/*-******************************************
* bitStream encoding API (write forward)
********************************************/
-/*!
-* bitStream can mix input from multiple sources.
-* A critical property of these streams is that they encode and decode in **reverse** direction.
-* So the first bit sequence you add will be the last to be read, like a LIFO stack.
+/* bitStream can mix input from multiple sources.
+* A critical property of these streams is that they encode and decode in **reverse** direction.
+* So the first bit sequence you add will be the last to be read, like a LIFO stack.
*/
typedef struct
{
MEM_STATIC void BIT_flushBits(BIT_CStream_t* bitC);
MEM_STATIC size_t BIT_closeCStream(BIT_CStream_t* bitC);
-/*!
-* Start by initCStream, providing the size of buffer to write into.
+/*Start by initCStream, providing the size of buffer to write into.
* bitStream will never write outside of this buffer.
-* @dstCapacity must be >= sizeof(size_t), otherwise @return will be an error code.
+* `dstCapacity` must be >= sizeof(size_t), otherwise @return will be an error code.
*
* bits are first added to a local register.
* Local register is size_t, hence 64-bits on 64-bits systems, or 32-bits on 32-bits systems.
*
* Last operation is to close the bitStream.
* The function returns the final size of CStream in bytes.
-* If data couldn't fit into @dstBuffer, it will return a 0 ( == not storable)
+* If data couldn't fit into `dstBuffer`, it will return a 0 ( == not storable)
*/
MEM_STATIC unsigned BIT_endOfDStream(const BIT_DStream_t* bitD);
-/*!
-* Start by invoking BIT_initDStream().
+/*Start by invoking BIT_initDStream().
* A chunk of the bitStream is then stored into a local register.
* Local register size is 64-bits on 64-bits systems, 32-bits on 32-bits systems (size_t).
* You can then retrieve bitFields stored into the local register, **in reverse order**.
bitC->bitPos += nbBits;
}
-/*! BIT_addBitsFast
+/*! BIT_addBitsFast() :
* works only if `value` is _clean_, meaning all high bits above nbBits are 0 */
MEM_STATIC void BIT_addBitsFast(BIT_CStream_t* bitC, size_t value, unsigned nbBits)
{
bitC->bitPos += nbBits;
}
-/*! BIT_flushBitsFast
+/*! BIT_flushBitsFast() :
* unsafe version; does not check buffer overflow */
MEM_STATIC void BIT_flushBitsFast(BIT_CStream_t* bitC)
{
bitC->bitContainer >>= nbBytes*8; /* if bitPos >= sizeof(bitContainer)*8 --> undefined behavior */
}
-/*! BIT_closeCStream
- * @result : size of CStream, in bytes, or 0 if it cannot fit into dstBuffer */
+/*! BIT_closeCStream() :
+ * @return : size of CStream, in bytes, or 0 if it cannot fit into dstBuffer */
MEM_STATIC size_t BIT_closeCStream(BIT_CStream_t* bitC)
{
char* endPtr;
/*-********************************************************
* bitStream decoding
**********************************************************/
-/*!BIT_initDStream
+/*!BIT_initDStream() :
* Initialize a BIT_DStream_t.
-* @bitD : a pointer to an already allocated BIT_DStream_t structure
-* @srcBuffer must point at the beginning of a bitStream
-* @srcSize must be the exact size of the bitStream
-* @result : size of stream (== srcSize) or an errorCode if a problem is detected
+* `bitD` : a pointer to an already allocated BIT_DStream_t structure.
+* `srcBuffer` must point at the beginning of a bitStream.
+* `srcSize` must be the exact size of the bitStream.
+* @return : size of stream (== srcSize) or an errorCode if a problem is detected
*/
MEM_STATIC size_t BIT_initDStream(BIT_DStream_t* bitD, const void* srcBuffer, size_t srcSize)
{
return srcSize;
}
-/*!BIT_lookBits
- * Provides next n bits from local register
- * local register is not modified (bits are still present for next read/look)
- * On 32-bits, maxNbBits==25
- * On 64-bits, maxNbBits==57
+/*!BIT_lookBits() :
+ * Provides next n bits from local register.
+ * local register is not modified (bits are still present for next read/look).
+ * On 32-bits, maxNbBits==24.
+ * On 64-bits, maxNbBits==56.
* @return : value extracted
*/
MEM_STATIC size_t BIT_lookBits(BIT_DStream_t* bitD, U32 nbBits)
{
- const U32 bitMask = sizeof(bitD->bitContainer)*8 - 1;
+ U32 const bitMask = sizeof(bitD->bitContainer)*8 - 1;
return ((bitD->bitContainer << (bitD->bitsConsumed & bitMask)) >> 1) >> ((bitMask-nbBits) & bitMask);
}
-/*! BIT_lookBitsFast :
+/*! BIT_lookBitsFast*() :
* unsafe version; only works only if nbBits >= 1 */
MEM_STATIC size_t BIT_lookBitsFast(BIT_DStream_t* bitD, U32 nbBits)
{
- const U32 bitMask = sizeof(bitD->bitContainer)*8 - 1;
+ U32 const bitMask = sizeof(bitD->bitContainer)*8 - 1;
return (bitD->bitContainer << (bitD->bitsConsumed & bitMask)) >> (((bitMask+1)-nbBits) & bitMask);
}
bitD->bitsConsumed += nbBits;
}
-/*!BIT_readBits
+/*!BIT_readBits() :
* Read next n bits from local register.
* pay attention to not read more than nbBits contained into local register.
* @return : extracted value.
return value;
}
-/*!BIT_readBitsFast :
+/*!BIT_readBitsFast() :
* unsafe version; only works only if nbBits >= 1 */
MEM_STATIC size_t BIT_readBitsFast(BIT_DStream_t* bitD, U32 nbBits)
{
}
}
-/*! BIT_endOfDStream
+/*! BIT_endOfDStream() :
* @return Tells if DStream has reached its exact end
*/
MEM_STATIC unsigned BIT_endOfDStream(const BIT_DStream_t* DStream)
static size_t ZSTD_buildSeqTable(FSE_DTable* DTable, U32 type, U32 rawBits, U32 maxLog,
const void* src, size_t srcSize)
{
+ U32 max = (1<<rawBits)-1;
switch(type)
{
case FSE_ENCODING_RLE :
if (!srcSize) return ERROR(srcSize_wrong);
- FSE_buildDTable_rle(DTable, *(const BYTE*)src);
+ FSE_buildDTable_rle(DTable, (*(const BYTE*)src) & max); /* if *src > max, data is corrupted */
return 1;
case FSE_ENCODING_RAW :
FSE_buildDTable_raw(DTable, rawBits);
return 0;
default : /* impossible */
case FSE_ENCODING_DYNAMIC :
- { U32 tableLog, max = (1<<rawBits)-1;
+ { U32 tableLog;
S16 norm[MaxSeq+1];
size_t const headerSize = FSE_readNCount(norm, &max, &tableLog, src, srcSize);
if (FSE_isError(headerSize)) return ERROR(GENERIC);
}
-
-
size_t ZSTD_decodeSeqHeaders(int* nbSeq, const BYTE** dumpsPtr, size_t* dumpsLengthPtr,
FSE_DTable* DTableLL, FSE_DTable* DTableML, FSE_DTable* DTableOffb,
const void* src, size_t srcSize)
}
/* Offset */
- {
- static const U32 offsetPrefix[MaxOff+1] = {
- 1 /*fake*/, 1, 2, 4, 8, 0x10, 0x20, 0x40, 0x80, 0x100,
- 0x200, 0x400, 0x800, 0x1000, 0x2000, 0x4000, 0x8000, 0x10000, 0x20000, 0x40000,
- 0x80000, 0x100000, 0x200000, 0x400000, 0x800000, 0x1000000, 0x2000000, 0x4000000, /*fake*/ 1, 1, 1, 1 };
- const U32 offsetCode = FSE_peakSymbol(&(seqState->stateOffb)); /* <= maxOff, by table construction */
- const U32 nbBits = offsetCode ? offsetCode-1 : 0;
+ { static const U32 offsetPrefix[MaxOff+1] = {
+ 1 /*fake*/, 1, 2, 4, 8, 0x10, 0x20, 0x40,
+ 0x80, 0x100, 0x200, 0x400, 0x800, 0x1000, 0x2000, 0x4000,
+ 0x8000, 0x10000, 0x20000, 0x40000, 0x80000, 0x100000, 0x200000, 0x400000,
+ 0x800000, 0x1000000, 0x2000000, 0x4000000, /*fake*/ 1, 1, 1, 1 };
+ U32 const offsetCode = FSE_peakSymbol(&(seqState->stateOffb)); /* <= maxOff, by table construction */
+ U32 const nbBits = offsetCode ? offsetCode-1 : 0;
offset = offsetPrefix[offsetCode] + BIT_readBits(&(seqState->DStream), nbBits);
if (MEM_32bits()) BIT_reloadDStream(&(seqState->DStream));
if (offsetCode==0) offset = litLength ? seq->offset : seqState->prevOffset;
return sequenceLength;
}
/* span extDict & currentPrefixSegment */
- {
- size_t length1 = dictEnd - match;
+ { size_t const length1 = dictEnd - match;
memmove(oLitEnd, match, length1);
op = oLitEnd + length1;
sequence.matchLength -= length1;
CNBuffer = malloc(COMPRESSIBLE_NOISE_LENGTH);
compressedBuffer = malloc(ZSTD_compressBound(COMPRESSIBLE_NOISE_LENGTH));
decodedBuffer = malloc(COMPRESSIBLE_NOISE_LENGTH);
- if (!CNBuffer || !compressedBuffer || !decodedBuffer)
- {
+ if (!CNBuffer || !compressedBuffer || !decodedBuffer) {
DISPLAY("Not enough memory, aborting\n");
testResult = 1;
goto _end;
if (result != COMPRESSIBLE_NOISE_LENGTH) goto _output_error;
DISPLAYLEVEL(4, "OK \n");
- {
- size_t i;
+ { size_t i;
DISPLAYLEVEL(4, "test%3i : check decompressed result : ", testNb++);
- for (i=0; i<COMPRESSIBLE_NOISE_LENGTH; i++)
- {
+ for (i=0; i<COMPRESSIBLE_NOISE_LENGTH; i++) {
if (((BYTE*)decodedBuffer)[i] != ((BYTE*)CNBuffer)[i]) goto _output_error;;
}
DISPLAYLEVEL(4, "OK \n");
DISPLAYLEVEL(4, "OK \n");
/* Dictionary and Duplication tests */
- {
- ZSTD_CCtx* ctxOrig = ZSTD_createCCtx();
+ { ZSTD_CCtx* ctxOrig = ZSTD_createCCtx();
ZSTD_CCtx* ctxDuplicated = ZSTD_createCCtx();
ZSTD_DCtx* dctx = ZSTD_createDCtx();
const size_t dictSize = 500;
DISPLAYLEVEL(4, "OK \n");
/* block API tests */
- {
- ZSTD_CCtx* const cctx = ZSTD_createCCtx();
+ { ZSTD_CCtx* const cctx = ZSTD_createCCtx();
ZSTD_DCtx* const dctx = ZSTD_createDCtx();
const size_t blockSize = 100 KB;
const size_t dictSize = 16 KB;
}
/* long rle test */
- {
- size_t sampleSize = 0;
+ { size_t sampleSize = 0;
DISPLAYLEVEL(4, "test%3i : Long RLE test : ", testNb++);
RDG_genBuffer(CNBuffer, sampleSize, compressibility, 0., randState);
memset((char*)CNBuffer+sampleSize, 'B', 256 KB - 1);
DISPLAYLEVEL(4, "OK \n");
/* nbSeq limit test */
- {
- #define _3BYTESTESTLENGTH 131000
- #define NB3BYTESSEQLOG 9
- #define NB3BYTESSEQ (1 << NB3BYTESSEQLOG)
- #define NB3BYTESSEQMASK (NB3BYTESSEQ-1)
- BYTE _3BytesSeqs[NB3BYTESSEQ][3];
+ #define _3BYTESTESTLENGTH 131000
+ #define NB3BYTESSEQLOG 9
+ #define NB3BYTESSEQ (1 << NB3BYTESSEQLOG)
+ #define NB3BYTESSEQMASK (NB3BYTESSEQ-1)
+ { BYTE _3BytesSeqs[NB3BYTESSEQ][3];
U32 r = 1;
- int i;
- for (i=0; i < NB3BYTESSEQ; i++) {
+ { int i; for (i=0; i < NB3BYTESSEQ; i++) {
_3BytesSeqs[i][0] = (BYTE)(FUZ_rand(&r) & 255);
_3BytesSeqs[i][1] = (BYTE)(FUZ_rand(&r) & 255);
_3BytesSeqs[i][2] = (BYTE)(FUZ_rand(&r) & 255);
- }
+ }}
- for (i=0; i < _3BYTESTESTLENGTH; ) {
+ { int i; for (i=0; i < _3BYTESTESTLENGTH; ) {
U32 id = FUZ_rand(&r) & NB3BYTESSEQMASK;
((BYTE*)CNBuffer)[i+0] = _3BytesSeqs[id][0];
((BYTE*)CNBuffer)[i+1] = _3BytesSeqs[id][1];
((BYTE*)CNBuffer)[i+2] = _3BytesSeqs[id][2];
i += 3;
- }
+ }}
DISPLAYLEVEL(4, "test%3i : compress lots 3-bytes sequences : ", testNb++);
result = ZSTD_compress(compressedBuffer, ZSTD_compressBound(_3BYTESTESTLENGTH), CNBuffer, _3BYTESTESTLENGTH, 19);
const BYTE* b1 = (const BYTE*)buf1;
const BYTE* b2 = (const BYTE*)buf2;
size_t i;
- for (i=0; i<max; i++)
- {
+ for (i=0; i<max; i++) {
if (b1[i] != b2[i]) break;
}
return i;
FUZ_rand(&coreSeed);
/* test loop */
- for ( ; (testNb <= nbTests) || (FUZ_GetMilliSpan(startTime) < g_testTime); testNb++ )
- {
+ for ( ; (testNb <= nbTests) || (FUZ_GetMilliSpan(startTime) < g_testTime); testNb++ ) {
size_t sampleSize, sampleStart, maxTestSize, totalTestSize;
size_t cSize, dSize, dSupSize, errorCode, totalCSize, totalGenSize;
U32 sampleSizeLog, buffNb, cLevelMod, nbChunks, n;
lseed = coreSeed ^ prime1;
buffNb = FUZ_rand(&lseed) & 127;
if (buffNb & 7) buffNb=2;
- else
- {
+ else {
buffNb >>= 3;
- if (buffNb & 7)
- {
+ if (buffNb & 7) {
const U32 tnb[2] = { 1, 3 };
buffNb = tnb[buffNb >> 3];
- }
- else
- {
+ } else {
const U32 tnb[2] = { 0, 4 };
buffNb = tnb[buffNb >> 3];
}
crcOrig = XXH64(sampleBuffer, sampleSize, 0);
/* compression test */
- //cLevelMod = MAX(1, 38 - (int)(MAX(9, sampleSizeLog) * 2)); /* high levels only for small samples, for manageable speed */
cLevelMod = MIN( ZSTD_maxCLevel(), (U32)MAX(1, 55 - 3*(int)sampleSizeLog) ); /* high levels only for small samples, for manageable speed */
cLevel = (FUZ_rand(&lseed) % cLevelMod) +1;
cSize = ZSTD_compressCCtx(ctx, cBuffer, cBufferSize, sampleBuffer, sampleSize, cLevel);
const size_t missing = (FUZ_rand(&lseed) % (cSize-2)) + 1; /* no problem, as cSize > 4 (frameHeaderSizer) */
const size_t tooSmallSize = cSize - missing;
static const U32 endMark = 0x4DC2B1A9;
- U32 endCheck;
memcpy(dstBuffer+tooSmallSize, &endMark, 4);
errorCode = ZSTD_compressCCtx(ctx, dstBuffer, tooSmallSize, sampleBuffer, sampleSize, cLevel);
CHECK(!ZSTD_isError(errorCode), "ZSTD_compressCCtx should have failed ! (buffer too small : %u < %u)", (U32)tooSmallSize, (U32)cSize);
- memcpy(&endCheck, dstBuffer+tooSmallSize, 4);
- CHECK(endCheck != endMark, "ZSTD_compressCCtx : dst buffer overflow");
+ { U32 endCheck; memcpy(&endCheck, dstBuffer+tooSmallSize, 4);
+ CHECK(endCheck != endMark, "ZSTD_compressCCtx : dst buffer overflow"); }
}
/* decompression header test */
free(sampleBuffer); /* no longer useful after this point */
/* truncated src decompression test */
- {
- const size_t missing = (FUZ_rand(&lseed) % (cSize-2)) + 1; /* no problem, as cSize > 4 (frameHeaderSizer) */
+ { const size_t missing = (FUZ_rand(&lseed) % (cSize-2)) + 1; /* no problem, as cSize > 4 (frameHeaderSizer) */
const size_t tooSmallSize = cSize - missing;
void* cBufferTooSmall = malloc(tooSmallSize); /* valgrind will catch overflows */
CHECK(cBufferTooSmall == NULL, "not enough memory !");
}
/* too small dst decompression test */
- if (sampleSize > 3)
- {
+ if (sampleSize > 3) {
const size_t missing = (FUZ_rand(&lseed) % (sampleSize-2)) + 1; /* no problem, as cSize > 4 (frameHeaderSizer) */
const size_t tooSmallSize = sampleSize - missing;
static const BYTE token = 0xA9;
}
/* noisy src decompression test */
- if (cSize > 6)
- {
- const U32 maxNbBits = FUZ_highbit32((U32)(cSize-4));
- size_t pos = 4; /* preserve magic number (too easy to detect) */
- U32 nbBits = FUZ_rand(&lseed) % maxNbBits;
- size_t mask = (1<<nbBits) - 1;
- size_t skipLength = FUZ_rand(&lseed) & mask;
- pos += skipLength;
-
- while (pos < cSize)
- {
- /* add noise */
- size_t noiseStart, noiseLength;
- nbBits = FUZ_rand(&lseed) % maxNbBits;
- if (nbBits>0) nbBits--;
- mask = (1<<nbBits) - 1;
- noiseLength = (FUZ_rand(&lseed) & mask) + 1;
- if ( pos+noiseLength > cSize ) noiseLength = cSize-pos;
- noiseStart = FUZ_rand(&lseed) % (srcBufferSize - noiseLength);
- memcpy(cBuffer + pos, srcBuffer + noiseStart, noiseLength);
- pos += noiseLength;
-
- /* keep some original src */
- nbBits = FUZ_rand(&lseed) % maxNbBits;
- mask = (1<<nbBits) - 1;
- skipLength = FUZ_rand(&lseed) & mask;
- pos += skipLength;
- }
+ if (cSize > 6) {
+ /* insert noise into src */
+ { U32 const maxNbBits = FUZ_highbit32((U32)(cSize-4));
+ size_t pos = 4; /* preserve magic number (too easy to detect) */
+ for (;;) {
+ /* keep some original src */
+ { U32 const nbBits = FUZ_rand(&lseed) % maxNbBits;
+ size_t const mask = (1<<nbBits) - 1;
+ size_t const skipLength = FUZ_rand(&lseed) & mask;
+ pos += skipLength;
+ }
+ if (pos <= cSize) break;
+ /* add noise */
+ { U32 nbBits = FUZ_rand(&lseed) % maxNbBits;
+ size_t mask, noiseStart, noiseLength;
+ if (nbBits>0) nbBits--;
+ mask = (1<<nbBits) - 1;
+ noiseLength = (FUZ_rand(&lseed) & mask) + 1;
+ if ( pos+noiseLength > cSize ) noiseLength = cSize-pos;
+ noiseStart = FUZ_rand(&lseed) % (srcBufferSize - noiseLength);
+ memcpy(cBuffer + pos, srcBuffer + noiseStart, noiseLength);
+ pos += noiseLength;
+ } } }
/* decompress noisy source */
- { U32 const noiseSrc = FUZ_rand(&lseed) % 5;
- U32 const endMark = 0xA9B1C3D6;
- srcBuffer = cNoiseBuffer[noiseSrc];
+ { U32 const endMark = 0xA9B1C3D6;
memcpy(dstBuffer+sampleSize, &endMark, 4);
errorCode = ZSTD_decompress(dstBuffer, sampleSize, cBuffer, cSize);
/* result *may* be an unlikely success, but even then, it must strictly respect dest buffer boundaries */
"ZSTD_decompress on noisy src : result is too large : %u > %u (dst buffer)", (U32)errorCode, (U32)sampleSize);
{ U32 endCheck; memcpy(&endCheck, dstBuffer+sampleSize, 4);
CHECK(endMark!=endCheck, "ZSTD_decompress on noisy src : dst buffer overflow"); }
- }
- }
+ } } /* noisy src decompression test */
/* Streaming compression of scattered segments test */
XXH64_reset(xxh64, 0);
errorCode = ZSTD_copyCCtx(ctx, refCtx);
CHECK (ZSTD_isError(errorCode), "ZSTD_copyCCtx error : %s", ZSTD_getErrorName(errorCode));
totalTestSize = 0; cSize = 0;
- for (n=0; n<nbChunks; n++)
- {
+ for (n=0; n<nbChunks; n++) {
sampleSizeLog = FUZ_rand(&lseed) % maxSampleLog;
sampleSize = (size_t)1 << sampleSizeLog;
sampleSize += FUZ_rand(&lseed) & (sampleSize-1);
CHECK (ZSTD_isError(errorCode), "cannot init DCtx : %s", ZSTD_getErrorName(errorCode));
totalCSize = 0;
totalGenSize = 0;
- while (totalCSize < cSize)
- {
+ while (totalCSize < cSize) {
size_t inSize = ZSTD_nextSrcSizeToDecompress(dctx);
size_t genSize = ZSTD_decompressContinue(dctx, dstBuffer+totalGenSize, dstBufferSize-totalGenSize, cBuffer+totalCSize, inSize);
CHECK (ZSTD_isError(genSize), "streaming decompression error : %s", ZSTD_getErrorName(genSize));
errorCode = findDiff(mirrorBuffer, dstBuffer, totalTestSize);
CHECK (crcDest!=crcOrig, "streaming decompressed data corrupted : byte %u / %u (%02X!=%02X)",
(U32)errorCode, (U32)totalTestSize, dstBuffer[errorCode], mirrorBuffer[errorCode]);
-
}
DISPLAY("\r%u fuzzer tests completed \n", testNb-1);
}
-/*********************************************************
+/*_*******************************************************
* Command line
*********************************************************/
-int FUZ_usage(char* programName)
+int FUZ_usage(const char* programName)
{
DISPLAY( "Usage :\n");
DISPLAY( " %s [args]\n", programName);
}
-int main(int argc, char** argv)
+int main(int argc, const char** argv)
{
U32 seed=0;
int seedset=0;
int proba = FUZ_COMPRESSIBILITY_DEFAULT;
int result=0;
U32 mainPause = 0;
- char* programName;
+ const char* programName;
/* Check command line */
programName = argv[0];
- for(argNb=1; argNb<argc; argNb++)
- {
- char* argument = argv[argNb];
-
+ for (argNb=1; argNb<argc; argNb++) {
+ const char* argument = argv[argNb];
if(!argument) continue; /* Protection if argument empty */
/* Handle commands. Aggregated commands are allowed */
- if (argument[0]=='-')
- {
+ if (argument[0]=='-') {
argument++;
-
- while (*argument!=0)
- {
+ while (*argument!=0) {
switch(*argument)
{
case 'h':
case 'i':
argument++; g_testTime=0;
nbTests=0;
- while ((*argument>='0') && (*argument<='9'))
- {
+ while ((*argument>='0') && (*argument<='9')) {
nbTests *= 10;
nbTests += *argument - '0';
argument++;
case 'T':
argument++;
nbTests=0; g_testTime=0;
- while ((*argument>='0') && (*argument<='9'))
- {
+ while ((*argument>='0') && (*argument<='9')) {
g_testTime *= 10;
g_testTime += *argument - '0';
argument++;
argument++;
seed=0;
seedset=1;
- while ((*argument>='0') && (*argument<='9'))
- {
+ while ((*argument>='0') && (*argument<='9')) {
seed *= 10;
seed += *argument - '0';
argument++;
case 't':
argument++;
testNb=0;
- while ((*argument>='0') && (*argument<='9'))
- {
+ while ((*argument>='0') && (*argument<='9')) {
testNb *= 10;
testNb += *argument - '0';
argument++;
case 'P': /* compressibility % */
argument++;
proba=0;
- while ((*argument>='0') && (*argument<='9'))
- {
+ while ((*argument>='0') && (*argument<='9')) {
proba *= 10;
proba += *argument - '0';
argument++;
default:
return FUZ_usage(programName);
- }
- }
- }
- }
+ } } } } /* for (argNb=1; argNb<argc; argNb++) */
/* Get Seed */
DISPLAY("Starting zstd tester (%i-bits, %s)\n", (int)(sizeof(size_t)*8), ZSTD_VERSION);
DISPLAY("Seed = %u\n", seed);
if (proba!=FUZ_COMPRESSIBILITY_DEFAULT) DISPLAY("Compressibility : %i%%\n", proba);
- if (testNb==0) result = basicUnitTests(0, ((double)proba) / 100); /* constant seed for predictability */
+ if (testNb==0)
+ result = basicUnitTests(0, ((double)proba) / 100); /* constant seed for predictability */
if (!result)
result = fuzzerTests(seed, nbTests, testNb, ((double)proba) / 100);
- if (mainPause)
- {
+ if (mainPause) {
int unused;
DISPLAY("Press Enter \n");
unused = getchar();
projects / thirdparty / zstd.git / commitdiff
