code_c/Maasha/src/test/test_list.c

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