numcodecs 0.16.4__cp313-cp313-macosx_11_0_arm64.whl

numcodecs/tests/test_blosc.py

@@ -0,0 +1,290 @@
+from multiprocessing import Pool
+from multiprocessing.pool import ThreadPool
+
+import numpy as np
+import pytest
+
+try:
+    from numcodecs import blosc
+    from numcodecs.blosc import Blosc
+except ImportError:  # pragma: no cover
+    pytest.skip("numcodecs.blosc not available", allow_module_level=True)
+
+
+from numcodecs.tests.common import (
+    check_backwards_compatibility,
+    check_config,
+    check_encode_decode,
+    check_err_decode_object_buffer,
+    check_err_encode_object_buffer,
+    check_max_buffer_size,
+)
+
+codecs = [
+    Blosc(shuffle=Blosc.SHUFFLE),
+    Blosc(clevel=0, shuffle=Blosc.SHUFFLE),
+    Blosc(cname='lz4', shuffle=Blosc.SHUFFLE),
+    Blosc(cname='lz4', clevel=1, shuffle=Blosc.NOSHUFFLE),
+    Blosc(cname='lz4', clevel=5, shuffle=Blosc.SHUFFLE),
+    Blosc(cname='lz4', clevel=9, shuffle=Blosc.BITSHUFFLE),
+    Blosc(cname='zlib', clevel=1, shuffle=0),
+    Blosc(cname='zstd', clevel=1, shuffle=1),
+    Blosc(cname='blosclz', clevel=1, shuffle=2),
+    None,  # was snappy
+    Blosc(shuffle=Blosc.SHUFFLE, blocksize=0),
+    Blosc(shuffle=Blosc.SHUFFLE, blocksize=2**8),
+    Blosc(cname='lz4', clevel=1, shuffle=Blosc.NOSHUFFLE, blocksize=2**8),
+]
+
+
+# mix of dtypes: integer, float, bool, string
+# 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.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),
+    np.random.randint(0, 2**60, size=1000, dtype='u8').view('M8[ns]'),
+    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]'),
+]
+
+
+def _skip_null(codec):
+    if codec is None:
+        pytest.skip("codec has been removed")
+
+
+@pytest.fixture(scope='module', params=[True, False, None])
+def use_threads(request):
+    return request.param
+
+
+@pytest.mark.parametrize('array', arrays)
+@pytest.mark.parametrize('codec', codecs)
+def test_encode_decode(array, codec):
+    _skip_null(codec)
+    check_encode_decode(array, codec)
+
+
+def test_config():
+    codec = Blosc(cname='zstd', clevel=3, shuffle=1)
+    check_config(codec)
+    codec = Blosc(cname='lz4', clevel=1, shuffle=2, blocksize=2**8)
+    check_config(codec)
+
+
+def test_repr():
+    expect = "Blosc(cname='zstd', clevel=3, shuffle=SHUFFLE, blocksize=0)"
+    actual = repr(Blosc(cname='zstd', clevel=3, shuffle=Blosc.SHUFFLE, blocksize=0))
+    assert expect == actual
+    expect = "Blosc(cname='lz4', clevel=1, shuffle=NOSHUFFLE, blocksize=256)"
+    actual = repr(Blosc(cname='lz4', clevel=1, shuffle=Blosc.NOSHUFFLE, blocksize=256))
+    assert expect == actual
+    expect = "Blosc(cname='zlib', clevel=9, shuffle=BITSHUFFLE, blocksize=512)"
+    actual = repr(Blosc(cname='zlib', clevel=9, shuffle=Blosc.BITSHUFFLE, blocksize=512))
+    assert expect == actual
+    expect = "Blosc(cname='blosclz', clevel=5, shuffle=AUTOSHUFFLE, blocksize=1024)"
+    actual = repr(Blosc(cname='blosclz', clevel=5, shuffle=Blosc.AUTOSHUFFLE, blocksize=1024))
+    assert expect == actual
+
+
+def test_eq():
+    assert Blosc() == Blosc()
+    assert Blosc(cname='lz4') != Blosc(cname='zstd')
+    assert Blosc(clevel=1) != Blosc(clevel=9)
+    assert Blosc(cname='lz4') != 'foo'
+
+
+def test_compress_blocksize_default(use_threads):
+    arr = np.arange(1000, dtype='i4')
+
+    blosc.use_threads = use_threads
+
+    # default blocksize
+    enc = blosc.compress(arr, b'lz4', 1, Blosc.NOSHUFFLE)
+    _, _, blocksize = blosc._cbuffer_sizes(enc)
+    assert blocksize > 0
+
+    # explicit default blocksize
+    enc = blosc.compress(arr, b'lz4', 1, Blosc.NOSHUFFLE, 0)
+    _, _, blocksize = blosc._cbuffer_sizes(enc)
+    assert blocksize > 0
+
+
+@pytest.mark.parametrize('bs', [2**7, 2**8])
+def test_compress_blocksize(use_threads, bs):
+    arr = np.arange(1000, dtype='i4')
+
+    blosc.use_threads = use_threads
+
+    enc = blosc.compress(arr, b'lz4', 1, Blosc.NOSHUFFLE, bs)
+    _, _, blocksize = blosc._cbuffer_sizes(enc)
+    assert blocksize == bs
+
+
+def test_compress_complib(use_threads):
+    arr = np.arange(1000, dtype='i4')
+    expected_complibs = {
+        'lz4': 'LZ4',
+        'lz4hc': 'LZ4',
+        'blosclz': 'BloscLZ',
+        'zlib': 'Zlib',
+        'zstd': 'Zstd',
+    }
+    blosc.use_threads = use_threads
+    for cname in blosc.list_compressors():
+        enc = blosc.compress(arr, cname.encode(), 1, Blosc.NOSHUFFLE)
+        complib = blosc.cbuffer_complib(enc)
+        expected_complib = expected_complibs[cname]
+        assert complib == expected_complib
+    with pytest.raises(ValueError):
+        # capitalized cname
+        blosc.compress(arr, b'LZ4', 1)
+    with pytest.raises(ValueError):
+        # bad cname
+        blosc.compress(arr, b'foo', 1)
+
+
+@pytest.mark.parametrize('dtype', ['i1', 'i2', 'i4', 'i8'])
+def test_compress_metainfo(dtype, use_threads):
+    arr = np.arange(1000, dtype=dtype)
+    for shuffle in Blosc.NOSHUFFLE, Blosc.SHUFFLE, Blosc.BITSHUFFLE:
+        blosc.use_threads = use_threads
+        for cname in blosc.list_compressors():
+            enc = blosc.compress(arr, cname.encode(), 1, shuffle)
+            typesize, did_shuffle, _ = blosc._cbuffer_metainfo(enc)
+            assert typesize == arr.dtype.itemsize
+            assert did_shuffle == shuffle
+
+
+def test_compress_autoshuffle(use_threads):
+    arr = np.arange(8000)
+    for dtype in 'i1', 'i2', 'i4', 'i8', 'f2', 'f4', 'f8', 'bool', 'S10':
+        varr = arr.view(dtype)
+        blosc.use_threads = use_threads
+        for cname in blosc.list_compressors():
+            enc = blosc.compress(varr, cname.encode(), 1, Blosc.AUTOSHUFFLE)
+            typesize, did_shuffle, _ = blosc._cbuffer_metainfo(enc)
+            assert typesize == varr.dtype.itemsize
+            if typesize == 1:
+                assert did_shuffle == Blosc.BITSHUFFLE
+            else:
+                assert did_shuffle == Blosc.SHUFFLE
+
+
+def test_config_blocksize():
+    # N.B., we want to be backwards compatible with any config where blocksize is not
+    # explicitly stated
+
+    # blocksize not stated
+    config = {"cname": 'lz4', "clevel": 1, "shuffle": Blosc.SHUFFLE}
+    codec = Blosc.from_config(config)
+    assert codec.blocksize == 0
+
+    # blocksize stated
+    config = {"cname": 'lz4', "clevel": 1, "shuffle": Blosc.SHUFFLE, "blocksize": 2**8}
+    codec = Blosc.from_config(config)
+    assert codec.blocksize == 2**8
+
+
+def test_backwards_compatibility():
+    check_backwards_compatibility(Blosc.codec_id, arrays, codecs)
+
+
+def _encode_worker(data):
+    compressor = Blosc(cname='zlib', clevel=9, shuffle=Blosc.SHUFFLE)
+    return compressor.encode(data)
+
+
+def _decode_worker(enc):
+    compressor = Blosc()
+    return compressor.decode(enc)
+
+
+@pytest.mark.parametrize('pool', [Pool, ThreadPool])
+def test_multiprocessing(use_threads, pool):
+    data = np.arange(1000000)
+    enc = _encode_worker(data)
+
+    pool = pool(5)
+
+    try:
+        blosc.use_threads = use_threads
+
+        # test with process pool and thread pool
+
+        # test encoding
+        enc_results = pool.map(_encode_worker, [data] * 5)
+        assert all(len(enc) == len(e) for e in enc_results)
+
+        # test decoding
+        dec_results = pool.map(_decode_worker, [enc] * 5)
+        assert all(data.nbytes == len(d) for d in dec_results)
+
+        # tidy up
+        pool.close()
+        pool.join()
+
+    finally:
+        blosc.use_threads = None  # restore default
+
+
+def test_err_decode_object_buffer():
+    check_err_decode_object_buffer(Blosc())
+
+
+def test_err_encode_object_buffer():
+    check_err_encode_object_buffer(Blosc())
+
+
+@pytest.mark.parametrize('codec', codecs)
+def test_decompression_error_handling(codec):
+    _skip_null(codec)
+    with pytest.raises(RuntimeError):
+        codec.decode(bytearray())
+    with pytest.raises(RuntimeError):
+        codec.decode(bytearray(0))
+
+
+@pytest.mark.parametrize('codec', codecs)
+def test_max_buffer_size(codec):
+    _skip_null(codec)
+    assert codec.max_buffer_size == 2**31 - 1
+    check_max_buffer_size(codec)
+
+
+def test_typesize_explicit():
+    arr = np.arange(100).astype("int64")
+    itemsize = arr.itemsize
+    codec_no_type_size = Blosc(shuffle=Blosc.SHUFFLE)
+    codec_itemsize = Blosc(shuffle=Blosc.SHUFFLE, typesize=itemsize)
+    encoded_without_itemsize = codec_no_type_size.encode(arr.tobytes())
+    encoded_with_itemsize = codec_itemsize.encode(arr.tobytes())
+    # third byte encodes the `typesize`
+    assert encoded_without_itemsize[3] == 1  # inferred from bytes i.e., 1
+    assert encoded_with_itemsize[3] == itemsize  # given as a constructor argument
+
+
+def test_typesize_less_than_1():
+    with pytest.raises(ValueError, match=r"Cannot use typesize"):
+        Blosc(shuffle=Blosc.SHUFFLE, typesize=0)
+    compressor = Blosc(shuffle=Blosc.SHUFFLE)
+    # not really something that should be done in practice, but good for testing.
+    compressor._typesize = 0
+    arr = np.arange(100)
+    with pytest.raises(ValueError, match=r"Cannot use typesize"):
+        compressor.encode(arr.tobytes())
+
+
+def test_config_no_typesize():
+    codec = Blosc(shuffle=Blosc.SHUFFLE, typesize=5)
+    config = codec.get_config()
+    assert "typesize" not in config

numcodecs/tests/test_bz2.py

@@ -0,0 +1,66 @@
+import itertools
+
+import numpy as np
+
+from numcodecs.bz2 import BZ2
+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 = [
+    BZ2(),
+    BZ2(level=1),
+    BZ2(level=5),
+    BZ2(level=9),
+]
+
+
+# mix of dtypes: integer, float, bool, string
+# 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.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),
+    np.random.randint(0, 2**60, size=1000, dtype='u8').view('M8[ns]'),
+    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]'),
+]
+
+
+def test_encode_decode():
+    for arr, codec in itertools.product(arrays, codecs):
+        check_encode_decode(arr, codec)
+
+
+def test_config():
+    codec = BZ2(level=3)
+    check_config(codec)
+
+
+def test_repr():
+    check_repr("BZ2(level=3)")
+
+
+def test_backwards_compatibility():
+    check_backwards_compatibility(BZ2.codec_id, arrays, codecs)
+
+
+def test_err_decode_object_buffer():
+    check_err_decode_object_buffer(BZ2())
+
+
+def test_err_encode_object_buffer():
+    check_err_encode_object_buffer(BZ2())

numcodecs/tests/test_categorize.py

@@ -0,0 +1,87 @@
+import numpy as np
+import pytest
+from numpy.testing import assert_array_equal
+
+from numcodecs.categorize import Categorize
+from numcodecs.tests.common import (
+    check_backwards_compatibility,
+    check_config,
+    check_encode_decode,
+    check_encode_decode_array,
+)
+
+labels = ['ƒöõ', 'ßàř', 'ßāẑ', 'ƪùüx']
+arrays = [
+    np.random.choice(labels, size=1000),
+    np.random.choice(labels, size=(100, 10)),
+    np.random.choice(labels, size=(10, 10, 10)),
+    np.random.choice(labels, size=1000).reshape(100, 10, order='F'),
+]
+arrays_object = [a.astype(object) for a in arrays]
+
+
+def test_encode_decode():
+    # unicode dtype
+    for arr in arrays:
+        codec = Categorize(labels, dtype=arr.dtype)
+        check_encode_decode(arr, codec)
+
+    # object dtype
+    for arr in arrays_object:
+        codec = Categorize(labels, dtype=arr.dtype)
+        check_encode_decode_array(arr, codec)
+
+
+def test_encode():
+    for dtype in 'U', object:
+        arr = np.array(['ƒöõ', 'ßàř', 'ƒöõ', 'ßāẑ', 'ƪùüx'], dtype=dtype)
+        # miss off quux
+        codec = Categorize(labels=labels[:-1], dtype=arr.dtype, astype='u1')
+
+        # test encoding
+        expect = np.array([1, 2, 1, 3, 0], dtype='u1')
+        enc = codec.encode(arr)
+        assert_array_equal(expect, enc)
+        assert expect.dtype == enc.dtype
+
+        # test decoding with unexpected value
+        dec = codec.decode(enc)
+        expect = arr.copy()
+        expect[expect == 'ƪùüx'] = ''
+        assert_array_equal(expect, dec)
+        assert arr.dtype == dec.dtype
+
+
+def test_config():
+    codec = Categorize(labels=labels, dtype='U4')
+    check_config(codec)
+
+
+def test_repr():
+    dtype = '<U3'
+    astype = '|u1'
+    codec = Categorize(labels=['foo', 'bar', 'baz', 'qux'], dtype=dtype, astype=astype)
+    expect = "Categorize(dtype='<U3', astype='|u1', labels=['foo', 'bar', 'baz', ...])"
+    actual = repr(codec)
+    assert expect == actual
+
+    dtype = '<U4'
+    astype = '|u1'
+    codec = Categorize(labels=labels, dtype=dtype, astype=astype)
+    expect = "Categorize(dtype='<U4', astype='|u1', labels=['ƒöõ', 'ßàř', 'ßāẑ', ...])"
+    actual = repr(codec)
+    assert expect == actual
+
+
+def test_backwards_compatibility():
+    codec = Categorize(labels=labels, dtype='<U4', astype='u1')
+    check_backwards_compatibility(Categorize.codec_id, arrays, [codec], prefix='U')
+    codec = Categorize(labels=labels, dtype=object, astype='u1')
+    check_backwards_compatibility(Categorize.codec_id, arrays_object, [codec], prefix='O')
+
+
+def test_errors():
+    with pytest.raises(TypeError):
+        Categorize(labels=['foo', 'bar'], dtype='S6')
+    with pytest.raises(TypeError):
+        Categorize(labels=['foo', 'bar'], dtype='U6', astype=object)

numcodecs/tests/test_checksum32.py

@@ -0,0 +1,199 @@
+import itertools
+from contextlib import suppress
+
+import numpy as np
+import pytest
+
+from numcodecs.checksum32 import CRC32, Adler32
+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,
+)
+
+has_crc32c = False
+with suppress(ImportError):
+    from numcodecs.checksum32 import CRC32C
+
+    has_crc32c = True
+
+# mix of dtypes: integer, float, bool, string
+# 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.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),
+    np.random.randint(0, 2**60, size=1000, dtype='u8').view('M8[ns]'),
+    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]'),
+]
+
+base_codecs = [
+    CRC32(),
+    CRC32(location="end"),
+    Adler32(),
+    Adler32(location="end"),
+]
+
+
+def get_all_codecs():
+    codecs = base_codecs.copy()
+    if has_crc32c:
+        codecs.extend(
+            [
+                CRC32C(location="start"),
+                CRC32C(),
+            ]
+        )
+    return codecs
+
+
+@pytest.mark.parametrize(("codec", "arr"), itertools.product(get_all_codecs(), arrays))
+def test_encode_decode(codec, arr):
+    check_encode_decode(arr, codec)
+
+
+@pytest.mark.parametrize(("codec", "arr"), itertools.product(get_all_codecs(), arrays))
+def test_errors(codec, arr):
+    enc = codec.encode(arr)
+    with pytest.raises(RuntimeError):
+        codec.decode(enc[:-1])
+
+
+@pytest.mark.parametrize("codec", get_all_codecs())
+def test_config(codec):
+    check_config(codec)
+
+
+@pytest.mark.parametrize("codec", get_all_codecs())
+def test_err_input_too_small(codec):
+    buf = b'000'  # 3 bytes are too little for a 32-bit checksum
+    with pytest.raises(ValueError):
+        codec.decode(buf)
+
+
+@pytest.mark.parametrize("codec", get_all_codecs())
+def test_err_encode_non_contiguous(codec):
+    # non-contiguous memory
+    arr = np.arange(1000, dtype='i4')[::2]
+    with pytest.raises(ValueError):
+        codec.encode(arr)
+
+
+@pytest.mark.parametrize("codec", get_all_codecs())
+def test_err_encode_list(codec):
+    data = ['foo', 'bar', 'baz']
+    with pytest.raises(TypeError):
+        codec.encode(data)
+
+
+def test_err_location():
+    with pytest.raises(ValueError):
+        CRC32(location="foo")
+    with pytest.raises(ValueError):
+        Adler32(location="foo")
+    if not has_crc32c:
+        pytest.skip("Needs `crc32c` installed")
+    with pytest.raises(ValueError):
+        CRC32C(location="foo")
+
+
+@pytest.mark.parametrize(
+    "repr_str",
+    [
+        "CRC32(location='start')",
+        "CRC32(location='end')",
+        "Adler32(location='start')",
+        "Adler32(location='end')",
+        pytest.param(
+            "CRC32C(location='start')",
+            marks=pytest.mark.skipif(not has_crc32c, reason="Needs `crc32c` installed"),
+        ),
+        pytest.param(
+            "CRC32C(location='end')",
+            marks=pytest.mark.skipif(not has_crc32c, reason="Needs `crc32c` installed"),
+        ),
+    ],
+)
+def test_repr(repr_str):
+    check_repr(repr_str)
+
+
+@pytest.mark.parametrize(
+    ('codec_id', 'codec_instance'),
+    [
+        (CRC32.codec_id, CRC32()),
+        (Adler32.codec_id, Adler32()),
+    ],
+)
+def test_backwards_compatibility(codec_id, codec_instance):
+    check_backwards_compatibility(codec_id, arrays, [codec_instance])
+
+
+@pytest.mark.skipif(not has_crc32c, reason="Needs `crc32c` installed")
+def test_backwards_compatibility_crc32c():
+    check_backwards_compatibility(CRC32C.codec_id, arrays, [CRC32C()])
+
+
+@pytest.mark.parametrize("codec", get_all_codecs())
+def test_err_encode_object_buffer(codec):
+    check_err_encode_object_buffer(codec)
+
+
+@pytest.mark.parametrize("codec", get_all_codecs())
+def test_err_decode_object_buffer(codec):
+    check_err_decode_object_buffer(codec)
+
+
+@pytest.mark.parametrize("codec", get_all_codecs())
+def test_err_out_too_small(codec):
+    arr = np.arange(10, dtype='i4')
+    out = np.empty_like(arr)[:-1]
+    with pytest.raises(ValueError):
+        codec.decode(codec.encode(arr), out)
+
+
+@pytest.mark.skipif(not has_crc32c, reason="Needs `crc32c` installed")
+def test_crc32c_checksum():
+    arr = np.arange(0, 64, dtype="uint8")
+    buf = CRC32C(location="end").encode(arr)
+    assert np.frombuffer(buf, dtype="<u4", offset=(len(buf) - 4))[0] == np.uint32(4218238699)
+
+
+@pytest.mark.skipif(not has_crc32c, reason="Needs `crc32c` installed")
+def test_crc32c_incremental():
+    """Test that CRC32C.checksum supports incremental calculation via value parameter."""
+    # Test incremental checksum calculation (for API compatibility)
+    data1 = np.frombuffer(b"hello", dtype='uint8')
+    data2 = np.frombuffer(b" world", dtype='uint8')
+    full_data = np.frombuffer(b"hello world", dtype='uint8')
+
+    # Calculate checksum in one go
+    checksum_full = CRC32C.checksum(full_data)
+
+    # Calculate incrementally using the value parameter
+    checksum_part1 = CRC32C.checksum(data1, 0)
+    checksum_part2 = CRC32C.checksum(data2, checksum_part1)
+
+    # Both methods should produce the same result
+    assert checksum_full == checksum_part2
+
+
+@pytest.mark.parametrize("codec", get_all_codecs())
+def test_err_checksum(codec):
+    arr = np.arange(0, 64, dtype="uint8")
+    buf = bytearray(codec.encode(arr))
+    buf[-1] = 0  # corrupt the checksum
+    with pytest.raises(RuntimeError):
+        codec.decode(buf)