db/pgbackrest
1
0
Fork 0
mirror of https://github.com/pgbackrest/pgbackrest.git synced 2025-07-05 00:28:52 +02:00
Code Issues Releases Activity

Fix incorrect result types in unit tests.

Browse Source 
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.
This commit is contained in:
David Steele
2020-03-22 20:25:31 -04:00
parent e1da6a45e0
commit d6ffa9ea6d
29 changed files with 205 additions and 221 deletions
Download Patch File Download Diff File Expand all files Collapse all files

16
test/src/common/harnessTest.h
View File

@ -271,13 +271,6 @@ Macros to ease the use of common data types
#define TEST_RESULT_BOOL(statement, resultExpected, ...) \ #define TEST_RESULT_BOOL(statement, resultExpected, ...) \
TEST_RESULT_BOOL_PARAM(statement, resultExpected, ==, __VA_ARGS__); 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, ...) \ #define TEST_RESULT_DOUBLE_PARAM(statement, resultExpected, typeOp, ...) \
TEST_RESULT(statement, resultExpected, double, "%f", TEST_TYPE_FORMAT, typeOp, TEST_TYPE_COMPARE, __VA_ARGS__); TEST_RESULT(statement, resultExpected, double, "%f", TEST_TYPE_FORMAT, typeOp, TEST_TYPE_COMPARE, __VA_ARGS__);
#define TEST_RESULT_DOUBLE(statement, resultExpected, ...) \ #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, ...) \ #define TEST_RESULT_PTR_NE(statement, resultExpected, ...) \
TEST_RESULT_PTR_PARAM(statement, resultExpected, !=, __VA_ARGS__); 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, ...) \ #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__); TEST_RESULT(statement, resultExpected, char *, "%s", TEST_TYPE_FORMAT_PTR, typeOp, TEST_TYPE_COMPARE_STR, __VA_ARGS__);
#define TEST_RESULT_Z(statement, resultExpected, ...) \ #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__); TEST_RESULT_UINT_PARAM(statement, resultExpected, ==, __VA_ARGS__);
#define TEST_RESULT_UINT_NE(statement, resultExpected, ...) \ #define TEST_RESULT_UINT_NE(statement, resultExpected, ...) \
TEST_RESULT_UINT_PARAM(statement, resultExpected, !=, __VA_ARGS__); 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 Test system calls

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

@ -168,7 +168,7 @@ testRun(void)
TEST_RESULT_INT( TEST_RESULT_INT(
archiveGetFile(storageTest, archiveFile, walDestination, false, cipherTypeNone, NULL), 0, "WAL segment copied"); archiveGetFile(storageTest, archiveFile, walDestination, false, cipherTypeNone, NULL), 0, "WAL segment copied");
TEST_RESULT_BOOL(storageExistsP(storageTest, walDestination), true, " check exists"); 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( storageRemoveP(
storageTest, storageTest,
@ -211,7 +211,7 @@ testRun(void)
archiveGetFile( archiveGetFile(
storageTest, archiveFile, walDestination, false, cipherTypeAes256Cbc, strNew("12345678")), 0, "WAL segment copied"); storageTest, archiveFile, walDestination, false, cipherTypeAes256Cbc, strNew("12345678")), 0, "WAL segment copied");
TEST_RESULT_BOOL(storageExistsP(storageTest, walDestination), true, " check exists"); 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 // Check protocol function directly
// ------------------------------------------------------------------------------------------------------------------------- // -------------------------------------------------------------------------------------------------------------------------

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

@ -219,7 +219,7 @@ testRun(void)
TEST_RESULT_BOOL(info.exists, true, " check exists"); TEST_RESULT_BOOL(info.exists, true, " check exists");
TEST_RESULT_UINT(info.size, 7, " check size"); TEST_RESULT_UINT(info.size, 7, " check size");
TEST_RESULT_UINT(info.mode, 0600, " check mode"); 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.user, testUser(), " check user");
TEST_RESULT_STR_Z(info.group, testGroup(), " check group"); TEST_RESULT_STR_Z(info.group, testGroup(), " check group");
TEST_RESULT_STR_Z(strNewBuf(storageGetP(storageNewReadP(storagePg(), strNew("normal")))), "acefile", " check contents"); 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_BOOL(info.exists, true, " check exists");
TEST_RESULT_UINT(info.size, 9, " check size"); TEST_RESULT_UINT(info.size, 9, " check size");
TEST_RESULT_UINT(info.mode, 0677, " check mode"); 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.user, testUser(), " check user");
TEST_RESULT_STR_Z(info.group, testGroup(), " check group"); TEST_RESULT_STR_Z(info.group, testGroup(), " check group");
TEST_RESULT_STR_Z( TEST_RESULT_STR_Z(
@ -452,9 +452,9 @@ testRun(void)
TEST_TITLE("system time UTC"); TEST_TITLE("system time UTC");
setenv("TZ", "UTC", true); setenv("TZ", "UTC", true);
TEST_RESULT_UINT(getEpoch(strNew("2020-01-08 09:18:15-0700")), 1578500295, "epoch with timezone"); TEST_RESULT_INT(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_INT(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 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-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"); 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]; char timeBuffer[20];
strftime(timeBuffer, sizeof(timeBuffer), "%Y-%m-%d %H:%M:%S", localtime(&testTime)); 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_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_INT(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_INT(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_INT(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("2018-04-27 04:29:00+04:30")), 1524787140, "GMT+0430");
// ------------------------------------------------------------------------------------------------------------------------- // -------------------------------------------------------------------------------------------------------------------------
TEST_TITLE("invalid target time format"); 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( TEST_RESULT_LOG(
"P00 WARN: automatic backup set selection cannot be performed with provided time 'Tue, 15 Nov 1994 12:45:26'," "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" " latest backup set will be used\n"

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

@ -92,11 +92,11 @@ testRun(void)
cipherBlockNew(cipherModeEncrypt, cipherTypeAes256Cbc, BUFSTRZ(TEST_PASS), NULL)); cipherBlockNew(cipherModeEncrypt, cipherTypeAes256Cbc, BUFSTRZ(TEST_PASS), NULL));
TEST_RESULT_Z(memContextName(cipherBlock->memContext), "CipherBlock", "mem context name is valid"); 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->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(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->saltDone, false, "salt done is false");
TEST_RESULT_BOOL(cipherBlock->processDone, false, "process 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->cipher, NULL, "cipher is set");
TEST_RESULT_PTR_NE(cipherBlock->digest, NULL, "digest is set"); TEST_RESULT_PTR_NE(cipherBlock->digest, NULL, "digest is set");
TEST_RESULT_PTR(cipherBlock->cipherContext, NULL, "cipher context is not set"); TEST_RESULT_PTR(cipherBlock->cipherContext, NULL, "cipher context is not set");
@ -109,13 +109,13 @@ testRun(void)
blockEncryptFilter = cipherBlockNewVar(ioFilterParamList(blockEncryptFilter)); blockEncryptFilter = cipherBlockNewVar(ioFilterParamList(blockEncryptFilter));
CipherBlock *blockEncrypt = (CipherBlock *)ioFilterDriver(blockEncryptFilter); CipherBlock *blockEncrypt = (CipherBlock *)ioFilterDriver(blockEncryptFilter);
TEST_RESULT_INT( TEST_RESULT_UINT(
cipherBlockProcessSize(blockEncrypt, strlen(TEST_PLAINTEXT)), cipherBlockProcessSize(blockEncrypt, strlen(TEST_PLAINTEXT)),
strlen(TEST_PLAINTEXT) + EVP_MAX_BLOCK_LENGTH + CIPHER_BLOCK_MAGIC_SIZE + PKCS5_SALT_LEN, "check process size"); strlen(TEST_PLAINTEXT) + EVP_MAX_BLOCK_LENGTH + CIPHER_BLOCK_MAGIC_SIZE + PKCS5_SALT_LEN, "check process size");
bufLimitSet(encryptBuffer, CIPHER_BLOCK_MAGIC_SIZE); bufLimitSet(encryptBuffer, CIPHER_BLOCK_MAGIC_SIZE);
ioFilterProcessInOut(blockEncryptFilter, testPlainText, encryptBuffer); 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"); TEST_RESULT_BOOL(ioFilterInputSame(blockEncryptFilter), true, "filter needs same input");
bufLimitSet(encryptBuffer, CIPHER_BLOCK_MAGIC_SIZE + PKCS5_SALT_LEN); 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->saltDone, true, "salt done is true");
TEST_RESULT_BOOL(blockEncrypt->processDone, true, "process 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_UINT(blockEncrypt->headerSize, 0, "header size is 0");
TEST_RESULT_INT(bufUsed(encryptBuffer), CIPHER_BLOCK_HEADER_SIZE, "cipher size is header len"); 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)), cipherBlockProcessSize(blockEncrypt, strlen(TEST_PLAINTEXT)),
strlen(TEST_PLAINTEXT) + EVP_MAX_BLOCK_LENGTH, "check process size"); strlen(TEST_PLAINTEXT) + EVP_MAX_BLOCK_LENGTH, "check process size");
@ -139,13 +139,13 @@ testRun(void)
ioFilterProcessInOut(blockEncryptFilter, testPlainText, encryptBuffer); ioFilterProcessInOut(blockEncryptFilter, testPlainText, encryptBuffer);
bufLimitClear(encryptBuffer); bufLimitClear(encryptBuffer);
TEST_RESULT_INT( TEST_RESULT_UINT(
bufUsed(encryptBuffer), CIPHER_BLOCK_HEADER_SIZE + (size_t)EVP_CIPHER_block_size(blockEncrypt->cipher), bufUsed(encryptBuffer), CIPHER_BLOCK_HEADER_SIZE + (size_t)EVP_CIPHER_block_size(blockEncrypt->cipher),
"cipher size increases by one block"); "cipher size increases by one block");
TEST_RESULT_BOOL(ioFilterDone(blockEncryptFilter), false, "filter is not done"); TEST_RESULT_BOOL(ioFilterDone(blockEncryptFilter), false, "filter is not done");
ioFilterProcessInOut(blockEncryptFilter, NULL, encryptBuffer); 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), bufUsed(encryptBuffer), CIPHER_BLOCK_HEADER_SIZE + (size_t)(EVP_CIPHER_block_size(blockEncrypt->cipher) * 2),
"cipher size increases by one block on flush"); "cipher size increases by one block on flush");
TEST_RESULT_BOOL(ioFilterDone(blockEncryptFilter), true, "filter is done"); TEST_RESULT_BOOL(ioFilterDone(blockEncryptFilter), true, "filter is done");
@ -160,15 +160,15 @@ testRun(void)
blockDecryptFilter = cipherBlockNewVar(ioFilterParamList(blockDecryptFilter)); blockDecryptFilter = cipherBlockNewVar(ioFilterParamList(blockDecryptFilter));
CipherBlock *blockDecrypt = (CipherBlock *)ioFilterDriver(blockDecryptFilter); CipherBlock *blockDecrypt = (CipherBlock *)ioFilterDriver(blockDecryptFilter);
TEST_RESULT_INT( TEST_RESULT_UINT(
cipherBlockProcessSize(blockDecrypt, bufUsed(encryptBuffer)), bufUsed(encryptBuffer) + EVP_MAX_BLOCK_LENGTH, cipherBlockProcessSize(blockDecrypt, bufUsed(encryptBuffer)), bufUsed(encryptBuffer) + EVP_MAX_BLOCK_LENGTH,
"check process size"); "check process size");
ioFilterProcessInOut(blockDecryptFilter, encryptBuffer, decryptBuffer); 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); 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"); TEST_RESULT_STR_Z(strNewBuf(decryptBuffer), TEST_PLAINTEXT TEST_PLAINTEXT, "check final decrypt buffer");
@ -182,19 +182,19 @@ testRun(void)
bufUsedZero(decryptBuffer); bufUsedZero(decryptBuffer);
ioFilterProcessInOut(blockDecryptFilter, bufNewC(bufPtr(encryptBuffer), CIPHER_BLOCK_MAGIC_SIZE), 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->saltDone, false, "salt done is false");
TEST_RESULT_BOOL(blockDecrypt->processDone, false, "process 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( TEST_RESULT_BOOL(
memcmp(blockDecrypt->header, CIPHER_BLOCK_MAGIC, CIPHER_BLOCK_MAGIC_SIZE) == 0, true, "check header magic"); memcmp(blockDecrypt->header, CIPHER_BLOCK_MAGIC, CIPHER_BLOCK_MAGIC_SIZE) == 0, true, "check header magic");
ioFilterProcessInOut( ioFilterProcessInOut(
blockDecryptFilter, bufNewC(bufPtr(encryptBuffer) + CIPHER_BLOCK_MAGIC_SIZE, PKCS5_SALT_LEN), decryptBuffer); 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->saltDone, true, "salt done is true");
TEST_RESULT_BOOL(blockDecrypt->processDone, false, "process 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 (not increased)"); TEST_RESULT_UINT(blockDecrypt->headerSize, CIPHER_BLOCK_MAGIC_SIZE, "check header size (not increased)");
TEST_RESULT_BOOL( TEST_RESULT_BOOL(
memcmp( memcmp(
blockDecrypt->header + CIPHER_BLOCK_MAGIC_SIZE, bufPtr(encryptBuffer) + CIPHER_BLOCK_MAGIC_SIZE, blockDecrypt->header + CIPHER_BLOCK_MAGIC_SIZE, bufPtr(encryptBuffer) + CIPHER_BLOCK_MAGIC_SIZE,
@ -205,10 +205,10 @@ testRun(void)
blockDecryptFilter, blockDecryptFilter,
bufNewC(bufPtr(encryptBuffer) + CIPHER_BLOCK_HEADER_SIZE, bufUsed(encryptBuffer) - CIPHER_BLOCK_HEADER_SIZE), bufNewC(bufPtr(encryptBuffer) + CIPHER_BLOCK_HEADER_SIZE, bufUsed(encryptBuffer) - CIPHER_BLOCK_HEADER_SIZE),
decryptBuffer); 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); 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"); TEST_RESULT_STR_Z(strNewBuf(decryptBuffer), TEST_PLAINTEXT TEST_PLAINTEXT, "check final decrypt buffer");
@ -222,7 +222,7 @@ testRun(void)
bufUsedZero(encryptBuffer); bufUsedZero(encryptBuffer);
ioFilterProcessInOut(blockEncryptFilter, NULL, 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); ioFilterFree(blockEncryptFilter);
@ -232,9 +232,9 @@ testRun(void)
bufUsedZero(decryptBuffer); bufUsedZero(decryptBuffer);
ioFilterProcessInOut(blockDecryptFilter, encryptBuffer, 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); 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); ioFilterFree(blockDecryptFilter);

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

@ -55,42 +55,42 @@ testRun(void)
{ {
char buffer[STACK_TRACE_PARAM_MAX]; 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_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_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_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_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_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_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_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_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_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_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_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"); TEST_RESULT_Z(buffer, "\"test2\"", " check full string");
} }

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

@ -13,32 +13,32 @@ testRun(void)
// ***************************************************************************************************************************** // *****************************************************************************************************************************
if (testBegin("base64")) 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]; char destinationEncode[256];
encodeToStr(encodeBase64, encode, 1, destinationEncode); encodeToStr(encodeBase64, encode, 1, destinationEncode);
TEST_RESULT_Z(destinationEncode, "cw==", "1 character encode"); 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); encodeToStr(encodeBase64, encode, 2, destinationEncode);
TEST_RESULT_Z(destinationEncode, "c3Q=", "2 character encode"); 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); encodeToStr(encodeBase64, encode, 3, destinationEncode);
TEST_RESULT_Z(destinationEncode, "c3Ry", "3 character encode"); 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); encodeToStr(encodeBase64, encode, strlen((char *)encode) - 2, destinationEncode);
TEST_RESULT_Z(destinationEncode, "c3RyaW5nX3RvX2VuY29kZQ==", "encode full string"); 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); encodeToStr(encodeBase64, encode, strlen((char *)encode), destinationEncode);
TEST_RESULT_Z(destinationEncode, "c3RyaW5nX3RvX2VuY29kZQ0K", "encode full string with \\r\\n"); 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); encodeToStr(encodeBase64, encode, strlen((char *)encode) + 1, destinationEncode);
TEST_RESULT_Z(destinationEncode, "c3RyaW5nX3RvX2VuY29kZQ0KAA==", "encode full string with \\r\\n and null"); 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(encodeToStr(999, encode, strlen((char *)encode), destinationEncode), AssertError, "invalid encode type 999");
TEST_ERROR(encodeToStrSize(999, strlen((char *)encode)), 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)); memset(destinationDecode, 0xFF, sizeof(destinationDecode));
const char *decode = "c3RyaW5nX3RvX2VuY29kZQ0KAA=="; const char *decode = "c3RyaW5nX3RvX2VuY29kZQ0KAA==";
decodeToBin(encodeBase64, decode, destinationDecode); 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(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)); memset(destinationDecode, 0xFF, sizeof(destinationDecode));
decode = "c3RyaW5nX3RvX2VuY29kZQ0K"; decode = "c3RyaW5nX3RvX2VuY29kZQ0K";
decodeToBin(encodeBase64, decode, destinationDecode); decodeToBin(encodeBase64, decode, destinationDecode);
TEST_RESULT_INT(memcmp(destinationDecode, encode, strlen((char *)encode)), 0, "full string with \\r\\n decode"); 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(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)); memset(destinationDecode, 0xFF, sizeof(destinationDecode));
decode = "c3RyaW5nX3RvX2VuY29kZQ=="; decode = "c3RyaW5nX3RvX2VuY29kZQ==";
decodeToBin(encodeBase64, decode, destinationDecode); decodeToBin(encodeBase64, decode, destinationDecode);
TEST_RESULT_INT(memcmp(destinationDecode, encode, strlen((char *)encode) - 2), 0, "full string decode"); 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(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)); memset(destinationDecode, 0xFF, sizeof(destinationDecode));
decode = "c3Ry"; decode = "c3Ry";
decodeToBin(encodeBase64, decode, destinationDecode); decodeToBin(encodeBase64, decode, destinationDecode);
TEST_RESULT_INT(memcmp(destinationDecode, encode, 3), 0, "3 character decode"); TEST_RESULT_INT(memcmp(destinationDecode, encode, 3), 0, "3 character decode");
TEST_RESULT_INT(destinationDecode[3], 0xFF, "check for overrun"); 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)); memset(destinationDecode, 0xFF, sizeof(destinationDecode));
decode = "c3Q="; decode = "c3Q=";
decodeToBin(encodeBase64, decode, destinationDecode); decodeToBin(encodeBase64, decode, destinationDecode);
TEST_RESULT_INT(memcmp(destinationDecode, encode, 2), 0, "2 character decode"); TEST_RESULT_INT(memcmp(destinationDecode, encode, 2), 0, "2 character decode");
TEST_RESULT_INT(destinationDecode[2], 0xFF, "check for overrun"); 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)); memset(destinationDecode, 0xFF, sizeof(destinationDecode));
decode = "cw=="; decode = "cw==";
decodeToBin(encodeBase64, decode, destinationDecode); decodeToBin(encodeBase64, decode, destinationDecode);
TEST_RESULT_INT(memcmp(destinationDecode, encode, 1), 0, "1 character decode"); TEST_RESULT_INT(memcmp(destinationDecode, encode, 1), 0, "1 character decode");
TEST_RESULT_INT(destinationDecode[1], 0xFF, "check for overrun"); 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(decodeToBin(9999, decode, destinationDecode), AssertError, "invalid encode type 9999");
TEST_ERROR(decodeToBinSize(9999, decode), AssertError, "invalid encode type 9999"); TEST_ERROR(decodeToBinSize(9999, decode), AssertError, "invalid encode type 9999");

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

@ -251,9 +251,9 @@ testRun(void)
// ***************************************************************************************************************************** // *****************************************************************************************************************************
if (testBegin("ioBufferSize() and ioBufferSizeSet()")) 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_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"); "create io read object");
TEST_RESULT_BOOL(ioReadOpen(read), true, " open io 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_BOOL(ioReadEof(read), false, " no eof");
TEST_RESULT_VOID(ioReadClose(read), " close io object"); TEST_RESULT_VOID(ioReadClose(read), " close io object");
TEST_RESULT_BOOL(testIoReadCloseCalled, true, " check io object closed"); 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_ASSIGN(bufferRead, ioBufferReadNew(bufferOriginal), "create empty buffer read object");
TEST_RESULT_BOOL(ioReadOpen(bufferRead), true, " open"); TEST_RESULT_BOOL(ioReadOpen(bufferRead), true, " open");
TEST_RESULT_BOOL(ioReadEof(bufferRead), false, " not eof"); 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"); TEST_RESULT_BOOL(ioReadEof(bufferRead), true, " now eof");
// ------------------------------------------------------------------------------------------------------------------------- // -------------------------------------------------------------------------------------------------------------------------
@ -323,26 +323,26 @@ testRun(void)
TEST_RESULT_BOOL(ioReadOpen(bufferRead), true, " open"); TEST_RESULT_BOOL(ioReadOpen(bufferRead), true, " open");
TEST_RESULT_INT(ioReadHandle(bufferRead), -1, " handle invalid"); TEST_RESULT_INT(ioReadHandle(bufferRead), -1, " handle invalid");
TEST_RESULT_BOOL(ioReadEof(bufferRead), false, " not eof"); TEST_RESULT_BOOL(ioReadEof(bufferRead), false, " not eof");
TEST_RESULT_SIZE(ioRead(bufferRead, buffer), 2, " read 2 bytes"); TEST_RESULT_UINT(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), 0, " read 0 bytes (full buffer)");
TEST_RESULT_STR_Z(strNewBuf(buffer), "11", " check read"); TEST_RESULT_STR_Z(strNewBuf(buffer), "11", " check read");
TEST_RESULT_STR_Z(ioFilterType(sizeFilter), "size", "check filter type"); TEST_RESULT_STR_Z(ioFilterType(sizeFilter), "size", "check filter type");
TEST_RESULT_BOOL(ioReadEof(bufferRead), false, " not eof"); TEST_RESULT_BOOL(ioReadEof(bufferRead), false, " not eof");
TEST_RESULT_VOID(bufUsedZero(buffer), " zero buffer"); 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_RESULT_STR_Z(strNewBuf(buffer), "22", " check read");
TEST_ASSIGN(buffer, bufNew(3), "change output buffer size to 3"); 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_STR_Z(strNewBuf(buffer), "33X", " check read");
TEST_RESULT_VOID(bufUsedZero(buffer), " zero buffer"); 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_STR_Z(strNewBuf(buffer), "XX", " check read");
TEST_RESULT_BOOL(ioReadEof(bufferRead), true, " eof"); TEST_RESULT_BOOL(ioReadEof(bufferRead), true, " eof");
TEST_RESULT_BOOL(ioBufferRead(ioReadDriver(bufferRead), buffer, true), 0, " eof from driver"); TEST_RESULT_UINT(ioBufferRead(ioReadDriver(bufferRead), buffer, true), 0, " eof from driver");
TEST_RESULT_SIZE(ioRead(bufferRead, buffer), 0, " read 0 bytes"); TEST_RESULT_UINT(ioRead(bufferRead, buffer), 0, " read 0 bytes");
TEST_RESULT_VOID(ioReadClose(bufferRead), " close buffer read object"); TEST_RESULT_VOID(ioReadClose(bufferRead), " close buffer read object");
TEST_RESULT_STR_Z( TEST_RESULT_STR_Z(
jsonFromVar(ioFilterGroupResultAll(ioReadFilterGroup(bufferRead))), jsonFromVar(ioFilterGroupResultAll(ioReadFilterGroup(bufferRead))),
@ -397,7 +397,7 @@ testRun(void)
buffer = bufNew(3); buffer = bufNew(3);
// Start with a buffer read // 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"); TEST_RESULT_STR_Z(strNewBuf(buffer), "AAA", " check buffer");
// Do line reads of various lengths // Do line reads of various lengths
@ -407,14 +407,14 @@ testRun(void)
TEST_RESULT_STR_Z(ioReadLine(read), "12", "read line"); TEST_RESULT_STR_Z(ioReadLine(read), "12", "read line");
// Read what was left in the line buffer // 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); 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"); TEST_RESULT_STR_Z(strNewBuf(buffer), "AAB", " check buffer");
bufUsedSet(buffer, 0); bufUsedSet(buffer, 0);
// Now do a full buffer read from the input // 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"); TEST_RESULT_STR_Z(strNewBuf(buffer), "DDD", " check buffer");
// Read line doesn't work without a linefeed // 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 // But those bytes can be picked up by a buffer read
buffer = bufNew(2); 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"); TEST_RESULT_STR_Z(strNewBuf(buffer), "EF", " check buffer");
buffer = bufNew(1); 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"); TEST_RESULT_STR_Z(strNewBuf(buffer), "F", " check buffer");
// Nothing left to read // Nothing left to read
TEST_ERROR(ioReadLine(read), FileReadError, "unexpected eof while reading line"); 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 // Error if buffer is full and there is no linefeed
ioBufferSizeSet(10); ioBufferSizeSet(10);

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

@ -225,12 +225,12 @@ testRun(void)
TEST_RESULT_BOOL(ioReadEof(tlsClientIoRead(client)), false, " check eof = false"); TEST_RESULT_BOOL(ioReadEof(tlsClientIoRead(client)), false, " check eof = false");
Buffer *output = bufNew(12); 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_STR_Z(strNewBuf(output), "some content", " check output");
TEST_RESULT_BOOL(ioReadEof(tlsClientIoRead(client)), false, " check eof = false"); TEST_RESULT_BOOL(ioReadEof(tlsClientIoRead(client)), false, " check eof = false");
output = bufNew(8); 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_STR_Z(strNewBuf(output), "AND MORE", " check output");
TEST_RESULT_BOOL(ioReadEof(tlsClientIoRead(client)), false, " check eof = false"); TEST_RESULT_BOOL(ioReadEof(tlsClientIoRead(client)), false, " check eof = false");
@ -246,12 +246,12 @@ testRun(void)
ioWriteFlush(tlsClientIoWrite(client)); ioWriteFlush(tlsClientIoWrite(client));
output = bufNew(12); 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_STR_Z(strNewBuf(output), "0123456789AB", " check output");
TEST_RESULT_BOOL(ioReadEof(tlsClientIoRead(client)), false, " check eof = false"); TEST_RESULT_BOOL(ioReadEof(tlsClientIoRead(client)), false, " check eof = false");
output = bufNew(12); 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"); TEST_RESULT_BOOL(ioReadEof(tlsClientIoRead(client)), true, " check eof = true");
// ------------------------------------------------------------------------------------------------------------------------- // -------------------------------------------------------------------------------------------------------------------------

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

@ -85,7 +85,7 @@ testRun(void)
{ {
HARNESS_FORK_CHILD_BEGIN(0, false) 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); sleepMSec(500);
} }
HARNESS_FORK_CHILD_END(); HARNESS_FORK_CHILD_END();

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

@ -36,7 +36,7 @@ testRun(void)
const String *string = STRDEF("abcdef"); const String *string = STRDEF("abcdef");
TEST_RESULT_BOOL(regExpMatch(regExp, string), true, "match regexp"); TEST_RESULT_BOOL(regExpMatch(regExp, string), true, "match regexp");
TEST_RESULT_PTR(regExpMatchPtr(regExp), strPtr(string), "check ptr"); 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"); 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_BOOL(regExpMatch(regExp, strNew("bcdef")), false, "no match regexp");
TEST_RESULT_PTR(regExpMatchPtr(regExp), NULL, "check ptr"); 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"); TEST_RESULT_PTR(regExpMatchStr(regExp), NULL, "check str");
// ------------------------------------------------------------------------------------------------------------------------- // -------------------------------------------------------------------------------------------------------------------------

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

@ -16,11 +16,11 @@ testRun(void)
{ {
char buffer[8]; 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_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_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"); TEST_RESULT_Z(buffer, "1234567", " check buffer is unmodified");
} }

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

@ -23,7 +23,7 @@ testRun(void)
MEM_CONTEXT_TEMP_END(); MEM_CONTEXT_TEMP_END();
TEST_RESULT_PTR(bufPtr(buffer), buffer->buffer, "buffer pointer"); 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_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"); TEST_RESULT_BOOL(memcmp(bufPtr(buffer), "TEST-STR", 8) == 0, true, "check buffer");
@ -52,9 +52,9 @@ testRun(void)
unsigned char *bufferPtr = NULL; unsigned char *bufferPtr = NULL;
TEST_ASSIGN(buffer, bufNew(0), "new zero buffer"); 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_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_VOID(bufUsedSet(buffer, 256), "set used size");
TEST_RESULT_BOOL(bufFull(buffer), true, "check buffer full"); TEST_RESULT_BOOL(bufFull(buffer), true, "check buffer full");
@ -67,10 +67,10 @@ testRun(void)
// Increase buffer size // Increase buffer size
TEST_ASSIGN(bufferPtr, bufPtr(bufResize(buffer, 512)), "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_ASSIGN(bufferPtr, bufPtr(bufResize(buffer, 512)), "set to same size");
TEST_RESULT_INT(bufSize(buffer), 512, "check size"); TEST_RESULT_UINT(bufSize(buffer), 512, "check size");
TEST_RESULT_INT(bufUsed(buffer), 256, "check used size"); TEST_RESULT_UINT(bufUsed(buffer), 256, "check used size");
TEST_RESULT_BOOL(bufFull(buffer), false, "check buffer not full"); 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_PTR(bufRemainsPtr(buffer), bufPtr(buffer) + 256, "check remaining buffer space pointer");
TEST_RESULT_VOID(bufUsedInc(buffer, 256), "set used size"); TEST_RESULT_VOID(bufUsedInc(buffer, 256), "set used size");
TEST_RESULT_BOOL(bufFull(buffer), true, "check buffer full"); TEST_RESULT_BOOL(bufFull(buffer), true, "check buffer full");
@ -85,7 +85,7 @@ testRun(void)
// Decrease buffer size // Decrease buffer size
TEST_ASSIGN(bufferPtr, bufPtr(bufResize(buffer, 128)), "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 // Test that no bytes have changed in the original data
sameTotal = 0; sameTotal = 0;
@ -97,22 +97,22 @@ testRun(void)
// Use limits to change size reporting // Use limits to change size reporting
TEST_RESULT_VOID(bufLimitSet(buffer, 64), "set limit"); 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_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 // Resize to zero buffer
TEST_RESULT_VOID(bufUsedZero(buffer), "set used to 0"); 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(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_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(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_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_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");
} }
// ***************************************************************************************************************************** // *****************************************************************************************************************************

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

@ -18,9 +18,9 @@ testRun(void)
TEST_ERROR(cvtBoolToZ(true, buffer, 4), AssertError, "buffer overflow"); 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_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"); TEST_RESULT_Z(buffer, "false", " check buffer");
} }
@ -31,7 +31,7 @@ testRun(void)
TEST_ERROR(cvtCharToZ('A', buffer, 1), AssertError, "buffer overflow"); 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"); TEST_RESULT_Z(buffer, "C", " check buffer");
} }
@ -42,13 +42,13 @@ testRun(void)
TEST_ERROR(cvtDoubleToZ(999.1234, buffer, 4), AssertError, "buffer overflow"); 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_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_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_RESULT_Z(buffer, "999", " check buffer");
TEST_ERROR(cvtZToDouble("AAA"), FormatError, "unable to convert string 'AAA' to double"); 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_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_RESULT_Z(buffer, "1234567890", " check buffer");
TEST_ERROR(cvtZToInt("FEF"), FormatError, "unable to convert base 10 string 'FEF' to int"); 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_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_Z(buffer, "0777", " check buffer");
TEST_RESULT_UINT(cvtZToMode("0700"), 0700, "convert string to mode"); 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_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"); TEST_RESULT_Z(buffer, "-9999", " check buffer");
} }
@ -126,7 +126,7 @@ testRun(void)
TEST_ERROR(cvtUIntToZ(9999, buffer, 4), AssertError, "buffer overflow"); 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_RESULT_Z(buffer, "4294967295", " check buffer");
TEST_ERROR(cvtZToUInt("-1"), FormatError, "unable to convert base 10 string '-1' to unsigned int"); 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_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_RESULT_Z(buffer, "9223372036854775807", " check buffer");
TEST_ERROR(cvtZToInt64("123INV"), FormatError, "unable to convert base 10 string '123INV' to int64"); 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_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_RESULT_Z(buffer, "18446744073709551615", " check buffer");
TEST_ERROR(cvtZToUInt64("FEF"), FormatError, "unable to convert base 10 string 'FEF' to uint64"); 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_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_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(); FUNCTION_HARNESS_RESULT_VOID();

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

@ -93,7 +93,7 @@ testRun(void)
VariantList *valueList = NULL; VariantList *valueList = NULL;
TEST_ASSIGN(valueList, varVarLst(jsonToVar(strNew("[1, \"test\", false]"))), "array"); TEST_ASSIGN(valueList, varVarLst(jsonToVar(strNew("[1, \"test\", false]"))), "array");
TEST_RESULT_UINT(varLstSize(valueList), 3, "check array size"); 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_STR_Z(varStr(varLstGet(valueList, 1)), "test", "check array str");
TEST_RESULT_BOOL(varBool(varLstGet(valueList, 2)), false, "check array bool"); TEST_RESULT_BOOL(varBool(varLstGet(valueList, 2)), false, "check array bool");

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

@ -34,9 +34,9 @@ testRun(void)
{ {
List *list = lstNew(sizeof(void *)); List *list = lstNew(sizeof(void *));
TEST_RESULT_INT(list->itemSize, sizeof(void *), "item size"); TEST_RESULT_UINT(list->itemSize, sizeof(void *), "item size");
TEST_RESULT_INT(list->listSize, 0, "list size"); TEST_RESULT_UINT(list->listSize, 0, "list size");
TEST_RESULT_INT(list->listSizeMax, 0, "list size max"); TEST_RESULT_UINT(list->listSizeMax, 0, "list size max");
TEST_RESULT_PTR(lstMemContext(list), list->memContext, "list mem context"); TEST_RESULT_PTR(lstMemContext(list), list->memContext, "list mem context");
TEST_RESULT_VOID(lstClear(list), "clear list"); TEST_RESULT_VOID(lstClear(list), "clear list");

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

@ -27,10 +27,10 @@ testRun(void)
String *string = strNew("static string"); String *string = strNew("static string");
TEST_RESULT_STR_Z(string, "static string", "new with 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_BOOL(strEmpty(string), false, "is not empty");
TEST_RESULT_INT(strlen(strPtr(string)), 13, "check size with strlen()"); TEST_RESULT_UINT(strlen(strPtr(string)), 13, "check size with strlen()");
TEST_RESULT_CHAR(strPtr(string)[2], 'a', "check character"); TEST_RESULT_INT(strPtr(string)[2], 'a', "check character");
TEST_RESULT_VOID(strFree(string), "free string"); TEST_RESULT_VOID(strFree(string), "free string");
@ -93,11 +93,11 @@ testRun(void)
String *string2 = strNew("ZZZZ"); String *string2 = strNew("ZZZZ");
TEST_RESULT_STR_Z(strCat(string, "YYYY"), "XXXXYYYY", "cat string"); 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_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_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"); 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, '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_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"); 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(); 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 // Read them back and check values
// ------------------------------------------------------------------------------------------------------------------------- // -------------------------------------------------------------------------------------------------------------------------

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

@ -71,7 +71,7 @@ testRun(void)
TEST_RESULT_DOUBLE(varDblForce(varNewBool(false)), 0, "force bool to double"); 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(VARINT(123)), 123, "force int to double");
TEST_RESULT_DOUBLE(varDblForce(VARINT64(999999999999)), 999999999999, "force int64 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(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("879.01")), 879.01, "force String to double");
TEST_RESULT_DOUBLE(varDblForce(VARSTRDEF("0")), 0, "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); Variant *uint64 = varNewUInt64(44);
TEST_RESULT_DOUBLE(varUInt64(uint64), 44, "uint64 variant"); TEST_RESULT_UINT(varUInt64(uint64), 44, "uint64 variant");
TEST_RESULT_DOUBLE(varUInt64Force(uint64), 44, "force uint64 to uint64"); TEST_RESULT_UINT(varUInt64Force(uint64), 44, "force uint64 to uint64");
varFree(uint64); varFree(uint64);
// ------------------------------------------------------------------------------------------------------------------------- // -------------------------------------------------------------------------------------------------------------------------
TEST_RESULT_DOUBLE(varUInt64Force(varNewBool(true)), 1, "force bool to uint64"); TEST_RESULT_UINT(varUInt64Force(varNewBool(true)), 1, "force bool to uint64");
TEST_RESULT_DOUBLE(varUInt64Force(VARINT(2147483647)), 2147483647, "force int to uint64"); TEST_RESULT_UINT(varUInt64Force(VARINT(2147483647)), 2147483647, "force int to uint64");
TEST_RESULT_INT(varUInt64Force(VARUINT(4294967295)), 4294967295, "force uint to uint64"); TEST_RESULT_UINT(varUInt64Force(VARUINT(4294967295)), 4294967295, "force uint to uint64");
TEST_RESULT_DOUBLE(varUInt64Force(VARINT64(2147483647)), 2147483647, "force int64 to uint64"); TEST_RESULT_UINT(varUInt64Force(VARINT64(2147483647)), 2147483647, "force int64 to uint64");
TEST_RESULT_DOUBLE(varUInt64Force(varNewStrZ("18446744073709551615")), 18446744073709551615U, "force str to uint64"); TEST_RESULT_UINT(varUInt64Force(varNewStrZ("18446744073709551615")), 18446744073709551615U, "force str to uint64");
TEST_RESULT_DOUBLE(varUInt64Force(VARUINT64(18446744073709551615U)), 18446744073709551615U, "force uint64 to uint64"); TEST_RESULT_UINT(varUInt64Force(VARUINT64(18446744073709551615U)), 18446744073709551615U, "force uint64 to uint64");
TEST_ERROR( TEST_ERROR(
varUInt64Force(varNewStrZ("18446744073709551616")), FormatError, varUInt64Force(varNewStrZ("18446744073709551616")), FormatError,
@ -243,7 +243,7 @@ testRun(void)
TEST_ERROR(varUInt64(varNewStrZ("string")), AssertError, "assertion 'this->type == varTypeUInt64' failed"); 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"); TEST_RESULT_BOOL(varEq(NULL, NULL), true, "null, null eq");

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

@ -22,9 +22,9 @@ testRun(void)
TimeMSec begin = timeMSec(); TimeMSec begin = timeMSec();
TEST_ASSIGN(wait, waitNew(200), "new wait = 0.2 sec"); TEST_ASSIGN(wait, waitNew(200), "new wait = 0.2 sec");
TEST_RESULT_DOUBLE(wait->waitTime, 200, " check wait time"); TEST_RESULT_UINT(wait->waitTime, 200, " check wait time");
TEST_RESULT_DOUBLE(wait->sleepTime, 20, " check sleep time"); TEST_RESULT_UINT(wait->sleepTime, 20, " check sleep time");
TEST_RESULT_DOUBLE(wait->sleepPrevTime, 0, " check sleep prev time"); TEST_RESULT_UINT(wait->sleepPrevTime, 0, " check sleep prev time");
TEST_RESULT_BOOL(wait->beginTime > (TimeMSec)1483228800000, true, " check begin time"); TEST_RESULT_BOOL(wait->beginTime > (TimeMSec)1483228800000, true, " check begin time");
while (waitMore(wait)); while (waitMore(wait));
@ -40,9 +40,9 @@ testRun(void)
begin = timeMSec(); begin = timeMSec();
TEST_ASSIGN(wait, waitNew(1100), "new wait = 1.1 sec"); TEST_ASSIGN(wait, waitNew(1100), "new wait = 1.1 sec");
TEST_RESULT_DOUBLE(wait->waitTime, 1100, " check wait time"); TEST_RESULT_UINT(wait->waitTime, 1100, " check wait time");
TEST_RESULT_DOUBLE(wait->sleepTime, 100, " check sleep time"); TEST_RESULT_UINT(wait->sleepTime, 100, " check sleep time");
TEST_RESULT_DOUBLE(wait->sleepPrevTime, 0, " check sleep prev time"); TEST_RESULT_UINT(wait->sleepPrevTime, 0, " check sleep prev time");
TEST_RESULT_BOOL(wait->beginTime > (TimeMSec)1483228800000, true, " check begin time"); TEST_RESULT_BOOL(wait->beginTime > (TimeMSec)1483228800000, true, " check begin time");
while (waitMore(wait)); while (waitMore(wait));

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

@ -170,7 +170,7 @@ testRun(void)
TEST_RESULT_VOID( TEST_RESULT_VOID(
cfgOptionSet(cfgOptArchivePushQueueMax, cfgSourceParam, varNewInt64(999999999999)), "set archive-push-queue-max"); 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(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_VOID(cfgOptionSet(cfgOptProtocolTimeout, cfgSourceParam, varNewDbl(1.1)), "set protocol-timeout");
TEST_RESULT_DOUBLE(cfgOptionDbl(cfgOptProtocolTimeout), 1.1, "protocol-timeout is set"); TEST_RESULT_DOUBLE(cfgOptionDbl(cfgOptProtocolTimeout), 1.1, "protocol-timeout is set");

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

@ -400,7 +400,7 @@ testRun(void)
ioBufferSizeSet(333); ioBufferSizeSet(333);
TEST_RESULT_VOID(cfgLoad(strLstSize(argList), strLstPtr(argList)), "help command"); 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 // Help command for backup
// ------------------------------------------------------------------------------------------------------------------------- // -------------------------------------------------------------------------------------------------------------------------
@ -414,7 +414,7 @@ testRun(void)
strLstAdd(argList, strNew("--repo1-retention-full=2")); strLstAdd(argList, strNew("--repo1-retention-full=2"));
TEST_RESULT_VOID(cfgLoad(strLstSize(argList), strLstPtr(argList)), "help command for backup"); 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 // Command takes lock and opens log file
// ------------------------------------------------------------------------------------------------------------------------- // -------------------------------------------------------------------------------------------------------------------------

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

@ -121,7 +121,7 @@ testRun(void)
TEST_RESULT_INT(cfgOptionSource(cfgOptCompressLevel), cfgSourceConfig, " compress-level is source config"); TEST_RESULT_INT(cfgOptionSource(cfgOptCompressLevel), cfgSourceConfig, " compress-level is source config");
TEST_RESULT_BOOL(cfgOptionBool(cfgOptBackupStandby), false, " backup-standby not is set"); TEST_RESULT_BOOL(cfgOptionBool(cfgOptBackupStandby), false, " backup-standby not is set");
TEST_RESULT_INT(cfgOptionSource(cfgOptBackupStandby), cfgSourceDefault, " backup-standby is source default"); 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"); TEST_RESULT_INT(cfgOptionSource(cfgOptBufferSize), cfgSourceConfig, " backup-standby is source config");
// Rename conf files - ensure read of conf extension only is attempted // 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_INT(cfgOptionSource(cfgOptBackupStandby), cfgSourceDefault, " backup-standby is source default");
TEST_RESULT_BOOL(cfgOptionBool(cfgOptDelta), true, " delta is set"); TEST_RESULT_BOOL(cfgOptionBool(cfgOptDelta), true, " delta is set");
TEST_RESULT_INT(cfgOptionSource(cfgOptDelta), cfgSourceConfig, " delta is source config"); 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"); TEST_RESULT_INT(cfgOptionSource(cfgOptBufferSize), cfgSourceConfig, " backup-standby is source config");
unsetenv("PGBACKREST_BOGUS"); unsetenv("PGBACKREST_BOGUS");

2
test/src/module/info/infoArchiveTest.c
View File

@ -86,7 +86,7 @@ testRun(void)
TEST_RESULT_INT(infoPgDataTotal(info->infoPg), 2, " history incremented"); TEST_RESULT_INT(infoPgDataTotal(info->infoPg), 2, " history incremented");
TEST_ASSIGN(infoPgData, infoPgDataCurrent(info->infoPg), " get current infoPgData"); TEST_ASSIGN(infoPgData, infoPgDataCurrent(info->infoPg), " get current infoPgData");
TEST_RESULT_INT(infoPgData.version, PG_VERSION_94, " version set"); 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 // Free
// ------------------------------------------------------------------------------------------------------------------------- // -------------------------------------------------------------------------------------------------------------------------

18
test/src/module/info/infoBackupTest.c
View File

@ -90,7 +90,7 @@ testRun(void)
TEST_RESULT_INT(infoPgDataTotal(infoBackup->infoPg), 2, " history incremented"); TEST_RESULT_INT(infoPgDataTotal(infoBackup->infoPg), 2, " history incremented");
TEST_ASSIGN(infoPgData, infoPgDataCurrent(infoBackup->infoPg), " get current infoPgData"); TEST_ASSIGN(infoPgData, infoPgDataCurrent(infoBackup->infoPg), " get current infoPgData");
TEST_RESULT_INT(infoPgData.version, PG_VERSION_94, " version set"); 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 // Free
//-------------------------------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------------------------------
@ -146,10 +146,10 @@ testRun(void)
TEST_RESULT_STR_Z(backupData.backrestVersion, "2.04", " backrest version"); TEST_RESULT_STR_Z(backupData.backrestVersion, "2.04", " backrest version");
TEST_RESULT_STR_Z(backupData.backupArchiveStart, "00000007000000000000001C", " archive start"); TEST_RESULT_STR_Z(backupData.backupArchiveStart, "00000007000000000000001C", " archive start");
TEST_RESULT_STR_Z(backupData.backupArchiveStop, "00000007000000000000001C", " archive stop"); TEST_RESULT_STR_Z(backupData.backupArchiveStop, "00000007000000000000001C", " archive stop");
TEST_RESULT_INT(backupData.backupInfoRepoSize, 3159776, " repo size"); TEST_RESULT_UINT(backupData.backupInfoRepoSize, 3159776, " repo size");
TEST_RESULT_INT(backupData.backupInfoRepoSizeDelta, 3159776, " repo delta"); TEST_RESULT_UINT(backupData.backupInfoRepoSizeDelta, 3159776, " repo delta");
TEST_RESULT_INT(backupData.backupInfoSize, 26897030, " backup size"); TEST_RESULT_UINT(backupData.backupInfoSize, 26897030, " backup size");
TEST_RESULT_INT(backupData.backupInfoSizeDelta, 26897030, " backup delta"); TEST_RESULT_UINT(backupData.backupInfoSizeDelta, 26897030, " backup delta");
TEST_RESULT_INT(backupData.backupPgId, 1, " pg id"); TEST_RESULT_INT(backupData.backupPgId, 1, " pg id");
TEST_RESULT_PTR(backupData.backupPrior, NULL, " backup prior NULL"); TEST_RESULT_PTR(backupData.backupPrior, NULL, " backup prior NULL");
TEST_RESULT_PTR(backupData.backupReference, NULL, " backup reference NULL"); TEST_RESULT_PTR(backupData.backupReference, NULL, " backup reference NULL");
@ -159,10 +159,10 @@ testRun(void)
backupData = infoBackupData(infoBackup, 1); backupData = infoBackupData(infoBackup, 1);
TEST_RESULT_STR_Z(backupData.backupLabel, "20161219-212741F_20161219-212803D", "diff backup label"); 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_STR_Z(backupData.backupType, "diff", " backup type diff");
TEST_RESULT_INT(backupData.backupInfoRepoSize, 3159811, " repo size"); TEST_RESULT_UINT(backupData.backupInfoRepoSize, 3159811, " repo size");
TEST_RESULT_INT(backupData.backupInfoRepoSizeDelta, 15765, " repo delta"); TEST_RESULT_UINT(backupData.backupInfoRepoSizeDelta, 15765, " repo delta");
TEST_RESULT_INT(backupData.backupInfoSize, 26897030, " backup size"); TEST_RESULT_UINT(backupData.backupInfoSize, 26897030, " backup size");
TEST_RESULT_INT(backupData.backupInfoSizeDelta, 163866, " backup delta"); TEST_RESULT_UINT(backupData.backupInfoSizeDelta, 163866, " backup delta");
TEST_RESULT_STR_Z(backupData.backupPrior, "20161219-212741F", " backup prior exists"); TEST_RESULT_STR_Z(backupData.backupPrior, "20161219-212741F", " backup prior exists");
TEST_RESULT_BOOL( TEST_RESULT_BOOL(
(strLstSize(backupData.backupReference) == 1 && strLstExistsZ(backupData.backupReference, "20161219-212741F")), true, (strLstSize(backupData.backupReference) == 1 && strLstExistsZ(backupData.backupReference, "20161219-212741F")), true,

22
test/src/module/info/infoPgTest.c
View File

@ -53,8 +53,8 @@ testRun(void)
TEST_RESULT_INT(infoPgDataCurrentId(infoPg), 0, " 0 historyCurrent"); TEST_RESULT_INT(infoPgDataCurrentId(infoPg), 0, " 0 historyCurrent");
InfoPgData pgData = infoPgData(infoPg, infoPgDataCurrentId(infoPg)); InfoPgData pgData = infoPgData(infoPg, infoPgDataCurrentId(infoPg));
TEST_RESULT_INT(pgData.id, 1, " id set"); TEST_RESULT_INT(pgData.id, 1, " id set");
TEST_RESULT_INT(pgData.systemId, 6569239123849665679, " system-id set"); TEST_RESULT_UINT(pgData.systemId, 6569239123849665679, " system-id set");
TEST_RESULT_INT(pgData.version, PG_VERSION_94, " version set"); TEST_RESULT_UINT(pgData.version, PG_VERSION_94, " version set");
TEST_ASSIGN( TEST_ASSIGN(
infoPg, infoPgSet(infoPg, infoPgArchive, PG_VERSION_95, 6569239123849665999), "infoPgSet - infoPgArchive second db"); 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"); TEST_RESULT_INT(infoPgDataCurrentId(infoPg), 0, " 0 historyCurrent");
pgData = infoPgData(infoPg, infoPgDataCurrentId(infoPg)); pgData = infoPgData(infoPg, infoPgDataCurrentId(infoPg));
TEST_RESULT_INT(pgData.id, 2, " current id updated"); TEST_RESULT_INT(pgData.id, 2, " current id updated");
TEST_RESULT_INT(pgData.systemId, 6569239123849665999, " system-id updated"); TEST_RESULT_UINT(pgData.systemId, 6569239123849665999, " system-id updated");
TEST_RESULT_INT(pgData.version, PG_VERSION_95, " version updated"); TEST_RESULT_UINT(pgData.version, PG_VERSION_95, " version updated");
TEST_RESULT_STR(infoCipherPass(infoPgInfo(infoPg)), NULL, " cipherPass not set"); TEST_RESULT_STR(infoCipherPass(infoPgInfo(infoPg)), NULL, " cipherPass not set");
//-------------------------------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------------------------------
@ -74,8 +74,8 @@ testRun(void)
TEST_RESULT_INT(infoPgDataCurrentId(infoPg), 0, " 0 historyCurrent"); TEST_RESULT_INT(infoPgDataCurrentId(infoPg), 0, " 0 historyCurrent");
pgData = infoPgData(infoPg, infoPgDataCurrentId(infoPg)); pgData = infoPgData(infoPg, infoPgDataCurrentId(infoPg));
TEST_RESULT_INT(pgData.id, 1, " id set"); TEST_RESULT_INT(pgData.id, 1, " id set");
TEST_RESULT_INT(pgData.systemId, 6569239123849665679, " system-id set"); TEST_RESULT_UINT(pgData.systemId, 6569239123849665679, " system-id set");
TEST_RESULT_INT(pgData.version, PG_VERSION_94, " version set"); TEST_RESULT_UINT(pgData.version, PG_VERSION_94, " version set");
TEST_RESULT_STR_Z(infoCipherPass(infoPgInfo(infoPg)), "123xyz", " cipherPass set"); TEST_RESULT_STR_Z(infoCipherPass(infoPgInfo(infoPg)), "123xyz", " cipherPass set");
} }
@ -118,8 +118,8 @@ testRun(void)
InfoPgData pgData = infoPgDataCurrent(infoPg); InfoPgData pgData = infoPgDataCurrent(infoPg);
TEST_RESULT_INT(pgData.id, 1, " id set"); TEST_RESULT_INT(pgData.id, 1, " id set");
TEST_RESULT_INT(pgData.version, PG_VERSION_94, " version set"); TEST_RESULT_UINT(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");
TEST_RESULT_INT(infoPgDataTotal(infoPg), 1, " check pg data total"); 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_STR_Z(infoPgArchiveId(infoPg, 0), "9.4-1", " check pg archive id");
TEST_RESULT_PTR(infoPgCipherPass(infoPg), NULL, " no cipher passphrase"); TEST_RESULT_PTR(infoPgCipherPass(infoPg), NULL, " no cipher passphrase");
@ -164,12 +164,12 @@ testRun(void)
pgData = infoPgDataCurrent(infoPg); pgData = infoPgDataCurrent(infoPg);
TEST_RESULT_INT(pgData.id, 2, " id set"); TEST_RESULT_INT(pgData.id, 2, " id set");
TEST_RESULT_INT(pgData.version, PG_VERSION_95, " version 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); pgData = infoPgData(infoPg, 1);
TEST_RESULT_INT(pgData.id, 1, " id set"); TEST_RESULT_INT(pgData.id, 1, " id set");
TEST_RESULT_INT(pgData.version, PG_VERSION_94, " version 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); contentSave = bufNew(0);
@ -186,7 +186,7 @@ testRun(void)
InfoPgData pgDataTest = infoPgDataCurrent(infoPg); InfoPgData pgDataTest = infoPgDataCurrent(infoPg);
TEST_RESULT_INT(pgDataTest.id, 3, " id set"); TEST_RESULT_INT(pgDataTest.id, 3, " id set");
TEST_RESULT_INT(pgDataTest.version, PG_VERSION_96, " version 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 // infoPgDataToLog
//-------------------------------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------------------------------

6
test/src/module/info/manifestTest.c
View File

@ -1174,7 +1174,7 @@ testRun(void)
manifest->data.backupOptionOnline = true; manifest->data.backupOptionOnline = true;
TEST_RESULT_VOID(manifestBuildValidate(manifest, true, 1482182860, false), "validate manifest"); 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_BOOL(varBool(manifest->data.backupOptionDelta), true, "check delta");
TEST_RESULT_UINT(manifest->data.backupOptionCompressType, compressTypeNone, "check compress"); 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}); &(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_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_RESULT_BOOL(varBool(manifest->data.backupOptionDelta), false, "check delta");
// ------------------------------------------------------------------------------------------------------------------------- // -------------------------------------------------------------------------------------------------------------------------
TEST_TITLE("timestamp in future forces delta"); TEST_TITLE("timestamp in future forces delta");
TEST_RESULT_VOID(manifestBuildValidate(manifest, false, 1482182859, true), "validate manifest"); 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_BOOL(varBool(manifest->data.backupOptionDelta), true, "check delta");
TEST_RESULT_UINT(manifest->data.backupOptionCompressType, compressTypeGz, "check compress"); TEST_RESULT_UINT(manifest->data.backupOptionCompressType, compressTypeGz, "check compress");

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

@ -77,8 +77,8 @@ testRun(void)
PgControl info = {0}; PgControl info = {0};
TEST_ASSIGN(info, pgControlFromFile(storageTest), "get control info v11"); TEST_ASSIGN(info, pgControlFromFile(storageTest), "get control info v11");
TEST_RESULT_INT(info.systemId, 0xFACEFACE, " check system id"); TEST_RESULT_UINT(info.systemId, 0xFACEFACE, " check system id");
TEST_RESULT_INT(info.version, PG_VERSION_11, " check version"); TEST_RESULT_UINT(info.version, PG_VERSION_11, " check version");
//-------------------------------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------------------------------
storagePutP( storagePutP(
@ -101,8 +101,8 @@ testRun(void)
pgControlTestToBuffer((PgControl){.version = PG_VERSION_83, .systemId = 0xEFEFEFEFEF})); pgControlTestToBuffer((PgControl){.version = PG_VERSION_83, .systemId = 0xEFEFEFEFEF}));
TEST_ASSIGN(info, pgControlFromFile(storageTest), "get control info v83"); TEST_ASSIGN(info, pgControlFromFile(storageTest), "get control info v83");
TEST_RESULT_INT(info.systemId, 0xEFEFEFEFEF, " check system id"); TEST_RESULT_UINT(info.systemId, 0xEFEFEFEFEF, " check system id");
TEST_RESULT_INT(info.version, PG_VERSION_83, " check version"); TEST_RESULT_UINT(info.version, PG_VERSION_83, " check version");
} }
// ***************************************************************************************************************************** // *****************************************************************************************************************************
@ -184,8 +184,8 @@ testRun(void)
unsigned char page[PG_PAGE_SIZE_DEFAULT]; unsigned char page[PG_PAGE_SIZE_DEFAULT];
memset(page, 0xFF, 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(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, 999), 0x0EC3, "check 0xFF filled page, block 999");
} }
// ***************************************************************************************************************************** // *****************************************************************************************************************************
@ -223,8 +223,8 @@ testRun(void)
PgWal info = {0}; PgWal info = {0};
TEST_ASSIGN(info, pgWalFromFile(walFile), "get wal info v11"); TEST_ASSIGN(info, pgWalFromFile(walFile), "get wal info v11");
TEST_RESULT_INT(info.systemId, 0xECAFECAF, " check system id"); TEST_RESULT_UINT(info.systemId, 0xECAFECAF, " check system id");
TEST_RESULT_INT(info.version, PG_VERSION_11, " check version"); TEST_RESULT_UINT(info.version, PG_VERSION_11, " check version");
//-------------------------------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------------------------------
memset(bufPtr(result), 0, bufSize(result)); memset(bufPtr(result), 0, bufSize(result));
@ -232,8 +232,8 @@ testRun(void)
storagePutP(storageNewWriteP(storageTest, walFile), result); storagePutP(storageNewWriteP(storageTest, walFile), result);
TEST_ASSIGN(info, pgWalFromFile(walFile), "get wal info v8.3"); TEST_ASSIGN(info, pgWalFromFile(walFile), "get wal info v8.3");
TEST_RESULT_INT(info.systemId, 0xEAEAEAEA, " check system id"); TEST_RESULT_UINT(info.systemId, 0xEAEAEAEA, " check system id");
TEST_RESULT_INT(info.version, PG_VERSION_83, " check version"); TEST_RESULT_UINT(info.version, PG_VERSION_83, " check version");
} }
// ***************************************************************************************************************************** // *****************************************************************************************************************************

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

@ -200,9 +200,9 @@ testRun(void)
TEST_RESULT_PTR(info.name, NULL, " name is not set"); TEST_RESULT_PTR(info.name, NULL, " name is not set");
TEST_RESULT_BOOL(info.exists, true, " check exists"); TEST_RESULT_BOOL(info.exists, true, " check exists");
TEST_RESULT_INT(info.type, storageTypePath, " check type"); 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_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_PTR(info.linkDestination, NULL, " no link destination");
TEST_RESULT_UINT(info.userId, getuid(), " check user id"); TEST_RESULT_UINT(info.userId, getuid(), " check user id");
TEST_RESULT_STR_Z(info.user, testUser(), " check user"); 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_PTR(info.name, NULL, " name is not set");
TEST_RESULT_BOOL(info.exists, true, " check exists"); TEST_RESULT_BOOL(info.exists, true, " check exists");
TEST_RESULT_INT(info.type, storageTypeFile, " check type"); 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_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_PTR(info.linkDestination, NULL, " no link destination");
TEST_RESULT_STR(info.user, NULL, " check user"); TEST_RESULT_STR(info.user, NULL, " check user");
TEST_RESULT_STR(info.group, NULL, " check group"); 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_PTR(info.name, NULL, " name is not set");
TEST_RESULT_BOOL(info.exists, true, " check exists"); TEST_RESULT_BOOL(info.exists, true, " check exists");
TEST_RESULT_INT(info.type, storageTypeLink, " check type"); 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_INT(info.mode, 0777, " check mode");
TEST_RESULT_STR_Z(info.linkDestination, "/tmp", " check link destination"); TEST_RESULT_STR_Z(info.linkDestination, "/tmp", " check link destination");
TEST_RESULT_STR_Z(info.user, testUser(), " check user"); 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_PTR(info.name, NULL, " name is not set");
TEST_RESULT_BOOL(info.exists, true, " check exists"); TEST_RESULT_BOOL(info.exists, true, " check exists");
TEST_RESULT_INT(info.type, storageTypePath, " check type"); 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_INT(info.mode, 0777, " check mode");
TEST_RESULT_STR(info.linkDestination, NULL, " check link destination"); TEST_RESULT_STR(info.linkDestination, NULL, " check link destination");
TEST_RESULT_STR_Z(info.user, "root", " check user"); 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_PTR(info.name, NULL, " name is not set");
TEST_RESULT_BOOL(info.exists, true, " check exists"); TEST_RESULT_BOOL(info.exists, true, " check exists");
TEST_RESULT_INT(info.type, storageTypeSpecial, " check type"); 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_INT(info.mode, 0666, " check mode");
TEST_RESULT_STR(info.linkDestination, NULL, " check link destination"); TEST_RESULT_STR(info.linkDestination, NULL, " check link destination");
TEST_RESULT_STR_Z(info.user, testUser(), " check user"); 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, fileName), false, "destination file does not exist");
TEST_RESULT_BOOL(storageExistsP(storageTest, fileNameTmp), true, "destination tmp file exists"); 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()); 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_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_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_RESULT_BOOL(memcmp(bufPtr(buffer), "TESTFILE\n", bufSize(buffer)) == 0, true, "check content");
// ------------------------------------------------------------------------------------------------------------------------- // -------------------------------------------------------------------------------------------------------------------------
TEST_ASSIGN( TEST_ASSIGN(
buffer, storageGetP(storageNewReadP(storageTest, strNewFmt("%s/test.txt", testPath())), .exactSize = 4), "get exact"); 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_RESULT_BOOL(memcmp(bufPtr(buffer), "TEST", bufSize(buffer)) == 0, true, "check content");
TEST_ERROR_FMT( TEST_ERROR_FMT(
@ -809,7 +809,7 @@ testRun(void)
ioBufferSizeSet(2); ioBufferSizeSet(2);
TEST_ASSIGN(buffer, storageGetP(storageNewReadP(storageTest, strNewFmt("%s/test.txt", testPath()))), "get text"); 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_RESULT_BOOL(memcmp(bufPtr(buffer), "TESTFILE\n", bufSize(buffer)) == 0, true, "check content");
// ------------------------------------------------------------------------------------------------------------------------- // -------------------------------------------------------------------------------------------------------------------------
@ -819,7 +819,7 @@ testRun(void)
TEST_ASSIGN( TEST_ASSIGN(
buffer, storageGetP(storageNewReadP(storageTest, strNewFmt("%s/test.txt", testPath()), .limit = VARUINT64(7))), "get"); 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"); TEST_RESULT_BOOL(memcmp(bufPtr(buffer), "TESTFIL", bufSize(buffer)) == 0, true, "check content");
} }
@ -923,12 +923,12 @@ testRun(void)
bufUsedZero(outBuffer); bufUsedZero(outBuffer);
TEST_RESULT_VOID(ioRead(storageReadIo(file), outBuffer), " no data to load"); 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( TEST_RESULT_VOID(
storageReadPosix(storageRead(file), outBuffer, true), storageReadPosix(storageRead(file), outBuffer, true),
" no data to load from driver either"); " 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)"); TEST_RESULT_BOOL(bufEq(buffer, expectedBuffer), true, " check file contents (all loaded)");

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

@ -144,9 +144,9 @@ testRun(void)
TEST_RESULT_PTR(info.name, NULL, " name is not set"); TEST_RESULT_PTR(info.name, NULL, " name is not set");
TEST_RESULT_BOOL(info.exists, true, " check exists"); TEST_RESULT_BOOL(info.exists, true, " check exists");
TEST_RESULT_INT(info.type, storageTypePath, " check type"); 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_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_PTR(info.linkDestination, NULL, " no link destination");
TEST_RESULT_UINT(info.userId, getuid(), " check user id"); TEST_RESULT_UINT(info.userId, getuid(), " check user id");
TEST_RESULT_STR_Z(info.user, testUser(), " check user"); 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_PTR(info.name, NULL, " name is not set");
TEST_RESULT_BOOL(info.exists, true, " check exists"); TEST_RESULT_BOOL(info.exists, true, " check exists");
TEST_RESULT_INT(info.type, storageTypeFile, " check type"); 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_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_PTR(info.linkDestination, NULL, " no link destination");
TEST_RESULT_UINT(info.userId, getuid(), " check user id"); TEST_RESULT_UINT(info.userId, getuid(), " check user id");
TEST_RESULT_STR_Z(info.user, testUser(), " check user"); 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_PTR(info.name, NULL, " name is not set");
TEST_RESULT_BOOL(info.exists, true, " check exists"); TEST_RESULT_BOOL(info.exists, true, " check exists");
TEST_RESULT_INT(info.type, storageTypeSpecial, " check type"); 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_INT(info.mode, 0666, " check mode");
TEST_RESULT_PTR(info.linkDestination, NULL, " no link destination"); TEST_RESULT_PTR(info.linkDestination, NULL, " no link destination");
TEST_RESULT_UINT(info.userId, getuid(), " check user id"); 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_PTR(info.name, NULL, " name is not set");
TEST_RESULT_BOOL(info.exists, true, " check exists"); TEST_RESULT_BOOL(info.exists, true, " check exists");
TEST_RESULT_INT(info.type, storageTypeLink, " check type"); 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_INT(info.mode, 0777, " check mode");
TEST_RESULT_STR_Z(info.linkDestination, "../repo/test", " check link destination"); TEST_RESULT_STR_Z(info.linkDestination, "../repo/test", " check link destination");
TEST_RESULT_UINT(info.userId, getuid(), " check user id"); 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_PTR(info.name, NULL, " name is not set");
TEST_RESULT_BOOL(info.exists, true, " check exists"); TEST_RESULT_BOOL(info.exists, true, " check exists");
TEST_RESULT_INT(info.type, storageTypeFile, " check type"); 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_INT(info.mode, 0640, " check mode");
TEST_RESULT_PTR(info.linkDestination, NULL, " no link destination"); TEST_RESULT_PTR(info.linkDestination, NULL, " no link destination");
TEST_RESULT_UINT(info.userId, getuid(), " check user id"); 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(bufEq(storageGetP(fileRead), contentBuf), true, "get file");
TEST_RESULT_BOOL(storageReadIgnoreMissing(fileRead), false, "check ignore missing"); TEST_RESULT_BOOL(storageReadIgnoreMissing(fileRead), false, "check ignore missing");
TEST_RESULT_STR_Z(storageReadName(fileRead), hrnReplaceKey("{[path]}/repo/test.txt"), "check name"); 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, storageReadRemote(storageRead(fileRead), bufNew(32), false), 0,
"nothing more to read"); "nothing more to read");

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

@ -845,7 +845,7 @@ testRun(void)
TEST_RESULT_BOOL(info.exists, true, " check exists"); TEST_RESULT_BOOL(info.exists, true, " check exists");
TEST_RESULT_UINT(info.type, storageTypeFile, " check type"); TEST_RESULT_UINT(info.type, storageTypeFile, " check type");
TEST_RESULT_UINT(info.size, 9999, " check exists"); 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() // InfoList()
// ------------------------------------------------------------------------------------------------------------------------- // -------------------------------------------------------------------------------------------------------------------------
@ -862,7 +862,7 @@ testRun(void)
TEST_RESULT_UINT(testStorageInfoList[0].type, storageTypePath, " check type"); TEST_RESULT_UINT(testStorageInfoList[0].type, storageTypePath, " check type");
TEST_RESULT_STR_Z(testStorageInfoList[1].name, "test_file", " check name"); 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].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"); TEST_RESULT_UINT(testStorageInfoList[1].type, storageTypeFile, " check type");
// storageDriverList() // storageDriverList()