예제 #1
0
파일: test.c 프로젝트: albedium/liblist
void * list_get_data(void * arg)
{
    int retval;
    ck_assert ( arg != NULL );
    llist listToTest = (llist)arg;


    start_waiting:

    retval = llist_delete_node ( listToTest, ( llist_node ) 4, false, NULL );
    if ( LLIST_SUCCESS != retval)
    {
        //wait for 100 milliseconds
        printf("find attempted");
        usleep(1000*100);
        //printf ("the address to jump %p", &&start_waiting);
        goto start_waiting;
    }
    return NULL;
}
예제 #2
0
파일: test.c 프로젝트: capnramses/apg
int main () {
	printf ("apg_data_structures test\n");
	printf ("sizeof llist_node_t %i\nsizeof dllist_node_t %i\n", (int)sizeof (llist_node_t),
		(int)sizeof (dllist_node_t));
	{
		printf ("\n0) linked list:\n");
		llist_node_t* llist_list_ptr = NULL;
		// add nodes
		char data = 'a';
		llist_add_to_front (&llist_list_ptr, &data, 1);
		data = 'b';
		llist_add_to_front (&llist_list_ptr, &data, 1);
		data = 'c';
		llist_add_to_front (&llist_list_ptr, &data, 1);
		data = 'd';
		llist_node_t* d_ptr = llist_add_to_front (&llist_list_ptr, &data, 1);
		data = 'e';
		llist_add_to_front (&llist_list_ptr, &data, 1);
		data = 'f';
		llist_add_to_front (&llist_list_ptr, &data, 1);
		// add g 'after' d
		data = 'g';
		llist_node_t* g_ptr = llist_insert_after (d_ptr, &data, 1);
		printf ("contents of list:\n");
		llist_node_t* p = llist_list_ptr;
		while (p) {
			printf ("  %c\n", *(char*)p->data);
			p = p->next;
		}
		print_mem_allocd ();
		// remove a node from front, end, middle
		// delete 'f'
		assert (llist_delete_node (&llist_list_ptr, llist_list_ptr));
		// delete 'a'
		llist_node_t* end_ptr = llist_find_end_node (llist_list_ptr);
		assert (llist_delete_node (&llist_list_ptr, end_ptr));
		// delete 'd'
		assert (llist_delete_node (&llist_list_ptr, d_ptr));
		printf ("contents of list:\n");
		p = llist_list_ptr;
		while (p) {
			printf ("  %c\n", *(char*)p->data);
			p = p->next;
		}
		print_mem_allocd ();
		// delete the entire list
		assert (llist_recursive_delete (&llist_list_ptr));
		printf ("contents of list:\n");
		p = llist_list_ptr;
		while (p) {
			printf ("  %c\n", *(char*)p->data);
			p = p->next;
		}
		print_mem_allocd ();
	}
	///////////////////////////////////////////////////////////////////////////
	{
		printf ("\n1) doubly-linked list:\n");
		dllist_node_t* dllist_list_ptr = NULL;
		// add nodes
		char data = 'a';
		dllist_add_to_front (&dllist_list_ptr, &data, 1);
		data = 'b';
		dllist_add_to_front (&dllist_list_ptr, &data, 1);
		data = 'c';
		dllist_add_to_front (&dllist_list_ptr, &data, 1);
		data = 'd';
		dllist_node_t* d_ptr = dllist_add_to_front (&dllist_list_ptr, &data, 1);
		data = 'e';
		dllist_add_to_front (&dllist_list_ptr, &data, 1);
		data = 'f';
		dllist_add_to_front (&dllist_list_ptr, &data, 1);
		// add g 'after' d
		data = 'g';
		dllist_node_t* g_ptr = dllist_insert_after (d_ptr, &data, 1);
		printf ("contents of list:\n");
		dllist_node_t* p = dllist_list_ptr;
		while (p) {
			printf ("  %c\n", *(char*)p->data);
			p = p->next;
		}
		print_mem_allocd ();
		// remove a node from front, end, middle
		// delete 'f'
		assert (dllist_delete_node (&dllist_list_ptr, dllist_list_ptr));
		// delete 'a'
		dllist_node_t* end_ptr = dllist_find_end_node (dllist_list_ptr);
		assert (dllist_delete_node (&dllist_list_ptr, end_ptr));
		// delete 'd'
		assert (dllist_delete_node (&dllist_list_ptr, d_ptr));
		printf ("contents of list:\n");
		p = dllist_list_ptr;
		while (p) {
			printf ("  %c\n", *(char*)p->data);
			p = p->next;
		}
		print_mem_allocd ();
		// delete the entire list
		assert (dllist_recursive_delete (&dllist_list_ptr));
		printf ("contents of list:\n");
		p = dllist_list_ptr;
		while (p) {
			printf ("  %c\n", *(char*)p->data);
			p = p->next;
		}
		print_mem_allocd ();
	}
	///////////////////////////////////////////////////////////////////////////
#if 0
	{
		printf ("\n2) hash table length 16:\n");
		int k = 16;
		printf ("dog = %i\n", hash_index ("dog", k));
		printf ("god = %i\n", hash_index ("god", k));
		printf ("cat = %i\n", hash_index ("cat", k));
		printf ("hamster = %i\n", hash_index ("hamster", k));
		printf ("albatross = %i\n", hash_index ("albatross", k));
		printf ("unfavourable stare = %i\n", hash_index ("unfavourable stare", k));
		printf ("anton = %i\n", hash_index ("anton", k));
		printf ("is = %i\n", hash_index ("is", k));
		printf ("and outstanding gentleman, and incredibly humble = %i\n",
			hash_index ("and outstanding gentleman, and incredibly humble", k));
		printf ("suddenly = %i\n", hash_index ("suddenly", k));
		printf ("it = %i\n", hash_index ("it", k));
		printf ("sprang = %i\n", hash_index ("sprang", k));
		printf ("from = %i\n", hash_index ("from", k));
	}
#endif
	{
		int u = 1000, v = 250;
		reduce_frac( &u, &v );
		printf("1000/250 reduces to %i/%i\n", u, v);
	}
	return 0;
}
예제 #3
0
파일: test.c 프로젝트: albedium/liblist
END_TEST

START_TEST ( llist_04_delete_nodes )
{
    int retval;
    //llist_node temp;
    llist listToTest = NULL;
    listToTest = llist_create ( NULL, trivial_equal,  test_mt ? MT_SUPPORT_FALSE : MT_SUPPORT_TRUE  );

    // Insert a 5 nodes 1..5
    retval = llist_add_node ( listToTest, ( llist_node ) 1, ADD_NODE_FRONT );
    ck_assert_int_eq ( retval, LLIST_SUCCESS );

    retval = llist_add_node ( listToTest, ( llist_node ) 2, ADD_NODE_FRONT );
    ck_assert_int_eq ( retval, LLIST_SUCCESS );

    retval = llist_add_node ( listToTest, ( llist_node ) 3, ADD_NODE_FRONT );
    ck_assert_int_eq ( retval, LLIST_SUCCESS );

    retval = llist_add_node ( listToTest, ( llist_node ) 4, ADD_NODE_FRONT );
    ck_assert_int_eq ( retval, LLIST_SUCCESS );

    retval = llist_add_node ( listToTest, ( llist_node ) 5, ADD_NODE_FRONT );
    ck_assert_int_eq ( retval, LLIST_SUCCESS );

    printf ( "List after adding nodes: " );
    print_llist ( listToTest );

   // Delete tail
    retval = llist_delete_node ( listToTest, ( llist_node ) 1, false, NULL );
    ck_assert_int_eq ( retval, LLIST_SUCCESS );

    printf ( "List after deleting tail: " );
    print_llist ( listToTest );

    // Delete node in the middle
    retval = llist_delete_node ( listToTest, ( llist_node ) 3, false, NULL );
    ck_assert_int_eq ( retval, LLIST_SUCCESS );

    printf ( "List after deleting middle node: " );
    print_llist ( listToTest );

    // Delete head
    retval = llist_delete_node ( listToTest, ( llist_node ) 5, false, NULL );
    ck_assert_int_eq ( retval, LLIST_SUCCESS );

    printf ( "List after deleting head node: " );
    print_llist ( listToTest );

    // Delete a node that doesn't exist
    retval = llist_delete_node ( listToTest, ( llist_node ) 6, false, NULL );
    ck_assert_int_eq ( retval, LLIST_NODE_NOT_FOUND );

    retval = llist_delete_node ( listToTest, ( llist_node ) 2, false, NULL );
    ck_assert_int_eq ( retval, LLIST_SUCCESS );

    // The list should not  be empty now
    ck_assert_int_eq(llist_is_empty ( listToTest ), FALSE );

    ck_assert_int_eq(llist_is_empty ( listToTest ), FALSE );

    // Delete last node
    retval = llist_delete_node ( listToTest, ( llist_node ) 4, false, NULL );
    ck_assert_int_eq ( retval, LLIST_SUCCESS );

    // The list should be empty now
    ck_assert_int_eq(llist_is_empty ( listToTest ), TRUE );

    llist_destroy ( listToTest, false, NULL );
}