static void
test_with_deque_iterator() {
struct clib_deque* myDeq = create_deque();
print_using_iterator(myDeq);
replace_values_using_iterators(myDeq);
print_using_iterator(myDeq);
delete_c_deque ( myDeq );
}
int main(int argc, char* argv[])
{
deque_t* pdeq_coll = NULL;
person_t t_person;
type_register(person_t, NULL, NULL, NULL, NULL);
pdeq_coll = create_deque(person_t);
if(pdeq_coll == NULL)
{
return -1;
}
deque_init(pdeq_coll);
memset(t_person.s_firstname, '\0', 21);
memset(t_person.s_lastname, '\0', 21);
strcpy(t_person.s_firstname, "Jonh");
strcpy(t_person.s_lastname, "right");
deque_push_back(pdeq_coll, &t_person);
memset(t_person.s_firstname, '\0', 21);
memset(t_person.s_lastname, '\0', 21);
strcpy(t_person.s_firstname, "Bill");
strcpy(t_person.s_lastname, "killer");
deque_push_back(pdeq_coll, &t_person);
memset(t_person.s_firstname, '\0', 21);
memset(t_person.s_lastname, '\0', 21);
strcpy(t_person.s_firstname, "Jonh");
strcpy(t_person.s_lastname, "sound");
deque_push_back(pdeq_coll, &t_person);
memset(t_person.s_firstname, '\0', 21);
memset(t_person.s_lastname, '\0', 21);
strcpy(t_person.s_firstname, "Bin");
strcpy(t_person.s_lastname, "lee");
deque_push_back(pdeq_coll, &t_person);
memset(t_person.s_firstname, '\0', 21);
memset(t_person.s_lastname, '\0', 21);
strcpy(t_person.s_firstname, "Lee");
strcpy(t_person.s_lastname, "bird");
deque_push_back(pdeq_coll, &t_person);
algo_for_each(deque_begin(pdeq_coll), deque_end(pdeq_coll), _print);
printf("\n");
algo_sort_if(deque_begin(pdeq_coll), deque_end(pdeq_coll), _person_sort_criterion);
algo_for_each(deque_begin(pdeq_coll), deque_end(pdeq_coll), _print);
printf("\n");
deque_destroy(pdeq_coll);
return 0;
}
int main() {
srand(time(NULL));
deque* d1 = create_deque(int_cmp);
for(uint i = 0; i < 10; ++i) {
int* elem = (int*) s_malloc(sizeof(int));
*elem = (rand() % 100) + 1;
push_back(d1, elem);
}
display_deque_int(d1);
printf("\n\nDeque 2 with pushfront\n\n");
deque* d2 = create_deque(int_cmp);
for(uint i = 0; i < 10; ++i) {
int* elem = (int*) s_malloc(sizeof(int));
*elem = (rand() % 100) + 1;
push_front(d2, elem);
}
display_deque_int(d2);
reorder_deque(d1, sizeof(int));
display_deque_int(d1);
free_deque_front(d1, s_free);
free_deque_back(d2, s_free);
deque* d3 = create_deque(str_cmp);
char* s1 = strdup("Jessica");
char* s2 = strdup("Melanie");
char* s3 = strdup("Batuhan");
char* s4 = strdup("Graves");
push_back(d3, s1);
push_back(d3, s2);
push_back(d3, s3);
push_back(d3, s4);
printf("\n\nDeque 3\n\n");
display_deque_str(d3);
free_deque_front(d3, s_free);
return 0;
}
static void
t_clib_for_each() {
struct clib_array *pArray;
struct clib_deque *pDeq;
struct clib_set *pSet;
struct clib_map *pMap;
struct clib_slist *pSlist;
struct clib_iterator *pArrayIterator;
struct clib_iterator *pDequeIterator;
struct clib_iterator *pSetIterator;
struct clib_iterator *pMapIterator;
struct clib_iterator *pSlistIterator;
printf ( "Performing for_each for array\n");
pArray = create_c_array();
pArrayIterator = new_iterator_c_array ( pArray );
clib_for_each ( pArrayIterator, print_integers );
delete_c_array( pArray );
delete_iterator_c_array ( pArrayIterator );
printf ( "Performing for_each for deque\n");
pDeq = create_deque();
pDequeIterator = new_iterator_c_deque ( pDeq );
clib_for_each ( pDequeIterator, print_integers );
delete_c_deque( pDeq );
delete_iterator_c_deque ( pDequeIterator );
printf ( "Performing for_each for set\n");
pSet = create_set();
pSetIterator = new_iterator_c_set ( pSet );
clib_for_each ( pSetIterator, print_integers );
delete_c_set( pSet );
delete_iterator_c_set ( pSetIterator );
printf ( "Performing for_each for map\n");
pMap = create_map();
pMapIterator = new_iterator_c_map ( pMap );
clib_for_each ( pMapIterator, print_integers );
delete_c_map( pMap );
delete_iterator_c_map ( pMapIterator );
printf ( "Performing for_each for slist\n");
pSlist = create_slist();
pSlistIterator = new_iterator_c_slist ( pSlist );
clib_for_each ( pSlistIterator, print_integers );
delete_c_slist( pSlist );
delete_iterator_c_slist ( pSlistIterator );
}
static VALUE deque_alloc(VALUE klass) {
deque *deque = create_deque();
return Data_Wrap_Struct(klass, deque_mark, deque_free, deque);
}
/* This main function does a little testing. Like all good CS Majors, you should
* test your code here. There is no substitute for testing and you should be
* sure to test for all edge cases, like calling empty_deque on an empty deque.
*/
int main(void) {
printf("\n\n**SYDNEY'S TEST CASES**");
printf("\nTEST CASE 01: PUSHING BACK\n");
printf("Creating deque...\n");
deque* abcd = create_deque();
struct person* abbie = create_person("Abbie", 20);
struct person* brian = create_person("Brian", 27);
struct person* charlie = create_person("Charlie", 36);
struct person* daniel = create_person("Daniel", 15);
// end result of adding should look like this:
// (abbie) -> (brian) -> (charlie) -> (daniel)
push_back(abcd, abbie);
assert(abcd->size == 1);
assert(front(abcd) == abbie);
assert(back(abcd) == abbie);
traverse(abcd, print_person);
assert(get(abcd, 0) == abbie);
printf("Successfully added Abbie, 20 \n\n");
// (abbie)
push_back(abcd, brian);
assert(abcd->size == 2);
assert(front(abcd) == abbie);
assert(back(abcd) == brian);
traverse(abcd, print_person);
assert(get(abcd, 0) == abbie);
assert(get(abcd, 1) == brian);
printf("Successfully added Brian, 27 \n\n");
// (abbie) -> (brian)
push_back(abcd, charlie); // push on back Charlie
assert(abcd->size == 3);
assert(front(abcd) == abbie);
assert(back(abcd) == charlie);
traverse(abcd, print_person);
assert(get(abcd, 0) == abbie);
assert(get(abcd, 1) == brian);
assert(get(abcd, 2) == charlie);
printf("Successfully added Charlie, 36 \n\n");
// (abbie) -> (brian) -> (charlie)
push_back(abcd, daniel); // push on back Daniel
assert(abcd->size == 4);
assert(front(abcd) == abbie);
assert(back(abcd) == daniel);
traverse(abcd, print_person);
assert(get(abcd, 0) == abbie);
assert(get(abcd, 1) == brian);
assert(get(abcd, 2) == charlie);
assert(get(abcd, 3) == daniel);
printf("Successfully added Daniel, 15 \n\n");
// (abbie) -> (brian) -> (charlie) -> (daniel)
printf("Everyone added successfully!\n");
printf("Emptying deque...\n");
empty_deque(abcd, free_person);
assert(abcd != NULL);
assert(abcd->size == 0);
assert(front(abcd) == NULL);
assert(back(abcd) == NULL);
printf("\n\nTEST CASE 02: PUSHING FRONT\n");
abbie = create_person("Abbie", 20);
brian = create_person("Brian", 27);
charlie = create_person("Charlie", 36);
daniel = create_person("Daniel", 15);
push_front(abcd, daniel);
assert(abcd->size == 1);
assert(front(abcd) == daniel);
assert(back(abcd) == daniel);
traverse(abcd, print_person);
assert(get(abcd, 0) == daniel);
printf("Successfully added Daniel, 15 \n\n");
// (daniel)
push_front(abcd, charlie);
assert(abcd->size == 2);
assert(front(abcd) == charlie);
assert(back(abcd) == daniel);
traverse(abcd, print_person);
assert(get(abcd, 0) == charlie);
assert(get(abcd, 1) == daniel);
printf("Successfully added Charlie, 36 \n\n");
// (charlie) -> (daniel)
push_front(abcd, brian);
assert(abcd->size == 3);
assert(front(abcd) == brian);
assert(back(abcd) == daniel);
traverse(abcd, print_person);
assert(get(abcd, 0) == brian);
assert(get(abcd, 1) == charlie);
assert(get(abcd, 2) == daniel);
printf("Successfully added Brian, 27 \n\n");
// (brian) -> (charlie) -> (daniel)
push_front(abcd, abbie);
assert(abcd->size == 4);
assert(front(abcd) == abbie);
assert(back(abcd) == daniel);
traverse(abcd, print_person);
assert(get(abcd, 0) == abbie);
assert(get(abcd, 1) == brian);
assert(get(abcd, 2) == charlie);
assert(get(abcd, 3) == daniel);
printf("Successfully added Abby, 20 \n\n");
// (abbie) -> (brian) -> (charlie) -> (daniel)
printf("Everyone added successfully!\n");
printf("\n\nTEST CASE 3: REMOVE IF\n");
printf("This should check if a node being removed is:\n");
printf(" 1) a head only\n");
printf(" 2) a tail only\n");
printf(" 3) both a head and tail\n");
printf(" 4) neither a head nor tail\n\n");
printf("Initial config:\n");
traverse(abcd, print_person);
printf("\n");
remove_if(abcd, is_age_15, free_person); // should remove Daniel
assert(front(abcd) == abbie);
assert(back(abcd) == charlie);
assert(abcd->size == 3);
assert(front(abcd) == abbie);
assert(back(abcd) == charlie);
traverse(abcd, print_person);
assert(get(abcd, 0) == abbie);
assert(get(abcd, 1) == brian);
assert(get(abcd, 2) == charlie);
printf("Removed person who is tail only successfully.\n\n");
// (abbie) -> (brian) -> (charlie)
remove_if(abcd, is_age_20, free_person); // should remove Abbie
assert(front(abcd) == brian);
assert(back(abcd) == charlie);
assert(abcd->size == 2);
traverse(abcd, print_person);
assert(get(abcd, 0) == brian);
assert(get(abcd, 1) == charlie);
printf("Removed person who is head only successfully.\n\n");
// (brian) -> (charlie)
remove_if(abcd, is_age_27, free_person); // removes Brian to test a different edge case
// (charlie)
remove_if(abcd, is_age_36, free_person); // should Remove Charlie
assert(abcd->size == 0);
assert(front(abcd) == NULL);
assert(back(abcd) == NULL);
traverse(abcd, print_person);
// <empty>
printf("Removed person who is both a head and tail successfully.\n\n");
printf("Resetting deque...\n");
abbie = create_person("Abbie", 20);
brian = create_person("Brian", 27);
charlie = create_person("Charlie", 36);
daniel = create_person("Daniel", 15);
push_back(abcd, abbie);
push_back(abcd, brian);
push_back(abcd, charlie);
push_back(abcd, daniel);
// (abbie) -> (brian) -> (charlie) -> (daniel)
printf("Updated config:\n");
traverse(abcd, print_person);
printf("\n");
remove_if(abcd, is_age_36, free_person);
assert(abcd->size == 3);
traverse(abcd, print_person);
assert(get(abcd, 0) == abbie);
assert(get(abcd, 1) == brian);
assert(get(abcd, 2) == daniel);
//
printf("Removed person that is neither a head nor tail successfully.\n");
printf("Success!\n");
empty_deque(abcd, free_person);
free(abcd);
printf("\n\nMake sure to write more test cases as well in test.c!\n"
"Also test using valgrind. Half credit will be given to\n"
"functions with memory leaks or memory errors.\n");
return 0;
}
