Implemented Stacks and Queues.

This includes unit testing for both modules.

Bugs in Linked List implementation have been found as a result
and removed.

Shortened test messages to make room for longer descriptions.

diff --git a/lib_ll.c b/lib_ll.c
index c53284e..11f1f20 100644 (file)
--- a/lib_ll.c
+++ b/lib_ll.c
@@ -2,6 +2,7 @@
 #include <stddef.h>
 #include <stdbool.h>
 #include <stdio.h>
+#include <string.h>
 
 #include "lib_ll.h"
 
@@ -22,6 +23,8 @@ void list_delete(List_Head *pHead)
                pTemp = pTemp->pNext;
                free(pTemp);
        }
+       pHead->count = 0;
+       pHead->pNext = NULL;
        free(pHead);
 }
 
@@ -41,13 +44,9 @@ List_Node *list_tail(List_Head *pHead)
 {
        List_Node *pTemp = pHead->pNext;
 
-       if(pHead->pNext == NULL)
-       {
-               return NULL;
-       }
-       while(pTemp->pNext != NULL){
+       if(pHead->pNext == NULL) return NULL;
+       while(pTemp->pNext != NULL)
                pTemp = pTemp->pNext;
-       }
        return pTemp;
 }
 
@@ -63,6 +62,7 @@ List_Node *list_ins_head(List_Head *pHead)
        List_Node *pNode = malloc(sizeof(List_Node));
        if (pNode == NULL) return NULL;
        pNode->pData = NULL;
+       pNode->pNext = NULL;
        if(pHead->pNext == NULL) /* adding to empty list */
        {
                pHead->pNext = pNode;
@@ -84,8 +84,7 @@ List_Node *list_ins_tail(List_Head *pHead)
        {
                pHead->pNext = pNode;
        } else {
-               while (pTemp->pNext != NULL)/* move to end of list */
-                       pTemp = pNode->pNext;
+               pTemp = list_tail(pHead);
                pTemp->pNext = pNode;
                pNode->pNext = NULL;
        }
@@ -150,96 +149,43 @@ List_Node *list_ins_after(List_Head *pHead, List_Node *pNode)
 
 int list_rm_node(List_Head *pHead, List_Node *pNode)
 {
-       List_Node *pTemp;
-
-       if (list_size(pHead) == 0)
-               return -1; /* list was empty */
-
-       if (pNode == NULL) { /* removal from head */
-          pTemp = pHead->pNext;
-          pHead->pNext = pHead->pNext->pNext;
-
-         /*if (list_size(pHead) == 1)
-             pHead->tail = NULL;  */
-
-       } else { /* removal away from head */
-
-               if (pNode->pNext == NULL)
-                       return -1;
-
-               pTemp = pNode->pNext;
-               pNode->pNext = pNode->pNext->pNext;
-               /*
-               if (pNode->next == NULL)
-                       pHead->tail = pNode;*/
-       }
-       free(pTemp);
-       pHead->count--;
-       return 1;
-}
+       List_Node *pPrev = NULL;
 
-int list_rm_next(List_Head *pHead, List_Node *pNode)
-{
-       List_Node *pTemp;
+       if(pHead == NULL || pNode == NULL)
+               return -1; /* Not valid data */
 
-       if (list_size(pHead) == 0)
+       if(list_size(pHead) == 0)
                return -1; /* list was empty */
 
-       if (pNode == NULL) { /* removal from head */
-          pTemp = pHead->pNext;
-          pHead->pNext = pHead->pNext->pNext;
-
-         /*if (list_size(pHead) == 1)
-             pHead->tail = NULL;  */
-
-       } else { /* removal away from head */
-
-               if (pNode->pNext == NULL)
-                       return -1;
-
-               pTemp = pNode->pNext;
-               pNode->pNext = pNode->pNext->pNext;
-               /*
-               if (pNode->next == NULL)
-                       pHead->tail = pNode;*/
+       pPrev = list_prev_node(pHead, pNode);
+       if(pNode->pNext == NULL) /* removing from end of list */
+       {
+               if(pPrev == NULL) /* no node before this one */
+               {
+                       pHead->pNext = NULL;
+               } else { /* previous node exists */
+                       /*pHead->pNext = pHead->pNext->pNext;*/
+                       pPrev->pNext = NULL;
+               }
+       } else { /* removing from middle */
+               if(pPrev == NULL)
+               {
+                       pHead->pNext = pNode->pNext;
+               } else {
+                       pPrev->pNext = pNode->pNext;
+               }
        }
-       free(pTemp);
+       free(pNode);
        pHead->count--;
        return 1;
 }
 
 int list_rm_before(List_Head *pHead, List_Node *pNode)
 {
-       pNode=NULL;
-       pHead=NULL;
-       /* IMPLEMENT THIS */
-       return 0;
-}
-
-int list_rm_node2(List_Head *pHead, List_Node *pNode)
-{
-       List_Node *pTemp = pHead->pNext;
-       List_Node *pPrev = NULL;
-       if(pHead->count == 0) return -1;
-
-       /* find node in list */
-       while(pTemp != pNode)
-       {
-               pPrev = pTemp;
-               pTemp = pTemp->pNext;
-       }
-       if(pTemp == NULL) return -1; /* could not find this node at all */
-
-       /* found node at end of list */
-       if(pTemp->pNext == NULL)
-       {
-               pPrev->pNext = NULL; /* move end of list up one */
-       } else { /* found node between two other nodes */
-               pPrev->pNext = pTemp->pNext;
-       }
-       free(pNode);
-       pHead->count--;
-       return 1;
+       List_Node *pPrev = list_prev_node(pHead, pNode);
+       if(pPrev == NULL)
+               return -1;
+       return list_rm_node(pHead, pPrev);
 }
 
 void list_clear(List_Head *pHead)
@@ -256,3 +202,18 @@ void list_clear(List_Head *pHead)
        pHead->count = 0;
        pHead->pNext = NULL;
 }
+
+List_Node *list_prev_node(List_Head *pHead, List_Node *pNode)
+{
+       List_Node *pPrev = NULL, *pTemp;
+
+       if(pHead == NULL || pNode == NULL)
+               return NULL;
+       pTemp = pHead->pNext;
+       do {
+               pPrev = pTemp;
+               pTemp = pTemp->pNext;
+               if(pTemp == NULL) return NULL; /* reached end of list */
+       } while(pTemp != pNode);
+       return pPrev;
+}

diff --git a/lib_ll.h b/lib_ll.h
index 9a81e23..aec6316 100644 (file)
--- a/lib_ll.h
+++ b/lib_ll.h
@@ -7,12 +7,19 @@
 /* return address of data in this node */
 #define list_data(element) ((element)->pData)
 
+/* test node to determine if it is the head of list */
 #define list_is_head(list, element) ((element) == (list)->pNext ? 1 : 0)
 
+/* test node to determine if it is the tail of list */
 #define list_is_tail(element) ((element)->pNext == NULL ? 1 : 0)
 
+/* remove next node in list */
+#define list_rm_next(list, element) list_rm_node(list, (element)->pNext)
+
+/* return pointer to the head node in the list */
 #define list_head(list) ((list)->pNext)
 
+/* return integer value of the size of the list */
 #define list_size(list) ((list)->count)
 
 typedef struct list_node {
@@ -31,9 +38,9 @@ List_Head *list_new(void);
 /* completely delete list and return all memory to heap */
 void list_delete(List_Head *);
 
-/* Returns length of list
-       Returns integer count of number of nodes in list.
-       If pointer passed to function is null, returns -1 value.
+/* returns length of list.
+       returns integer count of number of nodes in list.
+       if pointer passed to function is null, returns -1 value.
 */
 int list_len(List_Head *);
 
@@ -43,7 +50,7 @@ List_Node *list_search(List_Head *);
 /* return address of end of list */
 List_Node *list_tail(List_Head *);
 
-/*print list contents and details */
+/* print list contents and details */
 void list_print(List_Head *);
 
 /* push new node on head of list */
@@ -61,12 +68,17 @@ List_Node *list_ins_after(List_Head *, List_Node *);
 /* node remove (by address) */
 int list_rm_node(List_Head *pHead, List_Node *);
 
-/* remove next node in list */
-int list_rm_next(List_Head *pHead, List_Node *);
-
+/* remove node before this address if it exists
+       returns 1 if ok, -1 list empty or did not contain specified node
+*/
 int list_rm_before(List_Head *pHead, List_Node *);
 
 /* remove all nodes in list and free memory for each node */
 void list_clear(List_Head *);
 
+/* return address of previous node in list
+       returns NULL if no node found -- address of node otherwise
+*/
+List_Node *list_prev_node(List_Head *pHead, List_Node *pNode);
+
 #endif /* LIB_LL_H_ */

diff --git a/lib_test.c b/lib_test.c
index fb4a708..e27844d 100644 (file)
--- a/lib_test.c
+++ b/lib_test.c
@@ -5,6 +5,8 @@
 
 #include "lib_test.h"
 #include "lib_ll.h"
+#include "lib_vqueue.h"
+#include "lib_vstack.h"
 
 #define PASSED 0
 #define FAILED 1
@@ -12,10 +14,6 @@
 void exit_error(const char *err_msg)
 {
        fprintf(stderr, "ERROR: %s\n", err_msg);
-       /*
-       if(pInfile != NULL) { fclose(pInfile); }
-       if(pOutfile != NULL) { fclose(pOutfile); }
-       */
        exit(EXIT_FAILURE);
 }
 
@@ -48,115 +46,108 @@ void test_msg_end(int pass)
 int test_linked_list()
 {
        int result = 0;
-       List_Node *test_node = NULL;
+       List_Node *test_node1 = NULL;
        List_Node *test_node2 = NULL;
        List_Head *test_list = list_new();
 
-       test_msg_start("Testing Linked List Creation");
+       test_msg_start("Test Linked List Creation");
        if(test_list == NULL) result++;
        test_msg_end(result);
 
-       test_msg_start("Testing Linked List Empty Length - Using Variable");
+       test_msg_start("Test Linked List Empty Length - Using Variable");
        if(test_list->count != 0) result++;
        test_msg_end(result);
 
-       test_msg_start("Testing Linked List Empty Length - Using Length Function");
+       test_msg_start("Test Linked List Empty Length - Using Length Function");
        if(list_len(test_list) != 0 ) result++;
        test_msg_end(result);
 
-       test_msg_start("Testing Linked List - Adding Node To Empty List");
+       test_msg_start("Test Linked List - Adding Node To Empty List");
        if(list_ins_tail(test_list) == NULL) result++;
        test_msg_end(result);
 
-       test_msg_start("Testing Linked List - Adding Node To Non-Empty List");
+       test_msg_start("Test Linked List - Adding Node To Non-Empty List");
        if(list_ins_tail(test_list) == NULL) result++;
        test_msg_end(result);
 
-       test_msg_start("Testing Linked List - Clearing List With More Than One Node");
+       test_msg_start("Test Linked List - Clearing List With More Than One Node");
        list_clear(test_list);
        if(test_list->count != 0) result++;
        if(list_len(test_list) != 0 ) result++;
        test_msg_end(result);
 
-       test_msg_start("Testing Linked List - Clearing List With No Nodes");
+       test_msg_start("Test Linked List - Clearing List With No Nodes");
        list_clear(test_list);
        if(test_list->count != 0) result++;
        if(list_len(test_list) != 0 ) result++;
        test_msg_end(result);
 
-       test_msg_start("Testing Linked List End - No Nodes");
+       test_msg_start("Test Linked List End - No Nodes");
        list_clear(test_list);
        if(list_tail(test_list) != NULL) result++;
        test_msg_end(result);
 
-       test_msg_start("Testing Linked List End - One Node Only");
+       test_msg_start("Test Linked List End - One Node Only");
        list_clear(test_list);
-       test_node = list_ins_tail(test_list);
-       if(test_node == NULL) result++;
-       if(list_tail(test_list) != test_node) result++;
+       test_node1 = list_ins_tail(test_list);
+       if(test_node1 == NULL) result++;
+       if(list_tail(test_list) != test_node1) result++;
        test_msg_end(result);
 
-       test_msg_start("Testing Linked List End - More Than One Node");
+       test_msg_start("Test Linked List End - More Than One Node");
        list_clear(test_list);
        list_ins_tail(test_list);
-       test_node = list_ins_tail(test_list);
-       if(test_node == NULL) result++;
-       if(list_tail(test_list) != test_node) result++;
+       test_node1 = list_ins_tail(test_list);
+       if(test_node1 == NULL) result++;
+       if(list_tail(test_list) != test_node1) result++;
        test_msg_end(result);
 
-       /*
-       test_msg_start("Testing Linked List - Deleting List");
-       list_delete(test_list);
-       if(list_len(test_list) != -1) result++;
-       test_msg_end(result);
-       */
-
-       test_msg_start("Testing Linked List - Removing Node From List With More Than One Node");
+       test_msg_start("Test Linked List - Removing Node From List With More Than One Node");
        list_clear(test_list);
-       test_node = list_ins_tail(test_list);
+       test_node1 = list_ins_tail(test_list);
        test_node2 = list_ins_head(test_list);
-       list_rm_node(test_list, test_node);
+       list_rm_node(test_list, test_node1);
        if(test_list->pNext != test_node2) result++;
        test_msg_end(result);
 
-       test_msg_start("Testing Linked List - Removing Node From Empty List");
+       test_msg_start("Test Linked List - Removing Node From Empty List");
        list_clear(test_list);
-       test_node = (List_Node*)&test_list; /* pointer points to known bad location */
+       test_node1 = (List_Node*)&test_list; /* pointer points to known bad location */
        /* should not crash but return gracefully */
-       if(list_rm_node(test_list, test_node) != -1) result++;
+       if(list_rm_node(test_list, test_node1) != -1) result++;
        test_msg_end(result);
 
-       test_msg_start("Testing Linked List - Inserting Node After");
+       test_msg_start("Test Linked List - Inserting Node After");
        list_clear(test_list);
-       test_node = NULL;
+       test_node1 = NULL;
        test_node2 = NULL;
-       test_node = list_ins_tail(test_list);
-       test_node2 = list_ins_after(test_list, test_node);
+       test_node1 = list_ins_tail(test_list);
+       test_node2 = list_ins_after(test_list, test_node1);
 
         /* test beginning */
-       if(test_list->pNext != test_node) result++;
+       if(test_list->pNext != test_node1) result++;
         /*...and end nodes. */
        if(list_tail(test_list) != test_node2) result++;
        /* end node next should be null */
        if(list_tail(test_list)->pNext != NULL) result++;
        test_msg_end(result);
 
-       test_msg_start("Testing Linked List - Inserting Node Before");
+       test_msg_start("Test Linked List - Inserting Node Before");
        list_clear(test_list);
-       test_node = NULL;
+       test_node1 = NULL;
        test_node2 = NULL;
-       test_node = list_ins_head(test_list);
-       test_node2 = list_ins_before(test_list, test_node);
+       test_node1 = list_ins_head(test_list);
+       test_node2 = list_ins_before(test_list, test_node1);
 
        /* test beginning */
        if(test_list->pNext != test_node2) result++;
        /*...and end nodes. */
-       if(list_tail(test_list) != test_node) result++;
+       if(list_tail(test_list) != test_node1) result++;
        /* end node next should be null */
        if(list_tail(test_list)->pNext != NULL) result++;
        test_msg_end(result);
 
-       test_msg_start("Testing Linked List - Test Lengths");
+       test_msg_start("Test Linked List - Test Lengths");
        list_clear(test_list);
        if(list_len(test_list) != 0) result++;
 
@@ -172,61 +163,248 @@ int test_linked_list()
 
        list_ins_after(test_list, list_tail(test_list));
        if(list_len(test_list) != 4) result++;
+       test_msg_end(result);
+
+       test_msg_start("Test Linked List - Previous Node Check");
+       list_clear(test_list);
+       test_node1 = NULL;
+       test_node2 = NULL;
+       if(list_prev_node(test_list, NULL) != NULL) result++;
+       if(list_prev_node(NULL, test_list->pNext) != NULL) result++;
+       if(list_prev_node(NULL, test_node1 + 1000) != NULL) result++;
+       test_node1 = list_ins_head(test_list);
+       if(list_prev_node(test_list, test_list->pNext) != NULL) result++;
+       test_node2 = list_ins_head(test_list);
+       if(list_prev_node(test_list, test_node1) != test_node2) result++;
+       if(list_prev_node(test_list, test_node2) != NULL) result++;
+       test_msg_end(result);
 
+       test_msg_start("Test Linked List - Removing Nodes By Address");
        /* removing nodes from various places */
+       list_clear(test_list);
+       test_node1 = NULL;
+       test_node2 = NULL;
+
+       if(list_rm_node(NULL, test_list->pNext)!= -1) result++;
+       if(list_rm_node(test_list, NULL) != -1) result++;
+       test_node1 = list_ins_head(test_list);
+       test_node2 = list_ins_head(test_list);
        list_rm_node(test_list, test_list->pNext);
-       if(list_len(test_list) != 3) result++;
+       if(list_len(test_list) != 1) result++;
+       test_node1 = list_tail(test_list);
+       list_rm_node(test_list, test_node1);
+       if(list_len(test_list) != 0) result++;
+       if(list_rm_node(test_list, list_tail(test_list)) != -1) result++;
+       test_msg_end(result);
 
-       list_rm_node(test_list, list_tail(test_list));
-       if(list_len(test_list) != 2) result++;
+       test_msg_start("Test Linked List - Removing Nodes After Address");
+       list_clear(test_list);
+       test_node1 = NULL;
+       test_node2 = NULL;
+       test_node1 = list_ins_tail(test_list);
+       test_node2 = list_ins_tail(test_list);
+       if(list_rm_next(test_list, test_node1) != 1) result++;
 
        test_msg_end(result);
 
-       test_msg_start("Testing Linked List - List Next Preprocessor");
+       test_msg_start("Test Linked List - Removing Nodes Before Address");
        list_clear(test_list);
-       test_node = NULL;
+       test_node1 = NULL;
        test_node2 = NULL;
-       test_node = list_ins_tail(test_list);
+       if(list_rm_before(test_list, NULL) != -1) result++;
+       if(list_rm_before(NULL, NULL) != -1) result++;
+       if(list_rm_before(test_list + 1000, NULL) != -1) result++;
+       test_node1 = list_ins_tail(test_list);
        test_node2 = list_ins_tail(test_list);
-       if(list_next(test_node) == test_node) result++;
-       if(list_next(test_node) != test_node2) result++;
-       /* add stuff here */
+       if(list_rm_before(test_list, test_node2 + 1000) != -1) result++;
+       if(list_rm_before(test_list, test_node2) != 1) result++;
        test_msg_end(result);
 
-       test_msg_start("Testing Linked List - List Data Preprocessor");
-       /* default payload should be null */
-       if(list_data(test_node2) != NULL) result++;
+       test_msg_start("Test Linked List - List Next Preprocessor");
+       list_clear(test_list);
+       test_node1 = NULL;
+       test_node2 = NULL;
+       test_node1 = list_ins_tail(test_list);
+       test_node2 = list_ins_tail(test_list);
+       if(list_next(test_node1) == test_node2) result++;
+       test_msg_end(result);
+
+       test_msg_start("Test Linked List - Default Payload");
+       list_clear(test_list);
+       test_node1 = NULL;
+       test_node2 = NULL;
+       test_node1 = list_ins_tail(test_list);
+       test_node2 = list_ins_tail(test_list);
+       if(test_node1->pData != NULL) result++;
 
        /* make data point to something and test again... */
-       test_node2->pData = test_node2;
-       if(list_data(test_node2) != test_node2) result++;
+       test_node1->pData = test_node1;
+       if(list_data(test_node1) != test_node1) result++;
        test_msg_end(result);
 
-       test_msg_start("Testing Linked List - List Is Head Preprocessor");
+       test_msg_start("Test Linked List - List Is Head Preprocessor");
        if(list_is_head(test_list, test_node2) != 0) result++;
-       if(list_is_head(test_list, test_node) != 1) result++;
+       if(list_is_head(test_list, test_node1) != 1) result++;
        test_msg_end(result);
 
-       test_msg_start("Testing Linked List - List Is Tail Preprocessor");
+       test_msg_start("Test Linked List - List Is Tail Preprocessor");
        if(list_is_tail(test_node2) != 1) result++;
-       if(list_is_tail(test_node) != 0) result++;
+       if(list_is_tail(test_node1) != 0) result++;
+       test_msg_end(result);
+
+       test_msg_start("Test Linked List - List Head Preprocessor");
+       if(list_head(test_list) != test_node1) result++;
+       test_msg_end(result);
+
+       return result;
+}
+
+int test_vstack()
+{
+       int result = 0;
+       int i = 0;
+       char data[] = "This is some test data\n";
+       char *pCh;
+       Stack_Head *test_stack = vstack_new();
+       Stack_Node *temp_node1 = NULL, *temp_node2 = NULL;
+
+       test_msg_start("Test Variable Stack - Creating New Stack");
+       if(!test_stack) result++;
        test_msg_end(result);
 
-       test_msg_start("Testing Linked List - List Head Preprocessor");
-       if(list_head(test_list) != test_node) result++;
+       test_msg_start("Test Variable Stack - Pushing Data Into Stack");
+       while(data[i] != '\0')
+       {
+               temp_node1 = vstack_push(test_stack);
+               /* reserve memory for node payload - pointer to memory in pData */
+               pCh = malloc(sizeof(char));
+               *pCh = data[i];
+               temp_node1->pData = pCh;
+               i++;
+       }
+       test_msg_end(result);
+
+       test_msg_start("Test Variable Stack - Popping Data Off Of Stack");
+       while(i > 0)
+       {
+               i--;
+               temp_node1 = vstack_peek(test_stack);
+               /* verify data of this node */
+               pCh = temp_node1->pData;
+               if(*pCh != data[i]) result++;
+               vstack_pop(test_stack);
+       }
+       test_msg_end(result);
+
+       test_msg_start("Test Variable Stack - Popping Data Off Empty Stack");
+       vstack_clear(test_stack);
+       if(vstack_pop(test_stack) != -1) result++;
+       test_msg_end(result);
+
+       test_msg_start("Test Variable Stack - Tracking Stack Size");
+       vstack_clear(test_stack);
+       if(vstack_size(test_stack) != 0) result++;
+       vstack_push(test_stack);
+       if(vstack_size(test_stack) != 1) result++;
+       temp_node1 = vstack_peek(test_stack);
+       if(vstack_size(test_stack) != 1) result++;
+       vstack_pop(test_stack);
+       if(vstack_size(test_stack) != 0) result++;
        test_msg_end(result);
 
-       test_msg_start("Testing Linked List - Inserting Node Before");
-       /* add stuff here */
+       test_msg_start("Test Variable Stack - Tracking Node Address With Peek and Push");
+       vstack_clear(test_stack);
+       temp_node1 = NULL;
+       temp_node1 = vstack_push(test_stack);
+       temp_node2 = vstack_push(test_stack);
+       if(vstack_peek(test_stack) != temp_node2) result++;
+       vstack_pop(test_stack);
+       if(vstack_peek(test_stack) != temp_node1) result++;
        test_msg_end(result);
 
        return result;
 }
 
+int test_vqueue()
+{
+       int result = 0;
+       int i = 0;
+       char data[] = "T\n";
+       char *pCh;
+       Queue_Head *test_q = vq_new();
+       Queue_Node *temp_node1 = NULL, *temp_node2 = NULL;
+
+       test_msg_start("Test Queue - Creating New Queue");
+       if(!test_q) result++;
+       test_msg_end(result);
+
+       test_msg_start("Test Queue - Pushing Data Into Queue");
+       while(data[i] != '\0')
+       {
+               temp_node1 = vq_enq(test_q);
+               /* reserve memory for node payload - pointer to memory in pData */
+               pCh = malloc(sizeof(char));
+               *pCh = data[i];
+               temp_node1->pData = pCh;
+               i++;
+       }
+       test_msg_end(result);
+
+       test_msg_start("Test Queue - Popping Data Off Of Queue");
+       i = 0;
+       while(data[i] != '\n')
+       {
+               temp_node1 = vq_peek(test_q);
+               /* verify data of this node */
+               pCh = temp_node1->pData;
+               if(*pCh != data[i]) result++;
+               vq_deq(test_q);
+               i++;
+       }
+       test_msg_end(result);
+
+       test_msg_start("Test Queue - Popping Data Off Empty Queue");
+       vq_clear(test_q);
+       if(vq_deq(test_q) != -1) result++;
+       test_msg_end(result);
+
+       test_msg_start("Test Queue - Tracking Queue Size");
+       vq_clear(test_q);
+       if(vq_size(test_q) != 0) result++;
+       vq_enq(test_q);
+       if(vq_size(test_q) != 1) result++;
+       temp_node1 = vq_peek(test_q);
+       if(vq_size(test_q) != 1) result++;
+       vq_deq(test_q);
+       if(vq_size(test_q) != 0) result++;
+       test_msg_end(result);
+
+       test_msg_start("Test Queue - Tracking Node Address With Enqueue and Dequeue");
+       vq_clear(test_q); temp_node1 = NULL; temp_node2 = NULL;
+       temp_node1 = vq_enq(test_q);
+       temp_node2 = vq_enq(test_q);
+       if(vq_peek(test_q) != temp_node1) result++;
+       vq_deq(test_q);
+       if(vq_peek(test_q) != temp_node2) result++;
+       test_msg_end(result);
+
+       return result;
+}
+
+int test_stack_array()
+{
+       int result = 0;
+
+       return result;
+}
+
 int test_all()
 {
        int result = 0;
        result += test_linked_list();
+       result += test_stack_array();
+       result += test_vstack();
+       result += test_vqueue();
        return result;
 }
 

diff --git a/lib_vqueue.h b/lib_vqueue.h
new file mode 100644 (file)
index 0000000..de842a9
--- /dev/null
+++ b/lib_vqueue.h
@@ -0,0 +1,28 @@
+#ifndef LIB_VQUEUE_H_
+#define LIB_VQUEUE_H_
+
+#define Queue_Head List_Head
+#define Queue_Node List_Node
+
+/* create a new queue */
+#define vq_new() list_new()
+
+/* add node to queue */
+#define vq_enq(pHead) list_ins_head(pHead)
+
+/* remove node from queue */
+#define vq_deq(pHead) list_rm_node(pHead, list_tail(pHead))
+
+/* view next node in line */
+#define vq_peek(pHead) list_tail(pHead)
+
+/* number of elements in queue */
+#define vq_size(pHead) pHead->count
+
+/* empty contents of queue */
+#define vq_clear(pHead) list_clear(pHead)
+
+/* delete and free contents of this queue */
+#define vq_delete(pHead) list_delete(pHead)
+
+#endif /* LIB_VQUEUE_H_ */

diff --git a/lib_vstack.h b/lib_vstack.h
new file mode 100644 (file)
index 0000000..cffe38f
--- /dev/null
+++ b/lib_vstack.h
@@ -0,0 +1,28 @@
+#ifndef LIB_VSTACK_H_
+#define LIB_VSTACK_H_
+
+#define Stack_Head List_Head
+#define Stack_Node List_Node
+
+/* create a new stack */
+#define vstack_new() list_new()
+
+/* push node onto stack */
+#define vstack_push(pHead) list_ins_head(pHead)
+
+/* remove node from stack */
+#define vstack_pop(pHead) list_rm_node(pHead, pHead->pNext)
+
+/* view next node in stack */
+#define vstack_peek(pHead) pHead->pNext
+
+/* number of elements in stack */
+#define vstack_size(pHead) pHead->count
+
+/* empty contents of stack */
+#define vstack_clear(pHead) list_clear(pHead)
+
+/* delete and free contents of this queue */
+#define vstack_delete(pHead) list_delete(pHead)
+
+#endif /* LIB_VSTACK_H_ */