PageRenderTime 955ms CodeModel.GetById 121ms app.highlight 687ms RepoModel.GetById 128ms app.codeStats 1ms

/Lib/test/test_builtin.py

http://unladen-swallow.googlecode.com/
Python | 1542 lines | 1422 code | 88 blank | 32 comment | 55 complexity | addc20e6276091a619d68970ac8a0cf7 MD5 | raw file

Large files files are truncated, but you can click here to view the full file

   1# Python test set -- built-in functions
   2
   3import test.test_support, unittest
   4from test.test_support import fcmp, have_unicode, TESTFN, unlink, \
   5                              run_unittest, run_with_locale
   6from operator import neg
   7
   8import sys, warnings, cStringIO, random, fractions, UserDict
   9warnings.filterwarnings("ignore", "hex../oct.. of negative int",
  10                        FutureWarning, __name__)
  11warnings.filterwarnings("ignore", "integer argument expected",
  12                        DeprecationWarning, "unittest")
  13
  14# count the number of test runs.
  15# used to skip running test_execfile() multiple times
  16numruns = 0
  17
  18class Squares:
  19
  20    def __init__(self, max):
  21        self.max = max
  22        self.sofar = []
  23
  24    def __len__(self): return len(self.sofar)
  25
  26    def __getitem__(self, i):
  27        if not 0 <= i < self.max: raise IndexError
  28        n = len(self.sofar)
  29        while n <= i:
  30            self.sofar.append(n*n)
  31            n += 1
  32        return self.sofar[i]
  33
  34class StrSquares:
  35
  36    def __init__(self, max):
  37        self.max = max
  38        self.sofar = []
  39
  40    def __len__(self):
  41        return len(self.sofar)
  42
  43    def __getitem__(self, i):
  44        if not 0 <= i < self.max:
  45            raise IndexError
  46        n = len(self.sofar)
  47        while n <= i:
  48            self.sofar.append(str(n*n))
  49            n += 1
  50        return self.sofar[i]
  51
  52class BitBucket:
  53    def write(self, line):
  54        pass
  55
  56
  57class TestFailingBool:
  58    def __nonzero__(self):
  59        raise RuntimeError
  60
  61class TestFailingIter:
  62    def __iter__(self):
  63        raise RuntimeError
  64
  65class BuiltinTest(unittest.TestCase):
  66
  67    def test_import(self):
  68        __import__('sys')
  69        __import__('time')
  70        __import__('string')
  71        __import__(name='sys')
  72        __import__(name='time', level=0)
  73        self.assertRaises(ImportError, __import__, 'spamspam')
  74        self.assertRaises(TypeError, __import__, 1, 2, 3, 4)
  75        self.assertRaises(ValueError, __import__, '')
  76        self.assertRaises(TypeError, __import__, 'sys', name='sys')
  77
  78    def test_abs(self):
  79        # int
  80        self.assertEqual(abs(0), 0)
  81        self.assertEqual(abs(1234), 1234)
  82        self.assertEqual(abs(-1234), 1234)
  83        self.assertTrue(abs(-sys.maxint-1) > 0)
  84        # float
  85        self.assertEqual(abs(0.0), 0.0)
  86        self.assertEqual(abs(3.14), 3.14)
  87        self.assertEqual(abs(-3.14), 3.14)
  88        # long
  89        self.assertEqual(abs(0L), 0L)
  90        self.assertEqual(abs(1234L), 1234L)
  91        self.assertEqual(abs(-1234L), 1234L)
  92        # str
  93        self.assertRaises(TypeError, abs, 'a')
  94
  95    def test_all(self):
  96        self.assertEqual(all([2, 4, 6]), True)
  97        self.assertEqual(all([2, None, 6]), False)
  98        self.assertRaises(RuntimeError, all, [2, TestFailingBool(), 6])
  99        self.assertRaises(RuntimeError, all, TestFailingIter())
 100        self.assertRaises(TypeError, all, 10)               # Non-iterable
 101        self.assertRaises(TypeError, all)                   # No args
 102        self.assertRaises(TypeError, all, [2, 4, 6], [])    # Too many args
 103        self.assertEqual(all([]), True)                     # Empty iterator
 104        S = [50, 60]
 105        self.assertEqual(all(x > 42 for x in S), True)
 106        S = [50, 40, 60]
 107        self.assertEqual(all(x > 42 for x in S), False)
 108
 109    def test_any(self):
 110        self.assertEqual(any([None, None, None]), False)
 111        self.assertEqual(any([None, 4, None]), True)
 112        self.assertRaises(RuntimeError, any, [None, TestFailingBool(), 6])
 113        self.assertRaises(RuntimeError, all, TestFailingIter())
 114        self.assertRaises(TypeError, any, 10)               # Non-iterable
 115        self.assertRaises(TypeError, any)                   # No args
 116        self.assertRaises(TypeError, any, [2, 4, 6], [])    # Too many args
 117        self.assertEqual(any([]), False)                    # Empty iterator
 118        S = [40, 60, 30]
 119        self.assertEqual(any(x > 42 for x in S), True)
 120        S = [10, 20, 30]
 121        self.assertEqual(any(x > 42 for x in S), False)
 122
 123    def test_neg(self):
 124        x = -sys.maxint-1
 125        self.assert_(isinstance(x, int))
 126        self.assertEqual(-x, sys.maxint+1)
 127
 128    def test_apply(self):
 129        def f0(*args):
 130            self.assertEqual(args, ())
 131        def f1(a1):
 132            self.assertEqual(a1, 1)
 133        def f2(a1, a2):
 134            self.assertEqual(a1, 1)
 135            self.assertEqual(a2, 2)
 136        def f3(a1, a2, a3):
 137            self.assertEqual(a1, 1)
 138            self.assertEqual(a2, 2)
 139            self.assertEqual(a3, 3)
 140        apply(f0, ())
 141        apply(f1, (1,))
 142        apply(f2, (1, 2))
 143        apply(f3, (1, 2, 3))
 144
 145        # A PyCFunction that takes only positional parameters should allow an
 146        # empty keyword dictionary to pass without a complaint, but raise a
 147        # TypeError if the dictionary is non-empty.
 148        apply(id, (1,), {})
 149        self.assertRaises(TypeError, apply, id, (1,), {"foo": 1})
 150        self.assertRaises(TypeError, apply)
 151        self.assertRaises(TypeError, apply, id, 42)
 152        self.assertRaises(TypeError, apply, id, (42,), 42)
 153
 154    def test_callable(self):
 155        self.assert_(callable(len))
 156        def f(): pass
 157        self.assert_(callable(f))
 158        class C:
 159            def meth(self): pass
 160        self.assert_(callable(C))
 161        x = C()
 162        self.assert_(callable(x.meth))
 163        self.assert_(not callable(x))
 164        class D(C):
 165            def __call__(self): pass
 166        y = D()
 167        self.assert_(callable(y))
 168        y()
 169
 170    def test_chr(self):
 171        self.assertEqual(chr(32), ' ')
 172        self.assertEqual(chr(65), 'A')
 173        self.assertEqual(chr(97), 'a')
 174        self.assertEqual(chr(0xff), '\xff')
 175        self.assertRaises(ValueError, chr, 256)
 176        self.assertRaises(TypeError, chr)
 177
 178    def test_cmp(self):
 179        self.assertEqual(cmp(-1, 1), -1)
 180        self.assertEqual(cmp(1, -1), 1)
 181        self.assertEqual(cmp(1, 1), 0)
 182        # verify that circular objects are not handled
 183        a = []; a.append(a)
 184        b = []; b.append(b)
 185        from UserList import UserList
 186        c = UserList(); c.append(c)
 187        self.assertRaises(RuntimeError, cmp, a, b)
 188        self.assertRaises(RuntimeError, cmp, b, c)
 189        self.assertRaises(RuntimeError, cmp, c, a)
 190        self.assertRaises(RuntimeError, cmp, a, c)
 191       # okay, now break the cycles
 192        a.pop(); b.pop(); c.pop()
 193        self.assertRaises(TypeError, cmp)
 194
 195    def test_coerce(self):
 196        self.assert_(not fcmp(coerce(1, 1.1), (1.0, 1.1)))
 197        self.assertEqual(coerce(1, 1L), (1L, 1L))
 198        self.assert_(not fcmp(coerce(1L, 1.1), (1.0, 1.1)))
 199        self.assertRaises(TypeError, coerce)
 200        class BadNumber:
 201            def __coerce__(self, other):
 202                raise ValueError
 203        self.assertRaises(ValueError, coerce, 42, BadNumber())
 204        self.assertRaises(OverflowError, coerce, 0.5, int("12345" * 1000))
 205
 206    def test_compile(self):
 207        compile('print 1\n', '', 'exec')
 208        bom = '\xef\xbb\xbf'
 209        compile(bom + 'print 1\n', '', 'exec')
 210        compile(source='pass', filename='?', mode='exec')
 211        compile(dont_inherit=0, filename='tmp', source='0', mode='eval')
 212        compile('pass', '?', dont_inherit=1, mode='exec')
 213        self.assertRaises(TypeError, compile)
 214        self.assertRaises(ValueError, compile, 'print 42\n', '<string>', 'badmode')
 215        self.assertRaises(ValueError, compile, 'print 42\n', '<string>', 'single', 0xff)
 216        self.assertRaises(TypeError, compile, chr(0), 'f', 'exec')
 217        self.assertRaises(TypeError, compile, 'pass', '?', 'exec',
 218                          mode='eval', source='0', filename='tmp')
 219        if have_unicode:
 220            compile(unicode('print u"\xc3\xa5"\n', 'utf8'), '', 'exec')
 221            self.assertRaises(TypeError, compile, unichr(0), 'f', 'exec')
 222            self.assertRaises(ValueError, compile, unicode('a = 1'), 'f', 'bad')
 223
 224
 225    def test_delattr(self):
 226        import sys
 227        sys.spam = 1
 228        delattr(sys, 'spam')
 229        self.assertRaises(TypeError, delattr)
 230
 231    def test_dir(self):
 232        # dir(wrong number of arguments)
 233        self.assertRaises(TypeError, dir, 42, 42)
 234
 235        # dir() - local scope
 236        local_var = 1
 237        self.assert_('local_var' in dir())
 238
 239        # dir(module)
 240        import sys
 241        self.assert_('exit' in dir(sys))
 242
 243        # dir(module_with_invalid__dict__)
 244        import types
 245        class Foo(types.ModuleType):
 246            __dict__ = 8
 247        f = Foo("foo")
 248        self.assertRaises(TypeError, dir, f)
 249
 250        # dir(type)
 251        self.assert_("strip" in dir(str))
 252        self.assert_("__mro__" not in dir(str))
 253
 254        # dir(obj)
 255        class Foo(object):
 256            def __init__(self):
 257                self.x = 7
 258                self.y = 8
 259                self.z = 9
 260        f = Foo()
 261        self.assert_("y" in dir(f))
 262
 263        # dir(obj_no__dict__)
 264        class Foo(object):
 265            __slots__ = []
 266        f = Foo()
 267        self.assert_("__repr__" in dir(f))
 268
 269        # dir(obj_no__class__with__dict__)
 270        # (an ugly trick to cause getattr(f, "__class__") to fail)
 271        class Foo(object):
 272            __slots__ = ["__class__", "__dict__"]
 273            def __init__(self):
 274                self.bar = "wow"
 275        f = Foo()
 276        self.assert_("__repr__" not in dir(f))
 277        self.assert_("bar" in dir(f))
 278
 279        # dir(obj_using __dir__)
 280        class Foo(object):
 281            def __dir__(self):
 282                return ["kan", "ga", "roo"]
 283        f = Foo()
 284        self.assert_(dir(f) == ["ga", "kan", "roo"])
 285
 286        # dir(obj__dir__not_list)
 287        class Foo(object):
 288            def __dir__(self):
 289                return 7
 290        f = Foo()
 291        self.assertRaises(TypeError, dir, f)
 292
 293    def test_divmod(self):
 294        self.assertEqual(divmod(12, 7), (1, 5))
 295        self.assertEqual(divmod(-12, 7), (-2, 2))
 296        self.assertEqual(divmod(12, -7), (-2, -2))
 297        self.assertEqual(divmod(-12, -7), (1, -5))
 298
 299        self.assertEqual(divmod(12L, 7L), (1L, 5L))
 300        self.assertEqual(divmod(-12L, 7L), (-2L, 2L))
 301        self.assertEqual(divmod(12L, -7L), (-2L, -2L))
 302        self.assertEqual(divmod(-12L, -7L), (1L, -5L))
 303
 304        self.assertEqual(divmod(12, 7L), (1, 5L))
 305        self.assertEqual(divmod(-12, 7L), (-2, 2L))
 306        self.assertEqual(divmod(12L, -7), (-2L, -2))
 307        self.assertEqual(divmod(-12L, -7), (1L, -5))
 308
 309        self.assertEqual(divmod(-sys.maxint-1, -1),
 310                         (sys.maxint+1, 0))
 311
 312        self.assert_(not fcmp(divmod(3.25, 1.0), (3.0, 0.25)))
 313        self.assert_(not fcmp(divmod(-3.25, 1.0), (-4.0, 0.75)))
 314        self.assert_(not fcmp(divmod(3.25, -1.0), (-4.0, -0.75)))
 315        self.assert_(not fcmp(divmod(-3.25, -1.0), (3.0, -0.25)))
 316
 317        self.assertRaises(TypeError, divmod)
 318
 319    def test_eval(self):
 320        self.assertEqual(eval('1+1'), 2)
 321        self.assertEqual(eval(' 1+1\n'), 2)
 322        globals = {'a': 1, 'b': 2}
 323        locals = {'b': 200, 'c': 300}
 324        self.assertEqual(eval('a', globals) , 1)
 325        self.assertEqual(eval('a', globals, locals), 1)
 326        self.assertEqual(eval('b', globals, locals), 200)
 327        self.assertEqual(eval('c', globals, locals), 300)
 328        if have_unicode:
 329            self.assertEqual(eval(unicode('1+1')), 2)
 330            self.assertEqual(eval(unicode(' 1+1\n')), 2)
 331        globals = {'a': 1, 'b': 2}
 332        locals = {'b': 200, 'c': 300}
 333        if have_unicode:
 334            self.assertEqual(eval(unicode('a'), globals), 1)
 335            self.assertEqual(eval(unicode('a'), globals, locals), 1)
 336            self.assertEqual(eval(unicode('b'), globals, locals), 200)
 337            self.assertEqual(eval(unicode('c'), globals, locals), 300)
 338            bom = '\xef\xbb\xbf'
 339            self.assertEqual(eval(bom + 'a', globals, locals), 1)
 340            self.assertEqual(eval(unicode('u"\xc3\xa5"', 'utf8'), globals),
 341                             unicode('\xc3\xa5', 'utf8'))
 342        self.assertRaises(TypeError, eval)
 343        self.assertRaises(TypeError, eval, ())
 344
 345    def test_general_eval(self):
 346        # Tests that general mappings can be used for the locals argument
 347
 348        class M:
 349            "Test mapping interface versus possible calls from eval()."
 350            def __getitem__(self, key):
 351                if key == 'a':
 352                    return 12
 353                raise KeyError
 354            def keys(self):
 355                return list('xyz')
 356
 357        m = M()
 358        g = globals()
 359        self.assertEqual(eval('a', g, m), 12)
 360        self.assertRaises(NameError, eval, 'b', g, m)
 361        self.assertEqual(eval('dir()', g, m), list('xyz'))
 362        self.assertEqual(eval('globals()', g, m), g)
 363        self.assertEqual(eval('locals()', g, m), m)
 364        self.assertRaises(TypeError, eval, 'a', m)
 365        class A:
 366            "Non-mapping"
 367            pass
 368        m = A()
 369        self.assertRaises(TypeError, eval, 'a', g, m)
 370
 371        # Verify that dict subclasses work as well
 372        class D(dict):
 373            def __getitem__(self, key):
 374                if key == 'a':
 375                    return 12
 376                return dict.__getitem__(self, key)
 377            def keys(self):
 378                return list('xyz')
 379
 380        d = D()
 381        self.assertEqual(eval('a', g, d), 12)
 382        self.assertRaises(NameError, eval, 'b', g, d)
 383        self.assertEqual(eval('dir()', g, d), list('xyz'))
 384        self.assertEqual(eval('globals()', g, d), g)
 385        self.assertEqual(eval('locals()', g, d), d)
 386
 387        # Verify locals stores (used by list comps)
 388        eval('[locals() for i in (2,3)]', g, d)
 389        eval('[locals() for i in (2,3)]', g, UserDict.UserDict())
 390
 391        class SpreadSheet:
 392            "Sample application showing nested, calculated lookups."
 393            _cells = {}
 394            def __setitem__(self, key, formula):
 395                self._cells[key] = formula
 396            def __getitem__(self, key):
 397                return eval(self._cells[key], globals(), self)
 398
 399        ss = SpreadSheet()
 400        ss['a1'] = '5'
 401        ss['a2'] = 'a1*6'
 402        ss['a3'] = 'a2*7'
 403        self.assertEqual(ss['a3'], 210)
 404
 405        # Verify that dir() catches a non-list returned by eval
 406        # SF bug #1004669
 407        class C:
 408            def __getitem__(self, item):
 409                raise KeyError(item)
 410            def keys(self):
 411                return 'a'
 412        self.assertRaises(TypeError, eval, 'dir()', globals(), C())
 413
 414    # Done outside of the method test_z to get the correct scope
 415    z = 0
 416    f = open(TESTFN, 'w')
 417    f.write('z = z+1\n')
 418    f.write('z = z*2\n')
 419    f.close()
 420    execfile(TESTFN)
 421
 422    def test_execfile(self):
 423        global numruns
 424        if numruns:
 425            return
 426        numruns += 1
 427
 428        globals = {'a': 1, 'b': 2}
 429        locals = {'b': 200, 'c': 300}
 430
 431        self.assertEqual(self.__class__.z, 2)
 432        globals['z'] = 0
 433        execfile(TESTFN, globals)
 434        self.assertEqual(globals['z'], 2)
 435        locals['z'] = 0
 436        execfile(TESTFN, globals, locals)
 437        self.assertEqual(locals['z'], 2)
 438
 439        class M:
 440            "Test mapping interface versus possible calls from execfile()."
 441            def __init__(self):
 442                self.z = 10
 443            def __getitem__(self, key):
 444                if key == 'z':
 445                    return self.z
 446                raise KeyError
 447            def __setitem__(self, key, value):
 448                if key == 'z':
 449                    self.z = value
 450                    return
 451                raise KeyError
 452
 453        locals = M()
 454        locals['z'] = 0
 455        execfile(TESTFN, globals, locals)
 456        self.assertEqual(locals['z'], 2)
 457
 458        unlink(TESTFN)
 459        self.assertRaises(TypeError, execfile)
 460        self.assertRaises(TypeError, execfile, TESTFN, {}, ())
 461        import os
 462        self.assertRaises(IOError, execfile, os.curdir)
 463        self.assertRaises(IOError, execfile, "I_dont_exist")
 464
 465    def test_filter(self):
 466        self.assertEqual(filter(lambda c: 'a' <= c <= 'z', 'Hello World'), 'elloorld')
 467        self.assertEqual(filter(None, [1, 'hello', [], [3], '', None, 9, 0]), [1, 'hello', [3], 9])
 468        self.assertEqual(filter(lambda x: x > 0, [1, -3, 9, 0, 2]), [1, 9, 2])
 469        self.assertEqual(filter(None, Squares(10)), [1, 4, 9, 16, 25, 36, 49, 64, 81])
 470        self.assertEqual(filter(lambda x: x%2, Squares(10)), [1, 9, 25, 49, 81])
 471        def identity(item):
 472            return 1
 473        filter(identity, Squares(5))
 474        self.assertRaises(TypeError, filter)
 475        class BadSeq(object):
 476            def __getitem__(self, index):
 477                if index<4:
 478                    return 42
 479                raise ValueError
 480        self.assertRaises(ValueError, filter, lambda x: x, BadSeq())
 481        def badfunc():
 482            pass
 483        self.assertRaises(TypeError, filter, badfunc, range(5))
 484
 485        # test bltinmodule.c::filtertuple()
 486        self.assertEqual(filter(None, (1, 2)), (1, 2))
 487        self.assertEqual(filter(lambda x: x>=3, (1, 2, 3, 4)), (3, 4))
 488        self.assertRaises(TypeError, filter, 42, (1, 2))
 489
 490        # test bltinmodule.c::filterstring()
 491        self.assertEqual(filter(None, "12"), "12")
 492        self.assertEqual(filter(lambda x: x>="3", "1234"), "34")
 493        self.assertRaises(TypeError, filter, 42, "12")
 494        class badstr(str):
 495            def __getitem__(self, index):
 496                raise ValueError
 497        self.assertRaises(ValueError, filter, lambda x: x >="3", badstr("1234"))
 498
 499        class badstr2(str):
 500            def __getitem__(self, index):
 501                return 42
 502        self.assertRaises(TypeError, filter, lambda x: x >=42, badstr2("1234"))
 503
 504        class weirdstr(str):
 505            def __getitem__(self, index):
 506                return weirdstr(2*str.__getitem__(self, index))
 507        self.assertEqual(filter(lambda x: x>="33", weirdstr("1234")), "3344")
 508
 509        class shiftstr(str):
 510            def __getitem__(self, index):
 511                return chr(ord(str.__getitem__(self, index))+1)
 512        self.assertEqual(filter(lambda x: x>="3", shiftstr("1234")), "345")
 513
 514        if have_unicode:
 515            # test bltinmodule.c::filterunicode()
 516            self.assertEqual(filter(None, unicode("12")), unicode("12"))
 517            self.assertEqual(filter(lambda x: x>="3", unicode("1234")), unicode("34"))
 518            self.assertRaises(TypeError, filter, 42, unicode("12"))
 519            self.assertRaises(ValueError, filter, lambda x: x >="3", badstr(unicode("1234")))
 520
 521            class badunicode(unicode):
 522                def __getitem__(self, index):
 523                    return 42
 524            self.assertRaises(TypeError, filter, lambda x: x >=42, badunicode("1234"))
 525
 526            class weirdunicode(unicode):
 527                def __getitem__(self, index):
 528                    return weirdunicode(2*unicode.__getitem__(self, index))
 529            self.assertEqual(
 530                filter(lambda x: x>=unicode("33"), weirdunicode("1234")), unicode("3344"))
 531
 532            class shiftunicode(unicode):
 533                def __getitem__(self, index):
 534                    return unichr(ord(unicode.__getitem__(self, index))+1)
 535            self.assertEqual(
 536                filter(lambda x: x>=unicode("3"), shiftunicode("1234")),
 537                unicode("345")
 538            )
 539
 540    def test_filter_subclasses(self):
 541        # test that filter() never returns tuple, str or unicode subclasses
 542        # and that the result always goes through __getitem__
 543        funcs = (None, bool, lambda x: True)
 544        class tuple2(tuple):
 545            def __getitem__(self, index):
 546                return 2*tuple.__getitem__(self, index)
 547        class str2(str):
 548            def __getitem__(self, index):
 549                return 2*str.__getitem__(self, index)
 550        inputs = {
 551            tuple2: {(): (), (1, 2, 3): (2, 4, 6)},
 552            str2:   {"": "", "123": "112233"}
 553        }
 554        if have_unicode:
 555            class unicode2(unicode):
 556                def __getitem__(self, index):
 557                    return 2*unicode.__getitem__(self, index)
 558            inputs[unicode2] = {
 559                unicode(): unicode(),
 560                unicode("123"): unicode("112233")
 561            }
 562
 563        for (cls, inps) in inputs.iteritems():
 564            for (inp, exp) in inps.iteritems():
 565                # make sure the output goes through __getitem__
 566                # even if func is None
 567                self.assertEqual(
 568                    filter(funcs[0], cls(inp)),
 569                    filter(funcs[1], cls(inp))
 570                )
 571                for func in funcs:
 572                    outp = filter(func, cls(inp))
 573                    self.assertEqual(outp, exp)
 574                    self.assert_(not isinstance(outp, cls))
 575
 576    def test_getattr(self):
 577        import sys
 578        self.assert_(getattr(sys, 'stdout') is sys.stdout)
 579        self.assertRaises(TypeError, getattr, sys, 1)
 580        self.assertRaises(TypeError, getattr, sys, 1, "foo")
 581        self.assertRaises(TypeError, getattr)
 582        if have_unicode:
 583            self.assertRaises(UnicodeError, getattr, sys, unichr(sys.maxunicode))
 584
 585    def test_hasattr(self):
 586        import sys
 587        self.assert_(hasattr(sys, 'stdout'))
 588        self.assertRaises(TypeError, hasattr, sys, 1)
 589        self.assertRaises(TypeError, hasattr)
 590        if have_unicode:
 591            self.assertRaises(UnicodeError, hasattr, sys, unichr(sys.maxunicode))
 592
 593        # Check that hasattr allows SystemExit and KeyboardInterrupts by
 594        class A:
 595            def __getattr__(self, what):
 596                raise KeyboardInterrupt
 597        self.assertRaises(KeyboardInterrupt, hasattr, A(), "b")
 598        class B:
 599            def __getattr__(self, what):
 600                raise SystemExit
 601        self.assertRaises(SystemExit, hasattr, B(), "b")
 602
 603    def test_hash(self):
 604        hash(None)
 605        self.assertEqual(hash(1), hash(1L))
 606        self.assertEqual(hash(1), hash(1.0))
 607        hash('spam')
 608        if have_unicode:
 609            self.assertEqual(hash('spam'), hash(unicode('spam')))
 610        hash((0,1,2,3))
 611        def f(): pass
 612        self.assertRaises(TypeError, hash, [])
 613        self.assertRaises(TypeError, hash, {})
 614        # Bug 1536021: Allow hash to return long objects
 615        class X:
 616            def __hash__(self):
 617                return 2**100
 618        self.assertEquals(type(hash(X())), int)
 619        class Y(object):
 620            def __hash__(self):
 621                return 2**100
 622        self.assertEquals(type(hash(Y())), int)
 623        class Z(long):
 624            def __hash__(self):
 625                return self
 626        self.assertEquals(hash(Z(42)), hash(42L))
 627
 628    def test_hex(self):
 629        self.assertEqual(hex(16), '0x10')
 630        self.assertEqual(hex(16L), '0x10L')
 631        self.assertEqual(hex(-16), '-0x10')
 632        self.assertEqual(hex(-16L), '-0x10L')
 633        self.assertRaises(TypeError, hex, {})
 634
 635    def test_id(self):
 636        id(None)
 637        id(1)
 638        id(1L)
 639        id(1.0)
 640        id('spam')
 641        id((0,1,2,3))
 642        id([0,1,2,3])
 643        id({'spam': 1, 'eggs': 2, 'ham': 3})
 644
 645    # Test input() later, together with raw_input
 646
 647    def test_intern(self):
 648        self.assertRaises(TypeError, intern)
 649        s = "never interned before"
 650        self.assert_(intern(s) is s)
 651        s2 = s.swapcase().swapcase()
 652        self.assert_(intern(s2) is s)
 653
 654        # Verify the error message we get when interning a non-string.
 655        try:
 656            intern(object())
 657        except TypeError, e:
 658            self.assertEqual(str(e),
 659                             "intern() argument 1 must be string, not object")
 660        else:
 661            self.fail("Failed to raise exception")
 662
 663        # Subclasses of string can't be interned, because they
 664        # provide too much opportunity for insane things to happen.
 665        # We don't want them in the interned dict and if they aren't
 666        # actually interned, we don't want to create the appearance
 667        # that they are by allowing intern() to succeeed.
 668        class S(str):
 669            def __hash__(self):
 670                return 123
 671
 672        self.assertRaises(TypeError, intern, S("abc"))
 673
 674        # It's still safe to pass these strings to routines that
 675        # call intern internally, e.g. PyObject_SetAttr().
 676        s = S("abc")
 677        setattr(s, s, s)
 678        self.assertEqual(getattr(s, s), s)
 679
 680    def test_iter(self):
 681        self.assertRaises(TypeError, iter)
 682        self.assertRaises(TypeError, iter, 42, 42)
 683        lists = [("1", "2"), ["1", "2"], "12"]
 684        if have_unicode:
 685            lists.append(unicode("12"))
 686        for l in lists:
 687            i = iter(l)
 688            self.assertEqual(i.next(), '1')
 689            self.assertEqual(i.next(), '2')
 690            self.assertRaises(StopIteration, i.next)
 691
 692    def test_isinstance(self):
 693        class C:
 694            pass
 695        class D(C):
 696            pass
 697        class E:
 698            pass
 699        c = C()
 700        d = D()
 701        e = E()
 702        self.assert_(isinstance(c, C))
 703        self.assert_(isinstance(d, C))
 704        self.assert_(not isinstance(e, C))
 705        self.assert_(not isinstance(c, D))
 706        self.assert_(not isinstance('foo', E))
 707        self.assertRaises(TypeError, isinstance, E, 'foo')
 708        self.assertRaises(TypeError, isinstance)
 709
 710    def test_issubclass(self):
 711        class C:
 712            pass
 713        class D(C):
 714            pass
 715        class E:
 716            pass
 717        c = C()
 718        d = D()
 719        e = E()
 720        self.assert_(issubclass(D, C))
 721        self.assert_(issubclass(C, C))
 722        self.assert_(not issubclass(C, D))
 723        self.assertRaises(TypeError, issubclass, 'foo', E)
 724        self.assertRaises(TypeError, issubclass, E, 'foo')
 725        self.assertRaises(TypeError, issubclass)
 726
 727    def test_len(self):
 728        self.assertEqual(len('123'), 3)
 729        self.assertEqual(len(()), 0)
 730        self.assertEqual(len((1, 2, 3, 4)), 4)
 731        self.assertEqual(len([1, 2, 3, 4]), 4)
 732        self.assertEqual(len({}), 0)
 733        self.assertEqual(len({'a':1, 'b': 2}), 2)
 734        class BadSeq:
 735            def __len__(self):
 736                raise ValueError
 737        self.assertRaises(ValueError, len, BadSeq())
 738
 739    def test_map(self):
 740        self.assertEqual(
 741            map(None, 'hello world'),
 742            ['h','e','l','l','o',' ','w','o','r','l','d']
 743        )
 744        self.assertEqual(
 745            map(None, 'abcd', 'efg'),
 746            [('a', 'e'), ('b', 'f'), ('c', 'g'), ('d', None)]
 747        )
 748        self.assertEqual(
 749            map(None, range(10)),
 750            [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
 751        )
 752        self.assertEqual(
 753            map(lambda x: x*x, range(1,4)),
 754            [1, 4, 9]
 755        )
 756        try:
 757            from math import sqrt
 758        except ImportError:
 759            def sqrt(x):
 760                return pow(x, 0.5)
 761        self.assertEqual(
 762            map(lambda x: map(sqrt,x), [[16, 4], [81, 9]]),
 763            [[4.0, 2.0], [9.0, 3.0]]
 764        )
 765        self.assertEqual(
 766            map(lambda x, y: x+y, [1,3,2], [9,1,4]),
 767            [10, 4, 6]
 768        )
 769
 770        def plus(*v):
 771            accu = 0
 772            for i in v: accu = accu + i
 773            return accu
 774        self.assertEqual(
 775            map(plus, [1, 3, 7]),
 776            [1, 3, 7]
 777        )
 778        self.assertEqual(
 779            map(plus, [1, 3, 7], [4, 9, 2]),
 780            [1+4, 3+9, 7+2]
 781        )
 782        self.assertEqual(
 783            map(plus, [1, 3, 7], [4, 9, 2], [1, 1, 0]),
 784            [1+4+1, 3+9+1, 7+2+0]
 785        )
 786        self.assertEqual(
 787            map(None, Squares(10)),
 788            [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
 789        )
 790        self.assertEqual(
 791            map(int, Squares(10)),
 792            [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
 793        )
 794        self.assertEqual(
 795            map(None, Squares(3), Squares(2)),
 796            [(0,0), (1,1), (4,None)]
 797        )
 798        self.assertEqual(
 799            map(max, Squares(3), Squares(2)),
 800            [0, 1, 4]
 801        )
 802        self.assertRaises(TypeError, map)
 803        self.assertRaises(TypeError, map, lambda x: x, 42)
 804        self.assertEqual(map(None, [42]), [42])
 805        class BadSeq:
 806            def __getitem__(self, index):
 807                raise ValueError
 808        self.assertRaises(ValueError, map, lambda x: x, BadSeq())
 809        def badfunc(x):
 810            raise RuntimeError
 811        self.assertRaises(RuntimeError, map, badfunc, range(5))
 812
 813    def test_max(self):
 814        self.assertEqual(max('123123'), '3')
 815        self.assertEqual(max(1, 2, 3), 3)
 816        self.assertEqual(max((1, 2, 3, 1, 2, 3)), 3)
 817        self.assertEqual(max([1, 2, 3, 1, 2, 3]), 3)
 818
 819        self.assertEqual(max(1, 2L, 3.0), 3.0)
 820        self.assertEqual(max(1L, 2.0, 3), 3)
 821        self.assertEqual(max(1.0, 2, 3L), 3L)
 822
 823        for stmt in (
 824            "max(key=int)",                 # no args
 825            "max(1, key=int)",              # single arg not iterable
 826            "max(1, 2, keystone=int)",      # wrong keyword
 827            "max(1, 2, key=int, abc=int)",  # two many keywords
 828            "max(1, 2, key=1)",             # keyfunc is not callable
 829            ):
 830            try:
 831                exec(stmt) in globals()
 832            except TypeError:
 833                pass
 834            else:
 835                self.fail(stmt)
 836
 837        self.assertEqual(max((1,), key=neg), 1)     # one elem iterable
 838        self.assertEqual(max((1,2), key=neg), 1)    # two elem iterable
 839        self.assertEqual(max(1, 2, key=neg), 1)     # two elems
 840
 841        data = [random.randrange(200) for i in range(100)]
 842        keys = dict((elem, random.randrange(50)) for elem in data)
 843        f = keys.__getitem__
 844        self.assertEqual(max(data, key=f),
 845                         sorted(reversed(data), key=f)[-1])
 846
 847    def test_min(self):
 848        self.assertEqual(min('123123'), '1')
 849        self.assertEqual(min(1, 2, 3), 1)
 850        self.assertEqual(min((1, 2, 3, 1, 2, 3)), 1)
 851        self.assertEqual(min([1, 2, 3, 1, 2, 3]), 1)
 852
 853        self.assertEqual(min(1, 2L, 3.0), 1)
 854        self.assertEqual(min(1L, 2.0, 3), 1L)
 855        self.assertEqual(min(1.0, 2, 3L), 1.0)
 856
 857        self.assertRaises(TypeError, min)
 858        self.assertRaises(TypeError, min, 42)
 859        self.assertRaises(ValueError, min, ())
 860        class BadSeq:
 861            def __getitem__(self, index):
 862                raise ValueError
 863        self.assertRaises(ValueError, min, BadSeq())
 864        class BadNumber:
 865            def __cmp__(self, other):
 866                raise ValueError
 867        self.assertRaises(ValueError, min, (42, BadNumber()))
 868
 869        for stmt in (
 870            "min(key=int)",                 # no args
 871            "min(1, key=int)",              # single arg not iterable
 872            "min(1, 2, keystone=int)",      # wrong keyword
 873            "min(1, 2, key=int, abc=int)",  # two many keywords
 874            "min(1, 2, key=1)",             # keyfunc is not callable
 875            ):
 876            try:
 877                exec(stmt) in globals()
 878            except TypeError:
 879                pass
 880            else:
 881                self.fail(stmt)
 882
 883        self.assertEqual(min((1,), key=neg), 1)     # one elem iterable
 884        self.assertEqual(min((1,2), key=neg), 2)    # two elem iterable
 885        self.assertEqual(min(1, 2, key=neg), 2)     # two elems
 886
 887        data = [random.randrange(200) for i in range(100)]
 888        keys = dict((elem, random.randrange(50)) for elem in data)
 889        f = keys.__getitem__
 890        self.assertEqual(min(data, key=f),
 891                         sorted(data, key=f)[0])
 892
 893    def test_next(self):
 894        it = iter(range(2))
 895        self.assertEqual(next(it), 0)
 896        self.assertEqual(next(it), 1)
 897        self.assertRaises(StopIteration, next, it)
 898        self.assertRaises(StopIteration, next, it)
 899        self.assertEquals(next(it, 42), 42)
 900
 901        class Iter(object):
 902            def __iter__(self):
 903                return self
 904            def next(self):
 905                raise StopIteration
 906
 907        it = iter(Iter())
 908        self.assertEquals(next(it, 42), 42)
 909        self.assertRaises(StopIteration, next, it)
 910
 911        def gen():
 912            yield 1
 913            return
 914
 915        it = gen()
 916        self.assertEquals(next(it), 1)
 917        self.assertRaises(StopIteration, next, it)
 918        self.assertEquals(next(it, 42), 42)
 919
 920    def test_oct(self):
 921        self.assertEqual(oct(100), '0144')
 922        self.assertEqual(oct(100L), '0144L')
 923        self.assertEqual(oct(-100), '-0144')
 924        self.assertEqual(oct(-100L), '-0144L')
 925        self.assertRaises(TypeError, oct, ())
 926
 927    def write_testfile(self):
 928        # NB the first 4 lines are also used to test input and raw_input, below
 929        fp = open(TESTFN, 'w')
 930        try:
 931            fp.write('1+1\n')
 932            fp.write('1+1\n')
 933            fp.write('The quick brown fox jumps over the lazy dog')
 934            fp.write('.\n')
 935            fp.write('Dear John\n')
 936            fp.write('XXX'*100)
 937            fp.write('YYY'*100)
 938        finally:
 939            fp.close()
 940
 941    def test_open(self):
 942        self.write_testfile()
 943        fp = open(TESTFN, 'r')
 944        try:
 945            self.assertEqual(fp.readline(4), '1+1\n')
 946            self.assertEqual(fp.readline(4), '1+1\n')
 947            self.assertEqual(fp.readline(), 'The quick brown fox jumps over the lazy dog.\n')
 948            self.assertEqual(fp.readline(4), 'Dear')
 949            self.assertEqual(fp.readline(100), ' John\n')
 950            self.assertEqual(fp.read(300), 'XXX'*100)
 951            self.assertEqual(fp.read(1000), 'YYY'*100)
 952        finally:
 953            fp.close()
 954        unlink(TESTFN)
 955
 956    def test_ord(self):
 957        self.assertEqual(ord(' '), 32)
 958        self.assertEqual(ord('A'), 65)
 959        self.assertEqual(ord('a'), 97)
 960        if have_unicode:
 961            self.assertEqual(ord(unichr(sys.maxunicode)), sys.maxunicode)
 962        self.assertRaises(TypeError, ord, 42)
 963        if have_unicode:
 964            self.assertRaises(TypeError, ord, unicode("12"))
 965
 966    def test_pow(self):
 967        self.assertEqual(pow(0,0), 1)
 968        self.assertEqual(pow(0,1), 0)
 969        self.assertEqual(pow(1,0), 1)
 970        self.assertEqual(pow(1,1), 1)
 971
 972        self.assertEqual(pow(2,0), 1)
 973        self.assertEqual(pow(2,10), 1024)
 974        self.assertEqual(pow(2,20), 1024*1024)
 975        self.assertEqual(pow(2,30), 1024*1024*1024)
 976
 977        self.assertEqual(pow(-2,0), 1)
 978        self.assertEqual(pow(-2,1), -2)
 979        self.assertEqual(pow(-2,2), 4)
 980        self.assertEqual(pow(-2,3), -8)
 981
 982        self.assertEqual(pow(0L,0), 1)
 983        self.assertEqual(pow(0L,1), 0)
 984        self.assertEqual(pow(1L,0), 1)
 985        self.assertEqual(pow(1L,1), 1)
 986
 987        self.assertEqual(pow(2L,0), 1)
 988        self.assertEqual(pow(2L,10), 1024)
 989        self.assertEqual(pow(2L,20), 1024*1024)
 990        self.assertEqual(pow(2L,30), 1024*1024*1024)
 991
 992        self.assertEqual(pow(-2L,0), 1)
 993        self.assertEqual(pow(-2L,1), -2)
 994        self.assertEqual(pow(-2L,2), 4)
 995        self.assertEqual(pow(-2L,3), -8)
 996
 997        self.assertAlmostEqual(pow(0.,0), 1.)
 998        self.assertAlmostEqual(pow(0.,1), 0.)
 999        self.assertAlmostEqual(pow(1.,0), 1.)
1000        self.assertAlmostEqual(pow(1.,1), 1.)
1001
1002        self.assertAlmostEqual(pow(2.,0), 1.)
1003        self.assertAlmostEqual(pow(2.,10), 1024.)
1004        self.assertAlmostEqual(pow(2.,20), 1024.*1024.)
1005        self.assertAlmostEqual(pow(2.,30), 1024.*1024.*1024.)
1006
1007        self.assertAlmostEqual(pow(-2.,0), 1.)
1008        self.assertAlmostEqual(pow(-2.,1), -2.)
1009        self.assertAlmostEqual(pow(-2.,2), 4.)
1010        self.assertAlmostEqual(pow(-2.,3), -8.)
1011
1012        for x in 2, 2L, 2.0:
1013            for y in 10, 10L, 10.0:
1014                for z in 1000, 1000L, 1000.0:
1015                    if isinstance(x, float) or \
1016                       isinstance(y, float) or \
1017                       isinstance(z, float):
1018                        self.assertRaises(TypeError, pow, x, y, z)
1019                    else:
1020                        self.assertAlmostEqual(pow(x, y, z), 24.0)
1021
1022        self.assertRaises(TypeError, pow, -1, -2, 3)
1023        self.assertRaises(ValueError, pow, 1, 2, 0)
1024        self.assertRaises(TypeError, pow, -1L, -2L, 3L)
1025        self.assertRaises(ValueError, pow, 1L, 2L, 0L)
1026        # Will return complex in 3.0:
1027        self.assertRaises(ValueError, pow, -342.43, 0.234)
1028
1029        self.assertRaises(TypeError, pow)
1030
1031    def test_range(self):
1032        self.assertEqual(range(3), [0, 1, 2])
1033        self.assertEqual(range(1, 5), [1, 2, 3, 4])
1034        self.assertEqual(range(0), [])
1035        self.assertEqual(range(-3), [])
1036        self.assertEqual(range(1, 10, 3), [1, 4, 7])
1037        self.assertEqual(range(5, -5, -3), [5, 2, -1, -4])
1038
1039        # Now test range() with longs
1040        self.assertEqual(range(-2**100), [])
1041        self.assertEqual(range(0, -2**100), [])
1042        self.assertEqual(range(0, 2**100, -1), [])
1043        self.assertEqual(range(0, 2**100, -1), [])
1044
1045        a = long(10 * sys.maxint)
1046        b = long(100 * sys.maxint)
1047        c = long(50 * sys.maxint)
1048
1049        self.assertEqual(range(a, a+2), [a, a+1])
1050        self.assertEqual(range(a+2, a, -1L), [a+2, a+1])
1051        self.assertEqual(range(a+4, a, -2), [a+4, a+2])
1052
1053        seq = range(a, b, c)
1054        self.assert_(a in seq)
1055        self.assert_(b not in seq)
1056        self.assertEqual(len(seq), 2)
1057
1058        seq = range(b, a, -c)
1059        self.assert_(b in seq)
1060        self.assert_(a not in seq)
1061        self.assertEqual(len(seq), 2)
1062
1063        seq = range(-a, -b, -c)
1064        self.assert_(-a in seq)
1065        self.assert_(-b not in seq)
1066        self.assertEqual(len(seq), 2)
1067
1068        self.assertRaises(TypeError, range)
1069        self.assertRaises(TypeError, range, 1, 2, 3, 4)
1070        self.assertRaises(ValueError, range, 1, 2, 0)
1071        self.assertRaises(ValueError, range, a, a + 1, long(0))
1072
1073        class badzero(int):
1074            def __cmp__(self, other):
1075                raise RuntimeError
1076            __hash__ = None # Invalid cmp makes this unhashable
1077        self.assertRaises(RuntimeError, range, a, a + 1, badzero(1))
1078
1079        # Reject floats when it would require PyLongs to represent.
1080        # (smaller floats still accepted, but deprecated)
1081        self.assertRaises(TypeError, range, 1e100, 1e101, 1e101)
1082
1083        self.assertRaises(TypeError, range, 0, "spam")
1084        self.assertRaises(TypeError, range, 0, 42, "spam")
1085
1086        self.assertRaises(OverflowError, range, -sys.maxint, sys.maxint)
1087        self.assertRaises(OverflowError, range, 0, 2*sys.maxint)
1088
1089    def test_input_and_raw_input(self):
1090        self.write_testfile()
1091        fp = open(TESTFN, 'r')
1092        savestdin = sys.stdin
1093        savestdout = sys.stdout # Eats the echo
1094        try:
1095            sys.stdin = fp
1096            sys.stdout = BitBucket()
1097            self.assertEqual(input(), 2)
1098            self.assertEqual(input('testing\n'), 2)
1099            self.assertEqual(raw_input(), 'The quick brown fox jumps over the lazy dog.')
1100            self.assertEqual(raw_input('testing\n'), 'Dear John')
1101
1102            # SF 1535165: don't segfault on closed stdin
1103            # sys.stdout must be a regular file for triggering
1104            sys.stdout = savestdout
1105            sys.stdin.close()
1106            self.assertRaises(ValueError, input)
1107
1108            sys.stdout = BitBucket()
1109            sys.stdin = cStringIO.StringIO("NULL\0")
1110            self.assertRaises(TypeError, input, 42, 42)
1111            sys.stdin = cStringIO.StringIO("    'whitespace'")
1112            self.assertEqual(input(), 'whitespace')
1113            sys.stdin = cStringIO.StringIO()
1114            self.assertRaises(EOFError, input)
1115
1116            # SF 876178: make sure input() respect future options.
1117            sys.stdin = cStringIO.StringIO('1/2')
1118            sys.stdout = cStringIO.StringIO()
1119            exec compile('print input()', 'test_builtin_tmp', 'exec')
1120            sys.stdin.seek(0, 0)
1121            exec compile('from __future__ import division;print input()',
1122                         'test_builtin_tmp', 'exec')
1123            sys.stdin.seek(0, 0)
1124            exec compile('print input()', 'test_builtin_tmp', 'exec')
1125            # The result we expect depends on whether new division semantics
1126            # are already in effect.
1127            if 1/2 == 0:
1128                # This test was compiled with old semantics.
1129                expected = ['0', '0.5', '0']
1130            else:
1131                # This test was compiled with new semantics (e.g., -Qnew
1132                # was given on the command line.
1133                expected = ['0.5', '0.5', '0.5']
1134            self.assertEqual(sys.stdout.getvalue().splitlines(), expected)
1135
1136            del sys.stdout
1137            self.assertRaises(RuntimeError, input, 'prompt')
1138            del sys.stdin
1139            self.assertRaises(RuntimeError, input, 'prompt')
1140        finally:
1141            sys.stdin = savestdin
1142            sys.stdout = savestdout
1143            fp.close()
1144            unlink(TESTFN)
1145
1146    def test_reduce(self):
1147        self.assertEqual(reduce(lambda x, y: x+y, ['a', 'b', 'c'], ''), 'abc')
1148        self.assertEqual(
1149            reduce(lambda x, y: x+y, [['a', 'c'], [], ['d', 'w']], []),
1150            ['a','c','d','w']
1151        )
1152        self.assertEqual(reduce(lambda x, y: x*y, range(2,8), 1), 5040)
1153        self.assertEqual(
1154            reduce(lambda x, y: x*y, range(2,21), 1L),
1155            2432902008176640000L
1156        )
1157        self.assertEqual(reduce(lambda x, y: x+y, Squares(10)), 285)
1158        self.assertEqual(reduce(lambda x, y: x+y, Squares(10), 0), 285)
1159        self.assertEqual(reduce(lambda x, y: x+y, Squares(0), 0), 0)
1160        self.assertRaises(TypeError, reduce)
1161        self.assertRaises(TypeError, reduce, 42, 42)
1162        self.assertRaises(TypeError, reduce, 42, 42, 42)
1163        self.assertEqual(reduce(42, "1"), "1") # func is never called with one item
1164        self.assertEqual(reduce(42, "", "1"), "1") # func is never called with one item
1165        self.assertRaises(TypeError, reduce, 42, (42, 42))
1166
1167        class BadSeq:
1168            def __getitem__(self, index):
1169                raise ValueError
1170        self.assertRaises(ValueError, reduce, 42, BadSeq())
1171
1172    def test_reload(self):
1173        import marshal
1174        reload(marshal)
1175        import string
1176        reload(string)
1177        ## import sys
1178        ## self.assertRaises(ImportError, reload, sys)
1179
1180    def test_repr(self):
1181        self.assertEqual(repr(''), '\'\'')
1182        self.assertEqual(repr(0), '0')
1183        self.assertEqual(repr(0L), '0L')
1184        self.assertEqual(repr(()), '()')
1185        self.assertEqual(repr([]), '[]')
1186        self.assertEqual(repr({}), '{}')
1187        a = []
1188        a.append(a)
1189        self.assertEqual(repr(a), '[[...]]')
1190        a = {}
1191        a[0] = a
1192        self.assertEqual(repr(a), '{0: {...}}')
1193
1194    def test_round(self):
1195        self.assertEqual(round(0.0), 0.0)
1196        self.assertEqual(type(round(0.0)), float)  # Will be int in 3.0.
1197        self.assertEqual(round(1.0), 1.0)
1198        self.assertEqual(round(10.0), 10.0)
1199        self.assertEqual(round(1000000000.0), 1000000000.0)
1200        self.assertEqual(round(1e20), 1e20)
1201
1202        self.assertEqual(round(-1.0), -1.0)
1203        self.assertEqual(round(-10.0), -10.0)
1204        self.assertEqual(round(-1000000000.0), -1000000000.0)
1205        self.assertEqual(round(-1e20), -1e20)
1206
1207        self.assertEqual(round(0.1), 0.0)
1208        self.assertEqual(round(1.1), 1.0)
1209        self.assertEqual(round(10.1), 10.0)
1210        self.assertEqual(round(1000000000.1), 1000000000.0)
1211
1212        self.assertEqual(round(-1.1), -1.0)
1213        self.assertEqual(round(-10.1), -10.0)
1214        self.assertEqual(round(-1000000000.1), -1000000000.0)
1215
1216        self.assertEqual(round(0.9), 1.0)
1217        self.assertEqual(round(9.9), 10.0)
1218        self.assertEqual(round(999999999.9), 1000000000.0)
1219
1220        self.assertEqual(round(-0.9), -1.0)
1221        self.assertEqual(round(-9.9), -10.0)
1222        self.assertEqual(round(-999999999.9), -1000000000.0)
1223
1224        self.assertEqual(round(-8.0, -1), -10.0)
1225        self.assertEqual(type(round(-8.0, -1)), float)
1226
1227        self.assertEqual(type(round(-8.0, 0)), float)
1228        self.assertEqual(type(round(-8.0, 1)), float)
1229
1230        # Check half rounding behaviour.
1231        self.assertEqual(round(5.5), 6)
1232        self.assertEqual(round(6.5), 7)
1233        self.assertEqual(round(-5.5), -6)
1234        self.assertEqual(round(-6.5), -7)
1235
1236        # Check behavior on ints
1237        self.assertEqual(round(0), 0)
1238        self.assertEqual(round(8), 8)
1239        self.assertEqual(round(-8), -8)
1240        self.assertEqual(type(round(0)), float)  # Will be int in 3.0.
1241        self.assertEqual(type(round(-8, -1)), float)
1242        self.assertEqual(type(round(-8, 0)), float)
1243        self.assertEqual(type(round(-8, 1)), float)
1244
1245        # test new kwargs
1246        self.assertEqual(round(number=-8.0, ndigits=-1), -10.0)
1247
1248        self.assertRaises(TypeError, round)
1249
1250        # test generic rounding delegation for reals
1251        class TestRound(object):
1252            def __float__(self):
1253                return 23.0
1254
1255        class TestNoRound(object):
1256            pass
1257
1258        self.assertEqual(round(TestRound()), 23)
1259
1260        self.assertRaises(TypeError, round, 1, 2, 3)
1261        self.assertRaises(TypeError, round, TestNoRound())
1262
1263        t = TestNoRound()
1264        t.__float__ = lambda *args: args
1265        self.assertRaises(TypeError, round, t)
1266        self.assertRaises(TypeError, round, t, 0)
1267
1268    def test_setattr(self):
1269        setattr(sys, 'spam', 1)
1270        self.assertEqual(sys.spam, 1)
1271        self.assertRaises(TypeError, setattr, sys, 1, 'spam')
1272        self.assertRaises(TypeError, setattr)
1273
1274    def test_sum(self):
1275        self.assertEqual(sum([]), 0)
1276        self.assertEqual(sum(range(2,8)), 27)
1277        self.assertEqual(sum(iter(range(2,8))), 27)
1278        self.assertEqual(sum(Squares(10)), 285)
1279        self.assertEqual(sum(iter(Squares(10))), 285)
1280        self.assertEqual(sum([[1], [2], [3]], []), [1, 2, 3])
1281
1282        self.assertRaises(TypeError, sum)
1283        self.assertRaises(TypeError, sum, 42)
1284        self.assertRaises(TypeError, sum, ['a', 'b', 'c'])
1285        self.assertRaises(TypeError, sum, ['a', 'b', 'c'], '')
1286        self.assertRaises(TypeError, sum, [[1], [2], [3]])
1287        self.assertRaises(TypeError, sum, [{2:3}])
1288        self.assertRaises(TypeError, sum, [{2:3}]*2, {2:3})
1289
1290        class BadSeq:
1291            def __getitem__(self, index):
1292                raise ValueError
1293        self.assertRaises(ValueError, sum, BadSeq())
1294
1295    def test_type(self):
1296        self.assertEqual(type(''),  type('123'))
1297        self.assertNotEqual(type(''), type(()))
1298
1299    def test_unichr(self):
1300        if have_unicode:
1301            self.assertEqual(unichr(32), unicode(' '))
1302            self.assertEqual(unichr(65), unicode('A'))
1303            self.assertEqual(unichr(97), unicode('a'))
1304            self.assertEqual(
1305                unichr(sys.maxunicode),
1306                unicode('\\U%08x' % (sys.maxunicode), 'unicode-escape')
1307            )
1308            self.assertRaises(ValueError, unichr, sys.maxunicode+1)
1309            self.assertRaises(TypeError, unichr)
1310            self.assertRaises((OverflowError, ValueError), unichr, 2**32)
1311
1312    # We don't want self in vars(), so these are static methods
1313
1314    @staticmethod
1315    def get_vars_f0():
1316        return vars()
1317
1318    @staticmethod
1319    def get_vars_f2():
1320        BuiltinTest.get_vars_f0()
1321        a = 1
1322        b = 2
1323        return vars()
1324
1325    def test_vars(self):
1326        self.assertEqual(set(vars()), set(dir()))
1327        import sys
1328        self.assertEqual(set(vars(sys)), set(dir(sys)))
1329        self.assertEqual(self.get_vars_f0(), {})
1330        self.assertEqual(self.get_vars_f2(), {'a': 1, 'b': 2})
1331        self.assertRaises(TypeError, vars, 42, 42)
1332        self.assertRaises(TypeError, vars, 42)
1333
1334    def test_zip(self):
1335        a = (1, 2, 3)
1336        b = (4, 5, 6)
1337        t = [(1, 4), (2, 5), (3, 6)]
1338        self.assertEqual(zip(a, b), t)
1339        b = [4, 5, 6]
1340        self.assertEqual(zip(a, b), t)
1341        b = (4, 5, 6, 7)
1342        self.assertEqual(zip(a, b), t)
1343        class I:
1344            def __getitem__(self, i):
1345                if i < 0 or i > 2: raise IndexError
1346                return i + 4
1347        self.assertEqual(zip(a, I()), t)
1348        self.assertEqual(zip(), [])
1349        self.assertEqual(zip(*[]), [])
1350        self.assertRaises(TypeError, zip, None)
1351        class G:
1352            pass
1353        self.assertRaises(TypeError, zip, a, G())
1354
1355        # Make sure zip doesn't try to allocate a billion elements for the
1356        # result list when one of its arguments doesn't say how long it is.
1357        # A MemoryError is the most likely failure mode.
1358        class SequenceWithoutALength:
1359            def __getitem__(self, i):
1360                if i == 5:
1361                    raise IndexError
1362                else:
1363                    return i
1364        self.assertEqual(
1365            zip(SequenceWithoutALength(), xrange(2**30)),
1366            list(enumerate(range(5)))
1367        )
1368
1369        class BadSeq:
1370            def __getitem__(self, i):
1371                if i == 5:
1372                    raise ValueError
1373                else:
1374                    return i
1375        self.assertRaises(ValueError, zip, BadSeq(), BadSeq())
1376
1377    def test_format(self):
1378        # Test the basic machinery of the format() builtin.  Don't test
1379        #  the specifics of the various formatters
1380        self.assertEqual(format(3, ''), '3')
1381
1382        # Returns some classes to use for various tests.  There's
1383        #  an old-style version, and a new-style version
1384        def classes_new():
1385            class A(object):
1386                def __init__(self, x):
1387                    self.x = x
1388                def __format__(self, format_spec):
1389                    return str(self.x) + format_spec
1390            class DerivedFromA(A):
1391                pass
1392
1393            class Simple(object): pass
1394            class DerivedFromSimple(Simple):
1395                def __init__(self, x):
1396                    self.x = x
1397                def __format__(self, format_spec):
1398                    return str(self.x) + format_spec
1399            class DerivedFromSi

Large files files are truncated, but you can click here to view the full file