X-Git-Url: https://pintos-os.org/cgi-bin/gitweb.cgi?a=blobdiff_plain;f=tests%2Flibpspp%2Fllx-test.c;h=7d95474d49b541edd6eea022585d0766f17aa58c;hb=refs%2Fheads%2Fctables10;hp=f825a3a420242f30691a071c471c7097589f2a1c;hpb=3089f789be8524fdf13ccbec73ab5caa49683e5c;p=pspp
diff --git a/tests/libpspp/llx-test.c b/tests/libpspp/llx-test.c
index f825a3a420..7d95474d49 100644
--- a/tests/libpspp/llx-test.c
+++ b/tests/libpspp/llx-test.c
@@ -1,27 +1,25 @@
-/* PSPP - computes sample statistics.
- Copyright (C) 2006 Free Software Foundation, Inc.
+/* PSPP - a program for statistical analysis.
+ Copyright (C) 2006, 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 the Free Software Foundation; either version 2 of the
- License, or (at your option) any later version.
+ 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
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
- This program is distributed in the hope that it will be useful, but
- WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- General Public License for more details.
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
You should have received a copy of the GNU General Public License
- along with this program; if not, write to the Free Software
- Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
- 02110-1301, USA. */
+ along with this program. If not, see . */
/* This is a test program for the llx_* routines defined in
ll.c. This test program aims to be as comprehensive as
possible. "gcov -b" should report 100% coverage of lines and
branches in llx.c and llx.h. "valgrind --leak-check=yes
--show-reachable=yes" should give a clean report.
-
+
This test program depends only on ll.c, llx.c, and the
standard C library.
@@ -32,7 +30,6 @@
#endif
#include
-#include
#include
#include
#include
@@ -44,26 +41,22 @@
#define UNUSED
#endif
-/* Currently running test. */
-static const char *test_name;
-
/* Exit with a failure code.
(Place a breakpoint on this function while debugging.) */
static void
-check_die (void)
+check_die (void)
{
- exit (EXIT_FAILURE);
+ exit (EXIT_FAILURE);
}
/* If OK is not true, prints a message about failure on the
current source file and the given LINE and terminates. */
static void
-check_func (bool ok, int line)
+check_func (bool ok, int line)
{
- if (!ok)
+ 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 ();
}
}
@@ -84,9 +77,9 @@ xalloc_die (void)
/* Allocates and returns N bytes of memory. */
static void *
-xmalloc (size_t n)
+xmalloc (size_t n)
{
- if (n != 0)
+ if (n != 0)
{
void *p = malloc (n);
if (p == NULL)
@@ -100,7 +93,7 @@ xmalloc (size_t n)
/* Allocates and returns N * M bytes of memory. */
static void *
-xnmalloc (size_t n, size_t m)
+xnmalloc (size_t n, size_t m)
{
if ((size_t) -1 / m <= n)
xalloc_die ();
@@ -116,13 +109,13 @@ null_allocate_node (void *aux UNUSED)
/* Does nothing. */
static void
-null_release_node (struct llx *llx UNUSED, void *aux UNUSED)
+null_release_node (struct llx *llx UNUSED, void *aux UNUSED)
{
}
/* Memory manager that fails all allocations and does nothing on
free. */
-static const struct llx_manager llx_null_mgr =
+static const struct llx_manager llx_null_mgr =
{
null_allocate_node,
null_release_node,
@@ -138,7 +131,7 @@ struct element
int y; /* Secondary value. */
};
-int aux_data;
+static int aux_data;
/* Prints the elements in LIST. */
static void UNUSED
@@ -147,7 +140,7 @@ print_list (struct llx_list *list)
struct llx *x;
printf ("list:");
- for (x = llx_head (list); x != llx_null (list); x = llx_next (x))
+ for (x = llx_head (list); x != llx_null (list); x = llx_next (x))
{
const struct element *e = llx_data (x);
printf (" %d", e->x);
@@ -159,24 +152,24 @@ print_list (struct llx_list *list)
AUX for each element in LIST. */
static void UNUSED
print_pred (struct llx_list *list,
- llx_predicate_func *predicate, void *aux UNUSED)
+ llx_predicate_func *predicate, void *aux UNUSED)
{
struct llx *x;
printf ("pred:");
- for (x = llx_head (list); x != llx_null (list); x = llx_next (x))
+ for (x = llx_head (list); x != llx_null (list); x = llx_next (x))
printf (" %d", predicate (x, aux));
printf ("\n");
}
-/* Prints the CNT numbers in VALUES. */
+/* Prints the N numbers in VALUES. */
static void UNUSED
-print_array (int values[], size_t cnt)
+print_array (int values[], size_t n)
{
size_t i;
printf ("arry:");
- for (i = 0; i < cnt; i++)
+ for (i = 0; i < n; i++)
printf (" %d", values[i]);
printf ("\n");
}
@@ -184,7 +177,7 @@ print_array (int values[], size_t cnt)
/* Compares the `x' values in A and B and returns a strcmp-type
return value. Verifies that AUX points to aux_data. */
static int
-compare_elements (const void *a_, const void *b_, void *aux)
+compare_elements (const void *a_, const void *b_, void *aux)
{
const struct element *a = a_;
const struct element *b = b_;
@@ -197,7 +190,7 @@ compare_elements (const void *a_, const void *b_, void *aux)
strcmp-type return value. Verifies that AUX points to
aux_data. */
static int
-compare_elements_x_y (const void *a_, const void *b_, void *aux)
+compare_elements_x_y (const void *a_, const void *b_, void *aux)
{
const struct element *a = a_;
const struct element *b = b_;
@@ -226,7 +219,7 @@ compare_elements_y (const void *a_, const void *b_, void *aux)
/* Returns true if the bit in *PATTERN indicated by `x in
*ELEMENT is set, false otherwise. */
static bool
-pattern_pred (const void *element_, void *pattern_)
+pattern_pred (const void *element_, void *pattern_)
{
const struct element *element = element_;
unsigned int *pattern = pattern_;
@@ -246,7 +239,7 @@ allocate_elements (size_t n,
struct llx_list *list,
struct element ***elems,
struct llx ***elemp,
- int **values)
+ int **values)
{
size_t i;
@@ -254,35 +247,35 @@ allocate_elements (size_t n,
llx_init (list);
*elems = xnmalloc (n, sizeof **elems);
- if (elemp != NULL)
+ if (elemp != NULL)
{
*elemp = xnmalloc (n + 1, sizeof *elemp);
(*elemp)[n] = llx_null (list);
}
-
- for (i = 0; i < n; i++)
+
+ for (i = 0; i < n; i++)
{
(*elems)[i] = xmalloc (sizeof ***elems);
- if (list != NULL)
+ if (list != NULL)
{
struct llx *llx = llx_push_tail (list, (*elems)[i], &llx_malloc_mgr);
if (elemp != NULL)
- (*elemp)[i] = llx;
+ (*elemp)[i] = llx;
}
}
-
+
if (values != NULL)
*values = xnmalloc (n, sizeof *values);
}
-/* Copies the CNT values of `x' from LIST into VALUES[]. */
+/* Copies the N values of `x' from LIST into VALUES[]. */
static void
-extract_values (struct llx_list *list, int values[], size_t cnt)
+extract_values (struct llx_list *list, int values[], size_t n)
{
struct llx *x;
-
- check (llx_count (list) == cnt);
- for (x = llx_head (list); x != llx_null (list); x = llx_next (x))
+
+ check (llx_count (list) == n);
+ for (x = llx_head (list); x != llx_null (list); x = llx_next (x))
{
struct element *e = llx_data (x);
*values++ = e->x;
@@ -297,16 +290,16 @@ allocate_ascending (size_t n,
struct llx_list *list,
struct element ***elems,
struct llx ***elemp,
- int **values)
+ int **values)
{
size_t i;
allocate_elements (n, list, elems, elemp, values);
-
- for (i = 0; i < n; i++)
+
+ for (i = 0; i < n; i++)
(*elems)[i]->x = i;
if (values != NULL)
- extract_values (list, *values, n);
+ extract_values (list, *values, n);
}
/* As allocate_elements, but sets binary values extracted from
@@ -318,31 +311,31 @@ allocate_pattern (size_t n,
struct llx_list *list,
struct element ***elems,
struct llx ***elemp,
- int **values)
+ int **values)
{
size_t i;
allocate_elements (n, list, elems, elemp, values);
-
- for (i = 0; i < n; i++)
+
+ for (i = 0; i < n; i++)
(*elems)[i]->x = (pattern & (1 << i)) != 0;
if (values != NULL)
- extract_values (list, *values, n);
+ extract_values (list, *values, n);
}
-/* 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;
- if (i != j)
+ size_t j = rand () % (n - i) + i;
+ if (i != j)
{
memcpy (tmp, array + j * size, size);
memcpy (array + j * size, array + i * size, size);
@@ -359,17 +352,17 @@ allocate_random (size_t n,
struct llx_list *list,
struct element ***elems,
struct llx ***elemp,
- int **values)
+ int **values)
{
size_t i;
allocate_elements (n, list, elems, elemp, values);
-
- for (i = 0; i < n; i++)
+
+ for (i = 0; i < n; i++)
(*elems)[i]->x = i;
random_shuffle (*elems, n, sizeof **elems);
if (values != NULL)
- extract_values (list, *values, n);
+ extract_values (list, *values, n);
}
/* Frees LIST, the N elements of ELEMS, ELEMP, and VALUES. */
@@ -378,7 +371,7 @@ free_elements (size_t n,
struct llx_list *list,
struct element **elems,
struct llx **elemp,
- int *values)
+ int *values)
{
size_t i;
@@ -386,14 +379,14 @@ free_elements (size_t n,
llx_destroy (list, NULL, NULL, &llx_malloc_mgr);
for (i = 0; i < n; i++)
free (elems[i]);
- free (elems);
+ free (elems);
free (elemp);
free (values);
}
/* Compares A and B and returns a strcmp-type return value. */
static int
-compare_ints (const void *a_, const void *b_, void *aux UNUSED)
+compare_ints (const void *a_, const void *b_, void *aux UNUSED)
{
const int *a = a_;
const int *b = b_;
@@ -403,7 +396,7 @@ compare_ints (const void *a_, const void *b_, void *aux UNUSED)
/* Compares A and B and returns a strcmp-type return value. */
static int
-compare_ints_noaux (const void *a_, const void *b_)
+compare_ints_noaux (const void *a_, const void *b_)
{
const int *a = a_;
const int *b = b_;
@@ -411,17 +404,17 @@ compare_ints_noaux (const void *a_, const void *b_)
return *a < *b ? -1 : *a > *b;
}
-/* Checks that LIST contains the CNT values in ELEMENTS. */
+/* Checks that LIST contains the N values in ELEMENTS. */
static void
-check_list_contents (struct llx_list *list, int elements[], size_t cnt)
+check_list_contents (struct llx_list *list, int elements[], size_t n)
{
struct llx *llx;
size_t i;
- check ((cnt == 0) == llx_is_empty (list));
+ check ((n == 0) == llx_is_empty (list));
/* Iterate in forward order. */
- for (llx = llx_head (list), i = 0; i < cnt; llx = llx_next (llx), i++)
+ for (llx = llx_head (list), i = 0; i < n; llx = llx_next (llx), i++)
{
struct element *e = llx_data (llx);
check (elements[i] == e->x);
@@ -430,15 +423,15 @@ check_list_contents (struct llx_list *list, int elements[], size_t cnt)
check (llx == llx_null (list));
/* Iterate in reverse order. */
- for (llx = llx_tail (list), i = 0; i < cnt; llx = llx_prev (llx), i++)
+ for (llx = llx_tail (list), i = 0; i < n; llx = llx_prev (llx), i++)
{
struct element *e = llx_data (llx);
- check (elements[cnt - i - 1] == e->x);
+ check (elements[n - i - 1] == e->x);
check (llx != llx_null (list));
}
check (llx == llx_null (list));
- check (llx_count (list) == cnt);
+ check (llx_count (list) == n);
}
/* Lexicographicallxy compares ARRAY1, which contains COUNT1
@@ -452,7 +445,7 @@ lexicographical_compare_3way (const void *array1, size_t count1,
size_t size,
int (*compare) (const void *, const void *,
void *aux),
- void *aux)
+ void *aux)
{
const char *first1 = array1;
const char *first2 = array2;
@@ -491,7 +484,7 @@ test_push_pop (void)
/* Push on tail. */
llx_init (&list);
check_list_contents (&list, NULL, 0);
- for (i = 0; i < max_elems; i++)
+ for (i = 0; i < max_elems; i++)
{
values[i] = elems[i]->x = i;
llx_push_tail (&list, elems[i], &llx_malloc_mgr);
@@ -499,7 +492,7 @@ test_push_pop (void)
}
/* Remove from tail. */
- for (i = 0; i < max_elems; i++)
+ for (i = 0; i < max_elems; i++)
{
struct element *e = llx_pop_tail (&list, &llx_malloc_mgr);
check (e->x == max_elems - i - 1);
@@ -516,7 +509,7 @@ test_push_pop (void)
}
/* Remove from start. */
- for (i = 0; i < max_elems; i++)
+ for (i = 0; i < max_elems; i++)
{
struct element *e = llx_pop_head (&list, &llx_malloc_mgr);
check (e->x == (int) i);
@@ -528,25 +521,25 @@ test_push_pop (void)
/* Tests insertion and removal at arbitrary positions. */
static void
-test_insert_remove (void)
+test_insert_remove (void)
{
const int max_elems = 16;
- int cnt;
+ int n;
- for (cnt = 0; cnt < max_elems; cnt++)
+ for (n = 0; n < max_elems; n++)
{
struct element **elems;
struct llx **elemp;
- int *values = xnmalloc (cnt + 1, sizeof *values);
+ int *values = xnmalloc (n + 1, sizeof *values);
struct llx_list list;
struct element extra;
struct llx *extra_llx;
int pos;
- allocate_ascending (cnt, &list, &elems, &elemp, NULL);
+ allocate_ascending (n, &list, &elems, &elemp, NULL);
extra.x = -1;
- for (pos = 0; pos <= cnt; pos++)
+ for (pos = 0; pos <= n; pos++)
{
int i, j;
@@ -557,26 +550,26 @@ test_insert_remove (void)
for (i = 0; i < pos; i++)
values[j++] = i;
values[j++] = -1;
- for (; i < cnt; i++)
+ for (; i < n; i++)
values[j++] = i;
- check_list_contents (&list, values, cnt + 1);
+ check_list_contents (&list, values, n + 1);
llx_remove (extra_llx, &llx_malloc_mgr);
}
- check_list_contents (&list, values, cnt);
+ check_list_contents (&list, values, n);
- free_elements (cnt, &list, elems, elemp, values);
+ free_elements (n, &list, elems, elemp, values);
}
}
/* Tests swapping individual elements. */
static void
-test_swap (void)
+test_swap (void)
{
const int max_elems = 8;
- int cnt;
+ int n;
- for (cnt = 0; cnt <= max_elems; cnt++)
+ for (n = 0; n <= max_elems; n++)
{
struct llx_list list;
struct element **elems;
@@ -585,12 +578,12 @@ test_swap (void)
int i, j, k;
- allocate_ascending (cnt, &list, &elems, &elemp, &values);
- check_list_contents (&list, values, cnt);
+ allocate_ascending (n, &list, &elems, &elemp, &values);
+ check_list_contents (&list, values, n);
- for (i = 0; i < cnt; i++)
- for (j = 0; j < cnt; j++)
- for (k = 0; k < 2; k++)
+ for (i = 0; i < n; i++)
+ for (j = 0; j < n; j++)
+ for (k = 0; k < 2; k++)
{
int t;
@@ -598,25 +591,25 @@ test_swap (void)
t = values[i];
values[i] = values[j];
values[j] = t;
- check_list_contents (&list, values, cnt);
- }
+ check_list_contents (&list, values, n);
+ }
- free_elements (cnt, &list, elems, elemp, values);
+ free_elements (n, &list, elems, elemp, values);
}
}
/* Tests swapping ranges of list elements. */
static void
-test_swap_range (void)
+test_swap_range (void)
{
const int max_elems = 8;
- int cnt, a0, a1, b0, b1, r;
+ int n, a0, a1, b0, b1, r;
- for (cnt = 0; cnt <= max_elems; cnt++)
- for (a0 = 0; a0 <= cnt; a0++)
- for (a1 = a0; a1 <= cnt; a1++)
- for (b0 = a1; b0 <= cnt; b0++)
- for (b1 = b0; b1 <= cnt; b1++)
+ for (n = 0; n <= max_elems; n++)
+ for (a0 = 0; a0 <= n; a0++)
+ for (a1 = a0; a1 <= n; a1++)
+ for (b0 = a1; b0 <= n; b0++)
+ for (b1 = b0; b1 <= n; b1++)
for (r = 0; r < 2; r++)
{
struct llx_list list;
@@ -626,8 +619,8 @@ test_swap_range (void)
int i, j;
- allocate_ascending (cnt, &list, &elems, &elemp, &values);
- check_list_contents (&list, values, cnt);
+ allocate_ascending (n, &list, &elems, &elemp, &values);
+ check_list_contents (&list, values, n);
j = 0;
for (i = 0; i < a0; i++)
@@ -638,31 +631,31 @@ test_swap_range (void)
values[j++] = i;
for (i = a0; i < a1; i++)
values[j++] = i;
- for (i = b1; i < cnt; i++)
+ for (i = b1; i < n; i++)
values[j++] = i;
- check (j == cnt);
+ check (j == n);
if (r == 0)
llx_swap_range (elemp[a0], elemp[a1], elemp[b0], elemp[b1]);
else
llx_swap_range (elemp[b0], elemp[b1], elemp[a0], elemp[a1]);
- check_list_contents (&list, values, cnt);
+ check_list_contents (&list, values, n);
- free_elements (cnt, &list, elems, elemp, values);
+ free_elements (n, &list, elems, elemp, values);
}
}
/* Tests removing ranges of list elements. */
static void
-test_remove_range (void)
+test_remove_range (void)
{
const int max_elems = 8;
- int cnt, r0, r1;
+ int n, r0, r1;
- for (cnt = 0; cnt <= max_elems; cnt++)
- for (r0 = 0; r0 <= cnt; r0++)
- for (r1 = r0; r1 <= cnt; r1++)
+ for (n = 0; n <= max_elems; n++)
+ for (r0 = 0; r0 <= n; r0++)
+ for (r1 = r0; r1 <= n; r1++)
{
struct llx_list list;
struct element **elems;
@@ -671,34 +664,34 @@ test_remove_range (void)
int i, j;
- allocate_ascending (cnt, &list, &elems, &elemp, &values);
- check_list_contents (&list, values, cnt);
+ allocate_ascending (n, &list, &elems, &elemp, &values);
+ check_list_contents (&list, values, n);
j = 0;
for (i = 0; i < r0; i++)
values[j++] = i;
- for (i = r1; i < cnt; i++)
+ for (i = r1; i < n; i++)
values[j++] = i;
llx_remove_range (elemp[r0], elemp[r1], &llx_malloc_mgr);
check_list_contents (&list, values, j);
- free_elements (cnt, &list, elems, elemp, values);
+ free_elements (n, &list, elems, elemp, values);
}
}
/* Tests llx_remove_equal. */
static void
-test_remove_equal (void)
+test_remove_equal (void)
{
const int max_elems = 8;
- int cnt, r0, r1, eq_pat;
+ int n, r0, r1, eq_pat;
- for (cnt = 0; cnt <= max_elems; cnt++)
- for (r0 = 0; r0 <= cnt; r0++)
- for (r1 = r0; r1 <= cnt; r1++)
- for (eq_pat = 0; eq_pat <= 1 << cnt; eq_pat++)
+ for (n = 0; n <= max_elems; n++)
+ for (r0 = 0; r0 <= n; r0++)
+ for (r1 = r0; r1 <= n; r1++)
+ for (eq_pat = 0; eq_pat <= 1 << n; eq_pat++)
{
struct llx_list list;
struct element **elems;
@@ -709,41 +702,41 @@ test_remove_equal (void)
int remaining;
int i;
- allocate_elements (cnt, &list, &elems, &elemp, &values);
+ allocate_elements (n, &list, &elems, &elemp, &values);
remaining = 0;
- for (i = 0; i < cnt; i++)
+ for (i = 0; i < n; i++)
{
int x = eq_pat & (1 << i) ? -1 : i;
bool delete = x == -1 && r0 <= i && i < r1;
elems[i]->x = x;
if (!delete)
- values[remaining++] = x;
+ values[remaining++] = x;
}
to_remove.x = -1;
check ((int) llx_remove_equal (elemp[r0], elemp[r1], &to_remove,
compare_elements, &aux_data,
&llx_malloc_mgr)
- == cnt - remaining);
+ == n - remaining);
check_list_contents (&list, values, remaining);
- free_elements (cnt, &list, elems, elemp, values);
+ free_elements (n, &list, elems, elemp, values);
}
}
/* Tests llx_remove_if. */
static void
-test_remove_if (void)
+test_remove_if (void)
{
const int max_elems = 8;
- int cnt, r0, r1, pattern;
+ int n, r0, r1, pattern;
- for (cnt = 0; cnt <= max_elems; cnt++)
- for (r0 = 0; r0 <= cnt; r0++)
- for (r1 = r0; r1 <= cnt; r1++)
- for (pattern = 0; pattern <= 1 << cnt; pattern++)
+ for (n = 0; n <= max_elems; n++)
+ for (r0 = 0; r0 <= n; r0++)
+ for (r1 = r0; r1 <= n; r1++)
+ for (pattern = 0; pattern <= 1 << n; pattern++)
{
struct llx_list list;
struct element **elems;
@@ -753,23 +746,23 @@ test_remove_if (void)
int remaining;
int i;
- allocate_ascending (cnt, &list, &elems, &elemp, &values);
+ allocate_ascending (n, &list, &elems, &elemp, &values);
remaining = 0;
- for (i = 0; i < cnt; i++)
+ for (i = 0; i < n; i++)
{
bool delete = (pattern & (1 << i)) && r0 <= i && i < r1;
if (!delete)
- values[remaining++] = i;
+ values[remaining++] = i;
}
- check ((int) llx_remove_if (elemp[r0], elemp[r1],
+ check ((int) llx_remove_if (elemp[r0], elemp[r1],
pattern_pred, &pattern,
&llx_malloc_mgr)
- == cnt - remaining);
+ == n - remaining);
check_list_contents (&list, values, remaining);
- free_elements (cnt, &list, elems, elemp, values);
+ free_elements (n, &list, elems, elemp, values);
}
}
@@ -782,10 +775,10 @@ test_examine_equal_range (void (*helper) (int r0, int r1, int eq_pat,
{
const int max_elems = 8;
- int cnt, r0, r1, eq_pat;
+ int n, r0, r1, eq_pat;
- for (cnt = 0; cnt <= max_elems; cnt++)
- for (eq_pat = 0; eq_pat <= 1 << cnt; eq_pat++)
+ for (n = 0; n <= max_elems; n++)
+ for (eq_pat = 0; eq_pat <= 1 << n; eq_pat++)
{
struct llx_list list;
struct element **elems;
@@ -796,20 +789,20 @@ test_examine_equal_range (void (*helper) (int r0, int r1, int eq_pat,
int i;
- allocate_ascending (cnt, &list, &elems, &elemp, &values);
+ allocate_ascending (n, &list, &elems, &elemp, &values);
- for (i = 0; i < cnt; i++)
+ for (i = 0; i < n; i++)
if (eq_pat & (1 << i))
values[i] = elems[i]->x = -1;
to_find.x = -1;
- for (r0 = 0; r0 <= cnt; r0++)
- for (r1 = r0; r1 <= cnt; r1++)
+ for (r0 = 0; r0 <= n; r0++)
+ for (r1 = r0; r1 <= n; r1++)
helper (r0, r1, eq_pat, &to_find, elemp);
- check_list_contents (&list, values, cnt);
+ check_list_contents (&list, values, n);
- free_elements (cnt, &list, elems, elemp, values);
+ free_elements (n, &list, elems, elemp, values);
}
}
@@ -821,25 +814,25 @@ test_examine_if_range (void (*helper) (int r0, int r1, int eq_pat,
{
const int max_elems = 8;
- int cnt, r0, r1, eq_pat;
+ int n, r0, r1, eq_pat;
- for (cnt = 0; cnt <= max_elems; cnt++)
- for (eq_pat = 0; eq_pat <= 1 << cnt; eq_pat++)
+ for (n = 0; n <= max_elems; n++)
+ for (eq_pat = 0; eq_pat <= 1 << n; eq_pat++)
{
struct llx_list list;
struct element **elems;
struct llx **elemp;
int *values;
- allocate_ascending (cnt, &list, &elems, &elemp, &values);
+ allocate_ascending (n, &list, &elems, &elemp, &values);
- for (r0 = 0; r0 <= cnt; r0++)
- for (r1 = r0; r1 <= cnt; r1++)
+ for (r0 = 0; r0 <= n; r0++)
+ for (r1 = r0; r1 <= n; r1++)
helper (r0, r1, eq_pat, elemp);
- check_list_contents (&list, values, cnt);
+ check_list_contents (&list, values, n);
- free_elements (cnt, &list, elems, elemp, values);
+ free_elements (n, &list, elems, elemp, values);
}
}
@@ -857,16 +850,44 @@ test_find_equal_helper (int r0, int r1, int eq_pat,
if (eq_pat & (1 << i))
break;
- check (match == elemp[i]);
+ check (match == elemp[i]);
}
/* Tests llx_find_equal. */
static void
-test_find_equal (void)
+test_find_equal (void)
{
test_examine_equal_range (test_find_equal_helper);
}
+/* Tests llx_find(). */
+static void
+test_find (void)
+{
+ const int max_elems = 8;
+
+ int n;
+
+ for (n = 0; n <= max_elems; n++)
+ {
+ struct llx_list list;
+ struct element **elems;
+ struct llx **elemp;
+ int *values;
+
+ int i;
+
+ allocate_ascending (n, &list, &elems, &elemp, &values);
+
+ for (i = 0; i < n; i++)
+ check (llx_find (llx_head (&list), llx_null (&list), elems[i])
+ == elemp[i]);
+ check (llx_find (llx_head (&list), llx_null (&list), NULL) == NULL);
+
+ free_elements (n, &list, elems, elemp, values);
+ }
+}
+
/* Helper function for testing llx_find_if. */
static void
test_find_if_helper (int r0, int r1, int eq_pat, struct llx **elemp)
@@ -879,26 +900,26 @@ test_find_if_helper (int r0, int r1, int eq_pat, struct llx **elemp)
if (eq_pat & (1 << i))
break;
- check (match == elemp[i]);
+ check (match == elemp[i]);
}
/* Tests llx_find_if. */
static void
-test_find_if (void)
+test_find_if (void)
{
test_examine_if_range (test_find_if_helper);
}
/* Tests llx_find_adjacent_equal. */
static void
-test_find_adjacent_equal (void)
+test_find_adjacent_equal (void)
{
const int max_elems = 8;
- int cnt, eq_pat;
+ int n, eq_pat;
- for (cnt = 0; cnt <= max_elems; cnt++)
- for (eq_pat = 0; eq_pat <= 1 << cnt; eq_pat++)
+ for (n = 0; n <= max_elems; n++)
+ for (eq_pat = 0; eq_pat <= 1 << n; eq_pat++)
{
struct llx_list list;
struct element **elems;
@@ -908,13 +929,13 @@ test_find_adjacent_equal (void)
int i;
- allocate_ascending (cnt, &list, &elems, &elemp, &values);
+ allocate_ascending (n, &list, &elems, &elemp, &values);
match = -1;
- for (i = 0; i < cnt - 1; i++)
+ for (i = 0; i < n - 1; i++)
{
elems[i]->y = i;
- if (eq_pat & (1 << i))
+ if (eq_pat & (1 << i))
{
values[i] = elems[i]->x = match;
values[i + 1] = elems[i + 1]->x = match;
@@ -922,8 +943,8 @@ test_find_adjacent_equal (void)
else
match--;
}
-
- for (i = 0; i <= cnt; i++)
+
+ for (i = 0; i <= n; i++)
{
struct llx *llx1 = llx_find_adjacent_equal (elemp[i], llx_null (&list),
compare_elements,
@@ -932,17 +953,17 @@ test_find_adjacent_equal (void)
int j;
llx2 = llx_null (&list);
- for (j = i; j < cnt - 1; j++)
- if (eq_pat & (1 << j))
+ for (j = i; j < n - 1; j++)
+ if (eq_pat & (1 << j))
{
llx2 = elemp[j];
break;
}
check (llx1 == llx2);
}
- check_list_contents (&list, values, cnt);
+ check_list_contents (&list, values, n);
- free_elements (cnt, &list, elems, elemp, values);
+ free_elements (n, &list, elems, elemp, values);
}
}
@@ -955,7 +976,7 @@ test_count_range_helper (int r0, int r1, int eq_pat UNUSED, struct llx **elemp)
/* Tests llx_count_range. */
static void
-test_count_range (void)
+test_count_range (void)
{
test_examine_if_range (test_count_range_helper);
}
@@ -974,20 +995,20 @@ test_count_equal_helper (int r0, int r1, int eq_pat,
for (i = r0; i < r1; i++)
if (eq_pat & (1 << i))
count2++;
-
- check (count1 == count2);
+
+ check (count1 == count2);
}
/* Tests llx_count_equal. */
static void
-test_count_equal (void)
+test_count_equal (void)
{
test_examine_equal_range (test_count_equal_helper);
}
/* Helper function for testing llx_count_if. */
static void
-test_count_if_helper (int r0, int r1, int eq_pat, struct llx **elemp)
+test_count_if_helper (int r0, int r1, int eq_pat, struct llx **elemp)
{
int count1;
int count2;
@@ -1000,19 +1021,19 @@ test_count_if_helper (int r0, int r1, int eq_pat, struct llx **elemp)
if (eq_pat & (1 << i))
count2++;
- check (count1 == count2);
+ check (count1 == count2);
}
/* Tests llx_count_if. */
static void
-test_count_if (void)
+test_count_if (void)
{
test_examine_if_range (test_count_if_helper);
}
/* Returns N!. */
static unsigned int
-factorial (unsigned int n)
+factorial (unsigned int n)
{
unsigned int value = 1;
while (n > 1)
@@ -1020,73 +1041,73 @@ factorial (unsigned int n)
return value;
}
-/* Returns the number of permutations of the CNT values in
+/* Returns the number of permutations of the N values in
VALUES. If VALUES contains duplicates, they must be
adjacent. */
static unsigned int
-expected_perms (int *values, size_t cnt)
+expected_perms (int *values, size_t n)
{
size_t i, j;
- unsigned int perm_cnt;
-
- perm_cnt = factorial (cnt);
- for (i = 0; i < cnt; i = j)
+ unsigned int n_perms;
+
+ n_perms = factorial (n);
+ for (i = 0; i < n; i = j)
{
- for (j = i + 1; j < cnt; j++)
+ for (j = i + 1; j < n; j++)
if (values[i] != values[j])
break;
- perm_cnt /= factorial (j - i);
+ n_perms /= factorial (j - i);
}
- return perm_cnt;
+ return n_perms;
}
/* Tests llx_min and llx_max. */
static void
-test_min_max (void)
+test_min_max (void)
{
const int max_elems = 6;
- int cnt;
+ int n;
- for (cnt = 0; cnt <= max_elems; cnt++)
+ for (n = 0; n <= max_elems; n++)
{
struct llx_list list;
struct element **elems;
struct llx **elemp;
int *values;
- int *new_values = xnmalloc (cnt, sizeof *values);
+ int *new_values = xnmalloc (n, sizeof *values);
- size_t perm_cnt;
+ size_t n_perms;
- allocate_ascending (cnt, &list, &elems, &elemp, &values);
+ allocate_ascending (n, &list, &elems, &elemp, &values);
- perm_cnt = 1;
+ n_perms = 1;
while (llx_next_permutation (llx_head (&list), llx_null (&list),
- compare_elements, &aux_data))
+ compare_elements, &aux_data))
{
int r0, r1;
struct llx *x;
int i;
-
+
for (i = 0, x = llx_head (&list); x != llx_null (&list);
- x = llx_next (x), i++)
+ x = llx_next (x), i++)
{
struct element *e = llx_data (x);
elemp[i] = x;
new_values[i] = e->x;
}
- for (r0 = 0; r0 <= cnt; r0++)
- for (r1 = r0; r1 <= cnt; r1++)
+ for (r0 = 0; r0 <= n; r0++)
+ for (r1 = r0; r1 <= n; r1++)
{
struct llx *min = llx_min (elemp[r0], elemp[r1],
compare_elements, &aux_data);
struct llx *max = llx_max (elemp[r0], elemp[r1],
compare_elements, &aux_data);
- if (r0 == r1)
+ if (r0 == r1)
{
check (min == elemp[r1]);
- check (max == elemp[r1]);
+ check (max == elemp[r1]);
}
- else
+ else
{
struct element *min_elem = llx_data (min);
struct element *max_elem = llx_data (max);
@@ -1103,31 +1124,31 @@ test_min_max (void)
max_int = value;
}
check (min != elemp[r1] && min_elem->x == min_int);
- check (max != elemp[r1] && max_elem->x == max_int);
+ check (max != elemp[r1] && max_elem->x == max_int);
}
}
- perm_cnt++;
+ n_perms++;
}
- check (perm_cnt == factorial (cnt));
- check_list_contents (&list, values, cnt);
+ check (n_perms == factorial (n));
+ check_list_contents (&list, values, n);
- free_elements (cnt, &list, elems, elemp, values);
+ free_elements (n, &list, elems, elemp, values);
free (new_values);
}
}
/* Tests llx_lexicographical_compare_3way. */
static void
-test_lexicographical_compare_3way (void)
+test_lexicographical_compare_3way (void)
{
const int max_elems = 4;
- int cnt_a, pat_a, cnt_b, pat_b;
+ int n_a, pat_a, n_b, pat_b;
- for (cnt_a = 0; cnt_a <= max_elems; cnt_a++)
- for (pat_a = 0; pat_a <= 1 << cnt_a; pat_a++)
- for (cnt_b = 0; cnt_b <= max_elems; cnt_b++)
- for (pat_b = 0; pat_b <= 1 << cnt_b; pat_b++)
+ for (n_a = 0; n_a <= max_elems; n_a++)
+ for (pat_a = 0; pat_a <= 1 << n_a; pat_a++)
+ for (n_b = 0; n_b <= max_elems; n_b++)
+ for (pat_b = 0; pat_b <= 1 << n_b; pat_b++)
{
struct llx_list list_a, list_b;
struct element **elems_a, **elems_b;
@@ -1136,15 +1157,15 @@ test_lexicographical_compare_3way (void)
int a0, a1, b0, b1;
- allocate_pattern (cnt_a, pat_a,
+ allocate_pattern (n_a, pat_a,
&list_a, &elems_a, &elemp_a, &values_a);
- allocate_pattern (cnt_b, pat_b,
+ allocate_pattern (n_b, pat_b,
&list_b, &elems_b, &elemp_b, &values_b);
- for (a0 = 0; a0 <= cnt_a; a0++)
- for (a1 = a0; a1 <= cnt_a; a1++)
- for (b0 = 0; b0 <= cnt_b; b0++)
- for (b1 = b0; b1 <= cnt_b; b1++)
+ for (a0 = 0; a0 <= n_a; a0++)
+ for (a1 = a0; a1 <= n_a; a1++)
+ for (b0 = 0; b0 <= n_b; b0++)
+ for (b1 = b0; b1 <= n_b; b1++)
{
int a_ordering = lexicographical_compare_3way (
values_a + a0, a1 - a0,
@@ -1158,35 +1179,35 @@ test_lexicographical_compare_3way (void)
compare_elements, &aux_data);
check (a_ordering == b_ordering);
- }
+ }
- free_elements (cnt_a, &list_a, elems_a, elemp_a, values_a);
- free_elements (cnt_b, &list_b, elems_b, elemp_b, values_b);
+ free_elements (n_a, &list_a, elems_a, elemp_a, values_a);
+ free_elements (n_b, &list_b, elems_b, elemp_b, values_b);
}
}
/* Appends the `x' value in element E to the array pointed to by
NEXT_OUTPUT, and advances NEXT_OUTPUT to the next position. */
static void
-apply_func (void *e_, void *next_output_)
+apply_func (void *e_, void *next_output_)
{
struct element *e = e_;
int **next_output = next_output_;
-
+
*(*next_output)++ = e->x;
}
/* Tests llx_apply. */
static void
-test_apply (void)
+test_apply (void)
{
const int max_elems = 8;
- int cnt, r0, r1;
+ int n, r0, r1;
- for (cnt = 0; cnt <= max_elems; cnt++)
- for (r0 = 0; r0 <= cnt; r0++)
- for (r1 = r0; r1 <= cnt; r1++)
+ for (n = 0; n <= max_elems; n++)
+ for (r0 = 0; r0 <= n; r0++)
+ for (r1 = r0; r1 <= n; r1++)
{
struct llx_list list;
struct element **elems;
@@ -1197,32 +1218,32 @@ test_apply (void)
int *next_output;
int j;
- allocate_ascending (cnt, &list, &elems, &elemp, &values);
- check_list_contents (&list, values, cnt);
+ allocate_ascending (n, &list, &elems, &elemp, &values);
+ check_list_contents (&list, values, n);
- output = next_output = xnmalloc (cnt, sizeof *output);
+ output = next_output = xnmalloc (n, sizeof *output);
llx_apply (elemp[r0], elemp[r1], apply_func, &next_output);
- check_list_contents (&list, values, cnt);
+ check_list_contents (&list, values, n);
llx_destroy (&list, NULL, NULL, &llx_malloc_mgr);
-
+
check (r1 - r0 == next_output - output);
for (j = 0; j < r1 - r0; j++)
check (output[j] == r0 + j);
- free_elements (cnt, NULL, elems, elemp, values);
+ free_elements (n, NULL, elems, elemp, values);
free (output);
}
}
/* Tests llx_destroy. */
static void
-test_destroy (void)
+test_destroy (void)
{
const int max_elems = 8;
- int cnt;
+ int n;
- for (cnt = 0; cnt <= max_elems; cnt++)
+ for (n = 0; n <= max_elems; n++)
{
struct llx_list list;
struct element **elems;
@@ -1233,32 +1254,32 @@ test_destroy (void)
int *next_output;
int j;
- allocate_ascending (cnt, &list, &elems, &elemp, &values);
- check_list_contents (&list, values, cnt);
+ allocate_ascending (n, &list, &elems, &elemp, &values);
+ check_list_contents (&list, values, n);
- output = next_output = xnmalloc (cnt, sizeof *output);
+ output = next_output = xnmalloc (n, sizeof *output);
llx_destroy (&list, apply_func, &next_output, &llx_malloc_mgr);
-
- check (cnt == next_output - output);
- for (j = 0; j < cnt; j++)
+
+ check (n == next_output - output);
+ for (j = 0; j < n; j++)
check (output[j] == j);
- free_elements (cnt, NULL, elems, elemp, values);
+ free_elements (n, NULL, elems, elemp, values);
free (output);
}
}
/* Tests llx_reverse. */
static void
-test_reverse (void)
+test_reverse (void)
{
const int max_elems = 8;
- int cnt, r0, r1;
+ int n, r0, r1;
- for (cnt = 0; cnt <= max_elems; cnt++)
- for (r0 = 0; r0 <= cnt; r0++)
- for (r1 = r0; r1 <= cnt; r1++)
+ for (n = 0; n <= max_elems; n++)
+ for (r0 = 0; r0 <= n; r0++)
+ for (r1 = r0; r1 <= n; r1++)
{
struct llx_list list;
struct element **elems;
@@ -1267,79 +1288,79 @@ test_reverse (void)
int i, j;
- allocate_ascending (cnt, &list, &elems, &elemp, &values);
- check_list_contents (&list, values, cnt);
+ allocate_ascending (n, &list, &elems, &elemp, &values);
+ check_list_contents (&list, values, n);
j = 0;
for (i = 0; i < r0; i++)
values[j++] = i;
for (i = r1 - 1; i >= r0; i--)
values[j++] = i;
- for (i = r1; i < cnt; i++)
+ for (i = r1; i < n; i++)
values[j++] = i;
llx_reverse (elemp[r0], elemp[r1]);
- check_list_contents (&list, values, cnt);
+ check_list_contents (&list, values, n);
- free_elements (cnt, &list, elems, elemp, values);
+ free_elements (n, &list, elems, elemp, values);
}
}
/* Tests llx_next_permutation and llx_prev_permutation when the
permuted values have no duplicates. */
static void
-test_permutations_no_dups (void)
+test_permutations_no_dups (void)
{
const int max_elems = 8;
- int cnt;
+ int n;
- for (cnt = 0; cnt <= max_elems; cnt++)
+ for (n = 0; n <= max_elems; n++)
{
struct llx_list list;
struct element **elems;
int *values;
- int *old_values = xnmalloc (cnt, sizeof *values);
- int *new_values = xnmalloc (cnt, sizeof *values);
+ int *old_values = xnmalloc (n, sizeof *values);
+ int *new_values = xnmalloc (n, sizeof *values);
- size_t perm_cnt;
+ size_t n_perms;
- allocate_ascending (cnt, &list, &elems, NULL, &values);
+ allocate_ascending (n, &list, &elems, NULL, &values);
- perm_cnt = 1;
- extract_values (&list, old_values, cnt);
+ n_perms = 1;
+ extract_values (&list, old_values, n);
while (llx_next_permutation (llx_head (&list), llx_null (&list),
- compare_elements, &aux_data))
+ compare_elements, &aux_data))
{
- extract_values (&list, new_values, cnt);
- check (lexicographical_compare_3way (new_values, cnt,
- old_values, cnt,
+ extract_values (&list, new_values, n);
+ check (lexicographical_compare_3way (new_values, n,
+ old_values, n,
sizeof *new_values,
compare_ints, NULL) > 0);
- memcpy (old_values, new_values, (cnt) * sizeof *old_values);
- perm_cnt++;
+ memcpy (old_values, new_values, (n) * sizeof *old_values);
+ n_perms++;
}
- check (perm_cnt == factorial (cnt));
- check_list_contents (&list, values, cnt);
+ check (n_perms == factorial (n));
+ check_list_contents (&list, values, n);
- perm_cnt = 1;
+ n_perms = 1;
llx_reverse (llx_head (&list), llx_null (&list));
- extract_values (&list, old_values, cnt);
+ extract_values (&list, old_values, n);
while (llx_prev_permutation (llx_head (&list), llx_null (&list),
- compare_elements, &aux_data))
+ compare_elements, &aux_data))
{
- extract_values (&list, new_values, cnt);
- check (lexicographical_compare_3way (new_values, cnt,
- old_values, cnt,
+ extract_values (&list, new_values, n);
+ check (lexicographical_compare_3way (new_values, n,
+ old_values, n,
sizeof *new_values,
compare_ints, NULL) < 0);
- memcpy (old_values, new_values, (cnt) * sizeof *old_values);
- perm_cnt++;
+ memcpy (old_values, new_values, (n) * sizeof *old_values);
+ n_perms++;
}
- check (perm_cnt == factorial (cnt));
+ check (n_perms == factorial (n));
llx_reverse (llx_head (&list), llx_null (&list));
- check_list_contents (&list, values, cnt);
+ check_list_contents (&list, values, n);
- free_elements (cnt, &list, elems, NULL, values);
+ free_elements (n, &list, elems, NULL, values);
free (old_values);
free (new_values);
}
@@ -1348,16 +1369,14 @@ test_permutations_no_dups (void)
/* Tests llx_next_permutation and llx_prev_permutation when the
permuted values contain duplicates. */
static void
-test_permutations_with_dups (void)
+test_permutations_with_dups (void)
{
const int max_elems = 8;
const int max_dup = 3;
const int repetitions = 1024;
- int cnt, repeat;
-
- for (repeat = 0; repeat < repetitions; repeat++)
- for (cnt = 0; cnt < max_elems; cnt++)
+ for (int repeat = 0; repeat < repetitions; repeat++)
+ for (int n_elems = 0; n_elems < max_elems; n_elems++)
{
struct llx_list list;
struct element **elems;
@@ -1366,11 +1385,11 @@ test_permutations_with_dups (void)
int *old_values = xnmalloc (max_elems, sizeof *values);
int *new_values = xnmalloc (max_elems, sizeof *values);
- unsigned int permutation_cnt;
- int left = cnt;
+ unsigned int n_permutations;
+ int left = n_elems;
int value = 0;
-
- allocate_elements (cnt, &list, &elems, &elemp, &values);
+
+ allocate_elements (n_elems, &list, &elems, &elemp, &values);
value = 0;
while (left > 0)
@@ -1379,46 +1398,46 @@ test_permutations_with_dups (void)
int n = rand () % max + 1;
while (n-- > 0)
{
- int idx = cnt - left--;
+ int idx = n_elems - left--;
values[idx] = elems[idx]->x = value;
}
value++;
}
- permutation_cnt = 1;
- extract_values (&list, old_values, cnt);
+ n_permutations = 1;
+ extract_values (&list, old_values, n_elems);
while (llx_next_permutation (llx_head (&list), llx_null (&list),
- compare_elements, &aux_data))
+ compare_elements, &aux_data))
{
- extract_values (&list, new_values, cnt);
- check (lexicographical_compare_3way (new_values, cnt,
- old_values, cnt,
+ extract_values (&list, new_values, n_elems);
+ check (lexicographical_compare_3way (new_values, n_elems,
+ old_values, n_elems,
sizeof *new_values,
compare_ints, NULL) > 0);
- memcpy (old_values, new_values, cnt * sizeof *old_values);
- permutation_cnt++;
+ memcpy (old_values, new_values, n_elems * sizeof *old_values);
+ n_permutations++;
}
- check (permutation_cnt == expected_perms (values, cnt));
- check_list_contents (&list, values, cnt);
+ check (n_permutations == expected_perms (values, n_elems));
+ check_list_contents (&list, values, n_elems);
- permutation_cnt = 1;
+ n_permutations = 1;
llx_reverse (llx_head (&list), llx_null (&list));
- extract_values (&list, old_values, cnt);
+ extract_values (&list, old_values, n_elems);
while (llx_prev_permutation (llx_head (&list), llx_null (&list),
- compare_elements, &aux_data))
+ compare_elements, &aux_data))
{
- extract_values (&list, new_values, cnt);
- check (lexicographical_compare_3way (new_values, cnt,
- old_values, cnt,
+ extract_values (&list, new_values, n_elems);
+ check (lexicographical_compare_3way (new_values, n_elems,
+ old_values, n_elems,
sizeof *new_values,
compare_ints, NULL) < 0);
- permutation_cnt++;
+ n_permutations++;
}
llx_reverse (llx_head (&list), llx_null (&list));
- check (permutation_cnt == expected_perms (values, cnt));
- check_list_contents (&list, values, cnt);
+ check (n_permutations == expected_perms (values, n_elems));
+ check_list_contents (&list, values, n_elems);
- free_elements (cnt, &list, elems, elemp, values);
+ free_elements (n_elems, &list, elems, elemp, values);
free (old_values);
free (new_values);
}
@@ -1426,15 +1445,15 @@ test_permutations_with_dups (void)
/* Tests llx_merge when no equal values are to be merged. */
static void
-test_merge_no_dups (void)
+test_merge_no_dups (void)
{
const int max_elems = 8;
const int max_fillxer = 3;
- int merge_cnt, pattern, pfx, gap, sfx, order;
-
- for (merge_cnt = 0; merge_cnt < max_elems; merge_cnt++)
- for (pattern = 0; pattern <= (1 << merge_cnt); pattern++)
+ int n_merges, pattern, pfx, gap, sfx, order;
+
+ for (n_merges = 0; n_merges < max_elems; n_merges++)
+ for (pattern = 0; pattern <= (1 << n_merges); pattern++)
for (pfx = 0; pfx < max_fillxer; pfx++)
for (gap = 0; gap < max_fillxer; gap++)
for (sfx = 0; sfx < max_fillxer; sfx++)
@@ -1445,46 +1464,46 @@ test_merge_no_dups (void)
struct llx **elemp;
int *values;
- int list_cnt = pfx + merge_cnt + gap + sfx;
+ int n_lists = pfx + n_merges + gap + sfx;
int a0, a1, b0, b1;
int i, j;
- allocate_elements (list_cnt, &list,
+ allocate_elements (n_lists, &list,
&elems, &elemp, &values);
j = 0;
for (i = 0; i < pfx; i++)
elems[j++]->x = 100 + i;
a0 = j;
- for (i = 0; i < merge_cnt; i++)
+ for (i = 0; i < n_merges; i++)
if (pattern & (1u << i))
elems[j++]->x = i;
a1 = j;
for (i = 0; i < gap; i++)
elems[j++]->x = 200 + i;
b0 = j;
- for (i = 0; i < merge_cnt; i++)
+ for (i = 0; i < n_merges; i++)
if (!(pattern & (1u << i)))
elems[j++]->x = i;
b1 = j;
for (i = 0; i < sfx; i++)
elems[j++]->x = 300 + i;
- check (list_cnt == j);
+ check (n_lists == j);
j = 0;
for (i = 0; i < pfx; i++)
values[j++] = 100 + i;
if (order == 0)
- for (i = 0; i < merge_cnt; i++)
+ for (i = 0; i < n_merges; i++)
values[j++] = i;
for (i = 0; i < gap; i++)
values[j++] = 200 + i;
if (order == 1)
- for (i = 0; i < merge_cnt; i++)
+ for (i = 0; i < n_merges; i++)
values[j++] = i;
for (i = 0; i < sfx; i++)
values[j++] = 300 + i;
- check (list_cnt == j);
+ check (n_lists == j);
if (order == 0)
llx_merge (elemp[a0], elemp[a1], elemp[b0], elemp[b1],
@@ -1493,23 +1512,23 @@ test_merge_no_dups (void)
llx_merge (elemp[b0], elemp[b1], elemp[a0], elemp[a1],
compare_elements, &aux_data);
- check_list_contents (&list, values, list_cnt);
+ check_list_contents (&list, values, n_lists);
- free_elements (list_cnt, &list, elems, elemp, values);
+ free_elements (n_lists, &list, elems, elemp, values);
}
}
/* Tests llx_merge when equal values are to be merged. */
static void
-test_merge_with_dups (void)
+test_merge_with_dups (void)
{
const int max_elems = 8;
- int cnt, merge_pat, inc_pat, order;
-
- for (cnt = 0; cnt <= max_elems; cnt++)
- for (merge_pat = 0; merge_pat <= (1 << cnt); merge_pat++)
- for (inc_pat = 0; inc_pat <= (1 << cnt); inc_pat++)
+ int n, merge_pat, inc_pat, order;
+
+ for (n = 0; n <= max_elems; n++)
+ for (merge_pat = 0; merge_pat <= (1 << n); merge_pat++)
+ for (inc_pat = 0; inc_pat <= (1 << n); inc_pat++)
for (order = 0; order < 2; order++)
{
struct llx_list list;
@@ -1520,72 +1539,72 @@ test_merge_with_dups (void)
int mid;
int i, j, k;
- allocate_elements (cnt, &list, &elems, &elemp, &values);
+ allocate_elements (n, &list, &elems, &elemp, &values);
j = 0;
- for (i = k = 0; i < cnt; i++)
+ for (i = k = 0; i < n; i++)
{
- if (merge_pat & (1u << i))
+ if (merge_pat & (1u << i))
elems[j++]->x = k;
if (inc_pat & (1u << i))
k++;
}
mid = j;
- for (i = k = 0; i < cnt; i++)
+ for (i = k = 0; i < n; i++)
{
- if (!(merge_pat & (1u << i)))
+ if (!(merge_pat & (1u << i)))
elems[j++]->x = k;
if (inc_pat & (1u << i))
k++;
}
- check (cnt == j);
+ check (n == j);
- if (order == 0)
+ if (order == 0)
{
- for (i = 0; i < cnt; i++)
- elems[i]->y = i;
+ for (i = 0; i < n; i++)
+ elems[i]->y = i;
}
- else
+ else
{
for (i = 0; i < mid; i++)
elems[i]->y = 100 + i;
- for (i = mid; i < cnt; i++)
+ for (i = mid; i < n; i++)
elems[i]->y = i;
}
j = 0;
- for (i = k = 0; i < cnt; i++)
+ for (i = k = 0; i < n; i++)
{
values[j++] = k;
if (inc_pat & (1u << i))
- k++;
+ k++;
}
- check (cnt == j);
+ check (n == j);
if (order == 0)
- llx_merge (elemp[0], elemp[mid], elemp[mid], elemp[cnt],
+ llx_merge (elemp[0], elemp[mid], elemp[mid], elemp[n],
compare_elements, &aux_data);
else
- llx_merge (elemp[mid], elemp[cnt], elemp[0], elemp[mid],
+ llx_merge (elemp[mid], elemp[n], elemp[0], elemp[mid],
compare_elements, &aux_data);
- check_list_contents (&list, values, cnt);
+ check_list_contents (&list, values, n);
check (llx_is_sorted (llx_head (&list), llx_null (&list),
compare_elements_x_y, &aux_data));
- free_elements (cnt, &list, elems, elemp, values);
+ free_elements (n, &list, elems, elemp, values);
}
}
/* Tests llx_sort on all permutations up to a maximum number of
elements. */
static void
-test_sort_exhaustive (void)
+test_sort_exhaustive (void)
{
const int max_elems = 8;
- int cnt;
+ int n;
- for (cnt = 0; cnt <= max_elems; cnt++)
+ for (n = 0; n <= max_elems; n++)
{
struct llx_list list;
struct element **elems;
@@ -1594,50 +1613,50 @@ test_sort_exhaustive (void)
struct element **perm_elems;
int *perm_values;
- size_t perm_cnt;
+ size_t n_perms;
- allocate_ascending (cnt, &list, &elems, NULL, &values);
- allocate_elements (cnt, NULL, &perm_elems, NULL, &perm_values);
+ allocate_ascending (n, &list, &elems, NULL, &values);
+ allocate_elements (n, NULL, &perm_elems, NULL, &perm_values);
- perm_cnt = 1;
+ n_perms = 1;
while (llx_next_permutation (llx_head (&list), llx_null (&list),
- compare_elements, &aux_data))
+ compare_elements, &aux_data))
{
struct llx_list perm_list;
int j;
- extract_values (&list, perm_values, cnt);
+ extract_values (&list, perm_values, n);
llx_init (&perm_list);
- for (j = 0; j < cnt; j++)
- {
+ for (j = 0; j < n; j++)
+ {
perm_elems[j]->x = perm_values[j];
llx_push_tail (&perm_list, perm_elems[j], &llx_malloc_mgr);
}
llx_sort (llx_head (&perm_list), llx_null (&perm_list),
compare_elements, &aux_data);
- check_list_contents (&perm_list, values, cnt);
+ check_list_contents (&perm_list, values, n);
check (llx_is_sorted (llx_head (&perm_list), llx_null (&perm_list),
compare_elements, &aux_data));
llx_destroy (&perm_list, NULL, NULL, &llx_malloc_mgr);
- perm_cnt++;
+ n_perms++;
}
- check (perm_cnt == factorial (cnt));
+ check (n_perms == factorial (n));
- free_elements (cnt, &list, elems, NULL, values);
- free_elements (cnt, NULL, perm_elems, NULL, perm_values);
+ free_elements (n, &list, elems, NULL, values);
+ free_elements (n, NULL, perm_elems, NULL, perm_values);
}
}
/* Tests that llx_sort is stable in the presence of equal
values. */
static void
-test_sort_stable (void)
+test_sort_stable (void)
{
const int max_elems = 6;
- int cnt, inc_pat;
+ int n, inc_pat;
- for (cnt = 0; cnt <= max_elems; cnt++)
- for (inc_pat = 0; inc_pat <= 1 << cnt; inc_pat++)
+ for (n = 0; n <= max_elems; n++)
+ for (inc_pat = 0; inc_pat <= 1 << n; inc_pat++)
{
struct llx_list list;
struct element **elems;
@@ -1646,14 +1665,14 @@ test_sort_stable (void)
struct element **perm_elems;
int *perm_values;
- size_t perm_cnt;
+ size_t n_perms;
int i, j;
- allocate_elements (cnt, &list, &elems, NULL, &values);
- allocate_elements (cnt, NULL, &perm_elems, NULL, &perm_values);
+ allocate_elements (n, &list, &elems, NULL, &values);
+ allocate_elements (n, NULL, &perm_elems, NULL, &perm_values);
j = 0;
- for (i = 0; i < cnt; i++)
+ for (i = 0; i < n; i++)
{
elems[i]->x = values[i] = j;
if (inc_pat & (1 << i))
@@ -1661,32 +1680,32 @@ test_sort_stable (void)
elems[i]->y = i;
}
- perm_cnt = 1;
+ n_perms = 1;
while (llx_next_permutation (llx_head (&list), llx_null (&list),
- compare_elements_y, &aux_data))
+ compare_elements_y, &aux_data))
{
struct llx_list perm_list;
- extract_values (&list, perm_values, cnt);
+ extract_values (&list, perm_values, n);
llx_init (&perm_list);
- for (i = 0; i < cnt; i++)
- {
+ for (i = 0; i < n; i++)
+ {
perm_elems[i]->x = perm_values[i];
perm_elems[i]->y = i;
llx_push_tail (&perm_list, perm_elems[i], &llx_malloc_mgr);
}
llx_sort (llx_head (&perm_list), llx_null (&perm_list),
compare_elements, &aux_data);
- check_list_contents (&perm_list, values, cnt);
+ check_list_contents (&perm_list, values, n);
check (llx_is_sorted (llx_head (&perm_list), llx_null (&perm_list),
compare_elements_x_y, &aux_data));
llx_destroy (&perm_list, NULL, NULL, &llx_malloc_mgr);
- perm_cnt++;
+ n_perms++;
}
- check (perm_cnt == factorial (cnt));
+ check (n_perms == factorial (n));
- free_elements (cnt, &list, elems, NULL, values);
- free_elements (cnt, NULL, perm_elems, NULL, perm_values);
+ free_elements (n, &list, elems, NULL, values);
+ free_elements (n, NULL, perm_elems, NULL, perm_values);
}
}
@@ -1697,25 +1716,25 @@ test_sort_subset (void)
{
const int max_elems = 8;
- int cnt, r0, r1, repeat;
+ int n, r0, r1, repeat;
- for (cnt = 0; cnt <= max_elems; cnt++)
+ for (n = 0; n <= max_elems; n++)
for (repeat = 0; repeat < 100; repeat++)
- for (r0 = 0; r0 <= cnt; r0++)
- for (r1 = r0; r1 <= cnt; r1++)
+ for (r0 = 0; r0 <= n; r0++)
+ for (r1 = r0; r1 <= n; r1++)
{
struct llx_list list;
struct element **elems;
struct llx **elemp;
int *values;
- allocate_random (cnt, &list, &elems, &elemp, &values);
+ allocate_random (n, &list, &elems, &elemp, &values);
qsort (&values[r0], r1 - r0, sizeof *values, compare_ints_noaux);
llx_sort (elemp[r0], elemp[r1], compare_elements, &aux_data);
- check_list_contents (&list, values, cnt);
+ check_list_contents (&list, values, n);
- free_elements (cnt, &list, elems, elemp, values);
+ free_elements (n, &list, elems, elemp, values);
}
}
@@ -1725,55 +1744,55 @@ test_sort_big (void)
{
const int max_elems = 1024;
- int cnt;
+ int n;
- for (cnt = 0; cnt < max_elems; cnt++)
+ for (n = 0; n < max_elems; n++)
{
struct llx_list list;
struct element **elems;
int *values;
- allocate_random (cnt, &list, &elems, NULL, &values);
+ allocate_random (n, &list, &elems, NULL, &values);
- qsort (values, cnt, sizeof *values, compare_ints_noaux);
+ qsort (values, n, sizeof *values, compare_ints_noaux);
llx_sort (llx_head (&list), llx_null (&list), compare_elements, &aux_data);
- check_list_contents (&list, values, cnt);
+ check_list_contents (&list, values, n);
- free_elements (cnt, &list, elems, NULL, values);
+ free_elements (n, &list, elems, NULL, values);
}
}
/* Tests llx_unique. */
static void
-test_unique (void)
+test_unique (void)
{
const int max_elems = 10;
int *ascending = xnmalloc (max_elems, sizeof *ascending);
- int cnt, inc_pat, i, j, unique_values;
+ int n, inc_pat, i, j, unique_values;
for (i = 0; i < max_elems; i++)
ascending[i] = i;
- for (cnt = 0; cnt < max_elems; cnt++)
- for (inc_pat = 0; inc_pat < (1 << cnt); inc_pat++)
+ for (n = 0; n < max_elems; n++)
+ for (inc_pat = 0; inc_pat < (1 << n); inc_pat++)
{
struct llx_list list, dups;
struct element **elems;
int *values;
- allocate_elements (cnt, &list, &elems, NULL, &values);
+ allocate_elements (n, &list, &elems, NULL, &values);
j = unique_values = 0;
- for (i = 0; i < cnt; i++)
+ for (i = 0; i < n; i++)
{
unique_values = j + 1;
elems[i]->x = values[i] = j;
if (inc_pat & (1 << i))
j++;
}
- check_list_contents (&list, values, cnt);
+ check_list_contents (&list, values, n);
llx_init (&dups);
check (llx_unique (llx_head (&list), llx_null (&list),
@@ -1785,10 +1804,10 @@ test_unique (void)
llx_splice (llx_null (&list), llx_head (&dups), llx_null (&dups));
llx_sort (llx_head (&list), llx_null (&list), compare_elements, &aux_data);
- check_list_contents (&list, values, cnt);
+ check_list_contents (&list, values, n);
llx_destroy (&dups, NULL, NULL, &llx_malloc_mgr);
- free_elements (cnt, &list, elems, NULL, values);
+ free_elements (n, &list, elems, NULL, values);
}
free (ascending);
@@ -1796,13 +1815,13 @@ test_unique (void)
/* Tests llx_sort_unique. */
static void
-test_sort_unique (void)
+test_sort_unique (void)
{
const int max_elems = 7;
- int cnt, inc_pat;
+ int n, inc_pat;
- for (cnt = 0; cnt <= max_elems; cnt++)
- for (inc_pat = 0; inc_pat <= 1 << cnt; inc_pat++)
+ for (n = 0; n <= max_elems; n++)
+ for (inc_pat = 0; inc_pat <= 1 << n; inc_pat++)
{
struct llx_list list;
struct element **elems;
@@ -1811,38 +1830,38 @@ test_sort_unique (void)
struct element **perm_elems;
int *perm_values;
- int unique_cnt;
+ int n_uniques;
int *unique_values;
- size_t perm_cnt;
+ size_t n_perms;
int i, j;
- allocate_elements (cnt, &list, &elems, NULL, &values);
- allocate_elements (cnt, NULL, &perm_elems, NULL, &perm_values);
+ allocate_elements (n, &list, &elems, NULL, &values);
+ allocate_elements (n, NULL, &perm_elems, NULL, &perm_values);
- j = unique_cnt = 0;
- for (i = 0; i < cnt; i++)
+ j = n_uniques = 0;
+ for (i = 0; i < n; i++)
{
elems[i]->x = values[i] = j;
- unique_cnt = j + 1;
+ n_uniques = j + 1;
if (inc_pat & (1 << i))
j++;
}
- unique_values = xnmalloc (unique_cnt, sizeof *unique_values);
- for (i = 0; i < unique_cnt; i++)
+ unique_values = xnmalloc (n_uniques, sizeof *unique_values);
+ for (i = 0; i < n_uniques; i++)
unique_values[i] = i;
- perm_cnt = 1;
+ n_perms = 1;
while (llx_next_permutation (llx_head (&list), llx_null (&list),
- compare_elements, &aux_data))
+ compare_elements, &aux_data))
{
struct llx_list perm_list;
- extract_values (&list, perm_values, cnt);
+ extract_values (&list, perm_values, n);
llx_init (&perm_list);
- for (i = 0; i < cnt; i++)
- {
+ for (i = 0; i < n; i++)
+ {
perm_elems[i]->x = perm_values[i];
perm_elems[i]->y = i;
llx_push_tail (&perm_list, perm_elems[i], &llx_malloc_mgr);
@@ -1850,29 +1869,29 @@ test_sort_unique (void)
llx_sort_unique (llx_head (&perm_list), llx_null (&perm_list), NULL,
compare_elements, &aux_data,
&llx_malloc_mgr);
- check_list_contents (&perm_list, unique_values, unique_cnt);
+ check_list_contents (&perm_list, unique_values, n_uniques);
check (llx_is_sorted (llx_head (&perm_list), llx_null (&perm_list),
compare_elements_x_y, &aux_data));
llx_destroy (&perm_list, NULL, NULL, &llx_malloc_mgr);
- perm_cnt++;
+ n_perms++;
}
- check (perm_cnt == expected_perms (values, cnt));
-
- free_elements (cnt, &list, elems, NULL, values);
- free_elements (cnt, NULL, perm_elems, NULL, perm_values);
+ check (n_perms == expected_perms (values, n));
+
+ free_elements (n, &list, elems, NULL, values);
+ free_elements (n, NULL, perm_elems, NULL, perm_values);
free (unique_values);
}
}
/* Tests llx_insert_ordered. */
static void
-test_insert_ordered (void)
+test_insert_ordered (void)
{
const int max_elems = 6;
- int cnt, inc_pat;
+ int n, inc_pat;
- for (cnt = 0; cnt <= max_elems; cnt++)
- for (inc_pat = 0; inc_pat <= 1 << cnt; inc_pat++)
+ for (n = 0; n <= max_elems; n++)
+ for (inc_pat = 0; inc_pat <= 1 << n; inc_pat++)
{
struct llx_list list;
struct element **elems;
@@ -1881,14 +1900,14 @@ test_insert_ordered (void)
struct element **perm_elems;
int *perm_values;
- size_t perm_cnt;
+ size_t n_perms;
int i, j;
- allocate_elements (cnt, &list, &elems, NULL, &values);
- allocate_elements (cnt, NULL, &perm_elems, NULL, &perm_values);
+ allocate_elements (n, &list, &elems, NULL, &values);
+ allocate_elements (n, NULL, &perm_elems, NULL, &perm_values);
j = 0;
- for (i = 0; i < cnt; i++)
+ for (i = 0; i < n; i++)
{
elems[i]->x = values[i] = j;
if (inc_pat & (1 << i))
@@ -1896,16 +1915,16 @@ test_insert_ordered (void)
elems[i]->y = i;
}
- perm_cnt = 1;
+ n_perms = 1;
while (llx_next_permutation (llx_head (&list), llx_null (&list),
- compare_elements_y, &aux_data))
+ compare_elements_y, &aux_data))
{
struct llx_list perm_list;
- extract_values (&list, perm_values, cnt);
+ extract_values (&list, perm_values, n);
llx_init (&perm_list);
- for (i = 0; i < cnt; i++)
- {
+ for (i = 0; i < n; i++)
+ {
perm_elems[i]->x = perm_values[i];
perm_elems[i]->y = i;
llx_insert_ordered (llx_head (&perm_list),
@@ -1917,12 +1936,12 @@ test_insert_ordered (void)
check (llx_is_sorted (llx_head (&perm_list), llx_null (&perm_list),
compare_elements_x_y, &aux_data));
llx_destroy (&perm_list, NULL, NULL, &llx_malloc_mgr);
- perm_cnt++;
+ n_perms++;
}
- check (perm_cnt == factorial (cnt));
+ check (n_perms == factorial (n));
- free_elements (cnt, &list, elems, NULL, values);
- free_elements (cnt, NULL, perm_elems, NULL, perm_values);
+ free_elements (n, &list, elems, NULL, values);
+ free_elements (n, NULL, perm_elems, NULL, perm_values);
}
}
@@ -1931,14 +1950,14 @@ static void
test_partition (void)
{
const int max_elems = 10;
-
- int cnt;
+
+ int n;
unsigned int pbase;
int r0, r1;
- for (cnt = 0; cnt < max_elems; cnt++)
- for (r0 = 0; r0 <= cnt; r0++)
- for (r1 = r0; r1 <= cnt; r1++)
+ for (n = 0; n < max_elems; n++)
+ for (r0 = 0; r0 <= n; r0++)
+ for (r1 = r0; r1 <= n; r1++)
for (pbase = 0; pbase <= (1u << (r1 - r0)); pbase++)
{
struct llx_list list;
@@ -1950,8 +1969,8 @@ test_partition (void)
int i, j;
int first_false;
struct llx *part_llx;
-
- allocate_ascending (cnt, &list, &elems, &elemp, &values);
+
+ allocate_ascending (n, &list, &elems, &elemp, &values);
/* Check that llx_find_partition works okay in every
case. We use it after partitioning, too, but that
@@ -1961,12 +1980,12 @@ test_partition (void)
break;
j = i;
for (; i < r1; i++)
- if (pattern & (1u << i))
+ if (pattern & (1u << i))
break;
part_llx = llx_find_partition (elemp[r0], elemp[r1],
pattern_pred,
&pattern);
- if (i == r1)
+ if (i == r1)
check (part_llx == elemp[j]);
else
check (part_llx == NULL);
@@ -1984,13 +2003,13 @@ test_partition (void)
{
if (first_false == -1)
first_false = i;
- values[j++] = i;
+ values[j++] = i;
}
if (first_false == -1)
first_false = r1;
- for (i = r1; i < cnt; i++)
+ for (i = r1; i < n; i++)
values[j++] = i;
- check (j == cnt);
+ check (j == n);
/* Partition and check for expected results. */
check (llx_partition (elemp[r0], elemp[r1],
@@ -1999,79 +2018,231 @@ test_partition (void)
check (llx_find_partition (elemp[r0], elemp[r1],
pattern_pred, &pattern)
== elemp[first_false]);
- check_list_contents (&list, values, cnt);
- check ((int) llx_count (&list) == cnt);
+ check_list_contents (&list, values, n);
+ check ((int) llx_count (&list) == n);
- free_elements (cnt, &list, elems, elemp, values);
+ free_elements (n, &list, elems, elemp, values);
}
}
/* Tests that allocation failure is gracefully handled. */
static void
-test_allocation_failure (void)
+test_allocation_failure (void)
{
struct llx_list list;
llx_init (&list);
- check (llx_push_head (&list, NULL, &llx_null_mgr) == NULL);
- check (llx_push_tail (&list, NULL, &llx_null_mgr) == NULL);
- check (llx_insert (llx_null (&list), NULL, &llx_null_mgr) == NULL);
+ check (llx_push_head (&list, NULL, &llx_null_mgr) == NULL);
+ check (llx_push_tail (&list, NULL, &llx_null_mgr) == NULL);
+ check (llx_insert (llx_null (&list), NULL, &llx_null_mgr) == NULL);
check_list_contents (&list, NULL, 0);
}
/* 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[] =
+ {
+ {
+ "push-pop",
+ "push/pop",
+ test_push_pop
+ },
+ {
+ "insert-remove",
+ "insert/remove",
+ test_insert_remove
+ },
+ {
+ "swap",
+ "swap",
+ test_swap
+ },
+ {
+ "swap-range",
+ "swap_range",
+ test_swap_range
+ },
+ {
+ "remove-range",
+ "remove_range",
+ test_remove_range
+ },
+ {
+ "remove-equal",
+ "remove_equal",
+ test_remove_equal
+ },
+ {
+ "remove-if",
+ "remove_if",
+ test_remove_if
+ },
+ {
+ "find-equal",
+ "find_equal",
+ test_find_equal
+ },
+ {
+ "find",
+ "find",
+ test_find
+ },
+ {
+ "find-if",
+ "find_if",
+ test_find_if
+ },
+ {
+ "find-adjacent-equal",
+ "find_adjacent_equal",
+ test_find_adjacent_equal
+ },
+ {
+ "count-range",
+ "count_range",
+ test_count_range
+ },
+ {
+ "count-equal",
+ "count_equal",
+ test_count_equal
+ },
+ {
+ "count-if",
+ "count_if",
+ test_count_if
+ },
+ {
+ "min-max",
+ "min/max",
+ test_min_max
+ },
+ {
+ "lexicographical-compare-3way",
+ "lexicographical_compare_3way",
+ test_lexicographical_compare_3way
+ },
+ {
+ "apply",
+ "apply",
+ test_apply
+ },
+ {
+ "destroy",
+ "destroy",
+ test_destroy
+ },
+ {
+ "reverse",
+ "reverse",
+ test_reverse
+ },
+ {
+ "permutations-no-dups",
+ "permutations (no dups)",
+ test_permutations_no_dups
+ },
+ {
+ "permutations-with-dups",
+ "permutations (with dups)",
+ test_permutations_with_dups
+ },
+ {
+ "merge-no-dups",
+ "merge (no dups)",
+ test_merge_no_dups
+ },
+ {
+ "merge-with-dups",
+ "merge (with dups)",
+ test_merge_with_dups
+ },
+ {
+ "sort-exhaustive",
+ "sort (exhaustive)",
+ test_sort_exhaustive
+ },
+ {
+ "sort-stable",
+ "sort (stability)",
+ test_sort_stable
+ },
+ {
+ "sort-subset",
+ "sort (subset)",
+ test_sort_subset
+ },
+ {
+ "sort-big",
+ "sort (big)",
+ test_sort_big
+ },
+ {
+ "unique",
+ "unique",
+ test_unique
+ },
+ {
+ "sort-unique",
+ "sort_unique",
+ test_sort_unique
+ },
+ {
+ "insert-ordered",
+ "insert_ordered",
+ test_insert_ordered
+ },
+ {
+ "partition",
+ "partition",
+ test_partition
+ },
+ {
+ "allocation-failure",
+ "allocation failure",
+ test_allocation_failure
+ },
+ };
+
+enum { N_TESTS = sizeof tests / sizeof *tests };
int
-main (void)
-{
- run_test (test_push_pop, "push/pop");
- run_test (test_insert_remove, "insert/remove");
- run_test (test_swap, "swap");
- run_test (test_swap_range, "swap_range");
- run_test (test_remove_range, "remove_range");
- run_test (test_remove_equal, "remove_equal");
- run_test (test_remove_if, "remove_if");
- run_test (test_find_equal, "find_equal");
- run_test (test_find_if, "find_if");
- run_test (test_find_adjacent_equal, "find_adjacent_equal");
- run_test (test_count_range, "count_range");
- run_test (test_count_equal, "count_equal");
- run_test (test_count_if, "count_if");
- run_test (test_min_max, "min/max");
- run_test (test_lexicographical_compare_3way, "lexicographical_compare_3way");
- run_test (test_apply, "apply");
- run_test (test_destroy, "destroy");
- run_test (test_reverse, "reverse");
- run_test (test_permutations_no_dups, "permutations (no dups)");
- run_test (test_permutations_with_dups, "permutations (with dups)");
- run_test (test_merge_no_dups, "merge (no dups)");
- run_test (test_merge_with_dups, "merge (with dups)");
- run_test (test_sort_exhaustive, "sort (exhaustive)");
- run_test (test_sort_stable, "sort (stability)");
- run_test (test_sort_subset, "sort (subset)");
- run_test (test_sort_big, "sort (big)");
- run_test (test_unique, "unique");
- run_test (test_sort_unique, "sort_unique");
- run_test (test_insert_ordered, "insert_ordered");
- run_test (test_partition, "partition");
- run_test (test_allocation_failure, "allocation failure");
- putchar ('\n');
-
- return 0;
-}
-
-/*
- Local Variables:
- compile-command: "gcc -Wall -Wstrict-prototypes -Wmissing-prototypes ll.c llx.c llx-test.c -o llx-test -g"
- End:
- */
+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 doubly linked list of pointers (llx) library\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;
+ }
+}