1 /*
2 fuzzer.c - Fuzzer test tool for LZ4
3 Copyright (C) Yann Collet 2012-2017
4
5 GPL v2 License
6
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2 of the License, or
10 (at your option) any later version.
11
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
16
17 You should have received a copy of the GNU General Public License along
18 with this program; if not, write to the Free Software Foundation, Inc.,
19 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
20
21 You can contact the author at :
22 - LZ4 homepage : http://www.lz4.org
23 - LZ4 source repo : https://github.com/lz4/lz4
24 */
25
26 /*-************************************
27 * Compiler options
28 **************************************/
29 #ifdef _MSC_VER /* Visual Studio */
30 # pragma warning(disable : 4127) /* disable: C4127: conditional expression is constant */
31 # pragma warning(disable : 4146) /* disable: C4146: minus unsigned expression */
32 # pragma warning(disable : 4310) /* disable: C4310: constant char value > 127 */
33 #endif
34
35
36 /*-************************************
37 * Dependencies
38 **************************************/
39 #if defined(__unix__) && !defined(_AIX) /* must be included before platform.h for MAP_ANONYMOUS */
40 # undef _GNU_SOURCE /* in case it's already defined */
41 # define _GNU_SOURCE /* MAP_ANONYMOUS even in -std=c99 mode */
42 # include <sys/mman.h> /* mmap */
43 #endif
44 #include "platform.h" /* _CRT_SECURE_NO_WARNINGS */
45 #include "util.h" /* U32 */
46 #include <stdlib.h>
47 #include <stdio.h> /* fgets, sscanf */
48 #include <string.h> /* strcmp */
49 #include <time.h> /* clock_t, clock, CLOCKS_PER_SEC */
50 #include <assert.h>
51 #include <limits.h> /* INT_MAX */
52
53 #if defined(_AIX)
54 # include <sys/mman.h> /* mmap */
55 #endif
56
57 #define LZ4_DISABLE_DEPRECATE_WARNINGS /* LZ4_decompress_fast */
58 #define LZ4_STATIC_LINKING_ONLY
59 #include "lz4.h"
60 #define LZ4_HC_STATIC_LINKING_ONLY
61 #include "lz4hc.h"
62 #define XXH_STATIC_LINKING_ONLY
63 #include "xxhash.h"
64
65
66 /*-************************************
67 * Basic Types
68 **************************************/
69 #if !defined(__cplusplus) && !(defined (__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) /* C99 */)
70 typedef size_t uintptr_t; /* true on most systems, except OpenVMS-64 (which doesn't need address overflow test) */
71 #endif
72
73
74 /*-************************************
75 * Constants
76 **************************************/
77 #define NB_ATTEMPTS (1<<16)
78 #define COMPRESSIBLE_NOISE_LENGTH (1 << 21)
79 #define FUZ_MAX_BLOCK_SIZE (1 << 17)
80 #define FUZ_MAX_DICT_SIZE (1 << 15)
81 #define FUZ_COMPRESSIBILITY_DEFAULT 60
82 #define PRIME1 2654435761U
83 #define PRIME2 2246822519U
84 #define PRIME3 3266489917U
85
86 #define KB *(1U<<10)
87 #define MB *(1U<<20)
88 #define GB *(1U<<30)
89
90
91 /*-***************************************
92 * Macros
93 *****************************************/
94 #define DISPLAY(...) fprintf(stdout, __VA_ARGS__)
95 #define DISPLAYLEVEL(l, ...) if (g_displayLevel>=l) { DISPLAY(__VA_ARGS__); }
96 static int g_displayLevel = 2;
97
98 #define MIN(a,b) ( (a) < (b) ? (a) : (b) )
99
100
101 /*-*******************************************************
102 * Fuzzer functions
103 *********************************************************/
FUZ_GetClockSpan(clock_t clockStart)104 static clock_t FUZ_GetClockSpan(clock_t clockStart)
105 {
106 return clock() - clockStart; /* works even if overflow; max span ~ 30mn */
107 }
108
FUZ_displayUpdate(unsigned testNb)109 static void FUZ_displayUpdate(unsigned testNb)
110 {
111 static clock_t g_time = 0;
112 static const clock_t g_refreshRate = CLOCKS_PER_SEC / 5;
113 if ((FUZ_GetClockSpan(g_time) > g_refreshRate) || (g_displayLevel>=4)) {
114 g_time = clock();
115 DISPLAY("\r%5u ", testNb);
116 fflush(stdout);
117 }
118 }
119
FUZ_rotl32(U32 u32,U32 nbBits)120 static U32 FUZ_rotl32(U32 u32, U32 nbBits)
121 {
122 return ((u32 << nbBits) | (u32 >> (32 - nbBits)));
123 }
124
FUZ_highbit32(U32 v32)125 static U32 FUZ_highbit32(U32 v32)
126 {
127 unsigned nbBits = 0;
128 if (v32==0) return 0;
129 while (v32) { v32 >>= 1; nbBits++; }
130 return nbBits;
131 }
132
FUZ_rand(U32 * src)133 static U32 FUZ_rand(U32* src)
134 {
135 U32 rand32 = *src;
136 rand32 *= PRIME1;
137 rand32 ^= PRIME2;
138 rand32 = FUZ_rotl32(rand32, 13);
139 *src = rand32;
140 return rand32;
141 }
142
143
144 #define FUZ_RAND15BITS ((FUZ_rand(seed) >> 3) & 32767)
145 #define FUZ_RANDLENGTH ( ((FUZ_rand(seed) >> 7) & 3) ? (FUZ_rand(seed) % 15) : (FUZ_rand(seed) % 510) + 15)
FUZ_fillCompressibleNoiseBuffer(void * buffer,size_t bufferSize,double proba,U32 * seed)146 static void FUZ_fillCompressibleNoiseBuffer(void* buffer, size_t bufferSize, double proba, U32* seed)
147 {
148 BYTE* const BBuffer = (BYTE*)buffer;
149 size_t pos = 0;
150 U32 const P32 = (U32)(32768 * proba);
151
152 /* First Bytes */
153 while (pos < 20)
154 BBuffer[pos++] = (BYTE)(FUZ_rand(seed));
155
156 while (pos < bufferSize) {
157 /* Select : Literal (noise) or copy (within 64K) */
158 if (FUZ_RAND15BITS < P32) {
159 /* Copy (within 64K) */
160 size_t const length = (size_t)FUZ_RANDLENGTH + 4;
161 size_t const d = MIN(pos+length, bufferSize);
162 size_t match;
163 size_t offset = (size_t)FUZ_RAND15BITS + 1;
164 while (offset > pos) offset >>= 1;
165 match = pos - offset;
166 while (pos < d) BBuffer[pos++] = BBuffer[match++];
167 } else {
168 /* Literal (noise) */
169 size_t const length = FUZ_RANDLENGTH;
170 size_t const d = MIN(pos+length, bufferSize);
171 while (pos < d) BBuffer[pos++] = (BYTE)(FUZ_rand(seed) >> 5);
172 }
173 }
174 }
175
176
177 #define MAX_NB_BUFF_I134 150
178 #define BLOCKSIZE_I134 (32 MB)
179 /*! FUZ_AddressOverflow() :
180 * Aggressively pushes memory allocation limits,
181 * and generates patterns which create address space overflow.
182 * only possible in 32-bits mode */
FUZ_AddressOverflow(void)183 static int FUZ_AddressOverflow(void)
184 {
185 char* buffers[MAX_NB_BUFF_I134+1];
186 int nbBuff=0;
187 int highAddress = 0;
188
189 DISPLAY("Overflow tests : ");
190
191 /* Only possible in 32-bits */
192 if (sizeof(void*)==8) {
193 DISPLAY("64 bits mode : no overflow \n");
194 fflush(stdout);
195 return 0;
196 }
197
198 buffers[0] = (char*)malloc(BLOCKSIZE_I134);
199 buffers[1] = (char*)malloc(BLOCKSIZE_I134);
200 if ((!buffers[0]) || (!buffers[1])) {
201 free(buffers[0]); free(buffers[1]);
202 DISPLAY("not enough memory for tests \n");
203 return 0;
204 }
205
206 for (nbBuff=2; nbBuff < MAX_NB_BUFF_I134; nbBuff++) {
207 DISPLAY("%3i \b\b\b\b", nbBuff); fflush(stdout);
208 buffers[nbBuff] = (char*)malloc(BLOCKSIZE_I134);
209 if (buffers[nbBuff]==NULL) goto _endOfTests;
210
211 if (((uintptr_t)buffers[nbBuff] > (uintptr_t)0x80000000) && (!highAddress)) {
212 DISPLAY("high address detected : ");
213 fflush(stdout);
214 highAddress=1;
215 }
216
217 { size_t const sizeToGenerateOverflow = (size_t)(- ((uintptr_t)buffers[nbBuff-1]) + 512);
218 int const nbOf255 = (int)((sizeToGenerateOverflow / 255) + 1);
219 char* const input = buffers[nbBuff-1];
220 char* output = buffers[nbBuff];
221 int r;
222 input[0] = (char)0xF0; /* Literal length overflow */
223 input[1] = (char)0xFF;
224 input[2] = (char)0xFF;
225 input[3] = (char)0xFF;
226 { int u; for(u = 4; u <= nbOf255+4; u++) input[u] = (char)0xff; }
227 r = LZ4_decompress_safe(input, output, nbOf255+64, BLOCKSIZE_I134);
228 if (r>0) { DISPLAY("LZ4_decompress_safe = %i \n", r); goto _overflowError; }
229 input[0] = (char)0x1F; /* Match length overflow */
230 input[1] = (char)0x01;
231 input[2] = (char)0x01;
232 input[3] = (char)0x00;
233 r = LZ4_decompress_safe(input, output, nbOf255+64, BLOCKSIZE_I134);
234 if (r>0) { DISPLAY("LZ4_decompress_safe = %i \n", r); goto _overflowError; }
235
236 output = buffers[nbBuff-2]; /* Reverse in/out pointer order */
237 input[0] = (char)0xF0; /* Literal length overflow */
238 input[1] = (char)0xFF;
239 input[2] = (char)0xFF;
240 input[3] = (char)0xFF;
241 r = LZ4_decompress_safe(input, output, nbOf255+64, BLOCKSIZE_I134);
242 if (r>0) goto _overflowError;
243 input[0] = (char)0x1F; /* Match length overflow */
244 input[1] = (char)0x01;
245 input[2] = (char)0x01;
246 input[3] = (char)0x00;
247 r = LZ4_decompress_safe(input, output, nbOf255+64, BLOCKSIZE_I134);
248 if (r>0) goto _overflowError;
249 }
250 }
251
252 nbBuff++;
253 _endOfTests:
254 { int i; for (i=0 ; i<nbBuff; i++) free(buffers[i]); }
255 if (!highAddress) DISPLAY("high address not possible \n");
256 else DISPLAY("all overflows correctly detected \n");
257 return 0;
258
259 _overflowError:
260 DISPLAY("Address space overflow error !! \n");
261 exit(1);
262 }
263
264
265 #ifdef __unix__ /* is expected to be triggered on linux+gcc */
266
FUZ_createLowAddr(size_t size)267 static void* FUZ_createLowAddr(size_t size)
268 {
269 void* const lowBuff = mmap((void*)(0x1000), size,
270 PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS,
271 -1, 0);
272 DISPLAYLEVEL(2, "generating low buffer at address %p \n", lowBuff);
273 return lowBuff;
274 }
275
FUZ_freeLowAddr(void * buffer,size_t size)276 static void FUZ_freeLowAddr(void* buffer, size_t size)
277 {
278 if (munmap(buffer, size)) {
279 perror("fuzzer: freeing low address buffer");
280 abort();
281 }
282 }
283
284 #else
285
FUZ_createLowAddr(size_t size)286 static void* FUZ_createLowAddr(size_t size)
287 {
288 return malloc(size);
289 }
290
FUZ_freeLowAddr(void * buffer,size_t size)291 static void FUZ_freeLowAddr(void* buffer, size_t size)
292 {
293 (void)size;
294 free(buffer);
295 }
296
297 #endif
298
299
300 /*! FUZ_findDiff() :
301 * find the first different byte between buff1 and buff2.
302 * presumes buff1 != buff2.
303 * presumes a difference exists before end of either buffer.
304 * Typically invoked after a checksum mismatch.
305 */
FUZ_findDiff(const void * buff1,const void * buff2)306 static void FUZ_findDiff(const void* buff1, const void* buff2)
307 {
308 const BYTE* const b1 = (const BYTE*)buff1;
309 const BYTE* const b2 = (const BYTE*)buff2;
310 size_t u = 0;
311 while (b1[u]==b2[u]) u++;
312 DISPLAY("\nWrong Byte at position %u \n", (unsigned)u);
313 }
314
315
FUZ_test(U32 seed,U32 nbCycles,const U32 startCycle,const double compressibility,U32 duration_s)316 static int FUZ_test(U32 seed, U32 nbCycles, const U32 startCycle, const double compressibility, U32 duration_s)
317 {
318 unsigned long long bytes = 0;
319 unsigned long long cbytes = 0;
320 unsigned long long hcbytes = 0;
321 unsigned long long ccbytes = 0;
322 void* const CNBuffer = malloc(COMPRESSIBLE_NOISE_LENGTH);
323 size_t const compressedBufferSize = (size_t)LZ4_compressBound(FUZ_MAX_BLOCK_SIZE);
324 char* const compressedBuffer = (char*)malloc(compressedBufferSize);
325 char* const decodedBuffer = (char*)malloc(FUZ_MAX_DICT_SIZE + FUZ_MAX_BLOCK_SIZE);
326 size_t const labSize = 96 KB;
327 void* const lowAddrBuffer = FUZ_createLowAddr(labSize);
328 void* const stateLZ4 = malloc((size_t)LZ4_sizeofState());
329 void* const stateLZ4HC = malloc((size_t)LZ4_sizeofStateHC());
330 LZ4_stream_t LZ4dictBody;
331 LZ4_streamHC_t* LZ4dictHC = LZ4_createStreamHC();
332 U32 coreRandState = seed;
333 clock_t const clockStart = clock();
334 clock_t const clockDuration = (clock_t)duration_s * CLOCKS_PER_SEC;
335 int result = 0;
336 unsigned cycleNb;
337
338 # define EXIT_MSG(...) { \
339 printf("Test %u : ", testNb); printf(__VA_ARGS__); \
340 printf(" (seed %u, cycle %u) \n", seed, cycleNb); \
341 exit(1); \
342 }
343
344 # define FUZ_CHECKTEST(cond, ...) if (cond) { EXIT_MSG(__VA_ARGS__) }
345
346 # define FUZ_DISPLAYTEST(...) { \
347 testNb++; \
348 if (g_displayLevel>=4) { \
349 printf("\r%4u - %2u :", cycleNb, testNb); \
350 printf(" " __VA_ARGS__); \
351 printf(" "); \
352 fflush(stdout); \
353 } }
354
355
356 /* init */
357 if(!CNBuffer || !compressedBuffer || !decodedBuffer || !LZ4dictHC) {
358 DISPLAY("Not enough memory to start fuzzer tests");
359 exit(1);
360 }
361 if ( LZ4_initStream(&LZ4dictBody, sizeof(LZ4dictBody)) == NULL) abort();
362 { U32 randState = coreRandState ^ PRIME3;
363 FUZ_fillCompressibleNoiseBuffer(CNBuffer, COMPRESSIBLE_NOISE_LENGTH, compressibility, &randState);
364 }
365
366 /* move to startCycle */
367 for (cycleNb = 0; cycleNb < startCycle; cycleNb++)
368 (void) FUZ_rand(&coreRandState); /* sync coreRandState */
369
370 /* Main test loop */
371 for (cycleNb = startCycle;
372 (cycleNb < nbCycles) || (FUZ_GetClockSpan(clockStart) < clockDuration);
373 cycleNb++) {
374 U32 testNb = 0;
375 U32 randState = FUZ_rand(&coreRandState) ^ PRIME3;
376 int const blockSize = (FUZ_rand(&randState) % (FUZ_MAX_BLOCK_SIZE-1)) + 1;
377 int const blockStart = (int)(FUZ_rand(&randState) % (U32)(COMPRESSIBLE_NOISE_LENGTH - blockSize - 1)) + 1;
378 int const dictSizeRand = FUZ_rand(&randState) % FUZ_MAX_DICT_SIZE;
379 int const dictSize = MIN(dictSizeRand, blockStart - 1);
380 int const compressionLevel = FUZ_rand(&randState) % (LZ4HC_CLEVEL_MAX+1);
381 const char* block = ((char*)CNBuffer) + blockStart;
382 const char* dict = block - dictSize;
383 int compressedSize, HCcompressedSize;
384 int blockContinueCompressedSize;
385 U32 const crcOrig = XXH32(block, (size_t)blockSize, 0);
386 int ret;
387
388 FUZ_displayUpdate(cycleNb);
389
390 /* Compression tests */
391 if ( ((FUZ_rand(&randState) & 63) == 2)
392 && ((size_t)blockSize < labSize) ) {
393 memcpy(lowAddrBuffer, block, blockSize);
394 block = (const char*)lowAddrBuffer;
395 }
396
397 /* Test compression destSize */
398 FUZ_DISPLAYTEST("test LZ4_compress_destSize()");
399 { int cSize, srcSize = blockSize;
400 int const targetSize = srcSize * (int)((FUZ_rand(&randState) & 127)+1) >> 7;
401 char const endCheck = (char)(FUZ_rand(&randState) & 255);
402 compressedBuffer[targetSize] = endCheck;
403 cSize = LZ4_compress_destSize(block, compressedBuffer, &srcSize, targetSize);
404 FUZ_CHECKTEST(cSize > targetSize, "LZ4_compress_destSize() result larger than dst buffer !");
405 FUZ_CHECKTEST(compressedBuffer[targetSize] != endCheck, "LZ4_compress_destSize() overwrite dst buffer !");
406 FUZ_CHECKTEST(srcSize > blockSize, "LZ4_compress_destSize() read more than src buffer !");
407 DISPLAYLEVEL(5, "destSize : %7i/%7i; content%7i/%7i ", cSize, targetSize, srcSize, blockSize);
408 if (targetSize>0) {
409 /* check correctness */
410 U32 const crcBase = XXH32(block, (size_t)srcSize, 0);
411 char const canary = (char)(FUZ_rand(&randState) & 255);
412 FUZ_CHECKTEST((cSize==0), "LZ4_compress_destSize() compression failed");
413 FUZ_DISPLAYTEST();
414 decodedBuffer[srcSize] = canary;
415 { int const dSize = LZ4_decompress_safe(compressedBuffer, decodedBuffer, cSize, srcSize);
416 FUZ_CHECKTEST(dSize<0, "LZ4_decompress_safe() failed on data compressed by LZ4_compress_destSize");
417 FUZ_CHECKTEST(dSize!=srcSize, "LZ4_decompress_safe() failed : did not fully decompressed data");
418 }
419 FUZ_CHECKTEST(decodedBuffer[srcSize] != canary, "LZ4_decompress_safe() overwrite dst buffer !");
420 { U32 const crcDec = XXH32(decodedBuffer, (size_t)srcSize, 0);
421 FUZ_CHECKTEST(crcDec!=crcBase, "LZ4_decompress_safe() corrupted decoded data");
422 } }
423 DISPLAYLEVEL(5, " OK \n");
424 }
425
426 /* Test compression HC destSize */
427 FUZ_DISPLAYTEST("test LZ4_compress_HC_destSize()");
428 { int cSize, srcSize = blockSize;
429 int const targetSize = srcSize * (int)((FUZ_rand(&randState) & 127)+1) >> 7;
430 char const endCheck = (char)(FUZ_rand(&randState) & 255);
431 void* const ctx = LZ4_createHC(block);
432 FUZ_CHECKTEST(ctx==NULL, "LZ4_createHC() allocation failed");
433 compressedBuffer[targetSize] = endCheck;
434 cSize = LZ4_compress_HC_destSize(ctx, block, compressedBuffer, &srcSize, targetSize, compressionLevel);
435 DISPLAYLEVEL(5, "LZ4_compress_HC_destSize(%i): destSize : %7i/%7i; content%7i/%7i ",
436 compressionLevel, cSize, targetSize, srcSize, blockSize);
437 LZ4_freeHC(ctx);
438 FUZ_CHECKTEST(cSize > targetSize, "LZ4_compress_HC_destSize() result larger than dst buffer !");
439 FUZ_CHECKTEST(compressedBuffer[targetSize] != endCheck, "LZ4_compress_HC_destSize() overwrite dst buffer !");
440 FUZ_CHECKTEST(srcSize > blockSize, "LZ4_compress_HC_destSize() fed more than src buffer !");
441 if (targetSize>0) {
442 /* check correctness */
443 U32 const crcBase = XXH32(block, (size_t)srcSize, 0);
444 char const canary = (char)(FUZ_rand(&randState) & 255);
445 FUZ_CHECKTEST((cSize==0), "LZ4_compress_HC_destSize() compression failed");
446 FUZ_DISPLAYTEST();
447 decodedBuffer[srcSize] = canary;
448 { int const dSize = LZ4_decompress_safe(compressedBuffer, decodedBuffer, cSize, srcSize);
449 FUZ_CHECKTEST(dSize<0, "LZ4_decompress_safe failed (%i) on data compressed by LZ4_compressHC_destSize", dSize);
450 FUZ_CHECKTEST(dSize!=srcSize, "LZ4_decompress_safe failed : decompressed %i bytes, was supposed to decompress %i bytes", dSize, srcSize);
451 }
452 FUZ_CHECKTEST(decodedBuffer[srcSize] != canary, "LZ4_decompress_safe overwrite dst buffer !");
453 { U32 const crcDec = XXH32(decodedBuffer, (size_t)srcSize, 0);
454 FUZ_CHECKTEST(crcDec!=crcBase, "LZ4_decompress_safe() corrupted decoded data");
455 } }
456 DISPLAYLEVEL(5, " OK \n");
457 }
458
459 /* Test compression HC */
460 FUZ_DISPLAYTEST("test LZ4_compress_HC()");
461 HCcompressedSize = LZ4_compress_HC(block, compressedBuffer, blockSize, (int)compressedBufferSize, compressionLevel);
462 FUZ_CHECKTEST(HCcompressedSize==0, "LZ4_compress_HC() failed");
463
464 /* Test compression HC using external state */
465 FUZ_DISPLAYTEST("test LZ4_compress_HC_extStateHC()");
466 { int const r = LZ4_compress_HC_extStateHC(stateLZ4HC, block, compressedBuffer, blockSize, (int)compressedBufferSize, compressionLevel);
467 FUZ_CHECKTEST(r==0, "LZ4_compress_HC_extStateHC() failed")
468 }
469
470 /* Test compression HC using fast reset external state */
471 FUZ_DISPLAYTEST("test LZ4_compress_HC_extStateHC_fastReset()");
472 { int const r = LZ4_compress_HC_extStateHC_fastReset(stateLZ4HC, block, compressedBuffer, blockSize, (int)compressedBufferSize, compressionLevel);
473 FUZ_CHECKTEST(r==0, "LZ4_compress_HC_extStateHC_fastReset() failed");
474 }
475
476 /* Test compression using external state */
477 FUZ_DISPLAYTEST("test LZ4_compress_fast_extState()");
478 { int const r = LZ4_compress_fast_extState(stateLZ4, block, compressedBuffer, blockSize, (int)compressedBufferSize, 8);
479 FUZ_CHECKTEST(r==0, "LZ4_compress_fast_extState() failed"); }
480
481 /* Test compression using fast reset external state*/
482 FUZ_DISPLAYTEST();
483 { int const r = LZ4_compress_fast_extState_fastReset(stateLZ4, block, compressedBuffer, blockSize, (int)compressedBufferSize, 8);
484 FUZ_CHECKTEST(r==0, "LZ4_compress_fast_extState_fastReset() failed"); }
485
486 /* Test compression */
487 FUZ_DISPLAYTEST("test LZ4_compress_default()");
488 compressedSize = LZ4_compress_default(block, compressedBuffer, blockSize, (int)compressedBufferSize);
489 FUZ_CHECKTEST(compressedSize<=0, "LZ4_compress_default() failed");
490
491 /* Decompression tests */
492
493 /* Test decompress_fast() with input buffer size exactly correct => must not read out of bound */
494 { char* const cBuffer_exact = (char*)malloc((size_t)compressedSize);
495 assert(cBuffer_exact != NULL);
496 assert(compressedSize <= (int)compressedBufferSize);
497 memcpy(cBuffer_exact, compressedBuffer, compressedSize);
498
499 /* Test decoding with output size exactly correct => must work */
500 FUZ_DISPLAYTEST("LZ4_decompress_fast() with exact output buffer");
501 { int const r = LZ4_decompress_fast(cBuffer_exact, decodedBuffer, blockSize);
502 FUZ_CHECKTEST(r<0, "LZ4_decompress_fast failed despite correct space");
503 FUZ_CHECKTEST(r!=compressedSize, "LZ4_decompress_fast failed : did not fully read compressed data");
504 }
505 { U32 const crcCheck = XXH32(decodedBuffer, (size_t)blockSize, 0);
506 FUZ_CHECKTEST(crcCheck!=crcOrig, "LZ4_decompress_fast corrupted decoded data");
507 }
508
509 /* Test decoding with one byte missing => must fail */
510 FUZ_DISPLAYTEST("LZ4_decompress_fast() with output buffer 1-byte too short");
511 decodedBuffer[blockSize-1] = 0;
512 { int const r = LZ4_decompress_fast(cBuffer_exact, decodedBuffer, blockSize-1);
513 FUZ_CHECKTEST(r>=0, "LZ4_decompress_fast should have failed, due to Output Size being too small");
514 }
515 FUZ_CHECKTEST(decodedBuffer[blockSize-1]!=0, "LZ4_decompress_fast overrun specified output buffer");
516
517 /* Test decoding with one byte too much => must fail */
518 FUZ_DISPLAYTEST();
519 { int const r = LZ4_decompress_fast(cBuffer_exact, decodedBuffer, blockSize+1);
520 FUZ_CHECKTEST(r>=0, "LZ4_decompress_fast should have failed, due to Output Size being too large");
521 }
522
523 /* Test decoding with output size exactly what's necessary => must work */
524 FUZ_DISPLAYTEST();
525 decodedBuffer[blockSize] = 0;
526 { int const r = LZ4_decompress_safe(cBuffer_exact, decodedBuffer, compressedSize, blockSize);
527 FUZ_CHECKTEST(r<0, "LZ4_decompress_safe failed despite sufficient space");
528 FUZ_CHECKTEST(r!=blockSize, "LZ4_decompress_safe did not regenerate original data");
529 }
530 FUZ_CHECKTEST(decodedBuffer[blockSize], "LZ4_decompress_safe overrun specified output buffer size");
531 { U32 const crcCheck = XXH32(decodedBuffer, (size_t)blockSize, 0);
532 FUZ_CHECKTEST(crcCheck!=crcOrig, "LZ4_decompress_safe corrupted decoded data");
533 }
534
535 /* Test decoding with more than enough output size => must work */
536 FUZ_DISPLAYTEST();
537 decodedBuffer[blockSize] = 0;
538 decodedBuffer[blockSize+1] = 0;
539 { int const r = LZ4_decompress_safe(cBuffer_exact, decodedBuffer, compressedSize, blockSize+1);
540 FUZ_CHECKTEST(r<0, "LZ4_decompress_safe failed despite amply sufficient space");
541 FUZ_CHECKTEST(r!=blockSize, "LZ4_decompress_safe did not regenerate original data");
542 }
543 FUZ_CHECKTEST(decodedBuffer[blockSize+1], "LZ4_decompress_safe overrun specified output buffer size");
544 { U32 const crcCheck = XXH32(decodedBuffer, (size_t)blockSize, 0);
545 FUZ_CHECKTEST(crcCheck!=crcOrig, "LZ4_decompress_safe corrupted decoded data");
546 }
547
548 /* Test decoding with output size being one byte too short => must fail */
549 FUZ_DISPLAYTEST();
550 decodedBuffer[blockSize-1] = 0;
551 { int const r = LZ4_decompress_safe(cBuffer_exact, decodedBuffer, compressedSize, blockSize-1);
552 FUZ_CHECKTEST(r>=0, "LZ4_decompress_safe should have failed, due to Output Size being one byte too short");
553 }
554 FUZ_CHECKTEST(decodedBuffer[blockSize-1], "LZ4_decompress_safe overrun specified output buffer size");
555
556 /* Test decoding with output size being 10 bytes too short => must fail */
557 FUZ_DISPLAYTEST();
558 if (blockSize>10) {
559 decodedBuffer[blockSize-10] = 0;
560 { int const r = LZ4_decompress_safe(cBuffer_exact, decodedBuffer, compressedSize, blockSize-10);
561 FUZ_CHECKTEST(r>=0, "LZ4_decompress_safe should have failed, due to Output Size being 10 bytes too short");
562 }
563 FUZ_CHECKTEST(decodedBuffer[blockSize-10], "LZ4_decompress_safe overrun specified output buffer size");
564 }
565
566 /* noisy src decompression test */
567
568 /* insert noise into src */
569 { U32 const maxNbBits = FUZ_highbit32((U32)compressedSize);
570 size_t pos = 0;
571 for (;;) {
572 /* keep some original src */
573 { U32 const nbBits = FUZ_rand(&randState) % maxNbBits;
574 size_t const mask = (1<<nbBits) - 1;
575 size_t const skipLength = FUZ_rand(&randState) & mask;
576 pos += skipLength;
577 }
578 if (pos >= (size_t)compressedSize) break;
579 /* add noise */
580 { U32 const nbBitsCodes = FUZ_rand(&randState) % maxNbBits;
581 U32 const nbBits = nbBitsCodes ? nbBitsCodes-1 : 0;
582 size_t const mask = (1<<nbBits) - 1;
583 size_t const rNoiseLength = (FUZ_rand(&randState) & mask) + 1;
584 size_t const noiseLength = MIN(rNoiseLength, (size_t)compressedSize-pos);
585 size_t const noiseStart = FUZ_rand(&randState) % (COMPRESSIBLE_NOISE_LENGTH - noiseLength);
586 memcpy(cBuffer_exact + pos, (const char*)CNBuffer + noiseStart, noiseLength);
587 pos += noiseLength;
588 } } }
589
590 /* decompress noisy source */
591 FUZ_DISPLAYTEST("decompress noisy source ");
592 { U32 const endMark = 0xA9B1C3D6;
593 memcpy(decodedBuffer+blockSize, &endMark, sizeof(endMark));
594 { int const decompressResult = LZ4_decompress_safe(cBuffer_exact, decodedBuffer, compressedSize, blockSize);
595 /* result *may* be an unlikely success, but even then, it must strictly respect dst buffer boundaries */
596 FUZ_CHECKTEST(decompressResult > blockSize, "LZ4_decompress_safe on noisy src : result is too large : %u > %u (dst buffer)", (unsigned)decompressResult, (unsigned)blockSize);
597 }
598 { U32 endCheck; memcpy(&endCheck, decodedBuffer+blockSize, sizeof(endCheck));
599 FUZ_CHECKTEST(endMark!=endCheck, "LZ4_decompress_safe on noisy src : dst buffer overflow");
600 } } /* noisy src decompression test */
601
602 free(cBuffer_exact);
603 }
604
605 /* Test decoding with input size being one byte too short => must fail */
606 FUZ_DISPLAYTEST();
607 { int const r = LZ4_decompress_safe(compressedBuffer, decodedBuffer, compressedSize-1, blockSize);
608 FUZ_CHECKTEST(r>=0, "LZ4_decompress_safe should have failed, due to input size being one byte too short (blockSize=%i, result=%i, compressedSize=%i)", blockSize, r, compressedSize);
609 }
610
611 /* Test decoding with input size being one byte too large => must fail */
612 FUZ_DISPLAYTEST();
613 decodedBuffer[blockSize] = 0;
614 { int const r = LZ4_decompress_safe(compressedBuffer, decodedBuffer, compressedSize+1, blockSize);
615 FUZ_CHECKTEST(r>=0, "LZ4_decompress_safe should have failed, due to input size being too large");
616 }
617 FUZ_CHECKTEST(decodedBuffer[blockSize], "LZ4_decompress_safe overrun specified output buffer size");
618
619 /* Test partial decoding => must work */
620 FUZ_DISPLAYTEST("test LZ4_decompress_safe_partial");
621 { size_t const missingOutBytes = FUZ_rand(&randState) % (unsigned)blockSize;
622 int const targetSize = (int)((size_t)blockSize - missingOutBytes);
623 size_t const extraneousInBytes = FUZ_rand(&randState) % 2;
624 int const inCSize = (int)((size_t)compressedSize + extraneousInBytes);
625 char const sentinel = decodedBuffer[targetSize] = block[targetSize] ^ 0x5A;
626 int const decResult = LZ4_decompress_safe_partial(compressedBuffer, decodedBuffer, inCSize, targetSize, blockSize);
627 FUZ_CHECKTEST(decResult<0, "LZ4_decompress_safe_partial failed despite valid input data (error:%i)", decResult);
628 FUZ_CHECKTEST(decResult != targetSize, "LZ4_decompress_safe_partial did not regenerated required amount of data (%i < %i <= %i)", decResult, targetSize, blockSize);
629 FUZ_CHECKTEST(decodedBuffer[targetSize] != sentinel, "LZ4_decompress_safe_partial overwrite beyond requested size (though %i <= %i <= %i)", decResult, targetSize, blockSize);
630 FUZ_CHECKTEST(memcmp(block, decodedBuffer, (size_t)targetSize), "LZ4_decompress_safe_partial: corruption detected in regenerated data");
631 }
632
633 /* Test Compression with limited output size */
634
635 /* Test compression with output size being exactly what's necessary (should work) */
636 FUZ_DISPLAYTEST("test LZ4_compress_default() with output buffer just the right size");
637 ret = LZ4_compress_default(block, compressedBuffer, blockSize, compressedSize);
638 FUZ_CHECKTEST(ret==0, "LZ4_compress_default() failed despite sufficient space");
639
640 /* Test compression with output size being exactly what's necessary and external state (should work) */
641 FUZ_DISPLAYTEST("test LZ4_compress_fast_extState() with output buffer just the right size");
642 ret = LZ4_compress_fast_extState(stateLZ4, block, compressedBuffer, blockSize, compressedSize, 1);
643 FUZ_CHECKTEST(ret==0, "LZ4_compress_fast_extState() failed despite sufficient space");
644
645 /* Test HC compression with output size being exactly what's necessary (should work) */
646 FUZ_DISPLAYTEST("test LZ4_compress_HC() with output buffer just the right size");
647 ret = LZ4_compress_HC(block, compressedBuffer, blockSize, HCcompressedSize, compressionLevel);
648 FUZ_CHECKTEST(ret==0, "LZ4_compress_HC() failed despite sufficient space");
649
650 /* Test HC compression with output size being exactly what's necessary (should work) */
651 FUZ_DISPLAYTEST("test LZ4_compress_HC_extStateHC() with output buffer just the right size");
652 ret = LZ4_compress_HC_extStateHC(stateLZ4HC, block, compressedBuffer, blockSize, HCcompressedSize, compressionLevel);
653 FUZ_CHECKTEST(ret==0, "LZ4_compress_HC_extStateHC() failed despite sufficient space");
654
655 /* Test compression with missing bytes into output buffer => must fail */
656 FUZ_DISPLAYTEST("test LZ4_compress_default() with output buffer a bit too short");
657 { int missingBytes = (FUZ_rand(&randState) % 0x3F) + 1;
658 if (missingBytes >= compressedSize) missingBytes = compressedSize-1;
659 missingBytes += !missingBytes; /* avoid special case missingBytes==0 */
660 compressedBuffer[compressedSize-missingBytes] = 0;
661 { int const cSize = LZ4_compress_default(block, compressedBuffer, blockSize, compressedSize-missingBytes);
662 FUZ_CHECKTEST(cSize, "LZ4_compress_default should have failed (output buffer too small by %i byte)", missingBytes);
663 }
664 FUZ_CHECKTEST(compressedBuffer[compressedSize-missingBytes], "LZ4_compress_default overran output buffer ! (%i missingBytes)", missingBytes)
665 }
666
667 /* Test HC compression with missing bytes into output buffer => must fail */
668 FUZ_DISPLAYTEST("test LZ4_compress_HC() with output buffer a bit too short");
669 { int missingBytes = (FUZ_rand(&randState) % 0x3F) + 1;
670 if (missingBytes >= HCcompressedSize) missingBytes = HCcompressedSize-1;
671 missingBytes += !missingBytes; /* avoid special case missingBytes==0 */
672 compressedBuffer[HCcompressedSize-missingBytes] = 0;
673 { int const hcSize = LZ4_compress_HC(block, compressedBuffer, blockSize, HCcompressedSize-missingBytes, compressionLevel);
674 FUZ_CHECKTEST(hcSize, "LZ4_compress_HC should have failed (output buffer too small by %i byte)", missingBytes);
675 }
676 FUZ_CHECKTEST(compressedBuffer[HCcompressedSize-missingBytes], "LZ4_compress_HC overran output buffer ! (%i missingBytes)", missingBytes)
677 }
678
679
680 /*-******************/
681 /* Dictionary tests */
682 /*-******************/
683
684 /* Compress using dictionary */
685 FUZ_DISPLAYTEST("test LZ4_compress_fast_continue() with dictionary of size %i", dictSize);
686 { LZ4_stream_t LZ4_stream;
687 LZ4_initStream(&LZ4_stream, sizeof(LZ4_stream));
688 LZ4_compress_fast_continue (&LZ4_stream, dict, compressedBuffer, dictSize, (int)compressedBufferSize, 1); /* Just to fill hash tables */
689 blockContinueCompressedSize = LZ4_compress_fast_continue (&LZ4_stream, block, compressedBuffer, blockSize, (int)compressedBufferSize, 1);
690 FUZ_CHECKTEST(blockContinueCompressedSize==0, "LZ4_compress_fast_continue failed");
691 }
692
693 /* Decompress with dictionary as prefix */
694 FUZ_DISPLAYTEST("test LZ4_decompress_fast_usingDict() with dictionary as prefix");
695 memcpy(decodedBuffer, dict, dictSize);
696 ret = LZ4_decompress_fast_usingDict(compressedBuffer, decodedBuffer+dictSize, blockSize, decodedBuffer, dictSize);
697 FUZ_CHECKTEST(ret!=blockContinueCompressedSize, "LZ4_decompress_fast_usingDict did not read all compressed block input");
698 { U32 const crcCheck = XXH32(decodedBuffer+dictSize, (size_t)blockSize, 0);
699 if (crcCheck!=crcOrig) {
700 FUZ_findDiff(block, decodedBuffer);
701 EXIT_MSG("LZ4_decompress_fast_usingDict corrupted decoded data (dict %i)", dictSize);
702 } }
703
704 FUZ_DISPLAYTEST("test LZ4_decompress_safe_usingDict()");
705 ret = LZ4_decompress_safe_usingDict(compressedBuffer, decodedBuffer+dictSize, blockContinueCompressedSize, blockSize, decodedBuffer, dictSize);
706 FUZ_CHECKTEST(ret!=blockSize, "LZ4_decompress_safe_usingDict did not regenerate original data");
707 { U32 const crcCheck = XXH32(decodedBuffer+dictSize, (size_t)blockSize, 0);
708 FUZ_CHECKTEST(crcCheck!=crcOrig, "LZ4_decompress_safe_usingDict corrupted decoded data");
709 }
710
711 /* Compress using External dictionary */
712 FUZ_DISPLAYTEST("test LZ4_compress_fast_continue(), with non-contiguous dictionary");
713 dict -= (size_t)(FUZ_rand(&randState) & 0xF) + 1; /* create space, so now dictionary is an ExtDict */
714 if (dict < (char*)CNBuffer) dict = (char*)CNBuffer;
715 LZ4_loadDict(&LZ4dictBody, dict, dictSize);
716 blockContinueCompressedSize = LZ4_compress_fast_continue(&LZ4dictBody, block, compressedBuffer, blockSize, (int)compressedBufferSize, 1);
717 FUZ_CHECKTEST(blockContinueCompressedSize==0, "LZ4_compress_fast_continue failed");
718
719 FUZ_DISPLAYTEST("LZ4_compress_fast_continue() with dictionary and output buffer too short by one byte");
720 LZ4_loadDict(&LZ4dictBody, dict, dictSize);
721 ret = LZ4_compress_fast_continue(&LZ4dictBody, block, compressedBuffer, blockSize, blockContinueCompressedSize-1, 1);
722 FUZ_CHECKTEST(ret>0, "LZ4_compress_fast_continue using ExtDict should fail : one missing byte for output buffer : %i written, %i buffer", ret, blockContinueCompressedSize);
723
724 FUZ_DISPLAYTEST("test LZ4_compress_fast_continue() with dictionary loaded with LZ4_loadDict()");
725 DISPLAYLEVEL(5, " compress %i bytes from buffer(%p) into dst(%p) using dict(%p) of size %i \n",
726 blockSize, (const void *)block, (void *)decodedBuffer, (const void *)dict, dictSize);
727 LZ4_loadDict(&LZ4dictBody, dict, dictSize);
728 ret = LZ4_compress_fast_continue(&LZ4dictBody, block, compressedBuffer, blockSize, blockContinueCompressedSize, 1);
729 FUZ_CHECKTEST(ret!=blockContinueCompressedSize, "LZ4_compress_limitedOutput_compressed size is different (%i != %i)", ret, blockContinueCompressedSize);
730 FUZ_CHECKTEST(ret<=0, "LZ4_compress_fast_continue should work : enough size available within output buffer");
731
732 /* Decompress with dictionary as external */
733 FUZ_DISPLAYTEST("test LZ4_decompress_fast_usingDict() with dictionary as extDict");
734 DISPLAYLEVEL(5, " decoding %i bytes from buffer(%p) using dict(%p) of size %i \n",
735 blockSize, (void *)decodedBuffer, (const void *)dict, dictSize);
736 decodedBuffer[blockSize] = 0;
737 ret = LZ4_decompress_fast_usingDict(compressedBuffer, decodedBuffer, blockSize, dict, dictSize);
738 FUZ_CHECKTEST(ret!=blockContinueCompressedSize, "LZ4_decompress_fast_usingDict did not read all compressed block input");
739 FUZ_CHECKTEST(decodedBuffer[blockSize], "LZ4_decompress_fast_usingDict overrun specified output buffer size");
740 { U32 const crcCheck = XXH32(decodedBuffer, (size_t)blockSize, 0);
741 if (crcCheck!=crcOrig) {
742 FUZ_findDiff(block, decodedBuffer);
743 EXIT_MSG("LZ4_decompress_fast_usingDict corrupted decoded data (dict %i)", dictSize);
744 } }
745
746 FUZ_DISPLAYTEST();
747 decodedBuffer[blockSize] = 0;
748 ret = LZ4_decompress_safe_usingDict(compressedBuffer, decodedBuffer, blockContinueCompressedSize, blockSize, dict, dictSize);
749 FUZ_CHECKTEST(ret!=blockSize, "LZ4_decompress_safe_usingDict did not regenerate original data");
750 FUZ_CHECKTEST(decodedBuffer[blockSize], "LZ4_decompress_safe_usingDict overrun specified output buffer size");
751 { U32 const crcCheck = XXH32(decodedBuffer, (size_t)blockSize, 0);
752 FUZ_CHECKTEST(crcCheck!=crcOrig, "LZ4_decompress_safe_usingDict corrupted decoded data");
753 }
754
755 FUZ_DISPLAYTEST();
756 decodedBuffer[blockSize-1] = 0;
757 ret = LZ4_decompress_fast_usingDict(compressedBuffer, decodedBuffer, blockSize-1, dict, dictSize);
758 FUZ_CHECKTEST(ret>=0, "LZ4_decompress_fast_usingDict should have failed : wrong original size (-1 byte)");
759 FUZ_CHECKTEST(decodedBuffer[blockSize-1], "LZ4_decompress_fast_usingDict overrun specified output buffer size");
760
761 FUZ_DISPLAYTEST();
762 decodedBuffer[blockSize-1] = 0;
763 ret = LZ4_decompress_safe_usingDict(compressedBuffer, decodedBuffer, blockContinueCompressedSize, blockSize-1, dict, dictSize);
764 FUZ_CHECKTEST(ret>=0, "LZ4_decompress_safe_usingDict should have failed : not enough output size (-1 byte)");
765 FUZ_CHECKTEST(decodedBuffer[blockSize-1], "LZ4_decompress_safe_usingDict overrun specified output buffer size");
766
767 FUZ_DISPLAYTEST();
768 { int const missingBytes = (FUZ_rand(&randState) & 0xF) + 2;
769 if (blockSize > missingBytes) {
770 decodedBuffer[blockSize-missingBytes] = 0;
771 ret = LZ4_decompress_safe_usingDict(compressedBuffer, decodedBuffer, blockContinueCompressedSize, blockSize-missingBytes, dict, dictSize);
772 FUZ_CHECKTEST(ret>=0, "LZ4_decompress_safe_usingDict should have failed : output buffer too small (-%i byte)", missingBytes);
773 FUZ_CHECKTEST(decodedBuffer[blockSize-missingBytes], "LZ4_decompress_safe_usingDict overrun specified output buffer size (-%i byte) (blockSize=%i)", missingBytes, blockSize);
774 } }
775
776 /* Compress using external dictionary stream */
777 { LZ4_stream_t LZ4_stream;
778 int expectedSize;
779 U32 expectedCrc;
780
781 FUZ_DISPLAYTEST("LZ4_compress_fast_continue() after LZ4_loadDict()");
782 LZ4_loadDict(&LZ4dictBody, dict, dictSize);
783 expectedSize = LZ4_compress_fast_continue(&LZ4dictBody, block, compressedBuffer, blockSize, (int)compressedBufferSize, 1);
784 FUZ_CHECKTEST(expectedSize<=0, "LZ4_compress_fast_continue reference compression for extDictCtx should have succeeded");
785 expectedCrc = XXH32(compressedBuffer, (size_t)expectedSize, 0);
786
787 FUZ_DISPLAYTEST("LZ4_compress_fast_continue() after LZ4_attach_dictionary()");
788 LZ4_loadDict(&LZ4dictBody, dict, dictSize);
789 LZ4_initStream(&LZ4_stream, sizeof(LZ4_stream));
790 LZ4_attach_dictionary(&LZ4_stream, &LZ4dictBody);
791 blockContinueCompressedSize = LZ4_compress_fast_continue(&LZ4_stream, block, compressedBuffer, blockSize, (int)compressedBufferSize, 1);
792 FUZ_CHECKTEST(blockContinueCompressedSize==0, "LZ4_compress_fast_continue using extDictCtx failed");
793
794 /* In the future, it might be desirable to let extDictCtx mode's
795 * output diverge from the output generated by regular extDict mode.
796 * Until that time, this comparison serves as a good regression
797 * test.
798 */
799 FUZ_CHECKTEST(blockContinueCompressedSize != expectedSize, "LZ4_compress_fast_continue using extDictCtx produced different-sized output (%d expected vs %d actual)", expectedSize, blockContinueCompressedSize);
800 FUZ_CHECKTEST(XXH32(compressedBuffer, (size_t)blockContinueCompressedSize, 0) != expectedCrc, "LZ4_compress_fast_continue using extDictCtx produced different output");
801
802 FUZ_DISPLAYTEST("LZ4_compress_fast_continue() after LZ4_attach_dictionary(), but output buffer is 1 byte too short");
803 LZ4_resetStream_fast(&LZ4_stream);
804 LZ4_attach_dictionary(&LZ4_stream, &LZ4dictBody);
805 ret = LZ4_compress_fast_continue(&LZ4_stream, block, compressedBuffer, blockSize, blockContinueCompressedSize-1, 1);
806 FUZ_CHECKTEST(ret>0, "LZ4_compress_fast_continue using extDictCtx should fail : one missing byte for output buffer : %i written, %i buffer", ret, blockContinueCompressedSize);
807 /* note : context is no longer dirty after a failed compressed block */
808
809 FUZ_DISPLAYTEST();
810 LZ4_resetStream_fast(&LZ4_stream);
811 LZ4_attach_dictionary(&LZ4_stream, &LZ4dictBody);
812 ret = LZ4_compress_fast_continue(&LZ4_stream, block, compressedBuffer, blockSize, blockContinueCompressedSize, 1);
813 FUZ_CHECKTEST(ret!=blockContinueCompressedSize, "LZ4_compress_limitedOutput_compressed size is different (%i != %i)", ret, blockContinueCompressedSize);
814 FUZ_CHECKTEST(ret<=0, "LZ4_compress_fast_continue using extDictCtx should work : enough size available within output buffer");
815 FUZ_CHECKTEST(ret != expectedSize, "LZ4_compress_fast_continue using extDictCtx produced different-sized output");
816 FUZ_CHECKTEST(XXH32(compressedBuffer, (size_t)ret, 0) != expectedCrc, "LZ4_compress_fast_continue using extDictCtx produced different output");
817
818 FUZ_DISPLAYTEST();
819 LZ4_resetStream_fast(&LZ4_stream);
820 LZ4_attach_dictionary(&LZ4_stream, &LZ4dictBody);
821 ret = LZ4_compress_fast_continue(&LZ4_stream, block, compressedBuffer, blockSize, blockContinueCompressedSize, 1);
822 FUZ_CHECKTEST(ret!=blockContinueCompressedSize, "LZ4_compress_limitedOutput_compressed size is different (%i != %i)", ret, blockContinueCompressedSize);
823 FUZ_CHECKTEST(ret<=0, "LZ4_compress_fast_continue using extDictCtx with re-used context should work : enough size available within output buffer");
824 FUZ_CHECKTEST(ret != expectedSize, "LZ4_compress_fast_continue using extDictCtx produced different-sized output");
825 FUZ_CHECKTEST(XXH32(compressedBuffer, (size_t)ret, 0) != expectedCrc, "LZ4_compress_fast_continue using extDictCtx produced different output");
826 }
827
828 /* Decompress with dictionary as external */
829 FUZ_DISPLAYTEST();
830 decodedBuffer[blockSize] = 0;
831 ret = LZ4_decompress_fast_usingDict(compressedBuffer, decodedBuffer, blockSize, dict, dictSize);
832 FUZ_CHECKTEST(ret!=blockContinueCompressedSize, "LZ4_decompress_fast_usingDict did not read all compressed block input");
833 FUZ_CHECKTEST(decodedBuffer[blockSize], "LZ4_decompress_fast_usingDict overrun specified output buffer size");
834 { U32 const crcCheck = XXH32(decodedBuffer, (size_t)blockSize, 0);
835 if (crcCheck!=crcOrig) {
836 FUZ_findDiff(block, decodedBuffer);
837 EXIT_MSG("LZ4_decompress_fast_usingDict corrupted decoded data (dict %i)", dictSize);
838 } }
839
840 FUZ_DISPLAYTEST();
841 decodedBuffer[blockSize] = 0;
842 ret = LZ4_decompress_safe_usingDict(compressedBuffer, decodedBuffer, blockContinueCompressedSize, blockSize, dict, dictSize);
843 FUZ_CHECKTEST(ret!=blockSize, "LZ4_decompress_safe_usingDict did not regenerate original data");
844 FUZ_CHECKTEST(decodedBuffer[blockSize], "LZ4_decompress_safe_usingDict overrun specified output buffer size");
845 { U32 const crcCheck = XXH32(decodedBuffer, (size_t)blockSize, 0);
846 FUZ_CHECKTEST(crcCheck!=crcOrig, "LZ4_decompress_safe_usingDict corrupted decoded data");
847 }
848
849 FUZ_DISPLAYTEST();
850 decodedBuffer[blockSize-1] = 0;
851 ret = LZ4_decompress_fast_usingDict(compressedBuffer, decodedBuffer, blockSize-1, dict, dictSize);
852 FUZ_CHECKTEST(ret>=0, "LZ4_decompress_fast_usingDict should have failed : wrong original size (-1 byte)");
853 FUZ_CHECKTEST(decodedBuffer[blockSize-1], "LZ4_decompress_fast_usingDict overrun specified output buffer size");
854
855 FUZ_DISPLAYTEST();
856 decodedBuffer[blockSize-1] = 0;
857 ret = LZ4_decompress_safe_usingDict(compressedBuffer, decodedBuffer, blockContinueCompressedSize, blockSize-1, dict, dictSize);
858 FUZ_CHECKTEST(ret>=0, "LZ4_decompress_safe_usingDict should have failed : not enough output size (-1 byte)");
859 FUZ_CHECKTEST(decodedBuffer[blockSize-1], "LZ4_decompress_safe_usingDict overrun specified output buffer size");
860
861 FUZ_DISPLAYTEST("LZ4_decompress_safe_usingDict with a too small output buffer");
862 { int const missingBytes = (FUZ_rand(&randState) & 0xF) + 2;
863 if (blockSize > missingBytes) {
864 decodedBuffer[blockSize-missingBytes] = 0;
865 ret = LZ4_decompress_safe_usingDict(compressedBuffer, decodedBuffer, blockContinueCompressedSize, blockSize-missingBytes, dict, dictSize);
866 FUZ_CHECKTEST(ret>=0, "LZ4_decompress_safe_usingDict should have failed : output buffer too small (-%i byte)", missingBytes);
867 FUZ_CHECKTEST(decodedBuffer[blockSize-missingBytes], "LZ4_decompress_safe_usingDict overrun specified output buffer size (-%i byte) (blockSize=%i)", missingBytes, blockSize);
868 } }
869
870 /* Compress HC using External dictionary */
871 FUZ_DISPLAYTEST("LZ4_compress_HC_continue with an external dictionary");
872 dict -= (FUZ_rand(&randState) & 7); /* even bigger separation */
873 if (dict < (char*)CNBuffer) dict = (char*)CNBuffer;
874 LZ4_loadDictHC(LZ4dictHC, dict, dictSize);
875 LZ4_setCompressionLevel (LZ4dictHC, compressionLevel);
876 blockContinueCompressedSize = LZ4_compress_HC_continue(LZ4dictHC, block, compressedBuffer, blockSize, (int)compressedBufferSize);
877 FUZ_CHECKTEST(blockContinueCompressedSize==0, "LZ4_compress_HC_continue failed");
878 FUZ_CHECKTEST(LZ4dictHC->internal_donotuse.dirty, "Context should be clean");
879
880 FUZ_DISPLAYTEST("LZ4_compress_HC_continue with same external dictionary, but output buffer 1 byte too short");
881 LZ4_loadDictHC(LZ4dictHC, dict, dictSize);
882 ret = LZ4_compress_HC_continue(LZ4dictHC, block, compressedBuffer, blockSize, blockContinueCompressedSize-1);
883 FUZ_CHECKTEST(ret>0, "LZ4_compress_HC_continue using ExtDict should fail : one missing byte for output buffer (expected %i, but result=%i)", blockContinueCompressedSize, ret);
884 /* note : context is no longer dirty after a failed compressed block */
885
886 FUZ_DISPLAYTEST("LZ4_compress_HC_continue with same external dictionary, and output buffer exactly the right size");
887 LZ4_loadDictHC(LZ4dictHC, dict, dictSize);
888 ret = LZ4_compress_HC_continue(LZ4dictHC, block, compressedBuffer, blockSize, blockContinueCompressedSize);
889 FUZ_CHECKTEST(ret!=blockContinueCompressedSize, "LZ4_compress_HC_continue size is different : ret(%i) != expected(%i)", ret, blockContinueCompressedSize);
890 FUZ_CHECKTEST(ret<=0, "LZ4_compress_HC_continue should work : enough size available within output buffer");
891 FUZ_CHECKTEST(LZ4dictHC->internal_donotuse.dirty, "Context should be clean");
892
893 FUZ_DISPLAYTEST();
894 decodedBuffer[blockSize] = 0;
895 ret = LZ4_decompress_safe_usingDict(compressedBuffer, decodedBuffer, blockContinueCompressedSize, blockSize, dict, dictSize);
896 FUZ_CHECKTEST(ret!=blockSize, "LZ4_decompress_safe_usingDict did not regenerate original data");
897 FUZ_CHECKTEST(decodedBuffer[blockSize], "LZ4_decompress_safe_usingDict overrun specified output buffer size");
898 { U32 const crcCheck = XXH32(decodedBuffer, (size_t)blockSize, 0);
899 if (crcCheck!=crcOrig) {
900 FUZ_findDiff(block, decodedBuffer);
901 EXIT_MSG("LZ4_decompress_safe_usingDict corrupted decoded data");
902 } }
903
904 /* Compress HC using external dictionary stream */
905 FUZ_DISPLAYTEST();
906 { LZ4_streamHC_t* const LZ4_streamHC = LZ4_createStreamHC();
907
908 LZ4_loadDictHC(LZ4dictHC, dict, dictSize);
909 LZ4_attach_HC_dictionary(LZ4_streamHC, LZ4dictHC);
910 LZ4_setCompressionLevel (LZ4_streamHC, compressionLevel);
911 blockContinueCompressedSize = LZ4_compress_HC_continue(LZ4_streamHC, block, compressedBuffer, blockSize, (int)compressedBufferSize);
912 FUZ_CHECKTEST(blockContinueCompressedSize==0, "LZ4_compress_HC_continue with ExtDictCtx failed");
913 FUZ_CHECKTEST(LZ4_streamHC->internal_donotuse.dirty, "Context should be clean");
914
915 FUZ_DISPLAYTEST();
916 LZ4_resetStreamHC_fast (LZ4_streamHC, compressionLevel);
917 LZ4_attach_HC_dictionary(LZ4_streamHC, LZ4dictHC);
918 ret = LZ4_compress_HC_continue(LZ4_streamHC, block, compressedBuffer, blockSize, blockContinueCompressedSize-1);
919 FUZ_CHECKTEST(ret>0, "LZ4_compress_HC_continue using ExtDictCtx should fail : one missing byte for output buffer (%i != %i)", ret, blockContinueCompressedSize);
920 /* note : context is no longer dirty after a failed compressed block */
921
922 FUZ_DISPLAYTEST();
923 LZ4_resetStreamHC_fast (LZ4_streamHC, compressionLevel);
924 LZ4_attach_HC_dictionary(LZ4_streamHC, LZ4dictHC);
925 ret = LZ4_compress_HC_continue(LZ4_streamHC, block, compressedBuffer, blockSize, blockContinueCompressedSize);
926 FUZ_CHECKTEST(ret!=blockContinueCompressedSize, "LZ4_compress_HC_continue using ExtDictCtx size is different (%i != %i)", ret, blockContinueCompressedSize);
927 FUZ_CHECKTEST(ret<=0, "LZ4_compress_HC_continue using ExtDictCtx should work : enough size available within output buffer");
928 FUZ_CHECKTEST(LZ4_streamHC->internal_donotuse.dirty, "Context should be clean");
929
930 FUZ_DISPLAYTEST();
931 LZ4_resetStreamHC_fast (LZ4_streamHC, compressionLevel);
932 LZ4_attach_HC_dictionary(LZ4_streamHC, LZ4dictHC);
933 ret = LZ4_compress_HC_continue(LZ4_streamHC, block, compressedBuffer, blockSize, blockContinueCompressedSize);
934 FUZ_CHECKTEST(ret!=blockContinueCompressedSize, "LZ4_compress_HC_continue using ExtDictCtx and fast reset size is different (%i != %i)",
935 ret, blockContinueCompressedSize);
936 FUZ_CHECKTEST(ret<=0, "LZ4_compress_HC_continue using ExtDictCtx and fast reset should work : enough size available within output buffer");
937 FUZ_CHECKTEST(LZ4_streamHC->internal_donotuse.dirty, "Context should be clean");
938
939 LZ4_freeStreamHC(LZ4_streamHC);
940 }
941
942 FUZ_DISPLAYTEST();
943 decodedBuffer[blockSize] = 0;
944 ret = LZ4_decompress_safe_usingDict(compressedBuffer, decodedBuffer, blockContinueCompressedSize, blockSize, dict, dictSize);
945 FUZ_CHECKTEST(ret!=blockSize, "LZ4_decompress_safe_usingDict did not regenerate original data");
946 FUZ_CHECKTEST(decodedBuffer[blockSize], "LZ4_decompress_safe_usingDict overrun specified output buffer size");
947 { U32 const crcCheck = XXH32(decodedBuffer, (size_t)blockSize, 0);
948 if (crcCheck!=crcOrig) {
949 FUZ_findDiff(block, decodedBuffer);
950 EXIT_MSG("LZ4_decompress_safe_usingDict corrupted decoded data");
951 } }
952
953 /* Compress HC continue destSize */
954 FUZ_DISPLAYTEST();
955 { int const availableSpace = (int)(FUZ_rand(&randState) % (U32)blockSize) + 5;
956 int consumedSize = blockSize;
957 FUZ_DISPLAYTEST();
958 LZ4_loadDictHC(LZ4dictHC, dict, dictSize);
959 LZ4_setCompressionLevel(LZ4dictHC, compressionLevel);
960 blockContinueCompressedSize = LZ4_compress_HC_continue_destSize(LZ4dictHC, block, compressedBuffer, &consumedSize, availableSpace);
961 DISPLAYLEVEL(5, " LZ4_compress_HC_continue_destSize : compressed %6i/%6i into %6i/%6i at cLevel=%i \n",
962 consumedSize, blockSize, blockContinueCompressedSize, availableSpace, compressionLevel);
963 FUZ_CHECKTEST(blockContinueCompressedSize==0, "LZ4_compress_HC_continue_destSize failed");
964 FUZ_CHECKTEST(blockContinueCompressedSize > availableSpace, "LZ4_compress_HC_continue_destSize write overflow");
965 FUZ_CHECKTEST(consumedSize > blockSize, "LZ4_compress_HC_continue_destSize read overflow");
966
967 FUZ_DISPLAYTEST();
968 decodedBuffer[consumedSize] = 0;
969 ret = LZ4_decompress_safe_usingDict(compressedBuffer, decodedBuffer, blockContinueCompressedSize, consumedSize, dict, dictSize);
970 FUZ_CHECKTEST(ret != consumedSize, "LZ4_decompress_safe_usingDict regenerated %i bytes (%i expected)", ret, consumedSize);
971 FUZ_CHECKTEST(decodedBuffer[consumedSize], "LZ4_decompress_safe_usingDict overrun specified output buffer size")
972 { U32 const crcSrc = XXH32(block, (size_t)consumedSize, 0);
973 U32 const crcDst = XXH32(decodedBuffer, (size_t)consumedSize, 0);
974 if (crcSrc!=crcDst) {
975 FUZ_findDiff(block, decodedBuffer);
976 EXIT_MSG("LZ4_decompress_safe_usingDict corrupted decoded data");
977 } }
978 }
979
980 /* ***** End of tests *** */
981 /* Fill stats */
982 assert(blockSize >= 0);
983 bytes += (unsigned)blockSize;
984 assert(compressedSize >= 0);
985 cbytes += (unsigned)compressedSize;
986 assert(HCcompressedSize >= 0);
987 hcbytes += (unsigned)HCcompressedSize;
988 assert(blockContinueCompressedSize >= 0);
989 ccbytes += (unsigned)blockContinueCompressedSize;
990 }
991
992 if (nbCycles<=1) nbCycles = cycleNb; /* end by time */
993 bytes += !bytes; /* avoid division by 0 */
994 printf("\r%7u /%7u - ", cycleNb, nbCycles);
995 printf("all tests completed successfully \n");
996 printf("compression ratio: %0.3f%%\n", (double)cbytes/bytes*100);
997 printf("HC compression ratio: %0.3f%%\n", (double)hcbytes/bytes*100);
998 printf("ratio with dict: %0.3f%%\n", (double)ccbytes/bytes*100);
999
1000 /* release memory */
1001 free(CNBuffer);
1002 free(compressedBuffer);
1003 free(decodedBuffer);
1004 FUZ_freeLowAddr(lowAddrBuffer, labSize);
1005 LZ4_freeStreamHC(LZ4dictHC);
1006 free(stateLZ4);
1007 free(stateLZ4HC);
1008 return result;
1009 }
1010
1011
1012 #define testInputSize (196 KB)
1013 #define testCompressedSize (130 KB)
1014 #define ringBufferSize (8 KB)
1015
FUZ_unitTests(int compressionLevel)1016 static void FUZ_unitTests(int compressionLevel)
1017 {
1018 const unsigned testNb = 0;
1019 const unsigned seed = 0;
1020 const unsigned cycleNb= 0;
1021 char* testInput = (char*)malloc(testInputSize);
1022 char* testCompressed = (char*)malloc(testCompressedSize);
1023 char* testVerify = (char*)malloc(testInputSize);
1024 char ringBuffer[ringBufferSize] = {0};
1025 U32 randState = 1;
1026
1027 /* Init */
1028 if (!testInput || !testCompressed || !testVerify) {
1029 EXIT_MSG("not enough memory for FUZ_unitTests");
1030 }
1031 FUZ_fillCompressibleNoiseBuffer(testInput, testInputSize, 0.50, &randState);
1032
1033 /* 32-bits address space overflow test */
1034 FUZ_AddressOverflow();
1035
1036 /* Test decoding with empty input */
1037 DISPLAYLEVEL(3, "LZ4_decompress_safe() with empty input \n");
1038 LZ4_decompress_safe(testCompressed, testVerify, 0, testInputSize);
1039
1040 /* Test decoding with a one byte input */
1041 DISPLAYLEVEL(3, "LZ4_decompress_safe() with one byte input \n");
1042 { char const tmp = (char)0xFF;
1043 LZ4_decompress_safe(&tmp, testVerify, 1, testInputSize);
1044 }
1045
1046 /* Test decoding shortcut edge case */
1047 DISPLAYLEVEL(3, "LZ4_decompress_safe() with shortcut edge case \n");
1048 { char tmp[17];
1049 /* 14 bytes of literals, followed by a 14 byte match.
1050 * Should not read beyond the end of the buffer.
1051 * See https://github.com/lz4/lz4/issues/508. */
1052 *tmp = (char)0xEE;
1053 memset(tmp + 1, 0, 14);
1054 tmp[15] = 14;
1055 tmp[16] = 0;
1056 { int const r = LZ4_decompress_safe(tmp, testVerify, sizeof(tmp), testInputSize);
1057 FUZ_CHECKTEST(r >= 0, "LZ4_decompress_safe() should fail");
1058 } }
1059
1060
1061 /* to be tested with undefined sanitizer */
1062 DISPLAYLEVEL(3, "LZ4_compress_default() with NULL input:");
1063 { int const maxCSize = LZ4_compressBound(0);
1064 int const cSize = LZ4_compress_default(NULL, testCompressed, 0, maxCSize);
1065 FUZ_CHECKTEST(!(cSize==1 && testCompressed[0]==0),
1066 "compressing empty should give byte 0"
1067 " (maxCSize == %i) (cSize == %i) (byte == 0x%02X)",
1068 maxCSize, cSize, testCompressed[0]);
1069 }
1070 DISPLAYLEVEL(3, " OK \n");
1071
1072 DISPLAYLEVEL(3, "LZ4_compress_default() with both NULL input and output:");
1073 { int const cSize = LZ4_compress_default(NULL, NULL, 0, 0);
1074 FUZ_CHECKTEST(cSize != 0,
1075 "compressing into NULL must fail"
1076 " (cSize == %i != 0)", cSize);
1077 }
1078 DISPLAYLEVEL(3, " OK \n");
1079
1080 /* in-place compression test */
1081 DISPLAYLEVEL(3, "in-place compression using LZ4_compress_default() :");
1082 { int const sampleSize = 65 KB;
1083 int const maxCSize = LZ4_COMPRESSBOUND(sampleSize);
1084 int const outSize = LZ4_COMPRESS_INPLACE_BUFFER_SIZE(maxCSize);
1085 int const startInputIndex = outSize - sampleSize;
1086 char* const startInput = testCompressed + startInputIndex;
1087 XXH32_hash_t const crcOrig = XXH32(testInput, sampleSize, 0);
1088 int cSize;
1089 assert(outSize < (int)testCompressedSize);
1090 memcpy(startInput, testInput, sampleSize); /* copy at end of buffer */
1091 /* compress in-place */
1092 cSize = LZ4_compress_default(startInput, testCompressed, sampleSize, maxCSize);
1093 assert(cSize != 0); /* ensure compression is successful */
1094 assert(maxCSize < INT_MAX);
1095 assert(cSize <= maxCSize);
1096 /* decompress and verify */
1097 { int const dSize = LZ4_decompress_safe(testCompressed, testVerify, cSize, testInputSize);
1098 assert(dSize == sampleSize); /* correct size */
1099 { XXH32_hash_t const crcCheck = XXH32(testVerify, (size_t)dSize, 0);
1100 FUZ_CHECKTEST(crcCheck != crcOrig, "LZ4_decompress_safe decompression corruption");
1101 } } }
1102 DISPLAYLEVEL(3, " OK \n");
1103
1104 /* in-place decompression test */
1105 DISPLAYLEVEL(3, "in-place decompression, limit case:");
1106 { int const sampleSize = 65 KB;
1107
1108 FUZ_fillCompressibleNoiseBuffer(testInput, sampleSize, 0.0, &randState);
1109 memset(testInput, 0, 267); /* calculated exactly so that compressedSize == originalSize-1 */
1110
1111 { XXH64_hash_t const crcOrig = XXH64(testInput, sampleSize, 0);
1112 int const cSize = LZ4_compress_default(testInput, testCompressed, sampleSize, testCompressedSize);
1113 assert(cSize == sampleSize - 1); /* worst case for in-place decompression */
1114
1115 { int const bufferSize = LZ4_DECOMPRESS_INPLACE_BUFFER_SIZE(sampleSize);
1116 int const startInputIndex = bufferSize - cSize;
1117 char* const startInput = testVerify + startInputIndex;
1118 memcpy(startInput, testCompressed, cSize);
1119
1120 /* decompress and verify */
1121 { int const dSize = LZ4_decompress_safe(startInput, testVerify, cSize, sampleSize);
1122 assert(dSize == sampleSize); /* correct size */
1123 { XXH64_hash_t const crcCheck = XXH64(testVerify, (size_t)dSize, 0);
1124 FUZ_CHECKTEST(crcCheck != crcOrig, "LZ4_decompress_safe decompression corruption");
1125 } } } } }
1126 DISPLAYLEVEL(3, " OK \n");
1127
1128 DISPLAYLEVEL(3, "LZ4_initStream with multiple valid alignments : ");
1129 { typedef struct {
1130 LZ4_stream_t state1;
1131 LZ4_stream_t state2;
1132 char c;
1133 LZ4_stream_t state3;
1134 } shct;
1135 shct* const shc = (shct*)malloc(sizeof(*shc));
1136 assert(shc != NULL);
1137 memset(shc, 0, sizeof(*shc));
1138 DISPLAYLEVEL(4, "state1(%p) state2(%p) state3(%p) LZ4_stream_t size(0x%x): ",
1139 &(shc->state1), &(shc->state2), &(shc->state3), (unsigned)sizeof(LZ4_stream_t));
1140 FUZ_CHECKTEST( LZ4_initStream(&(shc->state1), sizeof(shc->state1)) == NULL, "state1 (%p) failed init", &(shc->state1) );
1141 FUZ_CHECKTEST( LZ4_initStream(&(shc->state2), sizeof(shc->state2)) == NULL, "state2 (%p) failed init", &(shc->state2) );
1142 FUZ_CHECKTEST( LZ4_initStream(&(shc->state3), sizeof(shc->state3)) == NULL, "state3 (%p) failed init", &(shc->state3) );
1143 FUZ_CHECKTEST( LZ4_initStream((char*)&(shc->state1) + 1, sizeof(shc->state1)) != NULL,
1144 "hc1+1 (%p) init must fail, due to bad alignment", (char*)&(shc->state1) + 1 );
1145 free(shc);
1146 }
1147 DISPLAYLEVEL(3, "all inits OK \n");
1148
1149 /* Allocation test */
1150 { LZ4_stream_t* const statePtr = LZ4_createStream();
1151 FUZ_CHECKTEST(statePtr==NULL, "LZ4_createStream() allocation failed");
1152 LZ4_freeStream(statePtr);
1153 }
1154
1155 /* LZ4 streaming tests */
1156 { LZ4_stream_t streamingState;
1157
1158 /* simple compression test */
1159 LZ4_initStream(&streamingState, sizeof(streamingState));
1160 { int const cs = LZ4_compress_fast_continue(&streamingState, testInput, testCompressed, testCompressedSize, testCompressedSize-1, 1);
1161 FUZ_CHECKTEST(cs==0, "LZ4_compress_fast_continue() compression failed!");
1162 { int const r = LZ4_decompress_safe(testCompressed, testVerify, cs, testCompressedSize);
1163 FUZ_CHECKTEST(r!=(int)testCompressedSize, "LZ4_decompress_safe() decompression failed");
1164 } }
1165 { U64 const crcOrig = XXH64(testInput, testCompressedSize, 0);
1166 U64 const crcNew = XXH64(testVerify, testCompressedSize, 0);
1167 FUZ_CHECKTEST(crcOrig!=crcNew, "LZ4_decompress_safe() decompression corruption");
1168 }
1169
1170 /* early saveDict */
1171 DISPLAYLEVEL(3, "saveDict (right after init) : ");
1172 { LZ4_stream_t* const ctx = LZ4_initStream(&streamingState, sizeof(streamingState));
1173 assert(ctx != NULL); /* ensure init is successful */
1174
1175 /* Check access violation with asan */
1176 FUZ_CHECKTEST( LZ4_saveDict(ctx, NULL, 0) != 0,
1177 "LZ4_saveDict() can't save anything into (NULL,0)");
1178
1179 /* Check access violation with asan */
1180 { char tmp_buffer[240] = { 0 };
1181 FUZ_CHECKTEST( LZ4_saveDict(ctx, tmp_buffer, sizeof(tmp_buffer)) != 0,
1182 "LZ4_saveDict() can't save anything since compression hasn't started");
1183 } }
1184 DISPLAYLEVEL(3, "OK \n");
1185
1186 /* ring buffer test */
1187 { XXH64_state_t xxhOrig;
1188 XXH64_state_t xxhNewSafe, xxhNewFast;
1189 LZ4_streamDecode_t decodeStateSafe, decodeStateFast;
1190 const U32 maxMessageSizeLog = 10;
1191 const U32 maxMessageSizeMask = (1<<maxMessageSizeLog) - 1;
1192 U32 messageSize = (FUZ_rand(&randState) & maxMessageSizeMask) + 1;
1193 U32 iNext = 0;
1194 U32 rNext = 0;
1195 U32 dNext = 0;
1196 const U32 dBufferSize = ringBufferSize + maxMessageSizeMask;
1197
1198 XXH64_reset(&xxhOrig, 0);
1199 XXH64_reset(&xxhNewSafe, 0);
1200 XXH64_reset(&xxhNewFast, 0);
1201 LZ4_resetStream_fast(&streamingState);
1202 LZ4_setStreamDecode(&decodeStateSafe, NULL, 0);
1203 LZ4_setStreamDecode(&decodeStateFast, NULL, 0);
1204
1205 while (iNext + messageSize < testCompressedSize) {
1206 int compressedSize; U64 crcOrig;
1207 XXH64_update(&xxhOrig, testInput + iNext, messageSize);
1208 crcOrig = XXH64_digest(&xxhOrig);
1209
1210 memcpy (ringBuffer + rNext, testInput + iNext, messageSize);
1211 compressedSize = LZ4_compress_fast_continue(&streamingState, ringBuffer + rNext, testCompressed, (int)messageSize, testCompressedSize-ringBufferSize, 1);
1212 FUZ_CHECKTEST(compressedSize==0, "LZ4_compress_fast_continue() compression failed");
1213
1214 { int const r = LZ4_decompress_safe_continue(&decodeStateSafe, testCompressed, testVerify + dNext, compressedSize, (int)messageSize);
1215 FUZ_CHECKTEST(r!=(int)messageSize, "ringBuffer : LZ4_decompress_safe_continue() test failed"); }
1216
1217 XXH64_update(&xxhNewSafe, testVerify + dNext, messageSize);
1218 { U64 const crcNew = XXH64_digest(&xxhNewSafe);
1219 FUZ_CHECKTEST(crcOrig!=crcNew, "LZ4_decompress_safe_continue() decompression corruption"); }
1220
1221 { int const r = LZ4_decompress_fast_continue(&decodeStateFast, testCompressed, testVerify + dNext, (int)messageSize);
1222 FUZ_CHECKTEST(r!=compressedSize, "ringBuffer : LZ4_decompress_fast_continue() test failed"); }
1223
1224 XXH64_update(&xxhNewFast, testVerify + dNext, messageSize);
1225 { U64 const crcNew = XXH64_digest(&xxhNewFast);
1226 FUZ_CHECKTEST(crcOrig!=crcNew, "LZ4_decompress_fast_continue() decompression corruption"); }
1227
1228 /* prepare next message */
1229 iNext += messageSize;
1230 rNext += messageSize;
1231 dNext += messageSize;
1232 messageSize = (FUZ_rand(&randState) & maxMessageSizeMask) + 1;
1233 if (rNext + messageSize > ringBufferSize) rNext = 0;
1234 if (dNext + messageSize > dBufferSize) dNext = 0;
1235 } }
1236 }
1237
1238 DISPLAYLEVEL(3, "LZ4_initStreamHC with multiple valid alignments : ");
1239 { typedef struct {
1240 LZ4_streamHC_t hc1;
1241 LZ4_streamHC_t hc2;
1242 char c;
1243 LZ4_streamHC_t hc3;
1244 } shct;
1245 shct* const shc = (shct*)malloc(sizeof(*shc));
1246 assert(shc != NULL);
1247 memset(shc, 0, sizeof(*shc));
1248 DISPLAYLEVEL(4, "hc1(%p) hc2(%p) hc3(%p) size(0x%x): ",
1249 &(shc->hc1), &(shc->hc2), &(shc->hc3), (unsigned)sizeof(LZ4_streamHC_t));
1250 FUZ_CHECKTEST( LZ4_initStreamHC(&(shc->hc1), sizeof(shc->hc1)) == NULL, "hc1 (%p) failed init", &(shc->hc1) );
1251 FUZ_CHECKTEST( LZ4_initStreamHC(&(shc->hc2), sizeof(shc->hc2)) == NULL, "hc2 (%p) failed init", &(shc->hc2) );
1252 FUZ_CHECKTEST( LZ4_initStreamHC(&(shc->hc3), sizeof(shc->hc3)) == NULL, "hc3 (%p) failed init", &(shc->hc3) );
1253 FUZ_CHECKTEST( LZ4_initStreamHC((char*)&(shc->hc1) + 1, sizeof(shc->hc1)) != NULL,
1254 "hc1+1 (%p) init must fail, due to bad alignment", (char*)&(shc->hc1) + 1 );
1255 free(shc);
1256 }
1257 DISPLAYLEVEL(3, "all inits OK \n");
1258
1259 /* LZ4 HC streaming tests */
1260 { LZ4_streamHC_t sHC; /* statically allocated */
1261 int result;
1262 LZ4_initStreamHC(&sHC, sizeof(sHC));
1263
1264 /* Allocation test */
1265 DISPLAYLEVEL(3, "Basic HC allocation : ");
1266 { LZ4_streamHC_t* const sp = LZ4_createStreamHC();
1267 FUZ_CHECKTEST(sp==NULL, "LZ4_createStreamHC() allocation failed");
1268 LZ4_freeStreamHC(sp);
1269 }
1270 DISPLAYLEVEL(3, "OK \n");
1271
1272 /* simple HC compression test */
1273 DISPLAYLEVEL(3, "Simple HC round-trip : ");
1274 { U64 const crc64 = XXH64(testInput, testCompressedSize, 0);
1275 LZ4_setCompressionLevel(&sHC, compressionLevel);
1276 result = LZ4_compress_HC_continue(&sHC, testInput, testCompressed, testCompressedSize, testCompressedSize-1);
1277 FUZ_CHECKTEST(result==0, "LZ4_compressHC_limitedOutput_continue() compression failed");
1278 FUZ_CHECKTEST(sHC.internal_donotuse.dirty, "Context should be clean");
1279
1280 result = LZ4_decompress_safe(testCompressed, testVerify, result, testCompressedSize);
1281 FUZ_CHECKTEST(result!=(int)testCompressedSize, "LZ4_decompress_safe() decompression failed");
1282 { U64 const crcNew = XXH64(testVerify, testCompressedSize, 0);
1283 FUZ_CHECKTEST(crc64!=crcNew, "LZ4_decompress_safe() decompression corruption");
1284 } }
1285 DISPLAYLEVEL(3, "OK \n");
1286
1287 /* saveDictHC test #926 */
1288 DISPLAYLEVEL(3, "saveDictHC test #926 : ");
1289 { LZ4_streamHC_t* const ctx = LZ4_initStreamHC(&sHC, sizeof(sHC));
1290 assert(ctx != NULL); /* ensure init is successful */
1291
1292 /* Check access violation with asan */
1293 FUZ_CHECKTEST( LZ4_saveDictHC(ctx, NULL, 0) != 0,
1294 "LZ4_saveDictHC() can't save anything into (NULL,0)");
1295
1296 /* Check access violation with asan */
1297 { char tmp_buffer[240] = { 0 };
1298 FUZ_CHECKTEST( LZ4_saveDictHC(ctx, tmp_buffer, sizeof(tmp_buffer)) != 0,
1299 "LZ4_saveDictHC() can't save anything since compression hasn't started");
1300 } }
1301 DISPLAYLEVEL(3, "OK \n");
1302
1303 /* long sequence test */
1304 DISPLAYLEVEL(3, "Long sequence HC_destSize test : ");
1305 { size_t const blockSize = 1 MB;
1306 size_t const targetSize = 4116; /* size carefully selected to trigger an overflow */
1307 void* const block = malloc(blockSize);
1308 void* const dstBlock = malloc(targetSize+1);
1309 BYTE const sentinel = 101;
1310 int srcSize;
1311
1312 assert(block != NULL); assert(dstBlock != NULL);
1313 memset(block, 0, blockSize);
1314 ((char*)dstBlock)[targetSize] = sentinel;
1315
1316 LZ4_resetStreamHC_fast(&sHC, 3);
1317 assert(blockSize < INT_MAX);
1318 srcSize = (int)blockSize;
1319 assert(targetSize < INT_MAX);
1320 result = LZ4_compress_HC_destSize(&sHC, (const char*)block, (char*)dstBlock, &srcSize, (int)targetSize, 3);
1321 DISPLAYLEVEL(4, "cSize=%i; readSize=%i; ", result, srcSize);
1322 FUZ_CHECKTEST(result != 4116, "LZ4_compress_HC_destSize() : "
1323 "compression (%i->%i) must fill dstBuffer (%i) exactly",
1324 srcSize, result, (int)targetSize);
1325 FUZ_CHECKTEST(((char*)dstBlock)[targetSize] != sentinel,
1326 "LZ4_compress_HC_destSize() overwrites dst buffer");
1327 FUZ_CHECKTEST(srcSize < 1045000, "LZ4_compress_HC_destSize() doesn't compress enough"
1328 " (%i -> %i , expected > %i)", srcSize, result, 1045000);
1329
1330 LZ4_resetStreamHC_fast(&sHC, 3); /* make sure the context is clean after the test */
1331 free(block);
1332 free(dstBlock);
1333 }
1334 DISPLAYLEVEL(3, " OK \n");
1335
1336 /* simple dictionary HC compression test */
1337 DISPLAYLEVEL(3, "HC dictionary compression test : ");
1338 { U64 const crc64 = XXH64(testInput + 64 KB, testCompressedSize, 0);
1339 LZ4_resetStreamHC_fast(&sHC, compressionLevel);
1340 LZ4_loadDictHC(&sHC, testInput, 64 KB);
1341 { int const cSize = LZ4_compress_HC_continue(&sHC, testInput + 64 KB, testCompressed, testCompressedSize, testCompressedSize-1);
1342 FUZ_CHECKTEST(cSize==0, "LZ4_compressHC_limitedOutput_continue() dictionary compression failed : @return = %i", cSize);
1343 FUZ_CHECKTEST(sHC.internal_donotuse.dirty, "Context should be clean");
1344 { int const dSize = LZ4_decompress_safe_usingDict(testCompressed, testVerify, cSize, testCompressedSize, testInput, 64 KB);
1345 FUZ_CHECKTEST(dSize!=(int)testCompressedSize, "LZ4_decompress_safe() simple dictionary decompression test failed");
1346 } }
1347 { U64 const crcNew = XXH64(testVerify, testCompressedSize, 0);
1348 FUZ_CHECKTEST(crc64!=crcNew, "LZ4_decompress_safe() simple dictionary decompression test : corruption");
1349 } }
1350 DISPLAYLEVEL(3, " OK \n");
1351
1352 /* multiple HC compression test with dictionary */
1353 { int result1, result2;
1354 int segSize = testCompressedSize / 2;
1355 XXH64_hash_t const crc64 = ( (void)assert((unsigned)segSize + testCompressedSize < testInputSize) ,
1356 XXH64(testInput + segSize, testCompressedSize, 0) );
1357 LZ4_resetStreamHC_fast(&sHC, compressionLevel);
1358 LZ4_loadDictHC(&sHC, testInput, segSize);
1359 result1 = LZ4_compress_HC_continue(&sHC, testInput + segSize, testCompressed, segSize, segSize -1);
1360 FUZ_CHECKTEST(result1==0, "LZ4_compressHC_limitedOutput_continue() dictionary compression failed : result = %i", result1);
1361 FUZ_CHECKTEST(sHC.internal_donotuse.dirty, "Context should be clean");
1362 result2 = LZ4_compress_HC_continue(&sHC, testInput + 2*(size_t)segSize, testCompressed+result1, segSize, segSize-1);
1363 FUZ_CHECKTEST(result2==0, "LZ4_compressHC_limitedOutput_continue() dictionary compression failed : result = %i", result2);
1364 FUZ_CHECKTEST(sHC.internal_donotuse.dirty, "Context should be clean");
1365
1366 result = LZ4_decompress_safe_usingDict(testCompressed, testVerify, result1, segSize, testInput, segSize);
1367 FUZ_CHECKTEST(result!=segSize, "LZ4_decompress_safe() dictionary decompression part 1 failed");
1368 result = LZ4_decompress_safe_usingDict(testCompressed+result1, testVerify+segSize, result2, segSize, testInput, 2*segSize);
1369 FUZ_CHECKTEST(result!=segSize, "LZ4_decompress_safe() dictionary decompression part 2 failed");
1370 { XXH64_hash_t const crcNew = XXH64(testVerify, testCompressedSize, 0);
1371 FUZ_CHECKTEST(crc64!=crcNew, "LZ4_decompress_safe() dictionary decompression corruption");
1372 } }
1373
1374 /* remote dictionary HC compression test */
1375 { U64 const crc64 = XXH64(testInput + 64 KB, testCompressedSize, 0);
1376 LZ4_resetStreamHC_fast(&sHC, compressionLevel);
1377 LZ4_loadDictHC(&sHC, testInput, 32 KB);
1378 result = LZ4_compress_HC_continue(&sHC, testInput + 64 KB, testCompressed, testCompressedSize, testCompressedSize-1);
1379 FUZ_CHECKTEST(result==0, "LZ4_compressHC_limitedOutput_continue() remote dictionary failed : result = %i", result);
1380 FUZ_CHECKTEST(sHC.internal_donotuse.dirty, "Context should be clean");
1381
1382 result = LZ4_decompress_safe_usingDict(testCompressed, testVerify, result, testCompressedSize, testInput, 32 KB);
1383 FUZ_CHECKTEST(result!=(int)testCompressedSize, "LZ4_decompress_safe_usingDict() decompression failed following remote dictionary HC compression test");
1384 { U64 const crcNew = XXH64(testVerify, testCompressedSize, 0);
1385 FUZ_CHECKTEST(crc64!=crcNew, "LZ4_decompress_safe_usingDict() decompression corruption");
1386 } }
1387
1388 /* multiple HC compression with ext. dictionary */
1389 { XXH64_state_t crcOrigState;
1390 XXH64_state_t crcNewState;
1391 const char* dict = testInput + 3;
1392 size_t dictSize = (FUZ_rand(&randState) & 8191);
1393 char* dst = testVerify;
1394
1395 size_t segStart = dictSize + 7;
1396 size_t segSize = (FUZ_rand(&randState) & 8191);
1397 int segNb = 1;
1398
1399 LZ4_resetStreamHC_fast(&sHC, compressionLevel);
1400 LZ4_loadDictHC(&sHC, dict, (int)dictSize);
1401
1402 XXH64_reset(&crcOrigState, 0);
1403 XXH64_reset(&crcNewState, 0);
1404
1405 while (segStart + segSize < testInputSize) {
1406 XXH64_hash_t crcOrig;
1407 XXH64_update(&crcOrigState, testInput + segStart, segSize);
1408 crcOrig = XXH64_digest(&crcOrigState);
1409 assert(segSize <= INT_MAX);
1410 result = LZ4_compress_HC_continue(&sHC, testInput + segStart, testCompressed, (int)segSize, LZ4_compressBound((int)segSize));
1411 FUZ_CHECKTEST(result==0, "LZ4_compressHC_limitedOutput_continue() dictionary compression failed : result = %i", result);
1412 FUZ_CHECKTEST(sHC.internal_donotuse.dirty, "Context should be clean");
1413
1414 result = LZ4_decompress_safe_usingDict(testCompressed, dst, result, (int)segSize, dict, (int)dictSize);
1415 FUZ_CHECKTEST(result!=(int)segSize, "LZ4_decompress_safe_usingDict() dictionary decompression part %i failed", (int)segNb);
1416 XXH64_update(&crcNewState, dst, segSize);
1417 { U64 const crcNew = XXH64_digest(&crcNewState);
1418 if (crcOrig != crcNew) FUZ_findDiff(dst, testInput+segStart);
1419 FUZ_CHECKTEST(crcOrig!=crcNew, "LZ4_decompress_safe_usingDict() part %i corruption", segNb);
1420 }
1421
1422 dict = dst;
1423 dictSize = segSize;
1424
1425 dst += segSize + 1;
1426 segNb ++;
1427
1428 segStart += segSize + (FUZ_rand(&randState) & 0xF) + 1;
1429 segSize = (FUZ_rand(&randState) & 8191);
1430 } }
1431
1432 /* ring buffer test */
1433 { XXH64_state_t xxhOrig;
1434 XXH64_state_t xxhNewSafe, xxhNewFast;
1435 LZ4_streamDecode_t decodeStateSafe, decodeStateFast;
1436 const U32 maxMessageSizeLog = 10;
1437 const U32 maxMessageSizeMask = (1<<maxMessageSizeLog) - 1;
1438 U32 messageSize = (FUZ_rand(&randState) & maxMessageSizeMask) + 1;
1439 U32 iNext = 0;
1440 U32 rNext = 0;
1441 U32 dNext = 0;
1442 const U32 dBufferSize = ringBufferSize + maxMessageSizeMask;
1443
1444 XXH64_reset(&xxhOrig, 0);
1445 XXH64_reset(&xxhNewSafe, 0);
1446 XXH64_reset(&xxhNewFast, 0);
1447 LZ4_resetStreamHC_fast(&sHC, compressionLevel);
1448 LZ4_setStreamDecode(&decodeStateSafe, NULL, 0);
1449 LZ4_setStreamDecode(&decodeStateFast, NULL, 0);
1450
1451 while (iNext + messageSize < testCompressedSize) {
1452 int compressedSize;
1453 XXH64_hash_t crcOrig;
1454 XXH64_update(&xxhOrig, testInput + iNext, messageSize);
1455 crcOrig = XXH64_digest(&xxhOrig);
1456
1457 memcpy (ringBuffer + rNext, testInput + iNext, messageSize);
1458 assert(messageSize < INT_MAX);
1459 compressedSize = LZ4_compress_HC_continue(&sHC, ringBuffer + rNext, testCompressed, (int)messageSize, testCompressedSize-ringBufferSize);
1460 FUZ_CHECKTEST(compressedSize==0, "LZ4_compress_HC_continue() compression failed");
1461 FUZ_CHECKTEST(sHC.internal_donotuse.dirty, "Context should be clean");
1462
1463 assert(messageSize < INT_MAX);
1464 result = LZ4_decompress_safe_continue(&decodeStateSafe, testCompressed, testVerify + dNext, compressedSize, (int)messageSize);
1465 FUZ_CHECKTEST(result!=(int)messageSize, "ringBuffer : LZ4_decompress_safe_continue() test failed");
1466
1467 XXH64_update(&xxhNewSafe, testVerify + dNext, messageSize);
1468 { XXH64_hash_t const crcNew = XXH64_digest(&xxhNewSafe);
1469 FUZ_CHECKTEST(crcOrig!=crcNew, "LZ4_decompress_safe_continue() decompression corruption"); }
1470
1471 assert(messageSize < INT_MAX);
1472 result = LZ4_decompress_fast_continue(&decodeStateFast, testCompressed, testVerify + dNext, (int)messageSize);
1473 FUZ_CHECKTEST(result!=compressedSize, "ringBuffer : LZ4_decompress_fast_continue() test failed");
1474
1475 XXH64_update(&xxhNewFast, testVerify + dNext, messageSize);
1476 { XXH64_hash_t const crcNew = XXH64_digest(&xxhNewFast);
1477 FUZ_CHECKTEST(crcOrig!=crcNew, "LZ4_decompress_fast_continue() decompression corruption"); }
1478
1479 /* prepare next message */
1480 iNext += messageSize;
1481 rNext += messageSize;
1482 dNext += messageSize;
1483 messageSize = (FUZ_rand(&randState) & maxMessageSizeMask) + 1;
1484 if (rNext + messageSize > ringBufferSize) rNext = 0;
1485 if (dNext + messageSize > dBufferSize) dNext = 0;
1486 }
1487 }
1488
1489 /* Ring buffer test : Non synchronized decoder */
1490 /* This test uses minimum amount of memory required to setup a decoding ring buffer
1491 * while being unsynchronized with encoder
1492 * (no assumption done on how the data is encoded, it just follows LZ4 format specification).
1493 * This size is documented in lz4.h, and is LZ4_decoderRingBufferSize(maxBlockSize).
1494 */
1495 { XXH64_state_t xxhOrig;
1496 XXH64_state_t xxhNewSafe, xxhNewFast;
1497 XXH64_hash_t crcOrig;
1498 LZ4_streamDecode_t decodeStateSafe, decodeStateFast;
1499 const int maxMessageSizeLog = 12;
1500 const int maxMessageSize = 1 << maxMessageSizeLog;
1501 const int maxMessageSizeMask = maxMessageSize - 1;
1502 int messageSize;
1503 U32 totalMessageSize = 0;
1504 const int dBufferSize = LZ4_decoderRingBufferSize(maxMessageSize);
1505 char* const ringBufferSafe = testVerify;
1506 char* const ringBufferFast = testVerify + dBufferSize + 1; /* used by LZ4_decompress_fast_continue */
1507 int iNext = 0;
1508 int dNext = 0;
1509 int compressedSize;
1510
1511 assert((size_t)dBufferSize * 2 + 1 < testInputSize); /* space used by ringBufferSafe and ringBufferFast */
1512 XXH64_reset(&xxhOrig, 0);
1513 XXH64_reset(&xxhNewSafe, 0);
1514 XXH64_reset(&xxhNewFast, 0);
1515 LZ4_resetStreamHC_fast(&sHC, compressionLevel);
1516 LZ4_setStreamDecode(&decodeStateSafe, NULL, 0);
1517 LZ4_setStreamDecode(&decodeStateFast, NULL, 0);
1518
1519 #define BSIZE1 (dBufferSize - (maxMessageSize-1))
1520
1521 /* first block */
1522 messageSize = BSIZE1; /* note : we cheat a bit here, in theory no message should be > maxMessageSize. We just want to fill the decoding ring buffer once. */
1523 XXH64_update(&xxhOrig, testInput + iNext, (size_t)messageSize);
1524 crcOrig = XXH64_digest(&xxhOrig);
1525
1526 compressedSize = LZ4_compress_HC_continue(&sHC, testInput + iNext, testCompressed, messageSize, testCompressedSize-ringBufferSize);
1527 FUZ_CHECKTEST(compressedSize==0, "LZ4_compress_HC_continue() compression failed");
1528 FUZ_CHECKTEST(sHC.internal_donotuse.dirty, "Context should be clean");
1529
1530 result = LZ4_decompress_safe_continue(&decodeStateSafe, testCompressed, ringBufferSafe + dNext, compressedSize, messageSize);
1531 FUZ_CHECKTEST(result!=messageSize, "64K D.ringBuffer : LZ4_decompress_safe_continue() test failed");
1532
1533 XXH64_update(&xxhNewSafe, ringBufferSafe + dNext, (size_t)messageSize);
1534 { U64 const crcNew = XXH64_digest(&xxhNewSafe);
1535 FUZ_CHECKTEST(crcOrig!=crcNew, "LZ4_decompress_safe_continue() decompression corruption"); }
1536
1537 result = LZ4_decompress_fast_continue(&decodeStateFast, testCompressed, ringBufferFast + dNext, messageSize);
1538 FUZ_CHECKTEST(result!=compressedSize, "64K D.ringBuffer : LZ4_decompress_fast_continue() test failed");
1539
1540 XXH64_update(&xxhNewFast, ringBufferFast + dNext, (size_t)messageSize);
1541 { U64 const crcNew = XXH64_digest(&xxhNewFast);
1542 FUZ_CHECKTEST(crcOrig!=crcNew, "LZ4_decompress_fast_continue() decompression corruption"); }
1543
1544 /* prepare second message */
1545 dNext += messageSize;
1546 assert(messageSize >= 0);
1547 totalMessageSize += (unsigned)messageSize;
1548 messageSize = maxMessageSize;
1549 iNext = BSIZE1+1;
1550 assert(BSIZE1 >= 65535);
1551 memcpy(testInput + iNext, testInput + (BSIZE1-65535), messageSize); /* will generate a match at max distance == 65535 */
1552 FUZ_CHECKTEST(dNext+messageSize <= dBufferSize, "Ring buffer test : second message should require restarting from beginning");
1553 dNext = 0;
1554
1555 while (totalMessageSize < 9 MB) {
1556 XXH64_update(&xxhOrig, testInput + iNext, (size_t)messageSize);
1557 crcOrig = XXH64_digest(&xxhOrig);
1558
1559 compressedSize = LZ4_compress_HC_continue(&sHC, testInput + iNext, testCompressed, messageSize, testCompressedSize-ringBufferSize);
1560 FUZ_CHECKTEST(compressedSize==0, "LZ4_compress_HC_continue() compression failed");
1561 FUZ_CHECKTEST(sHC.internal_donotuse.dirty, "Context should be clean");
1562 DISPLAYLEVEL(5, "compressed %i bytes to %i bytes \n", messageSize, compressedSize);
1563
1564 /* test LZ4_decompress_safe_continue */
1565 assert(dNext < dBufferSize);
1566 assert(dBufferSize - dNext >= maxMessageSize);
1567 result = LZ4_decompress_safe_continue(&decodeStateSafe,
1568 testCompressed, ringBufferSafe + dNext,
1569 compressedSize, dBufferSize - dNext); /* works without knowing messageSize, under assumption that messageSize <= maxMessageSize */
1570 FUZ_CHECKTEST(result!=messageSize, "D.ringBuffer : LZ4_decompress_safe_continue() test failed");
1571 XXH64_update(&xxhNewSafe, ringBufferSafe + dNext, (size_t)messageSize);
1572 { U64 const crcNew = XXH64_digest(&xxhNewSafe);
1573 if (crcOrig != crcNew) FUZ_findDiff(testInput + iNext, ringBufferSafe + dNext);
1574 FUZ_CHECKTEST(crcOrig!=crcNew, "LZ4_decompress_safe_continue() decompression corruption during D.ringBuffer test");
1575 }
1576
1577 /* test LZ4_decompress_fast_continue in its own buffer ringBufferFast */
1578 result = LZ4_decompress_fast_continue(&decodeStateFast, testCompressed, ringBufferFast + dNext, messageSize);
1579 FUZ_CHECKTEST(result!=compressedSize, "D.ringBuffer : LZ4_decompress_fast_continue() test failed");
1580 XXH64_update(&xxhNewFast, ringBufferFast + dNext, (size_t)messageSize);
1581 { U64 const crcNew = XXH64_digest(&xxhNewFast);
1582 if (crcOrig != crcNew) FUZ_findDiff(testInput + iNext, ringBufferFast + dNext);
1583 FUZ_CHECKTEST(crcOrig!=crcNew, "LZ4_decompress_fast_continue() decompression corruption during D.ringBuffer test");
1584 }
1585
1586 /* prepare next message */
1587 dNext += messageSize;
1588 assert(messageSize >= 0);
1589 totalMessageSize += (unsigned)messageSize;
1590 messageSize = (FUZ_rand(&randState) & maxMessageSizeMask) + 1;
1591 iNext = (FUZ_rand(&randState) & 65535);
1592 if (dNext + maxMessageSize > dBufferSize) dNext = 0;
1593 }
1594 } /* Ring buffer test : Non synchronized decoder */
1595 }
1596
1597 DISPLAYLEVEL(3, "LZ4_compress_HC_destSize : ");
1598 /* encode congenerical sequence test for HC compressors */
1599 { LZ4_streamHC_t* const sHC = LZ4_createStreamHC();
1600 int const src_buf_size = 3 MB;
1601 int const dst_buf_size = 6 KB;
1602 int const payload = 0;
1603 int const dst_step = 43;
1604 int const dst_min_len = 33 + (FUZ_rand(&randState) % dst_step);
1605 int const dst_max_len = 5000;
1606 int slen, dlen;
1607 char* sbuf1 = (char*)malloc(src_buf_size + 1);
1608 char* sbuf2 = (char*)malloc(src_buf_size + 1);
1609 char* dbuf1 = (char*)malloc(dst_buf_size + 1);
1610 char* dbuf2 = (char*)malloc(dst_buf_size + 1);
1611
1612 assert(sHC != NULL);
1613 assert(dst_buf_size > dst_max_len);
1614 if (!sbuf1 || !sbuf2 || !dbuf1 || !dbuf2) {
1615 EXIT_MSG("not enough memory for FUZ_unitTests (destSize)");
1616 }
1617 for (dlen = dst_min_len; dlen <= dst_max_len; dlen += dst_step) {
1618 int src_len = (dlen - 10)*255 + 24;
1619 if (src_len + 10 >= src_buf_size) break; /* END of check */
1620 for (slen = src_len - 3; slen <= src_len + 3; slen++) {
1621 int srcsz1, srcsz2;
1622 int dsz1, dsz2;
1623 int res1, res2;
1624 char const endchk = (char)0x88;
1625 DISPLAYLEVEL(5, "slen = %i, ", slen);
1626
1627 srcsz1 = slen;
1628 memset(sbuf1, payload, slen);
1629 memset(dbuf1, 0, dlen);
1630 dbuf1[dlen] = endchk;
1631 dsz1 = LZ4_compress_destSize(sbuf1, dbuf1, &srcsz1, dlen);
1632 DISPLAYLEVEL(5, "LZ4_compress_destSize: %i bytes compressed into %i bytes, ", srcsz1, dsz1);
1633 DISPLAYLEVEL(5, "last token : 0x%0X, ", dbuf1[dsz1 - 6]);
1634 DISPLAYLEVEL(5, "last ML extra lenbyte : 0x%0X, \n", dbuf1[dsz1 - 7]);
1635 FUZ_CHECKTEST(dbuf1[dlen] != endchk, "LZ4_compress_destSize() overwrite dst buffer !");
1636 FUZ_CHECKTEST(dsz1 <= 0, "LZ4_compress_destSize() compression failed");
1637 FUZ_CHECKTEST(dsz1 > dlen, "LZ4_compress_destSize() result larger than dst buffer !");
1638 FUZ_CHECKTEST(srcsz1 > slen, "LZ4_compress_destSize() read more than src buffer !");
1639
1640 res1 = LZ4_decompress_safe(dbuf1, sbuf1, dsz1, src_buf_size);
1641 FUZ_CHECKTEST(res1 != srcsz1, "LZ4_compress_destSize() decompression failed!");
1642
1643 srcsz2 = slen;
1644 memset(sbuf2, payload, slen);
1645 memset(dbuf2, 0, dlen);
1646 dbuf2[dlen] = endchk;
1647 LZ4_resetStreamHC(sHC, compressionLevel);
1648 dsz2 = LZ4_compress_HC_destSize(sHC, sbuf2, dbuf2, &srcsz2, dlen, compressionLevel);
1649 DISPLAYLEVEL(5, "LZ4_compress_HC_destSize: %i bytes compressed into %i bytes, ", srcsz2, dsz2);
1650 DISPLAYLEVEL(5, "last token : 0x%0X, ", dbuf2[dsz2 - 6]);
1651 DISPLAYLEVEL(5, "last ML extra lenbyte : 0x%0X, \n", dbuf2[dsz2 - 7]);
1652 FUZ_CHECKTEST(dbuf2[dlen] != endchk, "LZ4_compress_HC_destSize() overwrite dst buffer !");
1653 FUZ_CHECKTEST(dsz2 <= 0, "LZ4_compress_HC_destSize() compression failed");
1654 FUZ_CHECKTEST(dsz2 > dlen, "LZ4_compress_HC_destSize() result larger than dst buffer !");
1655 FUZ_CHECKTEST(srcsz2 > slen, "LZ4_compress_HC_destSize() read more than src buffer !");
1656 FUZ_CHECKTEST(dsz2 != dsz1, "LZ4_compress_HC_destSize() return incorrect result !");
1657 FUZ_CHECKTEST(srcsz2 != srcsz1, "LZ4_compress_HC_destSize() return incorrect src buffer size "
1658 ": srcsz2(%i) != srcsz1(%i)", srcsz2, srcsz1);
1659 FUZ_CHECKTEST(memcmp(dbuf2, dbuf1, (size_t)dsz2), "LZ4_compress_HC_destSize() return incorrect data into dst buffer !");
1660
1661 res2 = LZ4_decompress_safe(dbuf2, sbuf1, dsz2, src_buf_size);
1662 FUZ_CHECKTEST(res2 != srcsz1, "LZ4_compress_HC_destSize() decompression failed!");
1663
1664 FUZ_CHECKTEST(memcmp(sbuf1, sbuf2, (size_t)res2), "LZ4_compress_HC_destSize() decompression corruption!");
1665 }
1666 }
1667 LZ4_freeStreamHC(sHC);
1668 free(sbuf1);
1669 free(sbuf2);
1670 free(dbuf1);
1671 free(dbuf2);
1672 }
1673 DISPLAYLEVEL(3, " OK \n");
1674
1675
1676 /* clean up */
1677 free(testInput);
1678 free(testCompressed);
1679 free(testVerify);
1680
1681 printf("All unit tests completed successfully compressionLevel=%d \n", compressionLevel);
1682 return;
1683 }
1684
1685
1686
1687 /* =======================================
1688 * CLI
1689 * ======================================= */
1690
FUZ_usage(const char * programName)1691 static int FUZ_usage(const char* programName)
1692 {
1693 DISPLAY( "Usage :\n");
1694 DISPLAY( " %s [args]\n", programName);
1695 DISPLAY( "\n");
1696 DISPLAY( "Arguments :\n");
1697 DISPLAY( " -i# : Nb of tests (default:%i) \n", NB_ATTEMPTS);
1698 DISPLAY( " -T# : Duration of tests, in seconds (default: use Nb of tests) \n");
1699 DISPLAY( " -s# : Select seed (default:prompt user)\n");
1700 DISPLAY( " -t# : Select starting test number (default:0)\n");
1701 DISPLAY( " -P# : Select compressibility in %% (default:%i%%)\n", FUZ_COMPRESSIBILITY_DEFAULT);
1702 DISPLAY( " -v : verbose\n");
1703 DISPLAY( " -p : pause at the end\n");
1704 DISPLAY( " -h : display help and exit\n");
1705 return 0;
1706 }
1707
1708
main(int argc,const char ** argv)1709 int main(int argc, const char** argv)
1710 {
1711 U32 seed = 0;
1712 int seedset = 0;
1713 int argNb;
1714 unsigned nbTests = NB_ATTEMPTS;
1715 unsigned testNb = 0;
1716 int proba = FUZ_COMPRESSIBILITY_DEFAULT;
1717 int use_pause = 0;
1718 const char* programName = argv[0];
1719 U32 duration = 0;
1720
1721 /* Check command line */
1722 for(argNb=1; argNb<argc; argNb++) {
1723 const char* argument = argv[argNb];
1724
1725 if(!argument) continue; // Protection if argument empty
1726
1727 // Decode command (note : aggregated commands are allowed)
1728 if (argument[0]=='-') {
1729 if (!strcmp(argument, "--no-prompt")) { use_pause=0; seedset=1; g_displayLevel=1; continue; }
1730 argument++;
1731
1732 while (*argument!=0) {
1733 switch(*argument)
1734 {
1735 case 'h': /* display help */
1736 return FUZ_usage(programName);
1737
1738 case 'v': /* verbose mode */
1739 g_displayLevel++;
1740 argument++;
1741 break;
1742
1743 case 'p': /* pause at the end */
1744 use_pause=1;
1745 argument++;
1746 break;
1747
1748 case 'i':
1749 argument++;
1750 nbTests = 0; duration = 0;
1751 while ((*argument>='0') && (*argument<='9')) {
1752 nbTests *= 10;
1753 nbTests += (unsigned)(*argument - '0');
1754 argument++;
1755 }
1756 break;
1757
1758 case 'T':
1759 argument++;
1760 nbTests = 0; duration = 0;
1761 for (;;) {
1762 switch(*argument)
1763 {
1764 case 'm': duration *= 60; argument++; continue;
1765 case 's':
1766 case 'n': argument++; continue;
1767 case '0':
1768 case '1':
1769 case '2':
1770 case '3':
1771 case '4':
1772 case '5':
1773 case '6':
1774 case '7':
1775 case '8':
1776 case '9': duration *= 10; duration += (U32)(*argument++ - '0'); continue;
1777 }
1778 break;
1779 }
1780 break;
1781
1782 case 's':
1783 argument++;
1784 seed=0; seedset=1;
1785 while ((*argument>='0') && (*argument<='9')) {
1786 seed *= 10;
1787 seed += (U32)(*argument - '0');
1788 argument++;
1789 }
1790 break;
1791
1792 case 't': /* select starting test nb */
1793 argument++;
1794 testNb=0;
1795 while ((*argument>='0') && (*argument<='9')) {
1796 testNb *= 10;
1797 testNb += (unsigned)(*argument - '0');
1798 argument++;
1799 }
1800 break;
1801
1802 case 'P': /* change probability */
1803 argument++;
1804 proba=0;
1805 while ((*argument>='0') && (*argument<='9')) {
1806 proba *= 10;
1807 proba += *argument - '0';
1808 argument++;
1809 }
1810 if (proba<0) proba=0;
1811 if (proba>100) proba=100;
1812 break;
1813 default: ;
1814 }
1815 }
1816 }
1817 }
1818
1819 printf("Starting LZ4 fuzzer (%i-bits, v%s)\n", (int)(sizeof(size_t)*8), LZ4_versionString());
1820
1821 if (!seedset) {
1822 time_t const t = time(NULL);
1823 U32 const h = XXH32(&t, sizeof(t), 1);
1824 seed = h % 10000;
1825 }
1826 printf("Seed = %u\n", seed);
1827
1828 if (proba!=FUZ_COMPRESSIBILITY_DEFAULT) printf("Compressibility : %i%%\n", proba);
1829
1830 if ((seedset==0) && (testNb==0)) { FUZ_unitTests(LZ4HC_CLEVEL_DEFAULT); FUZ_unitTests(LZ4HC_CLEVEL_OPT_MIN); }
1831
1832 nbTests += (nbTests==0); /* avoid zero */
1833
1834 { int const result = FUZ_test(seed, nbTests, testNb, ((double)proba) / 100, duration);
1835 if (use_pause) {
1836 DISPLAY("press enter ... \n");
1837 (void)getchar();
1838 }
1839 return result;
1840 }
1841 }
1842