1 # Test enhancements related to descriptors and new-style classes
3 from test
.test_support
import verify
, vereq
, verbose
, TestFailed
, TESTFN
, get_original_stdout
4 from copy
import deepcopy
7 warnings
.filterwarnings("ignore",
8 r
'complex divmod\(\), // and % are deprecated$',
9 DeprecationWarning, r
'(<string>|%s)$' % __name__
)
13 raise TestFailed
, "%r is %r" % (a
, b
)
15 def testunop(a
, res
, expr
="len(a)", meth
="__len__"):
16 if verbose
: print "checking", expr
18 vereq(eval(expr
, dict), res
)
21 while meth
not in t
.__dict
__:
23 vereq(m
, t
.__dict
__[meth
])
28 def testbinop(a
, b
, res
, expr
="a+b", meth
="__add__"):
29 if verbose
: print "checking", expr
30 dict = {'a': a
, 'b': b
}
32 # XXX Hack so this passes before 2.3 when -Qnew is specified.
33 if meth
== "__div__" and 1/2 == 0.5:
36 vereq(eval(expr
, dict), res
)
39 while meth
not in t
.__dict
__:
41 vereq(m
, t
.__dict
__[meth
])
46 def testternop(a
, b
, c
, res
, expr
="a[b:c]", meth
="__getslice__"):
47 if verbose
: print "checking", expr
48 dict = {'a': a
, 'b': b
, 'c': c
}
49 vereq(eval(expr
, dict), res
)
52 while meth
not in t
.__dict
__:
54 vereq(m
, t
.__dict
__[meth
])
55 vereq(m(a
, b
, c
), res
)
59 def testsetop(a
, b
, res
, stmt
="a+=b", meth
="__iadd__"):
60 if verbose
: print "checking", stmt
61 dict = {'a': deepcopy(a
), 'b': b
}
66 while meth
not in t
.__dict
__:
68 vereq(m
, t
.__dict
__[meth
])
69 dict['a'] = deepcopy(a
)
72 dict['a'] = deepcopy(a
)
73 bm
= getattr(dict['a'], meth
)
77 def testset2op(a
, b
, c
, res
, stmt
="a[b]=c", meth
="__setitem__"):
78 if verbose
: print "checking", stmt
79 dict = {'a': deepcopy(a
), 'b': b
, 'c': c
}
84 while meth
not in t
.__dict
__:
86 vereq(m
, t
.__dict
__[meth
])
87 dict['a'] = deepcopy(a
)
90 dict['a'] = deepcopy(a
)
91 bm
= getattr(dict['a'], meth
)
95 def testset3op(a
, b
, c
, d
, res
, stmt
="a[b:c]=d", meth
="__setslice__"):
96 if verbose
: print "checking", stmt
97 dict = {'a': deepcopy(a
), 'b': b
, 'c': c
, 'd': d
}
101 while meth
not in t
.__dict
__:
104 vereq(m
, t
.__dict
__[meth
])
105 dict['a'] = deepcopy(a
)
106 m(dict['a'], b
, c
, d
)
107 vereq(dict['a'], res
)
108 dict['a'] = deepcopy(a
)
109 bm
= getattr(dict['a'], meth
)
111 vereq(dict['a'], res
)
113 def class_docstrings():
115 "A classic docstring."
116 vereq(Classic
.__doc
__, "A classic docstring.")
117 vereq(Classic
.__dict
__['__doc__'], "A classic docstring.")
121 verify(Classic2
.__doc__
is None)
123 class NewStatic(object):
125 vereq(NewStatic
.__doc
__, "Another docstring.")
126 vereq(NewStatic
.__dict
__['__doc__'], "Another docstring.")
128 class NewStatic2(object):
130 verify(NewStatic2
.__doc__
is None)
132 class NewDynamic(object):
134 vereq(NewDynamic
.__doc
__, "Another docstring.")
135 vereq(NewDynamic
.__dict
__['__doc__'], "Another docstring.")
137 class NewDynamic2(object):
139 verify(NewDynamic2
.__doc__
is None)
142 if verbose
: print "Testing list operations..."
143 testbinop([1], [2], [1,2], "a+b", "__add__")
144 testbinop([1,2,3], 2, 1, "b in a", "__contains__")
145 testbinop([1,2,3], 4, 0, "b in a", "__contains__")
146 testbinop([1,2,3], 1, 2, "a[b]", "__getitem__")
147 testternop([1,2,3], 0, 2, [1,2], "a[b:c]", "__getslice__")
148 testsetop([1], [2], [1,2], "a+=b", "__iadd__")
149 testsetop([1,2], 3, [1,2,1,2,1,2], "a*=b", "__imul__")
150 testunop([1,2,3], 3, "len(a)", "__len__")
151 testbinop([1,2], 3, [1,2,1,2,1,2], "a*b", "__mul__")
152 testbinop([1,2], 3, [1,2,1,2,1,2], "b*a", "__rmul__")
153 testset2op([1,2], 1, 3, [1,3], "a[b]=c", "__setitem__")
154 testset3op([1,2,3,4], 1, 3, [5,6], [1,5,6,4], "a[b:c]=d", "__setslice__")
157 if verbose
: print "Testing dict operations..."
158 testbinop({1:2}, {2:1}, -1, "cmp(a,b)", "__cmp__")
159 testbinop({1:2,3:4}, 1, 1, "b in a", "__contains__")
160 testbinop({1:2,3:4}, 2, 0, "b in a", "__contains__")
161 testbinop({1:2,3:4}, 1, 2, "a[b]", "__getitem__")
164 for i
in d
.keys(): l1
.append(i
)
166 for i
in iter(d
): l
.append(i
)
169 for i
in d
.__iter
__(): l
.append(i
)
172 for i
in dict.__iter
__(d
): l
.append(i
)
175 testunop(d
, 2, "len(a)", "__len__")
176 vereq(eval(repr(d
), {}), d
)
177 vereq(eval(d
.__repr
__(), {}), d
)
178 testset2op({1:2,3:4}, 2, 3, {1:2,2:3,3:4}, "a[b]=c", "__setitem__")
180 def dict_constructor():
182 print "Testing dict constructor ..."
187 d
= dict({1: 2, 'a': 'b'})
188 vereq(d
, {1: 2, 'a': 'b'})
189 vereq(d
, dict(d
.items()))
190 vereq(d
, dict(d
.iteritems()))
191 d
= dict({'one':1, 'two':2})
192 vereq(d
, dict(one
=1, two
=2))
194 vereq(d
, dict({"one": 1}, two
=2))
195 vereq(d
, dict([("two", 2)], one
=1))
196 vereq(d
, dict([("one", 100), ("two", 200)], **d
))
197 verify(d
is not dict(**d
))
198 for badarg
in 0, 0L, 0j
, "0", [0], (0,):
205 # It's a sequence, and its elements are also sequences (gotta
206 # love strings <wink>), but they aren't of length 2, so this
207 # one seemed better as a ValueError than a TypeError.
210 raise TestFailed("no TypeError from dict(%r)" % badarg
)
212 raise TestFailed("no TypeError from dict(%r)" % badarg
)
219 raise TestFailed("no TypeError from dict({}, {})")
222 # Lacks a .keys() method; will be added later.
223 dict = {1:2, 3:4, 'a':1j
}
230 raise TestFailed("no TypeError from dict(incomplete mapping)")
232 Mapping
.keys
= lambda self
: self
.dict.keys()
233 Mapping
.__getitem
__ = lambda self
, i
: self
.dict[i
]
235 vereq(d
, Mapping
.dict)
237 # Init from sequence of iterable objects, each producing a 2-sequence.
238 class AddressBookEntry
:
239 def __init__(self
, first
, last
):
243 return iter([self
.first
, self
.last
])
245 d
= dict([AddressBookEntry('Tim', 'Warsaw'),
246 AddressBookEntry('Barry', 'Peters'),
247 AddressBookEntry('Tim', 'Peters'),
248 AddressBookEntry('Barry', 'Warsaw')])
249 vereq(d
, {'Barry': 'Warsaw', 'Tim': 'Peters'})
251 d
= dict(zip(range(4), range(1, 5)))
252 vereq(d
, dict([(i
, i
+1) for i
in range(4)]))
254 # Bad sequence lengths.
255 for bad
in [('tooshort',)], [('too', 'long', 'by 1')]:
261 raise TestFailed("no ValueError from dict(%r)" % bad
)
265 print "Testing dir() ..."
267 vereq(dir(), ['junk'])
270 # Just make sure these don't blow up!
271 for arg
in 2, 2L, 2j
, 2e0
, [2], "2", u
"2", (2,), {2:2}, type, test_dir
:
274 # Try classic classes.
277 def Cmethod(self
): pass
279 cstuff
= ['Cdata', 'Cmethod', '__doc__', '__module__']
280 vereq(dir(C
), cstuff
)
281 verify('im_self' in dir(C
.Cmethod
))
283 c
= C() # c.__doc__ is an odd thing to see here; ditto c.__module__.
284 vereq(dir(c
), cstuff
)
287 c
.cmethod
= lambda self
: 0
288 vereq(dir(c
), cstuff
+ ['cdata', 'cmethod'])
289 verify('im_self' in dir(c
.Cmethod
))
293 def Amethod(self
): pass
295 astuff
= ['Adata', 'Amethod'] + cstuff
296 vereq(dir(A
), astuff
)
297 verify('im_self' in dir(A
.Amethod
))
299 vereq(dir(a
), astuff
)
300 verify('im_self' in dir(a
.Amethod
))
302 a
.amethod
= lambda self
: 3
303 vereq(dir(a
), astuff
+ ['adata', 'amethod'])
305 # The same, but with new-style classes. Since these have object as a
306 # base class, a lot more gets sucked in.
307 def interesting(strings
):
308 return [s
for s
in strings
if not s
.startswith('_')]
312 def Cmethod(self
): pass
314 cstuff
= ['Cdata', 'Cmethod']
315 vereq(interesting(dir(C
)), cstuff
)
318 vereq(interesting(dir(c
)), cstuff
)
319 verify('im_self' in dir(C
.Cmethod
))
322 c
.cmethod
= lambda self
: 0
323 vereq(interesting(dir(c
)), cstuff
+ ['cdata', 'cmethod'])
324 verify('im_self' in dir(c
.Cmethod
))
328 def Amethod(self
): pass
330 astuff
= ['Adata', 'Amethod'] + cstuff
331 vereq(interesting(dir(A
)), astuff
)
332 verify('im_self' in dir(A
.Amethod
))
334 vereq(interesting(dir(a
)), astuff
)
336 a
.amethod
= lambda self
: 3
337 vereq(interesting(dir(a
)), astuff
+ ['adata', 'amethod'])
338 verify('im_self' in dir(a
.Amethod
))
340 # Try a module subclass.
347 names
= [x
for x
in dir(minstance
) if x
not in ["__name__", "__doc__"]]
348 vereq(names
, ['a', 'b'])
353 __dict__
= property(getdict
)
355 m2instance
= M2("m2")
358 vereq(m2instance
.__dict
__, "Not a dict!")
364 # Two essentially featureless objects, just inheriting stuff from
366 vereq(dir(None), dir(Ellipsis))
368 # Nasty test case for proxied objects
369 class Wrapper(object):
370 def __init__(self
, obj
):
373 return "Wrapper(%s)" % repr(self
.__obj
)
374 def __getitem__(self
, key
):
375 return Wrapper(self
.__obj
[key
])
377 return len(self
.__obj
)
378 def __getattr__(self
, name
):
379 return Wrapper(getattr(self
.__obj
, name
))
382 def __getclass(self
):
383 return Wrapper(type(self
))
384 __class__
= property(__getclass
)
386 dir(C()) # This used to segfault
410 for name
, expr
in binops
.items():
412 expr
= expr
+ "(a, b)"
414 expr
= 'a %s b' % expr
429 for name
, expr
in unops
.items():
436 def numops(a
, b
, skip
=[]):
437 dict = {'a': a
, 'b': b
}
438 for name
, expr
in binops
.items():
440 name
= "__%s__" % name
442 res
= eval(expr
, dict)
443 testbinop(a
, b
, res
, expr
, name
)
444 for name
, expr
in unops
.items():
446 name
= "__%s__" % name
448 res
= eval(expr
, dict)
449 testunop(a
, res
, expr
, name
)
452 if verbose
: print "Testing int operations..."
454 # The following crashes in Python 2.2
455 vereq((1).__nonzero
__(), 1)
456 vereq((0).__nonzero
__(), 0)
457 # This returns 'NotImplemented' in Python 2.2
459 def __add__(self
, other
):
460 return NotImplemented
467 raise TestFailed
, "NotImplemented should have caused TypeError"
471 except OverflowError:
474 raise TestFailed
, "should have raised OverflowError"
477 if verbose
: print "Testing long operations..."
481 if verbose
: print "Testing float operations..."
485 if verbose
: print "Testing complex operations..."
486 numops(100.0j
, 3.0j
, skip
=['lt', 'le', 'gt', 'ge', 'int', 'long', 'float'])
487 class Number(complex):
489 def __new__(cls
, *args
, **kwds
):
490 result
= complex.__new
__(cls
, *args
)
491 result
.prec
= kwds
.get('prec', 12)
496 return "%.*g" % (prec
, self
.real
)
498 return "%.*gj" % (prec
, self
.imag
)
499 return "(%.*g+%.*gj)" % (prec
, self
.real
, prec
, self
.imag
)
502 a
= Number(3.14, prec
=6)
503 vereq(repr(a
), "3.14")
506 a
= Number(a
, prec
=2)
507 vereq(repr(a
), "3.1")
511 vereq(repr(a
), "234.5")
515 if verbose
: print "Testing spamlist operations..."
516 import copy
, xxsubtype
as spam
517 def spamlist(l
, memo
=None):
518 import xxsubtype
as spam
519 return spam
.spamlist(l
)
520 # This is an ugly hack:
521 copy
._deepcopy
_dispatch
[spam
.spamlist
] = spamlist
523 testbinop(spamlist([1]), spamlist([2]), spamlist([1,2]), "a+b", "__add__")
524 testbinop(spamlist([1,2,3]), 2, 1, "b in a", "__contains__")
525 testbinop(spamlist([1,2,3]), 4, 0, "b in a", "__contains__")
526 testbinop(spamlist([1,2,3]), 1, 2, "a[b]", "__getitem__")
527 testternop(spamlist([1,2,3]), 0, 2, spamlist([1,2]),
528 "a[b:c]", "__getslice__")
529 testsetop(spamlist([1]), spamlist([2]), spamlist([1,2]),
531 testsetop(spamlist([1,2]), 3, spamlist([1,2,1,2,1,2]), "a*=b", "__imul__")
532 testunop(spamlist([1,2,3]), 3, "len(a)", "__len__")
533 testbinop(spamlist([1,2]), 3, spamlist([1,2,1,2,1,2]), "a*b", "__mul__")
534 testbinop(spamlist([1,2]), 3, spamlist([1,2,1,2,1,2]), "b*a", "__rmul__")
535 testset2op(spamlist([1,2]), 1, 3, spamlist([1,3]), "a[b]=c", "__setitem__")
536 testset3op(spamlist([1,2,3,4]), 1, 3, spamlist([5,6]),
537 spamlist([1,5,6,4]), "a[b:c]=d", "__setslice__")
539 class C(spam
.spamlist
):
540 def foo(self
): return 1
546 vereq(a
.getstate(), 0)
548 vereq(a
.getstate(), 42)
551 if verbose
: print "Testing spamdict operations..."
552 import copy
, xxsubtype
as spam
553 def spamdict(d
, memo
=None):
554 import xxsubtype
as spam
556 for k
, v
in d
.items(): sd
[k
] = v
558 # This is an ugly hack:
559 copy
._deepcopy
_dispatch
[spam
.spamdict
] = spamdict
561 testbinop(spamdict({1:2}), spamdict({2:1}), -1, "cmp(a,b)", "__cmp__")
562 testbinop(spamdict({1:2,3:4}), 1, 1, "b in a", "__contains__")
563 testbinop(spamdict({1:2,3:4}), 2, 0, "b in a", "__contains__")
564 testbinop(spamdict({1:2,3:4}), 1, 2, "a[b]", "__getitem__")
565 d
= spamdict({1:2,3:4})
567 for i
in d
.keys(): l1
.append(i
)
569 for i
in iter(d
): l
.append(i
)
572 for i
in d
.__iter
__(): l
.append(i
)
575 for i
in type(spamdict({})).__iter
__(d
): l
.append(i
)
577 straightd
= {1:2, 3:4}
578 spamd
= spamdict(straightd
)
579 testunop(spamd
, 2, "len(a)", "__len__")
580 testunop(spamd
, repr(straightd
), "repr(a)", "__repr__")
581 testset2op(spamdict({1:2,3:4}), 2, 3, spamdict({1:2,2:3,3:4}),
582 "a[b]=c", "__setitem__")
584 class C(spam
.spamdict
):
585 def foo(self
): return 1
590 vereq(a
.items(), [('foo', 'bar')])
591 vereq(a
.getstate(), 0)
593 vereq(a
.getstate(), 100)
596 if verbose
: print "Testing Python subclass of dict..."
597 verify(issubclass(dict, dict))
598 verify(isinstance({}, dict))
601 verify(d
.__class
__ is dict)
602 verify(isinstance(d
, dict))
605 def __init__(self
, *a
, **kw
):
610 for k
, v
in kw
.items(): self
[v
] = k
611 def __getitem__(self
, key
):
612 return self
.get(key
, 0)
613 def __setitem__(self
, key
, value
):
614 verify(isinstance(key
, type(0)))
615 dict.__setitem
__(self
, key
, value
)
616 def setstate(self
, state
):
620 verify(issubclass(C
, dict))
624 vereq(a2
[1] == 'foo' and a2
[2], 'bar')
627 vereq(a
.getstate(), -1)
630 vereq(a
.getstate(), 0)
633 vereq(a
.getstate(), 10)
637 if verbose
: print "pydict stress test ..."
648 if verbose
: print "Testing Python subclass of list..."
650 def __getitem__(self
, i
):
651 return list.__getitem
__(self
, i
) + 100
652 def __getslice__(self
, i
, j
):
659 vereq(a
[100:200], (100,200))
662 if verbose
: print "Testing __metaclass__..."
669 def setstate(self
, state
):
672 vereq(a
.getstate(), 0)
674 vereq(a
.getstate(), 10)
676 class __metaclass__(type):
677 def myself(cls
): return cls
680 verify(d
.__class
__ is D
)
682 def __new__(cls
, name
, bases
, dict):
684 return type.__new
__(cls
, name
, bases
, dict)
691 class _instance(object):
695 def __new__(cls
, name
, bases
, dict):
696 self
= object.__new
__(cls
)
703 # Early binding of methods
704 for key
in self
.dict:
705 if key
.startswith("__"):
707 setattr(it
, key
, self
.dict[key
].__get
__(it
, self
))
715 verify('spam' in C
.dict)
719 # More metaclass examples
721 class autosuper(type):
722 # Automatically add __super to the class
723 # This trick only works for dynamic classes
724 def __new__(metaclass
, name
, bases
, dict):
725 cls
= super(autosuper
, metaclass
).__new
__(metaclass
,
727 # Name mangling for __super removes leading underscores
728 while name
[:1] == "_":
731 name
= "_%s__super" % name
734 setattr(cls
, name
, super(cls
))
737 __metaclass__
= autosuper
742 return "B" + self
.__super
.meth()
745 return "C" + self
.__super
.meth()
748 return "D" + self
.__super
.meth()
749 vereq(D().meth(), "DCBA")
752 return "E" + self
.__super
.meth()
753 vereq(E().meth(), "EBCA")
755 class autoproperty(type):
756 # Automatically create property attributes when methods
757 # named _get_x and/or _set_x are found
758 def __new__(metaclass
, name
, bases
, dict):
760 for key
, val
in dict.iteritems():
761 if key
.startswith("_get_"):
763 get
, set = hits
.get(key
, (None, None))
766 elif key
.startswith("_set_"):
768 get
, set = hits
.get(key
, (None, None))
771 for key
, (get
, set) in hits
.iteritems():
772 dict[key
] = property(get
, set)
773 return super(autoproperty
, metaclass
).__new
__(metaclass
,
776 __metaclass__
= autoproperty
782 verify(not hasattr(a
, "x"))
787 class multimetaclass(autoproperty
, autosuper
):
788 # Merge of multiple cooperating metaclasses
791 __metaclass__
= multimetaclass
796 return "B" + self
.__super
._get
_x
()
799 return "C" + self
.__super
._get
_x
()
802 return "D" + self
.__super
._get
_x
()
805 # Make sure type(x) doesn't call x.__class__.__init__
808 def __init__(self
, *args
):
817 class C(object): pass
820 except TypeError: pass
821 else: raise TestFailed
, "calling object w/o call method should raise TypeError"
824 if verbose
: print "Testing Python subclass of module..."
829 def __init__(self
, name
):
830 MT
.__init
__(self
, name
)
831 def __getattribute__(self
, name
):
832 log
.append(("getattr", name
))
833 return MT
.__getattribute
__(self
, name
)
834 def __setattr__(self
, name
, value
):
835 log
.append(("setattr", name
, value
))
836 MT
.__setattr
__(self
, name
, value
)
837 def __delattr__(self
, name
):
838 log
.append(("delattr", name
))
839 MT
.__delattr
__(self
, name
)
844 vereq(log
, [("setattr", "foo", 12),
849 if verbose
: print "Testing multiple inheritance..."
855 def setstate(self
, state
):
858 vereq(a
.getstate(), 0)
860 vereq(a
.getstate(), 10)
863 type({}).__init
__(self
)
868 vereq(d
.items(), [("hello", "world")])
869 vereq(d
["hello"], "world")
870 vereq(d
.getstate(), 0)
872 vereq(d
.getstate(), 10)
873 vereq(D
.__mro
__, (D
, dict, C
, object))
878 return int(self
.foo())
881 class Frag(Node
, list):
884 vereq(Node().__int
__(), 23)
885 vereq(int(Node()), 23)
886 vereq(Frag().__int
__(), 42)
887 vereq(int(Frag()), 42)
889 # MI mixing classic and new-style classes.
904 # Classic MRO is preserved for a classic base class.
907 vereq(E
.__mro
__, (E
, D
, B
, A
, C
, object))
910 # But with a mix of classic bases, their MROs are combined using
912 class F(B
, C
, object):
914 vereq(F
.__mro
__, (F
, B
, C
, A
, object))
917 # Try something else.
921 def all_method(self
):
927 def all_method(self
):
930 vereq(M1
.__mro__
, (M1
, C
, object))
932 vereq(m
.cmethod(), "C a")
933 vereq(m
.m1method(), "M1 a")
934 vereq(m
.all_method(), "M1 b")
939 def all_method(self
):
945 def all_method(self
):
948 vereq(M2
.__mro__
, (M2
, D
, C
, object))
950 vereq(m
.cmethod(), "C a")
951 vereq(m
.dmethod(), "D a")
952 vereq(m
.m2method(), "M2 a")
953 vereq(m
.all_method(), "M2 b")
955 class M3(M1
, M2
, object):
958 def all_method(self
):
960 vereq(M3
.__mro__
, (M3
, M1
, M2
, D
, C
, object))
962 vereq(m
.cmethod(), "C a")
963 vereq(m
.dmethod(), "D a")
964 vereq(m
.m1method(), "M1 a")
965 vereq(m
.m2method(), "M2 a")
966 vereq(m
.m3method(), "M3 a")
967 vereq(m
.all_method(), "M3 b")
977 raise TestFailed
, "new class with only classic bases - shouldn't be"
980 if verbose
: print "Testing multiple inheritance special cases..."
982 def spam(self
): return "A"
983 vereq(A().spam(), "A")
985 def boo(self
): return "B"
986 def spam(self
): return "B"
987 vereq(B().spam(), "B")
988 vereq(B().boo(), "B")
990 def boo(self
): return "C"
991 vereq(C().spam(), "A")
992 vereq(C().boo(), "C")
994 vereq(D().spam(), "B")
995 vereq(D().boo(), "B")
996 vereq(D
.__mro
__, (D
, B
, C
, A
, object))
998 vereq(E().spam(), "B")
999 vereq(E().boo(), "C")
1000 vereq(E
.__mro
__, (E
, C
, B
, A
, object))
1001 # MRO order disagreement
1007 raise TestFailed
, "expected MRO order disagreement (F)"
1013 raise TestFailed
, "expected MRO order disagreement (G)"
1016 # see thread python-dev/2002-October/029035.html
1018 if verbose
: print "Testing ex5 from C3 switch discussion..."
1019 class A(object): pass
1020 class B(object): pass
1021 class C(object): pass
1024 class Z(X
,B
,Y
,C
): pass
1025 vereq(Z
.__mro
__, (Z
, X
, B
, Y
, A
, C
, object))
1027 # see "A Monotonic Superclass Linearization for Dylan",
1028 # by Kim Barrett et al. (OOPSLA 1996)
1030 if verbose
: print "Testing MRO monotonicity..."
1031 class Boat(object): pass
1032 class DayBoat(Boat
): pass
1033 class WheelBoat(Boat
): pass
1034 class EngineLess(DayBoat
): pass
1035 class SmallMultihull(DayBoat
): pass
1036 class PedalWheelBoat(EngineLess
,WheelBoat
): pass
1037 class SmallCatamaran(SmallMultihull
): pass
1038 class Pedalo(PedalWheelBoat
,SmallCatamaran
): pass
1040 vereq(PedalWheelBoat
.__mro
__,
1041 (PedalWheelBoat
, EngineLess
, DayBoat
, WheelBoat
, Boat
,
1043 vereq(SmallCatamaran
.__mro
__,
1044 (SmallCatamaran
, SmallMultihull
, DayBoat
, Boat
, object))
1046 vereq(Pedalo
.__mro
__,
1047 (Pedalo
, PedalWheelBoat
, EngineLess
, SmallCatamaran
,
1048 SmallMultihull
, DayBoat
, WheelBoat
, Boat
, object))
1050 # see "A Monotonic Superclass Linearization for Dylan",
1051 # by Kim Barrett et al. (OOPSLA 1996)
1052 def consistency_with_epg():
1053 if verbose
: print "Testing consistentcy with EPG..."
1054 class Pane(object): pass
1055 class ScrollingMixin(object): pass
1056 class EditingMixin(object): pass
1057 class ScrollablePane(Pane
,ScrollingMixin
): pass
1058 class EditablePane(Pane
,EditingMixin
): pass
1059 class EditableScrollablePane(ScrollablePane
,EditablePane
): pass
1061 vereq(EditableScrollablePane
.__mro
__,
1062 (EditableScrollablePane
, ScrollablePane
, EditablePane
,
1063 Pane
, ScrollingMixin
, EditingMixin
, object))
1065 mro_err_msg
= """Cannot create a consistent method resolution
1066 order (MRO) for bases """
1068 def mro_disagreement():
1069 if verbose
: print "Testing error messages for MRO disagreement..."
1070 def raises(exc
, expected
, callable, *args
):
1074 if not str(msg
).startswith(expected
):
1075 raise TestFailed
, "Message %r, expected %r" % (str(msg
),
1078 raise TestFailed
, "Expected %s" % exc
1079 class A(object): pass
1081 class C(object): pass
1082 # Test some very simple errors
1083 raises(TypeError, "duplicate base class A",
1084 type, "X", (A
, A
), {})
1085 raises(TypeError, mro_err_msg
,
1086 type, "X", (A
, B
), {})
1087 raises(TypeError, mro_err_msg
,
1088 type, "X", (A
, C
, B
), {})
1089 # Test a slightly more complex error
1090 class GridLayout(object): pass
1091 class HorizontalGrid(GridLayout
): pass
1092 class VerticalGrid(GridLayout
): pass
1093 class HVGrid(HorizontalGrid
, VerticalGrid
): pass
1094 class VHGrid(VerticalGrid
, HorizontalGrid
): pass
1095 raises(TypeError, mro_err_msg
,
1096 type, "ConfusedGrid", (HVGrid
, VHGrid
), {})
1099 if verbose
: print "Testing object class..."
1101 vereq(a
.__class
__, object)
1102 vereq(type(a
), object)
1105 verify(not hasattr(a
, "foo"))
1108 except (AttributeError, TypeError):
1111 verify(0, "object() should not allow setting a foo attribute")
1112 verify(not hasattr(object(), "__dict__"))
1114 class Cdict(object):
1117 vereq(x
.__dict
__, {})
1120 vereq(x
.__dict
__, {'foo': 1})
1123 if verbose
: print "Testing __slots__..."
1127 verify(not hasattr(x
, "__dict__"))
1128 verify(not hasattr(x
, "foo"))
1133 verify(not hasattr(x
, "__dict__"))
1134 verify(not hasattr(x
, "a"))
1140 verify(not hasattr(x
, "a"))
1143 __slots__
= ['a', 'b', 'c']
1145 verify(not hasattr(x
, "__dict__"))
1146 verify(not hasattr(x
, 'a'))
1147 verify(not hasattr(x
, 'b'))
1148 verify(not hasattr(x
, 'c'))
1157 """Validate name mangling"""
1159 def __init__(self
, value
):
1164 verify(not hasattr(x
, '__dict__'))
1165 verify(not hasattr(x
, '__a'))
1169 except AttributeError:
1172 raise TestFailed
, "Double underscored names not mangled"
1174 # Make sure slot names are proper identifiers
1181 raise TestFailed
, "[None] slots not caught"
1184 __slots__
= ["foo bar"]
1188 raise TestFailed
, "['foo bar'] slots not caught"
1191 __slots__
= ["foo\0bar"]
1195 raise TestFailed
, "['foo\\0bar'] slots not caught"
1202 raise TestFailed
, "['1'] slots not caught"
1209 raise TestFailed
, "[''] slots not caught"
1211 __slots__
= ["a", "a_b", "_a", "A0123456789Z"]
1214 class Counted(object):
1215 counter
= 0 # counts the number of instances alive
1217 Counted
.counter
+= 1
1219 Counted
.counter
-= 1
1221 __slots__
= ['a', 'b', 'c']
1226 vereq(Counted
.counter
, 3)
1228 vereq(Counted
.counter
, 0)
1234 vereq(Counted
.counter
, 2)
1236 vereq(Counted
.counter
, 0)
1243 vereq(Counted
.counter
, 3)
1245 vereq(Counted
.counter
, 0)
1247 # Test cyclical leaks [SF bug 519621]
1249 __slots__
= ['a', 'b']
1252 s
.a
= [Counted(), s
]
1253 vereq(Counted
.counter
, 1)
1257 vereq(Counted
.counter
, 0)
1259 # Test lookup leaks [SF bug 572567]
1262 def __cmp__(self
, other
):
1265 orig_objects
= len(gc
.get_objects())
1266 for i
in xrange(10):
1268 new_objects
= len(gc
.get_objects())
1269 vereq(orig_objects
, new_objects
)
1271 __slots__
= ['a', 'b']
1279 save_stderr
= sys
.stderr
1280 sys
.stderr
= sys
.stdout
1285 sys
.stderr
= save_stderr
1288 if verbose
: print "Testing __dict__ and __weakref__ in __slots__..."
1291 __slots__
= ["__dict__"]
1293 verify(hasattr(a
, "__dict__"))
1294 verify(not hasattr(a
, "__weakref__"))
1296 vereq(a
.__dict
__, {"foo": 42})
1299 __slots__
= ["__weakref__"]
1301 verify(hasattr(a
, "__weakref__"))
1302 verify(not hasattr(a
, "__dict__"))
1305 except AttributeError:
1308 raise TestFailed
, "shouldn't be allowed to set a.foo"
1313 verify(hasattr(a
, "__dict__"))
1314 verify(hasattr(a
, "__weakref__"))
1316 vereq(a
.__dict
__, {"foo": 42})
1321 verify(hasattr(a
, "__dict__"))
1322 verify(hasattr(a
, "__weakref__"))
1324 vereq(a
.__dict
__, {"foo": 42})
1326 # MRO order disagreement
1335 if verbose
: print "Testing class attribute propagation..."
1344 # Test that dynamic attributes are inherited
1347 # Test dynamic instances
1351 verify(not hasattr(a
, "foobar"))
1354 C
.method
= lambda self
: 42
1355 vereq(a
.method(), 42)
1356 C
.__repr
__ = lambda self
: "C()"
1357 vereq(repr(a
), "C()")
1358 C
.__int
__ = lambda self
: 100
1361 verify(not hasattr(a
, "spam"))
1362 def mygetattr(self
, name
):
1365 raise AttributeError
1366 C
.__getattr
__ = mygetattr
1367 vereq(a
.spam
, "spam")
1370 def mysetattr(self
, name
, value
):
1372 raise AttributeError
1373 return object.__setattr
__(self
, name
, value
)
1374 C
.__setattr
__ = mysetattr
1377 except AttributeError:
1380 verify(0, "expected AttributeError")
1381 vereq(a
.spam
, "spam")
1388 # Test handling of int*seq and seq*int
1391 vereq("a"*I(2), "aa")
1392 vereq(I(2)*"a", "aa")
1397 # Test handling of long*seq and seq*long
1400 vereq("a"*L(2L), "aa")
1401 vereq(L(2L)*"a", "aa")
1406 # Test comparison of classes with dynamic metaclasses
1407 class dynamicmetaclass(type):
1410 __metaclass__
= dynamicmetaclass
1411 verify(someclass
!= object)
1414 if verbose
: print "Testing errors..."
1417 class C(list, dict):
1422 verify(0, "inheritance from both list and dict should be illegal")
1425 class C(object, None):
1430 verify(0, "inheritance from non-type should be illegal")
1440 verify(0, "inheritance from CFunction should be illegal")
1448 verify(0, "__slots__ = 1 should be illegal")
1456 verify(0, "__slots__ = [1] should be illegal")
1459 if verbose
: print "Testing class methods..."
1461 def foo(*a
): return a
1462 goo
= classmethod(foo
)
1464 vereq(C
.goo(1), (C
, 1))
1465 vereq(c
.goo(1), (C
, 1))
1466 vereq(c
.foo(1), (c
, 1))
1470 vereq(D
.goo(1), (D
, 1))
1471 vereq(d
.goo(1), (D
, 1))
1472 vereq(d
.foo(1), (d
, 1))
1473 vereq(D
.foo(d
, 1), (d
, 1))
1474 # Test for a specific crash (SF bug 528132)
1475 def f(cls
, arg
): return (cls
, arg
)
1477 vereq(ff
.__get
__(0, int)(42), (int, 42))
1478 vereq(ff
.__get
__(0)(42), (int, 42))
1480 # Test super() with classmethods (SF bug 535444)
1481 veris(C
.goo
.im_self
, C
)
1482 veris(D
.goo
.im_self
, D
)
1483 veris(super(D
,D
).goo
.im_self
, D
)
1484 veris(super(D
,d
).goo
.im_self
, D
)
1485 vereq(super(D
,D
).goo(), (D
,))
1486 vereq(super(D
,d
).goo(), (D
,))
1488 # Verify that argument is checked for callability (SF bug 753451)
1490 classmethod(1).__get
__(1)
1494 raise TestFailed
, "classmethod should check for callability"
1496 def classmethods_in_c():
1497 if verbose
: print "Testing C-based class methods..."
1498 import xxsubtype
as spam
1501 x
, a1
, d1
= spam
.spamlist
.classmeth(*a
, **d
)
1502 veris(x
, spam
.spamlist
)
1505 x
, a1
, d1
= spam
.spamlist().classmeth(*a
, **d
)
1506 veris(x
, spam
.spamlist
)
1510 def staticmethods():
1511 if verbose
: print "Testing static methods..."
1513 def foo(*a
): return a
1514 goo
= staticmethod(foo
)
1516 vereq(C
.goo(1), (1,))
1517 vereq(c
.goo(1), (1,))
1518 vereq(c
.foo(1), (c
, 1,))
1522 vereq(D
.goo(1), (1,))
1523 vereq(d
.goo(1), (1,))
1524 vereq(d
.foo(1), (d
, 1))
1525 vereq(D
.foo(d
, 1), (d
, 1))
1527 def staticmethods_in_c():
1528 if verbose
: print "Testing C-based static methods..."
1529 import xxsubtype
as spam
1532 x
, a1
, d1
= spam
.spamlist
.staticmeth(*a
, **d
)
1536 x
, a1
, d2
= spam
.spamlist().staticmeth(*a
, **d
)
1542 if verbose
: print "Testing classic classes..."
1544 def foo(*a
): return a
1545 goo
= classmethod(foo
)
1547 vereq(C
.goo(1), (C
, 1))
1548 vereq(c
.goo(1), (C
, 1))
1549 vereq(c
.foo(1), (c
, 1))
1553 vereq(D
.goo(1), (D
, 1))
1554 vereq(d
.goo(1), (D
, 1))
1555 vereq(d
.foo(1), (d
, 1))
1556 vereq(D
.foo(d
, 1), (d
, 1))
1557 class E
: # *not* subclassing from C
1559 vereq(E().foo
, C
.foo
) # i.e., unbound
1560 verify(repr(C
.foo
.__get
__(C())).startswith("<bound method "))
1563 if verbose
: print "Testing computed attributes..."
1565 class computed_attribute(object):
1566 def __init__(self
, get
, set=None, delete
=None):
1569 self
.__delete
= delete
1570 def __get__(self
, obj
, type=None):
1571 return self
.__get
(obj
)
1572 def __set__(self
, obj
, value
):
1573 return self
.__set
(obj
, value
)
1574 def __delete__(self
, obj
):
1575 return self
.__delete
(obj
)
1582 def __set_x(self
, x
):
1584 def __delete_x(self
):
1586 x
= computed_attribute(__get_x
, __set_x
, __delete_x
)
1594 vereq(hasattr(a
, 'x'), 0)
1597 if verbose
: print "Testing __new__ slot override..."
1600 self
= list.__new
__(cls
)
1604 self
.foo
= self
.foo
+ 2
1607 verify(a
.__class
__ is C
)
1612 verify(b
.__class
__ is D
)
1615 if verbose
: print "Testing mro() and overriding it..."
1617 def f(self
): return "A"
1621 def f(self
): return "C"
1624 vereq(D
.mro(), [D
, B
, C
, A
, object])
1625 vereq(D
.__mro
__, (D
, B
, C
, A
, object))
1628 class PerverseMetaType(type):
1634 __metaclass__
= PerverseMetaType
1635 vereq(X
.__mro
__, (object, A
, C
, B
, D
, X
))
1640 class __metaclass__(type):
1642 return [self
, dict, object]
1646 raise TestFailed
, "devious mro() return not caught"
1650 class __metaclass__(type):
1656 raise TestFailed
, "non-class mro() return not caught"
1660 class __metaclass__(type):
1666 raise TestFailed
, "non-sequence mro() return not caught"
1670 if verbose
: print "Testing operator overloading..."
1673 "Intermediate class because object doesn't have a __setattr__"
1677 def __getattr__(self
, name
):
1679 return ("getattr", name
)
1681 raise AttributeError
1682 def __setattr__(self
, name
, value
):
1684 self
.setattr = (name
, value
)
1686 return B
.__setattr
__(self
, name
, value
)
1687 def __delattr__(self
, name
):
1691 return B
.__delattr
__(self
, name
)
1693 def __getitem__(self
, key
):
1694 return ("getitem", key
)
1695 def __setitem__(self
, key
, value
):
1696 self
.setitem
= (key
, value
)
1697 def __delitem__(self
, key
):
1700 def __getslice__(self
, i
, j
):
1701 return ("getslice", i
, j
)
1702 def __setslice__(self
, i
, j
, value
):
1703 self
.setslice
= (i
, j
, value
)
1704 def __delslice__(self
, i
, j
):
1705 self
.delslice
= (i
, j
)
1708 vereq(a
.foo
, ("getattr", "foo"))
1710 vereq(a
.setattr, ("foo", 12))
1712 vereq(a
.delattr, "foo")
1714 vereq(a
[12], ("getitem", 12))
1716 vereq(a
.setitem
, (12, 21))
1718 vereq(a
.delitem
, 12)
1720 vereq(a
[0:10], ("getslice", 0, 10))
1722 vereq(a
.setslice
, (0, 10, "foo"))
1724 vereq(a
.delslice
, (0, 10))
1727 if verbose
: print "Testing methods..."
1729 def __init__(self
, x
):
1744 vereq(E().foo
, C
.foo
) # i.e., unbound
1745 verify(repr(C
.foo
.__get
__(C(1))).startswith("<bound method "))
1748 # Test operators like __hash__ for which a built-in default exists
1749 if verbose
: print "Testing special operators..."
1750 # Test the default behavior for static classes
1752 def __getitem__(self
, i
):
1753 if 0 <= i
< 10: return i
1758 vereq(hash(c1
), id(c1
))
1759 vereq(cmp(c1
, c2
), cmp(id(c1
), id(c2
)))
1762 verify(not c1
!= c1
)
1763 verify(not c1
== c2
)
1764 # Note that the module name appears in str/repr, and that varies
1765 # depending on whether this test is run standalone or from a framework.
1766 verify(str(c1
).find('C object at ') >= 0)
1767 vereq(str(c1
), repr(c1
))
1768 verify(-1 not in c1
)
1771 verify(10 not in c1
)
1772 # Test the default behavior for dynamic classes
1774 def __getitem__(self
, i
):
1775 if 0 <= i
< 10: return i
1780 vereq(hash(d1
), id(d1
))
1781 vereq(cmp(d1
, d2
), cmp(id(d1
), id(d2
)))
1784 verify(not d1
!= d1
)
1785 verify(not d1
== d2
)
1786 # Note that the module name appears in str/repr, and that varies
1787 # depending on whether this test is run standalone or from a framework.
1788 verify(str(d1
).find('D object at ') >= 0)
1789 vereq(str(d1
), repr(d1
))
1790 verify(-1 not in d1
)
1793 verify(10 not in d1
)
1794 # Test overridden behavior for static classes
1795 class Proxy(object):
1796 def __init__(self
, x
):
1798 def __nonzero__(self
):
1799 return not not self
.x
1802 def __eq__(self
, other
):
1803 return self
.x
== other
1804 def __ne__(self
, other
):
1805 return self
.x
!= other
1806 def __cmp__(self
, other
):
1807 return cmp(self
.x
, other
.x
)
1809 return "Proxy:%s" % self
.x
1811 return "Proxy(%r)" % self
.x
1812 def __contains__(self
, value
):
1813 return value
in self
.x
1819 vereq(hash(p0
), hash(0))
1822 verify(not p0
!= p0
)
1824 vereq(cmp(p0
, p1
), -1)
1825 vereq(cmp(p0
, p0
), 0)
1826 vereq(cmp(p0
, p_1
), 1)
1827 vereq(str(p0
), "Proxy:0")
1828 vereq(repr(p0
), "Proxy(0)")
1829 p10
= Proxy(range(10))
1830 verify(-1 not in p10
)
1833 verify(10 not in p10
)
1834 # Test overridden behavior for dynamic classes
1835 class DProxy(object):
1836 def __init__(self
, x
):
1838 def __nonzero__(self
):
1839 return not not self
.x
1842 def __eq__(self
, other
):
1843 return self
.x
== other
1844 def __ne__(self
, other
):
1845 return self
.x
!= other
1846 def __cmp__(self
, other
):
1847 return cmp(self
.x
, other
.x
)
1849 return "DProxy:%s" % self
.x
1851 return "DProxy(%r)" % self
.x
1852 def __contains__(self
, value
):
1853 return value
in self
.x
1859 vereq(hash(p0
), hash(0))
1862 verify(not p0
!= p0
)
1864 vereq(cmp(p0
, p1
), -1)
1865 vereq(cmp(p0
, p0
), 0)
1866 vereq(cmp(p0
, p_1
), 1)
1867 vereq(str(p0
), "DProxy:0")
1868 vereq(repr(p0
), "DProxy(0)")
1869 p10
= DProxy(range(10))
1870 verify(-1 not in p10
)
1873 verify(10 not in p10
)
1874 # Safety test for __cmp__
1875 def unsafecmp(a
, b
):
1877 a
.__class
__.__cmp
__(a
, b
)
1881 raise TestFailed
, "shouldn't allow %s.__cmp__(%r, %r)" % (
1883 unsafecmp(u
"123", "123")
1884 unsafecmp("123", u
"123")
1891 def __new__(cls
, letter
):
1893 return str.__new
__(cls
)
1894 return str.__new
__(cls
, letter
)
1900 # sys.stdout needs to be the original to trigger the recursion bug
1902 test_stdout
= sys
.stdout
1903 sys
.stdout
= get_original_stdout()
1905 # nothing should actually be printed, this should raise an exception
1907 except RuntimeError:
1910 raise TestFailed
, "expected a RuntimeError for print recursion"
1911 sys
.stdout
= test_stdout
1914 if verbose
: print "Testing weak references..."
1924 class NoWeak(object):
1929 except TypeError, msg
:
1930 verify(str(msg
).find("weak reference") >= 0)
1932 verify(0, "weakref.ref(no) should be illegal")
1934 __slots__
= ['foo', '__weakref__']
1936 r
= weakref
.ref(yes
)
1943 if verbose
: print "Testing property..."
1947 def setx(self
, value
):
1951 x
= property(getx
, setx
, delx
, doc
="I'm the x property.")
1953 verify(not hasattr(a
, "x"))
1958 verify(not hasattr(a
, "x"))
1959 verify(not hasattr(a
, "_C__x"))
1961 vereq(C
.x
.__get
__(a
), 100)
1963 verify(not hasattr(a
, "x"))
1965 raw
= C
.__dict
__['x']
1966 verify(isinstance(raw
, property))
1969 verify("__doc__" in attrs
)
1970 verify("fget" in attrs
)
1971 verify("fset" in attrs
)
1972 verify("fdel" in attrs
)
1974 vereq(raw
.__doc
__, "I'm the x property.")
1975 verify(raw
.fget
is C
.__dict
__['getx'])
1976 verify(raw
.fset
is C
.__dict
__['setx'])
1977 verify(raw
.fdel
is C
.__dict
__['delx'])
1979 for attr
in "__doc__", "fget", "fset", "fdel":
1981 setattr(raw
, attr
, 42)
1982 except TypeError, msg
:
1983 if str(msg
).find('readonly') < 0:
1984 raise TestFailed("when setting readonly attr %r on a "
1985 "property, got unexpected TypeError "
1986 "msg %r" % (attr
, str(msg
)))
1988 raise TestFailed("expected TypeError from trying to set "
1989 "readonly %r attr on a property" % attr
)
1992 __getitem__
= property(lambda s
: 1/0)
1998 except ZeroDivisionError:
2001 raise TestFailed
, "expected ZeroDivisionError from bad property"
2004 if verbose
: print "Testing super..."
2010 vereq(A().meth(1), "A(1)")
2014 self
.__super
= super(B
, self
)
2016 return "B(%r)" % a
+ self
.__super
.meth(a
)
2018 vereq(B().meth(2), "B(2)A(2)")
2022 return "C(%r)" % a
+ self
.__super
.meth(a
)
2023 C
._C
__super
= super(C
)
2025 vereq(C().meth(3), "C(3)A(3)")
2029 return "D(%r)" % a
+ super(D
, self
).meth(a
)
2031 vereq(D().meth(4), "D(4)C(4)B(4)A(4)")
2033 # Test for subclassing super
2035 class mysuper(super):
2036 def __init__(self
, *args
):
2037 return super(mysuper
, self
).__init
__(*args
)
2041 return "E(%r)" % a
+ mysuper(E
, self
).meth(a
)
2043 vereq(E().meth(5), "E(5)D(5)C(5)B(5)A(5)")
2047 s
= self
.__super
# == mysuper(F, self)
2048 return "F(%r)[%s]" % (a
, s
.__class
__.__name
__) + s
.meth(a
)
2049 F
._F
__super
= mysuper(F
)
2051 vereq(F().meth(6), "F(6)[mysuper]E(6)D(6)C(6)B(6)A(6)")
2053 # Make sure certain errors are raised
2060 raise TestFailed
, "shouldn't allow super(D, 42)"
2067 raise TestFailed
, "shouldn't allow super(D, C())"
2070 super(D
).__get
__(12)
2074 raise TestFailed
, "shouldn't allow super(D).__get__(12)"
2077 super(D
).__get
__(C())
2081 raise TestFailed
, "shouldn't allow super(D).__get__(C())"
2083 # Make sure data descriptors can be overridden and accessed via super
2084 # (new feature in Python 2.3)
2086 class DDbase(object):
2087 def getx(self
): return 42
2090 class DDsub(DDbase
):
2091 def getx(self
): return "hello"
2095 vereq(dd
.x
, "hello")
2096 vereq(super(DDsub
, dd
).x
, 42)
2098 # Ensure that super() lookup of descriptor from classmethod
2099 # works (SF ID# 743627)
2102 aProp
= property(lambda self
: "foo")
2107 return super(Sub
,klass
).aProp
2109 veris(Sub
.test(), Base
.aProp
)
2113 if verbose
: print "Testing inheritance from basic types..."
2118 def __add__(self
, other
):
2119 return hexint(int.__add
__(self
, other
))
2120 # (Note that overriding __radd__ doesn't work,
2121 # because the int type gets first dibs.)
2122 vereq(repr(hexint(7) + 9), "0x10")
2123 vereq(repr(hexint(1000) + 7), "0x3ef")
2126 vereq(int(a
), 12345)
2127 verify(int(a
).__class
__ is int)
2128 vereq(hash(a
), hash(12345))
2129 verify((+a
).__class
__ is int)
2130 verify((a
>> 0).__class
__ is int)
2131 verify((a
<< 0).__class
__ is int)
2132 verify((hexint(0) << 12).__class
__ is int)
2133 verify((hexint(0) >> 12).__class
__ is int)
2135 class octlong(long):
2142 def __add__(self
, other
):
2143 return self
.__class
__(super(octlong
, self
).__add
__(other
))
2145 vereq(str(octlong(3) + 5), "010")
2146 # (Note that overriding __radd__ here only seems to work
2147 # because the example uses a short int left argument.)
2148 vereq(str(5 + octlong(3000)), "05675")
2151 vereq(long(a
), 12345L)
2152 vereq(hash(a
), hash(12345L))
2153 verify(long(a
).__class
__ is long)
2154 verify((+a
).__class
__ is long)
2155 verify((-a
).__class
__ is long)
2156 verify((-octlong(0)).__class
__ is long)
2157 verify((a
>> 0).__class
__ is long)
2158 verify((a
<< 0).__class
__ is long)
2159 verify((a
- 0).__class
__ is long)
2160 verify((a
* 1).__class
__ is long)
2161 verify((a
** 1).__class
__ is long)
2162 verify((a
// 1).__class
__ is long)
2163 verify((1 * a
).__class
__ is long)
2164 verify((a |
0).__class
__ is long)
2165 verify((a ^
0).__class
__ is long)
2166 verify((a
& -1L).__class
__ is long)
2167 verify((octlong(0) << 12).__class
__ is long)
2168 verify((octlong(0) >> 12).__class
__ is long)
2169 verify(abs(octlong(0)).__class
__ is long)
2171 # Because octlong overrides __add__, we can't check the absence of +0
2172 # optimizations using octlong.
2173 class longclone(long):
2176 verify((a
+ 0).__class
__ is long)
2177 verify((0 + a
).__class
__ is long)
2179 # Check that negative clones don't segfault
2181 vereq(a
.__dict
__, {})
2182 vereq(long(a
), -1) # verify PyNumber_Long() copies the sign bit
2184 class precfloat(float):
2185 __slots__
= ['prec']
2186 def __init__(self
, value
=0.0, prec
=12):
2187 self
.prec
= int(prec
)
2188 float.__init
__(value
)
2190 return "%.*g" % (self
.prec
, self
)
2191 vereq(repr(precfloat(1.1)), "1.1")
2192 a
= precfloat(12345)
2194 vereq(float(a
), 12345.0)
2195 verify(float(a
).__class
__ is float)
2196 vereq(hash(a
), hash(12345.0))
2197 verify((+a
).__class
__ is float)
2199 class madcomplex(complex):
2201 return "%.17gj%+.17g" % (self
.imag
, self
.real
)
2202 a
= madcomplex(-3, 4)
2203 vereq(repr(a
), "4j-3")
2204 base
= complex(-3, 4)
2205 veris(base
.__class
__, complex)
2207 vereq(complex(a
), base
)
2208 veris(complex(a
).__class
__, complex)
2209 a
= madcomplex(a
) # just trying another form of the constructor
2210 vereq(repr(a
), "4j-3")
2212 vereq(complex(a
), base
)
2213 veris(complex(a
).__class
__, complex)
2214 vereq(hash(a
), hash(base
))
2215 veris((+a
).__class
__, complex)
2216 veris((a
+ 0).__class
__, complex)
2218 veris((a
- 0).__class
__, complex)
2220 veris((a
* 1).__class
__, complex)
2222 veris((a
/ 1).__class
__, complex)
2225 class madtuple(tuple):
2228 if self
._rev
is not None:
2232 self
._rev
= self
.__class
__(L
)
2234 a
= madtuple((1,2,3,4,5,6,7,8,9,0))
2235 vereq(a
, (1,2,3,4,5,6,7,8,9,0))
2236 vereq(a
.rev(), madtuple((0,9,8,7,6,5,4,3,2,1)))
2237 vereq(a
.rev().rev(), madtuple((1,2,3,4,5,6,7,8,9,0)))
2238 for i
in range(512):
2239 t
= madtuple(range(i
))
2243 a
= madtuple((1,2,3,4,5))
2244 vereq(tuple(a
), (1,2,3,4,5))
2245 verify(tuple(a
).__class
__ is tuple)
2246 vereq(hash(a
), hash((1,2,3,4,5)))
2247 verify(a
[:].__class
__ is tuple)
2248 verify((a
* 1).__class
__ is tuple)
2249 verify((a
* 0).__class
__ is tuple)
2250 verify((a
+ ()).__class
__ is tuple)
2253 verify(tuple(a
).__class
__ is tuple)
2254 verify((a
+ a
).__class
__ is tuple)
2255 verify((a
* 0).__class
__ is tuple)
2256 verify((a
* 1).__class
__ is tuple)
2257 verify((a
* 2).__class
__ is tuple)
2258 verify(a
[:].__class
__ is tuple)
2260 class madstring(str):
2263 if self
._rev
is not None:
2267 self
._rev
= self
.__class
__("".join(L
))
2269 s
= madstring("abcdefghijklmnopqrstuvwxyz")
2270 vereq(s
, "abcdefghijklmnopqrstuvwxyz")
2271 vereq(s
.rev(), madstring("zyxwvutsrqponmlkjihgfedcba"))
2272 vereq(s
.rev().rev(), madstring("abcdefghijklmnopqrstuvwxyz"))
2273 for i
in range(256):
2274 s
= madstring("".join(map(chr, range(i
))))
2278 s
= madstring("12345")
2279 vereq(str(s
), "12345")
2280 verify(str(s
).__class
__ is str)
2286 verify(str(s
).__class
__ is str)
2287 vereq(hash(s
), hash(base
))
2288 vereq({s
: 1}[base
], 1)
2289 vereq({base
: 1}[s
], 1)
2290 verify((s
+ "").__class
__ is str)
2292 verify(("" + s
).__class
__ is str)
2294 verify((s
* 0).__class
__ is str)
2296 verify((s
* 1).__class
__ is str)
2298 verify((s
* 2).__class
__ is str)
2299 vereq(s
* 2, base
+ base
)
2300 verify(s
[:].__class
__ is str)
2302 verify(s
[0:0].__class
__ is str)
2304 verify(s
.strip().__class
__ is str)
2305 vereq(s
.strip(), base
)
2306 verify(s
.lstrip().__class
__ is str)
2307 vereq(s
.lstrip(), base
)
2308 verify(s
.rstrip().__class
__ is str)
2309 vereq(s
.rstrip(), base
)
2310 identitytab
= ''.join([chr(i
) for i
in range(256)])
2311 verify(s
.translate(identitytab
).__class
__ is str)
2312 vereq(s
.translate(identitytab
), base
)
2313 verify(s
.translate(identitytab
, "x").__class
__ is str)
2314 vereq(s
.translate(identitytab
, "x"), base
)
2315 vereq(s
.translate(identitytab
, "\x00"), "")
2316 verify(s
.replace("x", "x").__class
__ is str)
2317 vereq(s
.replace("x", "x"), base
)
2318 verify(s
.ljust(len(s
)).__class
__ is str)
2319 vereq(s
.ljust(len(s
)), base
)
2320 verify(s
.rjust(len(s
)).__class
__ is str)
2321 vereq(s
.rjust(len(s
)), base
)
2322 verify(s
.center(len(s
)).__class
__ is str)
2323 vereq(s
.center(len(s
)), base
)
2324 verify(s
.lower().__class
__ is str)
2325 vereq(s
.lower(), base
)
2327 class madunicode(unicode):
2330 if self
._rev
is not None:
2334 self
._rev
= self
.__class
__(u
"".join(L
))
2336 u
= madunicode("ABCDEF")
2338 vereq(u
.rev(), madunicode(u
"FEDCBA"))
2339 vereq(u
.rev().rev(), madunicode(u
"ABCDEF"))
2341 u
= madunicode(base
)
2342 vereq(unicode(u
), base
)
2343 verify(unicode(u
).__class
__ is unicode)
2344 vereq(hash(u
), hash(base
))
2345 vereq({u
: 1}[base
], 1)
2346 vereq({base
: 1}[u
], 1)
2347 verify(u
.strip().__class
__ is unicode)
2348 vereq(u
.strip(), base
)
2349 verify(u
.lstrip().__class
__ is unicode)
2350 vereq(u
.lstrip(), base
)
2351 verify(u
.rstrip().__class
__ is unicode)
2352 vereq(u
.rstrip(), base
)
2353 verify(u
.replace(u
"x", u
"x").__class
__ is unicode)
2354 vereq(u
.replace(u
"x", u
"x"), base
)
2355 verify(u
.replace(u
"xy", u
"xy").__class
__ is unicode)
2356 vereq(u
.replace(u
"xy", u
"xy"), base
)
2357 verify(u
.center(len(u
)).__class
__ is unicode)
2358 vereq(u
.center(len(u
)), base
)
2359 verify(u
.ljust(len(u
)).__class
__ is unicode)
2360 vereq(u
.ljust(len(u
)), base
)
2361 verify(u
.rjust(len(u
)).__class
__ is unicode)
2362 vereq(u
.rjust(len(u
)), base
)
2363 verify(u
.lower().__class
__ is unicode)
2364 vereq(u
.lower(), base
)
2365 verify(u
.upper().__class
__ is unicode)
2366 vereq(u
.upper(), base
)
2367 verify(u
.capitalize().__class
__ is unicode)
2368 vereq(u
.capitalize(), base
)
2369 verify(u
.title().__class
__ is unicode)
2370 vereq(u
.title(), base
)
2371 verify((u
+ u
"").__class
__ is unicode)
2372 vereq(u
+ u
"", base
)
2373 verify((u
"" + u
).__class
__ is unicode)
2374 vereq(u
"" + u
, base
)
2375 verify((u
* 0).__class
__ is unicode)
2377 verify((u
* 1).__class
__ is unicode)
2379 verify((u
* 2).__class
__ is unicode)
2380 vereq(u
* 2, base
+ base
)
2381 verify(u
[:].__class
__ is unicode)
2383 verify(u
[0:0].__class
__ is unicode)
2386 class sublist(list):
2388 a
= sublist(range(5))
2391 vereq(a
, range(5) + ["hello"])
2394 a
.extend(range(6, 20))
2401 vereq(list(a
), range(10))
2406 vereq(a
[:5], range(5))
2408 class CountedInput(file):
2409 """Counts lines read by self.readline().
2411 self.lineno is the 0-based ordinal of the last line read, up to
2412 a maximum of one greater than the number of lines in the file.
2414 self.ateof is true if and only if the final "" line has been read,
2415 at which point self.lineno stops incrementing, and further calls
2416 to readline() continue to return "".
2424 s
= file.readline(self
)
2425 # Next line works too.
2426 # s = super(CountedInput, self).readline()
2432 f
= file(name
=TESTFN
, mode
='w')
2433 lines
= ['a\n', 'b\n', 'c\n']
2437 f
= CountedInput(TESTFN
)
2438 for (i
, expected
) in zip(range(1, 5) + [4], lines
+ 2 * [""]):
2440 vereq(expected
, got
)
2442 vereq(f
.ateof
, (i
> len(lines
)))
2457 print "Testing keyword args to basic type constructors ..."
2459 vereq(float(x
=2), 2.0)
2460 vereq(long(x
=3), 3L)
2461 vereq(complex(imag
=42, real
=666), complex(666, 42))
2462 vereq(str(object=500), '500')
2463 vereq(unicode(string
='abc', errors
='strict'), u
'abc')
2464 vereq(tuple(sequence
=range(3)), (0, 1, 2))
2465 vereq(list(sequence
=(0, 1, 2)), range(3))
2466 # note: as of Python 2.3, dict() no longer has an "items" keyword arg
2468 for constructor
in (int, float, long, complex, str, unicode,
2471 constructor(bogus_keyword_arg
=1)
2475 raise TestFailed("expected TypeError from bogus keyword "
2476 "argument to %r" % constructor
)
2479 # XXX This test is disabled because rexec is not deemed safe
2483 print "Testing interaction with restricted execution ..."
2485 sandbox
= rexec
.RExec()
2487 code1
= """f = open(%r, 'w')""" % TESTFN
2488 code2
= """f = file(%r, 'w')""" % TESTFN
2491 t = type(f) # a sneaky way to get the file() constructor
2493 f = t(%r, 'w') # rexec can't catch this by itself
2494 """ % (TESTFN
, TESTFN
)
2496 f
= open(TESTFN
, 'w') # Create the file so code3 can find it.
2500 for code
in code1
, code2
, code3
:
2502 sandbox
.r_exec(code
)
2503 except IOError, msg
:
2504 if str(msg
).find("restricted") >= 0:
2507 outcome
= "got an exception, but not an expected one"
2509 outcome
= "expected a restricted-execution exception"
2512 raise TestFailed("%s, in %r" % (outcome
, code
))
2521 def str_subclass_as_dict_key():
2523 print "Testing a str subclass used as dict key .."
2526 """Sublcass of str that computes __eq__ case-insensitively.
2528 Also computes a hash code of the string in canonical form.
2531 def __init__(self
, value
):
2532 self
.canonical
= value
.lower()
2533 self
.hashcode
= hash(self
.canonical
)
2535 def __eq__(self
, other
):
2536 if not isinstance(other
, cistr
):
2537 other
= cistr(other
)
2538 return self
.canonical
== other
.canonical
2541 return self
.hashcode
2543 vereq(cistr('ABC'), 'abc')
2544 vereq('aBc', cistr('ABC'))
2545 vereq(str(cistr('ABC')), 'ABC')
2547 d
= {cistr('one'): 1, cistr('two'): 2, cistr('tHree'): 3}
2548 vereq(d
[cistr('one')], 1)
2549 vereq(d
[cistr('tWo')], 2)
2550 vereq(d
[cistr('THrEE')], 3)
2551 verify(cistr('ONe') in d
)
2552 vereq(d
.get(cistr('thrEE')), 3)
2554 def classic_comparisons():
2555 if verbose
: print "Testing classic comparisons..."
2558 for base
in (classic
, int, object):
2559 if verbose
: print " (base = %s)" % base
2561 def __init__(self
, value
):
2562 self
.value
= int(value
)
2563 def __cmp__(self
, other
):
2564 if isinstance(other
, C
):
2565 return cmp(self
.value
, other
.value
)
2566 if isinstance(other
, int) or isinstance(other
, long):
2567 return cmp(self
.value
, other
)
2568 return NotImplemented
2573 c
= {1: c1
, 2: c2
, 3: c3
}
2576 verify(cmp(c
[x
], c
[y
]) == cmp(x
, y
), "x=%d, y=%d" % (x
, y
))
2577 for op
in "<", "<=", "==", "!=", ">", ">=":
2578 verify(eval("c[x] %s c[y]" % op
) == eval("x %s y" % op
),
2579 "x=%d, y=%d" % (x
, y
))
2580 verify(cmp(c
[x
], y
) == cmp(x
, y
), "x=%d, y=%d" % (x
, y
))
2581 verify(cmp(x
, c
[y
]) == cmp(x
, y
), "x=%d, y=%d" % (x
, y
))
2583 def rich_comparisons():
2585 print "Testing rich comparisons..."
2592 def __eq__(self
, other
):
2594 return abs(self
- other
) <= 1e-6
2596 return NotImplemented
2603 for base
in (classic
, int, object, list):
2604 if verbose
: print " (base = %s)" % base
2606 def __init__(self
, value
):
2607 self
.value
= int(value
)
2608 def __cmp__(self
, other
):
2609 raise TestFailed
, "shouldn't call __cmp__"
2610 def __eq__(self
, other
):
2611 if isinstance(other
, C
):
2612 return self
.value
== other
.value
2613 if isinstance(other
, int) or isinstance(other
, long):
2614 return self
.value
== other
2615 return NotImplemented
2616 def __ne__(self
, other
):
2617 if isinstance(other
, C
):
2618 return self
.value
!= other
.value
2619 if isinstance(other
, int) or isinstance(other
, long):
2620 return self
.value
!= other
2621 return NotImplemented
2622 def __lt__(self
, other
):
2623 if isinstance(other
, C
):
2624 return self
.value
< other
.value
2625 if isinstance(other
, int) or isinstance(other
, long):
2626 return self
.value
< other
2627 return NotImplemented
2628 def __le__(self
, other
):
2629 if isinstance(other
, C
):
2630 return self
.value
<= other
.value
2631 if isinstance(other
, int) or isinstance(other
, long):
2632 return self
.value
<= other
2633 return NotImplemented
2634 def __gt__(self
, other
):
2635 if isinstance(other
, C
):
2636 return self
.value
> other
.value
2637 if isinstance(other
, int) or isinstance(other
, long):
2638 return self
.value
> other
2639 return NotImplemented
2640 def __ge__(self
, other
):
2641 if isinstance(other
, C
):
2642 return self
.value
>= other
.value
2643 if isinstance(other
, int) or isinstance(other
, long):
2644 return self
.value
>= other
2645 return NotImplemented
2650 c
= {1: c1
, 2: c2
, 3: c3
}
2653 for op
in "<", "<=", "==", "!=", ">", ">=":
2654 verify(eval("c[x] %s c[y]" % op
) == eval("x %s y" % op
),
2655 "x=%d, y=%d" % (x
, y
))
2656 verify(eval("c[x] %s y" % op
) == eval("x %s y" % op
),
2657 "x=%d, y=%d" % (x
, y
))
2658 verify(eval("x %s c[y]" % op
) == eval("x %s y" % op
),
2659 "x=%d, y=%d" % (x
, y
))
2662 if verbose
: print "Testing coercions..."
2671 class F(float): pass
2678 class C(complex): pass
2689 if verbose
: print "Testing descriptor doc strings..."
2690 def check(descr
, what
):
2691 vereq(descr
.__doc
__, what
)
2692 check(file.closed
, "True if the file is closed") # getset descriptor
2693 check(file.name
, "file name") # member descriptor
2696 if verbose
: print "Testing __class__ assignment..."
2697 class C(object): pass
2698 class D(object): pass
2699 class E(object): pass
2701 for cls
in C
, D
, E
, F
:
2702 for cls2
in C
, D
, E
, F
:
2705 verify(x
.__class
__ is cls2
)
2707 verify(x
.__class
__ is cls
)
2714 raise TestFailed
, "shouldn't allow %r.__class__ = %r" % (x
, C
)
2716 delattr(x
, "__class__")
2720 raise TestFailed
, "shouldn't allow del %r.__class__" % x
2725 cant(object(), list)
2726 cant(list(), object)
2727 class Int(int): __slots__
= []
2738 if verbose
: print "Testing __dict__ assignment..."
2739 class C(object): pass
2741 a
.__dict
__ = {'b': 1}
2746 except (AttributeError, TypeError):
2749 raise TestFailed
, "shouldn't allow %r.__dict__ = %r" % (x
, dict)
2753 del a
.__dict
__ # Deleting __dict__ is allowed
2754 # Classes don't allow __dict__ assignment
2759 print "Testing pickling and copying new-style classes and objects..."
2760 import pickle
, cPickle
2769 def __init__(self
, a
, b
):
2770 super(C
, self
).__init
__()
2774 return "C(%r, %r)" % (self
.a
, self
.b
)
2778 def __new__(cls
, a
, b
):
2779 return super(C1
, cls
).__new
__(cls
)
2780 def __getnewargs__(self
):
2781 return (self
.a
, self
.b
)
2782 def __init__(self
, a
, b
):
2786 return "C1(%r, %r)<%r>" % (self
.a
, self
.b
, list(self
))
2790 def __new__(cls
, a
, b
, val
=0):
2791 return super(C2
, cls
).__new
__(cls
, val
)
2792 def __getnewargs__(self
):
2793 return (self
.a
, self
.b
, int(self
))
2794 def __init__(self
, a
, b
, val
=0):
2798 return "C2(%r, %r)<%r>" % (self
.a
, self
.b
, int(self
))
2802 def __init__(self
, foo
):
2804 def __getstate__(self
):
2806 def __setstate__(self
, foo
):
2809 global C4classic
, C4
2810 class C4classic
: # classic
2812 class C4(C4classic
, object): # mixed inheritance
2815 for p
in pickle
, cPickle
:
2818 print p
.__name
__, ["text", "binary"][bin
]
2820 for cls
in C
, C1
, C2
:
2821 s
= p
.dumps(cls
, bin
)
2825 a
= C1(1, 2); a
.append(42); a
.append(24)
2826 b
= C2("hello", "world", 42)
2827 s
= p
.dumps((a
, b
), bin
)
2829 vereq(x
.__class
__, a
.__class
__)
2830 vereq(sorteditems(x
.__dict
__), sorteditems(a
.__dict
__))
2831 vereq(y
.__class
__, b
.__class
__)
2832 vereq(sorteditems(y
.__dict
__), sorteditems(b
.__dict
__))
2833 vereq(repr(x
), repr(a
))
2834 vereq(repr(y
), repr(b
))
2838 # Test for __getstate__ and __setstate__ on new style class
2842 veris(u
.__class
__, v
.__class
__)
2844 # Test for picklability of hybrid class
2849 veris(u
.__class
__, v
.__class
__)
2852 # Testing copy.deepcopy()
2856 for cls
in C
, C1
, C2
:
2857 cls2
= copy
.deepcopy(cls
)
2860 a
= C1(1, 2); a
.append(42); a
.append(24)
2861 b
= C2("hello", "world", 42)
2862 x
, y
= copy
.deepcopy((a
, b
))
2863 vereq(x
.__class
__, a
.__class
__)
2864 vereq(sorteditems(x
.__dict
__), sorteditems(a
.__dict
__))
2865 vereq(y
.__class
__, b
.__class
__)
2866 vereq(sorteditems(y
.__dict
__), sorteditems(b
.__dict
__))
2867 vereq(repr(x
), repr(a
))
2868 vereq(repr(y
), repr(b
))
2874 if verbose
: print "Testing pickling of classes with __slots__ ..."
2875 import pickle
, cPickle
2876 # Pickling of classes with __slots__ but without __getstate__ should fail
2880 for base
in [object, B
]:
2890 raise TestFailed
, "should fail: pickle C instance - %s" % base
2896 raise TestFailed
, "should fail: cPickle C instance - %s" % base
2902 raise TestFailed
, "should fail: pickle D instance - %s" % base
2908 raise TestFailed
, "should fail: cPickle D instance - %s" % base
2909 # Give C a nice generic __getstate__ and __setstate__
2912 def __getstate__(self
):
2914 d
= self
.__dict
__.copy()
2915 except AttributeError:
2917 for cls
in self
.__class
__.__mro
__:
2918 for sn
in cls
.__dict
__.get('__slots__', ()):
2920 d
[sn
] = getattr(self
, sn
)
2921 except AttributeError:
2924 def __setstate__(self
, d
):
2925 for k
, v
in d
.items():
2929 # Now it should work
2931 y
= pickle
.loads(pickle
.dumps(x
))
2932 vereq(hasattr(y
, 'a'), 0)
2933 y
= cPickle
.loads(cPickle
.dumps(x
))
2934 vereq(hasattr(y
, 'a'), 0)
2936 y
= pickle
.loads(pickle
.dumps(x
))
2938 y
= cPickle
.loads(cPickle
.dumps(x
))
2943 y
= pickle
.loads(pickle
.dumps(x
))
2944 vereq(y
.a
+ y
.b
, 142)
2945 y
= cPickle
.loads(cPickle
.dumps(x
))
2946 vereq(y
.a
+ y
.b
, 142)
2947 # A subclass that adds a slot should also work
2953 y
= pickle
.loads(pickle
.dumps(x
))
2956 y
= cPickle
.loads(cPickle
.dumps(x
))
2961 if verbose
: print "Testing copy.copy() and copy.deepcopy()..."
2969 vereq(b
.__dict
__, a
.__dict
__)
2974 verify(c
.bar
is a
.bar
)
2976 d
= copy
.deepcopy(a
)
2977 vereq(d
.__dict
__, a
.__dict
__)
2979 vereq(d
.bar
, [1,2,3])
2981 def binopoverride():
2982 if verbose
: print "Testing overrides of binary operations..."
2985 return "I(%r)" % int(self
)
2986 def __add__(self
, other
):
2987 return I(int(self
) + int(other
))
2989 def __pow__(self
, other
, mod
=None):
2991 return I(pow(int(self
), int(other
)))
2993 return I(pow(int(self
), int(other
), int(mod
)))
2994 def __rpow__(self
, other
, mod
=None):
2996 return I(pow(int(other
), int(self
), mod
))
2998 return I(pow(int(other
), int(self
), int(mod
)))
3000 vereq(repr(I(1) + I(2)), "I(3)")
3001 vereq(repr(I(1) + 2), "I(3)")
3002 vereq(repr(1 + I(2)), "I(3)")
3003 vereq(repr(I(2) ** I(3)), "I(8)")
3004 vereq(repr(2 ** I(3)), "I(8)")
3005 vereq(repr(I(2) ** 3), "I(8)")
3006 vereq(repr(pow(I(2), I(3), I(5))), "I(3)")
3008 def __eq__(self
, other
):
3009 return self
.lower() == other
.lower()
3011 def subclasspropagation():
3012 if verbose
: print "Testing propagation of slot functions to subclasses..."
3022 vereq(hash(d
), id(d
))
3023 A
.__hash
__ = lambda self
: 42
3025 C
.__hash
__ = lambda self
: 314
3027 B
.__hash
__ = lambda self
: 144
3029 D
.__hash
__ = lambda self
: 100
3038 vereq(hash(d
), id(d
))
3043 def __getattribute__(self
, name
):
3046 return object.__getattribute
__(self
, name
)
3047 A
.__getattribute
__ = __getattribute__
3050 def __getattr__(self
, name
):
3051 if name
in ("spam", "foo", "bar"):
3053 raise AttributeError, name
3054 B
.__getattr
__ = __getattr__
3055 vereq(d
.spam
, "hello")
3058 del A
.__getattribute
__
3061 vereq(d
.foo
, "hello")
3066 except AttributeError:
3069 raise TestFailed
, "d.foo should be undefined now"
3071 # Test a nasty bug in recurse_down_subclasses()
3079 A
.__setitem
__ = lambda *a
: None # crash
3081 def buffer_inherit():
3083 # SF bug [#470040] ParseTuple t# vs subclasses.
3085 print "Testing that buffer interface is inherited ..."
3091 # b2a_hex uses the buffer interface to get its argument's value, via
3092 # PyArg_ParseTuple 't#' code.
3093 vereq(binascii
.b2a_hex(m
), binascii
.b2a_hex(base
))
3095 # It's not clear that unicode will continue to support the character
3096 # buffer interface, and this test will fail if that's taken away.
3097 class MyUni(unicode):
3101 vereq(binascii
.b2a_hex(m
), binascii
.b2a_hex(base
))
3108 raise TestFailed('subclass of int should not have a buffer interface')
3112 def str_of_str_subclass():
3117 print "Testing __str__ defined in subclass of str ..."
3119 class octetstring(str):
3121 return binascii
.b2a_hex(self
)
3123 return self
+ " repr"
3125 o
= octetstring('A')
3126 vereq(type(o
), octetstring
)
3127 vereq(type(str(o
)), str)
3128 vereq(type(repr(o
)), str)
3131 vereq(repr(o
), 'A repr')
3132 vereq(o
.__str
__(), '41')
3133 vereq(o
.__repr
__(), 'A repr')
3135 capture
= cStringIO
.StringIO()
3136 # Calling str() or not exercises different internal paths.
3138 print >> capture
, str(o
)
3139 vereq(capture
.getvalue(), '41\n41\n')
3143 if verbose
: print "Testing keyword arguments to __init__, __call__..."
3145 vereq(f
.__call
__(a
=42), 42)
3147 list.__init
__(a
, sequence
=[0, 1, 2])
3151 if verbose
: print "Testing __del__ hook..."
3161 class D(object): pass
3164 except TypeError: pass
3165 else: raise TestFailed
, "invalid del() didn't raise TypeError"
3168 if verbose
: print "Testing hash of mutable subclasses..."
3178 raise TestFailed
, "hash() of dict subclass should fail"
3188 raise TestFailed
, "hash() of list subclass should fail"
3192 except TypeError: pass
3193 else: raise TestFailed
, "'' + 5 doesn't raise TypeError"
3196 except ValueError: pass
3197 else: raise TestFailed
, "''.split('') doesn't raise ValueError"
3200 except TypeError: pass
3201 else: raise TestFailed
, "''.join([0]) doesn't raise TypeError"
3204 except ValueError: pass
3205 else: raise TestFailed
, "''.rindex('5') doesn't raise ValueError"
3208 except TypeError: pass
3209 else: raise TestFailed
, "'%(n)s' % None doesn't raise TypeError"
3212 except ValueError: pass
3213 else: raise TestFailed
, "'%(n' % {} '' doesn't raise ValueError"
3215 try: '%*s' % ('abc')
3216 except TypeError: pass
3217 else: raise TestFailed
, "'%*s' % ('abc') doesn't raise TypeError"
3219 try: '%*.*s' % ('abc', 5)
3220 except TypeError: pass
3221 else: raise TestFailed
, "'%*.*s' % ('abc', 5) doesn't raise TypeError"
3224 except TypeError: pass
3225 else: raise TestFailed
, "'%s' % (1, 2) doesn't raise TypeError"
3228 except ValueError: pass
3229 else: raise TestFailed
, "'%' % None doesn't raise ValueError"
3231 vereq('534253'.isdigit(), 1)
3232 vereq('534253x'.isdigit(), 0)
3233 vereq('%c' % 5, '\x05')
3234 vereq('%c' % '5', '5')
3236 def deepcopyrecursive():
3237 if verbose
: print "Testing deepcopy of recursive objects..."
3244 z
= deepcopy(a
) # This blew up before
3247 if verbose
: print "Testing uninitialized module objects..."
3248 from types
import ModuleType
as M
3251 vereq(hasattr(m
, "__name__"), 0)
3252 vereq(hasattr(m
, "__file__"), 0)
3253 vereq(hasattr(m
, "foo"), 0)
3254 vereq(m
.__dict
__, None)
3256 vereq(m
.__dict
__, {"foo": 1})
3258 def dictproxyiterkeys():
3262 if verbose
: print "Testing dict-proxy iterkeys..."
3263 keys
= [ key
for key
in C
.__dict
__.iterkeys() ]
3265 vereq(keys
, ['__dict__', '__doc__', '__module__', '__weakref__', 'meth'])
3267 def dictproxyitervalues():
3271 if verbose
: print "Testing dict-proxy itervalues..."
3272 values
= [ values
for values
in C
.__dict
__.itervalues() ]
3273 vereq(len(values
), 5)
3275 def dictproxyiteritems():
3279 if verbose
: print "Testing dict-proxy iteritems..."
3280 keys
= [ key
for (key
, value
) in C
.__dict
__.iteritems() ]
3282 vereq(keys
, ['__dict__', '__doc__', '__module__', '__weakref__', 'meth'])
3285 if verbose
: print "Testing __new__ returning something unexpected..."
3287 def __new__(cls
, arg
):
3288 if isinstance(arg
, str): return [1, 2, 3]
3289 elif isinstance(arg
, int): return object.__new
__(D
)
3290 else: return object.__new
__(cls
)
3292 def __init__(self
, arg
):
3294 vereq(C("1"), [1, 2, 3])
3295 vereq(D("1"), [1, 2, 3])
3299 vereq(isinstance(d
, D
), True)
3302 vereq(isinstance(d
, D
), True)
3307 if verbose
: print "Testing for __imul__ problems..."
3309 def __imul__(self
, other
):
3310 return (self
, other
)
3323 vereq(y
, (x
, 1L<<100))
3329 vereq(y
, (x
, "foo"))
3331 def docdescriptor():
3333 if verbose
: print "Testing __doc__ descriptor..."
3334 class DocDescr(object):
3335 def __get__(self
, object, otype
):
3337 object = object.__class
__.__name
__ + ' instance'
3339 otype
= otype
.__name
__
3340 return 'object=%s; type=%s' % (object, otype
)
3342 __doc__
= DocDescr()
3343 class NewClass(object):
3344 __doc__
= DocDescr()
3345 vereq(OldClass
.__doc
__, 'object=None; type=OldClass')
3346 vereq(OldClass().__doc
__, 'object=OldClass instance; type=OldClass')
3347 vereq(NewClass
.__doc
__, 'object=None; type=NewClass')
3348 vereq(NewClass().__doc
__, 'object=NewClass instance; type=NewClass')
3350 def string_exceptions():
3352 print "Testing string exceptions ..."
3354 # Ensure builtin strings work OK as exceptions.
3355 astring
= "An exception string."
3361 raise TestFailed
, "builtin string not usable as exception"
3363 # Ensure string subclass instances do not.
3367 newstring
= MyStr("oops -- shouldn't work")
3373 raise TestFailed
, "string subclass allowed as exception"
3375 def copy_setstate():
3377 print "Testing that copy.*copy() correctly uses __setstate__..."
3380 def __init__(self
, foo
=None):
3383 def setfoo(self
, foo
=None):
3387 def __getstate__(self
):
3389 def __setstate__(self
, lst
):
3390 assert len(lst
) == 1
3391 self
.__foo
= self
.foo
= lst
[0]
3395 vereq(a
.getfoo(), 42)
3398 vereq(b
.getfoo(), 24)
3399 b
= copy
.deepcopy(a
)
3401 vereq(b
.getfoo(), 24)
3405 print "Testing cases with slices and overridden __getitem__ ..."
3407 vereq("hello"[:4], "hell")
3408 vereq("hello"[slice(4)], "hell")
3409 vereq(str.__getitem
__("hello", slice(4)), "hell")
3411 def __getitem__(self
, x
):
3412 return str.__getitem
__(self
, x
)
3413 vereq(S("hello")[:4], "hell")
3414 vereq(S("hello")[slice(4)], "hell")
3415 vereq(S("hello").__getitem
__(slice(4)), "hell")
3417 vereq((1,2,3)[:2], (1,2))
3418 vereq((1,2,3)[slice(2)], (1,2))
3419 vereq(tuple.__getitem
__((1,2,3), slice(2)), (1,2))
3421 def __getitem__(self
, x
):
3422 return tuple.__getitem
__(self
, x
)
3423 vereq(T((1,2,3))[:2], (1,2))
3424 vereq(T((1,2,3))[slice(2)], (1,2))
3425 vereq(T((1,2,3)).__getitem
__(slice(2)), (1,2))
3427 vereq([1,2,3][:2], [1,2])
3428 vereq([1,2,3][slice(2)], [1,2])
3429 vereq(list.__getitem
__([1,2,3], slice(2)), [1,2])
3431 def __getitem__(self
, x
):
3432 return list.__getitem
__(self
, x
)
3433 vereq(L([1,2,3])[:2], [1,2])
3434 vereq(L([1,2,3])[slice(2)], [1,2])
3435 vereq(L([1,2,3]).__getitem
__(slice(2)), [1,2])
3436 # Now do lists and __setitem__
3438 a
[slice(1, 3)] = [3,2]
3440 a
[slice(0, 2, 1)] = [3,1]
3442 a
.__setitem
__(slice(1, 3), [2,1])
3444 a
.__setitem
__(slice(0, 2, 1), [2,3])
3447 def subtype_resurrection():
3449 print "Testing resurrection of new-style instance..."
3455 # resurrect the instance
3456 C
.container
.append(self
)
3460 # The most interesting thing here is whether this blows up, due to flawed
3461 # GC tracking logic in typeobject.c's call_finalizer() (a 2.2.1 bug).
3464 # If that didn't blow up, it's also interesting to see whether clearing
3465 # the last container slot works: that will attempt to delete c again,
3466 # which will cause c to get appended back to the container again "during"
3469 vereq(len(C
.container
), 1)
3470 vereq(C
.container
[-1].attr
, 42)
3472 # Make c mortal again, so that the test framework with -l doesn't report
3477 # Deallocating deeply nested slotted trash caused stack overflows
3479 print "Testing slot trash..."
3480 class trash(object):
3482 def __init__(self
, x
):
3485 for i
in xrange(50000):
3489 def slotmultipleinheritance():
3490 # SF bug 575229, multiple inheritance w/ slots dumps core
3497 vereq(C
.__basicsize
__, B
.__basicsize
__)
3498 verify(hasattr(C
, '__dict__'))
3499 verify(hasattr(C
, '__weakref__'))
3505 print "Testing correct invocation of __rmul__..."
3507 def __mul__(self
, other
):
3509 def __rmul__(self
, other
):
3515 vereq(2.2*a
, "rmul")
3520 print "Testing correct invocation of __ipow__..."
3522 def __ipow__(self
, other
):
3527 def do_this_first():
3529 print "Testing SF bug 551412 ..."
3530 # This dumps core when SF bug 551412 isn't fixed --
3531 # but only when test_descr.py is run separately.
3532 # (That can't be helped -- as soon as PyType_Ready()
3533 # is called for PyLong_Type, the bug is gone.)
3534 class UserLong(object):
3535 def __pow__(self
, *args
):
3538 pow(0L, UserLong(), 0L)
3543 print "Testing SF bug 570483..."
3544 # Another segfault only when run early
3545 # (before PyType_Ready(tuple) is called)
3548 def test_mutable_bases():
3550 print "Testing mutable bases..."
3551 # stuff that should work:
3555 def __getattribute__(self
, attr
):
3559 return super(C2
, self
).__getattribute
__(attr
)
3574 vereq(C2
.__subclasses__(), [D
])
3576 # stuff that shouldn't:
3581 L
.__bases
__ = (dict,)
3585 raise TestFailed
, "shouldn't turn list subclass into dict subclass"
3588 list.__bases
__ = (dict,)
3592 raise TestFailed
, "shouldn't be able to assign to list.__bases__"
3599 raise TestFailed
, "shouldn't be able to delete .__bases__"
3603 except TypeError, msg
:
3604 if str(msg
) == "a new-style class can't have only classic bases":
3605 raise TestFailed
, "wrong error message for .__bases__ = ()"
3607 raise TestFailed
, "shouldn't be able to set .__bases__ to ()"
3614 # actually, we'll have crashed by here...
3615 raise TestFailed
, "shouldn't be able to create inheritance cycles"
3618 D
.__bases
__ = (C
, C
)
3622 raise TestFailed
, "didn't detect repeated base classes"
3629 raise TestFailed
, "shouldn't be able to create inheritance cycles"
3631 # let's throw a classic class into the mix:
3636 D
.__bases
__ = (C
, Classic
)
3642 except AttributeError:
3645 raise TestFailed
, "attribute should have vanished"
3648 D
.__bases
__ = (Classic
,)
3652 raise TestFailed
, "new-style class must have a new-style base"
3654 def test_mutable_bases_with_failing_mro():
3656 print "Testing mutable bases with failing mro..."
3657 class WorkOnce(type):
3658 def __new__(self
, name
, bases
, ns
):
3660 return super(WorkOnce
, self
).__new
__(WorkOnce
, name
, bases
, ns
)
3663 raise RuntimeError, "bozo"
3666 return type.mro(self
)
3668 class WorkAlways(type):
3670 # this is here to make sure that .mro()s aren't called
3671 # with an exception set (which was possible at one point).
3672 # An error message will be printed in a debug build.
3673 # What's a good way to test for this?
3674 return type.mro(self
)
3689 __metaclass__
= WorkOnce
3692 __metaclass__
= WorkAlways
3694 # Immediate subclasses have their mro's adjusted in alphabetical
3695 # order, so E's will get adjusted before adjusting F's fails. We
3696 # check here that E's gets restored.
3698 E_mro_before
= E
.__mro
__
3699 D_mro_before
= D
.__mro
__
3703 except RuntimeError:
3704 vereq(E
.__mro
__, E_mro_before
)
3705 vereq(D
.__mro
__, D_mro_before
)
3707 raise TestFailed
, "exception not propagated"
3709 def test_mutable_bases_catch_mro_conflict():
3711 print "Testing mutable bases catch mro conflict..."
3728 C
.__bases
__ = (B
, A
)
3732 raise TestFailed
, "didn't catch MRO conflict"
3734 def mutable_names():
3736 print "Testing mutable names..."
3740 # C.__module__ could be 'test_descr' or '__main__'
3744 vereq((C
.__module
__, C
.__name
__), (mod
, 'D'))
3747 vereq((C
.__module
__, C
.__name
__), (mod
, 'D.E'))
3749 def subclass_right_op():
3751 print "Testing correct dispatch of subclass overloading __r<op>__..."
3753 # This code tests various cases where right-dispatch of a subclass
3754 # should be preferred over left-dispatch of a base class.
3756 # Case 1: subclass of int; this tests code in abstract.c::binary_op1()
3759 def __floordiv__(self
, other
):
3760 return "B.__floordiv__"
3761 def __rfloordiv__(self
, other
):
3762 return "B.__rfloordiv__"
3764 vereq(B(1) // 1, "B.__floordiv__")
3765 vereq(1 // B(1), "B.__rfloordiv__")
3767 # Case 2: subclass of object; this is just the baseline for case 3
3770 def __floordiv__(self
, other
):
3771 return "C.__floordiv__"
3772 def __rfloordiv__(self
, other
):
3773 return "C.__rfloordiv__"
3775 vereq(C() // 1, "C.__floordiv__")
3776 vereq(1 // C(), "C.__rfloordiv__")
3778 # Case 3: subclass of new-style class; here it gets interesting
3781 def __floordiv__(self
, other
):
3782 return "D.__floordiv__"
3783 def __rfloordiv__(self
, other
):
3784 return "D.__rfloordiv__"
3786 vereq(D() // C(), "D.__floordiv__")
3787 vereq(C() // D(), "D.__rfloordiv__")
3789 # Case 4: this didn't work right in 2.2.2 and 2.3a1
3794 vereq(E
.__rfloordiv
__, C
.__rfloordiv
__)
3796 vereq(E() // 1, "C.__floordiv__")
3797 vereq(1 // E(), "C.__rfloordiv__")
3798 vereq(E() // C(), "C.__floordiv__")
3799 vereq(C() // E(), "C.__floordiv__") # This one would fail
3801 def dict_type_with_metaclass():
3803 print "Testing type of __dict__ when __metaclass__ set..."
3810 # In 2.3a1, C.__dict__ was a real dict rather than a dict proxy
3812 veris(type(C
.__dict
__), type(B
.__dict
__))
3814 def meth_class_get():
3815 # Full coverage of descrobject.c::classmethod_get()
3817 print "Testing __get__ method of METH_CLASS C methods..."
3820 res
= {1: None, 2: None, 3: None}
3821 vereq(dict.fromkeys(arg
), res
)
3822 vereq({}.fromkeys(arg
), res
)
3823 # Now get the descriptor
3824 descr
= dict.__dict
__["fromkeys"]
3825 # More baseline using the descriptor directly
3826 vereq(descr
.__get
__(None, dict)(arg
), res
)
3827 vereq(descr
.__get
__({})(arg
), res
)
3828 # Now check various error cases
3830 descr
.__get
__(None, None)
3834 raise TestFailed
, "shouldn't have allowed descr.__get__(None, None)"
3840 raise TestFailed
, "shouldn't have allowed descr.__get__(42)"
3842 descr
.__get
__(None, 42)
3846 raise TestFailed
, "shouldn't have allowed descr.__get__(None, 42)"
3848 descr
.__get
__(None, int)
3852 raise TestFailed
, "shouldn't have allowed descr.__get__(None, int)"
3854 def isinst_isclass():
3856 print "Testing proxy isinstance() and isclass()..."
3857 class Proxy(object):
3858 def __init__(self
, obj
):
3860 def __getattribute__(self
, name
):
3861 if name
.startswith("_Proxy__"):
3862 return object.__getattribute
__(self
, name
)
3864 return getattr(self
.__obj
, name
)
3865 # Test with a classic class
3870 verify(isinstance(a
, C
)) # Baseline
3871 verify(isinstance(pa
, C
)) # Test
3872 # Test with a classic subclass
3877 verify(isinstance(a
, C
)) # Baseline
3878 verify(isinstance(pa
, C
)) # Test
3879 # Test with a new-style class
3884 verify(isinstance(a
, C
)) # Baseline
3885 verify(isinstance(pa
, C
)) # Test
3886 # Test with a new-style subclass
3891 verify(isinstance(a
, C
)) # Baseline
3892 verify(isinstance(pa
, C
)) # Test
3896 print "Testing super() for a proxy object..."
3897 class Proxy(object):
3898 def __init__(self
, obj
):
3900 def __getattribute__(self
, name
):
3901 if name
.startswith("_Proxy__"):
3902 return object.__getattribute
__(self
, name
)
3904 return getattr(self
.__obj
, name
)
3912 return super(C
, self
).f() + "->C.f"
3916 vereq(C
.__dict
__["f"](p
), "B.f->C.f")
3920 print "Testing prohibition of Carlo Verre's hack..."
3922 object.__setattr
__(str, "foo", 42)
3926 raise TestFailed
, "Carlo Verre __setattr__ suceeded!"
3928 object.__delattr
__(str, "lower")
3932 raise TestFailed
, "Carlo Verre __delattr__ succeeded!"
3934 def weakref_segfault():
3937 print "Testing weakref segfault..."
3942 def __init__(self
, referrent
):
3943 self
.ref
= weakref
.ref(referrent
)
3952 o
.whatever
= Provoker(o
)
3955 # Fix SF #762455, segfault when sys.stdout is changed in getattr
3958 print "Testing sys.stdout is changed in getattr..."
3961 def __getattr__(self
, attr
):
3962 sys
.stdout
= sys
.__stdout
__
3963 raise RuntimeError("Premature access to sys.stdout.%s" % attr
)
3964 sys
.stdout
= StdoutGuard()
3967 except RuntimeError:
3970 def vicious_descriptor_nonsense():
3971 # A potential segfault spotted by Thomas Wouters in mail to
3972 # python-dev 2003-04-17, turned into an example & fixed by Michael
3973 # Hudson just less than four months later...
3975 print "Testing vicious_descriptor_nonsense..."
3980 def __eq__(self
, other
):
3984 class Descr(object):
3985 def __get__(self
, ob
, type=None):
3992 c
.__dict
__[Evil()] = 0
3995 # this makes a crash more likely:
3996 import gc
; gc
.collect()
3997 vereq(hasattr(c
, 'attr'), False)
4009 raise TestFailed
, "did not test __init__() for None return"
4011 def methodwrapper():
4012 # <type 'method-wrapper'> did not support any reflection before 2.5
4014 print "Testing method-wrapper objects..."
4017 vereq(l
.__add
__, l
.__add
__)
4018 verify(l
.__add
__ != [].__add
__)
4019 verify(l
.__add
__.__name
__ == '__add__')
4020 verify(l
.__add
__.__self
__ is l
)
4021 verify(l
.__add
__.__objclass
__ is list)
4022 vereq(l
.__add
__.__doc
__, list.__add
__.__doc
__)
4024 def notimplemented():
4025 # all binary methods should be able to return a NotImplemented
4027 print "Testing NotImplemented..."
4033 def specialmethod(self
, other
):
4034 return NotImplemented
4036 def check(expr
, x
, y
):
4038 exec expr
in {'x': x
, 'y': y
, 'operator': operator
}
4042 raise TestFailed("no TypeError from %r" % (expr
,))
4044 N1
= sys
.maxint
+ 1L # might trigger OverflowErrors instead of TypeErrors
4045 N2
= sys
.maxint
# if sizeof(int) < sizeof(long), might trigger
4046 # ValueErrors instead of TypeErrors
4047 for metaclass
in [type, types
.ClassType
]:
4048 for name
, expr
, iexpr
in [
4049 ('__add__', 'x + y', 'x += y'),
4050 ('__sub__', 'x - y', 'x -= y'),
4051 ('__mul__', 'x * y', 'x *= y'),
4052 ('__truediv__', 'operator.truediv(x, y)', None),
4053 ('__floordiv__', 'operator.floordiv(x, y)', None),
4054 ('__div__', 'x / y', 'x /= y'),
4055 ('__mod__', 'x % y', 'x %= y'),
4056 ('__divmod__', 'divmod(x, y)', None),
4057 ('__pow__', 'x ** y', 'x **= y'),
4058 ('__lshift__', 'x << y', 'x <<= y'),
4059 ('__rshift__', 'x >> y', 'x >>= y'),
4060 ('__and__', 'x & y', 'x &= y'),
4061 ('__or__', 'x | y', 'x |= y'),
4062 ('__xor__', 'x ^ y', 'x ^= y'),
4063 ('__coerce__', 'coerce(x, y)', None)]:
4064 if name
== '__coerce__':
4067 rname
= '__r' + name
[2:]
4068 A
= metaclass('A', (), {name
: specialmethod
})
4069 B
= metaclass('B', (), {rname
: specialmethod
})
4087 iname
= '__i' + name
[2:]
4088 C
= metaclass('C', (), {iname
: specialmethod
})
4096 weakref_segfault() # Must be first, somehow
4118 consistency_with_epg()
4127 staticmethods_in_c()
4141 str_subclass_as_dict_key()
4142 classic_comparisons()
4151 subclasspropagation()
4153 str_of_str_subclass()
4161 dictproxyitervalues()
4162 dictproxyiteritems()
4170 subtype_resurrection()
4172 slotmultipleinheritance()
4175 test_mutable_bases()
4176 test_mutable_bases_with_failing_mro()
4177 test_mutable_bases_catch_mro_conflict()
4180 dict_type_with_metaclass()
4186 vicious_descriptor_nonsense()
4191 if verbose
: print "All OK"
4193 if __name__
== "__main__":