Remove yield test that are not support by pytest anymore

And remove comparison of str/unicode as it is not relevant anymore as
both are the same.

We can now unpin pytest as well, which we should make sure is in release
notes and in the conda-forge recipe

As nose does not understand `@parametrize`, and the nose `@skip`
decorator messes with that as well, we mark tests with parametrize as
not-tests for iptests

.travis.yml

@@ -1,113 +1,113 b''
 # http://travis-ci.org/#!/ipython/ipython
 language: python
 os: linux
 
 addons:
   apt:
     packages:
       - graphviz
 
 python:
     - 3.8
 
 env:
   global:
     - PATH=$TRAVIS_BUILD_DIR/pandoc:$PATH
 
 group: edge
 
 before_install:
   - |
     # install Python on macOS
     if [[ "$TRAVIS_OS_NAME" == "osx" ]]; then
       env | sort
       if ! which python$TRAVIS_PYTHON_VERSION; then
         HOMEBREW_NO_AUTO_UPDATE=1 brew tap minrk/homebrew-python-frameworks
         HOMEBREW_NO_AUTO_UPDATE=1 brew cask install python-framework-${TRAVIS_PYTHON_VERSION/./}
       fi
       python3 -m pip install virtualenv
       python3 -m virtualenv -p $(which python$TRAVIS_PYTHON_VERSION) ~/travis-env
       source ~/travis-env/bin/activate
     fi
   - python --version
 
 install:
   - pip install pip --upgrade
   - pip install setuptools --upgrade
   - if [[ "$TRAVIS_PYTHON_VERSION" == "3.6" ]]; then
       echo "for the time being still test on 3.6";
       sed -ibkp s/7/6/g setup.py;
       git diff;
     fi
   - pip install -e file://$PWD#egg=ipython[test] --upgrade
   - pip install trio curio --upgrade --upgrade-strategy eager
-  - pip install 'pytest<6' 'matplotlib !=3.2.0'
+  - pip install 'pytest' 'matplotlib !=3.2.0'
   - pip install codecov check-manifest pytest-cov --upgrade
 
 
 script:
   - check-manifest
   - |
     if [[ "$TRAVIS_PYTHON_VERSION" == "nightly" ]]; then
        # on nightly fake parso known the grammar
        cp /home/travis/virtualenv/python3.9-dev/lib/python3.9/site-packages/parso/python/grammar38.txt /home/travis/virtualenv/python3.9-dev/lib/python3.9/site-packages/parso/python/grammar39.txt
     fi
   - |
     if [[ "$TRAVIS_PYTHON_VERSION" == "3.8" ]] && [[ "$TRAVIS_OS_NAME" == "linux" ]]; then
       cd /tmp && iptest --coverage xml && cd -
     fi
   - pytest --maxfail=10 IPython
   # On the latest Python (on Linux) only, make sure that the docs build.
   - |
     if [[ "$TRAVIS_PYTHON_VERSION" == "3.8" ]] && [[ "$TRAVIS_OS_NAME" == "linux" ]]; then
       pip install -r docs/requirements.txt
       python tools/fixup_whats_new_pr.py
       make -C docs/ html SPHINXOPTS="-W"
     fi
 
 after_success:
   - cp /tmp/ipy_coverage.xml ./
   - cp /tmp/.coverage ./
   - codecov
 
 matrix:
   include:
     - arch: amd64
       python: "3.6"
       dist: xenial
     - arch: amd64
       python: "3.7"
       dist: xenial
     - arch: amd64
       python: "3.8"
       dist: xenial
     - arch: amd64
       python: "nightly"
       dist: xenial
     - arch: amd64
       python: "3.9-dev"
     - os: osx
       language: generic
       python: 3.7
       env: TRAVIS_PYTHON_VERSION=3.7
   allow_failures:
     - python: nightly
 
 before_deploy:
   - rm -rf dist/
   - python setup.py sdist
   - python setup.py bdist_wheel
 
 deploy:
   provider: releases
   api_key:
     secure: Y/Ae9tYs5aoBU8bDjN2YrwGG6tCbezj/h3Lcmtx8HQavSbBgXnhnZVRb2snOKD7auqnqjfT/7QMm4ZyKvaOEgyggGktKqEKYHC8KOZ7yp8I5/UMDtk6j9TnXpSqqBxPiud4MDV76SfRYEQiaDoG4tGGvSfPJ9KcNjKrNvSyyxns=
   file: dist/*
   file_glob: true
   cleanup: false
   on:
     repo: ipython/ipython
     all_branches: true  # Backports are released from e.g. 5.x branch
     tags: true
     python: 3.6  # Any version should work, but we only need one
     condition: $TRAVIS_OS_NAME = "linux"

IPython/lib/latextools.py

@@ -1,222 +1,222 b''
 # -*- coding: utf-8 -*-
 """Tools for handling LaTeX."""
 
 # Copyright (c) IPython Development Team.
 # Distributed under the terms of the Modified BSD License.
 
 from io import BytesIO, open
 import os
 import tempfile
 import shutil
 import subprocess
 from base64 import encodebytes
 import textwrap
 
 from pathlib import Path, PurePath
 
 from IPython.utils.process import find_cmd, FindCmdError
 from traitlets.config import get_config
 from traitlets.config.configurable import SingletonConfigurable
 from traitlets import List, Bool, Unicode
 from IPython.utils.py3compat import cast_unicode
 
 
 class LaTeXTool(SingletonConfigurable):
     """An object to store configuration of the LaTeX tool."""
     def _config_default(self):
         return get_config()
 
     backends = List(
         Unicode(), ["matplotlib", "dvipng"],
         help="Preferred backend to draw LaTeX math equations. "
         "Backends in the list are checked one by one and the first "
         "usable one is used.  Note that `matplotlib` backend "
         "is usable only for inline style equations.  To draw  "
         "display style equations, `dvipng` backend must be specified. ",
         # It is a List instead of Enum, to make configuration more
         # flexible.  For example, to use matplotlib mainly but dvipng
         # for display style, the default ["matplotlib", "dvipng"] can
         # be used.  To NOT use dvipng so that other repr such as
         # unicode pretty printing is used, you can use ["matplotlib"].
         ).tag(config=True)
 
     use_breqn = Bool(
         True,
         help="Use breqn.sty to automatically break long equations. "
         "This configuration takes effect only for dvipng backend.",
         ).tag(config=True)
 
     packages = List(
         ['amsmath', 'amsthm', 'amssymb', 'bm'],
         help="A list of packages to use for dvipng backend. "
         "'breqn' will be automatically appended when use_breqn=True.",
         ).tag(config=True)
 
     preamble = Unicode(
         help="Additional preamble to use when generating LaTeX source "
         "for dvipng backend.",
         ).tag(config=True)
 
 
 def latex_to_png(s, encode=False, backend=None, wrap=False, color='Black',
                  scale=1.0):
     """Render a LaTeX string to PNG.
 
     Parameters
     ----------
     s : str
         The raw string containing valid inline LaTeX.
     encode : bool, optional
         Should the PNG data base64 encoded to make it JSON'able.
     backend : {matplotlib, dvipng}
         Backend for producing PNG data.
     wrap : bool
         If true, Automatically wrap `s` as a LaTeX equation.
     color : string
         Foreground color name among dvipsnames, e.g. 'Maroon' or on hex RGB
         format, e.g. '#AA20FA'.
     scale : float
         Scale factor for the resulting PNG.
 
     None is returned when the backend cannot be used.
 
     """
     s = cast_unicode(s)
     allowed_backends = LaTeXTool.instance().backends
     if backend is None:
         backend = allowed_backends[0]
     if backend not in allowed_backends:
         return None
     if backend == 'matplotlib':
         f = latex_to_png_mpl
     elif backend == 'dvipng':
         f = latex_to_png_dvipng
         if color.startswith('#'):
             # Convert hex RGB color to LaTeX RGB color.
             if len(color) == 7:
                 try:
                     color = "RGB {}".format(" ".join([str(int(x, 16)) for x in
                                                       textwrap.wrap(color[1:], 2)]))
                 except ValueError as e:
                     raise ValueError('Invalid color specification {}.'.format(color)) from e
             else:
                 raise ValueError('Invalid color specification {}.'.format(color))
     else:
         raise ValueError('No such backend {0}'.format(backend))
     bin_data = f(s, wrap, color, scale)
     if encode and bin_data:
         bin_data = encodebytes(bin_data)
     return bin_data
 
 
 def latex_to_png_mpl(s, wrap, color='Black', scale=1.0):
     try:
         from matplotlib import mathtext
         from pyparsing import ParseFatalException
     except ImportError:
         return None
 
     # mpl mathtext doesn't support display math, force inline
     s = s.replace('$$', '$')
     if wrap:
         s = u'${0}$'.format(s)
 
     try:
         mt = mathtext.MathTextParser('bitmap')
         f = BytesIO()
         dpi = 120*scale
         mt.to_png(f, s, fontsize=12, dpi=dpi, color=color)
         return f.getvalue()
     except (ValueError, RuntimeError, ParseFatalException):
         return None
 
 
 def latex_to_png_dvipng(s, wrap, color='Black', scale=1.0):
     try:
         find_cmd('latex')
         find_cmd('dvipng')
     except FindCmdError:
         return None
     try:
-        workdir = PurePath(tempfile.mkdtemp())
+        workdir = Path(tempfile.mkdtemp())
         tmpfile = workdir.joinpath("tmp.tex")
         dvifile = workdir.joinpath("tmp.dvi")
         outfile = workdir.joinpath("tmp.png")
 
         with tmpfile.open("w", encoding="utf8") as f:
             f.writelines(genelatex(s, wrap))
 
         with open(os.devnull, 'wb') as devnull:
             subprocess.check_call(
                 ["latex", "-halt-on-error", "-interaction", "batchmode", tmpfile],
                 cwd=workdir, stdout=devnull, stderr=devnull)
 
             resolution = round(150*scale)
             subprocess.check_call(
                 ["dvipng", "-T", "tight", "-D", str(resolution), "-z", "9",
                  "-bg", "transparent", "-o", outfile, dvifile, "-fg", color],
                  cwd=workdir, stdout=devnull, stderr=devnull)
 
         with outfile.open("rb") as f:
             return f.read()
     except subprocess.CalledProcessError:
         return None
     finally:
         shutil.rmtree(workdir)
 
 
 def kpsewhich(filename):
     """Invoke kpsewhich command with an argument `filename`."""
     try:
         find_cmd("kpsewhich")
         proc = subprocess.Popen(
             ["kpsewhich", filename],
             stdout=subprocess.PIPE, stderr=subprocess.PIPE)
         (stdout, stderr) = proc.communicate()
         return stdout.strip().decode('utf8', 'replace')
     except FindCmdError:
         pass
 
 
 def genelatex(body, wrap):
     """Generate LaTeX document for dvipng backend."""
     lt = LaTeXTool.instance()
     breqn = wrap and lt.use_breqn and kpsewhich("breqn.sty")
     yield r'\documentclass{article}'
     packages = lt.packages
     if breqn:
         packages = packages + ['breqn']
     for pack in packages:
         yield r'\usepackage{{{0}}}'.format(pack)
     yield r'\pagestyle{empty}'
     if lt.preamble:
         yield lt.preamble
     yield r'\begin{document}'
     if breqn:
         yield r'\begin{dmath*}'
         yield body
         yield r'\end{dmath*}'
     elif wrap:
         yield u'$${0}$$'.format(body)
     else:
         yield body
     yield u'\\end{document}'
 
 
 _data_uri_template_png = u"""<img src="data:image/png;base64,%s" alt=%s />"""
 
 def latex_to_html(s, alt='image'):
     """Render LaTeX to HTML with embedded PNG data using data URIs.
 
     Parameters
     ----------
     s : str
         The raw string containing valid inline LateX.
     alt : str
         The alt text to use for the HTML.
     """
     base64_data = latex_to_png(s, encode=True).decode('ascii')
     if base64_data:
         return _data_uri_template_png  % (base64_data, alt)
 
 

IPython/lib/tests/test_latextools.py

@@ -1,183 +1,191 b''
 """Tests for IPython.utils.path.py"""
 # Copyright (c) IPython Development Team.
 # Distributed under the terms of the Modified BSD License.
 
 from contextlib import contextmanager
 from unittest.mock import patch
 
 import nose.tools as nt
 import pytest
 
 from IPython.lib import latextools
-from IPython.testing.decorators import onlyif_cmds_exist, skipif_not_matplotlib
+from IPython.testing.decorators import (
+    onlyif_cmds_exist,
+    skipif_not_matplotlib,
+    skip_iptest_but_not_pytest,
+)
 from IPython.utils.process import FindCmdError
 
 
 @pytest.mark.parametrize('command', ['latex', 'dvipng'])
+@skip_iptest_but_not_pytest
 def test_check_latex_to_png_dvipng_fails_when_no_cmd(command):
     def mock_find_cmd(arg):
         if arg == command:
             raise FindCmdError
 
     with patch.object(latextools, "find_cmd", mock_find_cmd):
         assert latextools.latex_to_png_dvipng("whatever", True) == None
 
 
-@onlyif_cmds_exist('latex', 'dvipng')
-def test_latex_to_png_dvipng_runs():
+@contextmanager
+def no_op(*args, **kwargs):
+    yield
+
+
+@onlyif_cmds_exist("latex", "dvipng")
[e-mail]("s, wrap", [(u"$$x^2$$", False), (u"x^2", True)])
+@skip_iptest_but_not_pytest
+def test_latex_to_png_dvipng_runs(s, wrap):
     """
     Test that latex_to_png_dvipng just runs without error.
     """
     def mock_kpsewhich(filename):
         assert filename == "breqn.sty"
         return None
 
-    for (s, wrap) in [(u"$$x^2$$", False), (u"x^2", True)]:
-        yield (latextools.latex_to_png_dvipng, s, wrap)
+    latextools.latex_to_png_dvipng(s, wrap)
 
-        with patch.object(latextools, "kpsewhich", mock_kpsewhich):
-            yield (latextools.latex_to_png_dvipng, s, wrap)
+    with patch_latextool(mock_kpsewhich):
+        latextools.latex_to_png_dvipng(s, wrap)
 
 
-@contextmanager
-def no_op(*args, **kwargs):
-    yield
-
 def mock_kpsewhich(filename):
-        assert filename == "breqn.sty"
-        return None
+    assert filename == "breqn.sty"
+    return None
 
 @contextmanager
-def patch_latextool():
-    with patch.object(latextools, "kpsewhich", mock_kpsewhich):
+def patch_latextool(mock=mock_kpsewhich):
+    with patch.object(latextools, "kpsewhich", mock):
         yield
 
 @pytest.mark.parametrize('context', [no_op, patch_latextool])
 @pytest.mark.parametrize('s_wrap', [("$x^2$", False), ("x^2", True)])
+@skip_iptest_but_not_pytest
 def test_latex_to_png_mpl_runs(s_wrap, context):
     """
     Test that latex_to_png_mpl just runs without error.
     """
     try:
-        import matplotbli
+        import matplotlib
     except ImportError:
-        pytest.skip("This needs matplotlib to be availlable")
+        pytest.skip("This needs matplotlib to be available")
         return
     s, wrap = s_wrap
     with context():
         latextools.latex_to_png_mpl(s, wrap)
 
 @skipif_not_matplotlib
 def test_latex_to_html():
     img = latextools.latex_to_html("$x^2$")
     assert "data:image/png;base64,iVBOR" in img
 
 
 def test_genelatex_no_wrap():
     """
     Test genelatex with wrap=False.
     """
     def mock_kpsewhich(filename):
         assert False, ("kpsewhich should not be called "
                        "(called with {0})".format(filename))
 
-    with patch.object(latextools, "kpsewhich", mock_kpsewhich):
+    with patch_latextool(mock_kpsewhich):
         assert '\n'.join(latextools.genelatex("body text", False)) == r'''\documentclass{article}
 \usepackage{amsmath}
 \usepackage{amsthm}
 \usepackage{amssymb}
 \usepackage{bm}
 \pagestyle{empty}
 \begin{document}
 body text
 \end{document}'''
 
 
 def test_genelatex_wrap_with_breqn():
     """
     Test genelatex with wrap=True for the case breqn.sty is installed.
     """
     def mock_kpsewhich(filename):
         assert filename == "breqn.sty"
         return "path/to/breqn.sty"
 
-    with patch.object(latextools, "kpsewhich", mock_kpsewhich):
+    with patch_latextool(mock_kpsewhich):
         assert '\n'.join(latextools.genelatex("x^2", True)) == r'''\documentclass{article}
 \usepackage{amsmath}
 \usepackage{amsthm}
 \usepackage{amssymb}
 \usepackage{bm}
 \usepackage{breqn}
 \pagestyle{empty}
 \begin{document}
 \begin{dmath*}
 x^2
 \end{dmath*}
 \end{document}'''
 
 
 def test_genelatex_wrap_without_breqn():
     """
     Test genelatex with wrap=True for the case breqn.sty is not installed.
     """
     def mock_kpsewhich(filename):
         assert filename == "breqn.sty"
         return None
 
-    with patch.object(latextools, "kpsewhich", mock_kpsewhich):
+    with patch_latextool(mock_kpsewhich):
         assert '\n'.join(latextools.genelatex("x^2", True)) == r'''\documentclass{article}
 \usepackage{amsmath}
 \usepackage{amsthm}
 \usepackage{amssymb}
 \usepackage{bm}
 \pagestyle{empty}
 \begin{document}
 $$x^2$$
 \end{document}'''
 
 
 @skipif_not_matplotlib
 @onlyif_cmds_exist('latex', 'dvipng')
 def test_latex_to_png_color():
     """
     Test color settings for latex_to_png.
     """
     latex_string = "$x^2$"
     default_value = latextools.latex_to_png(latex_string, wrap=False)
     default_hexblack = latextools.latex_to_png(latex_string, wrap=False,
                                                color='#000000')
     dvipng_default = latextools.latex_to_png_dvipng(latex_string, False)
     dvipng_black = latextools.latex_to_png_dvipng(latex_string, False, 'Black')
     assert dvipng_default == dvipng_black
     mpl_default = latextools.latex_to_png_mpl(latex_string, False)
     mpl_black = latextools.latex_to_png_mpl(latex_string, False, 'Black')
     assert mpl_default == mpl_black
     assert default_value in [dvipng_black, mpl_black]
     assert default_hexblack in [dvipng_black, mpl_black]
 
     # Test that dvips name colors can be used without error
     dvipng_maroon = latextools.latex_to_png_dvipng(latex_string, False,
                                                    'Maroon')
     # And that it doesn't return the black one
     assert dvipng_black != dvipng_maroon
 
     mpl_maroon = latextools.latex_to_png_mpl(latex_string, False, 'Maroon')
     assert mpl_black != mpl_maroon
     mpl_white = latextools.latex_to_png_mpl(latex_string, False, 'White')
     mpl_hexwhite = latextools.latex_to_png_mpl(latex_string, False, '#FFFFFF')
     assert mpl_white == mpl_hexwhite
 
     mpl_white_scale = latextools.latex_to_png_mpl(latex_string, False,
                                                   'White', 1.2)
     assert mpl_white != mpl_white_scale
 
 
 def test_latex_to_png_invalid_hex_colors():
     """
     Test that invalid hex colors provided to dvipng gives an exception.
     """
     latex_string = "$x^2$"
     nt.assert_raises(ValueError, lambda: latextools.latex_to_png(latex_string,
                                         backend='dvipng', color="#f00bar"))
     nt.assert_raises(ValueError, lambda: latextools.latex_to_png(latex_string,
                                         backend='dvipng', color="#f00"))

IPython/lib/tests/test_pretty.py

@@ -1,472 +1,492 b''
 # coding: utf-8
 """Tests for IPython.lib.pretty."""
 
 # Copyright (c) IPython Development Team.
 # Distributed under the terms of the Modified BSD License.
 
 
 from collections import Counter, defaultdict, deque, OrderedDict
 import os
 import types
 import string
 import unittest
 
 import nose.tools as nt
+import pytest
 
 from IPython.lib import pretty
-from IPython.testing.decorators import skip_without
+from IPython.testing.decorators import skip_without, skip_iptest_but_not_pytest
 
 from io import StringIO
 
 
 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)
 
 
 class MyDict(dict):
     def _repr_pretty_(self, p, cycle):
         p.text("MyDict(...)")
 
 class MyObj(object):
     def somemethod(self):
         pass
 
 
 class Dummy1(object):
     def _repr_pretty_(self, p, cycle):
         p.text("Dummy1(...)")
 
 class Dummy2(Dummy1):
     _repr_pretty_ = None
 
 class NoModule(object):
     pass
 
 NoModule.__module__ = None
 
 class Breaking(object):
     def _repr_pretty_(self, p, cycle):
         with p.group(4,"TG: ",":"):
             p.text("Breaking(")
             p.break_()
             p.text(")")
 
 class BreakingRepr(object):
     def __repr__(self):
         return "Breaking(\n)"
 
 class BadRepr(object):
     
     def __repr__(self):
         return 1/0
 
 
 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)) + ")"
 
     nt.assert_equal(gotoutput, expectedoutput)
 
 
 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(...)"
 
     nt.assert_equal(gotoutput, expectedoutput)
 
 
 def test_callability_checking():
     """
     Test that the _repr_pretty_ method is tested for callability and skipped if
     not.
     """
     gotoutput = pretty.pretty(Dummy2())
     expectedoutput = "Dummy1(...)"
 
     nt.assert_equal(gotoutput, expectedoutput)
 
 
-def test_sets():
[e-mail](
+    "obj,expected_output",
+    zip(
+        [
+            set(),
+            frozenset(),
+            set([1]),
+            frozenset([1]),
+            set([1, 2]),
+            frozenset([1, 2]),
+            set([-1, -2, -3]),
+        ],
+        [
+            "set()",
+            "frozenset()",
+            "{1}",
+            "frozenset({1})",
+            "{1, 2}",
+            "frozenset({1, 2})",
+            "{-3, -2, -1}",
+        ],
+    ),
+)
+@skip_iptest_but_not_pytest
+def test_sets(obj, expected_output):
     """
     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 nt.assert_equal, got_output, expected_output
+    got_output = pretty.pretty(obj)
+    nt.assert_equal(got_output, expected_output)
 
 
 @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')
 
 def test_pprint_nomod():
     """
     Test that pprint works for classes with no __module__.
     """
     output = pretty.pretty(NoModule)
     nt.assert_equal(output, 'NoModule')
     
 def test_pprint_break():
     """
     Test that p.break_ produces expected output
     """
     output = pretty.pretty(Breaking())
     expected = "TG: Breaking(\n    ):"
     nt.assert_equal(output, expected)
 
 def test_pprint_break_repr():
     """
     Test that p.break_ is used in repr
     """
     output = pretty.pretty([[BreakingRepr()]])
     expected = "[[Breaking(\n  )]]"
     nt.assert_equal(output, expected)
 
     output = pretty.pretty([[BreakingRepr()]*2])
     expected = "[[Breaking(\n  ),\n  Breaking(\n  )]]"
     nt.assert_equal(output, expected)
 
 def test_bad_repr():
     """Don't catch bad repr errors"""
     with nt.assert_raises(ZeroDivisionError):
         pretty.pretty(BadRepr())
 
 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():
     with nt.assert_raises(BadException):
         pretty.pretty(ReallyBadRepr())
 
 
 class SA(object):
     pass
 
 class SB(SA):
     pass
 
 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)
 
 
 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]")
 
 
 def test_unicode_repr():
     u = u"üniçodé"
     ustr = u
     
     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)
 
 
 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)
 
 
 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():
     class MyCounter(Counter):
         pass
     cases = [
         (Counter(), 'Counter()'),
         (Counter(a=1), "Counter({'a': 1})"),
         (MyCounter(a=1), "MyCounter({'a': 1})"),
     ]
     for obj, expected in cases:
         nt.assert_equal(pretty.pretty(obj), expected)
 
 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)
 
 
 def test_simplenamespace():
     SN = types.SimpleNamespace
 
     sn_recursive = SN()
     sn_recursive.first = sn_recursive
     sn_recursive.second = sn_recursive
     cases = [
         (SN(), "namespace()"),
         (SN(x=SN()), "namespace(x=namespace())"),
         (SN(a_long_name=[SN(s=string.ascii_lowercase)]*3, a_short_name=None),
          "namespace(a_long_name=[namespace(s='abcdefghijklmnopqrstuvwxyz'),\n"
          "                       namespace(s='abcdefghijklmnopqrstuvwxyz'),\n"
          "                       namespace(s='abcdefghijklmnopqrstuvwxyz')],\n"
          "          a_short_name=None)"),
         (sn_recursive, "namespace(first=namespace(...), second=namespace(...))"),
     ]
     for obj, expected in cases:
         nt.assert_equal(pretty.pretty(obj), expected)
 
 
 def test_pretty_environ():
     dict_repr = pretty.pretty(dict(os.environ))
     # reindent to align with 'environ' prefix
     dict_indented = dict_repr.replace('\n', '\n' + (' ' * len('environ')))
     env_repr = pretty.pretty(os.environ)
     nt.assert_equal(env_repr, 'environ' + dict_indented)
 
 
 def test_function_pretty():
     "Test pretty print of function"
     # posixpath is a pure python module, its interface is consistent
     # across Python distributions
     import posixpath
     nt.assert_equal(pretty.pretty(posixpath.join), '<function posixpath.join(a, *p)>')
  
     # custom function
     def meaning_of_life(question=None):
         if question:
             return 42
         return "Don't panic"
 
     nt.assert_in('meaning_of_life(question=None)', pretty.pretty(meaning_of_life))
 
 
 class OrderedCounter(Counter, OrderedDict):
     'Counter that remembers the order elements are first encountered'
 
     def __repr__(self):
         return '%s(%r)' % (self.__class__.__name__, OrderedDict(self))
 
     def __reduce__(self):
         return self.__class__, (OrderedDict(self),)
 
 class MySet(set):  # Override repr of a basic type
     def __repr__(self):
         return 'mine'
 
 def test_custom_repr():
     """A custom repr should override a pretty printer for a parent type"""
     oc = OrderedCounter("abracadabra")
     nt.assert_in("OrderedCounter(OrderedDict", pretty.pretty(oc))
 
     nt.assert_equal(pretty.pretty(MySet()), 'mine')

IPython/testing/decorators.py

@@ -1,383 +1,394 b''
 # -*- coding: utf-8 -*-
 """Decorators for labeling test objects.
 
 Decorators that merely return a modified version of the original function
 object are straightforward.  Decorators that return a new function object need
 to use nose.tools.make_decorator(original_function)(decorator) in returning the
 decorator, in order to preserve metadata such as function name, setup and
 teardown functions and so on - see nose.tools for more information.
 
 This module provides a set of useful decorators meant to be ready to use in
 your own tests.  See the bottom of the file for the ready-made ones, and if you
 find yourself writing a new one that may be of generic use, add it here.
 
 Included decorators:
 
 
 Lightweight testing that remains unittest-compatible.
 
 - An @as_unittest decorator can be used to tag any normal parameter-less
   function as a unittest TestCase.  Then, both nose and normal unittest will
   recognize it as such.  This will make it easier to migrate away from Nose if
   we ever need/want to while maintaining very lightweight tests.
 
 NOTE: This file contains IPython-specific decorators. Using the machinery in
 IPython.external.decorators, we import either numpy.testing.decorators if numpy is
 available, OR use equivalent code in IPython.external._decorators, which
 we've copied verbatim from numpy.
 
 """
 
 # Copyright (c) IPython Development Team.
 # Distributed under the terms of the Modified BSD License.
 
 import os
 import shutil
 import sys
 import tempfile
 import unittest
 import warnings
 from importlib import import_module
 
 from decorator import decorator
 
 # Expose the unittest-driven decorators
 from .ipunittest import ipdoctest, ipdocstring
 
 # Grab the numpy-specific decorators which we keep in a file that we
 # occasionally update from upstream: decorators.py is a copy of
 # numpy.testing.decorators, we expose all of it here.
 from IPython.external.decorators import knownfailureif
 
 #-----------------------------------------------------------------------------
 # Classes and functions
 #-----------------------------------------------------------------------------
 
 # Simple example of the basic idea
 def as_unittest(func):
     """Decorator to make a simple function into a normal test via unittest."""
     class Tester(unittest.TestCase):
         def test(self):
             func()
 
     Tester.__name__ = func.__name__
 
     return Tester
 
 # Utility functions
 
 def apply_wrapper(wrapper, func):
     """Apply a wrapper to a function for decoration.
 
     This mixes Michele Simionato's decorator tool with nose's make_decorator,
     to apply a wrapper in a decorator so that all nose attributes, as well as
     function signature and other properties, survive the decoration cleanly.
     This will ensure that wrapped functions can still be well introspected via
     IPython, for example.
     """
     warnings.warn("The function `apply_wrapper` is deprecated since IPython 4.0",
             DeprecationWarning, stacklevel=2)
     import nose.tools
 
     return decorator(wrapper,nose.tools.make_decorator(func)(wrapper))
 
 
 def make_label_dec(label, ds=None):
     """Factory function to create a decorator that applies one or more labels.
 
     Parameters
     ----------
       label : string or sequence
       One or more labels that will be applied by the decorator to the functions
     it decorates.  Labels are attributes of the decorated function with their
     value set to True.
 
       ds : string
       An optional docstring for the resulting decorator.  If not given, a
       default docstring is auto-generated.
 
     Returns
     -------
       A decorator.
 
     Examples
     --------
 
     A simple labeling decorator:
 
     >>> slow = make_label_dec('slow')
     >>> slow.__doc__
     "Labels a test as 'slow'."
 
     And one that uses multiple labels and a custom docstring:
 
     >>> rare = make_label_dec(['slow','hard'],
     ... "Mix labels 'slow' and 'hard' for rare tests.")
     >>> rare.__doc__
     "Mix labels 'slow' and 'hard' for rare tests."
 
     Now, let's test using this one:
     >>> @rare
     ... def f(): pass
     ...
     >>>
     >>> f.slow
     True
     >>> f.hard
     True
     """
 
     warnings.warn("The function `make_label_dec` is deprecated since IPython 4.0",
             DeprecationWarning, stacklevel=2)
     if isinstance(label, str):
         labels = [label]
     else:
         labels = label
 
     # Validate that the given label(s) are OK for use in setattr() by doing a
     # dry run on a dummy function.
     tmp = lambda : None
     for label in labels:
         setattr(tmp,label,True)
 
     # This is the actual decorator we'll return
     def decor(f):
         for label in labels:
             setattr(f,label,True)
         return f
 
     # Apply the user's docstring, or autogenerate a basic one
     if ds is None:
         ds = "Labels a test as %r." % label
     decor.__doc__ = ds
 
     return decor
 
 
+def skip_iptest_but_not_pytest(f):
+    """
+    Warnign this will make the test invisible to iptest.
+    """
+    import os
+
+    if os.environ.get("IPTEST_WORKING_DIR", None) is not None:
+        f.__test__ = False
+    return f
+
+
 # Inspired by numpy's skipif, but uses the full apply_wrapper utility to
 # preserve function metadata better and allows the skip condition to be a
 # callable.
 def skipif(skip_condition, msg=None):
     ''' Make function raise SkipTest exception if skip_condition is true
 
     Parameters
     ----------
 
     skip_condition : bool or callable
       Flag to determine whether to skip test. If the condition is a
       callable, it is used at runtime to dynamically make the decision. This
       is useful for tests that may require costly imports, to delay the cost
       until the test suite is actually executed.
     msg : string
       Message to give on raising a SkipTest exception.
 
     Returns
     -------
     decorator : function
       Decorator, which, when applied to a function, causes SkipTest
       to be raised when the skip_condition was True, and the function
       to be called normally otherwise.
 
     Notes
     -----
     You will see from the code that we had to further decorate the
     decorator with the nose.tools.make_decorator function in order to
     transmit function name, and various other metadata.
     '''
 
     def skip_decorator(f):
         # Local import to avoid a hard nose dependency and only incur the
         # import time overhead at actual test-time.
         import nose
 
         # Allow for both boolean or callable skip conditions.
         if callable(skip_condition):
             skip_val = skip_condition
         else:
             skip_val = lambda : skip_condition
 
         def get_msg(func,msg=None):
             """Skip message with information about function being skipped."""
             if msg is None: out = 'Test skipped due to test condition.'
             else: out = msg
             return "Skipping test: %s. %s" % (func.__name__,out)
 
         # We need to define *two* skippers because Python doesn't allow both
         # return with value and yield inside the same function.
         def skipper_func(*args, **kwargs):
             """Skipper for normal test functions."""
             if skip_val():
                 raise nose.SkipTest(get_msg(f,msg))
             else:
                 return f(*args, **kwargs)
 
         def skipper_gen(*args, **kwargs):
             """Skipper for test generators."""
             if skip_val():
                 raise nose.SkipTest(get_msg(f,msg))
             else:
                 for x in f(*args, **kwargs):
                     yield x
 
         # Choose the right skipper to use when building the actual generator.
         if nose.util.isgenerator(f):
             skipper = skipper_gen
         else:
             skipper = skipper_func
 
         return nose.tools.make_decorator(f)(skipper)
 
     return skip_decorator
 
 # A version with the condition set to true, common case just to attach a message
 # to a skip decorator
 def skip(msg=None):
     """Decorator factory - mark a test function for skipping from test suite.
 
     Parameters
     ----------
       msg : string
         Optional message to be added.
 
     Returns
     -------
        decorator : function
          Decorator, which, when applied to a function, causes SkipTest
          to be raised, with the optional message added.
       """
     if msg and not isinstance(msg, str):
         raise ValueError('invalid object passed to `@skip` decorator, did you '
                          'meant `@skip()` with brackets ?')
     return skipif(True, msg)
 
 
 def onlyif(condition, msg):
     """The reverse from skipif, see skipif for details."""
 
     if callable(condition):
         skip_condition = lambda : not condition()
     else:
         skip_condition = lambda : not condition
 
     return skipif(skip_condition, msg)
 
 #-----------------------------------------------------------------------------
 # Utility functions for decorators
 def module_not_available(module):
     """Can module be imported?  Returns true if module does NOT import.
 
     This is used to make a decorator to skip tests that require module to be
     available, but delay the 'import numpy' to test execution time.
     """
     try:
         mod = import_module(module)
         mod_not_avail = False
     except ImportError:
         mod_not_avail = True
 
     return mod_not_avail
 
 
 def decorated_dummy(dec, name):
     """Return a dummy function decorated with dec, with the given name.
 
     Examples
     --------
     import IPython.testing.decorators as dec
     setup = dec.decorated_dummy(dec.skip_if_no_x11, __name__)
     """
     warnings.warn("The function `decorated_dummy` is deprecated since IPython 4.0",
         DeprecationWarning, stacklevel=2)
     dummy = lambda: None
     dummy.__name__ = name
     return dec(dummy)
 
 #-----------------------------------------------------------------------------
 # Decorators for public use
 
 # Decorators to skip certain tests on specific platforms.
 skip_win32 = skipif(sys.platform == 'win32',
                     "This test does not run under Windows")
 skip_linux = skipif(sys.platform.startswith('linux'),
                     "This test does not run under Linux")
 skip_osx = skipif(sys.platform == 'darwin',"This test does not run under OS X")
 
 
 # Decorators to skip tests if not on specific platforms.
 skip_if_not_win32 = skipif(sys.platform != 'win32',
                            "This test only runs under Windows")
 skip_if_not_linux = skipif(not sys.platform.startswith('linux'),
                            "This test only runs under Linux")
 skip_if_not_osx = skipif(sys.platform != 'darwin',
                          "This test only runs under OSX")
 
 
 _x11_skip_cond = (sys.platform not in ('darwin', 'win32') and
                   os.environ.get('DISPLAY', '') == '')
 _x11_skip_msg = "Skipped under *nix when X11/XOrg not available"
 
 skip_if_no_x11 = skipif(_x11_skip_cond, _x11_skip_msg)
 
 
 # Decorators to skip certain tests on specific platform/python combinations
 skip_win32_py38 = skipif(sys.version_info > (3,8) and os.name == 'nt')
 
 
 # not a decorator itself, returns a dummy function to be used as setup
 def skip_file_no_x11(name):
     warnings.warn("The function `skip_file_no_x11` is deprecated since IPython 4.0",
             DeprecationWarning, stacklevel=2)
     return decorated_dummy(skip_if_no_x11, name) if _x11_skip_cond else None
 
 # Other skip decorators
 
 # generic skip without module
 skip_without = lambda mod: skipif(module_not_available(mod), "This test requires %s" % mod)
 
 skipif_not_numpy = skip_without('numpy')
 
 skipif_not_matplotlib = skip_without('matplotlib')
 
 skipif_not_sympy = skip_without('sympy')
 
 skip_known_failure = knownfailureif(True,'This test is known to fail')
 
 # A null 'decorator', useful to make more readable code that needs to pick
 # between different decorators based on OS or other conditions
 null_deco = lambda f: f
 
 # Some tests only run where we can use unicode paths. Note that we can't just
 # check os.path.supports_unicode_filenames, which is always False on Linux.
 try:
     f = tempfile.NamedTemporaryFile(prefix=u"tmp€")
 except UnicodeEncodeError:
     unicode_paths = False
 else:
     unicode_paths = True
     f.close()
 
 onlyif_unicode_paths = onlyif(unicode_paths, ("This test is only applicable "
                                     "where we can use unicode in filenames."))
 
 
 def onlyif_cmds_exist(*commands):
     """
     Decorator to skip test when at least one of `commands` is not found.
     """
     for cmd in commands:
         if not shutil.which(cmd):
             return skip("This test runs only if command '{0}' "
                         "is installed".format(cmd))
     return null_deco
 
 def onlyif_any_cmd_exists(*commands):
     """
     Decorator to skip test unless at least one of `commands` is found.
     """
     warnings.warn("The function `onlyif_any_cmd_exists` is deprecated since IPython 4.0",
             DeprecationWarning, stacklevel=2)
     for cmd in commands:
         if shutil.which(cmd):
             return null_deco
     return skip("This test runs only if one of the commands {0} "
                 "is installed".format(commands))

IPython/utils/tests/test_capture.py

@@ -1,159 +1,172 b''
 # encoding: utf-8
 """Tests for IPython.utils.capture"""
 
 #-----------------------------------------------------------------------------
 #  Copyright (C) 2013 The IPython Development Team
 #
 #  Distributed under the terms of the BSD License.  The full license is in
 #  the file COPYING, distributed as part of this software.
 #-----------------------------------------------------------------------------
 
 #-----------------------------------------------------------------------------
 # Imports
 #-----------------------------------------------------------------------------
 
 
 import sys
 
 import nose.tools as nt
+import pytest
+
+from IPython.testing.decorators import skip_iptest_but_not_pytest
 
 from IPython.utils import capture
 
 #-----------------------------------------------------------------------------
 # Globals
 #-----------------------------------------------------------------------------
 
 _mime_map = dict(
     _repr_png_="image/png",
     _repr_jpeg_="image/jpeg",
     _repr_svg_="image/svg+xml",
     _repr_html_="text/html",
     _repr_json_="application/json",
     _repr_javascript_="application/javascript",
 )
 
 basic_data = {
     'image/png' : b'binarydata',
     'text/html' : "<b>bold</b>",
 }
 basic_metadata = {
     'image/png' : {
         'width' : 10,
         'height' : 20,
     },
 }
 
 full_data = {
     'image/png' : b'binarydata',
     'image/jpeg' : b'binarydata',
     'image/svg+xml' : "<svg>",
     'text/html' : "<b>bold</b>",
     'application/javascript' : "alert();",
     'application/json' : "{}",
 }
 full_metadata = {
     'image/png' : {"png" : "exists"},
     'image/jpeg' : {"jpeg" : "exists"},
     'image/svg+xml' : {"svg" : "exists"},
     'text/html' : {"html" : "exists"},
     'application/javascript' : {"js" : "exists"},
     'application/json' : {"json" : "exists"},
 }
 
 hello_stdout = "hello, stdout"
 hello_stderr = "hello, stderr"
 
 #-----------------------------------------------------------------------------
 # Test Functions
 #-----------------------------------------------------------------------------
-
-def test_rich_output_empty():
[e-mail]("method_mime", _mime_map.items())
+@skip_iptest_but_not_pytest
+def test_rich_output_empty(method_mime):
     """RichOutput with no args"""
     rich = capture.RichOutput()
-    for method, mime in _mime_map.items():
-        yield nt.assert_equal, getattr(rich, method)(), None
+    method, mime = method_mime
+    nt.assert_equal(getattr(rich, method)(), None)
     
 def test_rich_output():
     """test RichOutput basics"""
     data = basic_data
     metadata = basic_metadata
     rich = capture.RichOutput(data=data, metadata=metadata)
-    yield nt.assert_equal, rich._repr_html_(), data['text/html']
-    yield nt.assert_equal, rich._repr_png_(), (data['image/png'], metadata['image/png'])
-    yield nt.assert_equal, rich._repr_latex_(), None
-    yield nt.assert_equal, rich._repr_javascript_(), None
-    yield nt.assert_equal, rich._repr_svg_(), None
+    nt.assert_equal(rich._repr_html_(), data["text/html"])
+    nt.assert_equal(rich._repr_png_(), (data["image/png"], metadata["image/png"]))
+    nt.assert_equal(rich._repr_latex_(), None)
+    nt.assert_equal(rich._repr_javascript_(), None)
+    nt.assert_equal(rich._repr_svg_(), None)
 
-def test_rich_output_no_metadata():
+
+@skip_iptest_but_not_pytest
[e-mail]("method_mime", _mime_map.items())
+def test_rich_output_no_metadata(method_mime):
     """test RichOutput with no metadata"""
     data = full_data
     rich = capture.RichOutput(data=data)
-    for method, mime in _mime_map.items():
-        yield nt.assert_equal, getattr(rich, method)(), data[mime]
+    method, mime = method_mime
+    nt.assert_equal(getattr(rich, method)(), data[mime])
+
 
-def test_rich_output_metadata():
+@skip_iptest_but_not_pytest
[e-mail]("method_mime", _mime_map.items())
+def test_rich_output_metadata(method_mime):
     """test RichOutput with metadata"""
     data = full_data
     metadata = full_metadata
     rich = capture.RichOutput(data=data, metadata=metadata)
-    for method, mime in _mime_map.items():
-        yield nt.assert_equal, getattr(rich, method)(), (data[mime], metadata[mime])
+    method, mime = method_mime
+    nt.assert_equal(getattr(rich, method)(), (data[mime], metadata[mime]))
 
 def test_rich_output_display():
     """test RichOutput.display
     
     This is a bit circular, because we are actually using the capture code we are testing
     to test itself.
     """
     data = full_data
     rich = capture.RichOutput(data=data)
     with capture.capture_output() as cap:
         rich.display()
-    yield nt.assert_equal, len(cap.outputs), 1
+    nt.assert_equal(len(cap.outputs), 1)
     rich2 = cap.outputs[0]
-    yield nt.assert_equal, rich2.data, rich.data
-    yield nt.assert_equal, rich2.metadata, rich.metadata
+    nt.assert_equal(rich2.data, rich.data)
+    nt.assert_equal(rich2.metadata, rich.metadata)
 
 def test_capture_output():
     """capture_output works"""
     rich = capture.RichOutput(data=full_data)
     with capture.capture_output() as cap:
         print(hello_stdout, end="")
         print(hello_stderr, end="", file=sys.stderr)
         rich.display()
-    yield nt.assert_equal, hello_stdout, cap.stdout
-    yield nt.assert_equal, hello_stderr, cap.stderr
+    nt.assert_equal(hello_stdout, cap.stdout)
+    nt.assert_equal(hello_stderr, cap.stderr)
+
 
 def test_capture_output_no_stdout():
     """test capture_output(stdout=False)"""
     rich = capture.RichOutput(data=full_data)
     with capture.capture_output(stdout=False) as cap:
         print(hello_stdout, end="")
         print(hello_stderr, end="", file=sys.stderr)
         rich.display()
-    yield nt.assert_equal, "", cap.stdout
-    yield nt.assert_equal, hello_stderr, cap.stderr
-    yield nt.assert_equal, len(cap.outputs), 1
+    nt.assert_equal("", cap.stdout)
+    nt.assert_equal(hello_stderr, cap.stderr)
+    nt.assert_equal(len(cap.outputs), 1)
+
 
 def test_capture_output_no_stderr():
     """test capture_output(stderr=False)"""
     rich = capture.RichOutput(data=full_data)
     # add nested capture_output so stderr doesn't make it to nose output
     with capture.capture_output(), capture.capture_output(stderr=False) as cap:
         print(hello_stdout, end="")
         print(hello_stderr, end="", file=sys.stderr)
         rich.display()
-    yield nt.assert_equal, hello_stdout, cap.stdout
-    yield nt.assert_equal, "", cap.stderr
-    yield nt.assert_equal, len(cap.outputs), 1
+    nt.assert_equal(hello_stdout, cap.stdout)
+    nt.assert_equal("", cap.stderr)
+    nt.assert_equal(len(cap.outputs), 1)
+
 
 def test_capture_output_no_display():
     """test capture_output(display=False)"""
     rich = capture.RichOutput(data=full_data)
     with capture.capture_output(display=False) as cap:
         print(hello_stdout, end="")
         print(hello_stderr, end="", file=sys.stderr)
         rich.display()
-    yield nt.assert_equal, hello_stdout, cap.stdout
-    yield nt.assert_equal, hello_stderr, cap.stderr
-    yield nt.assert_equal, cap.outputs, []
  No newline at end of file
+    nt.assert_equal(hello_stdout, cap.stdout)
+    nt.assert_equal(hello_stderr, cap.stderr)
+    nt.assert_equal(cap.outputs, [])

IPython/utils/tests/test_pycolorize.py

@@ -1,78 +1,76 b''
 # coding: utf-8
 """Test suite for our color utilities.
 
 Authors
 -------
 
 * Min RK
 """
 #-----------------------------------------------------------------------------
 #  Copyright (C) 2011  The IPython Development Team
 #
 #  Distributed under the terms of the BSD License.  The full license is in
 #  the file COPYING.txt, distributed as part of this software.
 #-----------------------------------------------------------------------------
 
 #-----------------------------------------------------------------------------
 # Imports
 #-----------------------------------------------------------------------------
 
 # third party
 import nose.tools as nt
 
+from IPython.testing.decorators import skip_iptest_but_not_pytest
+
 # our own
 from IPython.utils.PyColorize import Parser
 import io
+import pytest
+
+
[e-mail](scope="module", params=("Linux", "NoColor", "LightBG", "Neutral"))
+def style(request):
+    yield request.param
 
 #-----------------------------------------------------------------------------
 # Test functions
 #-----------------------------------------------------------------------------
 
-sample = u"""
+sample = """
 def function(arg, *args, kwarg=True, **kwargs):
     '''
     this is docs
     '''
     pass is True
     False == None
 
     with io.open(ru'unicode'):
         raise ValueError("\n escape \r sequence")
 
     print("wěird ünicoðe")
 
 class Bar(Super):
 
     def __init__(self):
         super(Bar, self).__init__(1**2, 3^4, 5 or 6)
 """
 
-def test_loop_colors():
-
-    for style in ('Linux', 'NoColor','LightBG', 'Neutral'):
-
-        def test_unicode_colorize():
-            p = Parser(style=style)
-            f1 = p.format('1/0', 'str')
-            f2 = p.format(u'1/0', 'str')
-            nt.assert_equal(f1, f2)
 
-        def test_parse_sample():
-            """and test writing to a buffer"""
-            buf = io.StringIO()
-            p = Parser(style=style)
-            p.format(sample, buf)
-            buf.seek(0)
-            f1 = buf.read()
+@skip_iptest_but_not_pytest
+def test_parse_sample(style):
+    """and test writing to a buffer"""
+    buf = io.StringIO()
+    p = Parser(style=style)
+    p.format(sample, buf)
+    buf.seek(0)
+    f1 = buf.read()
 
-            nt.assert_not_in('ERROR', f1)
+    nt.assert_not_in("ERROR", f1)
 
-        def test_parse_error():
-            p = Parser(style=style)
-            f1 = p.format(')', 'str')
-            if style != 'NoColor':
-                nt.assert_in('ERROR', f1)
 
-        yield test_unicode_colorize
-        yield test_parse_sample
-        yield test_parse_error
+@skip_iptest_but_not_pytest
+def test_parse_error(style):
+    p = Parser(style=style)
+    f1 = p.format(")", "str")
+    if style != "NoColor":
+        nt.assert_in("ERROR", f1)

IPython/utils/tests/test_tokenutil.py

@@ -1,133 +1,141 b''
 """Tests for tokenutil"""
 # Copyright (c) IPython Development Team.
 # Distributed under the terms of the Modified BSD License.
 
 import nose.tools as nt
+import pytest
+from IPython.testing.decorators import skip_iptest_but_not_pytest
 
 from IPython.utils.tokenutil import token_at_cursor, line_at_cursor
 
 def expect_token(expected, cell, cursor_pos):
     token = token_at_cursor(cell, cursor_pos)
     offset = 0
     for line in cell.splitlines():
         if offset + len(line) >= cursor_pos:
             break
         else:
             offset += len(line)+1
     column = cursor_pos - offset
     line_with_cursor = '%s|%s' % (line[:column], line[column:])
     nt.assert_equal(token, expected,
         "Expected %r, got %r in: %r (pos %i)" % (
         expected, token, line_with_cursor, cursor_pos)
     )
 
 def test_simple(): 
     cell = "foo"
     for i in range(len(cell)):
         expect_token("foo", cell, i)
 
 def test_function():
     cell = "foo(a=5, b='10')"
     expected = 'foo'
     # up to `foo(|a=`
     for i in range(cell.find('a=') + 1):
         expect_token("foo", cell, i)
     # find foo after `=`
     for i in [cell.find('=') + 1, cell.rfind('=') + 1]:
         expect_token("foo", cell, i)
     # in between `5,|` and `|b=`
     for i in range(cell.find(','), cell.find('b=')):
         expect_token("foo", cell, i)
 
 def test_multiline():
     cell = '\n'.join([
         'a = 5',
         'b = hello("string", there)'
     ])
     expected = 'hello'
     start = cell.index(expected) + 1
     for i in range(start, start + len(expected)):
         expect_token(expected, cell, i)
     expected = 'hello'
     start = cell.index(expected) + 1
     for i in range(start, start + len(expected)):
         expect_token(expected, cell, i)
 
 def test_multiline_token():
     cell = '\n'.join([
         '"""\n\nxxxxxxxxxx\n\n"""',
         '5, """',
         'docstring',
         'multiline token',
         '""", [',
         '2, 3, "complicated"]',
         'b = hello("string", there)'
     ])
     expected = 'hello'
     start = cell.index(expected) + 1
     for i in range(start, start + len(expected)):
         expect_token(expected, cell, i)
     expected = 'hello'
     start = cell.index(expected) + 1
     for i in range(start, start + len(expected)):
         expect_token(expected, cell, i)
 
 def test_nested_call():
     cell = "foo(bar(a=5), b=10)"
     expected = 'foo'
     start = cell.index('bar') + 1
     for i in range(start, start + 3):
         expect_token(expected, cell, i)
     expected = 'bar'
     start = cell.index('a=')
     for i in range(start, start + 3):
         expect_token(expected, cell, i)
     expected = 'foo'
     start = cell.index(')') + 1
     for i in range(start, len(cell)-1):
         expect_token(expected, cell, i)
 
 def test_attrs():
     cell = "a = obj.attr.subattr"
     expected = 'obj'
     idx = cell.find('obj') + 1
     for i in range(idx, idx + 3):
         expect_token(expected, cell, i)
     idx = cell.find('.attr') + 2
     expected = 'obj.attr'
     for i in range(idx, idx + 4):
         expect_token(expected, cell, i)
     idx = cell.find('.subattr') + 2
     expected = 'obj.attr.subattr'
     for i in range(idx, len(cell)):
         expect_token(expected, cell, i)
 
 def test_line_at_cursor():
     cell = ""
     (line, offset) = line_at_cursor(cell, cursor_pos=11)
     nt.assert_equal(line, "")
     nt.assert_equal(offset, 0)
 
     # The position after a newline should be the start of the following line.
     cell = "One\nTwo\n"
     (line, offset) = line_at_cursor(cell, cursor_pos=4)
     nt.assert_equal(line, "Two\n")
     nt.assert_equal(offset, 4)
 
     # The end of a cell should be on the last line
     cell = "pri\npri"
     (line, offset) = line_at_cursor(cell, cursor_pos=7)
     nt.assert_equal(line, "pri")
     nt.assert_equal(offset, 4)
 
-def test_multiline_statement():
+
[e-mail](
+    "c, token",
+    zip(
+        list(range(16, 22)) + list(range(22, 28)),
+        ["int"] * (22 - 16) + ["map"] * (28 - 22),
+    ),
+)
+@skip_iptest_but_not_pytest
+def test_multiline_statement(c, token):
     cell = """a = (1,
     3)
 
 int()
 map()
 """
-    for c in range(16, 22):
-        yield lambda cell, c: expect_token("int", cell, c), cell, c
-    for c in range(22, 28):
-        yield lambda cell, c: expect_token("map", cell, c), cell, c
+    expect_token(token, cell, c)

appveyor.yml

@@ -1,31 +1,31 b''
 build: false
 matrix:
   fast_finish: true     # immediately finish build once one of the jobs fails.
 
 environment:
   matrix:
 
    - PYTHON: "C:\\Python37-x64"
      PYTHON_VERSION: "3.7.x"
      PYTHON_ARCH: "64"
 
    - PYTHON: "C:\\Python38"
      PYTHON_VERSION: "3.8.x"
      PYTHON_ARCH: "32"
 
    - PYTHON: "C:\\Python38-x64"
      PYTHON_VERSION: "3.8.x"
      PYTHON_ARCH: "64"
 
 init:
   - "ECHO %PYTHON% %PYTHON_VERSION% %PYTHON_ARCH%"
 
 install:
   - "SET PATH=%PYTHON%;%PYTHON%\\Scripts;%PATH%"
   - "%CMD_IN_ENV%  python -m pip install --upgrade setuptools pip"
-  - "%CMD_IN_ENV%  pip install nose coverage"
+  - "%CMD_IN_ENV%  pip install nose coverage pytest"
   - "%CMD_IN_ENV%  pip install .[test]"
   - "%CMD_IN_ENV%  mkdir results"
   - "%CMD_IN_ENV%  cd results"
 test_script:
   - "%CMD_IN_ENV%  iptest --coverage xml"