Esempio n. 1
0
int main(void)
{
  // data structures
  int linked_list_failed = run_test_suite(create_linked_list_test_suite());
  int chained_hash_table_failed = run_test_suite(create_chained_hash_table_test_suite());
  int stack_failed = run_test_suite(create_stack_test_suite());
  int queue_failed = run_test_suite(create_queue_test_suite());
  int circular_buffer_failed = run_test_suite(create_circular_buffer_test_suite());
  int doubly_linked_list_failed = run_test_suite(create_doubly_linked_list_test_suite());

  // algorithms
  int sort_failed = run_test_suite(create_sort_test_suite());

  // helpers
  int bit_helper_failed = run_test_suite(create_bit_helper_test_suite());

  int failed = 
    linked_list_failed + 
    chained_hash_table_failed + 
    circular_buffer_failed + 
    stack_failed +
    queue_failed +
    doubly_linked_list_failed +
    sort_failed +
    bit_helper_failed;

  return failed == 0 ? 0 : 1;
}
Esempio n. 2
0
int main(int argc, char **argv) {
  char optchar;
  opterr = 0;
  while ((optchar = getopt(argc, argv, "t:rf")) != -1) {
    switch (optchar) {
      case 't':
        run_test_suite(atoi(optarg));
        return EXIT_SUCCESS;
        break;
      case 'r':
        printf("---- RESULTS ----\n");
        printf("Elapsed execution time: %.6fs\n", longrunning_rotation());
        printf("---- END RESULTS ----\n");

        return EXIT_SUCCESS;
        break;
      case 'f':
        printf("---- RESULTS ----\n");
        printf("Elapsed execution time: %.6fs\n", longrunning_flipcount());
        printf("---- END RESULTS ----\n");

        return EXIT_SUCCESS;
        break;
    }
  }
  print_usage(argv[0]);
}
Esempio n. 3
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]);
	}

	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() {
    int err;
    TestSuite *suite = create_test_suite();

    add_test_with_context(suite, eclGetContextInteractively, runs);
    add_test_with_context(suite, eclGetContextInteractively,
                          returnsAContextIfNoErrorOccured);
    add_test_with_context(suite, eclGetContextInteractively,
                          returnsAValidContext);
    add_test_with_context(suite, eclGetContextInteractively,
                          returnsADeviceIfNoErrorOccured);
    add_test_with_context(suite, eclGetContextInteractively,
                          returnsAValidDevice);
    add_test_with_context(suite, eclGetContextInteractively,
                          returnsACommandQueueIfNoErrorOccured);
    add_test_with_context(suite, eclGetContextInteractively,
                          returnsAValidCommandQueue);
    add_test_with_context(suite, eclGetContextInteractively,
                          commandQueueConsistentWithContext);
    add_test_with_context(suite, eclGetContextInteractively,
                          commandQueueConsistentWithDevice);
    add_test_with_context(suite, eclGetContextInteractively,
                          doesntCrashDueToBogusPlatformChoice);
    add_test_with_context(suite, eclGetContextInteractively,
                          recoversFromBogusPlatformChoice);
    add_test_with_context(suite, eclGetContextInteractively,
                          doesntCrashDueToBogusDeviceChoice);
    add_test_with_context(suite, eclGetContextInteractively,
                          recoversFromBogusDeviceChoice);

    err = run_test_suite(suite, create_text_reporter());
    destroy_test_suite(suite);
    return err;
}
int main(int argc, char **argv) {
    TestSuite *suite = stream_tests();
    if (argc > 1) {
        return run_single_test(suite, argv[1], create_text_reporter());
    }
    return run_test_suite(suite, create_text_reporter());
}
Esempio n. 6
0
int __cdecl
#else
int
#endif
main(int __UNUSED(argc), const char ** __UNUSED(argv[])) {
  // squelch warnings
  __UNUSED_ARG(argc);
  __UNUSED_ARG(argv);

  return run_test_suite(suite_methods, ARRAY_SIZE(suite_methods));
}
int main(int argc, char **argv) {
	TestSuite *suite = create_test_suite();

	add_suite(suite, density_contrast_tests());
	add_suite(suite, cic_tests());

	if (argc > 1) {
		return run_single_test(suite, argv[1], create_text_reporter());
	}

	return run_test_suite(suite, create_text_reporter());
}
Esempio n. 8
0
/*
 * Main test case entry
 */
int main(int argc, char** argv) {

    TestSuite *suite = create_test_suite();

    add_suite(suite, atmi_test_all());


    if (argc > 1) {
        return run_single_test(suite,argv[1],create_text_reporter());
    }

    return run_test_suite(suite, create_text_reporter());
}
Esempio n. 9
0
int main(int argc, char **argv) {
    TestSuite *suite = create_test_suite();
    add_test(suite, reading_lines_from_empty_stream_gives_null);
    add_test(suite, one_character_stream_gives_one_character_line);
    add_test(suite, one_word_stream_gives_one_word_line);
    add_test(suite, drops_line_ending_from_word_and_stops);
    add_test(suite, single_line_ending_gives_empty_line);
    add_test(suite, one_character_is_made_into_a_one_letter_paragraph);
    add_test(suite, no_line_endings_makes_one_paragraph);
    add_test(suite, line_endings_generate_separate_paragraphs);
    add_test(suite, resources_are_paired_with_the_functions);
    add_test(suite, empty_paragraphs_are_ignored);
    if (argc > 1) {
        return run_single_test(suite, argv[1], create_text_reporter());
    }
    return run_test_suite(suite, create_text_reporter());
}
Esempio n. 10
0
int main(int argc, char **argv)
{
  PetscInitialize(&argc, &argv, NULL, help);
  TestSuite *suite = create_test_suite();
  add_test(suite, first_derivative_of_constant_is_zero);
  add_test(suite, first_derivative_fourth_order_of_constant_is_zero);
  add_test(suite, first_derivative_of_linear_function_is_computed_exactly);
  add_test(suite, first_derivative_fourth_order_of_linear_function_is_computed_exactly);
  add_test(suite, second_derivative_of_constant_is_zero);
  add_test(suite, second_derivative_fourth_order_of_constant_is_zero);
  add_test(suite, second_derivative_of_linear_function_is_zero);
  add_test(suite, second_derivative_fourth_order_of_linear_function_is_zero);
  int result = run_test_suite(suite, create_text_reporter());
  destroy_test_suite(suite);
  PetscFinalize();
  return result;
}
Esempio n. 11
0
int mediastreamer2_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 < mediastreamer2_tester_nb_test_suites(); i++) {
		run_test_suite(test_suite[i]);
	}

#if HAVE_CU_GET_SUITE
	if (suite_name){
		CU_pSuite suite;
		CU_basic_set_mode(CU_BRM_VERBOSE);
		suite=CU_get_suite(suite_name);
		if (test_name) {
			CU_pTest test=CU_get_test_by_name(test_name, suite);
			CU_basic_run_test(suite, test);
		} else
			CU_basic_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_basic_set_mode(CU_BRM_VERBOSE);
			CU_basic_run_tests();
		}
	}

	CU_cleanup_registry();
	return CU_get_error();
}
Esempio n. 12
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]);
	}

	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;
}
Esempio n. 13
0
/*----------------------------------------------------------------------*/
static int run_tests(TestReporter *reporter, const char *suite_name, const char *symbolic_name,
                     void *test_library_handle, TestItem test_items[], bool verbose) {
    int status;
    ContextSuite *context_suites = NULL;
    TestSuite *suite = create_named_test_suite(suite_name);

    const int number_of_matches = add_matching_tests_to_suite(test_library_handle, symbolic_name,
                                                              test_items, suite, &context_suites);

    if (error_when_matching(number_of_matches))
        return EXIT_FAILURE;

    if (symbolic_name != NULL && number_of_matches == 1) {
        bool found = matching_test_exists(symbolic_name, test_items);
        if (verbose)
            printf(" to only run one test: '%s' ...\n", symbolic_name);
        if (!found) {
            fprintf(stderr, "ERROR: No such test: '%s' in '%s'\n", symbolic_name, suite_name);
            return EXIT_FAILURE;
        }
        status = run_single_test(suite, test_name_of(symbolic_name), reporter);
    } else {
        if (verbose) {
            if (number_of_matches != count(test_items))
                printf(" to run %d matching tests ...\n", number_of_matches);
            else
                printf(" to run all %d discovered tests ...\n", count(test_items));
        }
        if (number_of_matches > 0)
            status = run_test_suite(suite, reporter);
        else {
            fprintf(stderr, "ERROR: No such test: '%s' in '%s'\n", symbolic_name, suite_name);
            status = EXIT_FAILURE;
        }
    }

    destroy_test_suite(suite);
    destroy_context_suites(context_suites);
    return(status);
}
Esempio n. 14
0
int main(int argc, char **argv)
{
    PetscInitialize(&argc, &argv, NULL, help);
    TestSuite *suite = create_test_suite();
    add_test_with_context(suite, FFT, can_be_constructed_from_DMDA);
    add_test_with_context(suite, FFT, registers_the_right_DM);
    add_test_with_context(suite, FFT, creates_output_vector_of_correct_size);
    add_test_with_context(suite, FFT, transforms_constant_into_delta_function);
    add_test_with_context(suite, FFT, can_transform_second_component);
    add_test_with_context(suite, FFT, i_transform_is_inverse_of_transform);
    add_test_with_context(suite, FFT, PSD_of_delta_function_is_flat);
    add_test_with_context(suite, FFT, yields_PSD_of_the_correct_size);
    int result;
    if (argc > 2) {
        result = run_single_test(suite, argv[1], create_text_reporter());
    } else {
        result = run_test_suite(suite, create_text_reporter());
    }
    destroy_test_suite(suite);
    PetscFinalize();
    return result;
}
int main(int argc, char **argv)
{
  PetscInitialize(&argc, &argv, NULL, help);
  TestSuite *suite = create_test_suite();
  add_test_with_context(suite, FourthOrderJacobian, can_be_built);
  add_test_with_context(suite, FourthOrderJacobian, is_consistent_for_constant_fields);
  add_test_with_context(suite, FourthOrderJacobian, is_consistent_for_sine_waves);
  add_test_with_context(suite, FourthOrderJacobian, is_consistent_for_gaussian);
  add_test_with_context(suite, FourthOrderJacobian, is_consistent_for_constant_right_moving);
  add_test_with_context(suite, FourthOrderJacobian, is_consistent_for_sine_wave_right_moving);
  add_test_with_context(suite, FourthOrderJacobian, is_consistent_for_gaussian_right_moving);
  /* Disable this test for now, need the right Chi3 physics
  add_test(suite, prec_consistent_sine_wave_non_zero_gamma);
  */
  int result;
  if (argc > 2) {
    result = run_single_test(suite, argv[1], create_text_reporter());
  } else {
    result = run_test_suite(suite, create_text_reporter());
  }
  destroy_test_suite(suite);
  PetscFinalize();
  return result;
}
Esempio n. 16
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;
}
Esempio n. 17
0
int main (int argc, char *argv[]) {

	run_test_suite();
	printf("Finished\n");
	return 0;
}
Esempio n. 18
0
int main(int argc, char **argv) {
    TestSuite *suite = create_config_suite();
    return run_test_suite(suite, create_text_reporter());
}
Esempio n. 19
0
static int run_all_test_suites(/*@notnull@*/ test_runner * runner)
/*@globals
	fileSystem,
	internalState
@*/
/*@modifies
	fileSystem,
	internalState,

	runner,
	runner->buffer,
	runner->suite_number,
	runner->suites->suite,
	runner->stats
@*/
{

	const char * summary1;
	const char * summary2;

	printf("Running all the tests...\n\n");

	for(runner->suite_number = 0; runner->suite_number < runner->suites->count; runner->suite_number++){

		/*@-boundsread@*/
		test_suite * suite = runner->suites->suite[runner->suite_number];
		/*@=boundsread@*/

		run_test_suite(runner, suite);

		if(!suite->is_requirement){

			switch(suite->status){

				case STATUS_PASSED:
					runner->stats.suites.passed++;
					/*@switchbreak@*/ break;

				case STATUS_WARNING:
					runner->stats.suites.warnings++;
					/*@switchbreak@*/ break;

				default: /* STATUS_FAILED */
					runner->stats.suites.failed++;
			}

			runner->stats.tests.passed		+= suite->stats.passed;
			runner->stats.tests.warnings	+= suite->stats.warnings;
			runner->stats.tests.failed		+= suite->stats.failed;
		}
	}

	calculate_total(&runner->stats.requirements);
	calculate_total(&runner->stats.tests);
	calculate_total(&runner->stats.suites);

	/* delete temporary files */
	(void)remove(runner->out);
	(void)remove(runner->err);

	if(runner->report != NULL){

		printf("\n\nGenerating report...\n");

		generate_report(runner);

		printf("\tTest report created.\n");

		open_report(runner);
	}

	if(runner->stats.suites.failed > 0){
		summary1 = "Some of the tests failed.";
	}else if(runner->stats.suites.warnings > 0){
		summary1 = "Some *non-critical* test didn't pass.";
	}else{
		summary1 = "All tests passed successfully.";
	}

	if(runner->stats.suites.failed == 0 && runner->stats.suites.warnings == 0){
		summary2 = "";
	}else if(runner->stats.requirements.total == 0){
		summary2 = "\n\tPlease verify platform requirements.";
	}else if(runner->stats.requirements.failed > 0 || runner->stats.requirements.warnings > 0){
		summary2 = "\n\tIt could be related to some error on **platform requirements**.";
	}else{
		summary2 = "\n\tPlease report it at: http://code.google.com/p/exceptions4c/";
	}

	printf("\n%s%s\n\n", summary1, summary2);

	return(EXIT_SUCCESS);
}
Esempio n. 20
0
int main(int argc, char **argv) {
    return run_test_suite(our_tests(), create_text_reporter());
}
Esempio n. 21
0
File: main.c Progetto: ketsler/OS
/* main */
int main(int argc, char *argv[]) {

    printf("TESTING STARTING");
    return run_test_suite();
}
Esempio n. 22
0
int main(int argc, char **argv) {
    TestSuite *suite = create_test_suite();
    add_test_with_context(suite, CrashExample, seg_faults_for_null_dereference);
    add_test_with_context(suite, CrashExample, will_loop_forever);
    return run_test_suite(suite, create_text_reporter());
}
Esempio n. 23
0
int test_ptrs_cli(int argc, char **argv)
{
  return run_test_suite(ptrs_test);
}
int test_type_base_memory_manager_cli(int argc, char **argv)
{
  return run_test_suite(type_base_memory_manager_test);
}
Esempio n. 25
0
/* main */
int main(int argc, char *argv[]) {

    return run_test_suite();
}
Esempio n. 26
0
int test_type_base_type_cli(int argc, char **argv)
{
    return run_test_suite(type_base_type_test);
}
Esempio n. 27
0
int test_bnf_cli(int argc, char **argv)
{
  return run_test_suite(bnf_test);
}
Esempio n. 28
0
int test_unicode_cli(int argc, char **argv)
{
  return run_test_suite(unicode_test);
}
Esempio n. 29
0
int		run()
{
	return (run_test_suite(&g_main_test_suite));
}
Esempio n. 30
0
int test_ansi_c_ast_base_cli(int argc, char **argv)
{
  return run_test_suite(ansi_c_ast_base_test);
}