/* PSPP - a program for statistical analysis.
- Copyright (C) 2007, 2008 Free Software Foundation, Inc.
+ Copyright (C) 2007, 2008, 2009, 2010 Free Software Foundation, Inc.
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
"valgrind --leak-check=yes --show-reachable=yes" should give a
clean report. */
-/* Warning:
-
- GCC 4.3 will miscompile this test program, specifically
- test_moved(), given small changes. This is a bug in GCC
- triggered by the test program, not by the library under test,
- so you may safely ignore it. To avoid miscompilation, compile
- this file with GCC 4.2 or earlier or GCC 4.4 or later.
+/* GCC 4.3 miscompiles some of the tests below, so we do not run
+ these tests on GCC 4.3. This is a bug in GCC 4.3 triggered by
+ the test program, not a bug in the library under test. GCC
+ 4.2 or earlier and GCC 4.4 or later do not have this bug.
Here is a minimal test program that demonstrates the same or a
similar bug in GCC 4.3:
#include <libpspp/hmap.h>
-#include <assert.h>
#include <limits.h>
#include <stdbool.h>
#include <stddef.h>
#include <libpspp/compiler.h>
\f
-/* Currently running test. */
-static const char *test_name;
-
/* Exit with a failure code.
(Place a breakpoint on this function while debugging.) */
static void
{
if (!ok)
{
- printf ("Check failed in %s test at %s, line %d\n",
- test_name, __FILE__, line);
+ fprintf (stderr, "%s:%d: check failed\n", __FILE__, line);
check_die ();
}
}
*b = t;
}
-/* Reverses the order of the CNT integers starting at VALUES. */
+/* Reverses the order of the N integers starting at VALUES. */
static void
-reverse (int *values, size_t cnt)
+reverse (int *values, size_t n)
{
size_t i = 0;
- size_t j = cnt;
+ size_t j = n;
while (j > i)
swap (&values[i++], &values[--j]);
}
-/* Arranges the CNT elements in VALUES into the lexicographically
+/* Arranges the N elements in VALUES into the lexicographically
next greater permutation. Returns true if successful.
If VALUES is already the lexicographically greatest
permutation of its elements (i.e. ordered from greatest to
permutation (i.e. ordered from smallest to largest) and
returns false. */
static bool
-next_permutation (int *values, size_t cnt)
+next_permutation (int *values, size_t n)
{
- if (cnt > 0)
+ if (n > 0)
{
- size_t i = cnt - 1;
+ size_t i = n - 1;
while (i != 0)
{
i--;
if (values[i] < values[i + 1])
{
size_t j;
- for (j = cnt - 1; values[i] >= values[j]; j--)
+ for (j = n - 1; values[i] >= values[j]; j--)
continue;
swap (values + i, values + j);
- reverse (values + (i + 1), cnt - (i + 1));
+ reverse (values + (i + 1), n - (i + 1));
return true;
}
}
- reverse (values, cnt);
+ reverse (values, n);
}
return false;
return value;
}
-/* Randomly shuffles the CNT elements in ARRAY, each of which is
+/* Randomly shuffles the N elements in ARRAY, each of which is
SIZE bytes in size. */
static void
-random_shuffle (void *array_, size_t cnt, size_t size)
+random_shuffle (void *array_, size_t n, size_t size)
{
char *array = array_;
char *tmp = xmalloc (size);
size_t i;
- for (i = 0; i < cnt; i++)
+ for (i = 0; i < n; i++)
{
- size_t j = rand () % (cnt - i) + i;
+ size_t j = rand () % (n - i) + i;
if (i != j)
{
memcpy (tmp, array + j * size, size);
typedef size_t hash_function (int data);
static size_t
-identity_hash (int data)
+identity_hash (int data)
{
return data;
}
static size_t
-constant_hash (int data UNUSED)
+constant_hash (int data UNUSED)
{
return 0x12345678u;
}
return &e->node;
}
-/* Checks that HMAP contains the CNT ints in DATA, that its
+/* Checks that HMAP contains the N ints in DATA, that its
structure is correct, and that certain operations on HMAP
produce the expected results. */
static void
-check_hmap (struct hmap *hmap, const int data[], size_t cnt,
+check_hmap (struct hmap *hmap, const int data[], size_t n,
hash_function *hash)
{
size_t i, j;
int *order;
- check (hmap_count (hmap) == cnt);
- check (cnt <= hmap_capacity (hmap));
+ check (hmap_is_empty (hmap) == (n == 0));
+ check (hmap_count (hmap) == n);
+ check (n <= hmap_capacity (hmap));
- order = xmemdup (data, cnt * sizeof *data);
- qsort (order, cnt, sizeof *order, compare_ints);
+ order = xmemdup (data, n * sizeof *data);
+ qsort (order, n, sizeof *order, compare_ints);
- for (i = 0; i < cnt; i = j)
+ for (i = 0; i < n; i = j)
{
struct element *e;
int count;
- for (j = i + 1; j < cnt; j++)
+ for (j = i + 1; j < n; j++)
if (order[i] != order[j])
break;
count = 0;
HMAP_FOR_EACH_WITH_HASH (e, struct element, node, hash (order[i]), hmap)
- if (e->data == order[i])
+ if (e->data == order[i])
count++;
check (count == j - i);
check (find_element (hmap, -1, hash) == NULL);
- if (cnt == 0)
+ if (n == 0)
check (hmap_first (hmap) == NULL);
else
{
struct hmap_node *p;
int left;
- left = cnt;
- for (p = hmap_first (hmap), i = 0; i < cnt; p = hmap_next (hmap, p), i++)
+ left = n;
+ for (p = hmap_first (hmap), i = 0; i < n; p = hmap_next (hmap, p), i++)
{
struct element *e = hmap_node_to_element (p);
- size_t j;
check (hmap_node_hash (&e->node) == hash (e->data));
for (j = 0; j < left; j++)
- if (order[j] == e->data)
+ if (order[j] == e->data)
{
order[j] = order[--left];
goto next;
free (order);
}
-/* Inserts the CNT values from 0 to CNT - 1 (inclusive) into an
+/* Inserts the N values from 0 to N - 1 (inclusive) into an
HMAP in the order specified by INSERTIONS, then deletes them in
the order specified by DELETIONS, checking the HMAP's contents
for correctness after each operation. Uses HASH as the hash
static void
test_insert_delete (const int insertions[],
const int deletions[],
- size_t cnt,
+ size_t n,
hash_function *hash)
{
struct element *elements;
struct hmap hmap;
size_t i;
- elements = xnmalloc (cnt, sizeof *elements);
- for (i = 0; i < cnt; i++)
+ elements = xnmalloc (n, sizeof *elements);
+ for (i = 0; i < n; i++)
elements[i].data = i;
hmap_init (&hmap);
hmap_reserve (&hmap, 1);
check_hmap (&hmap, NULL, 0, hash);
- for (i = 0; i < cnt; i++)
+ for (i = 0; i < n; i++)
{
size_t capacity;
hmap_insert (&hmap, &elements[insertions[i]].node, hash (insertions[i]));
hmap_shrink (&hmap);
check (capacity == hmap_capacity (&hmap));
}
- for (i = 0; i < cnt; i++)
+ for (i = 0; i < n; i++)
{
hmap_delete (&hmap, &elements[deletions[i]].node);
- check_hmap (&hmap, deletions + i + 1, cnt - i - 1, hash);
+ check_hmap (&hmap, deletions + i + 1, n - i - 1, hash);
}
hmap_destroy (&hmap);
test_insert_any_remove_any (hash_function *hash)
{
const int max_elems = 5;
- int cnt;
+ int n;
- for (cnt = 0; cnt <= max_elems; cnt++)
+ for (n = 0; n <= max_elems; n++)
{
int *insertions, *deletions;
- unsigned int ins_perm_cnt;
+ unsigned int ins_n_perms;
int i;
- insertions = xnmalloc (cnt, sizeof *insertions);
- deletions = xnmalloc (cnt, sizeof *deletions);
- for (i = 0; i < cnt; i++)
+ insertions = xnmalloc (n, sizeof *insertions);
+ deletions = xnmalloc (n, sizeof *deletions);
+ for (i = 0; i < n; i++)
insertions[i] = i;
- for (ins_perm_cnt = 0;
- ins_perm_cnt == 0 || next_permutation (insertions, cnt);
- ins_perm_cnt++)
+ for (ins_n_perms = 0;
+ ins_n_perms == 0 || next_permutation (insertions, n);
+ ins_n_perms++)
{
- unsigned int del_perm_cnt;
+ unsigned int del_n_perms;
int i;
- for (i = 0; i < cnt; i++)
+ for (i = 0; i < n; i++)
deletions[i] = i;
- for (del_perm_cnt = 0;
- del_perm_cnt == 0 || next_permutation (deletions, cnt);
- del_perm_cnt++)
- test_insert_delete (insertions, deletions, cnt, hash);
+ for (del_n_perms = 0;
+ del_n_perms == 0 || next_permutation (deletions, n);
+ del_n_perms++)
+ test_insert_delete (insertions, deletions, n, hash);
- check (del_perm_cnt == factorial (cnt));
+ check (del_n_perms == factorial (n));
}
- check (ins_perm_cnt == factorial (cnt));
+ check (ins_n_perms == factorial (n));
free (insertions);
free (deletions);
}
static void
-test_insert_any_remove_any_random_hash (void)
+test_insert_any_remove_any_random_hash (void)
{
test_insert_any_remove_any (random_hash);
}
static void
-test_insert_any_remove_any_identity_hash (void)
+test_insert_any_remove_any_identity_hash (void)
{
test_insert_any_remove_any (identity_hash);
}
static void
-test_insert_any_remove_any_constant_hash (void)
+test_insert_any_remove_any_constant_hash (void)
{
test_insert_any_remove_any (constant_hash);
}
test_insert_any_remove_same (hash_function *hash)
{
const int max_elems = 7;
- int cnt;
+ int n;
- for (cnt = 0; cnt <= max_elems; cnt++)
+ for (n = 0; n <= max_elems; n++)
{
int *values;
- unsigned int permutation_cnt;
+ unsigned int n_permutations;
int i;
- values = xnmalloc (cnt, sizeof *values);
- for (i = 0; i < cnt; i++)
+ values = xnmalloc (n, sizeof *values);
+ for (i = 0; i < n; i++)
values[i] = i;
- for (permutation_cnt = 0;
- permutation_cnt == 0 || next_permutation (values, cnt);
- permutation_cnt++)
- test_insert_delete (values, values, cnt, hash);
- check (permutation_cnt == factorial (cnt));
+ for (n_permutations = 0;
+ n_permutations == 0 || next_permutation (values, n);
+ n_permutations++)
+ test_insert_delete (values, values, n, hash);
+ check (n_permutations == factorial (n));
free (values);
}
}
static void
-test_insert_any_remove_same_random_hash (void)
+test_insert_any_remove_same_random_hash (void)
{
test_insert_any_remove_same (random_hash);
}
static void
-test_insert_any_remove_same_identity_hash (void)
+test_insert_any_remove_same_identity_hash (void)
{
test_insert_any_remove_same (identity_hash);
}
static void
-test_insert_any_remove_same_constant_hash (void)
+test_insert_any_remove_same_constant_hash (void)
{
test_insert_any_remove_same (constant_hash);
}
test_insert_any_remove_reverse (hash_function *hash)
{
const int max_elems = 7;
- int cnt;
+ int n;
- for (cnt = 0; cnt <= max_elems; cnt++)
+ for (n = 0; n <= max_elems; n++)
{
int *insertions, *deletions;
- unsigned int permutation_cnt;
+ unsigned int n_permutations;
int i;
- insertions = xnmalloc (cnt, sizeof *insertions);
- deletions = xnmalloc (cnt, sizeof *deletions);
- for (i = 0; i < cnt; i++)
+ insertions = xnmalloc (n, sizeof *insertions);
+ deletions = xnmalloc (n, sizeof *deletions);
+ for (i = 0; i < n; i++)
insertions[i] = i;
- for (permutation_cnt = 0;
- permutation_cnt == 0 || next_permutation (insertions, cnt);
- permutation_cnt++)
+ for (n_permutations = 0;
+ n_permutations == 0 || next_permutation (insertions, n);
+ n_permutations++)
{
- memcpy (deletions, insertions, sizeof *insertions * cnt);
- reverse (deletions, cnt);
+ memcpy (deletions, insertions, sizeof *insertions * n);
+ reverse (deletions, n);
- test_insert_delete (insertions, deletions, cnt, hash);
+ test_insert_delete (insertions, deletions, n, hash);
}
- check (permutation_cnt == factorial (cnt));
+ check (n_permutations == factorial (n));
free (insertions);
free (deletions);
test_random_sequence (int max_elems, hash_function *hash)
{
const int max_trials = 8;
- int cnt;
+ int n;
- for (cnt = 0; cnt <= max_elems; cnt += 2)
+ for (n = 0; n <= max_elems; n += 2)
{
int *insertions, *deletions;
int trial;
int i;
- insertions = xnmalloc (cnt, sizeof *insertions);
- deletions = xnmalloc (cnt, sizeof *deletions);
- for (i = 0; i < cnt; i++)
+ insertions = xnmalloc (n, sizeof *insertions);
+ deletions = xnmalloc (n, sizeof *deletions);
+ for (i = 0; i < n; i++)
insertions[i] = i;
- for (i = 0; i < cnt; i++)
+ for (i = 0; i < n; i++)
deletions[i] = i;
for (trial = 0; trial < max_trials; trial++)
{
- random_shuffle (insertions, cnt, sizeof *insertions);
- random_shuffle (deletions, cnt, sizeof *deletions);
+ random_shuffle (insertions, n, sizeof *insertions);
+ random_shuffle (deletions, n, sizeof *deletions);
- test_insert_delete (insertions, deletions, cnt, hash);
+ test_insert_delete (insertions, deletions, n, hash);
}
free (insertions);
}
static void
-test_random_sequence_random_hash (void)
+test_random_sequence_random_hash (void)
{
test_random_sequence (64, random_hash);
}
static void
-test_random_sequence_identity_hash (void)
+test_random_sequence_identity_hash (void)
{
test_random_sequence (64, identity_hash);
}
static void
-test_random_sequence_constant_hash (void)
+test_random_sequence_constant_hash (void)
{
test_random_sequence (32, constant_hash);
}
struct hmap hmap;
int i;
+#if __GNUC__ == 4 && __GNUC_MINOR__ == 3
+ /* This tells the Autotest framework that the test was skipped. */
+ exit (77);
+#endif
+
hmap_init (&hmap);
elements = xnmalloc (max_elems, sizeof *elements);
values = xnmalloc (max_elems, sizeof *values);
hmap_insert (&hmap, &elements[i].node, hash (elements[i].data));
check_hmap (&hmap, values, i + 1, hash);
- if (hash == identity_hash)
+ if (hash == identity_hash)
{
/* Check that every every hash bucket has (almost) the
same number of nodes in it. */
int max = INT_MIN;
int j;
- for (j = 0; j <= hmap.mask; j++)
+ for (j = 0; j <= hmap.mask; j++)
{
int count = 0;
struct hmap_node *node;
struct hmap hmap;
int i, j;
+#if __GNUC__ == 4 && __GNUC_MINOR__ == 3
+ /* This tells the Autotest framework that the test was skipped. */
+ exit (77);
+#endif
+
hmap_init (&hmap);
e[0] = xnmalloc (max_elems, sizeof *e[0]);
e[1] = xnmalloc (max_elems, sizeof *e[1]);
}
static void
-test_moved_random_hash (void)
+test_moved_random_hash (void)
{
test_moved (128, random_hash);
}
static void
-test_moved_identity_hash (void)
+test_moved_identity_hash (void)
{
test_moved (128, identity_hash);
}
static void
-test_moved_constant_hash (void)
+test_moved_constant_hash (void)
{
test_moved (32, constant_hash);
}
test_changed (hash_function *hash)
{
const int max_elems = 6;
- int cnt;
+ int n;
- for (cnt = 0; cnt <= max_elems; cnt++)
+ for (n = 0; n <= max_elems; n++)
{
int *values, *changed_values;
struct element *elements;
- unsigned int permutation_cnt;
+ unsigned int n_permutations;
int i;
- values = xnmalloc (cnt, sizeof *values);
- changed_values = xnmalloc (cnt, sizeof *changed_values);
- elements = xnmalloc (cnt, sizeof *elements);
- for (i = 0; i < cnt; i++)
+ values = xnmalloc (n, sizeof *values);
+ changed_values = xnmalloc (n, sizeof *changed_values);
+ elements = xnmalloc (n, sizeof *elements);
+ for (i = 0; i < n; i++)
values[i] = i;
- for (permutation_cnt = 0;
- permutation_cnt == 0 || next_permutation (values, cnt);
- permutation_cnt++)
+ for (n_permutations = 0;
+ n_permutations == 0 || next_permutation (values, n);
+ n_permutations++)
{
- for (i = 0; i < cnt; i++)
+ for (i = 0; i < n; i++)
{
int j, k;
- for (j = 0; j <= cnt; j++)
+ for (j = 0; j <= n; j++)
{
struct hmap hmap;
hmap_init (&hmap);
/* Add to HMAP in order. */
- for (k = 0; k < cnt; k++)
+ for (k = 0; k < n; k++)
{
int n = values[k];
elements[n].data = n;
hmap_insert (&hmap, &elements[n].node,
hash (elements[n].data));
}
- check_hmap (&hmap, values, cnt, hash);
+ check_hmap (&hmap, values, n, hash);
/* Change value i to j. */
elements[i].data = j;
hmap_changed (&hmap, &elements[i].node,
hash (elements[i].data));
- for (k = 0; k < cnt; k++)
+ for (k = 0; k < n; k++)
changed_values[k] = k;
changed_values[i] = j;
- check_hmap (&hmap, changed_values, cnt, hash);
+ check_hmap (&hmap, changed_values, n, hash);
hmap_destroy (&hmap);
}
}
}
- check (permutation_cnt == factorial (cnt));
+ check (n_permutations == factorial (n));
free (values);
free (changed_values);
}
static void
-test_swap (int max_elems, hash_function *hash)
+test_swap (int max_elems, hash_function *hash)
{
struct element *elements;
int *values;
struct hmap *working, *empty;
int i;
+#if __GNUC__ == 4 && __GNUC_MINOR__ == 3
+ /* This tells the Autotest framework that the test was skipped. */
+ exit (77);
+#endif
+
hmap_init (&a);
hmap_init (&b);
working = &a;
}
static void
-test_swap_random_hash (void)
+test_swap_random_hash (void)
{
test_swap (128, random_hash);
}
+/* Inserts elements into an hmap in ascending order, then clears the hash table
+ using hmap_clear(). */
static void
-test_destroy_null (void)
+test_clear (void)
+{
+ const int max_elems = 128;
+ struct element *elements;
+ int *values;
+ struct hmap hmap;
+ int n;
+
+#if __GNUC__ == 4 && __GNUC_MINOR__ == 3
+ /* This tells the Autotest framework that the test was skipped. */
+ exit (77);
+#endif
+
+ elements = xnmalloc (max_elems, sizeof *elements);
+ values = xnmalloc (max_elems, sizeof *values);
+
+ for (n = 0; n <= max_elems; n++)
+ {
+ int i;
+
+ hmap_init (&hmap);
+ for (i = 0; i < n; i++)
+ {
+ values[i] = elements[i].data = i;
+ hmap_insert (&hmap, &elements[i].node,
+ random_hash (elements[i].data));
+ check_hmap (&hmap, values, i + 1, random_hash);
+ }
+ hmap_clear (&hmap);
+ check_hmap (&hmap, NULL, 0, random_hash);
+ hmap_destroy (&hmap);
+ }
+
+ free (elements);
+ free (values);
+}
+
+static void
+test_destroy_null (void)
{
hmap_destroy (NULL);
}
\f
/* Main program. */
-/* Runs TEST_FUNCTION and prints a message about NAME. */
-static void
-run_test (void (*test_function) (void), const char *name)
-{
- test_name = name;
- putchar ('.');
- fflush (stdout);
- test_function ();
-}
+struct test
+ {
+ const char *name;
+ const char *description;
+ void (*function) (void);
+ };
+
+static const struct test tests[] =
+ {
+ {
+ "insert-any-remove-any-random-hash",
+ "insert any order, delete any order (random hash)",
+ test_insert_any_remove_any_random_hash
+ },
+ {
+ "insert-any-remove-any-identity-hash",
+ "insert any order, delete any order (identity hash)",
+ test_insert_any_remove_any_identity_hash
+ },
+ {
+ "insert-any-remove-any-constant-hash",
+ "insert any order, delete any order (constant hash)",
+ test_insert_any_remove_any_constant_hash
+ },
+
+ {
+ "insert-any-remove-same-random-hash",
+ "insert any order, delete same order (random hash)",
+ test_insert_any_remove_same_random_hash
+ },
+ {
+ "insert-any-remove-same-identity-hash",
+ "insert any order, delete same order (identity hash)",
+ test_insert_any_remove_same_identity_hash
+ },
+ {
+ "insert-any-remove-same-constant-hash",
+ "insert any order, delete same order (constant hash)",
+ test_insert_any_remove_same_constant_hash
+ },
+
+ {
+ "insert-any-remove-reverse-random-hash",
+ "insert any order, delete reverse order (random hash)",
+ test_insert_any_remove_reverse_random_hash
+ },
+ {
+ "insert-any-remove-reverse-identity-hash",
+ "insert any order, delete reverse order (identity hash)",
+ test_insert_any_remove_reverse_identity_hash
+ },
+ {
+ "insert-any-remove-reverse-constant-hash",
+ "insert any order, delete reverse order (constant hash)",
+ test_insert_any_remove_reverse_constant_hash
+ },
+
+ {
+ "random-sequence-random-hash",
+ "insert and delete in random sequence (random hash)",
+ test_random_sequence_random_hash
+ },
+ {
+ "random-sequence-identity-hash",
+ "insert and delete in random sequence (identity hash)",
+ test_random_sequence_identity_hash
+ },
+ {
+ "random-sequence-constant-hash",
+ "insert and delete in random sequence (constant hash)",
+ test_random_sequence_constant_hash
+ },
+
+ {
+ "insert-ordered-random-hash",
+ "insert in ascending order (random hash)",
+ test_insert_ordered_random_hash
+ },
+ {
+ "insert-ordered-identity-hash",
+ "insert in ascending order (identity hash)",
+ test_insert_ordered_identity_hash
+ },
+ {
+ "insert-ordered-constant-hash",
+ "insert in ascending order (constant hash)",
+ test_insert_ordered_constant_hash
+ },
+
+ {
+ "moved-random-hash",
+ "move elements around in memory (random hash)",
+ test_moved_random_hash
+ },
+ {
+ "moved-identity-hash",
+ "move elements around in memory (identity hash)",
+ test_moved_identity_hash
+ },
+ {
+ "moved-constant-hash",
+ "move elements around in memory (constant hash)",
+ test_moved_constant_hash
+ },
+
+ {
+ "changed-random-hash",
+ "change key data in nodes (random hash)",
+ test_changed_random_hash
+ },
+ {
+ "changed-identity-hash",
+ "change key data in nodes (identity hash)",
+ test_changed_identity_hash
+ },
+ {
+ "changed-constant-hash",
+ "change key data in nodes (constant hash)",
+ test_changed_constant_hash
+ },
+
+ {
+ "swap-random-hash",
+ "test swapping tables",
+ test_swap_random_hash
+ },
+ {
+ "clear",
+ "test clearing hash table",
+ test_clear
+ },
+ {
+ "destroy-null",
+ "test destroying null table",
+ test_destroy_null
+ },
+ {
+ "shrink-empty",
+ "test shrinking an empty table",
+ test_shrink_empty
+ },
+ };
+
+enum { N_TESTS = sizeof tests / sizeof *tests };
int
-main (void)
-{
- run_test (test_insert_any_remove_any_random_hash,
- "insert any order, delete any order (random hash)");
- run_test (test_insert_any_remove_any_identity_hash,
- "insert any order, delete any order (identity hash)");
- run_test (test_insert_any_remove_any_constant_hash,
- "insert any order, delete any order (constant hash)");
-
- run_test (test_insert_any_remove_same_random_hash,
- "insert any order, delete same order (random hash)");
- run_test (test_insert_any_remove_same_identity_hash,
- "insert any order, delete same order (identity hash)");
- run_test (test_insert_any_remove_same_constant_hash,
- "insert any order, delete same order (constant hash)");
-
- run_test (test_insert_any_remove_reverse_random_hash,
- "insert any order, delete reverse order (random hash)");
- run_test (test_insert_any_remove_reverse_identity_hash,
- "insert any order, delete reverse order (identity hash)");
- run_test (test_insert_any_remove_reverse_constant_hash,
- "insert any order, delete reverse order (constant hash)");
-
- run_test (test_random_sequence_random_hash,
- "insert and delete in random sequence (random hash)");
- run_test (test_random_sequence_identity_hash,
- "insert and delete in random sequence (identity hash)");
- run_test (test_random_sequence_constant_hash,
- "insert and delete in random sequence (constant hash)");
-
- run_test (test_insert_ordered_random_hash,
- "insert in ascending order (random hash)");
- run_test (test_insert_ordered_identity_hash,
- "insert in ascending order (identity hash)");
- run_test (test_insert_ordered_constant_hash,
- "insert in ascending order (constant hash)");
-
- run_test (test_moved_random_hash,
- "move elements around in memory (random hash)");
- run_test (test_moved_identity_hash,
- "move elements around in memory (identity hash)");
- run_test (test_moved_constant_hash,
- "move elements around in memory (constant hash)");
-
- run_test (test_changed_random_hash,
- "change key data in nodes (random hash)");
- run_test (test_changed_identity_hash,
- "change key data in nodes (identity hash)");
- run_test (test_changed_constant_hash,
- "change key data in nodes (constant hash)");
-
- run_test (test_swap_random_hash, "test swapping tables");
-
- run_test (test_destroy_null, "test destroying null table");
- run_test (test_shrink_empty, "test shrinking an empty table");
-
- putchar ('\n');
-
- return 0;
+main (int argc, char *argv[])
+{
+ int i;
+
+ if (argc != 2)
+ {
+ fprintf (stderr, "exactly one argument required; use --help for help\n");
+ return EXIT_FAILURE;
+ }
+ else if (!strcmp (argv[1], "--help"))
+ {
+ printf ("%s: test hash map\n"
+ "usage: %s TEST-NAME\n"
+ "where TEST-NAME is one of the following:\n",
+ argv[0], argv[0]);
+ for (i = 0; i < N_TESTS; i++)
+ printf (" %s\n %s\n", tests[i].name, tests[i].description);
+ return 0;
+ }
+ else
+ {
+ for (i = 0; i < N_TESTS; i++)
+ if (!strcmp (argv[1], tests[i].name))
+ {
+ tests[i].function ();
+ return 0;
+ }
+
+ fprintf (stderr, "unknown test %s; use --help for help\n", argv[1]);
+ return EXIT_FAILURE;
+ }
}
projects / pspp / blobdiff