/** Runs all tests within the basic interface.
* If non-NULL, the test registry is changed to the specified registry
* before running the tests, and reset to the original registry when
* done. If NULL, the default CUnit test registry will be used.
* @param pRegistry The CU_pTestRegistry containing the tests
* to be run. If NULL, use the default registry.
* @return An error code indicating the error status
* during the test run.
*/
static CU_ErrorCode basic_run_all_tests(CU_pTestRegistry pRegistry)
{
CU_pTestRegistry pOldRegistry = NULL;
CU_ErrorCode result;
f_pRunningSuite = NULL;
if (NULL != pRegistry)
pOldRegistry = CU_set_registry(pRegistry);
result = CU_run_all_tests();
if (NULL != pRegistry)
CU_set_registry(pOldRegistry);
return result;
}
/** Run the registered tests using the automated interface.
* If non-NULL. the specified registry is set as the active
* registry for running the tests. If NULL, then the default
* CUnit test registry is used. The actual test running is
* performed by CU_run_all_tests().
* @param pRegistry The test registry to run.
*/
static void automated_run_all_tests(CU_pTestRegistry pRegistry)
{
CU_pTestRegistry pOldRegistry = NULL;
assert(NULL != f_pTestResultFile);
f_pRunningSuite = NULL;
if (NULL != pRegistry) {
pOldRegistry = CU_set_registry(pRegistry);
}
fprintf(f_pTestResultFile," <CUNIT_RESULT_LISTING> \n");
CU_run_all_tests();
if (NULL != pRegistry) {
CU_set_registry(pOldRegistry);
}
}
/** Run all tests within the curses interface.
* The test registry is changed to the specified registry
* before running the tests, and reset to the original
* registry when done.
* @param pRegistry The CU_pTestRegistry containing the tests
* to be run (non-NULL).
* @return An error code indicating the error status
* during the test run.
*/
static CU_ErrorCode curses_run_all_tests(CU_pTestRegistry pRegistry)
{
CU_pTestRegistry pOldRegistry = NULL;
CU_ErrorCode result;
assert(pRegistry);
reset_run_parameters();
f_uiTotalTests = pRegistry->uiNumberOfTests;
f_uiTotalSuites = pRegistry->uiNumberOfSuites;
if (NULL != pRegistry) {
pOldRegistry = CU_set_registry(pRegistry);
}
result = CU_run_all_tests();
if (NULL != pOldRegistry) {
CU_set_registry(pOldRegistry);
}
return result;
}
int bc_tester_run_tests(const char *suite_name, const char *test_name) {
int i;
/* initialize the CUnit test registry */
if (CUE_SUCCESS != CU_initialize_registry())
return CU_get_error();
for (i = 0; i < nb_test_suites; i++) {
bc_tester_run_suite(test_suite[i]);
}
#ifdef HAVE_CU_GET_SUITE
CU_set_suite_start_handler(suite_start_message_handler);
CU_set_suite_complete_handler(suite_complete_message_handler);
CU_set_test_start_handler(test_start_message_handler);
CU_set_test_complete_handler(test_complete_message_handler);
#endif
CU_set_all_test_complete_handler(all_complete_message_handler);
CU_set_suite_init_failure_handler(suite_init_failure_message_handler);
CU_set_suite_cleanup_failure_handler(suite_cleanup_failure_message_handler);
if( xml_enabled != 0 ){
CU_automated_run_tests();
} else {
#ifndef HAVE_CU_GET_SUITE
if( suite_name ){
bc_tester_printf(bc_printf_verbosity_info, "Tester compiled without CU_get_suite() function, running all tests instead of suite '%s'", suite_name);
}
#else
if (suite_name){
CU_pSuite suite;
suite=CU_get_suite(suite_name);
if (!suite) {
bc_tester_printf(bc_printf_verbosity_error, "Could not find suite '%s'. Available suites are:", suite_name);
bc_tester_list_suites();
return -1;
} else if (test_name) {
CU_pTest test=CU_get_test_by_name(test_name, suite);
if (!test) {
bc_tester_printf(bc_printf_verbosity_error, "Could not find test '%s' in suite '%s'. Available tests are:", test_name, suite_name);
// do not use suite_name here, since this method is case sensitive
bc_tester_list_tests(suite->pName);
return -2;
} else {
CU_ErrorCode err= CU_run_test(suite, test);
if (err != CUE_SUCCESS) bc_tester_printf(bc_printf_verbosity_error, "CU_basic_run_test error %d", err);
}
} else {
CU_run_suite(suite);
}
}
else
#endif
{
#ifdef HAVE_CU_CURSES
if (curses) {
/* Run tests using the CUnit curses interface */
CU_curses_run_tests();
}
else
#endif
{
/* Run all tests using the CUnit Basic interface */
CU_run_all_tests();
}
}
}
#ifdef __linux
bc_tester_printf(bc_printf_verbosity_info, "Still %i kilobytes allocated when all tests are finished.",
mallinfo().uordblks / 1024);
#endif
return CU_get_number_of_tests_failed()!=0;
}
int liblinphone_tester_run_tests(const char *suite_name, const char *test_name) {
int i;
int ret;
/* initialize the CUnit test registry */
if (CUE_SUCCESS != CU_initialize_registry())
return CU_get_error();
for (i = 0; i < liblinphone_tester_nb_test_suites(); i++) {
run_test_suite(test_suite[i]);
}
CU_set_test_start_handler(test_start_message_handler);
CU_set_test_complete_handler(test_complete_message_handler);
CU_set_all_test_complete_handler(test_all_tests_complete_message_handler);
CU_set_suite_init_failure_handler(test_suite_init_failure_message_handler);
CU_set_suite_cleanup_failure_handler(test_suite_cleanup_failure_message_handler);
CU_set_suite_start_handler(test_suite_start_message_handler);
if( liblinphone_tester_xml_file != NULL ){
CU_set_output_filename(liblinphone_tester_xml_file);
}
if( liblinphone_tester_xml_enabled != 0 ){
CU_automated_run_tests();
} else {
#if !HAVE_CU_GET_SUITE
if( suite_name ){
ms_warning("Tester compiled without CU_get_suite() function, running all tests instead of suite '%s'\n", suite_name);
}
#else
if (suite_name){
CU_pSuite suite;
suite=CU_get_suite(suite_name);
if (!suite) {
ms_error("Could not find suite '%s'. Available suites are:", suite_name);
liblinphone_tester_list_suites();
return -1;
} else if (test_name) {
CU_pTest test=CU_get_test_by_name(test_name, suite);
if (!test) {
ms_error("Could not find test '%s' in suite '%s'. Available tests are:", test_name, suite_name);
// do not use suite_name here, since this method is case sensitive
liblinphone_tester_list_suite_tests(suite->pName);
return -2;
} else {
CU_ErrorCode err= CU_run_test(suite, test);
if (err != CUE_SUCCESS) ms_error("CU_basic_run_test error %d", err);
}
} else {
CU_run_suite(suite);
}
}
else
#endif
{
#if HAVE_CU_CURSES
if (curses) {
/* Run tests using the CUnit curses interface */
CU_curses_run_tests();
}
else
#endif
{
/* Run all tests using the CUnit Basic interface */
CU_run_all_tests();
}
}
}
ret=CU_get_number_of_tests_failed()!=0;
/* Redisplay list of failed tests on end */
if (CU_get_number_of_failure_records()){
CU_basic_show_failures(CU_get_failure_list());
liblinphone_tester_fprintf(stdout,"\n");
}
CU_cleanup_registry();
if( liblinphone_tester_keep_accounts_flag == 0){
liblinphone_tester_clear_accounts();
}
return ret;
}
/* The main() function for setting up and running the tests.
* Returns a CUE_SUCCESS on successful running, another
* CUnit error code on failure.
*/
int main(int argc, char *argv[])
{
#ifdef HAVE_CUNIT
int xml = 0;
int con = 0;
CU_pFailureRecord fr;
int size;
int i;
int rv;
if (argc >= 2 && !strcmp(argv[1], "-xml")) {
xml = 1;
} else
if (argc >= 2 && !strcmp(argv[1], "-con")) {
con = 1;
}
est_apps_startup();
est_set_log_source(EST_CLIENT);
/*
* Install thread locking mechanism for OpenSSL
*/
size = sizeof(pthread_mutex_t) * CRYPTO_num_locks();
if ((ssl_mutexes = (pthread_mutex_t*)malloc((size_t)size)) == NULL) {
printf("Cannot allocate mutexes");
exit(1);
}
for (i = 0; i < CRYPTO_num_locks(); i++) {
pthread_mutex_init(&ssl_mutexes[i], NULL);
}
CRYPTO_set_locking_callback(&ssl_locking_callback);
CRYPTO_set_id_callback(&ssl_id_callback);
/* initialize the CUnit test registry */
if (CUE_SUCCESS != CU_initialize_registry()) {
return CU_get_error();
}
#define ADD(N) { extern int N##_add_suite(void); rv = N##_add_suite(); \
if (rv != CUE_SUCCESS) { fprintf(stderr, "Failed "#N"_add_suite (%d)\n", rv); exit(1); } }
ADD(us748);
ADD(us893);
ADD(us894);
ADD(us895);
ADD(us896);
ADD(us897);
ADD(us898);
ADD(us899);
ADD(us900);
ADD(us901);
ADD(us902);
ADD(us903);
ADD(us1005);
ADD(us1060);
ADD(us1159);
ADD(us1864);
ADD(us1883);
ADD(us1884);
ADD(us2174);
if (xml) {
/* Run all test using automated interface, which
* generates XML output */
CU_list_tests_to_file();
CU_automated_run_tests();
} else if (con) {
CU_console_run_tests();
} else {
/* Run all tests using the CUnit Basic interface,
* which generates text output */
#if 0
CU_basic_set_mode(CU_BRM_VERBOSE);
CU_basic_run_tests();
#else
CU_set_test_start_handler (test_start);
CU_set_test_complete_handler(test_complete);
CU_run_all_tests();
#endif
fr = CU_get_failure_list();
if (fr) {
fprintf(stderr, "\nHere is a summary of the failed test cases:\n");
print_failures(fr);
} else {
fprintf(stderr, "\nAll enabled tests passed.\n");
}
}
/*
* Tear down the mutexes used by OpenSSL
*/
CRYPTO_set_locking_callback(NULL);
for (i = 0; i < CRYPTO_num_locks(); i++) {
pthread_mutex_destroy(&ssl_mutexes[i]);
}
CRYPTO_set_locking_callback(NULL);
CRYPTO_set_id_callback(NULL);
free(ssl_mutexes);
CU_cleanup_registry();
est_apps_shutdown();
return CU_get_error();
#else
printf("\nlibcunit not installed, unit tests are not enabled\n");
return 255;
#endif
}