mdw@git.distorted.org.uk Git - catacomb-python/blob - t/testutils.py

   1 ### -*- mode: python, coding: utf-8 -*-
   2 ###
   3 ### Test utilities
   4 ###
   5 ### (c) 2019 Straylight/Edgeware
   6 ###
   7
   8 ###----- Licensing notice ---------------------------------------------------
   9 ###
  10 ### This file is part of the Python interface to Catacomb.
  11 ###
  12 ### Catacomb/Python is free software: you can redistribute it and/or
  13 ### modify it under the terms of the GNU General Public License as
  14 ### published by the Free Software Foundation; either version 2 of the
  15 ### License, or (at your option) any later version.
  16 ###
  17 ### Catacomb/Python is distributed in the hope that it will be useful, but
  18 ### WITHOUT ANY WARRANTY; without even the implied warranty of
  19 ### MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  20 ### General Public License for more details.
  21 ###
  22 ### You should have received a copy of the GNU General Public License
  23 ### along with Catacomb/Python.  If not, write to the Free Software
  24 ### Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
  25 ### USA.
  26
  27 ###--------------------------------------------------------------------------
  28 ### Imported modules.
  29
  30 import catacomb as C
  31 import sys as SYS
  32 if SYS.version_info >= (3,): import builtins as B
  33 else: import __builtin__ as B
  34 import unittest as U
  35
  36 ###--------------------------------------------------------------------------
  37 ### Main code.
  38
  39 ## Some compatibility hacks.
  40 if SYS.version_info >= (3,):
  41   PY2, PY3 = False, True
  42   def bin(x): return x.encode('iso8859-1')
  43   def py23(x, y): return y
  44   range = range
  45   byteseq = bytes
  46   long = int
  47   imap = map
  48   def iterkeys(m): return m.keys()
  49   def itervalues(m): return m.values()
  50   def iteritems(m): return m.items()
  51   from io import StringIO
  52   MAXFIXNUM = SYS.maxsize
  53 else:
  54   import itertools as I
  55   PY2, PY3 = True, False
  56   def bin(x): return x
  57   def py23(x, y): return x
  58   range = xrange
  59   long = long
  60   imap = I.imap
  61   def byteseq(seq): return "".join(map(chr, seq))
  62   def iterkeys(m): return m.iterkeys()
  63   def itervalues(m): return m.itervalues()
  64   def iteritems(m): return m.iteritems()
  65   from cStringIO import StringIO
  66   MAXFIXNUM = SYS.maxint
  67
  68 DEBUGP = hasattr(SYS, "gettotalrefcount")
  69
  70 FULLSPAN = byteseq(range(256))
  71 def span(n):
  72   """A string `00 01 .. NN'."""
  73   return (n >> 8)*FULLSPAN + FULLSPAN[:n&255]
  74
  75 def bytes_as_int(w, bigendp):
  76   """Convert the byte-sequence `01 02 ... WW' to an integer."""
  77   x = 0
  78   if bigendp:
  79     for i in range(w): x = x << 8 | i + 1
  80   else:
  81     for i in range(w): x |= i + 1 << 8*i
  82   return x
  83
  84 def prep_lenseq(w, n, bigendp, goodp):
  85   """
  86   Return a reference buffer containing `00 LL .. LL 00 01 02 .. NN ff'.
  87
  88   Here, LL .. LL is the length of following sequence, not including the final
  89   `ff', as a W-byte integer.  If GOODP is false, then the most significant
  90   bit of LL .. LL is set, to provoke an overflow.
  91   """
  92   if goodp: l = n
  93   else: l = n + (1 << 8*w - 1)
  94   lenbyte = bigendp \
  95     and (lambda i: (l >> 8*(w - i - 1))&0xff) \
  96     or (lambda i: (l >> 8*i)&0xff)
  97   return byteseq([0x00]) + \
  98     byteseq([lenbyte(i) for i in range(w)]) + \
  99     span(n) + \
 100     byteseq([0xff])
 101
 102 def detrand(seed):
 103   """Return a fast deterministic random generator with the given SEED."""
 104   return C.chacha8rand(C.sha256().hash(bin(seed)).done())
 105
 106 class GenericTestMixin (U.TestCase):
 107   """
 108   A mixin class to generate test-case functions for all similar things.
 109   """
 110
 111   @classmethod
 112   def generate_testcases(cls, things):
 113     testfns = dict()
 114     checkfns = []
 115     for k, v in iteritems(cls.__dict__):
 116       if k.startswith("_test_"): checkfns.append((k[6:], v))
 117     for name, thing in things:
 118       for test, checkfn in checkfns:
 119         testfn = lambda me, thing = thing: checkfn(me, thing)
 120         doc = getattr(checkfn, "__doc__", None)
 121         if doc is not None: testfn.__doc__ = doc % name
 122         testfns["test_%s%%%s" % (test, name)] = testfn
 123     tmpcls =  type("_tmp", (cls,), testfns)
 124     for k, v in iteritems(tmpcls.__dict__):
 125       if k.startswith("test_"): setattr(cls, k, v)
 126
 127 class ImmutableMappingTextMixin (U.TestCase):
 128
 129   ## Subclass stubs.
 130   def _mkkey(me, i): return "k#%d" % i
 131   def _getkey(me, k): return int(k[2:])
 132   def _getvalue(me, v): return int(v[2:])
 133   def _getitem(me, it): k, v = it; return me._getkey(k), me._getvalue(v)
 134
 135   def check_immutable_mapping(me, map, model):
 136
 137     ## Lookup.
 138     limk = 0
 139     any = False
 140     me.assertEqual(len(map), len(model))
 141     for k, v in iteritems(model):
 142       any = True
 143       if k >= limk: limk = k + 1
 144       me.assertTrue(me._mkkey(k) in map)
 145       if PY2: me.assertTrue(map.has_key(me._mkkey(k)))
 146       me.assertEqual(me._getvalue(map[me._mkkey(k)]), v)
 147       me.assertEqual(me._getvalue(map.get(me._mkkey(k))), v)
 148     if any: me.assertTrue(me._mkkey(k) in map)
 149     if PY2: me.assertFalse(map.has_key(me._mkkey(limk)))
 150     me.assertRaises(KeyError, lambda: map[me._mkkey(limk)])
 151     me.assertEqual(map.get(me._mkkey(limk)), None)
 152
 153     if PY3:
 154       empty = set()
 155
 156       for k, v in iteritems(map):
 157         me.assertTrue(k in map.keys())
 158         me.assertTrue((k, v) in map.items())
 159       me.assertFalse(me._mkkey(limk) in map.keys())
 160
 161       for viewfn, getfn in [(lambda x: x.keys(), me._getkey),
 162                             (lambda x: x.items(), me._getitem)]:
 163         rview, rview2, mview = viewfn(map), viewfn(map), viewfn(model)
 164         me.assertEqual(set(imap(getfn, rview)), set(mview))
 165         me.assertEqual(rview, rview2)
 166         me.assertEqual(rview, set(rview2))
 167         me.assertEqual(rview | empty, set(rview))
 168         me.assertEqual(rview | rview2, set(rview))
 169         me.assertEqual(rview ^ empty, set(rview))
 170         me.assertEqual(rview ^ rview, empty)
 171         me.assertEqual(rview & empty, empty)
 172         me.assertEqual(len(rview), len(model))
 173
 174         if any: subset = set(rview2); subset.pop()
 175         superset = set(rview2); superset.add(object())
 176
 177         me.assertFalse(rview < rview2)
 178         me.assertTrue(rview < superset)
 179         me.assertFalse(superset < rview)
 180         me.assertFalse(rview < empty)
 181         if any:
 182           me.assertTrue(empty < rview)
 183           me.assertTrue(subset < rview)
 184           me.assertFalse(rview < subset)
 185
 186         me.assertTrue(rview <= rview2)
 187         me.assertTrue(rview <= superset)
 188         me.assertFalse(superset <= rview)
 189         if any:
 190           me.assertTrue(empty <= rview)
 191           me.assertFalse(rview <= empty)
 192           me.assertTrue(subset <= rview)
 193           me.assertFalse(rview <= subset)
 194
 195         me.assertTrue(rview >= rview2)
 196         me.assertTrue(superset >= rview)
 197         me.assertFalse(rview >= superset)
 198         if any:
 199           me.assertTrue(rview >= empty)
 200           me.assertFalse(empty >= rview)
 201           me.assertTrue(rview >= subset)
 202           me.assertFalse(subset >= rview)
 203
 204         me.assertFalse(rview > rview2)
 205         me.assertTrue(superset > rview)
 206         me.assertFalse(rview > superset)
 207         me.assertFalse(empty > rview)
 208         if any:
 209           me.assertTrue(rview > empty)
 210           me.assertTrue(rview > subset)
 211           me.assertFalse(subset > rview)
 212
 213     else:
 214       for listfn, getfn in [(lambda x: x.keys(), me._getkey),
 215                             (lambda x: x.values(), me._getvalue),
 216                             (lambda x: x.items(), me._getitem)]:
 217         rlist, mlist = listfn(map), listfn(model)
 218         me.assertEqual(type(rlist), list)
 219         rlist = B.map(getfn, rlist)
 220         rlist.sort(); mlist.sort(); me.assertEqual(rlist, mlist)
 221       for iterfn, getfn in [(lambda x: x.iterkeys(), me._getkey),
 222                             (lambda x: x.itervalues(), me._getvalue),
 223                             (lambda x: x.iteritems(), me._getitem)]:
 224         me.assertEqual(set(imap(getfn, iterfn(map))), set(iterfn(model)))
 225
 226 class MutableMappingTestMixin (ImmutableMappingTextMixin):
 227
 228   ## Subclass stubs.
 229   def _mkvalue(me, i): return "v#%d" % i
 230
 231   def check_mapping(me, emptymapfn):
 232
 233     map = emptymapfn()
 234     me.assertEqual(len(map), 0)
 235
 236     if not PY3:
 237       def check_views():
 238         me.check_immutable_mapping(map, model)
 239     else:
 240       kview, iview, vview = map.keys(), map.items(), map.values()
 241       def check_views():
 242         me.check_immutable_mapping(map, model)
 243         me.assertEqual(set(imap(me._getkey, kview)), model.keys())
 244         me.assertEqual(set(imap(me._getitem, iview)), model.items())
 245         me.assertEqual(set(imap(me._getvalue, vview)), set(model.values()))
 246
 247     model = { 1: 101, 2: 202, 4: 404 }
 248     for k, v in iteritems(model): map[me._mkkey(k)] = me._mkvalue(v)
 249     check_views()
 250
 251     model.update({ 2: 212, 6: 606, 7: 707 })
 252     map.update({ me._mkkey(2): me._mkvalue(212),
 253                  me._mkkey(6): me._mkvalue(606) },
 254                **{ me._mkkey(7): me._mkvalue(707) })
 255     check_views()
 256
 257     model[9] = 909
 258     map[me._mkkey(9)] = me._mkvalue(909)
 259     check_views()
 260
 261     model[9] = 919
 262     map[me._mkkey(9)] = me._mkvalue(919)
 263     check_views()
 264
 265     map.setdefault(me._mkkey(9), me._mkvalue(929))
 266     check_views()
 267
 268     model[8] = 808
 269     map.setdefault(me._mkkey(8), me._mkvalue(808))
 270     check_views()
 271
 272     me.assertRaises(KeyError, map.pop, me._mkkey(5))
 273     obj = object()
 274     me.assertEqual(map.pop(me._mkkey(5), obj), obj)
 275     me.assertEqual(me._getvalue(map.pop(me._mkkey(8))), 808)
 276     del model[8]
 277     check_views()
 278
 279     del model[9]
 280     del map[me._mkkey(9)]
 281     check_views()
 282
 283     k, v = map.popitem()
 284     mk, mv = me._getkey(k), me._getvalue(v)
 285     me.assertEqual(model[mk], mv)
 286     del model[mk]
 287     check_views()
 288
 289     map.clear()
 290     model = {}
 291     check_views()
 292
 293 class Explosion (Exception): pass
 294
 295 class EventRecorder (C.PrimeGenEventHandler):
 296   def __init__(me, parent = None, explode_after = None, *args, **kw):
 297     super(EventRecorder, me).__init__(*args, **kw)
 298     me._streak = 0
 299     me._op = None
 300     me._parent = parent
 301     me._countdown = explode_after
 302     me.rng = None
 303     if parent is None: me._buf = StringIO()
 304     else: me._buf = parent._buf
 305   def _event_common(me, ev):
 306     if me.rng is None: me.rng = ev.rng
 307     if me._countdown is None: pass
 308     elif me._countdown == 0: raise Explosion()
 309     else: me._countdown -= 1
 310   def _put(me, op):
 311     if op == me._op:
 312       me._streak += 1
 313     else:
 314       if me._op is not None: me._buf.write("%s%d/" % (me._op, me._streak))
 315       me._op = op
 316       me._streak = 1
 317   def pg_begin(me, ev):
 318     me._event_common(ev)
 319     me._buf.write("[%s:" % ev.name)
 320   def pg_try(me, ev):
 321     me._event_common(ev)
 322   def pg_fail(me, ev):
 323     me._event_common(ev)
 324     me._put("F")
 325   def pg_pass(me, ev):
 326     me._event_common(ev)
 327     me._put("P")
 328   def pg_done(me, ev):
 329     me._event_common(ev)
 330     me._put(None); me._buf.write("D]")
 331   def pg_abort(me, ev):
 332     me._event_common(ev)
 333     me._put(None); me._buf.write("A]")
 334   @property
 335   def events(me):
 336     return me._buf.getvalue()
 337
 338 ## Functions for operators.
 339 neg = lambda x: -x
 340 pos = lambda x: +x
 341 add = lambda x, y: x + y
 342 sub = lambda x, y: x - y
 343 mul = lambda x, y: x*y
 344 div = lambda x, y: x/y
 345 mod = lambda x, y: x%y
 346 floordiv = lambda x, y: x//y
 347 bitand = lambda x, y: x&y
 348 bitor = lambda x, y: x | y
 349 bitxor = lambda x, y: x ^ y
 350 bitnot = lambda x: ~x
 351 lsl = lambda x, y: x << y
 352 lsr = lambda x, y: x >> y
 353 eq = lambda x, y: x == y
 354 ne = lambda x, y: x != y
 355 lt = lambda x, y: x < y
 356 le = lambda x, y: x <= y
 357 ge = lambda x, y: x >= y
 358 gt = lambda x, y: x > y
 359
 360 ###----- That's all, folks --------------------------------------------------