Merge pull request #13206 from sgaist/nose_cleanup_first_step

Nose cleanup first step

.pre-commit-config.yaml

@@ -0,0 +1,16 b''
+# See https://pre-commit.com for more information
+# See https://pre-commit.com/hooks.html for more hooks
+repos:
+-   repo: https://github.com/pre-commit/pre-commit-hooks
+    rev: v3.2.0
+    hooks:
+    -   id: trailing-whitespace
+    -   id: end-of-file-fixer
+    -   id: check-yaml
+    -   id: check-added-large-files
+
+-   repo: https://github.com/akaihola/darker
+    rev: 1.3.1
+    hooks:
+    -   id: darker
+

IPython/core/tests/test_application.py

@@ -1,73 +1,70 b''
 # coding: utf-8
 """Tests for IPython.core.application"""
 
 import os
 import tempfile
 
-import nose.tools as nt
-
 from traitlets import Unicode
 
 from IPython.core.application import BaseIPythonApplication
 from IPython.testing import decorators as dec
 from IPython.utils.tempdir import TemporaryDirectory
 
 
 @dec.onlyif_unicode_paths
 def test_unicode_cwd():
     """Check that IPython starts with non-ascii characters in the path."""
     wd = tempfile.mkdtemp(suffix=u"€")
     
     old_wd = os.getcwd()
     os.chdir(wd)
     #raise Exception(repr(os.getcwd()))
     try:
         app = BaseIPythonApplication()
         # The lines below are copied from Application.initialize()
         app.init_profile_dir()
         app.init_config_files()
         app.load_config_file(suppress_errors=False)
     finally:
         os.chdir(old_wd)
 
 @dec.onlyif_unicode_paths
 def test_unicode_ipdir():
     """Check that IPython starts with non-ascii characters in the IP dir."""
     ipdir = tempfile.mkdtemp(suffix=u"€")
     
     # Create the config file, so it tries to load it.
     with open(os.path.join(ipdir, 'ipython_config.py'), "w") as f:
         pass
     
     old_ipdir1 = os.environ.pop("IPYTHONDIR", None)
     old_ipdir2 = os.environ.pop("IPYTHON_DIR", None)
     os.environ["IPYTHONDIR"] = ipdir
     try:
         app = BaseIPythonApplication()
         # The lines below are copied from Application.initialize()
         app.init_profile_dir()
         app.init_config_files()
         app.load_config_file(suppress_errors=False)
     finally:
         if old_ipdir1:
             os.environ["IPYTHONDIR"] = old_ipdir1
         if old_ipdir2:
             os.environ["IPYTHONDIR"] = old_ipdir2
 
 def test_cli_priority():
     with TemporaryDirectory() as td:
 
         class TestApp(BaseIPythonApplication):
             test = Unicode().tag(config=True)
 
         # Create the config file, so it tries to load it.
         with open(os.path.join(td, 'ipython_config.py'), "w") as f:
             f.write("c.TestApp.test = 'config file'")
 
         app = TestApp()
-        app.initialize(['--profile-dir', td])
-        nt.assert_equal(app.test, 'config file')
+        app.initialize(["--profile-dir", td])
+        assert app.test == "config file"
         app = TestApp()
-        app.initialize(['--profile-dir', td, '--TestApp.test=cli'])
-        nt.assert_equal(app.test, 'cli')
-
+        app.initialize(["--profile-dir", td, "--TestApp.test=cli"])
+        assert app.test == "cli"

IPython/core/tests/test_async_helpers.py

@@ -1,316 +1,315 b''
 """
 Test for async helpers.
 
 Should only trigger on python 3.5+ or will have syntax errors.
 """
 from itertools import chain, repeat
-import nose.tools as nt
 from textwrap import dedent, indent
 from unittest import TestCase
 from IPython.testing.decorators import skip_without
 import sys
 from typing import TYPE_CHECKING
 
 if TYPE_CHECKING:
     from IPython import get_ipython
 
     ip = get_ipython()
 
 
 iprc = lambda x: ip.run_cell(dedent(x)).raise_error()
 iprc_nr = lambda x: ip.run_cell(dedent(x))
 
 from IPython.core.async_helpers import _should_be_async
 
 class AsyncTest(TestCase):
     def test_should_be_async(self):
-        nt.assert_false(_should_be_async("False"))
-        nt.assert_true(_should_be_async("await bar()"))
-        nt.assert_true(_should_be_async("x = await bar()"))
-        nt.assert_false(
+        self.assertFalse(_should_be_async("False"))
+        self.assertTrue(_should_be_async("await bar()"))
+        self.assertTrue(_should_be_async("x = await bar()"))
+        self.assertFalse(
             _should_be_async(
                 dedent(
                     """
             async def awaitable():
                 pass
         """
                 )
             )
         )
 
     def _get_top_level_cases(self):
         # These are test cases that should be valid in a function
         # but invalid outside of a function.
         test_cases = []
         test_cases.append(('basic', "{val}"))
 
         # Note, in all conditional cases, I use True instead of
         # False so that the peephole optimizer won't optimize away
         # the return, so CPython will see this as a syntax error:
         #
         # while True:
         #    break
         #    return
         #
         # But not this:
         #
         # while False:
         #    return
         #
         # See https://bugs.python.org/issue1875
 
         test_cases.append(('if', dedent("""
         if True:
             {val}
         """)))
 
         test_cases.append(('while', dedent("""
         while True:
             {val}
             break
         """)))
 
         test_cases.append(('try', dedent("""
         try:
             {val}
         except:
             pass
         """)))
 
         test_cases.append(('except', dedent("""
         try:
             pass
         except:
             {val}
         """)))
 
         test_cases.append(('finally', dedent("""
         try:
             pass
         except:
             pass
         finally:
             {val}
         """)))
 
         test_cases.append(('for', dedent("""
         for _ in range(4):
             {val}
         """)))
 
 
         test_cases.append(('nested', dedent("""
         if True:
             while True:
                 {val}
                 break
         """)))
 
         test_cases.append(('deep-nested', dedent("""
         if True:
             while True:
                 break
                 for x in range(3):
                     if True:
                         while True:
                             for x in range(3):
                                 {val}
         """)))
 
         return test_cases
 
     def _get_ry_syntax_errors(self):
         # This is a mix of tests that should be a syntax error if
         # return or yield whether or not they are in a function
 
         test_cases = []
 
         test_cases.append(('class', dedent("""
         class V:
             {val}
         """)))
 
         test_cases.append(('nested-class', dedent("""
         class V:
             class C:
                 {val}
         """)))
 
         return test_cases
 
 
     def test_top_level_return_error(self):
         tl_err_test_cases = self._get_top_level_cases()
         tl_err_test_cases.extend(self._get_ry_syntax_errors())
 
         vals = ('return', 'yield', 'yield from (_ for _ in range(3))',
                 dedent('''
                     def f():
                         pass
                     return
                     '''),
                 )
 
         for test_name, test_case in tl_err_test_cases:
             # This example should work if 'pass' is used as the value
             with self.subTest((test_name, 'pass')):
                 iprc(test_case.format(val='pass'))
 
             # It should fail with all the values
             for val in vals:
                 with self.subTest((test_name, val)):
                     msg = "Syntax error not raised for %s, %s" % (test_name, val)
                     with self.assertRaises(SyntaxError, msg=msg):
                         iprc(test_case.format(val=val))
 
     def test_in_func_no_error(self):
         # Test that the implementation of top-level return/yield
         # detection isn't *too* aggressive, and works inside a function
         func_contexts = []
 
         func_contexts.append(('func', False, dedent("""
         def f():""")))
 
         func_contexts.append(('method', False, dedent("""
         class MyClass:
             def __init__(self):
         """)))
 
         func_contexts.append(('async-func', True,  dedent("""
         async def f():""")))
 
         func_contexts.append(('async-method', True,  dedent("""
         class MyClass:
             async def f(self):""")))
 
         func_contexts.append(('closure', False, dedent("""
         def f():
             def g():
         """)))
 
         def nest_case(context, case):
             # Detect indentation
             lines = context.strip().splitlines()
             prefix_len = 0
             for c in lines[-1]:
                 if c != ' ':
                     break
                 prefix_len += 1
 
             indented_case = indent(case, ' ' * (prefix_len + 4))
             return context + '\n' + indented_case
 
         # Gather and run the tests
 
         # yield is allowed in async functions, starting in Python 3.6,
         # and yield from is not allowed in any version
         vals = ('return', 'yield', 'yield from (_ for _ in range(3))')
 
         success_tests = zip(self._get_top_level_cases(), repeat(False))
         failure_tests = zip(self._get_ry_syntax_errors(), repeat(True))
 
         tests = chain(success_tests, failure_tests)
 
         for context_name, async_func, context in func_contexts:
             for (test_name, test_case), should_fail in tests:
                 nested_case = nest_case(context, test_case)
 
                 for val in vals:
                     test_id = (context_name, test_name, val)
                     cell = nested_case.format(val=val)
 
                     with self.subTest(test_id):
                         if should_fail:
                             msg = ("SyntaxError not raised for %s" %
                                     str(test_id))
                             with self.assertRaises(SyntaxError, msg=msg):
                                 iprc(cell)
 
                                 print(cell)
                         else:
                             iprc(cell)
 
     def test_nonlocal(self):
         # fails if outer scope is not a function scope or if var not defined
         with self.assertRaises(SyntaxError):
             iprc("nonlocal x")
             iprc("""
             x = 1
             def f():
                 nonlocal x
                 x = 10000
                 yield x
             """)
             iprc("""
             def f():
                 def g():
                     nonlocal x
                     x = 10000
                     yield x
             """)
 
         # works if outer scope is a function scope and var exists
         iprc("""
         def f():
             x = 20
             def g():
                 nonlocal x
                 x = 10000
                 yield x
         """)
 
 
     def test_execute(self):
         iprc("""
         import asyncio
         await asyncio.sleep(0.001)
         """
         )
 
     def test_autoawait(self):
         iprc("%autoawait False")
         iprc("%autoawait True")
         iprc("""
         from asyncio import sleep
         await sleep(0.1)
         """
         )
 
     if sys.version_info < (3,9):
         # new pgen parser in 3.9 does not raise MemoryError on too many nested
         # parens anymore
         def test_memory_error(self):
             with self.assertRaises(MemoryError):
                 iprc("(" * 200 + ")" * 200)
 
     @skip_without('curio')
     def test_autoawait_curio(self):
         iprc("%autoawait curio")
 
     @skip_without('trio')
     def test_autoawait_trio(self):
         iprc("%autoawait trio")
 
     @skip_without('trio')
     def test_autoawait_trio_wrong_sleep(self):
         iprc("%autoawait trio")
         res = iprc_nr("""
         import asyncio
         await asyncio.sleep(0)
         """)
-        with nt.assert_raises(TypeError):
+        with self.assertRaises(TypeError):
             res.raise_error()
 
     @skip_without('trio')
     def test_autoawait_asyncio_wrong_sleep(self):
         iprc("%autoawait asyncio")
         res = iprc_nr("""
         import trio
         await trio.sleep(0)
         """)
-        with nt.assert_raises(RuntimeError):
+        with self.assertRaises(RuntimeError):
             res.raise_error()
 
 
     def tearDown(self):
         ip.loop_runner = "asyncio"

IPython/core/tests/test_completer.py

@@ -1,1278 +1,1274 b''
 # encoding: utf-8
 """Tests for the IPython tab-completion machinery."""
 
 # Copyright (c) IPython Development Team.
 # Distributed under the terms of the Modified BSD License.
 
 import os
 import sys
 import textwrap
 import unittest
 
 from contextlib import contextmanager
 
-import nose.tools as nt
-
 from traitlets.config.loader import Config
 from IPython import get_ipython
 from IPython.core import completer
 from IPython.external import decorators
 from IPython.utils.tempdir import TemporaryDirectory, TemporaryWorkingDirectory
 from IPython.utils.generics import complete_object
 from IPython.testing import decorators as dec
 
 from IPython.core.completer import (
     Completion,
     provisionalcompleter,
     match_dict_keys,
     _deduplicate_completions,
 )
-from nose.tools import assert_in, assert_not_in
 
 # -----------------------------------------------------------------------------
 # Test functions
 # -----------------------------------------------------------------------------
 
 def recompute_unicode_ranges():
     """
     utility to recompute the largest unicode range without any characters
 
     use to recompute the gap in the global _UNICODE_RANGES of completer.py
     """
     import itertools
     import unicodedata
     valid = []
     for c in range(0,0x10FFFF + 1):
         try:
             unicodedata.name(chr(c))
         except ValueError:
             continue
         valid.append(c)
 
     def ranges(i):
         for a, b in itertools.groupby(enumerate(i), lambda pair: pair[1] - pair[0]):
             b = list(b)
             yield b[0][1], b[-1][1]
 
     rg = list(ranges(valid))
     lens = []
     gap_lens = []
     pstart, pstop = 0,0
     for start, stop in rg:
         lens.append(stop-start)
         gap_lens.append((start - pstop, hex(pstop), hex(start), f'{round((start - pstop)/0xe01f0*100)}%'))
         pstart, pstop = start, stop
 
     return sorted(gap_lens)[-1]
 
 
 
 def test_unicode_range():
     """
     Test that the ranges we test for unicode names give the same number of
     results than testing the full length.
     """
     from IPython.core.completer import  _unicode_name_compute, _UNICODE_RANGES
 
     expected_list = _unicode_name_compute([(0, 0x110000)])
     test = _unicode_name_compute(_UNICODE_RANGES)
     len_exp = len(expected_list)
     len_test = len(test)
 
     # do not inline the len() or on error pytest will try to print the 130 000 +
     # elements.
     message = None
     if len_exp != len_test or len_exp > 131808:
         size, start, stop, prct = recompute_unicode_ranges()
         message = f"""_UNICODE_RANGES likely wrong and need updating. This is
         likely due to a new release of Python. We've find that the biggest gap
         in unicode characters has reduces in size to be {size} characters
         ({prct}), from {start}, to {stop}. In completer.py likely update to
 
             _UNICODE_RANGES = [(32, {start}), ({stop}, 0xe01f0)]
 
         And update the assertion below to use
 
             len_exp <= {len_exp}
         """
     assert len_exp == len_test, message
 
     # fail if new unicode symbols have been added. 
     assert len_exp <= 137714, message
 
 
 @contextmanager
 def greedy_completion():
     ip = get_ipython()
     greedy_original = ip.Completer.greedy
     try:
         ip.Completer.greedy = True
         yield
     finally:
         ip.Completer.greedy = greedy_original
 
 
 def test_protect_filename():
     if sys.platform == "win32":
         pairs = [
             ("abc", "abc"),
             (" abc", '" abc"'),
             ("a bc", '"a bc"'),
             ("a  bc", '"a  bc"'),
             ("  bc", '"  bc"'),
         ]
     else:
         pairs = [
             ("abc", "abc"),
             (" abc", r"\ abc"),
             ("a bc", r"a\ bc"),
             ("a  bc", r"a\ \ bc"),
             ("  bc", r"\ \ bc"),
             # On posix, we also protect parens and other special characters.
             ("a(bc", r"a\(bc"),
             ("a)bc", r"a\)bc"),
             ("a( )bc", r"a\(\ \)bc"),
             ("a[1]bc", r"a\[1\]bc"),
             ("a{1}bc", r"a\{1\}bc"),
             ("a#bc", r"a\#bc"),
             ("a?bc", r"a\?bc"),
             ("a=bc", r"a\=bc"),
             ("a\\bc", r"a\\bc"),
             ("a|bc", r"a\|bc"),
             ("a;bc", r"a\;bc"),
             ("a:bc", r"a\:bc"),
             ("a'bc", r"a\'bc"),
             ("a*bc", r"a\*bc"),
             ('a"bc', r"a\"bc"),
             ("a^bc", r"a\^bc"),
             ("a&bc", r"a\&bc"),
         ]
     # run the actual tests
     for s1, s2 in pairs:
         s1p = completer.protect_filename(s1)
-        nt.assert_equal(s1p, s2)
+        assert s1p == s2
 
 
 def check_line_split(splitter, test_specs):
     for part1, part2, split in test_specs:
         cursor_pos = len(part1)
         line = part1 + part2
         out = splitter.split_line(line, cursor_pos)
-        nt.assert_equal(out, split)
+        assert out == split
 
 
 def test_line_split():
     """Basic line splitter test with default specs."""
     sp = completer.CompletionSplitter()
     # The format of the test specs is: part1, part2, expected answer.  Parts 1
     # and 2 are joined into the 'line' sent to the splitter, as if the cursor
     # was at the end of part1.  So an empty part2 represents someone hitting
     # tab at the end of the line, the most common case.
     t = [
         ("run some/scrip", "", "some/scrip"),
         ("run scripts/er", "ror.py foo", "scripts/er"),
         ("echo $HOM", "", "HOM"),
         ("print sys.pa", "", "sys.pa"),
         ("print(sys.pa", "", "sys.pa"),
         ("execfile('scripts/er", "", "scripts/er"),
         ("a[x.", "", "x."),
         ("a[x.", "y", "x."),
         ('cd "some_file/', "", "some_file/"),
     ]
     check_line_split(sp, t)
     # Ensure splitting works OK with unicode by re-running the tests with
     # all inputs turned into unicode
     check_line_split(sp, [map(str, p) for p in t])
 
 
 class NamedInstanceMetaclass(type):
     def __getitem__(cls, item):
         return cls.get_instance(item)
 
 
 class NamedInstanceClass(metaclass=NamedInstanceMetaclass):
     def __init__(self, name):
         if not hasattr(self.__class__, "instances"):
             self.__class__.instances = {}
         self.__class__.instances[name] = self
 
     @classmethod
     def _ipython_key_completions_(cls):
         return cls.instances.keys()
 
     @classmethod
     def get_instance(cls, name):
         return cls.instances[name]
 
 
 class KeyCompletable:
     def __init__(self, things=()):
         self.things = things
 
     def _ipython_key_completions_(self):
         return list(self.things)
 
 
 class TestCompleter(unittest.TestCase):
     def setUp(self):
         """
         We want to silence all PendingDeprecationWarning when testing the completer
         """
         self._assertwarns = self.assertWarns(PendingDeprecationWarning)
         self._assertwarns.__enter__()
 
     def tearDown(self):
         try:
             self._assertwarns.__exit__(None, None, None)
         except AssertionError:
             pass
 
     def test_custom_completion_error(self):
         """Test that errors from custom attribute completers are silenced."""
         ip = get_ipython()
 
         class A:
             pass
 
         ip.user_ns["x"] = A()
 
         @complete_object.register(A)
         def complete_A(a, existing_completions):
             raise TypeError("this should be silenced")
 
         ip.complete("x.")
 
     def test_custom_completion_ordering(self):
         """Test that errors from custom attribute completers are silenced."""
         ip = get_ipython()
 
         _, matches = ip.complete('in')
         assert matches.index('input') < matches.index('int')
 
         def complete_example(a):
             return ['example2', 'example1']
 
         ip.Completer.custom_completers.add_re('ex*', complete_example)
         _, matches = ip.complete('ex')
         assert matches.index('example2') < matches.index('example1')
 
     def test_unicode_completions(self):
         ip = get_ipython()
         # Some strings that trigger different types of completion.  Check them both
         # in str and unicode forms
         s = ["ru", "%ru", "cd /", "floa", "float(x)/"]
         for t in s + list(map(str, s)):
             # We don't need to check exact completion values (they may change
             # depending on the state of the namespace, but at least no exceptions
             # should be thrown and the return value should be a pair of text, list
             # values.
             text, matches = ip.complete(t)
-            nt.assert_true(isinstance(text, str))
-            nt.assert_true(isinstance(matches, list))
+            self.assertIsInstance(text, str)
+            self.assertIsInstance(matches, list)
 
     def test_latex_completions(self):
         from IPython.core.latex_symbols import latex_symbols
         import random
 
         ip = get_ipython()
         # Test some random unicode symbols
         keys = random.sample(latex_symbols.keys(), 10)
         for k in keys:
             text, matches = ip.complete(k)
-            nt.assert_equal(text, k)
-            nt.assert_equal(matches, [latex_symbols[k]])
+            self.assertEqual(text, k)
+            self.assertEqual(matches, [latex_symbols[k]])
         # Test a more complex line
         text, matches = ip.complete("print(\\alpha")
-        nt.assert_equal(text, "\\alpha")
-        nt.assert_equal(matches[0], latex_symbols["\\alpha"])
+        self.assertEqual(text, "\\alpha")
+        self.assertEqual(matches[0], latex_symbols["\\alpha"])
         # Test multiple matching latex symbols
         text, matches = ip.complete("\\al")
-        nt.assert_in("\\alpha", matches)
-        nt.assert_in("\\aleph", matches)
+        self.assertIn("\\alpha", matches)
+        self.assertIn("\\aleph", matches)
 
     def test_latex_no_results(self):
         """
         forward latex should really return nothing in either field if nothing is found.
         """
         ip = get_ipython()
         text, matches = ip.Completer.latex_matches("\\really_i_should_match_nothing")
-        nt.assert_equal(text, "")
-        nt.assert_equal(matches, ())
+        self.assertEqual(text, "")
+        self.assertEqual(matches, ())
 
     def test_back_latex_completion(self):
         ip = get_ipython()
 
         # do not return more than 1 matches for \beta, only the latex one.
         name, matches = ip.complete("\\β")
-        nt.assert_equal(matches, ['\\beta'])
+        self.assertEqual(matches, ["\\beta"])
 
     def test_back_unicode_completion(self):
         ip = get_ipython()
 
         name, matches = ip.complete("\\Ⅴ")
-        nt.assert_equal(matches, ("\\ROMAN NUMERAL FIVE",))
+        self.assertEqual(matches, ("\\ROMAN NUMERAL FIVE",))
 
     def test_forward_unicode_completion(self):
         ip = get_ipython()
 
         name, matches = ip.complete("\\ROMAN NUMERAL FIVE")
-        nt.assert_equal(matches, ["Ⅴ"] ) # This is not a V
-        nt.assert_equal(matches, ["\u2164"] ) # same as above but explicit.
+        self.assertEqual(matches, ["Ⅴ"])  # This is not a V
+        self.assertEqual(matches, ["\u2164"])  # same as above but explicit.
 
-    @nt.nottest  # now we have a completion for \jmath
+    @unittest.skip("now we have a completion for \jmath")
     @decorators.knownfailureif(
         sys.platform == "win32", "Fails if there is a C:\\j... path"
     )
     def test_no_ascii_back_completion(self):
         ip = get_ipython()
         with TemporaryWorkingDirectory():  # Avoid any filename completions
             # single ascii letter that don't have yet completions
             for letter in "jJ":
                 name, matches = ip.complete("\\" + letter)
-                nt.assert_equal(matches, [])
+                self.assertEqual(matches, [])
 
     class CompletionSplitterTestCase(unittest.TestCase):
         def setUp(self):
             self.sp = completer.CompletionSplitter()
 
         def test_delim_setting(self):
             self.sp.delims = " "
-            nt.assert_equal(self.sp.delims, " ")
-            nt.assert_equal(self.sp._delim_expr, r"[\ ]")
+            self.assertEqual(self.sp.delims, " ")
+            self.assertEqual(self.sp._delim_expr, r"[\ ]")
 
         def test_spaces(self):
             """Test with only spaces as split chars."""
             self.sp.delims = " "
             t = [("foo", "", "foo"), ("run foo", "", "foo"), ("run foo", "bar", "foo")]
             check_line_split(self.sp, t)
 
     def test_has_open_quotes1(self):
         for s in ["'", "'''", "'hi' '"]:
-            nt.assert_equal(completer.has_open_quotes(s), "'")
+            self.assertEqual(completer.has_open_quotes(s), "'")
 
     def test_has_open_quotes2(self):
         for s in ['"', '"""', '"hi" "']:
-            nt.assert_equal(completer.has_open_quotes(s), '"')
+            self.assertEqual(completer.has_open_quotes(s), '"')
 
     def test_has_open_quotes3(self):
         for s in ["''", "''' '''", "'hi' 'ipython'"]:
-            nt.assert_false(completer.has_open_quotes(s))
+            self.assertFalse(completer.has_open_quotes(s))
 
     def test_has_open_quotes4(self):
         for s in ['""', '""" """', '"hi" "ipython"']:
-            nt.assert_false(completer.has_open_quotes(s))
+            self.assertFalse(completer.has_open_quotes(s))
 
     @decorators.knownfailureif(
         sys.platform == "win32", "abspath completions fail on Windows"
     )
     def test_abspath_file_completions(self):
         ip = get_ipython()
         with TemporaryDirectory() as tmpdir:
             prefix = os.path.join(tmpdir, "foo")
             suffixes = ["1", "2"]
             names = [prefix + s for s in suffixes]
             for n in names:
                 open(n, "w").close()
 
             # Check simple completion
             c = ip.complete(prefix)[1]
-            nt.assert_equal(c, names)
+            self.assertEqual(c, names)
 
             # Now check with a function call
             cmd = 'a = f("%s' % prefix
             c = ip.complete(prefix, cmd)[1]
             comp = [prefix + s for s in suffixes]
-            nt.assert_equal(c, comp)
+            self.assertEqual(c, comp)
 
     def test_local_file_completions(self):
         ip = get_ipython()
         with TemporaryWorkingDirectory():
             prefix = "./foo"
             suffixes = ["1", "2"]
             names = [prefix + s for s in suffixes]
             for n in names:
                 open(n, "w").close()
 
             # Check simple completion
             c = ip.complete(prefix)[1]
-            nt.assert_equal(c, names)
+            self.assertEqual(c, names)
 
             # Now check with a function call
             cmd = 'a = f("%s' % prefix
             c = ip.complete(prefix, cmd)[1]
             comp = {prefix + s for s in suffixes}
-            nt.assert_true(comp.issubset(set(c)))
+            self.assertTrue(comp.issubset(set(c)))
 
     def test_quoted_file_completions(self):
         ip = get_ipython()
         with TemporaryWorkingDirectory():
             name = "foo'bar"
             open(name, "w").close()
 
             # Don't escape Windows
             escaped = name if sys.platform == "win32" else "foo\\'bar"
 
             # Single quote matches embedded single quote
             text = "open('foo"
             c = ip.Completer._complete(
                 cursor_line=0, cursor_pos=len(text), full_text=text
             )[1]
-            nt.assert_equal(c, [escaped])
+            self.assertEqual(c, [escaped])
 
             # Double quote requires no escape
             text = 'open("foo'
             c = ip.Completer._complete(
                 cursor_line=0, cursor_pos=len(text), full_text=text
             )[1]
-            nt.assert_equal(c, [name])
+            self.assertEqual(c, [name])
 
             # No quote requires an escape
             text = "%ls foo"
             c = ip.Completer._complete(
                 cursor_line=0, cursor_pos=len(text), full_text=text
             )[1]
-            nt.assert_equal(c, [escaped])
+            self.assertEqual(c, [escaped])
 
     def test_all_completions_dups(self):
         """
         Make sure the output of `IPCompleter.all_completions` does not have
         duplicated prefixes.
         """
         ip = get_ipython()
         c = ip.Completer
         ip.ex("class TestClass():\n\ta=1\n\ta1=2")
         for jedi_status in [True, False]:
             with provisionalcompleter():
                 ip.Completer.use_jedi = jedi_status
                 matches = c.all_completions("TestCl")
                 assert matches == ['TestClass'], jedi_status
                 matches = c.all_completions("TestClass.")
                 assert len(matches) > 2, jedi_status
                 matches = c.all_completions("TestClass.a")
                 assert matches == ['TestClass.a', 'TestClass.a1'], jedi_status
 
     def test_jedi(self):
         """
         A couple of issue we had with Jedi
         """
         ip = get_ipython()
 
         def _test_complete(reason, s, comp, start=None, end=None):
             l = len(s)
             start = start if start is not None else l
             end = end if end is not None else l
             with provisionalcompleter():
                 ip.Completer.use_jedi = True
                 completions = set(ip.Completer.completions(s, l))
                 ip.Completer.use_jedi = False
                 assert_in(Completion(start, end, comp), completions, reason)
 
         def _test_not_complete(reason, s, comp):
             l = len(s)
             with provisionalcompleter():
                 ip.Completer.use_jedi = True
                 completions = set(ip.Completer.completions(s, l))
                 ip.Completer.use_jedi = False
                 assert_not_in(Completion(l, l, comp), completions, reason)
 
         import jedi
 
         jedi_version = tuple(int(i) for i in jedi.__version__.split(".")[:3])
         if jedi_version > (0, 10):
             yield _test_complete, "jedi >0.9 should complete and not crash", "a=1;a.", "real"
         yield _test_complete, "can infer first argument", 'a=(1,"foo");a[0].', "real"
         yield _test_complete, "can infer second argument", 'a=(1,"foo");a[1].', "capitalize"
         yield _test_complete, "cover duplicate completions", "im", "import", 0, 2
 
         yield _test_not_complete, "does not mix types", 'a=(1,"foo");a[0].', "capitalize"
 
     def test_completion_have_signature(self):
         """
         Lets make sure jedi is capable of pulling out the signature of the function we are completing.
         """
         ip = get_ipython()
         with provisionalcompleter():
             ip.Completer.use_jedi = True
             completions = ip.Completer.completions("ope", 3)
             c = next(completions)  # should be `open`
             ip.Completer.use_jedi = False
         assert "file" in c.signature, "Signature of function was not found by completer"
         assert (
             "encoding" in c.signature
         ), "Signature of function was not found by completer"
 
     def test_deduplicate_completions(self):
         """
         Test that completions are correctly deduplicated (even if ranges are not the same)
         """
         ip = get_ipython()
         ip.ex(
             textwrap.dedent(
                 """
         class Z:
             zoo = 1
         """
             )
         )
         with provisionalcompleter():
             ip.Completer.use_jedi = True
             l = list(
                 _deduplicate_completions("Z.z", ip.Completer.completions("Z.z", 3))
             )
             ip.Completer.use_jedi = False
 
         assert len(l) == 1, "Completions (Z.z<tab>) correctly deduplicate: %s " % l
         assert l[0].text == "zoo"  # and not `it.accumulate`
 
     def test_greedy_completions(self):
         """
         Test the capability of the Greedy completer. 
 
         Most of the test here does not really show off the greedy completer, for proof
         each of the text below now pass with Jedi. The greedy completer is capable of more. 
 
         See the :any:`test_dict_key_completion_contexts`
 
         """
         ip = get_ipython()
         ip.ex("a=list(range(5))")
         _, c = ip.complete(".", line="a[0].")
-        nt.assert_false(".real" in c, "Shouldn't have completed on a[0]: %s" % c)
+        self.assertFalse(".real" in c, "Shouldn't have completed on a[0]: %s" % c)
 
         def _(line, cursor_pos, expect, message, completion):
             with greedy_completion(), provisionalcompleter():
                 ip.Completer.use_jedi = False
                 _, c = ip.complete(".", line=line, cursor_pos=cursor_pos)
-                nt.assert_in(expect, c, message % c)
+                self.assertIn(expect, c, message % c)
 
                 ip.Completer.use_jedi = True
                 with provisionalcompleter():
                     completions = ip.Completer.completions(line, cursor_pos)
-                nt.assert_in(completion, completions)
+                self.assertIn(completion, completions)
 
         with provisionalcompleter():
             yield _, "a[0].", 5, "a[0].real", "Should have completed on a[0].: %s", Completion(
                 5, 5, "real"
             )
             yield _, "a[0].r", 6, "a[0].real", "Should have completed on a[0].r: %s", Completion(
                 5, 6, "real"
             )
 
             yield _, "a[0].from_", 10, "a[0].from_bytes", "Should have completed on a[0].from_: %s", Completion(
                 5, 10, "from_bytes"
             )
 
     def test_omit__names(self):
         # also happens to test IPCompleter as a configurable
         ip = get_ipython()
         ip._hidden_attr = 1
         ip._x = {}
         c = ip.Completer
         ip.ex("ip=get_ipython()")
         cfg = Config()
         cfg.IPCompleter.omit__names = 0
         c.update_config(cfg)
         with provisionalcompleter():
             c.use_jedi = False
             s, matches = c.complete("ip.")
-            nt.assert_in("ip.__str__", matches)
-            nt.assert_in("ip._hidden_attr", matches)
+            self.assertIn("ip.__str__", matches)
+            self.assertIn("ip._hidden_attr", matches)
 
             # c.use_jedi = True
             # completions = set(c.completions('ip.', 3))
-            # nt.assert_in(Completion(3, 3, '__str__'), completions)
-            # nt.assert_in(Completion(3,3, "_hidden_attr"), completions)
+            # self.assertIn(Completion(3, 3, '__str__'), completions)
+            # self.assertIn(Completion(3,3, "_hidden_attr"), completions)
 
         cfg = Config()
         cfg.IPCompleter.omit__names = 1
         c.update_config(cfg)
         with provisionalcompleter():
             c.use_jedi = False
             s, matches = c.complete("ip.")
-            nt.assert_not_in("ip.__str__", matches)
-            # nt.assert_in('ip._hidden_attr', matches)
+            self.assertNotIn("ip.__str__", matches)
+            # self.assertIn('ip._hidden_attr', matches)
 
             # c.use_jedi = True
             # completions = set(c.completions('ip.', 3))
-            # nt.assert_not_in(Completion(3,3,'__str__'), completions)
-            # nt.assert_in(Completion(3,3, "_hidden_attr"), completions)
+            # self.assertNotIn(Completion(3,3,'__str__'), completions)
+            # self.assertIn(Completion(3,3, "_hidden_attr"), completions)
 
         cfg = Config()
         cfg.IPCompleter.omit__names = 2
         c.update_config(cfg)
         with provisionalcompleter():
             c.use_jedi = False
             s, matches = c.complete("ip.")
-            nt.assert_not_in("ip.__str__", matches)
-            nt.assert_not_in("ip._hidden_attr", matches)
+            self.assertNotIn("ip.__str__", matches)
+            self.assertNotIn("ip._hidden_attr", matches)
 
             # c.use_jedi = True
             # completions = set(c.completions('ip.', 3))
-            # nt.assert_not_in(Completion(3,3,'__str__'), completions)
-            # nt.assert_not_in(Completion(3,3, "_hidden_attr"), completions)
+            # self.assertNotIn(Completion(3,3,'__str__'), completions)
+            # self.assertNotIn(Completion(3,3, "_hidden_attr"), completions)
 
         with provisionalcompleter():
             c.use_jedi = False
             s, matches = c.complete("ip._x.")
-            nt.assert_in("ip._x.keys", matches)
+            self.assertIn("ip._x.keys", matches)
 
             # c.use_jedi = True
             # completions = set(c.completions('ip._x.', 6))
-            # nt.assert_in(Completion(6,6, "keys"), completions)
+            # self.assertIn(Completion(6,6, "keys"), completions)
 
         del ip._hidden_attr
         del ip._x
 
     def test_limit_to__all__False_ok(self):
         """
         Limit to all is deprecated, once we remove it this test can go away. 
         """
         ip = get_ipython()
         c = ip.Completer
         c.use_jedi = False
         ip.ex("class D: x=24")
         ip.ex("d=D()")
         cfg = Config()
         cfg.IPCompleter.limit_to__all__ = False
         c.update_config(cfg)
         s, matches = c.complete("d.")
-        nt.assert_in("d.x", matches)
+        self.assertIn("d.x", matches)
 
     def test_get__all__entries_ok(self):
         class A:
             __all__ = ["x", 1]
 
         words = completer.get__all__entries(A())
-        nt.assert_equal(words, ["x"])
+        self.assertEqual(words, ["x"])
 
     def test_get__all__entries_no__all__ok(self):
         class A:
             pass
 
         words = completer.get__all__entries(A())
-        nt.assert_equal(words, [])
+        self.assertEqual(words, [])
 
     def test_func_kw_completions(self):
         ip = get_ipython()
         c = ip.Completer
         c.use_jedi = False
         ip.ex("def myfunc(a=1,b=2): return a+b")
         s, matches = c.complete(None, "myfunc(1,b")
-        nt.assert_in("b=", matches)
+        self.assertIn("b=", matches)
         # Simulate completing with cursor right after b (pos==10):
         s, matches = c.complete(None, "myfunc(1,b)", 10)
-        nt.assert_in("b=", matches)
+        self.assertIn("b=", matches)
         s, matches = c.complete(None, 'myfunc(a="escaped\\")string",b')
-        nt.assert_in("b=", matches)
+        self.assertIn("b=", matches)
         # builtin function
         s, matches = c.complete(None, "min(k, k")
-        nt.assert_in("key=", matches)
+        self.assertIn("key=", matches)
 
     def test_default_arguments_from_docstring(self):
         ip = get_ipython()
         c = ip.Completer
         kwd = c._default_arguments_from_docstring("min(iterable[, key=func]) -> value")
-        nt.assert_equal(kwd, ["key"])
+        self.assertEqual(kwd, ["key"])
         # with cython type etc
         kwd = c._default_arguments_from_docstring(
             "Minuit.migrad(self, int ncall=10000, resume=True, int nsplit=1)\n"
         )
-        nt.assert_equal(kwd, ["ncall", "resume", "nsplit"])
+        self.assertEqual(kwd, ["ncall", "resume", "nsplit"])
         # white spaces
         kwd = c._default_arguments_from_docstring(
             "\n Minuit.migrad(self, int ncall=10000, resume=True, int nsplit=1)\n"
         )
-        nt.assert_equal(kwd, ["ncall", "resume", "nsplit"])
+        self.assertEqual(kwd, ["ncall", "resume", "nsplit"])
 
     def test_line_magics(self):
         ip = get_ipython()
         c = ip.Completer
         s, matches = c.complete(None, "lsmag")
-        nt.assert_in("%lsmagic", matches)
+        self.assertIn("%lsmagic", matches)
         s, matches = c.complete(None, "%lsmag")
-        nt.assert_in("%lsmagic", matches)
+        self.assertIn("%lsmagic", matches)
 
     def test_cell_magics(self):
         from IPython.core.magic import register_cell_magic
 
         @register_cell_magic
         def _foo_cellm(line, cell):
             pass
 
         ip = get_ipython()
         c = ip.Completer
 
         s, matches = c.complete(None, "_foo_ce")
-        nt.assert_in("%%_foo_cellm", matches)
+        self.assertIn("%%_foo_cellm", matches)
         s, matches = c.complete(None, "%%_foo_ce")
-        nt.assert_in("%%_foo_cellm", matches)
+        self.assertIn("%%_foo_cellm", matches)
 
     def test_line_cell_magics(self):
         from IPython.core.magic import register_line_cell_magic
 
         @register_line_cell_magic
         def _bar_cellm(line, cell):
             pass
 
         ip = get_ipython()
         c = ip.Completer
 
         # The policy here is trickier, see comments in completion code.  The
         # returned values depend on whether the user passes %% or not explicitly,
         # and this will show a difference if the same name is both a line and cell
         # magic.
         s, matches = c.complete(None, "_bar_ce")
-        nt.assert_in("%_bar_cellm", matches)
-        nt.assert_in("%%_bar_cellm", matches)
+        self.assertIn("%_bar_cellm", matches)
+        self.assertIn("%%_bar_cellm", matches)
         s, matches = c.complete(None, "%_bar_ce")
-        nt.assert_in("%_bar_cellm", matches)
-        nt.assert_in("%%_bar_cellm", matches)
+        self.assertIn("%_bar_cellm", matches)
+        self.assertIn("%%_bar_cellm", matches)
         s, matches = c.complete(None, "%%_bar_ce")
-        nt.assert_not_in("%_bar_cellm", matches)
-        nt.assert_in("%%_bar_cellm", matches)
+        self.assertNotIn("%_bar_cellm", matches)
+        self.assertIn("%%_bar_cellm", matches)
 
     def test_magic_completion_order(self):
         ip = get_ipython()
         c = ip.Completer
 
         # Test ordering of line and cell magics.
         text, matches = c.complete("timeit")
-        nt.assert_equal(matches, ["%timeit", "%%timeit"])
+        self.assertEqual(matches, ["%timeit", "%%timeit"])
 
     def test_magic_completion_shadowing(self):
         ip = get_ipython()
         c = ip.Completer
         c.use_jedi = False
 
         # Before importing matplotlib, %matplotlib magic should be the only option.
         text, matches = c.complete("mat")
-        nt.assert_equal(matches, ["%matplotlib"])
+        self.assertEqual(matches, ["%matplotlib"])
 
         # The newly introduced name should shadow the magic.
         ip.run_cell("matplotlib = 1")
         text, matches = c.complete("mat")
-        nt.assert_equal(matches, ["matplotlib"])
+        self.assertEqual(matches, ["matplotlib"])
 
         # After removing matplotlib from namespace, the magic should again be
         # the only option.
         del ip.user_ns["matplotlib"]
         text, matches = c.complete("mat")
-        nt.assert_equal(matches, ["%matplotlib"])
+        self.assertEqual(matches, ["%matplotlib"])
 
     def test_magic_completion_shadowing_explicit(self):
         """
         If the user try to complete a shadowed magic, and explicit % start should
         still return the completions.
         """
         ip = get_ipython()
         c = ip.Completer
 
         # Before importing matplotlib, %matplotlib magic should be the only option.
         text, matches = c.complete("%mat")
-        nt.assert_equal(matches, ["%matplotlib"])
+        self.assertEqual(matches, ["%matplotlib"])
 
         ip.run_cell("matplotlib = 1")
 
         # After removing matplotlib from namespace, the magic should still be
         # the only option.
         text, matches = c.complete("%mat")
-        nt.assert_equal(matches, ["%matplotlib"])
+        self.assertEqual(matches, ["%matplotlib"])
 
     def test_magic_config(self):
         ip = get_ipython()
         c = ip.Completer
 
         s, matches = c.complete(None, "conf")
-        nt.assert_in("%config", matches)
+        self.assertIn("%config", matches)
         s, matches = c.complete(None, "conf")
-        nt.assert_not_in("AliasManager", matches)
+        self.assertNotIn("AliasManager", matches)
         s, matches = c.complete(None, "config ")
-        nt.assert_in("AliasManager", matches)
+        self.assertIn("AliasManager", matches)
         s, matches = c.complete(None, "%config ")
-        nt.assert_in("AliasManager", matches)
+        self.assertIn("AliasManager", matches)
         s, matches = c.complete(None, "config Ali")
-        nt.assert_list_equal(["AliasManager"], matches)
+        self.assertListEqual(["AliasManager"], matches)
         s, matches = c.complete(None, "%config Ali")
-        nt.assert_list_equal(["AliasManager"], matches)
+        self.assertListEqual(["AliasManager"], matches)
         s, matches = c.complete(None, "config AliasManager")
-        nt.assert_list_equal(["AliasManager"], matches)
+        self.assertListEqual(["AliasManager"], matches)
         s, matches = c.complete(None, "%config AliasManager")
-        nt.assert_list_equal(["AliasManager"], matches)
+        self.assertListEqual(["AliasManager"], matches)
         s, matches = c.complete(None, "config AliasManager.")
-        nt.assert_in("AliasManager.default_aliases", matches)
+        self.assertIn("AliasManager.default_aliases", matches)
         s, matches = c.complete(None, "%config AliasManager.")
-        nt.assert_in("AliasManager.default_aliases", matches)
+        self.assertIn("AliasManager.default_aliases", matches)
         s, matches = c.complete(None, "config AliasManager.de")
-        nt.assert_list_equal(["AliasManager.default_aliases"], matches)
+        self.assertListEqual(["AliasManager.default_aliases"], matches)
         s, matches = c.complete(None, "config AliasManager.de")
-        nt.assert_list_equal(["AliasManager.default_aliases"], matches)
+        self.assertListEqual(["AliasManager.default_aliases"], matches)
 
     def test_magic_color(self):
         ip = get_ipython()
         c = ip.Completer
 
         s, matches = c.complete(None, "colo")
-        nt.assert_in("%colors", matches)
+        self.assertIn("%colors", matches)
         s, matches = c.complete(None, "colo")
-        nt.assert_not_in("NoColor", matches)
+        self.assertNotIn("NoColor", matches)
         s, matches = c.complete(None, "%colors")  # No trailing space
-        nt.assert_not_in("NoColor", matches)
+        self.assertNotIn("NoColor", matches)
         s, matches = c.complete(None, "colors ")
-        nt.assert_in("NoColor", matches)
+        self.assertIn("NoColor", matches)
         s, matches = c.complete(None, "%colors ")
-        nt.assert_in("NoColor", matches)
+        self.assertIn("NoColor", matches)
         s, matches = c.complete(None, "colors NoCo")
-        nt.assert_list_equal(["NoColor"], matches)
+        self.assertListEqual(["NoColor"], matches)
         s, matches = c.complete(None, "%colors NoCo")
-        nt.assert_list_equal(["NoColor"], matches)
+        self.assertListEqual(["NoColor"], matches)
 
     def test_match_dict_keys(self):
         """
         Test that match_dict_keys works on a couple of use case does return what
         expected, and does not crash
         """
         delims = " \t\n`!@#$^&*()=+[{]}\\|;:'\",<>?"
 
         keys = ["foo", b"far"]
         assert match_dict_keys(keys, "b'", delims=delims) == ("'", 2, ["far"])
         assert match_dict_keys(keys, "b'f", delims=delims) == ("'", 2, ["far"])
         assert match_dict_keys(keys, 'b"', delims=delims) == ('"', 2, ["far"])
         assert match_dict_keys(keys, 'b"f', delims=delims) == ('"', 2, ["far"])
 
         assert match_dict_keys(keys, "'", delims=delims) == ("'", 1, ["foo"])
         assert match_dict_keys(keys, "'f", delims=delims) == ("'", 1, ["foo"])
         assert match_dict_keys(keys, '"', delims=delims) == ('"', 1, ["foo"])
         assert match_dict_keys(keys, '"f', delims=delims) == ('"', 1, ["foo"])
 
         match_dict_keys
 
     def test_match_dict_keys_tuple(self):
         """
         Test that match_dict_keys called with extra prefix works on a couple of use case,
         does return what expected, and does not crash.
         """
         delims = " \t\n`!@#$^&*()=+[{]}\\|;:'\",<>?"
         
         keys = [("foo", "bar"), ("foo", "oof"), ("foo", b"bar"), ('other', 'test')]
 
         # Completion on first key == "foo"
         assert match_dict_keys(keys, "'", delims=delims, extra_prefix=("foo",)) == ("'", 1, ["bar", "oof"])
         assert match_dict_keys(keys, "\"", delims=delims, extra_prefix=("foo",)) == ("\"", 1, ["bar", "oof"])
         assert match_dict_keys(keys, "'o", delims=delims, extra_prefix=("foo",)) == ("'", 1, ["oof"])
         assert match_dict_keys(keys, "\"o", delims=delims, extra_prefix=("foo",)) == ("\"", 1, ["oof"])
         assert match_dict_keys(keys, "b'", delims=delims, extra_prefix=("foo",)) == ("'", 2, ["bar"])
         assert match_dict_keys(keys, "b\"", delims=delims, extra_prefix=("foo",)) == ("\"", 2, ["bar"])
         assert match_dict_keys(keys, "b'b", delims=delims, extra_prefix=("foo",)) == ("'", 2, ["bar"])
         assert match_dict_keys(keys, "b\"b", delims=delims, extra_prefix=("foo",)) == ("\"", 2, ["bar"])
 
         # No Completion
         assert match_dict_keys(keys, "'", delims=delims, extra_prefix=("no_foo",)) == ("'", 1, [])
         assert match_dict_keys(keys, "'", delims=delims, extra_prefix=("fo",)) == ("'", 1, [])
 
         keys = [('foo1', 'foo2', 'foo3', 'foo4'), ('foo1', 'foo2', 'bar', 'foo4')]
         assert match_dict_keys(keys, "'foo", delims=delims, extra_prefix=('foo1',)) == ("'", 1, ["foo2", "foo2"])
         assert match_dict_keys(keys, "'foo", delims=delims, extra_prefix=('foo1', 'foo2')) == ("'", 1, ["foo3"])
         assert match_dict_keys(keys, "'foo", delims=delims, extra_prefix=('foo1', 'foo2', 'foo3')) == ("'", 1, ["foo4"])
         assert match_dict_keys(keys, "'foo", delims=delims, extra_prefix=('foo1', 'foo2', 'foo3', 'foo4')) == ("'", 1, [])
 
     def test_dict_key_completion_string(self):
         """Test dictionary key completion for string keys"""
         ip = get_ipython()
         complete = ip.Completer.complete
 
         ip.user_ns["d"] = {"abc": None}
 
         # check completion at different stages
         _, matches = complete(line_buffer="d[")
-        nt.assert_in("'abc'", matches)
-        nt.assert_not_in("'abc']", matches)
+        self.assertIn("'abc'", matches)
+        self.assertNotIn("'abc']", matches)
 
         _, matches = complete(line_buffer="d['")
-        nt.assert_in("abc", matches)
-        nt.assert_not_in("abc']", matches)
+        self.assertIn("abc", matches)
+        self.assertNotIn("abc']", matches)
 
         _, matches = complete(line_buffer="d['a")
-        nt.assert_in("abc", matches)
-        nt.assert_not_in("abc']", matches)
+        self.assertIn("abc", matches)
+        self.assertNotIn("abc']", matches)
 
         # check use of different quoting
         _, matches = complete(line_buffer='d["')
-        nt.assert_in("abc", matches)
-        nt.assert_not_in('abc"]', matches)
+        self.assertIn("abc", matches)
+        self.assertNotIn('abc"]', matches)
 
         _, matches = complete(line_buffer='d["a')
-        nt.assert_in("abc", matches)
-        nt.assert_not_in('abc"]', matches)
+        self.assertIn("abc", matches)
+        self.assertNotIn('abc"]', matches)
 
         # check sensitivity to following context
         _, matches = complete(line_buffer="d[]", cursor_pos=2)
-        nt.assert_in("'abc'", matches)
+        self.assertIn("'abc'", matches)
 
         _, matches = complete(line_buffer="d['']", cursor_pos=3)
-        nt.assert_in("abc", matches)
-        nt.assert_not_in("abc'", matches)
-        nt.assert_not_in("abc']", matches)
+        self.assertIn("abc", matches)
+        self.assertNotIn("abc'", matches)
+        self.assertNotIn("abc']", matches)
 
         # check multiple solutions are correctly returned and that noise is not
         ip.user_ns["d"] = {
             "abc": None,
             "abd": None,
             "bad": None,
             object(): None,
             5: None,
             ("abe", None): None,
             (None, "abf"): None
         }
 
         _, matches = complete(line_buffer="d['a")
-        nt.assert_in("abc", matches)
-        nt.assert_in("abd", matches)
-        nt.assert_not_in("bad", matches)
-        nt.assert_not_in("abe", matches)
-        nt.assert_not_in("abf", matches)
+        self.assertIn("abc", matches)
+        self.assertIn("abd", matches)
+        self.assertNotIn("bad", matches)
+        self.assertNotIn("abe", matches)
+        self.assertNotIn("abf", matches)
         assert not any(m.endswith(("]", '"', "'")) for m in matches), matches
 
         # check escaping and whitespace
         ip.user_ns["d"] = {"a\nb": None, "a'b": None, 'a"b': None, "a word": None}
         _, matches = complete(line_buffer="d['a")
-        nt.assert_in("a\\nb", matches)
-        nt.assert_in("a\\'b", matches)
-        nt.assert_in('a"b', matches)
-        nt.assert_in("a word", matches)
+        self.assertIn("a\\nb", matches)
+        self.assertIn("a\\'b", matches)
+        self.assertIn('a"b', matches)
+        self.assertIn("a word", matches)
         assert not any(m.endswith(("]", '"', "'")) for m in matches), matches
 
         # - can complete on non-initial word of the string
         _, matches = complete(line_buffer="d['a w")
-        nt.assert_in("word", matches)
+        self.assertIn("word", matches)
 
         # - understands quote escaping
         _, matches = complete(line_buffer="d['a\\'")
-        nt.assert_in("b", matches)
+        self.assertIn("b", matches)
 
         # - default quoting should work like repr
         _, matches = complete(line_buffer="d[")
-        nt.assert_in('"a\'b"', matches)
+        self.assertIn('"a\'b"', matches)
 
         # - when opening quote with ", possible to match with unescaped apostrophe
         _, matches = complete(line_buffer="d[\"a'")
-        nt.assert_in("b", matches)
+        self.assertIn("b", matches)
 
         # need to not split at delims that readline won't split at
         if "-" not in ip.Completer.splitter.delims:
             ip.user_ns["d"] = {"before-after": None}
             _, matches = complete(line_buffer="d['before-af")
-            nt.assert_in("before-after", matches)
+            self.assertIn("before-after", matches)
 
         # check completion on tuple-of-string keys at different stage - on first key
         ip.user_ns["d"] = {('foo', 'bar'): None}
         _, matches = complete(line_buffer="d[")
-        nt.assert_in("'foo'", matches)
-        nt.assert_not_in("'foo']", matches)
-        nt.assert_not_in("'bar'", matches)
-        nt.assert_not_in("foo", matches)
-        nt.assert_not_in("bar", matches)
+        self.assertIn("'foo'", matches)
+        self.assertNotIn("'foo']", matches)
+        self.assertNotIn("'bar'", matches)
+        self.assertNotIn("foo", matches)
+        self.assertNotIn("bar", matches)
 
         # - match the prefix
         _, matches = complete(line_buffer="d['f")
-        nt.assert_in("foo", matches)
-        nt.assert_not_in("foo']", matches)
-        nt.assert_not_in("foo\"]", matches)
+        self.assertIn("foo", matches)
+        self.assertNotIn("foo']", matches)
+        self.assertNotIn('foo"]', matches)
         _, matches = complete(line_buffer="d['foo")
-        nt.assert_in("foo", matches)
+        self.assertIn("foo", matches)
 
         # - can complete on second key
         _, matches = complete(line_buffer="d['foo', ")
-        nt.assert_in("'bar'", matches)
+        self.assertIn("'bar'", matches)
         _, matches = complete(line_buffer="d['foo', 'b")
-        nt.assert_in("bar", matches)
-        nt.assert_not_in("foo", matches)
+        self.assertIn("bar", matches)
+        self.assertNotIn("foo", matches)
 
         # - does not propose missing keys
         _, matches = complete(line_buffer="d['foo', 'f")
-        nt.assert_not_in("bar", matches)
-        nt.assert_not_in("foo", matches)
+        self.assertNotIn("bar", matches)
+        self.assertNotIn("foo", matches)
 
         # check sensitivity to following context
         _, matches = complete(line_buffer="d['foo',]", cursor_pos=8)
-        nt.assert_in("'bar'", matches)
-        nt.assert_not_in("bar", matches)
-        nt.assert_not_in("'foo'", matches)
-        nt.assert_not_in("foo", matches)
+        self.assertIn("'bar'", matches)
+        self.assertNotIn("bar", matches)
+        self.assertNotIn("'foo'", matches)
+        self.assertNotIn("foo", matches)
 
         _, matches = complete(line_buffer="d['']", cursor_pos=3)
-        nt.assert_in("foo", matches)
+        self.assertIn("foo", matches)
         assert not any(m.endswith(("]", '"', "'")) for m in matches), matches
 
         _, matches = complete(line_buffer='d[""]', cursor_pos=3)
-        nt.assert_in("foo", matches)
+        self.assertIn("foo", matches)
         assert not any(m.endswith(("]", '"', "'")) for m in matches), matches
 
         _, matches = complete(line_buffer='d["foo","]', cursor_pos=9)
-        nt.assert_in("bar", matches)
+        self.assertIn("bar", matches)
         assert not any(m.endswith(("]", '"', "'")) for m in matches), matches
 
         _, matches = complete(line_buffer='d["foo",]', cursor_pos=8)
-        nt.assert_in("'bar'", matches)
-        nt.assert_not_in("bar", matches)
+        self.assertIn("'bar'", matches)
+        self.assertNotIn("bar", matches)
 
         # Can complete with longer tuple keys
         ip.user_ns["d"] = {('foo', 'bar', 'foobar'): None}
 
         # - can complete second key
         _, matches = complete(line_buffer="d['foo', 'b")
-        nt.assert_in('bar', matches)
-        nt.assert_not_in('foo', matches)
-        nt.assert_not_in('foobar', matches)
+        self.assertIn("bar", matches)
+        self.assertNotIn("foo", matches)
+        self.assertNotIn("foobar", matches)
 
         # - can complete third key
         _, matches = complete(line_buffer="d['foo', 'bar', 'fo")
-        nt.assert_in('foobar', matches)
-        nt.assert_not_in('foo', matches)
-        nt.assert_not_in('bar', matches)
-
+        self.assertIn("foobar", matches)
+        self.assertNotIn("foo", matches)
+        self.assertNotIn("bar", matches)
 
     def test_dict_key_completion_contexts(self):
         """Test expression contexts in which dict key completion occurs"""
         ip = get_ipython()
         complete = ip.Completer.complete
         d = {"abc": None}
         ip.user_ns["d"] = d
 
         class C:
             data = d
 
         ip.user_ns["C"] = C
         ip.user_ns["get"] = lambda: d
 
         def assert_no_completion(**kwargs):
             _, matches = complete(**kwargs)
-            nt.assert_not_in("abc", matches)
-            nt.assert_not_in("abc'", matches)
-            nt.assert_not_in("abc']", matches)
-            nt.assert_not_in("'abc'", matches)
-            nt.assert_not_in("'abc']", matches)
+            self.assertNotIn("abc", matches)
+            self.assertNotIn("abc'", matches)
+            self.assertNotIn("abc']", matches)
+            self.assertNotIn("'abc'", matches)
+            self.assertNotIn("'abc']", matches)
 
         def assert_completion(**kwargs):
             _, matches = complete(**kwargs)
-            nt.assert_in("'abc'", matches)
-            nt.assert_not_in("'abc']", matches)
+            self.assertIn("'abc'", matches)
+            self.assertNotIn("'abc']", matches)
 
         # no completion after string closed, even if reopened
         assert_no_completion(line_buffer="d['a'")
         assert_no_completion(line_buffer='d["a"')
         assert_no_completion(line_buffer="d['a' + ")
         assert_no_completion(line_buffer="d['a' + '")
 
         # completion in non-trivial expressions
         assert_completion(line_buffer="+ d[")
         assert_completion(line_buffer="(d[")
         assert_completion(line_buffer="C.data[")
 
         # greedy flag
         def assert_completion(**kwargs):
             _, matches = complete(**kwargs)
-            nt.assert_in("get()['abc']", matches)
+            self.assertIn("get()['abc']", matches)
 
         assert_no_completion(line_buffer="get()[")
         with greedy_completion():
             assert_completion(line_buffer="get()[")
             assert_completion(line_buffer="get()['")
             assert_completion(line_buffer="get()['a")
             assert_completion(line_buffer="get()['ab")
             assert_completion(line_buffer="get()['abc")
 
     def test_dict_key_completion_bytes(self):
         """Test handling of bytes in dict key completion"""
         ip = get_ipython()
         complete = ip.Completer.complete
 
         ip.user_ns["d"] = {"abc": None, b"abd": None}
 
         _, matches = complete(line_buffer="d[")
-        nt.assert_in("'abc'", matches)
-        nt.assert_in("b'abd'", matches)
+        self.assertIn("'abc'", matches)
+        self.assertIn("b'abd'", matches)
 
         if False:  # not currently implemented
             _, matches = complete(line_buffer="d[b")
-            nt.assert_in("b'abd'", matches)
-            nt.assert_not_in("b'abc'", matches)
+            self.assertIn("b'abd'", matches)
+            self.assertNotIn("b'abc'", matches)
 
             _, matches = complete(line_buffer="d[b'")
-            nt.assert_in("abd", matches)
-            nt.assert_not_in("abc", matches)
+            self.assertIn("abd", matches)
+            self.assertNotIn("abc", matches)
 
             _, matches = complete(line_buffer="d[B'")
-            nt.assert_in("abd", matches)
-            nt.assert_not_in("abc", matches)
+            self.assertIn("abd", matches)
+            self.assertNotIn("abc", matches)
 
             _, matches = complete(line_buffer="d['")
-            nt.assert_in("abc", matches)
-            nt.assert_not_in("abd", matches)
+            self.assertIn("abc", matches)
+            self.assertNotIn("abd", matches)
 
     def test_dict_key_completion_unicode_py3(self):
         """Test handling of unicode in dict key completion"""
         ip = get_ipython()
         complete = ip.Completer.complete
 
         ip.user_ns["d"] = {"a\u05d0": None}
 
         # query using escape
         if sys.platform != "win32":
             # Known failure on Windows
             _, matches = complete(line_buffer="d['a\\u05d0")
-            nt.assert_in("u05d0", matches)  # tokenized after \\
+            self.assertIn("u05d0", matches)  # tokenized after \\
 
         # query using character
         _, matches = complete(line_buffer="d['a\u05d0")
-        nt.assert_in("a\u05d0", matches)
+        self.assertIn("a\u05d0", matches)
 
         with greedy_completion():
             # query using escape
             _, matches = complete(line_buffer="d['a\\u05d0")
-            nt.assert_in("d['a\\u05d0']", matches)  # tokenized after \\
+            self.assertIn("d['a\\u05d0']", matches)  # tokenized after \\
 
             # query using character
             _, matches = complete(line_buffer="d['a\u05d0")
-            nt.assert_in("d['a\u05d0']", matches)
+            self.assertIn("d['a\u05d0']", matches)
 
     @dec.skip_without("numpy")
     def test_struct_array_key_completion(self):
         """Test dict key completion applies to numpy struct arrays"""
         import numpy
 
         ip = get_ipython()
         complete = ip.Completer.complete
         ip.user_ns["d"] = numpy.array([], dtype=[("hello", "f"), ("world", "f")])
         _, matches = complete(line_buffer="d['")
-        nt.assert_in("hello", matches)
-        nt.assert_in("world", matches)
+        self.assertIn("hello", matches)
+        self.assertIn("world", matches)
         # complete on the numpy struct itself
         dt = numpy.dtype(
             [("my_head", [("my_dt", ">u4"), ("my_df", ">u4")]), ("my_data", ">f4", 5)]
         )
         x = numpy.zeros(2, dtype=dt)
         ip.user_ns["d"] = x[1]
         _, matches = complete(line_buffer="d['")
-        nt.assert_in("my_head", matches)
-        nt.assert_in("my_data", matches)
+        self.assertIn("my_head", matches)
+        self.assertIn("my_data", matches)
         # complete on a nested level
         with greedy_completion():
             ip.user_ns["d"] = numpy.zeros(2, dtype=dt)
             _, matches = complete(line_buffer="d[1]['my_head']['")
-            nt.assert_true(any(["my_dt" in m for m in matches]))
-            nt.assert_true(any(["my_df" in m for m in matches]))
+            self.assertTrue(any(["my_dt" in m for m in matches]))
+            self.assertTrue(any(["my_df" in m for m in matches]))
 
     @dec.skip_without("pandas")
     def test_dataframe_key_completion(self):
         """Test dict key completion applies to pandas DataFrames"""
         import pandas
 
         ip = get_ipython()
         complete = ip.Completer.complete
         ip.user_ns["d"] = pandas.DataFrame({"hello": [1], "world": [2]})
         _, matches = complete(line_buffer="d['")
-        nt.assert_in("hello", matches)
-        nt.assert_in("world", matches)
+        self.assertIn("hello", matches)
+        self.assertIn("world", matches)
 
     def test_dict_key_completion_invalids(self):
         """Smoke test cases dict key completion can't handle"""
         ip = get_ipython()
         complete = ip.Completer.complete
 
         ip.user_ns["no_getitem"] = None
         ip.user_ns["no_keys"] = []
         ip.user_ns["cant_call_keys"] = dict
         ip.user_ns["empty"] = {}
         ip.user_ns["d"] = {"abc": 5}
 
         _, matches = complete(line_buffer="no_getitem['")
         _, matches = complete(line_buffer="no_keys['")
         _, matches = complete(line_buffer="cant_call_keys['")
         _, matches = complete(line_buffer="empty['")
         _, matches = complete(line_buffer="name_error['")
         _, matches = complete(line_buffer="d['\\")  # incomplete escape
 
     def test_object_key_completion(self):
         ip = get_ipython()
         ip.user_ns["key_completable"] = KeyCompletable(["qwerty", "qwick"])
 
         _, matches = ip.Completer.complete(line_buffer="key_completable['qw")
-        nt.assert_in("qwerty", matches)
-        nt.assert_in("qwick", matches)
+        self.assertIn("qwerty", matches)
+        self.assertIn("qwick", matches)
 
     def test_class_key_completion(self):
         ip = get_ipython()
         NamedInstanceClass("qwerty")
         NamedInstanceClass("qwick")
         ip.user_ns["named_instance_class"] = NamedInstanceClass
 
         _, matches = ip.Completer.complete(line_buffer="named_instance_class['qw")
-        nt.assert_in("qwerty", matches)
-        nt.assert_in("qwick", matches)
+        self.assertIn("qwerty", matches)
+        self.assertIn("qwick", matches)
 
     def test_tryimport(self):
         """
         Test that try-import don't crash on trailing dot, and import modules before
         """
         from IPython.core.completerlib import try_import
 
         assert try_import("IPython.")
 
     def test_aimport_module_completer(self):
         ip = get_ipython()
         _, matches = ip.complete("i", "%aimport i")
-        nt.assert_in("io", matches)
-        nt.assert_not_in("int", matches)
+        self.assertIn("io", matches)
+        self.assertNotIn("int", matches)
 
     def test_nested_import_module_completer(self):
         ip = get_ipython()
         _, matches = ip.complete(None, "import IPython.co", 17)
-        nt.assert_in("IPython.core", matches)
-        nt.assert_not_in("import IPython.core", matches)
-        nt.assert_not_in("IPython.display", matches)
+        self.assertIn("IPython.core", matches)
+        self.assertNotIn("import IPython.core", matches)
+        self.assertNotIn("IPython.display", matches)
 
     def test_import_module_completer(self):
         ip = get_ipython()
         _, matches = ip.complete("i", "import i")
-        nt.assert_in("io", matches)
-        nt.assert_not_in("int", matches)
+        self.assertIn("io", matches)
+        self.assertNotIn("int", matches)
 
     def test_from_module_completer(self):
         ip = get_ipython()
         _, matches = ip.complete("B", "from io import B", 16)
-        nt.assert_in("BytesIO", matches)
-        nt.assert_not_in("BaseException", matches)
+        self.assertIn("BytesIO", matches)
+        self.assertNotIn("BaseException", matches)
 
     def test_snake_case_completion(self):
         ip = get_ipython()
         ip.Completer.use_jedi = False
         ip.user_ns["some_three"] = 3
         ip.user_ns["some_four"] = 4
         _, matches = ip.complete("s_", "print(s_f")
-        nt.assert_in("some_three", matches)
-        nt.assert_in("some_four", matches)
+        self.assertIn("some_three", matches)
+        self.assertIn("some_four", matches)
 
     def test_mix_terms(self):
         ip = get_ipython()
         from textwrap import dedent
 
         ip.Completer.use_jedi = False
         ip.ex(
             dedent(
                 """
             class Test:
                 def meth(self, meth_arg1):
                     print("meth")
 
                 def meth_1(self, meth1_arg1, meth1_arg2):
                     print("meth1")
 
                 def meth_2(self, meth2_arg1, meth2_arg2):
                     print("meth2")
             test = Test()
             """
             )
         )
         _, matches = ip.complete(None, "test.meth(")
-        nt.assert_in("meth_arg1=", matches)
-        nt.assert_not_in("meth2_arg1=", matches)
+        self.assertIn("meth_arg1=", matches)
+        self.assertNotIn("meth2_arg1=", matches)

IPython/core/tests/test_completerlib.py

@@ -1,194 +1,192 b''
 # -*- coding: utf-8 -*-
 """Tests for completerlib.
 
 """
 
 #-----------------------------------------------------------------------------
 # Imports
 #-----------------------------------------------------------------------------
 
 import os
 import shutil
 import sys
 import tempfile
 import unittest
 from os.path import join
 
-import nose.tools as nt
-
 from IPython.core.completerlib import magic_run_completer, module_completion, try_import
 from IPython.utils.tempdir import TemporaryDirectory
 from IPython.testing.decorators import onlyif_unicode_paths
 
 
 class MockEvent(object):
     def __init__(self, line):
         self.line = line
 
 #-----------------------------------------------------------------------------
 # Test functions begin
 #-----------------------------------------------------------------------------
 class Test_magic_run_completer(unittest.TestCase):
     files = [u"aao.py", u"a.py", u"b.py", u"aao.txt"]
     dirs = [u"adir/", "bdir/"]
 
     def setUp(self):
         self.BASETESTDIR = tempfile.mkdtemp()
         for fil in self.files:
             with open(join(self.BASETESTDIR, fil), "w") as sfile:
                 sfile.write("pass\n")
         for d in self.dirs:
             os.mkdir(join(self.BASETESTDIR, d))
 
         self.oldpath = os.getcwd()
         os.chdir(self.BASETESTDIR)
 
     def tearDown(self):
         os.chdir(self.oldpath)
         shutil.rmtree(self.BASETESTDIR)
 
     def test_1(self):
         """Test magic_run_completer, should match two alternatives
         """
         event = MockEvent(u"%run a")
         mockself = None
         match = set(magic_run_completer(mockself, event))
         self.assertEqual(match, {u"a.py", u"aao.py", u"adir/"})
 
     def test_2(self):
         """Test magic_run_completer, should match one alternative
         """
         event = MockEvent(u"%run aa")
         mockself = None
         match = set(magic_run_completer(mockself, event))
         self.assertEqual(match, {u"aao.py"})
 
     def test_3(self):
         """Test magic_run_completer with unterminated " """
         event = MockEvent(u'%run "a')
         mockself = None
         match = set(magic_run_completer(mockself, event))
         self.assertEqual(match, {u"a.py", u"aao.py", u"adir/"})
 
     def test_completion_more_args(self):
         event = MockEvent(u'%run a.py ')
         match = set(magic_run_completer(None, event))
         self.assertEqual(match, set(self.files + self.dirs))
 
     def test_completion_in_dir(self):
         # Github issue #3459
         event = MockEvent(u'%run a.py {}'.format(join(self.BASETESTDIR, 'a')))
         print(repr(event.line))
         match = set(magic_run_completer(None, event))
         # We specifically use replace here rather than normpath, because
         # at one point there were duplicates 'adir' and 'adir/', and normpath
         # would hide the failure for that.
         self.assertEqual(match, {join(self.BASETESTDIR, f).replace('\\','/')
                             for f in (u'a.py', u'aao.py', u'aao.txt', u'adir/')})
 
 class Test_magic_run_completer_nonascii(unittest.TestCase):
     @onlyif_unicode_paths
     def setUp(self):
         self.BASETESTDIR = tempfile.mkdtemp()
         for fil in [u"aaø.py", u"a.py", u"b.py"]:
             with open(join(self.BASETESTDIR, fil), "w") as sfile:
                 sfile.write("pass\n")
         self.oldpath = os.getcwd()
         os.chdir(self.BASETESTDIR)
 
     def tearDown(self):
         os.chdir(self.oldpath)
         shutil.rmtree(self.BASETESTDIR)
 
     @onlyif_unicode_paths
     def test_1(self):
         """Test magic_run_completer, should match two alternatives
         """
         event = MockEvent(u"%run a")
         mockself = None
         match = set(magic_run_completer(mockself, event))
         self.assertEqual(match, {u"a.py", u"aaø.py"})
 
     @onlyif_unicode_paths
     def test_2(self):
         """Test magic_run_completer, should match one alternative
         """
         event = MockEvent(u"%run aa")
         mockself = None
         match = set(magic_run_completer(mockself, event))
         self.assertEqual(match, {u"aaø.py"})
 
     @onlyif_unicode_paths
     def test_3(self):
         """Test magic_run_completer with unterminated " """
         event = MockEvent(u'%run "a')
         mockself = None
         match = set(magic_run_completer(mockself, event))
         self.assertEqual(match, {u"a.py", u"aaø.py"})
 
 # module_completer:
 
 def test_import_invalid_module():
     """Testing of issue https://github.com/ipython/ipython/issues/1107"""
     invalid_module_names = {'foo-bar', 'foo:bar', '10foo'}
     valid_module_names = {'foobar'}
     with TemporaryDirectory() as tmpdir:
         sys.path.insert( 0, tmpdir )
         for name in invalid_module_names | valid_module_names:
             filename = os.path.join(tmpdir, name + '.py')
             open(filename, 'w').close()
 
         s = set( module_completion('import foo') )
         intersection = s.intersection(invalid_module_names)
-        nt.assert_equal(intersection, set())
+        assert intersection == set()
 
         assert valid_module_names.issubset(s), valid_module_names.intersection(s)
 
 
 def test_bad_module_all():
     """Test module with invalid __all__
 
     https://github.com/ipython/ipython/issues/9678
     """
     testsdir = os.path.dirname(__file__)
     sys.path.insert(0, testsdir)
     try:
-        results = module_completion('from bad_all import ')
-        nt.assert_in('puppies', results)
+        results = module_completion("from bad_all import ")
+        assert "puppies" in results
         for r in results:
-            nt.assert_is_instance(r, str)
+            assert isinstance(r, str)
 
         # bad_all doesn't contain submodules, but this completion
         # should finish without raising an exception:
         results = module_completion("import bad_all.")
-        nt.assert_equal(results, [])
+        assert results == []
     finally:
         sys.path.remove(testsdir)
 
 
 def test_module_without_init():
     """
     Test module without __init__.py.
     
     https://github.com/ipython/ipython/issues/11226
     """
     fake_module_name = "foo"
     with TemporaryDirectory() as tmpdir:
         sys.path.insert(0, tmpdir)
         try:
             os.makedirs(os.path.join(tmpdir, fake_module_name))
             s = try_import(mod=fake_module_name)
             assert s == []
         finally:
             sys.path.remove(tmpdir)
 
 
 def test_valid_exported_submodules():
     """
     Test checking exported (__all__) objects are submodules
     """
     results = module_completion("import os.pa")
     # ensure we get a valid submodule:
-    nt.assert_in("os.path", results)
+    assert "os.path" in results
     # ensure we don't get objects that aren't submodules:
-    nt.assert_not_in("os.pathconf", results)
+    assert "os.pathconf" not in results

IPython/core/tests/test_debugger.py

@@ -1,576 +1,574 b''
 """Tests for debugging machinery.
 """
 
 # Copyright (c) IPython Development Team.
 # Distributed under the terms of the Modified BSD License.
 
 import bdb
 import builtins
 import os
 import signal
 import subprocess
 import sys
 import time
 import warnings
 
 from subprocess import PIPE, CalledProcessError, check_output
 from tempfile import NamedTemporaryFile
 from textwrap import dedent
 from unittest.mock import patch
 
-import nose.tools as nt
-
 from IPython.core import debugger
 from IPython.testing import IPYTHON_TESTING_TIMEOUT_SCALE
 from IPython.testing.decorators import skip_win32
 
 #-----------------------------------------------------------------------------
 # Helper classes, from CPython's Pdb test suite
 #-----------------------------------------------------------------------------
 
 class _FakeInput(object):
     """
     A fake input stream for pdb's interactive debugger.  Whenever a
     line is read, print it (to simulate the user typing it), and then
     return it.  The set of lines to return is specified in the
     constructor; they should not have trailing newlines.
     """
     def __init__(self, lines):
         self.lines = iter(lines)
 
     def readline(self):
         line = next(self.lines)
         print(line)
         return line+'\n'
 
 class PdbTestInput(object):
     """Context manager that makes testing Pdb in doctests easier."""
 
     def __init__(self, input):
         self.input = input
 
     def __enter__(self):
         self.real_stdin = sys.stdin
         sys.stdin = _FakeInput(self.input)
 
     def __exit__(self, *exc):
         sys.stdin = self.real_stdin
 
 #-----------------------------------------------------------------------------
 # Tests
 #-----------------------------------------------------------------------------
 
 def test_longer_repr():
     from reprlib import repr as trepr
     
     a = '1234567890'* 7
     ar = "'1234567890123456789012345678901234567890123456789012345678901234567890'"
     a_trunc = "'123456789012...8901234567890'"
-    nt.assert_equal(trepr(a), a_trunc)
+    assert trepr(a) == a_trunc
     # The creation of our tracer modifies the repr module's repr function
     # in-place, since that global is used directly by the stdlib's pdb module.
     with warnings.catch_warnings():
         warnings.simplefilter('ignore', DeprecationWarning)
         debugger.Tracer()
-    nt.assert_equal(trepr(a), ar)
+    assert trepr(a) == ar
 
 def test_ipdb_magics():
     '''Test calling some IPython magics from ipdb.
 
     First, set up some test functions and classes which we can inspect.
 
     >>> class ExampleClass(object):
     ...    """Docstring for ExampleClass."""
     ...    def __init__(self):
     ...        """Docstring for ExampleClass.__init__"""
     ...        pass
     ...    def __str__(self):
     ...        return "ExampleClass()"
 
     >>> def example_function(x, y, z="hello"):
     ...     """Docstring for example_function."""
     ...     pass
 
     >>> old_trace = sys.gettrace()
 
     Create a function which triggers ipdb.
 
     >>> def trigger_ipdb():
     ...    a = ExampleClass()
     ...    debugger.Pdb().set_trace()
 
     >>> with PdbTestInput([
     ...    'pdef example_function',
     ...    'pdoc ExampleClass',
     ...    'up',
     ...    'down',
     ...    'list',
     ...    'pinfo a',
     ...    'll',
     ...    'continue',
     ... ]):
     ...     trigger_ipdb()
     --Return--
     None
     > <doctest ...>(3)trigger_ipdb()
           1 def trigger_ipdb():
           2    a = ExampleClass()
     ----> 3    debugger.Pdb().set_trace()
     <BLANKLINE>
     ipdb> pdef example_function
      example_function(x, y, z='hello')
      ipdb> pdoc ExampleClass
     Class docstring:
         Docstring for ExampleClass.
     Init docstring:
         Docstring for ExampleClass.__init__
     ipdb> up
     > <doctest ...>(11)<module>()
           7    'pinfo a',
           8    'll',
           9    'continue',
          10 ]):
     ---> 11     trigger_ipdb()
     <BLANKLINE>
     ipdb> down
     None
     > <doctest ...>(3)trigger_ipdb()
           1 def trigger_ipdb():
           2    a = ExampleClass()
     ----> 3    debugger.Pdb().set_trace()
     <BLANKLINE>
     ipdb> list
           1 def trigger_ipdb():
           2    a = ExampleClass()
     ----> 3    debugger.Pdb().set_trace()
     <BLANKLINE>
     ipdb> pinfo a
     Type:           ExampleClass
     String form:    ExampleClass()
     Namespace:      Local...
     Docstring:      Docstring for ExampleClass.
     Init docstring: Docstring for ExampleClass.__init__
     ipdb> ll
           1 def trigger_ipdb():
           2    a = ExampleClass()
     ----> 3    debugger.Pdb().set_trace()
     <BLANKLINE>
     ipdb> continue
     
     Restore previous trace function, e.g. for coverage.py    
     
     >>> sys.settrace(old_trace)
     '''
 
 def test_ipdb_magics2():
     '''Test ipdb with a very short function.
     
     >>> old_trace = sys.gettrace()
 
     >>> def bar():
     ...     pass
 
     Run ipdb.
 
     >>> with PdbTestInput([
     ...    'continue',
     ... ]):
     ...     debugger.Pdb().runcall(bar)
     > <doctest ...>(2)bar()
           1 def bar():
     ----> 2    pass
     <BLANKLINE>
     ipdb> continue
     
     Restore previous trace function, e.g. for coverage.py    
     
     >>> sys.settrace(old_trace)
     '''
 
 def can_quit():
     '''Test that quit work in ipydb
 
     >>> old_trace = sys.gettrace()
 
     >>> def bar():
     ...     pass
 
     >>> with PdbTestInput([
     ...    'quit',
     ... ]):
     ...     debugger.Pdb().runcall(bar)
     > <doctest ...>(2)bar()
             1 def bar():
     ----> 2    pass
     <BLANKLINE>
     ipdb> quit
 
     Restore previous trace function, e.g. for coverage.py
 
     >>> sys.settrace(old_trace)
     '''
 
 
 def can_exit():
     '''Test that quit work in ipydb
 
     >>> old_trace = sys.gettrace()
 
     >>> def bar():
     ...     pass
 
     >>> with PdbTestInput([
     ...    'exit',
     ... ]):
     ...     debugger.Pdb().runcall(bar)
     > <doctest ...>(2)bar()
             1 def bar():
     ----> 2    pass
     <BLANKLINE>
     ipdb> exit
 
     Restore previous trace function, e.g. for coverage.py
 
     >>> sys.settrace(old_trace)
     '''
 
 
 def test_interruptible_core_debugger():
     """The debugger can be interrupted.
 
     The presumption is there is some mechanism that causes a KeyboardInterrupt
     (this is implemented in ipykernel).  We want to ensure the
     KeyboardInterrupt cause debugging to cease.
     """
     def raising_input(msg="", called=[0]):
         called[0] += 1
         if called[0] == 1:
             raise KeyboardInterrupt()
         else:
             raise AssertionError("input() should only be called once!")
 
     with patch.object(builtins, "input", raising_input):
         debugger.InterruptiblePdb().set_trace()
         # The way this test will fail is by set_trace() never exiting,
         # resulting in a timeout by the test runner. The alternative
         # implementation would involve a subprocess, but that adds issues with
         # interrupting subprocesses that are rather complex, so it's simpler
         # just to do it this way.
 
 @skip_win32
 def test_xmode_skip():
     """that xmode skip frames
 
     Not as a doctest as pytest does not run doctests.
     """
     import pexpect
     env = os.environ.copy()
     env["IPY_TEST_SIMPLE_PROMPT"] = "1"
 
     child = pexpect.spawn(
         sys.executable, ["-m", "IPython", "--colors=nocolor"], env=env
     )
     child.timeout = 15 * IPYTHON_TESTING_TIMEOUT_SCALE
 
     child.expect("IPython")
     child.expect("\n")
     child.expect_exact("In [1]")
 
     block = dedent(
         """
     def f():
         __tracebackhide__ = True
         g()
 
     def g():
         raise ValueError
 
     f()
     """
     )
 
     for line in block.splitlines():
         child.sendline(line)
         child.expect_exact(line)
     child.expect_exact("skipping")
 
     block = dedent(
         """
     def f():
         __tracebackhide__ = True
         g()
 
     def g():
         from IPython.core.debugger import set_trace
         set_trace()
 
     f()
     """
     )
 
     for line in block.splitlines():
         child.sendline(line)
         child.expect_exact(line)
 
     child.expect("ipdb>")
     child.sendline("w")
     child.expect("hidden")
     child.expect("ipdb>")
     child.sendline("skip_hidden false")
     child.sendline("w")
     child.expect("__traceba")
     child.expect("ipdb>")
 
     child.close()
 
 
 skip_decorators_blocks = (
     """
     def helpers_helper():
         pass # should not stop here except breakpoint
     """,
     """
     def helper_1():
         helpers_helper() # should not stop here
     """,
     """
     def helper_2():
         pass # should not stop here
     """,
     """
     def pdb_skipped_decorator2(function):
         def wrapped_fn(*args, **kwargs):
             __debuggerskip__ = True
             helper_2()
             __debuggerskip__ = False
             result = function(*args, **kwargs)
             __debuggerskip__ = True
             helper_2()
             return result
         return wrapped_fn
     """,
     """
     def pdb_skipped_decorator(function):
         def wrapped_fn(*args, **kwargs):
             __debuggerskip__ = True
             helper_1()
             __debuggerskip__ = False
             result = function(*args, **kwargs)
             __debuggerskip__ = True
             helper_2()
             return result
         return wrapped_fn
     """,
     """
     @pdb_skipped_decorator
     @pdb_skipped_decorator2
     def bar(x, y):
         return x * y
     """,
     """import IPython.terminal.debugger as ipdb""",
     """
     def f():
         ipdb.set_trace()
         bar(3, 4)
     """,
     """
     f()
     """,
 )
 
 
 def _decorator_skip_setup():
     import pexpect
 
     env = os.environ.copy()
     env["IPY_TEST_SIMPLE_PROMPT"] = "1"
 
     child = pexpect.spawn(
         sys.executable, ["-m", "IPython", "--colors=nocolor"], env=env
     )
     child.timeout = 5 * IPYTHON_TESTING_TIMEOUT_SCALE
 
     child.expect("IPython")
     child.expect("\n")
 
     dedented_blocks = [dedent(b).strip() for b in skip_decorators_blocks]
     in_prompt_number = 1
     for cblock in dedented_blocks:
         child.expect_exact(f"In [{in_prompt_number}]:")
         in_prompt_number += 1
         for line in cblock.splitlines():
             child.sendline(line)
             child.expect_exact(line)
         child.sendline("")
     return child
 
 
 @skip_win32
 def test_decorator_skip():
     """test that decorator frames can be skipped."""
 
     child = _decorator_skip_setup()
 
     child.expect_exact("3     bar(3, 4)")
     child.expect("ipdb>")
 
     child.expect("ipdb>")
     child.sendline("step")
     child.expect_exact("step")
 
     child.expect_exact("1 @pdb_skipped_decorator")
 
     child.sendline("s")
     child.expect_exact("return x * y")
 
     child.close()
 
 
 @skip_win32
 def test_decorator_skip_disabled():
     """test that decorator frame skipping can be disabled"""
 
     child = _decorator_skip_setup()
 
     child.expect_exact("3     bar(3, 4)")
 
     for input_, expected in [
         ("skip_predicates debuggerskip False", ""),
         ("skip_predicates", "debuggerskip : False"),
         ("step", "---> 2     def wrapped_fn"),
         ("step", "----> 3         __debuggerskip__"),
         ("step", "----> 4         helper_1()"),
         ("step", "---> 1 def helper_1():"),
         ("next", "----> 2     helpers_helper()"),
         ("next", "--Return--"),
         ("next", "----> 5         __debuggerskip__ = False"),
     ]:
         child.expect("ipdb>")
         child.sendline(input_)
         child.expect_exact(input_)
         child.expect_exact(expected)
 
     child.close()
 
 
 @skip_win32
 def test_decorator_skip_with_breakpoint():
     """test that decorator frame skipping can be disabled"""
 
     import pexpect
 
     env = os.environ.copy()
     env["IPY_TEST_SIMPLE_PROMPT"] = "1"
 
     child = pexpect.spawn(
         sys.executable, ["-m", "IPython", "--colors=nocolor"], env=env
     )
     child.timeout = 5 * IPYTHON_TESTING_TIMEOUT_SCALE
 
     child.expect("IPython")
     child.expect("\n")
 
     ### we need a filename, so we need to exec the full block with a filename
     with NamedTemporaryFile(suffix=".py", dir=".", delete=True) as tf:
 
         name = tf.name[:-3].split("/")[-1]
         tf.write("\n".join([dedent(x) for x in skip_decorators_blocks[:-1]]).encode())
         tf.flush()
         codeblock = f"from {name} import f"
 
         dedented_blocks = [
             codeblock,
             "f()",
         ]
 
         in_prompt_number = 1
         for cblock in dedented_blocks:
             child.expect_exact(f"In [{in_prompt_number}]:")
             in_prompt_number += 1
             for line in cblock.splitlines():
                 child.sendline(line)
                 child.expect_exact(line)
             child.sendline("")
 
         # as the filename does not exists, we'll rely on the filename prompt
         child.expect_exact("47     bar(3, 4)")
 
         for input_, expected in [
             (f"b {name}.py:3", ""),
             ("step", "1---> 3     pass # should not stop here except"),
             ("step", "---> 38 @pdb_skipped_decorator"),
             ("continue", ""),
         ]:
             child.expect("ipdb>")
             child.sendline(input_)
             child.expect_exact(input_)
             child.expect_exact(expected)
 
     child.close()
 
 
 @skip_win32
 def test_where_erase_value():
     """Test that `where` does not access f_locals and erase values."""
     import pexpect
 
     env = os.environ.copy()
     env["IPY_TEST_SIMPLE_PROMPT"] = "1"
 
     child = pexpect.spawn(
         sys.executable, ["-m", "IPython", "--colors=nocolor"], env=env
     )
     child.timeout = 15 * IPYTHON_TESTING_TIMEOUT_SCALE
 
     child.expect("IPython")
     child.expect("\n")
     child.expect_exact("In [1]")
 
     block = dedent(
         """
     def simple_f():
          myvar = 1
          print(myvar)
          1/0
          print(myvar)
     simple_f()    """
     )
 
     for line in block.splitlines():
         child.sendline(line)
         child.expect_exact(line)
     child.expect_exact("ZeroDivisionError")
     child.expect_exact("In [2]:")
 
     child.sendline("%debug")
 
     ##
     child.expect("ipdb>")
 
     child.sendline("myvar")
     child.expect("1")
 
     ##
     child.expect("ipdb>")
 
     child.sendline("myvar = 2")
 
     ##
     child.expect_exact("ipdb>")
 
     child.sendline("myvar")
 
     child.expect_exact("2")
 
     ##
     child.expect("ipdb>")
     child.sendline("where")
 
     ##
     child.expect("ipdb>")
     child.sendline("myvar")
 
     child.expect_exact("2")
     child.expect("ipdb>")
 
     child.close()

IPython/core/tests/test_display.py

@@ -1,490 +1,511 b''
 # Copyright (c) IPython Development Team.
 # Distributed under the terms of the Modified BSD License.
 
 import json
 import os
 import warnings
 
 from unittest import mock
 
-import nose.tools as nt
+import pytest
 
 from IPython import display
 from IPython.core.getipython import get_ipython
 from IPython.utils.io import capture_output
 from IPython.utils.tempdir import NamedFileInTemporaryDirectory
 from IPython import paths as ipath
 from IPython.testing.tools import AssertNotPrints
 
 import IPython.testing.decorators as dec
 
 def test_image_size():
     """Simple test for display.Image(args, width=x,height=y)"""
     thisurl = 'http://www.google.fr/images/srpr/logo3w.png'
     img = display.Image(url=thisurl, width=200, height=200)
-    nt.assert_equal(u'<img src="%s" width="200" height="200"/>' % (thisurl), img._repr_html_())
+    assert '<img src="%s" width="200" height="200"/>' % (thisurl) == img._repr_html_()
     img = display.Image(url=thisurl, metadata={'width':200, 'height':200})
-    nt.assert_equal(u'<img src="%s" width="200" height="200"/>' % (thisurl), img._repr_html_())
+    assert '<img src="%s" width="200" height="200"/>' % (thisurl) == img._repr_html_()
     img = display.Image(url=thisurl, width=200)
-    nt.assert_equal(u'<img src="%s" width="200"/>' % (thisurl), img._repr_html_())
+    assert '<img src="%s" width="200"/>' % (thisurl) == img._repr_html_()
     img = display.Image(url=thisurl)
-    nt.assert_equal(u'<img src="%s"/>' % (thisurl), img._repr_html_())
+    assert '<img src="%s"/>' % (thisurl) == img._repr_html_()
     img = display.Image(url=thisurl, unconfined=True)
-    nt.assert_equal(u'<img src="%s" class="unconfined"/>' % (thisurl), img._repr_html_())
+    assert '<img src="%s" class="unconfined"/>' % (thisurl) == img._repr_html_()
 
 
 def test_image_mimes():
     fmt = get_ipython().display_formatter.format
     for format in display.Image._ACCEPTABLE_EMBEDDINGS:
         mime = display.Image._MIMETYPES[format]
         img = display.Image(b'garbage', format=format)
         data, metadata = fmt(img)
-        nt.assert_equal(sorted(data), sorted([mime, 'text/plain']))
+        assert sorted(data) == sorted([mime, "text/plain"])
 
 
 def test_geojson():
 
     gj = display.GeoJSON(data={
             "type": "Feature",
             "geometry": {
                 "type": "Point",
                 "coordinates": [-81.327, 296.038]
             },
             "properties": {
                 "name": "Inca City"
             }
         },
         url_template="http://s3-eu-west-1.amazonaws.com/whereonmars.cartodb.net/{basemap_id}/{z}/{x}/{y}.png",
         layer_options={
             "basemap_id": "celestia_mars-shaded-16k_global",
             "attribution": "Celestia/praesepe",
             "minZoom": 0,
             "maxZoom": 18,
-        })
-    nt.assert_equal(u'<IPython.core.display.GeoJSON object>', str(gj))
+        },
+    )
+    assert "<IPython.core.display.GeoJSON object>" == str(gj)
+
 
 def test_retina_png():
     here = os.path.dirname(__file__)
     img = display.Image(os.path.join(here, "2x2.png"), retina=True)
-    nt.assert_equal(img.height, 1)
-    nt.assert_equal(img.width, 1)
+    assert img.height == 1
+    assert img.width == 1
     data, md = img._repr_png_()
-    nt.assert_equal(md['width'], 1)
-    nt.assert_equal(md['height'], 1)
+    assert md["width"] == 1
+    assert md["height"] == 1
+
 
 def test_embed_svg_url():
     import gzip
     from io import BytesIO
     svg_data = b'<svg><circle x="0" y="0" r="1"/></svg>'
     url = 'http://test.com/circle.svg'
 
     gzip_svg = BytesIO()
     with gzip.open(gzip_svg, 'wb') as fp:
         fp.write(svg_data)
     gzip_svg = gzip_svg.getvalue()
 
     def mocked_urlopen(*args, **kwargs):
         class MockResponse:
             def __init__(self, svg):
                 self._svg_data = svg
                 self.headers = {'content-type': 'image/svg+xml'}
 
             def read(self):
                 return self._svg_data
 
         if args[0] == url:
             return MockResponse(svg_data)
         elif args[0] == url + "z":
             ret = MockResponse(gzip_svg)
             ret.headers["content-encoding"] = "gzip"
             return ret
         return MockResponse(None)
 
     with mock.patch('urllib.request.urlopen', side_effect=mocked_urlopen):
         svg = display.SVG(url=url)
-        nt.assert_true(svg._repr_svg_().startswith('<svg'))
-        svg = display.SVG(url=url + 'z')
-        nt.assert_true(svg._repr_svg_().startswith('<svg'))
+        assert svg._repr_svg_().startswith("<svg") is True
+        svg = display.SVG(url=url + "z")
+        assert svg._repr_svg_().startswith("<svg") is True
+
 
 def test_retina_jpeg():
     here = os.path.dirname(__file__)
     img = display.Image(os.path.join(here, "2x2.jpg"), retina=True)
-    nt.assert_equal(img.height, 1)
-    nt.assert_equal(img.width, 1)
+    assert img.height == 1
+    assert img.width == 1
     data, md = img._repr_jpeg_()
-    nt.assert_equal(md['width'], 1)
-    nt.assert_equal(md['height'], 1)
+    assert md["width"] == 1
+    assert md["height"] == 1
+
 
 def test_base64image():
     display.Image("iVBORw0KGgoAAAANSUhEUgAAAAEAAAABAQMAAAAl21bKAAAAA1BMVEUAAACnej3aAAAAAWJLR0QAiAUdSAAAAAlwSFlzAAALEwAACxMBAJqcGAAAAAd0SU1FB94BCRQnOqNu0b4AAAAKSURBVAjXY2AAAAACAAHiIbwzAAAAAElFTkSuQmCC")
 
 def test_image_filename_defaults():
     '''test format constraint, and validity of jpeg and png'''
     tpath = ipath.get_ipython_package_dir()
-    nt.assert_raises(ValueError, display.Image, filename=os.path.join(tpath, 'testing/tests/badformat.zip'),
-                     embed=True)
-    nt.assert_raises(ValueError, display.Image)
-    nt.assert_raises(ValueError, display.Image, data='this is not an image', format='badformat', embed=True)
-    # check both paths to allow packages to test at build and install time
+    pytest.raises(
+        ValueError,
+        display.Image,
+        filename=os.path.join(tpath, "testing/tests/badformat.zip"),
+        embed=True,
+    )
+    pytest.raises(ValueError, display.Image)
+    pytest.raises(
+        ValueError,
+        display.Image,
+        data="this is not an image",
+        format="badformat",
+        embed=True,
+    )
+    # check boths paths to allow packages to test at build and install time
     imgfile = os.path.join(tpath, 'core/tests/2x2.png')
     img = display.Image(filename=imgfile)
-    nt.assert_equal('png', img.format)
-    nt.assert_is_not_none(img._repr_png_())
-    img = display.Image(filename=os.path.join(tpath, 'testing/tests/logo.jpg'), embed=False)
-    nt.assert_equal('jpeg', img.format)
-    nt.assert_is_none(img._repr_jpeg_())
+    assert "png" == img.format
+    assert img._repr_png_() is not None
+    img = display.Image(
+        filename=os.path.join(tpath, "testing/tests/logo.jpg"), embed=False
+    )
+    assert "jpeg" == img.format
+    assert img._repr_jpeg_() is None
 
 def _get_inline_config():
     from matplotlib_inline.config import InlineBackend
     return InlineBackend.instance()
 
 
 @dec.skip_without("ipykernel")
 @dec.skip_without("matplotlib")
 def test_set_matplotlib_close():
     cfg = _get_inline_config()
     cfg.close_figures = False
     display.set_matplotlib_close()
     assert cfg.close_figures
     display.set_matplotlib_close(False)
     assert not cfg.close_figures
 
 _fmt_mime_map = {
     'png': 'image/png',
     'jpeg': 'image/jpeg',
     'pdf': 'application/pdf',
     'retina': 'image/png',
     'svg': 'image/svg+xml',
 }
 
 @dec.skip_without('matplotlib')
 def test_set_matplotlib_formats():
     from matplotlib.figure import Figure
     formatters = get_ipython().display_formatter.formatters
     for formats in [
         ('png',),
         ('pdf', 'svg'),
         ('jpeg', 'retina', 'png'),
         (),
     ]:
         active_mimes = {_fmt_mime_map[fmt] for fmt in formats}
         display.set_matplotlib_formats(*formats)
         for mime, f in formatters.items():
             if mime in active_mimes:
-                nt.assert_in(Figure, f)
+                assert Figure in f
             else:
-                nt.assert_not_in(Figure, f)
+                assert Figure not in f
 
 
 @dec.skip_without("ipykernel")
 @dec.skip_without("matplotlib")
 def test_set_matplotlib_formats_kwargs():
     from matplotlib.figure import Figure
     ip = get_ipython()
     cfg = _get_inline_config()
     cfg.print_figure_kwargs.update(dict(foo='bar'))
     kwargs = dict(dpi=150)
     display.set_matplotlib_formats('png', **kwargs)
     formatter = ip.display_formatter.formatters['image/png']
     f = formatter.lookup_by_type(Figure)
     formatter_kwargs = f.keywords
     expected = kwargs
     expected["base64"] = True
     expected["fmt"] = "png"
     expected.update(cfg.print_figure_kwargs)
-    nt.assert_equal(formatter_kwargs, expected)
+    assert formatter_kwargs == expected
 
 def test_display_available():
     """
     Test that display is available without import
 
     We don't really care if it's in builtin or anything else, but it should
     always be available.
     """
     ip = get_ipython()
     with AssertNotPrints('NameError'):
         ip.run_cell('display')
     try:
         ip.run_cell('del display')
     except NameError:
         pass # it's ok, it might be in builtins
     # even if deleted it should be back
     with AssertNotPrints('NameError'):
         ip.run_cell('display')
 
 def test_textdisplayobj_pretty_repr():
-     p = display.Pretty("This is a simple test")
-     nt.assert_equal(repr(p), '<IPython.core.display.Pretty object>')
-     nt.assert_equal(p.data, 'This is a simple test')
+    p = display.Pretty("This is a simple test")
+    assert repr(p) == "<IPython.core.display.Pretty object>"
+    assert p.data == "This is a simple test"
+
+    p._show_mem_addr = True
+    assert repr(p) == object.__repr__(p)
 
-     p._show_mem_addr = True
-     nt.assert_equal(repr(p), object.__repr__(p))
 
 def test_displayobject_repr():
-    h = display.HTML('<br />')
-    nt.assert_equal(repr(h), '<IPython.core.display.HTML object>')
+    h = display.HTML("<br />")
+    assert repr(h) == "<IPython.core.display.HTML object>"
     h._show_mem_addr = True
-    nt.assert_equal(repr(h), object.__repr__(h))
+    assert repr(h) == object.__repr__(h)
     h._show_mem_addr = False
-    nt.assert_equal(repr(h), '<IPython.core.display.HTML object>')
+    assert repr(h) == "<IPython.core.display.HTML object>"
 
-    j = display.Javascript('')
-    nt.assert_equal(repr(j), '<IPython.core.display.Javascript object>')
+    j = display.Javascript("")
+    assert repr(j) == "<IPython.core.display.Javascript object>"
     j._show_mem_addr = True
-    nt.assert_equal(repr(j), object.__repr__(j))
+    assert repr(j) == object.__repr__(j)
     j._show_mem_addr = False
-    nt.assert_equal(repr(j), '<IPython.core.display.Javascript object>')
+    assert repr(j) == "<IPython.core.display.Javascript object>"
 
 @mock.patch('warnings.warn')
 def test_encourage_iframe_over_html(m_warn):
     display.HTML()
     m_warn.assert_not_called()
 
     display.HTML('<br />')
     m_warn.assert_not_called()
 
     display.HTML('<html><p>Lots of content here</p><iframe src="http://a.com"></iframe>')
     m_warn.assert_not_called()
 
     display.HTML('<iframe src="http://a.com"></iframe>')
     m_warn.assert_called_with('Consider using IPython.display.IFrame instead')
 
     m_warn.reset_mock()
     display.HTML('<IFRAME SRC="http://a.com"></IFRAME>')
     m_warn.assert_called_with('Consider using IPython.display.IFrame instead')
 
 def test_progress():
     p = display.ProgressBar(10)
-    nt.assert_in('0/10',repr(p))
-    p.html_width = '100%'
+    assert "0/10" in repr(p)
+    p.html_width = "100%"
     p.progress = 5
-    nt.assert_equal(p._repr_html_(), "<progress style='width:100%' max='10' value='5'></progress>")
+    assert (
+        p._repr_html_() == "<progress style='width:100%' max='10' value='5'></progress>"
+    )
+
 
 def test_progress_iter():
     with capture_output(display=False) as captured:
         for i in display.ProgressBar(5):
             out = captured.stdout
-            nt.assert_in('{0}/5'.format(i), out)
+            assert "{0}/5".format(i) in out
     out = captured.stdout
-    nt.assert_in('5/5', out)
+    assert "5/5" in out
+
 
 def test_json():
     d = {'a': 5}
     lis = [d]
     metadata = [
         {'expanded': False, 'root': 'root'},
         {'expanded': True,  'root': 'root'},
         {'expanded': False, 'root': 'custom'},
         {'expanded': True,  'root': 'custom'},
     ]
     json_objs = [
         display.JSON(d),
         display.JSON(d, expanded=True),
         display.JSON(d, root='custom'),
         display.JSON(d, expanded=True, root='custom'),
     ]
     for j, md in zip(json_objs, metadata):
-        nt.assert_equal(j._repr_json_(), (d, md))
+        assert j._repr_json_() == (d, md)
 
     with warnings.catch_warnings(record=True) as w:
         warnings.simplefilter("always")
         j = display.JSON(json.dumps(d))
-        nt.assert_equal(len(w), 1)
-        nt.assert_equal(j._repr_json_(), (d, metadata[0]))
+        assert len(w) == 1
+        assert j._repr_json_() == (d, metadata[0])
 
     json_objs = [
         display.JSON(lis),
         display.JSON(lis, expanded=True),
         display.JSON(lis, root='custom'),
         display.JSON(lis, expanded=True, root='custom'),
     ]
     for j, md in zip(json_objs, metadata):
-        nt.assert_equal(j._repr_json_(), (lis, md))
+        assert j._repr_json_() == (lis, md)
 
     with warnings.catch_warnings(record=True) as w:
         warnings.simplefilter("always")
         j = display.JSON(json.dumps(lis))
-        nt.assert_equal(len(w), 1)
-        nt.assert_equal(j._repr_json_(), (lis, metadata[0]))
+        assert len(w) == 1
+        assert j._repr_json_() == (lis, metadata[0])
+
 
 def test_video_embedding():
     """use a tempfile, with dummy-data, to ensure that video embedding doesn't crash"""
     v = display.Video("http://ignored")
     assert not v.embed
     html = v._repr_html_()
-    nt.assert_not_in('src="data:', html)
-    nt.assert_in('src="http://ignored"', html)
+    assert 'src="data:' not in html
+    assert 'src="http://ignored"' in html
 
-    with nt.assert_raises(ValueError):
+    with pytest.raises(ValueError):
         v = display.Video(b'abc')
 
     with NamedFileInTemporaryDirectory('test.mp4') as f:
         f.write(b'abc')
         f.close()
 
         v = display.Video(f.name)
         assert not v.embed
         html = v._repr_html_()
-        nt.assert_not_in('src="data:', html)
+        assert 'src="data:' not in html
 
         v = display.Video(f.name, embed=True)
         html = v._repr_html_()
-        nt.assert_in('src="data:video/mp4;base64,YWJj"',html)
+        assert 'src="data:video/mp4;base64,YWJj"' in html
 
         v = display.Video(f.name, embed=True, mimetype='video/other')
         html = v._repr_html_()
-        nt.assert_in('src="data:video/other;base64,YWJj"',html)
+        assert 'src="data:video/other;base64,YWJj"' in html
 
         v = display.Video(b'abc', embed=True, mimetype='video/mp4')
         html = v._repr_html_()
-        nt.assert_in('src="data:video/mp4;base64,YWJj"',html)
+        assert 'src="data:video/mp4;base64,YWJj"' in html
 
         v = display.Video(u'YWJj', embed=True, mimetype='video/xyz')
         html = v._repr_html_()
-        nt.assert_in('src="data:video/xyz;base64,YWJj"',html)
+        assert 'src="data:video/xyz;base64,YWJj"' in html
 
 def test_html_metadata():
     s = "<h1>Test</h1>"
     h = display.HTML(s, metadata={"isolated": True})
-    nt.assert_equal(h._repr_html_(), (s, {"isolated": True}))
+    assert h._repr_html_() == (s, {"isolated": True})
+
 
 def test_display_id():
     ip = get_ipython()
     with mock.patch.object(ip.display_pub, 'publish') as pub:
         handle = display.display('x')
-        nt.assert_is(handle, None)
+        assert handle is None
         handle = display.display('y', display_id='secret')
-        nt.assert_is_instance(handle, display.DisplayHandle)
+        assert isinstance(handle, display.DisplayHandle)
         handle2 = display.display('z', display_id=True)
-        nt.assert_is_instance(handle2, display.DisplayHandle)
-    nt.assert_not_equal(handle.display_id, handle2.display_id)
+        assert isinstance(handle2, display.DisplayHandle)
+    assert handle.display_id != handle2.display_id
 
-    nt.assert_equal(pub.call_count, 3)
+    assert pub.call_count == 3
     args, kwargs = pub.call_args_list[0]
-    nt.assert_equal(args, ())
-    nt.assert_equal(kwargs, {
+    assert args == ()
+    assert kwargs == {
         'data': {
             'text/plain': repr('x')
         },
         'metadata': {},
-    })
+    }
     args, kwargs = pub.call_args_list[1]
-    nt.assert_equal(args, ())
-    nt.assert_equal(kwargs, {
+    assert args == ()
+    assert kwargs == {
         'data': {
             'text/plain': repr('y')
         },
         'metadata': {},
         'transient': {
             'display_id': handle.display_id,
         },
-    })
+    }
     args, kwargs = pub.call_args_list[2]
-    nt.assert_equal(args, ())
-    nt.assert_equal(kwargs, {
+    assert args == ()
+    assert kwargs == {
         'data': {
             'text/plain': repr('z')
         },
         'metadata': {},
         'transient': {
             'display_id': handle2.display_id,
         },
-    })
+    }
 
 
 def test_update_display():
     ip = get_ipython()
     with mock.patch.object(ip.display_pub, 'publish') as pub:
-        with nt.assert_raises(TypeError):
+        with pytest.raises(TypeError):
             display.update_display('x')
         display.update_display('x', display_id='1')
         display.update_display('y', display_id='2')
     args, kwargs = pub.call_args_list[0]
-    nt.assert_equal(args, ())
-    nt.assert_equal(kwargs, {
+    assert args == ()
+    assert kwargs == {
         'data': {
             'text/plain': repr('x')
         },
         'metadata': {},
         'transient': {
             'display_id': '1',
         },
         'update': True,
-    })
+    }
     args, kwargs = pub.call_args_list[1]
-    nt.assert_equal(args, ())
-    nt.assert_equal(kwargs, {
+    assert args == ()
+    assert kwargs == {
         'data': {
             'text/plain': repr('y')
         },
         'metadata': {},
         'transient': {
             'display_id': '2',
         },
         'update': True,
-    })
+    }
 
 
 def test_display_handle():
     ip = get_ipython()
     handle = display.DisplayHandle()
-    nt.assert_is_instance(handle.display_id, str)
-    handle = display.DisplayHandle('my-id')
-    nt.assert_equal(handle.display_id, 'my-id')
-    with mock.patch.object(ip.display_pub, 'publish') as pub:
-        handle.display('x')
-        handle.update('y')
+    assert isinstance(handle.display_id, str)
+    handle = display.DisplayHandle("my-id")
+    assert handle.display_id == "my-id"
+    with mock.patch.object(ip.display_pub, "publish") as pub:
+        handle.display("x")
+        handle.update("y")
 
     args, kwargs = pub.call_args_list[0]
-    nt.assert_equal(args, ())
-    nt.assert_equal(kwargs, {
+    assert args == ()
+    assert kwargs == {
         'data': {
             'text/plain': repr('x')
         },
         'metadata': {},
         'transient': {
             'display_id': handle.display_id,
         }
-    })
+    }
     args, kwargs = pub.call_args_list[1]
-    nt.assert_equal(args, ())
-    nt.assert_equal(kwargs, {
+    assert args == ()
+    assert kwargs == {
         'data': {
             'text/plain': repr('y')
         },
         'metadata': {},
         'transient': {
             'display_id': handle.display_id,
         },
         'update': True,
-    })
+    }
 
 
 def test_image_alt_tag():
     """Simple test for display.Image(args, alt=x,)"""
     thisurl = "http://example.com/image.png"
     img = display.Image(url=thisurl, alt="an image")
-    nt.assert_equal(u'<img src="%s" alt="an image"/>' % (thisurl), img._repr_html_())
+    assert '<img src="%s" alt="an image"/>' % (thisurl) == img._repr_html_()
     img = display.Image(url=thisurl, unconfined=True, alt="an image")
-    nt.assert_equal(
-        u'<img src="%s" class="unconfined" alt="an image"/>' % (thisurl),
-        img._repr_html_(),
+    assert (
+        '<img src="%s" class="unconfined" alt="an image"/>' % (thisurl)
+        == img._repr_html_()
     )
     img = display.Image(url=thisurl, alt='>"& <')
-    nt.assert_equal(
-        u'<img src="%s" alt="&gt;&quot;&amp; &lt;"/>' % (thisurl), img._repr_html_()
-    )
+    assert '<img src="%s" alt="&gt;&quot;&amp; &lt;"/>' % (thisurl) == img._repr_html_()
 
     img = display.Image(url=thisurl, metadata={"alt": "an image"})
-    nt.assert_equal(img.alt, "an image")
-
+    assert img.alt == "an image"
     here = os.path.dirname(__file__)
     img = display.Image(os.path.join(here, "2x2.png"), alt="an image")
-    nt.assert_equal(img.alt, "an image")
+    assert img.alt == "an image"
     _, md = img._repr_png_()
-    nt.assert_equal(md["alt"], "an image")
+    assert md["alt"] == "an image"
 
 
[e-mail](FileNotFoundError)
 def test_image_bad_filename_raises_proper_exception():
-    display.Image("/this/file/does/not/exist/")._repr_png_()
+    with pytest.raises(FileNotFoundError):
+        display.Image("/this/file/does/not/exist/")._repr_png_()

IPython/core/tests/test_events.py

@@ -1,92 +1,91 b''
 import unittest
 from unittest.mock import Mock
-import nose.tools as nt
 
 from IPython.core import events
 import IPython.testing.tools as tt
 
 
 @events._define_event
 def ping_received():
     pass
 
 
 @events._define_event
 def event_with_argument(argument):
     pass
 
 
 class CallbackTests(unittest.TestCase):
     def setUp(self):
         self.em = events.EventManager(get_ipython(),
                                       {'ping_received': ping_received,
                                        'event_with_argument': event_with_argument})
 
     def test_register_unregister(self):
         cb = Mock()
 
         self.em.register('ping_received', cb)        
         self.em.trigger('ping_received')
         self.assertEqual(cb.call_count, 1)
         
         self.em.unregister('ping_received', cb)
         self.em.trigger('ping_received')
         self.assertEqual(cb.call_count, 1)
 
     def test_bare_function_missed_unregister(self):
         def cb1():
             ...
 
         def cb2():
             ...
 
-        self.em.register('ping_received', cb1)
-        nt.assert_raises(ValueError, self.em.unregister, 'ping_received', cb2)
-        self.em.unregister('ping_received', cb1)
+        self.em.register("ping_received", cb1)
+        self.assertRaises(ValueError, self.em.unregister, "ping_received", cb2)
+        self.em.unregister("ping_received", cb1)
 
     def test_cb_error(self):
         cb = Mock(side_effect=ValueError)
         self.em.register('ping_received', cb)
         with tt.AssertPrints("Error in callback"):
             self.em.trigger('ping_received')
 
     def test_cb_keyboard_interrupt(self):
         cb = Mock(side_effect=KeyboardInterrupt)
         self.em.register('ping_received', cb)
         with tt.AssertPrints("Error in callback"):
             self.em.trigger('ping_received')
 
     def test_unregister_during_callback(self):
         invoked = [False] * 3
         
         def func1(*_):
             invoked[0] = True
             self.em.unregister('ping_received', func1)
             self.em.register('ping_received', func3)
 
         def func2(*_):
             invoked[1] = True
             self.em.unregister('ping_received', func2)
 
         def func3(*_):
             invoked[2] = True
             
         self.em.register('ping_received', func1)
         self.em.register('ping_received', func2)
 
         self.em.trigger('ping_received')
         self.assertEqual([True, True, False], invoked)
         self.assertEqual([func3], self.em.callbacks['ping_received'])
     
     def test_ignore_event_arguments_if_no_argument_required(self):
         call_count = [0]
         def event_with_no_argument():
             call_count[0] += 1
 
         self.em.register('event_with_argument', event_with_no_argument)
         self.em.trigger('event_with_argument', 'the argument')
         self.assertEqual(call_count[0], 1)
         
         self.em.unregister('event_with_argument', event_with_no_argument)
         self.em.trigger('ping_received')
         self.assertEqual(call_count[0], 1)

IPython/core/tests/test_extension.py

@@ -1,96 +1,94 b''
 import os.path
 
-import nose.tools as nt
-
 import IPython.testing.tools as tt
 from IPython.utils.syspathcontext import prepended_to_syspath
 from IPython.utils.tempdir import TemporaryDirectory
 
 ext1_content = """
 def load_ipython_extension(ip):
     print("Running ext1 load")
 
 def unload_ipython_extension(ip):
     print("Running ext1 unload")
 """
 
 ext2_content = """
 def load_ipython_extension(ip):
     print("Running ext2 load")
 """
 
 ext3_content = """
 def load_ipython_extension(ip):
     ip2 = get_ipython()
     print(ip is ip2)
 """
 
 def test_extension_loading():
     em = get_ipython().extension_manager
     with TemporaryDirectory() as td:
         ext1 = os.path.join(td, 'ext1.py')
         with open(ext1, 'w') as f:
             f.write(ext1_content)
         
         ext2 = os.path.join(td, 'ext2.py')
         with open(ext2, 'w') as f:
             f.write(ext2_content)
         
         with prepended_to_syspath(td):
             assert 'ext1' not in em.loaded
             assert 'ext2' not in em.loaded
             
             # Load extension
             with tt.AssertPrints("Running ext1 load"):
                 assert em.load_extension('ext1') is None
             assert 'ext1' in em.loaded
             
             # Should refuse to load it again
             with tt.AssertNotPrints("Running ext1 load"):
                 assert em.load_extension('ext1') == 'already loaded'
             
             # Reload
             with tt.AssertPrints("Running ext1 unload"):
                 with tt.AssertPrints("Running ext1 load", suppress=False):
                     em.reload_extension('ext1')
             
             # Unload
             with tt.AssertPrints("Running ext1 unload"):
                 assert em.unload_extension('ext1') is None
             
             # Can't unload again
             with tt.AssertNotPrints("Running ext1 unload"):
                 assert em.unload_extension('ext1') == 'not loaded'
             assert em.unload_extension('ext2') == 'not loaded'
             
             # Load extension 2
             with tt.AssertPrints("Running ext2 load"):
                 assert em.load_extension('ext2') is None
             
             # Can't unload this
             assert em.unload_extension('ext2') == 'no unload function'
             
             # But can reload it
             with tt.AssertPrints("Running ext2 load"):
                 em.reload_extension('ext2')
 
 
 def test_extension_builtins():
     em = get_ipython().extension_manager
     with TemporaryDirectory() as td:
         ext3 = os.path.join(td, 'ext3.py')
         with open(ext3, 'w') as f:
             f.write(ext3_content)
         
         assert 'ext3' not in em.loaded
         
         with prepended_to_syspath(td):
             # Load extension
             with tt.AssertPrints("True"):
                 assert em.load_extension('ext3') is None
             assert 'ext3' in em.loaded
 
 
 def test_non_extension():
     em = get_ipython().extension_manager
-    nt.assert_equal(em.load_extension('sys'), "no load function")
+    assert em.load_extension("sys") == "no load function"

IPython/core/tests/test_formatters.py

@@ -1,542 +1,544 b''
 """Tests for the Formatters."""
 
 import warnings
 from math import pi
 
 try:
     import numpy
 except:
     numpy = None
-import nose.tools as nt
+import pytest
 
 from IPython import get_ipython
 from traitlets.config import Config
 from IPython.core.formatters import (
     PlainTextFormatter, HTMLFormatter, PDFFormatter, _mod_name_key,
     DisplayFormatter, JSONFormatter,
 )
 from IPython.utils.io import capture_output
 
 class A(object):
     def __repr__(self):
         return 'A()'
 
 class B(A):
     def __repr__(self):
         return 'B()'
 
 class C:
     pass
 
 class BadRepr(object):
     def __repr__(self):
         raise ValueError("bad repr")
 
 class BadPretty(object):
     _repr_pretty_ = None
 
 class GoodPretty(object):
     def _repr_pretty_(self, pp, cycle):
         pp.text('foo')
 
     def __repr__(self):
         return 'GoodPretty()'
 
 def foo_printer(obj, pp, cycle):
     pp.text('foo')
 
 def test_pretty():
     f = PlainTextFormatter()
     f.for_type(A, foo_printer)
     assert f(A()) == "foo"
     assert f(B()) == "B()"
     assert f(GoodPretty()) == "foo"
     # Just don't raise an exception for the following:
     f(BadPretty())
 
     f.pprint = False
     assert f(A()) == "A()"
     assert f(B()) == "B()"
     assert f(GoodPretty()) == "GoodPretty()"
 
 
 def test_deferred():
     f = PlainTextFormatter()
 
 def test_precision():
     """test various values for float_precision."""
     f = PlainTextFormatter()
     assert f(pi) == repr(pi)
     f.float_precision = 0
     if numpy:
         po = numpy.get_printoptions()
         assert po["precision"] == 0
     assert f(pi) == "3"
     f.float_precision = 2
     if numpy:
         po = numpy.get_printoptions()
         assert po["precision"] == 2
     assert f(pi) == "3.14"
     f.float_precision = "%g"
     if numpy:
         po = numpy.get_printoptions()
         assert po["precision"] == 2
     assert f(pi) == "3.14159"
     f.float_precision = "%e"
     assert f(pi) == "3.141593e+00"
     f.float_precision = ""
     if numpy:
         po = numpy.get_printoptions()
         assert po["precision"] == 8
     assert f(pi) == repr(pi)
 
 
 def test_bad_precision():
     """test various invalid values for float_precision."""
     f = PlainTextFormatter()
     def set_fp(p):
-        f.float_precision=p
-    nt.assert_raises(ValueError, set_fp, '%')
-    nt.assert_raises(ValueError, set_fp, '%.3f%i')
-    nt.assert_raises(ValueError, set_fp, 'foo')
-    nt.assert_raises(ValueError, set_fp, -1)
+        f.float_precision = p
+
+    pytest.raises(ValueError, set_fp, "%")
+    pytest.raises(ValueError, set_fp, "%.3f%i")
+    pytest.raises(ValueError, set_fp, "foo")
+    pytest.raises(ValueError, set_fp, -1)
 
 def test_for_type():
     f = PlainTextFormatter()
     
     # initial return, None
-    nt.assert_is(f.for_type(C, foo_printer), None)
+    assert f.for_type(C, foo_printer) is None
     # no func queries
-    nt.assert_is(f.for_type(C), foo_printer)
+    assert f.for_type(C) is foo_printer
     # shouldn't change anything
-    nt.assert_is(f.for_type(C), foo_printer)
+    assert f.for_type(C) is foo_printer
     # None should do the same
-    nt.assert_is(f.for_type(C, None), foo_printer)
-    nt.assert_is(f.for_type(C, None), foo_printer)
+    assert f.for_type(C, None) is foo_printer
+    assert f.for_type(C, None) is foo_printer
 
 def test_for_type_string():
     f = PlainTextFormatter()
     
     type_str = '%s.%s' % (C.__module__, 'C')
     
     # initial return, None
-    nt.assert_is(f.for_type(type_str, foo_printer), None)
+    assert f.for_type(type_str, foo_printer) is None
     # no func queries
-    nt.assert_is(f.for_type(type_str), foo_printer)
-    nt.assert_in(_mod_name_key(C), f.deferred_printers)
-    nt.assert_is(f.for_type(C), foo_printer)
-    nt.assert_not_in(_mod_name_key(C), f.deferred_printers)
-    nt.assert_in(C, f.type_printers)
+    assert f.for_type(type_str) is foo_printer
+    assert _mod_name_key(C) in f.deferred_printers
+    assert f.for_type(C) is foo_printer
+    assert _mod_name_key(C) not in f.deferred_printers
+    assert C in f.type_printers
 
 def test_for_type_by_name():
     f = PlainTextFormatter()
     
     mod = C.__module__
     
     # initial return, None
-    nt.assert_is(f.for_type_by_name(mod, 'C', foo_printer), None)
+    assert f.for_type_by_name(mod, "C", foo_printer) is None
     # no func queries
-    nt.assert_is(f.for_type_by_name(mod, 'C'), foo_printer)
+    assert f.for_type_by_name(mod, "C") is foo_printer
     # shouldn't change anything
-    nt.assert_is(f.for_type_by_name(mod, 'C'), foo_printer)
+    assert f.for_type_by_name(mod, "C") is foo_printer
     # None should do the same
-    nt.assert_is(f.for_type_by_name(mod, 'C', None), foo_printer)
-    nt.assert_is(f.for_type_by_name(mod, 'C', None), foo_printer)
+    assert f.for_type_by_name(mod, "C", None) is foo_printer
+    assert f.for_type_by_name(mod, "C", None) is foo_printer
+
 
 def test_lookup():
     f = PlainTextFormatter()
     
     f.for_type(C, foo_printer)
-    nt.assert_is(f.lookup(C()), foo_printer)
-    with nt.assert_raises(KeyError):
+    assert f.lookup(C()) is foo_printer
+    with pytest.raises(KeyError):
         f.lookup(A())
 
 def test_lookup_string():
     f = PlainTextFormatter()
     type_str = '%s.%s' % (C.__module__, 'C')
     
     f.for_type(type_str, foo_printer)
-    nt.assert_is(f.lookup(C()), foo_printer)
+    assert f.lookup(C()) is foo_printer
     # should move from deferred to imported dict
-    nt.assert_not_in(_mod_name_key(C), f.deferred_printers)
-    nt.assert_in(C, f.type_printers)
+    assert _mod_name_key(C) not in f.deferred_printers
+    assert C in f.type_printers
 
 def test_lookup_by_type():
     f = PlainTextFormatter()
     f.for_type(C, foo_printer)
-    nt.assert_is(f.lookup_by_type(C), foo_printer)
-    with nt.assert_raises(KeyError):
+    assert f.lookup_by_type(C) is foo_printer
+    with pytest.raises(KeyError):
         f.lookup_by_type(A)
 
 def test_lookup_by_type_string():
     f = PlainTextFormatter()
     type_str = '%s.%s' % (C.__module__, 'C')
     f.for_type(type_str, foo_printer)
     
     # verify insertion
-    nt.assert_in(_mod_name_key(C), f.deferred_printers)
-    nt.assert_not_in(C, f.type_printers)
+    assert _mod_name_key(C) in f.deferred_printers
+    assert C not in f.type_printers
     
-    nt.assert_is(f.lookup_by_type(type_str), foo_printer)
+    assert f.lookup_by_type(type_str) is foo_printer
     # lookup by string doesn't cause import
-    nt.assert_in(_mod_name_key(C), f.deferred_printers)
-    nt.assert_not_in(C, f.type_printers)
+    assert _mod_name_key(C) in f.deferred_printers
+    assert C not in f.type_printers
     
-    nt.assert_is(f.lookup_by_type(C), foo_printer)
+    assert f.lookup_by_type(C) is foo_printer
     # should move from deferred to imported dict
-    nt.assert_not_in(_mod_name_key(C), f.deferred_printers)
-    nt.assert_in(C, f.type_printers)
+    assert _mod_name_key(C) not in f.deferred_printers
+    assert C in f.type_printers
 
 def test_in_formatter():
     f = PlainTextFormatter()
     f.for_type(C, foo_printer)
     type_str = '%s.%s' % (C.__module__, 'C')
-    nt.assert_in(C, f)
-    nt.assert_in(type_str, f)
+    assert C in f
+    assert type_str in f
 
 def test_string_in_formatter():
     f = PlainTextFormatter()
     type_str = '%s.%s' % (C.__module__, 'C')
     f.for_type(type_str, foo_printer)
-    nt.assert_in(type_str, f)
-    nt.assert_in(C, f)
+    assert type_str in f
+    assert C in f
 
 def test_pop():
     f = PlainTextFormatter()
     f.for_type(C, foo_printer)
-    nt.assert_is(f.lookup_by_type(C), foo_printer)
-    nt.assert_is(f.pop(C, None), foo_printer)
+    assert f.lookup_by_type(C) is foo_printer
+    assert f.pop(C, None) is foo_printer
     f.for_type(C, foo_printer)
-    nt.assert_is(f.pop(C), foo_printer)
-    with nt.assert_raises(KeyError):
+    assert f.pop(C) is foo_printer
+    with pytest.raises(KeyError):
         f.lookup_by_type(C)
-    with nt.assert_raises(KeyError):
+    with pytest.raises(KeyError):
         f.pop(C)
-    with nt.assert_raises(KeyError):
+    with pytest.raises(KeyError):
         f.pop(A)
-    nt.assert_is(f.pop(A, None), None)
+    assert f.pop(A, None) is None
 
 def test_pop_string():
     f = PlainTextFormatter()
     type_str = '%s.%s' % (C.__module__, 'C')
     
-    with nt.assert_raises(KeyError):
+    with pytest.raises(KeyError):
         f.pop(type_str)
     
     f.for_type(type_str, foo_printer)
     f.pop(type_str)
-    with nt.assert_raises(KeyError):
+    with pytest.raises(KeyError):
         f.lookup_by_type(C)
-    with nt.assert_raises(KeyError):
+    with pytest.raises(KeyError):
         f.pop(type_str)
 
     f.for_type(C, foo_printer)
-    nt.assert_is(f.pop(type_str, None), foo_printer)
-    with nt.assert_raises(KeyError):
+    assert f.pop(type_str, None) is foo_printer
+    with pytest.raises(KeyError):
         f.lookup_by_type(C)
-    with nt.assert_raises(KeyError):
+    with pytest.raises(KeyError):
         f.pop(type_str)
-    nt.assert_is(f.pop(type_str, None), None)
+    assert f.pop(type_str, None) is None
     
 
 def test_error_method():
     f = HTMLFormatter()
     class BadHTML(object):
         def _repr_html_(self):
             raise ValueError("Bad HTML")
     bad = BadHTML()
     with capture_output() as captured:
         result = f(bad)
-    nt.assert_is(result, None)
-    nt.assert_in("Traceback", captured.stdout)
-    nt.assert_in("Bad HTML", captured.stdout)
-    nt.assert_in("_repr_html_", captured.stdout)
+    assert result is None
+    assert "Traceback" in captured.stdout
+    assert "Bad HTML" in captured.stdout
+    assert "_repr_html_" in captured.stdout
 
 def test_nowarn_notimplemented():
     f = HTMLFormatter()
     class HTMLNotImplemented(object):
         def _repr_html_(self):
             raise NotImplementedError
     h = HTMLNotImplemented()
     with capture_output() as captured:
         result = f(h)
-    nt.assert_is(result, None)
+    assert result is None
     assert "" == captured.stderr
     assert "" == captured.stdout
 
 
 def test_warn_error_for_type():
     f = HTMLFormatter()
     f.for_type(int, lambda i: name_error)
     with capture_output() as captured:
         result = f(5)
-    nt.assert_is(result, None)
-    nt.assert_in("Traceback", captured.stdout)
-    nt.assert_in("NameError", captured.stdout)
-    nt.assert_in("name_error", captured.stdout)
+    assert result is None
+    assert "Traceback" in captured.stdout
+    assert "NameError" in captured.stdout
+    assert "name_error" in captured.stdout
 
 def test_error_pretty_method():
     f = PlainTextFormatter()
     class BadPretty(object):
         def _repr_pretty_(self):
             return "hello"
     bad = BadPretty()
     with capture_output() as captured:
         result = f(bad)
-    nt.assert_is(result, None)
-    nt.assert_in("Traceback", captured.stdout)
-    nt.assert_in("_repr_pretty_", captured.stdout)
-    nt.assert_in("given", captured.stdout)
-    nt.assert_in("argument", captured.stdout)
+    assert result is None
+    assert "Traceback" in captured.stdout
+    assert "_repr_pretty_" in captured.stdout
+    assert "given" in captured.stdout
+    assert "argument" in captured.stdout
 
 
 def test_bad_repr_traceback():
     f = PlainTextFormatter()
     bad = BadRepr()
     with capture_output() as captured:
         result = f(bad)
     # catches error, returns None
-    nt.assert_is(result, None)
-    nt.assert_in("Traceback", captured.stdout)
-    nt.assert_in("__repr__", captured.stdout)
-    nt.assert_in("ValueError", captured.stdout)
+    assert result is None
+    assert "Traceback" in captured.stdout
+    assert "__repr__" in captured.stdout
+    assert "ValueError" in captured.stdout
 
 
 class MakePDF(object):
     def _repr_pdf_(self):
         return 'PDF'
 
 def test_pdf_formatter():
     pdf = MakePDF()
     f = PDFFormatter()
     assert f(pdf) == "PDF"
 
 
 def test_print_method_bound():
     f = HTMLFormatter()
     class MyHTML(object):
         def _repr_html_(self):
             return "hello"
     with capture_output() as captured:
         result = f(MyHTML)
-    nt.assert_is(result, None)
-    nt.assert_not_in("FormatterWarning", captured.stderr)
+    assert result is None
+    assert "FormatterWarning" not in captured.stderr
 
     with capture_output() as captured:
         result = f(MyHTML())
     assert result == "hello"
     assert captured.stderr == ""
 
 
 def test_print_method_weird():
 
     class TextMagicHat(object):
         def __getattr__(self, key):
             return key
 
     f = HTMLFormatter()
 
     text_hat = TextMagicHat()
     assert text_hat._repr_html_ == "_repr_html_"
     with capture_output() as captured:
         result = f(text_hat)
     
-    nt.assert_is(result, None)
-    nt.assert_not_in("FormatterWarning", captured.stderr)
+    assert result is None
+    assert "FormatterWarning" not in captured.stderr
 
     class CallableMagicHat(object):
         def __getattr__(self, key):
             return lambda : key
     
     call_hat = CallableMagicHat()
     with capture_output() as captured:
         result = f(call_hat)
 
     assert result is None
 
     class BadReprArgs(object):
         def _repr_html_(self, extra, args):
             return "html"
     
     bad = BadReprArgs()
     with capture_output() as captured:
         result = f(bad)
     
-    nt.assert_is(result, None)
-    nt.assert_not_in("FormatterWarning", captured.stderr)
+    assert result is None
+    assert "FormatterWarning" not in captured.stderr
 
 
 def test_format_config():
     """config objects don't pretend to support fancy reprs with lazy attrs"""
     f = HTMLFormatter()
     cfg = Config()
     with capture_output() as captured:
         result = f(cfg)
-    nt.assert_is(result, None)
+    assert result is None
     assert captured.stderr == ""
 
     with capture_output() as captured:
         result = f(Config)
-    nt.assert_is(result, None)
+    assert result is None
     assert captured.stderr == ""
 
 
 def test_pretty_max_seq_length():
     f = PlainTextFormatter(max_seq_length=1)
     lis = list(range(3))
     text = f(lis)
     assert text == "[0, ...]"
     f.max_seq_length = 0
     text = f(lis)
     assert text == "[0, 1, 2]"
     text = f(list(range(1024)))
     lines = text.splitlines()
     assert len(lines) == 1024
 
 
 def test_ipython_display_formatter():
     """Objects with _ipython_display_ defined bypass other formatters"""
     f = get_ipython().display_formatter
     catcher = []
     class SelfDisplaying(object):
         def _ipython_display_(self):
             catcher.append(self)
 
     class NotSelfDisplaying(object):
         def __repr__(self):
             return "NotSelfDisplaying"
         
         def _ipython_display_(self):
             raise NotImplementedError
     
     save_enabled = f.ipython_display_formatter.enabled
     f.ipython_display_formatter.enabled = True
     
     yes = SelfDisplaying()
     no = NotSelfDisplaying()
 
     d, md = f.format(no)
     assert d == {"text/plain": repr(no)}
     assert md == {}
     assert catcher == []
 
     d, md = f.format(yes)
     assert d == {}
     assert md == {}
     assert catcher == [yes]
 
     f.ipython_display_formatter.enabled = save_enabled
 
 
 def test_json_as_string_deprecated():
     class JSONString(object):
         def _repr_json_(self):
             return '{}'
     
     f = JSONFormatter()
     with warnings.catch_warnings(record=True) as w:
         d = f(JSONString())
     assert d == {}
     assert len(w) == 1
 
 
 def test_repr_mime():
     class HasReprMime(object):
         def _repr_mimebundle_(self, include=None, exclude=None):
             return {
                 'application/json+test.v2': {
                     'x': 'y'
                 },
                 'plain/text' : '<HasReprMime>',
                 'image/png' : 'i-overwrite'
             }
 
         def _repr_png_(self):
             return 'should-be-overwritten'
         def _repr_html_(self):
             return '<b>hi!</b>'
     
     f = get_ipython().display_formatter
     html_f = f.formatters['text/html']
     save_enabled = html_f.enabled
     html_f.enabled = True
     obj = HasReprMime()
     d, md = f.format(obj)
     html_f.enabled = save_enabled
 
     assert sorted(d) == [
         "application/json+test.v2",
         "image/png",
         "plain/text",
         "text/html",
         "text/plain",
     ]
     assert md == {}
 
     d, md = f.format(obj, include={"image/png"})
     assert list(d.keys()) == [
         "image/png"
     ], "Include should filter out even things from repr_mimebundle"
 
     assert d["image/png"] == "i-overwrite", "_repr_mimebundle_ take precedence"
 
 
 def test_pass_correct_include_exclude():
     class Tester(object):
 
         def __init__(self, include=None, exclude=None):
             self.include = include
             self.exclude = exclude
 
         def _repr_mimebundle_(self, include, exclude, **kwargs):
             if include and (include != self.include):
                 raise ValueError('include got modified: display() may be broken.')
             if exclude and (exclude != self.exclude):
                 raise ValueError('exclude got modified: display() may be broken.')
 
             return None
 
     include = {'a', 'b', 'c'}
     exclude = {'c', 'e' , 'f'}
 
     f = get_ipython().display_formatter
     f.format(Tester(include=include, exclude=exclude), include=include, exclude=exclude)
     f.format(Tester(exclude=exclude), exclude=exclude)
     f.format(Tester(include=include), include=include)
 
 
 def test_repr_mime_meta():
     class HasReprMimeMeta(object):
         def _repr_mimebundle_(self, include=None, exclude=None):
             data = {
                 'image/png': 'base64-image-data',
             }
             metadata = {
                 'image/png': {
                     'width': 5,
                     'height': 10,
                 }
             }
             return (data, metadata)
     
     f = get_ipython().display_formatter
     obj = HasReprMimeMeta()
     d, md = f.format(obj)
     assert sorted(d) == ["image/png", "text/plain"]
     assert md == {
         "image/png": {
             "width": 5,
             "height": 10,
         }
     }
 
 
 def test_repr_mime_failure():
     class BadReprMime(object):
         def _repr_mimebundle_(self, include=None, exclude=None):
             raise RuntimeError
 
     f = get_ipython().display_formatter
     obj = BadReprMime()
     d, md = f.format(obj)
     assert "text/plain" in d

IPython/core/tests/test_handlers.py

@@ -1,94 +1,91 b''
 """Tests for input handlers.
 """
 #-----------------------------------------------------------------------------
 # Module imports
 #-----------------------------------------------------------------------------
 
-# third party
-import nose.tools as nt
-
 # our own packages
 from IPython.core import autocall
 from IPython.testing import tools as tt
 
 #-----------------------------------------------------------------------------
 # Globals
 #-----------------------------------------------------------------------------
 
 # Get the public instance of IPython
 
 failures = []
 num_tests = 0
 
 #-----------------------------------------------------------------------------
 # Test functions
 #-----------------------------------------------------------------------------
 
 class CallableIndexable(object):
     def __getitem__(self, idx): return True
     def __call__(self, *args, **kws): return True
 
 
 class Autocallable(autocall.IPyAutocall):
     def __call__(self):
         return "called"
 
 
 def run(tests):
     """Loop through a list of (pre, post) inputs, where pre is the string
     handed to ipython, and post is how that string looks after it's been
     transformed (i.e. ipython's notion of _i)"""
     tt.check_pairs(ip.prefilter_manager.prefilter_lines, tests)
 
 
 def test_handlers():
     call_idx = CallableIndexable()
     ip.user_ns['call_idx'] = call_idx
 
     # For many of the below, we're also checking that leading whitespace
     # turns off the esc char, which it should unless there is a continuation
     # line.
     run(
         [('"no change"', '"no change"'),             # normal
          (u"lsmagic",     "get_ipython().run_line_magic('lsmagic', '')"),   # magic
          #("a = b # PYTHON-MODE", '_i'),          # emacs -- avoids _in cache
          ])
 
     # Objects which are instances of IPyAutocall are *always* autocalled
     autocallable = Autocallable()
     ip.user_ns['autocallable'] = autocallable
 
     # auto
     ip.magic('autocall 0')
     # Only explicit escapes or instances of IPyAutocallable should get
     # expanded
     run([
         ('len "abc"',       'len "abc"'),
         ('autocallable',    'autocallable()'),
         # Don't add extra brackets (gh-1117)
         ('autocallable()',    'autocallable()'),
         ])
     ip.magic('autocall 1')
     run([
         ('len "abc"', 'len("abc")'),
         ('len "abc";', 'len("abc");'),  # ; is special -- moves out of parens
         # Autocall is turned off if first arg is [] and the object
         # is both callable and indexable.  Like so:
         ('len [1,2]', 'len([1,2])'),      # len doesn't support __getitem__...
         ('call_idx [1]', 'call_idx [1]'), # call_idx *does*..
         ('call_idx 1', 'call_idx(1)'),
         ('len', 'len'), # only at 2 does it auto-call on single args
         ])
     ip.magic('autocall 2')
     run([
         ('len "abc"', 'len("abc")'),
         ('len "abc";', 'len("abc");'),
         ('len [1,2]', 'len([1,2])'),
         ('call_idx [1]', 'call_idx [1]'),
         ('call_idx 1', 'call_idx(1)'),
         # This is what's different:
         ('len', 'len()'), # only at 2 does it auto-call on single args
         ])
     ip.magic('autocall 1')
 
-    nt.assert_equal(failures, [])
+    assert failures == []

IPython/core/tests/test_history.py

@@ -1,223 +1,218 b''
 # coding: utf-8
 """Tests for the IPython tab-completion machinery.
 """
 #-----------------------------------------------------------------------------
 # Module imports
 #-----------------------------------------------------------------------------
 
 # stdlib
 import io
 from pathlib import Path
 import sys
 import tempfile
 from datetime import datetime
 import sqlite3
 
-# third party
-import nose.tools as nt
-
 # our own packages
 from traitlets.config.loader import Config
 from IPython.utils.tempdir import TemporaryDirectory
 from IPython.core.history import HistoryManager, extract_hist_ranges
 from IPython.testing.decorators import skipif
 
 def test_proper_default_encoding():
-    nt.assert_equal(sys.getdefaultencoding(), "utf-8")
+    assert sys.getdefaultencoding() == "utf-8"
 
 @skipif(sqlite3.sqlite_version_info > (3,24,0))
 def test_history():
     ip = get_ipython()
     with TemporaryDirectory() as tmpdir:
         tmp_path = Path(tmpdir)
         hist_manager_ori = ip.history_manager
         hist_file = tmp_path / "history.sqlite"
         try:
             ip.history_manager = HistoryManager(shell=ip, hist_file=hist_file)
-            hist = [u'a=1', u'def f():\n    test = 1\n    return test', u"b='€Æ¾÷ß'"]
+            hist = ["a=1", "def f():\n    test = 1\n    return test", "b='€Æ¾÷ß'"]
             for i, h in enumerate(hist, start=1):
                 ip.history_manager.store_inputs(i, h)
 
             ip.history_manager.db_log_output = True
             # Doesn't match the input, but we'll just check it's stored.
             ip.history_manager.output_hist_reprs[3] = "spam"
             ip.history_manager.store_output(3)
 
-            nt.assert_equal(ip.history_manager.input_hist_raw, [''] + hist)
+            assert ip.history_manager.input_hist_raw == [""] + hist
 
             # Detailed tests for _get_range_session
             grs = ip.history_manager._get_range_session
-            nt.assert_equal(list(grs(start=2,stop=-1)), list(zip([0], [2], hist[1:-1])))
-            nt.assert_equal(list(grs(start=-2)), list(zip([0,0], [2,3], hist[-2:])))
-            nt.assert_equal(list(grs(output=True)), list(zip([0,0,0], [1,2,3], zip(hist, [None,None,'spam']))))
+            assert list(grs(start=2, stop=-1)) == list(zip([0], [2], hist[1:-1]))
+            assert list(grs(start=-2)) == list(zip([0, 0], [2, 3], hist[-2:]))
+            assert list(grs(output=True)) == list(
+                zip([0, 0, 0], [1, 2, 3], zip(hist, [None, None, "spam"]))
+            )
 
             # Check whether specifying a range beyond the end of the current
             # session results in an error (gh-804)
             ip.magic('%hist 2-500')
 
             # Check that we can write non-ascii characters to a file
             ip.magic("%%hist -f %s" % (tmp_path / "test1"))
             ip.magic("%%hist -pf %s" % (tmp_path / "test2"))
             ip.magic("%%hist -nf %s" % (tmp_path / "test3"))
             ip.magic("%%save %s 1-10" % (tmp_path / "test4"))
 
             # New session
             ip.history_manager.reset()
-            newcmds = [u"z=5",
-                       u"class X(object):\n    pass",
-                       u"k='p'",
-                       u"z=5"]
+            newcmds = ["z=5", "class X(object):\n    pass", "k='p'", "z=5"]
             for i, cmd in enumerate(newcmds, start=1):
                 ip.history_manager.store_inputs(i, cmd)
             gothist = ip.history_manager.get_range(start=1, stop=4)
-            nt.assert_equal(list(gothist), list(zip([0,0,0],[1,2,3], newcmds)))
+            assert list(gothist) == list(zip([0, 0, 0], [1, 2, 3], newcmds))
             # Previous session:
             gothist = ip.history_manager.get_range(-1, 1, 4)
-            nt.assert_equal(list(gothist), list(zip([1,1,1],[1,2,3], hist)))
+            assert list(gothist) == list(zip([1, 1, 1], [1, 2, 3], hist))
 
             newhist = [(2, i, c) for (i, c) in enumerate(newcmds, 1)]
 
             # Check get_hist_tail
             gothist = ip.history_manager.get_tail(5, output=True,
                                                     include_latest=True)
             expected = [(1, 3, (hist[-1], "spam"))] \
                 + [(s, n, (c, None)) for (s, n, c) in newhist]
-            nt.assert_equal(list(gothist), expected)
+            assert list(gothist) == expected
 
             gothist = ip.history_manager.get_tail(2)
             expected = newhist[-3:-1]
-            nt.assert_equal(list(gothist), expected)
+            assert list(gothist) == expected
 
             # Check get_hist_search
 
             gothist = ip.history_manager.search("*test*")
-            nt.assert_equal(list(gothist), [(1,2,hist[1])] )
+            assert list(gothist) == [(1, 2, hist[1])]
 
             gothist = ip.history_manager.search("*=*")
-            nt.assert_equal(list(gothist),
-                            [(1, 1, hist[0]),
-                             (1, 2, hist[1]),
-                             (1, 3, hist[2]),
-                             newhist[0],
-                             newhist[2],
-                             newhist[3]])
+            assert list(gothist) == [
+                (1, 1, hist[0]),
+                (1, 2, hist[1]),
+                (1, 3, hist[2]),
+                newhist[0],
+                newhist[2],
+                newhist[3],
+            ]
 
             gothist = ip.history_manager.search("*=*", n=4)
-            nt.assert_equal(list(gothist),
-                            [(1, 3, hist[2]),
-                             newhist[0],
-                             newhist[2],
-                             newhist[3]])
+            assert list(gothist) == [
+                (1, 3, hist[2]),
+                newhist[0],
+                newhist[2],
+                newhist[3],
+            ]
 
             gothist = ip.history_manager.search("*=*", unique=True)
-            nt.assert_equal(list(gothist),
-                            [(1, 1, hist[0]),
-                             (1, 2, hist[1]),
-                             (1, 3, hist[2]),
-                             newhist[2],
-                             newhist[3]])
+            assert list(gothist) == [
+                (1, 1, hist[0]),
+                (1, 2, hist[1]),
+                (1, 3, hist[2]),
+                newhist[2],
+                newhist[3],
+            ]
 
             gothist = ip.history_manager.search("*=*", unique=True, n=3)
-            nt.assert_equal(list(gothist),
-                            [(1, 3, hist[2]),
-                             newhist[2],
-                             newhist[3]])
+            assert list(gothist) == [(1, 3, hist[2]), newhist[2], newhist[3]]
 
             gothist = ip.history_manager.search("b*", output=True)
-            nt.assert_equal(list(gothist), [(1,3,(hist[2],"spam"))] )
+            assert list(gothist) == [(1, 3, (hist[2], "spam"))]
 
             # Cross testing: check that magic %save can get previous session.
             testfilename = (tmp_path / "test.py").resolve()
             ip.magic("save " + str(testfilename) + " ~1/1-3")
-            with io.open(testfilename, encoding='utf-8') as testfile:
-                nt.assert_equal(testfile.read(),
-                                        u"# coding: utf-8\n" + u"\n".join(hist)+u"\n")
+            with io.open(testfilename, encoding="utf-8") as testfile:
+                assert testfile.read() == "# coding: utf-8\n" + "\n".join(hist) + "\n"
 
             # Duplicate line numbers - check that it doesn't crash, and
             # gets a new session
             ip.history_manager.store_inputs(1, "rogue")
             ip.history_manager.writeout_cache()
-            nt.assert_equal(ip.history_manager.session_number, 3)
+            assert ip.history_manager.session_number == 3
         finally:
             # Ensure saving thread is shut down before we try to clean up the files
             ip.history_manager.save_thread.stop()
             # Forcibly close database rather than relying on garbage collection
             ip.history_manager.db.close()
             # Restore history manager
             ip.history_manager = hist_manager_ori
 
 
 def test_extract_hist_ranges():
     instr = "1 2/3 ~4/5-6 ~4/7-~4/9 ~9/2-~7/5 ~10/"
     expected = [(0, 1, 2),  # 0 == current session
                 (2, 3, 4),
                 (-4, 5, 7),
                 (-4, 7, 10),
                 (-9, 2, None),  # None == to end
                 (-8, 1, None),
                 (-7, 1, 6),
                 (-10, 1, None)]
     actual = list(extract_hist_ranges(instr))
-    nt.assert_equal(actual, expected)
+    assert actual == expected
 
 
 def test_extract_hist_ranges_empty_str():
     instr = ""
     expected = [(0, 1, None)]  # 0 == current session, None == to end
     actual = list(extract_hist_ranges(instr))
-    nt.assert_equal(actual, expected)
+    assert actual == expected
 
 
 def test_magic_rerun():
     """Simple test for %rerun (no args -> rerun last line)"""
     ip = get_ipython()
     ip.run_cell("a = 10", store_history=True)
     ip.run_cell("a += 1", store_history=True)
-    nt.assert_equal(ip.user_ns["a"], 11)
+    assert ip.user_ns["a"] == 11
     ip.run_cell("%rerun", store_history=True)
-    nt.assert_equal(ip.user_ns["a"], 12)
+    assert ip.user_ns["a"] == 12
 
 def test_timestamp_type():
     ip = get_ipython()
     info = ip.history_manager.get_session_info()
-    nt.assert_true(isinstance(info[1], datetime))
+    assert isinstance(info[1], datetime)
 
 def test_hist_file_config():
     cfg = Config()
     tfile = tempfile.NamedTemporaryFile(delete=False)
     cfg.HistoryManager.hist_file = Path(tfile.name)
     try:
         hm = HistoryManager(shell=get_ipython(), config=cfg)
-        nt.assert_equal(hm.hist_file, cfg.HistoryManager.hist_file)
+        assert hm.hist_file == cfg.HistoryManager.hist_file
     finally:
         try:
             Path(tfile.name).unlink()
         except OSError:
             # same catch as in testing.tools.TempFileMixin
             # On Windows, even though we close the file, we still can't
             # delete it.  I have no clue why
             pass
 
 def test_histmanager_disabled():
     """Ensure that disabling the history manager doesn't create a database."""
     cfg = Config()
     cfg.HistoryAccessor.enabled = False
 
     ip = get_ipython()
     with TemporaryDirectory() as tmpdir:
         hist_manager_ori = ip.history_manager
         hist_file = Path(tmpdir) / "history.sqlite"
         cfg.HistoryManager.hist_file = hist_file
         try:
             ip.history_manager = HistoryManager(shell=ip, config=cfg)
-            hist = [u'a=1', u'def f():\n    test = 1\n    return test', u"b='€Æ¾÷ß'"]
+            hist = ["a=1", "def f():\n    test = 1\n    return test", "b='€Æ¾÷ß'"]
             for i, h in enumerate(hist, start=1):
                 ip.history_manager.store_inputs(i, h)
-            nt.assert_equal(ip.history_manager.input_hist_raw, [''] + hist)
+            assert ip.history_manager.input_hist_raw == [""] + hist
             ip.history_manager.reset()
             ip.history_manager.end_session()
         finally:
             ip.history_manager = hist_manager_ori
 
     # hist_file should not be created
-    nt.assert_false(hist_file.exists())
+    assert hist_file.exists() is False

IPython/core/tests/test_hooks.py

@@ -1,80 +1,78 b''
 # -*- coding: utf-8 -*-
 """Tests for CommandChainDispatcher."""
 
 
 #-----------------------------------------------------------------------------
 # Imports
 #-----------------------------------------------------------------------------
 
-import nose.tools as nt
 from IPython.core.error import TryNext
 from IPython.core.hooks import CommandChainDispatcher
 
 #-----------------------------------------------------------------------------
 # Local utilities
 #-----------------------------------------------------------------------------
 
 # Define two classes, one which succeeds and one which raises TryNext. Each
 # sets the attribute `called` to True when it is called.
 class Okay(object):
     def __init__(self, message):
         self.message = message
         self.called = False
     def __call__(self):
         self.called = True
         return self.message
 
 class Fail(object):
     def __init__(self, message):
         self.message = message
         self.called = False
     def __call__(self):
         self.called = True
         raise TryNext(self.message)
 
 #-----------------------------------------------------------------------------
 # Test functions
 #-----------------------------------------------------------------------------
 
 def test_command_chain_dispatcher_ff():
     """Test two failing hooks"""
-    fail1 = Fail(u'fail1')
-    fail2 = Fail(u'fail2')
-    dp = CommandChainDispatcher([(0, fail1),
-                                 (10, fail2)])
+    fail1 = Fail("fail1")
+    fail2 = Fail("fail2")
+    dp = CommandChainDispatcher([(0, fail1), (10, fail2)])
 
     try:
         dp()
     except TryNext as e:
-        nt.assert_equal(str(e), u'fail2')
+        assert str(e) == "fail2"
     else:
         assert False, "Expected exception was not raised."
 
-    nt.assert_true(fail1.called)
-    nt.assert_true(fail2.called)
+    assert fail1.called is True
+    assert fail2.called is True
 
 def test_command_chain_dispatcher_fofo():
     """Test a mixture of failing and succeeding hooks."""
-    fail1 = Fail(u'fail1')
-    fail2 = Fail(u'fail2')
-    okay1 = Okay(u'okay1')
-    okay2 = Okay(u'okay2')
+    fail1 = Fail("fail1")
+    fail2 = Fail("fail2")
+    okay1 = Okay("okay1")
+    okay2 = Okay("okay2")
 
     dp = CommandChainDispatcher([(0, fail1),
                                  # (5, okay1), # add this later
                                  (10, fail2),
                                  (15, okay2)])
     dp.add(okay1, 5)
 
-    nt.assert_equal(dp(), u'okay1')
+    assert dp() == "okay1"
 
-    nt.assert_true(fail1.called)
-    nt.assert_true(okay1.called)
-    nt.assert_false(fail2.called)
-    nt.assert_false(okay2.called)
+    assert fail1.called is True
+    assert okay1.called is True
+    assert fail2.called is False
+    assert okay2.called is False
 
 def test_command_chain_dispatcher_eq_priority():
     okay1 = Okay(u'okay1')
     okay2 = Okay(u'okay2')
     dp = CommandChainDispatcher([(1, okay1)])
     dp.add(okay2, 1)

IPython/core/tests/test_inputsplitter.py

@@ -1,639 +1,638 b''
 # -*- coding: utf-8 -*-
 """Tests for the inputsplitter module."""
 
 
 # Copyright (c) IPython Development Team.
 # Distributed under the terms of the Modified BSD License.
 
 import unittest
 import sys
 
-import nose.tools as nt
-
 from IPython.core import inputsplitter as isp
 from IPython.core.inputtransformer import InputTransformer
 from IPython.core.tests.test_inputtransformer import syntax, syntax_ml
 from IPython.testing import tools as tt
 
 #-----------------------------------------------------------------------------
 # Semi-complete examples (also used as tests)
 #-----------------------------------------------------------------------------
 
 # Note: at the bottom, there's a slightly more complete version of this that
 # can be useful during development of code here.
 
 def mini_interactive_loop(input_func):
     """Minimal example of the logic of an interactive interpreter loop.
 
     This serves as an example, and it is used by the test system with a fake
     raw_input that simulates interactive input."""
 
     from IPython.core.inputsplitter import InputSplitter
 
     isp = InputSplitter()
     # In practice, this input loop would be wrapped in an outside loop to read
     # input indefinitely, until some exit/quit command was issued.  Here we
     # only illustrate the basic inner loop.
     while isp.push_accepts_more():
         indent = ' '*isp.get_indent_spaces()
         prompt = '>>> ' + indent
         line = indent + input_func(prompt)
         isp.push(line)
 
     # Here we just return input so we can use it in a test suite, but a real
     # interpreter would instead send it for execution somewhere.
     src = isp.source_reset()
     #print 'Input source was:\n', src  # dbg
     return src
 
 #-----------------------------------------------------------------------------
 # Test utilities, just for local use
 #-----------------------------------------------------------------------------
 
 def assemble(block):
     """Assemble a block into multi-line sub-blocks."""
     return ['\n'.join(sub_block)+'\n' for sub_block in block]
 
 
 def pseudo_input(lines):
     """Return a function that acts like raw_input but feeds the input list."""
     ilines = iter(lines)
     def raw_in(prompt):
         try:
             return next(ilines)
         except StopIteration:
             return ''
     return raw_in
 
 #-----------------------------------------------------------------------------
 # Tests
 #-----------------------------------------------------------------------------
 def test_spaces():
     tests = [('', 0),
              (' ', 1),
              ('\n', 0),
              (' \n', 1),
              ('x', 0),
              (' x', 1),
              ('  x',2),
              ('    x',4),
              # Note: tabs are counted as a single whitespace!
              ('\tx', 1),
              ('\t x', 2),
              ]
     tt.check_pairs(isp.num_ini_spaces, tests)
 
 
 def test_remove_comments():
     tests = [('text', 'text'),
              ('text # comment', 'text '),
              ('text # comment\n', 'text \n'),
              ('text # comment \n', 'text \n'),
              ('line # c \nline\n','line \nline\n'),
              ('line # c \nline#c2  \nline\nline #c\n\n',
               'line \nline\nline\nline \n\n'),
              ]
     tt.check_pairs(isp.remove_comments, tests)
 
 
 def test_get_input_encoding():
     encoding = isp.get_input_encoding()
-    nt.assert_true(isinstance(encoding, str))
+    assert isinstance(encoding, str)
     # simple-minded check that at least encoding a simple string works with the
     # encoding we got.
-    nt.assert_equal(u'test'.encode(encoding), b'test')
+    assert "test".encode(encoding) == b"test"
 
 
 class NoInputEncodingTestCase(unittest.TestCase):
     def setUp(self):
         self.old_stdin = sys.stdin
         class X: pass
         fake_stdin = X()
         sys.stdin = fake_stdin
 
     def test(self):
         # Verify that if sys.stdin has no 'encoding' attribute we do the right
         # thing
         enc = isp.get_input_encoding()
         self.assertEqual(enc, 'ascii')
 
     def tearDown(self):
         sys.stdin = self.old_stdin
 
 
 class InputSplitterTestCase(unittest.TestCase):
     def setUp(self):
         self.isp = isp.InputSplitter()
 
     def test_reset(self):
         isp = self.isp
         isp.push('x=1')
         isp.reset()
         self.assertEqual(isp._buffer, [])
         self.assertEqual(isp.get_indent_spaces(), 0)
         self.assertEqual(isp.source, '')
         self.assertEqual(isp.code, None)
         self.assertEqual(isp._is_complete, False)
 
     def test_source(self):
         self.isp._store('1')
         self.isp._store('2')
         self.assertEqual(self.isp.source, '1\n2\n')
         self.assertEqual(len(self.isp._buffer)>0, True)
         self.assertEqual(self.isp.source_reset(), '1\n2\n')
         self.assertEqual(self.isp._buffer, [])
         self.assertEqual(self.isp.source, '')
 
     def test_indent(self):
         isp = self.isp # shorthand
         isp.push('x=1')
         self.assertEqual(isp.get_indent_spaces(), 0)
         isp.push('if 1:\n    x=1')
         self.assertEqual(isp.get_indent_spaces(), 4)
         isp.push('y=2\n')
         self.assertEqual(isp.get_indent_spaces(), 0)
 
     def test_indent2(self):
         isp = self.isp
         isp.push('if 1:')
         self.assertEqual(isp.get_indent_spaces(), 4)
         isp.push('    x=1')
         self.assertEqual(isp.get_indent_spaces(), 4)
         # Blank lines shouldn't change the indent level
         isp.push(' '*2)
         self.assertEqual(isp.get_indent_spaces(), 4)
 
     def test_indent3(self):
         isp = self.isp
         # When a multiline statement contains parens or multiline strings, we
         # shouldn't get confused.
         isp.push("if 1:")
         isp.push("    x = (1+\n    2)")
         self.assertEqual(isp.get_indent_spaces(), 4)
 
     def test_indent4(self):
         isp = self.isp
         # whitespace after ':' should not screw up indent level
         isp.push('if 1: \n    x=1')
         self.assertEqual(isp.get_indent_spaces(), 4)
         isp.push('y=2\n')
         self.assertEqual(isp.get_indent_spaces(), 0)
         isp.push('if 1:\t\n    x=1')
         self.assertEqual(isp.get_indent_spaces(), 4)
         isp.push('y=2\n')
         self.assertEqual(isp.get_indent_spaces(), 0)
 
     def test_dedent_pass(self):
         isp = self.isp # shorthand
         # should NOT cause dedent
         isp.push('if 1:\n    passes = 5')
         self.assertEqual(isp.get_indent_spaces(), 4)
         isp.push('if 1:\n     pass')
         self.assertEqual(isp.get_indent_spaces(), 0)
         isp.push('if 1:\n     pass   ')
         self.assertEqual(isp.get_indent_spaces(), 0)
 
     def test_dedent_break(self):
         isp = self.isp # shorthand
         # should NOT cause dedent
         isp.push('while 1:\n    breaks = 5')
         self.assertEqual(isp.get_indent_spaces(), 4)
         isp.push('while 1:\n     break')
         self.assertEqual(isp.get_indent_spaces(), 0)
         isp.push('while 1:\n     break   ')
         self.assertEqual(isp.get_indent_spaces(), 0)
 
     def test_dedent_continue(self):
         isp = self.isp # shorthand
         # should NOT cause dedent
         isp.push('while 1:\n    continues = 5')
         self.assertEqual(isp.get_indent_spaces(), 4)
         isp.push('while 1:\n     continue')
         self.assertEqual(isp.get_indent_spaces(), 0)
         isp.push('while 1:\n     continue   ')
         self.assertEqual(isp.get_indent_spaces(), 0)
 
     def test_dedent_raise(self):
         isp = self.isp # shorthand
         # should NOT cause dedent
         isp.push('if 1:\n    raised = 4')
         self.assertEqual(isp.get_indent_spaces(), 4)
         isp.push('if 1:\n     raise TypeError()')
         self.assertEqual(isp.get_indent_spaces(), 0)
         isp.push('if 1:\n     raise')
         self.assertEqual(isp.get_indent_spaces(), 0)
         isp.push('if 1:\n     raise      ')
         self.assertEqual(isp.get_indent_spaces(), 0)
 
     def test_dedent_return(self):
         isp = self.isp # shorthand
         # should NOT cause dedent
         isp.push('if 1:\n    returning = 4')
         self.assertEqual(isp.get_indent_spaces(), 4)
         isp.push('if 1:\n     return 5 + 493')
         self.assertEqual(isp.get_indent_spaces(), 0)
         isp.push('if 1:\n     return')
         self.assertEqual(isp.get_indent_spaces(), 0)
         isp.push('if 1:\n     return      ')
         self.assertEqual(isp.get_indent_spaces(), 0)
         isp.push('if 1:\n     return(0)')
         self.assertEqual(isp.get_indent_spaces(), 0)
 
     def test_push(self):
         isp = self.isp
         self.assertEqual(isp.push('x=1'), True)
 
     def test_push2(self):
         isp = self.isp
         self.assertEqual(isp.push('if 1:'), False)
         for line in ['  x=1', '# a comment', '  y=2']:
             print(line)
             self.assertEqual(isp.push(line), True)
 
     def test_push3(self):
         isp = self.isp
         isp.push('if True:')
         isp.push('  a = 1')
         self.assertEqual(isp.push('b = [1,'), False)
 
     def test_push_accepts_more(self):
         isp = self.isp
         isp.push('x=1')
         self.assertEqual(isp.push_accepts_more(), False)
 
     def test_push_accepts_more2(self):
         isp = self.isp
         isp.push('if 1:')
         self.assertEqual(isp.push_accepts_more(), True)
         isp.push('  x=1')
         self.assertEqual(isp.push_accepts_more(), True)
         isp.push('')
         self.assertEqual(isp.push_accepts_more(), False)
 
     def test_push_accepts_more3(self):
         isp = self.isp
         isp.push("x = (2+\n3)")
         self.assertEqual(isp.push_accepts_more(), False)
 
     def test_push_accepts_more4(self):
         isp = self.isp
         # When a multiline statement contains parens or multiline strings, we
         # shouldn't get confused.
         # FIXME: we should be able to better handle de-dents in statements like
         # multiline strings and multiline expressions (continued with \ or
         # parens).  Right now we aren't handling the indentation tracking quite
         # correctly with this, though in practice it may not be too much of a
         # problem.  We'll need to see.
         isp.push("if 1:")
         isp.push("    x = (2+")
         isp.push("    3)")
         self.assertEqual(isp.push_accepts_more(), True)
         isp.push("    y = 3")
         self.assertEqual(isp.push_accepts_more(), True)
         isp.push('')
         self.assertEqual(isp.push_accepts_more(), False)
 
     def test_push_accepts_more5(self):
         isp = self.isp
         isp.push('try:')
         isp.push('    a = 5')
         isp.push('except:')
         isp.push('    raise')
         # We want to be able to add an else: block at this point, so it should
         # wait for a blank line.
         self.assertEqual(isp.push_accepts_more(), True)
 
     def test_continuation(self):
         isp = self.isp
         isp.push("import os, \\")
         self.assertEqual(isp.push_accepts_more(), True)
         isp.push("sys")
         self.assertEqual(isp.push_accepts_more(), False)
 
     def test_syntax_error(self):
         isp = self.isp
         # Syntax errors immediately produce a 'ready' block, so the invalid
         # Python can be sent to the kernel for evaluation with possible ipython
         # special-syntax conversion.
         isp.push('run foo')
         self.assertEqual(isp.push_accepts_more(), False)
 
     def test_unicode(self):
         self.isp.push(u"Pérez")
         self.isp.push(u'\xc3\xa9')
         self.isp.push(u"u'\xc3\xa9'")
 
     def test_line_continuation(self):
         """ Test issue #2108."""
         isp = self.isp
         # A blank line after a line continuation should not accept more
         isp.push("1 \\\n\n")
         self.assertEqual(isp.push_accepts_more(), False)
         # Whitespace after a \ is a SyntaxError.  The only way to test that
         # here is to test that push doesn't accept more (as with
         # test_syntax_error() above).
         isp.push(r"1 \ ")
         self.assertEqual(isp.push_accepts_more(), False)
         # Even if the line is continuable (c.f. the regular Python
         # interpreter)
         isp.push(r"(1 \ ")
         self.assertEqual(isp.push_accepts_more(), False)
 
     def test_check_complete(self):
         isp = self.isp
         self.assertEqual(isp.check_complete("a = 1"), ('complete', None))
         self.assertEqual(isp.check_complete("for a in range(5):"), ('incomplete', 4))
         self.assertEqual(isp.check_complete("raise = 2"), ('invalid', None))
         self.assertEqual(isp.check_complete("a = [1,\n2,"), ('incomplete', 0))
         self.assertEqual(isp.check_complete("def a():\n x=1\n global x"), ('invalid', None))
 
 class InteractiveLoopTestCase(unittest.TestCase):
     """Tests for an interactive loop like a python shell.
     """
     def check_ns(self, lines, ns):
         """Validate that the given input lines produce the resulting namespace.
 
         Note: the input lines are given exactly as they would be typed in an
         auto-indenting environment, as mini_interactive_loop above already does
         auto-indenting and prepends spaces to the input.
         """
         src = mini_interactive_loop(pseudo_input(lines))
         test_ns = {}
         exec(src, test_ns)
         # We can't check that the provided ns is identical to the test_ns,
         # because Python fills test_ns with extra keys (copyright, etc).  But
         # we can check that the given dict is *contained* in test_ns
         for k,v in ns.items():
             self.assertEqual(test_ns[k], v)
 
     def test_simple(self):
         self.check_ns(['x=1'], dict(x=1))
 
     def test_simple2(self):
         self.check_ns(['if 1:', 'x=2'], dict(x=2))
 
     def test_xy(self):
         self.check_ns(['x=1; y=2'], dict(x=1, y=2))
 
     def test_abc(self):
         self.check_ns(['if 1:','a=1','b=2','c=3'], dict(a=1, b=2, c=3))
 
     def test_multi(self):
         self.check_ns(['x =(1+','1+','2)'], dict(x=4))
 
 
 class IPythonInputTestCase(InputSplitterTestCase):
     """By just creating a new class whose .isp is a different instance, we
     re-run the same test battery on the new input splitter.
 
     In addition, this runs the tests over the syntax and syntax_ml dicts that
     were tested by individual functions, as part of the OO interface.
 
     It also makes some checks on the raw buffer storage.
     """
 
     def setUp(self):
         self.isp = isp.IPythonInputSplitter()
 
     def test_syntax(self):
         """Call all single-line syntax tests from the main object"""
         isp = self.isp
         for example in syntax.values():
             for raw, out_t in example:
                 if raw.startswith(' '):
                     continue
 
                 isp.push(raw+'\n')
                 out_raw = isp.source_raw
                 out = isp.source_reset()
                 self.assertEqual(out.rstrip(), out_t,
                         tt.pair_fail_msg.format("inputsplitter",raw, out_t, out))
                 self.assertEqual(out_raw.rstrip(), raw.rstrip())
 
     def test_syntax_multiline(self):
         isp = self.isp
         for example in syntax_ml.values():
             for line_pairs in example:
                 out_t_parts = []
                 raw_parts = []
                 for lraw, out_t_part in line_pairs:
                     if out_t_part is not None:
                         out_t_parts.append(out_t_part)
-                    
+
                     if lraw is not None:
                         isp.push(lraw)
                         raw_parts.append(lraw)
 
                 out_raw = isp.source_raw
                 out = isp.source_reset()
                 out_t = '\n'.join(out_t_parts).rstrip()
                 raw = '\n'.join(raw_parts).rstrip()
                 self.assertEqual(out.rstrip(), out_t)
                 self.assertEqual(out_raw.rstrip(), raw)
 
     def test_syntax_multiline_cell(self):
         isp = self.isp
         for example in syntax_ml.values():
 
             out_t_parts = []
             for line_pairs in example:
                 raw = '\n'.join(r for r, _ in line_pairs if r is not None)
                 out_t = '\n'.join(t for _,t in line_pairs if t is not None)
                 out = isp.transform_cell(raw)
                 # Match ignoring trailing whitespace
                 self.assertEqual(out.rstrip(), out_t.rstrip())
-    
+
     def test_cellmagic_preempt(self):
         isp = self.isp
         for raw, name, line, cell in [
             ("%%cellm a\nIn[1]:", u'cellm', u'a', u'In[1]:'),
             ("%%cellm \nline\n>>> hi", u'cellm', u'', u'line\n>>> hi'),
             (">>> %%cellm \nline\n>>> hi", u'cellm', u'', u'line\nhi'),
             ("%%cellm \n>>> hi", u'cellm', u'', u'>>> hi'),
             ("%%cellm \nline1\nline2", u'cellm', u'', u'line1\nline2'),
             ("%%cellm \nline1\\\\\nline2", u'cellm', u'', u'line1\\\\\nline2'),
         ]:
             expected = "get_ipython().run_cell_magic(%r, %r, %r)" % (
                 name, line, cell
             )
             out = isp.transform_cell(raw)
             self.assertEqual(out.rstrip(), expected.rstrip())
 
     def test_multiline_passthrough(self):
         isp = self.isp
         class CommentTransformer(InputTransformer):
             def __init__(self):
                 self._lines = []
-            
+
             def push(self, line):
                 self._lines.append(line + '#')
-            
+
             def reset(self):
                 text = '\n'.join(self._lines)
                 self._lines = []
                 return text
-        
+
         isp.physical_line_transforms.insert(0, CommentTransformer())
-        
+
         for raw, expected in [
             ("a=5", "a=5#"),
             ("%ls foo", "get_ipython().run_line_magic(%r, %r)" % (u'ls', u'foo#')),
             ("!ls foo\n%ls bar", "get_ipython().system(%r)\nget_ipython().run_line_magic(%r, %r)" % (
                 u'ls foo#', u'ls', u'bar#'
             )),
             ("1\n2\n3\n%ls foo\n4\n5", "1#\n2#\n3#\nget_ipython().run_line_magic(%r, %r)\n4#\n5#" % (u'ls', u'foo#')),
         ]:
             out = isp.transform_cell(raw)
             self.assertEqual(out.rstrip(), expected.rstrip())
 
 #-----------------------------------------------------------------------------
 # Main - use as a script, mostly for developer experiments
 #-----------------------------------------------------------------------------
 
 if __name__ == '__main__':
     # A simple demo for interactive experimentation.  This code will not get
     # picked up by any test suite.
     from IPython.core.inputsplitter import IPythonInputSplitter
 
     # configure here the syntax to use, prompt and whether to autoindent
     #isp, start_prompt = InputSplitter(), '>>> '
     isp, start_prompt = IPythonInputSplitter(), 'In> '
 
     autoindent = True
     #autoindent = False
 
     try:
         while True:
             prompt = start_prompt
             while isp.push_accepts_more():
                 indent = ' '*isp.get_indent_spaces()
                 if autoindent:
                     line = indent + input(prompt+indent)
                 else:
                     line = input(prompt)
                 isp.push(line)
                 prompt = '... '
 
             # Here we just return input so we can use it in a test suite, but a
             # real interpreter would instead send it for execution somewhere.
             #src = isp.source; raise EOFError # dbg
             raw = isp.source_raw
             src = isp.source_reset()
             print('Input source was:\n', src)
             print('Raw source was:\n', raw)
     except EOFError:
         print('Bye')
 
 # Tests for cell magics support
 
 def test_last_blank():
-    nt.assert_false(isp.last_blank(''))
-    nt.assert_false(isp.last_blank('abc'))
-    nt.assert_false(isp.last_blank('abc\n'))
-    nt.assert_false(isp.last_blank('abc\na'))
+    assert isp.last_blank("") is False
+    assert isp.last_blank("abc") is False
+    assert isp.last_blank("abc\n") is False
+    assert isp.last_blank("abc\na") is False
 
-    nt.assert_true(isp.last_blank('\n'))
-    nt.assert_true(isp.last_blank('\n '))
-    nt.assert_true(isp.last_blank('abc\n '))
-    nt.assert_true(isp.last_blank('abc\n\n'))
-    nt.assert_true(isp.last_blank('abc\nd\n\n'))
-    nt.assert_true(isp.last_blank('abc\nd\ne\n\n'))
-    nt.assert_true(isp.last_blank('abc \n \n \n\n'))
+    assert isp.last_blank("\n") is True
+    assert isp.last_blank("\n ") is True
+    assert isp.last_blank("abc\n ") is True
+    assert isp.last_blank("abc\n\n") is True
+    assert isp.last_blank("abc\nd\n\n") is True
+    assert isp.last_blank("abc\nd\ne\n\n") is True
+    assert isp.last_blank("abc \n \n \n\n") is True
 
 
 def test_last_two_blanks():
-    nt.assert_false(isp.last_two_blanks(''))
-    nt.assert_false(isp.last_two_blanks('abc'))
-    nt.assert_false(isp.last_two_blanks('abc\n'))
-    nt.assert_false(isp.last_two_blanks('abc\n\na'))
-    nt.assert_false(isp.last_two_blanks('abc\n \n'))
-    nt.assert_false(isp.last_two_blanks('abc\n\n'))
-
-    nt.assert_true(isp.last_two_blanks('\n\n'))
-    nt.assert_true(isp.last_two_blanks('\n\n '))
-    nt.assert_true(isp.last_two_blanks('\n \n'))
-    nt.assert_true(isp.last_two_blanks('abc\n\n '))
-    nt.assert_true(isp.last_two_blanks('abc\n\n\n'))
-    nt.assert_true(isp.last_two_blanks('abc\n\n \n'))
-    nt.assert_true(isp.last_two_blanks('abc\n\n \n '))
-    nt.assert_true(isp.last_two_blanks('abc\n\n \n \n'))
-    nt.assert_true(isp.last_two_blanks('abc\nd\n\n\n'))
-    nt.assert_true(isp.last_two_blanks('abc\nd\ne\nf\n\n\n'))
+    assert isp.last_two_blanks("") is False
+    assert isp.last_two_blanks("abc") is False
+    assert isp.last_two_blanks("abc\n") is False
+    assert isp.last_two_blanks("abc\n\na") is False
+    assert isp.last_two_blanks("abc\n \n") is False
+    assert isp.last_two_blanks("abc\n\n") is False
+
+    assert isp.last_two_blanks("\n\n") is True
+    assert isp.last_two_blanks("\n\n ") is True
+    assert isp.last_two_blanks("\n \n") is True
+    assert isp.last_two_blanks("abc\n\n ") is True
+    assert isp.last_two_blanks("abc\n\n\n") is True
+    assert isp.last_two_blanks("abc\n\n \n") is True
+    assert isp.last_two_blanks("abc\n\n \n ") is True
+    assert isp.last_two_blanks("abc\n\n \n \n") is True
+    assert isp.last_two_blanks("abc\nd\n\n\n") is True
+    assert isp.last_two_blanks("abc\nd\ne\nf\n\n\n") is True
 
 
 class CellMagicsCommon(object):
 
     def test_whole_cell(self):
         src = "%%cellm line\nbody\n"
         out = self.sp.transform_cell(src)
         ref = "get_ipython().run_cell_magic('cellm', 'line', 'body')\n"
-        nt.assert_equal(out, ref)
-    
+        assert out == ref
+
     def test_cellmagic_help(self):
         self.sp.push('%%cellm?')
-        nt.assert_false(self.sp.push_accepts_more())
+        assert self.sp.push_accepts_more() is False
 
     def tearDown(self):
         self.sp.reset()
 
 
 class CellModeCellMagics(CellMagicsCommon, unittest.TestCase):
     sp = isp.IPythonInputSplitter(line_input_checker=False)
 
     def test_incremental(self):
         sp = self.sp
-        sp.push('%%cellm firstline\n')
-        nt.assert_true(sp.push_accepts_more()) #1
-        sp.push('line2\n')
-        nt.assert_true(sp.push_accepts_more()) #2
-        sp.push('\n')
+        sp.push("%%cellm firstline\n")
+        assert sp.push_accepts_more() is True  # 1
+        sp.push("line2\n")
+        assert sp.push_accepts_more() is True  # 2
+        sp.push("\n")
         # This should accept a blank line and carry on until the cell is reset
-        nt.assert_true(sp.push_accepts_more()) #3
-    
+        assert sp.push_accepts_more() is True  # 3
+
     def test_no_strip_coding(self):
         src = '\n'.join([
             '%%writefile foo.py',
             '# coding: utf-8',
             'print(u"üñîçø∂é")',
         ])
         out = self.sp.transform_cell(src)
-        nt.assert_in('# coding: utf-8', out)
+        assert "# coding: utf-8" in out
 
 
 class LineModeCellMagics(CellMagicsCommon, unittest.TestCase):
     sp = isp.IPythonInputSplitter(line_input_checker=True)
 
     def test_incremental(self):
         sp = self.sp
-        sp.push('%%cellm line2\n')
-        nt.assert_true(sp.push_accepts_more()) #1
-        sp.push('\n')
+        sp.push("%%cellm line2\n")
+        assert sp.push_accepts_more() is True  # 1
+        sp.push("\n")
         # In this case, a blank line should end the cell magic
-        nt.assert_false(sp.push_accepts_more()) #2
+        assert sp.push_accepts_more() is False  # 2
+
 
 indentation_samples = [
     ('a = 1', 0),
     ('for a in b:', 4),
     ('def f():', 4),
     ('def f(): #comment', 4),
     ('a = ":#not a comment"', 0),
     ('def f():\n    a = 1', 4),
     ('def f():\n    return 1', 0),
     ('for a in b:\n'
      '   if a < 0:'
      '       continue', 3),
     ('a = {', 4),
     ('a = {\n'
      '     1,', 5),
     ('b = """123', 0),
     ('', 0),
     ('def f():\n    pass', 0),
     ('class Bar:\n    def f():\n        pass', 4),
     ('class Bar:\n    def f():\n        raise', 4),
 ]
 
 def test_find_next_indent():
     for code, exp in indentation_samples:
         res = isp.find_next_indent(code)
         msg = "{!r} != {!r} (expected)\n Code: {!r}".format(res, exp, code)
         assert res == exp, msg

IPython/core/tests/test_inputtransformer.py

@@ -1,485 +1,484 b''
 import tokenize
-import nose.tools as nt
 
 from IPython.testing import tools as tt
 
 from IPython.core import inputtransformer as ipt
 
 def transform_and_reset(transformer):
     transformer = transformer()
     def transform(inp):
         try:
             return transformer.push(inp)
         finally:
             transformer.reset()
     
     return transform
 
 # Transformer tests
 def transform_checker(tests, transformer, **kwargs):
     """Utility to loop over test inputs"""
     transformer = transformer(**kwargs)
     try:
         for inp, tr in tests:
             if inp is None:
                 out = transformer.reset()
             else:
                 out = transformer.push(inp)
-            nt.assert_equal(out, tr)
+            assert out == tr
     finally:
         transformer.reset()
 
 # Data for all the syntax tests in the form of lists of pairs of
 # raw/transformed input.  We store it here as a global dict so that we can use
 # it both within single-function tests and also to validate the behavior of the
 # larger objects
 
 syntax = \
   dict(assign_system =
        [('a =! ls', "a = get_ipython().getoutput('ls')"),
         ('b = !ls', "b = get_ipython().getoutput('ls')"),
         ('c= !ls', "c = get_ipython().getoutput('ls')"),
         ('d == !ls', 'd == !ls'), # Invalid syntax, but we leave == alone.
         ('x=1', 'x=1'), # normal input is unmodified
         ('    ','    '),  # blank lines are kept intact
         # Tuple unpacking
         ("a, b = !echo 'a\\nb'", "a, b = get_ipython().getoutput(\"echo 'a\\\\nb'\")"),
         ("a,= !echo 'a'", "a, = get_ipython().getoutput(\"echo 'a'\")"),
         ("a, *bc = !echo 'a\\nb\\nc'", "a, *bc = get_ipython().getoutput(\"echo 'a\\\\nb\\\\nc'\")"),
         # Tuple unpacking with regular Python expressions, not our syntax.
         ("a, b = range(2)", "a, b = range(2)"),
         ("a, = range(1)", "a, = range(1)"),
         ("a, *bc = range(3)", "a, *bc = range(3)"),
         ],
 
        assign_magic =
        [('a =% who', "a = get_ipython().run_line_magic('who', '')"),
         ('b = %who', "b = get_ipython().run_line_magic('who', '')"),
         ('c= %ls', "c = get_ipython().run_line_magic('ls', '')"),
         ('d == %ls', 'd == %ls'), # Invalid syntax, but we leave == alone.
         ('x=1', 'x=1'), # normal input is unmodified
         ('    ','    '),  # blank lines are kept intact
         ("a, b = %foo", "a, b = get_ipython().run_line_magic('foo', '')"),
         ],
 
        classic_prompt =
        [('>>> x=1', 'x=1'),
         ('x=1', 'x=1'), # normal input is unmodified
         ('    ', '    '),  # blank lines are kept intact
         ],
 
        ipy_prompt =
        [('In [1]: x=1', 'x=1'),
         ('x=1', 'x=1'), # normal input is unmodified
         ('    ','    '),  # blank lines are kept intact
         ],
 
        # Tests for the escape transformer to leave normal code alone
        escaped_noesc =
        [ ('    ', '    '),
          ('x=1', 'x=1'),
          ],
 
        # System calls
        escaped_shell =
        [ ('!ls', "get_ipython().system('ls')"),
          # Double-escape shell, this means to capture the output of the
          # subprocess and return it
          ('!!ls', "get_ipython().getoutput('ls')"),
          ],
 
        # Help/object info
        escaped_help =
        [ ('?', 'get_ipython().show_usage()'),
          ('?x1', "get_ipython().run_line_magic('pinfo', 'x1')"),
          ('??x2', "get_ipython().run_line_magic('pinfo2', 'x2')"),
          ('?a.*s', "get_ipython().run_line_magic('psearch', 'a.*s')"),
          ('?%hist1', "get_ipython().run_line_magic('pinfo', '%hist1')"),
          ('?%%hist2', "get_ipython().run_line_magic('pinfo', '%%hist2')"),
          ('?abc = qwe', "get_ipython().run_line_magic('pinfo', 'abc')"),
          ],
 
       end_help =
       [ ('x3?', "get_ipython().run_line_magic('pinfo', 'x3')"),
         ('x4??', "get_ipython().run_line_magic('pinfo2', 'x4')"),
         ('%hist1?', "get_ipython().run_line_magic('pinfo', '%hist1')"),
         ('%hist2??', "get_ipython().run_line_magic('pinfo2', '%hist2')"),
         ('%%hist3?', "get_ipython().run_line_magic('pinfo', '%%hist3')"),
         ('%%hist4??', "get_ipython().run_line_magic('pinfo2', '%%hist4')"),
         ('π.foo?', "get_ipython().run_line_magic('pinfo', 'π.foo')"),
         ('f*?', "get_ipython().run_line_magic('psearch', 'f*')"),
         ('ax.*aspe*?', "get_ipython().run_line_magic('psearch', 'ax.*aspe*')"),
         ('a = abc?', "get_ipython().set_next_input('a = abc');"
                       "get_ipython().run_line_magic('pinfo', 'abc')"),
         ('a = abc.qe??', "get_ipython().set_next_input('a = abc.qe');"
                           "get_ipython().run_line_magic('pinfo2', 'abc.qe')"),
         ('a = *.items?', "get_ipython().set_next_input('a = *.items');"
                           "get_ipython().run_line_magic('psearch', '*.items')"),
         ('plot(a?', "get_ipython().set_next_input('plot(a');"
                      "get_ipython().run_line_magic('pinfo', 'a')"),
         ('a*2 #comment?', 'a*2 #comment?'),
         ],
 
        # Explicit magic calls
        escaped_magic =
        [ ('%cd', "get_ipython().run_line_magic('cd', '')"),
          ('%cd /home', "get_ipython().run_line_magic('cd', '/home')"),
          # Backslashes need to be escaped.
          ('%cd C:\\User', "get_ipython().run_line_magic('cd', 'C:\\\\User')"),
          ('    %magic', "    get_ipython().run_line_magic('magic', '')"),
          ],
 
        # Quoting with separate arguments
        escaped_quote =
        [ (',f', 'f("")'),
          (',f x', 'f("x")'),
          ('  ,f y', '  f("y")'),
          (',f a b', 'f("a", "b")'),
          ],
 
        # Quoting with single argument
        escaped_quote2 =
        [ (';f', 'f("")'),
          (';f x', 'f("x")'),
          ('  ;f y', '  f("y")'),
          (';f a b', 'f("a b")'),
          ],
 
        # Simply apply parens
        escaped_paren =
        [ ('/f', 'f()'),
          ('/f x', 'f(x)'),
          ('  /f y', '  f(y)'),
          ('/f a b', 'f(a, b)'),
          ],
 
        # Check that we transform prompts before other transforms
        mixed =
        [ ('In [1]: %lsmagic', "get_ipython().run_line_magic('lsmagic', '')"),
          ('>>> %lsmagic', "get_ipython().run_line_magic('lsmagic', '')"),
          ('In [2]: !ls', "get_ipython().system('ls')"),
          ('In [3]: abs?', "get_ipython().run_line_magic('pinfo', 'abs')"),
          ('In [4]: b = %who', "b = get_ipython().run_line_magic('who', '')"),
          ],
        )
 
 # multiline syntax examples.  Each of these should be a list of lists, with
 # each entry itself having pairs of raw/transformed input.  The union (with
 # '\n'.join() of the transformed inputs is what the splitter should produce
 # when fed the raw lines one at a time via push.
 syntax_ml = \
   dict(classic_prompt =
        [ [('>>> for i in range(10):','for i in range(10):'),
           ('...     print i','    print i'),
           ('... ', ''),
           ],
          [('>>> a="""','a="""'),
           ('... 123"""','123"""'),
           ],
          [('a="""','a="""'),
           ('... 123','123'),
           ('... 456"""','456"""'),
           ],
          [('a="""','a="""'),
           ('>>> 123','123'),
           ('... 456"""','456"""'),
           ],
          [('a="""','a="""'),
           ('123','123'),
           ('... 456"""','... 456"""'),
           ],
          [('....__class__','....__class__'),
          ],
          [('a=5', 'a=5'),
           ('...', ''),
          ],
          [('>>> def f(x):', 'def f(x):'),
           ('...', ''),
           ('...     return x', '    return x'),
           ],
          [('board = """....', 'board = """....'),
           ('....', '....'),
           ('...."""', '...."""'),
           ],
         ],
 
        ipy_prompt =
        [ [('In [24]: for i in range(10):','for i in range(10):'),
           ('   ....:     print i','    print i'),
           ('   ....: ', ''),
           ],
          [('In [24]: for i in range(10):','for i in range(10):'),
           # Qt console prompts expand with spaces, not dots
           ('    ...:     print i','    print i'),
           ('    ...: ', ''),
           ],
          [('In [24]: for i in range(10):','for i in range(10):'),
           # Sometimes whitespace preceding '...' has been removed
           ('...:     print i','    print i'),
           ('...: ', ''),
           ],
          [('In [24]: for i in range(10):','for i in range(10):'),
           # Space after last continuation prompt has been removed (issue #6674)
           ('...:     print i','    print i'),
           ('...:', ''),
           ],
          [('In [2]: a="""','a="""'),
           ('   ...: 123"""','123"""'),
           ],
          [('a="""','a="""'),
           ('   ...: 123','123'),
           ('   ...: 456"""','456"""'),
           ],
          [('a="""','a="""'),
           ('In [1]: 123','123'),
           ('   ...: 456"""','456"""'),
           ],
          [('a="""','a="""'),
           ('123','123'),
           ('   ...: 456"""','   ...: 456"""'),
           ],
          ],
 
        multiline_datastructure_prompt =
        [ [('>>> a = [1,','a = [1,'),
           ('... 2]','2]'),
          ],
        ],
         
        multiline_datastructure =
        [ [('b = ("%s"', None),
           ('# comment', None),
           ('%foo )', 'b = ("%s"\n# comment\n%foo )'),
          ],
        ],
        
        multiline_string =
        [ [("'''foo?", None),
           ("bar'''", "'''foo?\nbar'''"),
          ],
        ],
        
        leading_indent =
        [ [('    print "hi"','print "hi"'),
           ],
          [('  for a in range(5):','for a in range(5):'),
           ('    a*2','  a*2'),
           ],
          [('    a="""','a="""'),
           ('    123"""','123"""'),
            ],
          [('a="""','a="""'),
           ('    123"""','    123"""'),
           ],
        ],
        
        cellmagic =
        [ [('%%foo a', None),
           (None, "get_ipython().run_cell_magic('foo', 'a', '')"),
           ],
          [('%%bar 123', None),
           ('hello', None),
           (None , "get_ipython().run_cell_magic('bar', '123', 'hello')"),
           ],
          [('a=5', 'a=5'),
           ('%%cellmagic', '%%cellmagic'),
           ],
        ],
        
        escaped =
        [ [('%abc def \\', None),
           ('ghi', "get_ipython().run_line_magic('abc', 'def ghi')"),
           ],
          [('%abc def \\', None),
           ('ghi\\', None),
           (None, "get_ipython().run_line_magic('abc', 'def ghi')"),
           ],
        ],
        
        assign_magic =
        [ [('a = %bc de \\', None),
           ('fg', "a = get_ipython().run_line_magic('bc', 'de fg')"),
           ],
          [('a = %bc de \\', None),
           ('fg\\', None),
           (None, "a = get_ipython().run_line_magic('bc', 'de fg')"),
           ],
        ],
        
        assign_system =
        [ [('a = !bc de \\', None),
           ('fg', "a = get_ipython().getoutput('bc de fg')"),
           ],
          [('a = !bc de \\', None),
           ('fg\\', None),
           (None, "a = get_ipython().getoutput('bc de fg')"),
           ],
        ],
        )
 
 
 def test_assign_system():
     tt.check_pairs(transform_and_reset(ipt.assign_from_system), syntax['assign_system'])
 
 def test_assign_magic():
     tt.check_pairs(transform_and_reset(ipt.assign_from_magic), syntax['assign_magic'])
 
 def test_classic_prompt():
     tt.check_pairs(transform_and_reset(ipt.classic_prompt), syntax['classic_prompt'])
     for example in syntax_ml['classic_prompt']:
         transform_checker(example, ipt.classic_prompt)
     for example in syntax_ml['multiline_datastructure_prompt']:
         transform_checker(example, ipt.classic_prompt)
 
     # Check that we don't transform the second line if the first is obviously
     # IPython syntax
     transform_checker([
         ('%foo', '%foo'),
         ('>>> bar', '>>> bar'),
     ], ipt.classic_prompt)
 
 
 def test_ipy_prompt():
     tt.check_pairs(transform_and_reset(ipt.ipy_prompt), syntax['ipy_prompt'])
     for example in syntax_ml['ipy_prompt']:
         transform_checker(example, ipt.ipy_prompt)
 
     # Check that we don't transform the second line if we're inside a cell magic
     transform_checker([
         ('%%foo', '%%foo'),
         ('In [1]: bar', 'In [1]: bar'),
     ], ipt.ipy_prompt)
 
 def test_assemble_logical_lines():
     tests = \
     [ [("a = \\", None),
        ("123", "a = 123"),
       ],
       [("a = \\", None),  # Test resetting when within a multi-line string
        ("12 *\\", None),
        (None, "a = 12 *"),
       ],
       [("# foo\\", "# foo\\"), # Comments can't be continued like this
       ],
     ]
     for example in tests:
         transform_checker(example, ipt.assemble_logical_lines)
 
 def test_assemble_python_lines():
     tests = \
     [ [("a = '''", None),
        ("abc'''", "a = '''\nabc'''"),
       ],
       [("a = '''", None),  # Test resetting when within a multi-line string
        ("def", None),
        (None, "a = '''\ndef"),
       ],
       [("a = [1,", None),
        ("2]", "a = [1,\n2]"),
       ],
       [("a = [1,", None),  # Test resetting when within a multi-line string
        ("2,", None),
        (None, "a = [1,\n2,"),
       ],
       [("a = '''", None),  # Test line continuation within a multi-line string
        ("abc\\", None),
        ("def", None),
        ("'''", "a = '''\nabc\\\ndef\n'''"),
       ],
     ] + syntax_ml['multiline_datastructure']
     for example in tests:
         transform_checker(example, ipt.assemble_python_lines)
 
 
 def test_help_end():
     tt.check_pairs(transform_and_reset(ipt.help_end), syntax['end_help'])
 
 def test_escaped_noesc():
     tt.check_pairs(transform_and_reset(ipt.escaped_commands), syntax['escaped_noesc'])
 
 
 def test_escaped_shell():
     tt.check_pairs(transform_and_reset(ipt.escaped_commands), syntax['escaped_shell'])
 
 
 def test_escaped_help():
     tt.check_pairs(transform_and_reset(ipt.escaped_commands), syntax['escaped_help'])
 
 
 def test_escaped_magic():
     tt.check_pairs(transform_and_reset(ipt.escaped_commands), syntax['escaped_magic'])
 
 
 def test_escaped_quote():
     tt.check_pairs(transform_and_reset(ipt.escaped_commands), syntax['escaped_quote'])
 
 
 def test_escaped_quote2():
     tt.check_pairs(transform_and_reset(ipt.escaped_commands), syntax['escaped_quote2'])
 
 
 def test_escaped_paren():
     tt.check_pairs(transform_and_reset(ipt.escaped_commands), syntax['escaped_paren'])
 
 
 def test_cellmagic():
     for example in syntax_ml['cellmagic']:
         transform_checker(example, ipt.cellmagic)
     
     line_example = [('%%bar 123', None),
                     ('hello', None),
                     ('' , "get_ipython().run_cell_magic('bar', '123', 'hello')"),
                    ]
     transform_checker(line_example, ipt.cellmagic, end_on_blank_line=True)
 
 def test_has_comment():
     tests = [('text', False),
              ('text #comment', True),
              ('text #comment\n', True),
              ('#comment', True),
              ('#comment\n', True),
              ('a = "#string"', False),
              ('a = "#string" # comment', True),
              ('a #comment not "string"', True),
              ]
     tt.check_pairs(ipt.has_comment, tests)
 
 @ipt.TokenInputTransformer.wrap
 def decistmt(tokens):
     """Substitute Decimals for floats in a string of statements.
 
     Based on an example from the tokenize module docs.
     """
     result = []
     for toknum, tokval, _, _, _  in tokens:
         if toknum == tokenize.NUMBER and '.' in tokval:  # replace NUMBER tokens
             yield from [
                 (tokenize.NAME, 'Decimal'),
                 (tokenize.OP, '('),
                 (tokenize.STRING, repr(tokval)),
                 (tokenize.OP, ')')
             ]
         else:
             yield (toknum, tokval)
 
 
 
 def test_token_input_transformer():
     tests = [('1.2', "Decimal ('1.2')"),
              ('"1.2"', '"1.2"'),
              ]
     tt.check_pairs(transform_and_reset(decistmt), tests)
     ml_tests = \
     [ [("a = 1.2; b = '''x", None),
        ("y'''", "a =Decimal ('1.2');b ='''x\ny'''"),
       ],
       [("a = [1.2,", None),
        ("3]", "a =[Decimal ('1.2'),\n3 ]"),
       ],
       [("a = '''foo", None),  # Test resetting when within a multi-line string
        ("bar", None),
        (None, "a = '''foo\nbar"),
       ],
     ]
     for example in ml_tests:
         transform_checker(example, decistmt)

IPython/core/tests/test_inputtransformer2.py

@@ -1,355 +1,359 b''
 """Tests for the token-based transformers in IPython.core.inputtransformer2
 
 Line-based transformers are the simpler ones; token-based transformers are
 more complex. See test_inputtransformer2_line for tests for line-based
 transformations.
 """
-import nose.tools as nt
 import string
 
 from IPython.core import inputtransformer2 as ipt2
 from IPython.core.inputtransformer2 import make_tokens_by_line, _find_assign_op
 
 from textwrap import dedent
 
 MULTILINE_MAGIC = ("""\
 a = f()
 %foo \\
 bar
 g()
 """.splitlines(keepends=True), (2, 0), """\
 a = f()
 get_ipython().run_line_magic('foo', ' bar')
 g()
 """.splitlines(keepends=True))
 
 INDENTED_MAGIC = ("""\
 for a in range(5):
     %ls
 """.splitlines(keepends=True), (2, 4), """\
 for a in range(5):
     get_ipython().run_line_magic('ls', '')
 """.splitlines(keepends=True))
 
 CRLF_MAGIC = ([
     "a = f()\n",
     "%ls\r\n",
     "g()\n"
 ], (2, 0), [
     "a = f()\n",
     "get_ipython().run_line_magic('ls', '')\n",
     "g()\n"
 ])
 
 MULTILINE_MAGIC_ASSIGN = ("""\
 a = f()
 b = %foo \\
   bar
 g()
 """.splitlines(keepends=True), (2, 4), """\
 a = f()
 b = get_ipython().run_line_magic('foo', '   bar')
 g()
 """.splitlines(keepends=True))
 
 MULTILINE_SYSTEM_ASSIGN = ("""\
 a = f()
 b = !foo \\
   bar
 g()
 """.splitlines(keepends=True), (2, 4), """\
 a = f()
 b = get_ipython().getoutput('foo    bar')
 g()
 """.splitlines(keepends=True))
 
 #####
 
 MULTILINE_SYSTEM_ASSIGN_AFTER_DEDENT = ("""\
 def test():
   for i in range(1):
     print(i)
   res =! ls
 """.splitlines(keepends=True), (4, 7), '''\
 def test():
   for i in range(1):
     print(i)
   res =get_ipython().getoutput(\' ls\')
 '''.splitlines(keepends=True))
 
 ######
 
 AUTOCALL_QUOTE = (
     [",f 1 2 3\n"], (1, 0),
     ['f("1", "2", "3")\n']
 )
 
 AUTOCALL_QUOTE2 = (
     [";f 1 2 3\n"], (1, 0),
     ['f("1 2 3")\n']
 )
 
 AUTOCALL_PAREN = (
     ["/f 1 2 3\n"], (1, 0),
     ['f(1, 2, 3)\n']
 )
 
 SIMPLE_HELP = (
     ["foo?\n"], (1, 0),
     ["get_ipython().run_line_magic('pinfo', 'foo')\n"]
 )
 
 DETAILED_HELP = (
     ["foo??\n"], (1, 0),
     ["get_ipython().run_line_magic('pinfo2', 'foo')\n"]
 )
 
 MAGIC_HELP = (
     ["%foo?\n"], (1, 0),
     ["get_ipython().run_line_magic('pinfo', '%foo')\n"]
 )
 
 HELP_IN_EXPR = (
     ["a = b + c?\n"], (1, 0),
     ["get_ipython().set_next_input('a = b + c');"
      "get_ipython().run_line_magic('pinfo', 'c')\n"]
 )
 
 HELP_CONTINUED_LINE = ("""\
 a = \\
 zip?
 """.splitlines(keepends=True), (1, 0),
 [r"get_ipython().set_next_input('a = \\\nzip');get_ipython().run_line_magic('pinfo', 'zip')" + "\n"]
 )
 
 HELP_MULTILINE = ("""\
 (a,
 b) = zip?
 """.splitlines(keepends=True), (1, 0),
 [r"get_ipython().set_next_input('(a,\nb) = zip');get_ipython().run_line_magic('pinfo', 'zip')" + "\n"]
 )
 
 HELP_UNICODE = (
     ["π.foo?\n"], (1, 0),
     ["get_ipython().run_line_magic('pinfo', 'π.foo')\n"]
 )
 
 
 def null_cleanup_transformer(lines):
     """
     A cleanup transform that returns an empty list.
     """
     return []
 
 def check_make_token_by_line_never_ends_empty():
     """
     Check that not sequence of single or double characters ends up leading to en empty list of tokens
     """
     from string import printable
     for c in printable:
-        nt.assert_not_equal(make_tokens_by_line(c)[-1], [])
+        assert make_tokens_by_line(c)[-1] != []
         for k in printable:
-            nt.assert_not_equal(make_tokens_by_line(c+k)[-1], [])
+            assert make_tokens_by_line(c + k)[-1] != []
+
 
 def check_find(transformer, case, match=True):
     sample, expected_start, _  = case
     tbl = make_tokens_by_line(sample)
     res = transformer.find(tbl)
     if match:
         # start_line is stored 0-indexed, expected values are 1-indexed
-        nt.assert_equal((res.start_line+1, res.start_col), expected_start)
+        assert (res.start_line + 1, res.start_col) == expected_start
         return res
     else:
-        nt.assert_is(res, None)
+        assert res is None
 
 def check_transform(transformer_cls, case):
     lines, start, expected = case
     transformer = transformer_cls(start)
-    nt.assert_equal(transformer.transform(lines), expected)
+    assert transformer.transform(lines) == expected
 
 def test_continued_line():
     lines = MULTILINE_MAGIC_ASSIGN[0]
-    nt.assert_equal(ipt2.find_end_of_continued_line(lines, 1), 2)
+    assert ipt2.find_end_of_continued_line(lines, 1) == 2
 
-    nt.assert_equal(ipt2.assemble_continued_line(lines, (1, 5), 2), "foo    bar")
+    assert ipt2.assemble_continued_line(lines, (1, 5), 2) == "foo    bar"
 
 def test_find_assign_magic():
     check_find(ipt2.MagicAssign, MULTILINE_MAGIC_ASSIGN)
     check_find(ipt2.MagicAssign, MULTILINE_SYSTEM_ASSIGN, match=False)
     check_find(ipt2.MagicAssign, MULTILINE_SYSTEM_ASSIGN_AFTER_DEDENT, match=False)
 
 def test_transform_assign_magic():
     check_transform(ipt2.MagicAssign, MULTILINE_MAGIC_ASSIGN)
 
 def test_find_assign_system():
     check_find(ipt2.SystemAssign, MULTILINE_SYSTEM_ASSIGN)
     check_find(ipt2.SystemAssign, MULTILINE_SYSTEM_ASSIGN_AFTER_DEDENT)
     check_find(ipt2.SystemAssign, (["a =  !ls\n"], (1, 5), None))
     check_find(ipt2.SystemAssign, (["a=!ls\n"], (1, 2), None))
     check_find(ipt2.SystemAssign, MULTILINE_MAGIC_ASSIGN, match=False)
 
 def test_transform_assign_system():
     check_transform(ipt2.SystemAssign, MULTILINE_SYSTEM_ASSIGN)
     check_transform(ipt2.SystemAssign, MULTILINE_SYSTEM_ASSIGN_AFTER_DEDENT)
 
 def test_find_magic_escape():
     check_find(ipt2.EscapedCommand, MULTILINE_MAGIC)
     check_find(ipt2.EscapedCommand, INDENTED_MAGIC)
     check_find(ipt2.EscapedCommand, MULTILINE_MAGIC_ASSIGN, match=False)
 
 def test_transform_magic_escape():
     check_transform(ipt2.EscapedCommand, MULTILINE_MAGIC)
     check_transform(ipt2.EscapedCommand, INDENTED_MAGIC)
     check_transform(ipt2.EscapedCommand, CRLF_MAGIC)
 
 def test_find_autocalls():
     for case in [AUTOCALL_QUOTE, AUTOCALL_QUOTE2, AUTOCALL_PAREN]:
         print("Testing %r" % case[0])
         check_find(ipt2.EscapedCommand, case)
 
 def test_transform_autocall():
     for case in [AUTOCALL_QUOTE, AUTOCALL_QUOTE2, AUTOCALL_PAREN]:
         print("Testing %r" % case[0])
         check_transform(ipt2.EscapedCommand, case)
 
 def test_find_help():
     for case in [SIMPLE_HELP, DETAILED_HELP, MAGIC_HELP, HELP_IN_EXPR]:
         check_find(ipt2.HelpEnd, case)
 
     tf = check_find(ipt2.HelpEnd, HELP_CONTINUED_LINE)
-    nt.assert_equal(tf.q_line, 1)
-    nt.assert_equal(tf.q_col, 3)
+    assert tf.q_line == 1
+    assert tf.q_col == 3
 
     tf = check_find(ipt2.HelpEnd, HELP_MULTILINE)
-    nt.assert_equal(tf.q_line, 1)
-    nt.assert_equal(tf.q_col, 8)
+    assert tf.q_line == 1
+    assert tf.q_col == 8
 
     # ? in a comment does not trigger help
     check_find(ipt2.HelpEnd, (["foo # bar?\n"], None, None), match=False)
     # Nor in a string
     check_find(ipt2.HelpEnd, (["foo = '''bar?\n"], None, None), match=False)
 
 def test_transform_help():
     tf = ipt2.HelpEnd((1, 0), (1, 9))
-    nt.assert_equal(tf.transform(HELP_IN_EXPR[0]), HELP_IN_EXPR[2])
+    assert tf.transform(HELP_IN_EXPR[0]) == HELP_IN_EXPR[2]
 
     tf = ipt2.HelpEnd((1, 0), (2, 3))
-    nt.assert_equal(tf.transform(HELP_CONTINUED_LINE[0]), HELP_CONTINUED_LINE[2])
+    assert tf.transform(HELP_CONTINUED_LINE[0]) == HELP_CONTINUED_LINE[2]
 
     tf = ipt2.HelpEnd((1, 0), (2, 8))
-    nt.assert_equal(tf.transform(HELP_MULTILINE[0]), HELP_MULTILINE[2])
+    assert tf.transform(HELP_MULTILINE[0]) == HELP_MULTILINE[2]
 
     tf = ipt2.HelpEnd((1, 0), (1, 0))
-    nt.assert_equal(tf.transform(HELP_UNICODE[0]), HELP_UNICODE[2])
+    assert tf.transform(HELP_UNICODE[0]) == HELP_UNICODE[2]
 
 def test_find_assign_op_dedent():
     """
     be careful that empty token like dedent are not counted as parens
     """
     class Tk:
         def __init__(self, s):
             self.string = s
 
-    nt.assert_equal(_find_assign_op([Tk(s) for s in ('','a','=','b')]), 2)
-    nt.assert_equal(_find_assign_op([Tk(s) for s in ('','(', 'a','=','b', ')', '=' ,'5')]), 6)
+    assert _find_assign_op([Tk(s) for s in ("", "a", "=", "b")]) == 2
+    assert (
+        _find_assign_op([Tk(s) for s in ("", "(", "a", "=", "b", ")", "=", "5")]) == 6
+    )
+
 
 def test_check_complete():
     cc = ipt2.TransformerManager().check_complete
-    nt.assert_equal(cc("a = 1"), ("complete", None))
-    nt.assert_equal(cc("for a in range(5):"), ("incomplete", 4))
-    nt.assert_equal(cc("for a in range(5):\n    if a > 0:"), ("incomplete", 8))
-    nt.assert_equal(cc("raise = 2"), ("invalid", None))
-    nt.assert_equal(cc("a = [1,\n2,"), ("incomplete", 0))
-    nt.assert_equal(cc("(\n))"), ("incomplete", 0))
-    nt.assert_equal(cc("\\\r\n"), ("incomplete", 0))
-    nt.assert_equal(cc("a = '''\n   hi"), ("incomplete", 3))
-    nt.assert_equal(cc("def a():\n x=1\n global x"), ("invalid", None))
-    nt.assert_equal(cc("a \\ "), ("invalid", None))  # Nothing allowed after backslash
-    nt.assert_equal(cc("1\\\n+2"), ("complete", None))
-    nt.assert_equal(cc("exit"), ("complete", None))
+    assert cc("a = 1") == ("complete", None)
+    assert cc("for a in range(5):") == ("incomplete", 4)
+    assert cc("for a in range(5):\n    if a > 0:") == ("incomplete", 8)
+    assert cc("raise = 2") == ("invalid", None)
+    assert cc("a = [1,\n2,") == ("incomplete", 0)
+    assert cc("(\n))") == ("incomplete", 0)
+    assert cc("\\\r\n") == ("incomplete", 0)
+    assert cc("a = '''\n   hi") == ("incomplete", 3)
+    assert cc("def a():\n x=1\n global x") == ("invalid", None)
+    assert cc("a \\ ") == ("invalid", None)  # Nothing allowed after backslash
+    assert cc("1\\\n+2") == ("complete", None)
+    assert cc("exit") == ("complete", None)
 
     example = dedent("""
         if True:
             a=1""" )
 
-    nt.assert_equal(cc(example), ('incomplete', 4))
-    nt.assert_equal(cc(example+'\n'), ('complete', None))
-    nt.assert_equal(cc(example+'\n    '), ('complete', None))
+    assert cc(example) == ("incomplete", 4)
+    assert cc(example + "\n") == ("complete", None)
+    assert cc(example + "\n    ") == ("complete", None)
 
     # no need to loop on all the letters/numbers.
     short = '12abAB'+string.printable[62:]
     for c in short:
         # test does not raise:
         cc(c)
         for k in short:
             cc(c+k)
 
-    nt.assert_equal(cc("def f():\n  x=0\n  \\\n  "), ('incomplete', 2))
+    assert cc("def f():\n  x=0\n  \\\n  ") == ("incomplete", 2)
+
 
 def test_check_complete_II():
     """
     Test that multiple line strings are properly handled.
 
     Separate test function for convenience
 
     """
     cc = ipt2.TransformerManager().check_complete
-    nt.assert_equal(cc('''def foo():\n    """'''), ('incomplete', 4))
+    assert cc('''def foo():\n    """''') == ("incomplete", 4)
 
 
 def test_check_complete_invalidates_sunken_brackets():
     """
     Test that a single line with more closing brackets than the opening ones is
     interpreted as invalid
     """
     cc = ipt2.TransformerManager().check_complete
-    nt.assert_equal(cc(")"), ("invalid", None))
-    nt.assert_equal(cc("]"), ("invalid", None))
-    nt.assert_equal(cc("}"), ("invalid", None))
-    nt.assert_equal(cc(")("), ("invalid", None))
-    nt.assert_equal(cc("]["), ("invalid", None))
-    nt.assert_equal(cc("}{"), ("invalid", None))
-    nt.assert_equal(cc("]()("), ("invalid", None))
-    nt.assert_equal(cc("())("), ("invalid", None))
-    nt.assert_equal(cc(")[]("), ("invalid", None))
-    nt.assert_equal(cc("()]("), ("invalid", None))
+    assert cc(")") == ("invalid", None)
+    assert cc("]") == ("invalid", None)
+    assert cc("}") == ("invalid", None)
+    assert cc(")(") == ("invalid", None)
+    assert cc("][") == ("invalid", None)
+    assert cc("}{") == ("invalid", None)
+    assert cc("]()(") == ("invalid", None)
+    assert cc("())(") == ("invalid", None)
+    assert cc(")[](") == ("invalid", None)
+    assert cc("()](") == ("invalid", None)
 
 
 def test_null_cleanup_transformer():
     manager = ipt2.TransformerManager()
     manager.cleanup_transforms.insert(0, null_cleanup_transformer)
-    assert  manager.transform_cell("") == ""
+    assert manager.transform_cell("") == ""
 
 
 
 
 def test_side_effects_I():
     count = 0
     def counter(lines):
         nonlocal count
         count += 1
         return lines
 
     counter.has_side_effects = True
 
     manager = ipt2.TransformerManager()
     manager.cleanup_transforms.insert(0, counter)
     assert manager.check_complete("a=1\n") == ('complete', None)
     assert count == 0
 
 
 
 
 def test_side_effects_II():
     count = 0
     def counter(lines):
         nonlocal count
         count += 1
         return lines
 
     counter.has_side_effects = True
 
     manager = ipt2.TransformerManager()
     manager.line_transforms.insert(0, counter)
     assert manager.check_complete("b=1\n") == ('complete', None)
     assert count == 0

IPython/core/tests/test_interactiveshell.py

@@ -1,1068 +1,1072 b''
 # -*- coding: utf-8 -*-
 """Tests for the key interactiveshell module.
 
 Historically the main classes in interactiveshell have been under-tested.  This
 module should grow as many single-method tests as possible to trap many of the
 recurring bugs we seem to encounter with high-level interaction.
 """
 
 # Copyright (c) IPython Development Team.
 # Distributed under the terms of the Modified BSD License.
 
 import asyncio
 import ast
 import os
 import signal
 import shutil
 import sys
 import tempfile
 import unittest
 from unittest import mock
 
 from os.path import join
 
-import nose.tools as nt
-
 from IPython.core.error import InputRejected
 from IPython.core.inputtransformer import InputTransformer
 from IPython.core import interactiveshell
 from IPython.testing.decorators import (
     skipif, skip_win32, onlyif_unicode_paths, onlyif_cmds_exist,
 )
 from IPython.testing import tools as tt
 from IPython.utils.process import find_cmd
 
 #-----------------------------------------------------------------------------
 # Globals
 #-----------------------------------------------------------------------------
 # This is used by every single test, no point repeating it ad nauseam
 
 #-----------------------------------------------------------------------------
 # Tests
 #-----------------------------------------------------------------------------
 
 class DerivedInterrupt(KeyboardInterrupt):
     pass
 
 class InteractiveShellTestCase(unittest.TestCase):
     def test_naked_string_cells(self):
         """Test that cells with only naked strings are fully executed"""
         # First, single-line inputs
         ip.run_cell('"a"\n')
         self.assertEqual(ip.user_ns['_'], 'a')
         # And also multi-line cells
         ip.run_cell('"""a\nb"""\n')
         self.assertEqual(ip.user_ns['_'], 'a\nb')
 
     def test_run_empty_cell(self):
         """Just make sure we don't get a horrible error with a blank
         cell of input. Yes, I did overlook that."""
         old_xc = ip.execution_count
         res = ip.run_cell('')
         self.assertEqual(ip.execution_count, old_xc)
         self.assertEqual(res.execution_count, None)
 
     def test_run_cell_multiline(self):
         """Multi-block, multi-line cells must execute correctly.
         """
         src = '\n'.join(["x=1",
                          "y=2",
                          "if 1:",
                          "    x += 1",
                          "    y += 1",])
         res = ip.run_cell(src)
         self.assertEqual(ip.user_ns['x'], 2)
         self.assertEqual(ip.user_ns['y'], 3)
         self.assertEqual(res.success, True)
         self.assertEqual(res.result, None)
 
     def test_multiline_string_cells(self):
         "Code sprinkled with multiline strings should execute (GH-306)"
         ip.run_cell('tmp=0')
         self.assertEqual(ip.user_ns['tmp'], 0)
         res = ip.run_cell('tmp=1;"""a\nb"""\n')
         self.assertEqual(ip.user_ns['tmp'], 1)
         self.assertEqual(res.success, True)
         self.assertEqual(res.result, "a\nb")
 
     def test_dont_cache_with_semicolon(self):
         "Ending a line with semicolon should not cache the returned object (GH-307)"
         oldlen = len(ip.user_ns['Out'])
         for cell in ['1;', '1;1;']:
             res = ip.run_cell(cell, store_history=True)
             newlen = len(ip.user_ns['Out'])
             self.assertEqual(oldlen, newlen)
             self.assertIsNone(res.result)
         i = 0
         #also test the default caching behavior
         for cell in ['1', '1;1']:
             ip.run_cell(cell, store_history=True)
             newlen = len(ip.user_ns['Out'])
             i += 1
             self.assertEqual(oldlen+i, newlen)
 
     def test_syntax_error(self):
         res = ip.run_cell("raise = 3")
         self.assertIsInstance(res.error_before_exec, SyntaxError)
 
     def test_In_variable(self):
         "Verify that In variable grows with user input (GH-284)"
         oldlen = len(ip.user_ns['In'])
         ip.run_cell('1;', store_history=True)
         newlen = len(ip.user_ns['In'])
         self.assertEqual(oldlen+1, newlen)
         self.assertEqual(ip.user_ns['In'][-1],'1;')
         
     def test_magic_names_in_string(self):
         ip.run_cell('a = """\n%exit\n"""')
         self.assertEqual(ip.user_ns['a'], '\n%exit\n')
     
     def test_trailing_newline(self):
         """test that running !(command) does not raise a SyntaxError"""
         ip.run_cell('!(true)\n', False)
         ip.run_cell('!(true)\n\n\n', False)
     
     def test_gh_597(self):
         """Pretty-printing lists of objects with non-ascii reprs may cause
         problems."""
         class Spam(object):
             def __repr__(self):
                 return "\xe9"*50
         import IPython.core.formatters
         f = IPython.core.formatters.PlainTextFormatter()
         f([Spam(),Spam()])
     
 
     def test_future_flags(self):
         """Check that future flags are used for parsing code (gh-777)"""
         ip.run_cell('from __future__ import barry_as_FLUFL')
         try:
             ip.run_cell('prfunc_return_val = 1 <> 2')
             assert 'prfunc_return_val' in ip.user_ns
         finally:
             # Reset compiler flags so we don't mess up other tests.
             ip.compile.reset_compiler_flags()
 
     def test_can_pickle(self):
         "Can we pickle objects defined interactively (GH-29)"
         ip = get_ipython()
         ip.reset()
         ip.run_cell(("class Mylist(list):\n"
                      "    def __init__(self,x=[]):\n"
                      "        list.__init__(self,x)"))
         ip.run_cell("w=Mylist([1,2,3])")
         
         from pickle import dumps
         
         # We need to swap in our main module - this is only necessary
         # inside the test framework, because IPython puts the interactive module
         # in place (but the test framework undoes this).
         _main = sys.modules['__main__']
         sys.modules['__main__'] = ip.user_module
         try:
             res = dumps(ip.user_ns["w"])
         finally:
             sys.modules['__main__'] = _main
         self.assertTrue(isinstance(res, bytes))
         
     def test_global_ns(self):
         "Code in functions must be able to access variables outside them."
         ip = get_ipython()
         ip.run_cell("a = 10")
         ip.run_cell(("def f(x):\n"
                      "    return x + a"))
         ip.run_cell("b = f(12)")
         self.assertEqual(ip.user_ns["b"], 22)
 
     def test_bad_custom_tb(self):
         """Check that InteractiveShell is protected from bad custom exception handlers"""
         ip.set_custom_exc((IOError,), lambda etype,value,tb: 1/0)
         self.assertEqual(ip.custom_exceptions, (IOError,))
         with tt.AssertPrints("Custom TB Handler failed", channel='stderr'):
             ip.run_cell(u'raise IOError("foo")')
         self.assertEqual(ip.custom_exceptions, ())
 
     def test_bad_custom_tb_return(self):
         """Check that InteractiveShell is protected from bad return types in custom exception handlers"""
         ip.set_custom_exc((NameError,),lambda etype,value,tb, tb_offset=None: 1)
         self.assertEqual(ip.custom_exceptions, (NameError,))
         with tt.AssertPrints("Custom TB Handler failed", channel='stderr'):
             ip.run_cell(u'a=abracadabra')
         self.assertEqual(ip.custom_exceptions, ())
 
     def test_drop_by_id(self):
         myvars = {"a":object(), "b":object(), "c": object()}
         ip.push(myvars, interactive=False)
         for name in myvars:
             assert name in ip.user_ns, name
             assert name in ip.user_ns_hidden, name
         ip.user_ns['b'] = 12
         ip.drop_by_id(myvars)
         for name in ["a", "c"]:
             assert name not in ip.user_ns, name
             assert name not in ip.user_ns_hidden, name
         assert ip.user_ns['b'] == 12
         ip.reset()
 
     def test_var_expand(self):
         ip.user_ns['f'] = u'Ca\xf1o'
         self.assertEqual(ip.var_expand(u'echo $f'), u'echo Ca\xf1o')
         self.assertEqual(ip.var_expand(u'echo {f}'), u'echo Ca\xf1o')
         self.assertEqual(ip.var_expand(u'echo {f[:-1]}'), u'echo Ca\xf1')
         self.assertEqual(ip.var_expand(u'echo {1*2}'), u'echo 2')
         
         self.assertEqual(ip.var_expand(u"grep x | awk '{print $1}'"), u"grep x | awk '{print $1}'")
 
         ip.user_ns['f'] = b'Ca\xc3\xb1o'
         # This should not raise any exception:
         ip.var_expand(u'echo $f')
    
     def test_var_expand_local(self):
         """Test local variable expansion in !system and %magic calls"""
         # !system
-        ip.run_cell('def test():\n'
-                    '    lvar = "ttt"\n'
-                    '    ret = !echo {lvar}\n'
-                    '    return ret[0]\n')
-        res = ip.user_ns['test']()
-        nt.assert_in('ttt', res)
-        
+        ip.run_cell(
+            "def test():\n"
+            '    lvar = "ttt"\n'
+            "    ret = !echo {lvar}\n"
+            "    return ret[0]\n"
+        )
+        res = ip.user_ns["test"]()
+        self.assertIn("ttt", res)
+
         # %magic
-        ip.run_cell('def makemacro():\n'
-                    '    macroname = "macro_var_expand_locals"\n'
-                    '    %macro {macroname} codestr\n')
-        ip.user_ns['codestr'] = "str(12)"
-        ip.run_cell('makemacro()')
-        nt.assert_in('macro_var_expand_locals', ip.user_ns)
-    
+        ip.run_cell(
+            "def makemacro():\n"
+            '    macroname = "macro_var_expand_locals"\n'
+            "    %macro {macroname} codestr\n"
+        )
+        ip.user_ns["codestr"] = "str(12)"
+        ip.run_cell("makemacro()")
+        self.assertIn("macro_var_expand_locals", ip.user_ns)
+
     def test_var_expand_self(self):
         """Test variable expansion with the name 'self', which was failing.
         
         See https://github.com/ipython/ipython/issues/1878#issuecomment-7698218
         """
-        ip.run_cell('class cTest:\n'
-                    '  classvar="see me"\n'
-                    '  def test(self):\n'
-                    '    res = !echo Variable: {self.classvar}\n'
-                    '    return res[0]\n')
-        nt.assert_in('see me', ip.user_ns['cTest']().test())
-    
+        ip.run_cell(
+            "class cTest:\n"
+            '  classvar="see me"\n'
+            "  def test(self):\n"
+            "    res = !echo Variable: {self.classvar}\n"
+            "    return res[0]\n"
+        )
+        self.assertIn("see me", ip.user_ns["cTest"]().test())
+
     def test_bad_var_expand(self):
         """var_expand on invalid formats shouldn't raise"""
         # SyntaxError
         self.assertEqual(ip.var_expand(u"{'a':5}"), u"{'a':5}")
         # NameError
         self.assertEqual(ip.var_expand(u"{asdf}"), u"{asdf}")
         # ZeroDivisionError
         self.assertEqual(ip.var_expand(u"{1/0}"), u"{1/0}")
     
     def test_silent_postexec(self):
         """run_cell(silent=True) doesn't invoke pre/post_run_cell callbacks"""
         pre_explicit = mock.Mock()
         pre_always = mock.Mock()
         post_explicit = mock.Mock()
         post_always = mock.Mock()
         all_mocks = [pre_explicit, pre_always, post_explicit, post_always]
         
         ip.events.register('pre_run_cell', pre_explicit)
         ip.events.register('pre_execute', pre_always)
         ip.events.register('post_run_cell', post_explicit)
         ip.events.register('post_execute', post_always)
         
         try:
             ip.run_cell("1", silent=True)
             assert pre_always.called
             assert not pre_explicit.called
             assert post_always.called
             assert not post_explicit.called
             # double-check that non-silent exec did what we expected
             # silent to avoid
             ip.run_cell("1")
             assert pre_explicit.called
             assert post_explicit.called
             info, = pre_explicit.call_args[0]
             result, = post_explicit.call_args[0]
             self.assertEqual(info, result.info)
             # check that post hooks are always called
             [m.reset_mock() for m in all_mocks]
             ip.run_cell("syntax error")
             assert pre_always.called
             assert pre_explicit.called
             assert post_always.called
             assert post_explicit.called
             info, = pre_explicit.call_args[0]
             result, = post_explicit.call_args[0]
             self.assertEqual(info, result.info)
         finally:
             # remove post-exec
             ip.events.unregister('pre_run_cell', pre_explicit)
             ip.events.unregister('pre_execute', pre_always)
             ip.events.unregister('post_run_cell', post_explicit)
             ip.events.unregister('post_execute', post_always)
     
     def test_silent_noadvance(self):
         """run_cell(silent=True) doesn't advance execution_count"""
         ec = ip.execution_count
         # silent should force store_history=False
         ip.run_cell("1", store_history=True, silent=True)
         
         self.assertEqual(ec, ip.execution_count)
         # double-check that non-silent exec did what we expected
         # silent to avoid
         ip.run_cell("1", store_history=True)
         self.assertEqual(ec+1, ip.execution_count)
     
     def test_silent_nodisplayhook(self):
         """run_cell(silent=True) doesn't trigger displayhook"""
         d = dict(called=False)
         
         trap = ip.display_trap
         save_hook = trap.hook
         
         def failing_hook(*args, **kwargs):
             d['called'] = True
         
         try:
             trap.hook = failing_hook
             res = ip.run_cell("1", silent=True)
             self.assertFalse(d['called'])
             self.assertIsNone(res.result)
             # double-check that non-silent exec did what we expected
             # silent to avoid
             ip.run_cell("1")
             self.assertTrue(d['called'])
         finally:
             trap.hook = save_hook
 
     def test_ofind_line_magic(self):
         from IPython.core.magic import register_line_magic
         
         @register_line_magic
         def lmagic(line):
             "A line magic"
 
         # Get info on line magic
         lfind = ip._ofind('lmagic')
         info = dict(found=True, isalias=False, ismagic=True,
                     namespace = 'IPython internal', obj= lmagic.__wrapped__,
                     parent = None)
-        nt.assert_equal(lfind, info)
+        self.assertEqual(lfind, info)
         
     def test_ofind_cell_magic(self):
         from IPython.core.magic import register_cell_magic
         
         @register_cell_magic
         def cmagic(line, cell):
             "A cell magic"
 
         # Get info on cell magic
         find = ip._ofind('cmagic')
         info = dict(found=True, isalias=False, ismagic=True,
                     namespace = 'IPython internal', obj= cmagic.__wrapped__,
                     parent = None)
-        nt.assert_equal(find, info)
+        self.assertEqual(find, info)
 
     def test_ofind_property_with_error(self):
         class A(object):
             @property
             def foo(self):
                 raise NotImplementedError()
         a = A()
 
         found = ip._ofind('a.foo', [('locals', locals())])
         info = dict(found=True, isalias=False, ismagic=False,
                     namespace='locals', obj=A.foo, parent=a)
-        nt.assert_equal(found, info)
+        self.assertEqual(found, info)
 
     def test_ofind_multiple_attribute_lookups(self):
         class A(object):
             @property
             def foo(self):
                 raise NotImplementedError()
 
         a = A()
         a.a = A()
         a.a.a = A()
 
         found = ip._ofind('a.a.a.foo', [('locals', locals())])
         info = dict(found=True, isalias=False, ismagic=False,
                     namespace='locals', obj=A.foo, parent=a.a.a)
-        nt.assert_equal(found, info)
+        self.assertEqual(found, info)
 
     def test_ofind_slotted_attributes(self):
         class A(object):
             __slots__ = ['foo']
             def __init__(self):
                 self.foo = 'bar'
 
         a = A()
         found = ip._ofind('a.foo', [('locals', locals())])
         info = dict(found=True, isalias=False, ismagic=False,
                     namespace='locals', obj=a.foo, parent=a)
-        nt.assert_equal(found, info)
+        self.assertEqual(found, info)
 
         found = ip._ofind('a.bar', [('locals', locals())])
         info = dict(found=False, isalias=False, ismagic=False,
                     namespace=None, obj=None, parent=a)
-        nt.assert_equal(found, info)
+        self.assertEqual(found, info)
 
     def test_ofind_prefers_property_to_instance_level_attribute(self):
         class A(object):
             @property
             def foo(self):
                 return 'bar'
         a = A()
-        a.__dict__['foo'] = 'baz'
-        nt.assert_equal(a.foo, 'bar')
-        found = ip._ofind('a.foo', [('locals', locals())])
-        nt.assert_is(found['obj'], A.foo)
+        a.__dict__["foo"] = "baz"
+        self.assertEqual(a.foo, "bar")
+        found = ip._ofind("a.foo", [("locals", locals())])
+        self.assertIs(found["obj"], A.foo)
 
     def test_custom_syntaxerror_exception(self):
         called = []
         def my_handler(shell, etype, value, tb, tb_offset=None):
             called.append(etype)
             shell.showtraceback((etype, value, tb), tb_offset=tb_offset)
 
         ip.set_custom_exc((SyntaxError,), my_handler)
         try:
             ip.run_cell("1f")
             # Check that this was called, and only once.
             self.assertEqual(called, [SyntaxError])
         finally:
             # Reset the custom exception hook
             ip.set_custom_exc((), None)
 
     def test_custom_exception(self):
         called = []
         def my_handler(shell, etype, value, tb, tb_offset=None):
             called.append(etype)
             shell.showtraceback((etype, value, tb), tb_offset=tb_offset)
         
         ip.set_custom_exc((ValueError,), my_handler)
         try:
             res = ip.run_cell("raise ValueError('test')")
             # Check that this was called, and only once.
             self.assertEqual(called, [ValueError])
             # Check that the error is on the result object
             self.assertIsInstance(res.error_in_exec, ValueError)
         finally:
             # Reset the custom exception hook
             ip.set_custom_exc((), None)
     
     @mock.patch("builtins.print")
     def test_showtraceback_with_surrogates(self, mocked_print):
         values = []
 
         def mock_print_func(value, sep=" ", end="\n", file=sys.stdout, flush=False):
             values.append(value)
             if value == chr(0xD8FF):
                 raise UnicodeEncodeError("utf-8", chr(0xD8FF), 0, 1, "")
 
         # mock builtins.print
         mocked_print.side_effect = mock_print_func
 
         # ip._showtraceback() is replaced in globalipapp.py.
         # Call original method to test.
         interactiveshell.InteractiveShell._showtraceback(ip, None, None, chr(0xD8FF))
 
         self.assertEqual(mocked_print.call_count, 2)
         self.assertEqual(values, [chr(0xD8FF), "\\ud8ff"])
 
     def test_mktempfile(self):
         filename = ip.mktempfile()
         # Check that we can open the file again on Windows
         with open(filename, 'w') as f:
             f.write('abc')
 
         filename = ip.mktempfile(data='blah')
         with open(filename, 'r') as f:
             self.assertEqual(f.read(), 'blah')
 
     def test_new_main_mod(self):
         # Smoketest to check that this accepts a unicode module name
         name = u'jiefmw'
         mod = ip.new_main_mod(u'%s.py' % name, name)
         self.assertEqual(mod.__name__, name)
 
     def test_get_exception_only(self):
         try:
             raise KeyboardInterrupt
         except KeyboardInterrupt:
             msg = ip.get_exception_only()
         self.assertEqual(msg, 'KeyboardInterrupt\n')
 
         try:
             raise DerivedInterrupt("foo")
         except KeyboardInterrupt:
             msg = ip.get_exception_only()
         self.assertEqual(msg, 'IPython.core.tests.test_interactiveshell.DerivedInterrupt: foo\n')
 
     def test_inspect_text(self):
         ip.run_cell('a = 5')
         text = ip.object_inspect_text('a')
         self.assertIsInstance(text, str)
 
     def test_last_execution_result(self):
         """ Check that last execution result gets set correctly (GH-10702) """
         result = ip.run_cell('a = 5; a')
         self.assertTrue(ip.last_execution_succeeded)
         self.assertEqual(ip.last_execution_result.result, 5)
 
         result = ip.run_cell('a = x_invalid_id_x')
         self.assertFalse(ip.last_execution_succeeded)
         self.assertFalse(ip.last_execution_result.success)
         self.assertIsInstance(ip.last_execution_result.error_in_exec, NameError)
 
     def test_reset_aliasing(self):
         """ Check that standard posix aliases work after %reset. """
         if os.name != 'posix':
             return
 
         ip.reset()
         for cmd in ('clear', 'more', 'less', 'man'):
             res = ip.run_cell('%' + cmd)
             self.assertEqual(res.success, True)
 
 
 class TestSafeExecfileNonAsciiPath(unittest.TestCase):
 
     @onlyif_unicode_paths
     def setUp(self):
         self.BASETESTDIR = tempfile.mkdtemp()
         self.TESTDIR = join(self.BASETESTDIR, u"åäö")
         os.mkdir(self.TESTDIR)
         with open(join(self.TESTDIR, u"åäötestscript.py"), "w") as sfile:
             sfile.write("pass\n")
         self.oldpath = os.getcwd()
         os.chdir(self.TESTDIR)
         self.fname = u"åäötestscript.py"
 
     def tearDown(self):
         os.chdir(self.oldpath)
         shutil.rmtree(self.BASETESTDIR)
 
     @onlyif_unicode_paths
     def test_1(self):
         """Test safe_execfile with non-ascii path
         """
         ip.safe_execfile(self.fname, {}, raise_exceptions=True)
 
 class ExitCodeChecks(tt.TempFileMixin):
 
     def setUp(self):
         self.system = ip.system_raw
 
     def test_exit_code_ok(self):
         self.system('exit 0')
         self.assertEqual(ip.user_ns['_exit_code'], 0)
 
     def test_exit_code_error(self):
         self.system('exit 1')
         self.assertEqual(ip.user_ns['_exit_code'], 1)
     
     @skipif(not hasattr(signal, 'SIGALRM'))
     def test_exit_code_signal(self):
         self.mktmp("import signal, time\n"
                    "signal.setitimer(signal.ITIMER_REAL, 0.1)\n"
                    "time.sleep(1)\n")
         self.system("%s %s" % (sys.executable, self.fname))
         self.assertEqual(ip.user_ns['_exit_code'], -signal.SIGALRM)
     
     @onlyif_cmds_exist("csh")
     def test_exit_code_signal_csh(self):
         SHELL = os.environ.get('SHELL', None)
         os.environ['SHELL'] = find_cmd("csh")
         try:
             self.test_exit_code_signal()
         finally:
             if SHELL is not None:
                 os.environ['SHELL'] = SHELL
             else:
                 del os.environ['SHELL']
 
 
 class TestSystemRaw(ExitCodeChecks):
 
     def setUp(self):
         super().setUp()
         self.system = ip.system_raw
 
     @onlyif_unicode_paths
     def test_1(self):
         """Test system_raw with non-ascii cmd
         """
         cmd = u'''python -c "'åäö'"   '''
         ip.system_raw(cmd)
 
     @mock.patch('subprocess.call', side_effect=KeyboardInterrupt)
     @mock.patch('os.system', side_effect=KeyboardInterrupt)
     def test_control_c(self, *mocks):
         try:
             self.system("sleep 1 # wont happen")
         except KeyboardInterrupt:
             self.fail(
                 "system call should intercept "
                 "keyboard interrupt from subprocess.call"
             )
         self.assertEqual(ip.user_ns["_exit_code"], -signal.SIGINT)
 
     def test_magic_warnings(self):
         for magic_cmd in ("ls", "pip", "conda", "cd"):
             with self.assertWarnsRegex(Warning, "You executed the system command"):
                 ip.system_raw(magic_cmd)
 
 # TODO: Exit codes are currently ignored on Windows.
 class TestSystemPipedExitCode(ExitCodeChecks):
 
     def setUp(self):
         super().setUp()
         self.system = ip.system_piped
 
     @skip_win32
     def test_exit_code_ok(self):
         ExitCodeChecks.test_exit_code_ok(self)
 
     @skip_win32
     def test_exit_code_error(self):
         ExitCodeChecks.test_exit_code_error(self)
 
     @skip_win32
     def test_exit_code_signal(self):
         ExitCodeChecks.test_exit_code_signal(self)
 
 class TestModules(tt.TempFileMixin):
     def test_extraneous_loads(self):
         """Test we're not loading modules on startup that we shouldn't.
         """
         self.mktmp("import sys\n"
                    "print('numpy' in sys.modules)\n"
                    "print('ipyparallel' in sys.modules)\n"
                    "print('ipykernel' in sys.modules)\n"
                    )
         out = "False\nFalse\nFalse\n"
         tt.ipexec_validate(self.fname, out)
 
 class Negator(ast.NodeTransformer):
     """Negates all number literals in an AST."""
 
     # for python 3.7 and earlier
     def visit_Num(self, node):
         node.n = -node.n
         return node
 
     # for python 3.8+
     def visit_Constant(self, node):
         if isinstance(node.value, int):
             return self.visit_Num(node)
         return node
 
 class TestAstTransform(unittest.TestCase):
     def setUp(self):
         self.negator = Negator()
         ip.ast_transformers.append(self.negator)
     
     def tearDown(self):
         ip.ast_transformers.remove(self.negator)
     
     def test_run_cell(self):
         with tt.AssertPrints('-34'):
             ip.run_cell('print (12 + 22)')
         
         # A named reference to a number shouldn't be transformed.
         ip.user_ns['n'] = 55
         with tt.AssertNotPrints('-55'):
             ip.run_cell('print (n)')
     
     def test_timeit(self):
         called = set()
         def f(x):
             called.add(x)
         ip.push({'f':f})
         
         with tt.AssertPrints("std. dev. of"):
             ip.run_line_magic("timeit", "-n1 f(1)")
         self.assertEqual(called, {-1})
         called.clear()
 
         with tt.AssertPrints("std. dev. of"):
             ip.run_cell_magic("timeit", "-n1 f(2)", "f(3)")
         self.assertEqual(called, {-2, -3})
     
     def test_time(self):
         called = []
         def f(x):
             called.append(x)
         ip.push({'f':f})
         
         # Test with an expression
         with tt.AssertPrints("Wall time: "):
             ip.run_line_magic("time", "f(5+9)")
         self.assertEqual(called, [-14])
         called[:] = []
         
         # Test with a statement (different code path)
         with tt.AssertPrints("Wall time: "):
             ip.run_line_magic("time", "a = f(-3 + -2)")
         self.assertEqual(called, [5])
     
     def test_macro(self):
         ip.push({'a':10})
         # The AST transformation makes this do a+=-1
         ip.define_macro("amacro", "a+=1\nprint(a)")
         
         with tt.AssertPrints("9"):
             ip.run_cell("amacro")
         with tt.AssertPrints("8"):
             ip.run_cell("amacro")
 
 class TestMiscTransform(unittest.TestCase):
 
 
     def test_transform_only_once(self):
         cleanup = 0
         line_t = 0
         def count_cleanup(lines):
             nonlocal cleanup
             cleanup += 1
             return lines
 
         def count_line_t(lines):
             nonlocal line_t
             line_t += 1
             return lines
 
         ip.input_transformer_manager.cleanup_transforms.append(count_cleanup)
         ip.input_transformer_manager.line_transforms.append(count_line_t)
 
         ip.run_cell('1')
 
         assert cleanup == 1
         assert line_t == 1
 
 class IntegerWrapper(ast.NodeTransformer):
     """Wraps all integers in a call to Integer()"""
 
     # for Python 3.7 and earlier
 
     # for Python 3.7 and earlier
     def visit_Num(self, node):
         if isinstance(node.n, int):
             return ast.Call(func=ast.Name(id='Integer', ctx=ast.Load()),
                             args=[node], keywords=[])
         return node
 
     # For Python 3.8+
     def visit_Constant(self, node):
         if isinstance(node.value, int):
             return self.visit_Num(node)
         return node
 
 
 class TestAstTransform2(unittest.TestCase):
     def setUp(self):
         self.intwrapper = IntegerWrapper()
         ip.ast_transformers.append(self.intwrapper)
         
         self.calls = []
         def Integer(*args):
             self.calls.append(args)
             return args
         ip.push({"Integer": Integer})
     
     def tearDown(self):
         ip.ast_transformers.remove(self.intwrapper)
         del ip.user_ns['Integer']
     
     def test_run_cell(self):
         ip.run_cell("n = 2")
         self.assertEqual(self.calls, [(2,)])
         
         # This shouldn't throw an error
         ip.run_cell("o = 2.0")
         self.assertEqual(ip.user_ns['o'], 2.0)
     
     def test_timeit(self):
         called = set()
         def f(x):
             called.add(x)
         ip.push({'f':f})
 
         with tt.AssertPrints("std. dev. of"):
             ip.run_line_magic("timeit", "-n1 f(1)")
         self.assertEqual(called, {(1,)})
         called.clear()
 
         with tt.AssertPrints("std. dev. of"):
             ip.run_cell_magic("timeit", "-n1 f(2)", "f(3)")
         self.assertEqual(called, {(2,), (3,)})
 
 class ErrorTransformer(ast.NodeTransformer):
     """Throws an error when it sees a number."""
 
     # for Python 3.7 and earlier
     def visit_Num(self, node):
         raise ValueError("test")
 
     # for Python 3.8+
     def visit_Constant(self, node):
         if isinstance(node.value, int):
             return self.visit_Num(node)
         return node
 
 
 class TestAstTransformError(unittest.TestCase):
     def test_unregistering(self):
         err_transformer = ErrorTransformer()
         ip.ast_transformers.append(err_transformer)
         
         with self.assertWarnsRegex(UserWarning, "It will be unregistered"):
             ip.run_cell("1 + 2")
         
         # This should have been removed.
-        nt.assert_not_in(err_transformer, ip.ast_transformers)
+        self.assertNotIn(err_transformer, ip.ast_transformers)
 
 
 class StringRejector(ast.NodeTransformer):
     """Throws an InputRejected when it sees a string literal.
 
     Used to verify that NodeTransformers can signal that a piece of code should
     not be executed by throwing an InputRejected.
     """
     
     #for python 3.7 and earlier
     def visit_Str(self, node):
         raise InputRejected("test")
 
     # 3.8 only
     def visit_Constant(self, node):
         if isinstance(node.value, str):
             raise InputRejected("test")
         return node
 
 
 class TestAstTransformInputRejection(unittest.TestCase):
 
     def setUp(self):
         self.transformer = StringRejector()
         ip.ast_transformers.append(self.transformer)
 
     def tearDown(self):
         ip.ast_transformers.remove(self.transformer)
 
     def test_input_rejection(self):
         """Check that NodeTransformers can reject input."""
 
         expect_exception_tb = tt.AssertPrints("InputRejected: test")
         expect_no_cell_output = tt.AssertNotPrints("'unsafe'", suppress=False)
 
         # Run the same check twice to verify that the transformer is not
         # disabled after raising.
         with expect_exception_tb, expect_no_cell_output:
             ip.run_cell("'unsafe'")
 
         with expect_exception_tb, expect_no_cell_output:
             res = ip.run_cell("'unsafe'")
 
         self.assertIsInstance(res.error_before_exec, InputRejected)
 
 def test__IPYTHON__():
     # This shouldn't raise a NameError, that's all
     __IPYTHON__
 
 
 class DummyRepr(object):
     def __repr__(self):
         return "DummyRepr"
     
     def _repr_html_(self):
         return "<b>dummy</b>"
     
     def _repr_javascript_(self):
         return "console.log('hi');", {'key': 'value'}
     
 
 def test_user_variables():
     # enable all formatters
     ip.display_formatter.active_types = ip.display_formatter.format_types
     
     ip.user_ns['dummy'] = d = DummyRepr()
     keys = {'dummy', 'doesnotexist'}
     r = ip.user_expressions({ key:key for key in keys})
 
-    nt.assert_equal(keys, set(r.keys()))
-    dummy = r['dummy']
-    nt.assert_equal({'status', 'data', 'metadata'}, set(dummy.keys()))
-    nt.assert_equal(dummy['status'], 'ok')
-    data = dummy['data']
-    metadata = dummy['metadata']
-    nt.assert_equal(data.get('text/html'), d._repr_html_())
+    assert keys == set(r.keys())
+    dummy = r["dummy"]
+    assert {"status", "data", "metadata"} == set(dummy.keys())
+    assert dummy["status"] == "ok"
+    data = dummy["data"]
+    metadata = dummy["metadata"]
+    assert data.get("text/html") == d._repr_html_()
     js, jsmd = d._repr_javascript_()
-    nt.assert_equal(data.get('application/javascript'), js)
-    nt.assert_equal(metadata.get('application/javascript'), jsmd)
-    
-    dne = r['doesnotexist']
-    nt.assert_equal(dne['status'], 'error')
-    nt.assert_equal(dne['ename'], 'NameError')
-    
+    assert data.get("application/javascript") == js
+    assert metadata.get("application/javascript") == jsmd
+
+    dne = r["doesnotexist"]
+    assert dne["status"] == "error"
+    assert dne["ename"] == "NameError"
+
     # back to text only
     ip.display_formatter.active_types = ['text/plain']
     
 def test_user_expression():
     # enable all formatters
     ip.display_formatter.active_types = ip.display_formatter.format_types
     query = {
         'a' : '1 + 2',
         'b' : '1/0',
     }
     r = ip.user_expressions(query)
     import pprint
     pprint.pprint(r)
-    nt.assert_equal(set(r.keys()), set(query.keys()))
-    a = r['a']
-    nt.assert_equal({'status', 'data', 'metadata'}, set(a.keys()))
-    nt.assert_equal(a['status'], 'ok')
-    data = a['data']
-    metadata = a['metadata']
-    nt.assert_equal(data.get('text/plain'), '3')
-    
-    b = r['b']
-    nt.assert_equal(b['status'], 'error')
-    nt.assert_equal(b['ename'], 'ZeroDivisionError')
-    
+    assert set(r.keys()) == set(query.keys())
+    a = r["a"]
+    assert {"status", "data", "metadata"} == set(a.keys())
+    assert a["status"] == "ok"
+    data = a["data"]
+    metadata = a["metadata"]
+    assert data.get("text/plain") == "3"
+
+    b = r["b"]
+    assert b["status"] == "error"
+    assert b["ename"] == "ZeroDivisionError"
+
     # back to text only
     ip.display_formatter.active_types = ['text/plain']
 
 
 class TestSyntaxErrorTransformer(unittest.TestCase):
     """Check that SyntaxError raised by an input transformer is handled by run_cell()"""
 
     @staticmethod
     def transformer(lines):
         for line in lines:
             pos = line.find('syntaxerror')
             if pos >= 0:
                 e = SyntaxError('input contains "syntaxerror"')
                 e.text = line
                 e.offset = pos + 1
                 raise e
         return lines
 
     def setUp(self):
         ip.input_transformers_post.append(self.transformer)
 
     def tearDown(self):
         ip.input_transformers_post.remove(self.transformer)
 
     def test_syntaxerror_input_transformer(self):
         with tt.AssertPrints('1234'):
             ip.run_cell('1234')
         with tt.AssertPrints('SyntaxError: invalid syntax'):
             ip.run_cell('1 2 3')   # plain python syntax error
         with tt.AssertPrints('SyntaxError: input contains "syntaxerror"'):
             ip.run_cell('2345  # syntaxerror')  # input transformer syntax error
         with tt.AssertPrints('3456'):
             ip.run_cell('3456')
 
 
 class TestWarningSuppression(unittest.TestCase):
     def test_warning_suppression(self):
         ip.run_cell("import warnings")
         try:
             with self.assertWarnsRegex(UserWarning, "asdf"):
                 ip.run_cell("warnings.warn('asdf')")
             # Here's the real test -- if we run that again, we should get the
             # warning again. Traditionally, each warning was only issued once per
             # IPython session (approximately), even if the user typed in new and
             # different code that should have also triggered the warning, leading
             # to much confusion.
             with self.assertWarnsRegex(UserWarning, "asdf"):
                 ip.run_cell("warnings.warn('asdf')")
         finally:
             ip.run_cell("del warnings")
 
 
     def test_deprecation_warning(self):
         ip.run_cell("""
 import warnings
 def wrn():
     warnings.warn(
         "I AM  A WARNING",
         DeprecationWarning
     )
         """)
         try:
             with self.assertWarnsRegex(DeprecationWarning, "I AM  A WARNING"):
                 ip.run_cell("wrn()")
         finally:
             ip.run_cell("del warnings")
             ip.run_cell("del wrn")
 
 
 class TestImportNoDeprecate(tt.TempFileMixin):
 
     def setUp(self):
         """Make a valid python temp file."""
         self.mktmp("""
 import warnings
 def wrn():
     warnings.warn(
         "I AM  A WARNING",
         DeprecationWarning
     )
 """)
         super().setUp()
 
     def test_no_dep(self):
         """
         No deprecation warning should be raised from imported functions
         """
         ip.run_cell("from {} import wrn".format(self.fname))
 
         with tt.AssertNotPrints("I AM  A WARNING"):
             ip.run_cell("wrn()")
         ip.run_cell("del wrn")
 
 
 def test_custom_exc_count():
     hook = mock.Mock(return_value=None)
     ip.set_custom_exc((SyntaxError,), hook)
     before = ip.execution_count
     ip.run_cell("def foo()", store_history=True)
     # restore default excepthook
     ip.set_custom_exc((), None)
-    nt.assert_equal(hook.call_count, 1)
-    nt.assert_equal(ip.execution_count, before + 1)
+    assert hook.call_count == 1
+    assert ip.execution_count == before + 1
 
 
 def test_run_cell_async():
     loop = asyncio.get_event_loop()
     ip.run_cell("import asyncio")
     coro = ip.run_cell_async("await asyncio.sleep(0.01)\n5")
     assert asyncio.iscoroutine(coro)
     result = loop.run_until_complete(coro)
     assert isinstance(result, interactiveshell.ExecutionResult)
     assert result.result == 5
 
 
 def test_should_run_async():
     assert not ip.should_run_async("a = 5")
     assert ip.should_run_async("await x")
     assert ip.should_run_async("import asyncio; await asyncio.sleep(1)")
 
 
 def test_set_custom_completer():
     num_completers = len(ip.Completer.matchers)
 
     def foo(*args, **kwargs):
         return "I'm a completer!"
 
     ip.set_custom_completer(foo, 0)
 
     # check that we've really added a new completer
     assert len(ip.Completer.matchers) == num_completers + 1
 
     # check that the first completer is the function we defined
     assert ip.Completer.matchers[0]() == "I'm a completer!"
 
     # clean up
     ip.Completer.custom_matchers.pop()

IPython/core/tests/test_magic.py

@@ -1,1341 +1,1366 b''
 # -*- coding: utf-8 -*-
 """Tests for various magic functions.
 
 Needs to be run by nose (to make ipython session available).
 """
 
 import asyncio
 import io
 import os
 import re
 import shlex
 import sys
 import warnings
 from importlib import invalidate_caches
 from io import StringIO
 from pathlib import Path
 from textwrap import dedent
 from unittest import TestCase, mock
 
-import nose.tools as nt
-
 import pytest
 
 from IPython import get_ipython
 from IPython.core import magic
 from IPython.core.error import UsageError
 from IPython.core.magic import (
     Magics,
     cell_magic,
     line_magic,
     magics_class,
     register_cell_magic,
     register_line_magic,
 )
 from IPython.core.magics import code, execution, logging, osm, script
 from IPython.testing import decorators as dec
 from IPython.testing import tools as tt
 from IPython.utils.io import capture_output
 from IPython.utils.process import find_cmd
 from IPython.utils.tempdir import TemporaryDirectory, TemporaryWorkingDirectory
 
 from .test_debugger import PdbTestInput
 
 
 @magic.magics_class
 class DummyMagics(magic.Magics): pass
 
 def test_extract_code_ranges():
     instr = "1 3 5-6 7-9 10:15 17: :10 10- -13 :"
-    expected = [(0, 1), 
-                (2, 3),
-                (4, 6),
-                (6, 9),
-                (9, 14),
-                (16, None),
-                (None, 9),
-                (9, None),
-                (None, 13),
-                (None, None)]
+    expected = [
+        (0, 1),
+        (2, 3),
+        (4, 6),
+        (6, 9),
+        (9, 14),
+        (16, None),
+        (None, 9),
+        (9, None),
+        (None, 13),
+        (None, None),
+    ]
     actual = list(code.extract_code_ranges(instr))
-    nt.assert_equal(actual, expected)
+    assert actual == expected
 
 def test_extract_symbols():
     source = """import foo\na = 10\ndef b():\n    return 42\n\n\nclass A: pass\n\n\n"""
     symbols_args = ["a", "b", "A", "A,b", "A,a", "z"]
     expected = [([], ['a']),
                 (["def b():\n    return 42\n"], []),
                 (["class A: pass\n"], []),
                 (["class A: pass\n", "def b():\n    return 42\n"], []),
                 (["class A: pass\n"], ['a']),
                 ([], ['z'])]
     for symbols, exp in zip(symbols_args, expected):
-        nt.assert_equal(code.extract_symbols(source, symbols), exp)
+        assert code.extract_symbols(source, symbols) == exp
 
 
 def test_extract_symbols_raises_exception_with_non_python_code():
     source = ("=begin A Ruby program :)=end\n"
               "def hello\n"
               "puts 'Hello world'\n"
               "end")
-    with nt.assert_raises(SyntaxError):
+    with pytest.raises(SyntaxError):
         code.extract_symbols(source, "hello")
 
 
 def test_magic_not_found():
     # magic not found raises UsageError
-    with nt.assert_raises(UsageError):
+    with pytest.raises(UsageError):
         _ip.magic('doesntexist')
 
     # ensure result isn't success when a magic isn't found
     result = _ip.run_cell('%doesntexist')
     assert isinstance(result.error_in_exec, UsageError)
 
 
 def test_cell_magic_not_found():
     # magic not found raises UsageError
-    with nt.assert_raises(UsageError):
+    with pytest.raises(UsageError):
         _ip.run_cell_magic('doesntexist', 'line', 'cell')
 
     # ensure result isn't success when a magic isn't found
     result = _ip.run_cell('%%doesntexist')
     assert isinstance(result.error_in_exec, UsageError)
 
 
 def test_magic_error_status():
     def fail(shell):
         1/0
     _ip.register_magic_function(fail)
     result = _ip.run_cell('%fail')
     assert isinstance(result.error_in_exec, ZeroDivisionError)
 
 
 def test_config():
     """ test that config magic does not raise
     can happen if Configurable init is moved too early into
     Magics.__init__ as then a Config object will be registered as a
     magic.
     """
     ## should not raise.
     _ip.magic('config')
 
 def test_config_available_configs():
     """ test that config magic prints available configs in unique and
     sorted order. """
     with capture_output() as captured:
         _ip.magic('config')
 
     stdout = captured.stdout
     config_classes = stdout.strip().split('\n')[1:]
-    nt.assert_list_equal(config_classes, sorted(set(config_classes)))
+    assert config_classes == sorted(set(config_classes))
 
 def test_config_print_class():
     """ test that config with a classname prints the class's options. """
     with capture_output() as captured:
         _ip.magic('config TerminalInteractiveShell')
 
     stdout = captured.stdout
     if not re.match("TerminalInteractiveShell.* options", stdout.splitlines()[0]):
         print(stdout)
         raise AssertionError("1st line of stdout not like "
                              "'TerminalInteractiveShell.* options'")
 
 def test_rehashx():
     # clear up everything
     _ip.alias_manager.clear_aliases()
     del _ip.db['syscmdlist']
-    
+
     _ip.magic('rehashx')
     # Practically ALL ipython development systems will have more than 10 aliases
 
-    nt.assert_true(len(_ip.alias_manager.aliases) > 10)
+    assert len(_ip.alias_manager.aliases) > 10
     for name, cmd in _ip.alias_manager.aliases:
         # we must strip dots from alias names
-        nt.assert_not_in('.', name)
+        assert "." not in name
 
     # rehashx must fill up syscmdlist
     scoms = _ip.db['syscmdlist']
-    nt.assert_true(len(scoms) > 10)
-            
+    assert len(scoms) > 10
 
 
 def test_magic_parse_options():
     """Test that we don't mangle paths when parsing magic options."""
     ip = get_ipython()
     path = 'c:\\x'
     m = DummyMagics(ip)
     opts = m.parse_options('-f %s' % path,'f:')[0]
     # argv splitting is os-dependent
     if os.name == 'posix':
         expected = 'c:x'
     else:
         expected = path
-    nt.assert_equal(opts['f'], expected)
+    assert opts["f"] == expected
+
 
 def test_magic_parse_long_options():
     """Magic.parse_options can handle --foo=bar long options"""
     ip = get_ipython()
     m = DummyMagics(ip)
-    opts, _ = m.parse_options('--foo --bar=bubble', 'a', 'foo', 'bar=')
-    nt.assert_in('foo', opts)
-    nt.assert_in('bar', opts)
-    nt.assert_equal(opts['bar'], "bubble")
+    opts, _ = m.parse_options("--foo --bar=bubble", "a", "foo", "bar=")
+    assert "foo" in opts
+    assert "bar" in opts
+    assert opts["bar"] == "bubble"
 
 
 def doctest_hist_f():
     """Test %hist -f with temporary filename.
 
     In [9]: import tempfile
 
     In [10]: tfile = tempfile.mktemp('.py','tmp-ipython-')
 
     In [11]: %hist -nl -f $tfile 3
 
     In [13]: import os; os.unlink(tfile)
     """
 
 
 def doctest_hist_op():
     """Test %hist -op
 
     In [1]: class b(float):
        ...:     pass
-       ...: 
+       ...:
 
     In [2]: class s(object):
        ...:     def __str__(self):
        ...:         return 's'
-       ...: 
+       ...:
 
-    In [3]: 
+    In [3]:
 
     In [4]: class r(b):
        ...:     def __repr__(self):
        ...:         return 'r'
-       ...: 
+       ...:
 
     In [5]: class sr(s,r): pass
-       ...: 
+       ...:
 
-    In [6]: 
+    In [6]:
 
     In [7]: bb=b()
 
     In [8]: ss=s()
 
     In [9]: rr=r()
 
     In [10]: ssrr=sr()
 
     In [11]: 4.5
     Out[11]: 4.5
 
     In [12]: str(ss)
     Out[12]: 's'
 
-    In [13]: 
+    In [13]:
 
     In [14]: %hist -op
     >>> class b:
     ...     pass
-    ... 
+    ...
     >>> class s(b):
     ...     def __str__(self):
     ...         return 's'
-    ... 
-    >>> 
+    ...
+    >>>
     >>> class r(b):
     ...     def __repr__(self):
     ...         return 'r'
-    ... 
+    ...
     >>> class sr(s,r): pass
-    >>> 
+    >>>
     >>> bb=b()
     >>> ss=s()
     >>> rr=r()
     >>> ssrr=sr()
     >>> 4.5
     4.5
     >>> str(ss)
     's'
-    >>> 
+    >>>
     """
 
 def test_hist_pof():
     ip = get_ipython()
-    ip.run_cell(u"1+2", store_history=True)
+    ip.run_cell("1+2", store_history=True)
     #raise Exception(ip.history_manager.session_number)
     #raise Exception(list(ip.history_manager._get_range_session()))
     with TemporaryDirectory() as td:
         tf = os.path.join(td, 'hist.py')
         ip.run_line_magic('history', '-pof %s' % tf)
         assert os.path.isfile(tf)
 
 
 def test_macro():
     ip = get_ipython()
     ip.history_manager.reset()   # Clear any existing history.
     cmds = ["a=1", "def b():\n  return a**2", "print(a,b())"]
     for i, cmd in enumerate(cmds, start=1):
         ip.history_manager.store_inputs(i, cmd)
     ip.magic("macro test 1-3")
-    nt.assert_equal(ip.user_ns["test"].value, "\n".join(cmds)+"\n")
-    
+    assert ip.user_ns["test"].value == "\n".join(cmds) + "\n"
+
     # List macros
-    nt.assert_in("test", ip.magic("macro"))
+    assert "test" in ip.magic("macro")
 
 
 def test_macro_run():
     """Test that we can run a multi-line macro successfully."""
     ip = get_ipython()
     ip.history_manager.reset()
     cmds = ["a=10", "a+=1", "print(a)", "%macro test 2-3"]
     for cmd in cmds:
         ip.run_cell(cmd, store_history=True)
-    nt.assert_equal(ip.user_ns["test"].value, "a+=1\nprint(a)\n")
+    assert ip.user_ns["test"].value == "a+=1\nprint(a)\n"
     with tt.AssertPrints("12"):
         ip.run_cell("test")
     with tt.AssertPrints("13"):
         ip.run_cell("test")
 
 
 def test_magic_magic():
     """Test %magic"""
     ip = get_ipython()
     with capture_output() as captured:
         ip.magic("magic")
-    
+
     stdout = captured.stdout
-    nt.assert_in('%magic', stdout)
-    nt.assert_in('IPython', stdout)
-    nt.assert_in('Available', stdout)
+    assert "%magic" in stdout
+    assert "IPython" in stdout
+    assert "Available" in stdout
 
 
 @dec.skipif_not_numpy
 def test_numpy_reset_array_undec():
     "Test '%reset array' functionality"
-    _ip.ex('import numpy as np')
-    _ip.ex('a = np.empty(2)')
-    nt.assert_in('a', _ip.user_ns)
-    _ip.magic('reset -f array')
-    nt.assert_not_in('a', _ip.user_ns)
+    _ip.ex("import numpy as np")
+    _ip.ex("a = np.empty(2)")
+    assert "a" in _ip.user_ns
+    _ip.magic("reset -f array")
+    assert "a" not in _ip.user_ns
+
 
 def test_reset_out():
     "Test '%reset out' magic"
     _ip.run_cell("parrot = 'dead'", store_history=True)
     # test '%reset -f out', make an Out prompt
     _ip.run_cell("parrot", store_history=True)
-    nt.assert_true('dead' in [_ip.user_ns[x] for x in ('_','__','___')])
-    _ip.magic('reset -f out')
-    nt.assert_false('dead' in [_ip.user_ns[x] for x in ('_','__','___')])
-    nt.assert_equal(len(_ip.user_ns['Out']), 0)
+    assert "dead" in [_ip.user_ns[x] for x in ("_", "__", "___")]
+    _ip.magic("reset -f out")
+    assert "dead" not in [_ip.user_ns[x] for x in ("_", "__", "___")]
+    assert len(_ip.user_ns["Out"]) == 0
+
 
 def test_reset_in():
     "Test '%reset in' magic"
     # test '%reset -f in'
     _ip.run_cell("parrot", store_history=True)
-    nt.assert_true('parrot' in [_ip.user_ns[x] for x in ('_i','_ii','_iii')])
-    _ip.magic('%reset -f in')
-    nt.assert_false('parrot' in [_ip.user_ns[x] for x in ('_i','_ii','_iii')])
-    nt.assert_equal(len(set(_ip.user_ns['In'])), 1)
+    assert "parrot" in [_ip.user_ns[x] for x in ("_i", "_ii", "_iii")]
+    _ip.magic("%reset -f in")
+    assert "parrot" not in [_ip.user_ns[x] for x in ("_i", "_ii", "_iii")]
+    assert len(set(_ip.user_ns["In"])) == 1
+
 
 def test_reset_dhist():
     "Test '%reset dhist' magic"
-    _ip.run_cell("tmp = [d for d in _dh]") # copy before clearing
-    _ip.magic('cd ' + os.path.dirname(nt.__file__))
-    _ip.magic('cd -')
-    nt.assert_true(len(_ip.user_ns['_dh']) > 0)
-    _ip.magic('reset -f dhist')
-    nt.assert_equal(len(_ip.user_ns['_dh']), 0)
-    _ip.run_cell("_dh = [d for d in tmp]") #restore
+    _ip.run_cell("tmp = [d for d in _dh]")  # copy before clearing
+    _ip.magic("cd " + os.path.dirname(pytest.__file__))
+    _ip.magic("cd -")
+    assert len(_ip.user_ns["_dh"]) > 0
+    _ip.magic("reset -f dhist")
+    assert len(_ip.user_ns["_dh"]) == 0
+    _ip.run_cell("_dh = [d for d in tmp]")  # restore
+
 
 def test_reset_in_length():
     "Test that '%reset in' preserves In[] length"
     _ip.run_cell("print 'foo'")
     _ip.run_cell("reset -f in")
-    nt.assert_equal(len(_ip.user_ns['In']), _ip.displayhook.prompt_count+1)
+    assert len(_ip.user_ns["In"]) == _ip.displayhook.prompt_count + 1
+
 
 class TestResetErrors(TestCase):
 
     def test_reset_redefine(self):
 
         @magics_class
         class KernelMagics(Magics):
               @line_magic
               def less(self, shell): pass
 
         _ip.register_magics(KernelMagics)
 
         with self.assertLogs() as cm:
             # hack, we want to just capture logs, but assertLogs fails if not
             # logs get produce.
             # so log one things we ignore.
             import logging as log_mod
             log = log_mod.getLogger()
             log.info('Nothing')
             # end hack.
             _ip.run_cell("reset -f")
 
         assert len(cm.output) == 1
         for out in cm.output:
             assert "Invalid alias" not in out
 
 def test_tb_syntaxerror():
     """test %tb after a SyntaxError"""
     ip = get_ipython()
     ip.run_cell("for")
-    
+
     # trap and validate stdout
     save_stdout = sys.stdout
     try:
         sys.stdout = StringIO()
         ip.run_cell("%tb")
         out = sys.stdout.getvalue()
     finally:
         sys.stdout = save_stdout
     # trim output, and only check the last line
     last_line = out.rstrip().splitlines()[-1].strip()
-    nt.assert_equal(last_line, "SyntaxError: invalid syntax")
+    assert last_line == "SyntaxError: invalid syntax"
 
 
 def test_time():
     ip = get_ipython()
-    
+
     with tt.AssertPrints("Wall time: "):
         ip.run_cell("%time None")
-    
+
     ip.run_cell("def f(kmjy):\n"
                 "    %time print (2*kmjy)")
-    
+
     with tt.AssertPrints("Wall time: "):
         with tt.AssertPrints("hihi", suppress=False):
             ip.run_cell("f('hi')")
 
 def test_time_last_not_expression():
     ip.run_cell("%%time\n"
                 "var_1 = 1\n"
                 "var_2 = 2\n")
     assert ip.user_ns['var_1'] == 1
     del ip.user_ns['var_1']
     assert ip.user_ns['var_2'] == 2
     del ip.user_ns['var_2']
-    
+
 
 @dec.skip_win32
 def test_time2():
     ip = get_ipython()
-    
+
     with tt.AssertPrints("CPU times: user "):
         ip.run_cell("%time None")
 
 def test_time3():
     """Erroneous magic function calls, issue gh-3334"""
     ip = get_ipython()
     ip.user_ns.pop('run', None)
-    
+
     with tt.AssertNotPrints("not found", channel='stderr'):
         ip.run_cell("%%time\n"
                     "run = 0\n"
                     "run += 1")
 
 def test_multiline_time():
     """Make sure last statement from time return a value."""
     ip = get_ipython()
     ip.user_ns.pop('run', None)
 
     ip.run_cell(dedent("""\
         %%time
         a = "ho"
         b = "hey"
         a+b
-        """))
-    nt.assert_equal(ip.user_ns_hidden['_'], 'hohey')
+        """
+        )
+    )
+    assert ip.user_ns_hidden["_"] == "hohey"
+
 
 def test_time_local_ns():
     """
     Test that local_ns is actually global_ns when running a cell magic
     """
     ip = get_ipython()
-    ip.run_cell("%%time\n"
-                "myvar = 1")
-    nt.assert_equal(ip.user_ns['myvar'], 1)
-    del ip.user_ns['myvar']
+    ip.run_cell("%%time\n" "myvar = 1")
+    assert ip.user_ns["myvar"] == 1
+    del ip.user_ns["myvar"]
+
 
 def test_doctest_mode():
     "Toggle doctest_mode twice, it should be a no-op and run without error"
     _ip.magic('doctest_mode')
     _ip.magic('doctest_mode')
 
 
 def test_parse_options():
     """Tests for basic options parsing in magics."""
     # These are only the most minimal of tests, more should be added later.  At
     # the very least we check that basic text/unicode calls work OK.
     m = DummyMagics(_ip)
-    nt.assert_equal(m.parse_options('foo', '')[1], 'foo')
-    nt.assert_equal(m.parse_options(u'foo', '')[1], u'foo')
+    assert m.parse_options("foo", "")[1] == "foo"
+    assert m.parse_options("foo", "")[1] == "foo"
 
 
 def test_parse_options_preserve_non_option_string():
     """Test to assert preservation of non-option part of magic-block, while parsing magic options."""
     m = DummyMagics(_ip)
     opts, stmt = m.parse_options(
         " -n1  -r 13 _ = 314 + foo", "n:r:", preserve_non_opts=True
     )
-    nt.assert_equal(opts, {"n": "1", "r": "13"})
-    nt.assert_equal(stmt, "_ = 314 + foo")
+    assert opts == {"n": "1", "r": "13"}
+    assert stmt == "_ = 314 + foo"
 
 
 def test_run_magic_preserve_code_block():
     """Test to assert preservation of non-option part of magic-block, while running magic."""
     _ip.user_ns["spaces"] = []
     _ip.magic("timeit -n1 -r1 spaces.append([s.count(' ') for s in ['document']])")
     assert _ip.user_ns["spaces"] == [[0]]
 
 
 def test_dirops():
     """Test various directory handling operations."""
     # curpath = lambda :os.path.splitdrive(os.getcwd())[1].replace('\\','/')
     curpath = os.getcwd
     startdir = os.getcwd()
     ipdir = os.path.realpath(_ip.ipython_dir)
     try:
         _ip.magic('cd "%s"' % ipdir)
-        nt.assert_equal(curpath(), ipdir)
+        assert curpath() == ipdir
         _ip.magic('cd -')
-        nt.assert_equal(curpath(), startdir)
+        assert curpath() == startdir
         _ip.magic('pushd "%s"' % ipdir)
-        nt.assert_equal(curpath(), ipdir)
+        assert curpath() == ipdir
         _ip.magic('popd')
-        nt.assert_equal(curpath(), startdir)
+        assert curpath() == startdir
     finally:
         os.chdir(startdir)
 
 
 def test_cd_force_quiet():
     """Test OSMagics.cd_force_quiet option"""
     _ip.config.OSMagics.cd_force_quiet = True
     osmagics = osm.OSMagics(shell=_ip)
 
     startdir = os.getcwd()
     ipdir = os.path.realpath(_ip.ipython_dir)
 
     try:
         with tt.AssertNotPrints(ipdir):
             osmagics.cd('"%s"' % ipdir)
         with tt.AssertNotPrints(startdir):
             osmagics.cd('-')
     finally:
         os.chdir(startdir)
 
 
 def test_xmode():
     # Calling xmode three times should be a no-op
     xmode = _ip.InteractiveTB.mode
     for i in range(4):
         _ip.magic("xmode")
-    nt.assert_equal(_ip.InteractiveTB.mode, xmode)
-    
+    assert _ip.InteractiveTB.mode == xmode
+
 def test_reset_hard():
     monitor = []
     class A(object):
         def __del__(self):
             monitor.append(1)
         def __repr__(self):
             return "<A instance>"
-            
+
     _ip.user_ns["a"] = A()
     _ip.run_cell("a")
-    
-    nt.assert_equal(monitor, [])
+
+    assert monitor == []
     _ip.magic("reset -f")
-    nt.assert_equal(monitor, [1])
-    
+    assert monitor == [1]
+
 class TestXdel(tt.TempFileMixin):
     def test_xdel(self):
         """Test that references from %run are cleared by xdel."""
         src = ("class A(object):\n"
                "    monitor = []\n"
                "    def __del__(self):\n"
                "        self.monitor.append(1)\n"
                "a = A()\n")
         self.mktmp(src)
         # %run creates some hidden references...
         _ip.magic("run %s" % self.fname)
         # ... as does the displayhook.
         _ip.run_cell("a")
-        
+
         monitor = _ip.user_ns["A"].monitor
-        nt.assert_equal(monitor, [])
-        
+        assert monitor == []
+
         _ip.magic("xdel a")
-        
+
         # Check that a's __del__ method has been called.
-        nt.assert_equal(monitor, [1])
+        assert monitor == [1]
 
 def doctest_who():
     """doctest for %who
-    
+
     In [1]: %reset -f
-    
+
     In [2]: alpha = 123
-    
+
     In [3]: beta = 'beta'
-    
+
     In [4]: %who int
     alpha
-    
+
     In [5]: %who str
     beta
-    
+
     In [6]: %whos
     Variable   Type    Data/Info
     ----------------------------
     alpha      int     123
     beta       str     beta
-    
+
     In [7]: %who_ls
     Out[7]: ['alpha', 'beta']
     """
 
 def test_whos():
     """Check that whos is protected against objects where repr() fails."""
     class A(object):
         def __repr__(self):
             raise Exception()
     _ip.user_ns['a'] = A()
     _ip.magic("whos")
 
 def doctest_precision():
     """doctest for %precision
-    
+
     In [1]: f = get_ipython().display_formatter.formatters['text/plain']
-    
+
     In [2]: %precision 5
     Out[2]: '%.5f'
-    
+
     In [3]: f.float_format
     Out[3]: '%.5f'
-    
+
     In [4]: %precision %e
     Out[4]: '%e'
-    
+
     In [5]: f(3.1415927)
     Out[5]: '3.141593e+00'
     """
 
 def test_debug_magic():
     """Test debugging a small code with %debug
-    
+
     In [1]: with PdbTestInput(['c']):
        ...:     %debug print("a b") #doctest: +ELLIPSIS
        ...:
     ...
     ipdb> c
     a b
     In [2]:
     """
 
 def test_psearch():
     with tt.AssertPrints("dict.fromkeys"):
         _ip.run_cell("dict.fr*?")
     with tt.AssertPrints("π.is_integer"):
         _ip.run_cell("π = 3.14;\nπ.is_integ*?")
 
 def test_timeit_shlex():
     """test shlex issues with timeit (#1109)"""
     _ip.ex("def f(*a,**kw): pass")
     _ip.magic('timeit -n1 "this is a bug".count(" ")')
     _ip.magic('timeit -r1 -n1 f(" ", 1)')
     _ip.magic('timeit -r1 -n1 f(" ", 1, " ", 2, " ")')
     _ip.magic('timeit -r1 -n1 ("a " + "b")')
     _ip.magic('timeit -r1 -n1 f("a " + "b")')
     _ip.magic('timeit -r1 -n1 f("a " + "b ")')
 
 
 def test_timeit_special_syntax():
     "Test %%timeit with IPython special syntax"
     @register_line_magic
     def lmagic(line):
         ip = get_ipython()
         ip.user_ns['lmagic_out'] = line
 
     # line mode test
-    _ip.run_line_magic('timeit', '-n1 -r1 %lmagic my line')
-    nt.assert_equal(_ip.user_ns['lmagic_out'], 'my line')
+    _ip.run_line_magic("timeit", "-n1 -r1 %lmagic my line")
+    assert _ip.user_ns["lmagic_out"] == "my line"
     # cell mode test
-    _ip.run_cell_magic('timeit', '-n1 -r1', '%lmagic my line2')
-    nt.assert_equal(_ip.user_ns['lmagic_out'], 'my line2')
+    _ip.run_cell_magic("timeit", "-n1 -r1", "%lmagic my line2")
+    assert _ip.user_ns["lmagic_out"] == "my line2"
+
 
 def test_timeit_return():
     """
     test whether timeit -o return object
     """
 
     res = _ip.run_line_magic('timeit','-n10 -r10 -o 1')
     assert(res is not None)
 
 def test_timeit_quiet():
     """
     test quiet option of timeit magic
     """
     with tt.AssertNotPrints("loops"):
         _ip.run_cell("%timeit -n1 -r1 -q 1")
 
 def test_timeit_return_quiet():
     with tt.AssertNotPrints("loops"):
         res = _ip.run_line_magic('timeit', '-n1 -r1 -q -o 1')
     assert (res is not None)
 
 def test_timeit_invalid_return():
-    with nt.assert_raises_regex(SyntaxError, "outside function"):
+    with pytest.raises(SyntaxError):
         _ip.run_line_magic('timeit', 'return')
 
 @dec.skipif(execution.profile is None)
 def test_prun_special_syntax():
     "Test %%prun with IPython special syntax"
     @register_line_magic
     def lmagic(line):
         ip = get_ipython()
         ip.user_ns['lmagic_out'] = line
 
     # line mode test
-    _ip.run_line_magic('prun', '-q %lmagic my line')
-    nt.assert_equal(_ip.user_ns['lmagic_out'], 'my line')
+    _ip.run_line_magic("prun", "-q %lmagic my line")
+    assert _ip.user_ns["lmagic_out"] == "my line"
     # cell mode test
-    _ip.run_cell_magic('prun', '-q', '%lmagic my line2')
-    nt.assert_equal(_ip.user_ns['lmagic_out'], 'my line2')
+    _ip.run_cell_magic("prun", "-q", "%lmagic my line2")
+    assert _ip.user_ns["lmagic_out"] == "my line2"
+
 
 @dec.skipif(execution.profile is None)
 def test_prun_quotes():
     "Test that prun does not clobber string escapes (GH #1302)"
     _ip.magic(r"prun -q x = '\t'")
-    nt.assert_equal(_ip.user_ns['x'], '\t')
+    assert _ip.user_ns["x"] == "\t"
+
 
 def test_extension():
     # Debugging information for failures of this test
     print('sys.path:')
     for p in sys.path:
         print(' ', p)
     print('CWD', os.getcwd())
 
-    nt.assert_raises(ImportError, _ip.magic, "load_ext daft_extension")
+    pytest.raises(ImportError, _ip.magic, "load_ext daft_extension")
     daft_path = os.path.join(os.path.dirname(__file__), "daft_extension")
     sys.path.insert(0, daft_path)
     try:
         _ip.user_ns.pop('arq', None)
         invalidate_caches()   # Clear import caches
         _ip.magic("load_ext daft_extension")
-        nt.assert_equal(_ip.user_ns['arq'], 185)
+        assert _ip.user_ns["arq"] == 185
         _ip.magic("unload_ext daft_extension")
         assert 'arq' not in _ip.user_ns
     finally:
         sys.path.remove(daft_path)
 
 
 def test_notebook_export_json():
     _ip = get_ipython()
     _ip.history_manager.reset()   # Clear any existing history.
-    cmds = [u"a=1", u"def b():\n  return a**2", u"print('noël, été', b())"]
+    cmds = ["a=1", "def b():\n  return a**2", "print('noël, été', b())"]
     for i, cmd in enumerate(cmds, start=1):
         _ip.history_manager.store_inputs(i, cmd)
     with TemporaryDirectory() as td:
         outfile = os.path.join(td, "nb.ipynb")
         _ip.magic("notebook -e %s" % outfile)
 
 
 class TestEnv(TestCase):
 
     def test_env(self):
         env = _ip.magic("env")
         self.assertTrue(isinstance(env, dict))
 
     def test_env_secret(self):
         env = _ip.magic("env")
         hidden = "<hidden>"
         with mock.patch.dict(
             os.environ,
             {
                 "API_KEY": "abc123",
                 "SECRET_THING": "ssshhh",
                 "JUPYTER_TOKEN": "",
                 "VAR": "abc"
             }
         ):
             env = _ip.magic("env")
         assert env["API_KEY"] == hidden
         assert env["SECRET_THING"] == hidden
         assert env["JUPYTER_TOKEN"] == hidden
         assert env["VAR"] == "abc"
 
     def test_env_get_set_simple(self):
         env = _ip.magic("env var val1")
         self.assertEqual(env, None)
         self.assertEqual(os.environ['var'], 'val1')
         self.assertEqual(_ip.magic("env var"), 'val1')
         env = _ip.magic("env var=val2")
         self.assertEqual(env, None)
         self.assertEqual(os.environ['var'], 'val2')
 
     def test_env_get_set_complex(self):
         env = _ip.magic("env var 'val1 '' 'val2")
         self.assertEqual(env, None)
         self.assertEqual(os.environ['var'], "'val1 '' 'val2")
         self.assertEqual(_ip.magic("env var"), "'val1 '' 'val2")
         env = _ip.magic('env var=val2 val3="val4')
         self.assertEqual(env, None)
         self.assertEqual(os.environ['var'], 'val2 val3="val4')
 
     def test_env_set_bad_input(self):
         self.assertRaises(UsageError, lambda: _ip.magic("set_env var"))
 
     def test_env_set_whitespace(self):
         self.assertRaises(UsageError, lambda: _ip.magic("env var A=B"))
 
 
 class CellMagicTestCase(TestCase):
 
     def check_ident(self, magic):
         # Manually called, we get the result
-        out = _ip.run_cell_magic(magic, 'a', 'b')
-        nt.assert_equal(out, ('a','b'))
+        out = _ip.run_cell_magic(magic, "a", "b")
+        assert out == ("a", "b")
         # Via run_cell, it goes into the user's namespace via displayhook
-        _ip.run_cell('%%' + magic +' c\nd\n')
-        nt.assert_equal(_ip.user_ns['_'], ('c','d\n'))
+        _ip.run_cell("%%" + magic + " c\nd\n")
+        assert _ip.user_ns["_"] == ("c", "d\n")
 
     def test_cell_magic_func_deco(self):
         "Cell magic using simple decorator"
         @register_cell_magic
         def cellm(line, cell):
             return line, cell
 
         self.check_ident('cellm')
 
     def test_cell_magic_reg(self):
         "Cell magic manually registered"
         def cellm(line, cell):
             return line, cell
 
         _ip.register_magic_function(cellm, 'cell', 'cellm2')
         self.check_ident('cellm2')
 
     def test_cell_magic_class(self):
         "Cell magics declared via a class"
         @magics_class
         class MyMagics(Magics):
 
             @cell_magic
             def cellm3(self, line, cell):
                 return line, cell
 
         _ip.register_magics(MyMagics)
         self.check_ident('cellm3')
 
     def test_cell_magic_class2(self):
         "Cell magics declared via a class, #2"
         @magics_class
         class MyMagics2(Magics):
 
             @cell_magic('cellm4')
             def cellm33(self, line, cell):
                 return line, cell
-            
+
         _ip.register_magics(MyMagics2)
         self.check_ident('cellm4')
         # Check that nothing is registered as 'cellm33'
         c33 = _ip.find_cell_magic('cellm33')
-        nt.assert_equal(c33, None)
+        assert c33 == None
 
 def test_file():
     """Basic %%writefile"""
     ip = get_ipython()
     with TemporaryDirectory() as td:
         fname = os.path.join(td, 'file1')
         ip.run_cell_magic("writefile", fname, u'\n'.join([
             'line1',
             'line2',
         ]))
         s = Path(fname).read_text()
-        nt.assert_in('line1\n', s)
-        nt.assert_in('line2', s)
+        assert "line1\n" in s
+        assert "line2" in s
+
 
 @dec.skip_win32
 def test_file_single_quote():
     """Basic %%writefile with embedded single quotes"""
     ip = get_ipython()
     with TemporaryDirectory() as td:
         fname = os.path.join(td, '\'file1\'')
         ip.run_cell_magic("writefile", fname, u'\n'.join([
             'line1',
             'line2',
         ]))
         s = Path(fname).read_text()
-        nt.assert_in('line1\n', s)
-        nt.assert_in('line2', s)
+        assert "line1\n" in s
+        assert "line2" in s
+
 
 @dec.skip_win32
 def test_file_double_quote():
     """Basic %%writefile with embedded double quotes"""
     ip = get_ipython()
     with TemporaryDirectory() as td:
         fname = os.path.join(td, '"file1"')
         ip.run_cell_magic("writefile", fname, u'\n'.join([
             'line1',
             'line2',
         ]))
         s = Path(fname).read_text()
-        nt.assert_in('line1\n', s)
-        nt.assert_in('line2', s)
+        assert "line1\n" in s
+        assert "line2" in s
+
 
 def test_file_var_expand():
     """%%writefile $filename"""
     ip = get_ipython()
     with TemporaryDirectory() as td:
         fname = os.path.join(td, 'file1')
         ip.user_ns['filename'] = fname
         ip.run_cell_magic("writefile", '$filename', u'\n'.join([
             'line1',
             'line2',
         ]))
         s = Path(fname).read_text()
-        nt.assert_in('line1\n', s)
-        nt.assert_in('line2', s)
+        assert "line1\n" in s
+        assert "line2" in s
+
 
 def test_file_unicode():
     """%%writefile with unicode cell"""
     ip = get_ipython()
     with TemporaryDirectory() as td:
         fname = os.path.join(td, 'file1')
         ip.run_cell_magic("writefile", fname, u'\n'.join([
             u'liné1',
             u'liné2',
         ]))
         with io.open(fname, encoding='utf-8') as f:
             s = f.read()
-        nt.assert_in(u'liné1\n', s)
-        nt.assert_in(u'liné2', s)
+        assert "liné1\n" in s
+        assert "liné2" in s
+
 
 def test_file_amend():
     """%%writefile -a amends files"""
     ip = get_ipython()
     with TemporaryDirectory() as td:
         fname = os.path.join(td, 'file2')
         ip.run_cell_magic("writefile", fname, u'\n'.join([
             'line1',
             'line2',
         ]))
         ip.run_cell_magic("writefile", "-a %s" % fname, u'\n'.join([
             'line3',
             'line4',
         ]))
         s = Path(fname).read_text()
-        nt.assert_in('line1\n', s)
-        nt.assert_in('line3\n', s)
+        assert "line1\n" in s
+        assert "line3\n" in s
+
 
 def test_file_spaces():
     """%%file with spaces in filename"""
     ip = get_ipython()
     with TemporaryWorkingDirectory() as td:
         fname = "file name"
         ip.run_cell_magic("file", '"%s"'%fname, u'\n'.join([
             'line1',
             'line2',
         ]))
         s = Path(fname).read_text()
-        nt.assert_in('line1\n', s)
-        nt.assert_in('line2', s)
-    
+        assert "line1\n" in s
+        assert "line2" in s
+
+
 def test_script_config():
     ip = get_ipython()
     ip.config.ScriptMagics.script_magics = ['whoda']
     sm = script.ScriptMagics(shell=ip)
-    nt.assert_in('whoda', sm.magics['cell'])
+    assert "whoda" in sm.magics["cell"]
+
 
 @dec.skip_iptest_but_not_pytest
 @dec.skip_win32
 @pytest.mark.skipif(
     sys.platform == "win32", reason="This test does not run under Windows"
 )
 def test_script_out():
     assert asyncio.get_event_loop().is_running() is False
 
     ip = get_ipython()
     ip.run_cell_magic("script", "--out output sh", "echo 'hi'")
     assert asyncio.get_event_loop().is_running() is False
-    nt.assert_equal(ip.user_ns['output'], 'hi\n')
+    assert ip.user_ns["output"] == "hi\n"
+
 
 @dec.skip_iptest_but_not_pytest
 @dec.skip_win32
 @pytest.mark.skipif(
     sys.platform == "win32", reason="This test does not run under Windows"
 )
 def test_script_err():
     ip = get_ipython()
     assert asyncio.get_event_loop().is_running() is False
     ip.run_cell_magic("script", "--err error sh", "echo 'hello' >&2")
     assert asyncio.get_event_loop().is_running() is False
-    nt.assert_equal(ip.user_ns['error'], 'hello\n')
+    assert ip.user_ns["error"] == "hello\n"
 
 
 @dec.skip_iptest_but_not_pytest
 @dec.skip_win32
 @pytest.mark.skipif(
     sys.platform == "win32", reason="This test does not run under Windows"
 )
 def test_script_out_err():
 
     ip = get_ipython()
     ip.run_cell_magic(
         "script", "--out output --err error sh", "echo 'hi'\necho 'hello' >&2"
     )
-    nt.assert_equal(ip.user_ns["output"], "hi\n")
-    nt.assert_equal(ip.user_ns["error"], "hello\n")
+    assert ip.user_ns["output"] == "hi\n"
+    assert ip.user_ns["error"] == "hello\n"
 
 
 @dec.skip_iptest_but_not_pytest
 @dec.skip_win32
 @pytest.mark.skipif(
     sys.platform == "win32", reason="This test does not run under Windows"
 )
 async def test_script_bg_out():
     ip = get_ipython()
     ip.run_cell_magic("script", "--bg --out output sh", "echo 'hi'")
-    nt.assert_equal((await ip.user_ns["output"].read()), b"hi\n")
+    assert (await ip.user_ns["output"].read()) == b"hi\n"
     ip.user_ns["output"].close()
     asyncio.get_event_loop().stop()
 
+
 @dec.skip_iptest_but_not_pytest
 @dec.skip_win32
 @pytest.mark.skipif(
     sys.platform == "win32", reason="This test does not run under Windows"
 )
 async def test_script_bg_err():
     ip = get_ipython()
     ip.run_cell_magic("script", "--bg --err error sh", "echo 'hello' >&2")
-    nt.assert_equal((await ip.user_ns["error"].read()), b"hello\n")
+    assert (await ip.user_ns["error"].read()) == b"hello\n"
     ip.user_ns["error"].close()
 
 
 @dec.skip_iptest_but_not_pytest
 @dec.skip_win32
 @pytest.mark.skipif(
     sys.platform == "win32", reason="This test does not run under Windows"
 )
 async def test_script_bg_out_err():
     ip = get_ipython()
     ip.run_cell_magic(
         "script", "--bg --out output --err error sh", "echo 'hi'\necho 'hello' >&2"
     )
-    nt.assert_equal((await ip.user_ns["output"].read()), b"hi\n")
-    nt.assert_equal((await ip.user_ns["error"].read()), b"hello\n")
+    assert (await ip.user_ns["output"].read()) == b"hi\n"
+    assert (await ip.user_ns["error"].read()) == b"hello\n"
     ip.user_ns["output"].close()
     ip.user_ns["error"].close()
 
 
 def test_script_defaults():
     ip = get_ipython()
     for cmd in ['sh', 'bash', 'perl', 'ruby']:
         try:
             find_cmd(cmd)
         except Exception:
             pass
         else:
-            nt.assert_in(cmd, ip.magics_manager.magics['cell'])
+            assert cmd in ip.magics_manager.magics["cell"]
 
 
 @magics_class
 class FooFoo(Magics):
     """class with both %foo and %%foo magics"""
     @line_magic('foo')
     def line_foo(self, line):
         "I am line foo"
         pass
 
     @cell_magic("foo")
     def cell_foo(self, line, cell):
         "I am cell foo, not line foo"
         pass
 
 def test_line_cell_info():
     """%%foo and %foo magics are distinguishable to inspect"""
     ip = get_ipython()
     ip.magics_manager.register(FooFoo)
-    oinfo = ip.object_inspect('foo')
-    nt.assert_true(oinfo['found'])
-    nt.assert_true(oinfo['ismagic'])
-    
-    oinfo = ip.object_inspect('%%foo')
-    nt.assert_true(oinfo['found'])
-    nt.assert_true(oinfo['ismagic'])
-    nt.assert_equal(oinfo['docstring'], FooFoo.cell_foo.__doc__)
-
-    oinfo = ip.object_inspect('%foo')
-    nt.assert_true(oinfo['found'])
-    nt.assert_true(oinfo['ismagic'])
-    nt.assert_equal(oinfo['docstring'], FooFoo.line_foo.__doc__)
+    oinfo = ip.object_inspect("foo")
+    assert oinfo["found"] is True
+    assert oinfo["ismagic"] is True
+
+    oinfo = ip.object_inspect("%%foo")
+    assert oinfo["found"] is True
+    assert oinfo["ismagic"] is True
+    assert oinfo["docstring"] == FooFoo.cell_foo.__doc__
+
+    oinfo = ip.object_inspect("%foo")
+    assert oinfo["found"] is True
+    assert oinfo["ismagic"] is True
+    assert oinfo["docstring"] == FooFoo.line_foo.__doc__
+
 
 def test_multiple_magics():
     ip = get_ipython()
     foo1 = FooFoo(ip)
     foo2 = FooFoo(ip)
     mm = ip.magics_manager
     mm.register(foo1)
-    nt.assert_true(mm.magics['line']['foo'].__self__ is foo1)
+    assert mm.magics["line"]["foo"].__self__ is foo1
     mm.register(foo2)
-    nt.assert_true(mm.magics['line']['foo'].__self__ is foo2)
+    assert mm.magics["line"]["foo"].__self__ is foo2
+
 
 def test_alias_magic():
     """Test %alias_magic."""
     ip = get_ipython()
     mm = ip.magics_manager
 
     # Basic operation: both cell and line magics are created, if possible.
-    ip.run_line_magic('alias_magic', 'timeit_alias timeit')
-    nt.assert_in('timeit_alias', mm.magics['line'])
-    nt.assert_in('timeit_alias', mm.magics['cell'])
+    ip.run_line_magic("alias_magic", "timeit_alias timeit")
+    assert "timeit_alias" in mm.magics["line"]
+    assert "timeit_alias" in mm.magics["cell"]
 
     # --cell is specified, line magic not created.
-    ip.run_line_magic('alias_magic', '--cell timeit_cell_alias timeit')
-    nt.assert_not_in('timeit_cell_alias', mm.magics['line'])
-    nt.assert_in('timeit_cell_alias', mm.magics['cell'])
+    ip.run_line_magic("alias_magic", "--cell timeit_cell_alias timeit")
+    assert "timeit_cell_alias" not in mm.magics["line"]
+    assert "timeit_cell_alias" in mm.magics["cell"]
 
     # Test that line alias is created successfully.
-    ip.run_line_magic('alias_magic', '--line env_alias env')
-    nt.assert_equal(ip.run_line_magic('env', ''),
-                    ip.run_line_magic('env_alias', ''))
+    ip.run_line_magic("alias_magic", "--line env_alias env")
+    assert ip.run_line_magic("env", "") == ip.run_line_magic("env_alias", "")
 
     # Test that line alias with parameters passed in is created successfully.
-    ip.run_line_magic('alias_magic', '--line history_alias history --params ' + shlex.quote('3'))
-    nt.assert_in('history_alias', mm.magics['line'])
+    ip.run_line_magic(
+        "alias_magic", "--line history_alias history --params " + shlex.quote("3")
+    )
+    assert "history_alias" in mm.magics["line"]
 
 
 def test_save():
     """Test %save."""
     ip = get_ipython()
     ip.history_manager.reset()   # Clear any existing history.
-    cmds = [u"a=1", u"def b():\n  return a**2", u"print(a, b())"]
+    cmds = ["a=1", "def b():\n  return a**2", "print(a, b())"]
     for i, cmd in enumerate(cmds, start=1):
         ip.history_manager.store_inputs(i, cmd)
     with TemporaryDirectory() as tmpdir:
         file = os.path.join(tmpdir, "testsave.py")
         ip.run_line_magic("save", "%s 1-10" % file)
         content = Path(file).read_text()
-        nt.assert_equal(content.count(cmds[0]), 1)
-        nt.assert_in("coding: utf-8", content)
+        assert content.count(cmds[0]) == 1
+        assert "coding: utf-8" in content
         ip.run_line_magic("save", "-a %s 1-10" % file)
         content = Path(file).read_text()
-        nt.assert_equal(content.count(cmds[0]), 2)
-        nt.assert_in("coding: utf-8", content)
+        assert content.count(cmds[0]) == 2
+        assert "coding: utf-8" in content
 
 
 def test_save_with_no_args():
     ip = get_ipython()
     ip.history_manager.reset()  # Clear any existing history.
-    cmds = [u"a=1", u"def b():\n    return a**2", u"print(a, b())", "%save"]
+    cmds = ["a=1", "def b():\n    return a**2", "print(a, b())", "%save"]
     for i, cmd in enumerate(cmds, start=1):
         ip.history_manager.store_inputs(i, cmd)
 
     with TemporaryDirectory() as tmpdir:
         path = os.path.join(tmpdir, "testsave.py")
         ip.run_line_magic("save", path)
         content = Path(path).read_text()
         expected_content = dedent(
             """\
             # coding: utf-8
             a=1
             def b():
                 return a**2
             print(a, b())
             """
         )
-        nt.assert_equal(content, expected_content)
+        assert content == expected_content
 
 
 def test_store():
     """Test %store."""
     ip = get_ipython()
     ip.run_line_magic('load_ext', 'storemagic')
-    
+
     # make sure the storage is empty
-    ip.run_line_magic('store', '-z')
-    ip.user_ns['var'] = 42
-    ip.run_line_magic('store', 'var')
-    ip.user_ns['var'] = 39
-    ip.run_line_magic('store', '-r')
-    nt.assert_equal(ip.user_ns['var'], 42)
+    ip.run_line_magic("store", "-z")
+    ip.user_ns["var"] = 42
+    ip.run_line_magic("store", "var")
+    ip.user_ns["var"] = 39
+    ip.run_line_magic("store", "-r")
+    assert ip.user_ns["var"] == 42
 
-    ip.run_line_magic('store', '-d var')
-    ip.user_ns['var'] = 39
-    ip.run_line_magic('store' , '-r')
-    nt.assert_equal(ip.user_ns['var'], 39)
+    ip.run_line_magic("store", "-d var")
+    ip.user_ns["var"] = 39
+    ip.run_line_magic("store", "-r")
+    assert ip.user_ns["var"] == 39
 
 
 def _run_edit_test(arg_s, exp_filename=None,
                         exp_lineno=-1,
                         exp_contents=None,
                         exp_is_temp=None):
     ip = get_ipython()
     M = code.CodeMagics(ip)
     last_call = ['','']
     opts,args = M.parse_options(arg_s,'prxn:')
     filename, lineno, is_temp = M._find_edit_target(ip, args, opts, last_call)
-        
+
     if exp_filename is not None:
-        nt.assert_equal(exp_filename, filename)
+        assert exp_filename == filename
     if exp_contents is not None:
         with io.open(filename, 'r', encoding='utf-8') as f:
             contents = f.read()
-        nt.assert_equal(exp_contents, contents)
+        assert exp_contents == contents
     if exp_lineno != -1:
-        nt.assert_equal(exp_lineno, lineno)
+        assert exp_lineno == lineno
     if exp_is_temp is not None:
-        nt.assert_equal(exp_is_temp, is_temp)
+        assert exp_is_temp == is_temp
 
 
 def test_edit_interactive():
     """%edit on interactively defined objects"""
     ip = get_ipython()
     n = ip.execution_count
-    ip.run_cell(u"def foo(): return 1", store_history=True)
-    
+    ip.run_cell("def foo(): return 1", store_history=True)
+
     try:
         _run_edit_test("foo")
     except code.InteractivelyDefined as e:
-        nt.assert_equal(e.index, n)
+        assert e.index == n
     else:
         raise AssertionError("Should have raised InteractivelyDefined")
 
 
 def test_edit_cell():
     """%edit [cell id]"""
     ip = get_ipython()
-    
-    ip.run_cell(u"def foo(): return 1", store_history=True)
-    
+
+    ip.run_cell("def foo(): return 1", store_history=True)
+
     # test
     _run_edit_test("1", exp_contents=ip.user_ns['In'][1], exp_is_temp=True)
 
 def test_edit_fname():
     """%edit file"""
     # test
     _run_edit_test("test file.py", exp_filename="test file.py")
 
 def test_bookmark():
     ip = get_ipython()
     ip.run_line_magic('bookmark', 'bmname')
     with tt.AssertPrints('bmname'):
         ip.run_line_magic('bookmark', '-l')
     ip.run_line_magic('bookmark', '-d bmname')
 
 def test_ls_magic():
     ip = get_ipython()
     json_formatter = ip.display_formatter.formatters['application/json']
     json_formatter.enabled = True
     lsmagic = ip.magic('lsmagic')
     with warnings.catch_warnings(record=True) as w:
         j = json_formatter(lsmagic)
-    nt.assert_equal(sorted(j), ['cell', 'line'])
-    nt.assert_equal(w, []) # no warnings
+    assert sorted(j) == ["cell", "line"]
+    assert w == []  # no warnings
+
 
 def test_strip_initial_indent():
     def sii(s):
         lines = s.splitlines()
         return '\n'.join(code.strip_initial_indent(lines))
 
-    nt.assert_equal(sii("  a = 1\nb = 2"), "a = 1\nb = 2")
-    nt.assert_equal(sii("  a\n    b\nc"), "a\n  b\nc")
-    nt.assert_equal(sii("a\n  b"), "a\n  b")
+    assert sii("  a = 1\nb = 2") == "a = 1\nb = 2"
+    assert sii("  a\n    b\nc") == "a\n  b\nc"
+    assert sii("a\n  b") == "a\n  b"
 
 def test_logging_magic_quiet_from_arg():
     _ip.config.LoggingMagics.quiet = False
     lm = logging.LoggingMagics(shell=_ip)
     with TemporaryDirectory() as td:
         try:
             with tt.AssertNotPrints(re.compile("Activating.*")):
                 lm.logstart('-q {}'.format(
                         os.path.join(td, "quiet_from_arg.log")))
         finally:
             _ip.logger.logstop()
 
 def test_logging_magic_quiet_from_config():
     _ip.config.LoggingMagics.quiet = True
     lm = logging.LoggingMagics(shell=_ip)
     with TemporaryDirectory() as td:
         try:
             with tt.AssertNotPrints(re.compile("Activating.*")):
                 lm.logstart(os.path.join(td, "quiet_from_config.log"))
         finally:
             _ip.logger.logstop()
 
 
 def test_logging_magic_not_quiet():
     _ip.config.LoggingMagics.quiet = False
     lm = logging.LoggingMagics(shell=_ip)
     with TemporaryDirectory() as td:
         try:
             with tt.AssertPrints(re.compile("Activating.*")):
                 lm.logstart(os.path.join(td, "not_quiet.log"))
         finally:
             _ip.logger.logstop()
 
 
 def test_time_no_var_expand():
     _ip.user_ns['a'] = 5
     _ip.user_ns['b'] = []
     _ip.magic('time b.append("{a}")')
     assert _ip.user_ns['b'] == ['{a}']
 
 
 # this is slow, put at the end for local testing.
 def test_timeit_arguments():
     "Test valid timeit arguments, should not cause SyntaxError (GH #1269)"
     if sys.version_info < (3,7):
         _ip.magic("timeit -n1 -r1 ('#')")
     else:
         # 3.7 optimize no-op statement like above out, and complain there is
         # nothing in the for loop.
         _ip.magic("timeit -n1 -r1 a=('#')")
 
 
 TEST_MODULE = """
 print('Loaded my_tmp')
 if __name__ == "__main__":
     print('I just ran a script')
 """
 
 
 def test_run_module_from_import_hook():
     "Test that a module can be loaded via an import hook"
     with TemporaryDirectory() as tmpdir:
         fullpath = os.path.join(tmpdir, 'my_tmp.py')
         Path(fullpath).write_text(TEST_MODULE)
 
         class MyTempImporter(object):
             def __init__(self):
                 pass
 
             def find_module(self, fullname, path=None):
                 if 'my_tmp' in fullname:
                     return self
                 return None
 
             def load_module(self, name):
                 import imp
                 return imp.load_source('my_tmp', fullpath)
 
             def get_code(self, fullname):
                 return compile(Path(fullpath).read_text(), "foo", "exec")
 
             def is_package(self, __):
                 return False
 
         sys.meta_path.insert(0, MyTempImporter())
 
         with capture_output() as captured:
             _ip.magic("run -m my_tmp")
             _ip.run_cell("import my_tmp")
 
         output = "Loaded my_tmp\nI just ran a script\nLoaded my_tmp\n"
-        nt.assert_equal(output, captured.stdout)
+        assert output == captured.stdout
 
         sys.meta_path.pop(0)

IPython/core/tests/test_magic_terminal.py

@@ -1,192 +1,193 b''
 """Tests for various magic functions specific to the terminal frontend.
 
 Needs to be run by nose (to make ipython session available).
 """
 
 #-----------------------------------------------------------------------------
 # Imports
 #-----------------------------------------------------------------------------
 
 import sys
 from io import StringIO
 from unittest import TestCase
 
-import nose.tools as nt
-
 from IPython.testing import tools as tt
 
 #-----------------------------------------------------------------------------
 # Test functions begin
 #-----------------------------------------------------------------------------
 
 def check_cpaste(code, should_fail=False):
     """Execute code via 'cpaste' and ensure it was executed, unless
     should_fail is set.
     """
     ip.user_ns['code_ran'] = False
 
     src = StringIO()
     if not hasattr(src, 'encoding'):
         # IPython expects stdin to have an encoding attribute
         src.encoding = None
     src.write(code)
     src.write('\n--\n')
     src.seek(0)
 
     stdin_save = sys.stdin
     sys.stdin = src
 
     try:
         context = tt.AssertPrints if should_fail else tt.AssertNotPrints
         with context("Traceback (most recent call last)"):
                 ip.magic('cpaste')
 
         if not should_fail:
             assert ip.user_ns['code_ran'], "%r failed" % code
     finally:
         sys.stdin = stdin_save
 
 def test_cpaste():
     """Test cpaste magic"""
 
     def runf():
         """Marker function: sets a flag when executed.
         """
         ip.user_ns['code_ran'] = True
         return 'runf' # return string so '+ runf()' doesn't result in success
 
     tests = {'pass': ["runf()",
                       "In [1]: runf()",
                       "In [1]: if 1:\n   ...:     runf()",
                       "> > > runf()",
                       ">>> runf()",
                       "   >>> runf()",
                       ],
 
              'fail': ["1 + runf()",
                       "++ runf()",
              ]}
 
     ip.user_ns['runf'] = runf
 
     for code in tests['pass']:
         check_cpaste(code)
 
     for code in tests['fail']:
         check_cpaste(code, should_fail=True)
 
 
 class PasteTestCase(TestCase):
     """Multiple tests for clipboard pasting"""
 
     def paste(self, txt, flags='-q'):
         """Paste input text, by default in quiet mode"""
         ip.hooks.clipboard_get = lambda : txt
         ip.magic('paste '+flags)
 
     def setUp(self):
         # Inject fake clipboard hook but save original so we can restore it later
         self.original_clip = ip.hooks.clipboard_get
 
     def tearDown(self): 
         # Restore original hook
         ip.hooks.clipboard_get = self.original_clip
        
     def test_paste(self):
-        ip.user_ns.pop('x', None)
-        self.paste('x = 1')
-        nt.assert_equal(ip.user_ns['x'], 1)
-        ip.user_ns.pop('x')
+        ip.user_ns.pop("x", None)
+        self.paste("x = 1")
+        self.assertEqual(ip.user_ns["x"], 1)
+        ip.user_ns.pop("x")
 
     def test_paste_pyprompt(self):
-        ip.user_ns.pop('x', None)
-        self.paste('>>> x=2')
-        nt.assert_equal(ip.user_ns['x'], 2)
-        ip.user_ns.pop('x')
+        ip.user_ns.pop("x", None)
+        self.paste(">>> x=2")
+        self.assertEqual(ip.user_ns["x"], 2)
+        ip.user_ns.pop("x")
 
     def test_paste_py_multi(self):
         self.paste("""
         >>> x = [1,2,3]
         >>> y = []
         >>> for i in x:
         ...     y.append(i**2)
         ... 
-        """)
-        nt.assert_equal(ip.user_ns['x'], [1,2,3])
-        nt.assert_equal(ip.user_ns['y'], [1,4,9])
+        """
+        )
+        self.assertEqual(ip.user_ns["x"], [1, 2, 3])
+        self.assertEqual(ip.user_ns["y"], [1, 4, 9])
 
     def test_paste_py_multi_r(self):
         "Now, test that self.paste -r works"
         self.test_paste_py_multi()
-        nt.assert_equal(ip.user_ns.pop('x'), [1,2,3])
-        nt.assert_equal(ip.user_ns.pop('y'), [1,4,9])
-        nt.assert_false('x' in ip.user_ns)
-        ip.magic('paste -r')
-        nt.assert_equal(ip.user_ns['x'], [1,2,3])
-        nt.assert_equal(ip.user_ns['y'], [1,4,9])
+        self.assertEqual(ip.user_ns.pop("x"), [1, 2, 3])
+        self.assertEqual(ip.user_ns.pop("y"), [1, 4, 9])
+        self.assertFalse("x" in ip.user_ns)
+        ip.magic("paste -r")
+        self.assertEqual(ip.user_ns["x"], [1, 2, 3])
+        self.assertEqual(ip.user_ns["y"], [1, 4, 9])
 
     def test_paste_email(self):
         "Test pasting of email-quoted contents"
         self.paste("""\
         >> def foo(x):
         >>     return x + 1
-        >> xx = foo(1.1)""")
-        nt.assert_equal(ip.user_ns['xx'], 2.1)
+        >> xx = foo(1.1)"""
+        )
+        self.assertEqual(ip.user_ns["xx"], 2.1)
 
     def test_paste_email2(self):
         "Email again; some programs add a space also at each quoting level"
         self.paste("""\
         > > def foo(x):
         > >     return x + 1
-        > > yy = foo(2.1)     """)
-        nt.assert_equal(ip.user_ns['yy'], 3.1)
+        > > yy = foo(2.1)     """
+        )
+        self.assertEqual(ip.user_ns["yy"], 3.1)
 
     def test_paste_email_py(self):
         "Email quoting of interactive input"
         self.paste("""\
         >> >>> def f(x):
         >> ...   return x+1
         >> ... 
-        >> >>> zz = f(2.5)      """)
-        nt.assert_equal(ip.user_ns['zz'], 3.5)
+        >> >>> zz = f(2.5)      """
+        )
+        self.assertEqual(ip.user_ns["zz"], 3.5)
 
     def test_paste_echo(self):
         "Also test self.paste echoing, by temporarily faking the writer"
         w = StringIO()
         writer = ip.write
         ip.write = w.write
         code = """
         a = 100
         b = 200"""
         try:
             self.paste(code,'')
             out = w.getvalue()
         finally:
             ip.write = writer
-        nt.assert_equal(ip.user_ns['a'], 100)
-        nt.assert_equal(ip.user_ns['b'], 200)
-        assert out == code+"\n## -- End pasted text --\n"
+        self.assertEqual(ip.user_ns["a"], 100)
+        self.assertEqual(ip.user_ns["b"], 200)
+        assert out == code + "\n## -- End pasted text --\n"
 
     def test_paste_leading_commas(self):
         "Test multiline strings with leading commas"
         tm = ip.magics_manager.registry['TerminalMagics']
         s = '''\
 a = """
 ,1,2,3
 """'''
-        ip.user_ns.pop('foo', None)
-        tm.store_or_execute(s, 'foo')
-        nt.assert_in('foo', ip.user_ns)
-
+        ip.user_ns.pop("foo", None)
+        tm.store_or_execute(s, "foo")
+        self.assertIn("foo", ip.user_ns)
 
     def test_paste_trailing_question(self):
         "Test pasting sources with trailing question marks"
         tm = ip.magics_manager.registry['TerminalMagics']
         s = '''\
 def funcfoo():
    if True: #am i true?
        return 'fooresult'
 '''
         ip.user_ns.pop('funcfoo', None)
         self.paste(s)
-        nt.assert_equal(ip.user_ns['funcfoo'](), 'fooresult')
+        self.assertEqual(ip.user_ns["funcfoo"](), "fooresult")

IPython/core/tests/test_oinspect.py

@@ -1,455 +1,454 b''
 """Tests for the object inspection functionality.
 """
 
 # Copyright (c) IPython Development Team.
 # Distributed under the terms of the Modified BSD License.
 
 
 from inspect import signature, Signature, Parameter
 import os
 import re
 
-import nose.tools as nt
-
 from .. import oinspect
 
 from decorator import decorator
 
 from IPython.testing.tools import AssertPrints, AssertNotPrints
 from IPython.utils.path import compress_user
 
 
 #-----------------------------------------------------------------------------
 # Globals and constants
 #-----------------------------------------------------------------------------
 
 inspector = None
 
 def setup_module():
     global inspector
     inspector = oinspect.Inspector()
 
 
 #-----------------------------------------------------------------------------
 # Local utilities
 #-----------------------------------------------------------------------------
 
 # WARNING: since this test checks the line number where a function is
 # defined, if any code is inserted above, the following line will need to be
 # updated.  Do NOT insert any whitespace between the next line and the function
 # definition below.
-THIS_LINE_NUMBER = 41  # Put here the actual number of this line
+THIS_LINE_NUMBER = 39  # Put here the actual number of this line
 
 from unittest import TestCase
 
 class Test(TestCase):
 
     def test_find_source_lines(self):
         self.assertEqual(oinspect.find_source_lines(Test.test_find_source_lines),
                     THIS_LINE_NUMBER+6)
 
 
 # A couple of utilities to ensure these tests work the same from a source or a
 # binary install
 def pyfile(fname):
     return os.path.normcase(re.sub('.py[co]$', '.py', fname))
 
 
 def match_pyfiles(f1, f2):
     assert pyfile(f1) == pyfile(f2)
 
 
 def test_find_file():
     match_pyfiles(oinspect.find_file(test_find_file), os.path.abspath(__file__))
 
 
 def test_find_file_decorated1():
 
     @decorator
     def noop1(f):
         def wrapper(*a, **kw):
             return f(*a, **kw)
         return wrapper
 
     @noop1
     def f(x):
         "My docstring"
-    
+
     match_pyfiles(oinspect.find_file(f), os.path.abspath(__file__))
     assert f.__doc__ == "My docstring"
 
 
 def test_find_file_decorated2():
 
     @decorator
     def noop2(f, *a, **kw):
         return f(*a, **kw)
 
     @noop2
     @noop2
     @noop2
     def f(x):
         "My docstring 2"
-    
+
     match_pyfiles(oinspect.find_file(f), os.path.abspath(__file__))
     assert f.__doc__ == "My docstring 2"
-    
+
 
 def test_find_file_magic():
     run = ip.find_line_magic('run')
-    nt.assert_not_equal(oinspect.find_file(run), None)
+    assert oinspect.find_file(run) is not None
 
 
 # A few generic objects we can then inspect in the tests below
 
 class Call(object):
     """This is the class docstring."""
 
     def __init__(self, x, y=1):
         """This is the constructor docstring."""
 
     def __call__(self, *a, **kw):
         """This is the call docstring."""
 
     def method(self, x, z=2):
         """Some method's docstring"""
 
 class HasSignature(object):
     """This is the class docstring."""
     __signature__ = Signature([Parameter('test', Parameter.POSITIONAL_OR_KEYWORD)])
 
     def __init__(self, *args):
         """This is the init docstring"""
 
 
 class SimpleClass(object):
     def method(self, x, z=2):
         """Some method's docstring"""
 
 
 class Awkward(object):
     def __getattr__(self, name):
         raise Exception(name)
 
 class NoBoolCall:
     """
     callable with `__bool__` raising should still be inspect-able.
     """
 
     def __call__(self):
         """does nothing"""
         pass
 
     def __bool__(self):
         """just raise NotImplemented"""
         raise NotImplementedError('Must be implemented')
 
 
 class SerialLiar(object):
     """Attribute accesses always get another copy of the same class.
 
     unittest.mock.call does something similar, but it's not ideal for testing
     as the failure mode is to eat all your RAM. This gives up after 10k levels.
     """
     def __init__(self, max_fibbing_twig, lies_told=0):
         if lies_told > 10000:
             raise RuntimeError('Nose too long, honesty is the best policy')
         self.max_fibbing_twig = max_fibbing_twig
         self.lies_told = lies_told
         max_fibbing_twig[0] = max(max_fibbing_twig[0], lies_told)
 
     def __getattr__(self, item):
         return SerialLiar(self.max_fibbing_twig, self.lies_told + 1)
 
 #-----------------------------------------------------------------------------
 # Tests
 #-----------------------------------------------------------------------------
 
 def test_info():
     "Check that Inspector.info fills out various fields as expected."
     i = inspector.info(Call, oname="Call")
     assert i["type_name"] == "type"
-    expted_class = str(type(type))  # <class 'type'> (Python 3) or <type 'type'>
-    assert i["base_class"] == expted_class
-    nt.assert_regex(
-        i["string_form"],
+    expected_class = str(type(type))  # <class 'type'> (Python 3) or <type 'type'>
+    assert i["base_class"] == expected_class
+    assert re.search(
         "<class 'IPython.core.tests.test_oinspect.Call'( at 0x[0-9a-f]{1,9})?>",
+        i["string_form"],
     )
     fname = __file__
     if fname.endswith(".pyc"):
         fname = fname[:-1]
     # case-insensitive comparison needed on some filesystems
     # e.g. Windows:
     assert i["file"].lower() == compress_user(fname).lower()
     assert i["definition"] == None
     assert i["docstring"] == Call.__doc__
     assert i["source"] == None
-    nt.assert_true(i["isclass"])
+    assert i["isclass"] is True
     assert i["init_definition"] == "Call(x, y=1)"
     assert i["init_docstring"] == Call.__init__.__doc__
 
     i = inspector.info(Call, detail_level=1)
-    nt.assert_not_equal(i["source"], None)
+    assert i["source"] is not None
     assert i["docstring"] == None
 
     c = Call(1)
     c.__doc__ = "Modified instance docstring"
     i = inspector.info(c)
     assert i["type_name"] == "Call"
     assert i["docstring"] == "Modified instance docstring"
     assert i["class_docstring"] == Call.__doc__
     assert i["init_docstring"] == Call.__init__.__doc__
     assert i["call_docstring"] == Call.__call__.__doc__
 
 
 def test_class_signature():
     info = inspector.info(HasSignature, "HasSignature")
     assert info["init_definition"] == "HasSignature(test)"
     assert info["init_docstring"] == HasSignature.__init__.__doc__
 
 
 def test_info_awkward():
     # Just test that this doesn't throw an error.
     inspector.info(Awkward())
 
 def test_bool_raise():
     inspector.info(NoBoolCall())
 
 def test_info_serialliar():
     fib_tracker = [0]
     inspector.info(SerialLiar(fib_tracker))
 
     # Nested attribute access should be cut off at 100 levels deep to avoid
     # infinite loops: https://github.com/ipython/ipython/issues/9122
-    nt.assert_less(fib_tracker[0], 9000)
+    assert fib_tracker[0] < 9000
 
 def support_function_one(x, y=2, *a, **kw):
     """A simple function."""
 
 def test_calldef_none():
     # We should ignore __call__ for all of these.
     for obj in [support_function_one, SimpleClass().method, any, str.upper]:
         i = inspector.info(obj)
-        nt.assert_is(i['call_def'], None)
+        assert i["call_def"] is None
+
 
 def f_kwarg(pos, *, kwonly):
     pass
 
 def test_definition_kwonlyargs():
     i = inspector.info(f_kwarg, oname="f_kwarg")  # analysis:ignore
     assert i["definition"] == "f_kwarg(pos, *, kwonly)"
 
 
 def test_getdoc():
     class A(object):
         """standard docstring"""
         pass
 
     class B(object):
         """standard docstring"""
         def getdoc(self):
             return "custom docstring"
-    
+
     class C(object):
         """standard docstring"""
         def getdoc(self):
             return None
-    
+
     a = A()
     b = B()
     c = C()
-    
+
     assert oinspect.getdoc(a) == "standard docstring"
     assert oinspect.getdoc(b) == "custom docstring"
     assert oinspect.getdoc(c) == "standard docstring"
 
 
 def test_empty_property_has_no_source():
     i = inspector.info(property(), detail_level=1)
-    nt.assert_is(i['source'], None)
+    assert i["source"] is None
 
 
 def test_property_sources():
-    import posixpath 
+    import posixpath
     # A simple adder whose source and signature stays
     # the same across Python distributions
     def simple_add(a, b):
         "Adds two numbers"
         return a + b
-    
+
     class A(object):
         @property
         def foo(self):
             return 'bar'
 
         foo = foo.setter(lambda self, v: setattr(self, 'bar', v))
 
         dname = property(posixpath.dirname)
-        adder = property(simple_add) 
+        adder = property(simple_add)
 
     i = inspector.info(A.foo, detail_level=1)
-    nt.assert_in('def foo(self):', i['source'])
-    nt.assert_in('lambda self, v:', i['source'])
+    assert "def foo(self):" in i["source"]
+    assert "lambda self, v:" in i["source"]
 
     i = inspector.info(A.dname, detail_level=1)
-    nt.assert_in('def dirname(p)', i['source'])
-    
+    assert "def dirname(p)" in i["source"]
+
     i = inspector.info(A.adder, detail_level=1)
-    nt.assert_in('def simple_add(a, b)', i['source'])
+    assert "def simple_add(a, b)" in i["source"]
 
 
 def test_property_docstring_is_in_info_for_detail_level_0():
     class A(object):
         @property
         def foobar(self):
             """This is `foobar` property."""
             pass
 
     ip.user_ns["a_obj"] = A()
     assert (
         "This is `foobar` property."
         == ip.object_inspect("a_obj.foobar", detail_level=0)["docstring"]
     )
 
     ip.user_ns["a_cls"] = A
     assert (
         "This is `foobar` property."
         == ip.object_inspect("a_cls.foobar", detail_level=0)["docstring"]
     )
 
 
 def test_pdef():
     # See gh-1914
     def foo(): pass
     inspector.pdef(foo, 'foo')
 
 
 def test_pinfo_nonascii():
     # See gh-1177
     from . import nonascii2
     ip.user_ns['nonascii2'] = nonascii2
     ip._inspect('pinfo', 'nonascii2', detail_level=1)
 
 def test_pinfo_type():
     """
     type can fail in various edge case, for example `type.__subclass__()`
     """
     ip._inspect('pinfo', 'type')
 
 
 def test_pinfo_docstring_no_source():
     """Docstring should be included with detail_level=1 if there is no source"""
     with AssertPrints('Docstring:'):
         ip._inspect('pinfo', 'str.format', detail_level=0)
     with AssertPrints('Docstring:'):
         ip._inspect('pinfo', 'str.format', detail_level=1)
 
 
 def test_pinfo_no_docstring_if_source():
     """Docstring should not be included with detail_level=1 if source is found"""
     def foo():
         """foo has a docstring"""
 
     ip.user_ns['foo'] = foo
 
     with AssertPrints('Docstring:'):
         ip._inspect('pinfo', 'foo', detail_level=0)
     with AssertPrints('Source:'):
         ip._inspect('pinfo', 'foo', detail_level=1)
     with AssertNotPrints('Docstring:'):
         ip._inspect('pinfo', 'foo', detail_level=1)
 
 
 def test_pinfo_docstring_if_detail_and_no_source():
     """ Docstring should be displayed if source info not available """
     obj_def = '''class Foo(object):
                   """ This is a docstring for Foo """
                   def bar(self):
                       """ This is a docstring for Foo.bar """
                       pass
-              ''' 
-    
+              '''
+
     ip.run_cell(obj_def)
     ip.run_cell('foo = Foo()')
-    
+
     with AssertNotPrints("Source:"):
         with AssertPrints('Docstring:'):
             ip._inspect('pinfo', 'foo', detail_level=0)
         with AssertPrints('Docstring:'):
             ip._inspect('pinfo', 'foo', detail_level=1)
         with AssertPrints('Docstring:'):
             ip._inspect('pinfo', 'foo.bar', detail_level=0)
 
     with AssertNotPrints('Docstring:'):
         with AssertPrints('Source:'):
             ip._inspect('pinfo', 'foo.bar', detail_level=1)
 
 
 def test_pinfo_magic():
     with AssertPrints('Docstring:'):
         ip._inspect('pinfo', 'lsmagic', detail_level=0)
 
     with AssertPrints('Source:'):
         ip._inspect('pinfo', 'lsmagic', detail_level=1)
 
 
 def test_init_colors():
     # ensure colors are not present in signature info
     info = inspector.info(HasSignature)
-    init_def = info['init_definition']
-    nt.assert_not_in('[0m', init_def)
+    init_def = info["init_definition"]
+    assert "[0m" not in init_def
 
 
 def test_builtin_init():
     info = inspector.info(list)
     init_def = info['init_definition']
-    nt.assert_is_not_none(init_def)
+    assert init_def is not None
 
 
 def test_render_signature_short():
     def short_fun(a=1): pass
     sig = oinspect._render_signature(
         signature(short_fun),
         short_fun.__name__,
     )
     assert sig == "short_fun(a=1)"
 
 
 def test_render_signature_long():
     from typing import Optional
 
     def long_function(
         a_really_long_parameter: int,
         and_another_long_one: bool = False,
         let_us_make_sure_this_is_looong: Optional[str] = None,
     ) -> bool: pass
 
     sig = oinspect._render_signature(
         signature(long_function),
         long_function.__name__,
     )
-    nt.assert_in(sig, [
+    assert sig in [
         # Python >=3.9
         '''\
 long_function(
     a_really_long_parameter: int,
     and_another_long_one: bool = False,
     let_us_make_sure_this_is_looong: Optional[str] = None,
 ) -> bool\
 ''',
         # Python >=3.7
         '''\
 long_function(
     a_really_long_parameter: int,
     and_another_long_one: bool = False,
     let_us_make_sure_this_is_looong: Union[str, NoneType] = None,
 ) -> bool\
 ''',  # Python <=3.6
         '''\
 long_function(
     a_really_long_parameter:int,
     and_another_long_one:bool=False,
     let_us_make_sure_this_is_looong:Union[str, NoneType]=None,
 ) -> bool\
 ''',
-    ])
+    ]

IPython/core/tests/test_paths.py

@@ -1,204 +1,205 b''
 import errno
 import os
 import shutil
 import sys
 import tempfile
 import warnings
 from unittest.mock import patch
 
-import nose.tools as nt
 from testpath import modified_env, assert_isdir, assert_isfile
 
 from IPython import paths
 from IPython.testing.decorators import skip_win32
 from IPython.utils.tempdir import TemporaryDirectory
 
 TMP_TEST_DIR = os.path.realpath(tempfile.mkdtemp())
 HOME_TEST_DIR = os.path.join(TMP_TEST_DIR, "home_test_dir")
 XDG_TEST_DIR = os.path.join(HOME_TEST_DIR, "xdg_test_dir")
 XDG_CACHE_DIR = os.path.join(HOME_TEST_DIR, "xdg_cache_dir")
 IP_TEST_DIR = os.path.join(HOME_TEST_DIR,'.ipython')
 
 def setup_module():
     """Setup testenvironment for the module:
 
             - Adds dummy home dir tree
     """
     # Do not mask exceptions here.  In particular, catching WindowsError is a
     # problem because that exception is only defined on Windows...
     os.makedirs(IP_TEST_DIR)
     os.makedirs(os.path.join(XDG_TEST_DIR, 'ipython'))
     os.makedirs(os.path.join(XDG_CACHE_DIR, 'ipython'))
 
 
 def teardown_module():
     """Teardown testenvironment for the module:
 
             - Remove dummy home dir tree
     """
     # Note: we remove the parent test dir, which is the root of all test
     # subdirs we may have created.  Use shutil instead of os.removedirs, so
     # that non-empty directories are all recursively removed.
     shutil.rmtree(TMP_TEST_DIR)
 
 def patch_get_home_dir(dirpath):
     return patch.object(paths, 'get_home_dir', return_value=dirpath)
 
 
 def test_get_ipython_dir_1():
     """test_get_ipython_dir_1, Testcase to see if we can call get_ipython_dir without Exceptions."""
     env_ipdir = os.path.join("someplace", ".ipython")
     with patch.object(paths, '_writable_dir', return_value=True), \
             modified_env({'IPYTHONDIR': env_ipdir}):
         ipdir = paths.get_ipython_dir()
 
-    nt.assert_equal(ipdir, env_ipdir)
+    assert ipdir == env_ipdir
 
 def test_get_ipython_dir_2():
     """test_get_ipython_dir_2, Testcase to see if we can call get_ipython_dir without Exceptions."""
     with patch_get_home_dir('someplace'), \
             patch.object(paths, 'get_xdg_dir', return_value=None), \
             patch.object(paths, '_writable_dir', return_value=True), \
             patch('os.name', "posix"), \
             modified_env({'IPYTHON_DIR': None,
                           'IPYTHONDIR': None,
                           'XDG_CONFIG_HOME': None
                          }):
         ipdir = paths.get_ipython_dir()
 
-    nt.assert_equal(ipdir, os.path.join("someplace", ".ipython"))
+    assert ipdir == os.path.join("someplace", ".ipython")
 
 def test_get_ipython_dir_3():
     """test_get_ipython_dir_3, move XDG if defined, and .ipython doesn't exist."""
     tmphome = TemporaryDirectory()
     try:
         with patch_get_home_dir(tmphome.name), \
                 patch('os.name', 'posix'), \
                 modified_env({
                     'IPYTHON_DIR': None,
                     'IPYTHONDIR': None,
                     'XDG_CONFIG_HOME': XDG_TEST_DIR,
                 }), warnings.catch_warnings(record=True) as w:
             ipdir = paths.get_ipython_dir()
 
-        nt.assert_equal(ipdir, os.path.join(tmphome.name, ".ipython"))
+        assert ipdir == os.path.join(tmphome.name, ".ipython")
         if sys.platform != 'darwin':
-            nt.assert_equal(len(w), 1)
-            nt.assert_in('Moving', str(w[0]))
+            assert len(w) == 1
+            assert "Moving" in str(w[0])
     finally:
         tmphome.cleanup()
 
 def test_get_ipython_dir_4():
     """test_get_ipython_dir_4, warn if XDG and home both exist."""
     with patch_get_home_dir(HOME_TEST_DIR), \
             patch('os.name', 'posix'):
         try:
             os.mkdir(os.path.join(XDG_TEST_DIR, 'ipython'))
         except OSError as e:
             if e.errno != errno.EEXIST:
                 raise
 
 
         with modified_env({
             'IPYTHON_DIR': None,
             'IPYTHONDIR': None,
             'XDG_CONFIG_HOME': XDG_TEST_DIR,
         }), warnings.catch_warnings(record=True) as w:
             ipdir = paths.get_ipython_dir()
 
-        nt.assert_equal(ipdir, os.path.join(HOME_TEST_DIR, ".ipython"))
+        assert ipdir == os.path.join(HOME_TEST_DIR, ".ipython")
         if sys.platform != 'darwin':
-            nt.assert_equal(len(w), 1)
-            nt.assert_in('Ignoring', str(w[0]))
+            assert len(w) == 1
+            assert "Ignoring" in str(w[0])
+
 
 def test_get_ipython_dir_5():
     """test_get_ipython_dir_5, use .ipython if exists and XDG defined, but doesn't exist."""
     with patch_get_home_dir(HOME_TEST_DIR), \
             patch('os.name', 'posix'):
         try:
             os.rmdir(os.path.join(XDG_TEST_DIR, 'ipython'))
         except OSError as e:
             if e.errno != errno.ENOENT:
                 raise
 
         with modified_env({
             'IPYTHON_DIR': None,
             'IPYTHONDIR': None,
             'XDG_CONFIG_HOME': XDG_TEST_DIR,
         }):
             ipdir = paths.get_ipython_dir()
 
-        nt.assert_equal(ipdir, IP_TEST_DIR)
+        assert ipdir == IP_TEST_DIR
 
 def test_get_ipython_dir_6():
     """test_get_ipython_dir_6, use home over XDG if defined and neither exist."""
     xdg = os.path.join(HOME_TEST_DIR, 'somexdg')
     os.mkdir(xdg)
     shutil.rmtree(os.path.join(HOME_TEST_DIR, '.ipython'))
     print(paths._writable_dir)
     with patch_get_home_dir(HOME_TEST_DIR), \
             patch.object(paths, 'get_xdg_dir', return_value=xdg), \
             patch('os.name', 'posix'), \
             modified_env({
                 'IPYTHON_DIR': None,
                 'IPYTHONDIR': None,
                 'XDG_CONFIG_HOME': None,
             }), warnings.catch_warnings(record=True) as w:
         ipdir = paths.get_ipython_dir()
 
-    nt.assert_equal(ipdir, os.path.join(HOME_TEST_DIR, '.ipython'))
-    nt.assert_equal(len(w), 0)
+    assert ipdir == os.path.join(HOME_TEST_DIR, ".ipython")
+    assert len(w) == 0
 
 def test_get_ipython_dir_7():
     """test_get_ipython_dir_7, test home directory expansion on IPYTHONDIR"""
     home_dir = os.path.normpath(os.path.expanduser('~'))
     with modified_env({'IPYTHONDIR': os.path.join('~', 'somewhere')}), \
             patch.object(paths, '_writable_dir', return_value=True):
         ipdir = paths.get_ipython_dir()
-    nt.assert_equal(ipdir, os.path.join(home_dir, 'somewhere'))
+    assert ipdir == os.path.join(home_dir, "somewhere")
+
 
 @skip_win32
 def test_get_ipython_dir_8():
     """test_get_ipython_dir_8, test / home directory"""
     if not os.access("/", os.W_OK):
         # test only when HOME directory actually writable
         return
 
-    with patch.object(paths, '_writable_dir', lambda path: bool(path)), \
-            patch.object(paths, 'get_xdg_dir', return_value=None), \
-            modified_env({
-                'IPYTHON_DIR': None,
-                'IPYTHONDIR': None,
-                'HOME': '/',
-            }):
-        nt.assert_equal(paths.get_ipython_dir(), '/.ipython')
+    with patch.object(paths, "_writable_dir", lambda path: bool(path)), patch.object(
+        paths, "get_xdg_dir", return_value=None
+    ), modified_env(
+        {
+            "IPYTHON_DIR": None,
+            "IPYTHONDIR": None,
+            "HOME": "/",
+        }
+    ):
+        assert paths.get_ipython_dir() == "/.ipython"
 
 
 def test_get_ipython_cache_dir():
     with modified_env({'HOME': HOME_TEST_DIR}):
         if os.name == 'posix' and sys.platform != 'darwin':
             # test default
             os.makedirs(os.path.join(HOME_TEST_DIR, ".cache"))
             with modified_env({'XDG_CACHE_HOME': None}):
                 ipdir = paths.get_ipython_cache_dir()
-            nt.assert_equal(os.path.join(HOME_TEST_DIR, ".cache", "ipython"),
-                            ipdir)
+            assert os.path.join(HOME_TEST_DIR, ".cache", "ipython") == ipdir
             assert_isdir(ipdir)
 
             # test env override
             with modified_env({"XDG_CACHE_HOME": XDG_CACHE_DIR}):
                 ipdir = paths.get_ipython_cache_dir()
             assert_isdir(ipdir)
-            nt.assert_equal(ipdir, os.path.join(XDG_CACHE_DIR, "ipython"))
+            assert ipdir == os.path.join(XDG_CACHE_DIR, "ipython")
         else:
-            nt.assert_equal(paths.get_ipython_cache_dir(),
-                            paths.get_ipython_dir())
+            assert paths.get_ipython_cache_dir() == paths.get_ipython_dir()
 
 def test_get_ipython_package_dir():
     ipdir = paths.get_ipython_package_dir()
     assert_isdir(ipdir)
 
 
 def test_get_ipython_module_path():
     ipapp_path = paths.get_ipython_module_path('IPython.terminal.ipapp')
     assert_isfile(ipapp_path)

IPython/core/tests/test_profile.py

@@ -1,170 +1,167 b''
 # coding: utf-8
 """Tests for profile-related functions.
 
 Currently only the startup-dir functionality is tested, but more tests should
 be added for:
 
     * ipython profile create
     * ipython profile list
     * ipython profile create --parallel
     * security dir permissions
 
 Authors
 -------
 
 * MinRK
 
 """
 
 #-----------------------------------------------------------------------------
 # Imports
 #-----------------------------------------------------------------------------
 
 import shutil
 import sys
 import tempfile
 
 from pathlib import Path
 from unittest import TestCase
 
-import nose.tools as nt
-
 from IPython.core.profileapp import list_profiles_in, list_bundled_profiles
 from IPython.core.profiledir import ProfileDir
 
 from IPython.testing import decorators as dec
 from IPython.testing import tools as tt
 from IPython.utils.process import getoutput
 from IPython.utils.tempdir import TemporaryDirectory
 
 #-----------------------------------------------------------------------------
 # Globals
 #-----------------------------------------------------------------------------
 TMP_TEST_DIR = Path(tempfile.mkdtemp())
 HOME_TEST_DIR = TMP_TEST_DIR / "home_test_dir"
 IP_TEST_DIR = HOME_TEST_DIR / ".ipython"
 
 #
 # Setup/teardown functions/decorators
 #
 
 def setup_module():
     """Setup test environment for the module:
 
             - Adds dummy home dir tree
     """
     # Do not mask exceptions here.  In particular, catching WindowsError is a
     # problem because that exception is only defined on Windows...
     (Path.cwd() / IP_TEST_DIR).mkdir(parents=True)
 
 
 def teardown_module():
     """Teardown test environment for the module:
 
             - Remove dummy home dir tree
     """
     # Note: we remove the parent test dir, which is the root of all test
     # subdirs we may have created.  Use shutil instead of os.removedirs, so
     # that non-empty directories are all recursively removed.
     shutil.rmtree(TMP_TEST_DIR)
 
 
 #-----------------------------------------------------------------------------
 # Test functions
 #-----------------------------------------------------------------------------
 def win32_without_pywin32():
     if sys.platform == 'win32':
         try:
             import pywin32
         except ImportError:
             return True
     return False
-    
+
 
 class ProfileStartupTest(TestCase):
     def setUp(self):
         # create profile dir
         self.pd = ProfileDir.create_profile_dir_by_name(IP_TEST_DIR, "test")
         self.options = ["--ipython-dir", IP_TEST_DIR, "--profile", "test"]
         self.fname = TMP_TEST_DIR / "test.py"
 
     def tearDown(self):
         # We must remove this profile right away so its presence doesn't
         # confuse other tests.
         shutil.rmtree(self.pd.location)
 
     def init(self, startup_file, startup, test):
         # write startup python file
         with open(Path(self.pd.startup_dir) / startup_file, "w") as f:
             f.write(startup)
         # write simple test file, to check that the startup file was run
         with open(self.fname, 'w') as f:
             f.write(test)
 
     def validate(self, output):
         tt.ipexec_validate(self.fname, output, '', options=self.options)
 
     @dec.skipif(win32_without_pywin32(), "Test requires pywin32 on Windows")
     def test_startup_py(self):
         self.init('00-start.py', 'zzz=123\n', 'print(zzz)\n')
         self.validate('123')
 
     @dec.skipif(win32_without_pywin32(), "Test requires pywin32 on Windows")
     def test_startup_ipy(self):
         self.init('00-start.ipy', '%xmode plain\n', '')
         self.validate('Exception reporting mode: Plain')
 
-    
+
 def test_list_profiles_in():
     # No need to remove these directories and files, as they will get nuked in
     # the module-level teardown.
     td = Path(tempfile.mkdtemp(dir=TMP_TEST_DIR))
     for name in ("profile_foo", "profile_hello", "not_a_profile"):
         Path(td / name).mkdir(parents=True)
     if dec.unicode_paths:
         Path(td / u"profile_ünicode").mkdir(parents=True)
 
     with open(td / "profile_file", "w") as f:
         f.write("I am not a profile directory")
     profiles = list_profiles_in(td)
-    
+
     # unicode normalization can turn u'ünicode' into u'u\0308nicode',
     # so only check for *nicode, and that creating a ProfileDir from the
     # name remains valid
     found_unicode = False
     for p in list(profiles):
         if p.endswith('nicode'):
             pd = ProfileDir.find_profile_dir_by_name(td, p)
             profiles.remove(p)
             found_unicode = True
             break
     if dec.unicode_paths:
-        nt.assert_true(found_unicode)
-    nt.assert_equal(set(profiles), {'foo', 'hello'})
+        assert found_unicode is True
+    assert set(profiles) == {"foo", "hello"}
 
 
 def test_list_bundled_profiles():
     # This variable will need to be updated when a new profile gets bundled
     bundled = sorted(list_bundled_profiles())
-    nt.assert_equal(bundled, [])
+    assert bundled == []
 
 
 def test_profile_create_ipython_dir():
     """ipython profile create respects --ipython-dir"""
     with TemporaryDirectory() as td:
         getoutput(
             [
                 sys.executable,
                 "-m",
                 "IPython",
                 "profile",
                 "create",
                 "foo",
                 "--ipython-dir=%s" % td,
             ]
         )
         profile_dir = Path(td) / "profile_foo"
         assert Path(profile_dir).exists()
         ipython_config = profile_dir / "ipython_config.py"
         assert Path(ipython_config).exists()
-        

IPython/core/tests/test_pylabtools.py

@@ -1,274 +1,273 b''
 """Tests for pylab tools module.
 """
 
 # Copyright (c) IPython Development Team.
 # Distributed under the terms of the Modified BSD License.
 
 
 from binascii import a2b_base64
 from io import BytesIO
 
 import matplotlib
 matplotlib.use('Agg')
 from matplotlib.figure import Figure
 
-from nose import SkipTest
-import nose.tools as nt
-
 from matplotlib import pyplot as plt
-import matplotlib_inline
+from matplotlib_inline import backend_inline
 import numpy as np
+import pytest
 
 from IPython.core.getipython import get_ipython
 from IPython.core.interactiveshell import InteractiveShell
 from IPython.core.display import _PNG, _JPEG
 from .. import pylabtools as pt
 
 from IPython.testing import decorators as dec
 
 
 def test_figure_to_svg():
     # simple empty-figure test
     fig = plt.figure()
-    nt.assert_equal(pt.print_figure(fig, 'svg'), None)
+    assert pt.print_figure(fig, "svg") is None
 
     plt.close('all')
 
     # simple check for at least svg-looking output
     fig = plt.figure()
     ax = fig.add_subplot(1,1,1)
     ax.plot([1,2,3])
     plt.draw()
-    svg = pt.print_figure(fig, 'svg')[:100].lower()
-    nt.assert_in(u'doctype svg', svg)
+    svg = pt.print_figure(fig, "svg")[:100].lower()
+    assert "doctype svg" in svg
+
 
 def _check_pil_jpeg_bytes():
     """Skip if PIL can't write JPEGs to BytesIO objects"""
     # PIL's JPEG plugin can't write to BytesIO objects
     # Pillow fixes this
     from PIL import Image
     buf = BytesIO()
     img = Image.new("RGB", (4,4))
     try:
         img.save(buf, 'jpeg')
     except Exception as e:
         ename = e.__class__.__name__
-        raise SkipTest("PIL can't write JPEG to BytesIO: %s: %s" % (ename, e)) from e
+        raise pytest.skip("PIL can't write JPEG to BytesIO: %s: %s" % (ename, e)) from e
 
 @dec.skip_without("PIL.Image")
 def test_figure_to_jpeg():
     _check_pil_jpeg_bytes()
     # simple check for at least jpeg-looking output
     fig = plt.figure()
     ax = fig.add_subplot(1,1,1)
     ax.plot([1,2,3])
     plt.draw()
     jpeg = pt.print_figure(fig, 'jpeg', pil_kwargs={'optimize': 50})[:100].lower()
     assert jpeg.startswith(_JPEG)
 
 def test_retina_figure():
     # simple empty-figure test
     fig = plt.figure()
-    nt.assert_equal(pt.retina_figure(fig), None)
+    assert pt.retina_figure(fig) == None
     plt.close('all')
 
     fig = plt.figure()
     ax = fig.add_subplot(1,1,1)
     ax.plot([1,2,3])
     plt.draw()
     png, md = pt.retina_figure(fig)
     assert png.startswith(_PNG)
-    nt.assert_in('width', md)
-    nt.assert_in('height', md)
+    assert "width" in md
+    assert "height" in md
+
 
 _fmt_mime_map = {
     'png': 'image/png',
     'jpeg': 'image/jpeg',
     'pdf': 'application/pdf',
     'retina': 'image/png',
     'svg': 'image/svg+xml',
 }
 
 def test_select_figure_formats_str():
     ip = get_ipython()
     for fmt, active_mime in _fmt_mime_map.items():
         pt.select_figure_formats(ip, fmt)
         for mime, f in ip.display_formatter.formatters.items():
             if mime == active_mime:
-                nt.assert_in(Figure, f)
+                assert Figure in f
             else:
-                nt.assert_not_in(Figure, f)
+                assert Figure not in f
 
 def test_select_figure_formats_kwargs():
     ip = get_ipython()
     kwargs = dict(quality=10, bbox_inches='tight')
     pt.select_figure_formats(ip, 'png', **kwargs)
     formatter = ip.display_formatter.formatters['image/png']
     f = formatter.lookup_by_type(Figure)
     cell = f.keywords
     expected = kwargs
     expected["base64"] = True
     expected["fmt"] = "png"
     assert cell == expected
 
     # check that the formatter doesn't raise
     fig = plt.figure()
     ax = fig.add_subplot(1,1,1)
     ax.plot([1,2,3])
     plt.draw()
     formatter.enabled = True
     png = formatter(fig)
     assert isinstance(png, str)
     png_bytes = a2b_base64(png)
     assert png_bytes.startswith(_PNG)
 
 def test_select_figure_formats_set():
     ip = get_ipython()
     for fmts in [
         {'png', 'svg'},
         ['png'],
         ('jpeg', 'pdf', 'retina'),
         {'svg'},
     ]:
         active_mimes = {_fmt_mime_map[fmt] for fmt in fmts}
         pt.select_figure_formats(ip, fmts)
         for mime, f in ip.display_formatter.formatters.items():
             if mime in active_mimes:
-                nt.assert_in(Figure, f)
+                assert Figure in f
             else:
-                nt.assert_not_in(Figure, f)
+                assert Figure not in f
 
 def test_select_figure_formats_bad():
     ip = get_ipython()
-    with nt.assert_raises(ValueError):
+    with pytest.raises(ValueError):
         pt.select_figure_formats(ip, 'foo')
-    with nt.assert_raises(ValueError):
+    with pytest.raises(ValueError):
         pt.select_figure_formats(ip, {'png', 'foo'})
-    with nt.assert_raises(ValueError):
+    with pytest.raises(ValueError):
         pt.select_figure_formats(ip, ['retina', 'pdf', 'bar', 'bad'])
 
 def test_import_pylab():
     ns = {}
     pt.import_pylab(ns, import_all=False)
-    nt.assert_true('plt' in ns)
-    nt.assert_equal(ns['np'], np)
+    assert "plt" in ns
+    assert ns["np"] == np
+
 
 from traitlets.config import Config
 
 
 class TestPylabSwitch(object):
     class Shell(InteractiveShell):
         def init_history(self):
             """Sets up the command history, and starts regular autosaves."""
             self.config.HistoryManager.hist_file = ":memory:"
             super().init_history()
 
         def enable_gui(self, gui):
             pass
 
     def setup(self):
         import matplotlib
         def act_mpl(backend):
             matplotlib.rcParams['backend'] = backend
 
         # Save rcParams since they get modified
         self._saved_rcParams = matplotlib.rcParams
         self._saved_rcParamsOrig = matplotlib.rcParamsOrig
         matplotlib.rcParams = dict(backend='Qt4Agg')
         matplotlib.rcParamsOrig = dict(backend='Qt4Agg')
 
         # Mock out functions
         self._save_am = pt.activate_matplotlib
         pt.activate_matplotlib = act_mpl
         self._save_ip = pt.import_pylab
         pt.import_pylab = lambda *a,**kw:None
-        self._save_cis = matplotlib_inline.backend_inline.configure_inline_support
-        matplotlib_inline.backend_inline.configure_inline_support = (
-            lambda *a, **kw: None
-        )
+        self._save_cis = backend_inline.configure_inline_support
+        backend_inline.configure_inline_support = lambda *a, **kw: None
 
     def teardown(self):
         pt.activate_matplotlib = self._save_am
         pt.import_pylab = self._save_ip
-        matplotlib_inline.backend_inline.configure_inline_support = self._save_cis
+        backend_inline.configure_inline_support = self._save_cis
         import matplotlib
         matplotlib.rcParams = self._saved_rcParams
         matplotlib.rcParamsOrig = self._saved_rcParamsOrig
 
     def test_qt(self):
 
         s = self.Shell()
         gui, backend = s.enable_matplotlib(None)
-        nt.assert_equal(gui, 'qt')
-        nt.assert_equal(s.pylab_gui_select, 'qt')
+        assert gui == "qt"
+        assert s.pylab_gui_select == "qt"
 
-        gui, backend = s.enable_matplotlib('inline')
-        nt.assert_equal(gui, 'inline')
-        nt.assert_equal(s.pylab_gui_select, 'qt')
+        gui, backend = s.enable_matplotlib("inline")
+        assert gui == "inline"
+        assert s.pylab_gui_select == "qt"
 
-        gui, backend = s.enable_matplotlib('qt')
-        nt.assert_equal(gui, 'qt')
-        nt.assert_equal(s.pylab_gui_select, 'qt')
+        gui, backend = s.enable_matplotlib("qt")
+        assert gui == "qt"
+        assert s.pylab_gui_select == "qt"
 
-        gui, backend = s.enable_matplotlib('inline')
-        nt.assert_equal(gui, 'inline')
-        nt.assert_equal(s.pylab_gui_select, 'qt')
+        gui, backend = s.enable_matplotlib("inline")
+        assert gui == "inline"
+        assert s.pylab_gui_select == "qt"
 
         gui, backend = s.enable_matplotlib()
-        nt.assert_equal(gui, 'qt')
-        nt.assert_equal(s.pylab_gui_select, 'qt')
+        assert gui == "qt"
+        assert s.pylab_gui_select == "qt"
 
     def test_inline(self):
         s = self.Shell()
-        gui, backend = s.enable_matplotlib('inline')
-        nt.assert_equal(gui, 'inline')
-        nt.assert_equal(s.pylab_gui_select, None)
+        gui, backend = s.enable_matplotlib("inline")
+        assert gui == "inline"
+        assert s.pylab_gui_select == None
 
-        gui, backend = s.enable_matplotlib('inline')
-        nt.assert_equal(gui, 'inline')
-        nt.assert_equal(s.pylab_gui_select, None)
+        gui, backend = s.enable_matplotlib("inline")
+        assert gui == "inline"
+        assert s.pylab_gui_select == None
 
-        gui, backend = s.enable_matplotlib('qt')
-        nt.assert_equal(gui, 'qt')
-        nt.assert_equal(s.pylab_gui_select, 'qt')
+        gui, backend = s.enable_matplotlib("qt")
+        assert gui == "qt"
+        assert s.pylab_gui_select == "qt"
 
     def test_inline_twice(self):
         "Using '%matplotlib inline' twice should not reset formatters"
 
         ip = self.Shell()
-        gui, backend = ip.enable_matplotlib('inline')
-        nt.assert_equal(gui, 'inline')
+        gui, backend = ip.enable_matplotlib("inline")
+        assert gui == "inline"
 
         fmts =  {'png'}
         active_mimes = {_fmt_mime_map[fmt] for fmt in fmts}
         pt.select_figure_formats(ip, fmts)
 
-        gui, backend = ip.enable_matplotlib('inline')
-        nt.assert_equal(gui, 'inline')
+        gui, backend = ip.enable_matplotlib("inline")
+        assert gui == "inline"
 
         for mime, f in ip.display_formatter.formatters.items():
             if mime in active_mimes:
-                nt.assert_in(Figure, f)
+                assert Figure in f
             else:
-                nt.assert_not_in(Figure, f)
+                assert Figure not in f
 
     def test_qt_gtk(self):
         s = self.Shell()
-        gui, backend = s.enable_matplotlib('qt')
-        nt.assert_equal(gui, 'qt')
-        nt.assert_equal(s.pylab_gui_select, 'qt')
+        gui, backend = s.enable_matplotlib("qt")
+        assert gui == "qt"
+        assert s.pylab_gui_select == "qt"
 
-        gui, backend = s.enable_matplotlib('gtk')
-        nt.assert_equal(gui, 'qt')
-        nt.assert_equal(s.pylab_gui_select, 'qt')
+        gui, backend = s.enable_matplotlib("gtk")
+        assert gui == "qt"
+        assert s.pylab_gui_select == "qt"
 
 
 def test_no_gui_backends():
     for k in ['agg', 'svg', 'pdf', 'ps']:
         assert k not in pt.backend2gui
 
 
 def test_figure_no_canvas():
     fig = Figure()
     fig.canvas = None
     pt.print_figure(fig)

IPython/core/tests/test_run.py

@@ -1,601 +1,599 b''
 # encoding: utf-8
 """Tests for code execution (%run and related), which is particularly tricky.
 
 Because of how %run manages namespaces, and the fact that we are trying here to
 verify subtle object deletion and reference counting issues, the %run tests
 will be kept in this separate file.  This makes it easier to aggregate in one
 place the tricks needed to handle it; most other magics are much easier to test
 and we do so in a common test_magic file.
 
 Note that any test using `run -i` should make sure to do a `reset` afterwards,
 as otherwise it may influence later tests.
 """
 
 # Copyright (c) IPython Development Team.
 # Distributed under the terms of the Modified BSD License.
 
 
 
 import functools
 import os
 from os.path import join as pjoin
 import random
 import string
 import sys
 import textwrap
 import unittest
 from unittest.mock import patch
 
-import nose.tools as nt
-from nose import SkipTest
+import pytest
 
 from IPython.testing import decorators as dec
 from IPython.testing import tools as tt
 from IPython.utils.io import capture_output
 from IPython.utils.tempdir import TemporaryDirectory
 from IPython.core import debugger
 
 def doctest_refbug():
     """Very nasty problem with references held by multiple runs of a script.
     See: https://github.com/ipython/ipython/issues/141
 
     In [1]: _ip.clear_main_mod_cache()
     # random
 
     In [2]: %run refbug
 
     In [3]: call_f()
     lowercased: hello
 
     In [4]: %run refbug
 
     In [5]: call_f()
     lowercased: hello
     lowercased: hello
     """
 
 
 def doctest_run_builtins():
     r"""Check that %run doesn't damage __builtins__.
 
     In [1]: import tempfile
 
     In [2]: bid1 = id(__builtins__)
 
     In [3]: fname = tempfile.mkstemp('.py')[1]
 
     In [3]: f = open(fname,'w')
 
     In [4]: dummy= f.write('pass\n')
 
     In [5]: f.flush()
 
     In [6]: t1 = type(__builtins__)
 
     In [7]: %run $fname
 
     In [7]: f.close()
 
     In [8]: bid2 = id(__builtins__)
 
     In [9]: t2 = type(__builtins__)
 
     In [10]: t1 == t2
     Out[10]: True
 
     In [10]: bid1 == bid2
     Out[10]: True
 
     In [12]: try:
        ....:     os.unlink(fname)
        ....: except:
        ....:     pass
        ....:
     """
 
 
 def doctest_run_option_parser():
     r"""Test option parser in %run.
 
     In [1]: %run print_argv.py
     []
 
     In [2]: %run print_argv.py print*.py
     ['print_argv.py']
 
     In [3]: %run -G print_argv.py print*.py
     ['print*.py']
 
     """
 
 
 @dec.skip_win32
 def doctest_run_option_parser_for_posix():
     r"""Test option parser in %run (Linux/OSX specific).
 
     You need double quote to escape glob in POSIX systems:
 
     In [1]: %run print_argv.py print\\*.py
     ['print*.py']
 
     You can't use quote to escape glob in POSIX systems:
 
     In [2]: %run print_argv.py 'print*.py'
     ['print_argv.py']
 
     """
 
 
 @dec.skip_if_not_win32
 def doctest_run_option_parser_for_windows():
     r"""Test option parser in %run (Windows specific).
 
     In Windows, you can't escape ``*` `by backslash:
 
     In [1]: %run print_argv.py print\\*.py
     ['print\\*.py']
 
     You can use quote to escape glob:
 
     In [2]: %run print_argv.py 'print*.py'
     ['print*.py']
 
     """
 
 
 def doctest_reset_del():
     """Test that resetting doesn't cause errors in __del__ methods.
 
     In [2]: class A(object):
        ...:     def __del__(self):
        ...:         print(str("Hi"))
        ...:
 
     In [3]: a = A()
 
     In [4]: get_ipython().reset()
     Hi
 
     In [5]: 1+1
     Out[5]: 2
     """
 
 # For some tests, it will be handy to organize them in a class with a common
 # setup that makes a temp file
 
 class TestMagicRunPass(tt.TempFileMixin):
 
     def setUp(self):
         content = "a = [1,2,3]\nb = 1"
         self.mktmp(content)
-        
+
     def run_tmpfile(self):
         _ip = get_ipython()
         # This fails on Windows if self.tmpfile.name has spaces or "~" in it.
         # See below and ticket https://bugs.launchpad.net/bugs/366353
         _ip.magic('run %s' % self.fname)
-        
+
     def run_tmpfile_p(self):
         _ip = get_ipython()
         # This fails on Windows if self.tmpfile.name has spaces or "~" in it.
         # See below and ticket https://bugs.launchpad.net/bugs/366353
         _ip.magic('run -p %s' % self.fname)
 
     def test_builtins_id(self):
         """Check that %run doesn't damage __builtins__ """
         _ip = get_ipython()
         # Test that the id of __builtins__ is not modified by %run
         bid1 = id(_ip.user_ns['__builtins__'])
         self.run_tmpfile()
         bid2 = id(_ip.user_ns['__builtins__'])
-        nt.assert_equal(bid1, bid2)
+        assert bid1 == bid2
 
     def test_builtins_type(self):
         """Check that the type of __builtins__ doesn't change with %run.
 
         However, the above could pass if __builtins__ was already modified to
         be a dict (it should be a module) by a previous use of %run.  So we
         also check explicitly that it really is a module:
         """
         _ip = get_ipython()
         self.run_tmpfile()
-        nt.assert_equal(type(_ip.user_ns['__builtins__']),type(sys))
-        
-    def test_run_profile( self ):
+        assert type(_ip.user_ns["__builtins__"]) == type(sys)
+
+    def test_run_profile(self):
         """Test that the option -p, which invokes the profiler, do not
         crash by invoking execfile"""
         self.run_tmpfile_p()
 
     def test_run_debug_twice(self):
         # https://github.com/ipython/ipython/issues/10028
         _ip = get_ipython()
         with tt.fake_input(['c']):
             _ip.magic('run -d %s' % self.fname)
         with tt.fake_input(['c']):
             _ip.magic('run -d %s' % self.fname)
 
     def test_run_debug_twice_with_breakpoint(self):
         """Make a valid python temp file."""
         _ip = get_ipython()
         with tt.fake_input(['b 2', 'c', 'c']):
             _ip.magic('run -d %s' % self.fname)
 
         with tt.fake_input(['c']):
             with tt.AssertNotPrints('KeyError'):
                 _ip.magic('run -d %s' % self.fname)
 
 
 class TestMagicRunSimple(tt.TempFileMixin):
 
     def test_simpledef(self):
         """Test that simple class definitions work."""
         src = ("class foo: pass\n"
                "def f(): return foo()")
         self.mktmp(src)
-        _ip.magic('run %s' % self.fname)
-        _ip.run_cell('t = isinstance(f(), foo)')
-        nt.assert_true(_ip.user_ns['t'])
+        _ip.magic("run %s" % self.fname)
+        _ip.run_cell("t = isinstance(f(), foo)")
+        assert _ip.user_ns["t"] is True
 
     def test_obj_del(self):
         """Test that object's __del__ methods are called on exit."""
         if sys.platform == 'win32':
             try:
                 import win32api
             except ImportError as e:
-                raise SkipTest("Test requires pywin32") from e
+                raise unittest.SkipTest("Test requires pywin32") from e
         src = ("class A(object):\n"
                "    def __del__(self):\n"
                "        print('object A deleted')\n"
                "a = A()\n")
         self.mktmp(src)
         err = None
         tt.ipexec_validate(self.fname, 'object A deleted', err)
-    
+
     def test_aggressive_namespace_cleanup(self):
         """Test that namespace cleanup is not too aggressive GH-238
 
         Returning from another run magic deletes the namespace"""
         # see ticket https://github.com/ipython/ipython/issues/238
-        
+
         with tt.TempFileMixin() as empty:
-            empty.mktmp('')
+            empty.mktmp("")
             # On Windows, the filename will have \users in it, so we need to use the
             # repr so that the \u becomes \\u.
-            src = ("ip = get_ipython()\n"
-                   "for i in range(5):\n"
-                   "   try:\n"
-                   "       ip.magic(%r)\n"
-                   "   except NameError as e:\n"
-                   "       print(i)\n"
-                   "       break\n" % ('run ' + empty.fname))
+            src = (
+                "ip = get_ipython()\n"
+                "for i in range(5):\n"
+                "   try:\n"
+                "       ip.magic(%r)\n"
+                "   except NameError as e:\n"
+                "       print(i)\n"
+                "       break\n" % ("run " + empty.fname)
+            )
             self.mktmp(src)
-            _ip.magic('run %s' % self.fname)
-            _ip.run_cell('ip == get_ipython()')
-            nt.assert_equal(_ip.user_ns['i'], 4)
-    
+            _ip.magic("run %s" % self.fname)
+            _ip.run_cell("ip == get_ipython()")
+            assert _ip.user_ns["i"] == 4
+
     def test_run_second(self):
-        """Test that running a second file doesn't clobber the first, gh-3547
-        """
-        self.mktmp("avar = 1\n"
-                   "def afunc():\n"
-                   "  return avar\n")
+        """Test that running a second file doesn't clobber the first, gh-3547"""
+        self.mktmp("avar = 1\n" "def afunc():\n" "  return avar\n")
 
         with tt.TempFileMixin() as empty:
             empty.mktmp("")
-            
-            _ip.magic('run %s' % self.fname)
-            _ip.magic('run %s' % empty.fname)
-            nt.assert_equal(_ip.user_ns['afunc'](), 1)
+
+            _ip.magic("run %s" % self.fname)
+            _ip.magic("run %s" % empty.fname)
+            assert _ip.user_ns["afunc"]() == 1
 
     @dec.skip_win32
     def test_tclass(self):
         mydir = os.path.dirname(__file__)
         tc = os.path.join(mydir, 'tclass')
         src = ("%%run '%s' C-first\n"
                "%%run '%s' C-second\n"
                "%%run '%s' C-third\n") % (tc, tc, tc)
         self.mktmp(src, '.ipy')
         out = """\
 ARGV 1-: ['C-first']
 ARGV 1-: ['C-second']
 tclass.py: deleting object: C-first
 ARGV 1-: ['C-third']
 tclass.py: deleting object: C-second
 tclass.py: deleting object: C-third
 """
         err = None
         tt.ipexec_validate(self.fname, out, err)
 
     def test_run_i_after_reset(self):
         """Check that %run -i still works after %reset (gh-693)"""
         src = "yy = zz\n"
         self.mktmp(src)
         _ip.run_cell("zz = 23")
         try:
-            _ip.magic('run -i %s' % self.fname)
-            nt.assert_equal(_ip.user_ns['yy'], 23)
+            _ip.magic("run -i %s" % self.fname)
+            assert _ip.user_ns["yy"] == 23
         finally:
             _ip.magic('reset -f')
-            
+
         _ip.run_cell("zz = 23")
         try:
-            _ip.magic('run -i %s' % self.fname)
-            nt.assert_equal(_ip.user_ns['yy'], 23)
+            _ip.magic("run -i %s" % self.fname)
+            assert _ip.user_ns["yy"] == 23
         finally:
             _ip.magic('reset -f')
-            
+
     def test_unicode(self):
         """Check that files in odd encodings are accepted."""
         mydir = os.path.dirname(__file__)
         na = os.path.join(mydir, 'nonascii.py')
         _ip.magic('run "%s"' % na)
-        nt.assert_equal(_ip.user_ns['u'], u'Ўт№Ф')
+        assert _ip.user_ns["u"] == "Ўт№Ф"
 
     def test_run_py_file_attribute(self):
         """Test handling of `__file__` attribute in `%run <file>.py`."""
         src = "t = __file__\n"
         self.mktmp(src)
         _missing = object()
         file1 = _ip.user_ns.get('__file__', _missing)
         _ip.magic('run %s' % self.fname)
         file2 = _ip.user_ns.get('__file__', _missing)
 
         # Check that __file__ was equal to the filename in the script's
         # namespace.
-        nt.assert_equal(_ip.user_ns['t'], self.fname)
+        assert _ip.user_ns["t"] == self.fname
 
         # Check that __file__ was not leaked back into user_ns.
-        nt.assert_equal(file1, file2)
+        assert file1 == file2
 
     def test_run_ipy_file_attribute(self):
         """Test handling of `__file__` attribute in `%run <file.ipy>`."""
         src = "t = __file__\n"
         self.mktmp(src, ext='.ipy')
         _missing = object()
         file1 = _ip.user_ns.get('__file__', _missing)
         _ip.magic('run %s' % self.fname)
         file2 = _ip.user_ns.get('__file__', _missing)
 
         # Check that __file__ was equal to the filename in the script's
         # namespace.
-        nt.assert_equal(_ip.user_ns['t'], self.fname)
+        assert _ip.user_ns["t"] == self.fname
 
         # Check that __file__ was not leaked back into user_ns.
-        nt.assert_equal(file1, file2)
+        assert file1 == file2
 
     def test_run_formatting(self):
         """ Test that %run -t -N<N> does not raise a TypeError for N > 1."""
         src = "pass"
         self.mktmp(src)
         _ip.magic('run -t -N 1 %s' % self.fname)
         _ip.magic('run -t -N 10 %s' % self.fname)
-    
+
     def test_ignore_sys_exit(self):
         """Test the -e option to ignore sys.exit()"""
         src = "import sys; sys.exit(1)"
         self.mktmp(src)
         with tt.AssertPrints('SystemExit'):
             _ip.magic('run %s' % self.fname)
-        
+
         with tt.AssertNotPrints('SystemExit'):
             _ip.magic('run -e %s' % self.fname)
 
     def test_run_nb(self):
         """Test %run notebook.ipynb"""
         from nbformat import v4, writes
         nb = v4.new_notebook(
            cells=[
                 v4.new_markdown_cell("The Ultimate Question of Everything"),
                 v4.new_code_cell("answer=42")
             ]
         )
         src = writes(nb, version=4)
         self.mktmp(src, ext='.ipynb')
-        
+
         _ip.magic("run %s" % self.fname)
-        
-        nt.assert_equal(_ip.user_ns['answer'], 42)
+
+        assert _ip.user_ns["answer"] == 42
 
     def test_run_nb_error(self):
         """Test %run notebook.ipynb error"""
         from nbformat import v4, writes
         # %run when a file name isn't provided
-        nt.assert_raises(Exception, _ip.magic, "run")
+        pytest.raises(Exception, _ip.magic, "run")
 
         # %run when a file doesn't exist
-        nt.assert_raises(Exception, _ip.magic, "run foobar.ipynb")
+        pytest.raises(Exception, _ip.magic, "run foobar.ipynb")
 
         # %run on a notebook with an error
         nb = v4.new_notebook(
            cells=[
                 v4.new_code_cell("0/0")
             ]
         )
         src = writes(nb, version=4)
         self.mktmp(src, ext='.ipynb')
-        nt.assert_raises(Exception, _ip.magic, "run %s" % self.fname)
+        pytest.raises(Exception, _ip.magic, "run %s" % self.fname)
 
     def test_file_options(self):
         src = ('import sys\n'
                'a = " ".join(sys.argv[1:])\n')
         self.mktmp(src)
-        test_opts = '-x 3 --verbose'
-        _ip.run_line_magic("run", '{0} {1}'.format(self.fname, test_opts))
-        nt.assert_equal(_ip.user_ns['a'], test_opts)
+        test_opts = "-x 3 --verbose"
+        _ip.run_line_magic("run", "{0} {1}".format(self.fname, test_opts))
+        assert _ip.user_ns["a"] == test_opts
 
 
 class TestMagicRunWithPackage(unittest.TestCase):
 
     def writefile(self, name, content):
         path = os.path.join(self.tempdir.name, name)
         d = os.path.dirname(path)
         if not os.path.isdir(d):
             os.makedirs(d)
         with open(path, 'w') as f:
             f.write(textwrap.dedent(content))
 
     def setUp(self):
         self.package = package = 'tmp{0}'.format(''.join([random.choice(string.ascii_letters) for i in range(10)]))
         """Temporary  (probably) valid python package name."""
 
         self.value = int(random.random() * 10000)
 
         self.tempdir = TemporaryDirectory()
         self.__orig_cwd = os.getcwd()
         sys.path.insert(0, self.tempdir.name)
 
         self.writefile(os.path.join(package, '__init__.py'), '')
         self.writefile(os.path.join(package, 'sub.py'), """
         x = {0!r}
         """.format(self.value))
         self.writefile(os.path.join(package, 'relative.py'), """
         from .sub import x
         """)
         self.writefile(os.path.join(package, 'absolute.py'), """
         from {0}.sub import x
         """.format(package))
         self.writefile(os.path.join(package, 'args.py'), """
         import sys
         a = " ".join(sys.argv[1:])
         """.format(package))
 
     def tearDown(self):
         os.chdir(self.__orig_cwd)
         sys.path[:] = [p for p in sys.path if p != self.tempdir.name]
         self.tempdir.cleanup()
 
     def check_run_submodule(self, submodule, opts=''):
         _ip.user_ns.pop('x', None)
         _ip.magic('run {2} -m {0}.{1}'.format(self.package, submodule, opts))
         self.assertEqual(_ip.user_ns['x'], self.value,
                          'Variable `x` is not loaded from module `{0}`.'
                          .format(submodule))
 
     def test_run_submodule_with_absolute_import(self):
         self.check_run_submodule('absolute')
 
     def test_run_submodule_with_relative_import(self):
         """Run submodule that has a relative import statement (#2727)."""
         self.check_run_submodule('relative')
 
     def test_prun_submodule_with_absolute_import(self):
         self.check_run_submodule('absolute', '-p')
 
     def test_prun_submodule_with_relative_import(self):
         self.check_run_submodule('relative', '-p')
 
     def with_fake_debugger(func):
         @functools.wraps(func)
         def wrapper(*args, **kwds):
             with patch.object(debugger.Pdb, 'run', staticmethod(eval)):
                 return func(*args, **kwds)
         return wrapper
 
     @with_fake_debugger
     def test_debug_run_submodule_with_absolute_import(self):
         self.check_run_submodule('absolute', '-d')
 
     @with_fake_debugger
     def test_debug_run_submodule_with_relative_import(self):
         self.check_run_submodule('relative', '-d')
 
     def test_module_options(self):
-        _ip.user_ns.pop('a', None)
-        test_opts = '-x abc -m test'
-        _ip.run_line_magic('run', '-m {0}.args {1}'.format(self.package, test_opts))
-        nt.assert_equal(_ip.user_ns['a'], test_opts)
+        _ip.user_ns.pop("a", None)
+        test_opts = "-x abc -m test"
+        _ip.run_line_magic("run", "-m {0}.args {1}".format(self.package, test_opts))
+        assert _ip.user_ns["a"] == test_opts
 
     def test_module_options_with_separator(self):
-        _ip.user_ns.pop('a', None)
-        test_opts = '-x abc -m test'
-        _ip.run_line_magic('run', '-m {0}.args -- {1}'.format(self.package, test_opts))
-        nt.assert_equal(_ip.user_ns['a'], test_opts)
+        _ip.user_ns.pop("a", None)
+        test_opts = "-x abc -m test"
+        _ip.run_line_magic("run", "-m {0}.args -- {1}".format(self.package, test_opts))
+        assert _ip.user_ns["a"] == test_opts
+
 
 def test_run__name__():
     with TemporaryDirectory() as td:
         path = pjoin(td, 'foo.py')
         with open(path, 'w') as f:
             f.write("q = __name__")
-        
-        _ip.user_ns.pop('q', None)
-        _ip.magic('run {}'.format(path))
-        nt.assert_equal(_ip.user_ns.pop('q'), '__main__')
-        
-        _ip.magic('run -n {}'.format(path))
-        nt.assert_equal(_ip.user_ns.pop('q'), 'foo')
+
+        _ip.user_ns.pop("q", None)
+        _ip.magic("run {}".format(path))
+        assert _ip.user_ns.pop("q") == "__main__"
+
+        _ip.magic("run -n {}".format(path))
+        assert _ip.user_ns.pop("q") == "foo"
 
         try:
-            _ip.magic('run -i -n {}'.format(path))
-            nt.assert_equal(_ip.user_ns.pop('q'), 'foo')
+            _ip.magic("run -i -n {}".format(path))
+            assert _ip.user_ns.pop("q") == "foo"
         finally:
             _ip.magic('reset -f')
 
 
 def test_run_tb():
     """Test traceback offset in %run"""
     with TemporaryDirectory() as td:
         path = pjoin(td, 'foo.py')
         with open(path, 'w') as f:
             f.write('\n'.join([
                 "def foo():",
                 "    return bar()",
                 "def bar():",
                 "    raise RuntimeError('hello!')",
                 "foo()",
             ]))
         with capture_output() as io:
             _ip.magic('run {}'.format(path))
         out = io.stdout
-        nt.assert_not_in("execfile", out)
-        nt.assert_in("RuntimeError", out)
-        nt.assert_equal(out.count("---->"), 3)
+        assert "execfile" not in out
+        assert "RuntimeError" in out
+        assert out.count("---->") == 3
         del ip.user_ns['bar']
         del ip.user_ns['foo']
 
 
 def test_multiprocessing_run():
     """Set we can run mutiprocesgin without messing up up main namespace
 
     Note that import `nose.tools as nt` mdify the value s
     sys.module['__mp_main__'] so we need to temporarily set it to None to test
     the issue.
     """
     with TemporaryDirectory() as td:
         mpm = sys.modules.get('__mp_main__')
         assert mpm is not None
         sys.modules['__mp_main__'] = None
         try:
             path = pjoin(td, 'test.py')
             with open(path, 'w') as f:
                 f.write("import multiprocessing\nprint('hoy')")
             with capture_output() as io:
                 _ip.run_line_magic('run', path)
                 _ip.run_cell("i_m_undefined")
             out = io.stdout
-            nt.assert_in("hoy", out)
-            nt.assert_not_in("AttributeError", out)
-            nt.assert_in("NameError", out)
-            nt.assert_equal(out.count("---->"), 1)
+            assert "hoy" in out
+            assert "AttributeError" not in out
+            assert "NameError" in out
+            assert out.count("---->") == 1
         except:
             raise
         finally:
             sys.modules['__mp_main__'] = mpm
 
 @dec.knownfailureif(sys.platform == 'win32', "writes to io.stdout aren't captured on Windows")
 def test_script_tb():
     """Test traceback offset in `ipython script.py`"""
     with TemporaryDirectory() as td:
         path = pjoin(td, 'foo.py')
         with open(path, 'w') as f:
             f.write('\n'.join([
                 "def foo():",
                 "    return bar()",
                 "def bar():",
                 "    raise RuntimeError('hello!')",
                 "foo()",
             ]))
         out, err = tt.ipexec(path)
-        nt.assert_not_in("execfile", out)
-        nt.assert_in("RuntimeError", out)
-        nt.assert_equal(out.count("---->"), 3)
-
+        assert "execfile" not in out
+        assert "RuntimeError" in out
+        assert out.count("---->") == 3

IPython/core/tests/test_splitinput.py

@@ -1,38 +1,38 b''
 # coding: utf-8
-import nose.tools as nt
 
 from IPython.core.splitinput import split_user_input, LineInfo
 from IPython.testing import tools as tt
 
 tests = [
-    ('x=1', ('', '', 'x', '=1')),
-    ('?', ('', '?', '', '')),
-    ('??', ('', '??', '', '')),
-    (' ?', (' ', '?', '', '')),
-    (' ??', (' ', '??', '', '')),
-    ('??x', ('', '??', 'x', '')),
-    ('?x=1', ('', '?', 'x', '=1')),
-    ('!ls', ('', '!', 'ls', '')),
-    ('  !ls', ('  ', '!', 'ls', '')),
-    ('!!ls', ('', '!!', 'ls', '')),
-    ('  !!ls', ('  ', '!!', 'ls', '')),
-    (',ls', ('', ',', 'ls', '')),
-    (';ls', ('', ';', 'ls', '')),
-    ('  ;ls', ('  ', ';', 'ls', '')),
-    ('f.g(x)',  ('', '', 'f.g', '(x)')),
-    ('f.g (x)', ('', '', 'f.g', '(x)')),
-    ('?%hist1', ('', '?', '%hist1', '')),
-    ('?%%hist2', ('', '?', '%%hist2', '')),
-    ('??%hist3', ('', '??', '%hist3', '')),
-    ('??%%hist4', ('', '??', '%%hist4', '')),
-    ('?x*', ('', '?', 'x*', '')),
-    ]
-tests.append((u"Pérez Fernando", (u'', u'', u'Pérez', u'Fernando')))
+    ("x=1", ("", "", "x", "=1")),
+    ("?", ("", "?", "", "")),
+    ("??", ("", "??", "", "")),
+    (" ?", (" ", "?", "", "")),
+    (" ??", (" ", "??", "", "")),
+    ("??x", ("", "??", "x", "")),
+    ("?x=1", ("", "?", "x", "=1")),
+    ("!ls", ("", "!", "ls", "")),
+    ("  !ls", ("  ", "!", "ls", "")),
+    ("!!ls", ("", "!!", "ls", "")),
+    ("  !!ls", ("  ", "!!", "ls", "")),
+    (",ls", ("", ",", "ls", "")),
+    (";ls", ("", ";", "ls", "")),
+    ("  ;ls", ("  ", ";", "ls", "")),
+    ("f.g(x)", ("", "", "f.g", "(x)")),
+    ("f.g (x)", ("", "", "f.g", "(x)")),
+    ("?%hist1", ("", "?", "%hist1", "")),
+    ("?%%hist2", ("", "?", "%%hist2", "")),
+    ("??%hist3", ("", "??", "%hist3", "")),
+    ("??%%hist4", ("", "??", "%%hist4", "")),
+    ("?x*", ("", "?", "x*", "")),
+]
+tests.append(("Pérez Fernando", ("", "", "Pérez", "Fernando")))
+
 
 def test_split_user_input():
     return tt.check_pairs(split_user_input, tests)
 
 def test_LineInfo():
     """Simple test for LineInfo construction and str()"""
-    linfo = LineInfo('  %cd /home')
-    nt.assert_equal(str(linfo), 'LineInfo [  |%|cd|/home]')
+    linfo = LineInfo("  %cd /home")
+    assert str(linfo) == "LineInfo [  |%|cd|/home]"

IPython/extensions/tests/test_autoreload.py

@@ -1,555 +1,554 b''
 """Tests for autoreload extension.
 """
 # -----------------------------------------------------------------------------
 #  Copyright (c) 2012 IPython Development Team.
 #
 #  Distributed under the terms of the Modified BSD License.
 #
 #  The full license is in the file COPYING.txt, distributed with this software.
 # -----------------------------------------------------------------------------
 
 # -----------------------------------------------------------------------------
 # Imports
 # -----------------------------------------------------------------------------
 
 import os
 import sys
 import tempfile
 import textwrap
 import shutil
 import random
 import time
 from io import StringIO
 
-import nose.tools as nt
 import IPython.testing.tools as tt
 
 from unittest import TestCase
 
 from IPython.extensions.autoreload import AutoreloadMagics
 from IPython.core.events import EventManager, pre_run_cell
 
 # -----------------------------------------------------------------------------
 # Test fixture
 # -----------------------------------------------------------------------------
 
 noop = lambda *a, **kw: None
 
 
 class FakeShell:
     def __init__(self):
         self.ns = {}
         self.user_ns = self.ns
         self.user_ns_hidden = {}
         self.events = EventManager(self, {"pre_run_cell", pre_run_cell})
         self.auto_magics = AutoreloadMagics(shell=self)
         self.events.register("pre_run_cell", self.auto_magics.pre_run_cell)
 
     register_magics = set_hook = noop
 
     def run_code(self, code):
         self.events.trigger("pre_run_cell")
         exec(code, self.user_ns)
         self.auto_magics.post_execute_hook()
 
     def push(self, items):
         self.ns.update(items)
 
     def magic_autoreload(self, parameter):
         self.auto_magics.autoreload(parameter)
 
     def magic_aimport(self, parameter, stream=None):
         self.auto_magics.aimport(parameter, stream=stream)
         self.auto_magics.post_execute_hook()
 
 
 class Fixture(TestCase):
     """Fixture for creating test module files"""
 
     test_dir = None
     old_sys_path = None
     filename_chars = "abcdefghijklmopqrstuvwxyz0123456789"
 
     def setUp(self):
         self.test_dir = tempfile.mkdtemp()
         self.old_sys_path = list(sys.path)
         sys.path.insert(0, self.test_dir)
         self.shell = FakeShell()
 
     def tearDown(self):
         shutil.rmtree(self.test_dir)
         sys.path = self.old_sys_path
 
         self.test_dir = None
         self.old_sys_path = None
         self.shell = None
 
     def get_module(self):
         module_name = "tmpmod_" + "".join(random.sample(self.filename_chars, 20))
         if module_name in sys.modules:
             del sys.modules[module_name]
         file_name = os.path.join(self.test_dir, module_name + ".py")
         return module_name, file_name
 
     def write_file(self, filename, content):
         """
         Write a file, and force a timestamp difference of at least one second
 
         Notes
         -----
         Python's .pyc files record the timestamp of their compilation
         with a time resolution of one second.
 
         Therefore, we need to force a timestamp difference between .py
         and .pyc, without having the .py file be timestamped in the
         future, and without changing the timestamp of the .pyc file
         (because that is stored in the file).  The only reliable way
         to achieve this seems to be to sleep.
         """
         content = textwrap.dedent(content)
         # Sleep one second + eps
         time.sleep(1.05)
 
         # Write
         with open(filename, "w") as f:
             f.write(content)
 
     def new_module(self, code):
         code = textwrap.dedent(code)
         mod_name, mod_fn = self.get_module()
         with open(mod_fn, "w") as f:
             f.write(code)
         return mod_name, mod_fn
 
 
 # -----------------------------------------------------------------------------
 # Test automatic reloading
 # -----------------------------------------------------------------------------
 
 
 def pickle_get_current_class(obj):
     """
     Original issue comes from pickle; hence the name.
     """
     name = obj.__class__.__name__
     module_name = getattr(obj, "__module__", None)
     obj2 = sys.modules[module_name]
     for subpath in name.split("."):
         obj2 = getattr(obj2, subpath)
     return obj2
 
 
 class TestAutoreload(Fixture):
     def test_reload_enums(self):
         mod_name, mod_fn = self.new_module(
             textwrap.dedent(
                 """
                                 from enum import Enum
                                 class MyEnum(Enum):
                                     A = 'A'
                                     B = 'B'
                             """
             )
         )
         self.shell.magic_autoreload("2")
         self.shell.magic_aimport(mod_name)
         self.write_file(
             mod_fn,
             textwrap.dedent(
                 """
                                 from enum import Enum
                                 class MyEnum(Enum):
                                     A = 'A'
                                     B = 'B'
                                     C = 'C'
                             """
             ),
         )
         with tt.AssertNotPrints(
             ("[autoreload of %s failed:" % mod_name), channel="stderr"
         ):
             self.shell.run_code("pass")  # trigger another reload
 
     def test_reload_class_type(self):
         self.shell.magic_autoreload("2")
         mod_name, mod_fn = self.new_module(
             """
             class Test():
                 def meth(self):
                     return "old"
         """
         )
         assert "test" not in self.shell.ns
         assert "result" not in self.shell.ns
 
         self.shell.run_code("from %s import Test" % mod_name)
         self.shell.run_code("test = Test()")
 
         self.write_file(
             mod_fn,
             """
             class Test():
                 def meth(self):
                     return "new"
         """,
         )
 
         test_object = self.shell.ns["test"]
 
         # important to trigger autoreload logic !
         self.shell.run_code("pass")
 
         test_class = pickle_get_current_class(test_object)
         assert isinstance(test_object, test_class)
 
         # extra check.
         self.shell.run_code("import pickle")
         self.shell.run_code("p = pickle.dumps(test)")
 
     def test_reload_class_attributes(self):
         self.shell.magic_autoreload("2")
         mod_name, mod_fn = self.new_module(
             textwrap.dedent(
                 """
                                 class MyClass:
 
                                     def __init__(self, a=10):
                                         self.a = a
                                         self.b = 22 
                                         # self.toto = 33
 
                                     def square(self):
                                         print('compute square')
                                         return self.a*self.a
                             """
             )
         )
         self.shell.run_code("from %s import MyClass" % mod_name)
         self.shell.run_code("first = MyClass(5)")
         self.shell.run_code("first.square()")
-        with nt.assert_raises(AttributeError):
+        with self.assertRaises(AttributeError):
             self.shell.run_code("first.cube()")
-        with nt.assert_raises(AttributeError):
+        with self.assertRaises(AttributeError):
             self.shell.run_code("first.power(5)")
         self.shell.run_code("first.b")
-        with nt.assert_raises(AttributeError):
+        with self.assertRaises(AttributeError):
             self.shell.run_code("first.toto")
 
         # remove square, add power
 
         self.write_file(
             mod_fn,
             textwrap.dedent(
                 """
                             class MyClass:
 
                                 def __init__(self, a=10):
                                     self.a = a
                                     self.b = 11
 
                                 def power(self, p):
                                     print('compute power '+str(p))
                                     return self.a**p
                             """
             ),
         )
 
         self.shell.run_code("second = MyClass(5)")
 
         for object_name in {"first", "second"}:
             self.shell.run_code(f"{object_name}.power(5)")
-            with nt.assert_raises(AttributeError):
+            with self.assertRaises(AttributeError):
                 self.shell.run_code(f"{object_name}.cube()")
-            with nt.assert_raises(AttributeError):
+            with self.assertRaises(AttributeError):
                 self.shell.run_code(f"{object_name}.square()")
             self.shell.run_code(f"{object_name}.b")
             self.shell.run_code(f"{object_name}.a")
-            with nt.assert_raises(AttributeError):
+            with self.assertRaises(AttributeError):
                 self.shell.run_code(f"{object_name}.toto")
 
     def test_autoload_newly_added_objects(self):
         self.shell.magic_autoreload("3")
         mod_code = """
         def func1(): pass
         """
         mod_name, mod_fn = self.new_module(textwrap.dedent(mod_code))
         self.shell.run_code(f"from {mod_name} import *")
         self.shell.run_code("func1()")
-        with nt.assert_raises(NameError):
+        with self.assertRaises(NameError):
             self.shell.run_code("func2()")
-        with nt.assert_raises(NameError):
+        with self.assertRaises(NameError):
             self.shell.run_code("t = Test()")
-        with nt.assert_raises(NameError):
+        with self.assertRaises(NameError):
             self.shell.run_code("number")
 
         # ----------- TEST NEW OBJ LOADED --------------------------
 
         new_code = """
         def func1(): pass
         def func2(): pass
         class Test: pass
         number = 0
         from enum import Enum
         class TestEnum(Enum):
             A = 'a'
         """
         self.write_file(mod_fn, textwrap.dedent(new_code))
 
         # test function now exists in shell's namespace namespace
         self.shell.run_code("func2()")
         # test function now exists in module's dict
         self.shell.run_code(f"import sys; sys.modules['{mod_name}'].func2()")
         # test class now exists
         self.shell.run_code("t = Test()")
         # test global built-in var now exists
         self.shell.run_code("number")
         # test the enumerations gets loaded successfully
         self.shell.run_code("TestEnum.A")
 
         # ----------- TEST NEW OBJ CAN BE CHANGED --------------------
 
         new_code = """
         def func1(): return 'changed'
         def func2(): return 'changed'
         class Test:
             def new_func(self):
                 return 'changed'
         number = 1
         from enum import Enum
         class TestEnum(Enum):
             A = 'a'
             B = 'added'
         """
         self.write_file(mod_fn, textwrap.dedent(new_code))
         self.shell.run_code("assert func1() == 'changed'")
         self.shell.run_code("assert func2() == 'changed'")
         self.shell.run_code("t = Test(); assert t.new_func() == 'changed'")
         self.shell.run_code("assert number == 1")
         self.shell.run_code("assert TestEnum.B.value == 'added'")
 
         # ----------- TEST IMPORT FROM MODULE --------------------------
 
         new_mod_code = """
         from enum import Enum
         class Ext(Enum):
             A = 'ext'
         def ext_func():
             return 'ext'
         class ExtTest:
             def meth(self):
                 return 'ext'
         ext_int = 2
         """
         new_mod_name, new_mod_fn = self.new_module(textwrap.dedent(new_mod_code))
         current_mod_code = f"""
         from {new_mod_name} import *
         """
         self.write_file(mod_fn, textwrap.dedent(current_mod_code))
         self.shell.run_code("assert Ext.A.value == 'ext'")
         self.shell.run_code("assert ext_func() == 'ext'")
         self.shell.run_code("t = ExtTest(); assert t.meth() == 'ext'")
         self.shell.run_code("assert ext_int == 2")
 
     def _check_smoketest(self, use_aimport=True):
         """
         Functional test for the automatic reloader using either
         '%autoreload 1' or '%autoreload 2'
         """
 
         mod_name, mod_fn = self.new_module(
             """
 x = 9
 
 z = 123  # this item will be deleted
 
 def foo(y):
     return y + 3
 
 class Baz(object):
     def __init__(self, x):
         self.x = x
     def bar(self, y):
         return self.x + y
     @property
     def quux(self):
         return 42
     def zzz(self):
         '''This method will be deleted below'''
         return 99
 
 class Bar:    # old-style class: weakref doesn't work for it on Python < 2.7
     def foo(self):
         return 1
 """
         )
 
         #
         # Import module, and mark for reloading
         #
         if use_aimport:
             self.shell.magic_autoreload("1")
             self.shell.magic_aimport(mod_name)
             stream = StringIO()
             self.shell.magic_aimport("", stream=stream)
-            nt.assert_in(("Modules to reload:\n%s" % mod_name), stream.getvalue())
+            self.assertIn(("Modules to reload:\n%s" % mod_name), stream.getvalue())
 
-            with nt.assert_raises(ImportError):
+            with self.assertRaises(ImportError):
                 self.shell.magic_aimport("tmpmod_as318989e89ds")
         else:
             self.shell.magic_autoreload("2")
             self.shell.run_code("import %s" % mod_name)
             stream = StringIO()
             self.shell.magic_aimport("", stream=stream)
-            nt.assert_true(
+            self.assertTrue(
                 "Modules to reload:\nall-except-skipped" in stream.getvalue()
             )
-        nt.assert_in(mod_name, self.shell.ns)
+        self.assertIn(mod_name, self.shell.ns)
 
         mod = sys.modules[mod_name]
 
         #
         # Test module contents
         #
         old_foo = mod.foo
         old_obj = mod.Baz(9)
         old_obj2 = mod.Bar()
 
         def check_module_contents():
-            nt.assert_equal(mod.x, 9)
-            nt.assert_equal(mod.z, 123)
+            self.assertEqual(mod.x, 9)
+            self.assertEqual(mod.z, 123)
 
-            nt.assert_equal(old_foo(0), 3)
-            nt.assert_equal(mod.foo(0), 3)
+            self.assertEqual(old_foo(0), 3)
+            self.assertEqual(mod.foo(0), 3)
 
             obj = mod.Baz(9)
-            nt.assert_equal(old_obj.bar(1), 10)
-            nt.assert_equal(obj.bar(1), 10)
-            nt.assert_equal(obj.quux, 42)
-            nt.assert_equal(obj.zzz(), 99)
+            self.assertEqual(old_obj.bar(1), 10)
+            self.assertEqual(obj.bar(1), 10)
+            self.assertEqual(obj.quux, 42)
+            self.assertEqual(obj.zzz(), 99)
 
             obj2 = mod.Bar()
-            nt.assert_equal(old_obj2.foo(), 1)
-            nt.assert_equal(obj2.foo(), 1)
+            self.assertEqual(old_obj2.foo(), 1)
+            self.assertEqual(obj2.foo(), 1)
 
         check_module_contents()
 
         #
         # Simulate a failed reload: no reload should occur and exactly
         # one error message should be printed
         #
         self.write_file(
             mod_fn,
             """
 a syntax error
 """,
         )
 
         with tt.AssertPrints(
             ("[autoreload of %s failed:" % mod_name), channel="stderr"
         ):
             self.shell.run_code("pass")  # trigger reload
         with tt.AssertNotPrints(
             ("[autoreload of %s failed:" % mod_name), channel="stderr"
         ):
             self.shell.run_code("pass")  # trigger another reload
         check_module_contents()
 
         #
         # Rewrite module (this time reload should succeed)
         #
         self.write_file(
             mod_fn,
             """
 x = 10
 
 def foo(y):
     return y + 4
 
 class Baz(object):
     def __init__(self, x):
         self.x = x
     def bar(self, y):
         return self.x + y + 1
     @property
     def quux(self):
         return 43
 
 class Bar:    # old-style class
     def foo(self):
         return 2
 """,
         )
 
         def check_module_contents():
-            nt.assert_equal(mod.x, 10)
-            nt.assert_false(hasattr(mod, "z"))
+            self.assertEqual(mod.x, 10)
+            self.assertFalse(hasattr(mod, "z"))
 
-            nt.assert_equal(old_foo(0), 4)  # superreload magic!
-            nt.assert_equal(mod.foo(0), 4)
+            self.assertEqual(old_foo(0), 4)  # superreload magic!
+            self.assertEqual(mod.foo(0), 4)
 
             obj = mod.Baz(9)
-            nt.assert_equal(old_obj.bar(1), 11)  # superreload magic!
-            nt.assert_equal(obj.bar(1), 11)
+            self.assertEqual(old_obj.bar(1), 11)  # superreload magic!
+            self.assertEqual(obj.bar(1), 11)
 
-            nt.assert_equal(old_obj.quux, 43)
-            nt.assert_equal(obj.quux, 43)
+            self.assertEqual(old_obj.quux, 43)
+            self.assertEqual(obj.quux, 43)
 
-            nt.assert_false(hasattr(old_obj, "zzz"))
-            nt.assert_false(hasattr(obj, "zzz"))
+            self.assertFalse(hasattr(old_obj, "zzz"))
+            self.assertFalse(hasattr(obj, "zzz"))
 
             obj2 = mod.Bar()
-            nt.assert_equal(old_obj2.foo(), 2)
-            nt.assert_equal(obj2.foo(), 2)
+            self.assertEqual(old_obj2.foo(), 2)
+            self.assertEqual(obj2.foo(), 2)
 
         self.shell.run_code("pass")  # trigger reload
         check_module_contents()
 
         #
         # Another failure case: deleted file (shouldn't reload)
         #
         os.unlink(mod_fn)
 
         self.shell.run_code("pass")  # trigger reload
         check_module_contents()
 
         #
         # Disable autoreload and rewrite module: no reload should occur
         #
         if use_aimport:
             self.shell.magic_aimport("-" + mod_name)
             stream = StringIO()
             self.shell.magic_aimport("", stream=stream)
-            nt.assert_true(("Modules to skip:\n%s" % mod_name) in stream.getvalue())
+            self.assertTrue(("Modules to skip:\n%s" % mod_name) in stream.getvalue())
 
             # This should succeed, although no such module exists
             self.shell.magic_aimport("-tmpmod_as318989e89ds")
         else:
             self.shell.magic_autoreload("0")
 
         self.write_file(
             mod_fn,
             """
 x = -99
 """,
         )
 
         self.shell.run_code("pass")  # trigger reload
         self.shell.run_code("pass")
         check_module_contents()
 
         #
         # Re-enable autoreload: reload should now occur
         #
         if use_aimport:
             self.shell.magic_aimport(mod_name)
         else:
             self.shell.magic_autoreload("")
 
         self.shell.run_code("pass")  # trigger reload
-        nt.assert_equal(mod.x, -99)
+        self.assertEqual(mod.x, -99)
 
     def test_smoketest_aimport(self):
         self._check_smoketest(use_aimport=True)
 
     def test_smoketest_autoreload(self):
         self._check_smoketest(use_aimport=False)

IPython/extensions/tests/test_storemagic.py

@@ -1,66 +1,65 b''
 import tempfile, os
 
 from traitlets.config.loader import Config
-import nose.tools as nt
 
 
 def setup_module():
     ip.magic('load_ext storemagic')
 
 def test_store_restore():
     assert 'bar' not in ip.user_ns, "Error: some other test leaked `bar` in user_ns"
     assert 'foo' not in ip.user_ns, "Error: some other test leaked `foo` in user_ns"
     assert 'foobar' not in ip.user_ns, "Error: some other test leaked `foobar` in user_ns"
     assert 'foobaz' not in ip.user_ns, "Error: some other test leaked `foobaz` in user_ns"
     ip.user_ns['foo'] = 78
     ip.magic('alias bar echo "hello"')
     ip.user_ns['foobar'] = 79
     ip.user_ns['foobaz'] = '80'
     tmpd = tempfile.mkdtemp()
     ip.magic('cd ' + tmpd)
     ip.magic('store foo')
     ip.magic('store bar')
     ip.magic('store foobar foobaz')
 
     # Check storing
-    nt.assert_equal(ip.db['autorestore/foo'], 78)
-    nt.assert_in('bar', ip.db['stored_aliases'])
-    nt.assert_equal(ip.db['autorestore/foobar'], 79)
-    nt.assert_equal(ip.db['autorestore/foobaz'], '80')
+    assert ip.db["autorestore/foo"] == 78
+    assert "bar" in ip.db["stored_aliases"]
+    assert ip.db["autorestore/foobar"] == 79
+    assert ip.db["autorestore/foobaz"] == "80"
 
     # Remove those items
     ip.user_ns.pop('foo', None)
     ip.user_ns.pop('foobar', None)
     ip.user_ns.pop('foobaz', None)
     ip.alias_manager.undefine_alias('bar')
     ip.magic('cd -')
     ip.user_ns['_dh'][:] = []
 
     # Check restoring
-    ip.magic('store -r foo bar foobar foobaz')
-    nt.assert_equal(ip.user_ns['foo'], 78)
-    assert ip.alias_manager.is_alias('bar')
-    nt.assert_equal(ip.user_ns['foobar'], 79)
-    nt.assert_equal(ip.user_ns['foobaz'], '80')
+    ip.magic("store -r foo bar foobar foobaz")
+    assert ip.user_ns["foo"] == 78
+    assert ip.alias_manager.is_alias("bar")
+    assert ip.user_ns["foobar"] == 79
+    assert ip.user_ns["foobaz"] == "80"
 
-    ip.magic('store -r') # restores _dh too
-    nt.assert_in(os.path.realpath(tmpd), ip.user_ns['_dh'])
+    ip.magic("store -r")  # restores _dh too
+    assert os.path.realpath(tmpd) in ip.user_ns["_dh"]
 
     os.rmdir(tmpd)
 
 def test_autorestore():
     ip.user_ns['foo'] = 95
     ip.magic('store foo')
     del ip.user_ns['foo']
     c = Config()
     c.StoreMagics.autorestore = False
     orig_config = ip.config
     try:
         ip.config = c
-        ip.extension_manager.reload_extension('storemagic')
-        nt.assert_not_in('foo', ip.user_ns)
+        ip.extension_manager.reload_extension("storemagic")
+        assert "foo" not in ip.user_ns
         c.StoreMagics.autorestore = True
-        ip.extension_manager.reload_extension('storemagic')
-        nt.assert_equal(ip.user_ns['foo'], 95)
+        ip.extension_manager.reload_extension("storemagic")
+        assert ip.user_ns["foo"] == 95
     finally:
         ip.config = orig_config

IPython/lib/tests/test_clipboard.py

@@ -1,21 +1,19 b''
-import nose.tools as nt
-
 from IPython.core.error import TryNext
 from IPython.lib.clipboard import ClipboardEmpty
 from IPython.testing.decorators import skip_if_no_x11
 
 @skip_if_no_x11
 def test_clipboard_get():
     # Smoketest for clipboard access - we can't easily guarantee that the
     # clipboard is accessible and has something on it, but this tries to
     # exercise the relevant code anyway.
     try:
         a = get_ipython().hooks.clipboard_get()
     except ClipboardEmpty:
         # Nothing in clipboard to get
         pass
     except TryNext:
         # No clipboard access API available
         pass
     else:
-        nt.assert_is_instance(a, str)
+        assert isinstance(a, str)

IPython/lib/tests/test_deepreload.py

@@ -1,36 +1,34 b''
 # -*- coding: utf-8 -*-
 """Test suite for the deepreload module."""
 
 # Copyright (c) IPython Development Team.
 # Distributed under the terms of the Modified BSD License.
 
 from pathlib import Path
 
-import nose.tools as nt
-
 from IPython.utils.syspathcontext import prepended_to_syspath
 from IPython.utils.tempdir import TemporaryDirectory
 from IPython.lib.deepreload import reload as dreload
 
 
 def test_deepreload():
     "Test that dreload does deep reloads and skips excluded modules."
     with TemporaryDirectory() as tmpdir:
         with prepended_to_syspath(tmpdir):
             tmpdirpath = Path(tmpdir)
             with open(tmpdirpath / "A.py", "w") as f:
                 f.write("class Object(object):\n    pass\n")
             with open(tmpdirpath / "B.py", "w") as f:
                 f.write("import A\n")
             import A
             import B
 
             # Test that A is not reloaded.
             obj = A.Object()
             dreload(B, exclude=["A"])
-            nt.assert_true(isinstance(obj, A.Object))
+            assert isinstance(obj, A.Object) is True
 
             # Test that A is reloaded.
             obj = A.Object()
             dreload(B)
-            nt.assert_false(isinstance(obj, A.Object))
+            assert isinstance(obj, A.Object) is False

IPython/lib/tests/test_display.py

@@ -1,272 +1,272 b''
 """Tests for IPython.lib.display.
 
 """
 #-----------------------------------------------------------------------------
 # Copyright (c) 2012, the IPython Development Team.
 #
 # Distributed under the terms of the Modified BSD License.
 #
 # The full license is in the file COPYING.txt, distributed with this software.
 #-----------------------------------------------------------------------------
 
 #-----------------------------------------------------------------------------
 # Imports
 #-----------------------------------------------------------------------------
 from tempfile import NamedTemporaryFile, mkdtemp
 from os.path import split, join as pjoin, dirname
 import pathlib
 from unittest import TestCase, mock
 import struct
 import wave
 from io import BytesIO
 
 # Third-party imports
-import nose.tools as nt
+import pytest
 
 try:
     import numpy
 except ImportError:
     pass
 
 # Our own imports
 from IPython.lib import display
 
 from IPython.testing.decorators import skipif_not_numpy
 
 #-----------------------------------------------------------------------------
 # Classes and functions
 #-----------------------------------------------------------------------------
 
 #--------------------------
 # FileLink tests
 #--------------------------
 
 def test_instantiation_FileLink():
     """FileLink: Test class can be instantiated"""
     fl = display.FileLink('example.txt')
     # TODO: remove if when only Python >= 3.6 is supported
     fl = display.FileLink(pathlib.PurePath('example.txt'))
 
 def test_warning_on_non_existent_path_FileLink():
-    """FileLink: Calling _repr_html_ on non-existent files returns a warning
-    """
-    fl = display.FileLink('example.txt')
-    nt.assert_true(fl._repr_html_().startswith('Path (<tt>example.txt</tt>)'))
+    """FileLink: Calling _repr_html_ on non-existent files returns a warning"""
+    fl = display.FileLink("example.txt")
+    assert fl._repr_html_().startswith("Path (<tt>example.txt</tt>)")
+
 
 def test_existing_path_FileLink():
     """FileLink: Calling _repr_html_ functions as expected on existing filepath
     """
     tf = NamedTemporaryFile()
     fl = display.FileLink(tf.name)
     actual = fl._repr_html_()
     expected = "<a href='%s' target='_blank'>%s</a><br>" % (tf.name, tf.name)
     assert actual == expected
 
 
 def test_existing_path_FileLink_repr():
     """FileLink: Calling repr() functions as expected on existing filepath
     """
     tf = NamedTemporaryFile()
     fl = display.FileLink(tf.name)
     actual = repr(fl)
     expected = tf.name
     assert actual == expected
 
 
 def test_error_on_directory_to_FileLink():
     """FileLink: Raises error when passed directory
     """
     td = mkdtemp()
-    nt.assert_raises(ValueError,display.FileLink,td)
+    pytest.raises(ValueError, display.FileLink, td)
 
 #--------------------------
 # FileLinks tests
 #--------------------------
 
 def test_instantiation_FileLinks():
     """FileLinks: Test class can be instantiated
     """
     fls = display.FileLinks('example')
 
 def test_warning_on_non_existent_path_FileLinks():
-    """FileLinks: Calling _repr_html_ on non-existent files returns a warning
-    """
-    fls = display.FileLinks('example')
-    nt.assert_true(fls._repr_html_().startswith('Path (<tt>example</tt>)'))
+    """FileLinks: Calling _repr_html_ on non-existent files returns a warning"""
+    fls = display.FileLinks("example")
+    assert fls._repr_html_().startswith("Path (<tt>example</tt>)")
+
 
 def test_existing_path_FileLinks():
     """FileLinks: Calling _repr_html_ functions as expected on existing dir
     """
     td = mkdtemp()
     tf1 = NamedTemporaryFile(dir=td)
     tf2 = NamedTemporaryFile(dir=td)
     fl = display.FileLinks(td)
     actual = fl._repr_html_()
     actual = actual.split('\n')
     actual.sort()
     # the links should always have forward slashes, even on windows, so replace
     # backslashes with forward slashes here
     expected = ["%s/<br>" % td,
                 "&nbsp;&nbsp;<a href='%s' target='_blank'>%s</a><br>" %\
                  (tf2.name.replace("\\","/"),split(tf2.name)[1]),
                 "&nbsp;&nbsp;<a href='%s' target='_blank'>%s</a><br>" %\
                  (tf1.name.replace("\\","/"),split(tf1.name)[1])]
     expected.sort()
     # We compare the sorted list of links here as that's more reliable
     assert actual == expected
 
 
 def test_existing_path_FileLinks_alt_formatter():
     """FileLinks: Calling _repr_html_ functions as expected w/ an alt formatter
     """
     td = mkdtemp()
     tf1 = NamedTemporaryFile(dir=td)
     tf2 = NamedTemporaryFile(dir=td)
     def fake_formatter(dirname,fnames,included_suffixes):
         return ["hello","world"]
     fl = display.FileLinks(td,notebook_display_formatter=fake_formatter)
     actual = fl._repr_html_()
     actual = actual.split('\n')
     actual.sort()
     expected = ["hello","world"]
     expected.sort()
     # We compare the sorted list of links here as that's more reliable
     assert actual == expected
 
 
 def test_existing_path_FileLinks_repr():
     """FileLinks: Calling repr() functions as expected on existing directory """
     td = mkdtemp()
     tf1 = NamedTemporaryFile(dir=td)
     tf2 = NamedTemporaryFile(dir=td)
     fl = display.FileLinks(td)
     actual = repr(fl)
     actual = actual.split('\n')
     actual.sort()
     expected = ['%s/' % td, '  %s' % split(tf1.name)[1],'  %s' % split(tf2.name)[1]]
     expected.sort()
     # We compare the sorted list of links here as that's more reliable
     assert actual == expected
 
 
 def test_existing_path_FileLinks_repr_alt_formatter():
     """FileLinks: Calling repr() functions as expected w/ alt formatter
     """
     td = mkdtemp()
     tf1 = NamedTemporaryFile(dir=td)
     tf2 = NamedTemporaryFile(dir=td)
     def fake_formatter(dirname,fnames,included_suffixes):
         return ["hello","world"]
     fl = display.FileLinks(td,terminal_display_formatter=fake_formatter)
     actual = repr(fl)
     actual = actual.split('\n')
     actual.sort()
     expected = ["hello","world"]
     expected.sort()
     # We compare the sorted list of links here as that's more reliable
     assert actual == expected
 
 
 def test_error_on_file_to_FileLinks():
     """FileLinks: Raises error when passed file
     """
     td = mkdtemp()
     tf1 = NamedTemporaryFile(dir=td)
-    nt.assert_raises(ValueError,display.FileLinks,tf1.name)
+    pytest.raises(ValueError, display.FileLinks, tf1.name)
+
 
 def test_recursive_FileLinks():
     """FileLinks: Does not recurse when recursive=False
     """
     td = mkdtemp()
     tf = NamedTemporaryFile(dir=td)
     subtd = mkdtemp(dir=td)
     subtf = NamedTemporaryFile(dir=subtd)
     fl = display.FileLinks(td)
     actual = str(fl)
     actual = actual.split('\n')
     assert len(actual) == 4, actual
     fl = display.FileLinks(td, recursive=False)
     actual = str(fl)
     actual = actual.split('\n')
     assert len(actual) == 2, actual
 
 def test_audio_from_file():
     path = pjoin(dirname(__file__), 'test.wav')
     display.Audio(filename=path)
 
 class TestAudioDataWithNumpy(TestCase):
 
     @skipif_not_numpy
     def test_audio_from_numpy_array(self):
         test_tone = get_test_tone()
         audio = display.Audio(test_tone, rate=44100)
         assert len(read_wav(audio.data)) == len(test_tone)
 
     @skipif_not_numpy
     def test_audio_from_list(self):
         test_tone = get_test_tone()
         audio = display.Audio(list(test_tone), rate=44100)
         assert len(read_wav(audio.data)) == len(test_tone)
 
     @skipif_not_numpy
     def test_audio_from_numpy_array_without_rate_raises(self):
-        nt.assert_raises(ValueError, display.Audio, get_test_tone())
+        self.assertRaises(ValueError, display.Audio, get_test_tone())
 
     @skipif_not_numpy
     def test_audio_data_normalization(self):
         expected_max_value = numpy.iinfo(numpy.int16).max
         for scale in [1, 0.5, 2]:
             audio = display.Audio(get_test_tone(scale), rate=44100)
             actual_max_value = numpy.max(numpy.abs(read_wav(audio.data)))
             assert actual_max_value == expected_max_value
 
     @skipif_not_numpy
     def test_audio_data_without_normalization(self):
         max_int16 = numpy.iinfo(numpy.int16).max
         for scale in [1, 0.5, 0.2]:
             test_tone = get_test_tone(scale)
             test_tone_max_abs = numpy.max(numpy.abs(test_tone))
             expected_max_value = int(max_int16 * test_tone_max_abs)
             audio = display.Audio(test_tone, rate=44100, normalize=False)
             actual_max_value = numpy.max(numpy.abs(read_wav(audio.data)))
             assert actual_max_value == expected_max_value
 
     def test_audio_data_without_normalization_raises_for_invalid_data(self):
-        nt.assert_raises(
+        self.assertRaises(
             ValueError,
             lambda: display.Audio([1.001], rate=44100, normalize=False))
-        nt.assert_raises(
+        self.assertRaises(
             ValueError,
             lambda: display.Audio([-1.001], rate=44100, normalize=False))
 
 def simulate_numpy_not_installed():
     try:
         import numpy
         return mock.patch('numpy.array', mock.MagicMock(side_effect=ImportError))
     except ModuleNotFoundError:
         return lambda x:x
 
 @simulate_numpy_not_installed()
 class TestAudioDataWithoutNumpy(TestAudioDataWithNumpy):
     # All tests from `TestAudioDataWithNumpy` are inherited.
 
     @skipif_not_numpy
     def test_audio_raises_for_nested_list(self):
         stereo_signal = [list(get_test_tone())] * 2
-        nt.assert_raises(
-            TypeError,
-            lambda: display.Audio(stereo_signal, rate=44100))
+        self.assertRaises(TypeError, lambda: display.Audio(stereo_signal, rate=44100))
+
 
 @skipif_not_numpy
 def get_test_tone(scale=1):
     return numpy.sin(2 * numpy.pi * 440 * numpy.linspace(0, 1, 44100)) * scale
 
 def read_wav(data):
     with wave.open(BytesIO(data)) as wave_file:
         wave_data = wave_file.readframes(wave_file.getnframes())
         num_samples = wave_file.getnframes() * wave_file.getnchannels()
         return struct.unpack('<%sh' % num_samples, wave_data)
 
 def test_code_from_file():
     c = display.Code(filename=__file__)
     assert c._repr_html_().startswith('<style>')

IPython/lib/tests/test_latextools.py

@@ -1,191 +1,196 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,
     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) is None
 
 
 @contextmanager
 def no_op(*args, **kwargs):
     yield
 
 
 @skip_iptest_but_not_pytest
 @onlyif_cmds_exist("latex", "dvipng")
 @pytest.mark.parametrize("s, wrap", [(u"$$x^2$$", False), (u"x^2", True)])
 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
 
     latextools.latex_to_png_dvipng(s, wrap)
 
     with patch_latextool(mock_kpsewhich):
         latextools.latex_to_png_dvipng(s, wrap)
 
 
 def mock_kpsewhich(filename):
     assert filename == "breqn.sty"
     return None
 
 @contextmanager
 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 matplotlib
     except ImportError:
         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_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_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_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"))
+    pytest.raises(
+        ValueError,
+        lambda: latextools.latex_to_png(
+            latex_string, backend="dvipng", color="#f00bar"
+        ),
+    )
+    pytest.raises(
+        ValueError,
+        lambda: latextools.latex_to_png(latex_string, backend="dvipng", color="#f00"),
+    )

IPython/lib/tests/test_pretty.py

@@ -1,502 +1,500 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, 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)) + ")"
 
     assert 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(...)"
 
     assert 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(...)"
 
     assert gotoutput == expectedoutput
 
 
 @pytest.mark.parametrize(
     "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.
     """
     got_output = pretty.pretty(obj)
     assert 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)
     assert output == "xxlimited.Null"
 
 
 def test_pprint_nomod():
     """
     Test that pprint works for classes with no __module__.
     """
     output = pretty.pretty(NoModule)
     assert output == "NoModule"
 
 
 def test_pprint_break():
     """
     Test that p.break_ produces expected output
     """
     output = pretty.pretty(Breaking())
     expected = "TG: Breaking(\n    ):"
     assert output == expected
 
 def test_pprint_break_repr():
     """
     Test that p.break_ is used in repr
     """
     output = pretty.pretty([[BreakingRepr()]])
     expected = "[[Breaking(\n  )]]"
     assert output == expected
 
     output = pretty.pretty([[BreakingRepr()]*2])
     expected = "[[Breaking(\n  ),\n  Breaking(\n  )]]"
     assert output == expected
 
 def test_bad_repr():
     """Don't catch bad repr errors"""
-    with nt.assert_raises(ZeroDivisionError):
+    with pytest.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):
+    with pytest.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)
     assert 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)
     assert p == u
     p = pretty.pretty([c])
     assert 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()
 
     assert output == "%s.MyObj" % __name__
-    nt.assert_true(type_pprint_wrapper.called)
+    assert type_pprint_wrapper.called is True
 
 
 # TODO : pytest.mark.parametrise once nose is gone.
 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 pretty.pretty(obj) == expected
 
 
 # TODO : pytest.mark.parametrise once nose is gone.
 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 pretty.pretty(obj) == expected
 
 
 # TODO : pytest.mark.parametrise once nose is gone.
 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 pretty.pretty(obj) == expected
 
 
 # TODO : pytest.mark.parametrise once nose is gone.
 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 pretty.pretty(obj) == expected
 
 # TODO : pytest.mark.parametrise once nose is gone.
 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:
         assert pretty.pretty(obj) == expected
 
 
 # TODO : pytest.mark.parametrise once nose is gone.
 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:
         assert 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)
     assert 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
 
     assert 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))
+    assert "meaning_of_life(question=None)" in 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))
+    assert "OrderedCounter(OrderedDict" in pretty.pretty(oc)
 
     assert pretty.pretty(MySet()) == "mine"

IPython/terminal/tests/test_embed.py

@@ -1,136 +1,137 b''
 """Test embedding of IPython"""
 
 #-----------------------------------------------------------------------------
 #  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 os
 import subprocess
 import sys
-import nose.tools as nt
+
 from IPython.utils.tempdir import NamedFileInTemporaryDirectory
 from IPython.testing.decorators import skip_win32
 from IPython.testing import IPYTHON_TESTING_TIMEOUT_SCALE
 
 #-----------------------------------------------------------------------------
 # Tests
 #-----------------------------------------------------------------------------
 
 
 _sample_embed = b"""
 import IPython
 
 a = 3
 b = 14
 print(a, '.', b)
 
 IPython.embed()
 
 print('bye!')
 """
 
 _exit = b"exit\r"
 
 def test_ipython_embed():
     """test that `IPython.embed()` works"""
     with NamedFileInTemporaryDirectory('file_with_embed.py') as f:
         f.write(_sample_embed)
         f.flush()
         f.close() # otherwise msft won't be able to read the file
 
         # run `python file_with_embed.py`
         cmd = [sys.executable, f.name]
         env = os.environ.copy()
         env['IPY_TEST_SIMPLE_PROMPT'] = '1'
 
         p = subprocess.Popen(cmd, env=env, stdin=subprocess.PIPE,
                 stdout=subprocess.PIPE, stderr=subprocess.PIPE)
         out, err = p.communicate(_exit)
         std = out.decode('UTF-8')
 
-        nt.assert_equal(p.returncode, 0)
-        nt.assert_in('3 . 14', std)
-        if os.name != 'nt':
+        assert p.returncode == 0
+        assert "3 . 14" in std
+        if os.name != "nt":
             # TODO: Fix up our different stdout references, see issue gh-14
-            nt.assert_in('IPython', std)
-        nt.assert_in('bye!', std)
+            assert "IPython" in std
+        assert "bye!" in std
+
 
 @skip_win32
 def test_nest_embed():
     """test that `IPython.embed()` is nestable"""
     import pexpect
     ipy_prompt = r']:' #ansi color codes give problems matching beyond this
     env = os.environ.copy()
     env['IPY_TEST_SIMPLE_PROMPT'] = '1'
 
 
     child = pexpect.spawn(sys.executable, ['-m', 'IPython', '--colors=nocolor'],
                           env=env)
     child.timeout = 5 * IPYTHON_TESTING_TIMEOUT_SCALE
     child.expect(ipy_prompt)
     child.sendline("import IPython")
     child.expect(ipy_prompt)
     child.sendline("ip0 = get_ipython()")
     #enter first nested embed
     child.sendline("IPython.embed()")
     #skip the banner until we get to a prompt
     try:
         prompted = -1
         while prompted != 0:
             prompted = child.expect([ipy_prompt, '\r\n'])
     except pexpect.TIMEOUT as e:
         print(e)
         #child.interact()
     child.sendline("embed1 = get_ipython()")
     child.expect(ipy_prompt)
     child.sendline("print('true' if embed1 is not ip0 else 'false')")
     assert(child.expect(['true\r\n', 'false\r\n']) == 0)
     child.expect(ipy_prompt)
     child.sendline("print('true' if IPython.get_ipython() is embed1 else 'false')")
     assert(child.expect(['true\r\n', 'false\r\n']) == 0)
     child.expect(ipy_prompt)
     #enter second nested embed
     child.sendline("IPython.embed()")
     #skip the banner until we get to a prompt
     try:
         prompted = -1
         while prompted != 0:
             prompted = child.expect([ipy_prompt, '\r\n'])
     except pexpect.TIMEOUT as e:
         print(e)
         #child.interact()
     child.sendline("embed2 = get_ipython()")
     child.expect(ipy_prompt)
     child.sendline("print('true' if embed2 is not embed1 else 'false')")
     assert(child.expect(['true\r\n', 'false\r\n']) == 0)
     child.expect(ipy_prompt)
     child.sendline("print('true' if embed2 is IPython.get_ipython() else 'false')")
     assert(child.expect(['true\r\n', 'false\r\n']) == 0)
     child.expect(ipy_prompt)
     child.sendline('exit')
     #back at first embed
     child.expect(ipy_prompt)
     child.sendline("print('true' if get_ipython() is embed1 else 'false')")
     assert(child.expect(['true\r\n', 'false\r\n']) == 0)
     child.expect(ipy_prompt)
     child.sendline("print('true' if IPython.get_ipython() is embed1 else 'false')")
     assert(child.expect(['true\r\n', 'false\r\n']) == 0)
     child.expect(ipy_prompt)
     child.sendline('exit')
     #back at launching scope
     child.expect(ipy_prompt)
     child.sendline("print('true' if get_ipython() is ip0 else 'false')")
     assert(child.expect(['true\r\n', 'false\r\n']) == 0)
     child.expect(ipy_prompt)
     child.sendline("print('true' if IPython.get_ipython() is ip0 else 'false')")
     assert(child.expect(['true\r\n', 'false\r\n']) == 0)
     child.expect(ipy_prompt)
     child.sendline('exit')
     child.close()

IPython/terminal/tests/test_interactivshell.py

@@ -1,193 +1,225 b''
 # -*- coding: utf-8 -*-
 """Tests for the TerminalInteractiveShell and related pieces."""
 # Copyright (c) IPython Development Team.
 # Distributed under the terms of the Modified BSD License.
 
 import sys
 import unittest
 import os
 
 from IPython.core.inputtransformer import InputTransformer
 from IPython.testing import tools as tt
 from IPython.utils.capture import capture_output
 
 from IPython.terminal.ptutils import _elide, _adjust_completion_text_based_on_context
-import nose.tools as nt
 
-class TestElide(unittest.TestCase):
 
+class TestElide(unittest.TestCase):
     def test_elide(self):
-        _elide('concatenate((a1, a2, ...), axis', '') # do not raise
-        _elide('concatenate((a1, a2, ..), . axis', '') # do not raise
-        nt.assert_equal(_elide('aaaa.bbbb.ccccc.dddddd.eeeee.fffff.gggggg.hhhhhh',''), 'aaaa.b…g.hhhhhh')
-
-        test_string = os.sep.join(['', 10*'a', 10*'b', 10*'c', ''])
-        expect_stirng = os.sep + 'a' + '\N{HORIZONTAL ELLIPSIS}' + 'b' + os.sep + 10*'c'
-        nt.assert_equal(_elide(test_string, ''), expect_stirng)
+        _elide("concatenate((a1, a2, ...), axis", "")  # do not raise
+        _elide("concatenate((a1, a2, ..), . axis", "")  # do not raise
+        self.assertEqual(
+            _elide("aaaa.bbbb.ccccc.dddddd.eeeee.fffff.gggggg.hhhhhh", ""),
+            "aaaa.b…g.hhhhhh",
+        )
+
+        test_string = os.sep.join(["", 10 * "a", 10 * "b", 10 * "c", ""])
+        expect_stirng = (
+            os.sep + "a" + "\N{HORIZONTAL ELLIPSIS}" + "b" + os.sep + 10 * "c"
+        )
+        self.assertEqual(_elide(test_string, ""), expect_stirng)
 
     def test_elide_typed_normal(self):
-        nt.assert_equal(_elide('the quick brown fox jumped over the lazy dog', 'the quick brown fox', min_elide=10), 'the…fox jumped over the lazy dog')
-
+        self.assertEqual(
+            _elide(
+                "the quick brown fox jumped over the lazy dog",
+                "the quick brown fox",
+                min_elide=10,
+            ),
+            "the…fox jumped over the lazy dog",
+        )
 
     def test_elide_typed_short_match(self):
         """
         if the match is too short we don't elide.
         avoid the "the...the"
         """
-        nt.assert_equal(_elide('the quick brown fox jumped over the lazy dog', 'the', min_elide=10), 'the quick brown fox jumped over the lazy dog')
+        self.assertEqual(
+            _elide("the quick brown fox jumped over the lazy dog", "the", min_elide=10),
+            "the quick brown fox jumped over the lazy dog",
+        )
 
     def test_elide_typed_no_match(self):
         """
         if the match is too short we don't elide.
         avoid the "the...the"
         """
         # here we typed red instead of brown
-        nt.assert_equal(_elide('the quick brown fox jumped over the lazy dog', 'the quick red fox', min_elide=10), 'the quick brown fox jumped over the lazy dog')
+        self.assertEqual(
+            _elide(
+                "the quick brown fox jumped over the lazy dog",
+                "the quick red fox",
+                min_elide=10,
+            ),
+            "the quick brown fox jumped over the lazy dog",
+        )
 
-class TestContextAwareCompletion(unittest.TestCase):
 
+class TestContextAwareCompletion(unittest.TestCase):
     def test_adjust_completion_text_based_on_context(self):
         # Adjusted case
-        nt.assert_equal(_adjust_completion_text_based_on_context('arg1=', 'func1(a=)', 7), 'arg1')
+        self.assertEqual(
+            _adjust_completion_text_based_on_context("arg1=", "func1(a=)", 7), "arg1"
+        )
 
         # Untouched cases
-        nt.assert_equal(_adjust_completion_text_based_on_context('arg1=', 'func1(a)', 7), 'arg1=')
-        nt.assert_equal(_adjust_completion_text_based_on_context('arg1=', 'func1(a', 7), 'arg1=')
-        nt.assert_equal(_adjust_completion_text_based_on_context('%magic', 'func1(a=)', 7), '%magic')
-        nt.assert_equal(_adjust_completion_text_based_on_context('func2', 'func1(a=)', 7), 'func2')
+        self.assertEqual(
+            _adjust_completion_text_based_on_context("arg1=", "func1(a)", 7), "arg1="
+        )
+        self.assertEqual(
+            _adjust_completion_text_based_on_context("arg1=", "func1(a", 7), "arg1="
+        )
+        self.assertEqual(
+            _adjust_completion_text_based_on_context("%magic", "func1(a=)", 7), "%magic"
+        )
+        self.assertEqual(
+            _adjust_completion_text_based_on_context("func2", "func1(a=)", 7), "func2"
+        )
+
 
 # Decorator for interaction loop tests -----------------------------------------
 
+
 class mock_input_helper(object):
     """Machinery for tests of the main interact loop.
 
     Used by the mock_input decorator.
     """
     def __init__(self, testgen):
         self.testgen = testgen
         self.exception = None
         self.ip = get_ipython()
 
     def __enter__(self):
         self.orig_prompt_for_code = self.ip.prompt_for_code
         self.ip.prompt_for_code = self.fake_input
         return self
 
     def __exit__(self, etype, value, tb):
         self.ip.prompt_for_code = self.orig_prompt_for_code
 
     def fake_input(self):
         try:
             return next(self.testgen)
         except StopIteration:
             self.ip.keep_running = False
             return u''
         except:
             self.exception = sys.exc_info()
             self.ip.keep_running = False
             return u''
 
 def mock_input(testfunc):
     """Decorator for tests of the main interact loop.
 
     Write the test as a generator, yield-ing the input strings, which IPython
     will see as if they were typed in at the prompt.
     """
     def test_method(self):
         testgen = testfunc(self)
         with mock_input_helper(testgen) as mih:
             mih.ip.interact()
 
         if mih.exception is not None:
             # Re-raise captured exception
             etype, value, tb = mih.exception
             import traceback
             traceback.print_tb(tb, file=sys.stdout)
             del tb  # Avoid reference loop
             raise value
 
     return test_method
 
 # Test classes -----------------------------------------------------------------
 
 class InteractiveShellTestCase(unittest.TestCase):
     def rl_hist_entries(self, rl, n):
         """Get last n readline history entries as a list"""
         return [rl.get_history_item(rl.get_current_history_length() - x)
                 for x in range(n - 1, -1, -1)]
     
     @mock_input
     def test_inputtransformer_syntaxerror(self):
         ip = get_ipython()
         ip.input_transformers_post.append(syntax_error_transformer)
 
         try:
             #raise Exception
             with tt.AssertPrints('4', suppress=False):
                 yield u'print(2*2)'
 
             with tt.AssertPrints('SyntaxError: input contains', suppress=False):
                 yield u'print(2345) # syntaxerror'
 
             with tt.AssertPrints('16', suppress=False):
                 yield u'print(4*4)'
 
         finally:
             ip.input_transformers_post.remove(syntax_error_transformer)
 
     def test_plain_text_only(self):
         ip = get_ipython()
         formatter = ip.display_formatter
         assert formatter.active_types == ['text/plain']
         assert not formatter.ipython_display_formatter.enabled
 
         class Test(object):
             def __repr__(self):
                 return "<Test %i>" % id(self)
 
             def _repr_html_(self):
                 return '<html>'
 
         # verify that HTML repr isn't computed
         obj = Test()
         data, _ = formatter.format(obj)
         self.assertEqual(data, {'text/plain': repr(obj)})
 
         class Test2(Test):
             def _ipython_display_(self):
                 from IPython.display import display
                 display('<custom>')
 
         # verify that _ipython_display_ shortcut isn't called
         obj = Test2()
         with capture_output() as captured:
             data, _ = formatter.format(obj)
 
         self.assertEqual(data, {'text/plain': repr(obj)})
         assert captured.stdout == ''
 
 def syntax_error_transformer(lines):
     """Transformer that throws SyntaxError if 'syntaxerror' is in the code."""
     for line in lines:
         pos = line.find('syntaxerror')
         if pos >= 0:
             e = SyntaxError('input contains "syntaxerror"')
             e.text = line
             e.offset = pos + 1
             raise e
     return lines
 
 
 class TerminalMagicsTestCase(unittest.TestCase):
     def test_paste_magics_blankline(self):
         """Test that code with a blank line doesn't get split (gh-3246)."""
         ip = get_ipython()
         s = ('def pasted_func(a):\n'
              '    b = a+1\n'
              '\n'
              '    return b')
         
         tm = ip.magics_manager.registry['TerminalMagics']
         tm.store_or_execute(s, name=None)
         
         self.assertEqual(ip.user_ns['pasted_func'](54), 55)

IPython/testing/tests/test_decorators.py

@@ -1,168 +1,166 b''
 """Tests for the decorators we've created for IPython.
 """
 
 # Module imports
 # Std lib
 import inspect
 import sys
 
-# Third party
-import nose.tools as nt
-
 # Our own
 from IPython.testing import decorators as dec
 from IPython.testing.skipdoctest import skip_doctest
 
 #-----------------------------------------------------------------------------
 # Utilities
 
 # Note: copied from OInspect, kept here so the testing stuff doesn't create
 # circular dependencies and is easier to reuse.
 def getargspec(obj):
     """Get the names and default values of a function's arguments.
 
     A tuple of four things is returned: (args, varargs, varkw, defaults).
     'args' is a list of the argument names (it may contain nested lists).
     'varargs' and 'varkw' are the names of the * and ** arguments or None.
     'defaults' is an n-tuple of the default values of the last n arguments.
 
     Modified version of inspect.getargspec from the Python Standard
     Library."""
 
     if inspect.isfunction(obj):
         func_obj = obj
     elif inspect.ismethod(obj):
         func_obj = obj.__func__
     else:
         raise TypeError('arg is not a Python function')
     args, varargs, varkw = inspect.getargs(func_obj.__code__)
     return args, varargs, varkw, func_obj.__defaults__
 
 #-----------------------------------------------------------------------------
 # Testing functions
 
 @dec.as_unittest
 def trivial():
     """A trivial test"""
     pass
 
 
 @dec.skip()
 def test_deliberately_broken():
     """A deliberately broken test - we want to skip this one."""
     1/0
 
 @dec.skip('Testing the skip decorator')
 def test_deliberately_broken2():
     """Another deliberately broken test - we want to skip this one."""
     1/0
 
 
 # Verify that we can correctly skip the doctest for a function at will, but
 # that the docstring itself is NOT destroyed by the decorator.
 @skip_doctest
 def doctest_bad(x,y=1,**k):
     """A function whose doctest we need to skip.
 
     >>> 1+1
     3
     """
     print('x:',x)
     print('y:',y)
     print('k:',k)
 
 
 def call_doctest_bad():
     """Check that we can still call the decorated functions.
     
     >>> doctest_bad(3,y=4)
     x: 3
     y: 4
     k: {}
     """
     pass
 
 
 def test_skip_dt_decorator():
     """Doctest-skipping decorator should preserve the docstring.
     """
     # Careful: 'check' must be a *verbatim* copy of the doctest_bad docstring!
     check = """A function whose doctest we need to skip.
 
     >>> 1+1
     3
     """
     # Fetch the docstring from doctest_bad after decoration.
     val = doctest_bad.__doc__
     
-    nt.assert_equal(check,val,"doctest_bad docstrings don't match")
+    assert check == val, "doctest_bad docstrings don't match"
 
 
 # Doctest skipping should work for class methods too
 class FooClass(object):
     """FooClass
 
     Example:
 
     >>> 1+1
     2
     """
 
     @skip_doctest
     def __init__(self,x):
         """Make a FooClass.
 
         Example:
 
         >>> f = FooClass(3)
         junk
         """
         print('Making a FooClass.')
         self.x = x
         
     @skip_doctest
     def bar(self,y):
         """Example:
 
         >>> ff = FooClass(3)
         >>> ff.bar(0)
         boom!
         >>> 1/0
         bam!
         """
         return 1/y
 
     def baz(self,y):
         """Example:
 
         >>> ff2 = FooClass(3)
         Making a FooClass.
         >>> ff2.baz(3)
         True
         """
         return self.x==y
 
 
 def test_skip_dt_decorator2():
     """Doctest-skipping decorator should preserve function signature.
     """
     # Hardcoded correct answer
     dtargs = (['x', 'y'], None, 'k', (1,))
     # Introspect out the value
     dtargsr = getargspec(doctest_bad)
     assert dtargsr==dtargs, \
            "Incorrectly reconstructed args for doctest_bad: %s" % (dtargsr,)
 
 
 @dec.skip_linux
 def test_linux():
-    nt.assert_false(sys.platform.startswith('linux'),"This test can't run under linux")
+    assert sys.platform.startswith("linux") is False, "This test can't run under linux"
+
 
 @dec.skip_win32
 def test_win32():
-    nt.assert_not_equal(sys.platform,'win32',"This test can't run under windows")
+    assert sys.platform != "win32", "This test can't run under windows"
+
 
 @dec.skip_osx
 def test_osx():
-    nt.assert_not_equal(sys.platform,'darwin',"This test can't run under osx")
-
+    assert sys.platform != "darwin", "This test can't run under osx"

IPython/testing/tests/test_tools.py

@@ -1,135 +1,133 b''
 # encoding: utf-8
 """
 Tests for testing.tools
 """
 
 #-----------------------------------------------------------------------------
 #  Copyright (C) 2008-2011  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 os
 import unittest
 
-import nose.tools as nt
-
 from IPython.testing import decorators as dec
 from IPython.testing import tools as tt
 
 #-----------------------------------------------------------------------------
 # Tests
 #-----------------------------------------------------------------------------
 
 @dec.skip_win32
 def test_full_path_posix():
-    spath = '/foo/bar.py'
-    result = tt.full_path(spath,['a.txt','b.txt'])
-    nt.assert_equal(result, ['/foo/a.txt', '/foo/b.txt'])
-    spath = '/foo'
-    result = tt.full_path(spath,['a.txt','b.txt'])
-    nt.assert_equal(result, ['/a.txt', '/b.txt'])
-    result = tt.full_path(spath,'a.txt')
-    nt.assert_equal(result, ['/a.txt'])
+    spath = "/foo/bar.py"
+    result = tt.full_path(spath, ["a.txt", "b.txt"])
+    assert result, ["/foo/a.txt" == "/foo/b.txt"]
+    spath = "/foo"
+    result = tt.full_path(spath, ["a.txt", "b.txt"])
+    assert result, ["/a.txt" == "/b.txt"]
+    result = tt.full_path(spath, "a.txt")
+    assert result == ["/a.txt"]
 
 
 @dec.skip_if_not_win32
 def test_full_path_win32():
-    spath = 'c:\\foo\\bar.py'
-    result = tt.full_path(spath,['a.txt','b.txt'])
-    nt.assert_equal(result, ['c:\\foo\\a.txt', 'c:\\foo\\b.txt'])
-    spath = 'c:\\foo'
-    result = tt.full_path(spath,['a.txt','b.txt'])
-    nt.assert_equal(result, ['c:\\a.txt', 'c:\\b.txt'])
-    result = tt.full_path(spath,'a.txt')
-    nt.assert_equal(result, ['c:\\a.txt'])
+    spath = "c:\\foo\\bar.py"
+    result = tt.full_path(spath, ["a.txt", "b.txt"])
+    assert result, ["c:\\foo\\a.txt" == "c:\\foo\\b.txt"]
+    spath = "c:\\foo"
+    result = tt.full_path(spath, ["a.txt", "b.txt"])
+    assert result, ["c:\\a.txt" == "c:\\b.txt"]
+    result = tt.full_path(spath, "a.txt")
+    assert result == ["c:\\a.txt"]
 
     
 def test_parser():
     err = ("FAILED (errors=1)", 1, 0)
     fail = ("FAILED (failures=1)", 0, 1)
     both = ("FAILED (errors=1, failures=1)", 1, 1)
     for txt, nerr, nfail in [err, fail, both]:
         nerr1, nfail1 = tt.parse_test_output(txt)
-        nt.assert_equal(nerr, nerr1)
-        nt.assert_equal(nfail, nfail1)
+        assert nerr == nerr1
+        assert nfail == nfail1
 
 
 def test_temp_pyfile():
     src = 'pass\n'
     fname = tt.temp_pyfile(src)
     assert os.path.isfile(fname)
     with open(fname) as fh2:
         src2 = fh2.read()
-    nt.assert_equal(src2, src)
+    assert src2 == src
 
 class TestAssertPrints(unittest.TestCase):
     def test_passing(self):
         with tt.AssertPrints("abc"):
             print("abcd")
             print("def")
             print(b"ghi")
     
     def test_failing(self):
         def func():
             with tt.AssertPrints("abc"):
                 print("acd")
                 print("def")
                 print(b"ghi")
         
         self.assertRaises(AssertionError, func)
 
 
 class Test_ipexec_validate(tt.TempFileMixin):
     def test_main_path(self):
         """Test with only stdout results.
         """
         self.mktmp("print('A')\n"
                    "print('B')\n"
                    )
         out = "A\nB"
         tt.ipexec_validate(self.fname, out)
 
     def test_main_path2(self):
         """Test with only stdout results, expecting windows line endings.
         """
         self.mktmp("print('A')\n"
                    "print('B')\n"
                    )
         out = "A\r\nB"
         tt.ipexec_validate(self.fname, out)
 
     def test_exception_path(self):
         """Test exception path in exception_validate.
         """
         self.mktmp("import sys\n"
                    "print('A')\n"
                    "print('B')\n"
                    "print('C', file=sys.stderr)\n"
                    "print('D', file=sys.stderr)\n"
                    )
         out = "A\nB"
         tt.ipexec_validate(self.fname, expected_out=out, expected_err="C\nD")
 
     def test_exception_path2(self):
         """Test exception path in exception_validate, expecting windows line endings.
         """
         self.mktmp("import sys\n"
                    "print('A')\n"
                    "print('B')\n"
                    "print('C', file=sys.stderr)\n"
                    "print('D', file=sys.stderr)\n"
                    )
         out = "A\r\nB"
         tt.ipexec_validate(self.fname, expected_out=out, expected_err="C\r\nD")
 
 
     def tearDown(self):
         # tear down correctly the mixin,
         # unittest.TestCase.tearDown does nothing
         tt.TempFileMixin.tearDown(self)

IPython/utils/tests/test_dir2.py

@@ -1,58 +1,67 b''
-import nose.tools as nt
 from IPython.utils.dir2 import dir2
 
+import pytest
+
 
 class Base(object):
     x = 1
     z = 23
 
 
 def test_base():
     res = dir2(Base())
-    assert ('x' in res)
-    assert ('z' in res)
-    assert ('y' not in res)
-    assert ('__class__' in res)
-    nt.assert_equal(res.count('x'), 1)
-    nt.assert_equal(res.count('__class__'), 1)
+    assert "x" in res
+    assert "z" in res
+    assert "y" not in res
+    assert "__class__" in res
+    assert res.count("x") == 1
+    assert res.count("__class__") == 1
+
 
 def test_SubClass():
 
     class SubClass(Base):
         y = 2
 
     res = dir2(SubClass())
-    assert ('y' in res)
-    nt.assert_equal(res.count('y'), 1)
-    nt.assert_equal(res.count('x'), 1)
+    assert "y" in res
+    assert res.count("y") == 1
+    assert res.count("x") == 1
 
 
 def test_SubClass_with_trait_names_attr():
     # usecase: trait_names is used in a class describing psychological classification
 
     class SubClass(Base):
         y = 2
         trait_names = 44
 
     res = dir2(SubClass())
-    assert('trait_names' in res)
+    assert "trait_names" in res
 
 
 def test_misbehaving_object_without_trait_names():
     # dir2 shouldn't raise even when objects are dumb and raise
     # something other than AttribteErrors on bad getattr.
 
-    class MisbehavingGetattr(object):
-        def __getattr__(self):
+    class MisbehavingGetattr:
+        def __getattr__(self, attr):
             raise KeyError("I should be caught")
 
         def some_method(self):
-            pass
+            return True
 
     class SillierWithDir(MisbehavingGetattr):
         def __dir__(self):
             return ['some_method']
 
     for bad_klass in (MisbehavingGetattr, SillierWithDir):
-        res = dir2(bad_klass())
-        assert('some_method' in res)
+        obj = bad_klass()
+
+        assert obj.some_method()
+
+        with pytest.raises(KeyError):
+            obj.other_method()
+
+        res = dir2(obj)
+        assert "some_method" in res

IPython/utils/tests/test_importstring.py

@@ -1,39 +1,40 b''
 """Tests for IPython.utils.importstring."""
 
 #-----------------------------------------------------------------------------
 #  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 nose.tools as nt
+import pytest
 
 from IPython.utils.importstring import import_item
 
 #-----------------------------------------------------------------------------
 # Tests
 #-----------------------------------------------------------------------------
 
 def test_import_plain():
     "Test simple imports"
     import os
-    os2 = import_item('os')
-    nt.assert_true(os is os2)
+
+    os2 = import_item("os")
+    assert os is os2
 
 
 def test_import_nested():
     "Test nested imports from the stdlib"
     from os import path
-    path2 = import_item('os.path')
-    nt.assert_true(path is path2)
+
+    path2 = import_item("os.path")
+    assert path is path2
 
 
 def test_import_raises():
     "Test that failing imports raise the right exception"
-    nt.assert_raises(ImportError, import_item, 'IPython.foobar')
-    
+    pytest.raises(ImportError, import_item, "IPython.foobar")

IPython/utils/tests/test_io.py

@@ -1,89 +1,87 b''
 # encoding: utf-8
 """Tests for io.py"""
 
 # Copyright (c) IPython Development Team.
 # Distributed under the terms of the Modified BSD License.
 
 
 import sys
 from io import StringIO
 
 from subprocess import Popen, PIPE
 import unittest
 
-import nose.tools as nt
-
 from IPython.utils.io import IOStream, Tee, capture_output
 
 
 def test_tee_simple():
     "Very simple check with stdout only"
     chan = StringIO()
     text = 'Hello'
     tee = Tee(chan, channel='stdout')
     print(text, file=chan)
-    nt.assert_equal(chan.getvalue(), text+"\n")
+    assert chan.getvalue() == text + "\n"
 
 
 class TeeTestCase(unittest.TestCase):
 
     def tchan(self, channel):
         trap = StringIO()
         chan = StringIO()
         text = 'Hello'
         
         std_ori = getattr(sys, channel)
         setattr(sys, channel, trap)
 
         tee = Tee(chan, channel=channel)
 
         print(text, end='', file=chan)
         trap_val = trap.getvalue()
-        nt.assert_equal(chan.getvalue(), text)
+        self.assertEqual(chan.getvalue(), text)
 
         tee.close()
 
         setattr(sys, channel, std_ori)
         assert getattr(sys, channel) == std_ori
 
     def test(self):
         for chan in ['stdout', 'stderr']:
             self.tchan(chan)
 
 def test_io_init():
     """Test that io.stdin/out/err exist at startup"""
     for name in ('stdin', 'stdout', 'stderr'):
         cmd = "from IPython.utils import io;print(io.%s.__class__)"%name
         with Popen([sys.executable, '-c', cmd], stdout=PIPE) as p:
             p.wait()
             classname = p.stdout.read().strip().decode('ascii')
         # __class__ is a reference to the class object in Python 3, so we can't
         # just test for string equality.
         assert 'IPython.utils.io.IOStream' in classname, classname
 
 class TestIOStream(unittest.TestCase):
 
     def test_IOStream_init(self):
         """IOStream initializes from a file-like object missing attributes. """
         # Cause a failure from getattr and dir(). (Issue #6386)
         class BadStringIO(StringIO):
             def __dir__(self):
                 attrs = super().__dir__()
                 attrs.append('name')
                 return attrs
         with self.assertWarns(DeprecationWarning):
             iostream = IOStream(BadStringIO())
             iostream.write('hi, bad iostream\n')
 
         assert not hasattr(iostream, 'name')
         iostream.close()
 
     def test_capture_output(self):
         """capture_output() context works"""
         
         with capture_output() as io:
-            print('hi, stdout')
-            print('hi, stderr', file=sys.stderr)
-        
-        nt.assert_equal(io.stdout, 'hi, stdout\n')
-        nt.assert_equal(io.stderr, 'hi, stderr\n')
+            print("hi, stdout")
+            print("hi, stderr", file=sys.stderr)
+
+        self.assertEqual(io.stdout, "hi, stdout\n")
+        self.assertEqual(io.stderr, "hi, stderr\n")

IPython/utils/tests/test_module_paths.py

@@ -1,111 +1,109 b''
 # encoding: utf-8
 """Tests for IPython.utils.module_paths.py"""
 
 #-----------------------------------------------------------------------------
 #  Copyright (C) 2008-2011  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 shutil
 import sys
 import tempfile
 
 from pathlib import Path
 
 from IPython.testing.tools import make_tempfile
 
 import IPython.utils.module_paths as mp
 
-import nose.tools as nt
-
 TEST_FILE_PATH = Path(__file__).resolve().parent
 
 TMP_TEST_DIR = Path(tempfile.mkdtemp(suffix="with.dot"))
 #
 # Setup/teardown functions/decorators
 #
 
 old_syspath = sys.path
 
 def make_empty_file(fname):
     open(fname, 'w').close()
 
 
 def setup_module():
     """Setup testenvironment for the module:
 
     """
     # Do not mask exceptions here.  In particular, catching WindowsError is a
     # problem because that exception is only defined on Windows...
     Path(TMP_TEST_DIR / "xmod").mkdir(parents=True)
     Path(TMP_TEST_DIR / "nomod").mkdir(parents=True)
     make_empty_file(TMP_TEST_DIR / "xmod/__init__.py")
     make_empty_file(TMP_TEST_DIR / "xmod/sub.py")
     make_empty_file(TMP_TEST_DIR / "pack.py")
     make_empty_file(TMP_TEST_DIR / "packpyc.pyc")
     sys.path = [str(TMP_TEST_DIR)]
 
 def teardown_module():
     """Teardown testenvironment for the module:
 
     - Remove tempdir
     - restore sys.path
     """
     # Note: we remove the parent test dir, which is the root of all test
     # subdirs we may have created.  Use shutil instead of os.removedirs, so
     # that non-empty directories are all recursively removed.
     shutil.rmtree(TMP_TEST_DIR)
     sys.path = old_syspath
 
 def test_tempdir():
     """
     Ensure the test are done with a temporary file that have a dot somewhere.
     """
-    nt.assert_in(".", str(TMP_TEST_DIR))
+    assert "." in str(TMP_TEST_DIR)
 
 
 def test_find_mod_1():
     """
     Search for a directory's file path.
     Expected output: a path to that directory's __init__.py file.
     """
     modpath = TMP_TEST_DIR / "xmod" / "__init__.py"
-    nt.assert_equal(Path(mp.find_mod("xmod")), modpath)
+    assert Path(mp.find_mod("xmod")) == modpath
 
 def test_find_mod_2():
     """
     Search for a directory's file path.
     Expected output: a path to that directory's __init__.py file.
     TODO: Confirm why this is a duplicate test.
     """
     modpath = TMP_TEST_DIR / "xmod" / "__init__.py"
-    nt.assert_equal(Path(mp.find_mod("xmod")), modpath)
+    assert Path(mp.find_mod("xmod")) == modpath
 
 def test_find_mod_3():
     """
     Search for a directory + a filename without its .py extension
     Expected output: full path with .py extension.
     """
     modpath = TMP_TEST_DIR / "xmod" / "sub.py"
-    nt.assert_equal(Path(mp.find_mod("xmod.sub")), modpath)
+    assert Path(mp.find_mod("xmod.sub")) == modpath
 
 def test_find_mod_4():
     """
     Search for a filename without its .py extension
     Expected output: full path with .py extension
     """
     modpath = TMP_TEST_DIR / "pack.py"
-    nt.assert_equal(Path(mp.find_mod("pack")), modpath)
+    assert Path(mp.find_mod("pack")) == modpath
 
 def test_find_mod_5():
     """
     Search for a filename with a .pyc extension
     Expected output: TODO: do we exclude or include .pyc files?
     """
-    nt.assert_equal(mp.find_mod("packpyc"), None)
+    assert mp.find_mod("packpyc") == None

IPython/utils/tests/test_openpy.py

@@ -1,39 +1,38 b''
 import io
 import os.path
-import nose.tools as nt
 
 from IPython.utils import openpy
 
 mydir = os.path.dirname(__file__)
 nonascii_path = os.path.join(mydir, "../../core/tests/nonascii.py")
 
 
 def test_detect_encoding():
     with open(nonascii_path, "rb") as f:
         enc, lines = openpy.detect_encoding(f.readline)
-    nt.assert_equal(enc, "iso-8859-5")
+    assert enc == "iso-8859-5"
 
 
 def test_read_file():
     with io.open(nonascii_path, encoding="iso-8859-5") as f:
         read_specified_enc = f.read()
     read_detected_enc = openpy.read_py_file(nonascii_path, skip_encoding_cookie=False)
-    nt.assert_equal(read_detected_enc, read_specified_enc)
+    assert read_detected_enc == read_specified_enc
     assert "coding: iso-8859-5" in read_detected_enc
 
     read_strip_enc_cookie = openpy.read_py_file(
         nonascii_path, skip_encoding_cookie=True
     )
     assert "coding: iso-8859-5" not in read_strip_enc_cookie
 
 
 def test_source_to_unicode():
     with io.open(nonascii_path, "rb") as f:
         source_bytes = f.read()
-    nt.assert_equal(
-        openpy.source_to_unicode(source_bytes, skip_encoding_cookie=False).splitlines(),
-        source_bytes.decode("iso-8859-5").splitlines(),
+    assert (
+        openpy.source_to_unicode(source_bytes, skip_encoding_cookie=False).splitlines()
+        == source_bytes.decode("iso-8859-5").splitlines()
     )
 
     source_no_cookie = openpy.source_to_unicode(source_bytes, skip_encoding_cookie=True)
-    nt.assert_not_in("coding: iso-8859-5", source_no_cookie)
+    assert "coding: iso-8859-5" not in source_no_cookie

IPython/utils/tests/test_path.py

@@ -1,494 +1,493 b''
 # encoding: utf-8
 """Tests for IPython.utils.path.py"""
 
 # Copyright (c) IPython Development Team.
 # Distributed under the terms of the Modified BSD License.
 
 import os
 import shutil
 import sys
 import tempfile
 import unittest
 from contextlib import contextmanager
 from unittest.mock import patch
 from os.path import join, abspath
 from imp import reload
 
 from nose import SkipTest, with_setup
-import nose.tools as nt
+import pytest
 
 import IPython
 from IPython import paths
 from IPython.testing import decorators as dec
 from IPython.testing.decorators import (skip_if_not_win32, skip_win32,
                                         onlyif_unicode_paths,
                                         skip_win32_py38,)
 from IPython.testing.tools import make_tempfile
 from IPython.utils import path
 from IPython.utils.tempdir import TemporaryDirectory
 
 
 # Platform-dependent imports
 try:
     import winreg as wreg
 except ImportError:
     #Fake _winreg module on non-windows platforms
     import types
     wr_name = "winreg"
     sys.modules[wr_name] = types.ModuleType(wr_name)
     try:
         import winreg as wreg
     except ImportError:
         import _winreg as wreg
         #Add entries that needs to be stubbed by the testing code
         (wreg.OpenKey, wreg.QueryValueEx,) = (None, None)
 
 #-----------------------------------------------------------------------------
 # Globals
 #-----------------------------------------------------------------------------
 env = os.environ
 TMP_TEST_DIR = tempfile.mkdtemp()
 HOME_TEST_DIR = join(TMP_TEST_DIR, "home_test_dir")
 #
 # Setup/teardown functions/decorators
 #
 
 def setup_module():
     """Setup testenvironment for the module:
 
     - Adds dummy home dir tree
     """
     # Do not mask exceptions here.  In particular, catching WindowsError is a
     # problem because that exception is only defined on Windows...
     os.makedirs(os.path.join(HOME_TEST_DIR, 'ipython'))
 
 
 def teardown_module():
     """Teardown testenvironment for the module:
 
     - Remove dummy home dir tree
     """
     # Note: we remove the parent test dir, which is the root of all test
     # subdirs we may have created.  Use shutil instead of os.removedirs, so
     # that non-empty directories are all recursively removed.
     shutil.rmtree(TMP_TEST_DIR)
 
 
 def setup_environment():
     """Setup testenvironment for some functions that are tested
     in this module. In particular this functions stores attributes
     and other things that we need to stub in some test functions.
     This needs to be done on a function level and not module level because
     each testfunction needs a pristine environment.
     """
     global oldstuff, platformstuff
     oldstuff = (env.copy(), os.name, sys.platform, path.get_home_dir, IPython.__file__, os.getcwd())
 
 def teardown_environment():
     """Restore things that were remembered by the setup_environment function
     """
     (oldenv, os.name, sys.platform, path.get_home_dir, IPython.__file__, old_wd) = oldstuff
     os.chdir(old_wd)
     reload(path)
 
     for key in list(env):
         if key not in oldenv:
             del env[key]
     env.update(oldenv)
     if hasattr(sys, 'frozen'):
         del sys.frozen
 
 # Build decorator that uses the setup_environment/setup_environment
 with_environment = with_setup(setup_environment, teardown_environment)
 
 @skip_if_not_win32
 @with_environment
 def test_get_home_dir_1():
     """Testcase for py2exe logic, un-compressed lib
     """
     unfrozen = path.get_home_dir()
     sys.frozen = True
 
     #fake filename for IPython.__init__
     IPython.__file__ = abspath(join(HOME_TEST_DIR, "Lib/IPython/__init__.py"))
 
     home_dir = path.get_home_dir()
     assert home_dir == unfrozen
 
 
 @skip_if_not_win32
 @with_environment
 def test_get_home_dir_2():
     """Testcase for py2exe logic, compressed lib
     """
     unfrozen = path.get_home_dir()
     sys.frozen = True
     #fake filename for IPython.__init__
     IPython.__file__ = abspath(join(HOME_TEST_DIR, "Library.zip/IPython/__init__.py")).lower()
 
     home_dir = path.get_home_dir(True)
     assert home_dir == unfrozen
 
 
 @skip_win32_py38
 @with_environment
 def test_get_home_dir_3():
     """get_home_dir() uses $HOME if set"""
     env["HOME"] = HOME_TEST_DIR
     home_dir = path.get_home_dir(True)
     # get_home_dir expands symlinks
     assert home_dir == os.path.realpath(env["HOME"])
 
 
 @with_environment
 def test_get_home_dir_4():
     """get_home_dir() still works if $HOME is not set"""
 
     if 'HOME' in env: del env['HOME']
     # this should still succeed, but we don't care what the answer is
     home = path.get_home_dir(False)
 
 @skip_win32_py38
 @with_environment
 def test_get_home_dir_5():
     """raise HomeDirError if $HOME is specified, but not a writable dir"""
     env['HOME'] = abspath(HOME_TEST_DIR+'garbage')
     # set os.name = posix, to prevent My Documents fallback on Windows
     os.name = 'posix'
-    nt.assert_raises(path.HomeDirError, path.get_home_dir, True)
+    pytest.raises(path.HomeDirError, path.get_home_dir, True)
 
 # Should we stub wreg fully so we can run the test on all platforms?
 @skip_if_not_win32
 @with_environment
 def test_get_home_dir_8():
     """Using registry hack for 'My Documents', os=='nt'
 
     HOMESHARE, HOMEDRIVE, HOMEPATH, USERPROFILE and others are missing.
     """
     os.name = 'nt'
     # Remove from stub environment all keys that may be set
     for key in ['HOME', 'HOMESHARE', 'HOMEDRIVE', 'HOMEPATH', 'USERPROFILE']:
         env.pop(key, None)
 
     class key:
         def __enter__(self):
             pass
         def Close(self):
             pass
         def __exit__(*args, **kwargs):
             pass
 
     with patch.object(wreg, 'OpenKey', return_value=key()), \
          patch.object(wreg, 'QueryValueEx', return_value=[abspath(HOME_TEST_DIR)]):
         home_dir = path.get_home_dir()
     assert home_dir == abspath(HOME_TEST_DIR)
 
 @with_environment
 def test_get_xdg_dir_0():
     """test_get_xdg_dir_0, check xdg_dir"""
     reload(path)
     path._writable_dir = lambda path: True
     path.get_home_dir = lambda : 'somewhere'
     os.name = "posix"
     sys.platform = "linux2"
     env.pop('IPYTHON_DIR', None)
     env.pop('IPYTHONDIR', None)
     env.pop('XDG_CONFIG_HOME', None)
 
     assert path.get_xdg_dir() == os.path.join("somewhere", ".config")
 
 
 @with_environment
 def test_get_xdg_dir_1():
     """test_get_xdg_dir_1, check nonexistent xdg_dir"""
     reload(path)
     path.get_home_dir = lambda : HOME_TEST_DIR
     os.name = "posix"
     sys.platform = "linux2"
     env.pop('IPYTHON_DIR', None)
     env.pop('IPYTHONDIR', None)
     env.pop('XDG_CONFIG_HOME', None)
     assert path.get_xdg_dir() is None
 
 @with_environment
 def test_get_xdg_dir_2():
     """test_get_xdg_dir_2, check xdg_dir default to ~/.config"""
     reload(path)
     path.get_home_dir = lambda : HOME_TEST_DIR
     os.name = "posix"
     sys.platform = "linux2"
     env.pop('IPYTHON_DIR', None)
     env.pop('IPYTHONDIR', None)
     env.pop('XDG_CONFIG_HOME', None)
     cfgdir=os.path.join(path.get_home_dir(), '.config')
     if not os.path.exists(cfgdir):
         os.makedirs(cfgdir)
 
     assert path.get_xdg_dir() == cfgdir
 
 @with_environment
 def test_get_xdg_dir_3():
     """test_get_xdg_dir_3, check xdg_dir not used on OS X"""
     reload(path)
     path.get_home_dir = lambda : HOME_TEST_DIR
     os.name = "posix"
     sys.platform = "darwin"
     env.pop('IPYTHON_DIR', None)
     env.pop('IPYTHONDIR', None)
     env.pop('XDG_CONFIG_HOME', None)
     cfgdir=os.path.join(path.get_home_dir(), '.config')
-    if not os.path.exists(cfgdir):
-        os.makedirs(cfgdir)
+    os.makedirs(cfgdir, exist_ok=True)
 
     assert path.get_xdg_dir() is None
 
 def test_filefind():
     """Various tests for filefind"""
     f = tempfile.NamedTemporaryFile()
     # print 'fname:',f.name
     alt_dirs = paths.get_ipython_dir()
     t = path.filefind(f.name, alt_dirs)
     # print 'found:',t
 
 
 @dec.skip_if_not_win32
 def test_get_long_path_name_win32():
     with TemporaryDirectory() as tmpdir:
 
         # Make a long path. Expands the path of tmpdir prematurely as it may already have a long
         # path component, so ensure we include the long form of it
         long_path = os.path.join(path.get_long_path_name(tmpdir), 'this is my long path name')
         os.makedirs(long_path)
 
         # Test to see if the short path evaluates correctly.
         short_path = os.path.join(tmpdir, 'THISIS~1')
         evaluated_path = path.get_long_path_name(short_path)
         assert evaluated_path.lower() == long_path.lower()
 
 
 @dec.skip_win32
 def test_get_long_path_name():
     p = path.get_long_path_name("/usr/local")
     assert p == "/usr/local"
 
 
 class TestRaiseDeprecation(unittest.TestCase):
 
     @dec.skip_win32 # can't create not-user-writable dir on win
     @with_environment
     def test_not_writable_ipdir(self):
         tmpdir = tempfile.mkdtemp()
         os.name = "posix"
         env.pop('IPYTHON_DIR', None)
         env.pop('IPYTHONDIR', None)
         env.pop('XDG_CONFIG_HOME', None)
         env['HOME'] = tmpdir
         ipdir = os.path.join(tmpdir, '.ipython')
         os.mkdir(ipdir, 0o555)
         try:
             open(os.path.join(ipdir, "_foo_"), 'w').close()
         except IOError:
             pass
         else:
             # I can still write to an unwritable dir,
             # assume I'm root and skip the test
             raise SkipTest("I can't create directories that I can't write to")
         with self.assertWarnsRegex(UserWarning, 'is not a writable location'):
             ipdir = paths.get_ipython_dir()
         env.pop('IPYTHON_DIR', None)
 
 @with_environment
 def test_get_py_filename():
     os.chdir(TMP_TEST_DIR)
     with make_tempfile("foo.py"):
         assert path.get_py_filename("foo.py") == "foo.py"
         assert path.get_py_filename("foo") == "foo.py"
     with make_tempfile("foo"):
         assert path.get_py_filename("foo") == "foo"
-        nt.assert_raises(IOError, path.get_py_filename, "foo.py")
-    nt.assert_raises(IOError, path.get_py_filename, "foo")
-    nt.assert_raises(IOError, path.get_py_filename, "foo.py")
+        pytest.raises(IOError, path.get_py_filename, "foo.py")
+    pytest.raises(IOError, path.get_py_filename, "foo")
+    pytest.raises(IOError, path.get_py_filename, "foo.py")
     true_fn = "foo with spaces.py"
     with make_tempfile(true_fn):
         assert path.get_py_filename("foo with spaces") == true_fn
         assert path.get_py_filename("foo with spaces.py") == true_fn
-        nt.assert_raises(IOError, path.get_py_filename, '"foo with spaces.py"')
-        nt.assert_raises(IOError, path.get_py_filename, "'foo with spaces.py'")
+        pytest.raises(IOError, path.get_py_filename, '"foo with spaces.py"')
+        pytest.raises(IOError, path.get_py_filename, "'foo with spaces.py'")
 
 @onlyif_unicode_paths
 def test_unicode_in_filename():
     """When a file doesn't exist, the exception raised should be safe to call
     str() on - i.e. in Python 2 it must only have ASCII characters.
 
     https://github.com/ipython/ipython/issues/875
     """
     try:
         # these calls should not throw unicode encode exceptions
         path.get_py_filename('fooéè.py')
     except IOError as ex:
         str(ex)
 
 
 class TestShellGlob(unittest.TestCase):
 
     @classmethod
     def setUpClass(cls):
         cls.filenames_start_with_a = ['a0', 'a1', 'a2']
         cls.filenames_end_with_b = ['0b', '1b', '2b']
         cls.filenames = cls.filenames_start_with_a + cls.filenames_end_with_b
         cls.tempdir = TemporaryDirectory()
         td = cls.tempdir.name
 
         with cls.in_tempdir():
             # Create empty files
             for fname in cls.filenames:
                 open(os.path.join(td, fname), 'w').close()
 
     @classmethod
     def tearDownClass(cls):
         cls.tempdir.cleanup()
 
     @classmethod
     @contextmanager
     def in_tempdir(cls):
         save = os.getcwd()
         try:
             os.chdir(cls.tempdir.name)
             yield
         finally:
             os.chdir(save)
 
     def check_match(self, patterns, matches):
         with self.in_tempdir():
             # glob returns unordered list. that's why sorted is required.
             assert sorted(path.shellglob(patterns)) == sorted(matches)
 
     def common_cases(self):
         return [
             (['*'], self.filenames),
             (['a*'], self.filenames_start_with_a),
             (['*c'], ['*c']),
             (['*', 'a*', '*b', '*c'], self.filenames
                                       + self.filenames_start_with_a
                                       + self.filenames_end_with_b
                                       + ['*c']),
             (['a[012]'], self.filenames_start_with_a),
         ]
 
     @skip_win32
     def test_match_posix(self):
         for (patterns, matches) in self.common_cases() + [
                 ([r'\*'], ['*']),
                 ([r'a\*', 'a*'], ['a*'] + self.filenames_start_with_a),
                 ([r'a\[012]'], ['a[012]']),
                 ]:
             yield (self.check_match, patterns, matches)
 
     @skip_if_not_win32
     def test_match_windows(self):
         for (patterns, matches) in self.common_cases() + [
                 # In windows, backslash is interpreted as path
                 # separator.  Therefore, you can't escape glob
                 # using it.
                 ([r'a\*', 'a*'], [r'a\*'] + self.filenames_start_with_a),
                 ([r'a\[012]'], [r'a\[012]']),
                 ]:
             yield (self.check_match, patterns, matches)
 
 
 # TODO : pytest.mark.parametrise once nose is gone.
 def test_unescape_glob():
     assert path.unescape_glob(r"\*\[\!\]\?") == "*[!]?"
     assert path.unescape_glob(r"\\*") == r"\*"
     assert path.unescape_glob(r"\\\*") == r"\*"
     assert path.unescape_glob(r"\\a") == r"\a"
     assert path.unescape_glob(r"\a") == r"\a"
 
 
 @onlyif_unicode_paths
 def test_ensure_dir_exists():
     with TemporaryDirectory() as td:
         d = os.path.join(td, '∂ir')
         path.ensure_dir_exists(d) # create it
         assert os.path.isdir(d)
         path.ensure_dir_exists(d) # no-op
         f = os.path.join(td, 'ƒile')
         open(f, 'w').close() # touch
-        with nt.assert_raises(IOError):
+        with pytest.raises(IOError):
             path.ensure_dir_exists(f)
 
 class TestLinkOrCopy(unittest.TestCase):
     def setUp(self):
         self.tempdir = TemporaryDirectory()
         self.src = self.dst("src")
         with open(self.src, "w") as f:
             f.write("Hello, world!")
 
     def tearDown(self):
         self.tempdir.cleanup()
 
     def dst(self, *args):
         return os.path.join(self.tempdir.name, *args)
 
     def assert_inode_not_equal(self, a, b):
         assert (
             os.stat(a).st_ino != os.stat(b).st_ino
         ), "%r and %r do reference the same indoes" % (a, b)
 
     def assert_inode_equal(self, a, b):
         assert (
             os.stat(a).st_ino == os.stat(b).st_ino
         ), "%r and %r do not reference the same indoes" % (a, b)
 
     def assert_content_equal(self, a, b):
         with open(a) as a_f:
             with open(b) as b_f:
                 assert a_f.read() == b_f.read()
 
     @skip_win32
     def test_link_successful(self):
         dst = self.dst("target")
         path.link_or_copy(self.src, dst)
         self.assert_inode_equal(self.src, dst)
 
     @skip_win32
     def test_link_into_dir(self):
         dst = self.dst("some_dir")
         os.mkdir(dst)
         path.link_or_copy(self.src, dst)
         expected_dst = self.dst("some_dir", os.path.basename(self.src))
         self.assert_inode_equal(self.src, expected_dst)
 
     @skip_win32
     def test_target_exists(self):
         dst = self.dst("target")
         open(dst, "w").close()
         path.link_or_copy(self.src, dst)
         self.assert_inode_equal(self.src, dst)
 
     @skip_win32
     def test_no_link(self):
         real_link = os.link
         try:
             del os.link
             dst = self.dst("target")
             path.link_or_copy(self.src, dst)
             self.assert_content_equal(self.src, dst)
             self.assert_inode_not_equal(self.src, dst)
         finally:
             os.link = real_link
 
     @skip_if_not_win32
     def test_windows(self):
         dst = self.dst("target")
         path.link_or_copy(self.src, dst)
         self.assert_content_equal(self.src, dst)
 
     def test_link_twice(self):
         # Linking the same file twice shouldn't leave duplicates around.
         # See https://github.com/ipython/ipython/issues/6450
         dst = self.dst('target')
         path.link_or_copy(self.src, dst)
         path.link_or_copy(self.src, dst)
         self.assert_inode_equal(self.src, dst)
         assert sorted(os.listdir(self.tempdir.name)) == ["src", "target"]

IPython/utils/tests/test_process.py

@@ -1,198 +1,197 b''
 # encoding: utf-8
 """
 Tests for platutils.py
 """
 
 #-----------------------------------------------------------------------------
 #  Copyright (C) 2008-2011  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 signal
 import os
 import time
 from _thread import interrupt_main  # Py 3
 import threading
-from unittest import SkipTest
 
-import nose.tools as nt
+import pytest
 
 from IPython.utils.process import (find_cmd, FindCmdError, arg_split,
                                    system, getoutput, getoutputerror,
                                    get_output_error_code)
 from IPython.utils.capture import capture_output
 from IPython.testing import decorators as dec
 from IPython.testing import tools as tt
 
 python = os.path.basename(sys.executable)
 
 #-----------------------------------------------------------------------------
 # Tests
 #-----------------------------------------------------------------------------
 
 
 @dec.skip_win32
 def test_find_cmd_ls():
     """Make sure we can find the full path to ls."""
-    path = find_cmd('ls')
-    nt.assert_true(path.endswith('ls'))
+    path = find_cmd("ls")
+    assert path.endswith("ls")
 
     
 def has_pywin32():
     try:
         import win32api
     except ImportError:
         return False
     return True
 
 
 @dec.onlyif(has_pywin32, "This test requires win32api to run")
 def test_find_cmd_pythonw():
     """Try to find pythonw on Windows."""
     path = find_cmd('pythonw')
     assert path.lower().endswith('pythonw.exe'), path
 
 
 @dec.onlyif(lambda : sys.platform != 'win32' or has_pywin32(),
             "This test runs on posix or in win32 with win32api installed")
 def test_find_cmd_fail():
     """Make sure that FindCmdError is raised if we can't find the cmd."""
-    nt.assert_raises(FindCmdError,find_cmd,'asdfasdf')
+    pytest.raises(FindCmdError, find_cmd, "asdfasdf")
 
 
 # TODO: move to pytest.mark.parametrize once nose gone
 @dec.skip_win32
 def test_arg_split():
     """Ensure that argument lines are correctly split like in a shell."""
     tests = [['hi', ['hi']],
              [u'hi', [u'hi']],
              ['hello there', ['hello', 'there']],
              # \u01ce == \N{LATIN SMALL LETTER A WITH CARON}
              # Do not use \N because the tests crash with syntax error in
              # some cases, for example windows python2.6.
              [u'h\u01cello', [u'h\u01cello']],
              ['something "with quotes"', ['something', '"with quotes"']],
              ]
     for argstr, argv in tests:
         assert arg_split(argstr) == argv
 
 
 # TODO: move to pytest.mark.parametrize once nose gone
 @dec.skip_if_not_win32
 def test_arg_split_win32():
     """Ensure that argument lines are correctly split like in a shell."""
     tests = [['hi', ['hi']],
              [u'hi', [u'hi']],
              ['hello there', ['hello', 'there']],
              [u'h\u01cello', [u'h\u01cello']],
              ['something "with quotes"', ['something', 'with quotes']],
              ]
     for argstr, argv in tests:
         assert arg_split(argstr) == argv
 
 
 class SubProcessTestCase(tt.TempFileMixin):
     def setUp(self):
         """Make a valid python temp file."""
         lines = [ "import sys",
                  "print('on stdout', end='', file=sys.stdout)",
                  "print('on stderr', end='', file=sys.stderr)",
                  "sys.stdout.flush()",
                  "sys.stderr.flush()"]
         self.mktmp('\n'.join(lines))
 
     def test_system(self):
         status = system('%s "%s"' % (python, self.fname))
         self.assertEqual(status, 0)
 
     def test_system_quotes(self):
         status = system('%s -c "import sys"' % python)
         self.assertEqual(status, 0)
 
     def assert_interrupts(self, command):
         """
         Interrupt a subprocess after a second.
         """
         if threading.main_thread() != threading.current_thread():
-            raise nt.SkipTest("Can't run this test if not in main thread.")
+            raise pytest.skip("Can't run this test if not in main thread.")
 
         # Some tests can overwrite SIGINT handler (by using pdb for example),
         # which then breaks this test, so just make sure it's operating
         # normally.
         signal.signal(signal.SIGINT, signal.default_int_handler)
 
         def interrupt():
             # Wait for subprocess to start:
             time.sleep(0.5)
             interrupt_main()
 
         threading.Thread(target=interrupt).start()
         start = time.time()
         try:
             result = command()
         except KeyboardInterrupt:
             # Success!
             pass
         end = time.time()
         self.assertTrue(
             end - start < 2, "Process didn't die quickly: %s" % (end - start)
         )
         return result
 
     def test_system_interrupt(self):
         """
         When interrupted in the way ipykernel interrupts IPython, the
         subprocess is interrupted.
         """
         def command():
             return system('%s -c "import time; time.sleep(5)"' % python)
 
         status = self.assert_interrupts(command)
         self.assertNotEqual(
             status, 0, "The process wasn't interrupted. Status: %s" % (status,)
         )
 
     def test_getoutput(self):
         out = getoutput('%s "%s"' % (python, self.fname))
         # we can't rely on the order the line buffered streams are flushed
         try:
             self.assertEqual(out, 'on stderron stdout')
         except AssertionError:
             self.assertEqual(out, 'on stdouton stderr')
 
     def test_getoutput_quoted(self):
         out = getoutput('%s -c "print (1)"' % python)
         self.assertEqual(out.strip(), '1')
 
     #Invalid quoting on windows
     @dec.skip_win32
     def test_getoutput_quoted2(self):
         out = getoutput("%s -c 'print (1)'" % python)
         self.assertEqual(out.strip(), '1')
         out = getoutput("%s -c 'print (\"1\")'" % python)
         self.assertEqual(out.strip(), '1')
 
     def test_getoutput_error(self):
         out, err = getoutputerror('%s "%s"' % (python, self.fname))
         self.assertEqual(out, 'on stdout')
         self.assertEqual(err, 'on stderr')
 
     def test_get_output_error_code(self):
         quiet_exit = '%s -c "import sys; sys.exit(1)"' % python
         out, err, code = get_output_error_code(quiet_exit)
         self.assertEqual(out, '')
         self.assertEqual(err, '')
         self.assertEqual(code, 1)
         out, err, code = get_output_error_code('%s "%s"' % (python, self.fname))
         self.assertEqual(out, 'on stdout')
         self.assertEqual(err, 'on stderr')
         self.assertEqual(code, 0)
 
         

IPython/utils/tests/test_pycolorize.py

@@ -1,76 +1,73 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
 
 
 @pytest.fixture(scope="module", params=("Linux", "NoColor", "LightBG", "Neutral"))
 def style(request):
     yield request.param
 
 #-----------------------------------------------------------------------------
 # Test functions
 #-----------------------------------------------------------------------------
 
 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)
 """
 
 
 @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)
+    assert "ERROR" not in f1
 
 
 @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)
+        assert "ERROR" in f1

IPython/utils/tests/test_sysinfo.py

@@ -1,17 +1,16 b''
 # coding: utf-8
 """Test suite for our sysinfo utilities."""
 
 # Copyright (c) IPython Development Team.
 # Distributed under the terms of the Modified BSD License.
 
 import json
-import nose.tools as nt
 
 from IPython.utils import sysinfo
 
 
 def test_json_getsysinfo():
     """
     test that it is easily jsonable and don't return bytes somewhere.
     """
     json.dumps(sysinfo.get_sys_info())

IPython/utils/tests/test_text.py

@@ -1,205 +1,207 b''
 # encoding: utf-8
 """Tests for IPython.utils.text"""
 
 #-----------------------------------------------------------------------------
 #  Copyright (C) 2011  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 os
 import math
 import random
 import sys
 
-import nose.tools as nt
 from pathlib import Path
 
+import pytest
+
 from IPython.utils import text
 
 #-----------------------------------------------------------------------------
 # Globals
 #-----------------------------------------------------------------------------
 
 def test_columnize():
     """Basic columnize tests."""
     size = 5
     items = [l*size for l in 'abcd']
 
     out = text.columnize(items, displaywidth=80)
     assert out == "aaaaa  bbbbb  ccccc  ddddd\n"
     out = text.columnize(items, displaywidth=25)
     assert out == "aaaaa  ccccc\nbbbbb  ddddd\n"
     out = text.columnize(items, displaywidth=12)
     assert out == "aaaaa  ccccc\nbbbbb  ddddd\n"
     out = text.columnize(items, displaywidth=10)
     assert out == "aaaaa\nbbbbb\nccccc\nddddd\n"
 
     out = text.columnize(items, row_first=True, displaywidth=80)
     assert out == "aaaaa  bbbbb  ccccc  ddddd\n"
     out = text.columnize(items, row_first=True, displaywidth=25)
     assert out == "aaaaa  bbbbb\nccccc  ddddd\n"
     out = text.columnize(items, row_first=True, displaywidth=12)
     assert out == "aaaaa  bbbbb\nccccc  ddddd\n"
     out = text.columnize(items, row_first=True, displaywidth=10)
     assert out == "aaaaa\nbbbbb\nccccc\nddddd\n"
 
     out = text.columnize(items, displaywidth=40, spread=True)
     assert out == "aaaaa      bbbbb      ccccc      ddddd\n"
     out = text.columnize(items, displaywidth=20, spread=True)
     assert out == "aaaaa          ccccc\nbbbbb          ddddd\n"
     out = text.columnize(items, displaywidth=12, spread=True)
     assert out == "aaaaa  ccccc\nbbbbb  ddddd\n"
     out = text.columnize(items, displaywidth=10, spread=True)
     assert out == "aaaaa\nbbbbb\nccccc\nddddd\n"
 
 
 def test_columnize_random():
     """Test with random input to hopefully catch edge case """
     for row_first in [True, False]:
         for nitems in [random.randint(2,70) for i in range(2,20)]:
             displaywidth = random.randint(20,200)
             rand_len = [random.randint(2,displaywidth) for i in range(nitems)]
             items = ['x'*l for l in rand_len]
             out = text.columnize(items, row_first=row_first, displaywidth=displaywidth)
             longer_line = max([len(x) for x in out.split('\n')])
             longer_element = max(rand_len)
             if longer_line > displaywidth:
                 print("Columnize displayed something lager than displaywidth : %s " % longer_line)
                 print("longer element : %s " % longer_element)
                 print("displaywidth : %s " % displaywidth)
                 print("number of element : %s " % nitems)
                 print("size of each element :\n %s" % rand_len)
                 assert False, "row_first={0}".format(row_first)
 
 
 # TODO: pytest mark.parametrize once nose removed.
 def test_columnize_medium():
     """Test with inputs than shouldn't be wider than 80"""
     size = 40
     items = [l*size for l in 'abc']
     for row_first in [True, False]:
         out = text.columnize(items, row_first=row_first, displaywidth=80)
         assert out == "\n".join(items + [""]), "row_first={0}".format(row_first)
 
 
 # TODO: pytest mark.parametrize once nose removed.
 def test_columnize_long():
     """Test columnize with inputs longer than the display window"""
     size = 11
     items = [l*size for l in 'abc']
     for row_first in [True, False]:
         out = text.columnize(items, row_first=row_first, displaywidth=size - 1)
         assert out == "\n".join(items + [""]), "row_first={0}".format(row_first)
 
 
 def eval_formatter_check(f):
     ns = dict(n=12, pi=math.pi, stuff='hello there', os=os, u=u"café", b="café")
     s = f.format("{n} {n//4} {stuff.split()[0]}", **ns)
     assert s == "12 3 hello"
     s = f.format(' '.join(['{n//%i}'%i for i in range(1,8)]), **ns)
     assert s == "12 6 4 3 2 2 1"
     s = f.format('{[n//i for i in range(1,8)]}', **ns)
     assert s == "[12, 6, 4, 3, 2, 2, 1]"
     s = f.format("{stuff!s}", **ns)
     assert s == ns["stuff"]
     s = f.format("{stuff!r}", **ns)
     assert s == repr(ns["stuff"])
 
     # Check with unicode:
     s = f.format("{u}", **ns)
     assert s == ns["u"]
     # This decodes in a platform dependent manner, but it shouldn't error out
     s = f.format("{b}", **ns)
-        
-    nt.assert_raises(NameError, f.format, '{dne}', **ns)
+
+    pytest.raises(NameError, f.format, "{dne}", **ns)
+
 
 def eval_formatter_slicing_check(f):
     ns = dict(n=12, pi=math.pi, stuff='hello there', os=os)
     s = f.format(" {stuff.split()[:]} ", **ns)
     assert s == " ['hello', 'there'] "
     s = f.format(" {stuff.split()[::-1]} ", **ns)
     assert s == " ['there', 'hello'] "
     s = f.format("{stuff[::2]}", **ns)
     assert s == ns["stuff"][::2]
 
-    nt.assert_raises(SyntaxError, f.format, "{n:x}", **ns)
+    pytest.raises(SyntaxError, f.format, "{n:x}", **ns)
 
 def eval_formatter_no_slicing_check(f):
     ns = dict(n=12, pi=math.pi, stuff='hello there', os=os)
     
     s = f.format('{n:x} {pi**2:+f}', **ns)
     assert s == "c +9.869604"
 
     s = f.format("{stuff[slice(1,4)]}", **ns)
     assert s == "ell"
 
     s = f.format("{a[:]}", a=[1, 2])
     assert s == "[1, 2]"
 
 def test_eval_formatter():
     f = text.EvalFormatter()
     eval_formatter_check(f)
     eval_formatter_no_slicing_check(f)
 
 def test_full_eval_formatter():
     f = text.FullEvalFormatter()
     eval_formatter_check(f)
     eval_formatter_slicing_check(f)
 
 def test_dollar_formatter():
     f = text.DollarFormatter()
     eval_formatter_check(f)
     eval_formatter_slicing_check(f)
     
     ns = dict(n=12, pi=math.pi, stuff='hello there', os=os)
     s = f.format("$n", **ns)
     assert s == "12"
     s = f.format("$n.real", **ns)
     assert s == "12"
     s = f.format("$n/{stuff[:5]}", **ns)
     assert s == "12/hello"
     s = f.format("$n $$HOME", **ns)
     assert s == "12 $HOME"
     s = f.format("${foo}", foo="HOME")
     assert s == "$HOME"
 
 
 def test_strip_email():
     src = """\
         >> >>> def f(x):
         >> ...   return x+1
         >> ... 
         >> >>> zz = f(2.5)"""
     cln = """\
 >>> def f(x):
 ...   return x+1
 ... 
 >>> zz = f(2.5)"""
     assert text.strip_email_quotes(src) == cln
 
 
 def test_strip_email2():
     src = '> > > list()'
     cln = 'list()'
     assert text.strip_email_quotes(src) == cln
 
 def test_LSString():
     lss = text.LSString("abc\ndef")
     assert lss.l == ["abc", "def"]
     assert lss.s == "abc def"
     lss = text.LSString(os.getcwd())
-    nt.assert_is_instance(lss.p[0], Path)
+    assert isinstance(lss.p[0], Path)
 
 def test_SList():
     sl = text.SList(["a 11", "b 1", "a 2"])
     assert sl.n == "a 11\nb 1\na 2"
     assert sl.s == "a 11 b 1 a 2"
     assert sl.grep(lambda x: x.startswith("a")) == text.SList(["a 11", "a 2"])
     assert sl.fields(0) == text.SList(["a", "b", "a"])
     assert sl.sort(field=1, nums=True) == text.SList(["b 1", "a 2", "a 11"])