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");
}
*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);
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);
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);
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
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;
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);
}
}
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;
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;
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);
}
}
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;
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++)
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);
}
}
{
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;
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);
}
}
{
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;
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;
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);
}
}
{
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;
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)
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);
}
}
{
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;
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);
}
}
{
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);
}
}
{
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 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);
}
}
{
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;
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))
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,
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];
}
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);
}
}
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);
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),
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);
}
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);
}
}
{
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;
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,
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);
}
}
{
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;
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);
}
}
{
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 *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);
}
}
{
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;
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);
}
}
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);
}
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;
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)
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);
}
{
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;
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;
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);
}
}
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;
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),
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);
}
}
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;
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))
{
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;
}
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);
}
}
{
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);
}
}
{
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);
}
}
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),
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);
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;
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;
{
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;
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);
}
}
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;
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))
{
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;
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);
}
}
{
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;
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
}
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],
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);
}
}
projects / pspp / blobdiff