src/tad/test_tadfragment.c

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