diff options
Diffstat (limited to 'FOSS/Python/Dependencies/future-0.18.2/tests/test_past')
7 files changed, 0 insertions, 3423 deletions
diff --git a/FOSS/Python/Dependencies/future-0.18.2/tests/test_past/__init__.py b/FOSS/Python/Dependencies/future-0.18.2/tests/test_past/__init__.py deleted file mode 100644 index e69de29..0000000 --- a/FOSS/Python/Dependencies/future-0.18.2/tests/test_past/__init__.py +++ /dev/null diff --git a/FOSS/Python/Dependencies/future-0.18.2/tests/test_past/test_basestring.py b/FOSS/Python/Dependencies/future-0.18.2/tests/test_past/test_basestring.py deleted file mode 100644 index d002095..0000000 --- a/FOSS/Python/Dependencies/future-0.18.2/tests/test_past/test_basestring.py +++ /dev/null @@ -1,24 +0,0 @@ -# -*- coding: utf-8 -*- -""" -Tests for the Py2-like class:`basestring` type. -""" - -from __future__ import absolute_import, unicode_literals, print_function -import os - -from past import utils -from future.tests.base import unittest -from past.builtins import basestring, str as oldstr - - -class TestBaseString(unittest.TestCase): - - def test_isinstance(self): - s = b'abc' - self.assertTrue(isinstance(s, basestring)) - s2 = oldstr(b'abc') - self.assertTrue(isinstance(s2, basestring)) - - -if __name__ == '__main__': - unittest.main() diff --git a/FOSS/Python/Dependencies/future-0.18.2/tests/test_past/test_builtins.py b/FOSS/Python/Dependencies/future-0.18.2/tests/test_past/test_builtins.py deleted file mode 100644 index d16978e..0000000 --- a/FOSS/Python/Dependencies/future-0.18.2/tests/test_past/test_builtins.py +++ /dev/null @@ -1,1790 +0,0 @@ -from __future__ import division -from __future__ import print_function -# Python test set -- built-in functions -from past.builtins import filter, map, range, zip -from past.builtins import basestring, dict, str, long #, unicode -from past.builtins import apply, cmp, execfile, intern, raw_input -from past.builtins import reduce, reload, unichr, unicode, xrange - -from future import standard_library -from future.backports.test.support import TESTFN #, run_unittest -import tempfile -import os -TESTFN = tempfile.mkdtemp() + os.path.sep + TESTFN - -import platform -import warnings -import sys -import io -import random -# import UserDict -from os import unlink -from operator import neg -from future.tests.base import unittest, expectedFailurePY3, skip26 - -# count the number of test runs. -# used to skip running test_execfile() multiple times -# and to create unique strings to intern in test_intern() -numruns = 0 - -def fcmp(x, y): # fuzzy comparison function - """ - From Python 2.7 test.test_support - """ - if isinstance(x, float) or isinstance(y, float): - try: - fuzz = (abs(x) + abs(y)) * FUZZ - if abs(x-y) <= fuzz: - return 0 - except: - pass - elif type(x) == type(y) and isinstance(x, (tuple, list)): - for i in range(min(len(x), len(y))): - outcome = fcmp(x[i], y[i]) - if outcome != 0: - return outcome - return (len(x) > len(y)) - (len(x) < len(y)) - return (x > y) - (x < y) - - -class Squares: - - def __init__(self, max): - self.max = max - self.sofar = [] - - def __len__(self): return len(self.sofar) - - def __getitem__(self, i): - if not 0 <= i < self.max: raise IndexError - n = len(self.sofar) - while n <= i: - self.sofar.append(n*n) - n += 1 - return self.sofar[i] - -class StrSquares: - - def __init__(self, max): - self.max = max - self.sofar = [] - - def __len__(self): - return len(self.sofar) - - def __getitem__(self, i): - if not 0 <= i < self.max: - raise IndexError - n = len(self.sofar) - while n <= i: - self.sofar.append(str(n*n)) - n += 1 - return self.sofar[i] - -class BitBucket: - def write(self, line): - pass - - -class TestFailingBool: - def __nonzero__(self): - raise RuntimeError - -class TestFailingIter: - def __iter__(self): - raise RuntimeError - -class BuiltinTest(unittest.TestCase): - - def test_import(self): - __import__('sys') - __import__('time') - __import__('string') - __import__(name='sys') - __import__(name='time', level=0) - self.assertRaises(ImportError, __import__, 'spamspam') - self.assertRaises(TypeError, __import__, 1, 2, 3, 4) - self.assertRaises(ValueError, __import__, '') - self.assertRaises(TypeError, __import__, 'sys', name='sys') - - def test_abs(self): - # int - self.assertEqual(abs(0), 0) - self.assertEqual(abs(1234), 1234) - self.assertEqual(abs(-1234), 1234) - self.assertTrue(abs(-sys.maxsize-1) > 0) - # float - self.assertEqual(abs(0.0), 0.0) - self.assertEqual(abs(3.14), 3.14) - self.assertEqual(abs(-3.14), 3.14) - # long - self.assertEqual(abs(0), 0) - self.assertEqual(abs(1234), 1234) - self.assertEqual(abs(-1234), 1234) - # str - self.assertRaises(TypeError, abs, 'a') - # bool - self.assertEqual(abs(True), 1) - self.assertEqual(abs(False), 0) - # other - self.assertRaises(TypeError, abs) - self.assertRaises(TypeError, abs, None) - class AbsClass(object): - def __abs__(self): - return -5 - self.assertEqual(abs(AbsClass()), -5) - - def test_all(self): - self.assertEqual(all([2, 4, 6]), True) - self.assertEqual(all([2, None, 6]), False) - # self.assertRaises(RuntimeError, all, [2, TestFailingBool(), 6]) - # self.assertRaises(RuntimeError, all, TestFailingIter()) - self.assertRaises(TypeError, all, 10) # Non-iterable - self.assertRaises(TypeError, all) # No args - self.assertRaises(TypeError, all, [2, 4, 6], []) # Too many args - self.assertEqual(all([]), True) # Empty iterator - self.assertEqual(all([0, TestFailingBool()]), False)# Short-circuit - S = [50, 60] - self.assertEqual(all(x > 42 for x in S), True) - S = [50, 40, 60] - self.assertEqual(all(x > 42 for x in S), False) - - def test_any(self): - self.assertEqual(any([None, None, None]), False) - self.assertEqual(any([None, 4, None]), True) - # self.assertRaises(RuntimeError, any, [None, TestFailingBool(), 6]) - # self.assertRaises(RuntimeError, any, TestFailingIter()) - self.assertRaises(TypeError, any, 10) # Non-iterable - self.assertRaises(TypeError, any) # No args - self.assertRaises(TypeError, any, [2, 4, 6], []) # Too many args - self.assertEqual(any([]), False) # Empty iterator - self.assertEqual(any([1, TestFailingBool()]), True) # Short-circuit - S = [40, 60, 30] - self.assertEqual(any(x > 42 for x in S), True) - S = [10, 20, 30] - self.assertEqual(any(x > 42 for x in S), False) - - def test_neg(self): - x = -sys.maxsize-1 - self.assertTrue(isinstance(x, int)) - self.assertEqual(-x, sys.maxsize+1) - - @expectedFailurePY3 - def test_apply(self): - def f0(*args): - self.assertEqual(args, ()) - def f1(a1): - self.assertEqual(a1, 1) - def f2(a1, a2): - self.assertEqual(a1, 1) - self.assertEqual(a2, 2) - def f3(a1, a2, a3): - self.assertEqual(a1, 1) - self.assertEqual(a2, 2) - self.assertEqual(a3, 3) - f0(*()) - f1(*(1,)) - f2(*(1, 2)) - f3(*(1, 2, 3)) - - # A PyCFunction that takes only positional parameters should allow an - # empty keyword dictionary to pass without a complaint, but raise a - # TypeError if the dictionary is non-empty. - id(*(1,), **{}) - self.assertRaises(TypeError, apply, id, (1,), {"foo": 1}) - self.assertRaises(TypeError, apply) - self.assertRaises(TypeError, apply, id, 42) - self.assertRaises(TypeError, apply, id, (42,), 42) - - def test_basestring(self): - assert isinstance('hello', basestring) - assert isinstance(b'hello', basestring) - - @expectedFailurePY3 - def test_callable(self): - self.assertTrue(callable(len)) - self.assertFalse(callable("a")) - self.assertTrue(callable(callable)) - self.assertTrue(callable(lambda x, y: x + y)) - self.assertFalse(callable(__builtins__)) - def f(): pass - self.assertTrue(callable(f)) - - class Classic: - def meth(self): pass - self.assertTrue(callable(Classic)) - c = Classic() - self.assertTrue(callable(c.meth)) - self.assertFalse(callable(c)) - - class NewStyle(object): - def meth(self): pass - self.assertTrue(callable(NewStyle)) - n = NewStyle() - self.assertTrue(callable(n.meth)) - self.assertFalse(callable(n)) - - # Classic and new-style classes evaluate __call__() differently - c.__call__ = None - self.assertTrue(callable(c)) - del c.__call__ - self.assertFalse(callable(c)) - n.__call__ = None - self.assertFalse(callable(n)) - del n.__call__ - self.assertFalse(callable(n)) - - class N2(object): - def __call__(self): pass - n2 = N2() - self.assertTrue(callable(n2)) - class N3(N2): pass - n3 = N3() - self.assertTrue(callable(n3)) - - @expectedFailurePY3 - def test_chr(self): - self.assertEqual(chr(32), ' ') - self.assertEqual(chr(65), 'A') - self.assertEqual(chr(97), 'a') - self.assertEqual(chr(0xff), '\xff') - self.assertRaises(ValueError, chr, 256) - self.assertRaises(TypeError, chr) - - @expectedFailurePY3 - def test_cmp(self): - self.assertEqual(cmp(-1, 1), -1) - self.assertEqual(cmp(1, -1), 1) - self.assertEqual(cmp(1, 1), 0) - # verify that circular objects are not handled - a = []; a.append(a) - b = []; b.append(b) - from UserList import UserList - c = UserList(); c.append(c) - self.assertRaises(RuntimeError, cmp, a, b) - self.assertRaises(RuntimeError, cmp, b, c) - self.assertRaises(RuntimeError, cmp, c, a) - self.assertRaises(RuntimeError, cmp, a, c) - # okay, now break the cycles - a.pop(); b.pop(); c.pop() - self.assertRaises(TypeError, cmp) - - @expectedFailurePY3 - def test_coerce(self): - self.assertTrue(not fcmp(coerce(1, 1.1), (1.0, 1.1))) - self.assertEqual(coerce(1, 1), (1, 1)) - self.assertTrue(not fcmp(coerce(1, 1.1), (1.0, 1.1))) - self.assertRaises(TypeError, coerce) - class BadNumber: - def __coerce__(self, other): - raise ValueError - self.assertRaises(ValueError, coerce, 42, BadNumber()) - self.assertRaises(OverflowError, coerce, 0.5, int("12345" * 1000)) - - @expectedFailurePY3 - def test_compile(self): - compile('print(1)\n', '', 'exec') - bom = '\xef\xbb\xbf' - compile(bom + 'print(1)\n', '', 'exec') - compile(source='pass', filename='?', mode='exec') - compile(dont_inherit=0, filename='tmp', source='0', mode='eval') - compile('pass', '?', dont_inherit=1, mode='exec') - self.assertRaises(TypeError, compile) - self.assertRaises(ValueError, compile, 'print(42)\n', '<string>', 'badmode') - self.assertRaises(ValueError, compile, 'print(42)\n', '<string>', 'single', 0xff) - self.assertRaises(TypeError, compile, chr(0), 'f', 'exec') - self.assertRaises(TypeError, compile, 'pass', '?', 'exec', - mode='eval', source='0', filename='tmp') - if True: # Was: if have_unicode: - compile(unicode('print(u"\xc3\xa5"\n)', 'utf8'), '', 'exec') - self.assertRaises(TypeError, compile, unichr(0), 'f', 'exec') - self.assertRaises(ValueError, compile, unicode('a = 1'), 'f', 'bad') - - - def test_delattr(self): - import sys - sys.spam = 1 - delattr(sys, 'spam') - self.assertRaises(TypeError, delattr) - - def test_dir(self): - # dir(wrong number of arguments) - self.assertRaises(TypeError, dir, 42, 42) - - # dir() - local scope - local_var = 1 - self.assertIn('local_var', dir()) - - # dir(module) - import sys - self.assertIn('exit', dir(sys)) - - # dir(module_with_invalid__dict__) - import types - class Foo(types.ModuleType): - __dict__ = 8 - f = Foo("foo") - self.assertRaises(TypeError, dir, f) - - # dir(type) - self.assertIn("strip", dir(str)) - self.assertNotIn("__mro__", dir(str)) - - # dir(obj) - class Foo(object): - def __init__(self): - self.x = 7 - self.y = 8 - self.z = 9 - f = Foo() - self.assertIn("y", dir(f)) - - # dir(obj_no__dict__) - class Foo(object): - __slots__ = [] - f = Foo() - self.assertIn("__repr__", dir(f)) - - # dir(obj_no__class__with__dict__) - # (an ugly trick to cause getattr(f, "__class__") to fail) - class Foo(object): - __slots__ = ["__class__", "__dict__"] - def __init__(self): - self.bar = "wow" - f = Foo() - self.assertNotIn("__repr__", dir(f)) - self.assertIn("bar", dir(f)) - - # dir(obj_using __dir__) - class Foo(object): - def __dir__(self): - return ["kan", "ga", "roo"] - f = Foo() - self.assertTrue(dir(f) == ["ga", "kan", "roo"]) - - # dir(obj__dir__not_list) - class Foo(object): - def __dir__(self): - return 7 - f = Foo() - self.assertRaises(TypeError, dir, f) - - def test_divmod(self): - self.assertEqual(divmod(12, 7), (1, 5)) - self.assertEqual(divmod(-12, 7), (-2, 2)) - self.assertEqual(divmod(12, -7), (-2, -2)) - self.assertEqual(divmod(-12, -7), (1, -5)) - - self.assertEqual(divmod(12, 7), (1, 5)) - self.assertEqual(divmod(-12, 7), (-2, 2)) - self.assertEqual(divmod(12, -7), (-2, -2)) - self.assertEqual(divmod(-12, -7), (1, -5)) - - self.assertEqual(divmod(12, 7), (1, 5)) - self.assertEqual(divmod(-12, 7), (-2, 2)) - self.assertEqual(divmod(12, -7), (-2, -2)) - self.assertEqual(divmod(-12, -7), (1, -5)) - - self.assertEqual(divmod(-sys.maxsize-1, -1), - (sys.maxsize+1, 0)) - - self.assertTrue(not fcmp(divmod(3.25, 1.0), (3.0, 0.25))) - self.assertTrue(not fcmp(divmod(-3.25, 1.0), (-4.0, 0.75))) - self.assertTrue(not fcmp(divmod(3.25, -1.0), (-4.0, -0.75))) - self.assertTrue(not fcmp(divmod(-3.25, -1.0), (3.0, -0.25))) - - self.assertRaises(TypeError, divmod) - - @expectedFailurePY3 - def test_eval(self): - self.assertEqual(eval('1+1'), 2) - self.assertEqual(eval(' 1+1\n'), 2) - globals = {'a': 1, 'b': 2} - locals = {'b': 200, 'c': 300} - self.assertEqual(eval('a', globals) , 1) - self.assertEqual(eval('a', globals, locals), 1) - self.assertEqual(eval('b', globals, locals), 200) - self.assertEqual(eval('c', globals, locals), 300) - if True: # Was: if have_unicode: - self.assertEqual(eval(unicode('1+1')), 2) - self.assertEqual(eval(unicode(' 1+1\n')), 2) - globals = {'a': 1, 'b': 2} - locals = {'b': 200, 'c': 300} - if True: # Was: if have_unicode: - self.assertEqual(eval(unicode('a'), globals), 1) - self.assertEqual(eval(unicode('a'), globals, locals), 1) - self.assertEqual(eval(unicode('b'), globals, locals), 200) - self.assertEqual(eval(unicode('c'), globals, locals), 300) - bom = '\xef\xbb\xbf' - self.assertEqual(eval(bom + 'a', globals, locals), 1) - self.assertEqual(eval(unicode('u"\xc3\xa5"', 'utf8'), globals), - unicode('\xc3\xa5', 'utf8')) - self.assertRaises(TypeError, eval) - self.assertRaises(TypeError, eval, ()) - - @expectedFailurePY3 - def test_general_eval(self): - # Tests that general mappings can be used for the locals argument - - class M: - "Test mapping interface versus possible calls from eval()." - def __getitem__(self, key): - if key == 'a': - return 12 - raise KeyError - def keys(self): - return list('xyz') - - m = M() - g = globals() - self.assertEqual(eval('a', g, m), 12) - self.assertRaises(NameError, eval, 'b', g, m) - self.assertEqual(eval('dir()', g, m), list('xyz')) - self.assertEqual(eval('globals()', g, m), g) - self.assertEqual(eval('locals()', g, m), m) - self.assertRaises(TypeError, eval, 'a', m) - class A: - "Non-mapping" - pass - m = A() - self.assertRaises(TypeError, eval, 'a', g, m) - - # Verify that dict subclasses work as well - class D(dict): - def __getitem__(self, key): - if key == 'a': - return 12 - return dict.__getitem__(self, key) - def keys(self): - return list('xyz') - - d = D() - self.assertEqual(eval('a', g, d), 12) - self.assertRaises(NameError, eval, 'b', g, d) - self.assertEqual(eval('dir()', g, d), list('xyz')) - self.assertEqual(eval('globals()', g, d), g) - self.assertEqual(eval('locals()', g, d), d) - - # Verify locals stores (used by list comps) - eval('[locals() for i in (2,3)]', g, d) - # eval('[locals() for i in (2,3)]', g, UserDict.UserDict()) - - class SpreadSheet: - "Sample application showing nested, calculated lookups." - _cells = {} - def __setitem__(self, key, formula): - self._cells[key] = formula - def __getitem__(self, key): - return eval(self._cells[key], globals(), self) - - ss = SpreadSheet() - ss['a1'] = '5' - ss['a2'] = 'a1*6' - ss['a3'] = 'a2*7' - self.assertEqual(ss['a3'], 210) - - # Verify that dir() catches a non-list returned by eval - # SF bug #1004669 - class C: - def __getitem__(self, item): - raise KeyError(item) - def keys(self): - return 'a' - self.assertRaises(TypeError, eval, 'dir()', globals(), C()) - - # Done outside of the method test_z to get the correct scope - z = 0 - f = open(TESTFN, 'w') - f.write('z = z+1\n') - f.write('z = z*2\n') - f.close() - if True: - # with check_py3k_warnings(("execfile.. not supported in 3.x", - # DeprecationWarning)): - execfile(TESTFN) - - def test_execfile(self): - global numruns - if numruns: - return - numruns += 1 - - globals = {'a': 1, 'b': 2} - locals = {'b': 200, 'c': 300} - - self.assertEqual(self.__class__.z, 2) - globals['z'] = 0 - execfile(TESTFN, globals) - self.assertEqual(globals['z'], 2) - locals['z'] = 0 - execfile(TESTFN, globals, locals) - self.assertEqual(locals['z'], 2) - - # This test only works if we pass in a Mapping type. - class M(dict): - "Test mapping interface versus possible calls from execfile()." - def __init__(self): - self.z = 10 - def __getitem__(self, key): - if key == 'z': - return self.z - raise KeyError - def __setitem__(self, key, value): - if key == 'z': - self.z = value - return - raise KeyError - - locals = M() - locals['z'] = 0 - execfile(TESTFN, globals, locals) - self.assertEqual(locals['z'], 2) - - unlink(TESTFN) - self.assertRaises(TypeError, execfile) - self.assertRaises(TypeError, execfile, TESTFN, {}, ()) - import os - self.assertRaises(IOError, execfile, os.curdir) - self.assertRaises(IOError, execfile, "I_dont_exist") - - @expectedFailurePY3 - def test_filter(self): - self.assertEqual(filter(lambda c: 'a' <= c <= 'z', 'Hello World'), 'elloorld') - self.assertEqual(filter(None, [1, 'hello', [], [3], '', None, 9, 0]), [1, 'hello', [3], 9]) - self.assertEqual(filter(lambda x: x > 0, [1, -3, 9, 0, 2]), [1, 9, 2]) - self.assertEqual(filter(None, Squares(10)), [1, 4, 9, 16, 25, 36, 49, 64, 81]) - self.assertEqual(filter(lambda x: x%2, Squares(10)), [1, 9, 25, 49, 81]) - def identity(item): - return 1 - filter(identity, Squares(5)) - self.assertRaises(TypeError, filter) - class BadSeq(object): - def __getitem__(self, index): - if index<4: - return 42 - raise ValueError - self.assertRaises(ValueError, filter, lambda x: x, BadSeq()) - def badfunc(): - pass - self.assertRaises(TypeError, filter, badfunc, range(5)) - - # test bltinmodule.c::filtertuple() - self.assertEqual(filter(None, (1, 2)), (1, 2)) - self.assertEqual(filter(lambda x: x>=3, (1, 2, 3, 4)), (3, 4)) - self.assertRaises(TypeError, filter, 42, (1, 2)) - - # test bltinmodule.c::filterstring() - self.assertEqual(filter(None, "12"), "12") - self.assertEqual(filter(lambda x: x>="3", "1234"), "34") - self.assertRaises(TypeError, filter, 42, "12") - class badstr(str): - def __getitem__(self, index): - raise ValueError - self.assertRaises(ValueError, filter, lambda x: x >="3", badstr("1234")) - - class badstr2(str): - def __getitem__(self, index): - return 42 - self.assertRaises(TypeError, filter, lambda x: x >=42, badstr2("1234")) - - class weirdstr(str): - def __getitem__(self, index): - return weirdstr(2*str.__getitem__(self, index)) - self.assertEqual(filter(lambda x: x>="33", weirdstr("1234")), "3344") - - class shiftstr(str): - def __getitem__(self, index): - return chr(ord(str.__getitem__(self, index))+1) - self.assertEqual(filter(lambda x: x>="3", shiftstr("1234")), "345") - - if True: # Was: if have_unicode: - # test bltinmodule.c::filterunicode() - self.assertEqual(filter(None, unicode("12")), unicode("12")) - self.assertEqual(filter(lambda x: x>="3", unicode("1234")), unicode("34")) - self.assertRaises(TypeError, filter, 42, unicode("12")) - self.assertRaises(ValueError, filter, lambda x: x >="3", badstr(unicode("1234"))) - - class badunicode(unicode): - def __getitem__(self, index): - return 42 - self.assertRaises(TypeError, filter, lambda x: x >=42, badunicode("1234")) - - class weirdunicode(unicode): - def __getitem__(self, index): - return weirdunicode(2*unicode.__getitem__(self, index)) - self.assertEqual( - filter(lambda x: x>=unicode("33"), weirdunicode("1234")), unicode("3344")) - - class shiftunicode(unicode): - def __getitem__(self, index): - return unichr(ord(unicode.__getitem__(self, index))+1) - self.assertEqual( - filter(lambda x: x>=unicode("3"), shiftunicode("1234")), - unicode("345") - ) - - @expectedFailurePY3 - def test_filter_subclasses(self): - # test that filter() never returns tuple, str or unicode subclasses - # and that the result always goes through __getitem__ - funcs = (None, bool, lambda x: True) - class tuple2(tuple): - def __getitem__(self, index): - return 2*tuple.__getitem__(self, index) - class str2(str): - def __getitem__(self, index): - return 2*str.__getitem__(self, index) - inputs = { - tuple2: {(): (), (1, 2, 3): (2, 4, 6)}, - str2: {"": "", "123": "112233"} - } - if True: # Was: if have_unicode: - class unicode2(unicode): - def __getitem__(self, index): - return 2*unicode.__getitem__(self, index) - inputs[unicode2] = { - unicode(): unicode(), - unicode("123"): unicode("112233") - } - - for (cls, inps) in inputs.items(): - for (inp, exp) in inps.items(): - # make sure the output goes through __getitem__ - # even if func is None - self.assertEqual( - filter(funcs[0], cls(inp)), - filter(funcs[1], cls(inp)) - ) - for func in funcs: - outp = filter(func, cls(inp)) - self.assertEqual(outp, exp) - self.assertTrue(not isinstance(outp, cls)) - - @expectedFailurePY3 - def test_getattr(self): - import sys - self.assertTrue(getattr(sys, 'stdout') is sys.stdout) - self.assertRaises(TypeError, getattr, sys, 1) - self.assertRaises(TypeError, getattr, sys, 1, "foo") - self.assertRaises(TypeError, getattr) - if True: # Was: have_unicode: - self.assertRaises(UnicodeError, getattr, sys, unichr(sys.maxunicode)) - - @expectedFailurePY3 - def test_hasattr(self): - import sys - self.assertTrue(hasattr(sys, 'stdout')) - self.assertRaises(TypeError, hasattr, sys, 1) - self.assertRaises(TypeError, hasattr) - if True: # Was: if have_unicode: - self.assertRaises(UnicodeError, hasattr, sys, unichr(sys.maxunicode)) - - # Check that hasattr allows SystemExit and KeyboardInterrupts by - class A: - def __getattr__(self, what): - raise KeyboardInterrupt - self.assertRaises(KeyboardInterrupt, hasattr, A(), "b") - class B: - def __getattr__(self, what): - raise SystemExit - self.assertRaises(SystemExit, hasattr, B(), "b") - - def test_hash(self): - hash(None) - self.assertEqual(hash(1), hash(1)) - self.assertEqual(hash(1), hash(1.0)) - hash('spam') - if True: # Was: if have_unicode: - self.assertEqual(hash('spam'), hash(unicode('spam'))) - hash((0,1,2,3)) - def f(): pass - self.assertRaises(TypeError, hash, []) - self.assertRaises(TypeError, hash, {}) - # Bug 1536021: Allow hash to return long objects - class X: - def __hash__(self): - return 2**100 - self.assertEqual(type(hash(X())), int) - class Y(object): - def __hash__(self): - return 2**100 - self.assertEqual(type(hash(Y())), int) - class Z(long): - def __hash__(self): - return self - self.assertEqual(hash(Z(42)), hash(42)) - - def test_hex(self): - self.assertEqual(hex(16), '0x10') - # self.assertEqual(hex(16L), '0x10L') - self.assertEqual(hex(-16), '-0x10') - # self.assertEqual(hex(-16L), '-0x10L') - self.assertRaises(TypeError, hex, {}) - - def test_id(self): - id(None) - id(1) - id(1) - id(1.0) - id('spam') - id((0,1,2,3)) - id([0,1,2,3]) - id({'spam': 1, 'eggs': 2, 'ham': 3}) - - # Test input() later, together with raw_input - - # test_int(): see test_int.py for int() tests. - - @expectedFailurePY3 - def test_intern(self): - self.assertRaises(TypeError, intern) - # This fails if the test is run twice with a constant string, - # therefore append the run counter - s = "never interned before " + str(numruns) - self.assertTrue(intern(s) is s) - s2 = s.swapcase().swapcase() - self.assertTrue(intern(s2) is s) - - # Subclasses of string can't be interned, because they - # provide too much opportunity for insane things to happen. - # We don't want them in the interned dict and if they aren't - # actually interned, we don't want to create the appearance - # that they are by allowing intern() to succeed. - class S(str): - def __hash__(self): - return 123 - - self.assertRaises(TypeError, intern, S("abc")) - - # It's still safe to pass these strings to routines that - # call intern internally, e.g. PyObject_SetAttr(). - s = S("abc") - setattr(s, s, s) - self.assertEqual(getattr(s, s), s) - - @expectedFailurePY3 - def test_iter(self): - self.assertRaises(TypeError, iter) - self.assertRaises(TypeError, iter, 42, 42) - lists = [("1", "2"), ["1", "2"], "12"] - if True: # Was: if have_unicode: - lists.append(unicode("12")) - for l in lists: - i = iter(l) - self.assertEqual(i.next(), '1') - self.assertEqual(i.next(), '2') - self.assertRaises(StopIteration, i.next) - - def test_isinstance(self): - class C: - pass - class D(C): - pass - class E: - pass - c = C() - d = D() - e = E() - self.assertTrue(isinstance(c, C)) - self.assertTrue(isinstance(d, C)) - self.assertTrue(not isinstance(e, C)) - self.assertTrue(not isinstance(c, D)) - self.assertTrue(not isinstance('foo', E)) - self.assertRaises(TypeError, isinstance, E, 'foo') - self.assertRaises(TypeError, isinstance) - - def test_issubclass(self): - class C: - pass - class D(C): - pass - class E: - pass - c = C() - d = D() - e = E() - self.assertTrue(issubclass(D, C)) - self.assertTrue(issubclass(C, C)) - self.assertTrue(not issubclass(C, D)) - self.assertRaises(TypeError, issubclass, 'foo', E) - self.assertRaises(TypeError, issubclass, E, 'foo') - self.assertRaises(TypeError, issubclass) - - @expectedFailurePY3 - def test_len(self): - self.assertEqual(len('123'), 3) - self.assertEqual(len(()), 0) - self.assertEqual(len((1, 2, 3, 4)), 4) - self.assertEqual(len([1, 2, 3, 4]), 4) - self.assertEqual(len({}), 0) - self.assertEqual(len({'a':1, 'b': 2}), 2) - class BadSeq: - def __len__(self): - raise ValueError - self.assertRaises(ValueError, len, BadSeq()) - self.assertRaises(TypeError, len, 2) - class ClassicStyle: pass - class NewStyle(object): pass - self.assertRaises(AttributeError, len, ClassicStyle()) - self.assertRaises(TypeError, len, NewStyle()) - - def test_map(self): - self.assertEqual( - map(None, 'hello world'), - ['h','e','l','l','o',' ','w','o','r','l','d'] - ) - self.assertEqual( - map(None, 'abcd', 'efg'), - [('a', 'e'), ('b', 'f'), ('c', 'g'), ('d', None)] - ) - self.assertEqual( - map(None, range(10)), - [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] - ) - self.assertEqual( - map(lambda x: x*x, range(1,4)), - [1, 4, 9] - ) - try: - from math import sqrt - except ImportError: - def sqrt(x): - return pow(x, 0.5) - self.assertEqual( - map(lambda x: map(sqrt,x), [[16, 4], [81, 9]]), - [[4.0, 2.0], [9.0, 3.0]] - ) - self.assertEqual( - map(lambda x, y: x+y, [1,3,2], [9,1,4]), - [10, 4, 6] - ) - - def plus(*v): - accu = 0 - for i in v: accu = accu + i - return accu - self.assertEqual( - map(plus, [1, 3, 7]), - [1, 3, 7] - ) - self.assertEqual( - map(plus, [1, 3, 7], [4, 9, 2]), - [1+4, 3+9, 7+2] - ) - self.assertEqual( - map(plus, [1, 3, 7], [4, 9, 2], [1, 1, 0]), - [1+4+1, 3+9+1, 7+2+0] - ) - self.assertEqual( - map(None, Squares(10)), - [0, 1, 4, 9, 16, 25, 36, 49, 64, 81] - ) - self.assertEqual( - map(int, Squares(10)), - [0, 1, 4, 9, 16, 25, 36, 49, 64, 81] - ) - self.assertEqual( - map(None, Squares(3), Squares(2)), - [(0,0), (1,1), (4,None)] - ) - # This fails on Py3: - # self.assertEqual( - # map(max, Squares(3), Squares(2)), - # [0, 1, 4] - # ) - self.assertRaises(TypeError, map) - self.assertRaises(TypeError, map, lambda x: x, 42) - self.assertEqual(map(None, [42]), [42]) - class BadSeq: - def __getitem__(self, index): - raise ValueError - self.assertRaises(ValueError, map, lambda x: x, BadSeq()) - def badfunc(x): - raise RuntimeError - self.assertRaises(RuntimeError, map, badfunc, range(5)) - - def test_max(self): - self.assertEqual(max('123123'), '3') - self.assertEqual(max(1, 2, 3), 3) - self.assertEqual(max((1, 2, 3, 1, 2, 3)), 3) - self.assertEqual(max([1, 2, 3, 1, 2, 3]), 3) - - self.assertEqual(max(1, 2, 3.0), 3.0) - self.assertEqual(max(1, 2.0, 3), 3) - self.assertEqual(max(1.0, 2, 3), 3) - - for stmt in ( - "max(key=int)", # no args - "max(1, key=int)", # single arg not iterable - "max(1, 2, keystone=int)", # wrong keyword - "max(1, 2, key=int, abc=int)", # two many keywords - "max(1, 2, key=1)", # keyfunc is not callable - ): - try: - exec(stmt) in globals() - except TypeError: - pass - else: - self.fail(stmt) - - self.assertEqual(max((1,), key=neg), 1) # one elem iterable - self.assertEqual(max((1,2), key=neg), 1) # two elem iterable - self.assertEqual(max(1, 2, key=neg), 1) # two elems - - data = [random.randrange(200) for i in range(100)] - keys = dict((elem, random.randrange(50)) for elem in data) - f = keys.__getitem__ - self.assertEqual(max(data, key=f), - sorted(reversed(data), key=f)[-1]) - - @expectedFailurePY3 - def test_min(self): - self.assertEqual(min('123123'), '1') - self.assertEqual(min(1, 2, 3), 1) - self.assertEqual(min((1, 2, 3, 1, 2, 3)), 1) - self.assertEqual(min([1, 2, 3, 1, 2, 3]), 1) - - self.assertEqual(min(1, 2, 3.0), 1) - self.assertEqual(min(1, 2.0, 3), 1) - self.assertEqual(min(1.0, 2, 3), 1.0) - - self.assertRaises(TypeError, min) - self.assertRaises(TypeError, min, 42) - self.assertRaises(ValueError, min, ()) - class BadSeq: - def __getitem__(self, index): - raise ValueError - self.assertRaises(ValueError, min, BadSeq()) - class BadNumber: - def __cmp__(self, other): - raise ValueError - self.assertRaises(ValueError, min, (42, BadNumber())) - - for stmt in ( - "min(key=int)", # no args - "min(1, key=int)", # single arg not iterable - "min(1, 2, keystone=int)", # wrong keyword - "min(1, 2, key=int, abc=int)", # two many keywords - "min(1, 2, key=1)", # keyfunc is not callable - ): - try: - exec(stmt) in globals() - except TypeError: - pass - else: - self.fail(stmt) - - self.assertEqual(min((1,), key=neg), 1) # one elem iterable - self.assertEqual(min((1,2), key=neg), 2) # two elem iterable - self.assertEqual(min(1, 2, key=neg), 2) # two elems - - data = [random.randrange(200) for i in range(100)] - keys = dict((elem, random.randrange(50)) for elem in data) - f = keys.__getitem__ - self.assertEqual(min(data, key=f), - sorted(data, key=f)[0]) - - @expectedFailurePY3 - def test_next(self): - it = iter(range(2)) - self.assertEqual(next(it), 0) - self.assertEqual(next(it), 1) - self.assertRaises(StopIteration, next, it) - self.assertRaises(StopIteration, next, it) - self.assertEqual(next(it, 42), 42) - - class Iter(object): - def __iter__(self): - return self - def next(self): - raise StopIteration - - it = iter(Iter()) - self.assertEqual(next(it, 42), 42) - self.assertRaises(StopIteration, next, it) - - def gen(): - yield 1 - return - - it = gen() - self.assertEqual(next(it), 1) - self.assertRaises(StopIteration, next, it) - self.assertEqual(next(it, 42), 42) - - @expectedFailurePY3 - def test_oct(self): - self.assertEqual(oct(100), '0144') - # self.assertEqual(oct(100L), '0144L') - self.assertEqual(oct(-100), '-0144') - # self.assertEqual(oct(-100L), '-0144L') - self.assertRaises(TypeError, oct, ()) - - def write_testfile(self): - # NB the first 4 lines are also used to test input and raw_input, below - fp = open(TESTFN, 'w') - try: - fp.write('1+1\n') - fp.write('1+1\n') - fp.write('The quick brown fox jumps over the lazy dog') - fp.write('.\n') - fp.write('Dear John\n') - fp.write('XXX'*100) - fp.write('YYY'*100) - finally: - fp.close() - - def test_open(self): - self.write_testfile() - fp = open(TESTFN, 'r') - try: - self.assertEqual(fp.readline(4), '1+1\n') - self.assertEqual(fp.readline(4), '1+1\n') - self.assertEqual(fp.readline(), 'The quick brown fox jumps over the lazy dog.\n') - self.assertEqual(fp.readline(4), 'Dear') - self.assertEqual(fp.readline(100), ' John\n') - self.assertEqual(fp.read(300), 'XXX'*100) - self.assertEqual(fp.read(1000), 'YYY'*100) - finally: - fp.close() - unlink(TESTFN) - - @expectedFailurePY3 - def test_ord(self): - self.assertEqual(ord(' '), 32) - self.assertEqual(ord('A'), 65) - self.assertEqual(ord('a'), 97) - if True: # Was: if have_unicode: - self.assertEqual(ord(unichr(sys.maxunicode)), sys.maxunicode) - self.assertRaises(TypeError, ord, 42) - if True: # Was: if have_unicode: - self.assertRaises(TypeError, ord, unicode("12")) - - @expectedFailurePY3 - def test_pow(self): - self.assertEqual(pow(0,0), 1) - self.assertEqual(pow(0,1), 0) - self.assertEqual(pow(1,0), 1) - self.assertEqual(pow(1,1), 1) - - self.assertEqual(pow(2,0), 1) - self.assertEqual(pow(2,10), 1024) - self.assertEqual(pow(2,20), 1024*1024) - self.assertEqual(pow(2,30), 1024*1024*1024) - - self.assertEqual(pow(-2,0), 1) - self.assertEqual(pow(-2,1), -2) - self.assertEqual(pow(-2,2), 4) - self.assertEqual(pow(-2,3), -8) - - self.assertEqual(pow(0,0), 1) - self.assertEqual(pow(0,1), 0) - self.assertEqual(pow(1,0), 1) - self.assertEqual(pow(1,1), 1) - - self.assertEqual(pow(2,0), 1) - self.assertEqual(pow(2,10), 1024) - self.assertEqual(pow(2,20), 1024*1024) - self.assertEqual(pow(2,30), 1024*1024*1024) - - self.assertEqual(pow(-2,0), 1) - self.assertEqual(pow(-2,1), -2) - self.assertEqual(pow(-2,2), 4) - self.assertEqual(pow(-2,3), -8) - - self.assertAlmostEqual(pow(0.,0), 1.) - self.assertAlmostEqual(pow(0.,1), 0.) - self.assertAlmostEqual(pow(1.,0), 1.) - self.assertAlmostEqual(pow(1.,1), 1.) - - self.assertAlmostEqual(pow(2.,0), 1.) - self.assertAlmostEqual(pow(2.,10), 1024.) - self.assertAlmostEqual(pow(2.,20), 1024.*1024.) - self.assertAlmostEqual(pow(2.,30), 1024.*1024.*1024.) - - self.assertAlmostEqual(pow(-2.,0), 1.) - self.assertAlmostEqual(pow(-2.,1), -2.) - self.assertAlmostEqual(pow(-2.,2), 4.) - self.assertAlmostEqual(pow(-2.,3), -8.) - - for x in 2, 2, 2.0: - for y in 10, 10, 10.0: - for z in 1000, 1000, 1000.0: - if isinstance(x, float) or \ - isinstance(y, float) or \ - isinstance(z, float): - self.assertRaises(TypeError, pow, x, y, z) - else: - self.assertAlmostEqual(pow(x, y, z), 24.0) - - self.assertRaises(TypeError, pow, -1, -2, 3) - self.assertRaises(ValueError, pow, 1, 2, 0) - self.assertRaises(TypeError, pow, -1, -2, 3) - self.assertRaises(ValueError, pow, 1, 2, 0) - # Will return complex in 3.0: - self.assertRaises(ValueError, pow, -342.43, 0.234) - - self.assertRaises(TypeError, pow) - - @skip26 - @expectedFailurePY3 - def test_range(self): - self.assertEqual(range(3), [0, 1, 2]) - self.assertEqual(range(1, 5), [1, 2, 3, 4]) - self.assertEqual(range(0), []) - self.assertEqual(range(-3), []) - self.assertEqual(range(1, 10, 3), [1, 4, 7]) - self.assertEqual(range(5, -5, -3), [5, 2, -1, -4]) - - # Now test range() with longs - self.assertEqual(range(-2**100), []) - self.assertEqual(range(0, -2**100), []) - self.assertEqual(range(0, 2**100, -1), []) - self.assertEqual(range(0, 2**100, -1), []) - - a = long(10 * sys.maxsize) - b = long(100 * sys.maxsize) - c = long(50 * sys.maxsize) - - self.assertEqual(range(a, a+2), [a, a+1]) - self.assertEqual(range(a+2, a, -1), [a+2, a+1]) - self.assertEqual(range(a+4, a, -2), [a+4, a+2]) - - seq = range(a, b, c) - self.assertIn(a, seq) - self.assertNotIn(b, seq) - self.assertEqual(len(seq), 2) - - seq = range(b, a, -c) - self.assertIn(b, seq) - self.assertNotIn(a, seq) - self.assertEqual(len(seq), 2) - - seq = range(-a, -b, -c) - self.assertIn(-a, seq) - self.assertNotIn(-b, seq) - self.assertEqual(len(seq), 2) - - self.assertRaises(TypeError, range) - self.assertRaises(TypeError, range, 1, 2, 3, 4) - self.assertRaises(ValueError, range, 1, 2, 0) - self.assertRaises(ValueError, range, a, a + 1, long(0)) - - class badzero(int): - def __cmp__(self, other): - raise RuntimeError - __hash__ = None # Invalid cmp makes this unhashable - self.assertRaises(RuntimeError, range, a, a + 1, badzero(1)) - - # Reject floats. - self.assertRaises(TypeError, range, 1., 1., 1.) - self.assertRaises(TypeError, range, 1e100, 1e101, 1e101) - - self.assertRaises(TypeError, range, 0, "spam") - self.assertRaises(TypeError, range, 0, 42, "spam") - - self.assertRaises(OverflowError, range, -sys.maxsize, sys.maxsize) - self.assertRaises(OverflowError, range, 0, 2*sys.maxsize) - - bignum = 2*sys.maxsize - smallnum = 42 - # Old-style user-defined class with __int__ method - class I0: - def __init__(self, n): - self.n = int(n) - def __int__(self): - return self.n - self.assertEqual(range(I0(bignum), I0(bignum + 1)), [bignum]) - self.assertEqual(range(I0(smallnum), I0(smallnum + 1)), [smallnum]) - - # New-style user-defined class with __int__ method - class I1(object): - def __init__(self, n): - self.n = int(n) - def __int__(self): - return self.n - self.assertEqual(range(I1(bignum), I1(bignum + 1)), [bignum]) - self.assertEqual(range(I1(smallnum), I1(smallnum + 1)), [smallnum]) - - # New-style user-defined class with failing __int__ method - class IX(object): - def __int__(self): - raise RuntimeError - self.assertRaises(RuntimeError, range, IX()) - - # New-style user-defined class with invalid __int__ method - class IN(object): - def __int__(self): - return "not a number" - self.assertRaises(TypeError, range, IN()) - - # Exercise various combinations of bad arguments, to check - # refcounting logic - self.assertRaises(TypeError, range, 0.0) - - self.assertRaises(TypeError, range, 0, 0.0) - self.assertRaises(TypeError, range, 0.0, 0) - self.assertRaises(TypeError, range, 0.0, 0.0) - - self.assertRaises(TypeError, range, 0, 0, 1.0) - self.assertRaises(TypeError, range, 0, 0.0, 1) - self.assertRaises(TypeError, range, 0, 0.0, 1.0) - self.assertRaises(TypeError, range, 0.0, 0, 1) - self.assertRaises(TypeError, range, 0.0, 0, 1.0) - self.assertRaises(TypeError, range, 0.0, 0.0, 1) - self.assertRaises(TypeError, range, 0.0, 0.0, 1.0) - - @expectedFailurePY3 - def test_input_and_raw_input(self): - self.write_testfile() - fp = open(TESTFN, 'r') - savestdin = sys.stdin - savestdout = sys.stdout # Eats the echo - try: - sys.stdin = fp - sys.stdout = BitBucket() - self.assertEqual(input(), 2) - self.assertEqual(input('testing\n'), 2) - self.assertEqual(raw_input(), 'The quick brown fox jumps over the lazy dog.') - self.assertEqual(raw_input('testing\n'), 'Dear John') - - # SF 1535165: don't segfault on closed stdin - # sys.stdout must be a regular file for triggering - sys.stdout = savestdout - sys.stdin.close() - self.assertRaises(ValueError, input) - - sys.stdout = BitBucket() - sys.stdin = io.BytesIO(b"NULL\0") - self.assertRaises(TypeError, input, 42, 42) - sys.stdin = io.BytesIO(b" 'whitespace'") - self.assertEqual(input(), 'whitespace') - sys.stdin = io.BytesIO() - self.assertRaises(EOFError, input) - - # SF 876178: make sure input() respect future options. - sys.stdin = io.BytesIO(b'1/2') - sys.stdout = io.BytesIO() - exec(compile('print(input())', 'test_builtin_tmp', 'exec')) - sys.stdin.seek(0, 0) - exec(compile('from __future__ import division;print(input())', - 'test_builtin_tmp', 'exec')) - sys.stdin.seek(0, 0) - exec(compile('print(input())', 'test_builtin_tmp', 'exec')) - # The result we expect depends on whether new division semantics - # are already in effect. - if 1/2 == 0: - # This test was compiled with old semantics. - expected = ['0', '0.5', '0'] - else: - # This test was compiled with new semantics (e.g., -Qnew - # was given on the command line. - expected = ['0.5', '0.5', '0.5'] - self.assertEqual(sys.stdout.getvalue().splitlines(), expected) - - del sys.stdout - self.assertRaises(RuntimeError, input, 'prompt') - del sys.stdin - self.assertRaises(RuntimeError, input, 'prompt') - finally: - sys.stdin = savestdin - sys.stdout = savestdout - fp.close() - unlink(TESTFN) - - def test_reduce(self): - add = lambda x, y: x+y - self.assertEqual(reduce(add, ['a', 'b', 'c'], ''), 'abc') - self.assertEqual( - reduce(add, [['a', 'c'], [], ['d', 'w']], []), - ['a','c','d','w'] - ) - self.assertEqual(reduce(lambda x, y: x*y, range(2,8), 1), 5040) - self.assertEqual( - reduce(lambda x, y: x*y, range(2,21), 1), - 2432902008176640000 - ) - self.assertEqual(reduce(add, Squares(10)), 285) - self.assertEqual(reduce(add, Squares(10), 0), 285) - self.assertEqual(reduce(add, Squares(0), 0), 0) - self.assertRaises(TypeError, reduce) - self.assertRaises(TypeError, reduce, 42) - self.assertRaises(TypeError, reduce, 42, 42) - self.assertRaises(TypeError, reduce, 42, 42, 42) - self.assertRaises(TypeError, reduce, None, range(5)) - self.assertRaises(TypeError, reduce, add, 42) - self.assertEqual(reduce(42, "1"), "1") # func is never called with one item - self.assertEqual(reduce(42, "", "1"), "1") # func is never called with one item - self.assertRaises(TypeError, reduce, 42, (42, 42)) - self.assertRaises(TypeError, reduce, add, []) # arg 2 must not be empty sequence with no initial value - self.assertRaises(TypeError, reduce, add, "") - self.assertRaises(TypeError, reduce, add, ()) - self.assertEqual(reduce(add, [], None), None) - self.assertEqual(reduce(add, [], 42), 42) - - class BadSeq: - def __getitem__(self, index): - raise ValueError - self.assertRaises(ValueError, reduce, 42, BadSeq()) - - def test_reload(self): - import marshal - reload(marshal) - import string - reload(string) - ## import sys - ## self.assertRaises(ImportError, reload, sys) - - def test_repr(self): - self.assertEqual(repr(''), '\'\'') - self.assertEqual(repr(0), '0') - # self.assertEqual(repr(0L), '0L') - self.assertEqual(repr(()), '()') - self.assertEqual(repr([]), '[]') - self.assertEqual(repr({}), '{}') - a = [] - a.append(a) - self.assertEqual(repr(a), '[[...]]') - a = {} - a[0] = a - self.assertEqual(repr(a), '{0: {...}}') - - @expectedFailurePY3 - def test_round(self): - self.assertEqual(round(0.0), 0.0) - self.assertEqual(type(round(0.0)), float) # Will be int in 3.0. - self.assertEqual(round(1.0), 1.0) - self.assertEqual(round(10.0), 10.0) - self.assertEqual(round(1000000000.0), 1000000000.0) - self.assertEqual(round(1e20), 1e20) - - self.assertEqual(round(-1.0), -1.0) - self.assertEqual(round(-10.0), -10.0) - self.assertEqual(round(-1000000000.0), -1000000000.0) - self.assertEqual(round(-1e20), -1e20) - - self.assertEqual(round(0.1), 0.0) - self.assertEqual(round(1.1), 1.0) - self.assertEqual(round(10.1), 10.0) - self.assertEqual(round(1000000000.1), 1000000000.0) - - self.assertEqual(round(-1.1), -1.0) - self.assertEqual(round(-10.1), -10.0) - self.assertEqual(round(-1000000000.1), -1000000000.0) - - self.assertEqual(round(0.9), 1.0) - self.assertEqual(round(9.9), 10.0) - self.assertEqual(round(999999999.9), 1000000000.0) - - self.assertEqual(round(-0.9), -1.0) - self.assertEqual(round(-9.9), -10.0) - self.assertEqual(round(-999999999.9), -1000000000.0) - - self.assertEqual(round(-8.0, -1), -10.0) - self.assertEqual(type(round(-8.0, -1)), float) - - self.assertEqual(type(round(-8.0, 0)), float) - self.assertEqual(type(round(-8.0, 1)), float) - - # Check half rounding behaviour. - self.assertEqual(round(5.5), 6) - self.assertEqual(round(6.5), 7) - self.assertEqual(round(-5.5), -6) - self.assertEqual(round(-6.5), -7) - - # Check behavior on ints - self.assertEqual(round(0), 0) - self.assertEqual(round(8), 8) - self.assertEqual(round(-8), -8) - self.assertEqual(type(round(0)), float) # Will be int in 3.0. - self.assertEqual(type(round(-8, -1)), float) - self.assertEqual(type(round(-8, 0)), float) - self.assertEqual(type(round(-8, 1)), float) - - # test new kwargs - self.assertEqual(round(number=-8.0, ndigits=-1), -10.0) - - self.assertRaises(TypeError, round) - - # test generic rounding delegation for reals - class TestRound(object): - def __float__(self): - return 23.0 - - class TestNoRound(object): - pass - - self.assertEqual(round(TestRound()), 23) - - self.assertRaises(TypeError, round, 1, 2, 3) - self.assertRaises(TypeError, round, TestNoRound()) - - t = TestNoRound() - t.__float__ = lambda *args: args - self.assertRaises(TypeError, round, t) - self.assertRaises(TypeError, round, t, 0) - - # Some versions of glibc for alpha have a bug that affects - # float -> integer rounding (floor, ceil, rint, round) for - # values in the range [2**52, 2**53). See: - # - # http://sources.redhat.com/bugzilla/show_bug.cgi?id=5350 - # - # We skip this test on Linux/alpha if it would fail. - linux_alpha = (platform.system().startswith('Linux') and - platform.machine().startswith('alpha')) - system_round_bug = round(5e15+1) != 5e15+1 - @unittest.skipIf(linux_alpha and system_round_bug, - "test will fail; failure is probably due to a " - "buggy system round function") - def test_round_large(self): - # Issue #1869: integral floats should remain unchanged - self.assertEqual(round(5e15-1), 5e15-1) - self.assertEqual(round(5e15), 5e15) - self.assertEqual(round(5e15+1), 5e15+1) - self.assertEqual(round(5e15+2), 5e15+2) - self.assertEqual(round(5e15+3), 5e15+3) - - def test_setattr(self): - setattr(sys, 'spam', 1) - self.assertEqual(sys.spam, 1) - self.assertRaises(TypeError, setattr, sys, 1, 'spam') - self.assertRaises(TypeError, setattr) - - def test_sum(self): - self.assertEqual(sum([]), 0) - self.assertEqual(sum(range(2,8)), 27) - self.assertEqual(sum(iter(range(2,8))), 27) - self.assertEqual(sum(Squares(10)), 285) - self.assertEqual(sum(iter(Squares(10))), 285) - self.assertEqual(sum([[1], [2], [3]], []), [1, 2, 3]) - - self.assertRaises(TypeError, sum) - self.assertRaises(TypeError, sum, 42) - self.assertRaises(TypeError, sum, ['a', 'b', 'c']) - self.assertRaises(TypeError, sum, ['a', 'b', 'c'], '') - self.assertRaises(TypeError, sum, [[1], [2], [3]]) - self.assertRaises(TypeError, sum, [{2:3}]) - self.assertRaises(TypeError, sum, [{2:3}]*2, {2:3}) - - class BadSeq: - def __getitem__(self, index): - raise ValueError - self.assertRaises(ValueError, sum, BadSeq()) - - empty = [] - sum(([x] for x in range(10)), empty) - self.assertEqual(empty, []) - - def test_type(self): - self.assertEqual(type(''), type('123')) - self.assertNotEqual(type(''), type(())) - - @expectedFailurePY3 - def test_unichr(self): - if True: # Was: if have_unicode: - self.assertEqual(unichr(32), unicode(' ')) - self.assertEqual(unichr(65), unicode('A')) - self.assertEqual(unichr(97), unicode('a')) - self.assertEqual( - unichr(sys.maxunicode), - unicode('\\U%08x' % (sys.maxunicode), 'unicode-escape') - ) - self.assertRaises(ValueError, unichr, sys.maxunicode+1) - self.assertRaises(TypeError, unichr) - self.assertRaises((OverflowError, ValueError), unichr, 2**32) - - # We don't want self in vars(), so these are static methods - - @staticmethod - def get_vars_f0(): - return vars() - - @staticmethod - def get_vars_f2(): - BuiltinTest.get_vars_f0() - a = 1 - b = 2 - return vars() - - class C_get_vars(object): - def getDict(self): - return {'a':2} - __dict__ = property(fget=getDict) - - def test_vars(self): - self.assertEqual(set(vars()), set(dir())) - import sys - self.assertEqual(set(vars(sys)), set(dir(sys))) - self.assertEqual(self.get_vars_f0(), {}) - self.assertEqual(self.get_vars_f2(), {'a': 1, 'b': 2}) - self.assertRaises(TypeError, vars, 42, 42) - self.assertRaises(TypeError, vars, 42) - self.assertEqual(vars(self.C_get_vars()), {'a':2}) - - def test_zip(self): - a = (1, 2, 3) - b = (4, 5, 6) - t = [(1, 4), (2, 5), (3, 6)] - self.assertEqual(zip(a, b), t) - b = [4, 5, 6] - self.assertEqual(zip(a, b), t) - b = (4, 5, 6, 7) - self.assertEqual(zip(a, b), t) - class I: - def __getitem__(self, i): - if i < 0 or i > 2: raise IndexError - return i + 4 - self.assertEqual(zip(a, I()), t) - self.assertEqual(zip(), []) - self.assertEqual(zip(*[]), []) - self.assertRaises(TypeError, zip, None) - class G: - pass - self.assertRaises(TypeError, zip, a, G()) - - # Make sure zip doesn't try to allocate a billion elements for the - # result list when one of its arguments doesn't say how long it is. - # A MemoryError is the most likely failure mode. - class SequenceWithoutALength: - def __getitem__(self, i): - if i == 5: - raise IndexError - else: - return i - self.assertEqual( - zip(SequenceWithoutALength(), xrange(2**30)), - list(enumerate(range(5))) - ) - - class BadSeq: - def __getitem__(self, i): - if i == 5: - raise ValueError - else: - return i - self.assertRaises(ValueError, zip, BadSeq(), BadSeq()) - - @skip26 - @expectedFailurePY3 - def test_format(self): - # Test the basic machinery of the format() builtin. Don't test - # the specifics of the various formatters - self.assertEqual(format(3, ''), '3') - - # Returns some classes to use for various tests. There's - # an old-style version, and a new-style version - def classes_new(): - class A(object): - def __init__(self, x): - self.x = x - def __format__(self, format_spec): - return str(self.x) + format_spec - class DerivedFromA(A): - pass - - class Simple(object): pass - class DerivedFromSimple(Simple): - def __init__(self, x): - self.x = x - def __format__(self, format_spec): - return str(self.x) + format_spec - class DerivedFromSimple2(DerivedFromSimple): pass - return A, DerivedFromA, DerivedFromSimple, DerivedFromSimple2 - - # In 3.0, classes_classic has the same meaning as classes_new - def classes_classic(): - class A: - def __init__(self, x): - self.x = x - def __format__(self, format_spec): - return str(self.x) + format_spec - class DerivedFromA(A): - pass - - class Simple: pass - class DerivedFromSimple(Simple): - def __init__(self, x): - self.x = x - def __format__(self, format_spec): - return str(self.x) + format_spec - class DerivedFromSimple2(DerivedFromSimple): pass - return A, DerivedFromA, DerivedFromSimple, DerivedFromSimple2 - - def class_test(A, DerivedFromA, DerivedFromSimple, DerivedFromSimple2): - self.assertEqual(format(A(3), 'spec'), '3spec') - self.assertEqual(format(DerivedFromA(4), 'spec'), '4spec') - self.assertEqual(format(DerivedFromSimple(5), 'abc'), '5abc') - self.assertEqual(format(DerivedFromSimple2(10), 'abcdef'), - '10abcdef') - - class_test(*classes_new()) - class_test(*classes_classic()) - - def empty_format_spec(value): - # test that: - # format(x, '') == str(x) - # format(x) == str(x) - self.assertEqual(format(value, ""), str(value)) - self.assertEqual(format(value), str(value)) - - # for builtin types, format(x, "") == str(x) - empty_format_spec(17**13) - empty_format_spec(1.0) - empty_format_spec(3.1415e104) - empty_format_spec(-3.1415e104) - empty_format_spec(3.1415e-104) - empty_format_spec(-3.1415e-104) - empty_format_spec(object) - empty_format_spec(None) - - # TypeError because self.__format__ returns the wrong type - class BadFormatResult: - def __format__(self, format_spec): - return 1.0 - self.assertRaises(TypeError, format, BadFormatResult(), "") - - # TypeError because format_spec is not unicode or str - self.assertRaises(TypeError, format, object(), 4) - self.assertRaises(TypeError, format, object(), object()) - - # tests for object.__format__ really belong elsewhere, but - # there's no good place to put them - x = object().__format__('') - self.assertTrue(x.startswith('<object object at')) - - # first argument to object.__format__ must be string - self.assertRaises(TypeError, object().__format__, 3) - self.assertRaises(TypeError, object().__format__, object()) - self.assertRaises(TypeError, object().__format__, None) - - # -------------------------------------------------------------------- - # Issue #7994: object.__format__ with a non-empty format string is - # pending deprecated - def test_deprecated_format_string(obj, fmt_str, should_raise_warning): - if sys.version_info[0] == 3 and sys.version_info[1] >= 4: - if should_raise_warning: - self.assertRaises(TypeError, format, obj, fmt_str) - else: - try: - format(obj, fmt_str) - except TypeError: - self.fail('object.__format__ raised TypeError unexpectedly') - else: - with warnings.catch_warnings(record=True) as w: - warnings.simplefilter("always", PendingDeprecationWarning) - format(obj, fmt_str) - if should_raise_warning: - self.assertEqual(len(w), 1) - self.assertIsInstance(w[0].message, PendingDeprecationWarning) - self.assertIn('object.__format__ with a non-empty format ' - 'string', str(w[0].message)) - else: - self.assertEqual(len(w), 0) - - fmt_strs = ['', 's', u'', u's'] - - class A: - def __format__(self, fmt_str): - return format('', fmt_str) - - for fmt_str in fmt_strs: - test_deprecated_format_string(A(), fmt_str, False) - - class B: - pass - - class C(object): - pass - - for cls in [object, B, C]: - for fmt_str in fmt_strs: - test_deprecated_format_string(cls(), fmt_str, len(fmt_str) != 0) - # -------------------------------------------------------------------- - - # make sure we can take a subclass of str as a format spec - class DerivedFromStr(str): pass - self.assertEqual(format(0, DerivedFromStr('10')), ' 0') - - def test_bin(self): - self.assertEqual(bin(0), '0b0') - self.assertEqual(bin(1), '0b1') - self.assertEqual(bin(-1), '-0b1') - self.assertEqual(bin(2**65), '0b1' + '0' * 65) - self.assertEqual(bin(2**65-1), '0b' + '1' * 65) - self.assertEqual(bin(-(2**65)), '-0b1' + '0' * 65) - self.assertEqual(bin(-(2**65-1)), '-0b' + '1' * 65) - - @expectedFailurePY3 - def test_bytearray_translate(self): - x = bytearray(b"abc") - self.assertRaises(ValueError, x.translate, "1", 1) - self.assertRaises(TypeError, x.translate, "1"*256, 1) - -class TestSorted(unittest.TestCase): - - @expectedFailurePY3 - def test_basic(self): - data = range(100) - copy = data[:] - random.shuffle(copy) - self.assertEqual(data, sorted(copy)) - self.assertNotEqual(data, copy) - - data.reverse() - random.shuffle(copy) - self.assertEqual(data, sorted(copy, cmp=lambda x, y: cmp(y,x))) - self.assertNotEqual(data, copy) - random.shuffle(copy) - self.assertEqual(data, sorted(copy, key=lambda x: -x)) - self.assertNotEqual(data, copy) - random.shuffle(copy) - self.assertEqual(data, sorted(copy, reverse=1)) - self.assertNotEqual(data, copy) - - def test_inputtypes(self): - s = 'abracadabra' - types = [list, tuple] - if True: # Was: if have_unicode: - types.insert(0, unicode) - for T in types: - self.assertEqual(sorted(s), sorted(T(s))) - - s = ''.join(dict.fromkeys(s).keys()) # unique letters only - types = [set, frozenset, list, tuple, dict.fromkeys] - if True: # Was: if have_unicode: - types.insert(0, unicode) - for T in types: - self.assertEqual(sorted(s), sorted(T(s))) - - def test_baddecorator(self): - data = 'The quick Brown fox Jumped over The lazy Dog'.split() - self.assertRaises(TypeError, sorted, data, None, lambda x,y: 0) - -# def _run_unittest(*args): -# # with check_py3k_warnings( -# # (".+ not supported in 3.x", DeprecationWarning), -# # (".+ is renamed to imp.reload", DeprecationWarning), -# # ("classic int division", DeprecationWarning)): -# if True: -# run_unittest(*args) -# -# def test_main(verbose=None): -# test_classes = (BuiltinTest, TestSorted) -# -# _run_unittest(*test_classes) -# -# # verify reference counting -# if verbose and hasattr(sys, "gettotalrefcount"): -# import gc -# counts = [None] * 5 -# for i in xrange(len(counts)): -# _run_unittest(*test_classes) -# gc.collect() -# counts[i] = sys.gettotalrefcount() -# print(counts) - - -if __name__ == "__main__": - # test_main(verbose=True) - unittest.main() diff --git a/FOSS/Python/Dependencies/future-0.18.2/tests/test_past/test_noniterators.py b/FOSS/Python/Dependencies/future-0.18.2/tests/test_past/test_noniterators.py deleted file mode 100644 index 518109c..0000000 --- a/FOSS/Python/Dependencies/future-0.18.2/tests/test_past/test_noniterators.py +++ /dev/null @@ -1,34 +0,0 @@ -# -*- coding: utf-8 -*- -""" -Tests for the Py2-like list-producing functions -""" - -from __future__ import absolute_import, unicode_literals, print_function -import os - -from past import utils -from future.tests.base import unittest -from past.builtins import filter, map, range, zip - - -class TestNonIterators(unittest.TestCase): - - def test_noniterators_produce_lists(self): - l = range(10) - self.assertTrue(isinstance(l, list)) - - l2 = zip(l, list('ABCDE')*2) - self.assertTrue(isinstance(l2, list)) - - double = lambda x: x*2 - l3 = map(double, l) - self.assertTrue(isinstance(l3, list)) - - is_odd = lambda x: x % 2 == 1 - l4 = filter(is_odd, range(10)) - self.assertEqual(l4, [1, 3, 5, 7, 9]) - self.assertTrue(isinstance(l4, list)) - - -if __name__ == '__main__': - unittest.main() diff --git a/FOSS/Python/Dependencies/future-0.18.2/tests/test_past/test_olddict.py b/FOSS/Python/Dependencies/future-0.18.2/tests/test_past/test_olddict.py deleted file mode 100644 index 9f21060..0000000 --- a/FOSS/Python/Dependencies/future-0.18.2/tests/test_past/test_olddict.py +++ /dev/null @@ -1,791 +0,0 @@ -# -*- coding: utf-8 -*- -""" -Tests for the resurrected Py2-like class:`dict` type. -""" - -from __future__ import absolute_import, unicode_literals, print_function -import os -import sys - -from future.utils import implements_iterator, PY3 -from future.tests.base import unittest, skip26 -from past.builtins import dict - - -class TestOldDict(unittest.TestCase): - def setUp(self): - self.d1 = dict({'C': 1, 'B': 2, 'A': 3}) - self.d2 = dict(key1='value1', key2='value2') - - def test_dict_empty(self): - """ - dict() -> {} - """ - self.assertEqual(dict(), {}) - - def test_dict_eq(self): - d = self.d1 - self.assertEqual(dict(d), d) - - def test_dict_keys(self): - """ - The keys, values and items methods should now return lists on - Python 3.x. - """ - d = self.d1 - self.assertEqual(set(dict(d)), set(d)) - self.assertEqual(set(dict(d).keys()), set(d.keys())) - keys = dict(d).keys() - assert isinstance(keys, list) - key0 = keys[0] - - def test_dict_values(self): - d = self.d1 - self.assertEqual(set(dict(d).values()), set(d.values())) - values = dict(d).values() - assert isinstance(values, list) - val0 = values[0] - - def test_dict_items(self): - d = self.d1 - self.assertEqual(set(dict(d).items()), set(d.items())) - items = dict(d).items() - assert isinstance(items, list) - item0 = items[0] - - def test_isinstance_dict(self): - self.assertTrue(isinstance(self.d1, dict)) - - def test_dict_getitem(self): - d = dict({'C': 1, 'B': 2, 'A': 3}) - self.assertEqual(d['C'], 1) - self.assertEqual(d['B'], 2) - self.assertEqual(d['A'], 3) - with self.assertRaises(KeyError): - self.assertEqual(d['D']) - - def test_methods_produce_lists(self): - for d in (dict(self.d1), self.d2): - assert isinstance(d.keys(), list) - assert isinstance(d.values(), list) - assert isinstance(d.items(), list) - - @unittest.skipIf(sys.version_info[:2] == (2, 6), - 'set-like behaviour of dict methods is only available in Py2.7+') - def test_set_like_behaviour(self): - d1, d2 = self.d1, self.d2 - self.assertEqual(dict(d1).viewkeys() & dict(d2).viewkeys(), set()) - self.assertEqual(dict(d1).viewkeys() | dict(d2).viewkeys(), - set(['key1', 'key2', 'C', 'B', 'A'])) - self.assertTrue(isinstance(d1.viewvalues() | d2.viewkeys(), set)) - self.assertTrue(isinstance(d1.viewitems() | d2.viewitems(), set)) - - with self.assertRaises(TypeError): - d1.values() | d2.values() - d1.keys() | d2.keys() - d1.items() | d2.items() - - def test_braces_create_newdict_object(self): - """ - It would nice if the {} dict syntax could be coaxed - into producing our new dict objects somehow ... - """ - d = self.d1 - if False: # This doesn't work ... - self.assertTrue(type(d) == dict) - - -# import UserDict -import random, string -import gc, weakref - - -class Py2DictTest(unittest.TestCase): - """ - These are Py2/3-compatible ports of the unit tests from Python 2.7's - tests/test_dict.py - """ - - def test_constructor(self): - # calling built-in types without argument must return empty - self.assertEqual(dict(), {}) - self.assertIsNot(dict(), {}) - - @skip26 - def test_literal_constructor(self): - # check literal constructor for different sized dicts - # (to exercise the BUILD_MAP oparg). - for n in (0, 1, 6, 256, 400): - items = [(''.join(random.sample(string.ascii_letters, 8)), i) - for i in range(n)] - random.shuffle(items) - formatted_items = ('{!r}: {:d}'.format(k, v) for k, v in items) - dictliteral = '{' + ', '.join(formatted_items) + '}' - self.assertEqual(eval(dictliteral), dict(items)) - - def test_bool(self): - self.assertIs(not dict(), True) - self.assertTrue(dict({1: 2})) - self.assertIs(bool(dict({})), False) - self.assertIs(bool(dict({1: 2})), True) - - def test_keys(self): - d = dict() - self.assertEqual(d.keys(), []) - d = dict({'a': 1, 'b': 2}) - k = d.keys() - self.assertTrue(d.has_key('a')) - self.assertTrue(d.has_key('b')) - - self.assertRaises(TypeError, d.keys, None) - - def test_values(self): - d = dict() - self.assertEqual(d.values(), []) - d = dict({1:2}) - self.assertEqual(d.values(), [2]) - - self.assertRaises(TypeError, d.values, None) - - def test_items(self): - d = dict() - self.assertEqual(d.items(), []) - - d = dict({1:2}) - self.assertEqual(d.items(), [(1, 2)]) - - self.assertRaises(TypeError, d.items, None) - - def test_has_key(self): - d = dict() - self.assertFalse(d.has_key('a')) - d = dict({'a': 1, 'b': 2}) - k = d.keys() - k.sort() - self.assertEqual(k, ['a', 'b']) - - self.assertRaises(TypeError, d.has_key) - - def test_contains(self): - d = dict() - self.assertNotIn('a', d) - self.assertFalse('a' in d) - self.assertTrue('a' not in d) - d = dict({'a': 1, 'b': 2}) - self.assertIn('a', d) - self.assertIn('b', d) - self.assertNotIn('c', d) - - self.assertRaises(TypeError, d.__contains__) - - def test_len(self): - d = dict() - self.assertEqual(len(d), 0) - d = dict({'a': 1, 'b': 2}) - self.assertEqual(len(d), 2) - - def test_getitem(self): - d = dict({'a': 1, 'b': 2}) - self.assertEqual(d['a'], 1) - self.assertEqual(d['b'], 2) - d['c'] = 3 - d['a'] = 4 - self.assertEqual(d['c'], 3) - self.assertEqual(d['a'], 4) - del d['b'] - self.assertEqual(d, dict({'a': 4, 'c': 3})) - - self.assertRaises(TypeError, d.__getitem__) - - class BadEq(object): - def __eq__(self, other): - raise Exc() - def __hash__(self): - return 24 - - d = dict() - d[BadEq()] = 42 - self.assertRaises(KeyError, d.__getitem__, 23) - - class Exc(Exception): pass - - class BadHash(object): - fail = False - def __hash__(self): - if self.fail: - raise Exc() - else: - return 42 - - x = BadHash() - d[x] = 42 - x.fail = True - self.assertRaises(Exc, d.__getitem__, x) - - def test_clear(self): - d = dict({1:1, 2:2, 3:3}) - d.clear() - self.assertEqual(d, {}) - - self.assertRaises(TypeError, d.clear, None) - - def test_update(self): - d = dict() - d.update({1:100}) - d.update(dict({2:20})) - d.update({1:1, 2:2, 3:3}) - self.assertEqual(d, {1:1, 2:2, 3:3}) - - d.update() - self.assertEqual(d, {1:1, 2:2, 3:3}) - - self.assertRaises((TypeError, AttributeError), d.update, None) - - class SimpleUserDict: - def __init__(self): - self.d = dict({1:1, 2:2, 3:3}) - def keys(self): - return self.d.keys() - def __getitem__(self, i): - return self.d[i] - d.clear() - d.update(SimpleUserDict()) - self.assertEqual(d, {1:1, 2:2, 3:3}) - - class Exc(Exception): pass - - d.clear() - class FailingUserDict: - def keys(self): - raise Exc - self.assertRaises(Exc, d.update, FailingUserDict()) - - class FailingUserDict: - def keys(self): - @implements_iterator - class BogonIter: - def __init__(self): - self.i = 1 - def __iter__(self): - return self - def __next__(self): - if self.i: - self.i = 0 - return 'a' - raise Exc - return BogonIter() - def __getitem__(self, key): - return key - self.assertRaises(Exc, d.update, FailingUserDict()) - - class FailingUserDict: - def keys(self): - @implements_iterator - class BogonIter: - def __init__(self): - self.i = ord('a') - def __iter__(self): - return self - def __next__(self): - if self.i <= ord('z'): - rtn = chr(self.i) - self.i += 1 - return rtn - raise StopIteration - return BogonIter() - def __getitem__(self, key): - raise Exc - self.assertRaises(Exc, d.update, FailingUserDict()) - - @implements_iterator - class badseq(object): - def __iter__(self): - return self - def __next__(self): - raise Exc() - - self.assertRaises(Exc, {}.update, badseq()) - - self.assertRaises(ValueError, {}.update, [(1, 2, 3)]) - - def test_fromkeys(self): - self.assertEqual(dict.fromkeys('abc'), {'a':None, 'b':None, 'c':None}) - d = dict() - self.assertIsNot(d.fromkeys('abc'), d) - self.assertEqual(d.fromkeys('abc'), {'a':None, 'b':None, 'c':None}) - self.assertEqual(d.fromkeys((4,5),0), {4:0, 5:0}) - self.assertEqual(d.fromkeys([]), {}) - def g(): - yield 1 - self.assertEqual(d.fromkeys(g()), {1:None}) - self.assertRaises(TypeError, dict().fromkeys, 3) - class dictlike(dict): pass - self.assertEqual(dictlike.fromkeys('a'), {'a':None}) - self.assertEqual(dictlike().fromkeys('a'), {'a':None}) - self.assertIsInstance(dictlike.fromkeys('a'), dictlike) - self.assertIsInstance(dictlike().fromkeys('a'), dictlike) - # class mydict(dict): - # def __new__(cls): - # return UserDict.UserDict() - # ud = mydict.fromkeys('ab') - # self.assertEqual(ud, {'a':None, 'b':None}) - # self.assertIsInstance(ud, UserDict.UserDict) - # self.assertRaises(TypeError, dict.fromkeys) - - class Exc(Exception): pass - - class baddict1(dict): - def __init__(self): - raise Exc() - - self.assertRaises(Exc, baddict1.fromkeys, [1]) - - @implements_iterator - class BadSeq(object): - def __iter__(self): - return self - def __next__(self): - raise Exc() - - self.assertRaises(Exc, dict.fromkeys, BadSeq()) - - class baddict2(dict): - def __setitem__(self, key, value): - raise Exc() - - self.assertRaises(Exc, baddict2.fromkeys, [1]) - - # test fast path for dictionary inputs - d = dict(zip(range(6), range(6))) - self.assertEqual(dict.fromkeys(d, 0), dict(zip(range(6), [0]*6))) - - class baddict3(dict): - def __new__(cls): - return d - d = dict((i, i) for i in range(10)) - res = d.copy() - res.update(a=None, b=None, c=None) - # Was: self.assertEqual(baddict3.fromkeys(set(["a", "b", "c"])), res) - # Infinite loop on Python 2.6 and 2.7 ... - - def test_copy(self): - d = dict({1:1, 2:2, 3:3}) - self.assertEqual(d.copy(), {1:1, 2:2, 3:3}) - self.assertEqual({}.copy(), {}) - self.assertRaises(TypeError, d.copy, None) - - def test_get(self): - d = dict() - self.assertIs(d.get('c'), None) - self.assertEqual(d.get('c', 3), 3) - d = dict({'a': 1, 'b': 2}) - self.assertIs(d.get('c'), None) - self.assertEqual(d.get('c', 3), 3) - self.assertEqual(d.get('a'), 1) - self.assertEqual(d.get('a', 3), 1) - self.assertRaises(TypeError, d.get) - self.assertRaises(TypeError, d.get, None, None, None) - - @skip26 - def test_setdefault(self): - # dict.setdefault() - d = dict() - self.assertIs(d.setdefault('key0'), None) - d.setdefault('key0', []) - self.assertIs(d.setdefault('key0'), None) - d.setdefault('key', []).append(3) - self.assertEqual(d['key'][0], 3) - d.setdefault('key', []).append(4) - self.assertEqual(len(d['key']), 2) - self.assertRaises(TypeError, d.setdefault) - - class Exc(Exception): pass - - class BadHash(object): - fail = False - def __hash__(self): - if self.fail: - raise Exc() - else: - return 42 - - x = BadHash() - d[x] = 42 - x.fail = True - self.assertRaises(Exc, d.setdefault, x, []) - - @skip26 - def test_setdefault_atomic(self): - # Issue #13521: setdefault() calls __hash__ and __eq__ only once. - class Hashed(object): - def __init__(self): - self.hash_count = 0 - self.eq_count = 0 - def __hash__(self): - self.hash_count += 1 - return 42 - def __eq__(self, other): - self.eq_count += 1 - return id(self) == id(other) - hashed1 = Hashed() - y = dict({hashed1: 5}) - hashed2 = Hashed() - y.setdefault(hashed2, []) - self.assertEqual(hashed1.hash_count, 1) - if PY3: - self.assertEqual(hashed2.hash_count, 1) - self.assertEqual(hashed1.eq_count + hashed2.eq_count, 1) - - def test_popitem(self): - # dict.popitem() - for copymode in -1, +1: - # -1: b has same structure as a - # +1: b is a.copy() - for log2size in range(12): - size = 2**log2size - a = dict() - b = dict() - for i in range(size): - a[repr(i)] = i - if copymode < 0: - b[repr(i)] = i - if copymode > 0: - b = a.copy() - for i in range(size): - ka, va = ta = a.popitem() - self.assertEqual(va, int(ka)) - kb, vb = tb = b.popitem() - self.assertEqual(vb, int(kb)) - self.assertFalse(copymode < 0 and ta != tb) - self.assertFalse(a) - self.assertFalse(b) - - d = dict() - self.assertRaises(KeyError, d.popitem) - - def test_pop(self): - # Tests for pop with specified key - d = dict() - k, v = 'abc', 'def' - d[k] = v - self.assertRaises(KeyError, d.pop, 'ghi') - - self.assertEqual(d.pop(k), v) - self.assertEqual(len(d), 0) - - self.assertRaises(KeyError, d.pop, k) - - self.assertEqual(d.pop(k, v), v) - d[k] = v - self.assertEqual(d.pop(k, 1), v) - - self.assertRaises(TypeError, d.pop) - - class Exc(Exception): pass - - class BadHash(object): - fail = False - def __hash__(self): - if self.fail: - raise Exc() - else: - return 42 - - x = BadHash() - d[x] = 42 - x.fail = True - self.assertRaises(Exc, d.pop, x) - - def test_mutatingiteration(self): - # changing dict size during iteration - d = dict() - d[1] = 1 - with self.assertRaises(RuntimeError): - for i in d: - d[i+1] = 1 - - def test_repr(self): - d = dict() - self.assertEqual(repr(d), '{}') - d[1] = 2 - self.assertEqual(repr(d), '{1: 2}') - d = dict() - d[1] = d - self.assertEqual(repr(d), '{1: {...}}') - - class Exc(Exception): pass - - class BadRepr(object): - def __repr__(self): - raise Exc() - - d = dict({1: BadRepr()}) - self.assertRaises(Exc, repr, d) - - @unittest.skip('Comparing dicts for order has not been forward-ported') - def test_le(self): - self.assertFalse(dict() < {}) - self.assertFalse(dict() < dict()) - self.assertFalse(dict({1: 2}) < {1: 2}) - - class Exc(Exception): pass - - class BadCmp(object): - def __eq__(self, other): - raise Exc() - def __hash__(self): - return 42 - - d1 = dict({BadCmp(): 1}) - d2 = dict({1: 1}) - - with self.assertRaises(Exc): - d1 < d2 - - @skip26 - def test_missing(self): - # Make sure dict doesn't have a __missing__ method - self.assertFalse(hasattr(dict, "__missing__")) - self.assertFalse(hasattr(dict(), "__missing__")) - # Test several cases: - # (D) subclass defines __missing__ method returning a value - # (E) subclass defines __missing__ method raising RuntimeError - # (F) subclass sets __missing__ instance variable (no effect) - # (G) subclass doesn't define __missing__ at a all - class D(dict): - def __missing__(self, key): - return 42 - d = D({1: 2, 3: 4}) - self.assertEqual(d[1], 2) - self.assertEqual(d[3], 4) - self.assertNotIn(2, d) - self.assertNotIn(2, d.keys()) - self.assertEqual(d[2], 42) - - class E(dict): - def __missing__(self, key): - raise RuntimeError(key) - e = E() - with self.assertRaises(RuntimeError) as c: - e[42] - self.assertEqual(c.exception.args, (42,)) - - class F(dict): - def __init__(self): - # An instance variable __missing__ should have no effect - self.__missing__ = lambda key: None - f = F() - with self.assertRaises(KeyError) as c: - f[42] - self.assertEqual(c.exception.args, (42,)) - - class G(dict): - pass - g = G() - with self.assertRaises(KeyError) as c: - g[42] - self.assertEqual(c.exception.args, (42,)) - - @skip26 - def test_tuple_keyerror(self): - # SF #1576657 - d = dict() - with self.assertRaises(KeyError) as c: - d[(1,)] - self.assertEqual(c.exception.args, ((1,),)) - - # def test_bad_key(self): - # # Dictionary lookups should fail if __cmp__() raises an exception. - # class CustomException(Exception): - # pass - - # class BadDictKey: - # def __hash__(self): - # return hash(self.__class__) - - # def __cmp__(self, other): - # if isinstance(other, self.__class__): - # raise CustomException - # return other - - # d = dict() - # x1 = BadDictKey() - # x2 = BadDictKey() - # d[x1] = 1 - # for stmt in ['d[x2] = 2', - # 'z = d[x2]', - # 'x2 in d', - # 'd.has_key(x2)', - # 'd.get(x2)', - # 'd.setdefault(x2, 42)', - # 'd.pop(x2)', - # 'd.update({x2: 2})']: - # with self.assertRaises(CustomException): - # utils.exec_(stmt, locals()) - # - # def test_resize1(self): - # # Dict resizing bug, found by Jack Jansen in 2.2 CVS development. - # # This version got an assert failure in debug build, infinite loop in - # # release build. Unfortunately, provoking this kind of stuff requires - # # a mix of inserts and deletes hitting exactly the right hash codes in - # # exactly the right order, and I can't think of a randomized approach - # # that would be *likely* to hit a failing case in reasonable time. - - # d = {} - # for i in range(5): - # d[i] = i - # for i in range(5): - # del d[i] - # for i in range(5, 9): # i==8 was the problem - # d[i] = i - - # def test_resize2(self): - # # Another dict resizing bug (SF bug #1456209). - # # This caused Segmentation faults or Illegal instructions. - - # class X(object): - # def __hash__(self): - # return 5 - # def __eq__(self, other): - # if resizing: - # d.clear() - # return False - # d = {} - # resizing = False - # d[X()] = 1 - # d[X()] = 2 - # d[X()] = 3 - # d[X()] = 4 - # d[X()] = 5 - # # now trigger a resize - # resizing = True - # d[9] = 6 - - # def test_empty_presized_dict_in_freelist(self): - # # Bug #3537: if an empty but presized dict with a size larger - # # than 7 was in the freelist, it triggered an assertion failure - # with self.assertRaises(ZeroDivisionError): - # d = {'a': 1 // 0, 'b': None, 'c': None, 'd': None, 'e': None, - # 'f': None, 'g': None, 'h': None} - # d = {} - - # def test_container_iterator(self): - # # Bug #3680: tp_traverse was not implemented for dictiter objects - # class C(object): - # pass - # iterators = (dict.iteritems, dict.itervalues, dict.iterkeys) - # for i in iterators: - # obj = C() - # ref = weakref.ref(obj) - # container = {obj: 1} - # obj.x = i(container) - # del obj, container - # gc.collect() - # self.assertIs(ref(), None, "Cycle was not collected") - - # def _not_tracked(self, t): - # # Nested containers can take several collections to untrack - # gc.collect() - # gc.collect() - # self.assertFalse(gc.is_tracked(t), t) - - # def _tracked(self, t): - # self.assertTrue(gc.is_tracked(t), t) - # gc.collect() - # gc.collect() - # self.assertTrue(gc.is_tracked(t), t) - - # @test_support.cpython_only - # def test_track_literals(self): - # # Test GC-optimization of dict literals - # x, y, z, w = 1.5, "a", (1, None), [] - - # self._not_tracked({}) - # self._not_tracked({x:(), y:x, z:1}) - # self._not_tracked({1: "a", "b": 2}) - # self._not_tracked({1: 2, (None, True, False, ()): int}) - # self._not_tracked({1: object()}) - - # # Dicts with mutable elements are always tracked, even if those - # # elements are not tracked right now. - # self._tracked({1: []}) - # self._tracked({1: ([],)}) - # self._tracked({1: {}}) - # self._tracked({1: set()}) - - # @test_support.cpython_only - # def test_track_dynamic(self): - # # Test GC-optimization of dynamically-created dicts - # class MyObject(object): - # pass - # x, y, z, w, o = 1.5, "a", (1, object()), [], MyObject() - - # d = dict() - # self._not_tracked(d) - # d[1] = "a" - # self._not_tracked(d) - # d[y] = 2 - # self._not_tracked(d) - # d[z] = 3 - # self._not_tracked(d) - # self._not_tracked(d.copy()) - # d[4] = w - # self._tracked(d) - # self._tracked(d.copy()) - # d[4] = None - # self._not_tracked(d) - # self._not_tracked(d.copy()) - - # # dd isn't tracked right now, but it may mutate and therefore d - # # which contains it must be tracked. - # d = dict() - # dd = dict() - # d[1] = dd - # self._not_tracked(dd) - # self._tracked(d) - # dd[1] = d - # self._tracked(dd) - - # d = dict.fromkeys([x, y, z]) - # self._not_tracked(d) - # dd = dict() - # dd.update(d) - # self._not_tracked(dd) - # d = dict.fromkeys([x, y, z, o]) - # self._tracked(d) - # dd = dict() - # dd.update(d) - # self._tracked(dd) - - # d = dict(x=x, y=y, z=z) - # self._not_tracked(d) - # d = dict(x=x, y=y, z=z, w=w) - # self._tracked(d) - # d = dict() - # d.update(x=x, y=y, z=z) - # self._not_tracked(d) - # d.update(w=w) - # self._tracked(d) - - # d = dict([(x, y), (z, 1)]) - # self._not_tracked(d) - # d = dict([(x, y), (z, w)]) - # self._tracked(d) - # d = dict() - # d.update([(x, y), (z, 1)]) - # self._not_tracked(d) - # d.update([(x, y), (z, w)]) - # self._tracked(d) - - # @test_support.cpython_only - # def test_track_subtypes(self): - # # Dict subtypes are always tracked - # class MyDict(dict): - # pass - # self._tracked(MyDict()) - - -if __name__ == '__main__': - # Only run these tests on Python 3 ... - if PY3: - unittest.main() diff --git a/FOSS/Python/Dependencies/future-0.18.2/tests/test_past/test_oldstr.py b/FOSS/Python/Dependencies/future-0.18.2/tests/test_past/test_oldstr.py deleted file mode 100644 index 17af03c..0000000 --- a/FOSS/Python/Dependencies/future-0.18.2/tests/test_past/test_oldstr.py +++ /dev/null @@ -1,46 +0,0 @@ -# -*- coding: utf-8 -*- -""" -Tests for the resurrected Py2-like 8-bit string type. -""" - -from __future__ import absolute_import, unicode_literals, print_function - -from numbers import Integral -from future.tests.base import unittest -from past.builtins import str as oldstr -from past.types.oldstr import unescape - - -class TestOldStr(unittest.TestCase): - def test_repr(self): - s1 = oldstr(b'abc') - self.assertEqual(repr(s1), "'abc'") - s2 = oldstr(b'abc\ndef') - self.assertEqual(repr(s2), "'abc\\ndef'") - - def test_str(self): - s1 = oldstr(b'abc') - self.assertEqual(str(s1), 'abc') - s2 = oldstr(b'abc\ndef') - self.assertEqual(str(s2), 'abc\ndef') - - def test_unescape(self): - self.assertEqual(unescape('abc\\ndef'), 'abc\ndef') - s = unescape(r'a\\b\c\\d') # i.e. 'a\\\\b\\c\\\\d' - self.assertEqual(str(s), r'a\b\c\d') - s2 = unescape(r'abc\\ndef') # i.e. 'abc\\\\ndef' - self.assertEqual(str(s2), r'abc\ndef') - - def test_getitem(self): - s = oldstr(b'abc') - - self.assertNotEqual(s[0], 97) - self.assertEqual(s[0], b'a') - self.assertEqual(s[0], oldstr(b'a')) - - self.assertEqual(s[1:], b'bc') - self.assertEqual(s[1:], oldstr(b'bc')) - - -if __name__ == '__main__': - unittest.main() diff --git a/FOSS/Python/Dependencies/future-0.18.2/tests/test_past/test_translation.py b/FOSS/Python/Dependencies/future-0.18.2/tests/test_past/test_translation.py deleted file mode 100644 index 2b442d9..0000000 --- a/FOSS/Python/Dependencies/future-0.18.2/tests/test_past/test_translation.py +++ /dev/null @@ -1,738 +0,0 @@ -# -*- coding: utf-8 -*- -""" -Tests for the Py2-like class:`basestring` type. -""" - -from __future__ import absolute_import, division, print_function -import os -import textwrap -import sys -import pprint -import tempfile -import os -import io -from subprocess import Popen, PIPE - -from past import utils -from past.builtins import basestring, str as oldstr, unicode - -from past.translation import install_hooks, remove_hooks, common_substring -from future.tests.base import (unittest, CodeHandler, skip26, - expectedFailurePY3, expectedFailurePY26) - - -class TestTranslate(unittest.TestCase): - def setUp(self): - self.tempdir = tempfile.mkdtemp() + os.path.sep - - # def tearDown(self): - # remove_hooks() - - def test_common_substring(self): - s1 = '/home/user/anaconda/envs/future3/lib/python3.3/lib-dynload/math.cpython-33m.so' - s2 = '/home/user/anaconda/envs/future3/lib/python3.3/urllib/__init__.py' - c = '/home/user/anaconda/envs/future3/lib/python3.3' - self.assertEqual(c, common_substring(s1, s2)) - - s1 = r'/Users/Fred Flintstone/Python3.3/lib/something' - s2 = r'/Users/Fred Flintstone/Python3.3/lib/somethingelse' - c = r'/Users/Fred Flintstone/Python3.3/lib' - self.assertEqual(c, common_substring(s1, s2)) - - def write_and_import(self, code, modulename='mymodule'): - self.assertTrue('.py' not in modulename) - filename = modulename + '.py' - if isinstance(code, bytes): - code = code.decode('utf-8') - # Be explicit about encoding the temp file as UTF-8 (issue #63): - with io.open(self.tempdir + filename, 'w', encoding='utf-8') as f: - f.write(textwrap.dedent(code).strip() + '\n') - - # meta_path_len = len(sys.meta_path) - install_hooks(modulename) - # print('Hooks installed') - # assert len(sys.meta_path) == 1 + meta_path_len - # print('sys.meta_path is: {0}'.format(sys.meta_path)) - module = None - - sys.path.insert(0, self.tempdir) - try: - module = __import__(modulename) - except SyntaxError: - print('Bombed!') - else: - print('Succeeded!') - finally: - remove_hooks() - # print('Hooks removed') - sys.path.remove(self.tempdir) - return module - - def test_print_statement(self): - code = """ - print 'Hello from a Python 2-style print statement!' - finished = True - """ - printer = self.write_and_import(code, 'printer') - self.assertTrue(printer.finished) - - def test_exec_statement(self): - code = """ - exec 'x = 5 + 2' - """ - module = self.write_and_import(code, 'execer') - self.assertEqual(module.x, 7) - - def test_div(self): - code = """ - x = 3 / 2 - """ - module = self.write_and_import(code, 'div') - self.assertEqual(module.x, 1) - - def test_import_future_standard_library(self): - """ - Does futurized Py3-like code like this work under autotranslation?? - """ - code = """ - from future import standard_library - standard_library.install_hooks() - import configparser - """ - module = self.write_and_import(code, 'future_standard_library') - self.assertTrue('configparser' in dir(module)) - from future import standard_library - standard_library.remove_hooks() - - def test_old_builtin_functions(self): - code = """ - # a = raw_input() - import sys - b = open(sys.executable, 'rb') - b.close() - - def is_even(x): - return x % 2 == 0 - c = filter(is_even, range(10)) - - def double(x): - return x * 2 - d = map(double, c) - - e = isinstance('abcd', str) - - for g in xrange(10**3): - pass - - # super(MyClass, self) - """ - module = self.write_and_import(code, 'test_builtin_functions') - self.assertTrue(hasattr(module.b, 'readlines')) - self.assertTrue(isinstance(module.c, list)) - self.assertEqual(module.c, [0, 2, 4, 6, 8]) - self.assertEqual(module.d, [0, 4, 8, 12, 16]) - self.assertTrue(module.e) - - @expectedFailurePY3 - def test_import_builtin_types(self): - code = """ - s1 = 'abcd' - s2 = u'abcd' - b1 = b'abcd' - b2 = s2.encode('utf-8') - d1 = {} - d2 = dict((i, i**2) for i in range(10)) - i1 = 1923482349324234L - i2 = 1923482349324234 - """ - module = self.write_and_import(code, 'test_builtin_types') - self.assertTrue(isinstance(module.s1, oldstr)) - self.assertTrue(isinstance(module.s2, unicode)) - self.assertTrue(isinstance(module.b1, oldstr)) - - def test_xrange(self): - code = ''' - total = 0 - for i in xrange(10): - total += i - ''' - module = self.write_and_import(code, 'xrange') - self.assertEqual(module.total, 45) - - def test_exception_syntax(self): - """ - Test of whether futurize handles the old-style exception syntax - """ - code = """ - value = 'string' - try: - value += 10 - except TypeError, e: # old exception syntax - value += ': success!' - """ - module = self.write_and_import(code, 'py2_exceptions') - self.assertEqual(module.value, 'string: success!') - - -# class TestFuturizeSimple(CodeHandler): -# """ -# This class contains snippets of Python 2 code (invalid Python 3) and -# tests for whether they can be imported correctly from Python 3 with the -# import hooks. -# """ -# -# @unittest.expectedFailure -# def test_problematic_string(self): -# """ This string generates a SyntaxError on Python 3 unless it has -# an r prefix. -# """ -# before = r""" -# s = 'The folder is "C:\Users"'. -# """ -# after = r""" -# s = r'The folder is "C:\Users"'. -# """ -# self.convert_check(before, after) -# -# def test_tobytes(self): -# """ -# The --tobytes option converts all UNADORNED string literals 'abcd' to b'abcd'. -# It does apply to multi-line strings but doesn't apply if it's a raw -# string, because ur'abcd' is a SyntaxError on Python 2 and br'abcd' is a -# SyntaxError on Python 3. -# """ -# before = r""" -# s0 = '1234' -# s1 = '''5678 -# ''' -# s2 = "9abc" -# # Unchanged: -# s3 = r'1234' -# s4 = R"defg" -# s5 = u'hijk' -# s6 = u"lmno" -# s7 = b'lmno' -# s8 = b"pqrs" -# """ -# after = r""" -# s0 = b'1234' -# s1 = b'''5678 -# ''' -# s2 = b"9abc" -# # Unchanged: -# s3 = r'1234' -# s4 = R"defg" -# s5 = u'hijk' -# s6 = u"lmno" -# s7 = b'lmno' -# s8 = b"pqrs" -# """ -# self.convert_check(before, after, tobytes=True) -# -# @unittest.expectedFailure -# def test_izip(self): -# before = """ -# from itertools import izip -# for (a, b) in izip([1, 3, 5], [2, 4, 6]): -# pass -# """ -# after = """ -# from __future__ import unicode_literals -# from future.builtins import zip -# for (a, b) in zip([1, 3, 5], [2, 4, 6]): -# pass -# """ -# self.convert_check(before, after, stages=(1, 2), ignore_imports=False) -# -# @unittest.expectedFailure -# def test_no_unneeded_list_calls(self): -# """ -# TODO: get this working -# """ -# code = """ -# for (a, b) in zip(range(3), range(3, 6)): -# pass -# """ -# self.unchanged(code) -# -# def test_xrange(self): -# code = ''' -# for i in xrange(10): -# pass -# ''' -# self.convert(code) -# -# @unittest.expectedFailure -# def test_source_coding_utf8(self): -# """ -# Tests to ensure that the source coding line is not corrupted or -# removed. It must be left as the first line in the file (including -# before any __future__ imports). Also tests whether the unicode -# characters in this encoding are parsed correctly and left alone. -# """ -# code = """ -# # -*- coding: utf-8 -*- -# icons = [u"◐", u"◓", u"◑", u"◒"] -# """ -# self.unchanged(code) -# -# def test_exception_syntax(self): -# """ -# Test of whether futurize handles the old-style exception syntax -# """ -# before = """ -# try: -# pass -# except IOError, e: -# val = e.errno -# """ -# after = """ -# try: -# pass -# except IOError as e: -# val = e.errno -# """ -# self.convert_check(before, after) -# -# def test_super(self): -# """ -# This tests whether futurize keeps the old two-argument super() calls the -# same as before. It should, because this still works in Py3. -# """ -# code = ''' -# class VerboseList(list): -# def append(self, item): -# print('Adding an item') -# super(VerboseList, self).append(item) -# ''' -# self.unchanged(code) -# -# @unittest.expectedFailure -# def test_file(self): -# """ -# file() as a synonym for open() is obsolete and invalid on Python 3. -# """ -# before = ''' -# f = file(__file__) -# data = f.read() -# f.close() -# ''' -# after = ''' -# f = open(__file__) -# data = f.read() -# f.close() -# ''' -# self.convert_check(before, after) -# -# def test_apply(self): -# before = ''' -# def addup(*x): -# return sum(x) -# -# assert apply(addup, (10,20)) == 30 -# ''' -# after = """ -# def addup(*x): -# return sum(x) -# -# assert addup(*(10,20)) == 30 -# """ -# self.convert_check(before, after) -# -# @unittest.skip('not implemented yet') -# def test_download_pypi_package_and_test(self, package_name='future'): -# URL = 'http://pypi.python.org/pypi/{0}/json' -# -# import requests -# r = requests.get(URL.format(package_name)) -# pprint.pprint(r.json()) -# -# download_url = r.json()['urls'][0]['url'] -# filename = r.json()['urls'][0]['filename'] -# # r2 = requests.get(download_url) -# # with open('/tmp/' + filename, 'w') as tarball: -# # tarball.write(r2.content) -# -# def test_raw_input(self): -# """ -# Passes in a string to the waiting input() after futurize -# conversion. -# -# The code is the first snippet from these docs: -# http://docs.python.org/2/library/2to3.html -# """ -# before = """ -# def greet(name): -# print "Hello, {0}!".format(name) -# print "What's your name?" -# name = raw_input() -# greet(name) -# """ -# desired = """ -# def greet(name): -# print("Hello, {0}!".format(name)) -# print("What's your name?") -# name = input() -# greet(name) -# """ -# self.convert_check(before, desired, run=False) -# -# for interpreter in self.interpreters: -# p1 = Popen([interpreter, self.tempdir + 'mytestscript.py'], -# stdout=PIPE, stdin=PIPE, stderr=PIPE) -# (stdout, stderr) = p1.communicate(b'Ed') -# self.assertEqual(stdout, b"What's your name?\nHello, Ed!\n") -# -# def test_literal_prefixes_are_not_stripped(self): -# """ -# Tests to ensure that the u'' and b'' prefixes on unicode strings and -# byte strings are not removed by the futurize script. Removing the -# prefixes on Py3.3+ is unnecessary and loses some information -- namely, -# that the strings have explicitly been marked as unicode or bytes, -# rather than just e.g. a guess by some automated tool about what they -# are. -# """ -# code = ''' -# s = u'unicode string' -# b = b'byte string' -# ''' -# self.unchanged(code) -# -# @unittest.expectedFailure -# def test_division(self): -# """ -# TODO: implement this! -# """ -# before = """ -# x = 1 / 2 -# """ -# after = """ -# from future.utils import old_div -# x = old_div(1, 2) -# """ -# self.convert_check(before, after, stages=[1]) -# -# -# class TestFuturizeRenamedStdlib(CodeHandler): -# def test_renamed_modules(self): -# before = """ -# import ConfigParser -# import copy_reg -# import cPickle -# import cStringIO -# -# s = cStringIO.StringIO('blah') -# """ -# after = """ -# import configparser -# import copyreg -# import pickle -# import io -# -# s = io.StringIO('blah') -# """ -# self.convert_check(before, after) -# -# @unittest.expectedFailure -# def test_urllib_refactor(self): -# # Code like this using urllib is refactored by futurize --stage2 to use -# # the new Py3 module names, but ``future`` doesn't support urllib yet. -# before = """ -# import urllib -# -# URL = 'http://pypi.python.org/pypi/future/json' -# package_name = 'future' -# r = urllib.urlopen(URL.format(package_name)) -# data = r.read() -# """ -# after = """ -# import urllib.request -# -# URL = 'http://pypi.python.org/pypi/future/json' -# package_name = 'future' -# r = urllib.request.urlopen(URL.format(package_name)) -# data = r.read() -# """ -# self.convert_check(before, after) -# -# def test_renamed_copy_reg_and_cPickle_modules(self): -# """ -# Example from docs.python.org/2/library/copy_reg.html -# """ -# before = """ -# import copy_reg -# import copy -# import cPickle -# class C(object): -# def __init__(self, a): -# self.a = a -# -# def pickle_c(c): -# print('pickling a C instance...') -# return C, (c.a,) -# -# copy_reg.pickle(C, pickle_c) -# c = C(1) -# d = copy.copy(c) -# p = cPickle.dumps(c) -# """ -# after = """ -# import copyreg -# import copy -# import pickle -# class C(object): -# def __init__(self, a): -# self.a = a -# -# def pickle_c(c): -# print('pickling a C instance...') -# return C, (c.a,) -# -# copyreg.pickle(C, pickle_c) -# c = C(1) -# d = copy.copy(c) -# p = pickle.dumps(c) -# """ -# self.convert_check(before, after) -# -# @unittest.expectedFailure -# def test_Py2_StringIO_module(self): -# """ -# Ideally, there would be a fixer for this. For now: -# -# TODO: add the Py3 equivalent for this to the docs -# """ -# before = """ -# import cStringIO -# s = cStringIO.StringIO('my string') -# assert isinstance(s, cStringIO.InputType) -# """ -# after = """ -# import io -# s = io.StringIO('my string') -# # assert isinstance(s, io.InputType) -# # There is no io.InputType in Python 3. What should we change this to -# # instead? -# """ -# self.convert_check(before, after) -# -# -# class TestFuturizeStage1(CodeHandler): -# # """ -# # Tests "stage 1": safe optimizations: modernizing Python 2 code so that it -# # uses print functions, new-style exception syntax, etc. -# -# # The behaviour should not change and this should introduce no dependency on -# # the ``future`` package. It produces more modern Python 2-only code. The -# # goal is to reduce the size of the real porting patch-set by performing -# # the uncontroversial patches first. -# # """ -# -# def test_apply(self): -# """ -# apply() should be changed by futurize --stage1 -# """ -# before = ''' -# def f(a, b): -# return a + b -# -# args = (1, 2) -# assert apply(f, args) == 3 -# assert apply(f, ('a', 'b')) == 'ab' -# ''' -# after = ''' -# def f(a, b): -# return a + b -# -# args = (1, 2) -# assert f(*args) == 3 -# assert f(*('a', 'b')) == 'ab' -# ''' -# self.convert_check(before, after, stages=[1]) -# -# def test_xrange(self): -# """ -# xrange should not be changed by futurize --stage1 -# """ -# code = ''' -# for i in xrange(10): -# pass -# ''' -# self.unchanged(code, stages=[1]) -# -# @unittest.expectedFailure -# def test_absolute_import_changes(self): -# """ -# Implicit relative imports should be converted to absolute or explicit -# relative imports correctly. -# -# Issue #16 (with porting bokeh/bbmodel.py) -# """ -# with open('specialmodels.py', 'w') as f: -# f.write('pass') -# -# before = """ -# import specialmodels.pandasmodel -# specialmodels.pandasmodel.blah() -# """ -# after = """ -# from __future__ import absolute_import -# from .specialmodels import pandasmodel -# pandasmodel.blah() -# """ -# self.convert_check(before, after, stages=[1]) -# -# def test_safe_futurize_imports(self): -# """ -# The standard library module names should not be changed until stage 2 -# """ -# before = """ -# import ConfigParser -# import HTMLParser -# import collections -# -# ConfigParser.ConfigParser -# HTMLParser.HTMLParser -# d = collections.OrderedDict() -# """ -# self.unchanged(before, stages=[1]) -# -# def test_print(self): -# before = """ -# print 'Hello' -# """ -# after = """ -# print('Hello') -# """ -# self.convert_check(before, after, stages=[1]) -# -# before = """ -# import sys -# print >> sys.stderr, 'Hello', 'world' -# """ -# after = """ -# import sys -# print('Hello', 'world', file=sys.stderr) -# """ -# self.convert_check(before, after, stages=[1]) -# -# def test_print_already_function(self): -# """ -# Running futurize --stage1 should not add a second set of parentheses -# """ -# before = """ -# print('Hello') -# """ -# self.unchanged(before, stages=[1]) -# -# @unittest.expectedFailure -# def test_print_already_function_complex(self): -# """ -# Running futurize --stage1 does add a second second set of parentheses -# in this case. This is because the underlying lib2to3 has two distinct -# grammars -- with a print statement and with a print function -- and, -# when going forwards (2 to both), futurize assumes print is a statement, -# which raises a ParseError. -# """ -# before = """ -# import sys -# print('Hello', 'world', file=sys.stderr) -# """ -# self.unchanged(before, stages=[1]) -# -# def test_exceptions(self): -# before = """ -# try: -# raise AttributeError('blah') -# except AttributeError, e: -# pass -# """ -# after = """ -# try: -# raise AttributeError('blah') -# except AttributeError as e: -# pass -# """ -# self.convert_check(before, after, stages=[1]) -# -# @unittest.expectedFailure -# def test_string_exceptions(self): -# """ -# 2to3 does not convert string exceptions: see -# http://python3porting.com/differences.html. -# """ -# before = """ -# try: -# raise "old string exception" -# except Exception, e: -# pass -# """ -# after = """ -# try: -# raise Exception("old string exception") -# except Exception as e: -# pass -# """ -# self.convert_check(before, after, stages=[1]) -# -# @unittest.expectedFailure -# def test_oldstyle_classes(self): -# """ -# We don't convert old-style classes to new-style automatically. Should we? -# """ -# before = """ -# class Blah: -# pass -# """ -# after = """ -# class Blah(object): -# pass -# """ -# self.convert_check(before, after, stages=[1]) -# -# -# def test_octal_literals(self): -# before = """ -# mode = 0644 -# """ -# after = """ -# mode = 0o644 -# """ -# self.convert_check(before, after) -# -# def test_long_int_literals(self): -# before = """ -# bignumber = 12345678901234567890L -# """ -# after = """ -# bignumber = 12345678901234567890 -# """ -# self.convert_check(before, after) -# -# def test___future___import_position(self): -# """ -# Issue #4: __future__ imports inserted too low in file: SyntaxError -# """ -# code = """ -# # Comments here -# # and here -# __version__=''' $Id$ ''' -# __doc__="A Sequencer class counts things. It aids numbering and formatting lists." -# __all__='Sequencer getSequencer setSequencer'.split() -# # -# # another comment -# # -# -# CONSTANTS = [ 0, 01, 011, 0111, 012, 02, 021, 0211, 02111, 013 ] -# _RN_LETTERS = "IVXLCDM" -# -# def my_func(value): -# pass -# -# ''' Docstring-like comment here ''' -# """ -# self.convert(code) - - -if __name__ == '__main__': - unittest.main() |