| OLD | NEW |
|---|
| 1 # Python test set -- built-in functions | 1 # Python test set -- built-in functions |
| 2 | 2 |
| 3 import test.test_support, unittest | 3 import test.test_support, unittest |
| 4 from test.test_support import fcmp, TESTFN, unlink, run_unittest, \ | 4 from test.test_support import fcmp, TESTFN, unlink, run_unittest, \ |
| 5 run_with_locale | 5 run_with_locale |
| 6 from operator import neg | 6 from operator import neg |
| 7 | 7 |
| 8 import sys, warnings, random, collections, io, fractions | 8 import sys, warnings, random, collections, io, fractions |
| 9 warnings.filterwarnings("ignore", "hex../oct.. of negative int", | 9 warnings.filterwarnings("ignore", "hex../oct.. of negative int", |
| 10 FutureWarning, __name__) | 10 FutureWarning, __name__) |
| 11 warnings.filterwarnings("ignore", "integer argument expected", | 11 warnings.filterwarnings("ignore", "integer argument expected", |
| 12 DeprecationWarning, "unittest") | 12 DeprecationWarning, "unittest") |
| 13 | 13 |
| 14 class Squares: | 14 class Squares: |
| 15 | 15 |
| 16 def __init__(self, max): | 16 def __init__(self, max): |
| 17 self.max = max | 17 self.max = max |
| 18 self.sofar = [] | 18 self.sofar = [] |
| 19 | 19 |
| 20 def __len__(self): return len(self.sofar) | 20 def __len__(self): return len(self.sofar) |
| 21 | 21 |
| 22 def __getitem__(self, i): | 22 def __getitem__(self, i): |
| 23 if not 0 <= i < self.max: raise IndexError | 23 if not 0 <= i < self.max: raise IndexError |
| 24 n = len(self.sofar) | 24 n = len(self.sofar) |
| 25 while n <= i: | 25 while n <= i: |
| 26 self.sofar.append(n*n) | 26 self.sofar.append(n*n) |
| 27 n += 1 | 27 n += 1 |
| 28 return self.sofar[i] | 28 return self.sofar[i] |
| 29 | 29 |
| 30 class StrSquares: | 30 class StrSquares: |
| 31 | 31 |
| 32 def __init__(self, max): | 32 def __init__(self, max): |
| 33 self.max = max | 33 self.max = max |
| 34 self.sofar = [] | 34 self.sofar = [] |
| 35 | 35 |
| 36 def __len__(self): | 36 def __len__(self): |
| 37 return len(self.sofar) | 37 return len(self.sofar) |
| 38 | 38 |
| 39 def __getitem__(self, i): | 39 def __getitem__(self, i): |
| 40 if not 0 <= i < self.max: | 40 if not 0 <= i < self.max: |
| 41 raise IndexError | 41 raise IndexError |
| 42 n = len(self.sofar) | 42 n = len(self.sofar) |
| 43 while n <= i: | 43 while n <= i: |
| 44 self.sofar.append(str(n*n)) | 44 self.sofar.append(str(n*n)) |
| 45 n += 1 | 45 n += 1 |
| 46 return self.sofar[i] | 46 return self.sofar[i] |
| 47 | 47 |
| 48 class BitBucket: | 48 class BitBucket: |
| 49 def write(self, line): | 49 def write(self, line): |
| 50 pass | 50 pass |
| (...skipping 1494 matching lines...) Show 10 above Show 10 below |
| 1545 self.assertEqual(list(range(0, -2**100)), []) | 1545 self.assertEqual(list(range(0, -2**100)), []) |
| 1546 self.assertEqual(list(range(0, 2**100, -1)), []) | 1546 self.assertEqual(list(range(0, 2**100, -1)), []) |
| 1547 self.assertEqual(list(range(0, 2**100, -1)), []) | 1547 self.assertEqual(list(range(0, 2**100, -1)), []) |
| 1548 | 1548 |
| 1549 a = int(10 * sys.maxsize) | 1549 a = int(10 * sys.maxsize) |
| 1550 b = int(100 * sys.maxsize) | 1550 b = int(100 * sys.maxsize) |
| 1551 c = int(50 * sys.maxsize) | 1551 c = int(50 * sys.maxsize) |
| 1552 | 1552 |
| 1553 self.assertEqual(list(range(a, a+2)), [a, a+1]) | 1553 self.assertEqual(list(range(a, a+2)), [a, a+1]) |
| 1554 self.assertEqual(list(range(a+2, a, -1)), [a+2, a+1]) | 1554 self.assertEqual(list(range(a+2, a, -1)), [a+2, a+1]) |
| 1555 self.assertEqual(list(range(a+4, a, -2)), [a+4, a+2]) | 1555 self.assertEqual(list(range(a+4, a, -2)), [a+4, a+2]) |
| 1556 | 1556 |
| 1557 seq = list(range(a, b, c)) | 1557 seq = list(range(a, b, c)) |
| 1558 self.assert_(a in seq) | 1558 self.assert_(a in seq) |
| 1559 self.assert_(b not in seq) | 1559 self.assert_(b not in seq) |
| 1560 self.assertEqual(len(seq), 2) | 1560 self.assertEqual(len(seq), 2) |
| 1561 | 1561 |
| 1562 seq = list(range(b, a, -c)) | 1562 seq = list(range(b, a, -c)) |
| 1563 self.assert_(b in seq) | 1563 self.assert_(b in seq) |
| 1564 self.assert_(a not in seq) | 1564 self.assert_(a not in seq) |
| 1565 self.assertEqual(len(seq), 2) | 1565 self.assertEqual(len(seq), 2) |
| 1566 | 1566 |
| 1567 seq = list(range(-a, -b, -c)) | 1567 seq = list(range(-a, -b, -c)) |
| 1568 self.assert_(-a in seq) | 1568 self.assert_(-a in seq) |
| 1569 self.assert_(-b not in seq) | 1569 self.assert_(-b not in seq) |
| 1570 self.assertEqual(len(seq), 2) | 1570 self.assertEqual(len(seq), 2) |
| 1571 | 1571 |
| 1572 self.assertRaises(TypeError, range) | 1572 self.assertRaises(TypeError, range) |
| 1573 self.assertRaises(TypeError, range, 1, 2, 3, 4) | 1573 self.assertRaises(TypeError, range, 1, 2, 3, 4) |
| 1574 self.assertRaises(ValueError, range, 1, 2, 0) | 1574 self.assertRaises(ValueError, range, 1, 2, 0) |
| 1575 self.assertRaises(ValueError, range, a, a + 1, int(0)) | 1575 self.assertRaises(ValueError, range, a, a + 1, int(0)) |
| 1576 | 1576 |
| 1577 class badzero(int): | 1577 class badzero(int): |
| 1578 def __eq__(self, other): | 1578 def __eq__(self, other): |
| 1579 raise RuntimeError | 1579 raise RuntimeError |
| 1580 __ne__ = __lt__ = __gt__ = __le__ = __ge__ = __eq__ | 1580 __ne__ = __lt__ = __gt__ = __le__ = __ge__ = __eq__ |
| 1581 | 1581 |
| 1582 # XXX This won't (but should!) raise RuntimeError if a is an int... | 1582 # XXX This won't (but should!) raise RuntimeError if a is an int... |
| 1583 self.assertRaises(RuntimeError, range, a, a + 1, badzero(1)) | 1583 self.assertRaises(RuntimeError, range, a, a + 1, badzero(1)) |
| 1584 """ | 1584 """ |
| 1585 | 1585 |
| 1586 # Reject floats when it would require PyLongs to represent. | 1586 # Reject floats when it would require PyLongs to represent. |
| 1587 # (smaller floats still accepted, but deprecated) | 1587 # (smaller floats still accepted, but deprecated) |
| 1588 self.assertRaises(TypeError, range, 1e100, 1e101, 1e101) | 1588 self.assertRaises(TypeError, range, 1e100, 1e101, 1e101) |
| 1589 | 1589 |
| 1590 self.assertRaises(TypeError, range, 0, "spam") | 1590 self.assertRaises(TypeError, range, 0, "spam") |
| 1591 self.assertRaises(TypeError, range, 0, 42, "spam") | 1591 self.assertRaises(TypeError, range, 0, 42, "spam") |
| 1592 | 1592 |
| 1593 #NEAL self.assertRaises(OverflowError, range, -sys.maxsize, sys.maxsize) | 1593 #NEAL self.assertRaises(OverflowError, range, -sys.maxsize, sys.maxsize) |
| 1594 #NEAL self.assertRaises(OverflowError, range, 0, 2*sys.maxsize) | 1594 #NEAL self.assertRaises(OverflowError, range, 0, 2*sys.maxsize) |
| 1595 | |
| 1596 self.assertRaises(OverflowError, len, range(0, sys.maxsize**10)) | |
| 1597 | 1595 |
| 1598 def test_input(self): | 1596 def test_input(self): |
| 1599 self.write_testfile() | 1597 self.write_testfile() |
| 1600 fp = open(TESTFN, 'r') | 1598 fp = open(TESTFN, 'r') |
| 1601 savestdin = sys.stdin | 1599 savestdin = sys.stdin |
| 1602 savestdout = sys.stdout # Eats the echo | 1600 savestdout = sys.stdout # Eats the echo |
| 1603 try: | 1601 try: |
| 1604 sys.stdin = fp | 1602 sys.stdin = fp |
| 1605 sys.stdout = BitBucket() | 1603 sys.stdout = BitBucket() |
| 1606 self.assertEqual(input(), "1+1") | 1604 self.assertEqual(input(), "1+1") |
| 1607 self.assertEqual(input('testing\n'), "1+1") | 1605 self.assertEqual(input('testing\n'), "1+1") |
| 1608 self.assertEqual(input(), 'The quick brown fox jumps over the lazy d
og.') | 1606 self.assertEqual(input(), 'The quick brown fox jumps over the lazy d
og.') |
| 1609 self.assertEqual(input('testing\n'), 'Dear John') | 1607 self.assertEqual(input('testing\n'), 'Dear John') |
| 1610 | 1608 |
| 1611 # SF 1535165: don't segfault on closed stdin | 1609 # SF 1535165: don't segfault on closed stdin |
| 1612 # sys.stdout must be a regular file for triggering | 1610 # sys.stdout must be a regular file for triggering |
| 1613 sys.stdout = savestdout | 1611 sys.stdout = savestdout |
| 1614 sys.stdin.close() | 1612 sys.stdin.close() |
| 1615 self.assertRaises(ValueError, input) | 1613 self.assertRaises(ValueError, input) |
| 1616 | 1614 |
| 1617 sys.stdout = BitBucket() | 1615 sys.stdout = BitBucket() |
| 1618 sys.stdin = io.StringIO("NULL\0") | 1616 sys.stdin = io.StringIO("NULL\0") |
| 1619 self.assertRaises(TypeError, input, 42, 42) | 1617 self.assertRaises(TypeError, input, 42, 42) |
| 1620 sys.stdin = io.StringIO(" 'whitespace'") | 1618 sys.stdin = io.StringIO(" 'whitespace'") |
| 1621 self.assertEqual(input(), " 'whitespace'") | 1619 self.assertEqual(input(), " 'whitespace'") |
| 1622 sys.stdin = io.StringIO() | 1620 sys.stdin = io.StringIO() |
| 1623 self.assertRaises(EOFError, input) | 1621 self.assertRaises(EOFError, input) |
| 1624 | 1622 |
| 1625 del sys.stdout | 1623 del sys.stdout |
| 1626 self.assertRaises(RuntimeError, input, 'prompt') | 1624 self.assertRaises(RuntimeError, input, 'prompt') |
| 1627 del sys.stdin | 1625 del sys.stdin |
| 1628 self.assertRaises(RuntimeError, input, 'prompt') | 1626 self.assertRaises(RuntimeError, input, 'prompt') |
| 1629 finally: | 1627 finally: |
| 1630 sys.stdin = savestdin | 1628 sys.stdin = savestdin |
| 1631 sys.stdout = savestdout | 1629 sys.stdout = savestdout |
| 1632 fp.close() | 1630 fp.close() |
| 1633 unlink(TESTFN) | 1631 unlink(TESTFN) |
| 1634 | 1632 |
| 1635 def test_repr(self): | 1633 def test_repr(self): |
| 1636 self.assertEqual(repr(''), '\'\'') | 1634 self.assertEqual(repr(''), '\'\'') |
| 1637 self.assertEqual(repr(0), '0') | 1635 self.assertEqual(repr(0), '0') |
| 1638 self.assertEqual(repr(0), '0') | 1636 self.assertEqual(repr(0), '0') |
| 1639 self.assertEqual(repr(()), '()') | 1637 self.assertEqual(repr(()), '()') |
| 1640 self.assertEqual(repr([]), '[]') | 1638 self.assertEqual(repr([]), '[]') |
| 1641 self.assertEqual(repr({}), '{}') | 1639 self.assertEqual(repr({}), '{}') |
| 1642 a = [] | 1640 a = [] |
| 1643 a.append(a) | 1641 a.append(a) |
| 1644 self.assertEqual(repr(a), '[[...]]') | 1642 self.assertEqual(repr(a), '[[...]]') |
| 1645 a = {} | 1643 a = {} |
| 1646 a[0] = a | 1644 a[0] = a |
| (...skipping 205 matching lines...) Show 10 above Show 10 below |
| 1852 class TestSorted(unittest.TestCase): | 1850 class TestSorted(unittest.TestCase): |
| 1853 | 1851 |
| 1854 def test_basic(self): | 1852 def test_basic(self): |
| 1855 data = list(range(100)) | 1853 data = list(range(100)) |
| 1856 copy = data[:] | 1854 copy = data[:] |
| 1857 random.shuffle(copy) | 1855 random.shuffle(copy) |
| 1858 self.assertEqual(data, sorted(copy)) | 1856 self.assertEqual(data, sorted(copy)) |
| 1859 self.assertNotEqual(data, copy) | 1857 self.assertNotEqual(data, copy) |
| 1860 | 1858 |
| 1861 data.reverse() | 1859 data.reverse() |
| 1862 random.shuffle(copy) | 1860 random.shuffle(copy) |
| 1863 self.assertEqual(data, sorted(copy, key=lambda x: -x)) | 1861 self.assertEqual(data, sorted(copy, key=lambda x: -x)) |
| 1864 self.assertNotEqual(data, copy) | 1862 self.assertNotEqual(data, copy) |
| 1865 random.shuffle(copy) | 1863 random.shuffle(copy) |
| 1866 self.assertEqual(data, sorted(copy, reverse=1)) | 1864 self.assertEqual(data, sorted(copy, reverse=1)) |
| 1867 self.assertNotEqual(data, copy) | 1865 self.assertNotEqual(data, copy) |
| 1868 | 1866 |
| 1869 def test_inputtypes(self): | 1867 def test_inputtypes(self): |
| 1870 s = 'abracadabra' | 1868 s = 'abracadabra' |
| 1871 types = [list, tuple, str] | 1869 types = [list, tuple, str] |
| 1872 for T in types: | 1870 for T in types: |
| 1873 self.assertEqual(sorted(s), sorted(T(s))) | 1871 self.assertEqual(sorted(s), sorted(T(s))) |
| 1874 | 1872 |
| 1875 s = ''.join(set(s)) # unique letters only | 1873 s = ''.join(set(s)) # unique letters only |
| 1876 types = [str, set, frozenset, list, tuple, dict.fromkeys] | 1874 types = [str, set, frozenset, list, tuple, dict.fromkeys] |
| 1877 for T in types: | 1875 for T in types: |
| 1878 self.assertEqual(sorted(s), sorted(T(s))) | 1876 self.assertEqual(sorted(s), sorted(T(s))) |
| 1879 | 1877 |
| 1880 def test_baddecorator(self): | 1878 def test_baddecorator(self): |
| 1881 data = 'The quick Brown fox Jumped over The lazy Dog'.split() | 1879 data = 'The quick Brown fox Jumped over The lazy Dog'.split() |
| 1882 self.assertRaises(TypeError, sorted, data, None, lambda x,y: 0) | 1880 self.assertRaises(TypeError, sorted, data, None, lambda x,y: 0) |
| 1883 | 1881 |
| 1884 def test_main(verbose=None): | 1882 def test_main(verbose=None): |
| 1885 test_classes = (BuiltinTest, TestSorted) | 1883 test_classes = (BuiltinTest, TestSorted) |
| 1886 | 1884 |
| 1887 run_unittest(*test_classes) | 1885 run_unittest(*test_classes) |
| 1888 | 1886 |
| 1889 # verify reference counting | 1887 # verify reference counting |
| 1890 if verbose and hasattr(sys, "gettotalrefcount"): | 1888 if verbose and hasattr(sys, "gettotalrefcount"): |
| 1891 import gc | 1889 import gc |
| 1892 counts = [None] * 5 | 1890 counts = [None] * 5 |
| 1893 for i in range(len(counts)): | 1891 for i in range(len(counts)): |
| 1894 run_unittest(*test_classes) | 1892 run_unittest(*test_classes) |
| 1895 gc.collect() | 1893 gc.collect() |
| 1896 counts[i] = sys.gettotalrefcount() | 1894 counts[i] = sys.gettotalrefcount() |
| 1897 print(counts) | 1895 print(counts) |
| 1898 | 1896 |
| 1899 | 1897 |
| 1900 if __name__ == "__main__": | 1898 if __name__ == "__main__": |
| 1901 test_main(verbose=True) | 1899 test_main(verbose=True) |
| OLD | NEW |
|---|
