From: Mark Wooding Date: Tue, 26 Nov 2019 22:23:50 +0000 (+0000) Subject: t/t-algorithms.py (HashBufferTestMixin): Assemble method names dynamically. X-Git-Url: https://git.distorted.org.uk/~mdw/catacomb-python/commitdiff_plain/c349475ea054b20bb610b9e1b42718233860e070 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 --- 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):