diff --git a/Lib/test/support/hashlib_helper.py b/Lib/test/support/hashlib_helper.py
index a4e6c92203ab50..477e0f110eabba 100644
--- a/Lib/test/support/hashlib_helper.py
+++ b/Lib/test/support/hashlib_helper.py
@@ -8,6 +8,10 @@
     _hashlib = None
 
 
+def requires_hashlib():
+    return unittest.skipIf(_hashlib is None, "requires _hashlib")
+
+
 def requires_hashdigest(digestname, openssl=None, usedforsecurity=True):
     """Decorator raising SkipTest if a hashing algorithm is not available
 
@@ -44,7 +48,7 @@ def wrapper(*args, **kwargs):
                     hashlib.new(digestname, usedforsecurity=usedforsecurity)
             except ValueError:
                 raise unittest.SkipTest(
-                    f"hash digest '{digestname}' is not available."
+                    f"hash digest {digestname!r} is not available."
                 )
             return func_or_class(*args, **kwargs)
         return wrapper
diff --git a/Lib/test/test_hmac.py b/Lib/test/test_hmac.py
index 1502fba9f3e8b8..982a5c53e0f324 100644
--- a/Lib/test/test_hmac.py
+++ b/Lib/test/test_hmac.py
@@ -2,138 +2,340 @@
 import functools
 import hmac
 import hashlib
+import random
+import test.support.hashlib_helper as hashlib_helper
 import unittest
 import unittest.mock
 import warnings
-
-from test.support import hashlib_helper, check_disallow_instantiation
-
 from _operator import _compare_digest as operator_compare_digest
+from test.support import check_disallow_instantiation
+from test.support.import_helper import import_fresh_module
 
 try:
-    import _hashlib as _hashopenssl
-    from _hashlib import HMAC as C_HMAC
-    from _hashlib import hmac_new as c_hmac_new
+    import _hashlib
     from _hashlib import compare_digest as openssl_compare_digest
 except ImportError:
-    _hashopenssl = None
-    C_HMAC = None
-    c_hmac_new = None
+    _hashlib = None
     openssl_compare_digest = None
 
 try:
-    import _sha256 as sha256_module
+    import _sha2 as sha2
 except ImportError:
-    sha256_module = None
+    sha2 = None
 
 
-def ignore_warning(func):
-    @functools.wraps(func)
-    def wrapper(*args, **kwargs):
-        with warnings.catch_warnings():
-            warnings.filterwarnings("ignore",
-                                    category=DeprecationWarning)
-            return func(*args, **kwargs)
-    return wrapper
+def requires_builtin_sha2():
+    return unittest.skipIf(sha2 is None, "requires _sha2")
 
 
-class TestVectorsTestCase(unittest.TestCase):
+class ModuleMixin:
+    """Mixin with a HMAC module implementation."""
 
-    def assert_hmac_internals(
-            self, h, digest, hashname, digest_size, block_size
-    ):
-        self.assertEqual(h.hexdigest().upper(), digest.upper())
-        self.assertEqual(h.digest(), binascii.unhexlify(digest))
+    hmac = None
+
+
+class PyModuleMixin(ModuleMixin):
+    """Pure Python implementation of HMAC.
+
+    The underlying hash functions may be OpenSSL-based or HACL* based,
+    depending on whether OpenSSL is present or not.
+    """
+
+    @classmethod
+    def setUpClass(cls):
+        super().setUpClass()
+        cls.hmac = import_fresh_module('hmac', blocked=['_hashlib', '_hmac'])
+
+
+@unittest.skip("no builtin implementation for HMAC for now")
+class BuiltinModuleMixin(ModuleMixin):
+    """Built-in HACL* implementation of HMAC."""
+
+    @classmethod
+    def setUpClass(cls):
+        super().setUpClass()
+        cls.hmac = import_fresh_module('_hmac')
+
+
+class CreatorMixin:
+    """Mixin exposing a method creating a HMAC object."""
+
+    def hmac_new(self, key, msg=None, digestmod=None):
+        """Create a new HMAC object."""
+        raise NotImplementedError
+
+    def bind_hmac_new(self, digestmod):
+        """Return a specialization of hmac_new() with a bound digestmod."""
+        return functools.partial(self.hmac_new, digestmod=digestmod)
+
+
+class DigestMixin:
+    """Mixin exposing a method computing a HMAC digest."""
+
+    def hmac_digest(self, key, msg=None, digestmod=None):
+        """Compute a HMAC digest."""
+        raise NotImplementedError
+
+    def bind_hmac_digest(self, digestmod):
+        """Return a specialization of hmac_digest() with a bound digestmod."""
+        return functools.partial(self.hmac_digest, digestmod=digestmod)
+
+
+class ThroughObjectMixin(ModuleMixin, CreatorMixin, DigestMixin):
+    """Mixin delegating to <module>.HMAC() and <module>.HMAC(...).digest().
+
+    Both the C implementation and the Python implementation of HMAC should
+    expose a HMAC class with the same functionalities.
+    """
+
+    def hmac_new(self, key, msg=None, digestmod=None):
+        """Create a HMAC object via a module-level class constructor."""
+        return self.hmac.HMAC(key, msg, digestmod=digestmod)
+
+    def hmac_digest(self, key, msg=None, digestmod=None):
+        """Call the digest() method on a HMAC object obtained by hmac_new()."""
+        return self.hmac_new(key, msg, digestmod).digest()
+
+
+class ThroughModuleAPIMixin(ModuleMixin, CreatorMixin, DigestMixin):
+    """Mixin delegating to <module>.new() and <module>.digest()."""
+
+    def hmac_new(self, key, msg=None, digestmod=None):
+        """Create a HMAC object via a module-level function."""
+        return self.hmac.new(key, msg, digestmod=digestmod)
+
+    def hmac_digest(self, key, msg=None, digestmod=None):
+        """One-shot HMAC digest computation."""
+        return self.hmac.digest(key, msg, digest=digestmod)
+
+
+@hashlib_helper.requires_hashlib()
+class ThroughOpenSSLAPIMixin(CreatorMixin, DigestMixin):
+    """Mixin delegating to _hashlib.hmac_new() and _hashlib.hmac_digest()."""
+
+    def hmac_new(self, key, msg=None, digestmod=None):
+        return _hashlib.hmac_new(key, msg, digestmod=digestmod)
+
+    def hmac_digest(self, key, msg=None, digestmod=None):
+        return _hashlib.hmac_digest(key, msg, digest=digestmod)
+
+
+class CheckerMixin:
+    """Mixin for checking HMAC objects (pure Python, OpenSSL or built-in)."""
+
+    def check_object(self, h, hexdigest, hashname, digest_size, block_size):
+        """Check a HMAC object 'h' against the given values."""
+        self.check_internals(h, hashname, digest_size, block_size)
+        self.check_hexdigest(h, hexdigest, digest_size)
+
+    def check_internals(self, h, hashname, digest_size, block_size):
+        """Check the constant attributes of a HMAC object."""
         self.assertEqual(h.name, f"hmac-{hashname}")
         self.assertEqual(h.digest_size, digest_size)
         self.assertEqual(h.block_size, block_size)
 
+    def check_hexdigest(self, h, hexdigest, digest_size):
+        """Check the HMAC digest of 'h' and its size."""
+        self.assertEqual(len(h.digest()), digest_size)
+        self.assertEqual(h.digest(), binascii.unhexlify(hexdigest))
+        self.assertEqual(h.hexdigest().upper(), hexdigest.upper())
+
+
+class TestVectorsMixin(CreatorMixin, DigestMixin, CheckerMixin):
+    """Mixin class for all test vectors test cases."""
+
+    def hmac_new_by_name(self, key, msg=None, hashname=None):
+        """Alternative implementation of hmac_new().
+
+        This is typically useful when one needs to test against an HMAC
+        implementation which only recognizes underlying hash functions
+        by their name (all HMAC implementations must at least recognize
+        hash functions by their names but some may use aliases such as
+        `hashlib.sha1` instead of "sha1").
+        """
+        self.assertIsInstance(hashname, str | None)
+        return self.hmac_new(key, msg, digestmod=hashname)
+
+    def hmac_digest_by_name(self, key, msg=None, hashname=None):
+        """Alternative implementation of hmac_digest()."""
+        self.assertIsInstance(hashname, str | None)
+        return self.hmac_digest(key, msg, digestmod=hashname)
+
     def assert_hmac(
-        self, key, data, digest, hashfunc, hashname, digest_size, block_size
+        self, key, msg, hexdigest, hashfunc, hashname, digest_size, block_size
     ):
-        h = hmac.HMAC(key, data, digestmod=hashfunc)
-        self.assert_hmac_internals(
-            h, digest, hashname, digest_size, block_size
+        """Check that HMAC(key, msg) == digest.
+
+        The 'hashfunc' and 'hashname' are used as 'digestmod' values,
+        thereby allowing to test the underlying dispatching mechanism.
+
+        Note that 'hashfunc' may be a string, a callable, or a PEP-257
+        module. Note that not all HMAC implementations may recognize the
+        same set of types for 'hashfunc', but they should always accept
+        a hash function by its name.
+        """
+        if hashfunc == hashname:
+            choices = [hashname]
+        else:
+            choices = [hashfunc, hashname]
+
+        for digestmod in choices:
+            with self.subTest(digestmod=digestmod):
+                self.assert_hmac_new(
+                    key, msg, hexdigest, digestmod,
+                    hashname, digest_size, block_size
+                )
+                self.assert_hmac_hexdigest(
+                    key, msg, hexdigest, digestmod, digest_size
+                )
+                self.assert_hmac_extra_cases(
+                    key, msg, hexdigest, digestmod,
+                    hashname, digest_size, block_size
+                )
+
+        self.assert_hmac_new_by_name(
+            key, msg, hexdigest, hashname, digest_size, block_size
         )
-
-        h = hmac.HMAC(key, data, digestmod=hashname)
-        self.assert_hmac_internals(
-            h, digest, hashname, digest_size, block_size
+        self.assert_hmac_hexdigest_by_new(
+            key, msg, hexdigest, hashname, digest_size
         )
 
-        h = hmac.HMAC(key, digestmod=hashname)
-        h2 = h.copy()
-        h2.update(b"test update")
-        h.update(data)
-        self.assertEqual(h.hexdigest().upper(), digest.upper())
+    def assert_hmac_new(
+        self, key, msg, hexdigest, digestmod, hashname, digest_size, block_size
+    ):
+        """Check that HMAC(key, msg) == digest.
+
+        This test uses the `hmac_new()` method to create HMAC objects.
+        """
+        self._check_hmac_new(
+            key, msg, hexdigest, hashname, digest_size, block_size,
+            hmac_new_func=self.hmac_new,
+            hmac_new_kwds={'digestmod': digestmod},
+        )
 
-        h = hmac.new(key, data, digestmod=hashname)
-        self.assert_hmac_internals(
-            h, digest, hashname, digest_size, block_size
+    def assert_hmac_new_by_name(
+        self, key, msg, hexdigest, hashname, digest_size, block_size
+    ):
+        """Check that HMAC(key, msg) == digest.
+
+        This test uses the `hmac_new_by_name()` method to create HMAC objects.
+        """
+        self._check_hmac_new(
+            key, msg, hexdigest, hashname, digest_size, block_size,
+            hmac_new_func=self.hmac_new_by_name,
+            hmac_new_kwds={'hashname': hashname},
         )
 
-        h = hmac.new(key, None, digestmod=hashname)
-        h.update(data)
-        self.assertEqual(h.hexdigest().upper(), digest.upper())
+    def _check_hmac_new(
+        self, key, msg, hexdigest, hashname, digest_size, block_size,
+        hmac_new_func, hmac_new_kwds,
+    ):
+        """Check that HMAC(key, msg) == digest.
+
+        This also tests that using an empty/None initial message and
+        then calling `h.update(msg)` produces the same result, namely
+        that HMAC(key, msg) is equivalent to HMAC(key).update(msg).
+        """
+        h = hmac_new_func(key, msg, **hmac_new_kwds)
+        self.check_object(h, hexdigest, hashname, digest_size, block_size)
+
+        def hmac_new_feed(*args):
+            h = hmac_new_func(key, *args, **hmac_new_kwds)
+            h.update(msg)
+            self.check_hexdigest(h, hexdigest, digest_size)
+
+        with self.subTest('no initial message'):
+            hmac_new_feed()
+        with self.subTest('initial message is empty'):
+            hmac_new_feed(b'')
+        with self.subTest('initial message is None'):
+            hmac_new_feed(None)
+
+    def assert_hmac_hexdigest(
+        self, key, msg, hexdigest, digestmod, digest_size,
+    ):
+        """Check a HMAC digest computed by hmac_digest()."""
+        d = self.hmac_digest(key, msg, digestmod=digestmod)
+        self.assertEqual(len(d), digest_size)
+        self.assertEqual(d, binascii.unhexlify(hexdigest))
+
+    def assert_hmac_hexdigest_by_new(
+        self, key, msg, hexdigest, hashname, digest_size
+    ):
+        """Check a HMAC digest computed by hmac_digest_by_name()."""
+        self.assertIsInstance(hashname, str | None)
+        d = self.hmac_digest_by_name(key, msg, hashname=hashname)
+        self.assertEqual(len(d), digest_size)
+        self.assertEqual(d, binascii.unhexlify(hexdigest))
+
+    def assert_hmac_extra_cases(
+        self, key, msg, hexdigest, digestmod, hashname, digest_size, block_size
+    ):
+        """Extra tests that can be added in subclasses."""
+        h1 = self.hmac_new_by_name(key, hashname=hashname)
+        h2 = h1.copy()
+        h2.update(b"test update should not affect original")
+        h1.update(msg)
+        self.check_object(h1, hexdigest, hashname, digest_size, block_size)
 
-        h = hmac.new(key, digestmod=hashname)
-        h.update(data)
-        self.assertEqual(h.hexdigest().upper(), digest.upper())
 
-        h = hmac.new(key, data, digestmod=hashfunc)
-        self.assertEqual(h.hexdigest().upper(), digest.upper())
+class PyTestVectorsMixin(PyModuleMixin, TestVectorsMixin):
 
-        self.assertEqual(
-            hmac.digest(key, data, digest=hashname),
-            binascii.unhexlify(digest)
-        )
-        self.assertEqual(
-            hmac.digest(key, data, digest=hashfunc),
-            binascii.unhexlify(digest)
+    def assert_hmac_extra_cases(
+        self, key, msg, hexdigest, digestmod, hashname, digest_size, block_size
+    ):
+        super().assert_hmac_extra_cases(
+            key, msg, hexdigest, digestmod, hashname, digest_size, block_size
         )
 
-        h = hmac.HMAC.__new__(hmac.HMAC)
-        h._init_old(key, data, digestmod=hashname)
-        self.assert_hmac_internals(
-            h, digest, hashname, digest_size, block_size
-        )
+        h = self.hmac.HMAC.__new__(self.hmac.HMAC)
+        h._init_old(key, msg, digestmod=digestmod)
+        self.check_object(h, hexdigest, hashname, digest_size, block_size)
 
-        if c_hmac_new is not None:
-            h = c_hmac_new(key, data, digestmod=hashname)
-            self.assert_hmac_internals(
-                h, digest, hashname, digest_size, block_size
-            )
 
-            h = c_hmac_new(key, digestmod=hashname)
-            h2 = h.copy()
-            h2.update(b"test update")
-            h.update(data)
-            self.assertEqual(h.hexdigest().upper(), digest.upper())
+class OpenSSLTestVectorsMixin(TestVectorsMixin):
 
-            func = getattr(_hashopenssl, f"openssl_{hashname}")
-            h = c_hmac_new(key, data, digestmod=func)
-            self.assert_hmac_internals(
-                h, digest, hashname, digest_size, block_size
-            )
+    def hmac_new(self, key, msg=None, digestmod=None):
+        return _hashlib.hmac_new(key, msg, digestmod=digestmod)
 
-            h = hmac.HMAC.__new__(hmac.HMAC)
-            h._init_hmac(key, data, digestmod=hashname)
-            self.assert_hmac_internals(
-                h, digest, hashname, digest_size, block_size
-            )
+    def hmac_digest(self, key, msg=None, digestmod=None):
+        return _hashlib.hmac_digest(key, msg, digest=digestmod)
 
-    @hashlib_helper.requires_hashdigest('md5', openssl=True)
-    def test_md5_vectors(self):
-        # Test the HMAC module against test vectors from the RFC.
+    def hmac_new_by_name(self, key, msg=None, hashname=None):
+        # ignore 'digestmod' and use the exact openssl function
+        openssl_func = getattr(_hashlib, f"openssl_{hashname}")
+        return self.hmac_new(key, msg, digestmod=openssl_func)
 
-        def md5test(key, data, digest):
-            self.assert_hmac(
-                key, data, digest,
-                hashfunc=hashlib.md5,
-                hashname="md5",
-                digest_size=16,
-                block_size=64
-            )
+    def hmac_digest_by_name(self, key, msg=None, hashname=None):
+        openssl_func = getattr(_hashlib, f"openssl_{hashname}")
+        return self.hmac_digest(key, msg, digestmod=openssl_func)
+
+
+class RFCTestCasesMixin(TestVectorsMixin):
+    """Test HMAC implementations against test vectors from the RFC.
+
+    Subclasses must override the 'md5' and other 'sha*' attributes
+    to test the implementations. Their value can be a string, a callable,
+    or a PEP-257 module.
+    """
+
+    ALGORITHMS = [
+        'md5', 'sha1',
+        'sha224', 'sha256', 'sha384', 'sha512',
+    ]
+
+    # Those will be automatically set to non-None on subclasses
+    # as they are set by __init_subclass()__.
+    md5 = sha1 = sha224 = sha256 = sha384 = sha512 = None
+
+    def __init_subclass__(cls, *args, **kwargs):
+        super().__init_subclass__(*args, **kwargs)
+        for name in cls.ALGORITHMS:
+            setattr(cls, name, name)
+
+    def test_md5(self):
+        def md5test(key, msg, hexdigest):
+            self.assert_hmac(key, msg, hexdigest, self.md5, "md5", 16, 64)
 
         md5test(b"\x0b" * 16,
                 b"Hi There",
@@ -164,16 +366,9 @@ def md5test(key, data, digest):
                  b"and Larger Than One Block-Size Data"),
                 "6f630fad67cda0ee1fb1f562db3aa53e")
 
-    @hashlib_helper.requires_hashdigest('sha1', openssl=True)
-    def test_sha_vectors(self):
-        def shatest(key, data, digest):
-            self.assert_hmac(
-                key, data, digest,
-                hashfunc=hashlib.sha1,
-                hashname="sha1",
-                digest_size=20,
-                block_size=64
-            )
+    def test_sha1(self):
+        def shatest(key, msg, hexdigest):
+            self.assert_hmac(key, msg, hexdigest, self.sha1, "sha1", 20, 64)
 
         shatest(b"\x0b" * 20,
                 b"Hi There",
@@ -204,141 +399,138 @@ def shatest(key, data, digest):
                  b"and Larger Than One Block-Size Data"),
                 "e8e99d0f45237d786d6bbaa7965c7808bbff1a91")
 
-    def _rfc4231_test_cases(self, hashfunc, hash_name, digest_size, block_size):
+    def test_sha2_224_rfc4231(self):
+        self._test_sha2_rfc4231(self.sha224, 'sha224', 28, 64)
+
+    def test_sha2_256_rfc4231(self):
+        self._test_sha2_rfc4231(self.sha256, 'sha256', 32, 64)
+
+    def test_sha2_384_rfc4231(self):
+        self._test_sha2_rfc4231(self.sha384, 'sha384', 48, 128)
+
+    def test_sha2_512_rfc4231(self):
+        self._test_sha2_rfc4231(self.sha512, 'sha512', 64, 128)
+
+    def _test_sha2_rfc4231(self, hashfunc, hashname, digest_size, block_size):
+
         def hmactest(key, data, hexdigests):
-            digest = hexdigests[hashfunc]
+            hexdigest = hexdigests[hashname]
 
             self.assert_hmac(
-                key, data, digest,
+                key, data, hexdigest,
                 hashfunc=hashfunc,
-                hashname=hash_name,
+                hashname=hashname,
                 digest_size=digest_size,
                 block_size=block_size
             )
 
         # 4.2.  Test Case 1
-        hmactest(key = b'\x0b'*20,
-                 data = b'Hi There',
-                 hexdigests = {
-                   hashlib.sha224: '896fb1128abbdf196832107cd49df33f'
-                                   '47b4b1169912ba4f53684b22',
-                   hashlib.sha256: 'b0344c61d8db38535ca8afceaf0bf12b'
-                                   '881dc200c9833da726e9376c2e32cff7',
-                   hashlib.sha384: 'afd03944d84895626b0825f4ab46907f'
-                                   '15f9dadbe4101ec682aa034c7cebc59c'
-                                   'faea9ea9076ede7f4af152e8b2fa9cb6',
-                   hashlib.sha512: '87aa7cdea5ef619d4ff0b4241a1d6cb0'
-                                   '2379f4e2ce4ec2787ad0b30545e17cde'
-                                   'daa833b7d6b8a702038b274eaea3f4e4'
-                                   'be9d914eeb61f1702e696c203a126854',
+        hmactest(key=b'\x0b' * 20,
+                 data=b'Hi There',
+                 hexdigests={
+                     'sha224': '896fb1128abbdf196832107cd49df33f'
+                               '47b4b1169912ba4f53684b22',
+                     'sha256': 'b0344c61d8db38535ca8afceaf0bf12b'
+                               '881dc200c9833da726e9376c2e32cff7',
+                     'sha384': 'afd03944d84895626b0825f4ab46907f'
+                               '15f9dadbe4101ec682aa034c7cebc59c'
+                               'faea9ea9076ede7f4af152e8b2fa9cb6',
+                     'sha512': '87aa7cdea5ef619d4ff0b4241a1d6cb0'
+                               '2379f4e2ce4ec2787ad0b30545e17cde'
+                               'daa833b7d6b8a702038b274eaea3f4e4'
+                               'be9d914eeb61f1702e696c203a126854',
                  })
 
         # 4.3.  Test Case 2
-        hmactest(key = b'Jefe',
-                 data = b'what do ya want for nothing?',
-                 hexdigests = {
-                   hashlib.sha224: 'a30e01098bc6dbbf45690f3a7e9e6d0f'
-                                   '8bbea2a39e6148008fd05e44',
-                   hashlib.sha256: '5bdcc146bf60754e6a042426089575c7'
-                                   '5a003f089d2739839dec58b964ec3843',
-                   hashlib.sha384: 'af45d2e376484031617f78d2b58a6b1b'
-                                   '9c7ef464f5a01b47e42ec3736322445e'
-                                   '8e2240ca5e69e2c78b3239ecfab21649',
-                   hashlib.sha512: '164b7a7bfcf819e2e395fbe73b56e0a3'
-                                   '87bd64222e831fd610270cd7ea250554'
-                                   '9758bf75c05a994a6d034f65f8f0e6fd'
-                                   'caeab1a34d4a6b4b636e070a38bce737',
+        hmactest(key=b'Jefe',
+                 data=b'what do ya want for nothing?',
+                 hexdigests={
+                     'sha224': 'a30e01098bc6dbbf45690f3a7e9e6d0f'
+                               '8bbea2a39e6148008fd05e44',
+                     'sha256': '5bdcc146bf60754e6a042426089575c7'
+                               '5a003f089d2739839dec58b964ec3843',
+                     'sha384': 'af45d2e376484031617f78d2b58a6b1b'
+                               '9c7ef464f5a01b47e42ec3736322445e'
+                               '8e2240ca5e69e2c78b3239ecfab21649',
+                     'sha512': '164b7a7bfcf819e2e395fbe73b56e0a3'
+                               '87bd64222e831fd610270cd7ea250554'
+                               '9758bf75c05a994a6d034f65f8f0e6fd'
+                               'caeab1a34d4a6b4b636e070a38bce737',
                  })
 
         # 4.4.  Test Case 3
-        hmactest(key = b'\xaa'*20,
-                 data = b'\xdd'*50,
-                 hexdigests = {
-                   hashlib.sha224: '7fb3cb3588c6c1f6ffa9694d7d6ad264'
-                                   '9365b0c1f65d69d1ec8333ea',
-                   hashlib.sha256: '773ea91e36800e46854db8ebd09181a7'
-                                   '2959098b3ef8c122d9635514ced565fe',
-                   hashlib.sha384: '88062608d3e6ad8a0aa2ace014c8a86f'
-                                   '0aa635d947ac9febe83ef4e55966144b'
-                                   '2a5ab39dc13814b94e3ab6e101a34f27',
-                   hashlib.sha512: 'fa73b0089d56a284efb0f0756c890be9'
-                                   'b1b5dbdd8ee81a3655f83e33b2279d39'
-                                   'bf3e848279a722c806b485a47e67c807'
-                                   'b946a337bee8942674278859e13292fb',
+        hmactest(key=b'\xaa' * 20,
+                 data=b'\xdd' * 50,
+                 hexdigests={
+                     'sha224': '7fb3cb3588c6c1f6ffa9694d7d6ad264'
+                               '9365b0c1f65d69d1ec8333ea',
+                     'sha256': '773ea91e36800e46854db8ebd09181a7'
+                               '2959098b3ef8c122d9635514ced565fe',
+                     'sha384': '88062608d3e6ad8a0aa2ace014c8a86f'
+                               '0aa635d947ac9febe83ef4e55966144b'
+                               '2a5ab39dc13814b94e3ab6e101a34f27',
+                     'sha512': 'fa73b0089d56a284efb0f0756c890be9'
+                               'b1b5dbdd8ee81a3655f83e33b2279d39'
+                               'bf3e848279a722c806b485a47e67c807'
+                               'b946a337bee8942674278859e13292fb',
                  })
 
         # 4.5.  Test Case 4
-        hmactest(key = bytes(x for x in range(0x01, 0x19+1)),
-                 data = b'\xcd'*50,
-                 hexdigests = {
-                   hashlib.sha224: '6c11506874013cac6a2abc1bb382627c'
-                                   'ec6a90d86efc012de7afec5a',
-                   hashlib.sha256: '82558a389a443c0ea4cc819899f2083a'
-                                   '85f0faa3e578f8077a2e3ff46729665b',
-                   hashlib.sha384: '3e8a69b7783c25851933ab6290af6ca7'
-                                   '7a9981480850009cc5577c6e1f573b4e'
-                                   '6801dd23c4a7d679ccf8a386c674cffb',
-                   hashlib.sha512: 'b0ba465637458c6990e5a8c5f61d4af7'
-                                   'e576d97ff94b872de76f8050361ee3db'
-                                   'a91ca5c11aa25eb4d679275cc5788063'
-                                   'a5f19741120c4f2de2adebeb10a298dd',
+        hmactest(key=bytes(x for x in range(0x01, 0x19 + 1)),
+                 data=b'\xcd' * 50,
+                 hexdigests={
+                     'sha224': '6c11506874013cac6a2abc1bb382627c'
+                               'ec6a90d86efc012de7afec5a',
+                     'sha256': '82558a389a443c0ea4cc819899f2083a'
+                               '85f0faa3e578f8077a2e3ff46729665b',
+                     'sha384': '3e8a69b7783c25851933ab6290af6ca7'
+                               '7a9981480850009cc5577c6e1f573b4e'
+                               '6801dd23c4a7d679ccf8a386c674cffb',
+                     'sha512': 'b0ba465637458c6990e5a8c5f61d4af7'
+                               'e576d97ff94b872de76f8050361ee3db'
+                               'a91ca5c11aa25eb4d679275cc5788063'
+                               'a5f19741120c4f2de2adebeb10a298dd',
                  })
 
         # 4.7.  Test Case 6
-        hmactest(key = b'\xaa'*131,
-                 data = b'Test Using Larger Than Block-Siz'
-                        b'e Key - Hash Key First',
-                 hexdigests = {
-                   hashlib.sha224: '95e9a0db962095adaebe9b2d6f0dbce2'
-                                   'd499f112f2d2b7273fa6870e',
-                   hashlib.sha256: '60e431591ee0b67f0d8a26aacbf5b77f'
-                                   '8e0bc6213728c5140546040f0ee37f54',
-                   hashlib.sha384: '4ece084485813e9088d2c63a041bc5b4'
-                                   '4f9ef1012a2b588f3cd11f05033ac4c6'
-                                   '0c2ef6ab4030fe8296248df163f44952',
-                   hashlib.sha512: '80b24263c7c1a3ebb71493c1dd7be8b4'
-                                   '9b46d1f41b4aeec1121b013783f8f352'
-                                   '6b56d037e05f2598bd0fd2215d6a1e52'
-                                   '95e64f73f63f0aec8b915a985d786598',
+        hmactest(key=b'\xaa' * 131,
+                 data=b'Test Using Larger Than Block-Siz'
+                      b'e Key - Hash Key First',
+                 hexdigests={
+                     'sha224': '95e9a0db962095adaebe9b2d6f0dbce2'
+                               'd499f112f2d2b7273fa6870e',
+                     'sha256': '60e431591ee0b67f0d8a26aacbf5b77f'
+                               '8e0bc6213728c5140546040f0ee37f54',
+                     'sha384': '4ece084485813e9088d2c63a041bc5b4'
+                               '4f9ef1012a2b588f3cd11f05033ac4c6'
+                               '0c2ef6ab4030fe8296248df163f44952',
+                     'sha512': '80b24263c7c1a3ebb71493c1dd7be8b4'
+                               '9b46d1f41b4aeec1121b013783f8f352'
+                               '6b56d037e05f2598bd0fd2215d6a1e52'
+                               '95e64f73f63f0aec8b915a985d786598',
                  })
 
         # 4.8.  Test Case 7
-        hmactest(key = b'\xaa'*131,
-                 data = b'This is a test using a larger th'
-                        b'an block-size key and a larger t'
-                        b'han block-size data. The key nee'
-                        b'ds to be hashed before being use'
-                        b'd by the HMAC algorithm.',
-                 hexdigests = {
-                   hashlib.sha224: '3a854166ac5d9f023f54d517d0b39dbd'
-                                   '946770db9c2b95c9f6f565d1',
-                   hashlib.sha256: '9b09ffa71b942fcb27635fbcd5b0e944'
-                                   'bfdc63644f0713938a7f51535c3a35e2',
-                   hashlib.sha384: '6617178e941f020d351e2f254e8fd32c'
-                                   '602420feb0b8fb9adccebb82461e99c5'
-                                   'a678cc31e799176d3860e6110c46523e',
-                   hashlib.sha512: 'e37b6a775dc87dbaa4dfa9f96e5e3ffd'
-                                   'debd71f8867289865df5a32d20cdc944'
-                                   'b6022cac3c4982b10d5eeb55c3e4de15'
-                                   '134676fb6de0446065c97440fa8c6a58',
+        hmactest(key=b'\xaa' * 131,
+                 data=b'This is a test using a larger th'
+                      b'an block-size key and a larger t'
+                      b'han block-size data. The key nee'
+                      b'ds to be hashed before being use'
+                      b'd by the HMAC algorithm.',
+                 hexdigests={
+                     'sha224': '3a854166ac5d9f023f54d517d0b39dbd'
+                               '946770db9c2b95c9f6f565d1',
+                     'sha256': '9b09ffa71b942fcb27635fbcd5b0e944'
+                               'bfdc63644f0713938a7f51535c3a35e2',
+                     'sha384': '6617178e941f020d351e2f254e8fd32c'
+                               '602420feb0b8fb9adccebb82461e99c5'
+                               'a678cc31e799176d3860e6110c46523e',
+                     'sha512': 'e37b6a775dc87dbaa4dfa9f96e5e3ffd'
+                               'debd71f8867289865df5a32d20cdc944'
+                               'b6022cac3c4982b10d5eeb55c3e4de15'
+                               '134676fb6de0446065c97440fa8c6a58',
                  })
 
-    @hashlib_helper.requires_hashdigest('sha224', openssl=True)
-    def test_sha224_rfc4231(self):
-        self._rfc4231_test_cases(hashlib.sha224, 'sha224', 28, 64)
-
-    @hashlib_helper.requires_hashdigest('sha256', openssl=True)
-    def test_sha256_rfc4231(self):
-        self._rfc4231_test_cases(hashlib.sha256, 'sha256', 32, 64)
-
-    @hashlib_helper.requires_hashdigest('sha384', openssl=True)
-    def test_sha384_rfc4231(self):
-        self._rfc4231_test_cases(hashlib.sha384, 'sha384', 48, 128)
-
-    @hashlib_helper.requires_hashdigest('sha512', openssl=True)
-    def test_sha512_rfc4231(self):
-        self._rfc4231_test_cases(hashlib.sha512, 'sha512', 64, 128)
-
     @hashlib_helper.requires_hashdigest('sha256')
     def test_legacy_block_size_warnings(self):
         class MockCrazyHash(object):
@@ -362,312 +554,517 @@ def digest(self):
                 hmac.HMAC(b'a', b'b', digestmod=MockCrazyHash)
                 self.fail('Expected warning about small block_size')
 
-    def test_with_digestmod_no_default(self):
-        """The digestmod parameter is required as of Python 3.8."""
-        with self.assertRaisesRegex(TypeError, r'required.*digestmod'):
-            key = b"\x0b" * 16
-            data = b"Hi There"
-            hmac.HMAC(key, data, digestmod=None)
-        with self.assertRaisesRegex(TypeError, r'required.*digestmod'):
-            hmac.new(key, data)
-        with self.assertRaisesRegex(TypeError, r'required.*digestmod'):
-            hmac.HMAC(key, msg=data, digestmod='')
-
     def test_with_fallback(self):
         cache = getattr(hashlib, '__builtin_constructor_cache')
         try:
             cache['foo'] = hashlib.sha256
             hexdigest = hmac.digest(b'key', b'message', 'foo').hex()
-            expected = '6e9ef29b75fffc5b7abae527d58fdadb2fe42e7219011976917343065f58ed4a'
+            expected = ('6e9ef29b75fffc5b7abae527d58fdadb'
+                        '2fe42e7219011976917343065f58ed4a')
             self.assertEqual(hexdigest, expected)
         finally:
             cache.pop('foo')
 
 
-class ConstructorTestCase(unittest.TestCase):
+class PyRFCTestCase(PyTestVectorsMixin, ThroughObjectMixin,
+                    RFCTestCasesMixin, unittest.TestCase):
+    """Python implementation of HMAC using hmac.HMAC()."""
 
-    expected = (
-        "6c845b47f52b3b47f6590c502db7825aad757bf4fadc8fa972f7cd2e76a5bdeb"
-    )
 
-    @hashlib_helper.requires_hashdigest('sha256')
-    def test_normal(self):
-        # Standard constructor call.
-        try:
-            hmac.HMAC(b"key", digestmod='sha256')
-        except Exception:
-            self.fail("Standard constructor call raised exception.")
+class PyDotNewRFCTestCase(PyTestVectorsMixin, ThroughModuleAPIMixin,
+                          RFCTestCasesMixin, unittest.TestCase):
+    """Python implementation of HMAC using hmac.new()."""
 
-    @hashlib_helper.requires_hashdigest('sha256')
-    def test_with_str_key(self):
-        # Pass a key of type str, which is an error, because it expects a key
-        # of type bytes
-        with self.assertRaises(TypeError):
-            h = hmac.HMAC("key", digestmod='sha256')
 
-    @hashlib_helper.requires_hashdigest('sha256')
-    def test_dot_new_with_str_key(self):
-        # Pass a key of type str, which is an error, because it expects a key
-        # of type bytes
-        with self.assertRaises(TypeError):
-            h = hmac.new("key", digestmod='sha256')
+@hashlib_helper.requires_hashlib()
+class OpenSSLRFCTestCase(OpenSSLTestVectorsMixin, RFCTestCasesMixin,
+                         unittest.TestCase):
+    """OpenSSL implementation of HMAC."""
 
-    @hashlib_helper.requires_hashdigest('sha256')
-    def test_withtext(self):
-        # Constructor call with text.
-        try:
-            h = hmac.HMAC(b"key", b"hash this!", digestmod='sha256')
-        except Exception:
-            self.fail("Constructor call with text argument raised exception.")
-        self.assertEqual(h.hexdigest(), self.expected)
+    def __init_subclass__(cls, *args, **kwargs):
+        super().__init_subclass__(*args, **kwargs)
 
-    @hashlib_helper.requires_hashdigest('sha256')
-    def test_with_bytearray(self):
-        try:
-            h = hmac.HMAC(bytearray(b"key"), bytearray(b"hash this!"),
-                          digestmod="sha256")
-        except Exception:
-            self.fail("Constructor call with bytearray arguments raised exception.")
-        self.assertEqual(h.hexdigest(), self.expected)
+        for name in cls.ALGORITHMS:
+            @property
+            @hashlib_helper.requires_hashdigest(name, openssl=True)
+            def func(self, *, __name=name):  # __name needed to bind 'name'
+                return getattr(_hashlib, f'openssl_{__name}')
+            setattr(cls, name, func)
 
-    @hashlib_helper.requires_hashdigest('sha256')
-    def test_with_memoryview_msg(self):
-        try:
-            h = hmac.HMAC(b"key", memoryview(b"hash this!"), digestmod="sha256")
-        except Exception:
-            self.fail("Constructor call with memoryview msg raised exception.")
-        self.assertEqual(h.hexdigest(), self.expected)
 
-    @hashlib_helper.requires_hashdigest('sha256')
-    def test_withmodule(self):
-        # Constructor call with text and digest module.
-        try:
-            h = hmac.HMAC(b"key", b"", hashlib.sha256)
-        except Exception:
-            self.fail("Constructor call with hashlib.sha256 raised exception.")
+class DigestModTestCaseMixin(CreatorMixin, DigestMixin):
+    """Tests for the 'digestmod' parameter."""
+
+    def assert_raises_missing_digestmod(self):
+        """A context manager catching errors when a digestmod is missing."""
+        return self.assertRaisesRegex(TypeError, "Missing required.*digestmod")
+
+    def assert_raises_unknown_digestmod(self):
+        """A context manager catching errors when a digestmod is unknown."""
+        return self.assertRaisesRegex(ValueError, "[Uu]nsupported.*")
+
+    def test_constructor_missing_digestmod(self):
+        catcher = self.assert_raises_missing_digestmod
+        self.do_test_constructor_missing_digestmod(catcher)
+
+    def test_constructor_unknown_digestmod(self):
+        catcher = self.assert_raises_unknown_digestmod
+        self.do_test_constructor_unknown_digestmod(catcher)
+
+    def do_test_constructor_missing_digestmod(self, catcher):
+        for func, args, kwds in self.cases_missing_digestmod_in_constructor():
+            with self.subTest(args=args, kwds=kwds), catcher():
+                func(*args, **kwds)
+
+    def do_test_constructor_unknown_digestmod(self, catcher):
+        for func, args, kwds in self.cases_unknown_digestmod_in_constructor():
+            with self.subTest(args=args, kwds=kwds), catcher():
+                func(*args, **kwds)
+
+    def cases_missing_digestmod_in_constructor(self):
+        raise NotImplementedError
+
+    def make_missing_digestmod_cases(self, func, choices):
+        """Generate cases for missing digestmod tests."""
+        key, msg = b'unused key', b'unused msg'
+        cases = self._invalid_digestmod_cases(func, key, msg, choices)
+        return [(func, (key,), {}), (func, (key, msg), {})] + cases
+
+    def cases_unknown_digestmod_in_constructor(self):
+        raise NotImplementedError
+
+    def make_unknown_digestmod_cases(self, func, choices):
+        """Generate cases for unknown digestmod tests."""
+        key, msg = b'unused key', b'unused msg'
+        return self._invalid_digestmod_cases(func, key, msg, choices)
+
+    def _invalid_digestmod_cases(self, func, key, msg, choices):
+        cases = []
+        for digestmod in choices:
+            kwargs = {'digestmod': digestmod}
+            cases.append((func, (key,), kwargs))
+            cases.append((func, (key, msg), kwargs))
+            cases.append((func, (key,), kwargs | {'msg': msg}))
+        return cases
+
+
+class ConstructorTestCaseMixin(CreatorMixin, DigestMixin, CheckerMixin):
+    """HMAC constructor tests based on HMAC-SHA-2/256."""
+
+    key = b"key"
+    msg = b"hash this!"
+    res = "6c845b47f52b3b47f6590c502db7825aad757bf4fadc8fa972f7cd2e76a5bdeb"
+
+    def do_test_constructor(self, hmac_on_key_and_msg):
+        self.do_test_constructor_invalid_types(hmac_on_key_and_msg)
+        self.do_test_constructor_supported_types(hmac_on_key_and_msg)
+
+    def do_test_constructor_invalid_types(self, hmac_on_key_and_msg):
+        self.assertRaises(TypeError, hmac_on_key_and_msg, 1)
+        self.assertRaises(TypeError, hmac_on_key_and_msg, "key")
+
+        self.assertRaises(TypeError, hmac_on_key_and_msg, b"key", 1)
+        self.assertRaises(TypeError, hmac_on_key_and_msg, b"key", "msg")
+
+    def do_test_constructor_supported_types(self, hmac_on_key_and_msg):
+        for tp_key in [bytes, bytearray]:
+            for tp_msg in [bytes, bytearray, memoryview]:
+                with self.subTest(tp_key=tp_key, tp_msg=tp_msg):
+                    h = hmac_on_key_and_msg(tp_key(self.key), tp_msg(self.msg))
+                    self.assertEqual(h.name, "hmac-sha256")
+                    self.assertEqual(h.hexdigest(), self.res)
+
+    @hashlib_helper.requires_hashdigest("sha256")
+    def test_constructor(self):
+        self.do_test_constructor(self.bind_hmac_new("sha256"))
+
+    @hashlib_helper.requires_hashdigest("sha256")
+    def test_digest(self):
+        digest = self.hmac_digest(self.key, self.msg, "sha256")
+        self.assertEqual(digest, binascii.unhexlify(self.res))
+
+
+class PyConstructorBaseMixin(PyModuleMixin,
+                             DigestModTestCaseMixin,
+                             ConstructorTestCaseMixin):
+
+    def cases_missing_digestmod_in_constructor(self):
+        func, choices = self.hmac_new, ['', None, False]
+        return self.make_missing_digestmod_cases(func, choices)
+
+    def cases_unknown_digestmod_in_constructor(self):
+        func, choices = self.hmac_new, ['unknown']
+        return self.make_unknown_digestmod_cases(func, choices)
+
+    @requires_builtin_sha2()
+    def test_constructor_with_module(self):
+        self.do_test_constructor(self.bind_hmac_new(sha2.sha256))
+
+    @requires_builtin_sha2()
+    def test_digest_with_module(self):
+        digest = self.hmac_digest(self.key, self.msg, sha2.sha256)
+        self.assertEqual(digest, binascii.unhexlify(self.res))
+
+
+class PyConstructorTestCase(ThroughObjectMixin, PyConstructorBaseMixin,
+                            unittest.TestCase):
+    """Test the hmac.HMAC() pure Python constructor."""
+
+
+class PyModuleConstructorTestCase(ThroughModuleAPIMixin, PyConstructorBaseMixin,
+                                  unittest.TestCase):
+    """Test the hmac.new() and hmac.digest() functions."""
+
+    def test_hmac_digest_digestmod_parameter(self):
+        func = self.hmac_digest
+
+        def raiser():
+            raise RuntimeError("custom exception")
+
+        with self.assertRaisesRegex(RuntimeError, "custom exception"):
+            func(b'key', b'msg', raiser)
+
+        with self.assertRaisesRegex(ValueError, 'hash type'):
+            func(b'key', b'msg', 'unknown')
+
+        with self.assertRaisesRegex(AttributeError, 'new'):
+            func(b'key', b'msg', 1234)
+        with self.assertRaisesRegex(AttributeError, 'new'):
+            func(b'key', b'msg', None)
+
+
+class ExtensionConstructorTestCaseMixin(DigestModTestCaseMixin,
+                                        ConstructorTestCaseMixin):
+
+    # The underlying C class.
+    obj_type = None
+
+    # The exact exception class raised when a 'digestmod' parameter is invalid.
+    exc_type = None
 
-    @unittest.skipUnless(C_HMAC is not None, 'need _hashlib')
     def test_internal_types(self):
-        # internal types like _hashlib.C_HMAC are not constructable
-        check_disallow_instantiation(self, C_HMAC)
+        # internal C types are immutable and cannot be instantiated
+        check_disallow_instantiation(self, self.obj_type)
         with self.assertRaisesRegex(TypeError, "immutable type"):
-            C_HMAC.value = None
+            self.obj_type.value = None
 
-    @unittest.skipUnless(sha256_module is not None, 'need _sha256')
-    def test_with_sha256_module(self):
-        h = hmac.HMAC(b"key", b"hash this!", digestmod=sha256_module.sha256)
-        self.assertEqual(h.hexdigest(), self.expected)
-        self.assertEqual(h.name, "hmac-sha256")
+    def assert_digestmod_error(self):
+        self.assertIsSubclass(self.exc_type, ValueError)
+        return self.assertRaises(self.exc_type)
 
-        digest = hmac.digest(b"key", b"hash this!", sha256_module.sha256)
-        self.assertEqual(digest, binascii.unhexlify(self.expected))
+    def test_constructor_missing_digestmod(self):
+        self.do_test_constructor_missing_digestmod(self.assert_digestmod_error)
 
+    def test_constructor_unknown_digestmod(self):
+        self.do_test_constructor_unknown_digestmod(self.assert_digestmod_error)
 
-class SanityTestCase(unittest.TestCase):
+    def cases_missing_digestmod_in_constructor(self):
+        func, choices = self.hmac_new, ['', None, False]
+        return self.make_missing_digestmod_cases(func, choices)
 
-    @hashlib_helper.requires_hashdigest('sha256')
-    def test_exercise_all_methods(self):
-        # Exercising all methods once.
-        # This must not raise any exceptions
-        try:
-            h = hmac.HMAC(b"my secret key", digestmod="sha256")
-            h.update(b"compute the hash of this text!")
-            h.digest()
-            h.hexdigest()
-            h.copy()
-        except Exception:
-            self.fail("Exception raised during normal usage of HMAC class.")
+    def cases_unknown_digestmod_in_constructor(self):
+        func, choices = self.hmac_new, ['unknown', 1234]
+        return self.make_unknown_digestmod_cases(func, choices)
 
 
-class UpdateTestCase(unittest.TestCase):
-    @hashlib_helper.requires_hashdigest('sha256')
-    def test_with_str_update(self):
-        with self.assertRaises(TypeError):
-            h = hmac.new(b"key", digestmod='sha256')
-            h.update("invalid update")
+class OpenSSLConstructorTestCase(ThroughOpenSSLAPIMixin,
+                                 ExtensionConstructorTestCaseMixin,
+                                 unittest.TestCase):
+
+    @property
+    def obj_type(self):
+        return _hashlib.HMAC
+
+    @property
+    def exc_type(self):
+        return _hashlib.UnsupportedDigestmodError
+
+    def test_hmac_digest_digestmod_parameter(self):
+        # TODO(picnixz): remove default arguments in _hashlib.hmac_digest()
+        # since the return value is not a HMAC object but a bytes object.
+        for value in [object, 'unknown', 1234, None]:
+            with self.subTest(value=value), self.assert_digestmod_error():
+                self.hmac_digest(b'key', b'msg', value)
+
+
+class SanityTestCaseMixin(CreatorMixin):
+    """Sanity checks for HMAC objects and their object interface.
+
+    The tests here use a common digestname and do not check all supported
+    hash functions.
+    """
+
+    # The underlying HMAC class to test. May be in C or in Python.
+    hmac_class: type
+    # The underlying hash function name (should be accepted by the HMAC class).
+    digestname: str
+
+    def test_methods(self):
+        h = self.hmac_new(b"my secret key", digestmod=self.digestname)
+        self.assertIsInstance(h, self.hmac_class)
+        self.assertIsNone(h.update(b"compute the hash of this text!"))
+        self.assertIsInstance(h.digest(), bytes)
+        self.assertIsInstance(h.hexdigest(), str)
+        self.assertIsInstance(h.copy(), self.hmac_class)
+
+    def test_repr(self):
+        # HMAC object representation may differ across implementations
+        raise NotImplementedError
+
 
+@hashlib_helper.requires_hashdigest('sha256')
+class PySanityTestCase(ThroughObjectMixin, PyModuleMixin, SanityTestCaseMixin,
+                       unittest.TestCase):
 
+    @classmethod
+    def setUpClass(cls):
+        super().setUpClass()
+        cls.hmac_class = cls.hmac.HMAC
+        cls.digestname = 'sha256'
+
+    def test_repr(self):
+        h = self.hmac_new(b"my secret key", digestmod=self.digestname)
+        self.assertStartsWith(repr(h), "<hmac.HMAC object at")
+
+
+@hashlib_helper.requires_hashdigest('sha256', openssl=True)
+class OpenSSLSanityTestCase(ThroughOpenSSLAPIMixin, SanityTestCaseMixin,
+                            unittest.TestCase):
+
+    @classmethod
+    def setUpClass(cls):
+        super().setUpClass()
+        cls.hmac_class = _hashlib.HMAC
+        cls.digestname = 'sha256'
+
+    def test_repr(self):
+        h = self.hmac_new(b"my secret key", digestmod=self.digestname)
+        self.assertStartsWith(repr(h), f"<{self.digestname} HMAC object @")
+
+
+class UpdateTestCaseMixin:
+    """Tests for the update() method (streaming HMAC)."""
+
+    def HMAC(self, key, msg=None):
+        """Create a HMAC object."""
+        raise NotImplementedError
+
+    def test_update(self):
+        key, msg = random.randbytes(16), random.randbytes(16)
+        with self.subTest(key=key, msg=msg):
+            h1 = self.HMAC(key, msg)
+
+            h2 = self.HMAC(key)
+            h2.update(msg)
+
+            self.assertEqual(h1.digest(), h2.digest())
+            self.assertEqual(h1.hexdigest(), h2.hexdigest())
+
+    def test_update_exceptions(self):
+        h = self.HMAC(b"key")
+        for msg in ['invalid msg', 123, (), []]:
+            with self.subTest(msg=msg):
+                self.assertRaises(TypeError, h.update, msg)
+
+
+@hashlib_helper.requires_hashdigest('sha256')
+class PyUpdateTestCase(UpdateTestCaseMixin, unittest.TestCase):
+
+    @classmethod
+    def setUpClass(cls):
+        super().setUpClass()
+        cls.hmac = import_fresh_module('hmac', blocked=['_hashlib'])
+
+    def HMAC(self, key, msg=None):
+        return self.hmac.HMAC(key, msg, digestmod='sha256')
+
+
+@hashlib_helper.requires_hashlib()
+@hashlib_helper.requires_hashdigest('sha256', openssl=True)
+class OpenSSLUpdateTestCase(UpdateTestCaseMixin, unittest.TestCase):
+
+    def HMAC(self, key, msg=None):
+        return hmac.new(key, msg, digestmod='sha256')
+
+
+@hashlib_helper.requires_hashdigest('sha256')
 class CopyTestCase(unittest.TestCase):
 
-    @hashlib_helper.requires_hashdigest('sha256')
     def test_attributes_old(self):
         # Testing if attributes are of same type.
         h1 = hmac.HMAC.__new__(hmac.HMAC)
         h1._init_old(b"key", b"msg", digestmod="sha256")
         h2 = h1.copy()
-        self.assertEqual(type(h1._inner), type(h2._inner),
-            "Types of inner don't match.")
-        self.assertEqual(type(h1._outer), type(h2._outer),
-            "Types of outer don't match.")
+        self.assertEqual(type(h1._inner), type(h2._inner))
+        self.assertEqual(type(h1._outer), type(h2._outer))
 
-    @hashlib_helper.requires_hashdigest('sha256')
     def test_realcopy_old(self):
         # Testing if the copy method created a real copy.
         h1 = hmac.HMAC.__new__(hmac.HMAC)
         h1._init_old(b"key", b"msg", digestmod="sha256")
+        self.assertIsNone(h1._hmac)
+
         h2 = h1.copy()
+        self.assertIsNone(h2._hmac)
         # Using id() in case somebody has overridden __eq__/__ne__.
-        self.assertTrue(id(h1) != id(h2), "No real copy of the HMAC instance.")
-        self.assertTrue(id(h1._inner) != id(h2._inner),
-            "No real copy of the attribute 'inner'.")
-        self.assertTrue(id(h1._outer) != id(h2._outer),
-            "No real copy of the attribute 'outer'.")
-        self.assertIs(h1._hmac, None)
-
-    @unittest.skipIf(_hashopenssl is None, "test requires _hashopenssl")
-    @hashlib_helper.requires_hashdigest('sha256')
+        self.assertNotEqual(id(h1), id(h2))
+        self.assertNotEqual(id(h1._inner), id(h2._inner))
+        self.assertNotEqual(id(h1._outer), id(h2._outer))
+
+    @hashlib_helper.requires_hashlib()
     def test_realcopy_hmac(self):
         h1 = hmac.HMAC.__new__(hmac.HMAC)
         h1._init_hmac(b"key", b"msg", digestmod="sha256")
         h2 = h1.copy()
-        self.assertTrue(id(h1._hmac) != id(h2._hmac))
+        self.assertNotEqual(id(h1._hmac), id(h2._hmac))
 
-    @hashlib_helper.requires_hashdigest('sha256')
     def test_equality(self):
         # Testing if the copy has the same digests.
         h1 = hmac.HMAC(b"key", digestmod="sha256")
         h1.update(b"some random text")
         h2 = h1.copy()
-        self.assertEqual(h1.digest(), h2.digest(),
-            "Digest of copy doesn't match original digest.")
-        self.assertEqual(h1.hexdigest(), h2.hexdigest(),
-            "Hexdigest of copy doesn't match original hexdigest.")
+        self.assertEqual(h1.digest(), h2.digest())
+        self.assertEqual(h1.hexdigest(), h2.hexdigest())
 
-    @hashlib_helper.requires_hashdigest('sha256')
     def test_equality_new(self):
         # Testing if the copy has the same digests with hmac.new().
         h1 = hmac.new(b"key", digestmod="sha256")
         h1.update(b"some random text")
         h2 = h1.copy()
-        self.assertTrue(
-            id(h1) != id(h2), "No real copy of the HMAC instance."
-        )
-        self.assertEqual(h1.digest(), h2.digest(),
-            "Digest of copy doesn't match original digest.")
-        self.assertEqual(h1.hexdigest(), h2.hexdigest(),
-            "Hexdigest of copy doesn't match original hexdigest.")
-
-
-class CompareDigestTestCase(unittest.TestCase):
-
-    def test_hmac_compare_digest(self):
-        self._test_compare_digest(hmac.compare_digest)
-        if openssl_compare_digest is not None:
-            self.assertIs(hmac.compare_digest, openssl_compare_digest)
-        else:
-            self.assertIs(hmac.compare_digest, operator_compare_digest)
-
-    def test_operator_compare_digest(self):
-        self._test_compare_digest(operator_compare_digest)
-
-    @unittest.skipIf(openssl_compare_digest is None, "test requires _hashlib")
-    def test_openssl_compare_digest(self):
-        self._test_compare_digest(openssl_compare_digest)
-
-    def _test_compare_digest(self, compare_digest):
-        # Testing input type exception handling
-        a, b = 100, 200
-        self.assertRaises(TypeError, compare_digest, a, b)
-        a, b = 100, b"foobar"
-        self.assertRaises(TypeError, compare_digest, a, b)
-        a, b = b"foobar", 200
-        self.assertRaises(TypeError, compare_digest, a, b)
-        a, b = "foobar", b"foobar"
-        self.assertRaises(TypeError, compare_digest, a, b)
-        a, b = b"foobar", "foobar"
-        self.assertRaises(TypeError, compare_digest, a, b)
-
+        self.assertNotEqual(id(h1), id(h2))
+        self.assertEqual(h1.digest(), h2.digest())
+        self.assertEqual(h1.hexdigest(), h2.hexdigest())
+
+
+class CompareDigestMixin:
+
+    @staticmethod
+    def compare_digest(a, b):
+        """Implementation of 'a == b' to test."""
+        raise NotImplementedError
+
+    def assert_digest_equal(self, a, b):
+        with self.subTest(a=a, b=b):
+            self.assertTrue(self.compare_digest(a, b))
+        with self.subTest(a=b, b=a):
+            self.assertTrue(self.compare_digest(b, a))
+
+    def assert_digest_not_equal(self, a, b):
+        with self.subTest(a=a, b=b):
+            self.assertFalse(self.compare_digest(a, b))
+        with self.subTest(a=b, b=a):
+            self.assertFalse(self.compare_digest(b, a))
+
+    def test_exceptions(self):
+        for a, b in [
+            # Testing input type exception handling
+            (100, 200), (100, b"foobar"), ("foobar", b"foobar"),
+            # non-ASCII strings
+            ("fooä", "fooä")
+        ]:
+            self.assertRaises(TypeError, self.compare_digest, a, b)
+            self.assertRaises(TypeError, self.compare_digest, b, a)
+
+    def test_bytes(self):
         # Testing bytes of different lengths
         a, b = b"foobar", b"foo"
-        self.assertFalse(compare_digest(a, b))
+        self.assert_digest_not_equal(a, b)
         a, b = b"\xde\xad\xbe\xef", b"\xde\xad"
-        self.assertFalse(compare_digest(a, b))
+        self.assert_digest_not_equal(a, b)
 
         # Testing bytes of same lengths, different values
         a, b = b"foobar", b"foobaz"
-        self.assertFalse(compare_digest(a, b))
+        self.assert_digest_not_equal(a, b)
         a, b = b"\xde\xad\xbe\xef", b"\xab\xad\x1d\xea"
-        self.assertFalse(compare_digest(a, b))
+        self.assert_digest_not_equal(a, b)
 
         # Testing bytes of same lengths, same values
         a, b = b"foobar", b"foobar"
-        self.assertTrue(compare_digest(a, b))
+        self.assert_digest_equal(a, b)
         a, b = b"\xde\xad\xbe\xef", b"\xde\xad\xbe\xef"
-        self.assertTrue(compare_digest(a, b))
+        self.assert_digest_equal(a, b)
 
+    def test_bytearray(self):
         # Testing bytearrays of same lengths, same values
         a, b = bytearray(b"foobar"), bytearray(b"foobar")
-        self.assertTrue(compare_digest(a, b))
+        self.assert_digest_equal(a, b)
 
         # Testing bytearrays of different lengths
         a, b = bytearray(b"foobar"), bytearray(b"foo")
-        self.assertFalse(compare_digest(a, b))
+        self.assert_digest_not_equal(a, b)
 
         # Testing bytearrays of same lengths, different values
         a, b = bytearray(b"foobar"), bytearray(b"foobaz")
-        self.assertFalse(compare_digest(a, b))
+        self.assert_digest_not_equal(a, b)
 
+    def test_mixed_types(self):
         # Testing byte and bytearray of same lengths, same values
         a, b = bytearray(b"foobar"), b"foobar"
-        self.assertTrue(compare_digest(a, b))
-        self.assertTrue(compare_digest(b, a))
+        self.assert_digest_equal(a, b)
 
         # Testing byte bytearray of different lengths
         a, b = bytearray(b"foobar"), b"foo"
-        self.assertFalse(compare_digest(a, b))
-        self.assertFalse(compare_digest(b, a))
+        self.assert_digest_not_equal(a, b)
 
         # Testing byte and bytearray of same lengths, different values
         a, b = bytearray(b"foobar"), b"foobaz"
-        self.assertFalse(compare_digest(a, b))
-        self.assertFalse(compare_digest(b, a))
+        self.assert_digest_not_equal(a, b)
 
+    def test_string(self):
         # Testing str of same lengths
         a, b = "foobar", "foobar"
-        self.assertTrue(compare_digest(a, b))
+        self.assert_digest_equal(a, b)
 
         # Testing str of different lengths
         a, b = "foo", "foobar"
-        self.assertFalse(compare_digest(a, b))
+        self.assert_digest_not_equal(a, b)
 
-        # Testing bytes of same lengths, different values
+        # Testing str of same lengths, different values
         a, b = "foobar", "foobaz"
-        self.assertFalse(compare_digest(a, b))
-
-        # Testing error cases
-        a, b = "foobar", b"foobar"
-        self.assertRaises(TypeError, compare_digest, a, b)
-        a, b = b"foobar", "foobar"
-        self.assertRaises(TypeError, compare_digest, a, b)
-        a, b = b"foobar", 1
-        self.assertRaises(TypeError, compare_digest, a, b)
-        a, b = 100, 200
-        self.assertRaises(TypeError, compare_digest, a, b)
-        a, b = "fooä", "fooä"
-        self.assertRaises(TypeError, compare_digest, a, b)
-
-        # subclasses are supported by ignore __eq__
-        class mystr(str):
+        self.assert_digest_not_equal(a, b)
+
+    def test_string_subclass(self):
+        class S(str):
             def __eq__(self, other):
-                return False
+                raise ValueError("should not be called")
 
-        a, b = mystr("foobar"), mystr("foobar")
-        self.assertTrue(compare_digest(a, b))
-        a, b = mystr("foobar"), "foobar"
-        self.assertTrue(compare_digest(a, b))
-        a, b = mystr("foobar"), mystr("foobaz")
-        self.assertFalse(compare_digest(a, b))
+        a, b = S("foobar"), S("foobar")
+        self.assert_digest_equal(a, b)
+        a, b = S("foobar"), "foobar"
+        self.assert_digest_equal(a, b)
+        a, b = S("foobar"), S("foobaz")
+        self.assert_digest_not_equal(a, b)
 
-        class mybytes(bytes):
+    def test_bytes_subclass(self):
+        class B(bytes):
             def __eq__(self, other):
-                return False
-
-        a, b = mybytes(b"foobar"), mybytes(b"foobar")
-        self.assertTrue(compare_digest(a, b))
-        a, b = mybytes(b"foobar"), b"foobar"
-        self.assertTrue(compare_digest(a, b))
-        a, b = mybytes(b"foobar"), mybytes(b"foobaz")
-        self.assertFalse(compare_digest(a, b))
+                raise ValueError("should not be called")
+
+        a, b = B(b"foobar"), B(b"foobar")
+        self.assert_digest_equal(a, b)
+        a, b = B(b"foobar"), b"foobar"
+        self.assert_digest_equal(a, b)
+        a, b = B(b"foobar"), B(b"foobaz")
+        self.assert_digest_not_equal(a, b)
+
+
+class HMACCompareDigestTestCase(CompareDigestMixin, unittest.TestCase):
+    compare_digest = hmac.compare_digest
+
+    def test_compare_digest_func(self):
+        if openssl_compare_digest is not None:
+            self.assertIs(self.compare_digest, openssl_compare_digest)
+        else:
+            self.assertIs(self.compare_digest, operator_compare_digest)
+
+
+@hashlib_helper.requires_hashlib()
+class OpenSSLCompareDigestTestCase(CompareDigestMixin, unittest.TestCase):
+    compare_digest = openssl_compare_digest
+
+
+class OperatorCompareDigestTestCase(CompareDigestMixin, unittest.TestCase):
+    compare_digest = operator_compare_digest
 
 
 if __name__ == "__main__":