int main(void) { CU_pSuite pSuite1 = NULL; if (CUE_SUCCESS != CU_initialize_registry()) { fprintf(stderr, "%s", CU_get_error_msg()); exit(-1); } pSuite1 = CU_add_suite("Suite_1", NULL, NULL); if (NULL == pSuite1) { CU_cleanup_registry(); fprintf(stderr, "%s", CU_get_error_msg()); exit(-1); } if (NULL == CU_add_test(pSuite1, "some test", test1)) { CU_cleanup_registry(); fprintf(stderr, "%s", CU_get_error_msg()); exit(-1); } /* TODO: set output file */ CU_automated_run_tests(); CU_cleanup_registry(); return 0; }
CU_pSuite t_init_pdu_tests(void) { CU_pSuite suite[2]; suite[0] = CU_add_suite("pdu parser", t_pdu_tests_create, t_pdu_tests_remove); if (!suite[0]) { /* signal error */ fprintf(stderr, "W: cannot add pdu parser test suite (%s)\n", CU_get_error_msg()); return NULL; } #define PDU_TEST(s,t) \ if (!CU_ADD_TEST(s,t)) { \ fprintf(stderr, "W: cannot add pdu parser test (%s)\n", \ CU_get_error_msg()); \ } PDU_TEST(suite[0], t_parse_pdu1); PDU_TEST(suite[0], t_parse_pdu2); PDU_TEST(suite[0], t_parse_pdu3); PDU_TEST(suite[0], t_parse_pdu4); PDU_TEST(suite[0], t_parse_pdu5); PDU_TEST(suite[0], t_parse_pdu6); PDU_TEST(suite[0], t_parse_pdu7); PDU_TEST(suite[0], t_parse_pdu8); PDU_TEST(suite[0], t_parse_pdu9); PDU_TEST(suite[0], t_parse_pdu10); PDU_TEST(suite[0], t_parse_pdu11); PDU_TEST(suite[0], t_parse_pdu12); PDU_TEST(suite[0], t_parse_pdu13); PDU_TEST(suite[0], t_parse_pdu14); suite[1] = CU_add_suite("pdu encoder", t_pdu_tests_create, t_pdu_tests_remove); if (suite[1]) { #define PDU_ENCODER_TEST(s,t) \ if (!CU_ADD_TEST(s,t)) { \ fprintf(stderr, "W: cannot add pdu encoder test (%s)\n", \ CU_get_error_msg()); \ } PDU_ENCODER_TEST(suite[1], t_encode_pdu1); PDU_ENCODER_TEST(suite[1], t_encode_pdu2); PDU_ENCODER_TEST(suite[1], t_encode_pdu3); PDU_ENCODER_TEST(suite[1], t_encode_pdu4); PDU_ENCODER_TEST(suite[1], t_encode_pdu5); PDU_ENCODER_TEST(suite[1], t_encode_pdu6); PDU_ENCODER_TEST(suite[1], t_encode_pdu7); PDU_ENCODER_TEST(suite[1], t_encode_pdu8); PDU_ENCODER_TEST(suite[1], t_encode_pdu9); PDU_ENCODER_TEST(suite[1], t_encode_pdu10); PDU_ENCODER_TEST(suite[1], t_encode_pdu11); } else /* signal error */ fprintf(stderr, "W: cannot add pdu parser test suite (%s)\n", CU_get_error_msg()); return suite[0]; }
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() { CU_ErrorCode error; if (CUE_SUCCESS != CU_initialize_registry()) return CU_get_error(); error=CU_register_suites(suites); if (error != CUE_SUCCESS) { perror(CU_get_error_msg()); CU_cleanup_registry(); return CU_get_error(); } printf("Seting OK\n"); fflush(stdout); /* 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(); }
int main(int argc, char *argv[]) { CU_ErrorCode cu; CU_pSuite suite; const char *configpath, *mode = NULL; if (argc < 2) { fprintf(stderr, "please gives a configuration file\n"); exit(-1); } cu = CU_initialize_registry(); if (cu != CUE_SUCCESS) { fprintf(stderr, "error cunit initialization: %s\n", CU_get_error_msg()); exit(-1); } configpath = argv[1]; if (argc > 2) mode = argv[2]; if (da_cloud_init(&config, configpath) == 0) { suite = CU_add_suite("da_cloud", NULL, NULL); CU_add_test(suite, "da_cloud_headers_test", da_cloud_headers_test); CU_add_test(suite, "da_cloud_simple_lookup", da_cloud_simple_lookup); CU_add_test(suite, "da_cloud_properties_test", da_cloud_properties_test); if (mode != NULL && strcasecmp(mode, "show") == 0) CU_basic_run_tests(); else CU_automated_run_tests(); } da_cloud_fini(&config); CU_cleanup_registry(); return (0); }
void registerJacobiTests() { if (CU_register_suites(jacobi_suites) != CUE_SUCCESS) { fprintf(stderr, "Suite registration failed - %s\n", CU_get_error_msg()); exit(CU_get_error()); } }
static void parse_and_add_test(char *test) { if (access(test, F_OK) == 0) { FILE *fh; char t[256]; if ((fh = fopen(test, "r")) == NULL) { printf("Failed to open test-list file %s\n", test); exit(10); } while (fgets(t, sizeof(t), fh) != NULL) { while (1) { int len = strlen(t); if (len == 0) { break; } if (!isprint(t[--len])) { t[len] = 0; continue; } break; } parse_and_add_tests(t); } fclose(fh); return; } if (add_tests(test) != CUE_SUCCESS) { fprintf(stderr, "error: suite registration failed: %s\n", CU_get_error_msg()); exit(1); } }
CU_pSuite t_init_sendqueue_tests(void) { CU_pSuite suite; suite = CU_add_suite("sendqueue", t_sendqueue_tests_create, t_sendqueue_tests_remove); if (!suite) { /* signal error */ fprintf(stderr, "W: cannot add sendqueue test suite (%s)\n", CU_get_error_msg()); return NULL; } #define SENDQUEUE_TEST(s,t) \ if (!CU_ADD_TEST(s,t)) { \ fprintf(stderr, "W: cannot add sendqueue test (%s)\n", \ CU_get_error_msg()); \ } SENDQUEUE_TEST(suite, t_sendqueue1); SENDQUEUE_TEST(suite, t_sendqueue2); SENDQUEUE_TEST(suite, t_sendqueue3); SENDQUEUE_TEST(suite, t_sendqueue4); SENDQUEUE_TEST(suite, t_sendqueue5); SENDQUEUE_TEST(suite, t_sendqueue6); SENDQUEUE_TEST(suite, t_sendqueue7); SENDQUEUE_TEST(suite, t_sendqueue8); SENDQUEUE_TEST(suite, t_sendqueue9); SENDQUEUE_TEST(suite, t_sendqueue10); return suite; }
CU_pSuite t_init_error_response_tests(void) { CU_pSuite suite[1]; suite[0] = CU_add_suite("error response generator", t_error_response_tests_create, t_error_response_tests_remove); if (!suite[0]) { /* signal error */ fprintf(stderr, "W: cannot add error response generator test suite (%s)\n", CU_get_error_msg()); return NULL; } #define ERROR_RESPONSE_TEST(s,t) \ if (!CU_ADD_TEST(s,t)) { \ fprintf(stderr, "W: cannot add error response generator test (%s)\n", \ CU_get_error_msg()); \ } ERROR_RESPONSE_TEST(suite[0], t_error_response1); ERROR_RESPONSE_TEST(suite[0], t_error_response2); ERROR_RESPONSE_TEST(suite[0], t_error_response3); ERROR_RESPONSE_TEST(suite[0], t_error_response4); ERROR_RESPONSE_TEST(suite[0], t_error_response5); ERROR_RESPONSE_TEST(suite[0], t_error_response6); ERROR_RESPONSE_TEST(suite[0], t_error_response7); ERROR_RESPONSE_TEST(suite[0], t_error_response8); return suite[0]; }
/* MAIN */ int main(void) { fprintf(stderr, "I'm here!\n"); CU_pSuite ste = NULL; if (CUE_SUCCESS != CU_initialize_registry()) { return CU_get_error(); } ste = CU_add_suite("mutable_string_suite", init_mutable_string_suite, clean_mutable_string_suite); if (NULL == ste) { CU_cleanup_registry(); return CU_get_error(); } if (CU_get_error() != CUE_SUCCESS) { fprintf(stderr, "Error creating suite: (%d)%s\n", CU_get_error(), CU_get_error_msg()); } ADD_TEST(CU_add_test(ste, "Verify mutable_string_init()...", t_mutable_string_init)); ADD_TEST(CU_add_test(ste, "Verify mutable_string_init_with_value()...", t_mutable_string_init_with_value)); ADD_TEST(CU_add_test(ste, "Verify mutable_string_resize()...", t_mutable_string_resize)); ADD_TEST(CU_add_test(ste, "Verify mutable_string_assign()...", t_mutable_string_assign)); ADD_TEST(CU_add_test(ste, "Verify mutable_string_append()...", t_mutable_string_append)); ADD_TEST(CU_add_test(ste, "Verify mutable_string_copy()...", t_mutable_string_copy)); ADD_TEST(CU_add_test(ste, "Verify mutable_string_append_mutable_string()...", t_mutable_string_append_mutable_string)); ADD_TEST(CU_add_test(ste, "Verify mutable_string_append_char()...", t_mutable_string_append_char)); ADD_TEST(CU_add_test(ste, "Verify mutable_string_char_at()...", t_mutable_string_char_at)); ADD_TEST(CU_add_test(ste, "Verify mutable_string_substring()...", t_mutable_string_substring)); ADD_TEST(CU_add_test(ste, "Verify mutable_string_int64/32/16()...", t_mutable_string_parse_int)); // if (CU_get_error() != CUE_SUCCESS) { fprintf(stderr, "Error creating suite: (%d)%s\n", CU_get_error(), CU_get_error_msg()); // } // CU_console_run_tests(); CU_basic_set_mode(CU_BRM_VERBOSE); CU_ErrorCode run_errors = CU_basic_run_suite(ste); if (run_errors != CUE_SUCCESS) { fprintf(stderr, "Error running tests: (%d)%s\n", run_errors, CU_get_error_msg()); } CU_basic_show_failures(CU_get_failure_list()); CU_cleanup_registry(); printf("\n"); printf("I'm done!\n"); return CU_get_error(); }
void AddTests(void) { assert(NULL != CU_get_registry()); assert(!CU_is_test_running()); if(CUE_SUCCESS != CU_register_suites(suites)) { fprintf(stderr, "Register suites failed - %s ", CU_get_error_msg()); exit(EXIT_FAILURE); } }
void test_cunit_CUError(void) { CU_ErrorCode old_err = CU_get_error(); CU_ErrorAction old_action = CU_get_error_action(); test_cunit_start_tests("CUError.c"); /* CU_set_error() & CU_get_error() */ CU_set_error(CUE_NOMEMORY); TEST(CU_get_error() != CUE_SUCCESS); TEST(CU_get_error() == CUE_NOMEMORY); CU_set_error(CUE_NOREGISTRY); TEST(CU_get_error() != CUE_SUCCESS); TEST(CU_get_error() == CUE_NOREGISTRY); /* CU_get_error_msg() */ CU_set_error(CUE_SUCCESS); TEST(!strcmp(CU_get_error_msg(), get_error_desc(CUE_SUCCESS))); CU_set_error(CUE_NOTEST); TEST(!strcmp(CU_get_error_msg(), get_error_desc(CUE_NOTEST))); CU_set_error(CUE_NOMEMORY); TEST(!strcmp(CU_get_error_msg(), get_error_desc(CUE_NOMEMORY))); TEST(strcmp(CU_get_error_msg(), get_error_desc(CUE_SCLEAN_FAILED))); TEST(!strcmp(get_error_desc(100), "Undefined Error")); /* CU_set_error_action() & CU_get_error_action() */ CU_set_error_action(CUEA_FAIL); TEST(CU_get_error_action() != CUEA_IGNORE); TEST(CU_get_error_action() == CUEA_FAIL); TEST(CU_get_error_action() != CUEA_ABORT); CU_set_error_action(CUEA_ABORT); TEST(CU_get_error_action() != CUEA_IGNORE); TEST(CU_get_error_action() != CUEA_FAIL); TEST(CU_get_error_action() == CUEA_ABORT); /* reset values */ CU_set_error(old_err); CU_set_error_action(old_action); test_cunit_end_tests(); }
int main(int argc, char** argv) { CU_pFailureRecord FailureList; CU_RunSummary *pRunSummary; int FailRec; if(CU_initialize_registry()) { fprintf(stderr, "Initialization of Test Registry failed.'n"); return -1; } assert(CU_get_registry()); assert(!CU_is_test_running()); if(CU_register_suites(suites) != CUE_SUCCESS) { fprintf(stderr, "Register suites failed - %s\n", CU_get_error_msg()); return -1; } CU_set_output_filename("lib-c"); CU_list_tests_to_file(); CU_automated_run_tests(); pRunSummary = CU_get_run_summary(); printf("Results:\n"); printf(" Number of suites run: %d\n", pRunSummary->nSuitesRun); printf(" Number of suites failed: %d\n", pRunSummary->nSuitesFailed); printf(" Number of tests run: %d\n", pRunSummary->nTestsRun); printf(" Number of tests failed: %d\n", pRunSummary->nTestsFailed); printf(" Number of asserts: %d\n", pRunSummary->nAsserts); printf(" Number of asserts failed: %d\n", pRunSummary->nAssertsFailed); printf(" Number of failures: %d\n", pRunSummary->nFailureRecords); /* Print any failures */ if (pRunSummary->nFailureRecords) { printf("\nFailures:\n"); FailRec = 1; for (FailureList = CU_get_failure_list(); FailureList; FailureList = FailureList->pNext) { printf("%d. File: %s Line: %u Test: %s\n", FailRec, FailureList->strFileName, FailureList->uiLineNumber, (FailureList->pTest)->pName); printf(" %s\n", FailureList->strCondition); FailRec++; } printf("\n"); } CU_cleanup_registry(); return 0; }
int main(void) { CU_pSuite pSuite1 = NULL; if (CUE_SUCCESS != CU_initialize_registry()) { fprintf(stderr, "%s", CU_get_error_msg()); exit(-1); } pSuite1 = CU_add_suite("Greater than Null", NULL, NULL); if (NULL == pSuite1) { CU_cleanup_registry(); fprintf(stderr, "%s", CU_get_error_msg()); exit(-1); } if (NULL == CU_add_test(pSuite1, "Test positive numbers", test_positive_numbers)) { CU_cleanup_registry(); fprintf(stderr, "%s", CU_get_error_msg()); exit(-1); } if (NULL == CU_add_test(pSuite1, "Test zero", test_zero)) { CU_cleanup_registry(); fprintf(stderr, "%s", CU_get_error_msg()); exit(-1); } if (NULL == CU_add_test(pSuite1, "Test negative numbers", test_negative_numbers)) { CU_cleanup_registry(); fprintf(stderr, "%s", CU_get_error_msg()); exit(-1); } CU_automated_run_tests(); CU_cleanup_registry(); return 0; }
void init_cunit() { if (is_init == 0) { is_init = 1; /* initialize the CUnit test registry */ if (CUE_SUCCESS != CU_initialize_registry()) { fprintf(stderr, "%s\n", CU_get_error_msg()); return; } } }
static void amdgpu_disable_suites() { amdgpu_device_handle device_handle; uint32_t major_version, minor_version, family_id; int i; int size = sizeof(suites_active_stat) / sizeof(suites_active_stat[0]); if (amdgpu_device_initialize(drm_amdgpu[0], &major_version, &minor_version, &device_handle)) return; family_id = device_handle->info.family_id; if (amdgpu_device_deinitialize(device_handle)) return; /* Set active status for suites based on their policies */ for (i = 0; i < size; ++i) if (amdgpu_set_suite_active(suites_active_stat[i].pName, suites_active_stat[i].pActive())) fprintf(stderr, "suite deactivation failed - %s\n", CU_get_error_msg()); /* Explicitly disable specific tests due to known bugs or preferences */ /* * BUG: Compute ring stalls and never recovers when the address is * written after the command already submitted */ if (amdgpu_set_test_active(DEADLOCK_TESTS_STR, "compute ring block test", CU_FALSE)) fprintf(stderr, "test deactivation failed - %s\n", CU_get_error_msg()); if (amdgpu_set_test_active(BO_TESTS_STR, "Metadata", CU_FALSE)) fprintf(stderr, "test deactivation failed - %s\n", CU_get_error_msg()); if (amdgpu_set_test_active(BASIC_TESTS_STR, "bo eviction Test", CU_FALSE)) fprintf(stderr, "test deactivation failed - %s\n", CU_get_error_msg()); /* This test was ran on GFX8 and GFX9 only */ if (family_id < AMDGPU_FAMILY_VI || family_id > AMDGPU_FAMILY_RV) if (amdgpu_set_test_active(BASIC_TESTS_STR, "Sync dependency Test", CU_FALSE)) fprintf(stderr, "test deactivation failed - %s\n", CU_get_error_msg()); }
int AddTests(void) { ASSERT(CU_get_registry() != NULL); ASSERT(CU_is_test_running() == FALSE); if (CU_register_suites(test_suites) != CUE_SUCCESS) { DbgLog(__FILE__, "%d CU_register_suites failed - %s\n", __LINE__, CU_get_error_msg()); return 1; } return 0; }
void tests_load(void) { assert(NULL != CU_get_registry()); assert(!CU_is_test_running()); if (CU_register_suites(suites) != CUE_SUCCESS) { fprintf(stderr, "suite registration failed - %s\n", CU_get_error_msg()); exit(EXIT_FAILURE); } }
GOS_ERROR_CODE TMR_Unit_Test_Handler(VOS_APPL_UNIT_TEST_T *ut) { int i = 0; CU_pSuite pSuite = NULL; // show all the test suites if (0 == ut->id) { printf("\r\n"); while(i < sizeof(tmr_suites)/sizeof(CU_SuiteInfo)) { if (CU_INVALID_SUITE != tmr_suites[i].id) printf("%d:\t%s\r\n", tmr_suites[i].id, tmr_suites[i].pName); i++; } return GOS_OK; } if(CU_initialize_registry()){ fprintf(stderr, " Initialization of Test Registry failed. "); return GOS_ERR_NOT_INIT; }else{ /**//* shortcut regitry */ if(CU_ALL_TEST == ut->id) { if(CUE_SUCCESS != CU_register_suites(&tmr_suites[0])){ fprintf(stderr, "Register suites failed - %s ", CU_get_error_msg()); return GOS_ERR_NOT_INIT; } } else { int j = ut->id - 1; if ((ut->id < 1) || (ut->id >= sizeof(tmr_suites)/sizeof(CU_SuiteInfo))) { return GOS_ERR_NOTSUPPORT; } pSuite = CU_add_suite(tmr_suites[j].pName, tmr_suites[j].pInitFunc, tmr_suites[j].pCleanupFunc); for (i = 0; NULL != tmr_suites[ut->id-1].pTests[i].pName; i++) { CU_add_test(pSuite, tmr_suites[j].pTests[i].pName, tmr_suites[j].pTests[i].pTestFunc) ; } } CU_basic_set_mode(CU_BRM_VERBOSE); CU_basic_run_tests(); CU_cleanup_registry(); } return GOS_OK; }
int main(void) { CU_pSuite pSuite1 = NULL; if (CUE_SUCCESS != CU_initialize_registry()) { fprintf(stderr, "%s", CU_get_error_msg()); exit(-1); } pSuite1 = CU_add_suite("Palindrom check", NULL, NULL); if (NULL == pSuite1) { CU_cleanup_registry(); fprintf(stderr, "%s", CU_get_error_msg()); exit(-1); } if (NULL == CU_add_test(pSuite1, "Test string that are a palindrom", test_real_palindroms)) { CU_cleanup_registry(); fprintf(stderr, "%s", CU_get_error_msg()); exit(-1); } if (NULL == CU_add_test(pSuite1, "Test string that are not a palindrom", test_false_palindroms)) { CU_cleanup_registry(); fprintf(stderr, "%s", CU_get_error_msg()); exit(-1); } CU_automated_run_tests(); CU_cleanup_registry(); return 0; }
int main(void) { //mkl_set_num_threads(1); mkl_domain_set_num_threads(1, MKL_BLAS); CU_pSuite pSuite = NULL; /* initialize the CUnit test registry */ if (CUE_SUCCESS != CU_initialize_registry()) { return CU_get_error(); } /* Create a test array */ CU_TestInfo test_array[] = { { "Parallel Gaussian" , test_pfunc }, CU_TEST_INFO_NULL, }; /* Create the test suite */ CU_SuiteInfo suites[] = { { "Parallel Evaluation of Expressions", init_suite, clean_suite, NULL, NULL, test_array }, CU_SUITE_INFO_NULL, }; /* Register test suites */ CU_ErrorCode CU_error = CU_register_suites(suites); if (CU_error != CUE_SUCCESS) { debug_body("%s", CU_get_error_msg()); 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(); CU_cleanup_registry(); return 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(void) { CU_pSuite pSuite = NULL; unsigned int num_tests_failed; /* 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("libwslay_TestSuite", init_suite1, clean_suite1); if (NULL == pSuite) { CU_cleanup_registry(); return CU_get_error(); } /* add the tests to the suite */ if(!CU_add_test(pSuite, "wslay_frame_context_init", test_wslay_frame_context_init) || !CU_add_test(pSuite, "wslay_frame_recv", test_wslay_frame_recv) || !CU_add_test(pSuite, "wslay_frame_recv_1byte", test_wslay_frame_recv_1byte) || !CU_add_test(pSuite, "wslay_frame_recv_fragmented", test_wslay_frame_recv_fragmented) || !CU_add_test(pSuite, "wslay_frame_recv_interleaved_ctrl_frame", test_wslay_frame_recv_interleaved_ctrl_frame) || !CU_add_test(pSuite, "wslay_frame_recv_zero_payloadlen", test_wslay_frame_recv_zero_payloadlen) || !CU_add_test(pSuite, "wslay_frame_recv_too_large_payload", test_wslay_frame_recv_too_large_payload) || !CU_add_test(pSuite, "wslay_frame_recv_ctrl_too_large_payload", test_wslay_frame_recv_ctrl_frame_too_large_payload) || !CU_add_test(pSuite, "wslay_frame_recv_minimum_ext_payload16", test_wslay_frame_recv_minimum_ext_payload16) || !CU_add_test(pSuite, "wslay_frame_recv_minimum_ext_payload64", test_wslay_frame_recv_minimum_ext_payload64) || !CU_add_test(pSuite, "wslay_frame_send", test_wslay_frame_send) || !CU_add_test(pSuite, "wslay_frame_send_fragmented", test_wslay_frame_send_fragmented) || !CU_add_test(pSuite, "wslay_frame_send_interleaved_ctrl_frame", test_wslay_frame_send_interleaved_ctrl_frame) || !CU_add_test(pSuite, "wslay_frame_send_1byte_masked", test_wslay_frame_send_1byte_masked) || !CU_add_test(pSuite, "wslay_frame_send_zero_payloadlen", test_wslay_frame_send_zero_payloadlen) || !CU_add_test(pSuite, "wslay_frame_send_too_large_payload", test_wslay_frame_send_too_large_payload) || !CU_add_test(pSuite, "wslay_frame_send_ctrl_frame_too_large_payload", test_wslay_frame_send_ctrl_frame_too_large_payload) || !CU_add_test(pSuite, "wslay_event_send_fragmented_msg", test_wslay_event_send_fragmented_msg) || !CU_add_test(pSuite, "wslay_event_send_fragmented_msg_with_ctrl", test_wslay_event_send_fragmented_msg_with_ctrl) || !CU_add_test(pSuite, "wslay_event_send_fragmented_msg_with_rsv1", test_wslay_event_send_fragmented_msg_with_rsv1) || !CU_add_test(pSuite, "wslay_event_send_msg_with_rsv1", test_wslay_event_send_msg_with_rsv1) || !CU_add_test(pSuite, "wslay_event_send_ctrl_msg_first", test_wslay_event_send_ctrl_msg_first) || !CU_add_test(pSuite, "wslay_event_send_ctrl_msg_with_rsv1", test_wslay_event_send_ctrl_msg_with_rsv1) || !CU_add_test(pSuite, "wslay_event_queue_close", test_wslay_event_queue_close) || !CU_add_test(pSuite, "wslay_event_queue_close_without_code", test_wslay_event_queue_close_without_code) || !CU_add_test(pSuite, "wslay_event_recv_close_without_code", test_wslay_event_recv_close_without_code) || !CU_add_test(pSuite, "wslay_event_reply_close", test_wslay_event_reply_close) || !CU_add_test(pSuite, "wslay_event_no_more_msg", test_wslay_event_no_more_msg) || !CU_add_test(pSuite, "wslay_event_callback_failure", test_wslay_event_callback_failure) || !CU_add_test(pSuite, "wslay_event_no_buffering", test_wslay_event_no_buffering) || !CU_add_test(pSuite, "wslay_event_recv_text_frame_with_rsv1", test_wslay_event_recv_text_frame_with_rsv1) || !CU_add_test(pSuite, "wslay_event_frame_too_big", test_wslay_event_frame_too_big) || !CU_add_test(pSuite, "wslay_event_message_too_big", test_wslay_event_message_too_big) || !CU_add_test(pSuite, "wslay_event_config_set_allowed_rsv_bits", test_wslay_event_config_set_allowed_rsv_bits) || !CU_add_test(pSuite, "wslay_queue", test_wslay_queue)) { 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(); num_tests_failed = CU_get_number_of_tests_failed(); CU_cleanup_registry(); if (CU_get_error() == CUE_SUCCESS) { return (int)num_tests_failed; } else { printf("CUnit Error: %s\n", CU_get_error_msg()); return CU_get_error(); } }
/* 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) { int c; /* Character received from getopt */ int i = 0; int suite_id = -1; /* By default run everything */ int test_id = -1; /* By default run all tests in the suite */ int pci_bus_id = -1; /* By default PC bus ID is not specified */ int pci_device_id = 0; /* By default PC device ID is zero */ int display_devices = 0;/* By default not to display devices' info */ CU_pSuite pSuite = NULL; CU_pTest pTest = NULL; int test_device_index; int display_list = 0; int force_run = 0; for (i = 0; i < MAX_CARDS_SUPPORTED; i++) drm_amdgpu[i] = -1; /* Parse command line string */ opterr = 0; /* Do not print error messages from getopt */ while ((c = getopt(argc, argv, options)) != -1) { switch (c) { case 'l': display_list = 1; break; case 's': suite_id = atoi(optarg); break; case 't': test_id = atoi(optarg); break; case 'b': pci_bus_id = atoi(optarg); break; case 'd': sscanf(optarg, "%x", &pci_device_id); break; case 'p': display_devices = 1; break; case 'r': open_render_node = 1; break; case 'f': force_run = 1; break; case '?': case 'h': fprintf(stderr, usage, argv[0]); exit(EXIT_SUCCESS); default: fprintf(stderr, usage, argv[0]); exit(EXIT_FAILURE); } } if (amdgpu_open_devices(open_render_node) <= 0) { perror("Cannot open AMDGPU device"); exit(EXIT_FAILURE); } if (drm_amdgpu[0] < 0) { perror("Cannot open AMDGPU device"); exit(EXIT_FAILURE); } if (display_devices) { amdgpu_print_devices(); amdgpu_close_devices(); exit(EXIT_SUCCESS); } if (pci_bus_id > 0 || pci_device_id) { /* A device was specified to run the test */ test_device_index = amdgpu_find_device(pci_bus_id, pci_device_id); if (test_device_index >= 0) { /* Most tests run on device of drm_amdgpu[0]. * Swap the chosen device to drm_amdgpu[0]. */ i = drm_amdgpu[0]; drm_amdgpu[0] = drm_amdgpu[test_device_index]; drm_amdgpu[test_device_index] = i; } else { fprintf(stderr, "The specified GPU device does not exist.\n"); exit(EXIT_FAILURE); } } /* Initialize test suites to run */ /* initialize the CUnit test registry */ if (CUE_SUCCESS != CU_initialize_registry()) { amdgpu_close_devices(); return CU_get_error(); } /* Register suites. */ if (CU_register_suites(suites) != CUE_SUCCESS) { fprintf(stderr, "suite registration failed - %s\n", CU_get_error_msg()); CU_cleanup_registry(); amdgpu_close_devices(); exit(EXIT_FAILURE); } /* Run tests using the CUnit Basic interface */ CU_basic_set_mode(CU_BRM_VERBOSE); /* Disable suites and individual tests based on misc. conditions */ amdgpu_disable_suites(); if (display_list) { display_test_suites(); goto end; } if (suite_id != -1) { /* If user specify particular suite? */ pSuite = CU_get_suite_by_index((unsigned int) suite_id, CU_get_registry()); if (pSuite) { if (force_run) CU_set_suite_active(pSuite, CU_TRUE); if (test_id != -1) { /* If user specify test id */ pTest = CU_get_test_by_index( (unsigned int) test_id, pSuite); if (pTest) { if (force_run) CU_set_test_active(pTest, CU_TRUE); CU_basic_run_test(pSuite, pTest); } else { fprintf(stderr, "Invalid test id: %d\n", test_id); CU_cleanup_registry(); amdgpu_close_devices(); exit(EXIT_FAILURE); } } else CU_basic_run_suite(pSuite); } else { fprintf(stderr, "Invalid suite id : %d\n", suite_id); CU_cleanup_registry(); amdgpu_close_devices(); exit(EXIT_FAILURE); } } else CU_basic_run_tests(); end: CU_cleanup_registry(); amdgpu_close_devices(); return CU_get_error(); }
/** * lw6scm_test_register * * @sys_context: global system context * @mode: test mode (bitmask) * * Registers all tests for the libscm module. * * Return value: 1 if test is successfull, 0 on error. */ int lw6scm_test_register (lw6sys_context_t * sys_context, int mode) { int ret = 1; CU_Suite *suite = NULL; _test_data.sys_context = sys_context; if (lw6sys_false ()) { /* * Just to make sure most functions are stuffed in the binary */ lw6sys_test_register (sys_context, mode); lw6hlp_test_register (sys_context, mode); } suite = CU_add_suite ("lw6scm", _setup_init, _setup_quit); if (suite) { LW6SYS_CUNIT_ADD_TEST (suite, _test_wrapper); LW6SYS_CUNIT_ADD_TEST (suite, _test_funcname); LW6SYS_CUNIT_ADD_TEST (suite, _test_utils); LW6SYS_CUNIT_ADD_TEST (suite, _test_coverage); } else { lw6sys_log (sys_context, LW6SYS_LOG_WARNING, _x_ ("unable to add CUnit test suite, error msg is \"%s\""), CU_get_error_msg ()); ret = 0; } return ret; }
int main(int argc, char* argv[]) { CU_pSuite pSuite = NULL; unsigned int num_tests_failed; /* 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("libnghttp2_TestSuite", init_suite1, clean_suite1); if (NULL == pSuite) { CU_cleanup_registry(); return CU_get_error(); } /* add the tests to the suite */ if(!CU_add_test(pSuite, "pq", test_nghttp2_pq) || !CU_add_test(pSuite, "pq_update", test_nghttp2_pq_update) || !CU_add_test(pSuite, "map", test_nghttp2_map) || !CU_add_test(pSuite, "map_functional", test_nghttp2_map_functional) || !CU_add_test(pSuite, "map_each_free", test_nghttp2_map_each_free) || !CU_add_test(pSuite, "queue", test_nghttp2_queue) || !CU_add_test(pSuite, "buffer", test_nghttp2_buffer) || !CU_add_test(pSuite, "buffer_reader", test_nghttp2_buffer_reader) || !CU_add_test(pSuite, "npn", test_nghttp2_npn) || !CU_add_test(pSuite, "session_recv", test_nghttp2_session_recv) || !CU_add_test(pSuite, "session_recv_invalid_stream_id", test_nghttp2_session_recv_invalid_stream_id) || !CU_add_test(pSuite, "session_recv_invalid_frame", test_nghttp2_session_recv_invalid_frame) || !CU_add_test(pSuite, "session_recv_eof", test_nghttp2_session_recv_eof) || !CU_add_test(pSuite, "session_recv_data", test_nghttp2_session_recv_data) || !CU_add_test(pSuite, "session_continue", test_nghttp2_session_continue) || !CU_add_test(pSuite, "session_add_frame", test_nghttp2_session_add_frame) || !CU_add_test(pSuite, "session_on_request_headers_received", test_nghttp2_session_on_request_headers_received) || !CU_add_test(pSuite, "session_on_response_headers_received", test_nghttp2_session_on_response_headers_received) || !CU_add_test(pSuite, "session_on_headers_received", test_nghttp2_session_on_headers_received) || !CU_add_test(pSuite, "session_on_push_response_headers_received", test_nghttp2_session_on_push_response_headers_received) || !CU_add_test(pSuite, "session_on_priority_received", test_nghttp2_session_on_priority_received) || !CU_add_test(pSuite, "session_on_rst_stream_received", test_nghttp2_session_on_rst_stream_received) || !CU_add_test(pSuite, "session_on_settings_received", test_nghttp2_session_on_settings_received) || !CU_add_test(pSuite, "session_on_push_promise_received", test_nghttp2_session_on_push_promise_received) || !CU_add_test(pSuite, "session_on_ping_received", test_nghttp2_session_on_ping_received) || !CU_add_test(pSuite, "session_on_goaway_received", test_nghttp2_session_on_goaway_received) || !CU_add_test(pSuite, "session_on_window_update_received", test_nghttp2_session_on_window_update_received) || !CU_add_test(pSuite, "session_on_data_received", test_nghttp2_session_on_data_received) || !CU_add_test(pSuite, "session_send_headers_start_stream", test_nghttp2_session_send_headers_start_stream) || !CU_add_test(pSuite, "session_send_headers_reply", test_nghttp2_session_send_headers_reply) || !CU_add_test(pSuite, "session_send_headers_header_comp_error", test_nghttp2_session_send_headers_header_comp_error) || !CU_add_test(pSuite, "session_send_headers_push_reply", test_nghttp2_session_send_headers_push_reply) || !CU_add_test(pSuite, "session_send_rst_stream", test_nghttp2_session_send_rst_stream) || !CU_add_test(pSuite, "session_send_push_promise", test_nghttp2_session_send_push_promise) || !CU_add_test(pSuite, "session_is_my_stream_id", test_nghttp2_session_is_my_stream_id) || !CU_add_test(pSuite, "session_upgrade", test_nghttp2_session_upgrade) || !CU_add_test(pSuite, "session_reprioritize_stream", test_nghttp2_session_reprioritize_stream) || !CU_add_test(pSuite, "submit_request_with_data", test_nghttp2_submit_request_with_data) || !CU_add_test(pSuite, "submit_request_without_data", test_nghttp2_submit_request_without_data) || !CU_add_test(pSuite, "submit_response_with_data", test_nghttp2_submit_response_with_data) || !CU_add_test(pSuite, "submit_response_without_data", test_nghttp2_submit_response_without_data) || !CU_add_test(pSuite, "submit_headers_start_stream", test_nghttp2_submit_headers_start_stream) || !CU_add_test(pSuite, "submit_headers_reply", test_nghttp2_submit_headers_reply) || !CU_add_test(pSuite, "submit_headers_push_reply", test_nghttp2_submit_headers_push_reply) || !CU_add_test(pSuite, "submit_headers", test_nghttp2_submit_headers) || !CU_add_test(pSuite, "submit_priority", test_nghttp2_submit_priority) || !CU_add_test(pSuite, "session_submit_settings", test_nghttp2_submit_settings) || !CU_add_test(pSuite, "session_submit_settings_update_local_window_size", test_nghttp2_submit_settings_update_local_window_size) || !CU_add_test(pSuite, "session_submit_push_promise", test_nghttp2_submit_push_promise) || !CU_add_test(pSuite, "submit_window_update", test_nghttp2_submit_window_update) || !CU_add_test(pSuite, "submit_window_update_local_window_size", test_nghttp2_submit_window_update_local_window_size) || !CU_add_test(pSuite, "submit_invalid_nv", test_nghttp2_submit_invalid_nv) || !CU_add_test(pSuite, "session_open_stream", test_nghttp2_session_open_stream) || !CU_add_test(pSuite, "session_get_next_ob_item", test_nghttp2_session_get_next_ob_item) || !CU_add_test(pSuite, "session_pop_next_ob_item", test_nghttp2_session_pop_next_ob_item) || !CU_add_test(pSuite, "session_reply_fail", test_nghttp2_session_reply_fail) || !CU_add_test(pSuite, "session_max_concurrent_streams", test_nghttp2_session_max_concurrent_streams) || !CU_add_test(pSuite, "session_stream_close_on_headers_push", test_nghttp2_session_stream_close_on_headers_push) || !CU_add_test(pSuite, "session_stop_data_with_rst_stream", test_nghttp2_session_stop_data_with_rst_stream) || !CU_add_test(pSuite, "session_defer_data", test_nghttp2_session_defer_data) || !CU_add_test(pSuite, "session_flow_control", test_nghttp2_session_flow_control) || !CU_add_test(pSuite, "session_flow_control_disable_remote", test_nghttp2_session_flow_control_disable_remote) || !CU_add_test(pSuite, "session_flow_control_disable_local", test_nghttp2_session_flow_control_disable_local) || !CU_add_test(pSuite, "session_flow_control_data_recv", test_nghttp2_session_flow_control_data_recv) || !CU_add_test(pSuite, "session_data_read_temporal_failure", test_nghttp2_session_data_read_temporal_failure) || !CU_add_test(pSuite, "session_on_request_recv_callback", test_nghttp2_session_on_request_recv_callback) || !CU_add_test(pSuite, "session_on_stream_close", test_nghttp2_session_on_stream_close) || !CU_add_test(pSuite, "session_on_ctrl_not_send", test_nghttp2_session_on_ctrl_not_send) || !CU_add_test(pSuite, "session_get_outbound_queue_size", test_nghttp2_session_get_outbound_queue_size) || !CU_add_test(pSuite, "session_get_effective_local_window_size", test_nghttp2_session_get_effective_local_window_size) || !CU_add_test(pSuite, "session_set_option", test_nghttp2_session_set_option) || !CU_add_test(pSuite, "session_data_backoff_by_high_pri_frame", test_nghttp2_session_data_backoff_by_high_pri_frame) || !CU_add_test(pSuite, "pack_settings_payload", test_nghttp2_pack_settings_payload) || !CU_add_test(pSuite, "frame_pack_headers", test_nghttp2_frame_pack_headers) || !CU_add_test(pSuite, "frame_pack_headers_frame_too_large", test_nghttp2_frame_pack_headers_frame_too_large) || !CU_add_test(pSuite, "frame_pack_priority", test_nghttp2_frame_pack_priority) || !CU_add_test(pSuite, "frame_pack_rst_stream", test_nghttp2_frame_pack_rst_stream) || !CU_add_test(pSuite, "frame_pack_settings", test_nghttp2_frame_pack_settings) || !CU_add_test(pSuite, "frame_pack_push_promise", test_nghttp2_frame_pack_push_promise) || !CU_add_test(pSuite, "frame_pack_ping", test_nghttp2_frame_pack_ping) || !CU_add_test(pSuite, "frame_pack_goaway", test_nghttp2_frame_pack_goaway) || !CU_add_test(pSuite, "frame_pack_window_update", test_nghttp2_frame_pack_window_update) || !CU_add_test(pSuite, "nv_array_check", test_nghttp2_nv_array_check) || !CU_add_test(pSuite, "nv_array_copy", test_nghttp2_nv_array_copy) || !CU_add_test(pSuite, "iv_check", test_nghttp2_iv_check) || !CU_add_test(pSuite, "hd_deflate", test_nghttp2_hd_deflate) || !CU_add_test(pSuite, "hd_deflate_same_indexed_repr", test_nghttp2_hd_deflate_same_indexed_repr) || !CU_add_test(pSuite, "hd_deflate_common_header_eviction", test_nghttp2_hd_deflate_common_header_eviction) || !CU_add_test(pSuite, "hd_deflate_deflate_buffer", test_nghttp2_hd_deflate_deflate_buffer) || !CU_add_test(pSuite, "hd_deflate_clear_refset", test_nghttp2_hd_deflate_clear_refset) || !CU_add_test(pSuite, "hd_inflate_indname_noinc", test_nghttp2_hd_inflate_indname_noinc) || !CU_add_test(pSuite, "hd_inflate_indname_inc", test_nghttp2_hd_inflate_indname_inc) || !CU_add_test(pSuite, "hd_inflate_indname_inc_eviction", test_nghttp2_hd_inflate_indname_inc_eviction) || !CU_add_test(pSuite, "hd_inflate_newname_noinc", test_nghttp2_hd_inflate_newname_noinc) || !CU_add_test(pSuite, "hd_inflate_newname_inc", test_nghttp2_hd_inflate_newname_inc) || !CU_add_test(pSuite, "hd_inflate_clearall_inc", test_nghttp2_hd_inflate_clearall_inc) || !CU_add_test(pSuite, "hd_inflate_zero_length_huffman", test_nghttp2_hd_inflate_zero_length_huffman) || !CU_add_test(pSuite, "hd_change_table_size", test_nghttp2_hd_change_table_size) || !CU_add_test(pSuite, "hd_deflate_inflate", test_nghttp2_hd_deflate_inflate) || !CU_add_test(pSuite, "gzip_inflate", test_nghttp2_gzip_inflate) || !CU_add_test(pSuite, "adjust_local_window_size", test_nghttp2_adjust_local_window_size) || !CU_add_test(pSuite, "check_header_name", test_nghttp2_check_header_name) || !CU_add_test(pSuite, "check_header_value", test_nghttp2_check_header_value) ) { 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(); num_tests_failed = CU_get_number_of_tests_failed(); CU_cleanup_registry(); if(CU_get_error() == CUE_SUCCESS) { return num_tests_failed; } else { printf("CUnit Error: %s\n", CU_get_error_msg()); return CU_get_error(); } }
int main(int argc, char* argv[]) { CU_pSuite pSuite = NULL; unsigned int num_tests_failed; /* 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("libspdylay_TestSuite", init_suite1, clean_suite1); if (NULL == pSuite) { CU_cleanup_registry(); return CU_get_error(); } /* add the tests to the suite */ if(!CU_add_test(pSuite, "pq", test_spdylay_pq) || !CU_add_test(pSuite, "map", test_spdylay_map) || !CU_add_test(pSuite, "map_functional", test_spdylay_map_functional) || !CU_add_test(pSuite, "map_each_free", test_spdylay_map_each_free) || !CU_add_test(pSuite, "queue", test_spdylay_queue) || !CU_add_test(pSuite, "buffer", test_spdylay_buffer) || !CU_add_test(pSuite, "buffer_reader", test_spdylay_buffer_reader) || !CU_add_test(pSuite, "zlib_spdy2", test_spdylay_zlib_spdy2) || !CU_add_test(pSuite, "zlib_spdy3", test_spdylay_zlib_spdy3) || !CU_add_test(pSuite, "npn", test_spdylay_npn) || !CU_add_test(pSuite, "npn_get_proto_list", test_spdylay_npn_get_proto_list) || !CU_add_test(pSuite, "npn_get_version", test_spdylay_npn_get_version) || !CU_add_test(pSuite, "session_recv", test_spdylay_session_recv) || !CU_add_test(pSuite, "session_recv_invalid_stream_id", test_spdylay_session_recv_invalid_stream_id) || !CU_add_test(pSuite, "session_add_frame", test_spdylay_session_add_frame) || !CU_add_test(pSuite, "session_on_syn_stream_received", test_spdylay_session_on_syn_stream_received) || !CU_add_test(pSuite, "session_on_syn_stream_received_with_push", test_spdylay_session_on_syn_stream_received_with_push) || !CU_add_test(pSuite, "session_on_syn_reply_received", test_spdylay_session_on_syn_reply_received) || !CU_add_test(pSuite, "session_send_syn_stream", test_spdylay_session_send_syn_stream) || !CU_add_test(pSuite, "session_send_syn_reply", test_spdylay_session_send_syn_reply) || !CU_add_test(pSuite, "submit_response", test_spdylay_submit_response) || !CU_add_test(pSuite, "submit_response_without_data", test_spdylay_submit_response_with_null_data_read_callback) || !CU_add_test(pSuite, "submit_request_with_data", test_spdylay_submit_request_with_data) || !CU_add_test(pSuite, "submit_request_without_data", test_spdylay_submit_request_with_null_data_read_callback) || !CU_add_test(pSuite, "submit_syn_stream", test_spdylay_submit_syn_stream) || !CU_add_test(pSuite, "submit_syn_reply", test_spdylay_submit_syn_reply) || !CU_add_test(pSuite, "submit_headers", test_spdylay_submit_headers) || !CU_add_test(pSuite, "submit_invalid_nv", test_spdylay_submit_invalid_nv) || !CU_add_test(pSuite, "session_reply_fail", test_spdylay_session_reply_fail) || !CU_add_test(pSuite, "session_on_headers_received", test_spdylay_session_on_headers_received) || !CU_add_test(pSuite, "session_on_window_update_received", test_spdylay_session_on_window_update_received) || !CU_add_test(pSuite, "session_on_ping_received", test_spdylay_session_on_ping_received) || !CU_add_test(pSuite, "session_on_goaway_received", test_spdylay_session_on_goaway_received) || !CU_add_test(pSuite, "session_on_data_received", test_spdylay_session_on_data_received) || !CU_add_test(pSuite, "session_on_rst_stream_received", test_spdylay_session_on_rst_received) || !CU_add_test(pSuite, "session_is_my_stream_id", test_spdylay_session_is_my_stream_id) || !CU_add_test(pSuite, "session_send_rst_stream", test_spdylay_session_send_rst_stream) || !CU_add_test(pSuite, "session_get_next_ob_item", test_spdylay_session_get_next_ob_item) || !CU_add_test(pSuite, "session_pop_next_ob_item", test_spdylay_session_pop_next_ob_item) || !CU_add_test(pSuite, "session_on_request_recv_callback", test_spdylay_session_on_request_recv_callback) || !CU_add_test(pSuite, "session_on_stream_close", test_spdylay_session_on_stream_close) || !CU_add_test(pSuite, "session_max_concurrent_streams", test_spdylay_session_max_concurrent_streams) || !CU_add_test(pSuite, "session_data_backoff_by_high_pri_frame", test_spdylay_session_data_backoff_by_high_pri_frame) || !CU_add_test(pSuite, "session_stop_data_with_rst_stream", test_spdylay_session_stop_data_with_rst_stream) || !CU_add_test(pSuite, "session_stream_close_on_syn_stream", test_spdylay_session_stream_close_on_syn_stream) || !CU_add_test(pSuite, "session_recv_invalid_frame", test_spdylay_session_recv_invalid_frame) || !CU_add_test(pSuite, "session_defer_data", test_spdylay_session_defer_data) || !CU_add_test(pSuite, "session_flow_control", test_spdylay_session_flow_control) || !CU_add_test(pSuite, "session_connection_flow_control", test_spdylay_session_connection_flow_control) || !CU_add_test(pSuite, "session_on_ctrl_not_send", test_spdylay_session_on_ctrl_not_send) || !CU_add_test(pSuite, "session_on_settings_received", test_spdylay_session_on_settings_received) || !CU_add_test(pSuite, "session_submit_settings", test_spdylay_submit_settings) || !CU_add_test(pSuite, "session_get_outbound_queue_size", test_spdylay_session_get_outbound_queue_size) || !CU_add_test(pSuite, "session_prep_credential", test_spdylay_session_prep_credential) || !CU_add_test(pSuite, "session_submit_syn_stream_with_credential", test_spdylay_submit_syn_stream_with_credential) || !CU_add_test(pSuite, "session_set_initial_client_cert_origin", test_spdylay_session_set_initial_client_cert_origin) || !CU_add_test(pSuite, "session_set_option", test_spdylay_session_set_option) || !CU_add_test(pSuite, "submit_window_update", test_spdylay_submit_window_update) || !CU_add_test(pSuite, "session_data_read_temporal_failure", test_spdylay_session_data_read_temporal_failure) || !CU_add_test(pSuite, "session_recv_eof", test_spdylay_session_recv_eof) || !CU_add_test(pSuite, "session_recv_data", test_spdylay_session_recv_data) || !CU_add_test(pSuite, "frame_unpack_nv_spdy2", test_spdylay_frame_unpack_nv_spdy2) || !CU_add_test(pSuite, "frame_unpack_nv_spdy3", test_spdylay_frame_unpack_nv_spdy3) || !CU_add_test(pSuite, "frame_count_nv_space", test_spdylay_frame_count_nv_space) || !CU_add_test(pSuite, "frame_count_unpack_nv_space", test_spdylay_frame_count_unpack_nv_space) || !CU_add_test(pSuite, "frame_pack_ping", test_spdylay_frame_pack_ping) || !CU_add_test(pSuite, "frame_pack_goaway_spdy2", test_spdylay_frame_pack_goaway_spdy2) || !CU_add_test(pSuite, "frame_pack_goaway_spdy3", test_spdylay_frame_pack_goaway_spdy3) || !CU_add_test(pSuite, "frame_pack_syn_stream_spdy2", test_spdylay_frame_pack_syn_stream_spdy2) || !CU_add_test(pSuite, "frame_pack_syn_stream_spdy3", test_spdylay_frame_pack_syn_stream_spdy3) || !CU_add_test(pSuite, "frame_pack_syn_stream_frame_too_large", test_spdylay_frame_pack_syn_stream_frame_too_large) || !CU_add_test(pSuite, "frame_pack_syn_reply_spdy2", test_spdylay_frame_pack_syn_reply_spdy2) || !CU_add_test(pSuite, "frame_pack_syn_reply_spdy3", test_spdylay_frame_pack_syn_reply_spdy3) || !CU_add_test(pSuite, "frame_pack_headers_spdy2", test_spdylay_frame_pack_headers_spdy2) || !CU_add_test(pSuite, "frame_pack_headers_spdy3", test_spdylay_frame_pack_headers_spdy3) || !CU_add_test(pSuite, "frame_pack_window_update", test_spdylay_frame_pack_window_update) || !CU_add_test(pSuite, "frame_pack_settings_spdy2", test_spdylay_frame_pack_settings_spdy2) || !CU_add_test(pSuite, "frame_pack_settings_spdy3", test_spdylay_frame_pack_settings_spdy3) || !CU_add_test(pSuite, "frame_pack_credential", test_spdylay_frame_pack_credential) || !CU_add_test(pSuite, "frame_nv_sort", test_spdylay_frame_nv_sort) || !CU_add_test(pSuite, "frame_nv_downcase", test_spdylay_frame_nv_downcase) || !CU_add_test(pSuite, "frame_pack_nv_duplicate_keys", test_spdylay_frame_pack_nv_duplicate_keys) || !CU_add_test(pSuite, "frame_pack_nv_empty_value_spdy2", test_spdylay_frame_pack_nv_empty_value_spdy2) || !CU_add_test(pSuite, "frame_pack_nv_empty_value_spdy3", test_spdylay_frame_pack_nv_empty_value_spdy3) || !CU_add_test(pSuite, "frame_nv_2to3", test_spdylay_frame_nv_2to3) || !CU_add_test(pSuite, "frame_nv_3to2", test_spdylay_frame_nv_3to2) || !CU_add_test(pSuite, "frame_unpack_nv_check_name_spdy2", test_spdylay_frame_unpack_nv_check_name_spdy2) || !CU_add_test(pSuite, "frame_unpack_nv_check_name_spdy3", test_spdylay_frame_unpack_nv_check_name_spdy3) || !CU_add_test(pSuite, "frame_unpack_nv_last_empty_value_spdy2", test_spdylay_frame_unpack_nv_last_empty_value_spdy2) || !CU_add_test(pSuite, "frame_unpack_nv_last_empty_value_spdy3", test_spdylay_frame_unpack_nv_last_empty_value_spdy3) || !CU_add_test(pSuite, "frame_nv_set_origin", test_spdylay_frame_nv_set_origin) || !CU_add_test(pSuite, "frame_nv_check_null", test_spdylay_frame_nv_check_null) || !CU_add_test(pSuite, "stream_add_pushed_stream", test_spdylay_stream_add_pushed_stream) || !CU_add_test(pSuite, "client_cert_vector_find", test_spdylay_client_cert_vector_find) || !CU_add_test(pSuite, "client_cert_vector_resize", test_spdylay_client_cert_vector_resize) || !CU_add_test(pSuite, "client_cert_vector_get_origin", test_spdylay_client_cert_vector_get_origin) || !CU_add_test(pSuite, "gzip_inflate", test_spdylay_gzip_inflate)) { 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(); num_tests_failed = CU_get_number_of_tests_failed(); CU_cleanup_registry(); if(CU_get_error() == CUE_SUCCESS) { return num_tests_failed; } else { printf("CUnit Error: %s\n", CU_get_error_msg()); return CU_get_error(); } }