t/t-algorithms.py (HashBufferTestMixin): Assemble method names dynamically.

Not everything I want to test with this machinery calls its methods
`hashXXX'.

diff --git a/t/t-algorithms.py b/t/t-algorithms.py
index 455e947..856470a 100644 (file)
--- a/t/t-algorithms.py
+++ b/t/t-algorithms.py
@@ -64,72 +64,82 @@ def different_key_size(ksz, sz):
 class HashBufferTestMixin (U.TestCase):
   """Mixin class for testing all of the various `hash...' methods."""
 
-  def check_hashbuffer_hashn(me, w, bigendp, makefn, hashfn):
+  HASHMETH = "hash"
+  def dohash(me, h, op, arg):
+    getattr(h, me.HASHMETH + op)(arg)
+    return me
+
+  def check_hashbuffer_hashn(me, w, bigendp, makefn, hashop):
     """Check `hashuN'."""
 
     ## Check encoding an integer.
     h0, donefn0 = makefn(w + 2)
-    hashfn(h0.hashu8(0x00), T.bytes_as_int(w, bigendp)).hashu8(w + 1)
+    me.dohash(h0, "u8", 0x00)
+    me.dohash(h0, hashop, T.bytes_as_int(w, bigendp))
+    me.dohash(h0, "u8", w + 1)
     h1, donefn1 = makefn(w + 2)
-    h1.hash(T.span(w + 2))
+    me.dohash(h1, "", T.span(w + 2))
     me.assertEqual(donefn0(), donefn1())
 
     ## Check overflow detection.
     h0, _ = makefn(w)
-    me.assertRaises(OverflowError, hashfn, h0, 1 << 8*w)
+    me.assertRaises(OverflowError, me.dohash, h0, hashop, 1 << 8*w)
 
-  def check_hashbuffer_bufn(me, w, bigendp, makefn, hashfn):
+  def check_hashbuffer_bufn(me, w, bigendp, makefn, hashop):
     """Check `hashbufN'."""
 
     ## Go through a number of different sizes.
     for n in [0, 1, 7, 8, 19, 255, 12345, 65535, 123456]:
       if n >= 1 << 8*w: continue
       h0, donefn0 = makefn(2 + w + n)
-      hashfn(h0.hashu8(0x00), T.span(n)).hashu8(0xff)
+      me.dohash(h0, "u8", 0x00)
+      me.dohash(h0, hashop, T.span(n))
+      me.dohash(h0, "u8", 0xff)
       h1, donefn1 = makefn(2 + w + n)
-      h1.hash(T.prep_lenseq(w, n, bigendp, True))
+      me.dohash(h1, "", T.prep_lenseq(w, n, bigendp, True))
       me.assertEqual(donefn0(), donefn1())
 
     ## Check blocks which are too large for the length prefix.
     if w <= 3:
       n = 1 << 8*w
       h0, _ = makefn(w + n)
-      me.assertRaises(ValueError, hashfn, h0, C.ByteString.zero(n))
+      me.assertRaises(ValueError,
+                      me.dohash, h0, hashop, C.ByteString.zero(n))
 
   def check_hashbuffer(me, makefn):
     """Test the various `hash...' methods."""
 
     ## Check `hashuN'.
-    me.check_hashbuffer_hashn(1, True, makefn, lambda h, n: h.hashu8(n))
-    me.check_hashbuffer_hashn(2, True, makefn, lambda h, n: h.hashu16(n))
-    me.check_hashbuffer_hashn(2, True, makefn, lambda h, n: h.hashu16b(n))
-    me.check_hashbuffer_hashn(2, False, makefn, lambda h, n: h.hashu16l(n))
-    me.check_hashbuffer_hashn(3, True, makefn, lambda h, n: h.hashu24(n))
-    me.check_hashbuffer_hashn(3, True, makefn, lambda h, n: h.hashu24b(n))
-    me.check_hashbuffer_hashn(3, False, makefn, lambda h, n: h.hashu24l(n))
-    me.check_hashbuffer_hashn(4, True, makefn, lambda h, n: h.hashu32(n))
-    me.check_hashbuffer_hashn(4, True, makefn, lambda h, n: h.hashu32b(n))
-    me.check_hashbuffer_hashn(4, False, makefn, lambda h, n: h.hashu32l(n))
-    if hasattr(makefn(0)[0], "hashu64"):
-      me.check_hashbuffer_hashn(8, True, makefn, lambda h, n: h.hashu64(n))
-      me.check_hashbuffer_hashn(8, True, makefn, lambda h, n: h.hashu64b(n))
-      me.check_hashbuffer_hashn(8, False, makefn, lambda h, n: h.hashu64l(n))
+    me.check_hashbuffer_hashn(1, True, makefn, "u8")
+    me.check_hashbuffer_hashn(2, True, makefn, "u16")
+    me.check_hashbuffer_hashn(2, True, makefn, "u16b")
+    me.check_hashbuffer_hashn(2, False, makefn, "u16l")
+    me.check_hashbuffer_hashn(3, True, makefn, "u24")
+    me.check_hashbuffer_hashn(3, True, makefn, "u24b")
+    me.check_hashbuffer_hashn(3, False, makefn, "u24l")
+    me.check_hashbuffer_hashn(4, True, makefn, "u32")
+    me.check_hashbuffer_hashn(4, True, makefn, "u32b")
+    me.check_hashbuffer_hashn(4, False, makefn, "u32l")
+    if hasattr(makefn(0)[0], me.HASHMETH + "u64"):
+      me.check_hashbuffer_hashn(8, True, makefn, "u64")
+      me.check_hashbuffer_hashn(8, True, makefn, "u64b")
+      me.check_hashbuffer_hashn(8, False, makefn, "u64l")
 
     ## Check `hashbufN'.
-    me.check_hashbuffer_bufn(1, True, makefn, lambda h, x: h.hashbuf8(x))
-    me.check_hashbuffer_bufn(2, True, makefn, lambda h, x: h.hashbuf16(x))
-    me.check_hashbuffer_bufn(2, True, makefn, lambda h, x: h.hashbuf16b(x))
-    me.check_hashbuffer_bufn(2, False, makefn, lambda h, x: h.hashbuf16l(x))
-    me.check_hashbuffer_bufn(3, True, makefn, lambda h, x: h.hashbuf24(x))
-    me.check_hashbuffer_bufn(3, True, makefn, lambda h, x: h.hashbuf24b(x))
-    me.check_hashbuffer_bufn(3, False, makefn, lambda h, x: h.hashbuf24l(x))
-    me.check_hashbuffer_bufn(4, True, makefn, lambda h, x: h.hashbuf32(x))
-    me.check_hashbuffer_bufn(4, True, makefn, lambda h, x: h.hashbuf32b(x))
-    me.check_hashbuffer_bufn(4, False, makefn, lambda h, x: h.hashbuf32l(x))
-    if hasattr(makefn(0)[0], "hashbuf64"):
-      me.check_hashbuffer_bufn(8, True, makefn, lambda h, x: h.hashbuf64(x))
-      me.check_hashbuffer_bufn(8, True, makefn, lambda h, x: h.hashbuf64b(x))
-      me.check_hashbuffer_bufn(8, False, makefn, lambda h, x: h.hashbuf64l(x))
+    me.check_hashbuffer_bufn(1, True, makefn, "buf8")
+    me.check_hashbuffer_bufn(2, True, makefn, "buf16")
+    me.check_hashbuffer_bufn(2, True, makefn, "buf16b")
+    me.check_hashbuffer_bufn(2, False, makefn, "buf16l")
+    me.check_hashbuffer_bufn(3, True, makefn, "buf24")
+    me.check_hashbuffer_bufn(3, True, makefn, "buf24b")
+    me.check_hashbuffer_bufn(3, False, makefn, "buf24l")
+    me.check_hashbuffer_bufn(4, True, makefn, "buf32")
+    me.check_hashbuffer_bufn(4, True, makefn, "buf32b")
+    me.check_hashbuffer_bufn(4, False, makefn, "buf32l")
+    if hasattr(makefn(0)[0], me.HASHMETH + "u64"):
+      me.check_hashbuffer_bufn(8, True, makefn, "buf64")
+      me.check_hashbuffer_bufn(8, True, makefn, "buf64b")
+      me.check_hashbuffer_bufn(8, False, makefn, "buf64l")
 
 ###--------------------------------------------------------------------------
 class TestKeysize (U.TestCase):