def test_super_repr():
output = pretty.pretty(super(SA))
assert_in('SA', output)
sb = SB()
output = pretty.pretty(super(SA, sb))
assert_in('SA', output)
def test_unicode_repr():
u = u"üniçodé"
ustr = unicode_to_str(u)
class C(object):
def __repr__(self):
return ustr
c = C()
p = pretty.pretty(c)
assert_equal(p, u)
p = pretty.pretty([c])
assert_equal(p, u"[%s]" % u)
def nicerepr(v):
if inspect.isfunction(v):
return get_pretty_function_description(v)
elif isinstance(v, type):
return v.__name__
else:
return to_str(pretty(v))
def test_callability_checking():
"""Test that the _repr_pretty_ method is tested for callability and skipped
if not."""
gotoutput = pretty.pretty(Dummy2())
expectedoutput = 'Dummy1(...)'
assert_equal(gotoutput, expectedoutput)
def test_collections_deque():
# Create deque with cycle
a = deque()
a.append(a)
cases = [
(deque(), 'deque([])'),
(deque(i for i in range(1000, 1020)),
'deque([1000,\n'
' 1001,\n'
' 1002,\n'
' 1003,\n'
' 1004,\n'
' 1005,\n'
' 1006,\n'
' 1007,\n'
' 1008,\n'
' 1009,\n'
' 1010,\n'
' 1011,\n'
' 1012,\n'
' 1013,\n'
' 1014,\n'
' 1015,\n'
' 1016,\n'
' 1017,\n'
' 1018,\n'
' 1019])'),
(a, 'deque([deque(...)])'),
]
for obj, expected in cases:
assert_equal(pretty.pretty(obj), expected)
def test_dispatch():
"""Test correct dispatching: The _repr_pretty_ method for MyDict must be
found before the registered printer for dict."""
gotoutput = pretty.pretty(MyDict())
expectedoutput = "MyDict(...)"
assert_equal(gotoutput, expectedoutput)
def test_indentation():
"""Test correct indentation in groups."""
count = 40
gotoutput = pretty.pretty(MyList(range(count)))
expectedoutput = "MyList(\n" + ",\n".join(" %d" % i for i in range(count)) + ")"
assert_equal(gotoutput, expectedoutput)
def test_re_evals():
for r in [
re.compile(r'hi'), re.compile(r'b\nc', re.MULTILINE),
re.compile(br'hi', 0), re.compile(u'foo', re.MULTILINE | re.UNICODE),
]:
r2 = eval(pretty.pretty(r), globals())
assert r.pattern == r2.pattern and r.flags == r2.flags
def test_indentation():
"""Test correct indentation in groups."""
count = 40
gotoutput = pretty.pretty(MyList(range(count)))
expectedoutput = 'MyList(\n' + ',\n'.join(' %d' %
i for i in range(count)) + ')'
assert_equal(gotoutput, expectedoutput)
def test_sets():
"""Test that set and frozenset use Python 3 formatting."""
objects = [set(), frozenset(), set([1]), frozenset([1]), set([1, 2]),
frozenset([1, 2]), set([-1, -2, -3])]
expected = ['set()', 'frozenset()', '{1}', 'frozenset({1})', '{1, 2}',
'frozenset({1, 2})', '{-3, -2, -1}']
for obj, expected_output in zip(objects, expected):
got_output = pretty.pretty(obj)
yield assert_equal, got_output, expected_output
def test_re_evals():
for r in [
re.compile(r"hi"),
re.compile(r"b\nc", re.MULTILINE),
re.compile(br"hi", 0),
re.compile(u"foo", re.MULTILINE | re.UNICODE),
]:
r2 = eval(pretty.pretty(r), globals())
assert r.pattern == r2.pattern and r.flags == r2.flags
def test_collections_counter():
class MyCounter(Counter):
pass
cases = [
(Counter(), 'Counter()'),
(Counter(a=1), "Counter({'a': 1})"),
(MyCounter(a=1), "MyCounter({'a': 1})"),
]
for obj, expected in cases:
assert_equal(pretty.pretty(obj), expected)
def test_collections_defaultdict():
# Create defaultdicts with cycles
a = defaultdict()
a.default_factory = a
b = defaultdict(list)
b['key'] = b
# Dictionary order cannot be relied on, test against single keys.
cases = [
(defaultdict(list), 'defaultdict(list, {})'),
(defaultdict(list, {'key': '-' * 50}),
'defaultdict(list,\n'
" {'key': '-----------------------------------------"
"---------'})"),
(a, 'defaultdict(defaultdict(...), {})'),
(b, "defaultdict(list, {'key': defaultdict(...)})"),
]
for obj, expected in cases:
assert_equal(pretty.pretty(obj), expected)
def test_collections_ordereddict():
# Create OrderedDict with cycle
a = OrderedDict()
a['key'] = a
cases = [
(OrderedDict(), 'OrderedDict()'),
(OrderedDict((i, i) for i in range(1000, 1010)),
'OrderedDict([(1000, 1000),\n'
' (1001, 1001),\n'
' (1002, 1002),\n'
' (1003, 1003),\n'
' (1004, 1004),\n'
' (1005, 1005),\n'
' (1006, 1006),\n'
' (1007, 1007),\n'
' (1008, 1008),\n'
' (1009, 1009)])'),
(a, "OrderedDict([('key', OrderedDict(...))])"),
]
for obj, expected in cases:
assert_equal(pretty.pretty(obj), expected)
def test_sets():
"""Test that set and frozenset use Python 3 formatting."""
objects = [
set(),
frozenset(),
{1},
frozenset([1]),
{1, 2},
frozenset([1, 2]),
{-1, -2, -3},
]
expected = [
"set()",
"frozenset()",
"{1}",
"frozenset({1})",
"{1, 2}",
"frozenset({1, 2})",
"{-3, -2, -1}",
]
for obj, expected_output in zip(objects, expected):
got_output = pretty.pretty(obj)
assert_equal(got_output, expected_output)
def test_long_tuple():
tup = tuple(range(10000))
p = pretty.pretty(tup)
last2 = p.rsplit("\n", 2)[-2:]
assert_equal(last2, [" 999,", " ...)"])
def test_unbound_method():
output = pretty.pretty(MyObj.somemethod)
assert_in("MyObj.somemethod", output)
def test_cyclic_list():
x = []
x.append(x)
assert pretty.pretty(x) == "[[...]]"
def test_pprint_break_repr():
"""Test that p.break_ is used in repr."""
output = pretty.pretty(BreakingReprParent())
expected = "TG: Breaking(\n ):"
assert_equal(output, expected)
def test_pprint_nomod():
"""Test that pprint works for classes with no __module__."""
output = pretty.pretty(NoModule)
assert_equal(output, "NoModule")
def test_cyclic_dequeue():
x = deque()
x.append(x)
assert pretty.pretty(x) == "deque([deque(...)])"
def test_print_builtin_function():
assert pretty.pretty(abs) == "<function abs>"
def test_custom():
assert "bye" not in pretty.pretty(CustomStuff())
assert "bye=" in pretty.pretty(CustomStuff(), verbose=True)
assert "squirrels" not in pretty.pretty(CustomStuff(), verbose=True)
def test_exception():
assert pretty.pretty(ValueError("hi")) == "ValueError('hi')"
assert pretty.pretty(ValueError("hi", "there")) == "ValueError('hi', 'there')"
assert "test_pretty." in pretty.pretty(MyException())
def test_print_with_indent():
pretty.pretty(BigList([1, 2, 3]))
def test_pprint():
t = {"hi": 1}
with capture_out() as o:
pretty.pprint(t)
assert o.getvalue().strip() == pretty.pretty(t)
def test_cyclic_set():
x = set()
x.add(HashItAnyway(x))
assert pretty.pretty(x) == "{{...}}"
def test_cyclic_dict():
x = {}
k = HashItAnyway(x)
x[k] = x
assert pretty.pretty(x) == "{{...}: {...}}"
def test_cyclic_counter():
c = Counter()
k = HashItAnyway(c)
c[k] = 1
assert pretty.pretty(c) == "Counter({Counter(...): 1})"
def test_pretty_function():
assert "." in pretty.pretty(test_pretty_function)
def test_pprint_heap_allocated_type():
"""Test that pprint works for heap allocated types."""
import xxlimited
output = pretty.pretty(xxlimited.Null)
assert_equal(output, "xxlimited.Null")
def test_breakable_at_group_boundary():
assert "\n" in pretty.pretty([[], "000000"], max_width=5)
def test_pprint_break():
"""Test that p.break_ produces expected output."""
output = pretty.pretty(Breaking())
expected = "TG: Breaking(\n ):"
assert_equal(output, expected)
def test_cyclic_list():
x = []
x.append(x)
assert pretty.pretty(x) == '[[...]]'
def test_bad_repr():
"""Don't catch bad repr errors."""
with assert_raises(ZeroDivisionError):
pretty.pretty(BadRepr())
def _repr_pretty_(self, pretty, cycle):
pretty.pretty(self.value)
def test_metaclass_repr():
output = pretty.pretty(ClassWithMeta)
assert_equal(output, "[CUSTOM REPR FOR CLASS ClassWithMeta]")
def test_cyclic_dict():
x = {}
k = HashItAnyway(x)
x[k] = x
assert pretty.pretty(x) == '{{...}: {...}}'
def test_long_dict():
d = {n: n for n in range(10000)}
p = pretty.pretty(d)
last2 = p.rsplit("\n", 2)[-2:]
assert_equal(last2, [" 999: 999,", " ...}"])
def test_pprint():
t = {'hi': 1}
with capture_out() as o:
pretty.pprint(t)
assert o.getvalue().strip() == pretty.pretty(t)
def test_metaclass_repr():
output = pretty.pretty(ClassWithMeta)
assert_equal(output, '[CUSTOM REPR FOR CLASS ClassWithMeta]')
def test_exception():
assert pretty.pretty(ValueError('hi')) == "ValueError('hi')"
assert pretty.pretty(ValueError('hi', 'there')) == \
"ValueError('hi', 'there')"
assert 'test_pretty.' in pretty.pretty(MyException())
def test_custom():
assert 'bye' not in pretty.pretty(CustomStuff())
assert 'bye=' in pretty.pretty(CustomStuff(), verbose=True)
assert 'squirrels' not in pretty.pretty(CustomStuff(), verbose=True)
def test_pretty_function():
assert '.' in pretty.pretty(test_pretty_function)
def test_list():
assert pretty.pretty([]) == "[]"
assert pretty.pretty([1]) == "[1]"
def _repr_pretty_(self, pretty, cycle):
pretty.pretty(self.value)
def test_cyclic_dequeue():
x = deque()
x.append(x)
assert pretty.pretty(x) == 'deque([deque(...)])'
def test_dict():
assert pretty.pretty({}) == "{}"
assert pretty.pretty({1: 1}) == "{1: 1}"
def test_cyclic_counter():
c = Counter()
k = HashItAnyway(c)
c[k] = 1
assert pretty.pretty(c) == 'Counter({Counter(...): 1})'
def test_tuple():
assert pretty.pretty(()) == "()"
assert pretty.pretty((1, )) == "(1,)"
assert pretty.pretty((1, 2)) == "(1, 2)"
def test_cyclic_set():
x = set()
x.add(HashItAnyway(x))
assert pretty.pretty(x) == '{{...}}'
def test_dict_with_custom_repr():
assert pretty.pretty(ReprDict()) == "hi"
def test_print_with_indent():
pretty.pretty(BigList([1, 2, 3]))
def test_set_with_custom_repr():
assert pretty.pretty(ReprSet()) == "cat"
def test_re_evals():
for r in [
re.compile(r'hi'), re.compile(r'b\nc', re.MULTILINE),
re.compile(br'hi', 0), re.compile(u'foo', re.MULTILINE | re.UNICODE),
]:
assert repr(eval(pretty.pretty(r), globals())) == repr(r)
def test_list_with_custom_repr():
assert pretty.pretty(ReprList()) == "bye"
def test_print_builtin_function():
assert pretty.pretty(abs) == '<function abs>'
def test_unsortable_set():
xs = {1, 2, 3, "foo", "bar", "baz", object()}
p = pretty.pretty(xs)
for x in xs:
assert pretty.pretty(x) in p
def test_breakable_at_group_boundary():
assert '\n' in pretty.pretty([[], '000000'], max_width=5)
def test_unsortable_dict():
xs = {k: 1 for k in [1, 2, 3, "foo", "bar", "baz", object()]}
p = pretty.pretty(xs)
for x in xs:
assert pretty.pretty(x) in p
