X-Git-Url: https://pintos-os.org/cgi-bin/gitweb.cgi?a=blobdiff_plain;f=tests%2Flibpspp%2Fll-test.c;h=0d501a85046fba925cd87965d9364508ffb1a820;hb=339f1956cc727eda788638644ef93ab7852b31cd;hp=353787b7fd356ea24d6929bddb74d4ad6948082f;hpb=60de513311fdc78a2d9d43f7444e790aeac0f080;p=pspp

diff --git a/tests/libpspp/ll-test.c b/tests/libpspp/ll-test.c
index 353787b7fd..0d501a8504 100644
--- a/tests/libpspp/ll-test.c
+++ b/tests/libpspp/ll-test.c
@@ -1,20 +1,18 @@
-/* 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 <http://www.gnu.org/licenses/>. */
 
 /* This is a test program for the ll_* routines defined in
    ll.c.  This test program aims to be as comprehensive as
@@ -33,7 +31,6 @@
 #endif
 
 #include <libpspp/ll.h>
-#include <assert.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
@@ -45,26 +42,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 ();
     }
 }
@@ -85,9 +78,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)
@@ -101,7 +94,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 ();
@@ -134,7 +127,7 @@ print_list (struct ll_list *list)
   struct ll *x;
 
   printf ("list:");
-  for (x = ll_head (list); x != ll_null (list); x = ll_next (x)) 
+  for (x = ll_head (list); x != ll_null (list); x = ll_next (x))
     {
       struct element *e = ll_to_element (x);
       printf (" %d", e->x);
@@ -146,19 +139,19 @@ print_list (struct ll_list *list)
    AUX for each element in LIST. */
 static void UNUSED
 print_pred (struct ll_list *list,
-            ll_predicate_func *predicate, void *aux UNUSED) 
+            ll_predicate_func *predicate, void *aux UNUSED)
 {
   struct ll *x;
 
   printf ("pred:");
-  for (x = ll_head (list); x != ll_null (list); x = ll_next (x)) 
+  for (x = ll_head (list); x != ll_null (list); x = ll_next (x))
     printf (" %d", predicate (x, aux));
   printf ("\n");
 }
 
 /* Prints the CNT numbers in VALUES. */
 static void UNUSED
-print_array (int values[], size_t cnt) 
+print_array (int values[], size_t cnt)
 {
   size_t i;
 
@@ -171,7 +164,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 struct ll *a_, const struct ll *b_, void *aux) 
+compare_elements (const struct ll *a_, const struct ll *b_, void *aux)
 {
   const struct element *a = ll_to_element (a_);
   const struct element *b = ll_to_element (b_);
@@ -184,7 +177,7 @@ compare_elements (const struct ll *a_, const struct ll *b_, void *aux)
    strcmp-type return value.  Verifies that AUX points to
    aux_data. */
 static int
-compare_elements_x_y (const struct ll *a_, const struct ll *b_, void *aux) 
+compare_elements_x_y (const struct ll *a_, const struct ll *b_, void *aux)
 {
   const struct element *a = ll_to_element (a_);
   const struct element *b = ll_to_element (b_);
@@ -213,7 +206,7 @@ compare_elements_y (const struct ll *a_, const struct ll *b_, void *aux)
 /* Returns true if the bit in *PATTERN indicated by `x in
    *ELEMENT is set, false otherwise. */
 static bool
-pattern_pred (const struct ll *element_, void *pattern_) 
+pattern_pred (const struct ll *element_, void *pattern_)
 {
   const struct element *element = ll_to_element (element_);
   unsigned int *pattern = pattern_;
@@ -233,7 +226,7 @@ allocate_elements (size_t n,
                    struct ll_list *list,
                    struct element ***elems,
                    struct ll ***elemp,
-                   int **values) 
+                   int **values)
 {
   size_t i;
 
@@ -241,33 +234,33 @@ allocate_elements (size_t n,
     ll_init (list);
 
   *elems = xnmalloc (n, sizeof **elems);
-  for (i = 0; i < n; i++) 
+  for (i = 0; i < n; i++)
     {
       (*elems)[i] = xmalloc (sizeof ***elems);
       if (list != NULL)
         ll_push_tail (list, &(*elems)[i]->ll);
     }
-  
-  if (elemp != NULL) 
+
+  if (elemp != NULL)
     {
       *elemp = xnmalloc (n + 1, sizeof *elemp);
       for (i = 0; i < n; i++)
         (*elemp)[i] = &(*elems)[i]->ll;
       (*elemp)[n] = ll_null (list);
     }
-  
+
   if (values != NULL)
     *values = xnmalloc (n, sizeof *values);
 }
 
 /* Copies the CNT values of `x' from LIST into VALUES[]. */
 static void
-extract_values (struct ll_list *list, int values[], size_t cnt) 
+extract_values (struct ll_list *list, int values[], size_t cnt)
 {
   struct ll *x;
-  
+
   check (ll_count (list) == cnt);
-  for (x = ll_head (list); x != ll_null (list); x = ll_next (x)) 
+  for (x = ll_head (list); x != ll_null (list); x = ll_next (x))
     {
       struct element *e = ll_to_element (x);
       *values++ = e->x;
@@ -282,16 +275,16 @@ allocate_ascending (size_t n,
                     struct ll_list *list,
                     struct element ***elems,
                     struct ll ***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
@@ -303,16 +296,16 @@ allocate_pattern (size_t n,
                   struct ll_list *list,
                   struct element ***elems,
                   struct ll ***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
@@ -324,10 +317,10 @@ random_shuffle (void *array_, size_t cnt, size_t size)
   char *tmp = xmalloc (size);
   size_t i;
 
-  for (i = 0; i < cnt; i++) 
+  for (i = 0; i < cnt; i++)
     {
       size_t j = rand () % (cnt - i) + i;
-      if (i != j) 
+      if (i != j)
         {
           memcpy (tmp, array + j * size, size);
           memcpy (array + j * size, array + i * size, size);
@@ -344,17 +337,17 @@ allocate_random (size_t n,
                  struct ll_list *list,
                  struct element ***elems,
                  struct ll ***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 the N elements of ELEMS, ELEMP, and VALUES. */
@@ -362,20 +355,20 @@ static void
 free_elements (size_t n,
                struct element **elems,
                struct ll **elemp,
-               int *values) 
+               int *values)
 {
   size_t i;
 
   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_;
@@ -385,7 +378,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_;
@@ -395,7 +388,7 @@ compare_ints_noaux (const void *a_, const void *b_)
 
 /* Checks that LIST contains the CNT values in ELEMENTS. */
 static void
-check_list_contents (struct ll_list *list, int elements[], size_t cnt) 
+check_list_contents (struct ll_list *list, int elements[], size_t cnt)
 {
   struct ll *ll;
   size_t i;
@@ -403,7 +396,7 @@ check_list_contents (struct ll_list *list, int elements[], size_t cnt)
   check ((cnt == 0) == ll_is_empty (list));
 
   /* Iterate in forward order. */
-  for (ll = ll_head (list), i = 0; i < cnt; ll = ll_next (ll), i++) 
+  for (ll = ll_head (list), i = 0; i < cnt; ll = ll_next (ll), i++)
     {
       struct element *e = ll_to_element (ll);
       check (elements[i] == e->x);
@@ -434,7 +427,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;
@@ -473,7 +466,7 @@ test_push_pop (void)
   /* Push on tail. */
   ll_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;
       ll_push_tail (&list, &elems[i]->ll);
@@ -481,7 +474,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 = ll_to_element (ll_pop_tail (&list));
       check (e->x == max_elems - i - 1);
@@ -498,7 +491,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 = ll_to_element (ll_pop_head (&list));
       check (e->x == (int) i);
@@ -510,12 +503,12 @@ 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;
 
-  for (cnt = 0; cnt < max_elems; cnt++) 
+  for (cnt = 0; cnt < max_elems; cnt++)
     {
       struct element **elems;
       struct ll **elemp;
@@ -527,7 +520,7 @@ test_insert_remove (void)
 
       allocate_ascending (cnt, &list, &elems, &elemp, NULL);
       extra.x = -1;
-      for (pos = 0; pos <= cnt; pos++) 
+      for (pos = 0; pos <= cnt; pos++)
         {
           int i, j;
 
@@ -551,12 +544,12 @@ test_insert_remove (void)
 
 /* Tests swapping individual elements. */
 static void
-test_swap (void) 
+test_swap (void)
 {
   const int max_elems = 8;
   int cnt;
 
-  for (cnt = 0; cnt <= max_elems; cnt++) 
+  for (cnt = 0; cnt <= max_elems; cnt++)
     {
       struct ll_list list;
       struct element **elems;
@@ -567,9 +560,9 @@ test_swap (void)
       allocate_ascending (cnt, &list, &elems, NULL, &values);
       check_list_contents (&list, values, cnt);
 
-      for (i = 0; i < cnt; i++) 
-        for (j = 0; j < cnt; j++) 
-          for (k = 0; k < 2; k++) 
+      for (i = 0; i < cnt; i++)
+        for (j = 0; j < cnt; j++)
+          for (k = 0; k < 2; k++)
             {
               int t;
 
@@ -578,23 +571,23 @@ test_swap (void)
               values[i] = values[j];
               values[j] = t;
               check_list_contents (&list, values, cnt);
-            } 
-  
+            }
+
       free_elements (cnt, elems, NULL, 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;
 
-  for (cnt = 0; cnt <= max_elems; cnt++) 
-    for (a0 = 0; a0 <= cnt; a0++) 
+  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 (b0 = a1; b0 <= cnt; b0++)
           for (b1 = b0; b1 <= cnt; b1++)
             for (r = 0; r < 2; r++)
               {
@@ -633,14 +626,14 @@ test_swap_range (void)
 
 /* 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;
 
   for (cnt = 0; cnt <= max_elems; cnt++)
-    for (r0 = 0; r0 <= cnt; r0++) 
+    for (r0 = 0; r0 <= cnt; r0++)
       for (r1 = r0; r1 <= cnt; r1++)
         {
           struct ll_list list;
@@ -668,7 +661,7 @@ test_remove_range (void)
 
 /* Tests ll_remove_equal. */
 static void
-test_remove_equal (void) 
+test_remove_equal (void)
 {
   const int max_elems = 8;
 
@@ -677,7 +670,7 @@ test_remove_equal (void)
   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 (eq_pat = 0; eq_pat <= 1 << cnt; eq_pat++)
           {
             struct ll_list list;
             struct element **elems;
@@ -691,13 +684,13 @@ test_remove_equal (void)
             allocate_elements (cnt, &list, &elems, &elemp, &values);
 
             remaining = 0;
-            for (i = 0; i < cnt; i++) 
+            for (i = 0; i < cnt; 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;
@@ -712,7 +705,7 @@ test_remove_equal (void)
 
 /* Tests ll_remove_if. */
 static void
-test_remove_if (void) 
+test_remove_if (void)
 {
   const int max_elems = 8;
 
@@ -721,7 +714,7 @@ test_remove_if (void)
   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 (pattern = 0; pattern <= 1 << cnt; pattern++)
           {
             struct ll_list list;
             struct element **elems;
@@ -734,15 +727,15 @@ test_remove_if (void)
             allocate_elements (cnt, &list, &elems, &elemp, &values);
 
             remaining = 0;
-            for (i = 0; i < cnt; i++) 
+            for (i = 0; i < cnt; i++)
               {
                 bool delete = (pattern & (1 << i)) && r0 <= i && i < r1;
                 elems[i]->x = i;
                 if (!delete)
-                  values[remaining++] = i; 
+                  values[remaining++] = i;
               }
 
-            check ((int) ll_remove_if (elemp[r0], elemp[r1], 
+            check ((int) ll_remove_if (elemp[r0], elemp[r1],
                                        pattern_pred, &pattern)
                    == cnt - remaining);
             check_list_contents (&list, values, remaining);
@@ -753,7 +746,7 @@ test_remove_if (void)
 
 /* Tests ll_moved. */
 static void
-test_moved (void) 
+test_moved (void)
 {
   const int max_elems = 8;
 
@@ -772,7 +765,7 @@ test_moved (void)
       allocate_elements (cnt, NULL, &new_elems, NULL, NULL);
       check_list_contents (&list, values, cnt);
 
-      for (i = 0; i < cnt; i++) 
+      for (i = 0; i < cnt; i++)
         {
           *new_elems[i] = *elems[i];
           ll_moved (&new_elems[i]->ll);
@@ -796,7 +789,7 @@ test_examine_equal_range (void (*helper) (int r0, int r1, int eq_pat,
   int cnt, r0, r1, eq_pat;
 
   for (cnt = 0; cnt <= max_elems; cnt++)
-    for (eq_pat = 0; eq_pat <= 1 << cnt; eq_pat++) 
+    for (eq_pat = 0; eq_pat <= 1 << cnt; eq_pat++)
       {
         struct ll_list list;
         struct element **elems;
@@ -835,7 +828,7 @@ test_examine_if_range (void (*helper) (int r0, int r1, int eq_pat,
   int cnt, r0, r1, eq_pat;
 
   for (cnt = 0; cnt <= max_elems; cnt++)
-    for (eq_pat = 0; eq_pat <= 1 << cnt; eq_pat++) 
+    for (eq_pat = 0; eq_pat <= 1 << cnt; eq_pat++)
       {
         struct ll_list list;
         struct element **elems;
@@ -868,12 +861,12 @@ 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 ll_find_equal. */
 static void
-test_find_equal (void) 
+test_find_equal (void)
 {
   test_examine_equal_range (test_find_equal_helper);
 }
@@ -890,26 +883,26 @@ test_find_if_helper (int r0, int r1, int eq_pat, struct ll **elemp)
     if (eq_pat & (1 << i))
       break;
 
-  check (match == elemp[i]); 
+  check (match == elemp[i]);
 }
 
 /* Tests ll_find_if. */
 static void
-test_find_if (void) 
+test_find_if (void)
 {
   test_examine_if_range (test_find_if_helper);
 }
 
 /* Tests ll_find_adjacent_equal. */
 static void
-test_find_adjacent_equal (void) 
+test_find_adjacent_equal (void)
 {
   const int max_elems = 8;
 
   int cnt, eq_pat;
 
   for (cnt = 0; cnt <= max_elems; cnt++)
-    for (eq_pat = 0; eq_pat <= 1 << cnt; eq_pat++) 
+    for (eq_pat = 0; eq_pat <= 1 << cnt; eq_pat++)
       {
         struct ll_list list;
         struct element **elems;
@@ -922,10 +915,10 @@ test_find_adjacent_equal (void)
         allocate_ascending (cnt, &list, &elems, &elemp, &values);
 
         match = -1;
-        for (i = 0; i < cnt - 1; i++) 
+        for (i = 0; i < cnt - 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;
@@ -933,7 +926,7 @@ test_find_adjacent_equal (void)
             else
               match--;
           }
-        
+
         for (i = 0; i <= cnt; i++)
           {
             struct ll *ll1 = ll_find_adjacent_equal (elemp[i], ll_null (&list),
@@ -944,7 +937,7 @@ test_find_adjacent_equal (void)
 
             ll2 = ll_null (&list);
             for (j = i; j < cnt - 1; j++)
-              if (eq_pat & (1 << j)) 
+              if (eq_pat & (1 << j))
                 {
                   ll2 = elemp[j];
                   break;
@@ -966,7 +959,7 @@ test_count_range_helper (int r0, int r1, int eq_pat UNUSED, struct ll **elemp)
 
 /* Tests ll_count_range. */
 static void
-test_count_range (void) 
+test_count_range (void)
 {
   test_examine_if_range (test_count_range_helper);
 }
@@ -985,20 +978,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 ll_count_equal. */
 static void
-test_count_equal (void) 
+test_count_equal (void)
 {
   test_examine_equal_range (test_count_equal_helper);
 }
 
 /* Helper function for testing ll_count_if. */
 static void
-test_count_if_helper (int r0, int r1, int eq_pat, struct ll **elemp) 
+test_count_if_helper (int r0, int r1, int eq_pat, struct ll **elemp)
 {
   int count1;
   int count2;
@@ -1011,19 +1004,19 @@ test_count_if_helper (int r0, int r1, int eq_pat, struct ll **elemp)
     if (eq_pat & (1 << i))
       count2++;
 
-  check (count1 == count2); 
+  check (count1 == count2);
 }
 
 /* Tests ll_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)
@@ -1035,30 +1028,30 @@ factorial (unsigned int n)
    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 cnt)
 {
   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 (cnt);
+  for (i = 0; i < cnt; i = j)
     {
       for (j = i + 1; j < cnt; j++)
         if (values[i] != values[j])
           break;
-      perm_cnt /= factorial (j - i);
+      n_perms /= factorial (j - i);
     }
-  return perm_cnt;
+  return n_perms;
 }
 
 /* Tests ll_min and ll_max. */
 static void
-test_min_max (void) 
+test_min_max (void)
 {
   const int max_elems = 6;
   int cnt;
 
-  for (cnt = 0; cnt <= max_elems; cnt++) 
+  for (cnt = 0; cnt <= max_elems; cnt++)
     {
       struct ll_list list;
       struct element **elems;
@@ -1066,38 +1059,38 @@ test_min_max (void)
       int *values;
       int *new_values = xnmalloc (cnt, sizeof *values);
 
-      size_t perm_cnt;
+      size_t n_perms;
 
       allocate_ascending (cnt, &list, &elems, &elemp, &values);
 
-      perm_cnt = 1;
+      n_perms = 1;
       while (ll_next_permutation (ll_head (&list), ll_null (&list),
-                                  compare_elements, &aux_data)) 
+                                  compare_elements, &aux_data))
         {
           int r0, r1;
           struct ll *x;
           int i;
-          
+
           for (i = 0, x = ll_head (&list); x != ll_null (&list);
-               x = ll_next (x), i++) 
+               x = ll_next (x), i++)
             {
               struct element *e = ll_to_element (x);
               elemp[i] = x;
               new_values[i] = e->x;
             }
           for (r0 = 0; r0 <= cnt; r0++)
-            for (r1 = r0; r1 <= cnt; r1++) 
+            for (r1 = r0; r1 <= cnt; r1++)
               {
                 struct ll *min = ll_min (elemp[r0], elemp[r1],
                                          compare_elements, &aux_data);
                 struct ll *max = ll_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
                   {
                     int min_int, max_int;
                     int i;
@@ -1114,12 +1107,12 @@ test_min_max (void)
                     check (min != elemp[r1]
                            && ll_to_element (min)->x == min_int);
                     check (max != elemp[r1]
-                           && ll_to_element (max)->x == max_int); 
+                           && ll_to_element (max)->x == max_int);
                   }
               }
-          perm_cnt++;
+          n_perms++;
         }
-      check (perm_cnt == factorial (cnt));
+      check (n_perms == factorial (cnt));
       check_list_contents (&list, values, cnt);
 
       free_elements (cnt, elems, elemp, values);
@@ -1129,7 +1122,7 @@ test_min_max (void)
 
 /* Tests ll_lexicographical_compare_3way. */
 static void
-test_lexicographical_compare_3way (void) 
+test_lexicographical_compare_3way (void)
 {
   const int max_elems = 4;
 
@@ -1138,7 +1131,7 @@ test_lexicographical_compare_3way (void)
   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 (pat_b = 0; pat_b <= 1 << cnt_b; pat_b++)
           {
             struct ll_list list_a, list_b;
             struct element **elems_a, **elems_b;
@@ -1169,7 +1162,7 @@ test_lexicographical_compare_3way (void)
                         compare_elements, &aux_data);
 
                       check (a_ordering == b_ordering);
-                    } 
+                    }
 
             free_elements (cnt_a, elems_a, elemp_a, values_a);
             free_elements (cnt_b, elems_b, elemp_b, values_b);
@@ -1179,24 +1172,24 @@ test_lexicographical_compare_3way (void)
 /* 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 (struct ll *e_, void *next_output_) 
+apply_func (struct ll *e_, void *next_output_)
 {
   struct element *e = ll_to_element (e_);
   int **next_output = next_output_;
-  
+
   *(*next_output)++ = e->x;
 }
 
 /* Tests ll_apply. */
 static void
-test_apply (void) 
+test_apply (void)
 {
   const int max_elems = 8;
 
   int cnt, r0, r1;
 
   for (cnt = 0; cnt <= max_elems; cnt++)
-    for (r0 = 0; r0 <= cnt; r0++) 
+    for (r0 = 0; r0 <= cnt; r0++)
       for (r1 = r0; r1 <= cnt; r1++)
         {
           struct ll_list list;
@@ -1227,14 +1220,14 @@ test_apply (void)
 
 /* Tests ll_reverse. */
 static void
-test_reverse (void) 
+test_reverse (void)
 {
   const int max_elems = 8;
 
   int cnt, r0, r1;
 
   for (cnt = 0; cnt <= max_elems; cnt++)
-    for (r0 = 0; r0 <= cnt; r0++) 
+    for (r0 = 0; r0 <= cnt; r0++)
       for (r1 = r0; r1 <= cnt; r1++)
         {
           struct ll_list list;
@@ -1265,12 +1258,12 @@ test_reverse (void)
 /* Tests ll_next_permutation and ll_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;
 
-  for (cnt = 0; cnt <= max_elems; cnt++) 
+  for (cnt = 0; cnt <= max_elems; cnt++)
     {
       struct ll_list list;
       struct element **elems;
@@ -1278,14 +1271,14 @@ test_permutations_no_dups (void)
       int *old_values = xnmalloc (cnt, sizeof *values);
       int *new_values = xnmalloc (cnt, sizeof *values);
 
-      size_t perm_cnt;
+      size_t n_perms;
 
       allocate_ascending (cnt, &list, &elems, NULL, &values);
 
-      perm_cnt = 1;
+      n_perms = 1;
       extract_values (&list, old_values, cnt);
       while (ll_next_permutation (ll_head (&list), ll_null (&list),
-                                  compare_elements, &aux_data)) 
+                                  compare_elements, &aux_data))
         {
           extract_values (&list, new_values, cnt);
           check (lexicographical_compare_3way (new_values, cnt,
@@ -1293,16 +1286,16 @@ test_permutations_no_dups (void)
                                                sizeof *new_values,
                                                compare_ints, NULL) > 0);
           memcpy (old_values, new_values, (cnt) * sizeof *old_values);
-          perm_cnt++;
+          n_perms++;
         }
-      check (perm_cnt == factorial (cnt));
+      check (n_perms == factorial (cnt));
       check_list_contents (&list, values, cnt);
 
-      perm_cnt = 1;
+      n_perms = 1;
       ll_reverse (ll_head (&list), ll_null (&list));
       extract_values (&list, old_values, cnt);
       while (ll_prev_permutation (ll_head (&list), ll_null (&list),
-                                  compare_elements, &aux_data)) 
+                                  compare_elements, &aux_data))
         {
           extract_values (&list, new_values, cnt);
           check (lexicographical_compare_3way (new_values, cnt,
@@ -1310,9 +1303,9 @@ test_permutations_no_dups (void)
                                                sizeof *new_values,
                                                compare_ints, NULL) < 0);
           memcpy (old_values, new_values, (cnt) * sizeof *old_values);
-          perm_cnt++;
+          n_perms++;
         }
-      check (perm_cnt == factorial (cnt));
+      check (n_perms == factorial (cnt));
       ll_reverse (ll_head (&list), ll_null (&list));
       check_list_contents (&list, values, cnt);
 
@@ -1325,7 +1318,7 @@ test_permutations_no_dups (void)
 /* Tests ll_next_permutation and ll_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;
@@ -1334,7 +1327,7 @@ test_permutations_with_dups (void)
   int cnt, repeat;
 
   for (repeat = 0; repeat < repetitions; repeat++)
-    for (cnt = 0; cnt < max_elems; cnt++) 
+    for (cnt = 0; cnt < max_elems; cnt++)
       {
         struct ll_list list;
         struct element **elems;
@@ -1342,10 +1335,10 @@ 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;
+        unsigned int n_permutations;
         int left = cnt;
         int value = 0;
-      
+
         allocate_elements (cnt, &list, &elems, NULL, &values);
 
         value = 0;
@@ -1361,10 +1354,10 @@ test_permutations_with_dups (void)
             value++;
           }
 
-        permutation_cnt = 1;
+        n_permutations = 1;
         extract_values (&list, old_values, cnt);
         while (ll_next_permutation (ll_head (&list), ll_null (&list),
-                                    compare_elements, &aux_data)) 
+                                    compare_elements, &aux_data))
           {
             extract_values (&list, new_values, cnt);
             check (lexicographical_compare_3way (new_values, cnt,
@@ -1372,26 +1365,26 @@ test_permutations_with_dups (void)
                                                  sizeof *new_values,
                                                  compare_ints, NULL) > 0);
             memcpy (old_values, new_values, cnt * sizeof *old_values);
-            permutation_cnt++;
+            n_permutations++;
           }
-        check (permutation_cnt == expected_perms (values, cnt));
+        check (n_permutations == expected_perms (values, cnt));
         check_list_contents (&list, values, cnt);
 
-        permutation_cnt = 1;
+        n_permutations = 1;
         ll_reverse (ll_head (&list), ll_null (&list));
         extract_values (&list, old_values, cnt);
         while (ll_prev_permutation (ll_head (&list), ll_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,
                                                  sizeof *new_values,
                                                  compare_ints, NULL) < 0);
-            permutation_cnt++;
+            n_permutations++;
           }
         ll_reverse (ll_head (&list), ll_null (&list));
-        check (permutation_cnt == expected_perms (values, cnt));
+        check (n_permutations == expected_perms (values, cnt));
         check_list_contents (&list, values, cnt);
 
         free_elements (cnt, elems, NULL, values);
@@ -1402,15 +1395,15 @@ test_permutations_with_dups (void)
 
 /* Tests ll_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_filler = 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_filler; pfx++)
         for (gap = 0; gap < max_filler; gap++)
           for (sfx = 0; sfx < max_filler; sfx++)
@@ -1421,46 +1414,46 @@ test_merge_no_dups (void)
                 struct ll **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)
                   ll_merge (elemp[a0], elemp[a1], elemp[b0], elemp[b1],
@@ -1469,20 +1462,20 @@ test_merge_no_dups (void)
                   ll_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, elems, elemp, values);
+                free_elements (n_lists, elems, elemp, values);
               }
 }
 
 /* Tests ll_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++)
@@ -1499,9 +1492,9 @@ test_merge_with_dups (void)
             allocate_elements (cnt, &list, &elems, &elemp, &values);
 
             j = 0;
-            for (i = k = 0; i < cnt; i++) 
+            for (i = k = 0; i < cnt; i++)
               {
-                if (merge_pat & (1u << i)) 
+                if (merge_pat & (1u << i))
                   elems[j++]->x = k;
                 if (inc_pat & (1u << i))
                   k++;
@@ -1509,19 +1502,19 @@ test_merge_with_dups (void)
             mid = j;
             for (i = k = 0; i < cnt; i++)
               {
-                if (!(merge_pat & (1u << i))) 
+                if (!(merge_pat & (1u << i)))
                   elems[j++]->x = k;
                 if (inc_pat & (1u << i))
                   k++;
               }
             check (cnt == j);
 
-            if (order == 0) 
+            if (order == 0)
               {
                 for (i = 0; i < cnt; i++)
-                  elems[i]->y = i; 
+                  elems[i]->y = i;
               }
-            else 
+            else
               {
                 for (i = 0; i < mid; i++)
                   elems[i]->y = 100 + i;
@@ -1530,11 +1523,11 @@ test_merge_with_dups (void)
               }
 
             j = 0;
-            for (i = k = 0; i < cnt; i++) 
+            for (i = k = 0; i < cnt; i++)
               {
                 values[j++] = k;
                 if (inc_pat & (1u << i))
-                  k++; 
+                  k++;
               }
             check (cnt == j);
 
@@ -1556,12 +1549,12 @@ test_merge_with_dups (void)
 /* Tests ll_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;
 
-  for (cnt = 0; cnt <= max_elems; cnt++) 
+  for (cnt = 0; cnt <= max_elems; cnt++)
     {
       struct ll_list list;
       struct element **elems;
@@ -1570,14 +1563,14 @@ 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);
 
-      perm_cnt = 1;
+      n_perms = 1;
       while (ll_next_permutation (ll_head (&list), ll_null (&list),
-                                  compare_elements, &aux_data)) 
+                                  compare_elements, &aux_data))
         {
           struct ll_list perm_list;
           int j;
@@ -1585,7 +1578,7 @@ test_sort_exhaustive (void)
           extract_values (&list, perm_values, cnt);
           ll_init (&perm_list);
           for (j = 0; j < cnt; j++)
-            { 
+            {
               perm_elems[j]->x = perm_values[j];
               ll_push_tail (&perm_list, &perm_elems[j]->ll);
             }
@@ -1594,9 +1587,9 @@ test_sort_exhaustive (void)
           check_list_contents (&perm_list, values, cnt);
           check (ll_is_sorted (ll_head (&perm_list), ll_null (&perm_list),
                                compare_elements, &aux_data));
-          perm_cnt++; 
+          n_perms++;
         }
-      check (perm_cnt == factorial (cnt));
+      check (n_perms == factorial (cnt));
 
       free_elements (cnt, elems, NULL, values);
       free_elements (cnt, perm_elems, NULL, perm_values);
@@ -1606,7 +1599,7 @@ test_sort_exhaustive (void)
 /* Tests that ll_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;
@@ -1621,14 +1614,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);
 
         j = 0;
-        for (i = 0; i < cnt; i++) 
+        for (i = 0; i < cnt; i++)
           {
             elems[i]->x = values[i] = j;
             if (inc_pat & (1 << i))
@@ -1636,16 +1629,16 @@ test_sort_stable (void)
             elems[i]->y = i;
           }
 
-        perm_cnt = 1;
+        n_perms = 1;
         while (ll_next_permutation (ll_head (&list), ll_null (&list),
-                                    compare_elements_y, &aux_data)) 
+                                    compare_elements_y, &aux_data))
           {
             struct ll_list perm_list;
 
             extract_values (&list, perm_values, cnt);
             ll_init (&perm_list);
             for (i = 0; i < cnt; i++)
-              { 
+              {
                 perm_elems[i]->x = perm_values[i];
                 perm_elems[i]->y = i;
                 ll_push_tail (&perm_list, &perm_elems[i]->ll);
@@ -1655,9 +1648,9 @@ test_sort_stable (void)
             check_list_contents (&perm_list, values, cnt);
             check (ll_is_sorted (ll_head (&perm_list), ll_null (&perm_list),
                                  compare_elements_x_y, &aux_data));
-            perm_cnt++; 
+            n_perms++;
           }
-        check (perm_cnt == factorial (cnt));
+        check (n_perms == factorial (cnt));
 
         free_elements (cnt, elems, NULL, values);
         free_elements (cnt, perm_elems, NULL, perm_values);
@@ -1675,7 +1668,7 @@ test_sort_subset (void)
 
   for (cnt = 0; cnt <= max_elems; cnt++)
     for (repeat = 0; repeat < 100; repeat++)
-      for (r0 = 0; r0 <= cnt; r0++) 
+      for (r0 = 0; r0 <= cnt; r0++)
         for (r1 = r0; r1 <= cnt; r1++)
           {
             struct ll_list list;
@@ -1719,7 +1712,7 @@ test_sort_big (void)
 
 /* Tests ll_unique. */
 static void
-test_unique (void) 
+test_unique (void)
 {
   const int max_elems = 10;
 
@@ -1740,7 +1733,7 @@ test_unique (void)
         allocate_elements (cnt, &list, &elems, NULL, &values);
 
         j = unique_values = 0;
-        for (i = 0; i < cnt; i++) 
+        for (i = 0; i < cnt; i++)
           {
             unique_values = j + 1;
             elems[i]->x = values[i] = j;
@@ -1767,7 +1760,7 @@ test_unique (void)
 
 /* Tests ll_sort_unique. */
 static void
-test_sort_unique (void) 
+test_sort_unique (void)
 {
   const int max_elems = 7;
   int cnt, inc_pat;
@@ -1782,50 +1775,50 @@ 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);
 
-        j = unique_cnt = 0;
-        for (i = 0; i < cnt; i++) 
+        j = n_uniques = 0;
+        for (i = 0; i < cnt; 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 (ll_next_permutation (ll_head (&list), ll_null (&list),
-                                    compare_elements, &aux_data)) 
+                                    compare_elements, &aux_data))
           {
             struct ll_list perm_list;
 
             extract_values (&list, perm_values, cnt);
             ll_init (&perm_list);
             for (i = 0; i < cnt; i++)
-              { 
+              {
                 perm_elems[i]->x = perm_values[i];
                 perm_elems[i]->y = i;
                 ll_push_tail (&perm_list, &perm_elems[i]->ll);
               }
             ll_sort_unique (ll_head (&perm_list), ll_null (&perm_list), NULL,
                             compare_elements, &aux_data);
-            check_list_contents (&perm_list, unique_values, unique_cnt);
+            check_list_contents (&perm_list, unique_values, n_uniques);
             check (ll_is_sorted (ll_head (&perm_list), ll_null (&perm_list),
                                  compare_elements_x_y, &aux_data));
-            perm_cnt++; 
+            n_perms++;
           }
-        check (perm_cnt == expected_perms (values, cnt));
+        check (n_perms == expected_perms (values, cnt));
 
         free_elements (cnt, elems, NULL, values);
         free_elements (cnt, perm_elems, NULL, perm_values);
@@ -1835,7 +1828,7 @@ test_sort_unique (void)
 
 /* Tests ll_insert_ordered. */
 static void
-test_insert_ordered (void) 
+test_insert_ordered (void)
 {
   const int max_elems = 6;
   int cnt, inc_pat;
@@ -1850,14 +1843,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);
 
         j = 0;
-        for (i = 0; i < cnt; i++) 
+        for (i = 0; i < cnt; i++)
           {
             elems[i]->x = values[i] = j;
             if (inc_pat & (1 << i))
@@ -1865,16 +1858,16 @@ test_insert_ordered (void)
             elems[i]->y = i;
           }
 
-        perm_cnt = 1;
+        n_perms = 1;
         while (ll_next_permutation (ll_head (&list), ll_null (&list),
-                                    compare_elements_y, &aux_data)) 
+                                    compare_elements_y, &aux_data))
           {
             struct ll_list perm_list;
 
             extract_values (&list, perm_values, cnt);
             ll_init (&perm_list);
             for (i = 0; i < cnt; i++)
-              { 
+              {
                 perm_elems[i]->x = perm_values[i];
                 perm_elems[i]->y = i;
                 ll_insert_ordered (ll_head (&perm_list), ll_null (&perm_list),
@@ -1883,9 +1876,9 @@ test_insert_ordered (void)
               }
             check (ll_is_sorted (ll_head (&perm_list), ll_null (&perm_list),
                                  compare_elements_x_y, &aux_data));
-            perm_cnt++; 
+            n_perms++;
           }
-        check (perm_cnt == factorial (cnt));
+        check (n_perms == factorial (cnt));
 
         free_elements (cnt, elems, NULL, values);
         free_elements (cnt, perm_elems, NULL, perm_values);
@@ -1897,7 +1890,7 @@ static void
 test_partition (void)
 {
   const int max_elems = 10;
-  
+
   int cnt;
   unsigned int pbase;
   int r0, r1;
@@ -1916,7 +1909,7 @@ test_partition (void)
             int i, j;
             int first_false;
             struct ll *part_ll;
-         
+
             allocate_ascending (cnt, &list, &elems, &elemp, &values);
 
             /* Check that ll_find_partition works okay in every
@@ -1927,12 +1920,12 @@ test_partition (void)
                 break;
             j = i;
             for (; i < r1; i++)
-              if (pattern & (1u << i)) 
+              if (pattern & (1u << i))
                 break;
             part_ll = ll_find_partition (elemp[r0], elemp[r1],
                                          pattern_pred,
                                          &pattern);
-            if (i == r1) 
+            if (i == r1)
               check (part_ll == elemp[j]);
             else
               check (part_ll == NULL);
@@ -1950,7 +1943,7 @@ test_partition (void)
                 {
                   if (first_false == -1)
                     first_false = i;
-                  values[j++] = i; 
+                  values[j++] = i;
                 }
             if (first_false == -1)
               first_false = r1;
@@ -1974,56 +1967,199 @@ test_partition (void)
 
 /* 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
+    },
+    {
+      "moved",
+      "moved",
+      test_moved
+    },
+    {
+      "find-equal",
+      "find_equal",
+      test_find_equal
+    },
+    {
+      "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
+    },
+    {
+      "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
+    },
+  };
+
+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_moved, "moved");
-  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_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");
-  putchar ('\n');
-
-  return 0;
-}
-
-/*
-  Local Variables:
-  compile-command: "gcc -Wall -Wstrict-prototypes -Wmissing-prototypes ll.c ll-test.c -o ll-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 (ll) 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;
+    }
+}