fixed another invalid scenario

compressSequencesAndLiterals() doesn't support sequence validation

diff --git a/.github/workflows/dev-long-tests.yml b/.github/workflows/dev-long-tests.yml
index d5e476b4c5a3332d251736956ba7917cded90c11..0adfed914128a9ecdfa3e14a23c8cd363325b212 100644 (file)
--- a/.github/workflows/dev-long-tests.yml
+++ b/.github/workflows/dev-long-tests.yml
@@ -188,7 +188,7 @@ jobs:
     - name: ASan + UBSan + Regression Test
       run: make -j uasanregressiontest
 
-  clang-ubsan-regression:
+  clang-asan-ubsan-regression:
     runs-on: ubuntu-latest
     steps:
     - uses: actions/checkout@b4ffde65f46336ab88eb53be808477a3936bae11 # tag=v4.1.1

diff --git a/tests/fuzz/Makefile b/tests/fuzz/Makefile
index a64d2d25289a81c5e098b55ec47d205b98013153..13e29bb7a96936dbcae4254ae3981e00cf0ce498 100644 (file)
--- a/tests/fuzz/Makefile
+++ b/tests/fuzz/Makefile
@@ -263,9 +263,10 @@ corpora: $(patsubst %,corpora/%,$(FUZZ_TARGETS))
 .PHONY: seedcorpora
 seedcorpora: $(patsubst %,corpora/%_seed_corpus.zip,$(FUZZ_TARGETS))
 
+REGRESSION_TARGET ?= all
 regressiontest: corpora
-       CC="$(CC)" CXX="$(CXX)" CFLAGS="$(CFLAGS)" CXXFLAGS="$(CXXFLAGS)" LDFLAGS="$(LDFLAGS)" $(PYTHON) ./fuzz.py build all --debug=$(DEBUGLEVEL)
-       $(PYTHON) ./fuzz.py regression all
+       CC="$(CC)" CXX="$(CXX)" CFLAGS="$(CFLAGS)" CXXFLAGS="$(CXXFLAGS)" LDFLAGS="$(LDFLAGS)" $(PYTHON) ./fuzz.py build $(REGRESSION_TARGET) --debug=$(DEBUGLEVEL)
+       $(PYTHON) ./fuzz.py regression $(REGRESSION_TARGET)
 
 clean:
        @$(RM) *.a *.o $(FUZZ_TARGETS)

diff --git a/tests/fuzz/dictionary_loader.c b/tests/fuzz/dictionary_loader.c
index 7b7c00428a799c777d986874dd521ed7e9d02bfc..ec9de4b0b6c288eecc53d46d543caf90ad6b6836 100644 (file)
--- a/tests/fuzz/dictionary_loader.c
+++ b/tests/fuzz/dictionary_loader.c
@@ -77,9 +77,9 @@ int LLVMFuzzerTestOneInput(const uint8_t *src, size_t size)
             FUZZ_dataProducer_uint32Range(producer, 0, 2);
     size = FUZZ_dataProducer_remainingBytes(producer);
 
-    DEBUGLOG(2, "Dict load method %d", dlm);
-    DEBUGLOG(2, "Dict content type %d", dct);
-    DEBUGLOG(2, "Dict size %u", (unsigned)size);
+    DEBUGLOG(4, "Dict load method %d", dlm);
+    DEBUGLOG(4, "Dict content type %d", dct);
+    DEBUGLOG(4, "Dict size %u", (unsigned)size);
 
     void* const rBuf = FUZZ_malloc(size);
     size_t const cBufSize = ZSTD_compressBound(size);

diff --git a/tests/fuzz/sequence_compression_api.c b/tests/fuzz/sequence_compression_api.c
index 21b6ac84e921eb1bf8e9ca8030d9bc396139d1d9..9295d248ccd155f1eb9224e65013f4cad9765267 100644 (file)
--- a/tests/fuzz/sequence_compression_api.c
+++ b/tests/fuzz/sequence_compression_api.c
@@ -239,8 +239,8 @@ transferLiterals(void* dst, size_t dstCapacity, const ZSTD_Sequence* seqs, size_
     for (n=0; n<nbSeqs; n++) {
         size_t litLen = seqs[n].litLength;
         size_t mlen = seqs[n].matchLength;
-        assert(op + litLen < oend);
-        assert(ip + litLen + mlen <= iend);
+        assert(op + litLen < oend); (void)oend;
+        assert(ip + litLen + mlen <= iend); (void)iend;
         memcpy(op, ip, litLen);
         op += litLen;
         ip += litLen + mlen;
@@ -253,8 +253,7 @@ static size_t roundTripTest_compressSequencesAndLiterals(
                     void* result, size_t resultCapacity,
                     void* compressed, size_t compressedCapacity,
                     const void* src, size_t srcSize,
-                    const ZSTD_Sequence* seqs, size_t nbSeqs,
-                    ZSTD_SequenceFormat_e mode)
+                    const ZSTD_Sequence* seqs, size_t nbSeqs)
 {
     size_t const litCapacity = srcSize + 8;
     void* literals = malloc(litCapacity);
@@ -267,21 +266,21 @@ static size_t roundTripTest_compressSequencesAndLiterals(
                                 compressed, compressedCapacity,
                                    seqs, nbSeqs,
                                    literals, litSize, litCapacity, srcSize);
-    if ( (ZSTD_getErrorCode(cSize) == ZSTD_error_dstSize_tooSmall)
-      && (mode == ZSTD_sf_explicitBlockDelimiters) ) {
+    free(literals);
+    if (ZSTD_getErrorCode(cSize) == ZSTD_error_cannotProduce_uncompressedBlock) {
+        /* Valid scenario : ZSTD_compressSequencesAndLiterals cannot generate uncompressed blocks */
+        return 0;
+    }
+    if (ZSTD_getErrorCode(cSize) == ZSTD_error_dstSize_tooSmall) {
         /* Valid scenario : in explicit delimiter mode,
          * it might be possible for the compressed size to outgrow dstCapacity.
          * In which case, it's still a valid fuzzer scenario,
          * but no roundtrip shall be possible */
         return 0;
     }
+
     /* round-trip */
-    if (ZSTD_isError(cSize)) {
-         ZSTD_ErrorCode err = ZSTD_getErrorCode(cSize);
-         /* this specific error might happen as a result of data being uncompressible */
-         if (err != ZSTD_error_cannotProduce_uncompressedBlock)
-            FUZZ_ZASSERT(cSize);
-    }
+    FUZZ_ZASSERT(cSize);
     {   size_t const dSize = ZSTD_decompressDCtx(dctx, result, resultCapacity, compressed, cSize);
         FUZZ_ZASSERT(dSize);
         FUZZ_ASSERT_MSG(dSize == srcSize, "Incorrect regenerated size");
@@ -305,11 +304,12 @@ static size_t roundTripTest(void* result, size_t resultCapacity,
         FUZZ_ZASSERT(ZSTD_DCtx_refDDict(dctx, ddict));
     }
 
-    {   int blockMode;
-        /* compressSequencesAndLiterals() only supports explicitBlockDelimiters */
+    {   int blockMode, validation;
+        /* compressSequencesAndLiterals() only supports explicitBlockDelimiters and no validation */
         FUZZ_ZASSERT(ZSTD_CCtx_getParameter(cctx, ZSTD_c_blockDelimiters, &blockMode));
-        if (blockMode == ZSTD_sf_explicitBlockDelimiters) {
-            FUZZ_ZASSERT(roundTripTest_compressSequencesAndLiterals(result, resultCapacity, compressed, compressedCapacity, src, srcSize, seqs, nbSeqs, mode));
+        FUZZ_ZASSERT(ZSTD_CCtx_getParameter(cctx, ZSTD_c_validateSequences, &validation));
+        if ((blockMode == ZSTD_sf_explicitBlockDelimiters) && (!validation)) {
+            FUZZ_ZASSERT(roundTripTest_compressSequencesAndLiterals(result, resultCapacity, compressed, compressedCapacity, src, srcSize, seqs, nbSeqs));
         }
     }