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_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_padding2(void)
{
QRinput *input;
BitStream *bstream;
int i, size, ret;
char data[] = "0123456789ABCDeF";
char correct[153];
unsigned char c;
testStart("Padding bit check. (1 or 2 padding bytes)");
/* 16 byte data (4 bit terminator and 1 byte padding) */
memset(correct, 0, 153);
memcpy(correct, "010000010000", 12);
for(size=0; size<16; size++) {
c = 0x80;
for(i=0; i<8; i++) {
correct[size * 8 + i + 12] = (data[size]&c)?'1':'0';
c = c >> 1;
}
}
memcpy(correct + 140, "000011101100", 12);
input = QRinput_new2(1, QR_ECLEVEL_L);
QRinput_append(input, QR_MODE_8, 16, (unsigned char *)data);
bstream = BitStream_new();
QRinput_getBitStream(input, bstream);
size = BitStream_size(bstream);
assert_equal(size, 152, "16byte: # of bit is incorrect (%d != 152).\n", size);
ret = ncmpBin(correct, bstream, 152);
assert_zero(ret, "Padding bits incorrect.\n");
printBstream(bstream);
QRinput_free(input);
BitStream_free(bstream);
/* 15 byte data (4 bit terminator and 2 byte paddings) */
memcpy(correct, "010000001111", 12);
memcpy(correct + 132, "00001110110000010001", 20);
input = QRinput_new2(1, QR_ECLEVEL_L);
QRinput_append(input, QR_MODE_8, 15, (unsigned char *)data);
bstream = BitStream_new();
QRinput_getBitStream(input, bstream);
size = BitStream_size(bstream);
assert_equal(size, 152, "15byte: # of bit is incorrect (%d != 152).\n", size);
ret = ncmpBin(correct, bstream, 152);
assert_zero(ret, "Padding bits incorrect.\n");
printBstream(bstream);
testFinish();
QRinput_free(input);
BitStream_free(bstream);
}
void test_encodeLongData(void)
{
QRinput *stream;
unsigned char data[7090];
int maxlength[4][4] = {{7089,5596,3993,3057},
{4296,3391,2420,1852},
{2953,2331,1663,1273},
{1817*2,1435*2,1024*2, 784*2}};
int i, l, len, ret;
QRcode *qrcode;
testStart("Encoding long data.");
for(i=QR_MODE_NUM; i<=QR_MODE_KANJI; i++) {
if(i != QR_MODE_KANJI) {
memset(data, '0', maxlength[i][0] + 1);
} else {
for(l=0; l<=maxlength[i][0]/2+1; l++) {
data[l*2] = 0x93; data[l*2+1] = 0x5f;
}
}
for(l=QR_ECLEVEL_L; l<=QR_ECLEVEL_H; l++) {
stream = QRinput_new2(0, l);
ret = QRinput_append(stream, i, maxlength[i][l], data);
assert_zero(ret, "Failed to add %d-byte %s to a QRinput\n", maxlength[i][l], modeStr[i]);
qrcode = QRcode_encodeInput(stream);
assert_nonnull(qrcode, "(QRcode_encodeInput) failed to encode %d-byte %s in level %d.\n", maxlength[i][l], modeStr[i], l);
if(qrcode != NULL) {
QRcode_free(qrcode);
}
QRinput_free(stream);
stream = QRinput_new2(0, l);
len = maxlength[i][l];
if(i == QR_MODE_KANJI) {
len += 2;
} else {
len += 1;
}
ret = QRinput_append(stream, i, len, data);
if(ret == 0) {
qrcode = QRcode_encodeInput(stream);
assert_null(qrcode, "(QRcode_encodeInput) incorrectly succeeded to encode %d-byte %s in level %d.\n", len, modeStr[i], l);
if(qrcode != NULL) {
printf("version: %d\n", qrcode->version);
QRcode_free(qrcode);
}
}
QRinput_free(stream);
}
}
testFinish();
}
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_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_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_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);
}
QRcode_List *QRcode_encodeStringStructured(const char *string, int version, QRecLevel level, QRencodeMode hint, int casesensitive)
{
QRinput *input;
QRcode_List *codes;
int ret;
if(version <= 0) {
errno = EINVAL;
return NULL;
}
if(hint != QR_MODE_8 && hint != QR_MODE_KANJI) {
errno = EINVAL;
return NULL;
}
input = QRinput_new2(version, level);
if(input == NULL) return NULL;
ret = Split_splitStringToQRinput(string, input, hint, casesensitive);
if(ret < 0) {
QRinput_free(input);
return NULL;
}
codes = QRcode_encodeInputToStructured(input);
QRinput_free(input);
return codes;
}
static QRcode_List *QRcode_encodeDataStructuredReal(
int size, const unsigned char *data,
int version, QRecLevel level,
int eightbit, QRencodeMode hint, int casesensitive)
{
QRinput *input;
QRcode_List *codes;
int ret;
if(version <= 0) {
errno = EINVAL;
return NULL;
}
if(!eightbit && (hint != QR_MODE_8 && hint != QR_MODE_KANJI)) {
errno = EINVAL;
return NULL;
}
input = QRinput_new2(version, level);
if(input == NULL) return NULL;
if(eightbit) {
ret = QRinput_append(input, QR_MODE_8, size, data);
} else {
ret = Split_splitStringToQRinput((char *)data, input, hint, casesensitive);
}
if(ret < 0) {
QRinput_free(input);
return NULL;
}
codes = QRcode_encodeInputToStructured(input);
QRinput_free(input);
return codes;
}
static QRcode *QRcode_encodeDataReal(const unsigned char *data, int length, int version, QRecLevel level, int mqr)
{
QRinput *input;
QRcode *code;
int ret;
if(data == NULL || length == 0) {
errno = EINVAL;
return NULL;
}
if(mqr) {
input = QRinput_newMQR(version, level);
} else {
input = QRinput_new2(version, level);
}
if(input == NULL) return NULL;
ret = QRinput_append(input, QR_MODE_8, length, data);
if(ret < 0) {
QRinput_free(input);
return NULL;
}
code = QRcode_encodeInput(input);
QRinput_free(input);
return code;
}
static QRcode *QRcode_encodeStringReal(const char *string, int version, QRecLevel level, int mqr, QRencodeMode hint, int casesensitive)
{
QRinput *input;
QRcode *code;
int ret;
if(string == NULL) {
errno = EINVAL;
return NULL;
}
if(hint != QR_MODE_8 && hint != QR_MODE_KANJI) {
errno = EINVAL;
return NULL;
}
if(mqr) {
input = QRinput_newMQR(version, level);
} else {
input = QRinput_new2(version, level);
}
if(input == NULL) return NULL;
ret = Split_splitStringToQRinput(string, input, hint, casesensitive);
if(ret < 0) {
QRinput_free(input);
return NULL;
}
code = QRcode_encodeInput(input);
QRinput_free(input);
return code;
}
int encodeAndCheckBStream(int mqr, int version, QRecLevel level, QRencodeMode mode, char *data, char *correct)
{
QRinput *input;
BitStream *bstream;
int ret;
if(mqr) {
input = QRinput_newMQR(version, level);
} else {
input = QRinput_new2(version, level);
}
QRinput_append(input, mode, strlen(data), (unsigned char *)data);
bstream = BitStream_new();
QRinput_getBitStream(input, bstream);
ret = cmpBin(correct, bstream);
if(ret) {
printf("result : ");
printBstream(bstream);
printf("correct: %s\n", correct);
}
QRinput_free(input);
BitStream_free(bstream);
return ret;
}
int encodeURLandCompare(char *url, int expected_length) {
QRinput *input;
BitStream *bstream;
int ret = 0;
input = QRinput_new2(0, QR_ECLEVEL_L);
Split_splitStringToQRinput(url, input, QR_MODE_8, 1);
bstream = BitStream_new();
QRinput_mergeBitStream(input, bstream);
int length = BitStream_size(bstream);
if(length > expected_length) {
printf("The length of the encode stream is longer than expected: %d over %d\n", length, expected_length);
printQRinput(input);
ret = 1;
} else if(length < expected_length) {
printf("The length of the encode stream is shorter than expected: %d under %d\n", length, expected_length);
printQRinput(input);
ret = 1;
}
QRinput_free(input);
BitStream_free(bstream);
return ret;
}
void test_split1(void)
{
QRinput *input;
BitStream *stream;
testStart("Split test: null string");
input = QRinput_new2(0, QR_ECLEVEL_L);
Split_splitStringToQRinput("", input, QR_MODE_8, 0);
stream = QRinput_mergeBitStream(input);
testEndExp(BitStream_size(stream) == 0);
QRinput_free(input);
BitStream_free(stream);
}
void test_split3c(void)
{
QRinput *input;
QRinput_List *list;
int err = 0;
testStart("Split test: single typed strings (an, case-sensitive)");
input = QRinput_new2(0, QR_ECLEVEL_L);
Split_splitStringToQRinput("ab:-E", input, QR_MODE_8, 1);
list = input->head;
if(inputTest(list, "8", 5)) {
err++;
}
testEnd(err);
QRinput_free(input);
err = 0;
testStart("Split test: num + an");
input = QRinput_new2(0, QR_ECLEVEL_L);
Split_splitStringToQRinput("0123abcde", input, QR_MODE_KANJI, 1);
list = input->head;
if(inputTest(list, "n8", 4, 5)) {
err++;
}
testEnd(err);
QRinput_free(input);
err = 0;
testStart("Split test: an + num + an");
input = QRinput_new2(0, QR_ECLEVEL_L);
Split_splitStringToQRinput("Ab345fg", input, QR_MODE_KANJI, 1);
list = input->head;
if(inputTest(list, "8", 7)) {
printQRinputInfo(input);
err++;
}
testEnd(err);
QRinput_free(input);
}
void print_01234567(void)
{
QRinput *stream;
char num[9] = "01234567";
QRcode *qrcode;
stream = QRinput_new2(1, QR_ECLEVEL_M);
QRinput_append(stream, QR_MODE_NUM, 8, (unsigned char *)num);
qrcode = QRcode_encodeInput(stream);
printQRcode(qrcode);
QRinput_free(stream);
QRcode_free(qrcode);
}
void test_split_kanji(int num)
{
QRinput *input;
QRinput_List *list;
int len, i, ret;
len = fill8bitString();
input = QRinput_new2(0, QR_ECLEVEL_L);
if(input == NULL) {
perror("test_split_kanji aborted at QRinput_new2():");
return;
}
ret = Split_splitStringToQRinput((char *)data, input, QR_MODE_KANJI, 1);
if(ret < 0) {
perror("test_split_kanji aborted at Split_splitStringToQRinput():");
QRinput_free(input);
return;
}
list = input->head;
i = 0;
while(list != NULL) {
memcpy(check + i, list->data, list->size);
i += list->size;
list = list->next;
}
if(i != len) {
printf("#%d: length is not correct. (%d should be %d)\n", num, i, len);
}
check[i] = '\0';
ret = memcmp(data, check, len);
if(ret != 0) {
printf("#%d: data mismatched.\n", num);
list = input->head;
i = 0;
while(list != NULL) {
ret = memcmp(data + i, list->data, list->size);
printf("wrong chunk:\n");
printf(" position: %d\n", i);
printf(" mode : %d\n", list->mode);
printf(" size : %d\n", list->size);
printf(" data : %.*s\n", list->size, list->data);
i += list->size;
list = list->next;
}
exit(1);
}
QRinput_free(input);
}
void encodeURLandPrint(char *url) {
QRinput *input;
BitStream *bstream;
input = QRinput_new2(0, QR_ECLEVEL_L);
Split_splitStringToQRinput(url, input, QR_MODE_8, 1);
bstream = BitStream_new();
QRinput_mergeBitStream(input, bstream);
printf("{%d,\"%s\"},\n", BitStream_size(bstream), url);
QRinput_free(input);
BitStream_free(bstream);
}
void test_split7(void)
{
QRinput *input;
QRinput_List *list;
int err = 0;
testStart("Split test: an and num as bits");
input = QRinput_new2(0, QR_ECLEVEL_L);
Split_splitStringToQRinput("\x82\xd9""abcde\x82\xb0""12345", input, QR_MODE_8, 0);
list = input->head;
if(inputTest(list, "8n", 9, 5)) {
err++;
}
testEnd(err);
QRinput_free(input);
}
void test_split5(void)
{
QRinput *input;
QRinput_List *list;
int err = 0;
testStart("Split test: bit, an, bit, num");
input = QRinput_new2(0, QR_ECLEVEL_L);
Split_splitStringToQRinput("\x82\xd9""abcdeabcdea\x82\xb0""123456", input, QR_MODE_8, 0);
list = input->head;
if(inputTest(list, "8a8n", 2, 11, 2, 6)) {
err++;
}
testEnd(err);
QRinput_free(input);
}
void test_encode3(void)
{
QRcode *code1, *code2;
QRinput *input;
testStart("Compare encodeString and encodeInput");
code1 = QRcode_encodeString("0123456", 0, QR_ECLEVEL_L, QR_MODE_8, 0);
input = QRinput_new2(0, QR_ECLEVEL_L);
QRinput_append(input, QR_MODE_NUM, 7, (unsigned char *)"0123456");
code2 = QRcode_encodeInput(input);
testEnd(memcmp(code1->data, code2->data, code1->width * code1->width));
QRcode_free(code1);
QRcode_free(code2);
QRinput_free(input);
}
void test_split8(void)
{
QRinput *input;
QRinput_List *list;
int err = 0;
testStart("Split test: terminated with a half of kanji code");
input = QRinput_new2(0, QR_ECLEVEL_L);
Split_splitStringToQRinput("\x82\xd9""abcdefgh\x82", input, QR_MODE_KANJI, 0);
list = input->head;
if(inputTest(list, "ka8", 2, 8, 1)) {
err++;
}
testEnd(err);
QRinput_free(input);
}
void test_split6(void)
{
QRinput *input;
QRinput_List *list;
int err = 0;
testStart("Split test: kanji, an, kanji, num");
input = QRinput_new2(0, QR_ECLEVEL_L);
Split_splitStringToQRinput("\x82\xd9""abcdeabcdea\x82\xb0""123456", input, QR_MODE_KANJI, 0);
list = input->head;
if(inputTest(list, "kakn", 2, 11, 2, 6)) {
printQRinputInfo(input);
err++;
}
testEnd(err);
QRinput_free(input);
}
void test_splitNum8(void)
{
QRinput *input;
QRinput_List *list;
int err = 0;
testStart("Split test: num and 8bit to 8bit");
input = QRinput_new2(0, QR_ECLEVEL_L);
Split_splitStringToQRinput("1abcdefg", input, QR_MODE_8, 1);
list = input->head;
if(inputTest(list, "8", 8)) {
err++;
printQRinputInfo(input);
}
testEnd(err);
QRinput_free(input);
}
void test_01234567(void)
{
QRinput *stream;
char num[9] = "01234567";
int i, err = 0;
QRcode *qrcode;
unsigned char correct[] = {
0xc1, 0xc1, 0xc1, 0xc1, 0xc1, 0xc1, 0xc1, 0xc0, 0x84, 0x03, 0x02, 0x03, 0x03, 0xc0, 0xc1, 0xc1, 0xc1, 0xc1, 0xc1, 0xc1, 0xc1,
0xc1, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc1, 0xc0, 0x84, 0x03, 0x03, 0x03, 0x03, 0xc0, 0xc1, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc1,
0xc1, 0xc0, 0xc1, 0xc1, 0xc1, 0xc0, 0xc1, 0xc0, 0x85, 0x02, 0x02, 0x02, 0x02, 0xc0, 0xc1, 0xc0, 0xc1, 0xc1, 0xc1, 0xc0, 0xc1,
0xc1, 0xc0, 0xc1, 0xc1, 0xc1, 0xc0, 0xc1, 0xc0, 0x85, 0x03, 0x02, 0x02, 0x02, 0xc0, 0xc1, 0xc0, 0xc1, 0xc1, 0xc1, 0xc0, 0xc1,
0xc1, 0xc0, 0xc1, 0xc1, 0xc1, 0xc0, 0xc1, 0xc0, 0x85, 0x02, 0x03, 0x03, 0x03, 0xc0, 0xc1, 0xc0, 0xc1, 0xc1, 0xc1, 0xc0, 0xc1,
0xc1, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc1, 0xc0, 0x85, 0x02, 0x02, 0x02, 0x03, 0xc0, 0xc1, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc1,
0xc1, 0xc1, 0xc1, 0xc1, 0xc1, 0xc1, 0xc1, 0xc0, 0x91, 0x90, 0x91, 0x90, 0x91, 0xc0, 0xc1, 0xc1, 0xc1, 0xc1, 0xc1, 0xc1, 0xc1,
0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0x85, 0x02, 0x02, 0x03, 0x03, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0,
0x85, 0x84, 0x85, 0x85, 0x85, 0x85, 0x91, 0x84, 0x84, 0x03, 0x02, 0x02, 0x03, 0x84, 0x85, 0x85, 0x85, 0x85, 0x85, 0x84, 0x84,
0x02, 0x02, 0x02, 0x03, 0x02, 0x03, 0x90, 0x03, 0x03, 0x02, 0x03, 0x02, 0x03, 0x02, 0x02, 0x03, 0x02, 0x03, 0x03, 0x02, 0x02,
0x02, 0x02, 0x03, 0x02, 0x02, 0x02, 0x91, 0x03, 0x02, 0x03, 0x02, 0x03, 0x02, 0x03, 0x02, 0x02, 0x03, 0x03, 0x03, 0x03, 0x03,
0x02, 0x02, 0x02, 0x02, 0x03, 0x02, 0x90, 0x02, 0x02, 0x03, 0x02, 0x02, 0x02, 0x02, 0x02, 0x03, 0x03, 0x03, 0x03, 0x02, 0x02,
0x02, 0x02, 0x02, 0x03, 0x03, 0x03, 0x91, 0x03, 0x03, 0x02, 0x02, 0x03, 0x02, 0x03, 0x02, 0x02, 0x03, 0x02, 0x02, 0x02, 0x02,
0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0x81, 0x02, 0x03, 0x03, 0x03, 0x03, 0x03, 0x02, 0x02, 0x03, 0x03, 0x02, 0x02,
0xc1, 0xc1, 0xc1, 0xc1, 0xc1, 0xc1, 0xc1, 0xc0, 0x84, 0x03, 0x03, 0x02, 0x03, 0x02, 0x03, 0x03, 0x02, 0x02, 0x02, 0x02, 0x02,
0xc1, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc1, 0xc0, 0x85, 0x02, 0x03, 0x03, 0x03, 0x03, 0x03, 0x02, 0x02, 0x02, 0x03, 0x02, 0x03,
0xc1, 0xc0, 0xc1, 0xc1, 0xc1, 0xc0, 0xc1, 0xc0, 0x85, 0x02, 0x02, 0x02, 0x03, 0x02, 0x02, 0x03, 0x02, 0x03, 0x03, 0x02, 0x02,
0xc1, 0xc0, 0xc1, 0xc1, 0xc1, 0xc0, 0xc1, 0xc0, 0x85, 0x03, 0x02, 0x02, 0x03, 0x02, 0x02, 0x03, 0x02, 0x02, 0x02, 0x02, 0x02,
0xc1, 0xc0, 0xc1, 0xc1, 0xc1, 0xc0, 0xc1, 0xc0, 0x85, 0x02, 0x03, 0x03, 0x02, 0x03, 0x02, 0x02, 0x03, 0x02, 0x03, 0x02, 0x02,
0xc1, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc1, 0xc0, 0x84, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x03, 0x03, 0x02, 0x03, 0x03, 0x02,
0xc1, 0xc1, 0xc1, 0xc1, 0xc1, 0xc1, 0xc1, 0xc0, 0x85, 0x03, 0x03, 0x03, 0x02, 0x03, 0x02, 0x02, 0x03, 0x02, 0x03, 0x02, 0x02};
testStart("Encode 01234567 in 1-M");
stream = QRinput_new2(1, QR_ECLEVEL_M);
QRinput_append(stream, QR_MODE_NUM, 8, (unsigned char *)num);
qrcode = QRcode_encodeInput(stream);
for(i=0; i<qrcode->width * qrcode->width; i++) {
if(qrcode->data[i] != correct[i]) {
err++;
}
}
testEnd(err);
QRinput_free(stream);
QRcode_free(qrcode);
}
void test_encodeNumeric_versionup(void)
{
QRinput *stream;
BitStream *bstream;
char *str;
int version;
testStart("Encoding numeric stream. (auto-version up test)");
str = (char *)malloc(1050);
memset(str, '1', 1050);
stream = QRinput_new2(0, QR_ECLEVEL_L);
QRinput_append(stream, QR_MODE_NUM, 1050, (unsigned char *)str);
bstream = QRinput_mergeBitStream(stream);
version = QRinput_getVersion(stream);
assert_equal(version, 14, "Version is %d (14 expected).", version);
testFinish();
QRinput_free(stream);
BitStream_free(bstream);
free(str);
}
QRcode_List *QRcode_encodeString8bitStructured(const char *string, int version, QRecLevel level)
{
QRinput *input;
QRcode_List *codes;
int ret;
if(version <= 0) {
errno = EINVAL;
return NULL;
}
input = QRinput_new2(version, level);
if(input == NULL) return NULL;
ret = QRinput_append(input, QR_MODE_8, strlen(string), (unsigned char *)string);
if(ret < 0) {
QRinput_free(input);
return NULL;
}
codes = QRcode_encodeInputToStructured(input);
QRinput_free(input);
return codes;
}
void test_struct_split_invalidVersion(void)
{
QRinput *input;
QRinput_Struct *s;
char *str;
int errsv;
testStart("Testing structured-append symbols. (invalid version 0)");
str = (char *)malloc(128);
memset(str, 'a', 128);
input = QRinput_new2(0, QR_ECLEVEL_H);
QRinput_append(input, QR_MODE_8, 128, (unsigned char *)str);
s = QRinput_splitQRinputToStruct(input);
errsv = errno;
assert_null(s, "returns non-null.");
assert_equal(errsv, ERANGE, "did not return ERANGE.");
testFinish();
if(s != NULL) QRinput_Struct_free(s);
QRinput_free(input);
free(str);
}
void draw_structuredQRcodeFromText(int argc, char **argv)
{
QRinput_Struct *s;
QRinput *input;
int i, ret;
s = QRinput_Struct_new();
if(s == NULL) {
fprintf(stderr, "Failed to allocate memory.\n");
exit(1);
}
for(i=0; i<argc; i++) {
input = QRinput_new2(version, level);
if(input == NULL) {
fprintf(stderr, "Failed to allocate memory.\n");
exit(1);
}
if(eightbit) {
ret = QRinput_append(input, QR_MODE_8, strlen(argv[i]), (unsigned char *)argv[i]);
} else {
ret = Split_splitStringToQRinput(argv[i], input, hint, casesensitive);
}
if(ret < 0) {
perror("Encoding the input string");
exit(1);
}
ret = QRinput_Struct_appendInput(s, input);
if(ret < 0) {
perror("Encoding the input string");
exit(1);
}
}
ret = QRinput_Struct_insertStructuredAppendHeaders(s);
if(ret < 0) {
fprintf(stderr, "Too many inputs.\n");
}
draw_structuredQRcode(s);
QRinput_Struct_free(s);
}