END_TEST
START_TEST (test_append_i_array_2d) {
int size, el_size, i, ret;
i_array_2d * v;
i_array * ia1;
i_array * ia2;
el_size = 3;
ia1 = init_i_array(el_size);
ia2 = init_i_array(el_size);
for (i = 0; i < el_size; i++) {
append_i_array(ia1, i);
append_i_array(ia2, (el_size + i));
}
size = 1;
v = init_i_array_2d(size, el_size);
ck_assert_int_eq(v->capacity, size);
ck_assert_int_eq(v->length, 0);
append_i_array_2d(v, ia1);
ck_assert_int_eq(v->capacity, size);
ck_assert_int_eq(v->length, 1);
ret = i_arrays_equal(v->a[0], ia1);
ck_assert_msg((ret != 0), "`i_array_2d` element is incorrect");
append_i_array_2d(v, ia2);
ck_assert_int_eq(v->capacity, size*2);
ck_assert_int_eq(v->length, 2);
ret = i_arrays_equal(v->a[1], ia2);
ck_assert_msg((ret != 0), "`i_array_2d` element is incorrect");
free_i_array_2d(v);
free_i_array(ia1);
free_i_array(ia2);
}
END_TEST
START_TEST (test_get_i_array_2d) {
int size, el_size, i, ret;
i_array_2d * v;
i_array * ia1;
i_array * ia2;
el_size = 3;
ia1 = init_i_array(el_size);
ia2 = init_i_array(el_size);
for (i = 0; i < el_size; i++) {
append_i_array(ia1, i);
append_i_array(ia2, (el_size + i));
}
size = 1;
v = init_i_array_2d(size, el_size);
append_i_array_2d(v, ia1);
ret = i_arrays_equal(get_i_array_2d(v, 0), ia1);
ck_assert_msg((ret != 0), "`i_array_2d` element is incorrect");
append_i_array_2d(v, ia2);
ret = i_arrays_equal(get_i_array_2d(v, 1), ia2);
ck_assert_msg((ret != 0), "`i_array_2d` element is incorrect");
free_i_array_2d(v);
free_i_array(ia1);
free_i_array(ia2);
}
END_TEST
START_TEST (test_set_i_array_2d) {
int size, el_size, i, ret;
i_array_2d * v;
i_array * ia1;
i_array * ia2;
el_size = 3;
ia1 = init_i_array(el_size);
ia2 = init_i_array(el_size);
for (i = 0; i < el_size; i++) {
append_i_array(ia1, i);
append_i_array(ia2, (el_size + i));
}
size = 1;
v = init_i_array_2d(size, el_size);
append_i_array_2d(v, ia1);
ret = i_arrays_equal(v->a[0], ia1);
ck_assert_msg((ret != 0), "`i_array_2d` element %d is incorrect: %d %d %d",
0, v->a[0]->a[0], v->a[0]->a[1], v->a[0]->a[2]);
set_i_array_2d(v, 0, ia2);
ret = i_arrays_equal(v->a[0], ia2);
ck_assert_msg((ret != 0), "`i_array_2d` element %d is incorrect: %d %d %d",
0, v->a[0]->a[0], v->a[0]->a[1], v->a[0]->a[2]);
free_i_array_2d(v);
free_i_array(ia1);
free_i_array(ia2);
}
END_TEST
START_TEST (test_get_el_i_array_2d) {
int size, el_size, i, ret;
i_array_2d * v;
i_array * ia1;
i_array * ia2;
el_size = 3;
ia1 = init_i_array(el_size);
ia2 = init_i_array(el_size);
for (i = 0; i < el_size; i++) {
append_i_array(ia1, i);
append_i_array(ia2, (el_size + i));
}
size = 1;
v = init_i_array_2d(size, el_size);
append_i_array_2d(v, ia1);
ck_assert_msg((get_el_i_array_2d(v, 0, 1) == 1), "`i_array_2d` array %d "
"element %d is %d, expecting %d", 0, 1,
get_el_i_array_2d(v, 0, 1), 1);
append_i_array_2d(v, ia2);
ck_assert_msg((get_el_i_array_2d(v, 1, 1) == 4), "`i_array_2d` array %d "
"element %d is %d, expecting %d", 1, 1,
get_el_i_array_2d(v, 1, 1), 4);
free_i_array_2d(v);
free_i_array(ia1);
free_i_array(ia2);
}
END_TEST
START_TEST (test_split_str_i) {
int ret;
i_array * v;
i_array * exp;
v = init_i_array(1);
exp = init_i_array(1);
char * string = "1\t22\t-432";
append_i_array(exp, 1);
append_i_array(exp, 22);
append_i_array(exp, -432);
ret = split_str_i(string, v, 0);
ck_assert_int_eq(ret, 0);
ck_assert_int_eq(v->length, 3);
ck_assert_msg((i_arrays_equal(v, exp) != 0),
"unexpected result of `split_str_i`");
ret = split_str_i(string, v, 3);
ck_assert_int_eq(ret, 0);
ret = split_str_i(string, v, 4);
ck_assert_int_eq(ret, 3);
ck_assert_msg((i_arrays_equal(v, exp) != 0),
"unexpected result of `split_str_i`");
free_i_array(v);
free_i_array(exp);
}
END_TEST
START_TEST (test_i_arrays_equal) {
int size, ret;
i_array * v1;
i_array * v2;
int s = 1;
size = 3;
v1 = init_i_array(size);
v2 = init_i_array(size);
ret = i_arrays_equal(v1, v2);
ck_assert_msg((ret != 0), "`i_array`s not equal, but should be");
append_i_array(v1, s);
ret = i_arrays_equal(v1, v2);
ck_assert_msg((ret == 0), "`i_array`s equal, but should not be");
append_i_array(v2, s);
ret = i_arrays_equal(v1, v2);
ck_assert_msg((ret != 0), "`i_array`s not equal, but should be");
s = 2;
append_i_array(v1, s);
ret = i_arrays_equal(v1, v2);
ck_assert_msg((ret == 0), "`i_array`s equal, but should not be");
append_i_array(v2, s);
ret = i_arrays_equal(v1, v2);
ck_assert_msg((ret != 0), "`i_array`s not equal, but should be");
append_i_array(v1, s);
ret = i_arrays_equal(v1, v2);
ck_assert_msg((ret == 0), "`i_array`s equal, but should not be");
s = 3;
append_i_array(v2, s);
ret = i_arrays_equal(v1, v2);
ck_assert_msg((ret == 0), "`i_array`s equal, but should not be");
free_i_array(v1);
free_i_array(v2);
}
END_TEST
/**
* `i_array` tests
*/
START_TEST (test_init_free_i_array) {
int i, size;
i_array * v;
size = 10;
v = init_i_array(size);
ck_assert_int_eq(v->capacity, size);
ck_assert_int_eq(v->length, 0);
ck_assert_msg((sizeof(v->length) == sizeof(int)), "`i_array.length` "
"attribute is not an int");
ck_assert_msg((sizeof(v->capacity) == sizeof(int)), "`i_array.capacity` "
"attribute is not an int");
ck_assert_msg((sizeof(v->a) == sizeof(long)), "Array attribute "
"of `i_array` is not a pointer");
ck_assert_msg((sizeof(*v->a) == sizeof(int)), "Pointer to array"
"of `i_array` is not pointing to int");
for (i = 0; i < v->capacity; i++) {
ck_assert_msg((v->a[i] == 0), "Element %d of %d was not initialized "
"to zero", i, size);
}
free_i_array(v);
}
END_TEST
START_TEST (test_get_doubles) {
int ret;
s_array * search_strings;
i_array * indices;
d_array * dest;
search_strings = init_s_array(1);
indices = init_i_array(1);
dest = init_d_array(1);
append_s_array(search_strings, "foo");
append_s_array(search_strings, "0.345");
append_s_array(search_strings, "156.345");
append_s_array(search_strings, "bar");
append_s_array(search_strings, "1.23e3");
append_s_array(search_strings, "1.2");
append_i_array(indices, 1);
append_i_array(indices, 2);
append_i_array(indices, 4);
ret = get_doubles(search_strings, indices, dest);
ck_assert_int_eq(ret, 0);
ck_assert_int_eq(dest->length, 3);
ck_assert_msg((almost_equal(get_d_array(dest, 0), 0.345, 0.000001)),
"extracted double is %lf, expected %lf",
get_d_array(dest, 0), 0.345);
ck_assert_msg((almost_equal(get_d_array(dest, 1), 156.345, 0.000001)),
"extracted double is %lf, expected %lf",
get_d_array(dest, 1), 156.345);
ck_assert_msg((almost_equal(get_d_array(dest, 2), 1230.0, 0.000001)),
"extracted double is %lf, expected %lf",
get_d_array(dest, 2), 1230.0);
append_i_array(indices, 0);
ret = get_doubles(search_strings, indices, dest);
ck_assert_int_eq(ret, 1);
}
END_TEST
START_TEST (test_summarize_stat_samples_p2_n5) {
int i;
s_array * paths;
s_array * paths_used;
c_array * line_buffer;
i_array * stat_indices;
sample_sum_array * ss_array;
d_array * means;
d_array * std_devs;
d_array * exp_means;
d_array * exp_std_devs;
int num_to_sample;
int expected_num_cols;
expected_num_cols = 6;
num_to_sample = 5;
paths = init_s_array(1);
paths_used = init_s_array(1);
line_buffer = init_c_array(1023);
stat_indices = init_i_array(4);
ss_array = init_sample_sum_array(4);
means = init_d_array(1);
std_devs = init_d_array(1);
exp_means = init_d_array(1);
exp_std_devs = init_d_array(1);
append_s_array(paths, "data/test_parameter_stat_samples.txt");
append_s_array(paths, "data/test_parameter_stat_samples2.txt");
for (i = 2; i < expected_num_cols; i++) {
append_i_array(stat_indices, i);
}
summarize_stat_samples(paths, line_buffer, stat_indices, ss_array, means,
std_devs, num_to_sample, expected_num_cols, paths_used);
ck_assert_int_eq(means->length, stat_indices->length);
ck_assert_int_eq(std_devs->length, stat_indices->length);
ck_assert_int_eq(ss_array->a[0]->n, num_to_sample);
ck_assert_msg((s_arrays_equal(paths, paths_used) != 0),
"paths used do not match input paths");
append_d_array(exp_means, 0.222);
append_d_array(exp_means, 0.218);
append_d_array(exp_means, 4.2);
append_d_array(exp_means, 3.6);
append_d_array(exp_std_devs, 0.1281405);
append_d_array(exp_std_devs, 0.0130384);
append_d_array(exp_std_devs, 3.962323);
append_d_array(exp_std_devs, 1.67332);
ck_assert_msg((d_arrays_equal(means, exp_means, 0.000001) != 0),
"unexpected means");
ck_assert_msg((d_arrays_equal(std_devs, exp_std_devs, 0.000001) != 0),
"unexpected std deviations");
free_s_array(paths);
free_s_array(paths_used);
free_c_array(line_buffer);
free_i_array(stat_indices);
free_sample_sum_array(ss_array);
free_d_array(means);
free_d_array(std_devs);
free_d_array(exp_means);
free_d_array(exp_std_devs);
}
END_TEST
START_TEST (test_reject_p2_n2_c4) {
int i;
s_array * paths;
c_array * line_buffer;
i_array * stat_indices;
d_array * obs_stats;
d_array * means;
d_array * std_devs;
s_array * header;
sample_array * samples;
int num_to_retain;
num_to_retain = 2;
paths = init_s_array(1);
line_buffer = init_c_array(1023);
stat_indices = init_i_array(4);
means = init_d_array(1);
std_devs = init_d_array(1);
obs_stats = init_d_array(1);
header = init_s_array(1);
append_s_array(paths, "data/test_parameter_stat_samples4.txt");
append_s_array(paths, "data/test_parameter_stat_samples.txt");
parse_header(get_s_array(paths, 0), line_buffer, header);
for (i = 2; i < header->length; i++) {
append_i_array(stat_indices, i);
}
append_d_array(obs_stats, 0.1);
append_d_array(obs_stats, 0.21);
append_d_array(obs_stats, 1.0);
append_d_array(obs_stats, 2.0);
append_d_array(means, 0.25);
append_d_array(means, 0.2225);
append_d_array(means, 2.5);
append_d_array(means, 3.0);
append_d_array(std_devs, 0.1290994);
append_d_array(std_devs, 0.009574271);
append_d_array(std_devs, 1.290994);
append_d_array(std_devs, 1.154701);
standardize_vector(obs_stats, means, std_devs);
samples = reject(paths, line_buffer, stat_indices, obs_stats, means,
std_devs, num_to_retain, header);
ck_assert_int_eq(samples->length, num_to_retain);
ck_assert_int_eq(samples->capacity, num_to_retain);
ck_assert_msg((almost_equal(samples->a[0]->distance, 0.0, 0.000001)),
"euclidean distance was %lf, expected %lf",
samples->a[0]->distance, 0.0);
ck_assert_msg((almost_equal(samples->a[1]->distance, 0.130035, 0.000001)),
"euclidean distance was %lf, expected %lf",
samples->a[1]->distance, 0.130035);
free_s_array(paths);
free_c_array(line_buffer);
free_i_array(stat_indices);
free_d_array(obs_stats);
free_sample_array(samples);
free_d_array(means);
free_d_array(std_devs);
free_s_array(header);
}
END_TEST
START_TEST (test_number_of_int_partitions_by_k_n0) {
int n, ip;
i_array * counts;
counts = init_i_array(1);
n = 0;
ip = number_of_int_partitions_by_k(n, counts); // SIGABRT
free_i_array(counts);
}
END_TEST
START_TEST (test_get_i_array_fail) {
int size;
i_array * v;
size = 1;
v = init_i_array(size);
append_i_array(v, 1);
get_i_array(v, 1); // SIGABRT
}
END_TEST
START_TEST (test_cumulative_number_of_int_partitions_by_k_n1) {
int n, ip;
i_array * counts;
counts = init_i_array(1);
n = 1;
ip = cumulative_number_of_int_partitions_by_k(n, counts);
ck_assert_int_eq(ip, 1);
ck_assert_int_eq(counts->length, n);
ck_assert_int_eq(get_i_array(counts, 0), 1);
free_i_array(counts);
}
END_TEST
START_TEST (test_get_i_array) {
int size;
i_array * v;
size = 1;
v = init_i_array(size);
append_i_array(v, 1);
ck_assert_msg((get_i_array(v, 0) == 1), "`i_array` element is %d, expecting %d",
get_i_array(v, 0), 1);
append_i_array(v, 2);
ck_assert_msg((get_i_array(v, 1) == 2), "`i_array` element is %d, expecting %d",
get_i_array(v, 1), 2);
}
END_TEST
START_TEST (test_set_i_array) {
int size;
i_array * v;
size = 1;
v = init_i_array(size);
append_i_array(v, 1);
ck_assert_msg((v->a[0] == 1), "`i_array` element is %d, expecting %d",
v->a[0], 1);
set_i_array(v, 0, 2);
ck_assert_msg((v->a[0] == 2), "`i_array` element is %d, expecting %d",
v->a[0], 2);
}
END_TEST
START_TEST (test_generate_int_partitions_n4) {
int n, i;
n = 4;
i_array * expected = init_i_array(1);
i_array_2d * partitions = init_i_array_2d(1,1);
partitions = generate_int_partitions(n);
ck_assert_int_eq(partitions->length, 5);
i = 0;
expected->length = 0;
append_i_array(expected, 4);
ck_assert_msg((i_arrays_equal(get_i_array_2d(partitions, i),
expected) != 0),
"unexpected partition");
i = 1;
expected->length = 0;
append_i_array(expected, 3);
append_i_array(expected, 1);
ck_assert_msg((i_arrays_equal(get_i_array_2d(partitions, i),
expected) != 0),
"unexpected partition");
i = 2;
expected->length = 0;
append_i_array(expected, 2);
append_i_array(expected, 2);
ck_assert_msg((i_arrays_equal(get_i_array_2d(partitions, i),
expected) != 0),
"unexpected partition");
i = 3;
expected->length = 0;
append_i_array(expected, 2);
append_i_array(expected, 1);
append_i_array(expected, 1);
ck_assert_msg((i_arrays_equal(get_i_array_2d(partitions, i),
expected) != 0),
"unexpected partition");
i = 4;
expected->length = 0;
append_i_array(expected, 1);
append_i_array(expected, 1);
append_i_array(expected, 1);
append_i_array(expected, 1);
ck_assert_msg((i_arrays_equal(get_i_array_2d(partitions, i),
expected) != 0),
"unexpected partition");
free_i_array(expected);
free_i_array_2d(partitions);
}
END_TEST
START_TEST (test_number_of_int_partitions_by_k_n3) {
int n, ip;
i_array * counts;
counts = init_i_array(1);
n = 3;
ip = number_of_int_partitions_by_k(n, counts);
ck_assert_int_eq(ip, 3);
ck_assert_int_eq(counts->length, n);
ck_assert_int_eq(get_i_array(counts, 0), 1);
ck_assert_int_eq(get_i_array(counts, 1), 1);
ck_assert_int_eq(get_i_array(counts, 2), 1);
free_i_array(counts);
}
END_TEST
START_TEST (test_generate_int_partitions_n1) {
int n;
n = 1;
i_array * expected = init_i_array(1);
i_array_2d * partitions = init_i_array_2d(1,1);
partitions = generate_int_partitions(n);
ck_assert_int_eq(partitions->length, 1);
append_i_array(expected, 1);
ck_assert_msg((i_arrays_equal(get_i_array_2d(partitions, 0),
expected) != 0),
"unexpected partition");
free_i_array(expected);
free_i_array_2d(partitions);
}
END_TEST
START_TEST (test_get_i_array_2d_fail) {
int size, el_size, i, ret;
i_array_2d * v;
i_array * ia1;
el_size = 3;
ia1 = init_i_array(el_size);
for (i = 0; i < el_size; i++) {
append_i_array(ia1, i);
}
size = 1;
v = init_i_array_2d(size, el_size);
append_i_array_2d(v, ia1);
get_i_array_2d(v, 1); // SIGABRT
}
END_TEST
START_TEST (test_expand_i_array) {
int i, size;
i_array * v;
size = 1;
v = init_i_array(size);
ck_assert_int_eq(v->capacity, size);
ck_assert_int_eq(v->length, 0);
for (i = 0; i < 5; i++) {
expand_i_array(v);
size *= 2;
ck_assert_int_eq(v->capacity, size);
ck_assert_int_eq(v->length, 0);
}
free_i_array(v);
}
END_TEST
START_TEST (test_get_matching_indices_fail) {
s_array * search_strings;
s_array * target_strings;
i_array * indices;
search_strings = init_s_array(1);
target_strings = init_s_array(1);
indices = init_i_array(1);
append_s_array(search_strings, "foo");
append_s_array(search_strings, "bar");
append_s_array(target_strings, "boo");
append_s_array(target_strings, "foo");
append_s_array(target_strings, "bar");
append_s_array(search_strings, "fail");
get_matching_indices(search_strings, target_strings, indices); // exit(1)
}
END_TEST
START_TEST (test_cumulative_number_of_int_partitions_by_k_n7) {
int n, ip;
i_array * counts;
counts = init_i_array(1);
n = 7;
ip = cumulative_number_of_int_partitions_by_k(n, counts);
ck_assert_int_eq(ip, 15);
ck_assert_int_eq(counts->length, n);
ck_assert_int_eq(get_i_array(counts, 0), 1);
ck_assert_int_eq(get_i_array(counts, 1), 4);
ck_assert_int_eq(get_i_array(counts, 2), 8);
ck_assert_int_eq(get_i_array(counts, 3), 11);
ck_assert_int_eq(get_i_array(counts, 4), 13);
ck_assert_int_eq(get_i_array(counts, 5), 14);
ck_assert_int_eq(get_i_array(counts, 6), 15);
free_i_array(counts);
}
END_TEST
START_TEST (test_summarize_stat_samples_p1_n4_missing_cell) {
int i;
s_array * paths;
s_array * paths_used;
c_array * line_buffer;
i_array * stat_indices;
sample_sum_array * ss_array;
d_array * means;
d_array * std_devs;
d_array * exp_means;
d_array * exp_std_devs;
int num_to_sample;
int expected_num_cols;
expected_num_cols = 6;
num_to_sample = 4;
paths = init_s_array(1);
paths_used = init_s_array(1);
line_buffer = init_c_array(1023);
stat_indices = init_i_array(4);
ss_array = init_sample_sum_array(4);
means = init_d_array(1);
std_devs = init_d_array(1);
exp_means = init_d_array(1);
exp_std_devs = init_d_array(1);
append_s_array(paths, "data/test_parameter_stat_samples.missing_cell.txt");
for (i = 2; i < expected_num_cols; i++) {
append_i_array(stat_indices, i);
}
summarize_stat_samples(paths, line_buffer, stat_indices, ss_array, means,
std_devs, num_to_sample, expected_num_cols, paths_used); // exit(1)
free_s_array(paths);
free_s_array(paths_used);
free_c_array(line_buffer);
free_i_array(stat_indices);
free_sample_sum_array(ss_array);
free_d_array(means);
free_d_array(std_devs);
free_d_array(exp_means);
free_d_array(exp_std_devs);
}
END_TEST
START_TEST (test_get_matching_indices) {
s_array * search_strings;
s_array * target_strings;
i_array * indices;
search_strings = init_s_array(1);
target_strings = init_s_array(1);
indices = init_i_array(1);
append_s_array(search_strings, "foo");
append_s_array(search_strings, "bar");
append_s_array(target_strings, "boo");
append_s_array(target_strings, "foo");
append_s_array(target_strings, "bar");
get_matching_indices(search_strings, target_strings, indices);
ck_assert_int_eq(indices->length, 2);
ck_assert_int_eq(indices->capacity, 2);
ck_assert_int_eq(get_i_array(indices, 0), 1);
ck_assert_int_eq(get_i_array(indices, 1), 2);
}
END_TEST
START_TEST (test_append_i_array) {
int size;
i_array * v;
size = 1;
v = init_i_array(size);
ck_assert_int_eq(v->capacity, size);
ck_assert_int_eq(v->length, 0);
append_i_array(v, 1);
ck_assert_int_eq(v->capacity, size);
ck_assert_int_eq(v->length, 1);
ck_assert_msg((v->a[0] == 1), "`i_array` element is %d, expecting %d",
v->a[0], 1);
append_i_array(v, -99);
ck_assert_int_eq(v->capacity, size*2);
ck_assert_int_eq(v->length, 2);
ck_assert_msg((v->a[1] == -99), "`i_array` element is %d, expecting %d",
v->a[0], -99);
}
END_TEST
START_TEST (test_init_i_array_fail) {
i_array * v;
v = init_i_array(0); // SIGABRT
}
