X-Git-Url: https://pintos-os.org/cgi-bin/gitweb.cgi?a=blobdiff_plain;f=tests%2Flibpspp%2Fllx-test.c;h=7d95474d49b541edd6eea022585d0766f17aa58c;hb=refs%2Fheads%2Fctables10;hp=34f46e8bbf8042105ad808ab8ee4266e79d2f708;hpb=a258e53c63a08b0ec48aea8f03808eb651729424;p=pspp diff --git a/tests/libpspp/llx-test.c b/tests/libpspp/llx-test.c index 34f46e8bbf..7d95474d49 100644 --- a/tests/libpspp/llx-test.c +++ b/tests/libpspp/llx-test.c @@ -30,7 +30,6 @@ #endif #include -#include #include #include #include @@ -163,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"); } @@ -269,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); @@ -324,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); @@ -405,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); @@ -424,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 @@ -525,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; @@ -551,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); } } @@ -568,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; @@ -579,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; @@ -592,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); } } @@ -604,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; @@ -620,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++) @@ -632,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); } } @@ -652,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; @@ -665,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); } } @@ -687,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; @@ -703,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; @@ -719,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); } } @@ -732,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; @@ -747,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) @@ -760,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); } } @@ -776,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; @@ -790,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); } } @@ -815,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); } } @@ -867,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; @@ -878,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); } } @@ -917,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; @@ -930,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)) @@ -945,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, @@ -954,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]; @@ -962,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); } } @@ -1042,24 +1041,24 @@ 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 perm_cnt; + unsigned int n_perms; - perm_cnt = 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; - perm_cnt /= factorial (j - i); + n_perms /= factorial (j - i); } - return perm_cnt; + return n_perms; } /* Tests llx_min and llx_max. */ @@ -1067,21 +1066,21 @@ 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 perm_cnt; + size_t n_perms; - allocate_ascending (cnt, &list, &elems, &elemp, &values); + allocate_ascending (n, &list, &elems, &elemp, &values); - perm_cnt = 1; + n_perms = 1; while (llx_next_permutation (llx_head (&list), llx_null (&list), compare_elements, &aux_data)) { @@ -1096,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); @@ -1128,12 +1127,12 @@ test_min_max (void) check (max != elemp[r1] && max_elem->x == max_int); } } - perm_cnt++; + n_perms++; } - check (perm_cnt == 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); } } @@ -1144,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; @@ -1158,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, @@ -1182,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); } } @@ -1204,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; @@ -1219,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); } } @@ -1242,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; @@ -1255,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); } } @@ -1276,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; @@ -1289,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); } } @@ -1313,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 perm_cnt; + size_t n_perms; - allocate_ascending (cnt, &list, &elems, NULL, &values); + allocate_ascending (n, &list, &elems, NULL, &values); - perm_cnt = 1; - extract_values (&list, old_values, cnt); + n_perms = 1; + 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); - perm_cnt++; + memcpy (old_values, new_values, (n) * sizeof *old_values); + n_perms++; } - check (perm_cnt == factorial (cnt)); - check_list_contents (&list, values, cnt); + check (n_perms == factorial (n)); + check_list_contents (&list, values, n); - perm_cnt = 1; + 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); - perm_cnt++; + memcpy (old_values, new_values, (n) * sizeof *old_values); + n_perms++; } - check (perm_cnt == 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); } @@ -1376,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,11 +1385,11 @@ test_permutations_with_dups (void) int *old_values = xnmalloc (max_elems, sizeof *values); int *new_values = xnmalloc (max_elems, sizeof *values); - unsigned int permutation_cnt; - int left = cnt; + unsigned int n_permutations; + 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) @@ -1401,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++; } - permutation_cnt = 1; - extract_values (&list, old_values, cnt); + n_permutations = 1; + 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); - permutation_cnt++; + memcpy (old_values, new_values, n_elems * sizeof *old_values); + n_permutations++; } - check (permutation_cnt == 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); - permutation_cnt = 1; + 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); - permutation_cnt++; + n_permutations++; } llx_reverse (llx_head (&list), llx_null (&list)); - check (permutation_cnt == 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); } @@ -1453,10 +1450,10 @@ test_merge_no_dups (void) const int max_elems = 8; const int max_fillxer = 3; - int merge_cnt, pattern, pfx, gap, sfx, order; + int n_merges, pattern, pfx, gap, sfx, order; - for (merge_cnt = 0; merge_cnt < max_elems; merge_cnt++) - for (pattern = 0; pattern <= (1 << merge_cnt); pattern++) + for (n_merges = 0; n_merges < max_elems; n_merges++) + for (pattern = 0; pattern <= (1 << n_merges); pattern++) for (pfx = 0; pfx < max_fillxer; pfx++) for (gap = 0; gap < max_fillxer; gap++) for (sfx = 0; sfx < max_fillxer; sfx++) @@ -1467,46 +1464,46 @@ test_merge_no_dups (void) struct llx **elemp; int *values; - int list_cnt = pfx + merge_cnt + gap + sfx; + int n_lists = pfx + n_merges + gap + sfx; int a0, a1, b0, b1; int i, j; - allocate_elements (list_cnt, &list, + allocate_elements (n_lists, &list, &elems, &elemp, &values); j = 0; for (i = 0; i < pfx; i++) elems[j++]->x = 100 + i; a0 = j; - for (i = 0; i < merge_cnt; i++) + for (i = 0; i < n_merges; i++) if (pattern & (1u << i)) elems[j++]->x = i; a1 = j; for (i = 0; i < gap; i++) elems[j++]->x = 200 + i; b0 = j; - for (i = 0; i < merge_cnt; i++) + for (i = 0; i < n_merges; i++) if (!(pattern & (1u << i))) elems[j++]->x = i; b1 = j; for (i = 0; i < sfx; i++) elems[j++]->x = 300 + i; - check (list_cnt == j); + check (n_lists == j); j = 0; for (i = 0; i < pfx; i++) values[j++] = 100 + i; if (order == 0) - for (i = 0; i < merge_cnt; i++) + for (i = 0; i < n_merges; i++) values[j++] = i; for (i = 0; i < gap; i++) values[j++] = 200 + i; if (order == 1) - for (i = 0; i < merge_cnt; i++) + for (i = 0; i < n_merges; i++) values[j++] = i; for (i = 0; i < sfx; i++) values[j++] = 300 + i; - check (list_cnt == j); + check (n_lists == j); if (order == 0) llx_merge (elemp[a0], elemp[a1], elemp[b0], elemp[b1], @@ -1515,9 +1512,9 @@ test_merge_no_dups (void) llx_merge (elemp[b0], elemp[b1], elemp[a0], elemp[a1], compare_elements, &aux_data); - check_list_contents (&list, values, list_cnt); + check_list_contents (&list, values, n_lists); - free_elements (list_cnt, &list, elems, elemp, values); + free_elements (n_lists, &list, elems, elemp, values); } } @@ -1527,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; @@ -1542,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; @@ -1553,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); } } @@ -1605,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; @@ -1616,37 +1613,37 @@ test_sort_exhaustive (void) struct element **perm_elems; int *perm_values; - size_t perm_cnt; + size_t n_perms; - allocate_ascending (cnt, &list, &elems, NULL, &values); - allocate_elements (cnt, NULL, &perm_elems, NULL, &perm_values); + allocate_ascending (n, &list, &elems, NULL, &values); + allocate_elements (n, NULL, &perm_elems, NULL, &perm_values); - perm_cnt = 1; + n_perms = 1; while (llx_next_permutation (llx_head (&list), llx_null (&list), compare_elements, &aux_data)) { 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); - perm_cnt++; + n_perms++; } - check (perm_cnt == 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); } } @@ -1656,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; @@ -1668,14 +1665,14 @@ test_sort_stable (void) struct element **perm_elems; int *perm_values; - size_t perm_cnt; + size_t n_perms; int i, j; - allocate_elements (cnt, &list, &elems, NULL, &values); - allocate_elements (cnt, NULL, &perm_elems, NULL, &perm_values); + 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)) @@ -1683,15 +1680,15 @@ test_sort_stable (void) elems[i]->y = i; } - perm_cnt = 1; + n_perms = 1; while (llx_next_permutation (llx_head (&list), llx_null (&list), compare_elements_y, &aux_data)) { 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; @@ -1699,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); - perm_cnt++; + n_perms++; } - check (perm_cnt == 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); } } @@ -1719,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); } } @@ -1747,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); } } @@ -1773,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), @@ -1807,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); @@ -1821,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; @@ -1833,37 +1830,37 @@ test_sort_unique (void) struct element **perm_elems; int *perm_values; - int unique_cnt; + int n_uniques; int *unique_values; - size_t perm_cnt; + size_t n_perms; int i, j; - allocate_elements (cnt, &list, &elems, NULL, &values); - allocate_elements (cnt, NULL, &perm_elems, NULL, &perm_values); + allocate_elements (n, &list, &elems, NULL, &values); + allocate_elements (n, NULL, &perm_elems, NULL, &perm_values); - j = unique_cnt = 0; - for (i = 0; i < cnt; i++) + j = n_uniques = 0; + for (i = 0; i < n; i++) { elems[i]->x = values[i] = j; - unique_cnt = j + 1; + n_uniques = j + 1; if (inc_pat & (1 << i)) j++; } - unique_values = xnmalloc (unique_cnt, sizeof *unique_values); - for (i = 0; i < unique_cnt; i++) + unique_values = xnmalloc (n_uniques, sizeof *unique_values); + for (i = 0; i < n_uniques; i++) unique_values[i] = i; - perm_cnt = 1; + n_perms = 1; while (llx_next_permutation (llx_head (&list), llx_null (&list), compare_elements, &aux_data)) { 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; @@ -1872,16 +1869,16 @@ test_sort_unique (void) llx_sort_unique (llx_head (&perm_list), llx_null (&perm_list), NULL, compare_elements, &aux_data, &llx_malloc_mgr); - check_list_contents (&perm_list, unique_values, unique_cnt); + check_list_contents (&perm_list, unique_values, n_uniques); 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); - perm_cnt++; + n_perms++; } - check (perm_cnt == 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); } } @@ -1891,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; @@ -1903,14 +1900,14 @@ test_insert_ordered (void) struct element **perm_elems; int *perm_values; - size_t perm_cnt; + size_t n_perms; int i, j; - allocate_elements (cnt, &list, &elems, NULL, &values); - allocate_elements (cnt, NULL, &perm_elems, NULL, &perm_values); + 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)) @@ -1918,15 +1915,15 @@ test_insert_ordered (void) elems[i]->y = i; } - perm_cnt = 1; + n_perms = 1; while (llx_next_permutation (llx_head (&list), llx_null (&list), compare_elements_y, &aux_data)) { 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; @@ -1939,12 +1936,12 @@ test_insert_ordered (void) 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); - perm_cnt++; + n_perms++; } - check (perm_cnt == 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); } } @@ -1954,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; @@ -1973,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 @@ -2010,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], @@ -2021,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); } }