src/test_parselib.c

   1 /*
   2  * test_parselib.c
   3  *
   4  * Copyright (c) 2009-2010 project bchan
   5  *
   6  * This software is provided 'as-is', without any express or implied
   7  * warranty. In no event will the authors be held liable for any damages
   8  * arising from the use of this software.
   9  *
  10  * Permission is granted to anyone to use this software for any purpose,
  11  * including commercial applications, and to alter it and redistribute it
  12  * freely, subject to the following restrictions:
  13  *
  14  * 1. The origin of this software must not be misrepresented; you must not
  15  *    claim that you wrote the original software. If you use this software
  16  *    in a product, an acknowledgment in the product documentation would be
  17  *    appreciated but is not required.
  18  *
  19  * 2. Altered source versions must be plainly marked as such, and must not be
  20  *    misrepresented as being the original software.
  21  *
  22  * 3. This notice may not be removed or altered from any source
  23  *    distribution.
  24  *
  25  */
  26
  27 #include    <btron/btron.h>
  28 #include    <bstdio.h>
  29 #include    <bstring.h>
  30 #include    <bstdlib.h>
  31
  32 #include    "test.h"
  33
  34 #include    "parselib.h"
  35
  36 LOCAL TEST_RESULT test_character_reference_1()
  37 {
  38         charreferparser_t parser;
  39         charreferparser_result_t parseresult;
  40         W err;
  41
  42         err = charreferparser_initialize(&parser);
  43         if (err < 0) {
  44                 return TEST_RESULT_FAIL;
  45         }
  46         parseresult = charreferparser_parsechar(&parser, '&');
  47         if (parseresult != CHARREFERPARSER_RESULT_CONTINUE) {
  48                 charreferparser_finalize(&parser);
  49                 return TEST_RESULT_FAIL;
  50         }
  51         parseresult = charreferparser_parsechar(&parser, '#');
  52         if (parseresult != CHARREFERPARSER_RESULT_CONTINUE) {
  53                 charreferparser_finalize(&parser);
  54                 return TEST_RESULT_FAIL;
  55         }
  56         parseresult = charreferparser_parsechar(&parser, '1');
  57         if (parseresult != CHARREFERPARSER_RESULT_CONTINUE) {
  58                 charreferparser_finalize(&parser);
  59                 return TEST_RESULT_FAIL;
  60         }
  61         parseresult = charreferparser_parsechar(&parser, '0');
  62         if (parseresult != CHARREFERPARSER_RESULT_CONTINUE) {
  63                 charreferparser_finalize(&parser);
  64                 return TEST_RESULT_FAIL;
  65         }
  66         parseresult = charreferparser_parsechar(&parser, ';');
  67                 charreferparser_finalize(&parser);
  68         if (parseresult != CHARREFERPARSER_RESULT_DETERMINE) {
  69                 return TEST_RESULT_FAIL;
  70         }
  71         err = charreferparser_getcharnumber(&parser);
  72         if (err < 0) {
  73                 charreferparser_finalize(&parser);
  74                 return TEST_RESULT_FAIL;
  75         }
  76         if (err != 10) {
  77                 charreferparser_finalize(&parser);
  78                 return TEST_RESULT_FAIL;
  79         }
  80         charreferparser_finalize(&parser);
  81
  82         return TEST_RESULT_PASS;
  83 }
  84
  85 LOCAL W test_charrefer_parsestr(charreferparser_t *parser, UB *str)
  86 {
  87         W i;
  88         charreferparser_result_t result;
  89
  90         for (i = 0; str[i] != '\0'; i++) {
  91                 result = charreferparser_parsechar(parser, str[i]);
  92                 if (result == CHARREFERPARSER_RESULT_INVALID) {
  93                         return -1;
  94                 }
  95                 if (result == CHARREFERPARSER_RESULT_DETERMINE) {
  96                         return 0;
  97                 }
  98         }
  99         return -1;
 100 }
 101
 102 LOCAL TEST_RESULT test_character_reference_2()
 103 {
 104         W i;
 105         struct {
 106                 UB *str;
 107                 W val;
 108         } tuple[] = {
 109                 {"&#0;", 0},
 110                 {"&#1;", 1},
 111                 {"&#2;", 2},
 112                 {"&#3;", 3},
 113                 {"&#4;", 4},
 114                 {"&#5;", 5},
 115                 {"&#6;", 6},
 116                 {"&#7;", 7},
 117                 {"&#8;", 8},
 118                 {"&#9;", 9},
 119                 {"&#10;", 10},
 120                 {"&#11;", 11},
 121                 {"&#12;", 12},
 122                 {"&#13;", 13},
 123                 {"&#14;", 14},
 124                 {"&#15;", 15},
 125                 {"&#16;", 16},
 126                 {"&#17;", 17},
 127                 {"&#18;", 18},
 128                 {"&#19;", 19},
 129                 {"&#20;", 20},
 130                 {"&#x0;", 0x0},
 131                 {"&#x1;", 0x1},
 132                 {"&#x2;", 0x2},
 133                 {"&#x3;", 0x3},
 134                 {"&#x4;", 0x4},
 135                 {"&#x5;", 0x5},
 136                 {"&#x6;", 0x6},
 137                 {"&#x7;", 0x7},
 138                 {"&#x8;", 0x8},
 139                 {"&#x9;", 0x9},
 140                 {"&#xa;", 0xa},
 141                 {"&#xb;", 0xb},
 142                 {"&#xc;", 0xc},
 143                 {"&#xd;", 0xd},
 144                 {"&#xe;", 0xe},
 145                 {"&#xf;", 0xf},
 146                 {"&#xA;", 0xa},
 147                 {"&#xB;", 0xb},
 148                 {"&#xC;", 0xc},
 149                 {"&#xD;", 0xd},
 150                 {"&#xE;", 0xe},
 151                 {"&#xF;", 0xf},
 152                 {"&#x10;", 0x10},
 153                 {"&#x11;", 0x11},
 154                 {"&#x12;", 0x12},
 155                 {"&#x13;", 0x13},
 156                 {"&#x14;", 0x14},
 157                 {"&#x15;", 0x15},
 158                 {"&#xA0;", 0xA0},
 159                 {"&#xB1;", 0xB1},
 160                 {"&#xC2;", 0xC2},
 161                 {"&#xD3;", 0xD3},
 162                 {"&#xE4;", 0xE4},
 163                 {"&#xF5;", 0xF5},
 164                 {"&#xa0;", 0xA0},
 165                 {"&#xb1;", 0xB1},
 166                 {"&#xc2;", 0xC2},
 167                 {"&#xd3;", 0xD3},
 168                 {"&#xe4;", 0xE4},
 169                 {"&#xf5;", 0xF5},
 170                 {NULL, 0}
 171         };
 172         charreferparser_t parser;
 173         W err;
 174
 175         for (i = 0; tuple[i].str != NULL; i++) {
 176                 err = charreferparser_initialize(&parser);
 177                 if (err < 0) {
 178                         return TEST_RESULT_FAIL;
 179                 }
 180                 err = test_charrefer_parsestr(&parser, tuple[i].str);
 181                 if (err < 0) {
 182                         printf("failed to parsing\n");
 183                         return TEST_RESULT_FAIL;
 184                 }
 185                 err = charreferparser_getcharnumber(&parser);
 186                 if (err < 0) {
 187                         printf("failed to get character number\n");
 188                         charreferparser_finalize(&parser);
 189                         return TEST_RESULT_FAIL;
 190                 }
 191                 if (err != tuple[i].val) {
 192                         printf("invalid parse result: %d(0x%x)\n", err, err);
 193                         printf("                         <- %s\n", tuple[i].str);
 194                         printf("                         <- %d\n", tuple[i].val);
 195                         printf("                         <- 0x%x\n", tuple[i].val);
 196                         charreferparser_finalize(&parser);
 197                         return TEST_RESULT_FAIL;
 198                 }
 199                 charreferparser_finalize(&parser);
 200         }
 201
 202         return TEST_RESULT_PASS;
 203 }
 204
 205 LOCAL TEST_RESULT test_character_reference_3()
 206 {
 207         W i;
 208         struct {
 209                 UB *str;
 210                 W val;
 211         } tuple[] = {
 212                 {"&amp;", '&'},
 213                 {"&gt;", '>'},
 214                 {"&lt;", '<'},
 215                 {"&quot;", '"'},
 216                 {NULL, 0}
 217         };
 218         charreferparser_t parser;
 219         W err;
 220
 221         for (i = 0; tuple[i].str != NULL; i++) {
 222                 err = charreferparser_initialize(&parser);
 223                 if (err < 0) {
 224                         return TEST_RESULT_FAIL;
 225                 }
 226                 err = test_charrefer_parsestr(&parser, tuple[i].str);
 227                 if (err < 0) {
 228                         printf("failed to parsing\n");
 229                         return TEST_RESULT_FAIL;
 230                 }
 231                 err = charreferparser_getcharnumber(&parser);
 232                 if (err < 0) {
 233                         printf("failed to get character number\n");
 234                         charreferparser_finalize(&parser);
 235                         return TEST_RESULT_FAIL;
 236                 }
 237                 if (err != tuple[i].val) {
 238                         printf("invalid parse result: %d(0x%x)\n", err, err);
 239                         printf("                         <- %s\n", tuple[i].str);
 240                         printf("                         <- %d\n", tuple[i].val);
 241                         printf("                         <- 0x%x\n", tuple[i].val);
 242                         charreferparser_finalize(&parser);
 243                         return TEST_RESULT_FAIL;
 244                 }
 245                 charreferparser_finalize(&parser);
 246         }
 247
 248         return TEST_RESULT_PASS;
 249 }
 250
 251 LOCAL TEST_RESULT test_character_reference_4()
 252 {
 253         W i, len, err;
 254         UB *str;
 255         UB data[] = "&aaa;";
 256         charreferparser_t parser;
 257
 258         err = charreferparser_initialize(&parser);
 259         if (err < 0) {
 260                 return TEST_RESULT_FAIL;
 261         }
 262         for (i = 0; data[i] != '\0'; i++) {
 263                 err = charreferparser_parsechar(&parser, data[i]);
 264                 if (err == CHARREFERPARSER_RESULT_INVALID) {
 265                         break;
 266                 }
 267         }
 268         if (i != 2) {
 269                 printf("failed to invalid position\n");
 270                 charreferparser_finalize(&parser);
 271                 return TEST_RESULT_FAIL;
 272         }
 273         charreferparser_getlastmatchedstring(&parser, &str, &len);
 274         if (len != 1) {
 275                 printf("failed to get last matched string length\n");
 276                 charreferparser_finalize(&parser);
 277                 return TEST_RESULT_FAIL;
 278         }
 279         err = strncmp(data + 1, str, len);
 280         if (err != 0) {
 281                 printf("failed to get last matched string\n");
 282                 charreferparser_finalize(&parser);
 283                 return TEST_RESULT_FAIL;
 284         }
 285         charreferparser_finalize(&parser);
 286
 287         return TEST_RESULT_PASS;
 288 }
 289
 290 LOCAL TEST_RESULT test_character_reference_5()
 291 {
 292         W i, len, err;
 293         UB *str;
 294         UB data[] = "&;";
 295         charreferparser_t parser;
 296
 297         err = charreferparser_initialize(&parser);
 298         if (err < 0) {
 299                 return TEST_RESULT_FAIL;
 300         }
 301         for (i = 0; data[i] != '\0'; i++) {
 302                 err = charreferparser_parsechar(&parser, data[i]);
 303                 if (err == CHARREFERPARSER_RESULT_INVALID) {
 304                         break;
 305                 }
 306         }
 307         if (i != 1) {
 308                 printf("failed to invalid position\n");
 309                 charreferparser_finalize(&parser);
 310                 return TEST_RESULT_FAIL;
 311         }
 312         charreferparser_getlastmatchedstring(&parser, &str, &len);
 313         if (len != 0) {
 314                 printf("failed to get last matched string length\n");
 315                 charreferparser_finalize(&parser);
 316                 return TEST_RESULT_FAIL;
 317         }
 318         err = strncmp(data + 1, str, len);
 319         if (err != 0) {
 320                 printf("failed to get last matched string\n");
 321                 charreferparser_finalize(&parser);
 322                 return TEST_RESULT_FAIL;
 323         }
 324         charreferparser_finalize(&parser);
 325
 326         return TEST_RESULT_PASS;
 327 }
 328
 329 LOCAL TEST_RESULT test_character_reference_6()
 330 {
 331         W i, len, err;
 332         UB *str;
 333         UB data[] = "&amm;";
 334         charreferparser_t parser;
 335
 336         err = charreferparser_initialize(&parser);
 337         if (err < 0) {
 338                 return TEST_RESULT_FAIL;
 339         }
 340         for (i = 0; data[i] != '\0'; i++) {
 341                 err = charreferparser_parsechar(&parser, data[i]);
 342                 if (err == CHARREFERPARSER_RESULT_INVALID) {
 343                         break;
 344                 }
 345         }
 346         if (i != 3) {
 347                 printf("failed to invalid position\n");
 348                 charreferparser_finalize(&parser);
 349                 return TEST_RESULT_FAIL;
 350         }
 351         charreferparser_getlastmatchedstring(&parser, &str, &len);
 352         if (len != 2) {
 353                 printf("failed to get last matched string length\n");
 354                 charreferparser_finalize(&parser);
 355                 return TEST_RESULT_FAIL;
 356         }
 357         err = strncmp(data + 1, str, len);
 358         if (err != 0) {
 359                 printf("failed to get last matched string\n");
 360                 charreferparser_finalize(&parser);
 361                 return TEST_RESULT_FAIL;
 362         }
 363         charreferparser_finalize(&parser);
 364
 365         return TEST_RESULT_PASS;
 366 }
 367
 368 LOCAL TEST_RESULT test_character_reference_7()
 369 {
 370         W i, len, err;
 371         UB *str;
 372         UB data[] = "&amps;";
 373         charreferparser_t parser;
 374
 375         err = charreferparser_initialize(&parser);
 376         if (err < 0) {
 377                 return TEST_RESULT_FAIL;
 378         }
 379         for (i = 0; data[i] != '\0'; i++) {
 380                 err = charreferparser_parsechar(&parser, data[i]);
 381                 if (err == CHARREFERPARSER_RESULT_INVALID) {
 382                         break;
 383                 }
 384         }
 385         if (i != 4) {
 386                 printf("failed to invalid position\n");
 387                 charreferparser_finalize(&parser);
 388                 return TEST_RESULT_FAIL;
 389         }
 390         charreferparser_getlastmatchedstring(&parser, &str, &len);
 391         if (len != 3) {
 392                 printf("failed to get last matched string length\n");
 393                 charreferparser_finalize(&parser);
 394                 return TEST_RESULT_FAIL;
 395         }
 396         err = strncmp(data + 1, str, len);
 397         if (err != 0) {
 398                 printf("failed to get last matched string\n");
 399                 charreferparser_finalize(&parser);
 400                 return TEST_RESULT_FAIL;
 401         }
 402         charreferparser_finalize(&parser);
 403
 404         return TEST_RESULT_PASS;
 405 }
 406
 407 LOCAL TEST_RESULT test_character_reference_8()
 408 {
 409         W i, len, err;
 410         UB *str;
 411         UB data[] = "&qqqq;";
 412         charreferparser_t parser;
 413
 414         err = charreferparser_initialize(&parser);
 415         if (err < 0) {
 416                 return TEST_RESULT_FAIL;
 417         }
 418         for (i = 0; data[i] != '\0'; i++) {
 419                 err = charreferparser_parsechar(&parser, data[i]);
 420                 if (err == CHARREFERPARSER_RESULT_INVALID) {
 421                         break;
 422                 }
 423         }
 424         if (i != 2) {
 425                 printf("failed to invalid position\n");
 426                 charreferparser_finalize(&parser);
 427                 return TEST_RESULT_FAIL;
 428         }
 429         charreferparser_getlastmatchedstring(&parser, &str, &len);
 430         if (len != 1) {
 431                 printf("failed to get last matched string length\n");
 432                 charreferparser_finalize(&parser);
 433                 return TEST_RESULT_FAIL;
 434         }
 435         err = strncmp(data + 1, str, len);
 436         if (err != 0) {
 437                 printf("failed to get last matched string\n");
 438                 charreferparser_finalize(&parser);
 439                 return TEST_RESULT_FAIL;
 440         }
 441         charreferparser_finalize(&parser);
 442
 443         return TEST_RESULT_PASS;
 444 }
 445
 446 LOCAL TEST_RESULT test_character_reference_9()
 447 {
 448         W i, len, err;
 449         UB *str;
 450         UB data[] = "&quuu;";
 451         charreferparser_t parser;
 452
 453         err = charreferparser_initialize(&parser);
 454         if (err < 0) {
 455                 return TEST_RESULT_FAIL;
 456         }
 457         for (i = 0; data[i] != '\0'; i++) {
 458                 err = charreferparser_parsechar(&parser, data[i]);
 459                 if (err == CHARREFERPARSER_RESULT_INVALID) {
 460                         break;
 461                 }
 462         }
 463         if (i != 3) {
 464                 printf("failed to invalid position\n");
 465                 charreferparser_finalize(&parser);
 466                 return TEST_RESULT_FAIL;
 467         }
 468         charreferparser_getlastmatchedstring(&parser, &str, &len);
 469         if (len != 2) {
 470                 printf("failed to get last matched string length\n");
 471                 charreferparser_finalize(&parser);
 472                 return TEST_RESULT_FAIL;
 473         }
 474         err = strncmp(data + 1, str, len);
 475         if (err != 0) {
 476                 printf("failed to get last matched string\n");
 477                 charreferparser_finalize(&parser);
 478                 return TEST_RESULT_FAIL;
 479         }
 480         charreferparser_finalize(&parser);
 481
 482         return TEST_RESULT_PASS;
 483 }
 484
 485 LOCAL TEST_RESULT test_character_reference_10()
 486 {
 487         W i, len, err;
 488         UB *str;
 489         UB data[] = "&quoo;";
 490         charreferparser_t parser;
 491
 492         err = charreferparser_initialize(&parser);
 493         if (err < 0) {
 494                 return TEST_RESULT_FAIL;
 495         }
 496         for (i = 0; data[i] != '\0'; i++) {
 497                 err = charreferparser_parsechar(&parser, data[i]);
 498                 if (err == CHARREFERPARSER_RESULT_INVALID) {
 499                         break;
 500                 }
 501         }
 502         if (i != 4) {
 503                 printf("failed to invalid position\n");
 504                 charreferparser_finalize(&parser);
 505                 return TEST_RESULT_FAIL;
 506         }
 507         charreferparser_getlastmatchedstring(&parser, &str, &len);
 508         if (len != 3) {
 509                 printf("failed to get last matched string length\n");
 510                 charreferparser_finalize(&parser);
 511                 return TEST_RESULT_FAIL;
 512         }
 513         err = strncmp(data + 1, str, len);
 514         if (err != 0) {
 515                 printf("failed to get last matched string\n");
 516                 charreferparser_finalize(&parser);
 517                 return TEST_RESULT_FAIL;
 518         }
 519         charreferparser_finalize(&parser);
 520
 521         return TEST_RESULT_PASS;
 522 }
 523
 524 LOCAL TEST_RESULT test_character_reference_11()
 525 {
 526         W i, len, err;
 527         UB *str;
 528         UB data[] = "&quott;";
 529         charreferparser_t parser;
 530
 531         err = charreferparser_initialize(&parser);
 532         if (err < 0) {
 533                 return TEST_RESULT_FAIL;
 534         }
 535         for (i = 0; data[i] != '\0'; i++) {
 536                 err = charreferparser_parsechar(&parser, data[i]);
 537                 if (err == CHARREFERPARSER_RESULT_INVALID) {
 538                         break;
 539                 }
 540         }
 541         if (i != 5) {
 542                 printf("failed to invalid position\n");
 543                 charreferparser_finalize(&parser);
 544                 return TEST_RESULT_FAIL;
 545         }
 546         charreferparser_getlastmatchedstring(&parser, &str, &len);
 547         if (len != 4) {
 548                 printf("failed to get last matched string length\n");
 549                 charreferparser_finalize(&parser);
 550                 return TEST_RESULT_FAIL;
 551         }
 552         err = strncmp(data + 1, str, len);
 553         if (err != 0) {
 554                 printf("failed to get last matched string\n");
 555                 charreferparser_finalize(&parser);
 556                 return TEST_RESULT_FAIL;
 557         }
 558         charreferparser_finalize(&parser);
 559
 560         return TEST_RESULT_PASS;
 561 }
 562
 563 LOCAL tokenchecker_valuetuple_t test_tokenchecker_testdata_tuple_0001[] = {
 564         {"aaa", 1},
 565         {"ab", 2},
 566         {"abcde", 3},
 567         {"bbb", 4},
 568         {"bcdef", 5},
 569         {"cdefghi", 6},
 570         {"d", 7}
 571 };
 572 LOCAL UB test_tokenchecker_testdata_etoken_0001[] = ":>";
 573
 574 LOCAL TEST_RESULT test_tokenchecker_1()
 575 {
 576         tokenchecker_t checker;
 577         W i, j, len, len2, val, ret;
 578         UB *str, *str2;
 579
 580         str = strdup(test_tokenchecker_testdata_tuple_0001[0].name);
 581         len = strlen(str);
 582
 583         tokenchecker_initialize(&checker,
 584                                                          test_tokenchecker_testdata_tuple_0001,
 585                                                          7,
 586                                                          test_tokenchecker_testdata_etoken_0001);
 587
 588         for (i = 0; i < len; i++) {
 589                 ret = tokenchecker_inputchar(&checker, str[i], &val);
 590                 if (ret != TOKENCHECKER_CONTINUE) {
 591                         printf("tokenchecker_inputchar fail: right string\n");
 592                         free(str);
 593                         return TEST_RESULT_FAIL;
 594                 }
 595                 tokenchecker_getlastmatchedstring(&checker, &str2, &len2);
 596                 if (strncmp(str, str2, len2) != 0) {
 597                         printf("tokenchecker_getlastmatchedstring fail: right string\n");
 598                         printf(" ");
 599                         for (j = 0; j < len; j++) {
 600                                 printf("%c", str[j]);
 601                         }
 602                         printf(" : ");
 603                         for (j = 0; j < len; j++) {
 604                                 printf("%c", str2[j]);
 605                         }
 606                         printf("\n");
 607                         free(str);
 608                         return TEST_RESULT_FAIL;
 609                 }
 610         }
 611         ret = tokenchecker_inputchar(&checker, ':', &val);
 612         if (ret != TOKENCHECKER_DETERMINE) {
 613                 printf("tokenchecker_inputchar fail: end character\n");
 614                 free(str);
 615                 return TEST_RESULT_FAIL;
 616         }
 617         if (val != 1) {
 618                 printf("tokenchecker_inputchar fail: select value\n");
 619                 free(str);
 620                 return TEST_RESULT_FAIL;
 621         }
 622         tokenchecker_getlastmatchedstring(&checker, &str2, &len2);
 623         if (strncmp(str, str2, len2) != 0) {
 624                 printf("tokenchecker_getlastmatchedstring fail: end token\n");
 625                 free(str);
 626                 return TEST_RESULT_FAIL;
 627         }
 628         ret = tokenchecker_inputchar(&checker, ':', &val);
 629         if (ret != TOKENCHECKER_AFTER_END) {
 630                 printf("tokenchecker_inputchar fail: after end\n");
 631                 free(str);
 632                 return TEST_RESULT_FAIL;
 633         }
 634
 635         free(str);
 636         return TEST_RESULT_PASS;
 637 }
 638
 639 LOCAL TEST_RESULT test_tokenchecker_2()
 640 {
 641         tokenchecker_t checker;
 642         W i, j, len, len2, val, ret;
 643         UB *str, *str2;
 644
 645         str = strdup(test_tokenchecker_testdata_tuple_0001[1].name);
 646         len = strlen(str);
 647
 648         tokenchecker_initialize(&checker,
 649                                                          test_tokenchecker_testdata_tuple_0001,
 650                                                          7,
 651                                                          test_tokenchecker_testdata_etoken_0001);
 652
 653         for (i = 0; i < len; i++) {
 654                 ret = tokenchecker_inputchar(&checker, str[i], &val);
 655                 if (ret != TOKENCHECKER_CONTINUE) {
 656                         printf("tokenchecker_inputchar fail: right string\n");
 657                         free(str);
 658                         return TEST_RESULT_FAIL;
 659                 }
 660                 tokenchecker_getlastmatchedstring(&checker, &str2, &len2);
 661                 if (strncmp(str, str2, len2) != 0) {
 662                         printf("tokenchecker_getlastmatchedstring fail: right string\n");
 663                         printf(" ");
 664                         for (j = 0; j < len; j++) {
 665                                 printf("%c", str[j]);
 666                         }
 667                         printf(" : ");
 668                         for (j = 0; j < len; j++) {
 669                                 printf("%c", str2[j]);
 670                         }
 671                         printf("\n");
 672                         free(str);
 673                         return TEST_RESULT_FAIL;
 674                 }
 675         }
 676         ret = tokenchecker_inputchar(&checker, ':', &val);
 677         if (ret != TOKENCHECKER_DETERMINE) {
 678                 printf("tokenchecker_inputchar fail: end character\n");
 679                 free(str);
 680                 return TEST_RESULT_FAIL;
 681         }
 682         if (val != 2) {
 683                 printf("tokenchecker_inputchar fail: select value\n");
 684                 free(str);
 685                 return TEST_RESULT_FAIL;
 686         }
 687         tokenchecker_getlastmatchedstring(&checker, &str2, &len2);
 688         if (strncmp(str, str2, len2) != 0) {
 689                 printf("tokenchecker_getlastmatchedstring fail: end token\n");
 690                 free(str);
 691                 return TEST_RESULT_FAIL;
 692         }
 693         ret = tokenchecker_inputchar(&checker, ':', &val);
 694         if (ret != TOKENCHECKER_AFTER_END) {
 695                 printf("tokenchecker_inputchar fail: after end\n");
 696                 free(str);
 697                 return TEST_RESULT_FAIL;
 698         }
 699
 700         free(str);
 701         return TEST_RESULT_PASS;
 702 }
 703
 704 LOCAL TEST_RESULT test_tokenchecker_3()
 705 {
 706         tokenchecker_t checker;
 707         W i, j, len, len2, val, ret;
 708         UB *str, *str2;
 709
 710         str = strdup(test_tokenchecker_testdata_tuple_0001[2].name);
 711         len = strlen(str);
 712
 713         tokenchecker_initialize(&checker,
 714                                                          test_tokenchecker_testdata_tuple_0001,
 715                                                          7,
 716                                                          test_tokenchecker_testdata_etoken_0001);
 717
 718         for (i = 0; i < len; i++) {
 719                 ret = tokenchecker_inputchar(&checker, str[i], &val);
 720                 if (ret != TOKENCHECKER_CONTINUE) {
 721                         printf("tokenchecker_inputchar fail: right string\n");
 722                         free(str);
 723                         return TEST_RESULT_FAIL;
 724                 }
 725                 tokenchecker_getlastmatchedstring(&checker, &str2, &len2);
 726                 if (strncmp(str, str2, len2) != 0) {
 727                         printf("tokenchecker_getlastmatchedstring fail: right string\n");
 728                         printf(" ");
 729                         for (j = 0; j < len; j++) {
 730                                 printf("%c", str[j]);
 731                         }
 732                         printf(" : ");
 733                         for (j = 0; j < len; j++) {
 734                                 printf("%c", str2[j]);
 735                         }
 736                         printf("\n");
 737                         free(str);
 738                         return TEST_RESULT_FAIL;
 739                 }
 740         }
 741         ret = tokenchecker_inputchar(&checker, ':', &val);
 742         if (ret != TOKENCHECKER_DETERMINE) {
 743                 printf("tokenchecker_inputchar fail: end character\n");
 744                 free(str);
 745                 return TEST_RESULT_FAIL;
 746         }
 747         if (val != 3) {
 748                 printf("tokenchecker_inputchar fail: select value\n");
 749                 free(str);
 750                 return TEST_RESULT_FAIL;
 751         }
 752         tokenchecker_getlastmatchedstring(&checker, &str2, &len2);
 753         if (strncmp(str, str2, len2) != 0) {
 754                 printf("tokenchecker_getlastmatchedstring fail: end token\n");
 755                 free(str);
 756                 return TEST_RESULT_FAIL;
 757         }
 758         ret = tokenchecker_inputchar(&checker, ':', &val);
 759         if (ret != TOKENCHECKER_AFTER_END) {
 760                 printf("tokenchecker_inputchar fail: after end\n");
 761                 free(str);
 762                 return TEST_RESULT_FAIL;
 763         }
 764
 765         free(str);
 766         return TEST_RESULT_PASS;
 767 }
 768
 769 LOCAL TEST_RESULT test_tokenchecker_4()
 770 {
 771         tokenchecker_t checker;
 772         W i, j, len, len2, val, ret;
 773         UB *str, *str2;
 774
 775         str = strdup(test_tokenchecker_testdata_tuple_0001[3].name);
 776         len = strlen(str);
 777
 778         tokenchecker_initialize(&checker,
 779                                                          test_tokenchecker_testdata_tuple_0001,
 780                                                          7,
 781                                                          test_tokenchecker_testdata_etoken_0001);
 782
 783         for (i = 0; i < len; i++) {
 784                 ret = tokenchecker_inputchar(&checker, str[i], &val);
 785                 if (ret != TOKENCHECKER_CONTINUE) {
 786                         printf("tokenchecker_inputchar fail: right string\n");
 787                         free(str);
 788                         return TEST_RESULT_FAIL;
 789                 }
 790                 tokenchecker_getlastmatchedstring(&checker, &str2, &len2);
 791                 if (strncmp(str, str2, len2) != 0) {
 792                         printf("tokenchecker_getlastmatchedstring fail: right string\n");
 793                         printf(" ");
 794                         for (j = 0; j < len; j++) {
 795                                 printf("%c", str[j]);
 796                         }
 797                         printf(" : ");
 798                         for (j = 0; j < len; j++) {
 799                                 printf("%c", str2[j]);
 800                         }
 801                         printf("\n");
 802                         free(str);
 803                         return TEST_RESULT_FAIL;
 804                 }
 805         }
 806         ret = tokenchecker_inputchar(&checker, ':', &val);
 807         if (ret != TOKENCHECKER_DETERMINE) {
 808                 printf("tokenchecker_inputchar fail: end character\n");
 809                 free(str);
 810                 return TEST_RESULT_FAIL;
 811         }
 812         if (val != 4) {
 813                 printf("tokenchecker_inputchar fail: select value\n");
 814                 free(str);
 815                 return TEST_RESULT_FAIL;
 816         }
 817         tokenchecker_getlastmatchedstring(&checker, &str2, &len2);
 818         if (strncmp(str, str2, len2) != 0) {
 819                 printf("tokenchecker_getlastmatchedstring fail: end token\n");
 820                 free(str);
 821                 return TEST_RESULT_FAIL;
 822         }
 823         ret = tokenchecker_inputchar(&checker, ':', &val);
 824         if (ret != TOKENCHECKER_AFTER_END) {
 825                 printf("tokenchecker_inputchar fail: after end\n");
 826                 free(str);
 827                 return TEST_RESULT_FAIL;
 828         }
 829
 830         free(str);
 831         return TEST_RESULT_PASS;
 832 }
 833
 834 LOCAL TEST_RESULT test_tokenchecker_5()
 835 {
 836         tokenchecker_t checker;
 837         W i, j, len, len2, val, ret;
 838         UB *str, *str2;
 839
 840         str = strdup(test_tokenchecker_testdata_tuple_0001[4].name);
 841         len = strlen(str);
 842
 843         tokenchecker_initialize(&checker,
 844                                                          test_tokenchecker_testdata_tuple_0001,
 845                                                          7,
 846                                                          test_tokenchecker_testdata_etoken_0001);
 847
 848         for (i = 0; i < len; i++) {
 849                 ret = tokenchecker_inputchar(&checker, str[i], &val);
 850                 if (ret != TOKENCHECKER_CONTINUE) {
 851                         printf("tokenchecker_inputchar fail: right string\n");
 852                         free(str);
 853                         return TEST_RESULT_FAIL;
 854                 }
 855                 tokenchecker_getlastmatchedstring(&checker, &str2, &len2);
 856                 if (strncmp(str, str2, len2) != 0) {
 857                         printf("tokenchecker_getlastmatchedstring fail: right string\n");
 858                         printf(" ");
 859                         for (j = 0; j < len; j++) {
 860                                 printf("%c", str[j]);
 861                         }
 862                         printf(" : ");
 863                         for (j = 0; j < len; j++) {
 864                                 printf("%c", str2[j]);
 865                         }
 866                         printf("\n");
 867                         free(str);
 868                         return TEST_RESULT_FAIL;
 869                 }
 870         }
 871         ret = tokenchecker_inputchar(&checker, ':', &val);
 872         if (ret != TOKENCHECKER_DETERMINE) {
 873                 printf("tokenchecker_inputchar fail: end character\n");
 874                 free(str);
 875                 return TEST_RESULT_FAIL;
 876         }
 877         if (val != 5) {
 878                 printf("tokenchecker_inputchar fail: select value\n");
 879                 free(str);
 880                 return TEST_RESULT_FAIL;
 881         }
 882         tokenchecker_getlastmatchedstring(&checker, &str2, &len2);
 883         if (strncmp(str, str2, len2) != 0) {
 884                 printf("tokenchecker_getlastmatchedstring fail: end token\n");
 885                 free(str);
 886                 return TEST_RESULT_FAIL;
 887         }
 888         ret = tokenchecker_inputchar(&checker, ':', &val);
 889         if (ret != TOKENCHECKER_AFTER_END) {
 890                 printf("tokenchecker_inputchar fail: after end\n");
 891                 free(str);
 892                 return TEST_RESULT_FAIL;
 893         }
 894
 895         free(str);
 896         return TEST_RESULT_PASS;
 897 }
 898
 899 LOCAL TEST_RESULT test_tokenchecker_6()
 900 {
 901         tokenchecker_t checker;
 902         W i, j, len, len2, val, ret;
 903         UB *str, *str2;
 904
 905         str = strdup(test_tokenchecker_testdata_tuple_0001[5].name);
 906         len = strlen(str);
 907
 908         tokenchecker_initialize(&checker,
 909                                                          test_tokenchecker_testdata_tuple_0001,
 910                                                          7,
 911                                                          test_tokenchecker_testdata_etoken_0001);
 912
 913         for (i = 0; i < len; i++) {
 914                 ret = tokenchecker_inputchar(&checker, str[i], &val);
 915                 if (ret != TOKENCHECKER_CONTINUE) {
 916                         printf("tokenchecker_inputchar fail: right string\n");
 917                         free(str);
 918                         return TEST_RESULT_FAIL;
 919                 }
 920                 tokenchecker_getlastmatchedstring(&checker, &str2, &len2);
 921                 if (strncmp(str, str2, len2) != 0) {
 922                         printf("tokenchecker_getlastmatchedstring fail: right string\n");
 923                         printf(" ");
 924                         for (j = 0; j < len; j++) {
 925                                 printf("%c", str[j]);
 926                         }
 927                         printf(" : ");
 928                         for (j = 0; j < len; j++) {
 929                                 printf("%c", str2[j]);
 930                         }
 931                         printf("\n");
 932                         free(str);
 933                         return TEST_RESULT_FAIL;
 934                 }
 935         }
 936         ret = tokenchecker_inputchar(&checker, ':', &val);
 937         if (ret != TOKENCHECKER_DETERMINE) {
 938                 printf("tokenchecker_inputchar fail: end character\n");
 939                 free(str);
 940                 return TEST_RESULT_FAIL;
 941         }
 942         if (val != 6) {
 943                 printf("tokenchecker_inputchar fail: select value\n");
 944                 free(str);
 945                 return TEST_RESULT_FAIL;
 946         }
 947         tokenchecker_getlastmatchedstring(&checker, &str2, &len2);
 948         if (strncmp(str, str2, len2) != 0) {
 949                 printf("tokenchecker_getlastmatchedstring fail: end token\n");
 950                 free(str);
 951                 return TEST_RESULT_FAIL;
 952         }
 953         ret = tokenchecker_inputchar(&checker, ':', &val);
 954         if (ret != TOKENCHECKER_AFTER_END) {
 955                 printf("tokenchecker_inputchar fail: after end\n");
 956                 free(str);
 957                 return TEST_RESULT_FAIL;
 958         }
 959
 960         free(str);
 961         return TEST_RESULT_PASS;
 962 }
 963
 964 LOCAL TEST_RESULT test_tokenchecker_7()
 965 {
 966         tokenchecker_t checker;
 967         W i, j, len, len2, val, ret;
 968         UB *str, *str2;
 969
 970         str = strdup(test_tokenchecker_testdata_tuple_0001[6].name);
 971         len = strlen(str);
 972
 973         tokenchecker_initialize(&checker,
 974                                                          test_tokenchecker_testdata_tuple_0001,
 975                                                          7,
 976                                                          test_tokenchecker_testdata_etoken_0001);
 977
 978         for (i = 0; i < len; i++) {
 979                 ret = tokenchecker_inputchar(&checker, str[i], &val);
 980                 if (ret != TOKENCHECKER_CONTINUE) {
 981                         printf("tokenchecker_inputchar fail: right string\n");
 982                         free(str);
 983                         return TEST_RESULT_FAIL;
 984                 }
 985                 tokenchecker_getlastmatchedstring(&checker, &str2, &len2);
 986                 if (strncmp(str, str2, len2) != 0) {
 987                         printf("tokenchecker_getlastmatchedstring fail: right string\n");
 988                         printf(" ");
 989                         for (j = 0; j < len; j++) {
 990                                 printf("%c", str[j]);
 991                         }
 992                         printf(" : ");
 993                         for (j = 0; j < len; j++) {
 994                                 printf("%c", str2[j]);
 995                         }
 996                         printf("\n");
 997                         free(str);
 998                         return TEST_RESULT_FAIL;
 999                 }
1000         }
1001         ret = tokenchecker_inputchar(&checker, ':', &val);
1002         if (ret != TOKENCHECKER_DETERMINE) {
1003                 printf("tokenchecker_inputchar fail: end character\n");
1004                 free(str);
1005                 return TEST_RESULT_FAIL;
1006         }
1007         if (val != 7) {
1008                 printf("tokenchecker_inputchar fail: select value\n");
1009                 free(str);
1010                 return TEST_RESULT_FAIL;
1011         }
1012         tokenchecker_getlastmatchedstring(&checker, &str2, &len2);
1013         if (strncmp(str, str2, len2) != 0) {
1014                 printf("tokenchecker_getlastmatchedstring fail: end token\n");
1015                 free(str);
1016                 return TEST_RESULT_FAIL;
1017         }
1018         ret = tokenchecker_inputchar(&checker, ':', &val);
1019         if (ret != TOKENCHECKER_AFTER_END) {
1020                 printf("tokenchecker_inputchar fail: after end\n");
1021                 free(str);
1022                 return TEST_RESULT_FAIL;
1023         }
1024
1025         free(str);
1026         return TEST_RESULT_PASS;
1027 }
1028
1029 LOCAL TEST_RESULT test_tokenchecker_nomatch_getlastmatchedstring_sequence(tokenchecker_t *checker, W num, UB *teststr, W teststr_len)
1030 {
1031         W i, j, len2, ret, val;
1032         UB *str2;
1033
1034         for (i = 0; i < num; i++) {
1035                 ret = tokenchecker_inputchar(checker, teststr[i], &val);
1036                 if (ret != TOKENCHECKER_CONTINUE) {
1037                         printf("tokenchecker_inputchar fail: right string\n");
1038                         return TEST_RESULT_FAIL;
1039                 }
1040         }
1041         ret = tokenchecker_inputchar(checker, 'z', &val);
1042         if (ret != TOKENCHECKER_CONTINUE_NOMATCH) {
1043                 printf("tokenchecker_inputchar fail: nomatch char\n");
1044                 return TEST_RESULT_FAIL;
1045         }
1046         tokenchecker_getlastmatchedstring(checker, &str2, &len2);
1047         if (len2 != num) {
1048                 printf("tokenchecker_getlastmatchedstring fail: length\n");
1049                 return TEST_RESULT_FAIL;
1050         }
1051         if (strncmp(teststr, str2, len2) != 0) {
1052                 printf("tokenchecker_getlastmatchedstring fail: nomatch string\n");
1053                 printf(" ");
1054                 for (j = 0; j < len2; j++) {
1055                         printf("%c", teststr[j]);
1056                 }
1057                 printf(" : ");
1058                 for (j = 0; j < len2; j++) {
1059                         printf("%c", str2[j]);
1060                 }
1061                 printf("\n");
1062                 return TEST_RESULT_FAIL;
1063         }
1064
1065         return TEST_RESULT_PASS;
1066 }
1067
1068 LOCAL TEST_RESULT test_tokenchecker_8()
1069 {
1070         tokenchecker_t checker;
1071         W i,len;
1072         UB *str;
1073         TEST_RESULT result;
1074
1075         str = strdup(test_tokenchecker_testdata_tuple_0001[0].name);
1076         len = strlen(str);
1077
1078         tokenchecker_initialize(&checker,
1079                                                          test_tokenchecker_testdata_tuple_0001,
1080                                                          7,
1081                                                          test_tokenchecker_testdata_etoken_0001);
1082
1083         for (i = 1; i < len; i++) {
1084                 result = test_tokenchecker_nomatch_getlastmatchedstring_sequence(&checker, i, str, len);
1085                 if (result != TEST_RESULT_PASS) {
1086                         return result;
1087                 }
1088                 tokenchecker_clear(&checker);
1089         }
1090
1091         free(str);
1092
1093         return TEST_RESULT_PASS;
1094 }
1095
1096 LOCAL TEST_RESULT test_tokenchecker_9()
1097 {
1098         tokenchecker_t checker;
1099         W i,len;
1100         UB *str;
1101         TEST_RESULT result;
1102
1103         str = strdup(test_tokenchecker_testdata_tuple_0001[1].name);
1104         len = strlen(str);
1105
1106         tokenchecker_initialize(&checker,
1107                                                          test_tokenchecker_testdata_tuple_0001,
1108                                                          7,
1109                                                          test_tokenchecker_testdata_etoken_0001);
1110
1111         for (i = 1; i < len; i++) {
1112                 result = test_tokenchecker_nomatch_getlastmatchedstring_sequence(&checker, i, str, len);
1113                 if (result != TEST_RESULT_PASS) {
1114                         return result;
1115                 }
1116                 tokenchecker_clear(&checker);
1117         }
1118
1119         free(str);
1120
1121         return TEST_RESULT_PASS;
1122 }
1123
1124 LOCAL TEST_RESULT test_tokenchecker_10()
1125 {
1126         tokenchecker_t checker;
1127         W i,len;
1128         UB *str;
1129         TEST_RESULT result;
1130
1131         str = strdup(test_tokenchecker_testdata_tuple_0001[2].name);
1132         len = strlen(str);
1133
1134         tokenchecker_initialize(&checker,
1135                                                          test_tokenchecker_testdata_tuple_0001,
1136                                                          7,
1137                                                          test_tokenchecker_testdata_etoken_0001);
1138
1139         for (i = 1; i < len; i++) {
1140                 result = test_tokenchecker_nomatch_getlastmatchedstring_sequence(&checker, i, str, len);
1141                 if (result != TEST_RESULT_PASS) {
1142                         return result;
1143                 }
1144                 tokenchecker_clear(&checker);
1145         }
1146
1147         free(str);
1148
1149         return TEST_RESULT_PASS;
1150 }
1151
1152 LOCAL TEST_RESULT test_tokenchecker_11()
1153 {
1154         tokenchecker_t checker;
1155         W i,len;
1156         UB *str;
1157         TEST_RESULT result;
1158
1159         str = strdup(test_tokenchecker_testdata_tuple_0001[3].name);
1160         len = strlen(str);
1161
1162         tokenchecker_initialize(&checker,
1163                                                          test_tokenchecker_testdata_tuple_0001,
1164                                                          7,
1165                                                          test_tokenchecker_testdata_etoken_0001);
1166
1167         for (i = 1; i < len; i++) {
1168                 result = test_tokenchecker_nomatch_getlastmatchedstring_sequence(&checker, i, str, len);
1169                 if (result != TEST_RESULT_PASS) {
1170                         return result;
1171                 }
1172                 tokenchecker_clear(&checker);
1173         }
1174
1175         free(str);
1176
1177         return TEST_RESULT_PASS;
1178 }
1179
1180 LOCAL TEST_RESULT test_tokenchecker_12()
1181 {
1182         tokenchecker_t checker;
1183         W i,len;
1184         UB *str;
1185         TEST_RESULT result;
1186
1187         str = strdup(test_tokenchecker_testdata_tuple_0001[4].name);
1188         len = strlen(str);
1189
1190         tokenchecker_initialize(&checker,
1191                                                          test_tokenchecker_testdata_tuple_0001,
1192                                                          7,
1193                                                          test_tokenchecker_testdata_etoken_0001);
1194
1195         for (i = 1; i < len; i++) {
1196                 result = test_tokenchecker_nomatch_getlastmatchedstring_sequence(&checker, i, str, len);
1197                 if (result != TEST_RESULT_PASS) {
1198                         return result;
1199                 }
1200                 tokenchecker_clear(&checker);
1201         }
1202
1203         free(str);
1204
1205         return TEST_RESULT_PASS;
1206 }
1207
1208 LOCAL TEST_RESULT test_tokenchecker_13()
1209 {
1210         tokenchecker_t checker;
1211         W i,len;
1212         UB *str;
1213         TEST_RESULT result;
1214
1215         str = strdup(test_tokenchecker_testdata_tuple_0001[5].name);
1216         len = strlen(str);
1217
1218         tokenchecker_initialize(&checker,
1219                                                          test_tokenchecker_testdata_tuple_0001,
1220                                                          7,
1221                                                          test_tokenchecker_testdata_etoken_0001);
1222
1223         for (i = 1; i < len; i++) {
1224                 result = test_tokenchecker_nomatch_getlastmatchedstring_sequence(&checker, i, str, len);
1225                 if (result != TEST_RESULT_PASS) {
1226                         return result;
1227                 }
1228                 tokenchecker_clear(&checker);
1229         }
1230
1231         free(str);
1232
1233         return TEST_RESULT_PASS;
1234 }
1235
1236 LOCAL TEST_RESULT test_tokenchecker_14()
1237 {
1238         tokenchecker_t checker;
1239         W i,len;
1240         UB *str;
1241         TEST_RESULT result;
1242
1243         str = strdup(test_tokenchecker_testdata_tuple_0001[6].name);
1244         len = strlen(str);
1245
1246         tokenchecker_initialize(&checker,
1247                                                          test_tokenchecker_testdata_tuple_0001,
1248                                                          7,
1249                                                          test_tokenchecker_testdata_etoken_0001);
1250
1251         for (i = 1; i < len; i++) {
1252                 result = test_tokenchecker_nomatch_getlastmatchedstring_sequence(&checker, i, str, len);
1253                 if (result != TEST_RESULT_PASS) {
1254                         return result;
1255                 }
1256                 tokenchecker_clear(&checker);
1257         }
1258
1259         free(str);
1260
1261         return TEST_RESULT_PASS;
1262 }
1263
1264 LOCAL VOID test_parselib_printresult(TEST_RESULT (*proc)(), B *test_name)
1265 {
1266         TEST_RESULT result;
1267
1268         printf("test_parselib: %s\n", test_name);
1269         printf("---------------------------------------------\n");
1270         result = proc();
1271         if (result == TEST_RESULT_PASS) {
1272                 printf("--pass---------------------------------------\n");
1273         } else {
1274                 printf("--fail---------------------------------------\n");
1275         }
1276         printf("---------------------------------------------\n");
1277 }
1278
1279 EXPORT VOID test_parselib_main()
1280 {
1281         test_parselib_printresult(test_character_reference_1, "test_character_reference_1");
1282         test_parselib_printresult(test_character_reference_2, "test_character_reference_2");
1283         test_parselib_printresult(test_character_reference_3, "test_character_reference_3");
1284         test_parselib_printresult(test_character_reference_4, "test_character_reference_4");
1285         test_parselib_printresult(test_character_reference_5, "test_character_reference_5");
1286         test_parselib_printresult(test_character_reference_6, "test_character_reference_6");
1287         test_parselib_printresult(test_character_reference_7, "test_character_reference_7");
1288         test_parselib_printresult(test_character_reference_8, "test_character_reference_8");
1289         test_parselib_printresult(test_character_reference_9, "test_character_reference_9");
1290         test_parselib_printresult(test_character_reference_10, "test_character_reference_10");
1291         test_parselib_printresult(test_character_reference_11, "test_character_reference_11");
1292         test_parselib_printresult(test_tokenchecker_1, "test_tokenchecker_1");
1293         test_parselib_printresult(test_tokenchecker_2, "test_tokenchecker_2");
1294         test_parselib_printresult(test_tokenchecker_3, "test_tokenchecker_3");
1295         test_parselib_printresult(test_tokenchecker_4, "test_tokenchecker_4");
1296         test_parselib_printresult(test_tokenchecker_5, "test_tokenchecker_5");
1297         test_parselib_printresult(test_tokenchecker_6, "test_tokenchecker_6");
1298         test_parselib_printresult(test_tokenchecker_7, "test_tokenchecker_7");
1299         test_parselib_printresult(test_tokenchecker_8, "test_tokenchecker_8");
1300         test_parselib_printresult(test_tokenchecker_9, "test_tokenchecker_9");
1301         test_parselib_printresult(test_tokenchecker_10, "test_tokenchecker_10");
1302         test_parselib_printresult(test_tokenchecker_11, "test_tokenchecker_11");
1303         test_parselib_printresult(test_tokenchecker_12, "test_tokenchecker_12");
1304         test_parselib_printresult(test_tokenchecker_13, "test_tokenchecker_13");
1305         test_parselib_printresult(test_tokenchecker_14, "test_tokenchecker_14");
1306 }