X-Git-Url: https://pintos-os.org/cgi-bin/gitweb.cgi?a=blobdiff_plain;f=tests%2Flibpspp%2Fstringi-map-test.c;h=499e8b33b6d8385772d6421fedad57ff95d7d6c7;hb=b525a9596e60d5ae4c6c464b4a426b77ade3dd72;hp=63b70ba80d0d6380ac3b66dc576c749c4ddfbe54;hpb=89c05dfe33f9542e60e66dd383f7a514849b5947;p=pspp

diff --git a/tests/libpspp/stringi-map-test.c b/tests/libpspp/stringi-map-test.c
index 63b70ba80d..499e8b33b6 100644
--- a/tests/libpspp/stringi-map-test.c
+++ b/tests/libpspp/stringi-map-test.c
@@ -134,18 +134,18 @@ swap (int *a, int *b)
   *b = t;
 }
 
-/* Reverses the order of the CNT integers starting at VALUES. */
+/* Reverses the order of the N integers starting at VALUES. */
 static void
-reverse (int *values, size_t cnt)
+reverse (int *values, size_t n)
 {
   size_t i = 0;
-  size_t j = cnt;
+  size_t j = n;
 
   while (j > i)
     swap (&values[i++], &values[--j]);
 }
 
-/* Arranges the CNT elements in VALUES into the lexicographically next greater
+/* 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 smallest), arranges them into the lexicographically least
@@ -153,28 +153,28 @@ reverse (int *values, size_t cnt)
 
    Comparisons among elements of VALUES consider only the bits in KEY_MASK. */
 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] & KEY_MASK) < (values[i + 1] & KEY_MASK))
             {
               size_t j;
-              for (j = cnt - 1;
+              for (j = n - 1;
                    (values[i] & KEY_MASK) >= (values[j] & KEY_MASK);
                    j--)
                 continue;
               swap (values + i, values + j);
-              reverse (values + (i + 1), cnt - (i + 1));
+              reverse (values + (i + 1), n - (i + 1));
               return true;
             }
         }
 
-      reverse (values, cnt);
+      reverse (values, n);
     }
 
   return false;
@@ -190,18 +190,18 @@ factorial (unsigned int n)
   return value;
 }
 
-/* Randomly shuffles the CNT elements in ARRAY, each of which is
+/* Randomly shuffles the N elements in ARRAY, each of which is
    SIZE bytes in size. */
 static void
-random_shuffle (void *array_, size_t cnt, size_t size)
+random_shuffle (void *array_, size_t n, size_t size)
 {
   char *array = array_;
   char *tmp = xmalloc (size);
   size_t i;
 
-  for (i = 0; i < cnt; i++)
+  for (i = 0; i < n; i++)
     {
-      size_t j = rand () % (cnt - i) + i;
+      size_t j = rand () % (n - i) + i;
       if (i != j)
         {
           memcpy (tmp, array + j * size, size);
@@ -241,17 +241,17 @@ check_map_contains (struct stringi_map *map,
   check (!strcmp (found_value, value));
 }
 
-/* Checks that MAP contains the CNT strings in DATA, that its structure is
+/* Checks that MAP contains the N strings in DATA, that its structure is
    correct, and that certain operations on MAP produce the expected results. */
 static void
-check_stringi_map (struct stringi_map *map, const int data[], size_t cnt)
+check_stringi_map (struct stringi_map *map, const int data[], size_t n)
 {
   size_t i;
 
-  check (stringi_map_is_empty (map) == (cnt == 0));
-  check (stringi_map_count (map) == cnt);
+  check (stringi_map_is_empty (map) == (n == 0));
+  check (stringi_map_count (map) == n);
 
-  for (i = 0; i < cnt; i++)
+  for (i = 0; i < n; i++)
     {
       const char *key = make_key (data[i]);
       const char *value = make_value (data[i]);
@@ -274,7 +274,7 @@ check_stringi_map (struct stringi_map *map, const int data[], size_t cnt)
   check (stringi_map_find_node (map, "", 0) == NULL);
   check (!stringi_map_delete (map, "xyz"));
 
-  if (cnt == 0)
+  if (n == 0)
     check (stringi_map_first (map) == NULL);
   else
     {
@@ -282,9 +282,9 @@ check_stringi_map (struct stringi_map *map, const int data[], size_t cnt)
       int *data_copy;
       int left;
 
-      data_copy = xmemdup (data, cnt * sizeof *data);
-      left = cnt;
-      for (node = stringi_map_first (map), i = 0; i < cnt;
+      data_copy = xmemdup (data, n * sizeof *data);
+      left = n;
+      for (node = stringi_map_first (map), i = 0; i < n;
            node = stringi_map_next (map, node), i++)
         {
           const char *key = stringi_map_node_get_key (node);
@@ -307,30 +307,30 @@ check_stringi_map (struct stringi_map *map, const int data[], size_t cnt)
     }
 }
 
-/* Inserts the CNT strings from 0 to CNT - 1 (inclusive) into a map in the
+/* Inserts the N strings from 0 to N - 1 (inclusive) into a map in the
    order specified by INSERTIONS, then deletes them in the order specified by
    DELETIONS, checking the map's contents for correctness after each
    operation.  */
 static void
 test_insert_delete (const int insertions[],
                     const int deletions[],
-                    size_t cnt)
+                    size_t n)
 {
   struct stringi_map map;
   size_t i;
 
   stringi_map_init (&map);
   check_stringi_map (&map, NULL, 0);
-  for (i = 0; i < cnt; i++)
+  for (i = 0; i < n; i++)
     {
       check (stringi_map_insert (&map, make_key (insertions[i]),
                                 make_value (insertions[i])));
       check_stringi_map (&map, insertions, i + 1);
     }
-  for (i = 0; i < cnt; i++)
+  for (i = 0; i < n; i++)
     {
       check (stringi_map_delete (&map, make_key (deletions[i])));
-      check_stringi_map (&map, deletions + i + 1, cnt - i - 1);
+      check_stringi_map (&map, deletions + i + 1, n - i - 1);
     }
   stringi_map_destroy (&map);
 }
@@ -342,37 +342,37 @@ test_insert_any_remove_any (void)
 {
   const int basis = 0;
   const int max_elems = 5;
-  int cnt;
+  int n;
 
-  for (cnt = 0; cnt <= max_elems; cnt++)
+  for (n = 0; n <= max_elems; n++)
     {
       int *insertions, *deletions;
       unsigned int ins_n_perms;
       int i;
 
-      insertions = xnmalloc (cnt, sizeof *insertions);
-      deletions = xnmalloc (cnt, sizeof *deletions);
-      for (i = 0; i < cnt; i++)
+      insertions = xnmalloc (n, sizeof *insertions);
+      deletions = xnmalloc (n, sizeof *deletions);
+      for (i = 0; i < n; i++)
         insertions[i] = i | random_value (i, basis);
 
       for (ins_n_perms = 0;
-           ins_n_perms == 0 || next_permutation (insertions, cnt);
+           ins_n_perms == 0 || next_permutation (insertions, n);
            ins_n_perms++)
         {
           unsigned int del_n_perms;
           int i;
 
-          for (i = 0; i < cnt; i++)
+          for (i = 0; i < n; i++)
             deletions[i] = i | random_value (i, basis);
 
           for (del_n_perms = 0;
-               del_n_perms == 0 || next_permutation (deletions, cnt);
+               del_n_perms == 0 || next_permutation (deletions, n);
                del_n_perms++)
-            test_insert_delete (insertions, deletions, cnt);
+            test_insert_delete (insertions, deletions, n);
 
-          check (del_n_perms == factorial (cnt));
+          check (del_n_perms == factorial (n));
         }
-      check (ins_n_perms == factorial (cnt));
+      check (ins_n_perms == factorial (n));
 
       free (insertions);
       free (deletions);
@@ -385,23 +385,23 @@ static void
 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;
       unsigned int n_permutations;
       int i;
 
-      values = xnmalloc (cnt, sizeof *values);
-      for (i = 0; i < cnt; i++)
+      values = xnmalloc (n, sizeof *values);
+      for (i = 0; i < n; i++)
         values[i] = i | random_value (i, 1);
 
       for (n_permutations = 0;
-           n_permutations == 0 || next_permutation (values, cnt);
+           n_permutations == 0 || next_permutation (values, n);
            n_permutations++)
-        test_insert_delete (values, values, cnt);
-      check (n_permutations == factorial (cnt));
+        test_insert_delete (values, values, n);
+      check (n_permutations == factorial (n));
 
       free (values);
     }
@@ -414,29 +414,29 @@ static void
 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;
       unsigned int n_permutations;
       int i;
 
-      insertions = xnmalloc (cnt, sizeof *insertions);
-      deletions = xnmalloc (cnt, sizeof *deletions);
-      for (i = 0; i < cnt; i++)
+      insertions = xnmalloc (n, sizeof *insertions);
+      deletions = xnmalloc (n, sizeof *deletions);
+      for (i = 0; i < n; i++)
         insertions[i] = i | random_value (i, 2);
 
       for (n_permutations = 0;
-           n_permutations == 0 || next_permutation (insertions, cnt);
+           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 (n_permutations == factorial (cnt));
+      check (n_permutations == factorial (n));
 
       free (insertions);
       free (deletions);
@@ -450,27 +450,27 @@ test_random_sequence (void)
   const int basis = 3;
   const int max_elems = 64;
   const int max_trials = 8;
-  int cnt;
+  int n;
 
-  for (cnt = 0; cnt <= max_elems; cnt += 2)
+  for (n = 0; n <= max_elems; n += 2)
     {
       int *insertions, *deletions;
       int trial;
       int i;
 
-      insertions = xnmalloc (cnt, sizeof *insertions);
-      deletions = xnmalloc (cnt, sizeof *deletions);
-      for (i = 0; i < cnt; i++)
+      insertions = xnmalloc (n, sizeof *insertions);
+      deletions = xnmalloc (n, sizeof *deletions);
+      for (i = 0; i < n; i++)
         insertions[i] = i | random_value (i, basis);
-      for (i = 0; i < cnt; i++)
+      for (i = 0; i < n; i++)
         deletions[i] = i | random_value (i, basis);
 
       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);
@@ -513,15 +513,15 @@ test_replace (void)
   const int basis = 15;
   enum { MAX_ELEMS = 16 };
   const int max_trials = 8;
-  int cnt;
+  int n;
 
-  for (cnt = 0; cnt <= MAX_ELEMS; cnt++)
+  for (n = 0; n <= MAX_ELEMS; n++)
     {
       int insertions[MAX_ELEMS];
       int trial;
       int i;
 
-      for (i = 0; i < cnt; i++)
+      for (i = 0; i < n; i++)
         insertions[i] = (i / 2) | random_value (i, basis);
 
       for (trial = 0; trial < max_trials; trial++)
@@ -533,8 +533,8 @@ test_replace (void)
           /* Insert with replacement in random order. */
           n_data = 0;
           stringi_map_init (&map);
-          random_shuffle (insertions, cnt, sizeof *insertions);
-          for (i = 0; i < cnt; i++)
+          random_shuffle (insertions, n, sizeof *insertions);
+          for (i = 0; i < n; i++)
             {
               const char *key = make_key (insertions[i]);
               const char *value = make_value (insertions[i]);
@@ -558,7 +558,7 @@ test_replace (void)
             }
 
           /* Delete in original order. */
-          for (i = 0; i < cnt; i++)
+          for (i = 0; i < n; i++)
             {
               const char *expected_value;
               char *value;