Gitiles
Code Review Sign In
gerrit-public.fairphone.software / platform / external / python / cpython2 / 4bf21e28dfb42c2da3d440c2c0d9898cb3196fe1 / . / Lib / test / test_pprint.py
blob: e0137dfc59f4d1dc318f90d035cc27d849ff0eaf [file] [log] [blame]
Tim Petersa814db52001-05-14 07:05:58 +0000[diff] [blame]1import pprint
Fred Drakeb456e4f2002-12-31 07:16:16 +0000[diff] [blame]2import test.test_support
Fred Drake43913dd2001-05-14 17:41:20 +0000[diff] [blame]3import unittest
Raymond Hettinger5310b692008-01-24 21:47:56 +0000[diff] [blame]4import test.test_set
Tim Petersa814db52001-05-14 07:05:58 +0000[diff] [blame]5
Martin v. Löwis339d0f72001-08-17 18:39:25 +0000[diff] [blame]6try:
7 uni = unicode
8except NameError:
Fred Drakeb456e4f2002-12-31 07:16:16 +0000[diff] [blame]9 def uni(x):
10 return x
Martin v. Löwis339d0f72001-08-17 18:39:25 +0000[diff] [blame]11
Walter Dörwald7a7ede52003-12-03 20:15:28 +0000[diff] [blame]12# list, tuple and dict subclasses that do or don't overwrite __repr__
13class list2(list):
14 pass
Tim Petersd609b1a2006-06-02 23:22:51 +0000[diff] [blame]15
Walter Dörwald7a7ede52003-12-03 20:15:28 +0000[diff] [blame]16class list3(list):
17 def __repr__(self):
18 return list.__repr__(self)
Tim Petersd609b1a2006-06-02 23:22:51 +0000[diff] [blame]19
Walter Dörwald7a7ede52003-12-03 20:15:28 +0000[diff] [blame]20class tuple2(tuple):
21 pass
Tim Petersd609b1a2006-06-02 23:22:51 +0000[diff] [blame]22
Walter Dörwald7a7ede52003-12-03 20:15:28 +0000[diff] [blame]23class tuple3(tuple):
24 def __repr__(self):
25 return tuple.__repr__(self)
Tim Petersd609b1a2006-06-02 23:22:51 +0000[diff] [blame]26
Walter Dörwald7a7ede52003-12-03 20:15:28 +0000[diff] [blame]27class dict2(dict):
28 pass
Tim Petersd609b1a2006-06-02 23:22:51 +0000[diff] [blame]29
Walter Dörwald7a7ede52003-12-03 20:15:28 +0000[diff] [blame]30class dict3(dict):
31 def __repr__(self):
32 return dict.__repr__(self)
Tim Petersa814db52001-05-14 07:05:58 +0000[diff] [blame]33
Fred Drake43913dd2001-05-14 17:41:20 +0000[diff] [blame]34class QueryTestCase(unittest.TestCase):
Tim Petersa814db52001-05-14 07:05:58 +0000[diff] [blame]35
Fred Drake43913dd2001-05-14 17:41:20 +0000[diff] [blame]36 def setUp(self):
37 self.a = range(100)
38 self.b = range(200)
39 self.a[-12] = self.b
Tim Petersa814db52001-05-14 07:05:58 +0000[diff] [blame]40
Fred Drake43913dd2001-05-14 17:41:20 +0000[diff] [blame]41 def test_basic(self):
Guido van Rossum32c2ae72002-08-22 19:45:32 +0000[diff] [blame]42 # Verify .isrecursive() and .isreadable() w/o recursion
Fred Drakeb456e4f2002-12-31 07:16:16 +0000[diff] [blame]43 pp = pprint.PrettyPrinter()
Martin v. Löwis339d0f72001-08-17 18:39:25 +0000[diff] [blame]44 for safe in (2, 2.0, 2j, "abc", [3], (2,2), {3: 3}, uni("yaddayadda"),
Fred Drake43913dd2001-05-14 17:41:20 +0000[diff] [blame]45 self.a, self.b):
Fred Drakeb456e4f2002-12-31 07:16:16 +0000[diff] [blame]46 # module-level convenience functions
Ezio Melotti469a05f2010-01-24 20:48:35 +0000[diff] [blame]47 self.assertFalse(pprint.isrecursive(safe),
48 "expected not isrecursive for %r" % (safe,))
49 self.assertTrue(pprint.isreadable(safe),
50 "expected isreadable for %r" % (safe,))
Fred Drakeb456e4f2002-12-31 07:16:16 +0000[diff] [blame]51 # PrettyPrinter methods
Ezio Melotti469a05f2010-01-24 20:48:35 +0000[diff] [blame]52 self.assertFalse(pp.isrecursive(safe),
53 "expected not isrecursive for %r" % (safe,))
54 self.assertTrue(pp.isreadable(safe),
55 "expected isreadable for %r" % (safe,))
Tim Petersa814db52001-05-14 07:05:58 +0000[diff] [blame]56
Fred Drake43913dd2001-05-14 17:41:20 +0000[diff] [blame]57 def test_knotted(self):
Guido van Rossum32c2ae72002-08-22 19:45:32 +0000[diff] [blame]58 # Verify .isrecursive() and .isreadable() w/ recursion
Fred Drake43913dd2001-05-14 17:41:20 +0000[diff] [blame]59 # Tie a knot.
60 self.b[67] = self.a
61 # Messy dict.
62 self.d = {}
63 self.d[0] = self.d[1] = self.d[2] = self.d
Tim Petersa814db52001-05-14 07:05:58 +0000[diff] [blame]64
Fred Drakeb456e4f2002-12-31 07:16:16 +0000[diff] [blame]65 pp = pprint.PrettyPrinter()
Tim Petersa814db52001-05-14 07:05:58 +0000[diff] [blame]66
Fred Drake43913dd2001-05-14 17:41:20 +0000[diff] [blame]67 for icky in self.a, self.b, self.d, (self.d, self.d):
Ezio Melotti469a05f2010-01-24 20:48:35 +0000[diff] [blame]68 self.assertTrue(pprint.isrecursive(icky), "expected isrecursive")
69 self.assertFalse(pprint.isreadable(icky), "expected not isreadable")
70 self.assertTrue(pp.isrecursive(icky), "expected isrecursive")
71 self.assertFalse(pp.isreadable(icky), "expected not isreadable")
Fred Drake43913dd2001-05-14 17:41:20 +0000[diff] [blame]72
73 # Break the cycles.
74 self.d.clear()
75 del self.a[:]
76 del self.b[:]
77
78 for safe in self.a, self.b, self.d, (self.d, self.d):
Fred Drakeb456e4f2002-12-31 07:16:16 +0000[diff] [blame]79 # module-level convenience functions
Ezio Melotti469a05f2010-01-24 20:48:35 +0000[diff] [blame]80 self.assertFalse(pprint.isrecursive(safe),
81 "expected not isrecursive for %r" % (safe,))
82 self.assertTrue(pprint.isreadable(safe),
83 "expected isreadable for %r" % (safe,))
Fred Drakeb456e4f2002-12-31 07:16:16 +0000[diff] [blame]84 # PrettyPrinter methods
Ezio Melotti469a05f2010-01-24 20:48:35 +0000[diff] [blame]85 self.assertFalse(pp.isrecursive(safe),
86 "expected not isrecursive for %r" % (safe,))
87 self.assertTrue(pp.isreadable(safe),
88 "expected isreadable for %r" % (safe,))
Fred Drake43913dd2001-05-14 17:41:20 +0000[diff] [blame]89
90 def test_unreadable(self):
Guido van Rossum32c2ae72002-08-22 19:45:32 +0000[diff] [blame]91 # Not recursive but not readable anyway
Fred Drakeb456e4f2002-12-31 07:16:16 +0000[diff] [blame]92 pp = pprint.PrettyPrinter()
Fred Drake43913dd2001-05-14 17:41:20 +0000[diff] [blame]93 for unreadable in type(3), pprint, pprint.isrecursive:
Fred Drakeb456e4f2002-12-31 07:16:16 +0000[diff] [blame]94 # module-level convenience functions
Ezio Melotti469a05f2010-01-24 20:48:35 +0000[diff] [blame]95 self.assertFalse(pprint.isrecursive(unreadable),
96 "expected not isrecursive for %r" % (unreadable,))
97 self.assertFalse(pprint.isreadable(unreadable),
98 "expected not isreadable for %r" % (unreadable,))
Fred Drakeb456e4f2002-12-31 07:16:16 +0000[diff] [blame]99 # PrettyPrinter methods
Ezio Melotti469a05f2010-01-24 20:48:35 +0000[diff] [blame]100 self.assertFalse(pp.isrecursive(unreadable),
101 "expected not isrecursive for %r" % (unreadable,))
102 self.assertFalse(pp.isreadable(unreadable),
103 "expected not isreadable for %r" % (unreadable,))
Fred Drake43913dd2001-05-14 17:41:20 +0000[diff] [blame]104
Tim Peters95b3f782001-05-14 18:39:41 +0000[diff] [blame]105 def test_same_as_repr(self):
Walter Dörwald7a7ede52003-12-03 20:15:28 +0000[diff] [blame]106 # Simple objects, small containers and classes that overwrite __repr__
Tim Petersd609b1a2006-06-02 23:22:51 +0000[diff] [blame]107 # For those the result should be the same as repr().
108 # Ahem. The docs don't say anything about that -- this appears to
109 # be testing an implementation quirk. Starting in Python 2.5, it's
110 # not true for dicts: pprint always sorts dicts by key now; before,
111 # it sorted a dict display if and only if the display required
112 # multiple lines. For that reason, dicts with more than one element
113 # aren't tested here.
Walter Dörwald7a7ede52003-12-03 20:15:28 +0000[diff] [blame]114 for simple in (0, 0L, 0+0j, 0.0, "", uni(""),
115 (), tuple2(), tuple3(),
116 [], list2(), list3(),
117 {}, dict2(), dict3(),
Ezio Melotti469a05f2010-01-24 20:48:35 +0000[diff] [blame]118 self.assertTrue, pprint,
Martin v. Löwis339d0f72001-08-17 18:39:25 +0000[diff] [blame]119 -6, -6L, -6-6j, -1.5, "x", uni("x"), (3,), [3], {3: 6},
Benjamin Peterson68ffe3e2009-03-30 15:15:38 +0000[diff] [blame]120 (1,2), [3,4], {5: 6},
Walter Dörwald7a7ede52003-12-03 20:15:28 +0000[diff] [blame]121 tuple2((1,2)), tuple3((1,2)), tuple3(range(100)),
122 [3,4], list2([3,4]), list3([3,4]), list3(range(100)),
Benjamin Peterson68ffe3e2009-03-30 15:15:38 +0000[diff] [blame]123 dict2({5: 6}), dict3({5: 6}),
Tim Peters95b3f782001-05-14 18:39:41 +0000[diff] [blame]124 range(10, -11, -1)
125 ):
126 native = repr(simple)
127 for function in "pformat", "saferepr":
128 f = getattr(pprint, function)
129 got = f(simple)
Ezio Melotti469a05f2010-01-24 20:48:35 +0000[diff] [blame]130 self.assertEqual(native, got,
131 "expected %s got %s from pprint.%s" %
132 (native, got, function))
Fred Drake43913dd2001-05-14 17:41:20 +0000[diff] [blame]133
Barry Warsaw00859c02001-11-28 05:49:39 +0000[diff] [blame]134 def test_basic_line_wrap(self):
Guido van Rossum32c2ae72002-08-22 19:45:32 +0000[diff] [blame]135 # verify basic line-wrapping operation
Barry Warsaw00859c02001-11-28 05:49:39 +0000[diff] [blame]136 o = {'RPM_cal': 0,
137 'RPM_cal2': 48059,
138 'Speed_cal': 0,
139 'controldesk_runtime_us': 0,
140 'main_code_runtime_us': 0,
141 'read_io_runtime_us': 0,
142 'write_io_runtime_us': 43690}
143 exp = """\
144{'RPM_cal': 0,
145 'RPM_cal2': 48059,
146 'Speed_cal': 0,
147 'controldesk_runtime_us': 0,
148 'main_code_runtime_us': 0,
149 'read_io_runtime_us': 0,
150 'write_io_runtime_us': 43690}"""
Walter Dörwald7a7ede52003-12-03 20:15:28 +0000[diff] [blame]151 for type in [dict, dict2]:
152 self.assertEqual(pprint.pformat(type(o)), exp)
153
154 o = range(100)
155 exp = '[%s]' % ',\n '.join(map(str, o))
156 for type in [list, list2]:
157 self.assertEqual(pprint.pformat(type(o)), exp)
158
159 o = tuple(range(100))
160 exp = '(%s)' % ',\n '.join(map(str, o))
161 for type in [tuple, tuple2]:
162 self.assertEqual(pprint.pformat(type(o)), exp)
Barry Warsaw00859c02001-11-28 05:49:39 +0000[diff] [blame]163
Walter Dörwaldc8de4582003-12-03 20:26:05 +0000[diff] [blame]164 # indent parameter
165 o = range(100)
166 exp = '[ %s]' % ',\n '.join(map(str, o))
167 for type in [list, list2]:
168 self.assertEqual(pprint.pformat(type(o), indent=4), exp)
169
Facundo Batista2da91c32008-06-21 17:43:56 +0000[diff] [blame]170 def test_nested_indentations(self):
171 o1 = list(range(10))
172 o2 = dict(first=1, second=2, third=3)
173 o = [o1, o2]
174 expected = """\
175[ [0, 1, 2, 3, 4, 5, 6, 7, 8, 9],
176 { 'first': 1,
177 'second': 2,
178 'third': 3}]"""
179 self.assertEqual(pprint.pformat(o, indent=4, width=42), expected)
180
Tim Petersd609b1a2006-06-02 23:22:51 +0000[diff] [blame]181 def test_sorted_dict(self):
182 # Starting in Python 2.5, pprint sorts dict displays by key regardless
183 # of how small the dictionary may be.
184 # Before the change, on 32-bit Windows pformat() gave order
185 # 'a', 'c', 'b' here, so this test failed.
186 d = {'a': 1, 'b': 1, 'c': 1}
187 self.assertEqual(pprint.pformat(d), "{'a': 1, 'b': 1, 'c': 1}")
188 self.assertEqual(pprint.pformat([d, d]),
189 "[{'a': 1, 'b': 1, 'c': 1}, {'a': 1, 'b': 1, 'c': 1}]")
190
191 # The next one is kind of goofy. The sorted order depends on the
192 # alphabetic order of type names: "int" < "str" < "tuple". Before
193 # Python 2.5, this was in the test_same_as_repr() test. It's worth
194 # keeping around for now because it's one of few tests of pprint
195 # against a crazy mix of types.
196 self.assertEqual(pprint.pformat({"xy\tab\n": (3,), 5: [[]], (): {}}),
197 r"{5: [[]], 'xy\tab\n': (3,), (): {}}")
198
Fred Drakeaee113d2002-04-02 05:08:35 +0000[diff] [blame]199 def test_subclassing(self):
200 o = {'names with spaces': 'should be presented using repr()',
201 'others.should.not.be': 'like.this'}
202 exp = """\
203{'names with spaces': 'should be presented using repr()',
204 others.should.not.be: like.this}"""
205 self.assertEqual(DottedPrettyPrinter().pformat(o), exp)
206
Raymond Hettinger5310b692008-01-24 21:47:56 +0000[diff] [blame]207 def test_set_reprs(self):
208 self.assertEqual(pprint.pformat(set()), 'set()')
209 self.assertEqual(pprint.pformat(set(range(3))), 'set([0, 1, 2])')
210 self.assertEqual(pprint.pformat(frozenset()), 'frozenset()')
211 self.assertEqual(pprint.pformat(frozenset(range(3))), 'frozenset([0, 1, 2])')
212 cube_repr_tgt = """\
213{frozenset([]): frozenset([frozenset([2]), frozenset([0]), frozenset([1])]),
214 frozenset([0]): frozenset([frozenset(),
215 frozenset([0, 2]),
216 frozenset([0, 1])]),
217 frozenset([1]): frozenset([frozenset(),
218 frozenset([1, 2]),
219 frozenset([0, 1])]),
220 frozenset([2]): frozenset([frozenset(),
221 frozenset([1, 2]),
222 frozenset([0, 2])]),
223 frozenset([1, 2]): frozenset([frozenset([2]),
224 frozenset([1]),
225 frozenset([0, 1, 2])]),
226 frozenset([0, 2]): frozenset([frozenset([2]),
227 frozenset([0]),
228 frozenset([0, 1, 2])]),
229 frozenset([0, 1]): frozenset([frozenset([0]),
230 frozenset([1]),
231 frozenset([0, 1, 2])]),
232 frozenset([0, 1, 2]): frozenset([frozenset([1, 2]),
233 frozenset([0, 2]),
234 frozenset([0, 1])])}"""
235 cube = test.test_set.cube(3)
236 self.assertEqual(pprint.pformat(cube), cube_repr_tgt)
237 cubo_repr_tgt = """\
238{frozenset([frozenset([0, 2]), frozenset([0])]): frozenset([frozenset([frozenset([0,
239 2]),
240 frozenset([0,
241 1,
242 2])]),
243 frozenset([frozenset([0]),
244 frozenset([0,
245 1])]),
246 frozenset([frozenset(),
247 frozenset([0])]),
248 frozenset([frozenset([2]),
249 frozenset([0,
250 2])])]),
251 frozenset([frozenset([0, 1]), frozenset([1])]): frozenset([frozenset([frozenset([0,
252 1]),
253 frozenset([0,
254 1,
255 2])]),
256 frozenset([frozenset([0]),
257 frozenset([0,
258 1])]),
259 frozenset([frozenset([1]),
260 frozenset([1,
261 2])]),
262 frozenset([frozenset(),
263 frozenset([1])])]),
264 frozenset([frozenset([1, 2]), frozenset([1])]): frozenset([frozenset([frozenset([1,
265 2]),
266 frozenset([0,
267 1,
268 2])]),
269 frozenset([frozenset([2]),
270 frozenset([1,
271 2])]),
272 frozenset([frozenset(),
273 frozenset([1])]),
274 frozenset([frozenset([1]),
275 frozenset([0,
276 1])])]),
277 frozenset([frozenset([1, 2]), frozenset([2])]): frozenset([frozenset([frozenset([1,
278 2]),
279 frozenset([0,
280 1,
281 2])]),
282 frozenset([frozenset([1]),
283 frozenset([1,
284 2])]),
285 frozenset([frozenset([2]),
286 frozenset([0,
287 2])]),
288 frozenset([frozenset(),
289 frozenset([2])])]),
290 frozenset([frozenset([]), frozenset([0])]): frozenset([frozenset([frozenset([0]),
291 frozenset([0,
292 1])]),
293 frozenset([frozenset([0]),
294 frozenset([0,
295 2])]),
296 frozenset([frozenset(),
297 frozenset([1])]),
298 frozenset([frozenset(),
299 frozenset([2])])]),
300 frozenset([frozenset([]), frozenset([1])]): frozenset([frozenset([frozenset(),
301 frozenset([0])]),
302 frozenset([frozenset([1]),
303 frozenset([1,
304 2])]),
305 frozenset([frozenset(),
306 frozenset([2])]),
307 frozenset([frozenset([1]),
308 frozenset([0,
309 1])])]),
310 frozenset([frozenset([2]), frozenset([])]): frozenset([frozenset([frozenset([2]),
311 frozenset([1,
312 2])]),
313 frozenset([frozenset(),
314 frozenset([0])]),
315 frozenset([frozenset(),
316 frozenset([1])]),
317 frozenset([frozenset([2]),
318 frozenset([0,
319 2])])]),
320 frozenset([frozenset([0, 1, 2]), frozenset([0, 1])]): frozenset([frozenset([frozenset([1,
321 2]),
322 frozenset([0,
323 1,
324 2])]),
325 frozenset([frozenset([0,
326 2]),
327 frozenset([0,
328 1,
329 2])]),
330 frozenset([frozenset([0]),
331 frozenset([0,
332 1])]),
333 frozenset([frozenset([1]),
334 frozenset([0,
335 1])])]),
336 frozenset([frozenset([0]), frozenset([0, 1])]): frozenset([frozenset([frozenset(),
337 frozenset([0])]),
338 frozenset([frozenset([0,
339 1]),
340 frozenset([0,
341 1,
342 2])]),
343 frozenset([frozenset([0]),
344 frozenset([0,
345 2])]),
346 frozenset([frozenset([1]),
347 frozenset([0,
348 1])])]),
349 frozenset([frozenset([2]), frozenset([0, 2])]): frozenset([frozenset([frozenset([0,
350 2]),
351 frozenset([0,
352 1,
353 2])]),
354 frozenset([frozenset([2]),
355 frozenset([1,
356 2])]),
357 frozenset([frozenset([0]),
358 frozenset([0,
359 2])]),
360 frozenset([frozenset(),
361 frozenset([2])])]),
362 frozenset([frozenset([0, 1, 2]), frozenset([0, 2])]): frozenset([frozenset([frozenset([1,
363 2]),
364 frozenset([0,
365 1,
366 2])]),
367 frozenset([frozenset([0,
368 1]),
369 frozenset([0,
370 1,
371 2])]),
372 frozenset([frozenset([0]),
373 frozenset([0,
374 2])]),
375 frozenset([frozenset([2]),
376 frozenset([0,
377 2])])]),
378 frozenset([frozenset([1, 2]), frozenset([0, 1, 2])]): frozenset([frozenset([frozenset([0,
379 2]),
380 frozenset([0,
381 1,
382 2])]),
383 frozenset([frozenset([0,
384 1]),
385 frozenset([0,
386 1,
387 2])]),
388 frozenset([frozenset([2]),
389 frozenset([1,
390 2])]),
391 frozenset([frozenset([1]),
392 frozenset([1,
393 2])])])}"""
394
395 cubo = test.test_set.linegraph(cube)
396 self.assertEqual(pprint.pformat(cubo), cubo_repr_tgt)
397
Georg Brandl23da6e62008-05-12 16:26:52 +0000[diff] [blame]398 def test_depth(self):
399 nested_tuple = (1, (2, (3, (4, (5, 6)))))
400 nested_dict = {1: {2: {3: {4: {5: {6: 6}}}}}}
401 nested_list = [1, [2, [3, [4, [5, [6, []]]]]]]
402 self.assertEqual(pprint.pformat(nested_tuple), repr(nested_tuple))
403 self.assertEqual(pprint.pformat(nested_dict), repr(nested_dict))
404 self.assertEqual(pprint.pformat(nested_list), repr(nested_list))
405
406 lv1_tuple = '(1, (...))'
407 lv1_dict = '{1: {...}}'
408 lv1_list = '[1, [...]]'
409 self.assertEqual(pprint.pformat(nested_tuple, depth=1), lv1_tuple)
410 self.assertEqual(pprint.pformat(nested_dict, depth=1), lv1_dict)
411 self.assertEqual(pprint.pformat(nested_list, depth=1), lv1_list)
412
Fred Drakeaee113d2002-04-02 05:08:35 +0000[diff] [blame]413
414class DottedPrettyPrinter(pprint.PrettyPrinter):
Guido van Rossum32c2ae72002-08-22 19:45:32 +0000[diff] [blame]415
Fred Drakeaee113d2002-04-02 05:08:35 +0000[diff] [blame]416 def format(self, object, context, maxlevels, level):
417 if isinstance(object, str):
418 if ' ' in object:
Walter Dörwald70a6b492004-02-12 17:35:32 +0000[diff] [blame]419 return repr(object), 1, 0
Fred Drakeaee113d2002-04-02 05:08:35 +0000[diff] [blame]420 else:
421 return object, 0, 0
422 else:
423 return pprint.PrettyPrinter.format(
424 self, object, context, maxlevels, level)
425
426
Fred Drake2e2be372001-09-20 21:33:42 +0000[diff] [blame]427def test_main():
Fred Drakeb456e4f2002-12-31 07:16:16 +0000[diff] [blame]428 test.test_support.run_unittest(QueryTestCase)
Fred Drake2e2be372001-09-20 21:33:42 +0000[diff] [blame]429
430
431if __name__ == "__main__":
432 test_main()