mirror of
https://github.com/HDFGroup/hdf5.git
synced 2024-12-21 07:51:46 +08:00
b0bd984ed6
* Removes the "try free" behavior from the skip lists This was only used in the ID code when iterating and a callback could delete IDs. It is not used anywhere else in the library and is now pointless overhead. Also quiets the const warnings when returning stored elements. They only need to be const with respect to the skip list code, which should never modify them. The library can do whatever it wants with the elements it stored. * Formatted source
1603 lines
54 KiB
C
1603 lines
54 KiB
C
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
|
|
* Copyright by The HDF Group. *
|
|
* Copyright by the Board of Trustees of the University of Illinois. *
|
|
* All rights reserved. *
|
|
* *
|
|
* This file is part of HDF5. The full HDF5 copyright notice, including *
|
|
* terms governing use, modification, and redistribution, is contained in *
|
|
* the COPYING file, which can be found at the root of the source code *
|
|
* distribution tree, or in https://www.hdfgroup.org/licenses. *
|
|
* If you do not have access to either file, you may request a copy from *
|
|
* help@hdfgroup.org. *
|
|
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
|
|
|
|
/*
|
|
Test HDF Skip List routines.
|
|
|
|
REMARKS
|
|
|
|
DESIGN
|
|
|
|
BUGS/LIMITATIONS
|
|
|
|
EXPORTED ROUTINES
|
|
|
|
AUTHOR
|
|
Quincey Koziol
|
|
|
|
MODIFICATION HISTORY
|
|
11/15/04 - Started coding
|
|
*/
|
|
|
|
#include "testhdf5.h"
|
|
#include "H5SLprivate.h"
|
|
|
|
/* The number of elements in testing arrays */
|
|
#define NUM_ELEMS 1000
|
|
|
|
/* Random numbers */
|
|
static int *rand_num;
|
|
static int *sort_rand_num;
|
|
static int *rev_sort_rand_num;
|
|
|
|
static int
|
|
tst_sort(const void *i1, const void *i2)
|
|
{
|
|
return (*(const int *)i1 - *(const int *)i2);
|
|
}
|
|
|
|
static int
|
|
tst_rev_sort(const void *i1, const void *i2)
|
|
{
|
|
return (*(const int *)i2 - *(const int *)i1);
|
|
}
|
|
|
|
/****************************************************************
|
|
**
|
|
** test_skiplist_init(): Test H5SL (skiplist) code.
|
|
** Initialize data for skip list testing
|
|
**
|
|
****************************************************************/
|
|
static void
|
|
test_skiplist_init(void)
|
|
{
|
|
time_t curr_time; /* Current time, for seeding random number generator */
|
|
int new_val; /* New value to insert */
|
|
unsigned found; /* Flag to indicate value was inserted already */
|
|
size_t u, v; /* Local index variables */
|
|
|
|
/* Allocate arrays */
|
|
rand_num = (int *)HDmalloc(sizeof(int) * NUM_ELEMS);
|
|
CHECK_PTR(rand_num, "HDmalloc");
|
|
sort_rand_num = (int *)HDmalloc(sizeof(int) * NUM_ELEMS);
|
|
CHECK_PTR(sort_rand_num, "HDmalloc");
|
|
rev_sort_rand_num = (int *)HDmalloc(sizeof(int) * NUM_ELEMS);
|
|
CHECK_PTR(rev_sort_rand_num, "HDmalloc");
|
|
|
|
/* Initialize random number seed */
|
|
curr_time = HDtime(NULL);
|
|
HDsrandom((unsigned)curr_time);
|
|
|
|
/* Create randomized set of numbers */
|
|
for (u = 0; u < NUM_ELEMS; u++) {
|
|
do {
|
|
/* Reset flag */
|
|
found = 0;
|
|
|
|
/* Generate random numbers from -5000 to 5000 */
|
|
new_val = (int)(HDrandom() % 10001) - 5001;
|
|
|
|
/* Check if the value is already in the array */
|
|
for (v = 0; v < u; v++)
|
|
if (rand_num[v] == new_val)
|
|
found = 1;
|
|
} while (found);
|
|
|
|
/* Set unique value in array */
|
|
rand_num[u] = new_val;
|
|
} /* end for */
|
|
|
|
/* Copy random values to sorted array */
|
|
HDmemcpy(sort_rand_num, rand_num, sizeof(int) * NUM_ELEMS);
|
|
|
|
/* Sort random numbers */
|
|
HDqsort(sort_rand_num, (size_t)NUM_ELEMS, sizeof(int), tst_sort);
|
|
|
|
/* Copy random values to reverse sorted array */
|
|
HDmemcpy(rev_sort_rand_num, rand_num, sizeof(int) * NUM_ELEMS);
|
|
|
|
/* Sort random numbers */
|
|
HDqsort(rev_sort_rand_num, (size_t)NUM_ELEMS, sizeof(int), tst_rev_sort);
|
|
} /* end test_skiplist_init() */
|
|
|
|
/****************************************************************
|
|
**
|
|
** 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, NULL);
|
|
CHECK_PTR(slist, "H5SL_create");
|
|
|
|
/* Try closing the skip list */
|
|
ret = H5SL_close(slist);
|
|
CHECK(ret, FAIL, "H5SL_close");
|
|
|
|
} /* end test_skiplist_create() */
|
|
|
|
/****************************************************************
|
|
**
|
|
** 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, NULL);
|
|
CHECK_PTR(slist, "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 = (int *)H5SL_search(slist, &key);
|
|
CHECK_PTR_NULL(found_item, "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 = (int *)H5SL_search(slist, &key);
|
|
CHECK_PTR(found_item, "H5SL_search");
|
|
VERIFY(*found_item, item, "H5SL_search");
|
|
|
|
/* Search for an item not in list */
|
|
search_key = 37;
|
|
found_item = (int *)H5SL_search(slist, &search_key);
|
|
CHECK_PTR_NULL(found_item, "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_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, NULL);
|
|
CHECK_PTR(slist, "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 = (int *)H5SL_search(slist, &rand_num[u]);
|
|
CHECK_PTR(found_item, "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() */
|
|
|
|
/****************************************************************
|
|
**
|
|
** 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, NULL);
|
|
CHECK_PTR(slist, "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 = (int *)H5SL_remove(slist, &search_key);
|
|
CHECK_PTR_NULL(found_item, "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 = (int *)H5SL_remove(slist, &search_key);
|
|
CHECK_PTR(found_item, "H5SL_remove");
|
|
CHECK_PTR_EQ(found_item, &key1, "H5SL_remove");
|
|
|
|
search_key = key2;
|
|
found_item = (int *)H5SL_remove(slist, &search_key);
|
|
CHECK_PTR(found_item, "H5SL_remove");
|
|
CHECK_PTR_EQ(found_item, &key2, "H5SL_remove");
|
|
|
|
search_key = key3;
|
|
found_item = (int *)H5SL_remove(slist, &search_key);
|
|
CHECK_PTR(found_item, "H5SL_remove");
|
|
CHECK_PTR_EQ(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 = (int *)H5SL_remove(slist, &search_key);
|
|
CHECK_PTR_NULL(found_item, "H5SL_remove");
|
|
|
|
/* Close the skip list */
|
|
ret = H5SL_close(slist);
|
|
CHECK(ret, FAIL, "H5SL_close");
|
|
|
|
} /* end test_skiplist_remove() */
|
|
|
|
/****************************************************************
|
|
**
|
|
** 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, NULL);
|
|
CHECK_PTR(slist, "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 = (int *)H5SL_remove(slist, &rand_num[u]);
|
|
CHECK_PTR(found_item, "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 = (int *)H5SL_remove(slist, &sort_rand_num[u]);
|
|
CHECK_PTR(found_item, "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 = (int *)H5SL_remove(slist, &rev_sort_rand_num[u]);
|
|
CHECK_PTR(found_item, "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_firstnext(): Test H5SL (skip list) code.
|
|
** Tests iterating over nodes in skip list with first/next calls.
|
|
**
|
|
****************************************************************/
|
|
static void
|
|
test_skiplist_firstnext(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 First/Next\n"));
|
|
|
|
/* Create a skip list */
|
|
slist = H5SL_create(H5SL_TYPE_INT, NULL);
|
|
CHECK_PTR(slist, "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_first(slist);
|
|
CHECK_PTR_NULL(node, "H5SL_first");
|
|
|
|
/* 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_first(slist);
|
|
CHECK_PTR(node, "H5SL_first");
|
|
u = 0;
|
|
while (node != NULL) {
|
|
found_item = (int *)H5SL_item(node);
|
|
VERIFY(*found_item, sort_rand_num[u], "H5SL_next");
|
|
u++;
|
|
node = H5SL_next(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_first(slist);
|
|
CHECK_PTR_NULL(node, "H5SL_first");
|
|
|
|
/* Close the skip list */
|
|
ret = H5SL_close(slist);
|
|
CHECK(ret, FAIL, "H5SL_close");
|
|
|
|
} /* end test_skiplist_firstnext() */
|
|
|
|
/****************************************************************
|
|
**
|
|
** 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, NULL);
|
|
CHECK_PTR(slist, "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 = (string_node *)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() */
|
|
|
|
static herr_t
|
|
test_skiplist_iter(void *item, void H5_ATTR_UNUSED *key, void *op_data)
|
|
{
|
|
size_t *up = (size_t *)op_data;
|
|
|
|
VERIFY(*(int *)item, sort_rand_num[*up], "H5SL_iterate");
|
|
(*up)++;
|
|
|
|
return (0);
|
|
}
|
|
|
|
/****************************************************************
|
|
**
|
|
** 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, NULL);
|
|
CHECK_PTR(slist, "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_hsize(): Test H5SL (skip list) code.
|
|
** Tests using hsize_t for keys in skip lists.
|
|
**
|
|
****************************************************************/
|
|
static void
|
|
test_skiplist_hsize(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 */
|
|
hsize_t data[10] = {10, 20, 15, 5, 50, 30, 31, 32, 80, 90};
|
|
hsize_t sorted_data[10] = {5, 10, 15, 20, 30, 31, 32, 50, 80, 90};
|
|
hsize_t * 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 hsize_t Keys\n"));
|
|
|
|
/* Create a skip list */
|
|
slist = H5SL_create(H5SL_TYPE_HSIZE, NULL);
|
|
CHECK_PTR(slist, "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 = (hsize_t *)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_hsize() */
|
|
|
|
/****************************************************************
|
|
**
|
|
** 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, NULL);
|
|
CHECK_PTR(slist, "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 = (unsigned *)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() */
|
|
|
|
/****************************************************************
|
|
**
|
|
** test_skiplist_obj(): Test H5SL (skip list) code.
|
|
** Tests using H5_obj_t's for keys in skip lists.
|
|
**
|
|
****************************************************************/
|
|
static void
|
|
test_skiplist_obj(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 */
|
|
H5_obj_t data[10] = {{10, 12}, {20, 12}, {10, 32}, {10, 11}, {50, 1},
|
|
{8, 12}, {31, 12}, {20, 11}, {31, 11}, {8, 32}};
|
|
H5_obj_t sorted_data[10] = {{8, 12}, {8, 32}, {10, 11}, {10, 12}, {10, 32},
|
|
{20, 11}, {20, 12}, {31, 11}, {31, 12}, {50, 1}};
|
|
H5_obj_t * 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 H5_obj_t Keys\n"));
|
|
|
|
/* Create a skip list */
|
|
slist = H5SL_create(H5SL_TYPE_OBJ, NULL);
|
|
CHECK_PTR(slist, "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 = (H5_obj_t *)H5SL_item(node);
|
|
VERIFY(found_item->fileno, sorted_data[u].fileno, "H5SL_next");
|
|
VERIFY(found_item->addr, sorted_data[u].addr, "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_obj() */
|
|
|
|
/****************************************************************
|
|
**
|
|
** test_skiplist_generic(): Test H5SL (skip list) code.
|
|
** Tests using generic keys in skip lists. Define
|
|
** structure for keys, and define comparison using
|
|
** key.a-key.b.
|
|
**
|
|
****************************************************************/
|
|
typedef struct generic_t {
|
|
unsigned a;
|
|
unsigned b;
|
|
} generic_t;
|
|
|
|
static int
|
|
test_skiplist_generic_cmp(const void *_key1, const void *_key2)
|
|
{
|
|
const generic_t *key1 = (const generic_t *)_key1;
|
|
const generic_t *key2 = (const generic_t *)_key2;
|
|
long long result =
|
|
(long long)(key1->a) - (long long)(key1->b) - (long long)(key2->a) + (long long)(key2->b);
|
|
|
|
if (result < 0)
|
|
return -1;
|
|
else if (result > 0)
|
|
return 1;
|
|
else
|
|
return 0;
|
|
} /* end test_skiplist_generic_cmp */
|
|
|
|
static void
|
|
test_skiplist_generic(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 */
|
|
generic_t data[10] = {{10, 1}, {20, 13}, {15, 32}, {5, 2}, {50, 37},
|
|
{30, 100}, {31, 38}, {32, 34}, {80, 32}, {90, 0}};
|
|
generic_t sorted_data[10] = {{30, 100}, {15, 32}, {31, 38}, {32, 34}, {5, 2},
|
|
{20, 13}, {10, 1}, {50, 37}, {80, 32}, {90, 0}};
|
|
generic_t * 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 generic Keys\n"));
|
|
|
|
/* Create a skip list */
|
|
slist = H5SL_create(H5SL_TYPE_GENERIC, test_skiplist_generic_cmp);
|
|
CHECK_PTR(slist, "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 = (generic_t *)H5SL_item(node);
|
|
VERIFY(found_item->a, sorted_data[u].a, "H5SL_next");
|
|
VERIFY(found_item->b, sorted_data[u].b, "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_generic() */
|
|
|
|
/****************************************************************
|
|
**
|
|
** 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, NULL);
|
|
CHECK_PTR(slist, "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);
|
|
CHECK_PTR_NULL(node, "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_PTR(node, "H5SL_last");
|
|
u = NUM_ELEMS - 1;
|
|
while (node != NULL) {
|
|
found_item = (int *)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);
|
|
CHECK_PTR_NULL(node, "H5SL_last");
|
|
|
|
/* Close the skip list */
|
|
ret = H5SL_close(slist);
|
|
CHECK(ret, FAIL, "H5SL_close");
|
|
|
|
} /* end test_skiplist_lastprev() */
|
|
|
|
/****************************************************************
|
|
**
|
|
** 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, NULL);
|
|
CHECK_PTR(slist, "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_PTR(node, "H5SL_find");
|
|
|
|
/* Iterate over the rest of the nodes in the skip list */
|
|
u = 4;
|
|
while (node != NULL) {
|
|
found_item = (unsigned *)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);
|
|
CHECK_PTR_NULL(node, "H5SL_find");
|
|
|
|
/* Close the skip list */
|
|
ret = H5SL_close(slist);
|
|
CHECK(ret, FAIL, "H5SL_close");
|
|
|
|
} /* end test_skiplist_find() */
|
|
|
|
/****************************************************************
|
|
**
|
|
** test_skiplist_add(): Test H5SL (skip list) code.
|
|
** Tests 'add' operation in skip lists.
|
|
**
|
|
****************************************************************/
|
|
static void
|
|
test_skiplist_add(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 new_item; /* Item to add to skip list */
|
|
herr_t ret; /* Generic return value */
|
|
|
|
/* Output message about test being performed */
|
|
MESSAGE(7, ("Testing Skip List 'Add' Operation\n"));
|
|
|
|
/* Create a skip list */
|
|
slist = H5SL_create(H5SL_TYPE_UNSIGNED, NULL);
|
|
CHECK_PTR(slist, "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 */
|
|
|
|
/* Add the element with key==12 in the skip list */
|
|
new_item = 12;
|
|
node = H5SL_add(slist, &new_item, &new_item);
|
|
CHECK_PTR(node, "H5SL_add");
|
|
|
|
/* Advance to next node in list */
|
|
node = H5SL_next(node);
|
|
CHECK_PTR(node, "H5SL_next");
|
|
|
|
/* Iterate over the rest of the nodes in the skip list */
|
|
u = 2;
|
|
while (node != NULL) {
|
|
found_item = (unsigned *)H5SL_item(node);
|
|
VERIFY(*found_item, sorted_data[u], "H5SL_item");
|
|
u++;
|
|
node = H5SL_next(node);
|
|
} /* end while */
|
|
|
|
/* Close the skip list */
|
|
ret = H5SL_close(slist);
|
|
CHECK(ret, FAIL, "H5SL_close");
|
|
|
|
} /* end test_skiplist_add() */
|
|
|
|
static herr_t
|
|
test_skiplist_destroy_free(void *item, void H5_ATTR_UNUSED *key, void *op_data)
|
|
{
|
|
unsigned *free_count = (unsigned *)op_data;
|
|
|
|
VERIFY(*(int *)item, sort_rand_num[*free_count], "H5SL_destroy");
|
|
(*free_count)++;
|
|
|
|
return (0);
|
|
}
|
|
|
|
/****************************************************************
|
|
**
|
|
** 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, NULL);
|
|
CHECK_PTR(slist, "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_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, NULL);
|
|
CHECK_PTR(slist, "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_less(): Test H5SL (skip list) code.
|
|
** Tests 'less' operation in skip lists.
|
|
**
|
|
****************************************************************/
|
|
static void
|
|
test_skiplist_less(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 'Less' Operation\n"));
|
|
|
|
/* Create a skip list */
|
|
slist = H5SL_create(H5SL_TYPE_UNSIGNED, NULL);
|
|
CHECK_PTR(slist, "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 = (unsigned *)H5SL_less(slist, &find_item);
|
|
VERIFY(*found_item, find_item, "H5SL_less");
|
|
find_item = 90;
|
|
found_item = (unsigned *)H5SL_less(slist, &find_item);
|
|
VERIFY(*found_item, find_item, "H5SL_less");
|
|
find_item = 5;
|
|
found_item = (unsigned *)H5SL_less(slist, &find_item);
|
|
VERIFY(*found_item, find_item, "H5SL_less");
|
|
|
|
/* Find item less than a missing key, in various positions */
|
|
find_item = 19;
|
|
found_item = (unsigned *)H5SL_less(slist, &find_item);
|
|
VERIFY(*found_item, 15, "H5SL_less");
|
|
find_item = 89;
|
|
found_item = (unsigned *)H5SL_less(slist, &find_item);
|
|
VERIFY(*found_item, 80, "H5SL_less");
|
|
find_item = 100;
|
|
found_item = (unsigned *)H5SL_less(slist, &find_item);
|
|
VERIFY(*found_item, 90, "H5SL_less");
|
|
find_item = 9;
|
|
found_item = (unsigned *)H5SL_less(slist, &find_item);
|
|
VERIFY(*found_item, 5, "H5SL_less");
|
|
find_item = 4;
|
|
found_item = (unsigned *)H5SL_less(slist, &find_item);
|
|
CHECK_PTR_NULL(found_item, "H5SL_less");
|
|
|
|
/* Close the skip list */
|
|
ret = H5SL_close(slist);
|
|
CHECK(ret, FAIL, "H5SL_close");
|
|
|
|
} /* end test_skiplist_less() */
|
|
|
|
/****************************************************************
|
|
**
|
|
** 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, NULL);
|
|
CHECK_PTR(slist, "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 = (unsigned *)H5SL_greater(slist, &find_item);
|
|
VERIFY(*found_item, find_item, "H5SL_greater");
|
|
find_item = 90;
|
|
found_item = (unsigned *)H5SL_greater(slist, &find_item);
|
|
VERIFY(*found_item, find_item, "H5SL_greater");
|
|
find_item = 5;
|
|
found_item = (unsigned *)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 = (unsigned *)H5SL_greater(slist, &find_item);
|
|
VERIFY(*found_item, 20, "H5SL_greater");
|
|
find_item = 89;
|
|
found_item = (unsigned *)H5SL_greater(slist, &find_item);
|
|
VERIFY(*found_item, 90, "H5SL_greater");
|
|
find_item = 100;
|
|
found_item = (unsigned *)H5SL_greater(slist, &find_item);
|
|
CHECK_PTR_NULL(found_item, "H5SL_greater");
|
|
find_item = 6;
|
|
found_item = (unsigned *)H5SL_greater(slist, &find_item);
|
|
VERIFY(*found_item, 10, "H5SL_greater");
|
|
find_item = 4;
|
|
found_item = (unsigned *)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_below(): Test H5SL (skip list) code.
|
|
** Tests 'below' operation in skip lists.
|
|
**
|
|
****************************************************************/
|
|
static void
|
|
test_skiplist_below(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 add to skip list */
|
|
herr_t ret; /* Generic return value */
|
|
|
|
/* Output message about test being performed */
|
|
MESSAGE(7, ("Testing Skip List 'Below' Operation\n"));
|
|
|
|
/* Create a skip list */
|
|
slist = H5SL_create(H5SL_TYPE_UNSIGNED, NULL);
|
|
CHECK_PTR(slist, "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;
|
|
node = H5SL_below(slist, &find_item);
|
|
CHECK_PTR(node, "H5SL_below");
|
|
found_item = (unsigned *)H5SL_item(node);
|
|
VERIFY(*found_item, find_item, "H5SL_below");
|
|
find_item = 90;
|
|
node = H5SL_below(slist, &find_item);
|
|
CHECK_PTR(node, "H5SL_below");
|
|
found_item = (unsigned *)H5SL_item(node);
|
|
VERIFY(*found_item, find_item, "H5SL_below");
|
|
find_item = 5;
|
|
node = H5SL_below(slist, &find_item);
|
|
CHECK_PTR(node, "H5SL_below");
|
|
found_item = (unsigned *)H5SL_item(node);
|
|
VERIFY(*found_item, find_item, "H5SL_below");
|
|
|
|
/* Find item less than a missing key, in various positions */
|
|
find_item = 19;
|
|
node = H5SL_below(slist, &find_item);
|
|
CHECK_PTR(node, "H5SL_below");
|
|
found_item = (unsigned *)H5SL_item(node);
|
|
VERIFY(*found_item, 15, "H5SL_below");
|
|
find_item = 89;
|
|
node = H5SL_below(slist, &find_item);
|
|
CHECK_PTR(node, "H5SL_below");
|
|
found_item = (unsigned *)H5SL_item(node);
|
|
VERIFY(*found_item, 80, "H5SL_below");
|
|
find_item = 100;
|
|
node = H5SL_below(slist, &find_item);
|
|
CHECK_PTR(node, "H5SL_below");
|
|
found_item = (unsigned *)H5SL_item(node);
|
|
VERIFY(*found_item, 90, "H5SL_below");
|
|
find_item = 9;
|
|
node = H5SL_below(slist, &find_item);
|
|
CHECK_PTR(node, "H5SL_below");
|
|
found_item = (unsigned *)H5SL_item(node);
|
|
VERIFY(*found_item, 5, "H5SL_below");
|
|
find_item = 4;
|
|
node = (H5SL_node_t *)H5SL_less(slist, &find_item);
|
|
CHECK_PTR_NULL(node, "H5SL_below");
|
|
|
|
/* Close the skip list */
|
|
ret = H5SL_close(slist);
|
|
CHECK(ret, FAIL, "H5SL_close");
|
|
|
|
} /* end test_skiplist_below() */
|
|
|
|
/****************************************************************
|
|
**
|
|
** test_skiplist_above(): Test H5SL (skip list) code.
|
|
** Tests 'above' operation in skip lists.
|
|
**
|
|
****************************************************************/
|
|
static void
|
|
test_skiplist_above(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 add to skip list */
|
|
herr_t ret; /* Generic return value */
|
|
|
|
/* Output message about test being performed */
|
|
MESSAGE(7, ("Testing Skip List 'Above' Operation\n"));
|
|
|
|
/* Create a skip list */
|
|
slist = H5SL_create(H5SL_TYPE_UNSIGNED, NULL);
|
|
CHECK_PTR(slist, "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;
|
|
node = H5SL_above(slist, &find_item);
|
|
CHECK_PTR(node, "H5SL_above");
|
|
found_item = (unsigned *)H5SL_item(node);
|
|
VERIFY(*found_item, find_item, "H5SL_above");
|
|
find_item = 90;
|
|
node = H5SL_above(slist, &find_item);
|
|
CHECK_PTR(node, "H5SL_above");
|
|
found_item = (unsigned *)H5SL_item(node);
|
|
VERIFY(*found_item, find_item, "H5SL_above");
|
|
find_item = 5;
|
|
node = H5SL_above(slist, &find_item);
|
|
CHECK_PTR(node, "H5SL_above");
|
|
found_item = (unsigned *)H5SL_item(node);
|
|
VERIFY(*found_item, find_item, "H5SL_above");
|
|
|
|
/* Find item greater than a missing key, in various positions */
|
|
find_item = 19;
|
|
node = H5SL_above(slist, &find_item);
|
|
CHECK_PTR(node, "H5SL_above");
|
|
found_item = (unsigned *)H5SL_item(node);
|
|
VERIFY(*found_item, 20, "H5SL_above");
|
|
find_item = 89;
|
|
node = H5SL_above(slist, &find_item);
|
|
CHECK_PTR(node, "H5SL_above");
|
|
found_item = (unsigned *)H5SL_item(node);
|
|
VERIFY(*found_item, 90, "H5SL_above");
|
|
find_item = 100;
|
|
node = H5SL_above(slist, &find_item);
|
|
CHECK_PTR_NULL(node, "H5SL_above");
|
|
find_item = 6;
|
|
node = H5SL_above(slist, &find_item);
|
|
CHECK_PTR(node, "H5SL_above");
|
|
found_item = (unsigned *)H5SL_item(node);
|
|
VERIFY(*found_item, 10, "H5SL_above");
|
|
find_item = 4;
|
|
node = H5SL_above(slist, &find_item);
|
|
CHECK_PTR(node, "H5SL_above");
|
|
found_item = (unsigned *)H5SL_item(node);
|
|
VERIFY(*found_item, 5, "H5SL_above");
|
|
|
|
/* Close the skip list */
|
|
ret = H5SL_close(slist);
|
|
CHECK(ret, FAIL, "H5SL_close");
|
|
|
|
} /* end test_skiplist_above() */
|
|
|
|
/****************************************************************
|
|
**
|
|
** 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, NULL);
|
|
CHECK_PTR(slist, "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 = (unsigned *)H5SL_remove_first(slist);
|
|
VERIFY(*found_item, sorted_data[u], "H5SL_remove_first");
|
|
} /* end for */
|
|
|
|
/* Check for removing object from empty list */
|
|
found_item = (unsigned *)H5SL_remove_first(slist);
|
|
CHECK_PTR_NULL(found_item, "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_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, NULL);
|
|
CHECK_PTR(slist, "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);
|
|
CHECK_PTR_NULL(found_item, "H5SL_remove_first");
|
|
|
|
/* Close the skip list */
|
|
ret = H5SL_close(slist);
|
|
CHECK(ret, FAIL, "H5SL_close");
|
|
|
|
} /* end test_skiplist_remove_first() */
|
|
|
|
/****************************************************************
|
|
**
|
|
** test_skiplist_term(): Test H5SL (skiplist) code.
|
|
** Release data for skip list testing
|
|
**
|
|
****************************************************************/
|
|
static void
|
|
test_skiplist_term(void)
|
|
{
|
|
/* Release arrays */
|
|
if (rand_num)
|
|
HDfree(rand_num);
|
|
if (sort_rand_num)
|
|
HDfree(sort_rand_num);
|
|
if (rev_sort_rand_num)
|
|
HDfree(rev_sort_rand_num);
|
|
} /* end test_skiplist_term() */
|
|
|
|
/****************************************************************
|
|
**
|
|
** test_skiplist(): Main H5SL testing routine.
|
|
**
|
|
****************************************************************/
|
|
void
|
|
test_skiplist(void)
|
|
{
|
|
/* Output message about test being performed */
|
|
MESSAGE(5, ("Testing Skip Lists\n"));
|
|
|
|
/* Initialize skip list testing data */
|
|
test_skiplist_init();
|
|
|
|
/* Actual skip list tests */
|
|
test_skiplist_create(); /* Test skip list creation */
|
|
test_skiplist_insert(); /* Test basic skip list insertion */
|
|
test_skiplist_insert_many(); /* Test insertion of many items into skip list */
|
|
test_skiplist_remove(); /* Test basic skip list removal */
|
|
test_skiplist_remove_many(); /* Test removal of many items from skip list */
|
|
test_skiplist_firstnext(); /* Test iteration over skip list nodes with first/next */
|
|
test_skiplist_string(); /* Test skip list string keys */
|
|
test_skiplist_iterate(); /* Test iteration over skip list nodes with callback */
|
|
test_skiplist_hsize(); /* Test skip list hsize_t keys */
|
|
test_skiplist_unsigned(); /* Test skip list unsigned keys */
|
|
test_skiplist_obj(); /* Test skip list H5_obj_t keys */
|
|
test_skiplist_generic(); /* Test skip list generic keys */
|
|
test_skiplist_lastprev(); /* Test iteration over skip list nodes with last/prev */
|
|
test_skiplist_find(); /* Test 'find' operation */
|
|
test_skiplist_add(); /* Test 'add' operation */
|
|
test_skiplist_destroy(); /* Test 'destroy' operation */
|
|
test_skiplist_free(); /* Test 'free' operation */
|
|
test_skiplist_less(); /* Test 'less' operation */
|
|
test_skiplist_greater(); /* Test 'greater' operation */
|
|
test_skiplist_below(); /* Test 'below' operation */
|
|
test_skiplist_above(); /* Test 'above' operation */
|
|
test_skiplist_remove_first(); /* Test 'remove first' operation */
|
|
test_skiplist_remove_first_many(); /* Test 'remove first' operation on large skip lists */
|
|
|
|
/* Release skip list testing data */
|
|
test_skiplist_term();
|
|
|
|
} /* end test_skiplist() */
|