int main (int argc, char** argv) {
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", setup, teardown);
if (NULL == pSuite) {
CU_cleanup_registry();
return CU_get_error();
}
/* add the tests to the suite */
if (NULL == CU_add_test(pSuite, "List Creation Test", test_linkedList_create) ||
NULL == CU_add_test(pSuite, "List Add Test", test_linkedList_add) ||
NULL == CU_add_test(pSuite, "List Remove Test", test_linkedList_remove))
{
CU_cleanup_registry();
return CU_get_error();
}
CU_set_output_filename(argv[1]);
CU_list_tests_to_file();
CU_automated_run_tests();
CU_cleanup_registry();
return CU_get_error();
}
void TcuExecute(void)
{
if (TestGetAutomatic()) {
if (TestGetFilename()) {
CU_set_output_filename(TestGetFilename());
}
CU_automated_run_tests();
}
else if (TestGetBasic()) {
CU_basic_set_mode(CU_BRM_VERBOSE);
(void) CU_basic_run_tests();
}
else if (TestGetConsole()) {
CU_console_run_tests();
}
else if (TestGetList()) {
if (TestGetFilename()) {
CU_set_output_filename(TestGetFilename());
}
(void) CU_list_tests_to_file();
}
if (CU_get_number_of_tests_failed()) {
return;
}
/* Clean up the registry */
CU_cleanup_registry();
}
int main() {
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("malELFicus Test Suite", init_suite_success, clean_suite_success);
if (NULL == pSuite) {
CU_cleanup_registry();
return CU_get_error();
}
/* add the tests to the suite */
if (
(NULL == CU_add_test(pSuite, "testing malelf_init_object()", test_malelf_init_object)) ||
(NULL == CU_add_test(pSuite, "testing malelf_openr", test_malelf_openr)) ||
(NULL == CU_add_test(pSuite, "testing malelf_openw", test_malelf_openw)) ||
(NULL == CU_add_test(pSuite, "testing malelf_check_elf", test_malelf_check_elf))
) {
CU_cleanup_registry();
return CU_get_error();
}
CU_set_output_filename("test_malelf_object");
/* Run all tests using the automated interface */
CU_automated_run_tests();
CU_list_tests_to_file();
/* Clean up registry and return */
CU_cleanup_registry();
return CU_get_error();
}
int main(int argc, char **argv)
{
int status;
if(CUE_SUCCESS != CU_initialize_registry())
return CU_get_error();
if(!(status = setup_object_tests())
|| !(status = setup_list_tests()))
{
CU_cleanup_registry();
return CU_get_error();
}
CU_basic_set_mode(CU_BRM_VERBOSE);
CU_basic_run_tests();
printf("\n");
CU_basic_show_failures(CU_get_failure_list());
printf("\n\n");
CU_automated_run_tests();
CU_list_tests_to_file();
//CU_console_run_tests();
CU_cleanup_registry();
return CU_get_error();
}
void gradle_cunit_register() {
CU_TestInfo unique_check_test_array[] = {
{"unique check", test_initializer},
CU_TEST_INFO_NULL,
};
CU_TestInfo row_column_validator_test_array[] = {
{"valid row column test", test_valid_row_column_validate},
{"invalid row column test", test_invalid_row_column_validate},
CU_TEST_INFO_NULL,
};
CU_TestInfo box_validator_test_array[] = {
{"valid box valid puzzle test", test_valid_box_validate_valid_puzzle},
{"valid box invalid puzzle test", test_valid_box_validate_invalid_puzzle},
{"invalid box invalid puzzle test", test_invalid_box_validate_invalid_puzzle},
CU_TEST_INFO_NULL,
};
CU_SuiteInfo suites[] = {
{ "unique check tests", unique_check_initializer_setup, unique_check_initializer_teardown, unique_check_test_array },
{ "row column validator tests", row_column_validate_setup, row_column_validate_teardown, row_column_validator_test_array },
{ "box validator tests", box_validate_setup, box_validate_teardown, box_validator_test_array },
CU_SUITE_INFO_NULL,
};
CU_register_suites(suites);
CU_basic_run_tests();
CU_basic_set_mode(CU_BRM_VERBOSE);
CU_list_tests_to_file();
}
int main() {
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();
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, "test of init args", test_init_args))
|| (NULL == CU_add_test(pSuite, "test of term args", test_term_args))
) {
CU_cleanup_registry();
return CU_get_error();
}
/* Run all tests using the CUnit Basic interface */
CU_list_tests_to_file();
CU_automated_run_tests();
CU_cleanup_registry();
return CU_get_error();
}
int main(int argc, char *argv[])
{
int basic;
int console;
int automated;
/* parse the command line options */
while ((c = getopt(argc, argv, "abc")) != -1)
{
switch (c)
{
case 'a': /* basic mode */
basic = 1;
break;
case 'b': /* basic mode */
basic = 1;
break;
case 'c': /* run from command line */
console = 1;
break;
default: /* error, print usage */
usage(argv[0]);
return -1;
}
}
if (CU_initialize_registry())
{
fprintf(stderr, "\nInitialization of Test Registry failed.\n");
exit(EXIT_FAILURE);
}
else
{
AddTests();
// set up the run mode and run the tests
if (automated)
{
CU_set_output_filename("TestOutput.xml");
CU_list_tests_to_file();
CU_automated_run_tests();
}
else if (basic)
{
CU_BasicRunMode mode = CU_BRM_VERBOSE;
CU_ErrorAction error_action = CUEA_IGNORE;
CU_basic_set_mode(mode);
CU_set_error_action(error_action);
CU_basic_run_tests();
}
else if (console)
{
CU_console_run_tests();
}
CU_cleanup_registry();
}
return 0;
}
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;
}
void gradle_cunit_register() {
CU_TestInfo mobile_element_test_array[] = { { "mobile element case 1",
test_mobile_element_state_1 }, { "mobile element case 2",
test_mobile_element_state_2 }, { "mobile element case 3",
test_mobile_element_state_3 }, { "mobile element case 4",
test_mobile_element_state_4 }, { "mobile element case 5",
test_mobile_element_state_5 }, { "mobile element case 6",
test_mobile_element_state_6 }, CU_TEST_INFO_NULL, };
CU_TestInfo generate_permutation_and_update_index_test_array[] = { {
"generate permutation and update index case 1",
test_generate_permutation_and_update_index_state_1 }, {
"generate permutation and update index case 2",
test_generate_permutation_and_update_index_state_2 }, {
"generate permutation and update index case 3",
test_generate_permutation_and_update_index_state_3 }, {
"generate permutation and update index case 4",
test_generate_permutation_and_update_index_state_4 }, {
"generate permutation and update index case 5",
test_generate_permutation_and_update_index_state_5 },
CU_TEST_INFO_NULL, };
CU_TestInfo initialize_record_test_array[] = { { "initialize_record",
test_initialize_record }, CU_TEST_INFO_NULL, };
CU_TestInfo update_direction_test_array[] = { { "update direction case 1",
test_update_direction_case_1 }, { "update direction case 2",
test_update_direction_case_2 }, CU_TEST_INFO_NULL, };
CU_TestInfo save_permutation_test_array[] = { {
"save permutation in storage", test_save_permutation }, {
"verify saving permutation in storage does not override older one",
test_adding_another_permutation_will_retain_older_one },
CU_TEST_INFO_NULL, };
CU_SuiteInfo suites[] = { { "mobile element tests",
mobile_element_setup_suite, mobile_element_teardown_suite,
mobile_element_test_array }, {
"generate permutation and update index tests",
test_generate_permutation_and_update_index_setup,
test_generate_permutation_and_update_index_teardown,
generate_permutation_and_update_index_test_array }, {
"mobile element tests", initialize_record_setup,
initialize_record_teardown, initialize_record_test_array }, {
"update direction tests", update_direction_setup,
update_direction_teardown, update_direction_test_array }, {
"save permutation tests", save_permutation_setup,
save_permutation_teardown, save_permutation_test_array },
CU_SUITE_INFO_NULL, };
CU_register_suites(suites);
CU_basic_set_mode (CU_BRM_VERBOSE);
CU_basic_run_tests();
CU_list_tests_to_file();
}
int main( int argc, char *argv[] ) {
if(CU_initialize_registry()) {
fprintf(stderr, " Initialization of Test Registry failed. ");
exit(EXIT_FAILURE);
}else{
AddTests();
CU_set_output_filename("Test single");
CU_list_tests_to_file();
CU_automated_run_tests();
CU_cleanup_registry();
}
return 0;
}
int automatedTest(int argc, char* argv[])
{
CU_BOOL Run = CU_FALSE ;
setvbuf(stdout, NULL, _IONBF, 0);
if (argc > 1) {
if (!strcmp("-i", argv[1])) {
Run = CU_TRUE ;
CU_set_error_action(CUEA_IGNORE);
}
else if (!strcmp("-f", argv[1])) {
Run = CU_TRUE ;
CU_set_error_action(CUEA_FAIL);
}
else if (!strcmp("-A", argv[1])) {
Run = CU_TRUE ;
CU_set_error_action(CUEA_ABORT);
}
// else if (!strcmp("-e", argv[1])) {
// print_example_results();
// }
else {
printf("\nUsage: AutomatedTest [option]\n\n"
" Options: -i Run, ignoring framework errors [default].\n"
" -f Run, failing on framework error.\n"
" -A Run, aborting on framework error.\n"
// " -e Print expected test results and exit.\n"
" -h Print this message.\n\n");
}
}
else {
Run = CU_TRUE;
CU_set_error_action(CUEA_IGNORE);
}
if (CU_TRUE == Run) {
if (CU_initialize_registry()) {
printf("\nInitialization of Test Registry failed.");
}
else {
AddTests();
CU_set_output_filename("TestAutomated");
CU_list_tests_to_file();
CU_automated_run_tests();
CU_cleanup_registry();
}
}
return 0;
}
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();
}
return;
}
}
void contact_provider_test_run()
{
if (CU_initialize_registry())
{
return;
}
else
{
contact_provider_add_tests();
CU_set_output_filename("contact_provider_test_output");
CU_list_tests_to_file();
int main()
{
if (CU_initialize_registry()) {
printf("\nInitialization of Test Registry failed.");
}else{
LOG_FILE_OPEN("log.txt");
AddTests();
/*******Automated Mode(best)*********************
* CU_set_output_filename("TestAutomated");
* CU_list_tests_to_file();
* CU_automated_run_tests();
******************************************/
CU_set_output_filename("TestAutomated");
CU_list_tests_to_file();
CU_automated_run_tests();
/*******Basic Mode*********************
* mode can choose:
* typedef enum {
* CU_BRM_NORMAL = 0, Normal mode - failures and run summary are printed [default].
* CU_BRM_SILENT, Silent mode - no output is printed except framework error messages.
* CU_BRM_VERBOSE Verbose mode - maximum output of run details.
* } CU_BasicRunMode;
****************************************
*
* CU_basic_set_mode(CU_BRM_NORMAL);
* CU_basic_run_tests();
******************************************/
/*******Console Mode*********************
* CU_console_run_tests();
******************************************/
/*******Curses Mode*********************
* CU_curses_run_tests();
******************************************/
CU_cleanup_registry();
}
LOG_FILE_CLOSE();
return 0;
}
int main(void) {
CU_initialize_registry();
suite_Utility();
suite_CcnClient();
suite_SeqNum();
suite_NdnlpPkt();
suite_MsgSlicer();
suite_PartialMsg();
suite_SentPkt();
suite_Link();
CU_automated_run_tests();
CU_list_tests_to_file();
CU_cleanup_registry();
return 0;
}
int main( int argc, char *argv[] )
{
printf("test start\n");
if(CU_initialize_registry()){
fprintf(stderr, "\nInitialization of Test Registry failed.\n");
exit(EXIT_FAILURE);
}else{
AddTests();
CU_set_output_filename("ununpack");
CU_list_tests_to_file();
CU_automated_run_tests();
CU_cleanup_registry();
}
printf("end\n");
return 0;
}
/*
* Set up and run tests.
*
* @return CUE_SUCCESS if successful, else a CUnit error code if
* any problems arise.
*/
int main()
{
if (CUE_SUCCESS != CU_initialize_registry())
{
return CU_get_error();
}
CU_pSuite suite =
CU_add_suite("Fibonacci Suite", initialise_suite, cleanup_suite);
if (NULL == suite)
{
CU_cleanup_registry();
return CU_get_error();
}
if ((NULL == CU_add_test(suite, "test_fibonacci_1", test_fibonacci_1)) ||
(NULL == CU_add_test(suite, "test_fibonacci_2", test_fibonacci_2)) ||
(NULL == CU_add_test(suite, "test_fibonacci_3", test_fibonacci_3)) ||
(NULL == CU_add_test(suite, "test_fibonacci_30", test_fibonacci_30)))
{
CU_cleanup_registry();
return CU_get_error();
}
// Run all tests using CUnit Basic interface which outputs
// results to command-line.
CU_basic_set_mode(CU_BRM_VERBOSE);
CU_basic_run_tests();
// Run all tests using CUnit Automated interface which outputs
// results to a file, default name CUnitAutomated-Results.xml.
// DTD CUnit-Run.dtd and and XSL stylesheet CUnit-Run.xsl in Share/
// Uncomment this line to override default output file prefix.
// CU_set_output_filename("Test");
CU_list_tests_to_file();
// Output listing of tests in suites to a file, default name
// CUnitAutomated-Listing.xml
// DTD CUnit-List.dtd and and XSL stylesheet CUnit-List.xsl in Share/
CU_automated_run_tests();
CU_cleanup_registry();
return CU_get_error();
}
int main (int argc, char** argv) {
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", setup, NULL);
if (NULL == pSuite) {
CU_cleanup_registry();
return CU_get_error();
}
/* add the tests to the suite */
if (NULL == CU_add_test(pSuite, "Map Creation Test", test_hashMap_create)
|| NULL == CU_add_test(pSuite, "Map Size Test", test_hashMap_size)
|| NULL == CU_add_test(pSuite, "Map Is Empty Test", test_hashMap_isEmpty)
|| NULL == CU_add_test(pSuite, "Map Get Test", test_hashMap_get)
|| NULL == CU_add_test(pSuite, "Map Contains Key Test", test_hashMap_containsKey)
|| NULL == CU_add_test(pSuite, "Map Get Entry Test", test_hashMap_getEntry)
|| NULL == CU_add_test(pSuite, "Map Put Test", test_hashMap_put)
|| NULL == CU_add_test(pSuite, "Map Resize Test", test_hashMap_resize)
|| NULL == CU_add_test(pSuite, "Map Remove Test", test_hashMap_remove)
|| NULL == CU_add_test(pSuite, "Map Remove Mapping Test", test_hashMap_removeMapping)
|| NULL == CU_add_test(pSuite, "Map Clear Test", test_hashMap_clear)
|| NULL == CU_add_test(pSuite, "Map Contains Value Test", test_hashMap_containsValue)
|| NULL == CU_add_test(pSuite, "Map To Array Test", test_hashMapValues_toArray)
)
{
CU_cleanup_registry();
return CU_get_error();
}
CU_set_output_filename(argv[1]);
CU_list_tests_to_file();
CU_automated_run_tests();
CU_cleanup_registry();
return CU_get_error();
}
int main(int argc, char **argv)
{
/* 初始化CUnit框架 */
if(CU_initialize_registry()){
fprintf(stderr, " Initialization of Test Registry failed\n");
exit(EXIT_FAILURE);
}
/* 添加测试suite和test */
/* ------------------ 需要添加修改 ------------------------ */
test_maxi_AddSuites();
test_mini_AddSuites();
/* -------------------------------------------------------- */
/* 设置输出模式 start */
#if 0 // Automated
CU_set_output_filename("TestMax");
CU_list_tests_to_file();
CU_automated_run_tests();
#endif
#if 1 //basic
CU_basic_set_mode(CU_BRM_VERBOSE);
CU_basic_run_tests();
#endif
#if 0 //Console
CU_console_run_tests();
#endif
#if 0 // Curses
CU_curses_run_tests();
#endif
/* 设置输出接口 end */
/* 清理CUnit框架 */
CU_cleanup_registry();
return 0;
}
int main (int argc, char** argv) {
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", setup, NULL);
if (NULL == pSuite) {
CU_cleanup_registry();
return CU_get_error();
}
/* add the tests to the suite */
if (NULL == CU_add_test(pSuite, "Array List Creation Test", test_arrayList_create)
|| NULL == CU_add_test(pSuite, "Array List Trim Test", test_arrayList_trimToSize)
|| NULL == CU_add_test(pSuite, "Array List Capacity Test", test_arrayList_ensureCapacity)
|| NULL == CU_add_test(pSuite, "Array List Size Test", test_arrayList_size)
|| NULL == CU_add_test(pSuite, "Array List Is Empty Test", test_arrayList_isEmpty)
|| NULL == CU_add_test(pSuite, "Array List Contains Test", test_arrayList_contains)
|| NULL == CU_add_test(pSuite, "Array List Index Of Test", test_arrayList_indexOf)
|| NULL == CU_add_test(pSuite, "Array List Get Test", test_arrayList_get)
|| NULL == CU_add_test(pSuite, "Array List Set Test", test_arrayList_set)
|| NULL == CU_add_test(pSuite, "Array List Add Test", test_arrayList_add)
|| NULL == CU_add_test(pSuite, "Array List Remove Test", test_arrayList_remove)
|| NULL == CU_add_test(pSuite, "Array List Remove Element Test", test_arrayList_removeElement)
|| NULL == CU_add_test(pSuite, "Array List Clear Test", test_arrayList_clear)
|| NULL == CU_add_test(pSuite, "Array List Add All", test_arrayList_addAll)
)
{
CU_cleanup_registry();
return CU_get_error();
}
CU_set_output_filename(argv[1]);
CU_list_tests_to_file();
CU_automated_run_tests();
CU_cleanup_registry();
return CU_get_error();
}
int main( int argc, char *argv[] )
{
int failed = 0;
gtk_set_locale ();
gtk_init (&argc, &argv);
if( CU_initialize_registry() )
{
g_critical( "Initialization of Test Registry failed." );
return EXIT_FAILURE;
}
register_all_tests();
CU_set_output_filename( "TestsResult" );
CU_list_tests_to_file();
CU_automated_run_tests();
/*CU_console_run_tests();*/
failed = CU_get_number_of_tests_failed();
CU_cleanup_registry();
if( failed == 0 )
return EXIT_SUCCESS;
return EXIT_FAILURE;
}
int main (int argc, char *argv []) {
CK_SLOT_ID slotlist [2];
CK_ULONG slotcount = 2;
CU_pSuite st [4];
int opt;
int todo;
extern char *optarg;
/*
* Test arguments.
*/
todo = 1;
while (todo && (opt = getopt_long (argc, argv, opts, longopts, NULL))) {
switch (opt) {
case 'p': // --pin
storepin ("user", optarg, ascii_pin_user, sizeof (ascii_pin_user) - 1);
break;
case 'P': // --so-pin
storepin ("SO", optarg, ascii_pin_so, sizeof (ascii_pin_so) - 1);
break;
case 'l': // --pkcs1llib
if (p11) {
fprintf (stderr, "You should not open multiple PKCS #11 libraries\n");
exit (1);
}
p11 = dlopen (optarg, RTLD_NOW | RTLD_GLOBAL);
if (!p11) {
fprintf (stderr, "%s\n", dlerror ());
exit (1);
}
break;
case 'X': // --destructive
if (destructive) {
fprintf (stderr, "You should not specify your destructive wishes more than once\n");
exit (1);
}
destructive = 1;
break;
case 'f': // --fast-and-frivolous
if (thousands < 1000) {
fprintf (stderr, "You should not specify the fast option more than once\n");
exit (1);
}
thousands = 10;
hundred = 8;
couple = 3;
break;
case 'v': // --verbose
if (optarg) {
verbosity = atoi (optarg);
if (verbosity < 0) {
fprintf (stderr, "You should not specify negative verbosity levels\n");
exit (1);
}
} else {
verbosity++;
}
break;
case 1: // --test-initiation
if (skip_initiation == 0) {
fprintf (stderr, "You should not specify --test-initiation more than once\n");
exit (1);
}
skip_initiation = 0;
break;
case 2: // --skip-fragmentation
if (skip_fragmentation) {
fprintf (stderr, "You should not specify --skip-fragmentation more than once\n");
exit (1);
}
skip_fragmentation = 1;
break;
case 3: // --skip-keysizing
if (skip_keysizing) {
fprintf (stderr, "You should not specify --skip-keysizing more than once\n");
exit (1);
}
skip_keysizing = 1;
break;
case 4: // --skip-signing
if (skip_signing) {
fprintf (stderr, "You should not specify --skip-signing more than once\n");
exit (1);
}
skip_signing = 1;
break;
// case 't':
// Token?
case -1: // Done -- but are we, really?
if ((*ascii_pin_user) && (*ascii_pin_so) && p11) {
todo = 0;
break;
}
// else continue...
fprintf (stderr, "Please set all values required.\n");
case 'h':
case ':':
case '?':
fprintf (stderr, "Minimal usage: %s --pin 1234 --so-pin 4321 --pkcs11lib /path/to/libpkcs11.so\n", argv [0]);
exit (opt != 'h');
}
}
/*
* Register test suites and tests.
*/
if (CU_initialize_registry () != CUE_SUCCESS) {
fprintf (stderr, "Failed to initialise test registry -- this is abnormal\n");
exit (1);
} else {
cu_open = 1;
}
st [0] = CU_add_suite ("Test if slot initiation works properly", NULL, NULL);
st [1] = CU_add_suite ("Test if memory does not get fragmented", NULL, NULL);
st [2] = CU_add_suite ("Test if key sizes work as desired", NULL, NULL);
st [3] = CU_add_suite ("Test if signatures are made correctly", NULL, NULL);
if (! (st [0] && st [1] && st [2] && st [3])) {
fprintf (stderr, "Failed to allocate all test suites -- this is abnormal\n");
exit (1);
}
if (! skip_initiation) {
if (! CU_add_test (st [0], "Initiation test", testslot_initiation)) {
fprintf (stderr, "Failed to register test #0 -- this is abnormal\n");
exit (1);
}
}
if (! skip_fragmentation) {
if (! CU_add_test (st [1], "Fragmentation test", testslot_fragmentation)) {
fprintf (stderr, "Failed to register test #1 -- this is abnormal\n");
exit (1);
}
}
if (! skip_keysizing) {
if (! CU_add_test (st [2], "Key sizing test", testslot_keysizing)) {
fprintf (stderr, "Failed to register test #2 -- this is abnormal\n");
exit (1);
}
}
if (! skip_signing) {
if (! CU_add_test (st [3], "Signing test", testslot_signing)) {
fprintf (stderr, "Failed to register test #3 -- this is abnormal\n");
exit (1);
}
}
/*
* Initialise the library and demand only one slot with a token.
*/
TESTRV ("Initialising PKCS #11 library",
P11("C_Initialize") (NULL_PTR));
MKFATAL ();
atexit (bailout);
TESTRV ("Obtaining list of slots",
P11("C_GetSlotList") (TRUE, slotlist, &slotcount));
if (slotcount != 1) {
fprintf (stderr, "Number of slots is %d, so not equal to 1 -- unsure which to test\n", (int) slotcount);
exit (1);
}
slotid = slotlist [0];
/*
* Obtain mechanism information from the token.
*/
TESTRV ("Getting number of mechanisms from token",
P11("C_GetMechanismInfo") (slotid, CKM_RSA_PKCS_KEY_PAIR_GEN, &mech_rsa_pkcs_key_pair_gen));
MKFATAL ();
TESTRV ("Getting number of mechanisms from token",
P11("C_GetMechanismInfo") (slotid, CKM_RSA_PKCS, &mech_rsa_pkcs));
MKFATAL ();
/*
TESTRV ("Getting number of mechanisms from token",
P11("C_GetMechanismInfo") (slotid, CKM_SHA_1, &mech_sha_1));
MKFATAL ();
*/
/*
* Format the token and run a test.
* Do we need an "are you sure?" warning here?
*/
if (strlen (TOKENLABEL_32CHARS) != 32) {
CU_FAIL_FATAL ("Token labels must be 32 characters long -- fix TOKENLABEL_32CHARS and recompile");
}
/*
* Automatically run all the tests that were registered
*/
if (verbosity >= 1) {
printf ("Beginning test sequence\n");
}
CU_list_tests_to_file ();
CU_automated_run_tests ();
if (verbosity >= 1) {
printf ("Ended test sequence\n");
}
/*
* Unload the PKCS #11 library
*/
if (p11) {
dlclose (p11);
p11 = NULL;
}
/*
* Terminate without error-reporting return value.
*/
if (cu_open) {
CU_cleanup_registry ();
cu_open = 0;
}
exit (0);
}
int main(int argc, char * argv[]) {
bool list = false, help = false;
const char * output = "CUnitAutomated";
const struct option longopts[] = {
{ "list", no_argument, (int *)&list, (int)true },
{ "output", required_argument, NULL, 'o' },
{ "help", no_argument, (int *)&help, (int)true },
{ NULL, 0, NULL, 0 }
};
opterr = 0;
int c, longindex;
while ((c = getopt_long(argc, argv, ":lo:h", longopts, &longindex)) != -1) {
switch (c) {
case 'l':
list = true;
break;
case 'o':
output = optarg;
break;
case 'h':
help = true;
break;
case ':':
fprintf(stderr, "Missing argument for option '%c'\n", optopt);
return -1;
case '?':
fprintf(stderr, "Unknown option '%c'\n", optopt);
return -1;
}
}
if (help) {
printf("Usage: %s [-l|--list] [-o|--output=<template>] [-h|--help]\n", argv[0]);
puts("Where:");
puts(" -l|--list lists the tests to a file (default \"CUnitAutomated-Listing.xml\")");
puts(" -o|--output sets the filename template to use (tests are listed in "
"\"<template>-Listing.xml\" while results are placed in \"<template>-Results.xml\")");
puts(" -h|--help displays this message");
return 0;
}
CU_ERROR_CHECK(CU_initialize_registry());
CU_ERROR_CHECK(CU_register_suites((CU_SuiteInfo *)suites));
CU_set_output_filename(output);
if (list) {
CU_ERROR_CHECK(CU_list_tests_to_file());
return 0;
}
CU_automated_run_tests();
unsigned int failures = CU_get_number_of_failures();
CU_cleanup_registry();
return (int)failures;
}
/* 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 xml = 0;
int con = 0;
CU_pFailureRecord fr;
int i;
if (argc >= 2 && !strcmp(argv[1], "-xml")) {
xml = 1;
} else if (argc >= 2 && !strcmp(argv[1], "-con")) {
con = 1;
}
#ifdef HAVE_CUNIT
int rv;
#ifndef WIN32
struct sigaction sig_act;
/*
* Indicate that the broken pipe signal during writes should be
* ignored
*/
memset(&sig_act, 0, sizeof(struct sigaction));
sig_act.sa_handler = SIG_IGN;
sigemptyset(&sig_act.sa_mask);
if (sigaction(SIGPIPE, &sig_act, NULL) == -1) {
printf("\nCannot set ignore action for SIGPIPE\n");
}
#endif
est_apps_startup();
/*
* Install thread locking mechanism for OpenSSL
*/
mutex_buf = malloc(CRYPTO_num_locks() * sizeof(MUTEX_TYPE));
if (!mutex_buf) {
printf("Cannot allocate mutexes");
exit(1);
}
for (i = 0; i < CRYPTO_num_locks(); i++)
MUTEX_SETUP(mutex_buf[i]);
CRYPTO_set_id_callback(id_function);
CRYPTO_set_locking_callback(locking_function);
/* initialize the CUnit test registry */
if (CUE_SUCCESS != CU_initialize_registry()) {
return CU_get_error();
}
#ifdef ENABLE_ALL_SUITES
rv = us748_add_suite();
if (rv != CUE_SUCCESS) {
printf("\nFailed to add test suite for US748 (%d)", rv);
exit(1);
}
#endif
#ifdef ENABLE_ALL_SUITES
rv = us893_add_suite();
if (rv != CUE_SUCCESS) {
printf("\nFailed to add test suite for US893 (%d)", rv);
exit(1);
}
#endif
#ifdef ENABLE_ALL_SUITES
rv = us894_add_suite();
if (rv != CUE_SUCCESS) {
printf("\nFailed to add test suite for US894 (%d)", rv);
exit(1);
}
#endif
#ifdef ENABLE_ALL_SUITES
rv = us895_add_suite();
if (rv != CUE_SUCCESS) {
printf("\nFailed to add test suite for US895 (%d)", rv);
exit(1);
}
#endif
#ifdef ENABLE_ALL_SUITES
rv = us896_add_suite();
if (rv != CUE_SUCCESS) {
printf("\nFailed to add test suite for US896 (%d)", rv);
exit(1);
}
#endif
#ifdef ENABLE_ALL_SUITES
rv = us897_add_suite();
if (rv != CUE_SUCCESS) {
printf("\nFailed to add test suite for US897 (%d)", rv);
exit(1);
}
#endif
#ifdef ENABLE_ALL_SUITES
rv = us898_add_suite();
if (rv != CUE_SUCCESS) {
printf("\nFailed to add test suite for US898 (%d)", rv);
exit(1);
}
#endif
#ifdef ENABLE_ALL_SUITES
rv = us899_add_suite();
if (rv != CUE_SUCCESS) {
printf("\nFailed to add test suite for US899 (%d)", rv);
exit(1);
}
#endif
#ifdef ENABLE_ALL_SUITES
rv = us900_add_suite();
if (rv != CUE_SUCCESS) {
printf("\nFailed to add test suite for US900 (%d)", rv);
exit(1);
}
#endif
#ifdef ENABLE_ALL_SUITES
rv = us901_add_suite();
if (rv != CUE_SUCCESS) {
printf("\nFailed to add test suite for US901 (%d)", rv);
exit(1);
}
#endif
#ifdef ENABLE_ALL_SUITES
rv = us902_add_suite();
if (rv != CUE_SUCCESS) {
printf("\nFailed to add test suite for US902 (%d)", rv);
exit(1);
}
#endif
#ifdef ENABLE_ALL_SUITES
rv = us903_add_suite();
if (rv != CUE_SUCCESS) {
printf("\nFailed to add test suite for US903 (%d)", rv);
exit(1);
}
#endif
#ifdef ENABLE_ALL_SUITES
rv = us1005_add_suite();
if (rv != CUE_SUCCESS) {
printf("\nFailed to add test suite for US1005 (%d)", rv);
exit(1);
}
#endif
#if (DISABLE_SUITE != 0)
rv = us1060_add_suite();
if (rv != CUE_SUCCESS) {
printf("\nFailed to add test suite for US1060 (%d)", rv);
exit(1);
}
#endif
#ifdef ENABLE_ALL_SUITES
rv = us1060c_add_suite();
if (rv != CUE_SUCCESS) {
printf("\nFailed to add test suite for US1060c (%d)", rv);
exit(1);
}
#endif
#ifdef ENABLE_ALL_SUITES
rv = us1159_add_suite();
if (rv != CUE_SUCCESS) {
printf("\nFailed to add test suite for US1159 (%d)", rv);
exit(1);
}
#endif
#ifdef ENABLE_ALL_SUITES
rv = us1190_add_suite();
if (rv != CUE_SUCCESS) {
printf("\nFailed to add test suite for US1190 (%d)", rv);
exit(1);
}
#endif
#ifdef ENABLE_ALL_SUITES
rv = us1864_add_suite();
if (rv != CUE_SUCCESS) {
printf("\nFailed to add test suite for US1864 (%d)", rv);
exit(1);
}
#endif
#ifdef ENABLE_ALL_SUITES
rv = us1883_add_suite();
if (rv != CUE_SUCCESS) {
printf("\nFailed to add test suite for US1883 (%d)", rv);
exit(1);
}
#endif
#ifdef ENABLE_ALL_SUITES
rv = us1884_add_suite();
if (rv != CUE_SUCCESS) {
printf("\nFailed to add test suite for US1884 (%d)", rv);
exit(1);
}
#endif
#ifdef ENABLE_ALL_SUITES
rv = us2174_add_suite();
if (rv != CUE_SUCCESS) {
printf("\nFailed to add test suite for US2174 (%d)", rv);
exit(1);
}
#endif
#ifdef ENABLE_ALL_SUITES
rv = us3496_add_suite();
if (rv != CUE_SUCCESS) {
printf("\nFailed to add test suite for US3496 (%d)", rv);
exit(1);
}
#endif
#ifdef ENABLE_ALL_SUITES
rv = us3512_add_suite();
if (rv != CUE_SUCCESS) {
printf("\nFailed to add test suite for US3512 (%d)", rv);
exit(1);
}
#endif
#ifdef ENABLE_ALL_SUITES
rv = us3612_add_suite();
if (rv != CUE_SUCCESS) {
printf("\nFailed to add test suite for US3612 (%d)", rv);
exit(1);
}
#endif
#ifdef ENABLE_ALL_SUITES
rv = us4020_add_suite();
if (rv != CUE_SUCCESS) {
printf("\nFailed to add test suite for US4020 (%d)", rv);
exit(1);
}
#endif
if (xml) {
/* Run all test using automated interface, which
* generates XML output */
CU_list_tests_to_file();
CU_automated_run_tests();
}
else if (con) {
CU_console_run_tests();
}
else {
/* Run all tests using the CUnit Basic interface,
* which generates text output */
CU_basic_set_mode(CU_BRM_VERBOSE);
CU_basic_run_tests();
fr = CU_get_failure_list();
if (fr) {
printf("\n\nHere is a summary of the failed test cases:\n");
CU_basic_show_failures(fr);
}
}
/*
* Tear down the mutexes used by OpenSSL
*/
if (!mutex_buf)
return 0;
CRYPTO_set_id_callback(NULL);
CRYPTO_set_locking_callback(NULL);
for (i = 0; i < CRYPTO_num_locks(); i++)
MUTEX_CLEANUP(mutex_buf[i]);
free(mutex_buf);
mutex_buf = NULL;
CU_cleanup_registry();
est_apps_shutdown();
return CU_get_error();
#else
printf("\nlibcunit not installed, unit test are not enabled\n");
#endif
}
int
main(int argc, char *argv[])
{
char *testname_re = NULL;
CU_BasicRunMode mode = CU_BRM_VERBOSE;
CU_ErrorAction error_action = CUEA_IGNORE;
int res;
struct scsi_readcapacity10 *rc10;
struct scsi_task *inq_task = NULL;
struct scsi_task *inq_lbp_task = NULL;
struct scsi_task *inq_bdc_task = NULL;
struct scsi_task *inq_bl_task = NULL;
struct scsi_task *rc16_task = NULL;
struct scsi_task *rsop_task = NULL;
int full_size;
int xml_mode = 0;
static struct option long_opts[] = {
{ "help", no_argument, 0, '?' },
{ "list", no_argument, 0, 'l' },
{ "initiator-name", required_argument, 0, 'i' },
{ "initiator-name-2", required_argument, 0, 'I' },
{ "test", required_argument, 0, 't' },
{ "dataloss", no_argument, 0, 'd' },
{ "allow-sanitize", no_argument, 0, 'S' },
{ "ignore", no_argument, 0, 'g' },
{ "fail", no_argument, 0, 'f' },
{ "abort", no_argument, 0, 'A' },
{ "silent", no_argument, 0, 's' },
{ "normal", no_argument, 0, 'n' },
{ "verbose", no_argument, 0, 'v' },
{ "xml", no_argument, 0, 'x' },
{ "Verbose-scsi", no_argument, 0, 'V' },
{ NULL, 0, 0, 0 }
};
int i, c;
int opt_idx = 0;
while ((c = getopt_long(argc, argv, "?hli:I:t:sdgfAsSnvxV", long_opts,
&opt_idx)) > 0) {
switch (c) {
case 'h':
case '?':
print_usage();
return 0;
case 'l':
list_all_tests();
return 0;
case 'i':
initiatorname1 = strdup(optarg);
break;
case 'I':
initiatorname2 = strdup(optarg);
break;
case 't':
testname_re = strdup(optarg);
break;
case 'd':
data_loss++;
break;
case 'g':
error_action = CUEA_IGNORE; /* default */
break;
case 'f':
error_action = CUEA_FAIL;
break;
case 'A':
error_action = CUEA_ABORT;
break;
case 's':
mode = CU_BRM_SILENT;
break;
case 'S':
allow_sanitize = 1;
break;
case 'n':
mode = CU_BRM_NORMAL;
break;
case 'v':
mode = CU_BRM_VERBOSE; /* default */
break;
case 'x':
xml_mode = 1;
break;
case 'V':
loglevel = LOG_VERBOSE;
break;
default:
fprintf(stderr,
"error: unknown option return: %c (option %s)\n",
c, argv[optind]);
return 1;
}
}
/* parse all trailing arguments as device paths */
mp_num_sds = 0;
while (optind < argc) {
if (mp_num_sds >= MPATH_MAX_DEVS) {
fprintf(stderr, "Too many multipath device URLs\n");
print_usage();
free(testname_re);
return 10;
}
mp_sds[mp_num_sds] = malloc(sizeof(struct scsi_device));
memset(mp_sds[mp_num_sds], '\0', sizeof(struct scsi_device));
mp_sds[mp_num_sds]->sgio_fd = -1;
if (!strncmp(argv[optind], "iscsi://", 8)) {
mp_sds[mp_num_sds]->iscsi_url = strdup(argv[optind++]);
#ifdef HAVE_SG_IO
} else {
mp_sds[mp_num_sds]->sgio_dev = strdup(argv[optind++]);
#endif
}
mp_num_sds++;
}
/* So that we can override iscsi_queue_pdu in tests
* and replace or mutate the blob that we are about to write to the
* wire.
* This allows such tests to do their mutates and then call out
* to the real queueing function once they have modified the data.
*/
real_iscsi_queue_pdu = dlsym(RTLD_NEXT, "iscsi_queue_pdu");
if ((mp_num_sds == 0) || (mp_sds[0]->iscsi_url == NULL
&& mp_sds[0]->sgio_dev == NULL)) {
#ifdef HAVE_SG_IO
fprintf(stderr, "You must specify either an iSCSI URL or a device file\n");
#else
fprintf(stderr, "You must specify an iSCSI URL\n");
#endif
print_usage();
if (testname_re)
free(testname_re);
return 10;
}
/* sd remains an alias for the first device */
sd = mp_sds[0];
for (i = 0; i < mp_num_sds; i++) {
res = connect_scsi_device(mp_sds[i], initiatorname1);
if (res < 0) {
fprintf(stderr,
"Failed to connect to SCSI device %d\n", i);
goto err_sds_free;
}
}
if (mp_num_sds > 1) {
/* check that all multipath sds identify as the same LU */
res = mpath_check_matching_ids(mp_num_sds, mp_sds);
if (res < 0) {
fprintf(stderr, "multipath devices don't match\n");
goto err_sds_free;
}
}
/*
* find the size of the LUN
* All devices support readcapacity10 but only some support
* readcapacity16
*/
task = NULL;
readcapacity10(sd, &task, 0, 0, EXPECT_STATUS_GOOD);
if (task == NULL) {
printf("Failed to send READCAPACITY10 command: %s\n", sd->error_str);
goto err_sds_free;
}
if (task->status != SCSI_STATUS_GOOD) {
printf("READCAPACITY10 command: failed with sense. %s\n", sd->error_str);
scsi_free_scsi_task(task);
goto err_sds_free;
}
rc10 = scsi_datain_unmarshall(task);
if (rc10 == NULL) {
printf("failed to unmarshall READCAPACITY10 data.\n");
scsi_free_scsi_task(task);
goto err_sds_free;
}
block_size = rc10->block_size;
num_blocks = rc10->lba + 1;
scsi_free_scsi_task(task);
rc16_task = NULL;
readcapacity16(sd, &rc16_task, 96, EXPECT_STATUS_GOOD);
if (rc16_task == NULL) {
printf("Failed to send READCAPACITY16 command: %s\n", sd->error_str);
goto err_sds_free;
}
if (rc16_task->status == SCSI_STATUS_GOOD) {
rc16 = scsi_datain_unmarshall(rc16_task);
if (rc16 == NULL) {
printf("failed to unmarshall READCAPACITY16 data. %s\n", sd->error_str);
scsi_free_scsi_task(rc16_task);
goto err_sds_free;
}
block_size = rc16->block_length;
num_blocks = rc16->returned_lba + 1;
lbppb = 1 << rc16->lbppbe;
}
inq_task = NULL;
inquiry(sd, &inq_task, 0, 0, 64, EXPECT_STATUS_GOOD);
if (inq_task == NULL || inq_task->status != SCSI_STATUS_GOOD) {
printf("Inquiry command failed : %s\n", sd->error_str);
goto err_sds_free;
}
full_size = scsi_datain_getfullsize(inq_task);
if (full_size > inq_task->datain.size) {
scsi_free_scsi_task(inq_task);
/* we need more data for the full list */
inq_task = NULL;
inquiry(sd, &inq_task, 0, 0, full_size, EXPECT_STATUS_GOOD);
if (inq_task == NULL) {
printf("Inquiry command failed : %s\n", sd->error_str);
goto err_sds_free;
}
}
inq = scsi_datain_unmarshall(inq_task);
if (inq == NULL) {
printf("failed to unmarshall inquiry datain blob\n");
scsi_free_scsi_task(inq_task);
goto err_sds_free;
}
sbc3_support = 0;
for (i = 0; i < 8; i++) {
if (inq->version_descriptor[i] == 0x04C0) {
sbc3_support = 1;
}
}
/* try reading block limits vpd */
inq_bl_task = NULL;
inquiry(sd, &inq_bl_task, 1, SCSI_INQUIRY_PAGECODE_BLOCK_LIMITS, 64, EXPECT_STATUS_GOOD);
if (inq_bl_task && inq_bl_task->status != SCSI_STATUS_GOOD) {
scsi_free_scsi_task(inq_bl_task);
inq_bl_task = NULL;
}
if (inq_bl_task) {
full_size = scsi_datain_getfullsize(inq_bl_task);
if (full_size > inq_bl_task->datain.size) {
scsi_free_scsi_task(inq_bl_task);
inq_bl_task = NULL;
inquiry(sd, &inq_bl_task, 1, SCSI_INQUIRY_PAGECODE_BLOCK_LIMITS, full_size,
EXPECT_STATUS_GOOD);
if (inq_bl_task == NULL) {
printf("Inquiry command failed : %s\n", sd->error_str);
goto err_sds_free;
}
}
inq_bl = scsi_datain_unmarshall(inq_bl_task);
if (inq_bl == NULL) {
printf("failed to unmarshall inquiry datain blob\n");
goto err_sds_free;
}
}
/* try reading block device characteristics vpd */
inquiry(sd, &inq_bdc_task, 1, SCSI_INQUIRY_PAGECODE_BLOCK_DEVICE_CHARACTERISTICS, 255,
EXPECT_STATUS_GOOD);
if (inq_bdc_task == NULL || inq_bdc_task->status != SCSI_STATUS_GOOD) {
printf("Failed to read Block Device Characteristics page\n");
} else {
inq_bdc = scsi_datain_unmarshall(inq_bdc_task);
if (inq_bdc == NULL) {
printf("failed to unmarshall inquiry datain blob\n");
goto err_sds_free;
}
}
/* if thin provisioned we also need to read the VPD page for it */
if (rc16 && rc16->lbpme != 0){
inq_lbp_task = NULL;
inquiry(sd, &inq_lbp_task, 1, SCSI_INQUIRY_PAGECODE_LOGICAL_BLOCK_PROVISIONING, 64,
EXPECT_STATUS_GOOD);
if (inq_lbp_task == NULL || inq_lbp_task->status != SCSI_STATUS_GOOD) {
printf("Inquiry command failed : %s\n", sd->error_str);
goto err_sds_free;
}
full_size = scsi_datain_getfullsize(inq_lbp_task);
if (full_size > inq_lbp_task->datain.size) {
scsi_free_scsi_task(inq_lbp_task);
/* we need more data for the full list */
inq_lbp_task = NULL;
inquiry(sd, &inq_lbp_task, 1, SCSI_INQUIRY_PAGECODE_LOGICAL_BLOCK_PROVISIONING,
full_size, EXPECT_STATUS_GOOD);
if (inq_lbp_task == NULL) {
printf("Inquiry command failed : %s\n", sd->error_str);
goto err_sds_free;
}
}
inq_lbp = scsi_datain_unmarshall(inq_lbp_task);
if (inq_lbp == NULL) {
printf("failed to unmarshall inquiry datain blob\n");
goto err_sds_free;
}
}
rsop_task = NULL;
report_supported_opcodes(sd, &rsop_task, 1, SCSI_REPORT_SUPPORTING_OPS_ALL, 0, 0, 65535,
EXPECT_STATUS_GOOD);
if (rsop_task == NULL) {
printf("Failed to send REPORT_SUPPORTED_OPCODES command: %s\n", sd->error_str);
goto err_sds_free;
}
if (rsop_task->status == SCSI_STATUS_GOOD) {
rsop = scsi_datain_unmarshall(rsop_task);
if (rsop == NULL) {
printf("failed to unmarshall REPORT_SUPPORTED_OPCODES data.\n");
scsi_free_scsi_task(rsop_task);
rsop_task = NULL;
}
}
/* check if the device is write protected or not */
task = NULL;
modesense6(sd, &task, 0, SCSI_MODESENSE_PC_CURRENT, SCSI_MODEPAGE_RETURN_ALL_PAGES, 0, 255,
EXPECT_STATUS_GOOD);
if (task == NULL) {
printf("Failed to send MODE_SENSE6 command: %s\n", sd->error_str);
goto err_sds_free;
}
if (task->status == SCSI_STATUS_GOOD) {
struct scsi_mode_sense *ms;
ms = scsi_datain_unmarshall(task);
if (ms == NULL) {
printf("failed to unmarshall mode sense datain blob\n");
scsi_free_scsi_task(task);
goto err_sds_free;
}
readonly = !!(ms->device_specific_parameter & 0x80);
}
scsi_free_scsi_task(task);
if (maxsectbytes) {
maximum_transfer_length = maxsectbytes / block_size;
printf("Bus transfer size is limited to %d bytes. Clamping "
"max transfers accordingly.\n", maxsectbytes);
}
if (CU_initialize_registry() != 0) {
fprintf(stderr, "error: unable to initialize test registry\n");
goto err_sds_free;
}
if (CU_is_test_running()) {
fprintf(stderr, "error: test suite(s) already running!?\n");
exit(1);
}
parse_and_add_tests(testname_re);
if (testname_re)
free(testname_re);
CU_basic_set_mode(mode);
CU_set_error_action(error_action);
printf("\n");
/*
* this actually runs the tests ...
*/
if (xml_mode) {
CU_list_tests_to_file();
CU_automated_run_tests();
} else {
res = CU_basic_run_tests();
printf("Tests completed with return value: %d\n", res);
}
CU_cleanup_registry();
if (inq_task != NULL) {
scsi_free_scsi_task(inq_task);
}
if (inq_bl_task != NULL) {
scsi_free_scsi_task(inq_bl_task);
}
if (inq_lbp_task != NULL) {
scsi_free_scsi_task(inq_lbp_task);
}
if (inq_bdc_task != NULL) {
scsi_free_scsi_task(inq_bdc_task);
}
if (rc16_task != NULL) {
scsi_free_scsi_task(rc16_task);
}
if (rsop_task != NULL) {
scsi_free_scsi_task(rsop_task);
}
for (i = 0; i < mp_num_sds; i++) {
free_scsi_device(mp_sds[i]);
}
return 0;
err_sds_free:
for (i = 0; i < mp_num_sds; i++) {
free_scsi_device(mp_sds[i]);
}
return -1;
}
/* 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[])
{
#ifdef HAVE_CUNIT
int xml = 0;
int con = 0;
CU_pFailureRecord fr;
int size;
int i;
int rv;
if (argc >= 2 && !strcmp(argv[1], "-xml")) {
xml = 1;
} else
if (argc >= 2 && !strcmp(argv[1], "-con")) {
con = 1;
}
est_apps_startup();
est_set_log_source(EST_CLIENT);
/*
* Install thread locking mechanism for OpenSSL
*/
size = sizeof(pthread_mutex_t) * CRYPTO_num_locks();
if ((ssl_mutexes = (pthread_mutex_t*)malloc((size_t)size)) == NULL) {
printf("Cannot allocate mutexes");
exit(1);
}
for (i = 0; i < CRYPTO_num_locks(); i++) {
pthread_mutex_init(&ssl_mutexes[i], NULL);
}
CRYPTO_set_locking_callback(&ssl_locking_callback);
CRYPTO_set_id_callback(&ssl_id_callback);
/* initialize the CUnit test registry */
if (CUE_SUCCESS != CU_initialize_registry()) {
return CU_get_error();
}
#define ADD(N) { extern int N##_add_suite(void); rv = N##_add_suite(); \
if (rv != CUE_SUCCESS) { fprintf(stderr, "Failed "#N"_add_suite (%d)\n", rv); exit(1); } }
ADD(us748);
ADD(us893);
ADD(us894);
ADD(us895);
ADD(us896);
ADD(us897);
ADD(us898);
ADD(us899);
ADD(us900);
ADD(us901);
ADD(us902);
ADD(us903);
ADD(us1005);
ADD(us1060);
ADD(us1159);
ADD(us1864);
ADD(us1883);
ADD(us1884);
ADD(us2174);
if (xml) {
/* Run all test using automated interface, which
* generates XML output */
CU_list_tests_to_file();
CU_automated_run_tests();
} else if (con) {
CU_console_run_tests();
} else {
/* Run all tests using the CUnit Basic interface,
* which generates text output */
#if 0
CU_basic_set_mode(CU_BRM_VERBOSE);
CU_basic_run_tests();
#else
CU_set_test_start_handler (test_start);
CU_set_test_complete_handler(test_complete);
CU_run_all_tests();
#endif
fr = CU_get_failure_list();
if (fr) {
fprintf(stderr, "\nHere is a summary of the failed test cases:\n");
print_failures(fr);
} else {
fprintf(stderr, "\nAll enabled tests passed.\n");
}
}
/*
* Tear down the mutexes used by OpenSSL
*/
CRYPTO_set_locking_callback(NULL);
for (i = 0; i < CRYPTO_num_locks(); i++) {
pthread_mutex_destroy(&ssl_mutexes[i]);
}
CRYPTO_set_locking_callback(NULL);
CRYPTO_set_id_callback(NULL);
free(ssl_mutexes);
CU_cleanup_registry();
est_apps_shutdown();
return CU_get_error();
#else
printf("\nlibcunit not installed, unit tests are not enabled\n");
return 255;
#endif
}
int
main(int argc, char *argv[])
{
char *testname_re = NULL;
int lun;
CU_BasicRunMode mode = CU_BRM_VERBOSE;
CU_ErrorAction error_action = CUEA_IGNORE;
int res;
struct scsi_readcapacity10 *rc10;
struct scsi_task *inq_task = NULL;
struct scsi_task *inq_lbp_task = NULL;
struct scsi_task *inq_bdc_task = NULL;
struct scsi_task *inq_bl_task = NULL;
struct scsi_task *rc16_task = NULL;
struct scsi_task *rsop_task = NULL;
int full_size;
int is_usb = 0;
int xml_mode = 0;
static struct option long_opts[] = {
{ "help", no_argument, 0, '?' },
{ "list", no_argument, 0, 'l' },
{ "initiator-name", required_argument, 0, 'i' },
{ "initiator-name-2", required_argument, 0, 'I' },
{ "test", required_argument, 0, 't' },
{ "dataloss", no_argument, 0, 'd' },
{ "allow-sanitize", no_argument, 0, 'S' },
{ "ignore", no_argument, 0, 'g' },
{ "fail", no_argument, 0, 'f' },
{ "abort", no_argument, 0, 'A' },
{ "silent", no_argument, 0, 's' },
{ "normal", no_argument, 0, 'n' },
{ "usb", no_argument, 0, 'u' },
{ "verbose", no_argument, 0, 'v' },
{ "xml", no_argument, 0, 'x' },
{ "Verbose-scsi", no_argument, 0, 'V' },
{ NULL, 0, 0, 0 }
};
int i, c;
int opt_idx = 0;
while ((c = getopt_long(argc, argv, "?hli:I:t:sdgfAsSnuvxV", long_opts,
&opt_idx)) > 0) {
switch (c) {
case 'h':
case '?':
print_usage();
return 0;
case 'l':
list_all_tests();
return 0;
case 'i':
initiatorname1 = strdup(optarg);
break;
case 'I':
initiatorname2 = strdup(optarg);
break;
case 't':
testname_re = strdup(optarg);
break;
case 'd':
data_loss++;
break;
case 'g':
error_action = CUEA_IGNORE; /* default */
break;
case 'f':
error_action = CUEA_FAIL;
break;
case 'A':
error_action = CUEA_ABORT;
break;
case 's':
mode = CU_BRM_SILENT;
break;
case 'S':
allow_sanitize = 1;
break;
case 'n':
mode = CU_BRM_NORMAL;
break;
case 'u':
is_usb = 1;
break;
case 'v':
mode = CU_BRM_VERBOSE; /* default */
break;
case 'x':
xml_mode = 1;
break;
case 'V':
loglevel = LOG_VERBOSE;
break;
default:
fprintf(stderr,
"error: unknown option return: %c (option %s)\n",
c, argv[optind]);
return 1;
}
}
if (optind < argc) {
tgt_url = strdup(argv[optind++]);
}
if (optind < argc) {
fprintf(stderr, "error: too many arguments\n");
print_usage();
return 1;
}
/* XXX why is this done? */
real_iscsi_queue_pdu = dlsym(RTLD_NEXT, "iscsi_queue_pdu");
if (tgt_url == NULL) {
fprintf(stderr, "You must specify the URL\n");
print_usage();
if (testname_re)
free(testname_re);
return 10;
}
iscsic = iscsi_context_login(initiatorname1, tgt_url, &lun);
if (iscsic == NULL) {
printf("Failed to login to target\n");
return -1;
}
/*
* find the size of the LUN
* All devices support readcapacity10 but only some support
* readcapacity16
*/
task = iscsi_readcapacity10_sync(iscsic, lun, 0, 0);
if (task == NULL) {
printf("Failed to send READCAPACITY10 command: %s\n",
iscsi_get_error(iscsic));
iscsi_destroy_context(iscsic);
return -1;
}
if (task->status != SCSI_STATUS_GOOD) {
printf("READCAPACITY10 command: failed with sense. %s\n",
iscsi_get_error(iscsic));
scsi_free_scsi_task(task);
iscsi_destroy_context(iscsic);
return -1;
}
rc10 = scsi_datain_unmarshall(task);
if (rc10 == NULL) {
printf("failed to unmarshall READCAPACITY10 data. %s\n",
iscsi_get_error(iscsic));
scsi_free_scsi_task(task);
iscsi_destroy_context(iscsic);
return -1;
}
block_size = rc10->block_size;
num_blocks = rc10->lba + 1;
scsi_free_scsi_task(task);
rc16_task = iscsi_readcapacity16_sync(iscsic, lun);
if (rc16_task == NULL) {
printf("Failed to send READCAPACITY16 command: %s\n",
iscsi_get_error(iscsic));
iscsi_destroy_context(iscsic);
return -1;
}
if (rc16_task->status == SCSI_STATUS_GOOD) {
rc16 = scsi_datain_unmarshall(rc16_task);
if (rc16 == NULL) {
printf("failed to unmarshall READCAPACITY16 data. %s\n",
iscsi_get_error(iscsic));
scsi_free_scsi_task(rc16_task);
iscsi_destroy_context(iscsic);
return -1;
}
block_size = rc16->block_length;
num_blocks = rc16->returned_lba + 1;
lbppb = 1 << rc16->lbppbe;
}
inq_task = iscsi_inquiry_sync(iscsic, lun, 0, 0, 64);
if (inq_task == NULL || inq_task->status != SCSI_STATUS_GOOD) {
printf("Inquiry command failed : %s\n", iscsi_get_error(iscsic));
return -1;
}
full_size = scsi_datain_getfullsize(inq_task);
if (full_size > inq_task->datain.size) {
scsi_free_scsi_task(inq_task);
/* we need more data for the full list */
inq_task = iscsi_inquiry_sync(iscsic, lun, 0, 0, full_size);
if (inq_task == NULL) {
printf("Inquiry command failed : %s\n",
iscsi_get_error(iscsic));
return -1;
}
}
inq = scsi_datain_unmarshall(inq_task);
if (inq == NULL) {
printf("failed to unmarshall inquiry datain blob\n");
scsi_free_scsi_task(inq_task);
return -1;
}
sbc3_support = 0;
for (i = 0; i < 8; i++) {
if (inq->version_descriptor[i] == 0x04C0) {
sbc3_support = 1;
}
}
/* try reading block limits vpd */
inq_bl_task = iscsi_inquiry_sync(iscsic, lun, 1, SCSI_INQUIRY_PAGECODE_BLOCK_LIMITS, 64);
if (inq_bl_task && inq_bl_task->status != SCSI_STATUS_GOOD) {
scsi_free_scsi_task(inq_bl_task);
inq_bl_task = NULL;
}
if (inq_bl_task) {
full_size = scsi_datain_getfullsize(inq_bl_task);
if (full_size > inq_bl_task->datain.size) {
scsi_free_scsi_task(inq_bl_task);
if ((inq_bl_task = iscsi_inquiry_sync(iscsic, lun, 1, SCSI_INQUIRY_PAGECODE_BLOCK_LIMITS, full_size)) == NULL) {
printf("Inquiry command failed : %s\n", iscsi_get_error(iscsic));
return -1;
}
}
inq_bl = scsi_datain_unmarshall(inq_bl_task);
if (inq_bl == NULL) {
printf("failed to unmarshall inquiry datain blob\n");
return -1;
}
}
/* try reading block device characteristics vpd */
inq_bdc_task = iscsi_inquiry_sync(iscsic, lun, 1, SCSI_INQUIRY_PAGECODE_BLOCK_DEVICE_CHARACTERISTICS, 255);
if (inq_bdc_task == NULL) {
printf("Failed to read Block Device Characteristics page\n");
}
if (inq_bdc_task) {
inq_bdc = scsi_datain_unmarshall(inq_bdc_task);
if (inq_bdc == NULL) {
printf("failed to unmarshall inquiry datain blob\n");
return -1;
}
}
/* if thin provisioned we also need to read the VPD page for it */
if (rc16 && rc16->lbpme != 0){
inq_lbp_task = iscsi_inquiry_sync(iscsic, lun, 1, SCSI_INQUIRY_PAGECODE_LOGICAL_BLOCK_PROVISIONING, 64);
if (inq_lbp_task == NULL || inq_lbp_task->status != SCSI_STATUS_GOOD) {
printf("Inquiry command failed : %s\n", iscsi_get_error(iscsic));
return -1;
}
full_size = scsi_datain_getfullsize(inq_lbp_task);
if (full_size > inq_lbp_task->datain.size) {
scsi_free_scsi_task(inq_lbp_task);
/* we need more data for the full list */
if ((inq_lbp_task = iscsi_inquiry_sync(iscsic, lun, 1, SCSI_INQUIRY_PAGECODE_LOGICAL_BLOCK_PROVISIONING, full_size)) == NULL) {
printf("Inquiry command failed : %s\n", iscsi_get_error(iscsic));
return -1;
}
}
inq_lbp = scsi_datain_unmarshall(inq_lbp_task);
if (inq_lbp == NULL) {
printf("failed to unmarshall inquiry datain blob\n");
return -1;
}
}
rsop_task = iscsi_report_supported_opcodes_sync(iscsic, lun,
1, SCSI_REPORT_SUPPORTING_OPS_ALL, 0, 0, 65535);
if (rsop_task == NULL) {
printf("Failed to send REPORT_SUPPORTED_OPCODES command: %s\n",
iscsi_get_error(iscsic));
iscsi_destroy_context(iscsic);
return -1;
}
if (rsop_task->status == SCSI_STATUS_GOOD) {
rsop = scsi_datain_unmarshall(rsop_task);
if (rsop == NULL) {
printf("failed to unmarshall REPORT_SUPPORTED_OPCODES "
"data. %s\n",
iscsi_get_error(iscsic));
scsi_free_scsi_task(rsop_task);
}
}
/* check if the device is write protected or not */
task = iscsi_modesense6_sync(iscsic, lun, 0, SCSI_MODESENSE_PC_CURRENT,
SCSI_MODEPAGE_RETURN_ALL_PAGES,
0, 255);
if (task == NULL) {
printf("Failed to send MODE_SENSE6 command: %s\n",
iscsi_get_error(iscsic));
iscsi_destroy_context(iscsic);
return -1;
}
if (task->status == SCSI_STATUS_GOOD) {
struct scsi_mode_sense *ms;
ms = scsi_datain_unmarshall(task);
if (ms == NULL) {
printf("failed to unmarshall mode sense datain blob\n");
scsi_free_scsi_task(task);
return -1;
}
readonly = !!(ms->device_specific_parameter & 0x80);
}
scsi_free_scsi_task(task);
iscsi_logout_sync(iscsic);
iscsi_destroy_context(iscsic);
if (is_usb) {
printf("USB device. Clamping maximum transfer length to 120k\n");
maximum_transfer_length = 120 *1024 / block_size;
}
if (CU_initialize_registry() != 0) {
fprintf(stderr, "error: unable to initialize test registry\n");
return 1;
}
if (CU_is_test_running()) {
fprintf(stderr, "error: test suite(s) already running!?\n");
exit(1);
}
parse_and_add_tests(testname_re);
if (testname_re)
free(testname_re);
CU_basic_set_mode(mode);
CU_set_error_action(error_action);
printf("\n");
/*
* this actually runs the tests ...
*/
if (xml_mode) {
CU_list_tests_to_file();
CU_automated_run_tests();
} else {
res = CU_basic_run_tests();
printf("Tests completed with return value: %d\n", res);
}
CU_cleanup_registry();
free(discard_const(tgt_url));
if (inq_task != NULL) {
scsi_free_scsi_task(inq_task);
}
if (inq_bl_task != NULL) {
scsi_free_scsi_task(inq_bl_task);
}
if (inq_lbp_task != NULL) {
scsi_free_scsi_task(inq_lbp_task);
}
if (inq_bdc_task != NULL) {
scsi_free_scsi_task(inq_bdc_task);
}
if (rc16_task != NULL) {
scsi_free_scsi_task(rc16_task);
}
if (rsop_task != NULL) {
scsi_free_scsi_task(rsop_task);
}
return 0;
}
int main(int argc, char **argv)
{
CU_pSuite pSuite = NULL;
if (CUE_SUCCESS != CU_initialize_registry())
return CU_get_error();
pSuite = CU_add_suite("suite_serverInit", NULL, NULL);
if (NULL == pSuite)
{
CU_cleanup_registry();
return CU_get_error();
}
if (NULL == CU_add_test(pSuite, "TEST: Server Initialization", test_serverInit))
{
CU_cleanup_registry();
return CU_get_error();
}
pSuite = CU_add_suite("suite_serverHandlers", NULL, NULL);
if (NULL == pSuite)
{
CU_cleanup_registry();
return CU_get_error();
}
if ((NULL == CU_add_test(pSuite, "TEST: Server Handlers - Add users", test_serverHandler_userAdd)) ||
(NULL == CU_add_test(pSuite, "TEST: Server Handlers - Add books", test_serverHandler_bookAdd)) ||
(NULL == CU_add_test(pSuite, "TEST: Server Handlers - Retrieve book properties", test_serverHandler_bookProp)) ||
(NULL == CU_add_test(pSuite, "TEST: Server Handlers - Create user activities and book history", test_serverHandler_createActy)) ||
(NULL == CU_add_test(pSuite, "TEST: Server Handlers - Send/receive messages", test_serverHandler_msgs)) ||
(NULL == CU_add_test(pSuite, "TEST: Server Handlers - Retrieve user activies and bok history", test_serverHandler_checkActies)))
{
CU_cleanup_registry();
return CU_get_error();
}
pSuite = CU_add_suite("suite_serverTerm", NULL, NULL);
if (NULL == pSuite)
{
CU_cleanup_registry();
return CU_get_error();
}
if (NULL == CU_add_test(pSuite, "TEST: Server Termination", test_serverTerm))
{
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_automated_run_tests();
CU_list_tests_to_file();
printf("\n\n");
printf("======================================\n");
printf(" number of suites run: %d\n", CU_get_number_of_suites_run());
printf(" number of suites failed: %d\n", CU_get_number_of_suites_failed());
printf(" number of tests run: %d\n", CU_get_number_of_tests_run());
printf(" number of tests failed: %d\n", CU_get_number_of_tests_failed());
printf(" number of asserts done: %d\n", CU_get_number_of_asserts());
printf(" number of asserts successful: %d\n", CU_get_number_of_successes());
printf(" number of asserts failed: %d\n", CU_get_number_of_failures());
printf("======================================\n");
CU_cleanup_registry();
return CU_get_error();
}
int main(int argc, char *argv[])
{
char configFile[1024], interface[25];
int createflag, unitflag, cleanflag;
extern int logflag;
int create_f, clean_f, log_f;
createflag = unitflag = cleanflag = FALSE;
create_f = clean_f, FLAG_NOT_SET;
// Begin command line parsing ***********************************************
if ( (checkForOption("--help", argc, argv) != FLAG_NOT_SET)
|| (checkForOption("-h", argc, argv) != FLAG_NOT_SET)
|| (checkForOption("-help", argc, argv) != FLAG_NOT_SET) ) {
print_help();
}
get_asf_share_dir_with_argv0(argv[0]);
handle_license_and_version_args(argc, argv, ASF_NAME_STRING);
// Check which options were provided
create_f = checkForOption("-create", argc, argv);
clean_f = checkForOption("-clean", argc, argv);
log_f = checkForOption("-log", argc, argv);
// We need to make sure the user specified the proper number of arguments
int needed_args = 1 + REQUIRED_ARGS; // command & REQUIRED_ARGS
int num_flags = 0;
if (create_f != FLAG_NOT_SET) {needed_args += 1; num_flags++;} // option
if (clean_f != FLAG_NOT_SET) {needed_args += 1; num_flags++;} // option
if (log_f != FLAG_NOT_SET) {needed_args += 2; num_flags++;} // option & param
// Make sure we have the right number of args
if (argc != needed_args) {
print_usage();
}
// Make sure argument for each flag (that requires an arg) is not another
// option flag & is not a required argument
if (log_f != FLAG_NOT_SET) {
if ((argv[log_f+1][0]=='-') || (log_f>=(argc-REQUIRED_ARGS))) {
print_usage();
}
}
// Make sure all options occur before the config file name argument
if (num_flags == 1 && (create_f > 1 || log_f > 1)) {
print_usage();
}
else if (num_flags > 1 &&
(create_f >= argc - REQUIRED_ARGS - 1 ||
log_f >= argc - REQUIRED_ARGS - 1)) {
print_usage();
}
// Do the actual flagging & such for each flag
if (create_f != FLAG_NOT_SET) {
createflag = TRUE;
}
if (clean_f != FLAG_NOT_SET) {
cleanflag = TRUE;
}
if (log_f != FLAG_NOT_SET) {
strcpy(logFile, argv[log_f+1]);
logflag = TRUE;
fLog = FOPEN(logFile, "w");
}
// Fetch required arguments
strcpy(interface, argv[argc-2]);
strcpy(configFile, argv[argc-1]);
// Report the command line
asfSplashScreen(argc, argv);
// End command line parsing *************************************************
// Get test information from configuration file
test_config *cfg;
char line[1024];
// Creating configuration files
if (createflag && !fileExists(configFile)) {
init_test_config(configFile);
return(EXIT_SUCCESS);
}
else if (createflag && fileExists(configFile)) {
cfg = read_test_config(configFile);
check_return(write_test_config(configFile, cfg),
"Could not update configuration file");
free_test_config(cfg);
return(EXIT_SUCCESS);
}
else if (!fileExists(configFile))
asfPrintError("Could not find config file (%s)\n", configFile);
// Unit tests or single configuration file?
if (strcmp_case(interface, "basic") == 0 ||
strcmp_case(interface, "automated") == 0)
unitflag = TRUE;
if (unitflag) {
extern int quietflag;
quietflag = 2;
if (CUE_SUCCESS != CU_initialize_registry())
return CU_get_error();
int test = FALSE;
FILE *fpList = FOPEN(configFile, "r");
while(fgets(line, 1024, fpList)) {
if (strcmp_case(trim_spaces(line), "uavsar_metadata") == 0)
add_uavsar_metadata_tests();
if (strcmp_case(trim_spaces(line), "uavsar_geotiff") == 0)
add_uavsar_geotiff_tests();
if (strcmp_case(trim_spaces(line), "rsat1_map_projections") == 0)
add_rsat1_map_projections_tests();
if (strcmp_case(trim_spaces(line), "rsat1_geotiff") == 0)
add_rsat1_geotiff_tests();
if (strcmp_case(trim_spaces(line), "alos_browse") == 0)
add_alos_browse_tests();
if (strcmp_case(trim_spaces(line), "alos_leader") == 0)
add_alos_leader_tests();
if (strcmp_case(trim_spaces(line), "rsat1_overlay") == 0)
add_rsat1_overlay_tests();
if (strcmp_case(trim_spaces(line), "alos_calibration") == 0)
add_alos_calibration_tests();
test = TRUE;
}
FCLOSE(fpList);
if (test && strcmp_case(interface, "basic") == 0) {
asfPrintStatus("Running tests in basic mode ...\n");
CU_basic_set_mode(CU_BRM_VERBOSE);
if (CUE_SUCCESS != CU_basic_run_tests()) {
CU_cleanup_registry();
return CU_get_error();
}
}
if (test && strcmp_case(interface, "automated") == 0) {
asfPrintStatus("Running tests in automated mode ...\n\n");
CU_set_output_filename("asf_tools");
CU_automated_run_tests();
CU_list_tests_to_file();
}
CU_cleanup_registry();
if (cleanflag)
cleanup_test_results(configFile);
}
else { // Configuration file for manual mode
cfg = read_test_config(configFile);
asfPrintStatus("Running tests in manual mode ...\n\n");
// Run metadata tests
if (strcmp_case(cfg->general->type, "metadata") == 0)
manual_metadata(configFile);
// Run geotiff tests
else if (strcmp_case(cfg->general->type, "geotiff") == 0)
manual_geotiff(configFile);
// Run binary tests
else if (strcmp_case(cfg->general->type, "binary") == 0)
manual_binary(configFile);
// Run library tests
else if (strcmp_case(cfg->general->type, "library") == 0)
manual_library(configFile);
free_test_config(cfg);
}
return(EXIT_SUCCESS);
}
