自学教程：C++ tcase_set_timeout函数代码示例

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_TESTSuite *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_TESTstatic 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_TESTSuite *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_TESTSuite *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_TESTSuite *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_TESTSuite *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_TESTSuite *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_TESTstatic 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_TESTSuite * 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_TESTSuite *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_TESTSuite * 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_TESTSuite *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_TESTTCase *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#endifstatic 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_TESTstatic 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#endifSuite *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;}