[mLib-python] / t / testutils.py

### -*-python-*-
###
### Test utilities
###
### (c) 2019 Straylight/Edgeware
###

###----- Licensing notice ---------------------------------------------------
###
### This file is part of the Python interface to mLib.
###
### mLib/Python is free software: you can redistribute it and/or modify it
### under the terms of the GNU General Public License as published by the
### Free Software Foundation; either version 2 of the License, or (at your
### option) any later version.
###
### mLib/Python is distributed in the hope that it will be useful, but
### WITHOUT ANY WARRANTY; without even the implied warranty of
### MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
### General Public License for more details.
###
### You should have received a copy of the GNU General Public License
### along with mLib/Python.  If not, write to the Free Software
### Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
### USA.

###--------------------------------------------------------------------------
### Imported modules.

import mLib as M
import contextlib as CTX
import os as OS
import sys as SYS
if SYS.version_info >= (3,): import builtins as B
else: import __builtin__ as B
import unittest as U

###--------------------------------------------------------------------------
### Main code.

## Some compatibility hacks.
if SYS.version_info >= (3,):
  PY2, PY3 = False, True
  def bin(x): return x.encode('iso8859-1')
  def py23(x, y): return y
  range = range
  byteseq = bytes
  long = int
  imap = map
  def iterkeys(m): return m.keys()
  def itervalues(m): return m.values()
  def iteritems(m): return m.items()
  from io import StringIO
  MAXFIXNUM = SYS.maxsize
else:
  import itertools as I
  PY2, PY3 = True, False
  def bin(x): return x
  def py23(x, y): return x
  range = xrange
  long = long
  imap = I.imap
  def byteseq(seq): return "".join(map(chr, seq))
  def iterkeys(m): return m.iterkeys()
  def itervalues(m): return m.itervalues()
  def iteritems(m): return m.iteritems()
  from cStringIO import StringIO
  MAXFIXNUM = SYS.maxint

def subprocess(fn):
  def func(test):
    for f in [SYS.stdout, SYS.stderr]: f.flush()
    kid = OS.fork()
    if kid == 0:
      old_stderr_fd = OS.dup(2)
      try: fn(test)
      except:
        for f in [SYS.stdout, SYS.stderr]: f.flush()
        OS.dup2(old_stderr_fd, 2)
        SYS.excepthook(*SYS.exc_info())
        SYS.stderr.flush()
        OS._exit(111)
      else:
        for f in [SYS.stdout, SYS.stderr]: f.flush()
        OS._exit(0)
    _, st = OS.waitpid(kid, 0)
    if OS.WIFSIGNALED(st):
      test.fail("child killed by signal %d" % OS.WTERMSIG(st))
    elif not OS.WIFEXITED(st):
      test.fail("child terminated with unknown status %x" % st)
    else:
      rc = OS.WEXITSTATUS(st)
      if rc != 0: test.fail("child exited with status %d" % rc)
  return func


class ImmutableMappingTextMixin (U.TestCase):

  ## Subclass stubs.
  def _mkkey(me, i): return "k#%d" % i
  def _getkey(me, k): return int(k[2:])
  def _getvalue(me, v): return int(v[2:])
  def _getitem(me, it): k, v = it; return me._getkey(k), me._getvalue(v)

  def check_immutable_mapping(me, map, model):

    ## Lookup.
    limk = 0
    any = False
    me.assertEqual(len(map), len(model))
    for k, v in iteritems(model):
      any = True
      if k >= limk: limk = k + 1
      me.assertTrue(me._mkkey(k) in map)
      if PY2: me.assertTrue(map.has_key(me._mkkey(k)))
      me.assertEqual(me._getvalue(map[me._mkkey(k)]), v)
      me.assertEqual(me._getvalue(map.get(me._mkkey(k))), v)
    if any: me.assertTrue(me._mkkey(k) in map)
    if PY2: me.assertFalse(map.has_key(me._mkkey(limk)))
    me.assertRaises(KeyError, lambda: map[me._mkkey(limk)])
    me.assertEqual(map.get(me._mkkey(limk)), None)

    if PY3:
      empty = set()

      for k, v in iteritems(map):
        me.assertTrue(k in map.keys())
        me.assertTrue((k, v) in map.items())
      me.assertFalse(me._mkkey(limk) in map.keys())

      for viewfn, getfn in [(lambda x: x.keys(), me._getkey),
                            (lambda x: x.items(), me._getitem)]:
        rview, rview2, mview = viewfn(map), viewfn(map), viewfn(model)
        me.assertEqual(set(imap(getfn, rview)), set(mview))
        me.assertEqual(rview, rview2)
        me.assertEqual(rview, set(rview2))
        me.assertEqual(rview | empty, set(rview))
        me.assertEqual(rview | rview2, set(rview))
        me.assertEqual(rview ^ empty, set(rview))
        me.assertEqual(rview ^ rview, empty)
        me.assertEqual(rview & empty, empty)
        me.assertEqual(len(rview), len(model))

        if any: subset = set(rview2); subset.pop()
        superset = set(rview2); superset.add(object())

        me.assertFalse(rview < rview2)
        me.assertTrue(rview < superset)
        me.assertFalse(superset < rview)
        me.assertFalse(rview < empty)
        if any:
          me.assertTrue(empty < rview)
          me.assertTrue(subset < rview)
          me.assertFalse(rview < subset)

        me.assertTrue(rview <= rview2)
        me.assertTrue(rview <= superset)
        me.assertFalse(superset <= rview)
        if any:
          me.assertTrue(empty <= rview)
          me.assertFalse(rview <= empty)
          me.assertTrue(subset <= rview)
          me.assertFalse(rview <= subset)

        me.assertTrue(rview >= rview2)
        me.assertTrue(superset >= rview)
        me.assertFalse(rview >= superset)
        if any:
          me.assertTrue(rview >= empty)
          me.assertFalse(empty >= rview)
          me.assertTrue(rview >= subset)
          me.assertFalse(subset >= rview)

        me.assertFalse(rview > rview2)
        me.assertTrue(superset > rview)
        me.assertFalse(rview > superset)
        me.assertFalse(empty > rview)
        if any:
          me.assertTrue(rview > empty)
          me.assertTrue(rview > subset)
          me.assertFalse(subset > rview)

    else:
      for listfn, getfn in [(lambda x: x.keys(), me._getkey),
                            (lambda x: x.values(), me._getvalue),
                            (lambda x: x.items(), me._getitem)]:
        rlist, mlist = listfn(map), listfn(model)
        me.assertEqual(type(rlist), list)
        rlist = B.map(getfn, rlist)
        rlist.sort(); mlist.sort(); me.assertEqual(rlist, mlist)
      for iterfn, getfn in [(lambda x: x.iterkeys(), me._getkey),
                            (lambda x: x.itervalues(), me._getvalue),
                            (lambda x: x.iteritems(), me._getitem)]:
        me.assertEqual(set(imap(getfn, iterfn(map))), set(iterfn(model)))

class MutableMappingTestMixin (ImmutableMappingTextMixin):

  ## Subclass stubs.
  def _mkvalue(me, i): return "v#%d" % i

  def check_mapping(me, emptymapfn):

    map = emptymapfn()
    me.assertEqual(len(map), 0)

    if not PY3:
      def check_views():
        me.check_immutable_mapping(map, model)
    else:
      kview, iview, vview = map.keys(), map.items(), map.values()
      def check_views():
        me.check_immutable_mapping(map, model)
        me.assertEqual(set(imap(me._getkey, kview)), model.keys())
        me.assertEqual(set(imap(me._getitem, iview)), model.items())
        me.assertEqual(set(imap(me._getvalue, vview)), set(model.values()))

    model = { 1: 101, 2: 202, 4: 404 }
    for k, v in iteritems(model): map[me._mkkey(k)] = me._mkvalue(v)
    check_views()

    model.update({ 2: 212, 6: 606, 7: 707 })
    map.update({ me._mkkey(2): me._mkvalue(212),
                 me._mkkey(6): me._mkvalue(606) },
               **{ me._mkkey(7): me._mkvalue(707) })
    check_views()

    model[9] = 909
    map[me._mkkey(9)] = me._mkvalue(909)
    check_views()

    model[9] = 919
    map[me._mkkey(9)] = me._mkvalue(919)
    check_views()

    map.setdefault(me._mkkey(9), me._mkvalue(929))
    check_views()

    model[8] = 808
    map.setdefault(me._mkkey(8), me._mkvalue(808))
    check_views()

    me.assertRaises(KeyError, map.pop, me._mkkey(5))
    obj = object()
    me.assertEqual(map.pop(me._mkkey(5), obj), obj)
    me.assertEqual(me._getvalue(map.pop(me._mkkey(8))), 808)
    del model[8]
    check_views()

    del model[9]
    del map[me._mkkey(9)]
    check_views()

    k, v = map.popitem()
    mk, mv = me._getkey(k), me._getvalue(v)
    me.assertEqual(model[mk], mv)
    del model[mk]
    check_views()

    map.clear()
    model = {}
    check_views()

###----- That's all, folks --------------------------------------------------
Commit	Line	Data
81f68b64 MW	1	### --python--
	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 mLib.
	11	###
	12	### mLib/Python is free software: you can redistribute it and/or modify it
	13	### under the terms of the GNU General Public License as published by the
	14	### Free Software Foundation; either version 2 of the License, or (at your
	15	### option) any later version.
	16	###
	17	### mLib/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 mLib/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 mLib as M
	31	import contextlib as CTX
	32	import os as OS
	33	import sys as SYS
	34	if SYS.version_info >= (3,): import builtins as B
	35	else: import __builtin__ as B
	36	import unittest as U
	37
	38	###--------------------------------------------------------------------------
	39	### Main code.
	40
	41	## Some compatibility hacks.
	42	if SYS.version_info >= (3,):
	43	PY2, PY3 = False, True
	44	def bin(x): return x.encode('iso8859-1')
	45	def py23(x, y): return y
	46	range = range
	47	byteseq = bytes
	48	long = int
	49	imap = map
	50	def iterkeys(m): return m.keys()
	51	def itervalues(m): return m.values()
	52	def iteritems(m): return m.items()
	53	from io import StringIO
	54	MAXFIXNUM = SYS.maxsize
	55	else:
	56	import itertools as I
	57	PY2, PY3 = True, False
	58	def bin(x): return x
	59	def py23(x, y): return x
	60	range = xrange
	61	long = long
	62	imap = I.imap
	63	def byteseq(seq): return "".join(map(chr, seq))
	64	def iterkeys(m): return m.iterkeys()
65	def itervalues(m): return m.itervalues()
66	def iteritems(m): return m.iteritems()
67	from cStringIO import StringIO
68	MAXFIXNUM = SYS.maxint
69
70	def subprocess(fn):
71	def func(test):
72	for f in [SYS.stdout, SYS.stderr]: f.flush()
73	kid = OS.fork()
74	if kid == 0:
75	old_stderr_fd = OS.dup(2)
76	try: fn(test)
77	except:
78	for f in [SYS.stdout, SYS.stderr]: f.flush()
79	OS.dup2(old_stderr_fd, 2)
80	SYS.excepthook(*SYS.exc_info())
81	SYS.stderr.flush()
82	OS._exit(111)
83	else:
84	for f in [SYS.stdout, SYS.stderr]: f.flush()
85	OS._exit(0)
86	_, st = OS.waitpid(kid, 0)
87	if OS.WIFSIGNALED(st):
88	test.fail("child killed by signal %d" % OS.WTERMSIG(st))
89	elif not OS.WIFEXITED(st):
90	test.fail("child terminated with unknown status %x" % st)
91	else:
92	rc = OS.WEXITSTATUS(st)
93	if rc != 0: test.fail("child exited with status %d" % rc)
94	return func
95
96
97	class ImmutableMappingTextMixin (U.TestCase):
98
99	## Subclass stubs.
100	def _mkkey(me, i): return "k#%d" % i
101	def _getkey(me, k): return int(k[2:])
102	def _getvalue(me, v): return int(v[2:])
103	def _getitem(me, it): k, v = it; return me._getkey(k), me._getvalue(v)
104
105	def check_immutable_mapping(me, map, model):
106
107	## Lookup.
108	limk = 0
109	any = False
110	me.assertEqual(len(map), len(model))
111	for k, v in iteritems(model):
112	any = True
113	if k >= limk: limk = k + 1
114	me.assertTrue(me._mkkey(k) in map)
115	if PY2: me.assertTrue(map.has_key(me._mkkey(k)))
116	me.assertEqual(me._getvalue(map[me._mkkey(k)]), v)
117	me.assertEqual(me._getvalue(map.get(me._mkkey(k))), v)
118	if any: me.assertTrue(me._mkkey(k) in map)
119	if PY2: me.assertFalse(map.has_key(me._mkkey(limk)))
120	me.assertRaises(KeyError, lambda: map[me._mkkey(limk)])
121	me.assertEqual(map.get(me._mkkey(limk)), None)
122
123	if PY3:
124	empty = set()
125
126	for k, v in iteritems(map):
127	me.assertTrue(k in map.keys())
128	me.assertTrue((k, v) in map.items())
129	me.assertFalse(me._mkkey(limk) in map.keys())
130
131	for viewfn, getfn in [(lambda x: x.keys(), me._getkey),
132	(lambda x: x.items(), me._getitem)]:
133	rview, rview2, mview = viewfn(map), viewfn(map), viewfn(model)
134	me.assertEqual(set(imap(getfn, rview)), set(mview))
135	me.assertEqual(rview, rview2)
136	me.assertEqual(rview, set(rview2))
137	me.assertEqual(rview \| empty, set(rview))
138	me.assertEqual(rview \| rview2, set(rview))
139	me.assertEqual(rview ^ empty, set(rview))
140	me.assertEqual(rview ^ rview, empty)
141	me.assertEqual(rview & empty, empty)
142	me.assertEqual(len(rview), len(model))
143
144	if any: subset = set(rview2); subset.pop()
145	superset = set(rview2); superset.add(object())
146
147	me.assertFalse(rview < rview2)
148	me.assertTrue(rview < superset)
149	me.assertFalse(superset < rview)
150	me.assertFalse(rview < empty)
151	if any:
152	me.assertTrue(empty < rview)
153	me.assertTrue(subset < rview)
154	me.assertFalse(rview < subset)
155
156	me.assertTrue(rview <= rview2)
157	me.assertTrue(rview <= superset)
158	me.assertFalse(superset <= rview)
159	if any:
160	me.assertTrue(empty <= rview)
161	me.assertFalse(rview <= empty)
162	me.assertTrue(subset <= rview)
163	me.assertFalse(rview <= subset)
164
165	me.assertTrue(rview >= rview2)
166	me.assertTrue(superset >= rview)
167	me.assertFalse(rview >= superset)
168	if any:
169	me.assertTrue(rview >= empty)
170	me.assertFalse(empty >= rview)
171	me.assertTrue(rview >= subset)
172	me.assertFalse(subset >= rview)
173
174	me.assertFalse(rview > rview2)
175	me.assertTrue(superset > rview)
176	me.assertFalse(rview > superset)
177	me.assertFalse(empty > rview)
178	if any:
179	me.assertTrue(rview > empty)
180	me.assertTrue(rview > subset)
181	me.assertFalse(subset > rview)
182
183	else:
184	for listfn, getfn in [(lambda x: x.keys(), me._getkey),
185	(lambda x: x.values(), me._getvalue),
186	(lambda x: x.items(), me._getitem)]:
187	rlist, mlist = listfn(map), listfn(model)
188	me.assertEqual(type(rlist), list)
189	rlist = B.map(getfn, rlist)
190	rlist.sort(); mlist.sort(); me.assertEqual(rlist, mlist)
191	for iterfn, getfn in [(lambda x: x.iterkeys(), me._getkey),
192	(lambda x: x.itervalues(), me._getvalue),
193	(lambda x: x.iteritems(), me._getitem)]:
194	me.assertEqual(set(imap(getfn, iterfn(map))), set(iterfn(model)))
195
196	class MutableMappingTestMixin (ImmutableMappingTextMixin):
197
198	## Subclass stubs.
199	def _mkvalue(me, i): return "v#%d" % i
200
201	def check_mapping(me, emptymapfn):
202
203	map = emptymapfn()
204	me.assertEqual(len(map), 0)
205
206	if not PY3:
207	def check_views():
208	me.check_immutable_mapping(map, model)
209	else:
210	kview, iview, vview = map.keys(), map.items(), map.values()
211	def check_views():
212	me.check_immutable_mapping(map, model)
213	me.assertEqual(set(imap(me._getkey, kview)), model.keys())
214	me.assertEqual(set(imap(me._getitem, iview)), model.items())
215	me.assertEqual(set(imap(me._getvalue, vview)), set(model.values()))
216
217	model = { 1: 101, 2: 202, 4: 404 }
218	for k, v in iteritems(model): map[me._mkkey(k)] = me._mkvalue(v)
219	check_views()
220
221	model.update({ 2: 212, 6: 606, 7: 707 })
222	map.update({ me._mkkey(2): me._mkvalue(212),
223	me._mkkey(6): me._mkvalue(606) },
224	**{ me._mkkey(7): me._mkvalue(707) })
225	check_views()
226
227	model[9] = 909
228	map[me._mkkey(9)] = me._mkvalue(909)
229	check_views()
230
231	model[9] = 919
232	map[me._mkkey(9)] = me._mkvalue(919)
233	check_views()
234
235	map.setdefault(me._mkkey(9), me._mkvalue(929))
236	check_views()
237
238	model[8] = 808
239	map.setdefault(me._mkkey(8), me._mkvalue(808))
240	check_views()
241
242	me.assertRaises(KeyError, map.pop, me._mkkey(5))
243	obj = object()
244	me.assertEqual(map.pop(me._mkkey(5), obj), obj)
245	me.assertEqual(me._getvalue(map.pop(me._mkkey(8))), 808)
246	del model[8]
247	check_views()
248
249	del model[9]
250	del map[me._mkkey(9)]
251	check_views()
252
253	k, v = map.popitem()
254	mk, mv = me._getkey(k), me._getvalue(v)
255	me.assertEqual(model[mk], mv)
256	del model[mk]
257	check_views()
258
259	map.clear()
260	model = {}
261	check_views()
262
263	###----- That's all, folks --------------------------------------------------