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