numcodecs 0.12.1__cp311-cp311-win_amd64.whl → 0.13.1__cp311-cp311-win_amd64.whl

numcodecs/tests/test_lzma.py

@@ -1,30 +1,31 @@
 import itertools
 import unittest
 
-
 import numpy as np
 import pytest
 
-
 try:
     # noinspection PyProtectedMember
     from numcodecs.lzma import LZMA, _lzma
-except ImportError:  # pragma: no cover
-    raise unittest.SkipTest("LZMA not available")
-
+except ImportError as e:  # pragma: no cover
+    raise unittest.SkipTest("LZMA not available") from e
 
-from numcodecs.tests.common import (check_encode_decode, check_config, check_repr,
-                                    check_backwards_compatibility,
-                                    check_err_decode_object_buffer,
-                                    check_err_encode_object_buffer)
 
+from numcodecs.tests.common import (
+    check_backwards_compatibility,
+    check_config,
+    check_encode_decode,
+    check_err_decode_object_buffer,
+    check_err_encode_object_buffer,
+    check_repr,
+)
 
 codecs = [
     LZMA(),
     LZMA(preset=1),
     LZMA(preset=5),
     LZMA(preset=9),
-    LZMA(format=_lzma.FORMAT_RAW, filters=[dict(id=_lzma.FILTER_LZMA2, preset=1)])
+    LZMA(format=_lzma.FORMAT_RAW, filters=[dict(id=_lzma.FILTER_LZMA2, preset=1)]),
 ]
 
 
@@ -41,10 +42,10 @@ arrays = [
     np.random.randint(0, 2**60, size=1000, dtype='u8').view('m8[ns]'),
     np.random.randint(0, 2**25, size=1000, dtype='u8').view('M8[m]'),
     np.random.randint(0, 2**25, size=1000, dtype='u8').view('m8[m]'),
-    np.random.randint(-2**63, -2**63 + 20, size=1000, dtype='i8').view('M8[ns]'),
-    np.random.randint(-2**63, -2**63 + 20, size=1000, dtype='i8').view('m8[ns]'),
-    np.random.randint(-2**63, -2**63 + 20, size=1000, dtype='i8').view('M8[m]'),
-    np.random.randint(-2**63, -2**63 + 20, size=1000, dtype='i8').view('m8[m]'),
+    np.random.randint(-(2**63), -(2**63) + 20, size=1000, dtype='i8').view('M8[ns]'),
+    np.random.randint(-(2**63), -(2**63) + 20, size=1000, dtype='i8').view('m8[ns]'),
+    np.random.randint(-(2**63), -(2**63) + 20, size=1000, dtype='i8').view('M8[m]'),
+    np.random.randint(-(2**63), -(2**63) + 20, size=1000, dtype='i8').view('m8[m]'),
 ]
 
 

numcodecs/tests/test_msgpacks.py

@@ -1,19 +1,21 @@
 import unittest
 
-
 import numpy as np
 import pytest
 
-
 try:
     from numcodecs.msgpacks import MsgPack
-except ImportError:  # pragma: no cover
-    raise unittest.SkipTest("msgpack not available")
+except ImportError as e:  # pragma: no cover
+    raise unittest.SkipTest("msgpack not available") from e
 
 
-from numcodecs.tests.common import (check_config, check_repr, check_encode_decode_array,
-                                    check_backwards_compatibility, greetings)
-
+from numcodecs.tests.common import (
+    check_backwards_compatibility,
+    check_config,
+    check_encode_decode_array,
+    check_repr,
+    greetings,
+)
 
 # object array with strings
 # object array with mix strings / nans
@@ -69,7 +71,7 @@ def test_backwards_compatibility():
         ([b"11", b"11"], None),
         ([b"11", b"1", b"1"], None),
         ([{b"key": b"value"}, [b"list", b"of", b"strings"]], object),
-    ]
+    ],
 )
 def test_non_numpy_inputs(input_data, dtype):
     codec = MsgPack()

numcodecs/tests/test_packbits.py

@@ -1,10 +1,12 @@
 import numpy as np
 
-
 from numcodecs.packbits import PackBits
-from numcodecs.tests.common import (check_encode_decode, check_config, check_repr,
-                                    check_backwards_compatibility)
-
+from numcodecs.tests.common import (
+    check_backwards_compatibility,
+    check_config,
+    check_encode_decode,
+    check_repr,
+)
 
 arrays = [
     np.random.randint(0, 2, size=1000, dtype=bool),

numcodecs/tests/test_pcodec.py

@@ -0,0 +1,80 @@
+import numpy as np
+import pytest
+
+from numcodecs.pcodec import PCodec
+
+try:
+    # initializing codec triggers ImportError
+    PCodec()
+except ImportError:  # pragma: no cover
+    pytest.skip("pcodec not available", allow_module_level=True)
+
+from numcodecs.tests.common import (
+    check_backwards_compatibility,
+    check_config,
+    check_encode_decode_array_to_bytes,
+    check_err_decode_object_buffer,
+    check_err_encode_object_buffer,
+    check_repr,
+)
+
+codecs = [
+    PCodec(),
+    PCodec(level=1),
+    PCodec(level=5),
+    PCodec(level=9),
+    PCodec(mode_spec='classic'),
+    PCodec(equal_pages_up_to=300),
+]
+
+
+# mix of dtypes: integer, float
+# mix of shapes: 1D, 2D
+# mix of orders: C, F
+arrays = [
+    np.arange(1000, dtype="u4"),
+    np.arange(1000, dtype="u8"),
+    np.arange(1000, dtype="i4"),
+    np.arange(1000, dtype="i8"),
+    np.linspace(1000, 1001, 1000, dtype="f4"),
+    np.linspace(1000, 1001, 1000, dtype="f8"),
+    np.random.normal(loc=1000, scale=1, size=(100, 10)),
+    np.asfortranarray(np.random.normal(loc=1000, scale=1, size=(100, 10))),
+    np.random.randint(0, 2**60, size=1000, dtype="u8"),
+    np.random.randint(-(2**63), -(2**63) + 20, size=1000, dtype="i8"),
+]
+
+
+@pytest.mark.parametrize("arr", arrays)
+@pytest.mark.parametrize("codec", codecs)
+def test_encode_decode(arr, codec):
+    check_encode_decode_array_to_bytes(arr, codec)
+
+
+def test_config():
+    codec = PCodec(level=3)
+    check_config(codec)
+
+
+def test_invalid_config_error():
+    with pytest.raises(ValueError):
+        codec = PCodec(mode_spec='bogus')
+        check_encode_decode_array_to_bytes(arrays[0], codec)
+
+
+def test_repr():
+    check_repr(
+        "PCodec(delta_encoding_order=None, equal_pages_up_to=262144, level=3, mode_spec='auto')"
+    )
+
+
+def test_backwards_compatibility():
+    check_backwards_compatibility(PCodec.codec_id, arrays, codecs)
+
+
+def test_err_decode_object_buffer():
+    check_err_decode_object_buffer(PCodec())
+
+
+def test_err_encode_object_buffer():
+    check_err_encode_object_buffer(PCodec())

numcodecs/tests/test_pickles.py

@@ -5,9 +5,13 @@ import numpy as np
 import pytest
 
 from numcodecs.pickles import Pickle
-from numcodecs.tests.common import (check_config, check_repr, check_encode_decode_array,
-                                    check_backwards_compatibility, greetings)
-
+from numcodecs.tests.common import (
+    check_backwards_compatibility,
+    check_config,
+    check_encode_decode_array,
+    check_repr,
+    greetings,
+)
 
 codecs = [Pickle(protocol=i) for i in range(5)]
 
@@ -45,14 +49,13 @@ def test_repr():
 
 # Details on xfail
 # https://stackoverflow.com/questions/58194852/modulenotfounderror-no-module-named-numpy-core-multiarray-r
-@pytest.mark.skipif(
-    sys.byteorder != "little", reason="Pickle does not restore byte orders"
-)
+@pytest.mark.skipif(sys.byteorder != "little", reason="Pickle does not restore byte orders")
 @pytest.mark.xfail(
-    sys.platform == "win32", reason=(
+    sys.platform == "win32",
+    reason=(
         "Pickle fails to read w/ Windows carriage return "
         "( https://github.com/zarr-developers/numcodecs/issues/271 )"
-    )
+    ),
 )
 def test_backwards_compatibility():
     check_backwards_compatibility(Pickle.codec_id, arrays, codecs)

numcodecs/tests/test_quantize.py

@@ -1,15 +1,16 @@
 import itertools
 
-
 import numpy as np
-from numpy.testing import assert_array_equal, assert_array_almost_equal
 import pytest
-
+from numpy.testing import assert_array_almost_equal, assert_array_equal
 
 from numcodecs.quantize import Quantize
-from numcodecs.tests.common import check_encode_decode, check_config, \
-    check_repr, check_backwards_compatibility
-
+from numcodecs.tests.common import (
+    check_backwards_compatibility,
+    check_config,
+    check_encode_decode,
+    check_repr,
+)
 
 arrays = [
     np.linspace(100, 200, 1000, dtype='<f8'),

numcodecs/tests/test_registry.py

@@ -1,7 +1,7 @@
-import pytest
-
 import inspect
 
+import pytest
+
 import numcodecs
 from numcodecs.registry import get_codec
 
@@ -27,8 +27,8 @@ def test_all_classes_registered():
     see #346 for more info
     """
     missing = set()
-    for name, submod in inspect.getmembers(numcodecs, inspect.ismodule):
-        for name, obj in inspect.getmembers(submod):
+    for _name, submod in inspect.getmembers(numcodecs, inspect.ismodule):
+        for _name, obj in inspect.getmembers(submod):
             if inspect.isclass(obj):
                 if issubclass(obj, numcodecs.abc.Codec):
                     if obj.codec_id not in numcodecs.registry.codec_registry:

numcodecs/tests/test_shuffle.py

@@ -1,29 +1,26 @@
 from multiprocessing import Pool
 from multiprocessing.pool import ThreadPool
 
-
 import numpy as np
 import pytest
 
-
 try:
     from numcodecs.shuffle import Shuffle
 except ImportError:  # pragma: no cover
-    pytest.skip(
-        "numcodecs.shuffle not available", allow_module_level=True
-    )
-
+    pytest.skip("numcodecs.shuffle not available", allow_module_level=True)
 
-from numcodecs.tests.common import (check_encode_decode,
-                                    check_config,
-                                    check_backwards_compatibility)
 
+from numcodecs.tests.common import (
+    check_backwards_compatibility,
+    check_config,
+    check_encode_decode,
+)
 
 codecs = [
     Shuffle(),
     Shuffle(elementsize=0),
     Shuffle(elementsize=4),
-    Shuffle(elementsize=8)
+    Shuffle(elementsize=8),
 ]
 
 
@@ -40,10 +37,10 @@ arrays = [
     np.random.randint(0, 2**60, size=1000, dtype='u8').view('m8[ns]'),
     np.random.randint(0, 2**25, size=1000, dtype='u8').view('M8[m]'),
     np.random.randint(0, 2**25, size=1000, dtype='u8').view('m8[m]'),
-    np.random.randint(-2**63, -2**63 + 20, size=1000, dtype='i8').view('M8[ns]'),
-    np.random.randint(-2**63, -2**63 + 20, size=1000, dtype='i8').view('m8[ns]'),
-    np.random.randint(-2**63, -2**63 + 20, size=1000, dtype='i8').view('M8[m]'),
-    np.random.randint(-2**63, -2**63 + 20, size=1000, dtype='i8').view('m8[m]'),
+    np.random.randint(-(2**63), -(2**63) + 20, size=1000, dtype='i8').view('M8[ns]'),
+    np.random.randint(-(2**63), -(2**63) + 20, size=1000, dtype='i8').view('m8[ns]'),
+    np.random.randint(-(2**63), -(2**63) + 20, size=1000, dtype='i8').view('M8[m]'),
+    np.random.randint(-(2**63), -(2**63) + 20, size=1000, dtype='i8').view('m8[m]'),
 ]
 
 
@@ -132,22 +129,33 @@ def test_backwards_compatibility():
 #         with pytest.raises(RuntimeError):
 #             codec.decode(bytearray(0))
 
+
 def test_expected_result():
     # If the input is treated as a 2D byte array, with shape (size of element, number of elements),
     # the shuffle is essentially a transpose. This can be made more apparent by using an array of
     # big-endian integers, as below.
-    arr = np.array([0x0001020304050607, 0x08090a0b0c0d0e0f, 0x1011121314151617, 0x18191a1b1c1d1e1f],
-                   dtype='>u8')
-    expected = np.array([
-        0x00081018,
-        0x01091119,
-        0x020a121a,
-        0x030b131b,
-        0x040c141c,
-        0x050d151d,
-        0x060e161e,
-        0x070f171f,
-    ], dtype='u4')
+    arr = np.array(
+        [
+            0x0001020304050607,
+            0x08090A0B0C0D0E0F,
+            0x1011121314151617,
+            0x18191A1B1C1D1E1F,
+        ],
+        dtype='>u8',
+    )
+    expected = np.array(
+        [
+            0x00081018,
+            0x01091119,
+            0x020A121A,
+            0x030B131B,
+            0x040C141C,
+            0x050D151D,
+            0x060E161E,
+            0x070F171F,
+        ],
+        dtype='u4',
+    )
     codec = Shuffle(elementsize=arr.data.itemsize)
     enc = codec.encode(arr)
     np.testing.assert_array_equal(np.frombuffer(enc.data, '>u4'), expected)

numcodecs/tests/test_vlen_array.py

@@ -5,21 +5,21 @@ import pytest
 
 try:
     from numcodecs.vlen import VLenArray
-except ImportError:  # pragma: no cover
-    raise unittest.SkipTest("vlen-array not available")
-from numcodecs.tests.common import (check_config, check_repr,
-                                    check_encode_decode_array,
-                                    check_backwards_compatibility,
-                                    assert_array_items_equal)
-
+except ImportError as e:  # pragma: no cover
+    raise unittest.SkipTest("vlen-array not available") from e
+from numcodecs.tests.common import (
+    assert_array_items_equal,
+    check_backwards_compatibility,
+    check_config,
+    check_encode_decode_array,
+    check_repr,
+)
 
 arrays = [
-    np.array([np.array([1, 2, 3]),
-              np.array([4]),
-              np.array([5, 6])] * 300, dtype=object),
-    np.array([np.array([1, 2, 3]),
-              np.array([4]),
-              np.array([5, 6])] * 300, dtype=object).reshape(90, 10),
+    np.array([np.array([1, 2, 3]), np.array([4]), np.array([5, 6])] * 300, dtype=object),
+    np.array([np.array([1, 2, 3]), np.array([4]), np.array([5, 6])] * 300, dtype=object).reshape(
+        90, 10
+    ),
 ]
 
 
@@ -93,7 +93,5 @@ def test_encode_none():
     codec = VLenArray(int)
     enc = codec.encode(a)
     dec = codec.decode(enc)
-    expect = np.array([np.array([1, 3]),
-                       np.array([]),
-                       np.array([4, 7])], dtype=object)
+    expect = np.array([np.array([1, 3]), np.array([]), np.array([4, 7])], dtype=object)
     assert_array_items_equal(expect, dec)

numcodecs/tests/test_vlen_bytes.py

@@ -5,12 +5,16 @@ import pytest
 
 try:
     from numcodecs.vlen import VLenBytes
-except ImportError:  # pragma: no cover
-    raise unittest.SkipTest("vlen-bytes not available")
-from numcodecs.tests.common import (check_config, check_repr, check_encode_decode_array,
-                                    check_backwards_compatibility, greetings,
-                                    assert_array_items_equal)
-
+except ImportError as e:  # pragma: no cover
+    raise unittest.SkipTest("vlen-bytes not available") from e
+from numcodecs.tests.common import (
+    assert_array_items_equal,
+    check_backwards_compatibility,
+    check_config,
+    check_encode_decode_array,
+    check_repr,
+    greetings,
+)
 
 greetings_bytes = [g.encode('utf-8') for g in greetings]
 
@@ -19,8 +23,9 @@ arrays = [
     np.array([b'foo', b'bar', b'baz'] * 300, dtype=object),
     np.array(greetings_bytes * 100, dtype=object),
     np.array([b'foo', b'bar', b'baz'] * 300, dtype=object).reshape(90, 10),
-    np.array(greetings_bytes * 1000, dtype=object).reshape(len(greetings_bytes), 100, 10,
-                                                           order='F'),
+    np.array(greetings_bytes * 1000, dtype=object).reshape(
+        len(greetings_bytes), 100, 10, order='F'
+    ),
 ]
 
 

numcodecs/tests/test_vlen_utf8.py

@@ -1,18 +1,20 @@
 import unittest
 
-
 import numpy as np
 import pytest
 
-
 try:
     from numcodecs.vlen import VLenUTF8
-except ImportError:  # pragma: no cover
-    raise unittest.SkipTest("vlen-utf8 not available")
-from numcodecs.tests.common import (check_config, check_repr, check_encode_decode_array,
-                                    check_backwards_compatibility, greetings,
-                                    assert_array_items_equal)
-
+except ImportError as e:  # pragma: no cover
+    raise unittest.SkipTest("vlen-utf8 not available") from e
+from numcodecs.tests.common import (
+    assert_array_items_equal,
+    check_backwards_compatibility,
+    check_config,
+    check_encode_decode_array,
+    check_repr,
+    greetings,
+)
 
 arrays = [
     np.array(['foo', 'bar', 'baz'] * 300, dtype=object),
@@ -77,8 +79,11 @@ def test_decode_errors():
         codec.decode(enc, out=np.zeros(10, dtype='i4'))
 
 
-def test_encode_utf8():
+@pytest.mark.parametrize("writable", [True, False])
+def test_encode_utf8(writable):
     a = np.array(['foo', None, 'bar'], dtype=object)
+    if not writable:
+        a.setflags(write=False)
     codec = VLenUTF8()
     enc = codec.encode(a)
     dec = codec.decode(enc)

numcodecs/tests/test_zfpy.py

@@ -1,8 +1,5 @@
-import pytest
-
-
 import numpy as np
-
+import pytest
 
 try:
     # noinspection PyProtectedMember
@@ -12,15 +9,14 @@ except ImportError:  # pragma: no cover
 
 
 from numcodecs.tests.common import (
-    check_encode_decode_array,
-    check_config,
-    check_repr,
     check_backwards_compatibility,
+    check_config,
+    check_encode_decode_array,
     check_err_decode_object_buffer,
     check_err_encode_object_buffer,
+    check_repr,
 )
 
-
 codecs = [
     ZFPY(mode=_zfpy.mode_fixed_rate, rate=-1),
     ZFPY(),
@@ -38,12 +34,8 @@ arrays = [
     np.random.normal(loc=1000, scale=1, size=(100, 10)),
     np.random.normal(loc=1000, scale=1, size=(10, 10, 10)),
     np.random.normal(loc=1000, scale=1, size=(2, 5, 10, 10)),
-    np.random.randint(-(2 ** 31), -(2 ** 31) + 20, size=1000, dtype="i4").reshape(
-        100, 10
-    ),
-    np.random.randint(-(2 ** 63), -(2 ** 63) + 20, size=1000, dtype="i8").reshape(
-        10, 10, 10
-    ),
+    np.random.randint(-(2**31), -(2**31) + 20, size=1000, dtype="i4").reshape(100, 10),
+    np.random.randint(-(2**63), -(2**63) + 20, size=1000, dtype="i8").reshape(10, 10, 10),
 ]
 
 
@@ -72,9 +64,7 @@ def test_backwards_compatibility():
             codec = [code]
             check_backwards_compatibility(ZFPY.codec_id, arrays, codec)
         else:
-            check_backwards_compatibility(
-                ZFPY.codec_id, arrays[: len(arrays) - 2], codecs
-            )
+            check_backwards_compatibility(ZFPY.codec_id, arrays[: len(arrays) - 2], codecs)
 
 
 def test_err_decode_object_buffer():

numcodecs/tests/test_zlib.py

@@ -1,16 +1,17 @@
 import itertools
 
-
 import numpy as np
 import pytest
 
-
+from numcodecs.tests.common import (
+    check_backwards_compatibility,
+    check_config,
+    check_encode_decode,
+    check_err_decode_object_buffer,
+    check_err_encode_object_buffer,
+    check_repr,
+)
 from numcodecs.zlib import Zlib
-from numcodecs.tests.common import (check_encode_decode, check_config, check_repr,
-                                    check_backwards_compatibility,
-                                    check_err_decode_object_buffer,
-                                    check_err_encode_object_buffer)
-
 
 codecs = [
     Zlib(),
@@ -35,10 +36,10 @@ arrays = [
     np.random.randint(0, 2**60, size=1000, dtype='u8').view('m8[ns]'),
     np.random.randint(0, 2**25, size=1000, dtype='u8').view('M8[m]'),
     np.random.randint(0, 2**25, size=1000, dtype='u8').view('m8[m]'),
-    np.random.randint(-2**63, -2**63 + 20, size=1000, dtype='i8').view('M8[ns]'),
-    np.random.randint(-2**63, -2**63 + 20, size=1000, dtype='i8').view('m8[ns]'),
-    np.random.randint(-2**63, -2**63 + 20, size=1000, dtype='i8').view('M8[m]'),
-    np.random.randint(-2**63, -2**63 + 20, size=1000, dtype='i8').view('m8[m]'),
+    np.random.randint(-(2**63), -(2**63) + 20, size=1000, dtype='i8').view('M8[ns]'),
+    np.random.randint(-(2**63), -(2**63) + 20, size=1000, dtype='i8').view('m8[ns]'),
+    np.random.randint(-(2**63), -(2**63) + 20, size=1000, dtype='i8').view('M8[m]'),
+    np.random.randint(-(2**63), -(2**63) + 20, size=1000, dtype='i8').view('m8[m]'),
 ]
 
 

numcodecs/tests/test_zstd.py

@@ -1,23 +1,22 @@
 import itertools
 
-
 import numpy as np
 import pytest
 
-
 try:
     from numcodecs.zstd import Zstd
 except ImportError:  # pragma: no cover
-    pytest.skip(
-        "numcodecs.zstd not available", allow_module_level=True
-    )
+    pytest.skip("numcodecs.zstd not available", allow_module_level=True)
 
 
-from numcodecs.tests.common import (check_encode_decode, check_config, check_repr,
-                                    check_backwards_compatibility,
-                                    check_err_decode_object_buffer,
-                                    check_err_encode_object_buffer)
-
+from numcodecs.tests.common import (
+    check_backwards_compatibility,
+    check_config,
+    check_encode_decode,
+    check_err_decode_object_buffer,
+    check_err_encode_object_buffer,
+    check_repr,
+)
 
 codecs = [
     Zstd(),
@@ -27,6 +26,9 @@ codecs = [
     Zstd(level=10),
     Zstd(level=22),
     Zstd(level=100),
+    Zstd(checksum=True),
+    Zstd(level=0, checksum=True),
+    Zstd(level=22, checksum=True),
 ]
 
 
@@ -34,8 +36,8 @@ codecs = [
 # mix of shapes: 1D, 2D, 3D
 # mix of orders: C, F
 arrays = [
-    np.arange(1000, dtype='i4'),
-    np.linspace(1000, 1001, 1000, dtype='f8'),
+    np.arange(1000, dtype="i4"),
+    np.linspace(1000, 1001, 1000, dtype="f8"),
     np.random.normal(loc=1000, scale=1, size=(100, 10)),
     np.random.randint(0, 2, size=1000, dtype=bool).reshape(100, 10, order='F'),
     np.random.choice([b'a', b'bb', b'ccc'], size=1000).reshape(10, 10, 10),
@@ -43,10 +45,10 @@ arrays = [
     np.random.randint(0, 2**60, size=1000, dtype='u8').view('m8[ns]'),
     np.random.randint(0, 2**25, size=1000, dtype='u8').view('M8[m]'),
     np.random.randint(0, 2**25, size=1000, dtype='u8').view('m8[m]'),
-    np.random.randint(-2**63, -2**63 + 20, size=1000, dtype='i8').view('M8[ns]'),
-    np.random.randint(-2**63, -2**63 + 20, size=1000, dtype='i8').view('m8[ns]'),
-    np.random.randint(-2**63, -2**63 + 20, size=1000, dtype='i8').view('M8[m]'),
-    np.random.randint(-2**63, -2**63 + 20, size=1000, dtype='i8').view('m8[m]'),
+    np.random.randint(-(2**63), -(2**63) + 20, size=1000, dtype='i8').view('M8[ns]'),
+    np.random.randint(-(2**63), -(2**63) + 20, size=1000, dtype='i8').view('m8[ns]'),
+    np.random.randint(-(2**63), -(2**63) + 20, size=1000, dtype='i8').view('M8[m]'),
+    np.random.randint(-(2**63), -(2**63) + 20, size=1000, dtype='i8').view('m8[m]'),
 ]
 
 
@@ -74,3 +76,17 @@ def test_err_decode_object_buffer():
 
 def test_err_encode_object_buffer():
     check_err_encode_object_buffer(Zstd())
+
+
+def test_checksum():
+    data = np.arange(0, 64, dtype="uint8")
+    assert len(Zstd(level=0, checksum=False).encode(data)) + 4 == len(
+        Zstd(level=0, checksum=True).encode(data)
+    )
+
+
+def test_native_functions():
+    # Note, these assertions might need to be changed for new versions of zstd
+    assert Zstd.default_level() == 3
+    assert Zstd.min_level() == -131072
+    assert Zstd.max_level() == 22