Lib/test/test_pprint.py

   1 import pprint
   2 import test.test_support
   3 import unittest
   4 import test.test_set
   5
   6 try:
   7     uni = unicode
   8 except NameError:
   9     def uni(x):
  10         return x
  11
  12 # list, tuple and dict subclasses that do or don't overwrite __repr__
  13 class list2(list):
  14     pass
  15
  16 class list3(list):
  17     def __repr__(self):
  18         return list.__repr__(self)
  19
  20 class tuple2(tuple):
  21     pass
  22
  23 class tuple3(tuple):
  24     def __repr__(self):
  25         return tuple.__repr__(self)
  26
  27 class dict2(dict):
  28     pass
  29
  30 class dict3(dict):
  31     def __repr__(self):
  32         return dict.__repr__(self)
  33
  34 class 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         pp = pprint.PrettyPrinter()
  44         for safe in (2, 2.0, 2j, "abc", [3], (2,2), {3: 3}, uni("yaddayadda"),
  45                      self.a, self.b):
  46             # module-level convenience functions
  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,))
  51             # PrettyPrinter methods
  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,))
  56
  57     def test_knotted(self):
  58         # Verify .isrecursive() and .isreadable() w/ recursion
  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
  64
  65         pp = pprint.PrettyPrinter()
  66
  67         for icky in self.a, self.b, self.d, (self.d, self.d):
  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")
  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):
  79             # module-level convenience functions
  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,))
  84             # PrettyPrinter methods
  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,))
  89
  90     def test_unreadable(self):
  91         # Not recursive but not readable anyway
  92         pp = pprint.PrettyPrinter()
  93         for unreadable in type(3), pprint, pprint.isrecursive:
  94             # module-level convenience functions
  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,))
  99             # PrettyPrinter methods
 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,))
 104
 105     def test_same_as_repr(self):
 106         # Simple objects, small containers and classes that overwrite __repr__
 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.
 114         for simple in (0, 0L, 0+0j, 0.0, "", uni(""),
 115                        (), tuple2(), tuple3(),
 116                        [], list2(), list3(),
 117                        {}, dict2(), dict3(),
 118                        self.assertTrue, pprint,
 119                        -6, -6L, -6-6j, -1.5, "x", uni("x"), (3,), [3], {3: 6},
 120                        (1,2), [3,4], {5: 6},
 121                        tuple2((1,2)), tuple3((1,2)), tuple3(range(100)),
 122                        [3,4], list2([3,4]), list3([3,4]), list3(range(100)),
 123                        dict2({5: 6}), dict3({5: 6}),
 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)
 130                 self.assertEqual(native, got,
 131                                  "expected %s got %s from pprint.%s" %
 132                                  (native, got, function))
 133
 134     def test_basic_line_wrap(self):
 135         # verify basic line-wrapping operation
 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}"""
 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)
 163
 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
 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
 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
 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
 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
 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
 413
 414 class DottedPrettyPrinter(pprint.PrettyPrinter):
 415
 416     def format(self, object, context, maxlevels, level):
 417         if isinstance(object, str):
 418             if ' ' in object:
 419                 return repr(object), 1, 0
 420             else:
 421                 return object, 0, 0
 422         else:
 423             return pprint.PrettyPrinter.format(
 424                 self, object, context, maxlevels, level)
 425
 426
 427 def test_main():
 428     test.test_support.run_unittest(QueryTestCase)
 429
 430
 431 if __name__ == "__main__":
 432     test_main()