示例#1
0
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;
}
示例#3
0
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;
}
示例#7
0
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;
}
示例#11
0
} 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;
}
示例#12
0
文件: files-tests.c 项目: SSSD/sssd
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;
}
示例#13
0
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;
}
示例#14
0
文件: url.t.c 项目: droe/sslsplit
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;
}
示例#15
0
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;
}
示例#16
0
文件: evas_suite.c 项目: jigpu/efl
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;
}
示例#17
0
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;
}
示例#18
0
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;
}
示例#19
0
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;
}
示例#20
0
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;
}
示例#21
0
} 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;
}
示例#22
0
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;
}
示例#23
0
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;
}
示例#25
0
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;
}
示例#27
0
文件: misc.c 项目: predever/proftpd
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;
}
示例#29
0
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;
}
示例#30
0
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;
}