X-Git-Url: https://pintos-os.org/cgi-bin/gitweb.cgi?a=blobdiff_plain;f=tests%2Flibpspp%2Fllx-test.c;h=7d95474d49b541edd6eea022585d0766f17aa58c;hb=e784ed9c161b6b7aec1402de566e6c09cb2031e0;hp=f8fe9b73618578f50f8dad56f18a3c261122b3f3;hpb=f550aee00a62fe1d8baf62d83cd7efef6cc2ee92;p=pspp diff --git a/tests/libpspp/llx-test.c b/tests/libpspp/llx-test.c index f8fe9b7361..7d95474d49 100644 --- a/tests/libpspp/llx-test.c +++ b/tests/libpspp/llx-test.c @@ -30,7 +30,6 @@ #endif #include -#include #include #include #include @@ -42,9 +41,6 @@ #define UNUSED #endif -/* Currently running test. */ -static const char *test_name; - /* Exit with a failure code. (Place a breakpoint on this function while debugging.) */ static void @@ -60,8 +56,7 @@ check_func (bool ok, int line) { if (!ok) { - printf ("Check failed in %s test at %s, line %d\n", - test_name, __FILE__, line); + fprintf (stderr, "%s:%d: check failed\n", __FILE__, line); check_die (); } } @@ -167,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"); } @@ -273,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); @@ -328,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); @@ -409,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); @@ -428,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 @@ -529,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; @@ -555,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); } } @@ -572,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; @@ -583,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; @@ -596,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); } } @@ -608,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; @@ -624,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++) @@ -636,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); } } @@ -656,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; @@ -669,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); } } @@ -691,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; @@ -707,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; @@ -723,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); } } @@ -736,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; @@ -751,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) @@ -764,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); } } @@ -780,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; @@ -794,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); } } @@ -819,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); } } @@ -871,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; @@ -882,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); } } @@ -921,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; @@ -934,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)) @@ -949,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, @@ -958,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]; @@ -966,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); } } @@ -1046,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. */ @@ -1071,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)) { @@ -1100,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); @@ -1132,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); } } @@ -1148,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; @@ -1162,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, @@ -1186,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); } } @@ -1208,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; @@ -1223,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); } } @@ -1246,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; @@ -1259,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); } } @@ -1280,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; @@ -1293,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); } } @@ -1317,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); } @@ -1380,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; @@ -1392,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) @@ -1405,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); } @@ -1457,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++) @@ -1471,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], @@ -1519,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); } } @@ -1531,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; @@ -1546,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; @@ -1557,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); } } @@ -1609,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; @@ -1620,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); } } @@ -1660,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; @@ -1672,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)) @@ -1687,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; @@ -1703,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); } } @@ -1723,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); } } @@ -1751,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); } } @@ -1777,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), @@ -1811,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); @@ -1825,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; @@ -1837,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; @@ -1876,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); } } @@ -1895,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; @@ -1907,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)) @@ -1922,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; @@ -1943,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); } } @@ -1958,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; @@ -1977,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 @@ -2014,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], @@ -2025,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); } } @@ -2047,58 +2040,209 @@ test_allocation_failure (void) /* Main program. */ -/* Runs TEST_FUNCTION and prints a message about NAME. */ -static void -run_test (void (*test_function) (void), const char *name) -{ - test_name = name; - putchar ('.'); - fflush (stdout); - test_function (); -} +struct test + { + const char *name; + const char *description; + void (*function) (void); + }; + +static const struct test tests[] = + { + { + "push-pop", + "push/pop", + test_push_pop + }, + { + "insert-remove", + "insert/remove", + test_insert_remove + }, + { + "swap", + "swap", + test_swap + }, + { + "swap-range", + "swap_range", + test_swap_range + }, + { + "remove-range", + "remove_range", + test_remove_range + }, + { + "remove-equal", + "remove_equal", + test_remove_equal + }, + { + "remove-if", + "remove_if", + test_remove_if + }, + { + "find-equal", + "find_equal", + test_find_equal + }, + { + "find", + "find", + test_find + }, + { + "find-if", + "find_if", + test_find_if + }, + { + "find-adjacent-equal", + "find_adjacent_equal", + test_find_adjacent_equal + }, + { + "count-range", + "count_range", + test_count_range + }, + { + "count-equal", + "count_equal", + test_count_equal + }, + { + "count-if", + "count_if", + test_count_if + }, + { + "min-max", + "min/max", + test_min_max + }, + { + "lexicographical-compare-3way", + "lexicographical_compare_3way", + test_lexicographical_compare_3way + }, + { + "apply", + "apply", + test_apply + }, + { + "destroy", + "destroy", + test_destroy + }, + { + "reverse", + "reverse", + test_reverse + }, + { + "permutations-no-dups", + "permutations (no dups)", + test_permutations_no_dups + }, + { + "permutations-with-dups", + "permutations (with dups)", + test_permutations_with_dups + }, + { + "merge-no-dups", + "merge (no dups)", + test_merge_no_dups + }, + { + "merge-with-dups", + "merge (with dups)", + test_merge_with_dups + }, + { + "sort-exhaustive", + "sort (exhaustive)", + test_sort_exhaustive + }, + { + "sort-stable", + "sort (stability)", + test_sort_stable + }, + { + "sort-subset", + "sort (subset)", + test_sort_subset + }, + { + "sort-big", + "sort (big)", + test_sort_big + }, + { + "unique", + "unique", + test_unique + }, + { + "sort-unique", + "sort_unique", + test_sort_unique + }, + { + "insert-ordered", + "insert_ordered", + test_insert_ordered + }, + { + "partition", + "partition", + test_partition + }, + { + "allocation-failure", + "allocation failure", + test_allocation_failure + }, + }; + +enum { N_TESTS = sizeof tests / sizeof *tests }; int -main (void) -{ - run_test (test_push_pop, "push/pop"); - run_test (test_insert_remove, "insert/remove"); - run_test (test_swap, "swap"); - run_test (test_swap_range, "swap_range"); - run_test (test_remove_range, "remove_range"); - run_test (test_remove_equal, "remove_equal"); - run_test (test_remove_if, "remove_if"); - run_test (test_find_equal, "find_equal"); - run_test (test_find, "find"); - run_test (test_find_if, "find_if"); - run_test (test_find_adjacent_equal, "find_adjacent_equal"); - run_test (test_count_range, "count_range"); - run_test (test_count_equal, "count_equal"); - run_test (test_count_if, "count_if"); - run_test (test_min_max, "min/max"); - run_test (test_lexicographical_compare_3way, "lexicographical_compare_3way"); - run_test (test_apply, "apply"); - run_test (test_destroy, "destroy"); - run_test (test_reverse, "reverse"); - run_test (test_permutations_no_dups, "permutations (no dups)"); - run_test (test_permutations_with_dups, "permutations (with dups)"); - run_test (test_merge_no_dups, "merge (no dups)"); - run_test (test_merge_with_dups, "merge (with dups)"); - run_test (test_sort_exhaustive, "sort (exhaustive)"); - run_test (test_sort_stable, "sort (stability)"); - run_test (test_sort_subset, "sort (subset)"); - run_test (test_sort_big, "sort (big)"); - run_test (test_unique, "unique"); - run_test (test_sort_unique, "sort_unique"); - run_test (test_insert_ordered, "insert_ordered"); - run_test (test_partition, "partition"); - run_test (test_allocation_failure, "allocation failure"); - putchar ('\n'); - - return 0; -} - -/* - Local Variables: - compile-command: "gcc -Wall -Wstrict-prototypes -Wmissing-prototypes ll.c llx.c llx-test.c -o llx-test -g" - End: - */ +main (int argc, char *argv[]) +{ + int i; + + if (argc != 2) + { + fprintf (stderr, "exactly one argument required; use --help for help\n"); + return EXIT_FAILURE; + } + else if (!strcmp (argv[1], "--help")) + { + printf ("%s: test doubly linked list of pointers (llx) library\n" + "usage: %s TEST-NAME\n" + "where TEST-NAME is one of the following:\n", + argv[0], argv[0]); + for (i = 0; i < N_TESTS; i++) + printf (" %s\n %s\n", tests[i].name, tests[i].description); + return 0; + } + else + { + for (i = 0; i < N_TESTS; i++) + if (!strcmp (argv[1], tests[i].name)) + { + tests[i].function (); + return 0; + } + + fprintf (stderr, "unknown test %s; use --help for help\n", argv[1]); + return EXIT_FAILURE; + } +}