zstandard: vendor python-zstandard 0.13.0

Version 0.13.0 of the package was just released. It contains
an upgraded zstd C library which can result in some performance
wins, official support for Python 3.8, and a blackened code base.

There were no meaningful code or functionality changes in this
release of python-zstandard: just reformatting and an upgraded
zstd library version. So the diff seems much larger than what it
is.

Files were added without modifications.

The clang-format-ignorelist file was updated to reflect a new
header file in the zstd distribution.

# no-check-commit because 3rd party code has different style guidelines

Differential Revision: https://phab.mercurial-scm.org/D7770

contrib/clang-format-ignorelist

@@ -1,102 +1,103 b''
 # Files that just need to be migrated to the formatter.
 # Do not add new files here!
 mercurial/cext/manifest.c
 mercurial/cext/osutil.c
 # Vendored code that we should never format:
 contrib/python-zstandard/c-ext/bufferutil.c
 contrib/python-zstandard/c-ext/compressionchunker.c
 contrib/python-zstandard/c-ext/compressiondict.c
 contrib/python-zstandard/c-ext/compressionparams.c
 contrib/python-zstandard/c-ext/compressionreader.c
 contrib/python-zstandard/c-ext/compressionwriter.c
 contrib/python-zstandard/c-ext/compressobj.c
 contrib/python-zstandard/c-ext/compressor.c
 contrib/python-zstandard/c-ext/compressoriterator.c
 contrib/python-zstandard/c-ext/constants.c
 contrib/python-zstandard/c-ext/decompressionreader.c
 contrib/python-zstandard/c-ext/decompressionwriter.c
 contrib/python-zstandard/c-ext/decompressobj.c
 contrib/python-zstandard/c-ext/decompressor.c
 contrib/python-zstandard/c-ext/decompressoriterator.c
 contrib/python-zstandard/c-ext/frameparams.c
 contrib/python-zstandard/c-ext/python-zstandard.h
 contrib/python-zstandard/zstd.c
 contrib/python-zstandard/zstd/common/bitstream.h
 contrib/python-zstandard/zstd/common/compiler.h
 contrib/python-zstandard/zstd/common/cpu.h
 contrib/python-zstandard/zstd/common/debug.c
 contrib/python-zstandard/zstd/common/debug.h
 contrib/python-zstandard/zstd/common/entropy_common.c
 contrib/python-zstandard/zstd/common/error_private.c
 contrib/python-zstandard/zstd/common/error_private.h
 contrib/python-zstandard/zstd/common/fse_decompress.c
 contrib/python-zstandard/zstd/common/fse.h
 contrib/python-zstandard/zstd/common/huf.h
 contrib/python-zstandard/zstd/common/mem.h
 contrib/python-zstandard/zstd/common/pool.c
 contrib/python-zstandard/zstd/common/pool.h
 contrib/python-zstandard/zstd/common/threading.c
 contrib/python-zstandard/zstd/common/threading.h
 contrib/python-zstandard/zstd/common/xxhash.c
 contrib/python-zstandard/zstd/common/xxhash.h
 contrib/python-zstandard/zstd/common/zstd_common.c
 contrib/python-zstandard/zstd/common/zstd_errors.h
 contrib/python-zstandard/zstd/common/zstd_internal.h
 contrib/python-zstandard/zstd/compress/fse_compress.c
 contrib/python-zstandard/zstd/compress/hist.c
 contrib/python-zstandard/zstd/compress/hist.h
 contrib/python-zstandard/zstd/compress/huf_compress.c
 contrib/python-zstandard/zstd/compress/zstd_compress.c
 contrib/python-zstandard/zstd/compress/zstd_compress_internal.h
 contrib/python-zstandard/zstd/compress/zstd_compress_literals.c
 contrib/python-zstandard/zstd/compress/zstd_compress_literals.h
 contrib/python-zstandard/zstd/compress/zstd_compress_sequences.c
 contrib/python-zstandard/zstd/compress/zstd_compress_sequences.h
+contrib/python-zstandard/zstd/compress/zstd_cwksp.h
 contrib/python-zstandard/zstd/compress/zstd_double_fast.c
 contrib/python-zstandard/zstd/compress/zstd_double_fast.h
 contrib/python-zstandard/zstd/compress/zstd_fast.c
 contrib/python-zstandard/zstd/compress/zstd_fast.h
 contrib/python-zstandard/zstd/compress/zstd_lazy.c
 contrib/python-zstandard/zstd/compress/zstd_lazy.h
 contrib/python-zstandard/zstd/compress/zstd_ldm.c
 contrib/python-zstandard/zstd/compress/zstd_ldm.h
 contrib/python-zstandard/zstd/compress/zstdmt_compress.c
 contrib/python-zstandard/zstd/compress/zstdmt_compress.h
 contrib/python-zstandard/zstd/compress/zstd_opt.c
 contrib/python-zstandard/zstd/compress/zstd_opt.h
 contrib/python-zstandard/zstd/decompress/huf_decompress.c
 contrib/python-zstandard/zstd/decompress/zstd_ddict.c
 contrib/python-zstandard/zstd/decompress/zstd_ddict.h
 contrib/python-zstandard/zstd/decompress/zstd_decompress_block.c
 contrib/python-zstandard/zstd/decompress/zstd_decompress_block.h
 contrib/python-zstandard/zstd/decompress/zstd_decompress_internal.h
 contrib/python-zstandard/zstd/decompress/zstd_decompress.c
 contrib/python-zstandard/zstd/deprecated/zbuff_common.c
 contrib/python-zstandard/zstd/deprecated/zbuff_compress.c
 contrib/python-zstandard/zstd/deprecated/zbuff_decompress.c
 contrib/python-zstandard/zstd/deprecated/zbuff.h
 contrib/python-zstandard/zstd/dictBuilder/cover.c
 contrib/python-zstandard/zstd/dictBuilder/cover.h
 contrib/python-zstandard/zstd/dictBuilder/divsufsort.c
 contrib/python-zstandard/zstd/dictBuilder/divsufsort.h
 contrib/python-zstandard/zstd/dictBuilder/fastcover.c
 contrib/python-zstandard/zstd/dictBuilder/zdict.c
 contrib/python-zstandard/zstd/dictBuilder/zdict.h
 contrib/python-zstandard/zstd/zstd.h
 hgext/fsmonitor/pywatchman/bser.c
 mercurial/thirdparty/xdiff/xdiff.h
 mercurial/thirdparty/xdiff/xdiffi.c
 mercurial/thirdparty/xdiff/xdiffi.h
 mercurial/thirdparty/xdiff/xemit.c
 mercurial/thirdparty/xdiff/xemit.h
 mercurial/thirdparty/xdiff/xhistogram.c
 mercurial/thirdparty/xdiff/xinclude.h
 mercurial/thirdparty/xdiff/xmacros.h
 mercurial/thirdparty/xdiff/xmerge.c
 mercurial/thirdparty/xdiff/xpatience.c
 mercurial/thirdparty/xdiff/xprepare.c
 mercurial/thirdparty/xdiff/xprepare.h
 mercurial/thirdparty/xdiff/xtypes.h
 mercurial/thirdparty/xdiff/xutils.c
 mercurial/thirdparty/xdiff/xutils.h
 mercurial/thirdparty/zope/interface/_zope_interface_coptimizations.c

contrib/python-zstandard/NEWS.rst

@@ -1,702 +1,721 b''
 ===============
 Version History
 ===============
 
 1.0.0 (not yet released)
 ========================
 
 Actions Blocking Release
 ------------------------
 
 * compression and decompression APIs that support ``io.RawIOBase`` interface
   (#13).
 * ``stream_writer()`` APIs should support ``io.RawIOBase`` interface.
 * Properly handle non-blocking I/O and partial writes for objects implementing
   ``io.RawIOBase``.
 * Make ``write_return_read=True`` the default for objects implementing
   ``io.RawIOBase``.
 * Audit for consistent and proper behavior of ``flush()`` and ``close()`` for
   all objects implementing ``io.RawIOBase``. Is calling ``close()`` on
   wrapped stream acceptable, should ``__exit__`` always call ``close()``,
   should ``close()`` imply ``flush()``, etc.
 * Consider making reads across frames configurable behavior.
 * Refactor module names so C and CFFI extensions live under ``zstandard``
   package.
 * Overall API design review.
 * Use Python allocator where possible.
 * Figure out what to do about experimental APIs not implemented by CFFI.
 * APIs for auto adjusting compression parameters based on input size. e.g.
   clamping the window log so it isn't too large for input.
 * Consider allowing compressor and decompressor instances to be thread safe,
   support concurrent operations. Or track when an operation is in progress and
   refuse to let concurrent operations use the same instance.
 * Support for magic-less frames for all decompression operations (``decompress()``
   doesn't work due to sniffing the content size and the lack of a ZSTD API to
   sniff magic-less frames - this should be fixed in 1.3.5.).
 * Audit for complete flushing when ending compression streams.
 * Deprecate legacy APIs.
 * Audit for ability to control read/write sizes on all APIs.
 * Detect memory leaks via bench.py.
 * Remove low-level compression parameters from ``ZstdCompressor.__init__`` and
   require use of ``CompressionParameters``.
 * Expose ``ZSTD_getFrameProgression()`` from more compressor types.
 * Support modifying compression parameters mid operation when supported by
   zstd API.
 * Expose ``ZSTD_CLEVEL_DEFAULT`` constant.
+* Expose ``ZSTD_SRCSIZEHINT_{MIN,MAX}`` constants.
 * Support ``ZSTD_p_forceAttachDict`` compression parameter.
-* Support ``ZSTD_c_literalCompressionMode `` compression parameter.
+* Support ``ZSTD_dictForceLoad`` dictionary compression parameter.
+* Support ``ZSTD_c_targetCBlockSize`` compression parameter.
+* Support ``ZSTD_c_literalCompressionMode`` compression parameter.
+* Support ``ZSTD_c_srcSizeHint`` compression parameter.
 * Use ``ZSTD_CCtx_getParameter()``/``ZSTD_CCtxParam_getParameter()`` for retrieving
   compression parameters.
 * Consider exposing ``ZSTDMT_toFlushNow()``.
 * Expose ``ZDICT_trainFromBuffer_fastCover()``,
   ``ZDICT_optimizeTrainFromBuffer_fastCover``.
+* Expose ``ZSTD_Sequence`` struct and related ``ZSTD_getSequences()`` API.
 * Expose and enforce ``ZSTD_minCLevel()`` for minimum compression level.
 * Consider a ``chunker()`` API for decompression.
 * Consider stats for ``chunker()`` API, including finding the last consumed
   offset of input data.
 * Consider exposing ``ZSTD_cParam_getBounds()`` and
   ``ZSTD_dParam_getBounds()`` APIs.
 * Consider controls over resetting compression contexts (session only, parameters,
   or session and parameters).
 * Actually use the CFFI backend in fuzzing tests.
 
 Other Actions Not Blocking Release
 ---------------------------------------
 
 * Support for block compression APIs.
 * API for ensuring max memory ceiling isn't exceeded.
 * Move off nose for testing.
 
+0.13.0 (released 2019-12-28)
+============================
+
+Changes
+-------
+
+* ``pytest-xdist`` ``pytest`` extension is now installed so tests can be
+  run in parallel.
+* CI now builds ``manylinux2010`` and ``manylinux2014`` binary wheels
+  instead of a mix of ``manylinux2010`` and ``manylinux1``.
+* Official support for Python 3.8 has been added.
+* Bundled zstandard library upgraded from 1.4.3 to 1.4.4.
+* Python code has been reformatted with black.
+
 0.12.0 (released 2019-09-15)
 ============================
 
 Backwards Compatibility Notes
 -----------------------------
 
 * Support for Python 3.4 has been dropped since Python 3.4 is no longer
   a supported Python version upstream. (But it will likely continue to
   work until Python 2.7 support is dropped and we port to Python 3.5+
   APIs.)
 
 Bug Fixes
 ---------
 
 * Fix ``ZstdDecompressor.__init__`` on 64-bit big-endian systems (#91).
 * Fix memory leak in ``ZstdDecompressionReader.seek()`` (#82).
 
 Changes
 -------
 
 * CI transitioned to Azure Pipelines (from AppVeyor and Travis CI).
 * Switched to ``pytest`` for running tests (from ``nose``).
 * Bundled zstandard library upgraded from 1.3.8 to 1.4.3.
 
 0.11.1 (released 2019-05-14)
 ============================
 
 * Fix memory leak in ``ZstdDecompressionReader.seek()`` (#82).
 
 0.11.0 (released 2019-02-24)
 ============================
 
 Backwards Compatibility Notes
 -----------------------------
 
 * ``ZstdDecompressor.read()`` now allows reading sizes of ``-1`` or ``0``
   and defaults to ``-1``, per the documented behavior of
   ``io.RawIOBase.read()``. Previously, we required an argument that was
   a positive value.
 * The ``readline()``, ``readlines()``, ``__iter__``, and ``__next__`` methods
   of ``ZstdDecompressionReader()`` now raise ``io.UnsupportedOperation``
   instead of ``NotImplementedError``.
 * ``ZstdDecompressor.stream_reader()`` now accepts a ``read_across_frames``
   argument. The default value will likely be changed in a future release
   and consumers are advised to pass the argument to avoid unwanted change
   of behavior in the future.
 * ``setup.py`` now always disables the CFFI backend if the installed
   CFFI package does not meet the minimum version requirements. Before, it was
   possible for the CFFI backend to be generated and a run-time error to
   occur.
 * In the CFFI backend, ``CompressionReader`` and ``DecompressionReader``
   were renamed to ``ZstdCompressionReader`` and ``ZstdDecompressionReader``,
   respectively so naming is identical to the C extension. This should have
   no meaningful end-user impact, as instances aren't meant to be
   constructed directly.
 * ``ZstdDecompressor.stream_writer()`` now accepts a ``write_return_read``
   argument to control whether ``write()`` returns the number of bytes
   read from the source / written to the decompressor. It defaults to off,
   which preserves the existing behavior of returning the number of bytes
   emitted from the decompressor. The default will change in a future release
   so behavior aligns with the specified behavior of ``io.RawIOBase``.
 * ``ZstdDecompressionWriter.__exit__`` now calls ``self.close()``. This
   will result in that stream plus the underlying stream being closed as
   well. If this behavior is not desirable, do not use instances as
   context managers.
 * ``ZstdCompressor.stream_writer()`` now accepts a ``write_return_read``
   argument to control whether ``write()`` returns the number of bytes read
   from the source / written to the compressor. It defaults to off, which
   preserves the existing behavior of returning the number of bytes emitted
   from the compressor. The default will change in a future release so
   behavior aligns with the specified behavior of ``io.RawIOBase``.
 * ``ZstdCompressionWriter.__exit__`` now calls ``self.close()``. This will
   result in that stream plus any underlying stream being closed as well. If
   this behavior is not desirable, do not use instances as context managers.
 * ``ZstdDecompressionWriter`` no longer requires being used as a context
   manager (#57).
 * ``ZstdCompressionWriter`` no longer requires being used as a context
   manager (#57).
 * The ``overlap_size_log`` attribute on ``CompressionParameters`` instances
   has been deprecated and will be removed in a future release. The
   ``overlap_log`` attribute should be used instead.
 * The ``overlap_size_log`` argument to ``CompressionParameters`` has been
   deprecated and will be removed in a future release. The ``overlap_log``
   argument should be used instead.
 * The ``ldm_hash_every_log`` attribute on ``CompressionParameters`` instances
   has been deprecated and will be removed in a future release. The
   ``ldm_hash_rate_log`` attribute should be used instead.
 * The ``ldm_hash_every_log`` argument to ``CompressionParameters`` has been
   deprecated and will be removed in a future release. The ``ldm_hash_rate_log``
   argument should be used instead.
 * The ``compression_strategy`` argument to ``CompressionParameters`` has been
   deprecated and will be removed in a future release. The ``strategy``
   argument should be used instead.
 * The ``SEARCHLENGTH_MIN`` and ``SEARCHLENGTH_MAX`` constants are deprecated
   and will be removed in a future release. Use ``MINMATCH_MIN`` and
   ``MINMATCH_MAX`` instead.
 * The ``zstd_cffi`` module has been renamed to ``zstandard.cffi``. As had
   been documented in the ``README`` file since the ``0.9.0`` release, the
   module should not be imported directly at its new location. Instead,
   ``import zstandard`` to cause an appropriate backend module to be loaded
   automatically.
 
 Bug Fixes
 ---------
 
 * CFFI backend could encounter a failure when sending an empty chunk into
   ``ZstdDecompressionObj.decompress()``. The issue has been fixed.
 * CFFI backend could encounter an error when calling
   ``ZstdDecompressionReader.read()`` if there was data remaining in an
   internal buffer. The issue has been fixed. (#71)
 
 Changes
 -------
 
 * ``ZstDecompressionObj.decompress()`` now properly handles empty inputs in
   the CFFI backend.
 * ``ZstdCompressionReader`` now implements ``read1()`` and ``readinto1()``.
   These are part of the ``io.BufferedIOBase`` interface.
 * ``ZstdCompressionReader`` has gained a ``readinto(b)`` method for reading
   compressed output into an existing buffer.
 * ``ZstdCompressionReader.read()`` now defaults to ``size=-1`` and accepts
   read sizes of ``-1`` and ``0``. The new behavior aligns with the documented
   behavior of ``io.RawIOBase``.
 * ``ZstdCompressionReader`` now implements ``readall()``. Previously, this
   method raised ``NotImplementedError``.
 * ``ZstdDecompressionReader`` now implements ``read1()`` and ``readinto1()``.
   These are part of the ``io.BufferedIOBase`` interface.
 * ``ZstdDecompressionReader.read()`` now defaults to ``size=-1`` and accepts
   read sizes of ``-1`` and ``0``. The new behavior aligns with the documented
   behavior of ``io.RawIOBase``.
 * ``ZstdDecompressionReader()`` now implements ``readall()``. Previously, this
   method raised ``NotImplementedError``.
 * The ``readline()``, ``readlines()``, ``__iter__``, and ``__next__`` methods
   of ``ZstdDecompressionReader()`` now raise ``io.UnsupportedOperation``
   instead of ``NotImplementedError``. This reflects a decision to never
   implement text-based I/O on (de)compressors and keep the low-level API
   operating in the binary domain. (#13)
 * ``README.rst`` now documented how to achieve linewise iteration using
   an ``io.TextIOWrapper`` with a ``ZstdDecompressionReader``.
 * ``ZstdDecompressionReader`` has gained a ``readinto(b)`` method for
   reading decompressed output into an existing buffer. This allows chaining
   to an ``io.TextIOWrapper`` on Python 3 without using an ``io.BufferedReader``.
 * ``ZstdDecompressor.stream_reader()`` now accepts a ``read_across_frames``
   argument to control behavior when the input data has multiple zstd
   *frames*. When ``False`` (the default for backwards compatibility), a
   ``read()`` will stop when the end of a zstd *frame* is encountered. When
   ``True``, ``read()`` can potentially return data spanning multiple zstd
   *frames*. The default will likely be changed to ``True`` in a future
   release.
 * ``setup.py`` now performs CFFI version sniffing and disables the CFFI
   backend if CFFI is too old. Previously, we only used ``install_requires``
   to enforce the CFFI version and not all build modes would properly enforce
   the minimum CFFI version. (#69)
 * CFFI's ``ZstdDecompressionReader.read()`` now properly handles data
   remaining in any internal buffer. Before, repeated ``read()`` could
   result in *random* errors. (#71)
 * Upgraded various Python packages in CI environment.
 * Upgrade to hypothesis 4.5.11.
 * In the CFFI backend, ``CompressionReader`` and ``DecompressionReader``
   were renamed to ``ZstdCompressionReader`` and ``ZstdDecompressionReader``,
   respectively.
 * ``ZstdDecompressor.stream_writer()`` now accepts a ``write_return_read``
   argument to control whether ``write()`` returns the number of bytes read
   from the source. It defaults to ``False`` to preserve backwards
   compatibility.
 * ``ZstdDecompressor.stream_writer()`` now implements the ``io.RawIOBase``
   interface and behaves as a proper stream object.
 * ``ZstdCompressor.stream_writer()`` now accepts a ``write_return_read``
   argument to control whether ``write()`` returns the number of bytes read
   from the source. It defaults to ``False`` to preserve backwards
   compatibility.
 * ``ZstdCompressionWriter`` now implements the ``io.RawIOBase`` interface and
   behaves as a proper stream object. ``close()`` will now close the stream
   and the underlying stream (if possible). ``__exit__`` will now call
   ``close()``. Methods like ``writable()`` and ``fileno()`` are implemented.
 * ``ZstdDecompressionWriter`` no longer must be used as a context manager.
 * ``ZstdCompressionWriter`` no longer must be used as a context manager.
   When not using as a context manager, it is important to call
   ``flush(FRAME_FRAME)`` or the compression stream won't be properly
   terminated and decoders may complain about malformed input.
 * ``ZstdCompressionWriter.flush()`` (what is returned from
   ``ZstdCompressor.stream_writer()``) now accepts an argument controlling the
   flush behavior. Its value can be one of the new constants
   ``FLUSH_BLOCK`` or ``FLUSH_FRAME``.
 * ``ZstdDecompressionObj`` instances now have a ``flush([length=None])`` method.
   This provides parity with standard library equivalent types. (#65)
 * ``CompressionParameters`` no longer redundantly store individual compression
   parameters on each instance. Instead, compression parameters are stored inside
   the underlying ``ZSTD_CCtx_params`` instance. Attributes for obtaining
   parameters are now properties rather than instance variables.
 * Exposed the ``STRATEGY_BTULTRA2`` constant.
 * ``CompressionParameters`` instances now expose an ``overlap_log`` attribute.
   This behaves identically to the ``overlap_size_log`` attribute.
 * ``CompressionParameters()`` now accepts an ``overlap_log`` argument that
   behaves identically to the ``overlap_size_log`` argument. An error will be
   raised if both arguments are specified.
 * ``CompressionParameters`` instances now expose an ``ldm_hash_rate_log``
   attribute. This behaves identically to the ``ldm_hash_every_log`` attribute.
 * ``CompressionParameters()`` now accepts a ``ldm_hash_rate_log`` argument that
   behaves identically to the ``ldm_hash_every_log`` argument. An error will be
   raised if both arguments are specified.
 * ``CompressionParameters()`` now accepts a ``strategy`` argument that behaves
   identically to the ``compression_strategy`` argument. An error will be raised
   if both arguments are specified.
 * The ``MINMATCH_MIN`` and ``MINMATCH_MAX`` constants were added. They are
   semantically equivalent to the old ``SEARCHLENGTH_MIN`` and
   ``SEARCHLENGTH_MAX`` constants.
 * Bundled zstandard library upgraded from 1.3.7 to 1.3.8.
 * ``setup.py`` denotes support for Python 3.7 (Python 3.7 was supported and
   tested in the 0.10 release).
 * ``zstd_cffi`` module has been renamed to ``zstandard.cffi``.
 * ``ZstdCompressor.stream_writer()`` now reuses a buffer in order to avoid
   allocating a new buffer for every operation. This should result in faster
   performance in cases where ``write()`` or ``flush()`` are being called
   frequently. (#62)
 * Bundled zstandard library upgraded from 1.3.6 to 1.3.7.
 
 0.10.2 (released 2018-11-03)
 ============================
 
 Bug Fixes
 ---------
 
 * ``zstd_cffi.py`` added to ``setup.py`` (#60).
 
 Changes
 -------
 
 * Change some integer casts to avoid ``ssize_t`` (#61).
 
 0.10.1 (released 2018-10-08)
 ============================
 
 Backwards Compatibility Notes
 -----------------------------
 
 * ``ZstdCompressor.stream_reader().closed`` is now a property instead of a
   method (#58).
 * ``ZstdDecompressor.stream_reader().closed`` is now a property instead of a
   method (#58).
 
 Changes
 -------
 
 * Stop attempting to package Python 3.6 for Miniconda. The latest version of
   Miniconda is using Python 3.7. The Python 3.6 Miniconda packages were a lie
   since this were built against Python 3.7.
 * ``ZstdCompressor.stream_reader()``'s and ``ZstdDecompressor.stream_reader()``'s
   ``closed`` attribute is now a read-only property instead of a method. This now
   properly matches the ``IOBase`` API and allows instances to be used in more
   places that accept ``IOBase`` instances.
 
 0.10.0 (released 2018-10-08)
 ============================
 
 Backwards Compatibility Notes
 -----------------------------
 
 * ``ZstdDecompressor.stream_reader().read()`` now consistently requires an
   argument in both the C and CFFI backends. Before, the CFFI implementation
   would assume a default value of ``-1``, which was later rejected.
 * The ``compress_literals`` argument and attribute has been removed from
   ``zstd.ZstdCompressionParameters`` because it was removed by the zstd 1.3.5
   API.
 * ``ZSTD_CCtx_setParametersUsingCCtxParams()`` is no longer called on every
   operation performed against ``ZstdCompressor`` instances. The reason for this
   change is that the zstd 1.3.5 API no longer allows this without calling
   ``ZSTD_CCtx_resetParameters()`` first. But if we called
   ``ZSTD_CCtx_resetParameters()`` on every operation, we'd have to redo
   potentially expensive setup when using dictionaries. We now call
   ``ZSTD_CCtx_reset()`` on every operation and don't attempt to change
   compression parameters.
 * Objects returned by ``ZstdCompressor.stream_reader()`` no longer need to be
   used as a context manager. The context manager interface still exists and its
   behavior is unchanged.
 * Objects returned by ``ZstdDecompressor.stream_reader()`` no longer need to be
   used as a context manager. The context manager interface still exists and its
   behavior is unchanged.
 
 Bug Fixes
 ---------
 
 * ``ZstdDecompressor.decompressobj().decompress()`` should now return all data
   from internal buffers in more scenarios. Before, it was possible for data to
   remain in internal buffers. This data would be emitted on a subsequent call
   to ``decompress()``. The overall output stream would still be valid. But if
   callers were expecting input data to exactly map to output data (say the
   producer had used ``flush(COMPRESSOBJ_FLUSH_BLOCK)`` and was attempting to
   map input chunks to output chunks), then the previous behavior would be
   wrong. The new behavior is such that output from
   ``flush(COMPRESSOBJ_FLUSH_BLOCK)`` fed into ``decompressobj().decompress()``
   should produce all available compressed input.
 * ``ZstdDecompressor.stream_reader().read()`` should no longer segfault after
   a previous context manager resulted in error (#56).
 * ``ZstdCompressor.compressobj().flush(COMPRESSOBJ_FLUSH_BLOCK)`` now returns
   all data necessary to flush a block. Before, it was possible for the
   ``flush()`` to not emit all data necessary to fully represent a block. This
   would mean decompressors wouldn't be able to decompress all data that had been
   fed into the compressor and ``flush()``ed. (#55).
 
 New Features
 ------------
 
 * New module constants ``BLOCKSIZELOG_MAX``, ``BLOCKSIZE_MAX``,
   ``TARGETLENGTH_MAX`` that expose constants from libzstd.
 * New ``ZstdCompressor.chunker()`` API for manually feeding data into a
   compressor and emitting chunks of a fixed size. Like ``compressobj()``, the
   API doesn't impose restrictions on the input or output types for the
   data streams. Unlike ``compressobj()``, it ensures output chunks are of a
   fixed size. This makes this API useful when the compressed output is being
   fed into an I/O layer, where uniform write sizes are useful.
 * ``ZstdCompressor.stream_reader()`` no longer needs to be used as a context
   manager (#34).
 * ``ZstdDecompressor.stream_reader()`` no longer needs to be used as a context
   manager (#34).
 * Bundled zstandard library upgraded from 1.3.4 to 1.3.6.
 
 Changes
 -------
 
 * Added ``zstd_cffi.py`` and ``NEWS.rst`` to ``MANIFEST.in``.
 * ``zstandard.__version__`` is now defined (#50).
 * Upgrade pip, setuptools, wheel, and cibuildwheel packages to latest versions.
 * Upgrade various packages used in CI to latest versions. Notably tox (in
   order to support Python 3.7).
 * Use relative paths in setup.py to appease Python 3.7 (#51).
 * Added CI for Python 3.7.
 
 0.9.1 (released 2018-06-04)
 ===========================
 
 * Debian packaging support.
 * Fix typo in setup.py (#44).
 * Support building with mingw compiler (#46).
 
 0.9.0 (released 2018-04-08)
 ===========================
 
 Backwards Compatibility Notes
 -----------------------------
 
 * CFFI 1.11 or newer is now required (previous requirement was 1.8).
 * The primary module is now ``zstandard``. Please change imports of ``zstd``
   and ``zstd_cffi`` to ``import zstandard``. See the README for more. Support
   for importing the old names will be dropped in the next release.
 * ``ZstdCompressor.read_from()`` and ``ZstdDecompressor.read_from()`` have
   been renamed to ``read_to_iter()``. ``read_from()`` is aliased to the new
   name and will be deleted in a future release.
 * Support for Python 2.6 has been removed.
 * Support for Python 3.3 has been removed.
 * The ``selectivity`` argument to ``train_dictionary()`` has been removed, as
   the feature disappeared from zstd 1.3.
 * Support for legacy dictionaries has been removed. Cover dictionaries are now
   the default. ``train_cover_dictionary()`` has effectively been renamed to
   ``train_dictionary()``.
 * The ``allow_empty`` argument from ``ZstdCompressor.compress()`` has been
   deleted and the method now allows empty inputs to be compressed by default.
 * ``estimate_compression_context_size()`` has been removed. Use
   ``CompressionParameters.estimated_compression_context_size()`` instead.
 * ``get_compression_parameters()`` has been removed. Use
   ``CompressionParameters.from_level()`` instead.
 * The arguments to ``CompressionParameters.__init__()`` have changed. If you
   were using positional arguments before, the positions now map to different
   arguments. It is recommended to use keyword arguments to construct
   ``CompressionParameters`` instances.
 * ``TARGETLENGTH_MAX`` constant has been removed (it disappeared from zstandard
   1.3.4).
 * ``ZstdCompressor.write_to()`` and ``ZstdDecompressor.write_to()`` have been
   renamed to ``ZstdCompressor.stream_writer()`` and
   ``ZstdDecompressor.stream_writer()``, respectively. The old names are still
   aliased, but will be removed in the next major release.
 * Content sizes are written into frame headers by default
   (``ZstdCompressor(write_content_size=True)`` is now the default).
 * ``CompressionParameters`` has been renamed to ``ZstdCompressionParameters``
   for consistency with other types. The old name is an alias and will be removed
   in the next major release.
 
 Bug Fixes
 ---------
 
 * Fixed memory leak in ``ZstdCompressor.copy_stream()`` (#40) (from 0.8.2).
 * Fixed memory leak in ``ZstdDecompressor.copy_stream()`` (#35) (from 0.8.2).
 * Fixed memory leak of ``ZSTD_DDict`` instances in CFFI's ``ZstdDecompressor``.
 
 New Features
 ------------
 
 * Bundled zstandard library upgraded from 1.1.3 to 1.3.4. This delivers various
   bug fixes and performance improvements. It also gives us access to newer
   features.
 * Support for negative compression levels.
 * Support for *long distance matching* (facilitates compression ratios that approach
   LZMA).
 * Supporting for reading empty zstandard frames (with an embedded content size
   of 0).
 * Support for writing and partial support for reading zstandard frames without a
   magic header.
 * New ``stream_reader()`` API that exposes the ``io.RawIOBase`` interface (allows
   you to ``.read()`` from a file-like object).
 * Several minor features, bug fixes, and performance enhancements.
 * Wheels for Linux and macOS are now provided with releases.
 
 Changes
 -------
 
 * Functions accepting bytes data now use the buffer protocol and can accept
   more types (like ``memoryview`` and ``bytearray``) (#26).
 * Add #includes so compilation on OS X and BSDs works (#20).
 * New ``ZstdDecompressor.stream_reader()`` API to obtain a read-only i/o stream
   of decompressed data for a source.
 * New ``ZstdCompressor.stream_reader()`` API to obtain a read-only i/o stream of
   compressed data for a source.
 * Renamed ``ZstdDecompressor.read_from()`` to ``ZstdDecompressor.read_to_iter()``.
   The old name is still available.
 * Renamed ``ZstdCompressor.read_from()`` to ``ZstdCompressor.read_to_iter()``.
   ``read_from()`` is still available at its old location.
 * Introduce the ``zstandard`` module to import and re-export the C or CFFI
   *backend* as appropriate. Behavior can be controlled via the
   ``PYTHON_ZSTANDARD_IMPORT_POLICY`` environment variable. See README for
   usage info.
 * Vendored version of zstd upgraded to 1.3.4.
 * Added module constants ``CONTENTSIZE_UNKNOWN`` and ``CONTENTSIZE_ERROR``.
 * Add ``STRATEGY_BTULTRA`` compression strategy constant.
 * Switch from deprecated ``ZSTD_getDecompressedSize()`` to
   ``ZSTD_getFrameContentSize()`` replacement.
 * ``ZstdCompressor.compress()`` can now compress empty inputs without requiring
   special handling.
 * ``ZstdCompressor`` and ``ZstdDecompressor`` now have a ``memory_size()``
   method for determining the current memory utilization of the underlying zstd
   primitive.
 * ``train_dictionary()`` has new arguments and functionality for trying multiple
   variations of COVER parameters and selecting the best one.
 * Added module constants ``LDM_MINMATCH_MIN``, ``LDM_MINMATCH_MAX``, and
   ``LDM_BUCKETSIZELOG_MAX``.
 * Converted all consumers to the zstandard *new advanced API*, which uses
   ``ZSTD_compress_generic()``
 * ``CompressionParameters.__init__`` now accepts several more arguments,
   including support for *long distance matching*.
 * ``ZstdCompressionDict.__init__`` now accepts a ``dict_type`` argument that
   controls how the dictionary should be interpreted. This can be used to
   force the use of *content-only* dictionaries or to require the presence
   of the dictionary magic header.
 * ``ZstdCompressionDict.precompute_compress()`` can be used to precompute the
   compression dictionary so it can efficiently be used with multiple
   ``ZstdCompressor`` instances.
 * Digested dictionaries are now stored in ``ZstdCompressionDict`` instances,
   created automatically on first use, and automatically reused by all
   ``ZstdDecompressor`` instances bound to that dictionary.
 * All meaningful functions now accept keyword arguments.
 * ``ZstdDecompressor.decompressobj()`` now accepts a ``write_size`` argument
   to control how much work to perform on every decompressor invocation.
 * ``ZstdCompressor.write_to()`` now exposes a ``tell()``, which exposes the
   total number of bytes written so far.
 * ``ZstdDecompressor.stream_reader()`` now supports ``seek()`` when moving
   forward in the stream.
 * Removed ``TARGETLENGTH_MAX`` constant.
 * Added ``frame_header_size(data)`` function.
 * Added ``frame_content_size(data)`` function.
 * Consumers of ``ZSTD_decompress*`` have been switched to the new *advanced
   decompression* API.
 * ``ZstdCompressor`` and ``ZstdCompressionParams`` can now be constructed with
   negative compression levels.
 * ``ZstdDecompressor`` now accepts a ``max_window_size`` argument to limit the
   amount of memory required for decompression operations.
 * ``FORMAT_ZSTD1`` and ``FORMAT_ZSTD1_MAGICLESS`` constants to be used with
   the ``format`` compression parameter to control whether the frame magic
   header is written.
 * ``ZstdDecompressor`` now accepts a ``format`` argument to control the
   expected frame format.
 * ``ZstdCompressor`` now has a ``frame_progression()`` method to return
   information about the current compression operation.
 * Error messages in CFFI no longer have ``b''`` literals.
 * Compiler warnings and underlying overflow issues on 32-bit platforms have been
   fixed.
 * Builds in CI now build with compiler warnings as errors. This should hopefully
   fix new compiler warnings from being introduced.
 * Make ``ZstdCompressor(write_content_size=True)`` and
   ``CompressionParameters(write_content_size=True)`` the default.
 * ``CompressionParameters`` has been renamed to ``ZstdCompressionParameters``.
 
 0.8.2 (released 2018-02-22)
 ---------------------------
 
 * Fixed memory leak in ``ZstdCompressor.copy_stream()`` (#40).
 * Fixed memory leak in ``ZstdDecompressor.copy_stream()`` (#35).
 
 0.8.1 (released 2017-04-08)
 ---------------------------
 
 * Add #includes so compilation on OS X and BSDs works (#20).
 
 0.8.0 (released 2017-03-08)
 ===========================
 
 * CompressionParameters now has a estimated_compression_context_size() method.
   zstd.estimate_compression_context_size() is now deprecated and slated for
   removal.
 * Implemented a lot of fuzzing tests.
 * CompressionParameters instances now perform extra validation by calling
   ZSTD_checkCParams() at construction time.
 * multi_compress_to_buffer() API for compressing multiple inputs as a
   single operation, as efficiently as possible.
 * ZSTD_CStream instances are now used across multiple operations on
   ZstdCompressor instances, resulting in much better performance for
   APIs that do streaming.
 * ZSTD_DStream instances are now used across multiple operations on
   ZstdDecompressor instances, resulting in much better performance for
   APIs that do streaming.
 * train_dictionary() now releases the GIL.
 * Support for training dictionaries using the COVER algorithm.
 * multi_decompress_to_buffer() API for decompressing multiple frames as a
   single operation, as efficiently as possible.
 * Support for multi-threaded compression.
 * Disable deprecation warnings when compiling CFFI module.
 * Fixed memory leak in train_dictionary().
 * Removed DictParameters type.
 * train_dictionary() now accepts keyword arguments instead of a
   DictParameters instance to control dictionary generation.
 
 0.7.0 (released 2017-02-07)
 ===========================
 
 * Added zstd.get_frame_parameters() to obtain info about a zstd frame.
 * Added ZstdDecompressor.decompress_content_dict_chain() for efficient
   decompression of *content-only dictionary chains*.
 * CFFI module fully implemented; all tests run against both C extension and
   CFFI implementation.
 * Vendored version of zstd updated to 1.1.3.
 * Use ZstdDecompressor.decompress() now uses ZSTD_createDDict_byReference()
   to avoid extra memory allocation of dict data.
 * Add function names to error messages (by using ":name" in PyArg_Parse*
   functions).
 * Reuse decompression context across operations. Previously, we created a
   new ZSTD_DCtx for each decompress(). This was measured to slow down
   decompression by 40-200MB/s. The API guarantees say ZstdDecompressor
   is not thread safe. So we reuse the ZSTD_DCtx across operations and make
   things faster in the process.
 * ZstdCompressor.write_to()'s compress() and flush() methods now return number
   of bytes written.
 * ZstdDecompressor.write_to()'s write() method now returns the number of bytes
   written to the underlying output object.
 * CompressionParameters instances now expose their values as attributes.
 * CompressionParameters instances no longer are subscriptable nor behave
   as tuples (backwards incompatible). Use attributes to obtain values.
 * DictParameters instances now expose their values as attributes.
 
 0.6.0 (released 2017-01-14)
 ===========================
 
 * Support for legacy zstd protocols (build time opt in feature).
 * Automation improvements to test against Python 3.6, latest versions
   of Tox, more deterministic AppVeyor behavior.
 * CFFI "parser" improved to use a compiler preprocessor instead of rewriting
   source code manually.
 * Vendored version of zstd updated to 1.1.2.
 * Documentation improvements.
 * Introduce a bench.py script for performing (crude) benchmarks.
 * ZSTD_CCtx instances are now reused across multiple compress() operations.
 * ZstdCompressor.write_to() now has a flush() method.
 * ZstdCompressor.compressobj()'s flush() method now accepts an argument to
   flush a block (as opposed to ending the stream).
 * Disallow compress(b'') when writing content sizes by default (issue #11).
 
 0.5.2 (released 2016-11-12)
 ===========================
 
 * more packaging fixes for source distribution
 
 0.5.1 (released 2016-11-12)
 ===========================
 
 * setup_zstd.py is included in the source distribution
 
 0.5.0 (released 2016-11-10)
 ===========================
 
 * Vendored version of zstd updated to 1.1.1.
 * Continuous integration for Python 3.6 and 3.7
 * Continuous integration for Conda
 * Added compression and decompression APIs providing similar interfaces
   to the standard library ``zlib`` and ``bz2`` modules. This allows
   coding to a common interface.
 * ``zstd.__version__` is now defined.
 * ``read_from()`` on various APIs now accepts objects implementing the buffer
   protocol.
 * ``read_from()`` has gained a ``skip_bytes`` argument. This allows callers
   to pass in an existing buffer with a header without having to create a
   slice or a new object.
 * Implemented ``ZstdCompressionDict.as_bytes()``.
 * Python's memory allocator is now used instead of ``malloc()``.
 * Low-level zstd data structures are reused in more instances, cutting down
   on overhead for certain operations.
 * ``distutils`` boilerplate for obtaining an ``Extension`` instance
   has now been refactored into a standalone ``setup_zstd.py`` file. This
   allows other projects with ``setup.py`` files to reuse the
   ``distutils`` code for this project without copying code.
 * The monolithic ``zstd.c`` file has been split into a header file defining
   types and separate ``.c`` source files for the implementation.
 
 Older History
 =============
 
 2016-08-31 - Zstandard 1.0.0 is released and Gregory starts hacking on a
 Python extension for use by the Mercurial project. A very hacky prototype
 is sent to the mercurial-devel list for RFC.
 
 2016-09-03 - Most functionality from Zstandard C API implemented. Source
 code published on https://github.com/indygreg/python-zstandard. Travis-CI
 automation configured. 0.0.1 release on PyPI.
 
 2016-09-05 - After the API was rounded out a bit and support for Python
 2.6 and 2.7 was added, version 0.1 was released to PyPI.
 
 2016-09-05 - After the compressor and decompressor APIs were changed, 0.2
 was released to PyPI.
 
 2016-09-10 - 0.3 is released with a bunch of new features. ZstdCompressor
 now accepts arguments controlling frame parameters. The source size can now
 be declared when performing streaming compression. ZstdDecompressor.decompress()
 is implemented. Compression dictionaries are now cached when using the simple
 compression and decompression APIs. Memory size APIs added.
 ZstdCompressor.read_from() and ZstdDecompressor.read_from() have been
 implemented. This rounds out the major compression/decompression APIs planned
 by the author.
 
 2016-10-02 - 0.3.3 is released with a bug fix for read_from not fully
 decoding a zstd frame (issue #2).
 
 2016-10-02 - 0.4.0 is released with zstd 1.1.0, support for custom read and
 write buffer sizes, and a few bug fixes involving failure to read/write
 all data when buffer sizes were too small to hold remaining data.
 
 2016-11-10 - 0.5.0 is released with zstd 1.1.1 and other enhancements.

contrib/python-zstandard/README.rst

@@ -1,1602 +1,1602 b''
 ================
 python-zstandard
 ================
 
 This project provides Python bindings for interfacing with the
 `Zstandard <http://www.zstd.net>`_ compression library. A C extension
 and CFFI interface are provided.
 
 The primary goal of the project is to provide a rich interface to the
 underlying C API through a Pythonic interface while not sacrificing
 performance. This means exposing most of the features and flexibility
 of the C API while not sacrificing usability or safety that Python provides.
 
 The canonical home for this project lives in a Mercurial repository run by
 the author. For convenience, that repository is frequently synchronized to
 https://github.com/indygreg/python-zstandard.
 
 |  |ci-status|
 
 Requirements
 ============
 
-This extension is designed to run with Python 2.7, 3.4, 3.5, 3.6, and 3.7
+This extension is designed to run with Python 2.7, 3.5, 3.6, 3.7, and 3.8
 on common platforms (Linux, Windows, and OS X). On PyPy (both PyPy2 and PyPy3) we support version 6.0.0 and above. 
 x86 and x86_64 are well-tested on Windows. Only x86_64 is well-tested on Linux and macOS.
 
 Installing
 ==========
 
 This package is uploaded to PyPI at https://pypi.python.org/pypi/zstandard.
 So, to install this package::
 
    $ pip install zstandard
 
 Binary wheels are made available for some platforms. If you need to
 install from a source distribution, all you should need is a working C
 compiler and the Python development headers/libraries. On many Linux
 distributions, you can install a ``python-dev`` or ``python-devel``
 package to provide these dependencies.
 
 Packages are also uploaded to Anaconda Cloud at
 https://anaconda.org/indygreg/zstandard. See that URL for how to install
 this package with ``conda``.
 
 Performance
 ===========
 
 zstandard is a highly tunable compression algorithm. In its default settings
 (compression level 3), it will be faster at compression and decompression and
 will have better compression ratios than zlib on most data sets. When tuned
 for speed, it approaches lz4's speed and ratios. When tuned for compression
 ratio, it approaches lzma ratios and compression speed, but decompression
 speed is much faster. See the official zstandard documentation for more.
 
 zstandard and this library support multi-threaded compression. There is a
 mechanism to compress large inputs using multiple threads.
 
 The performance of this library is usually very similar to what the zstandard
 C API can deliver. Overhead in this library is due to general Python overhead
 and can't easily be avoided by *any* zstandard Python binding. This library
 exposes multiple APIs for performing compression and decompression so callers
 can pick an API suitable for their need. Contrast with the compression
 modules in Python's standard library (like ``zlib``), which only offer limited
 mechanisms for performing operations. The API flexibility means consumers can
 choose to use APIs that facilitate zero copying or minimize Python object
 creation and garbage collection overhead.
 
 This library is capable of single-threaded throughputs well over 1 GB/s. For
 exact numbers, measure yourself. The source code repository has a ``bench.py``
 script that can be used to measure things.
 
 API
 ===
 
 To interface with Zstandard, simply import the ``zstandard`` module::
 
    import zstandard
 
 It is a popular convention to alias the module as a different name for
 brevity::
 
    import zstandard as zstd
 
 This module attempts to import and use either the C extension or CFFI
 implementation. On Python platforms known to support C extensions (like
 CPython), it raises an ImportError if the C extension cannot be imported.
 On Python platforms known to not support C extensions (like PyPy), it only
 attempts to import the CFFI implementation and raises ImportError if that
 can't be done. On other platforms, it first tries to import the C extension
 then falls back to CFFI if that fails and raises ImportError if CFFI fails.
 
 To change the module import behavior, a ``PYTHON_ZSTANDARD_IMPORT_POLICY``
 environment variable can be set. The following values are accepted:
 
 default
    The behavior described above.
 cffi_fallback
    Always try to import the C extension then fall back to CFFI if that
    fails.
 cext
    Only attempt to import the C extension.
 cffi
    Only attempt to import the CFFI implementation.
 
 In addition, the ``zstandard`` module exports a ``backend`` attribute
 containing the string name of the backend being used. It will be one
 of ``cext`` or ``cffi`` (for *C extension* and *cffi*, respectively).
 
 The types, functions, and attributes exposed by the ``zstandard`` module
 are documented in the sections below.
 
 .. note::
 
    The documentation in this section makes references to various zstd
    concepts and functionality. The source repository contains a
    ``docs/concepts.rst`` file explaining these in more detail.
 
 ZstdCompressor
 --------------
 
 The ``ZstdCompressor`` class provides an interface for performing
 compression operations. Each instance is essentially a wrapper around a
 ``ZSTD_CCtx`` from the C API.
 
 Each instance is associated with parameters that control compression
 behavior. These come from the following named arguments (all optional):
 
 level
    Integer compression level. Valid values are between 1 and 22.
 dict_data
    Compression dictionary to use.
 
    Note: When using dictionary data and ``compress()`` is called multiple
    times, the ``ZstdCompressionParameters`` derived from an integer
    compression ``level`` and the first compressed data's size will be reused
    for all subsequent operations. This may not be desirable if source data
    size varies significantly.
 compression_params
    A ``ZstdCompressionParameters`` instance defining compression settings.
 write_checksum
    Whether a 4 byte checksum should be written with the compressed data.
    Defaults to False. If True, the decompressor can verify that decompressed
    data matches the original input data.
 write_content_size
    Whether the size of the uncompressed data will be written into the
    header of compressed data. Defaults to True. The data will only be
    written if the compressor knows the size of the input data. This is
    often not true for streaming compression.
 write_dict_id
    Whether to write the dictionary ID into the compressed data.
    Defaults to True. The dictionary ID is only written if a dictionary
    is being used.
 threads
    Enables and sets the number of threads to use for multi-threaded compression
    operations. Defaults to 0, which means to use single-threaded compression.
    Negative values will resolve to the number of logical CPUs in the system.
    Read below for more info on multi-threaded compression. This argument only
    controls thread count for operations that operate on individual pieces of
    data. APIs that spawn multiple threads for working on multiple pieces of
    data have their own ``threads`` argument.
 
 ``compression_params`` is mutually exclusive with ``level``, ``write_checksum``,
 ``write_content_size``, ``write_dict_id``, and ``threads``.
 
 Unless specified otherwise, assume that no two methods of ``ZstdCompressor``
 instances can be called from multiple Python threads simultaneously. In other
 words, assume instances are not thread safe unless stated otherwise.
 
 Utility Methods
 ^^^^^^^^^^^^^^^
 
 ``frame_progression()`` returns a 3-tuple containing the number of bytes
 ingested, consumed, and produced by the current compression operation.
 
 ``memory_size()`` obtains the memory utilization of the underlying zstd
 compression context, in bytes.::
 
     cctx = zstd.ZstdCompressor()
     memory = cctx.memory_size()
 
 Simple API
 ^^^^^^^^^^
 
 ``compress(data)`` compresses and returns data as a one-shot operation.::
 
    cctx = zstd.ZstdCompressor()
    compressed = cctx.compress(b'data to compress')
 
 The ``data`` argument can be any object that implements the *buffer protocol*.
 
 Stream Reader API
 ^^^^^^^^^^^^^^^^^
 
 ``stream_reader(source)`` can be used to obtain an object conforming to the
 ``io.RawIOBase`` interface for reading compressed output as a stream::
 
    with open(path, 'rb') as fh:
        cctx = zstd.ZstdCompressor()
        reader = cctx.stream_reader(fh)
        while True:
            chunk = reader.read(16384)
            if not chunk:
                break
 
            # Do something with compressed chunk.
 
 Instances can also be used as context managers::
 
    with open(path, 'rb') as fh:
        with cctx.stream_reader(fh) as reader:
            while True:
                chunk = reader.read(16384)
                if not chunk:
                    break
 
                # Do something with compressed chunk.
 
 When the context manager exits or ``close()`` is called, the stream is closed,
 underlying resources are released, and future operations against the compression
 stream will fail.
 
 The ``source`` argument to ``stream_reader()`` can be any object with a
 ``read(size)`` method or any object implementing the *buffer protocol*.
 
 ``stream_reader()`` accepts a ``size`` argument specifying how large the input
 stream is. This is used to adjust compression parameters so they are
 tailored to the source size.::
 
    with open(path, 'rb') as fh:
        cctx = zstd.ZstdCompressor()
        with cctx.stream_reader(fh, size=os.stat(path).st_size) as reader:
            ...
 
 If the ``source`` is a stream, you can specify how large ``read()`` requests
 to that stream should be via the ``read_size`` argument. It defaults to
 ``zstandard.COMPRESSION_RECOMMENDED_INPUT_SIZE``.::
 
    with open(path, 'rb') as fh:
        cctx = zstd.ZstdCompressor()
        # Will perform fh.read(8192) when obtaining data to feed into the
        # compressor.
        with cctx.stream_reader(fh, read_size=8192) as reader:
            ...
 
 The stream returned by ``stream_reader()`` is neither writable nor seekable
 (even if the underlying source is seekable). ``readline()`` and
 ``readlines()`` are not implemented because they don't make sense for
 compressed data. ``tell()`` returns the number of compressed bytes
 emitted so far.
 
 Streaming Input API
 ^^^^^^^^^^^^^^^^^^^
 
 ``stream_writer(fh)`` allows you to *stream* data into a compressor.
 
 Returned instances implement the ``io.RawIOBase`` interface. Only methods
 that involve writing will do useful things.
 
 The argument to ``stream_writer()`` must have a ``write(data)`` method. As
 compressed data is available, ``write()`` will be called with the compressed
 data as its argument. Many common Python types implement ``write()``, including
 open file handles and ``io.BytesIO``.
 
 The ``write(data)`` method is used to feed data into the compressor.
 
 The ``flush([flush_mode=FLUSH_BLOCK])`` method can be called to evict whatever
 data remains within the compressor's internal state into the output object. This
 may result in 0 or more ``write()`` calls to the output object. This method
 accepts an optional ``flush_mode`` argument to control the flushing behavior.
 Its value can be any of the ``FLUSH_*`` constants.
 
 Both ``write()`` and ``flush()`` return the number of bytes written to the
 object's ``write()``. In many cases, small inputs do not accumulate enough
 data to cause a write and ``write()`` will return ``0``.
 
 Calling ``close()`` will mark the stream as closed and subsequent I/O
 operations will raise ``ValueError`` (per the documented behavior of
 ``io.RawIOBase``). ``close()`` will also call ``close()`` on the underlying
 stream if such a method exists.
 
 Typically usage is as follows::
 
    cctx = zstd.ZstdCompressor(level=10)
    compressor = cctx.stream_writer(fh)
 
    compressor.write(b'chunk 0\n')
    compressor.write(b'chunk 1\n')
    compressor.flush()
    # Receiver will be able to decode ``chunk 0\nchunk 1\n`` at this point.
    # Receiver is also expecting more data in the zstd *frame*.
 
    compressor.write(b'chunk 2\n')
    compressor.flush(zstd.FLUSH_FRAME)
    # Receiver will be able to decode ``chunk 0\nchunk 1\nchunk 2``.
    # Receiver is expecting no more data, as the zstd frame is closed.
    # Any future calls to ``write()`` at this point will construct a new
    # zstd frame.
 
 Instances can be used as context managers. Exiting the context manager is
 the equivalent of calling ``close()``, which is equivalent to calling
 ``flush(zstd.FLUSH_FRAME)``::
 
    cctx = zstd.ZstdCompressor(level=10)
    with cctx.stream_writer(fh) as compressor:
        compressor.write(b'chunk 0')
        compressor.write(b'chunk 1')
        ...
 
 .. important::
 
    If ``flush(FLUSH_FRAME)`` is not called, emitted data doesn't constitute
    a full zstd *frame* and consumers of this data may complain about malformed
    input. It is recommended to use instances as a context manager to ensure
    *frames* are properly finished.
 
 If the size of the data being fed to this streaming compressor is known,
 you can declare it before compression begins::
 
    cctx = zstd.ZstdCompressor()
    with cctx.stream_writer(fh, size=data_len) as compressor:
        compressor.write(chunk0)
        compressor.write(chunk1)
        ...
 
 Declaring the size of the source data allows compression parameters to
 be tuned. And if ``write_content_size`` is used, it also results in the
 content size being written into the frame header of the output data.
 
 The size of chunks being ``write()`` to the destination can be specified::
 
     cctx = zstd.ZstdCompressor()
     with cctx.stream_writer(fh, write_size=32768) as compressor:
         ...
 
 To see how much memory is being used by the streaming compressor::
 
     cctx = zstd.ZstdCompressor()
     with cctx.stream_writer(fh) as compressor:
         ...
         byte_size = compressor.memory_size()
 
 Thte total number of bytes written so far are exposed via ``tell()``::
 
     cctx = zstd.ZstdCompressor()
     with cctx.stream_writer(fh) as compressor:
         ...
         total_written = compressor.tell()
 
 ``stream_writer()`` accepts a ``write_return_read`` boolean argument to control
 the return value of ``write()``. When ``False`` (the default), ``write()`` returns
 the number of bytes that were ``write()``en to the underlying object. When
 ``True``, ``write()`` returns the number of bytes read from the input that
 were subsequently written to the compressor. ``True`` is the *proper* behavior
 for ``write()`` as specified by the ``io.RawIOBase`` interface and will become
 the default value in a future release.
 
 Streaming Output API
 ^^^^^^^^^^^^^^^^^^^^
 
 ``read_to_iter(reader)`` provides a mechanism to stream data out of a
 compressor as an iterator of data chunks.::
 
    cctx = zstd.ZstdCompressor()
    for chunk in cctx.read_to_iter(fh):
         # Do something with emitted data.
 
 ``read_to_iter()`` accepts an object that has a ``read(size)`` method or
 conforms to the buffer protocol.
 
 Uncompressed data is fetched from the source either by calling ``read(size)``
 or by fetching a slice of data from the object directly (in the case where
 the buffer protocol is being used). The returned iterator consists of chunks
 of compressed data.
 
 If reading from the source via ``read()``, ``read()`` will be called until
 it raises or returns an empty bytes (``b''``). It is perfectly valid for
 the source to deliver fewer bytes than were what requested by ``read(size)``.
 
 Like ``stream_writer()``, ``read_to_iter()`` also accepts a ``size`` argument
 declaring the size of the input stream::
 
     cctx = zstd.ZstdCompressor()
     for chunk in cctx.read_to_iter(fh, size=some_int):
         pass
 
 You can also control the size that data is ``read()`` from the source and
 the ideal size of output chunks::
 
     cctx = zstd.ZstdCompressor()
     for chunk in cctx.read_to_iter(fh, read_size=16384, write_size=8192):
         pass
 
 Unlike ``stream_writer()``, ``read_to_iter()`` does not give direct control
 over the sizes of chunks fed into the compressor. Instead, chunk sizes will
 be whatever the object being read from delivers. These will often be of a
 uniform size.
 
 Stream Copying API
 ^^^^^^^^^^^^^^^^^^
 
 ``copy_stream(ifh, ofh)`` can be used to copy data between 2 streams while
 compressing it.::
 
    cctx = zstd.ZstdCompressor()
    cctx.copy_stream(ifh, ofh)
 
 For example, say you wish to compress a file::
 
    cctx = zstd.ZstdCompressor()
    with open(input_path, 'rb') as ifh, open(output_path, 'wb') as ofh:
        cctx.copy_stream(ifh, ofh)
 
 It is also possible to declare the size of the source stream::
 
    cctx = zstd.ZstdCompressor()
    cctx.copy_stream(ifh, ofh, size=len_of_input)
 
 You can also specify how large the chunks that are ``read()`` and ``write()``
 from and to the streams::
 
    cctx = zstd.ZstdCompressor()
    cctx.copy_stream(ifh, ofh, read_size=32768, write_size=16384)
 
 The stream copier returns a 2-tuple of bytes read and written::
 
    cctx = zstd.ZstdCompressor()
    read_count, write_count = cctx.copy_stream(ifh, ofh)
 
 Compressor API
 ^^^^^^^^^^^^^^
 
 ``compressobj()`` returns an object that exposes ``compress(data)`` and
 ``flush()`` methods. Each returns compressed data or an empty bytes.
 
 The purpose of ``compressobj()`` is to provide an API-compatible interface
 with ``zlib.compressobj``, ``bz2.BZ2Compressor``, etc. This allows callers to
 swap in different compressor objects while using the same API.
 
 ``flush()`` accepts an optional argument indicating how to end the stream.
 ``zstd.COMPRESSOBJ_FLUSH_FINISH`` (the default) ends the compression stream.
 Once this type of flush is performed, ``compress()`` and ``flush()`` can
 no longer be called. This type of flush **must** be called to end the
 compression context. If not called, returned data may be incomplete.
 
 A ``zstd.COMPRESSOBJ_FLUSH_BLOCK`` argument to ``flush()`` will flush a
 zstd block. Flushes of this type can be performed multiple times. The next
 call to ``compress()`` will begin a new zstd block.
 
 Here is how this API should be used::
 
    cctx = zstd.ZstdCompressor()
    cobj = cctx.compressobj()
    data = cobj.compress(b'raw input 0')
    data = cobj.compress(b'raw input 1')
    data = cobj.flush()
 
 Or to flush blocks::
 
    cctx.zstd.ZstdCompressor()
    cobj = cctx.compressobj()
    data = cobj.compress(b'chunk in first block')
    data = cobj.flush(zstd.COMPRESSOBJ_FLUSH_BLOCK)
    data = cobj.compress(b'chunk in second block')
    data = cobj.flush()
 
 For best performance results, keep input chunks under 256KB. This avoids
 extra allocations for a large output object.
 
 It is possible to declare the input size of the data that will be fed into
 the compressor::
 
    cctx = zstd.ZstdCompressor()
    cobj = cctx.compressobj(size=6)
    data = cobj.compress(b'foobar')
    data = cobj.flush()
 
 Chunker API
 ^^^^^^^^^^^
 
 ``chunker(size=None, chunk_size=COMPRESSION_RECOMMENDED_OUTPUT_SIZE)`` returns
 an object that can be used to iteratively feed chunks of data into a compressor
 and produce output chunks of a uniform size.
 
 The object returned by ``chunker()`` exposes the following methods:
 
 ``compress(data)``
    Feeds new input data into the compressor.
 
 ``flush()``
    Flushes all data currently in the compressor.
 
 ``finish()``
    Signals the end of input data. No new data can be compressed after this
    method is called.
 
 ``compress()``, ``flush()``, and ``finish()`` all return an iterator of
 ``bytes`` instances holding compressed data. The iterator may be empty. Callers
 MUST iterate through all elements of the returned iterator before performing
 another operation on the object.
 
 All chunks emitted by ``compress()`` will have a length of ``chunk_size``.
 
 ``flush()`` and ``finish()`` may return a final chunk smaller than
 ``chunk_size``.
 
 Here is how the API should be used::
 
    cctx = zstd.ZstdCompressor()
    chunker = cctx.chunker(chunk_size=32768)
 
    with open(path, 'rb') as fh:
        while True:
            in_chunk = fh.read(32768)
            if not in_chunk:
                break
 
            for out_chunk in chunker.compress(in_chunk):
                # Do something with output chunk of size 32768.
 
        for out_chunk in chunker.finish():
            # Do something with output chunks that finalize the zstd frame.
 
 The ``chunker()`` API is often a better alternative to ``compressobj()``.
 
 ``compressobj()`` will emit output data as it is available. This results in a
 *stream* of output chunks of varying sizes. The consistency of the output chunk
 size with ``chunker()`` is more appropriate for many usages, such as sending
 compressed data to a socket.
 
 ``compressobj()`` may also perform extra memory reallocations in order to
 dynamically adjust the sizes of the output chunks. Since ``chunker()`` output
 chunks are all the same size (except for flushed or final chunks), there is
 less memory allocation overhead.
 
 Batch Compression API
 ^^^^^^^^^^^^^^^^^^^^^
 
 (Experimental. Not yet supported in CFFI bindings.)
 
 ``multi_compress_to_buffer(data, [threads=0])`` performs compression of multiple
 inputs as a single operation.
 
 Data to be compressed can be passed as a ``BufferWithSegmentsCollection``, a
 ``BufferWithSegments``, or a list containing byte like objects. Each element of
 the container will be compressed individually using the configured parameters
 on the ``ZstdCompressor`` instance.
 
 The ``threads`` argument controls how many threads to use for compression. The
 default is ``0`` which means to use a single thread. Negative values use the
 number of logical CPUs in the machine.
 
 The function returns a ``BufferWithSegmentsCollection``. This type represents
 N discrete memory allocations, eaching holding 1 or more compressed frames.
 
 Output data is written to shared memory buffers. This means that unlike
 regular Python objects, a reference to *any* object within the collection
 keeps the shared buffer and therefore memory backing it alive. This can have
 undesirable effects on process memory usage.
 
 The API and behavior of this function is experimental and will likely change.
 Known deficiencies include:
 
 * If asked to use multiple threads, it will always spawn that many threads,
   even if the input is too small to use them. It should automatically lower
   the thread count when the extra threads would just add overhead.
 * The buffer allocation strategy is fixed. There is room to make it dynamic,
   perhaps even to allow one output buffer per input, facilitating a variation
   of the API to return a list without the adverse effects of shared memory
   buffers.
 
 ZstdDecompressor
 ----------------
 
 The ``ZstdDecompressor`` class provides an interface for performing
 decompression. It is effectively a wrapper around the ``ZSTD_DCtx`` type from
 the C API.
 
 Each instance is associated with parameters that control decompression. These
 come from the following named arguments (all optional):
 
 dict_data
    Compression dictionary to use.
 max_window_size
    Sets an uppet limit on the window size for decompression operations in
    kibibytes. This setting can be used to prevent large memory allocations
    for inputs using large compression windows.
 format
    Set the format of data for the decoder. By default, this is
    ``zstd.FORMAT_ZSTD1``. It can be set to ``zstd.FORMAT_ZSTD1_MAGICLESS`` to
    allow decoding frames without the 4 byte magic header. Not all decompression
    APIs support this mode.
 
 The interface of this class is very similar to ``ZstdCompressor`` (by design).
 
 Unless specified otherwise, assume that no two methods of ``ZstdDecompressor``
 instances can be called from multiple Python threads simultaneously. In other
 words, assume instances are not thread safe unless stated otherwise.
 
 Utility Methods
 ^^^^^^^^^^^^^^^
 
 ``memory_size()`` obtains the size of the underlying zstd decompression context,
 in bytes.::
 
     dctx = zstd.ZstdDecompressor()
     size = dctx.memory_size()
 
 Simple API
 ^^^^^^^^^^
 
 ``decompress(data)`` can be used to decompress an entire compressed zstd
 frame in a single operation.::
 
     dctx = zstd.ZstdDecompressor()
     decompressed = dctx.decompress(data)
 
 By default, ``decompress(data)`` will only work on data written with the content
 size encoded in its header (this is the default behavior of
 ``ZstdCompressor().compress()`` but may not be true for streaming compression). If
 compressed data without an embedded content size is seen, ``zstd.ZstdError`` will
 be raised.
 
 If the compressed data doesn't have its content size embedded within it,
 decompression can be attempted by specifying the ``max_output_size``
 argument.::
 
     dctx = zstd.ZstdDecompressor()
     uncompressed = dctx.decompress(data, max_output_size=1048576)
 
 Ideally, ``max_output_size`` will be identical to the decompressed output
 size.
 
 If ``max_output_size`` is too small to hold the decompressed data,
 ``zstd.ZstdError`` will be raised.
 
 If ``max_output_size`` is larger than the decompressed data, the allocated
 output buffer will be resized to only use the space required.
 
 Please note that an allocation of the requested ``max_output_size`` will be
 performed every time the method is called. Setting to a very large value could
 result in a lot of work for the memory allocator and may result in
 ``MemoryError`` being raised if the allocation fails.
 
 .. important::
 
    If the exact size of decompressed data is unknown (not passed in explicitly
    and not stored in the zstandard frame), for performance reasons it is
    encouraged to use a streaming API.
 
 Stream Reader API
 ^^^^^^^^^^^^^^^^^
 
 ``stream_reader(source)`` can be used to obtain an object conforming to the
 ``io.RawIOBase`` interface for reading decompressed output as a stream::
 
    with open(path, 'rb') as fh:
        dctx = zstd.ZstdDecompressor()
        reader = dctx.stream_reader(fh)
        while True:
            chunk = reader.read(16384)
             if not chunk:
                 break
 
             # Do something with decompressed chunk.
 
 The stream can also be used as a context manager::
 
    with open(path, 'rb') as fh:
        dctx = zstd.ZstdDecompressor()
        with dctx.stream_reader(fh) as reader:
            ...
 
 When used as a context manager, the stream is closed and the underlying
 resources are released when the context manager exits. Future operations against
 the stream will fail.
 
 The ``source`` argument to ``stream_reader()`` can be any object with a
 ``read(size)`` method or any object implementing the *buffer protocol*.
 
 If the ``source`` is a stream, you can specify how large ``read()`` requests
 to that stream should be via the ``read_size`` argument. It defaults to
 ``zstandard.DECOMPRESSION_RECOMMENDED_INPUT_SIZE``.::
 
    with open(path, 'rb') as fh:
        dctx = zstd.ZstdDecompressor()
        # Will perform fh.read(8192) when obtaining data for the decompressor.
        with dctx.stream_reader(fh, read_size=8192) as reader:
            ...
 
 The stream returned by ``stream_reader()`` is not writable.
 
 The stream returned by ``stream_reader()`` is *partially* seekable.
 Absolute and relative positions (``SEEK_SET`` and ``SEEK_CUR``) forward
 of the current position are allowed. Offsets behind the current read
 position and offsets relative to the end of stream are not allowed and
 will raise ``ValueError`` if attempted.
 
 ``tell()`` returns the number of decompressed bytes read so far.
 
 Not all I/O methods are implemented. Notably missing is support for
 ``readline()``, ``readlines()``, and linewise iteration support. This is
 because streams operate on binary data - not text data. If you want to
 convert decompressed output to text, you can chain an ``io.TextIOWrapper``
 to the stream::
 
    with open(path, 'rb') as fh:
        dctx = zstd.ZstdDecompressor()
        stream_reader = dctx.stream_reader(fh)
        text_stream = io.TextIOWrapper(stream_reader, encoding='utf-8')
 
        for line in text_stream:
            ...
 
 The ``read_across_frames`` argument to ``stream_reader()`` controls the
 behavior of read operations when the end of a zstd *frame* is encountered.
 When ``False`` (the default), a read will complete when the end of a
 zstd *frame* is encountered. When ``True``, a read can potentially
 return data spanning multiple zstd *frames*.
 
 Streaming Input API
 ^^^^^^^^^^^^^^^^^^^
 
 ``stream_writer(fh)`` allows you to *stream* data into a decompressor.
 
 Returned instances implement the ``io.RawIOBase`` interface. Only methods
 that involve writing will do useful things.
 
 The argument to ``stream_writer()`` is typically an object that also implements
 ``io.RawIOBase``. But any object with a ``write(data)`` method will work. Many
 common Python types conform to this interface, including open file handles
 and ``io.BytesIO``.
 
 Behavior is similar to ``ZstdCompressor.stream_writer()``: compressed data
 is sent to the decompressor by calling ``write(data)`` and decompressed
 output is written to the underlying stream by calling its ``write(data)``
 method.::
 
     dctx = zstd.ZstdDecompressor()
     decompressor = dctx.stream_writer(fh)
 
     decompressor.write(compressed_data)
     ...
 
 
 Calls to ``write()`` will return the number of bytes written to the output
 object. Not all inputs will result in bytes being written, so return values
 of ``0`` are possible.
 
 Like the ``stream_writer()`` compressor, instances can be used as context
 managers. However, context managers add no extra special behavior and offer
 little to no benefit to being used.
 
 Calling ``close()`` will mark the stream as closed and subsequent I/O operations
 will raise ``ValueError`` (per the documented behavior of ``io.RawIOBase``).
 ``close()`` will also call ``close()`` on the underlying stream if such a
 method exists.
 
 The size of chunks being ``write()`` to the destination can be specified::
 
     dctx = zstd.ZstdDecompressor()
     with dctx.stream_writer(fh, write_size=16384) as decompressor:
         pass
 
 You can see how much memory is being used by the decompressor::
 
     dctx = zstd.ZstdDecompressor()
     with dctx.stream_writer(fh) as decompressor:
         byte_size = decompressor.memory_size()
 
 ``stream_writer()`` accepts a ``write_return_read`` boolean argument to control
 the return value of ``write()``. When ``False`` (the default)``, ``write()``
 returns the number of bytes that were ``write()``en to the underlying stream.
 When ``True``, ``write()`` returns the number of bytes read from the input.
 ``True`` is the *proper* behavior for ``write()`` as specified by the
 ``io.RawIOBase`` interface and will become the default in a future release.
 
 Streaming Output API
 ^^^^^^^^^^^^^^^^^^^^
 
 ``read_to_iter(fh)`` provides a mechanism to stream decompressed data out of a
 compressed source as an iterator of data chunks.:: 
 
     dctx = zstd.ZstdDecompressor()
     for chunk in dctx.read_to_iter(fh):
         # Do something with original data.
 
 ``read_to_iter()`` accepts an object with a ``read(size)`` method that will
 return  compressed bytes or an object conforming to the buffer protocol that
 can expose its data as a contiguous range of bytes.
 
 ``read_to_iter()`` returns an iterator whose elements are chunks of the
 decompressed data.
 
 The size of requested ``read()`` from the source can be specified::
 
     dctx = zstd.ZstdDecompressor()
     for chunk in dctx.read_to_iter(fh, read_size=16384):
         pass
 
 It is also possible to skip leading bytes in the input data::
 
     dctx = zstd.ZstdDecompressor()
     for chunk in dctx.read_to_iter(fh, skip_bytes=1):
         pass
 
 .. tip::
 
    Skipping leading bytes is useful if the source data contains extra
    *header* data. Traditionally, you would need to create a slice or
    ``memoryview`` of the data you want to decompress. This would create
    overhead. It is more efficient to pass the offset into this API.
 
 Similarly to ``ZstdCompressor.read_to_iter()``, the consumer of the iterator
 controls when data is decompressed. If the iterator isn't consumed,
 decompression is put on hold.
 
 When ``read_to_iter()`` is passed an object conforming to the buffer protocol,
 the behavior may seem similar to what occurs when the simple decompression
 API is used. However, this API works when the decompressed size is unknown.
 Furthermore, if feeding large inputs, the decompressor will work in chunks
 instead of performing a single operation.
 
 Stream Copying API
 ^^^^^^^^^^^^^^^^^^
 
 ``copy_stream(ifh, ofh)`` can be used to copy data across 2 streams while
 performing decompression.::
 
     dctx = zstd.ZstdDecompressor()
     dctx.copy_stream(ifh, ofh)
 
 e.g. to decompress a file to another file::
 
     dctx = zstd.ZstdDecompressor()
     with open(input_path, 'rb') as ifh, open(output_path, 'wb') as ofh:
         dctx.copy_stream(ifh, ofh)
 
 The size of chunks being ``read()`` and ``write()`` from and to the streams
 can be specified::
 
     dctx = zstd.ZstdDecompressor()
     dctx.copy_stream(ifh, ofh, read_size=8192, write_size=16384)
 
 Decompressor API
 ^^^^^^^^^^^^^^^^
 
 ``decompressobj()`` returns an object that exposes a ``decompress(data)``
 method. Compressed data chunks are fed into ``decompress(data)`` and
 uncompressed output (or an empty bytes) is returned. Output from subsequent
 calls needs to be concatenated to reassemble the full decompressed byte
 sequence.
 
 The purpose of ``decompressobj()`` is to provide an API-compatible interface
 with ``zlib.decompressobj`` and ``bz2.BZ2Decompressor``. This allows callers
 to swap in different decompressor objects while using the same API.
 
 Each object is single use: once an input frame is decoded, ``decompress()``
 can no longer be called.
 
 Here is how this API should be used::
 
    dctx = zstd.ZstdDecompressor()
    dobj = dctx.decompressobj()
    data = dobj.decompress(compressed_chunk_0)
    data = dobj.decompress(compressed_chunk_1)
 
 By default, calls to ``decompress()`` write output data in chunks of size
 ``DECOMPRESSION_RECOMMENDED_OUTPUT_SIZE``. These chunks are concatenated
 before being returned to the caller. It is possible to define the size of
 these temporary chunks by passing ``write_size`` to ``decompressobj()``::
 
    dctx = zstd.ZstdDecompressor()
    dobj = dctx.decompressobj(write_size=1048576)
 
 .. note::
 
    Because calls to ``decompress()`` may need to perform multiple
    memory (re)allocations, this streaming decompression API isn't as
    efficient as other APIs.
 
 For compatibility with the standard library APIs, instances expose a
 ``flush([length=None])`` method. This method no-ops and has no meaningful
 side-effects, making it safe to call any time.
 
 Batch Decompression API
 ^^^^^^^^^^^^^^^^^^^^^^^
 
 (Experimental. Not yet supported in CFFI bindings.)
 
 ``multi_decompress_to_buffer()`` performs decompression of multiple
 frames as a single operation and returns a ``BufferWithSegmentsCollection``
 containing decompressed data for all inputs.
 
 Compressed frames can be passed to the function as a ``BufferWithSegments``,
 a ``BufferWithSegmentsCollection``, or as a list containing objects that
 conform to the buffer protocol. For best performance, pass a
 ``BufferWithSegmentsCollection`` or a ``BufferWithSegments``, as
 minimal input validation will be done for that type. If calling from
 Python (as opposed to C), constructing one of these instances may add
 overhead cancelling out the performance overhead of validation for list
 inputs.::
 
     dctx = zstd.ZstdDecompressor()
     results = dctx.multi_decompress_to_buffer([b'...', b'...'])
 
 The decompressed size of each frame MUST be discoverable. It can either be
 embedded within the zstd frame (``write_content_size=True`` argument to
 ``ZstdCompressor``) or passed in via the ``decompressed_sizes`` argument.
 
 The ``decompressed_sizes`` argument is an object conforming to the buffer
 protocol which holds an array of 64-bit unsigned integers in the machine's
 native format defining the decompressed sizes of each frame. If this argument
 is passed, it avoids having to scan each frame for its decompressed size.
 This frame scanning can add noticeable overhead in some scenarios.::
 
     frames = [...]
     sizes = struct.pack('=QQQQ', len0, len1, len2, len3)
 
     dctx = zstd.ZstdDecompressor()
     results = dctx.multi_decompress_to_buffer(frames, decompressed_sizes=sizes)
 
 The ``threads`` argument controls the number of threads to use to perform
 decompression operations. The default (``0``) or the value ``1`` means to
 use a single thread. Negative values use the number of logical CPUs in the
 machine.
 
 .. note::
 
    It is possible to pass a ``mmap.mmap()`` instance into this function by
    wrapping it with a ``BufferWithSegments`` instance (which will define the
    offsets of frames within the memory mapped region).
 
 This function is logically equivalent to performing ``dctx.decompress()``
 on each input frame and returning the result.
 
 This function exists to perform decompression on multiple frames as fast
 as possible by having as little overhead as possible. Since decompression is
 performed as a single operation and since the decompressed output is stored in
 a single buffer, extra memory allocations, Python objects, and Python function
 calls are avoided. This is ideal for scenarios where callers know up front that
 they need to access data for multiple frames, such as when  *delta chains* are
 being used.
 
 Currently, the implementation always spawns multiple threads when requested,
 even if the amount of work to do is small. In the future, it will be smarter
 about avoiding threads and their associated overhead when the amount of
 work to do is small.
 
 Prefix Dictionary Chain Decompression
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 ``decompress_content_dict_chain(frames)`` performs decompression of a list of
 zstd frames produced using chained *prefix* dictionary compression. Such
 a list of frames is produced by compressing discrete inputs where each
 non-initial input is compressed with a *prefix* dictionary consisting of the
 content of the previous input.
 
 For example, say you have the following inputs::
 
    inputs = [b'input 1', b'input 2', b'input 3']
 
 The zstd frame chain consists of:
 
 1. ``b'input 1'`` compressed in standalone/discrete mode
 2. ``b'input 2'`` compressed using ``b'input 1'`` as a *prefix* dictionary
 3. ``b'input 3'`` compressed using ``b'input 2'`` as a *prefix* dictionary
 
 Each zstd frame **must** have the content size written.
 
 The following Python code can be used to produce a *prefix dictionary chain*::
 
     def make_chain(inputs):
         frames = []
 
         # First frame is compressed in standalone/discrete mode.
         zctx = zstd.ZstdCompressor()
         frames.append(zctx.compress(inputs[0]))
 
         # Subsequent frames use the previous fulltext as a prefix dictionary
         for i, raw in enumerate(inputs[1:]):
             dict_data = zstd.ZstdCompressionDict(
                 inputs[i], dict_type=zstd.DICT_TYPE_RAWCONTENT)
             zctx = zstd.ZstdCompressor(dict_data=dict_data)
             frames.append(zctx.compress(raw))
 
         return frames
 
 ``decompress_content_dict_chain()`` returns the uncompressed data of the last
 element in the input chain.
 
 
 .. note::
 
    It is possible to implement *prefix dictionary chain* decompression
    on top of other APIs. However, this function will likely be faster -
    especially for long input chains - as it avoids the overhead of instantiating
    and passing around intermediate objects between C and Python.
 
 Multi-Threaded Compression
 --------------------------
 
 ``ZstdCompressor`` accepts a ``threads`` argument that controls the number
 of threads to use for compression. The way this works is that input is split
 into segments and each segment is fed into a worker pool for compression. Once
 a segment is compressed, it is flushed/appended to the output.
 
 .. note::
 
    These threads are created at the C layer and are not Python threads. So they
    work outside the GIL. It is therefore possible to CPU saturate multiple cores
    from Python.
 
 The segment size for multi-threaded compression is chosen from the window size
 of the compressor. This is derived from the ``window_log`` attribute of a
 ``ZstdCompressionParameters`` instance. By default, segment sizes are in the 1+MB
 range.
 
 If multi-threaded compression is requested and the input is smaller than the
 configured segment size, only a single compression thread will be used. If the
 input is smaller than the segment size multiplied by the thread pool size or
 if data cannot be delivered to the compressor fast enough, not all requested
 compressor threads may be active simultaneously.
 
 Compared to non-multi-threaded compression, multi-threaded compression has
 higher per-operation overhead. This includes extra memory operations,
 thread creation, lock acquisition, etc.
 
 Due to the nature of multi-threaded compression using *N* compression
 *states*, the output from multi-threaded compression will likely be larger
 than non-multi-threaded compression. The difference is usually small. But
 there is a CPU/wall time versus size trade off that may warrant investigation.
 
 Output from multi-threaded compression does not require any special handling
 on the decompression side. To the decompressor, data generated with single
 threaded compressor looks the same as data generated by a multi-threaded
 compressor and does not require any special handling or additional resource
 requirements.
 
 Dictionary Creation and Management
 ----------------------------------
 
 Compression dictionaries are represented with the ``ZstdCompressionDict`` type.
 
 Instances can be constructed from bytes::
 
    dict_data = zstd.ZstdCompressionDict(data)
 
 It is possible to construct a dictionary from *any* data. If the data doesn't
 begin with a magic header, it will be treated as a *prefix* dictionary.
 *Prefix* dictionaries allow compression operations to reference raw data
 within the dictionary.
 
 It is possible to force the use of *prefix* dictionaries or to require a
 dictionary header:
 
    dict_data = zstd.ZstdCompressionDict(data,
                                         dict_type=zstd.DICT_TYPE_RAWCONTENT)
 
    dict_data = zstd.ZstdCompressionDict(data,
                                         dict_type=zstd.DICT_TYPE_FULLDICT)
 
 You can see how many bytes are in the dictionary by calling ``len()``::
 
    dict_data = zstd.train_dictionary(size, samples)
    dict_size = len(dict_data)  # will not be larger than ``size``
 
 Once you have a dictionary, you can pass it to the objects performing
 compression and decompression::
 
    dict_data = zstd.train_dictionary(131072, samples)
 
    cctx = zstd.ZstdCompressor(dict_data=dict_data)
    for source_data in input_data:
        compressed = cctx.compress(source_data)
        # Do something with compressed data.
 
    dctx = zstd.ZstdDecompressor(dict_data=dict_data)
    for compressed_data in input_data:
        buffer = io.BytesIO()
        with dctx.stream_writer(buffer) as decompressor:
            decompressor.write(compressed_data)
        # Do something with raw data in ``buffer``.
 
 Dictionaries have unique integer IDs. You can retrieve this ID via::
 
    dict_id = zstd.dictionary_id(dict_data)
 
 You can obtain the raw data in the dict (useful for persisting and constructing
 a ``ZstdCompressionDict`` later) via ``as_bytes()``::
 
    dict_data = zstd.train_dictionary(size, samples)
    raw_data = dict_data.as_bytes()
 
 By default, when a ``ZstdCompressionDict`` is *attached* to a
 ``ZstdCompressor``, each ``ZstdCompressor`` performs work to prepare the
 dictionary for use. This is fine if only 1 compression operation is being
 performed or if the ``ZstdCompressor`` is being reused for multiple operations.
 But if multiple ``ZstdCompressor`` instances are being used with the dictionary,
 this can add overhead.
 
 It is possible to *precompute* the dictionary so it can readily be consumed
 by multiple ``ZstdCompressor`` instances::
 
     d = zstd.ZstdCompressionDict(data)
 
     # Precompute for compression level 3.
     d.precompute_compress(level=3)
 
     # Precompute with specific compression parameters.
     params = zstd.ZstdCompressionParameters(...)
     d.precompute_compress(compression_params=params)
 
 .. note::
 
    When a dictionary is precomputed, the compression parameters used to
    precompute the dictionary overwrite some of the compression parameters
    specified to ``ZstdCompressor.__init__``.
 
 Training Dictionaries
 ^^^^^^^^^^^^^^^^^^^^^
 
 Unless using *prefix* dictionaries, dictionary data is produced by *training*
 on existing data::
 
    dict_data = zstd.train_dictionary(size, samples)
 
 This takes a target dictionary size and list of bytes instances and creates and
 returns a ``ZstdCompressionDict``.
 
 The dictionary training mechanism is known as *cover*. More details about it are
 available in the paper *Effective Construction of Relative Lempel-Ziv
 Dictionaries* (authors: Liao, Petri, Moffat, Wirth).
 
 The cover algorithm takes parameters ``k` and ``d``. These are the
 *segment size* and *dmer size*, respectively. The returned dictionary
 instance created by this function has ``k`` and ``d`` attributes
 containing the values for these parameters. If a ``ZstdCompressionDict``
 is constructed from raw bytes data (a content-only dictionary), the
 ``k`` and ``d`` attributes will be ``0``.
 
 The segment and dmer size parameters to the cover algorithm can either be
 specified manually or ``train_dictionary()`` can try multiple values
 and pick the best one, where *best* means the smallest compressed data size.
 This later mode is called *optimization* mode.
 
 If none of ``k``, ``d``, ``steps``, ``threads``, ``level``, ``notifications``,
 or ``dict_id`` (basically anything from the underlying ``ZDICT_cover_params_t``
 struct) are defined, *optimization* mode is used with default parameter
 values.
 
 If ``steps`` or ``threads`` are defined, then *optimization* mode is engaged
 with explicit control over those parameters. Specifying ``threads=0`` or
 ``threads=1`` can be used to engage *optimization* mode if other parameters
 are not defined.
 
 Otherwise, non-*optimization* mode is used with the parameters specified.
 
 This function takes the following arguments:
 
 dict_size
    Target size in bytes of the dictionary to generate.
 samples
    A list of bytes holding samples the dictionary will be trained from.
 k
    Parameter to cover algorithm defining the segment size. A reasonable range
    is [16, 2048+].
 d
    Parameter to cover algorithm defining the dmer size. A reasonable range is
    [6, 16]. ``d`` must be less than or equal to ``k``.
 dict_id
    Integer dictionary ID for the produced dictionary. Default is 0, which uses
    a random value.
 steps
    Number of steps through ``k`` values to perform when trying parameter
    variations.
 threads
    Number of threads to use when trying parameter variations. Default is 0,
    which means to use a single thread. A negative value can be specified to
    use as many threads as there are detected logical CPUs.
 level
    Integer target compression level when trying parameter variations.
 notifications
    Controls writing of informational messages to ``stderr``. ``0`` (the
    default) means to write nothing. ``1`` writes errors. ``2`` writes
    progression info. ``3`` writes more details. And ``4`` writes all info.
 
 Explicit Compression Parameters
 -------------------------------
 
 Zstandard offers a high-level *compression level* that maps to lower-level
 compression parameters. For many consumers, this numeric level is the only
 compression setting you'll need to touch.
 
 But for advanced use cases, it might be desirable to tweak these lower-level
 settings.
 
 The ``ZstdCompressionParameters`` type represents these low-level compression
 settings.
 
 Instances of this type can be constructed from a myriad of keyword arguments
 (defined below) for complete low-level control over each adjustable
 compression setting.
 
 From a higher level, one can construct a ``ZstdCompressionParameters`` instance
 given a desired compression level and target input and dictionary size
 using ``ZstdCompressionParameters.from_level()``. e.g.::
 
     # Derive compression settings for compression level 7.
     params = zstd.ZstdCompressionParameters.from_level(7)
 
     # With an input size of 1MB
     params = zstd.ZstdCompressionParameters.from_level(7, source_size=1048576)
 
 Using ``from_level()``, it is also possible to override individual compression
 parameters or to define additional settings that aren't automatically derived.
 e.g.::
 
     params = zstd.ZstdCompressionParameters.from_level(4, window_log=10)
     params = zstd.ZstdCompressionParameters.from_level(5, threads=4)
 
 Or you can define low-level compression settings directly::
 
     params = zstd.ZstdCompressionParameters(window_log=12, enable_ldm=True)
 
 Once a ``ZstdCompressionParameters`` instance is obtained, it can be used to
 configure a compressor::
 
     cctx = zstd.ZstdCompressor(compression_params=params)
 
 The named arguments and attributes of ``ZstdCompressionParameters`` are as
 follows:
 
 * format
 * compression_level
 * window_log
 * hash_log
 * chain_log
 * search_log
 * min_match
 * target_length
 * strategy
 * compression_strategy (deprecated: same as ``strategy``)
 * write_content_size
 * write_checksum
 * write_dict_id
 * job_size
 * overlap_log
 * overlap_size_log (deprecated: same as ``overlap_log``)
 * force_max_window
 * enable_ldm
 * ldm_hash_log
 * ldm_min_match
 * ldm_bucket_size_log
 * ldm_hash_rate_log
 * ldm_hash_every_log (deprecated: same as ``ldm_hash_rate_log``)
 * threads
 
 Some of these are very low-level settings. It may help to consult the official
 zstandard documentation for their behavior. Look for the ``ZSTD_p_*`` constants
 in ``zstd.h`` (https://github.com/facebook/zstd/blob/dev/lib/zstd.h).
 
 Frame Inspection
 ----------------
 
 Data emitted from zstd compression is encapsulated in a *frame*. This frame
 begins with a 4 byte *magic number* header followed by 2 to 14 bytes describing
 the frame in more detail. For more info, see
 https://github.com/facebook/zstd/blob/master/doc/zstd_compression_format.md.
 
 ``zstd.get_frame_parameters(data)`` parses a zstd *frame* header from a bytes
 instance and return a ``FrameParameters`` object describing the frame.
 
 Depending on which fields are present in the frame and their values, the
 length of the frame parameters varies. If insufficient bytes are passed
 in to fully parse the frame parameters, ``ZstdError`` is raised. To ensure
 frame parameters can be parsed, pass in at least 18 bytes.
 
 ``FrameParameters`` instances have the following attributes:
 
 content_size
    Integer size of original, uncompressed content. This will be ``0`` if the
    original content size isn't written to the frame (controlled with the
    ``write_content_size`` argument to ``ZstdCompressor``) or if the input
    content size was ``0``.
 
 window_size
    Integer size of maximum back-reference distance in compressed data.
 
 dict_id
    Integer of dictionary ID used for compression. ``0`` if no dictionary
    ID was used or if the dictionary ID was ``0``.
 
 has_checksum
    Bool indicating whether a 4 byte content checksum is stored at the end
    of the frame.
 
 ``zstd.frame_header_size(data)`` returns the size of the zstandard frame
 header.
 
 ``zstd.frame_content_size(data)`` returns the content size as parsed from
 the frame header. ``-1`` means the content size is unknown. ``0`` means
 an empty frame. The content size is usually correct. However, it may not
 be accurate.
 
 Misc Functionality
 ------------------
 
 estimate_decompression_context_size()
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 Estimate the memory size requirements for a decompressor instance.
 
 Constants
 ---------
 
 The following module constants/attributes are exposed:
 
 ZSTD_VERSION
     This module attribute exposes a 3-tuple of the Zstandard version. e.g.
     ``(1, 0, 0)``
 MAX_COMPRESSION_LEVEL
     Integer max compression level accepted by compression functions
 COMPRESSION_RECOMMENDED_INPUT_SIZE
     Recommended chunk size to feed to compressor functions
 COMPRESSION_RECOMMENDED_OUTPUT_SIZE
     Recommended chunk size for compression output
 DECOMPRESSION_RECOMMENDED_INPUT_SIZE
     Recommended chunk size to feed into decompresor functions
 DECOMPRESSION_RECOMMENDED_OUTPUT_SIZE
     Recommended chunk size for decompression output
 
 FRAME_HEADER
     bytes containing header of the Zstandard frame
 MAGIC_NUMBER
     Frame header as an integer
 
 FLUSH_BLOCK
     Flushing behavior that denotes to flush a zstd block. A decompressor will
     be able to decode all data fed into the compressor so far.
 FLUSH_FRAME
     Flushing behavior that denotes to end a zstd frame. Any new data fed
     to the compressor will start a new frame.
 
 CONTENTSIZE_UNKNOWN
     Value for content size when the content size is unknown.
 CONTENTSIZE_ERROR
     Value for content size when content size couldn't be determined.
 
 WINDOWLOG_MIN
     Minimum value for compression parameter
 WINDOWLOG_MAX
     Maximum value for compression parameter
 CHAINLOG_MIN
     Minimum value for compression parameter
 CHAINLOG_MAX
     Maximum value for compression parameter
 HASHLOG_MIN
     Minimum value for compression parameter
 HASHLOG_MAX
     Maximum value for compression parameter
 SEARCHLOG_MIN
     Minimum value for compression parameter
 SEARCHLOG_MAX
     Maximum value for compression parameter
 MINMATCH_MIN
     Minimum value for compression parameter
 MINMATCH_MAX
     Maximum value for compression parameter
 SEARCHLENGTH_MIN
     Minimum value for compression parameter
 
     Deprecated: use ``MINMATCH_MIN``
 SEARCHLENGTH_MAX
     Maximum value for compression parameter
 
     Deprecated: use ``MINMATCH_MAX``
 TARGETLENGTH_MIN
     Minimum value for compression parameter
 STRATEGY_FAST
     Compression strategy
 STRATEGY_DFAST
     Compression strategy
 STRATEGY_GREEDY
     Compression strategy
 STRATEGY_LAZY
     Compression strategy
 STRATEGY_LAZY2
     Compression strategy
 STRATEGY_BTLAZY2
     Compression strategy
 STRATEGY_BTOPT
     Compression strategy
 STRATEGY_BTULTRA
     Compression strategy
 STRATEGY_BTULTRA2
     Compression strategy
 
 FORMAT_ZSTD1
     Zstandard frame format
 FORMAT_ZSTD1_MAGICLESS
     Zstandard frame format without magic header
 
 Performance Considerations
 --------------------------
 
 The ``ZstdCompressor`` and ``ZstdDecompressor`` types maintain state to a
 persistent compression or decompression *context*. Reusing a ``ZstdCompressor``
 or ``ZstdDecompressor`` instance for multiple operations is faster than
 instantiating a new ``ZstdCompressor`` or ``ZstdDecompressor`` for each
 operation. The differences are magnified as the size of data decreases. For
 example, the difference between *context* reuse and non-reuse for 100,000
 100 byte inputs will be significant (possiby over 10x faster to reuse contexts)
 whereas 10 100,000,000 byte inputs will be more similar in speed (because the
 time spent doing compression dwarfs time spent creating new *contexts*).
 
 Buffer Types
 ------------
 
 The API exposes a handful of custom types for interfacing with memory buffers.
 The primary goal of these types is to facilitate efficient multi-object
 operations.
 
 The essential idea is to have a single memory allocation provide backing
 storage for multiple logical objects. This has 2 main advantages: fewer
 allocations and optimal memory access patterns. This avoids having to allocate
 a Python object for each logical object and furthermore ensures that access of
 data for objects can be sequential (read: fast) in memory.
 
 BufferWithSegments
 ^^^^^^^^^^^^^^^^^^
 
 The ``BufferWithSegments`` type represents a memory buffer containing N
 discrete items of known lengths (segments). It is essentially a fixed size
 memory address and an array of 2-tuples of ``(offset, length)`` 64-bit
 unsigned native endian integers defining the byte offset and length of each
 segment within the buffer.
 
 Instances behave like containers.
 
 ``len()`` returns the number of segments within the instance.
 
 ``o[index]`` or ``__getitem__`` obtains a ``BufferSegment`` representing an
 individual segment within the backing buffer. That returned object references
 (not copies) memory. This means that iterating all objects doesn't copy
 data within the buffer.
 
 The ``.size`` attribute contains the total size in bytes of the backing
 buffer.
 
 Instances conform to the buffer protocol. So a reference to the backing bytes
 can be obtained via ``memoryview(o)``. A *copy* of the backing bytes can also
 be obtained via ``.tobytes()``.
 
 The ``.segments`` attribute exposes the array of ``(offset, length)`` for
 segments within the buffer. It is a ``BufferSegments`` type.
 
 BufferSegment
 ^^^^^^^^^^^^^
 
 The ``BufferSegment`` type represents a segment within a ``BufferWithSegments``.
 It is essentially a reference to N bytes within a ``BufferWithSegments``.
 
 ``len()`` returns the length of the segment in bytes.
 
 ``.offset`` contains the byte offset of this segment within its parent
 ``BufferWithSegments`` instance.
 
 The object conforms to the buffer protocol. ``.tobytes()`` can be called to
 obtain a ``bytes`` instance with a copy of the backing bytes.
 
 BufferSegments
 ^^^^^^^^^^^^^^
 
 This type represents an array of ``(offset, length)`` integers defining segments
 within a ``BufferWithSegments``.
 
 The array members are 64-bit unsigned integers using host/native bit order.
 
 Instances conform to the buffer protocol.
 
 BufferWithSegmentsCollection
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 The ``BufferWithSegmentsCollection`` type represents a virtual spanning view
 of multiple ``BufferWithSegments`` instances.
 
 Instances are constructed from 1 or more ``BufferWithSegments`` instances. The
 resulting object behaves like an ordered sequence whose members are the
 segments within each ``BufferWithSegments``.
 
 ``len()`` returns the number of segments within all ``BufferWithSegments``
 instances.
 
 ``o[index]`` and ``__getitem__(index)`` return the ``BufferSegment`` at
 that offset as if all ``BufferWithSegments`` instances were a single
 entity.
 
 If the object is composed of 2 ``BufferWithSegments`` instances with the
 first having 2 segments and the second have 3 segments, then ``b[0]``
 and ``b[1]`` access segments in the first object and ``b[2]``, ``b[3]``,
 and ``b[4]`` access segments from the second.
 
 Choosing an API
 ===============
 
 There are multiple APIs for performing compression and decompression. This is
 because different applications have different needs and the library wants to
 facilitate optimal use in as many use cases as possible.
 
 From a high-level, APIs are divided into *one-shot* and *streaming*: either you
 are operating on all data at once or you operate on it piecemeal.
 
 The *one-shot* APIs are useful for small data, where the input or output
 size is known. (The size can come from a buffer length, file size, or
 stored in the zstd frame header.) A limitation of the *one-shot* APIs is that
 input and output must fit in memory simultaneously. For say a 4 GB input,
 this is often not feasible.
 
 The *one-shot* APIs also perform all work as a single operation. So, if you
 feed it large input, it could take a long time for the function to return.
 
 The streaming APIs do not have the limitations of the simple API. But the
 price you pay for this flexibility is that they are more complex than a
 single function call.
 
 The streaming APIs put the caller in control of compression and decompression
 behavior by allowing them to directly control either the input or output side
 of the operation.
 
 With the *streaming input*, *compressor*, and *decompressor* APIs, the caller
 has full control over the input to the compression or decompression stream.
 They can directly choose when new data is operated on.
 
 With the *streaming ouput* APIs, the caller has full control over the output
 of the compression or decompression stream. It can choose when to receive
 new data.
 
 When using the *streaming* APIs that operate on file-like or stream objects,
 it is important to consider what happens in that object when I/O is requested.
 There is potential for long pauses as data is read or written from the
 underlying stream (say from interacting with a filesystem or network). This
 could add considerable overhead.
 
 Thread Safety
 =============
 
 ``ZstdCompressor`` and ``ZstdDecompressor`` instances have no guarantees
 about thread safety. Do not operate on the same ``ZstdCompressor`` and
 ``ZstdDecompressor`` instance simultaneously from different threads. It is
 fine to have different threads call into a single instance, just not at the
 same time.
 
 Some operations require multiple function calls to complete. e.g. streaming
 operations. A single ``ZstdCompressor`` or ``ZstdDecompressor`` cannot be used
 for simultaneously active operations. e.g. you must not start a streaming
 operation when another streaming operation is already active.
 
 The C extension releases the GIL during non-trivial calls into the zstd C
 API. Non-trivial calls are notably compression and decompression. Trivial
 calls are things like parsing frame parameters. Where the GIL is released
 is considered an implementation detail and can change in any release.
 
 APIs that accept bytes-like objects don't enforce that the underlying object
 is read-only. However, it is assumed that the passed object is read-only for
 the duration of the function call. It is possible to pass a mutable object
 (like a ``bytearray``) to e.g. ``ZstdCompressor.compress()``, have the GIL
 released, and mutate the object from another thread. Such a race condition
 is a bug in the consumer of python-zstandard. Most Python data types are
 immutable, so unless you are doing something fancy, you don't need to
 worry about this.
 
 Note on Zstandard's *Experimental* API
 ======================================
 
 Many of the Zstandard APIs used by this module are marked as *experimental*
 within the Zstandard project.
 
 It is unclear how Zstandard's C API will evolve over time, especially with
 regards to this *experimental* functionality. We will try to maintain
 backwards compatibility at the Python API level. However, we cannot
 guarantee this for things not under our control.
 
 Since a copy of the Zstandard source code is distributed with this
 module and since we compile against it, the behavior of a specific
 version of this module should be constant for all of time. So if you
 pin the version of this module used in your projects (which is a Python
 best practice), you should be shielded from unwanted future changes.
 
 Donate
 ======
 
 A lot of time has been invested into this project by the author.
 
 If you find this project useful and would like to thank the author for
 their work, consider donating some money. Any amount is appreciated.
 
 .. image:: https://www.paypalobjects.com/en_US/i/btn/btn_donate_LG.gif
     :target: https://www.paypal.com/cgi-bin/webscr?cmd=_donations&business=gregory%2eszorc%40gmail%2ecom&lc=US&item_name=python%2dzstandard&currency_code=USD&bn=PP%2dDonationsBF%3abtn_donate_LG%2egif%3aNonHosted
     :alt: Donate via PayPal
 
 .. |ci-status| image:: https://dev.azure.com/gregoryszorc/python-zstandard/_apis/build/status/indygreg.python-zstandard?branchName=master
     :target: https://dev.azure.com/gregoryszorc/python-zstandard/_apis/build/status/indygreg.python-zstandard?branchName=master

contrib/python-zstandard/c-ext/python-zstandard.h

@@ -1,359 +1,359 b''
 /**
 * Copyright (c) 2016-present, Gregory Szorc
 * All rights reserved.
 *
 * This software may be modified and distributed under the terms
 * of the BSD license. See the LICENSE file for details.
 */
 
 #define PY_SSIZE_T_CLEAN
 #include <Python.h>
 #include "structmember.h"
 
 #define ZSTD_STATIC_LINKING_ONLY
 #define ZDICT_STATIC_LINKING_ONLY
 #include <zstd.h>
 #include <zdict.h>
 
 /* Remember to change the string in zstandard/__init__ as well */
-#define PYTHON_ZSTANDARD_VERSION "0.12.0"
+#define PYTHON_ZSTANDARD_VERSION "0.13.0"
 
 typedef enum {
 	compressorobj_flush_finish,
 	compressorobj_flush_block,
 } CompressorObj_Flush;
 
 /*
    Represents a ZstdCompressionParameters type.
 
    This type holds all the low-level compression parameters that can be set.
 */
 typedef struct {
 	PyObject_HEAD
 	ZSTD_CCtx_params* params;
 } ZstdCompressionParametersObject;
 
 extern PyTypeObject ZstdCompressionParametersType;
 
 /*
    Represents a FrameParameters type.
 
    This type is basically a wrapper around ZSTD_frameParams.
 */
 typedef struct {
 	PyObject_HEAD
 	unsigned long long frameContentSize;
 	unsigned long long windowSize;
 	unsigned dictID;
 	char checksumFlag;
 } FrameParametersObject;
 
 extern PyTypeObject FrameParametersType;
 
 /*
    Represents a ZstdCompressionDict type.
 
    Instances hold data used for a zstd compression dictionary.
 */
 typedef struct {
 	PyObject_HEAD
 
 	/* Pointer to dictionary data. Owned by self. */
 	void* dictData;
 	/* Size of dictionary data. */
 	size_t dictSize;
 	ZSTD_dictContentType_e dictType;
 	/* k parameter for cover dictionaries. Only populated by train_cover_dict(). */
 	unsigned k;
 	/* d parameter for cover dictionaries. Only populated by train_cover_dict(). */
 	unsigned d;
 	/* Digested dictionary, suitable for reuse. */
 	ZSTD_CDict* cdict;
 	ZSTD_DDict* ddict;
 } ZstdCompressionDict;
 
 extern PyTypeObject ZstdCompressionDictType;
 
 /*
    Represents a ZstdCompressor type.
 */
 typedef struct {
 	PyObject_HEAD
 
 	/* Number of threads to use for operations. */
 	unsigned int threads;
 	/* Pointer to compression dictionary to use. NULL if not using dictionary
 	   compression. */
 	ZstdCompressionDict* dict;
 	/* Compression context to use. Populated during object construction. */
 	ZSTD_CCtx* cctx;
 	/* Compression parameters in use. */
 	ZSTD_CCtx_params* params;
 } ZstdCompressor;
 
 extern PyTypeObject ZstdCompressorType;
 
 typedef struct {
 	PyObject_HEAD
 
 	ZstdCompressor* compressor;
 	ZSTD_outBuffer output;
 	int finished;
 } ZstdCompressionObj;
 
 extern PyTypeObject ZstdCompressionObjType;
 
 typedef struct {
 	PyObject_HEAD
 
 	ZstdCompressor* compressor;
 	PyObject* writer;
 	ZSTD_outBuffer output;
 	size_t outSize;
 	int entered;
 	int closed;
 	int writeReturnRead;
 	unsigned long long bytesCompressed;
 } ZstdCompressionWriter;
 
 extern PyTypeObject ZstdCompressionWriterType;
 
 typedef struct {
 	PyObject_HEAD
 
 	ZstdCompressor* compressor;
 	PyObject* reader;
 	Py_buffer buffer;
 	Py_ssize_t bufferOffset;
 	size_t inSize;
 	size_t outSize;
 
 	ZSTD_inBuffer input;
 	ZSTD_outBuffer output;
 	int finishedOutput;
 	int finishedInput;
 	PyObject* readResult;
 } ZstdCompressorIterator;
 
 extern PyTypeObject ZstdCompressorIteratorType;
 
 typedef struct {
 	PyObject_HEAD
 
 	ZstdCompressor* compressor;
 	PyObject* reader;
 	Py_buffer buffer;
 	size_t readSize;
 
 	int entered;
 	int closed;
 	unsigned long long bytesCompressed;
 
 	ZSTD_inBuffer input;
 	ZSTD_outBuffer output;
 	int finishedInput;
 	int finishedOutput;
 	PyObject* readResult;
 } ZstdCompressionReader;
 
 extern PyTypeObject ZstdCompressionReaderType;
 
 typedef struct {
 	PyObject_HEAD
 
 	ZstdCompressor* compressor;
 	ZSTD_inBuffer input;
 	ZSTD_outBuffer output;
 	Py_buffer inBuffer;
 	int finished;
 	size_t chunkSize;
 } ZstdCompressionChunker;
 
 extern PyTypeObject ZstdCompressionChunkerType;
 
 typedef enum {
 	compressionchunker_mode_normal,
 	compressionchunker_mode_flush,
 	compressionchunker_mode_finish,
 } CompressionChunkerMode;
 
 typedef struct {
 	PyObject_HEAD
 
 	ZstdCompressionChunker* chunker;
 	CompressionChunkerMode mode;
 } ZstdCompressionChunkerIterator;
 
 extern PyTypeObject ZstdCompressionChunkerIteratorType;
 
 typedef struct {
 	PyObject_HEAD
 
 	ZSTD_DCtx* dctx;
 	ZstdCompressionDict* dict;
 	size_t maxWindowSize;
 	ZSTD_format_e format;
 } ZstdDecompressor;
 
 extern PyTypeObject ZstdDecompressorType;
 
 typedef struct {
 	PyObject_HEAD
 
 	ZstdDecompressor* decompressor;
 	size_t outSize;
 	int finished;
 } ZstdDecompressionObj;
 
 extern PyTypeObject ZstdDecompressionObjType;
 
 typedef struct {
 	PyObject_HEAD
 
 	/* Parent decompressor to which this object is associated. */
 	ZstdDecompressor* decompressor;
 	/* Object to read() from (if reading from a stream). */
 	PyObject* reader;
 	/* Size for read() operations on reader. */
 	size_t readSize;
 	/* Whether a read() can return data spanning multiple zstd frames. */
 	int readAcrossFrames;
 	/* Buffer to read from (if reading from a buffer). */
 	Py_buffer buffer;
 
 	/* Whether the context manager is active. */
 	int entered;
 	/* Whether we've closed the stream. */
 	int closed;
 
 	/* Number of bytes decompressed and returned to user. */
 	unsigned long long bytesDecompressed;
 
 	/* Tracks data going into decompressor. */
 	ZSTD_inBuffer input;
 
 	/* Holds output from read() operation on reader. */
 	PyObject* readResult;
 
 	/* Whether all input has been sent to the decompressor. */
 	int finishedInput;
 	/* Whether all output has been flushed from the decompressor. */
 	int finishedOutput;
 } ZstdDecompressionReader;
 
 extern PyTypeObject ZstdDecompressionReaderType;
 
 typedef struct {
 	PyObject_HEAD
 
 	ZstdDecompressor* decompressor;
 	PyObject* writer;
 	size_t outSize;
 	int entered;
 	int closed;
 	int writeReturnRead;
 } ZstdDecompressionWriter;
 
 extern PyTypeObject ZstdDecompressionWriterType;
 
 typedef struct {
 	PyObject_HEAD
 
 	ZstdDecompressor* decompressor;
 	PyObject* reader;
 	Py_buffer buffer;
 	Py_ssize_t bufferOffset;
 	size_t inSize;
 	size_t outSize;
 	size_t skipBytes;
 	ZSTD_inBuffer input;
 	ZSTD_outBuffer output;
 	Py_ssize_t readCount;
 	int finishedInput;
 	int finishedOutput;
 } ZstdDecompressorIterator;
 
 extern PyTypeObject ZstdDecompressorIteratorType;
 
 typedef struct {
 	int errored;
 	PyObject* chunk;
 } DecompressorIteratorResult;
 
 typedef struct {
 	/* The public API is that these are 64-bit unsigned integers. So these can't
 	 * be size_t, even though values larger than SIZE_MAX or PY_SSIZE_T_MAX may 
 	 * be nonsensical for this platform. */
 	unsigned long long offset;
 	unsigned long long length;
 } BufferSegment;
 
 typedef struct {
 	PyObject_HEAD
 
 	PyObject* parent;
 	BufferSegment* segments;
 	Py_ssize_t segmentCount;
 } ZstdBufferSegments;
 
 extern PyTypeObject ZstdBufferSegmentsType;
 
 typedef struct {
 	PyObject_HEAD
 
 	PyObject* parent;
 	void* data;
 	Py_ssize_t dataSize;
 	unsigned long long offset;
 } ZstdBufferSegment;
 
 extern PyTypeObject ZstdBufferSegmentType;
 
 typedef struct {
 	PyObject_HEAD
 
 	Py_buffer parent;
 	void* data;
 	unsigned long long dataSize;
 	BufferSegment* segments;
 	Py_ssize_t segmentCount;
 	int useFree;
 } ZstdBufferWithSegments;
 
 extern PyTypeObject ZstdBufferWithSegmentsType;
 
 /**
  * An ordered collection of BufferWithSegments exposed as a squashed collection.
  *
  * This type provides a virtual view spanning multiple BufferWithSegments
  * instances. It allows multiple instances to be "chained" together and
  * exposed as a single collection. e.g. if there are 2 buffers holding
  * 10 segments each, then o[14] will access the 5th segment in the 2nd buffer.
  */
 typedef struct {
 	PyObject_HEAD
 
 	/* An array of buffers that should be exposed through this instance. */
 	ZstdBufferWithSegments** buffers;
 	/* Number of elements in buffers array. */
 	Py_ssize_t bufferCount;
 	/* Array of first offset in each buffer instance. 0th entry corresponds
 	   to number of elements in the 0th buffer. 1st entry corresponds to the
 	   sum of elements in 0th and 1st buffers. */
 	Py_ssize_t* firstElements;
 } ZstdBufferWithSegmentsCollection;
 
 extern PyTypeObject ZstdBufferWithSegmentsCollectionType;
 
 int set_parameter(ZSTD_CCtx_params* params, ZSTD_cParameter param, int value);
 int set_parameters(ZSTD_CCtx_params* params, ZstdCompressionParametersObject* obj);
 int to_cparams(ZstdCompressionParametersObject* params, ZSTD_compressionParameters* cparams);
 FrameParametersObject* get_frame_parameters(PyObject* self, PyObject* args, PyObject* kwargs);
 int ensure_ddict(ZstdCompressionDict* dict);
 int ensure_dctx(ZstdDecompressor* decompressor, int loadDict);
 ZstdCompressionDict* train_dictionary(PyObject* self, PyObject* args, PyObject* kwargs);
 ZstdBufferWithSegments* BufferWithSegments_FromMemory(void* data, unsigned long long dataSize, BufferSegment* segments, Py_ssize_t segmentsSize);
 Py_ssize_t BufferWithSegmentsCollection_length(ZstdBufferWithSegmentsCollection*);
 int cpu_count(void);
 size_t roundpow2(size_t);
 int safe_pybytes_resize(PyObject** obj, Py_ssize_t size);

contrib/python-zstandard/make_cffi.py

@@ -1,207 +1,225 b''
 # Copyright (c) 2016-present, Gregory Szorc
 # All rights reserved.
 #
 # This software may be modified and distributed under the terms
 # of the BSD license. See the LICENSE file for details.
 
 from __future__ import absolute_import
 
 import cffi
 import distutils.ccompiler
 import os
 import re
 import subprocess
 import tempfile
 
 
 HERE = os.path.abspath(os.path.dirname(__file__))
 
-SOURCES = ['zstd/%s' % p for p in (
-    'common/debug.c',
-    'common/entropy_common.c',
-    'common/error_private.c',
-    'common/fse_decompress.c',
-    'common/pool.c',
-    'common/threading.c',
-    'common/xxhash.c',
-    'common/zstd_common.c',
-    'compress/fse_compress.c',
-    'compress/hist.c',
-    'compress/huf_compress.c',
-    'compress/zstd_compress.c',
-    'compress/zstd_compress_literals.c',
-    'compress/zstd_compress_sequences.c',
-    'compress/zstd_double_fast.c',
-    'compress/zstd_fast.c',
-    'compress/zstd_lazy.c',
-    'compress/zstd_ldm.c',
-    'compress/zstd_opt.c',
-    'compress/zstdmt_compress.c',
-    'decompress/huf_decompress.c',
-    'decompress/zstd_ddict.c',
-    'decompress/zstd_decompress.c',
-    'decompress/zstd_decompress_block.c',
-    'dictBuilder/cover.c',
-    'dictBuilder/fastcover.c',
-    'dictBuilder/divsufsort.c',
-    'dictBuilder/zdict.c',
-)]
+SOURCES = [
+    "zstd/%s" % p
+    for p in (
+        "common/debug.c",
+        "common/entropy_common.c",
+        "common/error_private.c",
+        "common/fse_decompress.c",
+        "common/pool.c",
+        "common/threading.c",
+        "common/xxhash.c",
+        "common/zstd_common.c",
+        "compress/fse_compress.c",
+        "compress/hist.c",
+        "compress/huf_compress.c",
+        "compress/zstd_compress.c",
+        "compress/zstd_compress_literals.c",
+        "compress/zstd_compress_sequences.c",
+        "compress/zstd_double_fast.c",
+        "compress/zstd_fast.c",
+        "compress/zstd_lazy.c",
+        "compress/zstd_ldm.c",
+        "compress/zstd_opt.c",
+        "compress/zstdmt_compress.c",
+        "decompress/huf_decompress.c",
+        "decompress/zstd_ddict.c",
+        "decompress/zstd_decompress.c",
+        "decompress/zstd_decompress_block.c",
+        "dictBuilder/cover.c",
+        "dictBuilder/fastcover.c",
+        "dictBuilder/divsufsort.c",
+        "dictBuilder/zdict.c",
+    )
+]
 
 # Headers whose preprocessed output will be fed into cdef().
-HEADERS = [os.path.join(HERE, 'zstd', *p) for p in (
-    ('zstd.h',),
-    ('dictBuilder', 'zdict.h'),
-)]
+HEADERS = [
+    os.path.join(HERE, "zstd", *p) for p in (("zstd.h",), ("dictBuilder", "zdict.h"),)
+]
 
-INCLUDE_DIRS = [os.path.join(HERE, d) for d in (
-    'zstd',
-    'zstd/common',
-    'zstd/compress',
-    'zstd/decompress',
-    'zstd/dictBuilder',
-)]
+INCLUDE_DIRS = [
+    os.path.join(HERE, d)
+    for d in (
+        "zstd",
+        "zstd/common",
+        "zstd/compress",
+        "zstd/decompress",
+        "zstd/dictBuilder",
+    )
+]
 
 # cffi can't parse some of the primitives in zstd.h. So we invoke the
 # preprocessor and feed its output into cffi.
 compiler = distutils.ccompiler.new_compiler()
 
 # Needed for MSVC.
-if hasattr(compiler, 'initialize'):
+if hasattr(compiler, "initialize"):
     compiler.initialize()
 
 # Distutils doesn't set compiler.preprocessor, so invoke the preprocessor
 # manually.
-if compiler.compiler_type == 'unix':
-    args = list(compiler.executables['compiler'])
-    args.extend([
-        '-E',
-        '-DZSTD_STATIC_LINKING_ONLY',
-        '-DZDICT_STATIC_LINKING_ONLY',
-    ])
-elif compiler.compiler_type == 'msvc':
+if compiler.compiler_type == "unix":
+    args = list(compiler.executables["compiler"])
+    args.extend(
+        ["-E", "-DZSTD_STATIC_LINKING_ONLY", "-DZDICT_STATIC_LINKING_ONLY",]
+    )
+elif compiler.compiler_type == "msvc":
     args = [compiler.cc]
-    args.extend([
-        '/EP',
-        '/DZSTD_STATIC_LINKING_ONLY',
-        '/DZDICT_STATIC_LINKING_ONLY',
-    ])
+    args.extend(
+        ["/EP", "/DZSTD_STATIC_LINKING_ONLY", "/DZDICT_STATIC_LINKING_ONLY",]
+    )
 else:
-    raise Exception('unsupported compiler type: %s' % compiler.compiler_type)
+    raise Exception("unsupported compiler type: %s" % compiler.compiler_type)
+
 
 def preprocess(path):
-    with open(path, 'rb') as fh:
+    with open(path, "rb") as fh:
         lines = []
         it = iter(fh)
 
         for l in it:
             # zstd.h includes <stddef.h>, which is also included by cffi's
             # boilerplate. This can lead to duplicate declarations. So we strip
             # this include from the preprocessor invocation.
             #
             # The same things happens for including zstd.h, so give it the same
             # treatment.
             #
             # We define ZSTD_STATIC_LINKING_ONLY, which is redundant with the inline
             # #define in zstdmt_compress.h and results in a compiler warning. So drop
             # the inline #define.
-            if l.startswith((b'#include <stddef.h>',
-                             b'#include "zstd.h"',
-                             b'#define ZSTD_STATIC_LINKING_ONLY')):
+            if l.startswith(
+                (
+                    b"#include <stddef.h>",
+                    b'#include "zstd.h"',
+                    b"#define ZSTD_STATIC_LINKING_ONLY",
+                )
+            ):
                 continue
 
+            # The preprocessor environment on Windows doesn't define include
+            # paths, so the #include of limits.h fails. We work around this
+            # by removing that import and defining INT_MAX ourselves. This is
+            # a bit hacky. But it gets the job done.
+            # TODO make limits.h work on Windows so we ensure INT_MAX is
+            # correct.
+            if l.startswith(b"#include <limits.h>"):
+                l = b"#define INT_MAX 2147483647\n"
+
             # ZSTDLIB_API may not be defined if we dropped zstd.h. It isn't
             # important so just filter it out.
-            if l.startswith(b'ZSTDLIB_API'):
-                l = l[len(b'ZSTDLIB_API '):]
+            if l.startswith(b"ZSTDLIB_API"):
+                l = l[len(b"ZSTDLIB_API ") :]
 
             lines.append(l)
 
-    fd, input_file = tempfile.mkstemp(suffix='.h')
-    os.write(fd, b''.join(lines))
+    fd, input_file = tempfile.mkstemp(suffix=".h")
+    os.write(fd, b"".join(lines))
     os.close(fd)
 
     try:
         env = dict(os.environ)
-        if getattr(compiler, '_paths', None):
-            env['PATH'] = compiler._paths
-        process = subprocess.Popen(args + [input_file], stdout=subprocess.PIPE,
-                                   env=env)
+        if getattr(compiler, "_paths", None):
+            env["PATH"] = compiler._paths
+        process = subprocess.Popen(args + [input_file], stdout=subprocess.PIPE, env=env)
         output = process.communicate()[0]
         ret = process.poll()
         if ret:
-            raise Exception('preprocessor exited with error')
+            raise Exception("preprocessor exited with error")
 
         return output
     finally:
         os.unlink(input_file)
 
 
 def normalize_output(output):
     lines = []
     for line in output.splitlines():
         # CFFI's parser doesn't like __attribute__ on UNIX compilers.
         if line.startswith(b'__attribute__ ((visibility ("default"))) '):
-            line = line[len(b'__attribute__ ((visibility ("default"))) '):]
+            line = line[len(b'__attribute__ ((visibility ("default"))) ') :]
 
-        if line.startswith(b'__attribute__((deprecated('):
+        if line.startswith(b"__attribute__((deprecated("):
             continue
-        elif b'__declspec(deprecated(' in line:
+        elif b"__declspec(deprecated(" in line:
             continue
 
         lines.append(line)
 
-    return b'\n'.join(lines)
+    return b"\n".join(lines)
 
 
 ffi = cffi.FFI()
 # zstd.h uses a possible undefined MIN(). Define it until
 # https://github.com/facebook/zstd/issues/976 is fixed.
 # *_DISABLE_DEPRECATE_WARNINGS prevents the compiler from emitting a warning
 # when cffi uses the function. Since we statically link against zstd, even
 # if we use the deprecated functions it shouldn't be a huge problem.
-ffi.set_source('_zstd_cffi', '''
+ffi.set_source(
+    "_zstd_cffi",
+    """
 #define MIN(a,b) ((a)<(b) ? (a) : (b))
 #define ZSTD_STATIC_LINKING_ONLY
 #include <zstd.h>
 #define ZDICT_STATIC_LINKING_ONLY
 #define ZDICT_DISABLE_DEPRECATE_WARNINGS
 #include <zdict.h>
-''', sources=SOURCES,
-     include_dirs=INCLUDE_DIRS,
-     extra_compile_args=['-DZSTD_MULTITHREAD'])
+""",
+    sources=SOURCES,
+    include_dirs=INCLUDE_DIRS,
+    extra_compile_args=["-DZSTD_MULTITHREAD"],
+)
 
-DEFINE = re.compile(b'^\\#define ([a-zA-Z0-9_]+) ')
+DEFINE = re.compile(b"^\\#define ([a-zA-Z0-9_]+) ")
 
 sources = []
 
 # Feed normalized preprocessor output for headers into the cdef parser.
 for header in HEADERS:
     preprocessed = preprocess(header)
     sources.append(normalize_output(preprocessed))
 
     # #define's are effectively erased as part of going through preprocessor.
     # So perform a manual pass to re-add those to the cdef source.
-    with open(header, 'rb') as fh:
+    with open(header, "rb") as fh:
         for line in fh:
             line = line.strip()
             m = DEFINE.match(line)
             if not m:
                 continue
 
-            if m.group(1) == b'ZSTD_STATIC_LINKING_ONLY':
+            if m.group(1) == b"ZSTD_STATIC_LINKING_ONLY":
                 continue
 
             # The parser doesn't like some constants with complex values.
-            if m.group(1) in (b'ZSTD_LIB_VERSION', b'ZSTD_VERSION_STRING'):
+            if m.group(1) in (b"ZSTD_LIB_VERSION", b"ZSTD_VERSION_STRING"):
                 continue
 
             # The ... is magic syntax by the cdef parser to resolve the
             # value at compile time.
-            sources.append(m.group(0) + b' ...')
+            sources.append(m.group(0) + b" ...")
 
-cdeflines = b'\n'.join(sources).splitlines()
+cdeflines = b"\n".join(sources).splitlines()
 cdeflines = [l for l in cdeflines if l.strip()]
-ffi.cdef(b'\n'.join(cdeflines).decode('latin1'))
+ffi.cdef(b"\n".join(cdeflines).decode("latin1"))
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     ffi.compile()

contrib/python-zstandard/setup.py

@@ -1,112 +1,118 b''
 #!/usr/bin/env python
 # Copyright (c) 2016-present, Gregory Szorc
 # All rights reserved.
 #
 # This software may be modified and distributed under the terms
 # of the BSD license. See the LICENSE file for details.
 
 from __future__ import print_function
 
 from distutils.version import LooseVersion
 import os
 import sys
 from setuptools import setup
 
 # Need change in 1.10 for ffi.from_buffer() to handle all buffer types
 # (like memoryview).
 # Need feature in 1.11 for ffi.gc() to declare size of objects so we avoid
 # garbage collection pitfalls.
-MINIMUM_CFFI_VERSION = '1.11'
+MINIMUM_CFFI_VERSION = "1.11"
 
 try:
     import cffi
 
     # PyPy (and possibly other distros) have CFFI distributed as part of
     # them. The install_requires for CFFI below won't work. We need to sniff
     # out the CFFI version here and reject CFFI if it is too old.
     cffi_version = LooseVersion(cffi.__version__)
     if cffi_version < LooseVersion(MINIMUM_CFFI_VERSION):
-        print('CFFI 1.11 or newer required (%s found); '
-              'not building CFFI backend' % cffi_version,
-              file=sys.stderr)
+        print(
+            "CFFI 1.11 or newer required (%s found); "
+            "not building CFFI backend" % cffi_version,
+            file=sys.stderr,
+        )
         cffi = None
 
 except ImportError:
     cffi = None
 
 import setup_zstd
 
 SUPPORT_LEGACY = False
 SYSTEM_ZSTD = False
 WARNINGS_AS_ERRORS = False
 
-if os.environ.get('ZSTD_WARNINGS_AS_ERRORS', ''):
+if os.environ.get("ZSTD_WARNINGS_AS_ERRORS", ""):
     WARNINGS_AS_ERRORS = True
 
-if '--legacy' in sys.argv:
+if "--legacy" in sys.argv:
     SUPPORT_LEGACY = True
-    sys.argv.remove('--legacy')
+    sys.argv.remove("--legacy")
 
-if '--system-zstd' in sys.argv:
+if "--system-zstd" in sys.argv:
     SYSTEM_ZSTD = True
-    sys.argv.remove('--system-zstd')
+    sys.argv.remove("--system-zstd")
 
-if '--warnings-as-errors' in sys.argv:
+if "--warnings-as-errors" in sys.argv:
     WARNINGS_AS_ERRORS = True
-    sys.argv.remove('--warning-as-errors')
+    sys.argv.remove("--warning-as-errors")
 
 # Code for obtaining the Extension instance is in its own module to
 # facilitate reuse in other projects.
 extensions = [
-    setup_zstd.get_c_extension(name='zstd',
-                               support_legacy=SUPPORT_LEGACY,
-                               system_zstd=SYSTEM_ZSTD,
-                               warnings_as_errors=WARNINGS_AS_ERRORS),
+    setup_zstd.get_c_extension(
+        name="zstd",
+        support_legacy=SUPPORT_LEGACY,
+        system_zstd=SYSTEM_ZSTD,
+        warnings_as_errors=WARNINGS_AS_ERRORS,
+    ),
 ]
 
 install_requires = []
 
 if cffi:
     import make_cffi
+
     extensions.append(make_cffi.ffi.distutils_extension())
-    install_requires.append('cffi>=%s' % MINIMUM_CFFI_VERSION)
+    install_requires.append("cffi>=%s" % MINIMUM_CFFI_VERSION)
 
 version = None
 
-with open('c-ext/python-zstandard.h', 'r') as fh:
+with open("c-ext/python-zstandard.h", "r") as fh:
     for line in fh:
-        if not line.startswith('#define PYTHON_ZSTANDARD_VERSION'):
+        if not line.startswith("#define PYTHON_ZSTANDARD_VERSION"):
             continue
 
         version = line.split()[2][1:-1]
         break
 
 if not version:
-    raise Exception('could not resolve package version; '
-                    'this should never happen')
+    raise Exception("could not resolve package version; " "this should never happen")
 
 setup(
-    name='zstandard',
+    name="zstandard",
     version=version,
-    description='Zstandard bindings for Python',
-    long_description=open('README.rst', 'r').read(),
-    url='https://github.com/indygreg/python-zstandard',
-    author='Gregory Szorc',
-    author_email='[e-mail]',
-    license='BSD',
+    description="Zstandard bindings for Python",
+    long_description=open("README.rst", "r").read(),
+    url="https://github.com/indygreg/python-zstandard",
+    author="Gregory Szorc",
+    author_email="[e-mail]",
+    license="BSD",
     classifiers=[
-        'Development Status :: 4 - Beta',
-        'Intended Audience :: Developers',
-        'License :: OSI Approved :: BSD License',
-        'Programming Language :: C',
-        'Programming Language :: Python :: 2.7',
-        'Programming Language :: Python :: 3.5',
-        'Programming Language :: Python :: 3.6',
-        'Programming Language :: Python :: 3.7',
+        "Development Status :: 4 - Beta",
+        "Intended Audience :: Developers",
+        "License :: OSI Approved :: BSD License",
+        "Programming Language :: C",
+        "Programming Language :: Python :: 2.7",
+        "Programming Language :: Python :: 3.5",
+        "Programming Language :: Python :: 3.6",
+        "Programming Language :: Python :: 3.7",
+        "Programming Language :: Python :: 3.8",
     ],
-    keywords='zstandard zstd compression',
-    packages=['zstandard'],
+    keywords="zstandard zstd compression",
+    packages=["zstandard"],
     ext_modules=extensions,
-    test_suite='tests',
+    test_suite="tests",
     install_requires=install_requires,
+    tests_require=["hypothesis"],
 )

contrib/python-zstandard/setup_zstd.py

@@ -1,192 +1,206 b''
 # Copyright (c) 2016-present, Gregory Szorc
 # All rights reserved.
 #
 # This software may be modified and distributed under the terms
 # of the BSD license. See the LICENSE file for details.
 
 import distutils.ccompiler
 import os
 
 from distutils.extension import Extension
 
 
-zstd_sources = ['zstd/%s' % p for p in (
-    'common/debug.c',
-    'common/entropy_common.c',
-    'common/error_private.c',
-    'common/fse_decompress.c',
-    'common/pool.c',
-    'common/threading.c',
-    'common/xxhash.c',
-    'common/zstd_common.c',
-    'compress/fse_compress.c',
-    'compress/hist.c',
-    'compress/huf_compress.c',
-    'compress/zstd_compress_literals.c',
-    'compress/zstd_compress_sequences.c',
-    'compress/zstd_compress.c',
-    'compress/zstd_double_fast.c',
-    'compress/zstd_fast.c',
-    'compress/zstd_lazy.c',
-    'compress/zstd_ldm.c',
-    'compress/zstd_opt.c',
-    'compress/zstdmt_compress.c',
-    'decompress/huf_decompress.c',
-    'decompress/zstd_ddict.c',
-    'decompress/zstd_decompress.c',
-    'decompress/zstd_decompress_block.c',
-    'dictBuilder/cover.c',
-    'dictBuilder/divsufsort.c',
-    'dictBuilder/fastcover.c',
-    'dictBuilder/zdict.c',
-)]
+zstd_sources = [
+    "zstd/%s" % p
+    for p in (
+        "common/debug.c",
+        "common/entropy_common.c",
+        "common/error_private.c",
+        "common/fse_decompress.c",
+        "common/pool.c",
+        "common/threading.c",
+        "common/xxhash.c",
+        "common/zstd_common.c",
+        "compress/fse_compress.c",
+        "compress/hist.c",
+        "compress/huf_compress.c",
+        "compress/zstd_compress_literals.c",
+        "compress/zstd_compress_sequences.c",
+        "compress/zstd_compress.c",
+        "compress/zstd_double_fast.c",
+        "compress/zstd_fast.c",
+        "compress/zstd_lazy.c",
+        "compress/zstd_ldm.c",
+        "compress/zstd_opt.c",
+        "compress/zstdmt_compress.c",
+        "decompress/huf_decompress.c",
+        "decompress/zstd_ddict.c",
+        "decompress/zstd_decompress.c",
+        "decompress/zstd_decompress_block.c",
+        "dictBuilder/cover.c",
+        "dictBuilder/divsufsort.c",
+        "dictBuilder/fastcover.c",
+        "dictBuilder/zdict.c",
+    )
+]
 
-zstd_sources_legacy = ['zstd/%s' % p for p in (
-    'deprecated/zbuff_common.c',
-    'deprecated/zbuff_compress.c',
-    'deprecated/zbuff_decompress.c',
-    'legacy/zstd_v01.c',
-    'legacy/zstd_v02.c',
-    'legacy/zstd_v03.c',
-    'legacy/zstd_v04.c',
-    'legacy/zstd_v05.c',
-    'legacy/zstd_v06.c',
-    'legacy/zstd_v07.c'
-)]
+zstd_sources_legacy = [
+    "zstd/%s" % p
+    for p in (
+        "deprecated/zbuff_common.c",
+        "deprecated/zbuff_compress.c",
+        "deprecated/zbuff_decompress.c",
+        "legacy/zstd_v01.c",
+        "legacy/zstd_v02.c",
+        "legacy/zstd_v03.c",
+        "legacy/zstd_v04.c",
+        "legacy/zstd_v05.c",
+        "legacy/zstd_v06.c",
+        "legacy/zstd_v07.c",
+    )
+]
 
 zstd_includes = [
-    'zstd',
-    'zstd/common',
-    'zstd/compress',
-    'zstd/decompress',
-    'zstd/dictBuilder',
+    "zstd",
+    "zstd/common",
+    "zstd/compress",
+    "zstd/decompress",
+    "zstd/dictBuilder",
 ]
 
 zstd_includes_legacy = [
-    'zstd/deprecated',
-    'zstd/legacy',
+    "zstd/deprecated",
+    "zstd/legacy",
 ]
 
 ext_includes = [
-    'c-ext',
-    'zstd/common',
+    "c-ext",
+    "zstd/common",
 ]
 
 ext_sources = [
-    'zstd/common/pool.c',
-    'zstd/common/threading.c',
-    'zstd.c',
-    'c-ext/bufferutil.c',
-    'c-ext/compressiondict.c',
-    'c-ext/compressobj.c',
-    'c-ext/compressor.c',
-    'c-ext/compressoriterator.c',
-    'c-ext/compressionchunker.c',
-    'c-ext/compressionparams.c',
-    'c-ext/compressionreader.c',
-    'c-ext/compressionwriter.c',
-    'c-ext/constants.c',
-    'c-ext/decompressobj.c',
-    'c-ext/decompressor.c',
-    'c-ext/decompressoriterator.c',
-    'c-ext/decompressionreader.c',
-    'c-ext/decompressionwriter.c',
-    'c-ext/frameparams.c',
+    "zstd/common/error_private.c",
+    "zstd/common/pool.c",
+    "zstd/common/threading.c",
+    "zstd/common/zstd_common.c",
+    "zstd.c",
+    "c-ext/bufferutil.c",
+    "c-ext/compressiondict.c",
+    "c-ext/compressobj.c",
+    "c-ext/compressor.c",
+    "c-ext/compressoriterator.c",
+    "c-ext/compressionchunker.c",
+    "c-ext/compressionparams.c",
+    "c-ext/compressionreader.c",
+    "c-ext/compressionwriter.c",
+    "c-ext/constants.c",
+    "c-ext/decompressobj.c",
+    "c-ext/decompressor.c",
+    "c-ext/decompressoriterator.c",
+    "c-ext/decompressionreader.c",
+    "c-ext/decompressionwriter.c",
+    "c-ext/frameparams.c",
 ]
 
 zstd_depends = [
-    'c-ext/python-zstandard.h',
+    "c-ext/python-zstandard.h",
 ]
 
 
-def get_c_extension(support_legacy=False, system_zstd=False, name='zstd',
-                    warnings_as_errors=False, root=None):
+def get_c_extension(
+    support_legacy=False,
+    system_zstd=False,
+    name="zstd",
+    warnings_as_errors=False,
+    root=None,
+):
     """Obtain a distutils.extension.Extension for the C extension.
 
     ``support_legacy`` controls whether to compile in legacy zstd format support.
 
     ``system_zstd`` controls whether to compile against the system zstd library.
     For this to work, the system zstd library and headers must match what
     python-zstandard is coded against exactly.
 
     ``name`` is the module name of the C extension to produce.
 
     ``warnings_as_errors`` controls whether compiler warnings are turned into
     compiler errors.
 
     ``root`` defines a root path that source should be computed as relative
     to. This should be the directory with the main ``setup.py`` that is
     being invoked. If not defined, paths will be relative to this file.
     """
     actual_root = os.path.abspath(os.path.dirname(__file__))
     root = root or actual_root
 
     sources = set([os.path.join(actual_root, p) for p in ext_sources])
     if not system_zstd:
         sources.update([os.path.join(actual_root, p) for p in zstd_sources])
         if support_legacy:
-            sources.update([os.path.join(actual_root, p)
-                            for p in zstd_sources_legacy])
+            sources.update([os.path.join(actual_root, p) for p in zstd_sources_legacy])
     sources = list(sources)
 
     include_dirs = set([os.path.join(actual_root, d) for d in ext_includes])
     if not system_zstd:
-        include_dirs.update([os.path.join(actual_root, d)
-                             for d in zstd_includes])
+        include_dirs.update([os.path.join(actual_root, d) for d in zstd_includes])
         if support_legacy:
-            include_dirs.update([os.path.join(actual_root, d)
-                                 for d in zstd_includes_legacy])
+            include_dirs.update(
+                [os.path.join(actual_root, d) for d in zstd_includes_legacy]
+            )
     include_dirs = list(include_dirs)
 
     depends = [os.path.join(actual_root, p) for p in zstd_depends]
 
     compiler = distutils.ccompiler.new_compiler()
 
     # Needed for MSVC.
-    if hasattr(compiler, 'initialize'):
+    if hasattr(compiler, "initialize"):
         compiler.initialize()
 
-    if compiler.compiler_type == 'unix':
-        compiler_type = 'unix'
-    elif compiler.compiler_type == 'msvc':
-        compiler_type = 'msvc'
-    elif compiler.compiler_type == 'mingw32':
-        compiler_type = 'mingw32'
+    if compiler.compiler_type == "unix":
+        compiler_type = "unix"
+    elif compiler.compiler_type == "msvc":
+        compiler_type = "msvc"
+    elif compiler.compiler_type == "mingw32":
+        compiler_type = "mingw32"
     else:
-        raise Exception('unhandled compiler type: %s' %
-                        compiler.compiler_type)
+        raise Exception("unhandled compiler type: %s" % compiler.compiler_type)
 
-    extra_args = ['-DZSTD_MULTITHREAD']
+    extra_args = ["-DZSTD_MULTITHREAD"]
 
     if not system_zstd:
-        extra_args.append('-DZSTDLIB_VISIBILITY=')
-        extra_args.append('-DZDICTLIB_VISIBILITY=')
-        extra_args.append('-DZSTDERRORLIB_VISIBILITY=')
+        extra_args.append("-DZSTDLIB_VISIBILITY=")
+        extra_args.append("-DZDICTLIB_VISIBILITY=")
+        extra_args.append("-DZSTDERRORLIB_VISIBILITY=")
 
-        if compiler_type == 'unix':
-            extra_args.append('-fvisibility=hidden')
+        if compiler_type == "unix":
+            extra_args.append("-fvisibility=hidden")
 
     if not system_zstd and support_legacy:
-        extra_args.append('-DZSTD_LEGACY_SUPPORT=1')
+        extra_args.append("-DZSTD_LEGACY_SUPPORT=1")
 
     if warnings_as_errors:
-        if compiler_type in ('unix', 'mingw32'):
-            extra_args.append('-Werror')
-        elif compiler_type == 'msvc':
-            extra_args.append('/WX')
+        if compiler_type in ("unix", "mingw32"):
+            extra_args.append("-Werror")
+        elif compiler_type == "msvc":
+            extra_args.append("/WX")
         else:
             assert False
 
-    libraries = ['zstd'] if system_zstd else []
+    libraries = ["zstd"] if system_zstd else []
 
     # Python 3.7 doesn't like absolute paths. So normalize to relative.
     sources = [os.path.relpath(p, root) for p in sources]
     include_dirs = [os.path.relpath(p, root) for p in include_dirs]
     depends = [os.path.relpath(p, root) for p in depends]
 
     # TODO compile with optimizations.
-    return Extension(name, sources,
-                     include_dirs=include_dirs,
-                     depends=depends,
-                     extra_compile_args=extra_args,
-                     libraries=libraries)
+    return Extension(
+        name,
+        sources,
+        include_dirs=include_dirs,
+        depends=depends,
+        extra_compile_args=extra_args,
+        libraries=libraries,
+    )

contrib/python-zstandard/tests/common.py

@@ -1,185 +1,197 b''
 import imp
 import inspect
 import io
 import os
 import types
+import unittest
 
 try:
     import hypothesis
 except ImportError:
     hypothesis = None
 
 
+class TestCase(unittest.TestCase):
+    if not getattr(unittest.TestCase, "assertRaisesRegex", False):
+        assertRaisesRegex = unittest.TestCase.assertRaisesRegexp
+
+
 def make_cffi(cls):
     """Decorator to add CFFI versions of each test method."""
 
     # The module containing this class definition should
     # `import zstandard as zstd`. Otherwise things may blow up.
     mod = inspect.getmodule(cls)
-    if not hasattr(mod, 'zstd'):
+    if not hasattr(mod, "zstd"):
         raise Exception('test module does not contain "zstd" symbol')
 
-    if not hasattr(mod.zstd, 'backend'):
-        raise Exception('zstd symbol does not have "backend" attribute; did '
-                        'you `import zstandard as zstd`?')
+    if not hasattr(mod.zstd, "backend"):
+        raise Exception(
+            'zstd symbol does not have "backend" attribute; did '
+            "you `import zstandard as zstd`?"
+        )
 
     # If `import zstandard` already chose the cffi backend, there is nothing
     # for us to do: we only add the cffi variation if the default backend
     # is the C extension.
-    if mod.zstd.backend == 'cffi':
+    if mod.zstd.backend == "cffi":
         return cls
 
     old_env = dict(os.environ)
-    os.environ['PYTHON_ZSTANDARD_IMPORT_POLICY'] = 'cffi'
+    os.environ["PYTHON_ZSTANDARD_IMPORT_POLICY"] = "cffi"
     try:
         try:
-            mod_info = imp.find_module('zstandard')
-            mod = imp.load_module('zstandard_cffi', *mod_info)
+            mod_info = imp.find_module("zstandard")
+            mod = imp.load_module("zstandard_cffi", *mod_info)
         except ImportError:
             return cls
     finally:
         os.environ.clear()
         os.environ.update(old_env)
 
-    if mod.backend != 'cffi':
-        raise Exception('got the zstandard %s backend instead of cffi' % mod.backend)
+    if mod.backend != "cffi":
+        raise Exception("got the zstandard %s backend instead of cffi" % mod.backend)
 
     # If CFFI version is available, dynamically construct test methods
     # that use it.
 
     for attr in dir(cls):
         fn = getattr(cls, attr)
         if not inspect.ismethod(fn) and not inspect.isfunction(fn):
             continue
 
-        if not fn.__name__.startswith('test_'):
+        if not fn.__name__.startswith("test_"):
             continue
 
-        name = '%s_cffi' % fn.__name__
+        name = "%s_cffi" % fn.__name__
 
         # Replace the "zstd" symbol with the CFFI module instance. Then copy
         # the function object and install it in a new attribute.
         if isinstance(fn, types.FunctionType):
             globs = dict(fn.__globals__)
-            globs['zstd'] = mod
-            new_fn = types.FunctionType(fn.__code__, globs, name,
-                                        fn.__defaults__, fn.__closure__)
+            globs["zstd"] = mod
+            new_fn = types.FunctionType(
+                fn.__code__, globs, name, fn.__defaults__, fn.__closure__
+            )
             new_method = new_fn
         else:
             globs = dict(fn.__func__.func_globals)
-            globs['zstd'] = mod
-            new_fn = types.FunctionType(fn.__func__.func_code, globs, name,
-                                        fn.__func__.func_defaults,
-                                        fn.__func__.func_closure)
-            new_method = types.UnboundMethodType(new_fn, fn.im_self,
-                                                 fn.im_class)
+            globs["zstd"] = mod
+            new_fn = types.FunctionType(
+                fn.__func__.func_code,
+                globs,
+                name,
+                fn.__func__.func_defaults,
+                fn.__func__.func_closure,
+            )
+            new_method = types.UnboundMethodType(new_fn, fn.im_self, fn.im_class)
 
         setattr(cls, name, new_method)
 
     return cls
 
 
 class NonClosingBytesIO(io.BytesIO):
     """BytesIO that saves the underlying buffer on close().
 
     This allows us to access written data after close().
     """
+
     def __init__(self, *args, **kwargs):
         super(NonClosingBytesIO, self).__init__(*args, **kwargs)
         self._saved_buffer = None
 
     def close(self):
         self._saved_buffer = self.getvalue()
         return super(NonClosingBytesIO, self).close()
 
     def getvalue(self):
         if self.closed:
             return self._saved_buffer
         else:
             return super(NonClosingBytesIO, self).getvalue()
 
 
 class OpCountingBytesIO(NonClosingBytesIO):
     def __init__(self, *args, **kwargs):
         self._flush_count = 0
         self._read_count = 0
         self._write_count = 0
         return super(OpCountingBytesIO, self).__init__(*args, **kwargs)
 
     def flush(self):
         self._flush_count += 1
         return super(OpCountingBytesIO, self).flush()
 
     def read(self, *args):
         self._read_count += 1
         return super(OpCountingBytesIO, self).read(*args)
 
     def write(self, data):
         self._write_count += 1
         return super(OpCountingBytesIO, self).write(data)
 
 
 _source_files = []
 
 
 def random_input_data():
     """Obtain the raw content of source files.
 
     This is used for generating "random" data to feed into fuzzing, since it is
     faster than random content generation.
     """
     if _source_files:
         return _source_files
 
     for root, dirs, files in os.walk(os.path.dirname(__file__)):
         dirs[:] = list(sorted(dirs))
         for f in sorted(files):
             try:
-                with open(os.path.join(root, f), 'rb') as fh:
+                with open(os.path.join(root, f), "rb") as fh:
                     data = fh.read()
                     if data:
                         _source_files.append(data)
             except OSError:
                 pass
 
     # Also add some actual random data.
     _source_files.append(os.urandom(100))
     _source_files.append(os.urandom(1000))
     _source_files.append(os.urandom(10000))
     _source_files.append(os.urandom(100000))
     _source_files.append(os.urandom(1000000))
 
     return _source_files
 
 
 def generate_samples():
     inputs = [
-        b'foo',
-        b'bar',
-        b'abcdef',
-        b'sometext',
-        b'baz',
+        b"foo",
+        b"bar",
+        b"abcdef",
+        b"sometext",
+        b"baz",
     ]
 
     samples = []
 
     for i in range(128):
         samples.append(inputs[i % 5])
         samples.append(inputs[i % 5] * (i + 3))
         samples.append(inputs[-(i % 5)] * (i + 2))
 
     return samples
 
 
 if hypothesis:
     default_settings = hypothesis.settings(deadline=10000)
-    hypothesis.settings.register_profile('default', default_settings)
+    hypothesis.settings.register_profile("default", default_settings)
 
     ci_settings = hypothesis.settings(deadline=20000, max_examples=1000)
-    hypothesis.settings.register_profile('ci', ci_settings)
+    hypothesis.settings.register_profile("ci", ci_settings)
 
     expensive_settings = hypothesis.settings(deadline=None, max_examples=10000)
-    hypothesis.settings.register_profile('expensive', expensive_settings)
+    hypothesis.settings.register_profile("expensive", expensive_settings)
 
-    hypothesis.settings.load_profile(
-        os.environ.get('HYPOTHESIS_PROFILE', 'default'))
+    hypothesis.settings.load_profile(os.environ.get("HYPOTHESIS_PROFILE", "default"))

contrib/python-zstandard/tests/test_buffer_util.py

@@ -1,135 +1,146 b''
 import struct
 import unittest
 
 import zstandard as zstd
 
-ss = struct.Struct('=QQ')
+from .common import TestCase
+
+ss = struct.Struct("=QQ")
 
 
-class TestBufferWithSegments(unittest.TestCase):
+class TestBufferWithSegments(TestCase):
     def test_arguments(self):
-        if not hasattr(zstd, 'BufferWithSegments'):
-            self.skipTest('BufferWithSegments not available')
+        if not hasattr(zstd, "BufferWithSegments"):
+            self.skipTest("BufferWithSegments not available")
 
         with self.assertRaises(TypeError):
             zstd.BufferWithSegments()
 
         with self.assertRaises(TypeError):
-            zstd.BufferWithSegments(b'foo')
+            zstd.BufferWithSegments(b"foo")
 
         # Segments data should be a multiple of 16.
-        with self.assertRaisesRegexp(ValueError, 'segments array size is not a multiple of 16'):
-            zstd.BufferWithSegments(b'foo', b'\x00\x00')
+        with self.assertRaisesRegex(
+            ValueError, "segments array size is not a multiple of 16"
+        ):
+            zstd.BufferWithSegments(b"foo", b"\x00\x00")
 
     def test_invalid_offset(self):
-        if not hasattr(zstd, 'BufferWithSegments'):
-            self.skipTest('BufferWithSegments not available')
+        if not hasattr(zstd, "BufferWithSegments"):
+            self.skipTest("BufferWithSegments not available")
 
-        with self.assertRaisesRegexp(ValueError, 'offset within segments array references memory'):
-            zstd.BufferWithSegments(b'foo', ss.pack(0, 4))
+        with self.assertRaisesRegex(
+            ValueError, "offset within segments array references memory"
+        ):
+            zstd.BufferWithSegments(b"foo", ss.pack(0, 4))
 
     def test_invalid_getitem(self):
-        if not hasattr(zstd, 'BufferWithSegments'):
-            self.skipTest('BufferWithSegments not available')
+        if not hasattr(zstd, "BufferWithSegments"):
+            self.skipTest("BufferWithSegments not available")
 
-        b = zstd.BufferWithSegments(b'foo', ss.pack(0, 3))
+        b = zstd.BufferWithSegments(b"foo", ss.pack(0, 3))
 
-        with self.assertRaisesRegexp(IndexError, 'offset must be non-negative'):
+        with self.assertRaisesRegex(IndexError, "offset must be non-negative"):
             test = b[-10]
 
-        with self.assertRaisesRegexp(IndexError, 'offset must be less than 1'):
+        with self.assertRaisesRegex(IndexError, "offset must be less than 1"):
             test = b[1]
 
-        with self.assertRaisesRegexp(IndexError, 'offset must be less than 1'):
+        with self.assertRaisesRegex(IndexError, "offset must be less than 1"):
             test = b[2]
 
     def test_single(self):
-        if not hasattr(zstd, 'BufferWithSegments'):
-            self.skipTest('BufferWithSegments not available')
+        if not hasattr(zstd, "BufferWithSegments"):
+            self.skipTest("BufferWithSegments not available")
 
-        b = zstd.BufferWithSegments(b'foo', ss.pack(0, 3))
+        b = zstd.BufferWithSegments(b"foo", ss.pack(0, 3))
         self.assertEqual(len(b), 1)
         self.assertEqual(b.size, 3)
-        self.assertEqual(b.tobytes(), b'foo')
+        self.assertEqual(b.tobytes(), b"foo")
 
         self.assertEqual(len(b[0]), 3)
         self.assertEqual(b[0].offset, 0)
-        self.assertEqual(b[0].tobytes(), b'foo')
+        self.assertEqual(b[0].tobytes(), b"foo")
 
     def test_multiple(self):
-        if not hasattr(zstd, 'BufferWithSegments'):
-            self.skipTest('BufferWithSegments not available')
+        if not hasattr(zstd, "BufferWithSegments"):
+            self.skipTest("BufferWithSegments not available")
 
-        b = zstd.BufferWithSegments(b'foofooxfooxy', b''.join([ss.pack(0, 3),
-                                                               ss.pack(3, 4),
-                                                               ss.pack(7, 5)]))
+        b = zstd.BufferWithSegments(
+            b"foofooxfooxy", b"".join([ss.pack(0, 3), ss.pack(3, 4), ss.pack(7, 5)])
+        )
         self.assertEqual(len(b), 3)
         self.assertEqual(b.size, 12)
-        self.assertEqual(b.tobytes(), b'foofooxfooxy')
+        self.assertEqual(b.tobytes(), b"foofooxfooxy")
 
-        self.assertEqual(b[0].tobytes(), b'foo')
-        self.assertEqual(b[1].tobytes(), b'foox')
-        self.assertEqual(b[2].tobytes(), b'fooxy')
+        self.assertEqual(b[0].tobytes(), b"foo")
+        self.assertEqual(b[1].tobytes(), b"foox")
+        self.assertEqual(b[2].tobytes(), b"fooxy")
 
 
-class TestBufferWithSegmentsCollection(unittest.TestCase):
+class TestBufferWithSegmentsCollection(TestCase):
     def test_empty_constructor(self):
-        if not hasattr(zstd, 'BufferWithSegmentsCollection'):
-            self.skipTest('BufferWithSegmentsCollection not available')
+        if not hasattr(zstd, "BufferWithSegmentsCollection"):
+            self.skipTest("BufferWithSegmentsCollection not available")
 
-        with self.assertRaisesRegexp(ValueError, 'must pass at least 1 argument'):
+        with self.assertRaisesRegex(ValueError, "must pass at least 1 argument"):
             zstd.BufferWithSegmentsCollection()
 
     def test_argument_validation(self):
-        if not hasattr(zstd, 'BufferWithSegmentsCollection'):
-            self.skipTest('BufferWithSegmentsCollection not available')
+        if not hasattr(zstd, "BufferWithSegmentsCollection"):
+            self.skipTest("BufferWithSegmentsCollection not available")
 
-        with self.assertRaisesRegexp(TypeError, 'arguments must be BufferWithSegments'):
+        with self.assertRaisesRegex(TypeError, "arguments must be BufferWithSegments"):
             zstd.BufferWithSegmentsCollection(None)
 
-        with self.assertRaisesRegexp(TypeError, 'arguments must be BufferWithSegments'):
-            zstd.BufferWithSegmentsCollection(zstd.BufferWithSegments(b'foo', ss.pack(0, 3)),
-                                              None)
+        with self.assertRaisesRegex(TypeError, "arguments must be BufferWithSegments"):
+            zstd.BufferWithSegmentsCollection(
+                zstd.BufferWithSegments(b"foo", ss.pack(0, 3)), None
+            )
 
-        with self.assertRaisesRegexp(ValueError, 'ZstdBufferWithSegments cannot be empty'):
-            zstd.BufferWithSegmentsCollection(zstd.BufferWithSegments(b'', b''))
+        with self.assertRaisesRegex(
+            ValueError, "ZstdBufferWithSegments cannot be empty"
+        ):
+            zstd.BufferWithSegmentsCollection(zstd.BufferWithSegments(b"", b""))
 
     def test_length(self):
-        if not hasattr(zstd, 'BufferWithSegmentsCollection'):
-            self.skipTest('BufferWithSegmentsCollection not available')
+        if not hasattr(zstd, "BufferWithSegmentsCollection"):
+            self.skipTest("BufferWithSegmentsCollection not available")
 
-        b1 = zstd.BufferWithSegments(b'foo', ss.pack(0, 3))
-        b2 = zstd.BufferWithSegments(b'barbaz', b''.join([ss.pack(0, 3),
-                                                          ss.pack(3, 3)]))
+        b1 = zstd.BufferWithSegments(b"foo", ss.pack(0, 3))
+        b2 = zstd.BufferWithSegments(
+            b"barbaz", b"".join([ss.pack(0, 3), ss.pack(3, 3)])
+        )
 
         c = zstd.BufferWithSegmentsCollection(b1)
         self.assertEqual(len(c), 1)
         self.assertEqual(c.size(), 3)
 
         c = zstd.BufferWithSegmentsCollection(b2)
         self.assertEqual(len(c), 2)
         self.assertEqual(c.size(), 6)
 
         c = zstd.BufferWithSegmentsCollection(b1, b2)
         self.assertEqual(len(c), 3)
         self.assertEqual(c.size(), 9)
 
     def test_getitem(self):
-        if not hasattr(zstd, 'BufferWithSegmentsCollection'):
-            self.skipTest('BufferWithSegmentsCollection not available')
+        if not hasattr(zstd, "BufferWithSegmentsCollection"):
+            self.skipTest("BufferWithSegmentsCollection not available")
 
-        b1 = zstd.BufferWithSegments(b'foo', ss.pack(0, 3))
-        b2 = zstd.BufferWithSegments(b'barbaz', b''.join([ss.pack(0, 3),
-                                                          ss.pack(3, 3)]))
+        b1 = zstd.BufferWithSegments(b"foo", ss.pack(0, 3))
+        b2 = zstd.BufferWithSegments(
+            b"barbaz", b"".join([ss.pack(0, 3), ss.pack(3, 3)])
+        )
 
         c = zstd.BufferWithSegmentsCollection(b1, b2)
 
-        with self.assertRaisesRegexp(IndexError, 'offset must be less than 3'):
+        with self.assertRaisesRegex(IndexError, "offset must be less than 3"):
             c[3]
 
-        with self.assertRaisesRegexp(IndexError, 'offset must be less than 3'):
+        with self.assertRaisesRegex(IndexError, "offset must be less than 3"):
             c[4]
 
-        self.assertEqual(c[0].tobytes(), b'foo')
-        self.assertEqual(c[1].tobytes(), b'bar')
-        self.assertEqual(c[2].tobytes(), b'baz')
+        self.assertEqual(c[0].tobytes(), b"foo")
+        self.assertEqual(c[1].tobytes(), b"bar")
+        self.assertEqual(c[2].tobytes(), b"baz")

contrib/python-zstandard/tests/test_compressor.py

@@ -1,1735 +1,1770 b''
 import hashlib
 import io
 import os
 import struct
 import sys
 import tarfile
 import tempfile
 import unittest
 
 import zstandard as zstd
 
 from .common import (
     make_cffi,
     NonClosingBytesIO,
     OpCountingBytesIO,
+    TestCase,
 )
 
 
 if sys.version_info[0] >= 3:
     next = lambda it: it.__next__()
 else:
     next = lambda it: it.next()
 
 
 def multithreaded_chunk_size(level, source_size=0):
-    params = zstd.ZstdCompressionParameters.from_level(level,
-                                                       source_size=source_size)
+    params = zstd.ZstdCompressionParameters.from_level(level, source_size=source_size)
 
     return 1 << (params.window_log + 2)
 
 
 @make_cffi
-class TestCompressor(unittest.TestCase):
+class TestCompressor(TestCase):
     def test_level_bounds(self):
         with self.assertRaises(ValueError):
             zstd.ZstdCompressor(level=23)
 
     def test_memory_size(self):
         cctx = zstd.ZstdCompressor(level=1)
         self.assertGreater(cctx.memory_size(), 100)
 
 
 @make_cffi
-class TestCompressor_compress(unittest.TestCase):
+class TestCompressor_compress(TestCase):
     def test_compress_empty(self):
         cctx = zstd.ZstdCompressor(level=1, write_content_size=False)
-        result = cctx.compress(b'')
-        self.assertEqual(result, b'\x28\xb5\x2f\xfd\x00\x48\x01\x00\x00')
+        result = cctx.compress(b"")
+        self.assertEqual(result, b"\x28\xb5\x2f\xfd\x00\x48\x01\x00\x00")
         params = zstd.get_frame_parameters(result)
         self.assertEqual(params.content_size, zstd.CONTENTSIZE_UNKNOWN)
         self.assertEqual(params.window_size, 524288)
         self.assertEqual(params.dict_id, 0)
         self.assertFalse(params.has_checksum, 0)
 
         cctx = zstd.ZstdCompressor()
-        result = cctx.compress(b'')
-        self.assertEqual(result, b'\x28\xb5\x2f\xfd\x20\x00\x01\x00\x00')
+        result = cctx.compress(b"")
+        self.assertEqual(result, b"\x28\xb5\x2f\xfd\x20\x00\x01\x00\x00")
         params = zstd.get_frame_parameters(result)
         self.assertEqual(params.content_size, 0)
 
     def test_input_types(self):
         cctx = zstd.ZstdCompressor(level=1, write_content_size=False)
-        expected = b'\x28\xb5\x2f\xfd\x00\x00\x19\x00\x00\x66\x6f\x6f'
+        expected = b"\x28\xb5\x2f\xfd\x00\x00\x19\x00\x00\x66\x6f\x6f"
 
         mutable_array = bytearray(3)
-        mutable_array[:] = b'foo'
+        mutable_array[:] = b"foo"
 
         sources = [
-            memoryview(b'foo'),
-            bytearray(b'foo'),
+            memoryview(b"foo"),
+            bytearray(b"foo"),
             mutable_array,
         ]
 
         for source in sources:
             self.assertEqual(cctx.compress(source), expected)
 
     def test_compress_large(self):
         chunks = []
         for i in range(255):
-            chunks.append(struct.Struct('>B').pack(i) * 16384)
+            chunks.append(struct.Struct(">B").pack(i) * 16384)
 
         cctx = zstd.ZstdCompressor(level=3, write_content_size=False)
-        result = cctx.compress(b''.join(chunks))
+        result = cctx.compress(b"".join(chunks))
         self.assertEqual(len(result), 999)
-        self.assertEqual(result[0:4], b'\x28\xb5\x2f\xfd')
+        self.assertEqual(result[0:4], b"\x28\xb5\x2f\xfd")
 
         # This matches the test for read_to_iter() below.
         cctx = zstd.ZstdCompressor(level=1, write_content_size=False)
-        result = cctx.compress(b'f' * zstd.COMPRESSION_RECOMMENDED_INPUT_SIZE + b'o')
-        self.assertEqual(result, b'\x28\xb5\x2f\xfd\x00\x40\x54\x00\x00'
-                                 b'\x10\x66\x66\x01\x00\xfb\xff\x39\xc0'
-                                 b'\x02\x09\x00\x00\x6f')
+        result = cctx.compress(b"f" * zstd.COMPRESSION_RECOMMENDED_INPUT_SIZE + b"o")
+        self.assertEqual(
+            result,
+            b"\x28\xb5\x2f\xfd\x00\x40\x54\x00\x00"
+            b"\x10\x66\x66\x01\x00\xfb\xff\x39\xc0"
+            b"\x02\x09\x00\x00\x6f",
+        )
 
     def test_negative_level(self):
         cctx = zstd.ZstdCompressor(level=-4)
-        result = cctx.compress(b'foo' * 256)
+        result = cctx.compress(b"foo" * 256)
 
     def test_no_magic(self):
-        params = zstd.ZstdCompressionParameters.from_level(
-            1, format=zstd.FORMAT_ZSTD1)
+        params = zstd.ZstdCompressionParameters.from_level(1, format=zstd.FORMAT_ZSTD1)
         cctx = zstd.ZstdCompressor(compression_params=params)
-        magic = cctx.compress(b'foobar')
+        magic = cctx.compress(b"foobar")
 
         params = zstd.ZstdCompressionParameters.from_level(
-            1, format=zstd.FORMAT_ZSTD1_MAGICLESS)
+            1, format=zstd.FORMAT_ZSTD1_MAGICLESS
+        )
         cctx = zstd.ZstdCompressor(compression_params=params)
-        no_magic = cctx.compress(b'foobar')
+        no_magic = cctx.compress(b"foobar")
 
-        self.assertEqual(magic[0:4], b'\x28\xb5\x2f\xfd')
+        self.assertEqual(magic[0:4], b"\x28\xb5\x2f\xfd")
         self.assertEqual(magic[4:], no_magic)
 
     def test_write_checksum(self):
         cctx = zstd.ZstdCompressor(level=1)
-        no_checksum = cctx.compress(b'foobar')
+        no_checksum = cctx.compress(b"foobar")
         cctx = zstd.ZstdCompressor(level=1, write_checksum=True)
-        with_checksum = cctx.compress(b'foobar')
+        with_checksum = cctx.compress(b"foobar")
 
         self.assertEqual(len(with_checksum), len(no_checksum) + 4)
 
         no_params = zstd.get_frame_parameters(no_checksum)
         with_params = zstd.get_frame_parameters(with_checksum)
 
         self.assertFalse(no_params.has_checksum)
         self.assertTrue(with_params.has_checksum)
 
     def test_write_content_size(self):
         cctx = zstd.ZstdCompressor(level=1)
-        with_size = cctx.compress(b'foobar' * 256)
+        with_size = cctx.compress(b"foobar" * 256)
         cctx = zstd.ZstdCompressor(level=1, write_content_size=False)
-        no_size = cctx.compress(b'foobar' * 256)
+        no_size = cctx.compress(b"foobar" * 256)
 
         self.assertEqual(len(with_size), len(no_size) + 1)
 
         no_params = zstd.get_frame_parameters(no_size)
         with_params = zstd.get_frame_parameters(with_size)
         self.assertEqual(no_params.content_size, zstd.CONTENTSIZE_UNKNOWN)
         self.assertEqual(with_params.content_size, 1536)
 
     def test_no_dict_id(self):
         samples = []
         for i in range(128):
-            samples.append(b'foo' * 64)
-            samples.append(b'bar' * 64)
-            samples.append(b'foobar' * 64)
+            samples.append(b"foo" * 64)
+            samples.append(b"bar" * 64)
+            samples.append(b"foobar" * 64)
 
         d = zstd.train_dictionary(1024, samples)
 
         cctx = zstd.ZstdCompressor(level=1, dict_data=d)
-        with_dict_id = cctx.compress(b'foobarfoobar')
+        with_dict_id = cctx.compress(b"foobarfoobar")
 
         cctx = zstd.ZstdCompressor(level=1, dict_data=d, write_dict_id=False)
-        no_dict_id = cctx.compress(b'foobarfoobar')
+        no_dict_id = cctx.compress(b"foobarfoobar")
 
         self.assertEqual(len(with_dict_id), len(no_dict_id) + 4)
 
         no_params = zstd.get_frame_parameters(no_dict_id)
         with_params = zstd.get_frame_parameters(with_dict_id)
         self.assertEqual(no_params.dict_id, 0)
         self.assertEqual(with_params.dict_id, 1880053135)
 
     def test_compress_dict_multiple(self):
         samples = []
         for i in range(128):
-            samples.append(b'foo' * 64)
-            samples.append(b'bar' * 64)
-            samples.append(b'foobar' * 64)
+            samples.append(b"foo" * 64)
+            samples.append(b"bar" * 64)
+            samples.append(b"foobar" * 64)
 
         d = zstd.train_dictionary(8192, samples)
 
         cctx = zstd.ZstdCompressor(level=1, dict_data=d)
 
         for i in range(32):
-            cctx.compress(b'foo bar foobar foo bar foobar')
+            cctx.compress(b"foo bar foobar foo bar foobar")
 
     def test_dict_precompute(self):
         samples = []
         for i in range(128):
-            samples.append(b'foo' * 64)
-            samples.append(b'bar' * 64)
-            samples.append(b'foobar' * 64)
+            samples.append(b"foo" * 64)
+            samples.append(b"bar" * 64)
+            samples.append(b"foobar" * 64)
 
         d = zstd.train_dictionary(8192, samples)
         d.precompute_compress(level=1)
 
         cctx = zstd.ZstdCompressor(level=1, dict_data=d)
 
         for i in range(32):
-            cctx.compress(b'foo bar foobar foo bar foobar')
+            cctx.compress(b"foo bar foobar foo bar foobar")
 
     def test_multithreaded(self):
         chunk_size = multithreaded_chunk_size(1)
-        source = b''.join([b'x' * chunk_size, b'y' * chunk_size])
+        source = b"".join([b"x" * chunk_size, b"y" * chunk_size])
 
         cctx = zstd.ZstdCompressor(level=1, threads=2)
         compressed = cctx.compress(source)
 
         params = zstd.get_frame_parameters(compressed)
         self.assertEqual(params.content_size, chunk_size * 2)
         self.assertEqual(params.dict_id, 0)
         self.assertFalse(params.has_checksum)
 
         dctx = zstd.ZstdDecompressor()
         self.assertEqual(dctx.decompress(compressed), source)
 
     def test_multithreaded_dict(self):
         samples = []
         for i in range(128):
-            samples.append(b'foo' * 64)
-            samples.append(b'bar' * 64)
-            samples.append(b'foobar' * 64)
+            samples.append(b"foo" * 64)
+            samples.append(b"bar" * 64)
+            samples.append(b"foobar" * 64)
 
         d = zstd.train_dictionary(1024, samples)
 
         cctx = zstd.ZstdCompressor(dict_data=d, threads=2)
 
-        result = cctx.compress(b'foo')
-        params = zstd.get_frame_parameters(result);
-        self.assertEqual(params.content_size, 3);
+        result = cctx.compress(b"foo")
+        params = zstd.get_frame_parameters(result)
+        self.assertEqual(params.content_size, 3)
         self.assertEqual(params.dict_id, d.dict_id())
 
-        self.assertEqual(result,
-                         b'\x28\xb5\x2f\xfd\x23\x8f\x55\x0f\x70\x03\x19\x00\x00'
-                         b'\x66\x6f\x6f')
+        self.assertEqual(
+            result,
+            b"\x28\xb5\x2f\xfd\x23\x8f\x55\x0f\x70\x03\x19\x00\x00" b"\x66\x6f\x6f",
+        )
 
     def test_multithreaded_compression_params(self):
         params = zstd.ZstdCompressionParameters.from_level(0, threads=2)
         cctx = zstd.ZstdCompressor(compression_params=params)
 
-        result = cctx.compress(b'foo')
-        params = zstd.get_frame_parameters(result);
-        self.assertEqual(params.content_size, 3);
+        result = cctx.compress(b"foo")
+        params = zstd.get_frame_parameters(result)
+        self.assertEqual(params.content_size, 3)
 
-        self.assertEqual(result,
-                         b'\x28\xb5\x2f\xfd\x20\x03\x19\x00\x00\x66\x6f\x6f')
+        self.assertEqual(result, b"\x28\xb5\x2f\xfd\x20\x03\x19\x00\x00\x66\x6f\x6f")
 
 
 @make_cffi
-class TestCompressor_compressobj(unittest.TestCase):
+class TestCompressor_compressobj(TestCase):
     def test_compressobj_empty(self):
         cctx = zstd.ZstdCompressor(level=1, write_content_size=False)
         cobj = cctx.compressobj()
-        self.assertEqual(cobj.compress(b''), b'')
-        self.assertEqual(cobj.flush(),
-                         b'\x28\xb5\x2f\xfd\x00\x48\x01\x00\x00')
+        self.assertEqual(cobj.compress(b""), b"")
+        self.assertEqual(cobj.flush(), b"\x28\xb5\x2f\xfd\x00\x48\x01\x00\x00")
 
     def test_input_types(self):
-        expected = b'\x28\xb5\x2f\xfd\x00\x48\x19\x00\x00\x66\x6f\x6f'
+        expected = b"\x28\xb5\x2f\xfd\x00\x48\x19\x00\x00\x66\x6f\x6f"
         cctx = zstd.ZstdCompressor(level=1, write_content_size=False)
 
         mutable_array = bytearray(3)
-        mutable_array[:] = b'foo'
+        mutable_array[:] = b"foo"
 
         sources = [
-            memoryview(b'foo'),
-            bytearray(b'foo'),
+            memoryview(b"foo"),
+            bytearray(b"foo"),
             mutable_array,
         ]
 
         for source in sources:
             cobj = cctx.compressobj()
-            self.assertEqual(cobj.compress(source), b'')
+            self.assertEqual(cobj.compress(source), b"")
             self.assertEqual(cobj.flush(), expected)
 
     def test_compressobj_large(self):
         chunks = []
         for i in range(255):
-            chunks.append(struct.Struct('>B').pack(i) * 16384)
+            chunks.append(struct.Struct(">B").pack(i) * 16384)
 
         cctx = zstd.ZstdCompressor(level=3)
         cobj = cctx.compressobj()
 
-        result = cobj.compress(b''.join(chunks)) + cobj.flush()
+        result = cobj.compress(b"".join(chunks)) + cobj.flush()
         self.assertEqual(len(result), 999)
-        self.assertEqual(result[0:4], b'\x28\xb5\x2f\xfd')
+        self.assertEqual(result[0:4], b"\x28\xb5\x2f\xfd")
 
         params = zstd.get_frame_parameters(result)
         self.assertEqual(params.content_size, zstd.CONTENTSIZE_UNKNOWN)
         self.assertEqual(params.window_size, 2097152)
         self.assertEqual(params.dict_id, 0)
         self.assertFalse(params.has_checksum)
 
     def test_write_checksum(self):
         cctx = zstd.ZstdCompressor(level=1)
         cobj = cctx.compressobj()
-        no_checksum = cobj.compress(b'foobar') + cobj.flush()
+        no_checksum = cobj.compress(b"foobar") + cobj.flush()
         cctx = zstd.ZstdCompressor(level=1, write_checksum=True)
         cobj = cctx.compressobj()
-        with_checksum = cobj.compress(b'foobar') + cobj.flush()
+        with_checksum = cobj.compress(b"foobar") + cobj.flush()
 
         no_params = zstd.get_frame_parameters(no_checksum)
         with_params = zstd.get_frame_parameters(with_checksum)
         self.assertEqual(no_params.content_size, zstd.CONTENTSIZE_UNKNOWN)
         self.assertEqual(with_params.content_size, zstd.CONTENTSIZE_UNKNOWN)
         self.assertEqual(no_params.dict_id, 0)
         self.assertEqual(with_params.dict_id, 0)
         self.assertFalse(no_params.has_checksum)
         self.assertTrue(with_params.has_checksum)
 
         self.assertEqual(len(with_checksum), len(no_checksum) + 4)
 
     def test_write_content_size(self):
         cctx = zstd.ZstdCompressor(level=1)
-        cobj = cctx.compressobj(size=len(b'foobar' * 256))
-        with_size = cobj.compress(b'foobar' * 256) + cobj.flush()
+        cobj = cctx.compressobj(size=len(b"foobar" * 256))
+        with_size = cobj.compress(b"foobar" * 256) + cobj.flush()
         cctx = zstd.ZstdCompressor(level=1, write_content_size=False)
-        cobj = cctx.compressobj(size=len(b'foobar' * 256))
-        no_size = cobj.compress(b'foobar' * 256) + cobj.flush()
+        cobj = cctx.compressobj(size=len(b"foobar" * 256))
+        no_size = cobj.compress(b"foobar" * 256) + cobj.flush()
 
         no_params = zstd.get_frame_parameters(no_size)
         with_params = zstd.get_frame_parameters(with_size)
         self.assertEqual(no_params.content_size, zstd.CONTENTSIZE_UNKNOWN)
         self.assertEqual(with_params.content_size, 1536)
         self.assertEqual(no_params.dict_id, 0)
         self.assertEqual(with_params.dict_id, 0)
         self.assertFalse(no_params.has_checksum)
         self.assertFalse(with_params.has_checksum)
 
         self.assertEqual(len(with_size), len(no_size) + 1)
 
     def test_compress_after_finished(self):
         cctx = zstd.ZstdCompressor()
         cobj = cctx.compressobj()
 
-        cobj.compress(b'foo')
+        cobj.compress(b"foo")
         cobj.flush()
 
-        with self.assertRaisesRegexp(zstd.ZstdError, r'cannot call compress\(\) after compressor'):
-            cobj.compress(b'foo')
+        with self.assertRaisesRegex(
+            zstd.ZstdError, r"cannot call compress\(\) after compressor"
+        ):
+            cobj.compress(b"foo")
 
-        with self.assertRaisesRegexp(zstd.ZstdError, 'compressor object already finished'):
+        with self.assertRaisesRegex(
+            zstd.ZstdError, "compressor object already finished"
+        ):
             cobj.flush()
 
     def test_flush_block_repeated(self):
         cctx = zstd.ZstdCompressor(level=1)
         cobj = cctx.compressobj()
 
-        self.assertEqual(cobj.compress(b'foo'), b'')
-        self.assertEqual(cobj.flush(zstd.COMPRESSOBJ_FLUSH_BLOCK),
-                         b'\x28\xb5\x2f\xfd\x00\x48\x18\x00\x00foo')
-        self.assertEqual(cobj.compress(b'bar'), b'')
+        self.assertEqual(cobj.compress(b"foo"), b"")
+        self.assertEqual(
+            cobj.flush(zstd.COMPRESSOBJ_FLUSH_BLOCK),
+            b"\x28\xb5\x2f\xfd\x00\x48\x18\x00\x00foo",
+        )
+        self.assertEqual(cobj.compress(b"bar"), b"")
         # 3 byte header plus content.
-        self.assertEqual(cobj.flush(zstd.COMPRESSOBJ_FLUSH_BLOCK),
-                         b'\x18\x00\x00bar')
-        self.assertEqual(cobj.flush(), b'\x01\x00\x00')
+        self.assertEqual(cobj.flush(zstd.COMPRESSOBJ_FLUSH_BLOCK), b"\x18\x00\x00bar")
+        self.assertEqual(cobj.flush(), b"\x01\x00\x00")
 
     def test_flush_empty_block(self):
         cctx = zstd.ZstdCompressor(write_checksum=True)
         cobj = cctx.compressobj()
 
-        cobj.compress(b'foobar')
+        cobj.compress(b"foobar")
         cobj.flush(zstd.COMPRESSOBJ_FLUSH_BLOCK)
         # No-op if no block is active (this is internal to zstd).
-        self.assertEqual(cobj.flush(zstd.COMPRESSOBJ_FLUSH_BLOCK), b'')
+        self.assertEqual(cobj.flush(zstd.COMPRESSOBJ_FLUSH_BLOCK), b"")
 
         trailing = cobj.flush()
         # 3 bytes block header + 4 bytes frame checksum
         self.assertEqual(len(trailing), 7)
         header = trailing[0:3]
-        self.assertEqual(header, b'\x01\x00\x00')
+        self.assertEqual(header, b"\x01\x00\x00")
 
     def test_multithreaded(self):
         source = io.BytesIO()
-        source.write(b'a' * 1048576)
-        source.write(b'b' * 1048576)
-        source.write(b'c' * 1048576)
+        source.write(b"a" * 1048576)
+        source.write(b"b" * 1048576)
+        source.write(b"c" * 1048576)
         source.seek(0)
 
         cctx = zstd.ZstdCompressor(level=1, threads=2)
         cobj = cctx.compressobj()
 
         chunks = []
         while True:
             d = source.read(8192)
             if not d:
                 break
 
             chunks.append(cobj.compress(d))
 
         chunks.append(cobj.flush())
 
-        compressed = b''.join(chunks)
+        compressed = b"".join(chunks)
 
-        self.assertEqual(len(compressed), 295)
+        self.assertEqual(len(compressed), 119)
 
     def test_frame_progression(self):
         cctx = zstd.ZstdCompressor()
 
         self.assertEqual(cctx.frame_progression(), (0, 0, 0))
 
         cobj = cctx.compressobj()
 
-        cobj.compress(b'foobar')
+        cobj.compress(b"foobar")
         self.assertEqual(cctx.frame_progression(), (6, 0, 0))
 
         cobj.flush()
         self.assertEqual(cctx.frame_progression(), (6, 6, 15))
 
     def test_bad_size(self):
         cctx = zstd.ZstdCompressor()
 
         cobj = cctx.compressobj(size=2)
-        with self.assertRaisesRegexp(zstd.ZstdError, 'Src size is incorrect'):
-            cobj.compress(b'foo')
+        with self.assertRaisesRegex(zstd.ZstdError, "Src size is incorrect"):
+            cobj.compress(b"foo")
 
         # Try another operation on this instance.
-        with self.assertRaisesRegexp(zstd.ZstdError, 'Src size is incorrect'):
-            cobj.compress(b'aa')
+        with self.assertRaisesRegex(zstd.ZstdError, "Src size is incorrect"):
+            cobj.compress(b"aa")
 
         # Try another operation on the compressor.
         cctx.compressobj(size=4)
-        cctx.compress(b'foobar')
+        cctx.compress(b"foobar")
 
 
 @make_cffi
-class TestCompressor_copy_stream(unittest.TestCase):
+class TestCompressor_copy_stream(TestCase):
     def test_no_read(self):
         source = object()
         dest = io.BytesIO()
 
         cctx = zstd.ZstdCompressor()
         with self.assertRaises(ValueError):
             cctx.copy_stream(source, dest)
 
     def test_no_write(self):
         source = io.BytesIO()
         dest = object()
 
         cctx = zstd.ZstdCompressor()
         with self.assertRaises(ValueError):
             cctx.copy_stream(source, dest)
 
     def test_empty(self):
         source = io.BytesIO()
         dest = io.BytesIO()
 
         cctx = zstd.ZstdCompressor(level=1, write_content_size=False)
         r, w = cctx.copy_stream(source, dest)
         self.assertEqual(int(r), 0)
         self.assertEqual(w, 9)
 
-        self.assertEqual(dest.getvalue(),
-                         b'\x28\xb5\x2f\xfd\x00\x48\x01\x00\x00')
+        self.assertEqual(dest.getvalue(), b"\x28\xb5\x2f\xfd\x00\x48\x01\x00\x00")
 
     def test_large_data(self):
         source = io.BytesIO()
         for i in range(255):
-            source.write(struct.Struct('>B').pack(i) * 16384)
+            source.write(struct.Struct(">B").pack(i) * 16384)
         source.seek(0)
 
         dest = io.BytesIO()
         cctx = zstd.ZstdCompressor()
         r, w = cctx.copy_stream(source, dest)
 
         self.assertEqual(r, 255 * 16384)
         self.assertEqual(w, 999)
 
         params = zstd.get_frame_parameters(dest.getvalue())
         self.assertEqual(params.content_size, zstd.CONTENTSIZE_UNKNOWN)
         self.assertEqual(params.window_size, 2097152)
         self.assertEqual(params.dict_id, 0)
         self.assertFalse(params.has_checksum)
 
     def test_write_checksum(self):
-        source = io.BytesIO(b'foobar')
+        source = io.BytesIO(b"foobar")
         no_checksum = io.BytesIO()
 
         cctx = zstd.ZstdCompressor(level=1)
         cctx.copy_stream(source, no_checksum)
 
         source.seek(0)
         with_checksum = io.BytesIO()
         cctx = zstd.ZstdCompressor(level=1, write_checksum=True)
         cctx.copy_stream(source, with_checksum)
 
-        self.assertEqual(len(with_checksum.getvalue()),
-                         len(no_checksum.getvalue()) + 4)
+        self.assertEqual(len(with_checksum.getvalue()), len(no_checksum.getvalue()) + 4)
 
         no_params = zstd.get_frame_parameters(no_checksum.getvalue())
         with_params = zstd.get_frame_parameters(with_checksum.getvalue())
         self.assertEqual(no_params.content_size, zstd.CONTENTSIZE_UNKNOWN)
         self.assertEqual(with_params.content_size, zstd.CONTENTSIZE_UNKNOWN)
         self.assertEqual(no_params.dict_id, 0)
         self.assertEqual(with_params.dict_id, 0)
         self.assertFalse(no_params.has_checksum)
         self.assertTrue(with_params.has_checksum)
 
     def test_write_content_size(self):
-        source = io.BytesIO(b'foobar' * 256)
+        source = io.BytesIO(b"foobar" * 256)
         no_size = io.BytesIO()
 
         cctx = zstd.ZstdCompressor(level=1, write_content_size=False)
         cctx.copy_stream(source, no_size)
 
         source.seek(0)
         with_size = io.BytesIO()
         cctx = zstd.ZstdCompressor(level=1)
         cctx.copy_stream(source, with_size)
 
         # Source content size is unknown, so no content size written.
-        self.assertEqual(len(with_size.getvalue()),
-                         len(no_size.getvalue()))
+        self.assertEqual(len(with_size.getvalue()), len(no_size.getvalue()))
 
         source.seek(0)
         with_size = io.BytesIO()
         cctx.copy_stream(source, with_size, size=len(source.getvalue()))
 
         # We specified source size, so content size header is present.
-        self.assertEqual(len(with_size.getvalue()),
-                         len(no_size.getvalue()) + 1)
+        self.assertEqual(len(with_size.getvalue()), len(no_size.getvalue()) + 1)
 
         no_params = zstd.get_frame_parameters(no_size.getvalue())
         with_params = zstd.get_frame_parameters(with_size.getvalue())
         self.assertEqual(no_params.content_size, zstd.CONTENTSIZE_UNKNOWN)
         self.assertEqual(with_params.content_size, 1536)
         self.assertEqual(no_params.dict_id, 0)
         self.assertEqual(with_params.dict_id, 0)
         self.assertFalse(no_params.has_checksum)
         self.assertFalse(with_params.has_checksum)
 
     def test_read_write_size(self):
-        source = OpCountingBytesIO(b'foobarfoobar')
+        source = OpCountingBytesIO(b"foobarfoobar")
         dest = OpCountingBytesIO()
         cctx = zstd.ZstdCompressor()
         r, w = cctx.copy_stream(source, dest, read_size=1, write_size=1)
 
         self.assertEqual(r, len(source.getvalue()))
         self.assertEqual(w, 21)
         self.assertEqual(source._read_count, len(source.getvalue()) + 1)
         self.assertEqual(dest._write_count, len(dest.getvalue()))
 
     def test_multithreaded(self):
         source = io.BytesIO()
-        source.write(b'a' * 1048576)
-        source.write(b'b' * 1048576)
-        source.write(b'c' * 1048576)
+        source.write(b"a" * 1048576)
+        source.write(b"b" * 1048576)
+        source.write(b"c" * 1048576)
         source.seek(0)
 
         dest = io.BytesIO()
         cctx = zstd.ZstdCompressor(threads=2, write_content_size=False)
         r, w = cctx.copy_stream(source, dest)
         self.assertEqual(r, 3145728)
-        self.assertEqual(w, 295)
+        self.assertEqual(w, 111)
 
         params = zstd.get_frame_parameters(dest.getvalue())
         self.assertEqual(params.content_size, zstd.CONTENTSIZE_UNKNOWN)
         self.assertEqual(params.dict_id, 0)
         self.assertFalse(params.has_checksum)
 
         # Writing content size and checksum works.
         cctx = zstd.ZstdCompressor(threads=2, write_checksum=True)
         dest = io.BytesIO()
         source.seek(0)
         cctx.copy_stream(source, dest, size=len(source.getvalue()))
 
         params = zstd.get_frame_parameters(dest.getvalue())
         self.assertEqual(params.content_size, 3145728)
         self.assertEqual(params.dict_id, 0)
         self.assertTrue(params.has_checksum)
 
     def test_bad_size(self):
         source = io.BytesIO()
-        source.write(b'a' * 32768)
-        source.write(b'b' * 32768)
+        source.write(b"a" * 32768)
+        source.write(b"b" * 32768)
         source.seek(0)
 
         dest = io.BytesIO()
 
         cctx = zstd.ZstdCompressor()
 
-        with self.assertRaisesRegexp(zstd.ZstdError, 'Src size is incorrect'):
+        with self.assertRaisesRegex(zstd.ZstdError, "Src size is incorrect"):
             cctx.copy_stream(source, dest, size=42)
 
         # Try another operation on this compressor.
         source.seek(0)
         dest = io.BytesIO()
         cctx.copy_stream(source, dest)
 
 
 @make_cffi
-class TestCompressor_stream_reader(unittest.TestCase):
+class TestCompressor_stream_reader(TestCase):
     def test_context_manager(self):
         cctx = zstd.ZstdCompressor()
 
-        with cctx.stream_reader(b'foo') as reader:
-            with self.assertRaisesRegexp(ValueError, 'cannot __enter__ multiple times'):
+        with cctx.stream_reader(b"foo") as reader:
+            with self.assertRaisesRegex(ValueError, "cannot __enter__ multiple times"):
                 with reader as reader2:
                     pass
 
     def test_no_context_manager(self):
         cctx = zstd.ZstdCompressor()
 
-        reader = cctx.stream_reader(b'foo')
+        reader = cctx.stream_reader(b"foo")
         reader.read(4)
         self.assertFalse(reader.closed)
 
         reader.close()
         self.assertTrue(reader.closed)
-        with self.assertRaisesRegexp(ValueError, 'stream is closed'):
+        with self.assertRaisesRegex(ValueError, "stream is closed"):
             reader.read(1)
 
     def test_not_implemented(self):
         cctx = zstd.ZstdCompressor()
 
-        with cctx.stream_reader(b'foo' * 60) as reader:
+        with cctx.stream_reader(b"foo" * 60) as reader:
             with self.assertRaises(io.UnsupportedOperation):
                 reader.readline()
 
             with self.assertRaises(io.UnsupportedOperation):
                 reader.readlines()
 
             with self.assertRaises(io.UnsupportedOperation):
                 iter(reader)
 
             with self.assertRaises(io.UnsupportedOperation):
                 next(reader)
 
             with self.assertRaises(OSError):
                 reader.writelines([])
 
             with self.assertRaises(OSError):
-                reader.write(b'foo')
+                reader.write(b"foo")
 
     def test_constant_methods(self):
         cctx = zstd.ZstdCompressor()
 
-        with cctx.stream_reader(b'boo') as reader:
+        with cctx.stream_reader(b"boo") as reader:
             self.assertTrue(reader.readable())
             self.assertFalse(reader.writable())
             self.assertFalse(reader.seekable())
             self.assertFalse(reader.isatty())
             self.assertFalse(reader.closed)
             self.assertIsNone(reader.flush())
             self.assertFalse(reader.closed)
 
         self.assertTrue(reader.closed)
 
     def test_read_closed(self):
         cctx = zstd.ZstdCompressor()
 
-        with cctx.stream_reader(b'foo' * 60) as reader:
+        with cctx.stream_reader(b"foo" * 60) as reader:
             reader.close()
             self.assertTrue(reader.closed)
-            with self.assertRaisesRegexp(ValueError, 'stream is closed'):
+            with self.assertRaisesRegex(ValueError, "stream is closed"):
                 reader.read(10)
 
     def test_read_sizes(self):
         cctx = zstd.ZstdCompressor()
-        foo = cctx.compress(b'foo')
+        foo = cctx.compress(b"foo")
 
-        with cctx.stream_reader(b'foo') as reader:
-            with self.assertRaisesRegexp(ValueError, 'cannot read negative amounts less than -1'):
+        with cctx.stream_reader(b"foo") as reader:
+            with self.assertRaisesRegex(
+                ValueError, "cannot read negative amounts less than -1"
+            ):
                 reader.read(-2)
 
-            self.assertEqual(reader.read(0), b'')
+            self.assertEqual(reader.read(0), b"")
             self.assertEqual(reader.read(), foo)
 
     def test_read_buffer(self):
         cctx = zstd.ZstdCompressor()
 
-        source = b''.join([b'foo' * 60, b'bar' * 60, b'baz' * 60])
+        source = b"".join([b"foo" * 60, b"bar" * 60, b"baz" * 60])
         frame = cctx.compress(source)
 
         with cctx.stream_reader(source) as reader:
             self.assertEqual(reader.tell(), 0)
 
             # We should get entire frame in one read.
             result = reader.read(8192)
             self.assertEqual(result, frame)
             self.assertEqual(reader.tell(), len(result))
-            self.assertEqual(reader.read(), b'')
+            self.assertEqual(reader.read(), b"")
             self.assertEqual(reader.tell(), len(result))
 
     def test_read_buffer_small_chunks(self):
         cctx = zstd.ZstdCompressor()
 
-        source = b'foo' * 60
+        source = b"foo" * 60
         chunks = []
 
         with cctx.stream_reader(source) as reader:
             self.assertEqual(reader.tell(), 0)
 
             while True:
                 chunk = reader.read(1)
                 if not chunk:
                     break
 
                 chunks.append(chunk)
                 self.assertEqual(reader.tell(), sum(map(len, chunks)))
 
-        self.assertEqual(b''.join(chunks), cctx.compress(source))
+        self.assertEqual(b"".join(chunks), cctx.compress(source))
 
     def test_read_stream(self):
         cctx = zstd.ZstdCompressor()
 
-        source = b''.join([b'foo' * 60, b'bar' * 60, b'baz' * 60])
+        source = b"".join([b"foo" * 60, b"bar" * 60, b"baz" * 60])
         frame = cctx.compress(source)
 
         with cctx.stream_reader(io.BytesIO(source), size=len(source)) as reader:
             self.assertEqual(reader.tell(), 0)
 
             chunk = reader.read(8192)
             self.assertEqual(chunk, frame)
             self.assertEqual(reader.tell(), len(chunk))
-            self.assertEqual(reader.read(), b'')
+            self.assertEqual(reader.read(), b"")
             self.assertEqual(reader.tell(), len(chunk))
 
     def test_read_stream_small_chunks(self):
         cctx = zstd.ZstdCompressor()
 
-        source = b'foo' * 60
+        source = b"foo" * 60
         chunks = []
 
         with cctx.stream_reader(io.BytesIO(source), size=len(source)) as reader:
             self.assertEqual(reader.tell(), 0)
 
             while True:
                 chunk = reader.read(1)
                 if not chunk:
                     break
 
                 chunks.append(chunk)
                 self.assertEqual(reader.tell(), sum(map(len, chunks)))
 
-        self.assertEqual(b''.join(chunks), cctx.compress(source))
+        self.assertEqual(b"".join(chunks), cctx.compress(source))
 
     def test_read_after_exit(self):
         cctx = zstd.ZstdCompressor()
 
-        with cctx.stream_reader(b'foo' * 60) as reader:
+        with cctx.stream_reader(b"foo" * 60) as reader:
             while reader.read(8192):
                 pass
 
-        with self.assertRaisesRegexp(ValueError, 'stream is closed'):
+        with self.assertRaisesRegex(ValueError, "stream is closed"):
             reader.read(10)
 
     def test_bad_size(self):
         cctx = zstd.ZstdCompressor()
 
-        source = io.BytesIO(b'foobar')
+        source = io.BytesIO(b"foobar")
 
         with cctx.stream_reader(source, size=2) as reader:
-            with self.assertRaisesRegexp(zstd.ZstdError, 'Src size is incorrect'):
+            with self.assertRaisesRegex(zstd.ZstdError, "Src size is incorrect"):
                 reader.read(10)
 
         # Try another compression operation.
         with cctx.stream_reader(source, size=42):
             pass
 
     def test_readall(self):
         cctx = zstd.ZstdCompressor()
-        frame = cctx.compress(b'foo' * 1024)
+        frame = cctx.compress(b"foo" * 1024)
 
-        reader = cctx.stream_reader(b'foo' * 1024)
+        reader = cctx.stream_reader(b"foo" * 1024)
         self.assertEqual(reader.readall(), frame)
 
     def test_readinto(self):
         cctx = zstd.ZstdCompressor()
-        foo = cctx.compress(b'foo')
+        foo = cctx.compress(b"foo")
 
-        reader = cctx.stream_reader(b'foo')
+        reader = cctx.stream_reader(b"foo")
         with self.assertRaises(Exception):
-            reader.readinto(b'foobar')
+            reader.readinto(b"foobar")
 
         # readinto() with sufficiently large destination.
         b = bytearray(1024)
-        reader = cctx.stream_reader(b'foo')
+        reader = cctx.stream_reader(b"foo")
         self.assertEqual(reader.readinto(b), len(foo))
-        self.assertEqual(b[0:len(foo)], foo)
+        self.assertEqual(b[0 : len(foo)], foo)
         self.assertEqual(reader.readinto(b), 0)
-        self.assertEqual(b[0:len(foo)], foo)
+        self.assertEqual(b[0 : len(foo)], foo)
 
         # readinto() with small reads.
         b = bytearray(1024)
-        reader = cctx.stream_reader(b'foo', read_size=1)
+        reader = cctx.stream_reader(b"foo", read_size=1)
         self.assertEqual(reader.readinto(b), len(foo))
-        self.assertEqual(b[0:len(foo)], foo)
+        self.assertEqual(b[0 : len(foo)], foo)
 
         # Too small destination buffer.
         b = bytearray(2)
-        reader = cctx.stream_reader(b'foo')
+        reader = cctx.stream_reader(b"foo")
         self.assertEqual(reader.readinto(b), 2)
         self.assertEqual(b[:], foo[0:2])
         self.assertEqual(reader.readinto(b), 2)
         self.assertEqual(b[:], foo[2:4])
         self.assertEqual(reader.readinto(b), 2)
         self.assertEqual(b[:], foo[4:6])
 
     def test_readinto1(self):
         cctx = zstd.ZstdCompressor()
-        foo = b''.join(cctx.read_to_iter(io.BytesIO(b'foo')))
+        foo = b"".join(cctx.read_to_iter(io.BytesIO(b"foo")))
 
-        reader = cctx.stream_reader(b'foo')
+        reader = cctx.stream_reader(b"foo")
         with self.assertRaises(Exception):
-            reader.readinto1(b'foobar')
+            reader.readinto1(b"foobar")
 
         b = bytearray(1024)
-        source = OpCountingBytesIO(b'foo')
+        source = OpCountingBytesIO(b"foo")
         reader = cctx.stream_reader(source)
         self.assertEqual(reader.readinto1(b), len(foo))
-        self.assertEqual(b[0:len(foo)], foo)
+        self.assertEqual(b[0 : len(foo)], foo)
         self.assertEqual(source._read_count, 2)
 
         # readinto1() with small reads.
         b = bytearray(1024)
-        source = OpCountingBytesIO(b'foo')
+        source = OpCountingBytesIO(b"foo")
         reader = cctx.stream_reader(source, read_size=1)
         self.assertEqual(reader.readinto1(b), len(foo))
-        self.assertEqual(b[0:len(foo)], foo)
+        self.assertEqual(b[0 : len(foo)], foo)
         self.assertEqual(source._read_count, 4)
 
     def test_read1(self):
         cctx = zstd.ZstdCompressor()
-        foo = b''.join(cctx.read_to_iter(io.BytesIO(b'foo')))
+        foo = b"".join(cctx.read_to_iter(io.BytesIO(b"foo")))
 
-        b = OpCountingBytesIO(b'foo')
+        b = OpCountingBytesIO(b"foo")
         reader = cctx.stream_reader(b)
 
         self.assertEqual(reader.read1(), foo)
         self.assertEqual(b._read_count, 2)
 
-        b = OpCountingBytesIO(b'foo')
+        b = OpCountingBytesIO(b"foo")
         reader = cctx.stream_reader(b)
 
-        self.assertEqual(reader.read1(0), b'')
+        self.assertEqual(reader.read1(0), b"")
         self.assertEqual(reader.read1(2), foo[0:2])
         self.assertEqual(b._read_count, 2)
         self.assertEqual(reader.read1(2), foo[2:4])
         self.assertEqual(reader.read1(1024), foo[4:])
 
 
 @make_cffi
-class TestCompressor_stream_writer(unittest.TestCase):
+class TestCompressor_stream_writer(TestCase):
     def test_io_api(self):
         buffer = io.BytesIO()
         cctx = zstd.ZstdCompressor()
         writer = cctx.stream_writer(buffer)
 
         self.assertFalse(writer.isatty())
         self.assertFalse(writer.readable())
 
         with self.assertRaises(io.UnsupportedOperation):
             writer.readline()
 
         with self.assertRaises(io.UnsupportedOperation):
             writer.readline(42)
 
         with self.assertRaises(io.UnsupportedOperation):
             writer.readline(size=42)
 
         with self.assertRaises(io.UnsupportedOperation):
             writer.readlines()
 
         with self.assertRaises(io.UnsupportedOperation):
             writer.readlines(42)
 
         with self.assertRaises(io.UnsupportedOperation):
             writer.readlines(hint=42)
 
         with self.assertRaises(io.UnsupportedOperation):
             writer.seek(0)
 
         with self.assertRaises(io.UnsupportedOperation):
             writer.seek(10, os.SEEK_SET)
 
         self.assertFalse(writer.seekable())
 
         with self.assertRaises(io.UnsupportedOperation):
             writer.truncate()
 
         with self.assertRaises(io.UnsupportedOperation):
             writer.truncate(42)
 
         with self.assertRaises(io.UnsupportedOperation):
             writer.truncate(size=42)
 
         self.assertTrue(writer.writable())
 
         with self.assertRaises(NotImplementedError):
             writer.writelines([])
 
         with self.assertRaises(io.UnsupportedOperation):
             writer.read()
 
         with self.assertRaises(io.UnsupportedOperation):
             writer.read(42)
 
         with self.assertRaises(io.UnsupportedOperation):
             writer.read(size=42)
 
         with self.assertRaises(io.UnsupportedOperation):
             writer.readall()
 
         with self.assertRaises(io.UnsupportedOperation):
             writer.readinto(None)
 
         with self.assertRaises(io.UnsupportedOperation):
             writer.fileno()
 
         self.assertFalse(writer.closed)
 
     def test_fileno_file(self):
-        with tempfile.TemporaryFile('wb') as tf:
+        with tempfile.TemporaryFile("wb") as tf:
             cctx = zstd.ZstdCompressor()
             writer = cctx.stream_writer(tf)
 
             self.assertEqual(writer.fileno(), tf.fileno())
 
     def test_close(self):
         buffer = NonClosingBytesIO()
         cctx = zstd.ZstdCompressor(level=1)
         writer = cctx.stream_writer(buffer)
 
-        writer.write(b'foo' * 1024)
+        writer.write(b"foo" * 1024)
         self.assertFalse(writer.closed)
         self.assertFalse(buffer.closed)
         writer.close()
         self.assertTrue(writer.closed)
         self.assertTrue(buffer.closed)
 
-        with self.assertRaisesRegexp(ValueError, 'stream is closed'):
-            writer.write(b'foo')
+        with self.assertRaisesRegex(ValueError, "stream is closed"):
+            writer.write(b"foo")
 
-        with self.assertRaisesRegexp(ValueError, 'stream is closed'):
+        with self.assertRaisesRegex(ValueError, "stream is closed"):
             writer.flush()
 
-        with self.assertRaisesRegexp(ValueError, 'stream is closed'):
+        with self.assertRaisesRegex(ValueError, "stream is closed"):
             with writer:
                 pass
 
-        self.assertEqual(buffer.getvalue(),
-                         b'\x28\xb5\x2f\xfd\x00\x48\x55\x00\x00\x18\x66\x6f'
-                         b'\x6f\x01\x00\xfa\xd3\x77\x43')
+        self.assertEqual(
+            buffer.getvalue(),
+            b"\x28\xb5\x2f\xfd\x00\x48\x55\x00\x00\x18\x66\x6f"
+            b"\x6f\x01\x00\xfa\xd3\x77\x43",
+        )
 
         # Context manager exit should close stream.
         buffer = io.BytesIO()
         writer = cctx.stream_writer(buffer)
 
         with writer:
-            writer.write(b'foo')
+            writer.write(b"foo")
 
         self.assertTrue(writer.closed)
 
     def test_empty(self):
         buffer = NonClosingBytesIO()
         cctx = zstd.ZstdCompressor(level=1, write_content_size=False)
         with cctx.stream_writer(buffer) as compressor:
-            compressor.write(b'')
+            compressor.write(b"")
 
         result = buffer.getvalue()
-        self.assertEqual(result, b'\x28\xb5\x2f\xfd\x00\x48\x01\x00\x00')
+        self.assertEqual(result, b"\x28\xb5\x2f\xfd\x00\x48\x01\x00\x00")
 
         params = zstd.get_frame_parameters(result)
         self.assertEqual(params.content_size, zstd.CONTENTSIZE_UNKNOWN)
         self.assertEqual(params.window_size, 524288)
         self.assertEqual(params.dict_id, 0)
         self.assertFalse(params.has_checksum)
 
         # Test without context manager.
         buffer = io.BytesIO()
         compressor = cctx.stream_writer(buffer)
-        self.assertEqual(compressor.write(b''), 0)
-        self.assertEqual(buffer.getvalue(), b'')
+        self.assertEqual(compressor.write(b""), 0)
+        self.assertEqual(buffer.getvalue(), b"")
         self.assertEqual(compressor.flush(zstd.FLUSH_FRAME), 9)
         result = buffer.getvalue()
-        self.assertEqual(result, b'\x28\xb5\x2f\xfd\x00\x48\x01\x00\x00')
+        self.assertEqual(result, b"\x28\xb5\x2f\xfd\x00\x48\x01\x00\x00")
 
         params = zstd.get_frame_parameters(result)
         self.assertEqual(params.content_size, zstd.CONTENTSIZE_UNKNOWN)
         self.assertEqual(params.window_size, 524288)
         self.assertEqual(params.dict_id, 0)
         self.assertFalse(params.has_checksum)
 
         # Test write_return_read=True
         compressor = cctx.stream_writer(buffer, write_return_read=True)
-        self.assertEqual(compressor.write(b''), 0)
+        self.assertEqual(compressor.write(b""), 0)
 
     def test_input_types(self):
-        expected = b'\x28\xb5\x2f\xfd\x00\x48\x19\x00\x00\x66\x6f\x6f'
+        expected = b"\x28\xb5\x2f\xfd\x00\x48\x19\x00\x00\x66\x6f\x6f"
         cctx = zstd.ZstdCompressor(level=1)
 
         mutable_array = bytearray(3)
-        mutable_array[:] = b'foo'
+        mutable_array[:] = b"foo"
 
         sources = [
-            memoryview(b'foo'),
-            bytearray(b'foo'),
+            memoryview(b"foo"),
+            bytearray(b"foo"),
             mutable_array,
         ]
 
         for source in sources:
             buffer = NonClosingBytesIO()
             with cctx.stream_writer(buffer) as compressor:
                 compressor.write(source)
 
             self.assertEqual(buffer.getvalue(), expected)
 
             compressor = cctx.stream_writer(buffer, write_return_read=True)
             self.assertEqual(compressor.write(source), len(source))
 
     def test_multiple_compress(self):
         buffer = NonClosingBytesIO()
         cctx = zstd.ZstdCompressor(level=5)
         with cctx.stream_writer(buffer) as compressor:
-            self.assertEqual(compressor.write(b'foo'), 0)
-            self.assertEqual(compressor.write(b'bar'), 0)
-            self.assertEqual(compressor.write(b'x' * 8192), 0)
+            self.assertEqual(compressor.write(b"foo"), 0)
+            self.assertEqual(compressor.write(b"bar"), 0)
+            self.assertEqual(compressor.write(b"x" * 8192), 0)
 
         result = buffer.getvalue()
-        self.assertEqual(result,
-                         b'\x28\xb5\x2f\xfd\x00\x58\x75\x00\x00\x38\x66\x6f'
-                         b'\x6f\x62\x61\x72\x78\x01\x00\xfc\xdf\x03\x23')
+        self.assertEqual(
+            result,
+            b"\x28\xb5\x2f\xfd\x00\x58\x75\x00\x00\x38\x66\x6f"
+            b"\x6f\x62\x61\x72\x78\x01\x00\xfc\xdf\x03\x23",
+        )
 
         # Test without context manager.
         buffer = io.BytesIO()
         compressor = cctx.stream_writer(buffer)
-        self.assertEqual(compressor.write(b'foo'), 0)
-        self.assertEqual(compressor.write(b'bar'), 0)
-        self.assertEqual(compressor.write(b'x' * 8192), 0)
+        self.assertEqual(compressor.write(b"foo"), 0)
+        self.assertEqual(compressor.write(b"bar"), 0)
+        self.assertEqual(compressor.write(b"x" * 8192), 0)
         self.assertEqual(compressor.flush(zstd.FLUSH_FRAME), 23)
         result = buffer.getvalue()
-        self.assertEqual(result,
-                         b'\x28\xb5\x2f\xfd\x00\x58\x75\x00\x00\x38\x66\x6f'
-                         b'\x6f\x62\x61\x72\x78\x01\x00\xfc\xdf\x03\x23')
+        self.assertEqual(
+            result,
+            b"\x28\xb5\x2f\xfd\x00\x58\x75\x00\x00\x38\x66\x6f"
+            b"\x6f\x62\x61\x72\x78\x01\x00\xfc\xdf\x03\x23",
+        )
 
         # Test with write_return_read=True.
         compressor = cctx.stream_writer(buffer, write_return_read=True)
-        self.assertEqual(compressor.write(b'foo'), 3)
-        self.assertEqual(compressor.write(b'barbiz'), 6)
-        self.assertEqual(compressor.write(b'x' * 8192), 8192)
+        self.assertEqual(compressor.write(b"foo"), 3)
+        self.assertEqual(compressor.write(b"barbiz"), 6)
+        self.assertEqual(compressor.write(b"x" * 8192), 8192)
 
     def test_dictionary(self):
         samples = []
         for i in range(128):
-            samples.append(b'foo' * 64)
-            samples.append(b'bar' * 64)
-            samples.append(b'foobar' * 64)
+            samples.append(b"foo" * 64)
+            samples.append(b"bar" * 64)
+            samples.append(b"foobar" * 64)
 
         d = zstd.train_dictionary(8192, samples)
 
         h = hashlib.sha1(d.as_bytes()).hexdigest()
-        self.assertEqual(h, '7a2e59a876db958f74257141045af8f912e00d4e')
+        self.assertEqual(h, "7a2e59a876db958f74257141045af8f912e00d4e")
 
         buffer = NonClosingBytesIO()
         cctx = zstd.ZstdCompressor(level=9, dict_data=d)
         with cctx.stream_writer(buffer) as compressor:
-            self.assertEqual(compressor.write(b'foo'), 0)
-            self.assertEqual(compressor.write(b'bar'), 0)
-            self.assertEqual(compressor.write(b'foo' * 16384), 0)
+            self.assertEqual(compressor.write(b"foo"), 0)
+            self.assertEqual(compressor.write(b"bar"), 0)
+            self.assertEqual(compressor.write(b"foo" * 16384), 0)
 
         compressed = buffer.getvalue()
 
         params = zstd.get_frame_parameters(compressed)
         self.assertEqual(params.content_size, zstd.CONTENTSIZE_UNKNOWN)
         self.assertEqual(params.window_size, 2097152)
         self.assertEqual(params.dict_id, d.dict_id())
         self.assertFalse(params.has_checksum)
 
         h = hashlib.sha1(compressed).hexdigest()
-        self.assertEqual(h, '0a7c05635061f58039727cdbe76388c6f4cfef06')
+        self.assertEqual(h, "0a7c05635061f58039727cdbe76388c6f4cfef06")
 
-        source = b'foo' + b'bar' + (b'foo' * 16384)
+        source = b"foo" + b"bar" + (b"foo" * 16384)
 
         dctx = zstd.ZstdDecompressor(dict_data=d)
 
-        self.assertEqual(dctx.decompress(compressed, max_output_size=len(source)),
-                         source)
+        self.assertEqual(
+            dctx.decompress(compressed, max_output_size=len(source)), source
+        )
 
     def test_compression_params(self):
         params = zstd.ZstdCompressionParameters(
             window_log=20,
             chain_log=6,
             hash_log=12,
             min_match=5,
             search_log=4,
             target_length=10,
-            strategy=zstd.STRATEGY_FAST)
+            strategy=zstd.STRATEGY_FAST,
+        )
 
         buffer = NonClosingBytesIO()
         cctx = zstd.ZstdCompressor(compression_params=params)
         with cctx.stream_writer(buffer) as compressor:
-            self.assertEqual(compressor.write(b'foo'), 0)
-            self.assertEqual(compressor.write(b'bar'), 0)
-            self.assertEqual(compressor.write(b'foobar' * 16384), 0)
+            self.assertEqual(compressor.write(b"foo"), 0)
+            self.assertEqual(compressor.write(b"bar"), 0)
+            self.assertEqual(compressor.write(b"foobar" * 16384), 0)
 
         compressed = buffer.getvalue()
 
         params = zstd.get_frame_parameters(compressed)
         self.assertEqual(params.content_size, zstd.CONTENTSIZE_UNKNOWN)
         self.assertEqual(params.window_size, 1048576)
         self.assertEqual(params.dict_id, 0)
         self.assertFalse(params.has_checksum)
 
         h = hashlib.sha1(compressed).hexdigest()
-        self.assertEqual(h, 'dd4bb7d37c1a0235b38a2f6b462814376843ef0b')
+        self.assertEqual(h, "dd4bb7d37c1a0235b38a2f6b462814376843ef0b")
 
     def test_write_checksum(self):
         no_checksum = NonClosingBytesIO()
         cctx = zstd.ZstdCompressor(level=1)
         with cctx.stream_writer(no_checksum) as compressor:
-            self.assertEqual(compressor.write(b'foobar'), 0)
+            self.assertEqual(compressor.write(b"foobar"), 0)
 
         with_checksum = NonClosingBytesIO()
         cctx = zstd.ZstdCompressor(level=1, write_checksum=True)
         with cctx.stream_writer(with_checksum) as compressor:
-            self.assertEqual(compressor.write(b'foobar'), 0)
+            self.assertEqual(compressor.write(b"foobar"), 0)
 
         no_params = zstd.get_frame_parameters(no_checksum.getvalue())
         with_params = zstd.get_frame_parameters(with_checksum.getvalue())
         self.assertEqual(no_params.content_size, zstd.CONTENTSIZE_UNKNOWN)
         self.assertEqual(with_params.content_size, zstd.CONTENTSIZE_UNKNOWN)
         self.assertEqual(no_params.dict_id, 0)
         self.assertEqual(with_params.dict_id, 0)
         self.assertFalse(no_params.has_checksum)
         self.assertTrue(with_params.has_checksum)
 
-        self.assertEqual(len(with_checksum.getvalue()),
-                         len(no_checksum.getvalue()) + 4)
+        self.assertEqual(len(with_checksum.getvalue()), len(no_checksum.getvalue()) + 4)
 
     def test_write_content_size(self):
         no_size = NonClosingBytesIO()
         cctx = zstd.ZstdCompressor(level=1, write_content_size=False)
         with cctx.stream_writer(no_size) as compressor:
-            self.assertEqual(compressor.write(b'foobar' * 256), 0)
+            self.assertEqual(compressor.write(b"foobar" * 256), 0)
 
         with_size = NonClosingBytesIO()
         cctx = zstd.ZstdCompressor(level=1)
         with cctx.stream_writer(with_size) as compressor:
-            self.assertEqual(compressor.write(b'foobar' * 256), 0)
+            self.assertEqual(compressor.write(b"foobar" * 256), 0)
 
         # Source size is not known in streaming mode, so header not
         # written.
-        self.assertEqual(len(with_size.getvalue()),
-                         len(no_size.getvalue()))
+        self.assertEqual(len(with_size.getvalue()), len(no_size.getvalue()))
 
         # Declaring size will write the header.
         with_size = NonClosingBytesIO()
-        with cctx.stream_writer(with_size, size=len(b'foobar' * 256)) as compressor:
-            self.assertEqual(compressor.write(b'foobar' * 256), 0)
+        with cctx.stream_writer(with_size, size=len(b"foobar" * 256)) as compressor:
+            self.assertEqual(compressor.write(b"foobar" * 256), 0)
 
         no_params = zstd.get_frame_parameters(no_size.getvalue())
         with_params = zstd.get_frame_parameters(with_size.getvalue())
         self.assertEqual(no_params.content_size, zstd.CONTENTSIZE_UNKNOWN)
         self.assertEqual(with_params.content_size, 1536)
         self.assertEqual(no_params.dict_id, 0)
         self.assertEqual(with_params.dict_id, 0)
         self.assertFalse(no_params.has_checksum)
         self.assertFalse(with_params.has_checksum)
 
-        self.assertEqual(len(with_size.getvalue()),
-                         len(no_size.getvalue()) + 1)
+        self.assertEqual(len(with_size.getvalue()), len(no_size.getvalue()) + 1)
 
     def test_no_dict_id(self):
         samples = []
         for i in range(128):
-            samples.append(b'foo' * 64)
-            samples.append(b'bar' * 64)
-            samples.append(b'foobar' * 64)
+            samples.append(b"foo" * 64)
+            samples.append(b"bar" * 64)
+            samples.append(b"foobar" * 64)
 
         d = zstd.train_dictionary(1024, samples)
 
         with_dict_id = NonClosingBytesIO()
         cctx = zstd.ZstdCompressor(level=1, dict_data=d)
         with cctx.stream_writer(with_dict_id) as compressor:
-            self.assertEqual(compressor.write(b'foobarfoobar'), 0)
+            self.assertEqual(compressor.write(b"foobarfoobar"), 0)
 
-        self.assertEqual(with_dict_id.getvalue()[4:5], b'\x03')
+        self.assertEqual(with_dict_id.getvalue()[4:5], b"\x03")
 
         cctx = zstd.ZstdCompressor(level=1, dict_data=d, write_dict_id=False)
         no_dict_id = NonClosingBytesIO()
         with cctx.stream_writer(no_dict_id) as compressor:
-            self.assertEqual(compressor.write(b'foobarfoobar'), 0)
+            self.assertEqual(compressor.write(b"foobarfoobar"), 0)
 
-        self.assertEqual(no_dict_id.getvalue()[4:5], b'\x00')
+        self.assertEqual(no_dict_id.getvalue()[4:5], b"\x00")
 
         no_params = zstd.get_frame_parameters(no_dict_id.getvalue())
         with_params = zstd.get_frame_parameters(with_dict_id.getvalue())
         self.assertEqual(no_params.content_size, zstd.CONTENTSIZE_UNKNOWN)
         self.assertEqual(with_params.content_size, zstd.CONTENTSIZE_UNKNOWN)
         self.assertEqual(no_params.dict_id, 0)
         self.assertEqual(with_params.dict_id, d.dict_id())
         self.assertFalse(no_params.has_checksum)
         self.assertFalse(with_params.has_checksum)
 
-        self.assertEqual(len(with_dict_id.getvalue()),
-                         len(no_dict_id.getvalue()) + 4)
+        self.assertEqual(len(with_dict_id.getvalue()), len(no_dict_id.getvalue()) + 4)
 
     def test_memory_size(self):
         cctx = zstd.ZstdCompressor(level=3)
         buffer = io.BytesIO()
         with cctx.stream_writer(buffer) as compressor:
-            compressor.write(b'foo')
+            compressor.write(b"foo")
             size = compressor.memory_size()
 
         self.assertGreater(size, 100000)
 
     def test_write_size(self):
         cctx = zstd.ZstdCompressor(level=3)
         dest = OpCountingBytesIO()
         with cctx.stream_writer(dest, write_size=1) as compressor:
-            self.assertEqual(compressor.write(b'foo'), 0)
-            self.assertEqual(compressor.write(b'bar'), 0)
-            self.assertEqual(compressor.write(b'foobar'), 0)
+            self.assertEqual(compressor.write(b"foo"), 0)
+            self.assertEqual(compressor.write(b"bar"), 0)
+            self.assertEqual(compressor.write(b"foobar"), 0)
 
         self.assertEqual(len(dest.getvalue()), dest._write_count)
 
     def test_flush_repeated(self):
         cctx = zstd.ZstdCompressor(level=3)
         dest = OpCountingBytesIO()
         with cctx.stream_writer(dest) as compressor:
-            self.assertEqual(compressor.write(b'foo'), 0)
+            self.assertEqual(compressor.write(b"foo"), 0)
             self.assertEqual(dest._write_count, 0)
             self.assertEqual(compressor.flush(), 12)
             self.assertEqual(dest._write_count, 1)
-            self.assertEqual(compressor.write(b'bar'), 0)
+            self.assertEqual(compressor.write(b"bar"), 0)
             self.assertEqual(dest._write_count, 1)
             self.assertEqual(compressor.flush(), 6)
             self.assertEqual(dest._write_count, 2)
-            self.assertEqual(compressor.write(b'baz'), 0)
+            self.assertEqual(compressor.write(b"baz"), 0)
 
         self.assertEqual(dest._write_count, 3)
 
     def test_flush_empty_block(self):
         cctx = zstd.ZstdCompressor(level=3, write_checksum=True)
         dest = OpCountingBytesIO()
         with cctx.stream_writer(dest) as compressor:
-            self.assertEqual(compressor.write(b'foobar' * 8192), 0)
+            self.assertEqual(compressor.write(b"foobar" * 8192), 0)
             count = dest._write_count
             offset = dest.tell()
             self.assertEqual(compressor.flush(), 23)
             self.assertGreater(dest._write_count, count)
             self.assertGreater(dest.tell(), offset)
             offset = dest.tell()
             # Ending the write here should cause an empty block to be written
             # to denote end of frame.
 
         trailing = dest.getvalue()[offset:]
         # 3 bytes block header + 4 bytes frame checksum
         self.assertEqual(len(trailing), 7)
 
         header = trailing[0:3]
-        self.assertEqual(header, b'\x01\x00\x00')
+        self.assertEqual(header, b"\x01\x00\x00")
 
     def test_flush_frame(self):
         cctx = zstd.ZstdCompressor(level=3)
         dest = OpCountingBytesIO()
 
         with cctx.stream_writer(dest) as compressor:
-            self.assertEqual(compressor.write(b'foobar' * 8192), 0)
+            self.assertEqual(compressor.write(b"foobar" * 8192), 0)
             self.assertEqual(compressor.flush(zstd.FLUSH_FRAME), 23)
-            compressor.write(b'biz' * 16384)
+            compressor.write(b"biz" * 16384)
 
-        self.assertEqual(dest.getvalue(),
-                         # Frame 1.
-                         b'\x28\xb5\x2f\xfd\x00\x58\x75\x00\x00\x30\x66\x6f\x6f'
-                         b'\x62\x61\x72\x01\x00\xf7\xbf\xe8\xa5\x08'
-                         # Frame 2.
-                         b'\x28\xb5\x2f\xfd\x00\x58\x5d\x00\x00\x18\x62\x69\x7a'
-                         b'\x01\x00\xfa\x3f\x75\x37\x04')
+        self.assertEqual(
+            dest.getvalue(),
+            # Frame 1.
+            b"\x28\xb5\x2f\xfd\x00\x58\x75\x00\x00\x30\x66\x6f\x6f"
+            b"\x62\x61\x72\x01\x00\xf7\xbf\xe8\xa5\x08"
+            # Frame 2.
+            b"\x28\xb5\x2f\xfd\x00\x58\x5d\x00\x00\x18\x62\x69\x7a"
+            b"\x01\x00\xfa\x3f\x75\x37\x04",
+        )
 
     def test_bad_flush_mode(self):
         cctx = zstd.ZstdCompressor()
         dest = io.BytesIO()
         with cctx.stream_writer(dest) as compressor:
-            with self.assertRaisesRegexp(ValueError, 'unknown flush_mode: 42'):
+            with self.assertRaisesRegex(ValueError, "unknown flush_mode: 42"):
                 compressor.flush(flush_mode=42)
 
     def test_multithreaded(self):
         dest = NonClosingBytesIO()
         cctx = zstd.ZstdCompressor(threads=2)
         with cctx.stream_writer(dest) as compressor:
-            compressor.write(b'a' * 1048576)
-            compressor.write(b'b' * 1048576)
-            compressor.write(b'c' * 1048576)
+            compressor.write(b"a" * 1048576)
+            compressor.write(b"b" * 1048576)
+            compressor.write(b"c" * 1048576)
 
-        self.assertEqual(len(dest.getvalue()), 295)
+        self.assertEqual(len(dest.getvalue()), 111)
 
     def test_tell(self):
         dest = io.BytesIO()
         cctx = zstd.ZstdCompressor()
         with cctx.stream_writer(dest) as compressor:
             self.assertEqual(compressor.tell(), 0)
 
             for i in range(256):
-                compressor.write(b'foo' * (i + 1))
+                compressor.write(b"foo" * (i + 1))
                 self.assertEqual(compressor.tell(), dest.tell())
 
     def test_bad_size(self):
         cctx = zstd.ZstdCompressor()
 
         dest = io.BytesIO()
 
-        with self.assertRaisesRegexp(zstd.ZstdError, 'Src size is incorrect'):
+        with self.assertRaisesRegex(zstd.ZstdError, "Src size is incorrect"):
             with cctx.stream_writer(dest, size=2) as compressor:
-                compressor.write(b'foo')
+                compressor.write(b"foo")
 
         # Test another operation.
         with cctx.stream_writer(dest, size=42):
             pass
 
     def test_tarfile_compat(self):
         dest = NonClosingBytesIO()
         cctx = zstd.ZstdCompressor()
         with cctx.stream_writer(dest) as compressor:
-            with tarfile.open('tf', mode='w|', fileobj=compressor) as tf:
-                tf.add(__file__, 'test_compressor.py')
+            with tarfile.open("tf", mode="w|", fileobj=compressor) as tf:
+                tf.add(__file__, "test_compressor.py")
 
         dest = io.BytesIO(dest.getvalue())
 
         dctx = zstd.ZstdDecompressor()
         with dctx.stream_reader(dest) as reader:
-            with tarfile.open(mode='r|', fileobj=reader) as tf:
+            with tarfile.open(mode="r|", fileobj=reader) as tf:
                 for member in tf:
-                    self.assertEqual(member.name, 'test_compressor.py')
+                    self.assertEqual(member.name, "test_compressor.py")
 
 
 @make_cffi
-class TestCompressor_read_to_iter(unittest.TestCase):
+class TestCompressor_read_to_iter(TestCase):
     def test_type_validation(self):
         cctx = zstd.ZstdCompressor()
 
         # Object with read() works.
         for chunk in cctx.read_to_iter(io.BytesIO()):
             pass
 
         # Buffer protocol works.
-        for chunk in cctx.read_to_iter(b'foobar'):
+        for chunk in cctx.read_to_iter(b"foobar"):
             pass
 
-        with self.assertRaisesRegexp(ValueError, 'must pass an object with a read'):
+        with self.assertRaisesRegex(ValueError, "must pass an object with a read"):
             for chunk in cctx.read_to_iter(True):
                 pass
 
     def test_read_empty(self):
         cctx = zstd.ZstdCompressor(level=1, write_content_size=False)
 
         source = io.BytesIO()
         it = cctx.read_to_iter(source)
         chunks = list(it)
         self.assertEqual(len(chunks), 1)
-        compressed = b''.join(chunks)
-        self.assertEqual(compressed, b'\x28\xb5\x2f\xfd\x00\x48\x01\x00\x00')
+        compressed = b"".join(chunks)
+        self.assertEqual(compressed, b"\x28\xb5\x2f\xfd\x00\x48\x01\x00\x00")
 
         # And again with the buffer protocol.
-        it = cctx.read_to_iter(b'')
+        it = cctx.read_to_iter(b"")
         chunks = list(it)
         self.assertEqual(len(chunks), 1)
-        compressed2 = b''.join(chunks)
+        compressed2 = b"".join(chunks)
         self.assertEqual(compressed2, compressed)
 
     def test_read_large(self):
         cctx = zstd.ZstdCompressor(level=1, write_content_size=False)
 
         source = io.BytesIO()
-        source.write(b'f' * zstd.COMPRESSION_RECOMMENDED_INPUT_SIZE)
-        source.write(b'o')
+        source.write(b"f" * zstd.COMPRESSION_RECOMMENDED_INPUT_SIZE)
+        source.write(b"o")
         source.seek(0)
 
         # Creating an iterator should not perform any compression until
         # first read.
         it = cctx.read_to_iter(source, size=len(source.getvalue()))
         self.assertEqual(source.tell(), 0)
 
         # We should have exactly 2 output chunks.
         chunks = []
         chunk = next(it)
         self.assertIsNotNone(chunk)
         self.assertEqual(source.tell(), zstd.COMPRESSION_RECOMMENDED_INPUT_SIZE)
         chunks.append(chunk)
         chunk = next(it)
         self.assertIsNotNone(chunk)
         chunks.append(chunk)
 
         self.assertEqual(source.tell(), len(source.getvalue()))
 
         with self.assertRaises(StopIteration):
             next(it)
 
         # And again for good measure.
         with self.assertRaises(StopIteration):
             next(it)
 
         # We should get the same output as the one-shot compression mechanism.
-        self.assertEqual(b''.join(chunks), cctx.compress(source.getvalue()))
+        self.assertEqual(b"".join(chunks), cctx.compress(source.getvalue()))
 
-        params = zstd.get_frame_parameters(b''.join(chunks))
+        params = zstd.get_frame_parameters(b"".join(chunks))
         self.assertEqual(params.content_size, zstd.CONTENTSIZE_UNKNOWN)
         self.assertEqual(params.window_size, 262144)
         self.assertEqual(params.dict_id, 0)
         self.assertFalse(params.has_checksum)
 
         # Now check the buffer protocol.
         it = cctx.read_to_iter(source.getvalue())
         chunks = list(it)
         self.assertEqual(len(chunks), 2)
 
-        params = zstd.get_frame_parameters(b''.join(chunks))
+        params = zstd.get_frame_parameters(b"".join(chunks))
         self.assertEqual(params.content_size, zstd.CONTENTSIZE_UNKNOWN)
-        #self.assertEqual(params.window_size, 262144)
+        # self.assertEqual(params.window_size, 262144)
         self.assertEqual(params.dict_id, 0)
         self.assertFalse(params.has_checksum)
 
-        self.assertEqual(b''.join(chunks), cctx.compress(source.getvalue()))
+        self.assertEqual(b"".join(chunks), cctx.compress(source.getvalue()))
 
     def test_read_write_size(self):
-        source = OpCountingBytesIO(b'foobarfoobar')
+        source = OpCountingBytesIO(b"foobarfoobar")
         cctx = zstd.ZstdCompressor(level=3)
         for chunk in cctx.read_to_iter(source, read_size=1, write_size=1):
             self.assertEqual(len(chunk), 1)
 
         self.assertEqual(source._read_count, len(source.getvalue()) + 1)
 
     def test_multithreaded(self):
         source = io.BytesIO()
-        source.write(b'a' * 1048576)
-        source.write(b'b' * 1048576)
-        source.write(b'c' * 1048576)
+        source.write(b"a" * 1048576)
+        source.write(b"b" * 1048576)
+        source.write(b"c" * 1048576)
         source.seek(0)
 
         cctx = zstd.ZstdCompressor(threads=2)
 
-        compressed = b''.join(cctx.read_to_iter(source))
-        self.assertEqual(len(compressed), 295)
+        compressed = b"".join(cctx.read_to_iter(source))
+        self.assertEqual(len(compressed), 111)
 
     def test_bad_size(self):
         cctx = zstd.ZstdCompressor()
 
-        source = io.BytesIO(b'a' * 42)
+        source = io.BytesIO(b"a" * 42)
 
-        with self.assertRaisesRegexp(zstd.ZstdError, 'Src size is incorrect'):
-            b''.join(cctx.read_to_iter(source, size=2))
+        with self.assertRaisesRegex(zstd.ZstdError, "Src size is incorrect"):
+            b"".join(cctx.read_to_iter(source, size=2))
 
         # Test another operation on errored compressor.
-        b''.join(cctx.read_to_iter(source))
+        b"".join(cctx.read_to_iter(source))
 
 
 @make_cffi
-class TestCompressor_chunker(unittest.TestCase):
+class TestCompressor_chunker(TestCase):
     def test_empty(self):
         cctx = zstd.ZstdCompressor(write_content_size=False)
         chunker = cctx.chunker()
 
-        it = chunker.compress(b'')
+        it = chunker.compress(b"")
 
         with self.assertRaises(StopIteration):
             next(it)
 
         it = chunker.finish()
 
-        self.assertEqual(next(it), b'\x28\xb5\x2f\xfd\x00\x58\x01\x00\x00')
+        self.assertEqual(next(it), b"\x28\xb5\x2f\xfd\x00\x58\x01\x00\x00")
 
         with self.assertRaises(StopIteration):
             next(it)
 
     def test_simple_input(self):
         cctx = zstd.ZstdCompressor()
         chunker = cctx.chunker()
 
-        it = chunker.compress(b'foobar')
+        it = chunker.compress(b"foobar")
 
         with self.assertRaises(StopIteration):
             next(it)
 
-        it = chunker.compress(b'baz' * 30)
+        it = chunker.compress(b"baz" * 30)
 
         with self.assertRaises(StopIteration):
             next(it)
 
         it = chunker.finish()
 
-        self.assertEqual(next(it),
-                         b'\x28\xb5\x2f\xfd\x00\x58\x7d\x00\x00\x48\x66\x6f'
-                         b'\x6f\x62\x61\x72\x62\x61\x7a\x01\x00\xe4\xe4\x8e')
+        self.assertEqual(
+            next(it),
+            b"\x28\xb5\x2f\xfd\x00\x58\x7d\x00\x00\x48\x66\x6f"
+            b"\x6f\x62\x61\x72\x62\x61\x7a\x01\x00\xe4\xe4\x8e",
+        )
 
         with self.assertRaises(StopIteration):
             next(it)
 
     def test_input_size(self):
         cctx = zstd.ZstdCompressor()
         chunker = cctx.chunker(size=1024)
 
-        it = chunker.compress(b'x' * 1000)
+        it = chunker.compress(b"x" * 1000)
 
         with self.assertRaises(StopIteration):
             next(it)
 
-        it = chunker.compress(b'y' * 24)
+        it = chunker.compress(b"y" * 24)
 
         with self.assertRaises(StopIteration):
             next(it)
 
         chunks = list(chunker.finish())
 
-        self.assertEqual(chunks, [
-            b'\x28\xb5\x2f\xfd\x60\x00\x03\x65\x00\x00\x18\x78\x78\x79\x02\x00'
-            b'\xa0\x16\xe3\x2b\x80\x05'
-        ])
+        self.assertEqual(
+            chunks,
+            [
+                b"\x28\xb5\x2f\xfd\x60\x00\x03\x65\x00\x00\x18\x78\x78\x79\x02\x00"
+                b"\xa0\x16\xe3\x2b\x80\x05"
+            ],
+        )
 
         dctx = zstd.ZstdDecompressor()
 
-        self.assertEqual(dctx.decompress(b''.join(chunks)),
-                         (b'x' * 1000) + (b'y' * 24))
+        self.assertEqual(dctx.decompress(b"".join(chunks)), (b"x" * 1000) + (b"y" * 24))
 
     def test_small_chunk_size(self):
         cctx = zstd.ZstdCompressor()
         chunker = cctx.chunker(chunk_size=1)
 
-        chunks = list(chunker.compress(b'foo' * 1024))
+        chunks = list(chunker.compress(b"foo" * 1024))
         self.assertEqual(chunks, [])
 
         chunks = list(chunker.finish())
         self.assertTrue(all(len(chunk) == 1 for chunk in chunks))
 
         self.assertEqual(
-            b''.join(chunks),
-            b'\x28\xb5\x2f\xfd\x00\x58\x55\x00\x00\x18\x66\x6f\x6f\x01\x00'
-            b'\xfa\xd3\x77\x43')
+            b"".join(chunks),
+            b"\x28\xb5\x2f\xfd\x00\x58\x55\x00\x00\x18\x66\x6f\x6f\x01\x00"
+            b"\xfa\xd3\x77\x43",
+        )
 
         dctx = zstd.ZstdDecompressor()
-        self.assertEqual(dctx.decompress(b''.join(chunks),
-                                         max_output_size=10000),
-                         b'foo' * 1024)
+        self.assertEqual(
+            dctx.decompress(b"".join(chunks), max_output_size=10000), b"foo" * 1024
+        )
 
     def test_input_types(self):
         cctx = zstd.ZstdCompressor()
 
         mutable_array = bytearray(3)
-        mutable_array[:] = b'foo'
+        mutable_array[:] = b"foo"
 
         sources = [
-            memoryview(b'foo'),
-            bytearray(b'foo'),
+            memoryview(b"foo"),
+            bytearray(b"foo"),
             mutable_array,
         ]
 
         for source in sources:
             chunker = cctx.chunker()
 
             self.assertEqual(list(chunker.compress(source)), [])
-            self.assertEqual(list(chunker.finish()), [
-                b'\x28\xb5\x2f\xfd\x00\x58\x19\x00\x00\x66\x6f\x6f'
-            ])
+            self.assertEqual(
+                list(chunker.finish()),
+                [b"\x28\xb5\x2f\xfd\x00\x58\x19\x00\x00\x66\x6f\x6f"],
+            )
 
     def test_flush(self):
         cctx = zstd.ZstdCompressor()
         chunker = cctx.chunker()
 
-        self.assertEqual(list(chunker.compress(b'foo' * 1024)), [])
-        self.assertEqual(list(chunker.compress(b'bar' * 1024)), [])
+        self.assertEqual(list(chunker.compress(b"foo" * 1024)), [])
+        self.assertEqual(list(chunker.compress(b"bar" * 1024)), [])
 
         chunks1 = list(chunker.flush())
 
-        self.assertEqual(chunks1, [
-            b'\x28\xb5\x2f\xfd\x00\x58\x8c\x00\x00\x30\x66\x6f\x6f\x62\x61\x72'
-            b'\x02\x00\xfa\x03\xfe\xd0\x9f\xbe\x1b\x02'
-        ])
+        self.assertEqual(
+            chunks1,
+            [
+                b"\x28\xb5\x2f\xfd\x00\x58\x8c\x00\x00\x30\x66\x6f\x6f\x62\x61\x72"
+                b"\x02\x00\xfa\x03\xfe\xd0\x9f\xbe\x1b\x02"
+            ],
+        )
 
         self.assertEqual(list(chunker.flush()), [])
         self.assertEqual(list(chunker.flush()), [])
 
-        self.assertEqual(list(chunker.compress(b'baz' * 1024)), [])
+        self.assertEqual(list(chunker.compress(b"baz" * 1024)), [])
 
         chunks2 = list(chunker.flush())
         self.assertEqual(len(chunks2), 1)
 
         chunks3 = list(chunker.finish())
         self.assertEqual(len(chunks2), 1)
 
         dctx = zstd.ZstdDecompressor()
 
-        self.assertEqual(dctx.decompress(b''.join(chunks1 + chunks2 + chunks3),
-                                         max_output_size=10000),
-                         (b'foo' * 1024) + (b'bar' * 1024) + (b'baz' * 1024))
+        self.assertEqual(
+            dctx.decompress(
+                b"".join(chunks1 + chunks2 + chunks3), max_output_size=10000
+            ),
+            (b"foo" * 1024) + (b"bar" * 1024) + (b"baz" * 1024),
+        )
 
     def test_compress_after_finish(self):
         cctx = zstd.ZstdCompressor()
         chunker = cctx.chunker()
 
-        list(chunker.compress(b'foo'))
+        list(chunker.compress(b"foo"))
         list(chunker.finish())
 
-        with self.assertRaisesRegexp(
-                zstd.ZstdError,
-                r'cannot call compress\(\) after compression finished'):
-            list(chunker.compress(b'foo'))
+        with self.assertRaisesRegex(
+            zstd.ZstdError, r"cannot call compress\(\) after compression finished"
+        ):
+            list(chunker.compress(b"foo"))
 
     def test_flush_after_finish(self):
         cctx = zstd.ZstdCompressor()
         chunker = cctx.chunker()
 
-        list(chunker.compress(b'foo'))
+        list(chunker.compress(b"foo"))
         list(chunker.finish())
 
-        with self.assertRaisesRegexp(
-                zstd.ZstdError,
-                r'cannot call flush\(\) after compression finished'):
+        with self.assertRaisesRegex(
+            zstd.ZstdError, r"cannot call flush\(\) after compression finished"
+        ):
             list(chunker.flush())
 
     def test_finish_after_finish(self):
         cctx = zstd.ZstdCompressor()
         chunker = cctx.chunker()
 
-        list(chunker.compress(b'foo'))
+        list(chunker.compress(b"foo"))
         list(chunker.finish())
 
-        with self.assertRaisesRegexp(
-                zstd.ZstdError,
-                r'cannot call finish\(\) after compression finished'):
+        with self.assertRaisesRegex(
+            zstd.ZstdError, r"cannot call finish\(\) after compression finished"
+        ):
             list(chunker.finish())
 
 
-class TestCompressor_multi_compress_to_buffer(unittest.TestCase):
+class TestCompressor_multi_compress_to_buffer(TestCase):
     def test_invalid_inputs(self):
         cctx = zstd.ZstdCompressor()
 
-        if not hasattr(cctx, 'multi_compress_to_buffer'):
-            self.skipTest('multi_compress_to_buffer not available')
+        if not hasattr(cctx, "multi_compress_to_buffer"):
+            self.skipTest("multi_compress_to_buffer not available")
 
         with self.assertRaises(TypeError):
             cctx.multi_compress_to_buffer(True)
 
         with self.assertRaises(TypeError):
             cctx.multi_compress_to_buffer((1, 2))
 
-        with self.assertRaisesRegexp(TypeError, 'item 0 not a bytes like object'):
-            cctx.multi_compress_to_buffer([u'foo'])
+        with self.assertRaisesRegex(TypeError, "item 0 not a bytes like object"):
+            cctx.multi_compress_to_buffer([u"foo"])
 
     def test_empty_input(self):
         cctx = zstd.ZstdCompressor()
 
-        if not hasattr(cctx, 'multi_compress_to_buffer'):
-            self.skipTest('multi_compress_to_buffer not available')
+        if not hasattr(cctx, "multi_compress_to_buffer"):
+            self.skipTest("multi_compress_to_buffer not available")
 
-        with self.assertRaisesRegexp(ValueError, 'no source elements found'):
+        with self.assertRaisesRegex(ValueError, "no source elements found"):
             cctx.multi_compress_to_buffer([])
 
-        with self.assertRaisesRegexp(ValueError, 'source elements are empty'):
-            cctx.multi_compress_to_buffer([b'', b'', b''])
+        with self.assertRaisesRegex(ValueError, "source elements are empty"):
+            cctx.multi_compress_to_buffer([b"", b"", b""])
 
     def test_list_input(self):
         cctx = zstd.ZstdCompressor(write_checksum=True)
 
-        if not hasattr(cctx, 'multi_compress_to_buffer'):
-            self.skipTest('multi_compress_to_buffer not available')
+        if not hasattr(cctx, "multi_compress_to_buffer"):
+            self.skipTest("multi_compress_to_buffer not available")
 
-        original = [b'foo' * 12, b'bar' * 6]
+        original = [b"foo" * 12, b"bar" * 6]
         frames = [cctx.compress(c) for c in original]
         b = cctx.multi_compress_to_buffer(original)
 
         self.assertIsInstance(b, zstd.BufferWithSegmentsCollection)
 
         self.assertEqual(len(b), 2)
         self.assertEqual(b.size(), 44)
 
         self.assertEqual(b[0].tobytes(), frames[0])
         self.assertEqual(b[1].tobytes(), frames[1])
 
     def test_buffer_with_segments_input(self):
         cctx = zstd.ZstdCompressor(write_checksum=True)
 
-        if not hasattr(cctx, 'multi_compress_to_buffer'):
-            self.skipTest('multi_compress_to_buffer not available')
+        if not hasattr(cctx, "multi_compress_to_buffer"):
+            self.skipTest("multi_compress_to_buffer not available")
 
-        original = [b'foo' * 4, b'bar' * 6]
+        original = [b"foo" * 4, b"bar" * 6]
         frames = [cctx.compress(c) for c in original]
 
-        offsets = struct.pack('=QQQQ', 0, len(original[0]),
-                                       len(original[0]), len(original[1]))
-        segments = zstd.BufferWithSegments(b''.join(original), offsets)
+        offsets = struct.pack(
+            "=QQQQ", 0, len(original[0]), len(original[0]), len(original[1])
+        )
+        segments = zstd.BufferWithSegments(b"".join(original), offsets)
 
         result = cctx.multi_compress_to_buffer(segments)
 
         self.assertEqual(len(result), 2)
         self.assertEqual(result.size(), 47)
 
         self.assertEqual(result[0].tobytes(), frames[0])
         self.assertEqual(result[1].tobytes(), frames[1])
 
     def test_buffer_with_segments_collection_input(self):
         cctx = zstd.ZstdCompressor(write_checksum=True)
 
-        if not hasattr(cctx, 'multi_compress_to_buffer'):
-            self.skipTest('multi_compress_to_buffer not available')
+        if not hasattr(cctx, "multi_compress_to_buffer"):
+            self.skipTest("multi_compress_to_buffer not available")
 
         original = [
-            b'foo1',
-            b'foo2' * 2,
-            b'foo3' * 3,
-            b'foo4' * 4,
-            b'foo5' * 5,
+            b"foo1",
+            b"foo2" * 2,
+            b"foo3" * 3,
+            b"foo4" * 4,
+            b"foo5" * 5,
         ]
 
         frames = [cctx.compress(c) for c in original]
 
-        b = b''.join([original[0], original[1]])
-        b1 = zstd.BufferWithSegments(b, struct.pack('=QQQQ',
-                                                    0, len(original[0]),
-                                                    len(original[0]), len(original[1])))
-        b = b''.join([original[2], original[3], original[4]])
-        b2 = zstd.BufferWithSegments(b, struct.pack('=QQQQQQ',
-                                                    0, len(original[2]),
-                                                    len(original[2]), len(original[3]),
-                                                    len(original[2]) + len(original[3]), len(original[4])))
+        b = b"".join([original[0], original[1]])
+        b1 = zstd.BufferWithSegments(
+            b,
+            struct.pack(
+                "=QQQQ", 0, len(original[0]), len(original[0]), len(original[1])
+            ),
+        )
+        b = b"".join([original[2], original[3], original[4]])
+        b2 = zstd.BufferWithSegments(
+            b,
+            struct.pack(
+                "=QQQQQQ",
+                0,
+                len(original[2]),
+                len(original[2]),
+                len(original[3]),
+                len(original[2]) + len(original[3]),
+                len(original[4]),
+            ),
+        )
 
         c = zstd.BufferWithSegmentsCollection(b1, b2)
 
         result = cctx.multi_compress_to_buffer(c)
 
         self.assertEqual(len(result), len(frames))
 
         for i, frame in enumerate(frames):
             self.assertEqual(result[i].tobytes(), frame)
 
     def test_multiple_threads(self):
         # threads argument will cause multi-threaded ZSTD APIs to be used, which will
         # make output different.
         refcctx = zstd.ZstdCompressor(write_checksum=True)
-        reference = [refcctx.compress(b'x' * 64), refcctx.compress(b'y' * 64)]
+        reference = [refcctx.compress(b"x" * 64), refcctx.compress(b"y" * 64)]
 
         cctx = zstd.ZstdCompressor(write_checksum=True)
 
-        if not hasattr(cctx, 'multi_compress_to_buffer'):
-            self.skipTest('multi_compress_to_buffer not available')
+        if not hasattr(cctx, "multi_compress_to_buffer"):
+            self.skipTest("multi_compress_to_buffer not available")
 
         frames = []
-        frames.extend(b'x' * 64 for i in range(256))
-        frames.extend(b'y' * 64 for i in range(256))
+        frames.extend(b"x" * 64 for i in range(256))
+        frames.extend(b"y" * 64 for i in range(256))
 
         result = cctx.multi_compress_to_buffer(frames, threads=-1)
 
         self.assertEqual(len(result), 512)
         for i in range(512):
             if i < 256:
                 self.assertEqual(result[i].tobytes(), reference[0])
             else:
                 self.assertEqual(result[i].tobytes(), reference[1])

contrib/python-zstandard/tests/test_compressor_fuzzing.py

@@ -1,711 +1,836 b''
 import io
 import os
 import unittest
 
 try:
     import hypothesis
     import hypothesis.strategies as strategies
 except ImportError:
-    raise unittest.SkipTest('hypothesis not available')
+    raise unittest.SkipTest("hypothesis not available")
 
 import zstandard as zstd
 
-from . common import (
+from .common import (
     make_cffi,
     NonClosingBytesIO,
     random_input_data,
+    TestCase,
 )
 
 
[e-mail]('ZSTD_SLOW_TESTS' in os.environ, 'ZSTD_SLOW_TESTS not set')
[e-mail]("ZSTD_SLOW_TESTS" in os.environ, "ZSTD_SLOW_TESTS not set")
 @make_cffi
-class TestCompressor_stream_reader_fuzzing(unittest.TestCase):
+class TestCompressor_stream_reader_fuzzing(TestCase):
     @hypothesis.settings(
-        suppress_health_check=[hypothesis.HealthCheck.large_base_example])
-    @hypothesis.given(original=strategies.sampled_from(random_input_data()),
-                      level=strategies.integers(min_value=1, max_value=5),
-                      source_read_size=strategies.integers(1, 16384),
-                      read_size=strategies.integers(-1, zstd.COMPRESSION_RECOMMENDED_OUTPUT_SIZE))
-    def test_stream_source_read(self, original, level, source_read_size,
-                                read_size):
+        suppress_health_check=[hypothesis.HealthCheck.large_base_example]
+    )
+    @hypothesis.given(
+        original=strategies.sampled_from(random_input_data()),
+        level=strategies.integers(min_value=1, max_value=5),
+        source_read_size=strategies.integers(1, 16384),
+        read_size=strategies.integers(-1, zstd.COMPRESSION_RECOMMENDED_OUTPUT_SIZE),
+    )
+    def test_stream_source_read(self, original, level, source_read_size, read_size):
         if read_size == 0:
             read_size = -1
 
         refctx = zstd.ZstdCompressor(level=level)
         ref_frame = refctx.compress(original)
 
         cctx = zstd.ZstdCompressor(level=level)
-        with cctx.stream_reader(io.BytesIO(original), size=len(original),
-                                read_size=source_read_size) as reader:
+        with cctx.stream_reader(
+            io.BytesIO(original), size=len(original), read_size=source_read_size
+        ) as reader:
             chunks = []
             while True:
                 chunk = reader.read(read_size)
                 if not chunk:
                     break
 
                 chunks.append(chunk)
 
-        self.assertEqual(b''.join(chunks), ref_frame)
+        self.assertEqual(b"".join(chunks), ref_frame)
 
     @hypothesis.settings(
-        suppress_health_check=[hypothesis.HealthCheck.large_base_example])
-    @hypothesis.given(original=strategies.sampled_from(random_input_data()),
-                      level=strategies.integers(min_value=1, max_value=5),
-                      source_read_size=strategies.integers(1, 16384),
-                      read_size=strategies.integers(-1, zstd.COMPRESSION_RECOMMENDED_OUTPUT_SIZE))
-    def test_buffer_source_read(self, original, level, source_read_size,
-                                read_size):
+        suppress_health_check=[hypothesis.HealthCheck.large_base_example]
+    )
+    @hypothesis.given(
+        original=strategies.sampled_from(random_input_data()),
+        level=strategies.integers(min_value=1, max_value=5),
+        source_read_size=strategies.integers(1, 16384),
+        read_size=strategies.integers(-1, zstd.COMPRESSION_RECOMMENDED_OUTPUT_SIZE),
+    )
+    def test_buffer_source_read(self, original, level, source_read_size, read_size):
         if read_size == 0:
             read_size = -1
 
         refctx = zstd.ZstdCompressor(level=level)
         ref_frame = refctx.compress(original)
 
         cctx = zstd.ZstdCompressor(level=level)
-        with cctx.stream_reader(original, size=len(original),
-                                read_size=source_read_size) as reader:
+        with cctx.stream_reader(
+            original, size=len(original), read_size=source_read_size
+        ) as reader:
             chunks = []
             while True:
                 chunk = reader.read(read_size)
                 if not chunk:
                     break
 
                 chunks.append(chunk)
 
-        self.assertEqual(b''.join(chunks), ref_frame)
+        self.assertEqual(b"".join(chunks), ref_frame)
 
     @hypothesis.settings(
-        suppress_health_check=[hypothesis.HealthCheck.large_base_example])
-    @hypothesis.given(original=strategies.sampled_from(random_input_data()),
-                      level=strategies.integers(min_value=1, max_value=5),
-                      source_read_size=strategies.integers(1, 16384),
-                      read_sizes=strategies.data())
-    def test_stream_source_read_variance(self, original, level, source_read_size,
-                                         read_sizes):
+        suppress_health_check=[
+            hypothesis.HealthCheck.large_base_example,
+            hypothesis.HealthCheck.too_slow,
+        ]
+    )
+    @hypothesis.given(
+        original=strategies.sampled_from(random_input_data()),
+        level=strategies.integers(min_value=1, max_value=5),
+        source_read_size=strategies.integers(1, 16384),
+        read_sizes=strategies.data(),
+    )
+    def test_stream_source_read_variance(
+        self, original, level, source_read_size, read_sizes
+    ):
         refctx = zstd.ZstdCompressor(level=level)
         ref_frame = refctx.compress(original)
 
         cctx = zstd.ZstdCompressor(level=level)
-        with cctx.stream_reader(io.BytesIO(original), size=len(original),
-                                read_size=source_read_size) as reader:
+        with cctx.stream_reader(
+            io.BytesIO(original), size=len(original), read_size=source_read_size
+        ) as reader:
             chunks = []
             while True:
                 read_size = read_sizes.draw(strategies.integers(-1, 16384))
                 chunk = reader.read(read_size)
                 if not chunk and read_size:
                     break
 
                 chunks.append(chunk)
 
-        self.assertEqual(b''.join(chunks), ref_frame)
+        self.assertEqual(b"".join(chunks), ref_frame)
 
     @hypothesis.settings(
-        suppress_health_check=[hypothesis.HealthCheck.large_base_example])
-    @hypothesis.given(original=strategies.sampled_from(random_input_data()),
-                      level=strategies.integers(min_value=1, max_value=5),
-                      source_read_size=strategies.integers(1, 16384),
-                      read_sizes=strategies.data())
-    def test_buffer_source_read_variance(self, original, level, source_read_size,
-                                         read_sizes):
+        suppress_health_check=[
+            hypothesis.HealthCheck.large_base_example,
+            hypothesis.HealthCheck.too_slow,
+        ]
+    )
+    @hypothesis.given(
+        original=strategies.sampled_from(random_input_data()),
+        level=strategies.integers(min_value=1, max_value=5),
+        source_read_size=strategies.integers(1, 16384),
+        read_sizes=strategies.data(),
+    )
+    def test_buffer_source_read_variance(
+        self, original, level, source_read_size, read_sizes
+    ):
 
         refctx = zstd.ZstdCompressor(level=level)
         ref_frame = refctx.compress(original)
 
         cctx = zstd.ZstdCompressor(level=level)
-        with cctx.stream_reader(original, size=len(original),
-                                read_size=source_read_size) as reader:
+        with cctx.stream_reader(
+            original, size=len(original), read_size=source_read_size
+        ) as reader:
             chunks = []
             while True:
                 read_size = read_sizes.draw(strategies.integers(-1, 16384))
                 chunk = reader.read(read_size)
                 if not chunk and read_size:
                     break
 
                 chunks.append(chunk)
 
-        self.assertEqual(b''.join(chunks), ref_frame)
+        self.assertEqual(b"".join(chunks), ref_frame)
 
     @hypothesis.settings(
-        suppress_health_check=[hypothesis.HealthCheck.large_base_example])
-    @hypothesis.given(original=strategies.sampled_from(random_input_data()),
-                      level=strategies.integers(min_value=1, max_value=5),
-                      source_read_size=strategies.integers(1, 16384),
-                      read_size=strategies.integers(1, zstd.COMPRESSION_RECOMMENDED_OUTPUT_SIZE))
-    def test_stream_source_readinto(self, original, level,
-                                    source_read_size, read_size):
+        suppress_health_check=[hypothesis.HealthCheck.large_base_example]
+    )
+    @hypothesis.given(
+        original=strategies.sampled_from(random_input_data()),
+        level=strategies.integers(min_value=1, max_value=5),
+        source_read_size=strategies.integers(1, 16384),
+        read_size=strategies.integers(1, zstd.COMPRESSION_RECOMMENDED_OUTPUT_SIZE),
+    )
+    def test_stream_source_readinto(self, original, level, source_read_size, read_size):
         refctx = zstd.ZstdCompressor(level=level)
         ref_frame = refctx.compress(original)
 
         cctx = zstd.ZstdCompressor(level=level)
-        with cctx.stream_reader(io.BytesIO(original), size=len(original),
-                                read_size=source_read_size) as reader:
+        with cctx.stream_reader(
+            io.BytesIO(original), size=len(original), read_size=source_read_size
+        ) as reader:
             chunks = []
             while True:
                 b = bytearray(read_size)
                 count = reader.readinto(b)
 
                 if not count:
                     break
 
                 chunks.append(bytes(b[0:count]))
 
-        self.assertEqual(b''.join(chunks), ref_frame)
+        self.assertEqual(b"".join(chunks), ref_frame)
 
     @hypothesis.settings(
-        suppress_health_check=[hypothesis.HealthCheck.large_base_example])
-    @hypothesis.given(original=strategies.sampled_from(random_input_data()),
-                      level=strategies.integers(min_value=1, max_value=5),
-                      source_read_size=strategies.integers(1, 16384),
-                      read_size=strategies.integers(1, zstd.COMPRESSION_RECOMMENDED_OUTPUT_SIZE))
-    def test_buffer_source_readinto(self, original, level,
-                                    source_read_size, read_size):
+        suppress_health_check=[hypothesis.HealthCheck.large_base_example]
+    )
+    @hypothesis.given(
+        original=strategies.sampled_from(random_input_data()),
+        level=strategies.integers(min_value=1, max_value=5),
+        source_read_size=strategies.integers(1, 16384),
+        read_size=strategies.integers(1, zstd.COMPRESSION_RECOMMENDED_OUTPUT_SIZE),
+    )
+    def test_buffer_source_readinto(self, original, level, source_read_size, read_size):
 
         refctx = zstd.ZstdCompressor(level=level)
         ref_frame = refctx.compress(original)
 
         cctx = zstd.ZstdCompressor(level=level)
-        with cctx.stream_reader(original, size=len(original),
-                                read_size=source_read_size) as reader:
+        with cctx.stream_reader(
+            original, size=len(original), read_size=source_read_size
+        ) as reader:
             chunks = []
             while True:
                 b = bytearray(read_size)
                 count = reader.readinto(b)
 
                 if not count:
                     break
 
                 chunks.append(bytes(b[0:count]))
 
-        self.assertEqual(b''.join(chunks), ref_frame)
+        self.assertEqual(b"".join(chunks), ref_frame)
 
     @hypothesis.settings(
-        suppress_health_check=[hypothesis.HealthCheck.large_base_example])
-    @hypothesis.given(original=strategies.sampled_from(random_input_data()),
-                      level=strategies.integers(min_value=1, max_value=5),
-                      source_read_size=strategies.integers(1, 16384),
-                      read_sizes=strategies.data())
-    def test_stream_source_readinto_variance(self, original, level,
-                                             source_read_size, read_sizes):
+        suppress_health_check=[
+            hypothesis.HealthCheck.large_base_example,
+            hypothesis.HealthCheck.too_slow,
+        ]
+    )
+    @hypothesis.given(
+        original=strategies.sampled_from(random_input_data()),
+        level=strategies.integers(min_value=1, max_value=5),
+        source_read_size=strategies.integers(1, 16384),
+        read_sizes=strategies.data(),
+    )
+    def test_stream_source_readinto_variance(
+        self, original, level, source_read_size, read_sizes
+    ):
         refctx = zstd.ZstdCompressor(level=level)
         ref_frame = refctx.compress(original)
 
         cctx = zstd.ZstdCompressor(level=level)
-        with cctx.stream_reader(io.BytesIO(original), size=len(original),
-                                read_size=source_read_size) as reader:
+        with cctx.stream_reader(
+            io.BytesIO(original), size=len(original), read_size=source_read_size
+        ) as reader:
             chunks = []
             while True:
                 read_size = read_sizes.draw(strategies.integers(1, 16384))
                 b = bytearray(read_size)
                 count = reader.readinto(b)
 
                 if not count:
                     break
 
                 chunks.append(bytes(b[0:count]))
 
-        self.assertEqual(b''.join(chunks), ref_frame)
+        self.assertEqual(b"".join(chunks), ref_frame)
 
     @hypothesis.settings(
-        suppress_health_check=[hypothesis.HealthCheck.large_base_example])
-    @hypothesis.given(original=strategies.sampled_from(random_input_data()),
-                      level=strategies.integers(min_value=1, max_value=5),
-                      source_read_size=strategies.integers(1, 16384),
-                      read_sizes=strategies.data())
-    def test_buffer_source_readinto_variance(self, original, level,
-                                             source_read_size, read_sizes):
+        suppress_health_check=[
+            hypothesis.HealthCheck.large_base_example,
+            hypothesis.HealthCheck.too_slow,
+        ]
+    )
+    @hypothesis.given(
+        original=strategies.sampled_from(random_input_data()),
+        level=strategies.integers(min_value=1, max_value=5),
+        source_read_size=strategies.integers(1, 16384),
+        read_sizes=strategies.data(),
+    )
+    def test_buffer_source_readinto_variance(
+        self, original, level, source_read_size, read_sizes
+    ):
 
         refctx = zstd.ZstdCompressor(level=level)
         ref_frame = refctx.compress(original)
 
         cctx = zstd.ZstdCompressor(level=level)
-        with cctx.stream_reader(original, size=len(original),
-                                read_size=source_read_size) as reader:
+        with cctx.stream_reader(
+            original, size=len(original), read_size=source_read_size
+        ) as reader:
             chunks = []
             while True:
                 read_size = read_sizes.draw(strategies.integers(1, 16384))
                 b = bytearray(read_size)
                 count = reader.readinto(b)
 
                 if not count:
                     break
 
                 chunks.append(bytes(b[0:count]))
 
-        self.assertEqual(b''.join(chunks), ref_frame)
+        self.assertEqual(b"".join(chunks), ref_frame)
 
     @hypothesis.settings(
-        suppress_health_check=[hypothesis.HealthCheck.large_base_example])
-    @hypothesis.given(original=strategies.sampled_from(random_input_data()),
-                      level=strategies.integers(min_value=1, max_value=5),
-                      source_read_size=strategies.integers(1, 16384),
-                      read_size=strategies.integers(-1, zstd.COMPRESSION_RECOMMENDED_OUTPUT_SIZE))
-    def test_stream_source_read1(self, original, level, source_read_size,
-                                 read_size):
+        suppress_health_check=[hypothesis.HealthCheck.large_base_example]
+    )
+    @hypothesis.given(
+        original=strategies.sampled_from(random_input_data()),
+        level=strategies.integers(min_value=1, max_value=5),
+        source_read_size=strategies.integers(1, 16384),
+        read_size=strategies.integers(-1, zstd.COMPRESSION_RECOMMENDED_OUTPUT_SIZE),
+    )
+    def test_stream_source_read1(self, original, level, source_read_size, read_size):
         if read_size == 0:
             read_size = -1
 
         refctx = zstd.ZstdCompressor(level=level)
         ref_frame = refctx.compress(original)
 
         cctx = zstd.ZstdCompressor(level=level)
-        with cctx.stream_reader(io.BytesIO(original), size=len(original),
-                                read_size=source_read_size) as reader:
+        with cctx.stream_reader(
+            io.BytesIO(original), size=len(original), read_size=source_read_size
+        ) as reader:
             chunks = []
             while True:
                 chunk = reader.read1(read_size)
                 if not chunk:
                     break
 
                 chunks.append(chunk)
 
-        self.assertEqual(b''.join(chunks), ref_frame)
+        self.assertEqual(b"".join(chunks), ref_frame)
 
     @hypothesis.settings(
-        suppress_health_check=[hypothesis.HealthCheck.large_base_example])
-    @hypothesis.given(original=strategies.sampled_from(random_input_data()),
-                      level=strategies.integers(min_value=1, max_value=5),
-                      source_read_size=strategies.integers(1, 16384),
-                      read_size=strategies.integers(-1, zstd.COMPRESSION_RECOMMENDED_OUTPUT_SIZE))
-    def test_buffer_source_read1(self, original, level, source_read_size,
-                                 read_size):
+        suppress_health_check=[hypothesis.HealthCheck.large_base_example]
+    )
+    @hypothesis.given(
+        original=strategies.sampled_from(random_input_data()),
+        level=strategies.integers(min_value=1, max_value=5),
+        source_read_size=strategies.integers(1, 16384),
+        read_size=strategies.integers(-1, zstd.COMPRESSION_RECOMMENDED_OUTPUT_SIZE),
+    )
+    def test_buffer_source_read1(self, original, level, source_read_size, read_size):
         if read_size == 0:
             read_size = -1
 
         refctx = zstd.ZstdCompressor(level=level)
         ref_frame = refctx.compress(original)
 
         cctx = zstd.ZstdCompressor(level=level)
-        with cctx.stream_reader(original, size=len(original),
-                                read_size=source_read_size) as reader:
+        with cctx.stream_reader(
+            original, size=len(original), read_size=source_read_size
+        ) as reader:
             chunks = []
             while True:
                 chunk = reader.read1(read_size)
                 if not chunk:
                     break
 
                 chunks.append(chunk)
 
-        self.assertEqual(b''.join(chunks), ref_frame)
+        self.assertEqual(b"".join(chunks), ref_frame)
 
     @hypothesis.settings(
-        suppress_health_check=[hypothesis.HealthCheck.large_base_example])
-    @hypothesis.given(original=strategies.sampled_from(random_input_data()),
-                      level=strategies.integers(min_value=1, max_value=5),
-                      source_read_size=strategies.integers(1, 16384),
-                      read_sizes=strategies.data())
-    def test_stream_source_read1_variance(self, original, level, source_read_size,
-                                          read_sizes):
+        suppress_health_check=[
+            hypothesis.HealthCheck.large_base_example,
+            hypothesis.HealthCheck.too_slow,
+        ]
+    )
+    @hypothesis.given(
+        original=strategies.sampled_from(random_input_data()),
+        level=strategies.integers(min_value=1, max_value=5),
+        source_read_size=strategies.integers(1, 16384),
+        read_sizes=strategies.data(),
+    )
+    def test_stream_source_read1_variance(
+        self, original, level, source_read_size, read_sizes
+    ):
         refctx = zstd.ZstdCompressor(level=level)
         ref_frame = refctx.compress(original)
 
         cctx = zstd.ZstdCompressor(level=level)
-        with cctx.stream_reader(io.BytesIO(original), size=len(original),
-                                read_size=source_read_size) as reader:
+        with cctx.stream_reader(
+            io.BytesIO(original), size=len(original), read_size=source_read_size
+        ) as reader:
             chunks = []
             while True:
                 read_size = read_sizes.draw(strategies.integers(-1, 16384))
                 chunk = reader.read1(read_size)
                 if not chunk and read_size:
                     break
 
                 chunks.append(chunk)
 
-        self.assertEqual(b''.join(chunks), ref_frame)
+        self.assertEqual(b"".join(chunks), ref_frame)
 
     @hypothesis.settings(
-        suppress_health_check=[hypothesis.HealthCheck.large_base_example])
-    @hypothesis.given(original=strategies.sampled_from(random_input_data()),
-                      level=strategies.integers(min_value=1, max_value=5),
-                      source_read_size=strategies.integers(1, 16384),
-                      read_sizes=strategies.data())
-    def test_buffer_source_read1_variance(self, original, level, source_read_size,
-                                          read_sizes):
+        suppress_health_check=[
+            hypothesis.HealthCheck.large_base_example,
+            hypothesis.HealthCheck.too_slow,
+        ]
+    )
+    @hypothesis.given(
+        original=strategies.sampled_from(random_input_data()),
+        level=strategies.integers(min_value=1, max_value=5),
+        source_read_size=strategies.integers(1, 16384),
+        read_sizes=strategies.data(),
+    )
+    def test_buffer_source_read1_variance(
+        self, original, level, source_read_size, read_sizes
+    ):
 
         refctx = zstd.ZstdCompressor(level=level)
         ref_frame = refctx.compress(original)
 
         cctx = zstd.ZstdCompressor(level=level)
-        with cctx.stream_reader(original, size=len(original),
-                                read_size=source_read_size) as reader:
+        with cctx.stream_reader(
+            original, size=len(original), read_size=source_read_size
+        ) as reader:
             chunks = []
             while True:
                 read_size = read_sizes.draw(strategies.integers(-1, 16384))
                 chunk = reader.read1(read_size)
                 if not chunk and read_size:
                     break
 
                 chunks.append(chunk)
 
-        self.assertEqual(b''.join(chunks), ref_frame)
-
+        self.assertEqual(b"".join(chunks), ref_frame)
 
     @hypothesis.settings(
-        suppress_health_check=[hypothesis.HealthCheck.large_base_example])
-    @hypothesis.given(original=strategies.sampled_from(random_input_data()),
-                      level=strategies.integers(min_value=1, max_value=5),
-                      source_read_size=strategies.integers(1, 16384),
-                      read_size=strategies.integers(1, zstd.COMPRESSION_RECOMMENDED_OUTPUT_SIZE))
-    def test_stream_source_readinto1(self, original, level, source_read_size,
-                                     read_size):
+        suppress_health_check=[hypothesis.HealthCheck.large_base_example]
+    )
+    @hypothesis.given(
+        original=strategies.sampled_from(random_input_data()),
+        level=strategies.integers(min_value=1, max_value=5),
+        source_read_size=strategies.integers(1, 16384),
+        read_size=strategies.integers(1, zstd.COMPRESSION_RECOMMENDED_OUTPUT_SIZE),
+    )
+    def test_stream_source_readinto1(
+        self, original, level, source_read_size, read_size
+    ):
         if read_size == 0:
             read_size = -1
 
         refctx = zstd.ZstdCompressor(level=level)
         ref_frame = refctx.compress(original)
 
         cctx = zstd.ZstdCompressor(level=level)
-        with cctx.stream_reader(io.BytesIO(original), size=len(original),
-                                read_size=source_read_size) as reader:
+        with cctx.stream_reader(
+            io.BytesIO(original), size=len(original), read_size=source_read_size
+        ) as reader:
             chunks = []
             while True:
                 b = bytearray(read_size)
                 count = reader.readinto1(b)
 
                 if not count:
                     break
 
                 chunks.append(bytes(b[0:count]))
 
-        self.assertEqual(b''.join(chunks), ref_frame)
+        self.assertEqual(b"".join(chunks), ref_frame)
 
     @hypothesis.settings(
-        suppress_health_check=[hypothesis.HealthCheck.large_base_example])
-    @hypothesis.given(original=strategies.sampled_from(random_input_data()),
-                      level=strategies.integers(min_value=1, max_value=5),
-                      source_read_size=strategies.integers(1, 16384),
-                      read_size=strategies.integers(1, zstd.COMPRESSION_RECOMMENDED_OUTPUT_SIZE))
-    def test_buffer_source_readinto1(self, original, level, source_read_size,
-                                     read_size):
+        suppress_health_check=[hypothesis.HealthCheck.large_base_example]
+    )
+    @hypothesis.given(
+        original=strategies.sampled_from(random_input_data()),
+        level=strategies.integers(min_value=1, max_value=5),
+        source_read_size=strategies.integers(1, 16384),
+        read_size=strategies.integers(1, zstd.COMPRESSION_RECOMMENDED_OUTPUT_SIZE),
+    )
+    def test_buffer_source_readinto1(
+        self, original, level, source_read_size, read_size
+    ):
         if read_size == 0:
             read_size = -1
 
         refctx = zstd.ZstdCompressor(level=level)
         ref_frame = refctx.compress(original)
 
         cctx = zstd.ZstdCompressor(level=level)
-        with cctx.stream_reader(original, size=len(original),
-                                read_size=source_read_size) as reader:
+        with cctx.stream_reader(
+            original, size=len(original), read_size=source_read_size
+        ) as reader:
             chunks = []
             while True:
                 b = bytearray(read_size)
                 count = reader.readinto1(b)
 
                 if not count:
                     break
 
                 chunks.append(bytes(b[0:count]))
 
-        self.assertEqual(b''.join(chunks), ref_frame)
+        self.assertEqual(b"".join(chunks), ref_frame)
 
     @hypothesis.settings(
-        suppress_health_check=[hypothesis.HealthCheck.large_base_example])
-    @hypothesis.given(original=strategies.sampled_from(random_input_data()),
-                      level=strategies.integers(min_value=1, max_value=5),
-                      source_read_size=strategies.integers(1, 16384),
-                      read_sizes=strategies.data())
-    def test_stream_source_readinto1_variance(self, original, level, source_read_size,
-                                              read_sizes):
+        suppress_health_check=[
+            hypothesis.HealthCheck.large_base_example,
+            hypothesis.HealthCheck.too_slow,
+        ]
+    )
+    @hypothesis.given(
+        original=strategies.sampled_from(random_input_data()),
+        level=strategies.integers(min_value=1, max_value=5),
+        source_read_size=strategies.integers(1, 16384),
+        read_sizes=strategies.data(),
+    )
+    def test_stream_source_readinto1_variance(
+        self, original, level, source_read_size, read_sizes
+    ):
         refctx = zstd.ZstdCompressor(level=level)
         ref_frame = refctx.compress(original)
 
         cctx = zstd.ZstdCompressor(level=level)
-        with cctx.stream_reader(io.BytesIO(original), size=len(original),
-                                read_size=source_read_size) as reader:
+        with cctx.stream_reader(
+            io.BytesIO(original), size=len(original), read_size=source_read_size
+        ) as reader:
             chunks = []
             while True:
                 read_size = read_sizes.draw(strategies.integers(1, 16384))
                 b = bytearray(read_size)
                 count = reader.readinto1(b)
 
                 if not count:
                     break
 
                 chunks.append(bytes(b[0:count]))
 
-        self.assertEqual(b''.join(chunks), ref_frame)
+        self.assertEqual(b"".join(chunks), ref_frame)
 
     @hypothesis.settings(
-        suppress_health_check=[hypothesis.HealthCheck.large_base_example])
-    @hypothesis.given(original=strategies.sampled_from(random_input_data()),
-                      level=strategies.integers(min_value=1, max_value=5),
-                      source_read_size=strategies.integers(1, 16384),
-                      read_sizes=strategies.data())
-    def test_buffer_source_readinto1_variance(self, original, level, source_read_size,
-                                              read_sizes):
+        suppress_health_check=[
+            hypothesis.HealthCheck.large_base_example,
+            hypothesis.HealthCheck.too_slow,
+        ]
+    )
+    @hypothesis.given(
+        original=strategies.sampled_from(random_input_data()),
+        level=strategies.integers(min_value=1, max_value=5),
+        source_read_size=strategies.integers(1, 16384),
+        read_sizes=strategies.data(),
+    )
+    def test_buffer_source_readinto1_variance(
+        self, original, level, source_read_size, read_sizes
+    ):
 
         refctx = zstd.ZstdCompressor(level=level)
         ref_frame = refctx.compress(original)
 
         cctx = zstd.ZstdCompressor(level=level)
-        with cctx.stream_reader(original, size=len(original),
-                                read_size=source_read_size) as reader:
+        with cctx.stream_reader(
+            original, size=len(original), read_size=source_read_size
+        ) as reader:
             chunks = []
             while True:
                 read_size = read_sizes.draw(strategies.integers(1, 16384))
                 b = bytearray(read_size)
                 count = reader.readinto1(b)
 
                 if not count:
                     break
 
                 chunks.append(bytes(b[0:count]))
 
-        self.assertEqual(b''.join(chunks), ref_frame)
-
+        self.assertEqual(b"".join(chunks), ref_frame)
 
 
[e-mail]('ZSTD_SLOW_TESTS' in os.environ, 'ZSTD_SLOW_TESTS not set')
[e-mail]("ZSTD_SLOW_TESTS" in os.environ, "ZSTD_SLOW_TESTS not set")
 @make_cffi
-class TestCompressor_stream_writer_fuzzing(unittest.TestCase):
-    @hypothesis.given(original=strategies.sampled_from(random_input_data()),
-                        level=strategies.integers(min_value=1, max_value=5),
-                        write_size=strategies.integers(min_value=1, max_value=1048576))
+class TestCompressor_stream_writer_fuzzing(TestCase):
+    @hypothesis.given(
+        original=strategies.sampled_from(random_input_data()),
+        level=strategies.integers(min_value=1, max_value=5),
+        write_size=strategies.integers(min_value=1, max_value=1048576),
+    )
     def test_write_size_variance(self, original, level, write_size):
         refctx = zstd.ZstdCompressor(level=level)
         ref_frame = refctx.compress(original)
 
         cctx = zstd.ZstdCompressor(level=level)
         b = NonClosingBytesIO()
-        with cctx.stream_writer(b, size=len(original), write_size=write_size) as compressor:
+        with cctx.stream_writer(
+            b, size=len(original), write_size=write_size
+        ) as compressor:
             compressor.write(original)
 
         self.assertEqual(b.getvalue(), ref_frame)
 
 
[e-mail]('ZSTD_SLOW_TESTS' in os.environ, 'ZSTD_SLOW_TESTS not set')
[e-mail]("ZSTD_SLOW_TESTS" in os.environ, "ZSTD_SLOW_TESTS not set")
 @make_cffi
-class TestCompressor_copy_stream_fuzzing(unittest.TestCase):
-    @hypothesis.given(original=strategies.sampled_from(random_input_data()),
-                      level=strategies.integers(min_value=1, max_value=5),
-                      read_size=strategies.integers(min_value=1, max_value=1048576),
-                      write_size=strategies.integers(min_value=1, max_value=1048576))
+class TestCompressor_copy_stream_fuzzing(TestCase):
+    @hypothesis.given(
+        original=strategies.sampled_from(random_input_data()),
+        level=strategies.integers(min_value=1, max_value=5),
+        read_size=strategies.integers(min_value=1, max_value=1048576),
+        write_size=strategies.integers(min_value=1, max_value=1048576),
+    )
     def test_read_write_size_variance(self, original, level, read_size, write_size):
         refctx = zstd.ZstdCompressor(level=level)
         ref_frame = refctx.compress(original)
 
         cctx = zstd.ZstdCompressor(level=level)
         source = io.BytesIO(original)
         dest = io.BytesIO()
 
-        cctx.copy_stream(source, dest, size=len(original), read_size=read_size,
-                         write_size=write_size)
+        cctx.copy_stream(
+            source, dest, size=len(original), read_size=read_size, write_size=write_size
+        )
 
         self.assertEqual(dest.getvalue(), ref_frame)
 
 
[e-mail]('ZSTD_SLOW_TESTS' in os.environ, 'ZSTD_SLOW_TESTS not set')
[e-mail]("ZSTD_SLOW_TESTS" in os.environ, "ZSTD_SLOW_TESTS not set")
 @make_cffi
-class TestCompressor_compressobj_fuzzing(unittest.TestCase):
+class TestCompressor_compressobj_fuzzing(TestCase):
     @hypothesis.settings(
-        suppress_health_check=[hypothesis.HealthCheck.large_base_example])
-    @hypothesis.given(original=strategies.sampled_from(random_input_data()),
-                      level=strategies.integers(min_value=1, max_value=5),
-                      chunk_sizes=strategies.data())
+        suppress_health_check=[
+            hypothesis.HealthCheck.large_base_example,
+            hypothesis.HealthCheck.too_slow,
+        ]
+    )
+    @hypothesis.given(
+        original=strategies.sampled_from(random_input_data()),
+        level=strategies.integers(min_value=1, max_value=5),
+        chunk_sizes=strategies.data(),
+    )
     def test_random_input_sizes(self, original, level, chunk_sizes):
         refctx = zstd.ZstdCompressor(level=level)
         ref_frame = refctx.compress(original)
 
         cctx = zstd.ZstdCompressor(level=level)
         cobj = cctx.compressobj(size=len(original))
 
         chunks = []
         i = 0
         while True:
             chunk_size = chunk_sizes.draw(strategies.integers(1, 4096))
-            source = original[i:i + chunk_size]
+            source = original[i : i + chunk_size]
             if not source:
                 break
 
             chunks.append(cobj.compress(source))
             i += chunk_size
 
         chunks.append(cobj.flush())
 
-        self.assertEqual(b''.join(chunks), ref_frame)
+        self.assertEqual(b"".join(chunks), ref_frame)
 
     @hypothesis.settings(
-        suppress_health_check=[hypothesis.HealthCheck.large_base_example])
-    @hypothesis.given(original=strategies.sampled_from(random_input_data()),
-                      level=strategies.integers(min_value=1, max_value=5),
-                      chunk_sizes=strategies.data(),
-                      flushes=strategies.data())
+        suppress_health_check=[
+            hypothesis.HealthCheck.large_base_example,
+            hypothesis.HealthCheck.too_slow,
+        ]
+    )
+    @hypothesis.given(
+        original=strategies.sampled_from(random_input_data()),
+        level=strategies.integers(min_value=1, max_value=5),
+        chunk_sizes=strategies.data(),
+        flushes=strategies.data(),
+    )
     def test_flush_block(self, original, level, chunk_sizes, flushes):
         cctx = zstd.ZstdCompressor(level=level)
         cobj = cctx.compressobj()
 
         dctx = zstd.ZstdDecompressor()
         dobj = dctx.decompressobj()
 
         compressed_chunks = []
         decompressed_chunks = []
         i = 0
         while True:
             input_size = chunk_sizes.draw(strategies.integers(1, 4096))
-            source = original[i:i + input_size]
+            source = original[i : i + input_size]
             if not source:
                 break
 
             i += input_size
 
             chunk = cobj.compress(source)
             compressed_chunks.append(chunk)
             decompressed_chunks.append(dobj.decompress(chunk))
 
             if not flushes.draw(strategies.booleans()):
                 continue
 
             chunk = cobj.flush(zstd.COMPRESSOBJ_FLUSH_BLOCK)
             compressed_chunks.append(chunk)
             decompressed_chunks.append(dobj.decompress(chunk))
 
-            self.assertEqual(b''.join(decompressed_chunks), original[0:i])
+            self.assertEqual(b"".join(decompressed_chunks), original[0:i])
 
         chunk = cobj.flush(zstd.COMPRESSOBJ_FLUSH_FINISH)
         compressed_chunks.append(chunk)
         decompressed_chunks.append(dobj.decompress(chunk))
 
-        self.assertEqual(dctx.decompress(b''.join(compressed_chunks),
-                                         max_output_size=len(original)),
-                         original)
-        self.assertEqual(b''.join(decompressed_chunks), original)
+        self.assertEqual(
+            dctx.decompress(b"".join(compressed_chunks), max_output_size=len(original)),
+            original,
+        )
+        self.assertEqual(b"".join(decompressed_chunks), original)
+
 
[e-mail]('ZSTD_SLOW_TESTS' in os.environ, 'ZSTD_SLOW_TESTS not set')
[e-mail]("ZSTD_SLOW_TESTS" in os.environ, "ZSTD_SLOW_TESTS not set")
 @make_cffi
-class TestCompressor_read_to_iter_fuzzing(unittest.TestCase):
-    @hypothesis.given(original=strategies.sampled_from(random_input_data()),
-                      level=strategies.integers(min_value=1, max_value=5),
-                      read_size=strategies.integers(min_value=1, max_value=4096),
-                      write_size=strategies.integers(min_value=1, max_value=4096))
+class TestCompressor_read_to_iter_fuzzing(TestCase):
+    @hypothesis.given(
+        original=strategies.sampled_from(random_input_data()),
+        level=strategies.integers(min_value=1, max_value=5),
+        read_size=strategies.integers(min_value=1, max_value=4096),
+        write_size=strategies.integers(min_value=1, max_value=4096),
+    )
     def test_read_write_size_variance(self, original, level, read_size, write_size):
         refcctx = zstd.ZstdCompressor(level=level)
         ref_frame = refcctx.compress(original)
 
         source = io.BytesIO(original)
 
         cctx = zstd.ZstdCompressor(level=level)
-        chunks = list(cctx.read_to_iter(source, size=len(original),
-                                        read_size=read_size,
-                                        write_size=write_size))
+        chunks = list(
+            cctx.read_to_iter(
+                source, size=len(original), read_size=read_size, write_size=write_size
+            )
+        )
 
-        self.assertEqual(b''.join(chunks), ref_frame)
+        self.assertEqual(b"".join(chunks), ref_frame)
 
 
[e-mail]('ZSTD_SLOW_TESTS' in os.environ, 'ZSTD_SLOW_TESTS not set')
-class TestCompressor_multi_compress_to_buffer_fuzzing(unittest.TestCase):
-    @hypothesis.given(original=strategies.lists(strategies.sampled_from(random_input_data()),
-                                                min_size=1, max_size=1024),
-                        threads=strategies.integers(min_value=1, max_value=8),
-                        use_dict=strategies.booleans())
[e-mail]("ZSTD_SLOW_TESTS" in os.environ, "ZSTD_SLOW_TESTS not set")
+class TestCompressor_multi_compress_to_buffer_fuzzing(TestCase):
+    @hypothesis.given(
+        original=strategies.lists(
+            strategies.sampled_from(random_input_data()), min_size=1, max_size=1024
+        ),
+        threads=strategies.integers(min_value=1, max_value=8),
+        use_dict=strategies.booleans(),
+    )
     def test_data_equivalence(self, original, threads, use_dict):
         kwargs = {}
 
         # Use a content dictionary because it is cheap to create.
         if use_dict:
-            kwargs['dict_data'] = zstd.ZstdCompressionDict(original[0])
+            kwargs["dict_data"] = zstd.ZstdCompressionDict(original[0])
 
-        cctx = zstd.ZstdCompressor(level=1,
-                                   write_checksum=True,
-                                   **kwargs)
+        cctx = zstd.ZstdCompressor(level=1, write_checksum=True, **kwargs)
 
-        if not hasattr(cctx, 'multi_compress_to_buffer'):
-            self.skipTest('multi_compress_to_buffer not available')
+        if not hasattr(cctx, "multi_compress_to_buffer"):
+            self.skipTest("multi_compress_to_buffer not available")
 
         result = cctx.multi_compress_to_buffer(original, threads=-1)
 
         self.assertEqual(len(result), len(original))
 
         # The frame produced via the batch APIs may not be bit identical to that
         # produced by compress() because compression parameters are adjusted
         # from the first input in batch mode. So the only thing we can do is
         # verify the decompressed data matches the input.
         dctx = zstd.ZstdDecompressor(**kwargs)
 
         for i, frame in enumerate(result):
             self.assertEqual(dctx.decompress(frame), original[i])
 
 
[e-mail]('ZSTD_SLOW_TESTS' in os.environ, 'ZSTD_SLOW_TESTS not set')
[e-mail]("ZSTD_SLOW_TESTS" in os.environ, "ZSTD_SLOW_TESTS not set")
 @make_cffi
-class TestCompressor_chunker_fuzzing(unittest.TestCase):
+class TestCompressor_chunker_fuzzing(TestCase):
     @hypothesis.settings(
-        suppress_health_check=[hypothesis.HealthCheck.large_base_example])
-    @hypothesis.given(original=strategies.sampled_from(random_input_data()),
-                      level=strategies.integers(min_value=1, max_value=5),
-                      chunk_size=strategies.integers(
-                          min_value=1,
-                          max_value=32 * 1048576),
-                      input_sizes=strategies.data())
+        suppress_health_check=[
+            hypothesis.HealthCheck.large_base_example,
+            hypothesis.HealthCheck.too_slow,
+        ]
+    )
+    @hypothesis.given(
+        original=strategies.sampled_from(random_input_data()),
+        level=strategies.integers(min_value=1, max_value=5),
+        chunk_size=strategies.integers(min_value=1, max_value=32 * 1048576),
+        input_sizes=strategies.data(),
+    )
     def test_random_input_sizes(self, original, level, chunk_size, input_sizes):
         cctx = zstd.ZstdCompressor(level=level)
         chunker = cctx.chunker(chunk_size=chunk_size)
 
         chunks = []
         i = 0
         while True:
             input_size = input_sizes.draw(strategies.integers(1, 4096))
-            source = original[i:i + input_size]
+            source = original[i : i + input_size]
             if not source:
                 break
 
             chunks.extend(chunker.compress(source))
             i += input_size
 
         chunks.extend(chunker.finish())
 
         dctx = zstd.ZstdDecompressor()
 
-        self.assertEqual(dctx.decompress(b''.join(chunks),
-                                         max_output_size=len(original)),
-                         original)
+        self.assertEqual(
+            dctx.decompress(b"".join(chunks), max_output_size=len(original)), original
+        )
 
         self.assertTrue(all(len(chunk) == chunk_size for chunk in chunks[:-1]))
 
     @hypothesis.settings(
-        suppress_health_check=[hypothesis.HealthCheck.large_base_example])
-    @hypothesis.given(original=strategies.sampled_from(random_input_data()),
-                      level=strategies.integers(min_value=1, max_value=5),
-                      chunk_size=strategies.integers(
-                          min_value=1,
-                          max_value=32 * 1048576),
-                      input_sizes=strategies.data(),
-                      flushes=strategies.data())
-    def test_flush_block(self, original, level, chunk_size, input_sizes,
-                         flushes):
+        suppress_health_check=[
+            hypothesis.HealthCheck.large_base_example,
+            hypothesis.HealthCheck.too_slow,
+        ]
+    )
+    @hypothesis.given(
+        original=strategies.sampled_from(random_input_data()),
+        level=strategies.integers(min_value=1, max_value=5),
+        chunk_size=strategies.integers(min_value=1, max_value=32 * 1048576),
+        input_sizes=strategies.data(),
+        flushes=strategies.data(),
+    )
+    def test_flush_block(self, original, level, chunk_size, input_sizes, flushes):
         cctx = zstd.ZstdCompressor(level=level)
         chunker = cctx.chunker(chunk_size=chunk_size)
 
         dctx = zstd.ZstdDecompressor()
         dobj = dctx.decompressobj()
 
         compressed_chunks = []
         decompressed_chunks = []
         i = 0
         while True:
             input_size = input_sizes.draw(strategies.integers(1, 4096))
-            source = original[i:i + input_size]
+            source = original[i : i + input_size]
             if not source:
                 break
 
             i += input_size
 
             chunks = list(chunker.compress(source))
             compressed_chunks.extend(chunks)
-            decompressed_chunks.append(dobj.decompress(b''.join(chunks)))
+            decompressed_chunks.append(dobj.decompress(b"".join(chunks)))
 
             if not flushes.draw(strategies.booleans()):
                 continue
 
             chunks = list(chunker.flush())
             compressed_chunks.extend(chunks)
-            decompressed_chunks.append(dobj.decompress(b''.join(chunks)))
+            decompressed_chunks.append(dobj.decompress(b"".join(chunks)))
 
-            self.assertEqual(b''.join(decompressed_chunks), original[0:i])
+            self.assertEqual(b"".join(decompressed_chunks), original[0:i])
 
         chunks = list(chunker.finish())
         compressed_chunks.extend(chunks)
-        decompressed_chunks.append(dobj.decompress(b''.join(chunks)))
+        decompressed_chunks.append(dobj.decompress(b"".join(chunks)))
 
-        self.assertEqual(dctx.decompress(b''.join(compressed_chunks),
-                                         max_output_size=len(original)),
-                         original)
-        self.assertEqual(b''.join(decompressed_chunks), original)
  No newline at end of file
+        self.assertEqual(
+            dctx.decompress(b"".join(compressed_chunks), max_output_size=len(original)),
+            original,
+        )
+        self.assertEqual(b"".join(decompressed_chunks), original)

contrib/python-zstandard/tests/test_data_structures.py

@@ -1,228 +1,241 b''
 import sys
 import unittest
 
 import zstandard as zstd
 
-from . common import (
+from .common import (
     make_cffi,
+    TestCase,
 )
 
 
 @make_cffi
-class TestCompressionParameters(unittest.TestCase):
+class TestCompressionParameters(TestCase):
     def test_bounds(self):
-        zstd.ZstdCompressionParameters(window_log=zstd.WINDOWLOG_MIN,
-                                       chain_log=zstd.CHAINLOG_MIN,
-                                       hash_log=zstd.HASHLOG_MIN,
-                                       search_log=zstd.SEARCHLOG_MIN,
-                                       min_match=zstd.MINMATCH_MIN + 1,
-                                       target_length=zstd.TARGETLENGTH_MIN,
-                                       strategy=zstd.STRATEGY_FAST)
+        zstd.ZstdCompressionParameters(
+            window_log=zstd.WINDOWLOG_MIN,
+            chain_log=zstd.CHAINLOG_MIN,
+            hash_log=zstd.HASHLOG_MIN,
+            search_log=zstd.SEARCHLOG_MIN,
+            min_match=zstd.MINMATCH_MIN + 1,
+            target_length=zstd.TARGETLENGTH_MIN,
+            strategy=zstd.STRATEGY_FAST,
+        )
 
-        zstd.ZstdCompressionParameters(window_log=zstd.WINDOWLOG_MAX,
-                                       chain_log=zstd.CHAINLOG_MAX,
-                                       hash_log=zstd.HASHLOG_MAX,
-                                       search_log=zstd.SEARCHLOG_MAX,
-                                       min_match=zstd.MINMATCH_MAX - 1,
-                                       target_length=zstd.TARGETLENGTH_MAX,
-                                       strategy=zstd.STRATEGY_BTULTRA2)
+        zstd.ZstdCompressionParameters(
+            window_log=zstd.WINDOWLOG_MAX,
+            chain_log=zstd.CHAINLOG_MAX,
+            hash_log=zstd.HASHLOG_MAX,
+            search_log=zstd.SEARCHLOG_MAX,
+            min_match=zstd.MINMATCH_MAX - 1,
+            target_length=zstd.TARGETLENGTH_MAX,
+            strategy=zstd.STRATEGY_BTULTRA2,
+        )
 
     def test_from_level(self):
         p = zstd.ZstdCompressionParameters.from_level(1)
         self.assertIsInstance(p, zstd.CompressionParameters)
 
         self.assertEqual(p.window_log, 19)
 
         p = zstd.ZstdCompressionParameters.from_level(-4)
         self.assertEqual(p.window_log, 19)
 
     def test_members(self):
-        p = zstd.ZstdCompressionParameters(window_log=10,
-                                           chain_log=6,
-                                           hash_log=7,
-                                           search_log=4,
-                                           min_match=5,
-                                           target_length=8,
-                                           strategy=1)
+        p = zstd.ZstdCompressionParameters(
+            window_log=10,
+            chain_log=6,
+            hash_log=7,
+            search_log=4,
+            min_match=5,
+            target_length=8,
+            strategy=1,
+        )
         self.assertEqual(p.window_log, 10)
         self.assertEqual(p.chain_log, 6)
         self.assertEqual(p.hash_log, 7)
         self.assertEqual(p.search_log, 4)
         self.assertEqual(p.min_match, 5)
         self.assertEqual(p.target_length, 8)
         self.assertEqual(p.compression_strategy, 1)
 
         p = zstd.ZstdCompressionParameters(compression_level=2)
         self.assertEqual(p.compression_level, 2)
 
         p = zstd.ZstdCompressionParameters(threads=4)
         self.assertEqual(p.threads, 4)
 
-        p = zstd.ZstdCompressionParameters(threads=2, job_size=1048576,
-                                           overlap_log=6)
+        p = zstd.ZstdCompressionParameters(threads=2, job_size=1048576, overlap_log=6)
         self.assertEqual(p.threads, 2)
         self.assertEqual(p.job_size, 1048576)
         self.assertEqual(p.overlap_log, 6)
         self.assertEqual(p.overlap_size_log, 6)
 
         p = zstd.ZstdCompressionParameters(compression_level=-1)
         self.assertEqual(p.compression_level, -1)
 
         p = zstd.ZstdCompressionParameters(compression_level=-2)
         self.assertEqual(p.compression_level, -2)
 
         p = zstd.ZstdCompressionParameters(force_max_window=True)
         self.assertEqual(p.force_max_window, 1)
 
         p = zstd.ZstdCompressionParameters(enable_ldm=True)
         self.assertEqual(p.enable_ldm, 1)
 
         p = zstd.ZstdCompressionParameters(ldm_hash_log=7)
         self.assertEqual(p.ldm_hash_log, 7)
 
         p = zstd.ZstdCompressionParameters(ldm_min_match=6)
         self.assertEqual(p.ldm_min_match, 6)
 
         p = zstd.ZstdCompressionParameters(ldm_bucket_size_log=7)
         self.assertEqual(p.ldm_bucket_size_log, 7)
 
         p = zstd.ZstdCompressionParameters(ldm_hash_rate_log=8)
         self.assertEqual(p.ldm_hash_every_log, 8)
         self.assertEqual(p.ldm_hash_rate_log, 8)
 
     def test_estimated_compression_context_size(self):
-        p = zstd.ZstdCompressionParameters(window_log=20,
-                                           chain_log=16,
-                                           hash_log=17,
-                                           search_log=1,
-                                           min_match=5,
-                                           target_length=16,
-                                           strategy=zstd.STRATEGY_DFAST)
+        p = zstd.ZstdCompressionParameters(
+            window_log=20,
+            chain_log=16,
+            hash_log=17,
+            search_log=1,
+            min_match=5,
+            target_length=16,
+            strategy=zstd.STRATEGY_DFAST,
+        )
 
         # 32-bit has slightly different values from 64-bit.
-        self.assertAlmostEqual(p.estimated_compression_context_size(), 1294144,
-                               delta=250)
+        self.assertAlmostEqual(
+            p.estimated_compression_context_size(), 1294464, delta=400
+        )
 
     def test_strategy(self):
-        with self.assertRaisesRegexp(ValueError, 'cannot specify both compression_strategy'):
+        with self.assertRaisesRegex(
+            ValueError, "cannot specify both compression_strategy"
+        ):
             zstd.ZstdCompressionParameters(strategy=0, compression_strategy=0)
 
         p = zstd.ZstdCompressionParameters(strategy=2)
         self.assertEqual(p.compression_strategy, 2)
 
         p = zstd.ZstdCompressionParameters(strategy=3)
         self.assertEqual(p.compression_strategy, 3)
 
     def test_ldm_hash_rate_log(self):
-        with self.assertRaisesRegexp(ValueError, 'cannot specify both ldm_hash_rate_log'):
+        with self.assertRaisesRegex(
+            ValueError, "cannot specify both ldm_hash_rate_log"
+        ):
             zstd.ZstdCompressionParameters(ldm_hash_rate_log=8, ldm_hash_every_log=4)
 
         p = zstd.ZstdCompressionParameters(ldm_hash_rate_log=8)
         self.assertEqual(p.ldm_hash_every_log, 8)
 
         p = zstd.ZstdCompressionParameters(ldm_hash_every_log=16)
         self.assertEqual(p.ldm_hash_every_log, 16)
 
     def test_overlap_log(self):
-        with self.assertRaisesRegexp(ValueError, 'cannot specify both overlap_log'):
+        with self.assertRaisesRegex(ValueError, "cannot specify both overlap_log"):
             zstd.ZstdCompressionParameters(overlap_log=1, overlap_size_log=9)
 
         p = zstd.ZstdCompressionParameters(overlap_log=2)
         self.assertEqual(p.overlap_log, 2)
         self.assertEqual(p.overlap_size_log, 2)
 
         p = zstd.ZstdCompressionParameters(overlap_size_log=4)
         self.assertEqual(p.overlap_log, 4)
         self.assertEqual(p.overlap_size_log, 4)
 
 
 @make_cffi
-class TestFrameParameters(unittest.TestCase):
+class TestFrameParameters(TestCase):
     def test_invalid_type(self):
         with self.assertRaises(TypeError):
             zstd.get_frame_parameters(None)
 
         # Python 3 doesn't appear to convert unicode to Py_buffer.
         if sys.version_info[0] >= 3:
             with self.assertRaises(TypeError):
-                zstd.get_frame_parameters(u'foobarbaz')
+                zstd.get_frame_parameters(u"foobarbaz")
         else:
             # CPython will convert unicode to Py_buffer. But CFFI won't.
-            if zstd.backend == 'cffi':
+            if zstd.backend == "cffi":
                 with self.assertRaises(TypeError):
-                    zstd.get_frame_parameters(u'foobarbaz')
+                    zstd.get_frame_parameters(u"foobarbaz")
             else:
                 with self.assertRaises(zstd.ZstdError):
-                    zstd.get_frame_parameters(u'foobarbaz')
+                    zstd.get_frame_parameters(u"foobarbaz")
 
     def test_invalid_input_sizes(self):
-        with self.assertRaisesRegexp(zstd.ZstdError, 'not enough data for frame'):
-            zstd.get_frame_parameters(b'')
+        with self.assertRaisesRegex(zstd.ZstdError, "not enough data for frame"):
+            zstd.get_frame_parameters(b"")
 
-        with self.assertRaisesRegexp(zstd.ZstdError, 'not enough data for frame'):
+        with self.assertRaisesRegex(zstd.ZstdError, "not enough data for frame"):
             zstd.get_frame_parameters(zstd.FRAME_HEADER)
 
     def test_invalid_frame(self):
-        with self.assertRaisesRegexp(zstd.ZstdError, 'Unknown frame descriptor'):
-            zstd.get_frame_parameters(b'foobarbaz')
+        with self.assertRaisesRegex(zstd.ZstdError, "Unknown frame descriptor"):
+            zstd.get_frame_parameters(b"foobarbaz")
 
     def test_attributes(self):
-        params = zstd.get_frame_parameters(zstd.FRAME_HEADER + b'\x00\x00')
+        params = zstd.get_frame_parameters(zstd.FRAME_HEADER + b"\x00\x00")
         self.assertEqual(params.content_size, zstd.CONTENTSIZE_UNKNOWN)
         self.assertEqual(params.window_size, 1024)
         self.assertEqual(params.dict_id, 0)
         self.assertFalse(params.has_checksum)
 
         # Lowest 2 bits indicate a dictionary and length. Here, the dict id is 1 byte.
-        params = zstd.get_frame_parameters(zstd.FRAME_HEADER + b'\x01\x00\xff')
+        params = zstd.get_frame_parameters(zstd.FRAME_HEADER + b"\x01\x00\xff")
         self.assertEqual(params.content_size, zstd.CONTENTSIZE_UNKNOWN)
         self.assertEqual(params.window_size, 1024)
         self.assertEqual(params.dict_id, 255)
         self.assertFalse(params.has_checksum)
 
         # Lowest 3rd bit indicates if checksum is present.
-        params = zstd.get_frame_parameters(zstd.FRAME_HEADER + b'\x04\x00')
+        params = zstd.get_frame_parameters(zstd.FRAME_HEADER + b"\x04\x00")
         self.assertEqual(params.content_size, zstd.CONTENTSIZE_UNKNOWN)
         self.assertEqual(params.window_size, 1024)
         self.assertEqual(params.dict_id, 0)
         self.assertTrue(params.has_checksum)
 
         # Upper 2 bits indicate content size.
-        params = zstd.get_frame_parameters(zstd.FRAME_HEADER + b'\x40\x00\xff\x00')
+        params = zstd.get_frame_parameters(zstd.FRAME_HEADER + b"\x40\x00\xff\x00")
         self.assertEqual(params.content_size, 511)
         self.assertEqual(params.window_size, 1024)
         self.assertEqual(params.dict_id, 0)
         self.assertFalse(params.has_checksum)
 
         # Window descriptor is 2nd byte after frame header.
-        params = zstd.get_frame_parameters(zstd.FRAME_HEADER + b'\x00\x40')
+        params = zstd.get_frame_parameters(zstd.FRAME_HEADER + b"\x00\x40")
         self.assertEqual(params.content_size, zstd.CONTENTSIZE_UNKNOWN)
         self.assertEqual(params.window_size, 262144)
         self.assertEqual(params.dict_id, 0)
         self.assertFalse(params.has_checksum)
 
         # Set multiple things.
-        params = zstd.get_frame_parameters(zstd.FRAME_HEADER + b'\x45\x40\x0f\x10\x00')
+        params = zstd.get_frame_parameters(zstd.FRAME_HEADER + b"\x45\x40\x0f\x10\x00")
         self.assertEqual(params.content_size, 272)
         self.assertEqual(params.window_size, 262144)
         self.assertEqual(params.dict_id, 15)
         self.assertTrue(params.has_checksum)
 
     def test_input_types(self):
-        v = zstd.FRAME_HEADER + b'\x00\x00'
+        v = zstd.FRAME_HEADER + b"\x00\x00"
 
         mutable_array = bytearray(len(v))
         mutable_array[:] = v
 
         sources = [
             memoryview(v),
             bytearray(v),
             mutable_array,
         ]
 
         for source in sources:
             params = zstd.get_frame_parameters(source)
             self.assertEqual(params.content_size, zstd.CONTENTSIZE_UNKNOWN)
             self.assertEqual(params.window_size, 1024)
             self.assertEqual(params.dict_id, 0)
             self.assertFalse(params.has_checksum)

contrib/python-zstandard/tests/test_data_structures_fuzzing.py

@@ -1,76 +1,105 b''
 import io
 import os
 import sys
 import unittest
 
 try:
     import hypothesis
     import hypothesis.strategies as strategies
 except ImportError:
-    raise unittest.SkipTest('hypothesis not available')
+    raise unittest.SkipTest("hypothesis not available")
 
 import zstandard as zstd
 
 from .common import (
     make_cffi,
+    TestCase,
+)
+
+
+s_windowlog = strategies.integers(
+    min_value=zstd.WINDOWLOG_MIN, max_value=zstd.WINDOWLOG_MAX
+)
+s_chainlog = strategies.integers(
+    min_value=zstd.CHAINLOG_MIN, max_value=zstd.CHAINLOG_MAX
+)
+s_hashlog = strategies.integers(min_value=zstd.HASHLOG_MIN, max_value=zstd.HASHLOG_MAX)
+s_searchlog = strategies.integers(
+    min_value=zstd.SEARCHLOG_MIN, max_value=zstd.SEARCHLOG_MAX
+)
+s_minmatch = strategies.integers(
+    min_value=zstd.MINMATCH_MIN, max_value=zstd.MINMATCH_MAX
+)
+s_targetlength = strategies.integers(
+    min_value=zstd.TARGETLENGTH_MIN, max_value=zstd.TARGETLENGTH_MAX
+)
+s_strategy = strategies.sampled_from(
+    (
+        zstd.STRATEGY_FAST,
+        zstd.STRATEGY_DFAST,
+        zstd.STRATEGY_GREEDY,
+        zstd.STRATEGY_LAZY,
+        zstd.STRATEGY_LAZY2,
+        zstd.STRATEGY_BTLAZY2,
+        zstd.STRATEGY_BTOPT,
+        zstd.STRATEGY_BTULTRA,
+        zstd.STRATEGY_BTULTRA2,
+    )
 )
 
 
-s_windowlog = strategies.integers(min_value=zstd.WINDOWLOG_MIN,
-                                    max_value=zstd.WINDOWLOG_MAX)
-s_chainlog = strategies.integers(min_value=zstd.CHAINLOG_MIN,
-                                    max_value=zstd.CHAINLOG_MAX)
-s_hashlog = strategies.integers(min_value=zstd.HASHLOG_MIN,
-                                max_value=zstd.HASHLOG_MAX)
-s_searchlog = strategies.integers(min_value=zstd.SEARCHLOG_MIN,
-                                    max_value=zstd.SEARCHLOG_MAX)
-s_minmatch = strategies.integers(min_value=zstd.MINMATCH_MIN,
-                                 max_value=zstd.MINMATCH_MAX)
-s_targetlength = strategies.integers(min_value=zstd.TARGETLENGTH_MIN,
-                                     max_value=zstd.TARGETLENGTH_MAX)
-s_strategy = strategies.sampled_from((zstd.STRATEGY_FAST,
-                                        zstd.STRATEGY_DFAST,
-                                        zstd.STRATEGY_GREEDY,
-                                        zstd.STRATEGY_LAZY,
-                                        zstd.STRATEGY_LAZY2,
-                                        zstd.STRATEGY_BTLAZY2,
-                                        zstd.STRATEGY_BTOPT,
-                                        zstd.STRATEGY_BTULTRA,
-                                        zstd.STRATEGY_BTULTRA2))
-
+@make_cffi
[e-mail]("ZSTD_SLOW_TESTS" in os.environ, "ZSTD_SLOW_TESTS not set")
+class TestCompressionParametersHypothesis(TestCase):
+    @hypothesis.given(
+        s_windowlog,
+        s_chainlog,
+        s_hashlog,
+        s_searchlog,
+        s_minmatch,
+        s_targetlength,
+        s_strategy,
+    )
+    def test_valid_init(
+        self, windowlog, chainlog, hashlog, searchlog, minmatch, targetlength, strategy
+    ):
+        zstd.ZstdCompressionParameters(
+            window_log=windowlog,
+            chain_log=chainlog,
+            hash_log=hashlog,
+            search_log=searchlog,
+            min_match=minmatch,
+            target_length=targetlength,
+            strategy=strategy,
+        )
 
-@make_cffi
[e-mail]('ZSTD_SLOW_TESTS' in os.environ, 'ZSTD_SLOW_TESTS not set')
-class TestCompressionParametersHypothesis(unittest.TestCase):
-    @hypothesis.given(s_windowlog, s_chainlog, s_hashlog, s_searchlog,
-                        s_minmatch, s_targetlength, s_strategy)
-    def test_valid_init(self, windowlog, chainlog, hashlog, searchlog,
-                        minmatch, targetlength, strategy):
-        zstd.ZstdCompressionParameters(window_log=windowlog,
-                                       chain_log=chainlog,
-                                       hash_log=hashlog,
-                                       search_log=searchlog,
-                                       min_match=minmatch,
-                                       target_length=targetlength,
-                                       strategy=strategy)
-
-    @hypothesis.given(s_windowlog, s_chainlog, s_hashlog, s_searchlog,
-                      s_minmatch, s_targetlength, s_strategy)
-    def test_estimated_compression_context_size(self, windowlog, chainlog,
-                                                hashlog, searchlog,
-                                                minmatch, targetlength,
-                                                strategy):
-        if minmatch == zstd.MINMATCH_MIN and strategy in (zstd.STRATEGY_FAST, zstd.STRATEGY_GREEDY):
+    @hypothesis.given(
+        s_windowlog,
+        s_chainlog,
+        s_hashlog,
+        s_searchlog,
+        s_minmatch,
+        s_targetlength,
+        s_strategy,
+    )
+    def test_estimated_compression_context_size(
+        self, windowlog, chainlog, hashlog, searchlog, minmatch, targetlength, strategy
+    ):
+        if minmatch == zstd.MINMATCH_MIN and strategy in (
+            zstd.STRATEGY_FAST,
+            zstd.STRATEGY_GREEDY,
+        ):
             minmatch += 1
         elif minmatch == zstd.MINMATCH_MAX and strategy != zstd.STRATEGY_FAST:
             minmatch -= 1
 
-        p = zstd.ZstdCompressionParameters(window_log=windowlog,
-                                           chain_log=chainlog,
-                                           hash_log=hashlog,
-                                           search_log=searchlog,
-                                           min_match=minmatch,
-                                           target_length=targetlength,
-                                           strategy=strategy)
+        p = zstd.ZstdCompressionParameters(
+            window_log=windowlog,
+            chain_log=chainlog,
+            hash_log=hashlog,
+            search_log=searchlog,
+            min_match=minmatch,
+            target_length=targetlength,
+            strategy=strategy,
+        )
         size = p.estimated_compression_context_size()
-

contrib/python-zstandard/tests/test_decompressor.py

@@ -1,1611 +1,1670 b''
 import io
 import os
 import random
 import struct
 import sys
 import tempfile
 import unittest
 
 import zstandard as zstd
 
 from .common import (
     generate_samples,
     make_cffi,
     NonClosingBytesIO,
     OpCountingBytesIO,
+    TestCase,
 )
 
 
 if sys.version_info[0] >= 3:
     next = lambda it: it.__next__()
 else:
     next = lambda it: it.next()
 
 
 @make_cffi
-class TestFrameHeaderSize(unittest.TestCase):
+class TestFrameHeaderSize(TestCase):
     def test_empty(self):
-        with self.assertRaisesRegexp(
-            zstd.ZstdError, 'could not determine frame header size: Src size '
-                            'is incorrect'):
-            zstd.frame_header_size(b'')
+        with self.assertRaisesRegex(
+            zstd.ZstdError,
+            "could not determine frame header size: Src size " "is incorrect",
+        ):
+            zstd.frame_header_size(b"")
 
     def test_too_small(self):
-        with self.assertRaisesRegexp(
-            zstd.ZstdError, 'could not determine frame header size: Src size '
-                            'is incorrect'):
-            zstd.frame_header_size(b'foob')
+        with self.assertRaisesRegex(
+            zstd.ZstdError,
+            "could not determine frame header size: Src size " "is incorrect",
+        ):
+            zstd.frame_header_size(b"foob")
 
     def test_basic(self):
         # It doesn't matter that it isn't a valid frame.
-        self.assertEqual(zstd.frame_header_size(b'long enough but no magic'), 6)
+        self.assertEqual(zstd.frame_header_size(b"long enough but no magic"), 6)
 
 
 @make_cffi
-class TestFrameContentSize(unittest.TestCase):
+class TestFrameContentSize(TestCase):
     def test_empty(self):
-        with self.assertRaisesRegexp(zstd.ZstdError,
-                                     'error when determining content size'):
-            zstd.frame_content_size(b'')
+        with self.assertRaisesRegex(
+            zstd.ZstdError, "error when determining content size"
+        ):
+            zstd.frame_content_size(b"")
 
     def test_too_small(self):
-        with self.assertRaisesRegexp(zstd.ZstdError,
-                                     'error when determining content size'):
-            zstd.frame_content_size(b'foob')
+        with self.assertRaisesRegex(
+            zstd.ZstdError, "error when determining content size"
+        ):
+            zstd.frame_content_size(b"foob")
 
     def test_bad_frame(self):
-        with self.assertRaisesRegexp(zstd.ZstdError,
-                                     'error when determining content size'):
-            zstd.frame_content_size(b'invalid frame header')
+        with self.assertRaisesRegex(
+            zstd.ZstdError, "error when determining content size"
+        ):
+            zstd.frame_content_size(b"invalid frame header")
 
     def test_unknown(self):
         cctx = zstd.ZstdCompressor(write_content_size=False)
-        frame = cctx.compress(b'foobar')
+        frame = cctx.compress(b"foobar")
 
         self.assertEqual(zstd.frame_content_size(frame), -1)
 
     def test_empty(self):
         cctx = zstd.ZstdCompressor()
-        frame = cctx.compress(b'')
+        frame = cctx.compress(b"")
 
         self.assertEqual(zstd.frame_content_size(frame), 0)
 
     def test_basic(self):
         cctx = zstd.ZstdCompressor()
-        frame = cctx.compress(b'foobar')
+        frame = cctx.compress(b"foobar")
 
         self.assertEqual(zstd.frame_content_size(frame), 6)
 
 
 @make_cffi
-class TestDecompressor(unittest.TestCase):
+class TestDecompressor(TestCase):
     def test_memory_size(self):
         dctx = zstd.ZstdDecompressor()
 
         self.assertGreater(dctx.memory_size(), 100)
 
 
 @make_cffi
-class TestDecompressor_decompress(unittest.TestCase):
+class TestDecompressor_decompress(TestCase):
     def test_empty_input(self):
         dctx = zstd.ZstdDecompressor()
 
-        with self.assertRaisesRegexp(zstd.ZstdError, 'error determining content size from frame header'):
-            dctx.decompress(b'')
+        with self.assertRaisesRegex(
+            zstd.ZstdError, "error determining content size from frame header"
+        ):
+            dctx.decompress(b"")
 
     def test_invalid_input(self):
         dctx = zstd.ZstdDecompressor()
 
-        with self.assertRaisesRegexp(zstd.ZstdError, 'error determining content size from frame header'):
-            dctx.decompress(b'foobar')
+        with self.assertRaisesRegex(
+            zstd.ZstdError, "error determining content size from frame header"
+        ):
+            dctx.decompress(b"foobar")
 
     def test_input_types(self):
         cctx = zstd.ZstdCompressor(level=1)
-        compressed = cctx.compress(b'foo')
+        compressed = cctx.compress(b"foo")
 
         mutable_array = bytearray(len(compressed))
         mutable_array[:] = compressed
 
         sources = [
             memoryview(compressed),
             bytearray(compressed),
             mutable_array,
         ]
 
         dctx = zstd.ZstdDecompressor()
         for source in sources:
-            self.assertEqual(dctx.decompress(source), b'foo')
+            self.assertEqual(dctx.decompress(source), b"foo")
 
     def test_no_content_size_in_frame(self):
         cctx = zstd.ZstdCompressor(write_content_size=False)
-        compressed = cctx.compress(b'foobar')
+        compressed = cctx.compress(b"foobar")
 
         dctx = zstd.ZstdDecompressor()
-        with self.assertRaisesRegexp(zstd.ZstdError, 'could not determine content size in frame header'):
+        with self.assertRaisesRegex(
+            zstd.ZstdError, "could not determine content size in frame header"
+        ):
             dctx.decompress(compressed)
 
     def test_content_size_present(self):
         cctx = zstd.ZstdCompressor()
-        compressed = cctx.compress(b'foobar')
+        compressed = cctx.compress(b"foobar")
 
         dctx = zstd.ZstdDecompressor()
         decompressed = dctx.decompress(compressed)
-        self.assertEqual(decompressed, b'foobar')
+        self.assertEqual(decompressed, b"foobar")
 
     def test_empty_roundtrip(self):
         cctx = zstd.ZstdCompressor()
-        compressed = cctx.compress(b'')
+        compressed = cctx.compress(b"")
 
         dctx = zstd.ZstdDecompressor()
         decompressed = dctx.decompress(compressed)
 
-        self.assertEqual(decompressed, b'')
+        self.assertEqual(decompressed, b"")
 
     def test_max_output_size(self):
         cctx = zstd.ZstdCompressor(write_content_size=False)
-        source = b'foobar' * 256
+        source = b"foobar" * 256
         compressed = cctx.compress(source)
 
         dctx = zstd.ZstdDecompressor()
         # Will fit into buffer exactly the size of input.
         decompressed = dctx.decompress(compressed, max_output_size=len(source))
         self.assertEqual(decompressed, source)
 
         # Input size - 1 fails
-        with self.assertRaisesRegexp(zstd.ZstdError,
-                'decompression error: did not decompress full frame'):
+        with self.assertRaisesRegex(
+            zstd.ZstdError, "decompression error: did not decompress full frame"
+        ):
             dctx.decompress(compressed, max_output_size=len(source) - 1)
 
         # Input size + 1 works
         decompressed = dctx.decompress(compressed, max_output_size=len(source) + 1)
         self.assertEqual(decompressed, source)
 
         # A much larger buffer works.
         decompressed = dctx.decompress(compressed, max_output_size=len(source) * 64)
         self.assertEqual(decompressed, source)
 
     def test_stupidly_large_output_buffer(self):
         cctx = zstd.ZstdCompressor(write_content_size=False)
-        compressed = cctx.compress(b'foobar' * 256)
+        compressed = cctx.compress(b"foobar" * 256)
         dctx = zstd.ZstdDecompressor()
 
         # Will get OverflowError on some Python distributions that can't
         # handle really large integers.
         with self.assertRaises((MemoryError, OverflowError)):
-            dctx.decompress(compressed, max_output_size=2**62)
+            dctx.decompress(compressed, max_output_size=2 ** 62)
 
     def test_dictionary(self):
         samples = []
         for i in range(128):
-            samples.append(b'foo' * 64)
-            samples.append(b'bar' * 64)
-            samples.append(b'foobar' * 64)
+            samples.append(b"foo" * 64)
+            samples.append(b"bar" * 64)
+            samples.append(b"foobar" * 64)
 
         d = zstd.train_dictionary(8192, samples)
 
-        orig = b'foobar' * 16384
+        orig = b"foobar" * 16384
         cctx = zstd.ZstdCompressor(level=1, dict_data=d)
         compressed = cctx.compress(orig)
 
         dctx = zstd.ZstdDecompressor(dict_data=d)
         decompressed = dctx.decompress(compressed)
 
         self.assertEqual(decompressed, orig)
 
     def test_dictionary_multiple(self):
         samples = []
         for i in range(128):
-            samples.append(b'foo' * 64)
-            samples.append(b'bar' * 64)
-            samples.append(b'foobar' * 64)
+            samples.append(b"foo" * 64)
+            samples.append(b"bar" * 64)
+            samples.append(b"foobar" * 64)
 
         d = zstd.train_dictionary(8192, samples)
 
-        sources = (b'foobar' * 8192, b'foo' * 8192, b'bar' * 8192)
+        sources = (b"foobar" * 8192, b"foo" * 8192, b"bar" * 8192)
         compressed = []
         cctx = zstd.ZstdCompressor(level=1, dict_data=d)
         for source in sources:
             compressed.append(cctx.compress(source))
 
         dctx = zstd.ZstdDecompressor(dict_data=d)
         for i in range(len(sources)):
             decompressed = dctx.decompress(compressed[i])
             self.assertEqual(decompressed, sources[i])
 
     def test_max_window_size(self):
-        with open(__file__, 'rb') as fh:
+        with open(__file__, "rb") as fh:
             source = fh.read()
 
         # If we write a content size, the decompressor engages single pass
         # mode and the window size doesn't come into play.
         cctx = zstd.ZstdCompressor(write_content_size=False)
         frame = cctx.compress(source)
 
-        dctx = zstd.ZstdDecompressor(max_window_size=2**zstd.WINDOWLOG_MIN)
+        dctx = zstd.ZstdDecompressor(max_window_size=2 ** zstd.WINDOWLOG_MIN)
 
-        with self.assertRaisesRegexp(
-            zstd.ZstdError, 'decompression error: Frame requires too much memory'):
+        with self.assertRaisesRegex(
+            zstd.ZstdError, "decompression error: Frame requires too much memory"
+        ):
             dctx.decompress(frame, max_output_size=len(source))
 
 
 @make_cffi
-class TestDecompressor_copy_stream(unittest.TestCase):
+class TestDecompressor_copy_stream(TestCase):
     def test_no_read(self):
         source = object()
         dest = io.BytesIO()
 
         dctx = zstd.ZstdDecompressor()
         with self.assertRaises(ValueError):
             dctx.copy_stream(source, dest)
 
     def test_no_write(self):
         source = io.BytesIO()
         dest = object()
 
         dctx = zstd.ZstdDecompressor()
         with self.assertRaises(ValueError):
             dctx.copy_stream(source, dest)
 
     def test_empty(self):
         source = io.BytesIO()
         dest = io.BytesIO()
 
         dctx = zstd.ZstdDecompressor()
         # TODO should this raise an error?
         r, w = dctx.copy_stream(source, dest)
 
         self.assertEqual(r, 0)
         self.assertEqual(w, 0)
-        self.assertEqual(dest.getvalue(), b'')
+        self.assertEqual(dest.getvalue(), b"")
 
     def test_large_data(self):
         source = io.BytesIO()
         for i in range(255):
-            source.write(struct.Struct('>B').pack(i) * 16384)
+            source.write(struct.Struct(">B").pack(i) * 16384)
         source.seek(0)
 
         compressed = io.BytesIO()
         cctx = zstd.ZstdCompressor()
         cctx.copy_stream(source, compressed)
 
         compressed.seek(0)
         dest = io.BytesIO()
         dctx = zstd.ZstdDecompressor()
         r, w = dctx.copy_stream(compressed, dest)
 
         self.assertEqual(r, len(compressed.getvalue()))
         self.assertEqual(w, len(source.getvalue()))
 
     def test_read_write_size(self):
-        source = OpCountingBytesIO(zstd.ZstdCompressor().compress(
-            b'foobarfoobar'))
+        source = OpCountingBytesIO(zstd.ZstdCompressor().compress(b"foobarfoobar"))
 
         dest = OpCountingBytesIO()
         dctx = zstd.ZstdDecompressor()
         r, w = dctx.copy_stream(source, dest, read_size=1, write_size=1)
 
         self.assertEqual(r, len(source.getvalue()))
-        self.assertEqual(w, len(b'foobarfoobar'))
+        self.assertEqual(w, len(b"foobarfoobar"))
         self.assertEqual(source._read_count, len(source.getvalue()) + 1)
         self.assertEqual(dest._write_count, len(dest.getvalue()))
 
 
 @make_cffi
-class TestDecompressor_stream_reader(unittest.TestCase):
+class TestDecompressor_stream_reader(TestCase):
     def test_context_manager(self):
         dctx = zstd.ZstdDecompressor()
 
-        with dctx.stream_reader(b'foo') as reader:
-            with self.assertRaisesRegexp(ValueError, 'cannot __enter__ multiple times'):
+        with dctx.stream_reader(b"foo") as reader:
+            with self.assertRaisesRegex(ValueError, "cannot __enter__ multiple times"):
                 with reader as reader2:
                     pass
 
     def test_not_implemented(self):
         dctx = zstd.ZstdDecompressor()
 
-        with dctx.stream_reader(b'foo') as reader:
+        with dctx.stream_reader(b"foo") as reader:
             with self.assertRaises(io.UnsupportedOperation):
                 reader.readline()
 
             with self.assertRaises(io.UnsupportedOperation):
                 reader.readlines()
 
             with self.assertRaises(io.UnsupportedOperation):
                 iter(reader)
 
             with self.assertRaises(io.UnsupportedOperation):
                 next(reader)
 
             with self.assertRaises(io.UnsupportedOperation):
-                reader.write(b'foo')
+                reader.write(b"foo")
 
             with self.assertRaises(io.UnsupportedOperation):
                 reader.writelines([])
 
     def test_constant_methods(self):
         dctx = zstd.ZstdDecompressor()
 
-        with dctx.stream_reader(b'foo') as reader:
+        with dctx.stream_reader(b"foo") as reader:
             self.assertFalse(reader.closed)
             self.assertTrue(reader.readable())
             self.assertFalse(reader.writable())
             self.assertTrue(reader.seekable())
             self.assertFalse(reader.isatty())
             self.assertFalse(reader.closed)
             self.assertIsNone(reader.flush())
             self.assertFalse(reader.closed)
 
         self.assertTrue(reader.closed)
 
     def test_read_closed(self):
         dctx = zstd.ZstdDecompressor()
 
-        with dctx.stream_reader(b'foo') as reader:
+        with dctx.stream_reader(b"foo") as reader:
             reader.close()
             self.assertTrue(reader.closed)
-            with self.assertRaisesRegexp(ValueError, 'stream is closed'):
+            with self.assertRaisesRegex(ValueError, "stream is closed"):
                 reader.read(1)
 
     def test_read_sizes(self):
         cctx = zstd.ZstdCompressor()
-        foo = cctx.compress(b'foo')
+        foo = cctx.compress(b"foo")
 
         dctx = zstd.ZstdDecompressor()
 
         with dctx.stream_reader(foo) as reader:
-            with self.assertRaisesRegexp(ValueError, 'cannot read negative amounts less than -1'):
+            with self.assertRaisesRegex(
+                ValueError, "cannot read negative amounts less than -1"
+            ):
                 reader.read(-2)
 
-            self.assertEqual(reader.read(0), b'')
-            self.assertEqual(reader.read(), b'foo')
+            self.assertEqual(reader.read(0), b"")
+            self.assertEqual(reader.read(), b"foo")
 
     def test_read_buffer(self):
         cctx = zstd.ZstdCompressor()
 
-        source = b''.join([b'foo' * 60, b'bar' * 60, b'baz' * 60])
+        source = b"".join([b"foo" * 60, b"bar" * 60, b"baz" * 60])
         frame = cctx.compress(source)
 
         dctx = zstd.ZstdDecompressor()
 
         with dctx.stream_reader(frame) as reader:
             self.assertEqual(reader.tell(), 0)
 
             # We should get entire frame in one read.
             result = reader.read(8192)
             self.assertEqual(result, source)
             self.assertEqual(reader.tell(), len(source))
 
             # Read after EOF should return empty bytes.
-            self.assertEqual(reader.read(1), b'')
+            self.assertEqual(reader.read(1), b"")
             self.assertEqual(reader.tell(), len(result))
 
         self.assertTrue(reader.closed)
 
     def test_read_buffer_small_chunks(self):
         cctx = zstd.ZstdCompressor()
-        source = b''.join([b'foo' * 60, b'bar' * 60, b'baz' * 60])
+        source = b"".join([b"foo" * 60, b"bar" * 60, b"baz" * 60])
         frame = cctx.compress(source)
 
         dctx = zstd.ZstdDecompressor()
         chunks = []
 
         with dctx.stream_reader(frame, read_size=1) as reader:
             while True:
                 chunk = reader.read(1)
                 if not chunk:
                     break
 
                 chunks.append(chunk)
                 self.assertEqual(reader.tell(), sum(map(len, chunks)))
 
-        self.assertEqual(b''.join(chunks), source)
+        self.assertEqual(b"".join(chunks), source)
 
     def test_read_stream(self):
         cctx = zstd.ZstdCompressor()
-        source = b''.join([b'foo' * 60, b'bar' * 60, b'baz' * 60])
+        source = b"".join([b"foo" * 60, b"bar" * 60, b"baz" * 60])
         frame = cctx.compress(source)
 
         dctx = zstd.ZstdDecompressor()
         with dctx.stream_reader(io.BytesIO(frame)) as reader:
             self.assertEqual(reader.tell(), 0)
 
             chunk = reader.read(8192)
             self.assertEqual(chunk, source)
             self.assertEqual(reader.tell(), len(source))
-            self.assertEqual(reader.read(1), b'')
+            self.assertEqual(reader.read(1), b"")
             self.assertEqual(reader.tell(), len(source))
             self.assertFalse(reader.closed)
 
         self.assertTrue(reader.closed)
 
     def test_read_stream_small_chunks(self):
         cctx = zstd.ZstdCompressor()
-        source = b''.join([b'foo' * 60, b'bar' * 60, b'baz' * 60])
+        source = b"".join([b"foo" * 60, b"bar" * 60, b"baz" * 60])
         frame = cctx.compress(source)
 
         dctx = zstd.ZstdDecompressor()
         chunks = []
 
         with dctx.stream_reader(io.BytesIO(frame), read_size=1) as reader:
             while True:
                 chunk = reader.read(1)
                 if not chunk:
                     break
 
                 chunks.append(chunk)
                 self.assertEqual(reader.tell(), sum(map(len, chunks)))
 
-        self.assertEqual(b''.join(chunks), source)
+        self.assertEqual(b"".join(chunks), source)
 
     def test_read_after_exit(self):
         cctx = zstd.ZstdCompressor()
-        frame = cctx.compress(b'foo' * 60)
+        frame = cctx.compress(b"foo" * 60)
 
         dctx = zstd.ZstdDecompressor()
 
         with dctx.stream_reader(frame) as reader:
             while reader.read(16):
                 pass
 
         self.assertTrue(reader.closed)
 
-        with self.assertRaisesRegexp(ValueError, 'stream is closed'):
+        with self.assertRaisesRegex(ValueError, "stream is closed"):
             reader.read(10)
 
     def test_illegal_seeks(self):
         cctx = zstd.ZstdCompressor()
-        frame = cctx.compress(b'foo' * 60)
+        frame = cctx.compress(b"foo" * 60)
 
         dctx = zstd.ZstdDecompressor()
 
         with dctx.stream_reader(frame) as reader:
-            with self.assertRaisesRegexp(ValueError,
-                                         'cannot seek to negative position'):
+            with self.assertRaisesRegex(ValueError, "cannot seek to negative position"):
                 reader.seek(-1, os.SEEK_SET)
 
             reader.read(1)
 
-            with self.assertRaisesRegexp(
-                ValueError, 'cannot seek zstd decompression stream backwards'):
+            with self.assertRaisesRegex(
+                ValueError, "cannot seek zstd decompression stream backwards"
+            ):
                 reader.seek(0, os.SEEK_SET)
 
-            with self.assertRaisesRegexp(
-                ValueError, 'cannot seek zstd decompression stream backwards'):
+            with self.assertRaisesRegex(
+                ValueError, "cannot seek zstd decompression stream backwards"
+            ):
                 reader.seek(-1, os.SEEK_CUR)
 
-            with self.assertRaisesRegexp(
-                ValueError,
-                'zstd decompression streams cannot be seeked with SEEK_END'):
+            with self.assertRaisesRegex(
+                ValueError, "zstd decompression streams cannot be seeked with SEEK_END"
+            ):
                 reader.seek(0, os.SEEK_END)
 
             reader.close()
 
-            with self.assertRaisesRegexp(ValueError, 'stream is closed'):
+            with self.assertRaisesRegex(ValueError, "stream is closed"):
                 reader.seek(4, os.SEEK_SET)
 
-        with self.assertRaisesRegexp(ValueError, 'stream is closed'):
+        with self.assertRaisesRegex(ValueError, "stream is closed"):
             reader.seek(0)
 
     def test_seek(self):
-        source = b'foobar' * 60
+        source = b"foobar" * 60
         cctx = zstd.ZstdCompressor()
         frame = cctx.compress(source)
 
         dctx = zstd.ZstdDecompressor()
 
         with dctx.stream_reader(frame) as reader:
             reader.seek(3)
-            self.assertEqual(reader.read(3), b'bar')
+            self.assertEqual(reader.read(3), b"bar")
 
             reader.seek(4, os.SEEK_CUR)
-            self.assertEqual(reader.read(2), b'ar')
+            self.assertEqual(reader.read(2), b"ar")
 
     def test_no_context_manager(self):
-        source = b'foobar' * 60
+        source = b"foobar" * 60
         cctx = zstd.ZstdCompressor()
         frame = cctx.compress(source)
 
         dctx = zstd.ZstdDecompressor()
         reader = dctx.stream_reader(frame)
 
-        self.assertEqual(reader.read(6), b'foobar')
-        self.assertEqual(reader.read(18), b'foobar' * 3)
+        self.assertEqual(reader.read(6), b"foobar")
+        self.assertEqual(reader.read(18), b"foobar" * 3)
         self.assertFalse(reader.closed)
 
         # Calling close prevents subsequent use.
         reader.close()
         self.assertTrue(reader.closed)
 
-        with self.assertRaisesRegexp(ValueError, 'stream is closed'):
+        with self.assertRaisesRegex(ValueError, "stream is closed"):
             reader.read(6)
 
     def test_read_after_error(self):
-        source = io.BytesIO(b'')
+        source = io.BytesIO(b"")
         dctx = zstd.ZstdDecompressor()
 
         reader = dctx.stream_reader(source)
 
         with reader:
             reader.read(0)
 
         with reader:
-            with self.assertRaisesRegexp(ValueError, 'stream is closed'):
+            with self.assertRaisesRegex(ValueError, "stream is closed"):
                 reader.read(100)
 
     def test_partial_read(self):
         # Inspired by https://github.com/indygreg/python-zstandard/issues/71.
         buffer = io.BytesIO()
         cctx = zstd.ZstdCompressor()
         writer = cctx.stream_writer(buffer)
         writer.write(bytearray(os.urandom(1000000)))
         writer.flush(zstd.FLUSH_FRAME)
         buffer.seek(0)
 
         dctx = zstd.ZstdDecompressor()
         reader = dctx.stream_reader(buffer)
 
         while True:
             chunk = reader.read(8192)
             if not chunk:
                 break
 
     def test_read_multiple_frames(self):
         cctx = zstd.ZstdCompressor()
         source = io.BytesIO()
         writer = cctx.stream_writer(source)
-        writer.write(b'foo')
+        writer.write(b"foo")
         writer.flush(zstd.FLUSH_FRAME)
-        writer.write(b'bar')
+        writer.write(b"bar")
         writer.flush(zstd.FLUSH_FRAME)
 
         dctx = zstd.ZstdDecompressor()
 
         reader = dctx.stream_reader(source.getvalue())
-        self.assertEqual(reader.read(2), b'fo')
-        self.assertEqual(reader.read(2), b'o')
-        self.assertEqual(reader.read(2), b'ba')
-        self.assertEqual(reader.read(2), b'r')
+        self.assertEqual(reader.read(2), b"fo")
+        self.assertEqual(reader.read(2), b"o")
+        self.assertEqual(reader.read(2), b"ba")
+        self.assertEqual(reader.read(2), b"r")
 
         source.seek(0)
         reader = dctx.stream_reader(source)
-        self.assertEqual(reader.read(2), b'fo')
-        self.assertEqual(reader.read(2), b'o')
-        self.assertEqual(reader.read(2), b'ba')
-        self.assertEqual(reader.read(2), b'r')
+        self.assertEqual(reader.read(2), b"fo")
+        self.assertEqual(reader.read(2), b"o")
+        self.assertEqual(reader.read(2), b"ba")
+        self.assertEqual(reader.read(2), b"r")
 
         reader = dctx.stream_reader(source.getvalue())
-        self.assertEqual(reader.read(3), b'foo')
-        self.assertEqual(reader.read(3), b'bar')
+        self.assertEqual(reader.read(3), b"foo")
+        self.assertEqual(reader.read(3), b"bar")
 
         source.seek(0)
         reader = dctx.stream_reader(source)
-        self.assertEqual(reader.read(3), b'foo')
-        self.assertEqual(reader.read(3), b'bar')
+        self.assertEqual(reader.read(3), b"foo")
+        self.assertEqual(reader.read(3), b"bar")
 
         reader = dctx.stream_reader(source.getvalue())
-        self.assertEqual(reader.read(4), b'foo')
-        self.assertEqual(reader.read(4), b'bar')
+        self.assertEqual(reader.read(4), b"foo")
+        self.assertEqual(reader.read(4), b"bar")
 
         source.seek(0)
         reader = dctx.stream_reader(source)
-        self.assertEqual(reader.read(4), b'foo')
-        self.assertEqual(reader.read(4), b'bar')
+        self.assertEqual(reader.read(4), b"foo")
+        self.assertEqual(reader.read(4), b"bar")
 
         reader = dctx.stream_reader(source.getvalue())
-        self.assertEqual(reader.read(128), b'foo')
-        self.assertEqual(reader.read(128), b'bar')
+        self.assertEqual(reader.read(128), b"foo")
+        self.assertEqual(reader.read(128), b"bar")
 
         source.seek(0)
         reader = dctx.stream_reader(source)
-        self.assertEqual(reader.read(128), b'foo')
-        self.assertEqual(reader.read(128), b'bar')
+        self.assertEqual(reader.read(128), b"foo")
+        self.assertEqual(reader.read(128), b"bar")
 
         # Now tests for reads spanning frames.
         reader = dctx.stream_reader(source.getvalue(), read_across_frames=True)
-        self.assertEqual(reader.read(3), b'foo')
-        self.assertEqual(reader.read(3), b'bar')
+        self.assertEqual(reader.read(3), b"foo")
+        self.assertEqual(reader.read(3), b"bar")
 
         source.seek(0)
         reader = dctx.stream_reader(source, read_across_frames=True)
-        self.assertEqual(reader.read(3), b'foo')
-        self.assertEqual(reader.read(3), b'bar')
+        self.assertEqual(reader.read(3), b"foo")
+        self.assertEqual(reader.read(3), b"bar")
 
         reader = dctx.stream_reader(source.getvalue(), read_across_frames=True)
-        self.assertEqual(reader.read(6), b'foobar')
+        self.assertEqual(reader.read(6), b"foobar")
 
         source.seek(0)
         reader = dctx.stream_reader(source, read_across_frames=True)
-        self.assertEqual(reader.read(6), b'foobar')
+        self.assertEqual(reader.read(6), b"foobar")
 
         reader = dctx.stream_reader(source.getvalue(), read_across_frames=True)
-        self.assertEqual(reader.read(7), b'foobar')
+        self.assertEqual(reader.read(7), b"foobar")
 
         source.seek(0)
         reader = dctx.stream_reader(source, read_across_frames=True)
-        self.assertEqual(reader.read(7), b'foobar')
+        self.assertEqual(reader.read(7), b"foobar")
 
         reader = dctx.stream_reader(source.getvalue(), read_across_frames=True)
-        self.assertEqual(reader.read(128), b'foobar')
+        self.assertEqual(reader.read(128), b"foobar")
 
         source.seek(0)
         reader = dctx.stream_reader(source, read_across_frames=True)
-        self.assertEqual(reader.read(128), b'foobar')
+        self.assertEqual(reader.read(128), b"foobar")
 
     def test_readinto(self):
         cctx = zstd.ZstdCompressor()
-        foo = cctx.compress(b'foo')
+        foo = cctx.compress(b"foo")
 
         dctx = zstd.ZstdDecompressor()
 
         # Attempting to readinto() a non-writable buffer fails.
         # The exact exception varies based on the backend.
         reader = dctx.stream_reader(foo)
         with self.assertRaises(Exception):
-            reader.readinto(b'foobar')
+            reader.readinto(b"foobar")
 
         # readinto() with sufficiently large destination.
         b = bytearray(1024)
         reader = dctx.stream_reader(foo)
         self.assertEqual(reader.readinto(b), 3)
-        self.assertEqual(b[0:3], b'foo')
+        self.assertEqual(b[0:3], b"foo")
         self.assertEqual(reader.readinto(b), 0)
-        self.assertEqual(b[0:3], b'foo')
+        self.assertEqual(b[0:3], b"foo")
 
         # readinto() with small reads.
         b = bytearray(1024)
         reader = dctx.stream_reader(foo, read_size=1)
         self.assertEqual(reader.readinto(b), 3)
-        self.assertEqual(b[0:3], b'foo')
+        self.assertEqual(b[0:3], b"foo")
 
         # Too small destination buffer.
         b = bytearray(2)
         reader = dctx.stream_reader(foo)
         self.assertEqual(reader.readinto(b), 2)
-        self.assertEqual(b[:], b'fo')
+        self.assertEqual(b[:], b"fo")
 
     def test_readinto1(self):
         cctx = zstd.ZstdCompressor()
-        foo = cctx.compress(b'foo')
+        foo = cctx.compress(b"foo")
 
         dctx = zstd.ZstdDecompressor()
 
         reader = dctx.stream_reader(foo)
         with self.assertRaises(Exception):
-            reader.readinto1(b'foobar')
+            reader.readinto1(b"foobar")
 
         # Sufficiently large destination.
         b = bytearray(1024)
         reader = dctx.stream_reader(foo)
         self.assertEqual(reader.readinto1(b), 3)
-        self.assertEqual(b[0:3], b'foo')
+        self.assertEqual(b[0:3], b"foo")
         self.assertEqual(reader.readinto1(b), 0)
-        self.assertEqual(b[0:3], b'foo')
+        self.assertEqual(b[0:3], b"foo")
 
         # readinto() with small reads.
         b = bytearray(1024)
         reader = dctx.stream_reader(foo, read_size=1)
         self.assertEqual(reader.readinto1(b), 3)
-        self.assertEqual(b[0:3], b'foo')
+        self.assertEqual(b[0:3], b"foo")
 
         # Too small destination buffer.
         b = bytearray(2)
         reader = dctx.stream_reader(foo)
         self.assertEqual(reader.readinto1(b), 2)
-        self.assertEqual(b[:], b'fo')
+        self.assertEqual(b[:], b"fo")
 
     def test_readall(self):
         cctx = zstd.ZstdCompressor()
-        foo = cctx.compress(b'foo')
+        foo = cctx.compress(b"foo")
 
         dctx = zstd.ZstdDecompressor()
         reader = dctx.stream_reader(foo)
 
-        self.assertEqual(reader.readall(), b'foo')
+        self.assertEqual(reader.readall(), b"foo")
 
     def test_read1(self):
         cctx = zstd.ZstdCompressor()
-        foo = cctx.compress(b'foo')
+        foo = cctx.compress(b"foo")
 
         dctx = zstd.ZstdDecompressor()
 
         b = OpCountingBytesIO(foo)
         reader = dctx.stream_reader(b)
 
-        self.assertEqual(reader.read1(), b'foo')
+        self.assertEqual(reader.read1(), b"foo")
         self.assertEqual(b._read_count, 1)
 
         b = OpCountingBytesIO(foo)
         reader = dctx.stream_reader(b)
 
-        self.assertEqual(reader.read1(0), b'')
-        self.assertEqual(reader.read1(2), b'fo')
+        self.assertEqual(reader.read1(0), b"")
+        self.assertEqual(reader.read1(2), b"fo")
         self.assertEqual(b._read_count, 1)
-        self.assertEqual(reader.read1(1), b'o')
+        self.assertEqual(reader.read1(1), b"o")
         self.assertEqual(b._read_count, 1)
-        self.assertEqual(reader.read1(1), b'')
+        self.assertEqual(reader.read1(1), b"")
         self.assertEqual(b._read_count, 2)
 
     def test_read_lines(self):
         cctx = zstd.ZstdCompressor()
-        source = b'\n'.join(('line %d' % i).encode('ascii') for i in range(1024))
+        source = b"\n".join(("line %d" % i).encode("ascii") for i in range(1024))
 
         frame = cctx.compress(source)
 
         dctx = zstd.ZstdDecompressor()
         reader = dctx.stream_reader(frame)
-        tr = io.TextIOWrapper(reader, encoding='utf-8')
+        tr = io.TextIOWrapper(reader, encoding="utf-8")
 
         lines = []
         for line in tr:
-            lines.append(line.encode('utf-8'))
+            lines.append(line.encode("utf-8"))
 
         self.assertEqual(len(lines), 1024)
-        self.assertEqual(b''.join(lines), source)
+        self.assertEqual(b"".join(lines), source)
 
         reader = dctx.stream_reader(frame)
-        tr = io.TextIOWrapper(reader, encoding='utf-8')
+        tr = io.TextIOWrapper(reader, encoding="utf-8")
 
         lines = tr.readlines()
         self.assertEqual(len(lines), 1024)
-        self.assertEqual(''.join(lines).encode('utf-8'), source)
+        self.assertEqual("".join(lines).encode("utf-8"), source)
 
         reader = dctx.stream_reader(frame)
-        tr = io.TextIOWrapper(reader, encoding='utf-8')
+        tr = io.TextIOWrapper(reader, encoding="utf-8")
 
         lines = []
         while True:
             line = tr.readline()
             if not line:
                 break
 
-            lines.append(line.encode('utf-8'))
+            lines.append(line.encode("utf-8"))
 
         self.assertEqual(len(lines), 1024)
-        self.assertEqual(b''.join(lines), source)
+        self.assertEqual(b"".join(lines), source)
 
 
 @make_cffi
-class TestDecompressor_decompressobj(unittest.TestCase):
+class TestDecompressor_decompressobj(TestCase):
     def test_simple(self):
-        data = zstd.ZstdCompressor(level=1).compress(b'foobar')
+        data = zstd.ZstdCompressor(level=1).compress(b"foobar")
 
         dctx = zstd.ZstdDecompressor()
         dobj = dctx.decompressobj()
-        self.assertEqual(dobj.decompress(data), b'foobar')
+        self.assertEqual(dobj.decompress(data), b"foobar")
         self.assertIsNone(dobj.flush())
         self.assertIsNone(dobj.flush(10))
         self.assertIsNone(dobj.flush(length=100))
 
     def test_input_types(self):
-        compressed = zstd.ZstdCompressor(level=1).compress(b'foo')
+        compressed = zstd.ZstdCompressor(level=1).compress(b"foo")
 
         dctx = zstd.ZstdDecompressor()
 
         mutable_array = bytearray(len(compressed))
         mutable_array[:] = compressed
 
         sources = [
             memoryview(compressed),
             bytearray(compressed),
             mutable_array,
         ]
 
         for source in sources:
             dobj = dctx.decompressobj()
             self.assertIsNone(dobj.flush())
             self.assertIsNone(dobj.flush(10))
             self.assertIsNone(dobj.flush(length=100))
-            self.assertEqual(dobj.decompress(source), b'foo')
+            self.assertEqual(dobj.decompress(source), b"foo")
             self.assertIsNone(dobj.flush())
 
     def test_reuse(self):
-        data = zstd.ZstdCompressor(level=1).compress(b'foobar')
+        data = zstd.ZstdCompressor(level=1).compress(b"foobar")
 
         dctx = zstd.ZstdDecompressor()
         dobj = dctx.decompressobj()
         dobj.decompress(data)
 
-        with self.assertRaisesRegexp(zstd.ZstdError, 'cannot use a decompressobj'):
+        with self.assertRaisesRegex(zstd.ZstdError, "cannot use a decompressobj"):
             dobj.decompress(data)
             self.assertIsNone(dobj.flush())
 
     def test_bad_write_size(self):
         dctx = zstd.ZstdDecompressor()
 
-        with self.assertRaisesRegexp(ValueError, 'write_size must be positive'):
+        with self.assertRaisesRegex(ValueError, "write_size must be positive"):
             dctx.decompressobj(write_size=0)
 
     def test_write_size(self):
-        source = b'foo' * 64 + b'bar' * 128
+        source = b"foo" * 64 + b"bar" * 128
         data = zstd.ZstdCompressor(level=1).compress(source)
 
         dctx = zstd.ZstdDecompressor()
 
         for i in range(128):
             dobj = dctx.decompressobj(write_size=i + 1)
             self.assertEqual(dobj.decompress(data), source)
 
 
 def decompress_via_writer(data):
     buffer = io.BytesIO()
     dctx = zstd.ZstdDecompressor()
     decompressor = dctx.stream_writer(buffer)
     decompressor.write(data)
 
     return buffer.getvalue()
 
 
 @make_cffi
-class TestDecompressor_stream_writer(unittest.TestCase):
+class TestDecompressor_stream_writer(TestCase):
     def test_io_api(self):
         buffer = io.BytesIO()
         dctx = zstd.ZstdDecompressor()
         writer = dctx.stream_writer(buffer)
 
         self.assertFalse(writer.closed)
         self.assertFalse(writer.isatty())
         self.assertFalse(writer.readable())
 
         with self.assertRaises(io.UnsupportedOperation):
             writer.readline()
 
         with self.assertRaises(io.UnsupportedOperation):
             writer.readline(42)
 
         with self.assertRaises(io.UnsupportedOperation):
             writer.readline(size=42)
 
         with self.assertRaises(io.UnsupportedOperation):
             writer.readlines()
 
         with self.assertRaises(io.UnsupportedOperation):
             writer.readlines(42)
 
         with self.assertRaises(io.UnsupportedOperation):
             writer.readlines(hint=42)
 
         with self.assertRaises(io.UnsupportedOperation):
             writer.seek(0)
 
         with self.assertRaises(io.UnsupportedOperation):
             writer.seek(10, os.SEEK_SET)
 
         self.assertFalse(writer.seekable())
 
         with self.assertRaises(io.UnsupportedOperation):
             writer.tell()
 
         with self.assertRaises(io.UnsupportedOperation):
             writer.truncate()
 
         with self.assertRaises(io.UnsupportedOperation):
             writer.truncate(42)
 
         with self.assertRaises(io.UnsupportedOperation):
             writer.truncate(size=42)
 
         self.assertTrue(writer.writable())
 
         with self.assertRaises(io.UnsupportedOperation):
             writer.writelines([])
 
         with self.assertRaises(io.UnsupportedOperation):
             writer.read()
 
         with self.assertRaises(io.UnsupportedOperation):
             writer.read(42)
 
         with self.assertRaises(io.UnsupportedOperation):
             writer.read(size=42)
 
         with self.assertRaises(io.UnsupportedOperation):
             writer.readall()
 
         with self.assertRaises(io.UnsupportedOperation):
             writer.readinto(None)
 
         with self.assertRaises(io.UnsupportedOperation):
             writer.fileno()
 
     def test_fileno_file(self):
-        with tempfile.TemporaryFile('wb') as tf:
+        with tempfile.TemporaryFile("wb") as tf:
             dctx = zstd.ZstdDecompressor()
             writer = dctx.stream_writer(tf)
 
             self.assertEqual(writer.fileno(), tf.fileno())
 
     def test_close(self):
-        foo = zstd.ZstdCompressor().compress(b'foo')
+        foo = zstd.ZstdCompressor().compress(b"foo")
 
         buffer = NonClosingBytesIO()
         dctx = zstd.ZstdDecompressor()
         writer = dctx.stream_writer(buffer)
 
         writer.write(foo)
         self.assertFalse(writer.closed)
         self.assertFalse(buffer.closed)
         writer.close()
         self.assertTrue(writer.closed)
         self.assertTrue(buffer.closed)
 
-        with self.assertRaisesRegexp(ValueError, 'stream is closed'):
-            writer.write(b'')
+        with self.assertRaisesRegex(ValueError, "stream is closed"):
+            writer.write(b"")
 
-        with self.assertRaisesRegexp(ValueError, 'stream is closed'):
+        with self.assertRaisesRegex(ValueError, "stream is closed"):
             writer.flush()
 
-        with self.assertRaisesRegexp(ValueError, 'stream is closed'):
+        with self.assertRaisesRegex(ValueError, "stream is closed"):
             with writer:
                 pass
 
-        self.assertEqual(buffer.getvalue(), b'foo')
+        self.assertEqual(buffer.getvalue(), b"foo")
 
         # Context manager exit should close stream.
         buffer = NonClosingBytesIO()
         writer = dctx.stream_writer(buffer)
 
         with writer:
             writer.write(foo)
 
         self.assertTrue(writer.closed)
-        self.assertEqual(buffer.getvalue(), b'foo')
+        self.assertEqual(buffer.getvalue(), b"foo")
 
     def test_flush(self):
         buffer = OpCountingBytesIO()
         dctx = zstd.ZstdDecompressor()
         writer = dctx.stream_writer(buffer)
 
         writer.flush()
         self.assertEqual(buffer._flush_count, 1)
         writer.flush()
         self.assertEqual(buffer._flush_count, 2)
 
     def test_empty_roundtrip(self):
         cctx = zstd.ZstdCompressor()
-        empty = cctx.compress(b'')
-        self.assertEqual(decompress_via_writer(empty), b'')
+        empty = cctx.compress(b"")
+        self.assertEqual(decompress_via_writer(empty), b"")
 
     def test_input_types(self):
         cctx = zstd.ZstdCompressor(level=1)
-        compressed = cctx.compress(b'foo')
+        compressed = cctx.compress(b"foo")
 
         mutable_array = bytearray(len(compressed))
         mutable_array[:] = compressed
 
         sources = [
             memoryview(compressed),
             bytearray(compressed),
             mutable_array,
         ]
 
         dctx = zstd.ZstdDecompressor()
         for source in sources:
             buffer = io.BytesIO()
 
             decompressor = dctx.stream_writer(buffer)
             decompressor.write(source)
-            self.assertEqual(buffer.getvalue(), b'foo')
+            self.assertEqual(buffer.getvalue(), b"foo")
 
             buffer = NonClosingBytesIO()
 
             with dctx.stream_writer(buffer) as decompressor:
                 self.assertEqual(decompressor.write(source), 3)
 
-            self.assertEqual(buffer.getvalue(), b'foo')
+            self.assertEqual(buffer.getvalue(), b"foo")
 
             buffer = io.BytesIO()
             writer = dctx.stream_writer(buffer, write_return_read=True)
             self.assertEqual(writer.write(source), len(source))
-            self.assertEqual(buffer.getvalue(), b'foo')
+            self.assertEqual(buffer.getvalue(), b"foo")
 
     def test_large_roundtrip(self):
         chunks = []
         for i in range(255):
-            chunks.append(struct.Struct('>B').pack(i) * 16384)
-        orig = b''.join(chunks)
+            chunks.append(struct.Struct(">B").pack(i) * 16384)
+        orig = b"".join(chunks)
         cctx = zstd.ZstdCompressor()
         compressed = cctx.compress(orig)
 
         self.assertEqual(decompress_via_writer(compressed), orig)
 
     def test_multiple_calls(self):
         chunks = []
         for i in range(255):
             for j in range(255):
-                chunks.append(struct.Struct('>B').pack(j) * i)
+                chunks.append(struct.Struct(">B").pack(j) * i)
 
-        orig = b''.join(chunks)
+        orig = b"".join(chunks)
         cctx = zstd.ZstdCompressor()
         compressed = cctx.compress(orig)
 
         buffer = NonClosingBytesIO()
         dctx = zstd.ZstdDecompressor()
         with dctx.stream_writer(buffer) as decompressor:
             pos = 0
             while pos < len(compressed):
                 pos2 = pos + 8192
                 decompressor.write(compressed[pos:pos2])
                 pos += 8192
         self.assertEqual(buffer.getvalue(), orig)
 
         # Again with write_return_read=True
         buffer = io.BytesIO()
         writer = dctx.stream_writer(buffer, write_return_read=True)
         pos = 0
         while pos < len(compressed):
             pos2 = pos + 8192
             chunk = compressed[pos:pos2]
             self.assertEqual(writer.write(chunk), len(chunk))
             pos += 8192
         self.assertEqual(buffer.getvalue(), orig)
 
     def test_dictionary(self):
         samples = []
         for i in range(128):
-            samples.append(b'foo' * 64)
-            samples.append(b'bar' * 64)
-            samples.append(b'foobar' * 64)
+            samples.append(b"foo" * 64)
+            samples.append(b"bar" * 64)
+            samples.append(b"foobar" * 64)
 
         d = zstd.train_dictionary(8192, samples)
 
-        orig = b'foobar' * 16384
+        orig = b"foobar" * 16384
         buffer = NonClosingBytesIO()
         cctx = zstd.ZstdCompressor(dict_data=d)
         with cctx.stream_writer(buffer) as compressor:
             self.assertEqual(compressor.write(orig), 0)
 
         compressed = buffer.getvalue()
         buffer = io.BytesIO()
 
         dctx = zstd.ZstdDecompressor(dict_data=d)
         decompressor = dctx.stream_writer(buffer)
         self.assertEqual(decompressor.write(compressed), len(orig))
         self.assertEqual(buffer.getvalue(), orig)
 
         buffer = NonClosingBytesIO()
 
         with dctx.stream_writer(buffer) as decompressor:
             self.assertEqual(decompressor.write(compressed), len(orig))
 
         self.assertEqual(buffer.getvalue(), orig)
 
     def test_memory_size(self):
         dctx = zstd.ZstdDecompressor()
         buffer = io.BytesIO()
 
         decompressor = dctx.stream_writer(buffer)
         size = decompressor.memory_size()
         self.assertGreater(size, 100000)
 
         with dctx.stream_writer(buffer) as decompressor:
             size = decompressor.memory_size()
 
         self.assertGreater(size, 100000)
 
     def test_write_size(self):
-        source = zstd.ZstdCompressor().compress(b'foobarfoobar')
+        source = zstd.ZstdCompressor().compress(b"foobarfoobar")
         dest = OpCountingBytesIO()
         dctx = zstd.ZstdDecompressor()
         with dctx.stream_writer(dest, write_size=1) as decompressor:
-            s = struct.Struct('>B')
+            s = struct.Struct(">B")
             for c in source:
                 if not isinstance(c, str):
                     c = s.pack(c)
                 decompressor.write(c)
 
-        self.assertEqual(dest.getvalue(), b'foobarfoobar')
+        self.assertEqual(dest.getvalue(), b"foobarfoobar")
         self.assertEqual(dest._write_count, len(dest.getvalue()))
 
 
 @make_cffi
-class TestDecompressor_read_to_iter(unittest.TestCase):
+class TestDecompressor_read_to_iter(TestCase):
     def test_type_validation(self):
         dctx = zstd.ZstdDecompressor()
 
         # Object with read() works.
         dctx.read_to_iter(io.BytesIO())
 
         # Buffer protocol works.
-        dctx.read_to_iter(b'foobar')
+        dctx.read_to_iter(b"foobar")
 
-        with self.assertRaisesRegexp(ValueError, 'must pass an object with a read'):
-            b''.join(dctx.read_to_iter(True))
+        with self.assertRaisesRegex(ValueError, "must pass an object with a read"):
+            b"".join(dctx.read_to_iter(True))
 
     def test_empty_input(self):
         dctx = zstd.ZstdDecompressor()
 
         source = io.BytesIO()
         it = dctx.read_to_iter(source)
         # TODO this is arguably wrong. Should get an error about missing frame foo.
         with self.assertRaises(StopIteration):
             next(it)
 
-        it = dctx.read_to_iter(b'')
+        it = dctx.read_to_iter(b"")
         with self.assertRaises(StopIteration):
             next(it)
 
     def test_invalid_input(self):
         dctx = zstd.ZstdDecompressor()
 
-        source = io.BytesIO(b'foobar')
+        source = io.BytesIO(b"foobar")
         it = dctx.read_to_iter(source)
-        with self.assertRaisesRegexp(zstd.ZstdError, 'Unknown frame descriptor'):
+        with self.assertRaisesRegex(zstd.ZstdError, "Unknown frame descriptor"):
             next(it)
 
-        it = dctx.read_to_iter(b'foobar')
-        with self.assertRaisesRegexp(zstd.ZstdError, 'Unknown frame descriptor'):
+        it = dctx.read_to_iter(b"foobar")
+        with self.assertRaisesRegex(zstd.ZstdError, "Unknown frame descriptor"):
             next(it)
 
     def test_empty_roundtrip(self):
         cctx = zstd.ZstdCompressor(level=1, write_content_size=False)
-        empty = cctx.compress(b'')
+        empty = cctx.compress(b"")
 
         source = io.BytesIO(empty)
         source.seek(0)
 
         dctx = zstd.ZstdDecompressor()
         it = dctx.read_to_iter(source)
 
         # No chunks should be emitted since there is no data.
         with self.assertRaises(StopIteration):
             next(it)
 
         # Again for good measure.
         with self.assertRaises(StopIteration):
             next(it)
 
     def test_skip_bytes_too_large(self):
         dctx = zstd.ZstdDecompressor()
 
-        with self.assertRaisesRegexp(ValueError, 'skip_bytes must be smaller than read_size'):
-            b''.join(dctx.read_to_iter(b'', skip_bytes=1, read_size=1))
+        with self.assertRaisesRegex(
+            ValueError, "skip_bytes must be smaller than read_size"
+        ):
+            b"".join(dctx.read_to_iter(b"", skip_bytes=1, read_size=1))
 
-        with self.assertRaisesRegexp(ValueError, 'skip_bytes larger than first input chunk'):
-            b''.join(dctx.read_to_iter(b'foobar', skip_bytes=10))
+        with self.assertRaisesRegex(
+            ValueError, "skip_bytes larger than first input chunk"
+        ):
+            b"".join(dctx.read_to_iter(b"foobar", skip_bytes=10))
 
     def test_skip_bytes(self):
         cctx = zstd.ZstdCompressor(write_content_size=False)
-        compressed = cctx.compress(b'foobar')
+        compressed = cctx.compress(b"foobar")
 
         dctx = zstd.ZstdDecompressor()
-        output = b''.join(dctx.read_to_iter(b'hdr' + compressed, skip_bytes=3))
-        self.assertEqual(output, b'foobar')
+        output = b"".join(dctx.read_to_iter(b"hdr" + compressed, skip_bytes=3))
+        self.assertEqual(output, b"foobar")
 
     def test_large_output(self):
         source = io.BytesIO()
-        source.write(b'f' * zstd.DECOMPRESSION_RECOMMENDED_OUTPUT_SIZE)
-        source.write(b'o')
+        source.write(b"f" * zstd.DECOMPRESSION_RECOMMENDED_OUTPUT_SIZE)
+        source.write(b"o")
         source.seek(0)
 
         cctx = zstd.ZstdCompressor(level=1)
         compressed = io.BytesIO(cctx.compress(source.getvalue()))
         compressed.seek(0)
 
         dctx = zstd.ZstdDecompressor()
         it = dctx.read_to_iter(compressed)
 
         chunks = []
         chunks.append(next(it))
         chunks.append(next(it))
 
         with self.assertRaises(StopIteration):
             next(it)
 
-        decompressed = b''.join(chunks)
+        decompressed = b"".join(chunks)
         self.assertEqual(decompressed, source.getvalue())
 
         # And again with buffer protocol.
         it = dctx.read_to_iter(compressed.getvalue())
         chunks = []
         chunks.append(next(it))
         chunks.append(next(it))
 
         with self.assertRaises(StopIteration):
             next(it)
 
-        decompressed = b''.join(chunks)
+        decompressed = b"".join(chunks)
         self.assertEqual(decompressed, source.getvalue())
 
-    @unittest.skipUnless('ZSTD_SLOW_TESTS' in os.environ, 'ZSTD_SLOW_TESTS not set')
+    @unittest.skipUnless("ZSTD_SLOW_TESTS" in os.environ, "ZSTD_SLOW_TESTS not set")
     def test_large_input(self):
-        bytes = list(struct.Struct('>B').pack(i) for i in range(256))
+        bytes = list(struct.Struct(">B").pack(i) for i in range(256))
         compressed = NonClosingBytesIO()
         input_size = 0
         cctx = zstd.ZstdCompressor(level=1)
         with cctx.stream_writer(compressed) as compressor:
             while True:
                 compressor.write(random.choice(bytes))
                 input_size += 1
 
-                have_compressed = len(compressed.getvalue()) > zstd.DECOMPRESSION_RECOMMENDED_INPUT_SIZE
+                have_compressed = (
+                    len(compressed.getvalue())
+                    > zstd.DECOMPRESSION_RECOMMENDED_INPUT_SIZE
+                )
                 have_raw = input_size > zstd.DECOMPRESSION_RECOMMENDED_OUTPUT_SIZE * 2
                 if have_compressed and have_raw:
                     break
 
         compressed = io.BytesIO(compressed.getvalue())
-        self.assertGreater(len(compressed.getvalue()),
-                           zstd.DECOMPRESSION_RECOMMENDED_INPUT_SIZE)
+        self.assertGreater(
+            len(compressed.getvalue()), zstd.DECOMPRESSION_RECOMMENDED_INPUT_SIZE
+        )
 
         dctx = zstd.ZstdDecompressor()
         it = dctx.read_to_iter(compressed)
 
         chunks = []
         chunks.append(next(it))
         chunks.append(next(it))
         chunks.append(next(it))
 
         with self.assertRaises(StopIteration):
             next(it)
 
-        decompressed = b''.join(chunks)
+        decompressed = b"".join(chunks)
         self.assertEqual(len(decompressed), input_size)
 
         # And again with buffer protocol.
         it = dctx.read_to_iter(compressed.getvalue())
 
         chunks = []
         chunks.append(next(it))
         chunks.append(next(it))
         chunks.append(next(it))
 
         with self.assertRaises(StopIteration):
             next(it)
 
-        decompressed = b''.join(chunks)
+        decompressed = b"".join(chunks)
         self.assertEqual(len(decompressed), input_size)
 
     def test_interesting(self):
         # Found this edge case via fuzzing.
         cctx = zstd.ZstdCompressor(level=1)
 
         source = io.BytesIO()
 
         compressed = NonClosingBytesIO()
         with cctx.stream_writer(compressed) as compressor:
             for i in range(256):
-                chunk = b'\0' * 1024
+                chunk = b"\0" * 1024
                 compressor.write(chunk)
                 source.write(chunk)
 
         dctx = zstd.ZstdDecompressor()
 
-        simple = dctx.decompress(compressed.getvalue(),
-                                 max_output_size=len(source.getvalue()))
+        simple = dctx.decompress(
+            compressed.getvalue(), max_output_size=len(source.getvalue())
+        )
         self.assertEqual(simple, source.getvalue())
 
         compressed = io.BytesIO(compressed.getvalue())
-        streamed = b''.join(dctx.read_to_iter(compressed))
+        streamed = b"".join(dctx.read_to_iter(compressed))
         self.assertEqual(streamed, source.getvalue())
 
     def test_read_write_size(self):
-        source = OpCountingBytesIO(zstd.ZstdCompressor().compress(b'foobarfoobar'))
+        source = OpCountingBytesIO(zstd.ZstdCompressor().compress(b"foobarfoobar"))
         dctx = zstd.ZstdDecompressor()
         for chunk in dctx.read_to_iter(source, read_size=1, write_size=1):
             self.assertEqual(len(chunk), 1)
 
         self.assertEqual(source._read_count, len(source.getvalue()))
 
     def test_magic_less(self):
         params = zstd.CompressionParameters.from_level(
-            1, format=zstd.FORMAT_ZSTD1_MAGICLESS)
+            1, format=zstd.FORMAT_ZSTD1_MAGICLESS
+        )
         cctx = zstd.ZstdCompressor(compression_params=params)
-        frame = cctx.compress(b'foobar')
+        frame = cctx.compress(b"foobar")
 
-        self.assertNotEqual(frame[0:4], b'\x28\xb5\x2f\xfd')
+        self.assertNotEqual(frame[0:4], b"\x28\xb5\x2f\xfd")
 
         dctx = zstd.ZstdDecompressor()
-        with self.assertRaisesRegexp(
-            zstd.ZstdError, 'error determining content size from frame header'):
+        with self.assertRaisesRegex(
+            zstd.ZstdError, "error determining content size from frame header"
+        ):
             dctx.decompress(frame)
 
         dctx = zstd.ZstdDecompressor(format=zstd.FORMAT_ZSTD1_MAGICLESS)
-        res = b''.join(dctx.read_to_iter(frame))
-        self.assertEqual(res, b'foobar')
+        res = b"".join(dctx.read_to_iter(frame))
+        self.assertEqual(res, b"foobar")
 
 
 @make_cffi
-class TestDecompressor_content_dict_chain(unittest.TestCase):
+class TestDecompressor_content_dict_chain(TestCase):
     def test_bad_inputs_simple(self):
         dctx = zstd.ZstdDecompressor()
 
         with self.assertRaises(TypeError):
-            dctx.decompress_content_dict_chain(b'foo')
+            dctx.decompress_content_dict_chain(b"foo")
 
         with self.assertRaises(TypeError):
-            dctx.decompress_content_dict_chain((b'foo', b'bar'))
+            dctx.decompress_content_dict_chain((b"foo", b"bar"))
 
-        with self.assertRaisesRegexp(ValueError, 'empty input chain'):
+        with self.assertRaisesRegex(ValueError, "empty input chain"):
             dctx.decompress_content_dict_chain([])
 
-        with self.assertRaisesRegexp(ValueError, 'chunk 0 must be bytes'):
-            dctx.decompress_content_dict_chain([u'foo'])
+        with self.assertRaisesRegex(ValueError, "chunk 0 must be bytes"):
+            dctx.decompress_content_dict_chain([u"foo"])
 
-        with self.assertRaisesRegexp(ValueError, 'chunk 0 must be bytes'):
+        with self.assertRaisesRegex(ValueError, "chunk 0 must be bytes"):
             dctx.decompress_content_dict_chain([True])
 
-        with self.assertRaisesRegexp(ValueError, 'chunk 0 is too small to contain a zstd frame'):
+        with self.assertRaisesRegex(
+            ValueError, "chunk 0 is too small to contain a zstd frame"
+        ):
             dctx.decompress_content_dict_chain([zstd.FRAME_HEADER])
 
-        with self.assertRaisesRegexp(ValueError, 'chunk 0 is not a valid zstd frame'):
-            dctx.decompress_content_dict_chain([b'foo' * 8])
+        with self.assertRaisesRegex(ValueError, "chunk 0 is not a valid zstd frame"):
+            dctx.decompress_content_dict_chain([b"foo" * 8])
 
-        no_size = zstd.ZstdCompressor(write_content_size=False).compress(b'foo' * 64)
+        no_size = zstd.ZstdCompressor(write_content_size=False).compress(b"foo" * 64)
 
-        with self.assertRaisesRegexp(ValueError, 'chunk 0 missing content size in frame'):
+        with self.assertRaisesRegex(
+            ValueError, "chunk 0 missing content size in frame"
+        ):
             dctx.decompress_content_dict_chain([no_size])
 
         # Corrupt first frame.
-        frame = zstd.ZstdCompressor().compress(b'foo' * 64)
+        frame = zstd.ZstdCompressor().compress(b"foo" * 64)
         frame = frame[0:12] + frame[15:]
-        with self.assertRaisesRegexp(zstd.ZstdError,
-                                     'chunk 0 did not decompress full frame'):
+        with self.assertRaisesRegex(
+            zstd.ZstdError, "chunk 0 did not decompress full frame"
+        ):
             dctx.decompress_content_dict_chain([frame])
 
     def test_bad_subsequent_input(self):
-        initial = zstd.ZstdCompressor().compress(b'foo' * 64)
+        initial = zstd.ZstdCompressor().compress(b"foo" * 64)
 
         dctx = zstd.ZstdDecompressor()
 
-        with self.assertRaisesRegexp(ValueError, 'chunk 1 must be bytes'):
-            dctx.decompress_content_dict_chain([initial, u'foo'])
+        with self.assertRaisesRegex(ValueError, "chunk 1 must be bytes"):
+            dctx.decompress_content_dict_chain([initial, u"foo"])
 
-        with self.assertRaisesRegexp(ValueError, 'chunk 1 must be bytes'):
+        with self.assertRaisesRegex(ValueError, "chunk 1 must be bytes"):
             dctx.decompress_content_dict_chain([initial, None])
 
-        with self.assertRaisesRegexp(ValueError, 'chunk 1 is too small to contain a zstd frame'):
+        with self.assertRaisesRegex(
+            ValueError, "chunk 1 is too small to contain a zstd frame"
+        ):
             dctx.decompress_content_dict_chain([initial, zstd.FRAME_HEADER])
 
-        with self.assertRaisesRegexp(ValueError, 'chunk 1 is not a valid zstd frame'):
-            dctx.decompress_content_dict_chain([initial, b'foo' * 8])
+        with self.assertRaisesRegex(ValueError, "chunk 1 is not a valid zstd frame"):
+            dctx.decompress_content_dict_chain([initial, b"foo" * 8])
 
-        no_size = zstd.ZstdCompressor(write_content_size=False).compress(b'foo' * 64)
+        no_size = zstd.ZstdCompressor(write_content_size=False).compress(b"foo" * 64)
 
-        with self.assertRaisesRegexp(ValueError, 'chunk 1 missing content size in frame'):
+        with self.assertRaisesRegex(
+            ValueError, "chunk 1 missing content size in frame"
+        ):
             dctx.decompress_content_dict_chain([initial, no_size])
 
         # Corrupt second frame.
-        cctx = zstd.ZstdCompressor(dict_data=zstd.ZstdCompressionDict(b'foo' * 64))
-        frame = cctx.compress(b'bar' * 64)
+        cctx = zstd.ZstdCompressor(dict_data=zstd.ZstdCompressionDict(b"foo" * 64))
+        frame = cctx.compress(b"bar" * 64)
         frame = frame[0:12] + frame[15:]
 
-        with self.assertRaisesRegexp(zstd.ZstdError, 'chunk 1 did not decompress full frame'):
+        with self.assertRaisesRegex(
+            zstd.ZstdError, "chunk 1 did not decompress full frame"
+        ):
             dctx.decompress_content_dict_chain([initial, frame])
 
     def test_simple(self):
         original = [
-            b'foo' * 64,
-            b'foobar' * 64,
-            b'baz' * 64,
-            b'foobaz' * 64,
-            b'foobarbaz' * 64,
+            b"foo" * 64,
+            b"foobar" * 64,
+            b"baz" * 64,
+            b"foobaz" * 64,
+            b"foobarbaz" * 64,
         ]
 
         chunks = []
         chunks.append(zstd.ZstdCompressor().compress(original[0]))
         for i, chunk in enumerate(original[1:]):
             d = zstd.ZstdCompressionDict(original[i])
             cctx = zstd.ZstdCompressor(dict_data=d)
             chunks.append(cctx.compress(chunk))
 
         for i in range(1, len(original)):
             chain = chunks[0:i]
             expected = original[i - 1]
             dctx = zstd.ZstdDecompressor()
             decompressed = dctx.decompress_content_dict_chain(chain)
             self.assertEqual(decompressed, expected)
 
 
 # TODO enable for CFFI
-class TestDecompressor_multi_decompress_to_buffer(unittest.TestCase):
+class TestDecompressor_multi_decompress_to_buffer(TestCase):
     def test_invalid_inputs(self):
         dctx = zstd.ZstdDecompressor()
 
-        if not hasattr(dctx, 'multi_decompress_to_buffer'):
-            self.skipTest('multi_decompress_to_buffer not available')
+        if not hasattr(dctx, "multi_decompress_to_buffer"):
+            self.skipTest("multi_decompress_to_buffer not available")
 
         with self.assertRaises(TypeError):
             dctx.multi_decompress_to_buffer(True)
 
         with self.assertRaises(TypeError):
             dctx.multi_decompress_to_buffer((1, 2))
 
-        with self.assertRaisesRegexp(TypeError, 'item 0 not a bytes like object'):
-            dctx.multi_decompress_to_buffer([u'foo'])
+        with self.assertRaisesRegex(TypeError, "item 0 not a bytes like object"):
+            dctx.multi_decompress_to_buffer([u"foo"])
 
-        with self.assertRaisesRegexp(ValueError, 'could not determine decompressed size of item 0'):
-            dctx.multi_decompress_to_buffer([b'foobarbaz'])
+        with self.assertRaisesRegex(
+            ValueError, "could not determine decompressed size of item 0"
+        ):
+            dctx.multi_decompress_to_buffer([b"foobarbaz"])
 
     def test_list_input(self):
         cctx = zstd.ZstdCompressor()
 
-        original = [b'foo' * 4, b'bar' * 6]
+        original = [b"foo" * 4, b"bar" * 6]
         frames = [cctx.compress(d) for d in original]
 
         dctx = zstd.ZstdDecompressor()
 
-        if not hasattr(dctx, 'multi_decompress_to_buffer'):
-            self.skipTest('multi_decompress_to_buffer not available')
+        if not hasattr(dctx, "multi_decompress_to_buffer"):
+            self.skipTest("multi_decompress_to_buffer not available")
 
         result = dctx.multi_decompress_to_buffer(frames)
 
         self.assertEqual(len(result), len(frames))
         self.assertEqual(result.size(), sum(map(len, original)))
 
         for i, data in enumerate(original):
             self.assertEqual(result[i].tobytes(), data)
 
         self.assertEqual(result[0].offset, 0)
         self.assertEqual(len(result[0]), 12)
         self.assertEqual(result[1].offset, 12)
         self.assertEqual(len(result[1]), 18)
 
     def test_list_input_frame_sizes(self):
         cctx = zstd.ZstdCompressor()
 
-        original = [b'foo' * 4, b'bar' * 6, b'baz' * 8]
+        original = [b"foo" * 4, b"bar" * 6, b"baz" * 8]
         frames = [cctx.compress(d) for d in original]
-        sizes = struct.pack('=' + 'Q' * len(original), *map(len, original))
+        sizes = struct.pack("=" + "Q" * len(original), *map(len, original))
 
         dctx = zstd.ZstdDecompressor()
 
-        if not hasattr(dctx, 'multi_decompress_to_buffer'):
-            self.skipTest('multi_decompress_to_buffer not available')
+        if not hasattr(dctx, "multi_decompress_to_buffer"):
+            self.skipTest("multi_decompress_to_buffer not available")
 
         result = dctx.multi_decompress_to_buffer(frames, decompressed_sizes=sizes)
 
         self.assertEqual(len(result), len(frames))
         self.assertEqual(result.size(), sum(map(len, original)))
 
         for i, data in enumerate(original):
             self.assertEqual(result[i].tobytes(), data)
 
     def test_buffer_with_segments_input(self):
         cctx = zstd.ZstdCompressor()
 
-        original = [b'foo' * 4, b'bar' * 6]
+        original = [b"foo" * 4, b"bar" * 6]
         frames = [cctx.compress(d) for d in original]
 
         dctx = zstd.ZstdDecompressor()
 
-        if not hasattr(dctx, 'multi_decompress_to_buffer'):
-            self.skipTest('multi_decompress_to_buffer not available')
+        if not hasattr(dctx, "multi_decompress_to_buffer"):
+            self.skipTest("multi_decompress_to_buffer not available")
 
-        segments = struct.pack('=QQQQ', 0, len(frames[0]), len(frames[0]), len(frames[1]))
-        b = zstd.BufferWithSegments(b''.join(frames), segments)
+        segments = struct.pack(
+            "=QQQQ", 0, len(frames[0]), len(frames[0]), len(frames[1])
+        )
+        b = zstd.BufferWithSegments(b"".join(frames), segments)
 
         result = dctx.multi_decompress_to_buffer(b)
 
         self.assertEqual(len(result), len(frames))
         self.assertEqual(result[0].offset, 0)
         self.assertEqual(len(result[0]), 12)
         self.assertEqual(result[1].offset, 12)
         self.assertEqual(len(result[1]), 18)
 
     def test_buffer_with_segments_sizes(self):
         cctx = zstd.ZstdCompressor(write_content_size=False)
-        original = [b'foo' * 4, b'bar' * 6, b'baz' * 8]
+        original = [b"foo" * 4, b"bar" * 6, b"baz" * 8]
         frames = [cctx.compress(d) for d in original]
-        sizes = struct.pack('=' + 'Q' * len(original), *map(len, original))
+        sizes = struct.pack("=" + "Q" * len(original), *map(len, original))
 
         dctx = zstd.ZstdDecompressor()
 
-        if not hasattr(dctx, 'multi_decompress_to_buffer'):
-            self.skipTest('multi_decompress_to_buffer not available')
+        if not hasattr(dctx, "multi_decompress_to_buffer"):
+            self.skipTest("multi_decompress_to_buffer not available")
 
-        segments = struct.pack('=QQQQQQ', 0, len(frames[0]),
-                               len(frames[0]), len(frames[1]),
-                               len(frames[0]) + len(frames[1]), len(frames[2]))
-        b = zstd.BufferWithSegments(b''.join(frames), segments)
+        segments = struct.pack(
+            "=QQQQQQ",
+            0,
+            len(frames[0]),
+            len(frames[0]),
+            len(frames[1]),
+            len(frames[0]) + len(frames[1]),
+            len(frames[2]),
+        )
+        b = zstd.BufferWithSegments(b"".join(frames), segments)
 
         result = dctx.multi_decompress_to_buffer(b, decompressed_sizes=sizes)
 
         self.assertEqual(len(result), len(frames))
         self.assertEqual(result.size(), sum(map(len, original)))
 
         for i, data in enumerate(original):
             self.assertEqual(result[i].tobytes(), data)
 
     def test_buffer_with_segments_collection_input(self):
         cctx = zstd.ZstdCompressor()
 
         original = [
-            b'foo0' * 2,
-            b'foo1' * 3,
-            b'foo2' * 4,
-            b'foo3' * 5,
-            b'foo4' * 6,
+            b"foo0" * 2,
+            b"foo1" * 3,
+            b"foo2" * 4,
+            b"foo3" * 5,
+            b"foo4" * 6,
         ]
 
-        if not hasattr(cctx, 'multi_compress_to_buffer'):
-            self.skipTest('multi_compress_to_buffer not available')
+        if not hasattr(cctx, "multi_compress_to_buffer"):
+            self.skipTest("multi_compress_to_buffer not available")
 
         frames = cctx.multi_compress_to_buffer(original)
 
         # Check round trip.
         dctx = zstd.ZstdDecompressor()
 
         decompressed = dctx.multi_decompress_to_buffer(frames, threads=3)
 
         self.assertEqual(len(decompressed), len(original))
 
         for i, data in enumerate(original):
             self.assertEqual(data, decompressed[i].tobytes())
 
         # And a manual mode.
-        b = b''.join([frames[0].tobytes(), frames[1].tobytes()])
-        b1 = zstd.BufferWithSegments(b, struct.pack('=QQQQ',
-                                                    0, len(frames[0]),
-                                                    len(frames[0]), len(frames[1])))
+        b = b"".join([frames[0].tobytes(), frames[1].tobytes()])
+        b1 = zstd.BufferWithSegments(
+            b, struct.pack("=QQQQ", 0, len(frames[0]), len(frames[0]), len(frames[1]))
+        )
 
-        b = b''.join([frames[2].tobytes(), frames[3].tobytes(), frames[4].tobytes()])
-        b2 = zstd.BufferWithSegments(b, struct.pack('=QQQQQQ',
-                                                    0, len(frames[2]),
-                                                    len(frames[2]), len(frames[3]),
-                                                    len(frames[2]) + len(frames[3]), len(frames[4])))
+        b = b"".join([frames[2].tobytes(), frames[3].tobytes(), frames[4].tobytes()])
+        b2 = zstd.BufferWithSegments(
+            b,
+            struct.pack(
+                "=QQQQQQ",
+                0,
+                len(frames[2]),
+                len(frames[2]),
+                len(frames[3]),
+                len(frames[2]) + len(frames[3]),
+                len(frames[4]),
+            ),
+        )
 
         c = zstd.BufferWithSegmentsCollection(b1, b2)
 
         dctx = zstd.ZstdDecompressor()
         decompressed = dctx.multi_decompress_to_buffer(c)
 
         self.assertEqual(len(decompressed), 5)
         for i in range(5):
             self.assertEqual(decompressed[i].tobytes(), original[i])
 
     def test_dict(self):
         d = zstd.train_dictionary(16384, generate_samples(), k=64, d=16)
 
         cctx = zstd.ZstdCompressor(dict_data=d, level=1)
         frames = [cctx.compress(s) for s in generate_samples()]
 
         dctx = zstd.ZstdDecompressor(dict_data=d)
 
-        if not hasattr(dctx, 'multi_decompress_to_buffer'):
-            self.skipTest('multi_decompress_to_buffer not available')
+        if not hasattr(dctx, "multi_decompress_to_buffer"):
+            self.skipTest("multi_decompress_to_buffer not available")
 
         result = dctx.multi_decompress_to_buffer(frames)
 
         self.assertEqual([o.tobytes() for o in result], generate_samples())
 
     def test_multiple_threads(self):
         cctx = zstd.ZstdCompressor()
 
         frames = []
-        frames.extend(cctx.compress(b'x' * 64) for i in range(256))
-        frames.extend(cctx.compress(b'y' * 64) for i in range(256))
+        frames.extend(cctx.compress(b"x" * 64) for i in range(256))
+        frames.extend(cctx.compress(b"y" * 64) for i in range(256))
 
         dctx = zstd.ZstdDecompressor()
 
-        if not hasattr(dctx, 'multi_decompress_to_buffer'):
-            self.skipTest('multi_decompress_to_buffer not available')
+        if not hasattr(dctx, "multi_decompress_to_buffer"):
+            self.skipTest("multi_decompress_to_buffer not available")
 
         result = dctx.multi_decompress_to_buffer(frames, threads=-1)
 
         self.assertEqual(len(result), len(frames))
         self.assertEqual(result.size(), 2 * 64 * 256)
-        self.assertEqual(result[0].tobytes(), b'x' * 64)
-        self.assertEqual(result[256].tobytes(), b'y' * 64)
+        self.assertEqual(result[0].tobytes(), b"x" * 64)
+        self.assertEqual(result[256].tobytes(), b"y" * 64)
 
     def test_item_failure(self):
         cctx = zstd.ZstdCompressor()
-        frames = [cctx.compress(b'x' * 128), cctx.compress(b'y' * 128)]
+        frames = [cctx.compress(b"x" * 128), cctx.compress(b"y" * 128)]
 
-        frames[1] = frames[1][0:15] + b'extra' + frames[1][15:]
+        frames[1] = frames[1][0:15] + b"extra" + frames[1][15:]
 
         dctx = zstd.ZstdDecompressor()
 
-        if not hasattr(dctx, 'multi_decompress_to_buffer'):
-            self.skipTest('multi_decompress_to_buffer not available')
+        if not hasattr(dctx, "multi_decompress_to_buffer"):
+            self.skipTest("multi_decompress_to_buffer not available")
 
-        with self.assertRaisesRegexp(zstd.ZstdError,
-                                     'error decompressing item 1: ('
-                                     'Corrupted block|'
-                                     'Destination buffer is too small)'):
+        with self.assertRaisesRegex(
+            zstd.ZstdError,
+            "error decompressing item 1: ("
+            "Corrupted block|"
+            "Destination buffer is too small)",
+        ):
             dctx.multi_decompress_to_buffer(frames)
 
-        with self.assertRaisesRegexp(zstd.ZstdError,
-                            'error decompressing item 1: ('
-                            'Corrupted block|'
-                            'Destination buffer is too small)'):
+        with self.assertRaisesRegex(
+            zstd.ZstdError,
+            "error decompressing item 1: ("
+            "Corrupted block|"
+            "Destination buffer is too small)",
+        ):
             dctx.multi_decompress_to_buffer(frames, threads=2)
-

contrib/python-zstandard/tests/test_decompressor_fuzzing.py

@@ -1,485 +1,576 b''
 import io
 import os
 import unittest
 
 try:
     import hypothesis
     import hypothesis.strategies as strategies
 except ImportError:
-    raise unittest.SkipTest('hypothesis not available')
+    raise unittest.SkipTest("hypothesis not available")
 
 import zstandard as zstd
 
-from . common import (
+from .common import (
     make_cffi,
     NonClosingBytesIO,
     random_input_data,
+    TestCase,
 )
 
 
[e-mail]('ZSTD_SLOW_TESTS' in os.environ, 'ZSTD_SLOW_TESTS not set')
[e-mail]("ZSTD_SLOW_TESTS" in os.environ, "ZSTD_SLOW_TESTS not set")
 @make_cffi
-class TestDecompressor_stream_reader_fuzzing(unittest.TestCase):
+class TestDecompressor_stream_reader_fuzzing(TestCase):
     @hypothesis.settings(
-        suppress_health_check=[hypothesis.HealthCheck.large_base_example])
-    @hypothesis.given(original=strategies.sampled_from(random_input_data()),
-                      level=strategies.integers(min_value=1, max_value=5),
-                      streaming=strategies.booleans(),
-                      source_read_size=strategies.integers(1, 1048576),
-                      read_sizes=strategies.data())
-    def test_stream_source_read_variance(self, original, level, streaming,
-                                         source_read_size, read_sizes):
+        suppress_health_check=[
+            hypothesis.HealthCheck.large_base_example,
+            hypothesis.HealthCheck.too_slow,
+        ]
+    )
+    @hypothesis.given(
+        original=strategies.sampled_from(random_input_data()),
+        level=strategies.integers(min_value=1, max_value=5),
+        streaming=strategies.booleans(),
+        source_read_size=strategies.integers(1, 1048576),
+        read_sizes=strategies.data(),
+    )
+    def test_stream_source_read_variance(
+        self, original, level, streaming, source_read_size, read_sizes
+    ):
         cctx = zstd.ZstdCompressor(level=level)
 
         if streaming:
             source = io.BytesIO()
             writer = cctx.stream_writer(source)
             writer.write(original)
             writer.flush(zstd.FLUSH_FRAME)
             source.seek(0)
         else:
             frame = cctx.compress(original)
             source = io.BytesIO(frame)
 
         dctx = zstd.ZstdDecompressor()
 
         chunks = []
         with dctx.stream_reader(source, read_size=source_read_size) as reader:
             while True:
                 read_size = read_sizes.draw(strategies.integers(-1, 131072))
                 chunk = reader.read(read_size)
                 if not chunk and read_size:
                     break
 
                 chunks.append(chunk)
 
-        self.assertEqual(b''.join(chunks), original)
+        self.assertEqual(b"".join(chunks), original)
 
     # Similar to above except we have a constant read() size.
     @hypothesis.settings(
-        suppress_health_check=[hypothesis.HealthCheck.large_base_example])
-    @hypothesis.given(original=strategies.sampled_from(random_input_data()),
-                      level=strategies.integers(min_value=1, max_value=5),
-                      streaming=strategies.booleans(),
-                      source_read_size=strategies.integers(1, 1048576),
-                      read_size=strategies.integers(-1, 131072))
-    def test_stream_source_read_size(self, original, level, streaming,
-                                     source_read_size, read_size):
+        suppress_health_check=[hypothesis.HealthCheck.large_base_example]
+    )
+    @hypothesis.given(
+        original=strategies.sampled_from(random_input_data()),
+        level=strategies.integers(min_value=1, max_value=5),
+        streaming=strategies.booleans(),
+        source_read_size=strategies.integers(1, 1048576),
+        read_size=strategies.integers(-1, 131072),
+    )
+    def test_stream_source_read_size(
+        self, original, level, streaming, source_read_size, read_size
+    ):
         if read_size == 0:
             read_size = 1
 
         cctx = zstd.ZstdCompressor(level=level)
 
         if streaming:
             source = io.BytesIO()
             writer = cctx.stream_writer(source)
             writer.write(original)
             writer.flush(zstd.FLUSH_FRAME)
             source.seek(0)
         else:
             frame = cctx.compress(original)
             source = io.BytesIO(frame)
 
         dctx = zstd.ZstdDecompressor()
 
         chunks = []
         reader = dctx.stream_reader(source, read_size=source_read_size)
         while True:
             chunk = reader.read(read_size)
             if not chunk and read_size:
                 break
 
             chunks.append(chunk)
 
-        self.assertEqual(b''.join(chunks), original)
+        self.assertEqual(b"".join(chunks), original)
 
     @hypothesis.settings(
-        suppress_health_check=[hypothesis.HealthCheck.large_base_example])
-    @hypothesis.given(original=strategies.sampled_from(random_input_data()),
-                      level=strategies.integers(min_value=1, max_value=5),
-                      streaming=strategies.booleans(),
-                      source_read_size=strategies.integers(1, 1048576),
-                      read_sizes=strategies.data())
-    def test_buffer_source_read_variance(self, original, level, streaming,
-                                         source_read_size, read_sizes):
+        suppress_health_check=[
+            hypothesis.HealthCheck.large_base_example,
+            hypothesis.HealthCheck.too_slow,
+        ]
+    )
+    @hypothesis.given(
+        original=strategies.sampled_from(random_input_data()),
+        level=strategies.integers(min_value=1, max_value=5),
+        streaming=strategies.booleans(),
+        source_read_size=strategies.integers(1, 1048576),
+        read_sizes=strategies.data(),
+    )
+    def test_buffer_source_read_variance(
+        self, original, level, streaming, source_read_size, read_sizes
+    ):
         cctx = zstd.ZstdCompressor(level=level)
 
         if streaming:
             source = io.BytesIO()
             writer = cctx.stream_writer(source)
             writer.write(original)
             writer.flush(zstd.FLUSH_FRAME)
             frame = source.getvalue()
         else:
             frame = cctx.compress(original)
 
         dctx = zstd.ZstdDecompressor()
         chunks = []
 
         with dctx.stream_reader(frame, read_size=source_read_size) as reader:
             while True:
                 read_size = read_sizes.draw(strategies.integers(-1, 131072))
                 chunk = reader.read(read_size)
                 if not chunk and read_size:
                     break
 
                 chunks.append(chunk)
 
-        self.assertEqual(b''.join(chunks), original)
+        self.assertEqual(b"".join(chunks), original)
 
     # Similar to above except we have a constant read() size.
     @hypothesis.settings(
-        suppress_health_check=[hypothesis.HealthCheck.large_base_example])
-    @hypothesis.given(original=strategies.sampled_from(random_input_data()),
-                      level=strategies.integers(min_value=1, max_value=5),
-                      streaming=strategies.booleans(),
-                      source_read_size=strategies.integers(1, 1048576),
-                      read_size=strategies.integers(-1, 131072))
-    def test_buffer_source_constant_read_size(self, original, level, streaming,
-                                              source_read_size, read_size):
+        suppress_health_check=[hypothesis.HealthCheck.large_base_example]
+    )
+    @hypothesis.given(
+        original=strategies.sampled_from(random_input_data()),
+        level=strategies.integers(min_value=1, max_value=5),
+        streaming=strategies.booleans(),
+        source_read_size=strategies.integers(1, 1048576),
+        read_size=strategies.integers(-1, 131072),
+    )
+    def test_buffer_source_constant_read_size(
+        self, original, level, streaming, source_read_size, read_size
+    ):
         if read_size == 0:
             read_size = -1
 
         cctx = zstd.ZstdCompressor(level=level)
 
         if streaming:
             source = io.BytesIO()
             writer = cctx.stream_writer(source)
             writer.write(original)
             writer.flush(zstd.FLUSH_FRAME)
             frame = source.getvalue()
         else:
             frame = cctx.compress(original)
 
         dctx = zstd.ZstdDecompressor()
         chunks = []
 
         reader = dctx.stream_reader(frame, read_size=source_read_size)
         while True:
             chunk = reader.read(read_size)
             if not chunk and read_size:
                 break
 
             chunks.append(chunk)
 
-        self.assertEqual(b''.join(chunks), original)
+        self.assertEqual(b"".join(chunks), original)
 
     @hypothesis.settings(
-        suppress_health_check=[hypothesis.HealthCheck.large_base_example])
-    @hypothesis.given(original=strategies.sampled_from(random_input_data()),
-                      level=strategies.integers(min_value=1, max_value=5),
-                      streaming=strategies.booleans(),
-                      source_read_size=strategies.integers(1, 1048576))
-    def test_stream_source_readall(self, original, level, streaming,
-                                         source_read_size):
+        suppress_health_check=[hypothesis.HealthCheck.large_base_example]
+    )
+    @hypothesis.given(
+        original=strategies.sampled_from(random_input_data()),
+        level=strategies.integers(min_value=1, max_value=5),
+        streaming=strategies.booleans(),
+        source_read_size=strategies.integers(1, 1048576),
+    )
+    def test_stream_source_readall(self, original, level, streaming, source_read_size):
         cctx = zstd.ZstdCompressor(level=level)
 
         if streaming:
             source = io.BytesIO()
             writer = cctx.stream_writer(source)
             writer.write(original)
             writer.flush(zstd.FLUSH_FRAME)
             source.seek(0)
         else:
             frame = cctx.compress(original)
             source = io.BytesIO(frame)
 
         dctx = zstd.ZstdDecompressor()
 
         data = dctx.stream_reader(source, read_size=source_read_size).readall()
         self.assertEqual(data, original)
 
     @hypothesis.settings(
-        suppress_health_check=[hypothesis.HealthCheck.large_base_example])
-    @hypothesis.given(original=strategies.sampled_from(random_input_data()),
-                      level=strategies.integers(min_value=1, max_value=5),
-                      streaming=strategies.booleans(),
-                      source_read_size=strategies.integers(1, 1048576),
-                      read_sizes=strategies.data())
-    def test_stream_source_read1_variance(self, original, level, streaming,
-                                          source_read_size, read_sizes):
+        suppress_health_check=[
+            hypothesis.HealthCheck.large_base_example,
+            hypothesis.HealthCheck.too_slow,
+        ]
+    )
+    @hypothesis.given(
+        original=strategies.sampled_from(random_input_data()),
+        level=strategies.integers(min_value=1, max_value=5),
+        streaming=strategies.booleans(),
+        source_read_size=strategies.integers(1, 1048576),
+        read_sizes=strategies.data(),
+    )
+    def test_stream_source_read1_variance(
+        self, original, level, streaming, source_read_size, read_sizes
+    ):
         cctx = zstd.ZstdCompressor(level=level)
 
         if streaming:
             source = io.BytesIO()
             writer = cctx.stream_writer(source)
             writer.write(original)
             writer.flush(zstd.FLUSH_FRAME)
             source.seek(0)
         else:
             frame = cctx.compress(original)
             source = io.BytesIO(frame)
 
         dctx = zstd.ZstdDecompressor()
 
         chunks = []
         with dctx.stream_reader(source, read_size=source_read_size) as reader:
             while True:
                 read_size = read_sizes.draw(strategies.integers(-1, 131072))
                 chunk = reader.read1(read_size)
                 if not chunk and read_size:
                     break
 
                 chunks.append(chunk)
 
-        self.assertEqual(b''.join(chunks), original)
+        self.assertEqual(b"".join(chunks), original)
 
     @hypothesis.settings(
-        suppress_health_check=[hypothesis.HealthCheck.large_base_example])
-    @hypothesis.given(original=strategies.sampled_from(random_input_data()),
-                      level=strategies.integers(min_value=1, max_value=5),
-                      streaming=strategies.booleans(),
-                      source_read_size=strategies.integers(1, 1048576),
-                      read_sizes=strategies.data())
-    def test_stream_source_readinto1_variance(self, original, level, streaming,
-                                          source_read_size, read_sizes):
+        suppress_health_check=[
+            hypothesis.HealthCheck.large_base_example,
+            hypothesis.HealthCheck.too_slow,
+        ]
+    )
+    @hypothesis.given(
+        original=strategies.sampled_from(random_input_data()),
+        level=strategies.integers(min_value=1, max_value=5),
+        streaming=strategies.booleans(),
+        source_read_size=strategies.integers(1, 1048576),
+        read_sizes=strategies.data(),
+    )
+    def test_stream_source_readinto1_variance(
+        self, original, level, streaming, source_read_size, read_sizes
+    ):
         cctx = zstd.ZstdCompressor(level=level)
 
         if streaming:
             source = io.BytesIO()
             writer = cctx.stream_writer(source)
             writer.write(original)
             writer.flush(zstd.FLUSH_FRAME)
             source.seek(0)
         else:
             frame = cctx.compress(original)
             source = io.BytesIO(frame)
 
         dctx = zstd.ZstdDecompressor()
 
         chunks = []
         with dctx.stream_reader(source, read_size=source_read_size) as reader:
             while True:
                 read_size = read_sizes.draw(strategies.integers(1, 131072))
                 b = bytearray(read_size)
                 count = reader.readinto1(b)
 
                 if not count:
                     break
 
                 chunks.append(bytes(b[0:count]))
 
-        self.assertEqual(b''.join(chunks), original)
+        self.assertEqual(b"".join(chunks), original)
 
     @hypothesis.settings(
-        suppress_health_check=[hypothesis.HealthCheck.large_base_example])
+        suppress_health_check=[
+            hypothesis.HealthCheck.large_base_example,
+            hypothesis.HealthCheck.too_slow,
+        ]
+    )
     @hypothesis.given(
         original=strategies.sampled_from(random_input_data()),
         level=strategies.integers(min_value=1, max_value=5),
         source_read_size=strategies.integers(1, 1048576),
         seek_amounts=strategies.data(),
-        read_sizes=strategies.data())
-    def test_relative_seeks(self, original, level, source_read_size, seek_amounts,
-                            read_sizes):
+        read_sizes=strategies.data(),
+    )
+    def test_relative_seeks(
+        self, original, level, source_read_size, seek_amounts, read_sizes
+    ):
         cctx = zstd.ZstdCompressor(level=level)
         frame = cctx.compress(original)
 
         dctx = zstd.ZstdDecompressor()
 
         with dctx.stream_reader(frame, read_size=source_read_size) as reader:
             while True:
                 amount = seek_amounts.draw(strategies.integers(0, 16384))
                 reader.seek(amount, os.SEEK_CUR)
 
                 offset = reader.tell()
                 read_amount = read_sizes.draw(strategies.integers(1, 16384))
                 chunk = reader.read(read_amount)
 
                 if not chunk:
                     break
 
-                self.assertEqual(original[offset:offset + len(chunk)], chunk)
+                self.assertEqual(original[offset : offset + len(chunk)], chunk)
 
     @hypothesis.settings(
-        suppress_health_check=[hypothesis.HealthCheck.large_base_example])
+        suppress_health_check=[
+            hypothesis.HealthCheck.large_base_example,
+            hypothesis.HealthCheck.too_slow,
+        ]
+    )
     @hypothesis.given(
         originals=strategies.data(),
         frame_count=strategies.integers(min_value=2, max_value=10),
         level=strategies.integers(min_value=1, max_value=5),
         source_read_size=strategies.integers(1, 1048576),
-        read_sizes=strategies.data())
-    def test_multiple_frames(self, originals, frame_count, level,
-                             source_read_size, read_sizes):
+        read_sizes=strategies.data(),
+    )
+    def test_multiple_frames(
+        self, originals, frame_count, level, source_read_size, read_sizes
+    ):
 
         cctx = zstd.ZstdCompressor(level=level)
         source = io.BytesIO()
         buffer = io.BytesIO()
         writer = cctx.stream_writer(buffer)
 
         for i in range(frame_count):
             data = originals.draw(strategies.sampled_from(random_input_data()))
             source.write(data)
             writer.write(data)
             writer.flush(zstd.FLUSH_FRAME)
 
         dctx = zstd.ZstdDecompressor()
         buffer.seek(0)
-        reader = dctx.stream_reader(buffer, read_size=source_read_size,
-                                    read_across_frames=True)
+        reader = dctx.stream_reader(
+            buffer, read_size=source_read_size, read_across_frames=True
+        )
 
         chunks = []
 
         while True:
             read_amount = read_sizes.draw(strategies.integers(-1, 16384))
             chunk = reader.read(read_amount)
 
             if not chunk and read_amount:
                 break
 
             chunks.append(chunk)
 
-        self.assertEqual(source.getvalue(), b''.join(chunks))
+        self.assertEqual(source.getvalue(), b"".join(chunks))
 
 
[e-mail]('ZSTD_SLOW_TESTS' in os.environ, 'ZSTD_SLOW_TESTS not set')
[e-mail]("ZSTD_SLOW_TESTS" in os.environ, "ZSTD_SLOW_TESTS not set")
 @make_cffi
-class TestDecompressor_stream_writer_fuzzing(unittest.TestCase):
-    @hypothesis.given(original=strategies.sampled_from(random_input_data()),
-                      level=strategies.integers(min_value=1, max_value=5),
-                      write_size=strategies.integers(min_value=1, max_value=8192),
-                      input_sizes=strategies.data())
+class TestDecompressor_stream_writer_fuzzing(TestCase):
+    @hypothesis.settings(
+        suppress_health_check=[
+            hypothesis.HealthCheck.large_base_example,
+            hypothesis.HealthCheck.too_slow,
+        ]
+    )
+    @hypothesis.given(
+        original=strategies.sampled_from(random_input_data()),
+        level=strategies.integers(min_value=1, max_value=5),
+        write_size=strategies.integers(min_value=1, max_value=8192),
+        input_sizes=strategies.data(),
+    )
     def test_write_size_variance(self, original, level, write_size, input_sizes):
         cctx = zstd.ZstdCompressor(level=level)
         frame = cctx.compress(original)
 
         dctx = zstd.ZstdDecompressor()
         source = io.BytesIO(frame)
         dest = NonClosingBytesIO()
 
         with dctx.stream_writer(dest, write_size=write_size) as decompressor:
             while True:
                 input_size = input_sizes.draw(strategies.integers(1, 4096))
                 chunk = source.read(input_size)
                 if not chunk:
                     break
 
                 decompressor.write(chunk)
 
         self.assertEqual(dest.getvalue(), original)
 
 
[e-mail]('ZSTD_SLOW_TESTS' in os.environ, 'ZSTD_SLOW_TESTS not set')
[e-mail]("ZSTD_SLOW_TESTS" in os.environ, "ZSTD_SLOW_TESTS not set")
 @make_cffi
-class TestDecompressor_copy_stream_fuzzing(unittest.TestCase):
-    @hypothesis.given(original=strategies.sampled_from(random_input_data()),
-                      level=strategies.integers(min_value=1, max_value=5),
-                      read_size=strategies.integers(min_value=1, max_value=8192),
-                      write_size=strategies.integers(min_value=1, max_value=8192))
+class TestDecompressor_copy_stream_fuzzing(TestCase):
+    @hypothesis.settings(
+        suppress_health_check=[
+            hypothesis.HealthCheck.large_base_example,
+            hypothesis.HealthCheck.too_slow,
+        ]
+    )
+    @hypothesis.given(
+        original=strategies.sampled_from(random_input_data()),
+        level=strategies.integers(min_value=1, max_value=5),
+        read_size=strategies.integers(min_value=1, max_value=8192),
+        write_size=strategies.integers(min_value=1, max_value=8192),
+    )
     def test_read_write_size_variance(self, original, level, read_size, write_size):
         cctx = zstd.ZstdCompressor(level=level)
         frame = cctx.compress(original)
 
         source = io.BytesIO(frame)
         dest = io.BytesIO()
 
         dctx = zstd.ZstdDecompressor()
         dctx.copy_stream(source, dest, read_size=read_size, write_size=write_size)
 
         self.assertEqual(dest.getvalue(), original)
 
 
[e-mail]('ZSTD_SLOW_TESTS' in os.environ, 'ZSTD_SLOW_TESTS not set')
[e-mail]("ZSTD_SLOW_TESTS" in os.environ, "ZSTD_SLOW_TESTS not set")
 @make_cffi
-class TestDecompressor_decompressobj_fuzzing(unittest.TestCase):
-    @hypothesis.given(original=strategies.sampled_from(random_input_data()),
-                      level=strategies.integers(min_value=1, max_value=5),
-                      chunk_sizes=strategies.data())
+class TestDecompressor_decompressobj_fuzzing(TestCase):
+    @hypothesis.settings(
+        suppress_health_check=[
+            hypothesis.HealthCheck.large_base_example,
+            hypothesis.HealthCheck.too_slow,
+        ]
+    )
+    @hypothesis.given(
+        original=strategies.sampled_from(random_input_data()),
+        level=strategies.integers(min_value=1, max_value=5),
+        chunk_sizes=strategies.data(),
+    )
     def test_random_input_sizes(self, original, level, chunk_sizes):
         cctx = zstd.ZstdCompressor(level=level)
         frame = cctx.compress(original)
 
         source = io.BytesIO(frame)
 
         dctx = zstd.ZstdDecompressor()
         dobj = dctx.decompressobj()
 
         chunks = []
         while True:
             chunk_size = chunk_sizes.draw(strategies.integers(1, 4096))
             chunk = source.read(chunk_size)
             if not chunk:
                 break
 
             chunks.append(dobj.decompress(chunk))
 
-        self.assertEqual(b''.join(chunks), original)
+        self.assertEqual(b"".join(chunks), original)
 
-    @hypothesis.given(original=strategies.sampled_from(random_input_data()),
-                      level=strategies.integers(min_value=1, max_value=5),
-                      write_size=strategies.integers(min_value=1,
-                                                     max_value=4 * zstd.DECOMPRESSION_RECOMMENDED_OUTPUT_SIZE),
-                      chunk_sizes=strategies.data())
+    @hypothesis.settings(
+        suppress_health_check=[
+            hypothesis.HealthCheck.large_base_example,
+            hypothesis.HealthCheck.too_slow,
+        ]
+    )
+    @hypothesis.given(
+        original=strategies.sampled_from(random_input_data()),
+        level=strategies.integers(min_value=1, max_value=5),
+        write_size=strategies.integers(
+            min_value=1, max_value=4 * zstd.DECOMPRESSION_RECOMMENDED_OUTPUT_SIZE
+        ),
+        chunk_sizes=strategies.data(),
+    )
     def test_random_output_sizes(self, original, level, write_size, chunk_sizes):
         cctx = zstd.ZstdCompressor(level=level)
         frame = cctx.compress(original)
 
         source = io.BytesIO(frame)
 
         dctx = zstd.ZstdDecompressor()
         dobj = dctx.decompressobj(write_size=write_size)
 
         chunks = []
         while True:
             chunk_size = chunk_sizes.draw(strategies.integers(1, 4096))
             chunk = source.read(chunk_size)
             if not chunk:
                 break
 
             chunks.append(dobj.decompress(chunk))
 
-        self.assertEqual(b''.join(chunks), original)
+        self.assertEqual(b"".join(chunks), original)
 
 
[e-mail]('ZSTD_SLOW_TESTS' in os.environ, 'ZSTD_SLOW_TESTS not set')
[e-mail]("ZSTD_SLOW_TESTS" in os.environ, "ZSTD_SLOW_TESTS not set")
 @make_cffi
-class TestDecompressor_read_to_iter_fuzzing(unittest.TestCase):
-    @hypothesis.given(original=strategies.sampled_from(random_input_data()),
-                      level=strategies.integers(min_value=1, max_value=5),
-                      read_size=strategies.integers(min_value=1, max_value=4096),
-                      write_size=strategies.integers(min_value=1, max_value=4096))
+class TestDecompressor_read_to_iter_fuzzing(TestCase):
+    @hypothesis.given(
+        original=strategies.sampled_from(random_input_data()),
+        level=strategies.integers(min_value=1, max_value=5),
+        read_size=strategies.integers(min_value=1, max_value=4096),
+        write_size=strategies.integers(min_value=1, max_value=4096),
+    )
     def test_read_write_size_variance(self, original, level, read_size, write_size):
         cctx = zstd.ZstdCompressor(level=level)
         frame = cctx.compress(original)
 
         source = io.BytesIO(frame)
 
         dctx = zstd.ZstdDecompressor()
-        chunks = list(dctx.read_to_iter(source, read_size=read_size, write_size=write_size))
+        chunks = list(
+            dctx.read_to_iter(source, read_size=read_size, write_size=write_size)
+        )
 
-        self.assertEqual(b''.join(chunks), original)
+        self.assertEqual(b"".join(chunks), original)
 
 
[e-mail]('ZSTD_SLOW_TESTS' in os.environ, 'ZSTD_SLOW_TESTS not set')
-class TestDecompressor_multi_decompress_to_buffer_fuzzing(unittest.TestCase):
-    @hypothesis.given(original=strategies.lists(strategies.sampled_from(random_input_data()),
-                                        min_size=1, max_size=1024),
-                threads=strategies.integers(min_value=1, max_value=8),
-                use_dict=strategies.booleans())
[e-mail]("ZSTD_SLOW_TESTS" in os.environ, "ZSTD_SLOW_TESTS not set")
+class TestDecompressor_multi_decompress_to_buffer_fuzzing(TestCase):
+    @hypothesis.given(
+        original=strategies.lists(
+            strategies.sampled_from(random_input_data()), min_size=1, max_size=1024
+        ),
+        threads=strategies.integers(min_value=1, max_value=8),
+        use_dict=strategies.booleans(),
+    )
     def test_data_equivalence(self, original, threads, use_dict):
         kwargs = {}
         if use_dict:
-            kwargs['dict_data'] = zstd.ZstdCompressionDict(original[0])
+            kwargs["dict_data"] = zstd.ZstdCompressionDict(original[0])
 
-        cctx = zstd.ZstdCompressor(level=1,
-                                   write_content_size=True,
-                                   write_checksum=True,
-                                   **kwargs)
+        cctx = zstd.ZstdCompressor(
+            level=1, write_content_size=True, write_checksum=True, **kwargs
+        )
 
-        if not hasattr(cctx, 'multi_compress_to_buffer'):
-            self.skipTest('multi_compress_to_buffer not available')
+        if not hasattr(cctx, "multi_compress_to_buffer"):
+            self.skipTest("multi_compress_to_buffer not available")
 
         frames_buffer = cctx.multi_compress_to_buffer(original, threads=-1)
 
         dctx = zstd.ZstdDecompressor(**kwargs)
         result = dctx.multi_decompress_to_buffer(frames_buffer)
 
         self.assertEqual(len(result), len(original))
         for i, frame in enumerate(result):
             self.assertEqual(frame.tobytes(), original[i])
 
         frames_list = [f.tobytes() for f in frames_buffer]
         result = dctx.multi_decompress_to_buffer(frames_list)
 
         self.assertEqual(len(result), len(original))
         for i, frame in enumerate(result):
             self.assertEqual(frame.tobytes(), original[i])

contrib/python-zstandard/tests/test_estimate_sizes.py

@@ -1,15 +1,15 b''
 import unittest
 
 import zstandard as zstd
 
-from . common import (
+from .common import (
     make_cffi,
+    TestCase,
 )
 
 
 @make_cffi
-class TestSizes(unittest.TestCase):
+class TestSizes(TestCase):
     def test_decompression_size(self):
         size = zstd.estimate_decompression_context_size()
         self.assertGreater(size, 100000)
-

contrib/python-zstandard/tests/test_module_attributes.py

@@ -1,69 +1,70 b''
 from __future__ import unicode_literals
 
 import unittest
 
 import zstandard as zstd
 
-from . common import (
+from .common import (
     make_cffi,
+    TestCase,
 )
 
 
 @make_cffi
-class TestModuleAttributes(unittest.TestCase):
+class TestModuleAttributes(TestCase):
     def test_version(self):
-        self.assertEqual(zstd.ZSTD_VERSION, (1, 4, 3))
+        self.assertEqual(zstd.ZSTD_VERSION, (1, 4, 4))
 
-        self.assertEqual(zstd.__version__, '0.12.0')
+        self.assertEqual(zstd.__version__, "0.13.0")
 
     def test_constants(self):
         self.assertEqual(zstd.MAX_COMPRESSION_LEVEL, 22)
-        self.assertEqual(zstd.FRAME_HEADER, b'\x28\xb5\x2f\xfd')
+        self.assertEqual(zstd.FRAME_HEADER, b"\x28\xb5\x2f\xfd")
 
     def test_hasattr(self):
         attrs = (
-            'CONTENTSIZE_UNKNOWN',
-            'CONTENTSIZE_ERROR',
-            'COMPRESSION_RECOMMENDED_INPUT_SIZE',
-            'COMPRESSION_RECOMMENDED_OUTPUT_SIZE',
-            'DECOMPRESSION_RECOMMENDED_INPUT_SIZE',
-            'DECOMPRESSION_RECOMMENDED_OUTPUT_SIZE',
-            'MAGIC_NUMBER',
-            'FLUSH_BLOCK',
-            'FLUSH_FRAME',
-            'BLOCKSIZELOG_MAX',
-            'BLOCKSIZE_MAX',
-            'WINDOWLOG_MIN',
-            'WINDOWLOG_MAX',
-            'CHAINLOG_MIN',
-            'CHAINLOG_MAX',
-            'HASHLOG_MIN',
-            'HASHLOG_MAX',
-            'HASHLOG3_MAX',
-            'MINMATCH_MIN',
-            'MINMATCH_MAX',
-            'SEARCHLOG_MIN',
-            'SEARCHLOG_MAX',
-            'SEARCHLENGTH_MIN',
-            'SEARCHLENGTH_MAX',
-            'TARGETLENGTH_MIN',
-            'TARGETLENGTH_MAX',
-            'LDM_MINMATCH_MIN',
-            'LDM_MINMATCH_MAX',
-            'LDM_BUCKETSIZELOG_MAX',
-            'STRATEGY_FAST',
-            'STRATEGY_DFAST',
-            'STRATEGY_GREEDY',
-            'STRATEGY_LAZY',
-            'STRATEGY_LAZY2',
-            'STRATEGY_BTLAZY2',
-            'STRATEGY_BTOPT',
-            'STRATEGY_BTULTRA',
-            'STRATEGY_BTULTRA2',
-            'DICT_TYPE_AUTO',
-            'DICT_TYPE_RAWCONTENT',
-            'DICT_TYPE_FULLDICT',
+            "CONTENTSIZE_UNKNOWN",
+            "CONTENTSIZE_ERROR",
+            "COMPRESSION_RECOMMENDED_INPUT_SIZE",
+            "COMPRESSION_RECOMMENDED_OUTPUT_SIZE",
+            "DECOMPRESSION_RECOMMENDED_INPUT_SIZE",
+            "DECOMPRESSION_RECOMMENDED_OUTPUT_SIZE",
+            "MAGIC_NUMBER",
+            "FLUSH_BLOCK",
+            "FLUSH_FRAME",
+            "BLOCKSIZELOG_MAX",
+            "BLOCKSIZE_MAX",
+            "WINDOWLOG_MIN",
+            "WINDOWLOG_MAX",
+            "CHAINLOG_MIN",
+            "CHAINLOG_MAX",
+            "HASHLOG_MIN",
+            "HASHLOG_MAX",
+            "HASHLOG3_MAX",
+            "MINMATCH_MIN",
+            "MINMATCH_MAX",
+            "SEARCHLOG_MIN",
+            "SEARCHLOG_MAX",
+            "SEARCHLENGTH_MIN",
+            "SEARCHLENGTH_MAX",
+            "TARGETLENGTH_MIN",
+            "TARGETLENGTH_MAX",
+            "LDM_MINMATCH_MIN",
+            "LDM_MINMATCH_MAX",
+            "LDM_BUCKETSIZELOG_MAX",
+            "STRATEGY_FAST",
+            "STRATEGY_DFAST",
+            "STRATEGY_GREEDY",
+            "STRATEGY_LAZY",
+            "STRATEGY_LAZY2",
+            "STRATEGY_BTLAZY2",
+            "STRATEGY_BTOPT",
+            "STRATEGY_BTULTRA",
+            "STRATEGY_BTULTRA2",
+            "DICT_TYPE_AUTO",
+            "DICT_TYPE_RAWCONTENT",
+            "DICT_TYPE_FULLDICT",
         )
 
         for a in attrs:
             self.assertTrue(hasattr(zstd, a), a)

contrib/python-zstandard/tests/test_train_dictionary.py

@@ -1,89 +1,92 b''
 import struct
 import sys
 import unittest
 
 import zstandard as zstd
 
-from . common import (
+from .common import (
     generate_samples,
     make_cffi,
     random_input_data,
+    TestCase,
 )
 
 if sys.version_info[0] >= 3:
     int_type = int
 else:
     int_type = long
 
 
 @make_cffi
-class TestTrainDictionary(unittest.TestCase):
+class TestTrainDictionary(TestCase):
     def test_no_args(self):
         with self.assertRaises(TypeError):
             zstd.train_dictionary()
 
     def test_bad_args(self):
         with self.assertRaises(TypeError):
-            zstd.train_dictionary(8192, u'foo')
+            zstd.train_dictionary(8192, u"foo")
 
         with self.assertRaises(ValueError):
-            zstd.train_dictionary(8192, [u'foo'])
+            zstd.train_dictionary(8192, [u"foo"])
 
     def test_no_params(self):
         d = zstd.train_dictionary(8192, random_input_data())
         self.assertIsInstance(d.dict_id(), int_type)
 
         # The dictionary ID may be different across platforms.
-        expected = b'\x37\xa4\x30\xec' + struct.pack('<I', d.dict_id())
+        expected = b"\x37\xa4\x30\xec" + struct.pack("<I", d.dict_id())
 
         data = d.as_bytes()
         self.assertEqual(data[0:8], expected)
 
     def test_basic(self):
         d = zstd.train_dictionary(8192, generate_samples(), k=64, d=16)
         self.assertIsInstance(d.dict_id(), int_type)
 
         data = d.as_bytes()
-        self.assertEqual(data[0:4], b'\x37\xa4\x30\xec')
+        self.assertEqual(data[0:4], b"\x37\xa4\x30\xec")
 
         self.assertEqual(d.k, 64)
         self.assertEqual(d.d, 16)
 
     def test_set_dict_id(self):
-        d = zstd.train_dictionary(8192, generate_samples(), k=64, d=16,
-                                  dict_id=42)
+        d = zstd.train_dictionary(8192, generate_samples(), k=64, d=16, dict_id=42)
         self.assertEqual(d.dict_id(), 42)
 
     def test_optimize(self):
-        d = zstd.train_dictionary(8192, generate_samples(), threads=-1, steps=1,
-                                  d=16)
+        d = zstd.train_dictionary(8192, generate_samples(), threads=-1, steps=1, d=16)
 
         # This varies by platform.
         self.assertIn(d.k, (50, 2000))
         self.assertEqual(d.d, 16)
 
+
 @make_cffi
-class TestCompressionDict(unittest.TestCase):
+class TestCompressionDict(TestCase):
     def test_bad_mode(self):
-        with self.assertRaisesRegexp(ValueError, 'invalid dictionary load mode'):
-            zstd.ZstdCompressionDict(b'foo', dict_type=42)
+        with self.assertRaisesRegex(ValueError, "invalid dictionary load mode"):
+            zstd.ZstdCompressionDict(b"foo", dict_type=42)
 
     def test_bad_precompute_compress(self):
         d = zstd.train_dictionary(8192, generate_samples(), k=64, d=16)
 
-        with self.assertRaisesRegexp(ValueError, 'must specify one of level or '):
+        with self.assertRaisesRegex(ValueError, "must specify one of level or "):
             d.precompute_compress()
 
-        with self.assertRaisesRegexp(ValueError, 'must only specify one of level or '):
-            d.precompute_compress(level=3,
-                                  compression_params=zstd.CompressionParameters())
+        with self.assertRaisesRegex(ValueError, "must only specify one of level or "):
+            d.precompute_compress(
+                level=3, compression_params=zstd.CompressionParameters()
+            )
 
     def test_precompute_compress_rawcontent(self):
-        d = zstd.ZstdCompressionDict(b'dictcontent' * 64,
-                                     dict_type=zstd.DICT_TYPE_RAWCONTENT)
+        d = zstd.ZstdCompressionDict(
+            b"dictcontent" * 64, dict_type=zstd.DICT_TYPE_RAWCONTENT
+        )
         d.precompute_compress(level=1)
 
-        d = zstd.ZstdCompressionDict(b'dictcontent' * 64,
-                                     dict_type=zstd.DICT_TYPE_FULLDICT)
-        with self.assertRaisesRegexp(zstd.ZstdError, 'unable to precompute dictionary'):
+        d = zstd.ZstdCompressionDict(
+            b"dictcontent" * 64, dict_type=zstd.DICT_TYPE_FULLDICT
+        )
+        with self.assertRaisesRegex(zstd.ZstdError, "unable to precompute dictionary"):
             d.precompute_compress(level=1)

contrib/python-zstandard/zstandard/__init__.py

@@ -1,65 +1,75 b''
 # Copyright (c) 2017-present, Gregory Szorc
 # All rights reserved.
 #
 # This software may be modified and distributed under the terms
 # of the BSD license. See the LICENSE file for details.
 
 """Python interface to the Zstandard (zstd) compression library."""
 
 from __future__ import absolute_import, unicode_literals
 
 # This module serves 2 roles:
 #
 # 1) Export the C or CFFI "backend" through a central module.
 # 2) Implement additional functionality built on top of C or CFFI backend.
 
 import os
 import platform
 
 # Some Python implementations don't support C extensions. That's why we have
 # a CFFI implementation in the first place. The code here import one of our
 # "backends" then re-exports the symbols from this module. For convenience,
 # we support falling back to the CFFI backend if the C extension can't be
 # imported. But for performance reasons, we only do this on unknown Python
 # implementation. Notably, for CPython we require the C extension by default.
 # Because someone will inevitably want special behavior, the behavior is
 # configurable via an environment variable. A potentially better way to handle
 # this is to import a special ``__importpolicy__`` module or something
 # defining a variable and `setup.py` could write the file with whatever
 # policy was specified at build time. Until someone needs it, we go with
 # the hacky but simple environment variable approach.
-_module_policy = os.environ.get('PYTHON_ZSTANDARD_IMPORT_POLICY', 'default')
+_module_policy = os.environ.get("PYTHON_ZSTANDARD_IMPORT_POLICY", "default")
 
-if _module_policy == 'default':
-    if platform.python_implementation() in ('CPython',):
+if _module_policy == "default":
+    if platform.python_implementation() in ("CPython",):
         from zstd import *
-        backend = 'cext'
-    elif platform.python_implementation() in ('PyPy',):
+
+        backend = "cext"
+    elif platform.python_implementation() in ("PyPy",):
         from .cffi import *
-        backend = 'cffi'
+
+        backend = "cffi"
     else:
         try:
             from zstd import *
-            backend = 'cext'
+
+            backend = "cext"
         except ImportError:
             from .cffi import *
-            backend = 'cffi'
-elif _module_policy == 'cffi_fallback':
+
+            backend = "cffi"
+elif _module_policy == "cffi_fallback":
     try:
         from zstd import *
-        backend = 'cext'
+
+        backend = "cext"
     except ImportError:
         from .cffi import *
-        backend = 'cffi'
-elif _module_policy == 'cext':
+
+        backend = "cffi"
+elif _module_policy == "cext":
     from zstd import *
-    backend = 'cext'
-elif _module_policy == 'cffi':
+
+    backend = "cext"
+elif _module_policy == "cffi":
     from .cffi import *
-    backend = 'cffi'
+
+    backend = "cffi"
 else:
-    raise ImportError('unknown module import policy: %s; use default, cffi_fallback, '
-                      'cext, or cffi' % _module_policy)
+    raise ImportError(
+        "unknown module import policy: %s; use default, cffi_fallback, "
+        "cext, or cffi" % _module_policy
+    )
 
 # Keep this in sync with python-zstandard.h.
-__version__ = '0.12.0'
+__version__ = "0.13.0"