int main(
const int argc,
const char* const * argv)
{
int exitCode = 1;
const char* progname = basename((char*) argv[0]);
if (-1 == openulog(progname, 0, LOG_LOCAL0, "-")) {
(void) fprintf(stderr, "Couldn't open logging system\n");
}
else {
if (CUE_SUCCESS == CU_initialize_registry()) {
CU_Suite* testSuite = CU_add_suite(__FILE__, setup, teardown);
if (NULL != testSuite) {
if (CU_ADD_TEST(testSuite, test_msm_init)
&& CU_ADD_TEST(testSuite, test_locking)
&& CU_ADD_TEST(testSuite, test_msm_put)
&& CU_ADD_TEST(testSuite, test_msm_getPid)
&& CU_ADD_TEST(testSuite, test_msm_removePid)
&& CU_ADD_TEST(testSuite, test_msm_destroy)
) {
CU_basic_set_mode(CU_BRM_VERBOSE);
(void) CU_basic_run_tests();
}
}
exitCode = CU_get_number_of_tests_failed();
CU_cleanup_registry();
}
}
return exitCode;
}
int main(
const int argc,
const char* const * argv)
{
int exitCode = 1;
const char* progname = basename((char*) argv[0]);
(void)log_init(progname);
if (CUE_SUCCESS == CU_initialize_registry()) {
CU_Suite* testSuite = CU_add_suite(__FILE__, setup, teardown);
if (NULL != testSuite) {
if (CU_ADD_TEST(testSuite, test_exe_new) &&
CU_ADD_TEST(testSuite, test_exe_submit) &&
CU_ADD_TEST(testSuite, test_exe_shutdown_empty) &&
CU_ADD_TEST(testSuite, test_exe_shutdown) &&
CU_ADD_TEST(testSuite, test_submit_while_shutdown) &&
CU_ADD_TEST(testSuite, test_exe_clear)) {
CU_basic_set_mode(CU_BRM_VERBOSE);
(void) CU_basic_run_tests();
}
}
exitCode = CU_get_number_of_tests_failed();
CU_cleanup_registry();
}
log_free();
return exitCode;
}
int
main(
const int argc,
const char* const* argv)
{
int exitCode = EXIT_FAILURE;
if (log_init(argv[0])) {
(void)fprintf(stderr, "Couldn't initialize logging system\n");
}
else {
if (CUE_SUCCESS == CU_initialize_registry()) {
CU_Suite* testSuite = CU_add_suite(__FILE__, setup,
teardown);
if (NULL != testSuite) {
CU_ADD_TEST(testSuite, test_add_get);
CU_ADD_TEST(testSuite, test_order);
if (CU_basic_run_tests() == CUE_SUCCESS)
exitCode = CU_get_number_of_suites_failed() +
CU_get_number_of_tests_failed();
}
CU_cleanup_registry();
} /* CUnit registery allocated */
log_free();
} /* logging system initialized */
return exitCode;
}
void TcuExecute(void)
{
if (TestGetAutomatic()) {
if (TestGetFilename()) {
CU_set_output_filename(TestGetFilename());
}
CU_automated_run_tests();
}
else if (TestGetBasic()) {
CU_basic_set_mode(CU_BRM_VERBOSE);
(void) CU_basic_run_tests();
}
else if (TestGetConsole()) {
CU_console_run_tests();
}
else if (TestGetList()) {
if (TestGetFilename()) {
CU_set_output_filename(TestGetFilename());
}
(void) CU_list_tests_to_file();
}
if (CU_get_number_of_tests_failed()) {
return;
}
/* Clean up the registry */
CU_cleanup_registry();
}
int main(
const int argc,
const char* const * argv)
{
int exitCode = 1; // Failure default
int status = log_init(argv[0]);
if (status) {
(void) fprintf(stderr, "Couldn't initialize logging system\n");
}
else {
if (CUE_SUCCESS == CU_initialize_registry()) {
CU_Suite* testSuite = CU_add_suite(__FILE__, setup, teardown);
if (NULL != testSuite) {
if (CU_ADD_TEST(testSuite, test_fq_new) &&
CU_ADD_TEST(testSuite, test_fq_shutdown) &&
CU_ADD_TEST(testSuite, test_write_then_read) &&
CU_ADD_TEST(testSuite, test_concurrency)) {
CU_basic_set_mode(CU_BRM_VERBOSE);
(void) CU_basic_run_tests();
}
}
exitCode = CU_get_number_of_tests_failed();
CU_cleanup_registry();
}
}
log_fini();
return exitCode;
}
int main() {
if (CU_initialize_registry() != CUE_SUCCESS)
return CU_get_error();
unsigned int tests_failed = 0;
CU_pSuite suite = CU_add_suite("Shunting Yard", NULL, NULL);
if (!suite)
goto exit;
if (!CU_add_test(suite, "addition", test_addition) ||
!CU_add_test(suite, "subtraction", test_subtraction) ||
!CU_add_test(suite, "multiplication", test_multiplication) ||
!CU_add_test(suite, "division", test_division) ||
!CU_add_test(suite, "modulus", test_modulus) ||
!CU_add_test(suite, "exponentiation", test_exponentiation) ||
!CU_add_test(suite, "factorials", test_factorials) ||
!CU_add_test(suite, "functions", test_functions) ||
!CU_add_test(suite, "constants", test_constants) ||
!CU_add_test(suite, "operator precedence", test_precedence) ||
!CU_add_test(suite, "error handling", test_errors))
goto exit;
CU_basic_set_mode(CU_BRM_NORMAL);
CU_basic_run_tests();
tests_failed = CU_get_number_of_tests_failed();
exit:
CU_cleanup_registry();
return tests_failed ? EXIT_FAILURE : CU_get_error();
}
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]);
}
if (suite_name){
CU_pSuite suite;
CU_basic_set_mode(CU_BRM_VERBOSE);
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 sentisitive
liblinphone_tester_list_suite_tests(suite->pName);
return -2;
} else {
CU_ErrorCode err= CU_basic_run_test(suite, test);
if (err != CUE_SUCCESS) ms_error("CU_basic_run_test error %d", err);
}
} else {
CU_basic_run_suite(suite);
}
} else
{
#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_basic_set_mode(CU_BRM_VERBOSE);
CU_basic_run_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());
printf("\n");
}
CU_cleanup_registry();
return ret;
}
int main(
const int argc,
const char* const * argv)
{
int exitCode = 1;
if (log_init(argv[0])) {
log_syserr("Couldn't initialize logging module");
exitCode = EXIT_FAILURE;
}
else {
if (CUE_SUCCESS == CU_initialize_registry()) {
CU_Suite* testSuite = CU_add_suite(__FILE__, setup, teardown);
if (NULL != testSuite) {
if (CU_ADD_TEST(testSuite, test_socketpair)) {
CU_basic_set_mode(CU_BRM_VERBOSE);
(void) CU_basic_run_tests();
}
}
exitCode = CU_get_number_of_tests_failed();
CU_cleanup_registry();
}
log_fini();
}
return exitCode;
}
int main(
const int argc,
const char* const * argv)
{
int exitCode = 1;
const char* progname = basename((char*) argv[0]);
if (log_init(progname)) {
(void) fprintf(stderr, "Couldn't open logging system\n");
exitCode = 1;
}
else {
if (CUE_SUCCESS == CU_initialize_registry()) {
CU_Suite* testSuite = CU_add_suite(__FILE__, setup, teardown);
if (NULL != testSuite) {
if (CU_ADD_TEST(testSuite, test_null_buffer) &&
CU_ADD_TEST(testSuite, test_ft_format_none) &&
CU_ADD_TEST(testSuite, test_ft_format_any) &&
CU_ADD_TEST(testSuite, test_ft_format_ids_ddplus) &&
CU_ADD_TEST(testSuite, test_ps_format) &&
CU_ADD_TEST(testSuite, test_ts_format) &&
CU_ADD_TEST(testSuite, test_pc_format)) {
CU_basic_set_mode(CU_BRM_VERBOSE);
(void) CU_basic_run_tests();
}
}
exitCode = CU_get_number_of_tests_failed();
CU_cleanup_registry();
}
}
return exitCode;
}
int main() {
// Set the library error handler to the custom one
gmcmc_error_handler = cu_error_handler;
// Initialise the CUnit test registry
CU_ErrorCode error;
if ((error = CU_initialize_registry()) != CUE_SUCCESS) {
fprintf(stderr, "failed to initialise test registry: %s\n", CU_get_error_msg());
return error;
}
// Create a test suite within the registry
CU_pSuite suite;
if ((suite = CU_add_suite("prior", NULL, NULL)) == NULL) {
fprintf(stderr, "failed to create test suite: %s\n", CU_get_error_msg());
return error;
}
// Add the tests to the suite
if (CU_ADD_TEST(suite, test_prior_create) == NULL) {
fprintf(stderr, "failed to add test: %s\n", CU_get_error_msg());
return error;
}
if (CU_ADD_TEST(suite, test_prior_sample) == NULL) {
fprintf(stderr, "failed to add test: %s\n", CU_get_error_msg());
return error;
}
if (CU_ADD_TEST(suite, test_prior_evaluate) == NULL) {
fprintf(stderr, "failed to add test: %s\n", CU_get_error_msg());
return error;
}
if (CU_ADD_TEST(suite, test_prior_evaluate_1st_order) == NULL) {
fprintf(stderr, "failed to add test: %s\n", CU_get_error_msg());
return error;
}
if (CU_ADD_TEST(suite, test_prior_evaluate_2nd_order) == NULL) {
fprintf(stderr, "failed to add test: %s\n", CU_get_error_msg());
return error;
}
// Run the test suites using the CUnit basic interface
if ((error = CU_basic_run_tests()) != CUE_SUCCESS) {
fprintf(stderr, "failed to run tests: %s\n", CU_get_error_msg());
return error;
}
// Display any failures (plus hack for newline afterwards)
CU_basic_show_failures(CU_get_failure_list());
if (CU_get_number_of_failure_records() > 0) printf("\n");
// Get the number of tests that failed
unsigned int failures = CU_get_number_of_tests_failed();
// Cleanup the test registry
CU_cleanup_registry();
// Return the number of test failures
return (int)failures;
}
int
main(int argc, char *argv[])
{
CU_pSuite kvstore_suite = NULL;
unsigned int fails = 0;
printf("starting tests for kvstore...\n");
if (!CUE_SUCCESS == CU_initialize_registry()) {
fprintf(stderr, "error initialising CUnit test registry!\n");
return EXIT_FAILURE;
}
/*
* set up the suite
*/
kvstore_suite = CU_add_suite("kvstore_tests", initialise_kvstore_test,
cleanup_kvstore_test);
if (NULL == kvstore_suite)
destroy_test_registry();
if (NULL == CU_add_test(kvstore_suite, "lifecycle",
test_kvstore_new))
destroy_test_registry();
if (NULL == CU_add_test(kvstore_suite, "double refcount check",
test_kvstore_refcount))
destroy_test_registry();
if (NULL == CU_add_test(kvstore_suite, "many refcounts check",
test_kvstore_many_refcounts))
destroy_test_registry();
if (NULL == CU_add_test(kvstore_suite, "kvstore set",
test_kvstore_set))
destroy_test_registry();
if (NULL == CU_add_test(kvstore_suite, "kvstore update",
test_kvstore_update))
destroy_test_registry();
if (NULL == CU_add_test(kvstore_suite, "kvstore delete",
test_kvstore_del))
destroy_test_registry();
if (NULL == CU_add_test(kvstore_suite, "multikey test",
test_kvstore_multikey))
destroy_test_registry();
CU_basic_set_mode(CU_BRM_VERBOSE);
CU_basic_run_tests();
fails = CU_get_number_of_tests_failed();
CU_cleanup_registry();
return fails;
}
int main(int argc, char *argv[])
{
CU_ErrorCode cuStatus = CU_initialize_registry();
if (CUE_SUCCESS != cuStatus)
{
fprintf(stderr, "could not create CUnit test registry\n");
return -1;
}
gcstl_test_testStartPrint();
CU_TestInfo test_gcstl_destroy[] =
{
{ "test_gcstl_destroy_default", test_gcstl_destroy_default },
CU_TEST_INFO_NULL
};
CU_TestInfo test_gcstl_rbtree[] =
{
{ "test_gcstl_rbtree_insert", test_gcstl_rbtree_insert },
{ "test_gcstl_rbtree_remove", test_gcstl_rbtree_remove },
CU_TEST_INFO_NULL
};
CU_SuiteInfo gcstl_test_suites[] =
{
{ "test_gcstl_destroy", NULL, NULL, test_gcstl_destroy},
{ "test_gcstl_rbtree", NULL, NULL, test_gcstl_rbtree },
CU_SUITE_INFO_NULL
};
cuStatus = CU_register_suites(gcstl_test_suites);
if (CUE_SUCCESS != cuStatus)
{
fprintf(stderr, "could register CUnit test suites\n");
return -1;
}
CU_basic_run_tests();
if (CUE_SUCCESS != cuStatus)
{
gcstl_test_testFailedToCompletePrint();
return -1;
}
else if (0 != CU_get_number_of_tests_failed())
{
gcstl_test_testCompleteWithFailuresPrint();
return -1;
}
gcstl_test_testCompleteSuccessfullyPrint();
CU_cleanup_registry();
return 0;
}
int main(int argc, char **argv) {
if (argc == 2 && (strcmp(argv[1], "--help") == 0 || strcmp(argv[1], "-h") == 0)) {
fprintf(stderr, "usage %s [test prefix]\n\ntest options:\n", argv[0]);
for (test_case_t *p = test_cases; p != NULL; p = p->next) {
fprintf(stderr, " %s\n", p->description);
}
return EXIT_FAILURE;
}
if (CU_initialize_registry() != CUE_SUCCESS) {
CU_ErrorCode err = CU_get_error();
fprintf(stderr, "failed to initialise CUnit registry\n");
return err;
}
CU_pSuite suite = CU_add_suite("passwand", NULL, NULL);
if (suite == NULL) {
CU_ErrorCode err = CU_get_error();
CU_cleanup_registry();
fprintf(stderr, "failed to add suite\n");
return err;
}
unsigned total = 0;
for (test_case_t *p = test_cases; p != NULL; p = p->next) {
if (argc == 1 || strncmp(argv[1], p->description, strlen(argv[1])) == 0) {
if (CU_add_test(suite, p->description, p->function) == NULL) {
CU_ErrorCode err = CU_get_error();
fprintf(stderr, "failed to add test \"%s\"\n", p->description);
CU_cleanup_registry();
return err;
}
total++;
}
}
if (total == 0) {
fprintf(stderr, "no tests found\n");
return EXIT_FAILURE;
}
CU_basic_set_mode(CU_BRM_VERBOSE);
CU_basic_run_tests();
unsigned failed = CU_get_number_of_tests_failed();
CU_cleanup_registry();
printf("%u/%u passed\n", total - failed, total);
return failed > 0 ? EXIT_FAILURE : EXIT_SUCCESS;
}
static int clean_quit(void) {
int failures = (int)CU_get_number_of_tests_failed();
CU_cleanup_registry();
/* return CU_get_error(); */
/* return number of failures so runs launched by Makefile
* will stop when error is encountered
*/
return failures;
}
/*
* Main
*/
int
main(void)
{
CU_pSuite ptr_suite = NULL;
int nr_of_failed_tests = 0;
int nr_of_failed_suites = 0;
/* Initialize the CUnit test registry */
if (CUE_SUCCESS != CU_initialize_registry())
return CU_get_error();
/* add a suite to the registry */
ptr_suite = CU_add_suite("ofp port config", init_suite, clean_suite);
if (NULL == ptr_suite) {
CU_cleanup_registry();
return CU_get_error();
}
if (NULL == CU_ADD_TEST(ptr_suite,
test_sinlge_port_basic)) {
CU_cleanup_registry();
return CU_get_error();
}
if (NULL == CU_ADD_TEST(ptr_suite,
test_two_ports_vlan)) {
CU_cleanup_registry();
return CU_get_error();
}
if (NULL == CU_ADD_TEST(ptr_suite,
test_gre_port)) {
CU_cleanup_registry();
return CU_get_error();
}
#if OFP_TESTMODE_AUTO
CU_set_output_filename("CUnit-Port-conf");
CU_automated_run_tests();
#else
/* Run all tests using the CUnit Basic interface */
CU_basic_set_mode(CU_BRM_VERBOSE);
CU_basic_run_tests();
#endif
nr_of_failed_tests = CU_get_number_of_tests_failed();
nr_of_failed_suites = CU_get_number_of_suites_failed();
CU_cleanup_registry();
return (nr_of_failed_suites > 0 ?
nr_of_failed_suites : nr_of_failed_tests);
}
/* 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()
{
trn_init();
CU_pSuite Suite_grid = NULL;
CU_pSuite Suite_game = NULL;
CU_pSuite suitePiece = NULL;
CU_pSuite suiteFunctional = NULL;
/* initialize the CUnit test registry */
if (CUE_SUCCESS != CU_initialize_registry())
return CU_get_error();
/* Create TrnGrid test suite */
ADD_SUITE_TO_REGISTRY(Suite_grid);
ADD_TEST_TO_SUITE(Suite_grid, test_grid_new_destroy);
ADD_TEST_TO_SUITE(Suite_grid, test_grid_set_get_cell);
ADD_TEST_TO_SUITE(Suite_grid, test_piece_position_in_grid);
ADD_TEST_TO_SUITE(Suite_grid, test_grid_set_cells_with_piece);
ADD_TEST_TO_SUITE(Suite_grid, TestGridCellIsInGrid);
ADD_TEST_TO_SUITE(Suite_grid, TestGridCellIsInGridAndIsVoid);
ADD_TEST_TO_SUITE(Suite_grid, TestGridCanSetCellsWithPiece);
ADD_TEST_TO_SUITE(Suite_grid, test_grid_pop_row_and_make_above_fall);
ADD_TEST_TO_SUITE(Suite_grid, test_grid_find_last_complete_row_index);
ADD_TEST_TO_SUITE(Suite_grid, test_clear_row);
ADD_TEST_TO_SUITE(Suite_grid, test_set_grid_to_zero);
/* Create TrnGame test suite */
ADD_SUITE_TO_REGISTRY(Suite_game);
ADD_TEST_TO_SUITE(Suite_game, test_game_update_score);
ADD_TEST_TO_SUITE(Suite_game, test_complete_rows);
/* Create TrnPiece test suite */
ADD_SUITE_TO_REGISTRY(suitePiece );
ADD_TEST_TO_SUITE(suitePiece, test_piece_move_to_left);
ADD_TEST_TO_SUITE(suitePiece, test_piece_move_to_right);
ADD_TEST_TO_SUITE(suitePiece, test_piece_move_to_bottom);
ADD_TEST_TO_SUITE(suitePiece, test_piece_rotate_clockwise);
/* Create functional test suite */
ADD_SUITE_TO_REGISTRY(suiteFunctional);
ADD_TEST_TO_SUITE(suiteFunctional, stack_some_pieces);
/* Run all tests using the CUnit Basic interface */
CU_basic_set_mode(CU_BRM_VERBOSE);
CU_basic_run_tests();
int number_of_tests_failed = CU_get_number_of_tests_failed();
CU_cleanup_registry();
return number_of_tests_failed;
}
int main() {
unsigned int result;
CU_pSuite pSuite = NULL;
/* Initialize the CUnit test registry */
if (CUE_SUCCESS != CU_initialize_registry())
return CU_get_error();
/* Add a suite to the registry */
pSuite = CU_add_suite("SCPI Utils", init_suite, clean_suite);
if (NULL == pSuite) {
CU_cleanup_registry();
return CU_get_error();
}
/* Add the tests to the suite */
if (0
|| (NULL == CU_add_test(pSuite, "strnpbrk", test_strnpbrk))
|| (NULL == CU_add_test(pSuite, "Int32ToStr", test_Int32ToStr))
|| (NULL == CU_add_test(pSuite, "UInt32ToStrBase", test_UInt32ToStrBase))
|| (NULL == CU_add_test(pSuite, "Int64ToStr", test_Int64ToStr))
|| (NULL == CU_add_test(pSuite, "UInt64ToStrBase", test_UInt64ToStrBase))
|| (NULL == CU_add_test(pSuite, "SCPI_dtostre", test_scpi_dtostre))
|| (NULL == CU_add_test(pSuite, "floatToStr", test_floatToStr))
|| (NULL == CU_add_test(pSuite, "doubleToStr", test_doubleToStr))
|| (NULL == CU_add_test(pSuite, "strBaseToInt32", test_strBaseToInt32))
|| (NULL == CU_add_test(pSuite, "strBaseToUInt32", test_strBaseToUInt32))
|| (NULL == CU_add_test(pSuite, "strBaseToInt64", test_strBaseToInt64))
|| (NULL == CU_add_test(pSuite, "strBaseToUInt64", test_strBaseToUInt64))
|| (NULL == CU_add_test(pSuite, "strToDouble", test_strToDouble))
|| (NULL == CU_add_test(pSuite, "compareStr", test_compareStr))
|| (NULL == CU_add_test(pSuite, "compareStrAndNum", test_compareStrAndNum))
|| (NULL == CU_add_test(pSuite, "matchPattern", test_matchPattern))
|| (NULL == CU_add_test(pSuite, "matchCommand", test_matchCommand))
|| (NULL == CU_add_test(pSuite, "composeCompoundCommand", test_composeCompoundCommand))
|| (NULL == CU_add_test(pSuite, "swap", test_swap))
#if USE_DEVICE_DEPENDENT_ERROR_INFORMATION && !USE_MEMORY_ALLOCATION_FREE
|| (NULL == CU_add_test(pSuite, "heap", test_heap))
#endif
) {
CU_cleanup_registry();
return CU_get_error();
}
/* Run all tests using the CUnit Basic interface */
CU_basic_set_mode(CU_BRM_VERBOSE);
CU_basic_run_tests();
result = CU_get_number_of_tests_failed();
CU_cleanup_registry();
return result ? result : CU_get_error();
}
int main() {
// Initialise the CUnit test registry
CU_ErrorCode error;
if ((error = CU_initialize_registry()) != CUE_SUCCESS) {
fprintf(stderr, "failed to initialise test registry: %s\n", CU_get_error_msg());
return error;
}
// Create a test suite within the registry
CU_pSuite suite;
if ((suite = CU_add_suite("lognormal", test_init, test_cleanup)) == NULL) {
fprintf(stderr, "failed to create test suite: %s\n", CU_get_error_msg());
return error;
}
// Add the tests to the suite
if (CU_ADD_TEST(suite, test_params) == NULL) {
fprintf(stderr, "failed to add test: %s\n", CU_get_error_msg());
return error;
}
if (CU_ADD_TEST(suite, test_evaluation) == NULL) {
fprintf(stderr, "failed to add test: %s\n", CU_get_error_msg());
return error;
}
if (CU_ADD_TEST(suite, test_statistics) == NULL) {
fprintf(stderr, "failed to add test: %s\n", CU_get_error_msg());
return error;
}
// Run the test suites using the CUnit basic interface
if ((error = CU_basic_run_tests()) != CUE_SUCCESS) {
fprintf(stderr, "failed to run tests: %s\n", CU_get_error_msg());
return error;
}
// Display any failures (plus hack for newline afterwards)
CU_basic_show_failures(CU_get_failure_list());
if (CU_get_number_of_failure_records() > 0) printf("\n");
// Get the number of tests that failed
unsigned int failures = CU_get_number_of_tests_failed();
// Cleanup the test registry
CU_cleanup_registry();
// Return the number of test failures
return (int)failures;
}
int main() {
printf("Testing DAGDB\n");
CU_initialize_registry();
//CU_basic_set_mode(CU_BRM_SILENT);
CU_basic_set_mode(CU_BRM_NORMAL);
//CU_basic_set_mode(CU_BRM_VERBOSE);
CU_register_suites(error_suites);
CU_register_suites(bitarray_suites);
CU_register_suites(mem_suites);
CU_register_suites(base_suites);
CU_register_suites(api_suites);
CU_basic_run_tests();
int result = CU_get_number_of_tests_failed();
CU_cleanup_registry();
return result;
}
/*
* Set up and run tests.
*
* @return CUE_SUCCESS if successful, else a CUnit error code if
* any problems arise.
*/
int main()
{
int r;
r = 0;
if (CUE_SUCCESS != CU_initialize_registry())
{
return CU_get_error();
}
CU_pSuite suite =
CU_add_suite("Fibonacci Suite", initialise_suite, cleanup_suite);
if (NULL == suite)
{
CU_cleanup_registry();
return CU_get_error();
}
if ((NULL == CU_add_test(suite, "test_fibonacci_1", test_fibonacci_1)) ||
(NULL == CU_add_test(suite, "test_fibonacci_2", test_fibonacci_2)) ||
(NULL == CU_add_test(suite, "test_fibonacci_3", test_fibonacci_3)) ||
(NULL == CU_add_test(suite, "test_fibonacci_30", test_fibonacci_30)))
{
CU_cleanup_registry();
return CU_get_error();
}
// Run all tests using CUnit Basic interface which outputs
// results to command-line.
CU_basic_set_mode(CU_BRM_VERBOSE);
CU_basic_run_tests();
r = CU_get_number_of_tests_failed();
// Run all tests using CUnit Automated interface which outputs
// results to a file, default name CUnitAutomated-Results.xml.
// DTD CUnit-Run.dtd and and XSL stylesheet CUnit-Run.xsl in Share/
// Uncomment this line to override default output file prefix.
// CU_set_output_filename("Test");
//CU_list_tests_to_file();
// Output listing of tests in suites to a file, default name
// CUnitAutomated-Listing.xml
// DTD CUnit-List.dtd and and XSL stylesheet CUnit-List.xsl in Share/
//CU_automated_run_tests();
CU_cleanup_registry();
return r;
}
int main()
{
CU_pSuite pSuite = NULL;
unsigned int fails;
/* initialize the CUnit test registry */
if (CUE_SUCCESS != CU_initialize_registry())
return CU_get_error();
/* add a suite to the registry */
pSuite = CU_add_suite("dcap_url", init_suite, clean_suite);
if (NULL == pSuite) {
CU_cleanup_registry();
return CU_get_error();
}
/* add the tests to the suite */
if (
(NULL == CU_add_test(pSuite, "not a url", test_not_a_url))
||
(NULL == CU_add_test(pSuite, "well formated url", test_url))
||
(NULL == CU_add_test(pSuite, "well formated url with prefix", test_url_with_prefix))
||
(NULL == CU_add_test(pSuite, "url without port number", test_url_no_port))
||
(NULL == CU_add_test(pSuite, "url with ipv4", test_url_ipv4))
||
(NULL == CU_add_test(pSuite, "url with ipv4, no port number", test_url_ipv4_no_port))
||
(NULL == CU_add_test(pSuite, "url with ipv6", test_url_ipv6))
||
(NULL == CU_add_test(pSuite, "url with ipv6, no port", test_url_ipv6_no_port))
||
(NULL == CU_add_test(pSuite, "bad formated url", test_bad_formated))
) {
CU_cleanup_registry();
return CU_get_error();
}
/* Run all tests using the CUnit Basic interface */
CU_basic_set_mode(CU_BRM_VERBOSE);
CU_basic_run_tests();
fails = CU_get_number_of_tests_failed();
CU_cleanup_registry();
return fails;
}
/*
* The main function sets up the test suite, registers the test cases,
* runs through them, and hopefully doesn't explode.
*/
int
main(void)
{
CU_pSuite tsuite = NULL;
unsigned int fails;
if (!(CUE_SUCCESS == CU_initialize_registry())) {
errx(EX_CONFIG, "failed to initialise test registry");
return EXIT_FAILURE;
}
tsuite = CU_add_suite("strongbox_test", init_test, cleanup_test);
if (NULL == tsuite)
fireball();
if (NULL == CU_add_test(tsuite, "opening box", test_decrypt))
fireball();
if (NULL == CU_add_test(tsuite, "basic checks", test_identity))
fireball();
if (NULL == CU_add_test(tsuite, "test vector #1", test_vector1))
fireball();
if (NULL == CU_add_test(tsuite, "test vector #2", test_vector2))
fireball();
if (NULL == CU_add_test(tsuite, "test vector #3", test_vector3))
fireball();
if (NULL == CU_add_test(tsuite, "test vector #4", test_vector4))
fireball();
if (NULL == CU_add_test(tsuite, "test vector #5", test_vector5))
fireball();
if (NULL == CU_add_test(tsuite, "test vector #6", test_vector6))
fireball();
if (NULL == CU_add_test(tsuite, "test vector #7", test_vector7))
fireball();
if (NULL == CU_add_test(tsuite, "test vector #8", test_vector8))
fireball();
if (NULL == CU_add_test(tsuite, "test vector #9", test_vector9))
fireball();
CU_basic_set_mode(CU_BRM_VERBOSE);
CU_basic_run_tests();
fails = CU_get_number_of_tests_failed();
warnx("%u tests failed", fails);
CU_cleanup_registry();
return fails;
}
int main(int argc, char **argv) {
CU_pSuite suite;
int ret, failed_num;
pid_t pid;
signal(SIGPIPE, SIG_IGN);
// preprocessing of tests
test_init();
pid = start_newtd();
if(pid > 0) {
CU_initialize_registry();
ADD_TESTS(test_optparse);
ADD_TESTS(test_config);
ADD_TESTS(test_signal);
ADD_TESTS(test_daemon);
ADD_TESTS(test_frame);
ADD_TESTS(test_stomp);
ADD_TESTS(test_queue);
ADD_TESTS(test_transaction);
ADD_TESTS(test_persistent);
ADD_TESTS(test_proto_connect);
ADD_TESTS(test_proto_disconnect);
ADD_TESTS(test_proto_subscribe);
ADD_TESTS(test_proto_reply_to);
ADD_TESTS(test_proto_topic);
ADD_TESTS(test_proto_begin);
ADD_TESTS(test_proto_error);
ADD_TESTS(test_newtctl_worker);
CU_basic_run_tests();
failed_num = CU_get_number_of_tests_failed();
CU_cleanup_registry();
kill(pid, SIGINT);
wait(NULL);
}
return failed_num;
}
int main(int argc, char** argv)
{
CU_initialize_registry();
CU_pSuite suite_memory = CU_add_suite("Memory", NULL, NULL);
CU_ADD_TEST(suite_memory, test_phalcon_alloc_zval);
CU_ADD_TEST(suite_memory, test_phalcon_init_var);
CU_ADD_TEST(suite_memory, test_phalcon_init_nvar);
CU_ADD_TEST(suite_memory, test_phalcon_init_nvar_pnull);
CU_ADD_TEST(suite_memory, test_phalcon_cpy_wrt);
CU_ADD_TEST(suite_memory, test_phalcon_cpy_wrt_ctor);
CU_ADD_TEST(suite_memory, test_phalcon_obs_var);
CU_ADD_TEST(suite_memory, test_phalcon_obs_nvar);
CU_ADD_TEST(suite_memory, test_phalcon_separate);
CU_ADD_TEST(suite_memory, test_phalcon_separate_param);
CU_pSuite suite_assert = CU_add_suite("Assert", setup_assert, teardown_assert);
CU_ADD_TEST(suite_assert, test_phalcon_assert_class);
CU_pSuite suite_array = CU_add_suite("Array", NULL, NULL);
CU_ADD_TEST(suite_array, test_phalcon_array_unshift);
CU_ADD_TEST(suite_array, test_phalcon_array_values);
CU_ADD_TEST(suite_array, test_phalcon_array_key_exists);
CU_pSuite suite_variables = CU_add_suite("Variables", NULL, NULL);
CU_ADD_TEST(suite_variables, test_phalcon_serialize);
CU_ADD_TEST(suite_variables, test_phalcon_unserialize);
CU_pSuite suite_testbed = CU_add_suite("Testbed", NULL, NULL);
CU_ADD_TEST(suite_testbed, test_increment);
CU_ADD_TEST(suite_testbed, test_phalcon_mvc_router_route__construct);
CU_ADD_TEST(suite_testbed, test_array_mess);
CU_ADD_TEST(suite_testbed, test_exceptions);
CU_ADD_TEST(suite_testbed, test_unclean_shutdown);
initialize_embed_wrapper();
CU_basic_set_mode(CU_BRM_VERBOSE);
CU_basic_run_tests();
CU_cleanup_registry();
return CU_get_number_of_tests_failed() ? EXIT_FAILURE : EXIT_SUCCESS;
}
/** Handler function called at completion of each test.
* @param pTest The test being run.
* @param pSuite The suite containing the test.
* @param pFailure Pointer to the 1st failure record for this test.
*/
static void curses_test_complete_message_handler(const CU_pTest pTest,
const CU_pSuite pSuite,
const CU_pFailureRecord pFailure)
{
/* Not used in curses implementation - quiet compiler warning */
CU_UNREFERENCED_PARAMETER(pTest);
CU_UNREFERENCED_PARAMETER(pSuite);
CU_UNREFERENCED_PARAMETER(pFailure);
f_uiTestsRun++;
if (CU_get_number_of_tests_failed() != f_uiTestsFailed) {
f_uiTestsFailed++;
}
else {
f_uiTestsRunSuccessful++;
}
refresh_summary_window();
refresh_progress_window();
}
int main(void)
{
CU_pSuite ptr_suite = NULL;
int nr_of_failed_tests = 0;
int nr_of_failed_suites = 0;
/* Initialize the CUnit test registry */
if (CUE_SUCCESS != CU_initialize_registry())
return CU_get_error();
/* add a suite to the registry */
ptr_suite = CU_add_suite("ofp errno", init_suite, NULL);
if (NULL == ptr_suite) {
CU_cleanup_registry();
return CU_get_error();
}
if (NULL == CU_ADD_TEST(ptr_suite, test_strerrno)) {
CU_cleanup_registry();
return CU_get_error();
}
if (NULL == CU_ADD_TEST(ptr_suite, test_tls_errno)) {
CU_cleanup_registry();
return CU_get_error();
}
#if defined(OFP_TESTMODE_AUTO)
CU_set_output_filename("CUnit-Util");
CU_automated_run_tests();
#else
/* Run all tests using the CUnit Basic interface */
CU_basic_set_mode(CU_BRM_VERBOSE);
CU_basic_run_tests();
#endif
nr_of_failed_tests = CU_get_number_of_tests_failed();
nr_of_failed_suites = CU_get_number_of_suites_failed();
CU_cleanup_registry();
return (nr_of_failed_suites > 0 ?
nr_of_failed_suites : nr_of_failed_tests);
}
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]);
}
if (suite_name){
CU_pSuite suite;
CU_basic_set_mode(CU_BRM_VERBOSE);
suite=CU_get_suite_by_name(suite_name, CU_get_registry());
if (test_name) {
CU_pTest test=CU_get_test_by_name(test_name, suite);
CU_ErrorCode err= CU_basic_run_test(suite, test);
if (err != CUE_SUCCESS) ms_error("CU_basic_run_test error %d", err);
} else
CU_basic_run_suite(suite);
} else
{
#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_basic_set_mode(CU_BRM_VERBOSE);
CU_basic_run_tests();
}
}
ret=CU_get_number_of_tests_failed()!=0;
CU_cleanup_registry();
return ret;
}
void cleanup()
{
char cmd[MAXBUF];
ops_crypto_finish();
if (CU_get_number_of_tests_failed())
{
fprintf(stderr, "Test directory %s retained, "
"because one or more tests failed.\n", dir);
}
else
{
/* Remove test dir and files */
snprintf(cmd, sizeof cmd, "rm -rf %s", dir);
if (run(cmd))
{
perror("Can't delete test directory ");
return;
}
}
}
int main(
const int argc,
const char* const* argv)
{
int exitCode = 1;
if (CUE_SUCCESS == CU_initialize_registry()) {
CU_Suite* testSuite = CU_add_suite(__FILE__, setup, teardown);
if (NULL != testSuite) {
if (CU_ADD_TEST(testSuite, test_cond_wait)) {
CU_basic_set_mode(CU_BRM_VERBOSE);
(void)CU_basic_run_tests();
}
}
exitCode = CU_get_number_of_suites_failed() +
CU_get_number_of_tests_failed();
CU_cleanup_registry();
}
return exitCode;
}
int
main(void)
{
CU_pSuite card_suite = NULL;
unsigned int fails = 0;
printf("starting tests for card...\n");
if (! CUE_SUCCESS == CU_initialize_registry()) {
fprintf(stderr, "error initialising CUnit test registry!\n");
return EXIT_FAILURE;
}
/* set up the suite */
card_suite = CU_add_suite("card_tests", initialise_card_test,
cleanup_card_test);
if (NULL == card_suite)
destroy_test_registry();
/* add tests */
if (NULL == CU_add_test(card_suite, "test of card_read", test_card_read))
destroy_test_registry();
if (NULL == CU_add_test(card_suite, "test of card_str", test_card_str))
destroy_test_registry();
CU_basic_set_mode(CU_BRM_VERBOSE);
CU_basic_run_tests();
fails = CU_get_number_of_tests_failed();
CU_cleanup_registry();
/* should never get here! */
return fails;
}
