Merge pull request #13098 from Carreau/less-nose-II

Remove more nose idioms

IPython/core/tests/test_oinspect.py

@@ -1,447 +1,455 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
 
 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):
-    nt.assert_equal(pyfile(f1), pyfile(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__))
-    nt.assert_equal(f.__doc__, "My docstring")
+    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__))
-    nt.assert_equal(f.__doc__, "My docstring 2")
+    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)
 
 
 # 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')
-    nt.assert_equal(i['type_name'], 'type')
+    i = inspector.info(Call, oname="Call")
+    assert i["type_name"] == "type"
     expted_class = str(type(type))  # <class 'type'> (Python 3) or <type 'type'>
-    nt.assert_equal(i['base_class'], expted_class)
-    nt.assert_regex(i['string_form'], "<class 'IPython.core.tests.test_oinspect.Call'( at 0x[0-9a-f]{1,9})?>")
+    assert i["base_class"] == expted_class
+    nt.assert_regex(
+        i["string_form"],
+        "<class 'IPython.core.tests.test_oinspect.Call'( at 0x[0-9a-f]{1,9})?>",
+    )
     fname = __file__
     if fname.endswith(".pyc"):
         fname = fname[:-1]
     # case-insensitive comparison needed on some filesystems
     # e.g. Windows:
-    nt.assert_equal(i['file'].lower(), compress_user(fname).lower())
-    nt.assert_equal(i['definition'], None)
-    nt.assert_equal(i['docstring'], Call.__doc__)
-    nt.assert_equal(i['source'], None)
-    nt.assert_true(i['isclass'])
-    nt.assert_equal(i['init_definition'], "Call(x, y=1)")
-    nt.assert_equal(i['init_docstring'], Call.__init__.__doc__)
+    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["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)
-    nt.assert_equal(i['docstring'], None)
+    nt.assert_not_equal(i["source"], None)
+    assert i["docstring"] == None
 
     c = Call(1)
     c.__doc__ = "Modified instance docstring"
     i = inspector.info(c)
-    nt.assert_equal(i['type_name'], 'Call')
-    nt.assert_equal(i['docstring'], "Modified instance docstring")
-    nt.assert_equal(i['class_docstring'], Call.__doc__)
-    nt.assert_equal(i['init_docstring'], Call.__init__.__doc__)
-    nt.assert_equal(i['call_docstring'], Call.__call__.__doc__)
+    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')
-    nt.assert_equal(info['init_definition'], "HasSignature(test)")
-    nt.assert_equal(info['init_docstring'], HasSignature.__init__.__doc__)
+    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)
 
 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)
 
 def f_kwarg(pos, *, kwonly):
     pass
 
 def test_definition_kwonlyargs():
-    i = inspector.info(f_kwarg, oname='f_kwarg')  # analysis:ignore
-    nt.assert_equal(i['definition'], "f_kwarg(pos, *, kwonly)")
+    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()
     
-    nt.assert_equal(oinspect.getdoc(a), "standard docstring")
-    nt.assert_equal(oinspect.getdoc(b), "custom docstring")
-    nt.assert_equal(oinspect.getdoc(c), "standard docstring")
+    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)
 
 
 def test_property_sources():
     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) 
 
     i = inspector.info(A.foo, detail_level=1)
     nt.assert_in('def foo(self):', i['source'])
     nt.assert_in('lambda self, v:', i['source'])
 
     i = inspector.info(A.dname, detail_level=1)
     nt.assert_in('def dirname(p)', i['source'])
     
     i = inspector.info(A.adder, detail_level=1)
     nt.assert_in('def simple_add(a, b)', 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()
-    nt.assert_equal(
-        'This is `foobar` property.',
-        ip.object_inspect('a_obj.foobar', detail_level=0)['docstring'])
+    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
-    nt.assert_equal(
-        'This is `foobar` property.',
-        ip.object_inspect('a_cls.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)
 
 
 def test_builtin_init():
     info = inspector.info(list)
     init_def = info['init_definition']
     nt.assert_is_not_none(init_def)
 
 
 def test_render_signature_short():
     def short_fun(a=1): pass
     sig = oinspect._render_signature(
         signature(short_fun),
         short_fun.__name__,
     )
-    nt.assert_equal(sig, 'short_fun(a=1)')
+    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, [
         # 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/lib/tests/test_backgroundjobs.py

@@ -1,88 +1,85 b''
 """Tests for pylab tools module.
 """
 #-----------------------------------------------------------------------------
 # Copyright (c) 2011, 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
 #-----------------------------------------------------------------------------
 
 # Stdlib imports
 import time
 
-# Third-party imports
-import nose.tools as nt
-
 # Our own imports
 from IPython.lib import backgroundjobs as bg
 
 #-----------------------------------------------------------------------------
 # Globals and constants
 #-----------------------------------------------------------------------------
 t_short = 0.0001  # very short interval to wait on jobs
 
 #-----------------------------------------------------------------------------
 # Local utilities
 #-----------------------------------------------------------------------------
 def sleeper(interval=t_short, *a, **kw):
     args = dict(interval=interval,
                 other_args=a,
                 kw_args=kw)
     time.sleep(interval)
     return args
 
 def crasher(interval=t_short, *a, **kw):
     time.sleep(interval)
     raise Exception("Dead job with interval %s" % interval)
 
 #-----------------------------------------------------------------------------
 # Classes and functions
 #-----------------------------------------------------------------------------
 
 def test_result():
     """Test job submission and result retrieval"""
     jobs = bg.BackgroundJobManager()
     j = jobs.new(sleeper)
     j.join()
-    nt.assert_equal(j.result['interval'], t_short)
-    
+    assert j.result["interval"] == t_short
+
 
 def test_flush():
     """Test job control"""
     jobs = bg.BackgroundJobManager()
     j = jobs.new(sleeper)
     j.join()
-    nt.assert_equal(len(jobs.completed), 1)
-    nt.assert_equal(len(jobs.dead), 0)
+    assert len(jobs.completed) == 1
+    assert len(jobs.dead) == 0
     jobs.flush()
-    nt.assert_equal(len(jobs.completed), 0)
+    assert len(jobs.completed) == 0
     
 
 def test_dead():
     """Test control of dead jobs"""
     jobs = bg.BackgroundJobManager()
     j = jobs.new(crasher)
     j.join()
-    nt.assert_equal(len(jobs.completed), 0)
-    nt.assert_equal(len(jobs.dead), 1)
+    assert len(jobs.completed) == 0
+    assert len(jobs.dead) == 1
     jobs.flush()    
-    nt.assert_equal(len(jobs.dead), 0)
+    assert len(jobs.dead) == 0
 
 
 def test_longer():
     """Test control of longer-running jobs"""
     jobs = bg.BackgroundJobManager()
     # Sleep for long enough for the following two checks to still report the
     # job as running, but not so long that it makes the test suite noticeably
     # slower. 
     j = jobs.new(sleeper, 0.1)
-    nt.assert_equal(len(jobs.running), 1)
-    nt.assert_equal(len(jobs.completed), 0)
+    assert len(jobs.running) == 1
+    assert len(jobs.completed) == 0
     j.join()
-    nt.assert_equal(len(jobs.running), 0)
-    nt.assert_equal(len(jobs.completed), 1)
+    assert len(jobs.running) == 0
+    assert len(jobs.completed) == 1

IPython/lib/tests/test_display.py

@@ -1,266 +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
 
 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>)'))
 
 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)
-    nt.assert_equal(actual,expected)
+    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
-    nt.assert_equal(actual,expected)
+    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)
 
 #--------------------------
 # 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>)'))
 
 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
-    nt.assert_equal(actual,expected)
+    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
-    nt.assert_equal(actual,expected)
+    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
-    nt.assert_equal(actual,expected)
-    
+    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
-    nt.assert_equal(actual,expected)
-    
+    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)
 
 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')
-    nt.assert_equal(len(actual), 4, actual)
+    assert len(actual) == 4, actual
     fl = display.FileLinks(td, recursive=False)
     actual = str(fl)
     actual = actual.split('\n')
-    nt.assert_equal(len(actual), 2, actual)
+    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)
-        nt.assert_equal(len(read_wav(audio.data)), len(test_tone))
+        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)
-        nt.assert_equal(len(read_wav(audio.data)), len(test_tone))
+        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())
 
     @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)))
-            nt.assert_equal(actual_max_value, expected_max_value)
+            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)))
-            nt.assert_equal(actual_max_value, expected_max_value)
+            assert actual_max_value == expected_max_value
 
     def test_audio_data_without_normalization_raises_for_invalid_data(self):
         nt.assert_raises(
             ValueError,
             lambda: display.Audio([1.001], rate=44100, normalize=False))
         nt.assert_raises(
             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))
 
 @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_editorhooks.py

@@ -1,34 +1,32 b''
 """Test installing editor hooks"""
 import sys
 from unittest import mock
 
-import nose.tools as nt
-
 from IPython import get_ipython
 from IPython.lib import editorhooks
 
 def test_install_editor():
     called = []
     def fake_popen(*args, **kwargs):
         called.append({
             'args': args,
             'kwargs': kwargs,
         })
         return mock.MagicMock(**{'wait.return_value': 0})
     editorhooks.install_editor('foo -l {line} -f {filename}', wait=False)
     
     with mock.patch('subprocess.Popen', fake_popen):
         get_ipython().hooks.editor('the file', 64)
     
-    nt.assert_equal(len(called), 1)
-    args = called[0]['args']
-    kwargs = called[0]['kwargs']
-    
-    nt.assert_equal(kwargs, {'shell': True})
-    
-    if sys.platform.startswith('win'):
-        expected = ['foo', '-l', '64', '-f', 'the file']
+    assert len(called) == 1
+    args = called[0]["args"]
+    kwargs = called[0]["kwargs"]
+
+    assert kwargs == {"shell": True}
+
+    if sys.platform.startswith("win"):
+        expected = ["foo", "-l", "64", "-f", "the file"]
     else:
         expected = "foo -l 64 -f 'the file'"
     cmd = args[0]
-    nt.assert_equal(cmd, expected)
+    assert cmd == expected

IPython/lib/tests/test_latextools.py

@@ -1,191 +1,191 b''
 """Tests for IPython.utils.path.py"""
 # Copyright (c) IPython Development Team.
 # Distributed under the terms of the Modified BSD License.
 
 from contextlib import contextmanager
 from unittest.mock import patch
 
 import nose.tools as nt
 import pytest
 
 from IPython.lib import latextools
 from IPython.testing.decorators import (
     onlyif_cmds_exist,
     skipif_not_matplotlib,
     skip_iptest_but_not_pytest,
 )
 from IPython.utils.process import FindCmdError
 
 
 @pytest.mark.parametrize('command', ['latex', 'dvipng'])
 @skip_iptest_but_not_pytest
 def test_check_latex_to_png_dvipng_fails_when_no_cmd(command):
     def mock_find_cmd(arg):
         if arg == command:
             raise FindCmdError
 
     with patch.object(latextools, "find_cmd", mock_find_cmd):
-        assert latextools.latex_to_png_dvipng("whatever", True) == None
+        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"))

IPython/lib/tests/test_pretty.py

@@ -1,492 +1,502 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)) + ")"
 
-    nt.assert_equal(gotoutput, expectedoutput)
+    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(...)"
 
-    nt.assert_equal(gotoutput, expectedoutput)
+    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(...)"
 
-    nt.assert_equal(gotoutput, expectedoutput)
+    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)
-    nt.assert_equal(got_output, expected_output)
+    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)
-    nt.assert_equal(output, 'xxlimited.Null')
+    assert output == "xxlimited.Null"
+
 
 def test_pprint_nomod():
     """
     Test that pprint works for classes with no __module__.
     """
     output = pretty.pretty(NoModule)
-    nt.assert_equal(output, 'NoModule')
-    
+    assert output == "NoModule"
+
+
 def test_pprint_break():
     """
     Test that p.break_ produces expected output
     """
     output = pretty.pretty(Breaking())
     expected = "TG: Breaking(\n    ):"
-    nt.assert_equal(output, expected)
+    assert output == expected
 
 def test_pprint_break_repr():
     """
     Test that p.break_ is used in repr
     """
     output = pretty.pretty([[BreakingRepr()]])
     expected = "[[Breaking(\n  )]]"
-    nt.assert_equal(output, expected)
+    assert output == expected
 
     output = pretty.pretty([[BreakingRepr()]*2])
     expected = "[[Breaking(\n  ),\n  Breaking(\n  )]]"
-    nt.assert_equal(output, expected)
+    assert output == expected
 
 def test_bad_repr():
     """Don't catch bad repr errors"""
     with nt.assert_raises(ZeroDivisionError):
         pretty.pretty(BadRepr())
 
 class BadException(Exception):
     def __str__(self):
         return -1
 
 class ReallyBadRepr(object):
     __module__ = 1
     @property
     def __class__(self):
         raise ValueError("I am horrible")
     
     def __repr__(self):
         raise BadException()
 
 def test_really_bad_repr():
     with nt.assert_raises(BadException):
         pretty.pretty(ReallyBadRepr())
 
 
 class SA(object):
     pass
 
 class SB(SA):
     pass
 
 class TestsPretty(unittest.TestCase):
 
     def test_super_repr(self):
         # "<super: module_name.SA, None>"
         output = pretty.pretty(super(SA))
         self.assertRegex(output, r"<super: \S+.SA, None>")
 
         # "<super: module_name.SA, <module_name.SB at 0x...>>"
         sb = SB()
         output = pretty.pretty(super(SA, sb))
         self.assertRegex(output, r"<super: \S+.SA,\s+<\S+.SB at 0x\S+>>")
 
 
     def test_long_list(self):
         lis = list(range(10000))
         p = pretty.pretty(lis)
         last2 = p.rsplit('\n', 2)[-2:]
         self.assertEqual(last2, [' 999,', ' ...]'])
 
     def test_long_set(self):
         s = set(range(10000))
         p = pretty.pretty(s)
         last2 = p.rsplit('\n', 2)[-2:]
         self.assertEqual(last2, [' 999,', ' ...}'])
 
     def test_long_tuple(self):
         tup = tuple(range(10000))
         p = pretty.pretty(tup)
         last2 = p.rsplit('\n', 2)[-2:]
         self.assertEqual(last2, [' 999,', ' ...)'])
 
     def test_long_dict(self):
         d = { n:n for n in range(10000) }
         p = pretty.pretty(d)
         last2 = p.rsplit('\n', 2)[-2:]
         self.assertEqual(last2, [' 999: 999,', ' ...}'])
 
     def test_unbound_method(self):
         output = pretty.pretty(MyObj.somemethod)
         self.assertIn('MyObj.somemethod', output)
 
 
 class MetaClass(type):
     def __new__(cls, name):
         return type.__new__(cls, name, (object,), {'name': name})
 
     def __repr__(self):
         return "[CUSTOM REPR FOR CLASS %s]" % self.name
 
 
 ClassWithMeta = MetaClass('ClassWithMeta')
 
 
 def test_metaclass_repr():
     output = pretty.pretty(ClassWithMeta)
-    nt.assert_equal(output, "[CUSTOM REPR FOR CLASS ClassWithMeta]")
+    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)
-    nt.assert_equal(p, u)
+    assert p == u
     p = pretty.pretty([c])
-    nt.assert_equal(p, u'[%s]' % u)
+    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()
 
-    nt.assert_equal(output, '%s.MyObj' % __name__)
+    assert output == "%s.MyObj" % __name__
     nt.assert_true(type_pprint_wrapper.called)
 
 
+# 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:
-        nt.assert_equal(pretty.pretty(obj), expected)
+        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:
-        nt.assert_equal(pretty.pretty(obj), expected)
+        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:
-        nt.assert_equal(pretty.pretty(obj), expected)
+        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:
-        nt.assert_equal(pretty.pretty(obj), expected)
+        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:
-        nt.assert_equal(pretty.pretty(obj), expected)
+        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:
-        nt.assert_equal(pretty.pretty(obj), expected)
+        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)
-    nt.assert_equal(env_repr, 'environ' + dict_indented)
+    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
-    nt.assert_equal(pretty.pretty(posixpath.join), '<function posixpath.join(a, *p)>')
- 
+
+    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))
 
 
 class OrderedCounter(Counter, OrderedDict):
     'Counter that remembers the order elements are first encountered'
 
     def __repr__(self):
         return '%s(%r)' % (self.__class__.__name__, OrderedDict(self))
 
     def __reduce__(self):
         return self.__class__, (OrderedDict(self),)
 
 class MySet(set):  # Override repr of a basic type
     def __repr__(self):
         return 'mine'
 
 def test_custom_repr():
     """A custom repr should override a pretty printer for a parent type"""
     oc = OrderedCounter("abracadabra")
     nt.assert_in("OrderedCounter(OrderedDict", pretty.pretty(oc))
 
-    nt.assert_equal(pretty.pretty(MySet()), 'mine')
+    assert pretty.pretty(MySet()) == "mine"

IPython/lib/tests/test_security.py

@@ -1,26 +1,27 b''
 # coding: utf-8
 from IPython.lib import passwd
 from IPython.lib.security import passwd_check, salt_len
-import nose.tools as nt
 
 def test_passwd_structure():
-    p = passwd('passphrase')
-    algorithm, salt, hashed = p.split(':')
-    nt.assert_equal(algorithm, 'sha1')
-    nt.assert_equal(len(salt), salt_len)
-    nt.assert_equal(len(hashed), 40)
+    p = passwd("passphrase")
+    algorithm, salt, hashed = p.split(":")
+    assert algorithm == "sha1"
+    assert len(salt) == salt_len
+    assert len(hashed) == 40
 
 def test_roundtrip():
-    p = passwd('passphrase')
-    nt.assert_equal(passwd_check(p, 'passphrase'), True)
+    p = passwd("passphrase")
+    assert passwd_check(p, "passphrase") is True
+
 
 def test_bad():
     p = passwd('passphrase')
-    nt.assert_equal(passwd_check(p, p), False)
-    nt.assert_equal(passwd_check(p, 'a:b:c:d'), False)
-    nt.assert_equal(passwd_check(p, 'a:b'), False)
+    assert passwd_check(p, p) is False
+    assert passwd_check(p, "a:b:c:d") is False
+    assert passwd_check(p, "a:b") is False
+
 
 def test_passwd_check_unicode():
     # GH issue #4524
     phash = u'sha1:23862bc21dd3:7a415a95ae4580582e314072143d9c382c491e4f'
-    assert passwd_check(phash, u"łe¶ŧ←↓→")
  No newline at end of file
+    assert passwd_check(phash, u"łe¶ŧ←↓→")

IPython/utils/tests/test_capture.py

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

IPython/utils/tests/test_path.py

@@ -1,492 +1,494 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 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()
-    nt.assert_equal(home_dir, unfrozen)
+    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)
-    nt.assert_equal(home_dir, unfrozen)
+    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
-    nt.assert_equal(home_dir, os.path.realpath(env["HOME"]))
+    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)
 
 # 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()
-    nt.assert_equal(home_dir, abspath(HOME_TEST_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)
 
-    nt.assert_equal(path.get_xdg_dir(), os.path.join('somewhere', '.config'))
+    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)
-    nt.assert_equal(path.get_xdg_dir(), 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)
 
-    nt.assert_equal(path.get_xdg_dir(), 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)
 
-    nt.assert_equal(path.get_xdg_dir(), None)
+    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)
-        nt.assert_equal(evaluated_path.lower(), long_path.lower())
+        assert evaluated_path.lower() == long_path.lower()
 
 
 @dec.skip_win32
 def test_get_long_path_name():
-    p = path.get_long_path_name('/usr/local')
-    nt.assert_equal(p,'/usr/local')
+    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'):
-        nt.assert_equal(path.get_py_filename('foo.py'), 'foo.py')
-        nt.assert_equal(path.get_py_filename('foo'), 'foo.py')
-    with make_tempfile('foo'):
-        nt.assert_equal(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')
-    true_fn = 'foo with spaces.py'
+    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")
+    true_fn = "foo with spaces.py"
     with make_tempfile(true_fn):
-        nt.assert_equal(path.get_py_filename('foo with spaces'), true_fn)
-        nt.assert_equal(path.get_py_filename('foo with spaces.py'), 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'")
 
 @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.
-            nt.assert_equal(sorted(path.shellglob(patterns)),
-                            sorted(matches))
+            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():
-    nt.assert_equal(path.unescape_glob(r'\*\[\!\]\?'), '*[!]?')
-    nt.assert_equal(path.unescape_glob(r'\\*'), r'\*')
-    nt.assert_equal(path.unescape_glob(r'\\\*'), r'\*')
-    nt.assert_equal(path.unescape_glob(r'\\a'), r'\a')
-    nt.assert_equal(path.unescape_glob(r'\a'), r'\a')
+    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):
             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):
-        nt.assert_not_equal(os.stat(a).st_ino, os.stat(b).st_ino,
-                            "%r and %r do reference the same indoes" %(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):
-        nt.assert_equal(os.stat(a).st_ino, os.stat(b).st_ino,
-                        "%r and %r do not reference the same indoes" %(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:
-                nt.assert_equal(a_f.read(), b_f.read())
+                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)
-        nt.assert_equal(sorted(os.listdir(self.tempdir.name)), ['src', 'target'])
+        assert sorted(os.listdir(self.tempdir.name)) == ["src", "target"]

IPython/utils/tests/test_process.py

@@ -1,195 +1,198 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
 
 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'))
 
     
 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')
 
-    
+
+# 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:
-        nt.assert_equal(arg_split(argstr), argv)
-    
+        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:
-        nt.assert_equal(arg_split(argstr), argv)
+        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.")
 
         # 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_text.py

@@ -1,200 +1,205 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
 
 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)
-    nt.assert_equal(out, 'aaaaa  bbbbb  ccccc  ddddd\n')
+    assert out == "aaaaa  bbbbb  ccccc  ddddd\n"
     out = text.columnize(items, displaywidth=25)
-    nt.assert_equal(out, 'aaaaa  ccccc\nbbbbb  ddddd\n')
+    assert out == "aaaaa  ccccc\nbbbbb  ddddd\n"
     out = text.columnize(items, displaywidth=12)
-    nt.assert_equal(out, 'aaaaa  ccccc\nbbbbb  ddddd\n')
+    assert out == "aaaaa  ccccc\nbbbbb  ddddd\n"
     out = text.columnize(items, displaywidth=10)
-    nt.assert_equal(out, 'aaaaa\nbbbbb\nccccc\nddddd\n')
+    assert out == "aaaaa\nbbbbb\nccccc\nddddd\n"
 
     out = text.columnize(items, row_first=True, displaywidth=80)
-    nt.assert_equal(out, 'aaaaa  bbbbb  ccccc  ddddd\n')
+    assert out == "aaaaa  bbbbb  ccccc  ddddd\n"
     out = text.columnize(items, row_first=True, displaywidth=25)
-    nt.assert_equal(out, 'aaaaa  bbbbb\nccccc  ddddd\n')
+    assert out == "aaaaa  bbbbb\nccccc  ddddd\n"
     out = text.columnize(items, row_first=True, displaywidth=12)
-    nt.assert_equal(out, 'aaaaa  bbbbb\nccccc  ddddd\n')
+    assert out == "aaaaa  bbbbb\nccccc  ddddd\n"
     out = text.columnize(items, row_first=True, displaywidth=10)
-    nt.assert_equal(out, 'aaaaa\nbbbbb\nccccc\nddddd\n')
+    assert out == "aaaaa\nbbbbb\nccccc\nddddd\n"
 
     out = text.columnize(items, displaywidth=40, spread=True)
-    nt.assert_equal(out, 'aaaaa      bbbbb      ccccc      ddddd\n')
+    assert out == "aaaaa      bbbbb      ccccc      ddddd\n"
     out = text.columnize(items, displaywidth=20, spread=True)
-    nt.assert_equal(out, 'aaaaa          ccccc\nbbbbb          ddddd\n')
+    assert out == "aaaaa          ccccc\nbbbbb          ddddd\n"
     out = text.columnize(items, displaywidth=12, spread=True)
-    nt.assert_equal(out, 'aaaaa  ccccc\nbbbbb  ddddd\n')
+    assert out == "aaaaa  ccccc\nbbbbb  ddddd\n"
     out = text.columnize(items, displaywidth=10, spread=True)
-    nt.assert_equal(out, 'aaaaa\nbbbbb\nccccc\nddddd\n')
+    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)
-        nt.assert_equal(out, '\n'.join(items+['']), "row_first={0}".format(row_first))
+        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)
-        nt.assert_equal(out, '\n'.join(items+['']), "row_first={0}".format(row_first))
+        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)
-    nt.assert_equal(s, "12 3 hello")
+    assert s == "12 3 hello"
     s = f.format(' '.join(['{n//%i}'%i for i in range(1,8)]), **ns)
-    nt.assert_equal(s, "12 6 4 3 2 2 1")
+    assert s == "12 6 4 3 2 2 1"
     s = f.format('{[n//i for i in range(1,8)]}', **ns)
-    nt.assert_equal(s, "[12, 6, 4, 3, 2, 2, 1]")
+    assert s == "[12, 6, 4, 3, 2, 2, 1]"
     s = f.format("{stuff!s}", **ns)
-    nt.assert_equal(s, ns['stuff'])
+    assert s == ns["stuff"]
     s = f.format("{stuff!r}", **ns)
-    nt.assert_equal(s, repr(ns['stuff']))
-    
+    assert s == repr(ns["stuff"])
+
     # Check with unicode:
     s = f.format("{u}", **ns)
-    nt.assert_equal(s, ns['u'])
+    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)
 
 def eval_formatter_slicing_check(f):
     ns = dict(n=12, pi=math.pi, stuff='hello there', os=os)
     s = f.format(" {stuff.split()[:]} ", **ns)
-    nt.assert_equal(s, " ['hello', 'there'] ")
+    assert s == " ['hello', 'there'] "
     s = f.format(" {stuff.split()[::-1]} ", **ns)
-    nt.assert_equal(s, " ['there', 'hello'] ")
+    assert s == " ['there', 'hello'] "
     s = f.format("{stuff[::2]}", **ns)
-    nt.assert_equal(s, ns['stuff'][::2])
-    
+    assert s == ns["stuff"][::2]
+
     nt.assert_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)
-    nt.assert_equal(s, "c +9.869604")
-    
-    s = f.format('{stuff[slice(1,4)]}', **ns)
-    nt.assert_equal(s, 'ell')
+    assert s == "c +9.869604"
+
+    s = f.format("{stuff[slice(1,4)]}", **ns)
+    assert s == "ell"
 
     s = f.format("{a[:]}", a=[1, 2])
-    nt.assert_equal(s, "[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)
-    nt.assert_equal(s, "12")
+    assert s == "12"
     s = f.format("$n.real", **ns)
-    nt.assert_equal(s, "12")
+    assert s == "12"
     s = f.format("$n/{stuff[:5]}", **ns)
-    nt.assert_equal(s, "12/hello")
+    assert s == "12/hello"
     s = f.format("$n $$HOME", **ns)
-    nt.assert_equal(s, "12 $HOME")
+    assert s == "12 $HOME"
     s = f.format("${foo}", foo="HOME")
-    nt.assert_equal(s, "$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)"""
-    nt.assert_equal(text.strip_email_quotes(src), cln)
+    assert text.strip_email_quotes(src) == cln
 
 
 def test_strip_email2():
     src = '> > > list()'
     cln = 'list()'
-    nt.assert_equal(text.strip_email_quotes(src), cln)
+    assert text.strip_email_quotes(src) == cln
 
 def test_LSString():
     lss = text.LSString("abc\ndef")
-    nt.assert_equal(lss.l, ['abc', 'def'])
-    nt.assert_equal(lss.s, 'abc def')
+    assert lss.l == ["abc", "def"]
+    assert lss.s == "abc def"
     lss = text.LSString(os.getcwd())
     nt.assert_is_instance(lss.p[0], Path)
 
 def test_SList():
-    sl = text.SList(['a 11', 'b 1', 'a 2'])
-    nt.assert_equal(sl.n, 'a 11\nb 1\na 2')
-    nt.assert_equal(sl.s, 'a 11 b 1 a 2')
-    nt.assert_equal(sl.grep(lambda x: x.startswith('a')), text.SList(['a 11', 'a 2']))
-    nt.assert_equal(sl.fields(0), text.SList(['a', 'b', 'a']))
-    nt.assert_equal(sl.sort(field=1, nums=True), text.SList(['b 1', 'a 2', 'a 11']))
+    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"])