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_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_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_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_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_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_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_encodeAn2(void)
{
QRinput *stream;
char str[] = "!,;$%";
int ret;
testStart("Encoding INVALID alphabet-numeric stream.");
stream = QRinput_new();
ret = QRinput_append(stream, QR_MODE_AN, 5, (unsigned char *)str);
testEnd(!ret);
QRinput_free(stream);
}
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_encodeAnNum(void)
{
QRinput *input;
BitStream *bstream;
testStart("Bit length check of alpha-numeric stream. (11 + 12)");
input = QRinput_new();
QRinput_append(input, QR_MODE_AN, 11, (unsigned char *)"ABCDEFGHIJK");
QRinput_append(input, QR_MODE_NUM, 12, (unsigned char *)"123456789012");
bstream = QRinput_mergeBitStream(input);
testEndExp(BitStream_size(bstream) == 128);
QRinput_free(input);
BitStream_free(bstream);
testStart("Bit length check of alphabet stream. (23)");
input = QRinput_new();
QRinput_append(input, QR_MODE_AN, 23, (unsigned char *)"ABCDEFGHIJK123456789012");
bstream = QRinput_mergeBitStream(input);
testEndExp(BitStream_size(bstream) == 140);
QRinput_free(input);
BitStream_free(bstream);
}
void test_ECIinvalid(void)
{
QRinput *stream;
int ret;
testStart("Appending invalid ECI header");
stream = QRinput_new();
ret = QRinput_appendECIheader(stream, 999999);
assert_zero(ret, "Valid ECI header rejected.");
ret = QRinput_appendECIheader(stream, 1000000);
assert_nonzero(ret, "Invalid ECI header accepted.");
QRinput_free(stream);
testFinish();
}
void test_structure(void)
{
QRinput *stream;
int bits;
testStart("Estimation of a structure-append header");
stream = QRinput_new();
QRinput_insertStructuredAppendHeader(stream, 10, 1, 0);
bits = QRinput_estimateBitStreamSize(stream, 1);
testEndExp(bits == 20);
QRinput_insertStructuredAppendHeader(gstream, 10, 1, 0);
QRinput_free(stream);
}
void test_numbit(void)
{
QRinput *stream;
char num[9]="01234567";
int bits;
testStart("Estimation of Numeric stream (8 digits)");
stream = QRinput_new();
QRinput_append(stream, QR_MODE_NUM, 8, (unsigned char *)num);
bits = QRinput_estimateBitStreamSize(stream, 0);
testEndExp(bits == 41);
QRinput_append(gstream, QR_MODE_NUM, 8, (unsigned char *)num);
QRinput_free(stream);
}
void test_8(void)
{
QRinput *stream;
char str[9]="12345678";
int bits;
testStart("Estimation of 8 bit data stream (8 bytes)");
stream = QRinput_new();
QRinput_append(stream, QR_MODE_8, 8, (unsigned char *)str);
bits = QRinput_estimateBitStreamSize(stream, 0);
testEndExp(bits == 76);
QRinput_append(gstream, QR_MODE_8, 8, (unsigned char *)str);
QRinput_free(stream);
}
void test_an(void)
{
QRinput *stream;
char str[6]="AC-42";
int bits;
testStart("Estimation of Alphabet-Numeric stream (5 chars)");
stream = QRinput_new();
QRinput_append(stream, QR_MODE_AN, 5, (unsigned char *)str);
bits = QRinput_estimateBitStreamSize(stream, 0);
testEndExp(bits == 41);
QRinput_append(gstream, QR_MODE_AN, 5, (unsigned char *)str);
QRinput_free(stream);
}
void test_encodeNumeric(void)
{
QRinput *stream;
char num[9] = "01234567";
char correct[] = "00010000001000000000110001010110011000011";
BitStream *bstream;
testStart("Encoding numeric stream. (8 digits)");
stream = QRinput_new();
QRinput_append(stream, QR_MODE_NUM, 8, (unsigned char *)num);
bstream = QRinput_mergeBitStream(stream);
testEnd(cmpBin(correct, bstream));
QRinput_free(stream);
BitStream_free(bstream);
}
void test_encodeAn(void)
{
QRinput *stream;
char str[] = "AC-42";
char correct[] = "00100000001010011100111011100111001000010";
BitStream *bstream;
testStart("Encoding alphabet-numeric stream.");
stream = QRinput_new();
QRinput_append(stream, QR_MODE_AN, 5, (unsigned char *)str);
bstream = QRinput_mergeBitStream(stream);
testEnd(cmpBin(correct, bstream));
QRinput_free(stream);
BitStream_free(bstream);
}
int main(int argc, char **argv)
{
gstream = QRinput_new();
test_numbit();
test_numbit2();
test_numbit3();
test_an();
test_8();
test_kanji();
test_structure();
test_mix();
report();
return 0;
}
static int check_lengthOfCode(QRencodeMode mode, char *data, int size, int version)
{
QRinput *input;
BitStream *b;
int bits;
int bytes;
input = QRinput_new();
QRinput_setVersion(input, version);
QRinput_append(input, mode, size, (unsigned char *)data);
b = QRinput_mergeBitStream(input);
bits = BitStream_size(b);
bytes = QRinput_lengthOfCode(mode, version, bits);
QRinput_free(input);
BitStream_free(b);
return bytes;
}
void test_iterate2()
{
int i;
QRinput *stream;
char num[9] = "01234567";
QRRawCode *raw;
int err = 0;
unsigned char correct[] = {
0x10, 0x11, 0xec, 0xec, 0x20, 0xec, 0x11, 0x11,
0x0c, 0x11, 0xec, 0xec, 0x56, 0xec, 0x11, 0x11,
0x61, 0x11, 0xec, 0xec, 0x80, 0xec, 0x11, 0x11,
0xec, 0x11, 0xec, 0xec, 0x11, 0xec, 0x11, 0x11,
0xec, 0x11, 0xec, 0xec, 0x11, 0xec, 0x11, 0x11,
0xec, 0x11, 0xec, 0xec, 0x11, 0x11,
0x5c, 0xde, 0x68, 0x68, 0x4d, 0xb3, 0xdb, 0xdb,
0xd5, 0x14, 0xe1, 0xe1, 0x5b, 0x2a, 0x1f, 0x1f,
0x49, 0xc4, 0x78, 0x78, 0xf7, 0xe0, 0x5b, 0x5b,
0xc3, 0xa7, 0xc1, 0xc1, 0x5d, 0x9a, 0xea, 0xea,
0x48, 0xad, 0x9d, 0x9d, 0x58, 0xb3, 0x3f, 0x3f,
0x10, 0xdb, 0xbf, 0xbf, 0xeb, 0xec, 0x05, 0x05,
0x98, 0x35, 0x83, 0x83, 0xa9, 0x95, 0xa6, 0xa6,
0xea, 0x7b, 0x8d, 0x8d, 0x04, 0x3c, 0x08, 0x08,
0x64, 0xce, 0x3e, 0x3e, 0x4d, 0x9b, 0x30, 0x30,
0x4e, 0x65, 0xd6, 0xd6, 0xe4, 0x53, 0x2c, 0x2c,
0x46, 0x1d, 0x2e, 0x2e, 0x29, 0x16, 0x27, 0x27
};
testStart("Test getCode (5-H)");
stream = QRinput_new();
QRinput_setVersion(stream, 5);
QRinput_setErrorCorrectionLevel(stream, QR_ECLEVEL_H);
QRinput_append(stream, QR_MODE_NUM, 8, (unsigned char *)num);
raw = QRraw_new(stream);
for(i=0; i<raw->dataLength; i++) {
if(correct[i] != QRraw_getCode(raw)) {
err++;
}
}
QRinput_free(stream);
QRraw_free(raw);
testEnd(err);
}
void test_encodeKanji(void)
{
QRinput *stream;
unsigned char str[4]= {0x93, 0x5f,0xe4, 0xaa};
unsigned char *buf;
char correct[] = "10000000001001101100111111101010101010";
BitStream *bstream;
testStart("Encoding kanji stream.");
buf = (unsigned char *)malloc(4);
memcpy(buf, str, 4);
stream = QRinput_new();
QRinput_append(stream, QR_MODE_KANJI, 4, buf);
bstream = QRinput_mergeBitStream(stream);
testEnd(cmpBin(correct, bstream));
QRinput_free(stream);
BitStream_free(bstream);
free(buf);
}
/* See pp. 73 of JIS X0510:2004 */
void test_rscodeexample(void)
{
QRinput *stream;
QRRawCode *code;
static const char str[9] = "01234567";
static unsigned char correct[26] = {
0x10, 0x20, 0x0c, 0x56, 0x61, 0x80, 0xec, 0x11, 0xec, 0x11, 0xec, 0x11,
0xec, 0x11, 0xec, 0x11, 0xa5, 0x24, 0xd4, 0xc1, 0xed, 0x36, 0xc7, 0x87,
0x2c, 0x55};
testStart("RS ecc test");
stream = QRinput_new();
QRinput_append(stream, QR_MODE_NUM, 8, (unsigned char *)str);
QRinput_setErrorCorrectionLevel(stream, QR_ECLEVEL_M);
code = QRraw_new(stream);
testEnd(memcmp(correct + 16, code->rsblock[0].ecc, 10));
QRinput_free(stream);
QRraw_free(code);
}
void test_numbit3(void)
{
QRinput *stream;
char *num;
int bits;
testStart("Estimation of Numeric stream (400 digits)");
stream = QRinput_new();
num = (char *)malloc(401);
memset(num, '1', 400);
num[400] = '\0';
QRinput_append(stream, QR_MODE_NUM, 400, (unsigned char *)num);
bits = QRinput_estimateBitStreamSize(stream, 0);
/* 4 + 10 + 133*10 + 4 = 1348 */
testEndExp(bits == 1348);
QRinput_append(gstream, QR_MODE_NUM, 400, (unsigned char *)num);
QRinput_free(stream);
free(num);
}
void test_encode8_versionup(void)
{
QRinput *stream;
BitStream *bstream;
char *str;
int version;
testStart("Encoding 8bit stream. (auto-version up test)");
str = (char *)malloc(2900);
memset(str, 0xff, 2900);
stream = QRinput_new();
QRinput_append(stream, QR_MODE_8, 2900, (unsigned char *)str);
bstream = QRinput_mergeBitStream(stream);
version = QRinput_getVersion(stream);
assert_equal(version, 40, "Version is %d (40 expected).\n", version);
testFinish();
QRinput_free(stream);
BitStream_free(bstream);
free(str);
}
void test_insertStructuredAppendHeader(void)
{
QRinput *stream;
char correct[] = "0011000011111010010101000000000101000001";
BitStream *bstream;
int ret;
testStart("Insert a structured-append header");
stream = QRinput_new();
QRinput_append(stream, QR_MODE_8, 1, (unsigned char *)"A");
ret = QRinput_insertStructuredAppendHeader(stream, 16, 1, 0xa5);
assert_zero(ret, "QRinput_insertStructuredAppendHeader() returns nonzero.\n");
bstream = QRinput_mergeBitStream(stream);
assert_nonnull(bstream->data, "Bstream->data is null.");
assert_zero(cmpBin(correct, bstream), "bitstream is wrong.");
testFinish();
QRinput_free(stream);
BitStream_free(bstream);
}
void test_encodeTooLong(void)
{
QRinput *stream;
unsigned char *data;
BitStream *bstream;
data = (unsigned char *)malloc(4297);
memset(data, 'A', 4297);
testStart("Encoding long string. (4297 bytes of alphanumeric)");
stream = QRinput_new();
QRinput_append(stream, QR_MODE_AN, 4297, data);
bstream = QRinput_mergeBitStream(stream);
testEndExp(bstream == NULL);
QRinput_free(stream);
if(bstream != NULL) {
BitStream_free(bstream);
}
free(data);
}
int mergeAndCheckBStream(int mqr, QRencodeMode mode, char *data, char *correct)
{
QRinput *input;
BitStream *bstream;
int ret;
if(mqr) {
input = QRinput_newMQR(1, QR_ECLEVEL_L);
} else {
input = QRinput_new();
}
QRinput_append(input, mode, strlen(data), (unsigned char *)data);
bstream = BitStream_new();
QRinput_mergeBitStream(input, bstream);
ret = cmpBin(correct, bstream);
QRinput_free(input);
BitStream_free(bstream);
return ret;
}
void test_insertStructuredAppendHeader_error(void)
{
QRinput *stream;
int ret;
testStart("Insert a structured-append header (errors expected)");
stream = QRinput_new();
QRinput_append(stream, QR_MODE_8, 1, (unsigned char *)"A");
ret = QRinput_insertStructuredAppendHeader(stream, 17, 1, 0xa5);
assert_equal(-1, ret, "QRinput_insertStructuredAppendHeader() returns 0.");
assert_equal(EINVAL, errno, "errno is not set correctly (%d returned).", errno);
ret = QRinput_insertStructuredAppendHeader(stream, 16, 17, 0xa5);
assert_equal(-1, ret, "QRinput_insertStructuredAppendHeader() returns 0.");
assert_equal(EINVAL, errno, "errno is not set correctly (%d returned).", errno);
ret = QRinput_insertStructuredAppendHeader(stream, 16, 0, 0xa5);
assert_equal(-1, ret, "QRinput_insertStructuredAppendHeader() returns 0.");
assert_equal(EINVAL, errno, "errno is not set correctly (%d returned).", errno);
testFinish();
QRinput_free(stream);
}
void test_kanji(void)
{
int res;
QRinput *stream;
unsigned char str[4]= {0x93, 0x5f,0xe4, 0xaa};
int bits;
testStart("Estimation of Kanji stream (2 chars)");
stream = QRinput_new();
res = QRinput_append(stream, QR_MODE_KANJI, 4, (unsigned char *)str);
if(res < 0) {
printf("Failed to add.\n");
testEnd(1);
} else {
bits = QRinput_estimateBitStreamSize(stream, 0);
testEndExp(bits == 38);
QRinput_append(gstream, QR_MODE_KANJI, 4, (unsigned char *)str);
}
QRinput_free(stream);
}
void test_invalid_input(void)
{
QRinput *input;
QRcode *code;
testStart("Testing invalid input.");
input = QRinput_new();
QRinput_append(input, QR_MODE_AN, 5, (unsigned char *)"TEST1");
input->version = -1;
input->level = QR_ECLEVEL_L;
code = QRcode_encodeInput(input);
assert_null(code, "invalid version(-1) was not checked.\n");
if(code != NULL) QRcode_free(code);
input->version = 41;
input->level = QR_ECLEVEL_L;
code = QRcode_encodeInput(input);
assert_null(code, "invalid version(41) access was not checked.\n");
if(code != NULL) QRcode_free(code);
input->version = 1;
input->level = (QRecLevel)(QR_ECLEVEL_H + 1);
code = QRcode_encodeInput(input);
assert_null(code, "invalid level(H+1) access was not checked.\n");
if(code != NULL) QRcode_free(code);
input->version = 1;
input->level = (QRecLevel)-1;
code = QRcode_encodeInput(input);
assert_null(code, "invalid level(-1) access was not checked.\n");
if(code != NULL) QRcode_free(code);
QRinput_free(input);
testFinish();
}
