static Suite * camerabin_suite (void) { Suite *s = suite_create ("camerabin"); TCase *tc_basic = tcase_create ("general"); TCase *tc_validate = tcase_create ("validate"); /* Test that basic operations run without errors */ suite_add_tcase (s, tc_basic); /* Increase timeout due to video recording */ tcase_set_timeout (tc_basic, 20); tcase_add_checked_fixture (tc_basic, setup, teardown); tcase_add_test (tc_basic, test_single_image_capture); tcase_add_test (tc_basic, test_single_image_capture_with_flags); tcase_add_test (tc_basic, test_video_recording); tcase_add_test (tc_basic, test_video_recording_with_flags); tcase_add_test (tc_basic, test_video_recording_pause); tcase_add_test (tc_basic, test_video_recording_no_audio); tcase_add_test (tc_basic, test_image_video_cycle); /* Validate captured files */ suite_add_tcase (s, tc_validate); /* Increase timeout due to file playback */ tcase_set_timeout (tc_validate, 20); tcase_add_test (tc_validate, validate_captured_image_files); tcase_add_test (tc_validate, validate_captured_video_files); return s; }
END_TEST Suite * t_datanode_basics_suite() { Suite *s = suite_create("datanode"); TCase *tc = tcase_create("buf"), *tc2; tcase_add_unchecked_fixture(tc, setup_buf, teardown_buf); tcase_set_timeout(tc, 2*60/*2 minutes*/); // Loop each test to send or not send crcs tcase_add_loop_test(tc, test_dn_write_buf, 0, 2); suite_add_tcase(s, tc); tc2 = tcase_create("file"); tcase_add_unchecked_fixture(tc2, setup_file, teardown_file); tcase_set_timeout(tc2, 2*60/*2 minutes*/); // Loop each test to send or not send crcs tcase_add_loop_test(tc2, test_dn_write_file, 0, 2); suite_add_tcase(s, tc2); return s; }
END_TEST static Suite * loop_timer_suite(void) { TCase *tc; Suite *s = suite_create("loop_timers"); tc = tcase_create("limits"); tcase_add_test(tc, test_loop_timer_input); suite_add_tcase(s, tc); tc = tcase_create("basic"); tcase_add_test(tc, test_loop_timer_basic); tcase_set_timeout(tc, 30); suite_add_tcase(s, tc); tc = tcase_create("precision"); tcase_add_test(tc, test_loop_timer_precision); tcase_set_timeout(tc, 30); suite_add_tcase(s, tc); tc = tcase_create("expire_leak"); tcase_add_test(tc, test_loop_timer_expire_leak); tcase_set_timeout(tc, 30); suite_add_tcase(s, tc); return s; }
END_TEST /***************************************************************************** * Test case management *****************************************************************************/ static Suite *mafw_proxy_source_suite_new(void) { Suite *suite; suite = suite_create("MafwProxySource"); checkmore_add_tcase(suite, "Browse", test_browse); tcase_set_timeout(checkmore_add_tcase(suite, "Cancel browse", test_cancel_browse), 5); tcase_set_timeout(checkmore_add_tcase(suite, "Cancel invalid browse session", test_cancel_browse_invalid), 5); checkmore_add_tcase(suite, "Metadata", test_metadata); checkmore_add_tcase(suite, "Metadatas", test_metadatas); checkmore_add_tcase(suite, "Create object", test_object_creation); checkmore_add_tcase(suite, "Destroy object", test_object_destruction); checkmore_add_tcase(suite, "Set metadata", test_set_metadata); checkmore_add_tcase(suite, "Signal testing", test_source_signals); return suite; }
END_TEST /** /** * @brief This runs the marking tests for Assignment 3. */ int main(int argc, char *argv[]) { if(argc == 2) server_port = atoi(argv[1]); else server_port = SERVERPORT; printf("Using server port: %d.\n", server_port); Suite *s = suite_create("SET Testing!!!!!"); TCase *tc; // Config file tests tc = tcase_create("test_with_table_name_null"); tcase_set_timeout(tc, TESTTIMEOUT); tcase_add_checked_fixture(tc, test_setup_simple, test_teardown); tcase_add_test(tc, test_with_table_name_null); suite_add_tcase(s, tc); tc = tcase_create("non_exisiting_table"); tcase_set_timeout(tc, TESTTIMEOUT); tcase_add_checked_fixture(tc, test_setup_simple, test_teardown); tcase_add_test(tc, non_exisiting_table); suite_add_tcase(s, tc); tc = tcase_create("correct_table_input_for_first_table"); tcase_set_timeout(tc, TESTTIMEOUT); tcase_add_checked_fixture(tc, test_setup_simple, test_teardown); tcase_add_test(tc, correct_table_input_for_first_table); suite_add_tcase(s, tc); tc = tcase_create("correct_table_input_for_second_table"); tcase_set_timeout(tc, TESTTIMEOUT); tcase_add_checked_fixture(tc, test_setup_simple, test_teardown); tcase_add_test(tc, correct_table_input_for_second_table); suite_add_tcase(s, tc); tc = tcase_create("correct_table_input_for_third_table"); tcase_set_timeout(tc, TESTTIMEOUT); tcase_add_checked_fixture(tc, test_setup_simple, test_teardown); tcase_add_test(tc, correct_table_input_for_third_table); suite_add_tcase(s, tc); SRunner *sr = srunner_create(s); srunner_set_log(sr, "results.log"); srunner_run_all(sr, CK_ENV); srunner_ntests_failed(sr); srunner_free(sr); return EXIT_SUCCESS; }
END_TEST Suite *ot_suite_failures(void) { Suite *s = suite_create("Failures"); tcase_set_timeout(ot_tcase_add(s, test_suspended_memcache), 60); tcase_set_timeout(ot_tcase_add(s, test_all_backends_fail), 60); return s; }
// create_case_timeout() allow to specific a specific timeout - intended for breaking testcases which needs longer then 30seconds (default) void create_case_timeout(Suite *s, const char *name, TFun function, int timeout) { TCase *tc_new = tcase_create(name); tcase_set_timeout(tc_new, timeout); suite_add_tcase (s, tc_new); tcase_add_test(tc_new, function); }
END_TEST Suite *suite_server_monitor_cstat(void) { Suite *s; TCase *tc_core; s=suite_create("server_monitor_cstat"); tc_core=tcase_create("Core"); tcase_set_timeout(tc_core, 5); tcase_add_test(tc_core, test_cstat_set_backup_list); tcase_add_test(tc_core, test_cstat_set_backup_list_fail_bu_get_list); tcase_add_test(tc_core, test_cstat_get_client_names); tcase_add_test(tc_core, test_cstat_reload_from_client_confs); tcase_add_test(tc_core, test_cstat_remove_first); tcase_add_test(tc_core, test_cstat_remove_second); tcase_add_test(tc_core, test_cstat_remove_third); tcase_add_test(tc_core, test_cstat_remove_fourth); tcase_add_test(tc_core, test_cstat_remove_only); tcase_add_test(tc_core, test_cstat_add_out_of_order); tcase_add_test(tc_core, test_cstat_set_run_status); tcase_add_test(tc_core, test_cstat_reload_from_clientdir); tcase_add_test(tc_core, test_cstat_permitted); tcase_add_test(tc_core, test_cstat_load_data_from_disk); suite_add_tcase(s, tc_core); return s; }
static Suite * adder_suite (void) { Suite *s = suite_create ("adder"); TCase *tc_chain = tcase_create ("general"); suite_add_tcase (s, tc_chain); tcase_add_test (tc_chain, test_event); tcase_add_test (tc_chain, test_play_twice); tcase_add_test (tc_chain, test_play_twice_then_add_and_play_again); tcase_add_test (tc_chain, test_live_seeking); tcase_add_test (tc_chain, test_add_pad); tcase_add_test (tc_chain, test_remove_pad); tcase_add_test (tc_chain, test_clip); /* Use a longer timeout */ #ifdef HAVE_VALGRIND if (RUNNING_ON_VALGRIND) { tcase_set_timeout (tc_chain, 5 * 60); } else #endif { /* this is shorter than the default 60 seconds?! (tpm) */ /* tcase_set_timeout (tc_chain, 6); */ } return s; }
static Suite * gst_object_suite (void) { Suite *s = suite_create ("GstObject"); TCase *tc_chain = tcase_create ("general"); /* turn off timeout */ tcase_set_timeout (tc_chain, 60); suite_add_tcase (s, tc_chain); tcase_add_test (tc_chain, test_fake_object_new); tcase_add_test (tc_chain, test_fake_object_name); #if 0 tcase_add_test (tc_chain, test_fake_object_name_threaded_wrong); #endif tcase_add_test (tc_chain, test_fake_object_name_threaded_right); tcase_add_test (tc_chain, test_fake_object_name_threaded_unique); tcase_add_test (tc_chain, test_fake_object_parentage); tcase_add_test (tc_chain, test_fake_object_parentage_dispose); tcase_add_test (tc_chain, test_fake_object_has_ancestor); //tcase_add_checked_fixture (tc_chain, setup, teardown); return s; }
END_TEST Suite *test_suite(void) { Suite *s = suite_create("os_net"); TCase *tc_tcp = tcase_create("TCP"); tcase_add_test(tc_tcp, test_tcpv4_local); tcase_add_test(tc_tcp, test_tcpv4_inet); tcase_add_test(tc_tcp, test_tcpv6); tcase_add_test(tc_tcp, test_tcpinvalidsockets); TCase *tc_udp = tcase_create("UDP"); tcase_add_test(tc_udp, test_udpv4); tcase_add_test(tc_udp, test_udpv6); tcase_add_test(tc_udp, test_udpinvalidsockets); TCase *tc_unix = tcase_create("Unix"); tcase_add_test(tc_unix, test_unix); tcase_add_test(tc_unix, test_unixinvalidsockets); TCase *tc_gethost = tcase_create("GetHost"); tcase_add_test(tc_gethost, test_gethost_success); tcase_add_test(tc_gethost, test_gethost_fail1); tcase_add_test(tc_gethost, test_gethost_fail2); tcase_set_timeout(tc_gethost, 10); suite_add_tcase(s, tc_tcp); suite_add_tcase(s, tc_udp); suite_add_tcase(s, tc_unix); suite_add_tcase(s, tc_gethost); return (s); }
END_TEST Suite *suite_server_monitor_json_output(void) { Suite *s; TCase *tc_core; s=suite_create("server_monitor_json_output"); tc_core=tcase_create("Core"); tcase_set_timeout(tc_core, 5); tcase_add_test(tc_core, cleanup); tcase_add_test(tc_core, test_json_send_warn); tcase_add_test(tc_core, test_json_send_empty); tcase_add_test(tc_core, test_json_send_clients); tcase_add_test(tc_core, test_json_send_clients_with_backup); tcase_add_test(tc_core, test_json_send_clients_with_backups); tcase_add_test(tc_core, test_json_send_clients_with_backups_working); tcase_add_test(tc_core, test_json_send_clients_with_backups_finishing); tcase_add_test(tc_core, test_json_send_client_specific); tcase_add_test(tc_core, test_json_matching_output); tcase_add_test(tc_core, cleanup); suite_add_tcase(s, tc_core); return s; }
END_TEST Suite *suite_client_monitor_status_client_ncurses(void) { Suite *s; TCase *tc_core; s=suite_create("client_monitor_status_client_ncurses"); tc_core=tcase_create("Core"); tcase_set_timeout(tc_core, 60); tcase_add_test(tc_core, test_status_client_ncurses_null_as); tcase_add_test(tc_core, test_status_client_ncurses_read_error); tcase_add_test(tc_core, test_status_client_ncurses_simplest_json); tcase_add_test(tc_core, test_status_client_ncurses_multiline_json); tcase_add_test(tc_core, test_status_client_ncurses_bad_json); tcase_add_test(tc_core, test_status_client_ncurses_up); tcase_add_test(tc_core, test_status_client_ncurses_quit); tcase_add_test(tc_core, test_status_client_ncurses_input_size_error); tcase_add_test(tc_core, test_status_client_ncurses_input_error); tcase_add_test(tc_core, test_status_client_ncurses_with_clients); tcase_add_test(tc_core, test_status_client_ncurses_with_clients_down); tcase_add_test(tc_core, test_status_client_ncurses_with_clients_downx2); tcase_add_test(tc_core, test_status_client_ncurses_with_orig_client); suite_add_tcase(s, tc_core); return s; }
static Suite * baseaudiosrc_suite (void) { Suite *s = suite_create ("baseaudiosrc"); TCase *tc_chain = tcase_create ("general"); guint timeout; /* timeout 6 sec */ timeout = 6; #ifdef HAVE_VALGRIND { if (RUNNING_ON_VALGRIND) timeout *= 4; } #endif tcase_set_timeout (tc_chain, timeout); suite_add_tcase (s, tc_chain); #ifndef GST_DISABLE_PARSE tcase_add_test (tc_chain, test_basetime_calculation); #endif return s; }
END_TEST /* ---------------------------------------------------------------------- */ TCase *register_tcase(int threading) { TCase *tc = tcase_create("1 - REGISTER"); add_register_fixtures(tc, threading, 0); { tcase_add_test(tc, register_1_0_1); tcase_add_test(tc, register_1_1_1); tcase_add_test(tc, register_1_1_2); tcase_add_test(tc, register_1_2_1); tcase_add_test(tc, register_1_2_2_1); tcase_add_test(tc, register_1_2_2_2); tcase_add_test(tc, register_1_2_2_3); tcase_add_test(tc, register_1_2_3); tcase_add_test(tc, register_1_3_1); tcase_add_test(tc, register_1_3_2_1); tcase_add_test(tc, register_1_3_2_2); } tcase_set_timeout(tc, 10); return tc; }
Suite * eina_build_suite(int argc, const char **argv) { TCase *tc; Suite *s; int i; s = suite_create("Eina"); for (i = 0; etc[i].test_case; ++i) { if (!_use_test(argc, argv, etc[i].test_case)) continue; tc = tcase_create(etc[i].test_case); #ifndef _WIN32 tcase_set_timeout(tc, 0); #endif etc[i].build(tc); suite_add_tcase(s, tc); } return s; }
static Suite * gst_plugin_suite (void) { Suite *s = suite_create ("GstPlugin"); TCase *tc_chain = tcase_create ("general"); /* turn off timeout */ tcase_set_timeout (tc_chain, 60); suite_add_tcase (s, tc_chain); #ifdef GST_GNUC_CONSTRUCTOR_DEFINED tcase_add_test (tc_chain, test_old_register_static); #endif tcase_add_test (tc_chain, test_register_static); tcase_add_test (tc_chain, test_registry); tcase_add_test (tc_chain, test_load_coreelements); tcase_add_test (tc_chain, test_registry_get_plugin_list); tcase_add_test (tc_chain, test_find_plugin); tcase_add_test (tc_chain, test_find_feature); tcase_add_test (tc_chain, test_find_element); tcase_add_test (tc_chain, test_version_checks); //tcase_add_test (tc_chain, test_typefind); return s; }
END_TEST static Suite *libjwt_suite(void) { Suite *s; TCase *tc_core; s = suite_create("LibJWT Encode"); tc_core = tcase_create("jwt_encode"); tcase_add_test(tc_core, test_jwt_encode_fp); tcase_add_test(tc_core, test_jwt_encode_str); tcase_add_test(tc_core, test_jwt_encode_alg_none); tcase_add_test(tc_core, test_jwt_encode_hs256); tcase_add_test(tc_core, test_jwt_encode_hs384); tcase_add_test(tc_core, test_jwt_encode_hs512); tcase_add_test(tc_core, test_jwt_encode_change_alg); tcase_add_test(tc_core, test_jwt_encode_invalid); tcase_set_timeout(tc_core, 30); suite_add_tcase(s, tc_core); return s; }
int main(void) { setlogmask(LOG_UPTO(LOG_DEBUG)); Suite *s1 = suite_create("art"); TCase *tc1 = tcase_create("art"); SRunner *sr = srunner_create(s1); int nf; // Add the art tests suite_add_tcase(s1, tc1); tcase_add_test(tc1, test_art_init_and_destroy); tcase_add_test(tc1, test_art_insert); tcase_add_test(tc1, test_art_insert_verylong); tcase_add_test(tc1, test_art_insert_search); tcase_add_test(tc1, test_art_insert_delete); tcase_add_test(tc1, test_art_insert_random_delete); tcase_add_test(tc1, test_art_insert_iter); tcase_add_test(tc1, test_art_iter_prefix); tcase_add_test(tc1, test_art_long_prefix); tcase_add_test(tc1, test_art_insert_search_uuid); tcase_add_test(tc1, test_art_max_prefix_len_scan_prefix); tcase_set_timeout(tc1, 180); srunner_run_all(sr, CK_ENV); nf = srunner_ntests_failed(sr); srunner_free(sr); return nf == 0 ? 0 : 1; }
}END_TEST Suite * leds_suite(void) { Suite *s = suite_create("Leds"); TCase *tc = tcase_create("Core"); tcase_add_checked_fixture(tc,setup,teardown); tcase_add_test(tc,test_init); tcase_add_test(tc,test_loop_full); tcase_add_test(tc,test_loop_full2); tcase_add_test(tc,test_loop_half1); tcase_add_test(tc,test_loop_half2); tcase_add_test(tc,test_loop_lesshalf1); tcase_add_test(tc,test_loop_lesshalf2); tcase_add_test(tc,test_loop_halfempty1); tcase_add_test(tc,test_loop_halfempty2); tcase_add_test(tc,test_loop_empty1); tcase_add_test(tc,test_loop_empty2); tcase_add_test(tc,test_loop_fullempty); tcase_add_test(tc,test_loop_timer); tcase_add_test(tc,test_loop_ledState1); tcase_add_test(tc,test_loop_ledState2); tcase_set_timeout(tc,0); suite_add_tcase(s,tc); return s; }
static Suite * rtspclient_suite (void) { Suite *s = suite_create ("rtspclient"); TCase *tc = tcase_create ("general"); suite_add_tcase (s, tc); tcase_set_timeout (tc, 20); // tcase_add_test (tc, test_request); // tcase_add_test (tc, test_options); tcase_add_test (tc, test_describe); #if 0 tcase_add_test (tc, test_client_multicast_transport_404); tcase_add_test (tc, test_client_multicast_transport); tcase_add_test (tc, test_client_multicast_ignore_transport_specific); tcase_add_test (tc, test_client_multicast_invalid_transport_specific); tcase_add_test (tc, test_client_multicast_transport_specific); tcase_add_test (tc, test_client_sdp_with_max_bitrate_tag); tcase_add_test (tc, test_client_sdp_with_bitrate_tag); tcase_add_test (tc, test_client_sdp_with_max_bitrate_and_bitrate_tags); tcase_add_test (tc, test_client_sdp_with_no_bitrate_tags); #endif return s; }
END_TEST Suite *sed_plume_suite( void ) { Suite *s = suite_create( "Plume" ); TCase *test_case_core = tcase_create( "Core" ); TCase *test_case_approx = tcase_create( "Approximation" ); TCase *test_case_num = tcase_create( "Numerical" ); suite_add_tcase( s , test_case_core ); suite_add_tcase( s , test_case_approx ); suite_add_tcase( s , test_case_num ); tcase_set_timeout( test_case_num , 0 ); /* tcase_add_test( test_case_core , test_plume ); // tcase_add_test( test_case_core , test_plume_from_file ); tcase_add_test( test_case_approx , test_approx_nd ); tcase_add_test( test_case_approx , test_approx_deposit_nd ); tcase_add_test( test_case_approx , test_approx_from_file ); */ tcase_add_test( test_case_num , test_i_bar ); return s; }
} END_TEST Suite * check_suite(void) { Suite *s = suite_create("lhtable"); /* Begin a new test */ TCase *tc = tcase_create("lhtable"); tcase_set_timeout(tc, 0); // disable timeouts srandom(43); /* Sub tests are added, one per line, here */ tcase_add_test(tc, singleThreadHashTest); #ifndef DBUG_TEST // TODO should run exactly one of these two tests under dbug. Need good way to choose which one. tcase_add_test(tc, wraparoundHashTest); tcase_add_test(tc, concurrentHashTest); #endif /* --------------------------------------------- */ tcase_add_checked_fixture(tc, setup, teardown); suite_add_tcase(s, tc); return s; }
void create_case_fixture(Suite *s, const char *name, TFun function, void (*setup)(void), void (*teardown)(void)) { TCase *tc_new = tcase_create(name); tcase_add_checked_fixture(tc_new, setup, teardown); tcase_set_timeout(tc_new, 30); suite_add_tcase (s, tc_new); tcase_add_test(tc_new, function); }
END_TEST Suite *suite_client_restore(void) { Suite *s; TCase *tc_core; s=suite_create("client_restore"); tc_core=tcase_create("Core"); tcase_set_timeout(tc_core, 60); tcase_add_test(tc_core, test_restore_proto1_bad_read); tcase_add_test(tc_core, test_restore_proto1_no_files); tcase_add_test(tc_core, test_restore_proto1_no_datapth); tcase_add_test(tc_core, test_restore_proto1_no_attribs); tcase_add_test(tc_core, test_restore_proto1_some_things); tcase_add_test(tc_core, test_restore_proto2_bad_read); tcase_add_test(tc_core, test_restore_proto2_some_things); tcase_add_test(tc_core, test_restore_proto2_interrupt); suite_add_tcase(s, tc_core); return s; }
END_TEST TCase * libanoubissig_testcase_signature(void) { TCase *testcase = tcase_create("Signature"); tcase_set_timeout(testcase, 120); tcase_add_checked_fixture(testcase, libanoubissig_tc_setup, libanoubissig_tc_teardown); tcase_add_test(testcase, sign_and_verify_match_tc); tcase_add_test(testcase, sign_and_verify_mismatch_tc); tcase_add_test(testcase, t_anoubis_sign_csum); tcase_add_test(testcase, t_anoubis_verify_policy); tcase_add_test(testcase, t_anoubis_validity_check); tcase_add_test(testcase, t_anoubis_sig_keycmp_einval); tcase_add_test(testcase, t_anoubis_sig_keycmp_pp_match); tcase_add_test(testcase, t_anoubis_sig_keycmp_pp_mismatch); tcase_add_test(testcase, t_anoubis_sig_keycmp_pc_match); tcase_add_test(testcase, t_anoubis_sig_keycmp_pc_mismatch); tcase_add_test(testcase, t_anoubis_sig_keycmp_cc_match); tcase_add_test(testcase, t_anoubis_sig_keycmp_cc_mismatch); return (testcase); }
END_TEST #endif static TCase * modem_sim_api_tcase(void) { TCase *tc = tcase_create("modem-sim"); #if XXX tcase_add_checked_fixture(tc, modem_sim_api_init, NULL); { tcase_add_test(tc, modem_sim_api); tcase_add_test(tc, modem_sim_api2); tcase_add_test(tc, modem_sim_requests); } tcase_set_timeout(tc, 40); #endif return tc; }
} END_TEST /** Add suite declarations here */ Suite * check_suite(void) { Suite *s = suite_create("regions"); /* Begin a new test */ TCase *tc = tcase_create("regions_test"); tcase_set_timeout(tc, 0); // disable timeouts stasis_log_softcommit = 1; // disable forcing log at commit /* Sub tests are added, one per line, here */ tcase_add_test(tc, regions_smokeTest); tcase_add_test(tc, regions_randomizedTest); tcase_add_test(tc, regions_lockSmokeTest); tcase_add_test(tc, regions_lockRandomizedTest); tcase_add_test(tc, regions_recoveryTest); /* --------------------------------------------- */ tcase_add_checked_fixture(tc, setup, teardown); suite_add_tcase(s, tc); return s; }
END_TEST static Suite *test_clamd_suite(void) { Suite *s = suite_create("clamd"); TCase *tc_commands, *tc_stress; tc_commands = tcase_create("clamd commands"); suite_add_tcase(s, tc_commands); tcase_add_unchecked_fixture(tc_commands, commands_setup, commands_teardown); #ifdef CHECK_HAVE_LOOPS tcase_add_loop_test(tc_commands, test_basic_commands, 0, sizeof(basic_tests)/sizeof(basic_tests[0])); tcase_add_loop_test(tc_commands, test_compat_commands, 0, sizeof(basic_tests)/sizeof(basic_tests[0])); tcase_add_loop_test(tc_commands, test_fildes, 0, 4*sizeof(fildes_cmds)/sizeof(fildes_cmds[0])); #endif tcase_add_test(tc_commands, test_stats); tcase_add_test(tc_commands, test_instream); tcase_add_test(tc_commands, test_stream); tcase_add_test(tc_commands, test_idsession); tc_stress = tcase_create("clamd stress test"); suite_add_tcase(s, tc_stress); tcase_set_timeout(tc_stress, 20); tcase_add_test(tc_stress, test_fildes_many); tcase_add_test(tc_stress, test_idsession_stress); tcase_add_test(tc_stress, test_fildes_unwanted); #ifndef C_BSD /* FreeBSD and Darwin: connect() says connection refused on both * tcp/unix sockets, if I too quickly connect ~193 times, even if * listen backlog is higher. * Don't run this test on BSD for now */ tcase_add_test(tc_stress, test_connections); #endif return s; }
END_TEST #endif Suite * getdns_context_set_timeout_suite (void) { Suite *s = suite_create ("getdns_context_set_timeout()"); /* Negative test caseis */ TCase *tc_neg = tcase_create("Negative"); tcase_add_test(tc_neg, getdns_context_set_timeout_1); tcase_add_test(tc_neg, getdns_context_set_timeout_2); suite_add_tcase(s, tc_neg); /* Positive test cases */ /* Temporarily disabled because of unpredictable results */ #if 0 TCase *tc_pos = tcase_create("Positive"); tcase_set_timeout(tc_pos, 15.0); tcase_add_test(tc_pos, getdns_context_set_timeout_3); suite_add_tcase(s, tc_pos); #endif return s; }