"Test the functionality of Python classes implementing operators." from test.test_support import TestFailed testmeths = [ # Binary operations "add", "radd", "sub", "rsub", "mul", "rmul", "truediv", "rtruediv", "mod", "rmod", "divmod", "rdivmod", "pow", "rpow", "rshift", "rrshift", "lshift", "rlshift", "and", "rand", "or", "ror", "xor", "rxor", # List/dict operations "contains", "getitem", "getslice", "setitem", "setslice", "delitem", "delslice", # Unary operations "neg", "pos", "abs", # generic operations "init", ] # These need to return something other than None # "hash", # "str", # "repr", # "int", # "long", # "float", # "oct", # "hex", # These are separate because they can influence the test of other methods. # "getattr", # "setattr", # "delattr", class AllTests: def __hash__(self, *args): print("__hash__:", args) return hash(id(self)) def __str__(self, *args): print("__str__:", args) return "AllTests" def __repr__(self, *args): print("__repr__:", args) return "AllTests" def __int__(self, *args): print("__int__:", args) return 1 def __float__(self, *args): print("__float__:", args) return 1.0 def __oct__(self, *args): print("__oct__:", args) return '01' def __hex__(self, *args): print("__hex__:", args) return '0x1' def __cmp__(self, *args): print("__cmp__:", args) return 0 def __eq__(self, *args): print("__eq__:", args) return True def __ne__(self, *args): print("__ne__:", args) return False def __lt__(self, *args): print("__lt__:", args) return False def __le__(self, *args): print("__le__:", args) return True def __gt__(self, *args): print("__gt__:", args) return False def __ge__(self, *args): print("__ge__:", args) return True def __del__(self, *args): print("__del__:", args) # Synthesize AllTests methods from the names in testmeths. method_template = """\ def __%(method)s__(self, *args): print "__%(method)s__:", args """ d = {} for method in testmeths: exec(method_template % locals(), d) for k in d: setattr(AllTests, k, d[k]) del d, k del method, method_template # this also tests __init__ of course. testme = AllTests() # Binary operations testme + 1 1 + testme testme - 1 1 - testme testme * 1 1 * testme testme / 1 1 / testme testme % 1 1 % testme divmod(testme,1) divmod(1, testme) testme ** 1 1 ** testme testme >> 1 1 >> testme testme << 1 1 << testme testme & 1 1 & testme testme | 1 1 | testme testme ^ 1 1 ^ testme # List/dict operations class Empty: pass try: 1 in Empty() print('failed, should have raised TypeError') except TypeError: pass 1 in testme testme[1] testme[1] = 1 del testme[1] testme[:42] testme[:42] = "The Answer" del testme[:42] testme[2:1024:10] testme[2:1024:10] = "A lot" del testme[2:1024:10] testme[:42, ..., :24:, 24, 100] testme[:42, ..., :24:, 24, 100] = "Strange" del testme[:42, ..., :24:, 24, 100] # Now remove the slice hooks to see if converting normal slices to slice # object works. del AllTests.__getslice__ del AllTests.__setslice__ del AllTests.__delslice__ import sys if sys.platform[:4] != 'java': testme[:42] testme[:42] = "The Answer" del testme[:42] else: # This works under Jython, but the actual slice values are # different. print("__getitem__: (slice(0, 42, None),)") print("__setitem__: (slice(0, 42, None), 'The Answer')") print("__delitem__: (slice(0, 42, None),)") # Unary operations -testme +testme abs(testme) int(testme) int(testme) float(testme) oct(testme) hex(testme) # And the rest... hash(testme) repr(testme) str(testme) testme == 1 testme < 1 testme > 1 testme != 1 1 == testme 1 < testme 1 > testme 1 != testme # This test has to be last (duh.) del testme if sys.platform[:4] == 'java': import java java.lang.System.gc() # Interfering tests class ExtraTests: def __getattr__(self, *args): print("__getattr__:", args) return "SomeVal" def __setattr__(self, *args): print("__setattr__:", args) def __delattr__(self, *args): print("__delattr__:", args) testme = ExtraTests() testme.spam testme.eggs = "spam, spam, spam and ham" del testme.cardinal # return values of some method are type-checked class BadTypeClass: def __int__(self): return None __float__ = __int__ __str__ = __int__ __repr__ = __int__ __oct__ = __int__ __hex__ = __int__ def check_exc(stmt, exception): """Raise TestFailed if executing 'stmt' does not raise 'exception' """ try: exec(stmt) except exception: pass else: raise TestFailed, "%s should raise %s" % (stmt, exception) check_exc("int(BadTypeClass())", TypeError) check_exc("float(BadTypeClass())", TypeError) check_exc("str(BadTypeClass())", TypeError) check_exc("repr(BadTypeClass())", TypeError) check_exc("oct(BadTypeClass())", TypeError) check_exc("hex(BadTypeClass())", TypeError) # Test correct errors from hash() on objects with comparisons but no __hash__ class C0: pass hash(C0()) # This should work; the next two should raise TypeError class C1: def __cmp__(self, other): return 0 check_exc("hash(C1())", TypeError) class C2: def __eq__(self, other): return 1 check_exc("hash(C2())", TypeError) # Test for SF bug 532646 class A: pass A.__call__ = A() a = A() try: a() # This should not segfault except RuntimeError: pass else: raise TestFailed, "how could this not have overflowed the stack?" # Tests for exceptions raised in instance_getattr2(). def booh(self): raise AttributeError, "booh" class A: a = property(booh) try: A().a # Raised AttributeError: A instance has no attribute 'a' except AttributeError as x: if str(x) != "booh": print("attribute error for A().a got masked:", str(x)) class E: __eq__ = property(booh) E() == E() # In debug mode, caused a C-level assert() to fail class I: __init__ = property(booh) try: I() # In debug mode, printed XXX undetected error and raises AttributeError except AttributeError as x: pass else: print("attribute error for I.__init__ got masked") # Test comparison and hash of methods class A: def __init__(self, x): self.x = x def f(self): pass def g(self): pass def __eq__(self, other): return self.x == other.x def __hash__(self): return self.x class B(A): pass a1 = A(1) a2 = A(2) assert a1.f == a1.f assert a1.f != a2.f assert a1.f != a1.g assert a1.f == A(1).f assert hash(a1.f) == hash(a1.f) assert hash(a1.f) == hash(A(1).f) assert A.f != a1.f assert A.f != A.g assert B.f == A.f assert hash(B.f) == hash(A.f) # the following triggers a SystemError in 2.4 a = A(hash(A.f.im_func)^(-1)) hash(a.f)