code_c/Maasha/src/test/test_list.c

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