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