db/pgbackrest
1
0
Fork 0
mirror of https://github.com/pgbackrest/pgbackrest.git synced 2025-07-17 01:12:23 +02:00
Code Issues Releases Activity

Rename HARNESS_FORK*() macros to HRN_FORK*().

Browse Source 
This matches the new pattern for harness macro naming and is shorter.
This commit is contained in:
David Steele
2021-07-13 11:58:23 -04:00
parent d6797009f8
commit 76cfbf833d
26 changed files with 384 additions and 384 deletions
Download Patch File Download Diff File Expand all files Collapse all files

12
CONTRIBUTING.md
View File

@ -438,9 +438,9 @@ TEST_RESULT_LOG(
Sometimes it is useful to use a child process for testing. Below is a simple example. See [harnessFork.h](https://github.com/pgbackrest/pgbackrest/blob/master/test/src/common/harnessFork.h) for more details. Sometimes it is useful to use a child process for testing. Below is a simple example. See [harnessFork.h](https://github.com/pgbackrest/pgbackrest/blob/master/test/src/common/harnessFork.h) for more details.
``` ```
HARNESS_FORK_BEGIN() HRN_FORK_BEGIN()
{ {
HARNESS_FORK_CHILD_BEGIN(0, false) HRN_FORK_CHILD_BEGIN(0, false)
{ {
TEST_RESULT_INT_NE( TEST_RESULT_INT_NE(
lockAcquire(cfgOptionStr(cfgOptLockPath), STRDEF("stanza1"), STRDEF("999-ffffffff"), lockTypeBackup, 0, true), lockAcquire(cfgOptionStr(cfgOptLockPath), STRDEF("stanza1"), STRDEF("999-ffffffff"), lockTypeBackup, 0, true),
@ -449,9 +449,9 @@ HARNESS_FORK_BEGIN()
sleepMSec(1000); sleepMSec(1000);
lockRelease(true); lockRelease(true);
} }
HARNESS_FORK_CHILD_END(); HRN_FORK_CHILD_END();
HARNESS_FORK_PARENT_BEGIN() HRN_FORK_PARENT_BEGIN()
{ {
sleepMSec(250); sleepMSec(250);
@ -467,9 +467,9 @@ HARNESS_FORK_BEGIN()
"text - single stanza, no valid backups, backup/expire lock detected"); "text - single stanza, no valid backups, backup/expire lock detected");
} }
HARNESS_FORK_PARENT_END(); HRN_FORK_PARENT_END();
} }
HARNESS_FORK_END(); HRN_FORK_END();
``` ```
#### Testing using a shim #### Testing using a shim

12
doc/xml/contributing.xml
View File

@ -497,9 +497,9 @@ TEST_RESULT_LOG(
<p>Sometimes it is useful to use a child process for testing. Below is a simple example. See <link url="{[github-url-test-common]}/harnessFork.h">harnessFork.h</link> for more details.</p> <p>Sometimes it is useful to use a child process for testing. Below is a simple example. See <link url="{[github-url-test-common]}/harnessFork.h">harnessFork.h</link> for more details.</p>
<code-block> <code-block>
HARNESS_FORK_BEGIN() HRN_FORK_BEGIN()
{ {
HARNESS_FORK_CHILD_BEGIN(0, false) HRN_FORK_CHILD_BEGIN(0, false)
{ {
TEST_RESULT_INT_NE( TEST_RESULT_INT_NE(
lockAcquire(cfgOptionStr(cfgOptLockPath), STRDEF("stanza1"), STRDEF("999-ffffffff"), lockTypeBackup, 0, true), lockAcquire(cfgOptionStr(cfgOptLockPath), STRDEF("stanza1"), STRDEF("999-ffffffff"), lockTypeBackup, 0, true),
@ -508,9 +508,9 @@ HARNESS_FORK_BEGIN()
sleepMSec(1000); sleepMSec(1000);
lockRelease(true); lockRelease(true);
} }
HARNESS_FORK_CHILD_END(); HRN_FORK_CHILD_END();
HARNESS_FORK_PARENT_BEGIN() HRN_FORK_PARENT_BEGIN()
{ {
sleepMSec(250); sleepMSec(250);
@ -526,9 +526,9 @@ HARNESS_FORK_BEGIN()
"text - single stanza, no valid backups, backup/expire lock detected"); "text - single stanza, no valid backups, backup/expire lock detected");
} }
HARNESS_FORK_PARENT_END(); HRN_FORK_PARENT_END();
} }
HARNESS_FORK_END(); HRN_FORK_END();
</code-block> </code-block>
</section> </section>

154
test/src/common/harnessFork.h
View File

@ -6,34 +6,34 @@ polluting memory in the main process with something that can't easily be undone.
The general form of the fork harness is: The general form of the fork harness is:
HARNESS_FORK_BEGIN() HRN_FORK_BEGIN()
{ {
// This block is required and can be repeated up to HARNESS_FORK_CHILD_MAX times. // This block is required and can be repeated up to HRN_FORK_CHILD_MAX times.
// //
// The first parameter is the expected exit code. If the child block does not have an explicit exit then it will automatically // The first parameter is the expected exit code. If the child block does not have an explicit exit then it will automatically
// exit on 0. // exit on 0.
// //
// The second parameter specifies whether pipes should be setup between the parent and child processes. These can be accessed // The second parameter specifies whether pipes should be setup between the parent and child processes. These can be accessed
// with the HARNESS_FORK_*() macros; // with the HRN_FORK_*() macros;
HARNESS_FORK_CHILD_BEGIN(0, true) HRN_FORK_CHILD_BEGIN(0, true)
{ {
// Child test code goes here // Child test code goes here
} }
HARNESS_FORK_CHILD_END(); HRN_FORK_CHILD_END();
// This block is optional but generally useful // This block is optional but generally useful
HARNESS_FORK_PARENT_BEGIN() HRN_FORK_PARENT_BEGIN()
{ {
// Parent test code goes here // Parent test code goes here
} }
HARNESS_FORK_PARENT_END(); HRN_FORK_PARENT_END();
} }
HARNESS_FORK_END(); HRN_FORK_END();
If the child process does not explicitly exit in HARNESS_FORK_CHILD_BEGIN/END() then it will exit with 0 at HARNESS_FORK_END(). If the child process does not explicitly exit in HRN_FORK_CHILD_BEGIN/END() then it will exit with 0 at HRN_FORK_END(). This harness
This harness is not intended for long-lived child processes. is not intended for long-lived child processes.
There should not be any code outside the HARNESS_FORK_CHILD_BEGIN/END() and HARNESS_FORK_PARENT_BEGIN/END() blocks. There should not be any code outside the HRN_FORK_CHILD_BEGIN/END() and HRN_FORK_PARENT_BEGIN/END() blocks.
***********************************************************************************************************************************/ ***********************************************************************************************************************************/
#include <sys/wait.h> #include <sys/wait.h>
#include <unistd.h> #include <unistd.h>
@ -43,149 +43,149 @@ There should not be any code outside the HARNESS_FORK_CHILD_BEGIN/END() and HARN
/*********************************************************************************************************************************** /***********************************************************************************************************************************
Define the max number of child processes allowed Define the max number of child processes allowed
***********************************************************************************************************************************/ ***********************************************************************************************************************************/
#define HARNESS_FORK_CHILD_MAX 4 #define HRN_FORK_CHILD_MAX 4
/*********************************************************************************************************************************** /***********************************************************************************************************************************
Total number of child processes forked Total number of child processes forked
***********************************************************************************************************************************/ ***********************************************************************************************************************************/
#define HARNESS_FORK_PROCESS_TOTAL() \ #define HRN_FORK_PROCESS_TOTAL() \
HARNESS_FORK_processTotal HRN_FORK_processTotal
/*********************************************************************************************************************************** /***********************************************************************************************************************************
Return the process index of the child (i.e. the index in the total) Return the process index of the child (i.e. the index in the total)
***********************************************************************************************************************************/ ***********************************************************************************************************************************/
#define HARNESS_FORK_PROCESS_IDX() \ #define HRN_FORK_PROCESS_IDX() \
HARNESS_FORK_processIdx HRN_FORK_processIdx
/*********************************************************************************************************************************** /***********************************************************************************************************************************
Return the id of the child process, 0 if in the child process Return the id of the child process, 0 if in the child process
***********************************************************************************************************************************/ ***********************************************************************************************************************************/
#define HARNESS_FORK_PROCESS_ID(processIdx) \ #define HRN_FORK_PROCESS_ID(processIdx) \
HARNESS_FORK_processIdList[processIdx] HRN_FORK_processIdList[processIdx]
/*********************************************************************************************************************************** /***********************************************************************************************************************************
Return the pipe for the child process Return the pipe for the child process
***********************************************************************************************************************************/ ***********************************************************************************************************************************/
#define HARNESS_FORK_PIPE(processIdx) \ #define HRN_FORK_PIPE(processIdx) \
HARNESS_FORK_pipe[processIdx] HRN_FORK_pipe[processIdx]
/*********************************************************************************************************************************** /***********************************************************************************************************************************
Is the pipe required for this child process? Is the pipe required for this child process?
***********************************************************************************************************************************/ ***********************************************************************************************************************************/
#define HARNESS_FORK_PIPE_REQUIRED(processIdx) \ #define HRN_FORK_PIPE_REQUIRED(processIdx) \
HARNESS_FORK_pipeRequired[processIdx] HRN_FORK_pipeRequired[processIdx]
/*********************************************************************************************************************************** /***********************************************************************************************************************************
Get read/write pipe file descriptors Get read/write pipe file descriptors
***********************************************************************************************************************************/ ***********************************************************************************************************************************/
#define HARNESS_FORK_CHILD_READ_PROCESS(processIdx) \ #define HRN_FORK_CHILD_READ_PROCESS(processIdx) \
HARNESS_FORK_PIPE(processIdx)[1][0] HRN_FORK_PIPE(processIdx)[1][0]
#define HARNESS_FORK_CHILD_READ() \ #define HRN_FORK_CHILD_READ() \
HARNESS_FORK_CHILD_READ_PROCESS(HARNESS_FORK_PROCESS_IDX()) HRN_FORK_CHILD_READ_PROCESS(HRN_FORK_PROCESS_IDX())
#define HARNESS_FORK_CHILD_WRITE_PROCESS(processIdx) \ #define HRN_FORK_CHILD_WRITE_PROCESS(processIdx) \
HARNESS_FORK_PIPE(processIdx)[0][1] HRN_FORK_PIPE(processIdx)[0][1]
#define HARNESS_FORK_CHILD_WRITE() \ #define HRN_FORK_CHILD_WRITE() \
HARNESS_FORK_CHILD_WRITE_PROCESS(HARNESS_FORK_PROCESS_IDX()) HRN_FORK_CHILD_WRITE_PROCESS(HRN_FORK_PROCESS_IDX())
#define HARNESS_FORK_PARENT_READ_PROCESS(processIdx) \ #define HRN_FORK_PARENT_READ_PROCESS(processIdx) \
HARNESS_FORK_PIPE(processIdx)[0][0] HRN_FORK_PIPE(processIdx)[0][0]
#define HARNESS_FORK_PARENT_WRITE_PROCESS(processIdx) \ #define HRN_FORK_PARENT_WRITE_PROCESS(processIdx) \
HARNESS_FORK_PIPE(processIdx)[1][1] HRN_FORK_PIPE(processIdx)[1][1]
/*********************************************************************************************************************************** /***********************************************************************************************************************************
At the end of the HARNESS_FORK block the parent will wait for the child to exit. By default an exit code of 0 is expected but that At the end of the HRN_FORK block the parent will wait for the child to exit. By default an exit code of 0 is expected but that can
can be modified when the child begins. be modified when the child begins.
***********************************************************************************************************************************/ ***********************************************************************************************************************************/
#define HARNESS_FORK_CHILD_EXPECTED_EXIT_STATUS(processIdx) \ #define HRN_FORK_CHILD_EXPECTED_EXIT_STATUS(processIdx) \
HARNESS_FORK_expectedExitStatus[processIdx] HRN_FORK_expectedExitStatus[processIdx]
/*********************************************************************************************************************************** /***********************************************************************************************************************************
Begin the fork block Begin the fork block
***********************************************************************************************************************************/ ***********************************************************************************************************************************/
#define HARNESS_FORK_BEGIN() \ #define HRN_FORK_BEGIN() \
do \ do \
{ \ { \
unsigned int HARNESS_FORK_PROCESS_TOTAL() = 0; \ unsigned int HRN_FORK_PROCESS_TOTAL() = 0; \
pid_t HARNESS_FORK_PROCESS_ID(HARNESS_FORK_CHILD_MAX) = {0}; \ pid_t HRN_FORK_PROCESS_ID(HRN_FORK_CHILD_MAX) = {0}; \
int HARNESS_FORK_CHILD_EXPECTED_EXIT_STATUS(HARNESS_FORK_CHILD_MAX) = {0}; \ int HRN_FORK_CHILD_EXPECTED_EXIT_STATUS(HRN_FORK_CHILD_MAX) = {0}; \
bool HARNESS_FORK_PIPE_REQUIRED(HARNESS_FORK_CHILD_MAX) = {0}; \ bool HRN_FORK_PIPE_REQUIRED(HRN_FORK_CHILD_MAX) = {0}; \
int HARNESS_FORK_PIPE(HARNESS_FORK_CHILD_MAX)[2][2] = {{{0}}}; int HRN_FORK_PIPE(HRN_FORK_CHILD_MAX)[2][2] = {{{0}}};
/*********************************************************************************************************************************** /***********************************************************************************************************************************
Create a child process Create a child process
***********************************************************************************************************************************/ ***********************************************************************************************************************************/
#define HARNESS_FORK_CHILD_BEGIN(expectedExitStatus, pipeRequired) \ #define HRN_FORK_CHILD_BEGIN(expectedExitStatus, pipeRequired) \
do \ do \
{ \ { \
HARNESS_FORK_CHILD_EXPECTED_EXIT_STATUS(HARNESS_FORK_PROCESS_TOTAL()) = expectedExitStatus; \ HRN_FORK_CHILD_EXPECTED_EXIT_STATUS(HRN_FORK_PROCESS_TOTAL()) = expectedExitStatus; \
\ \
if (pipeRequired) \ if (pipeRequired) \
{ \ { \
HARNESS_FORK_PIPE_REQUIRED(HARNESS_FORK_PROCESS_TOTAL()) = true; \ HRN_FORK_PIPE_REQUIRED(HRN_FORK_PROCESS_TOTAL()) = true; \
\ \
THROW_ON_SYS_ERROR_FMT( \ THROW_ON_SYS_ERROR_FMT( \
pipe(HARNESS_FORK_PIPE(HARNESS_FORK_PROCESS_TOTAL())[0]) == -1, KernelError, \ pipe(HRN_FORK_PIPE(HRN_FORK_PROCESS_TOTAL())[0]) == -1, KernelError, \
"unable to create read pipe for child process %u", HARNESS_FORK_PROCESS_TOTAL()); \ "unable to create read pipe for child process %u", HRN_FORK_PROCESS_TOTAL()); \
THROW_ON_SYS_ERROR_FMT( \ THROW_ON_SYS_ERROR_FMT( \
pipe(HARNESS_FORK_PIPE(HARNESS_FORK_PROCESS_TOTAL())[1]) == -1, KernelError, \ pipe(HRN_FORK_PIPE(HRN_FORK_PROCESS_TOTAL())[1]) == -1, KernelError, \
"unable to create write pipe for child process %u", HARNESS_FORK_PROCESS_TOTAL()); \ "unable to create write pipe for child process %u", HRN_FORK_PROCESS_TOTAL()); \
} \ } \
\ \
HARNESS_FORK_PROCESS_ID(HARNESS_FORK_PROCESS_TOTAL()) = fork(); \ HRN_FORK_PROCESS_ID(HRN_FORK_PROCESS_TOTAL()) = fork(); \
\ \
if (HARNESS_FORK_PROCESS_ID(HARNESS_FORK_PROCESS_TOTAL()) == 0) \ if (HRN_FORK_PROCESS_ID(HRN_FORK_PROCESS_TOTAL()) == 0) \
{ \ { \
unsigned int HARNESS_FORK_PROCESS_IDX() = HARNESS_FORK_PROCESS_TOTAL(); \ unsigned int HRN_FORK_PROCESS_IDX() = HRN_FORK_PROCESS_TOTAL(); \
\ \
/* Change log process id to aid in debugging */ \ /* Change log process id to aid in debugging */ \
hrnLogProcessIdSet(HARNESS_FORK_PROCESS_IDX() + 1); \ hrnLogProcessIdSet(HRN_FORK_PROCESS_IDX() + 1); \
\ \
if (pipeRequired) \ if (pipeRequired) \
{ \ { \
close(HARNESS_FORK_PARENT_READ_PROCESS(HARNESS_FORK_PROCESS_IDX())); \ close(HRN_FORK_PARENT_READ_PROCESS(HRN_FORK_PROCESS_IDX())); \
close(HARNESS_FORK_PARENT_WRITE_PROCESS(HARNESS_FORK_PROCESS_IDX())); \ close(HRN_FORK_PARENT_WRITE_PROCESS(HRN_FORK_PROCESS_IDX())); \
} }
#define HARNESS_FORK_CHILD_END() \ #define HRN_FORK_CHILD_END() \
if (HARNESS_FORK_PIPE_REQUIRED(HARNESS_FORK_PROCESS_IDX())) \ if (HRN_FORK_PIPE_REQUIRED(HRN_FORK_PROCESS_IDX())) \
{ \ { \
close(HARNESS_FORK_CHILD_READ()); \ close(HRN_FORK_CHILD_READ()); \
close(HARNESS_FORK_CHILD_WRITE()); \ close(HRN_FORK_CHILD_WRITE()); \
} \ } \
\ \
exit(0); \ exit(0); \
} \ } \
\ \
HARNESS_FORK_PROCESS_TOTAL()++; \ HRN_FORK_PROCESS_TOTAL()++; \
} \ } \
while (0) while (0)
/*********************************************************************************************************************************** /***********************************************************************************************************************************
Process in the parent Process in the parent
***********************************************************************************************************************************/ ***********************************************************************************************************************************/
#define HARNESS_FORK_PARENT_BEGIN() \ #define HRN_FORK_PARENT_BEGIN() \
do \ do \
{ \ { \
for (unsigned int processIdx = 0; processIdx < HARNESS_FORK_PROCESS_TOTAL(); processIdx++) \ for (unsigned int processIdx = 0; processIdx < HRN_FORK_PROCESS_TOTAL(); processIdx++) \
{ \ { \
if (HARNESS_FORK_PIPE_REQUIRED(processIdx)) \ if (HRN_FORK_PIPE_REQUIRED(processIdx)) \
{ \ { \
close(HARNESS_FORK_CHILD_READ_PROCESS(processIdx)); \ close(HRN_FORK_CHILD_READ_PROCESS(processIdx)); \
close(HARNESS_FORK_CHILD_WRITE_PROCESS(processIdx)); \ close(HRN_FORK_CHILD_WRITE_PROCESS(processIdx)); \
} \ } \
} }
#define HARNESS_FORK_PARENT_END() \ #define HRN_FORK_PARENT_END() \
for (unsigned int processIdx = 0; processIdx < HARNESS_FORK_PROCESS_TOTAL(); processIdx++) \ for (unsigned int processIdx = 0; processIdx < HRN_FORK_PROCESS_TOTAL(); processIdx++) \
{ \ { \
if (HARNESS_FORK_PIPE_REQUIRED(processIdx)) \ if (HRN_FORK_PIPE_REQUIRED(processIdx)) \
{ \ { \
close(HARNESS_FORK_PARENT_READ_PROCESS(processIdx)); \ close(HRN_FORK_PARENT_READ_PROCESS(processIdx)); \
close(HARNESS_FORK_PARENT_WRITE_PROCESS(processIdx)); \ close(HRN_FORK_PARENT_WRITE_PROCESS(processIdx)); \
} \ } \
} \ } \
} \ } \
@ -194,19 +194,19 @@ Process in the parent
/*********************************************************************************************************************************** /***********************************************************************************************************************************
End the fork block and check exit status for all child processes End the fork block and check exit status for all child processes
***********************************************************************************************************************************/ ***********************************************************************************************************************************/
#define HARNESS_FORK_END() \ #define HRN_FORK_END() \
for (unsigned int processIdx = 0; processIdx < HARNESS_FORK_PROCESS_TOTAL(); processIdx++) \ for (unsigned int processIdx = 0; processIdx < HRN_FORK_PROCESS_TOTAL(); processIdx++) \
{ \ { \
int processStatus; \ int processStatus; \
\ \
if (waitpid(HARNESS_FORK_PROCESS_ID(processIdx), &processStatus, 0) != HARNESS_FORK_PROCESS_ID(processIdx)) \ if (waitpid(HRN_FORK_PROCESS_ID(processIdx), &processStatus, 0) != HRN_FORK_PROCESS_ID(processIdx)) \
THROW_SYS_ERROR_FMT(AssertError, "unable to find child process %u", processIdx); \ THROW_SYS_ERROR_FMT(AssertError, "unable to find child process %u", processIdx); \
\ \
if (WEXITSTATUS(processStatus) != HARNESS_FORK_CHILD_EXPECTED_EXIT_STATUS(processIdx)) \ if (WEXITSTATUS(processStatus) != HRN_FORK_CHILD_EXPECTED_EXIT_STATUS(processIdx)) \
{ \ { \
THROW_FMT( \ THROW_FMT( \
AssertError, "child %u exited with error %d but expected %d", processIdx, WEXITSTATUS(processStatus), \ AssertError, "child %u exited with error %d but expected %d", processIdx, WEXITSTATUS(processStatus), \
HARNESS_FORK_CHILD_EXPECTED_EXIT_STATUS(processIdx)); \ HRN_FORK_CHILD_EXPECTED_EXIT_STATUS(processIdx)); \
} \ } \
} \ } \
} \ } \

12
test/src/module/command/archiveCommonTest.c
View File

@ -252,9 +252,9 @@ testRun(void)
TEST_TITLE("timeout"); TEST_TITLE("timeout");
// Check timeout by making the wal segment appear after 250ms // Check timeout by making the wal segment appear after 250ms
HARNESS_FORK_BEGIN() HRN_FORK_BEGIN()
{ {
HARNESS_FORK_CHILD_BEGIN(0, false) HRN_FORK_CHILD_BEGIN(0, false)
{ {
sleepMSec(250); sleepMSec(250);
@ -262,17 +262,17 @@ testRun(void)
storageTest, storageTest,
"archive/db/9.6-2/1234567812345678/123456781234567812345678-aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"); "archive/db/9.6-2/1234567812345678/123456781234567812345678-aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa");
} }
HARNESS_FORK_CHILD_END(); HRN_FORK_CHILD_END();
HARNESS_FORK_PARENT_BEGIN() HRN_FORK_PARENT_BEGIN()
{ {
TEST_RESULT_STR_Z( TEST_RESULT_STR_Z(
walSegmentFind(storageRepo(), STRDEF("9.6-2"), STRDEF("123456781234567812345678"), 1000), walSegmentFind(storageRepo(), STRDEF("9.6-2"), STRDEF("123456781234567812345678"), 1000),
"123456781234567812345678-aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", "found segment"); "123456781234567812345678-aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", "found segment");
} }
HARNESS_FORK_PARENT_END(); HRN_FORK_PARENT_END();
} }
HARNESS_FORK_END(); HRN_FORK_END();
// ------------------------------------------------------------------------------------------------------------------------- // -------------------------------------------------------------------------------------------------------------------------
TEST_TITLE("duplicate"); TEST_TITLE("duplicate");

20
test/src/module/command/archiveGetTest.c
View File

@ -731,12 +731,12 @@ testRun(void)
TEST_TITLE("unable to get lock"); TEST_TITLE("unable to get lock");
// Make sure the process times out when it can't get a lock // Make sure the process times out when it can't get a lock
HARNESS_FORK_BEGIN() HRN_FORK_BEGIN()
{ {
HARNESS_FORK_CHILD_BEGIN(0, true) HRN_FORK_CHILD_BEGIN(0, true)
{ {
IoRead *read = ioFdReadNewOpen(STRDEF("child read"), HARNESS_FORK_CHILD_READ(), 2000); IoRead *read = ioFdReadNewOpen(STRDEF("child read"), HRN_FORK_CHILD_READ(), 2000);
IoWrite *write = ioFdWriteNewOpen(STRDEF("child write"), HARNESS_FORK_CHILD_WRITE(), 2000); IoWrite *write = ioFdWriteNewOpen(STRDEF("child write"), HRN_FORK_CHILD_WRITE(), 2000);
TEST_RESULT_VOID( TEST_RESULT_VOID(
lockAcquire( lockAcquire(
@ -751,12 +751,12 @@ testRun(void)
lockRelease(true); lockRelease(true);
} }
HARNESS_FORK_CHILD_END(); HRN_FORK_CHILD_END();
HARNESS_FORK_PARENT_BEGIN() HRN_FORK_PARENT_BEGIN()
{ {
IoRead *read = ioFdReadNewOpen(STRDEF("parent read"), HARNESS_FORK_PARENT_READ_PROCESS(0), 2000); IoRead *read = ioFdReadNewOpen(STRDEF("parent read"), HRN_FORK_PARENT_READ_PROCESS(0), 2000);
IoWrite *write = ioFdWriteNewOpen(STRDEF("parent write"), HARNESS_FORK_PARENT_WRITE_PROCESS(0), 2000); IoWrite *write = ioFdWriteNewOpen(STRDEF("parent write"), HRN_FORK_PARENT_WRITE_PROCESS(0), 2000);
// Wait for the child to acquire the lock // Wait for the child to acquire the lock
ioReadLine(read); ioReadLine(read);
@ -769,9 +769,9 @@ testRun(void)
ioWriteLine(write, bufNew(0)); ioWriteLine(write, bufNew(0));
ioWriteFlush(write); ioWriteFlush(write);
} }
HARNESS_FORK_PARENT_END(); HRN_FORK_PARENT_END();
} }
HARNESS_FORK_END(); HRN_FORK_END();
// ------------------------------------------------------------------------------------------------------------------------- // -------------------------------------------------------------------------------------------------------------------------
TEST_TITLE("too many parameters specified"); TEST_TITLE("too many parameters specified");

20
test/src/module/command/archivePushTest.c
View File

@ -709,12 +709,12 @@ testRun(void)
THROW_ON_SYS_ERROR(chdir(strZ(cfgOptionStr(cfgOptPgPath))) != 0, PathMissingError, "unable to chdir()"); THROW_ON_SYS_ERROR(chdir(strZ(cfgOptionStr(cfgOptPgPath))) != 0, PathMissingError, "unable to chdir()");
HARNESS_FORK_BEGIN() HRN_FORK_BEGIN()
{ {
HARNESS_FORK_CHILD_BEGIN(0, true) HRN_FORK_CHILD_BEGIN(0, true)
{ {
IoRead *read = ioFdReadNewOpen(STRDEF("child read"), HARNESS_FORK_CHILD_READ(), 2000); IoRead *read = ioFdReadNewOpen(STRDEF("child read"), HRN_FORK_CHILD_READ(), 2000);
IoWrite *write = ioFdWriteNewOpen(STRDEF("child write"), HARNESS_FORK_CHILD_WRITE(), 2000); IoWrite *write = ioFdWriteNewOpen(STRDEF("child write"), HRN_FORK_CHILD_WRITE(), 2000);
lockAcquire( lockAcquire(
cfgOptionStr(cfgOptLockPath), cfgOptionStr(cfgOptStanza), STRDEF("555-fefefefe"), cfgLockType(), 30000, true); cfgOptionStr(cfgOptLockPath), cfgOptionStr(cfgOptStanza), STRDEF("555-fefefefe"), cfgLockType(), 30000, true);
@ -726,12 +726,12 @@ testRun(void)
lockRelease(true); lockRelease(true);
} }
HARNESS_FORK_CHILD_END(); HRN_FORK_CHILD_END();
HARNESS_FORK_PARENT_BEGIN() HRN_FORK_PARENT_BEGIN()
{ {
IoRead *read = ioFdReadNewOpen(STRDEF("parent read"), HARNESS_FORK_PARENT_READ_PROCESS(0), 2000); IoRead *read = ioFdReadNewOpen(STRDEF("parent read"), HRN_FORK_PARENT_READ_PROCESS(0), 2000);
IoWrite *write = ioFdWriteNewOpen(STRDEF("parent write"), HARNESS_FORK_PARENT_WRITE_PROCESS(0), 2000); IoWrite *write = ioFdWriteNewOpen(STRDEF("parent write"), HRN_FORK_PARENT_WRITE_PROCESS(0), 2000);
// Wait for the child to acquire the lock // Wait for the child to acquire the lock
ioReadLine(read); ioReadLine(read);
@ -744,9 +744,9 @@ testRun(void)
ioWriteLine(write, bufNew(0)); ioWriteLine(write, bufNew(0));
ioWriteFlush(write); ioWriteFlush(write);
} }
HARNESS_FORK_PARENT_END(); HRN_FORK_PARENT_END();
} }
HARNESS_FORK_END(); HRN_FORK_END();
// ------------------------------------------------------------------------------------------------------------------------- // -------------------------------------------------------------------------------------------------------------------------
TEST_TITLE("async WAL push"); TEST_TITLE("async WAL push");

80
test/src/module/command/controlTest.c
View File

@ -160,12 +160,12 @@ testRun(void)
HRN_STORAGE_REMOVE(hrnStorage, "lock/db" STOP_FILE_EXT, .errorOnMissing = true, .comment = "remove stanza stop file"); HRN_STORAGE_REMOVE(hrnStorage, "lock/db" STOP_FILE_EXT, .errorOnMissing = true, .comment = "remove stanza stop file");
HRN_STORAGE_PUT_EMPTY(hrnStorage, "lock/empty" LOCK_FILE_EXT, .comment = "create empty lock file"); HRN_STORAGE_PUT_EMPTY(hrnStorage, "lock/empty" LOCK_FILE_EXT, .comment = "create empty lock file");
HARNESS_FORK_BEGIN() HRN_FORK_BEGIN()
{ {
HARNESS_FORK_CHILD_BEGIN(0, true) HRN_FORK_CHILD_BEGIN(0, true)
{ {
IoRead *read = ioFdReadNewOpen(STRDEF("child read"), HARNESS_FORK_CHILD_READ(), 2000); IoRead *read = ioFdReadNewOpen(STRDEF("child read"), HRN_FORK_CHILD_READ(), 2000);
IoWrite *write = ioFdWriteNewOpen(STRDEF("child write"), HARNESS_FORK_CHILD_WRITE(), 2000); IoWrite *write = ioFdWriteNewOpen(STRDEF("child write"), HRN_FORK_CHILD_WRITE(), 2000);
int lockFd = open(HRN_PATH "/lock/empty" LOCK_FILE_EXT, O_RDONLY, 0); int lockFd = open(HRN_PATH "/lock/empty" LOCK_FILE_EXT, O_RDONLY, 0);
TEST_RESULT_BOOL(lockFd != -1, true, "file descriptor acquired"); TEST_RESULT_BOOL(lockFd != -1, true, "file descriptor acquired");
@ -181,12 +181,12 @@ testRun(void)
// Parent removed the file so just close the file descriptor // Parent removed the file so just close the file descriptor
close(lockFd); close(lockFd);
} }
HARNESS_FORK_CHILD_END(); HRN_FORK_CHILD_END();
HARNESS_FORK_PARENT_BEGIN() HRN_FORK_PARENT_BEGIN()
{ {
IoRead *read = ioFdReadNewOpen(STRDEF("parent read"), HARNESS_FORK_PARENT_READ_PROCESS(0), 2000); IoRead *read = ioFdReadNewOpen(STRDEF("parent read"), HRN_FORK_PARENT_READ_PROCESS(0), 2000);
IoWrite *write = ioFdWriteNewOpen(STRDEF("parent write"), HARNESS_FORK_PARENT_WRITE_PROCESS(0), 2000); IoWrite *write = ioFdWriteNewOpen(STRDEF("parent write"), HRN_FORK_PARENT_WRITE_PROCESS(0), 2000);
// Wait for the child to acquire the lock // Wait for the child to acquire the lock
ioReadLine(read); ioReadLine(read);
@ -200,9 +200,9 @@ testRun(void)
ioWriteLine(write, bufNew(0)); ioWriteLine(write, bufNew(0));
ioWriteFlush(write); ioWriteFlush(write);
} }
HARNESS_FORK_PARENT_END(); HRN_FORK_PARENT_END();
} }
HARNESS_FORK_END(); HRN_FORK_END();
// ------------------------------------------------------------------------------------------------------------------------- // -------------------------------------------------------------------------------------------------------------------------
TEST_TITLE("not empty lock file with another process lock, processId size trimmed to 0"); TEST_TITLE("not empty lock file with another process lock, processId size trimmed to 0");
@ -210,12 +210,12 @@ testRun(void)
HRN_STORAGE_REMOVE(hrnStorage, "lock/db" STOP_FILE_EXT, .errorOnMissing = true, .comment = "remove stanza stop file"); HRN_STORAGE_REMOVE(hrnStorage, "lock/db" STOP_FILE_EXT, .errorOnMissing = true, .comment = "remove stanza stop file");
HRN_STORAGE_PUT_Z(hrnStorage, "lock/empty" LOCK_FILE_EXT, " ", .comment = "create non-empty lock file"); HRN_STORAGE_PUT_Z(hrnStorage, "lock/empty" LOCK_FILE_EXT, " ", .comment = "create non-empty lock file");
HARNESS_FORK_BEGIN() HRN_FORK_BEGIN()
{ {
HARNESS_FORK_CHILD_BEGIN(0, true) HRN_FORK_CHILD_BEGIN(0, true)
{ {
IoRead *read = ioFdReadNewOpen(STRDEF("child read"), HARNESS_FORK_CHILD_READ(), 2000); IoRead *read = ioFdReadNewOpen(STRDEF("child read"), HRN_FORK_CHILD_READ(), 2000);
IoWrite *write = ioFdWriteNewOpen(STRDEF("child write"), HARNESS_FORK_CHILD_WRITE(), 2000); IoWrite *write = ioFdWriteNewOpen(STRDEF("child write"), HRN_FORK_CHILD_WRITE(), 2000);
int lockFd = open(HRN_PATH "/lock/empty" LOCK_FILE_EXT, O_RDONLY, 0); int lockFd = open(HRN_PATH "/lock/empty" LOCK_FILE_EXT, O_RDONLY, 0);
TEST_RESULT_BOOL(lockFd != -1, true, "file descriptor acquired"); TEST_RESULT_BOOL(lockFd != -1, true, "file descriptor acquired");
@ -231,12 +231,12 @@ testRun(void)
// Parent removed the file so just close the file descriptor // Parent removed the file so just close the file descriptor
close(lockFd); close(lockFd);
} }
HARNESS_FORK_CHILD_END(); HRN_FORK_CHILD_END();
HARNESS_FORK_PARENT_BEGIN() HRN_FORK_PARENT_BEGIN()
{ {
IoRead *read = ioFdReadNewOpen(STRDEF("parent read"), HARNESS_FORK_PARENT_READ_PROCESS(0), 2000); IoRead *read = ioFdReadNewOpen(STRDEF("parent read"), HRN_FORK_PARENT_READ_PROCESS(0), 2000);
IoWrite *write = ioFdWriteNewOpen(STRDEF("parent write"), HARNESS_FORK_PARENT_WRITE_PROCESS(0), 2000); IoWrite *write = ioFdWriteNewOpen(STRDEF("parent write"), HRN_FORK_PARENT_WRITE_PROCESS(0), 2000);
// Wait for the child to acquire the lock // Wait for the child to acquire the lock
ioReadLine(read); ioReadLine(read);
@ -250,20 +250,20 @@ testRun(void)
ioWriteLine(write, bufNew(0)); ioWriteLine(write, bufNew(0));
ioWriteFlush(write); ioWriteFlush(write);
} }
HARNESS_FORK_PARENT_END(); HRN_FORK_PARENT_END();
} }
HARNESS_FORK_END(); HRN_FORK_END();
// ------------------------------------------------------------------------------------------------------------------------- // -------------------------------------------------------------------------------------------------------------------------
TEST_TITLE("lock file with another process lock, processId is valid"); TEST_TITLE("lock file with another process lock, processId is valid");
HRN_STORAGE_REMOVE(hrnStorage, "lock/db" STOP_FILE_EXT, .errorOnMissing = true, .comment = "remove stanza stop file"); HRN_STORAGE_REMOVE(hrnStorage, "lock/db" STOP_FILE_EXT, .errorOnMissing = true, .comment = "remove stanza stop file");
HARNESS_FORK_BEGIN() HRN_FORK_BEGIN()
{ {
HARNESS_FORK_CHILD_BEGIN(0, true) HRN_FORK_CHILD_BEGIN(0, true)
{ {
IoRead *read = ioFdReadNewOpen(STRDEF("child read"), HARNESS_FORK_CHILD_READ(), 2000); IoRead *read = ioFdReadNewOpen(STRDEF("child read"), HRN_FORK_CHILD_READ(), 2000);
IoWrite *write = ioFdWriteNewOpen(STRDEF("child write"), HARNESS_FORK_CHILD_WRITE(), 2000); IoWrite *write = ioFdWriteNewOpen(STRDEF("child write"), HRN_FORK_CHILD_WRITE(), 2000);
TEST_RESULT_BOOL( TEST_RESULT_BOOL(
lockAcquire(STRDEF(HRN_PATH "/lock"), cfgOptionStr(cfgOptStanza), cfgOptionStr(cfgOptExecId), 0, 30000, true), lockAcquire(STRDEF(HRN_PATH "/lock"), cfgOptionStr(cfgOptStanza), cfgOptionStr(cfgOptExecId), 0, 30000, true),
@ -276,11 +276,11 @@ testRun(void)
// Wait for a linefeed from the parent but it will not arrive before the process is terminated // Wait for a linefeed from the parent but it will not arrive before the process is terminated
ioReadLine(read); ioReadLine(read);
} }
HARNESS_FORK_CHILD_END(); HRN_FORK_CHILD_END();
HARNESS_FORK_PARENT_BEGIN() HRN_FORK_PARENT_BEGIN()
{ {
IoRead *read = ioFdReadNewOpen(STRDEF("parent read"), HARNESS_FORK_PARENT_READ_PROCESS(0), 2000); IoRead *read = ioFdReadNewOpen(STRDEF("parent read"), HRN_FORK_PARENT_READ_PROCESS(0), 2000);
// Wait for the child to acquire the lock // Wait for the child to acquire the lock
ioReadLine(read); ioReadLine(read);
@ -288,11 +288,11 @@ testRun(void)
TEST_RESULT_VOID( TEST_RESULT_VOID(
cmdStop(), "stanza, create stop file, force - lock file with another process lock, processId is valid"); cmdStop(), "stanza, create stop file, force - lock file with another process lock, processId is valid");
TEST_RESULT_LOG_FMT("P00 INFO: sent term signal to process %d", HARNESS_FORK_PROCESS_ID(0)); TEST_RESULT_LOG_FMT("P00 INFO: sent term signal to process %d", HRN_FORK_PROCESS_ID(0));
} }
HARNESS_FORK_PARENT_END(); HRN_FORK_PARENT_END();
} }
HARNESS_FORK_END(); HRN_FORK_END();
// ------------------------------------------------------------------------------------------------------------------------- // -------------------------------------------------------------------------------------------------------------------------
TEST_TITLE("lock file with another process lock, processId is invalid"); TEST_TITLE("lock file with another process lock, processId is invalid");
@ -300,12 +300,12 @@ testRun(void)
HRN_STORAGE_REMOVE(hrnStorage, "lock/db" STOP_FILE_EXT, .errorOnMissing = true, .comment = "remove stanza stop file"); HRN_STORAGE_REMOVE(hrnStorage, "lock/db" STOP_FILE_EXT, .errorOnMissing = true, .comment = "remove stanza stop file");
HRN_STORAGE_PUT_Z(hrnStorage, "lock/badpid" LOCK_FILE_EXT, "-32768", .comment = "create lock file with invalid PID"); HRN_STORAGE_PUT_Z(hrnStorage, "lock/badpid" LOCK_FILE_EXT, "-32768", .comment = "create lock file with invalid PID");
HARNESS_FORK_BEGIN() HRN_FORK_BEGIN()
{ {
HARNESS_FORK_CHILD_BEGIN(0, true) HRN_FORK_CHILD_BEGIN(0, true)
{ {
IoRead *read = ioFdReadNewOpen(STRDEF("child read"), HARNESS_FORK_CHILD_READ(), 2000); IoRead *read = ioFdReadNewOpen(STRDEF("child read"), HRN_FORK_CHILD_READ(), 2000);
IoWrite *write = ioFdWriteNewOpen(STRDEF("child write"), HARNESS_FORK_CHILD_WRITE(), 2000); IoWrite *write = ioFdWriteNewOpen(STRDEF("child write"), HRN_FORK_CHILD_WRITE(), 2000);
int lockFd = open(HRN_PATH "/lock/badpid" LOCK_FILE_EXT, O_RDONLY, 0); int lockFd = open(HRN_PATH "/lock/badpid" LOCK_FILE_EXT, O_RDONLY, 0);
TEST_RESULT_BOOL(lockFd != -1, true, "file descriptor acquired"); TEST_RESULT_BOOL(lockFd != -1, true, "file descriptor acquired");
@ -322,12 +322,12 @@ testRun(void)
HRN_STORAGE_REMOVE(hrnStorage, "lock/badpid" LOCK_FILE_EXT); HRN_STORAGE_REMOVE(hrnStorage, "lock/badpid" LOCK_FILE_EXT);
close(lockFd); close(lockFd);
} }
HARNESS_FORK_CHILD_END(); HRN_FORK_CHILD_END();
HARNESS_FORK_PARENT_BEGIN() HRN_FORK_PARENT_BEGIN()
{ {
IoRead *read = ioFdReadNewOpen(STRDEF("parent read"), HARNESS_FORK_PARENT_READ_PROCESS(0), 2000); IoRead *read = ioFdReadNewOpen(STRDEF("parent read"), HRN_FORK_PARENT_READ_PROCESS(0), 2000);
IoWrite *write = ioFdWriteNewOpen(STRDEF("parent write"), HARNESS_FORK_PARENT_WRITE_PROCESS(0), 2000); IoWrite *write = ioFdWriteNewOpen(STRDEF("parent write"), HRN_FORK_PARENT_WRITE_PROCESS(0), 2000);
// Wait for the child to acquire the lock // Wait for the child to acquire the lock
ioReadLine(read); ioReadLine(read);
@ -341,9 +341,9 @@ testRun(void)
ioWriteLine(write, bufNew(0)); ioWriteLine(write, bufNew(0));
ioWriteFlush(write); ioWriteFlush(write);
} }
HARNESS_FORK_PARENT_END(); HRN_FORK_PARENT_END();
} }
HARNESS_FORK_END(); HRN_FORK_END();
} }
FUNCTION_HARNESS_RETURN_VOID(); FUNCTION_HARNESS_RETURN_VOID();

48
test/src/module/command/infoTest.c
View File

@ -226,9 +226,9 @@ testRun(void)
// archive section will cross reference backup db-id 2 to archive db-id 3 but db section will only use the db-ids from // archive section will cross reference backup db-id 2 to archive db-id 3 but db section will only use the db-ids from
// backup.info. Execute while a backup lock is held. // backup.info. Execute while a backup lock is held.
HARNESS_FORK_BEGIN() HRN_FORK_BEGIN()
{ {
HARNESS_FORK_CHILD_BEGIN(0, false) HRN_FORK_CHILD_BEGIN(0, false)
{ {
TEST_RESULT_INT_NE( TEST_RESULT_INT_NE(
lockAcquire(cfgOptionStr(cfgOptLockPath), STRDEF("stanza1"), STRDEF("999-ffffffff"), lockTypeBackup, 0, true), lockAcquire(cfgOptionStr(cfgOptLockPath), STRDEF("stanza1"), STRDEF("999-ffffffff"), lockTypeBackup, 0, true),
@ -237,9 +237,9 @@ testRun(void)
sleepMSec(1000); sleepMSec(1000);
lockRelease(true); lockRelease(true);
} }
HARNESS_FORK_CHILD_END(); HRN_FORK_CHILD_END();
HARNESS_FORK_PARENT_BEGIN() HRN_FORK_PARENT_BEGIN()
{ {
sleepMSec(250); sleepMSec(250);
@ -307,9 +307,9 @@ testRun(void)
"text - single stanza, no valid backups, backup/expire lock detected"); "text - single stanza, no valid backups, backup/expire lock detected");
} }
HARNESS_FORK_PARENT_END(); HRN_FORK_PARENT_END();
} }
HARNESS_FORK_END(); HRN_FORK_END();
//-------------------------------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------------------------------
TEST_TITLE("multi-repo - stanza missing on specified repo"); TEST_TITLE("multi-repo - stanza missing on specified repo");
@ -409,9 +409,9 @@ testRun(void)
"\"db-version\":\"9.4\"}\n"); "\"db-version\":\"9.4\"}\n");
// Execute while a backup lock is held // Execute while a backup lock is held
HARNESS_FORK_BEGIN() HRN_FORK_BEGIN()
{ {
HARNESS_FORK_CHILD_BEGIN(0, false) HRN_FORK_CHILD_BEGIN(0, false)
{ {
TEST_RESULT_INT_NE( TEST_RESULT_INT_NE(
lockAcquire(cfgOptionStr(cfgOptLockPath), STRDEF("stanza1"), STRDEF("777-afafafaf"), lockTypeBackup, 0, true), lockAcquire(cfgOptionStr(cfgOptLockPath), STRDEF("stanza1"), STRDEF("777-afafafaf"), lockTypeBackup, 0, true),
@ -420,9 +420,9 @@ testRun(void)
sleepMSec(1000); sleepMSec(1000);
lockRelease(true); lockRelease(true);
} }
HARNESS_FORK_CHILD_END(); HRN_FORK_CHILD_END();
HARNESS_FORK_PARENT_BEGIN() HRN_FORK_PARENT_BEGIN()
{ {
sleepMSec(250); sleepMSec(250);
@ -589,9 +589,9 @@ testRun(void)
" repo1: backup set size: 3MB, backup size: 3KB\n", " repo1: backup set size: 3MB, backup size: 3KB\n",
"text - single stanza, valid backup, no priors, no archives in latest DB, backup/expire lock detected"); "text - single stanza, valid backup, no priors, no archives in latest DB, backup/expire lock detected");
} }
HARNESS_FORK_PARENT_END(); HRN_FORK_PARENT_END();
} }
HARNESS_FORK_END(); HRN_FORK_END();
// Cleanup // Cleanup
HRN_STORAGE_PATH_REMOVE(storageTest, TEST_PATH "/repo/" STORAGE_PATH_ARCHIVE "/stanza1/9.3-2", .recurse = true); HRN_STORAGE_PATH_REMOVE(storageTest, TEST_PATH "/repo/" STORAGE_PATH_ARCHIVE "/stanza1/9.3-2", .recurse = true);
@ -989,9 +989,9 @@ testRun(void)
StringList *argListMultiRepoJson = strLstDup(argListMultiRepo); StringList *argListMultiRepoJson = strLstDup(argListMultiRepo);
hrnCfgArgRawZ(argListMultiRepoJson, cfgOptOutput, "json"); hrnCfgArgRawZ(argListMultiRepoJson, cfgOptOutput, "json");
HARNESS_FORK_BEGIN() HRN_FORK_BEGIN()
{ {
HARNESS_FORK_CHILD_BEGIN(0, false) HRN_FORK_CHILD_BEGIN(0, false)
{ {
TEST_RESULT_INT_NE( TEST_RESULT_INT_NE(
lockAcquire(cfgOptionStr(cfgOptLockPath), STRDEF("stanza2"), STRDEF("999-ffffffff"), lockTypeBackup, 0, true), lockAcquire(cfgOptionStr(cfgOptLockPath), STRDEF("stanza2"), STRDEF("999-ffffffff"), lockTypeBackup, 0, true),
@ -1000,9 +1000,9 @@ testRun(void)
sleepMSec(1000); sleepMSec(1000);
lockRelease(true); lockRelease(true);
} }
HARNESS_FORK_CHILD_END(); HRN_FORK_CHILD_END();
HARNESS_FORK_PARENT_BEGIN() HRN_FORK_PARENT_BEGIN()
{ {
sleepMSec(250); sleepMSec(250);
@ -1403,13 +1403,13 @@ testRun(void)
"]", "]",
"json - multiple stanzas, some with valid backups, archives in latest DB, backup lock held on one stanza"); "json - multiple stanzas, some with valid backups, archives in latest DB, backup lock held on one stanza");
} }
HARNESS_FORK_PARENT_END(); HRN_FORK_PARENT_END();
} }
HARNESS_FORK_END(); HRN_FORK_END();
HARNESS_FORK_BEGIN() HRN_FORK_BEGIN()
{ {
HARNESS_FORK_CHILD_BEGIN(0, false) HRN_FORK_CHILD_BEGIN(0, false)
{ {
TEST_RESULT_INT_NE( TEST_RESULT_INT_NE(
lockAcquire(cfgOptionStr(cfgOptLockPath), STRDEF("stanza2"), STRDEF("999-ffffffff"), lockTypeBackup, 0, true), lockAcquire(cfgOptionStr(cfgOptLockPath), STRDEF("stanza2"), STRDEF("999-ffffffff"), lockTypeBackup, 0, true),
@ -1418,9 +1418,9 @@ testRun(void)
sleepMSec(1000); sleepMSec(1000);
lockRelease(true); lockRelease(true);
} }
HARNESS_FORK_CHILD_END(); HRN_FORK_CHILD_END();
HARNESS_FORK_PARENT_BEGIN() HRN_FORK_PARENT_BEGIN()
{ {
sleepMSec(250); sleepMSec(250);
@ -1507,9 +1507,9 @@ testRun(void)
" repo2: backup set size: 3MB, backup size: 3KB\n", " repo2: backup set size: 3MB, backup size: 3KB\n",
"text - multiple stanzas, multi-repo with valid backups, backup lock held on one stanza"); "text - multiple stanzas, multi-repo with valid backups, backup lock held on one stanza");
} }
HARNESS_FORK_PARENT_END(); HRN_FORK_PARENT_END();
} }
HARNESS_FORK_END(); HRN_FORK_END();
//-------------------------------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------------------------------
TEST_TITLE("multi-repo: stanza exists but requested backup does not"); TEST_TITLE("multi-repo: stanza exists but requested backup does not");

18
test/src/module/command/localTest.c
View File

@ -26,9 +26,9 @@ testRun(void)
THROW_ON_SYS_ERROR(pipe(pipeRead) == -1, KernelError, "unable to read test pipe"); THROW_ON_SYS_ERROR(pipe(pipeRead) == -1, KernelError, "unable to read test pipe");
THROW_ON_SYS_ERROR(pipe(pipeWrite) == -1, KernelError, "unable to write test pipe"); THROW_ON_SYS_ERROR(pipe(pipeWrite) == -1, KernelError, "unable to write test pipe");
HARNESS_FORK_BEGIN() HRN_FORK_BEGIN()
{ {
HARNESS_FORK_CHILD_BEGIN(0, true) HRN_FORK_CHILD_BEGIN(0, true)
{ {
StringList *argList = strLstNew(); StringList *argList = strLstNew();
strLstAddZ(argList, "--stanza=test1"); strLstAddZ(argList, "--stanza=test1");
@ -37,22 +37,22 @@ testRun(void)
hrnCfgArgRawStrId(argList, cfgOptRemoteType, protocolStorageTypeRepo); hrnCfgArgRawStrId(argList, cfgOptRemoteType, protocolStorageTypeRepo);
HRN_CFG_LOAD(cfgCmdArchiveGet, argList, .role = cfgCmdRoleLocal); HRN_CFG_LOAD(cfgCmdArchiveGet, argList, .role = cfgCmdRoleLocal);
cmdLocal(HARNESS_FORK_CHILD_READ(), HARNESS_FORK_CHILD_WRITE()); cmdLocal(HRN_FORK_CHILD_READ(), HRN_FORK_CHILD_WRITE());
} }
HARNESS_FORK_CHILD_END(); HRN_FORK_CHILD_END();
HARNESS_FORK_PARENT_BEGIN() HRN_FORK_PARENT_BEGIN()
{ {
ProtocolClient *client = protocolClientNew( ProtocolClient *client = protocolClientNew(
STRDEF("test"), PROTOCOL_SERVICE_LOCAL_STR, STRDEF("test"), PROTOCOL_SERVICE_LOCAL_STR,
ioFdReadNewOpen(STRDEF("server read"), HARNESS_FORK_PARENT_READ_PROCESS(0), 2000), ioFdReadNewOpen(STRDEF("server read"), HRN_FORK_PARENT_READ_PROCESS(0), 2000),
ioFdWriteNewOpen(STRDEF("server write"), HARNESS_FORK_PARENT_WRITE_PROCESS(0), 2000)); ioFdWriteNewOpen(STRDEF("server write"), HRN_FORK_PARENT_WRITE_PROCESS(0), 2000));
protocolClientNoOp(client); protocolClientNoOp(client);
protocolClientFree(client); protocolClientFree(client);
} }
HARNESS_FORK_PARENT_END(); HRN_FORK_PARENT_END();
} }
HARNESS_FORK_END(); HRN_FORK_END();
} }
FUNCTION_HARNESS_RETURN_VOID(); FUNCTION_HARNESS_RETURN_VOID();

90
test/src/module/command/remoteTest.c
View File

@ -27,9 +27,9 @@ testRun(void)
// ------------------------------------------------------------------------------------------------------------------------- // -------------------------------------------------------------------------------------------------------------------------
TEST_TITLE("no lock is required because process is > 0 (not the main remote)"); TEST_TITLE("no lock is required because process is > 0 (not the main remote)");
HARNESS_FORK_BEGIN() HRN_FORK_BEGIN()
{ {
HARNESS_FORK_CHILD_BEGIN(0, true) HRN_FORK_CHILD_BEGIN(0, true)
{ {
StringList *argList = strLstNew(); StringList *argList = strLstNew();
strLstAddZ(argList, "--stanza=test1"); strLstAddZ(argList, "--stanza=test1");
@ -37,29 +37,29 @@ testRun(void)
hrnCfgArgRawStrId(argList, cfgOptRemoteType, protocolStorageTypeRepo); hrnCfgArgRawStrId(argList, cfgOptRemoteType, protocolStorageTypeRepo);
HRN_CFG_LOAD(cfgCmdInfo, argList, .role = cfgCmdRoleRemote); HRN_CFG_LOAD(cfgCmdInfo, argList, .role = cfgCmdRoleRemote);
cmdRemote(HARNESS_FORK_CHILD_READ(), HARNESS_FORK_CHILD_WRITE()); cmdRemote(HRN_FORK_CHILD_READ(), HRN_FORK_CHILD_WRITE());
} }
HARNESS_FORK_CHILD_END(); HRN_FORK_CHILD_END();
HARNESS_FORK_PARENT_BEGIN() HRN_FORK_PARENT_BEGIN()
{ {
ProtocolClient *client = protocolClientNew( ProtocolClient *client = protocolClientNew(
STRDEF("test"), PROTOCOL_SERVICE_REMOTE_STR, STRDEF("test"), PROTOCOL_SERVICE_REMOTE_STR,
ioFdReadNewOpen(STRDEF("server read"), HARNESS_FORK_PARENT_READ_PROCESS(0), 2000), ioFdReadNewOpen(STRDEF("server read"), HRN_FORK_PARENT_READ_PROCESS(0), 2000),
ioFdWriteNewOpen(STRDEF("server write"), HARNESS_FORK_PARENT_WRITE_PROCESS(0), 2000)); ioFdWriteNewOpen(STRDEF("server write"), HRN_FORK_PARENT_WRITE_PROCESS(0), 2000));
protocolClientNoOp(client); protocolClientNoOp(client);
protocolClientFree(client); protocolClientFree(client);
} }
HARNESS_FORK_PARENT_END(); HRN_FORK_PARENT_END();
} }
HARNESS_FORK_END(); HRN_FORK_END();
// ------------------------------------------------------------------------------------------------------------------------- // -------------------------------------------------------------------------------------------------------------------------
TEST_TITLE("no remote lock is required for this command"); TEST_TITLE("no remote lock is required for this command");
HARNESS_FORK_BEGIN() HRN_FORK_BEGIN()
{ {
HARNESS_FORK_CHILD_BEGIN(0, true) HRN_FORK_CHILD_BEGIN(0, true)
{ {
StringList *argList = strLstNew(); StringList *argList = strLstNew();
strLstAddZ(argList, "--process=0"); strLstAddZ(argList, "--process=0");
@ -69,32 +69,32 @@ testRun(void)
hrnCfgArgRawZ(argList, cfgOptPgPath, "/path/to/pg"); hrnCfgArgRawZ(argList, cfgOptPgPath, "/path/to/pg");
HRN_CFG_LOAD(cfgCmdArchiveGet, argList, .role = cfgCmdRoleRemote, .noStd = true); HRN_CFG_LOAD(cfgCmdArchiveGet, argList, .role = cfgCmdRoleRemote, .noStd = true);
cmdRemote(HARNESS_FORK_CHILD_READ(), HARNESS_FORK_CHILD_WRITE()); cmdRemote(HRN_FORK_CHILD_READ(), HRN_FORK_CHILD_WRITE());
} }
HARNESS_FORK_CHILD_END(); HRN_FORK_CHILD_END();
HARNESS_FORK_PARENT_BEGIN() HRN_FORK_PARENT_BEGIN()
{ {
ProtocolClient *client = NULL; ProtocolClient *client = NULL;
TEST_ASSIGN( TEST_ASSIGN(
client, client,
protocolClientNew(STRDEF("test"), PROTOCOL_SERVICE_REMOTE_STR, protocolClientNew(STRDEF("test"), PROTOCOL_SERVICE_REMOTE_STR,
ioFdReadNewOpen(STRDEF("server read"), HARNESS_FORK_PARENT_READ_PROCESS(0), 2000), ioFdReadNewOpen(STRDEF("server read"), HRN_FORK_PARENT_READ_PROCESS(0), 2000),
ioFdWriteNewOpen(STRDEF("server write"), HARNESS_FORK_PARENT_WRITE_PROCESS(0), 2000)), ioFdWriteNewOpen(STRDEF("server write"), HRN_FORK_PARENT_WRITE_PROCESS(0), 2000)),
"create client"); "create client");
protocolClientNoOp(client); protocolClientNoOp(client);
protocolClientFree(client); protocolClientFree(client);
} }
HARNESS_FORK_PARENT_END(); HRN_FORK_PARENT_END();
} }
HARNESS_FORK_END(); HRN_FORK_END();
// ------------------------------------------------------------------------------------------------------------------------- // -------------------------------------------------------------------------------------------------------------------------
TEST_TITLE("remote lock is required but lock path is invalid"); TEST_TITLE("remote lock is required but lock path is invalid");
HARNESS_FORK_BEGIN() HRN_FORK_BEGIN()
{ {
HARNESS_FORK_CHILD_BEGIN(0, true) HRN_FORK_CHILD_BEGIN(0, true)
{ {
StringList *argList = strLstNew(); StringList *argList = strLstNew();
strLstAddZ(argList, "--stanza=test"); strLstAddZ(argList, "--stanza=test");
@ -103,29 +103,29 @@ testRun(void)
strLstAddZ(argList, "--lock-path=/bogus"); strLstAddZ(argList, "--lock-path=/bogus");
HRN_CFG_LOAD(cfgCmdArchivePush, argList, .role = cfgCmdRoleRemote, .noStd = true); HRN_CFG_LOAD(cfgCmdArchivePush, argList, .role = cfgCmdRoleRemote, .noStd = true);
cmdRemote(HARNESS_FORK_CHILD_READ(), HARNESS_FORK_CHILD_WRITE()); cmdRemote(HRN_FORK_CHILD_READ(), HRN_FORK_CHILD_WRITE());
} }
HARNESS_FORK_CHILD_END(); HRN_FORK_CHILD_END();
HARNESS_FORK_PARENT_BEGIN() HRN_FORK_PARENT_BEGIN()
{ {
TEST_ERROR( TEST_ERROR(
protocolClientNew( protocolClientNew(
STRDEF("test"), PROTOCOL_SERVICE_REMOTE_STR, STRDEF("test"), PROTOCOL_SERVICE_REMOTE_STR,
ioFdReadNewOpen(STRDEF("server read"), HARNESS_FORK_PARENT_READ_PROCESS(0), 2000), ioFdReadNewOpen(STRDEF("server read"), HRN_FORK_PARENT_READ_PROCESS(0), 2000),
ioFdWriteNewOpen(STRDEF("server write"), HARNESS_FORK_PARENT_WRITE_PROCESS(0), 2000)), ioFdWriteNewOpen(STRDEF("server write"), HRN_FORK_PARENT_WRITE_PROCESS(0), 2000)),
PathCreateError, "raised from test: unable to create path '/bogus': [13] Permission denied"); PathCreateError, "raised from test: unable to create path '/bogus': [13] Permission denied");
} }
HARNESS_FORK_PARENT_END(); HRN_FORK_PARENT_END();
} }
HARNESS_FORK_END(); HRN_FORK_END();
// ------------------------------------------------------------------------------------------------------------------------- // -------------------------------------------------------------------------------------------------------------------------
TEST_TITLE("remote lock is required and succeeds"); TEST_TITLE("remote lock is required and succeeds");
HARNESS_FORK_BEGIN() HRN_FORK_BEGIN()
{ {
HARNESS_FORK_CHILD_BEGIN(0, true) HRN_FORK_CHILD_BEGIN(0, true)
{ {
StringList *argList = strLstNew(); StringList *argList = strLstNew();
strLstAddZ(argList, "--stanza=test"); strLstAddZ(argList, "--stanza=test");
@ -134,19 +134,19 @@ testRun(void)
hrnCfgArgRawZ(argList, cfgOptRepo, "1"); hrnCfgArgRawZ(argList, cfgOptRepo, "1");
HRN_CFG_LOAD(cfgCmdArchivePush, argList, .role = cfgCmdRoleRemote); HRN_CFG_LOAD(cfgCmdArchivePush, argList, .role = cfgCmdRoleRemote);
cmdRemote(HARNESS_FORK_CHILD_READ(), HARNESS_FORK_CHILD_WRITE()); cmdRemote(HRN_FORK_CHILD_READ(), HRN_FORK_CHILD_WRITE());
} }
HARNESS_FORK_CHILD_END(); HRN_FORK_CHILD_END();
HARNESS_FORK_PARENT_BEGIN() HRN_FORK_PARENT_BEGIN()
{ {
ProtocolClient *client = NULL; ProtocolClient *client = NULL;
TEST_ASSIGN( TEST_ASSIGN(
client, client,
protocolClientNew( protocolClientNew(
STRDEF("test"), PROTOCOL_SERVICE_REMOTE_STR, STRDEF("test"), PROTOCOL_SERVICE_REMOTE_STR,
ioFdReadNewOpen(STRDEF("server read"), HARNESS_FORK_PARENT_READ_PROCESS(0), 2000), ioFdReadNewOpen(STRDEF("server read"), HRN_FORK_PARENT_READ_PROCESS(0), 2000),
ioFdWriteNewOpen(STRDEF("server write"), HARNESS_FORK_PARENT_WRITE_PROCESS(0), 2000)), ioFdWriteNewOpen(STRDEF("server write"), HRN_FORK_PARENT_WRITE_PROCESS(0), 2000)),
"create client"); "create client");
protocolClientNoOp(client); protocolClientNoOp(client);
@ -156,16 +156,16 @@ testRun(void)
protocolClientFree(client); protocolClientFree(client);
} }
HARNESS_FORK_PARENT_END(); HRN_FORK_PARENT_END();
} }
HARNESS_FORK_END(); HRN_FORK_END();
// ------------------------------------------------------------------------------------------------------------------------- // -------------------------------------------------------------------------------------------------------------------------
TEST_TITLE("remote lock is required but stop file exists"); TEST_TITLE("remote lock is required but stop file exists");
HARNESS_FORK_BEGIN() HRN_FORK_BEGIN()
{ {
HARNESS_FORK_CHILD_BEGIN(0, true) HRN_FORK_CHILD_BEGIN(0, true)
{ {
StringList *argList = strLstNew(); StringList *argList = strLstNew();
strLstAddZ(argList, "--stanza=test"); strLstAddZ(argList, "--stanza=test");
@ -173,26 +173,26 @@ testRun(void)
hrnCfgArgRawStrId(argList, cfgOptRemoteType, protocolStorageTypeRepo); hrnCfgArgRawStrId(argList, cfgOptRemoteType, protocolStorageTypeRepo);
HRN_CFG_LOAD(cfgCmdArchivePush, argList, .role = cfgCmdRoleRemote); HRN_CFG_LOAD(cfgCmdArchivePush, argList, .role = cfgCmdRoleRemote);
cmdRemote(HARNESS_FORK_CHILD_READ(), HARNESS_FORK_CHILD_WRITE()); cmdRemote(HRN_FORK_CHILD_READ(), HRN_FORK_CHILD_WRITE());
} }
HARNESS_FORK_CHILD_END(); HRN_FORK_CHILD_END();
HARNESS_FORK_PARENT_BEGIN() HRN_FORK_PARENT_BEGIN()
{ {
storagePutP(storageNewWriteP(hrnStorage, STRDEF("lock/all" STOP_FILE_EXT)), NULL); storagePutP(storageNewWriteP(hrnStorage, STRDEF("lock/all" STOP_FILE_EXT)), NULL);
TEST_ERROR( TEST_ERROR(
protocolClientNew( protocolClientNew(
STRDEF("test"), PROTOCOL_SERVICE_REMOTE_STR, STRDEF("test"), PROTOCOL_SERVICE_REMOTE_STR,
ioFdReadNewOpen(STRDEF("server read"), HARNESS_FORK_PARENT_READ_PROCESS(0), 2000), ioFdReadNewOpen(STRDEF("server read"), HRN_FORK_PARENT_READ_PROCESS(0), 2000),
ioFdWriteNewOpen(STRDEF("server write"), HARNESS_FORK_PARENT_WRITE_PROCESS(0), 2000)), ioFdWriteNewOpen(STRDEF("server write"), HRN_FORK_PARENT_WRITE_PROCESS(0), 2000)),
StopError, "raised from test: stop file exists for all stanzas"); StopError, "raised from test: stop file exists for all stanzas");
storageRemoveP(hrnStorage, STRDEF("lock/all" STOP_FILE_EXT)); storageRemoveP(hrnStorage, STRDEF("lock/all" STOP_FILE_EXT));
} }
HARNESS_FORK_PARENT_END(); HRN_FORK_PARENT_END();
} }
HARNESS_FORK_END(); HRN_FORK_END();
} }
FUNCTION_HARNESS_RETURN_VOID(); FUNCTION_HARNESS_RETURN_VOID();

8
test/src/module/common/errorTest.c
View File

@ -378,15 +378,15 @@ testRun(void)
if (testBegin("Uncaught error")) if (testBegin("Uncaught error"))
{ {
// Test in a fork so the process does not actually exit // Test in a fork so the process does not actually exit
HARNESS_FORK_BEGIN() HRN_FORK_BEGIN()
{ {
HARNESS_FORK_CHILD_BEGIN(UnhandledError.code, false) HRN_FORK_CHILD_BEGIN(UnhandledError.code, false)
{ {
THROW(TestChildError, "does not get caught!"); THROW(TestChildError, "does not get caught!");
} }
HARNESS_FORK_CHILD_END(); HRN_FORK_CHILD_END();
} }
HARNESS_FORK_END(); HRN_FORK_END();
} }
FUNCTION_HARNESS_RETURN_VOID(); FUNCTION_HARNESS_RETURN_VOID();

8
test/src/module/common/execTest.c
View File

@ -68,9 +68,9 @@ testRun(void)
// Run the same test as above but close all file descriptors first to ensure we don't accidentally close a required // Run the same test as above but close all file descriptors first to ensure we don't accidentally close a required
// descriptor while running dup2()/close() between the fork() and the exec(). // descriptor while running dup2()/close() between the fork() and the exec().
// ------------------------------------------------------------------------------------------------------------------------- // -------------------------------------------------------------------------------------------------------------------------
HARNESS_FORK_BEGIN() HRN_FORK_BEGIN()
{ {
HARNESS_FORK_CHILD_BEGIN(0, false) HRN_FORK_CHILD_BEGIN(0, false)
{ {
// This is not really fd max but for the purposes of testing is fine -- we won't have more than 64 fds open // This is not really fd max but for the purposes of testing is fine -- we won't have more than 64 fds open
for (int fd = 0; fd < 64; fd++) for (int fd = 0; fd < 64; fd++)
@ -87,9 +87,9 @@ testRun(void)
TEST_RESULT_STR_Z(ioReadLine(execIoRead(exec)), " 1\tACKBYACK", "read cat exec"); TEST_RESULT_STR_Z(ioReadLine(execIoRead(exec)), " 1\tACKBYACK", "read cat exec");
TEST_RESULT_VOID(execFree(exec), "free exec"); TEST_RESULT_VOID(execFree(exec), "free exec");
} }
HARNESS_FORK_CHILD_END(); HRN_FORK_CHILD_END();
} }
HARNESS_FORK_END(); HRN_FORK_END();
// ------------------------------------------------------------------------------------------------------------------------- // -------------------------------------------------------------------------------------------------------------------------
option = strLstNew(); option = strLstNew();

8
test/src/module/common/exitTest.c
View File

@ -32,16 +32,16 @@ testRun(void)
{ {
HRN_CFG_LOAD(cfgCmdHelp, strLstNew()); HRN_CFG_LOAD(cfgCmdHelp, strLstNew());
HARNESS_FORK_BEGIN() HRN_FORK_BEGIN()
{ {
HARNESS_FORK_CHILD_BEGIN(errorTypeCode(&TermError), false) HRN_FORK_CHILD_BEGIN(errorTypeCode(&TermError), false)
{ {
exitInit(); exitInit();
raise(SIGTERM); raise(SIGTERM);
} }
HARNESS_FORK_CHILD_END(); // {uncoverable - signal is raised in block} HRN_FORK_CHILD_END(); // {uncoverable - signal is raised in block}
} }
HARNESS_FORK_END(); HRN_FORK_END();
} }
// ***************************************************************************************************************************** // *****************************************************************************************************************************

8
test/src/module/common/forkTest.c
View File

@ -16,9 +16,9 @@ testRun(void)
{ {
int sessionId = getsid(0); int sessionId = getsid(0);
HARNESS_FORK_BEGIN() HRN_FORK_BEGIN()
{ {
HARNESS_FORK_CHILD_BEGIN(0, false) HRN_FORK_CHILD_BEGIN(0, false)
{ {
char buffer[1024]; char buffer[1024];
@ -30,9 +30,9 @@ testRun(void)
TEST_RESULT_INT(write(STDOUT_FILENO, buffer, strlen(buffer)), -1, "write to stdout fails"); TEST_RESULT_INT(write(STDOUT_FILENO, buffer, strlen(buffer)), -1, "write to stdout fails");
TEST_RESULT_INT(write(STDERR_FILENO, buffer, strlen(buffer)), -1, "write to stderr fails"); TEST_RESULT_INT(write(STDERR_FILENO, buffer, strlen(buffer)), -1, "write to stderr fails");
} }
HARNESS_FORK_CHILD_END(); HRN_FORK_CHILD_END();
} }
HARNESS_FORK_END(); HRN_FORK_END();
} }
FUNCTION_HARNESS_RETURN_VOID(); FUNCTION_HARNESS_RETURN_VOID();

16
test/src/module/common/ioHttpTest.c
View File

@ -279,22 +279,22 @@ testRun(void)
httpRequestResponse(httpRequestNewP(client, STRDEF("GET"), STRDEF("/")), false), HostConnectError, httpRequestResponse(httpRequestNewP(client, STRDEF("GET"), STRDEF("/")), false), HostConnectError,
"unable to connect to 'localhost:%u': [111] Connection refused", hrnServerPort(0)); "unable to connect to 'localhost:%u': [111] Connection refused", hrnServerPort(0));
HARNESS_FORK_BEGIN() HRN_FORK_BEGIN()
{ {
HARNESS_FORK_CHILD_BEGIN(0, true) HRN_FORK_CHILD_BEGIN(0, true)
{ {
// Start HTTP test server // Start HTTP test server
TEST_RESULT_VOID( TEST_RESULT_VOID(
hrnServerRunP( hrnServerRunP(
ioFdReadNew(STRDEF("test server read"), HARNESS_FORK_CHILD_READ(), 5000), hrnServerProtocolSocket), ioFdReadNew(STRDEF("test server read"), HRN_FORK_CHILD_READ(), 5000), hrnServerProtocolSocket),
"http server run"); "http server run");
} }
HARNESS_FORK_CHILD_END(); HRN_FORK_CHILD_END();
HARNESS_FORK_PARENT_BEGIN() HRN_FORK_PARENT_BEGIN()
{ {
IoWrite *http = hrnServerScriptBegin( IoWrite *http = hrnServerScriptBegin(
ioFdWriteNew(STRDEF("test client write"), HARNESS_FORK_PARENT_WRITE_PROCESS(0), 2000)); ioFdWriteNew(STRDEF("test client write"), HRN_FORK_PARENT_WRITE_PROCESS(0), 2000));
// ----------------------------------------------------------------------------------------------------------------- // -----------------------------------------------------------------------------------------------------------------
TEST_TITLE("create client"); TEST_TITLE("create client");
@ -717,9 +717,9 @@ testRun(void)
hrnServerScriptClose(http); hrnServerScriptClose(http);
hrnServerScriptEnd(http); hrnServerScriptEnd(http);
} }
HARNESS_FORK_PARENT_END(); HRN_FORK_PARENT_END();
} }
HARNESS_FORK_END(); HRN_FORK_END();
// ------------------------------------------------------------------------------------------------------------------------- // -------------------------------------------------------------------------------------------------------------------------
TEST_TITLE("statistics exist"); TEST_TITLE("statistics exist");

16
test/src/module/common/ioTest.c
View File

@ -537,13 +537,13 @@ testRun(void)
{ {
ioBufferSizeSet(16); ioBufferSizeSet(16);
HARNESS_FORK_BEGIN() HRN_FORK_BEGIN()
{ {
HARNESS_FORK_CHILD_BEGIN(0, true) HRN_FORK_CHILD_BEGIN(0, true)
{ {
IoWrite *write = NULL; IoWrite *write = NULL;
TEST_ASSIGN(write, ioFdWriteNewOpen(STRDEF("write test"), HARNESS_FORK_CHILD_WRITE(), 1000), "move write"); TEST_ASSIGN(write, ioFdWriteNewOpen(STRDEF("write test"), HRN_FORK_CHILD_WRITE(), 1000), "move write");
TEST_RESULT_BOOL(ioWriteReadyP(write), true, "write is ready"); TEST_RESULT_BOOL(ioWriteReadyP(write), true, "write is ready");
TEST_RESULT_INT(ioWriteFd(write), ((IoFdWrite *)write->driver)->fd, "check write fd"); TEST_RESULT_INT(ioWriteFd(write), ((IoFdWrite *)write->driver)->fd, "check write fd");
@ -563,11 +563,11 @@ testRun(void)
TEST_RESULT_VOID(ioWrite(write, buffer), "write buffer"); TEST_RESULT_VOID(ioWrite(write, buffer), "write buffer");
ioWriteFlush(write); ioWriteFlush(write);
} }
HARNESS_FORK_CHILD_END(); HRN_FORK_CHILD_END();
HARNESS_FORK_PARENT_BEGIN() HRN_FORK_PARENT_BEGIN()
{ {
IoRead *read = ioFdReadNewOpen(STRDEF("read test"), HARNESS_FORK_PARENT_READ_PROCESS(0), 1000); IoRead *read = ioFdReadNewOpen(STRDEF("read test"), HRN_FORK_PARENT_READ_PROCESS(0), 1000);
TEST_RESULT_INT(ioReadFd(read), ((IoFdRead *)ioReadDriver(read))->fd, "check fd"); TEST_RESULT_INT(ioReadFd(read), ((IoFdRead *)ioReadDriver(read))->fd, "check fd");
TEST_RESULT_PTR(ioReadInterface(read), &read->pub.interface, "check interface"); TEST_RESULT_PTR(ioReadInterface(read), &read->pub.interface, "check interface");
@ -601,9 +601,9 @@ testRun(void)
TEST_RESULT_UINT(ioFdRead(ioReadDriver(read), buffer, true), 0, "read buffer at eof"); TEST_RESULT_UINT(ioFdRead(ioReadDriver(read), buffer, true), 0, "read buffer at eof");
TEST_RESULT_UINT(ioFdRead(ioReadDriver(read), buffer, true), 0, "read buffer at eof again"); TEST_RESULT_UINT(ioFdRead(ioReadDriver(read), buffer, true), 0, "read buffer at eof again");
} }
HARNESS_FORK_PARENT_END(); HRN_FORK_PARENT_END();
} }
HARNESS_FORK_END(); HRN_FORK_END();
// ------------------------------------------------------------------------------------------------------------------------- // -------------------------------------------------------------------------------------------------------------------------
TEST_ERROR(ioFdWriteOneStr(999999, STRDEF("test")), FileWriteError, "unable to write to fd: [9] Bad file descriptor"); TEST_ERROR(ioFdWriteOneStr(999999, STRDEF("test")), FileWriteError, "unable to write to fd: [9] Bad file descriptor");

32
test/src/module/common/ioTlsTest.c
View File

@ -245,24 +245,24 @@ testRun(void)
"echo \"127.0.0.1 test.pgbackrest.org host.test2.pgbackrest.org test3.pgbackrest.org\" | sudo tee -a /etc/hosts >" "echo \"127.0.0.1 test.pgbackrest.org host.test2.pgbackrest.org test3.pgbackrest.org\" | sudo tee -a /etc/hosts >"
" /dev/null"); " /dev/null");
HARNESS_FORK_BEGIN() HRN_FORK_BEGIN()
{ {
HARNESS_FORK_CHILD_BEGIN(0, true) HRN_FORK_CHILD_BEGIN(0, true)
{ {
// Start server to test various certificate errors // Start server to test various certificate errors
TEST_RESULT_VOID( TEST_RESULT_VOID(
hrnServerRunP( hrnServerRunP(
ioFdReadNew(STRDEF("test server read"), HARNESS_FORK_CHILD_READ(), 5000), hrnServerProtocolTls, ioFdReadNew(STRDEF("test server read"), HRN_FORK_CHILD_READ(), 5000), hrnServerProtocolTls,
.certificate = STRDEF(HRN_PATH_REPO "/" HRN_SERVER_CERT_PREFIX "-alt-name.crt"), .certificate = STRDEF(HRN_PATH_REPO "/" HRN_SERVER_CERT_PREFIX "-alt-name.crt"),
.key = STRDEF(HRN_PATH_REPO "/" HRN_SERVER_CERT_PREFIX ".key")), .key = STRDEF(HRN_PATH_REPO "/" HRN_SERVER_CERT_PREFIX ".key")),
"tls alt name server run"); "tls alt name server run");
} }
HARNESS_FORK_CHILD_END(); HRN_FORK_CHILD_END();
HARNESS_FORK_PARENT_BEGIN() HRN_FORK_PARENT_BEGIN()
{ {
IoWrite *tls = hrnServerScriptBegin( IoWrite *tls = hrnServerScriptBegin(
ioFdWriteNew(STRDEF("test client write"), HARNESS_FORK_PARENT_WRITE_PROCESS(0), 1000)); ioFdWriteNew(STRDEF("test client write"), HRN_FORK_PARENT_WRITE_PROCESS(0), 1000));
// ----------------------------------------------------------------------------------------------------------------- // -----------------------------------------------------------------------------------------------------------------
TEST_TITLE("certificate error on invalid ca path"); TEST_TITLE("certificate error on invalid ca path");
@ -351,9 +351,9 @@ testRun(void)
// ----------------------------------------------------------------------------------------------------------------- // -----------------------------------------------------------------------------------------------------------------
hrnServerScriptEnd(tls); hrnServerScriptEnd(tls);
} }
HARNESS_FORK_PARENT_END(); HRN_FORK_PARENT_END();
} }
HARNESS_FORK_END(); HRN_FORK_END();
#endif // TEST_CONTAINER_REQUIRED #endif // TEST_CONTAINER_REQUIRED
} }
@ -363,21 +363,21 @@ testRun(void)
IoClient *client = NULL; IoClient *client = NULL;
IoSession *session = NULL; IoSession *session = NULL;
HARNESS_FORK_BEGIN() HRN_FORK_BEGIN()
{ {
HARNESS_FORK_CHILD_BEGIN(0, true) HRN_FORK_CHILD_BEGIN(0, true)
{ {
TEST_RESULT_VOID( TEST_RESULT_VOID(
hrnServerRunP( hrnServerRunP(
ioFdReadNew(STRDEF("test server read"), HARNESS_FORK_CHILD_READ(), 5000), hrnServerProtocolTls), ioFdReadNew(STRDEF("test server read"), HRN_FORK_CHILD_READ(), 5000), hrnServerProtocolTls),
"tls server run"); "tls server run");
} }
HARNESS_FORK_CHILD_END(); HRN_FORK_CHILD_END();
HARNESS_FORK_PARENT_BEGIN() HRN_FORK_PARENT_BEGIN()
{ {
IoWrite *tls = IoWrite *tls =
hrnServerScriptBegin(ioFdWriteNew(STRDEF("test client write"), HARNESS_FORK_PARENT_WRITE_PROCESS(0), 1000)); hrnServerScriptBegin(ioFdWriteNew(STRDEF("test client write"), HRN_FORK_PARENT_WRITE_PROCESS(0), 1000));
ioBufferSizeSet(12); ioBufferSizeSet(12);
TEST_ASSIGN( TEST_ASSIGN(
@ -493,9 +493,9 @@ testRun(void)
// ----------------------------------------------------------------------------------------------------------------- // -----------------------------------------------------------------------------------------------------------------
hrnServerScriptEnd(tls); hrnServerScriptEnd(tls);
} }
HARNESS_FORK_PARENT_END(); HRN_FORK_PARENT_END();
} }
HARNESS_FORK_END(); HRN_FORK_END();
// ------------------------------------------------------------------------------------------------------------------------- // -------------------------------------------------------------------------------------------------------------------------
TEST_TITLE("stastistics exist"); TEST_TITLE("stastistics exist");

12
test/src/module/common/lockTest.c
View File

@ -91,16 +91,16 @@ testRun(void)
// ------------------------------------------------------------------------------------------------------------------------- // -------------------------------------------------------------------------------------------------------------------------
const String *backupLock = STRDEF(TEST_PATH "/main-backup" LOCK_FILE_EXT); const String *backupLock = STRDEF(TEST_PATH "/main-backup" LOCK_FILE_EXT);
HARNESS_FORK_BEGIN() HRN_FORK_BEGIN()
{ {
HARNESS_FORK_CHILD_BEGIN(0, false) HRN_FORK_CHILD_BEGIN(0, false)
{ {
TEST_RESULT_INT_NE(lockAcquireFile(backupLock, STRDEF("1-test"), 0, true), -1, "lock on fork"); TEST_RESULT_INT_NE(lockAcquireFile(backupLock, STRDEF("1-test"), 0, true), -1, "lock on fork");
sleepMSec(500); sleepMSec(500);
} }
HARNESS_FORK_CHILD_END(); HRN_FORK_CHILD_END();
HARNESS_FORK_PARENT_BEGIN() HRN_FORK_PARENT_BEGIN()
{ {
sleepMSec(250); sleepMSec(250);
TEST_ERROR( TEST_ERROR(
@ -111,9 +111,9 @@ testRun(void)
"unable to acquire lock on file '%s': Resource temporarily unavailable\n" "unable to acquire lock on file '%s': Resource temporarily unavailable\n"
"HINT: is another pgBackRest process running?", strZ(backupLock)))); "HINT: is another pgBackRest process running?", strZ(backupLock))));
} }
HARNESS_FORK_PARENT_END(); HRN_FORK_PARENT_END();
} }
HARNESS_FORK_END(); HRN_FORK_END();
} }
// ***************************************************************************************************************************** // *****************************************************************************************************************************

20
test/src/module/config/protocolTest.c
View File

@ -20,9 +20,9 @@ testRun(void)
// ***************************************************************************************************************************** // *****************************************************************************************************************************
if (testBegin("configOptionProtocol() and configOptionRemote()")) if (testBegin("configOptionProtocol() and configOptionRemote()"))
{ {
HARNESS_FORK_BEGIN() HRN_FORK_BEGIN()
{ {
HARNESS_FORK_CHILD_BEGIN(0, true) HRN_FORK_CHILD_BEGIN(0, true)
{ {
StringList *argList = strLstNew(); StringList *argList = strLstNew();
strLstAddZ(argList, "--stanza=test1"); strLstAddZ(argList, "--stanza=test1");
@ -32,20 +32,20 @@ testRun(void)
HRN_CFG_LOAD(cfgCmdArchiveGet, argList); HRN_CFG_LOAD(cfgCmdArchiveGet, argList);
ProtocolServer *server = protocolServerNew( ProtocolServer *server = protocolServerNew(
STRDEF("test"), STRDEF("config"), ioFdReadNewOpen(STRDEF("client read"), HARNESS_FORK_CHILD_READ(), 2000), STRDEF("test"), STRDEF("config"), ioFdReadNewOpen(STRDEF("client read"), HRN_FORK_CHILD_READ(), 2000),
ioFdWriteNewOpen(STRDEF("client write"), HARNESS_FORK_CHILD_WRITE(), 2000)); ioFdWriteNewOpen(STRDEF("client write"), HRN_FORK_CHILD_WRITE(), 2000));
static const ProtocolServerHandler commandHandler[] = {PROTOCOL_SERVER_HANDLER_OPTION_LIST}; static const ProtocolServerHandler commandHandler[] = {PROTOCOL_SERVER_HANDLER_OPTION_LIST};
protocolServerProcess(server, NULL, commandHandler, PROTOCOL_SERVER_HANDLER_LIST_SIZE(commandHandler)); protocolServerProcess(server, NULL, commandHandler, PROTOCOL_SERVER_HANDLER_LIST_SIZE(commandHandler));
} }
HARNESS_FORK_CHILD_END(); HRN_FORK_CHILD_END();
HARNESS_FORK_PARENT_BEGIN() HRN_FORK_PARENT_BEGIN()
{ {
ProtocolClient *client = protocolClientNew( ProtocolClient *client = protocolClientNew(
STRDEF("test"), STRDEF("config"), STRDEF("test"), STRDEF("config"),
ioFdReadNewOpen(STRDEF("server read"), HARNESS_FORK_PARENT_READ_PROCESS(0), 2000), ioFdReadNewOpen(STRDEF("server read"), HRN_FORK_PARENT_READ_PROCESS(0), 2000),
ioFdWriteNewOpen(STRDEF("server write"), HARNESS_FORK_PARENT_WRITE_PROCESS(0), 2000)); ioFdWriteNewOpen(STRDEF("server write"), HRN_FORK_PARENT_WRITE_PROCESS(0), 2000));
VariantList *list = varLstNew(); VariantList *list = varLstNew();
varLstAdd(list, varNewStr(STRDEF("repo1-host"))); varLstAdd(list, varNewStr(STRDEF("repo1-host")));
@ -56,9 +56,9 @@ testRun(void)
protocolClientFree(client); protocolClientFree(client);
} }
HARNESS_FORK_PARENT_END(); HRN_FORK_PARENT_END();
} }
HARNESS_FORK_END(); HRN_FORK_END();
} }
FUNCTION_HARNESS_RETURN_VOID(); FUNCTION_HARNESS_RETURN_VOID();

20
test/src/module/db/dbTest.c
View File

@ -59,9 +59,9 @@ testRun(void)
// ***************************************************************************************************************************** // *****************************************************************************************************************************
if (testBegin("Db and dbProtocol()")) if (testBegin("Db and dbProtocol()"))
{ {
HARNESS_FORK_BEGIN() HRN_FORK_BEGIN()
{ {
HARNESS_FORK_CHILD_BEGIN(0, true) HRN_FORK_CHILD_BEGIN(0, true)
{ {
// Set options // Set options
StringList *argList = strLstNew(); StringList *argList = strLstNew();
@ -98,8 +98,8 @@ testRun(void)
server, server,
protocolServerNew( protocolServerNew(
STRDEF("db test server"), STRDEF("test"), STRDEF("db test server"), STRDEF("test"),
ioFdReadNewOpen(STRDEF("client read"), HARNESS_FORK_CHILD_READ(), 2000), ioFdReadNewOpen(STRDEF("client read"), HRN_FORK_CHILD_READ(), 2000),
ioFdWriteNewOpen(STRDEF("client write"), HARNESS_FORK_CHILD_WRITE(), 2000)), ioFdWriteNewOpen(STRDEF("client write"), HRN_FORK_CHILD_WRITE(), 2000)),
"create server"); "create server");
static const ProtocolServerHandler commandHandler[] = {PROTOCOL_SERVER_HANDLER_DB_LIST}; static const ProtocolServerHandler commandHandler[] = {PROTOCOL_SERVER_HANDLER_DB_LIST};
@ -109,9 +109,9 @@ testRun(void)
"run process loop"); "run process loop");
TEST_RESULT_VOID(protocolServerFree(server), "free server"); TEST_RESULT_VOID(protocolServerFree(server), "free server");
} }
HARNESS_FORK_CHILD_END(); HRN_FORK_CHILD_END();
HARNESS_FORK_PARENT_BEGIN() HRN_FORK_PARENT_BEGIN()
{ {
// Create client // Create client
ProtocolClient *client = NULL; ProtocolClient *client = NULL;
@ -121,8 +121,8 @@ testRun(void)
client, client,
protocolClientNew( protocolClientNew(
STRDEF("db test client"), STRDEF("test"), STRDEF("db test client"), STRDEF("test"),
ioFdReadNewOpen(STRDEF("server read"), HARNESS_FORK_PARENT_READ_PROCESS(0), 2000), ioFdReadNewOpen(STRDEF("server read"), HRN_FORK_PARENT_READ_PROCESS(0), 2000),
ioFdWriteNewOpen(STRDEF("server write"), HARNESS_FORK_PARENT_WRITE_PROCESS(0), 2000)), ioFdWriteNewOpen(STRDEF("server write"), HRN_FORK_PARENT_WRITE_PROCESS(0), 2000)),
"create client"); "create client");
TRY_BEGIN() TRY_BEGIN()
@ -171,9 +171,9 @@ testRun(void)
} }
TRY_END(); TRY_END();
} }
HARNESS_FORK_PARENT_END(); HRN_FORK_PARENT_END();
} }
HARNESS_FORK_END(); HRN_FORK_END();
} }
// ***************************************************************************************************************************** // *****************************************************************************************************************************

20
test/src/module/performance/storageTest.c
View File

@ -147,9 +147,9 @@ testRun(void)
CHECK(TEST_SCALE <= 2000); CHECK(TEST_SCALE <= 2000);
uint64_t fileTotal = (uint64_t)1000000 * TEST_SCALE; uint64_t fileTotal = (uint64_t)1000000 * TEST_SCALE;
HARNESS_FORK_BEGIN() HRN_FORK_BEGIN()
{ {
HARNESS_FORK_CHILD_BEGIN(0, true) HRN_FORK_CHILD_BEGIN(0, true)
{ {
// Create a basic configuration so the remote storage driver can determine the storage type // Create a basic configuration so the remote storage driver can determine the storage type
StringList *argList = strLstNew(); StringList *argList = strLstNew();
@ -174,22 +174,22 @@ testRun(void)
// Setup handler for remote storage protocol // Setup handler for remote storage protocol
ProtocolServer *server = protocolServerNew( ProtocolServer *server = protocolServerNew(
STRDEF("storage test server"), STRDEF("test"), STRDEF("storage test server"), STRDEF("test"),
ioFdReadNewOpen(STRDEF("storage server read"), HARNESS_FORK_CHILD_READ(), 60000), ioFdReadNewOpen(STRDEF("storage server read"), HRN_FORK_CHILD_READ(), 60000),
ioFdWriteNewOpen(STRDEF("storage server write"), HARNESS_FORK_CHILD_WRITE(), 1000)); ioFdWriteNewOpen(STRDEF("storage server write"), HRN_FORK_CHILD_WRITE(), 1000));
static const ProtocolServerHandler commandHandler[] = {PROTOCOL_SERVER_HANDLER_STORAGE_REMOTE_LIST}; static const ProtocolServerHandler commandHandler[] = {PROTOCOL_SERVER_HANDLER_STORAGE_REMOTE_LIST};
protocolServerProcess(server, NULL, commandHandler, PROTOCOL_SERVER_HANDLER_LIST_SIZE(commandHandler)); protocolServerProcess(server, NULL, commandHandler, PROTOCOL_SERVER_HANDLER_LIST_SIZE(commandHandler));
} }
HARNESS_FORK_CHILD_END(); HRN_FORK_CHILD_END();
HARNESS_FORK_PARENT_BEGIN() HRN_FORK_PARENT_BEGIN()
{ {
// Create client // Create client
ProtocolClient *client = protocolClientNew( ProtocolClient *client = protocolClientNew(
STRDEF("storage test client"), STRDEF("test"), STRDEF("storage test client"), STRDEF("test"),
ioFdReadNewOpen(STRDEF("storage client read"), HARNESS_FORK_PARENT_READ_PROCESS(0), 60000), ioFdReadNewOpen(STRDEF("storage client read"), HRN_FORK_PARENT_READ_PROCESS(0), 60000),
ioFdWriteNewOpen(STRDEF("storage client write"), HARNESS_FORK_PARENT_WRITE_PROCESS(0), 1000)); ioFdWriteNewOpen(STRDEF("storage client write"), HRN_FORK_PARENT_WRITE_PROCESS(0), 1000));
// Create remote storage // Create remote storage
Storage *storageRemote = storageRemoteNew( Storage *storageRemote = storageRemoteNew(
@ -206,9 +206,9 @@ testRun(void)
// Free client // Free client
protocolClientFree(client); protocolClientFree(client);
} }
HARNESS_FORK_PARENT_END(); HRN_FORK_PARENT_END();
} }
HARNESS_FORK_END(); HRN_FORK_END();
} }
// ***************************************************************************************************************************** // *****************************************************************************************************************************

50
test/src/module/protocol/protocolTest.c
View File

@ -433,12 +433,12 @@ testRun(void)
// ***************************************************************************************************************************** // *****************************************************************************************************************************
if (testBegin("ProtocolClient, ProtocolCommand, and ProtocolServer")) if (testBegin("ProtocolClient, ProtocolCommand, and ProtocolServer"))
{ {
HARNESS_FORK_BEGIN() HRN_FORK_BEGIN()
{ {
HARNESS_FORK_CHILD_BEGIN(0, true) HRN_FORK_CHILD_BEGIN(0, true)
{ {
IoRead *read = ioFdReadNewOpen(STRDEF("server read"), HARNESS_FORK_CHILD_READ(), 2000); IoRead *read = ioFdReadNewOpen(STRDEF("server read"), HRN_FORK_CHILD_READ(), 2000);
IoWrite *write = ioFdWriteNewOpen(STRDEF("server write"), HARNESS_FORK_CHILD_WRITE(), 2000); IoWrite *write = ioFdWriteNewOpen(STRDEF("server write"), HRN_FORK_CHILD_WRITE(), 2000);
// Various bogus greetings // Various bogus greetings
// ----------------------------------------------------------------------------------------------------------------- // -----------------------------------------------------------------------------------------------------------------
@ -488,12 +488,12 @@ testRun(void)
// This cannot run in a TEST* macro because tests are run by the command handlers // This cannot run in a TEST* macro because tests are run by the command handlers
protocolServerProcess(server, retryList, commandHandler, PROTOCOL_SERVER_HANDLER_LIST_SIZE(commandHandler)); protocolServerProcess(server, retryList, commandHandler, PROTOCOL_SERVER_HANDLER_LIST_SIZE(commandHandler));
} }
HARNESS_FORK_CHILD_END(); HRN_FORK_CHILD_END();
HARNESS_FORK_PARENT_BEGIN() HRN_FORK_PARENT_BEGIN()
{ {
IoRead *read = ioFdReadNewOpen(STRDEF("client read"), HARNESS_FORK_PARENT_READ_PROCESS(0), 2000); IoRead *read = ioFdReadNewOpen(STRDEF("client read"), HRN_FORK_PARENT_READ_PROCESS(0), 2000);
IoWrite *write = ioFdWriteNewOpen(STRDEF("client write"), HARNESS_FORK_PARENT_WRITE_PROCESS(0), 2000); IoWrite *write = ioFdWriteNewOpen(STRDEF("client write"), HRN_FORK_PARENT_WRITE_PROCESS(0), 2000);
// ----------------------------------------------------------------------------------------------------------------- // -----------------------------------------------------------------------------------------------------------------
TEST_TITLE("bogus greetings"); TEST_TITLE("bogus greetings");
@ -622,9 +622,9 @@ testRun(void)
TEST_RESULT_VOID(protocolClientFree(client), "free"); TEST_RESULT_VOID(protocolClientFree(client), "free");
} }
HARNESS_FORK_PARENT_END(); HRN_FORK_PARENT_END();
} }
HARNESS_FORK_END(); HRN_FORK_END();
} }
// ***************************************************************************************************************************** // *****************************************************************************************************************************
@ -656,18 +656,18 @@ testRun(void)
TEST_RESULT_VOID(protocolParallelJobFree(job), "free job"); TEST_RESULT_VOID(protocolParallelJobFree(job), "free job");
// ------------------------------------------------------------------------------------------------------------------------- // -------------------------------------------------------------------------------------------------------------------------
HARNESS_FORK_BEGIN() HRN_FORK_BEGIN()
{ {
// Local 1 // Local 1
HARNESS_FORK_CHILD_BEGIN(0, true) HRN_FORK_CHILD_BEGIN(0, true)
{ {
ProtocolServer *server = NULL; ProtocolServer *server = NULL;
TEST_ASSIGN( TEST_ASSIGN(
server, server,
protocolServerNew( protocolServerNew(
STRDEF("local server 1"), STRDEF("test"), STRDEF("local server 1"), STRDEF("test"),
ioFdReadNewOpen(STRDEF("local server 1 read"), HARNESS_FORK_CHILD_READ(), 10000), ioFdReadNewOpen(STRDEF("local server 1 read"), HRN_FORK_CHILD_READ(), 10000),
ioFdWriteNewOpen(STRDEF("local server 1 write"), HARNESS_FORK_CHILD_WRITE(), 2000)), ioFdWriteNewOpen(STRDEF("local server 1 write"), HRN_FORK_CHILD_WRITE(), 2000)),
"local server 1"); "local server 1");
TEST_RESULT_UINT(protocolServerCommandGet(server).id, PROTOCOL_COMMAND_NOOP, "noop command get"); TEST_RESULT_UINT(protocolServerCommandGet(server).id, PROTOCOL_COMMAND_NOOP, "noop command get");
@ -684,18 +684,18 @@ testRun(void)
// Wait for exit // Wait for exit
TEST_RESULT_UINT(protocolServerCommandGet(server).id, PROTOCOL_COMMAND_EXIT, "noop command get"); TEST_RESULT_UINT(protocolServerCommandGet(server).id, PROTOCOL_COMMAND_EXIT, "noop command get");
} }
HARNESS_FORK_CHILD_END(); HRN_FORK_CHILD_END();
// Local 2 // Local 2
HARNESS_FORK_CHILD_BEGIN(0, true) HRN_FORK_CHILD_BEGIN(0, true)
{ {
ProtocolServer *server = NULL; ProtocolServer *server = NULL;
TEST_ASSIGN( TEST_ASSIGN(
server, server,
protocolServerNew( protocolServerNew(
STRDEF("local server 2"), STRDEF("test"), STRDEF("local server 2"), STRDEF("test"),
ioFdReadNewOpen(STRDEF("local server 2 read"), HARNESS_FORK_CHILD_READ(), 10000), ioFdReadNewOpen(STRDEF("local server 2 read"), HRN_FORK_CHILD_READ(), 10000),
ioFdWriteNewOpen(STRDEF("local server 2 write"), HARNESS_FORK_CHILD_WRITE(), 2000)), ioFdWriteNewOpen(STRDEF("local server 2 write"), HRN_FORK_CHILD_WRITE(), 2000)),
"local server 2"); "local server 2");
TEST_RESULT_UINT(protocolServerCommandGet(server).id, PROTOCOL_COMMAND_NOOP, "noop command get"); TEST_RESULT_UINT(protocolServerCommandGet(server).id, PROTOCOL_COMMAND_NOOP, "noop command get");
@ -716,9 +716,9 @@ testRun(void)
// Wait for exit // Wait for exit
CHECK(protocolServerCommandGet(server).id == PROTOCOL_COMMAND_EXIT); CHECK(protocolServerCommandGet(server).id == PROTOCOL_COMMAND_EXIT);
} }
HARNESS_FORK_CHILD_END(); HRN_FORK_CHILD_END();
HARNESS_FORK_PARENT_BEGIN() HRN_FORK_PARENT_BEGIN()
{ {
TestParallelJobCallback data = {.jobList = lstNewP(sizeof(ProtocolParallelJob *))}; TestParallelJobCallback data = {.jobList = lstNewP(sizeof(ProtocolParallelJob *))};
ProtocolParallel *parallel = NULL; ProtocolParallel *parallel = NULL;
@ -727,7 +727,7 @@ testRun(void)
// Add client // Add client
unsigned int clientTotal = 2; unsigned int clientTotal = 2;
ProtocolClient *client[HARNESS_FORK_CHILD_MAX]; ProtocolClient *client[HRN_FORK_CHILD_MAX];
for (unsigned int clientIdx = 0; clientIdx < clientTotal; clientIdx++) for (unsigned int clientIdx = 0; clientIdx < clientTotal; clientIdx++)
{ {
@ -736,9 +736,9 @@ testRun(void)
protocolClientNew( protocolClientNew(
strNewFmt("local client %u", clientIdx), STRDEF("test"), strNewFmt("local client %u", clientIdx), STRDEF("test"),
ioFdReadNewOpen( ioFdReadNewOpen(
strNewFmt("local client %u read", clientIdx), HARNESS_FORK_PARENT_READ_PROCESS(clientIdx), 2000), strNewFmt("local client %u read", clientIdx), HRN_FORK_PARENT_READ_PROCESS(clientIdx), 2000),
ioFdWriteNewOpen( ioFdWriteNewOpen(
strNewFmt("local client %u write", clientIdx), HARNESS_FORK_PARENT_WRITE_PROCESS(clientIdx), 2000)), strNewFmt("local client %u write", clientIdx), HRN_FORK_PARENT_WRITE_PROCESS(clientIdx), 2000)),
strZ(strNewFmt("local client %u new", clientIdx))); strZ(strNewFmt("local client %u new", clientIdx)));
TEST_RESULT_VOID( TEST_RESULT_VOID(
protocolParallelClientAdd(parallel, client[clientIdx]), strZ(strNewFmt("local client %u add", clientIdx))); protocolParallelClientAdd(parallel, client[clientIdx]), strZ(strNewFmt("local client %u add", clientIdx)));
@ -848,9 +848,9 @@ testRun(void)
for (unsigned int clientIdx = 0; clientIdx < clientTotal; clientIdx++) for (unsigned int clientIdx = 0; clientIdx < clientTotal; clientIdx++)
TEST_RESULT_VOID(protocolClientFree(client[clientIdx]), strZ(strNewFmt("free client %u", clientIdx))); TEST_RESULT_VOID(protocolClientFree(client[clientIdx]), strZ(strNewFmt("free client %u", clientIdx)));
} }
HARNESS_FORK_PARENT_END(); HRN_FORK_PARENT_END();
} }
HARNESS_FORK_END(); HRN_FORK_END();
} }
// ***************************************************************************************************************************** // *****************************************************************************************************************************

16
test/src/module/storage/azureTest.c
View File

@ -265,20 +265,20 @@ testRun(void)
// ***************************************************************************************************************************** // *****************************************************************************************************************************
if (testBegin("StorageAzure, StorageReadAzure, and StorageWriteAzure")) if (testBegin("StorageAzure, StorageReadAzure, and StorageWriteAzure"))
{ {
HARNESS_FORK_BEGIN() HRN_FORK_BEGIN()
{ {
HARNESS_FORK_CHILD_BEGIN(0, true) HRN_FORK_CHILD_BEGIN(0, true)
{ {
TEST_RESULT_VOID( TEST_RESULT_VOID(
hrnServerRunP(ioFdReadNew(STRDEF("azure server read"), HARNESS_FORK_CHILD_READ(), 5000), hrnServerProtocolTls), hrnServerRunP(ioFdReadNew(STRDEF("azure server read"), HRN_FORK_CHILD_READ(), 5000), hrnServerProtocolTls),
"azure server run"); "azure server run");
} }
HARNESS_FORK_CHILD_END(); HRN_FORK_CHILD_END();
HARNESS_FORK_PARENT_BEGIN() HRN_FORK_PARENT_BEGIN()
{ {
IoWrite *service = hrnServerScriptBegin( IoWrite *service = hrnServerScriptBegin(
ioFdWriteNew(STRDEF("azure client write"), HARNESS_FORK_PARENT_WRITE_PROCESS(0), 2000)); ioFdWriteNew(STRDEF("azure client write"), HRN_FORK_PARENT_WRITE_PROCESS(0), 2000));
// ----------------------------------------------------------------------------------------------------------------- // -----------------------------------------------------------------------------------------------------------------
TEST_TITLE("test against local host"); TEST_TITLE("test against local host");
@ -857,9 +857,9 @@ testRun(void)
// ----------------------------------------------------------------------------------------------------------------- // -----------------------------------------------------------------------------------------------------------------
hrnServerScriptEnd(service); hrnServerScriptEnd(service);
} }
HARNESS_FORK_PARENT_END(); HRN_FORK_PARENT_END();
} }
HARNESS_FORK_END(); HRN_FORK_END();
} }
FUNCTION_HARNESS_RETURN_VOID(); FUNCTION_HARNESS_RETURN_VOID();

32
test/src/module/storage/gcsTest.c
View File

@ -277,46 +277,46 @@ testRun(void)
{ {
HRN_STORAGE_PUT(storageTest, TEST_KEY_FILE, BUFSTR(strNewFmt(TEST_KEY, strZ(testHost), testPortAuth))); HRN_STORAGE_PUT(storageTest, TEST_KEY_FILE, BUFSTR(strNewFmt(TEST_KEY, strZ(testHost), testPortAuth)));
HARNESS_FORK_BEGIN() HRN_FORK_BEGIN()
{ {
HARNESS_FORK_CHILD_BEGIN(0, true) HRN_FORK_CHILD_BEGIN(0, true)
{ {
TEST_RESULT_VOID( TEST_RESULT_VOID(
hrnServerRunP( hrnServerRunP(
ioFdReadNew(STRDEF("gcs server read"), HARNESS_FORK_CHILD_READ(), 5000), hrnServerProtocolTls, ioFdReadNew(STRDEF("gcs server read"), HRN_FORK_CHILD_READ(), 5000), hrnServerProtocolTls,
.port = testPort), .port = testPort),
"gcs server run"); "gcs server run");
} }
HARNESS_FORK_CHILD_END(); HRN_FORK_CHILD_END();
HARNESS_FORK_CHILD_BEGIN(0, true) HRN_FORK_CHILD_BEGIN(0, true)
{ {
TEST_RESULT_VOID( TEST_RESULT_VOID(
hrnServerRunP( hrnServerRunP(
ioFdReadNew(STRDEF("auth server read"), HARNESS_FORK_CHILD_READ(), 5000), hrnServerProtocolTls, ioFdReadNew(STRDEF("auth server read"), HRN_FORK_CHILD_READ(), 5000), hrnServerProtocolTls,
.port = testPortAuth), .port = testPortAuth),
"auth server run"); "auth server run");
} }
HARNESS_FORK_CHILD_END(); HRN_FORK_CHILD_END();
HARNESS_FORK_CHILD_BEGIN(0, true) HRN_FORK_CHILD_BEGIN(0, true)
{ {
TEST_RESULT_VOID( TEST_RESULT_VOID(
hrnServerRunP( hrnServerRunP(
ioFdReadNew(STRDEF("meta server read"), HARNESS_FORK_CHILD_READ(), 10000), hrnServerProtocolSocket, ioFdReadNew(STRDEF("meta server read"), HRN_FORK_CHILD_READ(), 10000), hrnServerProtocolSocket,
.port = testPortMeta), .port = testPortMeta),
"meta server run"); "meta server run");
} }
HARNESS_FORK_CHILD_END(); HRN_FORK_CHILD_END();
HARNESS_FORK_PARENT_BEGIN() HRN_FORK_PARENT_BEGIN()
{ {
IoWrite *service = hrnServerScriptBegin( IoWrite *service = hrnServerScriptBegin(
ioFdWriteNew(STRDEF("gcs client write"), HARNESS_FORK_PARENT_WRITE_PROCESS(0), 2000)); ioFdWriteNew(STRDEF("gcs client write"), HRN_FORK_PARENT_WRITE_PROCESS(0), 2000));
IoWrite *auth = hrnServerScriptBegin( IoWrite *auth = hrnServerScriptBegin(
ioFdWriteNew(STRDEF("auth client write"), HARNESS_FORK_PARENT_WRITE_PROCESS(1), 2000)); ioFdWriteNew(STRDEF("auth client write"), HRN_FORK_PARENT_WRITE_PROCESS(1), 2000));
IoWrite *meta = hrnServerScriptBegin( IoWrite *meta = hrnServerScriptBegin(
ioFdWriteNew(STRDEF("meta client write"), HARNESS_FORK_PARENT_WRITE_PROCESS(2), 2000)); ioFdWriteNew(STRDEF("meta client write"), HRN_FORK_PARENT_WRITE_PROCESS(2), 2000));
// ----------------------------------------------------------------------------------------------------------------- // -----------------------------------------------------------------------------------------------------------------
TEST_TITLE("test service auth"); TEST_TITLE("test service auth");
@ -976,9 +976,9 @@ testRun(void)
// ----------------------------------------------------------------------------------------------------------------- // -----------------------------------------------------------------------------------------------------------------
hrnServerScriptEnd(service); hrnServerScriptEnd(service);
} }
HARNESS_FORK_PARENT_END(); HRN_FORK_PARENT_END();
} }
HARNESS_FORK_END(); HRN_FORK_END();
} }
FUNCTION_HARNESS_RETURN_VOID(); FUNCTION_HARNESS_RETURN_VOID();

12
test/src/module/storage/posixTest.c
View File

@ -143,22 +143,22 @@ testRun(void)
HRN_SYSTEM_FMT("rm %s", strZ(fileExists)); HRN_SYSTEM_FMT("rm %s", strZ(fileExists));
// ------------------------------------------------------------------------------------------------------------------------- // -------------------------------------------------------------------------------------------------------------------------
HARNESS_FORK_BEGIN() HRN_FORK_BEGIN()
{ {
HARNESS_FORK_CHILD_BEGIN(0, false) HRN_FORK_CHILD_BEGIN(0, false)
{ {
sleepMSec(250); sleepMSec(250);
HRN_SYSTEM_FMT("touch %s", strZ(fileExists)); HRN_SYSTEM_FMT("touch %s", strZ(fileExists));
} }
HARNESS_FORK_CHILD_END(); HRN_FORK_CHILD_END();
HARNESS_FORK_PARENT_BEGIN() HRN_FORK_PARENT_BEGIN()
{ {
TEST_RESULT_BOOL(storageExistsP(storageTest, fileExists, .timeout = 1000), true, "file exists after wait"); TEST_RESULT_BOOL(storageExistsP(storageTest, fileExists, .timeout = 1000), true, "file exists after wait");
} }
HARNESS_FORK_PARENT_END(); HRN_FORK_PARENT_END();
} }
HARNESS_FORK_END(); HRN_FORK_END();
HRN_SYSTEM_FMT("rm %s", strZ(fileExists)); HRN_SYSTEM_FMT("rm %s", strZ(fileExists));
} }

24
test/src/module/storage/s3Test.c
View File

@ -351,33 +351,33 @@ testRun(void)
// ***************************************************************************************************************************** // *****************************************************************************************************************************
if (testBegin("storageS3*(), StorageReadS3, and StorageWriteS3")) if (testBegin("storageS3*(), StorageReadS3, and StorageWriteS3"))
{ {
HARNESS_FORK_BEGIN() HRN_FORK_BEGIN()
{ {
HARNESS_FORK_CHILD_BEGIN(0, true) HRN_FORK_CHILD_BEGIN(0, true)
{ {
TEST_RESULT_VOID( TEST_RESULT_VOID(
hrnServerRunP( hrnServerRunP(
ioFdReadNew(STRDEF("s3 server read"), HARNESS_FORK_CHILD_READ(), 5000), hrnServerProtocolTls, .port = port), ioFdReadNew(STRDEF("s3 server read"), HRN_FORK_CHILD_READ(), 5000), hrnServerProtocolTls, .port = port),
"s3 server run"); "s3 server run");
} }
HARNESS_FORK_CHILD_END(); HRN_FORK_CHILD_END();
HARNESS_FORK_CHILD_BEGIN(0, true) HRN_FORK_CHILD_BEGIN(0, true)
{ {
TEST_RESULT_VOID( TEST_RESULT_VOID(
hrnServerRunP( hrnServerRunP(
ioFdReadNew(STRDEF("auth server read"), HARNESS_FORK_CHILD_READ(), 5000), hrnServerProtocolSocket, ioFdReadNew(STRDEF("auth server read"), HRN_FORK_CHILD_READ(), 5000), hrnServerProtocolSocket,
.port = authPort), .port = authPort),
"auth server run"); "auth server run");
} }
HARNESS_FORK_CHILD_END(); HRN_FORK_CHILD_END();
HARNESS_FORK_PARENT_BEGIN() HRN_FORK_PARENT_BEGIN()
{ {
IoWrite *service = hrnServerScriptBegin( IoWrite *service = hrnServerScriptBegin(
ioFdWriteNew(STRDEF("s3 client write"), HARNESS_FORK_PARENT_WRITE_PROCESS(0), 2000)); ioFdWriteNew(STRDEF("s3 client write"), HRN_FORK_PARENT_WRITE_PROCESS(0), 2000));
IoWrite *auth = hrnServerScriptBegin( IoWrite *auth = hrnServerScriptBegin(
ioFdWriteNew(STRDEF("auth client write"), HARNESS_FORK_PARENT_WRITE_PROCESS(1), 2000)); ioFdWriteNew(STRDEF("auth client write"), HRN_FORK_PARENT_WRITE_PROCESS(1), 2000));
// ----------------------------------------------------------------------------------------------------------------- // -----------------------------------------------------------------------------------------------------------------
TEST_TITLE("config with keys, token, and host with custom port"); TEST_TITLE("config with keys, token, and host with custom port");
@ -1240,9 +1240,9 @@ testRun(void)
// ----------------------------------------------------------------------------------------------------------------- // -----------------------------------------------------------------------------------------------------------------
hrnServerScriptEnd(service); hrnServerScriptEnd(service);
} }
HARNESS_FORK_PARENT_END(); HRN_FORK_PARENT_END();
} }
HARNESS_FORK_END(); HRN_FORK_END();
} }
FUNCTION_HARNESS_RETURN_VOID(); FUNCTION_HARNESS_RETURN_VOID();