numcodecs 0.16.0__cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl

numcodecs/tests/test_blosc.py

@@ -0,0 +1,284 @@
+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())
+
+
+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)
+
+
+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())

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,154 @@
+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]'),
+]
+
+codecs = [
+    CRC32(),
+    CRC32(location="end"),
+    Adler32(),
+    Adler32(location="end"),
+]
+if has_crc32c:
+    codecs.extend(
+        [
+            CRC32C(location="start"),
+            CRC32C(),
+        ]
+    )
+
+
+@pytest.mark.parametrize(("codec", "arr"), itertools.product(codecs, arrays))
+def test_encode_decode(codec, arr):
+    check_encode_decode(arr, codec)
+
+
+@pytest.mark.parametrize(("codec", "arr"), itertools.product(codecs, arrays))
+def test_errors(codec, arr):
+    enc = codec.encode(arr)
+    with pytest.raises(RuntimeError):
+        codec.decode(enc[:-1])
+
+
+@pytest.mark.parametrize("codec", codecs)
+def test_config(codec):
+    check_config(codec)
+
+
+@pytest.mark.parametrize("codec", 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", 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", 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 has_crc32c:
+        with pytest.raises(ValueError):
+            CRC32C(location="foo")
+
+
+def test_repr():
+    check_repr("CRC32(location='start')")
+    check_repr("CRC32(location='end')")
+    check_repr("Adler32(location='start')")
+    check_repr("Adler32(location='end')")
+    if has_crc32c:
+        check_repr("CRC32C(location='start')")
+        check_repr("CRC32C(location='end')")
+
+
+def test_backwards_compatibility():
+    check_backwards_compatibility(CRC32.codec_id, arrays, [CRC32()])
+    check_backwards_compatibility(Adler32.codec_id, arrays, [Adler32()])
+    if has_crc32c:
+        check_backwards_compatibility(CRC32C.codec_id, arrays, [CRC32C()])
+
+
+@pytest.mark.parametrize("codec", codecs)
+def test_err_encode_object_buffer(codec):
+    check_err_encode_object_buffer(codec)
+
+
+@pytest.mark.parametrize("codec", codecs)
+def test_err_decode_object_buffer(codec):
+    check_err_decode_object_buffer(codec)
+
+
+@pytest.mark.parametrize("codec", 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.parametrize("codec", 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)

numcodecs/tests/test_compat.py

@@ -0,0 +1,111 @@
+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)
+
+
+@pytest.mark.filterwarnings(
+    "ignore:The 'u' type code is deprecated and will be removed in Python 3.16"
+)
+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)