← Back to branch summary

~mmach/netext73/lz4

« back to all changes in this revision

Viewing changes to tests/fuzzer.c

  • Committer: mmach
  • Date: 2022-11-09 18:52:10 UTC
  • Revision ID: netbit73@gmail.com-20221109185210-w358idlhh0phq688
1.9.4

Show diffs side-by-side

added added

removed removed

Lines of Context:
tests/fuzzer.c
1
1
/*
2
2
    fuzzer.c - Fuzzer test tool for LZ4
3
 
    Copyright (C) Yann Collet 2012-2017
 
3
    Copyright (C) Yann Collet 2012-2020
4
4
 
5
5
    GPL v2 License
6
6
 
30
30
#  pragma warning(disable : 4127)    /* disable: C4127: conditional expression is constant */
31
31
#  pragma warning(disable : 4146)    /* disable: C4146: minus unsigned expression */
32
32
#  pragma warning(disable : 4310)    /* disable: C4310: constant char value > 127 */
 
33
#  pragma warning(disable : 26451)   /* disable: C26451: Arithmetic overflow */
33
34
#endif
34
35
 
35
36
 
494
495
        {   char* const cBuffer_exact = (char*)malloc((size_t)compressedSize);
495
496
            assert(cBuffer_exact != NULL);
496
497
            assert(compressedSize <= (int)compressedBufferSize);
 
498
#if defined(_MSC_VER) && (_MSC_VER <= 1933) /* MSVC 2022 ver 17.3 or earlier */
 
499
#  pragma warning(push)
 
500
#  pragma warning(disable : 6385) /* lz4\tests\fuzzer.c(497): warning C6385: Reading invalid data from 'compressedBuffer'. */
 
501
#endif
497
502
            memcpy(cBuffer_exact, compressedBuffer, compressedSize);
 
503
#if defined(_MSC_VER) && (_MSC_VER <= 1933) /* MSVC 2022 ver 17.3 or earlier */
 
504
#  pragma warning(pop)
 
505
#endif
498
506
 
499
507
            /* Test decoding with output size exactly correct => must work */
500
508
            FUZ_DISPLAYTEST("LZ4_decompress_fast() with exact output buffer");
571
579
                for (;;) {
572
580
                    /* keep some original src */
573
581
                    {   U32 const nbBits = FUZ_rand(&randState) % maxNbBits;
574
 
                        size_t const mask = (1<<nbBits) - 1;
 
582
                        size_t const mask = (1ULL <<nbBits) - 1;
575
583
                        size_t const skipLength = FUZ_rand(&randState) & mask;
576
584
                        pos += skipLength;
577
585
                    }
579
587
                    /* add noise */
580
588
                    {   U32 const nbBitsCodes = FUZ_rand(&randState) % maxNbBits;
581
589
                        U32 const nbBits = nbBitsCodes ? nbBitsCodes-1 : 0;
582
 
                        size_t const mask = (1<<nbBits) - 1;
 
590
                        size_t const mask = (1ULL <<nbBits) - 1;
583
591
                        size_t const rNoiseLength = (FUZ_rand(&randState) & mask) + 1;
584
592
                        size_t const noiseLength = MIN(rNoiseLength, (size_t)compressedSize-pos);
585
593
                        size_t const noiseStart = FUZ_rand(&randState) % (COMPRESSIBLE_NOISE_LENGTH - noiseLength);
630
638
            FUZ_CHECKTEST(memcmp(block, decodedBuffer, (size_t)targetSize), "LZ4_decompress_safe_partial: corruption detected in regenerated data");
631
639
        }
632
640
 
 
641
        /* Partial decompression using dictionary. */
 
642
        FUZ_DISPLAYTEST("test LZ4_decompress_safe_partial_usingDict using no dict");
 
643
        {   size_t const missingOutBytes = FUZ_rand(&randState) % (unsigned)blockSize;
 
644
            int const targetSize = (int)((size_t)blockSize - missingOutBytes);
 
645
            size_t const extraneousInBytes = FUZ_rand(&randState) % 2;
 
646
            int const inCSize = (int)((size_t)compressedSize + extraneousInBytes);
 
647
            char const sentinel = decodedBuffer[targetSize] = block[targetSize] ^ 0x5A;
 
648
            int const decResult = LZ4_decompress_safe_partial_usingDict(compressedBuffer, decodedBuffer, inCSize, targetSize, blockSize, NULL, 0);
 
649
            FUZ_CHECKTEST(decResult<0, "LZ4_decompress_safe_partial_usingDict failed despite valid input data (error:%i)", decResult);
 
650
            FUZ_CHECKTEST(decResult != targetSize, "LZ4_decompress_safe_partial_usingDict did not regenerated required amount of data (%i < %i <= %i)", decResult, targetSize, blockSize);
 
651
            FUZ_CHECKTEST(decodedBuffer[targetSize] != sentinel, "LZ4_decompress_safe_partial_usingDict overwrite beyond requested size (though %i <= %i <= %i)", decResult, targetSize, blockSize);
 
652
            FUZ_CHECKTEST(memcmp(block, decodedBuffer, (size_t)targetSize), "LZ4_decompress_safe_partial_usingDict: corruption detected in regenerated data");
 
653
        }
 
654
 
 
655
        FUZ_DISPLAYTEST("test LZ4_decompress_safe_partial_usingDict() using prefix as dict");
 
656
        {   size_t const missingOutBytes = FUZ_rand(&randState) % (unsigned)blockSize;
 
657
            int const targetSize = (int)((size_t)blockSize - missingOutBytes);
 
658
            size_t const extraneousInBytes = FUZ_rand(&randState) % 2;
 
659
            int const inCSize = (int)((size_t)compressedSize + extraneousInBytes);
 
660
            char const sentinel = decodedBuffer[targetSize] = block[targetSize] ^ 0x5A;
 
661
            int const decResult = LZ4_decompress_safe_partial_usingDict(compressedBuffer, decodedBuffer, inCSize, targetSize, blockSize, decodedBuffer, dictSize);
 
662
            FUZ_CHECKTEST(decResult<0, "LZ4_decompress_safe_partial_usingDict failed despite valid input data (error:%i)", decResult);
 
663
            FUZ_CHECKTEST(decResult != targetSize, "LZ4_decompress_safe_partial_usingDict did not regenerated required amount of data (%i < %i <= %i)", decResult, targetSize, blockSize);
 
664
            FUZ_CHECKTEST(decodedBuffer[targetSize] != sentinel, "LZ4_decompress_safe_partial_usingDict overwrite beyond requested size (though %i <= %i <= %i)", decResult, targetSize, blockSize);
 
665
            FUZ_CHECKTEST(memcmp(block, decodedBuffer, (size_t)targetSize), "LZ4_decompress_safe_partial_usingDict: corruption detected in regenerated data");
 
666
        }
 
667
 
 
668
        FUZ_DISPLAYTEST("test LZ4_decompress_safe_partial_usingDict() using external dict");
 
669
        {   size_t const missingOutBytes = FUZ_rand(&randState) % (unsigned)blockSize;
 
670
            int const targetSize = (int)((size_t)blockSize - missingOutBytes);
 
671
            size_t const extraneousInBytes = FUZ_rand(&randState) % 2;
 
672
            int const inCSize = (int)((size_t)compressedSize + extraneousInBytes);
 
673
            char const sentinel = decodedBuffer[targetSize] = block[targetSize] ^ 0x5A;
 
674
            int const decResult = LZ4_decompress_safe_partial_usingDict(compressedBuffer, decodedBuffer, inCSize, targetSize, blockSize, dict, dictSize);
 
675
            FUZ_CHECKTEST(decResult<0, "LZ4_decompress_safe_partial_usingDict failed despite valid input data (error:%i)", decResult);
 
676
            FUZ_CHECKTEST(decResult != targetSize, "LZ4_decompress_safe_partial_usingDict did not regenerated required amount of data (%i < %i <= %i)", decResult, targetSize, blockSize);
 
677
            FUZ_CHECKTEST(decodedBuffer[targetSize] != sentinel, "LZ4_decompress_safe_partial_usingDict overwrite beyond requested size (though %i <= %i <= %i)", decResult, targetSize, blockSize);
 
678
            FUZ_CHECKTEST(memcmp(block, decodedBuffer, (size_t)targetSize), "LZ4_decompress_safe_partial_usingDict: corruption detected in regenerated data");
 
679
        }
 
680
 
633
681
        /* Test Compression with limited output size */
634
682
 
635
683
        /* Test compression with output size being exactly what's necessary (should work) */
1136
1184
        assert(shc != NULL);
1137
1185
        memset(shc, 0, sizeof(*shc));
1138
1186
        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)  );
 
1187
                    (void*)&(shc->state1), (void*)&(shc->state2), (void*)&(shc->state3), (unsigned)sizeof(LZ4_stream_t));
 
1188
        FUZ_CHECKTEST( LZ4_initStream(&(shc->state1), sizeof(shc->state1)) == NULL, "state1 (%p) failed init", (void*)&(shc->state1) );
 
1189
        FUZ_CHECKTEST( LZ4_initStream(&(shc->state2), sizeof(shc->state2)) == NULL, "state2 (%p) failed init", (void*)&(shc->state2)  );
 
1190
        FUZ_CHECKTEST( LZ4_initStream(&(shc->state3), sizeof(shc->state3)) == NULL, "state3 (%p) failed init", (void*)&(shc->state3)  );
1143
1191
        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 );
 
1192
                       "hc1+1 (%p) init must fail, due to bad alignment", (void*)((char*)&(shc->state1) + 1) );
1145
1193
        free(shc);
1146
1194
    }
1147
1195
    DISPLAYLEVEL(3, "all inits OK \n");
1246
1294
        assert(shc != NULL);
1247
1295
        memset(shc, 0, sizeof(*shc));
1248
1296
        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)  );
 
1297
                    (void*)&(shc->hc1), (void*)&(shc->hc2), (void*)&(shc->hc3),
 
1298
                    (unsigned)sizeof(LZ4_streamHC_t));
 
1299
        FUZ_CHECKTEST( LZ4_initStreamHC(&(shc->hc1), sizeof(shc->hc1)) == NULL, "hc1 (%p) failed init", (void*)&(shc->hc1) );
 
1300
        FUZ_CHECKTEST( LZ4_initStreamHC(&(shc->hc2), sizeof(shc->hc2)) == NULL, "hc2 (%p) failed init", (void*)&(shc->hc2)  );
 
1301
        FUZ_CHECKTEST( LZ4_initStreamHC(&(shc->hc3), sizeof(shc->hc3)) == NULL, "hc3 (%p) failed init", (void*)&(shc->hc3)  );
1253
1302
        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 );
 
1303
                        "hc1+1 (%p) init must fail, due to bad alignment", (void*)((char*)&(shc->hc1) + 1) );
1255
1304
        free(shc);
1256
1305
    }
1257
1306
    DISPLAYLEVEL(3, "all inits OK \n");