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_TEST Suite *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_TEST Suite * 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_TEST Suite* 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_TEST Suite *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_TEST void 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_TEST Suite *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_TEST Suite* 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_TEST Suite *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_TEST Suite * 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_TEST Suite * create_suite_CalcUnitDefinition (void) { Suite *suite = suite_create("CalcUnitDefinition"); TCase *tcase = tcase_create("CalcUnitDefinition"); tcase_add_checked_fixture(tcase, CalcUnitDefinition_setup, CalcUnitDefinition_teardown); tcase_add_test(tcase, test_CalcUnitDefinition_parameter ); tcase_add_test(tcase, test_CalcUnitDefinition_parameter1 ); tcase_add_test(tcase, test_CalcUnitDefinition_initialAssignment ); tcase_add_test(tcase, test_CalcUnitDefinition_initialAssignment1 ); tcase_add_test(tcase, test_CalcUnitDefinition_initialAssignment_useRn ); tcase_add_test(tcase, test_CalcUnitDefinition_initialAssignment_useSR ); tcase_add_test(tcase, test_CalcUnitDefinition_initialAssignment_useSR1 ); tcase_add_test(tcase, test_CalcUnitDefinition_assignmentRule ); tcase_add_test(tcase, test_CalcUnitDefinition_assignmentRule1 ); tcase_add_test(tcase, test_CalcUnitDefinition_eventAssignment ); tcase_add_test(tcase, test_CalcUnitDefinition_eventAssignment1 ); tcase_add_test(tcase, test_CalcUnitDefinition_eventAssignment2 ); tcase_add_test(tcase, test_CalcUnitDefinition_rateRule ); tcase_add_test(tcase, test_CalcUnitDefinition_rateRule1 ); tcase_add_test(tcase, test_CalcUnitDefinition_delay ); tcase_add_test(tcase, test_CalcUnitDefinition_priority ); tcase_add_test(tcase, test_CalcUnitDefinition_global_with_local_known ); tcase_add_test(tcase, test_CalcUnitDefinition_global_with_local_unknown ); tcase_add_test(tcase, test_CalcUnitDefinition_local ); //tcase_add_test(tcase, test_CalcUnitDefinition_local1 ); tcase_add_test(tcase, test_CalcUnitDefinition_unknownReaction ); tcase_add_test(tcase, test_CalcUnitDefinition_rateRule_timeUnknown ); tcase_add_test(tcase, test_CalcUnitDefinition_noModel ); suite_add_tcase(suite, tcase); return suite; }
END_TEST Suite * 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_TEST Suite * 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_TEST static Suite* 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. */ int main(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_TEST Suite * 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_TEST int 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_TEST static 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_TEST Suite *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_TEST Suite* 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_TEST Suite *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"); tcase_add_checked_fixture(tc_VarySettings_setValueByID, setup_vs, teardown_vs); tcase_add_test(tc_VarySettings_setValueByID, test_VarySettings_setValueByID); suite_add_tcase(s, tc_VarySettings_setValueByID); tc_VarySettings_getValueByID = tcase_create("VarySettings_getValueByID"); tcase_add_checked_fixture(tc_VarySettings_getValueByID, setup_vs, teardown_vs); tcase_add_test(tc_VarySettings_getValueByID, test_VarySettings_getValueByID); suite_add_tcase(s, tc_VarySettings_getValueByID); tc_VarySettings_getName = tcase_create("VarySettings_getName"); tcase_add_checked_fixture(tc_VarySettings_getName, setup_vs, teardown_vs); tcase_add_test(tc_VarySettings_getName, test_VarySettings_getName); suite_add_tcase(s, tc_VarySettings_getName); tc_VarySettings_getReactionName = tcase_create("VarySettings_getReactionName"); tcase_add_checked_fixture(tc_VarySettings_getReactionName, setup_vs, teardown_vs); tcase_add_test(tc_VarySettings_getReactionName, test_VarySettings_getReactionName); suite_add_tcase(s, tc_VarySettings_getReactionName); return s; }
END_TEST Suite * 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_TEST void 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_TEST static 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_TEST Suite *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; }