siphashc 2.7__tar.gz → 2.8__tar.gz

{siphashc-2.7 → siphashc-2.8}/CHANGES.rst

@@ -1,6 +1,14 @@
 Changes
 =======
 
+2.8
+---
+
+* Added support for Python 3.15, including free-threaded builds.
+* Fixed SipHash input decoding on platforms with different alignment or byte
+  order.
+* Improved hashing performance and enabled concurrent hashing of large inputs.
+
 2.7
 ---
 

{siphashc-2.7/siphashc.egg-info → siphashc-2.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: siphashc
-Version: 2.7
+Version: 2.8
 Summary: Python module (in c) for siphash-2-4
 Author-email: Michal Čihař <michal@weblate.org>
 License-Expression: ISC
@@ -20,6 +20,7 @@ Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Classifier: Programming Language :: Python :: 3.14
+Classifier: Programming Language :: Python :: 3.15
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Requires-Python: >=3.10
 Description-Content-Type: text/x-rst

{siphashc-2.7 → siphashc-2.8}/pyproject.toml

@@ -11,10 +11,10 @@ lint = [
   {include-group = "pre-commit"}
 ]
 pre-commit = [
-  "pre-commit==4.3.0"
+  "prek==0.4.11"
 ]
 test = [
-  "pytest==8.4.2"
+  "pytest==9.1.1"
 ]
 
 [project]
@@ -29,6 +29,7 @@ classifiers = [
   "Programming Language :: Python :: 3.12",
   "Programming Language :: Python :: 3.13",
   "Programming Language :: Python :: 3.14",
+  "Programming Language :: Python :: 3.15",
   "Topic :: Software Development :: Libraries :: Python Modules"
 ]
 description = "Python module (in c) for siphash-2-4"
@@ -37,7 +38,7 @@ license = "ISC"
 license-files = ["LICENSE.md"]
 name = "siphashc"
 requires-python = ">=3.10"
-version = "2.7"
+version = "2.8"
 
 [[project.authors]]
 email = "michal@weblate.org"
@@ -80,6 +81,7 @@ docstring-code-format = true
 
 [tool.ruff.lint]
 ignore = [
+  "CPY001",  # TODO: update copyright info
   "S101",  # CONFIG: using pytest
   "D203",  # CONFIG: incompatible with D211
   "D212"  # CONFIG: incompatible with D213
@@ -96,6 +98,20 @@ max-complexity = 16
 [tool.ruff.lint.per-file-ignores]
 "benchmark.py" = ["T201"]
 
+[tool.rumdl]
+disable = [
+  # We do not enforce heading
+  "first-line-heading",
+  # Avoid length limit checks
+  "line-length"
+]
+
+[tool.rumdl.per-file-ignores]
+"README.md" = [
+  # Allow HTML
+  "MD033"
+]
+
 [tool.setuptools]
 include-package-data = true
 zip-safe = true

{siphashc-2.7 → siphashc-2.8}/setup.py

@@ -5,13 +5,14 @@ import sysconfig
 
 from setuptools import Extension, setup
 
+free_threaded = bool(sysconfig.get_config_var("Py_GIL_DISABLED"))
 define_macros = [("Py_LIMITED_API", "0x030A0000")]
 bdist_options = {"py_limited_api": "cp310"}
 
-# Free-threaded Python is not compatible with ABI3, see
-# https://github.com/python/cpython/issues/111506
-if sysconfig.get_config_var("Py_GIL_DISABLED"):
-    define_macros = []
+# Build version-specific free-threaded wheels until setuptools supports ABI3T.
+# https://github.com/pypa/setuptools/issues/5205
+if free_threaded:
+    define_macros = [("Py_GIL_DISABLED", "1")]
     bdist_options = {}
 
 setup(
@@ -21,7 +22,7 @@ setup(
             sources=["siphashc.c", "siphash/siphash.c"],
             language="c",
             define_macros=define_macros,
-            py_limited_api=True,
+            py_limited_api=not free_threaded,
         ),
     ],
     options={"bdist_wheel": bdist_options},

siphashc-2.8/siphash/README.md

@@ -0,0 +1 @@
+siphash from <https://github.com/floodyberry/siphash>

{siphashc-2.7 → siphashc-2.8}/siphash/siphash.c

@@ -4,7 +4,14 @@
 
 INLINE static uint64_t
 U8TO64_LE(const unsigned char *p) {
-    return *(const uint64_t *)p;
+    return ((uint64_t)p[0])
+        | ((uint64_t)p[1] << 8)
+        | ((uint64_t)p[2] << 16)
+        | ((uint64_t)p[3] << 24)
+        | ((uint64_t)p[4] << 32)
+        | ((uint64_t)p[5] << 40)
+        | ((uint64_t)p[6] << 48)
+        | ((uint64_t)p[7] << 56);
 }
 
 uint64_t

siphashc-2.8/siphashc.c

@@ -0,0 +1,191 @@
+/*
+ * Copyright (c) 2013 Eli Janssen
+ * Copyright (c) 2014 Carlo Pires
+ * Copyright © 2017–2023 Michal Čihař
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+**/
+
+#define PY_SSIZE_T_CLEAN
+
+#include <Python.h>
+#include <stdlib.h>
+#include <string.h>
+#include "siphash/siphash.h"
+
+#define SIPHASH_GIL_THRESHOLD 8192
+#if PY_VERSION_HEX < 0x030B0000
+#define SIPHASHC_PYC_FUNCTION_CAST(func) \
+    ((PyCFunction)(void (*)(void))(func))
+#else
+#define SIPHASHC_PYC_FUNCTION_CAST(func) _PyCFunction_CAST(func)
+#endif
+
+static int get_immutable_data(
+        PyObject *object,
+        const char *argument_name,
+        const char **data,
+        Py_ssize_t *size) {
+    if (PyBytes_Check(object)) {
+        char *bytes_data;
+
+        if (PyBytes_AsStringAndSize(object, &bytes_data, size) < 0) {
+            return 0;
+        }
+        *data = bytes_data;
+        return 1;
+    }
+
+    if (PyUnicode_Check(object)) {
+        *data = PyUnicode_AsUTF8AndSize(object, size);
+        return *data != NULL;
+    }
+
+    PyErr_Format(
+        PyExc_TypeError,
+        "%s must be str or bytes",
+        argument_name);
+    return 0;
+}
+
+static PyObject *pysiphash(
+        PyObject *self,
+        PyObject *const *args,
+        Py_ssize_t nargs) {
+    PyObject *key_object;
+    PyObject *plaintext_object;
+    const char *key = NULL;
+    Py_ssize_t key_sz;
+    const char *plaintext = NULL;
+    Py_ssize_t plain_sz;
+    uint64_t hash;
+
+    if (nargs != 2) {
+        PyErr_Format(
+            PyExc_TypeError,
+            "siphash() takes exactly 2 arguments (%zd given)",
+            nargs);
+        return NULL;
+    }
+    key_object = args[0];
+    plaintext_object = args[1];
+
+    /* Both objects own immutable storage and remain alive for the call. */
+    if (!get_immutable_data(key_object, "key", &key, &key_sz) ||
+            !get_immutable_data(
+                plaintext_object,
+                "plaintext",
+                &plaintext,
+                &plain_sz)) {
+        return NULL;
+    }
+
+    if (key_sz != 16) {
+        PyErr_SetString(
+            PyExc_ValueError,
+            "key must be exactly 128 bits long (16 chars)");
+        return NULL;
+    }
+
+#ifdef Py_GIL_DISABLED
+    hash = siphash(
+        (const unsigned char *)key,
+        (const unsigned char *)plaintext,
+        plain_sz);
+#else
+    if (plain_sz >= SIPHASH_GIL_THRESHOLD) {
+        Py_BEGIN_ALLOW_THREADS
+        hash = siphash(
+            (const unsigned char *)key,
+            (const unsigned char *)plaintext,
+            plain_sz);
+        Py_END_ALLOW_THREADS
+    } else {
+        hash = siphash(
+            (const unsigned char *)key,
+            (const unsigned char *)plaintext,
+            plain_sz);
+    }
+#endif
+
+    return PyLong_FromUnsignedLongLong(hash);
+}
+
+static char siphash_docstring[] = ""
+    "Computes Siphash-2-4 of the given string and key\n\n"
+    "siphash(key, plaintext) -> hash\n"
+    " - key: must be 128 bit long (16 chars at 8 bit each)\n"
+    " - plaintext: text\n"
+    "returns 64-bit output (python Long)\n";
+
+static PyMethodDef siphashc_methods[] = {
+    {"siphash", SIPHASHC_PYC_FUNCTION_CAST(pysiphash), METH_FASTCALL,
+     siphash_docstring},
+    {NULL, NULL, 0, NULL} /* sentinel */
+};
+
+#ifdef Py_TARGET_ABI3T
+
+PyABIInfo_VAR(abi_info);
+
+static PySlot siphashc_slots[] = {
+    PySlot_STATIC_DATA(Py_mod_abi, &abi_info),
+    PySlot_STATIC_DATA(Py_mod_name, "siphashc"),
+    PySlot_STATIC_DATA(Py_mod_methods, siphashc_methods),
+    PySlot_STATIC_DATA(Py_mod_gil, Py_MOD_GIL_NOT_USED),
+    PySlot_END,
+};
+
+PyMODEXPORT_FUNC
+PyModExport_siphashc(void)
+{
+    return siphashc_slots;
+}
+
+#else
+
+static struct PyModuleDef moduledef = {
+    PyModuleDef_HEAD_INIT,
+    "siphashc",
+    NULL,
+    -1,
+    siphashc_methods,
+    NULL,
+    NULL,
+    NULL,
+    NULL
+};
+
+PyObject *
+PyInit_siphashc(void)
+{
+    PyObject *module = PyModule_Create(&moduledef);
+
+#ifdef Py_GIL_DISABLED
+    if (module != NULL &&
+            PyUnstable_Module_SetGIL(module, Py_MOD_GIL_NOT_USED) < 0) {
+        Py_DECREF(module);
+        return NULL;
+    }
+#endif
+
+    return module;
+}
+
+#endif

{siphashc-2.7 → siphashc-2.8/siphashc.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: siphashc
-Version: 2.7
+Version: 2.8
 Summary: Python module (in c) for siphash-2-4
 Author-email: Michal Čihař <michal@weblate.org>
 License-Expression: ISC
@@ -20,6 +20,7 @@ Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Classifier: Programming Language :: Python :: 3.14
+Classifier: Programming Language :: Python :: 3.15
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Requires-Python: >=3.10
 Description-Content-Type: text/x-rst

siphashc-2.8/test_siphashc.py

@@ -0,0 +1,236 @@
+"""Test for siphashc module."""
+
+from __future__ import annotations
+
+import sys
+import sysconfig
+import threading
+import time
+import unittest
+
+import pytest
+
+from siphashc import siphash
+
+GIL_THRESHOLD = 8192
+GIL_TEST_ITERATIONS = 10_000
+
+
+class BytesSubclass(bytes):
+    """Bytes subclass used to verify accepted immutable inputs."""
+
+
+class StringSubclass(str):
+    """String subclass used to verify accepted immutable inputs."""
+
+    __slots__ = ()
+
+
+class TestSiphashC(unittest.TestCase):
+    """Test for siphashc module."""
+
+    @pytest.mark.skipif(
+        not sysconfig.get_config_var("Py_GIL_DISABLED"),
+        reason="requires free-threaded Python",
+    )
+    def test_gil_disabled(self: TestSiphashC) -> None:
+        """Test that importing the module does not enable the GIL."""
+        assert not sys._is_gil_enabled()  # noqa: SLF001
+
+    def test_hash(self: TestSiphashC) -> None:
+        """Test simple hashing."""
+        result = siphash("sixteencharstrng", "i need a hash of this")
+        assert result == 10796923698683394048  # noqa: PLR2004
+
+        result = siphash("0123456789ABCDEF", "a")
+        assert result == 12398370950267227270  # noqa: PLR2004
+
+    def test_immutable_inputs(self: TestSiphashC) -> None:
+        """Test accepted immutable input types."""
+        expected = siphash(b"0123456789ABCDEF", b"a")
+
+        assert siphash("0123456789ABCDEF", "a") == expected
+        assert (
+            siphash(
+                BytesSubclass(b"0123456789ABCDEF"),
+                BytesSubclass(b"a"),
+            )
+            == expected
+        )
+        assert (
+            siphash(
+                StringSubclass("0123456789ABCDEF"),
+                StringSubclass("a"),
+            )
+            == expected
+        )
+
+    def test_rejects_other_inputs(self: TestSiphashC) -> None:
+        """Test rejection of mutable and generic buffer inputs."""
+        invalid_keys = (
+            bytearray(b"0123456789ABCDEF"),
+            memoryview(b"0123456789ABCDEF"),
+            object(),
+        )
+        invalid_plaintexts = (bytearray(b"a"), memoryview(b"a"), object())
+
+        for key in invalid_keys:
+            with pytest.raises(TypeError, match="key must be str or bytes"):
+                siphash(key, b"a")
+
+        for plaintext in invalid_plaintexts:
+            with pytest.raises(TypeError, match="plaintext must be str or bytes"):
+                siphash(b"0123456789ABCDEF", plaintext)
+
+    def test_argument_count(self: TestSiphashC) -> None:
+        """Test positional argument count errors."""
+        for args in ((), (b"key",), (b"key", b"plaintext", b"extra")):
+            with pytest.raises(TypeError) as error:
+                siphash(*args)
+            assert str(error.value) == (
+                f"siphash() takes exactly 2 arguments ({len(args)} given)"
+            )
+
+    def test_rejects_keywords(self: TestSiphashC) -> None:
+        """Test rejection of keyword arguments."""
+        with pytest.raises(
+            TypeError,
+            match=r"siphash\(\) takes no keyword arguments",
+        ):
+            siphash(key=b"0123456789ABCDEF", plaintext=b"a")
+
+    @pytest.mark.skipif(
+        bool(sysconfig.get_config_var("Py_GIL_DISABLED")),
+        reason="requires a GIL-enabled Python",
+    )
+    def test_gil_release_threshold(self: TestSiphashC) -> None:
+        """Test that only inputs at or above the threshold release the GIL."""
+        counter = 0
+        ready = threading.Event()
+        stop = threading.Event()
+
+        def count_in_thread() -> None:
+            nonlocal counter
+            ready.set()
+            while not stop.is_set():
+                counter += 1
+                time.sleep(0)
+
+        thread = threading.Thread(target=count_in_thread)
+        previous_interval = sys.getswitchinterval()
+        sys.setswitchinterval(1.0)
+        try:
+            thread.start()
+            assert ready.wait(timeout=5)
+
+            key = b"0123456789ABCDEF"
+            below_threshold = b"a" * (GIL_THRESHOLD - 1)
+            at_threshold = b"a" * GIL_THRESHOLD
+
+            before = counter
+            for _ in range(GIL_TEST_ITERATIONS):
+                siphash(key, below_threshold)
+            assert counter == before
+
+            before = counter
+            for _ in range(GIL_TEST_ITERATIONS):
+                siphash(key, at_threshold)
+            assert counter > before
+        finally:
+            stop.set()
+            sys.setswitchinterval(previous_interval)
+            thread.join(timeout=5)
+
+        assert not thread.is_alive()
+
+    def test_errors(self: TestSiphashC) -> None:
+        """Test error handling."""
+        with pytest.raises(
+            ValueError,
+            match=r"key must be exactly 128 bits long \(16 chars\)",
+        ):
+            siphash("not long enough", "a")
+        with pytest.raises(
+            ValueError,
+            match=r"key must be exactly 128 bits long \(16 chars\)",
+        ):
+            siphash("toooooooooooooooooooooooo long", "a")
+        with pytest.raises(
+            ValueError,
+            match=r"key must be exactly 128 bits long \(16 chars\)",
+        ):
+            siphash("", "a")
+
+    def test_reference_vectors(self: TestSiphashC) -> None:
+        """Test reference vectors."""
+        vectors = [
+            0x726FDB47DD0E0E31,
+            0x74F839C593DC67FD,
+            0x0D6C8009D9A94F5A,
+            0x85676696D7FB7E2D,
+            0xCF2794E0277187B7,
+            0x18765564CD99A68D,
+            0xCBC9466E58FEE3CE,
+            0xAB0200F58B01D137,
+            0x93F5F5799A932462,
+            0x9E0082DF0BA9E4B0,
+            0x7A5DBBC594DDB9F3,
+            0xF4B32F46226BADA7,
+            0x751E8FBC860EE5FB,
+            0x14EA5627C0843D90,
+            0xF723CA908E7AF2EE,
+            0xA129CA6149BE45E5,
+            0x3F2ACC7F57C29BDB,
+            0x699AE9F52CBE4794,
+            0x4BC1B3F0968DD39C,
+            0xBB6DC91DA77961BD,
+            0xBED65CF21AA2EE98,
+            0xD0F2CBB02E3B67C7,
+            0x93536795E3A33E88,
+            0xA80C038CCD5CCEC8,
+            0xB8AD50C6F649AF94,
+            0xBCE192DE8A85B8EA,
+            0x17D835B85BBB15F3,
+            0x2F2E6163076BCFAD,
+            0xDE4DAAACA71DC9A5,
+            0xA6A2506687956571,
+            0xAD87A3535C49EF28,
+            0x32D892FAD841C342,
+            0x7127512F72F27CCE,
+            0xA7F32346F95978E3,
+            0x12E0B01ABB051238,
+            0x15E034D40FA197AE,
+            0x314DFFBE0815A3B4,
+            0x027990F029623981,
+            0xCADCD4E59EF40C4D,
+            0x9ABFD8766A33735C,
+            0x0E3EA96B5304A7D0,
+            0xAD0C42D6FC585992,
+            0x187306C89BC215A9,
+            0xD4A60ABCF3792B95,
+            0xF935451DE4F21DF2,
+            0xA9538F0419755787,
+            0xDB9ACDDFF56CA510,
+            0xD06C98CD5C0975EB,
+            0xE612A3CB9ECBA951,
+            0xC766E62CFCADAF96,
+            0xEE64435A9752FE72,
+            0xA192D576B245165A,
+            0x0A8787BF8ECB74B2,
+            0x81B3E73D20B49B6F,
+            0x7FA8220BA3B2ECEA,
+            0x245731C13CA42499,
+            0xB78DBFAF3A8D83BD,
+            0xEA1AD565322A1A0B,
+            0x60E61C23A3795013,
+            0x6606D7E446282B93,
+            0x6CA4ECB15C5F91E1,
+            0x9F626DA15C9625F3,
+            0xE51B38608EF25F57,
+            0x958A324CEB064572,
+        ]
+        k = bytes(range(16))
+        message = b""
+        for i in range(64):
+            assert siphash(k, message) == vectors[i]
+            message += bytes((i,))

siphashc-2.7/siphash/README.md

@@ -1 +0,0 @@
-siphash from https://github.com/floodyberry/siphash

siphashc-2.7/siphashc.c

@@ -1,88 +0,0 @@
-/*
- * Copyright (c) 2013 Eli Janssen
- * Copyright (c) 2014 Carlo Pires
- * Copyright © 2017–2023 Michal Čihař
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in
- * all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
- * THE SOFTWARE.
-**/
-
-#define PY_SSIZE_T_CLEAN
-
-#include <stdlib.h>
-#include <string.h>
-#include <Python.h>
-#include "siphash/siphash.h"
-
-static PyObject *pysiphash(PyObject *self, PyObject *args) {
-    const char *key = NULL;
-    Py_ssize_t key_sz;
-    const char *plaintext = NULL;
-    Py_ssize_t plain_sz;
-    uint64_t hash;
-
-    if (!PyArg_ParseTuple(
-            args, "s#s#:siphash",
-            &key, &key_sz, &plaintext, &plain_sz)) {
-        return NULL;
-    }
-
-    if (key_sz != 16) {
-        PyErr_SetString(
-            PyExc_ValueError,
-            "key must be exactly 128 bits long (16 chars)");
-        return NULL;
-    }
-
-    hash = siphash(
-        (const unsigned char*)key,
-        (const unsigned char*)plaintext,
-        plain_sz);
-
-    return PyLong_FromUnsignedLongLong(hash);
-}
-
-static char siphash_docstring[] = ""
-    "Computes Siphash-2-4 of the given string and key\n\n"
-    "siphash(key, plaintext) -> hash\n"
-    " - key: must be 128 bit long (16 chars at 8 bit each)\n"
-    " - plaintext: text\n"
-    "returns 64-bit output (python Long)\n";
-
-static PyMethodDef siphashc_methods[] = {
-    {"siphash", pysiphash, METH_VARARGS, siphash_docstring},
-    {NULL, NULL, 0, NULL} /* sentinel */
-};
-
-static struct PyModuleDef moduledef = {
-    PyModuleDef_HEAD_INIT,
-    "siphashc",
-    NULL,
-    -1,
-    siphashc_methods,
-    NULL,
-    NULL,
-    NULL,
-    NULL
-};
-
-PyObject *
-PyInit_siphashc(void)
-{
-    return PyModule_Create(&moduledef);
-}

siphashc-2.7/test_siphashc.py

@@ -1,113 +0,0 @@
-"""Test for siphashc module."""
-
-from __future__ import annotations
-
-import unittest
-
-import pytest
-
-from siphashc import siphash
-
-
-class TestSiphashC(unittest.TestCase):
-    """Test for siphashc module."""
-
-    def test_hash(self: TestSiphashC) -> None:
-        """Test simple hashing."""
-        result = siphash("sixteencharstrng", "i need a hash of this")
-        assert result == 10796923698683394048  # noqa: PLR2004
-
-        result = siphash("0123456789ABCDEF", "a")
-        assert result == 12398370950267227270  # noqa: PLR2004
-
-    def test_errors(self: TestSiphashC) -> None:
-        """Test error handling."""
-        with pytest.raises(
-            ValueError,
-            match=r"key must be exactly 128 bits long \(16 chars\)",
-        ):
-            siphash("not long enough", "a")
-        with pytest.raises(
-            ValueError,
-            match=r"key must be exactly 128 bits long \(16 chars\)",
-        ):
-            siphash("toooooooooooooooooooooooo long", "a")
-        with pytest.raises(
-            ValueError,
-            match=r"key must be exactly 128 bits long \(16 chars\)",
-        ):
-            siphash("", "a")
-
-    def test_reference_vectors(self: TestSiphashC) -> None:
-        """Test reference vectors."""
-        vectors = [
-            0x726FDB47DD0E0E31,
-            0x74F839C593DC67FD,
-            0x0D6C8009D9A94F5A,
-            0x85676696D7FB7E2D,
-            0xCF2794E0277187B7,
-            0x18765564CD99A68D,
-            0xCBC9466E58FEE3CE,
-            0xAB0200F58B01D137,
-            0x93F5F5799A932462,
-            0x9E0082DF0BA9E4B0,
-            0x7A5DBBC594DDB9F3,
-            0xF4B32F46226BADA7,
-            0x751E8FBC860EE5FB,
-            0x14EA5627C0843D90,
-            0xF723CA908E7AF2EE,
-            0xA129CA6149BE45E5,
-            0x3F2ACC7F57C29BDB,
-            0x699AE9F52CBE4794,
-            0x4BC1B3F0968DD39C,
-            0xBB6DC91DA77961BD,
-            0xBED65CF21AA2EE98,
-            0xD0F2CBB02E3B67C7,
-            0x93536795E3A33E88,
-            0xA80C038CCD5CCEC8,
-            0xB8AD50C6F649AF94,
-            0xBCE192DE8A85B8EA,
-            0x17D835B85BBB15F3,
-            0x2F2E6163076BCFAD,
-            0xDE4DAAACA71DC9A5,
-            0xA6A2506687956571,
-            0xAD87A3535C49EF28,
-            0x32D892FAD841C342,
-            0x7127512F72F27CCE,
-            0xA7F32346F95978E3,
-            0x12E0B01ABB051238,
-            0x15E034D40FA197AE,
-            0x314DFFBE0815A3B4,
-            0x027990F029623981,
-            0xCADCD4E59EF40C4D,
-            0x9ABFD8766A33735C,
-            0x0E3EA96B5304A7D0,
-            0xAD0C42D6FC585992,
-            0x187306C89BC215A9,
-            0xD4A60ABCF3792B95,
-            0xF935451DE4F21DF2,
-            0xA9538F0419755787,
-            0xDB9ACDDFF56CA510,
-            0xD06C98CD5C0975EB,
-            0xE612A3CB9ECBA951,
-            0xC766E62CFCADAF96,
-            0xEE64435A9752FE72,
-            0xA192D576B245165A,
-            0x0A8787BF8ECB74B2,
-            0x81B3E73D20B49B6F,
-            0x7FA8220BA3B2ECEA,
-            0x245731C13CA42499,
-            0xB78DBFAF3A8D83BD,
-            0xEA1AD565322A1A0B,
-            0x60E61C23A3795013,
-            0x6606D7E446282B93,
-            0x6CA4ECB15C5F91E1,
-            0x9F626DA15C9625F3,
-            0xE51B38608EF25F57,
-            0x958A324CEB064572,
-        ]
-        k = "\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f"
-        message = ""
-        for i in range(64):
-            assert siphash(k, message) == vectors[i]
-            message += chr(i)