/**************************************************************** ** ** test_skiplist_free(): Test H5SL (skip list) code. ** Tests 'free' operation in skip lists. ** ****************************************************************/ static void test_skiplist_free(void) { H5SL_t *slist; /* Skip list created */ size_t num; /* Number of elements in skip list */ 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 'Free' 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_free(slist,test_skiplist_destroy_free,&free_count); CHECK(ret, FAIL, "H5SL_destroy"); VERIFY(free_count, NUM_ELEMS, "H5SL_free"); /* Check that the skip list has correct # of elements */ num=H5SL_count(slist); VERIFY(num, 0, "H5SL_count"); /* Insert objects into the skip list again */ 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"); /* Close the skip list */ ret=H5SL_close(slist); CHECK(ret, FAIL, "H5SL_close"); } /* end test_skiplist_free() */
/**************************************************************** ** ** 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_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: ref_path_table_put * * Purpose: Enter the 'obj' with 'path' in the table (assumes its not * already there) * * Create an object reference, pte, and store them * in the table. * * NOTE: Takes ownership of the path name string passed in! * * Return: Non-negative on success, negative on failure * * Programmer: REMcG * * Modifications: * *------------------------------------------------------------------------- */ static int ref_path_table_put(const char *path, haddr_t objno) { ref_path_node_t *new_node; HDassert(ref_path_table); HDassert(path); if((new_node = HDmalloc(sizeof(ref_path_node_t))) == NULL) return(-1); new_node->objno = objno; new_node->path = HDstrdup(path); return(H5SL_insert(ref_path_table, new_node, &(new_node->objno))); }
/**************************************************************** ** ** 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() */