Beispiel #1
0
void RunAllTests(void)
{
    CuString *output = CuStringNew();
    CuSuite* suite = CuSuiteNew();


    SUITE_ADD_TEST(suite, TestInitLL);
    SUITE_ADD_TEST(suite, TestLengthLL);
    SUITE_ADD_TEST(suite, TestInsertLLIncreasesLength);
    SUITE_ADD_TEST(suite, TestInsertLLInserts);
    SUITE_ADD_TEST(suite, TestCountLL);
    SUITE_ADD_TEST(suite, TestIndexLL);
    SUITE_ADD_TEST(suite, TestRemoveLL);
    SUITE_ADD_TEST(suite, TestExtendLL);
    SUITE_ADD_TEST(suite, TestLookup);
    SUITE_ADD_TEST(suite, TestLookup2);
    SUITE_ADD_TEST(suite, TestLookup3);

    CuSuiteRun(suite);
    CuSuiteSummary(suite, output);
    CuSuiteDetails(suite, output);
    printf("%s\n", output->buffer);
    CuStringDelete(output);
    CuSuiteDelete(suite);
}
void RunAllTests(void) 
{
    CuString *output = CuStringNew();
    CuSuite* suite = CuSuiteNew();


    SUITE_ADD_TEST(suite, Test_find_decoded_line_length_b4_should_be_four);
    SUITE_ADD_TEST(suite, Test_find_decoded_line_length_b1000_should_be_one_thousand);
    SUITE_ADD_TEST(suite, Test_find_decoded_line_length_b502_should_be_502);
    SUITE_ADD_TEST(suite, Test_string_of_encode);
    SUITE_ADD_TEST(suite, Test_string_of_encode_with_all_the_same_character);
    SUITE_ADD_TEST(suite, Test_string_of_encode_with_a_large_number_of_characters);
    SUITE_ADD_TEST(suite, Test_string_of_encode_with_single_occurrence_characters);
    SUITE_ADD_TEST(suite, Test_same_character_string_of_decode);
    SUITE_ADD_TEST(suite, Test_multicharacter_string_of_decode);
    SUITE_ADD_TEST(suite, Test_140character_string_of_decode);
    SUITE_ADD_TEST(suite, Test_1character_occurrences_string_of_decode);

    CuSuiteRun(suite);
    CuSuiteSummary(suite, output);
    CuSuiteDetails(suite, output);
    printf("%s\n", output->buffer);
    CuStringDelete(output);
    CuSuiteDelete(suite);
}
Beispiel #3
0
int main() {
    CuSuite *suites[] = {
        strtrim_get_cusuite(),
        strrpl_get_cusuite(),
        iv_parse_config_get_cusuite(),
        iv_parse_index_get_cusuite(),
        iv_parse_series_get_cusuite(),
        iv_parse_auth_get_cusuite(),
        iv_parse_categories_get_cusuite(),
    };
    CuString *output = CuStringNew();
    CuSuite *suite = CuSuiteNew();
    unsigned int i;
    for(i=0; i<SUITE_COUNT(suites); i++) {
        if(suites[i]) { CuSuiteAddSuite(suite, suites[i]); }
        /* Hack for CuTest odditiy - CuSuiteAddSuite() implementation copies
         * tests attached to suites[i] into suite and doesn't internally free
         * suites[i]. Documentation doesn't mention anything about this. */
        free(suites[i]);
    }
    CuSuiteRun(suite);
    CuSuiteSummary(suite, output);
    CuSuiteDetails(suite, output);
    printf("%s\n", output->buffer);
    CuSuiteDelete(suite);
    CuStringDelete(output);
    return 0;
}
Beispiel #4
0
int
main (void)
{
    CuString *output = CuStringNew ();
    CuSuite* suite = CuSuiteNew ();
    int ret;

    _p11_mutex_init (&race_mutex);
    mock_module_init ();
    _p11_library_init ();

#ifdef OS_UNIX
    SUITE_ADD_TEST (suite, test_fork_initialization);
#endif

    SUITE_ADD_TEST (suite, test_recursive_initialization);
    SUITE_ADD_TEST (suite, test_threaded_initialization);

    CuSuiteRun (suite);
    CuSuiteSummary (suite, output);
    CuSuiteDetails (suite, output);
    printf ("%s\n", output->buffer);
    ret = suite->failCount;
    CuSuiteDelete (suite);
    CuStringDelete (output);

    return ret;
}
Beispiel #5
0
void RunAllTests(void)
{
    LOGD("RunAllTests() Entered!\n");
	CuString *output = CuStringNew();//Êä³ö½á¹¹Ìå
	CuSuite* suite = CuSuiteNew();//²âÊÔ×é¾ä±ú
	CuSuite* suite_test = NULL;//²âÊÔ×é¾ä±ú

	//Ôö¼ÓµÄ²âÊÔ×é
	printf("Step1\n");
	suite_test = CuGetSuite();
	CuSuiteRobSuite(suite, suite_test);
	CuSuiteDelete(suite_test);
	printf("Step2\n");
	suite_test = CuStringGetSuite();
	CuSuiteRobSuite(suite, suite_test);
	CuSuiteDelete(suite_test);
	printf("Step3\n");
	CuSuiteRun(suite);
	printf("Step4\n");
	CuSuiteSummary(suite, output);
	printf("Step5\n");
	CuSuiteDetails(suite, output);
	printf("%s\n", output->buffer);
	
	CuSuiteDelete(suite);
	CuStringDelete(output);
}
Beispiel #6
0
void RunTests(CuSuite * suite, const char *name) {
    CuString *output = CuStringNew();

    CuSuiteRun(suite);
    CuSuiteDetails(suite, output);
    if (suite->failCount) CuSuiteSummary(suite, output);
    printf("%s: %s", name, output->buffer);
    CuStringDelete(output);
}
Beispiel #7
0
void runAllTests_dbparseexpr(void)
{
	CuString *output = CuStringNew();
	CuSuite *suite = DBParseExprGetSuite();
	
	CuSuiteRun(suite);
	CuSuiteSummary(suite, output);
	CuSuiteDetails(suite, output);
	printf("%s\n", output->buffer);
	
	CuSuiteDelete(suite);
	CuStringDelete(output);
}
Beispiel #8
0
void runAllTests_sort()
{
	CuString *output = CuStringNew();
	CuSuite* suite = DBSortGetSuite();
	
	CuSuiteRun(suite);
	CuSuiteSummary(suite, output);
	CuSuiteDetails(suite, output);
	printf("%s\n", output->buffer);
	
	CuSuiteDelete(suite);
	CuStringDelete(output);
}
Beispiel #9
0
void runTests()
{
    srand(0);
    CuSuite* suite = CuSuiteNew();
    CuString* output = CuStringNew();
    addTests(suite);
    CuSuiteRun(suite);
    CuSuiteSummary(suite, output);
    CuSuiteDetails(suite, output);
    printf("%s\n", output->buffer);
    CuSuiteDelete(suite);
    CuStringDelete(output);
}
void RunAllTests(void) {
    CuString *output = CuStringNew();
    CuSuite *suite = CuGetSuite();

    //Run the tests!
    CuSuiteRun(suite);
    CuSuiteSummary(suite, output);
    CuSuiteDetails(suite, output);
    printf("%s\n", output->buffer);
    
    //Clean up.
    CuStringDelete(output);
    CuSuiteDelete(suite);
}
Beispiel #11
0
void runAllTests(void)
{
	CuString *output = CuStringNew();
	CuSuite* suite = CuSuiteNew();
	
	/* Create suites from other tests. */
	//CuSuite *agg_suite = DBAggregateGetSuite();
	CuSuite *dbqmm_suite = DBQueryMMGetSuite();
	CuSuite *lex_suite = LexerGetSuite();
	CuSuite *dbparseexpr_suite = DBParseExprGetSuite();
	CuSuite *eet_suite = DBEETGetSuite();
	CuSuite *ntjoin_suite = DBNTJoinGetSuite();
	CuSuite *osijoin_suite = DBOSIJoinGetSuite();
	CuSuite *project_suite = DBProjectGetSuite();
	CuSuite *scan_suite = DBScanGetSuite();
	CuSuite *select_suite = DBSelectGetSuite();
	CuSuite *sort_suite = DBSortGetSuite();
	
	//CuSuiteAddSuite(suite, agg_suite);
	CuSuiteAddSuite(suite, dbqmm_suite);
	CuSuiteAddSuite(suite, lex_suite);
	CuSuiteAddSuite(suite, dbparseexpr_suite);
	CuSuiteAddSuite(suite, eet_suite);
	CuSuiteAddSuite(suite, ntjoin_suite);
	CuSuiteAddSuite(suite, osijoin_suite);
	CuSuiteAddSuite(suite, project_suite);
	CuSuiteAddSuite(suite, scan_suite);
	CuSuiteAddSuite(suite, select_suite);
	CuSuiteAddSuite(suite, sort_suite);
	
	CuSuiteRun(suite);
	CuSuiteSummary(suite, output);
	CuSuiteDetails(suite, output);
	printf("%s\n", output->buffer);
	
	//CuSuiteDelete(agg_suite);
	CuSuiteDelete(dbqmm_suite);
	CuSuiteDelete(lex_suite);
	CuSuiteDelete(dbparseexpr_suite);
	CuSuiteDelete(eet_suite);
	CuSuiteDelete(ntjoin_suite);
	CuSuiteDelete(osijoin_suite);
	CuSuiteDelete(project_suite);
	CuSuiteDelete(scan_suite);
	CuSuiteDelete(select_suite);
	CuSuiteDelete(sort_suite);
	free(suite);
	CuStringDelete(output);
}
Beispiel #12
0
int RunAllSuites(void)
{
	int failCount, i;
	CuString *output;
	failCount = 0;
	for(i = 0; strlen(g_suites[i].name) != 0; i++) {
		printf("Running suite %s\n", g_suites[i].name);
		output = CuStringNew();
		failCount += g_suites[i].fn(output);
		printf("%s\n", output->buffer);
		CuStringDelete(output);
		printf("Finished suite %s\n", g_suites[i].name);
	}
	return (failCount);
}
Beispiel #13
0
void run_all_tests(void){
	
	CuString *output = CuStringNew();
	CuSuite *suite = CuSuiteNew();

	CuSuiteAddSuite(suite, TestHashLib());
        
	CuSuiteRun(suite);
	CuSuiteSummary(suite, output);
	CuSuiteDetails(suite, output);
	printf("%s\n", output->buffer);

	CuStringDelete(output);
	CuSuiteDelete(suite);
}
Beispiel #14
0
int RunSuite(const char * suite)
{
	int failCount, i;
	CuString *output;
	failCount = 0;
	for(i = 0; strlen(g_suites[i].name) != 0; i++)
		if (strcmp(g_suites[i].name, suite) == 0) {
			output = CuStringNew();
			failCount = g_suites[i].fn(output);
			printf("%s\n", output->buffer);
			CuStringDelete(output);
			break;
		}
	
	return (failCount);
}
Beispiel #15
0
void RunAllTests()
{
    platform_semaphore_init(&sub_sem);

	CuString *output = CuStringNew();
    CuSuite* suite = CuGetSuite();

	CuSuiteRun(suite);
	CuSuiteSummary(suite, output);
	CuSuiteDetails(suite, output);
    platform_printf("%s\n", output->buffer);
    CuStringDelete(output);
    CuSuiteDelete(suite);

    platform_semaphore_deinit(&sub_sem);
}
void RunAllTests(void) {

    printf("Running Test Suite: lib_clinalg\n");

    CuString * output = CuStringNew();
    CuSuite * suite = CuSuiteNew();

    CuSuite * clin = CLinalgSuite();
    CuSuiteAddSuite(suite, clin);
    CuSuiteRun(suite);
    CuSuiteSummary(suite, output);
    CuSuiteDetails(suite, output);
    printf("%s \n", output->buffer);

    CuSuiteDelete(clin);
    CuStringDelete(output);
    free(suite);
}
Beispiel #17
0
int main(void)
{
    int result;
    CuString *output = CuStringNew();
    CuSuite *suite = CuSuiteNew();


    add_suite_quicklist(suite);

    CuSuiteRun(suite);
    CuSuiteSummary(suite, output);
    CuSuiteDetails(suite, output);
    result = suite->failCount;
    printf("%s\n", output->buffer);
    CuSuiteDelete(suite);
    CuStringDelete(output);
    return result;
}
void RunAllTests(void) {
    
    printf("Running Test Suite: lib_stringmanip\n");

    CuString * output = CuStringNew();
    CuSuite * suite = CuSuiteNew();
    
    CuSuite * st = StringUtilGetSuite();
    CuSuiteAddSuite(suite, st);
    CuSuiteRun(suite);
    CuSuiteSummary(suite, output);
    CuSuiteDetails(suite, output);
    printf("%s \n", output->buffer);
    
    CuSuiteDelete(st);
    CuStringDelete(output);
    free(suite);
}
Beispiel #19
0
int include_RunAllTests(void) {
    CuString *output = CuStringNew();
    CuSuite *suite = CuSuiteNew();
    CuSuite *common_s = common_TestSuite();
    CuSuite *maf_s = mafShared_TestSuite();
    CuSuiteAddSuite(suite, common_s);
    CuSuiteAddSuite(suite, maf_s);
    CuSuiteRun(suite);
    CuSuiteSummary(suite, output);
    CuSuiteDetails(suite, output);
    printf("%s\n", output->buffer);
    CuStringDelete(output);
    int status = (suite->failCount > 0);
    free(common_s);
    free(maf_s);
    CuSuiteDelete(suite);
    return status;
}
void RunAllTests(void) {
    
    printf("Running Test Suite: lib_tensor\n");

    CuString * output = CuStringNew();
    CuSuite * suite = CuSuiteNew();
    
    CuSuite * tensor = TensorGetSuite();
    CuSuiteAddSuite(suite, tensor);
    CuSuiteRun(suite);
    CuSuiteSummary(suite, output);
    CuSuiteDetails(suite, output);
    printf("%s \n", output->buffer);
    
    CuSuiteDelete(tensor);
    CuStringDelete(output);
    free(suite);
   
}
bool CuSuiteDelete (CuSuite_t *testSuite) {
    if (testSuite) {
        CuSize_t n = testSuite->totalcount;
        bool freereturn;
        CuTestOrSuitePtr_t *testlist = testSuite->testlist;

        //assert (NULL != testSuite);
        printf ("Removing testcases:\n");

        //n may be 0 but then the loop is not executed
        for (; n > 0; --n) {
            //We start with n=n_max and proceed to n=1. therefore index with n-1
            //We can assume here that n>0
            register CuTestOrSuitePtr_t *test = &testlist[n - 1];

            if (NULL != test->test) {
                if (test->isSuite) {
                    CuSuiteDelete (test->suite);
                }
                else {
                    printf ("%s\n", CuStringCStr (test->test->name) );
                    CuTestDelete (test->test);
                    //assert (NULL != testSuite->list);
                    //free(testSuite->list);
                }
            }
        }


        freereturn = CuFree (testlist);
        assert (freereturn);
        freereturn = CuReportDestroy (testSuite->report);
        assert (freereturn);
        freereturn = CuStringDelete (testSuite->name);
        assert (freereturn);
        freereturn = CuFree (testSuite);
        assert (freereturn);
        return EXIT_SUCCESS;
    }

    return EXIT_FAILURE;
}
void RunAllTests(void) {
    
    printf("Running test suite for: lib_probability\n");
    CuString * output = CuStringNew();
    CuSuite * suite = CuSuiteNew();
    
    CuSuite * prob = ProbGetSuite();
    CuSuiteAddSuite(suite, prob);

    CuSuiteRun(suite);
    CuSuiteSummary(suite, output);
    CuSuiteDetails(suite, output);
    printf("%s \n", output->buffer);
    
    CuSuiteDelete(prob);
    
    CuStringDelete(output);
    free(suite);
   
}
Beispiel #23
0
void run_all_tests(void)
{
	api_msg_set_level(API_MSG_ERROR);

	CuString *output = CuStringNew();
	CuSuite *suite = CuSuiteNew();
	CuSuite *tsmapi_suite = tsmapi_get_suite();

	CuSuiteAddSuite(suite, tsmapi_suite);

	CuSuiteRun(suite);
	CuSuiteSummary(suite, output);
	CuSuiteDetails(suite, output);
	printf("%s\n", output->buffer);

	CuSuiteDelete(tsmapi_suite);

	free(suite);
	CuStringDelete(output);
}
Beispiel #24
0
void RunAllTests(void) 
{
    CuString *output = CuStringNew();
    CuSuite* suite = CuSuiteNew();


    SUITE_ADD_TEST(suite, TestInitializedListIsEmpty);
    SUITE_ADD_TEST(suite, TestInsertOneNodeInFrontOfList);
    SUITE_ADD_TEST(suite, TestInsertIsDoneInOrder);
    SUITE_ADD_TEST(suite, TestInsertDuplicateDoesNotInsertNewNode);
    SUITE_ADD_TEST(suite, TestDeleteRemovesNodeWithGivenValue);
    SUITE_ADD_TEST(suite, TestDeleteReturnNegativeValueWhenNodeNotFound);
    SUITE_ADD_TEST(suite, TestPrintList);

    CuSuiteRun(suite);
    CuSuiteSummary(suite, output);
    CuSuiteDetails(suite, output);
    printf("%s\n", output->buffer);
    CuStringDelete(output);
    CuSuiteDelete(suite);
}