##// END OF EJS Templates
Add EditorConfig to preserve trailing whitespace http://editorconfig.org/
Add EditorConfig to preserve trailing whitespace http://editorconfig.org/

File last commit:

r23706:c390ce47
r24007:3de88102
Show More
test_pretty.py
407 lines | 10.9 KiB | text/x-python | PythonLexer
Min RK
test pretty with unicode repr
r20662 # coding: utf-8
MinRK
Don't catch repr-errors in pretty...
r18024 """Tests for IPython.lib.pretty."""
# Copyright (c) IPython Development Team.
Walter Doerwald
Add test for the indentation fix.
r6295 # Distributed under the terms of the Modified BSD License.
Frazer McLean
Add pprint support for containers from collections...
r21375 from collections import Counter, defaultdict, deque, OrderedDict
Matthias Bussonnier
Refactor test to get rid of deprecation....
r23706 import types
import string
import unittest
Frazer McLean
Add pprint support for containers from collections...
r21375
Walter Doerwald
Add test for the indentation fix.
r6295 import nose.tools as nt
from IPython.lib import pretty
Paul Ivanov
remove Python2/3 specific decorators
r22960 from IPython.testing.decorators import skip_without
Remi Rampin
Adds test for pprint type without meta
r18420
Paul Ivanov
remove Python2/3 specific decorators
r22960 from io import StringIO
Walter Doerwald
Add test for the indentation fix.
r6295
class MyList(object):
def __init__(self, content):
self.content = content
def _repr_pretty_(self, p, cycle):
if cycle:
p.text("MyList(...)")
else:
with p.group(3, "MyList(", ")"):
for (i, child) in enumerate(self.content):
if i:
p.text(",")
p.breakable()
else:
p.breakable("")
p.pretty(child)
Walter Doerwald
Fix dispatching in the pretty printing module....
r6313 class MyDict(dict):
def _repr_pretty_(self, p, cycle):
p.text("MyDict(...)")
Thomas Kluyver
Add failing test for unbound method repr on Python 3
r16238 class MyObj(object):
def somemethod(self):
pass
Walter Doerwald
Fix dispatching in the pretty printing module....
r6313
Robert Kern
BUG: Look up the `_repr_pretty_` method on the class within the MRO rather than the original leaf class....
r7831 class Dummy1(object):
def _repr_pretty_(self, p, cycle):
p.text("Dummy1(...)")
class Dummy2(Dummy1):
_repr_pretty_ = None
MinRK
test pretty print when __module__ is None
r10789 class NoModule(object):
pass
NoModule.__module__ = None
Alex Rudy
Adds p.break_ for explicit newlines in lib.pretty...
r11875 class Breaking(object):
def _repr_pretty_(self, p, cycle):
with p.group(4,"TG: ",":"):
p.text("Breaking(")
p.break_()
p.text(")")
Alex Rudy
Uses p.break_() when repr() is used for printing...
r11876 class BreakingRepr(object):
def __repr__(self):
return "Breaking(\n)"
class BreakingReprParent(object):
def _repr_pretty_(self, p, cycle):
with p.group(4,"TG: ",":"):
p.pretty(BreakingRepr())
MinRK
test bad repr
r13425 class BadRepr(object):
def __repr__(self):
return 1/0
Alex Rudy
Uses p.break_() when repr() is used for printing...
r11876
Robert Kern
BUG: Look up the `_repr_pretty_` method on the class within the MRO rather than the original leaf class....
r7831
Walter Doerwald
Add test for the indentation fix.
r6295 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)) + ")"
Bradley M. Froehle
s/nt.assert_equals/nt.assert_equal/
r7875 nt.assert_equal(gotoutput, expectedoutput)
Walter Doerwald
Fix dispatching in the pretty printing module....
r6313
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(...)"
Bradley M. Froehle
s/nt.assert_equals/nt.assert_equal/
r7875 nt.assert_equal(gotoutput, expectedoutput)
Robert Kern
BUG: Look up the `_repr_pretty_` method on the class within the MRO rather than the original leaf class....
r7831
def test_callability_checking():
"""
Test that the _repr_pretty_ method is tested for callability and skipped if
not.
"""
gotoutput = pretty.pretty(Dummy2())
expectedoutput = "Dummy1(...)"
Bradley M. Froehle
s/nt.assert_equals/nt.assert_equal/
r7875 nt.assert_equal(gotoutput, expectedoutput)
Bradley M. Froehle
Add test for gh-2684.
r8888
Robert Kern
ENH: Add tests for set and frozenset pretty-printing.
r10234
def test_sets():
"""
Test that set and frozenset use Python 3 formatting.
"""
Robert Kern
ENH: Make the set pretty-printer sort the elements if possible, similar to dict keys.
r10235 objects = [set(), frozenset(), set([1]), frozenset([1]), set([1, 2]),
frozenset([1, 2]), set([-1, -2, -3])]
Robert Kern
ENH: Add tests for set and frozenset pretty-printing.
r10234 expected = ['set()', 'frozenset()', '{1}', 'frozenset({1})', '{1, 2}',
Robert Kern
ENH: Make the set pretty-printer sort the elements if possible, similar to dict keys.
r10235 'frozenset({1, 2})', '{-3, -2, -1}']
Robert Kern
ENH: Add tests for set and frozenset pretty-printing.
r10234 for obj, expected_output in zip(objects, expected):
got_output = pretty.pretty(obj)
yield nt.assert_equal, got_output, expected_output
Bradley M. Froehle
Add test for gh-2684.
r8888 @skip_without('xxlimited')
def test_pprint_heap_allocated_type():
"""
Test that pprint works for heap allocated types.
"""
import xxlimited
output = pretty.pretty(xxlimited.Null)
nt.assert_equal(output, 'xxlimited.Null')
MinRK
test pretty print when __module__ is None
r10789
def test_pprint_nomod():
"""
Test that pprint works for classes with no __module__.
"""
output = pretty.pretty(NoModule)
nt.assert_equal(output, 'NoModule')
Alex Rudy
Adds p.break_ for explicit newlines in lib.pretty...
r11875
def test_pprint_break():
"""
Test that p.break_ produces expected output
"""
output = pretty.pretty(Breaking())
expected = "TG: Breaking(\n ):"
nt.assert_equal(output, expected)
Alex Rudy
Uses p.break_() when repr() is used for printing...
r11876
def test_pprint_break_repr():
"""
Test that p.break_ is used in repr
"""
output = pretty.pretty(BreakingReprParent())
expected = "TG: Breaking(\n ):"
MinRK
test bad repr
r13425 nt.assert_equal(output, expected)
def test_bad_repr():
MinRK
Don't catch repr-errors in pretty...
r18024 """Don't catch bad repr errors"""
with nt.assert_raises(ZeroDivisionError):
Matthias Bussonnier
Cleanup some of the skip-if decorators....
r22837 pretty.pretty(BadRepr())
MinRK
test really bad repr
r13434
class BadException(Exception):
def __str__(self):
return -1
class ReallyBadRepr(object):
__module__ = 1
@property
def __class__(self):
raise ValueError("I am horrible")
def __repr__(self):
raise BadException()
def test_really_bad_repr():
MinRK
Don't catch repr-errors in pretty...
r18024 with nt.assert_raises(BadException):
Matthias Bussonnier
Cleanup some of the skip-if decorators....
r22837 pretty.pretty(ReallyBadRepr())
Thomas Kluyver
Add failing test for pretty repr of super() objects
r14996
class SA(object):
pass
class SB(SA):
pass
Matthias Bussonnier
Refactor test to get rid of deprecation....
r23706 class TestsPretty(unittest.TestCase):
def test_super_repr(self):
# "<super: module_name.SA, None>"
output = pretty.pretty(super(SA))
self.assertRegex(output, r"<super: \S+.SA, None>")
# "<super: module_name.SA, <module_name.SB at 0x...>>"
sb = SB()
output = pretty.pretty(super(SA, sb))
self.assertRegex(output, r"<super: \S+.SA,\s+<\S+.SB at 0x\S+>>")
def test_long_list(self):
lis = list(range(10000))
p = pretty.pretty(lis)
last2 = p.rsplit('\n', 2)[-2:]
self.assertEqual(last2, [' 999,', ' ...]'])
def test_long_set(self):
s = set(range(10000))
p = pretty.pretty(s)
last2 = p.rsplit('\n', 2)[-2:]
self.assertEqual(last2, [' 999,', ' ...}'])
def test_long_tuple(self):
tup = tuple(range(10000))
p = pretty.pretty(tup)
last2 = p.rsplit('\n', 2)[-2:]
self.assertEqual(last2, [' 999,', ' ...)'])
def test_long_dict(self):
d = { n:n for n in range(10000) }
p = pretty.pretty(d)
last2 = p.rsplit('\n', 2)[-2:]
self.assertEqual(last2, [' 999: 999,', ' ...}'])
def test_unbound_method(self):
output = pretty.pretty(MyObj.somemethod)
self.assertIn('MyObj.somemethod', output)
Remi Rampin
Adds test for pprinting type with meta __repr__...
r18403
class MetaClass(type):
def __new__(cls, name):
return type.__new__(cls, name, (object,), {'name': name})
def __repr__(self):
return "[CUSTOM REPR FOR CLASS %s]" % self.name
ClassWithMeta = MetaClass('ClassWithMeta')
def test_metaclass_repr():
output = pretty.pretty(ClassWithMeta)
nt.assert_equal(output, "[CUSTOM REPR FOR CLASS ClassWithMeta]")
Remi Rampin
Adds test for pprint type without meta
r18420
Min RK
test pretty with unicode repr
r20662 def test_unicode_repr():
Thomas Kluyver
Make unicode repr test work on cp1252 Windows...
r20727 u = u"üniçodé"
Paul Ivanov
remove Python2/3 specific decorators
r22960 ustr = u
Min RK
test pretty with unicode repr
r20662
class C(object):
def __repr__(self):
return ustr
c = C()
p = pretty.pretty(c)
nt.assert_equal(p, u)
p = pretty.pretty([c])
nt.assert_equal(p, u'[%s]' % u)
Remi Rampin
Adds test for pprint type without meta
r18420 def test_basic_class():
def type_pprint_wrapper(obj, p, cycle):
if obj is MyObj:
type_pprint_wrapper.called = True
return pretty._type_pprint(obj, p, cycle)
type_pprint_wrapper.called = False
stream = StringIO()
printer = pretty.RepresentationPrinter(stream)
printer.type_pprinters[type] = type_pprint_wrapper
printer.pretty(MyObj)
printer.flush()
output = stream.getvalue()
nt.assert_equal(output, '%s.MyObj' % __name__)
nt.assert_true(type_pprint_wrapper.called)
Frazer McLean
Add pprint support for containers from collections...
r21375
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:
nt.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:
nt.assert_equal(pretty.pretty(obj), expected)
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:
nt.assert_equal(pretty.pretty(obj), expected)
def test_collections_counter():
Min RK
pretty: don't hardcode names for counter/deque/etc subclasses...
r21769 class MyCounter(Counter):
pass
Frazer McLean
Add pprint support for containers from collections...
r21375 cases = [
(Counter(), 'Counter()'),
(Counter(a=1), "Counter({'a': 1})"),
Min RK
pretty: don't hardcode names for counter/deque/etc subclasses...
r21769 (MyCounter(a=1), "MyCounter({'a': 1})"),
Frazer McLean
Add pprint support for containers from collections...
r21375 ]
for obj, expected in cases:
nt.assert_equal(pretty.pretty(obj), expected)
Danilo J. S. Bellini
Add a types.MappingProxyType pretty printer #9821...
r22748
def test_mappingproxy():
MP = types.MappingProxyType
underlying_dict = {}
mp_recursive = MP(underlying_dict)
underlying_dict[2] = mp_recursive
underlying_dict[3] = underlying_dict
cases = [
(MP({}), "mappingproxy({})"),
(MP({None: MP({})}), "mappingproxy({None: mappingproxy({})})"),
(MP({k: k.upper() for k in string.ascii_lowercase}),
"mappingproxy({'a': 'A',\n"
" 'b': 'B',\n"
" 'c': 'C',\n"
" 'd': 'D',\n"
" 'e': 'E',\n"
" 'f': 'F',\n"
" 'g': 'G',\n"
" 'h': 'H',\n"
" 'i': 'I',\n"
" 'j': 'J',\n"
" 'k': 'K',\n"
" 'l': 'L',\n"
" 'm': 'M',\n"
" 'n': 'N',\n"
" 'o': 'O',\n"
" 'p': 'P',\n"
" 'q': 'Q',\n"
" 'r': 'R',\n"
" 's': 'S',\n"
" 't': 'T',\n"
" 'u': 'U',\n"
" 'v': 'V',\n"
" 'w': 'W',\n"
" 'x': 'X',\n"
" 'y': 'Y',\n"
" 'z': 'Z'})"),
(mp_recursive, "mappingproxy({2: {...}, 3: {2: {...}, 3: {...}}})"),
(underlying_dict,
"{2: mappingproxy({2: {...}, 3: {...}}), 3: {...}}"),
]
for obj, expected in cases:
nt.assert_equal(pretty.pretty(obj), expected)