Adding upstream version 0.23.93.upstream/0.23.93upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 214 insertions, 0 deletions

diff --git a/test/test_cpp_img.cpp b/test/test_cpp_img.cpp
new file mode 100644
index 0000000..3b57fcb
--- /dev/null
+++ b/test/test_cpp_img.cpp
@@ -0,0 +1,214 @@
+//------------------------------------------------------------------------
+//  Copyright 2007-2009 (c) Jeff Brown <spadix@users.sourceforge.net>
+//
+//  This file is part of the ZBar Bar Code Reader.
+//
+//  The ZBar Bar Code Reader is free software; you can redistribute it
+//  and/or modify it under the terms of the GNU Lesser Public License as
+//  published by the Free Software Foundation; either version 2.1 of
+//  the License, or (at your option) any later version.
+//
+//  The ZBar Bar Code Reader is distributed in the hope that it will be
+//  useful, but WITHOUT ANY WARRANTY; without even the implied warranty
+//  of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU Lesser Public License for more details.
+//
+//  You should have received a copy of the GNU Lesser Public License
+//  along with the ZBar Bar Code Reader; if not, write to the Free
+//  Software Foundation, Inc., 51 Franklin St, Fifth Floor,
+//  Boston, MA  02110-1301  USA
+//
+//  http://sourceforge.net/projects/zbar
+//------------------------------------------------------------------------
+
+// NB do not put anything before this header
+// it's here to check that we didn't omit any dependencies
+#include <zbar.h>
+
+#include <iomanip>
+#include <iostream>
+#include <sstream>
+#include "test_images.h"
+
+bool debug			     = false;
+bool verbose			     = false;
+int errors			     = 0;
+zbar::zbar_symbol_type_t expect_type = zbar::ZBAR_NONE;
+std::string expect_data;
+
+template <class T> inline std::string to_string(const T &t)
+{
+    std::stringstream ss;
+    ss << t;
+    return ss.str();
+}
+
+static inline int error(const std::string &msg)
+{
+    errors++;
+    std::cerr << "ERROR: " << msg << std::endl;
+    if (debug)
+	abort();
+    return (-1);
+}
+
+static inline int check_loc(const zbar::Image &img, const zbar::Symbol &sym)
+{
+    int n = 0;
+    int w = img.get_width();
+    int h = img.get_height();
+    for (zbar::Symbol::PointIterator p(sym.point_begin()); p != sym.point_end();
+	 ++p, n++) {
+	zbar::Symbol::Point q(*p);
+	if (q.x < 0 || q.x >= w || q.y < 0 || q.y >= h)
+	    error("location point out of range");
+    }
+    return (!n);
+}
+
+static inline int check_symbol(const zbar::Image &img, const zbar::Symbol &sym)
+{
+    zbar::zbar_symbol_type_t type(sym.get_type());
+    std::string data(sym.get_data());
+
+    bool pass = expect_type && type == expect_type && data == expect_data &&
+		sym.get_data_length() == expect_data.length() &&
+		sym.get_quality() > 4;
+    if (pass)
+	pass = !check_loc(img, sym);
+
+    if (verbose || !pass)
+	std::cerr << "decode Symbol: " << sym << std::endl;
+
+    if (!expect_type)
+	error("unexpected");
+    else if (!pass)
+	error(std::string("expected: ") +
+	      zbar::zbar_get_symbol_name(expect_type) + " " + expect_data);
+
+    expect_type = zbar::ZBAR_NONE;
+    expect_data = "";
+    return (!pass);
+}
+
+static inline int check_image(const zbar::Image &img)
+{
+    zbar::SymbolSet syms(img.get_symbols());
+    int setn = syms.get_size(), countn = 0;
+
+    int rc = 0;
+    for (zbar::SymbolIterator sym(syms.symbol_begin());
+	 sym != syms.symbol_end(); ++sym, ++countn)
+	rc |= check_symbol(img, *sym);
+
+    if (countn != setn)
+	rc |= error("SymbolSet size mismatch: exp=" + to_string(setn) +
+		    " act=" + to_string(countn));
+    return (rc);
+}
+
+static inline void expect(zbar::zbar_symbol_type_t type, std::string data)
+{
+    if (expect_type)
+	error(std::string("missing: ") + zbar_get_symbol_name(expect_type) +
+	      " " + expect_data);
+    expect_type = type;
+    expect_data = data;
+}
+
+class Handler : public zbar::Image::Handler
+{
+    void image_callback(zbar::Image &img);
+};
+
+void Handler::image_callback(zbar::Image &img)
+{
+    bool unexpected = !expect_type;
+    if (unexpected)
+	error("unexpected image callback");
+    check_image(img);
+}
+
+static inline int test_processor()
+{
+    // create processor w/no video and no window
+    zbar::Processor proc(debug, NULL);
+    Handler handler;
+    proc.set_handler(handler);
+    if (debug) {
+	proc.set_visible();
+	proc.user_wait();
+    }
+
+    // generate barcode test image
+    zbar::Image rgb3(0, 0, "RGB3");
+
+    // test cast to C image
+    if (test_image_ean13(rgb3))
+	error("failed to generate image");
+
+    // test decode
+    expect(zbar::ZBAR_EAN13, test_image_ean13_data);
+    proc.process_image(rgb3);
+    if (debug)
+	proc.user_wait();
+
+    expect(zbar::ZBAR_EAN13, test_image_ean13_data);
+    check_image(rgb3);
+
+    if (rgb3.get_format() != zbar_fourcc('R', 'G', 'B', '3'))
+	error("image format mismatch");
+
+    expect(zbar::ZBAR_NONE, "");
+    proc.set_config(zbar::ZBAR_EAN13, zbar::ZBAR_CFG_ENABLE, false);
+    proc.process_image(rgb3);
+    check_image(rgb3);
+    if (debug)
+	proc.user_wait();
+
+    proc.set_config("ean13.en");
+    expect(zbar::ZBAR_EAN13, test_image_ean13_data);
+    proc << rgb3;
+    expect(zbar::ZBAR_EAN13, test_image_ean13_data);
+    check_image(rgb3);
+    if (debug)
+	proc.user_wait();
+
+    {
+	zbar::Image grey(rgb3.convert(zbar_fourcc('G', 'R', 'E', 'Y')));
+	expect(zbar::ZBAR_EAN13, test_image_ean13_data);
+	proc << grey;
+
+	zbar::Image y800 = grey.convert("Y800");
+	expect(zbar::ZBAR_EAN13, test_image_ean13_data);
+	proc << y800;
+    }
+    if (debug)
+	// check image data retention
+	proc.user_wait();
+
+    expect(zbar::ZBAR_NONE, "");
+    return (0);
+}
+
+int main(int argc, char **argv)
+{
+    debug   = (argc > 1 && std::string(argv[1]) == "-d");
+    verbose = (debug || (argc > 1 && std::string(argv[1]) == "-v"));
+
+    if (test_processor()) {
+	error("ERROR: Processor test FAILED");
+	return (2);
+    }
+
+    if (test_image_check_cleanup())
+	error("cleanup failed");
+
+    if (errors) {
+	std::cout << "processor FAILED" << std::endl;
+	return (2);
+    } else {
+	std::cout << "processor PASSED." << std::endl;
+	return (0);
+    }
+}