Suite *local_suite(void) { Suite *s = suite_create(__FILE__); TCase *tc = tcase_create(__FILE__); /* put responses */ TEST_RES1(bsp_get_put_res, "INSERTED 4\r\n", BSC_PUT_RES_INSERTED, uint64_t, 4, intcmp, 1); TEST_RES1(bsp_get_put_res, "BURIED 4\r\n", BSC_RES_BURIED, uint64_t, 4, intcmp, 1); TEST_RES1(bsp_get_put_res, "EXPECTED_CRLF\r\n", BSC_PUT_RES_EXPECTED_CRLF, uint64_t, 0, intcmp, 0); TEST_RES1(bsp_get_put_res, "JOB_TOO_BIG\r\n", BSC_PUT_RES_JOB_TOO_BIG, uint64_t, 0, intcmp, 0); TEST_RES1(bsp_get_put_res, "OUT_OF_MEMORY\r\n", BSC_RES_OUT_OF_MEMORY, uint64_t, 0, intcmp, 0); TEST_RES1(bsp_get_put_res, "INTERNAL_ERROR\r\n", BSC_RES_INTERNAL_ERROR, uint64_t, 0, intcmp, 0); TEST_RES1(bsp_get_put_res, "UNKNOWN_COMMAND\r\n", BSC_RES_UNKNOWN_COMMAND, uint64_t, 0, intcmp, 0); /* use responses */ TEST_RES1(bsp_get_use_res, "USING bar\r\n", BSC_USE_RES_USING, char *, "bar", strcmp, 1); TEST_RES1(bsp_get_use_res, "OUT_OF_MEMORY\r\n", BSC_RES_OUT_OF_MEMORY, char *, "bar", strcmp, 0); /* reserve responses */ TEST_RES3( bsp_get_reserve_res, "RESERVED 3456543 3\r\n", BSC_RESERVE_RES_RESERVED, 3456543, 1); TEST_RES3( bsp_get_reserve_res, "DEADLINE_SOON\r\n", BSC_RESERVE_RES_DEADLINE_SOON, 3456543, 0); TEST_RES3( bsp_get_reserve_res, "TIMED_OUT\r\n", BSC_RESERVE_RES_TIMED_OUT, 3456543, 0); TEST_RES3( bsp_get_reserve_res, "INTERNAL_ERROR\r\n", BSC_RES_INTERNAL_ERROR, 3456543, 0); TEST_RES3( bsp_get_reserve_res, "UNKNOWN_COMMAND\r\n", BSC_RES_UNKNOWN_COMMAND, 3456543, 0); /* delete responses */ TEST_RES( bsp_get_delete_res, "DELETED\r\n", BSC_DELETE_RES_DELETED ); TEST_RES( bsp_get_delete_res, "NOT_FOUND\r\n", BSC_RES_NOT_FOUND ); TEST_RES( bsp_get_delete_res, "OUT_OF_MEMORY\r\n", BSC_RES_OUT_OF_MEMORY ); /* release responses */ TEST_RES( bsp_get_release_res, "RELEASED\r\n", BSC_RELEASE_RES_RELEASED ); TEST_RES( bsp_get_release_res, "BURIED\r\n", BSC_RES_BURIED ); TEST_RES( bsp_get_release_res, "NOT_FOUND\r\n", BSC_RES_NOT_FOUND ); TEST_RES( bsp_get_release_res, "INTERNAL_ERROR\r\n", BSC_RES_INTERNAL_ERROR ); /* bury responses */ TEST_RES( bsp_get_bury_res, "BURIED\r\n", BSC_RES_BURIED ); TEST_RES( bsp_get_bury_res, "NOT_FOUND\r\n", BSC_RES_NOT_FOUND ); TEST_RES( bsp_get_bury_res, "INTERNAL_ERROR\r\n", BSC_RES_INTERNAL_ERROR ); /* touch responses */ TEST_RES( bsp_get_touch_res, "TOUCHED\r\n", BSC_TOUCH_RES_TOUCHED ); TEST_RES( bsp_get_touch_res, "NOT_FOUND\r\n", BSC_RES_NOT_FOUND ); TEST_RES( bsp_get_touch_res, "UNKNOWN_COMMAND\r\n", BSC_RES_UNKNOWN_COMMAND ); /* watch responses */ TEST_RES1(bsp_get_watch_res, "WATCHING 4\r\n", BSC_RES_WATCHING, uint32_t, 4, intcmp, 1); TEST_RES1(bsp_get_watch_res, "OUT_OF_MEMORY\r\n", BSC_RES_OUT_OF_MEMORY, uint32_t, 0, intcmp, 0); /* ignore responses */ TEST_RES1(bsp_get_ignore_res, "WATCHING 4\r\n", BSC_RES_WATCHING, uint32_t, 4, intcmp, 1); TEST_RES1(bsp_get_ignore_res, "NOT_IGNORED\r\n", BSC_IGNORE_RES_NOT_IGNORED, uint32_t, 0, intcmp, 0); TEST_RES1(bsp_get_ignore_res, "OUT_OF_MEMORY\r\n", BSC_RES_OUT_OF_MEMORY, uint32_t, 0, intcmp, 0); /* peek responses */ TEST_RES3( bsp_get_peek_res, "FOUND 3456543 3\r\n", BSC_PEEK_RES_FOUND, 3456543, 1); TEST_RES3( bsp_get_peek_res, "NOT_FOUND\r\n", BSC_RES_NOT_FOUND, 3456543, 0); TEST_RES3( bsp_get_peek_res, "INTERNAL_ERROR\r\n", BSC_RES_INTERNAL_ERROR, 3456543, 0); TEST_RES3( bsp_get_peek_res, "GIBRISH\r\n", BSC_RES_UNRECOGNIZED, 3456543, 0); /* kick responses */ TEST_RES1(bsp_get_kick_res, "KICKED 4\r\n", BSC_KICK_RES_KICKED, uint32_t, 4, intcmp, 1); TEST_RES1(bsp_get_kick_res, "OUT_OF_MEMORY\r\n", BSC_RES_OUT_OF_MEMORY, uint32_t, 0, intcmp, 0); /* pause-tube responses */ TEST_RES( bsp_get_pause_tube_res, "PAUSED\r\n", BSC_PAUSE_TUBE_RES_PAUSED ); TEST_RES( bsp_get_pause_tube_res, "NOT_FOUND\r\n", BSC_RES_NOT_FOUND ); TEST_RES( bsp_get_pause_tube_res, "GIBRISH\r\n", BSC_RES_UNRECOGNIZED ); suite_add_tcase(s, tc); return s; }
void check_register_cases(Suite *suite, int threading) { suite_add_tcase(suite, register_tcase(threading)); suite_add_tcase(suite, pingpong_tcase(threading)); }
END_TEST #endif /* !OPENSSL_NO_ENGINE */ Suite * ssl_suite(void) { Suite *s; TCase *tc; s = suite_create("ssl"); tc = tcase_create("ssl_wildcardify"); tcase_add_checked_fixture(tc, ssl_setup, ssl_teardown); tcase_add_test(tc, ssl_wildcardify_01); tcase_add_test(tc, ssl_wildcardify_02); tcase_add_test(tc, ssl_wildcardify_03); suite_add_tcase(s, tc); tc = tcase_create("ssl_dnsname_match"); tcase_add_checked_fixture(tc, ssl_setup, ssl_teardown); tcase_add_test(tc, ssl_dnsname_match_01); tcase_add_test(tc, ssl_dnsname_match_02); tcase_add_test(tc, ssl_dnsname_match_03); tcase_add_test(tc, ssl_dnsname_match_04); tcase_add_test(tc, ssl_dnsname_match_05); tcase_add_test(tc, ssl_dnsname_match_06); tcase_add_test(tc, ssl_dnsname_match_07); tcase_add_test(tc, ssl_dnsname_match_08); tcase_add_test(tc, ssl_dnsname_match_09); tcase_add_test(tc, ssl_dnsname_match_10); tcase_add_test(tc, ssl_dnsname_match_11); tcase_add_test(tc, ssl_dnsname_match_12); tcase_add_test(tc, ssl_dnsname_match_13); tcase_add_test(tc, ssl_dnsname_match_14); tcase_add_test(tc, ssl_dnsname_match_15); tcase_add_test(tc, ssl_dnsname_match_16); suite_add_tcase(s, tc); tc = tcase_create("ssl_tls_clienthello_parse"); tcase_add_checked_fixture(tc, ssl_setup, ssl_teardown); tcase_add_test(tc, ssl_tls_clienthello_parse_00); tcase_add_test(tc, ssl_tls_clienthello_parse_01); tcase_add_test(tc, ssl_tls_clienthello_parse_02); tcase_add_test(tc, ssl_tls_clienthello_parse_03); tcase_add_test(tc, ssl_tls_clienthello_parse_04); tcase_add_test(tc, ssl_tls_clienthello_parse_05); tcase_add_test(tc, ssl_tls_clienthello_parse_06); tcase_add_test(tc, ssl_tls_clienthello_parse_07); tcase_add_test(tc, ssl_tls_clienthello_parse_08); tcase_add_test(tc, ssl_tls_clienthello_parse_09); tcase_add_test(tc, ssl_tls_clienthello_parse_10); suite_add_tcase(s, tc); tc = tcase_create("ssl_key_identifier_sha1"); tcase_add_checked_fixture(tc, ssl_setup, ssl_teardown); tcase_add_test(tc, ssl_key_identifier_sha1_01); suite_add_tcase(s, tc); tc = tcase_create("ssl_x509_names"); tcase_add_checked_fixture(tc, ssl_setup, ssl_teardown); tcase_add_test(tc, ssl_x509_names_01); suite_add_tcase(s, tc); tc = tcase_create("ssl_x509_names_to_str"); tcase_add_checked_fixture(tc, ssl_setup, ssl_teardown); tcase_add_test(tc, ssl_x509_names_to_str_01); tcase_add_test(tc, ssl_x509_names_to_str_02); suite_add_tcase(s, tc); tc = tcase_create("ssl_x509_subject"); tcase_add_checked_fixture(tc, ssl_setup, ssl_teardown); tcase_add_test(tc, ssl_x509_subject_01); suite_add_tcase(s, tc); tc = tcase_create("ssl_x509_subject_cn"); tcase_add_checked_fixture(tc, ssl_setup, ssl_teardown); tcase_add_test(tc, ssl_x509_subject_cn_01); suite_add_tcase(s, tc); tc = tcase_create("ssl_x509_ocsps"); tcase_add_checked_fixture(tc, ssl_setup, ssl_teardown); tcase_add_test(tc, ssl_x509_ocsps_01); tcase_add_test(tc, ssl_x509_ocsps_02); suite_add_tcase(s, tc); tc = tcase_create("ssl_is_ocspreq"); tcase_add_checked_fixture(tc, ssl_setup, ssl_teardown); tcase_add_test(tc, ssl_is_ocspreq_01); suite_add_tcase(s, tc); tc = tcase_create("ssl_features"); tcase_add_checked_fixture(tc, ssl_setup, ssl_teardown); tcase_add_test(tc, ssl_features_01); tcase_add_test(tc, ssl_features_02); suite_add_tcase(s, tc); tc = tcase_create("ssl_key_refcount_inc"); tcase_add_checked_fixture(tc, ssl_setup, ssl_teardown); tcase_add_test(tc, ssl_key_refcount_inc_01); suite_add_tcase(s, tc); tc = tcase_create("ssl_x509_refcount_inc"); tcase_add_checked_fixture(tc, ssl_setup, ssl_teardown); tcase_add_test(tc, ssl_x509_refcount_inc_01); suite_add_tcase(s, tc); #ifndef OPENSSL_NO_ENGINE tc = tcase_create("ssl_engine"); tcase_add_checked_fixture(tc, ssl_setup, ssl_teardown); tcase_add_test(tc, ssl_engine_01); suite_add_tcase(s, tc); #else /* OPENSSL_NO_ENGINE */ fprintf(stderr, "ssl: 1 test omitted because OpenSSL has no " "engine support\n"); #endif /* OPENSSL_NO_ENGINE */ return s; }
END_TEST /* cria suite de testes */ Suite * hd_suite(void) { Suite *s = suite_create("LDC_HD"); /* testes para a format_megabyte */ TCase *tc_hd_format = tcase_create("HD_format"); tcase_add_test(tc_hd_format, format_with_0m); tcase_add_test(tc_hd_format, format_with_1m); tcase_add_test(tc_hd_format, format_with_1024m); tcase_add_test(tc_hd_format, format_with_1025m); tcase_add_test(tc_hd_format, format_with_2047m); tcase_add_test(tc_hd_format, format_with_2048m); tcase_add_test(tc_hd_format, format_with_1024g); tcase_add_test(tc_hd_format, format_with_1025g); /* testes para a função get_info */ TCase *tc_hd_get_info = tcase_create("HD_get_info"); tcase_add_test(tc_hd_get_info, get_info_ok); tcase_add_test(tc_hd_get_info, get_info_with_null_device); /* testes para a função add_device_main_info */ TCase *tc_hd_add_device_main_info = tcase_create("HD_add_device_main_info"); tcase_add_test(tc_hd_add_device_main_info, add_device_main_info_ok); tcase_add_test(tc_hd_add_device_main_info, add_device_main_info_with_null_device); /* testes para a função add_device_size_info */ TCase *tc_hd_add_device_size_info = tcase_create("HD_add_device_size_info"); tcase_add_test(tc_hd_add_device_size_info, add_device_size_info_ok); tcase_add_test(tc_hd_add_device_size_info, add_device_size_info_with_null_device); /* testes para a função add_part_info */ TCase *tc_hd_add_part_info = tcase_create("HD_add_part_info"); tcase_add_test(tc_hd_add_part_info, add_part_info_ok); tcase_add_test(tc_hd_add_part_info, add_part_info_with_null_device); /* testes para a função add_part_flags */ TCase *tc_hd_add_part_flags = tcase_create("HD_add_part_flags"); tcase_add_test(tc_hd_add_part_flags, add_part_flags_ok); tcase_add_test(tc_hd_add_part_flags, add_part_flags_with_null_device); /* testes para a função add_geom_info */ TCase *tc_hd_add_geom_info = tcase_create("HD_add_geom_info"); tcase_add_test(tc_hd_add_geom_info, add_geom_info_ok); tcase_add_test(tc_hd_add_geom_info, add_geom_info_with_null_device); /* testes para a função add_df_info */ TCase *tc_hd_add_df_info = tcase_create("HD_add_df_info"); tcase_add_test(tc_hd_add_df_info, add_df_info_ok); tcase_add_test(tc_hd_add_df_info, add_df_info_with_null_device); /* testes para a função add_file_system_info */ TCase *tc_hd_add_file_system_info = tcase_create("HD_add_file_system_info"); tcase_add_test(tc_hd_add_file_system_info, add_file_system_info_ok); tcase_add_test(tc_hd_add_file_system_info, add_file_system_info_with_null_device); suite_add_tcase(s, tc_hd_format); suite_add_tcase(s, tc_hd_get_info); suite_add_tcase(s, tc_hd_add_device_main_info); suite_add_tcase(s, tc_hd_add_device_size_info); suite_add_tcase(s, tc_hd_add_part_info); suite_add_tcase(s, tc_hd_add_part_flags); suite_add_tcase(s, tc_hd_add_geom_info); suite_add_tcase(s, tc_hd_add_df_info); suite_add_tcase(s, tc_hd_add_file_system_info); return s; }
END_TEST /* this test is excluded for now, due to lack of a way * to set a friend's status for now. * ideas: * if we have access to the friends list, we could * just add a status manually ourselves. */ /* START_TEST(test_m_copy_userstatus) { assert(m_copy_userstatus(-1, buf, MAX_USERSTATUS_LENGTH) == -1); assert(m_copy_userstatus(REALLY_BIG_NUMBER, buf, MAX_USERSTATUS_LENGTH) == -1); m_copy_userstatus(friend_id_num, buf, MAX_USERSTATUS_LENGTH + 6); assert(STRINGS_EQUAL(name_buf, friend_id_status)); } END_TEST */ /* this test is excluded for now, due to lack of a way * to set a friend's nickname for now. * ideas: * if we have access to the friends list, we could * just add a name manually ourselves. */ /* START_TEST(test_getname) { uint8_t name_buf[MAX_NAME_LENGTH]; assert(getname(-1, name_buf) == -1); assert(getname(REALLY_BIG_NUMBER, name_buf) == -1); getname(friend_id_num, name_buf); assert(name_buf[MAX_NAME_LENGTH] == '\0'); // something like this } END_TEST */ Suite *messenger_suite(void) { Suite *s = suite_create("Messenger"); TCase *userstatus_size = tcase_create("userstatus_size"); TCase *set_userstatus = tcase_create("set_userstatus"); TCase *send_message = tcase_create("send_message"); TCase *friendstatus = tcase_create("friendstatus"); TCase *getself_name = tcase_create("getself_name"); TCase *delfriend = tcase_create("delfriend"); TCase *addfriend = tcase_create("addfriend"); TCase *setname = tcase_create("setname"); tcase_add_test(userstatus_size, test_m_get_userstatus_size); tcase_add_test(set_userstatus, test_m_set_userstatus); tcase_add_test(friendstatus, test_m_friendstatus); tcase_add_test(getself_name, test_getself_name); tcase_add_test(send_message, test_m_sendmesage); tcase_add_test(delfriend, test_m_delfriend); tcase_add_test(addfriend, test_m_addfriend); tcase_add_test(setname, test_setname); suite_add_tcase(s, userstatus_size); suite_add_tcase(s, set_userstatus); suite_add_tcase(s, friendstatus); suite_add_tcase(s, send_message); suite_add_tcase(s, getself_name); suite_add_tcase(s, delfriend); suite_add_tcase(s, addfriend); suite_add_tcase(s, setname); return s; }
Suite *nsurl_suite(void) { Suite *s; TCase *tc_api_assert; TCase *tc_create; TCase *tc_access; TCase *tc_nice_nostrip; TCase *tc_nice_strip; TCase *tc_replace_query; TCase *tc_join; TCase *tc_compare; TCase *tc_fragment; TCase *tc_component; TCase *tc_parent; s = suite_create("nsurl"); /* Basic API operation assert checks */ tc_api_assert = tcase_create("API asserts"); tcase_add_unchecked_fixture(tc_api_assert, corestring_create, corestring_teardown); tcase_add_test_raise_signal(tc_api_assert, nsurl_api_assert_create_test, 6); tcase_add_test_raise_signal(tc_api_assert, nsurl_api_assert_ref_test, 6); tcase_add_test_raise_signal(tc_api_assert, nsurl_api_assert_unref_test, 6); tcase_add_test_raise_signal(tc_api_assert, nsurl_api_assert_compare1_test, 6); tcase_add_test_raise_signal(tc_api_assert, nsurl_api_assert_compare2_test, 6); tcase_add_test_raise_signal(tc_api_assert, nsurl_api_assert_get_test, 6); tcase_add_test_raise_signal(tc_api_assert, nsurl_api_assert_get_component1_test, 6); tcase_add_test_raise_signal(tc_api_assert, nsurl_api_assert_get_component2_test, 6); tcase_add_test_raise_signal(tc_api_assert, nsurl_api_assert_has_component1_test, 6); tcase_add_test_raise_signal(tc_api_assert, nsurl_api_assert_has_component2_test, 6); tcase_add_test_raise_signal(tc_api_assert, nsurl_api_assert_access_test, 6); tcase_add_test_raise_signal(tc_api_assert, nsurl_api_assert_access_leaf_test, 6); tcase_add_test_raise_signal(tc_api_assert, nsurl_api_assert_length_test, 6); tcase_add_test_raise_signal(tc_api_assert, nsurl_api_assert_hash_test, 6); tcase_add_test_raise_signal(tc_api_assert, nsurl_api_assert_join1_test, 6); tcase_add_test_raise_signal(tc_api_assert, nsurl_api_assert_join2_test, 6); tcase_add_test_raise_signal(tc_api_assert, nsurl_api_assert_defragment_test, 6); tcase_add_test_raise_signal(tc_api_assert, nsurl_api_assert_refragment1_test, 6); tcase_add_test_raise_signal(tc_api_assert, nsurl_api_assert_refragment2_test, 6); tcase_add_test_raise_signal(tc_api_assert, nsurl_api_assert_replace_query1_test, 6); tcase_add_test_raise_signal(tc_api_assert, nsurl_api_assert_replace_query2_test, 6); tcase_add_test_raise_signal(tc_api_assert, nsurl_api_assert_replace_query3_test, 6); tcase_add_test_raise_signal(tc_api_assert, nsurl_api_assert_nice_test, 6); tcase_add_test_raise_signal(tc_api_assert, nsurl_api_assert_parent_test, 6); suite_add_tcase(s, tc_api_assert); /* url creation */ tc_create = tcase_create("Create"); tcase_add_unchecked_fixture(tc_create, corestring_create, corestring_teardown); tcase_add_loop_test(tc_create, nsurl_create_test, 0, NELEMS(create_tests)); tcase_add_test(tc_create, nsurl_ref_test); suite_add_tcase(s, tc_create); /* url access and length */ tc_access = tcase_create("Access"); tcase_add_unchecked_fixture(tc_access, corestring_create, corestring_teardown); tcase_add_loop_test(tc_access, nsurl_access_test, 0, NELEMS(access_tests)); tcase_add_loop_test(tc_access, nsurl_access_leaf_test, 0, NELEMS(access_tests)); tcase_add_loop_test(tc_access, nsurl_length_test, 0, NELEMS(access_tests)); suite_add_tcase(s, tc_access); /* nice filename without strip */ tc_nice_nostrip = tcase_create("Nice (nostrip)"); tcase_add_unchecked_fixture(tc_nice_nostrip, corestring_create, corestring_teardown); tcase_add_loop_test(tc_nice_nostrip, nsurl_nice_nostrip_test, 0, NELEMS(nice_tests)); suite_add_tcase(s, tc_nice_nostrip); /* nice filename with strip */ tc_nice_strip = tcase_create("Nice (strip)"); tcase_add_unchecked_fixture(tc_nice_strip, corestring_create, corestring_teardown); tcase_add_loop_test(tc_nice_strip, nsurl_nice_strip_test, 0, NELEMS(nice_strip_tests)); suite_add_tcase(s, tc_nice_strip); /* replace query */ tc_replace_query = tcase_create("Replace Query"); tcase_add_unchecked_fixture(tc_replace_query, corestring_create, corestring_teardown); tcase_add_loop_test(tc_replace_query, nsurl_replace_query_test, 0, NELEMS(replace_query_tests)); suite_add_tcase(s, tc_replace_query); /* url join */ tc_join = tcase_create("Join"); tcase_add_unchecked_fixture(tc_join, corestring_create, corestring_teardown); tcase_add_loop_test(tc_join, nsurl_join_test, 0, NELEMS(join_tests)); tcase_add_loop_test(tc_join, nsurl_join_complex_test, 0, NELEMS(join_complex_tests)); suite_add_tcase(s, tc_join); /* url compare */ tc_compare = tcase_create("Compare"); tcase_add_unchecked_fixture(tc_compare, corestring_create, corestring_teardown); tcase_add_loop_test(tc_compare, nsurl_compare_test, 0, NELEMS(compare_tests)); suite_add_tcase(s, tc_compare); /* fragment */ tc_fragment = tcase_create("Fragment"); tcase_add_unchecked_fixture(tc_fragment, corestring_create, corestring_teardown); tcase_add_loop_test(tc_fragment, nsurl_defragment_test, 0, NELEMS(parent_tests)); tcase_add_loop_test(tc_fragment, nsurl_refragment_test, 0, NELEMS(parent_tests)); suite_add_tcase(s, tc_fragment); /* component */ tc_component = tcase_create("Component"); tcase_add_unchecked_fixture(tc_component, corestring_create, corestring_teardown); tcase_add_loop_test(tc_component, nsurl_get_component_test, 0, NELEMS(component_tests)); tcase_add_loop_test(tc_component, nsurl_has_component_test, 0, NELEMS(component_tests)); suite_add_tcase(s, tc_component); /* parent */ tc_parent = tcase_create("Parent"); tcase_add_unchecked_fixture(tc_parent, corestring_create, corestring_teardown); tcase_add_loop_test(tc_parent, nsurl_parent_test, 0, NELEMS(parent_tests)); suite_add_tcase(s, tc_parent); return s; }
int main(void) { setlogmask(LOG_UPTO(LOG_DEBUG)); Suite *s1 = suite_create("Bloomd"); TCase *tc1 = tcase_create("config"); TCase *tc3 = tcase_create("filter"); TCase *tc4 = tcase_create("filter manager"); TCase *tc5 = tcase_create("art"); SRunner *sr = srunner_create(s1); int nf; // Add the config tests suite_add_tcase(s1, tc1); tcase_add_test(tc1, test_config_get_default); tcase_add_test(tc1, test_config_bad_file); tcase_add_test(tc1, test_config_empty_file); tcase_add_test(tc1, test_config_basic_config); tcase_add_test(tc1, test_validate_default_config); tcase_add_test(tc1, test_validate_bad_config); tcase_add_test(tc1, test_join_path_no_slash); tcase_add_test(tc1, test_join_path_with_slash); tcase_add_test(tc1, test_sane_log_level); tcase_add_test(tc1, test_sane_init_capacity); tcase_add_test(tc1, test_sane_default_probability); tcase_add_test(tc1, test_sane_scale_size); tcase_add_test(tc1, test_sane_probability_reduction); tcase_add_test(tc1, test_sane_flush_interval); tcase_add_test(tc1, test_sane_cold_interval); tcase_add_test(tc1, test_sane_in_memory); tcase_add_test(tc1, test_sane_use_mmap); tcase_add_test(tc1, test_sane_worker_threads); tcase_add_test(tc1, test_filter_config_bad_file); tcase_add_test(tc1, test_filter_config_empty_file); tcase_add_test(tc1, test_filter_config_basic_config); tcase_add_test(tc1, test_update_filename_from_filter_config); // Add the filter tests suite_add_tcase(s1, tc3); tcase_set_timeout(tc3, 3); tcase_add_test(tc3, test_filter_init_destroy); tcase_add_test(tc3, test_filter_init_discover_destroy); tcase_add_test(tc3, test_filter_init_discover_delete); tcase_add_test(tc3, test_filter_init_proxied); tcase_add_test(tc3, test_filter_add_check); tcase_add_test(tc3, test_filter_restore); tcase_add_test(tc3, test_filter_flush); tcase_add_test(tc3, test_filter_add_check_in_mem); tcase_add_test(tc3, test_filter_grow); tcase_add_test(tc3, test_filter_grow_restore); tcase_add_test(tc3, test_filter_restore_order); tcase_add_test(tc3, test_filter_page_out); tcase_add_test(tc3, test_filter_bounded_fp); // Add the filter tests suite_add_tcase(s1, tc4); tcase_set_timeout(tc4, 3); tcase_add_test(tc4, test_mgr_init_destroy); tcase_add_test(tc4, test_mgr_create_drop); tcase_add_test(tc4, test_mgr_create_double_drop); tcase_add_test(tc4, test_mgr_list); tcase_add_test(tc4, test_mgr_list_prefix); tcase_add_test(tc4, test_mgr_list_no_filters); tcase_add_test(tc4, test_mgr_add_check_keys); tcase_add_test(tc4, test_mgr_check_no_keys); tcase_add_test(tc4, test_mgr_add_check_no_filter); tcase_add_test(tc4, test_mgr_flush_no_filter); tcase_add_test(tc4, test_mgr_flush); tcase_add_test(tc4, test_mgr_unmap_no_filter); tcase_add_test(tc4, test_mgr_unmap); tcase_add_test(tc4, test_mgr_unmap_add_keys); tcase_add_test(tc4, test_mgr_clear_no_filter); tcase_add_test(tc4, test_mgr_clear_not_proxied); tcase_add_test(tc4, test_mgr_clear); tcase_add_test(tc4, test_mgr_clear_reload); tcase_add_test(tc4, test_mgr_list_cold_no_filters); tcase_add_test(tc4, test_mgr_list_cold); tcase_add_test(tc4, test_mgr_unmap_in_mem); tcase_add_test(tc4, test_mgr_create_custom_config); tcase_add_test(tc4, test_mgr_grow); tcase_add_test(tc4, test_mgr_restore); tcase_add_test(tc4, test_mgr_callback); // Add the art tests suite_add_tcase(s1, tc5); tcase_set_timeout(tc4, 8); tcase_add_test(tc5, test_art_init_and_destroy); tcase_add_test(tc5, test_art_insert); tcase_add_test(tc5, test_art_insert_search); tcase_add_test(tc5, test_art_insert_delete); tcase_add_test(tc5, test_art_insert_iter); tcase_add_test(tc5, test_art_iter_prefix); tcase_add_test(tc5, test_art_insert_copy_delete); srunner_run_all(sr, CK_ENV); nf = srunner_ntests_failed(sr); srunner_free(sr); return nf == 0 ? 0 : 1; }
} END_TEST /* ---------------------------------------------------------------------------- * Program * ------------------------------------------------------------------------- */ /* * Create a test suite for all registered test cases and run it. * * Tests must be run sequentially (in no-fork mode) or code coverage * cannot be determined properly. */ int main(void) { void *suite = suite_create("protobluff/message/descriptor"), *tcase = NULL; /* Add tests to test case "iterator" */ tcase = tcase_create("iterator"); tcase_add_test(tcase, test_iterator); tcase_add_test(tcase, test_iterator_empty); suite_add_tcase(suite, tcase); /* Add tests to test case "extend" */ tcase = tcase_create("extend"); tcase_add_test(tcase, test_extend); tcase_add_checked_fixture(tcase, setup, teardown); suite_add_tcase(suite, tcase); /* Add tests to test case "field-by-tag" */ tcase = tcase_create("field-by-tag"); tcase_add_test(tcase, test_field_by_tag); tcase_add_test(tcase, test_field_by_tag_absent); tcase_add_test(tcase, test_field_by_tag_empty); tcase_add_test(tcase, test_field_by_tag_scattered); tcase_add_test(tcase, test_field_by_tag_scattered_absent); tcase_add_test(tcase, test_field_by_tag_extended); tcase_add_checked_fixture(tcase, setup, teardown); suite_add_tcase(suite, tcase); /* Add tests to test case "field-by-name" */ tcase = tcase_create("field-by-name"); tcase_add_test(tcase, test_field_by_name); tcase_add_test(tcase, test_field_by_name_absent); tcase_add_test(tcase, test_field_by_name_empty); tcase_add_test(tcase, test_field_by_name_scattered); tcase_add_test(tcase, test_field_by_name_scattered_absent); tcase_add_test(tcase, test_field_by_name_extended); tcase_add_checked_fixture(tcase, setup, teardown); suite_add_tcase(suite, tcase); /* Create a test suite runner in no-fork mode */ void *runner = srunner_create(suite); srunner_set_fork_status(runner, CK_NOFORK); /* Execute test suite runner */ srunner_run_all(runner, CK_NORMAL); int failed = srunner_ntests_failed(runner); srunner_free(runner); /* Exit with status code */ return failed ? EXIT_FAILURE : EXIT_SUCCESS; }
END_TEST static Suite * make_suite(void) { Suite *s = suite_create("basic"); TCase *tc_basic = tcase_create("basic tests"); TCase *tc_namespace = tcase_create("XML namespaces"); suite_add_tcase(s, tc_basic); tcase_add_checked_fixture(tc_basic, basic_setup, basic_teardown); tcase_add_test(tc_basic, test_nul_byte); tcase_add_test(tc_basic, test_u0000_char); tcase_add_test(tc_basic, test_bom_utf8); tcase_add_test(tc_basic, test_bom_utf16_be); tcase_add_test(tc_basic, test_bom_utf16_le); tcase_add_test(tc_basic, test_illegal_utf8); tcase_add_test(tc_basic, test_utf16); tcase_add_test(tc_basic, test_utf16_le_epilog_newline); tcase_add_test(tc_basic, test_latin1_umlauts); /* Regression test for SF bug #491986. */ tcase_add_test(tc_basic, test_danish_latin1); /* Regression test for SF bug #514281. */ tcase_add_test(tc_basic, test_french_charref_hexidecimal); tcase_add_test(tc_basic, test_french_charref_decimal); tcase_add_test(tc_basic, test_french_latin1); tcase_add_test(tc_basic, test_french_utf8); tcase_add_test(tc_basic, test_utf8_false_rejection); tcase_add_test(tc_basic, test_line_number_after_parse); tcase_add_test(tc_basic, test_column_number_after_parse); tcase_add_test(tc_basic, test_line_and_column_numbers_inside_handlers); tcase_add_test(tc_basic, test_line_number_after_error); tcase_add_test(tc_basic, test_column_number_after_error); tcase_add_test(tc_basic, test_really_long_lines); tcase_add_test(tc_basic, test_end_element_events); tcase_add_test(tc_basic, test_attr_whitespace_normalization); tcase_add_test(tc_basic, test_xmldecl_misplaced); tcase_add_test(tc_basic, test_unknown_encoding_internal_entity); tcase_add_test(tc_basic, test_wfc_undeclared_entity_unread_external_subset); tcase_add_test(tc_basic, test_wfc_undeclared_entity_no_external_subset); tcase_add_test(tc_basic, test_wfc_undeclared_entity_standalone); tcase_add_test(tc_basic, test_wfc_undeclared_entity_with_external_subset); tcase_add_test(tc_basic, test_wfc_undeclared_entity_with_external_subset_standalone); tcase_add_test(tc_basic, test_wfc_no_recursive_entity_refs); tcase_add_test(tc_basic, test_ext_entity_set_encoding); tcase_add_test(tc_basic, test_dtd_default_handling); tcase_add_test(tc_basic, test_empty_ns_without_namespaces); tcase_add_test(tc_basic, test_ns_in_attribute_default_without_namespaces); suite_add_tcase(s, tc_namespace); tcase_add_checked_fixture(tc_namespace, namespace_setup, namespace_teardown); tcase_add_test(tc_namespace, test_return_ns_triplet); tcase_add_test(tc_namespace, test_ns_tagname_overwrite); tcase_add_test(tc_namespace, test_ns_tagname_overwrite_triplet); tcase_add_test(tc_namespace, test_start_ns_clears_start_element); tcase_add_test(tc_namespace, test_default_ns_from_ext_subset_and_ext_ge); tcase_add_test(tc_namespace, test_ns_prefix_with_empty_uri_1); tcase_add_test(tc_namespace, test_ns_prefix_with_empty_uri_2); tcase_add_test(tc_namespace, test_ns_prefix_with_empty_uri_3); tcase_add_test(tc_namespace, test_ns_prefix_with_empty_uri_4); tcase_add_test(tc_namespace, test_ns_default_with_empty_uri); tcase_add_test(tc_namespace, test_ns_duplicate_attrs_diff_prefixes); tcase_add_test(tc_namespace, test_ns_unbound_prefix_on_attribute); tcase_add_test(tc_namespace, test_ns_unbound_prefix_on_element); return s; }
END_TEST Suite *svr_jobfunc_suite(void) { Suite *s = suite_create("svr_jobfunc_suite methods"); TCase *tc_core = tcase_create("svr_enquejob_test"); tcase_add_test(tc_core, svr_enquejob_test); suite_add_tcase(s, tc_core); tc_core = tcase_create("svr_dequejob_test"); tcase_add_test(tc_core, svr_dequejob_test); suite_add_tcase(s, tc_core); tc_core = tcase_create("svr_setjobstate_test"); tcase_add_test(tc_core, svr_setjobstate_test); suite_add_tcase(s, tc_core); tc_core = tcase_create("svr_evaljobstate_test"); tcase_add_test(tc_core, svr_evaljobstate_test); suite_add_tcase(s, tc_core); tc_core = tcase_create("get_variable_test"); tcase_add_test(tc_core, get_variable_test); suite_add_tcase(s, tc_core); tc_core = tcase_create("chk_resc_limits_test"); tcase_add_test(tc_core, chk_resc_limits_test); suite_add_tcase(s, tc_core); tc_core = tcase_create("chk_resc_min_limits_test"); tcase_add_test(tc_core, chk_resc_min_limits_test); suite_add_tcase(s, tc_core); tc_core = tcase_create("svr_chkque_test"); tcase_add_test(tc_core, svr_chkque_test); suite_add_tcase(s, tc_core); tc_core = tcase_create("job_set_wait_test"); tcase_add_test(tc_core, job_set_wait_test); suite_add_tcase(s, tc_core); tc_core = tcase_create("prefix_std_file_test"); tcase_add_test(tc_core, prefix_std_file_test); suite_add_tcase(s, tc_core); tc_core = tcase_create("add_std_filename_test"); tcase_add_test(tc_core, add_std_filename_test); suite_add_tcase(s, tc_core); tc_core = tcase_create("get_jobowner_test"); tcase_add_test(tc_core, get_jobowner_test); suite_add_tcase(s, tc_core); tc_core = tcase_create("set_resc_deflt_test"); tcase_add_test(tc_core, set_resc_deflt_test); tcase_add_test(tc_core, test_numa_task_exceeds_resources); suite_add_tcase(s, tc_core); tc_core = tcase_create("set_chkpt_deflt_test"); tcase_add_test(tc_core, set_chkpt_deflt_test); suite_add_tcase(s, tc_core); tc_core = tcase_create("set_statechar_test"); tcase_add_test(tc_core, set_statechar_test); tcase_add_test(tc_core, is_valid_state_transition_test); tcase_add_test(tc_core, has_conflicting_resource_requeusts_test); suite_add_tcase(s, tc_core); tc_core = tcase_create("lock_ji_mutex_test"); tcase_add_test(tc_core, lock_ji_mutex_test); tcase_add_test(tc_core, chk_mppnodect_test); tcase_add_test(tc_core, job_wait_over_test); suite_add_tcase(s, tc_core); return s; }
END_TEST Suite * create_suite_ArrayInfixWriting () { Suite *suite = suite_create("ArrayInfixWriting"); TCase *tcase = tcase_create("ArrayInfixWriting"); tcase_add_test( tcase, test_parse_brackets_0args); tcase_add_test( tcase, test_parse_brackets_1args); tcase_add_test( tcase, test_parse_brackets_2args); tcase_add_test( tcase, test_parse_function_selector_0args); tcase_add_test( tcase, test_parse_function_selector_1args); tcase_add_test( tcase, test_parse_function_selector_2args); tcase_add_test( tcase, test_parse_function_selector_3args); tcase_add_test( tcase, test_parse_function_selector_needParens); tcase_add_test( tcase, test_parse_function_selector_needNoParens1); tcase_add_test( tcase, test_parse_function_selector_needNoParens2); #if (0) tcase_add_test( tcase, test_parse_function_selector_needNoParens3); #endif tcase_add_test( tcase, test_parse_curlybraces_0args); tcase_add_test( tcase, test_parse_curlybraces_1args); tcase_add_test( tcase, test_parse_curlybraces_2args); tcase_add_test( tcase, test_parse_curlybraces_nested); #if (0) tcase_add_test( tcase, test_parse_curlybraces_semicolons); tcase_add_test( tcase, test_parse_curlybraces_semicolons_short); #endif #if (0) tcase_add_test( tcase, test_parse_function_determinant); tcase_add_test( tcase, test_parse_function_det); tcase_add_test( tcase, test_parse_function_transpose); tcase_add_test( tcase, test_parse_function_trans); tcase_add_test( tcase, test_parse_function_vectorproduct); tcase_add_test( tcase, test_parse_function_vectorprod); tcase_add_test( tcase, test_parse_function_cross); tcase_add_test( tcase, test_parse_function_scalarproduct); tcase_add_test( tcase, test_parse_function_scalarprod); tcase_add_test( tcase, test_parse_function_dot); tcase_add_test( tcase, test_parse_function_outerproduct); tcase_add_test( tcase, test_parse_function_outerprod); tcase_add_test( tcase, test_parse_function_outer); #endif tcase_add_test( tcase, test_parse_function_vector_0args); tcase_add_test( tcase, test_parse_function_vector_1args); tcase_add_test( tcase, test_parse_function_vector_2args); #if (0) tcase_add_test( tcase, test_parse_function_matrix_empty); tcase_add_test( tcase, test_parse_function_matrix_1row); tcase_add_test( tcase, test_parse_function_matrix_2rows); tcase_add_test( tcase, test_parse_function_matrix_emptyrows); #endif tcase_add_test( tcase, test_parse_function_sum); suite_add_tcase(suite, tcase); return suite; }
END_TEST Suite * goal_suite(void) { Suite *s = suite_create("Goal"); TCase *tc; tc = tcase_create("Core"); tcase_add_unchecked_fixture(tc, fixture_all, teardown); tcase_add_test(tc, test_goal_actions); tcase_add_test(tc, test_goal_sanity); tcase_add_test(tc, test_goal_update_impossible); tcase_add_test(tc, test_goal_list_err); tcase_add_test(tc, test_goal_install); tcase_add_test(tc, test_goal_install_multilib); tcase_add_test(tc, test_goal_install_selector); tcase_add_test(tc, test_goal_install_selector_err); tcase_add_test(tc, test_goal_install_selector_two); tcase_add_test(tc, test_goal_install_selector_nomatch); tcase_add_test(tc, test_goal_install_optional); tcase_add_test(tc, test_goal_selector_glob); tcase_add_test(tc, test_goal_selector_provides_glob); tcase_add_test(tc, test_goal_selector_upgrade); tcase_add_test(tc, test_goal_selector_upgrade_provides); tcase_add_test(tc, test_goal_upgrade); tcase_add_test(tc, test_goal_upgrade_all); tcase_add_test(tc, test_goal_downgrade); tcase_add_test(tc, test_goal_get_reason); tcase_add_test(tc, test_goal_get_reason_selector); tcase_add_test(tc, test_goal_describe_problem); tcase_add_test(tc, test_goal_describe_problem_rules); tcase_add_test(tc, test_goal_distupgrade_all_keep_arch); tcase_add_test(tc, test_goal_no_reinstall); tcase_add_test(tc, test_goal_erase_simple); tcase_add_test(tc, test_goal_erase_with_deps); tcase_add_test(tc, test_goal_protected); tcase_add_test(tc, test_goal_erase_clean_deps); tcase_add_test(tc, test_goal_forcebest); tcase_add_test(tc, test_goal_get_solution); suite_add_tcase(s, tc); tc = tcase_create("ModifiesSackState"); tcase_add_unchecked_fixture(tc, fixture_all, teardown); tcase_add_checked_fixture(tc, fixture_reset, NULL); tcase_add_test(tc, test_goal_installonly); tcase_add_test(tc, test_goal_installonly_upgrade_all); tcase_add_test(tc, test_goal_upgrade_all_excludes); tcase_add_test(tc, test_goal_upgrade_disabled_repo); tcase_add_test(tc, test_goal_describe_problem_excludes); suite_add_tcase(s, tc); tc = tcase_create("Main"); tcase_add_unchecked_fixture(tc, fixture_with_main, teardown); tcase_add_test(tc, test_goal_distupgrade_all); tcase_add_test(tc, test_goal_distupgrade_selector_upgrade); tcase_add_test(tc, test_goal_distupgrade_selector_downgrade); tcase_add_test(tc, test_goal_distupgrade_selector_nothing); tcase_add_test(tc, test_goal_install_selector_file); tcase_add_test(tc, test_goal_rerun); tcase_add_test(tc, test_goal_unneeded); tcase_add_test(tc, test_goal_distupgrade_all_excludes); suite_add_tcase(s, tc); tc = tcase_create("Greedy"); tcase_add_unchecked_fixture(tc, fixture_greedy_only, teardown); tcase_add_test(tc, test_goal_run_all); tcase_add_test(tc, test_goal_install_selector_obsoletes_first); tcase_add_test(tc, test_goal_install_weak_deps); suite_add_tcase(s, tc); tc = tcase_create("Installonly"); tcase_add_unchecked_fixture(tc, fixture_installonly, teardown); tcase_add_checked_fixture(tc, fixture_reset, NULL); tcase_add_test(tc, test_goal_installonly_limit); tcase_add_test(tc, test_goal_installonly_limit_disabled); tcase_add_test(tc, test_goal_installonly_limit_running_kernel); tcase_add_test(tc, test_goal_installonly_limit_with_modules); tcase_add_test(tc, test_goal_kernel_protected); suite_add_tcase(s, tc); tc = tcase_create("Vendor"); tcase_add_unchecked_fixture(tc, fixture_with_vendor, teardown); tcase_add_test(tc, test_goal_update_vendor); suite_add_tcase(s, tc); tc = tcase_create("Forcebest"); tcase_add_unchecked_fixture(tc, fixture_with_forcebest, teardown); tcase_add_test(tc, test_goal_forcebest_arches); suite_add_tcase(s, tc); tc = tcase_create("Change"); tcase_add_unchecked_fixture(tc, fixture_with_change, teardown); tcase_add_test(tc, test_goal_change); tcase_add_test(tc, test_goal_clone); suite_add_tcase(s, tc); tc = tcase_create("Cmdline"); tcase_add_unchecked_fixture(tc, fixture_with_cmdline, teardown); tcase_add_test(tc, test_cmdline_file_provides); suite_add_tcase(s, tc); tc = tcase_create("Verify"); tcase_add_unchecked_fixture(tc, fixture_verify, teardown); tcase_add_test(tc, test_goal_verify); suite_add_tcase(s, tc); return s; }
Suite *mod_auth_cas_suite(void) { Suite *s = suite_create("mod_auth_cas"); TCase *tc_core = tcase_create("core"); tcase_add_checked_fixture(tc_core, core_setup, core_teardown); tcase_add_test(tc_core, escapeString_test); tcase_add_test(tc_core, isSSL_test); tcase_add_test(tc_core, cas_char_to_env_test); tcase_add_test(tc_core, cas_scrub_headers_test); tcase_add_test(tc_core, cas_strnenvcmp_test); tcase_add_test(tc_core, normalizeHeaderName_test); tcase_add_test(tc_core, cas_merge_server_config_test); tcase_add_test(tc_core, cas_merge_dir_config_test); tcase_add_test(tc_core, cas_setURL_test); tcase_add_test(tc_core, getCASPath_test); tcase_add_test(tc_core, getCASScope_test); tcase_add_test(tc_core, getCASGatewayV1_test); tcase_add_test(tc_core, getCASGatewayV2_test); tcase_add_test(tc_core, getCASRenew_test); tcase_add_test(tc_core, getCASLoginURL_test); tcase_add_test(tc_core, getCASService_http_test); tcase_add_test(tc_core, getCASService_https_test); tcase_add_test(tc_core, getCASService_http_port_test); tcase_add_test(tc_core, getCASService_https_port_test); tcase_add_test(tc_core, getCASService_root_proxied_test); tcase_add_test(tc_core, getCASService_empty_qs_test); tcase_add_test(tc_core, redirectRequest_test); tcase_add_test(tc_core, removeCASParams_test); tcase_add_test(tc_core, validCASTicketFormat_test); tcase_add_test(tc_core, getCASTicket_test); tcase_add_test(tc_core, getCASCookie_test); tcase_add_test(tc_core, setCASCookie_test); tcase_add_test(tc_core, setCASCookieExpiryNow_test); tcase_add_test(tc_core, setCASCookieExpiryFiveSeconds_test); tcase_add_test(tc_core, removeGatewayCookie_test); tcase_add_test(tc_core, urlEncode_test); tcase_add_test(tc_core, readCASCacheFile_test); tcase_add_test(tc_core, CASCleanCache_test); tcase_add_test(tc_core, writeCASCacheEntry_test); tcase_add_test(tc_core, createCASCookie_test); tcase_add_test(tc_core, expireCASST_test); tcase_add_test(tc_core, CASSAMLLogout_test); tcase_add_test(tc_core, deleteCASCacheFile_test); tcase_add_test(tc_core, getResponseFromServer_test); tcase_add_test(tc_core, isValidCASTicket_OpenSAML1_test); tcase_add_test(tc_core, isValidCASTicket_OpenSAML2_test); tcase_add_test(tc_core, isValidCASCookie_test); tcase_add_test(tc_core, cas_curl_write_test); tcase_add_test(tc_core, cas_curl_ssl_ctx_test); tcase_add_test(tc_core, cas_authenticate_test); tcase_add_test(tc_core, cas_ssl_locking_callback_test); tcase_add_test(tc_core, cas_ssl_id_callback_test); tcase_add_test(tc_core, cas_cleanup_test); tcase_add_test(tc_core, check_vhost_config_test); tcase_add_test(tc_core, check_merged_vhost_configs_test); tcase_add_test(tc_core, merged_vhost_configs_exist_test); tcase_add_test(tc_core, cas_post_config_test); tcase_add_test(tc_core, cas_in_filter_test); tcase_add_test(tc_core, cas_register_hooks_test); tcase_add_test(tc_core, cas_attribute_authz_test); suite_add_tcase(s, tc_core); suite_add_tcase(s, cas_saml_attr_tcase()); return s; }
END_TEST START_TEST(tc_pico_sntp_sync_ip) { union pico_address sntp_addr = { .ip4.addr = 0ul }; fail_if(pico_sntp_sync_ip(NULL, cb_synced) == 0); fail_if(pico_err != PICO_ERR_EINVAL); fail_if(pico_sntp_sync_ip(&sntp_addr, NULL) == 0); fail_if(pico_err != PICO_ERR_EINVAL); fail_if(pico_sntp_sync_ip(&sntp_addr, cb_synced) != 0); } END_TEST START_TEST(tc_pico_sntp_sync_start) { struct sntp_server_ns_cookie ck = { 0 }; union pico_address sntp_addr = { .ip4.addr= 0ul }; fail_if(pico_sntp_sync_start(&ck, &sntp_addr) != 0); } END_TEST START_TEST(tc_pico_sntp_sync_start_dns_ipv4) { const char *sntp_server = "ntp.nasa.gov"; fail_if(pico_sntp_sync_start_dns_ipv4(sntp_server, cb_synced) != 0); } END_TEST START_TEST(tc_pico_sntp_sync_start_dns_ipv6) { const char *sntp_server = "ntp.nasa.gov"; fail_if(pico_sntp_sync_start_dns_ipv6(sntp_server, cb_synced) != 0); } END_TEST START_TEST(tc_pico_sntp_sync_start_ipv4) { union pico_address sntp_addr = { .ip4.addr = 0}; fail_if(pico_sntp_sync_start_ipv4(&sntp_addr, cb_synced) != 0); } END_TEST START_TEST(tc_pico_sntp_sync_start_ipv6) { union pico_address sntp_addr = { .ip6.addr = { 0 } }; fail_if(pico_sntp_sync_start_ipv6(&sntp_addr, cb_synced) != 0); } END_TEST Suite *pico_suite(void) { Suite *s = suite_create("PicoTCP"); TCase *TCase_timestamp_convert = tcase_create("Unit test for pico_timeval"); TCase *TCase_pico_sntp_cleanup = tcase_create("Unit test for pico_sntp_cleanup"); TCase *TCase_pico_sntp_send = tcase_create("Unit test for pico_sntp_send"); TCase *TCase_pico_sntp_parse = tcase_create("Unit test for pico_sntp_parse"); TCase *TCase_pico_sntp_client_wakeup = tcase_create("Unit test for pico_sntp_client_wakeup"); TCase *TCase_sntp_receive_timeout = tcase_create("Unit test for sntp_receive_timeout"); TCase *TCase_dnsCallback = tcase_create("Unit test for dnsCallback"); TCase *TCase_pico_sntp_sync = tcase_create("Unit test for pico_sntp_sync"); TCase *TCase_pico_sntp_sync_ip = tcase_create("Unit test for pico_sntp_sync_ip"); TCase *TCase_pico_sntp_sync_start = tcase_create("Unit test for pico_sntp_sync_start"); TCase *TCase_pico_sntp_sync_start_dns_ipv4 = tcase_create("Unit test for pico_sntp_sync_start_dns_ipv4"); TCase *TCase_pico_sntp_sync_start_dns_ipv6 = tcase_create("Unit test for pico_sntp_sync_start_dns_ipv6"); TCase *TCase_pico_sntp_sync_start_ipv4 = tcase_create("Unit test for pico_sntp_sync_start_ipv4"); TCase *TCase_pico_sntp_sync_start_ipv6 = tcase_create("Unit test for pico_sntp_sync_start_ipv6"); tcase_add_test(TCase_timestamp_convert, tc_timestamp_convert); suite_add_tcase(s, TCase_timestamp_convert); tcase_add_test(TCase_pico_sntp_cleanup, tc_pico_sntp_cleanup); suite_add_tcase(s, TCase_pico_sntp_cleanup); tcase_add_test(TCase_pico_sntp_parse, tc_pico_sntp_parse); suite_add_tcase(s, TCase_pico_sntp_parse); tcase_add_test(TCase_pico_sntp_client_wakeup, tc_pico_sntp_client_wakeup); suite_add_tcase(s, TCase_pico_sntp_client_wakeup); tcase_add_test(TCase_sntp_receive_timeout, tc_sntp_receive_timeout); suite_add_tcase(s, TCase_sntp_receive_timeout); tcase_add_test(TCase_pico_sntp_send, tc_pico_sntp_send); suite_add_tcase(s, TCase_pico_sntp_send); tcase_add_test(TCase_dnsCallback, tc_dnsCallback); suite_add_tcase(s, TCase_dnsCallback); tcase_add_test(TCase_pico_sntp_sync, tc_pico_sntp_sync); suite_add_tcase(s, TCase_pico_sntp_sync); tcase_add_test(TCase_pico_sntp_sync_ip, tc_pico_sntp_sync_ip); suite_add_tcase(s, TCase_pico_sntp_sync_ip); tcase_add_test(TCase_pico_sntp_sync_start, tc_pico_sntp_sync_start); suite_add_tcase(s, TCase_pico_sntp_sync_start); tcase_add_test(TCase_pico_sntp_sync_start_dns_ipv4, tc_pico_sntp_sync_start_dns_ipv4); suite_add_tcase(s, TCase_pico_sntp_sync_start_dns_ipv4); tcase_add_test(TCase_pico_sntp_sync_start_dns_ipv6, tc_pico_sntp_sync_start_dns_ipv6); suite_add_tcase(s, TCase_pico_sntp_sync_start_dns_ipv6); tcase_add_test(TCase_pico_sntp_sync_start_ipv4, tc_pico_sntp_sync_start_ipv4); suite_add_tcase(s, TCase_pico_sntp_sync_start_ipv4); tcase_add_test(TCase_pico_sntp_sync_start_ipv6, tc_pico_sntp_sync_start_ipv6); suite_add_tcase(s, TCase_pico_sntp_sync_start_ipv6); return s; } int main(void) { int fails; Suite *s = pico_suite(); SRunner *sr = srunner_create(s); srunner_run_all(sr, CK_NORMAL); fails = srunner_ntests_failed(sr); srunner_free(sr); return fails; }
int main (void) { /* get the vm name to test against */ //TODO allow a list of names in this variable testvm = getenv("LIBVMI_CHECK_TESTVM"); if (NULL == testvm) { printf("!! Check requires VM name to test against.\n"); printf("!! Store name in env variable 'LIBVMI_CHECK_TESTVM'.\n"); return 1; } /* setup the test suite */ int number_failed = 0; Suite *s = suite_create("LibVMI"); /* add test cases */ suite_add_tcase(s, init_tcase()); suite_add_tcase(s, translate_tcase()); suite_add_tcase(s, read_tcase()); suite_add_tcase(s, write_tcase()); suite_add_tcase(s, print_tcase()); suite_add_tcase(s, accessor_tcase()); suite_add_tcase(s, util_tcase()); suite_add_tcase(s, peparse_tcase()); suite_add_tcase(s, cache_tcase()); suite_add_tcase(s, get_va_pages_tcase()); #if ENABLE_SHM_SNAPSHOT == 1 suite_add_tcase(s, shm_snapshot_tcase()); #endif /* run the tests */ SRunner *sr = srunner_create(s); srunner_run_all(sr, CK_VERBOSE); number_failed = srunner_ntests_failed(sr); srunner_free(sr); if (number_failed == 0) { return EXIT_SUCCESS; } else { return EXIT_FAILURE; } }
END_TEST Suite *asn1_suite_create() { Suite *s; TCase *tc; s = suite_create("asn1"); tc = tcase_create("algorithmIdentifier"); tcase_add_test(tc, test_asn1_algorithmIdentifier); suite_add_tcase(s, tc); tc = tcase_create("parse_algorithmIdentifier"); tcase_add_test(tc, test_asn1_parse_algorithmIdentifier); suite_add_tcase(s, tc); tc = tcase_create("known_oid"); tcase_add_test(tc, test_asn1_known_oid); suite_add_tcase(s, tc); tc = tcase_create("build_known_oid"); tcase_add_test(tc, test_asn1_build_known_oid); suite_add_tcase(s, tc); tc = tcase_create("oid_from_string"); tcase_add_test(tc, test_asn1_oid_from_string); suite_add_tcase(s, tc); tc = tcase_create("oid_to_string"); tcase_add_test(tc, test_asn1_oid_to_string); suite_add_tcase(s, tc); tc = tcase_create("length"); tcase_add_test(tc, test_asn1_length); suite_add_tcase(s, tc); tc = tcase_create("unwrap"); tcase_add_test(tc, test_asn1_unwrap); suite_add_tcase(s, tc); tc = tcase_create("is_asn1"); tcase_add_test(tc, test_is_asn1); suite_add_tcase(s, tc); tc = tcase_create("is_printablestring"); tcase_add_test(tc, test_asn1_is_printablestring); suite_add_tcase(s, tc); tc = tcase_create("to_time"); tcase_add_test(tc, test_asn1_to_time); suite_add_tcase(s, tc); tc = tcase_create("from_time"); tcase_add_test(tc, test_asn1_from_time); suite_add_tcase(s, tc); tc = tcase_create("parse_time"); tcase_add_test(tc, test_asn1_parse_time); suite_add_tcase(s, tc); tc = tcase_create("build_object"); tcase_add_test(tc, test_asn1_build_object); suite_add_tcase(s, tc); tc = tcase_create("simple_object"); tcase_add_test(tc, test_asn1_simple_object); suite_add_tcase(s, tc); tc = tcase_create("parse_simple_object"); tcase_add_test(tc, test_asn1_parse_simple_object); suite_add_tcase(s, tc); tc = tcase_create("bitstring"); tcase_add_test(tc, test_asn1_bitstring); suite_add_tcase(s, tc); tc = tcase_create("integer"); tcase_add_test(tc, test_asn1_integer); suite_add_tcase(s, tc); tc = tcase_create("parse_integer_uint64"); tcase_add_test(tc, test_asn1_parse_integer_uint64); suite_add_tcase(s, tc); return s; }
END_TEST /** * @brief Create the secsolve test suite */ Suite * secsolve_suite (int standard) { Suite *s = suite_create ("secsolve"); /* Create a test case for the standard MPSolve case and * one for the Gemignani's approach. */ TCase *tc_secular = tcase_create ("Secular equation"); /* Case of a_i = (-1)^(i+1) , b_i = i */ tcase_add_test (tc_secular, test_secsolve_altern); tcase_add_test (tc_secular, test_secsolve_altern_ga); /* Integer parsing */ tcase_add_test (tc_secular, test_secsolve_integer); /* Simple secular equation with cancellation problems */ tcase_add_test (tc_secular, test_secsolve_simple); /* Wilkinson polynomials */ tcase_add_test (tc_secular, test_secsolve_wilkinson); /* MONOMIAL TEST CASE */ TCase *tc_monomial = tcase_create ("Monomial input"); /* Roots of the unity */ tcase_add_test (tc_monomial, test_secsolve_nroots); /* Kam polynomials */ tcase_add_test (tc_monomial, test_secsolve_kam1_1); tcase_add_test (tc_monomial, test_secsolve_kam1_2); tcase_add_test (tc_monomial, test_secsolve_kam1_3); tcase_add_test (tc_monomial, test_secsolve_kam2_1); tcase_add_test (tc_monomial, test_secsolve_kam2_2); tcase_add_test (tc_monomial, test_secsolve_kam2_3); tcase_add_test (tc_monomial, test_secsolve_kam3_1); tcase_add_test (tc_monomial, test_secsolve_kam3_2); tcase_add_test (tc_monomial, test_secsolve_kam3_3); /* Exponentials */ tcase_add_test (tc_monomial, test_secsolve_exp); /* Mandelbrot polynomials */ tcase_add_test (tc_monomial, test_secsolve_mand); /* Chebyshev */ tcase_add_test (tc_monomial, test_secsolve_mignotte); /* Wilkinson polynomials */ tcase_add_test (tc_monomial, test_secsolve_wilkinson_monomial); /* Mult* polynomials */ tcase_add_test (tc_monomial, test_secsolve_mult); tcase_add_test (tc_monomial, test_secsolve_mult_high_precision); /* Topelitz */ tcase_add_test (tc_monomial, test_secsolve_toep); /* Traverso, polynomial generated by resolution of a polynomial * system using Groebner elimination. */ tcase_add_test (tc_monomial, test_secsolve_trv); /* Kirinnis polynomials */ tcase_add_test (tc_monomial, test_secsolve_kir1_10); tcase_add_test (tc_monomial, test_secsolve_kir1_10_hp); tcase_add_test (tc_monomial, test_secsolve_kir1_20); tcase_add_test (tc_monomial, test_secsolve_kir1_40); /* Spiral polynomials */ tcase_add_test (tc_monomial, test_secsolve_spiral10); tcase_add_test (tc_monomial, test_secsolve_spiral20); tcase_add_test (tc_monomial, test_secsolve_spiral10_high_precision); /* Mig polynomial with high precision */ tcase_add_test (tc_monomial, test_secsolve_mig1_200_high_precision); tcase_add_test (tc_monomial, test_secsolve_mig1_500_1); /* Add test case to the suite */ suite_add_tcase (s, tc_secular); suite_add_tcase (s, tc_monomial); return s; }
} END_TEST /* ---------------------------------------------------------------------------- * Program * ------------------------------------------------------------------------- */ /* * Create a test suite for all registered test cases and run it. * * Tests must be run sequentially (in no-fork mode) or code coverage * cannot be determined properly. */ int main(void) { void *suite = suite_create("protobluff/binary/stream"), *tcase = NULL; /* Add tests to test case "create" */ tcase = tcase_create("create"); tcase_add_test(tcase, test_create); tcase_add_test(tcase, test_create_at); suite_add_tcase(suite, tcase); /* Add tests to test case "copy" */ tcase = tcase_create("copy"); tcase_add_test(tcase, test_copy); suite_add_tcase(suite, tcase); /* Add tests to test case "skip" */ tcase = tcase_create("skip"); tcase_add_test(tcase, test_skip); tcase_add_test(tcase, test_skip_underrun); tcase_add_test(tcase, test_skip_fixed32); tcase_add_test(tcase, test_skip_fixed64); tcase_add_test(tcase, test_skip_varint); tcase_add_test(tcase, test_skip_varint_underrun); tcase_add_test(tcase, test_skip_length); tcase_add_test(tcase, test_skip_length_zero); tcase_add_test(tcase, test_skip_length_underrun); tcase_add_test(tcase, test_skip_length_prefix_underrun); suite_add_tcase(suite, tcase); /* Add tests to test case "read" */ tcase = tcase_create("read"); tcase_add_test(tcase, test_read); tcase_add_test(tcase, test_read_underrun); tcase_add_test(tcase, test_read_fixed32); tcase_add_test(tcase, test_read_fixed32_underrun); tcase_add_test(tcase, test_read_fixed64); tcase_add_test(tcase, test_read_fixed64_underrun); tcase_add_test(tcase, test_read_varint8); tcase_add_test(tcase, test_read_varint8_underrun); tcase_add_test(tcase, test_read_varint8_overflow); tcase_add_test(tcase, test_read_varint32); tcase_add_test(tcase, test_read_varint32_underrun); tcase_add_test(tcase, test_read_varint32_overflow); tcase_add_test(tcase, test_read_varint64); tcase_add_test(tcase, test_read_varint64_underrun); tcase_add_test(tcase, test_read_varint64_overflow); tcase_add_test(tcase, test_read_svarint32); tcase_add_test(tcase, test_read_svarint32_underrun); tcase_add_test(tcase, test_read_svarint32_overflow); tcase_add_test(tcase, test_read_svarint64); tcase_add_test(tcase, test_read_svarint64_underrun); tcase_add_test(tcase, test_read_svarint64_overflow); tcase_add_test(tcase, test_read_length); tcase_add_test(tcase, test_read_length_zero); tcase_add_test(tcase, test_read_length_underrun); tcase_add_test(tcase, test_read_length_prefix_underrun); suite_add_tcase(suite, tcase); /* Create a test suite runner in no-fork mode */ void *runner = srunner_create(suite); srunner_set_fork_status(runner, CK_NOFORK); /* Execute test suite runner */ srunner_run_all(runner, CK_NORMAL); int failed = srunner_ntests_failed(runner); srunner_free(runner); /* Exit with status code */ return failed ? EXIT_FAILURE : EXIT_SUCCESS; }
END_TEST Suite * query_suite(void) { Suite *s = suite_create("Query"); TCase *tc; tc = tcase_create("Core"); tcase_add_unchecked_fixture(tc, fixture_system_only, teardown); tcase_add_test(tc, test_query_sanity); tcase_add_test(tc, test_query_run_set_sanity); tcase_add_test(tc, test_query_clear); tcase_add_test(tc, test_query_clone); tcase_add_test(tc, test_query_empty); tcase_add_test(tc, test_query_repo); tcase_add_test(tc, test_query_name); tcase_add_test(tc, test_query_evr); tcase_add_test(tc, test_query_epoch); tcase_add_test(tc, test_query_version); tcase_add_test(tc, test_query_release); tcase_add_test(tc, test_query_glob); tcase_add_test(tc, test_query_case); tcase_add_test(tc, test_query_anded); tcase_add_test(tc, test_query_neq); tcase_add_test(tc, test_query_in); tcase_add_test(tc, test_query_pkg); tcase_add_test(tc, test_query_provides); tcase_add_test(tc, test_query_fileprovides); tcase_add_test(tc, test_query_nevra); tcase_add_test(tc, test_query_nevra_glob); tcase_add_test(tc, test_query_multiple_flags); tcase_add_test(tc, test_query_apply); suite_add_tcase(s, tc); tc = tcase_create("Updates"); tcase_add_unchecked_fixture(tc, fixture_with_updates, teardown); tcase_add_test(tc, test_upgrades_sanity); tcase_add_test(tc, test_upgrades); tcase_add_test(tc, test_upgradable); tcase_add_test(tc, test_filter_latest); tcase_add_test(tc, test_query_provides_in); tcase_add_test(tc, test_query_provides_in_not_found); suite_add_tcase(s, tc); tc = tcase_create("Main"); tcase_add_unchecked_fixture(tc, fixture_with_main, teardown); tcase_add_test(tc, test_upgrade_already_installed); tcase_add_test(tc, test_downgrade); tcase_add_test(tc, test_downgradable); tcase_add_test(tc, test_query_provides_str); tcase_add_test(tc, test_query_recommends); tcase_add_test(tc, test_query_suggests); tcase_add_test(tc, test_query_supplements); tcase_add_test(tc, test_query_enhances); tcase_add_test(tc, test_query_reldep); tcase_add_test(tc, test_query_reldep_arbitrary); tcase_add_test(tc, test_query_requires); tcase_add_test(tc, test_query_conflicts); suite_add_tcase(s, tc); tc = tcase_create("Full"); tcase_add_unchecked_fixture(tc, fixture_all, teardown); tcase_add_test(tc, test_filter_latest2); tcase_add_test(tc, test_filter_latest_archs); tcase_add_test(tc, test_filter_obsoletes); tcase_add_test(tc, test_filter_reponames); suite_add_tcase(s, tc); tc = tcase_create("Filelists etc."); tcase_add_unchecked_fixture(tc, fixture_yum, teardown); tcase_add_test(tc, test_filter_files); tcase_add_test(tc, test_filter_sourcerpm); tcase_add_test(tc, test_filter_description); tcase_add_test(tc, test_query_location); suite_add_tcase(s, tc); tc = tcase_create("Excluding"); tcase_add_unchecked_fixture(tc, fixture_with_main, teardown); tcase_add_checked_fixture(tc, fixture_reset, NULL); tcase_add_test(tc, test_excluded); tcase_add_test(tc, test_disabled_repo); suite_add_tcase(s, tc); return s; }
END_TEST /** * Image Control test case */ /* START_TEST (test_image_bitblt) { #include "image.c" struct point_t p; p.x = 0; p.y = 0; ulcd_image_bitblt(ulcd, &p, 480, 272, image); } END_TEST */ Suite * ulcd_suite(void) { Suite *s = suite_create("uLCD43"); /* Util test case */ TCase *tc_util = tcase_create("util"); tcase_add_unchecked_fixture(tc_util, setup, teardown); tcase_add_test(tc_util, test_error); tcase_add_test(tc_util, test_make_polygon); tcase_add_test(tc_util, test_pack_polygon); suite_add_tcase(s, tc_util); /* Gfx test case */ TCase *tc_gfx = tcase_create("gfx"); tcase_add_unchecked_fixture(tc_gfx, setup, teardown); tcase_add_test(tc_gfx, test_gfx_cls); tcase_add_test(tc_gfx, test_gfx_circle); tcase_add_test(tc_gfx, test_gfx_filled_circle); tcase_add_test(tc_gfx, test_gfx_rectangle); tcase_add_test(tc_gfx, test_gfx_filled_rectangle); tcase_add_test(tc_gfx, test_gfx_polygon); tcase_add_test(tc_gfx, test_gfx_filled_polygon); tcase_add_test(tc_gfx, test_gfx_contrast); tcase_add_test(tc_gfx, test_display_on_off); suite_add_tcase(s, tc_gfx); /* Serial test case */ TCase *tc_serial = tcase_create("serial"); tcase_add_unchecked_fixture(tc_serial, setup, teardown); tcase_add_test(tc_serial, test_set_baud_rate); suite_add_tcase(s, tc_serial); /* Touch test case */ TCase *tc_touch = tcase_create("touch"); tcase_add_unchecked_fixture(tc_touch, setup, teardown); tcase_add_test(tc_touch, test_touch_set_detect_region); tcase_add_test(tc_touch, test_touch_set); tcase_add_test(tc_touch, test_touch_get); tcase_add_test(tc_touch, test_touch_get_event); suite_add_tcase(s, tc_touch); /* Text test case */ TCase *tc_text = tcase_create("text"); tcase_add_unchecked_fixture(tc_text, setup, teardown); tcase_add_test(tc_text, test_move_cursor); tcase_add_test(tc_text, test_txt_putch); tcase_add_test(tc_text, test_txt_putstr); tcase_add_test(tc_text, test_txt_charwidth); tcase_add_test(tc_text, test_txt_charheight); tcase_add_test(tc_text, test_txt_set_color_fg); tcase_add_test(tc_text, test_txt_set_color_bg); tcase_add_test(tc_text, test_txt_set_font); tcase_add_test(tc_text, test_txt_set_width); tcase_add_test(tc_text, test_txt_set_height); tcase_add_test(tc_text, test_txt_set_xgap); tcase_add_test(tc_text, test_txt_set_ygap); tcase_add_test(tc_text, test_txt_set_bold); tcase_add_test(tc_text, test_txt_set_inverse); tcase_add_test(tc_text, test_txt_set_italic); tcase_add_test(tc_text, test_txt_set_underline); tcase_add_test(tc_text, test_txt_set_opacity); tcase_add_test(tc_text, test_txt_set_attributes); suite_add_tcase(s, tc_text); /* Image test case */ /* TCase *tc_image = tcase_create("Image"); tcase_add_unchecked_fixture(tc_image, setup, teardown); tcase_add_test(tc_image, test_image_bitblt); tcase_set_timeout(tc_image, 60); suite_add_tcase(s, tc_image); */ return s; }
END_TEST Suite * array_utils_suite(void) { Suite * s = suite_create("array_utils"); TCase * tc_d_array = tcase_create("d_array_test_case"); tcase_add_test(tc_d_array, test_init_free_d_array); tcase_add_test_raise_signal(tc_d_array, test_init_d_array_fail, SIGABRT); tcase_add_test(tc_d_array, test_expand_d_array); tcase_add_test(tc_d_array, test_append_d_array); tcase_add_test(tc_d_array, test_set_d_array); tcase_add_test_raise_signal(tc_d_array, test_set_d_array_fail, SIGABRT); tcase_add_test(tc_d_array, test_get_d_array); tcase_add_test_raise_signal(tc_d_array, test_get_d_array_fail, SIGABRT); suite_add_tcase(s, tc_d_array); TCase * tc_i_array = tcase_create("i_array_test_case"); tcase_add_test(tc_i_array, test_init_free_i_array); tcase_add_test_raise_signal(tc_i_array, test_init_i_array_fail, SIGABRT); tcase_add_test(tc_i_array, test_expand_i_array); tcase_add_test(tc_i_array, test_append_i_array); tcase_add_test(tc_i_array, test_set_i_array); tcase_add_test_raise_signal(tc_i_array, test_set_i_array_fail, SIGABRT); tcase_add_test(tc_i_array, test_get_i_array); tcase_add_test_raise_signal(tc_i_array, test_get_i_array_fail, SIGABRT); suite_add_tcase(s, tc_i_array); TCase * tc_c_array = tcase_create("c_array_test_case"); tcase_add_test(tc_c_array, test_init_free_c_array); tcase_add_test_raise_signal(tc_c_array, test_init_c_array_fail, SIGABRT); tcase_add_test(tc_c_array, test_expand_c_array); tcase_add_test(tc_c_array, test_assign_c_array); tcase_add_test(tc_c_array, test_get_c_array); suite_add_tcase(s, tc_c_array); TCase * tc_s_array = tcase_create("s_array_test_case"); tcase_add_test(tc_s_array, test_init_free_s_array); tcase_add_test_raise_signal(tc_s_array, test_init_s_array_fail, SIGABRT); tcase_add_test(tc_s_array, test_expand_s_array); tcase_add_test(tc_s_array, test_append_s_array); tcase_add_test(tc_s_array, test_set_s_array); tcase_add_test_raise_signal(tc_s_array, test_set_s_array_fail, SIGABRT); tcase_add_test(tc_s_array, test_get_s_array); tcase_add_test_raise_signal(tc_s_array, test_get_s_array_fail, SIGABRT); suite_add_tcase(s, tc_s_array); TCase * tc_i_array_2d = tcase_create("i_array_2d_test_case"); tcase_add_test(tc_i_array_2d, test_init_free_i_array_2d); tcase_add_test_raise_signal(tc_i_array_2d, test_init_i_array_2d_fail, SIGABRT); tcase_add_test(tc_i_array_2d, test_expand_i_array_2d); tcase_add_test(tc_i_array_2d, test_append_i_array_2d); tcase_add_test(tc_i_array_2d, test_append_el_i_array_2d); tcase_add_test(tc_i_array_2d, test_set_i_array_2d); tcase_add_test(tc_i_array_2d, test_set_el_i_array_2d); tcase_add_test_raise_signal(tc_i_array_2d, test_set_i_array_2d_fail, SIGABRT); tcase_add_test(tc_i_array_2d, test_get_i_array_2d); tcase_add_test(tc_i_array_2d, test_get_el_i_array_2d); tcase_add_test_raise_signal(tc_i_array_2d, test_get_i_array_2d_fail, SIGABRT); suite_add_tcase(s, tc_i_array_2d); TCase * tc_arrays_equal = tcase_create("arrays_equal_test_case"); tcase_add_test(tc_arrays_equal, test_s_arrays_equal); tcase_add_test(tc_arrays_equal, test_i_arrays_equal); tcase_add_test(tc_arrays_equal, test_d_arrays_equal); suite_add_tcase(s, tc_arrays_equal); TCase * tc_get_matching_indices = tcase_create( "get_matching_indices_test_case"); tcase_add_test(tc_get_matching_indices, test_get_matching_indices); tcase_add_exit_test(tc_get_matching_indices, test_get_matching_indices_fail, 1); suite_add_tcase(s, tc_get_matching_indices); TCase * tc_get_doubles = tcase_create("get_doubles_test_case"); tcase_add_test(tc_get_doubles, test_get_doubles); suite_add_tcase(s, tc_get_doubles); TCase * tc_split_str = tcase_create("split_str_test_case"); tcase_add_test(tc_split_str, test_split_str); tcase_add_test(tc_split_str, test_split_str_d); tcase_add_test(tc_split_str, test_split_str_i); suite_add_tcase(s, tc_split_str); return s; }
/* This is called whenever the context status changes */ static void context_state_callback(pa_context *c, void *userdata) { fail_unless(c != NULL); switch (pa_context_get_state(c)) { case PA_CONTEXT_CONNECTING: case PA_CONTEXT_AUTHORIZING: case PA_CONTEXT_SETTING_NAME: break; case PA_CONTEXT_READY: { pa_stream_flags_t flags = PA_STREAM_AUTO_TIMING_UPDATE; pa_buffer_attr attr; static const pa_sample_spec ss = { .format = PA_SAMPLE_S16LE, .rate = 44100, .channels = 2 }; pa_zero(attr); attr.maxlength = (uint32_t) -1; attr.tlength = latency > 0 ? (uint32_t) pa_usec_to_bytes(latency, &ss) : (uint32_t) -1; attr.prebuf = (uint32_t) -1; attr.minreq = (uint32_t) -1; attr.fragsize = (uint32_t) -1; #ifdef INTERPOLATE flags |= PA_STREAM_INTERPOLATE_TIMING; #endif if (latency > 0) flags |= PA_STREAM_ADJUST_LATENCY; pa_log("Connection established"); stream = pa_stream_new(c, "interpol-test", &ss, NULL); fail_unless(stream != NULL); if (playback) { pa_assert_se(pa_stream_connect_playback(stream, NULL, &attr, flags, NULL, NULL) == 0); pa_stream_set_write_callback(stream, stream_write_cb, NULL); } else { pa_assert_se(pa_stream_connect_record(stream, NULL, &attr, flags) == 0); pa_stream_set_read_callback(stream, stream_read_cb, NULL); } pa_stream_set_latency_update_callback(stream, stream_latency_cb, NULL); break; } case PA_CONTEXT_TERMINATED: break; case PA_CONTEXT_FAILED: default: pa_log_error("Context error: %s", pa_strerror(pa_context_errno(c))); ck_abort(); } } START_TEST (interpol_test) { pa_threaded_mainloop* m = NULL; int k; struct timeval start, last_info = { 0, 0 }; pa_usec_t old_t = 0, old_rtc = 0; #ifdef CORK bool corked = false; #endif /* Set up a new main loop */ m = pa_threaded_mainloop_new(); fail_unless(m != NULL); mainloop_api = pa_threaded_mainloop_get_api(m); fail_unless(mainloop_api != NULL); context = pa_context_new(mainloop_api, bname); fail_unless(context != NULL); pa_context_set_state_callback(context, context_state_callback, NULL); fail_unless(pa_context_connect(context, NULL, 0, NULL) >= 0); pa_gettimeofday(&start); fail_unless(pa_threaded_mainloop_start(m) >= 0); /* #ifdef CORK */ for (k = 0; k < 20000; k++) /* #else */ /* for (k = 0; k < 2000; k++) */ /* #endif */ { bool success = false, changed = false; pa_usec_t t, rtc, d; struct timeval now, tv; bool playing = false; pa_threaded_mainloop_lock(m); if (stream) { const pa_timing_info *info; if (pa_stream_get_time(stream, &t) >= 0 && pa_stream_get_latency(stream, &d, NULL) >= 0) success = true; if ((info = pa_stream_get_timing_info(stream))) { if (memcmp(&last_info, &info->timestamp, sizeof(struct timeval))) { changed = true; last_info = info->timestamp; } if (info->playing) playing = true; } } pa_threaded_mainloop_unlock(m); pa_gettimeofday(&now); if (success) { #ifdef CORK bool cork_now; #endif rtc = pa_timeval_diff(&now, &start); pa_log_info("%i\t%llu\t%llu\t%llu\t%llu\t%lli\t%u\t%u\t%llu\t%llu\n", k, (unsigned long long) rtc, (unsigned long long) t, (unsigned long long) (rtc-old_rtc), (unsigned long long) (t-old_t), (signed long long) rtc - (signed long long) t, changed, playing, (unsigned long long) latency, (unsigned long long) d); fflush(stdout); old_t = t; old_rtc = rtc; #ifdef CORK cork_now = (rtc / (2*PA_USEC_PER_SEC)) % 2 == 1; if (corked != cork_now) { pa_threaded_mainloop_lock(m); pa_operation_unref(pa_stream_cork(stream, cork_now, NULL, NULL)); pa_threaded_mainloop_unlock(m); pa_log(cork_now ? "Corking" : "Uncorking"); corked = cork_now; } #endif } /* Spin loop, ugly but normal usleep() is just too badly grained */ tv = now; while (pa_timeval_diff(pa_gettimeofday(&now), &tv) < 1000) pa_thread_yield(); } if (m) pa_threaded_mainloop_stop(m); if (stream) { pa_stream_disconnect(stream); pa_stream_unref(stream); } if (context) { pa_context_disconnect(context); pa_context_unref(context); } if (m) pa_threaded_mainloop_free(m); } END_TEST int main(int argc, char *argv[]) { int failed = 0; Suite *s; TCase *tc; SRunner *sr; if (!getenv("MAKE_CHECK")) pa_log_set_level(PA_LOG_DEBUG); bname = argv[0]; playback = argc <= 1 || !pa_streq(argv[1], "-r"); latency = (argc >= 2 && !pa_streq(argv[1], "-r")) ? atoi(argv[1]) : (argc >= 3 ? atoi(argv[2]) : 0); s = suite_create("Interpol"); tc = tcase_create("interpol"); tcase_add_test(tc, interpol_test); tcase_set_timeout(tc, 5 * 60); suite_add_tcase(s, tc); sr = srunner_create(s); srunner_run_all(sr, CK_NORMAL); failed = srunner_ntests_failed(sr); srunner_free(sr); return (failed == 0) ? EXIT_SUCCESS : EXIT_FAILURE; }
END_TEST /* START_TEST(test_qrsolve_consistency) { u32 i, j, t; double norm; seed_rng(); for (t = 0; t < LINALG_NUM; t++) { u32 n = sizerand(MSIZE_MAX); double x_gauss[n], x_qr[n]; double A[n*n], Ainv[n*n], b[n]; do { for (i = 0; i < n; i++) { b[i] = mrand; for (j = 0; j < n; j++) A[n*i + j] = mrand; } } while (matrix_inverse(n, A, Ainv) < 0); matrix_multiply(n, n, 1, Ainv, b, x_gauss); qrsolve(A, n, n, b, x_qr); norm = (vector_norm(n, x_qr) + vector_norm(n, x_gauss)) / 2; for (i = 0; i < n; i++) fail_unless(fabs(x_qr[i] - x_gauss[i]) < LINALG_TOL * norm, "QR solve failure; difference was %lf for element %u", x_qr[i] - x_gauss[i], i); } } END_TEST START_TEST(test_qrsolve_rect) { s32 i; const double A[8] = {-0.0178505395610981, 1.4638781031761146, -0.8242742209580581, -0.6843477128009663, 0.9155272861151404, -0.1651159277864960, -0.9929037180867774, -0.1491537478964264}; double Q[16], R[8]; double buf[10] __attribute__((unused)) = {22, 22, 22, 22, 22, 22, 22, 22, 22, 22}; i = qrdecomp(A, 4, 2, Q, R); printf("i returned %d\n", i); MAT_PRINTF(A, 4, 2); MAT_PRINTF(Q, 4, 4); MAT_PRINTF(R, 4, 2); } END_TEST */ Suite* linear_algebra_suite(void) { Suite *s = suite_create("Linear algebra"); /* Core test case */ TCase *tc_core = tcase_create("Core"); tcase_add_test(tc_core, test_matrix_eye); tcase_add_test(tc_core, test_matrix_triu); tcase_add_test(tc_core, test_matrix_reconstruct_udu); tcase_add_test(tc_core, test_matrix_udu_1); tcase_add_test(tc_core, test_matrix_udu_2); tcase_add_test(tc_core, test_matrix_udu_3); tcase_add_test(tc_core, test_matrix_add_sc); tcase_add_test(tc_core, test_matrix_copy); tcase_add_test(tc_core, test_matrix_transpose); tcase_add_test(tc_core, test_matrix_inverse_2x2); tcase_add_test(tc_core, test_matrix_inverse_3x3); tcase_add_test(tc_core, test_matrix_inverse_4x4); tcase_add_test(tc_core, test_matrix_inverse_5x5); tcase_add_test(tc_core, test_vector_dot); tcase_add_test(tc_core, test_vector_mean); tcase_add_test(tc_core, test_vector_norm); tcase_add_test(tc_core, test_vector_normalize); tcase_add_test(tc_core, test_vector_add_sc); tcase_add_test(tc_core, test_vector_add); tcase_add_test(tc_core, test_vector_subtract); tcase_add_test(tc_core, test_vector_cross); tcase_add_test(tc_core, test_vector_three); /*tcase_add_test(tc_core, test_qrsolve_consistency);*/ /*tcase_add_test(tc_core, test_qrsolve_rect);*/ suite_add_tcase(s, tc_core); return s; }
END_TEST /**** And the suites are set up here ****/ void lwc_basic_suite(SRunner *sr) { Suite *s = suite_create("libwapcaplet: Basic tests"); TCase *tc_basic = tcase_create("Creation/Destruction"); #ifndef NDEBUG tcase_add_test_raise_signal(tc_basic, test_lwc_intern_string_aborts1, SIGABRT); tcase_add_test_raise_signal(tc_basic, test_lwc_intern_string_aborts2, SIGABRT); tcase_add_test_raise_signal(tc_basic, test_lwc_intern_substring_aborts1, SIGABRT); tcase_add_test_raise_signal(tc_basic, test_lwc_intern_substring_aborts2, SIGABRT); tcase_add_test_raise_signal(tc_basic, test_lwc_string_ref_aborts, SIGABRT); tcase_add_test_raise_signal(tc_basic, test_lwc_string_unref_aborts, SIGABRT); tcase_add_test_raise_signal(tc_basic, test_lwc_string_data_aborts, SIGABRT); tcase_add_test_raise_signal(tc_basic, test_lwc_string_length_aborts, SIGABRT); tcase_add_test_raise_signal(tc_basic, test_lwc_string_hash_value_aborts, SIGABRT); #endif suite_add_tcase(s, tc_basic); tc_basic = tcase_create("Ops with a context"); tcase_add_checked_fixture(tc_basic, with_simple_context_setup, with_simple_context_teardown); tcase_add_test(tc_basic, test_lwc_intern_string_ok); tcase_add_test(tc_basic, test_lwc_intern_string_twice_ok); tcase_add_test(tc_basic, test_lwc_intern_string_twice_same_ok); suite_add_tcase(s, tc_basic); tc_basic = tcase_create("Ops with a filled context"); tcase_add_checked_fixture(tc_basic, with_filled_context_setup, with_filled_context_teardown); tcase_add_test(tc_basic, test_lwc_interning_works); tcase_add_test(tc_basic, test_lwc_intern_substring); tcase_add_test(tc_basic, test_lwc_string_ref_ok); tcase_add_test(tc_basic, test_lwc_string_ref_unref_ok); tcase_add_test(tc_basic, test_lwc_string_unref_ok); tcase_add_test(tc_basic, test_lwc_string_isequal_ok); tcase_add_test(tc_basic, test_lwc_string_caseless_isequal_ok1); tcase_add_test(tc_basic, test_lwc_string_caseless_isequal_ok2); tcase_add_test(tc_basic, test_lwc_string_caseless_isequal_bad); tcase_add_test(tc_basic, test_lwc_extract_data_ok); tcase_add_test(tc_basic, test_lwc_string_hash_value_ok); tcase_add_test(tc_basic, test_lwc_string_is_nul_terminated); tcase_add_test(tc_basic, test_lwc_substring_is_nul_terminated); tcase_add_test(tc_basic, test_lwc_intern_substring_bad_size); tcase_add_test(tc_basic, test_lwc_intern_substring_bad_offset); tcase_add_test(tc_basic, test_lwc_string_iteration); suite_add_tcase(s, tc_basic); srunner_add_suite(sr, s); }
Suite *make_sub_suite(void) { Suite *s; TCase *tc_simple; TCase *tc_signal; #if TIMEOUT_TESTS_ENABLED #if HAVE_WORKING_SETENV TCase *tc_timeout_env_int; TCase *tc_timeout_env_double; #endif /* HAVE_WORKING_SETENV */ TCase *tc_timeout_default; TCase *tc_timeout_usr_int; TCase *tc_timeout_usr_double; #if HAVE_WORKING_SETENV TCase *tc_timeout_env_scale_int; TCase *tc_timeout_scale_int; TCase *tc_timeout_usr_scale_int; TCase *tc_timeout_env_scale_double; TCase *tc_timeout_scale_double; TCase *tc_timeout_usr_scale_double; #endif /* HAVE_WORKING_SETENV */ #endif TCase *tc_limit; TCase *tc_messaging_and_fork; s = suite_create("Check Servant"); tc_simple = tcase_create("Simple Tests"); tc_signal = tcase_create("Signal Tests"); #if TIMEOUT_TESTS_ENABLED #if HAVE_WORKING_SETENV setenv("CK_DEFAULT_TIMEOUT", "6", 1); tc_timeout_env_int = tcase_create("Environment Integer Timeout Tests"); unsetenv("CK_DEFAULT_TIMEOUT"); setenv("CK_DEFAULT_TIMEOUT", "0.5", 1); tc_timeout_env_double = tcase_create("Environment Double Timeout Tests"); unsetenv("CK_DEFAULT_TIMEOUT"); #endif /* HAVE_WORKING_SETENV */ tc_timeout_default = tcase_create("Default Timeout Tests"); tc_timeout_usr_int = tcase_create("User Integer Timeout Tests"); tc_timeout_usr_double = tcase_create("User Double Timeout Tests"); #if HAVE_WORKING_SETENV setenv("CK_TIMEOUT_MULTIPLIER", "2", 1); tc_timeout_scale_int = tcase_create("Timeout Integer Scaling Tests"); tc_timeout_usr_scale_int = tcase_create("User Integer Timeout Scaling Tests"); setenv("CK_DEFAULT_TIMEOUT", "6", 1); tc_timeout_env_scale_int = tcase_create("Environment Integer Timeout Scaling Tests"); unsetenv("CK_DEFAULT_TIMEOUT"); unsetenv("CK_TIMEOUT_MULTIPLIER"); setenv("CK_TIMEOUT_MULTIPLIER", "0.4", 1); tc_timeout_scale_double = tcase_create("Timeout Double Scaling Tests"); tc_timeout_usr_scale_double = tcase_create("User Double Timeout Scaling Tests"); setenv("CK_DEFAULT_TIMEOUT", "0.9", 1); tc_timeout_env_scale_double = tcase_create("Environment Double Timeout Scaling Tests"); unsetenv("CK_DEFAULT_TIMEOUT"); unsetenv("CK_TIMEOUT_MULTIPLIER"); #endif /* HAVE_WORKING_SETENV */ #endif /* TIMEOUT_TESTS_ENABLED */ tc_limit = tcase_create("Limit Tests"); tc_messaging_and_fork = tcase_create("Msg and fork Tests"); suite_add_tcase (s, tc_simple); suite_add_tcase (s, tc_signal); #if TIMEOUT_TESTS_ENABLED #if HAVE_WORKING_SETENV suite_add_tcase (s, tc_timeout_env_int); suite_add_tcase (s, tc_timeout_env_double); #endif /* HAVE_WORKING_SETENV */ suite_add_tcase (s, tc_timeout_default); suite_add_tcase (s, tc_timeout_usr_int); suite_add_tcase (s, tc_timeout_usr_double); /* Add a second time to make sure tcase_set_timeout doesn't contaminate it. */ suite_add_tcase (s, tc_timeout_default); #if HAVE_WORKING_SETENV suite_add_tcase (s, tc_timeout_env_scale_int); suite_add_tcase (s, tc_timeout_env_scale_double); suite_add_tcase (s, tc_timeout_scale_int); suite_add_tcase (s, tc_timeout_scale_double); suite_add_tcase (s, tc_timeout_usr_scale_int); suite_add_tcase (s, tc_timeout_usr_scale_double); #endif #endif suite_add_tcase (s, tc_limit); suite_add_tcase (s, tc_messaging_and_fork); tcase_add_test (tc_simple, test_lno); tcase_add_test (tc_simple, test_mark_lno); tcase_add_test (tc_simple, test_pass); tcase_add_test (tc_simple, test_fail_unless); tcase_add_test (tc_simple, test_fail_if_pass); tcase_add_test (tc_simple, test_fail_if_fail); tcase_add_test (tc_simple, test_fail_null_msg); #if defined(__GNUC__) tcase_add_test (tc_simple, test_fail_no_msg); #endif /* __GNUC__ */ tcase_add_test (tc_simple, test_fail_if_null_msg); #if defined(__GNUC__) tcase_add_test (tc_simple, test_fail_if_no_msg); #endif /* __GNUC__ */ tcase_add_test (tc_simple, test_fail_vararg_msg_1); tcase_add_test (tc_simple, test_fail_vararg_msg_2); tcase_add_test (tc_simple, test_fail_vararg_msg_3); #if defined(__GNUC__) tcase_add_test (tc_simple, test_fail_empty); #endif /* __GNUC__ */ tcase_add_test (tc_simple, test_ck_abort); tcase_add_test (tc_simple, test_ck_abort_msg); tcase_add_test (tc_simple, test_ck_abort_msg_null); tcase_add_test (tc_simple, test_ck_assert); tcase_add_test (tc_simple, test_ck_assert_null); tcase_add_test (tc_simple, test_ck_assert_int_eq); tcase_add_test (tc_simple, test_ck_assert_int_ne); tcase_add_test (tc_simple, test_ck_assert_int_lt); tcase_add_test (tc_simple, test_ck_assert_int_le); tcase_add_test (tc_simple, test_ck_assert_int_gt); tcase_add_test (tc_simple, test_ck_assert_int_ge); tcase_add_test (tc_simple, test_ck_assert_int_expr); tcase_add_test (tc_simple, test_ck_assert_uint_eq); tcase_add_test (tc_simple, test_ck_assert_uint_ne); tcase_add_test (tc_simple, test_ck_assert_uint_lt); tcase_add_test (tc_simple, test_ck_assert_uint_le); tcase_add_test (tc_simple, test_ck_assert_uint_gt); tcase_add_test (tc_simple, test_ck_assert_uint_ge); tcase_add_test (tc_simple, test_ck_assert_uint_expr); tcase_add_test (tc_simple, test_ck_assert_str_eq); tcase_add_test (tc_simple, test_ck_assert_str_ne); tcase_add_test (tc_simple, test_ck_assert_str_lt); tcase_add_test (tc_simple, test_ck_assert_str_le); tcase_add_test (tc_simple, test_ck_assert_str_gt); tcase_add_test (tc_simple, test_ck_assert_str_ge); tcase_add_test (tc_simple, test_ck_assert_str_expr); tcase_add_test (tc_simple, test_ck_assert_ptr_eq); tcase_add_test (tc_simple, test_ck_assert_ptr_ne); tcase_add_test (tc_signal, test_segv); tcase_add_test_raise_signal (tc_signal, test_segv, 11); /* pass */ tcase_add_test_raise_signal (tc_signal, test_segv, 8); /* error */ tcase_add_test_raise_signal (tc_signal, test_pass, 8); /* fail */ tcase_add_test_raise_signal (tc_signal, test_fail_unless, 8); /* fail */ tcase_add_test (tc_signal, test_fpe); tcase_add_test (tc_signal, test_mark_point); #if TIMEOUT_TESTS_ENABLED #if HAVE_WORKING_SETENV tcase_add_test (tc_timeout_env_int, test_eternal); tcase_add_test (tc_timeout_env_int, test_sleep2); tcase_add_test (tc_timeout_env_int, test_sleep5); tcase_add_test (tc_timeout_env_int, test_sleep9); tcase_add_test (tc_timeout_env_double, test_eternal); #ifdef HAVE_LIBRT tcase_add_test (tc_timeout_env_double, test_sleep0_025); tcase_add_test (tc_timeout_env_double, test_sleep1); #endif /* HAVE_LIBRT */ tcase_add_test (tc_timeout_env_double, test_sleep2); tcase_add_test (tc_timeout_env_double, test_sleep5); tcase_add_test (tc_timeout_env_double, test_sleep9); #endif /* HAVE_WORKING_SETENV */ tcase_add_test (tc_timeout_default, test_eternal); #ifdef HAVE_LIBRT tcase_add_test (tc_timeout_default, test_sleep0_025); tcase_add_test (tc_timeout_default, test_sleep1); #endif /* HAVE_LIBRT */ tcase_add_test (tc_timeout_default, test_sleep2); tcase_add_test (tc_timeout_default, test_sleep5); tcase_add_test (tc_timeout_default, test_sleep9); tcase_set_timeout (tc_timeout_usr_int, 6); tcase_add_test (tc_timeout_usr_int, test_eternal); tcase_add_test (tc_timeout_usr_int, test_sleep2); tcase_add_test (tc_timeout_usr_int, test_sleep5); tcase_add_test (tc_timeout_usr_int, test_sleep9); tcase_set_timeout (tc_timeout_usr_double, 0.5); tcase_add_test (tc_timeout_usr_double, test_eternal); #ifdef HAVE_LIBRT tcase_add_test (tc_timeout_usr_double, test_sleep0_025); tcase_add_test (tc_timeout_usr_double, test_sleep1); #endif /* HAVE_LIBRT */ tcase_add_test (tc_timeout_usr_double, test_sleep2); tcase_add_test (tc_timeout_usr_double, test_sleep5); tcase_add_test (tc_timeout_usr_double, test_sleep9); #if HAVE_WORKING_SETENV tcase_add_test (tc_timeout_env_scale_int, test_eternal); #ifdef HAVE_LIBRT tcase_add_test (tc_timeout_env_scale_int, test_sleep0_025); tcase_add_test (tc_timeout_env_scale_int, test_sleep1); #endif /* HAVE_LIBRT */ tcase_add_test (tc_timeout_env_scale_int, test_sleep2); tcase_add_test (tc_timeout_env_scale_int, test_sleep5); tcase_add_test (tc_timeout_env_scale_int, test_sleep9); tcase_add_test (tc_timeout_env_scale_int, test_sleep14); tcase_add_test (tc_timeout_env_scale_double, test_eternal); #ifdef HAVE_LIBRT tcase_add_test (tc_timeout_env_scale_double, test_sleep0_025); tcase_add_test (tc_timeout_env_scale_double, test_sleep1); #endif /* HAVE_LIBRT */ tcase_add_test (tc_timeout_env_scale_double, test_sleep2); tcase_add_test (tc_timeout_env_scale_double, test_sleep5); tcase_add_test (tc_timeout_env_scale_double, test_sleep9); tcase_add_test (tc_timeout_env_scale_double, test_sleep14); tcase_add_test (tc_timeout_scale_int, test_eternal); #ifdef HAVE_LIBRT tcase_add_test (tc_timeout_scale_int, test_sleep0_025); tcase_add_test (tc_timeout_scale_int, test_sleep1); tcase_add_test (tc_timeout_scale_int, test_sleep2); #endif /* HAVE_LIBRT */ tcase_add_test (tc_timeout_scale_int, test_sleep5); tcase_add_test (tc_timeout_scale_int, test_sleep9); tcase_add_test (tc_timeout_scale_double, test_eternal); #ifdef HAVE_LIBRT tcase_add_test (tc_timeout_scale_double, test_sleep0_025); tcase_add_test (tc_timeout_scale_double, test_sleep1); #endif /* HAVE_LIBRT */ tcase_add_test (tc_timeout_scale_double, test_sleep2); tcase_add_test (tc_timeout_scale_double, test_sleep5); tcase_add_test (tc_timeout_scale_double, test_sleep9); setenv("CK_TIMEOUT_MULTIPLIER", "2", 1); tcase_set_timeout (tc_timeout_usr_scale_int, 6); unsetenv("CK_TIMEOUT_MULTIPLIER"); tcase_add_test (tc_timeout_usr_scale_int, test_eternal); #ifdef HAVE_LIBRT tcase_add_test (tc_timeout_usr_scale_int, test_sleep0_025); tcase_add_test (tc_timeout_usr_scale_int, test_sleep1); #endif /* HAVE_LIBRT */ tcase_add_test (tc_timeout_usr_scale_int, test_sleep2); tcase_add_test (tc_timeout_usr_scale_int, test_sleep5); tcase_add_test (tc_timeout_usr_scale_int, test_sleep9); tcase_add_test (tc_timeout_usr_scale_int, test_sleep14); setenv("CK_TIMEOUT_MULTIPLIER", "0.4", 1); tcase_set_timeout (tc_timeout_usr_scale_double, 0.9); unsetenv("CK_TIMEOUT_MULTIPLIER"); tcase_add_test (tc_timeout_usr_scale_double, test_eternal); #ifdef HAVE_LIBRT tcase_add_test (tc_timeout_usr_scale_double, test_sleep0_025); tcase_add_test (tc_timeout_usr_scale_double, test_sleep1); #endif /* HAVE_LIBRT */ tcase_add_test (tc_timeout_usr_scale_double, test_sleep2); tcase_add_test (tc_timeout_usr_scale_double, test_sleep5); tcase_add_test (tc_timeout_usr_scale_double, test_sleep9); tcase_add_test (tc_timeout_usr_scale_double, test_sleep14); #endif #endif tcase_add_test (tc_limit, test_early_exit); tcase_add_test (tc_limit, test_null); tcase_add_test (tc_limit, test_null_2); #ifdef _POSIX_VERSION tcase_add_test (tc_messaging_and_fork, test_fork1p_pass); tcase_add_test (tc_messaging_and_fork, test_fork1p_fail); tcase_add_test (tc_messaging_and_fork, test_fork1c_pass); tcase_add_test (tc_messaging_and_fork, test_fork1c_fail); tcase_add_test (tc_messaging_and_fork, test_fork2_pass); tcase_add_test (tc_messaging_and_fork, test_fork2_fail); #endif /* _POSIX_VERSION */ return s; }
END_TEST // -------------------------------------------------------------------------- /// Self test this class. void * sam_msg_test () { Suite *s = suite_create ("sam_msg"); TCase *tc = tcase_create("lifecycle (life)"); tcase_add_test (tc, test_msg_life_basic); tcase_add_test (tc, test_msg_own); suite_add_tcase (s, tc); tc = tcase_create ("pop ()"); tcase_add_test (tc, test_msg_pop_i); tcase_add_test (tc, test_msg_pop_s); tcase_add_test (tc, test_msg_pop_f); tcase_add_test (tc, test_msg_pop_p); tcase_add_test (tc, test_msg_pop_l); tcase_add_test (tc, test_msg_pop_l_empty); tcase_add_test (tc, test_msg_pop_l_double); tcase_add_test (tc, test_msg_pop); tcase_add_test (tc, test_msg_pop_insufficient_data); tcase_add_test (tc, test_msg_pop_successively); suite_add_tcase (s, tc); tc = tcase_create ("size ()"); tcase_add_test (tc, test_msg_size); tcase_add_test (tc, test_msg_size_successively); suite_add_tcase (s, tc); tc = tcase_create ("free ()"); tcase_add_test (tc, test_msg_free); suite_add_tcase (s, tc); tc = tcase_create ("get ()"); tcase_add_test (tc, test_msg_get_i); tcase_add_test (tc, test_msg_get_s); tcase_add_test (tc, test_msg_get_f); tcase_add_test (tc, test_msg_get_p); tcase_add_test (tc, test_msg_get_l); tcase_add_test (tc, test_msg_get_l_empty); tcase_add_test (tc, test_msg_get_l_double); tcase_add_test (tc, test_msg_get_skipped); tcase_add_test (tc, test_msg_get_skipped_nonempty); tcase_add_test (tc, test_msg_get); tcase_add_test (tc, test_msg_get_insufficient_data); suite_add_tcase (s, tc); tc = tcase_create ("encode () and decode ()"); tcase_add_test (tc, test_msg_code); tcase_add_test (tc, test_msg_code_pop); suite_add_tcase (s, tc); tc = tcase_create ("expect ()"); tcase_add_test (tc, test_msg_expect_zero_noframe); tcase_add_test (tc, test_msg_expect_zero); tcase_add_test (tc, test_msg_expect_nonzero_empty); tcase_add_test (tc, test_msg_expect_nonzero_noframe); tcase_add_test (tc, test_msg_expect_list); tcase_add_test (tc, test_msg_expect_list_less); tcase_add_test (tc, test_msg_expect_list_noframe); tcase_add_test (tc, test_msg_expect); tcase_add_test (tc, test_msg_expect_nonzero); suite_add_tcase (s, tc); tc = tcase_create ("dup ()"); tcase_add_test (tc, test_msg_dup); tcase_add_test (tc, test_msg_dup_refc); suite_add_tcase (s, tc); return s; }
END_TEST static Suite * litest_assert_macros_suite(void) { TCase *tc; Suite *s; s = suite_create("litest:assert macros"); tc = tcase_create("assert"); tcase_add_test_raise_signal(tc, litest_assert_trigger, SIGABRT); tcase_add_test(tc, litest_assert_notrigger); tcase_add_test_raise_signal(tc, litest_assert_msg_trigger, SIGABRT); tcase_add_test_raise_signal(tc, litest_assert_msg_NULL_trigger, SIGABRT); tcase_add_test(tc, litest_assert_msg_notrigger); suite_add_tcase(s, tc); tc = tcase_create("abort"); tcase_add_test_raise_signal(tc, litest_abort_msg_trigger, SIGABRT); tcase_add_test_raise_signal(tc, litest_abort_msg_NULL_trigger, SIGABRT); suite_add_tcase(s, tc); tc = tcase_create("int comparison "); tcase_add_test_raise_signal(tc, litest_int_eq_trigger, SIGABRT); tcase_add_test(tc, litest_int_eq_notrigger); tcase_add_test_raise_signal(tc, litest_int_ne_trigger, SIGABRT); tcase_add_test(tc, litest_int_ne_notrigger); tcase_add_test_raise_signal(tc, litest_int_le_trigger, SIGABRT); tcase_add_test(tc, litest_int_le_notrigger); tcase_add_test_raise_signal(tc, litest_int_lt_trigger_gt, SIGABRT); tcase_add_test_raise_signal(tc, litest_int_lt_trigger_eq, SIGABRT); tcase_add_test(tc, litest_int_lt_notrigger); tcase_add_test_raise_signal(tc, litest_int_ge_trigger, SIGABRT); tcase_add_test(tc, litest_int_ge_notrigger); tcase_add_test_raise_signal(tc, litest_int_gt_trigger_eq, SIGABRT); tcase_add_test_raise_signal(tc, litest_int_gt_trigger_lt, SIGABRT); tcase_add_test(tc, litest_int_gt_notrigger); suite_add_tcase(s, tc); tc = tcase_create("pointer comparison "); tcase_add_test_raise_signal(tc, litest_ptr_eq_trigger, SIGABRT); tcase_add_test_raise_signal(tc, litest_ptr_eq_trigger_NULL, SIGABRT); tcase_add_test_raise_signal(tc, litest_ptr_eq_trigger_NULL2, SIGABRT); tcase_add_test(tc, litest_ptr_eq_notrigger); tcase_add_test_raise_signal(tc, litest_ptr_ne_trigger, SIGABRT); tcase_add_test_raise_signal(tc, litest_ptr_ne_trigger_NULL, SIGABRT); tcase_add_test_raise_signal(tc, litest_ptr_ne_trigger_NULL2, SIGABRT); tcase_add_test(tc, litest_ptr_ne_notrigger); tcase_add_test_raise_signal(tc, litest_ptr_null_trigger, SIGABRT); tcase_add_test(tc, litest_ptr_null_notrigger); tcase_add_test_raise_signal(tc, litest_ptr_notnull_trigger, SIGABRT); tcase_add_test_raise_signal(tc, litest_ptr_notnull_trigger_NULL, SIGABRT); tcase_add_test(tc, litest_ptr_notnull_notrigger); suite_add_tcase(s, tc); tc = tcase_create("double comparison "); tcase_add_test(tc, ck_double_eq_and_ne); tcase_add_test(tc, ck_double_lt_gt); tcase_add_exit_test(tc, ck_double_eq_fails, 1); tcase_add_exit_test(tc, ck_double_ne_fails, 1); tcase_add_exit_test(tc, ck_double_lt_fails, 1); tcase_add_exit_test(tc, ck_double_gt_fails, 1); tcase_add_exit_test(tc, ck_double_le_fails, 1); tcase_add_exit_test(tc, ck_double_ge_fails, 1); suite_add_tcase(s, tc); return s; }
int main(void) { setlogmask(LOG_UPTO(LOG_DEBUG)); Suite *s1 = suite_create("Statsite"); TCase *tc1 = tcase_create("hashmap"); TCase *tc2 = tcase_create("quantile"); TCase *tc3 = tcase_create("heap"); TCase *tc4 = tcase_create("timer"); TCase *tc5 = tcase_create("counter"); TCase *tc6 = tcase_create("metrics"); TCase *tc7 = tcase_create("streaming"); TCase *tc8 = tcase_create("config"); TCase *tc9 = tcase_create("radix"); TCase *tc10 = tcase_create("hyperloglog"); TCase *tc11 = tcase_create("set"); SRunner *sr = srunner_create(s1); int nf; // Add the hashmap tests suite_add_tcase(s1, tc1); tcase_add_test(tc1, test_map_init_and_destroy); tcase_add_test(tc1, test_map_get_no_keys); tcase_add_test(tc1, test_map_put); tcase_add_test(tc1, test_map_put_get); tcase_add_test(tc1, test_map_delete_no_keys); tcase_add_test(tc1, test_map_put_delete); tcase_add_test(tc1, test_map_put_delete_get); tcase_add_test(tc1, test_map_clear_no_keys); tcase_add_test(tc1, test_map_put_clear_get); tcase_add_test(tc1, test_map_iter_no_keys); tcase_add_test(tc1, test_map_put_iter_break); tcase_add_test(tc1, test_map_put_grow); // Add the quantile tests suite_add_tcase(s1, tc2); tcase_add_test(tc2, test_cm_init_and_destroy); tcase_add_test(tc2, test_cm_init_no_quants); tcase_add_test(tc2, test_cm_init_bad_quants); tcase_add_test(tc2, test_cm_init_bad_eps); tcase_add_test(tc2, test_cm_init_add_destroy); tcase_add_test(tc2, test_cm_init_add_loop_destroy); tcase_add_test(tc2, test_cm_init_query_destroy); tcase_add_test(tc2, test_cm_init_add_query_destroy); tcase_add_test(tc2, test_cm_init_add_negative_query_destroy); tcase_add_test(tc2, test_cm_init_add_loop_query_destroy); tcase_add_test(tc2, test_cm_init_add_loop_rev_query_destroy); tcase_add_test(tc2, test_cm_init_add_loop_random_query_destroy); // Add the heap tests suite_add_tcase(s1, tc3); tcase_add_test(tc3, test_heap_init_and_destroy); tcase_add_test(tc3, test_heap_insert); tcase_add_test(tc3, test_heap_insert_delete); tcase_add_test(tc3, test_heap_delete_order); tcase_add_test(tc3, test_heap_for_each); tcase_add_test(tc3, test_heap_del_empty); // Add the timer tests suite_add_tcase(s1, tc4); tcase_add_test(tc4, test_timer_init_and_destroy); tcase_add_test(tc4, test_timer_init_add_destroy); tcase_add_test(tc4, test_timer_add_loop); tcase_add_test(tc4, test_timer_sample_rate); // Add the counter tests suite_add_tcase(s1, tc5); tcase_add_test(tc5, test_counter_init); tcase_add_test(tc5, test_counter_init_add); tcase_add_test(tc5, test_counter_add_loop); tcase_add_test(tc5, test_counter_sample_rate); // Add the counter tests suite_add_tcase(s1, tc6); tcase_add_test(tc6, test_metrics_init_and_destroy); tcase_add_test(tc6, test_metrics_init_defaults_and_destroy); tcase_add_test(tc6, test_metrics_empty_iter); tcase_add_test(tc6, test_metrics_add_iter); tcase_add_test(tc6, test_metrics_add_all_iter); tcase_add_test(tc6, test_metrics_histogram); tcase_add_test(tc6, test_metrics_gauges); // Add the streaming tests suite_add_tcase(s1, tc7); tcase_add_test(tc7, test_stream_empty); tcase_add_test(tc7, test_stream_some); tcase_add_test(tc7, test_stream_bad_cmd); tcase_add_test(tc7, test_stream_sigpipe); // Add the config tests suite_add_tcase(s1, tc8); tcase_add_test(tc8, test_config_get_default); tcase_add_test(tc8, test_config_bad_file); tcase_add_test(tc8, test_config_empty_file); tcase_add_test(tc8, test_config_basic_config); tcase_add_test(tc8, test_validate_default_config); tcase_add_test(tc8, test_validate_bad_config); tcase_add_test(tc8, test_join_path_no_slash); tcase_add_test(tc8, test_join_path_with_slash); tcase_add_test(tc8, test_sane_log_level); tcase_add_test(tc8, test_sane_log_facility); tcase_add_test(tc8, test_sane_timer_eps); tcase_add_test(tc8, test_sane_flush_interval); tcase_add_test(tc8, test_sane_histograms); tcase_add_test(tc8, test_sane_set_eps); tcase_add_test(tc8, test_config_histograms); tcase_add_test(tc8, test_build_radix); tcase_add_test(tc8, test_sane_prefixes); tcase_add_test(tc8, test_sane_global_prefix); tcase_add_test(tc8, test_sane_quantiles); tcase_add_test(tc8, test_extended_counters_include_count_only); tcase_add_test(tc8, test_extended_counters_include_count_rate); tcase_add_test(tc8, test_extended_counters_include_all_selected); tcase_add_test(tc8, test_extended_counters_include_all_by_default); tcase_add_test(tc8, test_timers_include_count_only); tcase_add_test(tc8, test_timers_include_count_rate); tcase_add_test(tc8, test_timers_include_all_selected); // Add the radix tests suite_add_tcase(s1, tc9); tcase_add_test(tc9, test_radix_init_and_destroy); tcase_add_test(tc9, test_radix_insert); tcase_add_test(tc9, test_radix_search); tcase_add_test(tc9, test_radix_longest_prefix); tcase_add_test(tc9, test_radix_foreach); // Add the hll tests suite_add_tcase(s1, tc10); tcase_add_test(tc10, test_hll_init_bad); tcase_add_test(tc10, test_hll_init_and_destroy); tcase_add_test(tc10, test_hll_add); tcase_add_test(tc10, test_hll_add_hash); tcase_add_test(tc10, test_hll_add_size); tcase_add_test(tc10, test_hll_size); tcase_add_test(tc10, test_hll_error_bound); tcase_add_test(tc10, test_hll_precision_for_error); // Add the set tests suite_add_tcase(s1, tc11); tcase_add_test(tc11, test_set_init_destroy); tcase_add_test(tc11, test_set_add_size_exact); tcase_add_test(tc11, test_set_add_size_exact_dedup); tcase_add_test(tc11, test_set_error_bound); srunner_run_all(sr, CK_ENV); nf = srunner_ntests_failed(sr); srunner_free(sr); return nf == 0 ? 0 : 1; }
} END_TEST Suite *analyzer_typecheck_suite_create(void) { Suite *s = suite_create("analyzer_type_check"); TCase *t_typecheck_misc = tcase_create("typecheck_misc"); tcase_add_checked_fixture(t_typecheck_misc, setup_analyzer_tests, teardown_analyzer_tests); tcase_add_test(t_typecheck_misc, test_typecheck_variable_declarations); tcase_add_test(t_typecheck_misc, test_typecheck_negative_int_variable_declarations); tcase_add_test(t_typecheck_misc, test_typecheck_complex_type_in_variable_declaration); tcase_add_test(t_typecheck_misc, test_typecheck_foreign_import); // TODO: Test where there are errors in two different parts of the code // to assert the continuation of the traversal works TCase *t_custom_types_val = tcase_create("typecheck_valid_custom_types"); tcase_add_checked_fixture(t_custom_types_val, setup_analyzer_tests, teardown_analyzer_tests); tcase_add_test(t_custom_types_val, test_typecheck_valid_custom_type_and_fncall1); tcase_add_test(t_custom_types_val, test_typecheck_valid_custom_type_and_fncall2); tcase_add_test(t_custom_types_val, test_typecheck_valid_custom_type_constructor); tcase_add_test(t_custom_types_val, test_typecheck_valid_custom_sum_type_constructor); tcase_add_test(t_custom_types_val, test_typecheck_valid_custom_sum_type_constructor2); TCase *t_custom_types_inv = tcase_create("typecheck_invalid_custom_types"); tcase_add_checked_fixture(t_custom_types_inv, setup_analyzer_tests_with_filelog, teardown_analyzer_tests); tcase_add_test(t_custom_types_inv, test_typecheck_invalid_custom_type_constructor); tcase_add_test(t_custom_types_inv, test_typecheck_invalid_type_in_typedecl); TCase *t_block_val = tcase_create("typecheck_valid_blocks"); tcase_add_checked_fixture(t_block_val, setup_analyzer_tests, teardown_analyzer_tests); tcase_add_test(t_block_val, test_typecheck_valid_assignment_from_block1); tcase_add_test(t_block_val, test_typecheck_valid_assignment_from_block2); TCase *t_block_inv = tcase_create("typecheck_invalid_blocks"); tcase_add_checked_fixture(t_block_inv, setup_analyzer_tests_with_filelog, teardown_analyzer_tests); tcase_add_test(t_block_inv, test_typecheck_invalid_assignment_from_block1); tcase_add_test(t_block_inv, test_typecheck_invalid_assignment_from_block2); TCase *t_if_val = tcase_create("typecheck_valid_if"); tcase_add_checked_fixture(t_if_val, setup_analyzer_tests, teardown_analyzer_tests); tcase_add_test(t_if_val, test_typecheck_valid_if_stmt); suite_add_tcase(s, t_typecheck_misc); suite_add_tcase(s, t_custom_types_val); suite_add_tcase(s, t_custom_types_inv); suite_add_tcase(s, t_block_val); suite_add_tcase(s, t_block_inv); suite_add_tcase(s, t_if_val); return s; }
void register_type_support_tests(Suite *s) { TCase *tc = tcase_create("type support tests"); tcase_addtests(tc, tests); suite_add_tcase (s, tc); }