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, 327 insertions, 0 deletions
diff --git a/lib/python2.7/test/test_repr.py b/lib/python2.7/test/test_repr.py new file mode 100644 index 0000000..062fccf --- /dev/null +++ b/lib/python2.7/test/test_repr.py @@ -0,0 +1,327 @@ +""" + 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() |