From 103bd7ad5b1894b05df21d1671bd4aea43d18b28 Mon Sep 17 00:00:00 2001 From: Patrick J Cherry Date: Tue, 20 Feb 2018 10:13:42 +0000 Subject: [PATCH] Undo formatting on test suite -- it wasn't right --- tests/unit/check_acl.c | 331 ++++++++--------- tests/unit/check_bitset.c | 655 +++++++++++++++++----------------- tests/unit/check_client.c | 128 ++++--- tests/unit/check_control.c | 41 ++- tests/unit/check_flexnbd.c | 50 +-- tests/unit/check_flexthread.c | 70 ++-- tests/unit/check_ioutil.c | 166 +++++---- tests/unit/check_mbox.c | 120 ++++--- tests/unit/check_nbdtypes.c | 351 +++++++++--------- tests/unit/check_parse.c | 46 +-- tests/unit/check_readwrite.c | 204 +++++------ tests/unit/check_self_pipe.c | 300 ++++++++-------- tests/unit/check_serve.c | 334 +++++++++-------- tests/unit/check_sockutil.c | 140 ++++---- tests/unit/check_status.c | 441 ++++++++++++----------- tests/unit/check_util.c | 189 +++++----- 16 files changed, 1844 insertions(+), 1722 deletions(-) diff --git a/tests/unit/check_acl.c b/tests/unit/check_acl.c index 6aac7ea..bb12f81 100644 --- a/tests/unit/check_acl.c +++ b/tests/unit/check_acl.c @@ -4,221 +4,226 @@ #include "acl.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_unless(0 == acl->len, "Incorrect length"); + fail_if( NULL == acl, "No acl alloced." ); + fail_unless( 0 == acl->len, "Incorrect length" ); } - -END_TEST START_TEST(test_parses_single_line) -{ - char *lines[] = { "127.0.0.1" }; - struct acl *acl = acl_create(1, lines, 0); - - fail_unless(1 == acl->len, "Incorrect length."); - fail_if(NULL == acl->entries, "No entries present."); -} - -END_TEST START_TEST(test_parses_multiple_lines) -{ - char *lines[] = { "127.0.0.1", "::1" }; - struct acl *acl = acl_create(2, lines, 0); - union mysockaddr e0, e1; - - parse_ip_to_sockaddr(&e0.generic, lines[0]); - parse_ip_to_sockaddr(&e1.generic, lines[1]); - - fail_unless(acl->len == 2, "Multiple lines not parsed"); - - struct ip_and_mask *entry; - entry = &(*acl->entries)[0]; - fail_unless(entry->ip.family == e0.family, - "entry 0 has wrong family!"); - entry = &(*acl->entries)[1]; - fail_unless(entry->ip.family == e1.family, - "entry 1 has wrong family!"); -} - -END_TEST START_TEST(test_destroy_doesnt_crash) -{ - char *lines[] = { "127.0.0.1" }; - struct acl *acl = acl_create(1, lines, 0); - - acl_destroy(acl); -} - -END_TEST START_TEST(test_includes_single_address) -{ - char *lines[] = { "127.0.0.1" }; - struct acl *acl = acl_create(1, lines, 0); - union mysockaddr x; - - parse_ip_to_sockaddr(&x.generic, "127.0.0.1"); - - fail_unless(acl_includes(acl, &x), "Included address wasn't covered"); -} - END_TEST -START_TEST(test_includes_single_address_when_netmask_specified_ipv4) + + +START_TEST( test_parses_single_line ) { - char *lines[] = { "127.0.0.1/24" }; - struct acl *acl = acl_create(1, lines, 0); - union mysockaddr x; + char *lines[] = {"127.0.0.1"}; + struct acl * acl = acl_create( 1, lines, 0 ); - parse_ip_to_sockaddr(&x.generic, "127.0.0.0"); - fail_unless(acl_includes(acl, &x), "Included address wasn't covered"); - - parse_ip_to_sockaddr(&x.generic, "127.0.0.1"); - fail_unless(acl_includes(acl, &x), "Included address wasn't covered"); - - parse_ip_to_sockaddr(&x.generic, "127.0.0.255"); - fail_unless(acl_includes(acl, &x), "Included address wasn't covered"); + fail_unless( 1 == acl->len, "Incorrect length." ); + fail_if( NULL == acl->entries, "No entries present." ); } - END_TEST -START_TEST(test_includes_single_address_when_netmask_specified_ipv6) + +START_TEST( test_parses_multiple_lines ) { - char *lines[] = { "fe80::/10" }; - struct acl *acl = acl_create(1, lines, 0); - union mysockaddr x; + char *lines[] = {"127.0.0.1", "::1"}; + struct acl * acl = acl_create( 2, lines, 0 ); + union mysockaddr e0, e1; - parse_ip_to_sockaddr(&x.generic, "fe80::1"); - fail_unless(acl_includes(acl, &x), "Included address wasn't covered"); + parse_ip_to_sockaddr( &e0.generic, lines[0] ); + parse_ip_to_sockaddr( &e1.generic, lines[1] ); - parse_ip_to_sockaddr(&x.generic, "fe80::2"); - fail_unless(acl_includes(acl, &x), "Included address wasn't covered"); + fail_unless( acl->len == 2, "Multiple lines not parsed" ); - parse_ip_to_sockaddr(&x.generic, "fe80:ffff:ffff::ffff"); - fail_unless(acl_includes(acl, &x), "Included address wasn't covered"); + struct ip_and_mask *entry; + entry = &(*acl->entries)[0]; + fail_unless(entry->ip.family == e0.family, "entry 0 has wrong family!"); + entry = &(*acl->entries)[1]; + fail_unless(entry->ip.family == e1.family, "entry 1 has wrong family!"); } - END_TEST -START_TEST(test_includes_single_address_when_multiple_entries_exist) + +START_TEST( test_destroy_doesnt_crash ) { - char *lines[] = { "127.0.0.1", "::1" }; - struct acl *acl = acl_create(2, lines, 0); - union mysockaddr e0; - union mysockaddr e1; + char *lines[] = {"127.0.0.1"}; + struct acl * acl = acl_create( 1, lines, 0 ); - parse_ip_to_sockaddr(&e0.generic, "127.0.0.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, &e1), - "Included address 1 wasn't covered"); + acl_destroy( acl ); } - -END_TEST START_TEST(test_doesnt_include_other_address) -{ - char *lines[] = { "127.0.0.1" }; - struct acl *acl = acl_create(1, lines, 0); - union mysockaddr x; - - parse_ip_to_sockaddr(&x.generic, "127.0.0.2"); - fail_if(acl_includes(acl, &x), "Excluded address was covered."); -} - END_TEST -START_TEST(test_doesnt_include_other_address_when_netmask_specified) + + +START_TEST( test_includes_single_address ) { - char *lines[] = { "127.0.0.1/32" }; - struct acl *acl = acl_create(1, lines, 0); - union mysockaddr x; + char *lines[] = {"127.0.0.1"}; + struct acl * acl = acl_create( 1, lines, 0 ); + union mysockaddr x; - parse_ip_to_sockaddr(&x.generic, "127.0.0.2"); - fail_if(acl_includes(acl, &x), "Excluded address was covered."); + parse_ip_to_sockaddr( &x.generic, "127.0.0.1" ); + + fail_unless( acl_includes( acl, &x ), "Included address wasn't covered" ); } - END_TEST -START_TEST(test_doesnt_include_other_address_when_multiple_entries_exist) + +START_TEST( test_includes_single_address_when_netmask_specified_ipv4 ) { - char *lines[] = { "127.0.0.1", "::1" }; - struct acl *acl = acl_create(2, lines, 0); - union mysockaddr e0; - union mysockaddr e1; + char *lines[] = {"127.0.0.1/24"}; + struct acl * acl = acl_create( 1, lines, 0 ); + union mysockaddr x; - parse_ip_to_sockaddr(&e0.generic, "127.0.0.2"); - parse_ip_to_sockaddr(&e1.generic, "::2"); + parse_ip_to_sockaddr( &x.generic, "127.0.0.0" ); + fail_unless( acl_includes( acl, &x ), "Included address wasn't covered" ); - fail_if(acl_includes(acl, &e0), "Excluded address 0 was covered."); - fail_if(acl_includes(acl, &e1), "Excluded address 1 was covered."); + parse_ip_to_sockaddr( &x.generic, "127.0.0.1" ); + fail_unless( acl_includes( acl, &x ), "Included address wasn't covered" ); + + parse_ip_to_sockaddr( &x.generic, "127.0.0.255" ); + fail_unless( acl_includes( acl, &x ), "Included address wasn't covered" ); } +END_TEST -END_TEST START_TEST(test_default_deny_rejects) +START_TEST( test_includes_single_address_when_netmask_specified_ipv6 ) { - struct acl *acl = acl_create(0, NULL, 1); - union mysockaddr x; + char *lines[] = {"fe80::/10"}; + struct acl * acl = acl_create( 1, lines, 0 ); + union mysockaddr x; - parse_ip_to_sockaddr(&x.generic, "127.0.0.1"); + parse_ip_to_sockaddr( &x.generic, "fe80::1" ); + fail_unless( acl_includes( acl, &x ), "Included address wasn't covered" ); - fail_if(acl_includes(acl, &x), "Default deny accepted."); + parse_ip_to_sockaddr( &x.generic, "fe80::2" ); + fail_unless( acl_includes( acl, &x ), "Included address wasn't covered" ); + + parse_ip_to_sockaddr( &x.generic, "fe80:ffff:ffff::ffff" ); + fail_unless( acl_includes( acl, &x ), "Included address wasn't covered" ); } +END_TEST -END_TEST START_TEST(test_default_accept_rejects) +START_TEST( test_includes_single_address_when_multiple_entries_exist ) { - struct acl *acl = acl_create(0, NULL, 0); - union mysockaddr x; + char *lines[] = {"127.0.0.1", "::1"}; + struct acl * acl = acl_create( 2, lines, 0 ); + union mysockaddr e0; + union mysockaddr e1; - parse_ip_to_sockaddr(&x.generic, "127.0.0.1"); + parse_ip_to_sockaddr( &e0.generic, "127.0.0.1" ); + parse_ip_to_sockaddr( &e1.generic, "::1" ); - fail_unless(acl_includes(acl, &x), "Default accept rejected."); + fail_unless( acl_includes( acl, &e0 ), "Included address 0 wasn't covered" ); + fail_unless( acl_includes( acl, &e1 ), "Included address 1 wasn't covered" ); } +END_TEST -END_TEST Suite * acl_suite(void) + +START_TEST( test_doesnt_include_other_address ) { - Suite *s = suite_create("acl"); - TCase *tc_create = tcase_create("create"); - TCase *tc_includes = tcase_create("includes"); - TCase *tc_destroy = tcase_create("destroy"); + char *lines[] = {"127.0.0.1"}; + struct acl * acl = acl_create( 1, lines, 0 ); + union mysockaddr x; + + parse_ip_to_sockaddr( &x.generic, "127.0.0.2" ); + fail_if( acl_includes( acl, &x ), "Excluded address was covered." ); +} +END_TEST + +START_TEST( test_doesnt_include_other_address_when_netmask_specified ) +{ + char *lines[] = {"127.0.0.1/32"}; + struct acl * acl = acl_create( 1, lines, 0 ); + union mysockaddr x; + + parse_ip_to_sockaddr( &x.generic, "127.0.0.2" ); + fail_if( acl_includes( acl, &x ), "Excluded address was covered." ); +} +END_TEST + +START_TEST( test_doesnt_include_other_address_when_multiple_entries_exist ) +{ + char *lines[] = {"127.0.0.1", "::1"}; + struct acl * acl = acl_create( 2, lines, 0 ); + union mysockaddr e0; + union mysockaddr e1; + + parse_ip_to_sockaddr( &e0.generic, "127.0.0.2" ); + parse_ip_to_sockaddr( &e1.generic, "::2" ); + + fail_if( acl_includes( acl, &e0 ), "Excluded address 0 was covered." ); + fail_if( acl_includes( acl, &e1 ), "Excluded address 1 was covered." ); +} +END_TEST + +START_TEST( test_default_deny_rejects ) +{ + struct acl * acl = acl_create( 0, NULL, 1 ); + union mysockaddr x; + + parse_ip_to_sockaddr( &x.generic, "127.0.0.1" ); + + fail_if( acl_includes( acl, &x ), "Default deny accepted." ); +} +END_TEST - tcase_add_test(tc_create, test_null_acl); - tcase_add_test(tc_create, test_parses_single_line); - tcase_add_test(tc_includes, test_parses_multiple_lines); +START_TEST( test_default_accept_rejects ) +{ + struct acl * acl = acl_create( 0, NULL, 0 ); + union mysockaddr x; - 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, - test_includes_single_address_when_netmask_specified_ipv6); + parse_ip_to_sockaddr( &x.generic, "127.0.0.1" ); - tcase_add_test(tc_includes, - test_includes_single_address_when_multiple_entries_exist); + fail_unless( acl_includes( acl, &x ), "Default accept rejected." ); +} +END_TEST - 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, - 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_accept_rejects); +Suite* acl_suite(void) +{ + Suite *s = suite_create("acl"); + TCase *tc_create = tcase_create("create"); + TCase *tc_includes = tcase_create("includes"); + TCase *tc_destroy = tcase_create("destroy"); - tcase_add_test(tc_destroy, test_destroy_doesnt_crash); - suite_add_tcase(s, tc_create); - suite_add_tcase(s, tc_includes); - suite_add_tcase(s, tc_destroy); + tcase_add_test(tc_create, test_null_acl); + tcase_add_test(tc_create, test_parses_single_line); + tcase_add_test(tc_includes, test_parses_multiple_lines); - return s; + 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, 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_doesnt_include_other_address); + tcase_add_test(tc_includes, 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_accept_rejects); + + tcase_add_test(tc_destroy, test_destroy_doesnt_crash); + + suite_add_tcase(s, tc_create); + suite_add_tcase(s, tc_includes); + suite_add_tcase(s, tc_destroy); + + return s; } int main(void) { #ifdef DEBUG - log_level = 0; + log_level = 0; #else - log_level = 2; + log_level = 2; #endif - int number_failed; - Suite *s = acl_suite(); - SRunner *sr = srunner_create(s); - srunner_run_all(sr, CK_NORMAL); - log_level = 0; - number_failed = srunner_ntests_failed(sr); - srunner_free(sr); - return (number_failed == 0) ? 0 : 1; + int number_failed; + Suite *s = acl_suite(); + SRunner *sr = srunner_create(s); + srunner_run_all(sr, CK_NORMAL); + log_level = 0; + number_failed = srunner_ntests_failed(sr); + srunner_free(sr); + return (number_failed == 0) ? 0 : 1; } + diff --git a/tests/unit/check_bitset.c b/tests/unit/check_bitset.c index 100e96b..36b4e55 100644 --- a/tests/unit/check_bitset.c +++ b/tests/unit/check_bitset.c @@ -9,473 +9,492 @@ START_TEST(test_bit_set) { - uint64_t num = 0; - bitfield_p bits = (bitfield_p) & num; + uint64_t num = 0; + bitfield_p bits = (bitfield_p) # #define TEST_BIT_SET(bit, newvalue) \ bit_set(bits, (bit)); \ fail_unless(num == (newvalue), "num was %x instead of %x", num, (newvalue)); - TEST_BIT_SET(0, 1); - TEST_BIT_SET(1, 3); - TEST_BIT_SET(2, 7); - TEST_BIT_SET(7, 0x87); - TEST_BIT_SET(63, 0x8000000000000087); + TEST_BIT_SET(0, 1); + TEST_BIT_SET(1, 3); + TEST_BIT_SET(2, 7); + TEST_BIT_SET(7, 0x87); + TEST_BIT_SET(63, 0x8000000000000087); } +END_TEST -END_TEST START_TEST(test_bit_clear) +START_TEST(test_bit_clear) { - uint64_t num = 0xffffffffffffffff; - bitfield_p bits = (bitfield_p) & num; + uint64_t num = 0xffffffffffffffff; + bitfield_p bits = (bitfield_p) # #define TEST_BIT_CLEAR(bit, newvalue) \ bit_clear(bits, (bit)); \ fail_unless(num == (newvalue), "num was %x instead of %x", num, (newvalue)); - TEST_BIT_CLEAR(0, 0xfffffffffffffffe); - TEST_BIT_CLEAR(1, 0xfffffffffffffffc); - TEST_BIT_CLEAR(2, 0xfffffffffffffff8); - TEST_BIT_CLEAR(7, 0xffffffffffffff78); - TEST_BIT_CLEAR(63, 0x7fffffffffffff78); + TEST_BIT_CLEAR(0, 0xfffffffffffffffe); + TEST_BIT_CLEAR(1, 0xfffffffffffffffc); + TEST_BIT_CLEAR(2, 0xfffffffffffffff8); + TEST_BIT_CLEAR(7, 0xffffffffffffff78); + TEST_BIT_CLEAR(63,0x7fffffffffffff78); } +END_TEST -END_TEST START_TEST(test_bit_tests) +START_TEST(test_bit_tests) { - uint64_t num = 0x5555555555555555; - bitfield_p bits = (bitfield_p) & num; + uint64_t num = 0x5555555555555555; + bitfield_p bits = (bitfield_p) # - 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, 63, 0), "bit_has_value 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_set(bits, 62), "bit_is_set malfunction"); - fail_unless(bit_is_clear(bits, 63), "bit_is_clear 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, 63, 0), "bit_has_value 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_set(bits, 62), "bit_is_set 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)]; - uint64_t *longs = (uint64_t *) buffer; - uint64_t i; + bitfield_word_t buffer[BIT_WORDS_FOR_SIZE(4160)]; + uint64_t *longs = (uint64_t *) buffer; + uint64_t i; - memset(buffer, 0, 4160); + memset(buffer, 0, 4160); - for (i = 0; i < 64; i++) { - bit_set_range(buffer, i * 64, i); - fail_unless(longs[i] == (1ULL << i) - 1, - "longs[%ld] = %lx SHOULD BE %lx", - i, longs[i], (1ULL << i) - 1); + for (i=0; i<64; i++) { + bit_set_range(buffer, i*64, i); + fail_unless( + longs[i] == (1ULL<bits; + map = bitset_alloc(6400, 100); + num = (uint64_t*) map->bits; - bitset_set_range(map, 0, 50); - ck_assert_int_eq(1, *num); - bitset_set_range(map, 99, 1); - ck_assert_int_eq(1, *num); - bitset_set_range(map, 100, 1); - ck_assert_int_eq(3, *num); - bitset_set_range(map, 0, 800); - ck_assert_int_eq(255, *num); - bitset_set_range(map, 1499, 2); - ck_assert_int_eq(0xc0ff, *num); - bitset_clear_range(map, 1499, 2); - ck_assert_int_eq(255, *num); + bitset_set_range(map,0,50); + ck_assert_int_eq(1, *num); + bitset_set_range(map,99,1); + ck_assert_int_eq(1, *num); + bitset_set_range(map,100,1); + ck_assert_int_eq(3, *num); + bitset_set_range(map,0,800); + ck_assert_int_eq(255, *num); + bitset_set_range(map,1499,2); + ck_assert_int_eq(0xc0ff, *num); + bitset_clear_range(map,1499,2); + ck_assert_int_eq(255, *num); - *num = 0; - bitset_set_range(map, 1499, 2); - bitset_clear_range(map, 1300, 200); - ck_assert_int_eq(0x8000, *num); + *num = 0; + bitset_set_range(map, 1499, 2); + bitset_clear_range(map, 1300, 200); + ck_assert_int_eq(0x8000, *num); - *num = 0; - bitset_set_range(map, 0, 6400); - ck_assert_int_eq(0xffffffffffffffff, *num); - bitset_clear_range(map, 3200, 400); - ck_assert_int_eq(0xfffffff0ffffffff, *num); + *num = 0; + bitset_set_range(map, 0, 6400); + ck_assert_int_eq(0xffffffffffffffff, *num); + bitset_clear_range(map, 3200, 400); + ck_assert_int_eq(0xfffffff0ffffffff, *num); } +END_TEST -END_TEST START_TEST(test_bitset_set) + +START_TEST( test_bitset_set ) { - struct bitset *map; - uint64_t run; + struct bitset * map; + uint64_t run; - map = bitset_alloc(64, 1); + map = bitset_alloc(64, 1); - assert_bitset_is(map, 0x0000000000000000); - bitset_set(map); - assert_bitset_is(map, 0xffffffffffffffff); - bitset_free(map); + assert_bitset_is( map, 0x0000000000000000 ); + bitset_set( map ); + assert_bitset_is( map, 0xffffffffffffffff ); + bitset_free( map ); - map = bitset_alloc(6400, 100); - assert_bitset_is(map, 0x0000000000000000); - bitset_set(map); - assert_bitset_is(map, 0xffffffffffffffff); - bitset_free(map); + map = bitset_alloc( 6400, 100 ); + assert_bitset_is( map, 0x0000000000000000 ); + bitset_set( map ); + assert_bitset_is( map, 0xffffffffffffffff ); + bitset_free( map ); - // Now do something large and representative - map = bitset_alloc(53687091200, 4096); - bitset_set(map); + // Now do something large and representative + map = bitset_alloc( 53687091200, 4096 ); + bitset_set( map ); - run = bitset_run_count(map, 0, 53687091200); - ck_assert_int_eq(run, 53687091200); - bitset_free(map); + run = bitset_run_count( map, 0, 53687091200 ); + ck_assert_int_eq( run, 53687091200 ); + bitset_free( map ); } +END_TEST -END_TEST START_TEST(test_bitset_clear) + +START_TEST( test_bitset_clear ) { - struct bitset *map; - uint64_t *num; - uint64_t run; + struct bitset * map; + uint64_t *num; + uint64_t run; - map = bitset_alloc(64, 1); - num = (uint64_t *) map->bits; + map = bitset_alloc(64, 1); + num = (uint64_t*) map->bits; - ck_assert_int_eq(0x0000000000000000, *num); - bitset_set(map); - bitset_clear(map); - ck_assert_int_eq(0x0000000000000000, *num); + ck_assert_int_eq( 0x0000000000000000, *num ); + bitset_set( map ); + bitset_clear( map ); + ck_assert_int_eq( 0x0000000000000000, *num ); - bitset_free(map); + bitset_free( map ); - // Now do something large and representative - map = bitset_alloc(53687091200, 4096); - bitset_set(map); - bitset_clear(map); - run = bitset_run_count(map, 0, 53687091200); - ck_assert_int_eq(run, 53687091200); - bitset_free(map); + // Now do something large and representative + map = bitset_alloc( 53687091200, 4096 ); + bitset_set( map ); + bitset_clear( map ); + run = bitset_run_count( map, 0, 53687091200 ); + ck_assert_int_eq( run, 53687091200 ); + 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); - assert_bitset_is(map, 0x0000000000000000); + struct bitset* map = bitset_alloc( 64, 1 ); + assert_bitset_is( map, 0x0000000000000000 ); - bitset_set_range(map, 8, 8); - assert_bitset_is(map, 0x000000000000ff00); + bitset_set_range( map, 8, 8 ); + assert_bitset_is( map, 0x000000000000ff00 ); - bitset_clear(map); - assert_bitset_is(map, 0x0000000000000000); - bitset_set_range(map, 0, 0); - assert_bitset_is(map, 0x0000000000000000); + bitset_clear( map ); + assert_bitset_is( map, 0x0000000000000000 ); + bitset_set_range( map, 0, 0 ); + 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); - bitset_set(map); - assert_bitset_is(map, 0xffffffffffffffff); + struct bitset* map = bitset_alloc( 64, 1 ); + bitset_set( map ); + assert_bitset_is( map, 0xffffffffffffffff ); - bitset_clear_range(map, 8, 8); - assert_bitset_is(map, 0xffffffffffff00ff); + bitset_clear_range( map, 8, 8 ); + assert_bitset_is( map, 0xffffffffffff00ff ); - bitset_set(map); - assert_bitset_is(map, 0xffffffffffffffff); - bitset_clear_range(map, 0, 0); - assert_bitset_is(map, 0xffffffffffffffff); + bitset_set( map ); + assert_bitset_is( map, 0xffffffffffffffff ); + bitset_clear_range( map, 0, 0 ); + 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); - uint64_t run; + struct bitset* map = bitset_alloc( 64, 1 ); + uint64_t run; - assert_bitset_is(map, 0x0000000000000000); + assert_bitset_is( map, 0x0000000000000000 ); - run = bitset_run_count(map, 0, 64); - ck_assert_int_eq(64, run); + run = bitset_run_count( map, 0, 64 ); + ck_assert_int_eq( 64, run ); - bitset_set_range(map, 0, 32); - assert_bitset_is(map, 0x00000000ffffffff); + bitset_set_range( map, 0, 32 ); + assert_bitset_is( map, 0x00000000ffffffff ); - run = bitset_run_count(map, 0, 64); - ck_assert_int_eq(32, run); + run = bitset_run_count( map, 0, 64 ); + ck_assert_int_eq( 32, run ); - run = bitset_run_count(map, 0, 16); - ck_assert_int_eq(16, run); + run = bitset_run_count( map, 0, 16 ); + ck_assert_int_eq( 16, run ); - run = bitset_run_count(map, 16, 64); - ck_assert_int_eq(16, run); + run = bitset_run_count( map, 16, 64 ); + ck_assert_int_eq( 16, run ); - run = bitset_run_count(map, 31, 64); - ck_assert_int_eq(1, run); + run = bitset_run_count( map, 31, 64 ); + ck_assert_int_eq( 1, run ); - run = bitset_run_count(map, 32, 64); - ck_assert_int_eq(32, run); + run = bitset_run_count( map, 32, 64 ); + ck_assert_int_eq( 32, run ); - run = bitset_run_count(map, 32, 32); - ck_assert_int_eq(32, run); + run = bitset_run_count( map, 32, 32 ); + ck_assert_int_eq( 32, run ); - run = bitset_run_count(map, 32, 16); - ck_assert_int_eq(16, run); + run = bitset_run_count( map, 32, 16 ); + ck_assert_int_eq( 16, run ); - bitset_free(map); + bitset_free( map ); - map = bitset_alloc(6400, 100); - assert_bitset_is(map, 0x0000000000000000); + map = bitset_alloc( 6400, 100 ); + assert_bitset_is( map, 0x0000000000000000 ); - run = bitset_run_count(map, 0, 6400); - ck_assert_int_eq(6400, run); + run = bitset_run_count( map, 0, 6400 ); + 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); - ck_assert_int_eq(3200, run); + run = bitset_run_count( map, 0, 6400 ); + ck_assert_int_eq( 3200, run ); - run = bitset_run_count(map, 1, 6400); - ck_assert_int_eq(3199, run); + run = bitset_run_count( map, 1, 6400 ); + ck_assert_int_eq( 3199, run ); - run = bitset_run_count(map, 3200, 6400); - ck_assert_int_eq(3200, run); + run = bitset_run_count( map, 3200, 6400 ); + ck_assert_int_eq( 3200, run ); - run = bitset_run_count(map, 6500, 6400); - ck_assert_int_eq(0, run); - bitset_free(map); + run = bitset_run_count( map, 6500, 6400 ); + ck_assert_int_eq( 0, run ); + bitset_free( map ); - // Now do something large and representative - map = bitset_alloc(53687091200, 4096); - bitset_set(map); - run = bitset_run_count(map, 0, 53687091200); - ck_assert_int_eq(run, 53687091200); + // Now do something large and representative + map = bitset_alloc( 53687091200, 4096 ); + bitset_set( map ); + run = bitset_run_count( map, 0, 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); - bitset_set_range(map, 0, 64); - ck_assert_int_eq(0, bitset_stream_size(map)); - bitset_free(map); + struct bitset *map = bitset_alloc( 64, 1 ); + bitset_set_range( map, 0, 64 ); + ck_assert_int_eq( 0, bitset_stream_size( 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); - bitset_clear_range(map, 0, 64); - ck_assert_int_eq(0, bitset_stream_size(map)); - bitset_free(map); + struct bitset *map = bitset_alloc( 64, 1 ); + bitset_clear_range( map, 0, 64 ); + ck_assert_int_eq( 0, bitset_stream_size( 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_stream_entry result; - memset(&result, 0, sizeof(result)); + struct bitset *map = bitset_alloc( 64, 1 ); + struct bitset_stream_entry 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(0, result.from); - ck_assert_int_eq(64, result.len); + ck_assert_int_eq( BITSET_STREAM_ON, result.event ); + ck_assert_int_eq( 0, result.from ); + 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_stream_entry result; - memset(&result, 0, sizeof(result)); + struct bitset *map = bitset_alloc( 64, 1 ); + struct bitset_stream_entry result; + memset( &result, 0, sizeof( result ) ); - bitset_enable_stream(map); - bitset_disable_stream(map); + bitset_enable_stream( map ); + bitset_disable_stream( map ); - ck_assert_int_eq(0, map->stream_enabled); - ck_assert_int_eq(2, bitset_stream_size(map)); + ck_assert_int_eq( 0, map->stream_enabled ); + ck_assert_int_eq( 2, bitset_stream_size( map ) ); - bitset_stream_dequeue(map, NULL); // ON - bitset_stream_dequeue(map, &result); // OFF + bitset_stream_dequeue( map, NULL ); // ON + bitset_stream_dequeue( map, &result ); // OFF - ck_assert_int_eq(BITSET_STREAM_OFF, result.event); - ck_assert_int_eq(0, result.from); - ck_assert_int_eq(64, result.len); + ck_assert_int_eq( BITSET_STREAM_OFF, result.event ); + ck_assert_int_eq( 0, result.from ); + 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_stream_entry result; - memset(&result, 0, sizeof(result)); + struct bitset *map = bitset_alloc( 64, 1 ); + struct bitset_stream_entry result; + memset( &result, 0, sizeof( result ) ); - bitset_enable_stream(map); - bitset_set_range(map, 0, 32); + bitset_enable_stream( map ); + 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, &result); // SET + bitset_stream_dequeue( map, NULL ); // ON + bitset_stream_dequeue( map, &result ); // SET - ck_assert_int_eq(BITSET_STREAM_SET, result.event); - ck_assert_int_eq(0, result.from); - ck_assert_int_eq(32, result.len); + ck_assert_int_eq( BITSET_STREAM_SET, result.event ); + ck_assert_int_eq( 0, result.from ); + 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_stream_entry result; - memset(&result, 0, sizeof(result)); + struct bitset *map = bitset_alloc( 64, 1 ); + struct bitset_stream_entry result; + memset( &result, 0, sizeof( result ) ); - bitset_enable_stream(map); - bitset_clear_range(map, 0, 32); - ck_assert_int_eq(2, bitset_stream_size(map)); + bitset_enable_stream( map ); + bitset_clear_range( map, 0, 32 ); + ck_assert_int_eq( 2, bitset_stream_size( map ) ); - bitset_stream_dequeue(map, NULL); // ON - bitset_stream_dequeue(map, &result); // UNSET + bitset_stream_dequeue( map, NULL ); // ON + bitset_stream_dequeue( map, &result ); // UNSET - ck_assert_int_eq(BITSET_STREAM_UNSET, result.event); - ck_assert_int_eq(0, result.from); - ck_assert_int_eq(32, result.len); + ck_assert_int_eq( BITSET_STREAM_UNSET, result.event ); + ck_assert_int_eq( 0, result.from ); + 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); - bitset_enable_stream(map); - bitset_set_range(map, 0, 32); - bitset_set_range(map, 16, 32); - bitset_set_range(map, 7, 16); + struct bitset *map = bitset_alloc( 64, 1 ); + bitset_enable_stream( map ); + bitset_set_range( map, 0, 32 ); + bitset_set_range( map, 16, 32 ); + bitset_set_range( map, 7, 16 ); - bitset_clear_range(map, 0, 32); - bitset_clear_range(map, 16, 32); - bitset_clear_range(map, 48, 16); - bitset_disable_stream(map); + bitset_clear_range( map, 0, 32 ); + bitset_clear_range( map, 16, 32 ); + bitset_clear_range( map, 48, 16 ); + 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); - bitset_enable_stream(map); - bitset_set_range(map, 0, 32); - bitset_set_range(map, 16, 32); - bitset_set_range(map, 7, 16); + struct bitset *map = bitset_alloc( 64, 1 ); + bitset_enable_stream( map ); + bitset_set_range( map, 0, 32 ); + bitset_set_range( map, 16, 32 ); + bitset_set_range( map, 7, 16 ); - bitset_clear_range(map, 0, 32); - bitset_clear_range(map, 16, 32); - bitset_clear_range(map, 48, 16); - bitset_clear_range(map, 0, 2); - bitset_disable_stream(map); + bitset_clear_range( map, 0, 32 ); + bitset_clear_range( map, 16, 32 ); + bitset_clear_range( map, 48, 16 ); + bitset_clear_range( map, 0, 2 ); + bitset_disable_stream( map ); - ck_assert_int_eq(64, - bitset_stream_queued_bytes(map, BITSET_STREAM_ON)); - ck_assert_int_eq(80, - bitset_stream_queued_bytes(map, BITSET_STREAM_SET)); - 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); + ck_assert_int_eq( 64, bitset_stream_queued_bytes( map, BITSET_STREAM_ON ) ); + ck_assert_int_eq( 80, bitset_stream_queued_bytes( map, BITSET_STREAM_SET ) ); + 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_add_test(tc_bit, test_bit_set); - tcase_add_test(tc_bit, test_bit_clear); - tcase_add_test(tc_bit, test_bit_tests); - tcase_add_test(tc_bit, test_bit_ranges); - tcase_add_test(tc_bit, test_bit_runs); - suite_add_tcase(s, tc_bit); + TCase *tc_bit = tcase_create("bit"); + tcase_add_test(tc_bit, test_bit_set); + tcase_add_test(tc_bit, test_bit_clear); + tcase_add_test(tc_bit, test_bit_tests); + tcase_add_test(tc_bit, test_bit_ranges); + tcase_add_test(tc_bit, test_bit_runs); + suite_add_tcase(s, tc_bit); - TCase *tc_bitset = tcase_create("bitset"); - tcase_add_test(tc_bitset, test_bitset); - tcase_add_test(tc_bitset, test_bitset_set); - tcase_add_test(tc_bitset, test_bitset_clear); - 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_clear_range); - 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); - suite_add_tcase(s, tc_bitset); + TCase *tc_bitset = tcase_create("bitset"); + tcase_add_test(tc_bitset, test_bitset); + tcase_add_test(tc_bitset, test_bitset_set); + tcase_add_test(tc_bitset, test_bitset_clear); + 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_clear_range); + 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); + suite_add_tcase(s, tc_bitset); - 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_disable_stream); - 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_size); - tcase_add_test(tc_bitset_stream, test_bitset_stream_queued_bytes); - suite_add_tcase(s, tc_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_disable_stream); + 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_size); + tcase_add_test(tc_bitset_stream, test_bitset_stream_queued_bytes); + suite_add_tcase(s, tc_bitset_stream); - return s; + return s; } int main(void) { - int number_failed; - Suite *s = bitset_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; + int number_failed; + Suite *s = bitset_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; } + diff --git a/tests/unit/check_client.c b/tests/unit/check_client.c index 3df7a13..188db10 100644 --- a/tests/unit/check_client.c +++ b/tests/unit/check_client.c @@ -9,104 +9,114 @@ #include -struct server fake_server = { 0 }; - +struct server fake_server = {0}; #define FAKE_SERVER &fake_server #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; - /* can't predict the storage size so we can't allocate one on - * the stack - */ - c = client_create(FAKE_SERVER, FAKE_SOCKET); + struct client * c; + /* can't predict the storage size so we can't allocate one on + * the stack + */ + 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), - "No signal was sent."); + fail_unless( 1 == self_pipe_signal_clear( c->stop_signal ), + "No signal was sent." ); } +END_TEST -END_TEST int fd_is_closed(int); -START_TEST(test_closes_stop_signal) +int fd_is_closed(int); + +START_TEST( test_closes_stop_signal ) { - struct client *c = client_create(FAKE_SERVER, FAKE_SOCKET); - int read_fd = c->stop_signal->read_fd; - int write_fd = c->stop_signal->write_fd; + struct client *c = client_create( FAKE_SERVER, FAKE_SOCKET ); + int read_fd = c->stop_signal->read_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(write_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." ); } +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]; - struct nbd_request nbdr; - pipe(fds); - struct client *c = client_create(FAKE_SERVER, fds[0]); + int fds[2]; + struct nbd_request nbdr; + pipe( fds ); + struct client *c = client_create( FAKE_SERVER, fds[0] ); + + client_signal_stop( c ); - client_signal_stop(c); + int client_serve_request( struct client *); + fail_unless( 1 == client_serve_request( c ), "Didn't quit on stop." ); - int client_serve_request(struct client *); - fail_unless(1 == client_serve_request(c), "Didn't quit on stop."); - - close(fds[0]); - close(fds[1]); + 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_signal = tcase_create("signal"); - TCase *tc_destroy = tcase_create("destroy"); + TCase *tc_create = tcase_create("create"); + TCase *tc_signal = tcase_create("signal"); + TCase *tc_destroy = tcase_create("destroy"); - tcase_add_test(tc_create, test_assigns_socket); - tcase_add_test(tc_create, test_assigns_server); + tcase_add_test(tc_create, test_assigns_socket); + tcase_add_test(tc_create, test_assigns_server); - 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_opens_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_signal); - suite_add_tcase(s, tc_destroy); + suite_add_tcase(s, tc_create); + suite_add_tcase(s, tc_signal); + suite_add_tcase(s, tc_destroy); - return s; + return s; } int main(void) { - 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; + 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; } + diff --git a/tests/unit/check_control.c b/tests/unit/check_control.c index 2afd6dc..fbb2ec9 100644 --- a/tests/unit/check_control.c +++ b/tests/unit/check_control.c @@ -4,36 +4,39 @@ #include -START_TEST(test_assigns_sock_name) +START_TEST( test_assigns_sock_name ) { - struct flexnbd flexnbd = { 0 }; - char csn[] = "foobar"; + struct flexnbd flexnbd = {0}; + 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); - suite_add_tcase(s, tc_create); + tcase_add_test(tc_create, test_assigns_sock_name); + suite_add_tcase( s, tc_create ); - return s; + return s; } int main(void) { - 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; + 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; } + diff --git a/tests/unit/check_flexnbd.c b/tests/unit/check_flexnbd.c index 6c45814..bff82e4 100644 --- a/tests/unit/check_flexnbd.c +++ b/tests/unit/check_flexnbd.c @@ -3,38 +3,42 @@ #include -START_TEST(test_listening_assigns_sock) +START_TEST( test_listening_assigns_sock ) { - struct flexnbd *flexnbd = flexnbd_create_listening("127.0.0.1", - "4777", - "fakefile", - "fakesock", - 0, - 0, - NULL); - fail_if(NULL == flexnbd->control->socket_name, "No socket was copied"); + struct flexnbd * flexnbd = flexnbd_create_listening( + "127.0.0.1", + "4777", + "fakefile", + "fakesock", + 0, + 0, + NULL ); + 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); - suite_add_tcase(s, tc_create); + tcase_add_test(tc_create, test_listening_assigns_sock); + suite_add_tcase( s, tc_create ); - return s; + return s; } int main(void) { - 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; + 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; } + diff --git a/tests/unit/check_flexthread.c b/tests/unit/check_flexthread.c index d6535a9..092ab5b 100644 --- a/tests/unit/check_flexthread.c +++ b/tests/unit/check_flexthread.c @@ -4,57 +4,59 @@ #include -START_TEST(test_mutex_create) +START_TEST( test_mutex_create ) { - struct flexthread_mutex *ftm = flexthread_mutex_create(); - NULLCHECK(ftm); - flexthread_mutex_destroy(ftm); + struct flexthread_mutex * ftm = flexthread_mutex_create(); + NULLCHECK( 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"); - flexthread_mutex_lock(ftm); - fail_unless(flexthread_mutex_held(ftm), - "Flexthread_mutex is not held inside lock"); - flexthread_mutex_unlock(ftm); - fail_if(flexthread_mutex_held(ftm), - "Flexthread_mutex is held after unlock"); + fail_if( flexthread_mutex_held( ftm ), "Flexthread_mutex is held before lock" ); + flexthread_mutex_lock( ftm ); + fail_unless( flexthread_mutex_held( ftm ), "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"); - TCase *tc_create = tcase_create("create"); - TCase *tc_destroy = tcase_create("destroy"); + Suite *s = suite_create("flexthread"); + TCase *tc_create = tcase_create("create"); + TCase *tc_destroy = tcase_create("destroy"); - tcase_add_test(tc_create, test_mutex_create); - tcase_add_test(tc_create, test_mutex_lock); + tcase_add_test( tc_create, test_mutex_create ); + tcase_add_test( tc_create, test_mutex_lock ); - suite_add_tcase(s, tc_create); - suite_add_tcase(s, tc_destroy); + suite_add_tcase(s, tc_create); + suite_add_tcase(s, tc_destroy); - return s; + return s; } int main(void) { #ifdef DEBUG - log_level = 0; + log_level = 0; #else - log_level = 2; + log_level = 2; #endif - int number_failed; - Suite *s = flexthread_suite(); - SRunner *sr = srunner_create(s); - srunner_run_all(sr, CK_NORMAL); - log_level = 0; - number_failed = srunner_ntests_failed(sr); - srunner_free(sr); - return (number_failed == 0) ? 0 : 1; + int number_failed; + Suite *s = flexthread_suite(); + SRunner *sr = srunner_create(s); + srunner_run_all(sr, CK_NORMAL); + log_level = 0; + number_failed = srunner_ntests_failed(sr); + srunner_free(sr); + return (number_failed == 0) ? 0 : 1; } + diff --git a/tests/unit/check_ioutil.c b/tests/unit/check_ioutil.c index dbe75ab..b1f26a5 100644 --- a/tests/unit/check_ioutil.c +++ b/tests/unit/check_ioutil.c @@ -2,125 +2,133 @@ #include -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 nread; - char buf[5] = { 0 }; - pipe(fds); + int fds[2]; + int nread; + char buf[5] = {0}; + pipe(fds); - write(fds[1], "1234\n", 5); + write( fds[1], "1234\n", 5 ); + + nread = read_until_newline( fds[0], buf, 5 ); - nread = read_until_newline(fds[0], buf, 5); - - ck_assert_int_eq(5, nread); + 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 nread; - char buf[5] = { 0 }; - pipe(fds); + int fds[2]; + int nread; + char buf[5] = {0}; + pipe(fds); - write(fds[1], "1234\n", 5); + write( fds[1], "1234\n", 5 ); + + nread = read_until_newline( fds[0], buf, 5 ); - nread = read_until_newline(fds[0], buf, 5); - - ck_assert_int_eq('\0', buf[4]); + 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 nread; - char buf[5] = { 0 }; - pipe(fds); + int fds[2]; + int nread; + char buf[5] = {0}; + pipe(fds); - write(fds[1], "\n", 1); - nread = read_until_newline(fds[0], buf, 1); + write( fds[1], "\n", 1 ); + nread = read_until_newline( fds[0], buf, 1 ); - ck_assert_int_eq('\0', buf[0]); - ck_assert_int_eq(1, nread); + ck_assert_int_eq( '\0', buf[0] ); + 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 nread; - char buf[5] = { 0 }; - pipe(fds); + int fds[2]; + int nread; + char buf[5] = {0}; + pipe( fds ); - close(fds[1]); - nread = read_until_newline(fds[0], buf, 5); + close( fds[1] ); + 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 nread; - char buf[5] = { 0 }; - pipe(fds); + int fds[2]; + int nread; + char buf[5] = {0}; + pipe(fds); - write(fds[1], "1234", 4); - close(fds[1]); - nread = read_until_newline(fds[0], buf, 5); + write( fds[1], "1234", 4 ); + close( fds[1] ); + nread = read_until_newline( fds[0], buf, 5 ); - ck_assert_int_eq(-1, nread); - ck_assert_int_eq('4', buf[3]); + ck_assert_int_eq( -1, nread ); + 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; - int fds[2]; - int nlines; - pipe(fds); + char **lines = NULL; + int fds[2]; + int nlines; + 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_lines_until_blankline = - tcase_create("read_lines_until_blankline"); + TCase *tc_read_until_newline = tcase_create("read_until_newline"); + 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, - test_read_until_newline_inserts_null); - 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_until_newline, test_read_until_newline_returns_line_length_plus_null); + tcase_add_test(tc_read_until_newline, test_read_until_newline_inserts_null); + 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_lines_until_blankline); + suite_add_tcase(s, tc_read_until_newline); + suite_add_tcase(s, tc_read_lines_until_blankline); - return s; + return s; } int main(void) { - 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; + 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; } + diff --git a/tests/unit/check_mbox.c b/tests/unit/check_mbox.c index 0d6c3d3..5399531 100644 --- a/tests/unit/check_mbox.c +++ b/tests/unit/check_mbox.c @@ -4,76 +4,83 @@ #include #include -START_TEST(test_allocs_cvar) +START_TEST( test_allocs_cvar ) { - struct mbox *mbox = mbox_create(); - fail_if(NULL == mbox, "Nothing allocated"); + struct mbox * mbox = mbox_create(); + fail_if( NULL == mbox, "Nothing allocated" ); - pthread_cond_t cond_zero; - /* A freshly inited pthread_cond_t is set to {0} */ - memset(&cond_zero, 'X', sizeof(cond_zero)); - fail_if(memcmp(&cond_zero, &mbox->filled_cond, sizeof(cond_zero)) == 0, - "Condition variable not allocated"); - fail_if(memcmp(&cond_zero, &mbox->emptied_cond, sizeof(cond_zero)) == - 0, "Condition variable not allocated"); + pthread_cond_t cond_zero; + /* A freshly inited pthread_cond_t is set to {0} */ + memset( &cond_zero, 'X', sizeof( cond_zero ) ); + fail_if( memcmp( &cond_zero, &mbox->filled_cond, sizeof( cond_zero ) ) == 0 , + "Condition variable not allocated" ); + fail_if( memcmp( &cond_zero, &mbox->emptied_cond, sizeof( cond_zero ) ) == 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 ); - void *deadbeef = (void *) 0xDEADBEEF; - mbox_post(mbox, deadbeef); - - fail_unless(deadbeef == mbox_contents(mbox), - "Contents were not posted"); + 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; - void *contents = NULL; + struct mbox * mbox = (struct mbox *)mbox_uncast; + void * contents = NULL; - contents = mbox_receive(mbox); - return contents; + contents = mbox_receive( mbox ); + return contents; } -START_TEST(test_receive_blocks_until_post) +START_TEST( test_receive_blocks_until_post ) { - struct mbox *mbox = mbox_create(); - pthread_t receiver; - pthread_create(&receiver, NULL, mbox_receive_runner, mbox); + struct mbox * mbox = mbox_create(); + pthread_t receiver; + 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"); - 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); - fail_unless(0 == pthread_join(receiver, &retval), - "Failed to join the receiver thread"); - fail_unless(retval == deadbeef, "Return value was wrong"); + 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"); - TCase *tc_create = tcase_create("create"); - TCase *tc_post = tcase_create("post"); + Suite *s = suite_create("mbox"); + TCase *tc_create = tcase_create("create"); + 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_receive_blocks_until_post); + tcase_add_test( tc_post, test_post_stores_value ); + tcase_add_test( tc_post, test_receive_blocks_until_post); - suite_add_tcase(s, tc_create); - suite_add_tcase(s, tc_post); + suite_add_tcase(s, tc_create); + suite_add_tcase(s, tc_post); - return s; + return s; } @@ -81,16 +88,17 @@ END_TEST Suite * mbox_suite(void) int main(void) { #ifdef DEBUG - log_level = 0; + log_level = 0; #else - log_level = 2; + log_level = 2; #endif - int number_failed; - Suite *s = mbox_suite(); - SRunner *sr = srunner_create(s); - srunner_run_all(sr, CK_NORMAL); - log_level = 0; - number_failed = srunner_ntests_failed(sr); - srunner_free(sr); - return (number_failed == 0) ? 0 : 1; + int number_failed; + Suite *s = mbox_suite(); + SRunner *sr = srunner_create(s); + srunner_run_all(sr, CK_NORMAL); + log_level = 0; + number_failed = srunner_ntests_failed(sr); + srunner_free(sr); + return (number_failed == 0) ? 0 : 1; } + diff --git a/tests/unit/check_nbdtypes.c b/tests/unit/check_nbdtypes.c index b1ee034..9124063 100644 --- a/tests/unit/check_nbdtypes.c +++ b/tests/unit/check_nbdtypes.c @@ -4,246 +4,257 @@ START_TEST(test_init_passwd) { - struct nbd_init_raw init_raw; - struct nbd_init init; + struct nbd_init_raw init_raw; + struct nbd_init init; - memcpy(init_raw.passwd, INIT_PASSWD, 8); - - nbd_r2h_init(&init_raw, &init); - memset(init_raw.passwd, 0, 8); - nbd_h2r_init(&init, &init_raw); - - fail_unless(memcmp(init.passwd, INIT_PASSWD, 8) == 0, - "The password was not copied."); - fail_unless(memcmp(init_raw.passwd, INIT_PASSWD, 8) == 0, - "The password was not copied back."); + memcpy( init_raw.passwd, INIT_PASSWD, 8 ); + + nbd_r2h_init( &init_raw, &init ); + memset( init_raw.passwd, 0, 8 ); + nbd_h2r_init( &init, &init_raw ); + + fail_unless( memcmp( init.passwd, INIT_PASSWD, 8 ) == 0, "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 init; + struct nbd_init_raw init_raw; + struct nbd_init init; - init_raw.magic = 12345; - nbd_r2h_init(&init_raw, &init); - fail_unless(be64toh(12345) == init.magic, "Magic was not converted."); + init_raw.magic = 12345; + nbd_r2h_init( &init_raw, &init ); + fail_unless( be64toh( 12345 ) == init.magic, "Magic was not converted." ); - init.magic = 67890; - nbd_h2r_init(&init, &init_raw); - fail_unless(htobe64(67890) == init_raw.magic, - "Magic was not converted back."); + init.magic = 67890; + nbd_h2r_init( &init, &init_raw ); + 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 init; + struct nbd_init_raw init_raw; + struct nbd_init init; - init_raw.size = 12345; - nbd_r2h_init(&init_raw, &init); - fail_unless(be64toh(12345) == init.size, "Size was not converted."); + init_raw.size = 12345; + nbd_r2h_init( &init_raw, &init ); + fail_unless( be64toh( 12345 ) == init.size, "Size was not converted." ); - init.size = 67890; - nbd_h2r_init(&init, &init_raw); - fail_unless(htobe64(67890) == init_raw.size, - "Size was not converted back."); + init.size = 67890; + nbd_h2r_init( &init, &init_raw ); + 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 request; + struct nbd_request_raw request_raw; + struct nbd_request request; - request_raw.magic = 12345; - nbd_r2h_request(&request_raw, &request); - fail_unless(be32toh(12345) == request.magic, - "Magic was not converted."); + request_raw.magic = 12345; + nbd_r2h_request( &request_raw, &request ); + fail_unless( be32toh( 12345 ) == request.magic, "Magic was not converted." ); - request.magic = 67890; - nbd_h2r_request(&request, &request_raw); - fail_unless(htobe32(67890) == request_raw.magic, - "Magic was not converted back."); + request.magic = 67890; + nbd_h2r_request( &request, &request_raw ); + 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 request; + struct nbd_request_raw request_raw; + struct nbd_request request; - request_raw.type = 123; - nbd_r2h_request(&request_raw, &request); - fail_unless(be16toh(123) == request.type, "Type was not converted."); + request_raw.type = 123; + nbd_r2h_request( &request_raw, &request ); + fail_unless( be16toh( 123 ) == request.type, "Type was not converted." ); - request.type = 234; - nbd_h2r_request(&request, &request_raw); - fail_unless(htobe16(234) == request_raw.type, - "Type was not converted back."); + request.type = 234; + nbd_h2r_request( &request, &request_raw ); + 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 request; + struct nbd_request_raw request_raw; + struct nbd_request request; - request_raw.flags = 123; - nbd_r2h_request(&request_raw, &request); - fail_unless(be16toh(123) == request.flags, - "Flags were not converted."); + request_raw.flags = 123; + nbd_r2h_request( &request_raw, &request ); + fail_unless( be16toh( 123 ) == request.flags, "Flags were not converted." ); - request.flags = 234; - nbd_h2r_request(&request, &request_raw); - fail_unless(htobe16(234) == request_raw.flags, - "Flags were not converted back."); + request.flags = 234; + nbd_h2r_request( &request, &request_raw ); + 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 request; + struct nbd_request_raw request_raw; + struct nbd_request request; - memcpy(request_raw.handle.b, "MYHANDLE", 8); - - nbd_r2h_request(&request_raw, &request); - request_raw.handle.w = 0; - nbd_h2r_request(&request, &request_raw); - - fail_unless(memcmp(request.handle.b, "MYHANDLE", 8) == 0, - "The handle was not copied."); - fail_unless(memcmp(request_raw.handle.b, "MYHANDLE", 8) == 0, - "The handle was not copied back."); + memcpy( request_raw.handle.b, "MYHANDLE", 8 ); + + nbd_r2h_request( &request_raw, &request ); + request_raw.handle.w = 0; + nbd_h2r_request( &request, &request_raw ); + + fail_unless( memcmp( request.handle.b, "MYHANDLE", 8 ) == 0, "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 request; + struct nbd_request_raw request_raw; + struct nbd_request request; - request_raw.from = 12345; - nbd_r2h_request(&request_raw, &request); - fail_unless(be64toh(12345) == request.from, "From was not converted."); + request_raw.from = 12345; + nbd_r2h_request( &request_raw, &request ); + fail_unless( be64toh( 12345 ) == request.from, "From was not converted." ); - request.from = 67890; - nbd_h2r_request(&request, &request_raw); - fail_unless(htobe64(67890) == request_raw.from, - "From was not converted back."); + request.from = 67890; + nbd_h2r_request( &request, &request_raw ); + 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 request; + struct nbd_request_raw request_raw; + struct nbd_request request; - request_raw.len = 12345; - nbd_r2h_request(&request_raw, &request); - fail_unless(be32toh(12345) == request.len, "Type was not converted."); + request_raw.len = 12345; + nbd_r2h_request( &request_raw, &request ); + fail_unless( be32toh( 12345 ) == request.len, "Type was not converted." ); - request.len = 67890; - nbd_h2r_request(&request, &request_raw); - fail_unless(htobe32(67890) == request_raw.len, - "Type was not converted back."); + request.len = 67890; + nbd_h2r_request( &request, &request_raw ); + 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 reply; + struct nbd_reply_raw reply_raw; + struct nbd_reply reply; - reply_raw.magic = 12345; - nbd_r2h_reply(&reply_raw, &reply); - fail_unless(be32toh(12345) == reply.magic, "Magic was not converted."); + reply_raw.magic = 12345; + nbd_r2h_reply( &reply_raw, &reply ); + fail_unless( be32toh( 12345 ) == reply.magic, "Magic was not converted." ); - reply.magic = 67890; - nbd_h2r_reply(&reply, &reply_raw); - fail_unless(htobe32(67890) == reply_raw.magic, - "Magic was not converted back."); + reply.magic = 67890; + nbd_h2r_reply( &reply, &reply_raw ); + 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 reply; + struct nbd_reply_raw reply_raw; + struct nbd_reply reply; - reply_raw.error = 12345; - nbd_r2h_reply(&reply_raw, &reply); - fail_unless(be32toh(12345) == reply.error, "Error was not converted."); + reply_raw.error = 12345; + nbd_r2h_reply( &reply_raw, &reply ); + fail_unless( be32toh( 12345 ) == reply.error, "Error was not converted." ); - reply.error = 67890; - nbd_h2r_reply(&reply, &reply_raw); - fail_unless(htobe32(67890) == reply_raw.error, - "Error was not converted back."); + reply.error = 67890; + nbd_h2r_reply( &reply, &reply_raw ); + 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 reply; + struct nbd_reply_raw reply_raw; + struct nbd_reply reply; - memcpy(reply_raw.handle.b, "MYHANDLE", 8); - - nbd_r2h_reply(&reply_raw, &reply); - reply_raw.handle.w = 0; - nbd_h2r_reply(&reply, &reply_raw); - - fail_unless(memcmp(reply.handle.b, "MYHANDLE", 8) == 0, - "The handle was not copied."); - fail_unless(memcmp(reply_raw.handle.b, "MYHANDLE", 8) == 0, - "The handle was not copied back."); + memcpy( reply_raw.handle.b, "MYHANDLE", 8 ); + + nbd_r2h_reply( &reply_raw, &reply ); + reply_raw.handle.w = 0; + nbd_h2r_reply( &reply, &reply_raw ); + + fail_unless( memcmp( reply.handle.b, "MYHANDLE", 8 ) == 0, "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 - * nbd_request_raw */ - struct nbd_request_raw request_raw; - struct nbd_request request; + /* Check that we can correctly pull numbers out of an + * nbd_request_raw */ + struct nbd_request_raw request_raw; + struct nbd_request request; - uint64_t target = 0x8000000000000000; + uint64_t target = 0x8000000000000000; - /* this is stored big-endian */ - request_raw.from = htobe64(target); + /* this is stored big-endian */ + request_raw.from = htobe64(target); - /* We expect this to convert big-endian to the host format */ - nbd_r2h_request(&request_raw, &request); + /* We expect this to convert big-endian to the host format */ + 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"); - TCase *tc_init = tcase_create("nbd_init"); - TCase *tc_request = tcase_create("nbd_request"); - TCase *tc_reply = tcase_create("nbd_reply"); + Suite *s = suite_create( "nbdtypes" ); + TCase *tc_init = tcase_create( "nbd_init" ); + TCase *tc_request = tcase_create( "nbd_request" ); + TCase *tc_reply = tcase_create( "nbd_reply" ); - tcase_add_test(tc_init, test_init_passwd); - tcase_add_test(tc_init, test_init_magic); - tcase_add_test(tc_init, test_init_size); - tcase_add_test(tc_request, test_request_magic); - tcase_add_test(tc_request, test_request_type); - tcase_add_test(tc_request, test_request_handle); - tcase_add_test(tc_request, test_request_from); - tcase_add_test(tc_request, test_request_len); - tcase_add_test(tc_request, test_convert_from); - tcase_add_test(tc_reply, test_reply_magic); - tcase_add_test(tc_reply, test_reply_error); - tcase_add_test(tc_reply, test_reply_handle); + tcase_add_test( tc_init, test_init_passwd ); + tcase_add_test( tc_init, test_init_magic ); + tcase_add_test( tc_init, test_init_size ); + tcase_add_test( tc_request, test_request_magic ); + tcase_add_test( tc_request, test_request_type ); + tcase_add_test( tc_request, test_request_handle ); + tcase_add_test( tc_request, test_request_from ); + tcase_add_test( tc_request, test_request_len ); + tcase_add_test( tc_request, test_convert_from ); + tcase_add_test( tc_reply, test_reply_magic ); + tcase_add_test( tc_reply, test_reply_error ); + tcase_add_test( tc_reply, test_reply_handle ); - suite_add_tcase(s, tc_init); - suite_add_tcase(s, tc_request); - suite_add_tcase(s, tc_reply); + suite_add_tcase( s, tc_init ); + suite_add_tcase( s, tc_request ); + suite_add_tcase( s, tc_reply ); - return s; + return s; } int main(void) { - int number_failed; - Suite *s = nbdtypes_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; + int number_failed; + Suite *s = nbdtypes_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; } + diff --git a/tests/unit/check_parse.c b/tests/unit/check_parse.c index 3d9130a..b30ee6d 100644 --- a/tests/unit/check_parse.c +++ b/tests/unit/check_parse.c @@ -3,41 +3,45 @@ #include -START_TEST(test_can_parse_ip_address_twice) +START_TEST( test_can_parse_ip_address_twice ) { - char ip_address[] = "127.0.0.1"; - struct sockaddr saddr; + char ip_address[] = "127.0.0.1"; + 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"); - TCase *tc_create = tcase_create("ip_to_sockaddr"); + Suite *s = suite_create("parse"); + 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 -#define LOG_LEVEL 0 +# define LOG_LEVEL 0 #else -#define LOG_LEVEL 2 +# define LOG_LEVEL 2 #endif int main(void) { - log_level = LOG_LEVEL; - int number_failed; - Suite *s = parse_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; + log_level = LOG_LEVEL; + int number_failed; + Suite *s = parse_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; } + diff --git a/tests/unit/check_readwrite.c b/tests/unit/check_readwrite.c index 9f20bf9..c158d7b 100644 --- a/tests/unit/check_readwrite.c +++ b/tests/unit/check_readwrite.c @@ -21,169 +21,173 @@ -int fd_read_request(int, struct nbd_request_raw *); -int fd_write_reply(int, uint64_t, int); +int fd_read_request( int, struct nbd_request_raw *); +int fd_write_reply( int, uint64_t, int ); int marker; -void error_marker(void *unused __attribute__ ((unused)), - int fatal __attribute__ ((unused))) +void error_marker(void * unused __attribute__((unused)), + int fatal __attribute__((unused))) { - marker = 1; - return; + marker = 1; + return; } struct respond { - int sock_fds[2]; // server end - int do_fail; - pthread_t thread_id; - pthread_attr_t thread_attr; - struct nbd_request received; + int sock_fds[2]; // server end + int do_fail; + pthread_t thread_id; + pthread_attr_t thread_attr; + struct nbd_request received; }; -void *responder(void *respond_uncast) +void * responder( void *respond_uncast ) { - struct respond *resp = (struct respond *) respond_uncast; - int sock_fd = resp->sock_fds[1]; - struct nbd_request_raw request_raw; - uint64_t wrong_handle = 0x80; + struct respond * resp = (struct respond *) respond_uncast; + int sock_fd = resp->sock_fds[1]; + struct nbd_request_raw request_raw; + uint64_t wrong_handle = 0x80; - if (fd_read_request(sock_fd, &request_raw) == -1) { - 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); + if( fd_read_request( sock_fd, &request_raw ) == -1){ + fprintf(stderr, "Problem with fd_read_request\n"); } else { - fd_write_reply(sock_fd, resp->received.handle.w, 0); + nbd_r2h_request( &request_raw, &resp->received); + 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 ); } - write(sock_fd, "12345678", 8); - } - return NULL; + 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)); - socketpair(PF_UNIX, SOCK_STREAM, 0, respond->sock_fds); - respond->do_fail = do_fail; + struct respond * respond = (struct respond *)calloc( 1, sizeof( struct respond ) ); + socketpair( PF_UNIX, SOCK_STREAM, 0, respond->sock_fds ); + respond->do_fail = do_fail; - pthread_attr_init(&respond->thread_attr); - pthread_create(&respond->thread_id, &respond->thread_attr, responder, - respond); + pthread_attr_init( &respond->thread_attr ); + pthread_create( &respond->thread_id, &respond->thread_attr, responder, respond ); - return respond; + return respond; } -void respond_destroy(struct respond *respond) -{ - NULLCHECK(respond); +void respond_destroy( struct respond * respond ){ + NULLCHECK( respond ); - pthread_join(respond->thread_id, NULL); - pthread_attr_destroy(&respond->thread_attr); + pthread_join( respond->thread_id, NULL ); + pthread_attr_destroy( &respond->thread_attr ); - close(respond->sock_fds[0]); - close(respond->sock_fds[1]); - free(respond); + close( respond->sock_fds[0] ); + close( respond->sock_fds[1] ); + free( respond ); } -void *reader(void *nothing __attribute__ ((unused))) +void * reader( void * nothing __attribute__((unused))) { - DECLARE_ERROR_CONTEXT(error_context); - error_set_handler((cleanup_handler *) error_marker, error_context); + 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 }; + 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); + socket_nbd_read( respond->sock_fds[0], 0, 8, devnull, outbuf, 1 ); - return NULL; + return NULL; } -START_TEST(test_rejects_mismatched_handle) +START_TEST( test_rejects_mismatched_handle ) { - error_init(); - pthread_t reader_thread; + error_init(); + 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; - 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"); + 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); - char outbuf[8] = { 0 }; + int devnull = open("/dev/null", O_WRONLY); + 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"); - TCase *tc_transfer = tcase_create("entrust"); - TCase *tc_disconnect = tcase_create("disconnect"); + Suite *s = suite_create("readwrite"); + TCase *tc_transfer = tcase_create("entrust"); + TCase *tc_disconnect = tcase_create("disconnect"); - tcase_add_test(tc_transfer, test_rejects_mismatched_handle); - tcase_add_exit_test(tc_transfer, test_accepts_matched_handle, 0); + tcase_add_test(tc_transfer, test_rejects_mismatched_handle); + tcase_add_exit_test(tc_transfer, test_accepts_matched_handle, 0); - /* This test is a little funny. We respond with a dodgy handle - * and check that this *doesn't* cause a message rejection, - * because we want to know that the sender won't even try to - * read the response. - */ - tcase_add_exit_test(tc_disconnect, test_disconnect_doesnt_read_reply, - 0); + /* This test is a little funny. We respond with a dodgy handle + * and check that this *doesn't* cause a message rejection, + * because we want to know that the sender won't even try to + * read the response. + */ + tcase_add_exit_test( tc_disconnect, test_disconnect_doesnt_read_reply,0 ); - suite_add_tcase(s, tc_transfer); - suite_add_tcase(s, tc_disconnect); + suite_add_tcase(s, tc_transfer); + suite_add_tcase(s, tc_disconnect); - return s; + return s; } #ifdef DEBUG -#define LOG_LEVEL 0 +# define LOG_LEVEL 0 #else -#define LOG_LEVEL 2 +# define LOG_LEVEL 2 #endif int main(void) { - log_level = LOG_LEVEL; - int number_failed; - Suite *s = readwrite_suite(); - SRunner *sr = srunner_create(s); - srunner_run_all(sr, CK_NORMAL); - log_level = 0; - number_failed = srunner_ntests_failed(sr); - srunner_free(sr); - return (number_failed == 0) ? 0 : 1; + log_level = LOG_LEVEL; + int number_failed; + Suite *s = readwrite_suite(); + SRunner *sr = srunner_create(s); + srunner_run_all(sr, CK_NORMAL); + log_level = 0; + number_failed = srunner_ntests_failed(sr); + srunner_free(sr); + return (number_failed == 0) ? 0 : 1; } + diff --git a/tests/unit/check_self_pipe.c b/tests/unit/check_self_pipe.c index fcc783f..c3026c9 100644 --- a/tests/unit/check_self_pipe.c +++ b/tests/unit/check_self_pipe.c @@ -9,180 +9,190 @@ #include "self_pipe.h" -START_TEST(test_opens_pipe) +START_TEST( test_opens_pipe ) { - struct self_pipe *sig; - char buf[] = " "; + struct self_pipe* sig; + char buf[] = " "; - sig = self_pipe_create(); + sig = self_pipe_create(); - write(sig->write_fd, "1", 1); - read(sig->read_fd, buf, 1); + write( sig->write_fd, "1", 1 ); + read( sig->read_fd, buf, 1 ); - fail_unless(buf[0] == '1', "Pipe does not seem to be open;"); - self_pipe_destroy(sig); + fail_unless( buf[0] == '1', "Pipe does not seem to be open;" ); + self_pipe_destroy( sig ); +} +END_TEST + + +void * signal_thread( void * thing ) +{ + struct self_pipe *sig = (struct self_pipe *)thing; + usleep( 100000 ); + self_pipe_signal( sig ); + return NULL; } -END_TEST void *signal_thread(void *thing) +pthread_t start_signal_thread( struct self_pipe *sig ) { - struct self_pipe *sig = (struct self_pipe *) thing; - usleep(100000); - self_pipe_signal(sig); - return NULL; -} + pthread_attr_t attr; + pthread_t thread_id; -pthread_t start_signal_thread(struct self_pipe * sig) -{ - pthread_attr_t attr; - pthread_t thread_id; + pthread_attr_init( &attr ); + pthread_create( &thread_id, &attr, signal_thread, sig ); + pthread_attr_destroy( &attr ); - pthread_attr_init(&attr); - pthread_create(&thread_id, &attr, signal_thread, sig); - pthread_attr_destroy(&attr); - - return thread_id; + return thread_id; } -START_TEST(test_signals) +START_TEST( test_signals ) { - struct self_pipe *sig; - fd_set fds; - pthread_t signal_thread_id; + struct self_pipe* sig; + fd_set fds; + pthread_t signal_thread_id; - sig = self_pipe_create(); + sig = self_pipe_create(); - FD_ZERO(&fds); - self_pipe_fd_set(sig, &fds); + FD_ZERO( &fds ); + self_pipe_fd_set( sig, &fds ); - signal_thread_id = start_signal_thread(sig); - if (select(FD_SETSIZE, &fds, NULL, NULL, NULL) == -1) { - 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; + signal_thread_id = start_signal_thread( sig ); + if ( select( FD_SETSIZE, &fds, NULL, NULL, NULL ) == -1 ) { + fail( strerror(errno) ); } - break; - default: - fail("The read fd wasn't closed, and had data in it."); - break; - } + 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 -END_TEST START_TEST(test_destroy_closes_write_pipe) + +START_TEST( test_clear_returns_immediately ) { - struct self_pipe *sig; - ssize_t write_len; - int orig_write_fd; + struct self_pipe *sig; + sig = self_pipe_create(); + fail_unless( 0 == self_pipe_signal_clear( sig ), "Wrong clear result." ); +} +END_TEST - 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); +START_TEST( test_destroy_closes_read_pipe ) +{ + struct self_pipe* sig; + ssize_t read_len; + int orig_read_fd; - 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; + 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; + } + break; + default: + fail( "The read fd wasn't closed, and had data in it." ); + break; } - break; - default: - /* To get here, the write(_,_,0) would have to - * write some bytes. +} +END_TEST + + +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); + suite_add_tcase(s, tc_destroy); -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. - */ - - suite_add_tcase(s, tc_create); - suite_add_tcase(s, tc_signal); - suite_add_tcase(s, tc_destroy); - - return s; + return s; } int main(void) { - 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; + 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; } + diff --git a/tests/unit/check_serve.c b/tests/unit/check_serve.c index e0a2a67..b00bb1a 100644 --- a/tests/unit/check_serve.c +++ b/tests/unit/check_serve.c @@ -15,9 +15,9 @@ #include #ifdef DEBUG -#define LOG_LEVEL 0 +# define LOG_LEVEL 0 #else -#define LOG_LEVEL 2 +# define LOG_LEVEL 2 #endif @@ -28,245 +28,237 @@ #define myfail_if( tst, msg ) do { if( tst ) { myfail( msg ); } } while (0) #define myfail_unless( tst, msg ) myfail_if( !(tst), msg ) -char *dummy_file; +char * dummy_file; char *make_tmpfile(void) { - FILE *fp; - char *fn_buf; - char leader[] = "/tmp/check_serve"; + FILE *fp; + char *fn_buf; + char leader[] = "/tmp/check_serve"; - fn_buf = (char *) malloc(1024); - strncpy(fn_buf, leader, sizeof(leader) - 1); - snprintf(&fn_buf[sizeof(leader) - 1], 10, "%d", getpid()); - fp = fopen(fn_buf, "w"); - fwrite(fn_buf, 1024, 1, fp); - fclose(fp); + fn_buf = (char *)malloc( 1024 ); + strncpy( fn_buf, leader, sizeof( leader ) - 1); + snprintf( &fn_buf[sizeof( leader ) - 1], 10, "%d", getpid() ); + fp = fopen( fn_buf, "w" ); + fwrite( fn_buf, 1024, 1, 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); - } - free(dummy_file); - dummy_file = NULL; + if( dummy_file ){ unlink( dummy_file ); } + free( dummy_file ); + dummy_file = NULL; } -START_TEST(test_replaces_acl) +START_TEST( test_replaces_acl ) { - struct flexnbd flexnbd; - flexnbd.signal_fd = -1; - struct server *s = - 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); + struct flexnbd flexnbd; + flexnbd.signal_fd = -1; + struct server * s = 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."); - server_destroy(s); + myfail_unless( s->acl == new_acl, "ACL wasn't replaced." ); + server_destroy( s ); } +END_TEST -END_TEST START_TEST(test_signals_acl_updated) + +START_TEST( test_signals_acl_updated ) { - struct flexnbd flexnbd; - flexnbd.signal_fd = -1; - struct server *s = - 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); + struct flexnbd flexnbd; + flexnbd.signal_fd = -1; + struct server * s = 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), - "No signal sent."); - server_destroy(s); + myfail_unless( 1 == self_pipe_signal_clear( s->acl_updated_signal ), + "No signal sent." ); + 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 *ailist, *aip; + struct addrinfo hint; + struct addrinfo *ailist, *aip; - memset(&hint, '\0', sizeof(struct addrinfo)); - hint.ai_socktype = SOCK_STREAM; + memset( &hint, '\0', sizeof( struct addrinfo ) ); + 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; - for (aip = ailist; aip; aip = aip->ai_next) { - ((struct sockaddr_in *) aip->ai_addr)->sin_port = - htons(actual_port); - client_fd = - socket(aip->ai_family, aip->ai_socktype, aip->ai_protocol); + int connected = 0; + for( aip = ailist; aip; aip = aip->ai_next ) { + ((struct sockaddr_in *)aip->ai_addr)->sin_port = htons( actual_port ); + client_fd = socket( aip->ai_family, aip->ai_socktype, aip->ai_protocol ); - if (source_addr) { - struct sockaddr src; - if (!parse_ip_to_sockaddr(&src, source_addr)) { - close(client_fd); - continue; - } - bind(client_fd, &src, sizeof(struct sockaddr_in6)); + if (source_addr) { + struct sockaddr src; + if( !parse_ip_to_sockaddr(&src, source_addr)) { + close(client_fd); + continue; + } + 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 ); } - 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."); - return client_fd; + myfail_unless( connected, "Didn't connect." ); + return client_fd; } /* These are "internal" functions we need for the following test. We * shouldn't need them but there's no other way at the moment. */ -void serve_open_server_socket(struct server *); -int server_port(struct server *); -void server_accept(struct server *); -int fd_is_closed(int); -void server_close_clients(struct server *); +void serve_open_server_socket( struct server * ); +int server_port( struct server * ); +void server_accept( struct server * ); +int fd_is_closed( int ); +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 - * and socket out of the server structure, we should be testing - * a client socket. - */ - struct flexnbd flexnbd; - flexnbd.signal_fd = -1; - struct server *s = - server_create(&flexnbd, "127.0.0.7", "0", dummy_file, 0, 0, NULL, - 1, 0, 1); - struct acl *new_acl = acl_create(0, NULL, 1); - struct client *c; - struct client_tbl_entry *entry; + /* This is the wrong way round. Rather than pulling the thread + * and socket out of the server structure, we should be testing + * a client socket. + */ + struct flexnbd flexnbd; + flexnbd.signal_fd = -1; + struct server * s = server_create( &flexnbd, "127.0.0.7", "0", dummy_file, 0, 0, NULL, 1, 0, 1 ); + struct acl * new_acl = acl_create( 0, NULL, 1 ); + struct client * c; + struct client_tbl_entry * entry; - int actual_port; - int client_fd; - int server_fd; + int actual_port; + int client_fd; + int server_fd; - serve_open_server_socket(s); - actual_port = server_port(s); + serve_open_server_socket( s ); + actual_port = server_port( s ); - client_fd = connect_client("127.0.0.7", actual_port, "127.0.0.1"); - server_accept(s); - entry = &s->nbd_client[0]; - c = entry->client; - /* At this point there should be an entry in the nbd_clients - * table and a background thread to run the client loop - */ - myfail_if(entry->thread == 0, "No client thread was started."); - server_fd = c->socket; - myfail_if(fd_is_closed(server_fd), - "Sanity check failed - client socket wasn't open."); + client_fd = connect_client( "127.0.0.7", actual_port, "127.0.0.1" ); + server_accept( s ); + entry = &s->nbd_client[0]; + c = entry->client; + /* At this point there should be an entry in the nbd_clients + * table and a background thread to run the client loop + */ + myfail_if( entry->thread == 0, "No client thread was started." ); + server_fd = c->socket; + myfail_if( fd_is_closed(server_fd), + "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 */ - server_accept(s); + /* accept again, so that we can react to the acl replacement signal */ + server_accept( s ); - /* Fail if we time out here */ - while (!fd_is_closed(server_fd)); + /* Fail if we time out here */ + while( !fd_is_closed( server_fd ) ); - close(client_fd); - server_close_clients(s); - server_destroy(s); + close( client_fd ); + server_close_clients( 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; - flexnbd.signal_fd = -1; + struct flexnbd flexnbd; + 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" }; - struct acl *new_acl = acl_create(1, lines, 1); - struct client *c; - struct client_tbl_entry *entry; + char *lines[] = {"127.0.0.1"}; + struct acl * new_acl = acl_create( 1, lines, 1 ); + struct client * c; + struct client_tbl_entry * entry; - int actual_port; - int client_fd; - int server_fd; + int actual_port; + int client_fd; + int server_fd; - serve_open_server_socket(s); - actual_port = server_port(s); - client_fd = connect_client("127.0.0.7", actual_port, "127.0.0.1"); - server_accept(s); - entry = &s->nbd_client[0]; - c = entry->client; - /* At this point there should be an entry in the nbd_clients - * table and a background thread to run the client loop - */ - myfail_if(entry->thread == 0, "No client thread was started."); - server_fd = c->socket; - myfail_if(fd_is_closed(server_fd), - "Sanity check failed - client socket wasn't open."); + serve_open_server_socket( s ); + actual_port = server_port( s ); + client_fd = connect_client( "127.0.0.7", actual_port, "127.0.0.1" ); + server_accept( s ); + entry = &s->nbd_client[0]; + c = entry->client; + /* At this point there should be an entry in the nbd_clients + * table and a background thread to run the client loop + */ + myfail_if( entry->thread == 0, "No client thread was started." ); + server_fd = c->socket; + myfail_if( fd_is_closed(server_fd), + "Sanity check failed - client socket wasn't open." ); - server_replace_acl(s, new_acl); - server_accept(s); + server_replace_acl( s, new_acl ); + server_accept( s ); - myfail_if(self_pipe_signal_clear(c->stop_signal), - "Client was told to stop."); + myfail_if( self_pipe_signal_clear( c->stop_signal ), + "Client was told to stop." ); - close(client_fd); - server_close_clients(s); - server_destroy(s); + close( client_fd ); + server_close_clients( s ); + server_destroy( s ); } +END_TEST -END_TEST Suite * serve_suite(void) + +Suite* serve_suite(void) { - Suite *s = suite_create("serve"); - TCase *tc_acl_update = tcase_create("acl_update"); + Suite *s = suite_create("serve"); + 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_signals_acl_updated); + tcase_add_test(tc_acl_update, test_replaces_acl); + 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_leaves_good_client, - 0); + tcase_add_exit_test(tc_acl_update, test_acl_update_closes_bad_client, 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) { - log_level = LOG_LEVEL; - error_init(); - int number_failed; - Suite *s = serve_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; + log_level = LOG_LEVEL; + error_init(); + int number_failed; + Suite *s = serve_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; } + diff --git a/tests/unit/check_sockutil.c b/tests/unit/check_sockutil.c index dc7295f..57626bb 100644 --- a/tests/unit/check_sockutil.c +++ b/tests/unit/check_sockutil.c @@ -6,112 +6,110 @@ #include -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_in *v4 = (struct sockaddr_in *) &sa; - char testbuf[128]; - const char *result; + struct sockaddr sa; + struct sockaddr_in* v4 = (struct sockaddr_in*) &sa; + char testbuf[128]; + const char* result; - v4->sin_family = AF_INET; - v4->sin_port = htons(4777); - ck_assert_int_eq(1, inet_pton(AF_INET, "192.168.0.1", &v4->sin_addr)); + v4->sin_family = AF_INET; + v4->sin_port = htons( 4777 ); + ck_assert_int_eq( 1, inet_pton( AF_INET, "192.168.0.1", &v4->sin_addr )); - result = sockaddr_address_string(&sa, &testbuf[0], 128); - ck_assert(result != NULL); + result = sockaddr_address_string( &sa, &testbuf[0], 128 ); + 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 -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 = &v6_raw; - struct sockaddr *sa = (struct sockaddr *) &v6_raw; + struct sockaddr_in6 v6_raw; + struct sockaddr_in6* v6 = &v6_raw; + struct sockaddr* sa = (struct sockaddr*) &v6_raw; - char testbuf[128]; - const char *result; + char testbuf[128]; + const char* result; - v6->sin6_family = AF_INET6; - v6->sin6_port = htons(4777); - ck_assert_int_eq(1, inet_pton(AF_INET6, "fe80::1", &v6->sin6_addr)); + v6->sin6_family = AF_INET6; + v6->sin6_port = htons( 4777 ); + ck_assert_int_eq( 1, inet_pton( AF_INET6, "fe80::1", &v6->sin6_addr )); - result = sockaddr_address_string(sa, &testbuf[0], 128); - ck_assert(result != NULL); + result = sockaddr_address_string( sa, &testbuf[0], 128 ); + ck_assert( result != NULL ); - ck_assert_str_eq("fe80::1 port 4777", testbuf); + ck_assert_str_eq( "fe80::1 port 4777", testbuf ); } - END_TEST + /* 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_in *v4 = (struct sockaddr_in *) &sa; - char testbuf[128]; - const char *result; + struct sockaddr sa; + struct sockaddr_in* v4 = (struct sockaddr_in*) &sa; + char testbuf[128]; + const char* result; - v4->sin_family = AF_UNSPEC; - v4->sin_port = htons(4777); - ck_assert_int_eq(1, inet_pton(AF_INET, "192.168.0.1", &v4->sin_addr)); + v4->sin_family = AF_UNSPEC; + v4->sin_port = htons( 4777 ); + ck_assert_int_eq( 1, inet_pton( AF_INET, "192.168.0.1", &v4->sin_addr )); - result = sockaddr_address_string(&sa, &testbuf[0], 128); - ck_assert(result == NULL); + result = sockaddr_address_string( &sa, &testbuf[0], 128 ); + ck_assert( result == NULL ); - ck_assert_str_eq("???", testbuf); + ck_assert_str_eq( "???", testbuf ); } - END_TEST + /* 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_in *v4 = (struct sockaddr_in *) &sa; - char testbuf[128]; - const char *result; + struct sockaddr sa; + struct sockaddr_in* v4 = (struct sockaddr_in*) &sa; + char testbuf[128]; + const char* result; - memset(testbuf, 0, 128); - v4->sin_family = AF_INET; - v4->sin_port = htons(4777); - ck_assert_int_eq(1, inet_pton(AF_INET, "192.168.0.1", &v4->sin_addr)); - memset(&testbuf, 0, 128); + memset( testbuf, 0, 128 ); + v4->sin_family = AF_INET; + v4->sin_port = htons( 4777 ); + ck_assert_int_eq( 1, inet_pton( AF_INET, "192.168.0.1", &v4->sin_addr )); + memset( &testbuf, 0, 128 ); - result = sockaddr_address_string(&sa, &testbuf[0], 2); - ck_assert(result == NULL); + result = sockaddr_address_string( &sa, &testbuf[0], 2 ); + 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, - test_sockaddr_address_string_af_inet6_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, - test_sockaddr_address_string_doesnt_overflow_short_buffer); - suite_add_tcase(s, tc_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, test_sockaddr_address_string_af_inet6_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, test_sockaddr_address_string_doesnt_overflow_short_buffer); + suite_add_tcase(s, tc_sockaddr_address_string); - return s; + return s; } int main(void) { - int number_failed; + int number_failed; - Suite *s = sockutil_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 = sockutil_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; } + diff --git a/tests/unit/check_status.c b/tests/unit/check_status.c index 8c37563..ea89d3b 100644 --- a/tests/unit/check_status.c +++ b/tests/unit/check_status.c @@ -6,331 +6,366 @@ #include -struct server *mock_server(void) +struct server* mock_server(void) { - struct server *out = xmalloc(sizeof(struct server)); - out->l_start_mirror = flexthread_mutex_create(); - out->nbd_client = xmalloc(sizeof(struct client_tbl_entry) * 4); - out->max_nbd_clients = 4; - out->size = 65536; + struct server* out = xmalloc( sizeof( struct server ) ); + out->l_start_mirror = flexthread_mutex_create(); + out->nbd_client = xmalloc( sizeof( struct client_tbl_entry ) * 4 ); + out->max_nbd_clients = 4; + 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(); - out->mirror = xmalloc(sizeof(struct mirror)); - out->mirror_super = xmalloc(sizeof(struct mirror_super)); - return out; + struct server *out = mock_server(); + out->mirror = xmalloc( sizeof( struct mirror ) ); + out->mirror_super = xmalloc( sizeof( struct mirror_super ) ); + return out; } -void destroy_mock_server(struct server *serve) +void destroy_mock_server( struct server* serve ) { - if (NULL != serve->mirror) { - free(serve->mirror); - } + if ( NULL != serve->mirror ) { + free( serve->mirror ); + } - if (NULL != serve->mirror_super) { - free(serve->mirror_super); - } + if ( NULL != 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); - free(serve->nbd_client); - free(serve); + bitset_free( serve->allocation_map ); + free( serve->nbd_client ); + free( serve ); } -START_TEST(test_status_create) +START_TEST( test_status_create ) { - struct server *server = mock_server(); - struct status *status = status_create(server); + struct server * server = mock_server(); + struct status * status = status_create( server ); - fail_if(NULL == status, "Status wasn't allocated"); - status_destroy(status); - destroy_mock_server(server); + fail_if( NULL == status, "Status wasn't allocated" ); + status_destroy( status ); + 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(); - server->success = 1; + struct server * server = mock_server(); + 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"); - status_destroy(status); - destroy_mock_server(server); + fail_unless( status->has_control == 1, "has_control wasn't copied" ); + status_destroy( status ); + 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 status *status = status_create(server); + struct server * server = mock_server(); + struct status * status = status_create( server ); - fail_if(status->is_mirroring, "is_mirroring was set"); - status_destroy(status); - destroy_mock_server(server); + fail_if( status->is_mirroring, "is_mirroring was set" ); + status_destroy( status ); + destroy_mock_server( server ); - server = mock_mirroring_server(); - status = status_create(server); + server = mock_mirroring_server(); + status = status_create( server ); - fail_unless(status->is_mirroring, "is_mirroring wasn't set"); - status_destroy(status); - destroy_mock_server(server); + fail_unless( status->is_mirroring, "is_mirroring wasn't set" ); + status_destroy( status ); + 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 status *status = status_create(server); + struct server * server = mock_server(); + struct status * status = status_create( server ); - fail_if(status->clients_allowed, "clients_allowed was set"); - status_destroy(status); + fail_if( status->clients_allowed, "clients_allowed was set" ); + status_destroy( status ); - server->allow_new_clients = 1; - status = status_create(server); + server->allow_new_clients = 1; + status = status_create( server ); - fail_unless(status->clients_allowed, "clients_allowed was not set"); - status_destroy(status); - destroy_mock_server(server); + fail_unless( status->clients_allowed, "clients_allowed was not set" ); + status_destroy( status ); + destroy_mock_server( server ); } +END_TEST -END_TEST START_TEST(test_gets_pid) +START_TEST( test_gets_pid ) { - struct server *server = mock_server(); - struct status *status = status_create(server); + struct server * server = mock_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); - destroy_mock_server(server); + status_destroy( status ); + destroy_mock_server( server ); } +END_TEST -END_TEST START_TEST(test_gets_size) +START_TEST( test_gets_size ) { - struct server *server = mock_server(); - server->size = 1024; + struct server * server = mock_server(); + 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); - destroy_mock_server(server); + status_destroy( status ); + 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(); - server->mirror->all_dirty = 16384; - server->mirror->max_bytes_per_second = 32768; - server->mirror->offset = 0; + struct server * server = mock_mirroring_server(); + server->mirror->all_dirty = 16384; + server->mirror->max_bytes_per_second = 32768; + server->mirror->offset = 0; - /* we have a bit of a time dependency here */ - server->mirror->migration_started = monotonic_time_ms(); + /* we have a bit of a time dependency here */ + server->mirror->migration_started = monotonic_time_ms(); - struct status *status = status_create(server); + struct status * status = status_create( server ); - fail_unless(0 == status->migration_duration || + fail_unless ( + 0 == status->migration_duration || 1 == status->migration_duration || 2 == status->migration_duration, - "migration_duration is unreasonable!"); + "migration_duration is unreasonable!" + ); - fail_unless(16384 / (status->migration_duration + 1) == - status->migration_speed, - "migration_speed not calculated correctly"); + fail_unless( + 16384 / ( status->migration_duration + 1 ) == status->migration_speed, + "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 - fail_unless(3 == status->migration_seconds_left, - "migration_seconds_left not gathered"); + // ( size / current_bps ) + 1 happens to be 3 for this test + fail_unless( 3 == status->migration_seconds_left, "migration_seconds_left not gathered" ); - status_destroy(status); - destroy_mock_server(server); + status_destroy( status ); + destroy_mock_server( server ); } - END_TEST + + #define RENDER_TEST_SETUP \ struct status status; \ int fds[2]; \ pipe( fds ); -void fail_unless_rendered(int fd, char *fragment) + +void fail_unless_rendered( int fd, char *fragment ) { - char buf[1024] = { 0 }; - char emsg[1024] = { 0 }; - char *found = NULL; + char buf[1024] = {0}; + char emsg[1024] = {0}; + 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"); - found = strstr(buf, fragment); - fail_if(NULL == found, emsg); + fail_unless( read_until_newline( fd, buf, 1024 ) > 0, "Couldn't read" ); + found = strstr( buf, fragment ); + 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 emsg[1024] = { 0 }; - char *found = NULL; + char buf[1024] = {0}; + char emsg[1024] = {0}; + 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"); - found = strstr(buf, fragment); - fail_unless(NULL == found, emsg); + fail_unless( read_until_newline( fd, buf, 1024 ) > 0, "Couldn't read" ); + found = strstr( buf, fragment ); + fail_unless( NULL == found, emsg ); - return; + return; } -START_TEST(test_renders_has_control) +START_TEST( test_renders_has_control ) { - RENDER_TEST_SETUP status.has_control = 1; - status_write(&status, fds[1]); - fail_unless_rendered(fds[0], "has_control=true"); + RENDER_TEST_SETUP - status.has_control = 0; - status_write(&status, fds[1]); - fail_unless_rendered(fds[0], "has_control=false"); + status.has_control = 1; + status_write( &status, fds[1] ); + fail_unless_rendered( fds[0], "has_control=true" ); + + 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 status.is_mirroring = 1; - status_write(&status, fds[1]); - fail_unless_rendered(fds[0], "is_mirroring=true"); + RENDER_TEST_SETUP - status.is_mirroring = 0; - status_write(&status, fds[1]); - fail_unless_rendered(fds[0], "is_mirroring=false"); + status.is_mirroring = 1; + status_write( &status, fds[1] ); + fail_unless_rendered( fds[0], "is_mirroring=true" ); + + 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 status.clients_allowed = 1; - status_write(&status, fds[1]); - fail_unless_rendered(fds[0], "clients_allowed=true"); + RENDER_TEST_SETUP - status.clients_allowed = 0; - status_write(&status, fds[1]); - fail_unless_rendered(fds[0], "clients_allowed=false"); + status.clients_allowed = 1; + status_write( &status, fds[1] ); + fail_unless_rendered( fds[0], "clients_allowed=true" ); + + 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 status.num_clients = 0; - status_write(&status, fds[1]); - fail_unless_rendered(fds[0], "num_clients=0"); + RENDER_TEST_SETUP - status.num_clients = 4000; - status_write(&status, fds[1]); - fail_unless_rendered(fds[0], "num_clients=4000"); + status.num_clients = 0; + status_write( &status, fds[1] ); + fail_unless_rendered( fds[0], "num_clients=0" ); + + 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 status.pid = 42; - status_write(&status, fds[1]); - fail_unless_rendered(fds[0], "pid=42"); + RENDER_TEST_SETUP + + status.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 status.size = ((uint64_t) 1 << 33); - status_write(&status, fds[1]); - fail_unless_rendered(fds[0], "size=8589934592"); + RENDER_TEST_SETUP + + status.size = ( (uint64_t)1 << 33 ); + 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 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; + RENDER_TEST_SETUP - status_write(&status, fds[1]); - fail_if_rendered(fds[0], "migration_duration"); + 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_write(&status, fds[1]); - fail_if_rendered(fds[0], "migration_speed"); + status_write( &status, fds[1] ); + fail_if_rendered( fds[0], "migration_duration" ); - 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" ); - status_write(&status, fds[1]); - fail_if_rendered(fds[0], "migration_seconds_left"); + status_write( &status, fds[1] ); + fail_if_rendered( fds[0], "migration_speed_limit" ); - status.is_mirroring = 1; + status_write( &status, fds[1] ); + fail_if_rendered( fds[0], "migration_seconds_left" ); - status_write(&status, fds[1]); - fail_unless_rendered(fds[0], "migration_duration=8"); + status.is_mirroring = 1; - status_write(&status, fds[1]); - fail_unless_rendered(fds[0], "migration_speed=40000000"); + status_write( &status, fds[1] ); + fail_unless_rendered( fds[0], "migration_duration=8" ); - status_write(&status, fds[1]); - fail_unless_rendered(fds[0], "migration_speed_limit=40000001"); + status_write( &status, fds[1] ); + fail_unless_rendered( fds[0], "migration_speed=40000000" ); - status_write(&status, fds[1]); - fail_unless_rendered(fds[0], "migration_seconds_left=1"); + status_write( &status, fds[1] ); + fail_unless_rendered( fds[0], "migration_speed_limit=40000001" ); - status_write(&status, fds[1]); - fail_unless_rendered(fds[0], "migration_bytes_left=5000"); + status_write( &status, fds[1] ); + fail_unless_rendered( fds[0], "migration_seconds_left=1" ); - status.migration_speed_limit = UINT64_MAX; + status_write( &status, fds[1] ); + fail_unless_rendered( fds[0], "migration_bytes_left=5000" ); - status_write(&status, fds[1]); - fail_if_rendered(fds[0], "migration_speed_limit"); + status.migration_speed_limit = UINT64_MAX; + + 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"); - TCase *tc_create = tcase_create("create"); - TCase *tc_render = tcase_create("render"); + Suite *s = suite_create("status"); + TCase *tc_create = tcase_create("create"); + TCase *tc_render = tcase_create("render"); - tcase_add_test(tc_create, test_status_create); - 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_clients_allowed); - tcase_add_test(tc_create, test_gets_pid); - tcase_add_test(tc_create, test_gets_size); - tcase_add_test(tc_create, test_gets_migration_statistics); + tcase_add_test(tc_create, test_status_create); + 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_clients_allowed); + tcase_add_test(tc_create, test_gets_pid); + tcase_add_test(tc_create, test_gets_size); + 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_is_mirroring); - 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_pid); - tcase_add_test(tc_render, test_renders_size); - tcase_add_test(tc_render, test_renders_migration_statistics); + 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_clients_allowed); + tcase_add_test(tc_render, test_renders_num_clients); + tcase_add_test(tc_render, test_renders_pid); + tcase_add_test(tc_render, test_renders_size); + tcase_add_test(tc_render, test_renders_migration_statistics); - suite_add_tcase(s, tc_create); - suite_add_tcase(s, tc_render); + suite_add_tcase(s, tc_create); + suite_add_tcase(s, tc_render); - return s; + return s; } int main(void) { - int number_failed; + int number_failed; - Suite *s = status_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 = status_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; } + diff --git a/tests/unit/check_util.c b/tests/unit/check_util.c index 5fdd588..63e2ade 100644 --- a/tests/unit/check_util.c +++ b/tests/unit/check_util.c @@ -9,156 +9,165 @@ struct cleanup_bucket { - struct self_pipe *called_signal; + struct self_pipe *called_signal; }; struct cleanup_bucket bkt; -void bucket_init(void) -{ - if (bkt.called_signal) { - self_pipe_destroy(bkt.called_signal); - } - bkt.called_signal = self_pipe_create(); +void bucket_init(void){ + if ( bkt.called_signal ) { + self_pipe_destroy( bkt.called_signal ); + } + bkt.called_signal = self_pipe_create(); } void setup(void) { - bkt.called_signal = NULL; + bkt.called_signal = NULL; } 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) { - self_pipe_signal(foo->called_signal); - } + if (NULL != foo){ + self_pipe_signal( foo->called_signal ); + } } void trigger_fatal(void) -{ - error_init(); - error_set_handler((cleanup_handler *) dummy_cleanup, &bkt); +{ + error_init(); + 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_set_handler((cleanup_handler *) dummy_cleanup, &bkt); - log_level = 4; - error("Expected error"); + error_init(); + error_set_handler( (cleanup_handler *) dummy_cleanup, &bkt); + log_level = 4; + 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) { - trigger_fatal(); - /* If we get here, just block so the test timeout fails - * us */ - sleep(10); - } else { - int kidret, kidstatus, result; - result = waitpid(pid, &kidret, 0); - fail_if(result < 0, "Wait failed."); - fail_unless(WIFSIGNALED(kidret), "Process didn't exit via signal"); - kidstatus = WTERMSIG(kidret); - ck_assert_int_eq(kidstatus, SIGABRT); - } + if ( pid == 0 ) { + trigger_fatal(); + /* If we get here, just block so the test timeout fails + * us */ + sleep(10); + } + else { + int kidret, kidstatus, result; + result = waitpid( pid, &kidret, 0 ); + fail_if( result < 0, "Wait failed." ); + fail_unless( WIFSIGNALED( kidret ), "Process didn't exit via signal" ); + kidstatus = WTERMSIG( kidret ); + 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(); - return NULL; + trigger_error(); + return NULL; } -START_TEST(test_error_doesnt_kill_process) +START_TEST( test_error_doesnt_kill_process ) { - bucket_init(); - pthread_attr_t attr; - pthread_t tid; + bucket_init(); + pthread_attr_t attr; + pthread_t tid; - pthread_attr_init(&attr); + pthread_attr_init( &attr ); - pthread_create(&tid, &attr, error_thread, NULL); - pthread_join(tid, NULL); + pthread_create( &tid, &attr, error_thread, 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_t tid; + pthread_attr_t attr; + pthread_t tid; - pthread_attr_init(&attr); + pthread_attr_init( &attr ); - pthread_create(&tid, &attr, error_thread, NULL); - pthread_join(tid, NULL); - fail_unless(handler_called(), "Handler wasn't called."); + pthread_create( &tid, &attr, error_thread, NULL ); + pthread_join( tid, NULL ); + 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(); - if (kidpid == 0) { - trigger_fatal(); - } else { - int kidstatus; - int result = waitpid(kidpid, &kidstatus, 0); - fail_if(result < 0, "Wait failed"); - fail_if(handler_called(), "Handler was called."); - } + kidpid = fork(); + if ( kidpid == 0 ) { + trigger_fatal(); + } + else { + int kidstatus; + int result = waitpid( kidpid, &kidstatus, 0 ); + fail_if( result < 0, "Wait failed" ); + fail_if( handler_called(), "Handler was called."); + } } +END_TEST -END_TEST Suite * util_suite(void) + +Suite* util_suite(void) { - Suite *s = suite_create("util"); - TCase *tc_process = tcase_create("process"); - TCase *tc_handler = tcase_create("handler"); + Suite *s = suite_create("util"); + TCase *tc_process = tcase_create("process"); + 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_error_doesnt_kill_process); - tcase_add_test(tc_handler, test_error_calls_handler); - tcase_add_test(tc_handler, test_fatal_doesnt_call_handler); + tcase_add_test(tc_process, test_fatal_kills_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_fatal_doesnt_call_handler); - suite_add_tcase(s, tc_process); - suite_add_tcase(s, tc_handler); - - return s; + suite_add_tcase(s, tc_process); + suite_add_tcase(s, tc_handler); + + return s; } int main(void) { - int number_failed; - Suite *s = util_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; + int number_failed; + Suite *s = util_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; } +