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;
}
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;
}
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;
}
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;
}
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;
}
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;
}
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;
}
}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;
}
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;
}
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;
}
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;
}
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;
}
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;
}
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;
}
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;
}
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;
}
} 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;
}
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;
}
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;
}