numcodecs 0.13.1__cp313-cp313-win_amd64.whl

numcodecs/tests/test_blosc.py

@@ -0,0 +1,277 @@
+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_encode_decode_partial,
+    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)
+
+
+@pytest.mark.parametrize('codec', codecs)
+@pytest.mark.parametrize(
+    'array',
+    [
+        pytest.param(x) if len(x.shape) == 1 else pytest.param(x, marks=[pytest.mark.xfail])
+        for x in arrays
+    ],
+)
+def test_partial_decode(codec, array):
+    _skip_null(codec)
+    check_encode_decode_partial(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 = dict(cname='lz4', clevel=1, shuffle=Blosc.SHUFFLE)
+    codec = Blosc.from_config(config)
+    assert codec.blocksize == 0
+
+    # blocksize stated
+    config = dict(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)
+    enc = compressor.encode(data)
+    return enc
+
+
+def _decode_worker(enc):
+    compressor = Blosc()
+    data = compressor.decode(enc)
+    return data
+
+
+@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())
+
+
+def test_decompression_error_handling():
+    for codec in codecs:
+        _skip_null(codec)
+        with pytest.raises(RuntimeError):
+            codec.decode(bytearray())
+        with pytest.raises(RuntimeError):
+            codec.decode(bytearray(0))
+
+
+def test_max_buffer_size():
+    for codec in codecs:
+        _skip_null(codec)
+        assert codec.max_buffer_size == 2**31 - 1
+        check_max_buffer_size(codec)

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,58 @@
+import itertools
+
+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_encode_object_buffer,
+    check_repr,
+)
+
+# 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),
+]
+
+codecs = [CRC32(), Adler32()]
+
+
+def test_encode_decode():
+    for codec, arr in itertools.product(codecs, arrays):
+        check_encode_decode(arr, codec)
+
+
+def test_errors():
+    for codec, arr in itertools.product(codecs, arrays):
+        enc = codec.encode(arr)
+        with pytest.raises(RuntimeError):
+            codec.decode(enc[:-1])
+
+
+def test_config():
+    for codec in codecs:
+        check_config(codec)
+
+
+def test_repr():
+    check_repr("CRC32()")
+    check_repr("Adler32()")
+
+
+def test_backwards_compatibility():
+    check_backwards_compatibility(CRC32.codec_id, arrays, [CRC32()])
+    check_backwards_compatibility(Adler32.codec_id, arrays, [Adler32()])
+
+
+def test_err_encode_object_buffer():
+    check_err_encode_object_buffer(CRC32())
+    check_err_encode_object_buffer(Adler32())

numcodecs/tests/test_compat.py

@@ -0,0 +1,108 @@
+import array
+import mmap
+
+import numpy as np
+import pytest
+
+from numcodecs.compat import ensure_bytes, ensure_contiguous_ndarray, ensure_text
+
+
+def test_ensure_text():
+    bufs = [
+        b'adsdasdas',
+        'adsdasdas',
+        np.asarray(memoryview(b'adsdasdas')),
+        array.array('B', b'qwertyuiqwertyui'),
+    ]
+    for buf in bufs:
+        b = ensure_text(buf)
+        assert isinstance(b, str)
+
+
+def test_ensure_bytes():
+    bufs = [
+        b'adsdasdas',
+        bytes(20),
+        np.arange(100),
+        array.array('l', b'qwertyuiqwertyui'),
+    ]
+    for buf in bufs:
+        b = ensure_bytes(buf)
+        assert isinstance(b, bytes)
+
+
+def test_ensure_contiguous_ndarray_shares_memory():
+    typed_bufs = [
+        ('u', 1, b'adsdasdas'),
+        ('u', 1, bytes(20)),
+        ('i', 8, np.arange(100, dtype=np.int64)),
+        ('f', 8, np.linspace(0, 1, 100, dtype=np.float64)),
+        ('i', 4, array.array('i', b'qwertyuiqwertyui')),
+        ('u', 4, array.array('I', b'qwertyuiqwertyui')),
+        ('f', 4, array.array('f', b'qwertyuiqwertyui')),
+        ('f', 8, array.array('d', b'qwertyuiqwertyui')),
+        ('i', 1, array.array('b', b'qwertyuiqwertyui')),
+        ('u', 1, array.array('B', b'qwertyuiqwertyui')),
+        ('u', 1, mmap.mmap(-1, 10)),
+    ]
+    for expected_kind, expected_itemsize, buf in typed_bufs:
+        a = ensure_contiguous_ndarray(buf)
+        assert isinstance(a, np.ndarray)
+        assert expected_kind == a.dtype.kind
+        if isinstance(buf, array.array):
+            assert buf.itemsize == a.dtype.itemsize
+        else:
+            assert expected_itemsize == a.dtype.itemsize
+        assert np.shares_memory(a, memoryview(buf))
+
+
+def test_ensure_bytes_invalid_inputs():
+    # object array not allowed
+    a = np.array(['Xin chào thế giới'], dtype=object)
+    for e in (a, memoryview(a)):
+        with pytest.raises(TypeError):
+            ensure_bytes(e)
+
+
+def test_ensure_contiguous_ndarray_invalid_inputs():
+    # object array not allowed
+    a = np.array(['Xin chào thế giới'], dtype=object)
+    for e in (a, memoryview(a)):
+        with pytest.raises(TypeError):
+            ensure_contiguous_ndarray(e)
+
+    # non-contiguous arrays not allowed
+    with pytest.raises(ValueError):
+        ensure_contiguous_ndarray(np.arange(100)[::2])
+
+    # unicode array.array not allowed
+    a = array.array('u', 'qwertyuiqwertyui')
+    with pytest.raises(TypeError):
+        ensure_contiguous_ndarray(a)
+
+
+def test_ensure_contiguous_ndarray_writeable():
+    # check that the writeability of the underlying buffer is preserved
+    for writeable in (False, True):
+        a = np.arange(100)
+        a.setflags(write=writeable)
+        m = ensure_contiguous_ndarray(a)
+        assert m.flags.writeable == writeable
+        m = ensure_contiguous_ndarray(memoryview(a))
+        assert m.flags.writeable == writeable
+
+
+def test_ensure_contiguous_ndarray_max_buffer_size():
+    for max_buffer_size in (4, 64, 1024):
+        ensure_contiguous_ndarray(np.zeros(max_buffer_size - 1, dtype=np.int8), max_buffer_size)
+        ensure_contiguous_ndarray(np.zeros(max_buffer_size, dtype=np.int8), max_buffer_size)
+        buffers = [
+            bytes(b"x" * (max_buffer_size + 1)),
+            np.zeros(max_buffer_size + 1, dtype=np.int8),
+            np.zeros(max_buffer_size + 2, dtype=np.int8),
+            np.zeros(max_buffer_size, dtype=np.int16),
+            np.zeros(max_buffer_size, dtype=np.int32),
+        ]
+        for buf in buffers:
+            with pytest.raises(ValueError):
+                ensure_contiguous_ndarray(buf, max_buffer_size=max_buffer_size)

numcodecs/tests/test_delta.py

@@ -0,0 +1,60 @@
+import numpy as np
+import pytest
+from numpy.testing import assert_array_equal
+
+from numcodecs.delta import Delta
+from numcodecs.tests.common import (
+    check_backwards_compatibility,
+    check_config,
+    check_encode_decode,
+    check_repr,
+)
+
+# mix of dtypes: integer, float
+# mix of shapes: 1D, 2D, 3D
+# mix of orders: C, F
+arrays = [
+    np.arange(1000, dtype='<i4'),
+    np.linspace(1000, 1001, 1000, dtype='<f4').reshape(100, 10),
+    np.random.normal(loc=1000, scale=1, size=(10, 10, 10)).astype('<f8'),
+    np.random.randint(0, 200, size=1000, dtype='u2').astype('<u2').reshape(100, 10, order='F'),
+]
+
+
+def test_encode_decode():
+    for arr in arrays:
+        codec = Delta(dtype=arr.dtype)
+        check_encode_decode(arr, codec)
+
+
+def test_encode():
+    dtype = 'i8'
+    astype = 'i4'
+    codec = Delta(dtype=dtype, astype=astype)
+    arr = np.arange(10, 20, 1, dtype=dtype)
+    expect = np.array([10] + ([1] * 9), dtype=astype)
+    actual = codec.encode(arr)
+    assert_array_equal(expect, actual)
+    assert np.dtype(astype) == actual.dtype
+
+
+def test_config():
+    codec = Delta(dtype='<i4', astype='<i2')
+    check_config(codec)
+
+
+def test_repr():
+    check_repr("Delta(dtype='<i4', astype='<i2')")
+
+
+def test_backwards_compatibility():
+    for arr in arrays:
+        codec = Delta(dtype=arr.dtype)
+        check_backwards_compatibility(Delta.codec_id, [arr], [codec], prefix=str(arr.dtype))
+
+
+def test_errors():
+    with pytest.raises(ValueError):
+        Delta(dtype=object)
+    with pytest.raises(ValueError):
+        Delta(dtype='i8', astype=object)

numcodecs/tests/test_entrypoints.py

@@ -0,0 +1,24 @@
+import os.path
+import sys
+
+import pytest
+
+import numcodecs.registry
+
+here = os.path.abspath(os.path.dirname(__file__))
+
+
+@pytest.fixture()
+def set_path():
+    sys.path.append(here)
+    numcodecs.registry.run_entrypoints()
+    yield
+    sys.path.remove(here)
+    numcodecs.registry.run_entrypoints()
+    numcodecs.registry.codec_registry.pop("test")
+
+
+@pytest.mark.usefixtures("set_path")
+def test_entrypoint_codec():
+    cls = numcodecs.registry.get_codec({"id": "test"})
+    assert cls.codec_id == "test"