END_TEST
/* END: Interoperability tests */
Suite * profile_suite (void)
{
Suite *s = suite_create ("EXI Profile");
{
/* Grammars test case */
TCase *tc_intProfile = tcase_create ("Interoperability tests");
tcase_add_test (tc_intProfile, test_noLearning01);
tcase_add_test (tc_intProfile, test_noLearning02);
// tcase_add_test (tc_intProfile, test_noLearning03);
// tcase_add_test (tc_intProfile, test_noLearning04);
// tcase_add_test (tc_intProfile, test_noLearning05);
suite_add_tcase (s, tc_intProfile);
}
return s;
}
END_TEST
Suite *
create_suite_ModelHistory_newSetters (void)
{
Suite *suite = suite_create("ModelHistory_newSetters");
TCase *tcase = tcase_create("ModelHistory_newSetters");
tcase_add_test( tcase, test_ModelHistory_setCreatedDate1 );
tcase_add_test( tcase, test_ModelHistory_setCreatedDate2 );
tcase_add_test( tcase, test_ModelHistory_setModifiedDate1 );
tcase_add_test( tcase, test_ModelHistory_setModifiedDate2 );
tcase_add_test( tcase, test_ModelHistory_addCreator1 );
tcase_add_test( tcase, test_ModelHistory_addCreator2 );
tcase_add_test( tcase, test_ModelHistory_addCreator3 );
suite_add_tcase(suite, tcase);
return suite;
}
END_TEST
TCase* tofu_tcase(void)
{
TCase *tc = tcase_create("tofu");
tcase_add_checked_fixture(tc, setup, teardown);
tcase_add_test(tc, test_finds_trusted_host);
tcase_add_test(tc, test_finds_trusted_host_with_indent);
tcase_add_test(tc, test_unfound_host_with_no_callback_registered);
tcase_add_test(tc, test_commented_host);
tcase_add_test(tc, test_mismatch_host_with_no_callback_registered);
tcase_add_test(tc, test_unfound_host_invokes_callback_and_rejects);
tcase_add_test(tc, test_mismatch_host_invokes_callback_and_rejects);
tcase_add_test(tc, test_unfound_host_invokes_callback_and_accepts_once);
tcase_add_test(tc, test_mismatch_host_invokes_callback_and_accepts_once);
tcase_add_test(tc, test_unfound_host_invokes_callback_and_trusts);
tcase_add_test(tc, test_mismatch_host_invokes_callback_and_trusts);
tcase_add_test(tc, test_trust_creates_known_hosts_file_and_directory);
return tc;
}
END_TEST
/* ---------- Suite creation ---------- */
Suite *create_hildon_time_picker_suite()
{
/* Create the suite */
Suite *s = suite_create("HildonTimePicker");
/* Create test cases */
TCase *tc1 = tcase_create("set_time");
/* Create test case for hildon_time_picker_set_time and add it to the suite */
tcase_add_checked_fixture(tc1, fx_setup_default_time_picker, fx_teardown_default_time_picker);
tcase_add_test(tc1, test_set_time_regular);
tcase_add_test(tc1, test_set_time_limits);
tcase_add_test(tc1, test_set_time_invalid);
suite_add_tcase(s, tc1);
/* Return created suite */
return s;
}
END_TEST
int run_tests()
{
int number_failed;
Suite *s = suite_create("hyperloglog");
SRunner *runner = srunner_create(s);
TCase *tc = tcase_create("basic");
tcase_add_test(tc, test_hyperloglog_basic);
tcase_add_test(tc, test_hyperloglog_copy_and_clone);
tcase_add_test(tc, test_hyperloglog_merge);
tcase_add_test(tc, test_hyperloglog_simd);
tcase_add_test(tc, test_hyperloglog_errors);
tcase_set_timeout(tc, 15);
suite_add_tcase(s, tc);
srunner_run_all(runner, CK_NORMAL);
number_failed = srunner_ntests_failed(runner);
srunner_free(runner);
return number_failed;
}
END_TEST
Suite* check_utility_suite(void)
{
Suite* suite = suite_create("Roman Numeral Utilities");
TCase* core = tcase_create("Core");
tcase_add_test(core, validate_roman_numeral_should_return_false_when_given_NULL_input);
tcase_add_test(core, validate_roman_numeral_should_return_false_when_given_empty_input);
tcase_add_test(core, validate_roman_numeral_should_return_false_when_longer_than_max_length);
tcase_add_test(core, validate_roman_numeral_should_return_false_when_input_with_invalid_digit);
tcase_add_test(core, validate_roman_numeral_should_return_true_when_input_with_all_valid_digits);
tcase_add_test(core, validate_roman_numeral_should_return_false_when_I_repeats_more_than_thrice);
tcase_add_test(core, validate_roman_numeral_should_return_false_when_X_repeats_more_than_thrice);
tcase_add_test(core, validate_roman_numeral_should_return_false_when_C_repeats_more_than_thrice);
tcase_add_test(core, validate_roman_numeral_should_return_false_when_V_repeats_more_than_once);
tcase_add_test(core, validate_roman_numeral_should_return_false_when_L_repeats_more_than_once);
tcase_add_test(core, validate_roman_numeral_should_return_false_when_D_repeats_more_than_once);
tcase_add_test(core, validate_integer_should_ensure_between_1_and_3999);
suite_add_tcase(suite, core);
return suite;
}
static Suite *
gst_utils_suite (void)
{
Suite *s = suite_create ("GstUtils");
TCase *tc_chain = tcase_create ("general");
suite_add_tcase (s, tc_chain);
tcase_add_test (tc_chain, test_buffer_probe_n_times);
tcase_add_test (tc_chain, test_buffer_probe_once);
tcase_add_test (tc_chain, test_math_scale);
tcase_add_test (tc_chain, test_math_scale_uint64);
tcase_add_test (tc_chain, test_math_scale_random);
tcase_add_test (tc_chain, test_guint64_to_gdouble);
tcase_add_test (tc_chain, test_gdouble_to_guint64);
#ifndef GST_DISABLE_PARSE
tcase_add_test (tc_chain, test_parse_bin_from_description);
#endif
tcase_add_test (tc_chain, test_element_found_tags);
tcase_add_test (tc_chain, test_element_unlink);
tcase_add_test (tc_chain, test_set_value_from_string);
return s;
}
static Suite *
flvmux_suite (void)
{
Suite *s = suite_create ("flvmux");
TCase *tc_chain = tcase_create ("general");
gint loop = 499;
suite_add_tcase (s, tc_chain);
#ifdef HAVE_VALGRIND
if (RUNNING_ON_VALGRIND) {
loop = 140;
}
#endif
tcase_add_loop_test (tc_chain, test_index_writing, 1, loop);
tcase_add_test (tc_chain, test_speex_streamable);
tcase_add_test (tc_chain, test_increasing_timestamp_when_pts_none);
return s;
}
END_TEST
/**********************************************************************/
/**********************************************************************/
/* END THE LKAB DEMO SUIT*/
/* Test suite */
Suite* exip_suite(void)
{
Suite *s = suite_create("Strict Grammar");
{
TCase *tc_builtin = tcase_create ("Strict Grammar");
tcase_add_test (tc_builtin, test_acceptance_for_A_01);
tcase_add_test (tc_builtin, test_acceptance_for_A_01_exip1);
tcase_add_test (tc_builtin, test_acceptance_for_A_01b);
tcase_add_test (tc_builtin, test_lkab_demo_suit);
suite_add_tcase (s, tc_builtin);
}
return s;
}
END_TEST
Suite *
create_suite_GraphicalPrimitive2D (void)
{
Suite *suite = suite_create("GraphicalPrimitive2D");
TCase *tcase = tcase_create("GraphicalPrimitive2D");
tcase_add_checked_fixture( tcase,
GraphicalPrimitive2DTest_setup,
GraphicalPrimitive2DTest_teardown );
tcase_add_test( tcase, test_GraphicalPrimitive2D_fill );
tcase_add_test( tcase, test_GraphicalPrimitive2D_fillRule );
suite_add_tcase(suite, tcase);
return suite;
}
} TEND
/************************************************************/
Suite *
tester_suite(void)
{
Suite *s = suite_create("lt_trie_t");
TCase *tc = tcase_create("Basic functionality");
tcase_add_checked_fixture(tc, setup, teardown);
T (lt_trie_new);
T (lt_trie_unref);
T (lt_trie_add);
T (lt_trie_replace);
T (lt_trie_remove);
T (lt_trie_lookup);
suite_add_tcase(s, tc);
return s;
}
END_TEST
static Suite *files_suite(void)
{
Suite *s = suite_create("files_suite");
TCase *tc_files = tcase_create("files");
tcase_add_checked_fixture(tc_files,
setup_files_test,
teardown_files_test);
tcase_add_test(tc_files, test_remove_tree);
tcase_add_test(tc_files, test_remove_subtree);
tcase_add_test(tc_files, test_simple_copy);
tcase_add_test(tc_files, test_copy_file);
tcase_add_test(tc_files, test_copy_symlink);
tcase_add_test(tc_files, test_copy_node);
tcase_add_test(tc_files, test_create_dir);
suite_add_tcase(s, tc_files);
return s;
}
END_TEST
Suite *
card_suite (void)
{
Suite *s = suite_create ("Blackjack");
/* Bust test case */
TCase *tc_core = tcase_create ("Game Methods");
tcase_add_test (tc_core, should_be_able_to_tell_if_an_empty_deck_has_busted);
tcase_add_test (tc_core, should_be_able_to_tell_if_a_busted_deck_has_busted);
tcase_add_test (tc_core, a_deck_with_21_cards_is_not_busted);
tcase_add_test (tc_core, should_be_able_to_create_new_game);
tcase_add_test (tc_core, players_should_start_game_with_no_cards);
tcase_add_test (tc_core, table_deck_should_start_with_52_cards);
suite_add_tcase (s, tc_core);
return s;
}
END_TEST
Suite *
url_suite(void)
{
Suite *s;
TCase *tc;
s = suite_create("url");
tc = tcase_create("url_dec");
tcase_add_test(tc, url_dec_01);
tcase_add_test(tc, url_dec_02);
tcase_add_test(tc, url_dec_03);
tcase_add_test(tc, url_dec_04);
tcase_add_test(tc, url_dec_05);
tcase_add_test(tc, url_dec_06);
suite_add_tcase(s, tc);
return s;
}
END_TEST
//TODO moar
Suite *
correlation_suite (void)
{
Suite *s = suite_create ("Correlation");
/* Operators test case */
TCase *tc_correlation = tcase_create ("Basic");
tcase_add_checked_fixture (tc_correlation, setup, teardown);
tcase_add_test (tc_correlation, test_basic);
//tcase_add_test (tc_operators, test_p_sat_add);
//tcase_add_test (tc_operators, test_p_sat_uadd);
suite_add_tcase (s, tc_correlation);
return s;
}
static Suite *
evas_suite_build(int argc, const char **argv)
{
TCase *tc;
Suite *s;
int i;
s = suite_create("Evas");
for (i = 0; etc[i].test_case; ++i)
{
if (!_use_test(argc, argv, etc[i].test_case)) continue;
tc = tcase_create(etc[i].test_case);
etc[i].build(tc);
suite_add_tcase(s, tc);
tcase_set_timeout(tc, 0);
}
return s;
}
END_TEST
static Suite* persist_suite(void)
{
Suite *s = suite_create("persist");
/* Core test case */
TCase *tc = tcase_create("persist");
tcase_add_checked_fixture(tc, handle_setup, handle_teardown);
tcase_add_test(tc, test_empty_private_get);
tcase_add_test(tc, test_empty_private_delete);
tcase_add_test(tc, test_kvpair_storage);
tcase_add_test(tc, test_private_save);
tcase_add_test(tc, test_private_delete);
tcase_add_test(tc, test_private_retrieve);
suite_add_tcase(s, tc);
return s;
}
static Suite *
gst_byte_reader_suite (void)
{
Suite *s = suite_create ("GstByteReader");
TCase *tc_chain = tcase_create ("general");
suite_add_tcase (s, tc_chain);
tcase_add_test (tc_chain, test_initialization);
tcase_add_test (tc_chain, test_get_uint_le);
tcase_add_test (tc_chain, test_get_uint_be);
tcase_add_test (tc_chain, test_get_int_le);
tcase_add_test (tc_chain, test_get_int_be);
tcase_add_test (tc_chain, test_get_float_le);
tcase_add_test (tc_chain, test_get_float_be);
tcase_add_test (tc_chain, test_position_tracking);
tcase_add_test (tc_chain, test_scan);
tcase_add_test (tc_chain, test_string_funcs);
tcase_add_test (tc_chain, test_dup_string);
return s;
}
END_TEST
Suite *make_pb_heap_suite(void)
{
Suite *s;
TCase *tc_heap;
s = suite_create("Heap");
tc_heap = tcase_create("Heap basic operations");
suite_add_tcase(s, tc_heap);
tcase_add_test(tc_heap, empty_get_test);
tcase_add_test(tc_heap, insert_test);
tcase_add_test(tc_heap, get_test);
tcase_add_test(tc_heap, insert_smaller_test);
tcase_add_test(tc_heap, expand_test);
tcase_add_test(tc_heap, decrease_test);
tcase_add_unchecked_fixture(tc_heap, pb_heap_test_setup, pb_heap_test_teardown);
return s;
}
END_TEST
Suite *ic_list_suite(void) {
Suite *s = suite_create("list");
TCase *tc_list = tcase_create("list");
tcase_add_test(tc_list, new_ic_list_should_be_empty);
tcase_add_test(tc_list, append_one_element_should_make_it_head_and_tail);
tcase_add_test(tc_list, append_many_elements);
tcase_add_test(tc_list, prepend_one_element_should_make_it_head_and_tail);
tcase_add_test(tc_list, prepend_many_elements);
tcase_add_test(tc_list, nth_should_return_element_data_at_that_position_or_NULL_if_out_of_bounds);
tcase_add_test(tc_list, find_should_return_matched_element_or_NULL_if_not_found);
suite_add_tcase(s, tc_list);
return s;
}
} END_TEST
static Suite *
radixdb_suite() {
Suite *s;
TCase *tc_core;
s = suite_create("RadixDB");
/* Core test case */
tc_core = tcase_create("Core");
tcase_add_test(tc_core, test_single_entry);
tcase_add_test(tc_core, test_insert_then_get);
tcase_add_test(tc_core, test_insert_duplicate_key);
tcase_add_test(tc_core, test_match_first_node);
tcase_add_test(tc_core, test_longest_match_ordered);
tcase_add_test(tc_core, test_longest_match_reverse);
suite_add_tcase(s, tc_core);
return s;
}
END_TEST
Suite* hash_suite(void) {
Suite* test_hashes;
TCase* test_md5,
* test_sha1,
* test_sha224,
* test_sha256,
* test_sha384,
* test_sha512;
test_hashes = suite_create("Hashes");
test_md5 = tcase_create("MD5");
tcase_add_test(test_md5, test_md5_standard_vectors);
tcase_add_test(test_md5, test_md5_large_input_vector);
test_sha1 = tcase_create("SHA1");
tcase_add_test(test_sha1, test_sha1_standard_vectors);
tcase_add_test(test_sha1, test_sha1_large_input_vector);
test_sha224 = tcase_create("SHA224");
tcase_add_test(test_sha224, test_sha224_standard_vectors);
tcase_add_test(test_sha224, test_sha224_large_input_vector);
test_sha256 = tcase_create("SHA256");
tcase_add_test(test_sha256, test_sha256_standard_vectors);
tcase_add_test(test_sha256, test_sha256_large_input_vector);
test_sha384 = tcase_create("SHA384");
tcase_add_test(test_sha384, test_sha384_standard_vectors);
tcase_add_test(test_sha384, test_sha384_large_input_vector);
test_sha512 = tcase_create("SHA512");
tcase_add_test(test_sha512, test_sha512_standard_vectors);
tcase_add_test(test_sha512, test_sha512_large_input_vector);
suite_add_tcase(test_hashes, test_md5);
suite_add_tcase(test_hashes, test_sha1);
suite_add_tcase(test_hashes, test_sha224);
suite_add_tcase(test_hashes, test_sha256);
suite_add_tcase(test_hashes, test_sha384);
suite_add_tcase(test_hashes, test_sha512);
return test_hashes;
}
static Suite *
volume_suite (void)
{
Suite *s = suite_create ("volume");
TCase *tc_chain = tcase_create ("general");
suite_add_tcase (s, tc_chain);
tcase_add_test (tc_chain, test_unity_s8);
tcase_add_test (tc_chain, test_half_s8);
tcase_add_test (tc_chain, test_double_s8);
tcase_add_test (tc_chain, test_mute_s8);
tcase_add_test (tc_chain, test_unity_s16);
tcase_add_test (tc_chain, test_half_s16);
tcase_add_test (tc_chain, test_double_s16);
tcase_add_test (tc_chain, test_mute_s16);
tcase_add_test (tc_chain, test_unity_s24);
tcase_add_test (tc_chain, test_half_s24);
tcase_add_test (tc_chain, test_double_s24);
tcase_add_test (tc_chain, test_mute_s24);
tcase_add_test (tc_chain, test_unity_s32);
tcase_add_test (tc_chain, test_half_s32);
tcase_add_test (tc_chain, test_double_s32);
tcase_add_test (tc_chain, test_mute_s32);
tcase_add_test (tc_chain, test_unity_f32);
tcase_add_test (tc_chain, test_half_f32);
tcase_add_test (tc_chain, test_double_f32);
tcase_add_test (tc_chain, test_mute_f32);
tcase_add_test (tc_chain, test_unity_f64);
tcase_add_test (tc_chain, test_half_f64);
tcase_add_test (tc_chain, test_double_f64);
tcase_add_test (tc_chain, test_mute_f64);
tcase_add_test (tc_chain, test_wrong_caps);
tcase_add_test (tc_chain, test_passthrough);
tcase_add_test (tc_chain, test_controller_usability);
tcase_add_test (tc_chain, test_controller_processing);
return s;
}
END_TEST
Suite * packet_accessors_suite(void)
{
Suite *s = suite_create("Packet Accessor Functions");
TCase *tc = tcase_create("Core");
tcase_add_checked_fixture(tc, setup, teardown);
suite_add_tcase(s, tc);
tcase_add_test(tc, test_packet_version);
tcase_add_test(tc, test_packet_srcaddr);
tcase_add_test(tc, test_packet_dstaddr);
tcase_add_test(tc, test_packet_is_fragment);
tcase_add_test(tc, test_packet_frag_mf);
tcase_add_test(tc, test_packet_frag_df);
tcase_add_test(tc, test_packet_frag_offset);
tcase_add_test(tc, test_packet_protocol);
tcase_add_test(tc, test_packet_id);
tcase_add_test(tc, test_packet_ttl);
tcase_add_test(tc, test_packet_tos);
tcase_add_test(tc, test_packet_srcport);
tcase_add_test(tc, test_packet_dstport);
tcase_add_test(tc, test_packet_mss);
tcase_add_test(tc, test_packet_win);
tcase_add_test(tc, test_packet_winscale);
tcase_add_test(tc, test_packet_seq);
tcase_add_test(tc, test_packet_ack);
tcase_add_test(tc, test_packet_tcp_fin);
tcase_add_test(tc, test_packet_tcp_syn);
tcase_add_test(tc, test_packet_tcp_rst);
tcase_add_test(tc, test_packet_tcp_push);
tcase_add_test(tc, test_packet_tcp_ack);
tcase_add_test(tc, test_packet_tcp_urg);
tcase_add_test(tc, test_packet_payload);
tcase_add_test(tc, test_packet_paysize);
return s;
}
END_TEST
/* Change operations */
//int do_username(const u64_t useridnr, const char *newuser);
//int do_maxmail(const u64_t useridnr, const u64_t maxmail);
//int do_clientid(const u64_t useridnr, const u64_t clientid);
//int do_password(const u64_t useridnr,
// const char * const password,
// const char * const enctype);
//int do_aliases(const u64_t useridnr,
// GList * alias_add,
// GList * alias_del);
/* External forwards */
//int do_forwards(const char *alias, const u64_t clientid,
// GList * fwds_add,
// GList * fwds_del);
/* Helper functions */
//u64_t strtomaxmail(const char * const str);
Suite *dbmail_common_suite(void)
{
Suite *s = suite_create("Dbmail User");
TCase *tc_user = tcase_create("User");
suite_add_tcase(s, tc_user);
tcase_add_checked_fixture(tc_user, setup, teardown);
tcase_add_test(tc_user, test_do_add);
tcase_add_test(tc_user, test_do_show);
tcase_add_test(tc_user, test_do_empty);
tcase_add_test(tc_user, test_do_delete);
tcase_add_test(tc_user, test_dm_match);
tcase_add_test(tc_user, test_dm_match_list);
return s;
}
END_TEST
Suite *
create_suite_FormulaParser (void)
{
Suite *suite = suite_create("FormulaParser");
TCase *tcase = tcase_create("FormulaParser");
tcase_add_test( tcase, test_FormulaParser_getAction );
tcase_add_test( tcase, test_FormulaParser_getGoto );
tcase_add_test( tcase, test_FormulaParser_accessWithNULL );
tcase_add_test( tcase, test_SBML_parseFormula_1 );
tcase_add_test( tcase, test_SBML_parseFormula_2 );
tcase_add_test( tcase, test_SBML_parseFormula_3 );
tcase_add_test( tcase, test_SBML_parseFormula_4 );
tcase_add_test( tcase, test_SBML_parseFormula_5 );
tcase_add_test( tcase, test_SBML_parseFormula_6 );
tcase_add_test( tcase, test_SBML_parseFormula_7 );
tcase_add_test( tcase, test_SBML_parseFormula_8 );
tcase_add_test( tcase, test_SBML_parseFormula_9 );
tcase_add_test( tcase, test_SBML_parseFormula_10 );
tcase_add_test( tcase, test_SBML_parseFormula_11 );
tcase_add_test( tcase, test_SBML_parseFormula_12 );
tcase_add_test( tcase, test_SBML_parseFormula_13 );
tcase_add_test( tcase, test_SBML_parseFormula_14 );
tcase_add_test( tcase, test_SBML_parseFormula_15 );
tcase_add_test( tcase, test_SBML_parseFormula_16 );
tcase_add_test( tcase, test_SBML_parseFormula_17 );
tcase_add_test( tcase, test_SBML_parseFormula_18 );
tcase_add_test( tcase, test_SBML_parseFormula_negInf );
tcase_add_test( tcase, test_SBML_parseFormula_negZero );
suite_add_tcase(suite, tcase);
return suite;
}
END_TEST
Suite *tests_get_misc_suite(void) {
Suite *suite;
TCase *testcase;
suite = suite_create("misc");
testcase = tcase_create("base");
tcase_add_checked_fixture(testcase, set_up, tear_down);
tcase_add_test(testcase, schedule_test);
tcase_add_test(testcase, get_name_max_test);
tcase_add_test(testcase, dir_interpolate_test);
tcase_add_test(testcase, dir_best_path_test);
tcase_add_test(testcase, dir_canonical_path_test);
tcase_add_test(testcase, dir_canonical_vpath_test);
tcase_add_test(testcase, dir_realpath_test);
tcase_add_test(testcase, dir_abs_path_test);
tcase_add_test(testcase, symlink_mode_test);
tcase_add_test(testcase, file_mode_test);
tcase_add_test(testcase, exists_test);
tcase_add_test(testcase, dir_exists_test);
tcase_add_test(testcase, file_exists_test);
tcase_add_test(testcase, safe_token_test);
tcase_add_test(testcase, check_shutmsg_test);
tcase_add_test(testcase, memscrub_test);
tcase_add_test(testcase, getopt_reset_test);
tcase_add_test(testcase, gmtime_test);
tcase_add_test(testcase, localtime_test);
tcase_add_test(testcase, strtime_test);
tcase_add_test(testcase, strtime2_test);
tcase_add_test(testcase, timeval2millis_test);
tcase_add_test(testcase, gettimeofday_millis_test);
suite_add_tcase(suite, testcase);
return suite;
}
END_TEST
Suite *
create_suite_KineticLaw_newSetters (void)
{
Suite *suite = suite_create("KineticLaw_newSetters");
TCase *tcase = tcase_create("KineticLaw_newSetters");
tcase_add_checked_fixture( tcase,
KineticLawTest1_setup,
KineticLawTest1_teardown );
tcase_add_test( tcase, test_KineticLaw_setFormula1 );
tcase_add_test( tcase, test_KineticLaw_setFormula2 );
tcase_add_test( tcase, test_KineticLaw_setFormula3 );
tcase_add_test( tcase, test_KineticLaw_setMath1 );
tcase_add_test( tcase, test_KineticLaw_setMath2 );
tcase_add_test( tcase, test_KineticLaw_setMath3 );
tcase_add_test( tcase, test_KineticLaw_setTimeUnits1 );
tcase_add_test( tcase, test_KineticLaw_setTimeUnits2 );
tcase_add_test( tcase, test_KineticLaw_setTimeUnits3 );
tcase_add_test( tcase, test_KineticLaw_setTimeUnits4 );
tcase_add_test( tcase, test_KineticLaw_setSubstanceUnits1 );
tcase_add_test( tcase, test_KineticLaw_setSubstanceUnits2 );
tcase_add_test( tcase, test_KineticLaw_setSubstanceUnits3 );
tcase_add_test( tcase, test_KineticLaw_setSubstanceUnits4 );
tcase_add_test( tcase, test_KineticLaw_addParameter1 );
tcase_add_test( tcase, test_KineticLaw_addParameter2 );
tcase_add_test( tcase, test_KineticLaw_addParameter3 );
tcase_add_test( tcase, test_KineticLaw_addParameter4 );
tcase_add_test( tcase, test_KineticLaw_createParameter );
suite_add_tcase(suite, tcase);
return suite;
}
END_TEST
/**
* @brief Test entry point.
*/
int32_t main(int32_t argc, char **argv) {
Test_Init(argc, argv);
TCase *tcase = tcase_create("check_master");
tcase_add_checked_fixture(tcase, setup, teardown);
tcase_add_test(tcase, check_Ms_AddServer);
tcase_add_test(tcase, check_Ms_BlacklistServer);
Suite *suite = suite_create("check_master");
suite_add_tcase(suite, tcase);
int32_t failed = Test_Run(suite);
Test_Shutdown();
return failed;
}
static Suite *
audioresample_suite (void)
{
Suite *s = suite_create ("audioresample");
TCase *tc_chain = tcase_create ("general");
suite_add_tcase (s, tc_chain);
tcase_add_test (tc_chain, test_perfect_stream);
tcase_add_test (tc_chain, test_discont_stream);
tcase_add_test (tc_chain, test_reuse);
tcase_add_test (tc_chain, test_shutdown);
tcase_add_test (tc_chain, test_live_switch);
tcase_add_test (tc_chain, test_timestamp_drift);
tcase_add_test (tc_chain, test_fft);
#ifndef GST_DISABLE_PARSE
tcase_set_timeout (tc_chain, 360);
tcase_add_test (tc_chain, test_pipelines);
tcase_add_test (tc_chain, test_preference_passthrough);
#endif
return s;
}