/** Run CUnit tests using the automated interface.
* This function sets appropriate callback functions,
* initializes the test output files, and calls the
* appropriate functions to list the tests and run them.
* If an output file name root has not been specified using
* CU_set_output_filename(), a generic root will be applied.
* It is an error to call this function before the CUnit
* test registry has been initialized (check by assertion).
*/
void CU_automated_run_tests(void)
{
assert(NULL != CU_get_registry());
/* Ensure output makes it to screen at the moment of a SIGSEGV. */
//setvbuf(stdout, NULL, _IONBF, 0);
// setvbuf(stderr, NULL, _IONBF, 0);
/* if a filename root hasn't been set, use the default one */
if (0 == strlen(f_szTestResultFileName)) {
CU_set_output_filename(f_szDefaultFileRoot);
}
if (CUE_SUCCESS != initialize_result_file(f_szTestResultFileName)) {
__err( "\nERROR - Failed to create/initialize the result file.");
}
else {
/* set up the message handlers for writing xml output */
CU_set_test_start_handler(automated_test_start_message_handler);
CU_set_test_complete_handler(automated_test_complete_message_handler);
CU_set_all_test_complete_handler(automated_all_tests_complete_message_handler);
CU_set_suite_init_failure_handler(automated_suite_init_failure_message_handler);
CU_set_suite_cleanup_failure_handler(automated_suite_cleanup_failure_message_handler);
f_bWriting_CUNIT_RUN_SUITE = CU_FALSE;
automated_run_all_tests(NULL);
if (CUE_SUCCESS != uninitialize_result_file()) {
__err( "\nERROR - Failed to close/uninitialize the result files.");
}
}
}
/** Initialize the message handlers in preparation for running tests. */
static bool test_initialize(void)
{
CU_set_test_start_handler(curses_test_start_message_handler);
CU_set_test_complete_handler(curses_test_complete_message_handler);
CU_set_all_test_complete_handler(curses_all_tests_complete_message_handler);
CU_set_suite_init_failure_handler(curses_suite_init_failure_message_handler);
return true;
}
/** Perform inialization actions for the basic interface.
* This includes setting output to unbuffered, printing a
* welcome message, and setting the test run handlers.
* @return An error code indicating the framework error condition.
*/
static CU_ErrorCode basic_initialize(void)
{
/* Unbuffered output so everything reaches the screen */
setvbuf(stdout, NULL, _IONBF, 0);
setvbuf(stderr, NULL, _IONBF, 0);
CU_set_error(CUE_SUCCESS);
if (CU_BRM_SILENT != f_run_mode)
fprintf(stdout, "\n\n CUnit - A Unit testing framework for C - Version " CU_VERSION
"\n http://cunit.sourceforge.net/\n\n");
CU_set_test_start_handler(basic_test_start_message_handler);
CU_set_test_complete_handler(basic_test_complete_message_handler);
CU_set_all_test_complete_handler(basic_all_tests_complete_message_handler);
CU_set_suite_init_failure_handler(basic_suite_init_failure_message_handler);
CU_set_suite_cleanup_failure_handler(basic_suite_cleanup_failure_message_handler);
return CU_get_error();
}
/** Performs inialization actions for the basic interface.
* This includes setting output to unbuffered, printing a
* welcome message, and setting the test run handlers.
* @return An error code indicating the framework error condition.
*/
static CU_ErrorCode basic_initialize(void)
{
/* Unbuffered output so everything reaches the screen */
setvbuf(stdout, NULL, _IONBF, 0);
setvbuf(stderr, NULL, _IONBF, 0);
CU_set_error(CUE_SUCCESS);
if (CU_BRM_SILENT != f_run_mode)
fprintf(stdout, "\n\n %s" CU_VERSION
"\n %s\n\n",
_("BCUnit - A unit testing framework for C - Version "),
_("https://github.com/BelledonneCommunications/bcunit/"));
CU_set_test_start_handler(basic_test_start_message_handler);
CU_set_test_complete_handler(basic_test_complete_message_handler);
CU_set_all_test_complete_handler(basic_all_tests_complete_message_handler);
CU_set_suite_init_failure_handler(basic_suite_init_failure_message_handler);
CU_set_suite_cleanup_failure_handler(basic_suite_cleanup_failure_message_handler);
return CU_get_error();
}
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
}
