From d6ffa9ea6d45fcae46abd79a5f6d6123e79c9168 Mon Sep 17 00:00:00 2001 From: David Steele Date: Sun, 22 Mar 2020 20:25:31 -0400 Subject: [PATCH] Fix incorrect result types in unit tests. Upcoming changes to the TEST_RESULT_* macros are more type safe and identified that the wrong macros were being used to test results in many cases. Commit these changes separately to verify that they work with the current macro versions. Note that no core bugs were exposed by these changes. --- test/src/common/harnessTest.h | 16 --------- test/src/module/command/archiveGetTest.c | 4 +-- test/src/module/command/restoreTest.c | 20 +++++------ test/src/module/common/cryptoTest.c | 42 ++++++++++++------------ test/src/module/common/debugOnTest.c | 24 +++++++------- test/src/module/common/encodeTest.c | 28 ++++++++-------- test/src/module/common/ioTest.c | 36 ++++++++++---------- test/src/module/common/ioTlsTest.c | 8 ++--- test/src/module/common/lockTest.c | 2 +- test/src/module/common/regExpTest.c | 4 +-- test/src/module/common/stackTraceTest.c | 6 ++-- test/src/module/common/typeBufferTest.c | 26 +++++++-------- test/src/module/common/typeConvertTest.c | 26 +++++++-------- test/src/module/common/typeJsonTest.c | 2 +- test/src/module/common/typeListTest.c | 6 ++-- test/src/module/common/typeStringTest.c | 16 ++++----- test/src/module/common/typeVariantTest.c | 20 +++++------ test/src/module/common/waitTest.c | 12 +++---- test/src/module/config/configTest.c | 2 +- test/src/module/config/loadTest.c | 4 +-- test/src/module/config/parseTest.c | 4 +-- test/src/module/info/infoArchiveTest.c | 2 +- test/src/module/info/infoBackupTest.c | 18 +++++----- test/src/module/info/infoPgTest.c | 22 ++++++------- test/src/module/info/manifestTest.c | 6 ++-- test/src/module/postgres/interfaceTest.c | 20 +++++------ test/src/module/storage/posixTest.c | 30 ++++++++--------- test/src/module/storage/remoteTest.c | 16 ++++----- test/src/module/storage/s3Test.c | 4 +-- 29 files changed, 205 insertions(+), 221 deletions(-) diff --git a/test/src/common/harnessTest.h b/test/src/common/harnessTest.h index 6158687eb..5d336f356 100644 --- a/test/src/common/harnessTest.h +++ b/test/src/common/harnessTest.h @@ -271,13 +271,6 @@ Macros to ease the use of common data types #define TEST_RESULT_BOOL(statement, resultExpected, ...) \ TEST_RESULT_BOOL_PARAM(statement, resultExpected, ==, __VA_ARGS__); -#define TEST_RESULT_CHAR_PARAM(statement, resultExpected, typeOp, ...) \ - TEST_RESULT(statement, resultExpected, char, "%c", TEST_TYPE_FORMAT, typeOp, TEST_TYPE_COMPARE, __VA_ARGS__); -#define TEST_RESULT_CHAR(statement, resultExpected, ...) \ - TEST_RESULT_CHAR_PARAM(statement, resultExpected, ==, __VA_ARGS__); -#define TEST_RESULT_CHAR_NE(statement, resultExpected, ...) \ - TEST_RESULT_CHAR_PARAM(statement, resultExpected, !=, __VA_ARGS__); - #define TEST_RESULT_DOUBLE_PARAM(statement, resultExpected, typeOp, ...) \ TEST_RESULT(statement, resultExpected, double, "%f", TEST_TYPE_FORMAT, typeOp, TEST_TYPE_COMPARE, __VA_ARGS__); #define TEST_RESULT_DOUBLE(statement, resultExpected, ...) \ @@ -297,13 +290,6 @@ Macros to ease the use of common data types #define TEST_RESULT_PTR_NE(statement, resultExpected, ...) \ TEST_RESULT_PTR_PARAM(statement, resultExpected, !=, __VA_ARGS__); -#define TEST_RESULT_SIZE_PARAM(statement, resultExpected, typeOp, ...) \ - TEST_RESULT(statement, resultExpected, size_t, "%zu", TEST_TYPE_FORMAT, typeOp, TEST_TYPE_COMPARE, __VA_ARGS__); -#define TEST_RESULT_SIZE(statement, resultExpected, ...) \ - TEST_RESULT_SIZE_PARAM(statement, resultExpected, ==, __VA_ARGS__); -#define TEST_RESULT_SIZE_NE(statement, resultExpected, ...) \ - TEST_RESULT_SIZE_PARAM(statement, resultExpected, !=, __VA_ARGS__); - #define TEST_RESULT_Z_PARAM(statement, resultExpected, typeOp, ...) \ TEST_RESULT(statement, resultExpected, char *, "%s", TEST_TYPE_FORMAT_PTR, typeOp, TEST_TYPE_COMPARE_STR, __VA_ARGS__); #define TEST_RESULT_Z(statement, resultExpected, ...) \ @@ -326,8 +312,6 @@ Macros to ease the use of common data types TEST_RESULT_UINT_PARAM(statement, resultExpected, ==, __VA_ARGS__); #define TEST_RESULT_UINT_NE(statement, resultExpected, ...) \ TEST_RESULT_UINT_PARAM(statement, resultExpected, !=, __VA_ARGS__); -#define TEST_RESULT_UINT_HEX(statement, resultExpected, ...) \ - TEST_RESULT(statement, resultExpected, uint64_t, "%" PRIx64, TEST_TYPE_FORMAT, ==, TEST_TYPE_COMPARE, __VA_ARGS__); /*********************************************************************************************************************************** Test system calls diff --git a/test/src/module/command/archiveGetTest.c b/test/src/module/command/archiveGetTest.c index 8f5790601..4d3fb9982 100644 --- a/test/src/module/command/archiveGetTest.c +++ b/test/src/module/command/archiveGetTest.c @@ -168,7 +168,7 @@ testRun(void) TEST_RESULT_INT( archiveGetFile(storageTest, archiveFile, walDestination, false, cipherTypeNone, NULL), 0, "WAL segment copied"); TEST_RESULT_BOOL(storageExistsP(storageTest, walDestination), true, " check exists"); - TEST_RESULT_INT(storageInfoP(storageTest, walDestination).size, 16 * 1024 * 1024, " check size"); + TEST_RESULT_UINT(storageInfoP(storageTest, walDestination).size, 16 * 1024 * 1024, " check size"); storageRemoveP( storageTest, @@ -211,7 +211,7 @@ testRun(void) archiveGetFile( storageTest, archiveFile, walDestination, false, cipherTypeAes256Cbc, strNew("12345678")), 0, "WAL segment copied"); TEST_RESULT_BOOL(storageExistsP(storageTest, walDestination), true, " check exists"); - TEST_RESULT_INT(storageInfoP(storageTest, walDestination).size, 16 * 1024 * 1024, " check size"); + TEST_RESULT_UINT(storageInfoP(storageTest, walDestination).size, 16 * 1024 * 1024, " check size"); // Check protocol function directly // ------------------------------------------------------------------------------------------------------------------------- diff --git a/test/src/module/command/restoreTest.c b/test/src/module/command/restoreTest.c index 8f4686981..0a5dd8a95 100644 --- a/test/src/module/command/restoreTest.c +++ b/test/src/module/command/restoreTest.c @@ -219,7 +219,7 @@ testRun(void) TEST_RESULT_BOOL(info.exists, true, " check exists"); TEST_RESULT_UINT(info.size, 7, " check size"); TEST_RESULT_UINT(info.mode, 0600, " check mode"); - TEST_RESULT_UINT(info.timeModified, 1557432154, " check time"); + TEST_RESULT_INT(info.timeModified, 1557432154, " check time"); TEST_RESULT_STR_Z(info.user, testUser(), " check user"); TEST_RESULT_STR_Z(info.group, testGroup(), " check group"); TEST_RESULT_STR_Z(strNewBuf(storageGetP(storageNewReadP(storagePg(), strNew("normal")))), "acefile", " check contents"); @@ -338,7 +338,7 @@ testRun(void) TEST_RESULT_BOOL(info.exists, true, " check exists"); TEST_RESULT_UINT(info.size, 9, " check size"); TEST_RESULT_UINT(info.mode, 0677, " check mode"); - TEST_RESULT_UINT(info.timeModified, 1557432100, " check time"); + TEST_RESULT_INT(info.timeModified, 1557432100, " check time"); TEST_RESULT_STR_Z(info.user, testUser(), " check user"); TEST_RESULT_STR_Z(info.group, testGroup(), " check group"); TEST_RESULT_STR_Z( @@ -452,9 +452,9 @@ testRun(void) TEST_TITLE("system time UTC"); setenv("TZ", "UTC", true); - TEST_RESULT_UINT(getEpoch(strNew("2020-01-08 09:18:15-0700")), 1578500295, "epoch with timezone"); - TEST_RESULT_UINT(getEpoch(strNew("2020-01-08 16:18:15.0000")), 1578500295, "same epoch no timezone"); - TEST_RESULT_UINT(getEpoch(strNew("2020-01-08 16:18:15.0000+00")), 1578500295, "same epoch timezone 0"); + TEST_RESULT_INT(getEpoch(strNew("2020-01-08 09:18:15-0700")), 1578500295, "epoch with timezone"); + TEST_RESULT_INT(getEpoch(strNew("2020-01-08 16:18:15.0000")), 1578500295, "same epoch no timezone"); + TEST_RESULT_INT(getEpoch(strNew("2020-01-08 16:18:15.0000+00")), 1578500295, "same epoch timezone 0"); TEST_ERROR_FMT(getEpoch(strNew("2020-13-08 16:18:15")), FormatError, "invalid date 2020-13-08"); TEST_ERROR_FMT(getEpoch(strNew("2020-01-08 16:68:15")), FormatError, "invalid time 16:68:15"); @@ -466,15 +466,15 @@ testRun(void) char timeBuffer[20]; strftime(timeBuffer, sizeof(timeBuffer), "%Y-%m-%d %H:%M:%S", localtime(&testTime)); TEST_RESULT_Z(timeBuffer, "2019-11-14 13:02:49", "check timezone set"); - TEST_RESULT_UINT(getEpoch(strNew("2019-11-14 13:02:49-0500")), 1573754569, "offset same as local"); - TEST_RESULT_UINT(getEpoch(strNew("2019-11-14 13:02:49")), 1573754569, "GMT-0500 (EST)"); - TEST_RESULT_UINT(getEpoch(strNew("2019-09-14 20:02:49")), 1568505769, "GMT-0400 (EDT)"); - TEST_RESULT_UINT(getEpoch(strNew("2018-04-27 04:29:00+04:30")), 1524787140, "GMT+0430"); + TEST_RESULT_INT(getEpoch(strNew("2019-11-14 13:02:49-0500")), 1573754569, "offset same as local"); + TEST_RESULT_INT(getEpoch(strNew("2019-11-14 13:02:49")), 1573754569, "GMT-0500 (EST)"); + TEST_RESULT_INT(getEpoch(strNew("2019-09-14 20:02:49")), 1568505769, "GMT-0400 (EDT)"); + TEST_RESULT_INT(getEpoch(strNew("2018-04-27 04:29:00+04:30")), 1524787140, "GMT+0430"); // ------------------------------------------------------------------------------------------------------------------------- TEST_TITLE("invalid target time format"); - TEST_RESULT_UINT(getEpoch(strNew("Tue, 15 Nov 1994 12:45:26")), 0, "invalid date time format"); + TEST_RESULT_INT(getEpoch(strNew("Tue, 15 Nov 1994 12:45:26")), 0, "invalid date time format"); TEST_RESULT_LOG( "P00 WARN: automatic backup set selection cannot be performed with provided time 'Tue, 15 Nov 1994 12:45:26'," " latest backup set will be used\n" diff --git a/test/src/module/common/cryptoTest.c b/test/src/module/common/cryptoTest.c index c38c8c628..b17256eb5 100644 --- a/test/src/module/common/cryptoTest.c +++ b/test/src/module/common/cryptoTest.c @@ -92,11 +92,11 @@ testRun(void) cipherBlockNew(cipherModeEncrypt, cipherTypeAes256Cbc, BUFSTRZ(TEST_PASS), NULL)); TEST_RESULT_Z(memContextName(cipherBlock->memContext), "CipherBlock", "mem context name is valid"); TEST_RESULT_INT(cipherBlock->mode, cipherModeEncrypt, "mode is valid"); - TEST_RESULT_INT(cipherBlock->passSize, strlen(TEST_PASS), "passphrase size is valid"); + TEST_RESULT_UINT(cipherBlock->passSize, strlen(TEST_PASS), "passphrase size is valid"); TEST_RESULT_BOOL(memcmp(cipherBlock->pass, TEST_PASS, strlen(TEST_PASS)) == 0, true, "passphrase is valid"); TEST_RESULT_BOOL(cipherBlock->saltDone, false, "salt done is false"); TEST_RESULT_BOOL(cipherBlock->processDone, false, "process done is false"); - TEST_RESULT_INT(cipherBlock->headerSize, 0, "header size is 0"); + TEST_RESULT_UINT(cipherBlock->headerSize, 0, "header size is 0"); TEST_RESULT_PTR_NE(cipherBlock->cipher, NULL, "cipher is set"); TEST_RESULT_PTR_NE(cipherBlock->digest, NULL, "digest is set"); TEST_RESULT_PTR(cipherBlock->cipherContext, NULL, "cipher context is not set"); @@ -109,13 +109,13 @@ testRun(void) blockEncryptFilter = cipherBlockNewVar(ioFilterParamList(blockEncryptFilter)); CipherBlock *blockEncrypt = (CipherBlock *)ioFilterDriver(blockEncryptFilter); - TEST_RESULT_INT( + TEST_RESULT_UINT( cipherBlockProcessSize(blockEncrypt, strlen(TEST_PLAINTEXT)), strlen(TEST_PLAINTEXT) + EVP_MAX_BLOCK_LENGTH + CIPHER_BLOCK_MAGIC_SIZE + PKCS5_SALT_LEN, "check process size"); bufLimitSet(encryptBuffer, CIPHER_BLOCK_MAGIC_SIZE); ioFilterProcessInOut(blockEncryptFilter, testPlainText, encryptBuffer); - TEST_RESULT_INT(bufUsed(encryptBuffer), CIPHER_BLOCK_MAGIC_SIZE, "cipher size is magic size"); + TEST_RESULT_UINT(bufUsed(encryptBuffer), CIPHER_BLOCK_MAGIC_SIZE, "cipher size is magic size"); TEST_RESULT_BOOL(ioFilterInputSame(blockEncryptFilter), true, "filter needs same input"); bufLimitSet(encryptBuffer, CIPHER_BLOCK_MAGIC_SIZE + PKCS5_SALT_LEN); @@ -124,10 +124,10 @@ testRun(void) TEST_RESULT_BOOL(blockEncrypt->saltDone, true, "salt done is true"); TEST_RESULT_BOOL(blockEncrypt->processDone, true, "process done is true"); - TEST_RESULT_INT(blockEncrypt->headerSize, 0, "header size is 0"); - TEST_RESULT_INT(bufUsed(encryptBuffer), CIPHER_BLOCK_HEADER_SIZE, "cipher size is header len"); + TEST_RESULT_UINT(blockEncrypt->headerSize, 0, "header size is 0"); + TEST_RESULT_UINT(bufUsed(encryptBuffer), CIPHER_BLOCK_HEADER_SIZE, "cipher size is header len"); - TEST_RESULT_INT( + TEST_RESULT_UINT( cipherBlockProcessSize(blockEncrypt, strlen(TEST_PLAINTEXT)), strlen(TEST_PLAINTEXT) + EVP_MAX_BLOCK_LENGTH, "check process size"); @@ -139,13 +139,13 @@ testRun(void) ioFilterProcessInOut(blockEncryptFilter, testPlainText, encryptBuffer); bufLimitClear(encryptBuffer); - TEST_RESULT_INT( + TEST_RESULT_UINT( bufUsed(encryptBuffer), CIPHER_BLOCK_HEADER_SIZE + (size_t)EVP_CIPHER_block_size(blockEncrypt->cipher), "cipher size increases by one block"); TEST_RESULT_BOOL(ioFilterDone(blockEncryptFilter), false, "filter is not done"); ioFilterProcessInOut(blockEncryptFilter, NULL, encryptBuffer); - TEST_RESULT_INT( + TEST_RESULT_UINT( bufUsed(encryptBuffer), CIPHER_BLOCK_HEADER_SIZE + (size_t)(EVP_CIPHER_block_size(blockEncrypt->cipher) * 2), "cipher size increases by one block on flush"); TEST_RESULT_BOOL(ioFilterDone(blockEncryptFilter), true, "filter is done"); @@ -160,15 +160,15 @@ testRun(void) blockDecryptFilter = cipherBlockNewVar(ioFilterParamList(blockDecryptFilter)); CipherBlock *blockDecrypt = (CipherBlock *)ioFilterDriver(blockDecryptFilter); - TEST_RESULT_INT( + TEST_RESULT_UINT( cipherBlockProcessSize(blockDecrypt, bufUsed(encryptBuffer)), bufUsed(encryptBuffer) + EVP_MAX_BLOCK_LENGTH, "check process size"); ioFilterProcessInOut(blockDecryptFilter, encryptBuffer, decryptBuffer); - TEST_RESULT_INT(bufUsed(decryptBuffer), EVP_CIPHER_block_size(blockDecrypt->cipher), "decrypt size is one block"); + TEST_RESULT_UINT(bufUsed(decryptBuffer), EVP_CIPHER_block_size(blockDecrypt->cipher), "decrypt size is one block"); ioFilterProcessInOut(blockDecryptFilter, NULL, decryptBuffer); - TEST_RESULT_INT(bufUsed(decryptBuffer), strlen(TEST_PLAINTEXT) * 2, "check final decrypt size"); + TEST_RESULT_UINT(bufUsed(decryptBuffer), strlen(TEST_PLAINTEXT) * 2, "check final decrypt size"); TEST_RESULT_STR_Z(strNewBuf(decryptBuffer), TEST_PLAINTEXT TEST_PLAINTEXT, "check final decrypt buffer"); @@ -182,19 +182,19 @@ testRun(void) bufUsedZero(decryptBuffer); ioFilterProcessInOut(blockDecryptFilter, bufNewC(bufPtr(encryptBuffer), CIPHER_BLOCK_MAGIC_SIZE), decryptBuffer); - TEST_RESULT_INT(bufUsed(decryptBuffer), 0, "no decrypt since header read is not complete"); + TEST_RESULT_UINT(bufUsed(decryptBuffer), 0, "no decrypt since header read is not complete"); TEST_RESULT_BOOL(blockDecrypt->saltDone, false, "salt done is false"); TEST_RESULT_BOOL(blockDecrypt->processDone, false, "process done is false"); - TEST_RESULT_INT(blockDecrypt->headerSize, CIPHER_BLOCK_MAGIC_SIZE, "check header size"); + TEST_RESULT_UINT(blockDecrypt->headerSize, CIPHER_BLOCK_MAGIC_SIZE, "check header size"); TEST_RESULT_BOOL( memcmp(blockDecrypt->header, CIPHER_BLOCK_MAGIC, CIPHER_BLOCK_MAGIC_SIZE) == 0, true, "check header magic"); ioFilterProcessInOut( blockDecryptFilter, bufNewC(bufPtr(encryptBuffer) + CIPHER_BLOCK_MAGIC_SIZE, PKCS5_SALT_LEN), decryptBuffer); - TEST_RESULT_INT(bufUsed(decryptBuffer), 0, "no decrypt since no data processed yet"); + TEST_RESULT_UINT(bufUsed(decryptBuffer), 0, "no decrypt since no data processed yet"); TEST_RESULT_BOOL(blockDecrypt->saltDone, true, "salt done is true"); TEST_RESULT_BOOL(blockDecrypt->processDone, false, "process done is false"); - TEST_RESULT_INT(blockDecrypt->headerSize, CIPHER_BLOCK_MAGIC_SIZE, "check header size (not increased)"); + TEST_RESULT_UINT(blockDecrypt->headerSize, CIPHER_BLOCK_MAGIC_SIZE, "check header size (not increased)"); TEST_RESULT_BOOL( memcmp( blockDecrypt->header + CIPHER_BLOCK_MAGIC_SIZE, bufPtr(encryptBuffer) + CIPHER_BLOCK_MAGIC_SIZE, @@ -205,10 +205,10 @@ testRun(void) blockDecryptFilter, bufNewC(bufPtr(encryptBuffer) + CIPHER_BLOCK_HEADER_SIZE, bufUsed(encryptBuffer) - CIPHER_BLOCK_HEADER_SIZE), decryptBuffer); - TEST_RESULT_INT(bufUsed(decryptBuffer), EVP_CIPHER_block_size(blockDecrypt->cipher), "decrypt size is one block"); + TEST_RESULT_UINT(bufUsed(decryptBuffer), EVP_CIPHER_block_size(blockDecrypt->cipher), "decrypt size is one block"); ioFilterProcessInOut(blockDecryptFilter, NULL, decryptBuffer); - TEST_RESULT_INT(bufUsed(decryptBuffer), strlen(TEST_PLAINTEXT) * 2, "check final decrypt size"); + TEST_RESULT_UINT(bufUsed(decryptBuffer), strlen(TEST_PLAINTEXT) * 2, "check final decrypt size"); TEST_RESULT_STR_Z(strNewBuf(decryptBuffer), TEST_PLAINTEXT TEST_PLAINTEXT, "check final decrypt buffer"); @@ -222,7 +222,7 @@ testRun(void) bufUsedZero(encryptBuffer); ioFilterProcessInOut(blockEncryptFilter, NULL, encryptBuffer); - TEST_RESULT_INT(bufUsed(encryptBuffer), 32, "check remaining size"); + TEST_RESULT_UINT(bufUsed(encryptBuffer), 32, "check remaining size"); ioFilterFree(blockEncryptFilter); @@ -232,9 +232,9 @@ testRun(void) bufUsedZero(decryptBuffer); ioFilterProcessInOut(blockDecryptFilter, encryptBuffer, decryptBuffer); - TEST_RESULT_INT(bufUsed(decryptBuffer), 0, "0 bytes processed"); + TEST_RESULT_UINT(bufUsed(decryptBuffer), 0, "0 bytes processed"); ioFilterProcessInOut(blockDecryptFilter, NULL, decryptBuffer); - TEST_RESULT_INT(bufUsed(decryptBuffer), 0, "0 bytes on flush"); + TEST_RESULT_UINT(bufUsed(decryptBuffer), 0, "0 bytes on flush"); ioFilterFree(blockDecryptFilter); diff --git a/test/src/module/common/debugOnTest.c b/test/src/module/common/debugOnTest.c index f59d5b297..c1ab05713 100644 --- a/test/src/module/common/debugOnTest.c +++ b/test/src/module/common/debugOnTest.c @@ -55,42 +55,42 @@ testRun(void) { char buffer[STACK_TRACE_PARAM_MAX]; - TEST_RESULT_INT(objToLog(NULL, "Object", buffer, 4), 4, "truncated null"); + TEST_RESULT_UINT(objToLog(NULL, "Object", buffer, 4), 4, "truncated null"); TEST_RESULT_Z(buffer, "nul", " check truncated null"); - TEST_RESULT_INT(objToLog(NULL, "Object", buffer, sizeof(buffer)), 4, "full null"); + TEST_RESULT_UINT(objToLog(NULL, "Object", buffer, sizeof(buffer)), 4, "full null"); TEST_RESULT_Z(buffer, "null", " check full null"); - TEST_RESULT_INT(objToLog((void *)1, "Object", buffer, 4), 8, "truncated object"); + TEST_RESULT_UINT(objToLog((void *)1, "Object", buffer, 4), 8, "truncated object"); TEST_RESULT_Z(buffer, "{Ob", " check truncated object"); - TEST_RESULT_INT(objToLog((void *)1, "Object", buffer, sizeof(buffer)), 8, "full object"); + TEST_RESULT_UINT(objToLog((void *)1, "Object", buffer, sizeof(buffer)), 8, "full object"); TEST_RESULT_Z(buffer, "{Object}", " check full object"); // ------------------------------------------------------------------------------------------------------------------------- - TEST_RESULT_INT(ptrToLog(NULL, "char *", buffer, 4), 4, "truncated null"); + TEST_RESULT_UINT(ptrToLog(NULL, "char *", buffer, 4), 4, "truncated null"); TEST_RESULT_Z(buffer, "nul", " check truncated null"); - TEST_RESULT_INT(ptrToLog(NULL, "char *", buffer, sizeof(buffer)), 4, "full null"); + TEST_RESULT_UINT(ptrToLog(NULL, "char *", buffer, sizeof(buffer)), 4, "full null"); TEST_RESULT_Z(buffer, "null", " check full null"); - TEST_RESULT_INT(ptrToLog((void *)1, "char *", buffer, 4), 8, "truncated pointer"); + TEST_RESULT_UINT(ptrToLog((void *)1, "char *", buffer, 4), 8, "truncated pointer"); TEST_RESULT_Z(buffer, "(ch", " check truncated pointer"); - TEST_RESULT_INT(ptrToLog((void *)1, "char *", buffer, sizeof(buffer)), 8, "full pointer"); + TEST_RESULT_UINT(ptrToLog((void *)1, "char *", buffer, sizeof(buffer)), 8, "full pointer"); TEST_RESULT_Z(buffer, "(char *)", " check full pointer"); // ------------------------------------------------------------------------------------------------------------------------- - TEST_RESULT_INT(strzToLog(NULL, buffer, 4), 4, "truncated null"); + TEST_RESULT_UINT(strzToLog(NULL, buffer, 4), 4, "truncated null"); TEST_RESULT_Z(buffer, "nul", " check truncated null"); - TEST_RESULT_INT(strzToLog(NULL, buffer, sizeof(buffer)), 4, "full null"); + TEST_RESULT_UINT(strzToLog(NULL, buffer, sizeof(buffer)), 4, "full null"); TEST_RESULT_Z(buffer, "null", " check full null"); - TEST_RESULT_INT(strzToLog("test", buffer, 4), 6, "truncated string"); + TEST_RESULT_UINT(strzToLog("test", buffer, 4), 6, "truncated string"); TEST_RESULT_Z(buffer, "\"te", " check truncated string"); - TEST_RESULT_INT(strzToLog("test2", buffer, sizeof(buffer)), 7, "full string"); + TEST_RESULT_UINT(strzToLog("test2", buffer, sizeof(buffer)), 7, "full string"); TEST_RESULT_Z(buffer, "\"test2\"", " check full string"); } diff --git a/test/src/module/common/encodeTest.c b/test/src/module/common/encodeTest.c index 24c6bb3c6..c6e0f9384 100644 --- a/test/src/module/common/encodeTest.c +++ b/test/src/module/common/encodeTest.c @@ -13,32 +13,32 @@ testRun(void) // ***************************************************************************************************************************** if (testBegin("base64")) { - unsigned char *encode = (unsigned char *)"string_to_encode\r\n"; + const unsigned char *encode = (const unsigned char *)"string_to_encode\r\n"; char destinationEncode[256]; encodeToStr(encodeBase64, encode, 1, destinationEncode); TEST_RESULT_Z(destinationEncode, "cw==", "1 character encode"); - TEST_RESULT_INT(encodeToStrSize(encodeBase64, 1), strlen(destinationEncode), "check size"); + TEST_RESULT_UINT(encodeToStrSize(encodeBase64, 1), strlen(destinationEncode), "check size"); encodeToStr(encodeBase64, encode, 2, destinationEncode); TEST_RESULT_Z(destinationEncode, "c3Q=", "2 character encode"); - TEST_RESULT_INT(encodeToStrSize(encodeBase64, 2), strlen(destinationEncode), "check size"); + TEST_RESULT_UINT(encodeToStrSize(encodeBase64, 2), strlen(destinationEncode), "check size"); encodeToStr(encodeBase64, encode, 3, destinationEncode); TEST_RESULT_Z(destinationEncode, "c3Ry", "3 character encode"); - TEST_RESULT_INT(encodeToStrSize(encodeBase64, 3), strlen(destinationEncode), "check size"); + TEST_RESULT_UINT(encodeToStrSize(encodeBase64, 3), strlen(destinationEncode), "check size"); encodeToStr(encodeBase64, encode, strlen((char *)encode) - 2, destinationEncode); TEST_RESULT_Z(destinationEncode, "c3RyaW5nX3RvX2VuY29kZQ==", "encode full string"); - TEST_RESULT_INT(encodeToStrSize(encodeBase64, strlen((char *)encode) - 2), strlen(destinationEncode), "check size"); + TEST_RESULT_UINT(encodeToStrSize(encodeBase64, strlen((char *)encode) - 2), strlen(destinationEncode), "check size"); encodeToStr(encodeBase64, encode, strlen((char *)encode), destinationEncode); TEST_RESULT_Z(destinationEncode, "c3RyaW5nX3RvX2VuY29kZQ0K", "encode full string with \\r\\n"); - TEST_RESULT_INT(encodeToStrSize(encodeBase64, strlen((char *)encode)), strlen(destinationEncode), "check size"); + TEST_RESULT_UINT(encodeToStrSize(encodeBase64, strlen((char *)encode)), strlen(destinationEncode), "check size"); encodeToStr(encodeBase64, encode, strlen((char *)encode) + 1, destinationEncode); TEST_RESULT_Z(destinationEncode, "c3RyaW5nX3RvX2VuY29kZQ0KAA==", "encode full string with \\r\\n and null"); - TEST_RESULT_INT(encodeToStrSize(encodeBase64, strlen((char *)encode) + 1), strlen(destinationEncode), "check size"); + TEST_RESULT_UINT(encodeToStrSize(encodeBase64, strlen((char *)encode) + 1), strlen(destinationEncode), "check size"); TEST_ERROR(encodeToStr(999, encode, strlen((char *)encode), destinationEncode), AssertError, "invalid encode type 999"); TEST_ERROR(encodeToStrSize(999, strlen((char *)encode)), AssertError, "invalid encode type 999"); @@ -49,44 +49,44 @@ testRun(void) memset(destinationDecode, 0xFF, sizeof(destinationDecode)); const char *decode = "c3RyaW5nX3RvX2VuY29kZQ0KAA=="; decodeToBin(encodeBase64, decode, destinationDecode); - TEST_RESULT_Z(destinationDecode, encode, "full string with \\r\\n and null decode"); + TEST_RESULT_Z((char *)destinationDecode, (char *)encode, "full string with \\r\\n and null decode"); TEST_RESULT_INT(destinationDecode[strlen((char *)encode) + 1], 0xFF, "check for overrun"); - TEST_RESULT_INT(decodeToBinSize(encodeBase64, decode), strlen((char *)encode) + 1, "check size"); + TEST_RESULT_UINT(decodeToBinSize(encodeBase64, decode), strlen((char *)encode) + 1, "check size"); memset(destinationDecode, 0xFF, sizeof(destinationDecode)); decode = "c3RyaW5nX3RvX2VuY29kZQ0K"; decodeToBin(encodeBase64, decode, destinationDecode); TEST_RESULT_INT(memcmp(destinationDecode, encode, strlen((char *)encode)), 0, "full string with \\r\\n decode"); TEST_RESULT_INT(destinationDecode[strlen((char *)encode)], 0xFF, "check for overrun"); - TEST_RESULT_INT(decodeToBinSize(encodeBase64, decode), strlen((char *)encode), "check size"); + TEST_RESULT_UINT(decodeToBinSize(encodeBase64, decode), strlen((char *)encode), "check size"); memset(destinationDecode, 0xFF, sizeof(destinationDecode)); decode = "c3RyaW5nX3RvX2VuY29kZQ=="; decodeToBin(encodeBase64, decode, destinationDecode); TEST_RESULT_INT(memcmp(destinationDecode, encode, strlen((char *)encode) - 2), 0, "full string decode"); TEST_RESULT_INT(destinationDecode[strlen((char *)encode) - 2], 0xFF, "check for overrun"); - TEST_RESULT_INT(decodeToBinSize(encodeBase64, decode), strlen((char *)encode) - 2, "check size"); + TEST_RESULT_UINT(decodeToBinSize(encodeBase64, decode), strlen((char *)encode) - 2, "check size"); memset(destinationDecode, 0xFF, sizeof(destinationDecode)); decode = "c3Ry"; decodeToBin(encodeBase64, decode, destinationDecode); TEST_RESULT_INT(memcmp(destinationDecode, encode, 3), 0, "3 character decode"); TEST_RESULT_INT(destinationDecode[3], 0xFF, "check for overrun"); - TEST_RESULT_INT(decodeToBinSize(encodeBase64, decode), 3, "check size"); + TEST_RESULT_UINT(decodeToBinSize(encodeBase64, decode), 3, "check size"); memset(destinationDecode, 0xFF, sizeof(destinationDecode)); decode = "c3Q="; decodeToBin(encodeBase64, decode, destinationDecode); TEST_RESULT_INT(memcmp(destinationDecode, encode, 2), 0, "2 character decode"); TEST_RESULT_INT(destinationDecode[2], 0xFF, "check for overrun"); - TEST_RESULT_INT(decodeToBinSize(encodeBase64, decode), 2, "check size"); + TEST_RESULT_UINT(decodeToBinSize(encodeBase64, decode), 2, "check size"); memset(destinationDecode, 0xFF, sizeof(destinationDecode)); decode = "cw=="; decodeToBin(encodeBase64, decode, destinationDecode); TEST_RESULT_INT(memcmp(destinationDecode, encode, 1), 0, "1 character decode"); TEST_RESULT_INT(destinationDecode[1], 0xFF, "check for overrun"); - TEST_RESULT_INT(decodeToBinSize(encodeBase64, decode), 1, "check size"); + TEST_RESULT_UINT(decodeToBinSize(encodeBase64, decode), 1, "check size"); TEST_ERROR(decodeToBin(9999, decode, destinationDecode), AssertError, "invalid encode type 9999"); TEST_ERROR(decodeToBinSize(9999, decode), AssertError, "invalid encode type 9999"); diff --git a/test/src/module/common/ioTest.c b/test/src/module/common/ioTest.c index 1616cfd9c..f9e550988 100644 --- a/test/src/module/common/ioTest.c +++ b/test/src/module/common/ioTest.c @@ -251,9 +251,9 @@ testRun(void) // ***************************************************************************************************************************** if (testBegin("ioBufferSize() and ioBufferSizeSet()")) { - TEST_RESULT_SIZE(ioBufferSize(), 65536, "check initial buffer size"); + TEST_RESULT_UINT(ioBufferSize(), 65536, "check initial buffer size"); TEST_RESULT_VOID(ioBufferSizeSet(16384), "set buffer size"); - TEST_RESULT_SIZE(ioBufferSize(), 16384, "check buffer size"); + TEST_RESULT_UINT(ioBufferSize(), 16384, "check buffer size"); } // ***************************************************************************************************************************** @@ -274,7 +274,7 @@ testRun(void) "create io read object"); TEST_RESULT_BOOL(ioReadOpen(read), true, " open io object"); - TEST_RESULT_SIZE(ioRead(read, buffer), 2, " read 2 bytes"); + TEST_RESULT_UINT(ioRead(read, buffer), 2, " read 2 bytes"); TEST_RESULT_BOOL(ioReadEof(read), false, " no eof"); TEST_RESULT_VOID(ioReadClose(read), " close io object"); TEST_RESULT_BOOL(testIoReadCloseCalled, true, " check io object closed"); @@ -291,7 +291,7 @@ testRun(void) TEST_ASSIGN(bufferRead, ioBufferReadNew(bufferOriginal), "create empty buffer read object"); TEST_RESULT_BOOL(ioReadOpen(bufferRead), true, " open"); TEST_RESULT_BOOL(ioReadEof(bufferRead), false, " not eof"); - TEST_RESULT_SIZE(ioRead(bufferRead, buffer), 0, " read 0 bytes"); + TEST_RESULT_UINT(ioRead(bufferRead, buffer), 0, " read 0 bytes"); TEST_RESULT_BOOL(ioReadEof(bufferRead), true, " now eof"); // ------------------------------------------------------------------------------------------------------------------------- @@ -323,26 +323,26 @@ testRun(void) TEST_RESULT_BOOL(ioReadOpen(bufferRead), true, " open"); TEST_RESULT_INT(ioReadHandle(bufferRead), -1, " handle invalid"); TEST_RESULT_BOOL(ioReadEof(bufferRead), false, " not eof"); - TEST_RESULT_SIZE(ioRead(bufferRead, buffer), 2, " read 2 bytes"); - TEST_RESULT_SIZE(ioRead(bufferRead, buffer), 0, " read 0 bytes (full buffer)"); + TEST_RESULT_UINT(ioRead(bufferRead, buffer), 2, " read 2 bytes"); + TEST_RESULT_UINT(ioRead(bufferRead, buffer), 0, " read 0 bytes (full buffer)"); TEST_RESULT_STR_Z(strNewBuf(buffer), "11", " check read"); TEST_RESULT_STR_Z(ioFilterType(sizeFilter), "size", "check filter type"); TEST_RESULT_BOOL(ioReadEof(bufferRead), false, " not eof"); TEST_RESULT_VOID(bufUsedZero(buffer), " zero buffer"); - TEST_RESULT_SIZE(ioRead(bufferRead, buffer), 2, " read 2 bytes"); + TEST_RESULT_UINT(ioRead(bufferRead, buffer), 2, " read 2 bytes"); TEST_RESULT_STR_Z(strNewBuf(buffer), "22", " check read"); TEST_ASSIGN(buffer, bufNew(3), "change output buffer size to 3"); - TEST_RESULT_SIZE(ioRead(bufferRead, buffer), 3, " read 3 bytes"); + TEST_RESULT_UINT(ioRead(bufferRead, buffer), 3, " read 3 bytes"); TEST_RESULT_STR_Z(strNewBuf(buffer), "33X", " check read"); TEST_RESULT_VOID(bufUsedZero(buffer), " zero buffer"); - TEST_RESULT_SIZE(ioRead(bufferRead, buffer), 2, " read 2 bytes"); + TEST_RESULT_UINT(ioRead(bufferRead, buffer), 2, " read 2 bytes"); TEST_RESULT_STR_Z(strNewBuf(buffer), "XX", " check read"); TEST_RESULT_BOOL(ioReadEof(bufferRead), true, " eof"); - TEST_RESULT_BOOL(ioBufferRead(ioReadDriver(bufferRead), buffer, true), 0, " eof from driver"); - TEST_RESULT_SIZE(ioRead(bufferRead, buffer), 0, " read 0 bytes"); + TEST_RESULT_UINT(ioBufferRead(ioReadDriver(bufferRead), buffer, true), 0, " eof from driver"); + TEST_RESULT_UINT(ioRead(bufferRead, buffer), 0, " read 0 bytes"); TEST_RESULT_VOID(ioReadClose(bufferRead), " close buffer read object"); TEST_RESULT_STR_Z( jsonFromVar(ioFilterGroupResultAll(ioReadFilterGroup(bufferRead))), @@ -397,7 +397,7 @@ testRun(void) buffer = bufNew(3); // Start with a buffer read - TEST_RESULT_INT(ioRead(read, buffer), 3, "read buffer"); + TEST_RESULT_UINT(ioRead(read, buffer), 3, "read buffer"); TEST_RESULT_STR_Z(strNewBuf(buffer), "AAA", " check buffer"); // Do line reads of various lengths @@ -407,14 +407,14 @@ testRun(void) TEST_RESULT_STR_Z(ioReadLine(read), "12", "read line"); // Read what was left in the line buffer - TEST_RESULT_INT(ioRead(read, buffer), 0, "read buffer"); + TEST_RESULT_UINT(ioRead(read, buffer), 0, "read buffer"); bufUsedSet(buffer, 2); - TEST_RESULT_INT(ioRead(read, buffer), 1, "read buffer"); + TEST_RESULT_UINT(ioRead(read, buffer), 1, "read buffer"); TEST_RESULT_STR_Z(strNewBuf(buffer), "AAB", " check buffer"); bufUsedSet(buffer, 0); // Now do a full buffer read from the input - TEST_RESULT_INT(ioRead(read, buffer), 3, "read buffer"); + TEST_RESULT_UINT(ioRead(read, buffer), 3, "read buffer"); TEST_RESULT_STR_Z(strNewBuf(buffer), "DDD", " check buffer"); // Read line doesn't work without a linefeed @@ -422,16 +422,16 @@ testRun(void) // But those bytes can be picked up by a buffer read buffer = bufNew(2); - TEST_RESULT_INT(ioRead(read, buffer), 2, "read buffer"); + TEST_RESULT_UINT(ioRead(read, buffer), 2, "read buffer"); TEST_RESULT_STR_Z(strNewBuf(buffer), "EF", " check buffer"); buffer = bufNew(1); - TEST_RESULT_INT(ioRead(read, buffer), 1, "read buffer"); + TEST_RESULT_UINT(ioRead(read, buffer), 1, "read buffer"); TEST_RESULT_STR_Z(strNewBuf(buffer), "F", " check buffer"); // Nothing left to read TEST_ERROR(ioReadLine(read), FileReadError, "unexpected eof while reading line"); - TEST_RESULT_INT(ioRead(read, buffer), 0, "read buffer"); + TEST_RESULT_UINT(ioRead(read, buffer), 0, "read buffer"); // Error if buffer is full and there is no linefeed ioBufferSizeSet(10); diff --git a/test/src/module/common/ioTlsTest.c b/test/src/module/common/ioTlsTest.c index 7e933f955..acc46fdb9 100644 --- a/test/src/module/common/ioTlsTest.c +++ b/test/src/module/common/ioTlsTest.c @@ -225,12 +225,12 @@ testRun(void) TEST_RESULT_BOOL(ioReadEof(tlsClientIoRead(client)), false, " check eof = false"); Buffer *output = bufNew(12); - TEST_RESULT_INT(ioRead(tlsClientIoRead(client), output), 12, "read output"); + TEST_RESULT_UINT(ioRead(tlsClientIoRead(client), output), 12, "read output"); TEST_RESULT_STR_Z(strNewBuf(output), "some content", " check output"); TEST_RESULT_BOOL(ioReadEof(tlsClientIoRead(client)), false, " check eof = false"); output = bufNew(8); - TEST_RESULT_INT(ioRead(tlsClientIoRead(client), output), 8, "read output"); + TEST_RESULT_UINT(ioRead(tlsClientIoRead(client), output), 8, "read output"); TEST_RESULT_STR_Z(strNewBuf(output), "AND MORE", " check output"); TEST_RESULT_BOOL(ioReadEof(tlsClientIoRead(client)), false, " check eof = false"); @@ -246,12 +246,12 @@ testRun(void) ioWriteFlush(tlsClientIoWrite(client)); output = bufNew(12); - TEST_RESULT_INT(ioRead(tlsClientIoRead(client), output), 12, "read output"); + TEST_RESULT_UINT(ioRead(tlsClientIoRead(client), output), 12, "read output"); TEST_RESULT_STR_Z(strNewBuf(output), "0123456789AB", " check output"); TEST_RESULT_BOOL(ioReadEof(tlsClientIoRead(client)), false, " check eof = false"); output = bufNew(12); - TEST_RESULT_INT(ioRead(tlsClientIoRead(client), output), 0, "read no output after eof"); + TEST_RESULT_UINT(ioRead(tlsClientIoRead(client), output), 0, "read no output after eof"); TEST_RESULT_BOOL(ioReadEof(tlsClientIoRead(client)), true, " check eof = true"); // ------------------------------------------------------------------------------------------------------------------------- diff --git a/test/src/module/common/lockTest.c b/test/src/module/common/lockTest.c index 97e8d2bf4..fa2e80219 100644 --- a/test/src/module/common/lockTest.c +++ b/test/src/module/common/lockTest.c @@ -85,7 +85,7 @@ testRun(void) { HARNESS_FORK_CHILD_BEGIN(0, false) { - TEST_RESULT_BOOL(lockAcquireFile(backupLock, 0, true), true, "lock on fork"); + TEST_RESULT_INT_NE(lockAcquireFile(backupLock, 0, true), -1, "lock on fork"); sleepMSec(500); } HARNESS_FORK_CHILD_END(); diff --git a/test/src/module/common/regExpTest.c b/test/src/module/common/regExpTest.c index 8609cc0b8..57372e9ad 100644 --- a/test/src/module/common/regExpTest.c +++ b/test/src/module/common/regExpTest.c @@ -36,7 +36,7 @@ testRun(void) const String *string = STRDEF("abcdef"); TEST_RESULT_BOOL(regExpMatch(regExp, string), true, "match regexp"); TEST_RESULT_PTR(regExpMatchPtr(regExp), strPtr(string), "check ptr"); - TEST_RESULT_SIZE(regExpMatchSize(regExp), 3, "check size"); + TEST_RESULT_UINT(regExpMatchSize(regExp), 3, "check size"); TEST_RESULT_STR_Z(regExpMatchStr(regExp), "abc", "check str"); // ------------------------------------------------------------------------------------------------------------------------- @@ -44,7 +44,7 @@ testRun(void) TEST_RESULT_BOOL(regExpMatch(regExp, strNew("bcdef")), false, "no match regexp"); TEST_RESULT_PTR(regExpMatchPtr(regExp), NULL, "check ptr"); - TEST_RESULT_SIZE(regExpMatchSize(regExp), 0, "check size"); + TEST_RESULT_UINT(regExpMatchSize(regExp), 0, "check size"); TEST_RESULT_PTR(regExpMatchStr(regExp), NULL, "check str"); // ------------------------------------------------------------------------------------------------------------------------- diff --git a/test/src/module/common/stackTraceTest.c b/test/src/module/common/stackTraceTest.c index 8657a5a29..24022e1fa 100644 --- a/test/src/module/common/stackTraceTest.c +++ b/test/src/module/common/stackTraceTest.c @@ -16,11 +16,11 @@ testRun(void) { char buffer[8]; - TEST_RESULT_INT(stackTraceFmt(buffer, 8, 0, "%s", "1234567"), 7, "fill buffer"); + TEST_RESULT_UINT(stackTraceFmt(buffer, 8, 0, "%s", "1234567"), 7, "fill buffer"); TEST_RESULT_Z(buffer, "1234567", " check buffer"); - TEST_RESULT_INT(stackTraceFmt(buffer, 8, 7, "%s", "1234567"), 7, "try to fill buffer - at end"); + TEST_RESULT_UINT(stackTraceFmt(buffer, 8, 7, "%s", "1234567"), 7, "try to fill buffer - at end"); TEST_RESULT_Z(buffer, "1234567", " check buffer is unmodified"); - TEST_RESULT_INT(stackTraceFmt(buffer, 8, 8, "%s", "1234567"), 7, "try to fill buffer - past end"); + TEST_RESULT_UINT(stackTraceFmt(buffer, 8, 8, "%s", "1234567"), 7, "try to fill buffer - past end"); TEST_RESULT_Z(buffer, "1234567", " check buffer is unmodified"); } diff --git a/test/src/module/common/typeBufferTest.c b/test/src/module/common/typeBufferTest.c index 703b69bf9..ef9b66814 100644 --- a/test/src/module/common/typeBufferTest.c +++ b/test/src/module/common/typeBufferTest.c @@ -23,7 +23,7 @@ testRun(void) MEM_CONTEXT_TEMP_END(); TEST_RESULT_PTR(bufPtr(buffer), buffer->buffer, "buffer pointer"); - TEST_RESULT_INT(bufSize(buffer), 256, "buffer size"); + TEST_RESULT_UINT(bufSize(buffer), 256, "buffer size"); TEST_ASSIGN(buffer, bufNewC("TEST-STR", sizeof("TEST-STR") - 1), "new buffer from string"); TEST_RESULT_BOOL(memcmp(bufPtr(buffer), "TEST-STR", 8) == 0, true, "check buffer"); @@ -52,9 +52,9 @@ testRun(void) unsigned char *bufferPtr = NULL; TEST_ASSIGN(buffer, bufNew(0), "new zero buffer"); - TEST_RESULT_INT(bufSize(buffer), 0, "check size"); + TEST_RESULT_UINT(bufSize(buffer), 0, "check size"); TEST_RESULT_PTR(bufResize(buffer, 256), buffer, "resize buffer"); - TEST_RESULT_INT(bufSize(buffer), 256, "check size"); + TEST_RESULT_UINT(bufSize(buffer), 256, "check size"); TEST_RESULT_VOID(bufUsedSet(buffer, 256), "set used size"); TEST_RESULT_BOOL(bufFull(buffer), true, "check buffer full"); @@ -67,10 +67,10 @@ testRun(void) // Increase buffer size TEST_ASSIGN(bufferPtr, bufPtr(bufResize(buffer, 512)), "increase buffer size"); TEST_ASSIGN(bufferPtr, bufPtr(bufResize(buffer, 512)), "set to same size"); - TEST_RESULT_INT(bufSize(buffer), 512, "check size"); - TEST_RESULT_INT(bufUsed(buffer), 256, "check used size"); + TEST_RESULT_UINT(bufSize(buffer), 512, "check size"); + TEST_RESULT_UINT(bufUsed(buffer), 256, "check used size"); TEST_RESULT_BOOL(bufFull(buffer), false, "check buffer not full"); - TEST_RESULT_INT(bufRemains(buffer), 256, "check remaining buffer space"); + TEST_RESULT_UINT(bufRemains(buffer), 256, "check remaining buffer space"); TEST_RESULT_PTR(bufRemainsPtr(buffer), bufPtr(buffer) + 256, "check remaining buffer space pointer"); TEST_RESULT_VOID(bufUsedInc(buffer, 256), "set used size"); TEST_RESULT_BOOL(bufFull(buffer), true, "check buffer full"); @@ -85,7 +85,7 @@ testRun(void) // Decrease buffer size TEST_ASSIGN(bufferPtr, bufPtr(bufResize(buffer, 128)), "decrease buffer size"); - TEST_RESULT_INT(bufSize(buffer), 128, "check size"); + TEST_RESULT_UINT(bufSize(buffer), 128, "check size"); // Test that no bytes have changed in the original data sameTotal = 0; @@ -97,22 +97,22 @@ testRun(void) // Use limits to change size reporting TEST_RESULT_VOID(bufLimitSet(buffer, 64), "set limit"); - TEST_RESULT_INT(bufSize(buffer), 64, " check limited size"); + TEST_RESULT_UINT(bufSize(buffer), 64, " check limited size"); TEST_RESULT_VOID(bufLimitClear(buffer), " clear limit"); - TEST_RESULT_INT(bufSize(buffer), 128, " check unlimited size"); + TEST_RESULT_UINT(bufSize(buffer), 128, " check unlimited size"); // Resize to zero buffer TEST_RESULT_VOID(bufUsedZero(buffer), "set used to 0"); - TEST_RESULT_INT(bufUsed(buffer), 0, "check used is zero"); + TEST_RESULT_UINT(bufUsed(buffer), 0, "check used is zero"); TEST_RESULT_VOID(bufLimitSet(buffer, 64), "set limit to make sure it gets reduced with the resize"); TEST_RESULT_VOID(bufResize(buffer, 32), "decrease size to 32"); - TEST_RESULT_INT(bufSize(buffer), 32, "check size"); + TEST_RESULT_UINT(bufSize(buffer), 32, "check size"); TEST_RESULT_VOID(bufLimitSet(buffer, 0), "set limit so that it won't need to be resized"); TEST_RESULT_VOID(bufResize(buffer, 0), "decrease size to zero"); - TEST_RESULT_INT(bufSize(buffer), 0, "check size"); + TEST_RESULT_UINT(bufSize(buffer), 0, "check size"); TEST_RESULT_VOID(bufResize(buffer, 0), "decrease size to zero again"); - TEST_RESULT_INT(bufSize(buffer), 0, "check size"); + TEST_RESULT_UINT(bufSize(buffer), 0, "check size"); } // ***************************************************************************************************************************** diff --git a/test/src/module/common/typeConvertTest.c b/test/src/module/common/typeConvertTest.c index a0e08220d..6d94b1bd9 100644 --- a/test/src/module/common/typeConvertTest.c +++ b/test/src/module/common/typeConvertTest.c @@ -18,9 +18,9 @@ testRun(void) TEST_ERROR(cvtBoolToZ(true, buffer, 4), AssertError, "buffer overflow"); - TEST_RESULT_INT(cvtBoolToZ(true, buffer, STACK_TRACE_PARAM_MAX), 4, "convert true bool to string"); + TEST_RESULT_UINT(cvtBoolToZ(true, buffer, STACK_TRACE_PARAM_MAX), 4, "convert true bool to string"); TEST_RESULT_Z(buffer, "true", " check buffer"); - TEST_RESULT_INT(cvtBoolToZ(false, buffer, STACK_TRACE_PARAM_MAX), 5, "convert false bool to string"); + TEST_RESULT_UINT(cvtBoolToZ(false, buffer, STACK_TRACE_PARAM_MAX), 5, "convert false bool to string"); TEST_RESULT_Z(buffer, "false", " check buffer"); } @@ -31,7 +31,7 @@ testRun(void) TEST_ERROR(cvtCharToZ('A', buffer, 1), AssertError, "buffer overflow"); - TEST_RESULT_INT(cvtCharToZ('C', buffer, STACK_TRACE_PARAM_MAX), 1, "convert char to string"); + TEST_RESULT_UINT(cvtCharToZ('C', buffer, STACK_TRACE_PARAM_MAX), 1, "convert char to string"); TEST_RESULT_Z(buffer, "C", " check buffer"); } @@ -42,13 +42,13 @@ testRun(void) TEST_ERROR(cvtDoubleToZ(999.1234, buffer, 4), AssertError, "buffer overflow"); - TEST_RESULT_INT(cvtDoubleToZ(999.1234, buffer, STACK_TRACE_PARAM_MAX), 8, "convert double to string"); + TEST_RESULT_UINT(cvtDoubleToZ(999.1234, buffer, STACK_TRACE_PARAM_MAX), 8, "convert double to string"); TEST_RESULT_Z(buffer, "999.1234", " check buffer"); - TEST_RESULT_INT(cvtDoubleToZ(999999999.123456, buffer, STACK_TRACE_PARAM_MAX), 16, "convert double to string"); + TEST_RESULT_UINT(cvtDoubleToZ(999999999.123456, buffer, STACK_TRACE_PARAM_MAX), 16, "convert double to string"); TEST_RESULT_Z(buffer, "999999999.123456", " check buffer"); - TEST_RESULT_INT(cvtDoubleToZ(999.0, buffer, STACK_TRACE_PARAM_MAX), 3, "convert double to string"); + TEST_RESULT_UINT(cvtDoubleToZ(999.0, buffer, STACK_TRACE_PARAM_MAX), 3, "convert double to string"); TEST_RESULT_Z(buffer, "999", " check buffer"); TEST_ERROR(cvtZToDouble("AAA"), FormatError, "unable to convert string 'AAA' to double"); @@ -64,7 +64,7 @@ testRun(void) TEST_ERROR(cvtIntToZ(9999, buffer, 4), AssertError, "buffer overflow"); - TEST_RESULT_INT(cvtIntToZ(1234567890, buffer, STACK_TRACE_PARAM_MAX), 10, "convert int to string"); + TEST_RESULT_UINT(cvtIntToZ(1234567890, buffer, STACK_TRACE_PARAM_MAX), 10, "convert int to string"); TEST_RESULT_Z(buffer, "1234567890", " check buffer"); TEST_ERROR(cvtZToInt("FEF"), FormatError, "unable to convert base 10 string 'FEF' to int"); @@ -85,7 +85,7 @@ testRun(void) TEST_ERROR(cvtModeToZ(0750, buffer, 4), AssertError, "buffer overflow"); - TEST_RESULT_INT(cvtModeToZ(0777, buffer, STACK_TRACE_PARAM_MAX), 4, "convert mode to string"); + TEST_RESULT_UINT(cvtModeToZ(0777, buffer, STACK_TRACE_PARAM_MAX), 4, "convert mode to string"); TEST_RESULT_Z(buffer, "0777", " check buffer"); TEST_RESULT_UINT(cvtZToMode("0700"), 0700, "convert string to mode"); @@ -104,7 +104,7 @@ testRun(void) // ------------------------------------------------------------------------------------------------------------------------ TEST_ERROR(cvtSSizeToZ(-9999, buffer, 4), AssertError, "buffer overflow"); - TEST_RESULT_INT(cvtSSizeToZ(-9999, buffer, STACK_TRACE_PARAM_MAX), 5, "convert ssize to string"); + TEST_RESULT_UINT(cvtSSizeToZ(-9999, buffer, STACK_TRACE_PARAM_MAX), 5, "convert ssize to string"); TEST_RESULT_Z(buffer, "-9999", " check buffer"); } @@ -126,7 +126,7 @@ testRun(void) TEST_ERROR(cvtUIntToZ(9999, buffer, 4), AssertError, "buffer overflow"); - TEST_RESULT_INT(cvtUIntToZ(4294967295, buffer, STACK_TRACE_PARAM_MAX), 10, "convert unsigned int to string"); + TEST_RESULT_UINT(cvtUIntToZ(4294967295, buffer, STACK_TRACE_PARAM_MAX), 10, "convert unsigned int to string"); TEST_RESULT_Z(buffer, "4294967295", " check buffer"); TEST_ERROR(cvtZToUInt("-1"), FormatError, "unable to convert base 10 string '-1' to unsigned int"); @@ -143,7 +143,7 @@ testRun(void) TEST_ERROR(cvtInt64ToZ(9999, buffer, 4), AssertError, "buffer overflow"); - TEST_RESULT_INT(cvtInt64ToZ(9223372036854775807, buffer, STACK_TRACE_PARAM_MAX), 19, "convert int64 to string"); + TEST_RESULT_UINT(cvtInt64ToZ(9223372036854775807, buffer, STACK_TRACE_PARAM_MAX), 19, "convert int64 to string"); TEST_RESULT_Z(buffer, "9223372036854775807", " check buffer"); TEST_ERROR(cvtZToInt64("123INV"), FormatError, "unable to convert base 10 string '123INV' to int64"); @@ -168,7 +168,7 @@ testRun(void) TEST_ERROR(cvtUInt64ToZ(9999, buffer, 4), AssertError, "buffer overflow"); - TEST_RESULT_INT(cvtUInt64ToZ(0xFFFFFFFFFFFFFFFF, buffer, STACK_TRACE_PARAM_MAX), 20, "convert uint64 to string"); + TEST_RESULT_UINT(cvtUInt64ToZ(0xFFFFFFFFFFFFFFFF, buffer, STACK_TRACE_PARAM_MAX), 20, "convert uint64 to string"); TEST_RESULT_Z(buffer, "18446744073709551615", " check buffer"); TEST_ERROR(cvtZToUInt64("FEF"), FormatError, "unable to convert base 10 string 'FEF' to uint64"); @@ -177,7 +177,7 @@ testRun(void) TEST_ERROR(cvtZToUInt64("-1"), FormatError, "unable to convert base 10 string '-1' to uint64"); TEST_RESULT_UINT(cvtZToUInt64Base("FF", 16), 255, "convert string to uint64"); - TEST_RESULT_DOUBLE(cvtZToUInt64("18446744073709551615"), 18446744073709551615U, "convert string to uint64"); + TEST_RESULT_UINT(cvtZToUInt64("18446744073709551615"), 18446744073709551615U, "convert string to uint64"); } FUNCTION_HARNESS_RESULT_VOID(); diff --git a/test/src/module/common/typeJsonTest.c b/test/src/module/common/typeJsonTest.c index 755edeff0..fe2cd3bde 100644 --- a/test/src/module/common/typeJsonTest.c +++ b/test/src/module/common/typeJsonTest.c @@ -93,7 +93,7 @@ testRun(void) VariantList *valueList = NULL; TEST_ASSIGN(valueList, varVarLst(jsonToVar(strNew("[1, \"test\", false]"))), "array"); TEST_RESULT_UINT(varLstSize(valueList), 3, "check array size"); - TEST_RESULT_INT(varUInt64(varLstGet(valueList, 0)), 1, "check array int"); + TEST_RESULT_UINT(varUInt64(varLstGet(valueList, 0)), 1, "check array int"); TEST_RESULT_STR_Z(varStr(varLstGet(valueList, 1)), "test", "check array str"); TEST_RESULT_BOOL(varBool(varLstGet(valueList, 2)), false, "check array bool"); diff --git a/test/src/module/common/typeListTest.c b/test/src/module/common/typeListTest.c index dd2bb775f..8da8b31bf 100644 --- a/test/src/module/common/typeListTest.c +++ b/test/src/module/common/typeListTest.c @@ -34,9 +34,9 @@ testRun(void) { List *list = lstNew(sizeof(void *)); - TEST_RESULT_INT(list->itemSize, sizeof(void *), "item size"); - TEST_RESULT_INT(list->listSize, 0, "list size"); - TEST_RESULT_INT(list->listSizeMax, 0, "list size max"); + TEST_RESULT_UINT(list->itemSize, sizeof(void *), "item size"); + TEST_RESULT_UINT(list->listSize, 0, "list size"); + TEST_RESULT_UINT(list->listSizeMax, 0, "list size max"); TEST_RESULT_PTR(lstMemContext(list), list->memContext, "list mem context"); TEST_RESULT_VOID(lstClear(list), "clear list"); diff --git a/test/src/module/common/typeStringTest.c b/test/src/module/common/typeStringTest.c index ab70caf52..ce9ae50ed 100644 --- a/test/src/module/common/typeStringTest.c +++ b/test/src/module/common/typeStringTest.c @@ -27,10 +27,10 @@ testRun(void) String *string = strNew("static string"); TEST_RESULT_STR_Z(string, "static string", "new with static string"); - TEST_RESULT_INT(strSize(string), 13, "check size"); + TEST_RESULT_UINT(strSize(string), 13, "check size"); TEST_RESULT_BOOL(strEmpty(string), false, "is not empty"); - TEST_RESULT_INT(strlen(strPtr(string)), 13, "check size with strlen()"); - TEST_RESULT_CHAR(strPtr(string)[2], 'a', "check character"); + TEST_RESULT_UINT(strlen(strPtr(string)), 13, "check size with strlen()"); + TEST_RESULT_INT(strPtr(string)[2], 'a', "check character"); TEST_RESULT_VOID(strFree(string), "free string"); @@ -93,11 +93,11 @@ testRun(void) String *string2 = strNew("ZZZZ"); TEST_RESULT_STR_Z(strCat(string, "YYYY"), "XXXXYYYY", "cat string"); - TEST_RESULT_SIZE(string->extra, 4, "check extra"); + TEST_RESULT_UINT(string->extra, 4, "check extra"); TEST_RESULT_STR_Z(strCatFmt(string, "%05d", 777), "XXXXYYYY00777", "cat formatted string"); - TEST_RESULT_SIZE(string->extra, 6, "check extra"); + TEST_RESULT_UINT(string->extra, 6, "check extra"); TEST_RESULT_STR_Z(strCatChr(string, '!'), "XXXXYYYY00777!", "cat chr"); - TEST_RESULT_SIZE(string->extra, 5, "check extra"); + TEST_RESULT_UINT(string->extra, 5, "check extra"); TEST_RESULT_STR_Z(string2, "ZZZZ", "check unaltered string"); } @@ -232,7 +232,7 @@ testRun(void) TEST_RESULT_STR_Z(strTrunc(val, strChr(val, 'n')), "abc\r\n to e", "complex string truncated"); TEST_RESULT_STR_Z(strTrunc(val, strChr(val, 'a')), "", "complete string truncated - empty string"); - TEST_RESULT_INT(strSize(val), 0, "0 size"); + TEST_RESULT_UINT(strSize(val), 0, "0 size"); TEST_RESULT_STR_Z(strTrunc(val, 0), "", "test coverage of empty string - no error thrown for index 0"); } @@ -292,7 +292,7 @@ testRun(void) } MEM_CONTEXT_TEMP_END(); - TEST_RESULT_INT(strLstSize(list), 9, "list size"); + TEST_RESULT_UINT(strLstSize(list), 9, "list size"); // Read them back and check values // ------------------------------------------------------------------------------------------------------------------------- diff --git a/test/src/module/common/typeVariantTest.c b/test/src/module/common/typeVariantTest.c index 555e3c785..174594f94 100644 --- a/test/src/module/common/typeVariantTest.c +++ b/test/src/module/common/typeVariantTest.c @@ -71,7 +71,7 @@ testRun(void) TEST_RESULT_DOUBLE(varDblForce(varNewBool(false)), 0, "force bool to double"); TEST_RESULT_DOUBLE(varDblForce(VARINT(123)), 123, "force int to double"); TEST_RESULT_DOUBLE(varDblForce(VARINT64(999999999999)), 999999999999, "force int64 to double"); - TEST_RESULT_DOUBLE(varDblForce(VARUINT64(9223372036854775807U)), 9223372036854775807U, "force uint64 to double"); + TEST_RESULT_DOUBLE(varDblForce(VARUINT64(9223372036854775807U)), 9223372036854775807.0, "force uint64 to double"); TEST_RESULT_DOUBLE(varDblForce(VARUINT(992)), 992, "force uint to double"); TEST_RESULT_DOUBLE(varDblForce(VARSTRDEF("879.01")), 879.01, "force String to double"); TEST_RESULT_DOUBLE(varDblForce(VARSTRDEF("0")), 0, "force String to double"); @@ -219,17 +219,17 @@ testRun(void) // ------------------------------------------------------------------------------------------------------------------------- Variant *uint64 = varNewUInt64(44); - TEST_RESULT_DOUBLE(varUInt64(uint64), 44, "uint64 variant"); - TEST_RESULT_DOUBLE(varUInt64Force(uint64), 44, "force uint64 to uint64"); + TEST_RESULT_UINT(varUInt64(uint64), 44, "uint64 variant"); + TEST_RESULT_UINT(varUInt64Force(uint64), 44, "force uint64 to uint64"); varFree(uint64); // ------------------------------------------------------------------------------------------------------------------------- - TEST_RESULT_DOUBLE(varUInt64Force(varNewBool(true)), 1, "force bool to uint64"); - TEST_RESULT_DOUBLE(varUInt64Force(VARINT(2147483647)), 2147483647, "force int to uint64"); - TEST_RESULT_INT(varUInt64Force(VARUINT(4294967295)), 4294967295, "force uint to uint64"); - TEST_RESULT_DOUBLE(varUInt64Force(VARINT64(2147483647)), 2147483647, "force int64 to uint64"); - TEST_RESULT_DOUBLE(varUInt64Force(varNewStrZ("18446744073709551615")), 18446744073709551615U, "force str to uint64"); - TEST_RESULT_DOUBLE(varUInt64Force(VARUINT64(18446744073709551615U)), 18446744073709551615U, "force uint64 to uint64"); + TEST_RESULT_UINT(varUInt64Force(varNewBool(true)), 1, "force bool to uint64"); + TEST_RESULT_UINT(varUInt64Force(VARINT(2147483647)), 2147483647, "force int to uint64"); + TEST_RESULT_UINT(varUInt64Force(VARUINT(4294967295)), 4294967295, "force uint to uint64"); + TEST_RESULT_UINT(varUInt64Force(VARINT64(2147483647)), 2147483647, "force int64 to uint64"); + TEST_RESULT_UINT(varUInt64Force(varNewStrZ("18446744073709551615")), 18446744073709551615U, "force str to uint64"); + TEST_RESULT_UINT(varUInt64Force(VARUINT64(18446744073709551615U)), 18446744073709551615U, "force uint64 to uint64"); TEST_ERROR( varUInt64Force(varNewStrZ("18446744073709551616")), FormatError, @@ -243,7 +243,7 @@ testRun(void) TEST_ERROR(varUInt64(varNewStrZ("string")), AssertError, "assertion 'this->type == varTypeUInt64' failed"); // ------------------------------------------------------------------------------------------------------------------------- - TEST_RESULT_DOUBLE(varUInt64(varDup(VARUINT64(88976))), 88976, "dup uint64"); + TEST_RESULT_UINT(varUInt64(varDup(VARUINT64(88976))), 88976, "dup uint64"); // ------------------------------------------------------------------------------------------------------------------------- TEST_RESULT_BOOL(varEq(NULL, NULL), true, "null, null eq"); diff --git a/test/src/module/common/waitTest.c b/test/src/module/common/waitTest.c index be62c969f..573cc2264 100644 --- a/test/src/module/common/waitTest.c +++ b/test/src/module/common/waitTest.c @@ -22,9 +22,9 @@ testRun(void) TimeMSec begin = timeMSec(); TEST_ASSIGN(wait, waitNew(200), "new wait = 0.2 sec"); - TEST_RESULT_DOUBLE(wait->waitTime, 200, " check wait time"); - TEST_RESULT_DOUBLE(wait->sleepTime, 20, " check sleep time"); - TEST_RESULT_DOUBLE(wait->sleepPrevTime, 0, " check sleep prev time"); + TEST_RESULT_UINT(wait->waitTime, 200, " check wait time"); + TEST_RESULT_UINT(wait->sleepTime, 20, " check sleep time"); + TEST_RESULT_UINT(wait->sleepPrevTime, 0, " check sleep prev time"); TEST_RESULT_BOOL(wait->beginTime > (TimeMSec)1483228800000, true, " check begin time"); while (waitMore(wait)); @@ -40,9 +40,9 @@ testRun(void) begin = timeMSec(); TEST_ASSIGN(wait, waitNew(1100), "new wait = 1.1 sec"); - TEST_RESULT_DOUBLE(wait->waitTime, 1100, " check wait time"); - TEST_RESULT_DOUBLE(wait->sleepTime, 100, " check sleep time"); - TEST_RESULT_DOUBLE(wait->sleepPrevTime, 0, " check sleep prev time"); + TEST_RESULT_UINT(wait->waitTime, 1100, " check wait time"); + TEST_RESULT_UINT(wait->sleepTime, 100, " check sleep time"); + TEST_RESULT_UINT(wait->sleepPrevTime, 0, " check sleep prev time"); TEST_RESULT_BOOL(wait->beginTime > (TimeMSec)1483228800000, true, " check begin time"); while (waitMore(wait)); diff --git a/test/src/module/config/configTest.c b/test/src/module/config/configTest.c index 14f6e6d70..a0bf8cd48 100644 --- a/test/src/module/config/configTest.c +++ b/test/src/module/config/configTest.c @@ -170,7 +170,7 @@ testRun(void) TEST_RESULT_VOID( cfgOptionSet(cfgOptArchivePushQueueMax, cfgSourceParam, varNewInt64(999999999999)), "set archive-push-queue-max"); TEST_RESULT_INT(cfgOptionInt64(cfgOptArchivePushQueueMax), 999999999999, "archive-push-queue-max is set"); - TEST_RESULT_INT(cfgOptionUInt64(cfgOptArchivePushQueueMax), 999999999999, "archive-push-queue-max is set"); + TEST_RESULT_UINT(cfgOptionUInt64(cfgOptArchivePushQueueMax), 999999999999, "archive-push-queue-max is set"); TEST_RESULT_VOID(cfgOptionSet(cfgOptProtocolTimeout, cfgSourceParam, varNewDbl(1.1)), "set protocol-timeout"); TEST_RESULT_DOUBLE(cfgOptionDbl(cfgOptProtocolTimeout), 1.1, "protocol-timeout is set"); diff --git a/test/src/module/config/loadTest.c b/test/src/module/config/loadTest.c index e3ac70599..050a02e70 100644 --- a/test/src/module/config/loadTest.c +++ b/test/src/module/config/loadTest.c @@ -400,7 +400,7 @@ testRun(void) ioBufferSizeSet(333); TEST_RESULT_VOID(cfgLoad(strLstSize(argList), strLstPtr(argList)), "help command"); - TEST_RESULT_SIZE(ioBufferSize(), 333, "buffer size not updated by help command"); + TEST_RESULT_UINT(ioBufferSize(), 333, "buffer size not updated by help command"); // Help command for backup // ------------------------------------------------------------------------------------------------------------------------- @@ -414,7 +414,7 @@ testRun(void) strLstAdd(argList, strNew("--repo1-retention-full=2")); TEST_RESULT_VOID(cfgLoad(strLstSize(argList), strLstPtr(argList)), "help command for backup"); - TEST_RESULT_SIZE(ioBufferSize(), 4 * 1024 * 1024, "buffer size set to option default"); + TEST_RESULT_UINT(ioBufferSize(), 4 * 1024 * 1024, "buffer size set to option default"); // Command takes lock and opens log file // ------------------------------------------------------------------------------------------------------------------------- diff --git a/test/src/module/config/parseTest.c b/test/src/module/config/parseTest.c index 397f57beb..c770d9b12 100644 --- a/test/src/module/config/parseTest.c +++ b/test/src/module/config/parseTest.c @@ -121,7 +121,7 @@ testRun(void) TEST_RESULT_INT(cfgOptionSource(cfgOptCompressLevel), cfgSourceConfig, " compress-level is source config"); TEST_RESULT_BOOL(cfgOptionBool(cfgOptBackupStandby), false, " backup-standby not is set"); TEST_RESULT_INT(cfgOptionSource(cfgOptBackupStandby), cfgSourceDefault, " backup-standby is source default"); - TEST_RESULT_BOOL(cfgOptionInt64(cfgOptBufferSize), 65536, " buffer-size is set"); + TEST_RESULT_INT(cfgOptionInt64(cfgOptBufferSize), 65536, " buffer-size is set"); TEST_RESULT_INT(cfgOptionSource(cfgOptBufferSize), cfgSourceConfig, " backup-standby is source config"); // Rename conf files - ensure read of conf extension only is attempted @@ -1263,7 +1263,7 @@ testRun(void) TEST_RESULT_INT(cfgOptionSource(cfgOptBackupStandby), cfgSourceDefault, " backup-standby is source default"); TEST_RESULT_BOOL(cfgOptionBool(cfgOptDelta), true, " delta is set"); TEST_RESULT_INT(cfgOptionSource(cfgOptDelta), cfgSourceConfig, " delta is source config"); - TEST_RESULT_BOOL(cfgOptionInt64(cfgOptBufferSize), 65536, " buffer-size is set"); + TEST_RESULT_INT(cfgOptionInt64(cfgOptBufferSize), 65536, " buffer-size is set"); TEST_RESULT_INT(cfgOptionSource(cfgOptBufferSize), cfgSourceConfig, " backup-standby is source config"); unsetenv("PGBACKREST_BOGUS"); diff --git a/test/src/module/info/infoArchiveTest.c b/test/src/module/info/infoArchiveTest.c index 9cb1ba331..3bb5a1690 100644 --- a/test/src/module/info/infoArchiveTest.c +++ b/test/src/module/info/infoArchiveTest.c @@ -86,7 +86,7 @@ testRun(void) TEST_RESULT_INT(infoPgDataTotal(info->infoPg), 2, " history incremented"); TEST_ASSIGN(infoPgData, infoPgDataCurrent(info->infoPg), " get current infoPgData"); TEST_RESULT_INT(infoPgData.version, PG_VERSION_94, " version set"); - TEST_RESULT_INT(infoPgData.systemId, 6569239123849665679, " systemId set"); + TEST_RESULT_UINT(infoPgData.systemId, 6569239123849665679, " systemId set"); // Free // ------------------------------------------------------------------------------------------------------------------------- diff --git a/test/src/module/info/infoBackupTest.c b/test/src/module/info/infoBackupTest.c index b210eb86c..d4e66854b 100644 --- a/test/src/module/info/infoBackupTest.c +++ b/test/src/module/info/infoBackupTest.c @@ -90,7 +90,7 @@ testRun(void) TEST_RESULT_INT(infoPgDataTotal(infoBackup->infoPg), 2, " history incremented"); TEST_ASSIGN(infoPgData, infoPgDataCurrent(infoBackup->infoPg), " get current infoPgData"); TEST_RESULT_INT(infoPgData.version, PG_VERSION_94, " version set"); - TEST_RESULT_INT(infoPgData.systemId, 6569239123849665679, " systemId set"); + TEST_RESULT_UINT(infoPgData.systemId, 6569239123849665679, " systemId set"); // Free //-------------------------------------------------------------------------------------------------------------------------- @@ -146,10 +146,10 @@ testRun(void) TEST_RESULT_STR_Z(backupData.backrestVersion, "2.04", " backrest version"); TEST_RESULT_STR_Z(backupData.backupArchiveStart, "00000007000000000000001C", " archive start"); TEST_RESULT_STR_Z(backupData.backupArchiveStop, "00000007000000000000001C", " archive stop"); - TEST_RESULT_INT(backupData.backupInfoRepoSize, 3159776, " repo size"); - TEST_RESULT_INT(backupData.backupInfoRepoSizeDelta, 3159776, " repo delta"); - TEST_RESULT_INT(backupData.backupInfoSize, 26897030, " backup size"); - TEST_RESULT_INT(backupData.backupInfoSizeDelta, 26897030, " backup delta"); + TEST_RESULT_UINT(backupData.backupInfoRepoSize, 3159776, " repo size"); + TEST_RESULT_UINT(backupData.backupInfoRepoSizeDelta, 3159776, " repo delta"); + TEST_RESULT_UINT(backupData.backupInfoSize, 26897030, " backup size"); + TEST_RESULT_UINT(backupData.backupInfoSizeDelta, 26897030, " backup delta"); TEST_RESULT_INT(backupData.backupPgId, 1, " pg id"); TEST_RESULT_PTR(backupData.backupPrior, NULL, " backup prior NULL"); TEST_RESULT_PTR(backupData.backupReference, NULL, " backup reference NULL"); @@ -159,10 +159,10 @@ testRun(void) backupData = infoBackupData(infoBackup, 1); TEST_RESULT_STR_Z(backupData.backupLabel, "20161219-212741F_20161219-212803D", "diff backup label"); TEST_RESULT_STR_Z(backupData.backupType, "diff", " backup type diff"); - TEST_RESULT_INT(backupData.backupInfoRepoSize, 3159811, " repo size"); - TEST_RESULT_INT(backupData.backupInfoRepoSizeDelta, 15765, " repo delta"); - TEST_RESULT_INT(backupData.backupInfoSize, 26897030, " backup size"); - TEST_RESULT_INT(backupData.backupInfoSizeDelta, 163866, " backup delta"); + TEST_RESULT_UINT(backupData.backupInfoRepoSize, 3159811, " repo size"); + TEST_RESULT_UINT(backupData.backupInfoRepoSizeDelta, 15765, " repo delta"); + TEST_RESULT_UINT(backupData.backupInfoSize, 26897030, " backup size"); + TEST_RESULT_UINT(backupData.backupInfoSizeDelta, 163866, " backup delta"); TEST_RESULT_STR_Z(backupData.backupPrior, "20161219-212741F", " backup prior exists"); TEST_RESULT_BOOL( (strLstSize(backupData.backupReference) == 1 && strLstExistsZ(backupData.backupReference, "20161219-212741F")), true, diff --git a/test/src/module/info/infoPgTest.c b/test/src/module/info/infoPgTest.c index c03e7bb1c..f5b914a5b 100644 --- a/test/src/module/info/infoPgTest.c +++ b/test/src/module/info/infoPgTest.c @@ -53,8 +53,8 @@ testRun(void) TEST_RESULT_INT(infoPgDataCurrentId(infoPg), 0, " 0 historyCurrent"); InfoPgData pgData = infoPgData(infoPg, infoPgDataCurrentId(infoPg)); TEST_RESULT_INT(pgData.id, 1, " id set"); - TEST_RESULT_INT(pgData.systemId, 6569239123849665679, " system-id set"); - TEST_RESULT_INT(pgData.version, PG_VERSION_94, " version set"); + TEST_RESULT_UINT(pgData.systemId, 6569239123849665679, " system-id set"); + TEST_RESULT_UINT(pgData.version, PG_VERSION_94, " version set"); TEST_ASSIGN( infoPg, infoPgSet(infoPg, infoPgArchive, PG_VERSION_95, 6569239123849665999), "infoPgSet - infoPgArchive second db"); @@ -62,8 +62,8 @@ testRun(void) TEST_RESULT_INT(infoPgDataCurrentId(infoPg), 0, " 0 historyCurrent"); pgData = infoPgData(infoPg, infoPgDataCurrentId(infoPg)); TEST_RESULT_INT(pgData.id, 2, " current id updated"); - TEST_RESULT_INT(pgData.systemId, 6569239123849665999, " system-id updated"); - TEST_RESULT_INT(pgData.version, PG_VERSION_95, " version updated"); + TEST_RESULT_UINT(pgData.systemId, 6569239123849665999, " system-id updated"); + TEST_RESULT_UINT(pgData.version, PG_VERSION_95, " version updated"); TEST_RESULT_STR(infoCipherPass(infoPgInfo(infoPg)), NULL, " cipherPass not set"); //-------------------------------------------------------------------------------------------------------------------------- @@ -74,8 +74,8 @@ testRun(void) TEST_RESULT_INT(infoPgDataCurrentId(infoPg), 0, " 0 historyCurrent"); pgData = infoPgData(infoPg, infoPgDataCurrentId(infoPg)); TEST_RESULT_INT(pgData.id, 1, " id set"); - TEST_RESULT_INT(pgData.systemId, 6569239123849665679, " system-id set"); - TEST_RESULT_INT(pgData.version, PG_VERSION_94, " version set"); + TEST_RESULT_UINT(pgData.systemId, 6569239123849665679, " system-id set"); + TEST_RESULT_UINT(pgData.version, PG_VERSION_94, " version set"); TEST_RESULT_STR_Z(infoCipherPass(infoPgInfo(infoPg)), "123xyz", " cipherPass set"); } @@ -118,8 +118,8 @@ testRun(void) InfoPgData pgData = infoPgDataCurrent(infoPg); TEST_RESULT_INT(pgData.id, 1, " id set"); - TEST_RESULT_INT(pgData.version, PG_VERSION_94, " version set"); - TEST_RESULT_INT(pgData.systemId, 6569239123849665679, " system-id set"); + TEST_RESULT_UINT(pgData.version, PG_VERSION_94, " version set"); + TEST_RESULT_UINT(pgData.systemId, 6569239123849665679, " system-id set"); TEST_RESULT_INT(infoPgDataTotal(infoPg), 1, " check pg data total"); TEST_RESULT_STR_Z(infoPgArchiveId(infoPg, 0), "9.4-1", " check pg archive id"); TEST_RESULT_PTR(infoPgCipherPass(infoPg), NULL, " no cipher passphrase"); @@ -164,12 +164,12 @@ testRun(void) pgData = infoPgDataCurrent(infoPg); TEST_RESULT_INT(pgData.id, 2, " id set"); TEST_RESULT_INT(pgData.version, PG_VERSION_95, " version set"); - TEST_RESULT_INT(pgData.systemId, 6365925855999999999, " system-id set"); + TEST_RESULT_UINT(pgData.systemId, 6365925855999999999, " system-id set"); pgData = infoPgData(infoPg, 1); TEST_RESULT_INT(pgData.id, 1, " id set"); TEST_RESULT_INT(pgData.version, PG_VERSION_94, " version set"); - TEST_RESULT_INT(pgData.systemId, 6569239123849665679, " system-id set"); + TEST_RESULT_UINT(pgData.systemId, 6569239123849665679, " system-id set"); contentSave = bufNew(0); @@ -186,7 +186,7 @@ testRun(void) InfoPgData pgDataTest = infoPgDataCurrent(infoPg); TEST_RESULT_INT(pgDataTest.id, 3, " id set"); TEST_RESULT_INT(pgDataTest.version, PG_VERSION_96, " version set"); - TEST_RESULT_INT(pgDataTest.systemId, 6399999999999999999, " system-id set"); + TEST_RESULT_UINT(pgDataTest.systemId, 6399999999999999999, " system-id set"); // infoPgDataToLog //-------------------------------------------------------------------------------------------------------------------------- diff --git a/test/src/module/info/manifestTest.c b/test/src/module/info/manifestTest.c index ab23f0e22..c13e1ea07 100644 --- a/test/src/module/info/manifestTest.c +++ b/test/src/module/info/manifestTest.c @@ -1174,7 +1174,7 @@ testRun(void) manifest->data.backupOptionOnline = true; TEST_RESULT_VOID(manifestBuildValidate(manifest, true, 1482182860, false), "validate manifest"); - TEST_RESULT_UINT(manifest->data.backupTimestampCopyStart, 1482182861, "check copy start"); + TEST_RESULT_INT(manifest->data.backupTimestampCopyStart, 1482182861, "check copy start"); TEST_RESULT_BOOL(varBool(manifest->data.backupOptionDelta), true, "check delta"); TEST_RESULT_UINT(manifest->data.backupOptionCompressType, compressTypeNone, "check compress"); @@ -1188,14 +1188,14 @@ testRun(void) &(ManifestFile){.name = STRDEF(MANIFEST_TARGET_PGDATA "/" PG_FILE_PGVERSION), .size = 4, .timestamp = 1482182860}); TEST_RESULT_VOID(manifestBuildValidate(manifest, false, 1482182860, false), "validate manifest"); - TEST_RESULT_UINT(manifest->data.backupTimestampCopyStart, 1482182860, "check copy start"); + TEST_RESULT_INT(manifest->data.backupTimestampCopyStart, 1482182860, "check copy start"); TEST_RESULT_BOOL(varBool(manifest->data.backupOptionDelta), false, "check delta"); // ------------------------------------------------------------------------------------------------------------------------- TEST_TITLE("timestamp in future forces delta"); TEST_RESULT_VOID(manifestBuildValidate(manifest, false, 1482182859, true), "validate manifest"); - TEST_RESULT_UINT(manifest->data.backupTimestampCopyStart, 1482182859, "check copy start"); + TEST_RESULT_INT(manifest->data.backupTimestampCopyStart, 1482182859, "check copy start"); TEST_RESULT_BOOL(varBool(manifest->data.backupOptionDelta), true, "check delta"); TEST_RESULT_UINT(manifest->data.backupOptionCompressType, compressTypeGz, "check compress"); diff --git a/test/src/module/postgres/interfaceTest.c b/test/src/module/postgres/interfaceTest.c index 3d3a16805..2a316c6ba 100644 --- a/test/src/module/postgres/interfaceTest.c +++ b/test/src/module/postgres/interfaceTest.c @@ -77,8 +77,8 @@ testRun(void) PgControl info = {0}; TEST_ASSIGN(info, pgControlFromFile(storageTest), "get control info v11"); - TEST_RESULT_INT(info.systemId, 0xFACEFACE, " check system id"); - TEST_RESULT_INT(info.version, PG_VERSION_11, " check version"); + TEST_RESULT_UINT(info.systemId, 0xFACEFACE, " check system id"); + TEST_RESULT_UINT(info.version, PG_VERSION_11, " check version"); //-------------------------------------------------------------------------------------------------------------------------- storagePutP( @@ -101,8 +101,8 @@ testRun(void) pgControlTestToBuffer((PgControl){.version = PG_VERSION_83, .systemId = 0xEFEFEFEFEF})); TEST_ASSIGN(info, pgControlFromFile(storageTest), "get control info v83"); - TEST_RESULT_INT(info.systemId, 0xEFEFEFEFEF, " check system id"); - TEST_RESULT_INT(info.version, PG_VERSION_83, " check version"); + TEST_RESULT_UINT(info.systemId, 0xEFEFEFEFEF, " check system id"); + TEST_RESULT_UINT(info.version, PG_VERSION_83, " check version"); } // ***************************************************************************************************************************** @@ -184,8 +184,8 @@ testRun(void) unsigned char page[PG_PAGE_SIZE_DEFAULT]; memset(page, 0xFF, PG_PAGE_SIZE_DEFAULT); - TEST_RESULT_UINT_HEX(pgPageChecksum(page, 0), 0x0E1C, "check 0xFF filled page, block 0"); - TEST_RESULT_UINT_HEX(pgPageChecksum(page, 999), 0x0EC3, "check 0xFF filled page, block 999"); + TEST_RESULT_UINT(pgPageChecksum(page, 0), 0x0E1C, "check 0xFF filled page, block 0"); + TEST_RESULT_UINT(pgPageChecksum(page, 999), 0x0EC3, "check 0xFF filled page, block 999"); } // ***************************************************************************************************************************** @@ -223,8 +223,8 @@ testRun(void) PgWal info = {0}; TEST_ASSIGN(info, pgWalFromFile(walFile), "get wal info v11"); - TEST_RESULT_INT(info.systemId, 0xECAFECAF, " check system id"); - TEST_RESULT_INT(info.version, PG_VERSION_11, " check version"); + TEST_RESULT_UINT(info.systemId, 0xECAFECAF, " check system id"); + TEST_RESULT_UINT(info.version, PG_VERSION_11, " check version"); //-------------------------------------------------------------------------------------------------------------------------- memset(bufPtr(result), 0, bufSize(result)); @@ -232,8 +232,8 @@ testRun(void) storagePutP(storageNewWriteP(storageTest, walFile), result); TEST_ASSIGN(info, pgWalFromFile(walFile), "get wal info v8.3"); - TEST_RESULT_INT(info.systemId, 0xEAEAEAEA, " check system id"); - TEST_RESULT_INT(info.version, PG_VERSION_83, " check version"); + TEST_RESULT_UINT(info.systemId, 0xEAEAEAEA, " check system id"); + TEST_RESULT_UINT(info.version, PG_VERSION_83, " check version"); } // ***************************************************************************************************************************** diff --git a/test/src/module/storage/posixTest.c b/test/src/module/storage/posixTest.c index b5953d7e3..4a1d64764 100644 --- a/test/src/module/storage/posixTest.c +++ b/test/src/module/storage/posixTest.c @@ -200,9 +200,9 @@ testRun(void) TEST_RESULT_PTR(info.name, NULL, " name is not set"); TEST_RESULT_BOOL(info.exists, true, " check exists"); TEST_RESULT_INT(info.type, storageTypePath, " check type"); - TEST_RESULT_INT(info.size, 0, " check size"); + TEST_RESULT_UINT(info.size, 0, " check size"); TEST_RESULT_INT(info.mode, 0770, " check mode"); - TEST_RESULT_UINT(info.timeModified, 1555160000, " check mod time"); + TEST_RESULT_INT(info.timeModified, 1555160000, " check mod time"); TEST_RESULT_PTR(info.linkDestination, NULL, " no link destination"); TEST_RESULT_UINT(info.userId, getuid(), " check user id"); TEST_RESULT_STR_Z(info.user, testUser(), " check user"); @@ -222,9 +222,9 @@ testRun(void) TEST_RESULT_PTR(info.name, NULL, " name is not set"); TEST_RESULT_BOOL(info.exists, true, " check exists"); TEST_RESULT_INT(info.type, storageTypeFile, " check type"); - TEST_RESULT_INT(info.size, 8, " check size"); + TEST_RESULT_UINT(info.size, 8, " check size"); TEST_RESULT_INT(info.mode, 0640, " check mode"); - TEST_RESULT_UINT(info.timeModified, 1555155555, " check mod time"); + TEST_RESULT_INT(info.timeModified, 1555155555, " check mod time"); TEST_RESULT_PTR(info.linkDestination, NULL, " no link destination"); TEST_RESULT_STR(info.user, NULL, " check user"); TEST_RESULT_STR(info.group, NULL, " check group"); @@ -239,7 +239,7 @@ testRun(void) TEST_RESULT_PTR(info.name, NULL, " name is not set"); TEST_RESULT_BOOL(info.exists, true, " check exists"); TEST_RESULT_INT(info.type, storageTypeLink, " check type"); - TEST_RESULT_INT(info.size, 0, " check size"); + TEST_RESULT_UINT(info.size, 0, " check size"); TEST_RESULT_INT(info.mode, 0777, " check mode"); TEST_RESULT_STR_Z(info.linkDestination, "/tmp", " check link destination"); TEST_RESULT_STR_Z(info.user, testUser(), " check user"); @@ -249,7 +249,7 @@ testRun(void) TEST_RESULT_PTR(info.name, NULL, " name is not set"); TEST_RESULT_BOOL(info.exists, true, " check exists"); TEST_RESULT_INT(info.type, storageTypePath, " check type"); - TEST_RESULT_INT(info.size, 0, " check size"); + TEST_RESULT_UINT(info.size, 0, " check size"); TEST_RESULT_INT(info.mode, 0777, " check mode"); TEST_RESULT_STR(info.linkDestination, NULL, " check link destination"); TEST_RESULT_STR_Z(info.user, "root", " check user"); @@ -265,7 +265,7 @@ testRun(void) TEST_RESULT_PTR(info.name, NULL, " name is not set"); TEST_RESULT_BOOL(info.exists, true, " check exists"); TEST_RESULT_INT(info.type, storageTypeSpecial, " check type"); - TEST_RESULT_INT(info.size, 0, " check size"); + TEST_RESULT_UINT(info.size, 0, " check size"); TEST_RESULT_INT(info.mode, 0666, " check mode"); TEST_RESULT_STR(info.linkDestination, NULL, " check link destination"); TEST_RESULT_STR_Z(info.user, testUser(), " check user"); @@ -746,7 +746,7 @@ testRun(void) TEST_RESULT_BOOL(storageExistsP(storageTest, fileName), false, "destination file does not exist"); TEST_RESULT_BOOL(storageExistsP(storageTest, fileNameTmp), true, "destination tmp file exists"); - TEST_RESULT_INT(storageInfoP(storageTest, fileNameTmp).size, 8, " check temp file size"); + TEST_RESULT_UINT(storageInfoP(storageTest, fileNameTmp).size, 8, " check temp file size"); // ------------------------------------------------------------------------------------------------------------------------- fileName = strNewFmt("%s/sub2/testfile", testPath()); @@ -788,17 +788,17 @@ testRun(void) // ------------------------------------------------------------------------------------------------------------------------- TEST_ASSIGN(buffer, storageGetP(storageNewReadP(storageTest, strNewFmt("%s/test.empty", testPath()))), "get empty"); - TEST_RESULT_INT(bufSize(buffer), 0, "size is 0"); + TEST_RESULT_UINT(bufSize(buffer), 0, "size is 0"); // ------------------------------------------------------------------------------------------------------------------------- TEST_ASSIGN(buffer, storageGetP(storageNewReadP(storageTest, strNewFmt("%s/test.txt", testPath()))), "get text"); - TEST_RESULT_INT(bufSize(buffer), 9, "check size"); + TEST_RESULT_UINT(bufSize(buffer), 9, "check size"); TEST_RESULT_BOOL(memcmp(bufPtr(buffer), "TESTFILE\n", bufSize(buffer)) == 0, true, "check content"); // ------------------------------------------------------------------------------------------------------------------------- TEST_ASSIGN( buffer, storageGetP(storageNewReadP(storageTest, strNewFmt("%s/test.txt", testPath())), .exactSize = 4), "get exact"); - TEST_RESULT_INT(bufSize(buffer), 4, "check size"); + TEST_RESULT_UINT(bufSize(buffer), 4, "check size"); TEST_RESULT_BOOL(memcmp(bufPtr(buffer), "TEST", bufSize(buffer)) == 0, true, "check content"); TEST_ERROR_FMT( @@ -809,7 +809,7 @@ testRun(void) ioBufferSizeSet(2); TEST_ASSIGN(buffer, storageGetP(storageNewReadP(storageTest, strNewFmt("%s/test.txt", testPath()))), "get text"); - TEST_RESULT_INT(bufSize(buffer), 9, "check size"); + TEST_RESULT_UINT(bufSize(buffer), 9, "check size"); TEST_RESULT_BOOL(memcmp(bufPtr(buffer), "TESTFILE\n", bufSize(buffer)) == 0, true, "check content"); // ------------------------------------------------------------------------------------------------------------------------- @@ -819,7 +819,7 @@ testRun(void) TEST_ASSIGN( buffer, storageGetP(storageNewReadP(storageTest, strNewFmt("%s/test.txt", testPath()), .limit = VARUINT64(7))), "get"); - TEST_RESULT_INT(bufSize(buffer), 7, "check size"); + TEST_RESULT_UINT(bufSize(buffer), 7, "check size"); TEST_RESULT_BOOL(memcmp(bufPtr(buffer), "TESTFIL", bufSize(buffer)) == 0, true, "check content"); } @@ -923,12 +923,12 @@ testRun(void) bufUsedZero(outBuffer); TEST_RESULT_VOID(ioRead(storageReadIo(file), outBuffer), " no data to load"); - TEST_RESULT_INT(bufUsed(outBuffer), 0, " buffer is empty"); + TEST_RESULT_UINT(bufUsed(outBuffer), 0, " buffer is empty"); TEST_RESULT_VOID( storageReadPosix(storageRead(file), outBuffer, true), " no data to load from driver either"); - TEST_RESULT_INT(bufUsed(outBuffer), 0, " buffer is empty"); + TEST_RESULT_UINT(bufUsed(outBuffer), 0, " buffer is empty"); TEST_RESULT_BOOL(bufEq(buffer, expectedBuffer), true, " check file contents (all loaded)"); diff --git a/test/src/module/storage/remoteTest.c b/test/src/module/storage/remoteTest.c index 2b9c39922..4e34652c9 100644 --- a/test/src/module/storage/remoteTest.c +++ b/test/src/module/storage/remoteTest.c @@ -144,9 +144,9 @@ testRun(void) TEST_RESULT_PTR(info.name, NULL, " name is not set"); TEST_RESULT_BOOL(info.exists, true, " check exists"); TEST_RESULT_INT(info.type, storageTypePath, " check type"); - TEST_RESULT_INT(info.size, 0, " check size"); + TEST_RESULT_UINT(info.size, 0, " check size"); TEST_RESULT_INT(info.mode, 0750, " check mode"); - TEST_RESULT_UINT(info.timeModified, 1555160000, " check mod time"); + TEST_RESULT_INT(info.timeModified, 1555160000, " check mod time"); TEST_RESULT_PTR(info.linkDestination, NULL, " no link destination"); TEST_RESULT_UINT(info.userId, getuid(), " check user id"); TEST_RESULT_STR_Z(info.user, testUser(), " check user"); @@ -162,9 +162,9 @@ testRun(void) TEST_RESULT_PTR(info.name, NULL, " name is not set"); TEST_RESULT_BOOL(info.exists, true, " check exists"); TEST_RESULT_INT(info.type, storageTypeFile, " check type"); - TEST_RESULT_INT(info.size, 6, " check size"); + TEST_RESULT_UINT(info.size, 6, " check size"); TEST_RESULT_INT(info.mode, 0640, " check mode"); - TEST_RESULT_UINT(info.timeModified, 1555160001, " check mod time"); + TEST_RESULT_INT(info.timeModified, 1555160001, " check mod time"); TEST_RESULT_PTR(info.linkDestination, NULL, " no link destination"); TEST_RESULT_UINT(info.userId, getuid(), " check user id"); TEST_RESULT_STR_Z(info.user, testUser(), " check user"); @@ -180,7 +180,7 @@ testRun(void) TEST_RESULT_PTR(info.name, NULL, " name is not set"); TEST_RESULT_BOOL(info.exists, true, " check exists"); TEST_RESULT_INT(info.type, storageTypeSpecial, " check type"); - TEST_RESULT_INT(info.size, 0, " check size"); + TEST_RESULT_UINT(info.size, 0, " check size"); TEST_RESULT_INT(info.mode, 0666, " check mode"); TEST_RESULT_PTR(info.linkDestination, NULL, " no link destination"); TEST_RESULT_UINT(info.userId, getuid(), " check user id"); @@ -197,7 +197,7 @@ testRun(void) TEST_RESULT_PTR(info.name, NULL, " name is not set"); TEST_RESULT_BOOL(info.exists, true, " check exists"); TEST_RESULT_INT(info.type, storageTypeLink, " check type"); - TEST_RESULT_INT(info.size, 0, " check size"); + TEST_RESULT_UINT(info.size, 0, " check size"); TEST_RESULT_INT(info.mode, 0777, " check mode"); TEST_RESULT_STR_Z(info.linkDestination, "../repo/test", " check link destination"); TEST_RESULT_UINT(info.userId, getuid(), " check user id"); @@ -212,7 +212,7 @@ testRun(void) TEST_RESULT_PTR(info.name, NULL, " name is not set"); TEST_RESULT_BOOL(info.exists, true, " check exists"); TEST_RESULT_INT(info.type, storageTypeFile, " check type"); - TEST_RESULT_INT(info.size, 6, " check size"); + TEST_RESULT_UINT(info.size, 6, " check size"); TEST_RESULT_INT(info.mode, 0640, " check mode"); TEST_RESULT_PTR(info.linkDestination, NULL, " no link destination"); TEST_RESULT_UINT(info.userId, getuid(), " check user id"); @@ -395,7 +395,7 @@ testRun(void) TEST_RESULT_BOOL(bufEq(storageGetP(fileRead), contentBuf), true, "get file"); TEST_RESULT_BOOL(storageReadIgnoreMissing(fileRead), false, "check ignore missing"); TEST_RESULT_STR_Z(storageReadName(fileRead), hrnReplaceKey("{[path]}/repo/test.txt"), "check name"); - TEST_RESULT_SIZE( + TEST_RESULT_UINT( storageReadRemote(storageRead(fileRead), bufNew(32), false), 0, "nothing more to read"); diff --git a/test/src/module/storage/s3Test.c b/test/src/module/storage/s3Test.c index ca1aa3c8e..784ad5522 100644 --- a/test/src/module/storage/s3Test.c +++ b/test/src/module/storage/s3Test.c @@ -845,7 +845,7 @@ testRun(void) TEST_RESULT_BOOL(info.exists, true, " check exists"); TEST_RESULT_UINT(info.type, storageTypeFile, " check type"); TEST_RESULT_UINT(info.size, 9999, " check exists"); - TEST_RESULT_UINT(info.timeModified, 1445412480, " check time"); + TEST_RESULT_INT(info.timeModified, 1445412480, " check time"); // InfoList() // ------------------------------------------------------------------------------------------------------------------------- @@ -862,7 +862,7 @@ testRun(void) TEST_RESULT_UINT(testStorageInfoList[0].type, storageTypePath, " check type"); TEST_RESULT_STR_Z(testStorageInfoList[1].name, "test_file", " check name"); TEST_RESULT_UINT(testStorageInfoList[1].size, 787, " check size"); - TEST_RESULT_UINT(testStorageInfoList[1].timeModified, 1255369830, " check time"); + TEST_RESULT_INT(testStorageInfoList[1].timeModified, 1255369830, " check time"); TEST_RESULT_UINT(testStorageInfoList[1].type, storageTypeFile, " check type"); // storageDriverList()