code_c/Maasha/src/test/test_list.c

   1 /* Martin Asser Hansen (mail@maasha.dk) Copyright (C) 2008 - All right reserved */
   2
   3 #include "common.h"
   4 #include "mem.h"
   5 #include "list.h"
   6
   7
   8 static void test_list_sl_new();
   9 static void test_node_sl_new();
  10 static void test_list_sl_add_beg();
  11 static void test_list_sl_add_after();
  12 static void test_list_sl_remove_beg();
  13 static void test_list_sl_remove_after();
  14 static void test_list_sl_print();
  15 static void test_list_sl_sort();
  16 static void test_list_sl_destroy();
  17 static void test_node_sl_destroy();
  18
  19 static void test_list_dl_new();
  20 static void test_node_dl_new();
  21 static void test_list_dl_add_beg();
  22 static void test_list_dl_add_end();
  23 static void test_list_dl_add_before();
  24 static void test_list_dl_add_after();
  25 static void test_list_dl_remove();
  26 static void test_list_dl_print();
  27 static void test_list_dl_destroy();
  28 static void test_node_dl_destroy();
  29
  30 static void test_list_count();
  31
  32
  33 int main()
  34 {
  35     fprintf( stderr, "Running all tests for list.c\n" );
  36
  37     test_list_sl_new();
  38     test_node_sl_new();
  39     test_list_sl_add_beg();
  40     test_list_sl_add_after();
  41     test_list_sl_remove_beg();
  42     test_list_sl_remove_after();
  43     test_list_sl_print();
  44     test_list_sl_sort();
  45     test_list_sl_destroy();
  46     test_node_sl_destroy();
  47
  48     test_list_dl_new();
  49     test_node_dl_new();
  50     test_list_dl_add_beg();
  51     test_list_dl_add_end();
  52     test_list_dl_add_before();
  53     test_list_dl_add_after();
  54     test_list_dl_remove();
  55     test_list_dl_print();
  56     test_list_dl_destroy();
  57     test_node_dl_destroy();
  58
  59     test_list_count();
  60
  61     fprintf( stderr, "Done\n\n" );
  62
  63     return EXIT_SUCCESS;
  64 }
  65
  66
  67 /* >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> SINGLY LINKED LIST <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<< */
  68
  69
  70 void test_list_sl_new()
  71 {
  72     fprintf( stderr, "   Testing list_sl_new ... " );
  73
  74     list_sl *list = NULL;
  75
  76     list = list_sl_new();
  77
  78     assert( list != NULL );
  79     assert( list->first == NULL );
  80
  81     fprintf( stderr, "OK\n" );
  82 }
  83
  84
  85 void test_node_sl_new()
  86 {
  87     fprintf( stderr, "   Testing node_sl_new ... " );
  88
  89     node_sl *node = NULL;
  90
  91     node = node_sl_new();
  92
  93     assert( node != NULL );
  94     assert( node->next == NULL );
  95     assert( node->val  == NULL );
  96
  97     fprintf( stderr, "OK\n" );
  98 }
  99
 100
 101 void test_list_sl_add_beg()
 102 {
 103     fprintf( stderr, "   Testing list_sl_add_beg ... " );
 104
 105     char    *array[3] = { "test1", "test2", "test3" };
 106     list_sl *list     = NULL;
 107     node_sl *node     = NULL;
 108     int      i        = 0;
 109
 110     list = list_sl_new();
 111
 112     for ( i = 0; i < 3; i++ )
 113     {
 114         node = node_sl_new();
 115
 116         node->val = array[ i ];
 117
 118         list_sl_add_beg( &list, &node );
 119     }
 120
 121     i = 2;
 122
 123     for ( node = list->first; node != NULL; node = node->next )
 124     {
 125         assert( strcmp( array[ i ], ( char * ) node->val ) == 0 );
 126
 127         i--;
 128     }
 129
 130     fprintf( stderr, "OK\n" );
 131 }
 132
 133
 134 void test_list_sl_add_after()
 135 {
 136     fprintf( stderr, "   Testing list_sl_add_after ... " );
 137
 138     char    *array[3] = { "test1", "test2", "test3" };
 139     list_sl *list     = NULL;
 140     node_sl *node     = NULL;
 141     node_sl *new_node = NULL;
 142     int      i        = 0;
 143
 144     list     = list_sl_new();
 145     new_node = node_sl_new();
 146
 147     new_node->val = array[ 0 ];
 148
 149     list_sl_add_beg( &list, &new_node );
 150
 151     node = new_node;
 152
 153     for ( i = 1; i < 3; i++ )
 154     {
 155         new_node = node_sl_new();
 156
 157         new_node->val = array[ i ];
 158
 159         list_sl_add_after( &node, &new_node );
 160
 161         node = new_node;
 162     }
 163
 164     i = 0;
 165
 166     for ( node = list->first; node != NULL; node = node->next )
 167     {
 168         assert( strcmp( array[ i ], ( char * ) node->val ) == 0 );
 169
 170         i++;
 171     }
 172
 173     fprintf( stderr, "OK\n" );
 174 }
 175
 176
 177 void test_list_sl_remove_beg()
 178 {
 179     fprintf( stderr, "   Testing list_sl_remove_beg ... " );
 180
 181     char    *array[3] = { "test1", "test2", "test3" };
 182     list_sl *list     = NULL;
 183     node_sl *node     = NULL;
 184     node_sl *new_node = NULL;
 185     int      i        = 0;
 186
 187     list     = list_sl_new();
 188     new_node = node_sl_new();
 189
 190     new_node->val = array[ 0 ];
 191
 192     list_sl_add_beg( &list, &new_node );
 193
 194     node = new_node;
 195
 196     for ( i = 1; i < 3; i++ )
 197     {
 198         new_node = node_sl_new();
 199
 200         new_node->val = array[ i ];
 201
 202         list_sl_add_after( &node, &new_node );
 203
 204         node = new_node;
 205     }
 206
 207     i = 0;
 208
 209     node = list->first;
 210
 211     while ( node != NULL )
 212     {
 213         assert( strcmp( ( char * ) node->val, array[ i ] ) == 0 );
 214
 215         list_sl_remove_beg( &list );
 216
 217         node = list->first;
 218
 219         i++;
 220     }
 221
 222     fprintf( stderr, "OK\n" );
 223 }
 224
 225
 226 void test_list_sl_remove_after()
 227 {
 228     fprintf( stderr, "   Testing list_sl_remove_after ... " );
 229
 230     char    *array[3] = { "test1", "test2", "test3" };
 231     list_sl *list     = NULL;
 232     node_sl *node     = NULL;
 233     node_sl *new_node = NULL;
 234     int      i        = 0;
 235
 236     list     = list_sl_new();
 237     new_node = node_sl_new();
 238
 239     new_node->val = array[ 0 ];
 240
 241     list_sl_add_beg( &list, &new_node );
 242
 243     node = new_node;
 244
 245     for ( i = 1; i < 3; i++ )
 246     {
 247         new_node = node_sl_new();
 248
 249         new_node->val = array[ i ];
 250
 251         list_sl_add_after( &node, &new_node );
 252
 253         node = new_node;
 254     }
 255
 256     assert( strcmp( ( char * ) list->first->next->val, "test2" ) == 0 );
 257
 258     list_sl_remove_after( &list->first );
 259
 260     assert( strcmp( ( char * ) list->first->next->val, "test3" ) == 0 );
 261
 262     fprintf( stderr, "OK\n" );
 263 }
 264
 265
 266 void test_list_sl_print()
 267 {
 268     fprintf( stderr, "   Testing list_sl_print ... " );
 269
 270     list_sl *list  = NULL;
 271     node_sl *node1 = NULL;
 272     node_sl *node2 = NULL;
 273     node_sl *node3 = NULL;
 274
 275     list = list_sl_new();
 276
 277     node1 = node_sl_new();
 278     node2 = node_sl_new();
 279     node3 = node_sl_new();
 280
 281     node1->val = "TEST1";
 282     node2->val = "TEST2";
 283     node3->val = "TEST3";
 284
 285     list_sl_add_beg( &list, &node1 );
 286     list_sl_add_beg( &list, &node2 );
 287     list_sl_add_beg( &list, &node3 );
 288
 289     // list_sl_print( list );
 290
 291     fprintf( stderr, "OK\n" );
 292 }
 293
 294
 295 void test_list_sl_sort()
 296 {
 297     fprintf( stderr, "   Testing list_sl_sort ... " );
 298
 299     /* Sorting a char list */
 300
 301     char    *array[3] = { "test1", "test2", "test3" };
 302     list_sl *list     = NULL;
 303     node_sl *node     = NULL;
 304     int      i        = 0;
 305
 306     list = list_sl_new();
 307
 308     for ( i = 0; i < 3; i++ )
 309     {
 310         node = node_sl_new();
 311
 312         node->val = array[ i ];
 313
 314         list_sl_add_beg( &list, &node );
 315     }
 316
 317     list_sl_sort( &list, cmp_list_sl_char_asc );
 318     list_sl_sort( &list, cmp_list_sl_char_desc );
 319
 320 //    /* Sorting a int list */
 321 //
 322 //    int int_array[ 5 ] = { 345, 23, 23, 1, 400 };
 323 //    list_sl *int_list  = NULL;
 324 //    node_sl *int_node  = NULL;
 325 //
 326 //    int_list = list_sl_new();
 327 //
 328 //    for ( i = 0; i < 5; i++ )
 329 //    {
 330 //        printf( "int: %d\n", int_array[ i ] );
 331 //
 332 //        int_node = node_sl_new();
 333 //
 334 //        node->val = int_array[ i ];
 335 //    }
 336
 337     fprintf( stderr, "OK\n" );
 338 }
 339
 340
 341 void test_list_sl_destroy()
 342 {
 343     fprintf( stderr, "   Testing list_sl_destroy ... " );
 344
 345     list_sl *list  = list_sl_new();
 346     node_sl *node1 = node_sl_new();
 347     node_sl *node2 = node_sl_new();
 348     node_sl *node3 = node_sl_new();
 349
 350     node1->val = mem_get( 10 );
 351     node2->val = mem_get( 10 );
 352     node3->val = mem_get( 10 );
 353
 354     list_sl_add_beg( &list, &node1 );
 355     list_sl_add_beg( &list, &node2 );
 356     list_sl_add_beg( &list, &node3 );
 357
 358     list_sl_destroy( &list );
 359
 360     assert( list == NULL );
 361
 362     fprintf( stderr, "OK\n" );
 363 }
 364
 365
 366 void test_node_sl_destroy()
 367 {
 368     fprintf( stderr, "   Testing node_sl_destroy ... " );
 369
 370     node_sl *node = NULL;
 371     char    *str  = NULL;
 372
 373     str  = mem_get( 1000000000 );
 374
 375     node = node_sl_new();
 376
 377     node->val = str;
 378
 379     node_sl_destroy( &node );
 380
 381     assert( node == NULL );
 382
 383     fprintf( stderr, "OK\n" );
 384 }
 385
 386
 387 /* >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> DOUBLY LINKED LIST <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<< */
 388
 389
 390 void test_list_dl_new()
 391 {
 392     fprintf( stderr, "   Testing list_dl_new ... " );
 393
 394     list_dl *list = NULL;
 395
 396     list = list_dl_new();
 397
 398     assert( list->first == NULL );
 399     assert( list->last  == NULL );
 400
 401     fprintf( stderr, "OK\n" );
 402 }
 403
 404
 405 void test_node_dl_new()
 406 {
 407     fprintf( stderr, "   Testing node_dl_new ... " );
 408
 409     node_dl *node = NULL;
 410
 411     node = node_dl_new();
 412
 413     assert( node->next == NULL );
 414     assert( node->prev == NULL );
 415     assert( node->val  == NULL );
 416
 417     fprintf( stderr, "OK\n" );
 418 }
 419
 420
 421 void test_list_dl_add_beg()
 422 {
 423     fprintf( stderr, "   Testing list_dl_add_beg ... " );
 424
 425     list_dl *list  = list_dl_new();
 426     node_dl *node1 = node_dl_new();
 427     node_dl *node2 = node_dl_new();
 428     node_dl *node3 = node_dl_new();
 429
 430     node1->val = "TEST1";
 431     node2->val = "TEST2";
 432     node3->val = "TEST3";
 433
 434     list_dl_add_beg( &list, &node1 );
 435
 436     assert( strcmp( list->first->val, "TEST1" ) == 0 );
 437
 438     list_dl_add_beg( &list, &node2 );
 439
 440     assert( strcmp( list->first->val, "TEST2" ) == 0 );
 441
 442     list_dl_add_beg( &list, &node3 );
 443
 444     assert( strcmp( list->first->val, "TEST3" ) == 0 );
 445
 446     fprintf( stderr, "OK\n" );
 447 }
 448
 449
 450 void test_list_dl_add_end()
 451 {
 452     fprintf( stderr, "   Testing list_dl_add_end ... " );
 453
 454     list_dl *list  = list_dl_new();
 455     node_dl *node1 = node_dl_new();
 456     node_dl *node2 = node_dl_new();
 457     node_dl *node3 = node_dl_new();
 458
 459     node1->val = "TEST1";
 460     node2->val = "TEST2";
 461     node3->val = "TEST3";
 462
 463     list_dl_add_end( &list, &node1 );
 464
 465     assert( strcmp( list->last->val, "TEST1" ) == 0 );
 466
 467     list_dl_add_end( &list, &node2 );
 468
 469     assert( strcmp( list->last->val, "TEST2" ) == 0 );
 470
 471     list_dl_add_end( &list, &node3 );
 472
 473     assert( strcmp( list->last->val, "TEST3" ) == 0 );
 474
 475     fprintf( stderr, "OK\n" );
 476 }
 477
 478
 479 void test_list_dl_add_before()
 480 {
 481     fprintf( stderr, "   Testing list_dl_add_before ... " );
 482
 483     list_dl *list  = list_dl_new();
 484     node_dl *node1 = node_dl_new();
 485     node_dl *node2 = node_dl_new();
 486     node_dl *node3 = node_dl_new();
 487
 488     node1->val = "TEST1";
 489     node2->val = "TEST2";
 490     node3->val = "TEST3";
 491
 492     list_dl_add_beg( &list, &node1 );
 493
 494     assert( strcmp( list->first->val, "TEST1" ) == 0 );
 495
 496     list_dl_add_before( &list, &node1, &node2 );
 497
 498     assert( strcmp( list->first->val, "TEST2" ) == 0 );
 499
 500     list_dl_add_before( &list, &node1, &node3 );
 501
 502     assert( strcmp( list->first->val, "TEST2" ) == 0 );
 503
 504     list_dl_add_before( &list, &node2, &node3 );
 505
 506     assert( strcmp( list->first->val, "TEST3" ) == 0 );
 507
 508     fprintf( stderr, "OK\n" );
 509 }
 510
 511
 512 void test_list_dl_add_after()
 513 {
 514     fprintf( stderr, "   Testing list_dl_add_after ... " );
 515
 516     list_dl *list  = list_dl_new();
 517     node_dl *node1 = node_dl_new();
 518     node_dl *node2 = node_dl_new();
 519     node_dl *node3 = node_dl_new();
 520
 521     node1->val = "TEST1";
 522     node2->val = "TEST2";
 523     node3->val = "TEST3";
 524
 525     list_dl_add_beg( &list, &node1 );
 526
 527     assert( strcmp( list->first->val, "TEST1" ) == 0 );
 528
 529     list_dl_add_after( &list, &node1, &node2 );
 530
 531     assert( strcmp( list->last->val, "TEST2" ) == 0 );
 532
 533     list_dl_add_after( &list, &node1, &node3 );
 534
 535     assert( strcmp( list->last->val, "TEST2" ) == 0 );
 536
 537     list_dl_add_after( &list, &node2, &node3 );
 538
 539     assert( strcmp( list->last->val, "TEST3" ) == 0 );
 540
 541     fprintf( stderr, "OK\n" );
 542 }
 543
 544
 545 void test_list_dl_remove()
 546 {
 547     fprintf( stderr, "   Testing list_dl_remove ... " );
 548
 549     list_dl *list  = list_dl_new();
 550     node_dl *node1 = node_dl_new();
 551     node_dl *node2 = node_dl_new();
 552     node_dl *node3 = node_dl_new();
 553
 554     node1->val = "TEST1";
 555     node2->val = "TEST2";
 556     node3->val = "TEST3";
 557
 558     list_dl_add_beg( &list, &node1 );
 559
 560     list_dl_add_after( &list, &node1, &node2 );
 561     list_dl_add_after( &list, &node2, &node3 );
 562
 563     list_dl_remove( &list, &node3 );
 564     assert( strcmp( list->last->val, "TEST2" ) == 0 );
 565
 566     list_dl_remove( &list, &node2 );
 567     assert( strcmp( list->last->val, "TEST1" ) == 0 );
 568
 569     list_dl_remove( &list, &node1 );
 570
 571     assert( list->first == NULL );
 572     assert( list->last  == NULL );
 573
 574     fprintf( stderr, "OK\n" );
 575 }
 576
 577
 578 void test_list_dl_print()
 579 {
 580     fprintf( stderr, "   Testing list_dl_print ... " );
 581
 582     list_dl *list  = list_dl_new();
 583     node_dl *node1 = node_dl_new();
 584     node_dl *node2 = node_dl_new();
 585     node_dl *node3 = node_dl_new();
 586
 587     node1->val = "TEST1";
 588     node2->val = "TEST2";
 589     node3->val = "TEST3";
 590
 591     list_dl_add_beg( &list, &node1 );
 592     list_dl_add_beg( &list, &node2 );
 593     list_dl_add_beg( &list, &node3 );
 594
 595     // list_dl_print( list );
 596
 597     fprintf( stderr, "OK\n" );
 598 }
 599
 600
 601 void test_list_dl_destroy()
 602 {
 603     fprintf( stderr, "   Testing list_dl_destroy ... " );
 604
 605     list_dl *list  = list_dl_new();
 606     node_dl *node1 = node_dl_new();
 607     node_dl *node2 = node_dl_new();
 608     node_dl *node3 = node_dl_new();
 609
 610     node1->val = "TEST1";
 611     node2->val = "TEST2";
 612     node3->val = "TEST3";
 613
 614     list_dl_add_beg( &list, &node1 );
 615     list_dl_add_beg( &list, &node2 );
 616     list_dl_add_beg( &list, &node3 );
 617
 618 //    list_dl_print( list );
 619
 620     list_dl_destroy( &list );
 621
 622     assert( list == NULL );
 623
 624     fprintf( stderr, "OK\n" );
 625 }
 626
 627
 628 void test_node_dl_destroy()
 629 {
 630     fprintf( stderr, "   Testing node_dl_destroy ... " );
 631
 632     node_dl *node = NULL;
 633     char    *str  = NULL;
 634
 635     str  = mem_get( 1000000000 );
 636
 637     node = node_dl_new();
 638
 639     node->val = str;
 640
 641     node_dl_destroy( &node );
 642
 643     assert( node == NULL );
 644
 645     fprintf( stderr, "OK\n" );
 646 }
 647
 648
 649 /* >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> GENERIC LINKED LIST <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<< */
 650
 651
 652 void test_list_count()
 653 {
 654     fprintf( stderr, "   Testing list_count ... " );
 655
 656     /* Singly linked list. */
 657
 658     char    *array[3] = { "test1", "test2", "test3" };
 659     list_sl *sllist   = NULL;
 660     node_sl *node     = NULL;
 661     node_sl *new_node = NULL;
 662     int      i        = 0;
 663
 664     sllist   = list_sl_new();
 665     new_node = node_sl_new();
 666
 667     new_node->val = array[ 0 ];
 668
 669     list_sl_add_beg( &sllist, &new_node );
 670
 671     node = new_node;
 672
 673     for ( i = 1; i < 3; i++ )
 674     {
 675         new_node = node_sl_new();
 676
 677         new_node->val = array[ i ];
 678
 679         list_sl_add_after( &node, &new_node );
 680
 681         node = new_node;
 682     }
 683
 684     assert( list_count( sllist ) == 3 );
 685
 686     /* Doubly linked list. */
 687
 688     list_dl *dllist = list_dl_new();
 689     node_dl *node1  = node_dl_new();
 690     node_dl *node2  = node_dl_new();
 691     node_dl *node3  = node_dl_new();
 692
 693     node1->val = "TEST1";
 694     node2->val = "TEST2";
 695     node3->val = "TEST3";
 696
 697     list_dl_add_beg( &dllist, &node1 );
 698     list_dl_add_beg( &dllist, &node2 );
 699     list_dl_add_beg( &dllist, &node3 );
 700
 701     assert( list_count( dllist ) == 3 );
 702
 703     fprintf( stderr, "OK\n" );
 704 }
 705
 706
 707 /* >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>><<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<< */
 708
 709