/* Exit with a failure code.
(Place a breakpoint on this function while debugging.) */
static void
-check_die (void)
+check_die (void)
{
- exit (EXIT_FAILURE);
+ exit (EXIT_FAILURE);
}
/* If OK is not true, prints a message about failure on the
current source file and the given LINE and terminates. */
static void
-check_func (bool ok, int line)
+check_func (bool ok, int line)
{
- if (!ok)
+ if (!ok)
{
printf ("Check failed in %s test at %s, line %d\n",
test_name, __FILE__, line);
/* Allocates and returns N bytes of memory. */
static void *
-xmalloc (size_t n)
+xmalloc (size_t n)
{
- if (n != 0)
+ if (n != 0)
{
void *p = malloc (n);
if (p == NULL)
/* Allocates and returns N * M bytes of memory. */
static void *
-xnmalloc (size_t n, size_t m)
+xnmalloc (size_t n, size_t m)
{
if ((size_t) -1 / m <= n)
xalloc_die ();
struct ll *x;
printf ("list:");
- for (x = ll_head (list); x != ll_null (list); x = ll_next (x))
+ for (x = ll_head (list); x != ll_null (list); x = ll_next (x))
{
struct element *e = ll_to_element (x);
printf (" %d", e->x);
AUX for each element in LIST. */
static void UNUSED
print_pred (struct ll_list *list,
- ll_predicate_func *predicate, void *aux UNUSED)
+ ll_predicate_func *predicate, void *aux UNUSED)
{
struct ll *x;
printf ("pred:");
- for (x = ll_head (list); x != ll_null (list); x = ll_next (x))
+ for (x = ll_head (list); x != ll_null (list); x = ll_next (x))
printf (" %d", predicate (x, aux));
printf ("\n");
}
/* Prints the CNT numbers in VALUES. */
static void UNUSED
-print_array (int values[], size_t cnt)
+print_array (int values[], size_t cnt)
{
size_t i;
/* Compares the `x' values in A and B and returns a strcmp-type
return value. Verifies that AUX points to aux_data. */
static int
-compare_elements (const struct ll *a_, const struct ll *b_, void *aux)
+compare_elements (const struct ll *a_, const struct ll *b_, void *aux)
{
const struct element *a = ll_to_element (a_);
const struct element *b = ll_to_element (b_);
strcmp-type return value. Verifies that AUX points to
aux_data. */
static int
-compare_elements_x_y (const struct ll *a_, const struct ll *b_, void *aux)
+compare_elements_x_y (const struct ll *a_, const struct ll *b_, void *aux)
{
const struct element *a = ll_to_element (a_);
const struct element *b = ll_to_element (b_);
/* Returns true if the bit in *PATTERN indicated by `x in
*ELEMENT is set, false otherwise. */
static bool
-pattern_pred (const struct ll *element_, void *pattern_)
+pattern_pred (const struct ll *element_, void *pattern_)
{
const struct element *element = ll_to_element (element_);
unsigned int *pattern = pattern_;
struct ll_list *list,
struct element ***elems,
struct ll ***elemp,
- int **values)
+ int **values)
{
size_t i;
ll_init (list);
*elems = xnmalloc (n, sizeof **elems);
- for (i = 0; i < n; i++)
+ for (i = 0; i < n; i++)
{
(*elems)[i] = xmalloc (sizeof ***elems);
if (list != NULL)
ll_push_tail (list, &(*elems)[i]->ll);
}
-
- if (elemp != NULL)
+
+ if (elemp != NULL)
{
*elemp = xnmalloc (n + 1, sizeof *elemp);
for (i = 0; i < n; i++)
(*elemp)[i] = &(*elems)[i]->ll;
(*elemp)[n] = ll_null (list);
}
-
+
if (values != NULL)
*values = xnmalloc (n, sizeof *values);
}
/* Copies the CNT values of `x' from LIST into VALUES[]. */
static void
-extract_values (struct ll_list *list, int values[], size_t cnt)
+extract_values (struct ll_list *list, int values[], size_t cnt)
{
struct ll *x;
-
+
check (ll_count (list) == cnt);
- for (x = ll_head (list); x != ll_null (list); x = ll_next (x))
+ for (x = ll_head (list); x != ll_null (list); x = ll_next (x))
{
struct element *e = ll_to_element (x);
*values++ = e->x;
struct ll_list *list,
struct element ***elems,
struct ll ***elemp,
- int **values)
+ int **values)
{
size_t i;
allocate_elements (n, list, elems, elemp, values);
- for (i = 0; i < n; i++)
+ for (i = 0; i < n; i++)
(*elems)[i]->x = i;
if (values != NULL)
- extract_values (list, *values, n);
+ extract_values (list, *values, n);
}
/* As allocate_elements, but sets binary values extracted from
struct ll_list *list,
struct element ***elems,
struct ll ***elemp,
- int **values)
+ int **values)
{
size_t i;
allocate_elements (n, list, elems, elemp, values);
-
- for (i = 0; i < n; i++)
+
+ for (i = 0; i < n; i++)
(*elems)[i]->x = (pattern & (1 << i)) != 0;
if (values != NULL)
- extract_values (list, *values, n);
+ extract_values (list, *values, n);
}
/* Randomly shuffles the CNT elements in ARRAY, each of which is
char *tmp = xmalloc (size);
size_t i;
- for (i = 0; i < cnt; i++)
+ for (i = 0; i < cnt; i++)
{
size_t j = rand () % (cnt - i) + i;
- if (i != j)
+ if (i != j)
{
memcpy (tmp, array + j * size, size);
memcpy (array + j * size, array + i * size, size);
struct ll_list *list,
struct element ***elems,
struct ll ***elemp,
- int **values)
+ int **values)
{
size_t i;
allocate_elements (n, list, elems, elemp, values);
-
- for (i = 0; i < n; i++)
+
+ for (i = 0; i < n; i++)
(*elems)[i]->x = i;
random_shuffle (*elems, n, sizeof **elems);
if (values != NULL)
- extract_values (list, *values, n);
+ extract_values (list, *values, n);
}
/* Frees the N elements of ELEMS, ELEMP, and VALUES. */
free_elements (size_t n,
struct element **elems,
struct ll **elemp,
- int *values)
+ int *values)
{
size_t i;
for (i = 0; i < n; i++)
free (elems[i]);
- free (elems);
+ free (elems);
free (elemp);
free (values);
}
/* Compares A and B and returns a strcmp-type return value. */
static int
-compare_ints (const void *a_, const void *b_, void *aux UNUSED)
+compare_ints (const void *a_, const void *b_, void *aux UNUSED)
{
const int *a = a_;
const int *b = b_;
/* Compares A and B and returns a strcmp-type return value. */
static int
-compare_ints_noaux (const void *a_, const void *b_)
+compare_ints_noaux (const void *a_, const void *b_)
{
const int *a = a_;
const int *b = b_;
/* Checks that LIST contains the CNT values in ELEMENTS. */
static void
-check_list_contents (struct ll_list *list, int elements[], size_t cnt)
+check_list_contents (struct ll_list *list, int elements[], size_t cnt)
{
struct ll *ll;
size_t i;
check ((cnt == 0) == ll_is_empty (list));
/* Iterate in forward order. */
- for (ll = ll_head (list), i = 0; i < cnt; ll = ll_next (ll), i++)
+ for (ll = ll_head (list), i = 0; i < cnt; ll = ll_next (ll), i++)
{
struct element *e = ll_to_element (ll);
check (elements[i] == e->x);
size_t size,
int (*compare) (const void *, const void *,
void *aux),
- void *aux)
+ void *aux)
{
const char *first1 = array1;
const char *first2 = array2;
/* Push on tail. */
ll_init (&list);
check_list_contents (&list, NULL, 0);
- for (i = 0; i < max_elems; i++)
+ for (i = 0; i < max_elems; i++)
{
values[i] = elems[i]->x = i;
ll_push_tail (&list, &elems[i]->ll);
}
/* Remove from tail. */
- for (i = 0; i < max_elems; i++)
+ for (i = 0; i < max_elems; i++)
{
struct element *e = ll_to_element (ll_pop_tail (&list));
check (e->x == max_elems - i - 1);
}
/* Remove from start. */
- for (i = 0; i < max_elems; i++)
+ for (i = 0; i < max_elems; i++)
{
struct element *e = ll_to_element (ll_pop_head (&list));
check (e->x == (int) i);
/* Tests insertion and removal at arbitrary positions. */
static void
-test_insert_remove (void)
+test_insert_remove (void)
{
const int max_elems = 16;
int cnt;
- for (cnt = 0; cnt < max_elems; cnt++)
+ for (cnt = 0; cnt < max_elems; cnt++)
{
struct element **elems;
struct ll **elemp;
allocate_ascending (cnt, &list, &elems, &elemp, NULL);
extra.x = -1;
- for (pos = 0; pos <= cnt; pos++)
+ for (pos = 0; pos <= cnt; pos++)
{
int i, j;
/* Tests swapping individual elements. */
static void
-test_swap (void)
+test_swap (void)
{
const int max_elems = 8;
int cnt;
- for (cnt = 0; cnt <= max_elems; cnt++)
+ for (cnt = 0; cnt <= max_elems; cnt++)
{
struct ll_list list;
struct element **elems;
allocate_ascending (cnt, &list, &elems, NULL, &values);
check_list_contents (&list, values, cnt);
- for (i = 0; i < cnt; i++)
- for (j = 0; j < cnt; j++)
- for (k = 0; k < 2; k++)
+ for (i = 0; i < cnt; i++)
+ for (j = 0; j < cnt; j++)
+ for (k = 0; k < 2; k++)
{
int t;
values[i] = values[j];
values[j] = t;
check_list_contents (&list, values, cnt);
- }
-
+ }
+
free_elements (cnt, elems, NULL, values);
}
}
/* Tests swapping ranges of list elements. */
static void
-test_swap_range (void)
+test_swap_range (void)
{
const int max_elems = 8;
int cnt, a0, a1, b0, b1, r;
- for (cnt = 0; cnt <= max_elems; cnt++)
- for (a0 = 0; a0 <= cnt; a0++)
+ 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 (b0 = a1; b0 <= cnt; b0++)
for (b1 = b0; b1 <= cnt; b1++)
for (r = 0; r < 2; r++)
{
/* Tests removing ranges of list elements. */
static void
-test_remove_range (void)
+test_remove_range (void)
{
const int max_elems = 8;
int cnt, r0, r1;
for (cnt = 0; cnt <= max_elems; cnt++)
- for (r0 = 0; r0 <= cnt; r0++)
+ for (r0 = 0; r0 <= cnt; r0++)
for (r1 = r0; r1 <= cnt; r1++)
{
struct ll_list list;
/* Tests ll_remove_equal. */
static void
-test_remove_equal (void)
+test_remove_equal (void)
{
const int max_elems = 8;
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 (eq_pat = 0; eq_pat <= 1 << cnt; eq_pat++)
{
struct ll_list list;
struct element **elems;
allocate_elements (cnt, &list, &elems, &elemp, &values);
remaining = 0;
- for (i = 0; i < cnt; i++)
+ for (i = 0; i < cnt; i++)
{
int x = eq_pat & (1 << i) ? -1 : i;
bool delete = x == -1 && r0 <= i && i < r1;
elems[i]->x = x;
if (!delete)
- values[remaining++] = x;
+ values[remaining++] = x;
}
to_remove.x = -1;
/* Tests ll_remove_if. */
static void
-test_remove_if (void)
+test_remove_if (void)
{
const int max_elems = 8;
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 (pattern = 0; pattern <= 1 << cnt; pattern++)
{
struct ll_list list;
struct element **elems;
allocate_elements (cnt, &list, &elems, &elemp, &values);
remaining = 0;
- for (i = 0; i < cnt; i++)
+ for (i = 0; i < cnt; i++)
{
bool delete = (pattern & (1 << i)) && r0 <= i && i < r1;
elems[i]->x = i;
if (!delete)
- values[remaining++] = i;
+ values[remaining++] = i;
}
- check ((int) ll_remove_if (elemp[r0], elemp[r1],
+ check ((int) ll_remove_if (elemp[r0], elemp[r1],
pattern_pred, &pattern)
== cnt - remaining);
check_list_contents (&list, values, remaining);
/* Tests ll_moved. */
static void
-test_moved (void)
+test_moved (void)
{
const int max_elems = 8;
allocate_elements (cnt, NULL, &new_elems, NULL, NULL);
check_list_contents (&list, values, cnt);
- for (i = 0; i < cnt; i++)
+ for (i = 0; i < cnt; i++)
{
*new_elems[i] = *elems[i];
ll_moved (&new_elems[i]->ll);
int cnt, r0, r1, eq_pat;
for (cnt = 0; cnt <= max_elems; cnt++)
- for (eq_pat = 0; eq_pat <= 1 << cnt; eq_pat++)
+ for (eq_pat = 0; eq_pat <= 1 << cnt; eq_pat++)
{
struct ll_list list;
struct element **elems;
int cnt, r0, r1, eq_pat;
for (cnt = 0; cnt <= max_elems; cnt++)
- for (eq_pat = 0; eq_pat <= 1 << cnt; eq_pat++)
+ for (eq_pat = 0; eq_pat <= 1 << cnt; eq_pat++)
{
struct ll_list list;
struct element **elems;
if (eq_pat & (1 << i))
break;
- check (match == elemp[i]);
+ check (match == elemp[i]);
}
/* Tests ll_find_equal. */
static void
-test_find_equal (void)
+test_find_equal (void)
{
test_examine_equal_range (test_find_equal_helper);
}
if (eq_pat & (1 << i))
break;
- check (match == elemp[i]);
+ check (match == elemp[i]);
}
/* Tests ll_find_if. */
static void
-test_find_if (void)
+test_find_if (void)
{
test_examine_if_range (test_find_if_helper);
}
/* Tests ll_find_adjacent_equal. */
static void
-test_find_adjacent_equal (void)
+test_find_adjacent_equal (void)
{
const int max_elems = 8;
int cnt, eq_pat;
for (cnt = 0; cnt <= max_elems; cnt++)
- for (eq_pat = 0; eq_pat <= 1 << cnt; eq_pat++)
+ for (eq_pat = 0; eq_pat <= 1 << cnt; eq_pat++)
{
struct ll_list list;
struct element **elems;
allocate_ascending (cnt, &list, &elems, &elemp, &values);
match = -1;
- for (i = 0; i < cnt - 1; i++)
+ for (i = 0; i < cnt - 1; i++)
{
elems[i]->y = i;
- if (eq_pat & (1 << i))
+ if (eq_pat & (1 << i))
{
values[i] = elems[i]->x = match;
values[i + 1] = elems[i + 1]->x = match;
else
match--;
}
-
+
for (i = 0; i <= cnt; i++)
{
struct ll *ll1 = ll_find_adjacent_equal (elemp[i], ll_null (&list),
ll2 = ll_null (&list);
for (j = i; j < cnt - 1; j++)
- if (eq_pat & (1 << j))
+ if (eq_pat & (1 << j))
{
ll2 = elemp[j];
break;
/* Tests ll_count_range. */
static void
-test_count_range (void)
+test_count_range (void)
{
test_examine_if_range (test_count_range_helper);
}
for (i = r0; i < r1; i++)
if (eq_pat & (1 << i))
count2++;
-
- check (count1 == count2);
+
+ check (count1 == count2);
}
/* Tests ll_count_equal. */
static void
-test_count_equal (void)
+test_count_equal (void)
{
test_examine_equal_range (test_count_equal_helper);
}
/* Helper function for testing ll_count_if. */
static void
-test_count_if_helper (int r0, int r1, int eq_pat, struct ll **elemp)
+test_count_if_helper (int r0, int r1, int eq_pat, struct ll **elemp)
{
int count1;
int count2;
if (eq_pat & (1 << i))
count2++;
- check (count1 == count2);
+ check (count1 == count2);
}
/* Tests ll_count_if. */
static void
-test_count_if (void)
+test_count_if (void)
{
test_examine_if_range (test_count_if_helper);
}
/* Returns N!. */
static unsigned int
-factorial (unsigned int n)
+factorial (unsigned int n)
{
unsigned int value = 1;
while (n > 1)
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 cnt)
{
size_t i, j;
unsigned int perm_cnt;
-
+
perm_cnt = factorial (cnt);
- for (i = 0; i < cnt; i = j)
+ for (i = 0; i < cnt; i = j)
{
for (j = i + 1; j < cnt; j++)
if (values[i] != values[j])
/* Tests ll_min and ll_max. */
static void
-test_min_max (void)
+test_min_max (void)
{
const int max_elems = 6;
int cnt;
- for (cnt = 0; cnt <= max_elems; cnt++)
+ for (cnt = 0; cnt <= max_elems; cnt++)
{
struct ll_list list;
struct element **elems;
perm_cnt = 1;
while (ll_next_permutation (ll_head (&list), ll_null (&list),
- compare_elements, &aux_data))
+ compare_elements, &aux_data))
{
int r0, r1;
struct ll *x;
int i;
-
+
for (i = 0, x = ll_head (&list); x != ll_null (&list);
- x = ll_next (x), i++)
+ x = ll_next (x), i++)
{
struct element *e = ll_to_element (x);
elemp[i] = x;
new_values[i] = e->x;
}
for (r0 = 0; r0 <= cnt; r0++)
- for (r1 = r0; r1 <= cnt; r1++)
+ for (r1 = r0; r1 <= cnt; r1++)
{
struct ll *min = ll_min (elemp[r0], elemp[r1],
compare_elements, &aux_data);
struct ll *max = ll_max (elemp[r0], elemp[r1],
compare_elements, &aux_data);
- if (r0 == r1)
+ if (r0 == r1)
{
check (min == elemp[r1]);
- check (max == elemp[r1]);
+ check (max == elemp[r1]);
}
- else
+ else
{
int min_int, max_int;
int i;
check (min != elemp[r1]
&& ll_to_element (min)->x == min_int);
check (max != elemp[r1]
- && ll_to_element (max)->x == max_int);
+ && ll_to_element (max)->x == max_int);
}
}
perm_cnt++;
/* Tests ll_lexicographical_compare_3way. */
static void
-test_lexicographical_compare_3way (void)
+test_lexicographical_compare_3way (void)
{
const int max_elems = 4;
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 (pat_b = 0; pat_b <= 1 << cnt_b; pat_b++)
{
struct ll_list list_a, list_b;
struct element **elems_a, **elems_b;
compare_elements, &aux_data);
check (a_ordering == b_ordering);
- }
+ }
free_elements (cnt_a, elems_a, elemp_a, values_a);
free_elements (cnt_b, elems_b, elemp_b, values_b);
/* Appends the `x' value in element E to the array pointed to by
NEXT_OUTPUT, and advances NEXT_OUTPUT to the next position. */
static void
-apply_func (struct ll *e_, void *next_output_)
+apply_func (struct ll *e_, void *next_output_)
{
struct element *e = ll_to_element (e_);
int **next_output = next_output_;
-
+
*(*next_output)++ = e->x;
}
/* Tests ll_apply. */
static void
-test_apply (void)
+test_apply (void)
{
const int max_elems = 8;
int cnt, r0, r1;
for (cnt = 0; cnt <= max_elems; cnt++)
- for (r0 = 0; r0 <= cnt; r0++)
+ for (r0 = 0; r0 <= cnt; r0++)
for (r1 = r0; r1 <= cnt; r1++)
{
struct ll_list list;
/* Tests ll_reverse. */
static void
-test_reverse (void)
+test_reverse (void)
{
const int max_elems = 8;
int cnt, r0, r1;
for (cnt = 0; cnt <= max_elems; cnt++)
- for (r0 = 0; r0 <= cnt; r0++)
+ for (r0 = 0; r0 <= cnt; r0++)
for (r1 = r0; r1 <= cnt; r1++)
{
struct ll_list list;
/* Tests ll_next_permutation and ll_prev_permutation when the
permuted values have no duplicates. */
static void
-test_permutations_no_dups (void)
+test_permutations_no_dups (void)
{
const int max_elems = 8;
int cnt;
- for (cnt = 0; cnt <= max_elems; cnt++)
+ for (cnt = 0; cnt <= max_elems; cnt++)
{
struct ll_list list;
struct element **elems;
perm_cnt = 1;
extract_values (&list, old_values, cnt);
while (ll_next_permutation (ll_head (&list), ll_null (&list),
- compare_elements, &aux_data))
+ compare_elements, &aux_data))
{
extract_values (&list, new_values, cnt);
check (lexicographical_compare_3way (new_values, cnt,
ll_reverse (ll_head (&list), ll_null (&list));
extract_values (&list, old_values, cnt);
while (ll_prev_permutation (ll_head (&list), ll_null (&list),
- compare_elements, &aux_data))
+ compare_elements, &aux_data))
{
extract_values (&list, new_values, cnt);
check (lexicographical_compare_3way (new_values, cnt,
/* Tests ll_next_permutation and ll_prev_permutation when the
permuted values contain duplicates. */
static void
-test_permutations_with_dups (void)
+test_permutations_with_dups (void)
{
const int max_elems = 8;
const int max_dup = 3;
int cnt, repeat;
for (repeat = 0; repeat < repetitions; repeat++)
- for (cnt = 0; cnt < max_elems; cnt++)
+ for (cnt = 0; cnt < max_elems; cnt++)
{
struct ll_list list;
struct element **elems;
unsigned int permutation_cnt;
int left = cnt;
int value = 0;
-
+
allocate_elements (cnt, &list, &elems, NULL, &values);
value = 0;
permutation_cnt = 1;
extract_values (&list, old_values, cnt);
while (ll_next_permutation (ll_head (&list), ll_null (&list),
- compare_elements, &aux_data))
+ compare_elements, &aux_data))
{
extract_values (&list, new_values, cnt);
check (lexicographical_compare_3way (new_values, cnt,
ll_reverse (ll_head (&list), ll_null (&list));
extract_values (&list, old_values, cnt);
while (ll_prev_permutation (ll_head (&list), ll_null (&list),
- compare_elements, &aux_data))
+ compare_elements, &aux_data))
{
extract_values (&list, new_values, cnt);
check (lexicographical_compare_3way (new_values, cnt,
/* Tests ll_merge when no equal values are to be merged. */
static void
-test_merge_no_dups (void)
+test_merge_no_dups (void)
{
const int max_elems = 8;
const int max_filler = 3;
int merge_cnt, pattern, pfx, gap, sfx, order;
-
+
for (merge_cnt = 0; merge_cnt < max_elems; merge_cnt++)
for (pattern = 0; pattern <= (1 << merge_cnt); pattern++)
for (pfx = 0; pfx < max_filler; pfx++)
/* Tests ll_merge when equal values are to be merged. */
static void
-test_merge_with_dups (void)
+test_merge_with_dups (void)
{
const int max_elems = 8;
int cnt, 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++)
allocate_elements (cnt, &list, &elems, &elemp, &values);
j = 0;
- for (i = k = 0; i < cnt; i++)
+ for (i = k = 0; i < cnt; i++)
{
- if (merge_pat & (1u << i))
+ if (merge_pat & (1u << i))
elems[j++]->x = k;
if (inc_pat & (1u << i))
k++;
mid = j;
for (i = k = 0; i < cnt; i++)
{
- if (!(merge_pat & (1u << i)))
+ if (!(merge_pat & (1u << i)))
elems[j++]->x = k;
if (inc_pat & (1u << i))
k++;
}
check (cnt == j);
- if (order == 0)
+ if (order == 0)
{
for (i = 0; i < cnt; i++)
- elems[i]->y = i;
+ elems[i]->y = i;
}
- else
+ else
{
for (i = 0; i < mid; i++)
elems[i]->y = 100 + i;
}
j = 0;
- for (i = k = 0; i < cnt; i++)
+ for (i = k = 0; i < cnt; i++)
{
values[j++] = k;
if (inc_pat & (1u << i))
- k++;
+ k++;
}
check (cnt == j);
/* Tests ll_sort on all permutations up to a maximum number of
elements. */
static void
-test_sort_exhaustive (void)
+test_sort_exhaustive (void)
{
const int max_elems = 8;
int cnt;
- for (cnt = 0; cnt <= max_elems; cnt++)
+ for (cnt = 0; cnt <= max_elems; cnt++)
{
struct ll_list list;
struct element **elems;
perm_cnt = 1;
while (ll_next_permutation (ll_head (&list), ll_null (&list),
- compare_elements, &aux_data))
+ compare_elements, &aux_data))
{
struct ll_list perm_list;
int j;
extract_values (&list, perm_values, cnt);
ll_init (&perm_list);
for (j = 0; j < cnt; j++)
- {
+ {
perm_elems[j]->x = perm_values[j];
ll_push_tail (&perm_list, &perm_elems[j]->ll);
}
check_list_contents (&perm_list, values, cnt);
check (ll_is_sorted (ll_head (&perm_list), ll_null (&perm_list),
compare_elements, &aux_data));
- perm_cnt++;
+ perm_cnt++;
}
check (perm_cnt == factorial (cnt));
/* Tests that ll_sort is stable in the presence of equal
values. */
static void
-test_sort_stable (void)
+test_sort_stable (void)
{
const int max_elems = 6;
int cnt, inc_pat;
allocate_elements (cnt, NULL, &perm_elems, NULL, &perm_values);
j = 0;
- for (i = 0; i < cnt; i++)
+ for (i = 0; i < cnt; i++)
{
elems[i]->x = values[i] = j;
if (inc_pat & (1 << i))
perm_cnt = 1;
while (ll_next_permutation (ll_head (&list), ll_null (&list),
- compare_elements_y, &aux_data))
+ compare_elements_y, &aux_data))
{
struct ll_list perm_list;
extract_values (&list, perm_values, cnt);
ll_init (&perm_list);
for (i = 0; i < cnt; i++)
- {
+ {
perm_elems[i]->x = perm_values[i];
perm_elems[i]->y = i;
ll_push_tail (&perm_list, &perm_elems[i]->ll);
check_list_contents (&perm_list, values, cnt);
check (ll_is_sorted (ll_head (&perm_list), ll_null (&perm_list),
compare_elements_x_y, &aux_data));
- perm_cnt++;
+ perm_cnt++;
}
check (perm_cnt == factorial (cnt));
for (cnt = 0; cnt <= max_elems; cnt++)
for (repeat = 0; repeat < 100; repeat++)
- for (r0 = 0; r0 <= cnt; r0++)
+ for (r0 = 0; r0 <= cnt; r0++)
for (r1 = r0; r1 <= cnt; r1++)
{
struct ll_list list;
/* Tests ll_unique. */
static void
-test_unique (void)
+test_unique (void)
{
const int max_elems = 10;
allocate_elements (cnt, &list, &elems, NULL, &values);
j = unique_values = 0;
- for (i = 0; i < cnt; i++)
+ for (i = 0; i < cnt; i++)
{
unique_values = j + 1;
elems[i]->x = values[i] = j;
/* Tests ll_sort_unique. */
static void
-test_sort_unique (void)
+test_sort_unique (void)
{
const int max_elems = 7;
int cnt, inc_pat;
allocate_elements (cnt, NULL, &perm_elems, NULL, &perm_values);
j = unique_cnt = 0;
- for (i = 0; i < cnt; i++)
+ for (i = 0; i < cnt; i++)
{
elems[i]->x = values[i] = j;
unique_cnt = j + 1;
perm_cnt = 1;
while (ll_next_permutation (ll_head (&list), ll_null (&list),
- compare_elements, &aux_data))
+ compare_elements, &aux_data))
{
struct ll_list perm_list;
extract_values (&list, perm_values, cnt);
ll_init (&perm_list);
for (i = 0; i < cnt; i++)
- {
+ {
perm_elems[i]->x = perm_values[i];
perm_elems[i]->y = i;
ll_push_tail (&perm_list, &perm_elems[i]->ll);
check_list_contents (&perm_list, unique_values, unique_cnt);
check (ll_is_sorted (ll_head (&perm_list), ll_null (&perm_list),
compare_elements_x_y, &aux_data));
- perm_cnt++;
+ perm_cnt++;
}
check (perm_cnt == expected_perms (values, cnt));
/* Tests ll_insert_ordered. */
static void
-test_insert_ordered (void)
+test_insert_ordered (void)
{
const int max_elems = 6;
int cnt, inc_pat;
allocate_elements (cnt, NULL, &perm_elems, NULL, &perm_values);
j = 0;
- for (i = 0; i < cnt; i++)
+ for (i = 0; i < cnt; i++)
{
elems[i]->x = values[i] = j;
if (inc_pat & (1 << i))
perm_cnt = 1;
while (ll_next_permutation (ll_head (&list), ll_null (&list),
- compare_elements_y, &aux_data))
+ compare_elements_y, &aux_data))
{
struct ll_list perm_list;
extract_values (&list, perm_values, cnt);
ll_init (&perm_list);
for (i = 0; i < cnt; i++)
- {
+ {
perm_elems[i]->x = perm_values[i];
perm_elems[i]->y = i;
ll_insert_ordered (ll_head (&perm_list), ll_null (&perm_list),
}
check (ll_is_sorted (ll_head (&perm_list), ll_null (&perm_list),
compare_elements_x_y, &aux_data));
- perm_cnt++;
+ perm_cnt++;
}
check (perm_cnt == factorial (cnt));
test_partition (void)
{
const int max_elems = 10;
-
+
int cnt;
unsigned int pbase;
int r0, r1;
int i, j;
int first_false;
struct ll *part_ll;
-
+
allocate_ascending (cnt, &list, &elems, &elemp, &values);
/* Check that ll_find_partition works okay in every
break;
j = i;
for (; i < r1; i++)
- if (pattern & (1u << i))
+ if (pattern & (1u << i))
break;
part_ll = ll_find_partition (elemp[r0], elemp[r1],
pattern_pred,
&pattern);
- if (i == r1)
+ if (i == r1)
check (part_ll == elemp[j]);
else
check (part_ll == NULL);
{
if (first_false == -1)
first_false = i;
- values[j++] = i;
+ values[j++] = i;
}
if (first_false == -1)
first_false = r1;
/* Runs TEST_FUNCTION and prints a message about NAME. */
static void
-run_test (void (*test_function) (void), const char *name)
+run_test (void (*test_function) (void), const char *name)
{
test_name = name;
putchar ('.');
}
int
-main (void)
+main (void)
{
run_test (test_push_pop, "push/pop");
run_test (test_insert_remove, "insert/remove");
projects / pspp-builds.git / blobdiff