Commit | Line | Data |
---|---|---|
920dae64 AT |
1 | import pprint |
2 | import test.test_support | |
3 | import unittest | |
4 | ||
5 | try: | |
6 | uni = unicode | |
7 | except NameError: | |
8 | def uni(x): | |
9 | return x | |
10 | ||
11 | # list, tuple and dict subclasses that do or don't overwrite __repr__ | |
12 | class list2(list): | |
13 | pass | |
14 | class list3(list): | |
15 | def __repr__(self): | |
16 | return list.__repr__(self) | |
17 | class tuple2(tuple): | |
18 | pass | |
19 | class tuple3(tuple): | |
20 | def __repr__(self): | |
21 | return tuple.__repr__(self) | |
22 | class dict2(dict): | |
23 | pass | |
24 | class dict3(dict): | |
25 | def __repr__(self): | |
26 | return dict.__repr__(self) | |
27 | ||
28 | class QueryTestCase(unittest.TestCase): | |
29 | ||
30 | def setUp(self): | |
31 | self.a = range(100) | |
32 | self.b = range(200) | |
33 | self.a[-12] = self.b | |
34 | ||
35 | def test_basic(self): | |
36 | # Verify .isrecursive() and .isreadable() w/o recursion | |
37 | verify = self.assert_ | |
38 | pp = pprint.PrettyPrinter() | |
39 | for safe in (2, 2.0, 2j, "abc", [3], (2,2), {3: 3}, uni("yaddayadda"), | |
40 | self.a, self.b): | |
41 | # module-level convenience functions | |
42 | verify(not pprint.isrecursive(safe), | |
43 | "expected not isrecursive for %r" % (safe,)) | |
44 | verify(pprint.isreadable(safe), | |
45 | "expected isreadable for %r" % (safe,)) | |
46 | # PrettyPrinter methods | |
47 | verify(not pp.isrecursive(safe), | |
48 | "expected not isrecursive for %r" % (safe,)) | |
49 | verify(pp.isreadable(safe), | |
50 | "expected isreadable for %r" % (safe,)) | |
51 | ||
52 | def test_knotted(self): | |
53 | # Verify .isrecursive() and .isreadable() w/ recursion | |
54 | # Tie a knot. | |
55 | self.b[67] = self.a | |
56 | # Messy dict. | |
57 | self.d = {} | |
58 | self.d[0] = self.d[1] = self.d[2] = self.d | |
59 | ||
60 | verify = self.assert_ | |
61 | pp = pprint.PrettyPrinter() | |
62 | ||
63 | for icky in self.a, self.b, self.d, (self.d, self.d): | |
64 | verify(pprint.isrecursive(icky), "expected isrecursive") | |
65 | verify(not pprint.isreadable(icky), "expected not isreadable") | |
66 | verify(pp.isrecursive(icky), "expected isrecursive") | |
67 | verify(not pp.isreadable(icky), "expected not isreadable") | |
68 | ||
69 | # Break the cycles. | |
70 | self.d.clear() | |
71 | del self.a[:] | |
72 | del self.b[:] | |
73 | ||
74 | for safe in self.a, self.b, self.d, (self.d, self.d): | |
75 | # module-level convenience functions | |
76 | verify(not pprint.isrecursive(safe), | |
77 | "expected not isrecursive for %r" % (safe,)) | |
78 | verify(pprint.isreadable(safe), | |
79 | "expected isreadable for %r" % (safe,)) | |
80 | # PrettyPrinter methods | |
81 | verify(not pp.isrecursive(safe), | |
82 | "expected not isrecursive for %r" % (safe,)) | |
83 | verify(pp.isreadable(safe), | |
84 | "expected isreadable for %r" % (safe,)) | |
85 | ||
86 | def test_unreadable(self): | |
87 | # Not recursive but not readable anyway | |
88 | verify = self.assert_ | |
89 | pp = pprint.PrettyPrinter() | |
90 | for unreadable in type(3), pprint, pprint.isrecursive: | |
91 | # module-level convenience functions | |
92 | verify(not pprint.isrecursive(unreadable), | |
93 | "expected not isrecursive for %r" % (unreadable,)) | |
94 | verify(not pprint.isreadable(unreadable), | |
95 | "expected not isreadable for %r" % (unreadable,)) | |
96 | # PrettyPrinter methods | |
97 | verify(not pp.isrecursive(unreadable), | |
98 | "expected not isrecursive for %r" % (unreadable,)) | |
99 | verify(not pp.isreadable(unreadable), | |
100 | "expected not isreadable for %r" % (unreadable,)) | |
101 | ||
102 | def test_same_as_repr(self): | |
103 | # Simple objects, small containers and classes that overwrite __repr__ | |
104 | # For those the result should be the same as repr() | |
105 | verify = self.assert_ | |
106 | for simple in (0, 0L, 0+0j, 0.0, "", uni(""), | |
107 | (), tuple2(), tuple3(), | |
108 | [], list2(), list3(), | |
109 | {}, dict2(), dict3(), | |
110 | verify, pprint, | |
111 | -6, -6L, -6-6j, -1.5, "x", uni("x"), (3,), [3], {3: 6}, | |
112 | (1,2), [3,4], {5: 6, 7: 8}, | |
113 | tuple2((1,2)), tuple3((1,2)), tuple3(range(100)), | |
114 | [3,4], list2([3,4]), list3([3,4]), list3(range(100)), | |
115 | {5: 6, 7: 8}, dict2({5: 6, 7: 8}), dict3({5: 6, 7: 8}), | |
116 | dict3([(x,x) for x in range(100)]), | |
117 | {"xy\tab\n": (3,), 5: [[]], (): {}}, | |
118 | range(10, -11, -1) | |
119 | ): | |
120 | native = repr(simple) | |
121 | for function in "pformat", "saferepr": | |
122 | f = getattr(pprint, function) | |
123 | got = f(simple) | |
124 | verify(native == got, "expected %s got %s from pprint.%s" % | |
125 | (native, got, function)) | |
126 | ||
127 | def test_basic_line_wrap(self): | |
128 | # verify basic line-wrapping operation | |
129 | o = {'RPM_cal': 0, | |
130 | 'RPM_cal2': 48059, | |
131 | 'Speed_cal': 0, | |
132 | 'controldesk_runtime_us': 0, | |
133 | 'main_code_runtime_us': 0, | |
134 | 'read_io_runtime_us': 0, | |
135 | 'write_io_runtime_us': 43690} | |
136 | exp = """\ | |
137 | {'RPM_cal': 0, | |
138 | 'RPM_cal2': 48059, | |
139 | 'Speed_cal': 0, | |
140 | 'controldesk_runtime_us': 0, | |
141 | 'main_code_runtime_us': 0, | |
142 | 'read_io_runtime_us': 0, | |
143 | 'write_io_runtime_us': 43690}""" | |
144 | for type in [dict, dict2]: | |
145 | self.assertEqual(pprint.pformat(type(o)), exp) | |
146 | ||
147 | o = range(100) | |
148 | exp = '[%s]' % ',\n '.join(map(str, o)) | |
149 | for type in [list, list2]: | |
150 | self.assertEqual(pprint.pformat(type(o)), exp) | |
151 | ||
152 | o = tuple(range(100)) | |
153 | exp = '(%s)' % ',\n '.join(map(str, o)) | |
154 | for type in [tuple, tuple2]: | |
155 | self.assertEqual(pprint.pformat(type(o)), exp) | |
156 | ||
157 | # indent parameter | |
158 | o = range(100) | |
159 | exp = '[ %s]' % ',\n '.join(map(str, o)) | |
160 | for type in [list, list2]: | |
161 | self.assertEqual(pprint.pformat(type(o), indent=4), exp) | |
162 | ||
163 | def test_subclassing(self): | |
164 | o = {'names with spaces': 'should be presented using repr()', | |
165 | 'others.should.not.be': 'like.this'} | |
166 | exp = """\ | |
167 | {'names with spaces': 'should be presented using repr()', | |
168 | others.should.not.be: like.this}""" | |
169 | self.assertEqual(DottedPrettyPrinter().pformat(o), exp) | |
170 | ||
171 | ||
172 | class DottedPrettyPrinter(pprint.PrettyPrinter): | |
173 | ||
174 | def format(self, object, context, maxlevels, level): | |
175 | if isinstance(object, str): | |
176 | if ' ' in object: | |
177 | return repr(object), 1, 0 | |
178 | else: | |
179 | return object, 0, 0 | |
180 | else: | |
181 | return pprint.PrettyPrinter.format( | |
182 | self, object, context, maxlevels, level) | |
183 | ||
184 | ||
185 | def test_main(): | |
186 | test.test_support.run_unittest(QueryTestCase) | |
187 | ||
188 | ||
189 | if __name__ == "__main__": | |
190 | test_main() |