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