int main(void)
{
struct my_list* mt = NULL;
mt = list_new();
list_add_element(mt, 1,1);
list_add_element(mt, 2,2);
list_add_element(mt, 3,3);
list_add_element(mt, 4,4);
list_print(mt);
list_remove_element(mt);
list_print(mt);
list_free(mt); /* always remember to free() the malloc()ed memory */
free(mt); /* free() if list is kept separate from free()ing the structure, I think its a good design */
mt = NULL; /* after free() always set that pointer to NULL, C will run havon on you if you try to use a dangling pointer */
list_print(mt);
return 0;
}
int main (int argc, char** argv) {
tree_t t = tree_new();
list_t l = list_new();
for (int i=0; i<argc-1; i++)
list_add_element (l, argv[i+1]);
int j=0;
for (element_t e = list_get_first_element (l); e != NULL; e = element_get_next (e)) {
if (includeElement())
tree_insert_node (t, e);
}
printf ("Before deleting list:\n");
tree_ordered_suffix_print (t);
list_delete (l);
printf ("After deleting list:\n");
tree_ordered_suffix_print (t);
tree_delete (t);
}
int test_size ( void )
{
// Sign on
printf("**** Linked List Test - size\n");
/*
* create a new list
*/
list_t *SizeTest;
SizeTest = list_create();
printf("\tTest01 - size on empty list %d \n",list_size(SizeTest));
list_add_element(SizeTest,100);
printf("\tTest02 - size on list 1 = %d\n",list_size(SizeTest));
printf("**** Linked ListTest - size Ends\n");
return 0;
}
int test_add ( void )
{
list_t *addTest;
list_t *emplaceTest;
// Sign on
printf("**** Linked List Test - add\n");
/*
* create a new list
*/
addTest = list_create();
printf("\tTest01a - add single element\n");
list_add_element(addTest,10);
list_show(addTest);
printf("\tTest01b - add more elements\n");
list_add_element(addTest,20);
list_add_element(addTest,30);
list_add_element(addTest,40);
list_add_element(addTest,50);
list_add_element(addTest,60);
list_show(addTest);
printf("\tTest01b - size of list %d\n", list_size(addTest));
printf("\tTest02a - add to front\n");
list_push_front(addTest, 111);
list_show(addTest);
printf("\tTest02a - size of list %d\n", list_size(addTest));
printf("\tTest03a - add to back\n");;
list_push_back(addTest, 222);
list_show(addTest);
printf("\tTest03a - size of list %d\n", list_size(addTest));
emplaceTest = list_create();
printf("\tTest04a - emplace\n");
list_add_element(emplaceTest, 1);
list_add_element(emplaceTest, 2);
list_add_element(emplaceTest, 3);
list_add_element(emplaceTest, 4);
list_show(emplaceTest);
printf("\tTest04a - size of list 4 = %d\n", list_size(emplaceTest));
printf("\tTest05a - emplace at position 2\n");
list_add_position(emplaceTest, 2, 5);
list_show(emplaceTest);
printf("\tTest05a - size of list %d\n", list_size(emplaceTest));
printf("\tTest05b get at position 2 (5) %d\n", list_get_position(emplaceTest, 2));
printf("\tTest05c - emplace at position 0\n");
list_add_position(emplaceTest, 0, 555);
list_show(emplaceTest);
printf("\tTest05c - size of list %d\n", list_size(emplaceTest));
printf("\tTest05c get at position 2 (555) %d\n", list_get_position(emplaceTest, 0));
printf("\tTest05d - emplace at position size+1\n");
list_add_position(emplaceTest, (list_size(emplaceTest)+1), 100);
printf("**** Linked List Test - add Ends\n");
return 0;
}
void main()
{
queue* myQueue = list_new();
assert(myQueue);
assert(myQueue->head->num == 0);
assert(myQueue->tail->num == 0);
printf("test no queue passed in\n");
int ret = list_remove_element(NULL, 9);
assert (ret == ULT_INVALID);
/*
printf("\ntest empty list\n");
ret = list_remove_element(myQueue, 12);
assert (ret == ULT_NONE);
*/
printf("\ntest add to invalid queue\n");
ret = list_add_element(NULL);
assert (ret == ULT_FAILED);
printf("\ntest add 1 element\n");
ret = list_add_element(myQueue);
printf("first element after tid 0: %d\n", ret);
assert (ULT_isOKRet(ret));
printf("\ninside queue, %d elements\n", myQueue->numTCB);
list_print(myQueue);
list_print_backwards(myQueue);
printf("\ntest add another element\n");
ret = list_add_element(myQueue);
printf("second element after tid 0: %d\n", ret);
assert (ULT_isOKRet(ret));
printf("\ninside queue, %d elements\n", myQueue->numTCB);
list_print(myQueue);
list_print_backwards(myQueue);
//TESTS FOR LIST_REMOVE_HEAD
printf("\ntest remove first element 3 times\n");
ret = list_remove_head(myQueue);
printf("element's tid: %d\n", ret);
assert (ULT_isOKRet(ret));
printf("\ninside queue, %d elements\n", myQueue->numTCB);
list_print(myQueue);
list_print_backwards(myQueue);
ret = list_remove_head(myQueue);
printf("element's tid: %d\n", ret);
assert (ULT_isOKRet(ret));
printf("\ninside queue, %d elements\n", myQueue->numTCB);
list_print(myQueue);
list_print_backwards(myQueue);
ret = list_remove_head(myQueue);
printf("element's tid: %d\n", ret);
assert (ULT_isOKRet(ret));
printf("\ninside queue, %d elements\n", myQueue->numTCB);
list_print(myQueue);
list_print_backwards(myQueue);
printf("\ntest add another element after emptying queue\n");
ret = list_add_element(myQueue);
printf("element: %d\n", ret);
assert (ULT_isOKRet(ret));
printf("\ninside queue, %d elements\n", myQueue->numTCB);
list_print(myQueue);
list_print_backwards(myQueue);
/*
//TESTS FOR LIST_REMOVE_ELEMENT
printf("\ntest remove third element\n");
ret = list_remove_element(myQueue, 2);
printf("element's tid: %d\n", ret);
assert (ULT_isOKRet(ret));
printf("\ninside queue, %d elements\n", myQueue->numTCB);
list_print(myQueue);
list_print_backwards(myQueue);
printf("\ntest remove second element\n");
ret = list_remove_element(myQueue, 1);
printf("element's tid: %d\n", ret);
assert (ULT_isOKRet(ret));
printf("\ninside queue, %d elements\n", myQueue->numTCB);
list_print(myQueue);
list_print_backwards(myQueue);
printf("\ntest remove first element\n");
ret = list_remove_element(myQueue, 0);
printf("element's tid: %d\n", ret);
assert (ULT_isOKRet(ret));
printf("\ninside queue, %d elements\n", myQueue->numTCB);
list_print(myQueue);
list_print_backwards(myQueue);
printf("\ntest remove no more elements\n");
ret = list_remove_element(myQueue, 1);
printf("element's tid: %d\n", ret);
assert (ret == ULT_INVALID);
printf("\ntest add another element after emptying list\n");
ret = list_add_element(myQueue);
printf("element: %d\n", ret);
assert (ULT_isOKRet(ret));
printf("\ninside queue, %d elements\n", myQueue->numTCB);
list_print(myQueue);
list_print_backwards(myQueue);
printf("\ntest add 2nd element after emptying list\n");
ret = list_add_element(myQueue);
printf("element: %d\n", ret);
assert (ULT_isOKRet(ret));
printf("\ninside queue, %d elements\n", myQueue->numTCB);
list_print(myQueue);
list_print_backwards(myQueue);
printf("\ntest add 3rd element after emptying list\n");
ret = list_add_element(myQueue);
printf("element: %d\n", ret);
assert (ULT_isOKRet(ret));
printf("\ninside queue, %d elements\n", myQueue->numTCB);
list_print(myQueue);
list_print_backwards(myQueue);
printf("\ntest remove second element AGAIN\n");
ret = list_remove_element(myQueue, 1);
printf("element's tid: %d\n", ret);
assert (ULT_isOKRet(ret));
printf("\ninside queue, %d elements\n", myQueue->numTCB);
list_print(myQueue);
list_print_backwards(myQueue);
*/
}
