← Back to branch summary

~mmach/netext73/lz4

« back to all changes in this revision

Viewing changes to ossfuzz/round_trip_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:
ossfuzz/round_trip_fuzzer.c
20
20
 
21
21
    size_t const partialCapacity = FUZZ_getRange_from_uint32(partialCapacitySeed, 0, size);
22
22
    size_t const dstCapacity = LZ4_compressBound(size);
23
 
 
24
 
    char* const dst = (char*)malloc(dstCapacity);
 
23
    size_t const largeSize = 64 * 1024 - 1;
 
24
    size_t const smallSize = 1024;
 
25
    char* const dstPlusLargePrefix = (char*)malloc(dstCapacity + largeSize);
 
26
    FUZZ_ASSERT(dstPlusLargePrefix);
 
27
    char* const dstPlusSmallPrefix = dstPlusLargePrefix + largeSize - smallSize;
 
28
    char* const largeDict = (char*)malloc(largeSize);
 
29
    FUZZ_ASSERT(largeDict);
 
30
    char* const smallDict = largeDict + largeSize - smallSize;
 
31
    char* const dst = dstPlusLargePrefix + largeSize;
25
32
    char* const rt = (char*)malloc(size);
26
 
 
27
 
    FUZZ_ASSERT(dst);
28
33
    FUZZ_ASSERT(rt);
29
34
 
30
35
    /* Compression must succeed and round trip correctly. */
47
52
        FUZZ_ASSERT_MSG(!memcmp(data, partial, partialSize), "Corruption!");
48
53
        free(partial);
49
54
    }
50
 
 
51
 
 
52
 
    free(dst);
 
55
    /* Partial decompression using dict with no dict. */
 
56
    {
 
57
        char* const partial = (char*)malloc(partialCapacity);
 
58
        FUZZ_ASSERT(partial);
 
59
        int const partialSize = LZ4_decompress_safe_partial_usingDict(
 
60
                dst, partial, dstSize, partialCapacity, partialCapacity, NULL, 0);
 
61
        FUZZ_ASSERT(partialSize >= 0);
 
62
        FUZZ_ASSERT_MSG(partialSize == partialCapacity, "Incorrect size");
 
63
        FUZZ_ASSERT_MSG(!memcmp(data, partial, partialSize), "Corruption!");
 
64
        free(partial);
 
65
    }
 
66
    /* Partial decompression using dict with small prefix as dict */
 
67
    {
 
68
        char* const partial = (char*)malloc(partialCapacity);
 
69
        FUZZ_ASSERT(partial);
 
70
        int const partialSize = LZ4_decompress_safe_partial_usingDict(
 
71
                dst, partial, dstSize, partialCapacity, partialCapacity, dstPlusSmallPrefix, smallSize);
 
72
        FUZZ_ASSERT(partialSize >= 0);
 
73
        FUZZ_ASSERT_MSG(partialSize == partialCapacity, "Incorrect size");
 
74
        FUZZ_ASSERT_MSG(!memcmp(data, partial, partialSize), "Corruption!");
 
75
        free(partial);
 
76
    }
 
77
    /* Partial decompression using dict with large prefix as dict */
 
78
    {
 
79
        char* const partial = (char*)malloc(partialCapacity);
 
80
        FUZZ_ASSERT(partial);
 
81
        int const partialSize = LZ4_decompress_safe_partial_usingDict(
 
82
                dst, partial, dstSize, partialCapacity, partialCapacity, dstPlusLargePrefix, largeSize);
 
83
        FUZZ_ASSERT(partialSize >= 0);
 
84
        FUZZ_ASSERT_MSG(partialSize == partialCapacity, "Incorrect size");
 
85
        FUZZ_ASSERT_MSG(!memcmp(data, partial, partialSize), "Corruption!");
 
86
        free(partial);
 
87
    }
 
88
    /* Partial decompression using dict with small external dict */
 
89
    {
 
90
        char* const partial = (char*)malloc(partialCapacity);
 
91
        FUZZ_ASSERT(partial);
 
92
        int const partialSize = LZ4_decompress_safe_partial_usingDict(
 
93
                dst, partial, dstSize, partialCapacity, partialCapacity, smallDict, smallSize);
 
94
        FUZZ_ASSERT(partialSize >= 0);
 
95
        FUZZ_ASSERT_MSG(partialSize == partialCapacity, "Incorrect size");
 
96
        FUZZ_ASSERT_MSG(!memcmp(data, partial, partialSize), "Corruption!");
 
97
        free(partial);
 
98
    }
 
99
    /* Partial decompression using dict with large external dict */
 
100
    {
 
101
        char* const partial = (char*)malloc(partialCapacity);
 
102
        FUZZ_ASSERT(partial);
 
103
        int const partialSize = LZ4_decompress_safe_partial_usingDict(
 
104
                dst, partial, dstSize, partialCapacity, partialCapacity, largeDict, largeSize);
 
105
        FUZZ_ASSERT(partialSize >= 0);
 
106
        FUZZ_ASSERT_MSG(partialSize == partialCapacity, "Incorrect size");
 
107
        FUZZ_ASSERT_MSG(!memcmp(data, partial, partialSize), "Corruption!");
 
108
        free(partial);
 
109
    }
 
110
 
 
111
    free(dstPlusLargePrefix);
 
112
    free(largeDict);
53
113
    free(rt);
54
114
    FUZZ_dataProducer_free(producer);
55
115