static Suite *
selector_suite (void)
{
  Suite *s = suite_create ("selector");
  TCase *tc_chain = tcase_create ("general");

  suite_add_tcase (s, tc_chain);
  tcase_add_test (tc_chain, test_output_selector_buffer_count);
  tcase_add_test (tc_chain, test_input_selector_buffer_count);
  tcase_add_test (tc_chain, test_input_selector_empty_stream);
  tcase_add_test (tc_chain, test_input_selector_shorter_stream);
  tcase_add_test (tc_chain, test_input_selector_switch_to_eos_stream);
  tcase_add_test (tc_chain, test_output_selector_no_srcpad_negotiation);

  tc_chain = tcase_create ("output-selector-negotiation");
  tcase_add_checked_fixture (tc_chain, setup_output_selector,
      teardown_output_selector);
  suite_add_tcase (s, tc_chain);
  tcase_add_test (tc_chain, test_output_selector_getcaps_none);
  tcase_add_test (tc_chain, test_output_selector_getcaps_all);
  tcase_add_test (tc_chain, test_output_selector_getcaps_active);

  return s;
}
Exemple #2
0
static Suite *
dtmf_suite (void)
{
  Suite *s = suite_create ("dtmf");
  TCase *tc;

  tc = tcase_create ("rtpdtmfdepay");
  tcase_add_test (tc, test_rtpdtmfdepay);
  suite_add_tcase (s, tc);

  tc = tcase_create ("rtpdtmfsrc");
  tcase_add_checked_fixture (tc, setup_rtpdtmfsrc, teardown_dtmfsrc);
  tcase_add_test (tc, test_dtmfsrc_invalid_events);
  tcase_add_test (tc, test_rtpdtmfsrc_min_duration);
  suite_add_tcase (s, tc);

  tc = tcase_create ("dtmfsrc");
  tcase_add_checked_fixture (tc, setup_dtmfsrc, teardown_dtmfsrc);
  tcase_add_test (tc, test_dtmfsrc_invalid_events);
  tcase_add_test (tc, test_dtmfsrc_min_duration);
  suite_add_tcase (s, tc);

  return s;
}
Exemple #3
0
END_TEST
#endif /* PR_USE_NLS */

Suite *tests_get_encode_suite(void) {
  Suite *suite;
  TCase *testcase;

  suite = suite_create("encode");

  testcase = tcase_create("base");
  tcase_add_checked_fixture(testcase, set_up, tear_down);

#ifdef PR_USE_NLS
  tcase_add_test(testcase, encode_encode_str_test);
  tcase_add_test(testcase, encode_decode_str_test);
  tcase_add_test(testcase, encode_charset_test);
  tcase_add_test(testcase, encode_encoding_test);
  tcase_add_test(testcase, encode_policy_test);
  tcase_add_test(testcase, encode_supports_telnet_iac_test);
#endif /* PR_USE_NLS */

  suite_add_tcase(suite, testcase);
  return suite;
}
Exemple #4
0
END_TEST


Suite *
create_suite_L3_Species (void)
{
  Suite *suite = suite_create("L3_Species");
  TCase *tcase = tcase_create("L3_Species");


  tcase_add_checked_fixture( tcase,
                             L3SpeciesTest_setup,
                             L3SpeciesTest_teardown );

  tcase_add_test( tcase, test_L3_Species_create              );
  tcase_add_test( tcase, test_L3_Species_free_NULL           );
  tcase_add_test( tcase, test_L3_Species_id               );
  tcase_add_test( tcase, test_L3_Species_name             );
  tcase_add_test( tcase, test_L3_Species_compartment            );
  tcase_add_test( tcase, test_L3_Species_initialAmount      );
  tcase_add_test( tcase, test_L3_Species_initialConcentration      );
  tcase_add_test( tcase, test_L3_Species_substanceUnits);
  tcase_add_test( tcase, test_L3_Species_hasOnlySubstanceUnits);
  tcase_add_test( tcase, test_L3_Species_boundaryCondition);
  tcase_add_test( tcase, test_L3_Species_constant);
  tcase_add_test( tcase, test_L3_Species_conversionFactor);
  tcase_add_test( tcase, test_L3_Species_createWithNS         );
  tcase_add_test( tcase, test_L3_Species_hasRequiredAttributes        );
  tcase_add_test( tcase, test_L3_Species_NS              );
  tcase_add_test( tcase, test_L3_Species_ModelHistory              );
  tcase_add_test( tcase, test_L3_Species_initDefaults            );

  suite_add_tcase(suite, tcase);

  return suite;
}
Exemple #5
0
static Suite *
gst_object_suite (void)
{
  Suite *s = suite_create ("GstObject");
  TCase *tc_chain = tcase_create ("general");

  /* turn off timeout */
  tcase_set_timeout (tc_chain, 60);

  suite_add_tcase (s, tc_chain);
  tcase_add_test (tc_chain, test_fake_object_new);
  tcase_add_test (tc_chain, test_fake_object_name);
#if 0
  tcase_add_test (tc_chain, test_fake_object_name_threaded_wrong);
#endif
  tcase_add_test (tc_chain, test_fake_object_name_threaded_right);
  tcase_add_test (tc_chain, test_fake_object_name_threaded_unique);
  tcase_add_test (tc_chain, test_fake_object_parentage);
  tcase_add_test (tc_chain, test_fake_object_parentage_dispose);

  tcase_add_test (tc_chain, test_fake_object_has_ancestor);
  //tcase_add_checked_fixture (tc_chain, setup, teardown);

  /* FIXME: GLib shouldn't crash here, but issue a warning and return a NULL
   * object, or at least g_error() and then abort properly ... (tpm) */
#ifndef HAVE_OSX
  /* Disabled for OS/X because a) it's a pretty silly test anyway and
   * b) different OS/X versions raise different signals and it isn't worth
   * the effort to try and detect which one should be producing which
   */
  /* SEGV tests go last so we can debug the others */
  tcase_add_test_raise_signal (tc_chain, test_fail_abstract_new, SIGSEGV);
#endif

  return s;
}
END_TEST


Suite *
create_suite_AlgebraicRule (void)
{
  Suite *suite = suite_create("AlgebraicRule");
  TCase *tcase = tcase_create("AlgebraicRule");


  tcase_add_checked_fixture( tcase,
                             AlgebraicRuleTest_setup,
                             AlgebraicRuleTest_teardown );

  tcase_add_test( tcase, test_AlgebraicRule_create         );
  tcase_add_test( tcase, test_AlgebraicRule_createWithFormula     );
  tcase_add_test( tcase, test_AlgebraicRule_createWithMath );
  tcase_add_test( tcase, test_AlgebraicRule_free_NULL      );
  tcase_add_test( tcase, test_AlgebraicRule_createWithNS         );

  suite_add_tcase(suite, tcase);

  return suite;
}
static Suite *
gst_info_suite (void)
{
  Suite *s = suite_create ("GstInfo");
  TCase *tc_chain = tcase_create ("info");

  tcase_set_timeout (tc_chain, 30);

  suite_add_tcase (s, tc_chain);
  tcase_add_test (tc_chain, info_fourcc);
#ifndef GST_DISABLE_GST_DEBUG
  tcase_add_test (tc_chain, info_segment_format_printf_extension);
  tcase_add_test (tc_chain, info_ptr_format_printf_extension);
  tcase_add_test (tc_chain, info_log_handler);
  tcase_add_test (tc_chain, info_dump_mem);
  tcase_add_test (tc_chain, info_fixme);
  tcase_add_test (tc_chain, info_old_printf_extensions);
  tcase_add_test (tc_chain, info_register_same_debug_category_twice);
  tcase_add_test (tc_chain, info_set_and_unset_single);
  tcase_add_test (tc_chain, info_set_and_unset_multiple);
#endif

  return s;
}
Exemple #8
0
END_TEST 

Suite *
make_test_libs_binary_tree_suite(void)
{
    Suite *suite;
    TCase *tc;

    suite = suite_create("binary_tree tests");
    tc = tcase_create("Core");
    tcase_add_test(tc, test_binary_tree_basic);
    /*
     * TODO: add other tests here 
     */
    /*
     * tcase_add_test(tc, test_binary_tree_new_test); 
     */
    tcase_add_test(tc, test_binary_tree_insert);
    tcase_add_test(tc, test_binary_tree_insert_duplicate);
    tcase_add_test(tc, test_binary_tree_remove);

    suite_add_tcase(suite, tc);
    return suite;
}
Exemple #9
0
static Suite *
oggmux_suite (void)
{
  Suite *s = suite_create ("oggmux");
  TCase *tc_chain = tcase_create ("general");

  suite_add_tcase (s, tc_chain);
#ifdef HAVE_VORBIS
  tcase_add_test (tc_chain, test_vorbis);
#endif

#ifdef HAVE_THEORA
  tcase_add_test (tc_chain, test_theora);
#endif

#if (defined (HAVE_THEORA) && defined (HAVE_VORBIS))
  tcase_add_test (tc_chain, test_vorbis_theora);
  tcase_add_test (tc_chain, test_theora_vorbis);
#endif

  tcase_add_test (tc_chain, test_simple_cleanup);
  tcase_add_test (tc_chain, test_request_pad_cleanup);
  return s;
}
Exemple #10
0
}END_TEST

Suite* lex_suite(){
	Suite *s = suite_create("Lex");
	TCase *tc_core = tcase_create("Core");

	tcase_add_test(tc_core,test_split_one);
	tcase_add_test(tc_core,test_split_two);
	tcase_add_test(tc_core,test_split_one_nofront);
	tcase_add_test(tc_core,test_split_one_noback);

	tcase_add_test(tc_core,test_identify_double_op);
	tcase_add_test(tc_core,test_identify_consecutive_op);

	tcase_add_test(tc_core,test_strip_backslash);

	tcase_add_test(tc_core,test_create_tokens);

	tcase_add_test(tc_core,test_lex);

	suite_add_tcase(s,tc_core);

	return s;
}
Exemple #11
0
END_TEST

Suite * hashmap_suite(void) {
  Suite *s = suite_create("HashMap");

  TCase *tc_core = tcase_create("Core");
  tcase_add_test(tc_core, test_hashmap_create);
  tcase_add_test(tc_core, test_hashmap_get);
  tcase_add_test(tc_core, test_hashmap_contains);
  tcase_add_test(tc_core, test_hashmap_locate_entry);
  tcase_add_test(tc_core, test_hashmap_put);
  tcase_add_test(tc_core, test_hashmap_entry_for_key);
  tcase_add_test(tc_core, test_hashmap_create_entry);
  tcase_add_test(tc_core, test_hashmap_index);
  tcase_add_test(tc_core, test_hashmap_hash);
  tcase_add_test(tc_core, test_hashmap_replace_entry_value);
  tcase_add_test(tc_core, test_hashmap_populate_entry);
  tcase_add_test(tc_core, test_hashmap_remove);
  tcase_add_test(tc_core, test_hashmap_clear);
  tcase_add_test(tc_core, test_hashmap_clear_index);
  suite_add_tcase(s, tc_core);

  return s;
}
Exemple #12
0
END_TEST

Suite *
scum_suite (void)
{
    Suite *s = suite_create ("Scum");
    TCase *tc_core = tcase_create ("Core");
    tcase_add_test (tc_core, test_make_fixnum);
    tcase_add_test (tc_core, test_make_character);
    tcase_add_test (tc_core, test_make_symbol);
    tcase_add_test (tc_core, test_pair_ops);
    tcase_add_test (tc_core, test_delim);
    tcase_add_test (tc_core, test_char_read);
    tcase_add_test (tc_core, test_read_string);
    tcase_add_test (tc_core, test_lambda);
    tcase_add_test (tc_core, test_nested_lambda);
    tcase_add_test (tc_core, test_lambda_recursion);
    tcase_add_test (tc_core, test_and);
    tcase_add_test (tc_core, test_or);
    tcase_add_test (tc_core, test_apply);
    suite_add_tcase (s, tc_core);

    return s;
}
Exemple #13
0
END_TEST

int main(void)
{
   register_trace_signal_handlers();

   Suite *s = suite_create("lib");

   TCase *tc_core = tcase_create("Core");
   tcase_add_unchecked_fixture(tc_core, setup, teardown);
   tcase_add_test(tc_core, test_lib_new);
   tcase_add_test(tc_core, test_lib_fopen);
   tcase_add_test(tc_core, test_lib_save);
   suite_add_tcase(s, tc_core);

   SRunner *sr = srunner_create(s);
   srunner_run_all(sr, CK_NORMAL);

   int nfail = srunner_ntests_failed(sr);

   srunner_free(sr);

   return nfail == 0 ? EXIT_SUCCESS : EXIT_FAILURE;
}
Exemple #14
0
static Suite *
gst_basetransform_suite (void)
{
  Suite *s = suite_create ("GstBaseTransform");
  TCase *tc = tcase_create ("general");

  suite_add_tcase (s, tc);
  tcase_add_checked_fixture (tc, transform1_setup, transform1_teardown);

  /* pass through */
  tcase_add_test (tc, basetransform_chain_pt1);
  tcase_add_test (tc, basetransform_chain_pt2);
  /* in place */
  tcase_add_test (tc, basetransform_chain_ip1);
  tcase_add_test (tc, basetransform_chain_ip2);
  /* copy transform */
  tcase_add_test (tc, basetransform_chain_ct1);
  tcase_add_test (tc, basetransform_chain_ct2);
  tcase_add_test (tc, basetransform_chain_ct3);
  /* stress */
  tcase_add_test (tc, basetransform_stress_pt_ip);

  return s;
}
END_TEST

int main(int argc, char *argv[]) {
    int failed = 0;
    Suite *s;
    TCase *tc;
    SRunner *sr;

    bname = argv[0];

    s = suite_create("Extended");
    tc = tcase_create("extended");
    tcase_add_test(tc, extended_test);
    /* 4s of audio, 0.5s grace time */
    tcase_set_timeout(tc, 4.5);
    suite_add_tcase(s, tc);

    sr = srunner_create(s);
    srunner_run_all(sr, CK_NORMAL);
    failed = srunner_ntests_failed(sr);
    srunner_free(sr);

    return (failed == 0) ? EXIT_SUCCESS : EXIT_FAILURE;
}
Exemple #16
0
END_TEST

Suite *standardLoop_suite(void)
{
  Suite *s = suite_create("standardLoop test suite");

  TCase *tc_axis = tcase_create("axis");
  tcase_add_test(tc_axis, axis_012);
  tcase_add_test(tc_axis, axis_102);
  tcase_add_test(tc_axis, axis_201);
  suite_add_tcase(s, tc_axis);

  TCase *tc_axis_eachrow = tcase_create("axis eachrow");
  tcase_add_test(tc_axis_eachrow, axis_012_eachrow);
  tcase_add_test(tc_axis_eachrow, axis_102_eachrow);
  tcase_add_test(tc_axis_eachrow, axis_201_eachrow);
  suite_add_tcase(s, tc_axis_eachrow);

  TCase *tc_axis_edge = tcase_create("axis edge");
  tcase_add_test(tc_axis_edge, edge);
  suite_add_tcase(s, tc_axis_edge);

  return s;
}
END_TEST

Suite *
create_suite_XMLOutputStream (void)
{
  Suite *suite = suite_create("XMLOutputStream");
  TCase *tcase = tcase_create("XMLOutputStream");

  tcase_add_test( tcase, test_XMLOutputStream_createStdout  );
  tcase_add_test( tcase, test_XMLOutputStream_createFile  );
  tcase_add_test( tcase, test_XMLOutputStream_createString  );
  tcase_add_test( tcase, test_XMLOutputStream_createStdoutWithProgramInfo  );
  tcase_add_test( tcase, test_XMLOutputStream_createFileWithProgramInfo    );
  tcase_add_test( tcase, test_XMLOutputStream_createStringWithProgramInfo  );
  tcase_add_test( tcase, test_XMLOutputStream_startEnd  );
  tcase_add_test( tcase, test_XMLOutputStream_Elements  );
  tcase_add_test( tcase, test_XMLOutputStream_CharacterReference );
  tcase_add_test( tcase, test_XMLOutputStream_PredefinedEntity );
  tcase_add_test( tcase, test_XMLOutputStream_accessWithNULL               );

  suite_add_tcase(suite, tcase);

  return suite;
}
END_TEST


Suite *
create_suite_L3Trigger (void)
{
    Suite *suite = suite_create("L3Trigger");
    TCase *tcase = tcase_create("L3Trigger");


    tcase_add_checked_fixture( tcase,
                               L3TriggerTest_setup,
                               L3TriggerTest_teardown );

    tcase_add_test( tcase, test_L3Trigger_create       );
    tcase_add_test( tcase, test_L3Trigger_setInitialValue      );
    tcase_add_test( tcase, test_L3Trigger_setInitialValue1     );
    tcase_add_test( tcase, test_L3Trigger_setPersistent      );
    tcase_add_test( tcase, test_L3Trigger_setPersistent1     );

    suite_add_tcase(suite, tcase);

    return suite;
}
Exemple #19
0
END_TEST



Suite *packages_test_suite()
{
  Suite *s = suite_create ("Packages");
  TCase *tc = tcase_create ("Packages");

  tcase_add_test (tc, test_struct_pkg);
  tcase_add_test (tc, test_pkg_info);
  tcase_add_test (tc, test_pkg_list);
  tcase_add_test (tc, test_pkg_search);
  tcase_add_test (tc, test_pkgtool);
  tcase_add_test (tc, test_pkg_version);
  tcase_add_test (tc, test_version);
  tcase_add_test (tc, test_dependency);
  tcase_add_test (tc, test_cache);
  tcase_add_test (tc, test_error);
  tcase_add_test (tc, test_network);

  suite_add_tcase (s, tc);
  return s;
}
END_TEST

Suite *nserv_util_suite (void)
{
    Suite *s;
    TCase *tc_core;
    
    s = suite_create("new server util funcs");

    /* Core test case */
    tc_core = tcase_create("core");

    tcase_add_test(tc_core, test_nserv_shuffle);
    tcase_add_test(tc_core, test_nserv_shuffle_err);
    tcase_add_test(tc_core, test_nserv_create_decks);
    tcase_add_test(tc_core, test_nserv_create_decks_err);
    tcase_add_test(tc_core, test_nserv_deckrotate);
    tcase_add_test(tc_core, test_nserv_deckrotate_err);
    tcase_add_test(tc_core, test_nserv_create_player);

    suite_add_tcase (s, tc_core);

    return s;
}
Exemple #21
0
Suite *
audiowsincband_suite (void)
{
  Suite *s = suite_create ("audiowsincband");
  TCase *tc_chain = tcase_create ("general");

  suite_add_tcase (s, tc_chain);
  tcase_add_test (tc_chain, test_32_bp_0hz);
  tcase_add_test (tc_chain, test_32_bp_11025hz);
  tcase_add_test (tc_chain, test_32_bp_22050hz);
  tcase_add_test (tc_chain, test_32_br_0hz);
  tcase_add_test (tc_chain, test_32_br_11025hz);
  tcase_add_test (tc_chain, test_32_br_22050hz);
  tcase_add_test (tc_chain, test_32_small_buffer);
  tcase_add_test (tc_chain, test_64_bp_0hz);
  tcase_add_test (tc_chain, test_64_bp_11025hz);
  tcase_add_test (tc_chain, test_64_bp_22050hz);
  tcase_add_test (tc_chain, test_64_br_0hz);
  tcase_add_test (tc_chain, test_64_br_11025hz);
  tcase_add_test (tc_chain, test_64_br_22050hz);
  tcase_add_test (tc_chain, test_64_small_buffer);

  return s;
}
Exemple #22
0
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);
#ifndef _WIN32
	tcase_set_timeout(tc, 0);
#endif
     }

   return s;
}
END_TEST

int main(void)
{
    Suite *s1 = suite_create("Core");
    TCase *tc1_1 = tcase_create("Core");
    SRunner *sr = srunner_create(s1);
    int nf;

    suite_add_tcase(s1, tc1_1);
    tcase_add_test(tc1_1, sum_function);
    tcase_add_test(tc1_1, stringLengthTest);
    tcase_add_test(tc1_1, stringCopyTest);
    tcase_add_test(tc1_1, getSubString1);
    tcase_add_test(tc1_1, getSubString2);
    tcase_add_test(tc1_1, concatString1);
    tcase_add_test(tc1_1, concatString2);

    srunner_run_all(sr, CK_ENV);
    nf = srunner_ntests_failed(sr);
    srunner_free(sr);

    return nf == 0 ? 0 : 1;
}
Exemple #24
0
} TEND

/************************************************************/
Suite *
imsettings_suite(void)
{
	Suite *s = suite_create("IMSettingsInfo");
	TCase *tc = tcase_create("Generic Functionalities");

	tcase_add_checked_fixture(tc, setup, teardown);

	T (imsettings_info_new);
	T (imsettings_info_get_language);
	T (imsettings_info_get_filename);
	T (imsettings_info_get_gtkimm);
	T (imsettings_info_get_qtimm);
	T (imsettings_info_get_xim);
	T (imsettings_info_get_xim_program);
	T (imsettings_info_get_xim_args);
	T (imsettings_info_get_prefs_program);
	T (imsettings_info_get_prefs_args);
	T (imsettings_info_get_aux_program);
	T (imsettings_info_get_aux_args);
	T (imsettings_info_get_short_desc);
	T (imsettings_info_get_long_desc);
	T (imsettings_info_get_icon_file);
	T (imsettings_info_is_visible);
	T (imsettings_info_is_system_default);
	T (imsettings_info_is_user_default);
	T (imsettings_info_is_xim);
	T (imsettings_info_compare);

	suite_add_tcase(s, tc);

	return s;
}
END_TEST
	
Suite* roman_validator_suite(void)
{
	Suite *s;
	TCase *tc_roman_validator;

	s = suite_create("Roman Numerals Validator");

	tc_roman_validator = tcase_create("Roman Validator");

	tcase_add_test(tc_roman_validator, test_input_A_is_invalid);
	tcase_add_test(tc_roman_validator, test_input_IIII_is_invalid);
	tcase_add_test(tc_roman_validator, test_input_MMDDCC_is_invalid);
	tcase_add_test(tc_roman_validator, test_input_IIZJID_is_invalid);
	tcase_add_test(tc_roman_validator, test_input_MMMMM_is_invalid);
	tcase_add_test(tc_roman_validator, test_input_MMMCMXCIX_is_valid);
	tcase_add_test(tc_roman_validator, test_input_DCLXXXVII_is_valid);
	tcase_add_test(tc_roman_validator, test_input_XCIX_is_valid);

	suite_add_tcase(s, tc_roman_validator);

	return s;
}
END_TEST

Suite *
cacacomun_suite(void) {

	Suite *s = suite_create("Caca comun");

	/* Core test case */
	TCase *tc_core = tcase_create("Core");
	tcase_set_timeout(tc_core, 600);
	tcase_add_test(tc_core, test_lee_matrix_long_stdin);
	tcase_add_test(tc_core, test_lee_matrix);
	tcase_add_test(tc_core, test_lee_matrix_stdin);
	tcase_add_test(tc_core, test_apuntador_arreglo);
	tcase_add_test(tc_core, test_apuntador_allocado);
	tcase_add_test(tc_core, test_imprime_apuntador);
	tcase_add_test(tc_core, test_imprime_array);
	tcase_add_test(tc_core, test_init_grapho);
	tcase_add_test(tc_core, test_init_grapho_busq_bin);
	tcase_add_test(tc_core, test_init_arbol_avl);
	tcase_add_test(tc_core, test_borrar_arbol_binario);
	tcase_add_test(tc_core, test_borrar_arbol_avl);
	tcase_add_test(tc_core, test_borrar_arbol_avl_ref_dir);
	tcase_add_test(tc_core, test_dijkstra_modificar_valor_nodo);
	tcase_add_test(tc_core, test_cola_prioridad_pop);
	tcase_add_test(tc_core, test_dijkstra);
	tcase_add_test(tc_core, test_grafo_copia_profunda);
	tcase_add_test(tc_core, test_grafo_copia_profunda_lista_ignorar);
	/*
	 */
	/*
	 */
	suite_add_tcase(s, tc_core);

	return s;
}
Exemple #27
0
END_TEST

// Construct the test suite
Suite* make_lifo_suite() {
    Suite* s = suite_create ("LIFO");

    // Core operation
    TCase* tc_core = tcase_create("Core");
    tcase_add_test(tc_core, test_lifo_create);
    tcase_add_test(tc_core, test_lifo_enqueue_once);
    tcase_add_test(tc_core, test_lifo_enqueue_dequeue_once);
    tcase_add_test(tc_core, test_lifo_enqueue_multiple);
    tcase_add_test(tc_core, test_lifo_enqueue_dequeue_multiple);
    suite_add_tcase(s, tc_core);

    // Invalid operation
    TCase* tc_invalid = tcase_create("Invalid");
    tcase_add_test(tc_invalid, test_lifo_dequeue_empty);
    tcase_add_test(tc_invalid, test_lifo_enqueue_nonlifo);
    suite_add_tcase(s, tc_invalid);

    // Return constructed suite
    return s;
}
static Suite *
effectv_suite (void)
{
  Suite *s = suite_create ("effectv");
  TCase *tc_chain = tcase_create ("general");

  suite_add_tcase (s, tc_chain);
  tcase_set_timeout (tc_chain, 180);

  tcase_add_test (tc_chain, test_agingtv);
  tcase_add_test (tc_chain, test_dicetv);
  tcase_add_test (tc_chain, test_edgetv);
  tcase_add_test (tc_chain, test_optv);
  tcase_add_test (tc_chain, test_quarktv);
  tcase_add_test (tc_chain, test_radioactv);
  tcase_add_test (tc_chain, test_revtv);
  tcase_add_test (tc_chain, test_rippletv);
  tcase_add_test (tc_chain, test_shagadelictv);
  tcase_add_test (tc_chain, test_streaktv);
  tcase_add_test (tc_chain, test_vertigotv);
  tcase_add_test (tc_chain, test_warptv);

  return s;
}
Exemple #29
0
END_TEST



Suite *
swift_integration(void) {
  
  Suite *s = suite_create("libswift");
  TCase *tc_int = tcase_create("Integration Tests");

  tcase_add_test(tc_int, test_reset);
  tcase_add_test(tc_int, test_container_create);
  tcase_add_test(tc_int, test_container_overwrite);
  tcase_add_test(tc_int, test_objects_create);
  tcase_add_test(tc_int, test_objects_premove_verify);
  tcase_add_test(tc_int, test_object_put);
  tcase_add_test(tc_int, test_objects_delete);
  tcase_add_test(tc_int, test_container_delete);

  tcase_set_timeout(tc_int, 100);
  suite_add_tcase(s, tc_int);

  return s;
}
END_TEST

Suite *
jabber_jutil_suite(void)
{
	Suite *s = suite_create("Jabber Utility Functions");

	TCase *tc = tcase_create("Get Resource");
	tcase_add_test(tc, test_get_resource);
	tcase_add_test(tc, test_get_resource_no_resource);
	suite_add_tcase(s, tc);

	tc = tcase_create("Get Bare JID");
	tcase_add_test(tc, test_get_bare_jid);
	suite_add_tcase(s, tc);

	tc = tcase_create("Nodeprep validate");
	tcase_add_test(tc, test_nodeprep_validate);
	tcase_add_test(tc, test_nodeprep_validate_illegal_chars);
	tcase_add_test(tc, test_nodeprep_validate_too_long);
	suite_add_tcase(s, tc);

	return s;
}