void test_split2(void)
{
QRinput *input;
QRinput_List *list;
int err = 0;
testStart("Split test: single typed strings (num)");
input = QRinput_new2(0, QR_ECLEVEL_L);
Split_splitStringToQRinput("0123", input, QR_MODE_8, 0);
list = input->head;
if(inputTest(list, "n", 4)) {
err++;
}
testEnd(err);
QRinput_free(input);
err = 0;
testStart("Split test: single typed strings (num2)");
input = QRinput_new2(0, QR_ECLEVEL_L);
Split_splitStringToQRinput("12345678901234567890", input, QR_MODE_KANJI, 0);
list = input->head;
if(inputTest(list, "n", 20)) {
err++;
}
testEnd(err);
QRinput_free(input);
}
void test_split4(void)
{
QRinput *input;
QRinput *i1, *i2;
int s1, s2, size;
#define CHUNKA "ABCDEFGHIJK"
#define CHUNKB "123456"
#define CHUNKC "1234567"
testStart("Split test: an and num entries");
input = QRinput_new2(0, QR_ECLEVEL_L);
Split_splitStringToQRinput(CHUNKA/**/CHUNKB, input, QR_MODE_8, 0);
i1 = QRinput_new();
QRinput_append(i1, QR_MODE_AN, 17, (unsigned char *)CHUNKA/**/CHUNKB);
i2 = QRinput_new();
QRinput_append(i2, QR_MODE_AN, 11, (unsigned char *)CHUNKA);
QRinput_append(i2, QR_MODE_NUM, 6, (unsigned char *)CHUNKB);
size = inputSize(input);
s1 = inputSize(i1);
s2 = inputSize(i2);
testEndExp(size == ((s1 < s2)?s1:s2));
QRinput_free(input);
QRinput_free(i1);
QRinput_free(i2);
testStart("Split test: num and an entries");
input = QRinput_new2(0, QR_ECLEVEL_L);
Split_splitStringToQRinput(CHUNKB/**/CHUNKA, input, QR_MODE_8, 0);
i1 = QRinput_new();
QRinput_append(i1, QR_MODE_AN, 17, (unsigned char *)CHUNKB/**/CHUNKA);
i2 = QRinput_new();
QRinput_append(i2, QR_MODE_NUM, 6, (unsigned char *)CHUNKB);
QRinput_append(i2, QR_MODE_AN, 11, (unsigned char *)CHUNKA);
size = inputSize(input);
s1 = inputSize(i1);
s2 = inputSize(i2);
testEndExp(size == ((s1 < s2)?s1:s2));
QRinput_free(input);
QRinput_free(i1);
QRinput_free(i2);
testStart("Split test: num and an entries (should be splitted)");
input = QRinput_new2(0, QR_ECLEVEL_L);
Split_splitStringToQRinput(CHUNKC/**/CHUNKA, input, QR_MODE_8, 0);
i1 = QRinput_new();
QRinput_append(i1, QR_MODE_AN, 18, (unsigned char *)CHUNKC/**/CHUNKA);
i2 = QRinput_new();
QRinput_append(i2, QR_MODE_NUM, 7, (unsigned char *)CHUNKC);
QRinput_append(i2, QR_MODE_AN, 11, (unsigned char *)CHUNKA);
size = inputSize(input);
s1 = inputSize(i1);
s2 = inputSize(i2);
testEndExp(size == ((s1 < s2)?s1:s2));
QRinput_free(input);
QRinput_free(i1);
QRinput_free(i2);
}
void test_toupper(void)
{
QRinput *input;
QRinput_List *list;
int err = 0;
testStart("Split test: check dupAndToUpper (lower->upper)");
input = QRinput_new2(0, QR_ECLEVEL_L);
Split_splitStringToQRinput("abcde", input, QR_MODE_8, 0);
list = input->head;
if(inputTest(list, "a", 5)) {
err++;
}
if(strncmp((char *)list->data, "ABCDE", list->size)) {
err++;
}
testEnd(err);
QRinput_free(input);
err = 0;
testStart("Split test: check dupAndToUpper (kanji)");
input = QRinput_new2(0, QR_ECLEVEL_L);
Split_splitStringToQRinput("\x83n\x83q\x83t\x83w\x83z", input, QR_MODE_KANJI, 0);
list = input->head;
if(inputTest(list, "k", 10)) {
printQRinputInfo(input);
err++;
}
if(strncmp((char *)list->data, "\x83n\x83q\x83t\x83w\x83z", list->size)) {
err++;
}
testEnd(err);
QRinput_free(input);
err = 0;
testStart("Split test: check dupAndToUpper (8bit)");
input = QRinput_new2(0, QR_ECLEVEL_L);
Split_splitStringToQRinput("\x83n\x83q\x83t\x83w\x83z", input, QR_MODE_8, 0);
list = input->head;
if(inputTest(list, "8", 10)) {
printQRinputInfo(input);
err++;
}
if(strncmp((char *)list->data, "\x83N\x83Q\x83T\x83W\x83Z", list->size)) {
err++;
}
testEnd(err);
QRinput_free(input);
}
void test_encodeTooLongMQR(void)
{
QRcode *code;
char *data[] = {"012345", "ABC0EFG", "0123456789", "0123456789ABCDEFG"};
testStart("Encode too large data for MQR.");
code = QRcode_encodeStringMQR(data[0], 1, QR_ECLEVEL_L, QR_MODE_8, 0);
assert_null(code, "6 byte length numeric string was accepted to version 1.\n");
assert_equal(errno, ERANGE, "errno != ERANGE\n");
code = QRcode_encodeStringMQR(data[1], 2, QR_ECLEVEL_L, QR_MODE_8, 0);
assert_null(code, "7 byte length alphanumeric string was accepted to version 2.\n");
assert_equal(errno, ERANGE, "errno != ERANGE\n");
code = QRcode_encodeString8bitMQR(data[2], 3, QR_ECLEVEL_L);
assert_null(code, "9 byte length 8bit string was accepted to version 3.\n");
assert_equal(errno, ERANGE, "errno != ERANGE\n");
code = QRcode_encodeString8bitMQR(data[3], 4, QR_ECLEVEL_L);
assert_null(code, "16 byte length 8bit string was accepted to version 4.\n");
assert_equal(errno, ERANGE, "errno != ERANGE\n");
testFinish();
if(code != NULL) {
printQRcode(code);
QRcode_free(code);
}
}
void test_struct_semilong(void)
{
QRcode_List *codes, *list;
const char *str = "asdfasdfasdfasdfasdfASDFASDASDFASDFAsdfasdfasdfasdASDFASDFADSADadsfasdf";
int num, size;
testStart("Testing semi-long structured-append symbols");
codes = QRcode_encodeString8bitStructured(str, 1, QR_ECLEVEL_L);
list = codes;
num = 0;
while(list != NULL) {
num++;
assert_equal(list->code->version, 1, "version number is %d (1 expected)\n", list->code->version);
list = list->next;
}
size = QRcode_List_size(codes);
assert_equal(num, size, "QRcode_List_size returns wrong size?");
QRcode_List_free(codes);
codes = QRcode_encodeStringStructured(str, 1, QR_ECLEVEL_L, QR_MODE_8, 1);
list = codes;
num = 0;
while(list != NULL) {
num++;
assert_equal(list->code->version, 1, "version number is %d (1 expected)\n", list->code->version);
list = list->next;
}
size = QRcode_List_size(codes);
assert_equal(num, size, "QRcode_List_size returns wrong size?");
QRcode_List_free(codes);
testFinish();
}
void test_encode(void)
{
QRinput *stream;
char num[9] = "01234567";
unsigned char *frame;
int err = 0;
int x, y, w;
int mask;
QRcode *qrcode;
testStart("Test encode (1-M)");
stream = QRinput_new();
QRinput_append(stream, QR_MODE_NUM, 8, (unsigned char *)num);
for(mask=0; mask<8; mask++) {
QRinput_setVersion(stream, 1);
QRinput_setErrorCorrectionLevel(stream, QR_ECLEVEL_M);
qrcode = QRcode_encodeMask(stream, mask);
w = qrcode->width;
frame = qrcode->data;
for(y=0; y<w; y++) {
for(x=0; x<w; x++) {
if(((m1pat[mask][y] >> (20-x)) & 1) != (frame[y*w+x]&1)) {
printf("Diff in mask=%d (%d,%d)\n", mask, x, y);
err++;
}
}
}
QRcode_free(qrcode);
}
QRinput_free(stream);
testEnd(err);
}
void test_fillerMQR(void)
{
unsigned char *frame;
int i, j, w, e, length;
testStart("Micro QR Code Frame filler test");
for(i=1; i<=MQRSPEC_VERSION_MAX; i++) {
length = MQRspec_getDataLengthBit(i, QR_ECLEVEL_L)
+ MQRspec_getECCLength(i, QR_ECLEVEL_L) * 8;
frame = FrameFiller_testMQR(i);
if(frame == NULL) {
assert_nonnull(frame, "Something wrong in version %d\n", i);
} else {
w = MQRspec_getWidth(i);
e = 0;
for(j=0; j<w*w; j++) {
if(frame[j] == 0) e++;
}
assert_zero(e, "Not filled bit is found. (%d,%d)\n", j%w,j/w);
if(i & 1) {
e = w * 9 + 1;
} else {
e = w * (w - 1) + 1;
}
assert_equal(frame[e], (unsigned char)((length - 1) & 127) | 0x80,
"Number of cell does not match in version %d.\n", i);
free(frame);
}
}
testFinish();
}
void test_padding(void)
{
QRinput *input;
BitStream *bstream;
int i, size;
char data[] = "0123456789ABCDeFG";
unsigned char c;
testStart("Padding bit check. (less than 5 bits)");
input = QRinput_new2(1, QR_ECLEVEL_L);
QRinput_append(input, QR_MODE_8, 17, (unsigned char *)data);
bstream = BitStream_new();
QRinput_getBitStream(input, bstream);
size = BitStream_size(bstream);
assert_equal(size, 152, "# of bit is incorrect (%d != 152).\n", size);
c = 0;
for(i=0; i<4; i++) {
c += bstream->data[size - i - 1];
}
assert_zero(c, "Padding bits are not zero.");
testFinish();
QRinput_free(input);
BitStream_free(bstream);
}
void test_format(void)
{
unsigned char *frame, *masked;
int version, mask, width, dmask;
QRecLevel level, dlevel;
QRcode *code;
int ret;
testStart("Checking format info.");
for(version=1; version<=QRSPEC_VERSION_MAX; version++) {
frame = QRspec_newFrame(version);
width = QRspec_getWidth(version);
for(level=0; level<4; level++) {
for(mask=0; mask<8; mask++) {
masked = Mask_makeMask(width, frame, mask, level);
code = QRcode_new(version, width, masked);
ret = QRcode_decodeFormat(code, &dlevel, &dmask);
assert_zero(ret, "Something wrong in format info.\n");
assert_equal(dlevel, level, "Decoded level is wrong: %d, expected %d", dlevel, level);
assert_equal(dmask, mask, "Decoded mask is wrong: %d, expected %d", dlevel, level);
QRcode_free(code);
}
}
free(frame);
}
testFinish();
}
void test_maskEvaluation(void)
{
static const int w = 11;
unsigned char pattern[w*w];
int i, score;
memset(pattern, 0, w*w);
testStart("Test mask evaluation");
score = MMask_evaluateSymbol(w, pattern);
assert_equal(score, 0, "Mask score caluculation is incorrect. (score=%d (%d expected)\n", score, 0);
for(i=0; i<w; i++) {
pattern[(w-1) * w + i] = 1;
}
score = MMask_evaluateSymbol(w, pattern);
assert_equal(score, 16 + w - 1, "Mask score caluculation is incorrect. (score=%d) (%d expected)\n", score, 16 + w - 1);
for(i=0; i<w; i++) {
pattern[(w-1) * w + i] = 0;
pattern[i * w + w - 1] = 1;
}
score = MMask_evaluateSymbol(w, pattern);
assert_equal(score, 16 + w - 1, "Mask score caluculation is incorrect. (score=%d) (%d expected)\n", score, 16 + w - 1);
for(i=0; i<w; i++) {
pattern[(w-1) * w + i] = 1;
pattern[i * w + w - 1] = 1;
}
score = MMask_evaluateSymbol(w, pattern);
assert_equal(score, 16 * (w - 1) + w - 1, "Mask score caluculation is incorrect. (score=%d) (%d expected)\n", score, 16 * (w - 1) + w - 1);
testFinish();
}
/* .#.#.#.#.#
* #.#.#.#.#.
* ..##..##..
* ##..##..##
* ...###...#
* ###...###.
* ....####..
* ####....##
* .....#####
* #####.....
*/
void test_eval2(void)
{
unsigned char *frame;
int w = 10;
int demerit;
int x;
frame = (unsigned char *)malloc(w * w);
testStart("Test mask evaluation (run length penalty check)");
for(x=0; x<w; x++) {
frame[ x] = x & 1;
frame[w + x] = (x & 1) ^ 1;
frame[w*2 + x] = (x / 2) & 1;
frame[w*3 + x] = ((x / 2) & 1) ^ 1;
frame[w*4 + x] = (x / 3) & 1;
frame[w*5 + x] = ((x / 3) & 1) ^ 1;
frame[w*6 + x] = (x / 4) & 1;
frame[w*7 + x] = ((x / 4) & 1) ^ 1;
frame[w*8 + x] = (x / 5) & 1;
frame[w*9 + x] = ((x / 5) & 1) ^ 1;
}
demerit = Mask_evaluateSymbol(w, frame);
testEndExp(demerit == N1 * 4 + N2 * 4);
free(frame);
}
void test_eccTable(void)
{
int i, j;
int ecc;
int data;
int err = 0;
int spec[5];
testStart("Checking ECC table.");
for(i=1; i<=QRSPEC_VERSION_MAX; i++) {
for(j=0; j<4; j++) {
QRspec_getEccSpec(i, (QRecLevel)j, spec);
data = QRspec_rsBlockNum1(spec) * QRspec_rsDataCodes1(spec)
+ QRspec_rsBlockNum2(spec) * QRspec_rsDataCodes2(spec);
ecc = QRspec_rsBlockNum1(spec) * QRspec_rsEccCodes1(spec)
+ QRspec_rsBlockNum2(spec) * QRspec_rsEccCodes2(spec);
if(data + ecc != QRspec_getDataLength(i, (QRecLevel)j) + QRspec_getECCLength(i, (QRecLevel)j)) {
printf("Error in version %d, level %d: invalid size\n", i, j);
printf("%d %d %d %d %d %d\n", spec[0], spec[1], spec[2], spec[3], spec[4], spec[2]);
err++;
}
if(ecc != QRspec_getECCLength(i, (QRecLevel)j)) {
printf("Error in version %d, level %d: invalid data\n", i, j);
printf("%d %d %d %d %d %d\n", spec[0], spec[1], spec[2], spec[3], spec[4], spec[2]);
err++;
}
}
}
testEnd(err);
}
/* This test is used to check positions of alignment pattern. See Appendix E
* (pp.71) of JIS X0510:2004 and compare to the output. Before comment out
* this test, change the value of the pattern marker's center dot from 0xa1
* to 0xb1 (QRspec_putAlignmentMarker() : finder).
*/
void test_alignment(void)
{
unsigned char *frame;
int i, x, y, width, c;
testStart("Checking alignment pattern.");
for(i=2; i<=QRSPEC_VERSION_MAX; i++) {
printf("%2d", i);
frame = QRspec_newFrame(i);
width = QRspec_getWidth(i);
c = 0;
for(x=0; x<width * width; x++) {
if(frame[x] == 0xb1) {
c++;
}
}
printf("|%2d| 6", c);
y = width - 7;
for(x=0; x < width; x++) {
if(frame[y * width + x] == 0xb1) {
printf(", %3d", x);
}
}
printf("\n");
free(frame);
}
testFinish();
}
void test_newframe(void)
{
unsigned char buf[QRSPEC_WIDTH_MAX * QRSPEC_WIDTH_MAX];
int i, width;
size_t len;
FILE *fp;
unsigned char *frame;
QRcode *qrcode;
unsigned int version;
testStart("Checking newly created frame.");
fp = fopen("frame", "rb");
if(fp == NULL) {
perror("Failed to open \"frame\":");
abort();
}
for(i=1; i<=QRSPEC_VERSION_MAX; i++) {
frame = QRspec_newFrame(i);
width = QRspec_getWidth(i);
len = fread(buf, 1, width * width, fp);
if((int)len != width * width) {
perror("Failed to read the pattern file:");
abort();
}
assert_zero(memcmp(frame, buf, len), "frame pattern mismatch (version %d)\n", i);
qrcode = QRcode_new(i, width, frame);
version = QRcode_decodeVersion(qrcode);
assert_equal(version, i, "Decoded version number is wrong: %d, expected %d.\n", version, i);
QRcode_free(qrcode);
}
testFinish();
fclose(fp);
}
void test_encodeECI(void)
{
QRinput *input;
BitStream *bstream;
unsigned char str[] = {0xa1, 0xa2, 0xa3, 0xa4, 0xa5};
char *correct = "0111 00001001 0100 00000101 10100001 10100010 10100011 10100100 10100101";
int ret;
testStart("Encoding characters with ECI header.");
input = QRinput_new();
ret = QRinput_appendECIheader(input, 9);
assert_zero(ret, "Valid ECI header rejected.\n");
ret = QRinput_append(input, QR_MODE_8, 5, str);
assert_zero(ret, "Failed to append characters.\n");
bstream = BitStream_new();
QRinput_mergeBitStream(input, bstream);
assert_nonnull(bstream, "Failed to merge.\n");
if(bstream != NULL) {
ret = ncmpBin(correct, bstream, 64);
assert_zero(ret, "Encodation of ECI header was invalid.\n");
BitStream_free(bstream);
}
QRinput_free(input);
testFinish();
}
void test_decodeVeryLong(void)
{
char str[4000];
int i;
QRcode *qrcode;
QRdata *qrdata;
testStart("Test code words (very long string).");
for(i=0; i<3999; i++) {
str[i] = decodeAnTable[(int)drand(45)];
}
str[3999] = '\0';
qrcode = QRcode_encodeString(str, 0, QR_ECLEVEL_L, QR_MODE_8, 0);
qrdata = QRcode_decode(qrcode);
assert_nonnull(qrdata, "Failed to decode.\n");
if(qrdata != NULL) {
assert_equal(strlen(str), qrdata->size, "Lengths of input/output mismatched.\n");
assert_zero(strncmp(str, (char *)(qrdata->data), qrdata->size), "Decoded data %s is different from the original %s\n", qrdata->data, str);
}
if(qrdata != NULL) QRdata_free(qrdata);
if(qrcode != NULL) QRcode_free(qrcode);
testFinish();
}
void test_iterate()
{
int i;
QRinput *stream;
char num[9] = "01234567";
unsigned char *data;
QRRawCode *raw;
int err = 0;
testStart("Test getCode (1-L)");
stream = QRinput_new();
QRinput_setVersion(stream, 1);
QRinput_setErrorCorrectionLevel(stream, QR_ECLEVEL_L);
QRinput_append(stream, QR_MODE_NUM, 8, (unsigned char *)num);
raw = QRraw_new(stream);
data = raw->datacode;
for(i=0; i<raw->dataLength; i++) {
if(data[i] != QRraw_getCode(raw)) {
err++;
}
}
QRinput_free(stream);
QRraw_free(raw);
testEnd(err);
}
void test_appendBytes(void)
{
BitStream *bstream;
unsigned char data[8];
char correct[] = "10001010111111111111111100010010001101000101011001111000";
testStart("Append Bytes");
bstream = BitStream_new();
data[0] = 0x8a;
BitStream_appendBytes(bstream, 1, data);
assert_zero(ncmpBin(correct, bstream, 8), "Internal data is incorrect.");
data[0] = 0xff;
data[1] = 0xff;
BitStream_appendBytes(bstream, 2, data);
assert_zero(ncmpBin(correct, bstream, 24), "Internal data is incorrect.\n");
data[0] = 0x12;
data[1] = 0x34;
data[2] = 0x56;
data[3] = 0x78;
BitStream_appendBytes(bstream, 4, data);
assert_zero(cmpBin(correct, bstream), "Internal data is incorrect.\n");
testFinish();
BitStream_free(bstream);
}
void test_oddBitCalcMQR(void)
{
/* test issue #25 (odd bits calculation bug) */
/* test pattern contributed by vlad417 */
TestString tests[] = {
{"46194", 1, QR_ECLEVEL_L, QR_MODE_8, 1},
{"WBA5Y47YPQQ", 3, QR_ECLEVEL_L, QR_MODE_8, 1}
};
QRcode *qrcode;
QRdata *qrdata;
int i;
testStart("Odd bits calculation bug checking (MQR).");
for(i=0; i<_countof(tests); i++) {
qrcode = QRcode_encodeStringMQR(tests[i].str,
tests[i].version,
tests[i].level,
tests[i].hint,
tests[i].casesensitive);
assert_nonnull(qrcode, "Failed to encode: %s\n", tests[i].str);
if(qrcode == NULL) continue;
qrdata = QRcode_decodeMQR(qrcode);
assert_nonnull(qrdata, "Failed to decode.\n");
assert_zero(strcmp((char *)qrdata->data, tests[i].str), "Decoded data (%s) mismatched (%s)\n", (char *)qrdata->data, tests[i].str);
if(qrdata != NULL) QRdata_free(qrdata);
QRcode_free(qrcode);
}
testFinish();
}
void test_format(void)
{
unsigned int format;
int version, l, mask;
int type;
int err = 0;
testStart("Format info test");
for(version=1; version<=MQRSPEC_VERSION_MAX; version++) {
for(l=QR_ECLEVEL_L; l<=QR_ECLEVEL_Q; l++) {
for(mask=0; mask<4; mask++) {
format = MQRspec_getFormatInfo(mask, version, (QRecLevel)l);
type = typeTable[version - 1][l];
if(type == -1) {
if(format != 0) {
printf("Error in version %d, level %d, mask %d\n",
version, l, mask);
err++;
}
} else {
if(format != calcFormatInfo(type, mask)) {
printf("Error in version %d, level %d, mask %d\n",
version, l, mask);
err++;
}
}
}
}
}
testEnd(err);
}
void test_toByte_4bitpadding(void)
{
BitStream *bstream;
unsigned char *result;
testStart("Convert to a byte array");
bstream = BitStream_new();
BitStream_appendNum(bstream, 4, 0xb);
result = BitStream_toByte(bstream);
assert_equal(result[0], 0xb0, "incorrect paddings\n");
BitStream_free(bstream);
free(result);
bstream = BitStream_new();
BitStream_appendNum(bstream, 12, 0x335);
result = BitStream_toByte(bstream);
assert_equal(result[0], 0x33, "incorrect paddings\n");
assert_equal(result[1], 0x50, "incorrect paddings\n");
BitStream_free(bstream);
free(result);
testFinish();
}
void test_parity(void)
{
QRinput *input;
QRinput_Struct *s;
const char *text = "an example of four Structured Append symbols,";
const char *str[4] = {
"an example ",
"of four Str",
"uctured Appe",
"nd symbols,"};
unsigned char p1, p2;
int i, len;
testStart("Testing parity calc.");
s = QRinput_Struct_new();
for(i=0; i<4; i++) {
input = QRinput_new2(1, QR_ECLEVEL_M);
QRinput_append(input, QR_MODE_8, strlen(str[i]), (unsigned char *)str[i]);
QRinput_Struct_appendInput(s, input);
}
QRinput_Struct_insertStructuredAppendHeaders(s);
p1 = s->parity;
p2 = 0;
len = strlen(text);
for(i=0; i<len; i++) {
p2 ^= text[i];
}
assert_equal(p1, p2, "Parity numbers didn't match. (%02x should be %02x).\n", p1, p2);
testFinish();
QRinput_Struct_free(s);
}
void test_null_free(void)
{
testStart("Testing free NULL pointers");
assert_nothing(QRinput_free(NULL), "Check QRinput_free(NULL).\n");
assert_nothing(QRinput_Struct_free(NULL), "Check QRinput_Struct_free(NULL).\n");
testFinish();
}
void test_struct_split_example(void)
{
QRinput *input;
QRinput_Struct *s;
QRinput_InputList *e;
QRinput_List *l;
const char *str[4] = { "an example ", "of four Str", "uctured Appe", "nd symbols,"};
int i;
BitStream *bstream;
testStart("Testing the example of structured-append symbols");
s = QRinput_Struct_new();
for(i=0; i<4; i++) {
input = QRinput_new2(1, QR_ECLEVEL_M);
QRinput_append(input, QR_MODE_8, strlen(str[i]), (unsigned char *)str[i]);
QRinput_Struct_appendInput(s, input);
}
QRinput_Struct_insertStructuredAppendHeaders(s);
e = s->head;
i = 0;
while(e != NULL) {
bstream = QRinput_mergeBitStream(e->input);
BitStream_free(bstream);
l = e->input->head->next;
assert_equal(l->mode, QR_MODE_8, "#%d: wrong mode (%d).\n", i, l->mode);
assert_equal(e->input->level, QR_ECLEVEL_M, "#%d: wrong level (%d).\n", i, e->input->level);
e = e->next;
i++;
}
testFinish();
QRinput_Struct_free(s);
}
void test_struct_insertStructuredAppendHeaders(void)
{
QRinput *input;
QRinput_Struct *s;
QRinput_InputList *p;
int i;
testStart("Insert structured-append headers to a QRinput_Struct.");
s = QRinput_Struct_new();
for(i=0; i<10; i++) {
input = QRinput_new();
QRinput_append(input, QR_MODE_8, 1, (unsigned char *)"A");
QRinput_Struct_appendInput(s, input);
}
QRinput_Struct_insertStructuredAppendHeaders(s);
p = s->head;
i = 1;
while(p != NULL) {
assert_equal(p->input->head->mode, QR_MODE_STRUCTURE, "a structured-append header is not inserted.");
assert_equal(p->input->head->data[0], 10, "size of the structured-header is wrong: #%d, %d should be %d\n", i, p->input->head->data[0], 10);
assert_equal(p->input->head->data[1], i, "index of the structured-header is wrong: #%d, %d should be %d\n", i, p->input->head->data[1], i);
assert_equal(p->input->head->data[2], 0, "parity of the structured-header is wrong: #%d\n", i);
p = p->next;
i++;
}
testFinish();
QRinput_Struct_free(s);
}
void test_struct_listop(void)
{
QRinput_Struct *s;
QRinput *inputs[5];
QRinput_InputList *l;
int i, ret;
testStart("QRinput_Struct list operation test.");
s = QRinput_Struct_new();
QRinput_Struct_setParity(s, 10);
assert_nonnull(s, "QRinput_Struct_new() failed.");
assert_equal(s->parity, 10, "QRinput_Struct_setParity() failed.");
for(i=0; i<5; i++) {
inputs[i] = QRinput_new();
QRinput_append(inputs[i], QR_MODE_AN, 5, (unsigned char *)"ABCDE");
ret = QRinput_Struct_appendInput(s, inputs[i]);
}
assert_equal(ret, 5, "QRinput_Struct_appendInput() returns wrong num?");
assert_equal(s->size, 5, "QRiput_Struct.size counts wrong number.");
l = s->head;
i = 0;
while(l != NULL) {
assert_equal(l->input, inputs[i], "QRinput_Struct input list order would be wrong?");
l = l->next;
i++;
}
QRinput_Struct_free(s);
testFinish();
}
void test_encodeNumericPadded2(void)
{
QRinput *stream;
char num[8] = "0123456";
char *correct;
char *correctHead = "000100000001110000001100010101100101100000000000";
BitStream *bstream;
int flag, i;
testStart("Encoding numeric stream. (7 digits)(padded)");
stream = QRinput_new();
QRinput_append(stream, QR_MODE_NUM, 7, (unsigned char *)num);
bstream = QRinput_getBitStream(stream);
correct = (char *)malloc(19 * 8 + 1);
correct[0] = '\0';
strcat(correct, correctHead);
for(i=0; i<13; i++) {
strcat(correct, (i&1)?"00010001":"11101100");
}
flag = cmpBin(correct, bstream);
testEnd(flag);
free(correct);
QRinput_free(stream);
BitStream_free(bstream);
}
void test_splitentry2(void)
{
QRinput *i1, *i2;
QRinput_List *e;
const char *str = "abcdefghij";
int size1, size2, i;
unsigned char *d1, *d2;
testStart("Testing QRinput_splitEntry. (next != NULL)");
i1 = QRinput_new();
QRinput_append(i1, QR_MODE_8, strlen(str), (unsigned char *)str);
QRinput_append(i1, QR_MODE_8, strlen(str), (unsigned char *)str);
i2 = QRinput_dup(i1);
e = i2->head;
e = i2->head;
QRinput_splitEntry(e, 4);
size1 = size2 = 0;
e = i1->head;
while(e != NULL) {
size1 += e->size;
e = e->next;
}
e = i2->head;
while(e != NULL) {
size2 += e->size;
e = e->next;
}
d1 = (unsigned char *)malloc(size1);
e = i1->head;
i = 0;
while(e != NULL) {
memcpy(&d1[i], e->data, e->size);
i += e->size;
e = e->next;
}
d2 = (unsigned char *)malloc(size2);
e = i2->head;
i = 0;
while(e != NULL) {
memcpy(&d2[i], e->data, e->size);
i += e->size;
e = e->next;
}
assert_equal(size1, size2, "sizes are different. (%d:%d)\n", size1, size2);
assert_equal(i2->head->size, 4, "split failed (first half)");
assert_equal(i2->head->next->size, 6, "split failed(second half)");
assert_zero(memcmp(d1, d2, size1), "strings are different.");
QRinput_free(i1);
QRinput_free(i2);
free(d1);
free(d2);
testFinish();
}
void test_encodeAn(void)
{
char *str = "AC-42";
char correct[] = "00100000001010011100111011100111001000010";
testStart("Encoding alphabet-numeric stream.");
testEnd(mergeAndCheckBStream(0, QR_MODE_AN, str, correct));
}
void test_null_free(void)
{
testStart("Testing free NULL pointers");
assert_nothing(QRcode_free(NULL), "Check QRcode_free(NULL).\n");
assert_nothing(QRcode_List_free(NULL), "Check QRcode_List_free(NULL).\n");
assert_nothing(QRraw_free(NULL), "Check QRraw_free(NULL).\n");
testFinish();
}
