db/pgbackrest
1
0
Fork 0
mirror of https://github.com/pgbackrest/pgbackrest.git synced 2025-07-11 00:50:20 +02:00
Code Issues Releases Activity
Files
02aa03d1a266827b7ff5cb739b9598e475777086
pgbackrest/test/src/module/common/compressTest.c

180 lines
8.1 KiB
C
Raw Normal View History

Add gzip compression/decompression filters for C.
2018-08-14 14:56:59 -04:00
/***********************************************************************************************************************************
Rename "gzip" to "gz". "gz" was used as the extension but "gzip" was generally used for function and type naming. With a new compression format on the way, it makes sense to standardize on a single abbreviation to represent a compression format in the code. Since the extension is standard and we must use it, also use the extension for all naming.
2020-02-27 12:09:05 -05:00
Test Compression
Add gzip compression/decompression filters for C.
2018-08-14 14:56:59 -04:00
***********************************************************************************************************************************/
#include "common/io/filter/group.h"
#include "common/io/bufferRead.h"
#include "common/io/bufferWrite.h"
#include "common/io/io.h"
/***********************************************************************************************************************************
Compress data
***********************************************************************************************************************************/
static Buffer *
Improve type safety of interfaces and drivers. The function pointer casting used when creating drivers made changing interfaces difficult and led to slightly divergent driver implementations. Unit testing caught production-level errors but there were a lot of small issues and the process was harder than it should have been. Use void pointers instead so that no casts are required. Introduce the THIS_VOID and THIS() macros to make dealing with void pointers a little safer. Since we don't want to expose void pointers in header files, driver functions have been removed from the headers and the various driver objects return their interface type. This cuts down on accessor methods and the vast majority of those functions were not being used. Move functions that are still required to .intern.h. Remove the special "C" crypto functions that were used in libc and instead use the standard interface.
2019-05-02 17:52:24 -04:00
testCompress(IoFilter *compress, Buffer *decompressed, size_t inputSize, size_t outputSize)
Add gzip compression/decompression filters for C.
2018-08-14 14:56:59 -04:00
{
Buffer *compressed = bufNew(1024 * 1024);
size_t inputTotal = 0;
ioBufferSizeSet(outputSize);
Improve type safety of interfaces and drivers. The function pointer casting used when creating drivers made changing interfaces difficult and led to slightly divergent driver implementations. Unit testing caught production-level errors but there were a lot of small issues and the process was harder than it should have been. Use void pointers instead so that no casts are required. Introduce the THIS_VOID and THIS() macros to make dealing with void pointers a little safer. Since we don't want to expose void pointers in header files, driver functions have been removed from the headers and the various driver objects return their interface type. This cuts down on accessor methods and the vast majority of those functions were not being used. Move functions that are still required to .intern.h. Remove the special "C" crypto functions that were used in libc and instead use the standard interface.
2019-05-02 17:52:24 -04:00
IoWrite *write = ioBufferWriteNew(compressed);
Allow protocol compression when read/writing remote files. If the file is compressible (i.e. not encrypted or already compressed) it can be marked as such in storageNewRead()/storageNewWrite(). If the file is being read from/written to a remote it will be compressed in transit using gzip. Simplify filter group handling by having the IoRead/IoWrite objects create the filter group automatically. This removes the need for a lot of NULL checking and has a negligible effect on performance since a filter group needs to be created eventually unless the source file is missing. Allow filters to be created using a VariantList so filter parameters can be passed to the remote.
2019-06-24 10:20:47 -04:00
ioFilterGroupAdd(ioWriteFilterGroup(write), compress);
Add gzip compression/decompression filters for C.
2018-08-14 14:56:59 -04:00
ioWriteOpen(write);
// Compress input data
while (inputTotal < bufSize(decompressed))
{
// Generate the input buffer based on input size. This breaks the data up into chunks as it would be in a real scenario.
Buffer *input = bufNewC(
Various Buffer improvements. Add bufDup() and bufNewUsedC(). Arrange bufNewC() params to match bufNewUsedC() since they have always seemed backward. Fix bufHex() to only render the used portion of the buffer and fix some places where used was not being set correctly. Use a union to make macro assignments for all legal values without casting. This is much more likely to catch bad assignments.
2019-05-02 12:43:09 -04:00
bufPtr(decompressed) + inputTotal,
inputSize > bufSize(decompressed) - inputTotal ? bufSize(decompressed) - inputTotal : inputSize);
Add gzip compression/decompression filters for C.
2018-08-14 14:56:59 -04:00
ioWrite(write, input);
inputTotal += bufUsed(input);
bufFree(input);
}
ioWriteClose(write);
Rename "gzip" to "gz". "gz" was used as the extension but "gzip" was generally used for function and type naming. With a new compression format on the way, it makes sense to standardize on a single abbreviation to represent a compression format in the code. Since the extension is standard and we must use it, also use the extension for all naming.
2020-02-27 12:09:05 -05:00
memContextFree(((GzCompress *)ioFilterDriver(compress))->memContext);
Add gzip compression/decompression filters for C.
2018-08-14 14:56:59 -04:00
return compressed;
}
/***********************************************************************************************************************************
Decompress data
***********************************************************************************************************************************/
static Buffer *
Improve type safety of interfaces and drivers. The function pointer casting used when creating drivers made changing interfaces difficult and led to slightly divergent driver implementations. Unit testing caught production-level errors but there were a lot of small issues and the process was harder than it should have been. Use void pointers instead so that no casts are required. Introduce the THIS_VOID and THIS() macros to make dealing with void pointers a little safer. Since we don't want to expose void pointers in header files, driver functions have been removed from the headers and the various driver objects return their interface type. This cuts down on accessor methods and the vast majority of those functions were not being used. Move functions that are still required to .intern.h. Remove the special "C" crypto functions that were used in libc and instead use the standard interface.
2019-05-02 17:52:24 -04:00
testDecompress(IoFilter *decompress, Buffer *compressed, size_t inputSize, size_t outputSize)
Add gzip compression/decompression filters for C.
2018-08-14 14:56:59 -04:00
{
Buffer *decompressed = bufNew(1024 * 1024);
Buffer *output = bufNew(outputSize);
ioBufferSizeSet(inputSize);
Improve type safety of interfaces and drivers. The function pointer casting used when creating drivers made changing interfaces difficult and led to slightly divergent driver implementations. Unit testing caught production-level errors but there were a lot of small issues and the process was harder than it should have been. Use void pointers instead so that no casts are required. Introduce the THIS_VOID and THIS() macros to make dealing with void pointers a little safer. Since we don't want to expose void pointers in header files, driver functions have been removed from the headers and the various driver objects return their interface type. This cuts down on accessor methods and the vast majority of those functions were not being used. Move functions that are still required to .intern.h. Remove the special "C" crypto functions that were used in libc and instead use the standard interface.
2019-05-02 17:52:24 -04:00
IoRead *read = ioBufferReadNew(compressed);
Allow protocol compression when read/writing remote files. If the file is compressible (i.e. not encrypted or already compressed) it can be marked as such in storageNewRead()/storageNewWrite(). If the file is being read from/written to a remote it will be compressed in transit using gzip. Simplify filter group handling by having the IoRead/IoWrite objects create the filter group automatically. This removes the need for a lot of NULL checking and has a negligible effect on performance since a filter group needs to be created eventually unless the source file is missing. Allow filters to be created using a VariantList so filter parameters can be passed to the remote.
2019-06-24 10:20:47 -04:00
ioFilterGroupAdd(ioReadFilterGroup(read), decompress);
Add gzip compression/decompression filters for C.
2018-08-14 14:56:59 -04:00
ioReadOpen(read);
while (!ioReadEof(read))
{
ioRead(read, output);
bufCat(decompressed, output);
bufUsedZero(output);
}
ioReadClose(read);
bufFree(output);
Rename "gzip" to "gz". "gz" was used as the extension but "gzip" was generally used for function and type naming. With a new compression format on the way, it makes sense to standardize on a single abbreviation to represent a compression format in the code. Since the extension is standard and we must use it, also use the extension for all naming.
2020-02-27 12:09:05 -05:00
memContextFree(((GzDecompress *)ioFilterDriver(decompress))->memContext);
Add gzip compression/decompression filters for C.
2018-08-14 14:56:59 -04:00
return decompressed;
}
/***********************************************************************************************************************************
Test Run
***********************************************************************************************************************************/
void
testRun(void)
{
FUNCTION_HARNESS_VOID();
// *****************************************************************************************************************************
Rename "gzip" to "gz". "gz" was used as the extension but "gzip" was generally used for function and type naming. With a new compression format on the way, it makes sense to standardize on a single abbreviation to represent a compression format in the code. Since the extension is standard and we must use it, also use the extension for all naming.
2020-02-27 12:09:05 -05:00
if (testBegin("gzError"))
Add gzip compression/decompression filters for C.
2018-08-14 14:56:59 -04:00
{
Rename "gzip" to "gz". "gz" was used as the extension but "gzip" was generally used for function and type naming. With a new compression format on the way, it makes sense to standardize on a single abbreviation to represent a compression format in the code. Since the extension is standard and we must use it, also use the extension for all naming.
2020-02-27 12:09:05 -05:00
TEST_RESULT_INT(gzError(Z_OK), Z_OK, "check ok");
TEST_RESULT_INT(gzError(Z_STREAM_END), Z_STREAM_END, "check stream end");
TEST_ERROR(gzError(Z_NEED_DICT), AssertError, "zlib threw error: [2] need dictionary");
TEST_ERROR(gzError(Z_ERRNO), AssertError, "zlib threw error: [-1] file error");
TEST_ERROR(gzError(Z_STREAM_ERROR), FormatError, "zlib threw error: [-2] stream error");
TEST_ERROR(gzError(Z_DATA_ERROR), FormatError, "zlib threw error: [-3] data error");
TEST_ERROR(gzError(Z_MEM_ERROR), MemoryError, "zlib threw error: [-4] insufficient memory");
TEST_ERROR(gzError(Z_BUF_ERROR), AssertError, "zlib threw error: [-5] no space in buffer");
TEST_ERROR(gzError(Z_VERSION_ERROR), FormatError, "zlib threw error: [-6] incompatible version");
TEST_ERROR(gzError(999), AssertError, "zlib threw error: [999] unknown error");
Add gzip compression/decompression filters for C.
2018-08-14 14:56:59 -04:00
}
// *****************************************************************************************************************************
Rename "gzip" to "gz". "gz" was used as the extension but "gzip" was generally used for function and type naming. With a new compression format on the way, it makes sense to standardize on a single abbreviation to represent a compression format in the code. Since the extension is standard and we must use it, also use the extension for all naming.
2020-02-27 12:09:05 -05:00
if (testBegin("GzCompress and GzDecompress"))
Add gzip compression/decompression filters for C.
2018-08-14 14:56:59 -04:00
{
const char *simpleData = "A simple string";
Buffer *compressed = NULL;
Various Buffer improvements. Add bufDup() and bufNewUsedC(). Arrange bufNewC() params to match bufNewUsedC() since they have always seemed backward. Fix bufHex() to only render the used portion of the buffer and fix some places where used was not being set correctly. Use a union to make macro assignments for all legal values without casting. This is much more likely to catch bad assignments.
2019-05-02 12:43:09 -04:00
Buffer *decompressed = bufNewC(simpleData, strlen(simpleData));
Add gzip compression/decompression filters for C.
2018-08-14 14:56:59 -04:00
Allow protocol compression when read/writing remote files. If the file is compressible (i.e. not encrypted or already compressed) it can be marked as such in storageNewRead()/storageNewWrite(). If the file is being read from/written to a remote it will be compressed in transit using gzip. Simplify filter group handling by having the IoRead/IoWrite objects create the filter group automatically. This removes the need for a lot of NULL checking and has a negligible effect on performance since a filter group needs to be created eventually unless the source file is missing. Allow filters to be created using a VariantList so filter parameters can be passed to the remote.
2019-06-24 10:20:47 -04:00
VariantList *compressParamList = varLstNew();
varLstAdd(compressParamList, varNewUInt(3));
varLstAdd(compressParamList, varNewBool(false));
Add gzip compression/decompression filters for C.
2018-08-14 14:56:59 -04:00
TEST_ASSIGN(
Rename "gzip" to "gz". "gz" was used as the extension but "gzip" was generally used for function and type naming. With a new compression format on the way, it makes sense to standardize on a single abbreviation to represent a compression format in the code. Since the extension is standard and we must use it, also use the extension for all naming.
2020-02-27 12:09:05 -05:00
compressed, testCompress(gzCompressNewVar(compressParamList), decompressed, 1024, 1024),
Add gzip compression/decompression filters for C.
2018-08-14 14:56:59 -04:00
"simple data - compress large in/large out buffer");
TEST_RESULT_BOOL(
Remove raw option for gz compression. This was a minor optimization used in protocol layer compression. Even though it was slightly faster, it omitted the crc-32 that is generated during normal compression which could lead to corrupt data after a bad network transmission. This would be caught on restore by our checksum but it seems better to catch an issue like this early. The raw option also made the function signature different than future compression formats which may not support raw, or require different code to support raw. In general, it doesn't seem worth the extra testing to support a format that has minimal benefit and is seldom used, since protocol compression is only enabled when the transmitted data is uncompressed.
2020-02-27 12:19:40 -05:00
bufEq(compressed, testCompress(gzCompressNew(3), decompressed, 1024, 1)), true,
Add gzip compression/decompression filters for C.
2018-08-14 14:56:59 -04:00
"simple data - compress large in/small out buffer");
TEST_RESULT_BOOL(
Remove raw option for gz compression. This was a minor optimization used in protocol layer compression. Even though it was slightly faster, it omitted the crc-32 that is generated during normal compression which could lead to corrupt data after a bad network transmission. This would be caught on restore by our checksum but it seems better to catch an issue like this early. The raw option also made the function signature different than future compression formats which may not support raw, or require different code to support raw. In general, it doesn't seem worth the extra testing to support a format that has minimal benefit and is seldom used, since protocol compression is only enabled when the transmitted data is uncompressed.
2020-02-27 12:19:40 -05:00
bufEq(compressed, testCompress(gzCompressNew(3), decompressed, 1, 1024)), true,
Add gzip compression/decompression filters for C.
2018-08-14 14:56:59 -04:00
"simple data - compress small in/large out buffer");
TEST_RESULT_BOOL(
Remove raw option for gz compression. This was a minor optimization used in protocol layer compression. Even though it was slightly faster, it omitted the crc-32 that is generated during normal compression which could lead to corrupt data after a bad network transmission. This would be caught on restore by our checksum but it seems better to catch an issue like this early. The raw option also made the function signature different than future compression formats which may not support raw, or require different code to support raw. In general, it doesn't seem worth the extra testing to support a format that has minimal benefit and is seldom used, since protocol compression is only enabled when the transmitted data is uncompressed.
2020-02-27 12:19:40 -05:00
bufEq(compressed, testCompress(gzCompressNew(3), decompressed, 1, 1)), true,
Add gzip compression/decompression filters for C.
2018-08-14 14:56:59 -04:00
"simple data - compress small in/small out buffer");
TEST_RESULT_BOOL(
Remove raw option for gz compression. This was a minor optimization used in protocol layer compression. Even though it was slightly faster, it omitted the crc-32 that is generated during normal compression which could lead to corrupt data after a bad network transmission. This would be caught on restore by our checksum but it seems better to catch an issue like this early. The raw option also made the function signature different than future compression formats which may not support raw, or require different code to support raw. In general, it doesn't seem worth the extra testing to support a format that has minimal benefit and is seldom used, since protocol compression is only enabled when the transmitted data is uncompressed.
2020-02-27 12:19:40 -05:00
bufEq(decompressed, testDecompress(gzDecompressNew(), compressed, 1024, 1024)), true,
Add gzip compression/decompression filters for C.
2018-08-14 14:56:59 -04:00
"simple data - decompress large in/large out buffer");
TEST_RESULT_BOOL(
Remove raw option for gz compression. This was a minor optimization used in protocol layer compression. Even though it was slightly faster, it omitted the crc-32 that is generated during normal compression which could lead to corrupt data after a bad network transmission. This would be caught on restore by our checksum but it seems better to catch an issue like this early. The raw option also made the function signature different than future compression formats which may not support raw, or require different code to support raw. In general, it doesn't seem worth the extra testing to support a format that has minimal benefit and is seldom used, since protocol compression is only enabled when the transmitted data is uncompressed.
2020-02-27 12:19:40 -05:00
bufEq(decompressed, testDecompress(gzDecompressNew(), compressed, 1024, 1)), true,
Add gzip compression/decompression filters for C.
2018-08-14 14:56:59 -04:00
"simple data - decompress large in/small out buffer");
TEST_RESULT_BOOL(
Remove raw option for gz compression. This was a minor optimization used in protocol layer compression. Even though it was slightly faster, it omitted the crc-32 that is generated during normal compression which could lead to corrupt data after a bad network transmission. This would be caught on restore by our checksum but it seems better to catch an issue like this early. The raw option also made the function signature different than future compression formats which may not support raw, or require different code to support raw. In general, it doesn't seem worth the extra testing to support a format that has minimal benefit and is seldom used, since protocol compression is only enabled when the transmitted data is uncompressed.
2020-02-27 12:19:40 -05:00
bufEq(decompressed, testDecompress(gzDecompressNew(), compressed, 1, 1024)), true,
Add gzip compression/decompression filters for C.
2018-08-14 14:56:59 -04:00
"simple data - decompress small in/large out buffer");
TEST_RESULT_BOOL(
Remove raw option for gz compression. This was a minor optimization used in protocol layer compression. Even though it was slightly faster, it omitted the crc-32 that is generated during normal compression which could lead to corrupt data after a bad network transmission. This would be caught on restore by our checksum but it seems better to catch an issue like this early. The raw option also made the function signature different than future compression formats which may not support raw, or require different code to support raw. In general, it doesn't seem worth the extra testing to support a format that has minimal benefit and is seldom used, since protocol compression is only enabled when the transmitted data is uncompressed.
2020-02-27 12:19:40 -05:00
bufEq(decompressed, testDecompress(gzDecompressNew(), compressed, 1, 1)), true,
Add gzip compression/decompression filters for C.
2018-08-14 14:56:59 -04:00
"simple data - decompress small in/small out buffer");
Fix segfault on unexpected EOF in gzip decompression. If the compressed stream terminated early then the decompression process would get a flush request (NULL input buffer) since the filter was not marked as done. This could happen on a zero-length or truncated (i.e. invalid) compressed file. Change the existing assertion to an error to catch this condition in production gracefully.
2019-12-11 08:48:46 -05:00
// -------------------------------------------------------------------------------------------------------------------------
TEST_TITLE("error on no compression data");
Remove raw option for gz compression. This was a minor optimization used in protocol layer compression. Even though it was slightly faster, it omitted the crc-32 that is generated during normal compression which could lead to corrupt data after a bad network transmission. This would be caught on restore by our checksum but it seems better to catch an issue like this early. The raw option also made the function signature different than future compression formats which may not support raw, or require different code to support raw. In general, it doesn't seem worth the extra testing to support a format that has minimal benefit and is seldom used, since protocol compression is only enabled when the transmitted data is uncompressed.
2020-02-27 12:19:40 -05:00
TEST_ERROR(testDecompress(gzDecompressNew(), bufNew(0), 1, 1), FormatError, "unexpected eof in compressed data");
Fix segfault on unexpected EOF in gzip decompression. If the compressed stream terminated early then the decompression process would get a flush request (NULL input buffer) since the filter was not marked as done. This could happen on a zero-length or truncated (i.e. invalid) compressed file. Change the existing assertion to an error to catch this condition in production gracefully.
2019-12-11 08:48:46 -05:00
// -------------------------------------------------------------------------------------------------------------------------
TEST_TITLE("error on truncated compression data");
Buffer *truncated = bufNew(0);
bufCatSub(truncated, compressed, 0, bufUsed(compressed) - 1);
TEST_RESULT_UINT(bufUsed(truncated), bufUsed(compressed) - 1, "check truncated buffer size");
Remove raw option for gz compression. This was a minor optimization used in protocol layer compression. Even though it was slightly faster, it omitted the crc-32 that is generated during normal compression which could lead to corrupt data after a bad network transmission. This would be caught on restore by our checksum but it seems better to catch an issue like this early. The raw option also made the function signature different than future compression formats which may not support raw, or require different code to support raw. In general, it doesn't seem worth the extra testing to support a format that has minimal benefit and is seldom used, since protocol compression is only enabled when the transmitted data is uncompressed.
2020-02-27 12:19:40 -05:00
TEST_ERROR(testDecompress(gzDecompressNew(), truncated, 512, 512), FormatError, "unexpected eof in compressed data");
Fix segfault on unexpected EOF in gzip decompression. If the compressed stream terminated early then the decompression process would get a flush request (NULL input buffer) since the filter was not marked as done. This could happen on a zero-length or truncated (i.e. invalid) compressed file. Change the existing assertion to an error to catch this condition in production gracefully.
2019-12-11 08:48:46 -05:00
Add gzip compression/decompression filters for C.
2018-08-14 14:56:59 -04:00
// Compress a large zero input buffer into small output buffer
// -------------------------------------------------------------------------------------------------------------------------
decompressed = bufNew(1024 * 1024 - 1);
memset(bufPtr(decompressed), 0, bufSize(decompressed));
bufUsedSet(decompressed, bufSize(decompressed));
TEST_ASSIGN(
Remove raw option for gz compression. This was a minor optimization used in protocol layer compression. Even though it was slightly faster, it omitted the crc-32 that is generated during normal compression which could lead to corrupt data after a bad network transmission. This would be caught on restore by our checksum but it seems better to catch an issue like this early. The raw option also made the function signature different than future compression formats which may not support raw, or require different code to support raw. In general, it doesn't seem worth the extra testing to support a format that has minimal benefit and is seldom used, since protocol compression is only enabled when the transmitted data is uncompressed.
2020-02-27 12:19:40 -05:00
compressed, testCompress(gzCompressNew(3), decompressed, bufSize(decompressed), 1024),
Add gzip compression/decompression filters for C.
2018-08-14 14:56:59 -04:00
"zero data - compress large in/small out buffer");
TEST_RESULT_BOOL(
Remove raw option for gz compression. This was a minor optimization used in protocol layer compression. Even though it was slightly faster, it omitted the crc-32 that is generated during normal compression which could lead to corrupt data after a bad network transmission. This would be caught on restore by our checksum but it seems better to catch an issue like this early. The raw option also made the function signature different than future compression formats which may not support raw, or require different code to support raw. In general, it doesn't seem worth the extra testing to support a format that has minimal benefit and is seldom used, since protocol compression is only enabled when the transmitted data is uncompressed.
2020-02-27 12:19:40 -05:00
bufEq(decompressed, testDecompress(gzDecompressNew(), compressed, bufSize(compressed), 1024 * 256)), true,
Add gzip compression/decompression filters for C.
2018-08-14 14:56:59 -04:00
"zero data - decompress large in/small out buffer");
}
// *****************************************************************************************************************************
Rename "gzip" to "gz". "gz" was used as the extension but "gzip" was generally used for function and type naming. With a new compression format on the way, it makes sense to standardize on a single abbreviation to represent a compression format in the code. Since the extension is standard and we must use it, also use the extension for all naming.
2020-02-27 12:09:05 -05:00
if (testBegin("gzDecompressToLog() and gzCompressToLog()"))
Add gzip compression/decompression filters for C.
2018-08-14 14:56:59 -04:00
{
Remove raw option for gz compression. This was a minor optimization used in protocol layer compression. Even though it was slightly faster, it omitted the crc-32 that is generated during normal compression which could lead to corrupt data after a bad network transmission. This would be caught on restore by our checksum but it seems better to catch an issue like this early. The raw option also made the function signature different than future compression formats which may not support raw, or require different code to support raw. In general, it doesn't seem worth the extra testing to support a format that has minimal benefit and is seldom used, since protocol compression is only enabled when the transmitted data is uncompressed.
2020-02-27 12:19:40 -05:00
GzDecompress *decompress = (GzDecompress *)ioFilterDriver(gzDecompressNew());
Add gzip compression/decompression filters for C.
2018-08-14 14:56:59 -04:00
Rename "gzip" to "gz". "gz" was used as the extension but "gzip" was generally used for function and type naming. With a new compression format on the way, it makes sense to standardize on a single abbreviation to represent a compression format in the code. Since the extension is standard and we must use it, also use the extension for all naming.
2020-02-27 12:09:05 -05:00
TEST_RESULT_STR_Z(gzDecompressToLog(decompress), "{inputSame: false, done: false, availIn: 0}", "format object");
Add gzip compression/decompression filters for C.
2018-08-14 14:56:59 -04:00
decompress->inputSame = true;
decompress->done = true;
Rename "gzip" to "gz". "gz" was used as the extension but "gzip" was generally used for function and type naming. With a new compression format on the way, it makes sense to standardize on a single abbreviation to represent a compression format in the code. Since the extension is standard and we must use it, also use the extension for all naming.
2020-02-27 12:09:05 -05:00
TEST_RESULT_STR_Z(gzDecompressToLog(decompress), "{inputSame: true, done: true, availIn: 0}", "format object");
Add gzip compression/decompression filters for C.
2018-08-14 14:56:59 -04:00
}
FUNCTION_HARNESS_RESULT_VOID();
}
Reference in New Issue Copy Permalink