Fred Drake | 8e6669a | 2001-07-19 22:27:56 +0000 | [diff] [blame] | 1 | """ |
| 2 | Test cases for the repr module |
| 3 | Nick Mathewson |
| 4 | """ |
| 5 | |
Barry Warsaw | 0bcf6d8 | 2001-08-24 18:37:32 +0000 | [diff] [blame] | 6 | import sys |
| 7 | import os |
Thomas Wouters | 4d70c3d | 2006-06-08 14:42:34 +0000 | [diff] [blame] | 8 | import shutil |
Antoine Pitrou | c541f8e | 2012-02-20 01:48:16 +0100 | [diff] [blame] | 9 | import importlib |
Brett Cannon | 9529fbf | 2013-06-15 17:11:25 -0400 | [diff] [blame] | 10 | import importlib.util |
Fred Drake | 8e6669a | 2001-07-19 22:27:56 +0000 | [diff] [blame] | 11 | import unittest |
Barry Warsaw | 0bcf6d8 | 2001-08-24 18:37:32 +0000 | [diff] [blame] | 12 | |
Raymond Hettinger | ffd842e | 2014-11-09 22:30:36 -0800 | [diff] [blame] | 13 | from test.support import create_empty_file, verbose |
Alexandre Vassalotti | 1f2ba4b | 2008-05-16 07:12:44 +0000 | [diff] [blame] | 14 | from reprlib import repr as r # Don't shadow builtin repr |
| 15 | from reprlib import Repr |
Raymond Hettinger | 98a5f3f | 2010-09-13 21:36:00 +0000 | [diff] [blame] | 16 | from reprlib import recursive_repr |
Fred Drake | 8e6669a | 2001-07-19 22:27:56 +0000 | [diff] [blame] | 17 | |
| 18 | |
| 19 | def nestedTuple(nesting): |
| 20 | t = () |
| 21 | for i in range(nesting): |
| 22 | t = (t,) |
| 23 | return t |
| 24 | |
| 25 | class ReprTests(unittest.TestCase): |
| 26 | |
| 27 | def test_string(self): |
Ezio Melotti | b3aedd4 | 2010-11-20 19:04:17 +0000 | [diff] [blame] | 28 | eq = self.assertEqual |
Fred Drake | 8e6669a | 2001-07-19 22:27:56 +0000 | [diff] [blame] | 29 | eq(r("abc"), "'abc'") |
| 30 | eq(r("abcdefghijklmnop"),"'abcdefghijklmnop'") |
| 31 | |
| 32 | s = "a"*30+"b"*30 |
Walter Dörwald | 70a6b49 | 2004-02-12 17:35:32 +0000 | [diff] [blame] | 33 | expected = repr(s)[:13] + "..." + repr(s)[-14:] |
Fred Drake | 8e6669a | 2001-07-19 22:27:56 +0000 | [diff] [blame] | 34 | eq(r(s), expected) |
Tim Peters | ab9ba27 | 2001-08-09 21:40:30 +0000 | [diff] [blame] | 35 | |
Fred Drake | 8e6669a | 2001-07-19 22:27:56 +0000 | [diff] [blame] | 36 | eq(r("\"'"), repr("\"'")) |
| 37 | s = "\""*30+"'"*100 |
Walter Dörwald | 70a6b49 | 2004-02-12 17:35:32 +0000 | [diff] [blame] | 38 | expected = repr(s)[:13] + "..." + repr(s)[-14:] |
Fred Drake | 8e6669a | 2001-07-19 22:27:56 +0000 | [diff] [blame] | 39 | eq(r(s), expected) |
| 40 | |
Guido van Rossum | cd16bf6 | 2007-06-13 18:07:49 +0000 | [diff] [blame] | 41 | def test_tuple(self): |
Ezio Melotti | b3aedd4 | 2010-11-20 19:04:17 +0000 | [diff] [blame] | 42 | eq = self.assertEqual |
Guido van Rossum | cd16bf6 | 2007-06-13 18:07:49 +0000 | [diff] [blame] | 43 | eq(r((1,)), "(1,)") |
| 44 | |
| 45 | t3 = (1, 2, 3) |
| 46 | eq(r(t3), "(1, 2, 3)") |
| 47 | |
| 48 | r2 = Repr() |
| 49 | r2.maxtuple = 2 |
| 50 | expected = repr(t3)[:-2] + "...)" |
| 51 | eq(r2.repr(t3), expected) |
| 52 | |
Fred Drake | 8e6669a | 2001-07-19 22:27:56 +0000 | [diff] [blame] | 53 | def test_container(self): |
Tim Peters | 6ee0480 | 2003-02-05 18:29:34 +0000 | [diff] [blame] | 54 | from array import array |
Raymond Hettinger | 1453e4a | 2004-05-21 23:01:18 +0000 | [diff] [blame] | 55 | from collections import deque |
Tim Peters | 6ee0480 | 2003-02-05 18:29:34 +0000 | [diff] [blame] | 56 | |
Ezio Melotti | b3aedd4 | 2010-11-20 19:04:17 +0000 | [diff] [blame] | 57 | eq = self.assertEqual |
Fred Drake | 8e6669a | 2001-07-19 22:27:56 +0000 | [diff] [blame] | 58 | # Tuples give up after 6 elements |
| 59 | eq(r(()), "()") |
| 60 | eq(r((1,)), "(1,)") |
| 61 | eq(r((1, 2, 3)), "(1, 2, 3)") |
| 62 | eq(r((1, 2, 3, 4, 5, 6)), "(1, 2, 3, 4, 5, 6)") |
| 63 | eq(r((1, 2, 3, 4, 5, 6, 7)), "(1, 2, 3, 4, 5, 6, ...)") |
| 64 | |
| 65 | # Lists give up after 6 as well |
| 66 | eq(r([]), "[]") |
| 67 | eq(r([1]), "[1]") |
| 68 | eq(r([1, 2, 3]), "[1, 2, 3]") |
| 69 | eq(r([1, 2, 3, 4, 5, 6]), "[1, 2, 3, 4, 5, 6]") |
| 70 | eq(r([1, 2, 3, 4, 5, 6, 7]), "[1, 2, 3, 4, 5, 6, ...]") |
| 71 | |
Raymond Hettinger | ba6cd36 | 2004-05-21 10:00:15 +0000 | [diff] [blame] | 72 | # Sets give up after 6 as well |
Raymond Hettinger | ffd842e | 2014-11-09 22:30:36 -0800 | [diff] [blame] | 73 | eq(r(set([])), "set()") |
| 74 | eq(r(set([1])), "{1}") |
| 75 | eq(r(set([1, 2, 3])), "{1, 2, 3}") |
| 76 | eq(r(set([1, 2, 3, 4, 5, 6])), "{1, 2, 3, 4, 5, 6}") |
| 77 | eq(r(set([1, 2, 3, 4, 5, 6, 7])), "{1, 2, 3, 4, 5, 6, ...}") |
Raymond Hettinger | ba6cd36 | 2004-05-21 10:00:15 +0000 | [diff] [blame] | 78 | |
| 79 | # Frozensets give up after 6 as well |
Raymond Hettinger | ffd842e | 2014-11-09 22:30:36 -0800 | [diff] [blame] | 80 | eq(r(frozenset([])), "frozenset()") |
| 81 | eq(r(frozenset([1])), "frozenset({1})") |
| 82 | eq(r(frozenset([1, 2, 3])), "frozenset({1, 2, 3})") |
| 83 | eq(r(frozenset([1, 2, 3, 4, 5, 6])), "frozenset({1, 2, 3, 4, 5, 6})") |
| 84 | eq(r(frozenset([1, 2, 3, 4, 5, 6, 7])), "frozenset({1, 2, 3, 4, 5, 6, ...})") |
Raymond Hettinger | ba6cd36 | 2004-05-21 10:00:15 +0000 | [diff] [blame] | 85 | |
Raymond Hettinger | 1453e4a | 2004-05-21 23:01:18 +0000 | [diff] [blame] | 86 | # collections.deque after 6 |
| 87 | eq(r(deque([1, 2, 3, 4, 5, 6, 7])), "deque([1, 2, 3, 4, 5, 6, ...])") |
| 88 | |
Fred Drake | 8e6669a | 2001-07-19 22:27:56 +0000 | [diff] [blame] | 89 | # Dictionaries give up after 4. |
| 90 | eq(r({}), "{}") |
| 91 | d = {'alice': 1, 'bob': 2, 'charles': 3, 'dave': 4} |
| 92 | eq(r(d), "{'alice': 1, 'bob': 2, 'charles': 3, 'dave': 4}") |
| 93 | d['arthur'] = 1 |
| 94 | eq(r(d), "{'alice': 1, 'arthur': 1, 'bob': 2, 'charles': 3, ...}") |
| 95 | |
Tim Peters | 6ee0480 | 2003-02-05 18:29:34 +0000 | [diff] [blame] | 96 | # array.array after 5. |
Raymond Hettinger | a34cd0c | 2014-11-15 10:58:58 -0800 | [diff] [blame] | 97 | eq(r(array('i')), "array('i')") |
Tim Peters | 6ee0480 | 2003-02-05 18:29:34 +0000 | [diff] [blame] | 98 | eq(r(array('i', [1])), "array('i', [1])") |
| 99 | eq(r(array('i', [1, 2])), "array('i', [1, 2])") |
| 100 | eq(r(array('i', [1, 2, 3])), "array('i', [1, 2, 3])") |
| 101 | eq(r(array('i', [1, 2, 3, 4])), "array('i', [1, 2, 3, 4])") |
| 102 | eq(r(array('i', [1, 2, 3, 4, 5])), "array('i', [1, 2, 3, 4, 5])") |
| 103 | eq(r(array('i', [1, 2, 3, 4, 5, 6])), |
| 104 | "array('i', [1, 2, 3, 4, 5, ...])") |
| 105 | |
Raymond Hettinger | ffd842e | 2014-11-09 22:30:36 -0800 | [diff] [blame] | 106 | def test_set_literal(self): |
| 107 | eq = self.assertEqual |
| 108 | eq(r({1}), "{1}") |
| 109 | eq(r({1, 2, 3}), "{1, 2, 3}") |
| 110 | eq(r({1, 2, 3, 4, 5, 6}), "{1, 2, 3, 4, 5, 6}") |
| 111 | eq(r({1, 2, 3, 4, 5, 6, 7}), "{1, 2, 3, 4, 5, 6, ...}") |
| 112 | |
| 113 | def test_frozenset(self): |
| 114 | eq = self.assertEqual |
| 115 | eq(r(frozenset({1})), "frozenset({1})") |
| 116 | eq(r(frozenset({1, 2, 3})), "frozenset({1, 2, 3})") |
| 117 | eq(r(frozenset({1, 2, 3, 4, 5, 6})), "frozenset({1, 2, 3, 4, 5, 6})") |
| 118 | eq(r(frozenset({1, 2, 3, 4, 5, 6, 7})), "frozenset({1, 2, 3, 4, 5, 6, ...})") |
| 119 | |
Fred Drake | 8e6669a | 2001-07-19 22:27:56 +0000 | [diff] [blame] | 120 | def test_numbers(self): |
Ezio Melotti | b3aedd4 | 2010-11-20 19:04:17 +0000 | [diff] [blame] | 121 | eq = self.assertEqual |
Fred Drake | 8e6669a | 2001-07-19 22:27:56 +0000 | [diff] [blame] | 122 | eq(r(123), repr(123)) |
Guido van Rossum | e2a383d | 2007-01-15 16:59:06 +0000 | [diff] [blame] | 123 | eq(r(123), repr(123)) |
Fred Drake | 8e6669a | 2001-07-19 22:27:56 +0000 | [diff] [blame] | 124 | eq(r(1.0/3), repr(1.0/3)) |
| 125 | |
Guido van Rossum | e2a383d | 2007-01-15 16:59:06 +0000 | [diff] [blame] | 126 | n = 10**100 |
Walter Dörwald | 70a6b49 | 2004-02-12 17:35:32 +0000 | [diff] [blame] | 127 | expected = repr(n)[:18] + "..." + repr(n)[-19:] |
Fred Drake | 8e6669a | 2001-07-19 22:27:56 +0000 | [diff] [blame] | 128 | eq(r(n), expected) |
| 129 | |
| 130 | def test_instance(self): |
Ezio Melotti | b3aedd4 | 2010-11-20 19:04:17 +0000 | [diff] [blame] | 131 | eq = self.assertEqual |
Fred Drake | 8e6669a | 2001-07-19 22:27:56 +0000 | [diff] [blame] | 132 | i1 = ClassWithRepr("a") |
| 133 | eq(r(i1), repr(i1)) |
Tim Peters | ab9ba27 | 2001-08-09 21:40:30 +0000 | [diff] [blame] | 134 | |
Fred Drake | 8e6669a | 2001-07-19 22:27:56 +0000 | [diff] [blame] | 135 | i2 = ClassWithRepr("x"*1000) |
Walter Dörwald | 70a6b49 | 2004-02-12 17:35:32 +0000 | [diff] [blame] | 136 | expected = repr(i2)[:13] + "..." + repr(i2)[-14:] |
Fred Drake | 8e6669a | 2001-07-19 22:27:56 +0000 | [diff] [blame] | 137 | eq(r(i2), expected) |
| 138 | |
| 139 | i3 = ClassWithFailingRepr() |
Serhiy Storchaka | 0c937b3 | 2014-07-22 12:14:52 +0300 | [diff] [blame] | 140 | eq(r(i3), ("<ClassWithFailingRepr instance at %#x>"%id(i3))) |
Fred Drake | 8e6669a | 2001-07-19 22:27:56 +0000 | [diff] [blame] | 141 | |
Guido van Rossum | cf856f9 | 2001-09-05 02:26:26 +0000 | [diff] [blame] | 142 | s = r(ClassWithFailingRepr) |
Benjamin Peterson | c9c0f20 | 2009-06-30 23:06:06 +0000 | [diff] [blame] | 143 | self.assertTrue(s.startswith("<class ")) |
| 144 | self.assertTrue(s.endswith(">")) |
Benjamin Peterson | 577473f | 2010-01-19 00:09:57 +0000 | [diff] [blame] | 145 | self.assertIn(s.find("..."), [12, 13]) |
Guido van Rossum | cf856f9 | 2001-09-05 02:26:26 +0000 | [diff] [blame] | 146 | |
Barry Warsaw | 0bcf6d8 | 2001-08-24 18:37:32 +0000 | [diff] [blame] | 147 | def test_lambda(self): |
Antoine Pitrou | 86a36b5 | 2011-11-25 18:56:07 +0100 | [diff] [blame] | 148 | r = repr(lambda x: x) |
| 149 | self.assertTrue(r.startswith("<function ReprTests.test_lambda.<locals>.<lambda"), r) |
Barry Warsaw | 0bcf6d8 | 2001-08-24 18:37:32 +0000 | [diff] [blame] | 150 | # XXX anonymous functions? see func_repr |
| 151 | |
| 152 | def test_builtin_function(self): |
Ezio Melotti | b3aedd4 | 2010-11-20 19:04:17 +0000 | [diff] [blame] | 153 | eq = self.assertEqual |
Barry Warsaw | 0bcf6d8 | 2001-08-24 18:37:32 +0000 | [diff] [blame] | 154 | # Functions |
| 155 | eq(repr(hash), '<built-in function hash>') |
| 156 | # Methods |
Benjamin Peterson | c9c0f20 | 2009-06-30 23:06:06 +0000 | [diff] [blame] | 157 | self.assertTrue(repr(''.split).startswith( |
Barry Warsaw | 0bcf6d8 | 2001-08-24 18:37:32 +0000 | [diff] [blame] | 158 | '<built-in method split of str object at 0x')) |
| 159 | |
Guido van Rossum | 805365e | 2007-05-07 22:24:25 +0000 | [diff] [blame] | 160 | def test_range(self): |
Ezio Melotti | b3aedd4 | 2010-11-20 19:04:17 +0000 | [diff] [blame] | 161 | eq = self.assertEqual |
Guido van Rossum | 3353a2e | 2007-05-21 18:14:54 +0000 | [diff] [blame] | 162 | eq(repr(range(1)), 'range(0, 1)') |
Guido van Rossum | 805365e | 2007-05-07 22:24:25 +0000 | [diff] [blame] | 163 | eq(repr(range(1, 2)), 'range(1, 2)') |
| 164 | eq(repr(range(1, 4, 3)), 'range(1, 4, 3)') |
Barry Warsaw | 0bcf6d8 | 2001-08-24 18:37:32 +0000 | [diff] [blame] | 165 | |
Fred Drake | 8e6669a | 2001-07-19 22:27:56 +0000 | [diff] [blame] | 166 | def test_nesting(self): |
Ezio Melotti | b3aedd4 | 2010-11-20 19:04:17 +0000 | [diff] [blame] | 167 | eq = self.assertEqual |
Fred Drake | 8e6669a | 2001-07-19 22:27:56 +0000 | [diff] [blame] | 168 | # everything is meant to give up after 6 levels. |
| 169 | eq(r([[[[[[[]]]]]]]), "[[[[[[[]]]]]]]") |
| 170 | eq(r([[[[[[[[]]]]]]]]), "[[[[[[[...]]]]]]]") |
| 171 | |
| 172 | eq(r(nestedTuple(6)), "(((((((),),),),),),)") |
| 173 | eq(r(nestedTuple(7)), "(((((((...),),),),),),)") |
| 174 | |
| 175 | eq(r({ nestedTuple(5) : nestedTuple(5) }), |
| 176 | "{((((((),),),),),): ((((((),),),),),)}") |
| 177 | eq(r({ nestedTuple(6) : nestedTuple(6) }), |
| 178 | "{((((((...),),),),),): ((((((...),),),),),)}") |
| 179 | |
| 180 | eq(r([[[[[[{}]]]]]]), "[[[[[[{}]]]]]]") |
| 181 | eq(r([[[[[[[{}]]]]]]]), "[[[[[[[...]]]]]]]") |
| 182 | |
Barry Warsaw | 0bcf6d8 | 2001-08-24 18:37:32 +0000 | [diff] [blame] | 183 | def test_cell(self): |
Serhiy Storchaka | 1f79cdf | 2013-12-10 10:20:31 +0200 | [diff] [blame] | 184 | def get_cell(): |
| 185 | x = 42 |
| 186 | def inner(): |
| 187 | return x |
| 188 | return inner |
| 189 | x = get_cell().__closure__[0] |
Zachary Ware | ea6854a | 2013-12-10 14:17:22 -0600 | [diff] [blame] | 190 | self.assertRegex(repr(x), r'<cell at 0x[0-9A-Fa-f]+: ' |
| 191 | r'int object at 0x[0-9A-Fa-f]+>') |
Serhiy Storchaka | 1f79cdf | 2013-12-10 10:20:31 +0200 | [diff] [blame] | 192 | self.assertRegex(r(x), r'<cell at 0x.*\.\.\..*>') |
Barry Warsaw | 0bcf6d8 | 2001-08-24 18:37:32 +0000 | [diff] [blame] | 193 | |
| 194 | def test_descriptors(self): |
Ezio Melotti | b3aedd4 | 2010-11-20 19:04:17 +0000 | [diff] [blame] | 195 | eq = self.assertEqual |
Barry Warsaw | 0bcf6d8 | 2001-08-24 18:37:32 +0000 | [diff] [blame] | 196 | # method descriptors |
Tim Peters | a427a2b | 2001-10-29 22:25:45 +0000 | [diff] [blame] | 197 | eq(repr(dict.items), "<method 'items' of 'dict' objects>") |
Barry Warsaw | 0bcf6d8 | 2001-08-24 18:37:32 +0000 | [diff] [blame] | 198 | # XXX member descriptors |
| 199 | # XXX attribute descriptors |
| 200 | # XXX slot descriptors |
| 201 | # static and class methods |
| 202 | class C: |
| 203 | def foo(cls): pass |
| 204 | x = staticmethod(C.foo) |
Benjamin Peterson | c9c0f20 | 2009-06-30 23:06:06 +0000 | [diff] [blame] | 205 | self.assertTrue(repr(x).startswith('<staticmethod object at 0x')) |
Barry Warsaw | 0bcf6d8 | 2001-08-24 18:37:32 +0000 | [diff] [blame] | 206 | x = classmethod(C.foo) |
Benjamin Peterson | c9c0f20 | 2009-06-30 23:06:06 +0000 | [diff] [blame] | 207 | self.assertTrue(repr(x).startswith('<classmethod object at 0x')) |
Barry Warsaw | 0bcf6d8 | 2001-08-24 18:37:32 +0000 | [diff] [blame] | 208 | |
Thomas Wouters | 1b7f891 | 2007-09-19 03:06:30 +0000 | [diff] [blame] | 209 | def test_unsortable(self): |
| 210 | # Repr.repr() used to call sorted() on sets, frozensets and dicts |
| 211 | # without taking into account that not all objects are comparable |
| 212 | x = set([1j, 2j, 3j]) |
| 213 | y = frozenset(x) |
| 214 | z = {1j: 1, 2j: 2} |
| 215 | r(x) |
| 216 | r(y) |
| 217 | r(z) |
| 218 | |
Victor Stinner | bf81622 | 2011-06-30 23:25:47 +0200 | [diff] [blame] | 219 | def write_file(path, text): |
| 220 | with open(path, 'w', encoding='ASCII') as fp: |
| 221 | fp.write(text) |
Barry Warsaw | 0bcf6d8 | 2001-08-24 18:37:32 +0000 | [diff] [blame] | 222 | |
Barry Warsaw | 0bcf6d8 | 2001-08-24 18:37:32 +0000 | [diff] [blame] | 223 | class LongReprTest(unittest.TestCase): |
Antoine Pitrou | 01296da | 2012-04-24 13:55:35 +0200 | [diff] [blame] | 224 | longname = 'areallylongpackageandmodulenametotestreprtruncation' |
| 225 | |
Barry Warsaw | 0bcf6d8 | 2001-08-24 18:37:32 +0000 | [diff] [blame] | 226 | def setUp(self): |
Antoine Pitrou | 01296da | 2012-04-24 13:55:35 +0200 | [diff] [blame] | 227 | self.pkgname = os.path.join(self.longname) |
| 228 | self.subpkgname = os.path.join(self.longname, self.longname) |
Barry Warsaw | 0bcf6d8 | 2001-08-24 18:37:32 +0000 | [diff] [blame] | 229 | # Make the package and subpackage |
Thomas Wouters | 4d70c3d | 2006-06-08 14:42:34 +0000 | [diff] [blame] | 230 | shutil.rmtree(self.pkgname, ignore_errors=True) |
Barry Warsaw | 0bcf6d8 | 2001-08-24 18:37:32 +0000 | [diff] [blame] | 231 | os.mkdir(self.pkgname) |
Victor Stinner | bf81622 | 2011-06-30 23:25:47 +0200 | [diff] [blame] | 232 | create_empty_file(os.path.join(self.pkgname, '__init__.py')) |
Thomas Wouters | 4d70c3d | 2006-06-08 14:42:34 +0000 | [diff] [blame] | 233 | shutil.rmtree(self.subpkgname, ignore_errors=True) |
Barry Warsaw | 0bcf6d8 | 2001-08-24 18:37:32 +0000 | [diff] [blame] | 234 | os.mkdir(self.subpkgname) |
Victor Stinner | bf81622 | 2011-06-30 23:25:47 +0200 | [diff] [blame] | 235 | create_empty_file(os.path.join(self.subpkgname, '__init__.py')) |
Barry Warsaw | 0bcf6d8 | 2001-08-24 18:37:32 +0000 | [diff] [blame] | 236 | # Remember where we are |
| 237 | self.here = os.getcwd() |
| 238 | sys.path.insert(0, self.here) |
Brett Cannon | ceffda8 | 2012-04-16 20:48:50 -0400 | [diff] [blame] | 239 | # When regrtest is run with its -j option, this command alone is not |
| 240 | # enough. |
Antoine Pitrou | c541f8e | 2012-02-20 01:48:16 +0100 | [diff] [blame] | 241 | importlib.invalidate_caches() |
Barry Warsaw | 0bcf6d8 | 2001-08-24 18:37:32 +0000 | [diff] [blame] | 242 | |
| 243 | def tearDown(self): |
| 244 | actions = [] |
Benjamin Peterson | 699adb9 | 2008-05-08 22:27:58 +0000 | [diff] [blame] | 245 | for dirpath, dirnames, filenames in os.walk(self.pkgname): |
| 246 | for name in dirnames + filenames: |
| 247 | actions.append(os.path.join(dirpath, name)) |
Barry Warsaw | 0bcf6d8 | 2001-08-24 18:37:32 +0000 | [diff] [blame] | 248 | actions.append(self.pkgname) |
| 249 | actions.sort() |
| 250 | actions.reverse() |
| 251 | for p in actions: |
| 252 | if os.path.isdir(p): |
| 253 | os.rmdir(p) |
| 254 | else: |
| 255 | os.remove(p) |
| 256 | del sys.path[0] |
| 257 | |
Antoine Pitrou | 01296da | 2012-04-24 13:55:35 +0200 | [diff] [blame] | 258 | def _check_path_limitations(self, module_name): |
| 259 | # base directory |
| 260 | source_path_len = len(self.here) |
| 261 | # a path separator + `longname` (twice) |
| 262 | source_path_len += 2 * (len(self.longname) + 1) |
| 263 | # a path separator + `module_name` + ".py" |
| 264 | source_path_len += len(module_name) + 1 + len(".py") |
Brett Cannon | 9529fbf | 2013-06-15 17:11:25 -0400 | [diff] [blame] | 265 | cached_path_len = (source_path_len + |
| 266 | len(importlib.util.cache_from_source("x.py")) - len("x.py")) |
Antoine Pitrou | 110ee34 | 2012-06-23 22:55:58 +0200 | [diff] [blame] | 267 | if os.name == 'nt' and cached_path_len >= 258: |
Antoine Pitrou | 01296da | 2012-04-24 13:55:35 +0200 | [diff] [blame] | 268 | # Under Windows, the max path len is 260 including C's terminating |
| 269 | # NUL character. |
| 270 | # (see http://msdn.microsoft.com/en-us/library/windows/desktop/aa365247%28v=vs.85%29.aspx#maxpath) |
| 271 | self.skipTest("test paths too long (%d characters) for Windows' 260 character limit" |
| 272 | % cached_path_len) |
Antoine Pitrou | 541b7c8 | 2012-06-23 00:07:38 +0200 | [diff] [blame] | 273 | elif os.name == 'nt' and verbose: |
Antoine Pitrou | f0f4742 | 2012-06-23 00:49:44 +0200 | [diff] [blame] | 274 | print("cached_path_len =", cached_path_len) |
Antoine Pitrou | 01296da | 2012-04-24 13:55:35 +0200 | [diff] [blame] | 275 | |
Barry Warsaw | 0bcf6d8 | 2001-08-24 18:37:32 +0000 | [diff] [blame] | 276 | def test_module(self): |
Eric Snow | b523f84 | 2013-11-22 09:05:39 -0700 | [diff] [blame] | 277 | self.maxDiff = None |
Antoine Pitrou | 01296da | 2012-04-24 13:55:35 +0200 | [diff] [blame] | 278 | self._check_path_limitations(self.pkgname) |
Victor Stinner | bf81622 | 2011-06-30 23:25:47 +0200 | [diff] [blame] | 279 | create_empty_file(os.path.join(self.subpkgname, self.pkgname + '.py')) |
Brett Cannon | ceffda8 | 2012-04-16 20:48:50 -0400 | [diff] [blame] | 280 | importlib.invalidate_caches() |
Barry Warsaw | 0bcf6d8 | 2001-08-24 18:37:32 +0000 | [diff] [blame] | 281 | from areallylongpackageandmodulenametotestreprtruncation.areallylongpackageandmodulenametotestreprtruncation import areallylongpackageandmodulenametotestreprtruncation |
Brett Cannon | 7b383c4 | 2012-06-11 11:02:36 -0400 | [diff] [blame] | 282 | module = areallylongpackageandmodulenametotestreprtruncation |
| 283 | self.assertEqual(repr(module), "<module %r from %r>" % (module.__name__, module.__file__)) |
| 284 | self.assertEqual(repr(sys), "<module 'sys' (built-in)>") |
Barry Warsaw | 0bcf6d8 | 2001-08-24 18:37:32 +0000 | [diff] [blame] | 285 | |
| 286 | def test_type(self): |
Antoine Pitrou | 01296da | 2012-04-24 13:55:35 +0200 | [diff] [blame] | 287 | self._check_path_limitations('foo') |
Ezio Melotti | b3aedd4 | 2010-11-20 19:04:17 +0000 | [diff] [blame] | 288 | eq = self.assertEqual |
Victor Stinner | bf81622 | 2011-06-30 23:25:47 +0200 | [diff] [blame] | 289 | write_file(os.path.join(self.subpkgname, 'foo.py'), '''\ |
Barry Warsaw | 0bcf6d8 | 2001-08-24 18:37:32 +0000 | [diff] [blame] | 290 | class foo(object): |
| 291 | pass |
| 292 | ''') |
Brett Cannon | ceffda8 | 2012-04-16 20:48:50 -0400 | [diff] [blame] | 293 | importlib.invalidate_caches() |
Barry Warsaw | 0bcf6d8 | 2001-08-24 18:37:32 +0000 | [diff] [blame] | 294 | from areallylongpackageandmodulenametotestreprtruncation.areallylongpackageandmodulenametotestreprtruncation import foo |
| 295 | eq(repr(foo.foo), |
Mark Hammond | d800ae1 | 2003-01-16 04:56:52 +0000 | [diff] [blame] | 296 | "<class '%s.foo'>" % foo.__name__) |
Barry Warsaw | 0bcf6d8 | 2001-08-24 18:37:32 +0000 | [diff] [blame] | 297 | |
Zachary Ware | 9fe6d86 | 2013-12-08 00:20:35 -0600 | [diff] [blame] | 298 | @unittest.skip('need a suitable object') |
Barry Warsaw | 0bcf6d8 | 2001-08-24 18:37:32 +0000 | [diff] [blame] | 299 | def test_object(self): |
| 300 | # XXX Test the repr of a type with a really long tp_name but with no |
| 301 | # tp_repr. WIBNI we had ::Inline? :) |
| 302 | pass |
| 303 | |
| 304 | def test_class(self): |
Antoine Pitrou | 01296da | 2012-04-24 13:55:35 +0200 | [diff] [blame] | 305 | self._check_path_limitations('bar') |
Victor Stinner | bf81622 | 2011-06-30 23:25:47 +0200 | [diff] [blame] | 306 | write_file(os.path.join(self.subpkgname, 'bar.py'), '''\ |
Barry Warsaw | 0bcf6d8 | 2001-08-24 18:37:32 +0000 | [diff] [blame] | 307 | class bar: |
| 308 | pass |
| 309 | ''') |
Brett Cannon | ceffda8 | 2012-04-16 20:48:50 -0400 | [diff] [blame] | 310 | importlib.invalidate_caches() |
Barry Warsaw | 0bcf6d8 | 2001-08-24 18:37:32 +0000 | [diff] [blame] | 311 | from areallylongpackageandmodulenametotestreprtruncation.areallylongpackageandmodulenametotestreprtruncation import bar |
Mark Hammond | d800ae1 | 2003-01-16 04:56:52 +0000 | [diff] [blame] | 312 | # Module name may be prefixed with "test.", depending on how run. |
Ezio Melotti | b3aedd4 | 2010-11-20 19:04:17 +0000 | [diff] [blame] | 313 | self.assertEqual(repr(bar.bar), "<class '%s.bar'>" % bar.__name__) |
Barry Warsaw | 0bcf6d8 | 2001-08-24 18:37:32 +0000 | [diff] [blame] | 314 | |
| 315 | def test_instance(self): |
Antoine Pitrou | 01296da | 2012-04-24 13:55:35 +0200 | [diff] [blame] | 316 | self._check_path_limitations('baz') |
Victor Stinner | bf81622 | 2011-06-30 23:25:47 +0200 | [diff] [blame] | 317 | write_file(os.path.join(self.subpkgname, 'baz.py'), '''\ |
Barry Warsaw | 0bcf6d8 | 2001-08-24 18:37:32 +0000 | [diff] [blame] | 318 | class baz: |
| 319 | pass |
| 320 | ''') |
Brett Cannon | ceffda8 | 2012-04-16 20:48:50 -0400 | [diff] [blame] | 321 | importlib.invalidate_caches() |
Barry Warsaw | 0bcf6d8 | 2001-08-24 18:37:32 +0000 | [diff] [blame] | 322 | from areallylongpackageandmodulenametotestreprtruncation.areallylongpackageandmodulenametotestreprtruncation import baz |
| 323 | ibaz = baz.baz() |
Benjamin Peterson | c9c0f20 | 2009-06-30 23:06:06 +0000 | [diff] [blame] | 324 | self.assertTrue(repr(ibaz).startswith( |
Guido van Rossum | a48a3b4 | 2006-04-20 16:07:39 +0000 | [diff] [blame] | 325 | "<%s.baz object at 0x" % baz.__name__)) |
Barry Warsaw | 0bcf6d8 | 2001-08-24 18:37:32 +0000 | [diff] [blame] | 326 | |
| 327 | def test_method(self): |
Antoine Pitrou | 01296da | 2012-04-24 13:55:35 +0200 | [diff] [blame] | 328 | self._check_path_limitations('qux') |
Ezio Melotti | b3aedd4 | 2010-11-20 19:04:17 +0000 | [diff] [blame] | 329 | eq = self.assertEqual |
Victor Stinner | bf81622 | 2011-06-30 23:25:47 +0200 | [diff] [blame] | 330 | write_file(os.path.join(self.subpkgname, 'qux.py'), '''\ |
Barry Warsaw | 0bcf6d8 | 2001-08-24 18:37:32 +0000 | [diff] [blame] | 331 | class aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa: |
| 332 | def amethod(self): pass |
| 333 | ''') |
Brett Cannon | ceffda8 | 2012-04-16 20:48:50 -0400 | [diff] [blame] | 334 | importlib.invalidate_caches() |
Barry Warsaw | 0bcf6d8 | 2001-08-24 18:37:32 +0000 | [diff] [blame] | 335 | from areallylongpackageandmodulenametotestreprtruncation.areallylongpackageandmodulenametotestreprtruncation import qux |
| 336 | # Unbound methods first |
Antoine Pitrou | 86a36b5 | 2011-11-25 18:56:07 +0100 | [diff] [blame] | 337 | r = repr(qux.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa.amethod) |
| 338 | self.assertTrue(r.startswith('<function aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa.amethod'), r) |
Barry Warsaw | 0bcf6d8 | 2001-08-24 18:37:32 +0000 | [diff] [blame] | 339 | # Bound method next |
| 340 | iqux = qux.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa() |
Antoine Pitrou | 86a36b5 | 2011-11-25 18:56:07 +0100 | [diff] [blame] | 341 | r = repr(iqux.amethod) |
| 342 | self.assertTrue(r.startswith( |
Guido van Rossum | a48a3b4 | 2006-04-20 16:07:39 +0000 | [diff] [blame] | 343 | '<bound method aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa.amethod of <%s.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa object at 0x' \ |
Antoine Pitrou | 86a36b5 | 2011-11-25 18:56:07 +0100 | [diff] [blame] | 344 | % (qux.__name__,) ), r) |
Barry Warsaw | 0bcf6d8 | 2001-08-24 18:37:32 +0000 | [diff] [blame] | 345 | |
Zachary Ware | 9fe6d86 | 2013-12-08 00:20:35 -0600 | [diff] [blame] | 346 | @unittest.skip('needs a built-in function with a really long name') |
Barry Warsaw | 0bcf6d8 | 2001-08-24 18:37:32 +0000 | [diff] [blame] | 347 | def test_builtin_function(self): |
| 348 | # XXX test built-in functions and methods with really long names |
| 349 | pass |
Fred Drake | 8e6669a | 2001-07-19 22:27:56 +0000 | [diff] [blame] | 350 | |
| 351 | class ClassWithRepr: |
| 352 | def __init__(self, s): |
| 353 | self.s = s |
| 354 | def __repr__(self): |
Guido van Rossum | a48a3b4 | 2006-04-20 16:07:39 +0000 | [diff] [blame] | 355 | return "ClassWithRepr(%r)" % self.s |
Fred Drake | 8e6669a | 2001-07-19 22:27:56 +0000 | [diff] [blame] | 356 | |
| 357 | |
| 358 | class ClassWithFailingRepr: |
| 359 | def __repr__(self): |
| 360 | raise Exception("This should be caught by Repr.repr_instance") |
| 361 | |
Raymond Hettinger | 98a5f3f | 2010-09-13 21:36:00 +0000 | [diff] [blame] | 362 | class MyContainer: |
| 363 | 'Helper class for TestRecursiveRepr' |
| 364 | def __init__(self, values): |
| 365 | self.values = list(values) |
| 366 | def append(self, value): |
| 367 | self.values.append(value) |
| 368 | @recursive_repr() |
| 369 | def __repr__(self): |
| 370 | return '<' + ', '.join(map(str, self.values)) + '>' |
| 371 | |
| 372 | class MyContainer2(MyContainer): |
| 373 | @recursive_repr('+++') |
| 374 | def __repr__(self): |
| 375 | return '<' + ', '.join(map(str, self.values)) + '>' |
| 376 | |
| 377 | class TestRecursiveRepr(unittest.TestCase): |
| 378 | def test_recursive_repr(self): |
| 379 | m = MyContainer(list('abcde')) |
| 380 | m.append(m) |
| 381 | m.append('x') |
| 382 | m.append(m) |
| 383 | self.assertEqual(repr(m), '<a, b, c, d, e, ..., x, ...>') |
| 384 | m = MyContainer2(list('abcde')) |
| 385 | m.append(m) |
| 386 | m.append('x') |
| 387 | m.append(m) |
| 388 | self.assertEqual(repr(m), '<a, b, c, d, e, +++, x, +++>') |
Fred Drake | 8e6669a | 2001-07-19 22:27:56 +0000 | [diff] [blame] | 389 | |
Fred Drake | 2e2be37 | 2001-09-20 21:33:42 +0000 | [diff] [blame] | 390 | if __name__ == "__main__": |
Raymond Hettinger | ffd842e | 2014-11-09 22:30:36 -0800 | [diff] [blame] | 391 | unittest.main() |