5 ### (c) 2019 Straylight/Edgeware
8 ###----- Licensing notice ---------------------------------------------------
10 ### This file is part of the Python interface to mLib.
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.
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.
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,
27 ###--------------------------------------------------------------------------
31 import contextlib
as CTX
34 if SYS
.version_info
>= (3,): import builtins
as B
35 else: import __builtin__
as B
38 ###--------------------------------------------------------------------------
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
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
57 PY2
, PY3
= True, False
59 def py23(x
, y
): return x
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
72 for f
in [SYS
.stdout
, SYS
.stderr
]: f
.flush()
75 old_stderr_fd
= OS
.dup(2)
78 for f
in [SYS
.stdout
, SYS
.stderr
]: f
.flush()
79 OS
.dup2(old_stderr_fd
, 2)
80 SYS
.excepthook(*SYS
.exc_info())
84 for f
in [SYS
.stdout
, SYS
.stderr
]: f
.flush()
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
)
92 rc
= OS
.WEXITSTATUS(st
)
93 if rc
!= 0: test
.fail("child exited with status %d" % rc
)
97 class ImmutableMappingTextMixin (U
.TestCase
):
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
)
105 def check_immutable_mapping(me
, map, model
):
110 me
.assertEqual(len(map), len(model
))
111 for k
, v
in iteritems(model
):
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)
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())
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
))
144 if any
: subset
= set(rview2
); subset
.pop()
145 superset
= set(rview2
); superset
.add(object())
147 me
.assertFalse(rview
< rview2
)
148 me
.assertTrue(rview
< superset
)
149 me
.assertFalse(superset
< rview
)
150 me
.assertFalse(rview
< empty
)
152 me
.assertTrue(empty
< rview
)
153 me
.assertTrue(subset
< rview
)
154 me
.assertFalse(rview
< subset
)
156 me
.assertTrue(rview
<= rview2
)
157 me
.assertTrue(rview
<= superset
)
158 me
.assertFalse(superset
<= rview
)
160 me
.assertTrue(empty
<= rview
)
161 me
.assertFalse(rview
<= empty
)
162 me
.assertTrue(subset
<= rview
)
163 me
.assertFalse(rview
<= subset
)
165 me
.assertTrue(rview
>= rview2
)
166 me
.assertTrue(superset
>= rview
)
167 me
.assertFalse(rview
>= superset
)
169 me
.assertTrue(rview
>= empty
)
170 me
.assertFalse(empty
>= rview
)
171 me
.assertTrue(rview
>= subset
)
172 me
.assertFalse(subset
>= rview
)
174 me
.assertFalse(rview
> rview2
)
175 me
.assertTrue(superset
> rview
)
176 me
.assertFalse(rview
> superset
)
177 me
.assertFalse(empty
> rview
)
179 me
.assertTrue(rview
> empty
)
180 me
.assertTrue(rview
> subset
)
181 me
.assertFalse(subset
> rview
)
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
)))
196 class MutableMappingTestMixin (ImmutableMappingTextMixin
):
199 def _mkvalue(me
, i
): return "v#%d" % i
201 def check_mapping(me
, emptymapfn
):
204 me
.assertEqual(len(map), 0)
208 me
.check_immutable_mapping(map, model
)
210 kview
, iview
, vview
= map.keys(), map.items(), map.values()
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()))
217 model
= { 1: 101, 2: 202, 4: 404 }
218 for k
, v
in iteritems(model
): map[me
._mkkey(k
)] = me
._mkvalue(v
)
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) })
228 map[me
._mkkey(9)] = me
._mkvalue(909)
232 map[me
._mkkey(9)] = me
._mkvalue(919)
235 map.setdefault(me
._mkkey(9), me
._mkvalue(929))
239 map.setdefault(me
._mkkey(8), me
._mkvalue(808))
242 me
.assertRaises(KeyError, map.pop
, me
._mkkey(5))
244 me
.assertEqual(map.pop(me
._mkkey(5), obj
), obj
)
245 me
.assertEqual(me
._getvalue(map.pop(me
._mkkey(8))), 808)
250 del map[me
._mkkey(9)]
254 mk
, mv
= me
._getkey(k
), me
._getvalue(v
)
255 me
.assertEqual(model
[mk
], mv
)
263 ###----- That's all, folks --------------------------------------------------