electrobun 0.0.1 → 0.0.2

package/src/bsdiff/zstd/tests/fuzz/decompress_cross_format.c

@@ -1,130 +0,0 @@
-/*
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- * All rights reserved.
- *
- * This source code is licensed under both the BSD-style license (found in the
- * LICENSE file in the root directory of this source tree) and the GPLv2 (found
- * in the COPYING file in the root directory of this source tree).
- * You may select, at your option, one of the above-listed licenses.
- */
-
-// This fuzz target validates decompression of magicless-format compressed data.
-
-#include <stddef.h>
-#include <stdlib.h>
-#include <stdio.h>
-#include <string.h>
-#include "fuzz_helpers.h"
-#define ZSTD_STATIC_LINKING_ONLY
-#include "zstd.h"
-#include "fuzz_data_producer.h"
-
-static ZSTD_DCtx *dctx = NULL;
-
-int LLVMFuzzerTestOneInput(const uint8_t *src, size_t size)
-{
-    // Give a random portion of src data to the producer, to use for parameter generation.
-    // The rest will be interpreted as magicless compressed data.
-    FUZZ_dataProducer_t *producer = FUZZ_dataProducer_create(src, size);
-    size_t magiclessSize = FUZZ_dataProducer_reserveDataPrefix(producer);
-    const uint8_t* const magiclessSrc = src;
-    size_t const dstSize = FUZZ_dataProducer_uint32Range(producer, 0, 10 * size);
-    uint8_t* const standardDst = (uint8_t*)FUZZ_malloc(dstSize);
-    uint8_t* const magiclessDst = (uint8_t*)FUZZ_malloc(dstSize);
-
-    // Create standard-format src from magicless-format src
-    const uint32_t zstd_magic = ZSTD_MAGICNUMBER;
-    size_t standardSize = sizeof(zstd_magic) + magiclessSize;
-    uint8_t* const standardSrc = (uint8_t*)FUZZ_malloc(standardSize);
-    memcpy(standardSrc, &zstd_magic, sizeof(zstd_magic)); // assume fuzzing on little-endian machine
-    memcpy(standardSrc + sizeof(zstd_magic), magiclessSrc, magiclessSize);
-
-    // Truncate to a single frame
-    {
-        const size_t standardFrameCompressedSize = ZSTD_findFrameCompressedSize(standardSrc, standardSize);
-        if (ZSTD_isError(standardFrameCompressedSize)) {
-            goto cleanup_and_return;
-        }
-        standardSize = standardFrameCompressedSize;
-        magiclessSize = standardFrameCompressedSize - sizeof(zstd_magic);
-    }
-
-    // Create DCtx if needed
-    if (!dctx) {
-        dctx = ZSTD_createDCtx();
-        FUZZ_ASSERT(dctx);
-    }
-
-    // Test one-shot decompression
-    {
-        FUZZ_ZASSERT(ZSTD_DCtx_reset(dctx, ZSTD_reset_session_and_parameters));
-        FUZZ_ZASSERT(ZSTD_DCtx_setParameter(dctx, ZSTD_d_format, ZSTD_f_zstd1));
-        const size_t standardRet = ZSTD_decompressDCtx(
-                                        dctx, standardDst, dstSize, standardSrc, standardSize);
-
-        FUZZ_ZASSERT(ZSTD_DCtx_reset(dctx, ZSTD_reset_session_and_parameters));
-        FUZZ_ZASSERT(ZSTD_DCtx_setParameter(dctx, ZSTD_d_format, ZSTD_f_zstd1_magicless));
-        const size_t magiclessRet = ZSTD_decompressDCtx(
-                                        dctx, magiclessDst, dstSize, magiclessSrc, magiclessSize);
-
-        // Standard accepts => magicless should accept
-        if (!ZSTD_isError(standardRet)) FUZZ_ZASSERT(magiclessRet);
-
-        // Magicless accepts => standard should accept
-        // NOTE: this is nice-to-have, please disable this check if it is difficult to satisfy.
-        if (!ZSTD_isError(magiclessRet)) FUZZ_ZASSERT(standardRet);
-
-        // If both accept, decompressed size and data should match
-        if (!ZSTD_isError(standardRet) && !ZSTD_isError(magiclessRet)) {
-            FUZZ_ASSERT(standardRet == magiclessRet);
-            if (standardRet > 0) {
-                FUZZ_ASSERT(
-                    memcmp(standardDst, magiclessDst, standardRet) == 0
-                );
-            }
-        }
-    }
-
-    // Test streaming decompression
-    {
-        ZSTD_inBuffer standardIn = { standardSrc, standardSize, 0 };
-        ZSTD_inBuffer magiclessIn = { magiclessSrc, magiclessSize, 0 };
-        ZSTD_outBuffer standardOut = { standardDst, dstSize, 0 };
-        ZSTD_outBuffer magiclessOut = { magiclessDst, dstSize, 0 };
-
-        FUZZ_ZASSERT(ZSTD_DCtx_reset(dctx, ZSTD_reset_session_and_parameters));
-        FUZZ_ZASSERT(ZSTD_DCtx_setParameter(dctx, ZSTD_d_format, ZSTD_f_zstd1));
-        const size_t standardRet = ZSTD_decompressStream(dctx, &standardOut, &standardIn);
-
-        FUZZ_ZASSERT(ZSTD_DCtx_reset(dctx, ZSTD_reset_session_and_parameters));
-        FUZZ_ZASSERT(ZSTD_DCtx_setParameter(dctx, ZSTD_d_format, ZSTD_f_zstd1_magicless));
-        const size_t magiclessRet = ZSTD_decompressStream(dctx, &magiclessOut, &magiclessIn);
-
-        // Standard accepts => magicless should accept
-        if (standardRet == 0) FUZZ_ASSERT(magiclessRet == 0);
-
-        // Magicless accepts => standard should accept
-        // NOTE: this is nice-to-have, please disable this check if it is difficult to satisfy.
-        if (magiclessRet == 0) FUZZ_ASSERT(standardRet == 0);
-
-        // If both accept, decompressed size and data should match
-        if (standardRet == 0 && magiclessRet == 0) {
-            FUZZ_ASSERT(standardOut.pos == magiclessOut.pos);
-            if (standardOut.pos > 0) {
-                FUZZ_ASSERT(
-                    memcmp(standardOut.dst, magiclessOut.dst, standardOut.pos) == 0
-                );
-            }
-        }
-    }
-
-cleanup_and_return:
-#ifndef STATEFUL_FUZZING
-    ZSTD_freeDCtx(dctx); dctx = NULL;
-#endif
-    free(standardSrc);
-    free(standardDst);
-    free(magiclessDst);
-    FUZZ_dataProducer_free(producer);
-    return 0;
-}

package/src/bsdiff/zstd/tests/fuzz/decompress_dstSize_tooSmall.c

@@ -1,74 +0,0 @@
-/*
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- * All rights reserved.
- *
- * This source code is licensed under both the BSD-style license (found in the
- * LICENSE file in the root directory of this source tree) and the GPLv2 (found
- * in the COPYING file in the root directory of this source tree).
- * You may select, at your option, one of the above-listed licenses.
- */
-
-/**
- * This fuzz target attempts to decompress a valid compressed frame into
- * an output buffer that is too small to ensure we always get
- * ZSTD_error_dstSize_tooSmall.
- */
-
-#include <stddef.h>
-#include <stdlib.h>
-#include <stdio.h>
-#include "fuzz_helpers.h"
-#include "zstd.h"
-#include "zstd_errors.h"
-#include "zstd_helpers.h"
-#include "fuzz_data_producer.h"
-#include "fuzz_third_party_seq_prod.h"
-
-static ZSTD_CCtx *cctx = NULL;
-static ZSTD_DCtx *dctx = NULL;
-
-int LLVMFuzzerTestOneInput(const uint8_t *src, size_t size)
-{
-    FUZZ_SEQ_PROD_SETUP();
-
-    /* Give a random portion of src data to the producer, to use for
-    parameter generation. The rest will be used for (de)compression */
-    FUZZ_dataProducer_t *producer = FUZZ_dataProducer_create(src, size);
-    size_t rBufSize = FUZZ_dataProducer_uint32Range(producer, 0, size);
-    size = FUZZ_dataProducer_remainingBytes(producer);
-    /* Ensure the round-trip buffer is too small. */
-    if (rBufSize >= size) {
-        rBufSize = size > 0 ? size - 1 : 0;
-    }
-    size_t const cBufSize = ZSTD_compressBound(size);
-
-    if (!cctx) {
-        cctx = ZSTD_createCCtx();
-        FUZZ_ASSERT(cctx);
-    }
-    if (!dctx) {
-        dctx = ZSTD_createDCtx();
-        FUZZ_ASSERT(dctx);
-    }
-
-    void *cBuf = FUZZ_malloc(cBufSize);
-    void *rBuf = FUZZ_malloc(rBufSize);
-    size_t const cSize = ZSTD_compressCCtx(cctx, cBuf, cBufSize, src, size, 1);
-    FUZZ_ZASSERT(cSize);
-    size_t const rSize = ZSTD_decompressDCtx(dctx, rBuf, rBufSize, cBuf, cSize);
-    if (size == 0) {
-        FUZZ_ASSERT(rSize == 0);
-    } else {
-        FUZZ_ASSERT(ZSTD_isError(rSize));
-        FUZZ_ASSERT(ZSTD_getErrorCode(rSize) == ZSTD_error_dstSize_tooSmall);
-    }
-    free(cBuf);
-    free(rBuf);
-    FUZZ_dataProducer_free(producer);
-#ifndef STATEFUL_FUZZING
-    ZSTD_freeCCtx(cctx); cctx = NULL;
-    ZSTD_freeDCtx(dctx); dctx = NULL;
-#endif
-    FUZZ_SEQ_PROD_TEARDOWN();
-    return 0;
-}

package/src/bsdiff/zstd/tests/fuzz/dictionary_decompress.c

@@ -1,77 +0,0 @@
-/*
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- * All rights reserved.
- *
- * This source code is licensed under both the BSD-style license (found in the
- * LICENSE file in the root directory of this source tree) and the GPLv2 (found
- * in the COPYING file in the root directory of this source tree).
- * You may select, at your option, one of the above-listed licenses.
- */
-
-/**
- * This fuzz target attempts to decompress the fuzzed data with the dictionary
- * decompression function to ensure the decompressor never crashes. It does not
- * fuzz the dictionary.
- */
-
-#include <stddef.h>
-#include <stdlib.h>
-#include <stdio.h>
-#include "fuzz_helpers.h"
-#include "zstd_helpers.h"
-#include "fuzz_data_producer.h"
-#include "fuzz_third_party_seq_prod.h"
-
-static ZSTD_DCtx *dctx = NULL;
-
-int LLVMFuzzerTestOneInput(const uint8_t *src, size_t size)
-{
-    FUZZ_SEQ_PROD_SETUP();
-
-    /* Give a random portion of src data to the producer, to use for
-    parameter generation. The rest will be used for (de)compression */
-    FUZZ_dataProducer_t *producer = FUZZ_dataProducer_create(src, size);
-    size = FUZZ_dataProducer_reserveDataPrefix(producer);
-
-    FUZZ_dict_t dict;
-    ZSTD_DDict* ddict = NULL;
-
-    if (!dctx) {
-        dctx = ZSTD_createDCtx();
-        FUZZ_ASSERT(dctx);
-    }
-    dict = FUZZ_train(src, size, producer);
-    if (FUZZ_dataProducer_uint32Range(producer, 0, 1) == 0) {
-        ddict = ZSTD_createDDict(dict.buff, dict.size);
-        FUZZ_ASSERT(ddict);
-    } else {
-        if (FUZZ_dataProducer_uint32Range(producer, 0, 1) == 0)
-            FUZZ_ZASSERT(ZSTD_DCtx_loadDictionary_advanced(
-                dctx, dict.buff, dict.size,
-                (ZSTD_dictLoadMethod_e)FUZZ_dataProducer_uint32Range(producer, 0, 1),
-                (ZSTD_dictContentType_e)FUZZ_dataProducer_uint32Range(producer, 0, 2)));
-        else
-            FUZZ_ZASSERT(ZSTD_DCtx_refPrefix_advanced(
-                dctx, dict.buff, dict.size,
-                (ZSTD_dictContentType_e)FUZZ_dataProducer_uint32Range(producer, 0, 2)));
-    }
-
-    {
-        size_t const bufSize = FUZZ_dataProducer_uint32Range(producer, 0, 10 * size);
-        void* rBuf = FUZZ_malloc(bufSize);
-        if (ddict) {
-            ZSTD_decompress_usingDDict(dctx, rBuf, bufSize, src, size, ddict);
-        } else {
-            ZSTD_decompressDCtx(dctx, rBuf, bufSize, src, size);
-        }
-        free(rBuf);
-    }
-    free(dict.buff);
-    FUZZ_dataProducer_free(producer);
-    ZSTD_freeDDict(ddict);
-#ifndef STATEFUL_FUZZING
-    ZSTD_freeDCtx(dctx); dctx = NULL;
-#endif
-    FUZZ_SEQ_PROD_TEARDOWN();
-    return 0;
-}

package/src/bsdiff/zstd/tests/fuzz/dictionary_loader.c

@@ -1,106 +0,0 @@
-/*
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- * All rights reserved.
- *
- * This source code is licensed under both the BSD-style license (found in the
- * LICENSE file in the root directory of this source tree) and the GPLv2 (found
- * in the COPYING file in the root directory of this source tree).
- * You may select, at your option, one of the above-listed licenses.
- */
-
-/**
- * This fuzz target makes sure that whenever a compression dictionary can be
- * loaded, the data can be round tripped.
- */
-
-#include <stddef.h>
-#include <stdlib.h>
-#include <stdio.h>
-#include <string.h>
-#include "fuzz_helpers.h"
-#include "zstd_helpers.h"
-#include "fuzz_data_producer.h"
-#include "fuzz_third_party_seq_prod.h"
-
-/**
- * Compresses the data and returns the compressed size or an error.
- */
-static size_t compress(void* compressed, size_t compressedCapacity,
-                       void const* source, size_t sourceSize,
-                       void const* dict, size_t dictSize,
-                       ZSTD_dictLoadMethod_e dictLoadMethod,
-                       ZSTD_dictContentType_e dictContentType,
-                       int const refPrefix)
-{
-    ZSTD_CCtx* cctx = ZSTD_createCCtx();
-    if (refPrefix)
-        FUZZ_ZASSERT(ZSTD_CCtx_refPrefix_advanced(
-            cctx, dict, dictSize, dictContentType));
-    else
-        FUZZ_ZASSERT(ZSTD_CCtx_loadDictionary_advanced(
-            cctx, dict, dictSize, dictLoadMethod, dictContentType));
-    size_t const compressedSize = ZSTD_compress2(
-            cctx, compressed, compressedCapacity, source, sourceSize);
-    ZSTD_freeCCtx(cctx);
-    return compressedSize;
-}
-
-static size_t decompress(void* result, size_t resultCapacity,
-                         void const* compressed, size_t compressedSize,
-                         void const* dict, size_t dictSize,
-                       ZSTD_dictLoadMethod_e dictLoadMethod,
-                         ZSTD_dictContentType_e dictContentType,
-                         int const refPrefix)
-{
-    ZSTD_DCtx* dctx = ZSTD_createDCtx();
-    if (refPrefix)
-        FUZZ_ZASSERT(ZSTD_DCtx_refPrefix_advanced(
-            dctx, dict, dictSize, dictContentType));
-    else
-        FUZZ_ZASSERT(ZSTD_DCtx_loadDictionary_advanced(
-            dctx, dict, dictSize, dictLoadMethod, dictContentType));
-    size_t const resultSize = ZSTD_decompressDCtx(
-            dctx, result, resultCapacity, compressed, compressedSize);
-    FUZZ_ZASSERT(resultSize);
-    ZSTD_freeDCtx(dctx);
-    return resultSize;
-}
-
-int LLVMFuzzerTestOneInput(const uint8_t *src, size_t size)
-{
-    FUZZ_SEQ_PROD_SETUP();
-    FUZZ_dataProducer_t *producer = FUZZ_dataProducer_create(src, size);
-    int const refPrefix = FUZZ_dataProducer_uint32Range(producer, 0, 1) != 0;
-    ZSTD_dictLoadMethod_e const dlm =
-    size = FUZZ_dataProducer_uint32Range(producer, 0, 1);
-    ZSTD_dictContentType_e const dct =
-            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);
-
-    void* const rBuf = FUZZ_malloc(size);
-    size_t const cBufSize = ZSTD_compressBound(size);
-    void* const cBuf = FUZZ_malloc(cBufSize);
-
-    size_t const cSize =
-            compress(cBuf, cBufSize, src, size, src, size, dlm, dct, refPrefix);
-    /* compression failing is okay */
-    if (ZSTD_isError(cSize)) {
-      FUZZ_ASSERT_MSG(dct != ZSTD_dct_rawContent, "Raw must always succeed!");
-      goto out;
-    }
-    size_t const rSize =
-            decompress(rBuf, size, cBuf, cSize, src, size, dlm, dct, refPrefix);
-    FUZZ_ASSERT_MSG(rSize == size, "Incorrect regenerated size");
-    FUZZ_ASSERT_MSG(!FUZZ_memcmp(src, rBuf, size), "Corruption!");
-
-out:
-    free(cBuf);
-    free(rBuf);
-    FUZZ_dataProducer_free(producer);
-    FUZZ_SEQ_PROD_TEARDOWN();
-    return 0;
-}

package/src/bsdiff/zstd/tests/fuzz/dictionary_round_trip.c

@@ -1,155 +0,0 @@
-/*
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- * All rights reserved.
- *
- * This source code is licensed under both the BSD-style license (found in the
- * LICENSE file in the root directory of this source tree) and the GPLv2 (found
- * in the COPYING file in the root directory of this source tree).
- * You may select, at your option, one of the above-listed licenses.
- */
-
-/**
- * This fuzz target performs a zstd round-trip test (compress & decompress) with
- * a dictionary, compares the result with the original, and calls abort() on
- * corruption.
- */
-
-#include <stddef.h>
-#include <stdlib.h>
-#include <stdio.h>
-#include <string.h>
-#include "fuzz_helpers.h"
-#include "zstd_helpers.h"
-#include "fuzz_data_producer.h"
-#include "fuzz_third_party_seq_prod.h"
-
-static ZSTD_CCtx* cctx = NULL;
-static ZSTD_DCtx* dctx = NULL;
-
-static size_t roundTripTest(void* result, size_t resultCapacity,
-                            void* compressed, size_t compressedCapacity,
-                            const void* src, size_t srcSize,
-                            FUZZ_dataProducer_t* producer)
-{
-    ZSTD_dictContentType_e dictContentType = ZSTD_dct_auto;
-    FUZZ_dict_t dict = FUZZ_train(src, srcSize, producer);
-    int const refPrefix = FUZZ_dataProducer_uint32Range(producer, 0, 1) != 0;
-    size_t cSize;
-    if (FUZZ_dataProducer_uint32Range(producer, 0, 15) == 0) {
-        int const cLevel = FUZZ_dataProducer_int32Range(producer, kMinClevel, kMaxClevel);
-
-        cSize = ZSTD_compress_usingDict(cctx,
-                compressed, compressedCapacity,
-                src, srcSize,
-                dict.buff, dict.size,
-                cLevel);
-        FUZZ_ZASSERT(cSize);
-        // Compress a second time and check for determinism
-        {
-            size_t const cSize0 = cSize;
-            XXH64_hash_t const hash0 = XXH64(compressed, cSize, 0);
-            cSize = ZSTD_compress_usingDict(cctx,
-                    compressed, compressedCapacity,
-                    src, srcSize,
-                    dict.buff, dict.size,
-                    cLevel);
-            FUZZ_ASSERT(cSize == cSize0);
-            FUZZ_ASSERT(XXH64(compressed, cSize, 0) == hash0);
-        }
-    } else {
-        size_t remainingBytes;
-        dictContentType = FUZZ_dataProducer_uint32Range(producer, 0, 2);
-        remainingBytes = FUZZ_dataProducer_remainingBytes(producer);
-        FUZZ_setRandomParameters(cctx, srcSize, producer);
-        /* Disable checksum so we can use sizes smaller than compress bound. */
-        FUZZ_ZASSERT(ZSTD_CCtx_setParameter(cctx, ZSTD_c_checksumFlag, 0));
-        if (refPrefix)
-            FUZZ_ZASSERT(ZSTD_CCtx_refPrefix_advanced(
-                cctx, dict.buff, dict.size,
-                dictContentType));
-        else
-            FUZZ_ZASSERT(ZSTD_CCtx_loadDictionary_advanced(
-                cctx, dict.buff, dict.size,
-                (ZSTD_dictLoadMethod_e)FUZZ_dataProducer_uint32Range(producer, 0, 1),
-                dictContentType));
-        cSize = ZSTD_compress2(cctx, compressed, compressedCapacity, src, srcSize);
-        FUZZ_ZASSERT(cSize);
-        // Compress a second time and check for determinism
-        {
-            size_t const cSize0 = cSize;
-            XXH64_hash_t const hash0 = XXH64(compressed, cSize, 0);
-            FUZZ_dataProducer_rollBack(producer, remainingBytes);
-            FUZZ_setRandomParameters(cctx, srcSize, producer);
-            FUZZ_ZASSERT(ZSTD_CCtx_setParameter(cctx, ZSTD_c_checksumFlag, 0));
-            if (refPrefix)
-                FUZZ_ZASSERT(ZSTD_CCtx_refPrefix_advanced(
-                    cctx, dict.buff, dict.size,
-                    dictContentType));
-            cSize = ZSTD_compress2(cctx, compressed, compressedCapacity, src, srcSize);
-            FUZZ_ASSERT(cSize == cSize0);
-            FUZZ_ASSERT(XXH64(compressed, cSize, 0) == hash0);
-        }
-    }
-    if (refPrefix)
-        FUZZ_ZASSERT(ZSTD_DCtx_refPrefix_advanced(
-            dctx, dict.buff, dict.size,
-            dictContentType));
-    else
-        FUZZ_ZASSERT(ZSTD_DCtx_loadDictionary_advanced(
-            dctx, dict.buff, dict.size,
-            (ZSTD_dictLoadMethod_e)FUZZ_dataProducer_uint32Range(producer, 0, 1),
-            dictContentType));
-    {
-        size_t const ret = ZSTD_decompressDCtx(
-                dctx, result, resultCapacity, compressed, cSize);
-        free(dict.buff);
-        return ret;
-    }
-}
-
-int LLVMFuzzerTestOneInput(const uint8_t *src, size_t size)
-{
-    FUZZ_SEQ_PROD_SETUP();
-
-    /* Give a random portion of src data to the producer, to use for
-    parameter generation. The rest will be used for (de)compression */
-    FUZZ_dataProducer_t *producer = FUZZ_dataProducer_create(src, size);
-    size = FUZZ_dataProducer_reserveDataPrefix(producer);
-
-    size_t const rBufSize = size;
-    void* rBuf = FUZZ_malloc(rBufSize);
-    size_t cBufSize = ZSTD_compressBound(size);
-    void *cBuf;
-    /* Half of the time fuzz with a 1 byte smaller output size.
-     * This will still succeed because we force the checksum to be disabled,
-     * giving us 4 bytes of overhead.
-     */
-    cBufSize -= FUZZ_dataProducer_uint32Range(producer, 0, 1);
-    cBuf = FUZZ_malloc(cBufSize);
-
-    if (!cctx) {
-        cctx = ZSTD_createCCtx();
-        FUZZ_ASSERT(cctx);
-    }
-    if (!dctx) {
-        dctx = ZSTD_createDCtx();
-        FUZZ_ASSERT(dctx);
-    }
-
-    {
-        size_t const result =
-            roundTripTest(rBuf, rBufSize, cBuf, cBufSize, src, size, producer);
-        FUZZ_ZASSERT(result);
-        FUZZ_ASSERT_MSG(result == size, "Incorrect regenerated size");
-        FUZZ_ASSERT_MSG(!FUZZ_memcmp(src, rBuf, size), "Corruption!");
-    }
-    free(rBuf);
-    free(cBuf);
-    FUZZ_dataProducer_free(producer);
-#ifndef STATEFUL_FUZZING
-    ZSTD_freeCCtx(cctx); cctx = NULL;
-    ZSTD_freeDCtx(dctx); dctx = NULL;
-#endif
-    FUZZ_SEQ_PROD_TEARDOWN();
-    return 0;
-}