X-Git-Url: https://pintos-os.org/cgi-bin/gitweb.cgi?a=blobdiff_plain;f=tests%2Flibpspp%2Fsparse-array-test.c;h=a8c5cf760e1b9386c351af0c3b1a8e6071daf207;hb=b525a9596e60d5ae4c6c464b4a426b77ade3dd72;hp=e146c3dbf537b7c765dfec60a16267756f8b4356;hpb=3bbb4370239deb29ebbf813d258aef6249e2a431;p=pspp

diff --git a/tests/libpspp/sparse-array-test.c b/tests/libpspp/sparse-array-test.c
index e146c3dbf5..a8c5cf760e 100644
--- a/tests/libpspp/sparse-array-test.c
+++ b/tests/libpspp/sparse-array-test.c
@@ -1,5 +1,5 @@
 /* PSPP - a program for statistical analysis.
-   Copyright (C) 2007, 2009 Free Software Foundation, Inc.
+   Copyright (C) 2007, 2009, 2010 Free Software Foundation, Inc.
 
    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
@@ -40,9 +40,6 @@
 #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
@@ -58,8 +55,7 @@ check_func (bool ok, int line)
 {
   if (!ok)
     {
-      printf ("%s:%d: Check failed in %s test\n",
-              __FILE__, line, test_name);
+      fprintf (stderr, "%s:%d: check failed\n", __FILE__, line);
       check_die ();
     }
 }
@@ -123,49 +119,49 @@ compare_unsigned_longs_noaux (const void *a_, const void *b_)
   return *a < *b ? -1 : *a > *b;
 }
 
-/* Checks that SPAR contains the CNT ints in DATA, that its
+/* Checks that SPAR contains the N ints in DATA, that its
    structure is correct, and that certain operations on SPAR
    produce the expected results. */
 static void
 check_sparse_array (struct sparse_array *spar,
-                    const unsigned long data[], size_t cnt)
+                    const unsigned long data[], size_t n)
 {
   unsigned long idx;
   unsigned long *order;
   unsigned long *p;
   size_t i;
 
-  check (sparse_array_count (spar) == cnt);
+  check (sparse_array_count (spar) == n);
 
-  for (i = 0; i < cnt; i++)
+  for (i = 0; i < n; i++)
     {
       p = sparse_array_get (spar, data[i]);
       check (p != NULL);
       check (*p == data[i]);
     }
 
-  order = xmemdup (data, cnt * sizeof *data);
-  qsort (order, cnt, sizeof *order, compare_unsigned_longs_noaux);
+  order = xmemdup (data, n * sizeof *data);
+  qsort (order, n, sizeof *order, compare_unsigned_longs_noaux);
 
-  for (i = 0; i < cnt; i++)
+  for (i = 0; i < n; i++)
     {
       p = sparse_array_get (spar, order[i]);
       check (p != NULL);
       check (*p == order[i]);
     }
 
-  if (cnt > 0 && order[0] - 1 != order[cnt - 1])
+  if (n > 0 && order[0] - 1 != order[n - 1])
     {
       check (sparse_array_get (spar, order[0] - 1) == NULL);
       check (!sparse_array_remove (spar, order[0] - 1));
     }
-  if (cnt > 0 && order[0] != order[cnt - 1] + 1)
+  if (n > 0 && order[0] != order[n - 1] + 1)
     {
-      check (sparse_array_get (spar, order[cnt - 1] + 1) == NULL);
-      check (!sparse_array_remove (spar, order[cnt - 1] + 1));
+      check (sparse_array_get (spar, order[n - 1] + 1) == NULL);
+      check (!sparse_array_remove (spar, order[n - 1] + 1));
     }
 
-  for (i = 0, p = sparse_array_first (spar, &idx); i < cnt;
+  for (i = 0, p = sparse_array_first (spar, &idx); i < n;
        i++, p = sparse_array_next (spar, idx, &idx))
     {
       check (p != NULL);
@@ -174,59 +170,59 @@ check_sparse_array (struct sparse_array *spar,
     }
   check (p == NULL);
 
-  for (i = 0, p = sparse_array_last (spar, &idx); i < cnt;
+  for (i = 0, p = sparse_array_last (spar, &idx); i < n;
        i++, p = sparse_array_prev (spar, idx, &idx))
     {
       check (p != NULL);
-      check (idx == order[cnt - i - 1]);
-      check (*p == order[cnt - i - 1]);
+      check (idx == order[n - i - 1]);
+      check (*p == order[n - i - 1]);
     }
   check (p == NULL);
 
   free (order);
 }
 
-/* Inserts the CNT values from 0 to CNT - 1 (inclusive) into a
+/* Inserts the N values from 0 to N - 1 (inclusive) into a
    sparse array in the order specified by INSERTIONS, then
    deletes them in the order specified by DELETIONS, checking the
    array's contents for correctness after each operation. */
 static void
 test_insert_delete (const unsigned long insertions[],
                     const unsigned long deletions[],
-                    size_t cnt)
+                    size_t n)
 {
   struct sparse_array *spar;
   size_t i;
 
   spar = sparse_array_create (sizeof *insertions);
-  for (i = 0; i < cnt; i++)
+  for (i = 0; i < n; i++)
     {
       unsigned long *p = sparse_array_insert (spar, insertions[i]);
       *p = insertions[i];
       check_sparse_array (spar, insertions, i + 1);
     }
-  for (i = 0; i < cnt; i++)
+  for (i = 0; i < n; i++)
     {
       bool deleted = sparse_array_remove (spar, deletions[i]);
       check (deleted);
-      check_sparse_array (spar, deletions + i + 1, cnt - (i + 1));
+      check_sparse_array (spar, deletions + i + 1, n - (i + 1));
     }
   check_sparse_array (spar, NULL, 0);
   sparse_array_destroy (spar);
 }
 
-/* Inserts the CNT values from 0 to CNT - 1 (inclusive) into a
+/* Inserts the N values from 0 to N - 1 (inclusive) into a
    sparse array in the order specified by INSERTIONS, then
    destroys the sparse array, to check that sparse_cases_destroy
    properly frees all the nodes. */
 static void
-test_destroy (const unsigned long insertions[], size_t cnt)
+test_destroy (const unsigned long insertions[], size_t n)
 {
   struct sparse_array *spar;
   size_t i;
 
   spar = sparse_array_create (sizeof *insertions);
-  for (i = 0; i < cnt; i++)
+  for (i = 0; i < n; i++)
     {
       unsigned long *p = sparse_array_insert (spar, insertions[i]);
       *p = insertions[i];
@@ -235,18 +231,18 @@ test_destroy (const unsigned long insertions[], size_t cnt)
   sparse_array_destroy (spar);
 }
 
-/* Randomly shuffles the CNT elements in ARRAY, each of which is
+/* Randomly shuffles the N elements in ARRAY, each of which is
    SIZE bytes in size. */
 static void
-random_shuffle (void *array_, size_t cnt, size_t size)
+random_shuffle (void *array_, size_t n, size_t size)
 {
   char *array = array_;
   char *tmp = xmalloc (size);
   size_t i;
 
-  for (i = 0; i < cnt; i++)
+  for (i = 0; i < n; i++)
     {
-      size_t j = rand () % (cnt - i) + i;
+      size_t j = rand () % (n - i) + i;
       if (i != j)
         {
           memcpy (tmp, array + j * size, size);
@@ -269,7 +265,7 @@ test_insert_delete_strides (void)
       1, 2, 4, 16, 64, 4096, 262144, 16777216,
       3, 5, 17, 67, 4099, 262147, 16777259,
     };
-  const size_t stride_cnt = sizeof strides / sizeof *strides;
+  const size_t n_strides = sizeof strides / sizeof *strides;
 
   static const unsigned long offsets[] =
     {
@@ -278,50 +274,49 @@ test_insert_delete_strides (void)
       1024ul * 1024 * 512 + 23,
       ULONG_MAX - 59,
     };
-  const size_t offset_cnt = sizeof offsets / sizeof *offsets;
+  const size_t n_offsets = sizeof offsets / sizeof *offsets;
 
-  int cnt = 100;
+  int n = 100;
   unsigned long *insertions, *deletions;
   const unsigned long *stride, *offset;
 
-  insertions = xnmalloc (cnt, sizeof *insertions);
-  deletions = xnmalloc (cnt, sizeof *deletions);
-  for (stride = strides; stride < strides + stride_cnt; stride++)
+  insertions = xnmalloc (n, sizeof *insertions);
+  deletions = xnmalloc (n, sizeof *deletions);
+  for (stride = strides; stride < strides + n_strides; stride++)
     {
-      for (offset = offsets; offset < offsets + offset_cnt; offset++)
+      printf ("%lu\n", *stride);
+      for (offset = offsets; offset < offsets + n_offsets; offset++)
         {
           int k;
 
-          for (k = 0; k < cnt; k++)
+          for (k = 0; k < n; k++)
             insertions[k] = *stride * k + *offset;
 
-          test_insert_delete (insertions, insertions, cnt);
-          test_destroy (insertions, cnt);
+          test_insert_delete (insertions, insertions, n);
+          test_destroy (insertions, n);
 
-          for (k = 0; k < cnt; k++)
-            deletions[k] = insertions[cnt - k - 1];
-          test_insert_delete (insertions, deletions, cnt);
+          for (k = 0; k < n; k++)
+            deletions[k] = insertions[n - k - 1];
+          test_insert_delete (insertions, deletions, n);
 
-          random_shuffle (insertions, cnt, sizeof *insertions);
-          test_insert_delete (insertions, insertions, cnt);
-          test_insert_delete (insertions, deletions, cnt);
+          random_shuffle (insertions, n, sizeof *insertions);
+          test_insert_delete (insertions, insertions, n);
+          test_insert_delete (insertions, deletions, n);
         }
-      putchar ('.');
-      fflush (stdout);
     }
   free (insertions);
   free (deletions);
 }
 
-/* Returns the index in ARRAY of the (CNT+1)th element that has
+/* Returns the index in ARRAY of the (N+1)th element that has
    the TARGET value. */
 static int
-scan_bools (bool target, bool array[], size_t cnt)
+scan_bools (bool target, bool array[], size_t n)
 {
   size_t i;
 
   for (i = 0; ; i++)
-    if (array[i] == target && cnt-- == 0)
+    if (array[i] == target && n-- == 0)
       return i;
 }
 
@@ -347,14 +342,14 @@ test_random_insert_delete (void)
   const int num_actions = 250000;
   struct sparse_array *spar;
   bool *has_values;
-  int cnt;
+  int n;
   int insert_chance;
   int i;
 
   has_values = xnmalloc (max_values, sizeof *has_values);
   memset (has_values, 0, max_values * sizeof *has_values);
 
-  cnt = 0;
+  n = 0;
   insert_chance = 5;
 
   spar = sparse_array_create (sizeof *values);
@@ -364,13 +359,13 @@ test_random_insert_delete (void)
       unsigned long *p;
       int j;
 
-      if (cnt == 0)
+      if (n == 0)
         {
           action = INSERT;
           if (insert_chance < 9)
             insert_chance++;
         }
-      else if (cnt == max_values)
+      else if (n == max_values)
         {
           action = DELETE;
           if (insert_chance > 0)
@@ -384,7 +379,7 @@ test_random_insert_delete (void)
           int ins_index;
 
           ins_index = scan_bools (false, has_values,
-                                  rand () % (max_values - cnt));
+                                  rand () % (max_values - n));
           assert (has_values[ins_index] == false);
           has_values[ins_index] = true;
 
@@ -392,23 +387,23 @@ test_random_insert_delete (void)
           check (p != NULL);
           *p = values[ins_index];
 
-          cnt++;
+          n++;
         }
       else if (action == DELETE)
         {
           int del_index;
 
-          del_index = scan_bools (true, has_values, rand () % cnt);
+          del_index = scan_bools (true, has_values, rand () % n);
           assert (has_values[del_index] == true);
           has_values[del_index] = false;
 
           check (sparse_array_remove (spar, values[del_index]));
-          cnt--;
+          n--;
         }
       else
         abort ();
 
-      check (sparse_array_count (spar) == cnt);
+      check (sparse_array_count (spar) == n);
       for (j = 0; j < max_values; j++)
         {
           p = sparse_array_get (spar, values[j]);
@@ -428,27 +423,62 @@ test_random_insert_delete (void)
   sparse_array_destroy (spar);
   free (has_values);
 }
-
+
 /* 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[] =
+  {
+    {
+      "random-insert-delete",
+      "random insertions and deletions",
+      test_random_insert_delete
+    },
+    {
+      "insert-delete-strides",
+      "insert in ascending order with strides and offset",
+      test_insert_delete_strides
+    },
+  };
+
+enum { N_TESTS = sizeof tests / sizeof *tests };
 
 int
-main (void)
+main (int argc, char *argv[])
 {
-  run_test (test_random_insert_delete,
-            "random insertions and deletions");
-  run_test (test_insert_delete_strides,
-            "insert in ascending order with strides and offset");
-  putchar ('\n');
+  int i;
 
-  return 0;
+  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 sparse array 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;
+    }
 }