def test_misbehavin(self):
class Misb:
def __lt__(self_, other): return 0
def __gt__(self_, other): return 0
def __eq__(self_, other): return 0
def __le__(self_, other): self.fail("This shouldn't happen")
def __ge__(self_, other): self.fail("This shouldn't happen")
def __ne__(self_, other): self.fail("This shouldn't happen")
a = Misb()
b = Misb()
self.assertEqual(a<b, 0)
self.assertEqual(a==b, 0)
self.assertEqual(a>b, 0)
python类__lt__()的实例源码
def test_goodentry(self):
# This test exercises the final call to PyObject_RichCompare()
# in Objects/listobject.c::list_richcompare()
class Good:
def __lt__(self, other):
return True
x = [Good()]
y = [Good()]
for op in opmap["lt"]:
self.assertIs(op(x, y), True)
def __lt__(self, other):
return self.x < other
def __lt__(self, other):
return Vector([a < b for a, b in zip(self.data, self.__cast(other))])
def test_misbehavin(self):
class Misb:
def __lt__(self_, other): return 0
def __gt__(self_, other): return 0
def __eq__(self_, other): return 0
def __le__(self_, other): self.fail("This shouldn't happen")
def __ge__(self_, other): self.fail("This shouldn't happen")
def __ne__(self_, other): self.fail("This shouldn't happen")
def __cmp__(self_, other): raise RuntimeError, "expected"
a = Misb()
b = Misb()
self.assertEqual(a<b, 0)
self.assertEqual(a==b, 0)
self.assertEqual(a>b, 0)
self.assertRaises(RuntimeError, cmp, a, b)
def test_goodentry(self):
# This test exercises the final call to PyObject_RichCompare()
# in Objects/listobject.c::list_richcompare()
class Good:
def __lt__(self, other):
return True
x = [Good()]
y = [Good()]
for op in opmap["lt"]:
self.assertIs(op(x, y), True)
def assert_array_less(x, y, err_msg='', verbose=True):
"""
Checks that x is smaller than y elementwise.
"""
assert_array_compare(operator.__lt__, x, y,
err_msg=err_msg, verbose=verbose,
header='Arrays are not less-ordered')
def assert_array_less(x, y, err_msg='', verbose=True):
"""
Checks that x is smaller than y elementwise.
"""
assert_array_compare(operator.__lt__, x, y,
err_msg=err_msg, verbose=verbose,
header='Arrays are not less-ordered')
def __lt__(self, other):
return self.x < other
def __lt__(self, other):
return Vector([a < b for a, b in zip(self.data, self.__cast(other))])
def test_misbehavin(self):
class Misb:
def __lt__(self_, other): return 0
def __gt__(self_, other): return 0
def __eq__(self_, other): return 0
def __le__(self_, other): self.fail("This shouldn't happen")
def __ge__(self_, other): self.fail("This shouldn't happen")
def __ne__(self_, other): self.fail("This shouldn't happen")
a = Misb()
b = Misb()
self.assertEqual(a<b, 0)
self.assertEqual(a==b, 0)
self.assertEqual(a>b, 0)
def test_goodentry(self):
# This test exercises the final call to PyObject_RichCompare()
# in Objects/listobject.c::list_richcompare()
class Good:
def __lt__(self, other):
return True
x = [Good()]
y = [Good()]
for op in opmap["lt"]:
self.assertIs(op(x, y), True)
def lessThan(typeA, typeB):
if operator.__lt__(typeA.number.getNum(), typeB.number.getNum()):
return True
else:
return False
def __lt__(self, other):
return self.__comparator__(other, operator.__lt__)
def test_lt(self):
self._test_incompatible_types_fail(operator.__lt__)
self.assertFalse(no_flags < no_flags)
self.assertTrue(no_flags < all_flags)
self.assertTrue(no_flags < f0)
self.assertTrue(no_flags < f1)
self.assertTrue(no_flags < f2)
self.assertTrue(no_flags < f01)
self.assertTrue(no_flags < f02)
self.assertTrue(no_flags < f12)
self.assertFalse(f0 < no_flags)
self.assertTrue(f0 < all_flags)
self.assertFalse(f0 < f0)
self.assertFalse(f0 < f1)
self.assertFalse(f0 < f2)
self.assertTrue(f0 < f01)
self.assertTrue(f0 < f02)
self.assertFalse(f0 < f12)
self.assertFalse(f01 < no_flags)
self.assertTrue(f01 < all_flags)
self.assertFalse(f01 < f0)
self.assertFalse(f01 < f1)
self.assertFalse(f01 < f2)
self.assertFalse(f01 < f01)
self.assertFalse(f01 < f02)
self.assertFalse(f01 < f12)
self.assertTrue(no_flags < all_flags)
self.assertFalse(all_flags < all_flags)
self.assertTrue(f0 < all_flags)
self.assertTrue(f1 < all_flags)
self.assertTrue(f2 < all_flags)
self.assertTrue(f01 < all_flags)
self.assertTrue(f02 < all_flags)
self.assertTrue(f12 < all_flags)
def assert_array_less(x, y, err_msg='', verbose=True):
"""
Checks that x is smaller than y elementwise.
"""
assert_array_compare(operator.__lt__, x, y,
err_msg=err_msg, verbose=verbose,
header='Arrays are not less-ordered')
