source: titan/mediathek/localhoster/lib/python2.7/test/test_builtin.py @ 40658

Last change on this file since 40658 was 40658, checked in by obi, 7 years ago

update python stuff
File size: 65.1 KB
Line 
1# Python test set -- built-in functions
2
3import platform
4import unittest
5from test.test_support import fcmp, have_unicode, TESTFN, unlink, \
6                              run_unittest, check_py3k_warnings
7import warnings
8from operator import neg
9
10import sys, cStringIO, random, UserDict
11
12# count the number of test runs.
13# used to skip running test_execfile() multiple times
14# and to create unique strings to intern in test_intern()
15numruns = 0
16
17class Squares:
18
19    def __init__(self, max):
20        self.max = max
21        self.sofar = []
22
23    def __len__(self): return len(self.sofar)
24
25    def __getitem__(self, i):
26        if not 0 <= i < self.max: raise IndexError
27        n = len(self.sofar)
28        while n <= i:
29            self.sofar.append(n*n)
30            n += 1
31        return self.sofar[i]
32
33class StrSquares:
34
35    def __init__(self, max):
36        self.max = max
37        self.sofar = []
38
39    def __len__(self):
40        return len(self.sofar)
41
42    def __getitem__(self, i):
43        if not 0 <= i < self.max:
44            raise IndexError
45        n = len(self.sofar)
46        while n <= i:
47            self.sofar.append(str(n*n))
48            n += 1
49        return self.sofar[i]
50
51class BitBucket:
52    def write(self, line):
53        pass
54
55
56class TestFailingBool:
57    def __nonzero__(self):
58        raise RuntimeError
59
60class TestFailingIter:
61    def __iter__(self):
62        raise RuntimeError
63
64class BuiltinTest(unittest.TestCase):
65
66    def test_import(self):
67        __import__('sys')
68        __import__('time')
69        __import__('string')
70        __import__(name='sys')
71        __import__(name='time', level=0)
72        self.assertRaises(ImportError, __import__, 'spamspam')
73        self.assertRaises(TypeError, __import__, 1, 2, 3, 4)
74        self.assertRaises(ValueError, __import__, '')
75        self.assertRaises(TypeError, __import__, 'sys', name='sys')
76
77    def test_abs(self):
78        # int
79        self.assertEqual(abs(0), 0)
80        self.assertEqual(abs(1234), 1234)
81        self.assertEqual(abs(-1234), 1234)
82        self.assertTrue(abs(-sys.maxint-1) > 0)
83        # float
84        self.assertEqual(abs(0.0), 0.0)
85        self.assertEqual(abs(3.14), 3.14)
86        self.assertEqual(abs(-3.14), 3.14)
87        # long
88        self.assertEqual(abs(0L), 0L)
89        self.assertEqual(abs(1234L), 1234L)
90        self.assertEqual(abs(-1234L), 1234L)
91        # str
92        self.assertRaises(TypeError, abs, 'a')
93        # bool
94        self.assertEqual(abs(True), 1)
95        self.assertEqual(abs(False), 0)
96        # other
97        self.assertRaises(TypeError, abs)
98        self.assertRaises(TypeError, abs, None)
99        class AbsClass(object):
100            def __abs__(self):
101                return -5
102        self.assertEqual(abs(AbsClass()), -5)
103
104    def test_all(self):
105        self.assertEqual(all([2, 4, 6]), True)
106        self.assertEqual(all([2, None, 6]), False)
107        self.assertRaises(RuntimeError, all, [2, TestFailingBool(), 6])
108        self.assertRaises(RuntimeError, all, TestFailingIter())
109        self.assertRaises(TypeError, all, 10)               # Non-iterable
110        self.assertRaises(TypeError, all)                   # No args
111        self.assertRaises(TypeError, all, [2, 4, 6], [])    # Too many args
112        self.assertEqual(all([]), True)                     # Empty iterator
113        self.assertEqual(all([0, TestFailingBool()]), False)# Short-circuit
114        S = [50, 60]
115        self.assertEqual(all(x > 42 for x in S), True)
116        S = [50, 40, 60]
117        self.assertEqual(all(x > 42 for x in S), False)
118
119    def test_any(self):
120        self.assertEqual(any([None, None, None]), False)
121        self.assertEqual(any([None, 4, None]), True)
122        self.assertRaises(RuntimeError, any, [None, TestFailingBool(), 6])
123        self.assertRaises(RuntimeError, any, TestFailingIter())
124        self.assertRaises(TypeError, any, 10)               # Non-iterable
125        self.assertRaises(TypeError, any)                   # No args
126        self.assertRaises(TypeError, any, [2, 4, 6], [])    # Too many args
127        self.assertEqual(any([]), False)                    # Empty iterator
128        self.assertEqual(any([1, TestFailingBool()]), True) # Short-circuit
129        S = [40, 60, 30]
130        self.assertEqual(any(x > 42 for x in S), True)
131        S = [10, 20, 30]
132        self.assertEqual(any(x > 42 for x in S), False)
133
134    def test_neg(self):
135        x = -sys.maxint-1
136        self.assertTrue(isinstance(x, int))
137        self.assertEqual(-x, sys.maxint+1)
138
139    def test_apply(self):
140        def f0(*args):
141            self.assertEqual(args, ())
142        def f1(a1):
143            self.assertEqual(a1, 1)
144        def f2(a1, a2):
145            self.assertEqual(a1, 1)
146            self.assertEqual(a2, 2)
147        def f3(a1, a2, a3):
148            self.assertEqual(a1, 1)
149            self.assertEqual(a2, 2)
150            self.assertEqual(a3, 3)
151        apply(f0, ())
152        apply(f1, (1,))
153        apply(f2, (1, 2))
154        apply(f3, (1, 2, 3))
155
156        # A PyCFunction that takes only positional parameters should allow an
157        # empty keyword dictionary to pass without a complaint, but raise a
158        # TypeError if the dictionary is non-empty.
159        apply(id, (1,), {})
160        self.assertRaises(TypeError, apply, id, (1,), {"foo": 1})
161        self.assertRaises(TypeError, apply)
162        self.assertRaises(TypeError, apply, id, 42)
163        self.assertRaises(TypeError, apply, id, (42,), 42)
164
165    def test_callable(self):
166        self.assertTrue(callable(len))
167        self.assertFalse(callable("a"))
168        self.assertTrue(callable(callable))
169        self.assertTrue(callable(lambda x, y: x + y))
170        self.assertFalse(callable(__builtins__))
171        def f(): pass
172        self.assertTrue(callable(f))
173
174        class Classic:
175            def meth(self): pass
176        self.assertTrue(callable(Classic))
177        c = Classic()
178        self.assertTrue(callable(c.meth))
179        self.assertFalse(callable(c))
180
181        class NewStyle(object):
182            def meth(self): pass
183        self.assertTrue(callable(NewStyle))
184        n = NewStyle()
185        self.assertTrue(callable(n.meth))
186        self.assertFalse(callable(n))
187
188        # Classic and new-style classes evaluate __call__() differently
189        c.__call__ = None
190        self.assertTrue(callable(c))
191        del c.__call__
192        self.assertFalse(callable(c))
193        n.__call__ = None
194        self.assertFalse(callable(n))
195        del n.__call__
196        self.assertFalse(callable(n))
197
198        class N2(object):
199            def __call__(self): pass
200        n2 = N2()
201        self.assertTrue(callable(n2))
202        class N3(N2): pass
203        n3 = N3()
204        self.assertTrue(callable(n3))
205
206    def test_chr(self):
207        self.assertEqual(chr(32), ' ')
208        self.assertEqual(chr(65), 'A')
209        self.assertEqual(chr(97), 'a')
210        self.assertEqual(chr(0xff), '\xff')
211        self.assertRaises(ValueError, chr, 256)
212        self.assertRaises(TypeError, chr)
213
214    def test_cmp(self):
215        self.assertEqual(cmp(-1, 1), -1)
216        self.assertEqual(cmp(1, -1), 1)
217        self.assertEqual(cmp(1, 1), 0)
218        # verify that circular objects are not handled
219        a = []; a.append(a)
220        b = []; b.append(b)
221        from UserList import UserList
222        c = UserList(); c.append(c)
223        self.assertRaises(RuntimeError, cmp, a, b)
224        self.assertRaises(RuntimeError, cmp, b, c)
225        self.assertRaises(RuntimeError, cmp, c, a)
226        self.assertRaises(RuntimeError, cmp, a, c)
227       # okay, now break the cycles
228        a.pop(); b.pop(); c.pop()
229        self.assertRaises(TypeError, cmp)
230
231    def test_coerce(self):
232        self.assertTrue(not fcmp(coerce(1, 1.1), (1.0, 1.1)))
233        self.assertEqual(coerce(1, 1L), (1L, 1L))
234        self.assertTrue(not fcmp(coerce(1L, 1.1), (1.0, 1.1)))
235        self.assertRaises(TypeError, coerce)
236        class BadNumber:
237            def __coerce__(self, other):
238                raise ValueError
239        self.assertRaises(ValueError, coerce, 42, BadNumber())
240        self.assertRaises(OverflowError, coerce, 0.5, int("12345" * 1000))
241
242    def test_compile(self):
243        compile('print 1\n', '', 'exec')
244        bom = '\xef\xbb\xbf'
245        compile(bom + 'print 1\n', '', 'exec')
246        compile(source='pass', filename='?', mode='exec')
247        compile(dont_inherit=0, filename='tmp', source='0', mode='eval')
248        compile('pass', '?', dont_inherit=1, mode='exec')
249        self.assertRaises(TypeError, compile)
250        self.assertRaises(ValueError, compile, 'print 42\n', '<string>', 'badmode')
251        self.assertRaises(ValueError, compile, 'print 42\n', '<string>', 'single', 0xff)
252        self.assertRaises(TypeError, compile, chr(0), 'f', 'exec')
253        self.assertRaises(TypeError, compile, 'pass', '?', 'exec',
254                          mode='eval', source='0', filename='tmp')
255        if have_unicode:
256            compile(unicode('print u"\xc3\xa5"\n', 'utf8'), '', 'exec')
257            self.assertRaises(TypeError, compile, unichr(0), 'f', 'exec')
258            self.assertRaises(ValueError, compile, unicode('a = 1'), 'f', 'bad')
259
260
261    def test_delattr(self):
262        import sys
263        sys.spam = 1
264        delattr(sys, 'spam')
265        self.assertRaises(TypeError, delattr)
266
267    def test_dir(self):
268        # dir(wrong number of arguments)
269        self.assertRaises(TypeError, dir, 42, 42)
270
271        # dir() - local scope
272        local_var = 1
273        self.assertIn('local_var', dir())
274
275        # dir(module)
276        import sys
277        self.assertIn('exit', dir(sys))
278
279        # dir(module_with_invalid__dict__)
280        import types
281        class Foo(types.ModuleType):
282            __dict__ = 8
283        f = Foo("foo")
284        self.assertRaises(TypeError, dir, f)
285
286        # dir(type)
287        self.assertIn("strip", dir(str))
288        self.assertNotIn("__mro__", dir(str))
289
290        # dir(obj)
291        class Foo(object):
292            def __init__(self):
293                self.x = 7
294                self.y = 8
295                self.z = 9
296        f = Foo()
297        self.assertIn("y", dir(f))
298
299        # dir(obj_no__dict__)
300        class Foo(object):
301            __slots__ = []
302        f = Foo()
303        self.assertIn("__repr__", dir(f))
304
305        # dir(obj_no__class__with__dict__)
306        # (an ugly trick to cause getattr(f, "__class__") to fail)
307        class Foo(object):
308            __slots__ = ["__class__", "__dict__"]
309            def __init__(self):
310                self.bar = "wow"
311        f = Foo()
312        self.assertNotIn("__repr__", dir(f))
313        self.assertIn("bar", dir(f))
314
315        # dir(obj_using __dir__)
316        class Foo(object):
317            def __dir__(self):
318                return ["kan", "ga", "roo"]
319        f = Foo()
320        self.assertTrue(dir(f) == ["ga", "kan", "roo"])
321
322        # dir(obj__dir__not_list)
323        class Foo(object):
324            def __dir__(self):
325                return 7
326        f = Foo()
327        self.assertRaises(TypeError, dir, f)
328
329    def test_divmod(self):
330        self.assertEqual(divmod(12, 7), (1, 5))
331        self.assertEqual(divmod(-12, 7), (-2, 2))
332        self.assertEqual(divmod(12, -7), (-2, -2))
333        self.assertEqual(divmod(-12, -7), (1, -5))
334
335        self.assertEqual(divmod(12L, 7L), (1L, 5L))
336        self.assertEqual(divmod(-12L, 7L), (-2L, 2L))
337        self.assertEqual(divmod(12L, -7L), (-2L, -2L))
338        self.assertEqual(divmod(-12L, -7L), (1L, -5L))
339
340        self.assertEqual(divmod(12, 7L), (1, 5L))
341        self.assertEqual(divmod(-12, 7L), (-2, 2L))
342        self.assertEqual(divmod(12L, -7), (-2L, -2))
343        self.assertEqual(divmod(-12L, -7), (1L, -5))
344
345        self.assertEqual(divmod(-sys.maxint-1, -1),
346                         (sys.maxint+1, 0))
347
348        self.assertTrue(not fcmp(divmod(3.25, 1.0), (3.0, 0.25)))
349        self.assertTrue(not fcmp(divmod(-3.25, 1.0), (-4.0, 0.75)))
350        self.assertTrue(not fcmp(divmod(3.25, -1.0), (-4.0, -0.75)))
351        self.assertTrue(not fcmp(divmod(-3.25, -1.0), (3.0, -0.25)))
352
353        self.assertRaises(TypeError, divmod)
354
355    def test_eval(self):
356        self.assertEqual(eval('1+1'), 2)
357        self.assertEqual(eval(' 1+1\n'), 2)
358        globals = {'a': 1, 'b': 2}
359        locals = {'b': 200, 'c': 300}
360        self.assertEqual(eval('a', globals) , 1)
361        self.assertEqual(eval('a', globals, locals), 1)
362        self.assertEqual(eval('b', globals, locals), 200)
363        self.assertEqual(eval('c', globals, locals), 300)
364        if have_unicode:
365            self.assertEqual(eval(unicode('1+1')), 2)
366            self.assertEqual(eval(unicode(' 1+1\n')), 2)
367        globals = {'a': 1, 'b': 2}
368        locals = {'b': 200, 'c': 300}
369        if have_unicode:
370            self.assertEqual(eval(unicode('a'), globals), 1)
371            self.assertEqual(eval(unicode('a'), globals, locals), 1)
372            self.assertEqual(eval(unicode('b'), globals, locals), 200)
373            self.assertEqual(eval(unicode('c'), globals, locals), 300)
374            bom = '\xef\xbb\xbf'
375            self.assertEqual(eval(bom + 'a', globals, locals), 1)
376            self.assertEqual(eval(unicode('u"\xc3\xa5"', 'utf8'), globals),
377                             unicode('\xc3\xa5', 'utf8'))
378        self.assertRaises(TypeError, eval)
379        self.assertRaises(TypeError, eval, ())
380
381    def test_general_eval(self):
382        # Tests that general mappings can be used for the locals argument
383
384        class M:
385            "Test mapping interface versus possible calls from eval()."
386            def __getitem__(self, key):
387                if key == 'a':
388                    return 12
389                raise KeyError
390            def keys(self):
391                return list('xyz')
392
393        m = M()
394        g = globals()
395        self.assertEqual(eval('a', g, m), 12)
396        self.assertRaises(NameError, eval, 'b', g, m)
397        self.assertEqual(eval('dir()', g, m), list('xyz'))
398        self.assertEqual(eval('globals()', g, m), g)
399        self.assertEqual(eval('locals()', g, m), m)
400        self.assertRaises(TypeError, eval, 'a', m)
401        class A:
402            "Non-mapping"
403            pass
404        m = A()
405        self.assertRaises(TypeError, eval, 'a', g, m)
406
407        # Verify that dict subclasses work as well
408        class D(dict):
409            def __getitem__(self, key):
410                if key == 'a':
411                    return 12
412                return dict.__getitem__(self, key)
413            def keys(self):
414                return list('xyz')
415
416        d = D()
417        self.assertEqual(eval('a', g, d), 12)
418        self.assertRaises(NameError, eval, 'b', g, d)
419        self.assertEqual(eval('dir()', g, d), list('xyz'))
420        self.assertEqual(eval('globals()', g, d), g)
421        self.assertEqual(eval('locals()', g, d), d)
422
423        # Verify locals stores (used by list comps)
424        eval('[locals() for i in (2,3)]', g, d)
425        eval('[locals() for i in (2,3)]', g, UserDict.UserDict())
426
427        class SpreadSheet:
428            "Sample application showing nested, calculated lookups."
429            _cells = {}
430            def __setitem__(self, key, formula):
431                self._cells[key] = formula
432            def __getitem__(self, key):
433                return eval(self._cells[key], globals(), self)
434
435        ss = SpreadSheet()
436        ss['a1'] = '5'
437        ss['a2'] = 'a1*6'
438        ss['a3'] = 'a2*7'
439        self.assertEqual(ss['a3'], 210)
440
441        # Verify that dir() catches a non-list returned by eval
442        # SF bug #1004669
443        class C:
444            def __getitem__(self, item):
445                raise KeyError(item)
446            def keys(self):
447                return 'a'
448        self.assertRaises(TypeError, eval, 'dir()', globals(), C())
449
450    def test_filter(self):
451        self.assertEqual(filter(lambda c: 'a' <= c <= 'z', 'Hello World'), 'elloorld')
452        self.assertEqual(filter(None, [1, 'hello', [], [3], '', None, 9, 0]), [1, 'hello', [3], 9])
453        self.assertEqual(filter(lambda x: x > 0, [1, -3, 9, 0, 2]), [1, 9, 2])
454        self.assertEqual(filter(None, Squares(10)), [1, 4, 9, 16, 25, 36, 49, 64, 81])
455        self.assertEqual(filter(lambda x: x%2, Squares(10)), [1, 9, 25, 49, 81])
456        def identity(item):
457            return 1
458        filter(identity, Squares(5))
459        self.assertRaises(TypeError, filter)
460        class BadSeq(object):
461            def __getitem__(self, index):
462                if index<4:
463                    return 42
464                raise ValueError
465        self.assertRaises(ValueError, filter, lambda x: x, BadSeq())
466        def badfunc():
467            pass
468        self.assertRaises(TypeError, filter, badfunc, range(5))
469
470        # test bltinmodule.c::filtertuple()
471        self.assertEqual(filter(None, (1, 2)), (1, 2))
472        self.assertEqual(filter(lambda x: x>=3, (1, 2, 3, 4)), (3, 4))
473        self.assertRaises(TypeError, filter, 42, (1, 2))
474
475        # test bltinmodule.c::filterstring()
476        self.assertEqual(filter(None, "12"), "12")
477        self.assertEqual(filter(lambda x: x>="3", "1234"), "34")
478        self.assertRaises(TypeError, filter, 42, "12")
479        class badstr(str):
480            def __getitem__(self, index):
481                raise ValueError
482        self.assertRaises(ValueError, filter, lambda x: x >="3", badstr("1234"))
483
484        class badstr2(str):
485            def __getitem__(self, index):
486                return 42
487        self.assertRaises(TypeError, filter, lambda x: x >=42, badstr2("1234"))
488
489        class weirdstr(str):
490            def __getitem__(self, index):
491                return weirdstr(2*str.__getitem__(self, index))
492        self.assertEqual(filter(lambda x: x>="33", weirdstr("1234")), "3344")
493
494        class shiftstr(str):
495            def __getitem__(self, index):
496                return chr(ord(str.__getitem__(self, index))+1)
497        self.assertEqual(filter(lambda x: x>="3", shiftstr("1234")), "345")
498
499        if have_unicode:
500            # test bltinmodule.c::filterunicode()
501            self.assertEqual(filter(None, unicode("12")), unicode("12"))
502            self.assertEqual(filter(lambda x: x>="3", unicode("1234")), unicode("34"))
503            self.assertRaises(TypeError, filter, 42, unicode("12"))
504            self.assertRaises(ValueError, filter, lambda x: x >="3", badstr(unicode("1234")))
505
506            class badunicode(unicode):
507                def __getitem__(self, index):
508                    return 42
509            self.assertRaises(TypeError, filter, lambda x: x >=42, badunicode("1234"))
510
511            class weirdunicode(unicode):
512                def __getitem__(self, index):
513                    return weirdunicode(2*unicode.__getitem__(self, index))
514            self.assertEqual(
515                filter(lambda x: x>=unicode("33"), weirdunicode("1234")), unicode("3344"))
516
517            class shiftunicode(unicode):
518                def __getitem__(self, index):
519                    return unichr(ord(unicode.__getitem__(self, index))+1)
520            self.assertEqual(
521                filter(lambda x: x>=unicode("3"), shiftunicode("1234")),
522                unicode("345")
523            )
524
525    def test_filter_subclasses(self):
526        # test that filter() never returns tuple, str or unicode subclasses
527        # and that the result always goes through __getitem__
528        funcs = (None, bool, lambda x: True)
529        class tuple2(tuple):
530            def __getitem__(self, index):
531                return 2*tuple.__getitem__(self, index)
532        class str2(str):
533            def __getitem__(self, index):
534                return 2*str.__getitem__(self, index)
535        inputs = {
536            tuple2: {(): (), (1, 2, 3): (2, 4, 6)},
537            str2:   {"": "", "123": "112233"}
538        }
539        if have_unicode:
540            class unicode2(unicode):
541                def __getitem__(self, index):
542                    return 2*unicode.__getitem__(self, index)
543            inputs[unicode2] = {
544                unicode(): unicode(),
545                unicode("123"): unicode("112233")
546            }
547
548        for (cls, inps) in inputs.iteritems():
549            for (inp, exp) in inps.iteritems():
550                # make sure the output goes through __getitem__
551                # even if func is None
552                self.assertEqual(
553                    filter(funcs[0], cls(inp)),
554                    filter(funcs[1], cls(inp))
555                )
556                for func in funcs:
557                    outp = filter(func, cls(inp))
558                    self.assertEqual(outp, exp)
559                    self.assertTrue(not isinstance(outp, cls))
560
561    def test_getattr(self):
562        import sys
563        self.assertTrue(getattr(sys, 'stdout') is sys.stdout)
564        self.assertRaises(TypeError, getattr, sys, 1)
565        self.assertRaises(TypeError, getattr, sys, 1, "foo")
566        self.assertRaises(TypeError, getattr)
567        if have_unicode:
568            self.assertRaises(UnicodeError, getattr, sys, unichr(sys.maxunicode))
569
570    def test_hasattr(self):
571        import sys
572        self.assertTrue(hasattr(sys, 'stdout'))
573        self.assertRaises(TypeError, hasattr, sys, 1)
574        self.assertRaises(TypeError, hasattr)
575        if have_unicode:
576            self.assertRaises(UnicodeError, hasattr, sys, unichr(sys.maxunicode))
577
578        # Check that hasattr allows SystemExit and KeyboardInterrupts by
579        class A:
580            def __getattr__(self, what):
581                raise KeyboardInterrupt
582        self.assertRaises(KeyboardInterrupt, hasattr, A(), "b")
583        class B:
584            def __getattr__(self, what):
585                raise SystemExit
586        self.assertRaises(SystemExit, hasattr, B(), "b")
587
588    def test_hash(self):
589        hash(None)
590        self.assertEqual(hash(1), hash(1L))
591        self.assertEqual(hash(1), hash(1.0))
592        hash('spam')
593        if have_unicode:
594            self.assertEqual(hash('spam'), hash(unicode('spam')))
595        hash((0,1,2,3))
596        def f(): pass
597        self.assertRaises(TypeError, hash, [])
598        self.assertRaises(TypeError, hash, {})
599        # Bug 1536021: Allow hash to return long objects
600        class X:
601            def __hash__(self):
602                return 2**100
603        self.assertEqual(type(hash(X())), int)
604        class Y(object):
605            def __hash__(self):
606                return 2**100
607        self.assertEqual(type(hash(Y())), int)
608        class Z(long):
609            def __hash__(self):
610                return self
611        self.assertEqual(hash(Z(42)), hash(42L))
612
613    def test_hex(self):
614        self.assertEqual(hex(16), '0x10')
615        self.assertEqual(hex(16L), '0x10L')
616        self.assertEqual(hex(-16), '-0x10')
617        self.assertEqual(hex(-16L), '-0x10L')
618        self.assertRaises(TypeError, hex, {})
619
620    def test_id(self):
621        id(None)
622        id(1)
623        id(1L)
624        id(1.0)
625        id('spam')
626        id((0,1,2,3))
627        id([0,1,2,3])
628        id({'spam': 1, 'eggs': 2, 'ham': 3})
629
630    # Test input() later, together with raw_input
631
632    # test_int(): see test_int.py for int() tests.
633
634    def test_intern(self):
635        self.assertRaises(TypeError, intern)
636        # This fails if the test is run twice with a constant string,
637        # therefore append the run counter
638        s = "never interned before " + str(numruns)
639        self.assertTrue(intern(s) is s)
640        s2 = s.swapcase().swapcase()
641        self.assertTrue(intern(s2) is s)
642
643        # Subclasses of string can't be interned, because they
644        # provide too much opportunity for insane things to happen.
645        # We don't want them in the interned dict and if they aren't
646        # actually interned, we don't want to create the appearance
647        # that they are by allowing intern() to succeed.
648        class S(str):
649            def __hash__(self):
650                return 123
651
652        self.assertRaises(TypeError, intern, S("abc"))
653
654        # It's still safe to pass these strings to routines that
655        # call intern internally, e.g. PyObject_SetAttr().
656        s = S("abc")
657        setattr(s, s, s)
658        self.assertEqual(getattr(s, s), s)
659
660    def test_iter(self):
661        self.assertRaises(TypeError, iter)
662        self.assertRaises(TypeError, iter, 42, 42)
663        lists = [("1", "2"), ["1", "2"], "12"]
664        if have_unicode:
665            lists.append(unicode("12"))
666        for l in lists:
667            i = iter(l)
668            self.assertEqual(i.next(), '1')
669            self.assertEqual(i.next(), '2')
670            self.assertRaises(StopIteration, i.next)
671
672    def test_isinstance(self):
673        class C:
674            pass
675        class D(C):
676            pass
677        class E:
678            pass
679        c = C()
680        d = D()
681        e = E()
682        self.assertTrue(isinstance(c, C))
683        self.assertTrue(isinstance(d, C))
684        self.assertTrue(not isinstance(e, C))
685        self.assertTrue(not isinstance(c, D))
686        self.assertTrue(not isinstance('foo', E))
687        self.assertRaises(TypeError, isinstance, E, 'foo')
688        self.assertRaises(TypeError, isinstance)
689
690    def test_issubclass(self):
691        class C:
692            pass
693        class D(C):
694            pass
695        class E:
696            pass
697        c = C()
698        d = D()
699        e = E()
700        self.assertTrue(issubclass(D, C))
701        self.assertTrue(issubclass(C, C))
702        self.assertTrue(not issubclass(C, D))
703        self.assertRaises(TypeError, issubclass, 'foo', E)
704        self.assertRaises(TypeError, issubclass, E, 'foo')
705        self.assertRaises(TypeError, issubclass)
706
707    def test_len(self):
708        self.assertEqual(len('123'), 3)
709        self.assertEqual(len(()), 0)
710        self.assertEqual(len((1, 2, 3, 4)), 4)
711        self.assertEqual(len([1, 2, 3, 4]), 4)
712        self.assertEqual(len({}), 0)
713        self.assertEqual(len({'a':1, 'b': 2}), 2)
714        class BadSeq:
715            def __len__(self):
716                raise ValueError
717        self.assertRaises(ValueError, len, BadSeq())
718        self.assertRaises(TypeError, len, 2)
719        class ClassicStyle: pass
720        class NewStyle(object): pass
721        self.assertRaises(AttributeError, len, ClassicStyle())
722        self.assertRaises(TypeError, len, NewStyle())
723
724    def test_map(self):
725        self.assertEqual(
726            map(None, 'hello world'),
727            ['h','e','l','l','o',' ','w','o','r','l','d']
728        )
729        self.assertEqual(
730            map(None, 'abcd', 'efg'),
731            [('a', 'e'), ('b', 'f'), ('c', 'g'), ('d', None)]
732        )
733        self.assertEqual(
734            map(None, range(10)),
735            [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
736        )
737        self.assertEqual(
738            map(lambda x: x*x, range(1,4)),
739            [1, 4, 9]
740        )
741        try:
742            from math import sqrt
743        except ImportError:
744            def sqrt(x):
745                return pow(x, 0.5)
746        self.assertEqual(
747            map(lambda x: map(sqrt,x), [[16, 4], [81, 9]]),
748            [[4.0, 2.0], [9.0, 3.0]]
749        )
750        self.assertEqual(
751            map(lambda x, y: x+y, [1,3,2], [9,1,4]),
752            [10, 4, 6]
753        )
754
755        def plus(*v):
756            accu = 0
757            for i in v: accu = accu + i
758            return accu
759        self.assertEqual(
760            map(plus, [1, 3, 7]),
761            [1, 3, 7]
762        )
763        self.assertEqual(
764            map(plus, [1, 3, 7], [4, 9, 2]),
765            [1+4, 3+9, 7+2]
766        )
767        self.assertEqual(
768            map(plus, [1, 3, 7], [4, 9, 2], [1, 1, 0]),
769            [1+4+1, 3+9+1, 7+2+0]
770        )
771        self.assertEqual(
772            map(None, Squares(10)),
773            [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
774        )
775        self.assertEqual(
776            map(int, Squares(10)),
777            [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
778        )
779        self.assertEqual(
780            map(None, Squares(3), Squares(2)),
781            [(0,0), (1,1), (4,None)]
782        )
783        self.assertEqual(
784            map(max, Squares(3), Squares(2)),
785            [0, 1, 4]
786        )
787        self.assertRaises(TypeError, map)
788        self.assertRaises(TypeError, map, lambda x: x, 42)
789        self.assertEqual(map(None, [42]), [42])
790        class BadSeq:
791            def __getitem__(self, index):
792                raise ValueError
793        self.assertRaises(ValueError, map, lambda x: x, BadSeq())
794        def badfunc(x):
795            raise RuntimeError
796        self.assertRaises(RuntimeError, map, badfunc, range(5))
797
798    def test_max(self):
799        self.assertEqual(max('123123'), '3')
800        self.assertEqual(max(1, 2, 3), 3)
801        self.assertEqual(max((1, 2, 3, 1, 2, 3)), 3)
802        self.assertEqual(max([1, 2, 3, 1, 2, 3]), 3)
803
804        self.assertEqual(max(1, 2L, 3.0), 3.0)
805        self.assertEqual(max(1L, 2.0, 3), 3)
806        self.assertEqual(max(1.0, 2, 3L), 3L)
807
808        for stmt in (
809            "max(key=int)",                 # no args
810            "max(1, key=int)",              # single arg not iterable
811            "max(1, 2, keystone=int)",      # wrong keyword
812            "max(1, 2, key=int, abc=int)",  # two many keywords
813            "max(1, 2, key=1)",             # keyfunc is not callable
814            ):
815            try:
816                exec(stmt) in globals()
817            except TypeError:
818                pass
819            else:
820                self.fail(stmt)
821
822        self.assertEqual(max((1,), key=neg), 1)     # one elem iterable
823        self.assertEqual(max((1,2), key=neg), 1)    # two elem iterable
824        self.assertEqual(max(1, 2, key=neg), 1)     # two elems
825
826        data = [random.randrange(200) for i in range(100)]
827        keys = dict((elem, random.randrange(50)) for elem in data)
828        f = keys.__getitem__
829        self.assertEqual(max(data, key=f),
830                         sorted(reversed(data), key=f)[-1])
831
832    def test_min(self):
833        self.assertEqual(min('123123'), '1')
834        self.assertEqual(min(1, 2, 3), 1)
835        self.assertEqual(min((1, 2, 3, 1, 2, 3)), 1)
836        self.assertEqual(min([1, 2, 3, 1, 2, 3]), 1)
837
838        self.assertEqual(min(1, 2L, 3.0), 1)
839        self.assertEqual(min(1L, 2.0, 3), 1L)
840        self.assertEqual(min(1.0, 2, 3L), 1.0)
841
842        self.assertRaises(TypeError, min)
843        self.assertRaises(TypeError, min, 42)
844        self.assertRaises(ValueError, min, ())
845        class BadSeq:
846            def __getitem__(self, index):
847                raise ValueError
848        self.assertRaises(ValueError, min, BadSeq())
849        class BadNumber:
850            def __cmp__(self, other):
851                raise ValueError
852        self.assertRaises(ValueError, min, (42, BadNumber()))
853
854        for stmt in (
855            "min(key=int)",                 # no args
856            "min(1, key=int)",              # single arg not iterable
857            "min(1, 2, keystone=int)",      # wrong keyword
858            "min(1, 2, key=int, abc=int)",  # two many keywords
859            "min(1, 2, key=1)",             # keyfunc is not callable
860            ):
861            try:
862                exec(stmt) in globals()
863            except TypeError:
864                pass
865            else:
866                self.fail(stmt)
867
868        self.assertEqual(min((1,), key=neg), 1)     # one elem iterable
869        self.assertEqual(min((1,2), key=neg), 2)    # two elem iterable
870        self.assertEqual(min(1, 2, key=neg), 2)     # two elems
871
872        data = [random.randrange(200) for i in range(100)]
873        keys = dict((elem, random.randrange(50)) for elem in data)
874        f = keys.__getitem__
875        self.assertEqual(min(data, key=f),
876                         sorted(data, key=f)[0])
877
878    def test_next(self):
879        it = iter(range(2))
880        self.assertEqual(next(it), 0)
881        self.assertEqual(next(it), 1)
882        self.assertRaises(StopIteration, next, it)
883        self.assertRaises(StopIteration, next, it)
884        self.assertEqual(next(it, 42), 42)
885
886        class Iter(object):
887            def __iter__(self):
888                return self
889            def next(self):
890                raise StopIteration
891
892        it = iter(Iter())
893        self.assertEqual(next(it, 42), 42)
894        self.assertRaises(StopIteration, next, it)
895
896        def gen():
897            yield 1
898            return
899
900        it = gen()
901        self.assertEqual(next(it), 1)
902        self.assertRaises(StopIteration, next, it)
903        self.assertEqual(next(it, 42), 42)
904
905    def test_oct(self):
906        self.assertEqual(oct(100), '0144')
907        self.assertEqual(oct(100L), '0144L')
908        self.assertEqual(oct(-100), '-0144')
909        self.assertEqual(oct(-100L), '-0144L')
910        self.assertRaises(TypeError, oct, ())
911
912    def write_testfile(self):
913        # NB the first 4 lines are also used to test input and raw_input, below
914        fp = open(TESTFN, 'w')
915        try:
916            fp.write('1+1\n')
917            fp.write('1+1\n')
918            fp.write('The quick brown fox jumps over the lazy dog')
919            fp.write('.\n')
920            fp.write('Dear John\n')
921            fp.write('XXX'*100)
922            fp.write('YYY'*100)
923        finally:
924            fp.close()
925
926    def test_open(self):
927        self.write_testfile()
928        fp = open(TESTFN, 'r')
929        try:
930            self.assertEqual(fp.readline(4), '1+1\n')
931            self.assertEqual(fp.readline(4), '1+1\n')
932            self.assertEqual(fp.readline(), 'The quick brown fox jumps over the lazy dog.\n')
933            self.assertEqual(fp.readline(4), 'Dear')
934            self.assertEqual(fp.readline(100), ' John\n')
935            self.assertEqual(fp.read(300), 'XXX'*100)
936            self.assertEqual(fp.read(1000), 'YYY'*100)
937        finally:
938            fp.close()
939        unlink(TESTFN)
940
941    def test_ord(self):
942        self.assertEqual(ord(' '), 32)
943        self.assertEqual(ord('A'), 65)
944        self.assertEqual(ord('a'), 97)
945        if have_unicode:
946            self.assertEqual(ord(unichr(sys.maxunicode)), sys.maxunicode)
947        self.assertRaises(TypeError, ord, 42)
948        if have_unicode:
949            self.assertRaises(TypeError, ord, unicode("12"))
950
951    def test_pow(self):
952        self.assertEqual(pow(0,0), 1)
953        self.assertEqual(pow(0,1), 0)
954        self.assertEqual(pow(1,0), 1)
955        self.assertEqual(pow(1,1), 1)
956
957        self.assertEqual(pow(2,0), 1)
958        self.assertEqual(pow(2,10), 1024)
959        self.assertEqual(pow(2,20), 1024*1024)
960        self.assertEqual(pow(2,30), 1024*1024*1024)
961
962        self.assertEqual(pow(-2,0), 1)
963        self.assertEqual(pow(-2,1), -2)
964        self.assertEqual(pow(-2,2), 4)
965        self.assertEqual(pow(-2,3), -8)
966
967        self.assertEqual(pow(0L,0), 1)
968        self.assertEqual(pow(0L,1), 0)
969        self.assertEqual(pow(1L,0), 1)
970        self.assertEqual(pow(1L,1), 1)
971
972        self.assertEqual(pow(2L,0), 1)
973        self.assertEqual(pow(2L,10), 1024)
974        self.assertEqual(pow(2L,20), 1024*1024)
975        self.assertEqual(pow(2L,30), 1024*1024*1024)
976
977        self.assertEqual(pow(-2L,0), 1)
978        self.assertEqual(pow(-2L,1), -2)
979        self.assertEqual(pow(-2L,2), 4)
980        self.assertEqual(pow(-2L,3), -8)
981
982        self.assertAlmostEqual(pow(0.,0), 1.)
983        self.assertAlmostEqual(pow(0.,1), 0.)
984        self.assertAlmostEqual(pow(1.,0), 1.)
985        self.assertAlmostEqual(pow(1.,1), 1.)
986
987        self.assertAlmostEqual(pow(2.,0), 1.)
988        self.assertAlmostEqual(pow(2.,10), 1024.)
989        self.assertAlmostEqual(pow(2.,20), 1024.*1024.)
990        self.assertAlmostEqual(pow(2.,30), 1024.*1024.*1024.)
991
992        self.assertAlmostEqual(pow(-2.,0), 1.)
993        self.assertAlmostEqual(pow(-2.,1), -2.)
994        self.assertAlmostEqual(pow(-2.,2), 4.)
995        self.assertAlmostEqual(pow(-2.,3), -8.)
996
997        for x in 2, 2L, 2.0:
998            for y in 10, 10L, 10.0:
999                for z in 1000, 1000L, 1000.0:
1000                    if isinstance(x, float) or \
1001                       isinstance(y, float) or \
1002                       isinstance(z, float):
1003                        self.assertRaises(TypeError, pow, x, y, z)
1004                    else:
1005                        self.assertAlmostEqual(pow(x, y, z), 24.0)
1006
1007        self.assertRaises(TypeError, pow, -1, -2, 3)
1008        self.assertRaises(ValueError, pow, 1, 2, 0)
1009        self.assertRaises(TypeError, pow, -1L, -2L, 3L)
1010        self.assertRaises(ValueError, pow, 1L, 2L, 0L)
1011        # Will return complex in 3.0:
1012        self.assertRaises(ValueError, pow, -342.43, 0.234)
1013
1014        self.assertRaises(TypeError, pow)
1015
1016    def test_range(self):
1017        self.assertEqual(range(3), [0, 1, 2])
1018        self.assertEqual(range(1, 5), [1, 2, 3, 4])
1019        self.assertEqual(range(0), [])
1020        self.assertEqual(range(-3), [])
1021        self.assertEqual(range(1, 10, 3), [1, 4, 7])
1022        self.assertEqual(range(5, -5, -3), [5, 2, -1, -4])
1023
1024        # Now test range() with longs
1025        self.assertEqual(range(-2**100), [])
1026        self.assertEqual(range(0, -2**100), [])
1027        self.assertEqual(range(0, 2**100, -1), [])
1028        self.assertEqual(range(0, 2**100, -1), [])
1029
1030        a = long(10 * sys.maxint)
1031        b = long(100 * sys.maxint)
1032        c = long(50 * sys.maxint)
1033
1034        self.assertEqual(range(a, a+2), [a, a+1])
1035        self.assertEqual(range(a+2, a, -1L), [a+2, a+1])
1036        self.assertEqual(range(a+4, a, -2), [a+4, a+2])
1037
1038        seq = range(a, b, c)
1039        self.assertIn(a, seq)
1040        self.assertNotIn(b, seq)
1041        self.assertEqual(len(seq), 2)
1042
1043        seq = range(b, a, -c)
1044        self.assertIn(b, seq)
1045        self.assertNotIn(a, seq)
1046        self.assertEqual(len(seq), 2)
1047
1048        seq = range(-a, -b, -c)
1049        self.assertIn(-a, seq)
1050        self.assertNotIn(-b, seq)
1051        self.assertEqual(len(seq), 2)
1052
1053        self.assertRaises(TypeError, range)
1054        self.assertRaises(TypeError, range, 1, 2, 3, 4)
1055        self.assertRaises(ValueError, range, 1, 2, 0)
1056        self.assertRaises(ValueError, range, a, a + 1, long(0))
1057
1058        class badzero(int):
1059            def __cmp__(self, other):
1060                raise RuntimeError
1061            __hash__ = None # Invalid cmp makes this unhashable
1062        self.assertRaises(RuntimeError, range, a, a + 1, badzero(1))
1063
1064        # Reject floats.
1065        self.assertRaises(TypeError, range, 1., 1., 1.)
1066        self.assertRaises(TypeError, range, 1e100, 1e101, 1e101)
1067
1068        self.assertRaises(TypeError, range, 0, "spam")
1069        self.assertRaises(TypeError, range, 0, 42, "spam")
1070
1071        self.assertRaises(OverflowError, range, -sys.maxint, sys.maxint)
1072        self.assertRaises(OverflowError, range, 0, 2*sys.maxint)
1073
1074        bignum = 2*sys.maxint
1075        smallnum = 42
1076        # Old-style user-defined class with __int__ method
1077        class I0:
1078            def __init__(self, n):
1079                self.n = int(n)
1080            def __int__(self):
1081                return self.n
1082        self.assertEqual(range(I0(bignum), I0(bignum + 1)), [bignum])
1083        self.assertEqual(range(I0(smallnum), I0(smallnum + 1)), [smallnum])
1084
1085        # New-style user-defined class with __int__ method
1086        class I1(object):
1087            def __init__(self, n):
1088                self.n = int(n)
1089            def __int__(self):
1090                return self.n
1091        self.assertEqual(range(I1(bignum), I1(bignum + 1)), [bignum])
1092        self.assertEqual(range(I1(smallnum), I1(smallnum + 1)), [smallnum])
1093
1094        # New-style user-defined class with failing __int__ method
1095        class IX(object):
1096            def __int__(self):
1097                raise RuntimeError
1098        self.assertRaises(RuntimeError, range, IX())
1099
1100        # New-style user-defined class with invalid __int__ method
1101        class IN(object):
1102            def __int__(self):
1103                return "not a number"
1104        self.assertRaises(TypeError, range, IN())
1105
1106        # Exercise various combinations of bad arguments, to check
1107        # refcounting logic
1108        self.assertRaises(TypeError, range, 0.0)
1109
1110        self.assertRaises(TypeError, range, 0, 0.0)
1111        self.assertRaises(TypeError, range, 0.0, 0)
1112        self.assertRaises(TypeError, range, 0.0, 0.0)
1113
1114        self.assertRaises(TypeError, range, 0, 0, 1.0)
1115        self.assertRaises(TypeError, range, 0, 0.0, 1)
1116        self.assertRaises(TypeError, range, 0, 0.0, 1.0)
1117        self.assertRaises(TypeError, range, 0.0, 0, 1)
1118        self.assertRaises(TypeError, range, 0.0, 0, 1.0)
1119        self.assertRaises(TypeError, range, 0.0, 0.0, 1)
1120        self.assertRaises(TypeError, range, 0.0, 0.0, 1.0)
1121
1122
1123
1124    def test_input_and_raw_input(self):
1125        self.write_testfile()
1126        fp = open(TESTFN, 'r')
1127        savestdin = sys.stdin
1128        savestdout = sys.stdout # Eats the echo
1129        try:
1130            sys.stdin = fp
1131            sys.stdout = BitBucket()
1132            self.assertEqual(input(), 2)
1133            self.assertEqual(input('testing\n'), 2)
1134            self.assertEqual(raw_input(), 'The quick brown fox jumps over the lazy dog.')
1135            self.assertEqual(raw_input('testing\n'), 'Dear John')
1136
1137            # SF 1535165: don't segfault on closed stdin
1138            # sys.stdout must be a regular file for triggering
1139            sys.stdout = savestdout
1140            sys.stdin.close()
1141            self.assertRaises(ValueError, input)
1142
1143            sys.stdout = BitBucket()
1144            sys.stdin = cStringIO.StringIO("NULL\0")
1145            self.assertRaises(TypeError, input, 42, 42)
1146            sys.stdin = cStringIO.StringIO("    'whitespace'")
1147            self.assertEqual(input(), 'whitespace')
1148            sys.stdin = cStringIO.StringIO()
1149            self.assertRaises(EOFError, input)
1150
1151            # SF 876178: make sure input() respect future options.
1152            sys.stdin = cStringIO.StringIO('1/2')
1153            sys.stdout = cStringIO.StringIO()
1154            exec compile('print input()', 'test_builtin_tmp', 'exec')
1155            sys.stdin.seek(0, 0)
1156            exec compile('from __future__ import division;print input()',
1157                         'test_builtin_tmp', 'exec')
1158            sys.stdin.seek(0, 0)
1159            exec compile('print input()', 'test_builtin_tmp', 'exec')
1160            # The result we expect depends on whether new division semantics
1161            # are already in effect.
1162            if 1/2 == 0:
1163                # This test was compiled with old semantics.
1164                expected = ['0', '0.5', '0']
1165            else:
1166                # This test was compiled with new semantics (e.g., -Qnew
1167                # was given on the command line.
1168                expected = ['0.5', '0.5', '0.5']
1169            self.assertEqual(sys.stdout.getvalue().splitlines(), expected)
1170
1171            del sys.stdout
1172            self.assertRaises(RuntimeError, input, 'prompt')
1173            del sys.stdin
1174            self.assertRaises(RuntimeError, input, 'prompt')
1175        finally:
1176            sys.stdin = savestdin
1177            sys.stdout = savestdout
1178            fp.close()
1179            unlink(TESTFN)
1180
1181    def test_reduce(self):
1182        add = lambda x, y: x+y
1183        self.assertEqual(reduce(add, ['a', 'b', 'c'], ''), 'abc')
1184        self.assertEqual(
1185            reduce(add, [['a', 'c'], [], ['d', 'w']], []),
1186            ['a','c','d','w']
1187        )
1188        self.assertEqual(reduce(lambda x, y: x*y, range(2,8), 1), 5040)
1189        self.assertEqual(
1190            reduce(lambda x, y: x*y, range(2,21), 1L),
1191            2432902008176640000L
1192        )
1193        self.assertEqual(reduce(add, Squares(10)), 285)
1194        self.assertEqual(reduce(add, Squares(10), 0), 285)
1195        self.assertEqual(reduce(add, Squares(0), 0), 0)
1196        self.assertRaises(TypeError, reduce)
1197        self.assertRaises(TypeError, reduce, 42)
1198        self.assertRaises(TypeError, reduce, 42, 42)
1199        self.assertRaises(TypeError, reduce, 42, 42, 42)
1200        self.assertRaises(TypeError, reduce, None, range(5))
1201        self.assertRaises(TypeError, reduce, add, 42)
1202        self.assertEqual(reduce(42, "1"), "1") # func is never called with one item
1203        self.assertEqual(reduce(42, "", "1"), "1") # func is never called with one item
1204        self.assertRaises(TypeError, reduce, 42, (42, 42))
1205        self.assertRaises(TypeError, reduce, add, []) # arg 2 must not be empty sequence with no initial value
1206        self.assertRaises(TypeError, reduce, add, "")
1207        self.assertRaises(TypeError, reduce, add, ())
1208        self.assertEqual(reduce(add, [], None), None)
1209        self.assertEqual(reduce(add, [], 42), 42)
1210
1211        class BadSeq:
1212            def __getitem__(self, index):
1213                raise ValueError
1214        self.assertRaises(ValueError, reduce, 42, BadSeq())
1215
1216    def test_reload(self):
1217        import marshal
1218        reload(marshal)
1219        import string
1220        reload(string)
1221        ## import sys
1222        ## self.assertRaises(ImportError, reload, sys)
1223
1224    def test_repr(self):
1225        self.assertEqual(repr(''), '\'\'')
1226        self.assertEqual(repr(0), '0')
1227        self.assertEqual(repr(0L), '0L')
1228        self.assertEqual(repr(()), '()')
1229        self.assertEqual(repr([]), '[]')
1230        self.assertEqual(repr({}), '{}')
1231        a = []
1232        a.append(a)
1233        self.assertEqual(repr(a), '[[...]]')
1234        a = {}
1235        a[0] = a
1236        self.assertEqual(repr(a), '{0: {...}}')
1237
1238    def test_round(self):
1239        self.assertEqual(round(0.0), 0.0)
1240        self.assertEqual(type(round(0.0)), float)  # Will be int in 3.0.
1241        self.assertEqual(round(1.0), 1.0)
1242        self.assertEqual(round(10.0), 10.0)
1243        self.assertEqual(round(1000000000.0), 1000000000.0)
1244        self.assertEqual(round(1e20), 1e20)
1245
1246        self.assertEqual(round(-1.0), -1.0)
1247        self.assertEqual(round(-10.0), -10.0)
1248        self.assertEqual(round(-1000000000.0), -1000000000.0)
1249        self.assertEqual(round(-1e20), -1e20)
1250
1251        self.assertEqual(round(0.1), 0.0)
1252        self.assertEqual(round(1.1), 1.0)
1253        self.assertEqual(round(10.1), 10.0)
1254        self.assertEqual(round(1000000000.1), 1000000000.0)
1255
1256        self.assertEqual(round(-1.1), -1.0)
1257        self.assertEqual(round(-10.1), -10.0)
1258        self.assertEqual(round(-1000000000.1), -1000000000.0)
1259
1260        self.assertEqual(round(0.9), 1.0)
1261        self.assertEqual(round(9.9), 10.0)
1262        self.assertEqual(round(999999999.9), 1000000000.0)
1263
1264        self.assertEqual(round(-0.9), -1.0)
1265        self.assertEqual(round(-9.9), -10.0)
1266        self.assertEqual(round(-999999999.9), -1000000000.0)
1267
1268        self.assertEqual(round(-8.0, -1), -10.0)
1269        self.assertEqual(type(round(-8.0, -1)), float)
1270
1271        self.assertEqual(type(round(-8.0, 0)), float)
1272        self.assertEqual(type(round(-8.0, 1)), float)
1273
1274        # Check half rounding behaviour.
1275        self.assertEqual(round(5.5), 6)
1276        self.assertEqual(round(6.5), 7)
1277        self.assertEqual(round(-5.5), -6)
1278        self.assertEqual(round(-6.5), -7)
1279
1280        # Check behavior on ints
1281        self.assertEqual(round(0), 0)
1282        self.assertEqual(round(8), 8)
1283        self.assertEqual(round(-8), -8)
1284        self.assertEqual(type(round(0)), float)  # Will be int in 3.0.
1285        self.assertEqual(type(round(-8, -1)), float)
1286        self.assertEqual(type(round(-8, 0)), float)
1287        self.assertEqual(type(round(-8, 1)), float)
1288
1289        # test new kwargs
1290        self.assertEqual(round(number=-8.0, ndigits=-1), -10.0)
1291
1292        self.assertRaises(TypeError, round)
1293
1294        # test generic rounding delegation for reals
1295        class TestRound(object):
1296            def __float__(self):
1297                return 23.0
1298
1299        class TestNoRound(object):
1300            pass
1301
1302        self.assertEqual(round(TestRound()), 23)
1303
1304        self.assertRaises(TypeError, round, 1, 2, 3)
1305        self.assertRaises(TypeError, round, TestNoRound())
1306
1307        t = TestNoRound()
1308        t.__float__ = lambda *args: args
1309        self.assertRaises(TypeError, round, t)
1310        self.assertRaises(TypeError, round, t, 0)
1311
1312    # Some versions of glibc for alpha have a bug that affects
1313    # float -> integer rounding (floor, ceil, rint, round) for
1314    # values in the range [2**52, 2**53).  See:
1315    #
1316    #   http://sources.redhat.com/bugzilla/show_bug.cgi?id=5350
1317    #
1318    # We skip this test on Linux/alpha if it would fail.
1319    linux_alpha = (platform.system().startswith('Linux') and
1320                   platform.machine().startswith('alpha'))
1321    system_round_bug = round(5e15+1) != 5e15+1
1322    @unittest.skipIf(linux_alpha and system_round_bug,
1323                     "test will fail;  failure is probably due to a "
1324                     "buggy system round function")
1325    def test_round_large(self):
1326        # Issue #1869: integral floats should remain unchanged
1327        self.assertEqual(round(5e15-1), 5e15-1)
1328        self.assertEqual(round(5e15), 5e15)
1329        self.assertEqual(round(5e15+1), 5e15+1)
1330        self.assertEqual(round(5e15+2), 5e15+2)
1331        self.assertEqual(round(5e15+3), 5e15+3)
1332
1333    def test_setattr(self):
1334        setattr(sys, 'spam', 1)
1335        self.assertEqual(sys.spam, 1)
1336        self.assertRaises(TypeError, setattr, sys, 1, 'spam')
1337        self.assertRaises(TypeError, setattr)
1338
1339    def test_sum(self):
1340        self.assertEqual(sum([]), 0)
1341        self.assertEqual(sum(range(2,8)), 27)
1342        self.assertEqual(sum(iter(range(2,8))), 27)
1343        self.assertEqual(sum(Squares(10)), 285)
1344        self.assertEqual(sum(iter(Squares(10))), 285)
1345        self.assertEqual(sum([[1], [2], [3]], []), [1, 2, 3])
1346
1347        self.assertRaises(TypeError, sum)
1348        self.assertRaises(TypeError, sum, 42)
1349        self.assertRaises(TypeError, sum, ['a', 'b', 'c'])
1350        self.assertRaises(TypeError, sum, ['a', 'b', 'c'], '')
1351        self.assertRaises(TypeError, sum, [[1], [2], [3]])
1352        self.assertRaises(TypeError, sum, [{2:3}])
1353        self.assertRaises(TypeError, sum, [{2:3}]*2, {2:3})
1354
1355        class BadSeq:
1356            def __getitem__(self, index):
1357                raise ValueError
1358        self.assertRaises(ValueError, sum, BadSeq())
1359
1360        empty = []
1361        sum(([x] for x in range(10)), empty)
1362        self.assertEqual(empty, [])
1363
1364    def test_type(self):
1365        self.assertEqual(type(''),  type('123'))
1366        self.assertNotEqual(type(''), type(()))
1367
1368    def test_unichr(self):
1369        if have_unicode:
1370            self.assertEqual(unichr(32), unicode(' '))
1371            self.assertEqual(unichr(65), unicode('A'))
1372            self.assertEqual(unichr(97), unicode('a'))
1373            self.assertEqual(
1374                unichr(sys.maxunicode),
1375                unicode('\\U%08x' % (sys.maxunicode), 'unicode-escape')
1376            )
1377            self.assertRaises(ValueError, unichr, sys.maxunicode+1)
1378            self.assertRaises(TypeError, unichr)
1379            self.assertRaises((OverflowError, ValueError), unichr, 2**32)
1380
1381    # We don't want self in vars(), so these are static methods
1382
1383    @staticmethod
1384    def get_vars_f0():
1385        return vars()
1386
1387    @staticmethod
1388    def get_vars_f2():
1389        BuiltinTest.get_vars_f0()
1390        a = 1
1391        b = 2
1392        return vars()
1393
1394    class C_get_vars(object):
1395        def getDict(self):
1396            return {'a':2}
1397        __dict__ = property(fget=getDict)
1398
1399    def test_vars(self):
1400        self.assertEqual(set(vars()), set(dir()))
1401        import sys
1402        self.assertEqual(set(vars(sys)), set(dir(sys)))
1403        self.assertEqual(self.get_vars_f0(), {})
1404        self.assertEqual(self.get_vars_f2(), {'a': 1, 'b': 2})
1405        self.assertRaises(TypeError, vars, 42, 42)
1406        self.assertRaises(TypeError, vars, 42)
1407        self.assertEqual(vars(self.C_get_vars()), {'a':2})
1408
1409    def test_zip(self):
1410        a = (1, 2, 3)
1411        b = (4, 5, 6)
1412        t = [(1, 4), (2, 5), (3, 6)]
1413        self.assertEqual(zip(a, b), t)
1414        b = [4, 5, 6]
1415        self.assertEqual(zip(a, b), t)
1416        b = (4, 5, 6, 7)
1417        self.assertEqual(zip(a, b), t)
1418        class I:
1419            def __getitem__(self, i):
1420                if i < 0 or i > 2: raise IndexError
1421                return i + 4
1422        self.assertEqual(zip(a, I()), t)
1423        self.assertEqual(zip(), [])
1424        self.assertEqual(zip(*[]), [])
1425        self.assertRaises(TypeError, zip, None)
1426        class G:
1427            pass
1428        self.assertRaises(TypeError, zip, a, G())
1429
1430        # Make sure zip doesn't try to allocate a billion elements for the
1431        # result list when one of its arguments doesn't say how long it is.
1432        # A MemoryError is the most likely failure mode.
1433        class SequenceWithoutALength:
1434            def __getitem__(self, i):
1435                if i == 5:
1436                    raise IndexError
1437                else:
1438                    return i
1439        self.assertEqual(
1440            zip(SequenceWithoutALength(), xrange(2**30)),
1441            list(enumerate(range(5)))
1442        )
1443
1444        class BadSeq:
1445            def __getitem__(self, i):
1446                if i == 5:
1447                    raise ValueError
1448                else:
1449                    return i
1450        self.assertRaises(ValueError, zip, BadSeq(), BadSeq())
1451
1452    def test_format(self):
1453        # Test the basic machinery of the format() builtin.  Don't test
1454        #  the specifics of the various formatters
1455        self.assertEqual(format(3, ''), '3')
1456
1457        # Returns some classes to use for various tests.  There's
1458        #  an old-style version, and a new-style version
1459        def classes_new():
1460            class A(object):
1461                def __init__(self, x):
1462                    self.x = x
1463                def __format__(self, format_spec):
1464                    return str(self.x) + format_spec
1465            class DerivedFromA(A):
1466                pass
1467
1468            class Simple(object): pass
1469            class DerivedFromSimple(Simple):
1470                def __init__(self, x):
1471                    self.x = x
1472                def __format__(self, format_spec):
1473                    return str(self.x) + format_spec
1474            class DerivedFromSimple2(DerivedFromSimple): pass
1475            return A, DerivedFromA, DerivedFromSimple, DerivedFromSimple2
1476
1477        # In 3.0, classes_classic has the same meaning as classes_new
1478        def classes_classic():
1479            class A:
1480                def __init__(self, x):
1481                    self.x = x
1482                def __format__(self, format_spec):
1483                    return str(self.x) + format_spec
1484            class DerivedFromA(A):
1485                pass
1486
1487            class Simple: pass
1488            class DerivedFromSimple(Simple):
1489                def __init__(self, x):
1490                    self.x = x
1491                def __format__(self, format_spec):
1492                    return str(self.x) + format_spec
1493            class DerivedFromSimple2(DerivedFromSimple): pass
1494            return A, DerivedFromA, DerivedFromSimple, DerivedFromSimple2
1495
1496        def class_test(A, DerivedFromA, DerivedFromSimple, DerivedFromSimple2):
1497            self.assertEqual(format(A(3), 'spec'), '3spec')
1498            self.assertEqual(format(DerivedFromA(4), 'spec'), '4spec')
1499            self.assertEqual(format(DerivedFromSimple(5), 'abc'), '5abc')
1500            self.assertEqual(format(DerivedFromSimple2(10), 'abcdef'),
1501                             '10abcdef')
1502
1503        class_test(*classes_new())
1504        class_test(*classes_classic())
1505
1506        def empty_format_spec(value):
1507            # test that:
1508            #  format(x, '') == str(x)
1509            #  format(x) == str(x)
1510            self.assertEqual(format(value, ""), str(value))
1511            self.assertEqual(format(value), str(value))
1512
1513        # for builtin types, format(x, "") == str(x)
1514        empty_format_spec(17**13)
1515        empty_format_spec(1.0)
1516        empty_format_spec(3.1415e104)
1517        empty_format_spec(-3.1415e104)
1518        empty_format_spec(3.1415e-104)
1519        empty_format_spec(-3.1415e-104)
1520        empty_format_spec(object)
1521        empty_format_spec(None)
1522
1523        # TypeError because self.__format__ returns the wrong type
1524        class BadFormatResult:
1525            def __format__(self, format_spec):
1526                return 1.0
1527        self.assertRaises(TypeError, format, BadFormatResult(), "")
1528
1529        # TypeError because format_spec is not unicode or str
1530        self.assertRaises(TypeError, format, object(), 4)
1531        self.assertRaises(TypeError, format, object(), object())
1532
1533        # tests for object.__format__ really belong elsewhere, but
1534        #  there's no good place to put them
1535        x = object().__format__('')
1536        self.assertTrue(x.startswith('<object object at'))
1537
1538        # first argument to object.__format__ must be string
1539        self.assertRaises(TypeError, object().__format__, 3)
1540        self.assertRaises(TypeError, object().__format__, object())
1541        self.assertRaises(TypeError, object().__format__, None)
1542
1543        # --------------------------------------------------------------------
1544        # Issue #7994: object.__format__ with a non-empty format string is
1545        #  pending deprecated
1546        def test_deprecated_format_string(obj, fmt_str, should_raise_warning):
1547            with warnings.catch_warnings(record=True) as w:
1548                warnings.simplefilter("always", PendingDeprecationWarning)
1549                format(obj, fmt_str)
1550            if should_raise_warning:
1551                self.assertEqual(len(w), 1)
1552                self.assertIsInstance(w[0].message, PendingDeprecationWarning)
1553                self.assertIn('object.__format__ with a non-empty format '
1554                              'string', str(w[0].message))
1555            else:
1556                self.assertEqual(len(w), 0)
1557
1558        fmt_strs = ['', 's', u'', u's']
1559
1560        class A:
1561            def __format__(self, fmt_str):
1562                return format('', fmt_str)
1563
1564        for fmt_str in fmt_strs:
1565            test_deprecated_format_string(A(), fmt_str, False)
1566
1567        class B:
1568            pass
1569
1570        class C(object):
1571            pass
1572
1573        for cls in [object, B, C]:
1574            for fmt_str in fmt_strs:
1575                test_deprecated_format_string(cls(), fmt_str, len(fmt_str) != 0)
1576        # --------------------------------------------------------------------
1577
1578        # make sure we can take a subclass of str as a format spec
1579        class DerivedFromStr(str): pass
1580        self.assertEqual(format(0, DerivedFromStr('10')), '         0')
1581
1582    def test_bin(self):
1583        self.assertEqual(bin(0), '0b0')
1584        self.assertEqual(bin(1), '0b1')
1585        self.assertEqual(bin(-1), '-0b1')
1586        self.assertEqual(bin(2**65), '0b1' + '0' * 65)
1587        self.assertEqual(bin(2**65-1), '0b' + '1' * 65)
1588        self.assertEqual(bin(-(2**65)), '-0b1' + '0' * 65)
1589        self.assertEqual(bin(-(2**65-1)), '-0b' + '1' * 65)
1590
1591    def test_bytearray_translate(self):
1592        x = bytearray("abc")
1593        self.assertRaises(ValueError, x.translate, "1", 1)
1594        self.assertRaises(TypeError, x.translate, "1"*256, 1)
1595
1596class TestExecFile(unittest.TestCase):
1597    # Done outside of the method test_z to get the correct scope
1598    z = 0
1599    f = open(TESTFN, 'w')
1600    f.write('z = z+1\n')
1601    f.write('z = z*2\n')
1602    f.close()
1603    with check_py3k_warnings(("execfile.. not supported in 3.x",
1604                              DeprecationWarning)):
1605        execfile(TESTFN)
1606
1607    def test_execfile(self):
1608        globals = {'a': 1, 'b': 2}
1609        locals = {'b': 200, 'c': 300}
1610
1611        self.assertEqual(self.__class__.z, 2)
1612        globals['z'] = 0
1613        execfile(TESTFN, globals)
1614        self.assertEqual(globals['z'], 2)
1615        locals['z'] = 0
1616        execfile(TESTFN, globals, locals)
1617        self.assertEqual(locals['z'], 2)
1618
1619        class M:
1620            "Test mapping interface versus possible calls from execfile()."
1621            def __init__(self):
1622                self.z = 10
1623            def __getitem__(self, key):
1624                if key == 'z':
1625                    return self.z
1626                raise KeyError
1627            def __setitem__(self, key, value):
1628                if key == 'z':
1629                    self.z = value
1630                    return
1631                raise KeyError
1632
1633        locals = M()
1634        locals['z'] = 0
1635        execfile(TESTFN, globals, locals)
1636        self.assertEqual(locals['z'], 2)
1637
1638        unlink(TESTFN)
1639        self.assertRaises(TypeError, execfile)
1640        self.assertRaises(TypeError, execfile, TESTFN, {}, ())
1641        import os
1642        self.assertRaises(IOError, execfile, os.curdir)
1643        self.assertRaises(IOError, execfile, "I_dont_exist")
1644
1645
1646class TestSorted(unittest.TestCase):
1647
1648    def test_basic(self):
1649        data = range(100)
1650        copy = data[:]
1651        random.shuffle(copy)
1652        self.assertEqual(data, sorted(copy))
1653        self.assertNotEqual(data, copy)
1654
1655        data.reverse()
1656        random.shuffle(copy)
1657        self.assertEqual(data, sorted(copy, cmp=lambda x, y: cmp(y,x)))
1658        self.assertNotEqual(data, copy)
1659        random.shuffle(copy)
1660        self.assertEqual(data, sorted(copy, key=lambda x: -x))
1661        self.assertNotEqual(data, copy)
1662        random.shuffle(copy)
1663        self.assertEqual(data, sorted(copy, reverse=1))
1664        self.assertNotEqual(data, copy)
1665
1666    def test_inputtypes(self):
1667        s = 'abracadabra'
1668        types = [list, tuple]
1669        if have_unicode:
1670            types.insert(0, unicode)
1671        for T in types:
1672            self.assertEqual(sorted(s), sorted(T(s)))
1673
1674        s = ''.join(dict.fromkeys(s).keys())  # unique letters only
1675        types = [set, frozenset, list, tuple, dict.fromkeys]
1676        if have_unicode:
1677            types.insert(0, unicode)
1678        for T in types:
1679            self.assertEqual(sorted(s), sorted(T(s)))
1680
1681    def test_baddecorator(self):
1682        data = 'The quick Brown fox Jumped over The lazy Dog'.split()
1683        self.assertRaises(TypeError, sorted, data, None, lambda x,y: 0)
1684
1685
1686class TestType(unittest.TestCase):
1687    def test_new_type(self):
1688        A = type('A', (), {})
1689        self.assertEqual(A.__name__, 'A')
1690        self.assertEqual(A.__module__, __name__)
1691        self.assertEqual(A.__bases__, (object,))
1692        self.assertIs(A.__base__, object)
1693        x = A()
1694        self.assertIs(type(x), A)
1695        self.assertIs(x.__class__, A)
1696
1697        class B:
1698            def ham(self):
1699                return 'ham%d' % self
1700        C = type('C', (B, int), {'spam': lambda self: 'spam%s' % self})
1701        self.assertEqual(C.__name__, 'C')
1702        self.assertEqual(C.__module__, __name__)
1703        self.assertEqual(C.__bases__, (B, int))
1704        self.assertIs(C.__base__, int)
1705        self.assertIn('spam', C.__dict__)
1706        self.assertNotIn('ham', C.__dict__)
1707        x = C(42)
1708        self.assertEqual(x, 42)
1709        self.assertIs(type(x), C)
1710        self.assertIs(x.__class__, C)
1711        self.assertEqual(x.ham(), 'ham42')
1712        self.assertEqual(x.spam(), 'spam42')
1713        self.assertEqual(x.bit_length(), 6)
1714
1715    def test_type_new_keywords(self):
1716        class B:
1717            def ham(self):
1718                return 'ham%d' % self
1719        C = type.__new__(type,
1720                         name='C',
1721                         bases=(B, int),
1722                         dict={'spam': lambda self: 'spam%s' % self})
1723        self.assertEqual(C.__name__, 'C')
1724        self.assertEqual(C.__module__, __name__)
1725        self.assertEqual(C.__bases__, (B, int))
1726        self.assertIs(C.__base__, int)
1727        self.assertIn('spam', C.__dict__)
1728        self.assertNotIn('ham', C.__dict__)
1729
1730    def test_type_name(self):
1731        for name in 'A', '\xc4', 'B.A', '42', '':
1732            A = type(name, (), {})
1733            self.assertEqual(A.__name__, name)
1734            self.assertEqual(A.__module__, __name__)
1735        with self.assertRaises(ValueError):
1736            type('A\x00B', (), {})
1737        with self.assertRaises(TypeError):
1738            type(u'A', (), {})
1739
1740        C = type('C', (), {})
1741        for name in 'A', '\xc4', 'B.A', '42', '':
1742            C.__name__ = name
1743            self.assertEqual(C.__name__, name)
1744            self.assertEqual(C.__module__, __name__)
1745
1746        A = type('C', (), {})
1747        with self.assertRaises(ValueError):
1748            A.__name__ = 'A\x00B'
1749        self.assertEqual(A.__name__, 'C')
1750        with self.assertRaises(TypeError):
1751            A.__name__ = u'A'
1752        self.assertEqual(A.__name__, 'C')
1753
1754    def test_type_doc(self):
1755        tests = ('x', '\xc4', 'x\x00y', 42, None)
1756        if have_unicode:
1757            tests += (u'\xc4', u'x\x00y')
1758        for doc in tests:
1759            A = type('A', (), {'__doc__': doc})
1760            self.assertEqual(A.__doc__, doc)
1761
1762        A = type('A', (), {})
1763        self.assertEqual(A.__doc__, None)
1764        with self.assertRaises(AttributeError):
1765            A.__doc__ = 'x'
1766
1767    def test_bad_args(self):
1768        with self.assertRaises(TypeError):
1769            type()
1770        with self.assertRaises(TypeError):
1771            type('A', ())
1772        with self.assertRaises(TypeError):
1773            type('A', (), {}, ())
1774        with self.assertRaises(TypeError):
1775            type('A', (), dict={})
1776        with self.assertRaises(TypeError):
1777            type('A', [], {})
1778        with self.assertRaises(TypeError):
1779            type('A', (), UserDict.UserDict())
1780        with self.assertRaises(TypeError):
1781            type('A', (None,), {})
1782        with self.assertRaises(TypeError):
1783            type('A', (bool,), {})
1784        with self.assertRaises(TypeError):
1785            type('A', (int, str), {})
1786        class B:
1787            pass
1788        with self.assertRaises(TypeError):
1789            type('A', (B,), {})
1790
1791    def test_bad_slots(self):
1792        with self.assertRaises(TypeError):
1793            type('A', (long,), {'__slots__': 'x'})
1794        with self.assertRaises(TypeError):
1795            type('A', (), {'__slots__': ''})
1796        with self.assertRaises(TypeError):
1797            type('A', (), {'__slots__': '42'})
1798        with self.assertRaises(TypeError):
1799            type('A', (), {'__slots__': 'x\x00y'})
1800        with self.assertRaises(TypeError):
1801            type('A', (), {'__slots__': ('__dict__', '__dict__')})
1802        with self.assertRaises(TypeError):
1803            type('A', (), {'__slots__': ('__weakref__', '__weakref__')})
1804
1805        class B(object):
1806            pass
1807        with self.assertRaises(TypeError):
1808            type('A', (B,), {'__slots__': '__dict__'})
1809        with self.assertRaises(TypeError):
1810            type('A', (B,), {'__slots__': '__weakref__'})
1811
1812
1813def _run_unittest(*args):
1814    with check_py3k_warnings(
1815            (".+ not supported in 3.x", DeprecationWarning),
1816            (".+ is renamed to imp.reload", DeprecationWarning),
1817            ("classic int division", DeprecationWarning)):
1818        run_unittest(*args)
1819
1820def test_main(verbose=None):
1821    global numruns
1822    if not numruns:
1823        with check_py3k_warnings(
1824                (".+ not supported in 3.x", DeprecationWarning)):
1825            run_unittest(TestExecFile)
1826    numruns += 1
1827    test_classes = (BuiltinTest, TestSorted, TestType)
1828
1829    _run_unittest(*test_classes)
1830
1831    # verify reference counting
1832    if verbose and hasattr(sys, "gettotalrefcount"):
1833        import gc
1834        counts = [None] * 5
1835        for i in xrange(len(counts)):
1836            _run_unittest(*test_classes)
1837            gc.collect()
1838            counts[i] = sys.gettotalrefcount()
1839        print counts
1840
1841
1842if __name__ == "__main__":
1843    test_main(verbose=True)
Note: See TracBrowser for help on using the repository browser.