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