git.sur5r.net Git - glabels/blob - bc-backends/qrencode-3.1.0/tests/test_split.c

   1 #include <stdio.h>
   2 #include <string.h>
   3 #include <stdarg.h>
   4 #include "common.h"
   5 #include "../qrspec.h"
   6 #include "../qrinput.h"
   7 #include "../mask.h"
   8 #include "../split.h"
   9 #include "../bitstream.h"
  10
  11 static int inputTest(QRinput_List *list, const char *fmt, ...)
  12 {
  13         va_list ap;
  14         int size;
  15         QRencodeMode mode;
  16         int i, err = 0;
  17
  18         va_start(ap, fmt);
  19         i = 1;
  20         while(*fmt) {
  21                 if(list == NULL) {
  22                         err = 1;
  23                         break;
  24                 }
  25                 size = va_arg(ap, int);
  26                 if(list->size != size) {
  27                         err = 1;
  28                         break;
  29                 }
  30
  31                 switch(*fmt++) {
  32                 case 'n':
  33                         mode = QR_MODE_NUM;
  34                         break;
  35                 case 'a':
  36                         mode = QR_MODE_AN;
  37                         break;
  38                 case 'k':
  39                         mode = QR_MODE_KANJI;
  40                         break;
  41                 case '8':
  42                         mode = QR_MODE_8;
  43                         break;
  44                 default:
  45                         return -1;
  46                         break;
  47                 }
  48                 if(list->mode != mode) {
  49                         err = 1;
  50                         break;
  51                 }
  52                 list = list->next;
  53                 i++;
  54         }
  55         va_end(ap);
  56         if(list != NULL) {
  57                 err = 1;
  58         }
  59         if(err) {
  60                 return -i;
  61         }
  62         return 0;
  63 }
  64
  65 int inputSize(QRinput *input)
  66 {
  67         BitStream *bstream;
  68         int size;
  69
  70         bstream = QRinput_mergeBitStream(input);
  71         size = BitStream_size(bstream);
  72         BitStream_free(bstream);
  73
  74         return size;
  75 }
  76
  77 void test_split1(void)
  78 {
  79         QRinput *input;
  80         BitStream *stream;
  81
  82         testStart("Split test: null string");
  83         input = QRinput_new2(0, QR_ECLEVEL_L);
  84         Split_splitStringToQRinput("", input, QR_MODE_8, 0);
  85         stream = QRinput_mergeBitStream(input);
  86         testEndExp(BitStream_size(stream) == 0);
  87         QRinput_free(input);
  88         BitStream_free(stream);
  89 }
  90
  91 void test_split2(void)
  92 {
  93         QRinput *input;
  94         QRinput_List *list;
  95         int err = 0;
  96
  97         testStart("Split test: single typed strings (num)");
  98         input = QRinput_new2(0, QR_ECLEVEL_L);
  99         Split_splitStringToQRinput("0123", input, QR_MODE_8, 0);
 100         list = input->head;
 101         if(inputTest(list, "n", 4)) {
 102                 err++;
 103         }
 104         testEnd(err);
 105         QRinput_free(input);
 106
 107         err = 0;
 108         testStart("Split test: single typed strings (num2)");
 109         input = QRinput_new2(0, QR_ECLEVEL_L);
 110         Split_splitStringToQRinput("12345678901234567890", input, QR_MODE_KANJI, 0);
 111         list = input->head;
 112         if(inputTest(list, "n", 20)) {
 113                 err++;
 114         }
 115         testEnd(err);
 116         QRinput_free(input);
 117 }
 118
 119 void test_split3(void)
 120 {
 121         QRinput *input;
 122         QRinput_List *list;
 123         int err = 0;
 124
 125         testStart("Split test: single typed strings (an)");
 126         input = QRinput_new2(0, QR_ECLEVEL_L);
 127         Split_splitStringToQRinput("ab:-E", input, QR_MODE_8, 0);
 128         list = input->head;
 129         if(inputTest(list, "a", 5)) {
 130                 printQrinput(input);
 131                 err++;
 132         }
 133         testEnd(err);
 134         QRinput_free(input);
 135
 136         err = 0;
 137         testStart("Split test: num + an");
 138         input = QRinput_new2(0, QR_ECLEVEL_L);
 139         Split_splitStringToQRinput("0123abcde", input, QR_MODE_KANJI, 0);
 140         list = input->head;
 141         if(inputTest(list, "a", 9)) {
 142                 err++;
 143         }
 144         testEnd(err);
 145         QRinput_free(input);
 146
 147         err = 0;
 148         testStart("Split test: an + num + an");
 149         input = QRinput_new2(0, QR_ECLEVEL_L);
 150         Split_splitStringToQRinput("Ab345fg", input, QR_MODE_KANJI, 0);
 151         list = input->head;
 152         if(inputTest(list, "a", 7)) {
 153                 err++;
 154         }
 155         testEnd(err);
 156         QRinput_free(input);
 157 }
 158
 159 void test_split4(void)
 160 {
 161         QRinput *input;
 162         QRinput *i1, *i2;
 163         int s1, s2, size;
 164 #define CHUNKA "ABCDEFGHIJK"
 165 #define CHUNKB "123456"
 166 #define CHUNKC "1234567"
 167
 168         testStart("Split test: an and num entries");
 169         input = QRinput_new2(0, QR_ECLEVEL_L);
 170         Split_splitStringToQRinput(CHUNKA/**/CHUNKB, input, QR_MODE_8, 0);
 171         i1 = QRinput_new();
 172         QRinput_append(i1, QR_MODE_AN, 17, (unsigned char *)CHUNKA/**/CHUNKB);
 173         i2 = QRinput_new();
 174         QRinput_append(i2, QR_MODE_AN, 11, (unsigned char *)CHUNKA);
 175         QRinput_append(i2, QR_MODE_NUM, 6, (unsigned char *)CHUNKB);
 176
 177         size = inputSize(input);
 178         s1 = inputSize(i1);
 179         s2 = inputSize(i2);
 180         testEndExp(size == ((s1 < s2)?s1:s2));
 181         QRinput_free(input);
 182         QRinput_free(i1);
 183         QRinput_free(i2);
 184
 185         testStart("Split test: num and an entries");
 186         input = QRinput_new2(0, QR_ECLEVEL_L);
 187         Split_splitStringToQRinput(CHUNKB/**/CHUNKA, input, QR_MODE_8, 0);
 188         i1 = QRinput_new();
 189         QRinput_append(i1, QR_MODE_AN, 17, (unsigned char *)CHUNKB/**/CHUNKA);
 190         i2 = QRinput_new();
 191         QRinput_append(i2, QR_MODE_NUM, 6, (unsigned char *)CHUNKB);
 192         QRinput_append(i2, QR_MODE_AN, 11, (unsigned char *)CHUNKA);
 193
 194         size = inputSize(input);
 195         s1 = inputSize(i1);
 196         s2 = inputSize(i2);
 197         testEndExp(size == ((s1 < s2)?s1:s2));
 198         QRinput_free(input);
 199         QRinput_free(i1);
 200         QRinput_free(i2);
 201
 202         testStart("Split test: num and an entries (should be splitted)");
 203         input = QRinput_new2(0, QR_ECLEVEL_L);
 204         Split_splitStringToQRinput(CHUNKC/**/CHUNKA, input, QR_MODE_8, 0);
 205         i1 = QRinput_new();
 206         QRinput_append(i1, QR_MODE_AN, 18, (unsigned char *)CHUNKC/**/CHUNKA);
 207         i2 = QRinput_new();
 208         QRinput_append(i2, QR_MODE_NUM, 7, (unsigned char *)CHUNKC);
 209         QRinput_append(i2, QR_MODE_AN, 11, (unsigned char *)CHUNKA);
 210
 211         size = inputSize(input);
 212         s1 = inputSize(i1);
 213         s2 = inputSize(i2);
 214         testEndExp(size == ((s1 < s2)?s1:s2));
 215         QRinput_free(input);
 216         QRinput_free(i1);
 217         QRinput_free(i2);
 218 }
 219
 220 void test_split5(void)
 221 {
 222         QRinput *input;
 223         QRinput_List *list;
 224         int err = 0;
 225
 226         testStart("Split test: bit, an, bit, num");
 227         input = QRinput_new2(0, QR_ECLEVEL_L);
 228         Split_splitStringToQRinput("\x82\xd9""abcdeabcdea\x82\xb0""123456", input, QR_MODE_8, 0);
 229         list = input->head;
 230         if(inputTest(list, "8a8n", 2, 11, 2, 6)) {
 231                 err++;
 232         }
 233         testEnd(err);
 234         QRinput_free(input);
 235 }
 236
 237 void test_split6(void)
 238 {
 239         QRinput *input;
 240         QRinput_List *list;
 241         int err = 0;
 242
 243         testStart("Split test: kanji, an, kanji, num");
 244         input = QRinput_new2(0, QR_ECLEVEL_L);
 245         Split_splitStringToQRinput("\x82\xd9""abcdeabcdea\x82\xb0""123456", input, QR_MODE_KANJI, 0);
 246         list = input->head;
 247         if(inputTest(list, "kakn", 2, 11, 2, 6)) {
 248                 printQrinput(input);
 249                 err++;
 250         }
 251         testEnd(err);
 252         QRinput_free(input);
 253 }
 254
 255 void test_split7(void)
 256 {
 257         QRinput *input;
 258         QRinput_List *list;
 259         int err = 0;
 260
 261         testStart("Split test: an and num as bits");
 262         input = QRinput_new2(0, QR_ECLEVEL_L);
 263         Split_splitStringToQRinput("\x82\xd9""abcde\x82\xb0""12345", input, QR_MODE_8, 0);
 264         list = input->head;
 265         if(inputTest(list, "8n", 9, 5)) {
 266                 err++;
 267         }
 268         testEnd(err);
 269         QRinput_free(input);
 270 }
 271
 272 void test_split8(void)
 273 {
 274         QRinput *input;
 275         QRinput_List *list;
 276         int err = 0;
 277
 278         testStart("Split test: terminated with a half of kanji code");
 279         input = QRinput_new2(0, QR_ECLEVEL_L);
 280         Split_splitStringToQRinput("\x82\xd9""abcdefgh\x82", input, QR_MODE_KANJI, 0);
 281         list = input->head;
 282         if(inputTest(list, "ka8", 2, 8, 1)) {
 283                 err++;
 284         }
 285         testEnd(err);
 286         QRinput_free(input);
 287 }
 288
 289 void test_split3c(void)
 290 {
 291         QRinput *input;
 292         QRinput_List *list;
 293         int err = 0;
 294
 295         testStart("Split test: single typed strings (an, case-sensitive)");
 296         input = QRinput_new2(0, QR_ECLEVEL_L);
 297         Split_splitStringToQRinput("ab:-E", input, QR_MODE_8, 1);
 298         list = input->head;
 299         if(inputTest(list, "8", 5)) {
 300                 err++;
 301         }
 302         testEnd(err);
 303         QRinput_free(input);
 304
 305         err = 0;
 306         testStart("Split test: num + an");
 307         input = QRinput_new2(0, QR_ECLEVEL_L);
 308         Split_splitStringToQRinput("0123abcde", input, QR_MODE_KANJI, 1);
 309         list = input->head;
 310         if(inputTest(list, "n8", 4, 5)) {
 311                 err++;
 312         }
 313         testEnd(err);
 314         QRinput_free(input);
 315
 316         err = 0;
 317         testStart("Split test: an + num + an");
 318         input = QRinput_new2(0, QR_ECLEVEL_L);
 319         Split_splitStringToQRinput("Ab345fg", input, QR_MODE_KANJI, 1);
 320         list = input->head;
 321         if(inputTest(list, "8", 7)) {
 322                 printQrinput(input);
 323                 err++;
 324         }
 325         testEnd(err);
 326         QRinput_free(input);
 327 }
 328
 329 void test_toupper(void)
 330 {
 331         QRinput *input;
 332         QRinput_List *list;
 333         int err = 0;
 334
 335         testStart("Split test: check dupAndToUpper (lower->upper)");
 336         input = QRinput_new2(0, QR_ECLEVEL_L);
 337         Split_splitStringToQRinput("abcde", input, QR_MODE_8, 0);
 338         list = input->head;
 339         if(inputTest(list, "a", 5)) {
 340                 err++;
 341         }
 342         if(strncmp((char *)list->data, "ABCDE", list->size)) {
 343                 err++;
 344         }
 345         testEnd(err);
 346         QRinput_free(input);
 347
 348         err = 0;
 349         testStart("Split test: check dupAndToUpper (kanji)");
 350         input = QRinput_new2(0, QR_ECLEVEL_L);
 351         Split_splitStringToQRinput("\x83n\x83q\x83t\x83w\x83z", input, QR_MODE_KANJI, 0);
 352         list = input->head;
 353         if(inputTest(list, "k", 10)) {
 354                 printQrinput(input);
 355                 err++;
 356         }
 357         if(strncmp((char *)list->data, "\x83n\x83q\x83t\x83w\x83z", list->size)) {
 358                 err++;
 359         }
 360         testEnd(err);
 361         QRinput_free(input);
 362
 363         err = 0;
 364         testStart("Split test: check dupAndToUpper (8bit)");
 365         input = QRinput_new2(0, QR_ECLEVEL_L);
 366         Split_splitStringToQRinput("\x83n\x83q\x83t\x83w\x83z", input, QR_MODE_8, 0);
 367         list = input->head;
 368         if(inputTest(list, "8", 10)) {
 369                 printQrinput(input);
 370                 err++;
 371         }
 372         if(strncmp((char *)list->data, "\x83N\x83Q\x83T\x83W\x83Z", list->size)) {
 373                 err++;
 374         }
 375         testEnd(err);
 376         QRinput_free(input);
 377 }
 378
 379 void test_splitNum8(void)
 380 {
 381         QRinput *input;
 382         QRinput_List *list;
 383         int err = 0;
 384
 385         testStart("Split test: num and 8bit to 8bit");
 386         input = QRinput_new2(0, QR_ECLEVEL_L);
 387         Split_splitStringToQRinput("1abcdefg", input, QR_MODE_8, 1);
 388         list = input->head;
 389         if(inputTest(list, "8", 8)) {
 390                 err++;
 391                 printQRinputInfo(input);
 392         }
 393         testEnd(err);
 394         QRinput_free(input);
 395 }
 396
 397 int main(int argc, char **argv)
 398 {
 399         test_split1();
 400         test_split2();
 401         test_split3();
 402         test_split4();
 403         test_split5();
 404         test_split6();
 405         test_split7();
 406         test_split8();
 407         test_split3c();
 408         test_toupper();
 409         test_splitNum8();
 410
 411         report();
 412
 413         return 0;
 414 }