mirror of
https://github.com/lz4/lz4.git
synced 2024-11-24 18:33:50 +08:00
added low address fuzzer tests
This commit is contained in:
test4973
parent
20e969e579
commit
c3f0ed28ff
@ -35,7 +35,8 @@ PRGDIR := ../programs
|
||||
TESTDIR := versionsTest
|
||||
PYTHON ?= python3
|
||||
|
||||
DEBUGFLAGS = -g -DLZ4_DEBUG=1
|
||||
DEBUGLEVEL?= 1
|
||||
DEBUGFLAGS = -g -DLZ4_DEBUG=$(DEBUGLEVEL)
|
||||
CFLAGS ?= -O3 # can select custom optimization flags. For example : CFLAGS=-O2 make
|
||||
CFLAGS += -Wall -Wextra -Wundef -Wcast-qual -Wcast-align -Wshadow \
|
||||
-Wswitch-enum -Wdeclaration-after-statement -Wstrict-prototypes \
|
||||
|
||||
113
tests/fuzzer.c
113
tests/fuzzer.c
@ -34,9 +34,13 @@
|
||||
|
||||
#define LZ4_DISABLE_DEPRECATE_WARNINGS
|
||||
|
||||
|
||||
/*-************************************
|
||||
* Dependencies
|
||||
**************************************/
|
||||
#ifdef __unix__ /* must be included before platform.h for MAP_ANONYMOUS */
|
||||
# include <sys/mman.h> /* mmap */
|
||||
#endif
|
||||
#include "platform.h" /* _CRT_SECURE_NO_WARNINGS */
|
||||
#include "util.h" /* U32 */
|
||||
#include <stdlib.h>
|
||||
@ -242,8 +246,6 @@ _overflowError:
|
||||
|
||||
#ifdef __unix__ /* is expected to be triggered on linux+gcc */
|
||||
|
||||
#include <sys/mman.h> /* mmap */
|
||||
|
||||
static void* FUZ_createLowAddr(size_t size)
|
||||
{
|
||||
void* const lowBuff = mmap((void*)(0x1000), size,
|
||||
@ -276,6 +278,7 @@ static void FUZ_freeLowAddr(void* buffer, size_t size)
|
||||
|
||||
#endif
|
||||
|
||||
|
||||
/*! FUZ_findDiff() :
|
||||
* find the first different byte between buff1 and buff2.
|
||||
* presumes buff1 != buff2.
|
||||
@ -316,10 +319,18 @@ static int FUZ_test(U32 seed, U32 nbCycles, const U32 startCycle, const double c
|
||||
|
||||
# define FUZ_CHECKTEST(cond, ...) if (cond) { printf("Test %u : ", testNb); printf(__VA_ARGS__); \
|
||||
printf(" (seed %u, cycle %u) \n", seed, cycleNb); goto _output_error; }
|
||||
# define FUZ_DISPLAYTEST { testNb++; g_displayLevel>=4 ? printf("%2u\b\b", testNb), fflush(stdout) : 0; }
|
||||
# define FUZ_DISPLAYTEST(...) { \
|
||||
testNb++; \
|
||||
if (g_displayLevel>=4) { \
|
||||
printf("\r%4u - %2u ", seed, testNb); \
|
||||
printf(" " __VA_ARGS__); \
|
||||
printf(" "); \
|
||||
fflush(stdout); \
|
||||
} }
|
||||
|
||||
|
||||
/* init */
|
||||
DISPLAYLEVEL(2, " g_displayLevel = %u \n", g_displayLevel);
|
||||
if(!CNBuffer || !compressedBuffer || !decodedBuffer) {
|
||||
DISPLAY("Not enough memory to start fuzzer tests");
|
||||
goto _output_error;
|
||||
@ -362,7 +373,7 @@ static int FUZ_test(U32 seed, U32 nbCycles, const U32 startCycle, const double c
|
||||
}
|
||||
|
||||
/* Test compression destSize */
|
||||
FUZ_DISPLAYTEST;
|
||||
FUZ_DISPLAYTEST("test LZ4_compress_destSize()");
|
||||
{ int srcSize = blockSize;
|
||||
int const targetSize = srcSize * ((FUZ_rand(&randState) & 127)+1) >> 7;
|
||||
char endCheck = FUZ_rand(&randState) & 255;
|
||||
@ -377,7 +388,7 @@ static int FUZ_test(U32 seed, U32 nbCycles, const U32 startCycle, const double c
|
||||
U32 const crcBase = XXH32(block, srcSize, 0);
|
||||
char const canary = FUZ_rand(&randState) & 255;
|
||||
FUZ_CHECKTEST((ret==0), "LZ4_compress_destSize() compression failed");
|
||||
FUZ_DISPLAYTEST;
|
||||
FUZ_DISPLAYTEST();
|
||||
compressedSize = ret;
|
||||
decodedBuffer[srcSize] = canary;
|
||||
ret = LZ4_decompress_safe(compressedBuffer, decodedBuffer, compressedSize, srcSize);
|
||||
@ -393,7 +404,7 @@ static int FUZ_test(U32 seed, U32 nbCycles, const U32 startCycle, const double c
|
||||
} }
|
||||
|
||||
/* Test compression HC destSize */
|
||||
FUZ_DISPLAYTEST;
|
||||
FUZ_DISPLAYTEST("test LZ4_compress_HC_destSize()");
|
||||
{ int srcSize = blockSize;
|
||||
int const targetSize = srcSize * ((FUZ_rand(&randState) & 127)+1) >> 7;
|
||||
char const endCheck = FUZ_rand(&randState) & 255;
|
||||
@ -407,14 +418,12 @@ static int FUZ_test(U32 seed, U32 nbCycles, const U32 startCycle, const double c
|
||||
FUZ_CHECKTEST(ret > targetSize, "LZ4_compress_HC_destSize() result larger than dst buffer !");
|
||||
FUZ_CHECKTEST(compressedBuffer[targetSize] != endCheck, "LZ4_compress_HC_destSize() overwrite dst buffer !");
|
||||
FUZ_CHECKTEST(srcSize > blockSize, "LZ4_compress_HC_destSize() fed more than src buffer !");
|
||||
DISPLAYLEVEL(5, "LZ4_compress_HC_destSize(%i): destSize : %7i/%7i; content%7i/%7i ",
|
||||
compressionLevel, ret, targetSize, srcSize, blockSize);
|
||||
if (targetSize>0) {
|
||||
/* check correctness */
|
||||
U32 const crcBase = XXH32(block, srcSize, 0);
|
||||
char const canary = FUZ_rand(&randState) & 255;
|
||||
FUZ_CHECKTEST((ret==0), "LZ4_compress_HC_destSize() compression failed");
|
||||
FUZ_DISPLAYTEST;
|
||||
FUZ_DISPLAYTEST();
|
||||
compressedSize = ret;
|
||||
decodedBuffer[srcSize] = canary;
|
||||
ret = LZ4_decompress_safe(compressedBuffer, decodedBuffer, compressedSize, srcSize);
|
||||
@ -430,31 +439,31 @@ static int FUZ_test(U32 seed, U32 nbCycles, const U32 startCycle, const double c
|
||||
} }
|
||||
|
||||
/* Test compression HC */
|
||||
FUZ_DISPLAYTEST;
|
||||
FUZ_DISPLAYTEST("test LZ4_compress_HC()");
|
||||
ret = LZ4_compress_HC(block, compressedBuffer, blockSize, (int)compressedBufferSize, compressionLevel);
|
||||
FUZ_CHECKTEST(ret==0, "LZ4_compress_HC() failed");
|
||||
HCcompressedSize = ret;
|
||||
|
||||
/* Test compression HC using external state */
|
||||
FUZ_DISPLAYTEST;
|
||||
FUZ_DISPLAYTEST("test LZ4_compress_HC_extStateHC()");
|
||||
ret = LZ4_compress_HC_extStateHC(stateLZ4HC, block, compressedBuffer, blockSize, (int)compressedBufferSize, compressionLevel);
|
||||
FUZ_CHECKTEST(ret==0, "LZ4_compress_HC_extStateHC() failed");
|
||||
|
||||
/* Test compression using external state */
|
||||
FUZ_DISPLAYTEST;
|
||||
FUZ_DISPLAYTEST("test LZ4_compress_fast_extState()");
|
||||
ret = LZ4_compress_fast_extState(stateLZ4, block, compressedBuffer, blockSize, (int)compressedBufferSize, 8);
|
||||
FUZ_CHECKTEST(ret==0, "LZ4_compress_fast_extState() failed");
|
||||
|
||||
/* Test compression */
|
||||
FUZ_DISPLAYTEST;
|
||||
FUZ_DISPLAYTEST("test LZ4_compress_default()");
|
||||
ret = LZ4_compress_default(block, compressedBuffer, blockSize, (int)compressedBufferSize);
|
||||
FUZ_CHECKTEST(ret==0, "LZ4_compress_default() failed");
|
||||
compressedSize = ret;
|
||||
|
||||
/* Decompression tests */
|
||||
|
||||
/* Test decoding with output size being exactly what's necessary => must work */
|
||||
FUZ_DISPLAYTEST;
|
||||
/* Test decoding with output size exactly correct => must work */
|
||||
FUZ_DISPLAYTEST("LZ4_decompress_fast() with exact output buffer");
|
||||
ret = LZ4_decompress_fast(compressedBuffer, decodedBuffer, blockSize);
|
||||
FUZ_CHECKTEST(ret<0, "LZ4_decompress_fast failed despite correct space");
|
||||
FUZ_CHECKTEST(ret!=compressedSize, "LZ4_decompress_fast failed : did not fully read compressed data");
|
||||
@ -462,19 +471,19 @@ static int FUZ_test(U32 seed, U32 nbCycles, const U32 startCycle, const double c
|
||||
FUZ_CHECKTEST(crcCheck!=crcOrig, "LZ4_decompress_fast corrupted decoded data");
|
||||
|
||||
/* Test decoding with one byte missing => must fail */
|
||||
FUZ_DISPLAYTEST;
|
||||
FUZ_DISPLAYTEST("LZ4_decompress_fast() with output buffer 1-byte too short");
|
||||
decodedBuffer[blockSize-1] = 0;
|
||||
ret = LZ4_decompress_fast(compressedBuffer, decodedBuffer, blockSize-1);
|
||||
FUZ_CHECKTEST(ret>=0, "LZ4_decompress_fast should have failed, due to Output Size being too small");
|
||||
FUZ_CHECKTEST(decodedBuffer[blockSize-1], "LZ4_decompress_fast overrun specified output buffer");
|
||||
|
||||
/* Test decoding with one byte too much => must fail */
|
||||
FUZ_DISPLAYTEST;
|
||||
FUZ_DISPLAYTEST();
|
||||
ret = LZ4_decompress_fast(compressedBuffer, decodedBuffer, blockSize+1);
|
||||
FUZ_CHECKTEST(ret>=0, "LZ4_decompress_fast should have failed, due to Output Size being too large");
|
||||
|
||||
/* Test decoding with output size exactly what's necessary => must work */
|
||||
FUZ_DISPLAYTEST;
|
||||
FUZ_DISPLAYTEST();
|
||||
decodedBuffer[blockSize] = 0;
|
||||
ret = LZ4_decompress_safe(compressedBuffer, decodedBuffer, compressedSize, blockSize);
|
||||
FUZ_CHECKTEST(ret<0, "LZ4_decompress_safe failed despite sufficient space");
|
||||
@ -484,7 +493,7 @@ static int FUZ_test(U32 seed, U32 nbCycles, const U32 startCycle, const double c
|
||||
FUZ_CHECKTEST(crcCheck!=crcOrig, "LZ4_decompress_safe corrupted decoded data");
|
||||
|
||||
// Test decoding with more than enough output size => must work
|
||||
FUZ_DISPLAYTEST;
|
||||
FUZ_DISPLAYTEST();
|
||||
decodedBuffer[blockSize] = 0;
|
||||
decodedBuffer[blockSize+1] = 0;
|
||||
ret = LZ4_decompress_safe(compressedBuffer, decodedBuffer, compressedSize, blockSize+1);
|
||||
@ -496,14 +505,14 @@ static int FUZ_test(U32 seed, U32 nbCycles, const U32 startCycle, const double c
|
||||
FUZ_CHECKTEST(crcCheck!=crcOrig, "LZ4_decompress_safe corrupted decoded data");
|
||||
|
||||
// Test decoding with output size being one byte too short => must fail
|
||||
FUZ_DISPLAYTEST;
|
||||
FUZ_DISPLAYTEST();
|
||||
decodedBuffer[blockSize-1] = 0;
|
||||
ret = LZ4_decompress_safe(compressedBuffer, decodedBuffer, compressedSize, blockSize-1);
|
||||
FUZ_CHECKTEST(ret>=0, "LZ4_decompress_safe should have failed, due to Output Size being one byte too short");
|
||||
FUZ_CHECKTEST(decodedBuffer[blockSize-1], "LZ4_decompress_safe overrun specified output buffer size");
|
||||
|
||||
// Test decoding with output size being 10 bytes too short => must fail
|
||||
FUZ_DISPLAYTEST;
|
||||
FUZ_DISPLAYTEST();
|
||||
if (blockSize>10) {
|
||||
decodedBuffer[blockSize-10] = 0;
|
||||
ret = LZ4_decompress_safe(compressedBuffer, decodedBuffer, compressedSize, blockSize-10);
|
||||
@ -512,51 +521,51 @@ static int FUZ_test(U32 seed, U32 nbCycles, const U32 startCycle, const double c
|
||||
}
|
||||
|
||||
// Test decoding with input size being one byte too short => must fail
|
||||
FUZ_DISPLAYTEST;
|
||||
FUZ_DISPLAYTEST();
|
||||
ret = LZ4_decompress_safe(compressedBuffer, decodedBuffer, compressedSize-1, blockSize);
|
||||
FUZ_CHECKTEST(ret>=0, "LZ4_decompress_safe should have failed, due to input size being one byte too short (blockSize=%i, ret=%i, compressedSize=%i)", blockSize, ret, compressedSize);
|
||||
|
||||
// Test decoding with input size being one byte too large => must fail
|
||||
FUZ_DISPLAYTEST;
|
||||
FUZ_DISPLAYTEST();
|
||||
decodedBuffer[blockSize] = 0;
|
||||
ret = LZ4_decompress_safe(compressedBuffer, decodedBuffer, compressedSize+1, blockSize);
|
||||
FUZ_CHECKTEST(ret>=0, "LZ4_decompress_safe should have failed, due to input size being too large");
|
||||
FUZ_CHECKTEST(decodedBuffer[blockSize], "LZ4_decompress_safe overrun specified output buffer size");
|
||||
|
||||
// Test partial decoding with target output size being max/2 => must work
|
||||
FUZ_DISPLAYTEST;
|
||||
FUZ_DISPLAYTEST();
|
||||
ret = LZ4_decompress_safe_partial(compressedBuffer, decodedBuffer, compressedSize, blockSize/2, blockSize);
|
||||
FUZ_CHECKTEST(ret<0, "LZ4_decompress_safe_partial failed despite sufficient space");
|
||||
|
||||
// Test partial decoding with target output size being just below max => must work
|
||||
FUZ_DISPLAYTEST;
|
||||
FUZ_DISPLAYTEST();
|
||||
ret = LZ4_decompress_safe_partial(compressedBuffer, decodedBuffer, compressedSize, blockSize-3, blockSize);
|
||||
FUZ_CHECKTEST(ret<0, "LZ4_decompress_safe_partial failed despite sufficient space");
|
||||
|
||||
/* Test Compression with limited output size */
|
||||
|
||||
/* Test compression with output size being exactly what's necessary (should work) */
|
||||
FUZ_DISPLAYTEST;
|
||||
FUZ_DISPLAYTEST("test LZ4_compress_default() with output buffer just the right size");
|
||||
ret = LZ4_compress_default(block, compressedBuffer, blockSize, compressedSize);
|
||||
FUZ_CHECKTEST(ret==0, "LZ4_compress_default() failed despite sufficient space");
|
||||
|
||||
/* Test compression with output size being exactly what's necessary and external state (should work) */
|
||||
FUZ_DISPLAYTEST;
|
||||
FUZ_DISPLAYTEST("test LZ4_compress_fast_extState() with output buffer just the right size");
|
||||
ret = LZ4_compress_fast_extState(stateLZ4, block, compressedBuffer, blockSize, compressedSize, 1);
|
||||
FUZ_CHECKTEST(ret==0, "LZ4_compress_fast_extState() failed despite sufficient space");
|
||||
|
||||
/* Test HC compression with output size being exactly what's necessary (should work) */
|
||||
FUZ_DISPLAYTEST;
|
||||
FUZ_DISPLAYTEST("test LZ4_compress_HC() with output buffer just the right size");
|
||||
ret = LZ4_compress_HC(block, compressedBuffer, blockSize, HCcompressedSize, compressionLevel);
|
||||
FUZ_CHECKTEST(ret==0, "LZ4_compress_HC() failed despite sufficient space");
|
||||
|
||||
/* Test HC compression with output size being exactly what's necessary (should work) */
|
||||
FUZ_DISPLAYTEST;
|
||||
FUZ_DISPLAYTEST("test LZ4_compress_HC_extStateHC() with output buffer just the right size");
|
||||
ret = LZ4_compress_HC_extStateHC(stateLZ4HC, block, compressedBuffer, blockSize, HCcompressedSize, compressionLevel);
|
||||
FUZ_CHECKTEST(ret==0, "LZ4_compress_HC_extStateHC() failed despite sufficient space");
|
||||
|
||||
/* Test compression with missing bytes into output buffer => must fail */
|
||||
FUZ_DISPLAYTEST;
|
||||
FUZ_DISPLAYTEST("test LZ4_compress_default() with output buffer a bit too short");
|
||||
{ int missingBytes = (FUZ_rand(&randState) % 0x3F) + 1;
|
||||
if (missingBytes >= compressedSize) missingBytes = compressedSize-1;
|
||||
missingBytes += !missingBytes; /* avoid special case missingBytes==0 */
|
||||
@ -567,7 +576,7 @@ static int FUZ_test(U32 seed, U32 nbCycles, const U32 startCycle, const double c
|
||||
}
|
||||
|
||||
/* Test HC compression with missing bytes into output buffer => must fail */
|
||||
FUZ_DISPLAYTEST;
|
||||
FUZ_DISPLAYTEST("test LZ4_compress_HC() with output buffer a bit too short");
|
||||
{ int missingBytes = (FUZ_rand(&randState) % 0x3F) + 1;
|
||||
if (missingBytes >= HCcompressedSize) missingBytes = HCcompressedSize-1;
|
||||
missingBytes += !missingBytes; /* avoid special case missingBytes==0 */
|
||||
@ -583,7 +592,7 @@ static int FUZ_test(U32 seed, U32 nbCycles, const U32 startCycle, const double c
|
||||
/*-******************/
|
||||
|
||||
/* Compress using dictionary */
|
||||
FUZ_DISPLAYTEST;
|
||||
FUZ_DISPLAYTEST("test LZ4_compress_fast_continue() with dictionary of size %i", dictSize);
|
||||
{ LZ4_stream_t LZ4_stream;
|
||||
LZ4_resetStream(&LZ4_stream);
|
||||
LZ4_compress_fast_continue (&LZ4_stream, dict, compressedBuffer, dictSize, (int)compressedBufferSize, 1); /* Just to fill hash tables */
|
||||
@ -592,7 +601,7 @@ static int FUZ_test(U32 seed, U32 nbCycles, const U32 startCycle, const double c
|
||||
}
|
||||
|
||||
/* Decompress with dictionary as prefix */
|
||||
FUZ_DISPLAYTEST;
|
||||
FUZ_DISPLAYTEST("test LZ4_decompress_fast_usingDict() with dictionary as prefix");
|
||||
memcpy(decodedBuffer, dict, dictSize);
|
||||
ret = LZ4_decompress_fast_usingDict(compressedBuffer, decodedBuffer+dictSize, blockSize, decodedBuffer, dictSize);
|
||||
FUZ_CHECKTEST(ret!=blockContinueCompressedSize, "LZ4_decompress_fast_usingDict did not read all compressed block input");
|
||||
@ -605,33 +614,33 @@ static int FUZ_test(U32 seed, U32 nbCycles, const U32 startCycle, const double c
|
||||
}
|
||||
FUZ_CHECKTEST(crcCheck!=crcOrig, "LZ4_decompress_fast_usingDict corrupted decoded data (dict %i)", dictSize);
|
||||
|
||||
FUZ_DISPLAYTEST;
|
||||
FUZ_DISPLAYTEST("test LZ4_decompress_safe_usingDict()");
|
||||
ret = LZ4_decompress_safe_usingDict(compressedBuffer, decodedBuffer+dictSize, blockContinueCompressedSize, blockSize, decodedBuffer, dictSize);
|
||||
FUZ_CHECKTEST(ret!=blockSize, "LZ4_decompress_safe_usingDict did not regenerate original data");
|
||||
crcCheck = XXH32(decodedBuffer+dictSize, blockSize, 0);
|
||||
FUZ_CHECKTEST(crcCheck!=crcOrig, "LZ4_decompress_safe_usingDict corrupted decoded data");
|
||||
|
||||
/* Compress using External dictionary */
|
||||
FUZ_DISPLAYTEST;
|
||||
dict -= (FUZ_rand(&randState) & 0xF) + 1; /* Separation, so it is an ExtDict */
|
||||
FUZ_DISPLAYTEST("test LZ4_compress_fast_continue(), with non-contiguous dictionary");
|
||||
dict -= (FUZ_rand(&randState) & 0xF) + 1; /* create space, so now dictionary is an ExtDict */
|
||||
if (dict < (char*)CNBuffer) dict = (char*)CNBuffer;
|
||||
LZ4_loadDict(&LZ4dict, dict, dictSize);
|
||||
blockContinueCompressedSize = LZ4_compress_fast_continue(&LZ4dict, block, compressedBuffer, blockSize, (int)compressedBufferSize, 1);
|
||||
FUZ_CHECKTEST(blockContinueCompressedSize==0, "LZ4_compress_fast_continue failed");
|
||||
|
||||
FUZ_DISPLAYTEST;
|
||||
FUZ_DISPLAYTEST("test LZ4_compress_fast_continue() with dictionary but with an output buffer too short by one byte");
|
||||
LZ4_loadDict(&LZ4dict, dict, dictSize);
|
||||
ret = LZ4_compress_fast_continue(&LZ4dict, block, compressedBuffer, blockSize, blockContinueCompressedSize-1, 1);
|
||||
FUZ_CHECKTEST(ret>0, "LZ4_compress_fast_continue using ExtDict should fail : one missing byte for output buffer : %i written, %i buffer", ret, blockContinueCompressedSize);
|
||||
|
||||
FUZ_DISPLAYTEST;
|
||||
FUZ_DISPLAYTEST("test LZ4_compress_fast_continue() with dictionary loaded with LZ4_loadDict()");
|
||||
LZ4_loadDict(&LZ4dict, dict, dictSize);
|
||||
ret = LZ4_compress_fast_continue(&LZ4dict, block, compressedBuffer, blockSize, blockContinueCompressedSize, 1);
|
||||
FUZ_CHECKTEST(ret!=blockContinueCompressedSize, "LZ4_compress_limitedOutput_compressed size is different (%i != %i)", ret, blockContinueCompressedSize);
|
||||
FUZ_CHECKTEST(ret<=0, "LZ4_compress_fast_continue should work : enough size available within output buffer");
|
||||
|
||||
/* Decompress with dictionary as external */
|
||||
FUZ_DISPLAYTEST;
|
||||
FUZ_DISPLAYTEST();
|
||||
decodedBuffer[blockSize] = 0;
|
||||
ret = LZ4_decompress_fast_usingDict(compressedBuffer, decodedBuffer, blockSize, dict, dictSize);
|
||||
FUZ_CHECKTEST(ret!=blockContinueCompressedSize, "LZ4_decompress_fast_usingDict did not read all compressed block input");
|
||||
@ -640,7 +649,7 @@ static int FUZ_test(U32 seed, U32 nbCycles, const U32 startCycle, const double c
|
||||
if (crcCheck!=crcOrig) FUZ_findDiff(block, decodedBuffer);
|
||||
FUZ_CHECKTEST(crcCheck!=crcOrig, "LZ4_decompress_fast_usingDict corrupted decoded data (dict %i)", dictSize);
|
||||
|
||||
FUZ_DISPLAYTEST;
|
||||
FUZ_DISPLAYTEST();
|
||||
decodedBuffer[blockSize] = 0;
|
||||
ret = LZ4_decompress_safe_usingDict(compressedBuffer, decodedBuffer, blockContinueCompressedSize, blockSize, dict, dictSize);
|
||||
FUZ_CHECKTEST(ret!=blockSize, "LZ4_decompress_safe_usingDict did not regenerate original data");
|
||||
@ -648,19 +657,19 @@ static int FUZ_test(U32 seed, U32 nbCycles, const U32 startCycle, const double c
|
||||
crcCheck = XXH32(decodedBuffer, blockSize, 0);
|
||||
FUZ_CHECKTEST(crcCheck!=crcOrig, "LZ4_decompress_safe_usingDict corrupted decoded data");
|
||||
|
||||
FUZ_DISPLAYTEST;
|
||||
FUZ_DISPLAYTEST();
|
||||
decodedBuffer[blockSize-1] = 0;
|
||||
ret = LZ4_decompress_fast_usingDict(compressedBuffer, decodedBuffer, blockSize-1, dict, dictSize);
|
||||
FUZ_CHECKTEST(ret>=0, "LZ4_decompress_fast_usingDict should have failed : wrong original size (-1 byte)");
|
||||
FUZ_CHECKTEST(decodedBuffer[blockSize-1], "LZ4_decompress_fast_usingDict overrun specified output buffer size");
|
||||
|
||||
FUZ_DISPLAYTEST;
|
||||
FUZ_DISPLAYTEST();
|
||||
decodedBuffer[blockSize-1] = 0;
|
||||
ret = LZ4_decompress_safe_usingDict(compressedBuffer, decodedBuffer, blockContinueCompressedSize, blockSize-1, dict, dictSize);
|
||||
FUZ_CHECKTEST(ret>=0, "LZ4_decompress_safe_usingDict should have failed : not enough output size (-1 byte)");
|
||||
FUZ_CHECKTEST(decodedBuffer[blockSize-1], "LZ4_decompress_safe_usingDict overrun specified output buffer size");
|
||||
|
||||
FUZ_DISPLAYTEST;
|
||||
FUZ_DISPLAYTEST();
|
||||
{ U32 const missingBytes = (FUZ_rand(&randState) & 0xF) + 2;
|
||||
if ((U32)blockSize > missingBytes) {
|
||||
decodedBuffer[blockSize-missingBytes] = 0;
|
||||
@ -670,7 +679,7 @@ static int FUZ_test(U32 seed, U32 nbCycles, const U32 startCycle, const double c
|
||||
} }
|
||||
|
||||
/* Compress HC using External dictionary */
|
||||
FUZ_DISPLAYTEST;
|
||||
FUZ_DISPLAYTEST();
|
||||
dict -= (FUZ_rand(&randState) & 7); /* even bigger separation */
|
||||
if (dict < (char*)CNBuffer) dict = (char*)CNBuffer;
|
||||
LZ4_resetStreamHC (&LZ4dictHC, compressionLevel);
|
||||
@ -679,18 +688,18 @@ static int FUZ_test(U32 seed, U32 nbCycles, const U32 startCycle, const double c
|
||||
blockContinueCompressedSize = LZ4_compress_HC_continue(&LZ4dictHC, block, compressedBuffer, blockSize, (int)compressedBufferSize);
|
||||
FUZ_CHECKTEST(blockContinueCompressedSize==0, "LZ4_compress_HC_continue failed");
|
||||
|
||||
FUZ_DISPLAYTEST;
|
||||
FUZ_DISPLAYTEST();
|
||||
LZ4_loadDictHC(&LZ4dictHC, dict, dictSize);
|
||||
ret = LZ4_compress_HC_continue(&LZ4dictHC, block, compressedBuffer, blockSize, blockContinueCompressedSize-1);
|
||||
FUZ_CHECKTEST(ret>0, "LZ4_compress_HC_continue using ExtDict should fail : one missing byte for output buffer (%i != %i)", ret, blockContinueCompressedSize);
|
||||
|
||||
FUZ_DISPLAYTEST;
|
||||
FUZ_DISPLAYTEST();
|
||||
LZ4_loadDictHC(&LZ4dictHC, dict, dictSize);
|
||||
ret = LZ4_compress_HC_continue(&LZ4dictHC, block, compressedBuffer, blockSize, blockContinueCompressedSize);
|
||||
FUZ_CHECKTEST(ret!=blockContinueCompressedSize, "LZ4_compress_HC_continue size is different (%i != %i)", ret, blockContinueCompressedSize);
|
||||
FUZ_CHECKTEST(ret<=0, "LZ4_compress_HC_continue should work : enough size available within output buffer");
|
||||
|
||||
FUZ_DISPLAYTEST;
|
||||
FUZ_DISPLAYTEST();
|
||||
decodedBuffer[blockSize] = 0;
|
||||
ret = LZ4_decompress_safe_usingDict(compressedBuffer, decodedBuffer, blockContinueCompressedSize, blockSize, dict, dictSize);
|
||||
FUZ_CHECKTEST(ret!=blockSize, "LZ4_decompress_safe_usingDict did not regenerate original data");
|
||||
@ -701,10 +710,10 @@ static int FUZ_test(U32 seed, U32 nbCycles, const U32 startCycle, const double c
|
||||
FUZ_CHECKTEST(crcCheck!=crcOrig, "LZ4_decompress_safe_usingDict corrupted decoded data");
|
||||
|
||||
/* Compress HC continue destSize */
|
||||
FUZ_DISPLAYTEST;
|
||||
FUZ_DISPLAYTEST();
|
||||
{ int const availableSpace = (FUZ_rand(&randState) % blockSize) + 5;
|
||||
int consumedSize = blockSize;
|
||||
FUZ_DISPLAYTEST;
|
||||
FUZ_DISPLAYTEST();
|
||||
LZ4_resetStreamHC (&LZ4dictHC, compressionLevel);
|
||||
LZ4_loadDictHC(&LZ4dictHC, dict, dictSize);
|
||||
blockContinueCompressedSize = LZ4_compress_HC_continue_destSize(&LZ4dictHC, block, compressedBuffer, &consumedSize, availableSpace);
|
||||
@ -713,7 +722,7 @@ static int FUZ_test(U32 seed, U32 nbCycles, const U32 startCycle, const double c
|
||||
FUZ_CHECKTEST(blockContinueCompressedSize > availableSpace, "LZ4_compress_HC_continue_destSize write overflow");
|
||||
FUZ_CHECKTEST(consumedSize > blockSize, "LZ4_compress_HC_continue_destSize read overflow");
|
||||
|
||||
FUZ_DISPLAYTEST;
|
||||
FUZ_DISPLAYTEST();
|
||||
decodedBuffer[consumedSize] = 0;
|
||||
ret = LZ4_decompress_safe_usingDict(compressedBuffer, decodedBuffer, blockContinueCompressedSize, consumedSize, dict, dictSize);
|
||||
FUZ_CHECKTEST(ret!=consumedSize, "LZ4_decompress_safe_usingDict did not regenerate original data");
|
||||
@ -1118,13 +1127,13 @@ int main(int argc, const char** argv)
|
||||
return FUZ_usage(programName);
|
||||
|
||||
case 'v': /* verbose mode */
|
||||
argument++;
|
||||
g_displayLevel++;
|
||||
argument++;
|
||||
break;
|
||||
|
||||
case 'p': /* pause at the end */
|
||||
argument++;
|
||||
use_pause=1;
|
||||
argument++;
|
||||
break;
|
||||
|
||||
case 'i':
|
||||
|
||||
Loading…
Reference in New Issue
Block a user