work on docs

[pspp] / tests / libpspp / abt-test.c

diff --git a/tests/libpspp/abt-test.c b/tests/libpspp/abt-test.c
index d946c64938ff8b1cf368497b8093c5cab701cd70..177e8f9108c3027b9085445642ac3c0843518f63 100644 (file)
--- a/tests/libpspp/abt-test.c
+++ b/tests/libpspp/abt-test.c
@@ -1,20 +1,18 @@
-/* PSPP - computes sample statistics.
-   Copyright (C) 2007 Free Software Foundation, Inc.
+/* PSPP - a program for statistical analysis.
+   Copyright (C) 2007, 2010, 2011 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
 
    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 abt_* routines defined in
    abt.c.  This test program aims to be as comprehensive as
 
 /* This is a test program for the abt_* routines defined in
    abt.c.  This test program aims to be as comprehensive as


@@ -28,7 +26,6 @@
 
 #include <libpspp/abt.h>
 
 
 #include <libpspp/abt.h>
 

-#include <assert.h>

 #include <stdbool.h>
 #include <stddef.h>
 #include <stdio.h>
 #include <stdbool.h>
 #include <stddef.h>
 #include <stdio.h>


@@ -37,9 +34,6 @@
 
 #include <libpspp/compiler.h>
 \f
 
 #include <libpspp/compiler.h>
 \f

-/* Currently running test. */
-static const char *test_name;
-

 /* Exit with a failure code.
    (Place a breakpoint on this function while debugging.) */
 static void
 /* Exit with a failure code.
    (Place a breakpoint on this function while debugging.) */
 static void


@@ -55,8 +49,7 @@ 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 ();
     }
 }
       check_die ();
     }
 }


@@ -125,7 +118,7 @@ static int aux_data;
 static struct element *
 abt_node_to_element (const struct abt_node *node)
 {
 static struct element *
 abt_node_to_element (const struct abt_node *node)
 {

-  return abt_data (node, struct element, node);
+  return ABT_DATA (node, struct element, node);

 }
 
 /* Compares the `x' values in A and B and returns a strcmp-type
 }
 
 /* Compares the `x' values in A and B and returns a strcmp-type


@@ -144,20 +137,17 @@ compare_elements (const struct abt_node *a_, const struct abt_node *b_,
 /* Recalculates the count for NODE's subtree by adding up the
    counts for its LEFT and RIGHT child subtrees. */
 static void
 /* Recalculates the count for NODE's subtree by adding up the
    counts for its LEFT and RIGHT child subtrees. */
 static void

-reaugment_elements (struct abt_node *node_,
-                    const struct abt_node *left,
-                    const struct abt_node *right,
-                    const void *aux)
+reaugment_elements (struct abt_node *node_, const void *aux)

 {
   struct element *node = abt_node_to_element (node_);
 
   check (aux == &aux_data);
 
   node->count = 1;
 {
   struct element *node = abt_node_to_element (node_);
 
   check (aux == &aux_data);
 
   node->count = 1;

-  if (left != NULL)
-    node->count += abt_node_to_element (left)->count;
-  if (right != NULL)
-    node->count += abt_node_to_element (right)->count;
+  if (node->node.down[0] != NULL)
+    node->count += abt_node_to_element (node->node.down[0])->count;
+  if (node->node.down[1] != NULL)
+    node->count += abt_node_to_element (node->node.down[1])->count;

 }
 
 /* Compares A and B and returns a strcmp-type return value. */
 }
 
 /* Compares A and B and returns a strcmp-type return value. */


@@ -179,18 +169,18 @@ swap (int *a, int *b)
   *b = t;
 }
 
   *b = t;
 }
 

-/* Reverses the order of the CNT integers starting at VALUES. */
+/* Reverses the order of the N integers starting at VALUES. */

 static void
 static void

-reverse (int *values, size_t cnt)
+reverse (int *values, size_t n)

 {
   size_t i = 0;
 {
   size_t i = 0;

-  size_t j = cnt;
+  size_t j = n;

 
   while (j > i)
     swap (&values[i++], &values[--j]);
 }
 
 
   while (j > i)
     swap (&values[i++], &values[--j]);
 }
 

-/* Arranges the CNT elements in VALUES into the lexicographically
+/* Arranges the N elements in VALUES into the lexicographically

    next greater permutation.  Returns true if successful.
    If VALUES is already the lexicographically greatest
    permutation of its elements (i.e. ordered from greatest to
    next greater permutation.  Returns true if successful.
    If VALUES is already the lexicographically greatest
    permutation of its elements (i.e. ordered from greatest to


@@ -198,26 +188,26 @@ reverse (int *values, size_t cnt)
    permutation (i.e. ordered from smallest to largest) and
    returns false. */
 static bool
    permutation (i.e. ordered from smallest to largest) and
    returns false. */
 static bool

-next_permutation (int *values, size_t cnt)
+next_permutation (int *values, size_t n)

 {
 {

-  if (cnt > 0)
+  if (n > 0)

     {
     {

-      size_t i = cnt - 1;
+      size_t i = n - 1;

       while (i != 0)
         {
           i--;
           if (values[i] < values[i + 1])
             {
               size_t j;
       while (i != 0)
         {
           i--;
           if (values[i] < values[i + 1])
             {
               size_t j;

-              for (j = cnt - 1; values[i] >= values[j]; j--)
+              for (j = n - 1; values[i] >= values[j]; j--)

                 continue;
               swap (values + i, values + j);
                 continue;
               swap (values + i, values + j);

-              reverse (values + (i + 1), cnt - (i + 1));
+              reverse (values + (i + 1), n - (i + 1));

               return true;
             }
         }
 
               return true;
             }
         }
 

-      reverse (values, cnt);
+      reverse (values, n);

     }
 
   return false;
     }
 
   return false;


@@ -233,18 +223,18 @@ factorial (unsigned int n)
   return value;
 }
 
   return value;
 }
 

-/* Randomly shuffles the CNT elements in ARRAY, each of which is
+/* Randomly shuffles the N elements in ARRAY, each of which is

    SIZE bytes in size. */
 static void
    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;
 
 {
   char *array = array_;
   char *tmp = xmalloc (size);
   size_t i;
 

-  for (i = 0; i < cnt; i++)
+  for (i = 0; i < n; i++)

     {
     {

-      size_t j = rand () % (cnt - i) + i;
+      size_t j = rand () % (n - i) + i;

       if (i != j)
         {
           memcpy (tmp, array + j * size, size);
       if (i != j)
         {
           memcpy (tmp, array + j * size, size);


@@ -262,7 +252,7 @@ static struct element *
 find_by_position (struct abt *abt, int position)
 {
   struct abt_node *p;
 find_by_position (struct abt *abt, int position)
 {
   struct abt_node *p;

-  for (p = abt->root; p != NULL; )
+  for (p = abt->root; p != NULL;)

     {
       int p_pos = p->down[0] ? abt_node_to_element (p->down[0])->count : 0;
       if (position == p_pos)
     {
       int p_pos = p->down[0] ? abt_node_to_element (p->down[0])->count : 0;
       if (position == p_pos)


@@ -323,22 +313,22 @@ check_levels (struct abt_node *p)
     }
 }
 
     }
 }
 

-/* Checks that ABT contains the CNT ints in DATA, that its
+/* Checks that ABT contains the N ints in DATA, that its

    structure is correct, and that certain operations on ABT
    produce the expected results. */
 static void
    structure is correct, and that certain operations on ABT
    produce the expected results. */
 static void

-check_abt (struct abt *abt, const int data[], size_t cnt)
+check_abt (struct abt *abt, const int data[], size_t n)

 {
   struct element e;
   size_t i;
   int *order;
 
 {
   struct element e;
   size_t i;
   int *order;
 

-  order = xmemdup (data, cnt * sizeof *data);
-  qsort (order, cnt, sizeof *order, compare_ints_noaux);
+  order = xmemdup (data, n * sizeof *data);
+  qsort (order, n, sizeof *order, compare_ints_noaux);

 
   if (abt->compare != NULL)
     {
 
   if (abt->compare != NULL)
     {

-      for (i = 0; i < cnt; i++)
+      for (i = 0; i < n; i++)

         {
           struct abt_node *p;
 
         {
           struct abt_node *p;
 


@@ -358,10 +348,10 @@ check_abt (struct abt *abt, const int data[], size_t cnt)
 
   check_levels (abt->root);
   check_augmentations (abt->root);
 
   check_levels (abt->root);
   check_augmentations (abt->root);

-  for (i = 0; i < cnt; i++)
+  for (i = 0; i < n; i++)

     check (find_by_position (abt, i)->data == order[i]);
 
     check (find_by_position (abt, i)->data == order[i]);
 

-  if (cnt == 0)
+  if (n == 0)

     {
       check (abt_first (abt) == NULL);
       check (abt_last (abt) == NULL);
     {
       check (abt_first (abt) == NULL);
       check (abt_last (abt) == NULL);


@@ -372,14 +362,15 @@ check_abt (struct abt *abt, const int data[], size_t cnt)
     {
       struct abt_node *p;
 
     {
       struct abt_node *p;
 

-      for (p = abt_first (abt), i = 0; i < cnt; p = abt_next (abt, p), i++)
+      for (p = abt_first (abt), i = 0; i < n; p = abt_next (abt, p), i++)

         check (abt_node_to_element (p)->data == order[i]);
       check (p == NULL);
 
         check (abt_node_to_element (p)->data == order[i]);
       check (p == NULL);
 

-      for (p = abt_last (abt), i = 0; i < cnt; p = abt_prev (abt, p), i++)
-        check (abt_node_to_element (p)->data == order[cnt - i - 1]);
+      for (p = abt_last (abt), i = 0; i < n; p = abt_prev (abt, p), i++)
+        check (abt_node_to_element (p)->data == order[n - i - 1]);

       check (p == NULL);
     }
       check (p == NULL);
     }

+  check (abt_is_empty (abt) == (n == 0));

 
   free (order);
 }
 
   free (order);
 }


@@ -427,7 +418,7 @@ insert_node (struct abt *abt, struct element *insert,
 }
 
 
 }
 
 

-/* Inserts the CNT values from 0 to CNT - 1 (inclusive) into an
+/* Inserts the N values from 0 to N - 1 (inclusive) into an

    ABT in the order specified by INSERTIONS using the given
    METHOD, then deletes them in the order specified by DELETIONS,
    checking the ABT's contents for correctness after each
    ABT in the order specified by INSERTIONS using the given
    METHOD, then deletes them in the order specified by DELETIONS,
    checking the ABT's contents for correctness after each


@@ -436,45 +427,45 @@ static void
 do_test_insert_delete (enum insertion_method method,
                        const int insertions[],
                        const int deletions[],
 do_test_insert_delete (enum insertion_method method,
                        const int insertions[],
                        const int deletions[],

-                       size_t cnt)
+                       size_t n)

 {
   struct element *elements;
   struct abt abt;
   size_t i;
 
 {
   struct element *elements;
   struct abt abt;
   size_t i;
 

-  elements = xnmalloc (cnt, sizeof *elements);
-  for (i = 0; i < cnt; i++)
+  elements = xnmalloc (n, sizeof *elements);
+  for (i = 0; i < n; i++)

     elements[i].data = i;
 
   abt_init (&abt, method == INSERT ? compare_elements : NULL,
             reaugment_elements, &aux_data);
   check_abt (&abt, NULL, 0);
     elements[i].data = i;
 
   abt_init (&abt, method == INSERT ? compare_elements : NULL,
             reaugment_elements, &aux_data);
   check_abt (&abt, NULL, 0);

-  for (i = 0; i < cnt; i++)
+  for (i = 0; i < n; i++)

     {
       insert_node (&abt, &elements[insertions[i]], method);
       check_abt (&abt, insertions, i + 1);
     }
     {
       insert_node (&abt, &elements[insertions[i]], method);
       check_abt (&abt, insertions, i + 1);
     }

-  for (i = 0; i < cnt; i++)
+  for (i = 0; i < n; i++)

     {
       abt_delete (&abt, &elements[deletions[i]].node);
     {
       abt_delete (&abt, &elements[deletions[i]].node);

-      check_abt (&abt, deletions + i + 1, cnt - i - 1);
+      check_abt (&abt, deletions + i + 1, n - i - 1);

     }
 
   free (elements);
 }
 
     }
 
   free (elements);
 }
 

-/* Inserts the CNT values from 0 to CNT - 1 (inclusive) into an
+/* Inserts the N values from 0 to N - 1 (inclusive) into an

    ABT in the order specified by INSERTIONS, then deletes them in
    the order specified by DELETIONS, checking the ABT's contents
    for correctness after each operation. */
 static void
 test_insert_delete (const int insertions[],
                     const int deletions[],
    ABT in the order specified by INSERTIONS, then deletes them in
    the order specified by DELETIONS, checking the ABT's contents
    for correctness after each operation. */
 static void
 test_insert_delete (const int insertions[],
                     const int deletions[],

-                    size_t cnt)
+                    size_t n)

 {
 {

-  do_test_insert_delete (INSERT, insertions, deletions, cnt);
-  do_test_insert_delete (INSERT_AFTER, insertions, deletions, cnt);
-  do_test_insert_delete (INSERT_BEFORE, insertions, deletions, cnt);
+  do_test_insert_delete (INSERT, insertions, deletions, n);
+  do_test_insert_delete (INSERT_AFTER, insertions, deletions, n);
+  do_test_insert_delete (INSERT_BEFORE, insertions, deletions, n);

 }
 \f
 /* Inserts values into an ABT in each possible order, then
 }
 \f
 /* Inserts values into an ABT in each possible order, then


@@ -484,37 +475,37 @@ static void
 test_insert_any_remove_any (void)
 {
   const int max_elems = 5;
 test_insert_any_remove_any (void)
 {
   const int max_elems = 5;

-  int cnt;
+  int n;

 
 

-  for (cnt = 0; cnt <= max_elems; cnt++)
+  for (n = 0; n <= max_elems; n++)

     {
       int *insertions, *deletions;
     {
       int *insertions, *deletions;

-      unsigned int ins_perm_cnt;
+      unsigned int ins_n_perms;

       int i;
 
       int i;
 

-      insertions = xnmalloc (cnt, sizeof *insertions);
-      deletions = xnmalloc (cnt, sizeof *deletions);
-      for (i = 0; i < cnt; i++)
+      insertions = xnmalloc (n, sizeof *insertions);
+      deletions = xnmalloc (n, sizeof *deletions);
+      for (i = 0; i < n; i++)

         insertions[i] = i;
 
         insertions[i] = i;
 

-      for (ins_perm_cnt = 0;
-           ins_perm_cnt == 0 || next_permutation (insertions, cnt);
-           ins_perm_cnt++)
+      for (ins_n_perms = 0;
+           ins_n_perms == 0 || next_permutation (insertions, n);
+           ins_n_perms++)

         {
         {

-          unsigned int del_perm_cnt;
+          unsigned int del_n_perms;

           int i;
 
           int i;
 

-          for (i = 0; i < cnt; i++)
+          for (i = 0; i < n; i++)

             deletions[i] = i;
 
             deletions[i] = i;
 

-          for (del_perm_cnt = 0;
-               del_perm_cnt == 0 || next_permutation (deletions, cnt);
-               del_perm_cnt++)
-            test_insert_delete (insertions, deletions, cnt);
+          for (del_n_perms = 0;
+               del_n_perms == 0 || next_permutation (deletions, n);
+               del_n_perms++)
+            test_insert_delete (insertions, deletions, n);

 
 

-          check (del_perm_cnt == factorial (cnt));
+          check (del_n_perms == factorial (n));

         }
         }

-      check (ins_perm_cnt == factorial (cnt));
+      check (ins_n_perms == factorial (n));

 
       free (insertions);
       free (deletions);
 
       free (insertions);
       free (deletions);


@@ -528,23 +519,23 @@ static void
 test_insert_any_remove_same (void)
 {
   const int max_elems = 7;
 test_insert_any_remove_same (void)
 {
   const int max_elems = 7;

-  int cnt;
+  int n;

 
 

-  for (cnt = 0; cnt <= max_elems; cnt++)
+  for (n = 0; n <= max_elems; n++)

     {
       int *values;
     {
       int *values;

-      unsigned int permutation_cnt;
+      unsigned int n_permutations;

       int i;
 
       int i;
 

-      values = xnmalloc (cnt, sizeof *values);
-      for (i = 0; i < cnt; i++)
+      values = xnmalloc (n, sizeof *values);
+      for (i = 0; i < n; i++)

         values[i] = i;
 
         values[i] = i;
 

-      for (permutation_cnt = 0;
-           permutation_cnt == 0 || next_permutation (values, cnt);
-           permutation_cnt++)
-        test_insert_delete (values, values, cnt);
-      check (permutation_cnt == factorial (cnt));
+      for (n_permutations = 0;
+           n_permutations == 0 || next_permutation (values, n);
+           n_permutations++)
+        test_insert_delete (values, values, n);
+      check (n_permutations == factorial (n));

 
       free (values);
     }
 
       free (values);
     }


@@ -557,29 +548,29 @@ static void
 test_insert_any_remove_reverse (void)
 {
   const int max_elems = 7;
 test_insert_any_remove_reverse (void)
 {
   const int max_elems = 7;

-  int cnt;
+  int n;

 
 

-  for (cnt = 0; cnt <= max_elems; cnt++)
+  for (n = 0; n <= max_elems; n++)

     {
       int *insertions, *deletions;
     {
       int *insertions, *deletions;

-      unsigned int permutation_cnt;
+      unsigned int n_permutations;

       int i;
 
       int i;
 

-      insertions = xnmalloc (cnt, sizeof *insertions);
-      deletions = xnmalloc (cnt, sizeof *deletions);
-      for (i = 0; i < cnt; i++)
+      insertions = xnmalloc (n, sizeof *insertions);
+      deletions = xnmalloc (n, sizeof *deletions);
+      for (i = 0; i < n; i++)

         insertions[i] = i;
 
         insertions[i] = i;
 

-      for (permutation_cnt = 0;
-           permutation_cnt == 0 || next_permutation (insertions, cnt);
-           permutation_cnt++)
+      for (n_permutations = 0;
+           n_permutations == 0 || next_permutation (insertions, n);
+           n_permutations++)

         {
         {

-          memcpy (deletions, insertions, sizeof *insertions * cnt);
-          reverse (deletions, cnt);
+          memcpy (deletions, insertions, sizeof *insertions * n);
+          reverse (deletions, n);

 
 

-          test_insert_delete (insertions, deletions, cnt);
+          test_insert_delete (insertions, deletions, n);

         }
         }

-      check (permutation_cnt == factorial (cnt));
+      check (n_permutations == factorial (n));

 
       free (insertions);
       free (deletions);
 
       free (insertions);
       free (deletions);


@@ -592,27 +583,27 @@ test_random_sequence (void)
 {
   const int max_elems = 128;
   const int max_trials = 8;
 {
   const int max_elems = 128;
   const int max_trials = 8;

-  int cnt;
+  int n;

 
 

-  for (cnt = 0; cnt <= max_elems; cnt += 2)
+  for (n = 0; n <= max_elems; n += 2)

     {
       int *insertions, *deletions;
       int trial;
       int i;
 
     {
       int *insertions, *deletions;
       int trial;
       int i;
 

-      insertions = xnmalloc (cnt, sizeof *insertions);
-      deletions = xnmalloc (cnt, sizeof *deletions);
-      for (i = 0; i < cnt; i++)
+      insertions = xnmalloc (n, sizeof *insertions);
+      deletions = xnmalloc (n, sizeof *deletions);
+      for (i = 0; i < n; i++)

         insertions[i] = i;
         insertions[i] = i;

-      for (i = 0; i < cnt; i++)
+      for (i = 0; i < n; i++)

         deletions[i] = i;
 
       for (trial = 0; trial < max_trials; trial++)
         {
         deletions[i] = i;
 
       for (trial = 0; trial < max_trials; trial++)
         {

-          random_shuffle (insertions, cnt, sizeof *insertions);
-          random_shuffle (deletions, cnt, sizeof *deletions);
+          random_shuffle (insertions, n, sizeof *insertions);
+          random_shuffle (deletions, n, sizeof *deletions);

 
 

-          test_insert_delete (insertions, deletions, cnt);
+          test_insert_delete (insertions, deletions, n);

         }
 
       free (insertions);
         }
 
       free (insertions);


@@ -684,29 +675,29 @@ static void
 test_changed (void)
 {
   const int max_elems = 6;
 test_changed (void)
 {
   const int max_elems = 6;

-  int cnt;
+  int n;

 
 

-  for (cnt = 0; cnt <= max_elems; cnt++)
+  for (n = 0; n <= max_elems; n++)

     {
       int *values, *changed_values;
       struct element *elements;
     {
       int *values, *changed_values;
       struct element *elements;

-      unsigned int permutation_cnt;
+      unsigned int n_permutations;

       int i;
 
       int i;
 

-      values = xnmalloc (cnt, sizeof *values);
-      changed_values = xnmalloc (cnt, sizeof *changed_values);
-      elements = xnmalloc (cnt, sizeof *elements);
-      for (i = 0; i < cnt; i++)
+      values = xnmalloc (n, sizeof *values);
+      changed_values = xnmalloc (n, sizeof *changed_values);
+      elements = xnmalloc (n, sizeof *elements);
+      for (i = 0; i < n; i++)

         values[i] = i;
 
         values[i] = i;
 

-      for (permutation_cnt = 0;
-           permutation_cnt == 0 || next_permutation (values, cnt);
-           permutation_cnt++)
+      for (n_permutations = 0;
+           n_permutations == 0 || next_permutation (values, n);
+           n_permutations++)

         {
         {

-          for (i = 0; i < cnt; i++)
+          for (i = 0; i < n; i++)

             {
               int j, k;
             {
               int j, k;

-              for (j = 0; j <= cnt; j++)
+              for (j = 0; j <= n; j++)

                 {
                   struct abt abt;
                   struct abt_node *changed_retval;
                 {
                   struct abt abt;
                   struct abt_node *changed_retval;


@@ -715,37 +706,37 @@ test_changed (void)
                             &aux_data);
 
                   /* Add to ABT in order. */
                             &aux_data);
 
                   /* Add to ABT in order. */

-                  for (k = 0; k < cnt; k++)
+                  for (k = 0; k < n; k++)

                     {
                       int n = values[k];
                       elements[n].data = n;
                       check (abt_insert (&abt, &elements[n].node) == NULL);
                     }
                     {
                       int n = values[k];
                       elements[n].data = n;
                       check (abt_insert (&abt, &elements[n].node) == NULL);
                     }

-                  check_abt (&abt, values, cnt);
+                  check_abt (&abt, values, n);

 
                   /* Change value i to j. */
                   elements[i].data = j;
 
                   /* Change value i to j. */
                   elements[i].data = j;

-                  for (k = 0; k < cnt; k++)
+                  for (k = 0; k < n; k++)

                     changed_values[k] = k;
                   changed_retval = abt_changed (&abt, &elements[i].node);
                     changed_values[k] = k;
                   changed_retval = abt_changed (&abt, &elements[i].node);

-                  if (i != j && j < cnt)
+                  if (i != j && j < n)

                     {
                       /* Will cause duplicate. */
                       check (changed_retval == &elements[j].node);
                     {
                       /* Will cause duplicate. */
                       check (changed_retval == &elements[j].node);

-                      changed_values[i] = changed_values[cnt - 1];
-                      check_abt (&abt, changed_values, cnt - 1);
+                      changed_values[i] = changed_values[n - 1];
+                      check_abt (&abt, changed_values, n - 1);

                     }
                   else
                     {
                       /* Succeeds. */
                       check (changed_retval == NULL);
                       changed_values[i] = j;
                     }
                   else
                     {
                       /* Succeeds. */
                       check (changed_retval == NULL);
                       changed_values[i] = j;

-                      check_abt (&abt, changed_values, cnt);
+                      check_abt (&abt, changed_values, n);

                     }
                 }
             }
         }
                     }
                 }
             }
         }

-      check (permutation_cnt == factorial (cnt));
+      check (n_permutations == factorial (n));

 
       free (values);
       free (changed_values);
 
       free (values);
       free (changed_values);


@@ -755,32 +746,84 @@ test_changed (void)
 \f
 /* Main program. */
 
 \f
 /* Main program. */
 

-/* Runs TEST_FUNCTION and prints a message about NAME. */
-static void
-run_test (void (*test_function) (void), const char *name)
-{
-  test_name = name;
-  putchar ('.');
-  fflush (stdout);
-  test_function ();
-}
+struct test
+  {
+    const char *name;
+    const char *description;
+    void (*function) (void);
+  };
+
+static const struct test tests[] =
+  {
+    {
+      "insert-any-remove-any",
+      "insert any order, delete any order",
+      test_insert_any_remove_any
+    },
+    {
+      "insert-any-remove-same",
+      "insert any order, delete same order",
+      test_insert_any_remove_same
+    },
+    {
+      "insert-any-remove-reverse",
+      "insert any order, delete reverse order",
+      test_insert_any_remove_reverse
+    },
+    {
+      "random-sequence",
+      "insert and delete in random sequence",
+      test_random_sequence
+    },
+    {
+      "insert-ordered",
+      "insert in ascending order",
+      test_insert_ordered
+    },
+    {
+      "moved",
+      "move elements around in memory",
+      test_moved
+    },
+    {
+      "changed",
+      "change key data in nodes",
+      test_changed
+    }
+  };
+
+enum { N_TESTS = sizeof tests / sizeof *tests };

 
 int
 
 int

-main (void)
+main (int argc, char *argv[])

 {
 {

-  run_test (test_insert_any_remove_any,
-            "insert any order, delete any order");
-  run_test (test_insert_any_remove_same,
-            "insert any order, delete same order");
-  run_test (test_insert_any_remove_reverse,
-            "insert any order, delete reverse order");
-  run_test (test_random_sequence,
-            "insert and delete in random sequence");
-  run_test (test_insert_ordered,
-            "insert in ascending order");
-  run_test (test_moved, "move elements around in memory");
-  run_test (test_changed, "change key data in nodes");
-  putchar ('\n');
-
-  return 0;
+  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 augmented binary tree\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;
+    }

 }
 }