Lib/test/test_class.py

   1 "Test the functionality of Python classes implementing operators."
   2
   3 import unittest
   4
   5 from test import test_support
   6
   7 testmeths = [
   8
   9 # Binary operations
  10     "add",
  11     "radd",
  12     "sub",
  13     "rsub",
  14     "mul",
  15     "rmul",
  16     "div",
  17     "rdiv",
  18     "mod",
  19     "rmod",
  20     "divmod",
  21     "rdivmod",
  22     "pow",
  23     "rpow",
  24     "rshift",
  25     "rrshift",
  26     "lshift",
  27     "rlshift",
  28     "and",
  29     "rand",
  30     "or",
  31     "ror",
  32     "xor",
  33     "rxor",
  34
  35 # List/dict operations
  36     "contains",
  37     "getitem",
  38     "getslice",
  39     "setitem",
  40     "setslice",
  41     "delitem",
  42     "delslice",
  43
  44 # Unary operations
  45     "neg",
  46     "pos",
  47     "abs",
  48
  49 # generic operations
  50     "init",
  51     ]
  52
  53 # These need to return something other than None
  54 #    "coerce",
  55 #    "hash",
  56 #    "str",
  57 #    "repr",
  58 #    "int",
  59 #    "long",
  60 #    "float",
  61 #    "oct",
  62 #    "hex",
  63
  64 # These are separate because they can influence the test of other methods.
  65 #    "getattr",
  66 #    "setattr",
  67 #    "delattr",
  68
  69 callLst = []
  70 def trackCall(f):
  71     def track(*args, **kwargs):
  72         callLst.append((f.__name__, args))
  73         return f(*args, **kwargs)
  74     return track
  75
  76 class AllTests:
  77     trackCall = trackCall
  78
  79     @trackCall
  80     def __coerce__(self, *args):
  81         return (self,) + args
  82
  83     @trackCall
  84     def __hash__(self, *args):
  85         return hash(id(self))
  86
  87     @trackCall
  88     def __str__(self, *args):
  89         return "AllTests"
  90
  91     @trackCall
  92     def __repr__(self, *args):
  93         return "AllTests"
  94
  95     @trackCall
  96     def __int__(self, *args):
  97         return 1
  98
  99     @trackCall
 100     def __float__(self, *args):
 101         return 1.0
 102
 103     @trackCall
 104     def __long__(self, *args):
 105         return 1L
 106
 107     @trackCall
 108     def __oct__(self, *args):
 109         return '01'
 110
 111     @trackCall
 112     def __hex__(self, *args):
 113         return '0x1'
 114
 115     @trackCall
 116     def __cmp__(self, *args):
 117         return 0
 118
 119 # Synthesize all the other AllTests methods from the names in testmeths.
 120
 121 method_template = """\
 122 @trackCall
 123 def __%(method)s__(self, *args):
 124     pass
 125 """
 126
 127 for method in testmeths:
 128     exec method_template % locals() in AllTests.__dict__
 129
 130 del method, method_template
 131
 132 class ClassTests(unittest.TestCase):
 133     def setUp(self):
 134         callLst[:] = []
 135
 136     def assertCallStack(self, expected_calls):
 137         actualCallList = callLst[:]  # need to copy because the comparison below will add
 138                                      # additional calls to callLst
 139         if expected_calls != actualCallList:
 140             self.fail("Expected call list:\n  %s\ndoes not match actual call list\n  %s" %
 141                       (expected_calls, actualCallList))
 142
 143     def testInit(self):
 144         foo = AllTests()
 145         self.assertCallStack([("__init__", (foo,))])
 146
 147     def testBinaryOps(self):
 148         testme = AllTests()
 149         # Binary operations
 150
 151         callLst[:] = []
 152         testme + 1
 153         self.assertCallStack([("__coerce__", (testme, 1)), ("__add__", (testme, 1))])
 154
 155         callLst[:] = []
 156         1 + testme
 157         self.assertCallStack([("__coerce__", (testme, 1)), ("__radd__", (testme, 1))])
 158
 159         callLst[:] = []
 160         testme - 1
 161         self.assertCallStack([("__coerce__", (testme, 1)), ("__sub__", (testme, 1))])
 162
 163         callLst[:] = []
 164         1 - testme
 165         self.assertCallStack([("__coerce__", (testme, 1)), ("__rsub__", (testme, 1))])
 166
 167         callLst[:] = []
 168         testme * 1
 169         self.assertCallStack([("__coerce__", (testme, 1)), ("__mul__", (testme, 1))])
 170
 171         callLst[:] = []
 172         1 * testme
 173         self.assertCallStack([("__coerce__", (testme, 1)), ("__rmul__", (testme, 1))])
 174
 175         if 1/2 == 0:
 176             callLst[:] = []
 177             testme / 1
 178             self.assertCallStack([("__coerce__", (testme, 1)), ("__div__", (testme, 1))])
 179
 180
 181             callLst[:] = []
 182             1 / testme
 183             self.assertCallStack([("__coerce__", (testme, 1)), ("__rdiv__", (testme, 1))])
 184
 185         callLst[:] = []
 186         testme % 1
 187         self.assertCallStack([("__coerce__", (testme, 1)), ("__mod__", (testme, 1))])
 188
 189         callLst[:] = []
 190         1 % testme
 191         self.assertCallStack([("__coerce__", (testme, 1)), ("__rmod__", (testme, 1))])
 192
 193
 194         callLst[:] = []
 195         divmod(testme,1)
 196         self.assertCallStack([("__coerce__", (testme, 1)), ("__divmod__", (testme, 1))])
 197
 198         callLst[:] = []
 199         divmod(1, testme)
 200         self.assertCallStack([("__coerce__", (testme, 1)), ("__rdivmod__", (testme, 1))])
 201
 202         callLst[:] = []
 203         testme ** 1
 204         self.assertCallStack([("__coerce__", (testme, 1)), ("__pow__", (testme, 1))])
 205
 206         callLst[:] = []
 207         1 ** testme
 208         self.assertCallStack([("__coerce__", (testme, 1)), ("__rpow__", (testme, 1))])
 209
 210         callLst[:] = []
 211         testme >> 1
 212         self.assertCallStack([("__coerce__", (testme, 1)), ("__rshift__", (testme, 1))])
 213
 214         callLst[:] = []
 215         1 >> testme
 216         self.assertCallStack([("__coerce__", (testme, 1)), ("__rrshift__", (testme, 1))])
 217
 218         callLst[:] = []
 219         testme << 1
 220         self.assertCallStack([("__coerce__", (testme, 1)), ("__lshift__", (testme, 1))])
 221
 222         callLst[:] = []
 223         1 << testme
 224         self.assertCallStack([("__coerce__", (testme, 1)), ("__rlshift__", (testme, 1))])
 225
 226         callLst[:] = []
 227         testme & 1
 228         self.assertCallStack([("__coerce__", (testme, 1)), ("__and__", (testme, 1))])
 229
 230         callLst[:] = []
 231         1 & testme
 232         self.assertCallStack([("__coerce__", (testme, 1)), ("__rand__", (testme, 1))])
 233
 234         callLst[:] = []
 235         testme | 1
 236         self.assertCallStack([("__coerce__", (testme, 1)), ("__or__", (testme, 1))])
 237
 238         callLst[:] = []
 239         1 | testme
 240         self.assertCallStack([("__coerce__", (testme, 1)), ("__ror__", (testme, 1))])
 241
 242         callLst[:] = []
 243         testme ^ 1
 244         self.assertCallStack([("__coerce__", (testme, 1)), ("__xor__", (testme, 1))])
 245
 246         callLst[:] = []
 247         1 ^ testme
 248         self.assertCallStack([("__coerce__", (testme, 1)), ("__rxor__", (testme, 1))])
 249
 250     def testListAndDictOps(self):
 251         testme = AllTests()
 252
 253         # List/dict operations
 254
 255         class Empty: pass
 256
 257         try:
 258             1 in Empty()
 259             self.fail('failed, should have raised TypeError')
 260         except TypeError:
 261             pass
 262
 263         callLst[:] = []
 264         1 in testme
 265         self.assertCallStack([('__contains__', (testme, 1))])
 266
 267         callLst[:] = []
 268         testme[1]
 269         self.assertCallStack([('__getitem__', (testme, 1))])
 270
 271         callLst[:] = []
 272         testme[1] = 1
 273         self.assertCallStack([('__setitem__', (testme, 1, 1))])
 274
 275         callLst[:] = []
 276         del testme[1]
 277         self.assertCallStack([('__delitem__', (testme, 1))])
 278
 279         callLst[:] = []
 280         testme[:42]
 281         self.assertCallStack([('__getslice__', (testme, 0, 42))])
 282
 283         callLst[:] = []
 284         testme[:42] = "The Answer"
 285         self.assertCallStack([('__setslice__', (testme, 0, 42, "The Answer"))])
 286
 287         callLst[:] = []
 288         del testme[:42]
 289         self.assertCallStack([('__delslice__', (testme, 0, 42))])
 290
 291         callLst[:] = []
 292         testme[2:1024:10]
 293         self.assertCallStack([('__getitem__', (testme, slice(2, 1024, 10)))])
 294
 295         callLst[:] = []
 296         testme[2:1024:10] = "A lot"
 297         self.assertCallStack([('__setitem__', (testme, slice(2, 1024, 10),
 298                                                                     "A lot"))])
 299         callLst[:] = []
 300         del testme[2:1024:10]
 301         self.assertCallStack([('__delitem__', (testme, slice(2, 1024, 10)))])
 302
 303         callLst[:] = []
 304         testme[:42, ..., :24:, 24, 100]
 305         self.assertCallStack([('__getitem__', (testme, (slice(None, 42, None),
 306                                                         Ellipsis,
 307                                                         slice(None, 24, None),
 308                                                         24, 100)))])
 309         callLst[:] = []
 310         testme[:42, ..., :24:, 24, 100] = "Strange"
 311         self.assertCallStack([('__setitem__', (testme, (slice(None, 42, None),
 312                                                         Ellipsis,
 313                                                         slice(None, 24, None),
 314                                                         24, 100), "Strange"))])
 315         callLst[:] = []
 316         del testme[:42, ..., :24:, 24, 100]
 317         self.assertCallStack([('__delitem__', (testme, (slice(None, 42, None),
 318                                                         Ellipsis,
 319                                                         slice(None, 24, None),
 320                                                         24, 100)))])
 321
 322         # Now remove the slice hooks to see if converting normal slices to
 323         #  slice object works.
 324
 325         getslice = AllTests.__getslice__
 326         del AllTests.__getslice__
 327         setslice = AllTests.__setslice__
 328         del AllTests.__setslice__
 329         delslice = AllTests.__delslice__
 330         del AllTests.__delslice__
 331
 332         # XXX when using new-style classes the slice testme[:42] produces
 333         #  slice(None, 42, None) instead of slice(0, 42, None). py3k will have
 334         #  to change this test.
 335         callLst[:] = []
 336         testme[:42]
 337         self.assertCallStack([('__getitem__', (testme, slice(0, 42, None)))])
 338
 339         callLst[:] = []
 340         testme[:42] = "The Answer"
 341         self.assertCallStack([('__setitem__', (testme, slice(0, 42, None),
 342                                                                 "The Answer"))])
 343         callLst[:] = []
 344         del testme[:42]
 345         self.assertCallStack([('__delitem__', (testme, slice(0, 42, None)))])
 346
 347         # Restore the slice methods, or the tests will fail with regrtest -R.
 348         AllTests.__getslice__ = getslice
 349         AllTests.__setslice__ = setslice
 350         AllTests.__delslice__ = delslice
 351
 352
 353     def testUnaryOps(self):
 354         testme = AllTests()
 355
 356         callLst[:] = []
 357         -testme
 358         self.assertCallStack([('__neg__', (testme,))])
 359         callLst[:] = []
 360         +testme
 361         self.assertCallStack([('__pos__', (testme,))])
 362         callLst[:] = []
 363         abs(testme)
 364         self.assertCallStack([('__abs__', (testme,))])
 365         callLst[:] = []
 366         int(testme)
 367         self.assertCallStack([('__int__', (testme,))])
 368         callLst[:] = []
 369         long(testme)
 370         self.assertCallStack([('__long__', (testme,))])
 371         callLst[:] = []
 372         float(testme)
 373         self.assertCallStack([('__float__', (testme,))])
 374         callLst[:] = []
 375         oct(testme)
 376         self.assertCallStack([('__oct__', (testme,))])
 377         callLst[:] = []
 378         hex(testme)
 379         self.assertCallStack([('__hex__', (testme,))])
 380
 381
 382     def testMisc(self):
 383         testme = AllTests()
 384
 385         callLst[:] = []
 386         hash(testme)
 387         self.assertCallStack([('__hash__', (testme,))])
 388
 389         callLst[:] = []
 390         repr(testme)
 391         self.assertCallStack([('__repr__', (testme,))])
 392
 393         callLst[:] = []
 394         str(testme)
 395         self.assertCallStack([('__str__', (testme,))])
 396
 397         callLst[:] = []
 398         testme == 1
 399         self.assertCallStack([("__coerce__", (testme, 1)), ('__cmp__', (testme, 1))])
 400
 401         callLst[:] = []
 402         testme < 1
 403         self.assertCallStack([("__coerce__", (testme, 1)), ('__cmp__', (testme, 1))])
 404
 405         callLst[:] = []
 406         testme > 1
 407         self.assertCallStack([("__coerce__", (testme, 1)), ('__cmp__', (testme, 1))])
 408
 409         callLst[:] = []
 410         testme <> 1  # XXX kill this in py3k
 411         self.assertCallStack([("__coerce__", (testme, 1)), ('__cmp__', (testme, 1))])
 412
 413         callLst[:] = []
 414         testme != 1
 415         self.assertCallStack([("__coerce__", (testme, 1)), ('__cmp__', (testme, 1))])
 416
 417         callLst[:] = []
 418         1 == testme
 419         self.assertCallStack([("__coerce__", (testme, 1)), ('__cmp__', (1, testme))])
 420
 421         callLst[:] = []
 422         1 < testme
 423         self.assertCallStack([("__coerce__", (testme, 1)), ('__cmp__', (1, testme))])
 424
 425         callLst[:] = []
 426         1 > testme
 427         self.assertCallStack([("__coerce__", (testme, 1)), ('__cmp__', (1, testme))])
 428
 429         callLst[:] = []
 430         1 <> testme
 431         self.assertCallStack([("__coerce__", (testme, 1)), ('__cmp__', (1, testme))])
 432
 433         callLst[:] = []
 434         1 != testme
 435         self.assertCallStack([("__coerce__", (testme, 1)), ('__cmp__', (1, testme))])
 436
 437
 438     def testGetSetAndDel(self):
 439         # Interfering tests
 440         class ExtraTests(AllTests):
 441             @trackCall
 442             def __getattr__(self, *args):
 443                 return "SomeVal"
 444
 445             @trackCall
 446             def __setattr__(self, *args):
 447                 pass
 448
 449             @trackCall
 450             def __delattr__(self, *args):
 451                 pass
 452
 453         testme = ExtraTests()
 454
 455         callLst[:] = []
 456         testme.spam
 457         self.assertCallStack([('__getattr__', (testme, "spam"))])
 458
 459         callLst[:] = []
 460         testme.eggs = "spam, spam, spam and ham"
 461         self.assertCallStack([('__setattr__', (testme, "eggs",
 462                                                "spam, spam, spam and ham"))])
 463
 464         callLst[:] = []
 465         del testme.cardinal
 466         self.assertCallStack([('__delattr__', (testme, "cardinal"))])
 467
 468     def testDel(self):
 469         x = []
 470
 471         class DelTest:
 472             def __del__(self):
 473                 x.append("crab people, crab people")
 474         testme = DelTest()
 475         del testme
 476         import gc
 477         gc.collect()
 478         self.assertEquals(["crab people, crab people"], x)
 479
 480     def testBadTypeReturned(self):
 481         # return values of some method are type-checked
 482         class BadTypeClass:
 483             def __int__(self):
 484                 return None
 485             __float__ = __int__
 486             __long__ = __int__
 487             __str__ = __int__
 488             __repr__ = __int__
 489             __oct__ = __int__
 490             __hex__ = __int__
 491
 492         for f in [int, float, long, str, repr, oct, hex]:
 493             self.assertRaises(TypeError, f, BadTypeClass())
 494
 495     def testMixIntsAndLongs(self):
 496         # mixing up ints and longs is okay
 497         class IntLongMixClass:
 498             @trackCall
 499             def __int__(self):
 500                 return 42L
 501
 502             @trackCall
 503             def __long__(self):
 504                 return 64
 505
 506         mixIntAndLong = IntLongMixClass()
 507
 508         callLst[:] = []
 509         as_int = int(mixIntAndLong)
 510         self.assertEquals(type(as_int), long)
 511         self.assertEquals(as_int, 42L)
 512         self.assertCallStack([('__int__', (mixIntAndLong,))])
 513
 514         callLst[:] = []
 515         as_long = long(mixIntAndLong)
 516         self.assertEquals(type(as_long), int)
 517         self.assertEquals(as_long, 64)
 518         self.assertCallStack([('__long__', (mixIntAndLong,))])
 519
 520     def testHashStuff(self):
 521         # Test correct errors from hash() on objects with comparisons but
 522         #  no __hash__
 523
 524         class C0:
 525             pass
 526
 527         hash(C0()) # This should work; the next two should raise TypeError
 528
 529         class C1:
 530             def __cmp__(self, other): return 0
 531
 532         self.assertRaises(TypeError, hash, C1())
 533
 534         class C2:
 535             def __eq__(self, other): return 1
 536
 537         self.assertRaises(TypeError, hash, C2())
 538
 539
 540     def testSFBug532646(self):
 541         # Test for SF bug 532646
 542
 543         class A:
 544             pass
 545         A.__call__ = A()
 546         a = A()
 547
 548         try:
 549             a() # This should not segfault
 550         except RuntimeError:
 551             pass
 552         else:
 553             self.fail("Failed to raise RuntimeError")
 554
 555     def testForExceptionsRaisedInInstanceGetattr2(self):
 556         # Tests for exceptions raised in instance_getattr2().
 557
 558         def booh(self):
 559             raise AttributeError("booh")
 560
 561         class A:
 562             a = property(booh)
 563         try:
 564             A().a # Raised AttributeError: A instance has no attribute 'a'
 565         except AttributeError, x:
 566             if str(x) != "booh":
 567                 self.fail("attribute error for A().a got masked: %s" % x)
 568
 569         class E:
 570             __eq__ = property(booh)
 571         E() == E() # In debug mode, caused a C-level assert() to fail
 572
 573         class I:
 574             __init__ = property(booh)
 575         try:
 576             # In debug mode, printed XXX undetected error and
 577             #  raises AttributeError
 578             I()
 579         except AttributeError, x:
 580             pass
 581         else:
 582             self.fail("attribute error for I.__init__ got masked")
 583
 584     def testHashComparisonOfMethods(self):
 585         # Test comparison and hash of methods
 586         class A:
 587             def __init__(self, x):
 588                 self.x = x
 589             def f(self):
 590                 pass
 591             def g(self):
 592                 pass
 593             def __eq__(self, other):
 594                 return self.x == other.x
 595             def __hash__(self):
 596                 return self.x
 597         class B(A):
 598             pass
 599
 600         a1 = A(1)
 601         a2 = A(2)
 602         self.assertEquals(a1.f, a1.f)
 603         self.assertNotEquals(a1.f, a2.f)
 604         self.assertNotEquals(a1.f, a1.g)
 605         self.assertEquals(a1.f, A(1).f)
 606         self.assertEquals(hash(a1.f), hash(a1.f))
 607         self.assertEquals(hash(a1.f), hash(A(1).f))
 608
 609         self.assertNotEquals(A.f, a1.f)
 610         self.assertNotEquals(A.f, A.g)
 611         self.assertEquals(B.f, A.f)
 612         self.assertEquals(hash(B.f), hash(A.f))
 613
 614         # the following triggers a SystemError in 2.4
 615         a = A(hash(A.f.im_func)^(-1))
 616         hash(a.f)
 617
 618 def test_main():
 619     test_support.run_unittest(ClassTests)
 620
 621 if __name__=='__main__':
 622     test_main()