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() |