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;
}
