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