src/parse/test_parselib.c

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