Lib/test/test_builtin.py

   1 # Python test set -- built-in functions
   2
   3 import test.test_support, unittest
   4 from test.test_support import fcmp, have_unicode, TESTFN, unlink
   5
   6 import sys, warnings, cStringIO
   7 warnings.filterwarnings("ignore", "hex../oct.. of negative int",
   8                         FutureWarning, __name__)
   9 warnings.filterwarnings("ignore", "integer argument expected",
  10                         DeprecationWarning, "unittest")
  11
  12 class Squares:
  13
  14     def __init__(self, max):
  15         self.max = max
  16         self.sofar = []
  17
  18     def __len__(self): return len(self.sofar)
  19
  20     def __getitem__(self, i):
  21         if not 0 <= i < self.max: raise IndexError
  22         n = len(self.sofar)
  23         while n <= i:
  24             self.sofar.append(n*n)
  25             n += 1
  26         return self.sofar[i]
  27
  28 class StrSquares:
  29
  30     def __init__(self, max):
  31         self.max = max
  32         self.sofar = []
  33
  34     def __len__(self):
  35         return len(self.sofar)
  36
  37     def __getitem__(self, i):
  38         if not 0 <= i < self.max:
  39             raise IndexError
  40         n = len(self.sofar)
  41         while n <= i:
  42             self.sofar.append(str(n*n))
  43             n += 1
  44         return self.sofar[i]
  45
  46 class BitBucket:
  47     def write(self, line):
  48         pass
  49
  50 L = [
  51         ('0', 0),
  52         ('1', 1),
  53         ('9', 9),
  54         ('10', 10),
  55         ('99', 99),
  56         ('100', 100),
  57         ('314', 314),
  58         (' 314', 314),
  59         ('314 ', 314),
  60         ('  \t\t  314  \t\t  ', 314),
  61         (`sys.maxint`, sys.maxint),
  62         ('  1x', ValueError),
  63         ('  1  ', 1),
  64         ('  1\02  ', ValueError),
  65         ('', ValueError),
  66         (' ', ValueError),
  67         ('  \t\t  ', ValueError)
  68 ]
  69 if have_unicode:
  70     L += [
  71         (unicode('0'), 0),
  72         (unicode('1'), 1),
  73         (unicode('9'), 9),
  74         (unicode('10'), 10),
  75         (unicode('99'), 99),
  76         (unicode('100'), 100),
  77         (unicode('314'), 314),
  78         (unicode(' 314'), 314),
  79         (unicode('\u0663\u0661\u0664 ','raw-unicode-escape'), 314),
  80         (unicode('  \t\t  314  \t\t  '), 314),
  81         (unicode('  1x'), ValueError),
  82         (unicode('  1  '), 1),
  83         (unicode('  1\02  '), ValueError),
  84         (unicode(''), ValueError),
  85         (unicode(' '), ValueError),
  86         (unicode('  \t\t  '), ValueError),
  87         (unichr(0x200), ValueError),
  88 ]
  89
  90 class BuiltinTest(unittest.TestCase):
  91
  92     def test_import(self):
  93         __import__('sys')
  94         __import__('time')
  95         __import__('string')
  96         self.assertRaises(ImportError, __import__, 'spamspam')
  97         self.assertRaises(TypeError, __import__, 1, 2, 3, 4)
  98
  99     def test_abs(self):
 100         # int
 101         self.assertEqual(abs(0), 0)
 102         self.assertEqual(abs(1234), 1234)
 103         self.assertEqual(abs(-1234), 1234)
 104         # float
 105         self.assertEqual(abs(0.0), 0.0)
 106         self.assertEqual(abs(3.14), 3.14)
 107         self.assertEqual(abs(-3.14), 3.14)
 108         # long
 109         self.assertEqual(abs(0L), 0L)
 110         self.assertEqual(abs(1234L), 1234L)
 111         self.assertEqual(abs(-1234L), 1234L)
 112         # str
 113         self.assertRaises(TypeError, abs, 'a')
 114
 115     def test_apply(self):
 116         def f0(*args):
 117             self.assertEqual(args, ())
 118         def f1(a1):
 119             self.assertEqual(a1, 1)
 120         def f2(a1, a2):
 121             self.assertEqual(a1, 1)
 122             self.assertEqual(a2, 2)
 123         def f3(a1, a2, a3):
 124             self.assertEqual(a1, 1)
 125             self.assertEqual(a2, 2)
 126             self.assertEqual(a3, 3)
 127         apply(f0, ())
 128         apply(f1, (1,))
 129         apply(f2, (1, 2))
 130         apply(f3, (1, 2, 3))
 131
 132         # A PyCFunction that takes only positional parameters should allow an
 133         # empty keyword dictionary to pass without a complaint, but raise a
 134         # TypeError if the dictionary is non-empty.
 135         apply(id, (1,), {})
 136         self.assertRaises(TypeError, apply, id, (1,), {"foo": 1})
 137         self.assertRaises(TypeError, apply)
 138         self.assertRaises(TypeError, apply, id, 42)
 139         self.assertRaises(TypeError, apply, id, (42,), 42)
 140
 141     def test_callable(self):
 142         self.assert_(callable(len))
 143         def f(): pass
 144         self.assert_(callable(f))
 145         class C:
 146             def meth(self): pass
 147         self.assert_(callable(C))
 148         x = C()
 149         self.assert_(callable(x.meth))
 150         self.assert_(not callable(x))
 151         class D(C):
 152             def __call__(self): pass
 153         y = D()
 154         self.assert_(callable(y))
 155         y()
 156
 157     def test_chr(self):
 158         self.assertEqual(chr(32), ' ')
 159         self.assertEqual(chr(65), 'A')
 160         self.assertEqual(chr(97), 'a')
 161         self.assertEqual(chr(0xff), '\xff')
 162         self.assertRaises(ValueError, chr, 256)
 163         self.assertRaises(TypeError, chr)
 164
 165     def test_cmp(self):
 166         self.assertEqual(cmp(-1, 1), -1)
 167         self.assertEqual(cmp(1, -1), 1)
 168         self.assertEqual(cmp(1, 1), 0)
 169         # verify that circular objects are handled
 170         a = []; a.append(a)
 171         b = []; b.append(b)
 172         from UserList import UserList
 173         c = UserList(); c.append(c)
 174         self.assertEqual(cmp(a, b), 0)
 175         self.assertEqual(cmp(b, c), 0)
 176         self.assertEqual(cmp(c, a), 0)
 177         self.assertEqual(cmp(a, c), 0)
 178         # okay, now break the cycles
 179         a.pop(); b.pop(); c.pop()
 180         self.assertRaises(TypeError, cmp)
 181
 182     def test_coerce(self):
 183         self.assert_(not fcmp(coerce(1, 1.1), (1.0, 1.1)))
 184         self.assertEqual(coerce(1, 1L), (1L, 1L))
 185         self.assert_(not fcmp(coerce(1L, 1.1), (1.0, 1.1)))
 186         self.assertRaises(TypeError, coerce)
 187         class BadNumber:
 188             def __coerce__(self, other):
 189                 raise ValueError
 190         self.assertRaises(ValueError, coerce, 42, BadNumber())
 191         self.assertRaises(OverflowError, coerce, 0.5, int("12345" * 1000))
 192
 193     def test_compile(self):
 194         compile('print 1\n', '', 'exec')
 195         bom = '\xef\xbb\xbf'
 196         compile(bom + 'print 1\n', '', 'exec')
 197         self.assertRaises(TypeError, compile)
 198         self.assertRaises(ValueError, compile, 'print 42\n', '<string>', 'badmode')
 199         self.assertRaises(ValueError, compile, 'print 42\n', '<string>', 'single', 0xff)
 200         if have_unicode:
 201             compile(unicode('print u"\xc3\xa5"\n', 'utf8'), '', 'exec')
 202
 203     def test_complex(self):
 204         class OS:
 205             def __complex__(self): return 1+10j
 206         class NS(object):
 207             def __complex__(self): return 1+10j
 208         self.assertEqual(complex(OS()), 1+10j)
 209         self.assertEqual(complex(NS()), 1+10j)
 210         self.assertEqual(complex("1+10j"), 1+10j)
 211         self.assertEqual(complex(10), 10+0j)
 212         self.assertEqual(complex(10.0), 10+0j)
 213         self.assertEqual(complex(10L), 10+0j)
 214         self.assertEqual(complex(10+0j), 10+0j)
 215         self.assertEqual(complex(1,10), 1+10j)
 216         self.assertEqual(complex(1,10L), 1+10j)
 217         self.assertEqual(complex(1,10.0), 1+10j)
 218         self.assertEqual(complex(1L,10), 1+10j)
 219         self.assertEqual(complex(1L,10L), 1+10j)
 220         self.assertEqual(complex(1L,10.0), 1+10j)
 221         self.assertEqual(complex(1.0,10), 1+10j)
 222         self.assertEqual(complex(1.0,10L), 1+10j)
 223         self.assertEqual(complex(1.0,10.0), 1+10j)
 224         self.assertEqual(complex(3.14+0j), 3.14+0j)
 225         self.assertEqual(complex(3.14), 3.14+0j)
 226         self.assertEqual(complex(314), 314.0+0j)
 227         self.assertEqual(complex(314L), 314.0+0j)
 228         self.assertEqual(complex(3.14+0j, 0j), 3.14+0j)
 229         self.assertEqual(complex(3.14, 0.0), 3.14+0j)
 230         self.assertEqual(complex(314, 0), 314.0+0j)
 231         self.assertEqual(complex(314L, 0L), 314.0+0j)
 232         self.assertEqual(complex(0j, 3.14j), -3.14+0j)
 233         self.assertEqual(complex(0.0, 3.14j), -3.14+0j)
 234         self.assertEqual(complex(0j, 3.14), 3.14j)
 235         self.assertEqual(complex(0.0, 3.14), 3.14j)
 236         self.assertEqual(complex("1"), 1+0j)
 237         self.assertEqual(complex("1j"), 1j)
 238
 239         c = 3.14 + 1j
 240         self.assert_(complex(c) is c)
 241         del c
 242
 243         self.assertRaises(TypeError, complex, "1", "1")
 244         self.assertRaises(TypeError, complex, 1, "1")
 245
 246         self.assertEqual(complex("  3.14+J  "), 3.14+1j)
 247         if have_unicode:
 248             self.assertEqual(complex(unicode("  3.14+J  ")), 3.14+1j)
 249
 250         # SF bug 543840:  complex(string) accepts strings with \0
 251         # Fixed in 2.3.
 252         self.assertRaises(ValueError, complex, '1+1j\0j')
 253
 254         class Z:
 255             def __complex__(self): return 3.14j
 256         z = Z()
 257         self.assertEqual(complex(z), 3.14j)
 258
 259     def test_delattr(self):
 260         import sys
 261         sys.spam = 1
 262         delattr(sys, 'spam')
 263         self.assertRaises(TypeError, delattr)
 264
 265     def test_dir(self):
 266         x = 1
 267         self.assert_('x' in dir())
 268         import sys
 269         self.assert_('modules' in dir(sys))
 270         self.assertRaises(TypeError, dir, 42, 42)
 271
 272     def test_divmod(self):
 273         self.assertEqual(divmod(12, 7), (1, 5))
 274         self.assertEqual(divmod(-12, 7), (-2, 2))
 275         self.assertEqual(divmod(12, -7), (-2, -2))
 276         self.assertEqual(divmod(-12, -7), (1, -5))
 277
 278         self.assertEqual(divmod(12L, 7L), (1L, 5L))
 279         self.assertEqual(divmod(-12L, 7L), (-2L, 2L))
 280         self.assertEqual(divmod(12L, -7L), (-2L, -2L))
 281         self.assertEqual(divmod(-12L, -7L), (1L, -5L))
 282
 283         self.assertEqual(divmod(12, 7L), (1, 5L))
 284         self.assertEqual(divmod(-12, 7L), (-2, 2L))
 285         self.assertEqual(divmod(12L, -7), (-2L, -2))
 286         self.assertEqual(divmod(-12L, -7), (1L, -5))
 287
 288         self.assert_(not fcmp(divmod(3.25, 1.0), (3.0, 0.25)))
 289         self.assert_(not fcmp(divmod(-3.25, 1.0), (-4.0, 0.75)))
 290         self.assert_(not fcmp(divmod(3.25, -1.0), (-4.0, -0.75)))
 291         self.assert_(not fcmp(divmod(-3.25, -1.0), (3.0, -0.25)))
 292
 293         self.assertRaises(TypeError, divmod)
 294
 295     def test_eval(self):
 296         self.assertEqual(eval('1+1'), 2)
 297         self.assertEqual(eval(' 1+1\n'), 2)
 298         globals = {'a': 1, 'b': 2}
 299         locals = {'b': 200, 'c': 300}
 300         self.assertEqual(eval('a', globals) , 1)
 301         self.assertEqual(eval('a', globals, locals), 1)
 302         self.assertEqual(eval('b', globals, locals), 200)
 303         self.assertEqual(eval('c', globals, locals), 300)
 304         if have_unicode:
 305             self.assertEqual(eval(unicode('1+1')), 2)
 306             self.assertEqual(eval(unicode(' 1+1\n')), 2)
 307         globals = {'a': 1, 'b': 2}
 308         locals = {'b': 200, 'c': 300}
 309         if have_unicode:
 310             self.assertEqual(eval(unicode('a'), globals), 1)
 311             self.assertEqual(eval(unicode('a'), globals, locals), 1)
 312             self.assertEqual(eval(unicode('b'), globals, locals), 200)
 313             self.assertEqual(eval(unicode('c'), globals, locals), 300)
 314             bom = '\xef\xbb\xbf'
 315             self.assertEqual(eval(bom + 'a', globals, locals), 1)
 316             self.assertEqual(eval(unicode('u"\xc3\xa5"', 'utf8'), globals),
 317                              unicode('\xc3\xa5', 'utf8'))
 318         self.assertRaises(TypeError, eval)
 319         self.assertRaises(TypeError, eval, ())
 320
 321     # Done outside of the method test_z to get the correct scope
 322     z = 0
 323     f = open(TESTFN, 'w')
 324     f.write('z = z+1\n')
 325     f.write('z = z*2\n')
 326     f.close()
 327     execfile(TESTFN)
 328
 329     def test_execfile(self):
 330         globals = {'a': 1, 'b': 2}
 331         locals = {'b': 200, 'c': 300}
 332
 333         self.assertEqual(self.__class__.z, 2)
 334         globals['z'] = 0
 335         execfile(TESTFN, globals)
 336         self.assertEqual(globals['z'], 2)
 337         locals['z'] = 0
 338         execfile(TESTFN, globals, locals)
 339         self.assertEqual(locals['z'], 2)
 340         unlink(TESTFN)
 341         self.assertRaises(TypeError, execfile)
 342         import os
 343         self.assertRaises(IOError, execfile, os.curdir)
 344         self.assertRaises(IOError, execfile, "I_dont_exist")
 345
 346     def test_filter(self):
 347         self.assertEqual(filter(lambda c: 'a' <= c <= 'z', 'Hello World'), 'elloorld')
 348         self.assertEqual(filter(None, [1, 'hello', [], [3], '', None, 9, 0]), [1, 'hello', [3], 9])
 349         self.assertEqual(filter(lambda x: x > 0, [1, -3, 9, 0, 2]), [1, 9, 2])
 350         self.assertEqual(filter(None, Squares(10)), [1, 4, 9, 16, 25, 36, 49, 64, 81])
 351         self.assertEqual(filter(lambda x: x%2, Squares(10)), [1, 9, 25, 49, 81])
 352         def identity(item):
 353             return 1
 354         filter(identity, Squares(5))
 355         self.assertRaises(TypeError, filter)
 356         class BadSeq(object):
 357             def __getitem__(self, index):
 358                 if index<4:
 359                     return 42
 360                 raise ValueError
 361         self.assertRaises(ValueError, filter, lambda x: x, BadSeq())
 362         def badfunc():
 363             pass
 364         self.assertRaises(TypeError, filter, badfunc, range(5))
 365
 366         # test bltinmodule.c::filtertuple()
 367         self.assertEqual(filter(None, (1, 2)), (1, 2))
 368         self.assertEqual(filter(lambda x: x>=3, (1, 2, 3, 4)), (3, 4))
 369         self.assertRaises(TypeError, filter, 42, (1, 2))
 370
 371         # test bltinmodule.c::filterstring()
 372         self.assertEqual(filter(None, "12"), "12")
 373         self.assertEqual(filter(lambda x: x>="3", "1234"), "34")
 374         self.assertRaises(TypeError, filter, 42, "12")
 375         class badstr(str):
 376             def __getitem__(self, index):
 377                 raise ValueError
 378         self.assertRaises(ValueError, filter, lambda x: x >="3", badstr("1234"))
 379
 380         class badstr2(str):
 381             def __getitem__(self, index):
 382                 return 42
 383         self.assertRaises(TypeError, filter, lambda x: x >=42, badstr2("1234"))
 384
 385         class weirdstr(str):
 386             def __getitem__(self, index):
 387                 return weirdstr(2*str.__getitem__(self, index))
 388         self.assertEqual(filter(lambda x: x>="33", weirdstr("1234")), "3344")
 389
 390         class shiftstr(str):
 391             def __getitem__(self, index):
 392                 return chr(ord(str.__getitem__(self, index))+1)
 393         self.assertEqual(filter(lambda x: x>="3", shiftstr("1234")), "345")
 394
 395         if have_unicode:
 396             # test bltinmodule.c::filterunicode()
 397             self.assertEqual(filter(None, unicode("12")), unicode("12"))
 398             self.assertEqual(filter(lambda x: x>="3", unicode("1234")), unicode("34"))
 399             self.assertRaises(TypeError, filter, 42, unicode("12"))
 400             self.assertRaises(ValueError, filter, lambda x: x >="3", badstr(unicode("1234")))
 401
 402             class badunicode(unicode):
 403                 def __getitem__(self, index):
 404                     return 42
 405             self.assertRaises(TypeError, filter, lambda x: x >=42, badunicode("1234"))
 406
 407             class weirdunicode(unicode):
 408                 def __getitem__(self, index):
 409                     return weirdunicode(2*unicode.__getitem__(self, index))
 410             self.assertEqual(
 411                 filter(lambda x: x>=unicode("33"), weirdunicode("1234")), unicode("3344"))
 412
 413             class shiftunicode(unicode):
 414                 def __getitem__(self, index):
 415                     return unichr(ord(unicode.__getitem__(self, index))+1)
 416             self.assertEqual(
 417                 filter(lambda x: x>=unicode("3"), shiftunicode("1234")),
 418                 unicode("345")
 419             )
 420
 421     def test_filter_subclasses(self):
 422         # test, that filter() never returns tuple, str or unicode subclasses
 423         # and that the result always go's through __getitem__
 424         funcs = (None, lambda x: True)
 425         class tuple2(tuple):
 426             def __getitem__(self, index):
 427                 return 2*tuple.__getitem__(self, index)
 428         class str2(str):
 429             def __getitem__(self, index):
 430                 return 2*str.__getitem__(self, index)
 431         inputs = {
 432             tuple2: {(): (), (1, 2, 3): (2, 4, 6)},
 433             str2:   {"": "", "123": "112233"}
 434         }
 435         if have_unicode:
 436             class unicode2(unicode):
 437                 def __getitem__(self, index):
 438                     return 2*unicode.__getitem__(self, index)
 439             inputs[unicode2] = {
 440                 unicode(): unicode(),
 441                 unicode("123"): unicode("112233")
 442             }
 443
 444         for (cls, inps) in inputs.iteritems():
 445             for (inp, exp) in inps.iteritems():
 446                 # make sure the output goes through __getitem__
 447                 # even if func is None
 448                 self.assertEqual(
 449                     filter(funcs[0], cls(inp)),
 450                     filter(funcs[1], cls(inp))
 451                 )
 452                 for func in funcs:
 453                     outp = filter(func, cls(inp))
 454                     self.assertEqual(outp, exp)
 455                     self.assert_(not isinstance(outp, cls))
 456
 457     def test_float(self):
 458         self.assertEqual(float(3.14), 3.14)
 459         self.assertEqual(float(314), 314.0)
 460         self.assertEqual(float(314L), 314.0)
 461         self.assertEqual(float("  3.14  "), 3.14)
 462         if have_unicode:
 463             self.assertEqual(float(unicode("  3.14  ")), 3.14)
 464             self.assertEqual(float(unicode("  \u0663.\u0661\u0664  ",'raw-unicode-escape')), 3.14)
 465
 466     def test_getattr(self):
 467         import sys
 468         self.assert_(getattr(sys, 'stdout') is sys.stdout)
 469         self.assertRaises(TypeError, getattr, sys, 1)
 470         self.assertRaises(TypeError, getattr, sys, 1, "foo")
 471         self.assertRaises(TypeError, getattr)
 472         self.assertRaises(UnicodeError, getattr, sys, unichr(sys.maxunicode))
 473
 474     def test_hasattr(self):
 475         import sys
 476         self.assert_(hasattr(sys, 'stdout'))
 477         self.assertRaises(TypeError, hasattr, sys, 1)
 478         self.assertRaises(TypeError, hasattr)
 479         self.assertRaises(UnicodeError, hasattr, sys, unichr(sys.maxunicode))
 480
 481     def test_hash(self):
 482         hash(None)
 483         self.assertEqual(hash(1), hash(1L))
 484         self.assertEqual(hash(1), hash(1.0))
 485         hash('spam')
 486         if have_unicode:
 487             self.assertEqual(hash('spam'), hash(unicode('spam')))
 488         hash((0,1,2,3))
 489         def f(): pass
 490         self.assertRaises(TypeError, hash, [])
 491         self.assertRaises(TypeError, hash, {})
 492
 493     def test_hex(self):
 494         self.assertEqual(hex(16), '0x10')
 495         self.assertEqual(hex(16L), '0x10L')
 496         self.assertEqual(len(hex(-1)), len(hex(sys.maxint)))
 497         self.assert_(hex(-16) in ('0xfffffff0', '0xfffffffffffffff0'))
 498         self.assertEqual(hex(-16L), '-0x10L')
 499         self.assertRaises(TypeError, hex, {})
 500
 501     def test_id(self):
 502         id(None)
 503         id(1)
 504         id(1L)
 505         id(1.0)
 506         id('spam')
 507         id((0,1,2,3))
 508         id([0,1,2,3])
 509         id({'spam': 1, 'eggs': 2, 'ham': 3})
 510
 511     # Test input() later, together with raw_input
 512
 513     def test_int(self):
 514         self.assertEqual(int(314), 314)
 515         self.assertEqual(int(3.14), 3)
 516         self.assertEqual(int(314L), 314)
 517         # Check that conversion from float truncates towards zero
 518         self.assertEqual(int(-3.14), -3)
 519         self.assertEqual(int(3.9), 3)
 520         self.assertEqual(int(-3.9), -3)
 521         self.assertEqual(int(3.5), 3)
 522         self.assertEqual(int(-3.5), -3)
 523         # Different base:
 524         self.assertEqual(int("10",16), 16L)
 525         if have_unicode:
 526             self.assertEqual(int(unicode("10"),16), 16L)
 527         # Test conversion from strings and various anomalies
 528         for s, v in L:
 529             for sign in "", "+", "-":
 530                 for prefix in "", " ", "\t", "  \t\t  ":
 531                     ss = prefix + sign + s
 532                     vv = v
 533                     if sign == "-" and v is not ValueError:
 534                         vv = -v
 535                     try:
 536                         self.assertEqual(int(ss), vv)
 537                     except v:
 538                         pass
 539
 540         s = `-1-sys.maxint`
 541         self.assertEqual(int(s)+1, -sys.maxint)
 542         # should return long
 543         int(s[1:])
 544
 545         # should return long
 546         x = int(1e100)
 547         self.assert_(isinstance(x, long))
 548         x = int(-1e100)
 549         self.assert_(isinstance(x, long))
 550
 551
 552         # SF bug 434186:  0x80000000/2 != 0x80000000>>1.
 553         # Worked by accident in Windows release build, but failed in debug build.
 554         # Failed in all Linux builds.
 555         x = -1-sys.maxint
 556         self.assertEqual(x >> 1, x//2)
 557
 558         self.assertRaises(ValueError, int, '123\0')
 559         self.assertRaises(ValueError, int, '53', 40)
 560
 561         x = int('1' * 600)
 562         self.assert_(isinstance(x, long))
 563
 564         if have_unicode:
 565             x = int(unichr(0x661) * 600)
 566             self.assert_(isinstance(x, long))
 567
 568         self.assertRaises(TypeError, int, 1, 12)
 569
 570         self.assertEqual(int('0123', 0), 83)
 571
 572     def test_intern(self):
 573         self.assertRaises(TypeError, intern)
 574         s = "never interned before"
 575         self.assert_(intern(s) is s)
 576         s2 = s.swapcase().swapcase()
 577         self.assert_(intern(s2) is s)
 578
 579     def test_iter(self):
 580         self.assertRaises(TypeError, iter)
 581         self.assertRaises(TypeError, iter, 42, 42)
 582         lists = [("1", "2"), ["1", "2"], "12"]
 583         if have_unicode:
 584             lists.append(unicode("12"))
 585         for l in lists:
 586             i = iter(l)
 587             self.assertEqual(i.next(), '1')
 588             self.assertEqual(i.next(), '2')
 589             self.assertRaises(StopIteration, i.next)
 590
 591     def test_isinstance(self):
 592         class C:
 593             pass
 594         class D(C):
 595             pass
 596         class E:
 597             pass
 598         c = C()
 599         d = D()
 600         e = E()
 601         self.assert_(isinstance(c, C))
 602         self.assert_(isinstance(d, C))
 603         self.assert_(not isinstance(e, C))
 604         self.assert_(not isinstance(c, D))
 605         self.assert_(not isinstance('foo', E))
 606         self.assertRaises(TypeError, isinstance, E, 'foo')
 607         self.assertRaises(TypeError, isinstance)
 608
 609     def test_issubclass(self):
 610         class C:
 611             pass
 612         class D(C):
 613             pass
 614         class E:
 615             pass
 616         c = C()
 617         d = D()
 618         e = E()
 619         self.assert_(issubclass(D, C))
 620         self.assert_(issubclass(C, C))
 621         self.assert_(not issubclass(C, D))
 622         self.assertRaises(TypeError, issubclass, 'foo', E)
 623         self.assertRaises(TypeError, issubclass, E, 'foo')
 624         self.assertRaises(TypeError, issubclass)
 625
 626     def test_len(self):
 627         self.assertEqual(len('123'), 3)
 628         self.assertEqual(len(()), 0)
 629         self.assertEqual(len((1, 2, 3, 4)), 4)
 630         self.assertEqual(len([1, 2, 3, 4]), 4)
 631         self.assertEqual(len({}), 0)
 632         self.assertEqual(len({'a':1, 'b': 2}), 2)
 633         class BadSeq:
 634             def __len__(self):
 635                 raise ValueError
 636         self.assertRaises(ValueError, len, BadSeq())
 637
 638     def test_list(self):
 639         self.assertEqual(list([]), [])
 640         l0_3 = [0, 1, 2, 3]
 641         l0_3_bis = list(l0_3)
 642         self.assertEqual(l0_3, l0_3_bis)
 643         self.assert_(l0_3 is not l0_3_bis)
 644         self.assertEqual(list(()), [])
 645         self.assertEqual(list((0, 1, 2, 3)), [0, 1, 2, 3])
 646         self.assertEqual(list(''), [])
 647         self.assertEqual(list('spam'), ['s', 'p', 'a', 'm'])
 648
 649         if sys.maxint == 0x7fffffff:
 650             # This test can currently only work on 32-bit machines.
 651             # XXX If/when PySequence_Length() returns a ssize_t, it should be
 652             # XXX re-enabled.
 653             # Verify clearing of bug #556025.
 654             # This assumes that the max data size (sys.maxint) == max
 655             # address size this also assumes that the address size is at
 656             # least 4 bytes with 8 byte addresses, the bug is not well
 657             # tested
 658             #
 659             # Note: This test is expected to SEGV under Cygwin 1.3.12 or
 660             # earlier due to a newlib bug.  See the following mailing list
 661             # thread for the details:
 662
 663             #     http://sources.redhat.com/ml/newlib/2002/msg00369.html
 664             self.assertRaises(MemoryError, list, xrange(sys.maxint // 2))
 665
 666     def test_long(self):
 667         self.assertEqual(long(314), 314L)
 668         self.assertEqual(long(3.14), 3L)
 669         self.assertEqual(long(314L), 314L)
 670         # Check that conversion from float truncates towards zero
 671         self.assertEqual(long(-3.14), -3L)
 672         self.assertEqual(long(3.9), 3L)
 673         self.assertEqual(long(-3.9), -3L)
 674         self.assertEqual(long(3.5), 3L)
 675         self.assertEqual(long(-3.5), -3L)
 676         self.assertEqual(long("-3"), -3L)
 677         if have_unicode:
 678             self.assertEqual(long(unicode("-3")), -3L)
 679         # Different base:
 680         self.assertEqual(long("10",16), 16L)
 681         if have_unicode:
 682             self.assertEqual(long(unicode("10"),16), 16L)
 683         # Check conversions from string (same test set as for int(), and then some)
 684         LL = [
 685                 ('1' + '0'*20, 10L**20),
 686                 ('1' + '0'*100, 10L**100)
 687         ]
 688         L2 = L
 689         if have_unicode:
 690             L2 += [
 691                 (unicode('1') + unicode('0')*20, 10L**20),
 692                 (unicode('1') + unicode('0')*100, 10L**100),
 693         ]
 694         for s, v in L2 + LL:
 695             for sign in "", "+", "-":
 696                 for prefix in "", " ", "\t", "  \t\t  ":
 697                     ss = prefix + sign + s
 698                     vv = v
 699                     if sign == "-" and v is not ValueError:
 700                         vv = -v
 701                     try:
 702                         self.assertEqual(long(ss), long(vv))
 703                     except v:
 704                         pass
 705
 706         self.assertRaises(ValueError, long, '123\0')
 707         self.assertRaises(ValueError, long, '53', 40)
 708         self.assertRaises(TypeError, long, 1, 12)
 709
 710     def test_map(self):
 711         self.assertEqual(
 712             map(None, 'hello world'),
 713             ['h','e','l','l','o',' ','w','o','r','l','d']
 714         )
 715         self.assertEqual(
 716             map(None, 'abcd', 'efg'),
 717             [('a', 'e'), ('b', 'f'), ('c', 'g'), ('d', None)]
 718         )
 719         self.assertEqual(
 720             map(None, range(10)),
 721             [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
 722         )
 723         self.assertEqual(
 724             map(lambda x: x*x, range(1,4)),
 725             [1, 4, 9]
 726         )
 727         try:
 728             from math import sqrt
 729         except ImportError:
 730             def sqrt(x):
 731                 return pow(x, 0.5)
 732         self.assertEqual(
 733             map(lambda x: map(sqrt,x), [[16, 4], [81, 9]]),
 734             [[4.0, 2.0], [9.0, 3.0]]
 735         )
 736         self.assertEqual(
 737             map(lambda x, y: x+y, [1,3,2], [9,1,4]),
 738             [10, 4, 6]
 739         )
 740
 741         def plus(*v):
 742             accu = 0
 743             for i in v: accu = accu + i
 744             return accu
 745         self.assertEqual(
 746             map(plus, [1, 3, 7]),
 747             [1, 3, 7]
 748         )
 749         self.assertEqual(
 750             map(plus, [1, 3, 7], [4, 9, 2]),
 751             [1+4, 3+9, 7+2]
 752         )
 753         self.assertEqual(
 754             map(plus, [1, 3, 7], [4, 9, 2], [1, 1, 0]),
 755             [1+4+1, 3+9+1, 7+2+0]
 756         )
 757         self.assertEqual(
 758             map(None, Squares(10)),
 759             [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
 760         )
 761         self.assertEqual(
 762             map(int, Squares(10)),
 763             [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
 764         )
 765         self.assertEqual(
 766             map(None, Squares(3), Squares(2)),
 767             [(0,0), (1,1), (4,None)]
 768         )
 769         self.assertEqual(
 770             map(max, Squares(3), Squares(2)),
 771             [0, 1, 4]
 772         )
 773         self.assertRaises(TypeError, map)
 774         self.assertRaises(TypeError, map, lambda x: x, 42)
 775         self.assertEqual(map(None, [42]), [42])
 776         class BadSeq:
 777             def __getitem__(self, index):
 778                 raise ValueError
 779         self.assertRaises(ValueError, map, lambda x: x, BadSeq())
 780
 781     def test_max(self):
 782         self.assertEqual(max('123123'), '3')
 783         self.assertEqual(max(1, 2, 3), 3)
 784         self.assertEqual(max((1, 2, 3, 1, 2, 3)), 3)
 785         self.assertEqual(max([1, 2, 3, 1, 2, 3]), 3)
 786
 787         self.assertEqual(max(1, 2L, 3.0), 3.0)
 788         self.assertEqual(max(1L, 2.0, 3), 3)
 789         self.assertEqual(max(1.0, 2, 3L), 3L)
 790
 791     def test_min(self):
 792         self.assertEqual(min('123123'), '1')
 793         self.assertEqual(min(1, 2, 3), 1)
 794         self.assertEqual(min((1, 2, 3, 1, 2, 3)), 1)
 795         self.assertEqual(min([1, 2, 3, 1, 2, 3]), 1)
 796
 797         self.assertEqual(min(1, 2L, 3.0), 1)
 798         self.assertEqual(min(1L, 2.0, 3), 1L)
 799         self.assertEqual(min(1.0, 2, 3L), 1.0)
 800
 801         self.assertRaises(TypeError, min)
 802         self.assertRaises(TypeError, min, 42)
 803         self.assertRaises(ValueError, min, ())
 804         class BadSeq:
 805             def __getitem__(self, index):
 806                 raise ValueError
 807         self.assertRaises(ValueError, min, BadSeq())
 808         class BadNumber:
 809             def __cmp__(self, other):
 810                 raise ValueError
 811         self.assertRaises(ValueError, min, (42, BadNumber()))
 812
 813     def test_oct(self):
 814         self.assertEqual(oct(100), '0144')
 815         self.assertEqual(oct(100L), '0144L')
 816         self.assert_(oct(-100) in ('037777777634', '01777777777777777777634'))
 817         self.assertEqual(oct(-100L), '-0144L')
 818         self.assertRaises(TypeError, oct, ())
 819
 820     def write_testfile(self):
 821         # NB the first 4 lines are also used to test input and raw_input, below
 822         fp = open(TESTFN, 'w')
 823         try:
 824             fp.write('1+1\n')
 825             fp.write('1+1\n')
 826             fp.write('The quick brown fox jumps over the lazy dog')
 827             fp.write('.\n')
 828             fp.write('Dear John\n')
 829             fp.write('XXX'*100)
 830             fp.write('YYY'*100)
 831         finally:
 832             fp.close()
 833
 834     def test_open(self):
 835         self.write_testfile()
 836         fp = open(TESTFN, 'r')
 837         try:
 838             self.assertEqual(fp.readline(4), '1+1\n')
 839             self.assertEqual(fp.readline(4), '1+1\n')
 840             self.assertEqual(fp.readline(), 'The quick brown fox jumps over the lazy dog.\n')
 841             self.assertEqual(fp.readline(4), 'Dear')
 842             self.assertEqual(fp.readline(100), ' John\n')
 843             self.assertEqual(fp.read(300), 'XXX'*100)
 844             self.assertEqual(fp.read(1000), 'YYY'*100)
 845         finally:
 846             fp.close()
 847         unlink(TESTFN)
 848
 849     def test_ord(self):
 850         self.assertEqual(ord(' '), 32)
 851         self.assertEqual(ord('A'), 65)
 852         self.assertEqual(ord('a'), 97)
 853         if have_unicode:
 854             self.assertEqual(ord(unichr(sys.maxunicode)), sys.maxunicode)
 855         self.assertRaises(TypeError, ord, 42)
 856         self.assertRaises(TypeError, ord, unicode("12"))
 857
 858     def test_pow(self):
 859         self.assertEqual(pow(0,0), 1)
 860         self.assertEqual(pow(0,1), 0)
 861         self.assertEqual(pow(1,0), 1)
 862         self.assertEqual(pow(1,1), 1)
 863
 864         self.assertEqual(pow(2,0), 1)
 865         self.assertEqual(pow(2,10), 1024)
 866         self.assertEqual(pow(2,20), 1024*1024)
 867         self.assertEqual(pow(2,30), 1024*1024*1024)
 868
 869         self.assertEqual(pow(-2,0), 1)
 870         self.assertEqual(pow(-2,1), -2)
 871         self.assertEqual(pow(-2,2), 4)
 872         self.assertEqual(pow(-2,3), -8)
 873
 874         self.assertEqual(pow(0L,0), 1)
 875         self.assertEqual(pow(0L,1), 0)
 876         self.assertEqual(pow(1L,0), 1)
 877         self.assertEqual(pow(1L,1), 1)
 878
 879         self.assertEqual(pow(2L,0), 1)
 880         self.assertEqual(pow(2L,10), 1024)
 881         self.assertEqual(pow(2L,20), 1024*1024)
 882         self.assertEqual(pow(2L,30), 1024*1024*1024)
 883
 884         self.assertEqual(pow(-2L,0), 1)
 885         self.assertEqual(pow(-2L,1), -2)
 886         self.assertEqual(pow(-2L,2), 4)
 887         self.assertEqual(pow(-2L,3), -8)
 888
 889         self.assertAlmostEqual(pow(0.,0), 1.)
 890         self.assertAlmostEqual(pow(0.,1), 0.)
 891         self.assertAlmostEqual(pow(1.,0), 1.)
 892         self.assertAlmostEqual(pow(1.,1), 1.)
 893
 894         self.assertAlmostEqual(pow(2.,0), 1.)
 895         self.assertAlmostEqual(pow(2.,10), 1024.)
 896         self.assertAlmostEqual(pow(2.,20), 1024.*1024.)
 897         self.assertAlmostEqual(pow(2.,30), 1024.*1024.*1024.)
 898
 899         self.assertAlmostEqual(pow(-2.,0), 1.)
 900         self.assertAlmostEqual(pow(-2.,1), -2.)
 901         self.assertAlmostEqual(pow(-2.,2), 4.)
 902         self.assertAlmostEqual(pow(-2.,3), -8.)
 903
 904         for x in 2, 2L, 2.0:
 905             for y in 10, 10L, 10.0:
 906                 for z in 1000, 1000L, 1000.0:
 907                     if isinstance(x, float) or \
 908                        isinstance(y, float) or \
 909                        isinstance(z, float):
 910                         self.assertRaises(TypeError, pow, x, y, z)
 911                     else:
 912                         self.assertAlmostEqual(pow(x, y, z), 24.0)
 913
 914         self.assertRaises(TypeError, pow, -1, -2, 3)
 915         self.assertRaises(ValueError, pow, 1, 2, 0)
 916         self.assertRaises(TypeError, pow, -1L, -2L, 3L)
 917         self.assertRaises(ValueError, pow, 1L, 2L, 0L)
 918         self.assertRaises(ValueError, pow, -342.43, 0.234)
 919
 920         self.assertRaises(TypeError, pow)
 921
 922     def test_range(self):
 923         self.assertEqual(range(3), [0, 1, 2])
 924         self.assertEqual(range(1, 5), [1, 2, 3, 4])
 925         self.assertEqual(range(0), [])
 926         self.assertEqual(range(-3), [])
 927         self.assertEqual(range(1, 10, 3), [1, 4, 7])
 928         self.assertEqual(range(5, -5, -3), [5, 2, -1, -4])
 929
 930         # Now test range() with longs
 931         self.assertEqual(range(-2**100), [])
 932         self.assertEqual(range(0, -2**100), [])
 933         self.assertEqual(range(0, 2**100, -1), [])
 934         self.assertEqual(range(0, 2**100, -1), [])
 935
 936         a = long(10 * sys.maxint)
 937         b = long(100 * sys.maxint)
 938         c = long(50 * sys.maxint)
 939
 940         self.assertEqual(range(a, a+2), [a, a+1])
 941         self.assertEqual(range(a+2, a, -1L), [a+2, a+1])
 942         self.assertEqual(range(a+4, a, -2), [a+4, a+2])
 943
 944         seq = range(a, b, c)
 945         self.assert_(a in seq)
 946         self.assert_(b not in seq)
 947         self.assertEqual(len(seq), 2)
 948
 949         seq = range(b, a, -c)
 950         self.assert_(b in seq)
 951         self.assert_(a not in seq)
 952         self.assertEqual(len(seq), 2)
 953
 954         seq = range(-a, -b, -c)
 955         self.assert_(-a in seq)
 956         self.assert_(-b not in seq)
 957         self.assertEqual(len(seq), 2)
 958
 959         self.assertRaises(TypeError, range)
 960         self.assertRaises(TypeError, range, 1, 2, 3, 4)
 961         self.assertRaises(ValueError, range, 1, 2, 0)
 962
 963         # Reject floats when it would require PyLongs to represent.
 964         # (smaller floats still accepted, but deprecated)
 965         self.assertRaises(TypeError, range, 1e100, 1e101, 1e101)
 966
 967         self.assertRaises(TypeError, range, 0, "spam")
 968         self.assertRaises(TypeError, range, 0, 42, "spam")
 969
 970         self.assertRaises(OverflowError, range, -sys.maxint, sys.maxint)
 971         self.assertRaises(OverflowError, range, 0, 2*sys.maxint)
 972
 973     def test_input_and_raw_input(self):
 974         self.write_testfile()
 975         fp = open(TESTFN, 'r')
 976         savestdin = sys.stdin
 977         savestdout = sys.stdout # Eats the echo
 978         try:
 979             sys.stdin = fp
 980             sys.stdout = BitBucket()
 981             self.assertEqual(input(), 2)
 982             self.assertEqual(input('testing\n'), 2)
 983             self.assertEqual(raw_input(), 'The quick brown fox jumps over the lazy dog.')
 984             self.assertEqual(raw_input('testing\n'), 'Dear John')
 985             sys.stdin = cStringIO.StringIO("NULL\0")
 986             self.assertRaises(TypeError, input, 42, 42)
 987             sys.stdin = cStringIO.StringIO("    'whitespace'")
 988             self.assertEqual(input(), 'whitespace')
 989             sys.stdin = cStringIO.StringIO()
 990             self.assertRaises(EOFError, input)
 991             del sys.stdout
 992             self.assertRaises(RuntimeError, input, 'prompt')
 993             del sys.stdin
 994             self.assertRaises(RuntimeError, input, 'prompt')
 995         finally:
 996             sys.stdin = savestdin
 997             sys.stdout = savestdout
 998             fp.close()
 999             unlink(TESTFN)
1000
1001     def test_reduce(self):
1002         self.assertEqual(reduce(lambda x, y: x+y, ['a', 'b', 'c'], ''), 'abc')
1003         self.assertEqual(
1004             reduce(lambda x, y: x+y, [['a', 'c'], [], ['d', 'w']], []),
1005             ['a','c','d','w']
1006         )
1007         self.assertEqual(reduce(lambda x, y: x*y, range(2,8), 1), 5040)
1008         self.assertEqual(
1009             reduce(lambda x, y: x*y, range(2,21), 1L),
1010             2432902008176640000L
1011         )
1012         self.assertEqual(reduce(lambda x, y: x+y, Squares(10)), 285)
1013         self.assertEqual(reduce(lambda x, y: x+y, Squares(10), 0), 285)
1014         self.assertEqual(reduce(lambda x, y: x+y, Squares(0), 0), 0)
1015         self.assertRaises(TypeError, reduce)
1016         self.assertRaises(TypeError, reduce, 42, 42)
1017         self.assertRaises(TypeError, reduce, 42, 42, 42)
1018         self.assertEqual(reduce(42, "1"), "1") # func is never called with one item
1019         self.assertEqual(reduce(42, "", "1"), "1") # func is never called with one item
1020         self.assertRaises(TypeError, reduce, 42, (42, 42))
1021
1022         class BadSeq:
1023             def __getitem__(self, index):
1024                 raise ValueError
1025         self.assertRaises(ValueError, reduce, 42, BadSeq())
1026
1027     def test_reload(self):
1028         import marshal
1029         reload(marshal)
1030         import string
1031         reload(string)
1032         ## import sys
1033         ## self.assertRaises(ImportError, reload, sys)
1034
1035     def test_repr(self):
1036         self.assertEqual(repr(''), '\'\'')
1037         self.assertEqual(repr(0), '0')
1038         self.assertEqual(repr(0L), '0L')
1039         self.assertEqual(repr(()), '()')
1040         self.assertEqual(repr([]), '[]')
1041         self.assertEqual(repr({}), '{}')
1042         a = []
1043         a.append(a)
1044         self.assertEqual(repr(a), '[[...]]')
1045         a = {}
1046         a[0] = a
1047         self.assertEqual(repr(a), '{0: {...}}')
1048
1049     def test_round(self):
1050         self.assertEqual(round(0.0), 0.0)
1051         self.assertEqual(round(1.0), 1.0)
1052         self.assertEqual(round(10.0), 10.0)
1053         self.assertEqual(round(1000000000.0), 1000000000.0)
1054         self.assertEqual(round(1e20), 1e20)
1055
1056         self.assertEqual(round(-1.0), -1.0)
1057         self.assertEqual(round(-10.0), -10.0)
1058         self.assertEqual(round(-1000000000.0), -1000000000.0)
1059         self.assertEqual(round(-1e20), -1e20)
1060
1061         self.assertEqual(round(0.1), 0.0)
1062         self.assertEqual(round(1.1), 1.0)
1063         self.assertEqual(round(10.1), 10.0)
1064         self.assertEqual(round(1000000000.1), 1000000000.0)
1065
1066         self.assertEqual(round(-1.1), -1.0)
1067         self.assertEqual(round(-10.1), -10.0)
1068         self.assertEqual(round(-1000000000.1), -1000000000.0)
1069
1070         self.assertEqual(round(0.9), 1.0)
1071         self.assertEqual(round(9.9), 10.0)
1072         self.assertEqual(round(999999999.9), 1000000000.0)
1073
1074         self.assertEqual(round(-0.9), -1.0)
1075         self.assertEqual(round(-9.9), -10.0)
1076         self.assertEqual(round(-999999999.9), -1000000000.0)
1077
1078         self.assertEqual(round(-8.0, -1), -10.0)
1079
1080         self.assertRaises(TypeError, round)
1081
1082     def test_setattr(self):
1083         setattr(sys, 'spam', 1)
1084         self.assertEqual(sys.spam, 1)
1085         self.assertRaises(TypeError, setattr, sys, 1, 'spam')
1086         self.assertRaises(TypeError, setattr)
1087
1088     def test_str(self):
1089         self.assertEqual(str(''), '')
1090         self.assertEqual(str(0), '0')
1091         self.assertEqual(str(0L), '0')
1092         self.assertEqual(str(()), '()')
1093         self.assertEqual(str([]), '[]')
1094         self.assertEqual(str({}), '{}')
1095         a = []
1096         a.append(a)
1097         self.assertEqual(str(a), '[[...]]')
1098         a = {}
1099         a[0] = a
1100         self.assertEqual(str(a), '{0: {...}}')
1101
1102     def test_sum(self):
1103         self.assertEqual(sum([]), 0)
1104         self.assertEqual(sum(range(2,8)), 27)
1105         self.assertEqual(sum(iter(range(2,8))), 27)
1106         self.assertEqual(sum(Squares(10)), 285)
1107         self.assertEqual(sum(iter(Squares(10))), 285)
1108         self.assertEqual(sum([[1], [2], [3]], []), [1, 2, 3])
1109
1110         self.assertRaises(TypeError, sum)
1111         self.assertRaises(TypeError, sum, 42)
1112         self.assertRaises(TypeError, sum, ['a', 'b', 'c'])
1113         self.assertRaises(TypeError, sum, ['a', 'b', 'c'], '')
1114         self.assertRaises(TypeError, sum, [[1], [2], [3]])
1115         self.assertRaises(TypeError, sum, [{2:3}])
1116         self.assertRaises(TypeError, sum, [{2:3}]*2, {2:3})
1117
1118         class BadSeq:
1119             def __getitem__(self, index):
1120                 raise ValueError
1121         self.assertRaises(ValueError, sum, BadSeq())
1122
1123     def test_tuple(self):
1124         self.assertEqual(tuple(()), ())
1125         t0_3 = (0, 1, 2, 3)
1126         t0_3_bis = tuple(t0_3)
1127         self.assert_(t0_3 is t0_3_bis)
1128         self.assertEqual(tuple([]), ())
1129         self.assertEqual(tuple([0, 1, 2, 3]), (0, 1, 2, 3))
1130         self.assertEqual(tuple(''), ())
1131         self.assertEqual(tuple('spam'), ('s', 'p', 'a', 'm'))
1132
1133     def test_type(self):
1134         self.assertEqual(type(''),  type('123'))
1135         self.assertNotEqual(type(''), type(()))
1136
1137     def test_unichr(self):
1138         if have_unicode:
1139             self.assertEqual(unichr(32), unicode(' '))
1140             self.assertEqual(unichr(65), unicode('A'))
1141             self.assertEqual(unichr(97), unicode('a'))
1142             self.assertEqual(
1143                 unichr(sys.maxunicode),
1144                 unicode('\\U%08x' % (sys.maxunicode), 'unicode-escape')
1145             )
1146             self.assertRaises(ValueError, unichr, sys.maxunicode+1)
1147             self.assertRaises(TypeError, unichr)
1148
1149     def get_vars_f0():
1150         return vars()
1151     # we don't want self in vars(), so use staticmethod
1152     get_vars_f0 = staticmethod(get_vars_f0)
1153
1154     def get_vars_f2():
1155         BuiltinTest.get_vars_f0()
1156         a = 1
1157         b = 2
1158         return vars()
1159     get_vars_f2 = staticmethod(get_vars_f2)
1160
1161     def test_vars(self):
1162         a = b = None
1163         a = vars().keys()
1164         b = dir()
1165         a.sort()
1166         b.sort()
1167         self.assertEqual(a, b)
1168         import sys
1169         a = vars(sys).keys()
1170         b = dir(sys)
1171         a.sort()
1172         b.sort()
1173         self.assertEqual(a, b)
1174         self.assertEqual(self.get_vars_f0(), {})
1175         self.assertEqual(self.get_vars_f2(), {'a': 1, 'b': 2})
1176         self.assertRaises(TypeError, vars, 42, 42)
1177         self.assertRaises(TypeError, vars, 42)
1178
1179     def test_zip(self):
1180         a = (1, 2, 3)
1181         b = (4, 5, 6)
1182         t = [(1, 4), (2, 5), (3, 6)]
1183         self.assertEqual(zip(a, b), t)
1184         b = [4, 5, 6]
1185         self.assertEqual(zip(a, b), t)
1186         b = (4, 5, 6, 7)
1187         self.assertEqual(zip(a, b), t)
1188         class I:
1189             def __getitem__(self, i):
1190                 if i < 0 or i > 2: raise IndexError
1191                 return i + 4
1192         self.assertEqual(zip(a, I()), t)
1193         self.assertRaises(TypeError, zip)
1194         self.assertRaises(TypeError, zip, None)
1195         class G:
1196             pass
1197         self.assertRaises(TypeError, zip, a, G())
1198
1199         # Make sure zip doesn't try to allocate a billion elements for the
1200         # result list when one of its arguments doesn't say how long it is.
1201         # A MemoryError is the most likely failure mode.
1202         class SequenceWithoutALength:
1203             def __getitem__(self, i):
1204                 if i == 5:
1205                     raise IndexError
1206                 else:
1207                     return i
1208         self.assertEqual(
1209             zip(SequenceWithoutALength(), xrange(2**30)),
1210             list(enumerate(range(5)))
1211         )
1212
1213         class BadSeq:
1214             def __getitem__(self, i):
1215                 if i == 5:
1216                     raise ValueError
1217                 else:
1218                     return i
1219         self.assertRaises(ValueError, zip, BadSeq(), BadSeq())
1220
1221 def test_main():
1222     suite = unittest.TestSuite()
1223     suite.addTest(unittest.makeSuite(BuiltinTest))
1224     test.test_support.run_suite(suite)
1225
1226 if __name__ == "__main__":
1227     test_main()