void test_list_ops(list* l) {
printf("list ops tests\n");
for (int i = 0; i < 100; i++) {
for (int j = 0; j < 100; j++) {
assert(add(l, i, create_testdata("test_testdata", i)) == true);
}
}
assert(size(l) == 10000);
struct testdata* test_testdata = create_testdata("our_test", 20);
add(l, 1024, test_testdata);
assert(get(l, 1024) == test_testdata);
assert(size(l) == 10001);
assert(list_remove(l, 1024) == test_testdata);
free_testdata(test_testdata);
assert(size(l) == 10000);
list* l2 = split_list(l, is_integer_val_50);
assert(size(l2) == 100);
assert(size(l) == 9900);
traverse(l, _traverse_all_integer_val_ne_50);
traverse(l2, _traverse_all_integer_val_eq_50);
free_td_list(l2);
}
void test_endOfList(list* l) {
printf("end of list tests\n");
struct testdata* last = create_testdata("Alex", 0);
push_front(l, last);
push_front(l, create_testdata("Steve", 0));
push_front(l, create_testdata("Joe", 0));
// also checks contains pointer return
struct testdata* me = create_testdata("Alex", 55);
assert(contains(l, me, testdata_string_val_comp)
== last);
free_testdata(me);
list* l2 = copy_list(l, copy_testdata);
for (int num_prints = 3; num_prints > 0; num_prints--) {
print_count = 0;
last_printed = NULL;
printf("Expecting %d elements to print:\n", num_prints);
traverse(l2, print_testdata);
assert(print_count == num_prints);
assert(strcmp(last_printed, "Alex") == 0);
free_testdata(pop_front(l2));
}
print_count = 0;
last_printed = NULL;
traverse(l2, print_testdata);
assert(print_count == 0);
free_td_list(l2);
}
// add tests
void test_add(list* l) {
struct testdata* bad = create_testdata("a", 0);
assert(add(l, 1, bad) == false);
assert(add(l, 0, create_testdata("b", 1)) == true);
assert(add(l, 1, create_testdata("c", 2)) == true);
assert(add(l, 0, create_testdata("a", 0)) == true);
assert(size(l) == 3);
free_testdata(bad);
}
void test_copy_list_trivial(list *l)
{
printf("Trivial test.\n");
add(l, 0, create_testdata("hi mum", 392));
add(l, 1, create_testdata("i wont drop out i swear", 392));
list *backup = copy_list(l, copy_testdata);
assert(size(backup) == size(l));
free_td_list(backup);
}
void copy_data_test(SshStream s1, SshStream s2)
{
ts1 = s1;
ts2 = s2;
create_testdata();
if (received_data)
ssh_buffer_clear(received_data);
else
received_data = ssh_buffer_allocate();
test_data_index = 0;
destroy_count = 0;
reader_sent_eof = FALSE;
ssh_stream_set_callback(s1, copy_writer, NULL);
ssh_stream_set_callback(s2, copy_reader, NULL);
ssh_event_loop_run();
if (destroy_count != 2 || ts1 != NULL || ts2 != NULL)
ssh_fatal("copy_data_test: one stream not destroyed");
if (ssh_buffer_len(received_data) > ssh_buffer_len(testdata))
ssh_fatal("copy_data_test: received more data than sent");
if (break_test)
ssh_buffer_consume_end(testdata,
ssh_buffer_len(testdata)
- ssh_buffer_len(received_data));
if (ssh_buffer_len(testdata) != ssh_buffer_len(received_data))
ssh_fatal("copy_data_test: data lens differ");
if (memcmp(ssh_buffer_ptr(testdata), ssh_buffer_ptr(received_data),
ssh_buffer_len(testdata)) != 0)
ssh_fatal("copy_data_test: received data differs");
}
void test_emptyList(list* l) {
printf("empty list tests\n");
assert(is_empty(l));
assert(pop_front(l) == NULL);
empty_list(l, free_testdata);
empty_list(l, free_testdata);
assert(is_empty(l));
assert(size(l) == 0);
print_count = 0;
last_printed = NULL;
traverse(l, print_testdata);
assert(print_count == 0);
list* l2 = split_list(l, is_integer_val_23_or_greater);
assert(is_empty(l));
assert(is_empty(l2));
list* l3 = copy_list(l, copy_testdata);
assert(is_empty(l3));
assert(get(l, 0) == NULL);
assert(front(l) == NULL);
struct testdata* td = create_testdata("Alex", 0);
assert(contains(l, td, testdata_string_val_comp) == NULL);
free_testdata(td);
free_td_list(l2);
free_td_list(l3);
}
void run() final {
osmium::thread::set_thread_name("_osmium_mock_in");
if (m_fail_in == "header") {
throw std::runtime_error("error in header");
}
set_header_value(osmium::io::Header{});
send_to_output_queue(create_testdata());
if (m_fail_in == "read") {
throw std::runtime_error("error in read");
}
}
// Copy a testdata
void *copy_testdata(const void *data) {
struct testdata *p = (struct testdata*) data;
return create_testdata(p->string_val, p->integer_val);
}
// remove tests
void test_remove(list* l) {
printf("list remove tests\n");
struct testdata* pa = create_testdata("a", 0);
struct testdata* pb = create_testdata("b", 10);
struct testdata* pc = create_testdata("c", 20);
struct testdata* pd = create_testdata("d", 30);
struct testdata* pe = create_testdata("e", 40);
struct testdata* pf = create_testdata("f", 50);
add(l, 0, pa);
add(l, 1, pb);
add(l, 2, pc);
add(l, 3, pd);
add(l, 4, pe);
add(l, 5, pf);
string_vals_sel_idx = 0;
string_vals_sel = (char**) string_vals0;
assert(size(l) == 6);
traverse(l, _traverse_assert_string_vals);
fprintf(stderr, "Removing first element.\n");
assert(list_remove(l, 0) == pa);
assert(size(l) == 5);
string_vals_sel_idx = 0;
string_vals_sel = (char**) string_vals1;
traverse(l, _traverse_assert_string_vals);
fprintf(stderr, "Removing last element.\n");
assert(list_remove(l, 4) == pf);
assert(size(l) == 4);
string_vals_sel_idx = 0;
string_vals_sel = (char**) string_vals2;
traverse(l, _traverse_assert_string_vals);
fprintf(stderr, "Removing list[1] ('c').\n");
assert(list_remove(l, 1) == pc);
assert(size(l) == 3);
string_vals_sel_idx = 0;
string_vals_sel = (char**) string_vals3;
traverse(l, _traverse_assert_string_vals);
fprintf(stderr, "Removing list[1] ('d').\n");
assert(list_remove(l, 1) == pd);
assert(size(l) == 2);
string_vals_sel_idx = 0;
string_vals_sel = (char**) string_vals4;
traverse(l, _traverse_assert_string_vals);
fprintf(stderr, "Removing list[0] ('b').\n");
assert(list_remove(l, 0) == pb);
assert(size(l) == 1);
string_vals_sel_idx = 0;
string_vals_sel = (char**) string_vals5;
traverse(l, _traverse_assert_string_vals);
fprintf(stderr, "Removing list[0] ('e').\n");
assert(list_remove(l, 0) == pe);
assert(size(l) == 0);
string_vals_sel_idx = 0;
string_vals_sel = (char**) string_vals6;
traverse(l, _traverse_assert_string_vals);
free_testdata(pa);
free_testdata(pb);
free_testdata(pc);
free_testdata(pd);
free_testdata(pe);
free_testdata(pf);
}
