blob: b0014789f923a84dd4d356b05195dbcbd93dad38 [file] [log] [blame]
Walter Dörwald919497e2003-01-19 16:23:59 +00001# Python test set -- built-in functions
Guido van Rossum3bead091992-01-27 17:00:37 +00002
Walter Dörwald919497e2003-01-19 16:23:59 +00003import test.test_support, unittest
Thomas Wouters477c8d52006-05-27 19:21:47 +00004from test.test_support import fcmp, have_unicode, TESTFN, unlink, \
5 run_unittest, run_with_locale
Raymond Hettinger3b0c7c22004-12-03 08:30:39 +00006from operator import neg
Guido van Rossum3bead091992-01-27 17:00:37 +00007
Raymond Hettinger214b1c32004-07-02 06:41:07 +00008import sys, warnings, cStringIO, random, UserDict
Walter Dörwald919497e2003-01-19 16:23:59 +00009warnings.filterwarnings("ignore", "hex../oct.. of negative int",
10 FutureWarning, __name__)
Guido van Rossumefbbb1c2003-04-11 18:43:06 +000011warnings.filterwarnings("ignore", "integer argument expected",
12 DeprecationWarning, "unittest")
Guido van Rossum3bead091992-01-27 17:00:37 +000013
Raymond Hettinger3b0c7c22004-12-03 08:30:39 +000014# count the number of test runs.
15# used to skip running test_execfile() multiple times
16numruns = 0
17
Walter Dörwald919497e2003-01-19 16:23:59 +000018class Squares:
Guido van Rossum3bead091992-01-27 17:00:37 +000019
Walter Dörwald919497e2003-01-19 16:23:59 +000020 def __init__(self, max):
21 self.max = max
22 self.sofar = []
23
24 def __len__(self): return len(self.sofar)
25
26 def __getitem__(self, i):
27 if not 0 <= i < self.max: raise IndexError
28 n = len(self.sofar)
29 while n <= i:
30 self.sofar.append(n*n)
31 n += 1
32 return self.sofar[i]
33
34class StrSquares:
35
36 def __init__(self, max):
37 self.max = max
38 self.sofar = []
39
40 def __len__(self):
41 return len(self.sofar)
42
43 def __getitem__(self, i):
44 if not 0 <= i < self.max:
45 raise IndexError
46 n = len(self.sofar)
47 while n <= i:
48 self.sofar.append(str(n*n))
49 n += 1
50 return self.sofar[i]
51
52class BitBucket:
53 def write(self, line):
54 pass
55
56L = [
57 ('0', 0),
58 ('1', 1),
59 ('9', 9),
60 ('10', 10),
61 ('99', 99),
62 ('100', 100),
63 ('314', 314),
64 (' 314', 314),
65 ('314 ', 314),
66 (' \t\t 314 \t\t ', 314),
Walter Dörwald70a6b492004-02-12 17:35:32 +000067 (repr(sys.maxint), sys.maxint),
Walter Dörwald919497e2003-01-19 16:23:59 +000068 (' 1x', ValueError),
69 (' 1 ', 1),
70 (' 1\02 ', ValueError),
71 ('', ValueError),
72 (' ', ValueError),
73 (' \t\t ', ValueError)
74]
75if have_unicode:
76 L += [
77 (unicode('0'), 0),
78 (unicode('1'), 1),
79 (unicode('9'), 9),
80 (unicode('10'), 10),
81 (unicode('99'), 99),
82 (unicode('100'), 100),
83 (unicode('314'), 314),
84 (unicode(' 314'), 314),
85 (unicode('\u0663\u0661\u0664 ','raw-unicode-escape'), 314),
86 (unicode(' \t\t 314 \t\t '), 314),
87 (unicode(' 1x'), ValueError),
88 (unicode(' 1 '), 1),
89 (unicode(' 1\02 '), ValueError),
90 (unicode(''), ValueError),
91 (unicode(' '), ValueError),
92 (unicode(' \t\t '), ValueError),
93 (unichr(0x200), ValueError),
94]
95
Raymond Hettinger96229b12005-03-11 06:49:40 +000096class TestFailingBool:
Jack Diederich4dafcc42006-11-28 19:15:13 +000097 def __bool__(self):
Raymond Hettinger96229b12005-03-11 06:49:40 +000098 raise RuntimeError
99
100class TestFailingIter:
101 def __iter__(self):
102 raise RuntimeError
103
Walter Dörwald919497e2003-01-19 16:23:59 +0000104class BuiltinTest(unittest.TestCase):
105
106 def test_import(self):
107 __import__('sys')
108 __import__('time')
109 __import__('string')
110 self.assertRaises(ImportError, __import__, 'spamspam')
111 self.assertRaises(TypeError, __import__, 1, 2, 3, 4)
Thomas Wouters49fd7fa2006-04-21 10:40:58 +0000112 self.assertRaises(ValueError, __import__, '')
Walter Dörwald919497e2003-01-19 16:23:59 +0000113
114 def test_abs(self):
115 # int
116 self.assertEqual(abs(0), 0)
117 self.assertEqual(abs(1234), 1234)
118 self.assertEqual(abs(-1234), 1234)
Thomas Wouters89f507f2006-12-13 04:49:30 +0000119 self.assertTrue(abs(-sys.maxint-1) > 0)
Walter Dörwald919497e2003-01-19 16:23:59 +0000120 # float
121 self.assertEqual(abs(0.0), 0.0)
122 self.assertEqual(abs(3.14), 3.14)
123 self.assertEqual(abs(-3.14), 3.14)
124 # long
125 self.assertEqual(abs(0L), 0L)
126 self.assertEqual(abs(1234L), 1234L)
127 self.assertEqual(abs(-1234L), 1234L)
128 # str
129 self.assertRaises(TypeError, abs, 'a')
130
Raymond Hettinger96229b12005-03-11 06:49:40 +0000131 def test_all(self):
132 self.assertEqual(all([2, 4, 6]), True)
133 self.assertEqual(all([2, None, 6]), False)
134 self.assertRaises(RuntimeError, all, [2, TestFailingBool(), 6])
135 self.assertRaises(RuntimeError, all, TestFailingIter())
136 self.assertRaises(TypeError, all, 10) # Non-iterable
137 self.assertRaises(TypeError, all) # No args
138 self.assertRaises(TypeError, all, [2, 4, 6], []) # Too many args
139 self.assertEqual(all([]), True) # Empty iterator
140 S = [50, 60]
141 self.assertEqual(all(x > 42 for x in S), True)
142 S = [50, 40, 60]
143 self.assertEqual(all(x > 42 for x in S), False)
144
145 def test_any(self):
146 self.assertEqual(any([None, None, None]), False)
147 self.assertEqual(any([None, 4, None]), True)
148 self.assertRaises(RuntimeError, any, [None, TestFailingBool(), 6])
149 self.assertRaises(RuntimeError, all, TestFailingIter())
150 self.assertRaises(TypeError, any, 10) # Non-iterable
151 self.assertRaises(TypeError, any) # No args
152 self.assertRaises(TypeError, any, [2, 4, 6], []) # Too many args
153 self.assertEqual(any([]), False) # Empty iterator
154 S = [40, 60, 30]
155 self.assertEqual(any(x > 42 for x in S), True)
156 S = [10, 20, 30]
157 self.assertEqual(any(x > 42 for x in S), False)
158
Thomas Wouters89f507f2006-12-13 04:49:30 +0000159 def test_neg(self):
160 x = -sys.maxint-1
161 self.assert_(isinstance(x, int))
162 self.assertEqual(-x, sys.maxint+1)
163
Walter Dörwald919497e2003-01-19 16:23:59 +0000164 def test_callable(self):
165 self.assert_(callable(len))
166 def f(): pass
167 self.assert_(callable(f))
168 class C:
169 def meth(self): pass
170 self.assert_(callable(C))
171 x = C()
172 self.assert_(callable(x.meth))
173 self.assert_(not callable(x))
174 class D(C):
175 def __call__(self): pass
176 y = D()
177 self.assert_(callable(y))
178 y()
179
180 def test_chr(self):
181 self.assertEqual(chr(32), ' ')
182 self.assertEqual(chr(65), 'A')
183 self.assertEqual(chr(97), 'a')
184 self.assertEqual(chr(0xff), '\xff')
185 self.assertRaises(ValueError, chr, 256)
186 self.assertRaises(TypeError, chr)
187
Guido van Rossum47b9ff62006-08-24 00:41:19 +0000188 def XXX_test_cmp(self):
189 # cmp() is no longer supported
Walter Dörwald919497e2003-01-19 16:23:59 +0000190 self.assertEqual(cmp(-1, 1), -1)
191 self.assertEqual(cmp(1, -1), 1)
192 self.assertEqual(cmp(1, 1), 0)
Armin Rigo2b3eb402003-10-28 12:05:48 +0000193 # verify that circular objects are not handled
Walter Dörwald919497e2003-01-19 16:23:59 +0000194 a = []; a.append(a)
195 b = []; b.append(b)
196 from UserList import UserList
197 c = UserList(); c.append(c)
Armin Rigo2b3eb402003-10-28 12:05:48 +0000198 self.assertRaises(RuntimeError, cmp, a, b)
199 self.assertRaises(RuntimeError, cmp, b, c)
200 self.assertRaises(RuntimeError, cmp, c, a)
201 self.assertRaises(RuntimeError, cmp, a, c)
202 # okay, now break the cycles
Walter Dörwald919497e2003-01-19 16:23:59 +0000203 a.pop(); b.pop(); c.pop()
204 self.assertRaises(TypeError, cmp)
205
Walter Dörwald919497e2003-01-19 16:23:59 +0000206 def test_compile(self):
207 compile('print 1\n', '', 'exec')
Just van Rossumf032f862003-02-09 20:38:48 +0000208 bom = '\xef\xbb\xbf'
209 compile(bom + 'print 1\n', '', 'exec')
Walter Dörwald919497e2003-01-19 16:23:59 +0000210 self.assertRaises(TypeError, compile)
211 self.assertRaises(ValueError, compile, 'print 42\n', '<string>', 'badmode')
212 self.assertRaises(ValueError, compile, 'print 42\n', '<string>', 'single', 0xff)
Neal Norwitzfcf44352005-11-27 20:37:43 +0000213 self.assertRaises(TypeError, compile, chr(0), 'f', 'exec')
Just van Rossum3aaf42c2003-02-10 08:21:10 +0000214 if have_unicode:
215 compile(unicode('print u"\xc3\xa5"\n', 'utf8'), '', 'exec')
Neal Norwitzfcf44352005-11-27 20:37:43 +0000216 self.assertRaises(TypeError, compile, unichr(0), 'f', 'exec')
217 self.assertRaises(ValueError, compile, unicode('a = 1'), 'f', 'bad')
Walter Dörwald919497e2003-01-19 16:23:59 +0000218
Walter Dörwald919497e2003-01-19 16:23:59 +0000219 def test_delattr(self):
220 import sys
221 sys.spam = 1
222 delattr(sys, 'spam')
223 self.assertRaises(TypeError, delattr)
224
225 def test_dir(self):
226 x = 1
227 self.assert_('x' in dir())
228 import sys
229 self.assert_('modules' in dir(sys))
230 self.assertRaises(TypeError, dir, 42, 42)
231
232 def test_divmod(self):
233 self.assertEqual(divmod(12, 7), (1, 5))
234 self.assertEqual(divmod(-12, 7), (-2, 2))
235 self.assertEqual(divmod(12, -7), (-2, -2))
236 self.assertEqual(divmod(-12, -7), (1, -5))
237
238 self.assertEqual(divmod(12L, 7L), (1L, 5L))
239 self.assertEqual(divmod(-12L, 7L), (-2L, 2L))
240 self.assertEqual(divmod(12L, -7L), (-2L, -2L))
241 self.assertEqual(divmod(-12L, -7L), (1L, -5L))
242
243 self.assertEqual(divmod(12, 7L), (1, 5L))
244 self.assertEqual(divmod(-12, 7L), (-2, 2L))
245 self.assertEqual(divmod(12L, -7), (-2L, -2))
246 self.assertEqual(divmod(-12L, -7), (1L, -5))
247
Raymond Hettinger5ea7e312004-09-30 07:47:20 +0000248 self.assertEqual(divmod(-sys.maxint-1, -1),
249 (sys.maxint+1, 0))
250
Walter Dörwald919497e2003-01-19 16:23:59 +0000251 self.assert_(not fcmp(divmod(3.25, 1.0), (3.0, 0.25)))
252 self.assert_(not fcmp(divmod(-3.25, 1.0), (-4.0, 0.75)))
253 self.assert_(not fcmp(divmod(3.25, -1.0), (-4.0, -0.75)))
254 self.assert_(not fcmp(divmod(-3.25, -1.0), (3.0, -0.25)))
255
256 self.assertRaises(TypeError, divmod)
257
258 def test_eval(self):
259 self.assertEqual(eval('1+1'), 2)
260 self.assertEqual(eval(' 1+1\n'), 2)
261 globals = {'a': 1, 'b': 2}
262 locals = {'b': 200, 'c': 300}
263 self.assertEqual(eval('a', globals) , 1)
264 self.assertEqual(eval('a', globals, locals), 1)
265 self.assertEqual(eval('b', globals, locals), 200)
266 self.assertEqual(eval('c', globals, locals), 300)
267 if have_unicode:
268 self.assertEqual(eval(unicode('1+1')), 2)
269 self.assertEqual(eval(unicode(' 1+1\n')), 2)
270 globals = {'a': 1, 'b': 2}
271 locals = {'b': 200, 'c': 300}
272 if have_unicode:
273 self.assertEqual(eval(unicode('a'), globals), 1)
274 self.assertEqual(eval(unicode('a'), globals, locals), 1)
275 self.assertEqual(eval(unicode('b'), globals, locals), 200)
276 self.assertEqual(eval(unicode('c'), globals, locals), 300)
Just van Rossumf032f862003-02-09 20:38:48 +0000277 bom = '\xef\xbb\xbf'
278 self.assertEqual(eval(bom + 'a', globals, locals), 1)
Just van Rossum3aaf42c2003-02-10 08:21:10 +0000279 self.assertEqual(eval(unicode('u"\xc3\xa5"', 'utf8'), globals),
280 unicode('\xc3\xa5', 'utf8'))
Walter Dörwald919497e2003-01-19 16:23:59 +0000281 self.assertRaises(TypeError, eval)
282 self.assertRaises(TypeError, eval, ())
283
Raymond Hettinger214b1c32004-07-02 06:41:07 +0000284 def test_general_eval(self):
285 # Tests that general mappings can be used for the locals argument
286
287 class M:
288 "Test mapping interface versus possible calls from eval()."
289 def __getitem__(self, key):
290 if key == 'a':
291 return 12
292 raise KeyError
293 def keys(self):
294 return list('xyz')
295
296 m = M()
297 g = globals()
298 self.assertEqual(eval('a', g, m), 12)
299 self.assertRaises(NameError, eval, 'b', g, m)
300 self.assertEqual(eval('dir()', g, m), list('xyz'))
301 self.assertEqual(eval('globals()', g, m), g)
302 self.assertEqual(eval('locals()', g, m), m)
Raymond Hettinger513ffe82004-07-06 13:44:41 +0000303 self.assertRaises(TypeError, eval, 'a', m)
Raymond Hettinger66bd2332004-08-02 08:30:07 +0000304 class A:
305 "Non-mapping"
306 pass
307 m = A()
308 self.assertRaises(TypeError, eval, 'a', g, m)
Raymond Hettinger214b1c32004-07-02 06:41:07 +0000309
310 # Verify that dict subclasses work as well
311 class D(dict):
312 def __getitem__(self, key):
313 if key == 'a':
314 return 12
315 return dict.__getitem__(self, key)
316 def keys(self):
317 return list('xyz')
318
319 d = D()
320 self.assertEqual(eval('a', g, d), 12)
321 self.assertRaises(NameError, eval, 'b', g, d)
322 self.assertEqual(eval('dir()', g, d), list('xyz'))
323 self.assertEqual(eval('globals()', g, d), g)
324 self.assertEqual(eval('locals()', g, d), d)
325
326 # Verify locals stores (used by list comps)
327 eval('[locals() for i in (2,3)]', g, d)
328 eval('[locals() for i in (2,3)]', g, UserDict.UserDict())
329
330 class SpreadSheet:
331 "Sample application showing nested, calculated lookups."
332 _cells = {}
333 def __setitem__(self, key, formula):
334 self._cells[key] = formula
Thomas Wouters73e5a5b2006-06-08 15:35:45 +0000335 def __getitem__(self, key):
Raymond Hettinger214b1c32004-07-02 06:41:07 +0000336 return eval(self._cells[key], globals(), self)
337
338 ss = SpreadSheet()
339 ss['a1'] = '5'
340 ss['a2'] = 'a1*6'
341 ss['a3'] = 'a2*7'
342 self.assertEqual(ss['a3'], 210)
343
Raymond Hettinger2a7dede2004-08-07 04:55:30 +0000344 # Verify that dir() catches a non-list returned by eval
345 # SF bug #1004669
346 class C:
347 def __getitem__(self, item):
348 raise KeyError(item)
349 def keys(self):
350 return 'a'
351 self.assertRaises(TypeError, eval, 'dir()', globals(), C())
352
Walter Dörwald919497e2003-01-19 16:23:59 +0000353 # Done outside of the method test_z to get the correct scope
354 z = 0
355 f = open(TESTFN, 'w')
356 f.write('z = z+1\n')
357 f.write('z = z*2\n')
358 f.close()
359 execfile(TESTFN)
360
361 def test_execfile(self):
Raymond Hettinger3b0c7c22004-12-03 08:30:39 +0000362 global numruns
363 if numruns:
364 return
365 numruns += 1
Tim Peters7f061872004-12-07 21:17:46 +0000366
Walter Dörwald919497e2003-01-19 16:23:59 +0000367 globals = {'a': 1, 'b': 2}
368 locals = {'b': 200, 'c': 300}
369
370 self.assertEqual(self.__class__.z, 2)
371 globals['z'] = 0
372 execfile(TESTFN, globals)
373 self.assertEqual(globals['z'], 2)
374 locals['z'] = 0
375 execfile(TESTFN, globals, locals)
376 self.assertEqual(locals['z'], 2)
Raymond Hettinger66bd2332004-08-02 08:30:07 +0000377
378 class M:
379 "Test mapping interface versus possible calls from execfile()."
380 def __init__(self):
381 self.z = 10
382 def __getitem__(self, key):
383 if key == 'z':
384 return self.z
385 raise KeyError
386 def __setitem__(self, key, value):
387 if key == 'z':
388 self.z = value
389 return
390 raise KeyError
391
392 locals = M()
393 locals['z'] = 0
394 execfile(TESTFN, globals, locals)
395 self.assertEqual(locals['z'], 2)
396
Walter Dörwald919497e2003-01-19 16:23:59 +0000397 unlink(TESTFN)
398 self.assertRaises(TypeError, execfile)
Neal Norwitzfcf44352005-11-27 20:37:43 +0000399 self.assertRaises(TypeError, execfile, TESTFN, {}, ())
Walter Dörwald919497e2003-01-19 16:23:59 +0000400 import os
401 self.assertRaises(IOError, execfile, os.curdir)
402 self.assertRaises(IOError, execfile, "I_dont_exist")
403
Georg Brandl7cae87c2006-09-06 06:51:57 +0000404 def test_exec(self):
405 g = {}
406 exec('z = 1', g)
407 if '__builtins__' in g:
408 del g['__builtins__']
409 self.assertEqual(g, {'z': 1})
410
411 exec(u'z = 1+1', g)
412 if '__builtins__' in g:
413 del g['__builtins__']
414 self.assertEqual(g, {'z': 2})
415 g = {}
416 l = {}
417
418 import warnings
419 warnings.filterwarnings("ignore", "global statement", module="<string>")
420 exec('global a; a = 1; b = 2', g, l)
421 if '__builtins__' in g:
422 del g['__builtins__']
423 if '__builtins__' in l:
424 del l['__builtins__']
425 self.assertEqual((g, l), ({'a': 1}, {'b': 2}))
426
Walter Dörwald919497e2003-01-19 16:23:59 +0000427 def test_filter(self):
428 self.assertEqual(filter(lambda c: 'a' <= c <= 'z', 'Hello World'), 'elloorld')
429 self.assertEqual(filter(None, [1, 'hello', [], [3], '', None, 9, 0]), [1, 'hello', [3], 9])
430 self.assertEqual(filter(lambda x: x > 0, [1, -3, 9, 0, 2]), [1, 9, 2])
431 self.assertEqual(filter(None, Squares(10)), [1, 4, 9, 16, 25, 36, 49, 64, 81])
432 self.assertEqual(filter(lambda x: x%2, Squares(10)), [1, 9, 25, 49, 81])
433 def identity(item):
434 return 1
435 filter(identity, Squares(5))
436 self.assertRaises(TypeError, filter)
437 class BadSeq(object):
Tim Petersf2715e02003-02-19 02:35:07 +0000438 def __getitem__(self, index):
439 if index<4:
440 return 42
441 raise ValueError
Walter Dörwald919497e2003-01-19 16:23:59 +0000442 self.assertRaises(ValueError, filter, lambda x: x, BadSeq())
443 def badfunc():
444 pass
445 self.assertRaises(TypeError, filter, badfunc, range(5))
446
Walter Dörwaldbf517072003-01-27 15:57:14 +0000447 # test bltinmodule.c::filtertuple()
Walter Dörwald919497e2003-01-19 16:23:59 +0000448 self.assertEqual(filter(None, (1, 2)), (1, 2))
449 self.assertEqual(filter(lambda x: x>=3, (1, 2, 3, 4)), (3, 4))
450 self.assertRaises(TypeError, filter, 42, (1, 2))
451
Walter Dörwaldbf517072003-01-27 15:57:14 +0000452 # test bltinmodule.c::filterstring()
Walter Dörwald919497e2003-01-19 16:23:59 +0000453 self.assertEqual(filter(None, "12"), "12")
454 self.assertEqual(filter(lambda x: x>="3", "1234"), "34")
455 self.assertRaises(TypeError, filter, 42, "12")
456 class badstr(str):
457 def __getitem__(self, index):
458 raise ValueError
459 self.assertRaises(ValueError, filter, lambda x: x >="3", badstr("1234"))
Walter Dörwaldbf517072003-01-27 15:57:14 +0000460
Walter Dörwald903f1e02003-02-04 16:28:00 +0000461 class badstr2(str):
462 def __getitem__(self, index):
463 return 42
464 self.assertRaises(TypeError, filter, lambda x: x >=42, badstr2("1234"))
465
466 class weirdstr(str):
467 def __getitem__(self, index):
468 return weirdstr(2*str.__getitem__(self, index))
469 self.assertEqual(filter(lambda x: x>="33", weirdstr("1234")), "3344")
470
Walter Dörwald5e61e242003-02-04 17:04:01 +0000471 class shiftstr(str):
472 def __getitem__(self, index):
473 return chr(ord(str.__getitem__(self, index))+1)
474 self.assertEqual(filter(lambda x: x>="3", shiftstr("1234")), "345")
475
Martin v. Löwis8afd7572003-01-25 22:46:11 +0000476 if have_unicode:
Walter Dörwaldbf517072003-01-27 15:57:14 +0000477 # test bltinmodule.c::filterunicode()
Martin v. Löwis8afd7572003-01-25 22:46:11 +0000478 self.assertEqual(filter(None, unicode("12")), unicode("12"))
479 self.assertEqual(filter(lambda x: x>="3", unicode("1234")), unicode("34"))
480 self.assertRaises(TypeError, filter, 42, unicode("12"))
481 self.assertRaises(ValueError, filter, lambda x: x >="3", badstr(unicode("1234")))
Walter Dörwald919497e2003-01-19 16:23:59 +0000482
Walter Dörwald903f1e02003-02-04 16:28:00 +0000483 class badunicode(unicode):
484 def __getitem__(self, index):
485 return 42
486 self.assertRaises(TypeError, filter, lambda x: x >=42, badunicode("1234"))
487
488 class weirdunicode(unicode):
489 def __getitem__(self, index):
490 return weirdunicode(2*unicode.__getitem__(self, index))
491 self.assertEqual(
492 filter(lambda x: x>=unicode("33"), weirdunicode("1234")), unicode("3344"))
493
Walter Dörwald5e61e242003-02-04 17:04:01 +0000494 class shiftunicode(unicode):
495 def __getitem__(self, index):
496 return unichr(ord(unicode.__getitem__(self, index))+1)
497 self.assertEqual(
498 filter(lambda x: x>=unicode("3"), shiftunicode("1234")),
499 unicode("345")
500 )
501
Walter Dörwaldc3da83f2003-02-04 20:24:45 +0000502 def test_filter_subclasses(self):
Walter Dörwaldc8cb5d92003-08-15 17:52:39 +0000503 # test that filter() never returns tuple, str or unicode subclasses
504 # and that the result always goes through __getitem__
505 funcs = (None, bool, lambda x: True)
Walter Dörwaldc3da83f2003-02-04 20:24:45 +0000506 class tuple2(tuple):
Walter Dörwald1918f772003-02-10 13:19:13 +0000507 def __getitem__(self, index):
508 return 2*tuple.__getitem__(self, index)
Walter Dörwaldc3da83f2003-02-04 20:24:45 +0000509 class str2(str):
Walter Dörwald1918f772003-02-10 13:19:13 +0000510 def __getitem__(self, index):
511 return 2*str.__getitem__(self, index)
Walter Dörwaldc3da83f2003-02-04 20:24:45 +0000512 inputs = {
Walter Dörwald8dd19322003-02-10 17:36:40 +0000513 tuple2: {(): (), (1, 2, 3): (2, 4, 6)},
Walter Dörwald1918f772003-02-10 13:19:13 +0000514 str2: {"": "", "123": "112233"}
Walter Dörwaldc3da83f2003-02-04 20:24:45 +0000515 }
516 if have_unicode:
517 class unicode2(unicode):
Walter Dörwald1918f772003-02-10 13:19:13 +0000518 def __getitem__(self, index):
519 return 2*unicode.__getitem__(self, index)
520 inputs[unicode2] = {
521 unicode(): unicode(),
522 unicode("123"): unicode("112233")
523 }
Walter Dörwaldc3da83f2003-02-04 20:24:45 +0000524
Walter Dörwald1918f772003-02-10 13:19:13 +0000525 for (cls, inps) in inputs.iteritems():
526 for (inp, exp) in inps.iteritems():
Tim Petersf2715e02003-02-19 02:35:07 +0000527 # make sure the output goes through __getitem__
528 # even if func is None
529 self.assertEqual(
530 filter(funcs[0], cls(inp)),
531 filter(funcs[1], cls(inp))
532 )
533 for func in funcs:
Walter Dörwald1918f772003-02-10 13:19:13 +0000534 outp = filter(func, cls(inp))
535 self.assertEqual(outp, exp)
536 self.assert_(not isinstance(outp, cls))
Walter Dörwaldc3da83f2003-02-04 20:24:45 +0000537
Walter Dörwald919497e2003-01-19 16:23:59 +0000538 def test_float(self):
539 self.assertEqual(float(3.14), 3.14)
540 self.assertEqual(float(314), 314.0)
541 self.assertEqual(float(314L), 314.0)
542 self.assertEqual(float(" 3.14 "), 3.14)
Neal Norwitze7214a12005-12-18 05:03:17 +0000543 self.assertRaises(ValueError, float, " 0x3.1 ")
544 self.assertRaises(ValueError, float, " -0x3.p-1 ")
Walter Dörwald919497e2003-01-19 16:23:59 +0000545 if have_unicode:
546 self.assertEqual(float(unicode(" 3.14 ")), 3.14)
547 self.assertEqual(float(unicode(" \u0663.\u0661\u0664 ",'raw-unicode-escape')), 3.14)
Walter Dörwaldede187f2005-11-29 15:45:14 +0000548 # Implementation limitation in PyFloat_FromString()
549 self.assertRaises(ValueError, float, unicode("1"*10000))
Walter Dörwald919497e2003-01-19 16:23:59 +0000550
Thomas Wouters477c8d52006-05-27 19:21:47 +0000551 @run_with_locale('LC_NUMERIC', 'fr_FR', 'de_DE')
Neal Norwitz5898fa22005-11-22 05:17:40 +0000552 def test_float_with_comma(self):
553 # set locale to something that doesn't use '.' for the decimal point
Thomas Wouters0e3f5912006-08-11 14:57:12 +0000554 # float must not accept the locale specific decimal point but
555 # it still has to accept the normal python syntac
Thomas Wouters477c8d52006-05-27 19:21:47 +0000556 import locale
557 if not locale.localeconv()['decimal_point'] == ',':
Neal Norwitz5898fa22005-11-22 05:17:40 +0000558 return
559
Thomas Wouters0e3f5912006-08-11 14:57:12 +0000560 self.assertEqual(float(" 3.14 "), 3.14)
561 self.assertEqual(float("+3.14 "), 3.14)
562 self.assertEqual(float("-3.14 "), -3.14)
563 self.assertEqual(float(".14 "), .14)
564 self.assertEqual(float("3. "), 3.0)
565 self.assertEqual(float("3.e3 "), 3000.0)
566 self.assertEqual(float("3.2e3 "), 3200.0)
567 self.assertEqual(float("2.5e-1 "), 0.25)
568 self.assertEqual(float("5e-1"), 0.5)
569 self.assertRaises(ValueError, float, " 3,14 ")
570 self.assertRaises(ValueError, float, " +3,14 ")
571 self.assertRaises(ValueError, float, " -3,14 ")
Thomas Wouters477c8d52006-05-27 19:21:47 +0000572 self.assertRaises(ValueError, float, " 0x3.1 ")
573 self.assertRaises(ValueError, float, " -0x3.p-1 ")
574 self.assertEqual(float(" 25.e-1 "), 2.5)
575 self.assertEqual(fcmp(float(" .25e-1 "), .025), 0)
Neal Norwitz5898fa22005-11-22 05:17:40 +0000576
Brett Cannonc3647ac2005-04-26 03:45:26 +0000577 def test_floatconversion(self):
578 # Make sure that calls to __float__() work properly
579 class Foo0:
580 def __float__(self):
581 return 42.
582
583 class Foo1(object):
584 def __float__(self):
585 return 42.
586
587 class Foo2(float):
588 def __float__(self):
589 return 42.
590
591 class Foo3(float):
592 def __new__(cls, value=0.):
593 return float.__new__(cls, 2*value)
594
595 def __float__(self):
596 return self
597
598 class Foo4(float):
599 def __float__(self):
600 return 42
601
602 self.assertAlmostEqual(float(Foo0()), 42.)
603 self.assertAlmostEqual(float(Foo1()), 42.)
604 self.assertAlmostEqual(float(Foo2()), 42.)
605 self.assertAlmostEqual(float(Foo3(21)), 42.)
606 self.assertRaises(TypeError, float, Foo4(42))
607
Walter Dörwald919497e2003-01-19 16:23:59 +0000608 def test_getattr(self):
609 import sys
610 self.assert_(getattr(sys, 'stdout') is sys.stdout)
611 self.assertRaises(TypeError, getattr, sys, 1)
612 self.assertRaises(TypeError, getattr, sys, 1, "foo")
613 self.assertRaises(TypeError, getattr)
Walter Dörwald4e41a4b2005-08-03 17:09:04 +0000614 if have_unicode:
615 self.assertRaises(UnicodeError, getattr, sys, unichr(sys.maxunicode))
Walter Dörwald919497e2003-01-19 16:23:59 +0000616
617 def test_hasattr(self):
618 import sys
619 self.assert_(hasattr(sys, 'stdout'))
620 self.assertRaises(TypeError, hasattr, sys, 1)
621 self.assertRaises(TypeError, hasattr)
Walter Dörwald4e41a4b2005-08-03 17:09:04 +0000622 if have_unicode:
623 self.assertRaises(UnicodeError, hasattr, sys, unichr(sys.maxunicode))
Walter Dörwald919497e2003-01-19 16:23:59 +0000624
625 def test_hash(self):
626 hash(None)
627 self.assertEqual(hash(1), hash(1L))
628 self.assertEqual(hash(1), hash(1.0))
629 hash('spam')
630 if have_unicode:
631 self.assertEqual(hash('spam'), hash(unicode('spam')))
632 hash((0,1,2,3))
633 def f(): pass
634 self.assertRaises(TypeError, hash, [])
635 self.assertRaises(TypeError, hash, {})
Thomas Wouters0e3f5912006-08-11 14:57:12 +0000636 # Bug 1536021: Allow hash to return long objects
637 class X:
638 def __hash__(self):
639 return 2**100
640 self.assertEquals(type(hash(X())), int)
641 class Y(object):
642 def __hash__(self):
643 return 2**100
644 self.assertEquals(type(hash(Y())), int)
645 class Z(long):
646 def __hash__(self):
647 return self
648 self.assertEquals(hash(Z(42)), hash(42L))
Walter Dörwald919497e2003-01-19 16:23:59 +0000649
650 def test_hex(self):
651 self.assertEqual(hex(16), '0x10')
Guido van Rossume2b70bc2006-08-18 22:13:04 +0000652 self.assertEqual(hex(16L), '0x10')
Guido van Rossum6c9e1302003-11-29 23:52:13 +0000653 self.assertEqual(hex(-16), '-0x10')
Guido van Rossume2b70bc2006-08-18 22:13:04 +0000654 self.assertEqual(hex(-16L), '-0x10')
Walter Dörwald919497e2003-01-19 16:23:59 +0000655 self.assertRaises(TypeError, hex, {})
656
657 def test_id(self):
658 id(None)
659 id(1)
660 id(1L)
661 id(1.0)
662 id('spam')
663 id((0,1,2,3))
664 id([0,1,2,3])
665 id({'spam': 1, 'eggs': 2, 'ham': 3})
666
Walter Dörwald919497e2003-01-19 16:23:59 +0000667 def test_int(self):
668 self.assertEqual(int(314), 314)
669 self.assertEqual(int(3.14), 3)
670 self.assertEqual(int(314L), 314)
671 # Check that conversion from float truncates towards zero
672 self.assertEqual(int(-3.14), -3)
673 self.assertEqual(int(3.9), 3)
674 self.assertEqual(int(-3.9), -3)
675 self.assertEqual(int(3.5), 3)
676 self.assertEqual(int(-3.5), -3)
677 # Different base:
678 self.assertEqual(int("10",16), 16L)
679 if have_unicode:
680 self.assertEqual(int(unicode("10"),16), 16L)
681 # Test conversion from strings and various anomalies
682 for s, v in L:
683 for sign in "", "+", "-":
684 for prefix in "", " ", "\t", " \t\t ":
685 ss = prefix + sign + s
686 vv = v
687 if sign == "-" and v is not ValueError:
688 vv = -v
689 try:
690 self.assertEqual(int(ss), vv)
691 except v:
692 pass
693
Walter Dörwald70a6b492004-02-12 17:35:32 +0000694 s = repr(-1-sys.maxint)
Thomas Wouters89f507f2006-12-13 04:49:30 +0000695 x = int(s)
696 self.assertEqual(x+1, -sys.maxint)
697 self.assert_(isinstance(x, int))
Walter Dörwald919497e2003-01-19 16:23:59 +0000698 # should return long
Thomas Wouters89f507f2006-12-13 04:49:30 +0000699 self.assertEqual(int(s[1:]), sys.maxint+1)
Walter Dörwald919497e2003-01-19 16:23:59 +0000700
701 # should return long
702 x = int(1e100)
703 self.assert_(isinstance(x, long))
704 x = int(-1e100)
705 self.assert_(isinstance(x, long))
706
707
708 # SF bug 434186: 0x80000000/2 != 0x80000000>>1.
709 # Worked by accident in Windows release build, but failed in debug build.
710 # Failed in all Linux builds.
711 x = -1-sys.maxint
712 self.assertEqual(x >> 1, x//2)
713
714 self.assertRaises(ValueError, int, '123\0')
715 self.assertRaises(ValueError, int, '53', 40)
716
Thomas Wouters89f507f2006-12-13 04:49:30 +0000717 # SF bug 1545497: embedded NULs were not detected with
718 # explicit base
719 self.assertRaises(ValueError, int, '123\0', 10)
720 self.assertRaises(ValueError, int, '123\x00 245', 20)
721
Walter Dörwald919497e2003-01-19 16:23:59 +0000722 x = int('1' * 600)
723 self.assert_(isinstance(x, long))
724
725 if have_unicode:
726 x = int(unichr(0x661) * 600)
727 self.assert_(isinstance(x, long))
728
729 self.assertRaises(TypeError, int, 1, 12)
730
731 self.assertEqual(int('0123', 0), 83)
Neal Norwitz5898fa22005-11-22 05:17:40 +0000732 self.assertEqual(int('0x123', 16), 291)
Walter Dörwald919497e2003-01-19 16:23:59 +0000733
Thomas Wouters477c8d52006-05-27 19:21:47 +0000734 # SF bug 1334662: int(string, base) wrong answers
735 # Various representations of 2**32 evaluated to 0
736 # rather than 2**32 in previous versions
737
738 self.assertEqual(int('100000000000000000000000000000000', 2), 4294967296L)
739 self.assertEqual(int('102002022201221111211', 3), 4294967296L)
740 self.assertEqual(int('10000000000000000', 4), 4294967296L)
741 self.assertEqual(int('32244002423141', 5), 4294967296L)
742 self.assertEqual(int('1550104015504', 6), 4294967296L)
743 self.assertEqual(int('211301422354', 7), 4294967296L)
744 self.assertEqual(int('40000000000', 8), 4294967296L)
745 self.assertEqual(int('12068657454', 9), 4294967296L)
746 self.assertEqual(int('4294967296', 10), 4294967296L)
747 self.assertEqual(int('1904440554', 11), 4294967296L)
748 self.assertEqual(int('9ba461594', 12), 4294967296L)
749 self.assertEqual(int('535a79889', 13), 4294967296L)
750 self.assertEqual(int('2ca5b7464', 14), 4294967296L)
751 self.assertEqual(int('1a20dcd81', 15), 4294967296L)
752 self.assertEqual(int('100000000', 16), 4294967296L)
753 self.assertEqual(int('a7ffda91', 17), 4294967296L)
754 self.assertEqual(int('704he7g4', 18), 4294967296L)
755 self.assertEqual(int('4f5aff66', 19), 4294967296L)
756 self.assertEqual(int('3723ai4g', 20), 4294967296L)
757 self.assertEqual(int('281d55i4', 21), 4294967296L)
758 self.assertEqual(int('1fj8b184', 22), 4294967296L)
759 self.assertEqual(int('1606k7ic', 23), 4294967296L)
760 self.assertEqual(int('mb994ag', 24), 4294967296L)
761 self.assertEqual(int('hek2mgl', 25), 4294967296L)
762 self.assertEqual(int('dnchbnm', 26), 4294967296L)
763 self.assertEqual(int('b28jpdm', 27), 4294967296L)
764 self.assertEqual(int('8pfgih4', 28), 4294967296L)
765 self.assertEqual(int('76beigg', 29), 4294967296L)
766 self.assertEqual(int('5qmcpqg', 30), 4294967296L)
767 self.assertEqual(int('4q0jto4', 31), 4294967296L)
768 self.assertEqual(int('4000000', 32), 4294967296L)
769 self.assertEqual(int('3aokq94', 33), 4294967296L)
770 self.assertEqual(int('2qhxjli', 34), 4294967296L)
771 self.assertEqual(int('2br45qb', 35), 4294967296L)
772 self.assertEqual(int('1z141z4', 36), 4294967296L)
773
774 # SF bug 1334662: int(string, base) wrong answers
775 # Checks for proper evaluation of 2**32 + 1
776 self.assertEqual(int('100000000000000000000000000000001', 2), 4294967297L)
777 self.assertEqual(int('102002022201221111212', 3), 4294967297L)
778 self.assertEqual(int('10000000000000001', 4), 4294967297L)
779 self.assertEqual(int('32244002423142', 5), 4294967297L)
780 self.assertEqual(int('1550104015505', 6), 4294967297L)
781 self.assertEqual(int('211301422355', 7), 4294967297L)
782 self.assertEqual(int('40000000001', 8), 4294967297L)
783 self.assertEqual(int('12068657455', 9), 4294967297L)
784 self.assertEqual(int('4294967297', 10), 4294967297L)
785 self.assertEqual(int('1904440555', 11), 4294967297L)
786 self.assertEqual(int('9ba461595', 12), 4294967297L)
787 self.assertEqual(int('535a7988a', 13), 4294967297L)
788 self.assertEqual(int('2ca5b7465', 14), 4294967297L)
789 self.assertEqual(int('1a20dcd82', 15), 4294967297L)
790 self.assertEqual(int('100000001', 16), 4294967297L)
791 self.assertEqual(int('a7ffda92', 17), 4294967297L)
792 self.assertEqual(int('704he7g5', 18), 4294967297L)
793 self.assertEqual(int('4f5aff67', 19), 4294967297L)
794 self.assertEqual(int('3723ai4h', 20), 4294967297L)
795 self.assertEqual(int('281d55i5', 21), 4294967297L)
796 self.assertEqual(int('1fj8b185', 22), 4294967297L)
797 self.assertEqual(int('1606k7id', 23), 4294967297L)
798 self.assertEqual(int('mb994ah', 24), 4294967297L)
799 self.assertEqual(int('hek2mgm', 25), 4294967297L)
800 self.assertEqual(int('dnchbnn', 26), 4294967297L)
801 self.assertEqual(int('b28jpdn', 27), 4294967297L)
802 self.assertEqual(int('8pfgih5', 28), 4294967297L)
803 self.assertEqual(int('76beigh', 29), 4294967297L)
804 self.assertEqual(int('5qmcpqh', 30), 4294967297L)
805 self.assertEqual(int('4q0jto5', 31), 4294967297L)
806 self.assertEqual(int('4000001', 32), 4294967297L)
807 self.assertEqual(int('3aokq95', 33), 4294967297L)
808 self.assertEqual(int('2qhxjlj', 34), 4294967297L)
809 self.assertEqual(int('2br45qc', 35), 4294967297L)
810 self.assertEqual(int('1z141z5', 36), 4294967297L)
811
Brett Cannonc3647ac2005-04-26 03:45:26 +0000812 def test_intconversion(self):
813 # Test __int__()
814 class Foo0:
815 def __int__(self):
816 return 42
817
818 class Foo1(object):
819 def __int__(self):
820 return 42
821
822 class Foo2(int):
823 def __int__(self):
824 return 42
825
826 class Foo3(int):
827 def __int__(self):
828 return self
829
830 class Foo4(int):
831 def __int__(self):
832 return 42L
833
834 class Foo5(int):
835 def __int__(self):
836 return 42.
837
838 self.assertEqual(int(Foo0()), 42)
839 self.assertEqual(int(Foo1()), 42)
840 self.assertEqual(int(Foo2()), 42)
841 self.assertEqual(int(Foo3()), 0)
842 self.assertEqual(int(Foo4()), 42L)
843 self.assertRaises(TypeError, int, Foo5())
844
Walter Dörwald919497e2003-01-19 16:23:59 +0000845 def test_iter(self):
846 self.assertRaises(TypeError, iter)
847 self.assertRaises(TypeError, iter, 42, 42)
848 lists = [("1", "2"), ["1", "2"], "12"]
849 if have_unicode:
850 lists.append(unicode("12"))
851 for l in lists:
852 i = iter(l)
853 self.assertEqual(i.next(), '1')
854 self.assertEqual(i.next(), '2')
855 self.assertRaises(StopIteration, i.next)
856
857 def test_isinstance(self):
858 class C:
859 pass
860 class D(C):
861 pass
862 class E:
863 pass
864 c = C()
865 d = D()
866 e = E()
867 self.assert_(isinstance(c, C))
868 self.assert_(isinstance(d, C))
869 self.assert_(not isinstance(e, C))
870 self.assert_(not isinstance(c, D))
871 self.assert_(not isinstance('foo', E))
872 self.assertRaises(TypeError, isinstance, E, 'foo')
873 self.assertRaises(TypeError, isinstance)
874
875 def test_issubclass(self):
876 class C:
877 pass
878 class D(C):
879 pass
880 class E:
881 pass
882 c = C()
883 d = D()
884 e = E()
885 self.assert_(issubclass(D, C))
886 self.assert_(issubclass(C, C))
887 self.assert_(not issubclass(C, D))
888 self.assertRaises(TypeError, issubclass, 'foo', E)
889 self.assertRaises(TypeError, issubclass, E, 'foo')
890 self.assertRaises(TypeError, issubclass)
891
892 def test_len(self):
893 self.assertEqual(len('123'), 3)
894 self.assertEqual(len(()), 0)
895 self.assertEqual(len((1, 2, 3, 4)), 4)
896 self.assertEqual(len([1, 2, 3, 4]), 4)
897 self.assertEqual(len({}), 0)
898 self.assertEqual(len({'a':1, 'b': 2}), 2)
899 class BadSeq:
900 def __len__(self):
901 raise ValueError
902 self.assertRaises(ValueError, len, BadSeq())
903
904 def test_list(self):
905 self.assertEqual(list([]), [])
906 l0_3 = [0, 1, 2, 3]
907 l0_3_bis = list(l0_3)
908 self.assertEqual(l0_3, l0_3_bis)
909 self.assert_(l0_3 is not l0_3_bis)
910 self.assertEqual(list(()), [])
911 self.assertEqual(list((0, 1, 2, 3)), [0, 1, 2, 3])
912 self.assertEqual(list(''), [])
913 self.assertEqual(list('spam'), ['s', 'p', 'a', 'm'])
914
915 if sys.maxint == 0x7fffffff:
916 # This test can currently only work on 32-bit machines.
917 # XXX If/when PySequence_Length() returns a ssize_t, it should be
918 # XXX re-enabled.
919 # Verify clearing of bug #556025.
920 # This assumes that the max data size (sys.maxint) == max
921 # address size this also assumes that the address size is at
922 # least 4 bytes with 8 byte addresses, the bug is not well
923 # tested
924 #
925 # Note: This test is expected to SEGV under Cygwin 1.3.12 or
926 # earlier due to a newlib bug. See the following mailing list
927 # thread for the details:
928
929 # http://sources.redhat.com/ml/newlib/2002/msg00369.html
930 self.assertRaises(MemoryError, list, xrange(sys.maxint // 2))
931
Raymond Hettingeraa241e02004-09-26 19:24:20 +0000932 # This code used to segfault in Py2.4a3
933 x = []
934 x.extend(-y for y in x)
935 self.assertEqual(x, [])
936
Walter Dörwald919497e2003-01-19 16:23:59 +0000937 def test_long(self):
938 self.assertEqual(long(314), 314L)
939 self.assertEqual(long(3.14), 3L)
940 self.assertEqual(long(314L), 314L)
941 # Check that conversion from float truncates towards zero
942 self.assertEqual(long(-3.14), -3L)
943 self.assertEqual(long(3.9), 3L)
944 self.assertEqual(long(-3.9), -3L)
945 self.assertEqual(long(3.5), 3L)
946 self.assertEqual(long(-3.5), -3L)
947 self.assertEqual(long("-3"), -3L)
948 if have_unicode:
949 self.assertEqual(long(unicode("-3")), -3L)
950 # Different base:
951 self.assertEqual(long("10",16), 16L)
952 if have_unicode:
953 self.assertEqual(long(unicode("10"),16), 16L)
954 # Check conversions from string (same test set as for int(), and then some)
955 LL = [
956 ('1' + '0'*20, 10L**20),
957 ('1' + '0'*100, 10L**100)
958 ]
Walter Dörwaldc8cb5d92003-08-15 17:52:39 +0000959 L2 = L[:]
Walter Dörwald919497e2003-01-19 16:23:59 +0000960 if have_unicode:
961 L2 += [
962 (unicode('1') + unicode('0')*20, 10L**20),
963 (unicode('1') + unicode('0')*100, 10L**100),
964 ]
965 for s, v in L2 + LL:
966 for sign in "", "+", "-":
967 for prefix in "", " ", "\t", " \t\t ":
968 ss = prefix + sign + s
969 vv = v
970 if sign == "-" and v is not ValueError:
971 vv = -v
972 try:
973 self.assertEqual(long(ss), long(vv))
974 except v:
975 pass
976
977 self.assertRaises(ValueError, long, '123\0')
978 self.assertRaises(ValueError, long, '53', 40)
979 self.assertRaises(TypeError, long, 1, 12)
980
Thomas Wouters477c8d52006-05-27 19:21:47 +0000981 self.assertEqual(long('100000000000000000000000000000000', 2),
982 4294967296)
983 self.assertEqual(long('102002022201221111211', 3), 4294967296)
984 self.assertEqual(long('10000000000000000', 4), 4294967296)
985 self.assertEqual(long('32244002423141', 5), 4294967296)
986 self.assertEqual(long('1550104015504', 6), 4294967296)
987 self.assertEqual(long('211301422354', 7), 4294967296)
988 self.assertEqual(long('40000000000', 8), 4294967296)
989 self.assertEqual(long('12068657454', 9), 4294967296)
990 self.assertEqual(long('4294967296', 10), 4294967296)
991 self.assertEqual(long('1904440554', 11), 4294967296)
992 self.assertEqual(long('9ba461594', 12), 4294967296)
993 self.assertEqual(long('535a79889', 13), 4294967296)
994 self.assertEqual(long('2ca5b7464', 14), 4294967296)
995 self.assertEqual(long('1a20dcd81', 15), 4294967296)
996 self.assertEqual(long('100000000', 16), 4294967296)
997 self.assertEqual(long('a7ffda91', 17), 4294967296)
998 self.assertEqual(long('704he7g4', 18), 4294967296)
999 self.assertEqual(long('4f5aff66', 19), 4294967296)
1000 self.assertEqual(long('3723ai4g', 20), 4294967296)
1001 self.assertEqual(long('281d55i4', 21), 4294967296)
1002 self.assertEqual(long('1fj8b184', 22), 4294967296)
1003 self.assertEqual(long('1606k7ic', 23), 4294967296)
1004 self.assertEqual(long('mb994ag', 24), 4294967296)
1005 self.assertEqual(long('hek2mgl', 25), 4294967296)
1006 self.assertEqual(long('dnchbnm', 26), 4294967296)
1007 self.assertEqual(long('b28jpdm', 27), 4294967296)
1008 self.assertEqual(long('8pfgih4', 28), 4294967296)
1009 self.assertEqual(long('76beigg', 29), 4294967296)
1010 self.assertEqual(long('5qmcpqg', 30), 4294967296)
1011 self.assertEqual(long('4q0jto4', 31), 4294967296)
1012 self.assertEqual(long('4000000', 32), 4294967296)
1013 self.assertEqual(long('3aokq94', 33), 4294967296)
1014 self.assertEqual(long('2qhxjli', 34), 4294967296)
1015 self.assertEqual(long('2br45qb', 35), 4294967296)
1016 self.assertEqual(long('1z141z4', 36), 4294967296)
1017
1018 self.assertEqual(long('100000000000000000000000000000001', 2),
1019 4294967297)
1020 self.assertEqual(long('102002022201221111212', 3), 4294967297)
1021 self.assertEqual(long('10000000000000001', 4), 4294967297)
1022 self.assertEqual(long('32244002423142', 5), 4294967297)
1023 self.assertEqual(long('1550104015505', 6), 4294967297)
1024 self.assertEqual(long('211301422355', 7), 4294967297)
1025 self.assertEqual(long('40000000001', 8), 4294967297)
1026 self.assertEqual(long('12068657455', 9), 4294967297)
1027 self.assertEqual(long('4294967297', 10), 4294967297)
1028 self.assertEqual(long('1904440555', 11), 4294967297)
1029 self.assertEqual(long('9ba461595', 12), 4294967297)
1030 self.assertEqual(long('535a7988a', 13), 4294967297)
1031 self.assertEqual(long('2ca5b7465', 14), 4294967297)
1032 self.assertEqual(long('1a20dcd82', 15), 4294967297)
1033 self.assertEqual(long('100000001', 16), 4294967297)
1034 self.assertEqual(long('a7ffda92', 17), 4294967297)
1035 self.assertEqual(long('704he7g5', 18), 4294967297)
1036 self.assertEqual(long('4f5aff67', 19), 4294967297)
1037 self.assertEqual(long('3723ai4h', 20), 4294967297)
1038 self.assertEqual(long('281d55i5', 21), 4294967297)
1039 self.assertEqual(long('1fj8b185', 22), 4294967297)
1040 self.assertEqual(long('1606k7id', 23), 4294967297)
1041 self.assertEqual(long('mb994ah', 24), 4294967297)
1042 self.assertEqual(long('hek2mgm', 25), 4294967297)
1043 self.assertEqual(long('dnchbnn', 26), 4294967297)
1044 self.assertEqual(long('b28jpdn', 27), 4294967297)
1045 self.assertEqual(long('8pfgih5', 28), 4294967297)
1046 self.assertEqual(long('76beigh', 29), 4294967297)
1047 self.assertEqual(long('5qmcpqh', 30), 4294967297)
1048 self.assertEqual(long('4q0jto5', 31), 4294967297)
1049 self.assertEqual(long('4000001', 32), 4294967297)
1050 self.assertEqual(long('3aokq95', 33), 4294967297)
1051 self.assertEqual(long('2qhxjlj', 34), 4294967297)
1052 self.assertEqual(long('2br45qc', 35), 4294967297)
1053 self.assertEqual(long('1z141z5', 36), 4294967297)
1054
1055
Brett Cannonc3647ac2005-04-26 03:45:26 +00001056 def test_longconversion(self):
1057 # Test __long__()
1058 class Foo0:
1059 def __long__(self):
1060 return 42L
1061
1062 class Foo1(object):
1063 def __long__(self):
1064 return 42L
1065
1066 class Foo2(long):
1067 def __long__(self):
1068 return 42L
1069
1070 class Foo3(long):
1071 def __long__(self):
1072 return self
1073
1074 class Foo4(long):
1075 def __long__(self):
1076 return 42
1077
1078 class Foo5(long):
1079 def __long__(self):
1080 return 42.
1081
1082 self.assertEqual(long(Foo0()), 42L)
1083 self.assertEqual(long(Foo1()), 42L)
1084 self.assertEqual(long(Foo2()), 42L)
1085 self.assertEqual(long(Foo3()), 0)
1086 self.assertEqual(long(Foo4()), 42)
1087 self.assertRaises(TypeError, long, Foo5())
1088
Walter Dörwald919497e2003-01-19 16:23:59 +00001089 def test_map(self):
1090 self.assertEqual(
1091 map(None, 'hello world'),
1092 ['h','e','l','l','o',' ','w','o','r','l','d']
1093 )
1094 self.assertEqual(
1095 map(None, 'abcd', 'efg'),
1096 [('a', 'e'), ('b', 'f'), ('c', 'g'), ('d', None)]
1097 )
1098 self.assertEqual(
1099 map(None, range(10)),
1100 [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
1101 )
1102 self.assertEqual(
1103 map(lambda x: x*x, range(1,4)),
1104 [1, 4, 9]
1105 )
1106 try:
1107 from math import sqrt
1108 except ImportError:
1109 def sqrt(x):
1110 return pow(x, 0.5)
1111 self.assertEqual(
1112 map(lambda x: map(sqrt,x), [[16, 4], [81, 9]]),
1113 [[4.0, 2.0], [9.0, 3.0]]
1114 )
1115 self.assertEqual(
1116 map(lambda x, y: x+y, [1,3,2], [9,1,4]),
1117 [10, 4, 6]
1118 )
1119
1120 def plus(*v):
1121 accu = 0
1122 for i in v: accu = accu + i
1123 return accu
1124 self.assertEqual(
1125 map(plus, [1, 3, 7]),
1126 [1, 3, 7]
1127 )
1128 self.assertEqual(
1129 map(plus, [1, 3, 7], [4, 9, 2]),
1130 [1+4, 3+9, 7+2]
1131 )
1132 self.assertEqual(
1133 map(plus, [1, 3, 7], [4, 9, 2], [1, 1, 0]),
1134 [1+4+1, 3+9+1, 7+2+0]
1135 )
1136 self.assertEqual(
1137 map(None, Squares(10)),
1138 [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
1139 )
1140 self.assertEqual(
1141 map(int, Squares(10)),
1142 [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
1143 )
1144 self.assertEqual(
1145 map(None, Squares(3), Squares(2)),
1146 [(0,0), (1,1), (4,None)]
1147 )
Guido van Rossum47b9ff62006-08-24 00:41:19 +00001148 def Max(a, b):
1149 if a is None:
1150 return b
1151 if b is None:
1152 return a
1153 return max(a, b)
Walter Dörwald919497e2003-01-19 16:23:59 +00001154 self.assertEqual(
Guido van Rossum47b9ff62006-08-24 00:41:19 +00001155 map(Max, Squares(3), Squares(2)),
Walter Dörwald919497e2003-01-19 16:23:59 +00001156 [0, 1, 4]
1157 )
1158 self.assertRaises(TypeError, map)
1159 self.assertRaises(TypeError, map, lambda x: x, 42)
1160 self.assertEqual(map(None, [42]), [42])
1161 class BadSeq:
1162 def __getitem__(self, index):
1163 raise ValueError
1164 self.assertRaises(ValueError, map, lambda x: x, BadSeq())
Neal Norwitzfcf44352005-11-27 20:37:43 +00001165 def badfunc(x):
1166 raise RuntimeError
1167 self.assertRaises(RuntimeError, map, badfunc, range(5))
Walter Dörwald919497e2003-01-19 16:23:59 +00001168
1169 def test_max(self):
1170 self.assertEqual(max('123123'), '3')
1171 self.assertEqual(max(1, 2, 3), 3)
1172 self.assertEqual(max((1, 2, 3, 1, 2, 3)), 3)
1173 self.assertEqual(max([1, 2, 3, 1, 2, 3]), 3)
1174
1175 self.assertEqual(max(1, 2L, 3.0), 3.0)
1176 self.assertEqual(max(1L, 2.0, 3), 3)
1177 self.assertEqual(max(1.0, 2, 3L), 3L)
1178
Raymond Hettinger3b0c7c22004-12-03 08:30:39 +00001179 for stmt in (
1180 "max(key=int)", # no args
1181 "max(1, key=int)", # single arg not iterable
1182 "max(1, 2, keystone=int)", # wrong keyword
1183 "max(1, 2, key=int, abc=int)", # two many keywords
1184 "max(1, 2, key=1)", # keyfunc is not callable
1185 ):
Tim Peters7f061872004-12-07 21:17:46 +00001186 try:
Georg Brandl7cae87c2006-09-06 06:51:57 +00001187 exec(stmt, globals())
Tim Peters7f061872004-12-07 21:17:46 +00001188 except TypeError:
1189 pass
1190 else:
1191 self.fail(stmt)
Raymond Hettinger3b0c7c22004-12-03 08:30:39 +00001192
1193 self.assertEqual(max((1,), key=neg), 1) # one elem iterable
1194 self.assertEqual(max((1,2), key=neg), 1) # two elem iterable
1195 self.assertEqual(max(1, 2, key=neg), 1) # two elems
1196
1197 data = [random.randrange(200) for i in range(100)]
1198 keys = dict((elem, random.randrange(50)) for elem in data)
1199 f = keys.__getitem__
1200 self.assertEqual(max(data, key=f),
1201 sorted(reversed(data), key=f)[-1])
1202
Walter Dörwald919497e2003-01-19 16:23:59 +00001203 def test_min(self):
1204 self.assertEqual(min('123123'), '1')
1205 self.assertEqual(min(1, 2, 3), 1)
1206 self.assertEqual(min((1, 2, 3, 1, 2, 3)), 1)
1207 self.assertEqual(min([1, 2, 3, 1, 2, 3]), 1)
1208
1209 self.assertEqual(min(1, 2L, 3.0), 1)
1210 self.assertEqual(min(1L, 2.0, 3), 1L)
1211 self.assertEqual(min(1.0, 2, 3L), 1.0)
1212
1213 self.assertRaises(TypeError, min)
1214 self.assertRaises(TypeError, min, 42)
1215 self.assertRaises(ValueError, min, ())
1216 class BadSeq:
1217 def __getitem__(self, index):
1218 raise ValueError
1219 self.assertRaises(ValueError, min, BadSeq())
1220 class BadNumber:
1221 def __cmp__(self, other):
1222 raise ValueError
Guido van Rossum47b9ff62006-08-24 00:41:19 +00001223 self.assertRaises(TypeError, min, (42, BadNumber()))
Walter Dörwald919497e2003-01-19 16:23:59 +00001224
Raymond Hettinger3b0c7c22004-12-03 08:30:39 +00001225 for stmt in (
1226 "min(key=int)", # no args
1227 "min(1, key=int)", # single arg not iterable
1228 "min(1, 2, keystone=int)", # wrong keyword
1229 "min(1, 2, key=int, abc=int)", # two many keywords
1230 "min(1, 2, key=1)", # keyfunc is not callable
1231 ):
Tim Peters7f061872004-12-07 21:17:46 +00001232 try:
Georg Brandl7cae87c2006-09-06 06:51:57 +00001233 exec(stmt, globals())
Tim Peters7f061872004-12-07 21:17:46 +00001234 except TypeError:
1235 pass
1236 else:
1237 self.fail(stmt)
Raymond Hettinger3b0c7c22004-12-03 08:30:39 +00001238
1239 self.assertEqual(min((1,), key=neg), 1) # one elem iterable
1240 self.assertEqual(min((1,2), key=neg), 2) # two elem iterable
1241 self.assertEqual(min(1, 2, key=neg), 2) # two elems
1242
1243 data = [random.randrange(200) for i in range(100)]
1244 keys = dict((elem, random.randrange(50)) for elem in data)
1245 f = keys.__getitem__
1246 self.assertEqual(min(data, key=f),
1247 sorted(data, key=f)[0])
1248
Walter Dörwald919497e2003-01-19 16:23:59 +00001249 def test_oct(self):
1250 self.assertEqual(oct(100), '0144')
Guido van Rossume2b70bc2006-08-18 22:13:04 +00001251 self.assertEqual(oct(100L), '0144')
Guido van Rossum6c9e1302003-11-29 23:52:13 +00001252 self.assertEqual(oct(-100), '-0144')
Guido van Rossume2b70bc2006-08-18 22:13:04 +00001253 self.assertEqual(oct(-100L), '-0144')
Walter Dörwald919497e2003-01-19 16:23:59 +00001254 self.assertRaises(TypeError, oct, ())
1255
1256 def write_testfile(self):
Walter Dörwald919497e2003-01-19 16:23:59 +00001257 fp = open(TESTFN, 'w')
1258 try:
1259 fp.write('1+1\n')
1260 fp.write('1+1\n')
1261 fp.write('The quick brown fox jumps over the lazy dog')
1262 fp.write('.\n')
1263 fp.write('Dear John\n')
1264 fp.write('XXX'*100)
1265 fp.write('YYY'*100)
1266 finally:
1267 fp.close()
1268
1269 def test_open(self):
1270 self.write_testfile()
1271 fp = open(TESTFN, 'r')
1272 try:
1273 self.assertEqual(fp.readline(4), '1+1\n')
1274 self.assertEqual(fp.readline(4), '1+1\n')
1275 self.assertEqual(fp.readline(), 'The quick brown fox jumps over the lazy dog.\n')
1276 self.assertEqual(fp.readline(4), 'Dear')
1277 self.assertEqual(fp.readline(100), ' John\n')
1278 self.assertEqual(fp.read(300), 'XXX'*100)
1279 self.assertEqual(fp.read(1000), 'YYY'*100)
1280 finally:
1281 fp.close()
1282 unlink(TESTFN)
1283
1284 def test_ord(self):
1285 self.assertEqual(ord(' '), 32)
1286 self.assertEqual(ord('A'), 65)
1287 self.assertEqual(ord('a'), 97)
1288 if have_unicode:
1289 self.assertEqual(ord(unichr(sys.maxunicode)), sys.maxunicode)
1290 self.assertRaises(TypeError, ord, 42)
Walter Dörwald4e41a4b2005-08-03 17:09:04 +00001291 if have_unicode:
1292 self.assertRaises(TypeError, ord, unicode("12"))
Walter Dörwald919497e2003-01-19 16:23:59 +00001293
1294 def test_pow(self):
1295 self.assertEqual(pow(0,0), 1)
1296 self.assertEqual(pow(0,1), 0)
1297 self.assertEqual(pow(1,0), 1)
1298 self.assertEqual(pow(1,1), 1)
1299
1300 self.assertEqual(pow(2,0), 1)
1301 self.assertEqual(pow(2,10), 1024)
1302 self.assertEqual(pow(2,20), 1024*1024)
1303 self.assertEqual(pow(2,30), 1024*1024*1024)
1304
1305 self.assertEqual(pow(-2,0), 1)
1306 self.assertEqual(pow(-2,1), -2)
1307 self.assertEqual(pow(-2,2), 4)
1308 self.assertEqual(pow(-2,3), -8)
1309
1310 self.assertEqual(pow(0L,0), 1)
1311 self.assertEqual(pow(0L,1), 0)
1312 self.assertEqual(pow(1L,0), 1)
1313 self.assertEqual(pow(1L,1), 1)
1314
1315 self.assertEqual(pow(2L,0), 1)
1316 self.assertEqual(pow(2L,10), 1024)
1317 self.assertEqual(pow(2L,20), 1024*1024)
1318 self.assertEqual(pow(2L,30), 1024*1024*1024)
1319
1320 self.assertEqual(pow(-2L,0), 1)
1321 self.assertEqual(pow(-2L,1), -2)
1322 self.assertEqual(pow(-2L,2), 4)
1323 self.assertEqual(pow(-2L,3), -8)
1324
1325 self.assertAlmostEqual(pow(0.,0), 1.)
1326 self.assertAlmostEqual(pow(0.,1), 0.)
1327 self.assertAlmostEqual(pow(1.,0), 1.)
1328 self.assertAlmostEqual(pow(1.,1), 1.)
1329
1330 self.assertAlmostEqual(pow(2.,0), 1.)
1331 self.assertAlmostEqual(pow(2.,10), 1024.)
1332 self.assertAlmostEqual(pow(2.,20), 1024.*1024.)
1333 self.assertAlmostEqual(pow(2.,30), 1024.*1024.*1024.)
1334
1335 self.assertAlmostEqual(pow(-2.,0), 1.)
1336 self.assertAlmostEqual(pow(-2.,1), -2.)
1337 self.assertAlmostEqual(pow(-2.,2), 4.)
1338 self.assertAlmostEqual(pow(-2.,3), -8.)
1339
1340 for x in 2, 2L, 2.0:
1341 for y in 10, 10L, 10.0:
1342 for z in 1000, 1000L, 1000.0:
1343 if isinstance(x, float) or \
1344 isinstance(y, float) or \
1345 isinstance(z, float):
1346 self.assertRaises(TypeError, pow, x, y, z)
1347 else:
1348 self.assertAlmostEqual(pow(x, y, z), 24.0)
1349
1350 self.assertRaises(TypeError, pow, -1, -2, 3)
1351 self.assertRaises(ValueError, pow, 1, 2, 0)
1352 self.assertRaises(TypeError, pow, -1L, -2L, 3L)
1353 self.assertRaises(ValueError, pow, 1L, 2L, 0L)
1354 self.assertRaises(ValueError, pow, -342.43, 0.234)
1355
1356 self.assertRaises(TypeError, pow)
1357
1358 def test_range(self):
1359 self.assertEqual(range(3), [0, 1, 2])
1360 self.assertEqual(range(1, 5), [1, 2, 3, 4])
1361 self.assertEqual(range(0), [])
1362 self.assertEqual(range(-3), [])
1363 self.assertEqual(range(1, 10, 3), [1, 4, 7])
1364 self.assertEqual(range(5, -5, -3), [5, 2, -1, -4])
1365
Guido van Rossumefbbb1c2003-04-11 18:43:06 +00001366 # Now test range() with longs
1367 self.assertEqual(range(-2**100), [])
1368 self.assertEqual(range(0, -2**100), [])
1369 self.assertEqual(range(0, 2**100, -1), [])
1370 self.assertEqual(range(0, 2**100, -1), [])
1371
1372 a = long(10 * sys.maxint)
1373 b = long(100 * sys.maxint)
1374 c = long(50 * sys.maxint)
1375
1376 self.assertEqual(range(a, a+2), [a, a+1])
1377 self.assertEqual(range(a+2, a, -1L), [a+2, a+1])
1378 self.assertEqual(range(a+4, a, -2), [a+4, a+2])
1379
1380 seq = range(a, b, c)
1381 self.assert_(a in seq)
1382 self.assert_(b not in seq)
1383 self.assertEqual(len(seq), 2)
1384
1385 seq = range(b, a, -c)
1386 self.assert_(b in seq)
1387 self.assert_(a not in seq)
1388 self.assertEqual(len(seq), 2)
1389
1390 seq = range(-a, -b, -c)
1391 self.assert_(-a in seq)
1392 self.assert_(-b not in seq)
1393 self.assertEqual(len(seq), 2)
1394
Walter Dörwald919497e2003-01-19 16:23:59 +00001395 self.assertRaises(TypeError, range)
1396 self.assertRaises(TypeError, range, 1, 2, 3, 4)
1397 self.assertRaises(ValueError, range, 1, 2, 0)
Neal Norwitzfcf44352005-11-27 20:37:43 +00001398 self.assertRaises(ValueError, range, a, a + 1, long(0))
1399
1400 class badzero(int):
Guido van Rossum47b9ff62006-08-24 00:41:19 +00001401 def __eq__(self, other):
Neal Norwitzfcf44352005-11-27 20:37:43 +00001402 raise RuntimeError
Guido van Rossum47b9ff62006-08-24 00:41:19 +00001403 __ne__ = __lt__ = __gt__ = __le__ = __ge__ = __eq__
1404
1405 # XXX This won't (but should!) raise RuntimeError if a is an int...
Neal Norwitzfcf44352005-11-27 20:37:43 +00001406 self.assertRaises(RuntimeError, range, a, a + 1, badzero(1))
Walter Dörwald919497e2003-01-19 16:23:59 +00001407
Guido van Rossumefbbb1c2003-04-11 18:43:06 +00001408 # Reject floats when it would require PyLongs to represent.
1409 # (smaller floats still accepted, but deprecated)
Tim Peters299b3df2003-04-15 14:40:03 +00001410 self.assertRaises(TypeError, range, 1e100, 1e101, 1e101)
Guido van Rossumefbbb1c2003-04-11 18:43:06 +00001411
Walter Dörwald357981e2003-04-15 18:59:28 +00001412 self.assertRaises(TypeError, range, 0, "spam")
1413 self.assertRaises(TypeError, range, 0, 42, "spam")
1414
1415 self.assertRaises(OverflowError, range, -sys.maxint, sys.maxint)
1416 self.assertRaises(OverflowError, range, 0, 2*sys.maxint)
1417
Walter Dörwald919497e2003-01-19 16:23:59 +00001418 def test_reload(self):
1419 import marshal
1420 reload(marshal)
1421 import string
1422 reload(string)
1423 ## import sys
1424 ## self.assertRaises(ImportError, reload, sys)
1425
1426 def test_repr(self):
1427 self.assertEqual(repr(''), '\'\'')
1428 self.assertEqual(repr(0), '0')
Guido van Rossume2b70bc2006-08-18 22:13:04 +00001429 self.assertEqual(repr(0L), '0')
Walter Dörwald919497e2003-01-19 16:23:59 +00001430 self.assertEqual(repr(()), '()')
1431 self.assertEqual(repr([]), '[]')
1432 self.assertEqual(repr({}), '{}')
1433 a = []
1434 a.append(a)
1435 self.assertEqual(repr(a), '[[...]]')
1436 a = {}
1437 a[0] = a
1438 self.assertEqual(repr(a), '{0: {...}}')
1439
1440 def test_round(self):
1441 self.assertEqual(round(0.0), 0.0)
1442 self.assertEqual(round(1.0), 1.0)
1443 self.assertEqual(round(10.0), 10.0)
1444 self.assertEqual(round(1000000000.0), 1000000000.0)
1445 self.assertEqual(round(1e20), 1e20)
1446
1447 self.assertEqual(round(-1.0), -1.0)
1448 self.assertEqual(round(-10.0), -10.0)
1449 self.assertEqual(round(-1000000000.0), -1000000000.0)
1450 self.assertEqual(round(-1e20), -1e20)
1451
1452 self.assertEqual(round(0.1), 0.0)
1453 self.assertEqual(round(1.1), 1.0)
1454 self.assertEqual(round(10.1), 10.0)
1455 self.assertEqual(round(1000000000.1), 1000000000.0)
1456
1457 self.assertEqual(round(-1.1), -1.0)
1458 self.assertEqual(round(-10.1), -10.0)
1459 self.assertEqual(round(-1000000000.1), -1000000000.0)
1460
1461 self.assertEqual(round(0.9), 1.0)
1462 self.assertEqual(round(9.9), 10.0)
1463 self.assertEqual(round(999999999.9), 1000000000.0)
1464
1465 self.assertEqual(round(-0.9), -1.0)
1466 self.assertEqual(round(-9.9), -10.0)
1467 self.assertEqual(round(-999999999.9), -1000000000.0)
1468
1469 self.assertEqual(round(-8.0, -1), -10.0)
1470
Thomas Wouters49fd7fa2006-04-21 10:40:58 +00001471 # test new kwargs
1472 self.assertEqual(round(number=-8.0, ndigits=-1), -10.0)
1473
Walter Dörwald919497e2003-01-19 16:23:59 +00001474 self.assertRaises(TypeError, round)
1475
1476 def test_setattr(self):
Tim Petersf2715e02003-02-19 02:35:07 +00001477 setattr(sys, 'spam', 1)
1478 self.assertEqual(sys.spam, 1)
1479 self.assertRaises(TypeError, setattr, sys, 1, 'spam')
1480 self.assertRaises(TypeError, setattr)
Walter Dörwald919497e2003-01-19 16:23:59 +00001481
1482 def test_str(self):
1483 self.assertEqual(str(''), '')
1484 self.assertEqual(str(0), '0')
1485 self.assertEqual(str(0L), '0')
1486 self.assertEqual(str(()), '()')
1487 self.assertEqual(str([]), '[]')
1488 self.assertEqual(str({}), '{}')
1489 a = []
1490 a.append(a)
1491 self.assertEqual(str(a), '[[...]]')
1492 a = {}
1493 a[0] = a
1494 self.assertEqual(str(a), '{0: {...}}')
1495
Alex Martellia70b1912003-04-22 08:12:33 +00001496 def test_sum(self):
1497 self.assertEqual(sum([]), 0)
1498 self.assertEqual(sum(range(2,8)), 27)
1499 self.assertEqual(sum(iter(range(2,8))), 27)
1500 self.assertEqual(sum(Squares(10)), 285)
1501 self.assertEqual(sum(iter(Squares(10))), 285)
1502 self.assertEqual(sum([[1], [2], [3]], []), [1, 2, 3])
1503
1504 self.assertRaises(TypeError, sum)
1505 self.assertRaises(TypeError, sum, 42)
1506 self.assertRaises(TypeError, sum, ['a', 'b', 'c'])
1507 self.assertRaises(TypeError, sum, ['a', 'b', 'c'], '')
1508 self.assertRaises(TypeError, sum, [[1], [2], [3]])
1509 self.assertRaises(TypeError, sum, [{2:3}])
1510 self.assertRaises(TypeError, sum, [{2:3}]*2, {2:3})
1511
1512 class BadSeq:
1513 def __getitem__(self, index):
1514 raise ValueError
1515 self.assertRaises(ValueError, sum, BadSeq())
1516
Walter Dörwald919497e2003-01-19 16:23:59 +00001517 def test_tuple(self):
1518 self.assertEqual(tuple(()), ())
1519 t0_3 = (0, 1, 2, 3)
1520 t0_3_bis = tuple(t0_3)
1521 self.assert_(t0_3 is t0_3_bis)
1522 self.assertEqual(tuple([]), ())
1523 self.assertEqual(tuple([0, 1, 2, 3]), (0, 1, 2, 3))
1524 self.assertEqual(tuple(''), ())
1525 self.assertEqual(tuple('spam'), ('s', 'p', 'a', 'm'))
1526
1527 def test_type(self):
1528 self.assertEqual(type(''), type('123'))
1529 self.assertNotEqual(type(''), type(()))
1530
1531 def test_unichr(self):
1532 if have_unicode:
1533 self.assertEqual(unichr(32), unicode(' '))
1534 self.assertEqual(unichr(65), unicode('A'))
1535 self.assertEqual(unichr(97), unicode('a'))
1536 self.assertEqual(
1537 unichr(sys.maxunicode),
1538 unicode('\\U%08x' % (sys.maxunicode), 'unicode-escape')
1539 )
1540 self.assertRaises(ValueError, unichr, sys.maxunicode+1)
1541 self.assertRaises(TypeError, unichr)
1542
Guido van Rossumfee7b932005-01-16 00:21:28 +00001543 # We don't want self in vars(), so these are static methods
1544
1545 @staticmethod
Walter Dörwald919497e2003-01-19 16:23:59 +00001546 def get_vars_f0():
1547 return vars()
Walter Dörwald919497e2003-01-19 16:23:59 +00001548
Guido van Rossumfee7b932005-01-16 00:21:28 +00001549 @staticmethod
Walter Dörwald919497e2003-01-19 16:23:59 +00001550 def get_vars_f2():
1551 BuiltinTest.get_vars_f0()
1552 a = 1
1553 b = 2
1554 return vars()
Walter Dörwald919497e2003-01-19 16:23:59 +00001555
1556 def test_vars(self):
Raymond Hettingera690a992003-11-16 16:17:49 +00001557 self.assertEqual(set(vars()), set(dir()))
Walter Dörwald919497e2003-01-19 16:23:59 +00001558 import sys
Raymond Hettingera690a992003-11-16 16:17:49 +00001559 self.assertEqual(set(vars(sys)), set(dir(sys)))
Walter Dörwald919497e2003-01-19 16:23:59 +00001560 self.assertEqual(self.get_vars_f0(), {})
1561 self.assertEqual(self.get_vars_f2(), {'a': 1, 'b': 2})
1562 self.assertRaises(TypeError, vars, 42, 42)
1563 self.assertRaises(TypeError, vars, 42)
1564
1565 def test_zip(self):
1566 a = (1, 2, 3)
1567 b = (4, 5, 6)
1568 t = [(1, 4), (2, 5), (3, 6)]
Guido van Rossum801f0d72006-08-24 19:48:10 +00001569 self.assertEqual(list(zip(a, b)), t)
Walter Dörwald919497e2003-01-19 16:23:59 +00001570 b = [4, 5, 6]
Guido van Rossum801f0d72006-08-24 19:48:10 +00001571 self.assertEqual(list(zip(a, b)), t)
Walter Dörwald919497e2003-01-19 16:23:59 +00001572 b = (4, 5, 6, 7)
Guido van Rossum801f0d72006-08-24 19:48:10 +00001573 self.assertEqual(list(zip(a, b)), t)
Walter Dörwald919497e2003-01-19 16:23:59 +00001574 class I:
1575 def __getitem__(self, i):
1576 if i < 0 or i > 2: raise IndexError
1577 return i + 4
Guido van Rossum801f0d72006-08-24 19:48:10 +00001578 self.assertEqual(list(zip(a, I())), t)
1579 self.assertEqual(list(zip()), [])
1580 self.assertEqual(list(zip(*[])), [])
Walter Dörwald919497e2003-01-19 16:23:59 +00001581 self.assertRaises(TypeError, zip, None)
1582 class G:
1583 pass
1584 self.assertRaises(TypeError, zip, a, G())
1585
1586 # Make sure zip doesn't try to allocate a billion elements for the
1587 # result list when one of its arguments doesn't say how long it is.
1588 # A MemoryError is the most likely failure mode.
1589 class SequenceWithoutALength:
1590 def __getitem__(self, i):
1591 if i == 5:
1592 raise IndexError
1593 else:
1594 return i
1595 self.assertEqual(
Guido van Rossum801f0d72006-08-24 19:48:10 +00001596 list(zip(SequenceWithoutALength(), xrange(2**30))),
Walter Dörwald919497e2003-01-19 16:23:59 +00001597 list(enumerate(range(5)))
1598 )
1599
1600 class BadSeq:
1601 def __getitem__(self, i):
1602 if i == 5:
1603 raise ValueError
1604 else:
1605 return i
Guido van Rossum801f0d72006-08-24 19:48:10 +00001606 self.assertRaises(ValueError, list, zip(BadSeq(), BadSeq()))
Walter Dörwald919497e2003-01-19 16:23:59 +00001607
Raymond Hettinger64958a12003-12-17 20:43:33 +00001608class TestSorted(unittest.TestCase):
1609
1610 def test_basic(self):
1611 data = range(100)
1612 copy = data[:]
1613 random.shuffle(copy)
1614 self.assertEqual(data, sorted(copy))
1615 self.assertNotEqual(data, copy)
1616
1617 data.reverse()
1618 random.shuffle(copy)
Guido van Rossum47b9ff62006-08-24 00:41:19 +00001619 self.assertEqual(data, sorted(copy, cmp=lambda x, y: (x < y) - (x > y)))
Raymond Hettinger64958a12003-12-17 20:43:33 +00001620 self.assertNotEqual(data, copy)
1621 random.shuffle(copy)
1622 self.assertEqual(data, sorted(copy, key=lambda x: -x))
1623 self.assertNotEqual(data, copy)
1624 random.shuffle(copy)
1625 self.assertEqual(data, sorted(copy, reverse=1))
1626 self.assertNotEqual(data, copy)
1627
1628 def test_inputtypes(self):
1629 s = 'abracadabra'
Walter Dörwald4e41a4b2005-08-03 17:09:04 +00001630 types = [list, tuple]
1631 if have_unicode:
1632 types.insert(0, unicode)
1633 for T in types:
Raymond Hettinger64958a12003-12-17 20:43:33 +00001634 self.assertEqual(sorted(s), sorted(T(s)))
1635
1636 s = ''.join(dict.fromkeys(s).keys()) # unique letters only
Walter Dörwald4e41a4b2005-08-03 17:09:04 +00001637 types = [set, frozenset, list, tuple, dict.fromkeys]
1638 if have_unicode:
1639 types.insert(0, unicode)
1640 for T in types:
Raymond Hettinger64958a12003-12-17 20:43:33 +00001641 self.assertEqual(sorted(s), sorted(T(s)))
1642
1643 def test_baddecorator(self):
1644 data = 'The quick Brown fox Jumped over The lazy Dog'.split()
1645 self.assertRaises(TypeError, sorted, data, None, lambda x,y: 0)
1646
Raymond Hettinger3b0c7c22004-12-03 08:30:39 +00001647def test_main(verbose=None):
1648 test_classes = (BuiltinTest, TestSorted)
1649
1650 run_unittest(*test_classes)
1651
1652 # verify reference counting
1653 if verbose and hasattr(sys, "gettotalrefcount"):
1654 import gc
1655 counts = [None] * 5
1656 for i in xrange(len(counts)):
1657 run_unittest(*test_classes)
1658 gc.collect()
1659 counts[i] = sys.gettotalrefcount()
1660 print counts
1661
Walter Dörwald919497e2003-01-19 16:23:59 +00001662
1663if __name__ == "__main__":
Raymond Hettinger3b0c7c22004-12-03 08:30:39 +00001664 test_main(verbose=True)