X-Git-Url: https://pintos-os.org/cgi-bin/gitweb.cgi?a=blobdiff_plain;f=tests%2Flibpspp%2Fllx-test.c;h=7d95474d49b541edd6eea022585d0766f17aa58c;hb=b525a9596e60d5ae4c6c464b4a426b77ade3dd72;hp=4a2defbc012a8ea90abd8bc05d2b1b065ebe5d41;hpb=89c05dfe33f9542e60e66dd383f7a514849b5947;p=pspp

diff --git a/tests/libpspp/llx-test.c b/tests/libpspp/llx-test.c
index 4a2defbc01..7d95474d49 100644
--- a/tests/libpspp/llx-test.c
+++ b/tests/libpspp/llx-test.c
@@ -162,14 +162,14 @@ print_pred (struct llx_list *list,
   printf ("\n");
 }
 
-/* Prints the CNT numbers in VALUES. */
+/* Prints the N numbers in VALUES. */
 static void UNUSED
-print_array (int values[], size_t cnt)
+print_array (int values[], size_t n)
 {
   size_t i;
 
   printf ("arry:");
-  for (i = 0; i < cnt; i++)
+  for (i = 0; i < n; i++)
     printf (" %d", values[i]);
   printf ("\n");
 }
@@ -268,13 +268,13 @@ allocate_elements (size_t n,
     *values = xnmalloc (n, sizeof *values);
 }
 
-/* Copies the CNT values of `x' from LIST into VALUES[]. */
+/* Copies the N values of `x' from LIST into VALUES[]. */
 static void
-extract_values (struct llx_list *list, int values[], size_t cnt)
+extract_values (struct llx_list *list, int values[], size_t n)
 {
   struct llx *x;
 
-  check (llx_count (list) == cnt);
+  check (llx_count (list) == n);
   for (x = llx_head (list); x != llx_null (list); x = llx_next (x))
     {
       struct element *e = llx_data (x);
@@ -323,18 +323,18 @@ allocate_pattern (size_t n,
     extract_values (list, *values, n);
 }
 
-/* Randomly shuffles the CNT elements in ARRAY, each of which is
+/* Randomly shuffles the N elements in ARRAY, each of which is
    SIZE bytes in size. */
 static void
-random_shuffle (void *array_, size_t cnt, size_t size)
+random_shuffle (void *array_, size_t n, size_t size)
 {
   char *array = array_;
   char *tmp = xmalloc (size);
   size_t i;
 
-  for (i = 0; i < cnt; i++)
+  for (i = 0; i < n; i++)
     {
-      size_t j = rand () % (cnt - i) + i;
+      size_t j = rand () % (n - i) + i;
       if (i != j)
         {
           memcpy (tmp, array + j * size, size);
@@ -404,17 +404,17 @@ compare_ints_noaux (const void *a_, const void *b_)
   return *a < *b ? -1 : *a > *b;
 }
 
-/* Checks that LIST contains the CNT values in ELEMENTS. */
+/* Checks that LIST contains the N values in ELEMENTS. */
 static void
-check_list_contents (struct llx_list *list, int elements[], size_t cnt)
+check_list_contents (struct llx_list *list, int elements[], size_t n)
 {
   struct llx *llx;
   size_t i;
 
-  check ((cnt == 0) == llx_is_empty (list));
+  check ((n == 0) == llx_is_empty (list));
 
   /* Iterate in forward order. */
-  for (llx = llx_head (list), i = 0; i < cnt; llx = llx_next (llx), i++)
+  for (llx = llx_head (list), i = 0; i < n; llx = llx_next (llx), i++)
     {
       struct element *e = llx_data (llx);
       check (elements[i] == e->x);
@@ -423,15 +423,15 @@ check_list_contents (struct llx_list *list, int elements[], size_t cnt)
   check (llx == llx_null (list));
 
   /* Iterate in reverse order. */
-  for (llx = llx_tail (list), i = 0; i < cnt; llx = llx_prev (llx), i++)
+  for (llx = llx_tail (list), i = 0; i < n; llx = llx_prev (llx), i++)
     {
       struct element *e = llx_data (llx);
-      check (elements[cnt - i - 1] == e->x);
+      check (elements[n - i - 1] == e->x);
       check (llx != llx_null (list));
     }
   check (llx == llx_null (list));
 
-  check (llx_count (list) == cnt);
+  check (llx_count (list) == n);
 }
 
 /* Lexicographicallxy compares ARRAY1, which contains COUNT1
@@ -524,22 +524,22 @@ static void
 test_insert_remove (void)
 {
   const int max_elems = 16;
-  int cnt;
+  int n;
 
-  for (cnt = 0; cnt < max_elems; cnt++)
+  for (n = 0; n < max_elems; n++)
     {
       struct element **elems;
       struct llx **elemp;
-      int *values = xnmalloc (cnt + 1, sizeof *values);
+      int *values = xnmalloc (n + 1, sizeof *values);
 
       struct llx_list list;
       struct element extra;
       struct llx *extra_llx;
       int pos;
 
-      allocate_ascending (cnt, &list, &elems, &elemp, NULL);
+      allocate_ascending (n, &list, &elems, &elemp, NULL);
       extra.x = -1;
-      for (pos = 0; pos <= cnt; pos++)
+      for (pos = 0; pos <= n; pos++)
         {
           int i, j;
 
@@ -550,15 +550,15 @@ test_insert_remove (void)
           for (i = 0; i < pos; i++)
             values[j++] = i;
           values[j++] = -1;
-          for (; i < cnt; i++)
+          for (; i < n; i++)
             values[j++] = i;
-          check_list_contents (&list, values, cnt + 1);
+          check_list_contents (&list, values, n + 1);
 
           llx_remove (extra_llx, &llx_malloc_mgr);
         }
-      check_list_contents (&list, values, cnt);
+      check_list_contents (&list, values, n);
 
-      free_elements (cnt, &list, elems, elemp, values);
+      free_elements (n, &list, elems, elemp, values);
     }
 }
 
@@ -567,9 +567,9 @@ static void
 test_swap (void)
 {
   const int max_elems = 8;
-  int cnt;
+  int n;
 
-  for (cnt = 0; cnt <= max_elems; cnt++)
+  for (n = 0; n <= max_elems; n++)
     {
       struct llx_list list;
       struct element **elems;
@@ -578,11 +578,11 @@ test_swap (void)
 
       int i, j, k;
 
-      allocate_ascending (cnt, &list, &elems, &elemp, &values);
-      check_list_contents (&list, values, cnt);
+      allocate_ascending (n, &list, &elems, &elemp, &values);
+      check_list_contents (&list, values, n);
 
-      for (i = 0; i < cnt; i++)
-        for (j = 0; j < cnt; j++)
+      for (i = 0; i < n; i++)
+        for (j = 0; j < n; j++)
           for (k = 0; k < 2; k++)
             {
               int t;
@@ -591,10 +591,10 @@ test_swap (void)
               t = values[i];
               values[i] = values[j];
               values[j] = t;
-              check_list_contents (&list, values, cnt);
+              check_list_contents (&list, values, n);
             }
 
-      free_elements (cnt, &list, elems, elemp, values);
+      free_elements (n, &list, elems, elemp, values);
     }
 }
 
@@ -603,13 +603,13 @@ static void
 test_swap_range (void)
 {
   const int max_elems = 8;
-  int cnt, a0, a1, b0, b1, r;
+  int n, a0, a1, b0, b1, r;
 
-  for (cnt = 0; cnt <= max_elems; cnt++)
-    for (a0 = 0; a0 <= cnt; a0++)
-      for (a1 = a0; a1 <= cnt; a1++)
-        for (b0 = a1; b0 <= cnt; b0++)
-          for (b1 = b0; b1 <= cnt; b1++)
+  for (n = 0; n <= max_elems; n++)
+    for (a0 = 0; a0 <= n; a0++)
+      for (a1 = a0; a1 <= n; a1++)
+        for (b0 = a1; b0 <= n; b0++)
+          for (b1 = b0; b1 <= n; b1++)
             for (r = 0; r < 2; r++)
               {
                 struct llx_list list;
@@ -619,8 +619,8 @@ test_swap_range (void)
 
                 int i, j;
 
-                allocate_ascending (cnt, &list, &elems, &elemp, &values);
-                check_list_contents (&list, values, cnt);
+                allocate_ascending (n, &list, &elems, &elemp, &values);
+                check_list_contents (&list, values, n);
 
                 j = 0;
                 for (i = 0; i < a0; i++)
@@ -631,17 +631,17 @@ test_swap_range (void)
                   values[j++] = i;
                 for (i = a0; i < a1; i++)
                   values[j++] = i;
-                for (i = b1; i < cnt; i++)
+                for (i = b1; i < n; i++)
                   values[j++] = i;
-                check (j == cnt);
+                check (j == n);
 
                 if (r == 0)
                   llx_swap_range (elemp[a0], elemp[a1], elemp[b0], elemp[b1]);
                 else
                   llx_swap_range (elemp[b0], elemp[b1], elemp[a0], elemp[a1]);
-                check_list_contents (&list, values, cnt);
+                check_list_contents (&list, values, n);
 
-                free_elements (cnt, &list, elems, elemp, values);
+                free_elements (n, &list, elems, elemp, values);
               }
 }
 
@@ -651,11 +651,11 @@ test_remove_range (void)
 {
   const int max_elems = 8;
 
-  int cnt, r0, r1;
+  int n, r0, r1;
 
-  for (cnt = 0; cnt <= max_elems; cnt++)
-    for (r0 = 0; r0 <= cnt; r0++)
-      for (r1 = r0; r1 <= cnt; r1++)
+  for (n = 0; n <= max_elems; n++)
+    for (r0 = 0; r0 <= n; r0++)
+      for (r1 = r0; r1 <= n; r1++)
         {
           struct llx_list list;
           struct element **elems;
@@ -664,19 +664,19 @@ test_remove_range (void)
 
           int i, j;
 
-          allocate_ascending (cnt, &list, &elems, &elemp, &values);
-          check_list_contents (&list, values, cnt);
+          allocate_ascending (n, &list, &elems, &elemp, &values);
+          check_list_contents (&list, values, n);
 
           j = 0;
           for (i = 0; i < r0; i++)
             values[j++] = i;
-          for (i = r1; i < cnt; i++)
+          for (i = r1; i < n; i++)
             values[j++] = i;
 
           llx_remove_range (elemp[r0], elemp[r1], &llx_malloc_mgr);
           check_list_contents (&list, values, j);
 
-          free_elements (cnt, &list, elems, elemp, values);
+          free_elements (n, &list, elems, elemp, values);
         }
 }
 
@@ -686,12 +686,12 @@ test_remove_equal (void)
 {
   const int max_elems = 8;
 
-  int cnt, r0, r1, eq_pat;
+  int n, r0, r1, eq_pat;
 
-  for (cnt = 0; cnt <= max_elems; cnt++)
-    for (r0 = 0; r0 <= cnt; r0++)
-      for (r1 = r0; r1 <= cnt; r1++)
-        for (eq_pat = 0; eq_pat <= 1 << cnt; eq_pat++)
+  for (n = 0; n <= max_elems; n++)
+    for (r0 = 0; r0 <= n; r0++)
+      for (r1 = r0; r1 <= n; r1++)
+        for (eq_pat = 0; eq_pat <= 1 << n; eq_pat++)
           {
             struct llx_list list;
             struct element **elems;
@@ -702,10 +702,10 @@ test_remove_equal (void)
             int remaining;
             int i;
 
-            allocate_elements (cnt, &list, &elems, &elemp, &values);
+            allocate_elements (n, &list, &elems, &elemp, &values);
 
             remaining = 0;
-            for (i = 0; i < cnt; i++)
+            for (i = 0; i < n; i++)
               {
                 int x = eq_pat & (1 << i) ? -1 : i;
                 bool delete = x == -1 && r0 <= i && i < r1;
@@ -718,10 +718,10 @@ test_remove_equal (void)
             check ((int) llx_remove_equal (elemp[r0], elemp[r1], &to_remove,
                                            compare_elements, &aux_data,
                                            &llx_malloc_mgr)
-                   == cnt - remaining);
+                   == n - remaining);
             check_list_contents (&list, values, remaining);
 
-            free_elements (cnt, &list, elems, elemp, values);
+            free_elements (n, &list, elems, elemp, values);
           }
 }
 
@@ -731,12 +731,12 @@ test_remove_if (void)
 {
   const int max_elems = 8;
 
-  int cnt, r0, r1, pattern;
+  int n, r0, r1, pattern;
 
-  for (cnt = 0; cnt <= max_elems; cnt++)
-    for (r0 = 0; r0 <= cnt; r0++)
-      for (r1 = r0; r1 <= cnt; r1++)
-        for (pattern = 0; pattern <= 1 << cnt; pattern++)
+  for (n = 0; n <= max_elems; n++)
+    for (r0 = 0; r0 <= n; r0++)
+      for (r1 = r0; r1 <= n; r1++)
+        for (pattern = 0; pattern <= 1 << n; pattern++)
           {
             struct llx_list list;
             struct element **elems;
@@ -746,10 +746,10 @@ test_remove_if (void)
             int remaining;
             int i;
 
-            allocate_ascending (cnt, &list, &elems, &elemp, &values);
+            allocate_ascending (n, &list, &elems, &elemp, &values);
 
             remaining = 0;
-            for (i = 0; i < cnt; i++)
+            for (i = 0; i < n; i++)
               {
                 bool delete = (pattern & (1 << i))  && r0 <= i && i < r1;
                 if (!delete)
@@ -759,10 +759,10 @@ test_remove_if (void)
             check ((int) llx_remove_if (elemp[r0], elemp[r1],
                                         pattern_pred, &pattern,
                                         &llx_malloc_mgr)
-                   == cnt - remaining);
+                   == n - remaining);
             check_list_contents (&list, values, remaining);
 
-            free_elements (cnt, &list, elems, elemp, values);
+            free_elements (n, &list, elems, elemp, values);
           }
 }
 
@@ -775,10 +775,10 @@ test_examine_equal_range (void (*helper) (int r0, int r1, int eq_pat,
 {
   const int max_elems = 8;
 
-  int cnt, r0, r1, eq_pat;
+  int n, r0, r1, eq_pat;
 
-  for (cnt = 0; cnt <= max_elems; cnt++)
-    for (eq_pat = 0; eq_pat <= 1 << cnt; eq_pat++)
+  for (n = 0; n <= max_elems; n++)
+    for (eq_pat = 0; eq_pat <= 1 << n; eq_pat++)
       {
         struct llx_list list;
         struct element **elems;
@@ -789,20 +789,20 @@ test_examine_equal_range (void (*helper) (int r0, int r1, int eq_pat,
 
         int i;
 
-        allocate_ascending (cnt, &list, &elems, &elemp, &values);
+        allocate_ascending (n, &list, &elems, &elemp, &values);
 
-        for (i = 0; i < cnt; i++)
+        for (i = 0; i < n; i++)
           if (eq_pat & (1 << i))
             values[i] = elems[i]->x = -1;
 
         to_find.x = -1;
-        for (r0 = 0; r0 <= cnt; r0++)
-          for (r1 = r0; r1 <= cnt; r1++)
+        for (r0 = 0; r0 <= n; r0++)
+          for (r1 = r0; r1 <= n; r1++)
             helper (r0, r1, eq_pat, &to_find, elemp);
 
-        check_list_contents (&list, values, cnt);
+        check_list_contents (&list, values, n);
 
-        free_elements (cnt, &list, elems, elemp, values);
+        free_elements (n, &list, elems, elemp, values);
       }
 }
 
@@ -814,25 +814,25 @@ test_examine_if_range (void (*helper) (int r0, int r1, int eq_pat,
 {
   const int max_elems = 8;
 
-  int cnt, r0, r1, eq_pat;
+  int n, r0, r1, eq_pat;
 
-  for (cnt = 0; cnt <= max_elems; cnt++)
-    for (eq_pat = 0; eq_pat <= 1 << cnt; eq_pat++)
+  for (n = 0; n <= max_elems; n++)
+    for (eq_pat = 0; eq_pat <= 1 << n; eq_pat++)
       {
         struct llx_list list;
         struct element **elems;
         struct llx **elemp;
         int *values;
 
-        allocate_ascending (cnt, &list, &elems, &elemp, &values);
+        allocate_ascending (n, &list, &elems, &elemp, &values);
 
-        for (r0 = 0; r0 <= cnt; r0++)
-          for (r1 = r0; r1 <= cnt; r1++)
+        for (r0 = 0; r0 <= n; r0++)
+          for (r1 = r0; r1 <= n; r1++)
             helper (r0, r1, eq_pat, elemp);
 
-        check_list_contents (&list, values, cnt);
+        check_list_contents (&list, values, n);
 
-        free_elements (cnt, &list, elems, elemp, values);
+        free_elements (n, &list, elems, elemp, values);
       }
 }
 
@@ -866,9 +866,9 @@ test_find (void)
 {
   const int max_elems = 8;
 
-  int cnt;
+  int n;
 
-  for (cnt = 0; cnt <= max_elems; cnt++)
+  for (n = 0; n <= max_elems; n++)
     {
       struct llx_list list;
       struct element **elems;
@@ -877,14 +877,14 @@ test_find (void)
 
       int i;
 
-      allocate_ascending (cnt, &list, &elems, &elemp, &values);
+      allocate_ascending (n, &list, &elems, &elemp, &values);
 
-      for (i = 0; i < cnt; i++)
+      for (i = 0; i < n; i++)
         check (llx_find (llx_head (&list), llx_null (&list), elems[i])
                == elemp[i]);
       check (llx_find (llx_head (&list), llx_null (&list), NULL) == NULL);
 
-      free_elements (cnt, &list, elems, elemp, values);
+      free_elements (n, &list, elems, elemp, values);
     }
 }
 
@@ -916,10 +916,10 @@ test_find_adjacent_equal (void)
 {
   const int max_elems = 8;
 
-  int cnt, eq_pat;
+  int n, eq_pat;
 
-  for (cnt = 0; cnt <= max_elems; cnt++)
-    for (eq_pat = 0; eq_pat <= 1 << cnt; eq_pat++)
+  for (n = 0; n <= max_elems; n++)
+    for (eq_pat = 0; eq_pat <= 1 << n; eq_pat++)
       {
         struct llx_list list;
         struct element **elems;
@@ -929,10 +929,10 @@ test_find_adjacent_equal (void)
 
         int i;
 
-        allocate_ascending (cnt, &list, &elems, &elemp, &values);
+        allocate_ascending (n, &list, &elems, &elemp, &values);
 
         match = -1;
-        for (i = 0; i < cnt - 1; i++)
+        for (i = 0; i < n - 1; i++)
           {
             elems[i]->y = i;
             if (eq_pat & (1 << i))
@@ -944,7 +944,7 @@ test_find_adjacent_equal (void)
               match--;
           }
 
-        for (i = 0; i <= cnt; i++)
+        for (i = 0; i <= n; i++)
           {
             struct llx *llx1 = llx_find_adjacent_equal (elemp[i], llx_null (&list),
                                                         compare_elements,
@@ -953,7 +953,7 @@ test_find_adjacent_equal (void)
             int j;
 
             llx2 = llx_null (&list);
-            for (j = i; j < cnt - 1; j++)
+            for (j = i; j < n - 1; j++)
               if (eq_pat & (1 << j))
                 {
                   llx2 = elemp[j];
@@ -961,9 +961,9 @@ test_find_adjacent_equal (void)
                 }
             check (llx1 == llx2);
           }
-        check_list_contents (&list, values, cnt);
+        check_list_contents (&list, values, n);
 
-        free_elements (cnt, &list, elems, elemp, values);
+        free_elements (n, &list, elems, elemp, values);
       }
 }
 
@@ -1041,19 +1041,19 @@ factorial (unsigned int n)
   return value;
 }
 
-/* Returns the number of permutations of the CNT values in
+/* Returns the number of permutations of the N values in
    VALUES.  If VALUES contains duplicates, they must be
    adjacent. */
 static unsigned int
-expected_perms (int *values, size_t cnt)
+expected_perms (int *values, size_t n)
 {
   size_t i, j;
   unsigned int n_perms;
 
-  n_perms = factorial (cnt);
-  for (i = 0; i < cnt; i = j)
+  n_perms = factorial (n);
+  for (i = 0; i < n; i = j)
     {
-      for (j = i + 1; j < cnt; j++)
+      for (j = i + 1; j < n; j++)
         if (values[i] != values[j])
           break;
       n_perms /= factorial (j - i);
@@ -1066,19 +1066,19 @@ static void
 test_min_max (void)
 {
   const int max_elems = 6;
-  int cnt;
+  int n;
 
-  for (cnt = 0; cnt <= max_elems; cnt++)
+  for (n = 0; n <= max_elems; n++)
     {
       struct llx_list list;
       struct element **elems;
       struct llx **elemp;
       int *values;
-      int *new_values = xnmalloc (cnt, sizeof *values);
+      int *new_values = xnmalloc (n, sizeof *values);
 
       size_t n_perms;
 
-      allocate_ascending (cnt, &list, &elems, &elemp, &values);
+      allocate_ascending (n, &list, &elems, &elemp, &values);
 
       n_perms = 1;
       while (llx_next_permutation (llx_head (&list), llx_null (&list),
@@ -1095,8 +1095,8 @@ test_min_max (void)
               elemp[i] = x;
               new_values[i] = e->x;
             }
-          for (r0 = 0; r0 <= cnt; r0++)
-            for (r1 = r0; r1 <= cnt; r1++)
+          for (r0 = 0; r0 <= n; r0++)
+            for (r1 = r0; r1 <= n; r1++)
               {
                 struct llx *min = llx_min (elemp[r0], elemp[r1],
                                            compare_elements, &aux_data);
@@ -1129,10 +1129,10 @@ test_min_max (void)
               }
           n_perms++;
         }
-      check (n_perms == factorial (cnt));
-      check_list_contents (&list, values, cnt);
+      check (n_perms == factorial (n));
+      check_list_contents (&list, values, n);
 
-      free_elements (cnt, &list, elems, elemp, values);
+      free_elements (n, &list, elems, elemp, values);
       free (new_values);
     }
 }
@@ -1143,12 +1143,12 @@ test_lexicographical_compare_3way (void)
 {
   const int max_elems = 4;
 
-  int cnt_a, pat_a, cnt_b, pat_b;
+  int n_a, pat_a, n_b, pat_b;
 
-  for (cnt_a = 0; cnt_a <= max_elems; cnt_a++)
-    for (pat_a = 0; pat_a <= 1 << cnt_a; pat_a++)
-      for (cnt_b = 0; cnt_b <= max_elems; cnt_b++)
-        for (pat_b = 0; pat_b <= 1 << cnt_b; pat_b++)
+  for (n_a = 0; n_a <= max_elems; n_a++)
+    for (pat_a = 0; pat_a <= 1 << n_a; pat_a++)
+      for (n_b = 0; n_b <= max_elems; n_b++)
+        for (pat_b = 0; pat_b <= 1 << n_b; pat_b++)
           {
             struct llx_list list_a, list_b;
             struct element **elems_a, **elems_b;
@@ -1157,15 +1157,15 @@ test_lexicographical_compare_3way (void)
 
             int a0, a1, b0, b1;
 
-            allocate_pattern (cnt_a, pat_a,
+            allocate_pattern (n_a, pat_a,
                               &list_a, &elems_a, &elemp_a, &values_a);
-            allocate_pattern (cnt_b, pat_b,
+            allocate_pattern (n_b, pat_b,
                               &list_b, &elems_b, &elemp_b, &values_b);
 
-            for (a0 = 0; a0 <= cnt_a; a0++)
-              for (a1 = a0; a1 <= cnt_a; a1++)
-                for (b0 = 0; b0 <= cnt_b; b0++)
-                  for (b1 = b0; b1 <= cnt_b; b1++)
+            for (a0 = 0; a0 <= n_a; a0++)
+              for (a1 = a0; a1 <= n_a; a1++)
+                for (b0 = 0; b0 <= n_b; b0++)
+                  for (b1 = b0; b1 <= n_b; b1++)
                     {
                       int a_ordering = lexicographical_compare_3way (
                         values_a + a0, a1 - a0,
@@ -1181,8 +1181,8 @@ test_lexicographical_compare_3way (void)
                       check (a_ordering == b_ordering);
                     }
 
-            free_elements (cnt_a, &list_a, elems_a, elemp_a, values_a);
-            free_elements (cnt_b, &list_b, elems_b, elemp_b, values_b);
+            free_elements (n_a, &list_a, elems_a, elemp_a, values_a);
+            free_elements (n_b, &list_b, elems_b, elemp_b, values_b);
           }
 }
 
@@ -1203,11 +1203,11 @@ test_apply (void)
 {
   const int max_elems = 8;
 
-  int cnt, r0, r1;
+  int n, r0, r1;
 
-  for (cnt = 0; cnt <= max_elems; cnt++)
-    for (r0 = 0; r0 <= cnt; r0++)
-      for (r1 = r0; r1 <= cnt; r1++)
+  for (n = 0; n <= max_elems; n++)
+    for (r0 = 0; r0 <= n; r0++)
+      for (r1 = r0; r1 <= n; r1++)
         {
           struct llx_list list;
           struct element **elems;
@@ -1218,19 +1218,19 @@ test_apply (void)
           int *next_output;
           int j;
 
-          allocate_ascending (cnt, &list, &elems, &elemp, &values);
-          check_list_contents (&list, values, cnt);
+          allocate_ascending (n, &list, &elems, &elemp, &values);
+          check_list_contents (&list, values, n);
 
-          output = next_output = xnmalloc (cnt, sizeof *output);
+          output = next_output = xnmalloc (n, sizeof *output);
           llx_apply (elemp[r0], elemp[r1], apply_func, &next_output);
-          check_list_contents (&list, values, cnt);
+          check_list_contents (&list, values, n);
           llx_destroy (&list, NULL, NULL, &llx_malloc_mgr);
 
           check (r1 - r0 == next_output - output);
           for (j = 0; j < r1 - r0; j++)
             check (output[j] == r0 + j);
 
-          free_elements (cnt, NULL, elems, elemp, values);
+          free_elements (n, NULL, elems, elemp, values);
           free (output);
         }
 }
@@ -1241,9 +1241,9 @@ test_destroy (void)
 {
   const int max_elems = 8;
 
-  int cnt;
+  int n;
 
-  for (cnt = 0; cnt <= max_elems; cnt++)
+  for (n = 0; n <= max_elems; n++)
     {
       struct llx_list list;
       struct element **elems;
@@ -1254,17 +1254,17 @@ test_destroy (void)
       int *next_output;
       int j;
 
-      allocate_ascending (cnt, &list, &elems, &elemp, &values);
-      check_list_contents (&list, values, cnt);
+      allocate_ascending (n, &list, &elems, &elemp, &values);
+      check_list_contents (&list, values, n);
 
-      output = next_output = xnmalloc (cnt, sizeof *output);
+      output = next_output = xnmalloc (n, sizeof *output);
       llx_destroy (&list, apply_func, &next_output, &llx_malloc_mgr);
 
-      check (cnt == next_output - output);
-      for (j = 0; j < cnt; j++)
+      check (n == next_output - output);
+      for (j = 0; j < n; j++)
         check (output[j] == j);
 
-      free_elements (cnt, NULL, elems, elemp, values);
+      free_elements (n, NULL, elems, elemp, values);
       free (output);
     }
 }
@@ -1275,11 +1275,11 @@ test_reverse (void)
 {
   const int max_elems = 8;
 
-  int cnt, r0, r1;
+  int n, r0, r1;
 
-  for (cnt = 0; cnt <= max_elems; cnt++)
-    for (r0 = 0; r0 <= cnt; r0++)
-      for (r1 = r0; r1 <= cnt; r1++)
+  for (n = 0; n <= max_elems; n++)
+    for (r0 = 0; r0 <= n; r0++)
+      for (r1 = r0; r1 <= n; r1++)
         {
           struct llx_list list;
           struct element **elems;
@@ -1288,21 +1288,21 @@ test_reverse (void)
 
           int i, j;
 
-          allocate_ascending (cnt, &list, &elems, &elemp, &values);
-          check_list_contents (&list, values, cnt);
+          allocate_ascending (n, &list, &elems, &elemp, &values);
+          check_list_contents (&list, values, n);
 
           j = 0;
           for (i = 0; i < r0; i++)
             values[j++] = i;
           for (i = r1 - 1; i >= r0; i--)
             values[j++] = i;
-          for (i = r1; i < cnt; i++)
+          for (i = r1; i < n; i++)
             values[j++] = i;
 
           llx_reverse (elemp[r0], elemp[r1]);
-          check_list_contents (&list, values, cnt);
+          check_list_contents (&list, values, n);
 
-          free_elements (cnt, &list, elems, elemp, values);
+          free_elements (n, &list, elems, elemp, values);
         }
 }
 
@@ -1312,55 +1312,55 @@ static void
 test_permutations_no_dups (void)
 {
   const int max_elems = 8;
-  int cnt;
+  int n;
 
-  for (cnt = 0; cnt <= max_elems; cnt++)
+  for (n = 0; n <= max_elems; n++)
     {
       struct llx_list list;
       struct element **elems;
       int *values;
-      int *old_values = xnmalloc (cnt, sizeof *values);
-      int *new_values = xnmalloc (cnt, sizeof *values);
+      int *old_values = xnmalloc (n, sizeof *values);
+      int *new_values = xnmalloc (n, sizeof *values);
 
       size_t n_perms;
 
-      allocate_ascending (cnt, &list, &elems, NULL, &values);
+      allocate_ascending (n, &list, &elems, NULL, &values);
 
       n_perms = 1;
-      extract_values (&list, old_values, cnt);
+      extract_values (&list, old_values, n);
       while (llx_next_permutation (llx_head (&list), llx_null (&list),
                                    compare_elements, &aux_data))
         {
-          extract_values (&list, new_values, cnt);
-          check (lexicographical_compare_3way (new_values, cnt,
-                                               old_values, cnt,
+          extract_values (&list, new_values, n);
+          check (lexicographical_compare_3way (new_values, n,
+                                               old_values, n,
                                                sizeof *new_values,
                                                compare_ints, NULL) > 0);
-          memcpy (old_values, new_values, (cnt) * sizeof *old_values);
+          memcpy (old_values, new_values, (n) * sizeof *old_values);
           n_perms++;
         }
-      check (n_perms == factorial (cnt));
-      check_list_contents (&list, values, cnt);
+      check (n_perms == factorial (n));
+      check_list_contents (&list, values, n);
 
       n_perms = 1;
       llx_reverse (llx_head (&list), llx_null (&list));
-      extract_values (&list, old_values, cnt);
+      extract_values (&list, old_values, n);
       while (llx_prev_permutation (llx_head (&list), llx_null (&list),
                                    compare_elements, &aux_data))
         {
-          extract_values (&list, new_values, cnt);
-          check (lexicographical_compare_3way (new_values, cnt,
-                                               old_values, cnt,
+          extract_values (&list, new_values, n);
+          check (lexicographical_compare_3way (new_values, n,
+                                               old_values, n,
                                                sizeof *new_values,
                                                compare_ints, NULL) < 0);
-          memcpy (old_values, new_values, (cnt) * sizeof *old_values);
+          memcpy (old_values, new_values, (n) * sizeof *old_values);
           n_perms++;
         }
-      check (n_perms == factorial (cnt));
+      check (n_perms == factorial (n));
       llx_reverse (llx_head (&list), llx_null (&list));
-      check_list_contents (&list, values, cnt);
+      check_list_contents (&list, values, n);
 
-      free_elements (cnt, &list, elems, NULL, values);
+      free_elements (n, &list, elems, NULL, values);
       free (old_values);
       free (new_values);
     }
@@ -1375,10 +1375,8 @@ test_permutations_with_dups (void)
   const int max_dup = 3;
   const int repetitions = 1024;
 
-  int cnt, repeat;
-
-  for (repeat = 0; repeat < repetitions; repeat++)
-    for (cnt = 0; cnt < max_elems; cnt++)
+  for (int repeat = 0; repeat < repetitions; repeat++)
+    for (int n_elems = 0; n_elems < max_elems; n_elems++)
       {
         struct llx_list list;
         struct element **elems;
@@ -1388,10 +1386,10 @@ test_permutations_with_dups (void)
         int *new_values = xnmalloc (max_elems, sizeof *values);
 
         unsigned int n_permutations;
-        int left = cnt;
+        int left = n_elems;
         int value = 0;
 
-        allocate_elements (cnt, &list, &elems, &elemp, &values);
+        allocate_elements (n_elems, &list, &elems, &elemp, &values);
 
         value = 0;
         while (left > 0)
@@ -1400,46 +1398,46 @@ test_permutations_with_dups (void)
             int n = rand () % max + 1;
             while (n-- > 0)
               {
-                int idx = cnt - left--;
+                int idx = n_elems - left--;
                 values[idx] = elems[idx]->x = value;
               }
             value++;
           }
 
         n_permutations = 1;
-        extract_values (&list, old_values, cnt);
+        extract_values (&list, old_values, n_elems);
         while (llx_next_permutation (llx_head (&list), llx_null (&list),
                                      compare_elements, &aux_data))
           {
-            extract_values (&list, new_values, cnt);
-            check (lexicographical_compare_3way (new_values, cnt,
-                                                 old_values, cnt,
+            extract_values (&list, new_values, n_elems);
+            check (lexicographical_compare_3way (new_values, n_elems,
+                                                 old_values, n_elems,
                                                  sizeof *new_values,
                                                  compare_ints, NULL) > 0);
-            memcpy (old_values, new_values, cnt * sizeof *old_values);
+            memcpy (old_values, new_values, n_elems * sizeof *old_values);
             n_permutations++;
           }
-        check (n_permutations == expected_perms (values, cnt));
-        check_list_contents (&list, values, cnt);
+        check (n_permutations == expected_perms (values, n_elems));
+        check_list_contents (&list, values, n_elems);
 
         n_permutations = 1;
         llx_reverse (llx_head (&list), llx_null (&list));
-        extract_values (&list, old_values, cnt);
+        extract_values (&list, old_values, n_elems);
         while (llx_prev_permutation (llx_head (&list), llx_null (&list),
                                      compare_elements, &aux_data))
           {
-            extract_values (&list, new_values, cnt);
-            check (lexicographical_compare_3way (new_values, cnt,
-                                                 old_values, cnt,
+            extract_values (&list, new_values, n_elems);
+            check (lexicographical_compare_3way (new_values, n_elems,
+                                                 old_values, n_elems,
                                                  sizeof *new_values,
                                                  compare_ints, NULL) < 0);
             n_permutations++;
           }
         llx_reverse (llx_head (&list), llx_null (&list));
-        check (n_permutations == expected_perms (values, cnt));
-        check_list_contents (&list, values, cnt);
+        check (n_permutations == expected_perms (values, n_elems));
+        check_list_contents (&list, values, n_elems);
 
-        free_elements (cnt, &list, elems, elemp, values);
+        free_elements (n_elems, &list, elems, elemp, values);
         free (old_values);
         free (new_values);
       }
@@ -1526,11 +1524,11 @@ test_merge_with_dups (void)
 {
   const int max_elems = 8;
 
-  int cnt, merge_pat, inc_pat, order;
+  int n, 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++)
+  for (n = 0; n <= max_elems; n++)
+    for (merge_pat = 0; merge_pat <= (1 << n); merge_pat++)
+      for (inc_pat = 0; inc_pat <= (1 << n); inc_pat++)
         for (order = 0; order < 2; order++)
           {
             struct llx_list list;
@@ -1541,10 +1539,10 @@ test_merge_with_dups (void)
             int mid;
             int i, j, k;
 
-            allocate_elements (cnt, &list, &elems, &elemp, &values);
+            allocate_elements (n, &list, &elems, &elemp, &values);
 
             j = 0;
-            for (i = k = 0; i < cnt; i++)
+            for (i = k = 0; i < n; i++)
               {
                 if (merge_pat & (1u << i))
                   elems[j++]->x = k;
@@ -1552,49 +1550,49 @@ test_merge_with_dups (void)
                   k++;
               }
             mid = j;
-            for (i = k = 0; i < cnt; i++)
+            for (i = k = 0; i < n; i++)
               {
                 if (!(merge_pat & (1u << i)))
                   elems[j++]->x = k;
                 if (inc_pat & (1u << i))
                   k++;
               }
-            check (cnt == j);
+            check (n == j);
 
             if (order == 0)
               {
-                for (i = 0; i < cnt; i++)
+                for (i = 0; i < n; i++)
                   elems[i]->y = i;
               }
             else
               {
                 for (i = 0; i < mid; i++)
                   elems[i]->y = 100 + i;
-                for (i = mid; i < cnt; i++)
+                for (i = mid; i < n; i++)
                   elems[i]->y = i;
               }
 
             j = 0;
-            for (i = k = 0; i < cnt; i++)
+            for (i = k = 0; i < n; i++)
               {
                 values[j++] = k;
                 if (inc_pat & (1u << i))
                   k++;
               }
-            check (cnt == j);
+            check (n == j);
 
             if (order == 0)
-              llx_merge (elemp[0], elemp[mid], elemp[mid], elemp[cnt],
+              llx_merge (elemp[0], elemp[mid], elemp[mid], elemp[n],
                          compare_elements, &aux_data);
             else
-              llx_merge (elemp[mid], elemp[cnt], elemp[0], elemp[mid],
+              llx_merge (elemp[mid], elemp[n], elemp[0], elemp[mid],
                          compare_elements, &aux_data);
 
-            check_list_contents (&list, values, cnt);
+            check_list_contents (&list, values, n);
             check (llx_is_sorted (llx_head (&list), llx_null (&list),
                                   compare_elements_x_y, &aux_data));
 
-            free_elements (cnt, &list, elems, elemp, values);
+            free_elements (n, &list, elems, elemp, values);
           }
 }
 
@@ -1604,9 +1602,9 @@ static void
 test_sort_exhaustive (void)
 {
   const int max_elems = 8;
-  int cnt;
+  int n;
 
-  for (cnt = 0; cnt <= max_elems; cnt++)
+  for (n = 0; n <= max_elems; n++)
     {
       struct llx_list list;
       struct element **elems;
@@ -1617,8 +1615,8 @@ test_sort_exhaustive (void)
 
       size_t n_perms;
 
-      allocate_ascending (cnt, &list, &elems, NULL, &values);
-      allocate_elements (cnt, NULL, &perm_elems, NULL, &perm_values);
+      allocate_ascending (n, &list, &elems, NULL, &values);
+      allocate_elements (n, NULL, &perm_elems, NULL, &perm_values);
 
       n_perms = 1;
       while (llx_next_permutation (llx_head (&list), llx_null (&list),
@@ -1627,25 +1625,25 @@ test_sort_exhaustive (void)
           struct llx_list perm_list;
           int j;
 
-          extract_values (&list, perm_values, cnt);
+          extract_values (&list, perm_values, n);
           llx_init (&perm_list);
-          for (j = 0; j < cnt; j++)
+          for (j = 0; j < n; j++)
             {
               perm_elems[j]->x = perm_values[j];
               llx_push_tail (&perm_list, perm_elems[j], &llx_malloc_mgr);
             }
           llx_sort (llx_head (&perm_list), llx_null (&perm_list),
                     compare_elements, &aux_data);
-          check_list_contents (&perm_list, values, cnt);
+          check_list_contents (&perm_list, values, n);
           check (llx_is_sorted (llx_head (&perm_list), llx_null (&perm_list),
                                 compare_elements, &aux_data));
           llx_destroy (&perm_list, NULL, NULL, &llx_malloc_mgr);
           n_perms++;
         }
-      check (n_perms == factorial (cnt));
+      check (n_perms == factorial (n));
 
-      free_elements (cnt, &list, elems, NULL, values);
-      free_elements (cnt, NULL, perm_elems, NULL, perm_values);
+      free_elements (n, &list, elems, NULL, values);
+      free_elements (n, NULL, perm_elems, NULL, perm_values);
     }
 }
 
@@ -1655,10 +1653,10 @@ static void
 test_sort_stable (void)
 {
   const int max_elems = 6;
-  int cnt, inc_pat;
+  int n, inc_pat;
 
-  for (cnt = 0; cnt <= max_elems; cnt++)
-    for (inc_pat = 0; inc_pat <= 1 << cnt; inc_pat++)
+  for (n = 0; n <= max_elems; n++)
+    for (inc_pat = 0; inc_pat <= 1 << n; inc_pat++)
       {
         struct llx_list list;
         struct element **elems;
@@ -1670,11 +1668,11 @@ test_sort_stable (void)
         size_t n_perms;
         int i, j;
 
-        allocate_elements (cnt, &list, &elems, NULL, &values);
-        allocate_elements (cnt, NULL, &perm_elems, NULL, &perm_values);
+        allocate_elements (n, &list, &elems, NULL, &values);
+        allocate_elements (n, NULL, &perm_elems, NULL, &perm_values);
 
         j = 0;
-        for (i = 0; i < cnt; i++)
+        for (i = 0; i < n; i++)
           {
             elems[i]->x = values[i] = j;
             if (inc_pat & (1 << i))
@@ -1688,9 +1686,9 @@ test_sort_stable (void)
           {
             struct llx_list perm_list;
 
-            extract_values (&list, perm_values, cnt);
+            extract_values (&list, perm_values, n);
             llx_init (&perm_list);
-            for (i = 0; i < cnt; i++)
+            for (i = 0; i < n; i++)
               {
                 perm_elems[i]->x = perm_values[i];
                 perm_elems[i]->y = i;
@@ -1698,16 +1696,16 @@ test_sort_stable (void)
               }
             llx_sort (llx_head (&perm_list), llx_null (&perm_list),
                       compare_elements, &aux_data);
-            check_list_contents (&perm_list, values, cnt);
+            check_list_contents (&perm_list, values, n);
             check (llx_is_sorted (llx_head (&perm_list), llx_null (&perm_list),
                                   compare_elements_x_y, &aux_data));
             llx_destroy (&perm_list, NULL, NULL, &llx_malloc_mgr);
             n_perms++;
           }
-        check (n_perms == factorial (cnt));
+        check (n_perms == factorial (n));
 
-        free_elements (cnt, &list, elems, NULL, values);
-        free_elements (cnt, NULL, perm_elems, NULL, perm_values);
+        free_elements (n, &list, elems, NULL, values);
+        free_elements (n, NULL, perm_elems, NULL, perm_values);
       }
 }
 
@@ -1718,25 +1716,25 @@ test_sort_subset (void)
 {
   const int max_elems = 8;
 
-  int cnt, r0, r1, repeat;
+  int n, r0, r1, repeat;
 
-  for (cnt = 0; cnt <= max_elems; cnt++)
+  for (n = 0; n <= max_elems; n++)
     for (repeat = 0; repeat < 100; repeat++)
-      for (r0 = 0; r0 <= cnt; r0++)
-        for (r1 = r0; r1 <= cnt; r1++)
+      for (r0 = 0; r0 <= n; r0++)
+        for (r1 = r0; r1 <= n; r1++)
           {
             struct llx_list list;
             struct element **elems;
             struct llx **elemp;
             int *values;
 
-            allocate_random (cnt, &list, &elems, &elemp, &values);
+            allocate_random (n, &list, &elems, &elemp, &values);
 
             qsort (&values[r0], r1 - r0, sizeof *values, compare_ints_noaux);
             llx_sort (elemp[r0], elemp[r1], compare_elements, &aux_data);
-            check_list_contents (&list, values, cnt);
+            check_list_contents (&list, values, n);
 
-            free_elements (cnt, &list, elems, elemp, values);
+            free_elements (n, &list, elems, elemp, values);
           }
 }
 
@@ -1746,21 +1744,21 @@ test_sort_big (void)
 {
   const int max_elems = 1024;
 
-  int cnt;
+  int n;
 
-  for (cnt = 0; cnt < max_elems; cnt++)
+  for (n = 0; n < max_elems; n++)
     {
       struct llx_list list;
       struct element **elems;
       int *values;
 
-      allocate_random (cnt, &list, &elems, NULL, &values);
+      allocate_random (n, &list, &elems, NULL, &values);
 
-      qsort (values, cnt, sizeof *values, compare_ints_noaux);
+      qsort (values, n, sizeof *values, compare_ints_noaux);
       llx_sort (llx_head (&list), llx_null (&list), compare_elements, &aux_data);
-      check_list_contents (&list, values, cnt);
+      check_list_contents (&list, values, n);
 
-      free_elements (cnt, &list, elems, NULL, values);
+      free_elements (n, &list, elems, NULL, values);
     }
 }
 
@@ -1772,29 +1770,29 @@ test_unique (void)
 
   int *ascending = xnmalloc (max_elems, sizeof *ascending);
 
-  int cnt, inc_pat, i, j, unique_values;
+  int n, inc_pat, i, j, unique_values;
 
   for (i = 0; i < max_elems; i++)
     ascending[i] = i;
 
-  for (cnt = 0; cnt < max_elems; cnt++)
-    for (inc_pat = 0; inc_pat < (1 << cnt); inc_pat++)
+  for (n = 0; n < max_elems; n++)
+    for (inc_pat = 0; inc_pat < (1 << n); inc_pat++)
       {
         struct llx_list list, dups;
         struct element **elems;
         int *values;
 
-        allocate_elements (cnt, &list, &elems, NULL, &values);
+        allocate_elements (n, &list, &elems, NULL, &values);
 
         j = unique_values = 0;
-        for (i = 0; i < cnt; i++)
+        for (i = 0; i < n; i++)
           {
             unique_values = j + 1;
             elems[i]->x = values[i] = j;
             if (inc_pat & (1 << i))
               j++;
           }
-        check_list_contents (&list, values, cnt);
+        check_list_contents (&list, values, n);
 
         llx_init (&dups);
         check (llx_unique (llx_head (&list), llx_null (&list),
@@ -1806,10 +1804,10 @@ test_unique (void)
 
         llx_splice (llx_null (&list), llx_head (&dups), llx_null (&dups));
         llx_sort (llx_head (&list), llx_null (&list), compare_elements, &aux_data);
-        check_list_contents (&list, values, cnt);
+        check_list_contents (&list, values, n);
 
         llx_destroy (&dups, NULL, NULL, &llx_malloc_mgr);
-        free_elements (cnt, &list, elems, NULL, values);
+        free_elements (n, &list, elems, NULL, values);
       }
 
   free (ascending);
@@ -1820,10 +1818,10 @@ static void
 test_sort_unique (void)
 {
   const int max_elems = 7;
-  int cnt, inc_pat;
+  int n, inc_pat;
 
-  for (cnt = 0; cnt <= max_elems; cnt++)
-    for (inc_pat = 0; inc_pat <= 1 << cnt; inc_pat++)
+  for (n = 0; n <= max_elems; n++)
+    for (inc_pat = 0; inc_pat <= 1 << n; inc_pat++)
       {
         struct llx_list list;
         struct element **elems;
@@ -1838,11 +1836,11 @@ test_sort_unique (void)
         size_t n_perms;
         int i, j;
 
-        allocate_elements (cnt, &list, &elems, NULL, &values);
-        allocate_elements (cnt, NULL, &perm_elems, NULL, &perm_values);
+        allocate_elements (n, &list, &elems, NULL, &values);
+        allocate_elements (n, NULL, &perm_elems, NULL, &perm_values);
 
         j = n_uniques = 0;
-        for (i = 0; i < cnt; i++)
+        for (i = 0; i < n; i++)
           {
             elems[i]->x = values[i] = j;
             n_uniques = j + 1;
@@ -1860,9 +1858,9 @@ test_sort_unique (void)
           {
             struct llx_list perm_list;
 
-            extract_values (&list, perm_values, cnt);
+            extract_values (&list, perm_values, n);
             llx_init (&perm_list);
-            for (i = 0; i < cnt; i++)
+            for (i = 0; i < n; i++)
               {
                 perm_elems[i]->x = perm_values[i];
                 perm_elems[i]->y = i;
@@ -1877,10 +1875,10 @@ test_sort_unique (void)
             llx_destroy (&perm_list, NULL, NULL, &llx_malloc_mgr);
             n_perms++;
           }
-        check (n_perms == expected_perms (values, cnt));
+        check (n_perms == expected_perms (values, n));
 
-        free_elements (cnt, &list, elems, NULL, values);
-        free_elements (cnt, NULL, perm_elems, NULL, perm_values);
+        free_elements (n, &list, elems, NULL, values);
+        free_elements (n, NULL, perm_elems, NULL, perm_values);
         free (unique_values);
       }
 }
@@ -1890,10 +1888,10 @@ static void
 test_insert_ordered (void)
 {
   const int max_elems = 6;
-  int cnt, inc_pat;
+  int n, inc_pat;
 
-  for (cnt = 0; cnt <= max_elems; cnt++)
-    for (inc_pat = 0; inc_pat <= 1 << cnt; inc_pat++)
+  for (n = 0; n <= max_elems; n++)
+    for (inc_pat = 0; inc_pat <= 1 << n; inc_pat++)
       {
         struct llx_list list;
         struct element **elems;
@@ -1905,11 +1903,11 @@ test_insert_ordered (void)
         size_t n_perms;
         int i, j;
 
-        allocate_elements (cnt, &list, &elems, NULL, &values);
-        allocate_elements (cnt, NULL, &perm_elems, NULL, &perm_values);
+        allocate_elements (n, &list, &elems, NULL, &values);
+        allocate_elements (n, NULL, &perm_elems, NULL, &perm_values);
 
         j = 0;
-        for (i = 0; i < cnt; i++)
+        for (i = 0; i < n; i++)
           {
             elems[i]->x = values[i] = j;
             if (inc_pat & (1 << i))
@@ -1923,9 +1921,9 @@ test_insert_ordered (void)
           {
             struct llx_list perm_list;
 
-            extract_values (&list, perm_values, cnt);
+            extract_values (&list, perm_values, n);
             llx_init (&perm_list);
-            for (i = 0; i < cnt; i++)
+            for (i = 0; i < n; i++)
               {
                 perm_elems[i]->x = perm_values[i];
                 perm_elems[i]->y = i;
@@ -1940,10 +1938,10 @@ test_insert_ordered (void)
             llx_destroy (&perm_list, NULL, NULL, &llx_malloc_mgr);
             n_perms++;
           }
-        check (n_perms == factorial (cnt));
+        check (n_perms == factorial (n));
 
-        free_elements (cnt, &list, elems, NULL, values);
-        free_elements (cnt, NULL, perm_elems, NULL, perm_values);
+        free_elements (n, &list, elems, NULL, values);
+        free_elements (n, NULL, perm_elems, NULL, perm_values);
       }
 }
 
@@ -1953,13 +1951,13 @@ test_partition (void)
 {
   const int max_elems = 10;
 
-  int cnt;
+  int n;
   unsigned int pbase;
   int r0, r1;
 
-  for (cnt = 0; cnt < max_elems; cnt++)
-    for (r0 = 0; r0 <= cnt; r0++)
-      for (r1 = r0; r1 <= cnt; r1++)
+  for (n = 0; n < max_elems; n++)
+    for (r0 = 0; r0 <= n; r0++)
+      for (r1 = r0; r1 <= n; r1++)
         for (pbase = 0; pbase <= (1u << (r1 - r0)); pbase++)
           {
             struct llx_list list;
@@ -1972,7 +1970,7 @@ test_partition (void)
             int first_false;
             struct llx *part_llx;
 
-            allocate_ascending (cnt, &list, &elems, &elemp, &values);
+            allocate_ascending (n, &list, &elems, &elemp, &values);
 
             /* Check that llx_find_partition works okay in every
                case.  We use it after partitioning, too, but that
@@ -2009,9 +2007,9 @@ test_partition (void)
                 }
             if (first_false == -1)
               first_false = r1;
-            for (i = r1; i < cnt; i++)
+            for (i = r1; i < n; i++)
               values[j++] = i;
-            check (j == cnt);
+            check (j == n);
 
             /* Partition and check for expected results. */
             check (llx_partition (elemp[r0], elemp[r1],
@@ -2020,10 +2018,10 @@ test_partition (void)
             check (llx_find_partition (elemp[r0], elemp[r1],
                                        pattern_pred, &pattern)
                    == elemp[first_false]);
-            check_list_contents (&list, values, cnt);
-            check ((int) llx_count (&list) == cnt);
+            check_list_contents (&list, values, n);
+            check ((int) llx_count (&list) == n);
 
-            free_elements (cnt, &list, elems, elemp, values);
+            free_elements (n, &list, elems, elemp, values);
           }
 }