diff options
Diffstat (limited to 'lib/python2.7/test/test_repr.py')
| -rw-r--r-- | lib/python2.7/test/test_repr.py | 327 |
1 files changed, 0 insertions, 327 deletions
diff --git a/lib/python2.7/test/test_repr.py b/lib/python2.7/test/test_repr.py deleted file mode 100644 index 062fccf..0000000 --- a/lib/python2.7/test/test_repr.py +++ /dev/null @@ -1,327 +0,0 @@ -""" - Test cases for the repr module - Nick Mathewson -""" - -import sys -import os -import shutil -import unittest - -from test.test_support import run_unittest, check_py3k_warnings -from repr import repr as r # Don't shadow builtin repr -from repr import Repr - - -def nestedTuple(nesting): - t = () - for i in range(nesting): - t = (t,) - return t - -class ReprTests(unittest.TestCase): - - def test_string(self): - eq = self.assertEqual - eq(r("abc"), "'abc'") - eq(r("abcdefghijklmnop"),"'abcdefghijklmnop'") - - s = "a"*30+"b"*30 - expected = repr(s)[:13] + "..." + repr(s)[-14:] - eq(r(s), expected) - - eq(r("\"'"), repr("\"'")) - s = "\""*30+"'"*100 - expected = repr(s)[:13] + "..." + repr(s)[-14:] - eq(r(s), expected) - - def test_tuple(self): - eq = self.assertEqual - eq(r((1,)), "(1,)") - - t3 = (1, 2, 3) - eq(r(t3), "(1, 2, 3)") - - r2 = Repr() - r2.maxtuple = 2 - expected = repr(t3)[:-2] + "...)" - eq(r2.repr(t3), expected) - - def test_container(self): - from array import array - from collections import deque - - eq = self.assertEqual - # Tuples give up after 6 elements - eq(r(()), "()") - eq(r((1,)), "(1,)") - eq(r((1, 2, 3)), "(1, 2, 3)") - eq(r((1, 2, 3, 4, 5, 6)), "(1, 2, 3, 4, 5, 6)") - eq(r((1, 2, 3, 4, 5, 6, 7)), "(1, 2, 3, 4, 5, 6, ...)") - - # Lists give up after 6 as well - eq(r([]), "[]") - eq(r([1]), "[1]") - eq(r([1, 2, 3]), "[1, 2, 3]") - eq(r([1, 2, 3, 4, 5, 6]), "[1, 2, 3, 4, 5, 6]") - eq(r([1, 2, 3, 4, 5, 6, 7]), "[1, 2, 3, 4, 5, 6, ...]") - - # Sets give up after 6 as well - eq(r(set([])), "set([])") - eq(r(set([1])), "set([1])") - eq(r(set([1, 2, 3])), "set([1, 2, 3])") - eq(r(set([1, 2, 3, 4, 5, 6])), "set([1, 2, 3, 4, 5, 6])") - eq(r(set([1, 2, 3, 4, 5, 6, 7])), "set([1, 2, 3, 4, 5, 6, ...])") - - # Frozensets give up after 6 as well - eq(r(frozenset([])), "frozenset([])") - eq(r(frozenset([1])), "frozenset([1])") - eq(r(frozenset([1, 2, 3])), "frozenset([1, 2, 3])") - eq(r(frozenset([1, 2, 3, 4, 5, 6])), "frozenset([1, 2, 3, 4, 5, 6])") - eq(r(frozenset([1, 2, 3, 4, 5, 6, 7])), "frozenset([1, 2, 3, 4, 5, 6, ...])") - - # collections.deque after 6 - eq(r(deque([1, 2, 3, 4, 5, 6, 7])), "deque([1, 2, 3, 4, 5, 6, ...])") - - # Dictionaries give up after 4. - eq(r({}), "{}") - d = {'alice': 1, 'bob': 2, 'charles': 3, 'dave': 4} - eq(r(d), "{'alice': 1, 'bob': 2, 'charles': 3, 'dave': 4}") - d['arthur'] = 1 - eq(r(d), "{'alice': 1, 'arthur': 1, 'bob': 2, 'charles': 3, ...}") - - # array.array after 5. - eq(r(array('i')), "array('i', [])") - eq(r(array('i', [1])), "array('i', [1])") - eq(r(array('i', [1, 2])), "array('i', [1, 2])") - eq(r(array('i', [1, 2, 3])), "array('i', [1, 2, 3])") - eq(r(array('i', [1, 2, 3, 4])), "array('i', [1, 2, 3, 4])") - eq(r(array('i', [1, 2, 3, 4, 5])), "array('i', [1, 2, 3, 4, 5])") - eq(r(array('i', [1, 2, 3, 4, 5, 6])), - "array('i', [1, 2, 3, 4, 5, ...])") - - def test_numbers(self): - eq = self.assertEqual - eq(r(123), repr(123)) - eq(r(123L), repr(123L)) - eq(r(1.0/3), repr(1.0/3)) - - n = 10L**100 - expected = repr(n)[:18] + "..." + repr(n)[-19:] - eq(r(n), expected) - - def test_instance(self): - eq = self.assertEqual - i1 = ClassWithRepr("a") - eq(r(i1), repr(i1)) - - i2 = ClassWithRepr("x"*1000) - expected = repr(i2)[:13] + "..." + repr(i2)[-14:] - eq(r(i2), expected) - - i3 = ClassWithFailingRepr() - eq(r(i3), ("<ClassWithFailingRepr instance at %x>"%id(i3))) - - s = r(ClassWithFailingRepr) - self.assertTrue(s.startswith("<class ")) - self.assertTrue(s.endswith(">")) - self.assertTrue(s.find("...") == 8) - - def test_file(self): - fp = open(unittest.__file__) - self.assertTrue(repr(fp).startswith( - "<open file %r, mode 'r' at 0x" % unittest.__file__)) - fp.close() - self.assertTrue(repr(fp).startswith( - "<closed file %r, mode 'r' at 0x" % unittest.__file__)) - - def test_lambda(self): - self.assertTrue(repr(lambda x: x).startswith( - "<function <lambda")) - # XXX anonymous functions? see func_repr - - def test_builtin_function(self): - eq = self.assertEqual - # Functions - eq(repr(hash), '<built-in function hash>') - # Methods - self.assertTrue(repr(''.split).startswith( - '<built-in method split of str object at 0x')) - - def test_xrange(self): - eq = self.assertEqual - eq(repr(xrange(1)), 'xrange(1)') - eq(repr(xrange(1, 2)), 'xrange(1, 2)') - eq(repr(xrange(1, 2, 3)), 'xrange(1, 4, 3)') - - def test_nesting(self): - eq = self.assertEqual - # everything is meant to give up after 6 levels. - eq(r([[[[[[[]]]]]]]), "[[[[[[[]]]]]]]") - eq(r([[[[[[[[]]]]]]]]), "[[[[[[[...]]]]]]]") - - eq(r(nestedTuple(6)), "(((((((),),),),),),)") - eq(r(nestedTuple(7)), "(((((((...),),),),),),)") - - eq(r({ nestedTuple(5) : nestedTuple(5) }), - "{((((((),),),),),): ((((((),),),),),)}") - eq(r({ nestedTuple(6) : nestedTuple(6) }), - "{((((((...),),),),),): ((((((...),),),),),)}") - - eq(r([[[[[[{}]]]]]]), "[[[[[[{}]]]]]]") - eq(r([[[[[[[{}]]]]]]]), "[[[[[[[...]]]]]]]") - - def test_buffer(self): - # XXX doesn't test buffers with no b_base or read-write buffers (see - # bufferobject.c). The test is fairly incomplete too. Sigh. - with check_py3k_warnings(): - x = buffer('foo') - self.assertTrue(repr(x).startswith('<read-only buffer for 0x')) - - def test_cell(self): - # XXX Hmm? How to get at a cell object? - pass - - def test_descriptors(self): - eq = self.assertEqual - # method descriptors - eq(repr(dict.items), "<method 'items' of 'dict' objects>") - # XXX member descriptors - # XXX attribute descriptors - # XXX slot descriptors - # static and class methods - class C: - def foo(cls): pass - x = staticmethod(C.foo) - self.assertTrue(repr(x).startswith('<staticmethod object at 0x')) - x = classmethod(C.foo) - self.assertTrue(repr(x).startswith('<classmethod object at 0x')) - - def test_unsortable(self): - # Repr.repr() used to call sorted() on sets, frozensets and dicts - # without taking into account that not all objects are comparable - x = set([1j, 2j, 3j]) - y = frozenset(x) - z = {1j: 1, 2j: 2} - r(x) - r(y) - r(z) - -def touch(path, text=''): - fp = open(path, 'w') - fp.write(text) - fp.close() - -class LongReprTest(unittest.TestCase): - def setUp(self): - longname = 'areallylongpackageandmodulenametotestreprtruncation' - self.pkgname = os.path.join(longname) - self.subpkgname = os.path.join(longname, longname) - # Make the package and subpackage - shutil.rmtree(self.pkgname, ignore_errors=True) - os.mkdir(self.pkgname) - touch(os.path.join(self.pkgname, '__init__'+os.extsep+'py')) - shutil.rmtree(self.subpkgname, ignore_errors=True) - os.mkdir(self.subpkgname) - touch(os.path.join(self.subpkgname, '__init__'+os.extsep+'py')) - # Remember where we are - self.here = os.getcwd() - sys.path.insert(0, self.here) - - def tearDown(self): - actions = [] - for dirpath, dirnames, filenames in os.walk(self.pkgname): - for name in dirnames + filenames: - actions.append(os.path.join(dirpath, name)) - actions.append(self.pkgname) - actions.sort() - actions.reverse() - for p in actions: - if os.path.isdir(p): - os.rmdir(p) - else: - os.remove(p) - del sys.path[0] - - def test_module(self): - eq = self.assertEqual - touch(os.path.join(self.subpkgname, self.pkgname + os.extsep + 'py')) - from areallylongpackageandmodulenametotestreprtruncation.areallylongpackageandmodulenametotestreprtruncation import areallylongpackageandmodulenametotestreprtruncation - eq(repr(areallylongpackageandmodulenametotestreprtruncation), - "<module '%s' from '%s'>" % (areallylongpackageandmodulenametotestreprtruncation.__name__, areallylongpackageandmodulenametotestreprtruncation.__file__)) - eq(repr(sys), "<module 'sys' (built-in)>") - - def test_type(self): - eq = self.assertEqual - touch(os.path.join(self.subpkgname, 'foo'+os.extsep+'py'), '''\ -class foo(object): - pass -''') - from areallylongpackageandmodulenametotestreprtruncation.areallylongpackageandmodulenametotestreprtruncation import foo - eq(repr(foo.foo), - "<class '%s.foo'>" % foo.__name__) - - def test_object(self): - # XXX Test the repr of a type with a really long tp_name but with no - # tp_repr. WIBNI we had ::Inline? :) - pass - - def test_class(self): - touch(os.path.join(self.subpkgname, 'bar'+os.extsep+'py'), '''\ -class bar: - pass -''') - from areallylongpackageandmodulenametotestreprtruncation.areallylongpackageandmodulenametotestreprtruncation import bar - # Module name may be prefixed with "test.", depending on how run. - self.assertTrue(repr(bar.bar).startswith( - "<class %s.bar at 0x" % bar.__name__)) - - def test_instance(self): - touch(os.path.join(self.subpkgname, 'baz'+os.extsep+'py'), '''\ -class baz: - pass -''') - from areallylongpackageandmodulenametotestreprtruncation.areallylongpackageandmodulenametotestreprtruncation import baz - ibaz = baz.baz() - self.assertTrue(repr(ibaz).startswith( - "<%s.baz instance at 0x" % baz.__name__)) - - def test_method(self): - eq = self.assertEqual - touch(os.path.join(self.subpkgname, 'qux'+os.extsep+'py'), '''\ -class aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa: - def amethod(self): pass -''') - from areallylongpackageandmodulenametotestreprtruncation.areallylongpackageandmodulenametotestreprtruncation import qux - # Unbound methods first - eq(repr(qux.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa.amethod), - '<unbound method aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa.amethod>') - # Bound method next - iqux = qux.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa() - self.assertTrue(repr(iqux.amethod).startswith( - '<bound method aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa.amethod of <%s.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa instance at 0x' \ - % (qux.__name__,) )) - - def test_builtin_function(self): - # XXX test built-in functions and methods with really long names - pass - -class ClassWithRepr: - def __init__(self, s): - self.s = s - def __repr__(self): - return "ClassWithLongRepr(%r)" % self.s - - -class ClassWithFailingRepr: - def __repr__(self): - raise Exception("This should be caught by Repr.repr_instance") - - -def test_main(): - run_unittest(ReprTests) - run_unittest(LongReprTest) - - -if __name__ == "__main__": - test_main() |