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

END_TEST/*----------------------------------------------------------------------- * Testing harness */Suite *ipset_suite(){    Suite  *s = suite_create("ipset");    TCase  *tc_general = tcase_create("general");    tcase_add_test(tc_general, test_set_starts_empty);    tcase_add_test(tc_general, test_empty_sets_equal);    tcase_add_test(tc_general, test_empty_sets_not_unequal);    tcase_add_test(tc_general, test_store_empty);    suite_add_tcase(s, tc_general);    TCase  *tc_ipv4 = tcase_create("ipv4");    tcase_add_test(tc_ipv4, test_ipv4_insert_01);    tcase_add_test(tc_ipv4, test_ipv4_insert_02);    tcase_add_test(tc_ipv4, test_ipv4_insert_network_01);    tcase_add_test(tc_ipv4, test_ipv4_insert_network_02);    tcase_add_test(tc_ipv4, test_ipv4_bad_netmask_01);    tcase_add_test(tc_ipv4, test_ipv4_bad_netmask_02);    tcase_add_test(tc_ipv4, test_ipv4_equality_1);    tcase_add_test(tc_ipv4, test_ipv4_inequality_1);    tcase_add_test(tc_ipv4, test_ipv4_memory_size_1);    tcase_add_test(tc_ipv4, test_ipv4_memory_size_2);    tcase_add_test(tc_ipv4, test_ipv4_store_01);    tcase_add_test(tc_ipv4, test_ipv4_store_02);    tcase_add_test(tc_ipv4, test_ipv4_store_03);    suite_add_tcase(s, tc_ipv4);    TCase  *tc_ipv6 = tcase_create("ipv6");    tcase_add_test(tc_ipv6, test_ipv6_insert_01);    tcase_add_test(tc_ipv6, test_ipv6_insert_02);    tcase_add_test(tc_ipv6, test_ipv6_insert_network_01);    tcase_add_test(tc_ipv6, test_ipv6_insert_network_02);    tcase_add_test(tc_ipv6, test_ipv6_bad_netmask_01);    tcase_add_test(tc_ipv6, test_ipv6_bad_netmask_02);    tcase_add_test(tc_ipv6, test_ipv6_equality_1);    tcase_add_test(tc_ipv6, test_ipv6_inequality_1);    tcase_add_test(tc_ipv6, test_ipv6_memory_size_1);    tcase_add_test(tc_ipv6, test_ipv6_memory_size_2);    tcase_add_test(tc_ipv6, test_ipv6_store_01);    tcase_add_test(tc_ipv6, test_ipv6_store_02);    tcase_add_test(tc_ipv6, test_ipv6_store_03);    suite_add_tcase(s, tc_ipv6);    return s;}

} END_TESTSuite *mapistore_namedprops_mysql_suite(void){	Suite	*s;	TCase	*tc_config;	TCase	*tc_mysql;	TCase	*tc_mysql_q;	s = suite_create("libmapistore named properties: MySQL backend");	/* Core / Configuration */	tc_config = tcase_create("MySQL backend configuration");	tcase_add_test(tc_config, test_parameters);	suite_add_tcase(s, tc_config);	/* MySQL initialization */	tc_mysql = tcase_create("MySQL initialization");	/* database provisioning takes longer than default timeout */	tcase_set_timeout(tc_mysql, 60);	tcase_add_checked_fixture(tc_mysql, checked_mysql_setup, checked_mysql_teardown);	tcase_add_test(tc_mysql, test_create_schema);	tcase_add_test(tc_mysql, test_is_schema_created);	tcase_add_test(tc_mysql, test_initialize_database);	suite_add_tcase(s, tc_mysql);	/* MySQL queries */	tc_mysql_q = tcase_create("MySQL queries");	tcase_set_timeout(tc_mysql_q, 60);	tcase_add_checked_fixture(tc_mysql_q, checked_mysql_query_setup, checked_mysql_query_teardown);	tcase_add_test(tc_mysql_q, test_next_unused_id);	tcase_add_test(tc_mysql_q, test_get_mapped_id_MNID_ID);	tcase_add_test(tc_mysql_q, test_get_mapped_id_MNID_STRING);	tcase_add_test(tc_mysql_q, test_get_mapped_id_not_found);	tcase_add_test(tc_mysql_q, test_get_nameid_type);	tcase_add_test(tc_mysql_q, test_get_nameid_type_not_found);	tcase_add_test(tc_mysql_q, test_get_nameid_MNID_ID);	tcase_add_test(tc_mysql_q, test_get_nameid_MNID_STRING);	tcase_add_test(tc_mysql_q, test_get_nameid_not_found);	tcase_add_test(tc_mysql_q, test_create_id_MNID_ID);	tcase_add_test(tc_mysql_q, test_create_id_MNID_STRING);	suite_add_tcase(s, tc_mysql_q);	return s;}

END_TESTSuite *create_suite_CubicBezier (void){  Suite *suite = suite_create("CubicBezier");  TCase *tcase = tcase_create("CubicBezier");      tcase_add_checked_fixture( tcase,                            CubicBezierTest_setup,                            CubicBezierTest_teardown );    tcase_add_test( tcase, test_CubicBezier_create                );  tcase_add_test( tcase, test_CubicBezier_createWithPoints      );  tcase_add_test( tcase, test_CubicBezier_createWithPoints_NULL );  tcase_add_test( tcase, test_CubicBezier_createWithCoordinates );  tcase_add_test( tcase, test_CubicBezier_free_NULL             );  tcase_add_test( tcase, test_CubicBezier_setStart              );  tcase_add_test( tcase, test_CubicBezier_setStart_NULL         );  tcase_add_test( tcase, test_CubicBezier_setBasePoint1         );  tcase_add_test( tcase, test_CubicBezier_setBasePoint1_NULL    );  tcase_add_test( tcase, test_CubicBezier_setBasePoint2         );  tcase_add_test( tcase, test_CubicBezier_setBasePoint2_NULL    );  tcase_add_test( tcase, test_CubicBezier_setEnd                );  tcase_add_test( tcase, test_CubicBezier_setEnd_NULL           );  tcase_add_test( tcase, test_CubicBezier_createFrom            );  tcase_add_test( tcase, test_CubicBezier_copyConstructor       );  tcase_add_test( tcase, test_CubicBezier_assignmentOperator    );    suite_add_tcase(suite, tcase);    return suite;}

END_TESTSuite* suite(void) {    Suite* s = suite_create("queue");    TCase *tc_core = tcase_create("core");    tcase_add_checked_fixture (tc_core, setup, teardown);    tcase_add_test(tc_core, test_init);    tcase_add_test(tc_core, test_get);    tcase_add_test(tc_core, test_get_missing);    tcase_add_test(tc_core, test_put);    tcase_add_test(tc_core, test_put_multiple);    tcase_add_test(tc_core, test_fill_up);    tcase_add_test(tc_core, test_overwrite);    tcase_add_test(tc_core, test_contains);    tcase_add_test(tc_core, test_does_not_contain);    tcase_add_test(tc_core, test_remove);    tcase_add_test(tc_core, test_remove_not_in_map);    tcase_add_test(tc_core, test_is_empty);    tcase_add_test(tc_core, test_size);    tcase_add_test(tc_core, test_create);    tcase_add_test(tc_core, test_iterate_empty);    tcase_add_test(tc_core, test_iterate_one);    tcase_add_test(tc_core, test_iterate_many);    suite_add_tcase(s, tc_core);    return s;}

END_TESTSuite *req_jobobit_suite(void)  {  Suite *s = suite_create("req_jobobit_suite methods");  TCase *tc_core = tcase_create("req_jobobit_tests");  tcase_add_test(tc_core, setup_from_test);  tcase_add_test(tc_core, is_joined_test);  tcase_add_test(tc_core, return_stdfile_test);  tcase_add_test(tc_core, rel_resc_test);  tcase_add_test(tc_core, handle_exiting_or_abort_substate_test);  tcase_add_test(tc_core, setrerun_test);  tcase_add_test(tc_core, setup_cpyfiles_test);  tcase_add_test(tc_core, handle_returnstd_test);  tcase_add_test(tc_core, mom_comm_test);  tcase_add_test(tc_core, handle_complete_first_time_test);  tcase_add_test(tc_core, handle_complete_second_time_test);  tcase_add_test(tc_core, handle_complete_subjob_test);  tcase_add_test(tc_core, handle_exited_test);  tcase_add_test(tc_core, add_comment_to_parent_test);  tcase_add_test(tc_core, end_of_job_accounting_test);  tcase_add_test(tc_core, handle_terminating_array_subjob_test);  tcase_add_test(tc_core, handle_rerunning_array_subjob_test);  tcase_add_test(tc_core, handle_terminating_job_test);  tcase_add_test(tc_core, handle_stageout_test);  tcase_add_test(tc_core, update_substate_from_exit_status_test);  tcase_add_test(tc_core, handle_stagedel_test);  tcase_add_test(tc_core, get_used_test);  suite_add_tcase(s, tc_core);  return(s);  }

END_TESTvoid add_common_tests(Suite *s){	TCase *tc_common = tcase_create("Common");	tcase_add_test(tc_common, printe_options);	tcase_add_test(tc_common, logprint_options);	tcase_add_loop_test(tc_common, dmonth_return_within_range, 0, 12);	tcase_add_test(tc_common, leapyears_are_known);	tcase_add_test(tc_common, mosecs_return_values);	tcase_add_test(tc_common, mosecs_does_not_change_tz);	tcase_add_test(tc_common, mosecs_does_not_change_struct_tm_pointer_content);	tcase_add_test(tc_common, countercalc_no_change_32bit);	tcase_add_test(tc_common, countercalc_no_change_64bit);	tcase_add_test(tc_common, countercalc_small_change_32bit);	tcase_add_test(tc_common, countercalc_small_change_64bit);	tcase_add_test(tc_common, countercalc_rollover_with_32bit);	tcase_add_test(tc_common, countercalc_rollover_with_64bit);	tcase_add_test(tc_common, countercalc_rollover_with_64bit_2);	tcase_add_test(tc_common, countercalc_rollover_with_32bit_starting_32bit);	tcase_add_test(tc_common, countercalc_rollover_with_32bit_starting_over_32bit);	tcase_add_test(tc_common, countercalc_rollover_with_64bit_starting_32bit);	tcase_add_test(tc_common, countercalc_rollover_with_64bit_starting_64bit);	tcase_add_test(tc_common, strncpy_nt_with_below_maximum_length_string);	tcase_add_test(tc_common, strncpy_nt_with_maximum_length_string);	tcase_add_test(tc_common, strncpy_nt_with_over_maximum_length_string);	tcase_add_test(tc_common, isnumeric_empty);	tcase_add_test(tc_common, isnumeric_it_is);	tcase_add_test(tc_common, isnumeric_it_is_not);	tcase_add_test(tc_common, getversion_returns_a_version);	tcase_add_test(tc_common, timeused_debug_outputs_something_expected_when_debug_is_enabled);	tcase_add_test(tc_common, timeused_debug_does_not_output_anything_when_debug_is_disabled);	tcase_add_test(tc_common, timeused_tracks_used_time);	tcase_add_exit_test(tc_common, can_panic, 1);	suite_add_tcase(s, tc_common);}

END_TESTSuite *pico_suite(void){    Suite *s = suite_create("PicoTCP");    TCase *TCase_check_opcode = tcase_create("Unit test for check_opcode");    TCase *TCase_find_session_by_socket = tcase_create("Unit test for find_session_by_socket");    TCase *TCase_tftp_finish = tcase_create("Unit test for tftp_finish");    TCase *TCase_tftp_send_ack = tcase_create("Unit test for tftp_send_ack");    TCase *TCase_tftp_send_req = tcase_create("Unit test for tftp_send_req");    TCase *TCase_tftp_send_rx_req = tcase_create("Unit test for tftp_send_rx_req");    TCase *TCase_tftp_send_tx_req = tcase_create("Unit test for tftp_send_tx_req");    TCase *TCase_tftp_send_error = tcase_create("Unit test for tftp_send_error");    TCase *TCase_tftp_send_data = tcase_create("Unit test for tftp_send_data");    TCase *Tcase_pico_tftp_abort = tcase_create("Unit test for pico_tftp_abort");    TCase *TCase_tftp_data = tcase_create("Unit test for tftp_data");    TCase *TCase_tftp_ack = tcase_create("Unit test for tftp_ack");    TCase *TCase_tftp_timeout = tcase_create("Unit test for tftp_timeout");    TCase *TCase_tftp_req = tcase_create("Unit test for tftp_req");    TCase *TCase_tftp_data_err = tcase_create("Unit test for tftp_data_err");    TCase *TCase_tftp_fsm_timeout = tcase_create("Unit test for tftp_fsm_timeout");    TCase *TCase_tftp_receive = tcase_create("Unit test for tftp_receive");    TCase *TCase_tftp_cb = tcase_create("Unit test for tftp_cb");    TCase *TCase_tftp_socket_open = tcase_create("Unit test for tftp_socket_open");    tcase_add_test(TCase_check_opcode, tc_check_opcode);    suite_add_tcase(s, TCase_check_opcode);    tcase_add_test(TCase_find_session_by_socket, tc_find_session_by_socket);    suite_add_tcase(s, TCase_find_session_by_socket);    tcase_add_test(TCase_tftp_finish, tc_tftp_finish);    suite_add_tcase(s, TCase_tftp_finish);    tcase_add_test(TCase_tftp_send_ack, tc_tftp_send_ack);    suite_add_tcase(s, TCase_tftp_send_ack);    tcase_add_test(TCase_tftp_send_req, tc_tftp_send_req);    suite_add_tcase(s, TCase_tftp_send_req);    tcase_add_test(TCase_tftp_send_rx_req, tc_tftp_send_rx_req);    suite_add_tcase(s, TCase_tftp_send_rx_req);    tcase_add_test(TCase_tftp_send_tx_req, tc_tftp_send_tx_req);    suite_add_tcase(s, TCase_tftp_send_tx_req);    tcase_add_test(TCase_tftp_send_error, tc_tftp_send_error);    suite_add_tcase(s, TCase_tftp_send_error);    tcase_add_test(TCase_tftp_send_data, tc_tftp_send_data);    suite_add_tcase(s, TCase_tftp_send_data);    tcase_add_test(TCase_tftp_data, tc_tftp_data);    suite_add_tcase(s, Tcase_pico_tftp_abort);    tcase_add_test(Tcase_pico_tftp_abort, tc_pico_tftp_abort);    suite_add_tcase(s, TCase_tftp_data);    tcase_add_test(TCase_tftp_ack, tc_tftp_ack);    suite_add_tcase(s, TCase_tftp_ack);    tcase_add_test(TCase_tftp_timeout, tc_tftp_timeout);    suite_add_tcase(s, TCase_tftp_timeout);    tcase_add_test(TCase_tftp_req, tc_tftp_req);    suite_add_tcase(s, TCase_tftp_req);    tcase_add_test(TCase_tftp_data_err, tc_tftp_data_err);    suite_add_tcase(s, TCase_tftp_data_err);    tcase_add_test(TCase_tftp_fsm_timeout, tc_tftp_fsm_timeout);    suite_add_tcase(s, TCase_tftp_fsm_timeout);    tcase_add_test(TCase_tftp_receive, tc_tftp_receive);    suite_add_tcase(s, TCase_tftp_receive);    tcase_add_test(TCase_tftp_cb, tc_tftp_cb);    suite_add_tcase(s, TCase_tftp_cb);    tcase_add_test(TCase_tftp_socket_open, tc_tftp_socket_open);    suite_add_tcase(s, TCase_tftp_socket_open);    return s;}

END_TEST/* Create Suite */Suite *inpdbzone_suite(void){   Suite *s = suite_create("InPDBZone");   TCase *tc_core          = tcase_create("Core"),         *tc_single_resnum = tcase_create("Single_Resnum"),         *tc_wrapper       = tcase_create("Wrapper");   /* blInPDBZone() */   /* Core */   tcase_add_checked_fixture(tc_core, inpdbzone_setup,                              inpdbzone_teardown);   tcase_add_test(tc_core, test_01);   tcase_add_test(tc_core, test_02);   tcase_add_test(tc_core, test_03);   tcase_add_test(tc_core, test_04);   tcase_add_test(tc_core, test_05);   tcase_add_test(tc_core, test_06);   tcase_add_test(tc_core, test_07);   tcase_add_test(tc_core, test_08);   tcase_add_test(tc_core, test_09);   tcase_add_test(tc_core, test_10);   tcase_add_test(tc_core, test_11);   tcase_add_test(tc_core, test_12);   suite_add_tcase(s, tc_core);   /* Single resnum */   tcase_add_checked_fixture(tc_single_resnum, inpdbzone_setup,                              inpdbzone_teardown);   tcase_add_test(tc_single_resnum, test_single_resnum_01);   tcase_add_test(tc_single_resnum, test_single_resnum_02);   tcase_add_test(tc_single_resnum, test_single_resnum_03);   tcase_add_test(tc_single_resnum, test_single_resnum_04);   tcase_add_test(tc_single_resnum, test_single_resnum_05);   tcase_add_test(tc_single_resnum, test_single_resnum_06);   tcase_add_test(tc_single_resnum, test_single_resnum_07);   tcase_add_test(tc_single_resnum, test_single_resnum_08);   suite_add_tcase(s, tc_single_resnum);   /* blInPDBZoneSpec() */   /* Wrapper */   tcase_add_checked_fixture(tc_wrapper, inpdbzone_setup,                              inpdbzone_teardown);   tcase_add_test(tc_wrapper, test_wrapper_01);   tcase_add_test(tc_wrapper, test_wrapper_02);   tcase_add_test(tc_wrapper, test_wrapper_03);   tcase_add_test(tc_wrapper, test_wrapper_04);   tcase_add_test(tc_wrapper, test_wrapper_05);   tcase_add_test(tc_wrapper, test_wrapper_06);      suite_add_tcase(s, tc_wrapper);   return(s);}

END_TESTSuite* roman_converter_suite(void){    Suite *s;    TCase *tc_convert_to_arabic;    TCase *tc_convert_to_roman;    TCase *tc_invalid;    s = suite_create("Roman Numerals Converter");    tc_convert_to_arabic = tcase_create("Convert to Arabic");    tc_convert_to_roman = tcase_create("Convert to Roman");    tc_invalid = tcase_create("Invalid");    // Convert to arabic test case    tcase_add_test(tc_convert_to_arabic, test_convert_I_to_1);    tcase_add_test(tc_convert_to_arabic, test_convert_II_to_2);    tcase_add_test(tc_convert_to_arabic, test_convert_IV_to_4);    tcase_add_test(tc_convert_to_arabic, test_convert_V_to_5);    tcase_add_test(tc_convert_to_arabic, test_convert_VI_to_6);    tcase_add_test(tc_convert_to_arabic, test_convert_IX_to_9);    tcase_add_test(tc_convert_to_arabic, test_convert_X_to_10);    tcase_add_test(tc_convert_to_arabic, test_convert_XL_to_40);    tcase_add_test(tc_convert_to_arabic, test_convert_L_to_50);    tcase_add_test(tc_convert_to_arabic, test_convert_XC_to_90);    tcase_add_test(tc_convert_to_arabic, test_convert_C_to_100);    tcase_add_test(tc_convert_to_arabic, test_convert_CD_to_400);    tcase_add_test(tc_convert_to_arabic, test_convert_CD_to_500);    tcase_add_test(tc_convert_to_arabic, test_convert_CM_to_900);    tcase_add_test(tc_convert_to_arabic, test_convert_M_to_1000);    // Convert to roman test case    tcase_add_test(tc_convert_to_roman, test_convert_1_to_I);    tcase_add_test(tc_convert_to_roman, test_convert_2_to_II);    tcase_add_test(tc_convert_to_roman, test_convert_3_to_III);    tcase_add_test(tc_convert_to_roman, test_convert_4_to_IV);    tcase_add_test(tc_convert_to_roman, test_convert_5_to_V);    tcase_add_test(tc_convert_to_roman, test_convert_9_to_IX);    tcase_add_test(tc_convert_to_roman, test_convert_10_to_X);    tcase_add_test(tc_convert_to_roman, test_convert_40_to_XL);    tcase_add_test(tc_convert_to_roman, test_convert_50_to_L);    tcase_add_test(tc_convert_to_roman, test_convert_90_to_XC);    tcase_add_test(tc_convert_to_roman, test_convert_100_to_C);    tcase_add_test(tc_convert_to_roman, test_convert_400_to_CD);    tcase_add_test(tc_convert_to_roman, test_convert_500_to_D);    tcase_add_test(tc_convert_to_roman, test_convert_900_to_CM);    tcase_add_test(tc_convert_to_roman, test_convert_1000_to_M);    // Test invalid    tcase_add_test(tc_convert_to_roman, test_convert_4000_is_invalid);    tcase_add_test(tc_convert_to_roman, test_convert_negative_values_is_invalid);    tcase_add_test(tc_convert_to_roman, test_convert_zero_is_invalid);    suite_add_tcase(s, tc_convert_to_roman);    suite_add_tcase(s, tc_convert_to_arabic);    suite_add_tcase(s, tc_invalid);    return s;}

END_TESTSuite *job_func_suite(void)  {  Suite *s = suite_create("job_func_suite methods");  TCase *tc_core = tcase_create("hostname_in_externals_test");  tcase_add_test(tc_core, hostname_in_externals_test);  suite_add_tcase(s, tc_core);  tc_core = tcase_create("fix_cray_exec_hosts_test");  tcase_add_test(tc_core, fix_cray_exec_hosts_test);  suite_add_tcase(s, tc_core);  tc_core = tcase_create("fix_external_exec_hosts_test");  tcase_add_test(tc_core, fix_external_exec_hosts_test);  suite_add_tcase(s, tc_core);  tc_core = tcase_create("change_external_job_name_test");  tcase_add_test(tc_core, change_external_job_name_test);  suite_add_tcase(s, tc_core);  tc_core = tcase_create("split_job_test");  tcase_add_test(tc_core, split_job_test);  suite_add_tcase(s, tc_core);  tc_core = tcase_create("job_abt_test");  tcase_add_test(tc_core, job_abt_test);  suite_add_tcase(s, tc_core);  tc_core = tcase_create("conn_qsub_test");  tcase_add_test(tc_core, conn_qsub_test);  suite_add_tcase(s, tc_core);  tc_core = tcase_create("job_alloc_test");  tcase_add_test(tc_core, job_alloc_test);  suite_add_tcase(s, tc_core);  tc_core = tcase_create("job_free_test");  tcase_add_test(tc_core, job_free_test);  suite_add_tcase(s, tc_core);  tc_core = tcase_create("copy_job_test");  tcase_add_test(tc_core, copy_job_test);  suite_add_tcase(s, tc_core);  tc_core = tcase_create("job_clone_test");  tcase_add_test(tc_core, job_clone_test);  suite_add_tcase(s, tc_core);  tc_core = tcase_create("job_clone_wt_test");  tcase_add_test(tc_core, job_clone_wt_test);  suite_add_tcase(s, tc_core);  tc_core = tcase_create("cpy_checkpoint_test");  tcase_add_test(tc_core, cpy_checkpoint_test);  suite_add_tcase(s, tc_core);  tc_core = tcase_create("remove_checkpoint_test");  tcase_add_test(tc_core, remove_checkpoint_test);  suite_add_tcase(s, tc_core);  tc_core = tcase_create("cleanup_restart_file_test");  tcase_add_test(tc_core, cleanup_restart_file_test);  suite_add_tcase(s, tc_core);  tc_core = tcase_create("record_jobinfo_test");  tcase_add_test(tc_core, record_jobinfo_test);  suite_add_tcase(s, tc_core);  tc_core = tcase_create("svr_job_purge_test");  tcase_add_test(tc_core, svr_job_purge_test);  suite_add_tcase(s, tc_core);  tc_core = tcase_create("find_job_by_array_test");  tcase_add_test(tc_core, find_job_by_array_test);  suite_add_tcase(s, tc_core);  tc_core = tcase_create("svr_find_job_test");  tcase_add_test(tc_core, svr_find_job_test);  suite_add_tcase(s, tc_core);  tc_core = tcase_create("get_jobs_array_test");  tcase_add_test(tc_core, get_jobs_array_test);  suite_add_tcase(s, tc_core);  tc_core = tcase_create("get_jobs_array_test");  tcase_add_test(tc_core, get_jobs_array_test);  suite_add_tcase(s, tc_core);  tc_core = tcase_create("get_jobs_queue_test");  tcase_add_test(tc_core, get_jobs_queue_test);  suite_add_tcase(s, tc_core);  return(s);  }

END_TESTSuite *create_suite_Reaction (void){  Suite *suite = suite_create("Reaction");  TCase *tcase = tcase_create("Reaction");  tcase_add_checked_fixture(tcase, ReactionTest_setup, ReactionTest_teardown);  tcase_add_test( tcase, test_Reaction_create          );  //tcase_add_test( tcase, test_Reaction_createWith      );  tcase_add_test( tcase, test_Reaction_free_NULL       );  tcase_add_test( tcase, test_Reaction_setId           );  tcase_add_test( tcase, test_Reaction_setName         );  tcase_add_test( tcase, test_Reaction_reversible      );  tcase_add_test( tcase, test_Reaction_fast            );  tcase_add_test( tcase, test_Reaction_compartment     );  tcase_add_test( tcase, test_Reaction_addReactant     );  tcase_add_test( tcase, test_Reaction_addReactantBySpecies     );  tcase_add_test( tcase, test_Reaction_addProduct      );  tcase_add_test( tcase, test_Reaction_addProductBySpecies      );  tcase_add_test( tcase, test_Reaction_addModifier     );  tcase_add_test( tcase, test_Reaction_addModifierBySpecies     );  tcase_add_test( tcase, test_Reaction_getReactant     );  tcase_add_test( tcase, test_Reaction_getReactantById );  tcase_add_test( tcase, test_Reaction_getProduct      );  tcase_add_test( tcase, test_Reaction_getProductById  );  tcase_add_test( tcase, test_Reaction_getModifier     );  tcase_add_test( tcase, test_Reaction_getModifierById );  tcase_add_test( tcase, test_Reaction_createWithNS         );  tcase_add_test( tcase, test_Reaction_removeReactant  );  tcase_add_test( tcase, test_Reaction_removeProduct   );  tcase_add_test( tcase, test_Reaction_removeModifier  );  suite_add_tcase(suite, tcase);  return suite;}

END_TESTSuite *create_suite_L3_Compartment (void){  Suite *suite = suite_create("L3_Compartment");  TCase *tcase = tcase_create("L3_Compartment");  tcase_add_checked_fixture( tcase,                             L3CompartmentTest_setup,                             L3CompartmentTest_teardown );  tcase_add_test( tcase, test_L3_Compartment_create              );  tcase_add_test( tcase, test_L3_Compartment_free_NULL           );  tcase_add_test( tcase, test_L3_Compartment_id               );  tcase_add_test( tcase, test_L3_Compartment_name             );  tcase_add_test( tcase, test_L3_Compartment_units            );  tcase_add_test( tcase, test_L3_Compartment_size           );  tcase_add_test( tcase, test_L3_Compartment_constant      );  tcase_add_test( tcase, test_L3_Compartment_spatialDimensions);  tcase_add_test( tcase, test_L3_Compartment_createWithNS         );  tcase_add_test( tcase, test_L3_Compartment_hasRequiredAttributes        );  tcase_add_test( tcase, test_L3_Compartment_NS              );  tcase_add_test( tcase, test_L3_Compartment_initDefaults              );  suite_add_tcase(suite, tcase);  return suite;}

END_TESTSuite * csstoken_suite (void) {    Suite *s = suite_create( "CSS Token" );    //    //  Creation    //    TCase *tc_create = tcase_create( "Creation" );    tcase_add_checked_fixture (tc_create, setup, teardown);    tcase_add_test (tc_create, test_csstoken_create_value);    tcase_add_test (tc_create, test_csstoken_create_start);    tcase_add_test (tc_create, test_csstoken_create_end);    tcase_add_test (tc_create, test_csstoken_create_length);    tcase_add_test (tc_create, test_csstoken_create_type);    suite_add_tcase (s, tc_create);    //    //  Equality     //    TCase *tc_eq = tcase_create( "Equality" );    tcase_add_checked_fixture (tc_eq, setup, teardown);    tcase_add_test (tc_eq, test_csstoken_eq);    tcase_add_test (tc_eq, test_csstoken_eq_value);    tcase_add_test (tc_eq, test_csstoken_eq_start);    tcase_add_test (tc_eq, test_csstoken_eq_end);    tcase_add_test (tc_eq, test_csstoken_eq_length);    tcase_add_test (tc_eq, test_csstoken_eq_type);    suite_add_tcase (s, tc_eq);    return s;}

END_TESTstaticSuite*make_test_suite (void){	Suite* s;	s = suite_create (__FILE__);	TCase* tc_parse_raw = tcase_create ("parse-raw");	suite_add_tcase (s, tc_parse_raw);	tcase_add_test (tc_parse_raw, test_parse_raw_pass_001);#ifndef PGM_CHECK_NOFORK	tcase_add_test_raise_signal (tc_parse_raw, test_parse_raw_fail_001, SIGABRT);#endif	TCase* tc_parse_udp_encap = tcase_create ("parse-udp-encap");	suite_add_tcase (s, tc_parse_udp_encap);	tcase_add_test (tc_parse_udp_encap, test_parse_udp_encap_pass_001);#ifndef PGM_CHECK_NOFORK	tcase_add_test_raise_signal (tc_parse_udp_encap, test_parse_udp_encap_fail_001, SIGABRT);#endif	TCase* tc_verify_spm = tcase_create ("verify-spm");	suite_add_tcase (s, tc_verify_spm);	tcase_add_test (tc_verify_spm, test_verify_spm_pass_001);#ifndef PGM_CHECK_NOFORK	tcase_add_test_raise_signal (tc_verify_spm, test_verify_spm_fail_001, SIGABRT);#endif	TCase* tc_verify_spmr = tcase_create ("verify-spmr");	suite_add_tcase (s, tc_verify_spmr);	tcase_add_test (tc_verify_spmr, test_verify_spmr_pass_001);#ifndef PGM_CHECK_NOFORK	tcase_add_test_raise_signal (tc_verify_spmr, test_verify_spmr_fail_001, SIGABRT);#endif	TCase* tc_verify_nak = tcase_create ("verify-nak");	suite_add_tcase (s, tc_verify_nak);	tcase_add_test (tc_verify_nak, test_verify_nak_pass_001);#ifndef PGM_CHECK_NOFORK	tcase_add_test_raise_signal (tc_verify_nak, test_verify_nak_fail_001, SIGABRT);#endif	TCase* tc_verify_nnak = tcase_create ("verify-nnak");	suite_add_tcase (s, tc_verify_nnak);	tcase_add_test (tc_verify_nnak, test_verify_nnak_pass_001);#ifndef PGM_CHECK_NOFORK	tcase_add_test_raise_signal (tc_verify_nnak, test_verify_nnak_fail_001, SIGABRT);#endif	TCase* tc_verify_ncf = tcase_create ("verify-ncf");	suite_add_tcase (s, tc_verify_ncf);	tcase_add_test (tc_verify_ncf, test_verify_ncf_pass_001);#ifndef PGM_CHECK_NOFORK	tcase_add_test_raise_signal (tc_verify_ncf, test_verify_ncf_fail_001, SIGABRT);#endif	return s;}

END_TEST/****************************************************************************** * Suite *****************************************************************************/Suite *cipher_suite(void) {	Suite *s = suite_create("Cipher Suite");	TCase *tc = NULL;	/* md4 tests */	tc = tcase_create("MD4");	tcase_add_test(tc, test_md4_empty_string);	tcase_add_test(tc, test_md4_a);	tcase_add_test(tc, test_md4_abc);	tcase_add_test(tc, test_md4_message_digest);	tcase_add_test(tc, test_md4_a_to_z);	tcase_add_test(tc, test_md4_A_to_Z_a_to_z_0_to_9);	tcase_add_test(tc, test_md4_1_to_0_8_times);	suite_add_tcase(s, tc);	/* md5 tests */	tc = tcase_create("MD5");	tcase_add_test(tc, test_md5_empty_string);	tcase_add_test(tc, test_md5_a);	tcase_add_test(tc, test_md5_abc);	tcase_add_test(tc, test_md5_message_digest);	tcase_add_test(tc, test_md5_a_to_z);	tcase_add_test(tc, test_md5_A_to_Z_a_to_z_0_to_9);	tcase_add_test(tc, test_md5_1_to_0_8_times);	suite_add_tcase(s, tc);	/* sha1 tests */	tc = tcase_create("SHA1");	tcase_add_test(tc, test_sha1_empty_string);	tcase_add_test(tc, test_sha1_a);	tcase_add_test(tc, test_sha1_abc);	tcase_add_test(tc, test_sha1_abcd_gibberish);	tcase_add_test(tc, test_sha1_1000_as_1000_times);	suite_add_tcase(s, tc);	/* sha256 tests */	tc = tcase_create("SHA256");	tcase_add_test(tc, test_sha256_empty_string);	tcase_add_test(tc, test_sha256_a);	tcase_add_test(tc, test_sha256_abc);	tcase_add_test(tc, test_sha256_abcd_gibberish);	tcase_add_test(tc, test_sha256_1000_as_1000_times);	suite_add_tcase(s, tc);	/* des tests */	tc = tcase_create("DES");	tcase_add_test(tc, test_des_12345678);	tcase_add_test(tc, test_des_abcdefgh);	suite_add_tcase(s, tc);	/* des3 ecb tests */	tc = tcase_create("DES3 ECB");	tcase_add_test(tc, test_des3_ecb_nist1);	tcase_add_test(tc, test_des3_ecb_nist2);	tcase_add_test(tc, test_des3_ecb_null_key);	tcase_add_test(tc, test_des3_ecb_null_text);	tcase_add_test(tc, test_des3_ecb_null_key_and_text);	suite_add_tcase(s, tc);	/* des3 cbc tests */	tc = tcase_create("DES3 CBC");	tcase_add_test(tc, test_des3_cbc_nist1);	tcase_add_test(tc, test_des3_cbc_nist2);	tcase_add_test(tc, test_des3_cbc_null_key);	tcase_add_test(tc, test_des3_cbc_null_text);	tcase_add_test(tc, test_des3_cbc_null_key_and_text);	suite_add_tcase(s, tc);	/* hmac tests */	tc = tcase_create("HMAC");	tcase_add_test(tc, test_hmac_md5_Hi);	tcase_add_test(tc, test_hmac_md5_what);	tcase_add_test(tc, test_hmac_md5_dd);	tcase_add_test(tc, test_hmac_md5_cd);	tcase_add_test(tc, test_hmac_md5_truncation);	tcase_add_test(tc, test_hmac_md5_large_key);	tcase_add_test(tc, test_hmac_md5_large_key_and_data);	tcase_add_test(tc, test_hmac_md5_null_key);	tcase_add_test(tc, test_hmac_md5_null_text);	tcase_add_test(tc, test_hmac_md5_null_key_and_text);	tcase_add_test(tc, test_hmac_sha1_Hi);	tcase_add_test(tc, test_hmac_sha1_what);	tcase_add_test(tc, test_hmac_sha1_dd);	tcase_add_test(tc, test_hmac_sha1_cd);	tcase_add_test(tc, test_hmac_sha1_truncation);	tcase_add_test(tc, test_hmac_sha1_large_key);	tcase_add_test(tc, test_hmac_sha1_large_key_and_data);	tcase_add_test(tc, test_hmac_sha1_null_key);	tcase_add_test(tc, test_hmac_sha1_null_text);	tcase_add_test(tc, test_hmac_sha1_null_key_and_text);	suite_add_tcase(s, tc);	return s;}

int main() {    Suite *s = suite_create("Validation");    TCase *tc_validation = tcase_create("Validation");    SRunner *sr = srunner_create(s);    int num_fails;    suite_add_tcase(s, tc_validation);    tcase_add_test(tc_validation, I_is_considered_valid);    tcase_add_test(tc_validation, Z_is_considered_invalid);    tcase_add_test(tc_validation, XI_is_considered_valid);    tcase_add_test(tc_validation, XZ_is_considered_invalid);    tcase_add_test(tc_validation, Dinosaurs_is_considered_invalid);    tcase_add_test(tc_validation, MMXLVI_is_considered_valid);    tcase_add_test(tc_validation, IXI_is_considered_invalid);    tcase_add_test(tc_validation, IVI_is_considered_invalid);    tcase_add_test(tc_validation, IM_is_considered_invalid);    tcase_add_test(tc_validation, VV_is_considered_invalid);    tcase_add_test(tc_validation, DD_is_considered_invalid);    tcase_add_test(tc_validation, IXCD_is_considered_invalid);    srunner_run_all(sr, CK_NORMAL);    num_fails = srunner_ntests_failed(sr);    srunner_free(sr);    return num_fails == 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. */intmain(void) {  void *suite = suite_create("protobluff/core/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 "field_by_tag" */  tcase = tcase_create("field_by_tag");  tcase_add_checked_fixture(tcase, setup, teardown);  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);  suite_add_tcase(suite, tcase);  /* Add tests to test case "extend" */  tcase = tcase_create("extend");  tcase_add_checked_fixture(tcase, setup, teardown);  tcase_add_test(tcase, test_extend);  suite_add_tcase(suite, tcase);  /* Add tests to test case "enum_iterator" */  tcase = tcase_create("enum_iterator");  tcase_add_test(tcase, test_enum_iterator);  tcase_add_test(tcase, test_enum_iterator_empty);  suite_add_tcase(suite, tcase);  /* Add tests to test case "enum_value_by_number" */  tcase = tcase_create("enum_value_by_number");  tcase_add_test(tcase, test_enum_value_by_number);  tcase_add_test(tcase, test_enum_value_by_number_absent);  tcase_add_test(tcase, test_enum_value_by_number_empty);  tcase_add_test(tcase, test_enum_value_by_number_scattered);  tcase_add_test(tcase, test_enum_value_by_number_scattered_absent);  suite_add_tcase(suite, tcase);  /* Add tests to test case "oneof_iterator" */  tcase = tcase_create("oneof_iterator");  tcase_add_test(tcase, test_oneof_iterator);  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_TESTSuite *package_suite(void){    Suite *s = suite_create("Package");    TCase *tc;    tc = tcase_create("Core");    tcase_add_unchecked_fixture(tc, fixture_system_only, teardown);    tcase_add_test(tc, test_refcounting);    tcase_add_test(tc, test_userdata);    tcase_add_test(tc, test_package_summary);    tcase_add_test(tc, test_identical);    tcase_add_test(tc, test_versions);    tcase_add_test(tc, test_no_sourcerpm);    suite_add_tcase(s, tc);    tc = tcase_create("Requires");    tcase_add_unchecked_fixture(tc, fixture_with_main, teardown);    tcase_add_test(tc, test_get_requires);    tcase_add_test(tc, test_get_more_requires);    tcase_add_test(tc, test_chksum_fail);    tcase_add_test(tc, test_installed);    suite_add_tcase(s, tc);    tc = tcase_create("WithRealRepo");    tcase_add_unchecked_fixture(tc, fixture_yum, teardown);    tcase_add_test(tc, test_checksums);    tcase_add_test(tc, test_get_files);    tcase_add_test(tc, test_get_updateinfo);    tcase_add_test(tc, test_lookup_num);    tcase_add_test(tc, test_packager);    tcase_add_test(tc, test_sourcerpm);    tcase_add_test(tc, test_presto);    suite_add_tcase(s, tc);    return s;}

END_TESTint main(int argc, char *argv[]){  int mpiret;  sc_MPI_Comm mpicomm;  int proc_size;  int nf;    p4est_connectivity_t *conn;  p4est_t* p4est;    /* MPI init */  mpiret = sc_MPI_Init(&argc, &argv);  SC_CHECK_MPI(mpiret);  mpicomm = sc_MPI_COMM_WORLD;  /* sc_init (mpicomm, 1, 1, NULL, SC_LP_ESSENTIAL); */  mpiret = MPI_Comm_size(mpicomm, &proc_size);  SC_CHECK_MPI (mpiret);  /* pXest init */  p4est_init(NULL, SC_LP_PRODUCTION);#if (P4EST_DIM)==3  conn = p8est_connectivity_new_unitcube();#else  conn = p4est_connectivity_new_unitsquare();#endif  p4est = p4est_new(mpicomm, conn, 0, NULL, NULL);  global_p4est_pointer = p4est;    /* start just-in-time dg-math */  dgmath_jit_init();    /* run tests */  Suite *s1 = suite_create("Test Plotting Functions");  SRunner *sr = srunner_create(s1);    TCase *tc1 = tcase_create("Test Surface and Contour plotting");  TCase *tc2 = tcase_create("Test Error Plotting");  tcase_add_test(tc1, test_surface_plot);  tcase_add_test(tc2, test_error_plot);  tcase_set_timeout(tc2, 100);  /* suite_add_tcase(s1,tc1);  */  suite_add_tcase(s1,tc2);     srunner_run_all(sr, CK_ENV);  nf = srunner_ntests_failed(sr);  /* free pointers */  dgmath_jit_destroy();  /* free pXest */  p4est_destroy(p4est);  p4est_connectivity_destroy(conn);  /* finalize mpi stuff   */  /* sc_finalize(); */  mpiret = sc_MPI_Finalize ();  SC_CHECK_MPI(mpiret);  srunner_free(sr);    return nf == 0 ? 0 : 1;}

END_TESTstatic Suite* Streader_suite(void){    Suite* s = suite_create("Streader");    const int timeout = DEFAULT_TIMEOUT;#define BUILD_TCASE(name)                   /    TCase* tc_##name = tcase_create(#name); /    suite_add_tcase(s, tc_##name);          /    tcase_set_timeout(tc_##name, timeout)    BUILD_TCASE(init);    BUILD_TCASE(match);    BUILD_TCASE(read_null);    BUILD_TCASE(read_bool);    BUILD_TCASE(read_int);    BUILD_TCASE(read_float);    BUILD_TCASE(read_string);    BUILD_TCASE(read_tstamp);    BUILD_TCASE(read_piref);    BUILD_TCASE(read_list);    BUILD_TCASE(read_dict);    BUILD_TCASE(read_format);#undef BUILD_TCASE    tcase_add_test(tc_init, Initial_streader_has_no_error_set);    tcase_add_test(tc_match, Matching_visible_characters_succeed);    tcase_add_test(tc_match, Matching_wrong_characters_fails);    tcase_add_test(tc_match, Characters_past_specified_length_are_ignored);    tcase_add_test(tc_match, Matching_strings_requires_quotes_in_data);    tcase_add_test(tc_match, Matching_strings_succeeds);    tcase_add_test(tc_match, Matching_wrong_strings_fails);    tcase_add_test(tc_read_null, Reading_null_consumes_data);    tcase_add_test(tc_read_null, Null_token_with_trailing_garbage_is_rejected);    tcase_add_test(tc_read_bool, Reading_bool_stores_correct_value);    tcase_add_test(tc_read_bool, Bool_with_trailing_garbage_is_rejected);    tcase_add_test(tc_read_int, Read_zero_int);    tcase_add_test(tc_read_int, Read_nonzero_int);    tcase_add_test(tc_read_int, Reading_too_large_int_in_magnitude_fails);    tcase_add_test(tc_read_float, Read_zero_float);    tcase_add_test(tc_read_float, Read_nonzero_float);    tcase_add_test(tc_read_float, Whitespace_terminates_decimal_number);    tcase_add_test(tc_read_string, Read_valid_string);    tcase_add_test(tc_read_string, Reading_invalid_string_fails);    tcase_add_test(tc_read_tstamp, Read_valid_tstamp);    tcase_add_test(tc_read_tstamp, Reading_invalid_tstamp_fails);    tcase_add_test(tc_read_piref, Read_valid_piref);    tcase_add_test(tc_read_piref, Reading_invalid_piref_fails);    tcase_add_test(tc_read_list, Read_empty_list);    tcase_add_test(tc_read_list, Read_list_of_numbers);    tcase_add_test(tc_read_list, Read_list_of_tstamps);    tcase_add_test(tc_read_list, Callback_must_be_specified_for_nonempty_lists);    tcase_add_test(tc_read_list, Callback_failure_interrupts_list_reading);    tcase_add_test(tc_read_dict, Read_empty_dict);    tcase_add_test(tc_read_dict, Read_dict_of_numbers);    tcase_add_test(tc_read_dict, Callback_must_be_specified_for_nonempty_dicts);    tcase_add_test(tc_read_dict, Callback_failure_interrupts_dict_reading);    tcase_add_test(tc_read_format, Read_formatted_input);    return s;}

END_TESTSuite *liblist_suite ( void ){    Suite *s = suite_create ( "Lib linked list tester" );    /* Core test case */    TCase *tc_core = tcase_create ( "Core" );	TCase *tc_mt = tcase_create ("Multithreaded");	tcase_add_test ( tc_core, llist_01_create_delete_lists );    tcase_add_test ( tc_core, llist_02_add_nodes );    tcase_add_test ( tc_core, llist_03_add_dynamic_nodes );    tcase_add_test ( tc_core, llist_04_delete_nodes );    tcase_add_test ( tc_core, llist_05_list_for_each );    tcase_add_test ( tc_core, llist_06_insert_nodes );    tcase_add_test ( tc_core, llist_07_test_stack );    tcase_add_test ( tc_core, llist_08_list_reverse );    tcase_add_test ( tc_core, llist_09_list_sort );    tcase_add_test ( tc_core, llist_11_find_min_max );    //really multithreaded test case    tcase_add_test ( tc_mt, llist_01_create_delete_lists );    tcase_add_test ( tc_mt, llist_02_add_nodes );    tcase_add_test ( tc_mt, llist_03_add_dynamic_nodes );    tcase_add_test ( tc_mt, llist_04_delete_nodes );    tcase_add_test ( tc_mt, llist_05_list_for_each );    tcase_add_test ( tc_mt, llist_06_insert_nodes );    tcase_add_test ( tc_mt, llist_07_test_stack );    tcase_add_test ( tc_mt, llist_08_list_reverse );    tcase_add_test ( tc_mt, llist_09_list_sort );    tcase_add_test ( tc_mt, llist_10_pure_add_delete_mt );    tcase_add_test ( tc_mt, llist_11_find_min_max );    suite_add_tcase ( s, tc_core );	suite_add_tcase ( s, tc_mt );    return s;}

static Suite *hls_demux_suite (void){  Suite *s = suite_create ("hls_demux");  TCase *tc_basicTest = tcase_create ("basicTest");  tcase_add_test (tc_basicTest, simpleTest);  tcase_add_test (tc_basicTest, testMasterPlaylist);  tcase_add_test (tc_basicTest, testMediaPlaylistNotFound);  tcase_add_test (tc_basicTest, testFragmentNotFound);  tcase_add_test (tc_basicTest, testFragmentDownloadError);  tcase_add_test (tc_basicTest, testSeek);  tcase_add_test (tc_basicTest, testSeekKeyUnitPosition);  tcase_add_test (tc_basicTest, testSeekPosition);  tcase_add_test (tc_basicTest, testSeekUpdateStopPosition);  tcase_add_test (tc_basicTest, testSeekSnapBeforePosition);  tcase_add_test (tc_basicTest, testSeekSnapAfterPosition);  tcase_add_test (tc_basicTest, testReverseSeekSnapBeforePosition);  tcase_add_test (tc_basicTest, testReverseSeekSnapAfterPosition);  tcase_add_unchecked_fixture (tc_basicTest, gst_adaptive_demux_test_setup,      gst_adaptive_demux_test_teardown);  suite_add_tcase (s, tc_basicTest);  return s;}

END_TESTSuite* r3_suite (void) {        Suite *suite = suite_create("blah");        TCase *tcase = tcase_create("testcase");        tcase_add_test(tcase, test_str_array);        tcase_add_test(tcase, test_ltrim_slash);        tcase_add_test(tcase, test_r3_node_construct_uniq);        tcase_add_test(tcase, test_r3_node_find_edge);        tcase_add_test(tcase, test_r3_tree_insert_pathl);        tcase_add_test(tcase, test_compile_slug);        tcase_add_test(tcase, test_compile);        tcase_add_test(tcase, test_route_cmp);        tcase_add_test(tcase, test_insert_route);        tcase_add_test(tcase, test_pcre_pattern_simple);        tcase_add_test(tcase, test_pcre_pattern_more);        tcase_add_test(tcase, test_pcre_patterns_insert);        tcase_add_test(tcase, benchmark_str);        suite_add_tcase(suite, tcase);        return suite;}

END_TESTSuite *tests_get_auth_suite(void) {    Suite *suite;    TCase *testcase;    suite = suite_create("auth");    testcase = tcase_create("base");    tcase_add_checked_fixture(testcase, set_up, tear_down);    /* pwent* et al */    tcase_add_test(testcase, auth_setpwent_test);    tcase_add_test(testcase, auth_endpwent_test);    tcase_add_test(testcase, auth_getpwent_test);    tcase_add_test(testcase, auth_getpwnam_test);    tcase_add_test(testcase, auth_getpwuid_test);    tcase_add_test(testcase, auth_name2uid_test);    tcase_add_test(testcase, auth_uid2name_test);    /* grent* et al */    tcase_add_test(testcase, auth_setgrent_test);    tcase_add_test(testcase, auth_endgrent_test);    tcase_add_test(testcase, auth_getgrent_test);    tcase_add_test(testcase, auth_getgrnam_test);    tcase_add_test(testcase, auth_getgrgid_test);    tcase_add_test(testcase, auth_gid2name_test);    tcase_add_test(testcase, auth_name2gid_test);    tcase_add_test(testcase, auth_getgroups_test);    /* Caching tests */    tcase_add_test(testcase, auth_cache_uid2name_test);    tcase_add_test(testcase, auth_cache_gid2name_test);    tcase_add_test(testcase, auth_cache_uid2name_failed_test);    tcase_add_test(testcase, auth_cache_gid2name_failed_test);    tcase_add_test(testcase, auth_cache_name2uid_failed_test);    tcase_add_test(testcase, auth_cache_name2gid_failed_test);#if 0    /* Authorization */    tcase_add_test(testcase, auth_authenticate_test);    tcase_add_test(testcase, auth_authorize_test);    tcase_add_test(testcase, auth_check_test);    tcase_add_test(testcase, auth_requires_pass_test);    /* Auth modules */    tcase_add_test(testcase, auth_add_auth_only_module_test);    tcase_add_test(testcase, auth_remove_auth_only_module_test);    tcase_add_test(testcase, auth_clear_auth_only_modules_test);#endif    suite_add_tcase(suite, testcase);    return suite;}

END_TEST/* public */Suite *create_suite_odeSolver(void){	Suite *s;	TCase *tc_SBML_odeSolver;	TCase *tc_Model_odeSolver;	TCase *tc_VarySettings_allocate;	TCase *tc_VarySettings_free;	TCase *tc_VarySettings_addDesignPoint;	TCase *tc_VarySettings_addParameter;	TCase *tc_VarySettings_setName;	TCase *tc_VarySettings_setValue;	TCase *tc_VarySettings_getValue;	TCase *tc_VarySettings_setValueByID;	TCase *tc_VarySettings_getValueByID;	TCase *tc_VarySettings_getName;	TCase *tc_VarySettings_getReactionName;	s = suite_create("odeSolver");	tc_SBML_odeSolver = tcase_create("SBML_odeSolver");	tcase_add_checked_fixture(tc_SBML_odeSolver,							  NULL,							  teardown_doc);	tcase_add_checked_fixture(tc_SBML_odeSolver,							  setup_cs,							  teardown_cs);	tcase_add_checked_fixture(tc_SBML_odeSolver,							  NULL,							  teardown_results);	tcase_add_test(tc_SBML_odeSolver, test_SBML_odeSolver_MAPK);	suite_add_tcase(s, tc_SBML_odeSolver);	tc_Model_odeSolver = tcase_create("Model_odeSolver");	tcase_add_checked_fixture(tc_Model_odeSolver,							  NULL,							  teardown_doc);	tcase_add_checked_fixture(tc_Model_odeSolver,							  setup_cs,							  teardown_cs);	tcase_add_checked_fixture(tc_Model_odeSolver,							  NULL,							  teardown_results);	tcase_add_test(tc_Model_odeSolver, test_Model_odeSolver_basic_model1_forward_l2);	tcase_add_test(tc_Model_odeSolver, test_Model_odeSolver_basic);	tcase_add_test(tc_Model_odeSolver, test_Model_odeSolver_events_1_event_1_assignment_l2);	tcase_add_test(tc_Model_odeSolver, test_Model_odeSolver_events_2_events_1_assignment_l2);	tcase_add_test(tc_Model_odeSolver, test_Model_odeSolver_huang96);	tcase_add_test(tc_Model_odeSolver, test_Model_odeSolver_repressilator);	suite_add_tcase(s, tc_Model_odeSolver);	tc_VarySettings_allocate = tcase_create("VarySettings_allocate");	tcase_add_checked_fixture(tc_VarySettings_allocate,							  NULL,							  teardown_vs);	tcase_add_test(tc_VarySettings_allocate, test_VarySettings_allocate);	suite_add_tcase(s, tc_VarySettings_allocate);	tc_VarySettings_free = tcase_create("VarySettings_free");	tcase_add_test(tc_VarySettings_free, test_VarySettings_free);	suite_add_tcase(s, tc_VarySettings_free);	tc_VarySettings_addDesignPoint = tcase_create("VarySettings_addDesignPoint");	tcase_add_checked_fixture(tc_VarySettings_addDesignPoint,							  setup_vs,							  teardown_vs);	tcase_add_test(tc_VarySettings_addDesignPoint, test_VarySettings_addDesignPoint);	suite_add_tcase(s, tc_VarySettings_addDesignPoint);	tc_VarySettings_addParameter = tcase_create("VarySettings_addParameter");	tcase_add_checked_fixture(tc_VarySettings_addParameter,							  setup_vs,							  teardown_vs);	tcase_add_test(tc_VarySettings_addParameter, test_VarySettings_addParameter);	suite_add_tcase(s, tc_VarySettings_addParameter);	tc_VarySettings_setName = tcase_create("VarySettings_setName");	tcase_add_checked_fixture(tc_VarySettings_setName,							  setup_vs,							  teardown_vs);	tcase_add_test(tc_VarySettings_setName, test_VarySettings_setName);	suite_add_tcase(s, tc_VarySettings_setName);	tc_VarySettings_setValue = tcase_create("VarySettings_setValue");	tcase_add_checked_fixture(tc_VarySettings_setValue,							  setup_vs,							  teardown_vs);	tcase_add_test(tc_VarySettings_setValue, test_VarySettings_setValue);	suite_add_tcase(s, tc_VarySettings_setValue);	tc_VarySettings_getValue = tcase_create("VarySettings_getValue");	tcase_add_checked_fixture(tc_VarySettings_getValue,							  setup_vs,							  teardown_vs);	tcase_add_test(tc_VarySettings_getValue, test_VarySettings_getValue);	suite_add_tcase(s, tc_VarySettings_getValue);	tc_VarySettings_setValueByID = tcase_create("VarySettings_setValueByID");//.........这里部分代码省略.........

END_TESTSuite *signon_suite(void){    Suite *s = suite_create ("signon-glib");    /* Core test case */    TCase * tc_core = tcase_create("Core");    /*     * 18 minutes timeout     * */    tcase_set_timeout(tc_core, 1080);    tcase_add_test (tc_core, test_init);    tcase_add_test (tc_core, test_query_methods);    tcase_add_test (tc_core, test_query_mechanisms);    tcase_add_test (tc_core, test_get_existing_identity);    tcase_add_test (tc_core, test_get_nonexisting_identity);    tcase_add_test (tc_core, test_auth_session_creation);    tcase_add_test (tc_core, test_auth_session_query_mechanisms);    tcase_add_test (tc_core, test_auth_session_query_mechanisms_nonexisting);    tcase_add_test (tc_core, test_auth_session_process);    tcase_add_test (tc_core, test_store_credentials_identity);    tcase_add_test (tc_core, test_verify_secret_identity);    tcase_add_test (tc_core, test_remove_identity);    tcase_add_test (tc_core, test_info_identity);    tcase_add_test (tc_core, test_signout_identity);    tcase_add_test (tc_core, test_unregistered_identity);    tcase_add_test (tc_core, test_unregistered_auth_session);    tcase_add_test (tc_core, test_regression_unref);    suite_add_tcase (s, tc_core);    return s;}

END_TESTvoid add_ifinfo_tests(Suite *s){	TCase *tc_ifinfo = tcase_create("Ifinfo");	tcase_add_test(tc_ifinfo, parseifinfo_zero_change);	tcase_add_test(tc_ifinfo, parseifinfo_1kb_change);	tcase_add_test(tc_ifinfo, parseifinfo_newdb);	tcase_add_test(tc_ifinfo, parseifinfo_1kb_change_with_booted_system);	tcase_add_test(tc_ifinfo, parseifinfo_long_update_interval_causes_sync);	tcase_add_test(tc_ifinfo, parseifinfo_hitting_maxbw_limit_causes_sync);	tcase_add_test(tc_ifinfo, parseifinfo_multiple_parses);	tcase_add_test(tc_ifinfo, getiflist_no_source);	tcase_add_test(tc_ifinfo, getiflist_proc_one_interface);	tcase_add_test(tc_ifinfo, getiflist_proc_one_interface_with_speed);	tcase_add_test(tc_ifinfo, getiflist_proc_multiple_interfaces);	tcase_add_test(tc_ifinfo, getiflist_sysclassnet_one_interface);	tcase_add_test(tc_ifinfo, getiflist_sysclassnet_one_interface_with_speed);	tcase_add_test(tc_ifinfo, getiflist_sysclassnet_multiple_interfaces);	tcase_add_test(tc_ifinfo, readproc_no_file);	tcase_add_test(tc_ifinfo, readproc_not_found);	tcase_add_test(tc_ifinfo, readproc_success);	tcase_add_test(tc_ifinfo, readsysclassnet_not_found);	tcase_add_test(tc_ifinfo, readsysclassnet_success);	tcase_add_test(tc_ifinfo, getifinfo_not_found);	tcase_add_test(tc_ifinfo, getifinfo_success);	suite_add_tcase(s, tc_ifinfo);}

END_TESTstatic Suite* testSuite_Client(void) {    Suite *s = suite_create("Register Server and Client");    TCase *tc_register = tcase_create("RegisterServer");    tcase_add_unchecked_fixture(tc_register, setup_lds, teardown_lds);    tcase_add_unchecked_fixture(tc_register, setup_register, teardown_register);    tcase_add_test(tc_register, Server_register);    // register two times, just for fun    tcase_add_test(tc_register, Server_register);    tcase_add_test(tc_register, Server_unregister);    tcase_add_test(tc_register, Server_register_periodic);    tcase_add_test(tc_register, Server_unregister_periodic);    suite_add_tcase(s,tc_register);    TCase *tc_register_retry = tcase_create("RegisterServer Retry");    //tcase_add_unchecked_fixture(tc_register, setup_lds, teardown_lds);    tcase_add_unchecked_fixture(tc_register_retry, setup_register, teardown_register);    tcase_add_test(tc_register_retry, Server_register_periodic);    tcase_add_test(tc_register_retry, Util_wait_startup); // wait a bit to let first try run through    // now start LDS    tcase_add_test(tc_register_retry, Util_start_lds);    tcase_add_test(tc_register_retry, Util_wait_retry);    // check if there    tcase_add_test(tc_register_retry, Client_find_registered);    tcase_add_test(tc_register_retry, Server_unregister_periodic);    tcase_add_test(tc_register_retry, Client_find_discovery);    tcase_add_test(tc_register_retry, Util_stop_lds);    suite_add_tcase(s,tc_register_retry);#ifdef UA_ENABLE_DISCOVERY_MULTICAST    TCase *tc_register_find = tcase_create("RegisterServer and FindServers");    tcase_add_unchecked_fixture(tc_register_find, setup_lds, teardown_lds);    tcase_add_unchecked_fixture(tc_register_find, setup_register, teardown_register);    tcase_add_test(tc_register_find, Client_find_discovery);    tcase_add_test(tc_register_find, Server_register);    tcase_add_test(tc_register_find, Client_find_registered);    tcase_add_test(tc_register_find, Util_wait_mdns);    tcase_add_test(tc_register_find, Client_find_on_network_registered);    tcase_add_test(tc_register_find, Client_find_filter);    tcase_add_test(tc_register_find, Client_get_endpoints);    tcase_add_test(tc_register_find, Client_filter_locale);    tcase_add_test(tc_register_find, Server_unregister);    tcase_add_test(tc_register_find, Client_find_discovery);    tcase_add_test(tc_register_find, Client_filter_discovery);    suite_add_tcase(s,tc_register_find);#endif    // register server again, then wait for timeout and auto unregister    TCase *tc_register_timeout = tcase_create("RegisterServer timeout");    tcase_add_unchecked_fixture(tc_register_timeout, setup_lds, teardown_lds);    tcase_add_unchecked_fixture(tc_register_timeout, setup_register, teardown_register);    tcase_set_timeout(tc_register_timeout, checkWait+2);    tcase_add_test(tc_register_timeout, Server_register);    tcase_add_test(tc_register_timeout, Client_find_registered);    tcase_add_test(tc_register_timeout, Util_wait_timeout);    tcase_add_test(tc_register_timeout, Client_find_discovery);#ifdef UA_ENABLE_DISCOVERY_SEMAPHORE    // now check if semaphore file works    tcase_add_test(tc_register_timeout, Server_register_semaphore);    tcase_add_test(tc_register_timeout, Client_find_registered);    tcase_add_test(tc_register_timeout, Server_unregister_semaphore);    tcase_add_test(tc_register_timeout, Util_wait_timeout);    tcase_add_test(tc_register_timeout, Client_find_discovery);#endif    suite_add_tcase(s,tc_register_timeout);    return s;}

END_TESTSuite *bio_reader_suite_create(){	Suite *s;	TCase *tc;	s = suite_create("bio_reader");	tc = tcase_create("integer reads");	tcase_add_test(tc, test_read_uint8);	tcase_add_test(tc, test_read_uint16);	tcase_add_test(tc, test_read_uint24);	tcase_add_test(tc, test_read_uint32);	tcase_add_test(tc, test_read_uint64);	suite_add_tcase(s, tc);	tc = tcase_create("integer reads from end");	tcase_add_test(tc, test_read_uint8_end);	tcase_add_test(tc, test_read_uint16_end);	tcase_add_test(tc, test_read_uint24_end);	tcase_add_test(tc, test_read_uint32_end);	tcase_add_test(tc, test_read_uint64_end);	suite_add_tcase(s, tc);	tc = tcase_create("data reads and peek");	tcase_add_test(tc, test_read_data);	tcase_add_test(tc, test_read_data_end);	suite_add_tcase(s, tc);	tc = tcase_create("data length reads");	tcase_add_test(tc, test_read_data8);	tcase_add_test(tc, test_read_data16);	tcase_add_test(tc, test_read_data24);	tcase_add_test(tc, test_read_data32);	suite_add_tcase(s, tc);	tc = tcase_create("constructors");	tcase_add_test(tc, test_create);	tcase_add_test(tc, test_create_own);	suite_add_tcase(s, tc);	return s;}