database/pgbackrest
1
0
Fork 0
mirror of https://github.com/pgbackrest/pgbackrest.git synced 2025-07-30 19:23:04 +03:00
Code Activity

Rename FUNCTION_HARNESS_RESULT*() macros to FUNCTION_HARNESS_RETURN*().

Browse Source 
When the FUNCTION_*_RESULT*() macros were renamed to FUNCTION_*_RETURN_*() in the core code the test harness macros were missed.

Update them to make the naming consistent.
This commit is contained in:
David Steele
2021-03-10 18:42:22 -05:00
parent 778adbf19f
commit 28301199eb
77 changed files with 129 additions and 129 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
test/src/common/harnessConfig.c
View File

@ -54,7 +54,7 @@ harnessCfgLoadRaw(unsigned int argListSize, const char *argList[])
if (cfgOptionValid(cfgOptExecId) && !cfgOptionTest(cfgOptExecId))
cfgOptionSet(cfgOptExecId, cfgSourceParam, VARSTRDEF("1-test"));
FUNCTION_HARNESS_RESULT_VOID();
FUNCTION_HARNESS_RETURN_VOID();
}
/**********************************************************************************************************************************/
@ -90,7 +90,7 @@ harnessCfgLoadRole(ConfigCommand commandId, ConfigCommandRole commandRoleId, con
harnessCfgLoadRaw(strLstSize(argList), strLstPtr(argList));
FUNCTION_HARNESS_RESULT_VOID();
FUNCTION_HARNESS_RETURN_VOID();
}
/**********************************************************************************************************************************/
@ -104,7 +104,7 @@ harnessCfgLoad(ConfigCommand commandId, const StringList *argListParam)
harnessCfgLoadRole(commandId, cfgCmdRoleDefault, argListParam);
FUNCTION_HARNESS_RESULT_VOID();
FUNCTION_HARNESS_RETURN_VOID();
}
/**********************************************************************************************************************************/

8
test/src/common/harnessDebug.h
View File

@ -50,7 +50,7 @@ C Debug Harness
} \
while (0)
#define FUNCTION_HARNESS_RESULT(typeMacroPrefix, result) \
#define FUNCTION_HARNESS_RETURN(typeMacroPrefix, result) \
do \
{ \
STACK_TRACE_POP(false); \
@ -58,7 +58,7 @@ C Debug Harness
} \
while (0)
#define FUNCTION_HARNESS_RESULT_VOID() \
#define FUNCTION_HARNESS_RETURN_VOID() \
STACK_TRACE_POP(false);
#else
#define FUNCTION_HARNESS_INIT(exe)
@ -71,10 +71,10 @@ C Debug Harness
#define FUNCTION_HARNESS_VOID()
#define FUNCTION_HARNESS_ASSERT(condition)
#define FUNCTION_HARNESS_RESULT(typeMacroPrefix, result) \
#define FUNCTION_HARNESS_RETURN(typeMacroPrefix, result) \
return result
#define FUNCTION_HARNESS_RESULT_VOID();
#define FUNCTION_HARNESS_RETURN_VOID();
#endif
#endif

4
test/src/common/harnessInfo.c
View File

@ -102,7 +102,7 @@ harnessInfoChecksum(const String *info)
}
MEM_CONTEXT_TEMP_END();
FUNCTION_HARNESS_RESULT(BUFFER, result);
FUNCTION_HARNESS_RETURN(BUFFER, result);
}
Buffer *
@ -114,7 +114,7 @@ harnessInfoChecksumZ(const char *info)
ASSERT(info != NULL);
FUNCTION_HARNESS_RESULT(BUFFER, harnessInfoChecksum(STR(info)));
FUNCTION_HARNESS_RETURN(BUFFER, harnessInfoChecksum(STR(info)));
}
/***********************************************************************************************************************************

18
test/src/common/harnessLog.c
View File

@ -60,7 +60,7 @@ harnessLogOpen(const char *logFile, int flags, int mode)
if (result == -1)
THROW_SYS_ERROR_FMT(FileOpenError, "unable to open log file '%s'", logFile);
FUNCTION_HARNESS_RESULT(INT, result);
FUNCTION_HARNESS_RETURN(INT, result);
}
/***********************************************************************************************************************************
@ -78,7 +78,7 @@ harnessLogInit(void)
logFdFile = harnessLogOpen(logFile, O_WRONLY | O_CREAT | O_TRUNC, 0640);
logAnySet();
FUNCTION_HARNESS_RESULT_VOID();
FUNCTION_HARNESS_RETURN_VOID();
}
/**********************************************************************************************************************************/
@ -170,7 +170,7 @@ harnessLogLoad(const char *logFile)
if (totalBytes > 0)
harnessLogBuffer[totalBytes - 1] = 0;
FUNCTION_HARNESS_RESULT_VOID();
FUNCTION_HARNESS_RETURN_VOID();
}
/**********************************************************************************************************************************/
@ -243,7 +243,7 @@ hrnLogReplaceAdd(const char *expression, const char *expressionSub, const char *
}
MEM_CONTEXT_END();
FUNCTION_HARNESS_RESULT_VOID();
FUNCTION_HARNESS_RETURN_VOID();
}
/**********************************************************************************************************************************/
@ -255,7 +255,7 @@ hrnLogReplaceClear(void)
if (harnessLog.replaceList != NULL)
lstClear(harnessLog.replaceList);
FUNCTION_HARNESS_RESULT_VOID();
FUNCTION_HARNESS_RETURN_VOID();
}
/***********************************************************************************************************************************
@ -337,7 +337,7 @@ hrnLogReplace(void)
MEM_CONTEXT_TEMP_END();
}
FUNCTION_HARNESS_RESULT_VOID();
FUNCTION_HARNESS_RETURN_VOID();
}
/***********************************************************************************************************************************
@ -369,7 +369,7 @@ harnessLogResult(const char *expected)
close(logFdFile);
logFdFile = harnessLogOpen(logFile, O_WRONLY | O_CREAT | O_TRUNC, 0640);
FUNCTION_HARNESS_RESULT_VOID();
FUNCTION_HARNESS_RETURN_VOID();
}
/***********************************************************************************************************************************
@ -415,7 +415,7 @@ harnessLogResultRegExp(const char *expression)
}
TRY_END();
FUNCTION_HARNESS_RESULT_VOID();
FUNCTION_HARNESS_RETURN_VOID();
}
/***********************************************************************************************************************************
@ -432,5 +432,5 @@ harnessLogFinal(void)
if (strcmp(harnessLogBuffer, "") != 0)
THROW_FMT(AssertError, "\n\nexpected log to be empty but actual log was:\n\n%s\n\n", harnessLogBuffer);
FUNCTION_HARNESS_RESULT_VOID();
FUNCTION_HARNESS_RETURN_VOID();
}

4
test/src/common/harnessPack.c
View File

@ -16,7 +16,7 @@ String *hrnPackBufToStr(const Buffer *buffer)
FUNCTION_HARNESS_PARAM(BUFFER, buffer);
FUNCTION_HARNESS_END();
FUNCTION_HARNESS_RESULT(STRING, hrnPackToStr(pckReadNewBuf(buffer)));
FUNCTION_HARNESS_RETURN(STRING, hrnPackToStr(pckReadNewBuf(buffer)));
}
/**********************************************************************************************************************************/
@ -96,5 +96,5 @@ String *hrnPackToStr(PackRead *read)
first = false;
}
FUNCTION_HARNESS_RESULT(STRING, result);
FUNCTION_HARNESS_RETURN(STRING, result);
}

24
test/src/common/harnessServer.c
View File

@ -64,7 +64,7 @@ hrnServerScriptCommand(IoWrite *write, HrnServerCmd cmd, const Variant *data)
ioWriteStrLine(write, jsonFromVar(data));
ioWriteFlush(write);
FUNCTION_HARNESS_RESULT_VOID();
FUNCTION_HARNESS_RETURN_VOID();
}
/**********************************************************************************************************************************/
@ -78,7 +78,7 @@ IoWrite *hrnServerScriptBegin(IoWrite *write)
ioWriteOpen(write);
FUNCTION_HARNESS_RESULT(IO_WRITE, write);
FUNCTION_HARNESS_RETURN(IO_WRITE, write);
}
void hrnServerScriptEnd(IoWrite *write)
@ -91,7 +91,7 @@ void hrnServerScriptEnd(IoWrite *write)
hrnServerScriptCommand(write, hrnServerCmdDone, NULL);
FUNCTION_HARNESS_RESULT_VOID();
FUNCTION_HARNESS_RETURN_VOID();
}
/**********************************************************************************************************************************/
@ -104,7 +104,7 @@ hrnServerScriptAbort(IoWrite *write)
hrnServerScriptCommand(write, hrnServerCmdAbort, NULL);
FUNCTION_HARNESS_RESULT_VOID();
FUNCTION_HARNESS_RETURN_VOID();
}
void
@ -116,7 +116,7 @@ hrnServerScriptAccept(IoWrite *write)
hrnServerScriptCommand(write, hrnServerCmdAccept, NULL);
FUNCTION_HARNESS_RESULT_VOID();
FUNCTION_HARNESS_RETURN_VOID();
}
void
@ -128,7 +128,7 @@ hrnServerScriptClose(IoWrite *write)
hrnServerScriptCommand(write, hrnServerCmdClose, NULL);
FUNCTION_HARNESS_RESULT_VOID();
FUNCTION_HARNESS_RETURN_VOID();
}
void
@ -143,7 +143,7 @@ hrnServerScriptExpect(IoWrite *write, const String *data)
hrnServerScriptCommand(write, hrnServerCmdExpect, VARSTR(data));
FUNCTION_HARNESS_RESULT_VOID();
FUNCTION_HARNESS_RETURN_VOID();
}
void
@ -158,7 +158,7 @@ hrnServerScriptExpectZ(IoWrite *write, const char *data)
hrnServerScriptCommand(write, hrnServerCmdExpect, VARSTRZ(data));
FUNCTION_HARNESS_RESULT_VOID();
FUNCTION_HARNESS_RETURN_VOID();
}
void
@ -173,7 +173,7 @@ hrnServerScriptReply(IoWrite *write, const String *data)
hrnServerScriptCommand(write, hrnServerCmdReply, VARSTR(data));
FUNCTION_HARNESS_RESULT_VOID();
FUNCTION_HARNESS_RETURN_VOID();
}
void
@ -188,7 +188,7 @@ hrnServerScriptReplyZ(IoWrite *write, const char *data)
hrnServerScriptCommand(write, hrnServerCmdReply, VARSTRZ(data));
FUNCTION_HARNESS_RESULT_VOID();
FUNCTION_HARNESS_RETURN_VOID();
}
void
@ -203,7 +203,7 @@ hrnServerScriptSleep(IoWrite *write, TimeMSec sleepMs)
hrnServerScriptCommand(write, hrnServerCmdSleep, VARUINT64(sleepMs));
FUNCTION_HARNESS_RESULT_VOID();
FUNCTION_HARNESS_RETURN_VOID();
}
/**********************************************************************************************************************************/
@ -422,7 +422,7 @@ void hrnServerRun(IoRead *read, HrnServerProtocol protocol, HrnServerRunParam pa
if (protocol == hrnServerProtocolTls)
SSL_CTX_free(serverContext);
FUNCTION_HARNESS_RESULT_VOID();
FUNCTION_HARNESS_RETURN_VOID();
}
/**********************************************************************************************************************************/

38
test/src/common/harnessTest.c
View File

@ -117,7 +117,7 @@ hrnInit(
strcpy(testGroupData, testGroupTemp);
FUNCTION_HARNESS_RESULT_VOID();
FUNCTION_HARNESS_RETURN_VOID();
}
/***********************************************************************************************************************************
@ -141,7 +141,7 @@ hrnAdd(int run, bool selected)
testList[testTotal].selected = selected;
testTotal++;
FUNCTION_HARNESS_RESULT_VOID();
FUNCTION_HARNESS_RETURN_VOID();
}
/***********************************************************************************************************************************
@ -218,7 +218,7 @@ testBegin(const char *name)
harnessTestLocal.logLastBeginTime = 0;
FUNCTION_HARNESS_RESULT(BOOL, result);
FUNCTION_HARNESS_RETURN(BOOL, result);
}
/***********************************************************************************************************************************
@ -242,7 +242,7 @@ hrnComplete(void)
exit(255);
}
FUNCTION_HARNESS_RESULT_VOID();
FUNCTION_HARNESS_RETURN_VOID();
}
/***********************************************************************************************************************************
@ -281,7 +281,7 @@ hrnReplaceStr(char *string, size_t bufferSize, const char *substring, const char
begin = strstr(begin + strlen(replace), substring);
}
FUNCTION_HARNESS_RESULT_VOID();
FUNCTION_HARNESS_RETURN_VOID();
}
/**********************************************************************************************************************************/
@ -308,7 +308,7 @@ hrnReplaceKey(const char *string)
hrnReplaceStr(harnessReplaceKeyBuffer, sizeof(harnessReplaceKeyBuffer), "{[group]}", testGroup());
hrnReplaceStr(harnessReplaceKeyBuffer, sizeof(harnessReplaceKeyBuffer), "{[project-exe]}", testProjectExe());
FUNCTION_HARNESS_RESULT(STRINGZ, harnessReplaceKeyBuffer);
FUNCTION_HARNESS_RETURN(STRINGZ, harnessReplaceKeyBuffer);
}
/**********************************************************************************************************************************/
@ -403,7 +403,7 @@ hrnDiff(const char *expected, const char *actual)
// Remove last linefeed from diff output
harnessDiffBuffer[strlen(harnessDiffBuffer) - 1] = 0;
FUNCTION_HARNESS_RESULT(STRINGZ, harnessDiffBuffer);
FUNCTION_HARNESS_RETURN(STRINGZ, harnessDiffBuffer);
}
/**********************************************************************************************************************************/
@ -465,7 +465,7 @@ hrnTestLogPrefix(int lineNo, bool padding)
// Add line number and padding
printf("l%04d %s", lineNo, padding ? " " : "");
FUNCTION_HARNESS_RESULT_VOID();
FUNCTION_HARNESS_RETURN_VOID();
}
/**********************************************************************************************************************************/
@ -500,7 +500,7 @@ hrnTestResultException(void)
harnessTestLocal.result.statement, errorName(), errorMessage(), errorStackTrace());
}
FUNCTION_HARNESS_RESULT(BOOL, false);
FUNCTION_HARNESS_RETURN(BOOL, false);
}
void
@ -751,7 +751,7 @@ const char *
testExe(void)
{
FUNCTION_HARNESS_VOID();
FUNCTION_HARNESS_RESULT(STRINGZ, testExeData);
FUNCTION_HARNESS_RETURN(STRINGZ, testExeData);
}
/**********************************************************************************************************************************/
@ -759,7 +759,7 @@ const char *
testProjectExe(void)
{
FUNCTION_HARNESS_VOID();
FUNCTION_HARNESS_RESULT(STRINGZ, testProjectExeData);
FUNCTION_HARNESS_RETURN(STRINGZ, testProjectExeData);
}
/**********************************************************************************************************************************/
@ -767,7 +767,7 @@ bool
testContainer(void)
{
FUNCTION_HARNESS_VOID();
FUNCTION_HARNESS_RESULT(BOOL, testContainerData);
FUNCTION_HARNESS_RETURN(BOOL, testContainerData);
}
/**********************************************************************************************************************************/
@ -775,7 +775,7 @@ unsigned int
testIdx(void)
{
FUNCTION_HARNESS_VOID();
FUNCTION_HARNESS_RESULT(UINT, testIdxData);
FUNCTION_HARNESS_RETURN(UINT, testIdxData);
}
/**********************************************************************************************************************************/
@ -783,7 +783,7 @@ uint64_t
testScale(void)
{
FUNCTION_HARNESS_VOID();
FUNCTION_HARNESS_RESULT(UINT64, testScaleData);
FUNCTION_HARNESS_RETURN(UINT64, testScaleData);
}
/**********************************************************************************************************************************/
@ -791,7 +791,7 @@ const char *
testPath(void)
{
FUNCTION_HARNESS_VOID();
FUNCTION_HARNESS_RESULT(STRINGZ, testPathData);
FUNCTION_HARNESS_RETURN(STRINGZ, testPathData);
}
/**********************************************************************************************************************************/
@ -799,7 +799,7 @@ const char *
testDataPath(void)
{
FUNCTION_HARNESS_VOID();
FUNCTION_HARNESS_RESULT(STRINGZ, testDataPathData);
FUNCTION_HARNESS_RETURN(STRINGZ, testDataPathData);
}
/**********************************************************************************************************************************/
@ -807,7 +807,7 @@ const char *
testRepoPath(void)
{
FUNCTION_HARNESS_VOID();
FUNCTION_HARNESS_RESULT(STRINGZ, testRepoPathData);
FUNCTION_HARNESS_RETURN(STRINGZ, testRepoPathData);
}
/**********************************************************************************************************************************/
@ -833,7 +833,7 @@ testTimeMSec(void)
struct timeval currentTime;
gettimeofday(&currentTime, NULL);
FUNCTION_HARNESS_RESULT(UINT64, ((uint64_t)currentTime.tv_sec * 1000) + (uint64_t)currentTime.tv_usec / 1000);
FUNCTION_HARNESS_RETURN(UINT64, ((uint64_t)currentTime.tv_sec * 1000) + (uint64_t)currentTime.tv_usec / 1000);
}
/**********************************************************************************************************************************/
@ -842,5 +842,5 @@ testTimeMSecBegin(void)
{
FUNCTION_HARNESS_VOID();
FUNCTION_HARNESS_RESULT(UINT64, timeMSecBegin);
FUNCTION_HARNESS_RETURN(UINT64, timeMSecBegin);
}

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

@ -353,5 +353,5 @@ testRun(void)
TEST_RESULT_STRLST_Z(strLstSort(list, sortOrderDesc), "11-10\n10-4\n9.4-2\n9.6-1\n", "sort descending");
}
FUNCTION_HARNESS_RESULT_VOID();
FUNCTION_HARNESS_RETURN_VOID();
}

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

@ -1080,5 +1080,5 @@ testRun(void)
TEST_RESULT_BOOL(archiveGetProtocol(strNew(BOGUS_STR), paramList, server), false, "invalid function");
}
FUNCTION_HARNESS_RESULT_VOID();
FUNCTION_HARNESS_RETURN_VOID();
}

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

@ -945,5 +945,5 @@ testRun(void)
"000000010000000100000001.ok\n000000010000000100000002.ok\n", "check status files");
}
FUNCTION_HARNESS_RESULT_VOID();
FUNCTION_HARNESS_RETURN_VOID();
}

2
test/src/module/command/backupCommonTest.c
View File

@ -324,5 +324,5 @@ testRun(void)
TEST_RESULT_STR_Z(backupTypeStr(backupTypeIncr), "incr", "backup type str incr");
}
FUNCTION_HARNESS_RESULT_VOID();
FUNCTION_HARNESS_RETURN_VOID();
}

4
test/src/module/command/backupTest.c
View File

@ -225,7 +225,7 @@ testBackupValidate(const Storage *storage, const String *path)
}
MEM_CONTEXT_TEMP_END();
FUNCTION_HARNESS_RESULT(STRING, result);
FUNCTION_HARNESS_RETURN(STRING, result);
}
/***********************************************************************************************************************************
@ -2649,5 +2649,5 @@ testRun(void)
}
}
FUNCTION_HARNESS_RESULT_VOID();
FUNCTION_HARNESS_RETURN_VOID();
}

2
test/src/module/command/checkTest.c
View File

@ -571,5 +571,5 @@ testRun(void)
"HINT: did an error occur during stanza-upgrade?");
}
FUNCTION_HARNESS_RESULT_VOID();
FUNCTION_HARNESS_RETURN_VOID();
}

2
test/src/module/command/commandTest.c
View File

@ -145,5 +145,5 @@ testRun(void)
harnessLogLevelReset();
}
FUNCTION_HARNESS_RESULT_VOID();
FUNCTION_HARNESS_RETURN_VOID();
}

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

@ -354,5 +354,5 @@ testRun(void)
HARNESS_FORK_END();
}
FUNCTION_HARNESS_RESULT_VOID();
FUNCTION_HARNESS_RETURN_VOID();
}

2
test/src/module/command/expireTest.c
View File

@ -2431,5 +2431,5 @@ testRun(void)
harnessLogLevelReset();
}
FUNCTION_HARNESS_RESULT_VOID();
FUNCTION_HARNESS_RETURN_VOID();
}

2
test/src/module/command/helpTest.c
View File

@ -478,5 +478,5 @@ testRun(void)
TEST_RESULT_STR_Z(strNewBuf(storageGetP(storageNewReadP(storage, stdoutFile))), generalHelp, " check text");
}
FUNCTION_HARNESS_RESULT_VOID();
FUNCTION_HARNESS_RETURN_VOID();
}

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

@ -2608,5 +2608,5 @@ testRun(void)
"HINT: is the backup listed when running the info command with --stanza option only?");
}
FUNCTION_HARNESS_RESULT_VOID();
FUNCTION_HARNESS_RETURN_VOID();
}

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

@ -57,5 +57,5 @@ testRun(void)
HARNESS_FORK_END();
}
FUNCTION_HARNESS_RESULT_VOID();
FUNCTION_HARNESS_RETURN_VOID();
}

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

@ -204,5 +204,5 @@ testRun(void)
HARNESS_FORK_END();
}
FUNCTION_HARNESS_RESULT_VOID();
FUNCTION_HARNESS_RETURN_VOID();
}

2
test/src/module/command/repoTest.c
View File

@ -777,5 +777,5 @@ testRun(void)
TEST_RESULT_BOOL(storagePathExistsP(storageRepo(), STRDEF("path")), true, " check path exists");
}
FUNCTION_HARNESS_RESULT_VOID();
FUNCTION_HARNESS_RETURN_VOID();
}

6
test/src/module/command/restoreTest.c
View File

@ -90,7 +90,7 @@ testRestoreCompare(const Storage *storage, const String *pgPath, const Manifest
// Compare
TEST_RESULT_STR_Z(callbackData.content, hrnReplaceKey(compare), " compare result manifest");
FUNCTION_HARNESS_RESULT_VOID();
FUNCTION_HARNESS_RETURN_VOID();
}
/***********************************************************************************************************************************
@ -136,7 +136,7 @@ testManifestMinimal(const String *label, unsigned int pgVersion, const String *p
}
MEM_CONTEXT_NEW_END();
FUNCTION_HARNESS_RESULT(MANIFEST, result);
FUNCTION_HARNESS_RETURN(MANIFEST, result);
}
/***********************************************************************************************************************************
@ -2591,5 +2591,5 @@ testRun(void)
testPath());
}
FUNCTION_HARNESS_RESULT_VOID();
FUNCTION_HARNESS_RETURN_VOID();
}

2
test/src/module/command/stanzaTest.c
View File

@ -1153,5 +1153,5 @@ testRun(void)
storageExistsP(storageTest, strNewFmt("repo/archive/%s/archive.info", strZ(stanzaOther))), true, "otherstanza exists");
}
FUNCTION_HARNESS_RESULT_VOID();
FUNCTION_HARNESS_RETURN_VOID();
}

2
test/src/module/command/verifyTest.c
View File

@ -1565,5 +1565,5 @@ testRun(void)
strZ(backupLabelDiff), strZ(backupLabelFullDb2))));
}
FUNCTION_HARNESS_RESULT_VOID();
FUNCTION_HARNESS_RETURN_VOID();
}

2
test/src/module/common/assertOffTest.c
View File

@ -17,5 +17,5 @@ testRun(void)
TEST_RESULT_VOID(ASSERT(false || false), "assert false ignored");
}
FUNCTION_HARNESS_RESULT_VOID();
FUNCTION_HARNESS_RETURN_VOID();
}

2
test/src/module/common/assertOnTest.c
View File

@ -17,5 +17,5 @@ testRun(void)
TEST_ERROR(ASSERT(false || false), AssertError, "assertion 'false || false' failed");
}
FUNCTION_HARNESS_RESULT_VOID();
FUNCTION_HARNESS_RETURN_VOID();
}

2
test/src/module/common/compressTest.c
View File

@ -383,5 +383,5 @@ testRun(void)
TEST_RESULT_INT(compressLevelDefault(compressTypeGz), 6, "gz level=6");
}
FUNCTION_HARNESS_RESULT_VOID();
FUNCTION_HARNESS_RETURN_VOID();
}

2
test/src/module/common/cryptoTest.c
View File

@ -387,5 +387,5 @@ testRun(void)
" check hmac");
}
FUNCTION_HARNESS_RESULT_VOID();
FUNCTION_HARNESS_RETURN_VOID();
}

2
test/src/module/common/debugOffTest.c
View File

@ -30,5 +30,5 @@ testRun(void)
TEST_RESULT_Z(debugUnitExtern, "static", "DEBUG_UNIT_EXTERN is static");
}
FUNCTION_HARNESS_RESULT_VOID();
FUNCTION_HARNESS_RETURN_VOID();
}

2
test/src/module/common/debugOnTest.c
View File

@ -160,5 +160,5 @@ testRun(void)
harnessLogResult("");
}
FUNCTION_HARNESS_RESULT_VOID();
FUNCTION_HARNESS_RETURN_VOID();
}

2
test/src/module/common/encodeTest.c
View File

@ -139,5 +139,5 @@ testRun(void)
TEST_ERROR(decodeToBin(encodeBase64Url, "c3", destinationDecode), AssertError, "unsupported");
}
FUNCTION_HARNESS_RESULT_VOID();
FUNCTION_HARNESS_RETURN_VOID();
}

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

@ -386,5 +386,5 @@ testRun(void)
HARNESS_FORK_END();
}
FUNCTION_HARNESS_RESULT_VOID();
FUNCTION_HARNESS_RETURN_VOID();
}

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

@ -108,5 +108,5 @@ testRun(void)
TEST_RESULT_VOID(execFree(exec), "sleep exited as expected");
}
FUNCTION_HARNESS_RESULT_VOID();
FUNCTION_HARNESS_RETURN_VOID();
}

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

@ -153,5 +153,5 @@ testRun(void)
harnessLogResult("P00 INFO: archive-push:async command end: terminated on signal [SIGTERM]");
}
FUNCTION_HARNESS_RESULT_VOID();
FUNCTION_HARNESS_RETURN_VOID();
}

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

@ -35,5 +35,5 @@ testRun(void)
HARNESS_FORK_END();
}
FUNCTION_HARNESS_RESULT_VOID();
FUNCTION_HARNESS_RETURN_VOID();
}

2
test/src/module/common/iniTest.c
View File

@ -198,5 +198,5 @@ testRun(void)
TEST_RESULT_STR_Z(iniGet(ini, strNew("db"), strNew("pg1-path")), "/path/to/pg", "get pg1-path");
}
FUNCTION_HARNESS_RESULT_VOID();
FUNCTION_HARNESS_RETURN_VOID();
}

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

@ -727,5 +727,5 @@ testRun(void)
TEST_RESULT_BOOL(varLstEmpty(kvKeyList(statToKv())), false, "check");
}
FUNCTION_HARNESS_RESULT_VOID();
FUNCTION_HARNESS_RETURN_VOID();
}

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

@ -679,5 +679,5 @@ testRun(void)
TRY_END();
}
FUNCTION_HARNESS_RESULT_VOID();
FUNCTION_HARNESS_RETURN_VOID();
}

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

@ -506,5 +506,5 @@ testRun(void)
TEST_RESULT_BOOL(varLstEmpty(kvKeyList(statToKv())), false, "check");
}
FUNCTION_HARNESS_RESULT_VOID();
FUNCTION_HARNESS_RETURN_VOID();
}

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

@ -212,5 +212,5 @@ testRun(void)
TEST_RESULT_BOOL(storageExistsP(storageTest, backupLockFile), true, "backup lock file still exists");
}
FUNCTION_HARNESS_RESULT_VOID();
FUNCTION_HARNESS_RETURN_VOID();
}

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

@ -24,7 +24,7 @@ testLogOpen(const char *logFile, int flags, int mode)
THROW_ON_SYS_ERROR_FMT(result == -1, FileOpenError, "unable to open log file '%s'", logFile);
FUNCTION_HARNESS_RESULT(INT, result);
FUNCTION_HARNESS_RETURN(INT, result);
}
/***********************************************************************************************************************************
@ -64,7 +64,7 @@ testLogLoad(const char *logFile, char *buffer, size_t bufferSize)
// Remove final linefeed
buffer[totalBytes - 1] = 0;
FUNCTION_HARNESS_RESULT_VOID();
FUNCTION_HARNESS_RETURN_VOID();
}
/***********************************************************************************************************************************
@ -88,7 +88,7 @@ testLogResult(const char *logFile, const char *expected)
THROW_FMT( // {+uncovered}
AssertError, "\n\nexpected log:\n\n%s\n\nbut actual log was:\n\n%s\n\n", expected, actual);
FUNCTION_HARNESS_RESULT_VOID();
FUNCTION_HARNESS_RETURN_VOID();
}
/***********************************************************************************************************************************
@ -308,5 +308,5 @@ testRun(void)
"P99 INFO: [DRY-RUN] info message 2");
}
FUNCTION_HARNESS_RESULT_VOID();
FUNCTION_HARNESS_RETURN_VOID();
}

2
test/src/module/common/memContextTest.c
View File

@ -420,5 +420,5 @@ testRun(void)
memContextFree(memContextTop());
FUNCTION_HARNESS_RESULT_VOID();
FUNCTION_HARNESS_RETURN_VOID();
}

2
test/src/module/common/regExpTest.c
View File

@ -111,5 +111,5 @@ testRun(void)
TEST_RESULT_BOOL(regExpMatchOne(strNew("^abc"), strNew("bcdef")), false, "no match regexp");
}
FUNCTION_HARNESS_RESULT_VOID();
FUNCTION_HARNESS_RETURN_VOID();
}

2
test/src/module/common/stackTraceTest.c
View File

@ -193,5 +193,5 @@ testRun(void)
assert(stackTraceLocal.stackSize == 0);
}
FUNCTION_HARNESS_RESULT_VOID();
FUNCTION_HARNESS_RETURN_VOID();
}

2
test/src/module/common/statTest.c
View File

@ -29,5 +29,5 @@ testRun(void)
TEST_RESULT_STR_Z(jsonFromKv(statToKv()), "{\"http.session\":{\"total\":1},\"tls.client\":{\"total\":2}}", "stat output");
}
FUNCTION_HARNESS_RESULT_VOID();
FUNCTION_HARNESS_RETURN_VOID();
}

2
test/src/module/common/timeTest.c
View File

@ -98,5 +98,5 @@ testRun(void)
TEST_RESULT_INT(epochFromParts(2020, 1, 8, 9, 18, 15, tzOffsetSeconds(-7, 0)), 1578500295, "epoch with timezone");
}
FUNCTION_HARNESS_RESULT_VOID();
FUNCTION_HARNESS_RETURN_VOID();
}

2
test/src/module/common/typeBufferTest.c
View File

@ -162,5 +162,5 @@ testRun(void)
TEST_RESULT_STR_Z(bufToLog(buffer), "{used: 0, size: 50, sizeAlloc: 100}", "buf to log");
}
FUNCTION_HARNESS_RESULT_VOID();
FUNCTION_HARNESS_RETURN_VOID();
}

2
test/src/module/common/typeConvertTest.c
View File

@ -202,5 +202,5 @@ testRun(void)
TEST_RESULT_UINT(cvtZToUInt64("18446744073709551615"), 18446744073709551615U, "convert string to uint64");
}
FUNCTION_HARNESS_RESULT_VOID();
FUNCTION_HARNESS_RETURN_VOID();
}

2
test/src/module/common/typeJsonTest.c
View File

@ -309,5 +309,5 @@ testRun(void)
TEST_RESULT_STR_Z(jsonFromVar(varNewStrZ("test \" string")), "\"test \\\" string\"", "string variant");
}
FUNCTION_HARNESS_RESULT_VOID();
FUNCTION_HARNESS_RETURN_VOID();
}

2
test/src/module/common/typeKeyValueTest.c
View File

@ -110,5 +110,5 @@ testRun(void)
TEST_RESULT_VOID(kvFree(store), "free store");
}
FUNCTION_HARNESS_RESULT_VOID();
FUNCTION_HARNESS_RETURN_VOID();
}

2
test/src/module/common/typeListTest.c
View File

@ -210,5 +210,5 @@ testRun(void)
CHECK(*(int *)lstFind(list, &listIdx) == listIdx);
}
FUNCTION_HARNESS_RESULT_VOID();
FUNCTION_HARNESS_RETURN_VOID();
}

2
test/src/module/common/typeMcvTest.c
View File

@ -64,5 +64,5 @@ testRun(void)
TEST_RESULT_BOOL(varBool(mcvResult(mcv)), false, "result is false");
}
FUNCTION_HARNESS_RESULT_VOID();
FUNCTION_HARNESS_RETURN_VOID();
}

2
test/src/module/common/typeObjectTest.c
View File

@ -94,5 +94,5 @@ testRun(void)
TEST_RESULT_BOOL(testObjectFreeResourceCalled, true, " check callback");
}
FUNCTION_HARNESS_RESULT_VOID();
FUNCTION_HARNESS_RETURN_VOID();
}

2
test/src/module/common/typePackTest.c
View File

@ -312,5 +312,5 @@ testRun(void)
TEST_RESULT_STR_Z(pckReadStrP(packRead), "test", "read string");
}
FUNCTION_HARNESS_RESULT_VOID();
FUNCTION_HARNESS_RETURN_VOID();
}

2
test/src/module/common/typeStringTest.c
View File

@ -539,5 +539,5 @@ testRun(void)
TEST_RESULT_STR_Z(strLstToLog(list), "{[\"item1\", \"item2\", \"item3\"]}", "format 3 item list");
}
FUNCTION_HARNESS_RESULT_VOID();
FUNCTION_HARNESS_RETURN_VOID();
}

2
test/src/module/common/typeVariantTest.c
View File

@ -418,5 +418,5 @@ testRun(void)
TEST_RESULT_PTR(varLstNewStrLst(NULL), NULL, "variant list from null string list");
}
FUNCTION_HARNESS_RESULT_VOID();
FUNCTION_HARNESS_RETURN_VOID();
}

2
test/src/module/common/typeXmlTest.c
View File

@ -107,5 +107,5 @@ testRun(void)
"get xml");
}
FUNCTION_HARNESS_RESULT_VOID();
FUNCTION_HARNESS_RETURN_VOID();
}

2
test/src/module/common/typecTest.c
View File

@ -23,5 +23,5 @@ testRun(void)
assert(!false);
}
FUNCTION_HARNESS_RESULT_VOID();
FUNCTION_HARNESS_RETURN_VOID();
}

2
test/src/module/common/userTest.c
View File

@ -32,5 +32,5 @@ testRun(void)
TEST_RESULT_STR_Z(groupNameFromId(77777), NULL, "invalid group name by id");
}
FUNCTION_HARNESS_RESULT_VOID();
FUNCTION_HARNESS_RETURN_VOID();
}

2
test/src/module/common/waitTest.c
View File

@ -65,5 +65,5 @@ testRun(void)
TEST_RESULT_VOID(waitFree(wait), " free wait");
}
FUNCTION_HARNESS_RESULT_VOID();
FUNCTION_HARNESS_RETURN_VOID();
}

2
test/src/module/config/execTest.c
View File

@ -75,5 +75,5 @@ testRun(void)
"exec restore -> restore");
}
FUNCTION_HARNESS_RESULT_VOID();
FUNCTION_HARNESS_RETURN_VOID();
}

2
test/src/module/config/loadTest.c
View File

@ -708,5 +708,5 @@ testRun(void)
lockRelease(true);
}
FUNCTION_HARNESS_RESULT_VOID();
FUNCTION_HARNESS_RETURN_VOID();
}

2
test/src/module/config/parseTest.c
View File

@ -1713,5 +1713,5 @@ testRun(void)
}
}
FUNCTION_HARNESS_RESULT_VOID();
FUNCTION_HARNESS_RETURN_VOID();
}

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

@ -66,5 +66,5 @@ testRun(void)
HARNESS_FORK_END();
}
FUNCTION_HARNESS_RESULT_VOID();
FUNCTION_HARNESS_RETURN_VOID();
}

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

@ -685,5 +685,5 @@ testRun(void)
TEST_RESULT_VOID(dbFree(result.standby), "free standby");
}
FUNCTION_HARNESS_RESULT_VOID();
FUNCTION_HARNESS_RETURN_VOID();
}

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

@ -383,5 +383,5 @@ testRun(void)
#endif // HAVE_LIBLZ4
}
FUNCTION_HARNESS_RESULT_VOID();
FUNCTION_HARNESS_RETURN_VOID();
}

2
test/src/module/performance/typeTest.c
View File

@ -360,5 +360,5 @@ testRun(void)
}
}
FUNCTION_HARNESS_RESULT_VOID();
FUNCTION_HARNESS_RETURN_VOID();
}

2
test/src/module/postgres/clientTest.c
View File

@ -317,5 +317,5 @@ testRun(void)
TEST_RESULT_VOID(pgClientClose(client), "close client again");
}
FUNCTION_HARNESS_RESULT_VOID();
FUNCTION_HARNESS_RETURN_VOID();
}

2
test/src/module/postgres/interfaceTest.c
View File

@ -269,5 +269,5 @@ testRun(void)
TEST_RESULT_STR_Z(pgWalToLog(&pgWal), "{version: 100000, systemId: 1095199817470}", "check log");
}
FUNCTION_HARNESS_RESULT_VOID();
FUNCTION_HARNESS_RETURN_VOID();
}

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

@ -64,7 +64,7 @@ testServerProtocol(const String *command, const VariantList *paramList, Protocol
}
MEM_CONTEXT_TEMP_END();
FUNCTION_HARNESS_RESULT(BOOL, found);
FUNCTION_HARNESS_RETURN(BOOL, found);
}
/***********************************************************************************************************************************
@ -1059,5 +1059,5 @@ testRun(void)
TEST_RESULT_VOID(protocolFree(), "free local and remote protocol objects");
}
FUNCTION_HARNESS_RESULT_VOID();
FUNCTION_HARNESS_RETURN_VOID();
}

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

@ -857,5 +857,5 @@ testRun(void)
HARNESS_FORK_END();
}
FUNCTION_HARNESS_RESULT_VOID();
FUNCTION_HARNESS_RETURN_VOID();
}

2
test/src/module/storage/cifsTest.c
View File

@ -40,5 +40,5 @@ testRun(void)
TEST_RESULT_VOID(storagePathSyncP(storage, strNew(BOGUS_STR)), "path sync is a noop");
}
FUNCTION_HARNESS_RESULT_VOID();
FUNCTION_HARNESS_RETURN_VOID();
}

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

@ -927,5 +927,5 @@ testRun(void)
HARNESS_FORK_END();
}
FUNCTION_HARNESS_RESULT_VOID();
FUNCTION_HARNESS_RETURN_VOID();
}

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

@ -1304,5 +1304,5 @@ testRun(void)
TEST_ERROR(storageSpoolWrite(), AssertError, "stanza cannot be NULL for this storage object");
}
FUNCTION_HARNESS_RESULT_VOID();
FUNCTION_HARNESS_RETURN_VOID();
}

2
test/src/module/storage/remoteTest.c
View File

@ -783,5 +783,5 @@ testRun(void)
protocolFree();
FUNCTION_HARNESS_RESULT_VOID();
FUNCTION_HARNESS_RETURN_VOID();
}

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

@ -195,7 +195,7 @@ testS3DateTime(time_t time)
strftime(buffer, sizeof(buffer), "%Y-%m-%dT%H:%M:%SZ", gmtime(&time)) != sizeof(buffer) - 1, AssertError,
"unable to format date");
FUNCTION_HARNESS_RESULT(STRING, strNew(buffer));
FUNCTION_HARNESS_RETURN(STRING, strNew(buffer));
}
/***********************************************************************************************************************************
@ -1179,5 +1179,5 @@ testRun(void)
HARNESS_FORK_END();
}
FUNCTION_HARNESS_RESULT_VOID();
FUNCTION_HARNESS_RETURN_VOID();
}

2
test/src/test.c
View File

@ -203,5 +203,5 @@ main(int argListSize, const char *argList[])
TRY_END();
#endif
FUNCTION_HARNESS_RESULT(INT, result);
FUNCTION_HARNESS_RETURN(INT, result);
}