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