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;
}
}
