bytemark/flexnbd-c
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Re-formatted tests with a bit of tinkering by hand

Browse Source
This commit is contained in:
Patrick J Cherry
2018-02-20 11:02:33 +00:00
parent 103bd7ad5b
commit 8893cd06c4
16 changed files with 1676 additions and 1709 deletions
Download Patch File Download Diff File Expand all files Collapse all files

261
tests/unit/check_acl.c
View File

@@ -4,226 +4,229 @@
#include "acl.h" #include "acl.h"
#include "util.h" #include "util.h"
START_TEST( test_null_acl ) START_TEST(test_null_acl)
{ {
struct acl *acl = acl_create( 0,NULL, 0 ); struct acl *acl = acl_create(0, NULL, 0);
fail_if( NULL == acl, "No acl alloced." ); fail_if(NULL == acl, "No acl alloced.");
fail_unless( 0 == acl->len, "Incorrect length" ); fail_unless(0 == acl->len, "Incorrect length");
} }
END_TEST END_TEST
START_TEST(test_parses_single_line)
START_TEST( test_parses_single_line )
{ {
char *lines[] = {"127.0.0.1"}; char *lines[] = { "127.0.0.1" };
struct acl * acl = acl_create( 1, lines, 0 ); struct acl *acl = acl_create(1, lines, 0);
fail_unless( 1 == acl->len, "Incorrect length." ); fail_unless(1 == acl->len, "Incorrect length.");
fail_if( NULL == acl->entries, "No entries present." ); fail_if(NULL == acl->entries, "No entries present.");
} }
END_TEST END_TEST
START_TEST( test_parses_multiple_lines ) START_TEST(test_parses_multiple_lines)
{ {
char *lines[] = {"127.0.0.1", "::1"}; char *lines[] = { "127.0.0.1", "::1" };
struct acl * acl = acl_create( 2, lines, 0 ); struct acl *acl = acl_create(2, lines, 0);
union mysockaddr e0, e1; union mysockaddr e0, e1;
parse_ip_to_sockaddr( &e0.generic, lines[0] ); parse_ip_to_sockaddr(&e0.generic, lines[0]);
parse_ip_to_sockaddr( &e1.generic, lines[1] ); parse_ip_to_sockaddr(&e1.generic, lines[1]);
fail_unless( acl->len == 2, "Multiple lines not parsed" ); fail_unless(acl->len == 2, "Multiple lines not parsed");
struct ip_and_mask *entry; struct ip_and_mask *entry;
entry = &(*acl->entries)[0]; entry = &(*acl->entries)[0];
fail_unless(entry->ip.family == e0.family, "entry 0 has wrong family!"); fail_unless(entry->ip.family == e0.family,
entry = &(*acl->entries)[1]; "entry 0 has wrong family!");
fail_unless(entry->ip.family == e1.family, "entry 1 has wrong family!"); entry = &(*acl->entries)[1];
fail_unless(entry->ip.family == e1.family,
"entry 1 has wrong family!");
} }
END_TEST END_TEST
START_TEST( test_destroy_doesnt_crash ) START_TEST(test_destroy_doesnt_crash)
{ {
char *lines[] = {"127.0.0.1"}; char *lines[] = { "127.0.0.1" };
struct acl * acl = acl_create( 1, lines, 0 ); struct acl *acl = acl_create(1, lines, 0);
acl_destroy( acl ); acl_destroy(acl);
} }
END_TEST END_TEST
START_TEST(test_includes_single_address)
START_TEST( test_includes_single_address )
{ {
char *lines[] = {"127.0.0.1"}; char *lines[] = { "127.0.0.1" };
struct acl * acl = acl_create( 1, lines, 0 ); struct acl *acl = acl_create(1, lines, 0);
union mysockaddr x; union mysockaddr x;
parse_ip_to_sockaddr( &x.generic, "127.0.0.1" ); parse_ip_to_sockaddr(&x.generic, "127.0.0.1");
fail_unless( acl_includes( acl, &x ), "Included address wasn't covered" ); fail_unless(acl_includes(acl, &x), "Included address wasn't covered");
} }
END_TEST END_TEST
START_TEST( test_includes_single_address_when_netmask_specified_ipv4 ) START_TEST(test_includes_single_address_when_netmask_specified_ipv4)
{ {
char *lines[] = {"127.0.0.1/24"}; char *lines[] = { "127.0.0.1/24" };
struct acl * acl = acl_create( 1, lines, 0 ); struct acl *acl = acl_create(1, lines, 0);
union mysockaddr x; union mysockaddr x;
parse_ip_to_sockaddr( &x.generic, "127.0.0.0" ); parse_ip_to_sockaddr(&x.generic, "127.0.0.0");
fail_unless( acl_includes( acl, &x ), "Included address wasn't covered" ); fail_unless(acl_includes(acl, &x), "Included address wasn't covered");
parse_ip_to_sockaddr( &x.generic, "127.0.0.1" ); parse_ip_to_sockaddr(&x.generic, "127.0.0.1");
fail_unless( acl_includes( acl, &x ), "Included address wasn't covered" ); fail_unless(acl_includes(acl, &x), "Included address wasn't covered");
parse_ip_to_sockaddr( &x.generic, "127.0.0.255" ); parse_ip_to_sockaddr(&x.generic, "127.0.0.255");
fail_unless( acl_includes( acl, &x ), "Included address wasn't covered" ); fail_unless(acl_includes(acl, &x), "Included address wasn't covered");
} }
END_TEST END_TEST
START_TEST( test_includes_single_address_when_netmask_specified_ipv6 ) START_TEST(test_includes_single_address_when_netmask_specified_ipv6)
{ {
char *lines[] = {"fe80::/10"}; char *lines[] = { "fe80::/10" };
struct acl * acl = acl_create( 1, lines, 0 ); struct acl *acl = acl_create(1, lines, 0);
union mysockaddr x; union mysockaddr x;
parse_ip_to_sockaddr( &x.generic, "fe80::1" ); parse_ip_to_sockaddr(&x.generic, "fe80::1");
fail_unless( acl_includes( acl, &x ), "Included address wasn't covered" ); fail_unless(acl_includes(acl, &x), "Included address wasn't covered");
parse_ip_to_sockaddr( &x.generic, "fe80::2" ); parse_ip_to_sockaddr(&x.generic, "fe80::2");
fail_unless( acl_includes( acl, &x ), "Included address wasn't covered" ); fail_unless(acl_includes(acl, &x), "Included address wasn't covered");
parse_ip_to_sockaddr( &x.generic, "fe80:ffff:ffff::ffff" ); parse_ip_to_sockaddr(&x.generic, "fe80:ffff:ffff::ffff");
fail_unless( acl_includes( acl, &x ), "Included address wasn't covered" ); fail_unless(acl_includes(acl, &x), "Included address wasn't covered");
} }
END_TEST END_TEST
START_TEST( test_includes_single_address_when_multiple_entries_exist ) START_TEST(test_includes_single_address_when_multiple_entries_exist)
{ {
char *lines[] = {"127.0.0.1", "::1"}; char *lines[] = { "127.0.0.1", "::1" };
struct acl * acl = acl_create( 2, lines, 0 ); struct acl *acl = acl_create(2, lines, 0);
union mysockaddr e0; union mysockaddr e0;
union mysockaddr e1; union mysockaddr e1;
parse_ip_to_sockaddr( &e0.generic, "127.0.0.1" ); parse_ip_to_sockaddr(&e0.generic, "127.0.0.1");
parse_ip_to_sockaddr( &e1.generic, "::1" ); parse_ip_to_sockaddr(&e1.generic, "::1");
fail_unless( acl_includes( acl, &e0 ), "Included address 0 wasn't covered" ); fail_unless(acl_includes(acl, &e0),
fail_unless( acl_includes( acl, &e1 ), "Included address 1 wasn't covered" ); "Included address 0 wasn't covered");
fail_unless(acl_includes(acl, &e1),
"Included address 1 wasn't covered");
} }
END_TEST END_TEST
START_TEST(test_doesnt_include_other_address)
START_TEST( test_doesnt_include_other_address )
{ {
char *lines[] = {"127.0.0.1"}; char *lines[] = { "127.0.0.1" };
struct acl * acl = acl_create( 1, lines, 0 ); struct acl *acl = acl_create(1, lines, 0);
union mysockaddr x; union mysockaddr x;
parse_ip_to_sockaddr( &x.generic, "127.0.0.2" ); parse_ip_to_sockaddr(&x.generic, "127.0.0.2");
fail_if( acl_includes( acl, &x ), "Excluded address was covered." ); fail_if(acl_includes(acl, &x), "Excluded address was covered.");
} }
END_TEST END_TEST
START_TEST( test_doesnt_include_other_address_when_netmask_specified ) START_TEST(test_doesnt_include_other_address_when_netmask_specified)
{ {
char *lines[] = {"127.0.0.1/32"}; char *lines[] = { "127.0.0.1/32" };
struct acl * acl = acl_create( 1, lines, 0 ); struct acl *acl = acl_create(1, lines, 0);
union mysockaddr x; union mysockaddr x;
parse_ip_to_sockaddr( &x.generic, "127.0.0.2" ); parse_ip_to_sockaddr(&x.generic, "127.0.0.2");
fail_if( acl_includes( acl, &x ), "Excluded address was covered." ); fail_if(acl_includes(acl, &x), "Excluded address was covered.");
} }
END_TEST END_TEST
START_TEST( test_doesnt_include_other_address_when_multiple_entries_exist ) START_TEST(test_doesnt_include_other_address_when_multiple_entries_exist)
{ {
char *lines[] = {"127.0.0.1", "::1"}; char *lines[] = { "127.0.0.1", "::1" };
struct acl * acl = acl_create( 2, lines, 0 ); struct acl *acl = acl_create(2, lines, 0);
union mysockaddr e0; union mysockaddr e0;
union mysockaddr e1; union mysockaddr e1;
parse_ip_to_sockaddr( &e0.generic, "127.0.0.2" ); parse_ip_to_sockaddr(&e0.generic, "127.0.0.2");
parse_ip_to_sockaddr( &e1.generic, "::2" ); parse_ip_to_sockaddr(&e1.generic, "::2");
fail_if( acl_includes( acl, &e0 ), "Excluded address 0 was covered." ); fail_if(acl_includes(acl, &e0), "Excluded address 0 was covered.");
fail_if( acl_includes( acl, &e1 ), "Excluded address 1 was covered." ); fail_if(acl_includes(acl, &e1), "Excluded address 1 was covered.");
} }
END_TEST END_TEST
START_TEST( test_default_deny_rejects ) START_TEST(test_default_deny_rejects)
{ {
struct acl * acl = acl_create( 0, NULL, 1 ); struct acl *acl = acl_create(0, NULL, 1);
union mysockaddr x; union mysockaddr x;
parse_ip_to_sockaddr( &x.generic, "127.0.0.1" ); parse_ip_to_sockaddr(&x.generic, "127.0.0.1");
fail_if( acl_includes( acl, &x ), "Default deny accepted." ); fail_if(acl_includes(acl, &x), "Default deny accepted.");
} }
END_TEST END_TEST
START_TEST(test_default_accept_rejects)
START_TEST( test_default_accept_rejects )
{ {
struct acl * acl = acl_create( 0, NULL, 0 ); struct acl *acl = acl_create(0, NULL, 0);
union mysockaddr x; union mysockaddr x;
parse_ip_to_sockaddr( &x.generic, "127.0.0.1" ); parse_ip_to_sockaddr(&x.generic, "127.0.0.1");
fail_unless( acl_includes( acl, &x ), "Default accept rejected." ); fail_unless(acl_includes(acl, &x), "Default accept rejected.");
} }
END_TEST END_TEST
Suite * acl_suite(void)
Suite* acl_suite(void)
{ {
Suite *s = suite_create("acl"); Suite *s = suite_create("acl");
TCase *tc_create = tcase_create("create"); TCase *tc_create = tcase_create("create");
TCase *tc_includes = tcase_create("includes"); TCase *tc_includes = tcase_create("includes");
TCase *tc_destroy = tcase_create("destroy"); TCase *tc_destroy = tcase_create("destroy");
tcase_add_test(tc_create, test_null_acl); tcase_add_test(tc_create, test_null_acl);
tcase_add_test(tc_create, test_parses_single_line); tcase_add_test(tc_create, test_parses_single_line);
tcase_add_test(tc_includes, test_parses_multiple_lines); tcase_add_test(tc_includes, test_parses_multiple_lines);
tcase_add_test(tc_includes, test_includes_single_address); tcase_add_test(tc_includes, test_includes_single_address);
tcase_add_test(tc_includes, test_includes_single_address_when_netmask_specified_ipv4); tcase_add_test(tc_includes,
tcase_add_test(tc_includes, test_includes_single_address_when_netmask_specified_ipv6); test_includes_single_address_when_netmask_specified_ipv4);
tcase_add_test(tc_includes,
test_includes_single_address_when_netmask_specified_ipv6);
tcase_add_test(tc_includes, test_includes_single_address_when_multiple_entries_exist); tcase_add_test(tc_includes,
test_includes_single_address_when_multiple_entries_exist);
tcase_add_test(tc_includes, test_doesnt_include_other_address); tcase_add_test(tc_includes, test_doesnt_include_other_address);
tcase_add_test(tc_includes, test_doesnt_include_other_address_when_netmask_specified); tcase_add_test(tc_includes,
tcase_add_test(tc_includes, test_doesnt_include_other_address_when_multiple_entries_exist); test_doesnt_include_other_address_when_netmask_specified);
tcase_add_test(tc_includes,
test_doesnt_include_other_address_when_multiple_entries_exist);
tcase_add_test(tc_includes, test_default_deny_rejects); tcase_add_test(tc_includes, test_default_deny_rejects);
tcase_add_test(tc_includes, test_default_accept_rejects); tcase_add_test(tc_includes, test_default_accept_rejects);
tcase_add_test(tc_destroy, test_destroy_doesnt_crash); tcase_add_test(tc_destroy, test_destroy_doesnt_crash);
suite_add_tcase(s, tc_create); suite_add_tcase(s, tc_create);
suite_add_tcase(s, tc_includes); suite_add_tcase(s, tc_includes);
suite_add_tcase(s, tc_destroy); suite_add_tcase(s, tc_destroy);
return s; return s;
} }
int main(void) int main(void)
{ {
#ifdef DEBUG #ifdef DEBUG
log_level = 0; log_level = 0;
#else #else
log_level = 2; log_level = 2;
#endif #endif
int number_failed; int number_failed;
Suite *s = acl_suite(); Suite *s = acl_suite();
SRunner *sr = srunner_create(s); SRunner *sr = srunner_create(s);
srunner_run_all(sr, CK_NORMAL); srunner_run_all(sr, CK_NORMAL);
log_level = 0; log_level = 0;
number_failed = srunner_ntests_failed(sr); number_failed = srunner_ntests_failed(sr);
srunner_free(sr); srunner_free(sr);
return (number_failed == 0) ? 0 : 1; return (number_failed == 0) ? 0 : 1;
} }

614
tests/unit/check_bitset.c
View File

@@ -9,492 +9,492 @@
START_TEST(test_bit_set) START_TEST(test_bit_set)
{ {
uint64_t num = 0; uint64_t num = 0;
bitfield_p bits = (bitfield_p) # bitfield_p bits = (bitfield_p) & num;
#define TEST_BIT_SET(bit, newvalue) \ #define TEST_BIT_SET(bit, newvalue) \
bit_set(bits, (bit)); \ bit_set(bits, (bit)); \
fail_unless(num == (newvalue), "num was %x instead of %x", num, (newvalue)); fail_unless(num == (newvalue), "num was %x instead of %x", num, (newvalue));
TEST_BIT_SET(0, 1); TEST_BIT_SET(0, 1);
TEST_BIT_SET(1, 3); TEST_BIT_SET(1, 3);
TEST_BIT_SET(2, 7); TEST_BIT_SET(2, 7);
TEST_BIT_SET(7, 0x87); TEST_BIT_SET(7, 0x87);
TEST_BIT_SET(63, 0x8000000000000087); TEST_BIT_SET(63, 0x8000000000000087);
} }
END_TEST END_TEST
START_TEST(test_bit_clear) START_TEST(test_bit_clear)
{ {
uint64_t num = 0xffffffffffffffff; uint64_t num = 0xffffffffffffffff;
bitfield_p bits = (bitfield_p) # bitfield_p bits = (bitfield_p) & num;
#define TEST_BIT_CLEAR(bit, newvalue) \ #define TEST_BIT_CLEAR(bit, newvalue) \
bit_clear(bits, (bit)); \ bit_clear(bits, (bit)); \
fail_unless(num == (newvalue), "num was %x instead of %x", num, (newvalue)); fail_unless(num == (newvalue), "num was %x instead of %x", num, (newvalue));
TEST_BIT_CLEAR(0, 0xfffffffffffffffe); TEST_BIT_CLEAR(0, 0xfffffffffffffffe);
TEST_BIT_CLEAR(1, 0xfffffffffffffffc); TEST_BIT_CLEAR(1, 0xfffffffffffffffc);
TEST_BIT_CLEAR(2, 0xfffffffffffffff8); TEST_BIT_CLEAR(2, 0xfffffffffffffff8);
TEST_BIT_CLEAR(7, 0xffffffffffffff78); TEST_BIT_CLEAR(7, 0xffffffffffffff78);
TEST_BIT_CLEAR(63,0x7fffffffffffff78); TEST_BIT_CLEAR(63, 0x7fffffffffffff78);
} }
END_TEST END_TEST
START_TEST(test_bit_tests) START_TEST(test_bit_tests)
{ {
uint64_t num = 0x5555555555555555; uint64_t num = 0x5555555555555555;
bitfield_p bits = (bitfield_p) # bitfield_p bits = (bitfield_p) & num;
fail_unless(bit_has_value(bits, 0, 1), "bit_has_value malfunction"); fail_unless(bit_has_value(bits, 0, 1), "bit_has_value malfunction");
fail_unless(bit_has_value(bits, 1, 0), "bit_has_value malfunction"); fail_unless(bit_has_value(bits, 1, 0), "bit_has_value malfunction");
fail_unless(bit_has_value(bits, 63, 0), "bit_has_value malfunction"); fail_unless(bit_has_value(bits, 63, 0), "bit_has_value malfunction");
fail_unless(bit_is_set(bits, 0), "bit_is_set malfunction"); fail_unless(bit_is_set(bits, 0), "bit_is_set malfunction");
fail_unless(bit_is_clear(bits, 1), "bit_is_clear malfunction"); fail_unless(bit_is_clear(bits, 1), "bit_is_clear malfunction");
fail_unless(bit_is_set(bits, 62), "bit_is_set malfunction"); fail_unless(bit_is_set(bits, 62), "bit_is_set malfunction");
fail_unless(bit_is_clear(bits, 63), "bit_is_clear malfunction"); fail_unless(bit_is_clear(bits, 63), "bit_is_clear malfunction");
} }
END_TEST END_TEST
START_TEST(test_bit_ranges) START_TEST(test_bit_ranges)
{ {
bitfield_word_t buffer[BIT_WORDS_FOR_SIZE(4160)]; bitfield_word_t buffer[BIT_WORDS_FOR_SIZE(4160)];
uint64_t *longs = (uint64_t *) buffer; uint64_t *longs = (uint64_t *) buffer;
uint64_t i; uint64_t i;
memset(buffer, 0, 4160); memset(buffer, 0, 4160);
for (i=0; i<64; i++) { for (i = 0; i < 64; i++) {
bit_set_range(buffer, i*64, i); bit_set_range(buffer, i * 64, i);
fail_unless( fail_unless(longs[i] == (1ULL << i) - 1,
longs[i] == (1ULL<<i)-1, "longs[%ld] = %lx SHOULD BE %lx",
"longs[%ld] = %lx SHOULD BE %lx", i, longs[i], (1ULL << i) - 1);
i, longs[i], (1ULL<<i)-1
);
fail_unless(longs[i+1] == 0, "bit_set_range overshot at i=%d", i); fail_unless(longs[i + 1] == 0, "bit_set_range overshot at i=%d",
} i);
}
for (i=0; i<64; i++) { for (i = 0; i < 64; i++) {
bit_clear_range(buffer, i*64, i); bit_clear_range(buffer, i * 64, i);
fail_unless(longs[i] == 0, "bit_clear_range didn't work at i=%d", i); fail_unless(longs[i] == 0, "bit_clear_range didn't work at i=%d",
} i);
}
} }
END_TEST END_TEST
START_TEST(test_bit_runs) START_TEST(test_bit_runs)
{ {
bitfield_word_t buffer[BIT_WORDS_FOR_SIZE(256)]; bitfield_word_t buffer[BIT_WORDS_FOR_SIZE(256)];
int i, ptr=0, runs[] = { int i, ptr = 0, runs[] = {
56,97,22,12,83,1,45,80,85,51,64,40,63,67,75,64,94,81,79,62 56, 97, 22, 12, 83, 1, 45, 80, 85, 51, 64, 40, 63, 67, 75, 64, 94,
}; 81, 79, 62
};
memset(buffer,0,256); memset(buffer, 0, 256);
for (i=0; i < 20; i += 2) { for (i = 0; i < 20; i += 2) {
ptr += runs[i]; ptr += runs[i];
bit_set_range(buffer, ptr, runs[i+1]); bit_set_range(buffer, ptr, runs[i + 1]);
ptr += runs[i+1]; ptr += runs[i + 1];
} }
ptr = 0; ptr = 0;
for (i=0; i < 20; i += 1) { for (i = 0; i < 20; i += 1) {
int run = bit_run_count(buffer, ptr, 2048-ptr, NULL); int run = bit_run_count(buffer, ptr, 2048 - ptr, NULL);
fail_unless( fail_unless(run == runs[i],
run == runs[i], "run %d should have been %d, was %d", i, runs[i], run);
"run %d should have been %d, was %d", ptr += runs[i];
i, runs[i], run }
);
ptr += runs[i];
}
} }
END_TEST END_TEST
START_TEST(test_bitset) START_TEST(test_bitset)
{ {
struct bitset * map; struct bitset *map;
uint64_t *num; uint64_t *num;
map = bitset_alloc(6400, 100); map = bitset_alloc(6400, 100);
num = (uint64_t*) map->bits; num = (uint64_t *) map->bits;
bitset_set_range(map,0,50); bitset_set_range(map, 0, 50);
ck_assert_int_eq(1, *num); ck_assert_int_eq(1, *num);
bitset_set_range(map,99,1); bitset_set_range(map, 99, 1);
ck_assert_int_eq(1, *num); ck_assert_int_eq(1, *num);
bitset_set_range(map,100,1); bitset_set_range(map, 100, 1);
ck_assert_int_eq(3, *num); ck_assert_int_eq(3, *num);
bitset_set_range(map,0,800); bitset_set_range(map, 0, 800);
ck_assert_int_eq(255, *num); ck_assert_int_eq(255, *num);
bitset_set_range(map,1499,2); bitset_set_range(map, 1499, 2);
ck_assert_int_eq(0xc0ff, *num); ck_assert_int_eq(0xc0ff, *num);
bitset_clear_range(map,1499,2); bitset_clear_range(map, 1499, 2);
ck_assert_int_eq(255, *num); ck_assert_int_eq(255, *num);
*num = 0; *num = 0;
bitset_set_range(map, 1499, 2); bitset_set_range(map, 1499, 2);
bitset_clear_range(map, 1300, 200); bitset_clear_range(map, 1300, 200);
ck_assert_int_eq(0x8000, *num); ck_assert_int_eq(0x8000, *num);
*num = 0; *num = 0;
bitset_set_range(map, 0, 6400); bitset_set_range(map, 0, 6400);
ck_assert_int_eq(0xffffffffffffffff, *num); ck_assert_int_eq(0xffffffffffffffff, *num);
bitset_clear_range(map, 3200, 400); bitset_clear_range(map, 3200, 400);
ck_assert_int_eq(0xfffffff0ffffffff, *num); ck_assert_int_eq(0xfffffff0ffffffff, *num);
} }
END_TEST END_TEST
START_TEST(test_bitset_set)
START_TEST( test_bitset_set )
{ {
struct bitset * map; struct bitset *map;
uint64_t run; uint64_t run;
map = bitset_alloc(64, 1); map = bitset_alloc(64, 1);
assert_bitset_is( map, 0x0000000000000000 ); assert_bitset_is(map, 0x0000000000000000);
bitset_set( map ); bitset_set(map);
assert_bitset_is( map, 0xffffffffffffffff ); assert_bitset_is(map, 0xffffffffffffffff);
bitset_free( map ); bitset_free(map);
map = bitset_alloc( 6400, 100 ); map = bitset_alloc(6400, 100);
assert_bitset_is( map, 0x0000000000000000 ); assert_bitset_is(map, 0x0000000000000000);
bitset_set( map ); bitset_set(map);
assert_bitset_is( map, 0xffffffffffffffff ); assert_bitset_is(map, 0xffffffffffffffff);
bitset_free( map ); bitset_free(map);
// Now do something large and representative // Now do something large and representative
map = bitset_alloc( 53687091200, 4096 ); map = bitset_alloc(53687091200, 4096);
bitset_set( map ); bitset_set(map);
run = bitset_run_count( map, 0, 53687091200 ); run = bitset_run_count(map, 0, 53687091200);
ck_assert_int_eq( run, 53687091200 ); ck_assert_int_eq(run, 53687091200);
bitset_free( map ); bitset_free(map);
} }
END_TEST END_TEST
START_TEST(test_bitset_clear)
START_TEST( test_bitset_clear )
{ {
struct bitset * map; struct bitset *map;
uint64_t *num; uint64_t *num;
uint64_t run; uint64_t run;
map = bitset_alloc(64, 1); map = bitset_alloc(64, 1);
num = (uint64_t*) map->bits; num = (uint64_t *) map->bits;
ck_assert_int_eq( 0x0000000000000000, *num ); ck_assert_int_eq(0x0000000000000000, *num);
bitset_set( map ); bitset_set(map);
bitset_clear( map ); bitset_clear(map);
ck_assert_int_eq( 0x0000000000000000, *num ); ck_assert_int_eq(0x0000000000000000, *num);
bitset_free( map ); bitset_free(map);
// Now do something large and representative // Now do something large and representative
map = bitset_alloc( 53687091200, 4096 ); map = bitset_alloc(53687091200, 4096);
bitset_set( map ); bitset_set(map);
bitset_clear( map ); bitset_clear(map);
run = bitset_run_count( map, 0, 53687091200 ); run = bitset_run_count(map, 0, 53687091200);
ck_assert_int_eq( run, 53687091200 ); ck_assert_int_eq(run, 53687091200);
bitset_free( map ); bitset_free(map);
} }
END_TEST END_TEST
START_TEST( test_bitset_set_range ) START_TEST(test_bitset_set_range)
{ {
struct bitset* map = bitset_alloc( 64, 1 ); struct bitset *map = bitset_alloc(64, 1);
assert_bitset_is( map, 0x0000000000000000 ); assert_bitset_is(map, 0x0000000000000000);
bitset_set_range( map, 8, 8 ); bitset_set_range(map, 8, 8);
assert_bitset_is( map, 0x000000000000ff00 ); assert_bitset_is(map, 0x000000000000ff00);
bitset_clear( map ); bitset_clear(map);
assert_bitset_is( map, 0x0000000000000000 ); assert_bitset_is(map, 0x0000000000000000);
bitset_set_range( map, 0, 0 ); bitset_set_range(map, 0, 0);
assert_bitset_is( map, 0x0000000000000000 ); assert_bitset_is(map, 0x0000000000000000);
bitset_free( map ); bitset_free(map);
} }
END_TEST END_TEST
START_TEST( test_bitset_clear_range ) START_TEST(test_bitset_clear_range)
{ {
struct bitset* map = bitset_alloc( 64, 1 ); struct bitset *map = bitset_alloc(64, 1);
bitset_set( map ); bitset_set(map);
assert_bitset_is( map, 0xffffffffffffffff ); assert_bitset_is(map, 0xffffffffffffffff);
bitset_clear_range( map, 8, 8 ); bitset_clear_range(map, 8, 8);
assert_bitset_is( map, 0xffffffffffff00ff ); assert_bitset_is(map, 0xffffffffffff00ff);
bitset_set( map ); bitset_set(map);
assert_bitset_is( map, 0xffffffffffffffff ); assert_bitset_is(map, 0xffffffffffffffff);
bitset_clear_range( map, 0, 0 ); bitset_clear_range(map, 0, 0);
assert_bitset_is( map, 0xffffffffffffffff ); assert_bitset_is(map, 0xffffffffffffffff);
bitset_free( map ); bitset_free(map);
} }
END_TEST END_TEST
START_TEST( test_bitset_run_count ) START_TEST(test_bitset_run_count)
{ {
struct bitset* map = bitset_alloc( 64, 1 ); struct bitset *map = bitset_alloc(64, 1);
uint64_t run; uint64_t run;
assert_bitset_is( map, 0x0000000000000000 ); assert_bitset_is(map, 0x0000000000000000);
run = bitset_run_count( map, 0, 64 ); run = bitset_run_count(map, 0, 64);
ck_assert_int_eq( 64, run ); ck_assert_int_eq(64, run);
bitset_set_range( map, 0, 32 ); bitset_set_range(map, 0, 32);
assert_bitset_is( map, 0x00000000ffffffff ); assert_bitset_is(map, 0x00000000ffffffff);
run = bitset_run_count( map, 0, 64 ); run = bitset_run_count(map, 0, 64);
ck_assert_int_eq( 32, run ); ck_assert_int_eq(32, run);
run = bitset_run_count( map, 0, 16 ); run = bitset_run_count(map, 0, 16);
ck_assert_int_eq( 16, run ); ck_assert_int_eq(16, run);
run = bitset_run_count( map, 16, 64 ); run = bitset_run_count(map, 16, 64);
ck_assert_int_eq( 16, run ); ck_assert_int_eq(16, run);
run = bitset_run_count( map, 31, 64 ); run = bitset_run_count(map, 31, 64);
ck_assert_int_eq( 1, run ); ck_assert_int_eq(1, run);
run = bitset_run_count( map, 32, 64 ); run = bitset_run_count(map, 32, 64);
ck_assert_int_eq( 32, run ); ck_assert_int_eq(32, run);
run = bitset_run_count( map, 32, 32 ); run = bitset_run_count(map, 32, 32);
ck_assert_int_eq( 32, run ); ck_assert_int_eq(32, run);
run = bitset_run_count( map, 32, 16 ); run = bitset_run_count(map, 32, 16);
ck_assert_int_eq( 16, run ); ck_assert_int_eq(16, run);
bitset_free( map ); bitset_free(map);
map = bitset_alloc( 6400, 100 ); map = bitset_alloc(6400, 100);
assert_bitset_is( map, 0x0000000000000000 ); assert_bitset_is(map, 0x0000000000000000);
run = bitset_run_count( map, 0, 6400 ); run = bitset_run_count(map, 0, 6400);
ck_assert_int_eq( 6400, run ); ck_assert_int_eq(6400, run);
bitset_set_range( map, 0, 3200 ); bitset_set_range(map, 0, 3200);
run = bitset_run_count( map, 0, 6400 ); run = bitset_run_count(map, 0, 6400);
ck_assert_int_eq( 3200, run ); ck_assert_int_eq(3200, run);
run = bitset_run_count( map, 1, 6400 ); run = bitset_run_count(map, 1, 6400);
ck_assert_int_eq( 3199, run ); ck_assert_int_eq(3199, run);
run = bitset_run_count( map, 3200, 6400 ); run = bitset_run_count(map, 3200, 6400);
ck_assert_int_eq( 3200, run ); ck_assert_int_eq(3200, run);
run = bitset_run_count( map, 6500, 6400 ); run = bitset_run_count(map, 6500, 6400);
ck_assert_int_eq( 0, run ); ck_assert_int_eq(0, run);
bitset_free( map ); bitset_free(map);
// Now do something large and representative // Now do something large and representative
map = bitset_alloc( 53687091200, 4096 ); map = bitset_alloc(53687091200, 4096);
bitset_set( map ); bitset_set(map);
run = bitset_run_count( map, 0, 53687091200 ); run = bitset_run_count(map, 0, 53687091200);
ck_assert_int_eq( run, 53687091200 ); ck_assert_int_eq(run, 53687091200);
bitset_free( map ); bitset_free(map);
} }
END_TEST END_TEST
START_TEST( test_bitset_set_range_doesnt_push_to_stream ) START_TEST(test_bitset_set_range_doesnt_push_to_stream)
{ {
struct bitset *map = bitset_alloc( 64, 1 ); struct bitset *map = bitset_alloc(64, 1);
bitset_set_range( map, 0, 64 ); bitset_set_range(map, 0, 64);
ck_assert_int_eq( 0, bitset_stream_size( map ) ); ck_assert_int_eq(0, bitset_stream_size(map));
bitset_free( map ); bitset_free(map);
} }
END_TEST END_TEST
START_TEST( test_bitset_clear_range_doesnt_push_to_stream ) START_TEST(test_bitset_clear_range_doesnt_push_to_stream)
{ {
struct bitset *map = bitset_alloc( 64, 1 ); struct bitset *map = bitset_alloc(64, 1);
bitset_clear_range( map, 0, 64 ); bitset_clear_range(map, 0, 64);
ck_assert_int_eq( 0, bitset_stream_size( map ) ); ck_assert_int_eq(0, bitset_stream_size(map));
bitset_free( map ); bitset_free(map);
} }
END_TEST END_TEST
START_TEST(test_bitset_enable_stream) START_TEST(test_bitset_enable_stream)
{ {
struct bitset *map = bitset_alloc( 64, 1 ); struct bitset *map = bitset_alloc(64, 1);
struct bitset_stream_entry result; struct bitset_stream_entry result;
memset( &result, 0, sizeof( result ) ); memset(&result, 0, sizeof(result));
bitset_enable_stream( map ); bitset_enable_stream(map);
ck_assert_int_eq( 1, map->stream_enabled ); ck_assert_int_eq(1, map->stream_enabled);
bitset_stream_dequeue( map, &result ); bitset_stream_dequeue(map, &result);
ck_assert_int_eq( BITSET_STREAM_ON, result.event ); ck_assert_int_eq(BITSET_STREAM_ON, result.event);
ck_assert_int_eq( 0, result.from ); ck_assert_int_eq(0, result.from);
ck_assert_int_eq( 64, result.len ); ck_assert_int_eq(64, result.len);
bitset_free( map ); bitset_free(map);
} }
END_TEST END_TEST
START_TEST(test_bitset_disable_stream) START_TEST(test_bitset_disable_stream)
{ {
struct bitset *map = bitset_alloc( 64, 1 ); struct bitset *map = bitset_alloc(64, 1);
struct bitset_stream_entry result; struct bitset_stream_entry result;
memset( &result, 0, sizeof( result ) ); memset(&result, 0, sizeof(result));
bitset_enable_stream( map ); bitset_enable_stream(map);
bitset_disable_stream( map ); bitset_disable_stream(map);
ck_assert_int_eq( 0, map->stream_enabled ); ck_assert_int_eq(0, map->stream_enabled);
ck_assert_int_eq( 2, bitset_stream_size( map ) ); ck_assert_int_eq(2, bitset_stream_size(map));
bitset_stream_dequeue( map, NULL ); // ON bitset_stream_dequeue(map, NULL); // ON
bitset_stream_dequeue( map, &result ); // OFF bitset_stream_dequeue(map, &result); // OFF
ck_assert_int_eq( BITSET_STREAM_OFF, result.event ); ck_assert_int_eq(BITSET_STREAM_OFF, result.event);
ck_assert_int_eq( 0, result.from ); ck_assert_int_eq(0, result.from);
ck_assert_int_eq( 64, result.len ); ck_assert_int_eq(64, result.len);
bitset_free( map ); bitset_free(map);
} }
END_TEST END_TEST
START_TEST(test_bitset_stream_with_set_range) START_TEST(test_bitset_stream_with_set_range)
{ {
struct bitset *map = bitset_alloc( 64, 1 ); struct bitset *map = bitset_alloc(64, 1);
struct bitset_stream_entry result; struct bitset_stream_entry result;
memset( &result, 0, sizeof( result ) ); memset(&result, 0, sizeof(result));
bitset_enable_stream( map ); bitset_enable_stream(map);
bitset_set_range( map, 0, 32 ); bitset_set_range(map, 0, 32);
ck_assert_int_eq( 2, bitset_stream_size( map ) ); ck_assert_int_eq(2, bitset_stream_size(map));
bitset_stream_dequeue( map, NULL ); // ON bitset_stream_dequeue(map, NULL); // ON
bitset_stream_dequeue( map, &result ); // SET bitset_stream_dequeue(map, &result); // SET
ck_assert_int_eq( BITSET_STREAM_SET, result.event ); ck_assert_int_eq(BITSET_STREAM_SET, result.event);
ck_assert_int_eq( 0, result.from ); ck_assert_int_eq(0, result.from);
ck_assert_int_eq( 32, result.len ); ck_assert_int_eq(32, result.len);
bitset_free( map ); bitset_free(map);
} }
END_TEST END_TEST
START_TEST(test_bitset_stream_with_clear_range) START_TEST(test_bitset_stream_with_clear_range)
{ {
struct bitset *map = bitset_alloc( 64, 1 ); struct bitset *map = bitset_alloc(64, 1);
struct bitset_stream_entry result; struct bitset_stream_entry result;
memset( &result, 0, sizeof( result ) ); memset(&result, 0, sizeof(result));
bitset_enable_stream( map ); bitset_enable_stream(map);
bitset_clear_range( map, 0, 32 ); bitset_clear_range(map, 0, 32);
ck_assert_int_eq( 2, bitset_stream_size( map ) ); ck_assert_int_eq(2, bitset_stream_size(map));
bitset_stream_dequeue( map, NULL ); // ON bitset_stream_dequeue(map, NULL); // ON
bitset_stream_dequeue( map, &result ); // UNSET bitset_stream_dequeue(map, &result); // UNSET
ck_assert_int_eq( BITSET_STREAM_UNSET, result.event ); ck_assert_int_eq(BITSET_STREAM_UNSET, result.event);
ck_assert_int_eq( 0, result.from ); ck_assert_int_eq(0, result.from);
ck_assert_int_eq( 32, result.len ); ck_assert_int_eq(32, result.len);
bitset_free( map ); bitset_free(map);
} }
END_TEST END_TEST
START_TEST(test_bitset_stream_size) START_TEST(test_bitset_stream_size)
{ {
struct bitset *map = bitset_alloc( 64, 1 ); struct bitset *map = bitset_alloc(64, 1);
bitset_enable_stream( map ); bitset_enable_stream(map);
bitset_set_range( map, 0, 32 ); bitset_set_range(map, 0, 32);
bitset_set_range( map, 16, 32 ); bitset_set_range(map, 16, 32);
bitset_set_range( map, 7, 16 ); bitset_set_range(map, 7, 16);
bitset_clear_range( map, 0, 32 ); bitset_clear_range(map, 0, 32);
bitset_clear_range( map, 16, 32 ); bitset_clear_range(map, 16, 32);
bitset_clear_range( map, 48, 16 ); bitset_clear_range(map, 48, 16);
bitset_disable_stream( map ); bitset_disable_stream(map);
ck_assert_int_eq( 8, bitset_stream_size( map ) ); ck_assert_int_eq(8, bitset_stream_size(map));
bitset_free( map ); bitset_free(map);
} }
END_TEST END_TEST
START_TEST(test_bitset_stream_queued_bytes) START_TEST(test_bitset_stream_queued_bytes)
{ {
struct bitset *map = bitset_alloc( 64, 1 ); struct bitset *map = bitset_alloc(64, 1);
bitset_enable_stream( map ); bitset_enable_stream(map);
bitset_set_range( map, 0, 32 ); bitset_set_range(map, 0, 32);
bitset_set_range( map, 16, 32 ); bitset_set_range(map, 16, 32);
bitset_set_range( map, 7, 16 ); bitset_set_range(map, 7, 16);
bitset_clear_range( map, 0, 32 ); bitset_clear_range(map, 0, 32);
bitset_clear_range( map, 16, 32 ); bitset_clear_range(map, 16, 32);
bitset_clear_range( map, 48, 16 ); bitset_clear_range(map, 48, 16);
bitset_clear_range( map, 0, 2 ); bitset_clear_range(map, 0, 2);
bitset_disable_stream( map ); bitset_disable_stream(map);
ck_assert_int_eq( 64, bitset_stream_queued_bytes( map, BITSET_STREAM_ON ) ); ck_assert_int_eq(64,
ck_assert_int_eq( 80, bitset_stream_queued_bytes( map, BITSET_STREAM_SET ) ); bitset_stream_queued_bytes(map, BITSET_STREAM_ON));
ck_assert_int_eq( 82, bitset_stream_queued_bytes( map, BITSET_STREAM_UNSET ) ); ck_assert_int_eq(80,
ck_assert_int_eq( 64, bitset_stream_queued_bytes( map, BITSET_STREAM_OFF ) ); bitset_stream_queued_bytes(map, BITSET_STREAM_SET));
bitset_free( map ); ck_assert_int_eq(82,
bitset_stream_queued_bytes(map, BITSET_STREAM_UNSET));
ck_assert_int_eq(64,
bitset_stream_queued_bytes(map, BITSET_STREAM_OFF));
bitset_free(map);
} }
END_TEST END_TEST
Suite* bitset_suite(void) Suite * bitset_suite(void)
{ {
Suite *s = suite_create("bitset"); Suite *s = suite_create("bitset");
TCase *tc_bit = tcase_create("bit"); TCase *tc_bit = tcase_create("bit");
tcase_add_test(tc_bit, test_bit_set); tcase_add_test(tc_bit, test_bit_set);
tcase_add_test(tc_bit, test_bit_clear); tcase_add_test(tc_bit, test_bit_clear);
tcase_add_test(tc_bit, test_bit_tests); tcase_add_test(tc_bit, test_bit_tests);
tcase_add_test(tc_bit, test_bit_ranges); tcase_add_test(tc_bit, test_bit_ranges);
tcase_add_test(tc_bit, test_bit_runs); tcase_add_test(tc_bit, test_bit_runs);
suite_add_tcase(s, tc_bit); suite_add_tcase(s, tc_bit);
TCase *tc_bitset = tcase_create("bitset"); TCase *tc_bitset = tcase_create("bitset");
tcase_add_test(tc_bitset, test_bitset); tcase_add_test(tc_bitset, test_bitset);
tcase_add_test(tc_bitset, test_bitset_set); tcase_add_test(tc_bitset, test_bitset_set);
tcase_add_test(tc_bitset, test_bitset_clear); tcase_add_test(tc_bitset, test_bitset_clear);
tcase_add_test(tc_bitset, test_bitset_run_count); tcase_add_test(tc_bitset, test_bitset_run_count);
tcase_add_test(tc_bitset, test_bitset_set_range); tcase_add_test(tc_bitset, test_bitset_set_range);
tcase_add_test(tc_bitset, test_bitset_clear_range); tcase_add_test(tc_bitset, test_bitset_clear_range);
tcase_add_test(tc_bitset, test_bitset_set_range_doesnt_push_to_stream); tcase_add_test(tc_bitset, test_bitset_set_range_doesnt_push_to_stream);
tcase_add_test(tc_bitset, test_bitset_clear_range_doesnt_push_to_stream); tcase_add_test(tc_bitset,
suite_add_tcase(s, tc_bitset); test_bitset_clear_range_doesnt_push_to_stream);
suite_add_tcase(s, tc_bitset);
TCase *tc_bitset_stream = tcase_create("bitset_stream"); TCase *tc_bitset_stream = tcase_create("bitset_stream");
tcase_add_test(tc_bitset_stream, test_bitset_enable_stream); tcase_add_test(tc_bitset_stream, test_bitset_enable_stream);
tcase_add_test(tc_bitset_stream, test_bitset_disable_stream); tcase_add_test(tc_bitset_stream, test_bitset_disable_stream);
tcase_add_test(tc_bitset_stream, test_bitset_stream_with_set_range); tcase_add_test(tc_bitset_stream, test_bitset_stream_with_set_range);
tcase_add_test(tc_bitset_stream, test_bitset_stream_with_clear_range); tcase_add_test(tc_bitset_stream, test_bitset_stream_with_clear_range);
tcase_add_test(tc_bitset_stream, test_bitset_stream_size); tcase_add_test(tc_bitset_stream, test_bitset_stream_size);
tcase_add_test(tc_bitset_stream, test_bitset_stream_queued_bytes); tcase_add_test(tc_bitset_stream, test_bitset_stream_queued_bytes);
suite_add_tcase(s, tc_bitset_stream); suite_add_tcase(s, tc_bitset_stream);
return s; return s;
} }
int main(void) int main(void)
{ {
int number_failed; int number_failed;
Suite *s = bitset_suite(); Suite *s = bitset_suite();
SRunner *sr = srunner_create(s); SRunner *sr = srunner_create(s);
srunner_run_all(sr, CK_NORMAL); srunner_run_all(sr, CK_NORMAL);
number_failed = srunner_ntests_failed(sr); number_failed = srunner_ntests_failed(sr);
srunner_free(sr); srunner_free(sr);
return (number_failed == 0) ? 0 : 1; return (number_failed == 0) ? 0 : 1;
} }

121
tests/unit/check_client.c
View File

@@ -9,114 +9,109 @@
#include <unistd.h> #include <unistd.h>
struct server fake_server = {0}; struct server fake_server = { 0 };
#define FAKE_SERVER &fake_server #define FAKE_SERVER &fake_server
#define FAKE_SOCKET (42) #define FAKE_SOCKET (42)
START_TEST( test_assigns_socket ) START_TEST(test_assigns_socket)
{ {
struct client * c; struct client *c;
c = client_create( FAKE_SERVER, FAKE_SOCKET ); c = client_create(FAKE_SERVER, FAKE_SOCKET);
fail_unless( 42 == c->socket, "Socket wasn't assigned." ); fail_unless(42 == c->socket, "Socket wasn't assigned.");
} }
END_TEST END_TEST
START_TEST(test_assigns_server)
START_TEST( test_assigns_server )
{ {
struct client * c; struct client *c;
/* can't predict the storage size so we can't allocate one on /* can't predict the storage size so we can't allocate one on
* the stack * the stack
*/ */
c = client_create( FAKE_SERVER, FAKE_SOCKET ); c = client_create(FAKE_SERVER, FAKE_SOCKET);
fail_unless( FAKE_SERVER == c->serve, "Serve wasn't assigned." ); fail_unless(FAKE_SERVER == c->serve, "Serve wasn't assigned.");
} }
END_TEST END_TEST
START_TEST(test_opens_stop_signal)
START_TEST( test_opens_stop_signal )
{ {
struct client *c = client_create( FAKE_SERVER, FAKE_SOCKET ); struct client *c = client_create(FAKE_SERVER, FAKE_SOCKET);
client_signal_stop( c ); client_signal_stop(c);
fail_unless( 1 == self_pipe_signal_clear( c->stop_signal ), fail_unless(1 == self_pipe_signal_clear(c->stop_signal),
"No signal was sent." ); "No signal was sent.");
} }
END_TEST END_TEST
int fd_is_closed(int); int fd_is_closed(int);
START_TEST( test_closes_stop_signal ) START_TEST(test_closes_stop_signal)
{ {
struct client *c = client_create( FAKE_SERVER, FAKE_SOCKET ); struct client *c = client_create(FAKE_SERVER, FAKE_SOCKET);
int read_fd = c->stop_signal->read_fd; int read_fd = c->stop_signal->read_fd;
int write_fd = c->stop_signal->write_fd; int write_fd = c->stop_signal->write_fd;
client_destroy( c ); client_destroy(c);
fail_unless( fd_is_closed( read_fd ), "Stop signal wasn't destroyed." ); fail_unless(fd_is_closed(read_fd), "Stop signal wasn't destroyed.");
fail_unless( fd_is_closed( write_fd ), "Stop signal wasn't destroyed." ); fail_unless(fd_is_closed(write_fd), "Stop signal wasn't destroyed.");
} }
END_TEST END_TEST
START_TEST(test_read_request_quits_on_stop_signal)
START_TEST( test_read_request_quits_on_stop_signal )
{ {
int fds[2]; int fds[2];
struct nbd_request nbdr; struct nbd_request nbdr;
pipe( fds ); pipe(fds);
struct client *c = client_create( FAKE_SERVER, fds[0] ); struct client *c = client_create(FAKE_SERVER, fds[0]);
client_signal_stop( c );
int client_serve_request( struct client *); client_signal_stop(c);
fail_unless( 1 == client_serve_request( c ), "Didn't quit on stop." );
close( fds[0] ); int client_serve_request(struct client *);
close( fds[1] ); fail_unless(1 == client_serve_request(c), "Didn't quit on stop.");
close(fds[0]);
close(fds[1]);
} }
END_TEST END_TEST
Suite * client_suite(void)
Suite *client_suite(void)
{ {
Suite *s = suite_create("client"); Suite *s = suite_create("client");
TCase *tc_create = tcase_create("create"); TCase *tc_create = tcase_create("create");
TCase *tc_signal = tcase_create("signal"); TCase *tc_signal = tcase_create("signal");
TCase *tc_destroy = tcase_create("destroy"); TCase *tc_destroy = tcase_create("destroy");
tcase_add_test(tc_create, test_assigns_socket); tcase_add_test(tc_create, test_assigns_socket);
tcase_add_test(tc_create, test_assigns_server); tcase_add_test(tc_create, test_assigns_server);
tcase_add_test(tc_signal, test_opens_stop_signal); tcase_add_test(tc_signal, test_opens_stop_signal);
tcase_add_test(tc_signal, test_read_request_quits_on_stop_signal); tcase_add_test(tc_signal, test_read_request_quits_on_stop_signal);
tcase_add_test( tc_destroy, test_closes_stop_signal ); tcase_add_test(tc_destroy, test_closes_stop_signal);
suite_add_tcase(s, tc_create); suite_add_tcase(s, tc_create);
suite_add_tcase(s, tc_signal); suite_add_tcase(s, tc_signal);
suite_add_tcase(s, tc_destroy); suite_add_tcase(s, tc_destroy);
return s; return s;
} }
int main(void) int main(void)
{ {
int number_failed; int number_failed;
Suite *s = client_suite();
SRunner *sr = srunner_create(s);
srunner_run_all(sr, CK_NORMAL);
number_failed = srunner_ntests_failed(sr);
srunner_free(sr);
return (number_failed == 0) ? 0 : 1;
}
Suite *s = client_suite();
SRunner *sr = srunner_create(s);
srunner_run_all(sr, CK_NORMAL);
number_failed = srunner_ntests_failed(sr);
srunner_free(sr);
return (number_failed == 0) ? 0 : 1;
}

40
tests/unit/check_control.c
View File

@@ -4,39 +4,37 @@
#include <check.h> #include <check.h>
START_TEST( test_assigns_sock_name ) START_TEST(test_assigns_sock_name)
{ {
struct flexnbd flexnbd = {0}; struct flexnbd flexnbd = { 0 };
char csn[] = "foobar"; char csn[] = "foobar";
struct control * control = control_create(&flexnbd, csn ); struct control *control = control_create(&flexnbd, csn);
fail_unless( csn == control->socket_name, "Socket name not assigned" ); fail_unless(csn == control->socket_name, "Socket name not assigned");
} }
END_TEST END_TEST
Suite * control_suite(void)
Suite *control_suite(void)
{ {
Suite *s = suite_create("control"); Suite *s = suite_create("control");
TCase *tc_create = tcase_create("create"); TCase *tc_create = tcase_create("create");
tcase_add_test(tc_create, test_assigns_sock_name); tcase_add_test(tc_create, test_assigns_sock_name);
suite_add_tcase( s, tc_create ); suite_add_tcase(s, tc_create);
return s; return s;
} }
int main(void) int main(void)
{ {
int number_failed; int number_failed;
Suite *s = control_suite();
SRunner *sr = srunner_create(s);
srunner_run_all(sr, CK_NORMAL);
number_failed = srunner_ntests_failed(sr);
srunner_free(sr);
return (number_failed == 0) ? 0 : 1;
}
Suite *s = control_suite();
SRunner *sr = srunner_create(s);
srunner_run_all(sr, CK_NORMAL);
number_failed = srunner_ntests_failed(sr);
srunner_free(sr);
return (number_failed == 0) ? 0 : 1;
}

49
tests/unit/check_flexnbd.c
View File

@@ -3,42 +3,39 @@
#include <check.h> #include <check.h>
START_TEST( test_listening_assigns_sock ) START_TEST(test_listening_assigns_sock)
{ {
struct flexnbd * flexnbd = flexnbd_create_listening( struct flexnbd *flexnbd = flexnbd_create_listening("127.0.0.1",
"127.0.0.1", "4777",
"4777", "fakefile",
"fakefile", "fakesock",
"fakesock", 0,
0, 0,
0, NULL);
NULL ); fail_if(NULL == flexnbd->control->socket_name, "No socket was copied");
fail_if( NULL == flexnbd->control->socket_name, "No socket was copied" );
} }
END_TEST END_TEST
Suite * flexnbd_suite(void)
Suite *flexnbd_suite(void)
{ {
Suite *s = suite_create("flexnbd"); Suite *s = suite_create("flexnbd");
TCase *tc_create = tcase_create("create"); TCase *tc_create = tcase_create("create");
tcase_add_test(tc_create, test_listening_assigns_sock); tcase_add_test(tc_create, test_listening_assigns_sock);
suite_add_tcase( s, tc_create ); suite_add_tcase(s, tc_create);
return s; return s;
} }
int main(void) int main(void)
{ {
int number_failed; int number_failed;
Suite *s = flexnbd_suite();
SRunner *sr = srunner_create(s);
srunner_run_all(sr, CK_NORMAL);
number_failed = srunner_ntests_failed(sr);
srunner_free(sr);
return (number_failed == 0) ? 0 : 1;
}
Suite *s = flexnbd_suite();
SRunner *sr = srunner_create(s);
srunner_run_all(sr, CK_NORMAL);
number_failed = srunner_ntests_failed(sr);
srunner_free(sr);
return (number_failed == 0) ? 0 : 1;
}

68
tests/unit/check_flexthread.c
View File

@@ -4,59 +4,59 @@
#include <check.h> #include <check.h>
START_TEST( test_mutex_create ) START_TEST(test_mutex_create)
{ {
struct flexthread_mutex * ftm = flexthread_mutex_create(); struct flexthread_mutex *ftm = flexthread_mutex_create();
NULLCHECK( ftm ); NULLCHECK(ftm);
flexthread_mutex_destroy( ftm ); flexthread_mutex_destroy(ftm);
} }
END_TEST END_TEST
START_TEST(test_mutex_lock)
START_TEST( test_mutex_lock )
{ {
struct flexthread_mutex * ftm = flexthread_mutex_create(); struct flexthread_mutex *ftm = flexthread_mutex_create();
fail_if( flexthread_mutex_held( ftm ), "Flexthread_mutex is held before lock" ); fail_if(flexthread_mutex_held(ftm),
flexthread_mutex_lock( ftm ); "Flexthread_mutex is held before lock");
fail_unless( flexthread_mutex_held( ftm ), "Flexthread_mutex is not held inside lock" ); flexthread_mutex_lock(ftm);
flexthread_mutex_unlock( ftm ); fail_unless(flexthread_mutex_held(ftm),
fail_if( flexthread_mutex_held( ftm ), "Flexthread_mutex is held after unlock" ); "Flexthread_mutex is not held inside lock");
flexthread_mutex_unlock(ftm);
fail_if(flexthread_mutex_held(ftm),
"Flexthread_mutex is held after unlock");
flexthread_mutex_destroy( ftm ); flexthread_mutex_destroy(ftm);
} }
END_TEST END_TEST
Suite * flexthread_suite(void)
Suite* flexthread_suite(void)
{ {
Suite *s = suite_create("flexthread"); Suite *s = suite_create("flexthread");
TCase *tc_create = tcase_create("create"); TCase *tc_create = tcase_create("create");
TCase *tc_destroy = tcase_create("destroy"); TCase *tc_destroy = tcase_create("destroy");
tcase_add_test( tc_create, test_mutex_create ); tcase_add_test(tc_create, test_mutex_create);
tcase_add_test( tc_create, test_mutex_lock ); tcase_add_test(tc_create, test_mutex_lock);
suite_add_tcase(s, tc_create); suite_add_tcase(s, tc_create);
suite_add_tcase(s, tc_destroy); suite_add_tcase(s, tc_destroy);
return s; return s;
} }
int main(void) int main(void)
{ {
#ifdef DEBUG #ifdef DEBUG
log_level = 0; log_level = 0;
#else #else
log_level = 2; log_level = 2;
#endif #endif
int number_failed; int number_failed;
Suite *s = flexthread_suite(); Suite *s = flexthread_suite();
SRunner *sr = srunner_create(s); SRunner *sr = srunner_create(s);
srunner_run_all(sr, CK_NORMAL); srunner_run_all(sr, CK_NORMAL);
log_level = 0; log_level = 0;
number_failed = srunner_ntests_failed(sr); number_failed = srunner_ntests_failed(sr);
srunner_free(sr); srunner_free(sr);
return (number_failed == 0) ? 0 : 1; return (number_failed == 0) ? 0 : 1;
} }

160
tests/unit/check_ioutil.c
View File

@@ -2,133 +2,131 @@
#include <check.h> #include <check.h>
START_TEST( test_read_until_newline_returns_line_length_plus_null ) START_TEST(test_read_until_newline_returns_line_length_plus_null)
{ {
int fds[2]; int fds[2];
int nread; int nread;
char buf[5] = {0}; char buf[5] = { 0 };
pipe(fds); pipe(fds);
write( fds[1], "1234\n", 5 ); write(fds[1], "1234\n", 5);
nread = read_until_newline( fds[0], buf, 5 );
ck_assert_int_eq( 5, nread ); nread = read_until_newline(fds[0], buf, 5);
ck_assert_int_eq(5, nread);
} }
END_TEST END_TEST
START_TEST(test_read_until_newline_inserts_null)
START_TEST( test_read_until_newline_inserts_null )
{ {
int fds[2]; int fds[2];
int nread; int nread;
char buf[5] = {0}; char buf[5] = { 0 };
pipe(fds); pipe(fds);
write( fds[1], "1234\n", 5 ); write(fds[1], "1234\n", 5);
nread = read_until_newline( fds[0], buf, 5 );
ck_assert_int_eq( '\0', buf[4] ); nread = read_until_newline(fds[0], buf, 5);
ck_assert_int_eq('\0', buf[4]);
} }
END_TEST END_TEST
START_TEST(test_read_empty_line_inserts_null)
START_TEST( test_read_empty_line_inserts_null )
{ {
int fds[2]; int fds[2];
int nread; int nread;
char buf[5] = {0}; char buf[5] = { 0 };
pipe(fds); pipe(fds);
write( fds[1], "\n", 1 ); write(fds[1], "\n", 1);
nread = read_until_newline( fds[0], buf, 1 ); nread = read_until_newline(fds[0], buf, 1);
ck_assert_int_eq( '\0', buf[0] ); ck_assert_int_eq('\0', buf[0]);
ck_assert_int_eq( 1, nread ); ck_assert_int_eq(1, nread);
} }
END_TEST END_TEST
START_TEST(test_read_eof_returns_err)
START_TEST( test_read_eof_returns_err )
{ {
int fds[2]; int fds[2];
int nread; int nread;
char buf[5] = {0}; char buf[5] = { 0 };
pipe( fds ); pipe(fds);
close( fds[1] ); close(fds[1]);
nread = read_until_newline( fds[0], buf, 5 ); nread = read_until_newline(fds[0], buf, 5);
ck_assert_int_eq( -1, nread ); ck_assert_int_eq(-1, nread);
} }
END_TEST END_TEST
START_TEST(test_read_eof_fills_line)
START_TEST( test_read_eof_fills_line )
{ {
int fds[2]; int fds[2];
int nread; int nread;
char buf[5] = {0}; char buf[5] = { 0 };
pipe(fds); pipe(fds);
write( fds[1], "1234", 4 ); write(fds[1], "1234", 4);
close( fds[1] ); close(fds[1]);
nread = read_until_newline( fds[0], buf, 5 ); nread = read_until_newline(fds[0], buf, 5);
ck_assert_int_eq( -1, nread ); ck_assert_int_eq(-1, nread);
ck_assert_int_eq( '4', buf[3] ); ck_assert_int_eq('4', buf[3]);
} }
END_TEST END_TEST
START_TEST(test_read_lines_until_blankline)
START_TEST( test_read_lines_until_blankline )
{ {
char **lines = NULL; char **lines = NULL;
int fds[2]; int fds[2];
int nlines; int nlines;
pipe( fds ); pipe(fds);
write( fds[1], "a\nb\nc\n\n", 7 ); write(fds[1], "a\nb\nc\n\n", 7);
nlines = read_lines_until_blankline( fds[0], 256, &lines ); nlines = read_lines_until_blankline(fds[0], 256, &lines);
ck_assert_int_eq( 3, nlines ); ck_assert_int_eq(3, nlines);
} }
END_TEST END_TEST
Suite * ioutil_suite(void)
Suite *ioutil_suite(void)
{ {
Suite *s = suite_create("ioutil"); Suite *s = suite_create("ioutil");
TCase *tc_read_until_newline = tcase_create("read_until_newline"); TCase *tc_read_until_newline = tcase_create("read_until_newline");
TCase *tc_read_lines_until_blankline = tcase_create("read_lines_until_blankline"); TCase *tc_read_lines_until_blankline =
tcase_create("read_lines_until_blankline");
tcase_add_test(tc_read_until_newline, test_read_until_newline_returns_line_length_plus_null); tcase_add_test(tc_read_until_newline,
tcase_add_test(tc_read_until_newline, test_read_until_newline_inserts_null); test_read_until_newline_returns_line_length_plus_null);
tcase_add_test(tc_read_until_newline, test_read_empty_line_inserts_null); tcase_add_test(tc_read_until_newline,
tcase_add_test(tc_read_until_newline, test_read_eof_returns_err); test_read_until_newline_inserts_null);
tcase_add_test(tc_read_until_newline, test_read_eof_fills_line ); tcase_add_test(tc_read_until_newline,
test_read_empty_line_inserts_null);
tcase_add_test(tc_read_until_newline, test_read_eof_returns_err);
tcase_add_test(tc_read_until_newline, test_read_eof_fills_line);
tcase_add_test(tc_read_lines_until_blankline, test_read_lines_until_blankline ); tcase_add_test(tc_read_lines_until_blankline,
test_read_lines_until_blankline);
suite_add_tcase(s, tc_read_until_newline); suite_add_tcase(s, tc_read_until_newline);
suite_add_tcase(s, tc_read_lines_until_blankline); suite_add_tcase(s, tc_read_lines_until_blankline);
return s; return s;
} }
int main(void) int main(void)
{ {
int number_failed; int number_failed;
Suite *s = ioutil_suite();
SRunner *sr = srunner_create(s);
srunner_run_all(sr, CK_NORMAL);
number_failed = srunner_ntests_failed(sr);
srunner_free(sr);
return (number_failed == 0) ? 0 : 1;
}
Suite *s = ioutil_suite();
SRunner *sr = srunner_create(s);
srunner_run_all(sr, CK_NORMAL);
number_failed = srunner_ntests_failed(sr);
srunner_free(sr);
return (number_failed == 0) ? 0 : 1;
}

117
tests/unit/check_mbox.c
View File

@@ -4,83 +4,79 @@
#include <pthread.h> #include <pthread.h>
#include <check.h> #include <check.h>
START_TEST( test_allocs_cvar ) START_TEST(test_allocs_cvar)
{ {
struct mbox * mbox = mbox_create(); struct mbox *mbox = mbox_create();
fail_if( NULL == mbox, "Nothing allocated" ); fail_if(NULL == mbox, "Nothing allocated");
pthread_cond_t cond_zero; pthread_cond_t cond_zero;
/* A freshly inited pthread_cond_t is set to {0} */ /* A freshly inited pthread_cond_t is set to {0} */
memset( &cond_zero, 'X', sizeof( cond_zero ) ); memset(&cond_zero, 'X', sizeof(cond_zero));
fail_if( memcmp( &cond_zero, &mbox->filled_cond, sizeof( cond_zero ) ) == 0 , fail_if(memcmp(&cond_zero, &mbox->filled_cond, sizeof(cond_zero)) == 0,
"Condition variable not allocated" ); "Condition variable not allocated");
fail_if( memcmp( &cond_zero, &mbox->emptied_cond, sizeof( cond_zero ) ) == 0 , fail_if(memcmp(&cond_zero, &mbox->emptied_cond, sizeof(cond_zero)) ==
"Condition variable not allocated" ); 0, "Condition variable not allocated");
} }
END_TEST END_TEST
START_TEST(test_post_stores_value)
START_TEST( test_post_stores_value )
{ {
struct mbox * mbox = mbox_create(); struct mbox *mbox = mbox_create();
void * deadbeef = (void *)0xDEADBEEF;
mbox_post( mbox, deadbeef );
fail_unless( deadbeef == mbox_contents( mbox ), void *deadbeef = (void *) 0xDEADBEEF;
"Contents were not posted" ); mbox_post(mbox, deadbeef);
fail_unless(deadbeef == mbox_contents(mbox),
"Contents were not posted");
} }
END_TEST END_TEST
void *mbox_receive_runner(void *mbox_uncast)
void * mbox_receive_runner( void * mbox_uncast )
{ {
struct mbox * mbox = (struct mbox *)mbox_uncast; struct mbox *mbox = (struct mbox *) mbox_uncast;
void * contents = NULL; void *contents = NULL;
contents = mbox_receive( mbox ); contents = mbox_receive(mbox);
return contents; return contents;
} }
START_TEST( test_receive_blocks_until_post ) START_TEST(test_receive_blocks_until_post)
{ {
struct mbox * mbox = mbox_create(); struct mbox *mbox = mbox_create();
pthread_t receiver; pthread_t receiver;
pthread_create( &receiver, NULL, mbox_receive_runner, mbox ); pthread_create(&receiver, NULL, mbox_receive_runner, mbox);
void * deadbeef = (void *)0xDEADBEEF;
void * retval =NULL;
usleep(10000);
fail_unless( EBUSY == pthread_tryjoin_np( receiver, &retval ),
"Receiver thread wasn't blocked");
mbox_post( mbox, deadbeef ); void *deadbeef = (void *) 0xDEADBEEF;
fail_unless( 0 == pthread_join( receiver, &retval ), void *retval = NULL;
"Failed to join the receiver thread" ); usleep(10000);
fail_unless( retval == deadbeef, fail_unless(EBUSY == pthread_tryjoin_np(receiver, &retval),
"Return value was wrong" ); "Receiver thread wasn't blocked");
mbox_post(mbox, deadbeef);
fail_unless(0 == pthread_join(receiver, &retval),
"Failed to join the receiver thread");
fail_unless(retval == deadbeef, "Return value was wrong");
} }
END_TEST END_TEST
Suite * mbox_suite(void)
Suite* mbox_suite(void)
{ {
Suite *s = suite_create("mbox"); Suite *s = suite_create("mbox");
TCase *tc_create = tcase_create("create"); TCase *tc_create = tcase_create("create");
TCase *tc_post = tcase_create("post"); TCase *tc_post = tcase_create("post");
tcase_add_test(tc_create, test_allocs_cvar); tcase_add_test(tc_create, test_allocs_cvar);
tcase_add_test( tc_post, test_post_stores_value ); tcase_add_test(tc_post, test_post_stores_value);
tcase_add_test( tc_post, test_receive_blocks_until_post); tcase_add_test(tc_post, test_receive_blocks_until_post);
suite_add_tcase(s, tc_create); suite_add_tcase(s, tc_create);
suite_add_tcase(s, tc_post); suite_add_tcase(s, tc_post);
return s; return s;
} }
@@ -88,17 +84,16 @@ Suite* mbox_suite(void)
int main(void) int main(void)
{ {
#ifdef DEBUG #ifdef DEBUG
log_level = 0; log_level = 0;
#else #else
log_level = 2; log_level = 2;
#endif #endif
int number_failed; int number_failed;
Suite *s = mbox_suite(); Suite *s = mbox_suite();
SRunner *sr = srunner_create(s); SRunner *sr = srunner_create(s);
srunner_run_all(sr, CK_NORMAL); srunner_run_all(sr, CK_NORMAL);
log_level = 0; log_level = 0;
number_failed = srunner_ntests_failed(sr); number_failed = srunner_ntests_failed(sr);
srunner_free(sr); srunner_free(sr);
return (number_failed == 0) ? 0 : 1; return (number_failed == 0) ? 0 : 1;
} }

326
tests/unit/check_nbdtypes.c
View File

@@ -4,257 +4,259 @@
START_TEST(test_init_passwd) START_TEST(test_init_passwd)
{ {
struct nbd_init_raw init_raw; struct nbd_init_raw init_raw;
struct nbd_init init; struct nbd_init init;
memcpy( init_raw.passwd, INIT_PASSWD, 8 ); memcpy(init_raw.passwd, INIT_PASSWD, 8);
nbd_r2h_init( &init_raw, &init ); nbd_r2h_init(&init_raw, &init);
memset( init_raw.passwd, 0, 8 ); memset(init_raw.passwd, 0, 8);
nbd_h2r_init( &init, &init_raw ); nbd_h2r_init(&init, &init_raw);
fail_unless( memcmp( init.passwd, INIT_PASSWD, 8 ) == 0, "The password was not copied." ); fail_unless(memcmp(init.passwd, INIT_PASSWD, 8) == 0,
fail_unless( memcmp( init_raw.passwd, INIT_PASSWD, 8 ) == 0, "The password was not copied back." ); "The password was not copied.");
fail_unless(memcmp(init_raw.passwd, INIT_PASSWD, 8) == 0,
"The password was not copied back.");
} }
END_TEST END_TEST
START_TEST(test_init_magic) START_TEST(test_init_magic)
{ {
struct nbd_init_raw init_raw; struct nbd_init_raw init_raw;
struct nbd_init init; struct nbd_init init;
init_raw.magic = 12345; init_raw.magic = 12345;
nbd_r2h_init( &init_raw, &init ); nbd_r2h_init(&init_raw, &init);
fail_unless( be64toh( 12345 ) == init.magic, "Magic was not converted." ); fail_unless(be64toh(12345) == init.magic, "Magic was not converted.");
init.magic = 67890; init.magic = 67890;
nbd_h2r_init( &init, &init_raw ); nbd_h2r_init(&init, &init_raw);
fail_unless( htobe64( 67890 ) == init_raw.magic, "Magic was not converted back." ); fail_unless(htobe64(67890) == init_raw.magic,
"Magic was not converted back.");
} }
END_TEST END_TEST
START_TEST(test_init_size) START_TEST(test_init_size)
{ {
struct nbd_init_raw init_raw; struct nbd_init_raw init_raw;
struct nbd_init init; struct nbd_init init;
init_raw.size = 12345; init_raw.size = 12345;
nbd_r2h_init( &init_raw, &init ); nbd_r2h_init(&init_raw, &init);
fail_unless( be64toh( 12345 ) == init.size, "Size was not converted." ); fail_unless(be64toh(12345) == init.size, "Size was not converted.");
init.size = 67890; init.size = 67890;
nbd_h2r_init( &init, &init_raw ); nbd_h2r_init(&init, &init_raw);
fail_unless( htobe64( 67890 ) == init_raw.size, "Size was not converted back." ); fail_unless(htobe64(67890) == init_raw.size,
"Size was not converted back.");
} }
END_TEST END_TEST
START_TEST(test_request_magic)
START_TEST(test_request_magic )
{ {
struct nbd_request_raw request_raw; struct nbd_request_raw request_raw;
struct nbd_request request; struct nbd_request request;
request_raw.magic = 12345; request_raw.magic = 12345;
nbd_r2h_request( &request_raw, &request ); nbd_r2h_request(&request_raw, &request);
fail_unless( be32toh( 12345 ) == request.magic, "Magic was not converted." ); fail_unless(be32toh(12345) == request.magic,
"Magic was not converted.");
request.magic = 67890; request.magic = 67890;
nbd_h2r_request( &request, &request_raw ); nbd_h2r_request(&request, &request_raw);
fail_unless( htobe32( 67890 ) == request_raw.magic, "Magic was not converted back." ); fail_unless(htobe32(67890) == request_raw.magic,
"Magic was not converted back.");
} }
END_TEST END_TEST
START_TEST(test_request_type) START_TEST(test_request_type)
{ {
struct nbd_request_raw request_raw; struct nbd_request_raw request_raw;
struct nbd_request request; struct nbd_request request;
request_raw.type = 123; request_raw.type = 123;
nbd_r2h_request( &request_raw, &request ); nbd_r2h_request(&request_raw, &request);
fail_unless( be16toh( 123 ) == request.type, "Type was not converted." ); fail_unless(be16toh(123) == request.type, "Type was not converted.");
request.type = 234; request.type = 234;
nbd_h2r_request( &request, &request_raw ); nbd_h2r_request(&request, &request_raw);
fail_unless( htobe16( 234 ) == request_raw.type, "Type was not converted back." ); fail_unless(htobe16(234) == request_raw.type,
"Type was not converted back.");
} }
END_TEST END_TEST
START_TEST(test_request_flags) START_TEST(test_request_flags)
{ {
struct nbd_request_raw request_raw; struct nbd_request_raw request_raw;
struct nbd_request request; struct nbd_request request;
request_raw.flags = 123; request_raw.flags = 123;
nbd_r2h_request( &request_raw, &request ); nbd_r2h_request(&request_raw, &request);
fail_unless( be16toh( 123 ) == request.flags, "Flags were not converted." ); fail_unless(be16toh(123) == request.flags,
"Flags were not converted.");
request.flags = 234; request.flags = 234;
nbd_h2r_request( &request, &request_raw ); nbd_h2r_request(&request, &request_raw);
fail_unless( htobe16( 234 ) == request_raw.flags, "Flags were not converted back." ); fail_unless(htobe16(234) == request_raw.flags,
"Flags were not converted back.");
} }
END_TEST END_TEST
START_TEST(test_request_handle) START_TEST(test_request_handle)
{ {
struct nbd_request_raw request_raw; struct nbd_request_raw request_raw;
struct nbd_request request; struct nbd_request request;
memcpy( request_raw.handle.b, "MYHANDLE", 8 ); memcpy(request_raw.handle.b, "MYHANDLE", 8);
nbd_r2h_request( &request_raw, &request ); nbd_r2h_request(&request_raw, &request);
request_raw.handle.w = 0; request_raw.handle.w = 0;
nbd_h2r_request( &request, &request_raw ); nbd_h2r_request(&request, &request_raw);
fail_unless( memcmp( request.handle.b, "MYHANDLE", 8 ) == 0, "The handle was not copied." ); fail_unless(memcmp(request.handle.b, "MYHANDLE", 8) == 0,
fail_unless( memcmp( request_raw.handle.b, "MYHANDLE", 8 ) == 0, "The handle was not copied back." ); "The handle was not copied.");
fail_unless(memcmp(request_raw.handle.b, "MYHANDLE", 8) == 0,
"The handle was not copied back.");
} }
END_TEST END_TEST
START_TEST(test_request_from)
START_TEST(test_request_from )
{ {
struct nbd_request_raw request_raw; struct nbd_request_raw request_raw;
struct nbd_request request; struct nbd_request request;
request_raw.from = 12345; request_raw.from = 12345;
nbd_r2h_request( &request_raw, &request ); nbd_r2h_request(&request_raw, &request);
fail_unless( be64toh( 12345 ) == request.from, "From was not converted." ); fail_unless(be64toh(12345) == request.from, "From was not converted.");
request.from = 67890; request.from = 67890;
nbd_h2r_request( &request, &request_raw ); nbd_h2r_request(&request, &request_raw);
fail_unless( htobe64( 67890 ) == request_raw.from, "From was not converted back." ); fail_unless(htobe64(67890) == request_raw.from,
"From was not converted back.");
} }
END_TEST END_TEST
START_TEST(test_request_len)
START_TEST(test_request_len )
{ {
struct nbd_request_raw request_raw; struct nbd_request_raw request_raw;
struct nbd_request request; struct nbd_request request;
request_raw.len = 12345; request_raw.len = 12345;
nbd_r2h_request( &request_raw, &request ); nbd_r2h_request(&request_raw, &request);
fail_unless( be32toh( 12345 ) == request.len, "Type was not converted." ); fail_unless(be32toh(12345) == request.len, "Type was not converted.");
request.len = 67890; request.len = 67890;
nbd_h2r_request( &request, &request_raw ); nbd_h2r_request(&request, &request_raw);
fail_unless( htobe32( 67890 ) == request_raw.len, "Type was not converted back." ); fail_unless(htobe32(67890) == request_raw.len,
"Type was not converted back.");
} }
END_TEST END_TEST
START_TEST(test_reply_magic)
START_TEST(test_reply_magic )
{ {
struct nbd_reply_raw reply_raw; struct nbd_reply_raw reply_raw;
struct nbd_reply reply; struct nbd_reply reply;
reply_raw.magic = 12345; reply_raw.magic = 12345;
nbd_r2h_reply( &reply_raw, &reply ); nbd_r2h_reply(&reply_raw, &reply);
fail_unless( be32toh( 12345 ) == reply.magic, "Magic was not converted." ); fail_unless(be32toh(12345) == reply.magic, "Magic was not converted.");
reply.magic = 67890; reply.magic = 67890;
nbd_h2r_reply( &reply, &reply_raw ); nbd_h2r_reply(&reply, &reply_raw);
fail_unless( htobe32( 67890 ) == reply_raw.magic, "Magic was not converted back." ); fail_unless(htobe32(67890) == reply_raw.magic,
"Magic was not converted back.");
} }
END_TEST END_TEST
START_TEST(test_reply_error)
START_TEST(test_reply_error )
{ {
struct nbd_reply_raw reply_raw; struct nbd_reply_raw reply_raw;
struct nbd_reply reply; struct nbd_reply reply;
reply_raw.error = 12345; reply_raw.error = 12345;
nbd_r2h_reply( &reply_raw, &reply ); nbd_r2h_reply(&reply_raw, &reply);
fail_unless( be32toh( 12345 ) == reply.error, "Error was not converted." ); fail_unless(be32toh(12345) == reply.error, "Error was not converted.");
reply.error = 67890; reply.error = 67890;
nbd_h2r_reply( &reply, &reply_raw ); nbd_h2r_reply(&reply, &reply_raw);
fail_unless( htobe32( 67890 ) == reply_raw.error, "Error was not converted back." ); fail_unless(htobe32(67890) == reply_raw.error,
"Error was not converted back.");
} }
END_TEST END_TEST
START_TEST(test_reply_handle) START_TEST(test_reply_handle)
{ {
struct nbd_reply_raw reply_raw; struct nbd_reply_raw reply_raw;
struct nbd_reply reply; struct nbd_reply reply;
memcpy( reply_raw.handle.b, "MYHANDLE", 8 ); memcpy(reply_raw.handle.b, "MYHANDLE", 8);
nbd_r2h_reply( &reply_raw, &reply ); nbd_r2h_reply(&reply_raw, &reply);
reply_raw.handle.w = 0; reply_raw.handle.w = 0;
nbd_h2r_reply( &reply, &reply_raw ); nbd_h2r_reply(&reply, &reply_raw);
fail_unless( memcmp( reply.handle.b, "MYHANDLE", 8 ) == 0, "The handle was not copied." ); fail_unless(memcmp(reply.handle.b, "MYHANDLE", 8) == 0,
fail_unless( memcmp( reply_raw.handle.b, "MYHANDLE", 8 ) == 0, "The handle was not copied back." ); "The handle was not copied.");
fail_unless(memcmp(reply_raw.handle.b, "MYHANDLE", 8) == 0,
"The handle was not copied back.");
} }
END_TEST END_TEST
START_TEST(test_convert_from)
START_TEST( test_convert_from )
{ {
/* Check that we can correctly pull numbers out of an /* Check that we can correctly pull numbers out of an
* nbd_request_raw */ * nbd_request_raw */
struct nbd_request_raw request_raw; struct nbd_request_raw request_raw;
struct nbd_request request; struct nbd_request request;
uint64_t target = 0x8000000000000000; uint64_t target = 0x8000000000000000;
/* this is stored big-endian */ /* this is stored big-endian */
request_raw.from = htobe64(target); request_raw.from = htobe64(target);
/* We expect this to convert big-endian to the host format */ /* We expect this to convert big-endian to the host format */
nbd_r2h_request( &request_raw, &request ); nbd_r2h_request(&request_raw, &request);
fail_unless( target == request.from, "from was wrong" ); fail_unless(target == request.from, "from was wrong");
} }
END_TEST END_TEST
Suite *nbdtypes_suite(void) Suite * nbdtypes_suite(void)
{ {
Suite *s = suite_create( "nbdtypes" ); Suite *s = suite_create("nbdtypes");
TCase *tc_init = tcase_create( "nbd_init" ); TCase *tc_init = tcase_create("nbd_init");
TCase *tc_request = tcase_create( "nbd_request" ); TCase *tc_request = tcase_create("nbd_request");
TCase *tc_reply = tcase_create( "nbd_reply" ); TCase *tc_reply = tcase_create("nbd_reply");
tcase_add_test( tc_init, test_init_passwd ); tcase_add_test(tc_init, test_init_passwd);
tcase_add_test( tc_init, test_init_magic ); tcase_add_test(tc_init, test_init_magic);
tcase_add_test( tc_init, test_init_size ); tcase_add_test(tc_init, test_init_size);
tcase_add_test( tc_request, test_request_magic ); tcase_add_test(tc_request, test_request_magic);
tcase_add_test( tc_request, test_request_type ); tcase_add_test(tc_request, test_request_type);
tcase_add_test( tc_request, test_request_handle ); tcase_add_test(tc_request, test_request_handle);
tcase_add_test( tc_request, test_request_from ); tcase_add_test(tc_request, test_request_from);
tcase_add_test( tc_request, test_request_len ); tcase_add_test(tc_request, test_request_len);
tcase_add_test( tc_request, test_convert_from ); tcase_add_test(tc_request, test_convert_from);
tcase_add_test( tc_reply, test_reply_magic ); tcase_add_test(tc_reply, test_reply_magic);
tcase_add_test( tc_reply, test_reply_error ); tcase_add_test(tc_reply, test_reply_error);
tcase_add_test( tc_reply, test_reply_handle ); tcase_add_test(tc_reply, test_reply_handle);
suite_add_tcase( s, tc_init ); suite_add_tcase(s, tc_init);
suite_add_tcase( s, tc_request ); suite_add_tcase(s, tc_request);
suite_add_tcase( s, tc_reply ); suite_add_tcase(s, tc_reply);
return s; return s;
} }
int main(void) int main(void)
{ {
int number_failed; int number_failed;
Suite *s = nbdtypes_suite(); Suite *s = nbdtypes_suite();
SRunner *sr = srunner_create(s); SRunner *sr = srunner_create(s);
srunner_run_all(sr, CK_NORMAL); srunner_run_all(sr, CK_NORMAL);
number_failed = srunner_ntests_failed(sr); number_failed = srunner_ntests_failed(sr);
srunner_free(sr); srunner_free(sr);
return (number_failed == 0) ? 0 : 1; return (number_failed == 0) ? 0 : 1;
} }

45
tests/unit/check_parse.c
View File

@@ -3,45 +3,42 @@
#include <check.h> #include <check.h>
START_TEST( test_can_parse_ip_address_twice ) START_TEST(test_can_parse_ip_address_twice)
{ {
char ip_address[] = "127.0.0.1"; char ip_address[] = "127.0.0.1";
struct sockaddr saddr; struct sockaddr saddr;
parse_ip_to_sockaddr( &saddr, ip_address ); parse_ip_to_sockaddr(&saddr, ip_address);
parse_ip_to_sockaddr( &saddr, ip_address ); parse_ip_to_sockaddr(&saddr, ip_address);
} }
END_TEST END_TEST
Suite * parse_suite(void)
Suite* parse_suite(void)
{ {
Suite *s = suite_create("parse"); Suite *s = suite_create("parse");
TCase *tc_create = tcase_create("ip_to_sockaddr"); TCase *tc_create = tcase_create("ip_to_sockaddr");
tcase_add_test(tc_create, test_can_parse_ip_address_twice); tcase_add_test(tc_create, test_can_parse_ip_address_twice);
suite_add_tcase(s, tc_create); suite_add_tcase(s, tc_create);
return s; return s;
} }
#ifdef DEBUG #ifdef DEBUG
# define LOG_LEVEL 0 #define LOG_LEVEL 0
#else #else
# define LOG_LEVEL 2 #define LOG_LEVEL 2
#endif #endif
int main(void) int main(void)
{ {
log_level = LOG_LEVEL; log_level = LOG_LEVEL;
int number_failed; int number_failed;
Suite *s = parse_suite(); Suite *s = parse_suite();
SRunner *sr = srunner_create(s); SRunner *sr = srunner_create(s);
srunner_run_all(sr, CK_NORMAL); srunner_run_all(sr, CK_NORMAL);
number_failed = srunner_ntests_failed(sr); number_failed = srunner_ntests_failed(sr);
srunner_free(sr); srunner_free(sr);
return (number_failed == 0) ? 0 : 1; return (number_failed == 0) ? 0 : 1;
} }

213
tests/unit/check_readwrite.c
View File

@@ -21,173 +21,172 @@
int fd_read_request( int, struct nbd_request_raw *); int fd_read_request(int, struct nbd_request_raw *);
int fd_write_reply( int, uint64_t, int ); int fd_write_reply(int, uint64_t, int);
int marker; int marker;
void error_marker(void * unused __attribute__((unused)), void error_marker(void *unused __attribute__ ((unused)),
int fatal __attribute__((unused))) int fatal __attribute__ ((unused)))
{ {
marker = 1; marker = 1;
return; return;
} }
struct respond { struct respond {
int sock_fds[2]; // server end int sock_fds[2]; // server end
int do_fail; int do_fail;
pthread_t thread_id; pthread_t thread_id;
pthread_attr_t thread_attr; pthread_attr_t thread_attr;
struct nbd_request received; struct nbd_request received;
}; };
void * responder( void *respond_uncast ) void *responder(void *respond_uncast)
{ {
struct respond * resp = (struct respond *) respond_uncast; struct respond *resp = (struct respond *) respond_uncast;
int sock_fd = resp->sock_fds[1]; int sock_fd = resp->sock_fds[1];
struct nbd_request_raw request_raw; struct nbd_request_raw request_raw;
uint64_t wrong_handle = 0x80; uint64_t wrong_handle = 0x80;
if( fd_read_request( sock_fd, &request_raw ) == -1){ if (fd_read_request(sock_fd, &request_raw) == -1) {
fprintf(stderr, "Problem with fd_read_request\n"); fprintf(stderr, "Problem with fd_read_request\n");
} else {
nbd_r2h_request(&request_raw, &resp->received);
if (resp->do_fail) {
fd_write_reply(sock_fd, wrong_handle, 0);
} else { } else {
nbd_r2h_request( &request_raw, &resp->received); fd_write_reply(sock_fd, resp->received.handle.w, 0);
if (resp->do_fail){
fd_write_reply( sock_fd, wrong_handle, 0 );
}
else {
fd_write_reply( sock_fd, resp->received.handle.w, 0 );
}
write( sock_fd, "12345678", 8 );
} }
return NULL; write(sock_fd, "12345678", 8);
}
return NULL;
} }
struct respond * respond_create( int do_fail ) struct respond *respond_create(int do_fail)
{ {
struct respond * respond = (struct respond *)calloc( 1, sizeof( struct respond ) ); struct respond *respond =
socketpair( PF_UNIX, SOCK_STREAM, 0, respond->sock_fds ); (struct respond *) calloc(1, sizeof(struct respond));
respond->do_fail = do_fail; socketpair(PF_UNIX, SOCK_STREAM, 0, respond->sock_fds);
respond->do_fail = do_fail;
pthread_attr_init( &respond->thread_attr ); pthread_attr_init(&respond->thread_attr);
pthread_create( &respond->thread_id, &respond->thread_attr, responder, respond ); pthread_create(&respond->thread_id, &respond->thread_attr, responder,
respond);
return respond; return respond;
} }
void respond_destroy( struct respond * respond ){ void respond_destroy(struct respond *respond)
NULLCHECK( respond );
pthread_join( respond->thread_id, NULL );
pthread_attr_destroy( &respond->thread_attr );
close( respond->sock_fds[0] );
close( respond->sock_fds[1] );
free( respond );
}
void * reader( void * nothing __attribute__((unused)))
{ {
DECLARE_ERROR_CONTEXT( error_context ); NULLCHECK(respond);
error_set_handler( (cleanup_handler *)error_marker, error_context );
struct respond * respond = respond_create( 1 ); pthread_join(respond->thread_id, NULL);
int devnull = open("/dev/null", O_WRONLY); pthread_attr_destroy(&respond->thread_attr);
char outbuf[8] = {0};
socket_nbd_read( respond->sock_fds[0], 0, 8, devnull, outbuf, 1 ); close(respond->sock_fds[0]);
close(respond->sock_fds[1]);
return NULL; free(respond);
} }
START_TEST( test_rejects_mismatched_handle )
void *reader(void *nothing __attribute__ ((unused)))
{
DECLARE_ERROR_CONTEXT(error_context);
error_set_handler((cleanup_handler *) error_marker, error_context);
struct respond *respond = respond_create(1);
int devnull = open("/dev/null", O_WRONLY);
char outbuf[8] = { 0 };
socket_nbd_read(respond->sock_fds[0], 0, 8, devnull, outbuf, 1);
return NULL;
}
START_TEST(test_rejects_mismatched_handle)
{ {
error_init(); error_init();
pthread_t reader_thread; pthread_t reader_thread;
log_level=5; log_level = 5;
marker = 0;
pthread_create( &reader_thread, NULL, reader, NULL );
FATAL_UNLESS( 0 == pthread_join( reader_thread, NULL ),
"pthread_join failed");
log_level=2;
fail_unless( marker == 1, "Error handler wasn't called" ); marker = 0;
pthread_create(&reader_thread, NULL, reader, NULL);
FATAL_UNLESS(0 == pthread_join(reader_thread, NULL),
"pthread_join failed");
log_level = 2;
fail_unless(marker == 1, "Error handler wasn't called");
} }
END_TEST END_TEST
START_TEST(test_accepts_matched_handle)
START_TEST( test_accepts_matched_handle )
{ {
struct respond * respond = respond_create( 0 ); struct respond *respond = respond_create(0);
int devnull = open("/dev/null", O_WRONLY); int devnull = open("/dev/null", O_WRONLY);
char outbuf[8] = {0}; char outbuf[8] = { 0 };
socket_nbd_read( respond->sock_fds[0], 0, 8, devnull, outbuf, 1 ); socket_nbd_read(respond->sock_fds[0], 0, 8, devnull, outbuf, 1);
respond_destroy( respond ); respond_destroy(respond);
} }
END_TEST END_TEST
START_TEST(test_disconnect_doesnt_read_reply)
START_TEST( test_disconnect_doesnt_read_reply )
{ {
struct respond * respond = respond_create( 1 ); struct respond *respond = respond_create(1);
socket_nbd_disconnect( respond->sock_fds[0] ); socket_nbd_disconnect(respond->sock_fds[0]);
respond_destroy( respond ); respond_destroy(respond);
} }
END_TEST END_TEST
Suite * readwrite_suite(void)
Suite* readwrite_suite(void)
{ {
Suite *s = suite_create("readwrite"); Suite *s = suite_create("readwrite");
TCase *tc_transfer = tcase_create("entrust"); TCase *tc_transfer = tcase_create("entrust");
TCase *tc_disconnect = tcase_create("disconnect"); TCase *tc_disconnect = tcase_create("disconnect");
tcase_add_test(tc_transfer, test_rejects_mismatched_handle); tcase_add_test(tc_transfer, test_rejects_mismatched_handle);
tcase_add_exit_test(tc_transfer, test_accepts_matched_handle, 0); tcase_add_exit_test(tc_transfer, test_accepts_matched_handle, 0);
/* This test is a little funny. We respond with a dodgy handle /* This test is a little funny. We respond with a dodgy handle
* and check that this *doesn't* cause a message rejection, * and check that this *doesn't* cause a message rejection,
* because we want to know that the sender won't even try to * because we want to know that the sender won't even try to
* read the response. * read the response.
*/ */
tcase_add_exit_test( tc_disconnect, test_disconnect_doesnt_read_reply,0 ); tcase_add_exit_test(tc_disconnect, test_disconnect_doesnt_read_reply,
0);
suite_add_tcase(s, tc_transfer); suite_add_tcase(s, tc_transfer);
suite_add_tcase(s, tc_disconnect); suite_add_tcase(s, tc_disconnect);
return s; return s;
} }
#ifdef DEBUG #ifdef DEBUG
# define LOG_LEVEL 0 #define LOG_LEVEL 0
#else #else
# define LOG_LEVEL 2 #define LOG_LEVEL 2
#endif #endif
int main(void) int main(void)
{ {
log_level = LOG_LEVEL; log_level = LOG_LEVEL;
int number_failed; int number_failed;
Suite *s = readwrite_suite(); Suite *s = readwrite_suite();
SRunner *sr = srunner_create(s); SRunner *sr = srunner_create(s);
srunner_run_all(sr, CK_NORMAL); srunner_run_all(sr, CK_NORMAL);
log_level = 0; log_level = 0;
number_failed = srunner_ntests_failed(sr); number_failed = srunner_ntests_failed(sr);
srunner_free(sr); srunner_free(sr);
return (number_failed == 0) ? 0 : 1; return (number_failed == 0) ? 0 : 1;
} }

295
tests/unit/check_self_pipe.c
View File

@@ -9,190 +9,185 @@
#include "self_pipe.h" #include "self_pipe.h"
START_TEST( test_opens_pipe ) START_TEST(test_opens_pipe)
{ {
struct self_pipe* sig; struct self_pipe *sig;
char buf[] = " "; char buf[] = " ";
sig = self_pipe_create(); sig = self_pipe_create();
write( sig->write_fd, "1", 1 ); write(sig->write_fd, "1", 1);
read( sig->read_fd, buf, 1 ); read(sig->read_fd, buf, 1);
fail_unless( buf[0] == '1', "Pipe does not seem to be open;" ); fail_unless(buf[0] == '1', "Pipe does not seem to be open;");
self_pipe_destroy( sig ); self_pipe_destroy(sig);
} }
END_TEST END_TEST
void *signal_thread(void *thing)
void * signal_thread( void * thing )
{ {
struct self_pipe *sig = (struct self_pipe *)thing; struct self_pipe *sig = (struct self_pipe *) thing;
usleep( 100000 ); usleep(100000);
self_pipe_signal( sig ); self_pipe_signal(sig);
return NULL; return NULL;
} }
pthread_t start_signal_thread( struct self_pipe *sig ) pthread_t start_signal_thread(struct self_pipe * sig)
{ {
pthread_attr_t attr; pthread_attr_t attr;
pthread_t thread_id; pthread_t thread_id;
pthread_attr_init( &attr ); pthread_attr_init(&attr);
pthread_create( &thread_id, &attr, signal_thread, sig ); pthread_create(&thread_id, &attr, signal_thread, sig);
pthread_attr_destroy( &attr ); pthread_attr_destroy(&attr);
return thread_id; return thread_id;
} }
START_TEST( test_signals ) START_TEST(test_signals)
{ {
struct self_pipe* sig; struct self_pipe *sig;
fd_set fds; fd_set fds;
pthread_t signal_thread_id; pthread_t signal_thread_id;
sig = self_pipe_create(); sig = self_pipe_create();
FD_ZERO( &fds ); FD_ZERO(&fds);
self_pipe_fd_set( sig, &fds ); self_pipe_fd_set(sig, &fds);
signal_thread_id = start_signal_thread( sig ); signal_thread_id = start_signal_thread(sig);
if ( select( FD_SETSIZE, &fds, NULL, NULL, NULL ) == -1 ) { if (select(FD_SETSIZE, &fds, NULL, NULL, NULL) == -1) {
fail( strerror(errno) ); fail(strerror(errno));
}
self_pipe_signal_clear(sig);
fail_unless(self_pipe_fd_isset(sig, &fds),
"Signalled pipe was not FD_ISSET.");
pthread_join(signal_thread_id, NULL);
self_pipe_destroy(sig);
}
END_TEST
START_TEST(test_clear_returns_immediately)
{
struct self_pipe *sig;
sig = self_pipe_create();
fail_unless(0 == self_pipe_signal_clear(sig), "Wrong clear result.");
}
END_TEST
START_TEST(test_destroy_closes_read_pipe)
{
struct self_pipe *sig;
ssize_t read_len;
int orig_read_fd;
sig = self_pipe_create();
orig_read_fd = sig->read_fd;
self_pipe_destroy(sig);
while ((read_len = read(orig_read_fd, "", 0)) == -1 && errno == EINTR);
switch (read_len) {
case 0:
fail("The read fd wasn't closed.");
break;
case -1:
switch (errno) {
case EBADF:
/* This is what we want */
break;
case EAGAIN:
fail("The read fd wasn't closed.");
break;
default:
fail(strerror(errno));
break;
} }
self_pipe_signal_clear( sig ); break;
default:
fail_unless( self_pipe_fd_isset( sig, &fds ), "Signalled pipe was not FD_ISSET." ); fail("The read fd wasn't closed, and had data in it.");
pthread_join( signal_thread_id, NULL ); break;
}
self_pipe_destroy( sig );
} }
END_TEST END_TEST
START_TEST(test_destroy_closes_write_pipe)
START_TEST( test_clear_returns_immediately )
{ {
struct self_pipe *sig; struct self_pipe *sig;
sig = self_pipe_create(); ssize_t write_len;
fail_unless( 0 == self_pipe_signal_clear( sig ), "Wrong clear result." ); int orig_write_fd;
}
END_TEST
sig = self_pipe_create();
orig_write_fd = sig->write_fd;
self_pipe_destroy(sig);
START_TEST( test_destroy_closes_read_pipe ) while ((write_len = write(orig_write_fd, "", 0)) == -1
{ && errno == EINTR);
struct self_pipe* sig;
ssize_t read_len;
int orig_read_fd;
sig = self_pipe_create(); switch (write_len) {
orig_read_fd = sig->read_fd; case 0:
self_pipe_destroy( sig ); fail("The write fd wasn't closed.");
break;
while( (read_len = read( orig_read_fd, "", 0 )) == -1 && errno == EINTR ); case -1:
switch (errno) {
switch( read_len ) { case EPIPE:
case 0: case EBADF:
fail("The read fd wasn't closed." ); /* This is what we want */
break; break;
case -1: case EAGAIN:
switch(errno) { fail("The write fd wasn't closed.");
case EBADF: break;
/* This is what we want */ default:
break; fail(strerror(errno));
case EAGAIN: break;
fail( "The read fd wasn't closed." );
break;
default:
fail( strerror( errno ) );
break;
}
break;
default:
fail( "The read fd wasn't closed, and had data in it." );
break;
} }
} break;
END_TEST default:
/* To get here, the write(_,_,0) would have to
* write some bytes.
START_TEST( test_destroy_closes_write_pipe )
{
struct self_pipe * sig;
ssize_t write_len;
int orig_write_fd;
sig = self_pipe_create();
orig_write_fd = sig->write_fd;
self_pipe_destroy( sig );
while ( ( write_len = write( orig_write_fd, "", 0 ) ) == -1 && errno == EINTR );
switch( write_len ) {
case 0:
fail( "The write fd wasn't closed." );
break;
case -1:
switch( errno ) {
case EPIPE:
case EBADF:
/* This is what we want */
break;
case EAGAIN:
fail("The write fd wasn't closed." );
break;
default:
fail( strerror( errno ) );
break;
}
break;
default:
/* To get here, the write(_,_,0) would have to
* write some bytes.
*/
fail( "The write fd wasn't closed, and something REALLY WEIRD is going on." );
break;
}
}
END_TEST
Suite *self_pipe_suite(void)
{
Suite *s = suite_create("self_pipe");
TCase *tc_create = tcase_create("create");
TCase *tc_signal = tcase_create("signal");
TCase *tc_destroy = tcase_create("destroy");
tcase_add_test(tc_create, test_opens_pipe);
tcase_add_test(tc_signal, test_signals );
tcase_add_test(tc_signal, test_clear_returns_immediately );
tcase_add_test(tc_destroy, test_destroy_closes_read_pipe );
tcase_add_test(tc_destroy, test_destroy_closes_write_pipe );
/* We don't test that destroy free()'s the self_pipe pointer because
* that'll be caught by valgrind.
*/ */
fail("The write fd wasn't closed, and something REALLY WEIRD is going on.");
break;
}
suite_add_tcase(s, tc_create); }
suite_add_tcase(s, tc_signal); END_TEST
suite_add_tcase(s, tc_destroy);
return s; Suite * self_pipe_suite(void)
{
Suite *s = suite_create("self_pipe");
TCase *tc_create = tcase_create("create");
TCase *tc_signal = tcase_create("signal");
TCase *tc_destroy = tcase_create("destroy");
tcase_add_test(tc_create, test_opens_pipe);
tcase_add_test(tc_signal, test_signals);
tcase_add_test(tc_signal, test_clear_returns_immediately);
tcase_add_test(tc_destroy, test_destroy_closes_read_pipe);
tcase_add_test(tc_destroy, test_destroy_closes_write_pipe);
/* We don't test that destroy free()'s the self_pipe pointer because
* that'll be caught by valgrind.
*/
suite_add_tcase(s, tc_create);
suite_add_tcase(s, tc_signal);
suite_add_tcase(s, tc_destroy);
return s;
} }
int main(void) int main(void)
{ {
int number_failed; int number_failed;
Suite *s = self_pipe_suite();
SRunner *sr = srunner_create(s);
srunner_run_all(sr, CK_NORMAL);
number_failed = srunner_ntests_failed(sr);
srunner_free(sr);
return (number_failed == 0) ? 0 : 1;
}
Suite *s = self_pipe_suite();
SRunner *sr = srunner_create(s);
srunner_run_all(sr, CK_NORMAL);
number_failed = srunner_ntests_failed(sr);
srunner_free(sr);
return (number_failed == 0) ? 0 : 1;
}

330
tests/unit/check_serve.c
View File

@@ -15,9 +15,9 @@
#include <fcntl.h> #include <fcntl.h>
#ifdef DEBUG #ifdef DEBUG
# define LOG_LEVEL 0 #define LOG_LEVEL 0
#else #else
# define LOG_LEVEL 2 #define LOG_LEVEL 2
#endif #endif
@@ -28,237 +28,249 @@
#define myfail_if( tst, msg ) do { if( tst ) { myfail( msg ); } } while (0) #define myfail_if( tst, msg ) do { if( tst ) { myfail( msg ); } } while (0)
#define myfail_unless( tst, msg ) myfail_if( !(tst), msg ) #define myfail_unless( tst, msg ) myfail_if( !(tst), msg )
char * dummy_file; char *dummy_file;
char *make_tmpfile(void) char *make_tmpfile(void)
{ {
FILE *fp; FILE *fp;
char *fn_buf; char *fn_buf;
char leader[] = "/tmp/check_serve"; char leader[] = "/tmp/check_serve";
fn_buf = (char *)malloc( 1024 ); fn_buf = (char *) malloc(1024);
strncpy( fn_buf, leader, sizeof( leader ) - 1); strncpy(fn_buf, leader, sizeof(leader) - 1);
snprintf( &fn_buf[sizeof( leader ) - 1], 10, "%d", getpid() ); snprintf(&fn_buf[sizeof(leader) - 1], 10, "%d", getpid());
fp = fopen( fn_buf, "w" ); fp = fopen(fn_buf, "w");
fwrite( fn_buf, 1024, 1, fp ); fwrite(fn_buf, 1024, 1, fp);
fclose( fp ); fclose(fp);
return fn_buf; return fn_buf;
} }
void setup( void ) void setup(void)
{ {
dummy_file = make_tmpfile(); dummy_file = make_tmpfile();
} }
void teardown( void ) void teardown(void)
{ {
if( dummy_file ){ unlink( dummy_file ); } if (dummy_file) {
free( dummy_file ); unlink(dummy_file);
dummy_file = NULL; }
free(dummy_file);
dummy_file = NULL;
} }
START_TEST( test_replaces_acl ) START_TEST(test_replaces_acl)
{ {
struct flexnbd flexnbd; struct flexnbd flexnbd;
flexnbd.signal_fd = -1; flexnbd.signal_fd = -1;
struct server * s = server_create( &flexnbd, "127.0.0.1", "0", dummy_file, 0, 0, NULL, 1, 0, 1 ); struct server *s =
struct acl * new_acl = acl_create( 0, NULL, 0 ); server_create(&flexnbd, "127.0.0.1", "0", dummy_file, 0, 0, NULL,
1, 0, 1);
struct acl *new_acl = acl_create(0, NULL, 0);
server_replace_acl( s, new_acl ); server_replace_acl(s, new_acl);
myfail_unless( s->acl == new_acl, "ACL wasn't replaced." ); myfail_unless(s->acl == new_acl, "ACL wasn't replaced.");
server_destroy( s ); server_destroy(s);
} }
END_TEST END_TEST
START_TEST(test_signals_acl_updated)
START_TEST( test_signals_acl_updated )
{ {
struct flexnbd flexnbd; struct flexnbd flexnbd;
flexnbd.signal_fd = -1; flexnbd.signal_fd = -1;
struct server * s = server_create( &flexnbd, "127.0.0.1", "0", dummy_file, 0, 0, NULL, 1, 0, 1 ); struct server *s =
struct acl * new_acl = acl_create( 0, NULL, 0 ); server_create(&flexnbd, "127.0.0.1", "0", dummy_file, 0, 0, NULL,
1, 0, 1);
struct acl *new_acl = acl_create(0, NULL, 0);
server_replace_acl( s, new_acl ); server_replace_acl(s, new_acl);
myfail_unless( 1 == self_pipe_signal_clear( s->acl_updated_signal ), myfail_unless(1 == self_pipe_signal_clear(s->acl_updated_signal),
"No signal sent." ); "No signal sent.");
server_destroy( s ); server_destroy(s);
} }
END_TEST END_TEST
int connect_client(char *addr, int actual_port, char *source_addr)
int connect_client( char *addr, int actual_port, char *source_addr )
{ {
int client_fd = -1; int client_fd = -1;
struct addrinfo hint; struct addrinfo hint;
struct addrinfo *ailist, *aip; struct addrinfo *ailist, *aip;
memset( &hint, '\0', sizeof( struct addrinfo ) ); memset(&hint, '\0', sizeof(struct addrinfo));
hint.ai_socktype = SOCK_STREAM; hint.ai_socktype = SOCK_STREAM;
myfail_if( getaddrinfo( addr, NULL, &hint, &ailist ) != 0, "getaddrinfo failed." ); myfail_if(getaddrinfo(addr, NULL, &hint, &ailist) != 0,
"getaddrinfo failed.");
int connected = 0; int connected = 0;
for( aip = ailist; aip; aip = aip->ai_next ) { for (aip = ailist; aip; aip = aip->ai_next) {
((struct sockaddr_in *)aip->ai_addr)->sin_port = htons( actual_port ); ((struct sockaddr_in *) aip->ai_addr)->sin_port =
client_fd = socket( aip->ai_family, aip->ai_socktype, aip->ai_protocol ); htons(actual_port);
client_fd =
socket(aip->ai_family, aip->ai_socktype, aip->ai_protocol);
if (source_addr) { if (source_addr) {
struct sockaddr src; struct sockaddr src;
if( !parse_ip_to_sockaddr(&src, source_addr)) { if (!parse_ip_to_sockaddr(&src, source_addr)) {
close(client_fd); close(client_fd);
continue; continue;
} }
bind(client_fd, &src, sizeof(struct sockaddr_in6)); bind(client_fd, &src, sizeof(struct sockaddr_in6));
}
if( client_fd == -1) { continue; }
if( connect( client_fd, aip->ai_addr, aip->ai_addrlen) == 0 ) {
connected = 1;
break;
}
close( client_fd );
} }
myfail_unless( connected, "Didn't connect." ); if (client_fd == -1) {
return client_fd; continue;
}
if (connect(client_fd, aip->ai_addr, aip->ai_addrlen) == 0) {
connected = 1;
break;
}
close(client_fd);
}
myfail_unless(connected, "Didn't connect.");
return client_fd;
} }
/* These are "internal" functions we need for the following test. We /* These are "internal" functions we need for the following test. We
* shouldn't need them but there's no other way at the moment. */ * shouldn't need them but there's no other way at the moment. */
void serve_open_server_socket( struct server * ); void serve_open_server_socket(struct server *);
int server_port( struct server * ); int server_port(struct server *);
void server_accept( struct server * ); void server_accept(struct server *);
int fd_is_closed( int ); int fd_is_closed(int);
void server_close_clients( struct server * ); void server_close_clients(struct server *);
START_TEST( test_acl_update_closes_bad_client ) START_TEST(test_acl_update_closes_bad_client)
{ {
/* This is the wrong way round. Rather than pulling the thread /* This is the wrong way round. Rather than pulling the thread
* and socket out of the server structure, we should be testing * and socket out of the server structure, we should be testing
* a client socket. * a client socket.
*/ */
struct flexnbd flexnbd; struct flexnbd flexnbd;
flexnbd.signal_fd = -1; flexnbd.signal_fd = -1;
struct server * s = server_create( &flexnbd, "127.0.0.7", "0", dummy_file, 0, 0, NULL, 1, 0, 1 ); struct server *s =
struct acl * new_acl = acl_create( 0, NULL, 1 ); server_create(&flexnbd, "127.0.0.7", "0", dummy_file, 0, 0, NULL,
struct client * c; 1, 0, 1);
struct client_tbl_entry * entry; struct acl *new_acl = acl_create(0, NULL, 1);
struct client *c;
struct client_tbl_entry *entry;
int actual_port; int actual_port;
int client_fd; int client_fd;
int server_fd; int server_fd;
serve_open_server_socket( s ); serve_open_server_socket(s);
actual_port = server_port( s ); actual_port = server_port(s);
client_fd = connect_client( "127.0.0.7", actual_port, "127.0.0.1" ); client_fd = connect_client("127.0.0.7", actual_port, "127.0.0.1");
server_accept( s ); server_accept(s);
entry = &s->nbd_client[0]; entry = &s->nbd_client[0];
c = entry->client; c = entry->client;
/* At this point there should be an entry in the nbd_clients /* At this point there should be an entry in the nbd_clients
* table and a background thread to run the client loop * table and a background thread to run the client loop
*/ */
myfail_if( entry->thread == 0, "No client thread was started." ); myfail_if(entry->thread == 0, "No client thread was started.");
server_fd = c->socket; server_fd = c->socket;
myfail_if( fd_is_closed(server_fd), myfail_if(fd_is_closed(server_fd),
"Sanity check failed - client socket wasn't open." ); "Sanity check failed - client socket wasn't open.");
server_replace_acl( s, new_acl ); server_replace_acl(s, new_acl);
/* accept again, so that we can react to the acl replacement signal */ /* accept again, so that we can react to the acl replacement signal */
server_accept( s ); server_accept(s);
/* Fail if we time out here */ /* Fail if we time out here */
while( !fd_is_closed( server_fd ) ); while (!fd_is_closed(server_fd));
close( client_fd ); close(client_fd);
server_close_clients( s ); server_close_clients(s);
server_destroy( s ); server_destroy(s);
} }
END_TEST END_TEST
START_TEST(test_acl_update_leaves_good_client)
START_TEST( test_acl_update_leaves_good_client )
{ {
struct flexnbd flexnbd; struct flexnbd flexnbd;
flexnbd.signal_fd = -1; flexnbd.signal_fd = -1;
struct server * s = server_create( &flexnbd, "127.0.0.7", "0", dummy_file, 0, 0, NULL, 1, 0, 1 ); struct server *s =
server_create(&flexnbd, "127.0.0.7", "0", dummy_file, 0, 0, NULL,
1, 0, 1);
char *lines[] = {"127.0.0.1"}; char *lines[] = { "127.0.0.1" };
struct acl * new_acl = acl_create( 1, lines, 1 ); struct acl *new_acl = acl_create(1, lines, 1);
struct client * c; struct client *c;
struct client_tbl_entry * entry; struct client_tbl_entry *entry;
int actual_port; int actual_port;
int client_fd; int client_fd;
int server_fd; int server_fd;
serve_open_server_socket( s ); serve_open_server_socket(s);
actual_port = server_port( s ); actual_port = server_port(s);
client_fd = connect_client( "127.0.0.7", actual_port, "127.0.0.1" ); client_fd = connect_client("127.0.0.7", actual_port, "127.0.0.1");
server_accept( s ); server_accept(s);
entry = &s->nbd_client[0]; entry = &s->nbd_client[0];
c = entry->client; c = entry->client;
/* At this point there should be an entry in the nbd_clients /* At this point there should be an entry in the nbd_clients
* table and a background thread to run the client loop * table and a background thread to run the client loop
*/ */
myfail_if( entry->thread == 0, "No client thread was started." ); myfail_if(entry->thread == 0, "No client thread was started.");
server_fd = c->socket; server_fd = c->socket;
myfail_if( fd_is_closed(server_fd), myfail_if(fd_is_closed(server_fd),
"Sanity check failed - client socket wasn't open." ); "Sanity check failed - client socket wasn't open.");
server_replace_acl( s, new_acl ); server_replace_acl(s, new_acl);
server_accept( s ); server_accept(s);
myfail_if( self_pipe_signal_clear( c->stop_signal ), myfail_if(self_pipe_signal_clear(c->stop_signal),
"Client was told to stop." ); "Client was told to stop.");
close( client_fd ); close(client_fd);
server_close_clients( s ); server_close_clients(s);
server_destroy( s ); server_destroy(s);
} }
END_TEST END_TEST
Suite * serve_suite(void)
Suite* serve_suite(void)
{ {
Suite *s = suite_create("serve"); Suite *s = suite_create("serve");
TCase *tc_acl_update = tcase_create("acl_update"); TCase *tc_acl_update = tcase_create("acl_update");
tcase_add_checked_fixture( tc_acl_update, setup, NULL ); tcase_add_checked_fixture(tc_acl_update, setup, NULL);
tcase_add_test(tc_acl_update, test_replaces_acl); tcase_add_test(tc_acl_update, test_replaces_acl);
tcase_add_test(tc_acl_update, test_signals_acl_updated); tcase_add_test(tc_acl_update, test_signals_acl_updated);
tcase_add_exit_test(tc_acl_update, test_acl_update_closes_bad_client, 0); tcase_add_exit_test(tc_acl_update, test_acl_update_closes_bad_client,
tcase_add_exit_test(tc_acl_update, test_acl_update_leaves_good_client, 0); 0);
tcase_add_exit_test(tc_acl_update, test_acl_update_leaves_good_client,
0);
suite_add_tcase(s, tc_acl_update); suite_add_tcase(s, tc_acl_update);
return s; return s;
} }
int main(void) int main(void)
{ {
log_level = LOG_LEVEL; log_level = LOG_LEVEL;
error_init(); error_init();
int number_failed; int number_failed;
Suite *s = serve_suite(); Suite *s = serve_suite();
SRunner *sr = srunner_create(s); SRunner *sr = srunner_create(s);
srunner_run_all(sr, CK_NORMAL); srunner_run_all(sr, CK_NORMAL);
number_failed = srunner_ntests_failed(sr); number_failed = srunner_ntests_failed(sr);
srunner_free(sr); srunner_free(sr);
return (number_failed == 0) ? 0 : 1; return (number_failed == 0) ? 0 : 1;
} }

133
tests/unit/check_sockutil.c
View File

@@ -6,110 +6,113 @@
#include <check.h> #include <check.h>
START_TEST( test_sockaddr_address_string_af_inet_converts_to_string ) START_TEST(test_sockaddr_address_string_af_inet_converts_to_string)
{ {
struct sockaddr sa; struct sockaddr sa;
struct sockaddr_in* v4 = (struct sockaddr_in*) &sa; struct sockaddr_in *v4 = (struct sockaddr_in *) &sa;
char testbuf[128]; char testbuf[128];
const char* result; const char *result;
v4->sin_family = AF_INET; v4->sin_family = AF_INET;
v4->sin_port = htons( 4777 ); v4->sin_port = htons(4777);
ck_assert_int_eq( 1, inet_pton( AF_INET, "192.168.0.1", &v4->sin_addr )); ck_assert_int_eq(1, inet_pton(AF_INET, "192.168.0.1", &v4->sin_addr));
result = sockaddr_address_string( &sa, &testbuf[0], 128 ); result = sockaddr_address_string(&sa, &testbuf[0], 128);
ck_assert( result != NULL ); ck_assert(result != NULL);
ck_assert_str_eq( "192.168.0.1 port 4777", testbuf ); ck_assert_str_eq("192.168.0.1 port 4777", testbuf);
} }
END_TEST END_TEST
START_TEST(test_sockaddr_address_string_af_inet6_converts_to_string)
START_TEST( test_sockaddr_address_string_af_inet6_converts_to_string )
{ {
struct sockaddr_in6 v6_raw; struct sockaddr_in6 v6_raw;
struct sockaddr_in6* v6 = &v6_raw; struct sockaddr_in6 *v6 = &v6_raw;
struct sockaddr* sa = (struct sockaddr*) &v6_raw; struct sockaddr *sa = (struct sockaddr *) &v6_raw;
char testbuf[128]; char testbuf[128];
const char* result; const char *result;
v6->sin6_family = AF_INET6; v6->sin6_family = AF_INET6;
v6->sin6_port = htons( 4777 ); v6->sin6_port = htons(4777);
ck_assert_int_eq( 1, inet_pton( AF_INET6, "fe80::1", &v6->sin6_addr )); ck_assert_int_eq(1, inet_pton(AF_INET6, "fe80::1", &v6->sin6_addr));
result = sockaddr_address_string( sa, &testbuf[0], 128 ); result = sockaddr_address_string(sa, &testbuf[0], 128);
ck_assert( result != NULL ); ck_assert(result != NULL);
ck_assert_str_eq( "fe80::1 port 4777", testbuf ); ck_assert_str_eq("fe80::1 port 4777", testbuf);
} }
END_TEST END_TEST
/* We don't know what it is, so we just call it "???" and return NULL */ /* We don't know what it is, so we just call it "???" and return NULL */
START_TEST( test_sockaddr_address_string_af_unspec_is_failure ) START_TEST(test_sockaddr_address_string_af_unspec_is_failure)
{ {
struct sockaddr sa; struct sockaddr sa;
struct sockaddr_in* v4 = (struct sockaddr_in*) &sa; struct sockaddr_in *v4 = (struct sockaddr_in *) &sa;
char testbuf[128]; char testbuf[128];
const char* result; const char *result;
v4->sin_family = AF_UNSPEC; v4->sin_family = AF_UNSPEC;
v4->sin_port = htons( 4777 ); v4->sin_port = htons(4777);
ck_assert_int_eq( 1, inet_pton( AF_INET, "192.168.0.1", &v4->sin_addr )); ck_assert_int_eq(1, inet_pton(AF_INET, "192.168.0.1", &v4->sin_addr));
result = sockaddr_address_string( &sa, &testbuf[0], 128 ); result = sockaddr_address_string(&sa, &testbuf[0], 128);
ck_assert( result == NULL ); ck_assert(result == NULL);
ck_assert_str_eq( "???", testbuf ); ck_assert_str_eq("???", testbuf);
} }
END_TEST END_TEST
/* This is a complete failure to parse, rather than a partial failure */ /* This is a complete failure to parse, rather than a partial failure */
START_TEST( test_sockaddr_address_string_doesnt_overflow_short_buffer ) START_TEST(test_sockaddr_address_string_doesnt_overflow_short_buffer)
{ {
struct sockaddr sa; struct sockaddr sa;
struct sockaddr_in* v4 = (struct sockaddr_in*) &sa; struct sockaddr_in *v4 = (struct sockaddr_in *) &sa;
char testbuf[128]; char testbuf[128];
const char* result; const char *result;
memset( testbuf, 0, 128 ); memset(testbuf, 0, 128);
v4->sin_family = AF_INET; v4->sin_family = AF_INET;
v4->sin_port = htons( 4777 ); v4->sin_port = htons(4777);
ck_assert_int_eq( 1, inet_pton( AF_INET, "192.168.0.1", &v4->sin_addr )); ck_assert_int_eq(1, inet_pton(AF_INET, "192.168.0.1", &v4->sin_addr));
memset( &testbuf, 0, 128 ); memset(&testbuf, 0, 128);
result = sockaddr_address_string( &sa, &testbuf[0], 2 ); result = sockaddr_address_string(&sa, &testbuf[0], 2);
ck_assert( result == NULL ); ck_assert(result == NULL);
ck_assert_str_eq( "??", testbuf ); ck_assert_str_eq("??", testbuf);
} }
END_TEST END_TEST
Suite *sockutil_suite(void) Suite * sockutil_suite(void)
{ {
Suite *s = suite_create("sockutil"); Suite *s = suite_create("sockutil");
TCase *tc_sockaddr_address_string = tcase_create("sockaddr_address_string"); TCase *tc_sockaddr_address_string =
tcase_create("sockaddr_address_string");
tcase_add_test(tc_sockaddr_address_string, test_sockaddr_address_string_af_inet_converts_to_string); tcase_add_test(tc_sockaddr_address_string,
tcase_add_test(tc_sockaddr_address_string, test_sockaddr_address_string_af_inet6_converts_to_string); test_sockaddr_address_string_af_inet_converts_to_string);
tcase_add_test(tc_sockaddr_address_string, test_sockaddr_address_string_af_unspec_is_failure); tcase_add_test(tc_sockaddr_address_string,
tcase_add_test(tc_sockaddr_address_string, test_sockaddr_address_string_doesnt_overflow_short_buffer); test_sockaddr_address_string_af_inet6_converts_to_string);
suite_add_tcase(s, tc_sockaddr_address_string); tcase_add_test(tc_sockaddr_address_string,
test_sockaddr_address_string_af_unspec_is_failure);
tcase_add_test(tc_sockaddr_address_string,
test_sockaddr_address_string_doesnt_overflow_short_buffer);
suite_add_tcase(s, tc_sockaddr_address_string);
return s; return s;
} }
int main(void) int main(void)
{ {
int number_failed; int number_failed;
Suite *s = sockutil_suite(); Suite *s = sockutil_suite();
SRunner *sr = srunner_create(s); SRunner *sr = srunner_create(s);
srunner_run_all(sr, CK_NORMAL); srunner_run_all(sr, CK_NORMAL);
number_failed = srunner_ntests_failed(sr); number_failed = srunner_ntests_failed(sr);
srunner_free(sr); srunner_free(sr);
return (number_failed == 0) ? 0 : 1; return (number_failed == 0) ? 0 : 1;
} }

428
tests/unit/check_status.c
View File

@@ -6,366 +6,344 @@
#include <check.h> #include <check.h>
struct server* mock_server(void) struct server *mock_server(void)
{ {
struct server* out = xmalloc( sizeof( struct server ) ); struct server *out = xmalloc(sizeof(struct server));
out->l_start_mirror = flexthread_mutex_create(); out->l_start_mirror = flexthread_mutex_create();
out->nbd_client = xmalloc( sizeof( struct client_tbl_entry ) * 4 ); out->nbd_client = xmalloc(sizeof(struct client_tbl_entry) * 4);
out->max_nbd_clients = 4; out->max_nbd_clients = 4;
out->size = 65536; out->size = 65536;
out->allocation_map = bitset_alloc( 65536, 4096 ); out->allocation_map = bitset_alloc(65536, 4096);
return out; return out;
} }
struct server* mock_mirroring_server(void) struct server *mock_mirroring_server(void)
{ {
struct server *out = mock_server(); struct server *out = mock_server();
out->mirror = xmalloc( sizeof( struct mirror ) ); out->mirror = xmalloc(sizeof(struct mirror));
out->mirror_super = xmalloc( sizeof( struct mirror_super ) ); out->mirror_super = xmalloc(sizeof(struct mirror_super));
return out; return out;
} }
void destroy_mock_server( struct server* serve ) void destroy_mock_server(struct server *serve)
{ {
if ( NULL != serve->mirror ) { if (NULL != serve->mirror) {
free( serve->mirror ); free(serve->mirror);
} }
if ( NULL != serve->mirror_super ) { if (NULL != serve->mirror_super) {
free( serve->mirror_super ); free(serve->mirror_super);
} }
flexthread_mutex_destroy( serve->l_start_mirror ); flexthread_mutex_destroy(serve->l_start_mirror);
bitset_free( serve->allocation_map ); bitset_free(serve->allocation_map);
free( serve->nbd_client ); free(serve->nbd_client);
free( serve ); free(serve);
} }
START_TEST( test_status_create ) START_TEST(test_status_create)
{ {
struct server * server = mock_server(); struct server *server = mock_server();
struct status * status = status_create( server ); struct status *status = status_create(server);
fail_if( NULL == status, "Status wasn't allocated" ); fail_if(NULL == status, "Status wasn't allocated");
status_destroy( status ); status_destroy(status);
destroy_mock_server( server ); destroy_mock_server(server);
} }
END_TEST END_TEST
START_TEST( test_gets_has_control ) START_TEST(test_gets_has_control)
{ {
struct server * server = mock_server(); struct server *server = mock_server();
server->success = 1; server->success = 1;
struct status * status = status_create( server ); struct status *status = status_create(server);
fail_unless( status->has_control == 1, "has_control wasn't copied" ); fail_unless(status->has_control == 1, "has_control wasn't copied");
status_destroy( status ); status_destroy(status);
destroy_mock_server( server ); destroy_mock_server(server);
} }
END_TEST END_TEST
START_TEST(test_gets_is_mirroring)
START_TEST( test_gets_is_mirroring )
{ {
struct server * server = mock_server(); struct server *server = mock_server();
struct status * status = status_create( server ); struct status *status = status_create(server);
fail_if( status->is_mirroring, "is_mirroring was set" ); fail_if(status->is_mirroring, "is_mirroring was set");
status_destroy( status ); status_destroy(status);
destroy_mock_server( server ); destroy_mock_server(server);
server = mock_mirroring_server(); server = mock_mirroring_server();
status = status_create( server ); status = status_create(server);
fail_unless( status->is_mirroring, "is_mirroring wasn't set" ); fail_unless(status->is_mirroring, "is_mirroring wasn't set");
status_destroy( status ); status_destroy(status);
destroy_mock_server( server ); destroy_mock_server(server);
} }
END_TEST END_TEST
START_TEST( test_gets_clients_allowed ) START_TEST(test_gets_clients_allowed)
{ {
struct server * server = mock_server(); struct server *server = mock_server();
struct status * status = status_create( server ); struct status *status = status_create(server);
fail_if( status->clients_allowed, "clients_allowed was set" ); fail_if(status->clients_allowed, "clients_allowed was set");
status_destroy( status ); status_destroy(status);
server->allow_new_clients = 1; server->allow_new_clients = 1;
status = status_create( server ); status = status_create(server);
fail_unless( status->clients_allowed, "clients_allowed was not set" ); fail_unless(status->clients_allowed, "clients_allowed was not set");
status_destroy( status ); status_destroy(status);
destroy_mock_server( server ); destroy_mock_server(server);
} }
END_TEST END_TEST
START_TEST( test_gets_pid ) START_TEST(test_gets_pid)
{ {
struct server * server = mock_server(); struct server *server = mock_server();
struct status * status = status_create( server ); struct status *status = status_create(server);
fail_unless( getpid() == status->pid, "Pid wasn't gathered" ); fail_unless(getpid() == status->pid, "Pid wasn't gathered");
status_destroy( status ); status_destroy(status);
destroy_mock_server( server ); destroy_mock_server(server);
} }
END_TEST END_TEST
START_TEST( test_gets_size ) START_TEST(test_gets_size)
{ {
struct server * server = mock_server(); struct server *server = mock_server();
server->size = 1024; server->size = 1024;
struct status * status = status_create( server ); struct status *status = status_create(server);
fail_unless( 1024 == status->size, "Size wasn't gathered" ); fail_unless(1024 == status->size, "Size wasn't gathered");
status_destroy( status ); status_destroy(status);
destroy_mock_server( server ); destroy_mock_server(server);
} }
END_TEST END_TEST
START_TEST( test_gets_migration_statistics ) START_TEST(test_gets_migration_statistics)
{ {
struct server * server = mock_mirroring_server(); struct server *server = mock_mirroring_server();
server->mirror->all_dirty = 16384; server->mirror->all_dirty = 16384;
server->mirror->max_bytes_per_second = 32768; server->mirror->max_bytes_per_second = 32768;
server->mirror->offset = 0; server->mirror->offset = 0;
/* we have a bit of a time dependency here */ /* we have a bit of a time dependency here */
server->mirror->migration_started = monotonic_time_ms(); server->mirror->migration_started = monotonic_time_ms();
struct status * status = status_create( server ); struct status *status = status_create(server);
fail_unless ( fail_unless(0 == status->migration_duration ||
0 == status->migration_duration ||
1 == status->migration_duration || 1 == status->migration_duration ||
2 == status->migration_duration, 2 == status->migration_duration,
"migration_duration is unreasonable!" "migration_duration is unreasonable!");
);
fail_unless( fail_unless(16384 / (status->migration_duration + 1) ==
16384 / ( status->migration_duration + 1 ) == status->migration_speed, status->migration_speed,
"migration_speed not calculated correctly" "migration_speed not calculated correctly");
);
fail_unless( 32768 == status->migration_speed_limit, "migration_speed_limit not read" ); fail_unless(32768 == status->migration_speed_limit,
"migration_speed_limit not read");
// ( size / current_bps ) + 1 happens to be 3 for this test // ( size / current_bps ) + 1 happens to be 3 for this test
fail_unless( 3 == status->migration_seconds_left, "migration_seconds_left not gathered" ); fail_unless(3 == status->migration_seconds_left,
"migration_seconds_left not gathered");
status_destroy( status ); status_destroy(status);
destroy_mock_server( server ); destroy_mock_server(server);
} }
END_TEST END_TEST
#define RENDER_TEST_SETUP \ #define RENDER_TEST_SETUP \
struct status status; \ struct status status; \
int fds[2]; \ int fds[2]; \
pipe( fds ); pipe( fds );
void fail_unless_rendered(int fd, char *fragment)
void fail_unless_rendered( int fd, char *fragment )
{ {
char buf[1024] = {0}; char buf[1024] = { 0 };
char emsg[1024] = {0}; char emsg[1024] = { 0 };
char *found = NULL; char *found = NULL;
sprintf(emsg, "Fragment: %s not found", fragment ); sprintf(emsg, "Fragment: %s not found", fragment);
fail_unless( read_until_newline( fd, buf, 1024 ) > 0, "Couldn't read" ); fail_unless(read_until_newline(fd, buf, 1024) > 0, "Couldn't read");
found = strstr( buf, fragment ); found = strstr(buf, fragment);
fail_if( NULL == found, emsg ); fail_if(NULL == found, emsg);
return; return;
} }
void fail_if_rendered( int fd, char *fragment ) void fail_if_rendered(int fd, char *fragment)
{ {
char buf[1024] = {0}; char buf[1024] = { 0 };
char emsg[1024] = {0}; char emsg[1024] = { 0 };
char *found = NULL; char *found = NULL;
sprintf(emsg, "Fragment: %s found", fragment ); sprintf(emsg, "Fragment: %s found", fragment);
fail_unless( read_until_newline( fd, buf, 1024 ) > 0, "Couldn't read" ); fail_unless(read_until_newline(fd, buf, 1024) > 0, "Couldn't read");
found = strstr( buf, fragment ); found = strstr(buf, fragment);
fail_unless( NULL == found, emsg ); fail_unless(NULL == found, emsg);
return; return;
} }
START_TEST( test_renders_has_control ) START_TEST(test_renders_has_control)
{ {
RENDER_TEST_SETUP RENDER_TEST_SETUP status.has_control = 1;
status_write(&status, fds[1]);
fail_unless_rendered(fds[0], "has_control=true");
status.has_control = 1; status.has_control = 0;
status_write( &status, fds[1] ); status_write(&status, fds[1]);
fail_unless_rendered( fds[0], "has_control=true" ); fail_unless_rendered(fds[0], "has_control=false");
status.has_control = 0;
status_write( &status, fds[1] );
fail_unless_rendered( fds[0], "has_control=false" );
} }
END_TEST END_TEST
START_TEST(test_renders_is_mirroring)
START_TEST( test_renders_is_mirroring )
{ {
RENDER_TEST_SETUP RENDER_TEST_SETUP status.is_mirroring = 1;
status_write(&status, fds[1]);
fail_unless_rendered(fds[0], "is_mirroring=true");
status.is_mirroring = 1; status.is_mirroring = 0;
status_write( &status, fds[1] ); status_write(&status, fds[1]);
fail_unless_rendered( fds[0], "is_mirroring=true" ); fail_unless_rendered(fds[0], "is_mirroring=false");
status.is_mirroring = 0;
status_write( &status, fds[1] );
fail_unless_rendered( fds[0], "is_mirroring=false" );
} }
END_TEST END_TEST
START_TEST( test_renders_clients_allowed ) START_TEST(test_renders_clients_allowed)
{ {
RENDER_TEST_SETUP RENDER_TEST_SETUP status.clients_allowed = 1;
status_write(&status, fds[1]);
fail_unless_rendered(fds[0], "clients_allowed=true");
status.clients_allowed = 1; status.clients_allowed = 0;
status_write( &status, fds[1] ); status_write(&status, fds[1]);
fail_unless_rendered( fds[0], "clients_allowed=true" ); fail_unless_rendered(fds[0], "clients_allowed=false");
status.clients_allowed = 0;
status_write( &status, fds[1] );
fail_unless_rendered( fds[0], "clients_allowed=false" );
} }
END_TEST END_TEST
START_TEST( test_renders_num_clients ) START_TEST(test_renders_num_clients)
{ {
RENDER_TEST_SETUP RENDER_TEST_SETUP status.num_clients = 0;
status_write(&status, fds[1]);
fail_unless_rendered(fds[0], "num_clients=0");
status.num_clients = 0; status.num_clients = 4000;
status_write( &status, fds[1] ); status_write(&status, fds[1]);
fail_unless_rendered( fds[0], "num_clients=0" ); fail_unless_rendered(fds[0], "num_clients=4000");
status.num_clients = 4000;
status_write( &status, fds[1] );
fail_unless_rendered( fds[0], "num_clients=4000" );
} }
END_TEST END_TEST
START_TEST(test_renders_pid)
START_TEST( test_renders_pid )
{ {
RENDER_TEST_SETUP RENDER_TEST_SETUP status.pid = 42;
status_write(&status, fds[1]);
status.pid = 42; fail_unless_rendered(fds[0], "pid=42");
status_write( &status, fds[1] );
fail_unless_rendered( fds[0], "pid=42" );
} }
END_TEST END_TEST
START_TEST( test_renders_size ) START_TEST(test_renders_size)
{ {
RENDER_TEST_SETUP RENDER_TEST_SETUP status.size = ((uint64_t) 1 << 33);
status_write(&status, fds[1]);
status.size = ( (uint64_t)1 << 33 ); fail_unless_rendered(fds[0], "size=8589934592");
status_write( &status, fds[1] );
fail_unless_rendered( fds[0], "size=8589934592" );
} }
END_TEST END_TEST
START_TEST( test_renders_migration_statistics ) START_TEST(test_renders_migration_statistics)
{ {
RENDER_TEST_SETUP RENDER_TEST_SETUP status.is_mirroring = 0;
status.migration_duration = 8;
status.migration_speed = 40000000;
status.migration_speed_limit = 40000001;
status.migration_seconds_left = 1;
status.migration_bytes_left = 5000;
status.is_mirroring = 0; status_write(&status, fds[1]);
status.migration_duration = 8; fail_if_rendered(fds[0], "migration_duration");
status.migration_speed = 40000000;
status.migration_speed_limit = 40000001;
status.migration_seconds_left = 1;
status.migration_bytes_left = 5000;
status_write( &status, fds[1] ); status_write(&status, fds[1]);
fail_if_rendered( fds[0], "migration_duration" ); fail_if_rendered(fds[0], "migration_speed");
status_write( &status, fds[1] ); status_write(&status, fds[1]);
fail_if_rendered( fds[0], "migration_speed" ); fail_if_rendered(fds[0], "migration_speed_limit");
status_write( &status, fds[1] ); status_write(&status, fds[1]);
fail_if_rendered( fds[0], "migration_speed_limit" ); fail_if_rendered(fds[0], "migration_seconds_left");
status_write( &status, fds[1] ); status.is_mirroring = 1;
fail_if_rendered( fds[0], "migration_seconds_left" );
status.is_mirroring = 1; status_write(&status, fds[1]);
fail_unless_rendered(fds[0], "migration_duration=8");
status_write( &status, fds[1] ); status_write(&status, fds[1]);
fail_unless_rendered( fds[0], "migration_duration=8" ); fail_unless_rendered(fds[0], "migration_speed=40000000");
status_write( &status, fds[1] ); status_write(&status, fds[1]);
fail_unless_rendered( fds[0], "migration_speed=40000000" ); fail_unless_rendered(fds[0], "migration_speed_limit=40000001");
status_write( &status, fds[1] ); status_write(&status, fds[1]);
fail_unless_rendered( fds[0], "migration_speed_limit=40000001" ); fail_unless_rendered(fds[0], "migration_seconds_left=1");
status_write( &status, fds[1] ); status_write(&status, fds[1]);
fail_unless_rendered( fds[0], "migration_seconds_left=1" ); fail_unless_rendered(fds[0], "migration_bytes_left=5000");
status_write( &status, fds[1] ); status.migration_speed_limit = UINT64_MAX;
fail_unless_rendered( fds[0], "migration_bytes_left=5000" );
status.migration_speed_limit = UINT64_MAX; status_write(&status, fds[1]);
fail_if_rendered(fds[0], "migration_speed_limit");
status_write( &status, fds[1] );
fail_if_rendered( fds[0], "migration_speed_limit" );
} }
END_TEST END_TEST
Suite * status_suite(void)
Suite *status_suite(void)
{ {
Suite *s = suite_create("status"); Suite *s = suite_create("status");
TCase *tc_create = tcase_create("create"); TCase *tc_create = tcase_create("create");
TCase *tc_render = tcase_create("render"); TCase *tc_render = tcase_create("render");
tcase_add_test(tc_create, test_status_create); tcase_add_test(tc_create, test_status_create);
tcase_add_test(tc_create, test_gets_has_control); tcase_add_test(tc_create, test_gets_has_control);
tcase_add_test(tc_create, test_gets_is_mirroring); tcase_add_test(tc_create, test_gets_is_mirroring);
tcase_add_test(tc_create, test_gets_clients_allowed); tcase_add_test(tc_create, test_gets_clients_allowed);
tcase_add_test(tc_create, test_gets_pid); tcase_add_test(tc_create, test_gets_pid);
tcase_add_test(tc_create, test_gets_size); tcase_add_test(tc_create, test_gets_size);
tcase_add_test(tc_create, test_gets_migration_statistics); tcase_add_test(tc_create, test_gets_migration_statistics);
tcase_add_test(tc_render, test_renders_has_control); tcase_add_test(tc_render, test_renders_has_control);
tcase_add_test(tc_render, test_renders_is_mirroring); tcase_add_test(tc_render, test_renders_is_mirroring);
tcase_add_test(tc_render, test_renders_clients_allowed); tcase_add_test(tc_render, test_renders_clients_allowed);
tcase_add_test(tc_render, test_renders_num_clients); tcase_add_test(tc_render, test_renders_num_clients);
tcase_add_test(tc_render, test_renders_pid); tcase_add_test(tc_render, test_renders_pid);
tcase_add_test(tc_render, test_renders_size); tcase_add_test(tc_render, test_renders_size);
tcase_add_test(tc_render, test_renders_migration_statistics); tcase_add_test(tc_render, test_renders_migration_statistics);
suite_add_tcase(s, tc_create); suite_add_tcase(s, tc_create);
suite_add_tcase(s, tc_render); suite_add_tcase(s, tc_render);
return s; return s;
} }
int main(void) int main(void)
{ {
int number_failed; int number_failed;
Suite *s = status_suite(); Suite *s = status_suite();
SRunner *sr = srunner_create(s); SRunner *sr = srunner_create(s);
srunner_run_all(sr, CK_NORMAL); srunner_run_all(sr, CK_NORMAL);
number_failed = srunner_ntests_failed(sr); number_failed = srunner_ntests_failed(sr);
srunner_free(sr); srunner_free(sr);
return (number_failed == 0) ? 0 : 1; return (number_failed == 0) ? 0 : 1;
} }

185
tests/unit/check_util.c
View File

@@ -9,165 +9,160 @@
struct cleanup_bucket { struct cleanup_bucket {
struct self_pipe *called_signal; struct self_pipe *called_signal;
}; };
struct cleanup_bucket bkt; struct cleanup_bucket bkt;
void bucket_init(void){ void bucket_init(void)
if ( bkt.called_signal ) { {
self_pipe_destroy( bkt.called_signal ); if (bkt.called_signal) {
} self_pipe_destroy(bkt.called_signal);
bkt.called_signal = self_pipe_create(); }
bkt.called_signal = self_pipe_create();
} }
void setup(void) void setup(void)
{ {
bkt.called_signal = NULL; bkt.called_signal = NULL;
} }
int handler_called(void) int handler_called(void)
{ {
return self_pipe_signal_clear( bkt.called_signal ); return self_pipe_signal_clear(bkt.called_signal);
} }
void dummy_cleanup( struct cleanup_bucket * foo, int fatal __attribute__((unused)) ) void dummy_cleanup(struct cleanup_bucket *foo, int fatal
__attribute__ ((unused)))
{ {
if (NULL != foo){ if (NULL != foo) {
self_pipe_signal( foo->called_signal ); self_pipe_signal(foo->called_signal);
} }
} }
void trigger_fatal(void) void trigger_fatal(void)
{ {
error_init(); error_init();
error_set_handler( (cleanup_handler*) dummy_cleanup, &bkt ); error_set_handler((cleanup_handler *) dummy_cleanup, &bkt);
log_level = 5; log_level = 5;
fatal("Expected fatal error"); fatal("Expected fatal error");
} }
void trigger_error( void ) void trigger_error(void)
{ {
error_init(); error_init();
error_set_handler( (cleanup_handler *) dummy_cleanup, &bkt); error_set_handler((cleanup_handler *) dummy_cleanup, &bkt);
log_level = 4; log_level = 4;
error("Expected error"); error("Expected error");
} }
START_TEST( test_fatal_kills_process ) START_TEST(test_fatal_kills_process)
{ {
pid_t pid; pid_t pid;
pid = fork(); pid = fork();
if ( pid == 0 ) { if (pid == 0) {
trigger_fatal(); trigger_fatal();
/* If we get here, just block so the test timeout fails /* If we get here, just block so the test timeout fails
* us */ * us */
sleep(10); sleep(10);
} } else {
else { int kidret, kidstatus, result;
int kidret, kidstatus, result; result = waitpid(pid, &kidret, 0);
result = waitpid( pid, &kidret, 0 ); fail_if(result < 0, "Wait failed.");
fail_if( result < 0, "Wait failed." ); fail_unless(WIFSIGNALED(kidret), "Process didn't exit via signal");
fail_unless( WIFSIGNALED( kidret ), "Process didn't exit via signal" ); kidstatus = WTERMSIG(kidret);
kidstatus = WTERMSIG( kidret ); ck_assert_int_eq(kidstatus, SIGABRT);
ck_assert_int_eq( kidstatus, SIGABRT ); }
}
} }
END_TEST END_TEST
void *error_thread(void *nothing __attribute__ ((unused)))
void * error_thread( void *nothing __attribute__((unused)) )
{ {
trigger_error(); trigger_error();
return NULL; return NULL;
} }
START_TEST( test_error_doesnt_kill_process ) START_TEST(test_error_doesnt_kill_process)
{ {
bucket_init(); bucket_init();
pthread_attr_t attr; pthread_attr_t attr;
pthread_t tid; pthread_t tid;
pthread_attr_init( &attr ); pthread_attr_init(&attr);
pthread_create( &tid, &attr, error_thread, NULL ); pthread_create(&tid, &attr, error_thread, NULL);
pthread_join( tid, NULL ); pthread_join(tid, NULL);
} }
END_TEST END_TEST
START_TEST(test_error_calls_handler)
START_TEST( test_error_calls_handler )
{ {
bucket_init(); bucket_init();
pthread_attr_t attr; pthread_attr_t attr;
pthread_t tid; pthread_t tid;
pthread_attr_init( &attr ); pthread_attr_init(&attr);
pthread_create( &tid, &attr, error_thread, NULL ); pthread_create(&tid, &attr, error_thread, NULL);
pthread_join( tid, NULL ); pthread_join(tid, NULL);
fail_unless( handler_called(), "Handler wasn't called." ); fail_unless(handler_called(), "Handler wasn't called.");
} }
END_TEST END_TEST
START_TEST(test_fatal_doesnt_call_handler)
START_TEST( test_fatal_doesnt_call_handler )
{ {
bucket_init(); bucket_init();
pid_t kidpid; pid_t kidpid;
kidpid = fork(); kidpid = fork();
if ( kidpid == 0 ) { if (kidpid == 0) {
trigger_fatal(); trigger_fatal();
} } else {
else { int kidstatus;
int kidstatus; int result = waitpid(kidpid, &kidstatus, 0);
int result = waitpid( kidpid, &kidstatus, 0 ); fail_if(result < 0, "Wait failed");
fail_if( result < 0, "Wait failed" ); fail_if(handler_called(), "Handler was called.");
fail_if( handler_called(), "Handler was called."); }
}
} }
END_TEST END_TEST
Suite *util_suite(void)
Suite* util_suite(void)
{ {
Suite *s = suite_create("util"); Suite *s = suite_create("util");
TCase *tc_process = tcase_create("process"); TCase *tc_process = tcase_create("process");
TCase *tc_handler = tcase_create("handler"); TCase *tc_handler = tcase_create("handler");
tcase_add_checked_fixture( tc_process, setup, NULL ); tcase_add_checked_fixture(tc_process, setup, NULL);
tcase_add_test(tc_process, test_fatal_kills_process); tcase_add_test(tc_process, test_fatal_kills_process);
tcase_add_test(tc_process, test_error_doesnt_kill_process); tcase_add_test(tc_process, test_error_doesnt_kill_process);
tcase_add_test(tc_handler, test_error_calls_handler ); tcase_add_test(tc_handler, test_error_calls_handler);
tcase_add_test(tc_handler, test_fatal_doesnt_call_handler); tcase_add_test(tc_handler, test_fatal_doesnt_call_handler);
suite_add_tcase(s, tc_process); suite_add_tcase(s, tc_process);
suite_add_tcase(s, tc_handler); suite_add_tcase(s, tc_handler);
return s; return s;
} }
int main(void) int main(void)
{ {
int number_failed; int number_failed;
Suite *s = util_suite(); Suite *s = util_suite();
SRunner *sr = srunner_create(s); SRunner *sr = srunner_create(s);
srunner_run_all(sr, CK_NORMAL); srunner_run_all(sr, CK_NORMAL);
number_failed = srunner_ntests_failed(sr); number_failed = srunner_ntests_failed(sr);
srunner_free(sr); srunner_free(sr);
return (number_failed == 0) ? 0 : 1; return (number_failed == 0) ? 0 : 1;
} }