/****************************************************************
**
** test_skiplist_destroy(): Test H5SL (skip list) code.
** Tests 'destroy' operation in skip lists.
**
****************************************************************/
static void
test_skiplist_destroy(void)
{
H5SL_t *slist; /* Skip list created */
size_t u; /* Local index variable */
unsigned free_count; /* Number of items freed */
herr_t ret; /* Generic return value */
/* Output message about test being performed */
MESSAGE(7, ("Testing Skip List 'Destroy' Operation\n"));
/* Create a skip list */
slist = H5SL_create(H5SL_TYPE_INT);
CHECK(slist, NULL, "H5SL_create");
/* Insert objects into the skip list */
for(u=0; u<NUM_ELEMS; u++) {
ret=H5SL_insert(slist,&rand_num[u],&rand_num[u]);
CHECK(ret, FAIL, "H5SL_insert");
} /* end for */
/* Destroy the skip list */
free_count=0;
ret=H5SL_destroy(slist,test_skiplist_destroy_free,&free_count);
CHECK(ret, FAIL, "H5SL_destroy");
VERIFY(free_count, NUM_ELEMS, "H5SL_destroy");
} /* end test_skiplist_destroy() */
/****************************************************************
**
** test_skiplist_lastprev(): Test H5SL (skip list) code.
** Tests iterating over nodes in skip list with last/prev calls.
**
****************************************************************/
static void
test_skiplist_lastprev(void)
{
H5SL_t *slist; /* Skip list created */
H5SL_node_t *node; /* Skip list node */
size_t num; /* Number of elements in skip list */
size_t u; /* Local index variable */
int *found_item; /* Item found in skip list */
herr_t ret; /* Generic return value */
/* Output message about test being performed */
MESSAGE(7, ("Testing Iterating Over Skip List With Last/Prev\n"));
/* Create a skip list */
slist = H5SL_create(H5SL_TYPE_INT);
CHECK(slist, NULL, "H5SL_create");
/* Check that the skip list has no elements */
num=H5SL_count(slist);
VERIFY(num, 0, "H5SL_count");
/* Check that the list appears empty */
node=H5SL_last(slist);
VERIFY(node, NULL, "H5SL_last");
/* Insert many objects into the skip list */
for(u=0; u<NUM_ELEMS; u++) {
ret=H5SL_insert(slist,&rand_num[u],&rand_num[u]);
CHECK(ret, FAIL, "H5SL_insert");
} /* end for */
/* Check that the skip list has correct # of elements */
num=H5SL_count(slist);
VERIFY(num, NUM_ELEMS, "H5SL_count");
/* Iterate over all the nodes in the skip list */
node=H5SL_last(slist);
CHECK(node, NULL, "H5SL_last");
u=NUM_ELEMS-1;
while(node!=NULL) {
found_item=H5SL_item(node);
VERIFY(*found_item,sort_rand_num[u],"H5SL_prev");
u--;
node=H5SL_prev(node);
} /* end while */
/* Release all the items from the list */
ret=H5SL_release(slist);
CHECK(ret, FAIL, "H5SL_release");
/* Check that the list appears empty again */
node=H5SL_last(slist);
VERIFY(node, NULL, "H5SL_last");
/* Close the skip list */
ret=H5SL_close(slist);
CHECK(ret, FAIL, "H5SL_close");
} /* end test_skiplist_lastprev() */
/****************************************************************
**
** test_skiplist_greater(): Test H5SL (skip list) code.
** Tests 'greater' operation in skip lists.
**
****************************************************************/
static void
test_skiplist_greater(void)
{
H5SL_t *slist; /* Skip list created */
size_t u; /* Local index variable */
unsigned data[10]={ 10, 20, 15, 5, 50, 30, 31, 32, 80, 90};
/* unsigned sorted_data[10]={ 5, 10, 15, 20, 30, 31, 32, 50, 80, 90}; */
unsigned *found_item; /* Item found in skip list */
unsigned find_item; /* Item to add to skip list */
herr_t ret; /* Generic return value */
/* Output message about test being performed */
MESSAGE(7, ("Testing Skip List 'Greater' Operation\n"));
/* Create a skip list */
slist = H5SL_create(H5SL_TYPE_UNSIGNED);
CHECK(slist, NULL, "H5SL_create");
/* Insert objects into the skip list */
for(u = 0; u < 10; u++) {
ret = H5SL_insert(slist, &data[u], &data[u]);
CHECK(ret, FAIL, "H5SL_insert");
} /* end for */
/* Check for exact match of items in various positions */
find_item = 20;
found_item = H5SL_greater(slist, &find_item);
VERIFY(*found_item, find_item, "H5SL_greater");
find_item = 90;
found_item = H5SL_greater(slist, &find_item);
VERIFY(*found_item, find_item, "H5SL_greater");
find_item = 5;
found_item = H5SL_greater(slist, &find_item);
VERIFY(*found_item, find_item, "H5SL_greater");
/* Find item greater than a missing key, in various positions */
find_item = 19;
found_item = H5SL_greater(slist,&find_item);
VERIFY(*found_item, 20, "H5SL_greater");
find_item = 89;
found_item = H5SL_greater(slist, &find_item);
VERIFY(*found_item, 90, "H5SL_greater");
find_item = 100;
found_item = H5SL_greater(slist, &find_item);
VERIFY(found_item, NULL, "H5SL_greater");
find_item = 6;
found_item = H5SL_greater(slist, &find_item);
VERIFY(*found_item, 10, "H5SL_greater");
find_item = 4;
found_item = H5SL_greater(slist, &find_item);
VERIFY(*found_item, 5, "H5SL_greater");
/* Close the skip list */
ret = H5SL_close(slist);
CHECK(ret, FAIL, "H5SL_close");
} /* end test_skiplist_greater() */
/****************************************************************
**
** test_skiplist_insert(): Test H5SL (skip list) code.
** Tests inserting single object into skip list.
**
****************************************************************/
static void
test_skiplist_insert(void)
{
H5SL_t *slist; /* Skip list created */
int key, /* Key of item to insert */
item; /* Item to insert */
int search_key; /* Key of item to search for in skip list */
int *found_item; /* Item found in skip list */
size_t num; /* Number of elements in skip list */
herr_t ret; /* Generic return value */
/* Output message about test being performed */
MESSAGE(7, ("Testing Insertion Into Skip List\n"));
/* Create a skip list */
slist = H5SL_create(H5SL_TYPE_INT);
CHECK(slist, NULL, "H5SL_create");
/* Check that the skip list has no elements */
num=H5SL_count(slist);
VERIFY(num, 0, "H5SL_count");
/* Try searching for item in empty skip list */
key=37;
found_item=H5SL_search(slist,&key);
VERIFY(found_item, NULL, "H5SL_search");
/* Insert an object into the skip list */
key=2; item=10;
ret=H5SL_insert(slist,&item,&key);
CHECK(ret, FAIL, "H5SL_insert");
/* Check that the skip list has one element */
num=H5SL_count(slist);
VERIFY(num, 1, "H5SL_count");
/* Search for the item just inserted */
found_item=H5SL_search(slist,&key);
CHECK(found_item, NULL, "H5SL_search");
VERIFY(*found_item,item,"H5SL_search");
/* Search for an item not in list */
search_key=37;
found_item=H5SL_search(slist,&search_key);
VERIFY(found_item, NULL, "H5SL_search");
/* Attempt to insert duplicate key (should fail) */
search_key=2;
ret=H5SL_insert(slist,&search_key,&search_key);
VERIFY(ret, FAIL, "H5SL_insert");
/* Close the skip list */
ret=H5SL_close(slist);
CHECK(ret, FAIL, "H5SL_close");
} /* end test_skiplist_insert() */
/****************************************************************
**
** test_skiplist_find(): Test H5SL (skip list) code.
** Tests 'find' operation in skip lists.
**
****************************************************************/
static void
test_skiplist_find(void)
{
H5SL_t *slist; /* Skip list created */
H5SL_node_t *node; /* Skip list node */
size_t u; /* Local index variable */
unsigned data[10]={ 10, 20, 15, 5, 50, 30, 31, 32, 80, 90};
unsigned sorted_data[10]={ 5, 10, 15, 20, 30, 31, 32, 50, 80, 90};
unsigned *found_item; /* Item found in skip list */
unsigned find_item; /* Item to find in skip list */
herr_t ret; /* Generic return value */
/* Output message about test being performed */
MESSAGE(7, ("Testing Skip List 'Find' Operation\n"));
/* Create a skip list */
slist = H5SL_create(H5SL_TYPE_UNSIGNED);
CHECK(slist, NULL, "H5SL_create");
/* Insert objects into the skip list */
for(u=0; u<10; u++) {
ret=H5SL_insert(slist,&data[u],&data[u]);
CHECK(ret, FAIL, "H5SL_insert");
} /* end for */
/* Find the element with key==30 in the skip list */
find_item=30;
node=H5SL_find(slist,&find_item);
CHECK(node, NULL, "H5SL_find");
/* Iterate over the rest of the nodes in the skip list */
u=4;
while(node!=NULL) {
found_item=H5SL_item(node);
VERIFY(*found_item,sorted_data[u],"H5SL_next");
u++;
node=H5SL_next(node);
} /* end while */
/* Check for trying to locate non-existent item */
find_item=81;
node=H5SL_find(slist,&find_item);
VERIFY(node, NULL, "H5SL_find");
/* Close the skip list */
ret=H5SL_close(slist);
CHECK(ret, FAIL, "H5SL_close");
} /* end test_skiplist_find() */
/****************************************************************
**
** test_skiplist_unsigned(): Test H5SL (skip list) code.
** Tests using unsigned for keys in skip lists.
**
****************************************************************/
static void
test_skiplist_unsigned(void)
{
H5SL_t *slist; /* Skip list created */
H5SL_node_t *node; /* Skip list node */
size_t num; /* Number of elements in skip list */
size_t u; /* Local index variable */
unsigned data[10]={ 10, 20, 15, 5, 50, 30, 31, 32, 80, 90};
unsigned sorted_data[10]={ 5, 10, 15, 20, 30, 31, 32, 50, 80, 90};
unsigned *found_item; /* Item found in skip list */
herr_t ret; /* Generic return value */
/* Output message about test being performed */
MESSAGE(7, ("Testing Skip List With unsigned Keys\n"));
/* Create a skip list */
slist = H5SL_create(H5SL_TYPE_UNSIGNED);
CHECK(slist, NULL, "H5SL_create");
/* Check that the skip list has no elements */
num=H5SL_count(slist);
VERIFY(num, 0, "H5SL_count");
/* Insert objects into the skip list */
for(u=0; u<10; u++) {
ret=H5SL_insert(slist,&data[u],&data[u]);
CHECK(ret, FAIL, "H5SL_insert");
} /* end for */
/* Check that the skip list has correct # of elements */
num=H5SL_count(slist);
VERIFY(num, 10, "H5SL_count");
/* Iterate over all the nodes in the skip list */
node=H5SL_first(slist);
u=0;
while(node!=NULL) {
found_item=H5SL_item(node);
VERIFY(*found_item,sorted_data[u],"H5SL_next");
u++;
node=H5SL_next(node);
} /* end while */
/* Close the skip list */
ret=H5SL_close(slist);
CHECK(ret, FAIL, "H5SL_close");
} /* end test_skiplist_unsigned() */
/*-------------------------------------------------------------------------
* Function: init_ref_path_table
*
* Purpose: Initalize the reference path table
*
* Return: Non-negative on success, negative on failure
*
* Programmer: Quincey Koziol
*
*-------------------------------------------------------------------------
*/
static int
init_ref_path_table(void)
{
/* Sanity check */
HDassert(thefile > 0);
/* Create skip list to store reference path information */
if((ref_path_table = H5SL_create(H5SL_TYPE_HADDR, NULL))==NULL)
return (-1);
/* Iterate over objects in this file */
if(h5trav_visit(thefile, "/", TRUE, TRUE, init_ref_path_cb, NULL, NULL) < 0) {
error_msg("unable to construct reference path table\n");
h5tools_setstatus(EXIT_FAILURE);
} /* end if */
return(0);
}
/****************************************************************
**
** test_skiplist_create(): Test basic H5SL (skiplist) code.
** Tests creating and closing skip lists.
**
****************************************************************/
static void
test_skiplist_create(void)
{
H5SL_t *slist; /* Skip list created */
herr_t ret; /* Generic return value */
/* Output message about test being performed */
MESSAGE(6, ("Testing Creating & Closing Skip Lists\n"));
/* Try creating a skip list */
slist = H5SL_create(H5SL_TYPE_INT);
CHECK(slist, NULL, "H5SL_create");
/* Try closing the skip list */
ret=H5SL_close(slist);
CHECK(ret, FAIL, "H5SL_close");
} /* end test_skiplist_create() */
/****************************************************************
**
** test_skiplist_iterate(): Test H5SL (skip list) code.
** Tests iterating over nodes in skip list with callbacks.
**
****************************************************************/
static void
test_skiplist_iterate(void)
{
H5SL_t *slist; /* Skip list created */
size_t num; /* Number of elements in skip list */
size_t u; /* Local index variable */
herr_t ret; /* Generic return value */
/* Output message about test being performed */
MESSAGE(7, ("Testing Iterating Over Skip List\n"));
/* Create a skip list */
slist = H5SL_create(H5SL_TYPE_INT);
CHECK(slist, NULL, "H5SL_create");
/* Check that the skip list has no elements */
num=H5SL_count(slist);
VERIFY(num, 0, "H5SL_count");
/* Insert many objects into the skip list */
for(u=0; u<NUM_ELEMS; u++) {
ret=H5SL_insert(slist,&rand_num[u],&rand_num[u]);
CHECK(ret, FAIL, "H5SL_insert");
} /* end for */
/* Check that the skip list has correct # of elements */
num=H5SL_count(slist);
VERIFY(num, NUM_ELEMS, "H5SL_count");
/* Iterate over all the nodes in the skip list */
u=0;
ret=H5SL_iterate(slist,test_skiplist_iter,&u);
CHECK(ret, FAIL, "H5SL_iterate");
/* Close the skip list */
ret=H5SL_close(slist);
CHECK(ret, FAIL, "H5SL_close");
} /* end test_skiplist_iterate() */
/****************************************************************
**
** test_skiplist_remote_first_many(): Test H5SL (skip list) code.
** Tests 'remove first' operation in large skip lists.
**
****************************************************************/
static void
test_skiplist_remove_first_many(void)
{
H5SL_t *slist; /* Skip list created */
size_t u; /* Local index variable */
int *found_item; /* Item found in skip list */
int prev_item = INT_MIN; /* Previously found item in skip list */
herr_t ret; /* Generic return value */
/* Output message about test being performed */
MESSAGE(7, ("Testing Skip List 'Remove First' Operation\n"));
/* Create a skip list */
slist = H5SL_create(H5SL_TYPE_INT);
CHECK(slist, NULL, "H5SL_create");
/* Insert objects into the skip list */
for(u = 0; u < NUM_ELEMS; u++) {
ret = H5SL_insert(slist, &rand_num[u], &rand_num[u]);
CHECK(ret, FAIL, "H5SL_insert");
} /* end for */
/* Remove objects from the skip list */
for(u = 0; u < NUM_ELEMS; u++) {
found_item = (int *)H5SL_remove_first(slist);
VERIFY(*found_item > prev_item, TRUE, "H5SL_remove_first");
prev_item = *found_item;
} /* end for */
/* Check for removing object from empty list */
found_item = (int *)H5SL_remove_first(slist);
VERIFY(found_item, NULL, "H5SL_remove_first");
/* Close the skip list */
ret = H5SL_close(slist);
CHECK(ret, FAIL, "H5SL_close");
} /* end test_skiplist_remove_first() */
/****************************************************************
**
** test_skiplist_remote_first(): Test H5SL (skip list) code.
** Tests 'remove first' operation in skip lists.
**
****************************************************************/
static void
test_skiplist_remove_first(void)
{
H5SL_t *slist; /* Skip list created */
size_t u; /* Local index variable */
unsigned data[10]={ 10, 20, 15, 5, 50, 30, 31, 32, 80, 90};
unsigned sorted_data[10]={ 5, 10, 15, 20, 30, 31, 32, 50, 80, 90};
unsigned *found_item; /* Item found in skip list */
herr_t ret; /* Generic return value */
/* Output message about test being performed */
MESSAGE(7, ("Testing Skip List 'Remove First' Operation\n"));
/* Create a skip list */
slist = H5SL_create(H5SL_TYPE_UNSIGNED);
CHECK(slist, NULL, "H5SL_create");
/* Insert objects into the skip list */
for(u = 0; u < 10; u++) {
ret = H5SL_insert(slist, &data[u], &data[u]);
CHECK(ret, FAIL, "H5SL_insert");
} /* end for */
/* Remove objects from the skip list */
for(u = 0; u < 10; u++) {
found_item = H5SL_remove_first(slist);
VERIFY(*found_item, sorted_data[u], "H5SL_remove_first");
} /* end for */
/* Check for removing object from empty list */
found_item = H5SL_remove_first(slist);
VERIFY(found_item, NULL, "H5SL_remove_first");
/* Close the skip list */
ret = H5SL_close(slist);
CHECK(ret, FAIL, "H5SL_close");
} /* end test_skiplist_remove_first() */
/****************************************************************
**
** test_skiplist_string(): Test H5SL (skip list) code.
** Tests using strings for keys in skip lists.
**
****************************************************************/
static void
test_skiplist_string(void)
{
H5SL_t *slist; /* Skip list created */
H5SL_node_t *node; /* Skip list node */
size_t num; /* Number of elements in skip list */
size_t u; /* Local index variable */
typedef struct string_node {
int i;
const char *s;
} string_node;
string_node data[10]={
{10,"10"},
{20,"20"},
{15,"15"},
{ 5,"05"},
{50,"50"},
{30,"30"},
{31,"31"},
{32,"32"},
{80,"80"},
{90,"90"}};
string_node hashed_data[10]={
{ 5,"05"},
{10,"10"},
{15,"15"},
{20,"20"},
{30,"30"},
{31,"31"},
{32,"32"},
{50,"50"},
{80,"80"},
{90,"90"}
};
string_node *found_item; /* Item found in skip list */
herr_t ret; /* Generic return value */
/* Output message about test being performed */
MESSAGE(7, ("Testing Skip List With String Keys\n"));
/* Create a skip list */
slist = H5SL_create(H5SL_TYPE_STR);
CHECK(slist, NULL, "H5SL_create");
/* Check that the skip list has no elements */
num=H5SL_count(slist);
VERIFY(num, 0, "H5SL_count");
/* Insert objects into the skip list */
for(u=0; u<10; u++) {
ret=H5SL_insert(slist,&data[u],data[u].s);
CHECK(ret, FAIL, "H5SL_insert");
} /* end for */
/* Check that the skip list has correct # of elements */
num=H5SL_count(slist);
VERIFY(num, 10, "H5SL_count");
/* Iterate over all the nodes in the skip list */
node=H5SL_first(slist);
u=0;
while(node!=NULL) {
found_item=H5SL_item(node);
VERIFY(found_item->i, hashed_data[u].i, "H5SL_next");
u++;
node=H5SL_next(node);
} /* end while */
/* Close the skip list */
ret=H5SL_close(slist);
CHECK(ret, FAIL, "H5SL_close");
} /* end test_skiplist_string() */
/****************************************************************
**
** test_skiplist_remove_many(): Test H5SL (skip list) code.
** Tests removing many objects from skip list.
**
****************************************************************/
static void
test_skiplist_remove_many(void)
{
H5SL_t *slist; /* Skip list created */
size_t num; /* Number of elements in skip list */
size_t u; /* Local index variable */
int *found_item; /* Item found in skip list */
herr_t ret; /* Generic return value */
/* Output message about test being performed */
MESSAGE(7, ("Testing Removal of Many Items From Skip List\n"));
/* Create a skip list */
slist = H5SL_create(H5SL_TYPE_INT);
CHECK(slist, NULL, "H5SL_create");
/* Check that the skip list has no elements */
num=H5SL_count(slist);
VERIFY(num, 0, "H5SL_count");
/* Insert many objects into the skip list */
for(u=0; u<NUM_ELEMS; u++) {
ret=H5SL_insert(slist,&rand_num[u],&rand_num[u]);
CHECK(ret, FAIL, "H5SL_insert");
} /* end for */
/* Check that the skip list has correct # of elements */
num=H5SL_count(slist);
VERIFY(num, NUM_ELEMS, "H5SL_count");
/* Remove all objects from the skip list (in random order) */
for(u=0; u<NUM_ELEMS; u++) {
found_item=H5SL_remove(slist,&rand_num[u]);
CHECK(found_item, NULL, "H5SL_remove");
VERIFY(*found_item,rand_num[u],"H5SL_remove");
} /* end for */
/* Check that the skip list has correct # of elements */
num=H5SL_count(slist);
VERIFY(num, 0, "H5SL_count");
/* Insert & remove again (in sorted order), to check that completely empty skip lists can be added again */
/* Insert many objects into the skip list */
for(u=0; u<NUM_ELEMS; u++) {
ret=H5SL_insert(slist,&rand_num[u],&rand_num[u]);
CHECK(ret, FAIL, "H5SL_insert");
} /* end for */
/* Check that the skip list has correct # of elements */
num=H5SL_count(slist);
VERIFY(num, NUM_ELEMS, "H5SL_count");
/* Remove all objects from the skip list */
for(u=0; u<NUM_ELEMS; u++) {
found_item=H5SL_remove(slist,&sort_rand_num[u]);
CHECK(found_item, NULL, "H5SL_remove");
VERIFY(*found_item,sort_rand_num[u],"H5SL_remove");
} /* end for */
/* Check that the skip list has correct # of elements */
num=H5SL_count(slist);
VERIFY(num, 0, "H5SL_count");
/* Insert & remove again (in reverse sorted order), to check that completely empty skip lists can be added again */
/* Insert many objects into the skip list */
for(u=0; u<NUM_ELEMS; u++) {
ret=H5SL_insert(slist,&rand_num[u],&rand_num[u]);
CHECK(ret, FAIL, "H5SL_insert");
} /* end for */
/* Check that the skip list has correct # of elements */
num=H5SL_count(slist);
VERIFY(num, NUM_ELEMS, "H5SL_count");
/* Remove all objects from the skip list */
for(u=0; u<NUM_ELEMS; u++) {
found_item=H5SL_remove(slist,&rev_sort_rand_num[u]);
CHECK(found_item, NULL, "H5SL_remove");
VERIFY(*found_item,rev_sort_rand_num[u],"H5SL_remove");
} /* end for */
/* Check that the skip list has correct # of elements */
num=H5SL_count(slist);
VERIFY(num, 0, "H5SL_count");
/* Close the skip list */
ret=H5SL_close(slist);
CHECK(ret, FAIL, "H5SL_close");
} /* end test_skiplist_remove_many() */
/****************************************************************
**
** test_skiplist_remove(): Test H5SL (skip list) code.
** Tests basic object removal from skip list.
**
****************************************************************/
static void
test_skiplist_remove(void)
{
H5SL_t *slist; /* Skip list created */
int key1, /* Key of 1st item to insert */
key2, /* Key of 2nd item to insert */
key3; /* Key of 3rd item to insert */
int search_key; /* Key of item to search for in skip list */
int *found_item; /* Item found in skip list */
size_t num; /* Number of elements in skip list */
herr_t ret; /* Generic return value */
/* Output message about test being performed */
MESSAGE(7, ("Testing Removal From Skip List\n"));
/* Create a skip list */
slist = H5SL_create(H5SL_TYPE_INT);
CHECK(slist, NULL, "H5SL_create");
/* Check that the skip list has no elements */
num=H5SL_count(slist);
VERIFY(num, 0, "H5SL_count");
/* Try removing an item in empty skip list */
search_key=37;
found_item=H5SL_remove(slist,&search_key);
VERIFY(found_item, NULL, "H5SL_remove");
/* Insert three objects into the skip list */
key1=15;
ret=H5SL_insert(slist,&key1,&key1);
CHECK(ret, FAIL, "H5SL_insert");
key2=10;
ret=H5SL_insert(slist,&key2,&key2);
CHECK(ret, FAIL, "H5SL_insert");
key3=20;
ret=H5SL_insert(slist,&key3,&key3);
CHECK(ret, FAIL, "H5SL_insert");
/* Check that the skip list has three elements */
num=H5SL_count(slist);
VERIFY(num, 3, "H5SL_count");
/* Try removing items from skip list */
search_key=key1;
found_item=H5SL_remove(slist,&search_key);
CHECK(found_item, NULL, "H5SL_remove");
VERIFY(found_item, &key1, "H5SL_remove");
search_key=key2;
found_item=H5SL_remove(slist,&search_key);
CHECK(found_item, NULL, "H5SL_remove");
VERIFY(found_item, &key2, "H5SL_remove");
search_key=key3;
found_item=H5SL_remove(slist,&search_key);
CHECK(found_item, NULL, "H5SL_remove");
VERIFY(found_item, &key3, "H5SL_remove");
/* Check that the skip list has no elements */
num=H5SL_count(slist);
VERIFY(num, 0, "H5SL_count");
/* Try removing items from empty skip list (after its been worked on) */
search_key=key1;
found_item=H5SL_remove(slist,&search_key);
VERIFY(found_item, NULL, "H5SL_remove");
/* Close the skip list */
ret=H5SL_close(slist);
CHECK(ret, FAIL, "H5SL_close");
} /* end test_skiplist_remove() */
/****************************************************************
**
** test_skiplist_insert_many(): Test H5SL (skip list) code.
** Tests inserting many objects into skip list.
**
****************************************************************/
static void
test_skiplist_insert_many(void)
{
H5SL_t *slist; /* Skip list created */
size_t num; /* Number of elements in skip list */
size_t u; /* Local index variable */
int *found_item; /* Item found in skip list */
herr_t ret; /* Generic return value */
/* Output message about test being performed */
MESSAGE(7, ("Testing Insertion of Many Items Into Skip List\n"));
/* Create a skip list */
slist = H5SL_create(H5SL_TYPE_INT);
CHECK(slist, NULL, "H5SL_create");
/* Check that the skip list has no elements */
num=H5SL_count(slist);
VERIFY(num, 0, "H5SL_count");
/* Insert many objects into the skip list */
for(u=0; u<NUM_ELEMS; u++) {
ret=H5SL_insert(slist,&rand_num[u],&rand_num[u]);
CHECK(ret, FAIL, "H5SL_insert");
} /* end for */
/* Check that the skip list has correct # of elements */
num=H5SL_count(slist);
VERIFY(num, NUM_ELEMS, "H5SL_count");
/* Search for all objects in the skip list */
for(u=0; u<NUM_ELEMS; u++) {
found_item=H5SL_search(slist,&rand_num[u]);
CHECK(found_item, NULL, "H5SL_search");
VERIFY(*found_item,rand_num[u],"H5SL_search");
} /* end for */
/* Release all the items from the list */
ret=H5SL_release(slist);
CHECK(ret, FAIL, "H5SL_release");
/* Check that the skip list has no elements */
num=H5SL_count(slist);
VERIFY(num, 0, "H5SL_count");
/* Insert many objects into the skip list */
for(u=0; u<NUM_ELEMS; u++) {
ret=H5SL_insert(slist,&rand_num[u],&rand_num[u]);
CHECK(ret, FAIL, "H5SL_insert");
} /* end for */
/* Check that the skip list has correct # of elements */
num=H5SL_count(slist);
VERIFY(num, NUM_ELEMS, "H5SL_count");
/* Release all the items from the list */
ret=H5SL_release(slist);
CHECK(ret, FAIL, "H5SL_release");
/* Close the skip list */
ret=H5SL_close(slist);
CHECK(ret, FAIL, "H5SL_close");
} /* end test_skiplist_insert_many() */