Python2/PyMuPDF: mupdf-source/thirdparty/zint/backend/tests/testcommon.c comparison

comparison mupdf-source/thirdparty/zint/backend/tests/testcommon.c @ 2:b50eed0cc0ef upstream

ADD: MuPDF v1.26.7: the MuPDF source as downloaded by a default build of PyMuPDF 1.26.4. The directory name has changed: no version number in the expanded directory now.

author	Franz Glasner <fzglas.hg@dom66.de>
date	Mon, 15 Sep 2025 11:43:07 +0200
parents
children

comparison

equal deleted inserted replaced

-:1d09e1dec1d9
+:b50eed0cc0ef
+/*
+libzint - the open source barcode library
+Copyright (C) 2019-2024 Robin Stuart <rstuart114@gmail.com>
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions
+are met:
+1. Redistributions of source code must retain the above copyright
+notice, this list of conditions and the following disclaimer.
+2. Redistributions in binary form must reproduce the above copyright
+notice, this list of conditions and the following disclaimer in the
+documentation and/or other materials provided with the distribution.
+3. Neither the name of the project nor the names of its contributors
+may be used to endorse or promote products derived from this software
+without specific prior written permission.
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+SUCH DAMAGE.
+*/
+/*
+* Adapted from qrencode/tests/common.c
+* Copyright (C) 2006-2017 Kentaro Fukuchi <kentaro@fukuchi.org>
+*/
+/* Due to above: */
+/* SPDX-License-Identifier: LGPL-2.1+ */
+#ifdef _WIN32
+#include <windows.h>
+#include <direct.h>
+#include <wchar.h>
+#endif
+#ifndef ZINT_NO_PNG
+#include <png.h>
+#include <zlib.h>
+#include <setjmp.h>
+#endif
+#include <assert.h>
+#include <limits.h>
+#include <sys/stat.h>
+#include "testcommon.h"
+#include "../eci.h"
+#include "../output.h"
+static int testTests = 0;
+static int testFailed = 0;
+static int testSkipped = 0;
+static int testDataset = 0;
+static int testDatasetNum = 0;
+static int testDatasetTot = 0;
+int testAssertFailed = 0;
+int testAssertNum = 0;
+static int testAssertTot = 0;
+struct zint_symbol **testAssertPPSymbol = NULL;
+const char *testAssertFilename = "";
+static const char *testName = NULL;
+static const char *testFunc = NULL;
+/* Visual C++ 6 doesn't support variadic args to macros, so make do with functions, which have inferior behaviour,
+e.g. don't exit on failure, `assert_equal()` type-specific */
+#if (defined(_MSC_VER) && _MSC_VER <= 1200) || defined(ZINT_IS_C89) /* VC6 or C89 */
+#include <stdarg.h>
+void assert_zero(int exp, const char *fmt, ...) {
+testAssertNum++;
+if (exp != 0) {
+va_list args; testAssertFailed++; va_start(args, fmt); vprintf(fmt, args); va_end(args); testFinish();
+if (testAssertPPSymbol) { ZBarcode_Delete(*testAssertPPSymbol); testAssertPPSymbol = NULL; };
+}
+}
+void assert_nonzero(int exp, const char *fmt, ...) {
+testAssertNum++;
+if (exp == 0) {
+va_list args; testAssertFailed++; va_start(args, fmt); vprintf(fmt, args); va_end(args); testFinish();
+if (testAssertPPSymbol) { ZBarcode_Delete(*testAssertPPSymbol); testAssertPPSymbol = NULL; };
+}
+}
+void assert_null(const void *exp, const char *fmt, ...) {
+testAssertNum++;
+if (exp != NULL) {
+va_list args; testAssertFailed++; va_start(args, fmt); vprintf(fmt, args); va_end(args); testFinish();
+if (testAssertPPSymbol) { ZBarcode_Delete(*testAssertPPSymbol); testAssertPPSymbol = NULL; };
+}
+}
+void assert_nonnull(const void *exp, const char *fmt, ...) {
+testAssertNum++;
+if (exp == NULL) {
+va_list args; testAssertFailed++; va_start(args, fmt); vprintf(fmt, args); va_end(args); testFinish();
+if (testAssertPPSymbol) { ZBarcode_Delete(*testAssertPPSymbol); testAssertPPSymbol = NULL; };
+}
+}
+void assert_equal(int e1, int e2, const char *fmt, ...) {
+testAssertNum++;
+if (e1 != e2) {
+va_list args; testAssertFailed++; va_start(args, fmt); vprintf(fmt, args); va_end(args); testFinish();
+if (testAssertPPSymbol) { ZBarcode_Delete(*testAssertPPSymbol); testAssertPPSymbol = NULL; };
+}
+}
+void assert_equalu64(uint64_t e1, uint64_t e2, const char *fmt, ...) {
+testAssertNum++;
+if (e1 != e2) {
+va_list args; testAssertFailed++; va_start(args, fmt); vprintf(fmt, args); va_end(args); testFinish();
+if (testAssertPPSymbol) { ZBarcode_Delete(*testAssertPPSymbol); testAssertPPSymbol = NULL; };
+}
+}
+void assert_notequal(int e1, int e2, const char *fmt, ...) {
+testAssertNum++;
+if (e1 == e2) {
+va_list args; testAssertFailed++; va_start(args, fmt); vprintf(fmt, args); va_end(args); testFinish();
+if (testAssertPPSymbol) { ZBarcode_Delete(*testAssertPPSymbol); testAssertPPSymbol = NULL; };
+}
+}
+#endif
+#ifdef _WIN32
+#define utf8_to_wide(u, w) \
+{ \
+int lenW; /* Includes NUL terminator */ \
+if ((lenW = MultiByteToWideChar(CP_UTF8, MB_ERR_INVALID_CHARS, u, -1, NULL, 0)) == 0) return 0; \
+w = (wchar_t *) z_alloca(sizeof(wchar_t) * lenW); \
+if (MultiByteToWideChar(CP_UTF8, MB_ERR_INVALID_CHARS, u, -1, w, lenW) == 0) return 0; \
+}
+#endif
+/* Begin individual test function */
+void testStartReal(const char *func, const char *name, struct zint_symbol **pp_symbol) {
+testTests++;
+if (func && *func && name && *name && strcmp(func, name) == 0) {
+testName = "";
+} else {
+testName = name;
+}
+testFunc = func ? func : "";
+testDataset = 0;
+testDatasetNum = 0;
+testAssertFailed = 0;
+testAssertNum = 0;
+testAssertPPSymbol = pp_symbol;
+printf("_____%d: %s: %s...\n", testTests, testFunc, testName ? testName : "");
+}
+/* End individual test function */
+void testFinish(void) {
+testAssertTot += testAssertNum;
+testDatasetTot += testDatasetNum;
+fputs(testAssertFailed ? "*****" : ".....", stdout);
+if (testName && *testName) {
+printf("%d: %s: %s ", testTests, testFunc, testName);
+} else {
+printf("%d: %s: ", testTests, testFunc);
+}
+if (testAssertFailed) {
+printf("FAILED. (%d assertions failed)\n", testAssertFailed);
+testFailed++;
+} else if (testDataset) {
+if (testAssertNum) {
+printf("PASSED. (%d assertions, %d dataset items)\n", testAssertNum, testDatasetNum);
+} else {
+printf("EMPTY. (***No assertions executed***)\n");
+}
+} else {
+if (testAssertNum) {
+printf("PASSED. (%d assertions)\n", testAssertNum);
+} else {
+printf("EMPTY. (***No assertions executed***)\n");
+}
+}
+}
+/* Skip (and end) individual test function */
+void testSkip(const char *msg) {
+testSkipped++;
+testAssertTot += testAssertNum;
+testDatasetTot += testDatasetNum;
+fputs(testAssertFailed ? "*****" : ".....", stdout);
+if (testName && *testName) {
+printf("%d: %s: %s ", testTests, testFunc, testName);
+} else {
+printf("%d: %s: ", testTests, testFunc);
+}
+if (testAssertFailed) {
+printf("FAILED. (%d assertions failed)\n", testAssertFailed);
+testFailed++;
+} else if (testDataset) {
+printf("SKIPPED. %s. (%d assertions, %d dataset items)\n", msg, testAssertNum, testDatasetNum);
+} else {
+printf("SKIPPED. %s. (%d assertions)\n", msg, testAssertNum);
+}
+}
+/* End test program */
+void testReport(void) {
+if (testFailed && testSkipped) {
+printf("Total %d tests, %d skipped, %d **fails**.\n", testTests, testSkipped, testFailed);
+exit(-1);
+}
+if (testFailed) {
+printf("Total %d tests, %d **fails**.\n", testTests, testFailed);
+exit(-1);
+}
+if (testSkipped) {
+printf("Total %d tests, %d skipped.\n", testTests, testSkipped);
+} else if (testTests) {
+if (testAssertTot) {
+if (testDatasetTot) {
+printf("Total %d tests (%d assertions, %d dataset items), all passed.\n",
+testTests, testAssertTot, testDatasetTot);
+} else {
+printf("Total %d tests (%d assertions), all passed.\n", testTests, testAssertTot);
+}
+} else {
+printf("***No assertions executed in %d tests.***\n", testTests);
+}
+} else {
+fputs("***No tests run.***\n", stdout);
+}
+}
+/* Verifies that a string `src` (length <= 9) only uses digits. On success returns value in `p_val` */
+static int validate_int(const char src[], int *p_val) {
+int val = 0;
+int i;
+const int length = (int) strlen(src);
+if (length > 9) { /* Prevent overflow */
+return 0;
+}
+for (i = 0; i < length; i++) {
+if (src[i] < '0' || src[i] > '9') {
+return 0;
+}
+val *= 10;
+val += src[i] - '0';
+}
+*p_val = val;
+return 1;
+}
+/* Verifies that a string `src` only uses digits or a hyphen-separated range of digits.
+On success returns value in `p_val` and if present a range end value in `p_val_end` */
+static int validate_int_range(const char src[], int *p_val, int *p_val_end) {
+int val = 0;
+int val_end = -1;
+const int length = (int) strlen(src);
+int i, j;
+for (i = 0; i < length; i++) {
+if (src[i] < '0' || src[i] > '9') {
+if (src[i] != '-') {
+return 0;
+}
+val_end = 0;
+for (j = i + 1; j < length; j++) {
+if (src[j] < '0' || src[j] > '9') {
+return 0;
+}
+if (j - (i + 1) >= 9) { /* Prevent overflow */
+return 0;
+}
+val_end *= 10;
+val_end += src[j] - '0';
+}
+break;
+}
+if (i >= 9) { /* Prevent overflow */
+return 0;
+}
+val *= 10;
+val += src[i] - '0';
+}
+*p_val = val;
+*p_val_end = val_end;
+return 1;
+}
+/* Begin test program, parse args */
+void testRun(int argc, char *argv[], testFunction funcs[], int funcs_size) {
+int i, ran;
+char *optarg;
+char *func = NULL;
+char func_buf[256 + 5];
+char *func_not = NULL;
+char func_not_buf[256 + 5];
+char *func_match = NULL;
+int exclude_idx = 0;
+testCtx ctx;
+ctx.index = ctx.index_end = -1;
+for (i = 0; i < ZINT_TEST_CTX_EXC_MAX; i++) {
+ctx.exclude[i] = ctx.exclude_end[i] = -1;
+}
+ctx.generate = ctx.debug = 0;
+if (argc) {
+const char *filename;
+#ifdef _WIN32
+if ((filename = strrchr(argv[0], '\\')) == NULL) {
+filename = strrchr(argv[0], '/');
+}
+#else
+filename = strrchr(argv[0], '/');
+#endif
+if (filename) {
+testAssertFilename = filename + 1;
+} else {
+testAssertFilename = argv[0];
+}
+}
+for (i = 1; i < argc; i++) {
+if (strcmp(argv[i], "-d") == 0) {
+if (i + 1 == argc) {
+fprintf(stderr, "***testRun: -d debug value missing, ignoring***\n");
+} else {
+int d; /* Allow multiple debug flags, OR-ing */
+optarg = argv[++i];
+if (!validate_int(optarg, &d)) {
+fprintf(stderr, "***testRun: -d debug value invalid, ignoring***\n");
+} else {
+ctx.debug |= d;
+}
+}
+} else if (strcmp(argv[i], "-f") == 0) {
+if (i + 1 == argc) {
+fprintf(stderr, "***testRun: -f func value missing, ignoring***\n");
+} else {
+optarg = argv[++i];
+if (strlen(optarg) < 256) {
+if (strncmp(optarg, "test_", 5) == 0) {
+strcpy(func_buf, optarg);
+} else {
+strcpy(func_buf, "test_");
+strcat(func_buf, optarg);
+}
+func = func_buf;
+} else {
+fprintf(stderr, "***testRun: -f func value too long, ignoring***\n");
+func = NULL;
+}
+}
+} else if (strcmp(argv[i], "-n") == 0) {
+if (i + 1 == argc) {
+fprintf(stderr, "***testRun: -n func exclude value missing, ignoring***\n");
+} else {
+optarg = argv[++i];
+if (strlen(optarg) < 256) {
+if (strncmp(optarg, "test_", 5) == 0) {
+strcpy(func_not_buf, optarg);
+} else {
+strcpy(func_not_buf, "test_");
+strcat(func_not_buf, optarg);
+}
+func_not = func_not_buf;
+} else {
+fprintf(stderr, "***testRun: -p func exclude value too long, ignoring***\n");
+func_not = NULL;
+}
+}
+} else if (strcmp(argv[i], "-m") == 0) {
+if (i + 1 == argc) {
+fprintf(stderr, "***testRun: -m func match value missing, ignoring***\n");
+} else {
+func_match = argv[++i];
+}
+} else if (strcmp(argv[i], "-g") == 0) {
+ctx.generate = 1;
+} else if (strcmp(argv[i], "-i") == 0) {
+if (i + 1 == argc) {
+fprintf(stderr, "***testRun: -i index value missing, ignoring***\n");
+} else {
+optarg = argv[++i];
+if (!validate_int_range(optarg, &ctx.index, &ctx.index_end)) {
+fprintf(stderr, "***testRun: -i index value invalid, ignoring***\n");
+ctx.index = ctx.index_end = -1;
+}
+}
+} else if (strcmp(argv[i], "-x") == 0) {
+if (i + 1 == argc) {
+fprintf(stderr, "***testRun: -x exclude value missing, ignoring***\n");
+} else {
+optarg = argv[++i];
+if (exclude_idx + 1 == ZINT_TEST_CTX_EXC_MAX) {
+fprintf(stderr, "***testRun: too many -x exclude values, ignoring***\n");
+} else if (!validate_int_range(optarg, &ctx.exclude[exclude_idx], &ctx.exclude_end[exclude_idx])) {
+fprintf(stderr, "***testRun: -x exclude value invalid, ignoring***\n");
+ctx.exclude[exclude_idx] = ctx.exclude_end[exclude_idx] = -1;
+} else {
+exclude_idx++;
+}
+}
+} else {
+fprintf(stderr, "***testRun: unknown arg '%s', ignoring***\n", argv[i]);
+}
+}
+ran = 0;
+for (i = 0; i < funcs_size; i++) {
+if (func && strcmp(func, funcs[i].name) != 0) {
+continue;
+}
+if (func_not && strcmp(func_not, funcs[i].name) == 0) {
+continue;
+}
+if (func_match && strstr(funcs[i].name, func_match) == NULL) {
+continue;
+}
+(*funcs[i].func)(&ctx);
+ran++;
+}
+if (func && !ran) {
+fprintf(stderr, "***testRun: unknown -f func arg '%s'***\n", func);
+}
+if (func_match && !ran) {
+fprintf(stderr, "***testRun: no funcs matched -m arg '%s'***\n", func_match);
+}
+}
+/* Call in a dataset loop to determine if a datum should be tested according to -i & -x args */
+int testContinue(const testCtx *const p_ctx, const int i) {
+int j;
+testDataset = 1;
+if (p_ctx->index != -1) {
+if (p_ctx->index_end != -1) {
+if (i < p_ctx->index || (p_ctx->index_end && i > p_ctx->index_end)) {
+return 1;
+}
+} else if (i != p_ctx->index) {
+return 1;
+}
+}
+for (j = 0; j < ZINT_TEST_CTX_EXC_MAX && p_ctx->exclude[j] != -1; j++) {
+if (p_ctx->exclude_end[j] != -1) {
+if (i >= p_ctx->exclude[j] && (p_ctx->exclude_end[j] == 0 || i <= p_ctx->exclude_end[j])) {
+return 1;
+}
+} else if (i == p_ctx->exclude[j]) {
+return 1;
+}
+}
+if ((p_ctx->debug & ZINT_DEBUG_TEST_PRINT) && !(p_ctx->debug & ZINT_DEBUG_TEST_LESS_NOISY)) {
+printf("i:%d\n", i);
+fflush(stdout); /* For assertion failures */
+}
+testDatasetNum++;
+return 0;
+}
+/* Helper to set common symbol fields */
+int testUtilSetSymbol(struct zint_symbol *symbol, int symbology, int input_mode, int eci, int option_1, int option_2,
+int option_3, int output_options, const char *data, int length, int debug) {
+symbol->symbology = symbology;
+if (input_mode != -1) {
+symbol->input_mode = input_mode;
+}
+if (eci != -1) {
+symbol->eci = eci;
+}
+if (option_1 != -1) {
+symbol->option_1 = option_1;
+}
+if (option_2 != -1) {
+symbol->option_2 = option_2;
+}
+if (option_3 != -1) {
+symbol->option_3 = option_3;
+}
+if (output_options != -1) {
+symbol->output_options = output_options;
+}
+symbol->debug |= debug;
+if (length == -1) {
+length = (int) strlen(data);
+}
+return length;
+}
+/* Pretty name for symbology */
+const char *testUtilBarcodeName(int symbology) {
+static char name[32];
+if (ZBarcode_BarcodeName(symbology, name) == -1) {
+fprintf(stderr, "testUtilBarcodeName: data table out of sync (%d)\n", symbology);
+abort();
+}
+return name;
+}
+/* Pretty name for error/warning */
+const char *testUtilErrorName(int error_number) {
+struct item {
+const char *name;
+int define;
+int val;
+};
+static const struct item data[] = {
+{ "0", 0, 0 },
+{ "ZINT_WARN_HRT_TRUNCATED", ZINT_WARN_HRT_TRUNCATED, 1 },
+{ "ZINT_WARN_INVALID_OPTION", ZINT_WARN_INVALID_OPTION, 2 },
+{ "ZINT_WARN_USES_ECI", ZINT_WARN_USES_ECI, 3 },
+{ "ZINT_WARN_NONCOMPLIANT", ZINT_WARN_NONCOMPLIANT, 4 },
+{ "ZINT_ERROR_TOO_LONG", ZINT_ERROR_TOO_LONG, 5 },
+{ "ZINT_ERROR_INVALID_DATA", ZINT_ERROR_INVALID_DATA, 6 },
+{ "ZINT_ERROR_INVALID_CHECK", ZINT_ERROR_INVALID_CHECK, 7 },
+{ "ZINT_ERROR_INVALID_OPTION", ZINT_ERROR_INVALID_OPTION, 8 },
+{ "ZINT_ERROR_ENCODING_PROBLEM", ZINT_ERROR_ENCODING_PROBLEM, 9 },
+{ "ZINT_ERROR_FILE_ACCESS", ZINT_ERROR_FILE_ACCESS, 10 },
+{ "ZINT_ERROR_MEMORY", ZINT_ERROR_MEMORY, 11 },
+{ "ZINT_ERROR_FILE_WRITE", ZINT_ERROR_FILE_WRITE, 12 },
+{ "ZINT_ERROR_USES_ECI", ZINT_ERROR_USES_ECI, 13 },
+{ "ZINT_ERROR_NONCOMPLIANT", ZINT_ERROR_NONCOMPLIANT, 14 },
+{ "ZINT_ERROR_HRT_TRUNCATED", ZINT_ERROR_HRT_TRUNCATED, 15 },
+};
+const int data_size = ARRAY_SIZE(data);
+if (error_number < 0 || error_number >= data_size) {
+return "";
+}
+/* Self-check */
+if (data[error_number].val != error_number
+|| (data[error_number].define != -1 && data[error_number].define != error_number)) {
+fprintf(stderr, "testUtilErrorName: data table out of sync (%d)\n", error_number);
+abort();
+}
+return data[error_number].name;
+}
+/* Pretty name for input mode */
+const char *testUtilInputModeName(int input_mode) {
+static char buf[512];
+struct item {
+const char *name;
+int define;
+int val;
+};
+static const struct item data[] = {
+{ "ESCAPE_MODE", ESCAPE_MODE, 0x0008 },
+{ "GS1PARENS_MODE", GS1PARENS_MODE, 0x0010 },
+{ "GS1NOCHECK_MODE", GS1NOCHECK_MODE, 0x0020 },
+{ "HEIGHTPERROW_MODE", HEIGHTPERROW_MODE, 0x0040 },
+{ "FAST_MODE", FAST_MODE, 0x0080 },
+{ "EXTRA_ESCAPE_MODE", EXTRA_ESCAPE_MODE, 0x0100 },
+};
+const int data_size = ARRAY_SIZE(data);
+int set, i;
+if (input_mode < 0) {
+return "-1";
+}
+*buf = '\0';
+if ((input_mode & 0x7) & UNICODE_MODE) {
+strcpy(buf, "UNICODE_MODE");
+set = UNICODE_MODE;
+} else if ((input_mode & 0x7) & GS1_MODE) {
+strcpy(buf, "GS1_MODE");
+set = GS1_MODE;
+} else {
+set = DATA_MODE;
+}
+for (i = 0; i < data_size; i++) {
+if (data[i].define != data[i].val) { /* Self-check */
+fprintf(stderr, "testUtilInputModeName: data table out of sync (%d)\n", i);
+abort();
+}
+if (input_mode & data[i].define) {
+if (*buf) {
+strcat(buf, " | ");
+}
+strcat(buf, data[i].name);
+set |= data[i].define;
+}
+}
+if (set != input_mode) {
+fprintf(stderr, "testUtilInputModeName: unknown input mode %d (%d)\n", input_mode & set, input_mode);
+abort();
+}
+if (set == DATA_MODE && *buf == '\0') {
+strcpy(buf, "DATA_MODE");
+}
+return buf;
+}
+/* Pretty name for option 3 */
+const char *testUtilOption3Name(int symbology, int option_3) {
+static char buffer[64];
+const char *name = NULL;
+const unsigned int high_byte = option_3 == -1 ? 0 : (option_3 >> 8) & 0xFF;
+if (symbology == BARCODE_DATAMATRIX || symbology == BARCODE_HIBC_DM) {
+if ((option_3 & 0x7F) == DM_SQUARE) {
+if ((option_3 & DM_ISO_144) == DM_ISO_144) {
+name = "DM_SQUARE | DM_ISO_144";
+} else {
+name = "DM_SQUARE";
+}
+} else if ((option_3 & 0x7F) == DM_DMRE) {
+if ((option_3 & DM_ISO_144) == DM_ISO_144) {
+name = "DM_DMRE | DM_ISO_144";
+} else {
+name = "DM_DMRE";
+}
+} else if ((option_3 & DM_ISO_144) == DM_ISO_144) {
+name = "DM_ISO_144";
+} else {
+name = (option_3 & 0xFF) ? "-1" : "0";
+}
+} else if (symbology == BARCODE_QRCODE || symbology == BARCODE_HIBC_QR || symbology == BARCODE_MICROQR
+|| symbology == BARCODE_RMQR || symbology == BARCODE_GRIDMATRIX || symbology == BARCODE_HANXIN) {
+if ((option_3 & 0xFF) == ZINT_FULL_MULTIBYTE) {
+name = "ZINT_FULL_MULTIBYTE";
+} else {
+name = (option_3 & 0xFF) ? "-1" : "0";
+}
+} else if (symbology == BARCODE_ULTRA) {
+if ((option_3 & 0xFF) == ULTRA_COMPRESSION) {
+name = "ULTRA_COMPRESSION";
+} else {
+name = (option_3 & 0xFF) ? "-1" : "0";
+}
+} else {
+if (option_3 != -1 && (option_3 & 0xFF) != 0) {
+fprintf(stderr, "testUtilOption3Name: unknown value (%d)\n", option_3);
+abort();
+}
+name = (option_3 & 0xFF) ? "-1" : "0";
+}
+if (high_byte) {
+if (option_3 & 0xFF) {
+sprintf(buffer, "%s | (%d << 8)", name, (int) high_byte);
+} else {
+sprintf(buffer, "%d << 8", (int) high_byte);
+}
+return buffer;
+}
+return name;
+}
+/* Pretty name for output options */
+const char *testUtilOutputOptionsName(int output_options) {
+static char buf[512];
+struct item {
+const char *name;
+int define;
+int val;
+};
+static const struct item data[] = {
+{ "BARCODE_BIND_TOP", BARCODE_BIND_TOP, 1 },
+{ "BARCODE_BIND", BARCODE_BIND, 2 },
+{ "BARCODE_BOX", BARCODE_BOX, 4 },
+{ "BARCODE_STDOUT", BARCODE_STDOUT, 8 },
+{ "READER_INIT", READER_INIT, 16 },
+{ "SMALL_TEXT", SMALL_TEXT, 32 },
+{ "BOLD_TEXT", BOLD_TEXT, 64 },
+{ "CMYK_COLOUR", CMYK_COLOUR, 128 },
+{ "BARCODE_DOTTY_MODE", BARCODE_DOTTY_MODE, 256 },
+{ "GS1_GS_SEPARATOR", GS1_GS_SEPARATOR, 512 },
+{ "OUT_BUFFER_INTERMEDIATE", OUT_BUFFER_INTERMEDIATE, 1024 },
+{ "BARCODE_QUIET_ZONES", BARCODE_QUIET_ZONES, 2048 },
+{ "BARCODE_NO_QUIET_ZONES", BARCODE_NO_QUIET_ZONES, 4096 },
+{ "COMPLIANT_HEIGHT", COMPLIANT_HEIGHT, 0x2000 },
+{ "EANUPC_GUARD_WHITESPACE", EANUPC_GUARD_WHITESPACE, 0x4000 },
+{ "EMBED_VECTOR_FONT", EMBED_VECTOR_FONT, 0x8000 },
+};
+static int const data_size = ARRAY_SIZE(data);
+int set = 0;
+int i;
+if (output_options == -1) {
+return "-1";
+}
+if (output_options == 0) {
+return "0";
+}
+buf[0] = '\0';
+for (i = 0; i < data_size; i++) {
+if (data[i].define != data[i].val) { /* Self-check */
+fprintf(stderr, "testUtilOutputOptionsName: data table out of sync (%d)\n", i);
+abort();
+}
+if (output_options & data[i].define) {
+if (set) {
+strcat(buf, " | ");
+}
+strcat(buf, data[i].name);
+set |= data[i].define;
+}
+}
+if (set != output_options) {
+fprintf(stderr, "testUtilOutputOptionsName: unknown output option(s) %d (%d, 0x%X)\n",
+output_options & set, output_options, output_options);
+abort();
+}
+return buf;
+}
+/* Convert modules spanning 3 rows to DAFT equivalents */
+int testUtilDAFTConvert(const struct zint_symbol *symbol, char *buffer, const int buffer_size) {
+int i;
+char *b = buffer;
+*b = '\0';
+for (i = 0; i < symbol->width && b < buffer + buffer_size; i += 2) {
+if (module_is_set(symbol, 0, i) && module_is_set(symbol, 2, i)) {
+*b++ = 'F';
+} else if (module_is_set(symbol, 0, i)) {
+*b++ = 'A';
+} else if (module_is_set(symbol, 2, i)) {
+*b++ = 'D';
+} else {
+*b++ = 'T';
+}
+}
+if (b == buffer + buffer_size) {
+return 0;
+}
+*b = '\0';
+return 1;
+}
+/* Is string valid UTF-8? */
+int testUtilIsValidUTF8(const unsigned char str[], const int length) {
+int i;
+unsigned int codepoint, state = 0;
+for (i = 0; i < length; i++) {
+if (decode_utf8(&state, &codepoint, str[i]) == 12) {
+return 0;
+}
+}
+return state == 0;
+}
+/* Escape data for printing on generate test. Has a number of issues, e.g. need to use octal escapes */
+char *testUtilEscape(const char *buffer, const int length, char *escaped, const int escaped_size) {
+int i;
+unsigned char *b = (unsigned char *) buffer;
+unsigned char *be = b + length;
+int non_utf8 = !testUtilIsValidUTF8(b, length);
+int chunk = -1;
+for (i = 0; b < be && i < escaped_size; b++) {
+/* For VC6-compatibility need to split literal strings into <= 2K chunks */
+if (i > 2040 && i / 2040 != chunk && (*b & 0xC0) != 0x80) { /* Avoid UTF-8 continuations */
+chunk = i / 2040;
+if (i + 3 < escaped_size) {
+escaped[i] = '"';
+escaped[i + 1] = ' ';
+escaped[i + 2] = '"';
+}
+i += 3;
+}
+if (non_utf8 || *b < ' ' || *b == '\177') {
+if (i + 4 < escaped_size) {
+sprintf(escaped + i, "\\%.3o", *b);
+}
+i += 4;
+} else if (*b == '\\' || *b == '"') {
+if (i + 2 < escaped_size) {
+escaped[i] = '\\';
+escaped[i + 1] = *b;
+}
+i += 2;
+} else if (b + 1 < be && *b == 0xC2 && *(b + 1) < 0xA0) {
+if (i + 8 < escaped_size) {
+sprintf(escaped + i, "\\%.3o\\%.3o", *b, *(b + 1));
+}
+i += 8;
+b++;
+} else {
+escaped[i++] = *b;
+}
+}
+if (i >= escaped_size) {
+return NULL;
+}
+escaped[i] = '\0';
+return escaped;
+}
+/* Helper to read a CSV field */
+const char *testUtilReadCSVField(const char *buffer, char *field, const int field_size) {
+int i;
+const char *b = buffer;
+for (i = 0; i < field_size && *b && *b != ',' && *b != '\n' && *b != '\r'; i++) {
+field[i] = *b++;
+}
+if (i == field_size) {
+return NULL;
+}
+field[i] = '\0';
+return b;
+}
+/* Helper to fill a buffer (for "large" tests) - single-byte filler only */
+void testUtilStrCpyRepeat(char *buffer, const char *repeat, const int size) {
+int i;
+int len = (int) strlen(repeat);
+int max = size - len;
+if (len == 0) {
+fprintf(stderr, "testUtilStrCpyRepeat: only use non-empty, non-NUL single-byte data for repeat pattern\n");
+abort();
+}
+for (i = 0; i < max; i += len) {
+memcpy(buffer + i, repeat, len);
+}
+memcpy(buffer + i, repeat, size - i);
+buffer[size] = '\0';
+}
+/* Compare some "important" symbol fields for equality */
+int testUtilSymbolCmp(const struct zint_symbol *a, const struct zint_symbol *b) {
+int i, j;
+if (a->symbology != b->symbology) {
+return 1;
+}
+if (a->rows != b->rows) {
+return 2;
+}
+if (a->width != b->width) {
+return 3;
+}
+if (a->symbology == BARCODE_ULTRA) {
+for (i = 0; i < a->rows; i++) {
+for (j = 0; j < a->width; j++) {
+if (module_colour_is_set(a, i, j) != module_colour_is_set(b, i, j)) {
+return 4;
+}
+}
+}
+} else {
+for (i = 0; i < a->rows; i++) {
+for (j = 0; j < a->width; j++) {
+if (module_is_set(a, i, j) != module_is_set(b, i, j)) {
+return 4;
+}
+}
+}
+}
+if (a->height != b->height) {
+return 5;
+}
+if (a->whitespace_width != b->whitespace_width) {
+return 6;
+}
+if (a->whitespace_height != b->whitespace_height) {
+return 7;
+}
+if (a->border_width != b->border_width) {
+return 8;
+}
+if (a->output_options != b->output_options) {
+return 9;
+}
+if (a->scale != b->scale) {
+return 10;
+}
+return 0;
+}
+/* Copy a full vector structure (for later comparison) */
+struct zint_vector *testUtilVectorCpy(const struct zint_vector *in) {
+struct zint_vector_rect *rect;
+struct zint_vector_string *string;
+struct zint_vector_circle *circle;
+struct zint_vector_hexagon *hexagon;
+struct zint_vector_rect **outrect;
+struct zint_vector_string **outstring;
+struct zint_vector_circle **outcircle;
+struct zint_vector_hexagon **outhexagon;
+struct zint_vector *out = malloc(sizeof(struct zint_vector));
+assert(out != NULL);
+out->width = in->width;
+out->height = in->height;
+out->rectangles = NULL;
+out->strings = NULL;
+out->circles = NULL;
+out->hexagons = NULL;
+/* Copy rectangles */
+rect = in->rectangles;
+outrect = &(out->rectangles);
+while (rect) {
+*outrect = malloc(sizeof(struct zint_vector_rect));
+assert(*outrect != NULL);
+memcpy(*outrect, rect, sizeof(struct zint_vector_rect));
+outrect = &((*outrect)->next);
+rect = rect->next;
+}
+*outrect = NULL;
+/* Copy Strings */
+string = in->strings;
+outstring = &(out->strings);
+while (string) {
+*outstring = malloc(sizeof(struct zint_vector_string));
+assert(*outstring != NULL);
+memcpy(*outstring, string, sizeof(struct zint_vector_string));
+(*outstring)->text = malloc(ustrlen(string->text) + 1);
+assert((*outstring)->text != NULL);
+ustrcpy((*outstring)->text, string->text);
+outstring = &((*outstring)->next);
+string = string->next;
+}
+*outstring = NULL;
+/* Copy Circles */
+circle = in->circles;
+outcircle = &(out->circles);
+while (circle) {
+*outcircle = malloc(sizeof(struct zint_vector_circle));
+assert(*outcircle != NULL);
+memcpy(*outcircle, circle, sizeof(struct zint_vector_circle));
+outcircle = &((*outcircle)->next);
+circle = circle->next;
+}
+*outcircle = NULL;
+/* Copy Hexagons */
+hexagon = in->hexagons;
+outhexagon = &(out->hexagons);
+while (hexagon) {
+*outhexagon = malloc(sizeof(struct zint_vector_hexagon));
+assert(*outhexagon != NULL);
+memcpy(*outhexagon, hexagon, sizeof(struct zint_vector_hexagon));
+outhexagon = &((*outhexagon)->next);
+hexagon = hexagon->next;
+}
+*outhexagon = NULL;
+return out;
+}
+/* Compare 2 full vector structures */
+int testUtilVectorCmp(const struct zint_vector *a, const struct zint_vector *b) {
+struct zint_vector_rect *arect;
+struct zint_vector_string *astring;
+struct zint_vector_circle *acircle;
+struct zint_vector_hexagon *ahexagon;
+struct zint_vector_rect *brect;
+struct zint_vector_string *bstring;
+struct zint_vector_circle *bcircle;
+struct zint_vector_hexagon *bhexagon;
+if (a->width != b->width) {
+return 1;
+}
+if (a->height != b->height) {
+return 2;
+}
+/* Compare rectangles */
+arect = a->rectangles;
+brect = b->rectangles;
+while (arect) {
+if (!brect) {
+return 11;
+}
+if (arect->x != brect->x) {
+return 12;
+}
+if (arect->y != brect->y) {
+return 13;
+}
+if (arect->height != brect->height) {
+return 14;
+}
+if (arect->width != brect->width) {
+return 15;
+}
+if (arect->colour != brect->colour) {
+return 16;
+}
+arect = arect->next;
+brect = brect->next;
+}
+if (brect) {
+return 10;
+}
+/* Compare strings */
+astring = a->strings;
+bstring = b->strings;
+while (astring) {
+if (!bstring) {
+return 21;
+}
+if (astring->x != bstring->x) {
+return 22;
+}
+if (astring->y != bstring->y) {
+return 23;
+}
+if (astring->fsize != bstring->fsize) {
+return 24;
+}
+if (astring->width != bstring->width) {
+return 25;
+}
+if (astring->length != bstring->length) {
+return 26;
+}
+if (ustrlen(astring->text) != ustrlen(bstring->text)) {
+return 27;
+}
+if (strcmp((const char *) astring->text, (const char *) bstring->text) != 0) {
+return 28;
+}
+astring = astring->next;
+bstring = bstring->next;
+}
+if (bstring) {
+return 20;
+}
+/* Compare circles */
+acircle = a->circles;
+bcircle = b->circles;
+while (acircle) {
+if (!bcircle) {
+return 31;
+}
+if (acircle->x != bcircle->x) {
+return 32;
+}
+if (acircle->y != bcircle->y) {
+return 33;
+}
+if (acircle->diameter != bcircle->diameter) {
+return 34;
+}
+if (acircle->colour != bcircle->colour) {
+return 35;
+}
+acircle = acircle->next;
+bcircle = bcircle->next;
+}
+if (bcircle) {
+return 30;
+}
+/* Compare hexagons */
+ahexagon = a->hexagons;
+bhexagon = b->hexagons;
+while (ahexagon) {
+if (!bhexagon) {
+return 41;
+}
+if (ahexagon->x != bhexagon->x) {
+return 42;
+}
+if (ahexagon->y != bhexagon->y) {
+return 43;
+}
+if (ahexagon->diameter != bhexagon->diameter) {
+return 44;
+}
+ahexagon = ahexagon->next;
+bhexagon = bhexagon->next;
+}
+if (bhexagon) {
+return 40;
+}
+return 0;
+}
+/* Dump modules into buffer as '0'/'1' (or colours '0', '1', '2' etc if Ultra) */
+int testUtilModulesDump(const struct zint_symbol *symbol, char dump[], int dump_size) {
+int r, w;
+char *d = dump;
+char *de = dump + dump_size;
+for (r = 0; r < symbol->rows && d < de; r++) {
+if (symbol->symbology == BARCODE_ULTRA) {
+for (w = 0; w < symbol->width && d < de; w++) {
+*d++ = module_colour_is_set(symbol, r, w) + '0';
+}
+} else {
+for (w = 0; w < symbol->width && d < de; w++) {
+*d++ = module_is_set(symbol, r, w) + '0';
+}
+}
+}
+if (d == de) {
+return -1;
+}
+*d = '\0';
+return d - dump;
+}
+/* Print out module dump (for generate tests) */
+void testUtilModulesPrint(const struct zint_symbol *symbol, const char *prefix, const char *postfix) {
+int r;
+for (r = 0; r < symbol->rows; r++) {
+testUtilModulesPrintRow(symbol, r, prefix, postfix);
+}
+}
+/* Print out a single row of a module dump (for generate tests where rows all the same, to avoid large dumps of
+duplicate data) */
+void testUtilModulesPrintRow(const struct zint_symbol *symbol, int row, const char *prefix, const char *postfix) {
+int w;
+if (*prefix) {
+fputs(prefix, stdout);
+}
+putchar('"');
+if (symbol->symbology == BARCODE_ULTRA) {
+for (w = 0; w < symbol->width; w++) {
+putchar(module_colour_is_set(symbol, row, w) + '0');
+}
+} else {
+for (w = 0; w < symbol->width; w++) {
+putchar(module_is_set(symbol, row, w) + '0');
+}
+}
+putchar('"');
+if (*postfix) {
+fputs(postfix, stdout);
+}
+}
+/* Whether 2 module dumps are the same */
+int testUtilModulesCmp(const struct zint_symbol *symbol, const char *expected, int *width, int *row) {
+const char *e = expected;
+const char *ep = expected + strlen(expected);
+int r, w = 0;
+if (symbol->symbology == BARCODE_ULTRA) {
+for (r = 0; r < symbol->rows && e < ep; r++) {
+for (w = 0; w < symbol->width && e < ep; w++) {
+if (module_colour_is_set(symbol, r, w) + '0' != *e) {
+*row = r;
+*width = w;
+return 1 /*fail*/;
+}
+e++;
+}
+}
+} else {
+for (r = 0; r < symbol->rows && e < ep; r++) {
+for (w = 0; w < symbol->width && e < ep; w++) {
+if (module_is_set(symbol, r, w) + '0' != *e) {
+*row = r;
+*width = w;
+return 1 /*fail*/;
+}
+e++;
+}
+}
+}
+*row = r;
+*width = w;
+return e != ep || r != symbol->rows || w != symbol->width ? 1 /*fail*/ : 0 /*success*/;
+}
+/* Whether 2 module row dumps are the same */
+int testUtilModulesCmpRow(const struct zint_symbol *symbol, int row, const char *expected, int *width) {
+const char *e = expected;
+const char *ep = expected + strlen(expected);
+int w;
+if (symbol->symbology == BARCODE_ULTRA) {
+for (w = 0; w < symbol->width && e < ep; w++) {
+if (module_colour_is_set(symbol, row, w) + '0' != *e) {
+*width = w;
+return 1 /*fail*/;
+}
+e++;
+}
+} else {
+for (w = 0; w < symbol->width && e < ep; w++) {
+if (module_is_set(symbol, row, w) + '0' != *e) {
+*width = w;
+return 1 /*fail*/;
+}
+e++;
+}
+}
+*width = w;
+return e != ep || w != symbol->width ? 1 /*fail*/ : 0 /*success*/;
+}
+/* Dump an unsigned int array as hex */
+char *testUtilUIntArrayDump(unsigned int *array, int size, char *dump, int dump_size) {
+int i, cnt_len = 0;
+for (i = 0; i < size; i++) {
+cnt_len += sprintf(dump + cnt_len, "%X ", array[i]);
+if (cnt_len + 17 >= dump_size) {
+break;
+}
+}
+dump[cnt_len ? cnt_len - 1 : 0] = '\0';
+return dump;
+}
+/* Dump an unsigned char array as hex */
+char *testUtilUCharArrayDump(unsigned char *array, int size, char *dump, int dump_size) {
+int i, cnt_len = 0;
+for (i = 0; i < size; i++) {
+cnt_len += sprintf(dump + cnt_len, "%X ", array[i]);
+if (cnt_len + 3 >= dump_size) {
+break;
+}
+}
+dump[cnt_len ? cnt_len - 1 : 0] = '\0';
+return dump;
+}
+/* Dump a bitmap to stdout, for generate tests. Also useful for debugging */
+void testUtilBitmapPrint(const struct zint_symbol *symbol, const char *prefix, const char *postfix) {
+static const char colour[] = { '0', 'C', 'M', 'B', 'Y', 'G', 'R', '1' };
+int row, column, i, j;
+if (!prefix) {
+fputs("     ", stdout);
+for (column = 0; column < symbol->bitmap_width; column += 10) printf("%-3d       ", column);
+fputs("\n     ", stdout);
+for (column = 0; column < symbol->bitmap_width; column++) printf("%d", column % 10);
+putchar('\n');
+}
+for (row = 0; row < symbol->bitmap_height; row++) {
+if (!prefix) {
+printf("%3d: ", row);
+} else {
+if (*prefix) {
+fputs(prefix, stdout);
+}
+putchar('"');
+}
+for (column = 0; column < symbol->bitmap_width; column++) {
+if (symbol->output_options & OUT_BUFFER_INTERMEDIATE) {
+putchar(symbol->bitmap[(row * symbol->bitmap_width) + column]);
+} else {
+i = ((row * symbol->bitmap_width) + column) * 3;
+if ((symbol->bitmap[i] == 0 || symbol->bitmap[i] == 0xff)
+&& (symbol->bitmap[i + 1] == 0 || symbol->bitmap[i + 1] == 0xff)
+&& (symbol->bitmap[i + 2] == 0 || symbol->bitmap[i + 2] == 0xff)) {
+j = !symbol->bitmap[i] + !symbol->bitmap[i + 1] * 2 + !symbol->bitmap[i + 2] * 4;
+putchar(colour[j]);
+} else {
+printf("%02X%02X%02X", symbol->bitmap[i], symbol->bitmap[i + 1], symbol->bitmap[i + 2]);
+}
+}
+}
+if (!postfix) {
+putchar('\n');
+} else {
+putchar('"');
+if (*postfix) {
+fputs(postfix, stdout);
+}
+}
+}
+if (!postfix) {
+fputs("     ", stdout);
+for (column = 0; column < symbol->bitmap_width; column++) printf("%d", column % 10);
+fputs("\n     ", stdout);
+for (column = 0; column < symbol->bitmap_width; column += 10) printf("%-3d       ", column);
+putchar('\n');
+}
+fflush(stdout);
+}
+/* Compare a bitmap to a dump */
+int testUtilBitmapCmp(const struct zint_symbol *symbol, const char *expected, int *row, int *column) {
+static const char colour[] = { '0', 'C', 'M', 'B', 'Y', 'G', 'R', '1' };
+int r, c = -1, i, j;
+const char *e = expected;
+const char *ep = expected + strlen(expected);
+char buf[7];
+for (r = 0; r < symbol->bitmap_height; r++) {
+for (c = 0; c < symbol->bitmap_width; c++) {
+if (symbol->output_options & OUT_BUFFER_INTERMEDIATE) {
+if (*e != symbol->bitmap[(r * symbol->bitmap_width) + c]) {
+*row = r;
+*column = c;
+return 1 /*fail*/;
+}
+e++;
+} else {
+i = ((r * symbol->bitmap_width) + c) * 3;
+if ((symbol->bitmap[i] == 0 || symbol->bitmap[i] == 0xff)
+&& (symbol->bitmap[i + 1] == 0 || symbol->bitmap[i + 1] == 0xff)
+&& (symbol->bitmap[i + 2] == 0 || symbol->bitmap[i + 2] == 0xff)) {
+j = !symbol->bitmap[i] + !symbol->bitmap[i + 1] * 2 + !symbol->bitmap[i + 2] * 4;
+if (*e != colour[j]) {
+*row = r;
+*column = c;
+return 1 /*fail*/;
+}
+e++;
+} else {
+sprintf(buf, "%02X%02X%02X", symbol->bitmap[i], symbol->bitmap[i + 1], symbol->bitmap[i + 2]);
+if (strncmp(buf, e, 6) != 0) {
+*row = r;
+*column = c;
+return 1 /*fail*/;
+}
+e += 6;
+}
+}
+}
+}
+*row = r;
+*column = c;
+return e != ep || r != symbol->bitmap_height || c != symbol->bitmap_width ? 1 /*fail*/ : 0 /*success*/;
+}
+/* Dump vectors to stdout, for debugging */
+void testUtilVectorPrint(const struct zint_symbol *symbol) {
+struct zint_vector_rect *rect;
+struct zint_vector_hexagon *hex;
+struct zint_vector_circle *circ;
+struct zint_vector_string *str;
+if (symbol->vector == NULL) {
+fputs("symbol->vector NULL\n", stdout);
+} else {
+for (rect = symbol->vector->rectangles; rect; rect = rect->next) {
+printf("rect(x %.9g, y %.9g, width %.9g, height %.9g, colour %d)\n", rect->x, rect->y, rect->width,
+rect->height, rect->colour);
+}
+for (hex = symbol->vector->hexagons; hex; hex = hex->next) {
+printf("hex(x %.9g, y %.9g, diameter %.9g, rotation %d)\n", hex->x, hex->y, hex->diameter, hex->rotation);
+}
+for (circ = symbol->vector->circles; circ; circ = circ->next) {
+printf("circ(x %.9g, y %.9g, diameter %.9g, width %.9g, colour %d)\n", circ->x, circ->y, circ->diameter,
+circ->width, circ->colour);
+}
+for (str = symbol->vector->strings; str; str = str->next) {
+printf("str(x %.9g, y %.9g, fsize %.9g, width %.9g, length %d, rotation %d, halign %d, \"%s\")\n", str->x,
+str->y, str->fsize, str->width, str->length, str->rotation, str->halign, str->text);
+}
+}
+fflush(stdout);
+}
+/* Determine the location of test data relative to where the test is being run */
+int testUtilDataPath(char *buffer, int buffer_size, const char *subdir, const char *filename) {
+int subdir_len = subdir ? (int) strlen(subdir) : 0;
+int filename_len = filename ? (int) strlen(filename) : 0;
+char *s, *s2;
+int len;
+char *cmake_src_dir;
+#ifdef _WIN32
+int i;
+#endif
+if ((cmake_src_dir = getenv("CMAKE_CURRENT_SOURCE_DIR")) != NULL) {
+len = (int) strlen(cmake_src_dir);
+if (len <= 0 || len >= buffer_size) {
+fprintf(stderr, "testUtilDataPath: warning CMAKE_CURRENT_SOURCE_DIR len %d, ignoring\n", len);
+cmake_src_dir = NULL;
+} else {
+strcpy(buffer, cmake_src_dir);
+}
+}
+if (cmake_src_dir == NULL) {
+if (getcwd(buffer, buffer_size) == NULL) {
+fprintf(stderr, "testUtilDataPath: getcwd NULL buffer_size %d\n", buffer_size);
+return 0;
+}
+len = (int) strlen(buffer);
+if (len <= 0) {
+fprintf(stderr, "testUtilDataPath: strlen <= 0\n");
+return 0;
+}
+}
+#ifdef _WIN32
+for (i = 0; i < len; i++) {
+if (buffer[i] == '\\') {
+buffer[i] = '/';
+}
+}
+#endif
+if (buffer[len - 1] == '/') {
+buffer[len--] = '\0';
+}
+if (len == 0) {
+fprintf(stderr, "testUtilDataPath: len == 0\n");
+return 0;
+}
+if ((s = strstr(buffer, "/tests")) != NULL) {
+while ((s2 = strstr(s + 1, "/tests")) != NULL) { /* Find rightmost */
+s = s2;
+}
+*s = '\0';
+len = s - buffer;
+}
+if ((s = strstr(buffer, "/backend")) != NULL) {
+while ((s2 = strstr(s + 1, "/backend")) != NULL) { /* Find rightmost */
+s = s2;
+}
+*s = '\0';
+len = s - buffer;
+} else if ((s = strstr(buffer, "/frontend")) != NULL) {
+while ((s2 = strstr(s + 1, "/frontend")) != NULL) { /* Find rightmost */
+s = s2;
+}
+*s = '\0';
+len = s - buffer;
+}
+if (cmake_src_dir == NULL && (s = strrchr(buffer, '/')) != NULL) { /* Remove "build" dir */
+*s = '\0';
+len = s - buffer;
+}
+if (subdir_len) {
+if (*subdir != '/' && buffer[len - 1] != '/') {
+if (len + 1 >= buffer_size) {
+fprintf(stderr, "testUtilDataPath: subdir len (%d) + 1 >= buffer_size (%d)\n", len, buffer_size);
+return 0;
+}
+buffer[len++] = '/';
+buffer[len] = '\0';
+}
+if (len + subdir_len >= buffer_size) {
+fprintf(stderr, "testUtilDataPath: len (%d) + subdir_len (%d) >= buffer_size (%d)\n",
+len, subdir_len, buffer_size);
+return 0;
+}
+strcpy(buffer + len, subdir);
+len += subdir_len;
+}
+if (filename_len) {
+if (*filename != '/' && buffer[len - 1] != '/') {
+if (len + 1 >= buffer_size) {
+fprintf(stderr, "testUtilDataPath: filename len (%d) + 1 >= buffer_size (%d)\n", len, buffer_size);
+return 0;
+}
+buffer[len++] = '/';
+buffer[len] = '\0';
+}
+if (len + filename_len >= buffer_size) {
+fprintf(stderr, "testUtilDataPath: len (%d) + filename_len (%d) >= buffer_size (%d)\n",
+len, filename_len, buffer_size);
+return 0;
+}
+strcpy(buffer + len, filename);
+}
+return 1;
+}
+/* Open a file (Windows compatibility) */
+FILE *testUtilOpen(const char *filename, const char *mode) {
+#ifdef _WIN32
+FILE *fp = out_win_fopen(filename, mode);
+#else
+FILE *fp = fopen(filename, mode);
+#endif
+return fp;
+}
+/* Does file exist? */
+int testUtilExists(const char *filename) {
+FILE *fp = testUtilOpen(filename, "r");
+if (fp == NULL) {
+return 0;
+}
+fclose(fp);
+return 1;
+}
+/* Remove a file (Windows compatibility). Returns 0 if successful, non-zero if not */
+int testUtilRemove(const char *filename) {
+#ifdef _WIN32
+wchar_t *filenameW;
+utf8_to_wide(filename, filenameW);
+return DeleteFileW(filenameW) == 0; /* Non-zero on success */
+#else
+return remove(filename);
+#endif
+}
+/* Does directory exist? (Windows compatibility) */
+int testUtilDirExists(const char *dirname) {
+#ifdef _WIN32
+DWORD dwAttrib;
+wchar_t *dirnameW;
+utf8_to_wide(dirname, dirnameW);
+dwAttrib = GetFileAttributesW(dirnameW);
+return dwAttrib != (DWORD) -1 && (dwAttrib & FILE_ATTRIBUTE_DIRECTORY);
+#else
+return testUtilExists(dirname);
+#endif
+}
+/* Make a directory (Windows compatibility). Returns 0 if successful, non-zero if not */
+int testUtilMkDir(const char *dirname) {
+#ifdef _WIN32
+wchar_t *dirnameW;
+utf8_to_wide(dirname, dirnameW);
+return CreateDirectoryW(dirnameW, NULL) == 0;
+#else
+return mkdir(dirname, S_IRWXU);
+#endif
+}
+/* Remove a directory (Windows compatibility). Returns 0 if successful, non-zero if not */
+int testUtilRmDir(const char *dirname) {
+#ifdef _WIN32
+wchar_t *dirnameW;
+utf8_to_wide(dirname, dirnameW);
+return RemoveDirectoryW(dirnameW) == 0;
+#else
+return rmdir(dirname);
+#endif
+}
+/* Rename a file (Windows compatibility) */
+int testUtilRename(const char *oldpath, const char *newpath) {
+#ifdef _WIN32
+wchar_t *oldpathW, *newpathW;
+int ret = testUtilRemove(newpath);
+if (ret != 0) return ret;
+utf8_to_wide(oldpath, oldpathW);
+utf8_to_wide(newpath, newpathW);
+return _wrename(oldpathW, newpathW);
+#else
+return rename(oldpath, newpath);
+#endif
+}
+/* Create read-only file */
+int testUtilCreateROFile(const char *filename) {
+#ifdef _WIN32
+wchar_t *filenameW;
+#endif
+FILE *fp = testUtilOpen(filename, "w+");
+if (fp == NULL) {
+return 0;
+}
+if (fclose(fp) != 0) {
+return 0;
+}
+#ifdef _WIN32
+utf8_to_wide(filename, filenameW);
+if (SetFileAttributesW(filenameW, GetFileAttributesW(filenameW) | FILE_ATTRIBUTE_READONLY) == 0) {
+return 0;
+}
+#else
+if (chmod(filename, S_IRUSR | S_IRGRP | S_IROTH) != 0) {
+return 0;
+}
+#endif
+return 1;
+}
+/* Remove read-only file (Windows compatibility) */
+int testUtilRmROFile(const char *filename) {
+#ifdef _WIN32
+wchar_t *filenameW;
+utf8_to_wide(filename, filenameW);
+if (SetFileAttributesW(filenameW, GetFileAttributesW(filenameW) & ~FILE_ATTRIBUTE_READONLY) == 0) {
+return -1;
+}
+#endif
+return testUtilRemove(filename);
+}
+/* Read file into buffer */
+int testUtilReadFile(const char *filename, unsigned char *buffer, int buffer_size, int *p_size) {
+long fileLen;
+size_t n;
+size_t nRead = 0;
+FILE *fp = testUtilOpen(filename, "rb");
+if (!fp) {
+return 1;
+}
+if (fseek(fp, 0, SEEK_END) != 0) {
+(void) fclose(fp);
+return 2;
+}
+fileLen = ftell(fp);
+if (fileLen <= 0 || fileLen == LONG_MAX) {
+(void) fclose(fp);
+return 3;
+}
+if (fseek(fp, 0, SEEK_SET) != 0) {
+(void) fclose(fp);
+return 4;
+}
+if (fileLen > (long) buffer_size) {
+(void) fclose(fp);
+return 5;
+}
+do {
+n = fread(buffer + nRead, 1, fileLen - nRead, fp);
+if (ferror(fp)) {
+(void) fclose(fp);
+return 6;
+}
+nRead += n;
+} while (!feof(fp) && (0 < n) && ((long) nRead < fileLen));
+if (fclose(fp) != 0) {
+return 7;
+}
+*p_size = (int) nRead;
+return 0;
+}
+/* Write file from buffer */
+int testUtilWriteFile(const char *filename, const unsigned char *buffer, const int buffer_size, const char *mode) {
+FILE *fp = testUtilOpen(filename, mode);
+if (!fp) {
+return 1;
+}
+if (fwrite(buffer, 1, buffer_size, fp) == 0) {
+(void) fclose(fp);
+return 2;
+}
+if (fclose(fp) != 0) {
+return 3;
+}
+return 0;
+}
+/* Compare 2 PNG files */
+int testUtilCmpPngs(const char *png1, const char *png2) {
+int ret = -1;
+#ifdef ZINT_NO_PNG
+(void)png1; (void)png2;
+#else
+FILE *fp1;
+FILE *fp2;
+png_structp png_ptr1, png_ptr2;
+png_infop info_ptr1, info_ptr2;
+int width1, height1, width2, height2;
+png_byte color_type1, color_type2;
+png_byte bit_depth1, bit_depth2;
+png_bytep row1, row2;
+size_t rowbytes1, rowbytes2;
+int r;
+fp1 = testUtilOpen(png1, "rb");
+if (!fp1) {
+return 2;
+}
+fp2 = testUtilOpen(png2, "rb");
+if (!fp2) {
+fclose(fp1);
+return 3;
+}
+png_ptr1 = png_create_read_struct(PNG_LIBPNG_VER_STRING, (png_voidp) NULL, NULL, NULL);
+if (!png_ptr1) {
+fclose(fp1);
+fclose(fp2);
+return 4;
+}
+info_ptr1 = png_create_info_struct(png_ptr1);
+if (!info_ptr1) {
+png_destroy_read_struct(&png_ptr1, (png_infopp) NULL, (png_infopp) NULL);
+fclose(fp1);
+fclose(fp2);
+return 5;
+}
+png_ptr2 = png_create_read_struct(PNG_LIBPNG_VER_STRING, (png_voidp) NULL, NULL, NULL);
+if (!png_ptr2) {
+png_destroy_read_struct(&png_ptr1, &info_ptr1, (png_infopp) NULL);
+fclose(fp1);
+fclose(fp2);
+return 6;
+}
+info_ptr2 = png_create_info_struct(png_ptr2);
+if (!info_ptr2) {
+png_destroy_read_struct(&png_ptr1, &info_ptr1, (png_infopp) NULL);
+png_destroy_read_struct(&png_ptr2, (png_infopp) NULL, (png_infopp) NULL);
+fclose(fp1);
+fclose(fp2);
+return 7;
+}
+row1 = row2 = NULL; /* Init here to avoid potential "clobbered" warning */
+if (setjmp(png_jmpbuf(png_ptr1))) {
+if (row1) {
+free(row1);
+}
+if (row2) {
+free(row2);
+}
+png_destroy_read_struct(&png_ptr1, &info_ptr1, (png_infopp) NULL);
+png_destroy_read_struct(&png_ptr2, &info_ptr2, (png_infopp) NULL);
+fclose(fp1);
+fclose(fp2);
+return 8;
+}
+if (setjmp(png_jmpbuf(png_ptr2))) {
+if (row1) {
+free(row1);
+}
+if (row2) {
+free(row2);
+}
+png_destroy_read_struct(&png_ptr1, &info_ptr1, (png_infopp) NULL);
+png_destroy_read_struct(&png_ptr2, &info_ptr2, (png_infopp) NULL);
+fclose(fp1);
+fclose(fp2);
+return 9;
+}
+png_init_io(png_ptr1, fp1);
+png_init_io(png_ptr2, fp2);
+png_read_info(png_ptr1, info_ptr1);
+png_read_info(png_ptr2, info_ptr2);
+width1 = png_get_image_width(png_ptr1, info_ptr1);
+height1 = png_get_image_height(png_ptr1, info_ptr1);
+width2 = png_get_image_width(png_ptr2, info_ptr2);
+height2 = png_get_image_height(png_ptr2, info_ptr2);
+if (width1 != width2 || height1 != height2) {
+printf("width1 %d, width2 %d, height1 %d, height2 %d\n", width1, width2, height1, height2);
+png_destroy_read_struct(&png_ptr1, &info_ptr1, (png_infopp) NULL);
+png_destroy_read_struct(&png_ptr2, &info_ptr2, (png_infopp) NULL);
+fclose(fp1);
+fclose(fp2);
+return 10;
+}
+color_type1 = png_get_color_type(png_ptr1, info_ptr1);
+bit_depth1 = png_get_bit_depth(png_ptr1, info_ptr1);
+if (bit_depth1 == 16) {
+#if defined(PNG_LIBPNG_VER) && PNG_LIBPNG_VER >= 10504
+png_set_scale_16(png_ptr1);
+#else
+png_set_strip_16(png_ptr1);
+#endif
+}
+if (color_type1 == PNG_COLOR_TYPE_PALETTE) {
+png_set_palette_to_rgb(png_ptr1);
+}
+if (color_type1 == PNG_COLOR_TYPE_GRAY && bit_depth1 < 8) {
+png_set_expand_gray_1_2_4_to_8(png_ptr1);
+}
+if (png_get_valid(png_ptr1, info_ptr1, PNG_INFO_tRNS)) {
+png_set_tRNS_to_alpha(png_ptr1);
+}
+if (color_type1 == PNG_COLOR_TYPE_RGB || color_type1 == PNG_COLOR_TYPE_GRAY
+|| color_type1 == PNG_COLOR_TYPE_PALETTE) {
+png_set_filler(png_ptr1, 0xFF, PNG_FILLER_AFTER);
+}
+if (color_type1 == PNG_COLOR_TYPE_GRAY || color_type1 == PNG_COLOR_TYPE_GRAY_ALPHA) {
+png_set_gray_to_rgb(png_ptr1);
+}
+color_type2 = png_get_color_type(png_ptr2, info_ptr2);
+bit_depth2 = png_get_bit_depth(png_ptr2, info_ptr2);
+if (bit_depth2 == 16) {
+#if defined(PNG_LIBPNG_VER) && PNG_LIBPNG_VER >= 10504
+png_set_scale_16(png_ptr2);
+#else
+png_set_strip_16(png_ptr2);
+#endif
+}
+if (color_type2 == PNG_COLOR_TYPE_PALETTE) {
+png_set_palette_to_rgb(png_ptr2);
+}
+if (color_type2 == PNG_COLOR_TYPE_GRAY && bit_depth2 < 8) {
+png_set_expand_gray_1_2_4_to_8(png_ptr2);
+}
+if (png_get_valid(png_ptr2, info_ptr2, PNG_INFO_tRNS)) {
+png_set_tRNS_to_alpha(png_ptr2);
+}
+if (color_type2 == PNG_COLOR_TYPE_RGB || color_type2 == PNG_COLOR_TYPE_GRAY
+|| color_type2 == PNG_COLOR_TYPE_PALETTE) {
+png_set_filler(png_ptr2, 0xFF, PNG_FILLER_AFTER);
+}
+if (color_type2 == PNG_COLOR_TYPE_GRAY || color_type2 == PNG_COLOR_TYPE_GRAY_ALPHA) {
+png_set_gray_to_rgb(png_ptr2);
+}
+png_read_update_info(png_ptr1, info_ptr1);
+png_read_update_info(png_ptr2, info_ptr2);
+rowbytes1 = png_get_rowbytes(png_ptr1, info_ptr1);
+rowbytes2 = png_get_rowbytes(png_ptr2, info_ptr2);
+if (rowbytes1 != rowbytes2) {
+png_destroy_read_struct(&png_ptr1, &info_ptr1, (png_infopp)NULL);
+png_destroy_read_struct(&png_ptr2, &info_ptr2, (png_infopp)NULL);
+fclose(fp1);
+fclose(fp2);
+return 11;
+}
+row1 = malloc(rowbytes1);
+if (!row1) {
+png_destroy_read_struct(&png_ptr1, &info_ptr1, (png_infopp)NULL);
+png_destroy_read_struct(&png_ptr2, &info_ptr2, (png_infopp)NULL);
+fclose(fp1);
+fclose(fp2);
+return 12;
+}
+row2 = malloc(rowbytes2);
+if (!row2) {
+free(row1);
+png_destroy_read_struct(&png_ptr1, &info_ptr1, (png_infopp)NULL);
+png_destroy_read_struct(&png_ptr2, &info_ptr2, (png_infopp)NULL);
+fclose(fp1);
+fclose(fp2);
+return 13;
+}
+for (r = 0; r < height1; r++) {
+png_read_row(png_ptr1, row1, NULL);
+png_read_row(png_ptr2, row2, NULL);
+if (memcmp(row1, row2, rowbytes1) != 0) {
+break;
+}
+}
+ret = r == height1 ? 0 : 20;
+free(row1);
+free(row2);
+png_destroy_read_struct(&png_ptr1, &info_ptr1, (png_infopp)NULL);
+png_destroy_read_struct(&png_ptr2, &info_ptr2, (png_infopp)NULL);
+fclose(fp1);
+fclose(fp2);
+#endif
+return ret;
+}
+/* Compare 2 TXT files */
+int testUtilCmpTxts(const char *txt1, const char *txt2) {
+int ret = -1;
+FILE *fp1;
+FILE *fp2;
+char buf1[1024];
+char buf2[1024];
+size_t len1 = 0, len2 = 0;
+fp1 = testUtilOpen(txt1, "r");
+if (!fp1) {
+return 2;
+}
+fp2 = testUtilOpen(txt2, "r");
+if (!fp2) {
+fclose(fp1);
+return 3;
+}
+while (1) {
+if (fgets(buf1, sizeof(buf1), fp1) == NULL) {
+if (fgets(buf2, sizeof(buf2), fp2) != NULL) {
+ret = 4;
+break;
+}
+break;
+}
+if (fgets(buf2, sizeof(buf2), fp2) == NULL) {
+ret = 5;
+break;
+}
+len1 = strlen(buf1);
+len2 = strlen(buf2);
+if (len1 != len2) {
+ret = 6;
+break;
+}
+if (strcmp(buf1, buf2) != 0) {
+ret = 7;
+break;
+}
+}
+if (ret == -1) {
+ret = feof(fp1) && feof(fp2) ? 0 : 20;
+}
+fclose(fp1);
+fclose(fp2);
+return ret;
+}
+/* Compare 2 binary files */
+int testUtilCmpBins(const char *bin1, const char *bin2) {
+int ret = -1;
+FILE *fp1;
+FILE *fp2;
+char buf1[1024];
+char buf2[1024];
+size_t len1 = 0, len2 = 0;
+fp1 = testUtilOpen(bin1, "rb");
+if (!fp1) {
+return 2;
+}
+fp2 = testUtilOpen(bin2, "rb");
+if (!fp2) {
+fclose(fp1);
+return 3;
+}
+do {
+len1 = fread(buf1, 1, sizeof(buf1), fp1);
+len2 = fread(buf2, 1, sizeof(buf2), fp2);
+if (ferror(fp1) || ferror(fp2)) {
+ret = 4;
+break;
+}
+if (len1 != len2) {
+ret = 6;
+break;
+}
+if (memcmp(buf1, buf2, len1) != 0) {
+ret = 7;
+break;
+}
+} while (!feof(fp1) && !feof(fp2));
+if (ret == -1) {
+ret = feof(fp1) && feof(fp2) ? 0 : 20;
+}
+fclose(fp1);
+fclose(fp2);
+return ret;
+}
+/* Compare 2 SVG files */
+int testUtilCmpSvgs(const char *svg1, const char *svg2) {
+return testUtilCmpTxts(svg1, svg2);
+}
+/* Compare 2 EPS files */
+int testUtilCmpEpss(const char *eps1, const char *eps2) {
+int ret = -1;
+FILE *fp1;
+FILE *fp2;
+char buf1[1024];
+char buf2[1024];
+size_t len1 = 0, len2 = 0;
+static char first_line[] = "%!PS-Adobe-3.0 EPSF-3.0\n";
+static char second_line_start[] = "%%Creator: Zint ";
+fp1 = testUtilOpen(eps1, "r");
+if (!fp1) {
+return 2;
+}
+fp2 = testUtilOpen(eps2, "r");
+if (!fp2) {
+fclose(fp1);
+return 3;
+}
+/* Preprocess the 1st 2 lines to avoid comparing changeable Zint version in 2nd line */
+if (fgets(buf1, sizeof(buf1), fp1) == NULL || strcmp(buf1, first_line) != 0
+|| fgets(buf2, sizeof(buf2), fp2) == NULL || strcmp(buf2, first_line) != 0) {
+ret = 10;
+} else if (fgets(buf1, sizeof(buf1), fp1) == NULL
+|| strncmp(buf1, second_line_start, sizeof(second_line_start) - 1) != 0
+|| fgets(buf2, sizeof(buf2), fp2) == NULL
+|| strncmp(buf2, second_line_start, sizeof(second_line_start) - 1) != 0) {
+ret = 11;
+}
+if (ret == -1) {
+while (1) {
+if (fgets(buf1, sizeof(buf1), fp1) == NULL) {
+if (fgets(buf2, sizeof(buf2), fp2) != NULL) {
+ret = 4;
+break;
+}
+break;
+}
+if (fgets(buf2, sizeof(buf2), fp2) == NULL) {
+ret = 5;
+break;
+}
+len1 = strlen(buf1);
+len2 = strlen(buf2);
+if (len1 != len2) {
+ret = 6;
+break;
+}
+if (strcmp(buf1, buf2) != 0) {
+ret = 7;
+break;
+}
+}
+if (ret == -1) {
+ret = feof(fp1) && feof(fp2) ? 0 : 20;
+}
+}
+fclose(fp1);
+fclose(fp2);
+return ret;
+}
+#ifdef _WIN32
+#define DEV_NULL "> NUL"
+#define DEV_NULL_STDERR "> NUL 2>&1"
+#else
+#define DEV_NULL "> /dev/null"
+#define DEV_NULL_STDERR "> /dev/null 2>&1"
+#endif
+/* Whether ImageMagick's identify utility available on system */
+const char *testUtilHaveIdentify(void) {
+static const char *progs[2] = { "magick identify", "identify" };
+if (system("magick -version " DEV_NULL_STDERR) == 0) {
+return progs[0];
+}
+if (system("identify -version " DEV_NULL_STDERR) == 0) {
+return progs[1];
+}
+return NULL;
+}
+/* Check raster files */
+int testUtilVerifyIdentify(const char *const prog, const char *filename, int debug) {
+char cmd[512 + 128];
+if (strlen(filename) > 512) {
+return -1;
+}
+/* Verbose option does a more thorough check */
+if (debug & ZINT_DEBUG_TEST_PRINT) {
+/* Verbose very noisy though so for quick check just return default output */
+if (debug & ZINT_DEBUG_TEST_LESS_NOISY) {
+sprintf(cmd, "%s %s", prog, filename);
+} else {
+sprintf(cmd, "%s -verbose %s", prog, filename);
+}
+} else {
+sprintf(cmd, "%s -verbose %s " DEV_NULL, prog, filename);
+}
+return system(cmd);
+}
+/* Whether Libre Office available on system */
+int testUtilHaveLibreOffice(void) {
+return system("libreoffice --version " DEV_NULL) == 0;
+}
+/* Check SVG files, very hacky to evoke. Will fail if Libre package that is not LibreOffice Draw is running */
+int testUtilVerifyLibreOffice(const char *filename, int debug) {
+char cmd[512 + 128];
+char svg[512];
+char *slash, *dot;
+char buf[16384];
+char *b = buf, *be = buf + sizeof(buf) - 1;
+FILE *fp;
+int len;
+/* Hack to read SVG produced by LibreOffice and search for 'x="-32767"' which indicates it didn't load barcode
+file */
+if (strlen(filename) > 512) {
+return -1;
+}
+slash = strrchr(filename, '/');
+if (slash) {
+strcpy(svg, slash + 1);
+} else {
+strcpy(svg, filename);
+}
+dot = strrchr(svg, '.');
+if (dot) {
+strcpy(dot, ".svg");
+} else {
+strcat(svg, ".svg");
+}
+if (strcmp(svg, filename) == 0) {
+fprintf(stderr, "testUtilVerifyLibreOffice: input '%s' same as svg '%s'\n", filename, svg);
+return -1;
+}
+sprintf(cmd, "libreoffice --convert-to svg %s " DEV_NULL_STDERR, filename);
+if (debug & ZINT_DEBUG_TEST_PRINT) {
+printf("%s\n", cmd);
+}
+if (system(cmd) != 0) {
+fprintf(stderr, "testUtilVerifyLibreOffice: failed to run '%s'\n", cmd);
+return -1;
+}
+fp = testUtilOpen(svg, "r");
+if (!fp) {
+fprintf(stderr, "testUtilVerifyLibreOffice: failed to open '%s' (%s)\n", svg, cmd);
+return -1;
+}
+while (!feof(fp) && b < be) {
+if (fgets(b, be - b, fp) == NULL) {
+fprintf(stderr, "testUtilVerifyLibreOffice: failed to get line from '%s' (%s)\n", svg, cmd);
+fclose(fp);
+return -1;
+}
+len = (int) strlen(b);
+if (len == 0) {
+break;
+}
+b += len;
+}
+*b = '\0';
+fclose(fp);
+if (strlen(buf) < 1024) {
+fprintf(stderr, "testUtilVerifyLibreOffice: failed to get much input from '%s' (%s)\n", svg, cmd);
+return -1;
+}
+if (strstr(buf, "x=\"-32767\"") != NULL) {
+return -1;
+}
+testUtilRemove(svg);
+return 0;
+}
+#ifdef _WIN32
+#define GS_FILENAME "gswin64c"
+#else
+#define GS_FILENAME "gs"
+#endif
+/* Whether Ghostscript available on system */
+int testUtilHaveGhostscript(void) {
+return system(GS_FILENAME " -v " DEV_NULL) == 0;
+}
+/* Check EPS files */
+int testUtilVerifyGhostscript(const char *filename, int debug) {
+char cmd[512 + 128];
+if (strlen(filename) > 512) {
+return -1;
+}
+if (debug & ZINT_DEBUG_TEST_PRINT) {
+/* Prints nothing of interest with or without -q unless bad */
+sprintf(cmd, GS_FILENAME " -dNOPAUSE -dBATCH -dNODISPLAY -q %s", filename);
+printf("%s\n", cmd);
+} else {
+sprintf(cmd, GS_FILENAME " -dNOPAUSE -dBATCH -dNODISPLAY -q %s", filename);
+}
+return system(cmd);
+}
+/* Whether vnu validator available on system. v.Nu https://github.com/validator/validator
+Needs "$INSTALL_DIR/vnu-runtime-image/bin" in PATH */
+int testUtilHaveVnu(void) {
+return system("vnu --version " DEV_NULL_STDERR) == 0;
+}
+/* Check SVG files, very full but very slow */
+int testUtilVerifyVnu(const char *filename, int debug) {
+char buf[512 + 128];
+if (strlen(filename) > 512) {
+return -1;
+}
+if (debug & ZINT_DEBUG_TEST_PRINT) {
+sprintf(buf, "vnu --svg --verbose %s", filename);
+printf("%s\n", buf);
+} else {
+sprintf(buf, "vnu --svg %s", filename);
+}
+return system(buf);
+}
+/* Whether tiffinfo available on system. Requires libtiff 4.2.0 http://www.libtiff.org to be installed */
+int testUtilHaveTiffInfo(void) {
+return system("tiffinfo -h " DEV_NULL) == 0;
+}
+/* Check TIF files */
+int testUtilVerifyTiffInfo(const char *filename, int debug) {
+char cmd[512 + 128];
+if (strlen(filename) > 512) {
+return -1;
+}
+if (debug & ZINT_DEBUG_TEST_PRINT) {
+sprintf(cmd, "tiffinfo -D %s", filename);
+} else {
+sprintf(cmd, "tiffinfo -D %s " DEV_NULL_STDERR, filename);
+}
+return system(cmd);
+}
+/* Map Zint symbology to BWIPP routine */
+static const char *testUtilBwippName(int index, const struct zint_symbol *symbol, int option_1, int option_2,
+int option_3, int debug, int *linear_row_height, int *gs1_cvt) {
+struct item {
+const char *name;
+int define;
+int val;
+int can_option_1;
+int can_option_2;
+int can_option_3;
+int linear_row_height;
+int gs1_cvt;
+};
+static const struct item data[] = {
+{ "", -1, 0, 0, 0, 0, 0, 0, },
+{ "code11", BARCODE_CODE11, 1, 0, 1, 0, 0, 0, },
+{ "matrix2of5", BARCODE_C25STANDARD, 2, 0, 1, 0, 0, 0, },
+{ "interleaved2of5", BARCODE_C25INTER, 3, 0, 1, 0, 0, 0, },
+{ "iata2of5", BARCODE_C25IATA, 4, 0, 1, 0, 0, 0, },
+{ "", -1, 5, 0, 0, 0, 0, 0, },
+{ "datalogic2of5", BARCODE_C25LOGIC, 6, 0, 1, 0, 0, 0, },
+{ "industrial2of5", BARCODE_C25IND, 7, 0, 1, 0, 0, 0, },
+{ "code39", BARCODE_CODE39, 8, 0, 1, 0, 0, 0, },
+{ "code39ext", BARCODE_EXCODE39, 9, 0, 1, 0, 0, 0, },
+{ "", -1, 10, 0, 0, 0, 0, 0, },
+{ "", -1, 11, 0, 0, 0, 0, 0, },
+{ "", -1, 12, 0, 0, 0, 0, 0, },
+{ "ean13", BARCODE_EANX, 13, 0, 1, 0, 0, 1 /*gs1_cvt*/, },
+{ "ean13", BARCODE_EANX_CHK, 14, 0, 1, 0, 0, 1, },
+{ "", -1, 15, 0, 0, 0, 0, 0, },
+{ "gs1-128", BARCODE_GS1_128, 16, 0, 0, 0, 0, 1 /*gs1_cvt*/, },
+{ "", -1, 17, 0, 0, 0, 0, 0, },
+{ "rationalizedCodabar", BARCODE_CODABAR, 18, 0, 1, 0, 0, 0, },
+{ "", -1, 19, 0, 0, 0, 0, 0, },
+{ "code128", BARCODE_CODE128, 20, 0, 0, 0, 0, 0, },
+{ "leitcode", BARCODE_DPLEIT, 21, 0, 0, 0, 0, 0, },
+{ "identcode", BARCODE_DPIDENT, 22, 0, 0, 0, 0, 0, },
+{ "code16k", BARCODE_CODE16K, 23, 1, 0, 0, 8 /*linear_row_height*/, 0, },
+{ "code49", BARCODE_CODE49, 24, 1, 0, 0, 8 /*linear_row_height*/, 0, },
+{ "code93ext", BARCODE_CODE93, 25, 0, 0, 0, 0, 0, },
+{ "", -1, 26, 0, 0, 0, 0, 0, },
+{ "", -1, 27, 0, 0, 0, 0, 0, },
+{ "flattermarken", BARCODE_FLAT, 28, 0, 0, 0, 0, 0, },
+{ "databaromni", BARCODE_DBAR_OMN, 29, 0, 0, 0, 0, 1 /*gs1_cvt*/, },
+{ "databarlimited", BARCODE_DBAR_LTD, 30, 0, 0, 0, 0, 1, },
+{ "databarexpanded", BARCODE_DBAR_EXP, 31, 0, 1, 0, 1 /*linear_row_height*/, 1, },
+{ "telepen", BARCODE_TELEPEN, 32, 0, 0, 0, 0, 0, },
+{ "", -1, 33, 0, 0, 0, 0, 0, },
+{ "upca", BARCODE_UPCA, 34, 0, 1, 0, 0, 1 /*gs1_cvt*/, },
+{ "upca", BARCODE_UPCA_CHK, 35, 0, 1, 0, 0, 1, },
+{ "", -1, 36, 0, 0, 0, 0, 0, },
+{ "upce", BARCODE_UPCE, 37, 0, 1, 0, 0, 1 /*gs1_cvt*/, },
+{ "upce", BARCODE_UPCE_CHK, 38, 0, 1, 0, 0, 1, },
+{ "", -1, 39, 0, 0, 0, 0, 0, },
+{ "postnet", BARCODE_POSTNET, 40, 0, 0, 0, 0, 0, },
+{ "", -1, 41, 0, 0, 0, 0, 0, },
+{ "", -1, 42, 0, 0, 0, 0, 0, },
+{ "", -1, 43, 0, 0, 0, 0, 0, },
+{ "", -1, 44, 0, 0, 0, 0, 0, },
+{ "", -1, 45, 0, 0, 0, 0, 0, },
+{ "", -1, 46, 0, 0, 0, 0, 0, },
+{ "msi", BARCODE_MSI_PLESSEY, 47, 0, 1, 0, 0, 0, },
+{ "", -1, 48, 0, 0, 0, 0, 0, },
+{ "symbol", BARCODE_FIM, 49, 0, 0, 0, 0, 0, },
+{ "code39", BARCODE_LOGMARS, 50, 0, 1, 0, 0, 0, },
+{ "pharmacode", BARCODE_PHARMA, 51, 0, 0, 0, 1 /*linear_row_height*/, 0, },
+{ "pzn", BARCODE_PZN, 52, 0, 1, 0, 0, 0, },
+{ "pharmacode2", BARCODE_PHARMA_TWO, 53, 0, 0, 0, 0, 0, },
+{ "", BARCODE_CEPNET, 54, 0, 0, 0, 0, 0, },
+{ "pdf417", BARCODE_PDF417, 55, 1, 1, 1, 0, 0, },
+{ "pdf417compact", BARCODE_PDF417COMP, 56, 1, 1, 1, 0, 0, },
+{ "maxicode", BARCODE_MAXICODE, 57, 1, 1, 0, 0, 0, },
+{ "qrcode", BARCODE_QRCODE, 58, 1, 1, 1, 0, 0, },
+{ "", -1, 59, 0, 0, 0, 0, 0, },
+{ "code128", BARCODE_CODE128AB, 60, 0, 0, 0, 0, 0, },
+{ "", -1, 61, 0, 0, 0, 0, 0, },
+{ "", -1, 62, 0, 0, 0, 0, 0, },
+{ "auspost", BARCODE_AUSPOST, 63, 0, 0, 0, 0, 0, },
+{ "", -1, 64, 0, 0, 0, 0, 0, },
+{ "", -1, 65, 0, 0, 0, 0, 0, },
+{ "", BARCODE_AUSREPLY, 66, 0, 0, 0, 0, 0, },
+{ "", BARCODE_AUSROUTE, 67, 0, 0, 0, 0, 0, },
+{ "", BARCODE_AUSREDIRECT, 68, 0, 0, 0, 0, 0, },
+{ "isbn", BARCODE_ISBNX, 69, 0, 1, 0, 0, 1 /*gs1_cvt*/, },
+{ "royalmail", BARCODE_RM4SCC, 70, 0, 0, 0, 0, 0, },
+{ "datamatrix", BARCODE_DATAMATRIX, 71, 0, 1, 1, 1, 0, },
+{ "ean14", BARCODE_EAN14, 72, 0, 0, 0, 0, 1 /*gs1_cvt*/, },
+{ "code39", BARCODE_VIN, 73, 0, 0, 0, 0, 0, },
+{ "codablockf", BARCODE_CODABLOCKF, 74, 1, 1, 0, 10 /*linear_row_height*/, 0, },
+{ "sscc18", BARCODE_NVE18, 75, 0, 0, 0, 0, 1 /*gs1_cvt*/, },
+{ "japanpost", BARCODE_JAPANPOST, 76, 0, 0, 0, 0, 0, },
+{ "", BARCODE_KOREAPOST, 77, 0, 0, 0, 0, 0, },
+{ "", -1, 78, 0, 0, 0, 0, 0, },
+{ "databarstacked", BARCODE_DBAR_STK, 79, 0, 0, 0, 0, 1 /*gs1_cvt*/, },
+{ "databarstackedomni", BARCODE_DBAR_OMNSTK, 80, 0, 0, 0, 33 /*linear_row_height*/, 1, },
+{ "databarexpandedstacked", BARCODE_DBAR_EXPSTK, 81, 0, 1, 0, 34 /*linear_row_height*/, 1, },
+{ "planet", BARCODE_PLANET, 82, 0, 0, 0, 0, 0, },
+{ "", -1, 83, 0, 0, 0, 0, 0, },
+{ "micropdf417", BARCODE_MICROPDF417, 84, 0, 1, 0, 0, 0, },
+{ "onecode", BARCODE_USPS_IMAIL, 85, 0, 0, 0, 0, 0, },
+{ "plessey", BARCODE_PLESSEY, 86, 0, 0, 0, 0, 0, },
+{ "telepennumeric", BARCODE_TELEPEN_NUM, 87, 0, 0, 0, 0, 0, },
+{ "", -1, 88, 0, 0, 0, 0, 0, },
+{ "itf14", BARCODE_ITF14, 89, 0, 0, 0, 0, 0, },
+{ "kix", BARCODE_KIX, 90, 0, 0, 0, 0, 0, },
+{ "", -1, 91, 0, 0, 0, 0, 0, },
+{ "azteccode", BARCODE_AZTEC, 92, 1, 1, 0, 0, 0, },
+{ "daft", BARCODE_DAFT, 93, 0, 0, 0, 0, 0, },
+{ "", -1, 94, 0, 0, 0, 0, 0, },
+{ "", -1, 95, 0, 0, 0, 0, 0, },
+{ "code128", BARCODE_DPD, 96, 0, 1, 0, 0, 0, },
+{ "microqrcode", BARCODE_MICROQR, 97, 1, 1, 1, 0, 0, },
+{ "hibccode128", BARCODE_HIBC_128, 98, 0, 0, 0, 0, 0, },
+{ "hibccode39", BARCODE_HIBC_39, 99, 0, 0, 0, 0, 0, },
+{ "", -1, 100, 0, 0, 0, 0, 0, },
+{ "", -1, 101, 0, 0, 0, 0, 0, },
+{ "hibcdatamatrix", BARCODE_HIBC_DM, 102, 0, 1, 1, 0, 0, },
+{ "", -1, 103, 0, 0, 0, 0, 0, },
+{ "hibcqrcode", BARCODE_HIBC_QR, 104, 1, 1, 1, 0, 0, },
+{ "", -1, 105, 0, 0, 0, 0, 0, },
+{ "hibcpdf417", BARCODE_HIBC_PDF, 106, 1, 1, 1, 0, 0, },
+{ "", -1, 107, 0, 0, 0, 0, 0, },
+{ "hibcmicropdf417", BARCODE_HIBC_MICPDF, 108, 0, 1, 0, 0, 0, },
+{ "", -1, 109, 0, 0, 0, 0, 0, },
+{ "hibccodablockf", BARCODE_HIBC_BLOCKF, 110, 1, 1, 0, 10 /*linear_row_height*/, 0, },
+{ "", -1, 111, 0, 0, 0, 0, 0, },
+{ "hibcazteccode", BARCODE_HIBC_AZTEC, 112, 1, 0, 1, 0, 0, },
+{ "", -1, 113, 0, 0, 0, 0, 0, },
+{ "", -1, 114, 0, 0, 0, 0, 0, },
+{ "dotcode", BARCODE_DOTCODE, 115, 0, 1, 1, 0, 0, },
+{ "hanxin", BARCODE_HANXIN, 116, 0, 0, 0, 0, 0, },
+{ "", -1, 117, 0, 0, 0, 0, 0, },
+{ "", -1, 118, 0, 0, 0, 0, 0, },
+{ "mailmark", BARCODE_MAILMARK_2D, 119, 0, 1, 0, 0, 0, },
+{ "code128", BARCODE_UPU_S10, 120, 0, 0, 0, 0, 0, },
+{ "", BARCODE_MAILMARK_4S, 121, 0, 0, 0, 0, 0, }, /* Note BWIPP mailmark is BARCODE_MAILMARK_2D above */
+{ "", -1, 122, 0, 0, 0, 0, 0, },
+{ "", -1, 123, 0, 0, 0, 0, 0, },
+{ "", -1, 124, 0, 0, 0, 0, 0, },
+{ "", -1, 125, 0, 0, 0, 0, 0, },
+{ "", -1, 126, 0, 0, 0, 0, 0, },
+{ "", BARCODE_DXFILMEDGE, 127, 0, 0, 0, 0, 0, },
+{ "aztecrune", BARCODE_AZRUNE, 128, 0, 0, 0, 0, 0, },
+{ "code32", BARCODE_CODE32, 129, 0, 0, 0, 0, 0, },
+{ "ean13composite", BARCODE_EANX_CC, 130, 1, 1, 0, 72 /*linear_row_height*/, 1 /*gs1_cvt*/, },
+{ "gs1-128composite", BARCODE_GS1_128_CC, 131, 1, 0, 0, 36, 1, },
+{ "databaromnicomposite", BARCODE_DBAR_OMN_CC, 132, 1, 0, 0, 33, 1, },
+{ "databarlimitedcomposite", BARCODE_DBAR_LTD_CC, 133, 1, 0, 0, 10 /*linear_row_height*/, 1, },
+{ "databarexpandedcomposite", BARCODE_DBAR_EXP_CC, 134, 1, 1, 0, 34 /*linear_row_height*/, 1, },
+{ "upcacomposite", BARCODE_UPCA_CC, 135, 1, 1, 0, 72, 1, },
+{ "upcecomposite", BARCODE_UPCE_CC, 136, 1, 1, 0, 72, 1, },
+{ "databarstackedcomposite", BARCODE_DBAR_STK_CC, 137, 1, 0, 0, 0, 1, },
+{ "databarstackedomnicomposite", BARCODE_DBAR_OMNSTK_CC, 138, 1, 0, 0, 33 /*linear_row_height*/, 1, },
+{ "databarexpandedstackedcomposite", BARCODE_DBAR_EXPSTK_CC, 139, 1, 1, 0, 34 /*linear_row_height*/, 1, },
+{ "channelcode", BARCODE_CHANNEL, 140, 0, 0, 0, 0, 0, },
+{ "codeone", BARCODE_CODEONE, 141, 0, 1, 0, 0, 0, },
+{ "", BARCODE_GRIDMATRIX, 142, 0, 0, 0, 0, 0, },
+{ "qrcode", BARCODE_UPNQR, 143, 0, 0, 1, 0, 0, },
+{ "ultracode", BARCODE_ULTRA, 144, 1, 1, 0, 0, 0, },
+{ "rectangularmicroqrcode", BARCODE_RMQR, 145, 1, 1, 1, 0, 0, },
+{ "bc412", BARCODE_BC412, 146, 1, 1, 0, 0, 0, },
+};
+const int data_size = ARRAY_SIZE(data);
+const int symbology = symbol->symbology;
+const int gs1 = (symbol->input_mode & 0x07) == GS1_MODE;
+if (symbology < 0 || symbology >= data_size) {
+fprintf(stderr, "testUtilBwippName: unknown symbology (%d)\n", symbology);
+abort();
+}
+/* Self-check */
+if (data[symbology].val != symbology || (data[symbology].define != -1 && data[symbology].define != symbology)) {
+fprintf(stderr, "testUtilBwippName: data table out of sync (%d)\n", symbology);
+abort();
+}
+if (data[symbology].name[0] == '\0') {
+if (debug & ZINT_DEBUG_TEST_PRINT) {
+printf("i:%d %s no BWIPP mapping\n", index, testUtilBarcodeName(symbology));
+}
+return NULL;
+}
+if ((option_1 != -1 && !data[symbology].can_option_1) || (option_2 != -1 && !data[symbology].can_option_2)
+|| (option_3 != -1 && !data[symbology].can_option_3)) {
+if (debug & ZINT_DEBUG_TEST_PRINT) {
+printf("i:%d %s not BWIPP compatible, options not supported, option_1 %d, option_2 %d, option_3 %d\n",
+index, testUtilBarcodeName(symbology), option_1, option_2, option_3);
+}
+return NULL;
+}
+if (symbol->structapp.count && symbology != BARCODE_MAXICODE) {
+if (debug & ZINT_DEBUG_TEST_PRINT) {
+printf("i:%d %s not BWIPP compatible, Structured Append not supported\n",
+index, testUtilBarcodeName(symbology));
+}
+return NULL;
+}
+if (symbology == BARCODE_CODE11) {
+if (option_2 != 1 && option_2 != 2) { /* 2 check digits (Zint default) not supported */
+if (debug & ZINT_DEBUG_TEST_PRINT) {
+printf("i:%d %s not BWIPP compatible, 2 check digits not supported, option_1 %d, option_2 %d\n",
+index, testUtilBarcodeName(symbology), option_1, option_2);
+}
+return NULL;
+}
+} else if (symbology == BARCODE_CODABLOCKF || symbology == BARCODE_HIBC_BLOCKF) {
+if (option_1 == 1) { /* Single row i.e. CODE128 not supported */
+if (debug & ZINT_DEBUG_TEST_PRINT) {
+printf("i:%d %s not BWIPP compatible, single row not supported, option_1 %d\n",
+index, testUtilBarcodeName(symbology), option_1);
+}
+return NULL;
+}
+} else if (symbology == BARCODE_AZTEC) {
+if (option_1 > 0 && option_2 > 0) {
+if (debug & ZINT_DEBUG_TEST_PRINT) {
+printf("i:%d %s not BWIPP compatible, cannot specify both option_1 %d and option_2 %d\n",
+index, testUtilBarcodeName(symbology), option_1, option_2);
+}
+return NULL;
+}
+} else if (symbology == BARCODE_RMQR) {
+if (option_2 < 1) {
+if (debug & ZINT_DEBUG_TEST_PRINT) {
+printf("i:%d %s not BWIPP compatible, version (option_2) must be specified\n",
+index, testUtilBarcodeName(symbology));
+}
+return NULL;
+}
+if (option_2 > 32) {
+if (debug & ZINT_DEBUG_TEST_PRINT) {
+printf("i:%d %s not BWIPP compatible, auto width (option_2 > 32) not supported\n",
+index, testUtilBarcodeName(symbology));
+}
+return NULL;
+}
+} else if (symbology == BARCODE_MAILMARK_2D) {
+if (option_2 < 1) {
+if (debug & ZINT_DEBUG_TEST_PRINT) {
+printf("i:%d %s not BWIPP compatible, version (option_2) must be specified\n",
+index, testUtilBarcodeName(symbology));
+}
+return NULL;
+}
+}
+if (linear_row_height) {
+*linear_row_height = data[symbology].linear_row_height;
+}
+if (gs1_cvt) {
+*gs1_cvt = data[symbology].gs1_cvt;
+}
+if (gs1) {
+if (symbology == BARCODE_DATAMATRIX) {
+if (gs1_cvt) {
+*gs1_cvt = 1;
+}
+return "gs1datamatrix";
+} else if (symbology == BARCODE_AZTEC || symbology == BARCODE_CODE16K || symbology == BARCODE_ULTRA
+|| symbology == BARCODE_CODE49) {
+if (debug & ZINT_DEBUG_TEST_PRINT) {
+printf("i:%d %s not BWIPP compatible, GS1_MODE not supported\n",
+index, testUtilBarcodeName(symbology));
+}
+return NULL;
+} else if (symbology == BARCODE_QRCODE) {
+if (gs1_cvt) {
+*gs1_cvt = 1;
+}
+return "gs1qrcode";
+} else if (symbology == BARCODE_DOTCODE) {
+if (gs1_cvt) {
+*gs1_cvt = 1;
+}
+return "gs1dotcode";
+}
+}
+return data[symbology].name;
+}
+/* Whether can use BWIPP to check a symbology with given options */
+int testUtilCanBwipp(int index, const struct zint_symbol *symbol, int option_1, int option_2, int option_3,
+int debug) {
+return testUtilBwippName(index, symbol, option_1, option_2, option_3, debug, NULL, NULL) != NULL;
+}
+/* Convert Zint GS1 and add-on format to BWIPP's */
+static void testUtilBwippCvtGS1Data(char *bwipp_data, const int upcean, const int parens_mode, int *addon_posn) {
+char *b;
+int pipe = 0;
+*addon_posn = 0;
+for (b = bwipp_data; *b; b++) {
+if (upcean && *b == '|') {
+pipe = 1;
+}
+if (!parens_mode && *b == '[') {
+*b = '(';
+} else if (!parens_mode && *b == ']') {
+*b = ')';
+} else if (*b == '+' && upcean && !pipe) {
+*b = ' ';
+*addon_posn = b - bwipp_data;
+}
+}
+}
+#define z_isxdigit(c) (z_isdigit(c) || ((c) >= 'A' && (c) <= 'F') || ((c) >= 'a' && (c) <= 'f'))
+#define z_isodigit(c) ((c) <= '7' && (c) >= '0')
+/* Convert data to Ghostscript format for passing to bwipp_dump.ps */
+static char *testUtilBwippEscape(char *bwipp_data, int bwipp_data_size, const char *data, int length,
+int zint_escape_mode, int eci, int *parse, int *parsefnc) {
+const int init_parsefnc = *parsefnc == 1;
+char *b = bwipp_data;
+char *be = b + bwipp_data_size;
+unsigned char *d = (unsigned char *) data;
+unsigned char *de = (unsigned char *) data + length;
+if (eci && !init_parsefnc) {
+sprintf(bwipp_data, "^ECI%06d", eci);
+*parsefnc = 1;
+b = bwipp_data + 10;
+}
+while (b < be && d < de) {
+/* Have to escape double quote otherwise Ghostscript gives "Unterminated quote in @-file" for some reason */
+/* Escape single quote also to avoid having to do proper shell escaping TODO: proper shell escaping */
+if (*d < 0x20 || *d >= 0x7F || (*d == '^' && !init_parsefnc) || *d == '"' || *d == '\''
+|| *d == '(' || (*d == '\\' && !zint_escape_mode)) {
+if (b + 4 >= be) {
+fprintf(stderr, "testUtilBwippEscape: double quote bwipp_data buffer full (%d)\n", bwipp_data_size);
+return NULL;
+}
+sprintf(b, "^%03u", *d++);
+b += 4;
+*parse = 1;
+} else if (zint_escape_mode && *d == '\\' && d + 1 < de) {
+int val;
+switch (*++d) {
+case '0': val = 0x00; /* Null */ break;
+case 'E': val = 0x04; /* End of Transmission */ break;
+case 'a': val = 0x07; /* Bell */ break;
+case 'b': val = 0x08; /* Backspace */ break;
+case 't': val = 0x09; /* Horizontal tab */ break;
+case 'n': val = 0x0a; /* Line feed */ break;
+case 'v': val = 0x0b; /* Vertical tab */ break;
+case 'f': val = 0x0c; /* Form feed */ break;
+case 'r': val = 0x0d; /* Carriage return */ break;
+case 'e': val = 0x1b; /* Escape */ break;
+case 'G': val = 0x1d; /* Group Separator */ break;
+case 'R': val = 0x1e; /* Record Separator */ break;
+case 'x':
+val = d + 2 < de && z_isxdigit(d[1]) && z_isxdigit(d[2]) ? (ctoi(d[1]) << 4) | ctoi(d[2]) : -1;
+if (val != -1) d+= 2;
+break;
+case 'd':
+val = d + 3 < de ? to_int(d + 1, 3) : -1;
+if (val > 255) val = -1;
+if (val != -1) d += 3;
+break;
+case 'o':
+val = d + 3 < de && z_isodigit(d[1]) && z_isodigit(d[2]) && z_isodigit(d[3])
+? (ctoi(d[1]) << 6) | (ctoi(d[2]) << 3) | ctoi(d[3]) : -1;
+if (val > 255) val = -1;
+if (val != -1) d += 3;
+break;
+case '\\': val = '\\'; break;
+/*case 'u': val = 0; TODO: implement break; */
+/*case 'U': val = 0; TODO: implement break; */
+case '^': val = -1; break; /* Code 128 special escapes */
+default: fprintf(stderr, "testUtilBwippEscape: unknown escape %c\n", *d); return NULL; break;
+}
+if (val >= 0) {
+if (b + 4 >= be) {
+fprintf(stderr, "testUtilBwippEscape: loop bwipp_data buffer full (%d)\n", bwipp_data_size);
+return NULL;
+}
+sprintf(b, "^%03d", val);
+b += 4;
+} else {
+if (*d == '^' && d + 1 < de && ((*(d + 1) >= '@' && *(d + 1) <= 'C') || *(d + 1) == '1')) {
+d++;
+if (*d == '1') {
+if (b + 5 >= be) {
+fprintf(stderr, "testUtilBwippEscape: FNC1 bwipp_data buffer full (%d)\n", bwipp_data_size);
+return NULL;
+}
+strcpy(b, "^FNC1");
+b += 5;
+*parsefnc = 1;
+}
+} else {
+if (b + 8 >= be) {
+fprintf(stderr, "testUtilBwippEscape: loop bwipp_data buffer full (%d)\n", bwipp_data_size);
+return NULL;
+}
+sprintf(b, "^%03d^%03d", '\\', *d);
+b += 8;
+if (*d == '^' && d + 1 < de && *(d + 1) == '^') {
+d++;
+}
+}
+}
+d++;
+*parse = 1;
+} else {
+*b++ = *d++;
+}
+}
+if (b == be && d < de) {
+fprintf(stderr, "testUtilBwippEscape: end bwipp_data buffer full (%d)\n", bwipp_data_size);
+return NULL;
+}
+*b = '\0';
+return bwipp_data;
+}
+/* Convert ISBN to BWIPP format */
+static void testUtilISBNHyphenate(char *bwipp_data, int addon_posn) {
+/* Hack in 4 hyphens in fixed format, wrong for many ISBNs */
+char temp[13 + 4 + 1 + 5 + 1];
+int len = (int) strlen(bwipp_data);
+int i, j;
+if (len < 13 || (addon_posn && addon_posn < 13 ) || len >= (int) sizeof(temp)) {
+return;
+}
+for (i = 0, j = 0; i <= len; i++, j++) {
+if (i == 3 || i == 5 || i == 10 || i == 12) {
+temp[j++] = '-';
+}
+temp[j] = bwipp_data[i];
+}
+strcpy(bwipp_data, temp);
+}
+/* Helper to convert UTF-8 data */
+static char *testUtilBwippUtf8Convert(const int index, const int symbology, const int try_sjis, int *p_eci,
+const unsigned char *data, int *p_data_len, unsigned char *converted) {
+int eci = *p_eci;
+if (eci == 0 && try_sjis
+&& (symbology == BARCODE_QRCODE || symbology == BARCODE_MICROQR || symbology == BARCODE_RMQR || symbology == BARCODE_UPNQR)) {
+if (symbology == BARCODE_UPNQR) { /* Note need to add "force binary mode" to BWIPP for this to work */
+if (utf8_to_eci(4, data, converted, p_data_len) != 0) {
+fprintf(stderr, "i:%d testUtilBwippUtf8Convert: failed to convert UTF-8 data for %s, ECI 4\n",
+index, testUtilBarcodeName(symbology));
+return NULL;
+}
+*p_eci = 4;
+} else {
+if (utf8_to_eci(0, data, converted, p_data_len) != 0) {
+if (utf8_to_eci(20, data, converted, p_data_len) != 0) {
+fprintf(stderr, "i:%d testUtilBwippUtf8Convert: failed to convert UTF-8 data for %s, ECI 0/20\n",
+index, testUtilBarcodeName(symbology));
+return NULL;
+}
+/* NOTE: not setting *p_eci = 20 */
+}
+}
+return (char *) converted;
+}
+if (ZBarcode_Cap(symbology, ZINT_CAP_ECI)) {
+if (utf8_to_eci(eci, data, converted, p_data_len) != 0) {
+if (eci != 0) {
+fprintf(stderr, "i:%d testUtilBwippUtf8Convert: failed to convert UTF-8 data for %s, ECI %d\n",
+index, testUtilBarcodeName(symbology), eci);
+return NULL;
+}
+*p_eci = eci = get_best_eci(data, *p_data_len);
+if (utf8_to_eci(eci, data, converted, p_data_len) != 0) {
+fprintf(stderr, "i:%d testUtilBwippUtf8Convert: failed to convert UTF-8 data for %s, ECI %d\n",
+index, testUtilBarcodeName(symbology), eci);
+return NULL;
+}
+}
+return (char *) converted;
+}
+if (eci != 0) {
+fprintf(stderr, "i:%d testUtilBwippUtf8Convert: ECI %d but not supported for %s\n",
+index, eci, testUtilBarcodeName(symbology));
+return NULL;
+}
+if (utf8_to_eci(eci, data, converted, p_data_len) != 0) {
+fprintf(stderr, "i:%d testUtilBwippUtf8Convert: failed to convert UTF-8 data for %s, default ECI %d\n",
+index, testUtilBarcodeName(symbology), eci);
+return NULL;
+}
+return (char *) converted;
+}
+#define GS_INITIAL_LEN  35 /* Length of cmd up to -q */
+/* Create bwipp_dump.ps command and run */
+int testUtilBwipp(int index, const struct zint_symbol *symbol, int option_1, int option_2, int option_3,
+const char *data, int length, const char *primary, char *buffer, int buffer_size, int *p_parsefnc) {
+static const char cmd_fmt[] = "gs -dNOPAUSE -dBATCH -dNODISPLAY -q -sb=%s -sd='%s'"
+" backend/tests/tools/bwipp_dump.ps";
+static const char cmd_opts_fmt[] = "gs -dNOPAUSE -dBATCH -dNODISPLAY -q -sb=%s -sd='%s' -so='%s'"
+" backend/tests/tools/bwipp_dump.ps";
+/* If data > 2K and < ~4K */
+static const char cmd_fmt2[] = "gs -dNOPAUSE -dBATCH -dNODISPLAY -q -sb=%s -sd='%.2040s' -sd2='%s'"
+" backend/tests/tools/bwipp_dump.ps";
+static const char cmd_opts_fmt2[] = "gs -dNOPAUSE -dBATCH -dNODISPLAY -q -sb=%s -sd='%.2040s' -sd2='%s' -so='%s'"
+" backend/tests/tools/bwipp_dump.ps";
+/* If data > ~4K and < ~6K */
+static const char cmd_fmt3[] = "gs -dNOPAUSE -dBATCH -dNODISPLAY -q -sb=%s -sd='%.2040s' -sd2='%.2040s' -sd3='%s'"
+" backend/tests/tools/bwipp_dump.ps";
+static const char cmd_opts_fmt3[] = "gs -dNOPAUSE -dBATCH -dNODISPLAY -q -sb=%s -sd='%.2040s' -sd2='%.2040s' -sd3='%s'"
+" -so='%s' backend/tests/tools/bwipp_dump.ps";
+/* If data > ~6K and < ~8K */
+static const char cmd_fmt4[] = "gs -dNOPAUSE -dBATCH -dNODISPLAY -q -sb=%s -sd='%.2040s' -sd2='%.2040s' -sd3='%.2040s'"
+" -sd4='%s' backend/tests/tools/bwipp_dump.ps";
+static const char cmd_opts_fmt4[] = "gs -dNOPAUSE -dBATCH -dNODISPLAY -q -sb=%s -sd='%.2040s' -sd2='%.2040s'"
+" -sd3='%.2040s' -sd4='%s' -so='%s' backend/tests/tools/bwipp_dump.ps";
+const int symbology = symbol->symbology;
+int data_len = length == -1 ? (int) strlen(data) : length;
+int primary_len = primary ? (int) strlen(primary) : 0;
+/* 4 AI prefix + primary + '|' + leading zero + escaped data + fudge */
+int max_data_len = 4 + primary_len + 1 + 1 + data_len * 4 + 64;
+int eci_length = get_eci_length(symbol->eci, (const unsigned char *) data, data_len);
+char *converted = (char *) z_alloca(eci_length + 1);
+char *cmd = (char *) z_alloca(max_data_len + 1024);
+const char *bwipp_barcode = NULL;
+char *bwipp_opts = NULL;
+int bwipp_data_size = max_data_len + 1;
+char *bwipp_data = (char *) z_alloca(bwipp_data_size);
+char bwipp_opts_buf[512];
+int *bwipp_row_height = (int *) z_alloca(sizeof(int) * symbol->rows);
+int linear_row_height;
+int gs1_cvt;
+int user_mask;
+FILE *fp = NULL;
+int cnt;
+char *b = buffer;
+char *be = buffer + buffer_size;
+int r, h;
+int parse = 0, parsefnc = p_parsefnc ? *p_parsefnc : 0;
+const int upcean = (ZBarcode_Cap(symbology, ZINT_CAP_EANUPC) & ZINT_CAP_EANUPC) == ZINT_CAP_EANUPC;
+const int upca = symbology == BARCODE_UPCA || symbology == BARCODE_UPCA_CHK || symbology == BARCODE_UPCA_CC;
+const int parens_mode = symbol->input_mode & GS1PARENS_MODE;
+const char obracket = parens_mode ? '(' : '[';
+const char cbracket = parens_mode ? ')' : ']';
+int addon_posn;
+int eci;
+int i, j, len;
+bwipp_data[0] = bwipp_opts_buf[0] = '\0';
+bwipp_barcode = testUtilBwippName(index, symbol, option_1, option_2, option_3, 0, &linear_row_height, &gs1_cvt);
+if (!bwipp_barcode) {
+fprintf(stderr, "i:%d testUtilBwipp: no mapping for %s, option_1 %d, option_2 %d, option_3 %d\n",
+index, testUtilBarcodeName(symbology), option_1, option_2, option_3);
+return -1;
+}
+for (r = 0; r < symbol->rows; r++) {
+if (symbology == BARCODE_MAXICODE) {
+bwipp_row_height[r] = 1;
+} else {
+bwipp_row_height[r] = symbol->row_height[r] ? symbol->row_height[r] : linear_row_height;
+}
+if ((symbol->debug & ZINT_DEBUG_TEST_PRINT) && !(symbol->debug & ZINT_DEBUG_TEST_LESS_NOISY)) {
+fprintf(stderr, "bwipp_row_height[%d] %d, symbol->row_height[%d] %g\n",
+r, bwipp_row_height[r], r, symbol->row_height[r]);
+}
+}
+eci = symbol->eci >= 3 && ZBarcode_Cap(symbology, ZINT_CAP_ECI) ? symbol->eci : 0;
+if ((symbol->input_mode & 0x07) == UNICODE_MODE && is_eci_convertible(eci)
+&& (data = testUtilBwippUtf8Convert(index, symbology, 1 /*try_sjis*/, &eci, (const unsigned char *) data,
+&data_len, (unsigned char *) converted)) == NULL) {
+fprintf(stderr, "i:%d testUtilBwipp: failed to convert UTF-8 data for %s\n",
+index, testUtilBarcodeName(symbology));
+return -1;
+}
+if (is_composite(symbology)) {
+if (!primary) {
+fprintf(stderr, "i:%d testUtilBwipp: no primary data given %s\n", index, testUtilBarcodeName(symbology));
+return -1;
+}
+if (*primary != obracket && !upcean) {
+strcat(bwipp_data, "(01)");
+}
+strcat(bwipp_data, primary);
+strcat(bwipp_data, "|");
+strcat(bwipp_data, data);
+testUtilBwippCvtGS1Data(bwipp_data, upcean, parens_mode, &addon_posn);
+/* Always set dontlint for now (until support for exclusive AIs check) */
+sprintf(bwipp_opts_buf + strlen(bwipp_opts_buf), "%sdontlint", strlen(bwipp_opts_buf) ? " " : "");
+bwipp_opts = bwipp_opts_buf;
+if (upcean) {
+if (symbology == BARCODE_EANX_CC && (primary_len <= 8 || (addon_posn && addon_posn <= 8))) {
+bwipp_barcode = "ean8composite";
+}
+if (addon_posn) {
+sprintf(bwipp_opts_buf + strlen(bwipp_opts_buf), "%saddongap=%d",
+strlen(bwipp_opts_buf) ? " " : "", option_2 > 0 ? option_2 : upca ? 9 : 7);
+}
+bwipp_row_height[symbol->rows - 1] = 72;
+}
+if (option_1 > 0) {
+sprintf(bwipp_opts_buf + strlen(bwipp_opts_buf), "%sccversion=%c",
+strlen(bwipp_opts_buf) ? " " : "", option_1 == 1 ? 'a' : option_1 == 2 ? 'b' : 'c');
+}
+if (option_2 > 0) {
+sprintf(bwipp_opts_buf + strlen(bwipp_opts_buf), "%ssegments=%d",
+strlen(bwipp_opts_buf) ? " " : "", option_2 * 2);
+}
+if (symbol->input_mode & GS1NOCHECK_MODE) {
+/* sprintf(bwipp_opts_buf + strlen(bwipp_opts_buf), "%sdontlint", strlen(bwipp_opts_buf) ? " " : ""); */
+}
+} else {
+if (gs1_cvt) {
+if (*data != obracket && !upcean) {
+strcat(bwipp_data, symbology == BARCODE_NVE18 ? "(00)" : "(01)");
+}
+strcat(bwipp_data, data);
+testUtilBwippCvtGS1Data(bwipp_data, upcean, parens_mode, &addon_posn);
+/* Always set dontlint for now (until support for exclusive AIs check) */
+sprintf(bwipp_opts_buf + strlen(bwipp_opts_buf), "%sdontlint", strlen(bwipp_opts_buf) ? " " : "");
+bwipp_opts = bwipp_opts_buf;
+if (upcean) {
+if ((symbology == BARCODE_EANX || symbology == BARCODE_EANX_CHK)
+&& (data_len <= 8 || (addon_posn && addon_posn <= 8))) {
+bwipp_barcode = data_len <= 3 ? "ean2" : data_len <= 5 ? "ean5" : "ean8";
+}
+if (symbology == BARCODE_ISBNX) {
+testUtilISBNHyphenate(bwipp_data, addon_posn);
+}
+if (addon_posn) {
+sprintf(bwipp_opts_buf + strlen(bwipp_opts_buf), "%saddongap=%d",
+strlen(bwipp_opts_buf) ? " " : "", option_2 > 0 ? option_2 : upca ? 9 : 7);
+}
+}
+if (option_2 > 0) {
+if (symbology == BARCODE_DBAR_EXP || symbology == BARCODE_DBAR_EXPSTK) {
+sprintf(bwipp_opts_buf + strlen(bwipp_opts_buf), "%ssegments=%d",
+strlen(bwipp_opts_buf) ? " " : "", option_2 * 2);
+}
+}
+if (symbol->input_mode & GS1NOCHECK_MODE) {
+/* sprintf(bwipp_opts_buf + strlen(bwipp_opts_buf), "%sdontlint", strlen(bwipp_opts_buf) ? " " : ""); */
+}
+} else {
+const int is_extra_escaped = (symbol->input_mode & EXTRA_ESCAPE_MODE)
+&& symbol->symbology == BARCODE_CODE128;
+const int is_escaped = (symbol->input_mode & ESCAPE_MODE) || is_extra_escaped;
+if (testUtilBwippEscape(bwipp_data, bwipp_data_size, data, data_len, is_escaped, eci, &parse, &parsefnc)
+== NULL) {
+return -1;
+}
+if (parse) {
+sprintf(bwipp_opts_buf + strlen(bwipp_opts_buf), "%sparse", strlen(bwipp_opts_buf) ? " " : "");
+bwipp_opts = bwipp_opts_buf;
+}
+if (parsefnc) {
+sprintf(bwipp_opts_buf + strlen(bwipp_opts_buf), "%sparsefnc",
+strlen(bwipp_opts_buf) ? " " : "");
+bwipp_opts = bwipp_opts_buf;
+}
+if (symbology == BARCODE_C25STANDARD || symbology == BARCODE_C25INTER || symbology == BARCODE_C25IATA
+|| symbology == BARCODE_C25LOGIC || symbology == BARCODE_C25IND) {
+if (option_2 == 1 || option_2 == 2) { /* Add check digit without or with HRT suppression */
+sprintf(bwipp_opts_buf + strlen(bwipp_opts_buf), "%sincludecheck",
+strlen(bwipp_opts_buf) ? " " : "");
+bwipp_opts = bwipp_opts_buf;
+}
+} else if (symbology == BARCODE_CODE93) {
+sprintf(bwipp_opts_buf + strlen(bwipp_opts_buf), "%sincludecheck",
+strlen(bwipp_opts_buf) ? " " : "");
+bwipp_opts = bwipp_opts_buf;
+} else if (symbology == BARCODE_PZN) {
+sprintf(bwipp_opts_buf + strlen(bwipp_opts_buf), "%spzn%c",
+strlen(bwipp_opts_buf) ? " " : "", option_2 == 1 ? '7' : '8');
+bwipp_opts = bwipp_opts_buf;
+} else if (symbology == BARCODE_TELEPEN_NUM) {
+if (data_len & 1) { /* Add leading zero */
+memmove(bwipp_data + 1, bwipp_data, strlen(bwipp_data) + 1);
+*bwipp_data = '0';
+}
+} else if (symbology == BARCODE_CODABLOCKF || symbology == BARCODE_HIBC_BLOCKF) {
+if (option_1 > 0) {
+sprintf(bwipp_opts_buf + strlen(bwipp_opts_buf), "%srows=%d",
+strlen(bwipp_opts_buf) ? " " : "", option_1);
+}
+if (option_2 > 0) {
+sprintf(bwipp_opts_buf + strlen(bwipp_opts_buf), "%scolumns=%d",
+strlen(bwipp_opts_buf) ? " " : "", option_2 - 5);
+} else {
+sprintf(bwipp_opts_buf + strlen(bwipp_opts_buf), "%scolumns=%d",
+strlen(bwipp_opts_buf) ? " " : "", (symbol->width - 57) / 11);
+}
+bwipp_opts = bwipp_opts_buf;
+} else if (symbology == BARCODE_CODE11 || symbology == BARCODE_CODE39 || symbology == BARCODE_EXCODE39
+|| symbology == BARCODE_LOGMARS || symbology == BARCODE_CODABAR) {
+if (option_2 > 0) {
+if (option_2 == 1) {
+sprintf(bwipp_opts_buf + strlen(bwipp_opts_buf), "%sincludecheck",
+strlen(bwipp_opts_buf) ? " " : "");
+}
+bwipp_opts = bwipp_opts_buf; /* Set always as option_2 == 2 is bwipp default */
+}
+} else if (symbology == BARCODE_PLESSEY) {
+sprintf(bwipp_opts_buf + strlen(bwipp_opts_buf), "%sincludecheck", strlen(bwipp_opts_buf) ? " " : "");
+bwipp_opts = bwipp_opts_buf;
+} else if (symbology == BARCODE_MSI_PLESSEY) {
+if (option_2 > 0) {
+const char *checktype = NULL;
+sprintf(bwipp_opts_buf + strlen(bwipp_opts_buf), "%sincludecheck",
+strlen(bwipp_opts_buf) ? " " : "");
+if (option_2 >= 11 && option_2 <= 16) {
+option_2 -= 10; /* Remove no-check indicator */
+}
+if (option_2 == 2) {
+checktype = "mod1010";
+} else if (option_2 == 3) {
+checktype = "mod11 badmod11";
+} else if (option_2 == 4) {
+checktype = "mod1110 badmod11";
+} else if (option_2 == 5) {
+checktype = "ncrmod11 badmod11";
+} else if (option_2 == 6) {
+checktype = "ncrmod1110 badmod11";
+}
+if (checktype) {
+sprintf(bwipp_opts_buf + strlen(bwipp_opts_buf), "%schecktype=%s",
+strlen(bwipp_opts_buf) ? " " : "", checktype);
+}
+bwipp_opts = bwipp_opts_buf;
+}
+} else if (symbology == BARCODE_PDF417 || symbology == BARCODE_PDF417COMP || symbology == BARCODE_HIBC_PDF
+|| symbology == BARCODE_MICROPDF417 || symbology == BARCODE_HIBC_MICPDF) {
+const int row_height = symbology == BARCODE_MICROPDF417 || symbology == BARCODE_HIBC_MICPDF ? 2 : 3;
+for (r = 0; r < symbol->rows; r++) bwipp_row_height[r] = row_height;
+if (option_1 >= 0) {
+sprintf(bwipp_opts_buf + strlen(bwipp_opts_buf), "%seclevel=%d fixedeclevel",
+strlen(bwipp_opts_buf) ? " " : "", option_1);
+bwipp_opts = bwipp_opts_buf;
+}
+if (option_2 > 0) {
+sprintf(bwipp_opts_buf + strlen(bwipp_opts_buf), "%scolumns=%d",
+strlen(bwipp_opts_buf) ? " " : "", option_2);
+bwipp_opts = bwipp_opts_buf;
+}
+if (option_3 > 0) {
+sprintf(bwipp_opts_buf + strlen(bwipp_opts_buf), "%srows=%d",
+strlen(bwipp_opts_buf) ? " " : "", option_3);
+bwipp_opts = bwipp_opts_buf;
+}
+} else if (symbology == BARCODE_POSTNET || symbology == BARCODE_PLANET || symbology == BARCODE_RM4SCC
+|| symbology == BARCODE_JAPANPOST || symbology == BARCODE_KIX || symbology == BARCODE_DAFT
+|| symbology == BARCODE_USPS_IMAIL || symbology == BARCODE_AUSPOST
+|| symbology == BARCODE_PHARMA_TWO) {
+for (r = 0; r < symbol->rows; r++) bwipp_row_height[r] = 1; /* Zap */
+if (symbology == BARCODE_RM4SCC || symbology == BARCODE_KIX || symbology == BARCODE_JAPANPOST || symbology == BARCODE_DAFT) {
+to_upper((unsigned char *) bwipp_data, (int) strlen(bwipp_data));
+} else if (symbology == BARCODE_USPS_IMAIL) {
+char *dash = strchr(bwipp_data, '-');
+if (dash) {
+memmove(dash, dash + 1, strlen(dash));
+}
+} else if (symbology == BARCODE_AUSPOST) {
+const char *prefix;
+if (data_len == 8) {
+prefix = "11";
+} else if (data_len == 13 || data_len == 16) {
+prefix = "59";
+if (data_len == 16) {
+sprintf(bwipp_opts_buf + strlen(bwipp_opts_buf), "%scustinfoenc=numeric",
+strlen(bwipp_opts_buf) ? " " : "");
+bwipp_opts = bwipp_opts_buf;
+}
+} else {
+prefix = "62";
+if (data_len == 23) {
+sprintf(bwipp_opts_buf + strlen(bwipp_opts_buf), "%scustinfoenc=numeric",
+strlen(bwipp_opts_buf) ? " " : "");
+bwipp_opts = bwipp_opts_buf;
+}
+}
+memmove(bwipp_data + 2, bwipp_data, data_len + 1);
+memmove(bwipp_data, prefix, 2);
+}
+} else if (symbology == BARCODE_CODE128AB) {
+sprintf(bwipp_opts_buf + strlen(bwipp_opts_buf), "%ssuppressc", strlen(bwipp_opts_buf) ? " " : "");
+bwipp_opts = bwipp_opts_buf;
+} else if (symbology == BARCODE_DPD) {
+if (data_len == 27 && option_2 != 1) {
+memmove(bwipp_data + 1, bwipp_data, data_len + 1);
+bwipp_data[0] = '%';
+}
+bwipp_opts = bwipp_opts_buf;
+} else if (symbology == BARCODE_FIM) {
+strcpy(bwipp_data, "fima");
+bwipp_data[3] = z_isupper(data[0]) ? data[0] - 'A' + 'a' : data[0];
+} else if (symbology == BARCODE_CODE16K || symbology == BARCODE_CODE49) {
+if (option_1 >= 2) {
+if ((symbology == BARCODE_CODE16K && option_1 <= 16)
+|| (symbology == BARCODE_CODE49 && option_1 <= 8 && option_1 >= symbol->rows)) {
+sprintf(bwipp_opts_buf + strlen(bwipp_opts_buf), "%srows=%d",
+strlen(bwipp_opts_buf) ? " " : "", option_1);
+}
+bwipp_opts = bwipp_opts_buf;
+}
+} else if (symbology == BARCODE_AZTEC || symbology == BARCODE_HIBC_AZTEC) {
+int compact = 0, full = 0;
+if (option_1 >= 1 && option_1 <= 4) {
+int eclevel;
+if (option_1 == 1) {
+eclevel = 10;
+} else if (option_1 == 2) {
+eclevel = 23;
+} else if (option_1 == 3) {
+eclevel = 36;
+} else {
+eclevel = 50;
+}
+sprintf(bwipp_opts_buf + strlen(bwipp_opts_buf), "%seclevel=%d",
+strlen(bwipp_opts_buf) ? " " : "", eclevel);
+bwipp_opts = bwipp_opts_buf;
+}
+if (option_2 >= 1) {
+int layers;
+if (option_2 <= 4) {
+compact = 1;
+layers = option_2;
+} else {
+layers = option_2 - 4;
+full = layers <= 4;
+}
+sprintf(bwipp_opts_buf + strlen(bwipp_opts_buf), "%slayers=%d",
+strlen(bwipp_opts_buf) ? " " : "", layers);
+bwipp_opts = bwipp_opts_buf;
+}
+if (symbol->output_options & READER_INIT) {
+sprintf(bwipp_opts_buf + strlen(bwipp_opts_buf), "%sreaderinit",
+strlen(bwipp_opts_buf) ? " " : "");
+bwipp_opts = bwipp_opts_buf;
+}
+if (symbology == BARCODE_HIBC_AZTEC) {
+compact = 1;
+}
+if (compact || full) {
+sprintf(bwipp_opts_buf + strlen(bwipp_opts_buf), "%sformat=%s",
+strlen(bwipp_opts_buf) ? " " : "", compact ? "compact" : "full");
+bwipp_opts = bwipp_opts_buf;
+}
+} else if (symbology == BARCODE_CODEONE) {
+if ((symbol->input_mode & 0x07) == GS1_MODE) { /* Hack pseudo-GS1 support */
+int last_ai, ai_latch = 0;
+/* Reduce square brackets (include NUL) */
+for (i = 0, j = 0, len = (int) strlen(bwipp_data); i <= len; i++) {
+if (bwipp_data[i] == obracket) {
+if (ai_latch == 0) {
+bwipp_data[j++] = '\x1D';
+}
+last_ai = to_int((unsigned char *) (bwipp_data + i + 1), 2);
+if ((last_ai >= 0 && last_ai <= 4) || (last_ai >= 11 && last_ai <= 20) || last_ai == 23
+|| (last_ai >= 31 && last_ai <= 36) || last_ai == 41) {
+ai_latch = 1;
+}
+} else if (bwipp_data[i] != cbracket) {
+bwipp_data[j++] = bwipp_data[i];
+}
+}
+/* Replace square brackets with ^FNC1 */
+for (len = (int) strlen(bwipp_data), i = len - 1; i >= 0; i--) {
+if (bwipp_data[i] == '\x1D') {
+memmove(bwipp_data + i + 5, bwipp_data + i + 1, len - i);
+memcpy(bwipp_data + i, "^FNC1", 5);
+len += 4;
+}
+}
+if (!parsefnc) { /* If not already done for ECI */
+sprintf(bwipp_opts_buf + strlen(bwipp_opts_buf), "%sparsefnc",
+strlen(bwipp_opts_buf) ? " " : "");
+bwipp_opts = bwipp_opts_buf;
+}
+}
+if (option_2 >= 1 && option_2 <= 10) {
+static const char *codeone_versions[] = { "A", "B", "C", "D", "E", "F", "G", "H" };
+const char *codeone_version;
+if (option_2 == 9) {
+codeone_version = length <= 6 ? "S-10" : length <= 12 ? "S-20" : "S-30";
+} else if (option_2 == 10) {
+/* TODO: Properly allow for different T sizes */
+codeone_version = length <= 22 ? "T-16" : length <= 34 ? "T-32" : "T-48";
+} else {
+codeone_version = codeone_versions[option_2 - 1];
+}
+sprintf(bwipp_opts_buf + strlen(bwipp_opts_buf), "%sversion=%s",
+strlen(bwipp_opts_buf) ? " " : "", codeone_version);
+bwipp_opts = bwipp_opts_buf;
+}
+} else if (symbology == BARCODE_MAXICODE) {
+int have_eci = memcmp(bwipp_data, "^ECI", 4) == 0;
+int have_scm = memcmp(bwipp_data + have_eci * 10, "[)>^03001^029", 13) == 0
+&& z_isdigit(bwipp_data[13 + have_eci * 10])
+&& z_isdigit(bwipp_data[14 + have_eci * 10]);
+int mode = option_1;
+char prefix_buf[30];
+int prefix_len = 0;
+if (mode <= 0) {
+if (primary_len == 0) {
+mode = 4;
+} else {
+mode = 2;
+for (i = 0; i < primary_len - 6; i++) {
+if (!z_isdigit(symbol->primary[i]) && (symbol->primary[i] != ' ')) {
+mode = 3;
+break;
+}
+}
+}
+}
+if (mode > 0) {
+sprintf(bwipp_opts_buf + strlen(bwipp_opts_buf), "%smode=%d",
+strlen(bwipp_opts_buf) ? " " : "", mode);
+bwipp_opts = bwipp_opts_buf;
+}
+if (option_2 > 0) {
+char scm_vv_buf[40];
+sprintf(scm_vv_buf, "[)>^03001^029%02d", option_2 - 1); /* [)>\R01\Gvv */
+memmove(bwipp_data + 15, bwipp_data, strlen(bwipp_data) + 1);
+memcpy(bwipp_data, scm_vv_buf, 15);
+have_scm = 1;
+have_eci = 0;
+if (!parse) {
+sprintf(bwipp_opts_buf + strlen(bwipp_opts_buf), "%sparse",
+strlen(bwipp_opts_buf) ? " " : "");
+bwipp_opts = bwipp_opts_buf;
+parse = 1;
+}
+}
+if (primary_len >= 6) { /* Keep gcc happy */
+int postcode_len = primary_len - 6;
+char postcode[10];
+if (postcode_len >= 10) postcode_len = 9;
+memcpy(postcode, primary, postcode_len);
+postcode[postcode_len] = '\0';
+if (mode == 2) {
+for (i = 0; i < postcode_len; i++) {
+if (postcode[i] == ' ') {
+postcode[i] = '\0';
+}
+}
+} else {
+postcode[6] = '\0';
+for (i = postcode_len; i < 6; i++) {
+postcode[i] = ' ';
+}
+}
+sprintf(prefix_buf, "%s^029%.3s^029%.3s^029",
+postcode, primary + primary_len - 6, primary + primary_len - 3);
+prefix_len = (int) strlen(prefix_buf);
+}
+if (prefix_len || have_scm) {
+char eci_buf[10];
+int offset = 15 * have_scm;
+if (have_eci) {
+memcpy(eci_buf, bwipp_data, 10);
+memmove(bwipp_data, bwipp_data + 10, strlen(bwipp_data) - 10 + 1);
+}
+memmove(bwipp_data + offset + prefix_len, bwipp_data + offset, strlen(bwipp_data) - offset + 1);
+memcpy(bwipp_data + offset, prefix_buf, prefix_len);
+if (have_eci) {
+memmove(bwipp_data + offset + prefix_len + 10, bwipp_data + offset + prefix_len,
+strlen(bwipp_data) - (offset + prefix_len) + 1);
+memcpy(bwipp_data + offset + prefix_len, eci_buf, 10);
+}
+}
+if (!parse) {
+sprintf(bwipp_opts_buf + strlen(bwipp_opts_buf), "%sparse",
+strlen(bwipp_opts_buf) ? " " : "");
+bwipp_opts = bwipp_opts_buf;
+parse = 1;
+}
+if (symbol->structapp.count) {
+sprintf(bwipp_opts_buf + strlen(bwipp_opts_buf), "%ssam=%c%c",
+strlen(bwipp_opts_buf) ? " " : "", itoc(symbol->structapp.index),
+itoc(symbol->structapp.count));
+bwipp_opts = bwipp_opts_buf;
+}
+} else if (symbology == BARCODE_BC412) {
+to_upper((unsigned char *) bwipp_data, (int) strlen(bwipp_data));
+sprintf(bwipp_opts_buf + strlen(bwipp_opts_buf), "%ssemi", strlen(bwipp_opts_buf) ? " " : "");
+bwipp_opts = bwipp_opts_buf;
+} else if (symbology == BARCODE_MAILMARK_2D) {
+sprintf(bwipp_opts_buf + strlen(bwipp_opts_buf), "%stype=%d",
+strlen(bwipp_opts_buf) ? " " : "", option_2 - 1);
+bwipp_opts = bwipp_opts_buf;
+}
+}
+if (symbology == BARCODE_CODE128 || symbology == BARCODE_CODE128AB || symbology == BARCODE_HIBC_128
+|| symbology == BARCODE_GS1_128 || symbology == BARCODE_GS1_128_CC || symbology == BARCODE_NVE18
+|| symbology == BARCODE_EAN14 || symbology == BARCODE_UPU_S10 || symbology == BARCODE_MAXICODE) {
+sprintf(bwipp_opts_buf + strlen(bwipp_opts_buf), "%snewencoder", strlen(bwipp_opts_buf) ? " " : "");
+bwipp_opts = bwipp_opts_buf;
+}
+if (symbology == BARCODE_DATAMATRIX || symbology == BARCODE_HIBC_DM) {
+int added_dmre = 0;
+#include "../dmatrix.h"
+(void)dm_matrixrsblock; (void)dm_matrixdatablock; (void)dm_matrixbytes;
+(void)dm_matrixFW; (void)dm_matrixFH;
+(void)dm_isDMRE; (void)dm_text_value; (void)dm_text_shift; (void)dm_c40_value; (void)dm_c40_shift;
+if (symbol->output_options & GS1_GS_SEPARATOR) {
+sprintf(bwipp_opts_buf + strlen(bwipp_opts_buf), "%sgssep", strlen(bwipp_opts_buf) ? " " : "");
+bwipp_opts = bwipp_opts_buf;
+}
+if (option_2 >= 1 && option_2 <= ARRAY_SIZE(dm_intsymbol)) {
+int idx = dm_intsymbol[option_2 - 1];
+sprintf(bwipp_opts_buf + strlen(bwipp_opts_buf), "%srows=%d columns=%d",
+strlen(bwipp_opts_buf) ? " " : "", dm_matrixH[idx], dm_matrixW[idx]);
+bwipp_opts = bwipp_opts_buf;
+if (option_2 >= 31) {
+sprintf(bwipp_opts_buf + strlen(bwipp_opts_buf), "%sdmre", strlen(bwipp_opts_buf) ? " " : "");
+added_dmre = 1;
+}
+}
+if ((option_3 & 0x7F) != DM_SQUARE && symbol->width != symbol->height) {
+if ((option_3 & 0x7F) == DM_DMRE && !added_dmre) {
+sprintf(bwipp_opts_buf + strlen(bwipp_opts_buf), "%sdmre", strlen(bwipp_opts_buf) ? " " : "");
+/*added_dmre = 1; */
+}
+sprintf(bwipp_opts_buf + strlen(bwipp_opts_buf), "%sformat=rectangle",
+strlen(bwipp_opts_buf) ? " " : "");
+bwipp_opts = bwipp_opts_buf;
+}
+if (option_3 != -1) {
+bwipp_opts = bwipp_opts_buf;
+}
+} else if (symbology == BARCODE_DOTCODE) {
+if (option_2 > 0) {
+sprintf(bwipp_opts_buf + strlen(bwipp_opts_buf), "%scolumns=%d",
+strlen(bwipp_opts_buf) ? " " : "", symbol->option_2);
+bwipp_opts = bwipp_opts_buf;
+}
+if (option_3 != -1) {
+user_mask = (option_3 >> 8) & 0x0F; /* User mask is pattern + 1, so >= 1 and <= 8 */
+if (user_mask >= 1 && user_mask <= 8) {
+sprintf(bwipp_opts_buf + strlen(bwipp_opts_buf), "%smask=%d",
+strlen(bwipp_opts_buf) ? " " : "", (user_mask - 1) % 4);
+bwipp_opts = bwipp_opts_buf;
+}
+}
+/* Hack to place ECI after Macro header */
+if (eci && length > 5 && memcmp("[)>\036", data, 4) == 0) {
+char macro_eci_buf[13];
+if (length > 6 && data[6] == 29 /*GS*/ && ((data[4] == '0' && data[5] == '5')
+|| (data[4] == '0' && data[5] == '6') || (data[4] == '1' && data[5] == '2'))) {
+memcpy(macro_eci_buf, bwipp_data + 10, 13); /* Macro */
+memcpy(bwipp_data + 13, bwipp_data, 10); /* ECI */
+memcpy(bwipp_data, macro_eci_buf, 13);
+} else if (z_isdigit(data[4]) && z_isdigit(data[5])) {
+memcpy(macro_eci_buf, bwipp_data, 10); /* ECI */
+memcpy(bwipp_data, bwipp_data + 10, 9); /* Macro */
+memcpy(bwipp_data + 9, macro_eci_buf, 10);
+}
+}
+} else if (symbology == BARCODE_QRCODE || symbology == BARCODE_HIBC_QR || symbology == BARCODE_MICROQR
+|| symbology == BARCODE_RMQR) {
+if (option_1 >= 1 && option_1 <= 4) {
+static const char eccs[4] = { 'L', 'M', 'Q', 'H' };
+sprintf(bwipp_opts_buf + strlen(bwipp_opts_buf), "%seclevel=%c fixedeclevel",
+strlen(bwipp_opts_buf) ? " " : "", eccs[option_1 - 1]);
+bwipp_opts = bwipp_opts_buf;
+}
+if (symbology == BARCODE_RMQR) {
+if (option_2 >= 1 && option_2 <= 32) {
+static const char *vers[] = {
+"R7x43", "R7x59", "R7x77", "R7x99", "R7x139",
+"R9x43", "R9x59", "R9x77", "R9x99", "R9x139",
+"R11x27", "R11x43", "R11x59", "R11x77", "R11x99", "R11x139",
+"R13x27", "R13x43", "R13x59", "R13x77", "R13x99", "R13x139",
+"R15x43", "R15x59", "R15x77", "R15x99", "R15x139",
+"R17x43", "R17x59", "R17x77", "R17x99", "R17x139",
+};
+sprintf(bwipp_opts_buf + strlen(bwipp_opts_buf), "%sversion=%s",
+strlen(bwipp_opts_buf) ? " " : "", vers[option_2 - 1]);
+bwipp_opts = bwipp_opts_buf;
+}
+} else {
+if (option_2 >= 1 && option_2 <= 40) {
+sprintf(bwipp_opts_buf + strlen(bwipp_opts_buf), "%sversion=%s%d",
+strlen(bwipp_opts_buf) ? " " : "", symbology == BARCODE_MICROQR ? "M" : "", option_2);
+bwipp_opts = bwipp_opts_buf;
+}
+if (option_3 != -1) {
+int mask = (symbol->option_3 >> 8) & 0x0F;
+if (mask >= 1 && ((symbology != BARCODE_MICROQR && mask <= 8)
+|| (symbology == BARCODE_MICROQR && mask <= 4))) {
+sprintf(bwipp_opts_buf + strlen(bwipp_opts_buf), "%smask=%d",
+strlen(bwipp_opts_buf) ? " " : "", ((symbol->option_3 >> 8) & 0x0F));
+bwipp_opts = bwipp_opts_buf;
+}
+}
+}
+} else if (symbology == BARCODE_ULTRA) {
+const int rev = option_2 == 2 ? 2 : 1;
+if (option_1 >= 1 && option_1 <= 6) {
+sprintf(bwipp_opts_buf + strlen(bwipp_opts_buf), "%seclevel=EC%d",
+strlen(bwipp_opts_buf) ? " " : "", option_1 - 1);
+}
+sprintf(bwipp_opts_buf + strlen(bwipp_opts_buf), "%srev=%d", strlen(bwipp_opts_buf) ? " " : "", rev);
+bwipp_opts = bwipp_opts_buf;
+}
+}
+if ((option_1 != -1 || option_2 != -1 || option_3 != -1) && !bwipp_opts) {
+fprintf(stderr,
+"i:%d testUtilBwipp: no BWIPP options set option_1 %d, option_2 %d, option_3 %d for symbology %s\n",
+index, option_1, option_2, option_3, testUtilBarcodeName(symbology));
+return -1;
+}
+if (bwipp_opts && strlen(bwipp_opts)) {
+if (strlen(bwipp_data) >= 2040) { /* Ghostscript's `arg_str_max` 2048 less "-sd?=" + quotes */
+if (strlen(bwipp_data) >= 2040 * 2) {
+if (strlen(bwipp_data) >= 2040 * 3) {
+sprintf(cmd, cmd_opts_fmt4, bwipp_barcode, bwipp_data, bwipp_data + 2040, bwipp_data + 2040 * 2,
+bwipp_data + 2040 * 3, bwipp_opts);
+} else {
+sprintf(cmd, cmd_opts_fmt3, bwipp_barcode, bwipp_data, bwipp_data + 2040, bwipp_data + 2040 * 2,
+bwipp_opts);
+}
+} else {
+sprintf(cmd, cmd_opts_fmt2, bwipp_barcode, bwipp_data, bwipp_data + 2040, bwipp_opts);
+}
+} else {
+sprintf(cmd, cmd_opts_fmt, bwipp_barcode, bwipp_data, bwipp_opts);
+}
+} else {
+if (strlen(bwipp_data) >= 2040) {
+if (strlen(bwipp_data) >= 2040 * 2) {
+if (strlen(bwipp_data) >= 2040 * 3) {
+sprintf(cmd, cmd_fmt4, bwipp_barcode, bwipp_data, bwipp_data + 2040, bwipp_data + 2040 * 2,
+bwipp_data + 2040 * 3);
+} else {
+sprintf(cmd, cmd_fmt3, bwipp_barcode, bwipp_data, bwipp_data + 2040, bwipp_data + 2040 * 2);
+}
+} else {
+sprintf(cmd, cmd_fmt2, bwipp_barcode, bwipp_data, bwipp_data + 2040);
+}
+} else {
+sprintf(cmd, cmd_fmt, bwipp_barcode, bwipp_data);
+}
+}
+/* Hack in various adjustments */
+if (symbology == BARCODE_DBAR_OMN || symbology == BARCODE_DBAR_LTD || symbology == BARCODE_DBAR_EXP) {
+/* Begin with space */
+char adj[] = " -sbs";
+memmove(cmd + GS_INITIAL_LEN + sizeof(adj) - 1, cmd + GS_INITIAL_LEN, strlen(cmd) + 1 - GS_INITIAL_LEN);
+memcpy(cmd + GS_INITIAL_LEN, adj, sizeof(adj) - 1);
+}
+if (symbology == BARCODE_CODE11 || symbology == BARCODE_CODE39 || symbology == BARCODE_EXCODE39
+|| symbology == BARCODE_CODABAR || symbology == BARCODE_PHARMA || symbology == BARCODE_PZN
+|| symbology == BARCODE_CODE32 || symbology == BARCODE_VIN) {
+/* Ratio 3 width bar/space -> 2 width */
+char adj[] = " -sr=0.6";
+memmove(cmd + GS_INITIAL_LEN + sizeof(adj) - 1, cmd + GS_INITIAL_LEN, strlen(cmd) + 1 - GS_INITIAL_LEN);
+memcpy(cmd + GS_INITIAL_LEN, adj, sizeof(adj) - 1);
+}
+if (symbology == BARCODE_C25INTER || symbology == BARCODE_DPLEIT || symbology == BARCODE_DPIDENT
+|| symbology == BARCODE_ITF14) {
+/* Ratio 2 width bar/space -> 3 width */
+char adj[] = " -sr=1.3";
+memmove(cmd + GS_INITIAL_LEN + sizeof(adj) - 1, cmd + GS_INITIAL_LEN, strlen(cmd) + 1 - GS_INITIAL_LEN);
+memcpy(cmd + GS_INITIAL_LEN, adj, sizeof(adj) - 1);
+}
+if (symbology == BARCODE_FIM) {
+/* Ratio 2.25 width bar/space -> 1 width */
+char adj[] = " -sr=0.444";
+memmove(cmd + GS_INITIAL_LEN + sizeof(adj) - 1, cmd + GS_INITIAL_LEN, strlen(cmd) + 1 - GS_INITIAL_LEN);
+memcpy(cmd + GS_INITIAL_LEN, adj, sizeof(adj) - 1);
+}
+if (symbology == BARCODE_PLESSEY) {
+/* Ceiling ratio 3/4/5 width bar/space -> 2 width then round ratio 2 width bar/space -> 3 width */
+char adj[] = " -sc=0.4 -sr=1.3";
+memmove(cmd + GS_INITIAL_LEN + sizeof(adj) - 1, cmd + GS_INITIAL_LEN, strlen(cmd) + 1 - GS_INITIAL_LEN);
+memcpy(cmd + GS_INITIAL_LEN, adj, sizeof(adj) - 1);
+}
+if (symbology == BARCODE_CODE11 || symbology == BARCODE_CODE39 || symbology == BARCODE_EXCODE39
+|| symbology == BARCODE_HIBC_39 || symbology == BARCODE_LOGMARS || symbology == BARCODE_PHARMA
+|| symbology == BARCODE_PZN || symbology == BARCODE_CODE32 || symbology == BARCODE_VIN
+|| symbology == BARCODE_C25INTER || symbology == BARCODE_DPLEIT || symbology == BARCODE_DPIDENT
+|| symbology == BARCODE_ITF14 || symbology == BARCODE_PHARMA_TWO) {
+/* End sbs loop on bar */
+char adj[] = " -selb";
+memmove(cmd + GS_INITIAL_LEN + sizeof(adj) - 1, cmd + GS_INITIAL_LEN, strlen(cmd) + 1 - GS_INITIAL_LEN);
+memcpy(cmd + GS_INITIAL_LEN, adj, sizeof(adj) - 1);
+}
+if (symbology == BARCODE_C25STANDARD) {
+/* Zint uses 4X start/stop wides while BWIPP uses 3X - convert */
+char adj[] = " -sp='i 0 eq i limit 4 sub eq or sbs i get 3 eq and { (1111) print true } { false } ifelse'";
+memmove(cmd + GS_INITIAL_LEN + sizeof(adj) - 1, cmd + GS_INITIAL_LEN, strlen(cmd) + 1 - GS_INITIAL_LEN);
+memcpy(cmd + GS_INITIAL_LEN, adj, sizeof(adj) - 1);
+}
+if (symbology == BARCODE_POSTNET || symbology == BARCODE_PLANET || symbology == BARCODE_RM4SCC
+|| symbology == BARCODE_JAPANPOST || symbology == BARCODE_KIX || symbology == BARCODE_DAFT
+|| symbology == BARCODE_USPS_IMAIL || symbology == BARCODE_AUSPOST || symbology == BARCODE_PHARMA_TWO) {
+/* Emulate rows with BWIPP heights. */
+char adj[] = " -shs";
+memmove(cmd + GS_INITIAL_LEN + sizeof(adj) - 1, cmd + GS_INITIAL_LEN, strlen(cmd) + 1 - GS_INITIAL_LEN);
+memcpy(cmd + GS_INITIAL_LEN, adj, sizeof(adj) - 1);
+}
+if (symbology == BARCODE_CODE16K || symbology == BARCODE_CODE49) {
+char adj[] = " -sxs=10 -sxe=1"; /* Strip first 10 and last zero */
+memmove(cmd + GS_INITIAL_LEN + sizeof(adj) - 1, cmd + GS_INITIAL_LEN, strlen(cmd) + 1 - GS_INITIAL_LEN);
+memcpy(cmd + GS_INITIAL_LEN, adj, sizeof(adj) - 1);
+}
+if (symbol->debug & ZINT_DEBUG_TEST_PRINT) {
+printf("i:%d testUtilBwipp: cmd %s\n", index, cmd);
+}
+fp = testutil_popen(cmd, "r");
+if (!fp) {
+fprintf(stderr, "i:%d testUtilBwipp: failed to run '%s'\n", index, cmd);
+return -1;
+}
+if (symbol->rows == 0) { /* For testing BWIPP against ZXingC++ (`ZBarcode_Encode()` not called) */
+cnt = (int) fread(b, 1, buffer_size - 1, fp); /* Just read the whole output */
+b += cnt;
+} else {
+for (r = 0; r < symbol->rows; r++) {
+if (b + symbol->width > be) {
+fprintf(stderr, "i:%d testUtilBwipp: row %d, width %d, row width iteration overrun (%s)\n",
+index, r, symbol->width, cmd);
+testutil_pclose(fp);
+return -1;
+}
+cnt = (int) fread(b, 1, symbol->width, fp);
+if (cnt != symbol->width) {
+fprintf(stderr, "i:%d testUtilBwipp: failed to read row %d of %d, symbol->width %d bytes, cnt %d (%s)\n",
+index, r + 1, symbol->rows, symbol->width, cnt, cmd);
+testutil_pclose(fp);
+return -1;
+}
+b += cnt;
+for (h = bwipp_row_height[r]; h > 1; h--) { /* Ignore row copies if any */
+cnt = (int) fread(b, 1, symbol->width, fp);
+if (cnt != symbol->width) {
+fprintf(stderr,
+"i:%d testUtilBwipp: failed to read/ignore symbol->width %d bytes, cnt %d, h %d"
+", bwipp_row_height[%d] %d, symbol->row_height[%d] %g (%s)\n",
+index, symbol->width, cnt, h, r, bwipp_row_height[r], r, symbol->row_height[r], cmd);
+testutil_pclose(fp);
+return -1;
+}
+if (h * 2 == bwipp_row_height[r]) { /* Hack to use middle row (avoids add-on text offsets) */
+memcpy(b - cnt, b, cnt);
+}
+}
+}
+}
+*b = '\0';
+if (fgetc(fp) != EOF) {
+fprintf(stderr, "i:%d testUtilBwipp: failed to read full stream (%s)\n", index, cmd);
+testutil_pclose(fp);
+return -1;
+}
+testutil_pclose(fp);
+return 0;
+}
+/* Append multiple segments together and then call `testUtilBwipp()` */
+int testUtilBwippSegs(int index, struct zint_symbol *symbol, int option_1, int option_2, int option_3,
+const struct zint_seg segs[], const int seg_count, const char *primary, char *buffer, int buffer_size) {
+const int symbology = symbol->symbology;
+const int unicode_mode = (symbol->input_mode & 0x7) == UNICODE_MODE;
+const int symbol_eci = symbol->eci;
+struct zint_seg *local_segs = (struct zint_seg *) z_alloca(sizeof(struct zint_seg) * seg_count);
+int total_len = 0;
+char *data, *d;
+int parsefnc = 1;
+int ret;
+int i;
+assert(ZBarcode_Cap(symbology, ZINT_CAP_ECI));
+for (i = 0; i < seg_count; i++) {
+local_segs[i] = segs[i];
+if (local_segs[i].length == -1) {
+local_segs[i].length = (int) ustrlen(local_segs[i].source);
+}
+if (unicode_mode) {
+total_len += get_eci_length(local_segs[i].eci, local_segs[i].source, local_segs[i].length);
+} else {
+total_len += local_segs[i].length;
+}
+}
+total_len += 10 * seg_count;
+d = data = (char *) z_alloca(total_len + 1);
+for (i = 0; i < seg_count; i++) {
+if (unicode_mode && is_eci_convertible(local_segs[i].eci)) {
+char *converted = testUtilBwippUtf8Convert(index, symbology, 0 /*try_sjis*/, &local_segs[i].eci,
+local_segs[i].source, &local_segs[i].length, (unsigned char *) d);
+if (converted == NULL) {
+return -1;
+}
+if (converted == d) {
+/* Ensure default ECI set if follows non-default ECI */
+if (i != 0 && local_segs[i].eci == 0 && local_segs[i - 1].eci > 3) {
+local_segs[i].eci = 3;
+}
+if (local_segs[i].eci) { /* Note this will fail if have DotCode macro */
+char eci_str[10 + 1];
+sprintf(eci_str, "^ECI%06d", local_segs[i].eci);
+memmove(d + 10, d, local_segs[i].length);
+memcpy(d, eci_str, 10);
+d += 10;
+}
+d += local_segs[i].length;
+} else {
+/* Ensure default ECI set if follows non-default ECI */
+if (i != 0 && local_segs[i].eci == 0 && local_segs[i - 1].eci > 3) {
+local_segs[i].eci = 3;
+}
+if (local_segs[i].eci) {
+d += sprintf(d, "^ECI%06d", local_segs[i].eci);
+}
+memcpy(d, local_segs[i].source, local_segs[i].length);
+d += local_segs[i].length;
+}
+} else {
+/* Ensure default ECI set if follows non-default ECI */
+if (i != 0 && local_segs[i].eci == 0 && local_segs[i - 1].eci > 3) {
+local_segs[i].eci = 3;
+}
+if (local_segs[i].eci) {
+d += sprintf(d, "^ECI%06d", local_segs[i].eci);
+}
+memcpy(d, local_segs[i].source, local_segs[i].length);
+d += local_segs[i].length;
+}
+}
+total_len = d - data;
+if (unicode_mode) {
+symbol->input_mode = DATA_MODE;
+}
+symbol->eci = 0;
+ret = testUtilBwipp(index, symbol, option_1, option_2, option_3, data, total_len, primary, buffer, buffer_size, &parsefnc);
+if (unicode_mode) {
+symbol->input_mode = UNICODE_MODE;
+}
+symbol->eci = symbol_eci;
+return ret;
+}
+/* Compare bwipp_dump.ps output to test suite module dump */
+int testUtilBwippCmp(const struct zint_symbol *symbol, char *msg, char *cmp_buf, const char *expected) {
+int cmp_len = (int) strlen(cmp_buf);
+int expected_len = (int) strlen(expected);
+int ret_memcmp;
+int i;
+(void)symbol;
+if (cmp_len != expected_len) {
+sprintf(msg, "cmp_len %d != expected_len %d", cmp_len, expected_len);
+return 2;
+}
+if (symbol->symbology == BARCODE_ULTRA) {
+static const char map[] = { '8', '1', '2', '3', '4', '5', '6', '7', '8', '7' };
+for (i = 0; i < cmp_len; i++) {
+if (z_isdigit(cmp_buf[i])) {
+cmp_buf[i] = map[cmp_buf[i] - '0'];
+}
+}
+}
+ret_memcmp = memcmp(cmp_buf, expected, expected_len);
+if (ret_memcmp != 0) {
+for (i = 0; i < expected_len; i++) {
+if (cmp_buf[i] != expected[i]) {
+break;
+}
+}
+sprintf(msg, "memcmp %d != 0, at %d, len %d", ret_memcmp, i, expected_len);
+return ret_memcmp;
+}
+return 0;
+}
+/* Compare bwipp_dump.ps output to single row module dump (see testUtilModulesPrintRow) */
+int testUtilBwippCmpRow(const struct zint_symbol *symbol, int row, char *msg, const char *cmp_buf,
+const char *expected) {
+int cmp_len = (int) strlen(cmp_buf);
+int expected_len = (int) strlen(expected);
+int ret_memcmp;
+int i, j;
+(void)symbol;
+if (cmp_len != expected_len * symbol->rows) {
+sprintf(msg, "cmp_len %d != expected_len %d * symbol->rows %d", cmp_len, expected_len, symbol->rows);
+return 2;
+}
+ret_memcmp = memcmp(cmp_buf + expected_len * row, expected, expected_len);
+if (ret_memcmp != 0) {
+for (i = 0, j = expected_len * row; i < expected_len; i++, j++) {
+if (cmp_buf[j] != expected[i]) {
+break;
+}
+}
+sprintf(msg, "memcmp %d != 0, at %d (%d), len %d", ret_memcmp, i, j, expected_len);
+return ret_memcmp;
+}
+return 0;
+}
+/* Whether ZXing-C++ Decoder available on system */
+/* Requires the "diagnostics2" branch from https://github.com/gitlost/zxing-cpp built with BUILD_EXAMPLE_DECODER
+and "zxingcppdecoder" placed in PATH, e.g.:
+git clone --branch diagnostics2 https://github.com/gitlost/zxing-cpp zxing-cpp-diagnostics2
+cd zxing-cpp-diagnostics2
+mkdir build; cd build
+cmake -DCMAKE_INSTALL_PREFIX=/usr/local -DBUILD_EXAMPLE_DECODER=ON ..
+make && sudo make install
+*/
+int testUtilHaveZXingCPPDecoder(void) {
+return system("zxingcppdecoder " DEV_NULL_STDERR) == 0;
+}
+/* Helper to test whether have non-ASCII */
+static int testUtilHasNonASCII(const char *source, const int length) {
+int i;
+for (i = 0; i < length; i++) {
+if (source[i] & 0x80) {
+return 1;
+}
+}
+return 0;
+}
+/* Map Zint symbology to ZXing-C++ format name */
+static const char *testUtilZXingCPPName(int index, const struct zint_symbol *symbol, const char *source,
+const int length, const int debug) {
+struct item {
+const char *name;
+int define;
+int val;
+};
+static const struct item data[] = {
+{ "", -1, 0, },
+{ "", BARCODE_CODE11, 1, },
+{ "", BARCODE_C25STANDARD, 2, },
+{ "ITF", BARCODE_C25INTER, 3, },
+{ "", BARCODE_C25IATA, 4, },
+{ "", -1, 5, },
+{ "", BARCODE_C25LOGIC, 6, },
+{ "", BARCODE_C25IND, 7, },
+{ "Code39", BARCODE_CODE39, 8, },
+{ "Code39", BARCODE_EXCODE39, 9, }, /* TODO: Code39 with specially encoded chars */
+{ "", -1, 10, },
+{ "", -1, 11, },
+{ "", -1, 12, },
+{ "EAN-13", BARCODE_EANX, 13, },
+{ "EAN-13", BARCODE_EANX_CHK, 14, },
+{ "", -1, 15, },
+{ "Code128", BARCODE_GS1_128, 16, },
+{ "", -1, 17, },
+{ "Codabar", BARCODE_CODABAR, 18, },
+{ "", -1, 19, },
+{ "Code128", BARCODE_CODE128, 20, },
+{ "ITF", BARCODE_DPLEIT, 21, },
+{ "ITF", BARCODE_DPIDENT, 22, },
+{ "Code16K", BARCODE_CODE16K, 23, },
+{ "", BARCODE_CODE49, 24, },
+{ "Code93", BARCODE_CODE93, 25, },
+{ "", -1, 26, },
+{ "", -1, 27, },
+{ "", BARCODE_FLAT, 28, },
+{ "DataBar", BARCODE_DBAR_OMN, 29, },
+{ "DataBarLimited", BARCODE_DBAR_LTD, 30, },
+{ "DataBarExpanded", BARCODE_DBAR_EXP, 31, },
+{ "", BARCODE_TELEPEN, 32, },
+{ "", -1, 33, },
+{ "UPC-A", BARCODE_UPCA, 34, },
+{ "UPC-A", BARCODE_UPCA_CHK, 35, },
+{ "", -1, 36, },
+{ "UPC-E", BARCODE_UPCE, 37, },
+{ "UPC-E", BARCODE_UPCE_CHK, 38, },
+{ "", -1, 39, },
+{ "", BARCODE_POSTNET, 40, },
+{ "", -1, 41, },
+{ "", -1, 42, },
+{ "", -1, 43, },
+{ "", -1, 44, },
+{ "", -1, 45, },
+{ "", -1, 46, },
+{ "", BARCODE_MSI_PLESSEY, 47, },
+{ "", -1, 48, },
+{ "", BARCODE_FIM, 49, },
+{ "Code39", BARCODE_LOGMARS, 50, },
+{ "", BARCODE_PHARMA, 51, },
+{ "Code39", BARCODE_PZN, 52, },
+{ "", BARCODE_PHARMA_TWO, 53, },
+{ "", -1, 54, },
+{ "PDF417", BARCODE_PDF417, 55, },
+{ "PDF417", BARCODE_PDF417COMP, 56, },
+{ "MaxiCode", BARCODE_MAXICODE, 57, },
+{ "QRCode", BARCODE_QRCODE, 58, },
+{ "", -1, 59, },
+{ "Code128", BARCODE_CODE128AB, 60, },
+{ "", -1, 61, },
+{ "", -1, 62, },
+{ "", BARCODE_AUSPOST, 63, },
+{ "", -1, 64, },
+{ "", -1, 65, },
+{ "", BARCODE_AUSREPLY, 66, },
+{ "", BARCODE_AUSROUTE, 67, },
+{ "", BARCODE_AUSREDIRECT, 68, },
+{ "EAN-13", BARCODE_ISBNX, 69, },
+{ "", BARCODE_RM4SCC, 70, },
+{ "DataMatrix", BARCODE_DATAMATRIX, 71, },
+{ "Code128", BARCODE_EAN14, 72, },
+{ "Code39", BARCODE_VIN, 73, },
+{ "CodablockF", BARCODE_CODABLOCKF, 74, },
+{ "Code128", BARCODE_NVE18, 75, },
+{ "", BARCODE_JAPANPOST, 76, },
+{ "", BARCODE_KOREAPOST, 77, },
+{ "", -1, 78, },
+{ "DataBar", BARCODE_DBAR_STK, 79, },
+{ "DataBar", BARCODE_DBAR_OMNSTK, 80, },
+{ "DataBarExpanded", BARCODE_DBAR_EXPSTK, 81, },
+{ "", BARCODE_PLANET, 82, },
+{ "", -1, 83, },
+{ "MicroPDF417", BARCODE_MICROPDF417, 84, },
+{ "", BARCODE_USPS_IMAIL, 85, },
+{ "", BARCODE_PLESSEY, 86, },
+{ "", BARCODE_TELEPEN_NUM, 87, },
+{ "", -1, 88, },
+{ "ITF", BARCODE_ITF14, 89, },
+{ "", BARCODE_KIX, 90, },
+{ "", -1, 91, },
+{ "Aztec", BARCODE_AZTEC, 92, },
+{ "", BARCODE_DAFT, 93, },
+{ "", -1, 94, },
+{ "", -1, 95, },
+{ "Code128", BARCODE_DPD, 96, },
+{ "MicroQRCode", BARCODE_MICROQR, 97, },
+{ "Code128", BARCODE_HIBC_128, 98, },
+{ "Code39", BARCODE_HIBC_39, 99, },
+{ "", -1, 100, },
+{ "", -1, 101, },
+{ "DataMatrix", BARCODE_HIBC_DM, 102, },
+{ "", -1, 103, },
+{ "QRCode", BARCODE_HIBC_QR, 104, },
+{ "", -1, 105, },
+{ "PDF417", BARCODE_HIBC_PDF, 106, },
+{ "", -1, 107, },
+{ "MicroPDF417", BARCODE_HIBC_MICPDF, 108, },
+{ "", -1, 109, },
+{ "CodablockF", BARCODE_HIBC_BLOCKF, 110, },
+{ "", -1, 111, },
+{ "Aztec", BARCODE_HIBC_AZTEC, 112, },
+{ "", -1, 113, },
+{ "", -1, 114, },
+{ "DotCode", BARCODE_DOTCODE, 115, },
+{ "HanXin", BARCODE_HANXIN, 116, },
+{ "", -1, 117, },
+{ "", -1, 118, },
+{ "DataMatrix", BARCODE_MAILMARK_2D, 119, },
+{ "Code128", BARCODE_UPU_S10, 120, },
+{ "", BARCODE_MAILMARK_4S, 121, },
+{ "", -1, 122, },
+{ "", -1, 123, },
+{ "", -1, 124, },
+{ "", -1, 125, },
+{ "", -1, 126, },
+{ "", -1, 127, },
+{ "", BARCODE_AZRUNE, 128, },
+{ "", BARCODE_CODE32, 129, }, /* Code39 based */
+{ "", BARCODE_EANX_CC, 130, },
+{ "", BARCODE_GS1_128_CC, 131, },
+{ "", BARCODE_DBAR_OMN_CC, 132, },
+{ "", BARCODE_DBAR_LTD_CC, 133, },
+{ "", BARCODE_DBAR_EXP_CC, 134, },
+{ "", BARCODE_UPCA_CC, 135, },
+{ "", BARCODE_UPCE_CC, 136, },
+{ "", BARCODE_DBAR_STK_CC, 137, },
+{ "", BARCODE_DBAR_OMNSTK_CC, 138, },
+{ "", BARCODE_DBAR_EXPSTK_CC, 139, },
+{ "", BARCODE_CHANNEL, 140, },
+{ "", BARCODE_CODEONE, 141, },
+{ "", BARCODE_GRIDMATRIX, 142, },
+{ "QRCode", BARCODE_UPNQR, 143, },
+{ "", BARCODE_ULTRA, 144, },
+{ "RMQRCode", BARCODE_RMQR, 145, },
+{ "", BARCODE_BC412, 146, },
+{ "DXFilmEdge", BARCODE_DXFILMEDGE, 147, },
+};
+const int data_size = ARRAY_SIZE(data);
+const int symbology = symbol->symbology;
+if (symbology < 0 || symbology >= data_size) {
+fprintf(stderr, "testUtilZXingCPPName: unknown symbology (%d)\n", symbology);
+abort();
+}
+/* Self-check */
+if (data[symbology].val != symbology || (data[symbology].define != -1 && data[symbology].define != symbology)) {
+fprintf(stderr, "testUtilZXingCPPName: data table out of sync (%d)\n", symbology);
+abort();
+}
+if (data[symbology].name[0] == '\0') {
+if (debug & ZINT_DEBUG_TEST_PRINT) {
+printf("i:%d %s no ZXint-C++ mapping\n", index, testUtilBarcodeName(symbology));
+}
+return NULL;
+}
+if (symbology == BARCODE_QRCODE || symbology == BARCODE_HIBC_QR || symbology == BARCODE_MICROQR
+|| symbology == BARCODE_RMQR) {
+const int full_multibyte = (symbol->option_3 & 0xFF) == ZINT_FULL_MULTIBYTE;
+if (full_multibyte && testUtilHasNonASCII(source, length)) { /* TODO: Support in ZXing-C++ */
+printf("i:%d %s not ZXing-C++ compatible, ZINT_FULL_MULTIBYTE not supported (with non-ASCII data)\n",
+index, testUtilBarcodeName(symbology));
+return NULL;
+}
+} else if (symbology == BARCODE_CODABLOCKF || symbology == BARCODE_HIBC_BLOCKF) {
+if (symbol->rows == 1) { /* Single row i.e. CODE128 not supported */
+if (debug & ZINT_DEBUG_TEST_PRINT) {
+printf("i:%d %s not ZXing-C++ compatible, single row not supported\n",
+index, testUtilBarcodeName(symbology));
+}
+return NULL;
+}
+} else if ((ZBarcode_Cap(symbology, ZINT_CAP_EANUPC) & ZINT_CAP_EANUPC) == ZINT_CAP_EANUPC) {
+if (symbology == BARCODE_EANX || symbology == BARCODE_EANX_CHK) {
+if (length < 9) {
+if (length < 6) {
+printf("i:%d %s not ZXing-C++ compatible, EAN-5/EAN-2 not supported\n",
+index, testUtilBarcodeName(symbology));
+return NULL;
+}
+return "EAN-8";
+}
+if (strchr(source, '+') != NULL && length < 15) {
+return "EAN-8";
+}
+}
+}
+return data[symbology].name;
+}
+/* Whether can use ZXing-C++ to check a symbology with given options */
+int testUtilCanZXingCPP(int index, const struct zint_symbol *symbol, const char *source, const int length,
+const int debug) {
+return testUtilZXingCPPName(index, symbol, source, length, debug) != NULL;
+}
+/* Run "zxingcppdecoder", returning result in `buffer` */
+int testUtilZXingCPP(int index, struct zint_symbol *symbol, const char *source, const int length, char *bits,
+char *buffer, const int buffer_size, int *p_cmp_len) {
+static const char cmd_fmt[] = "zxingcppdecoder -textonly -format %s -width %d -bits '%s'";
+static const char opts_cmd_fmt[] = "zxingcppdecoder -textonly -format %s -opts '%s' -width %d -bits '%s'";
+static const char cs_cmd_fmt[] = "zxingcppdecoder -textonly -format %s -charset %s -width %d -bits '%s'";
+const int bits_len = (int) strlen(bits);
+const int width = symbol->width;
+const int symbology = symbol->symbology;
+char *cmd = (char *) z_alloca(bits_len + 1024);
+const char *zxingcpp_barcode = NULL;
+const int data_mode = (symbol->input_mode & 0x07) == DATA_MODE;
+int set_charset = 0;
+const char *opts = NULL;
+FILE *fp = NULL;
+int cnt;
+buffer[0] = '\0';
+zxingcpp_barcode = testUtilZXingCPPName(index, symbol, source, length, 0 /*debug*/);
+if (!zxingcpp_barcode) {
+fprintf(stderr, "i:%d testUtilZXingCPP: no mapping for %s\n", index, testUtilBarcodeName(symbology));
+return -1;
+}
+if (symbology == BARCODE_EXCODE39) {
+if (symbol->option_2 == 1) {
+opts = "tryCode39ExtendedMode,validateCode39CheckSum";
+} else {
+opts = "tryCode39ExtendedMode";
+}
+} else if ((symbology == BARCODE_CODE39 || symbology == BARCODE_LOGMARS) && symbol->option_2 == 1) {
+opts = "validateCode39CheckSum";
+}
+if ((symbol->input_mode & 0x07) == UNICODE_MODE && symbol->eci == 0
+&& (symbology == BARCODE_QRCODE || symbology == BARCODE_MICROQR || symbology == BARCODE_HANXIN)) {
+int converted_len = length;
+unsigned char *converted_buf = (unsigned char *) z_alloca(converted_len + 1);
+if (symbology == BARCODE_HANXIN) {
+set_charset = utf8_to_eci(0, (const unsigned char *) source, converted_buf, &converted_len) != 0;
+} else {
+set_charset = utf8_to_eci(0, (const unsigned char *) source, converted_buf, &converted_len) == 0;
+}
+}
+if (set_charset) {
+const char *charset;
+if (symbology == BARCODE_HANXIN) {
+charset = "GB18030";
+} else {
+charset = "ISO8859_1";
+}
+sprintf(cmd, cs_cmd_fmt, zxingcpp_barcode, charset, width, bits);
+} else if (opts) {
+sprintf(cmd, opts_cmd_fmt, zxingcpp_barcode, opts, width, bits);
+} else {
+sprintf(cmd, cmd_fmt, zxingcpp_barcode, width, bits);
+}
+if (symbol->debug & ZINT_DEBUG_TEST_PRINT) {
+printf("i:%d testUtilZXingCPP: cmd %s\n", index, cmd);
+}
+fp = testutil_popen(cmd, "r");
+if (!fp) {
+fprintf(stderr, "i:%d testUtilZXingCPP: failed to run '%s'\n", index, cmd);
+return -1;
+}
+cnt = (int) fread(buffer, 1, buffer_size, fp);
+if (cnt == buffer_size) {
+fprintf(stderr, "i:%d testUtilZXingCPP: buffer too small, %d bytes, cnt %d (%s)\n",
+index, buffer_size, cnt, cmd);
+testutil_pclose(fp);
+return -1;
+}
+if (fgetc(fp) != EOF) {
+fprintf(stderr, "i:%d testUtilZXingCPP: failed to read full stream (%s)\n", index, cmd);
+testutil_pclose(fp);
+return -1;
+}
+testutil_pclose(fp);
+if ((data_mode && is_eci_convertible(symbol->eci)) || symbol->eci >= 899) {
+const int eci = symbol->eci >= 899 ? 3 : symbol->eci;
+int error_number;
+const int eci_length = get_eci_length(eci, (const unsigned char *) buffer, cnt);
+unsigned char *preprocessed = (unsigned char *) z_alloca(eci_length + 1);
+if (eci_length >= buffer_size) {
+fprintf(stderr, "i:%d testUtilZXingCPP: buffer too small, %d bytes, eci_length %d (%s)\n",
+index, buffer_size, eci_length, cmd);
+return -1;
+}
+error_number = utf8_to_eci(eci, (const unsigned char *) buffer, preprocessed, &cnt);
+if (error_number == 0) {
+memcpy(buffer, preprocessed, cnt);
+} else {
+if (eci != 0 && symbol->eci < 899) {
+fprintf(stderr, "i:%d testUtilZXingCPP: utf8_to_eci(%d) == %d (%s)\n", index, eci, error_number, cmd);
+return -1;
+} else {
+int i;
+unsigned int *vals = (unsigned int *) z_alloca(sizeof(int) * (cnt + 1));
+error_number = utf8_to_unicode(symbol, (const unsigned char *) buffer, vals, &cnt, 1);
+if (error_number != 0) {
+fprintf(stderr, "i:%d testUtilZXingCPP: utf8_to_unicode == %d (%s)\n", index, error_number, cmd);
+return -1;
+}
+for (i = 0; i < cnt; i++) {
+buffer[i] = (char) vals[i];
+}
+buffer[cnt] = '\0';
+}
+}
+}
+*p_cmp_len = cnt;
+return 0;
+}
+INTERNAL int escape_char_process_test(struct zint_symbol *symbol, const unsigned char *input_string, int *length,
+unsigned char *escaped_string);
+#include "../gs1.h"
+static const char TECHNETIUM[] = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ-. $/+%"; /* Same as SILVER (CODE39) */
+/* Helper to strip leading zeroes (as long as have at least one non-zero digit) */
+static const char *testUtilZXingCPPLeadingZeroes(const char *expected) {
+const char *stripped = expected;
+while (*stripped == '0') stripped++;
+return z_isdigit(*stripped) ? stripped : expected;
+}
+/* Helper to convert DX number from "NNNN"/"NNNNNN" format to "NNN-NN" format */
+static int textUtilZXingCPPDX(const char *expected, const int expected_len, const char *cmp_buf, char *out) {
+if (strchr(cmp_buf, '-')) {
+const char *stripped;
+if (strchr(expected, '-') == NULL) {
+if (expected_len == 6) {
+const int dx = to_int((const unsigned char *) expected + 1, expected_len - 2);
+sprintf(out, "%d-%d", dx / 16, dx % 16);
+} else {
+const int dx = to_int((const unsigned char *) expected, expected_len);
+sprintf(out, "%d-%d", dx / 16, dx % 16);
+}
+return 1;
+}
+if ((stripped = testUtilZXingCPPLeadingZeroes(expected)) != expected) {
+memcpy(out, stripped, expected_len - (stripped - expected));
+out[expected_len - (stripped - expected)] = '\0';
+return 1;
+}
+}
+return 0;
+}
+/* Massage result from "zxingcppdecoder" so as can compare to Zint input */
+int testUtilZXingCPPCmp(struct zint_symbol *symbol, char *msg, char *cmp_buf, int cmp_len,
+const char *expected, int expected_len, const char *primary, char *ret_buf, int *p_ret_len) {
+const int symbology = symbol->symbology;
+const int is_gs1_128_dbar_exp = symbology == BARCODE_GS1_128 || symbology == BARCODE_DBAR_EXP
+|| symbology == BARCODE_DBAR_EXPSTK;
+const int gs1 = (symbol->input_mode & 0x07) == GS1_MODE || is_gs1_128_dbar_exp;
+const int is_extra_escaped = (symbol->input_mode & EXTRA_ESCAPE_MODE) && symbol->symbology == BARCODE_CODE128;
+const int is_escaped = (symbol->input_mode & ESCAPE_MODE) || is_extra_escaped;
+const int is_hibc = symbology >= BARCODE_HIBC_128 && symbology <= BARCODE_HIBC_AZTEC;
+const int have_c25checkdigit = symbol->option_2 == 1 || symbol->option_2 == 2;
+const int have_c25inter = (symbology == BARCODE_C25INTER && ((expected_len & 1) || have_c25checkdigit))
+|| symbology == BARCODE_ITF14 || symbology == BARCODE_DPLEIT
+|| symbology == BARCODE_DPIDENT;
+const int is_upcean = (ZBarcode_Cap(symbology, ZINT_CAP_EANUPC) & ZINT_CAP_EANUPC) == ZINT_CAP_EANUPC;
+const int need_dpd_prefix = (symbology == BARCODE_DPD && expected_len == 27 && symbol->option_2 != 1);
+const int is_vin_international = symbology == BARCODE_VIN && (symbol->option_2 & 1);
+char *reduced = gs1 ? (char *) z_alloca(expected_len + 1) : NULL;
+char *escaped = is_escaped ? (char *) z_alloca(expected_len + 1) : NULL;
+char *hibc = is_hibc ? (char *) z_alloca(expected_len + 2 + 1) : NULL;
+char *maxi = symbology == BARCODE_MAXICODE && primary
+? (char *) z_alloca(expected_len + strlen(primary) + 4 + 6 + 9 + 1) : NULL;
+char *vin = is_vin_international ? (char *) z_alloca(expected_len + 1 + 1) : NULL;
+char *c25inter = have_c25inter ? (char *) z_alloca(expected_len + 13 + 1 + 1) : NULL;
+char *upcean = is_upcean ? (char *) z_alloca(expected_len + 1 + 1) : NULL;
+char *ean14_nve18 = symbology == BARCODE_EAN14 || symbology == BARCODE_NVE18
+? (char *) z_alloca(expected_len + 3 + 19 + 1) : NULL;
+char *dpd = need_dpd_prefix ? (char *) z_alloca(28 + 1) : NULL;
+char *pzn = symbology == BARCODE_PZN ? (char *) z_alloca(expected_len + 1 + 1) : NULL;
+char *dxfe = symbology == BARCODE_DXFILMEDGE ? (char *) z_alloca(expected_len * 2 + 1) : NULL;
+int ret;
+int ret_memcmp;
+int i;
+if (ret_buf) {
+ret_buf[0] = '\0';
+}
+if (p_ret_len) {
+*p_ret_len = 0;
+}
+if (is_escaped) {
+ret = escape_char_process_test(symbol, (unsigned char *) expected, &expected_len,
+(unsigned char *) escaped);
+if (ret != 0) {
+sprintf(msg, "escape_char_process %d != 0", ret);
+return 3;
+}
+if (is_extra_escaped) {
+/* Remove any Code 128 special escapes */
+int j = 0;
+int have_manual_ab = 0;
+for (i = 0; i < expected_len; i++) {
+if (escaped[i] == '\\' && i + 2 < expected_len && escaped[i + 1] == '^'
+&& ((escaped[i + 2] >= '@' && escaped[i + 2] <= 'C') || escaped[i + 2] == '1'
+|| escaped[i + 2] == '^')) {
+if (escaped[i + 2] != '^') {
+i += 2;
+if (escaped[i] == 'A' || escaped[i] == 'B') {
+have_manual_ab = 1; /* Hack to help guess if in Code Set C for AIM exception below */
+} else if (escaped[i] == '1') {
+/* FNC1 in 1st position treated as GS1 and in 2nd position AIM, neither transmitted -
+need to skip AIM (single alphabetic or Code Set C double digit)
+TODO: guessing about whether in Code Set C for double digit */
+if (j > 2 || (j == 1 && !(z_isupper(escaped[0]) || z_islower(escaped[0])))
+|| (j == 2 && !(z_isdigit(escaped[0]) && z_isdigit(escaped[1])
+&& !have_manual_ab))) {
+/* Probably not AIM */
+escaped[j++] = 29; /* GS */
+}
+}
+} else {
+escaped[j++] = escaped[i++];
+escaped[j++] = escaped[i++];
+}
+} else {
+escaped[j++] = escaped[i];
+}
+}
+expected_len = j;
+escaped[expected_len] = '\0';
+}
+expected = escaped;
+}
+if (gs1 && symbology != BARCODE_EAN14 && symbology != BARCODE_NVE18) {
+ret = gs1_verify(symbol, (const unsigned char *) expected, expected_len, (unsigned char *) reduced);
+if (ret >= ZINT_ERROR) {
+sprintf(msg, "gs1_verify %d != 0", ret);
+return 4;
+}
+expected_len = (int) strlen(reduced);
+expected = reduced;
+if (primary) {
+/* TODO: */
+}
+} else if (is_hibc) {
+int counter;
+int posns[110];
+hibc[0] = '+';
+memcpy(hibc + 1, expected, expected_len);
+to_upper((unsigned char *) (hibc + 1), expected_len);
+if (not_sane_lookup(TECHNETIUM, sizeof(TECHNETIUM) - 1, (unsigned char *) (hibc + 1), expected_len, posns)) {
+sprintf(msg, "HIBC not_sane_lookup(TECHNETIUM) failed");
+return 5;
+}
+counter = 41;
+for (i = 0; i < expected_len && i < 110; i++) {
+counter += posns[i];
+}
+counter = counter % 43;
+hibc[++expected_len] = TECHNETIUM[counter];
+hibc[++expected_len] = '\0';
+expected = hibc;
+}
+if (symbology == BARCODE_MAXICODE) {
+if (primary && primary[0]) {
+int primary_len = (int) strlen(primary);
+int maxi_len = 0;
+int have_manual_scm = 0;
+if (symbol->option_2 >= 1 && symbol->option_2 <= 100) {
+/* Suppress gcc warning null destination pointer [-Wformat-overflow=] false-positive */
+#if defined(__GNUC__) && !defined(__clang__) && __GNUC__ >= 7
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wformat-overflow="
+#endif
+sprintf(maxi, "[)>\03601\035%02d", symbol->option_2 - 1);
+#if defined(__GNUC__) && !defined(__clang__) && __GNUC__ >= 7
+#pragma GCC diagnostic pop
+#endif
+maxi_len = (int) strlen(maxi);
+} else if (expected_len >= 9 && strncmp(expected, "[)>\03601\035", 7) == 0
+&& z_isdigit(expected[7]) && z_isdigit(expected[8])) {
+have_manual_scm = 1;
+}
+if (primary[0] > '9') {
+sprintf(maxi + maxi_len, "%-6.*s\035%.*s\035%.*s\035", primary_len - 6, primary,
+3, primary + primary_len - 6, 3, primary + primary_len - 3);
+} else {
+if (primary_len == 11 && primary[5] == '8' && primary[6] == '4' && primary[7] == '0') {
+sprintf(maxi + maxi_len, "%.*s0000\035%.*s\035%.*s\035", primary_len - 6, primary,
+3, primary + primary_len - 6, 3, primary + primary_len - 3);
+} else {
+sprintf(maxi + maxi_len, "%.*s\035%.*s\035%.*s\035", primary_len - 6, primary,
+3, primary + primary_len - 6, 3, primary + primary_len - 3);
+}
+}
+maxi_len = (int) strlen(maxi);
+if (have_manual_scm) {
+memmove(maxi + 9, maxi, maxi_len);
+memcpy(maxi, expected, 9);
+memcpy(maxi + maxi_len + 9, expected + 9, expected_len - 9);
+} else {
+memcpy(maxi + maxi_len, expected, expected_len);
+}
+expected = maxi;
+expected_len += maxi_len;
+maxi[expected_len] = '\0';
+}
+} else if (symbology == BARCODE_CODABAR) {
+/* Ignore start A/B/C/D and stop A/B/C/D chars to avoid upper/lowercase issues */
+cmp_buf++;
+cmp_len -= 2;
+expected++;
+expected_len -= 2;
+if (symbol->option_2 == 1 || symbol->option_2 == 2) {
+cmp_len--; /* Too messy to calc the check digit so ignore */
+}
+} else if (is_vin_international) {
+vin[0] = 'I';
+memcpy(vin + 1, expected, expected_len);
+vin[++expected_len] = '\0';
+expected = vin;
+} else if (have_c25inter) {
+if (symbology == BARCODE_C25INTER) {
+if ((expected_len & 1) || have_c25checkdigit) {
+if (((expected_len & 1) && !have_c25checkdigit) || (!(expected_len & 1) && have_c25checkdigit)) {
+c25inter[0] = '0';
+memcpy(c25inter + 1, expected, expected_len);
+expected_len++;
+} else {
+memcpy(c25inter, expected, expected_len);
+}
+if (have_c25checkdigit) {
+c25inter[expected_len] = gs1_check_digit((const unsigned char *) c25inter, expected_len);
+expected_len++;
+}
+c25inter[expected_len] = '\0';
+expected = c25inter;
+}
+} else if (symbology == BARCODE_DPLEIT || symbology == BARCODE_DPIDENT) {
+const int len = symbology == BARCODE_DPLEIT ? 13 : 11;
+int zeroes = len - expected_len;
+unsigned int count = 0;
+int factor = 4;
+for (i = 0; i < zeroes; i++) {
+c25inter[i] = '0';
+}
+memcpy(c25inter + zeroes, expected, expected_len);
+expected_len += zeroes;
+for (i = len - 1; i >= 0; i--) {
+count += factor * ctoi(c25inter[i]);
+factor ^= 0x0D; /* Toggles 4 and 9 */
+}
+c25inter[expected_len] = itoc((10 - (count % 10)) % 10);
+c25inter[++expected_len] = '\0';
+expected = c25inter;
+} else if (symbology == BARCODE_ITF14) {
+int zeroes = 13 - expected_len;
+for (i = 0; i < zeroes; i++) {
+c25inter[i] = '0';
+}
+memcpy(c25inter + zeroes, expected, expected_len);
+expected_len += zeroes;
+c25inter[expected_len] = gs1_check_digit((const unsigned char *) c25inter, 13);
+c25inter[++expected_len] = '\0';
+expected = c25inter;
+}
+} else if (symbology == BARCODE_DBAR_OMN || symbology == BARCODE_DBAR_LTD || symbology == BARCODE_DBAR_OMNSTK
+|| symbology == BARCODE_DBAR_STK) {
+if (expected_len == 13) {
+cmp_len--; /* Too messy to calc the check digit so ignore */
+}
+if (symbology == BARCODE_DBAR_LTD) {
+cmp_buf += 2; /* Ignore prefixed "01" */
+cmp_len -= 2;
+}
+} else if (is_upcean) {
+if (symbology == BARCODE_UPCA && (expected_len == 11 || expected_len == 14 || expected_len == 17)) {
+memcpy(upcean, expected, 11);
+upcean[11] = gs1_check_digit((const unsigned char *) upcean, 11);
+if (expected_len == 14) {
+upcean[12] = ' ';
+memcpy(upcean + 13, expected + 12, 2);
+} else if (expected_len == 17) {
+upcean[12] = ' ';
+memcpy(upcean + 13, expected + 12, 5);
+}
+expected_len++;
+upcean[expected_len] = '\0';
+expected = upcean;
+} else if (symbology == BARCODE_UPCA_CHK && (expected_len == 15 || expected_len == 18)) {
+memcpy(upcean, expected, expected_len);
+upcean[12] = ' ';
+expected = upcean;
+} else if (symbology == BARCODE_UPCE && (expected_len == 7 || expected_len == 10 || expected_len == 13)) {
+char equivalent[11];
+memcpy(upcean, expected, 7);
+memcpy(equivalent, upcean, 3);
+memset(equivalent + 3, '0', 8);
+switch (upcean[6]) {
+case '0': case '1': case '2':
+equivalent[3] = upcean[6];
+equivalent[8] = upcean[3];
+equivalent[9] = upcean[4];
+equivalent[10] = upcean[5];
+break;
+case '3':
+equivalent[3] = upcean[3];
+equivalent[9] = upcean[4];
+equivalent[10] = upcean[5];
+break;
+case '4':
+equivalent[3] = upcean[3];
+equivalent[4] = upcean[4];
+equivalent[10] = upcean[5];
+break;
+case '5': case '6': case '7': case '8': case '9':
+equivalent[3] = upcean[3];
+equivalent[4] = upcean[4];
+equivalent[5] = upcean[5];
+equivalent[10] = upcean[6];
+break;
+}
+upcean[7] = gs1_check_digit((const unsigned char *) equivalent, 11);
+if (expected_len == 10) {
+upcean[8] = ' ';
+memcpy(upcean + 9, expected + 8, 2);
+} else if (expected_len == 13) {
+upcean[8] = ' ';
+memcpy(upcean + 9, expected + 8, 5);
+}
+expected_len++;
+upcean[expected_len] = '\0';
+expected = upcean;
+} else if (symbology == BARCODE_UPCE_CHK && (expected_len == 11 || expected_len == 14)) {
+memcpy(upcean, expected, expected_len);
+upcean[8] = ' ';
+expected = upcean;
+} else if (symbology == BARCODE_EANX && (expected_len == 12 || expected_len == 15 || expected_len == 18)) {
+memcpy(upcean, expected, 12);
+upcean[12] = gs1_check_digit((const unsigned char *) upcean, 12);
+if (expected_len == 15) {
+upcean[13] = ' ';
+memcpy(upcean + 14, expected + 13, 2);
+} else if (expected_len == 18) {
+upcean[13] = ' ';
+memcpy(upcean + 14, expected + 13, 5);
+}
+expected_len++;
+upcean[expected_len] = '\0';
+expected = upcean;
+} else if (symbology == BARCODE_EANX && (expected_len == 16 || expected_len == 19)) {
+memcpy(upcean, expected, expected_len);
+upcean[13] = ' ';
+expected = upcean;
+} else if (symbology == BARCODE_EANX && (expected_len == 7
+|| (strchr(expected, '+') != NULL && (expected_len == 10 || expected_len == 13)))) {
+memcpy(upcean, expected, 7);
+upcean[7] = gs1_check_digit((const unsigned char *) upcean, 7);
+if (expected_len == 10) {
+upcean[8] = ' ';
+memcpy(upcean + 9, expected + 8, 2);
+} else if (expected_len == 13) {
+upcean[8] = ' ';
+memcpy(upcean + 9, expected + 8, 5);
+}
+expected_len++;
+upcean[expected_len] = '\0';
+expected = upcean;
+} else if ((symbology == BARCODE_EANX_CHK || symbology == BARCODE_ISBNX)
+&& (expected_len == 16 || expected_len == 19)) {
+memcpy(upcean, expected, expected_len);
+upcean[13] = ' ';
+expected = upcean;
+} else if (symbology == BARCODE_EANX_CHK && strchr(expected, '+') != NULL
+&& (expected_len == 11 || expected_len == 14)) {
+memcpy(upcean, expected, expected_len);
+upcean[8] = ' ';
+expected = upcean;
+}
+} else if (symbology == BARCODE_EAN14 || symbology == BARCODE_NVE18) {
+int len = symbology == BARCODE_NVE18 ? 17 : 13;
+int zeroes = expected_len < len ? len - expected_len: 0;
+ean14_nve18[0] = '0';
+ean14_nve18[1] = symbology == BARCODE_NVE18 ? '0' : '1';
+memset(ean14_nve18 + 2, '0', zeroes);
+memcpy(ean14_nve18 + 2 + zeroes, expected, expected_len);
+ean14_nve18[len + 2] = gs1_check_digit((unsigned char *) (ean14_nve18 + 2), len);
+expected = ean14_nve18;
+expected_len += zeroes + 3;
+} else if (need_dpd_prefix) {
+dpd[0] = '%';
+memcpy(dpd + 1, expected, expected_len);
+expected = dpd;
+expected_len++;
+} else if (symbology == BARCODE_PZN) {
+/* Add hyphen at start */
+pzn[0] = '-';
+memcpy(pzn + 1, expected, expected_len);
+if ((symbol->option_2 == 0 && expected_len != 8) || (symbol->option_2 == 1 && expected_len != 7)) {
+cmp_len--; /* Don't bother with check digit */
+}
+expected = pzn;
+expected_len++;
+} else if (symbology == BARCODE_DXFILMEDGE) {
+const int dx_info_len = posn(expected, '/');
+if (dx_info_len != -1) {
+char frame_info[20];
+assert(strlen(expected + dx_info_len + 1) < sizeof(frame_info));
+strcpy(frame_info, expected + dx_info_len + 1);
+to_upper((unsigned char *) frame_info, (int) strlen(frame_info));
+if (!textUtilZXingCPPDX(expected, dx_info_len, cmp_buf, dxfe)) {
+memcpy(dxfe, expected, dx_info_len);
+dxfe[dx_info_len] = '\0';
+}
+if (strcmp(frame_info, "S") == 0 || strcmp(frame_info, "X") == 0) {
+strcat(dxfe, "/62");
+} else if (strcmp(frame_info, "SA") == 0 || strcmp(frame_info, "XA") == 0) {
+strcat(dxfe, "/62A");
+} else if (strcmp(frame_info, "K") == 0 || strcmp(frame_info, "00") == 0) {
+strcat(dxfe, "/63");
+} else if (strcmp(frame_info, "KA") == 0 || strcmp(frame_info, "00A") == 0) {
+strcat(dxfe, "/63A");
+} else if (strcmp(frame_info, "F") == 0) {
+strcat(dxfe, "/0");
+} else if (strcmp(frame_info, "FA") == 0) {
+strcat(dxfe, "/0A");
+} else {
+const char *stripped;
+if ((stripped = testUtilZXingCPPLeadingZeroes(frame_info)) != frame_info) {
+strcat(dxfe, "/");
+strcat(dxfe, stripped);
+} else {
+strcat(dxfe, expected + dx_info_len);
+}
+}
+expected = dxfe;
+expected_len = (int) strlen(expected);
+to_upper((unsigned char *) expected, expected_len);
+} else {
+if (textUtilZXingCPPDX(expected, expected_len, cmp_buf, dxfe)) {
+expected = dxfe;
+expected_len = (int) strlen(expected);
+}
+}
+}
+if (ret_buf) {
+memcpy(ret_buf, expected, expected_len);
+}
+if (p_ret_len) {
+*p_ret_len = expected_len;
+}
+if (cmp_len != expected_len) {
+sprintf(msg, "cmp_len %d != expected_len %d", cmp_len, expected_len);
+return 2;
+}
+ret_memcmp = memcmp(cmp_buf, expected, expected_len);
+if (ret_memcmp != 0) {
+for (i = 0; i < expected_len; i++) {
+if (cmp_buf[i] != expected[i]) {
+break;
+}
+}
+sprintf(msg, "memcmp %d != 0, at %d, len %d", ret_memcmp, i, expected_len);
+return ret_memcmp;
+}
+return 0;
+}
+int testUtilZXingCPPCmpSegs(struct zint_symbol *symbol, char *msg, char *cmp_buf, int cmp_len,
+const struct zint_seg segs[], const int seg_count, const char *primary, char *ret_buf, int *p_ret_len) {
+int expected_len = segs_length(segs, seg_count);
+char *expected = (char *) z_alloca(expected_len + 1);
+char *s = expected;
+int i;
+for (i = 0; i < seg_count; i++) {
+int len = segs[i].length == -1 ? (int) ustrlen(segs[i].source) : segs[i].length;
+memcpy(s, segs[i].source, len);
+s += len;
+}
+*s = '\0';
+return testUtilZXingCPPCmp(symbol, msg, cmp_buf, cmp_len, expected, expected_len, primary, ret_buf, p_ret_len);
+}
+/* vim: set ts=4 sw=4 et : */

Mercurial > hgrepos > Python2 > PyMuPDF

comparison mupdf-source/thirdparty/zint/backend/tests/testcommon.c @ 2:b50eed0cc0ef upstream