static void test_parse_invalid_unicode_surrogate() { TEST_ERROR(LEPT_PARSE_INVALID_UNICODE_SURROGATE, "\"\\uD800\""); TEST_ERROR(LEPT_PARSE_INVALID_UNICODE_SURROGATE, "\"\\uDBFF\""); TEST_ERROR(LEPT_PARSE_INVALID_UNICODE_SURROGATE, "\"\\uD800\\\\\""); TEST_ERROR(LEPT_PARSE_INVALID_UNICODE_SURROGATE, "\"\\uD800\\uDBFF\""); TEST_ERROR(LEPT_PARSE_INVALID_UNICODE_SURROGATE, "\"\\uD800\\uE000\""); }
void cli_disconnect(cli_info_t *cli) { if( CLI_DISCONN != cli->next_state[cli->state] ){ TEST_ERROR(("rank %d: bad client next state: expect %d have %d!", cli_rank(cli), CLI_DISCONN, cli->next_state[cli->state])); test_abort = true; } if( 0 > cli->sd ){ TEST_ERROR(("Bad sd = %d of rank = %d ", cli->sd, cli_rank(cli))); test_abort = true; } else { TEST_VERBOSE(("close sd = %d for rank = %d", cli->sd, cli_rank(cli))); close(cli->sd); cli->sd = -1; } if( NULL == cli->ev ){ TEST_ERROR(("Bad ev = NULL of rank = %d ", cli->sd, cli_rank(cli))); test_abort = true; } else { TEST_VERBOSE(("remove event of rank %d from event queue", cli_rank(cli))); event_del(cli->ev); event_free(cli->ev); cli->ev = NULL; } TEST_VERBOSE(("Destruct modex list for the rank %d", cli_rank(cli))); PMIX_LIST_DESTRUCT(&(cli->modex)); cli->state = CLI_DISCONN; }
int test_mylist_setup(void) { ani_response_t *response = NULL; ani_set_username(TEST_USER); ani_set_password(TEST_PASSWD); if (0 == ani_open_connection(NULL, 0)) { response = ani_login(); if (ANI_STATUS_LOGIN_ACCEPTED != response->status_code && ANI_STATUS_LOGIN_ACCEPTED_NEW_VERSION != response->status_code) { if (0 != ani_close_connection()) TEST_ERROR(); ani_free_response(response); TEST_ERROR(); return 1; } ani_free_response(response); return 0; } else { TEST_ERROR(); return 1; } }
void test_architecture_event_pic_02(void) { t_uint8 mask; TEST_ENTER(); if (event_reserve(32 + 9, EVENT_TYPE_FUNCTION, EVENT_ROUTINE(test_architecture_event_pic_02), EVENT_DATA(NULL)) != STATUS_OK) TEST_ERROR("[event_reserve] error"); ARCHITECTURE_INB(TEST_MASTER_PORT_B, mask); if ((mask & (1 << 2)) != 0) TEST_ERROR("invalid PIC mask"); ARCHITECTURE_INB(TEST_SLAVE_PORT_B, mask); if (mask != 0xfd) TEST_ERROR("invalid PIC mask"); TEST_SIGNATURE(vniwojw0f32wg3hh); TEST_LEAVE(); }
int test_connect_disconnect(char *my_nspace, int my_rank) { int rc; pmix_proc_t proc; (void)strncpy(proc.nspace, my_nspace, PMIX_MAX_NSLEN); proc.rank = PMIX_RANK_WILDCARD; rc = test_cd_common(&proc, 1, 1, 0); if (PMIX_SUCCESS != rc) { TEST_ERROR(("%s:%d: Connect blocking test failed.", my_nspace, my_rank)); return PMIX_ERROR; } TEST_VERBOSE(("%s:%d: Connect blocking test succeded.", my_nspace, my_rank)); rc = test_cd_common(&proc, 1, 1, 1); if (PMIX_SUCCESS != rc) { TEST_ERROR(("%s:%d: Disconnect blocking test failed.", my_nspace, my_rank)); return PMIX_ERROR; } TEST_VERBOSE(("%s:%d: Disconnect blocking test succeded.", my_nspace, my_rank)); rc = test_cd_common(&proc, 1, 0, 0); if (PMIX_SUCCESS != rc) { TEST_ERROR(("%s:%d: Connect non-blocking test failed.", my_nspace, my_rank)); return PMIX_ERROR; } TEST_VERBOSE(("%s:%d: Connect non-blocking test succeded.", my_nspace, my_rank)); rc = test_cd_common(&proc, 1, 0, 1); if (PMIX_SUCCESS != rc) { TEST_ERROR(("%s:%d: Disconnect non-blocking test failed.", my_nspace, my_rank)); return PMIX_ERROR; } TEST_VERBOSE(("%s:%d: Disconnect non-blocking test succeded.", my_nspace, my_rank)); return PMIX_SUCCESS; }
static void testErrorHandling(void) { output_buffer_clear(); error_buffer_clear(); #define TEST_ERROR(data, output, err_num) { \ output_buffer_clear(); \ error_buffer_clear(); \ SCPI_Input(&scpi_context, data, strlen(data)); \ CU_ASSERT_STRING_EQUAL(output, output_buffer); \ CU_ASSERT_EQUAL(err_buffer[0], err_num) \ } TEST_ERROR("*IDN?\r\n", "MA,IN,0,VER\r\n", 0); TEST_ERROR("IDN?\r\n", "", SCPI_ERROR_UNDEFINED_HEADER); TEST_ERROR("*ESE\r\n", "", SCPI_ERROR_MISSING_PARAMETER); TEST_ERROR("*IDN? 12\r\n", "MA,IN,0,VER\r\n", SCPI_ERROR_PARAMETER_NOT_ALLOWED); TEST_ERROR("TEXT? \"PARAM1\", \"PARAM2\"\r\n", "\"PARAM2\"\r\n", 0); // TODO: SCPI_ERROR_INVALID_SEPARATOR // TODO: SCPI_ERROR_INVALID_SUFFIX // TODO: SCPI_ERROR_SUFFIX_NOT_ALLOWED // TODO: SCPI_ERROR_EXECUTION_ERROR // TODO: SCPI_ERROR_ILLEGAL_PARAMETER_VALUE output_buffer_clear(); error_buffer_clear(); }
static void test_parse_root_not_singular() { TEST_ERROR(LEPT_PARSE_ROOT_NOT_SINGULAR, "null x"); /* invalid number */ TEST_ERROR(LEPT_PARSE_ROOT_NOT_SINGULAR, "0123"); /* after zero should be '.' or nothing */ TEST_ERROR(LEPT_PARSE_ROOT_NOT_SINGULAR, "0x0"); TEST_ERROR(LEPT_PARSE_ROOT_NOT_SINGULAR, "0x123"); }
void testFSNode() { TEST_INFO("==> Start test of FSNode"); std::string fileName("USERDATA:myFileTest.txt"); etk::FSNode myNodeTest1(fileName); TEST_INFO("********************************************"); TEST_INFO("** Filename=\"" << fileName << "\""); TEST_INFO("********************************************"); TEST_INFO(" GetNameFolder() ='" << myNodeTest1.getNameFolder() << "'"); TEST_INFO(" GetName() ='" << myNodeTest1.getName() << "'"); TEST_INFO(" GetNameFile() ='" << myNodeTest1.getNameFile() << "'"); TEST_INFO(" GetRelativeFolder() ='" << myNodeTest1.getRelativeFolder() << "'"); TEST_INFO(" getFileSystemName() ='" << myNodeTest1.getFileSystemName() << "'"); TEST_INFO(" exist =" << myNodeTest1.exist()); if (true==myNodeTest1.exist()) { TEST_ERROR(" ==> remove the file ==> bad for the test"); } else { TEST_INFO(" Display time when file does not exist :"); TEST_INFO(" TimeCreatedString() ='" << myNodeTest1.timeCreatedString() << "'"); TEST_INFO(" TimeModifiedString() ='" << myNodeTest1.timeModifiedString() << "'"); TEST_INFO(" TimeAccessedString() ='" << myNodeTest1.timeAccessedString() << "'"); } myNodeTest1.touch(); if (false==myNodeTest1.exist()) { TEST_ERROR(" ==> Error, can not create the file ...."); } else { TEST_INFO(" Display time when file does exist :"); TEST_INFO(" TimeCreatedString() ='" << myNodeTest1.timeCreatedString() << "'"); TEST_INFO(" TimeModifiedString() ='" << myNodeTest1.timeModifiedString() << "'"); TEST_INFO(" TimeAccessedString() ='" << myNodeTest1.timeAccessedString() << "'"); } etk::FSNode myNodeTest2(fileName); TEST_INFO("********************************************"); TEST_INFO("** Filename2=\"" << myNodeTest2<< "\""); TEST_INFO("********************************************"); TEST_INFO(" GetNameFolder() ='" << myNodeTest2.getNameFolder() << "'"); TEST_INFO(" GetName() ='" << myNodeTest2.getName() << "'"); TEST_INFO(" GetNameFile() ='" << myNodeTest2.getNameFile() << "'"); TEST_INFO(" GetRelativeFolder() ='" << myNodeTest2.getRelativeFolder() << "'"); TEST_INFO(" getFileSystemName() ='" << myNodeTest2.getFileSystemName() << "'"); TEST_INFO(" exist =" << myNodeTest2.exist()); if (false==myNodeTest1.exist()) { TEST_ERROR(" ==> Error, can not create the file ...."); } else { TEST_INFO(" Display time when file does exist :"); TEST_INFO(" TimeCreatedString() ='" << myNodeTest2.timeCreatedString() << "'"); TEST_INFO(" TimeModifiedString() ='" << myNodeTest2.timeModifiedString() << "'"); TEST_INFO(" TimeAccessedString() ='" << myNodeTest2.timeAccessedString() << "'"); } // Try remove the file : myNodeTest1.remove(); if (true==myNodeTest1.exist()) { TEST_ERROR(" ==> The file might be removed ==> but it is not the case ..."); } else { TEST_INFO(" ==> The file is removed"); } TEST_INFO("********************************************"); TEST_INFO("==> Stop test of FSNode"); }
void test_mylist_teardown(void) { ani_response_t *response = NULL; response = ani_logout(); if (ANI_STATUS_LOGGED_OUT != response->status_code) TEST_ERROR(); ani_free_response(response); if (0 != ani_close_connection()) TEST_ERROR(); }
/*********************************************************************************************************************************** Test Run ***********************************************************************************************************************************/ void testRun(void) { FUNCTION_HARNESS_VOID(); // Create default storage object for testing Storage *storageTest = storagePosixNew( strNew(testPath()), STORAGE_MODE_FILE_DEFAULT, STORAGE_MODE_PATH_DEFAULT, true, NULL); // ***************************************************************************************************************************** if (testBegin("lockStopFileName()")) { // Load configuration so lock path is set StringList *argList = strLstNew(); strLstAddZ(argList, "pgbackrest"); strLstAddZ(argList, "--stanza=db"); strLstAddZ(argList, "--lock-path=/path/to/lock"); strLstAddZ(argList, "archive-get"); harnessCfgLoad(strLstSize(argList), strLstPtr(argList)); TEST_RESULT_STR(strPtr(lockStopFileName(NULL)), "/path/to/lock/all.stop", "stop file for all stanzas"); TEST_RESULT_STR(strPtr(lockStopFileName(strNew("db"))), "/path/to/lock/db.stop", "stop file for on stanza"); } // ***************************************************************************************************************************** if (testBegin("lockStopTest()")) { StringList *argList = strLstNew(); strLstAddZ(argList, "pgbackrest"); strLstAdd(argList, strNewFmt("--lock-path=%s", testPath())); strLstAddZ(argList, "start"); harnessCfgLoad(strLstSize(argList), strLstPtr(argList)); TEST_RESULT_VOID(lockStopTest(), "no stop files without stanza"); // ------------------------------------------------------------------------------------------------------------------------- argList = strLstNew(); strLstAddZ(argList, "pgbackrest"); strLstAddZ(argList, "--stanza=db"); strLstAdd(argList, strNewFmt("--lock-path=%s", testPath())); strLstAddZ(argList, "start"); harnessCfgLoad(strLstSize(argList), strLstPtr(argList)); TEST_RESULT_VOID(lockStopTest(), "no stop files with stanza"); storagePutNP(storageNewWriteNP(storageTest, strNew("all.stop")), NULL); TEST_ERROR(lockStopTest(), StopError, "stop file exists for all stanzas"); storagePutNP(storageNewWriteNP(storageTest, strNew("db.stop")), NULL); TEST_ERROR(lockStopTest(), StopError, "stop file exists for stanza db"); } FUNCTION_HARNESS_RESULT_VOID(); }
int test_connect_disconnect(char *my_nspace, int my_rank) { int rc; pmix_proc_t proc; char nspace[PMIX_MAX_NSLEN+1]; pmix_rank_t newrank; cd_cbdata cbdata; (void)strncpy(proc.nspace, my_nspace, PMIX_MAX_NSLEN); proc.rank = PMIX_RANK_WILDCARD; rc = PMIx_Connect(&proc, 1, NULL, 0, nspace, &newrank); if (PMIX_SUCCESS != rc) { TEST_ERROR(("%s:%d: Connect blocking test failed.", my_nspace, my_rank)); return PMIX_ERROR; } TEST_VERBOSE(("%s:%d: Connect blocking test succeded to nspace %s.", my_nspace, my_rank, nspace)); rc = PMIx_Disconnect(nspace, NULL, 0); if (PMIX_SUCCESS != rc) { TEST_ERROR(("%s:%d: Disconnect blocking test failed.", my_nspace, my_rank)); return PMIX_ERROR; } TEST_VERBOSE(("%s:%d: Disconnect blocking test succeded.", my_nspace, my_rank)); cbdata.in_progress = 1; rc = PMIx_Connect_nb(&proc, 1, NULL, 0, cnct_cb, &cbdata); if (PMIX_SUCCESS == rc) { PMIX_WAIT_FOR_COMPLETION(cbdata.in_progress); rc = cbdata.status; } if (PMIX_SUCCESS != rc) { TEST_ERROR(("%s:%d: Connect non-blocking test failed.", my_nspace, my_rank)); return PMIX_ERROR; } TEST_VERBOSE(("%s:%d: Connect non-blocking test succeded.", my_nspace, my_rank)); cbdata.in_progress = 1; rc = PMIx_Disconnect_nb(nspace, NULL, 0, cd_cb, &cbdata); if (PMIX_SUCCESS == rc) { PMIX_WAIT_FOR_COMPLETION(cbdata.in_progress); rc = cbdata.status; } if (PMIX_SUCCESS != rc) { TEST_ERROR(("%s:%d: Disconnect non-blocking test failed.", my_nspace, my_rank)); return PMIX_ERROR; } TEST_VERBOSE(("%s:%d: Disconnect non-blocking test succeded.", my_nspace, my_rank)); return PMIX_SUCCESS; }
void test_architecture_event_interrupt_02_handler_58(t_id id) { thrown++; if (id != (ARCHITECTURE_IDT_SYSCALL_BASE + 2)) TEST_ERROR("invalid event identifier"); }
void errhandler(pmix_status_t status, pmix_proc_t procs[], size_t nprocs, pmix_info_t info[], size_t ninfo) { TEST_ERROR(("Error handler with status = %d", status)) test_abort = true; }
void test_normal_packet(void) { int i = 0; ani_response_t *response = NULL; char *responses[] = { "230 ANIME\n161|52|50|0|715|57|777|35|816|1|2002-2003|TV|Tokyo Mew Mew|" "東京ミュウミュウ||||TMM'mew|Cat Girls\n", "230 ANIME\n161|52|50|0|715|57|777|35|816|1|2002-2003|TV|Tokyo Mew Mew|" "東京ミュウミュウ||||TMM'mew|Cat Girls161|52|50|0|715|57|777|35|816|1|" "2002-2003|TV|Tokyo Mew Mew|東京ミュウミュウ||||TMM'mew|Cat Girls161|52|50" "|0|715|57|777|35|816|1|2002-2003|TV|Tokyo Mew Mew|東京ミュウミュウ||||TMM" "'mew|Cat Girls161|52|50|0|715|57|777|35|816|1|2002-2003|TV|" "Tokyo Mew Mew|東京ミュウミュウ||||TMM'mew|Cat Girls161|52|50|0|715|57|777" "|35|816|1|2002-2003|TV|Tokyo Mew Mew|東京ミュウミュウ||||T" "MM'mew|Cat Girls161|52|50|0|715|57|777|35|816|1|2002-2003|TV|" "Tokyo Mew Mew|東京ミュウミュウ||||TMM'mew|Cat Girls161|52|50|0|715|57" "|777|35|816|1|2002-2003|TV|Tokyo Mew Mew|東京ミュウミュウ||||TMM'mew|" "Cat Girls161|52|50|0|715|57|777|35|816|1|2002-2003|TV|Tokyo Mew Mew|" "東京ミュウミュウ||||TMM'mew|Cat Girls161|52|50|0|715|57|777|35|816|1|" "2002-2003|TV|Tokyo Mew Mew|東京ミュウミュウ||||TMM'mew|Cat Girls161|52|50" "|0|715|57|777|35|816|1|2002-2003|TV|Tokyo Mew Mew|東京ミュウミュウ||||" "TMM'mew|Cat Girls161|52|50|0|715|57|777|35|816|1|2002-2003|TV|" "Tokyo Mew Mew|東京ミュウミュウ||||TMM'mew|Cat Girls\n" }; for (i = 0; i < sizeof(responses)/sizeof(*responses); i++) { response = ani_create_response(responses[i]); if (ANI_STATUS_MALFORMED_RESPONSE == response->status_code) TEST_ERROR(); ani_free_response(response); } }
void test_architecture_event_interrupt_02(void) { TEST_ENTER(); event_release(ARCHITECTURE_IDT_SYSCALL_BASE + 0); event_release(ARCHITECTURE_IDT_SYSCALL_BASE + 1); event_release(ARCHITECTURE_IDT_SYSCALL_BASE + 2); if (event_reserve(ARCHITECTURE_IDT_SYSCALL_BASE + 0, EVENT_TYPE_FUNCTION, EVENT_ROUTINE(test_architecture_event_interrupt_02_handler_56), EVENT_DATA(NULL)) != STATUS_OK) TEST_ERROR("[event_reserve] error"); if (event_reserve(ARCHITECTURE_IDT_SYSCALL_BASE + 1, EVENT_TYPE_FUNCTION, EVENT_ROUTINE(test_architecture_event_interrupt_02_handler_57), EVENT_DATA(NULL)) != STATUS_OK) TEST_ERROR("[event_reserve] error"); if (event_reserve(ARCHITECTURE_IDT_SYSCALL_BASE + 2, EVENT_TYPE_FUNCTION, EVENT_ROUTINE(test_architecture_event_interrupt_02_handler_58), EVENT_DATA(NULL)) != STATUS_OK) TEST_ERROR("[event_reserve] error"); if (event_enable() != STATUS_OK) TEST_ERROR("[event_enable] error"); asm volatile("int $56"); asm volatile("int $57"); asm volatile("int $58"); if (event_disable() != STATUS_OK) TEST_ERROR("[event_disable] error"); if (thrown != 3) TEST_ERROR("some interrupt events have not been caught"); if (event_release(ARCHITECTURE_IDT_SYSCALL_BASE + 0) != STATUS_OK) TEST_ERROR("[event_release] error"); if (event_release(ARCHITECTURE_IDT_SYSCALL_BASE + 1) != STATUS_OK) TEST_ERROR("[event_release] error"); if (event_release(ARCHITECTURE_IDT_SYSCALL_BASE + 2) != STATUS_OK) TEST_ERROR("[event_release] error"); TEST_SIGNATURE(cd09iwfjg9gerkg43hg); TEST_LEAVE(); }
int test_spawn(char *my_nspace, int my_rank) { int rc; rc = test_spawn_common(my_nspace, my_rank, 1); if (PMIX_SUCCESS != rc) { TEST_ERROR(("%s:%d: Spawn blocking test failed.", my_nspace, my_rank)); return PMIX_ERROR; } TEST_VERBOSE(("%s:%d: Spawn blocking test succeded.", my_nspace, my_rank)); rc = test_spawn_common(my_nspace, my_rank, 0); if (PMIX_SUCCESS != rc) { TEST_ERROR(("%s:%d: Spawn non-blocking test failed.", my_nspace, my_rank)); return PMIX_ERROR; } TEST_VERBOSE(("%s:%d: Spawn non-blocking test succeded.", my_nspace, my_rank)); return PMIX_SUCCESS; }
void cli_finalize(cli_info_t *cli) { if( CLI_FIN != cli->next_state[cli->state] ){ TEST_ERROR(("rank %d: bad client next state: expect %d have %d!", cli_rank(cli), CLI_FIN, cli->next_state[cli->state])); test_abort = true; } cli->state = CLI_FIN; }
void test_core_set_array_01(void) { i_set id; TEST_ENTER(); if (set_reserve(array, SET_OPTION_NONE, 4, sizeof (t_id), &id) != STATUS_OK) TEST_ERROR("[set_reserve] error"); if (set_release(id) != STATUS_OK) TEST_ERROR("[set_release] error"); if (set_reserve(array, SET_OPTION_ALLOCATE | SET_OPTION_FREE, 4, sizeof (t_id), &id) == STATUS_OK) TEST_ERROR("[set_reserve] error: invalid arguments"); TEST_SIGNATURE(df093fiwg093h); TEST_LEAVE(); }
NSYNC_CPP_USING_ /* Verify the properties of a zero counter. */ static void test_counter_zero (testing t) { int i; nsync_counter c = nsync_counter_new (0); for (i = 0; i != 2; i++) { if (nsync_counter_value (c) != 0) { TEST_ERROR (t, ("zero counter is not zero (test, %d)", i)); } if (nsync_counter_wait (c, nsync_time_zero) != 0) { TEST_ERROR (t, ("zero counter is not zero (poll, %d)", i)); } if (nsync_counter_wait (c, nsync_time_no_deadline) != 0) { TEST_ERROR (t, ("zero counter is not zero (infinite wait, %d)", i)); } nsync_counter_add (c, 0); } nsync_counter_free (c); }
void cli_cleanup(cli_info_t *cli) { if (0 > cli->state || CLI_TERM < cli->state) { TEST_ERROR(("Bad rank %d state %d", cli_rank(cli), cli->state)); test_abort = true; return; } switch( cli->next_state[cli->state] ){ case CLI_FORKED: break; case CLI_CONNECTED: /* error - means that process terminated w/o calling finalize */ if (!test_abort) { TEST_ERROR(("rank %d with state %d unexpectedly terminated.", cli_rank(cli), cli->state)); } cli->state = CLI_TERM; test_abort = true; break; case CLI_FIN: /* error - means that process terminated w/o calling finalize */ if (!test_abort) { TEST_ERROR(("rank %d with state %d unexpectedly terminated.", cli_rank(cli), cli->state)); } cli_finalize(cli); cli_cleanup(cli); test_abort = true; break; case CLI_DISCONN: cli_disconnect(cli); cli_cleanup(cli); break; case CLI_TERM: cli_terminate(cli); break; default: TEST_ERROR(("Bad rank %d next state %d", cli_rank(cli), cli->next_state[cli->state])); test_abort = true; return; } }
int main(int _argc, const char *_argv[]) { etk::init(_argc, _argv); enet::init(_argc, _argv); for (int32_t iii=0; iii<_argc ; ++iii) { std::string data = _argv[iii]; if ( data == "-h" || data == "--help") { TEST_PRINT(etk::getApplicationName() << " - help : "); TEST_PRINT(" " << _argv[0] << " [options]"); TEST_PRINT(" No options ..."); return -1; } } TEST_INFO("=================================="); TEST_INFO("== Test TCP server =="); TEST_INFO("=================================="); //Wait on TCP connection: enet::TcpServer interface; // Configure server interface: interface.setHostNane("127.0.0.1"); interface.setPort(12345); // Start listening ... interface.link(); // Wait a new connection .. enet::Tcp tcpConnection = std::move(interface.waitNext()); // Free Connected port interface.unlink(); int32_t iii = 0; while (tcpConnection.getConnectionStatus() == enet::Tcp::status::link) { int32_t len = tcpConnection.write("plop" + etk::to_string(iii)); TEST_INFO("write len=" << len); char data[1024]; len = tcpConnection.read(data, 1024); if (len > 0) { TEST_INFO("read len=" << len << " data='" << data << "'"); } iii++; } if (iii>=1000000) { TEST_INFO("auto disconnected"); } else if (tcpConnection.getConnectionStatus() != enet::Tcp::status::link) { TEST_INFO("server disconnected"); } else { TEST_INFO("ERROR disconnected"); } if (tcpConnection.unlink() == false) { TEST_ERROR("can not unlink to the socket..."); return -1; } return 0; }
static int resolve_nspace(char *nspace, test_params params, char *my_nspace, int my_rank) { int rc; pmix_proc_t *procs; size_t nprocs, nranks, i; pmix_proc_t *ranks; rc = PMIx_Resolve_peers(NODE_NAME, nspace, &procs, &nprocs); if (PMIX_SUCCESS != rc) { TEST_ERROR(("%s:%d: Resolve peers test failed: rc = %d", my_nspace, my_rank, rc)); return rc; } if (NULL == procs || 0 == nprocs) { TEST_ERROR(("%s:%d: Resolve peers didn't find any process from ns %s at this node\n", my_nspace, my_rank,my_nspace)); return PMIX_ERROR; } rc = get_all_ranks_from_namespace(params, nspace, &ranks, &nranks); if (PMIX_SUCCESS != rc) { TEST_ERROR(("%s:%d: get_all_ranks_from_namespace function failed", my_nspace, my_rank)); PMIX_PROC_FREE(procs, nprocs); return rc; } if (nprocs != nranks) { TEST_ERROR(("%s:%d: Resolve peers returned incorect result: returned %lu processes, expected %lu", my_nspace, my_rank, nprocs, nranks)); PMIX_PROC_FREE(procs, nprocs); PMIX_PROC_FREE(ranks, nranks); return PMIX_ERROR; } for (i = 0; i < nprocs; i++) { if (procs[i].rank != ranks[i].rank) { TEST_ERROR(("%s:%d: Resolve peers returned incorrect result: returned value %s:%d, expected rank %d", my_nspace, my_rank, procs[i].nspace, procs[i].rank, ranks[i].rank)); rc = PMIX_ERROR; break; } } PMIX_PROC_FREE(procs, nprocs); PMIX_PROC_FREE(ranks, nranks); return rc; }
/*********************************************************************************************************************************** Test Run ***********************************************************************************************************************************/ void testRun(void) { FUNCTION_HARNESS_VOID(); // ***************************************************************************************************************************** if (testBegin("perlMain()")) { // ------------------------------------------------------------------------------------------------------------------------- cfgInit(); cfgCommandSet(cfgCmdInfo); cfgExeSet(strNew("/path/to/pgbackrest")); TEST_RESULT_STR( strPtr(perlMain()), "($iResult, $bErrorC, $strMessage) = pgBackRest::Main::main('info')", "command with no options"); // ------------------------------------------------------------------------------------------------------------------------- cfgOptionValidSet(cfgOptCompress, true); cfgOptionSet(cfgOptCompress, cfgSourceParam, varNewBool(true)); StringList *commandParamList = strLstNew(); strLstAdd(commandParamList, strNew("A")); strLstAdd(commandParamList, strNew("B")); cfgCommandParamSet(commandParamList); TEST_RESULT_STR( strPtr(perlMain()), "($iResult, $bErrorC, $strMessage) = pgBackRest::Main::main('info','A','B')", "command with one option and params"); } // ***************************************************************************************************************************** if (testBegin("perlInit(), perlExec(), and perlFree()")) { StringList *argList = strLstNew(); strLstAdd(argList, strNew("pgbackrest")); strLstAdd(argList, strNew("--stanza=db")); strLstAdd(argList, strNew("--log-level-console=off")); strLstAdd(argList, strNew("--log-level-stderr=off")); strLstAdd(argList, strNew("--log-level-file=off")); strLstAdd(argList, strNew("archive-push")); TEST_RESULT_VOID(cfgLoad(strLstSize(argList), strLstPtr(argList)), "load archive-push config"); TEST_RESULT_VOID(perlFree(0), "free Perl before it is init'd"); TEST_RESULT_VOID(perlInit(), "init Perl"); TEST_ERROR(perlExec(), PathMissingError, PERL_EMBED_ERROR); TEST_RESULT_VOID(perlFree(0), "free Perl"); } FUNCTION_HARNESS_RESULT_VOID(); }
void cli_terminate(cli_info_t *cli) { if( CLI_TERM != cli->next_state[cli->state] ){ TEST_ERROR(("rank %d: bad client next state: expect %d have %d!", cli_rank(cli), CLI_TERM, cli->next_state[cli->state])); test_abort = true; } cli->pid = -1; TEST_VERBOSE(("Client rank = %d terminated", cli_rank(cli))); cli->state = CLI_TERM; if (NULL != cli->ns) { free(cli->ns); } }
static void timeout_errhandler(size_t evhdlr_registration_id, pmix_status_t status, const pmix_proc_t *source, pmix_info_t info[], size_t ninfo, pmix_info_t results[], size_t nresults, pmix_event_notification_cbfunc_fn_t cbfunc, void *cbdata) { TEST_ERROR(("timeout errhandler called for error status = %d ninfo = %d", status, ninfo)); if (NULL != cbfunc) { cbfunc(PMIX_SUCCESS, NULL, 0, NULL, NULL, cbdata); } }
/* Verify the properties of a non-zero counter. */ static void test_counter_non_zero (testing t) { nsync_time start; nsync_time waited; nsync_time abs_deadline; nsync_counter c = nsync_counter_new (1); if (nsync_counter_value (c) != 1) { TEST_ERROR (t, ("counter is not 1 (test)")); } if (nsync_counter_wait (c, nsync_time_zero) != 1) { TEST_ERROR (t, ("counter is not 1 (poll)")); } start = nsync_time_now (); abs_deadline = nsync_time_add (nsync_time_now (), nsync_time_ms (1000)); if (nsync_counter_wait (c, abs_deadline) != 1) { TEST_ERROR (t, ("counter is not 1 (1s wait)")); } waited = nsync_time_sub (nsync_time_now (), start); if (nsync_time_cmp (waited, nsync_time_ms (900)) < 0) { TEST_ERROR (t, ("timed wait on non-zero counter returned too quickly (1s wait took %s)", nsync_time_str (waited, 2))); } if (nsync_time_cmp (waited, nsync_time_ms (2000)) > 0) { TEST_ERROR (t, ("timed wait on non-zero counter returned too slowly (1s wait took %s)", nsync_time_str (waited, 2))); } if (nsync_counter_add (c, -1) != 0) { TEST_ERROR (t, ("zero counter note is not 0 (add)")); } if (nsync_counter_value (c) != 0) { TEST_ERROR (t, ("zero counter note is not 0 (test)")); } if (nsync_counter_wait (c, nsync_time_zero) != 0) { TEST_ERROR (t, ("zero counter note is not 0 (poll)")); } if (nsync_counter_wait (c, nsync_time_no_deadline) != 0) { TEST_ERROR (t, ("zero counter note is not 0 (infinite wait)")); } nsync_counter_free (c); }
void test_response_overflow(void) { ani_response_t *response = NULL; char data[RAW_LEN * 2]; int i = 0; for (i = 0; i < RAW_LEN * 2; ++i) { data[i] = 'a'; } data[RAW_LEN * 2 - 1] = '\0'; response = ani_create_response(data); if (response->status_code != ANI_STATUS_MALFORMED_RESPONSE) TEST_ERROR(); ani_free_response(response); }
void test_response_nonterminated(void) { ani_response_t *response = NULL; char data[RAW_LEN + 1]; int i = 0; for (i = 0; i < RAW_LEN + 1; ++i) { data[i] = 'a'; } (void)strcpy(data, "tag1 210 Some Message\nSome Data\n"); data[strlen(data)] = ' '; response = ani_create_response(data); if (response->status_code != ANI_STATUS_MALFORMED_RESPONSE) TEST_ERROR(); ani_free_response(response); }
void test_response_blob(void) { unsigned char data[RAW_LEN]; int i = 0; ani_response_t *response = NULL; for (i = 0; i < RAW_LEN; i++) { srand(time(NULL)); data[i] = rand() % 9; } data[i] = '\0'; response = ani_create_response((char *)data); if (response->status_code != ANI_STATUS_MALFORMED_RESPONSE) TEST_ERROR(); ani_free_response(response); }
void cli_wait_all(double timeout) { struct timeval tv; double start_time, cur_time; gettimeofday(&tv, NULL); start_time = tv.tv_sec + 1E-6*tv.tv_usec; cur_time = start_time; //TEST_VERBOSE(("Wait for all children to terminate")) // Wait for all children to cleanup after the test. while( !test_terminated() && ( timeout >= (cur_time - start_time) ) ){ struct timespec ts; int status, i; pid_t pid; while( 0 < (pid = waitpid(-1, &status, WNOHANG) ) ){ TEST_VERBOSE(("waitpid = %d", pid)); for(i=0; i < cli_info_cnt; i++){ if( cli_info[i].pid == pid ){ TEST_VERBOSE(("the child with pid = %d has rank = %d\n" "\t\texited = %d, signalled = %d", pid, i, WIFEXITED(status), WIFSIGNALED(status) )); if( WIFEXITED(status) || WIFSIGNALED(status) ){ cli_cleanup(&cli_info[i]); } } } } if( pid < 0 ){ if( errno == ECHILD ){ TEST_VERBOSE(("No more children to wait. Happens on the last cli_wait_all call " "which is used to ensure that all children terminated.\n")); break; } else { TEST_ERROR(("waitpid(): %d : %s", errno, strerror(errno))); exit(0); } } ts.tv_sec = 0; ts.tv_nsec = 100000; nanosleep(&ts, NULL); // calculate current timestamp gettimeofday(&tv, NULL); cur_time = tv.tv_sec + 1E-6*tv.tv_usec; } }