Python code coverage for Lib/test/test_richcmp.py

#	count	content
1	n/a	# Tests for rich comparisons
2	n/a
3	n/a	import unittest
4	n/a	from test import support
5	n/a
6	n/a	import operator
7	n/a
8	n/a	class Number:
9	n/a
10	n/a	def __init__(self, x):
11	n/a	self.x = x
12	n/a
13	n/a	def __lt__(self, other):
14	n/a	return self.x < other
15	n/a
16	n/a	def __le__(self, other):
17	n/a	return self.x <= other
18	n/a
19	n/a	def __eq__(self, other):
20	n/a	return self.x == other
21	n/a
22	n/a	def __ne__(self, other):
23	n/a	return self.x != other
24	n/a
25	n/a	def __gt__(self, other):
26	n/a	return self.x > other
27	n/a
28	n/a	def __ge__(self, other):
29	n/a	return self.x >= other
30	n/a
31	n/a	def __cmp__(self, other):
32	n/a	raise support.TestFailed("Number.__cmp__() should not be called")
33	n/a
34	n/a	def __repr__(self):
35	n/a	return "Number(%r)" % (self.x, )
36	n/a
37	n/a	class Vector:
38	n/a
39	n/a	def __init__(self, data):
40	n/a	self.data = data
41	n/a
42	n/a	def __len__(self):
43	n/a	return len(self.data)
44	n/a
45	n/a	def __getitem__(self, i):
46	n/a	return self.data[i]
47	n/a
48	n/a	def __setitem__(self, i, v):
49	n/a	self.data[i] = v
50	n/a
51	n/a	__hash__ = None # Vectors cannot be hashed
52	n/a
53	n/a	def __bool__(self):
54	n/a	raise TypeError("Vectors cannot be used in Boolean contexts")
55	n/a
56	n/a	def __cmp__(self, other):
57	n/a	raise support.TestFailed("Vector.__cmp__() should not be called")
58	n/a
59	n/a	def __repr__(self):
60	n/a	return "Vector(%r)" % (self.data, )
61	n/a
62	n/a	def __lt__(self, other):
63	n/a	return Vector([a < b for a, b in zip(self.data, self.__cast(other))])
64	n/a
65	n/a	def __le__(self, other):
66	n/a	return Vector([a <= b for a, b in zip(self.data, self.__cast(other))])
67	n/a
68	n/a	def __eq__(self, other):
69	n/a	return Vector([a == b for a, b in zip(self.data, self.__cast(other))])
70	n/a
71	n/a	def __ne__(self, other):
72	n/a	return Vector([a != b for a, b in zip(self.data, self.__cast(other))])
73	n/a
74	n/a	def __gt__(self, other):
75	n/a	return Vector([a > b for a, b in zip(self.data, self.__cast(other))])
76	n/a
77	n/a	def __ge__(self, other):
78	n/a	return Vector([a >= b for a, b in zip(self.data, self.__cast(other))])
79	n/a
80	n/a	def __cast(self, other):
81	n/a	if isinstance(other, Vector):
82	n/a	other = other.data
83	n/a	if len(self.data) != len(other):
84	n/a	raise ValueError("Cannot compare vectors of different length")
85	n/a	return other
86	n/a
87	n/a	opmap = {
88	n/a	"lt": (lambda a,b: a< b, operator.lt, operator.__lt__),
89	n/a	"le": (lambda a,b: a<=b, operator.le, operator.__le__),
90	n/a	"eq": (lambda a,b: a==b, operator.eq, operator.__eq__),
91	n/a	"ne": (lambda a,b: a!=b, operator.ne, operator.__ne__),
92	n/a	"gt": (lambda a,b: a> b, operator.gt, operator.__gt__),
93	n/a	"ge": (lambda a,b: a>=b, operator.ge, operator.__ge__)
94	n/a	}
95	n/a
96	n/a	class VectorTest(unittest.TestCase):
97	n/a
98	n/a	def checkfail(self, error, opname, *args):
99	n/a	for op in opmap[opname]:
100	n/a	self.assertRaises(error, op, *args)
101	n/a
102	n/a	def checkequal(self, opname, a, b, expres):
103	n/a	for op in opmap[opname]:
104	n/a	realres = op(a, b)
105	n/a	# can't use assertEqual(realres, expres) here
106	n/a	self.assertEqual(len(realres), len(expres))
107	n/a	for i in range(len(realres)):
108	n/a	# results are bool, so we can use "is" here
109	n/a	self.assertTrue(realres[i] is expres[i])
110	n/a
111	n/a	def test_mixed(self):
112	n/a	# check that comparisons involving Vector objects
113	n/a	# which return rich results (i.e. Vectors with itemwise
114	n/a	# comparison results) work
115	n/a	a = Vector(range(2))
116	n/a	b = Vector(range(3))
117	n/a	# all comparisons should fail for different length
118	n/a	for opname in opmap:
119	n/a	self.checkfail(ValueError, opname, a, b)
120	n/a
121	n/a	a = list(range(5))
122	n/a	b = 5 * [2]
123	n/a	# try mixed arguments (but not (a, b) as that won't return a bool vector)
124	n/a	args = [(a, Vector(b)), (Vector(a), b), (Vector(a), Vector(b))]
125	n/a	for (a, b) in args:
126	n/a	self.checkequal("lt", a, b, [True, True, False, False, False])
127	n/a	self.checkequal("le", a, b, [True, True, True, False, False])
128	n/a	self.checkequal("eq", a, b, [False, False, True, False, False])
129	n/a	self.checkequal("ne", a, b, [True, True, False, True, True ])
130	n/a	self.checkequal("gt", a, b, [False, False, False, True, True ])
131	n/a	self.checkequal("ge", a, b, [False, False, True, True, True ])
132	n/a
133	n/a	for ops in opmap.values():
134	n/a	for op in ops:
135	n/a	# calls __bool__, which should fail
136	n/a	self.assertRaises(TypeError, bool, op(a, b))
137	n/a
138	n/a	class NumberTest(unittest.TestCase):
139	n/a
140	n/a	def test_basic(self):
141	n/a	# Check that comparisons involving Number objects
142	n/a	# give the same results give as comparing the
143	n/a	# corresponding ints
144	n/a	for a in range(3):
145	n/a	for b in range(3):
146	n/a	for typea in (int, Number):
147	n/a	for typeb in (int, Number):
148	n/a	if typea==typeb==int:
149	n/a	continue # the combination int, int is useless
150	n/a	ta = typea(a)
151	n/a	tb = typeb(b)
152	n/a	for ops in opmap.values():
153	n/a	for op in ops:
154	n/a	realoutcome = op(a, b)
155	n/a	testoutcome = op(ta, tb)
156	n/a	self.assertEqual(realoutcome, testoutcome)
157	n/a
158	n/a	def checkvalue(self, opname, a, b, expres):
159	n/a	for typea in (int, Number):
160	n/a	for typeb in (int, Number):
161	n/a	ta = typea(a)
162	n/a	tb = typeb(b)
163	n/a	for op in opmap[opname]:
164	n/a	realres = op(ta, tb)
165	n/a	realres = getattr(realres, "x", realres)
166	n/a	self.assertTrue(realres is expres)
167	n/a
168	n/a	def test_values(self):
169	n/a	# check all operators and all comparison results
170	n/a	self.checkvalue("lt", 0, 0, False)
171	n/a	self.checkvalue("le", 0, 0, True )
172	n/a	self.checkvalue("eq", 0, 0, True )
173	n/a	self.checkvalue("ne", 0, 0, False)
174	n/a	self.checkvalue("gt", 0, 0, False)
175	n/a	self.checkvalue("ge", 0, 0, True )
176	n/a
177	n/a	self.checkvalue("lt", 0, 1, True )
178	n/a	self.checkvalue("le", 0, 1, True )
179	n/a	self.checkvalue("eq", 0, 1, False)
180	n/a	self.checkvalue("ne", 0, 1, True )
181	n/a	self.checkvalue("gt", 0, 1, False)
182	n/a	self.checkvalue("ge", 0, 1, False)
183	n/a
184	n/a	self.checkvalue("lt", 1, 0, False)
185	n/a	self.checkvalue("le", 1, 0, False)
186	n/a	self.checkvalue("eq", 1, 0, False)
187	n/a	self.checkvalue("ne", 1, 0, True )
188	n/a	self.checkvalue("gt", 1, 0, True )
189	n/a	self.checkvalue("ge", 1, 0, True )
190	n/a
191	n/a	class MiscTest(unittest.TestCase):
192	n/a
193	n/a	def test_misbehavin(self):
194	n/a	class Misb:
195	n/a	def __lt__(self_, other): return 0
196	n/a	def __gt__(self_, other): return 0
197	n/a	def __eq__(self_, other): return 0
198	n/a	def __le__(self_, other): self.fail("This shouldn't happen")
199	n/a	def __ge__(self_, other): self.fail("This shouldn't happen")
200	n/a	def __ne__(self_, other): self.fail("This shouldn't happen")
201	n/a	a = Misb()
202	n/a	b = Misb()
203	n/a	self.assertEqual(a<b, 0)
204	n/a	self.assertEqual(a==b, 0)
205	n/a	self.assertEqual(a>b, 0)
206	n/a
207	n/a	def test_not(self):
208	n/a	# Check that exceptions in __bool__ are properly
209	n/a	# propagated by the not operator
210	n/a	import operator
211	n/a	class Exc(Exception):
212	n/a	pass
213	n/a	class Bad:
214	n/a	def __bool__(self):
215	n/a	raise Exc
216	n/a
217	n/a	def do(bad):
218	n/a	not bad
219	n/a
220	n/a	for func in (do, operator.not_):
221	n/a	self.assertRaises(Exc, func, Bad())
222	n/a
223	n/a	@support.no_tracing
224	n/a	def test_recursion(self):
225	n/a	# Check that comparison for recursive objects fails gracefully
226	n/a	from collections import UserList
227	n/a	a = UserList()
228	n/a	b = UserList()
229	n/a	a.append(b)
230	n/a	b.append(a)
231	n/a	self.assertRaises(RecursionError, operator.eq, a, b)
232	n/a	self.assertRaises(RecursionError, operator.ne, a, b)
233	n/a	self.assertRaises(RecursionError, operator.lt, a, b)
234	n/a	self.assertRaises(RecursionError, operator.le, a, b)
235	n/a	self.assertRaises(RecursionError, operator.gt, a, b)
236	n/a	self.assertRaises(RecursionError, operator.ge, a, b)
237	n/a
238	n/a	b.append(17)
239	n/a	# Even recursive lists of different lengths are different,
240	n/a	# but they cannot be ordered
241	n/a	self.assertTrue(not (a == b))
242	n/a	self.assertTrue(a != b)
243	n/a	self.assertRaises(RecursionError, operator.lt, a, b)
244	n/a	self.assertRaises(RecursionError, operator.le, a, b)
245	n/a	self.assertRaises(RecursionError, operator.gt, a, b)
246	n/a	self.assertRaises(RecursionError, operator.ge, a, b)
247	n/a	a.append(17)
248	n/a	self.assertRaises(RecursionError, operator.eq, a, b)
249	n/a	self.assertRaises(RecursionError, operator.ne, a, b)
250	n/a	a.insert(0, 11)
251	n/a	b.insert(0, 12)
252	n/a	self.assertTrue(not (a == b))
253	n/a	self.assertTrue(a != b)
254	n/a	self.assertTrue(a < b)
255	n/a
256	n/a	def test_exception_message(self):
257	n/a	class Spam:
258	n/a	pass
259	n/a
260	n/a	tests = [
261	n/a	(lambda: 42 < None, r"'<' .* of 'int' and 'NoneType'"),
262	n/a	(lambda: None < 42, r"'<' .* of 'NoneType' and 'int'"),
263	n/a	(lambda: 42 > None, r"'>' .* of 'int' and 'NoneType'"),
264	n/a	(lambda: "foo" < None, r"'<' .* of 'str' and 'NoneType'"),
265	n/a	(lambda: "foo" >= 666, r"'>=' .* of 'str' and 'int'"),
266	n/a	(lambda: 42 <= None, r"'<=' .* of 'int' and 'NoneType'"),
267	n/a	(lambda: 42 >= None, r"'>=' .* of 'int' and 'NoneType'"),
268	n/a	(lambda: 42 < [], r"'<' .* of 'int' and 'list'"),
269	n/a	(lambda: () > [], r"'>' .* of 'tuple' and 'list'"),
270	n/a	(lambda: None >= None, r"'>=' .* of 'NoneType' and 'NoneType'"),
271	n/a	(lambda: Spam() < 42, r"'<' .* of 'Spam' and 'int'"),
272	n/a	(lambda: 42 < Spam(), r"'<' .* of 'int' and 'Spam'"),
273	n/a	(lambda: Spam() <= Spam(), r"'<=' .* of 'Spam' and 'Spam'"),
274	n/a	]
275	n/a	for i, test in enumerate(tests):
276	n/a	with self.subTest(test=i):
277	n/a	with self.assertRaisesRegex(TypeError, test[1]):
278	n/a	test[0]()
279	n/a
280	n/a
281	n/a	class DictTest(unittest.TestCase):
282	n/a
283	n/a	def test_dicts(self):
284	n/a	# Verify that __eq__ and __ne__ work for dicts even if the keys and
285	n/a	# values don't support anything other than __eq__ and __ne__ (and
286	n/a	# __hash__). Complex numbers are a fine example of that.
287	n/a	import random
288	n/a	imag1a = {}
289	n/a	for i in range(50):
290	n/a	imag1a[random.randrange(100)1j] = random.randrange(100)1j
291	n/a	items = list(imag1a.items())
292	n/a	random.shuffle(items)
293	n/a	imag1b = {}
294	n/a	for k, v in items:
295	n/a	imag1b[k] = v
296	n/a	imag2 = imag1b.copy()
297	n/a	imag2[k] = v + 1.0
298	n/a	self.assertEqual(imag1a, imag1a)
299	n/a	self.assertEqual(imag1a, imag1b)
300	n/a	self.assertEqual(imag2, imag2)
301	n/a	self.assertTrue(imag1a != imag2)
302	n/a	for opname in ("lt", "le", "gt", "ge"):
303	n/a	for op in opmap[opname]:
304	n/a	self.assertRaises(TypeError, op, imag1a, imag2)
305	n/a
306	n/a	class ListTest(unittest.TestCase):
307	n/a
308	n/a	def test_coverage(self):
309	n/a	# exercise all comparisons for lists
310	n/a	x = [42]
311	n/a	self.assertIs(x<x, False)
312	n/a	self.assertIs(x<=x, True)
313	n/a	self.assertIs(x==x, True)
314	n/a	self.assertIs(x!=x, False)
315	n/a	self.assertIs(x>x, False)
316	n/a	self.assertIs(x>=x, True)
317	n/a	y = [42, 42]
318	n/a	self.assertIs(x<y, True)
319	n/a	self.assertIs(x<=y, True)
320	n/a	self.assertIs(x==y, False)
321	n/a	self.assertIs(x!=y, True)
322	n/a	self.assertIs(x>y, False)
323	n/a	self.assertIs(x>=y, False)
324	n/a
325	n/a	def test_badentry(self):
326	n/a	# make sure that exceptions for item comparison are properly
327	n/a	# propagated in list comparisons
328	n/a	class Exc(Exception):
329	n/a	pass
330	n/a	class Bad:
331	n/a	def __eq__(self, other):
332	n/a	raise Exc
333	n/a
334	n/a	x = [Bad()]
335	n/a	y = [Bad()]
336	n/a
337	n/a	for op in opmap["eq"]:
338	n/a	self.assertRaises(Exc, op, x, y)
339	n/a
340	n/a	def test_goodentry(self):
341	n/a	# This test exercises the final call to PyObject_RichCompare()
342	n/a	# in Objects/listobject.c::list_richcompare()
343	n/a	class Good:
344	n/a	def __lt__(self, other):
345	n/a	return True
346	n/a
347	n/a	x = [Good()]
348	n/a	y = [Good()]
349	n/a
350	n/a	for op in opmap["lt"]:
351	n/a	self.assertIs(op(x, y), True)
352	n/a
353	n/a
354	n/a	if __name__ == "__main__":
355	n/a	unittest.main()