/* 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() { ks3_global_init(); int ret = load_ak_sk(); if (ret != 0) { printf("[ERROR] load ak, sk failed\n"); return ret; } ret = CreateBucket(host, bucket); if (ret != 0) { printf("[ERROR] create bucket failed\n"); return ret; } 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("Suite_1", init_suite1, clean_suite1); if (NULL == pSuite) { CU_cleanup_registry(); ks3_global_destroy(); return CU_get_error(); } /* add the tests to the suite */ if (NULL == CU_add_test(pSuite, "test complete multipart para null\n", TEST_COMPLETE_MULTIPART_UPLOAD_ALL_NULL) || NULL == CU_add_test(pSuite, "test complete multipart para return code null\n", TEST_COMPLETE_MULTIPART_UPLOAD_RETURNCODE_NULL) || NULL == CU_add_test(pSuite, "test complete multipart para host\n", TEST_COMPLETE_MULTIPART_UPLOAD_HOST) || NULL == CU_add_test(pSuite, "test complete multipart para bucket\n", TEST_COMPLETE_MULTIPART_UPLOAD_BUCKET) || NULL == CU_add_test(pSuite, "test complete multipart para object\n", TEST_COMPLETE_MULTIPART_UPLOAD_OBJECT) || NULL == CU_add_test(pSuite, "test complete multipart para key\n", TEST_COMPLETE_MULTIPART_UPLOAD_KEY) || NULL == CU_add_test(pSuite, "test complete multipart para data buf\n", TEST_COMPLETE_MULTIPART_UPLOAD_BUFDATAPARA) || NULL == CU_add_test(pSuite, "test complete multipart para query\n", TEST_COMPLETE_MULTIPART_UPLOAD_QUERYPARA) || NULL == CU_add_test(pSuite, "test complete multipart para header\n", TEST_COMPLETE_MULTIPART_UPLOAD_HEADERPARA)) { CU_cleanup_registry(); ks3_global_destroy(); 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(); ret = DeleteBucket(host, bucket); if (ret != 0) { printf("[ERROR] delete bucket failed\n"); } ks3_global_destroy(); return CU_get_error(); }
int main(int argc, char **argv) { // use CUnit test framework 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("Header", NULL, NULL); if(!pSuite) { CU_cleanup_registry(); return CU_get_error(); } // add the tests to the suite if(!CU_add_test(pSuite, "First header byte construction", testHeaderFirstByteConstruction)) { CU_cleanup_registry(); return CU_get_error(); } if(!CU_add_test(pSuite, "Method codes", testMethodCodes)) { CU_cleanup_registry(); return CU_get_error(); } if(!CU_add_test(pSuite, "Message ID", testMessageID)) { CU_cleanup_registry(); return CU_get_error(); } if(!CU_add_test(pSuite, "Token insertion", testTokenInsertion)) { CU_cleanup_registry(); return CU_get_error(); } if(!CU_add_test(pSuite, "Option insertion", testOptionInsertion)) { CU_cleanup_registry(); return CU_get_error(); } if(!CU_add_test(pSuite, "URI setting", testURISetting)) { CU_cleanup_registry(); return CU_get_error(); } CU_pTest payloadTest = CU_add_test(pSuite, "Payload setting", testPayload); if(!payloadTest) { CU_cleanup_registry(); return CU_get_error(); } // Run all tests using the CUnit Basic interface CU_basic_set_mode(CU_BRM_VERBOSE); CU_set_error_action(CUEA_ABORT); CU_basic_run_tests(); CU_cleanup_registry(); //optionInsertionTest(); return CU_get_error(); }
int run_unit_tests() { 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("File Scanning", NULL, NULL); if (NULL == pSuite) { CU_cleanup_registry(); return CU_get_error(); } #ifdef SUPER // ms_set_log_level(DEBUG); // av_log_set_level(AV_LOG_DEBUG); /* add the tests to the ms_scan suite */ if ( NULL == CU_add_test(pSuite, "Simple test of ms_scan()", test_ms_scan) || NULL == CU_add_test(pSuite, "Test ms_scan() with no paths", test_ms_scan_2) || NULL == CU_add_test(pSuite, "Test of ms_scan() with too many paths", test_ms_scan_3) || NULL == CU_add_test(pSuite, "Test of ms_scan() with a bad directory", test_ms_scan_4) || // TODO: The following test fails due to the scanner freezing up. // NULL == CU_add_test(pSuite, "Test of ms_scan() with strange path slashes", test_ms_scan_5) || NULL == CU_add_test(pSuite, "Test of ms_scan()'s progress notifications", test_ms_scan_6) || NULL == CU_add_test(pSuite, "Test of ms_file_scan()", test_ms_file_scan_1) || //NULL == CU_add_test(pSuite, "Test of scanning LOTS of files", test_ms_large_directory) || NULL == CU_add_test(pSuite, "Test of misc functions", test_ms_misc_functions) || NULL == CU_add_test(pSuite, "Simple test of ASF audio file", test_ms_file_asf_audio) || NULL == CU_add_test(pSuite, "Test Berkeley database functionality", test_ms_db) ) { CU_cleanup_registry(); return CU_get_error(); } #endif // setupbackground_tests(); setupdefect_tests(); // setupimage_tests(); // setup_thumbnail_tests(); /* Run all tests using the CUnit Basic interface */ CU_basic_set_mode(CU_BRM_VERBOSE); CU_basic_run_tests(); // CU_automated_run_tests(); CU_cleanup_registry(); return CU_get_error(); } /* run_unit_tests() */
static void test_main(spdk_event_t event) { CU_pSuite suite = NULL; unsigned int num_failures; if (bdevio_construct_targets() < 0) { spdk_app_stop(-1); return; } if (CU_initialize_registry() != CUE_SUCCESS) { spdk_app_stop(CU_get_error()); return; } suite = CU_add_suite("components_suite", NULL, NULL); if (suite == NULL) { CU_cleanup_registry(); spdk_app_stop(CU_get_error()); return; } if ( CU_add_test(suite, "blockdev write read 4k", blockdev_write_read_4k) == NULL || CU_add_test(suite, "blockdev write read 512 bytes", blockdev_write_read_512Bytes) == NULL || CU_add_test(suite, "blockdev write read size > 128k", blockdev_write_read_size_gt_128k) == NULL || CU_add_test(suite, "blockdev write read invalid size", blockdev_write_read_invalid_size) == NULL || CU_add_test(suite, "blockdev write read offset + nbytes == size of blockdev", blockdev_write_read_offset_plus_nbytes_equals_bdev_size) == NULL || CU_add_test(suite, "blockdev write read offset + nbytes > size of blockdev", blockdev_write_read_offset_plus_nbytes_gt_bdev_size) == NULL || CU_add_test(suite, "blockdev write read max offset", blockdev_write_read_max_offset) == NULL || CU_add_test(suite, "blockdev write read 8k on overlapped address offset", blockdev_overlapped_write_read_8k) == NULL ) { CU_cleanup_registry(); spdk_app_stop(CU_get_error()); return; } pthread_mutex_init(&g_test_mutex, NULL); pthread_cond_init(&g_test_cond, NULL); CU_basic_set_mode(CU_BRM_VERBOSE); CU_basic_run_tests(); num_failures = CU_get_number_of_failures(); CU_cleanup_registry(); spdk_app_stop(num_failures); }
int main(int argc, char *argv[]) { CU_ErrorCode error; /** * Definizione dei test array * NOTA ? L?ORDINE DI INSERIMENTO E? IMPORTANTE */ CU_TestInfo test_array_conta_parole_bis[] = { { "test di conta_parole_bis()", test_conta_parole_bis }, CU_TEST_INFO_NULL, }; /** * crea le suite e vi aggiunge i test array * NOTA ? L?ORDINE DI INSERIMENTO E? IMPORTANTE */ CU_SuiteInfo suites[] = { { "test suite per conta_parole_bis ", suite_void_init, suite_void_cleanup, test_array_conta_parole_bis }, CU_SUITE_INFO_NULL, }; /* inizializza registro ? e? la prima istruzione */ if (CUE_SUCCESS != CU_initialize_registry()) { error = CU_get_error(); system("PAUSE"); return -1; } // add the suites to the registry error = CU_register_suites(suites); if (CUE_SUCCESS != error) { CU_cleanup_registry(); error = CU_get_error(); system("PAUSE"); return -1; } /** * Esegue tutti i casi di test con output sulla console */ CU_basic_set_mode(CU_BRM_VERBOSE); CU_basic_run_tests(); /** * Pulisce il registro e termina lo unit test **/ CU_cleanup_registry(); //system("PAUSE"); return error; }
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; }
/* * 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); }
int main() { CU_pSuite pSuite = NULL; /* Init CUnit test registry */ if (CUE_SUCCESS != CU_initialize_registry()) return CU_get_error(); /* Add suite to the registry */ pSuite = CU_add_suite("yee_common", init_testsuite1, clean_testsuite1); if (!pSuite) { CU_cleanup_registry(); return CU_get_error(); } /* Add the tests to the suite */ if (!CU_add_test(pSuite, "py_alloc_field", test_alloc_field) || !CU_add_test(pSuite, "py_set_grid", test_set_grid) || !CU_add_test(pSuite, "py_vec_func", test_vec_func) || !CU_add_test(pSuite, "py_vec_func2d", test_vec_func2d) || !CU_add_test(pSuite, "py_apply_func", test_apply_func) || !CU_add_test(pSuite, "py_init_acoustic_field", test_init_acoustic_field) || !CU_add_test(pSuite, "py_init_local_acoustic_field", test_init_local_acoustic_field) || !CU_add_test(pSuite, "py_assign_to, get_from", test_assign_and_get) || !CU_add_test(pSuite, "py_set_boundary", test_set_boundary) || !CU_add_test(pSuite, "py_leapfrog", test_leapfrog) || !CU_add_test(pSuite, "py_partition_grid", test_partition_grid) || !CU_add_test(pSuite, "py_get_partition_coords", test_get_partition_coords) /*|| !CU_add_test(pSuite, "py_expand_indices", test_expand_indices) */ /*|| !CU_add_test(pSuite, "py_verify_grid_integrity", test_verify_grid) */ /*|| !CU_add_test(pSuite, "py_set_local_index", test_set_local_index) */ || !CU_add_test(pSuite, "py_parse_cmdline", test_parse_cmdline) || !CU_add_test(pSuite, "py_zero", test_zero) || !CU_add_test(pSuite, "py_zero2d", test_zero2d) || !CU_add_test(pSuite, "py_identity", test_identity) || !CU_add_test(pSuite, "py_identity2d", test_identity) || !CU_add_test(pSuite, "py_round_up_divide", test_round_up_divide)) { CU_cleanup_registry(); return CU_get_error(); } /* Run all the tests using the CUnit Basic interface */ CU_basic_set_mode(CU_BRM_VERBOSE); CU_basic_run_tests(); CU_cleanup_registry(); 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 us894_add_suite (void) { #ifdef HAVE_CUNIT CU_pSuite pSuite = NULL; /* add a suite to the registry */ pSuite = CU_add_suite("us894_proxy_cacerts", us894_init_suite, us894_destroy_suite); if (NULL == pSuite) { CU_cleanup_registry(); return CU_get_error(); } /* add the tests to the suite */ /* NOTE - ORDER IS IMPORTANT - MUST TEST fread() AFTER fprintf() */ if ((NULL == CU_add_test(pSuite, "HTTP Basic Auth", us894_test1)) || (NULL == CU_add_test(pSuite, "HTTP Basic Auth Fail", us894_test2)) || (NULL == CU_add_test(pSuite, "HTTP Digest Auth", us894_test3)) || (NULL == CU_add_test(pSuite, "HTTP Digest Auth Fail", us894_test4)) || (NULL == CU_add_test(pSuite, "Get CA Certificates", us894_test5)) || (NULL == CU_add_test(pSuite, "SSL 3.0 Fail", us894_test6)) || (NULL == CU_add_test(pSuite, "TLS 1.0 Fail", us894_test7)) || (NULL == CU_add_test(pSuite, "TLS 1.1", us894_test8)) || (NULL == CU_add_test(pSuite, "TLS 1.2", us894_test9)) || (NULL == CU_add_test(pSuite, "Certificate auth - explicit cert chain", us894_test10)) || (NULL == CU_add_test(pSuite, "Certificate auth - implicit cert chain", us894_test11)) || (NULL == CU_add_test(pSuite, "Certificate auth - revoked cert", us894_test12)) || (NULL == CU_add_test(pSuite, "Certificate auth - self-signed cert", us894_test13)) || (NULL == CU_add_test(pSuite, "Anon cipher suite disabled", us894_test14)) || (NULL == CU_add_test(pSuite, "NULL Realm", us894_test15)) || (NULL == CU_add_test(pSuite, "NULL server cert", us894_test16)) || (NULL == CU_add_test(pSuite, "NULL server key", us894_test17)) || (NULL == CU_add_test(pSuite, "NULL local CA chain", us894_test18)) || (NULL == CU_add_test(pSuite, "Corrupted local CA chain", us894_test19)) || (NULL == CU_add_test(pSuite, "HTTP POST cacerts", us894_test20)) || (NULL == CU_add_test(pSuite, "SimpleEnroll - good HTTP auth/good Cert", us894_test21)) || (NULL == CU_add_test(pSuite, "SimpleEnroll - bad HTTP auth/good Cert", us894_test22)) || (NULL == CU_add_test(pSuite, "SimpleEnroll - no HTTP auth/no Cert", us894_test23)) || (NULL == CU_add_test(pSuite, "Set Server Invalid parameters", us894_test24)) || (NULL == CU_add_test(pSuite, "Set Auth Mode Invalid parameters", us894_test25)) || (NULL == CU_add_test(pSuite, "Optional CA Chain Response", us894_test26)) || (NULL == CU_add_test(pSuite, "Bad userid/password for proxy init", us894_test27))) { CU_cleanup_registry(); return CU_get_error(); } return CUE_SUCCESS; #endif }
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(); }
CU_ErrorCode test_string(CU_pSuite suite){ suite = CU_add_suite("CryString Tests (test_string.c)", before_all_test_string, after_all_test_string); if(suite == NULL){ CU_cleanup_registry(); return CU_get_error(); } if( (CU_add_test(suite, "String's tests are not done yet!", test_missing_strings_tests ) == NULL ) ){ CU_cleanup_registry(); return CU_get_error(); } return CUE_SUCCESS; }
int main (void) { 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("Suite1", init_suite1, clean_suite1); if (NULL == pSuite) { CU_cleanup_registry(); return CU_get_error(); } /* add the tests to the suite */ if ((NULL == CU_add_test(pSuite, " 1: Requesting a single record in a compressed warc file", test1)) || (NULL == CU_add_test(pSuite, " 2: Requesting a whole warc file", test2)) || (NULL == CU_add_test(pSuite, " 3: sending a bad request", test3)) || (NULL == CU_add_test(pSuite," 4: sending a filter request", test4)) || (NULL == CU_add_test(pSuite," 5: sending a List request with severral output format", test5))) { CU_cleanup_registry(); return CU_get_error(); } /* Run all tests using the automated interface*/ switch (menu()) { case 1: {CU_console_run_tests(); break;} case 2: { case 21: {CU_basic_set_mode(CU_BRM_NORMAL); CU_basic_run_tests(); break;} case 22:{CU_basic_set_mode(CU_BRM_VERBOSE ); CU_basic_run_tests(); break;} case 23:{CU_basic_set_mode(CU_BRM_SILENT); CU_basic_run_tests(); break;} } case 3:{ CU_set_output_filename("./utest/outputs/client"); CU_set_output_filename("./utest/outputs/client" ); CU_automated_run_tests(); CU_list_tests_to_file(); break;} } CU_cleanup_registry(); return CU_get_error(); }
int main(int argc, char **argv) { CU_pSuite suite = NULL; unsigned int num_failures; if (CU_initialize_registry() != CUE_SUCCESS) { return CU_get_error(); } suite = CU_add_suite("scsi_suite", null_init, null_clean); if (suite == NULL) { CU_cleanup_registry(); return CU_get_error(); } if ( CU_add_test(suite, "scsi init - set default scsi params", \ scsi_init_sp_null) == NULL || CU_add_test(suite, "scsi init - set max_unmap_lba_count", \ scsi_init_set_max_unmap_lba_count_config_param) == NULL || CU_add_test(suite, "scsi init - set max_unmap_block_descriptor_count", \ scsi_init_set_max_unmap_block_descriptor_count_config_param) == NULL || CU_add_test(suite, "scsi init - set optimal_unmap_granularity", \ scsi_init_set_optimal_unmap_granularity_config_param) == NULL || CU_add_test(suite, "scsi init - set unmap_granularity_alignment", \ scsi_init_set_unmap_granularity_alignment_config_param) == NULL || CU_add_test(suite, "scsi init - ugavalid value yes", \ scsi_init_ugavalid_yes) == NULL || CU_add_test(suite, "scsi init - ugavalid value no", \ scsi_init_ugavalid_no) == NULL || CU_add_test(suite, "scsi init - ugavalid unknown value", \ scsi_init_ugavalid_unknown_value_failure) == NULL || CU_add_test(suite, "scsi init - set max_write_same_length", \ scsi_init_max_write_same_length) == NULL || CU_add_test(suite, "scsi init - read config scsi parameters", \ scsi_init_read_config_scsi_params) == NULL || CU_add_test(suite, "scsi init - success", scsi_init_success) == NULL ) { CU_cleanup_registry(); return CU_get_error(); } CU_basic_set_mode(CU_BRM_VERBOSE); CU_basic_run_tests(); num_failures = CU_get_number_of_failures(); CU_cleanup_registry(); return num_failures; }
int main(int argc, char **argv) { CU_pSuite pSuite = NULL; putenv("LC_ALL=C"); putenv("LANG=C"); /* initialize the CUnit test registry */ if(CUE_SUCCESS != CU_initialize_registry()){ return CU_get_error(); } /* remove a suite to the registry */ pSuite = CU_add_suite("AgsConnectableTest", ags_connectable_test_init_suite, ags_connectable_test_clean_suite); if(pSuite == NULL){ CU_cleanup_registry(); return CU_get_error(); } /* remove the tests to the suite */ if((CU_add_test(pSuite, "test of AgsConnectable get uuid", ags_connectable_test_get_uuid) == NULL) || (CU_add_test(pSuite, "test of AgsConnectable has resource", ags_connectable_test_has_resource) == NULL) || (CU_add_test(pSuite, "test of AgsConnectable is ready", ags_connectable_test_is_ready) == NULL) || (CU_add_test(pSuite, "test of AgsConnectable add to registry", ags_connectable_test_add_to_registry) == NULL) || (CU_add_test(pSuite, "test of AgsConnectable remove from registry", ags_connectable_test_remove_from_registry) == NULL) || (CU_add_test(pSuite, "test of AgsConnectable list resource", ags_connectable_test_list_resource) == NULL) || (CU_add_test(pSuite, "test of AgsConnectable xml compose", ags_connectable_test_xml_compose) == NULL) || (CU_add_test(pSuite, "test of AgsConnectable xml parse", ags_connectable_test_xml_parse) == NULL) || (CU_add_test(pSuite, "test of AgsConnectable is connected", ags_connectable_test_is_connected) == NULL) || (CU_add_test(pSuite, "test of AgsConnectable connect", ags_connectable_test_connect) == NULL) || (CU_add_test(pSuite, "test of AgsConnectable disconnect", ags_connectable_test_disconnect) == NULL) || (CU_add_test(pSuite, "test of AgsConnectable connect connection", ags_connectable_test_connect_connection) == NULL) || (CU_add_test(pSuite, "test of AgsConnectable disconnect connection", ags_connectable_test_disconnect_connection) == NULL)){ 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 hello_test_register(CU_pSuite pSuite) { /* add a suite to the registry */ pSuite = CU_add_suite("Suite_hello", hello_test_init_suite, hello_test_clean_suite); if (NULL == pSuite) { CU_cleanup_registry(); return CU_get_error(); } if ((NULL == CU_add_test(pSuite, "hello::get_msg", hello_test_get_msg))) { CU_cleanup_registry(); return CU_get_error(); } }
int main(int argc, char **argv) { CU_pSuite suite = NULL; if(CU_initialize_registry() != CUE_SUCCESS) { return CU_get_error(); } // Init suite suite = CU_add_suite("Shadowdive", NULL, NULL); if(suite == NULL) { goto end; } // Add tests if(CU_add_test(suite, "test of sd_bk_create", test_sd_bk_create) == NULL) { goto end; } if(CU_add_test(suite, "test of sd_bk_delete", test_sd_bk_delete) == NULL) { goto end; } if(CU_add_test(suite, "test of sd_af_create", test_sd_af_create) == NULL) { goto end; } if(CU_add_test(suite, "test of sd_af_delete", test_sd_af_delete) == NULL) { goto end; } // Run tests CU_basic_set_mode(CU_BRM_VERBOSE); CU_basic_run_tests(); end: CU_cleanup_registry(); return CU_get_error(); }
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; }
void bc_tester_uninit() { /* Redisplay list of failed tests on end */ if (CU_get_number_of_failure_records()){ CU_basic_show_failures(CU_get_failure_list()); } CU_cleanup_registry(); /*add missing final newline*/ bc_tester_printf(bc_printf_verbosity_info,""); if( xml_enabled ){ /*create real xml file only if tester did not crash*/ size_t size = strlen(xml_file) + strlen(".tmp-Results.xml") + 1; char * xml_tmp_file = malloc(sizeof(char) * size); snprintf(xml_tmp_file, size, "%s.tmp-Results.xml", xml_file); rename(xml_tmp_file, xml_file); free(xml_tmp_file); } if (test_suite != NULL) { free(test_suite); test_suite = NULL; nb_test_suites = 0; } if (bc_tester_resource_dir_prefix != NULL) { free(bc_tester_resource_dir_prefix); bc_tester_resource_dir_prefix = NULL; } if (bc_tester_writable_dir_prefix != NULL) { free(bc_tester_writable_dir_prefix); bc_tester_writable_dir_prefix = NULL; } }
int main( const int argc, char* const* argv) { int exitCode = EXIT_FAILURE; if (CUE_SUCCESS == CU_initialize_registry()) { CU_Suite* testSuite = CU_add_suite(__FILE__, setup, teardown); if (NULL != testSuite) { CU_ADD_TEST(testSuite, test_getDottedDecimal); # if WANT_MULTICAST CU_ADD_TEST(testSuite, test_sa_getInetSockAddr); CU_ADD_TEST(testSuite, test_sa_getInet6SockAddr); CU_ADD_TEST(testSuite, test_sa_parse); CU_ADD_TEST(testSuite, test_sa_parseWithDefaults); # endif if (log_init(argv[0])) { (void)fprintf(stderr, "Couldn't open logging system\n"); } else { if (CU_basic_run_tests() == CUE_SUCCESS) { if (0 == CU_get_number_of_failures()) exitCode = EXIT_SUCCESS; } } } CU_cleanup_registry(); } /* CUnit registery allocated */ return exitCode; }
/* 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 err_code = 0; /* initialize the CUnit test registry */ if (CUE_SUCCESS != CU_initialize_registry()) return CU_get_error(); /* create suites, order is important */ if ( (err_code = build_suite__types()) || (err_code = build_suite__stub_memdev()) || (err_code = build_suite__somefs()) || (err_code = build_suite__smartfs()) || (err_code = build_suite__flxio()) || (err_code = build_suite__apdu())) { return err_code; } /* 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(void) { CU_initialize_registry(); CU_pSuite pSuite_cf_surname, pSuite_cf_name, pSuite_cf_date, pSuite_cf_ctrl_code, pSuite_cf_generator; pSuite_cf_surname = CU_add_suite("cf_surname", init_suite_default, clean_suite_default); pSuite_cf_name = CU_add_suite("cf_name",init_suite_default, clean_suite_default); pSuite_cf_date = CU_add_suite("cf_date",init_suite_default, clean_suite_default); pSuite_cf_ctrl_code = CU_add_suite("cf_ctrl_code",init_suite_default, clean_suite_default); pSuite_cf_generator = CU_add_suite("cf_generator",init_suite_default, clean_suite_default); CU_add_test(pSuite_cf_surname, "surname2code()", test_surname2code); CU_add_test(pSuite_cf_name, "name2code()", test_name2code); CU_add_test(pSuite_cf_date, "date2code()", test_date2code); CU_add_test(pSuite_cf_ctrl_code, "cf_ctrl_code()", test_cf_ctrl_code); CU_add_test(pSuite_cf_generator, "cf_generator()", test_cf_generator); CU_basic_set_mode(CU_BRM_VERBOSE); CU_basic_run_tests(); CU_cleanup_registry(); return CU_get_error(); }
int main() { CU_BasicRunMode mode = CU_BRM_VERBOSE; CU_ErrorAction error_action = CUEA_IGNORE; CU_ErrorCode cue = CU_initialize_registry(); if (cue != CUE_SUCCESS) { printf("ERROR in CU_initialize_registry\n"); return; } CU_basic_set_mode(mode); CU_set_error_action(error_action); CU_pSuite hitCounting, wordAdding, wordChomping, wordChecking; hitCounting = CU_add_suite("Hit counting", my_suite_init, my_suite_clean); wordAdding = CU_add_suite("Word adding", my_suite_init, my_suite_clean); wordChecking = CU_add_suite("Word checking", my_suite_init, my_suite_clean); CU_ADD_TEST(hitCounting, test_5_hits); CU_ADD_TEST(hitCounting, test_1_hits); CU_ADD_TEST(hitCounting, test_no_hits); CU_ADD_TEST(hitCounting, test_hits_out_of_order_do_not_count); CU_ADD_TEST(wordChecking, test_check_for_word_in_jdict); CU_ADD_TEST(wordChecking, test_winnowing_jdict); CU_basic_run_tests(); CU_cleanup_registry(); }
/** * @brief The main function for unitary tests. * @param argc - The number of aruments provided to the function. * @param argv - A string table that corresponds to the value of arguments. * @return An integer value. 0 if everything is OK. */ int main(int argc, char** argv) { CU_pSuite pSuite[7] = {}; CU_initialize_registry(); pSuite[0] = CU_add_suite("Verify formatName()", NULL, NULL); /*Verify formatName funtion.*/ CU_ADD_TEST(pSuite[0], verifyFormatName); pSuite[1] = CU_add_suite("Verify cleanGrid()", NULL, NULL); /*Verify cleanGrid funtion.*/ CU_ADD_TEST(pSuite[1], verifyCleanGrid); pSuite[2] = CU_add_suite("Verify generateItems()", NULL, NULL); /*Verify generateItems function.*/ CU_ADD_TEST(pSuite[2], verifyGenerateItems); pSuite[3] = CU_add_suite("Verify initGrid()", NULL, NULL); /*Verify initGrid funtion.*/ CU_ADD_TEST(pSuite[3], verifyInitGrid); pSuite[4] = CU_add_suite("Verify searchAndReplace()", NULL, NULL); /*Verify searchAndReplace function.*/ CU_ADD_TEST(pSuite[4], verifySearchAndReplace); pSuite[5] = CU_add_suite("Verify movePlayer()", NULL, NULL); /*Verify movePlayer funtion.*/ CU_ADD_TEST(pSuite[5], verifyMovePlayer); CU_ADD_TEST(pSuite[5], verifyPlayerCantMove); pSuite[6] = CU_add_suite("Verify reorderHighscore()", NULL, NULL); /*Verify reorderHighscore function.*/ CU_ADD_TEST(pSuite[6], reorderHighscore); CU_basic_run_tests(); CU_cleanup_registry(); return CU_get_error(); }
int main(void) { CU_BasicRunMode mode = CU_BRM_VERBOSE; CU_ErrorAction error_action = CUEA_IGNORE; setvbuf(stdout, NULL, _IONBF, 0); if (CU_initialize_registry()) { fprintf(stderr,"failed to initialise registry\n"); return EXIT_FAILURE; } tests_load(); CU_basic_set_mode(mode); CU_set_error_action(error_action); int status = CU_basic_run_tests(), nfail = CU_get_number_of_failures(); CU_cleanup_registry(); printf("\nSuite returned %d.\n", status); return (nfail > 0 ? EXIT_FAILURE : EXIT_SUCCESS); }
int main() { CU_ErrorCode error = CU_initialize_registry(); if (error != CUE_SUCCESS) CUNIT_ERROR("Failed to initialise test registry"); TEST(mt19937); TEST(mt19937_64); TEST(dcmt521); TEST(dcmt607); TEST(dcmt1279); TEST(dcmt2203); TEST(dcmt2281); TEST(dcmt3217); TEST(dcmt4253); TEST(dcmt9689); error = CU_basic_run_tests(); if (error != CUE_SUCCESS) CUNIT_ERROR("Failed to run tests"); CU_cleanup_registry(); return 0; }
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; }
void bc_tester_uninit(void) { /* Redisplay list of failed tests on end */ /*BUG: do not display list of failures on mingw, it crashes mysteriously*/ #if !defined(WIN32) && !defined(_MSC_VER) /* Redisplay list of failed tests on end */ if (CU_get_number_of_failure_records()){ CU_basic_show_failures(CU_get_failure_list()); } #endif CU_cleanup_registry(); /*add missing final newline*/ bc_tester_printf(bc_printf_verbosity_info,""); if( xml_enabled ){ /*create real xml file only if tester did not crash*/ char * xml_tmp_file = bc_sprintf("%s.tmp-Results.xml", xml_file); rename(xml_tmp_file, xml_file); free(xml_tmp_file); } if (test_suite != NULL) { free(test_suite); test_suite = NULL; nb_test_suites = 0; } if (bc_tester_resource_dir_prefix != NULL) { free(bc_tester_resource_dir_prefix); bc_tester_resource_dir_prefix = NULL; } if (bc_tester_writable_dir_prefix != NULL) { free(bc_tester_writable_dir_prefix); bc_tester_writable_dir_prefix = NULL; } }
int main (int argc, const char *argv[]) { int ret = 0; lw6sys_context_t *sys_context = NULL; int mode = 0; LW6SYS_MAIN_BEGIN (sys_context); lw6sys_log_clear (sys_context, NULL); mode = lw6sys_arg_test_mode (sys_context, argc, argv); if (CU_initialize_registry () == CUE_SUCCESS) { if (lw6sim_test_register (sys_context, mode)) { ret = lw6sim_test_run (sys_context, mode); } CU_cleanup_registry (); } LW6SYS_TEST_OUTPUT; LW6SYS_MAIN_END (sys_context); return (!ret); }
int runTestSuite() { CU_basic_set_mode(CU_BRM_VERBOSE); CU_basic_run_tests(); CU_cleanup_registry(); return CU_get_error(); }
int main( const int argc, const char* const* argv) { int exitCode = EXIT_FAILURE; if (-1 == openulog(basename(argv[0]), 0, LOG_LOCAL0, "-")) { (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_failures(); } CU_cleanup_registry(); } /* CUnit registery allocated */ } /* logging system initialized */ return exitCode; }