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_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_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_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_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); }
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; }
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_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_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_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); }
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; }
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_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_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); }
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; }
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_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); }
static int Split_eat8(const char *string, QRinput *input, QRencodeMode hint) { const char *p, *q; QRencodeMode mode; int ret; int run; int dif; int la, ln; la = QRspec_lengthIndicator(QR_MODE_AN, input->version); ln = QRspec_lengthIndicator(QR_MODE_NUM, input->version); p = string + 1; while(*p != '\0') { mode = Split_identifyMode(p, hint); if(mode == QR_MODE_KANJI) { break; } if(mode == QR_MODE_NUM) { q = p; while(isdigit(*q)) { q++; } dif = QRinput_estimateBitsMode8((int)(p - string)) /* + 4 + l8 */ + QRinput_estimateBitsModeNum((int)q - (int)p) + 4 + ln - QRinput_estimateBitsMode8((int)q - (int)string) /* - 4 - l8 */; if(dif < 0) { break; } else { p = q; } } else if(mode == QR_MODE_AN) { q = p; while(isalnum(*q)) { q++; } dif = QRinput_estimateBitsMode8((int)p - (int)string) /* + 4 + l8 */ + QRinput_estimateBitsModeAn((int)q - (int)p) + 4 + la - QRinput_estimateBitsMode8((int)q - (int)string) /* - 4 - l8 */; if(dif < 0) { break; } else { p = q; } } else { p++; } } run = (int)p - (int)string; ret = QRinput_append(input, QR_MODE_8, run, (unsigned char *)string); if(ret < 0) return -1; return run; }
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_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_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_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 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_splitentry3(void) { QRinput *input; QRinput_Struct *s; QRinput_List *e00, *e01, *e10, *e11; QRinput_InputList *list; const char *str = "abcdefghijklmno"; testStart("Testing QRinput_splitEntry. (does not split an entry)"); /* version 1 symbol contains 152 bit (19 byte) data. * 20 bits for a structured-append header, so 132 bits can be used. * 15 bytes of 8-bit data is suitable for the symbol. * (mode(4) + length(8) + data(120) == 132.) */ input = QRinput_new2(1, QR_ECLEVEL_L); QRinput_append(input, QR_MODE_8, strlen(str), (unsigned char *)str); QRinput_append(input, QR_MODE_8, strlen(str), (unsigned char *)str); s = QRinput_splitQRinputToStruct(input); list = s->head; e00 = list->input->head; e01 = e00->next; list = list->next; e10 = list->input->head; e11 = e00->next; assert_equal(e00->mode, QR_MODE_STRUCTURE, "Structure header is missing?"); assert_equal(e01->mode, QR_MODE_8, "no data?!"); assert_null(e01->next, "Input list is not terminated!\n"); assert_equal(e10->mode, QR_MODE_STRUCTURE, "Structure header is missing?"); assert_equal(e11->mode, QR_MODE_8, "no data?!"); assert_null(e11->next, "Input list is not terminated!\n"); QRinput_free(input); QRinput_Struct_free(s); testFinish(); }
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); }
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); }
static int Split_eatAn(const char *string, QRinput *input, QRencodeMode hint) { const char *p, *q; int ret; int run; int dif; int la, ln; la = QRspec_lengthIndicator(QR_MODE_AN, input->version); ln = QRspec_lengthIndicator(QR_MODE_NUM, input->version); p = string; while(isalnum(*p)) { if(isdigit(*p)) { q = p; while(isdigit(*q)) { q++; } dif = QRinput_estimateBitsModeAn(p - string) /* + 4 + la */ + QRinput_estimateBitsModeNum(q - p) + 4 + ln + (isalnum(*q)?(4 + ln):0) - QRinput_estimateBitsModeAn(q - string) /* - 4 - la */; if(dif < 0) { break; } else { p = q; } } else { p++; } } run = p - string; if(*p && !isalnum(*p)) { dif = QRinput_estimateBitsModeAn(run) + 4 + la + QRinput_estimateBitsMode8(1) /* + 4 + l8 */ - QRinput_estimateBitsMode8(run + 1) /* - 4 - l8 */; if(dif > 0) { return Split_eat8(string, input, hint); } } ret = QRinput_append(input, QR_MODE_AN, run, (unsigned char *)string); if(ret < 0) return -1; return run; }
static int Split_eatKanji(const char *string, QRinput *input, QRencodeMode hint) { const char *p; int ret; int run; p = string; while(Split_identifyMode(p, hint) == QR_MODE_KANJI) { p += 2; } run = (int)p - (int)string; ret = QRinput_append(input, QR_MODE_KANJI, run, (unsigned char *)string); if(ret < 0) return -1; return run; }