AuroraMiddleware/lz4
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

made roundTripTest fully general

Browse Source 
no longer "locked" on level 9
This commit is contained in:
Yann Collet 2018-09-04 18:23:21 -07:00
parent 2e4847c2d5
commit 52cce30562
1 changed files with 73 additions and 28 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

101
tests/roundTripTest.c
View File

@ -10,13 +10,22 @@
/* /*
* This program takes a file in input, * This program takes a file in input,
* performs an LZ4 round-trip test (compression - decompress) * performs an LZ4 round-trip test (compress + decompress)
* compares the result with original * compares the result with original
* and generates an abort() on corruption detection, * and generates an abort() on corruption detection,
* in order for afl to register the event as a crash. * in order for afl to register the event as a crash.
*/ */
/*===========================================
* Tuning Constant
*==========================================*/
#ifndef MIN_CLEVEL
# define MIN_CLEVEL (int)(-5)
#endif
/*=========================================== /*===========================================
* Dependencies * Dependencies
*==========================================*/ *==========================================*/
@ -62,27 +71,42 @@ static size_t checkBuffers(const void* buff1, const void* buff2, size_t buffSize
return pos; return pos;
} }
/* select a compression level
* based on first bytes present in a reference buffer */
static int select_clevel(const void* refBuff, size_t refBuffSize)
{
const int minCLevel = MIN_CLEVEL;
const int maxClevel = LZ4HC_CLEVEL_MAX;
const int cLevelSpan = maxClevel - minCLevel;
size_t const hashLength = MIN(16, refBuffSize);
unsigned const h32 = XXH32(refBuff, hashLength, 0);
int const randL = h32 % (cLevelSpan+1);
return minCLevel + randL;
}
typedef int (*compressFn)(const char* src, char* dst, int srcSize, int dstSize, int cLevel);
/** roundTripTest() : /** roundTripTest() :
* Compresses `srcBuff` into `compressedBuff`, * Compresses `srcBuff` into `compressedBuff`,
* then decompresses `compressedBuff` into `resultBuff`. * then decompresses `compressedBuff` into `resultBuff`.
* Compression level used is derived from content's head bytes. * If clevel==0, compression level is derived from srcBuff's content head bytes.
* This function abort() if it detects any round-trip error, * This function abort() if it detects any round-trip error.
* so if it returns, round trip is considered successfully validated. * Therefore, if it returns, round trip is considered successfully validated.
* Note : `compressedBuffCapacity` should be `>= LZ4_compressBound(srcSize)` * Note : `compressedBuffCapacity` should be `>= LZ4_compressBound(srcSize)`
* for compression to be guaranteed to work */ * for compression to be guaranteed to work */
static void roundTripTest(void* resultBuff, size_t resultBuffCapacity, static void roundTripTest(void* resultBuff, size_t resultBuffCapacity,
void* compressedBuff, size_t compressedBuffCapacity, void* compressedBuff, size_t compressedBuffCapacity,
const void* srcBuff, size_t srcSize) const void* srcBuff, size_t srcSize,
int clevel)
{ {
const int minCLevel = 1; int const proposed_clevel = clevel ? clevel : select_clevel(srcBuff, srcSize);
const int maxClevel = 12; int const selected_clevel = proposed_clevel < 0 ? -proposed_clevel : proposed_clevel; /* if level < 0, it becomes an accelearion value */
const int cLevelSpan = maxClevel - minCLevel; compressFn compress = selected_clevel >= LZ4HC_CLEVEL_MIN ? LZ4_compress_HC : LZ4_compress_fast;
size_t const hashLength = MIN(16, srcSize); int const cSize = compress((const char*)srcBuff, (char*)compressedBuff, (int)srcSize, (int)compressedBuffCapacity, selected_clevel);
unsigned const h32 = XXH32(srcBuff, hashLength, 0);
int const randL = h32 % (cLevelSpan+1);
int const cLevel = minCLevel + randL;
int const realCLevel = (cLevel * 0) + 9; /* <=== Currently : only test level 9 */
int const cSize = LZ4_compress_HC((const char*)srcBuff, (char*)compressedBuff, (int)srcSize, (int)compressedBuffCapacity, realCLevel);
CONTROL_MSG(cSize == 0, "Compression error !"); CONTROL_MSG(cSize == 0, "Compression error !");
{ int const dSize = LZ4_decompress_safe((const char*)compressedBuff, (char*)resultBuff, cSize, (int)resultBuffCapacity); { int const dSize = LZ4_decompress_safe((const char*)compressedBuff, (char*)resultBuff, cSize, (int)resultBuffCapacity);
@ -100,7 +124,7 @@ static void roundTripTest(void* resultBuff, size_t resultBuffCapacity,
} }
static void roundTripCheck(const void* srcBuff, size_t srcSize) static void roundTripCheck(const void* srcBuff, size_t srcSize, int clevel)
{ {
size_t const cBuffSize = LZ4_compressBound((int)srcSize); size_t const cBuffSize = LZ4_compressBound((int)srcSize);
void* const cBuff = malloc(cBuffSize); void* const cBuff = malloc(cBuffSize);
@ -113,7 +137,8 @@ static void roundTripCheck(const void* srcBuff, size_t srcSize)
roundTripTest(rBuff, cBuffSize, roundTripTest(rBuff, cBuffSize,
cBuff, cBuffSize, cBuff, cBuffSize,
srcBuff, srcSize); srcBuff, srcSize,
clevel);
free(rBuff); free(rBuff);
free(cBuff); free(cBuff);
@ -158,46 +183,66 @@ static void loadFile(void* buffer, const char* fileName, size_t fileSize)
{ {
FILE* const f = fopen(fileName, "rb"); FILE* const f = fopen(fileName, "rb");
if (isDirectory(fileName)) { if (isDirectory(fileName)) {
fprintf(stderr, "Ignoring %s directory \n", fileName); MSG("Ignoring %s directory \n", fileName);
exit(2); exit(2);
} }
if (f==NULL) { if (f==NULL) {
fprintf(stderr, "Impossible to open %s \n", fileName); MSG("Impossible to open %s \n", fileName);
exit(3); exit(3);
} }
{ size_t const readSize = fread(buffer, 1, fileSize, f); { size_t const readSize = fread(buffer, 1, fileSize, f);
if (readSize != fileSize) { if (readSize != fileSize) {
fprintf(stderr, "Error reading %s \n", fileName); MSG("Error reading %s \n", fileName);
exit(5); exit(5);
} } } }
fclose(f); fclose(f);
} }
static void fileCheck(const char* fileName) static void fileCheck(const char* fileName, int clevel)
{ {
size_t const fileSize = getFileSize(fileName); size_t const fileSize = getFileSize(fileName);
void* const buffer = malloc(fileSize + !fileSize /* avoid 0 */); void* const buffer = malloc(fileSize + !fileSize /* avoid 0 */);
if (!buffer) { if (!buffer) {
fprintf(stderr, "not enough memory \n"); MSG("not enough memory \n");
exit(4); exit(4);
} }
loadFile(buffer, fileName, fileSize); loadFile(buffer, fileName, fileSize);
roundTripCheck(buffer, fileSize); roundTripCheck(buffer, fileSize, clevel);
free (buffer); free (buffer);
} }
int bad_usage(const char* exeName)
{
MSG(" \n");
MSG("bad usage: \n");
MSG(" \n");
MSG("%s [Options] fileName \n", exeName);
MSG(" \n");
MSG("Options: \n");
MSG("-# : use #=[0-9] compression level (default:0 == random) \n");
return 1;
}
int main(int argCount, const char** argv) int main(int argCount, const char** argv)
{ {
int const argNb = 1; const char* const exeName = argv[0];
int argNb = 1;
int clevel = 0;
if (argCount < 2) { assert(argCount >= 1);
fprintf(stderr, "Error : no argument : need input file \n"); if (argCount < 2) return bad_usage(exeName);
exit(9);
if (argv[1][0] == '-') {
clevel = argv[1][1] - '0';
argNb = 2;
} }
fileCheck(argv[argNb]); if (argNb >= argCount) return bad_usage(exeName);
fprintf(stderr, "no pb detected \n");
fileCheck(argv[argNb], clevel);
MSG("no pb detected \n");
return 0; return 0;
} }