projects
/
pspp
/ blobdiff
commit
grep
author
committer
pickaxe
?
search:
re
summary
|
shortlog
|
log
|
commit
|
commitdiff
|
tree
raw
|
inline
| side by side
treewide: Replace <name>_cnt by n_<name>s and <name>_cap by allocated_<name>.
[pspp]
/
tests
/
libpspp
/
ll-test.c
diff --git
a/tests/libpspp/ll-test.c
b/tests/libpspp/ll-test.c
index f92bc6cba8b50245b41054127a5a2bb9220112e7..0d501a85046fba925cd87965d9364508ffb1a820 100644
(file)
--- a/
tests/libpspp/ll-test.c
+++ b/
tests/libpspp/ll-test.c
@@
-1031,17
+1031,17
@@
static unsigned int
expected_perms (int *values, size_t cnt)
{
size_t i, j;
expected_perms (int *values, size_t cnt)
{
size_t i, j;
- unsigned int
perm_cnt
;
+ unsigned int
n_perms
;
-
perm_cnt
= factorial (cnt);
+
n_perms
= factorial (cnt);
for (i = 0; i < cnt; i = j)
{
for (j = i + 1; j < cnt; j++)
if (values[i] != values[j])
break;
for (i = 0; i < cnt; i = j)
{
for (j = i + 1; j < cnt; j++)
if (values[i] != values[j])
break;
-
perm_cnt
/= factorial (j - i);
+
n_perms
/= factorial (j - i);
}
}
- return
perm_cnt
;
+ return
n_perms
;
}
/* Tests ll_min and ll_max. */
}
/* Tests ll_min and ll_max. */
@@
-1059,11
+1059,11
@@
test_min_max (void)
int *values;
int *new_values = xnmalloc (cnt, sizeof *values);
int *values;
int *new_values = xnmalloc (cnt, sizeof *values);
- size_t
perm_cnt
;
+ size_t
n_perms
;
allocate_ascending (cnt, &list, &elems, &elemp, &values);
allocate_ascending (cnt, &list, &elems, &elemp, &values);
-
perm_cnt
= 1;
+
n_perms
= 1;
while (ll_next_permutation (ll_head (&list), ll_null (&list),
compare_elements, &aux_data))
{
while (ll_next_permutation (ll_head (&list), ll_null (&list),
compare_elements, &aux_data))
{
@@
-1110,9
+1110,9
@@
test_min_max (void)
&& ll_to_element (max)->x == max_int);
}
}
&& ll_to_element (max)->x == max_int);
}
}
-
perm_cnt
++;
+
n_perms
++;
}
}
- check (
perm_cnt
== factorial (cnt));
+ check (
n_perms
== factorial (cnt));
check_list_contents (&list, values, cnt);
free_elements (cnt, elems, elemp, values);
check_list_contents (&list, values, cnt);
free_elements (cnt, elems, elemp, values);
@@
-1271,11
+1271,11
@@
test_permutations_no_dups (void)
int *old_values = xnmalloc (cnt, sizeof *values);
int *new_values = xnmalloc (cnt, sizeof *values);
int *old_values = xnmalloc (cnt, sizeof *values);
int *new_values = xnmalloc (cnt, sizeof *values);
- size_t
perm_cnt
;
+ size_t
n_perms
;
allocate_ascending (cnt, &list, &elems, NULL, &values);
allocate_ascending (cnt, &list, &elems, NULL, &values);
-
perm_cnt
= 1;
+
n_perms
= 1;
extract_values (&list, old_values, cnt);
while (ll_next_permutation (ll_head (&list), ll_null (&list),
compare_elements, &aux_data))
extract_values (&list, old_values, cnt);
while (ll_next_permutation (ll_head (&list), ll_null (&list),
compare_elements, &aux_data))
@@
-1286,12
+1286,12
@@
test_permutations_no_dups (void)
sizeof *new_values,
compare_ints, NULL) > 0);
memcpy (old_values, new_values, (cnt) * sizeof *old_values);
sizeof *new_values,
compare_ints, NULL) > 0);
memcpy (old_values, new_values, (cnt) * sizeof *old_values);
-
perm_cnt
++;
+
n_perms
++;
}
}
- check (
perm_cnt
== factorial (cnt));
+ check (
n_perms
== factorial (cnt));
check_list_contents (&list, values, cnt);
check_list_contents (&list, values, cnt);
-
perm_cnt
= 1;
+
n_perms
= 1;
ll_reverse (ll_head (&list), ll_null (&list));
extract_values (&list, old_values, cnt);
while (ll_prev_permutation (ll_head (&list), ll_null (&list),
ll_reverse (ll_head (&list), ll_null (&list));
extract_values (&list, old_values, cnt);
while (ll_prev_permutation (ll_head (&list), ll_null (&list),
@@
-1303,9
+1303,9
@@
test_permutations_no_dups (void)
sizeof *new_values,
compare_ints, NULL) < 0);
memcpy (old_values, new_values, (cnt) * sizeof *old_values);
sizeof *new_values,
compare_ints, NULL) < 0);
memcpy (old_values, new_values, (cnt) * sizeof *old_values);
-
perm_cnt
++;
+
n_perms
++;
}
}
- check (
perm_cnt
== factorial (cnt));
+ check (
n_perms
== factorial (cnt));
ll_reverse (ll_head (&list), ll_null (&list));
check_list_contents (&list, values, cnt);
ll_reverse (ll_head (&list), ll_null (&list));
check_list_contents (&list, values, cnt);
@@
-1335,7
+1335,7
@@
test_permutations_with_dups (void)
int *old_values = xnmalloc (max_elems, sizeof *values);
int *new_values = xnmalloc (max_elems, sizeof *values);
int *old_values = xnmalloc (max_elems, sizeof *values);
int *new_values = xnmalloc (max_elems, sizeof *values);
- unsigned int
permutation_cnt
;
+ unsigned int
n_permutations
;
int left = cnt;
int value = 0;
int left = cnt;
int value = 0;
@@
-1354,7
+1354,7
@@
test_permutations_with_dups (void)
value++;
}
value++;
}
-
permutation_cnt
= 1;
+
n_permutations
= 1;
extract_values (&list, old_values, cnt);
while (ll_next_permutation (ll_head (&list), ll_null (&list),
compare_elements, &aux_data))
extract_values (&list, old_values, cnt);
while (ll_next_permutation (ll_head (&list), ll_null (&list),
compare_elements, &aux_data))
@@
-1365,12
+1365,12
@@
test_permutations_with_dups (void)
sizeof *new_values,
compare_ints, NULL) > 0);
memcpy (old_values, new_values, cnt * sizeof *old_values);
sizeof *new_values,
compare_ints, NULL) > 0);
memcpy (old_values, new_values, cnt * sizeof *old_values);
-
permutation_cnt
++;
+
n_permutations
++;
}
}
- check (
permutation_cnt
== expected_perms (values, cnt));
+ check (
n_permutations
== expected_perms (values, cnt));
check_list_contents (&list, values, cnt);
check_list_contents (&list, values, cnt);
-
permutation_cnt
= 1;
+
n_permutations
= 1;
ll_reverse (ll_head (&list), ll_null (&list));
extract_values (&list, old_values, cnt);
while (ll_prev_permutation (ll_head (&list), ll_null (&list),
ll_reverse (ll_head (&list), ll_null (&list));
extract_values (&list, old_values, cnt);
while (ll_prev_permutation (ll_head (&list), ll_null (&list),
@@
-1381,10
+1381,10
@@
test_permutations_with_dups (void)
old_values, cnt,
sizeof *new_values,
compare_ints, NULL) < 0);
old_values, cnt,
sizeof *new_values,
compare_ints, NULL) < 0);
-
permutation_cnt
++;
+
n_permutations
++;
}
ll_reverse (ll_head (&list), ll_null (&list));
}
ll_reverse (ll_head (&list), ll_null (&list));
- check (
permutation_cnt
== expected_perms (values, cnt));
+ check (
n_permutations
== expected_perms (values, cnt));
check_list_contents (&list, values, cnt);
free_elements (cnt, elems, NULL, values);
check_list_contents (&list, values, cnt);
free_elements (cnt, elems, NULL, values);
@@
-1400,10
+1400,10
@@
test_merge_no_dups (void)
const int max_elems = 8;
const int max_filler = 3;
const int max_elems = 8;
const int max_filler = 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_filler; pfx++)
for (gap = 0; gap < max_filler; gap++)
for (sfx = 0; sfx < max_filler; sfx++)
for (pfx = 0; pfx < max_filler; pfx++)
for (gap = 0; gap < max_filler; gap++)
for (sfx = 0; sfx < max_filler; sfx++)
@@
-1414,46
+1414,46
@@
test_merge_no_dups (void)
struct ll **elemp;
int *values;
struct ll **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;
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;
&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;
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;
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)
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)
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;
values[j++] = i;
for (i = 0; i < sfx; i++)
values[j++] = 300 + i;
- check (
list_cnt
== j);
+ check (
n_lists
== j);
if (order == 0)
ll_merge (elemp[a0], elemp[a1], elemp[b0], elemp[b1],
if (order == 0)
ll_merge (elemp[a0], elemp[a1], elemp[b0], elemp[b1],
@@
-1462,9
+1462,9
@@
test_merge_no_dups (void)
ll_merge (elemp[b0], elemp[b1], elemp[a0], elemp[a1],
compare_elements, &aux_data);
ll_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
, elems, elemp, values);
+ free_elements (
n_lists
, elems, elemp, values);
}
}
}
}
@@
-1563,12
+1563,12
@@
test_sort_exhaustive (void)
struct element **perm_elems;
int *perm_values;
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 (cnt, &list, &elems, NULL, &values);
allocate_elements (cnt, NULL, &perm_elems, NULL, &perm_values);
-
perm_cnt
= 1;
+
n_perms
= 1;
while (ll_next_permutation (ll_head (&list), ll_null (&list),
compare_elements, &aux_data))
{
while (ll_next_permutation (ll_head (&list), ll_null (&list),
compare_elements, &aux_data))
{
@@
-1587,9
+1587,9
@@
test_sort_exhaustive (void)
check_list_contents (&perm_list, values, cnt);
check (ll_is_sorted (ll_head (&perm_list), ll_null (&perm_list),
compare_elements, &aux_data));
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
++;
+
n_perms
++;
}
}
- check (
perm_cnt
== factorial (cnt));
+ check (
n_perms
== factorial (cnt));
free_elements (cnt, elems, NULL, values);
free_elements (cnt, perm_elems, NULL, perm_values);
free_elements (cnt, elems, NULL, values);
free_elements (cnt, perm_elems, NULL, perm_values);
@@
-1614,7
+1614,7
@@
test_sort_stable (void)
struct element **perm_elems;
int *perm_values;
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);
int i, j;
allocate_elements (cnt, &list, &elems, NULL, &values);
@@
-1629,7
+1629,7
@@
test_sort_stable (void)
elems[i]->y = i;
}
elems[i]->y = i;
}
-
perm_cnt
= 1;
+
n_perms
= 1;
while (ll_next_permutation (ll_head (&list), ll_null (&list),
compare_elements_y, &aux_data))
{
while (ll_next_permutation (ll_head (&list), ll_null (&list),
compare_elements_y, &aux_data))
{
@@
-1648,9
+1648,9
@@
test_sort_stable (void)
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));
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
++;
+
n_perms
++;
}
}
- check (
perm_cnt
== factorial (cnt));
+ check (
n_perms
== factorial (cnt));
free_elements (cnt, elems, NULL, values);
free_elements (cnt, perm_elems, NULL, perm_values);
free_elements (cnt, elems, NULL, values);
free_elements (cnt, perm_elems, NULL, perm_values);
@@
-1775,29
+1775,29
@@
test_sort_unique (void)
struct element **perm_elems;
int *perm_values;
struct element **perm_elems;
int *perm_values;
- int
unique_cnt
;
+ int
n_uniques
;
int *unique_values;
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);
int i, j;
allocate_elements (cnt, &list, &elems, NULL, &values);
allocate_elements (cnt, NULL, &perm_elems, NULL, &perm_values);
- j =
unique_cnt
= 0;
+ j =
n_uniques
= 0;
for (i = 0; i < cnt; i++)
{
elems[i]->x = values[i] = j;
for (i = 0; i < cnt; i++)
{
elems[i]->x = values[i] = j;
-
unique_cnt
= j + 1;
+
n_uniques
= j + 1;
if (inc_pat & (1 << i))
j++;
}
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;
unique_values[i] = i;
-
perm_cnt
= 1;
+
n_perms
= 1;
while (ll_next_permutation (ll_head (&list), ll_null (&list),
compare_elements, &aux_data))
{
while (ll_next_permutation (ll_head (&list), ll_null (&list),
compare_elements, &aux_data))
{
@@
-1813,12
+1813,12
@@
test_sort_unique (void)
}
ll_sort_unique (ll_head (&perm_list), ll_null (&perm_list), NULL,
compare_elements, &aux_data);
}
ll_sort_unique (ll_head (&perm_list), ll_null (&perm_list), NULL,
compare_elements, &aux_data);
- check_list_contents (&perm_list, unique_values,
unique_cnt
);
+ check_list_contents (&perm_list, unique_values,
n_uniques
);
check (ll_is_sorted (ll_head (&perm_list), ll_null (&perm_list),
compare_elements_x_y, &aux_data));
check (ll_is_sorted (ll_head (&perm_list), ll_null (&perm_list),
compare_elements_x_y, &aux_data));
-
perm_cnt
++;
+
n_perms
++;
}
}
- check (
perm_cnt
== expected_perms (values, cnt));
+ check (
n_perms
== expected_perms (values, cnt));
free_elements (cnt, elems, NULL, values);
free_elements (cnt, perm_elems, NULL, perm_values);
free_elements (cnt, elems, NULL, values);
free_elements (cnt, perm_elems, NULL, perm_values);
@@
-1843,7
+1843,7
@@
test_insert_ordered (void)
struct element **perm_elems;
int *perm_values;
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);
int i, j;
allocate_elements (cnt, &list, &elems, NULL, &values);
@@
-1858,7
+1858,7
@@
test_insert_ordered (void)
elems[i]->y = i;
}
elems[i]->y = i;
}
-
perm_cnt
= 1;
+
n_perms
= 1;
while (ll_next_permutation (ll_head (&list), ll_null (&list),
compare_elements_y, &aux_data))
{
while (ll_next_permutation (ll_head (&list), ll_null (&list),
compare_elements_y, &aux_data))
{
@@
-1876,9
+1876,9
@@
test_insert_ordered (void)
}
check (ll_is_sorted (ll_head (&perm_list), ll_null (&perm_list),
compare_elements_x_y, &aux_data));
}
check (ll_is_sorted (ll_head (&perm_list), ll_null (&perm_list),
compare_elements_x_y, &aux_data));
-
perm_cnt
++;
+
n_perms
++;
}
}
- check (
perm_cnt
== factorial (cnt));
+ check (
n_perms
== factorial (cnt));
free_elements (cnt, elems, NULL, values);
free_elements (cnt, perm_elems, NULL, perm_values);
free_elements (cnt, elems, NULL, values);
free_elements (cnt, perm_elems, NULL, perm_values);