forked from pool/python-pprintpp
Matej Cepl
035ee0128b
- %check: drop usage of nose, use %pytest macro for testing - added patches fix https://github.com/wolever/pprintpp/pull/28 + python-pprintpp-remove-nose.patch OBS-URL: https://build.opensuse.org/request/show/927765 OBS-URL: https://build.opensuse.org/package/show/devel:languages:python/python-pprintpp?expand=0&rev=8
290 lines
8.8 KiB
Diff
290 lines
8.8 KiB
Diff
Index: pprintpp-0.4.0/test.py
|
|
===================================================================
|
|
--- pprintpp-0.4.0.orig/test.py 2021-10-26 13:15:18.391876167 +0200
|
|
+++ pprintpp-0.4.0/test.py 2021-10-26 13:15:23.059902356 +0200
|
|
@@ -1,46 +1,100 @@
|
|
from __future__ import print_function
|
|
|
|
import sys
|
|
-import ctypes
|
|
-import textwrap
|
|
-
|
|
-from nose.tools import assert_equal
|
|
-from parameterized import parameterized, param
|
|
+from contextlib import redirect_stdout
|
|
+import io
|
|
+import pytest
|
|
|
|
sys.path.append("pp/")
|
|
import pp
|
|
import pprintpp as p
|
|
from pprintpp import Counter, defaultdict, OrderedDict
|
|
|
|
-class PPrintppTestBase(object):
|
|
- def assertStdout(self, expected, trim=True):
|
|
- if trim:
|
|
- expected = textwrap.dedent(expected.rstrip().lstrip("\n"))
|
|
- # Assumes that nose's capture plugin is active
|
|
- assert_equal(sys.stdout.getvalue().rstrip(), expected)
|
|
-
|
|
-
|
|
-class TestPP(PPrintppTestBase):
|
|
- def test_pp(self):
|
|
+def test_pp():
|
|
+ expected = "['hello', 'world']"
|
|
+ f = io.StringIO()
|
|
+ with redirect_stdout(f):
|
|
pp(["hello", "world"])
|
|
- self.assertStdout("['hello', 'world']")
|
|
+ actual = f.getvalue().rstrip("\n")
|
|
+ assert actual == expected
|
|
|
|
- def test_pp_pprint(self):
|
|
+def test_pp_print():
|
|
+ expected = "'stuff'"
|
|
+ f = io.StringIO()
|
|
+ with redirect_stdout(f):
|
|
pp.pprint("stuff")
|
|
- self.assertStdout("'stuff'")
|
|
+ actual = f.getvalue().rstrip("\n")
|
|
+ assert actual == expected
|
|
|
|
- def test_fmt(self):
|
|
+def test_fmt():
|
|
+ expected = "'asdf'\n'stuff'"
|
|
+ f = io.StringIO()
|
|
+ with redirect_stdout(f):
|
|
print(pp.pformat("asdf"))
|
|
print(pp.fmt("stuff"))
|
|
- self.assertStdout("""
|
|
- 'asdf'
|
|
- 'stuff'
|
|
- """)
|
|
-
|
|
- def test_module_like(self):
|
|
- print(dir(pp))
|
|
- print(repr(pp))
|
|
+ actual = f.getvalue().rstrip("\n")
|
|
+ assert actual == expected
|
|
|
|
+def test_module_like():
|
|
+ print(dir(pp))
|
|
+ print(repr(pp))
|
|
+
|
|
+uni_safe = "\xe9 \u6f02 \u0e4f \u2661"
|
|
+uni_unsafe = "\u200a \u0302 \n"
|
|
+slashed = lambda s: u"%s'%s'" %(
|
|
+ p.u_prefix,
|
|
+ s.encode("ascii", "backslashreplace").decode("ascii").replace("\n", "\\n")
|
|
+)
|
|
+
|
|
+test_unicode_data = [
|
|
+ (uni_safe, "%s'%s'" %(p.u_prefix, uni_safe), "utf-8"),
|
|
+ (uni_unsafe, slashed(uni_unsafe), "utf-8"),
|
|
+ (uni_unsafe, slashed(uni_unsafe), "ascii"),
|
|
+ ("\U0002F9B2", slashed("\U0002F9B2"), "ascii")
|
|
+]
|
|
+
|
|
+@pytest.mark.parametrize("input,expected,encoding", test_unicode_data)
|
|
+def test_unicode(input, expected, encoding):
|
|
+ stream = p.TextIO(encoding=encoding)
|
|
+ p.pprint(input, stream=stream)
|
|
+ assert stream.getvalue().rstrip("\n") == expected
|
|
+
|
|
+test_back_and_forth_data = [
|
|
+ "'\\'\"'",
|
|
+ '"\'"',
|
|
+ "'\"'",
|
|
+ "frozenset(['a', 'b', 'c'])",
|
|
+ "set([None, 1, 'a'])",
|
|
+ "[]",
|
|
+ "[1]",
|
|
+ "{}",
|
|
+ "{1: 1}",
|
|
+ "set()",
|
|
+ "set([1])",
|
|
+ "frozenset()",
|
|
+ "frozenset([1])",
|
|
+ "()",
|
|
+ "(1, )",
|
|
+ "MyDict({})",
|
|
+ "MyDict({1: 1})",
|
|
+ "MyList([])",
|
|
+ "MyList([1])",
|
|
+ "MyTuple(())",
|
|
+ "MyTuple((1, ))",
|
|
+ "MySet()",
|
|
+ "MySet([1])",
|
|
+ "MyFrozenSet()",
|
|
+ "MyFrozenSet([1])",
|
|
+ "Counter()",
|
|
+ "Counter({1: 1})",
|
|
+ "OrderedDict()",
|
|
+ "OrderedDict([(1, 1), (5, 5), (2, 2)])",
|
|
+ "MyOrderedDict()",
|
|
+ "MyOrderedDict([(1, 1)])",
|
|
+ "MyCounter()",
|
|
+ "MyCounter({1: 1})",
|
|
+ "MyCounterWithRepr('dummy')",
|
|
+]
|
|
|
|
class MyDict(dict):
|
|
pass
|
|
@@ -70,104 +124,46 @@ class MyCounterWithRepr(p.Counter):
|
|
def __repr__(self):
|
|
return "MyCounterWithRepr('dummy')"
|
|
|
|
-class TestPPrint(PPrintppTestBase):
|
|
- uni_safe = u"\xe9 \u6f02 \u0e4f \u2661"
|
|
- uni_unsafe = u"\u200a \u0302 \n"
|
|
- slashed = lambda s: u"%s'%s'" %(
|
|
- p.u_prefix,
|
|
- s.encode("ascii", "backslashreplace").decode("ascii").replace("\n", "\\n")
|
|
- )
|
|
-
|
|
- @parameterized([
|
|
- param("safe", uni_safe, "%s'%s'" %(p.u_prefix, uni_safe)),
|
|
- param("unsafe", uni_unsafe, slashed(uni_unsafe)),
|
|
- param("encoding-aware", uni_safe, slashed(uni_safe), encoding="ascii"),
|
|
- param("high-end-chars", u"\U0002F9B2", slashed(u"\U0002F9B2"), encoding="ascii"),
|
|
- ])
|
|
- def test_unicode(self, name, input, expected, encoding="utf-8"):
|
|
- stream = p.TextIO(encoding=encoding)
|
|
- p.pprint(input, stream=stream)
|
|
- assert_equal(stream.getvalue().rstrip("\n"), expected)
|
|
-
|
|
- @parameterized([
|
|
- param(u"'\\'\"'"),
|
|
- param(u'"\'"'),
|
|
- param(u"'\"'"),
|
|
- param("frozenset(['a', 'b', 'c'])"),
|
|
- param("set([None, 1, 'a'])"),
|
|
-
|
|
- param("[]"),
|
|
- param("[1]"),
|
|
- param("{}"),
|
|
- param("{1: 1}"),
|
|
- param("set()"),
|
|
- param("set([1])"),
|
|
- param("frozenset()"),
|
|
- param("frozenset([1])"),
|
|
- param("()"),
|
|
- param("(1, )"),
|
|
-
|
|
- param("MyDict({})"),
|
|
- param("MyDict({1: 1})"),
|
|
- param("MyList([])"),
|
|
- param("MyList([1])"),
|
|
- param("MyTuple(())"),
|
|
- param("MyTuple((1, ))"),
|
|
- param("MySet()"),
|
|
- param("MySet([1])"),
|
|
- param("MyFrozenSet()"),
|
|
- param("MyFrozenSet([1])"),
|
|
-
|
|
- ] + ([] if not p._test_has_collections else [
|
|
- param("Counter()"),
|
|
- param("Counter({1: 1})"),
|
|
- param("OrderedDict()"),
|
|
- param("OrderedDict([(1, 1), (5, 5), (2, 2)])"),
|
|
- param("MyOrderedDict()"),
|
|
- param("MyOrderedDict([(1, 1)])"),
|
|
- param("MyCounter()"),
|
|
- param("MyCounter({1: 1})"),
|
|
- param("MyCounterWithRepr('dummy')"),
|
|
- ]))
|
|
- def test_back_and_forth(self, expected):
|
|
- input = eval(expected)
|
|
- stream = p.TextIO()
|
|
- p.pprint(input, stream=stream)
|
|
- assert_equal(stream.getvalue().rstrip("\n"), expected)
|
|
-
|
|
- if p._test_has_collections:
|
|
- @parameterized([
|
|
- param("defaultdict(%r, {})" %(int, ), defaultdict(int)),
|
|
- param("defaultdict(%r, {1: 1})" %(int, ), defaultdict(int, [(1, 1)])),
|
|
- param("MyDefaultDict(%r, {})" %(int, ), MyDefaultDict(int)),
|
|
- param("MyDefaultDict(%r, {1: 1})" %(int, ), MyDefaultDict(int, [(1, 1)])),
|
|
- ])
|
|
- def test_expected_input(self, expected, input):
|
|
- stream = p.TextIO()
|
|
- p.pprint(input, stream=stream)
|
|
- assert_equal(stream.getvalue().rstrip("\n"), expected)
|
|
-
|
|
- def test_unhashable_repr(self):
|
|
- # In Python 3, C extensions can define a __repr__ method which is an
|
|
- # instance of `instancemethod`, which is unhashable. It turns out to be
|
|
- # spectacularly difficult to create an `instancemethod` and attach it to
|
|
- # a type without using C... so we'll simulate it using a more explicitly
|
|
- # unhashable type.
|
|
- # See also: http://stackoverflow.com/q/40876368/71522
|
|
-
|
|
- class UnhashableCallable(object):
|
|
- __hash__ = None
|
|
-
|
|
- def __call__(self):
|
|
- return "some-repr"
|
|
-
|
|
- class MyCls(object):
|
|
- __repr__ = UnhashableCallable()
|
|
-
|
|
- obj = MyCls()
|
|
- assert_equal(p.pformat(obj), "some-repr")
|
|
-
|
|
-
|
|
-if __name__ == "__main__":
|
|
- import nose
|
|
- nose.main()
|
|
+@pytest.mark.parametrize("expected", test_back_and_forth_data)
|
|
+def test_back_and_forth(expected):
|
|
+ input = eval(expected)
|
|
+ stream = p.TextIO()
|
|
+ p.pprint(input, stream=stream)
|
|
+ assert stream.getvalue().rstrip("\n") == expected
|
|
+
|
|
+test_expected_input_data = [
|
|
+ ("defaultdict(%r, {})" %(int, ), defaultdict(int)),
|
|
+ ("defaultdict(%r, {1: 1})" %(int, ), defaultdict(int, [(1, 1)])),
|
|
+ ("MyDefaultDict(%r, {})" %(int, ), MyDefaultDict(int)),
|
|
+ ("MyDefaultDict(%r, {1: 1})" %(int, ), MyDefaultDict(int, [(1, 1)])),
|
|
+]
|
|
+
|
|
+@pytest.mark.parametrize("expected,input", test_expected_input_data)
|
|
+def test_expected_input(expected, input):
|
|
+ stream = p.TextIO()
|
|
+ p.pprint(input, stream=stream)
|
|
+ assert stream.getvalue().rstrip("\n") == expected
|
|
+
|
|
+
|
|
+def test_unhashable_repr():
|
|
+ # In Python 3, C extensions can define a __repr__ method which is an
|
|
+ # instance of `instancemethod`, which is unhashable. It turns out to be
|
|
+ # spectacularly difficult to create an `instancemethod` and attach it to
|
|
+ # a type without using C... so we'll simulate it using a more explicitly
|
|
+ # unhashable type.
|
|
+ # See also: http://stackoverflow.com/q/40876368/71522
|
|
+
|
|
+ class UnhashableCallable(object):
|
|
+ __hash__ = None
|
|
+
|
|
+ def __call__(self):
|
|
+ return "some-repr"
|
|
+
|
|
+ class MyCls(object):
|
|
+ __repr__ = UnhashableCallable()
|
|
+
|
|
+ obj = MyCls()
|
|
+ assert p.pformat(obj) == "some-repr"
|
|
+
|
|
+
|
|
+
|
|
Index: pprintpp-0.4.0/test-requires.txt
|
|
===================================================================
|
|
--- pprintpp-0.4.0.orig/test-requires.txt 2021-10-26 13:15:18.391876167 +0200
|
|
+++ pprintpp-0.4.0/test-requires.txt 2021-10-26 13:15:18.395876190 +0200
|
|
@@ -1,2 +1,2 @@
|
|
-nose==1.3.0
|
|
+pytest
|
|
parameterized==0.6.1
|
|
|