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

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.

test/src/common/harnessConfig.c

@@ -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();
 }
 
 /**********************************************************************************************************************************/

test/src/common/harnessDebug.h

@@ -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

test/src/common/harnessInfo.c

@@ -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)));
 }
 
 /***********************************************************************************************************************************

test/src/common/harnessLog.c

@@ -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();
 }

test/src/common/harnessPack.c

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

test/src/common/harnessServer.c

@@ -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();
 }
 
 /**********************************************************************************************************************************/

test/src/common/harnessTest.c

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

test/src/module/command/archiveCommonTest.c

@@ -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();
 }

test/src/module/command/archiveGetTest.c

@@ -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();
 }

test/src/module/command/archivePushTest.c

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

test/src/module/command/backupCommonTest.c

@@ -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();
 }

test/src/module/command/backupTest.c

@@ -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();
 }

test/src/module/command/checkTest.c

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

test/src/module/command/commandTest.c

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

test/src/module/command/controlTest.c

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

test/src/module/command/expireTest.c

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

test/src/module/command/helpTest.c

@@ -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();
 }

test/src/module/command/infoTest.c

@@ -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();
 }

test/src/module/command/localTest.c

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

test/src/module/command/remoteTest.c

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

test/src/module/command/repoTest.c

@@ -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();
 }

test/src/module/command/restoreTest.c

@@ -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();
 }

test/src/module/command/stanzaTest.c

@@ -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();
 }

test/src/module/command/verifyTest.c

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

test/src/module/common/assertOffTest.c

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

test/src/module/common/assertOnTest.c

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

test/src/module/common/compressTest.c

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

test/src/module/common/cryptoTest.c

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

test/src/module/common/debugOffTest.c

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

test/src/module/common/debugOnTest.c

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

test/src/module/common/encodeTest.c

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

test/src/module/common/errorTest.c

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

test/src/module/common/execTest.c

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

test/src/module/common/exitTest.c

@@ -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();
 }

test/src/module/common/forkTest.c

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

test/src/module/common/iniTest.c

@@ -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();
 }

test/src/module/common/ioHttpTest.c

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

test/src/module/common/ioTest.c

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

test/src/module/common/ioTlsTest.c

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

test/src/module/common/lockTest.c

@@ -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();
 }

test/src/module/common/logTest.c

@@ -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();
 }

test/src/module/common/memContextTest.c

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

test/src/module/common/regExpTest.c

@@ -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();
 }

test/src/module/common/stackTraceTest.c

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

test/src/module/common/statTest.c

@@ -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();
 }

test/src/module/common/timeTest.c

@@ -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();
 }

test/src/module/common/typeBufferTest.c

@@ -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();
 }

test/src/module/common/typeConvertTest.c

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

test/src/module/common/typeJsonTest.c

@@ -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();
 }

test/src/module/common/typeKeyValueTest.c

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

test/src/module/common/typeListTest.c

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

test/src/module/common/typeMcvTest.c

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

test/src/module/common/typeObjectTest.c

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

test/src/module/common/typePackTest.c

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

test/src/module/common/typeStringTest.c

@@ -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();
 }

test/src/module/common/typeVariantTest.c

@@ -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();
 }

test/src/module/common/typeXmlTest.c

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

test/src/module/common/typecTest.c

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

test/src/module/common/userTest.c

@@ -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();
 }

test/src/module/common/waitTest.c

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

test/src/module/config/execTest.c

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

test/src/module/config/loadTest.c

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

test/src/module/config/parseTest.c

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

test/src/module/config/protocolTest.c

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

test/src/module/db/dbTest.c

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

test/src/module/performance/storageTest.c

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

test/src/module/performance/typeTest.c

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

test/src/module/postgres/clientTest.c

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

test/src/module/postgres/interfaceTest.c

@@ -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();
 }

test/src/module/protocol/protocolTest.c

@@ -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();
 }

test/src/module/storage/azureTest.c

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

test/src/module/storage/cifsTest.c

@@ -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();
 }

test/src/module/storage/gcsTest.c

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

test/src/module/storage/posixTest.c

@@ -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();
 }

test/src/module/storage/remoteTest.c

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

test/src/module/storage/s3Test.c

@@ -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();
 }

test/src/test.c

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