lib_test.c

   1 #include <assert.h>
   2 #include <limits.h>
   3 #include <stdbool.h>
   4 #include <stdio.h>
   5 #include <stdlib.h>
   6 #include <string.h>
   7 #include <time.h>
   8
   9 #include "lib_test.h"
  10 #include "lib_hash.h"
  11 #include "lib_ll.h"
  12 #include "lib_random.h"
  13 #include "lib_sort.h"
  14 #include "lib_vbtree.h"
  15 #include "lib_vqueue.h"
  16 #include "lib_vstack.h"
  17
  18 #define PASSED 0
  19 #define FAILED 1
  20
  21 #define SORT_TESTS 1000
  22
  23 void exit_error(const char *err_msg)
  24 {
  25         fprintf(stderr, "ERROR: %s\n", err_msg);
  26         exit(EXIT_FAILURE);
  27 }
  28
  29 void test_msg_start(char *msg)
  30 {
  31         int msg_length = strlen(msg);
  32         printf("%s", msg);
  33
  34         /* 74 is 80 - length of "PASSED" */
  35         while(msg_length < 74)
  36         {
  37                 putchar('.');
  38                 msg_length++;
  39         }
  40 }
  41
  42 void test_msg_end(int pass)
  43 {
  44         if(pass == PASSED)
  45         {
  46                 printf("PASSED\n");
  47         } else {
  48                 printf("FAILED\n\n");
  49                 exit_error("UNIT TESTING FAILED.\n\n");
  50         }
  51 }
  52
  53 /* unit tests begin here */
  54
  55 int test_random()
  56 {
  57         int i, j, result = 0;
  58         test_msg_start("Test Random Number Generator - Integers 0 to 100");
  59                 random_seed();
  60                 j = 0;
  61                 while(j < 100000) {
  62                         i = random_int(0,100);
  63                         if(i < 0 || i > 100) result++;
  64                         j++;
  65                 }
  66         test_msg_end(result);
  67
  68         return result;
  69 }
  70
  71 int test_linked_list()
  72 {
  73         int i,j, result = 0;
  74         List_Node *test_node1 = NULL;
  75         List_Node *test_node2 = NULL;
  76         List_Node *test_node3 = NULL;
  77         List_Node *pTrack[5];
  78         void* pArr[6];
  79
  80         List_Head *test_list1 = list_new();
  81         List_Head *test_list2 = list_new();
  82
  83         test_msg_start("Test Linked List Creation");
  84                 if(test_list1 == NULL) result++;
  85         test_msg_end(result);
  86
  87         test_msg_start("Test Linked List Empty Length - Using Variable");
  88                 if(test_list1->count != 0) result++;
  89         test_msg_end(result);
  90
  91         test_msg_start("Test Linked List Empty Length - Using Length Function");
  92                 if(list_len(test_list1) != 0 ) result++;
  93         test_msg_end(result);
  94
  95         test_msg_start("Test Linked List - Adding Node To Empty List");
  96                 if(list_ins_tail(test_list1) == NULL) result++;
  97         test_msg_end(result);
  98
  99         test_msg_start("Test Linked List - Adding Node To Non-Empty List");
 100                 if(list_ins_tail(test_list1) == NULL) result++;
 101         test_msg_end(result);
 102
 103         test_msg_start("Test Linked List - Clearing List With More Than One Node");
 104                 list_clear(test_list1);
 105                 if(test_list1->count != 0) result++;
 106                 if(list_len(test_list1) != 0 ) result++;
 107         test_msg_end(result);
 108
 109         test_msg_start("Test Linked List - Clearing List With No Nodes");
 110                 list_clear(test_list1);
 111                 if(test_list1->count != 0) result++;
 112                 if(list_len(test_list1) != 0 ) result++;
 113         test_msg_end(result);
 114
 115         test_msg_start("Test Linked List End - No Nodes");
 116                 list_clear(test_list1);
 117                 if(list_tail(test_list1) != NULL) result++;
 118         test_msg_end(result);
 119
 120         test_msg_start("Test Linked List End - One Node Only");
 121                 list_clear(test_list1);
 122                 test_node1 = list_ins_tail(test_list1);
 123                 if(test_node1 == NULL) result++;
 124                 if(list_tail(test_list1) != test_node1) result++;
 125         test_msg_end(result);
 126
 127         test_msg_start("Test Linked List End - More Than One Node");
 128                 list_clear(test_list1);
 129                 list_ins_tail(test_list1);
 130                 test_node1 = list_ins_tail(test_list1);
 131                 if(test_node1 == NULL) result++;
 132                 if(list_tail(test_list1) != test_node1) result++;
 133         test_msg_end(result);
 134
 135         test_msg_start("Test Linked List - Removing Node From List With More Than One Node");
 136                 list_clear(test_list1);
 137                 test_node1 = list_ins_tail(test_list1);
 138                 test_node2 = list_ins_head(test_list1);
 139                 list_rm_node(test_list1, test_node1);
 140                 if(test_list1->pNext != test_node2) result++;
 141         test_msg_end(result);
 142
 143         test_msg_start("Test Linked List - Removing Node From Empty List");
 144                 list_clear(test_list1);
 145                 test_node1 = (List_Node*)&test_list1; /* pointer points to known bad location */
 146                 /* should not crash but return gracefully */
 147                 if(list_rm_node(test_list1, test_node1) != -1) result++;
 148         test_msg_end(result);
 149
 150         test_msg_start("Test Linked List - Inserting Node After");
 151                 list_clear(test_list1);
 152                 test_node1 = NULL;
 153                 test_node2 = NULL;
 154                 test_node1 = list_ins_tail(test_list1);
 155                 test_node2 = list_ins_after(test_list1, test_node1);
 156
 157                 /* test beginning */
 158                 if(test_list1->pNext != test_node1) result++;
 159                 /*...and end nodes. */
 160                 if(list_tail(test_list1) != test_node2) result++;
 161                 /* end node next should be null */
 162                 if(list_tail(test_list1)->pNext != NULL) result++;
 163         test_msg_end(result);
 164
 165         test_msg_start("Test Linked List - Inserting Node Before");
 166                 list_clear(test_list1);
 167                 test_node1 = NULL;
 168                 test_node2 = NULL;
 169                 test_node1 = list_ins_head(test_list1);
 170                 test_node2 = list_ins_before(test_list1, test_node1);
 171
 172                 /* test beginning */
 173                 if(test_list1->pNext != test_node2) result++;
 174                 /*...and end nodes. */
 175                 if(list_tail(test_list1) != test_node1) result++;
 176                 /* end node next should be null */
 177                 if(list_tail(test_list1)->pNext != NULL) result++;
 178         test_msg_end(result);
 179
 180         test_msg_start("Test Linked List - Test Lengths");
 181                 list_clear(test_list1);
 182                 if(list_len(test_list1) != 0) result++;
 183
 184                 /* adding nodes using each function */
 185                 list_ins_head(test_list1);
 186                 if(list_len(test_list1) != 1) result++;
 187
 188                 list_ins_tail(test_list1);
 189                 if(list_len(test_list1) != 2) result++;
 190
 191                 list_ins_before(test_list1, list_tail(test_list1));
 192                 if(list_len(test_list1) != 3) result++;
 193
 194                 list_ins_after(test_list1, list_tail(test_list1));
 195                 if(list_len(test_list1) != 4) result++;
 196         test_msg_end(result);
 197
 198         test_msg_start("Test Linked List - Previous Node Check");
 199                 list_clear(test_list1);
 200                 test_node1 = NULL;
 201                 test_node2 = NULL;
 202                 if(list_prev_node(test_list1, NULL) != NULL) result++;
 203                 if(list_prev_node(NULL, test_list1->pNext) != NULL) result++;
 204                 if(list_prev_node(NULL, test_node1 + 1000) != NULL) result++;
 205                 test_node1 = list_ins_head(test_list1);
 206                 if(list_prev_node(test_list1, test_list1->pNext) != NULL) result++;
 207                 test_node2 = list_ins_head(test_list1);
 208                 if(list_prev_node(test_list1, test_node1) != test_node2) result++;
 209                 if(list_prev_node(test_list1, test_node2) != NULL) result++;
 210         test_msg_end(result);
 211
 212         test_msg_start("Test Linked List - Removing Nodes By Address");
 213                 /* removing nodes from various places */
 214                 list_clear(test_list1);
 215                 test_node1 = NULL;
 216                 test_node2 = NULL;
 217
 218                 if(list_rm_node(NULL, test_list1->pNext)!= -1) result++;
 219                 if(list_rm_node(test_list1, NULL) != -1) result++;
 220                 test_node1 = list_ins_head(test_list1);
 221                 test_node2 = list_ins_head(test_list1);
 222                 list_rm_node(test_list1, test_list1->pNext);
 223                 if(list_len(test_list1) != 1) result++;
 224                 test_node1 = list_tail(test_list1);
 225                 list_rm_node(test_list1, test_node1);
 226                 if(list_len(test_list1) != 0) result++;
 227                 if(list_rm_node(test_list1, list_tail(test_list1)) != -1) result++;
 228         test_msg_end(result);
 229
 230         test_msg_start("Test Linked List - Removing Nodes After Address");
 231                 list_clear(test_list1);
 232                 test_node1 = NULL;
 233                 test_node2 = NULL;
 234                 test_node1 = list_ins_tail(test_list1);
 235                 test_node2 = list_ins_tail(test_list1);
 236                 if(list_rm_next(test_list1, test_node1) != 1) result++;
 237         test_msg_end(result);
 238
 239         test_msg_start("Test Linked List - Removing Nodes Before Address");
 240                 list_clear(test_list1);
 241                 test_node1 = NULL;
 242                 test_node2 = NULL;
 243                 if(list_rm_before(test_list1, NULL) != -1) result++;
 244                 if(list_rm_before(NULL, NULL) != -1) result++;
 245                 if(list_rm_before(test_list1 + 1000, NULL) != -1) result++;
 246                 test_node1 = list_ins_tail(test_list1);
 247                 test_node2 = list_ins_tail(test_list1);
 248                 if(list_rm_before(test_list1, test_node2 + 1000) != -1) result++;
 249                 if(list_rm_before(test_list1, test_node2) != 1) result++;
 250         test_msg_end(result);
 251
 252         test_msg_start("Test Linked List - Copying List");
 253                 list_clear(test_list1);
 254                 list_clear(test_list2);
 255                 test_node1 = list_ins_tail(test_list1);
 256                 test_node1->pData = &result;
 257                 test_node2 = list_ins_tail(test_list1);
 258                 if(list_copy(test_list2, test_list1) != 0) result++;
 259                 if(test_list1->pNext == test_list2->pNext) result++;
 260                 if(test_list1->count != 2) result++;
 261                 if(test_list2->count != 2) result++;
 262                 if(test_list1->pNext->pData != test_list2->pNext->pData) result++;
 263         test_msg_end(result);
 264
 265         test_msg_start("Test Linked List - Copying Empty List");
 266                 list_clear(test_list1);
 267                 list_clear(test_list2);
 268                 if(list_copy(test_list2, test_list1) != 0) result++;
 269                 if(test_list1->pNext != NULL) result++;
 270                 if(test_list2->pNext != NULL) result++;
 271                 if(test_list1->count != 0) result++;
 272                 if(test_list2->count != 0) result++;
 273         test_msg_end(result);
 274
 275         test_msg_start("Test Linked List - Get Node Address By Node Number - First Node");
 276                 list_clear(test_list1);
 277                 test_node1 = list_ins_head(test_list1);
 278                 test_node2 = list_ins_head(test_list1);
 279                 test_node3 = list_get_num(test_list1, 1);
 280                 if(test_node3 != test_node2) result++;
 281         test_msg_end(result);
 282
 283         test_msg_start("Test Linked List - Get Node Address By Node Number - Middle Node");
 284                 list_clear(test_list1);
 285                 list_ins_tail(test_list1);
 286                 list_ins_tail(test_list1);
 287                 list_ins_tail(test_list1);
 288                 list_ins_tail(test_list1);
 289                 test_node2 = list_ins_tail(test_list1);
 290                 list_ins_tail(test_list1);
 291                 list_ins_tail(test_list1);
 292                 list_ins_tail(test_list1);
 293                 list_ins_tail(test_list1);
 294                 test_node3 = list_get_num(test_list1, 5);
 295                 if(test_node3 != test_node2) result++;
 296         test_msg_end(result);
 297
 298         test_msg_start("Test Linked List - Get Node Address By Node Number - Last Node");
 299                 list_clear(test_list1);
 300                 test_node1 = list_ins_tail(test_list1);
 301                 test_node2 = list_ins_tail(test_list1);
 302                 test_node3 = list_get_num(test_list1, 2);
 303                 if(test_node3 != test_node2) result++;
 304         test_msg_end(result);
 305
 306         test_msg_start("Test Linked List - Get Node Address By Node Number - Empty List");
 307                 list_clear(test_list1);
 308                 test_node1 = list_get_num(test_list1, 1);
 309                 if(test_node1 != NULL) result++;
 310                 test_node1 = list_get_num(test_list1, 55);
 311                 if(test_node1 != NULL) result++;
 312         test_msg_end(result);
 313
 314         test_msg_start("Test Linked List - Swap Nodes In List");
 315                 list_clear(test_list1);
 316                 test_node1 = list_ins_tail(test_list1);
 317                 test_node2 = list_ins_tail(test_list1);
 318                 test_node3 = list_ins_tail(test_list1);
 319                 pTrack[1] = test_node1->pNext;
 320                 pTrack[2] = test_node2->pNext;
 321                 if(list_node_swap(test_node1, test_node2) != 0) result++;
 322                 if(test_node1->pNext != pTrack[2]) result++;
 323                 if(test_node2->pNext != pTrack[1]) result++;
 324         test_msg_end(result);
 325
 326         test_msg_start("Test Linked List - List Reverse - Pointer Tracking");
 327                 list_clear(test_list1);
 328                 for(i = 0; i < 5; i++) {
 329                         pTrack[i] = list_ins_tail(test_list1);
 330                         pTrack[i]->pData = &pTrack[i]->pData;
 331                 }
 332                 test_list1 = list_reverse(test_list1);
 333                 for(i = 1, j = 4; i <= 4; i++, j--) {
 334                         test_node1 = list_get_num(test_list1, i);
 335                         if(test_node1->pData != pTrack[j]) result++;
 336                 }
 337         test_msg_end(result);
 338
 339         test_msg_start("Test Linked List - List Next Preprocessor");
 340                 list_clear(test_list1);
 341                 list_clear(test_list2);
 342                 test_node1 = NULL;
 343                 test_node2 = NULL;
 344                 test_node1 = list_ins_head(test_list1);
 345                 test_node2 = list_ins_head(test_list1);
 346                 if(list_next(test_node1) == test_node2) result++;
 347         test_msg_end(result);
 348
 349         test_msg_start("Test Linked List - Default Payload");
 350                 list_clear(test_list1);
 351                 test_node1 = NULL;
 352                 test_node2 = NULL;
 353                 test_node1 = list_ins_tail(test_list1);
 354                 test_node2 = list_ins_tail(test_list1);
 355                 if(test_node1->pData != NULL) result++;
 356
 357                 /* make data point to something and test again... */
 358                 test_node1->pData = test_node1;
 359                 if(list_data(test_node1) != test_node1) result++;
 360         test_msg_end(result);
 361
 362         test_msg_start("Test Linked List - List Is Head Preprocessor");
 363                 if(list_is_head(test_list1, test_node2) != 0) result++;
 364                 if(list_is_head(test_list1, test_node1) != 1) result++;
 365         test_msg_end(result);
 366
 367         test_msg_start("Test Linked List - List Is Tail Preprocessor");
 368                 if(list_is_tail(test_node2) != 1) result++;
 369                 if(list_is_tail(test_node1) != 0) result++;
 370         test_msg_end(result);
 371
 372         test_msg_start("Test Linked List - List Head Preprocessor");
 373                 if(list_head(test_list1) != test_node1) result++;
 374         test_msg_end(result);
 375
 376         test_msg_start("Test Linked List - Append Lists - Pointer Tracking");
 377                 list_clear(test_list1);
 378                 list_clear(test_list2);
 379                 list_ins_tail(test_list1);
 380                 list_ins_tail(test_list1);
 381                 list_ins_tail(test_list1);
 382                 pTrack[0] = list_ins_tail(test_list1);
 383                 pTrack[1] = list_ins_tail(test_list2);
 384                 list_ins_tail(test_list2);
 385                 list_ins_tail(test_list2);
 386                 list_append(test_list1, test_list2);
 387                 if(test_list1->count != 7) result++;
 388                 if(!list_search(test_list1, pTrack[0])) result++;
 389                 if(!list_search(test_list1, pTrack[1])) result++;
 390                 if(pTrack[0] != list_get_num(test_list1, 4)) result++;
 391                 if(pTrack[1] != list_get_num(test_list1, 5)) result++;
 392         test_msg_end(result);
 393
 394         test_msg_start("Test Linked List - Create Data Array - Pointer Tracking");
 395                 list_clear(test_list1);
 396                 pTrack[0] = list_ins_tail(test_list1);
 397                 pTrack[0] = pTrack[0]->pData = &test_list1;
 398                 pTrack[1] = list_ins_tail(test_list1);
 399                 pTrack[1] = pTrack[1]->pData = &test_list2;
 400                 pTrack[2] = list_ins_tail(test_list1);
 401                 pTrack[2] = pTrack[2]->pData = &pTrack;
 402                 pTrack[3] = list_ins_tail(test_list1);
 403                 pTrack[3] = pTrack[3]->pData = &test_node1;
 404                 pTrack[4] = list_ins_tail(test_list1);
 405                 pTrack[4] = pTrack[4]->pData = &test_node2;
 406                 pArr[5] = &test_list1;
 407                 if(list_data_array(test_list1, pArr, 6) != 0) result++;
 408                 if(pArr[0] != pTrack[0]) result++;
 409                 if(pArr[1] != pTrack[1]) result++;
 410                 if(pArr[2] != pTrack[2]) result++;
 411                 if(pArr[3] != pTrack[3]) result++;
 412                 if(pArr[4] != pTrack[4]) result++;
 413                 if(pArr[5] != NULL) result++;
 414         test_msg_end(result);
 415
 416         test_msg_start("Test Linked List - Create Node Array - Pointer Tracking");
 417                 list_clear(test_list1);
 418                 pTrack[0] = list_ins_tail(test_list1);
 419                 pTrack[1] = list_ins_tail(test_list1);
 420                 pTrack[2] = list_ins_tail(test_list1);
 421                 pTrack[3] = list_ins_tail(test_list1);
 422                 pTrack[4] = list_ins_tail(test_list1);
 423                 pArr[5] = &test_list1;
 424                 if(list_node_array(test_list1, pArr, 6) != 0) result++;
 425                 if(pArr[0] != pTrack[0]) result++;
 426                 if(pArr[1] != pTrack[1]) result++;
 427                 if(pArr[2] != pTrack[2]) result++;
 428                 if(pArr[3] != pTrack[3]) result++;
 429                 if(pArr[4] != pTrack[4]) result++;
 430                 if(pArr[5] != NULL) result++;
 431         test_msg_end(result);
 432
 433         test_msg_start("Test Linked List - Search List");
 434                 list_clear(test_list1);
 435                 if(list_search(test_list1, test_node1) != 0) result++;
 436                 test_node1 = list_ins_head(test_list1);
 437                 if(list_search(test_list1, test_node1) != 1) result++;
 438                 if(list_search(test_list1, test_node2) != 0) result++;
 439                 if(list_search(test_list1, test_node3) != 0) result++;
 440                 if(list_search(test_list1, NULL) != 0) result++;
 441                 if(list_search(test_list1, (List_Node *)test_list1) != 0) result++;
 442                 test_node2 = list_ins_head(test_list1);
 443                 if(list_search(test_list1, test_node1) != 1) result++;
 444                 if(list_search(test_list1, test_node2) != 1) result++;
 445                 if(list_search(test_list1, test_node3) != 0) result++;
 446                 if(list_search(test_list1, NULL) != 0) result++;
 447                 if(list_search(test_list1, (List_Node *)test_list1) != 0) result++;
 448                 list_clear(test_list1);
 449                 if(list_search(test_list1, test_node1) != 0) result++;
 450                 if(list_search(test_list1, test_node2) != 0) result++;
 451                 if(list_search(test_list1, test_node3) != 0) result++;
 452                 if(list_search(test_list1, NULL) != 0) result++;
 453                 if(list_search(test_list1, (List_Node *)test_list1) != 0) result++;
 454         test_msg_end(result);
 455
 456         return result;
 457 }
 458
 459 int test_vstack()
 460 {
 461         int result = 0;
 462         int i = 0;
 463         char data[] = "This is some test data\n";
 464         char *pCh;
 465         Stack_Head *test_stack = vstack_new();
 466         Stack_Node *temp_node1 = NULL, *temp_node2 = NULL;
 467
 468         test_msg_start("Test Variable Stack - Creating New Stack");
 469                 if(!test_stack) result++;
 470         test_msg_end(result);
 471
 472         test_msg_start("Test Variable Stack - Pushing Data Into Stack");
 473                 while(data[i] != '\0')
 474                 {
 475                         temp_node1 = vstack_push(test_stack);
 476                         /* reserve memory for node payload - pointer to memory in pData */
 477                         pCh = malloc(sizeof(char));
 478                         *pCh = data[i];
 479                         temp_node1->pData = pCh;
 480                         i++;
 481                 }
 482         test_msg_end(result);
 483
 484         test_msg_start("Test Variable Stack - Popping Data Off Of Stack");
 485                 while(i > 0)
 486                 {
 487                         i--;
 488                         temp_node1 = vstack_peek(test_stack);
 489                         /* verify data of this node */
 490                         pCh = temp_node1->pData;
 491                         if(*pCh != data[i]) result++;
 492                         vstack_pop(test_stack);
 493                 }
 494         test_msg_end(result);
 495
 496         test_msg_start("Test Variable Stack - Popping Data Off Empty Stack");
 497                 vstack_clear(test_stack);
 498                 if(vstack_pop(test_stack) != -1) result++;
 499         test_msg_end(result);
 500
 501         test_msg_start("Test Variable Stack - Tracking Stack Size");
 502                 vstack_clear(test_stack);
 503                 if(vstack_size(test_stack) != 0) result++;
 504                 vstack_push(test_stack);
 505                 if(vstack_size(test_stack) != 1) result++;
 506                 temp_node1 = vstack_peek(test_stack);
 507                 if(vstack_size(test_stack) != 1) result++;
 508                 vstack_pop(test_stack);
 509                 if(vstack_size(test_stack) != 0) result++;
 510         test_msg_end(result);
 511
 512         test_msg_start("Test Variable Stack - Tracking Node Address With Peek and Push");
 513                 vstack_clear(test_stack);
 514                 temp_node1 = NULL;
 515                 temp_node1 = vstack_push(test_stack);
 516                 temp_node2 = vstack_push(test_stack);
 517                 if(vstack_peek(test_stack) != temp_node2) result++;
 518                 vstack_pop(test_stack);
 519                 if(vstack_peek(test_stack) != temp_node1) result++;
 520         test_msg_end(result);
 521
 522         return result;
 523 }
 524
 525 int test_vqueue()
 526 {
 527         int result = 0;
 528         int i = 0;
 529         char data[] = "T\n";
 530         char *pCh;
 531         Queue_Head *test_q1 = vq_new();
 532         Queue_Head *test_q2 = vq_new();
 533
 534         Queue_Node *test_node1 = NULL;
 535         Queue_Node *test_node2 = NULL;
 536         Queue_Node *test_node3 = NULL;
 537
 538         Queue_Node *pTrack[5];
 539
 540         test_msg_start("Test Queue - Creating New Queue");
 541                 if(!test_q1) result++;
 542         test_msg_end(result);
 543
 544         test_msg_start("Test Queue - Pushing Data Into Queue");
 545                 while(data[i] != '\0')
 546                 {
 547                         test_node1 = vq_enq(test_q1);
 548                         /* reserve memory for node payload - pointer to memory in pData */
 549                         pCh = malloc(sizeof(char));
 550                         *pCh = data[i];
 551                         test_node1->pData = pCh;
 552                         i++;
 553                 }
 554         test_msg_end(result);
 555
 556         test_msg_start("Test Queue - Popping Data Off Of Queue");
 557                 i = 0;
 558                 while(data[i] != '\n')
 559                 {
 560                         test_node1 = vq_peek(test_q1);
 561                         /* verify data of this node */
 562                         pCh = test_node1->pData;
 563                         if(*pCh != data[i]) result++;
 564                         vq_deq(test_q1);
 565                         i++;
 566                 }
 567         test_msg_end(result);
 568
 569         test_msg_start("Test Queue - Popping Data Off Empty Queue");
 570                 vq_clear(test_q1);
 571                 if(vq_deq(test_q1) != -1) result++;
 572         test_msg_end(result);
 573
 574         test_msg_start("Test Queue - Tracking Queue Size");
 575                 vq_clear(test_q1);
 576                 if(vq_size(test_q1) != 0) result++;
 577                 vq_enq(test_q1);
 578                 if(vq_size(test_q1) != 1) result++;
 579                 test_node1 = vq_peek(test_q1);
 580                 if(vq_size(test_q1) != 1) result++;
 581                 vq_deq(test_q1);
 582                 if(vq_size(test_q1) != 0) result++;
 583         test_msg_end(result);
 584
 585         test_msg_start("Test Queue - Tracking Node Address With Enqueue and Dequeue");
 586                 vq_clear(test_q1); test_node1 = NULL; test_node2 = NULL;
 587                 test_node1 = vq_enq(test_q1);
 588                 test_node2 = vq_enq(test_q1);
 589                 if(vq_peek(test_q1) != test_node1) result++;
 590                 vq_deq(test_q1);
 591                 if(vq_peek(test_q1) != test_node2) result++;
 592         test_msg_end(result);
 593
 594         test_msg_start("Test Queue - Copying Queue");
 595                 vq_clear(test_q1);
 596                 vq_clear(test_q2);
 597                 test_node1 = vq_enq(test_q1);
 598                 test_node1->pData = &result;
 599                 test_node2 = vq_enq(test_q1);
 600                 if(vq_copy(test_q2, test_q1) != 0) result++;
 601                 if(test_q1->pNext == test_q2->pNext) result++;
 602                 if(test_q1->count != 2) result++;
 603                 if(test_q2->count != 2) result++;
 604                 if(test_q1->pNext->pData != test_q2->pNext->pData) result++;
 605         test_msg_end(result);
 606
 607         test_msg_start("Test Queue - Copying Empty Queue");
 608                 vq_clear(test_q1);
 609                 vq_clear(test_q2);
 610                 if(vq_copy(test_q2, test_q1) != 0) result++;
 611                 if(test_q1->pNext != NULL) result++;
 612                 if(test_q2->pNext != NULL) result++;
 613                 if(test_q1->count != 0) result++;
 614                 if(test_q2->count != 0) result++;
 615         test_msg_end(result);
 616
 617         test_msg_start("Test Queue - Get Node Address By Node Number - First Node");
 618                 vq_clear(test_q1);
 619                 test_node1 = vq_enq(test_q1);
 620                 test_node2 = vq_enq(test_q1);
 621                 test_node3 = vq_get_num(test_q1, 1);
 622                 if(test_node3 != test_node2) result++;
 623         test_msg_end(result);
 624
 625         test_msg_start("Test Queue - Get Node Address By Node Number - Middle Node");
 626                 vq_clear(test_q1);
 627                 vq_enq(test_q1);
 628                 vq_enq(test_q1);
 629                 vq_enq(test_q1);
 630                 vq_enq(test_q1);
 631                 test_node2 = vq_enq(test_q1);
 632                 vq_enq(test_q1);
 633                 vq_enq(test_q1);
 634                 vq_enq(test_q1);
 635                 vq_enq(test_q1);
 636                 test_node3 = vq_get_num(test_q1, 5);
 637                 if(test_node3 != test_node2) result++;
 638         test_msg_end(result);
 639
 640         test_msg_start("Test Queue - Get Node Address By Node Number - Last Node");
 641                 vq_clear(test_q2);
 642                 test_node1 = list_ins_tail(test_q2);
 643                 test_node2 = list_ins_tail(test_q2);
 644                 test_node3 = list_get_num(test_q2, 2);
 645                 if(test_node3 != test_node2) result++;
 646         test_msg_end(result);
 647
 648         test_msg_start("Test Queue - Get Node Address By Node Number - Empty List");
 649                 vq_clear(test_q2);
 650                 test_node1 = vq_get_num(test_q2, 1);
 651                 if(test_node1 != NULL) result++;
 652                 test_node1 = vq_get_num(test_q2, 55);
 653                 if(test_node1 != NULL) result++;
 654         test_msg_end(result);
 655
 656         test_msg_start("Test Queue - Swap Nodes In List");
 657                 vq_clear(test_q2);
 658                 test_node1 = vq_enq(test_q2);
 659                 test_node2 = vq_enq(test_q2);
 660                 test_node3 = vq_enq(test_q2);
 661                 pTrack[1] = test_node1->pNext;
 662                 pTrack[2] = test_node2->pNext;
 663                 if(vq_node_swap(test_node1, test_node2) != 0) result++;
 664                 if(test_node1->pNext != pTrack[2]) result++;
 665                 if(test_node2->pNext != pTrack[1]) result++;
 666         test_msg_end(result);
 667
 668         return result;
 669 }
 670
 671 /* test outcome of sort algorithm - all data should be sorted */
 672 int test_sort_data(int data[], int lo, int hi)
 673 {
 674         int i = lo, result = 0;
 675         while(i < hi)
 676         {
 677                 if(!(data[i] <= data[i+1])) result++;
 678                 i++;
 679         }
 680         return result;
 681 }
 682
 683 /* test specific position of data */
 684 int test_sort_data_loc(int data[])
 685 {
 686         int i = 0, result = 0;
 687         while(i < 10) {
 688                 if(data[i] != i) result++;
 689                 i++;
 690         }
 691         return result;
 692 }
 693
 694 /* set pre-selected data in array */
 695 void sort_set_array(int data[])
 696 {
 697         assert(data != NULL);
 698         data[0] = 4;
 699         data[1] = 5;
 700         data[2] = 7;
 701         data[3] = 9;
 702         data[4] = 8;
 703         data[5] = 1;
 704         data[6] = 6;
 705         data[7] = 0;
 706         data[8] = 3;
 707         data[9] = 2;
 708 }
 709
 710 /* fill random length array with random data */
 711 void sort_rnd_data_fill(int *data, int length, int min, int max)
 712 {
 713         int i = 0;
 714         random_seed();
 715         while(i < length) {
 716                 data[i]= random_int(min, max);
 717                 i++;
 718         }
 719 }
 720
 721 int test_sort()
 722 {
 723         int i, result = 0, length, min_data_val, max_data_val;
 724         int *temp_data;
 725         int data[10];
 726
 727         test_msg_start("Test Selection Sort - Preset Array");
 728                 sort_set_array(data);
 729                 sort_selection(data, 0, 9);
 730                 result += test_sort_data(data, 0, 9);
 731                 result += test_sort_data_loc(data);
 732         test_msg_end(result);
 733
 734         test_msg_start("Test Selection Sort - Random Data");
 735                 for(i = 0; i < SORT_TESTS; i++) {
 736                         random_seed();
 737                         min_data_val = random_int(INT_MIN+1, (INT_MAX/2)-1);
 738                         max_data_val = random_int(min_data_val, (INT_MAX/2)-1);
 739                         length = random_int(500, 1000); /* get length of a new array */
 740                         temp_data = malloc(sizeof(int) * length);
 741                         sort_rnd_data_fill(temp_data, length, min_data_val, max_data_val);
 742                         sort_selection(temp_data, 0, length);
 743                         result += test_sort_data(temp_data, 0, length);
 744                         free(temp_data);
 745                         temp_data = NULL;
 746                 }
 747         test_msg_end(result);
 748
 749         test_msg_start("Test Insertion Sort - Preset Array");
 750                 sort_set_array(data);
 751                 sort_insertion(data, 0, 9);
 752                 result += test_sort_data(data, 0, 9);
 753                 result += test_sort_data_loc(data);
 754         test_msg_end(result);
 755
 756         test_msg_start("Test Insertion Sort - Random Data");
 757                 for(i = 0; i < SORT_TESTS; i++) {
 758                         random_seed();
 759                         min_data_val = random_int(INT_MIN+1, (INT_MAX/2)-1);
 760                         max_data_val = random_int(min_data_val, (INT_MAX/2)-1);
 761                         length = random_int(500, 1000); /* get length of a new array */
 762                         temp_data = malloc(sizeof(int) * length);
 763                         sort_rnd_data_fill(temp_data, length, min_data_val, max_data_val);
 764                         sort_insertion(temp_data, 0, length);
 765                         result += test_sort_data(temp_data, 0, length);
 766                         free(temp_data);
 767                         temp_data = NULL;
 768                 }
 769         test_msg_end(result);
 770
 771         test_msg_start("Test Quick Sort (Recursive) - Preset Array");
 772                 sort_set_array(data);
 773                 sort_quick(data, 0, 9);
 774                 result += test_sort_data(data, 0, 9);
 775                 result += test_sort_data_loc(data);
 776         test_msg_end(result);
 777
 778         test_msg_start("Test Quick Sort (Recursive) - Random Data");
 779                 for(i = 0; i < SORT_TESTS; i++) {
 780                         random_seed();
 781                         min_data_val = random_int(INT_MIN+1, (INT_MAX/2)-1);
 782                         max_data_val = random_int(min_data_val, (INT_MAX/2)-1);
 783                         length = random_int(500, 1000); /* get length of a new array */
 784                         temp_data = malloc(sizeof(int) * length);
 785                         sort_rnd_data_fill(temp_data, length, min_data_val, max_data_val);
 786                         sort_quick(temp_data, 0, length);
 787                         result += test_sort_data(temp_data, 0, length);
 788                         free(temp_data);
 789                         temp_data = NULL;
 790                 }
 791         test_msg_end(result);
 792
 793         test_msg_start("Test Quick Sort - Preset Array");
 794                 sort_set_array(data);
 795                 sort_quick_norecurse(data, 0, 9);
 796                 result += test_sort_data(data, 0, 9);
 797                 result += test_sort_data_loc(data);
 798         test_msg_end(result);
 799
 800         test_msg_start("Test Quick Sort - Random Data");
 801                 for(i = 0; i < SORT_TESTS; i++) {
 802                         random_seed();
 803                         min_data_val = random_int(INT_MIN+1, (INT_MAX/2)-1);
 804                         max_data_val = random_int(min_data_val, (INT_MAX/2)-1);
 805                         length = random_int(500, 1000); /* get length of a new array */
 806                         temp_data = malloc(sizeof(int) * length);
 807                         sort_rnd_data_fill(temp_data, length, min_data_val, max_data_val);
 808                         sort_quick_norecurse(temp_data, 0, length);
 809                         result += test_sort_data(temp_data, 0, length);
 810                         free(temp_data);
 811                         temp_data = NULL;
 812                 }
 813         test_msg_end(result);
 814
 815         return result;
 816 }
 817
 818 int test_hash()
 819 {
 820         int result = 0;
 821         Hash h;
 822         test_msg_start("Test Hash - Prime Number Generator");
 823                 if(is_prime(0)) result++;
 824                 if(is_prime(1)) result++;
 825                 if(!is_prime(2)) result++;
 826                 if(!is_prime(3571)) result++;
 827                 if(is_prime(3570)) result++;
 828         test_msg_end(result);
 829
 830         test_msg_start("Test Hash - Twin Prime Number Generator");
 831                 if(next_twinprime(6) != 7) result++;
 832                 if(next_twinprime(72) != 73) result++;
 833                 if(next_twinprime(1000) != 1021) result++;
 834                 if(next_twinprime(79154) != 79231) result++;
 835                 if(next_twinprime(INT_MAX) != -1) result++;
 836         test_msg_end(result);
 837
 838         test_msg_start("Test Hash - Create New Hash");
 839                 h = hash_new_prime(100);
 840                 if(hash_empty(h) != 0) result++;
 841                 if(h.size != 103) result++;
 842                 if(h.data == NULL) result++;
 843         test_msg_end(result);
 844
 845         test_msg_start("Test Hash - Insert and Verify Data");
 846                 hash_insert(h, "hello", 6);
 847                 if(hash_search(h, "hello", 6) == NULL) result++;
 848                 if(hash_search(h, "goodbye", 7) != NULL) result++;
 849                 if(hash_search(h, "", 0) != NULL) result++;
 850         test_msg_end(result);
 851
 852         test_msg_start("Test Hash - Fill Hash and Clear Data");
 853
 854                 /* if(hash_full(h) != 0) result++; */
 855         test_msg_end(result);
 856
 857         test_msg_start("Test Hash - Fill Hash and Remove Specific Data");
 858         test_msg_end(result);
 859
 860         test_msg_start("Test Hash - Insert and Verify Data");
 861         test_msg_end(result);
 862
 863         return result;
 864 }
 865
 866 int test_all()
 867 {
 868         int result = 0;
 869         result += test_random();
 870         result += test_linked_list();
 871         result += test_vstack();
 872         result += test_vqueue();
 873         result += test_sort();
 874         /* result += test_hash(); HASH IS NOT COMPLETE */
 875         return result;
 876 }
 877
 878 int main()
 879 {
 880         printf("\nRUNNING ALL UNIT TESTS ON DATA STRUCTURES.\n\n");
 881         if(test_all() == 0)
 882         {
 883                 printf("\nUNIT TEST COMPLETE - ALL TESTS RETURNED PASSED.\n\n");
 884         } else {
 885                 exit_error("UNIT TEST FAILED.\n\n");
 886         }
 887         exit(EXIT_SUCCESS);
 888 }