summaryrefslogtreecommitdiff
path: root/lib/python2.7/test/test_pprint.py
diff options
context:
space:
mode:
Diffstat (limited to 'lib/python2.7/test/test_pprint.py')
-rw-r--r--lib/python2.7/test/test_pprint.py432
1 files changed, 432 insertions, 0 deletions
diff --git a/lib/python2.7/test/test_pprint.py b/lib/python2.7/test/test_pprint.py
new file mode 100644
index 0000000..e0137df
--- /dev/null
+++ b/lib/python2.7/test/test_pprint.py
@@ -0,0 +1,432 @@
+import pprint
+import test.test_support
+import unittest
+import test.test_set
+
+try:
+ uni = unicode
+except NameError:
+ def uni(x):
+ return x
+
+# list, tuple and dict subclasses that do or don't overwrite __repr__
+class list2(list):
+ pass
+
+class list3(list):
+ def __repr__(self):
+ return list.__repr__(self)
+
+class tuple2(tuple):
+ pass
+
+class tuple3(tuple):
+ def __repr__(self):
+ return tuple.__repr__(self)
+
+class dict2(dict):
+ pass
+
+class dict3(dict):
+ def __repr__(self):
+ return dict.__repr__(self)
+
+class QueryTestCase(unittest.TestCase):
+
+ def setUp(self):
+ self.a = range(100)
+ self.b = range(200)
+ self.a[-12] = self.b
+
+ def test_basic(self):
+ # Verify .isrecursive() and .isreadable() w/o recursion
+ pp = pprint.PrettyPrinter()
+ for safe in (2, 2.0, 2j, "abc", [3], (2,2), {3: 3}, uni("yaddayadda"),
+ self.a, self.b):
+ # module-level convenience functions
+ self.assertFalse(pprint.isrecursive(safe),
+ "expected not isrecursive for %r" % (safe,))
+ self.assertTrue(pprint.isreadable(safe),
+ "expected isreadable for %r" % (safe,))
+ # PrettyPrinter methods
+ self.assertFalse(pp.isrecursive(safe),
+ "expected not isrecursive for %r" % (safe,))
+ self.assertTrue(pp.isreadable(safe),
+ "expected isreadable for %r" % (safe,))
+
+ def test_knotted(self):
+ # Verify .isrecursive() and .isreadable() w/ recursion
+ # Tie a knot.
+ self.b[67] = self.a
+ # Messy dict.
+ self.d = {}
+ self.d[0] = self.d[1] = self.d[2] = self.d
+
+ pp = pprint.PrettyPrinter()
+
+ for icky in self.a, self.b, self.d, (self.d, self.d):
+ self.assertTrue(pprint.isrecursive(icky), "expected isrecursive")
+ self.assertFalse(pprint.isreadable(icky), "expected not isreadable")
+ self.assertTrue(pp.isrecursive(icky), "expected isrecursive")
+ self.assertFalse(pp.isreadable(icky), "expected not isreadable")
+
+ # Break the cycles.
+ self.d.clear()
+ del self.a[:]
+ del self.b[:]
+
+ for safe in self.a, self.b, self.d, (self.d, self.d):
+ # module-level convenience functions
+ self.assertFalse(pprint.isrecursive(safe),
+ "expected not isrecursive for %r" % (safe,))
+ self.assertTrue(pprint.isreadable(safe),
+ "expected isreadable for %r" % (safe,))
+ # PrettyPrinter methods
+ self.assertFalse(pp.isrecursive(safe),
+ "expected not isrecursive for %r" % (safe,))
+ self.assertTrue(pp.isreadable(safe),
+ "expected isreadable for %r" % (safe,))
+
+ def test_unreadable(self):
+ # Not recursive but not readable anyway
+ pp = pprint.PrettyPrinter()
+ for unreadable in type(3), pprint, pprint.isrecursive:
+ # module-level convenience functions
+ self.assertFalse(pprint.isrecursive(unreadable),
+ "expected not isrecursive for %r" % (unreadable,))
+ self.assertFalse(pprint.isreadable(unreadable),
+ "expected not isreadable for %r" % (unreadable,))
+ # PrettyPrinter methods
+ self.assertFalse(pp.isrecursive(unreadable),
+ "expected not isrecursive for %r" % (unreadable,))
+ self.assertFalse(pp.isreadable(unreadable),
+ "expected not isreadable for %r" % (unreadable,))
+
+ def test_same_as_repr(self):
+ # Simple objects, small containers and classes that overwrite __repr__
+ # For those the result should be the same as repr().
+ # Ahem. The docs don't say anything about that -- this appears to
+ # be testing an implementation quirk. Starting in Python 2.5, it's
+ # not true for dicts: pprint always sorts dicts by key now; before,
+ # it sorted a dict display if and only if the display required
+ # multiple lines. For that reason, dicts with more than one element
+ # aren't tested here.
+ for simple in (0, 0L, 0+0j, 0.0, "", uni(""),
+ (), tuple2(), tuple3(),
+ [], list2(), list3(),
+ {}, dict2(), dict3(),
+ self.assertTrue, pprint,
+ -6, -6L, -6-6j, -1.5, "x", uni("x"), (3,), [3], {3: 6},
+ (1,2), [3,4], {5: 6},
+ tuple2((1,2)), tuple3((1,2)), tuple3(range(100)),
+ [3,4], list2([3,4]), list3([3,4]), list3(range(100)),
+ dict2({5: 6}), dict3({5: 6}),
+ range(10, -11, -1)
+ ):
+ native = repr(simple)
+ for function in "pformat", "saferepr":
+ f = getattr(pprint, function)
+ got = f(simple)
+ self.assertEqual(native, got,
+ "expected %s got %s from pprint.%s" %
+ (native, got, function))
+
+ def test_basic_line_wrap(self):
+ # verify basic line-wrapping operation
+ o = {'RPM_cal': 0,
+ 'RPM_cal2': 48059,
+ 'Speed_cal': 0,
+ 'controldesk_runtime_us': 0,
+ 'main_code_runtime_us': 0,
+ 'read_io_runtime_us': 0,
+ 'write_io_runtime_us': 43690}
+ exp = """\
+{'RPM_cal': 0,
+ 'RPM_cal2': 48059,
+ 'Speed_cal': 0,
+ 'controldesk_runtime_us': 0,
+ 'main_code_runtime_us': 0,
+ 'read_io_runtime_us': 0,
+ 'write_io_runtime_us': 43690}"""
+ for type in [dict, dict2]:
+ self.assertEqual(pprint.pformat(type(o)), exp)
+
+ o = range(100)
+ exp = '[%s]' % ',\n '.join(map(str, o))
+ for type in [list, list2]:
+ self.assertEqual(pprint.pformat(type(o)), exp)
+
+ o = tuple(range(100))
+ exp = '(%s)' % ',\n '.join(map(str, o))
+ for type in [tuple, tuple2]:
+ self.assertEqual(pprint.pformat(type(o)), exp)
+
+ # indent parameter
+ o = range(100)
+ exp = '[ %s]' % ',\n '.join(map(str, o))
+ for type in [list, list2]:
+ self.assertEqual(pprint.pformat(type(o), indent=4), exp)
+
+ def test_nested_indentations(self):
+ o1 = list(range(10))
+ o2 = dict(first=1, second=2, third=3)
+ o = [o1, o2]
+ expected = """\
+[ [0, 1, 2, 3, 4, 5, 6, 7, 8, 9],
+ { 'first': 1,
+ 'second': 2,
+ 'third': 3}]"""
+ self.assertEqual(pprint.pformat(o, indent=4, width=42), expected)
+
+ def test_sorted_dict(self):
+ # Starting in Python 2.5, pprint sorts dict displays by key regardless
+ # of how small the dictionary may be.
+ # Before the change, on 32-bit Windows pformat() gave order
+ # 'a', 'c', 'b' here, so this test failed.
+ d = {'a': 1, 'b': 1, 'c': 1}
+ self.assertEqual(pprint.pformat(d), "{'a': 1, 'b': 1, 'c': 1}")
+ self.assertEqual(pprint.pformat([d, d]),
+ "[{'a': 1, 'b': 1, 'c': 1}, {'a': 1, 'b': 1, 'c': 1}]")
+
+ # The next one is kind of goofy. The sorted order depends on the
+ # alphabetic order of type names: "int" < "str" < "tuple". Before
+ # Python 2.5, this was in the test_same_as_repr() test. It's worth
+ # keeping around for now because it's one of few tests of pprint
+ # against a crazy mix of types.
+ self.assertEqual(pprint.pformat({"xy\tab\n": (3,), 5: [[]], (): {}}),
+ r"{5: [[]], 'xy\tab\n': (3,), (): {}}")
+
+ def test_subclassing(self):
+ o = {'names with spaces': 'should be presented using repr()',
+ 'others.should.not.be': 'like.this'}
+ exp = """\
+{'names with spaces': 'should be presented using repr()',
+ others.should.not.be: like.this}"""
+ self.assertEqual(DottedPrettyPrinter().pformat(o), exp)
+
+ def test_set_reprs(self):
+ self.assertEqual(pprint.pformat(set()), 'set()')
+ self.assertEqual(pprint.pformat(set(range(3))), 'set([0, 1, 2])')
+ self.assertEqual(pprint.pformat(frozenset()), 'frozenset()')
+ self.assertEqual(pprint.pformat(frozenset(range(3))), 'frozenset([0, 1, 2])')
+ cube_repr_tgt = """\
+{frozenset([]): frozenset([frozenset([2]), frozenset([0]), frozenset([1])]),
+ frozenset([0]): frozenset([frozenset(),
+ frozenset([0, 2]),
+ frozenset([0, 1])]),
+ frozenset([1]): frozenset([frozenset(),
+ frozenset([1, 2]),
+ frozenset([0, 1])]),
+ frozenset([2]): frozenset([frozenset(),
+ frozenset([1, 2]),
+ frozenset([0, 2])]),
+ frozenset([1, 2]): frozenset([frozenset([2]),
+ frozenset([1]),
+ frozenset([0, 1, 2])]),
+ frozenset([0, 2]): frozenset([frozenset([2]),
+ frozenset([0]),
+ frozenset([0, 1, 2])]),
+ frozenset([0, 1]): frozenset([frozenset([0]),
+ frozenset([1]),
+ frozenset([0, 1, 2])]),
+ frozenset([0, 1, 2]): frozenset([frozenset([1, 2]),
+ frozenset([0, 2]),
+ frozenset([0, 1])])}"""
+ cube = test.test_set.cube(3)
+ self.assertEqual(pprint.pformat(cube), cube_repr_tgt)
+ cubo_repr_tgt = """\
+{frozenset([frozenset([0, 2]), frozenset([0])]): frozenset([frozenset([frozenset([0,
+ 2]),
+ frozenset([0,
+ 1,
+ 2])]),
+ frozenset([frozenset([0]),
+ frozenset([0,
+ 1])]),
+ frozenset([frozenset(),
+ frozenset([0])]),
+ frozenset([frozenset([2]),
+ frozenset([0,
+ 2])])]),
+ frozenset([frozenset([0, 1]), frozenset([1])]): frozenset([frozenset([frozenset([0,
+ 1]),
+ frozenset([0,
+ 1,
+ 2])]),
+ frozenset([frozenset([0]),
+ frozenset([0,
+ 1])]),
+ frozenset([frozenset([1]),
+ frozenset([1,
+ 2])]),
+ frozenset([frozenset(),
+ frozenset([1])])]),
+ frozenset([frozenset([1, 2]), frozenset([1])]): frozenset([frozenset([frozenset([1,
+ 2]),
+ frozenset([0,
+ 1,
+ 2])]),
+ frozenset([frozenset([2]),
+ frozenset([1,
+ 2])]),
+ frozenset([frozenset(),
+ frozenset([1])]),
+ frozenset([frozenset([1]),
+ frozenset([0,
+ 1])])]),
+ frozenset([frozenset([1, 2]), frozenset([2])]): frozenset([frozenset([frozenset([1,
+ 2]),
+ frozenset([0,
+ 1,
+ 2])]),
+ frozenset([frozenset([1]),
+ frozenset([1,
+ 2])]),
+ frozenset([frozenset([2]),
+ frozenset([0,
+ 2])]),
+ frozenset([frozenset(),
+ frozenset([2])])]),
+ frozenset([frozenset([]), frozenset([0])]): frozenset([frozenset([frozenset([0]),
+ frozenset([0,
+ 1])]),
+ frozenset([frozenset([0]),
+ frozenset([0,
+ 2])]),
+ frozenset([frozenset(),
+ frozenset([1])]),
+ frozenset([frozenset(),
+ frozenset([2])])]),
+ frozenset([frozenset([]), frozenset([1])]): frozenset([frozenset([frozenset(),
+ frozenset([0])]),
+ frozenset([frozenset([1]),
+ frozenset([1,
+ 2])]),
+ frozenset([frozenset(),
+ frozenset([2])]),
+ frozenset([frozenset([1]),
+ frozenset([0,
+ 1])])]),
+ frozenset([frozenset([2]), frozenset([])]): frozenset([frozenset([frozenset([2]),
+ frozenset([1,
+ 2])]),
+ frozenset([frozenset(),
+ frozenset([0])]),
+ frozenset([frozenset(),
+ frozenset([1])]),
+ frozenset([frozenset([2]),
+ frozenset([0,
+ 2])])]),
+ frozenset([frozenset([0, 1, 2]), frozenset([0, 1])]): frozenset([frozenset([frozenset([1,
+ 2]),
+ frozenset([0,
+ 1,
+ 2])]),
+ frozenset([frozenset([0,
+ 2]),
+ frozenset([0,
+ 1,
+ 2])]),
+ frozenset([frozenset([0]),
+ frozenset([0,
+ 1])]),
+ frozenset([frozenset([1]),
+ frozenset([0,
+ 1])])]),
+ frozenset([frozenset([0]), frozenset([0, 1])]): frozenset([frozenset([frozenset(),
+ frozenset([0])]),
+ frozenset([frozenset([0,
+ 1]),
+ frozenset([0,
+ 1,
+ 2])]),
+ frozenset([frozenset([0]),
+ frozenset([0,
+ 2])]),
+ frozenset([frozenset([1]),
+ frozenset([0,
+ 1])])]),
+ frozenset([frozenset([2]), frozenset([0, 2])]): frozenset([frozenset([frozenset([0,
+ 2]),
+ frozenset([0,
+ 1,
+ 2])]),
+ frozenset([frozenset([2]),
+ frozenset([1,
+ 2])]),
+ frozenset([frozenset([0]),
+ frozenset([0,
+ 2])]),
+ frozenset([frozenset(),
+ frozenset([2])])]),
+ frozenset([frozenset([0, 1, 2]), frozenset([0, 2])]): frozenset([frozenset([frozenset([1,
+ 2]),
+ frozenset([0,
+ 1,
+ 2])]),
+ frozenset([frozenset([0,
+ 1]),
+ frozenset([0,
+ 1,
+ 2])]),
+ frozenset([frozenset([0]),
+ frozenset([0,
+ 2])]),
+ frozenset([frozenset([2]),
+ frozenset([0,
+ 2])])]),
+ frozenset([frozenset([1, 2]), frozenset([0, 1, 2])]): frozenset([frozenset([frozenset([0,
+ 2]),
+ frozenset([0,
+ 1,
+ 2])]),
+ frozenset([frozenset([0,
+ 1]),
+ frozenset([0,
+ 1,
+ 2])]),
+ frozenset([frozenset([2]),
+ frozenset([1,
+ 2])]),
+ frozenset([frozenset([1]),
+ frozenset([1,
+ 2])])])}"""
+
+ cubo = test.test_set.linegraph(cube)
+ self.assertEqual(pprint.pformat(cubo), cubo_repr_tgt)
+
+ def test_depth(self):
+ nested_tuple = (1, (2, (3, (4, (5, 6)))))
+ nested_dict = {1: {2: {3: {4: {5: {6: 6}}}}}}
+ nested_list = [1, [2, [3, [4, [5, [6, []]]]]]]
+ self.assertEqual(pprint.pformat(nested_tuple), repr(nested_tuple))
+ self.assertEqual(pprint.pformat(nested_dict), repr(nested_dict))
+ self.assertEqual(pprint.pformat(nested_list), repr(nested_list))
+
+ lv1_tuple = '(1, (...))'
+ lv1_dict = '{1: {...}}'
+ lv1_list = '[1, [...]]'
+ self.assertEqual(pprint.pformat(nested_tuple, depth=1), lv1_tuple)
+ self.assertEqual(pprint.pformat(nested_dict, depth=1), lv1_dict)
+ self.assertEqual(pprint.pformat(nested_list, depth=1), lv1_list)
+
+
+class DottedPrettyPrinter(pprint.PrettyPrinter):
+
+ def format(self, object, context, maxlevels, level):
+ if isinstance(object, str):
+ if ' ' in object:
+ return repr(object), 1, 0
+ else:
+ return object, 0, 0
+ else:
+ return pprint.PrettyPrinter.format(
+ self, object, context, maxlevels, level)
+
+
+def test_main():
+ test.test_support.run_unittest(QueryTestCase)
+
+
+if __name__ == "__main__":
+ test_main()
generated by cgit v1.2.3 (git 2.25.1) at 2024-06-05 11:15:49 +0000