Merge pull request #4165 from takluyver/parametric-begone

Remove use of parametric tests

As discussed on the mailing list, our parametric tests system has been the source of various problems, and we've decided to get rid of it.

IPython/core/tests/test_magic_arguments.py

@@ -6,12 +6,11 b''
 # The full license is in the file COPYING.txt, distributed with this software.
 #-----------------------------------------------------------------------------
 
-from nose.tools import assert_equal, assert_true
+from nose.tools import assert_equal
 
 from IPython.external import argparse
 from IPython.core.magic_arguments import (argument, argument_group, kwds,
     magic_arguments, parse_argstring, real_name)
-from IPython.testing.decorators import parametric
 
 
 @magic_arguments()
@@ -74,48 +73,46 b' def foo(self, args):'
     return parse_argstring(foo, args)
 
 
-@parametric
 def test_magic_arguments():
-    # Ideally, these would be doctests, but I could not get it to work.
-    yield assert_equal(magic_foo1.__doc__, '%foo1 [-f FOO]\n\n A docstring.\n\noptional arguments:\n  -f FOO, --foo FOO  an argument\n')
-    yield assert_equal(getattr(magic_foo1, 'argcmd_name', None), None)
-    yield assert_equal(real_name(magic_foo1), 'foo1')
-    yield assert_equal(magic_foo1(None, ''), argparse.Namespace(foo=None))
-    yield assert_true(hasattr(magic_foo1, 'has_arguments'))
-
-    yield assert_equal(magic_foo2.__doc__, '%foo2\n\n A docstring.\n')
-    yield assert_equal(getattr(magic_foo2, 'argcmd_name', None), None)
-    yield assert_equal(real_name(magic_foo2), 'foo2')
-    yield assert_equal(magic_foo2(None, ''), argparse.Namespace())
-    yield assert_true(hasattr(magic_foo2, 'has_arguments'))
-
-    yield assert_equal(magic_foo3.__doc__, '%foo3 [-f FOO] [-b BAR] [-z BAZ]\n\n A docstring.\n\noptional arguments:\n  -f FOO, --foo FOO  an argument\n\nGroup:\n  -b BAR, --bar BAR  a grouped argument\n\nSecond Group:\n  -z BAZ, --baz BAZ  another grouped argument\n')
-    yield assert_equal(getattr(magic_foo3, 'argcmd_name', None), None)
-    yield assert_equal(real_name(magic_foo3), 'foo3')
-    yield assert_equal(magic_foo3(None, ''),
+    assert_equal(magic_foo1.__doc__, '%foo1 [-f FOO]\n\n A docstring.\n\noptional arguments:\n  -f FOO, --foo FOO  an argument\n')
+    assert_equal(getattr(magic_foo1, 'argcmd_name', None), None)
+    assert_equal(real_name(magic_foo1), 'foo1')
+    assert_equal(magic_foo1(None, ''), argparse.Namespace(foo=None))
+    assert hasattr(magic_foo1, 'has_arguments')
+
+    assert_equal(magic_foo2.__doc__, '%foo2\n\n A docstring.\n')
+    assert_equal(getattr(magic_foo2, 'argcmd_name', None), None)
+    assert_equal(real_name(magic_foo2), 'foo2')
+    assert_equal(magic_foo2(None, ''), argparse.Namespace())
+    assert hasattr(magic_foo2, 'has_arguments')
+
+    assert_equal(magic_foo3.__doc__, '%foo3 [-f FOO] [-b BAR] [-z BAZ]\n\n A docstring.\n\noptional arguments:\n  -f FOO, --foo FOO  an argument\n\nGroup:\n  -b BAR, --bar BAR  a grouped argument\n\nSecond Group:\n  -z BAZ, --baz BAZ  another grouped argument\n')
+    assert_equal(getattr(magic_foo3, 'argcmd_name', None), None)
+    assert_equal(real_name(magic_foo3), 'foo3')
+    assert_equal(magic_foo3(None, ''),
                        argparse.Namespace(bar=None, baz=None, foo=None))
-    yield assert_true(hasattr(magic_foo3, 'has_arguments'))
-
-    yield assert_equal(magic_foo4.__doc__, '%foo4 [-f FOO]\n\n A docstring.\n\noptional arguments:\n  -f FOO, --foo FOO  an argument\n')
-    yield assert_equal(getattr(magic_foo4, 'argcmd_name', None), None)
-    yield assert_equal(real_name(magic_foo4), 'foo4')
-    yield assert_equal(magic_foo4(None, ''), argparse.Namespace())
-    yield assert_true(hasattr(magic_foo4, 'has_arguments'))
-
-    yield assert_equal(magic_foo5.__doc__, '%frobnicate [-f FOO]\n\n A docstring.\n\noptional arguments:\n  -f FOO, --foo FOO  an argument\n')
-    yield assert_equal(getattr(magic_foo5, 'argcmd_name', None), 'frobnicate')
-    yield assert_equal(real_name(magic_foo5), 'frobnicate')
-    yield assert_equal(magic_foo5(None, ''), argparse.Namespace(foo=None))
-    yield assert_true(hasattr(magic_foo5, 'has_arguments'))
-
-    yield assert_equal(magic_magic_foo.__doc__, '%magic_foo [-f FOO]\n\n A docstring.\n\noptional arguments:\n  -f FOO, --foo FOO  an argument\n')
-    yield assert_equal(getattr(magic_magic_foo, 'argcmd_name', None), None)
-    yield assert_equal(real_name(magic_magic_foo), 'magic_foo')
-    yield assert_equal(magic_magic_foo(None, ''), argparse.Namespace(foo=None))
-    yield assert_true(hasattr(magic_magic_foo, 'has_arguments'))
-
-    yield assert_equal(foo.__doc__, '%foo [-f FOO]\n\n A docstring.\n\noptional arguments:\n  -f FOO, --foo FOO  an argument\n')
-    yield assert_equal(getattr(foo, 'argcmd_name', None), None)
-    yield assert_equal(real_name(foo), 'foo')
-    yield assert_equal(foo(None, ''), argparse.Namespace(foo=None))
-    yield assert_true(hasattr(foo, 'has_arguments'))
+    assert hasattr(magic_foo3, 'has_arguments')
+
+    assert_equal(magic_foo4.__doc__, '%foo4 [-f FOO]\n\n A docstring.\n\noptional arguments:\n  -f FOO, --foo FOO  an argument\n')
+    assert_equal(getattr(magic_foo4, 'argcmd_name', None), None)
+    assert_equal(real_name(magic_foo4), 'foo4')
+    assert_equal(magic_foo4(None, ''), argparse.Namespace())
+    assert hasattr(magic_foo4, 'has_arguments')
+
+    assert_equal(magic_foo5.__doc__, '%frobnicate [-f FOO]\n\n A docstring.\n\noptional arguments:\n  -f FOO, --foo FOO  an argument\n')
+    assert_equal(getattr(magic_foo5, 'argcmd_name', None), 'frobnicate')
+    assert_equal(real_name(magic_foo5), 'frobnicate')
+    assert_equal(magic_foo5(None, ''), argparse.Namespace(foo=None))
+    assert hasattr(magic_foo5, 'has_arguments')
+
+    assert_equal(magic_magic_foo.__doc__, '%magic_foo [-f FOO]\n\n A docstring.\n\noptional arguments:\n  -f FOO, --foo FOO  an argument\n')
+    assert_equal(getattr(magic_magic_foo, 'argcmd_name', None), None)
+    assert_equal(real_name(magic_magic_foo), 'magic_foo')
+    assert_equal(magic_magic_foo(None, ''), argparse.Namespace(foo=None))
+    assert hasattr(magic_magic_foo, 'has_arguments')
+
+    assert_equal(foo.__doc__, '%foo [-f FOO]\n\n A docstring.\n\noptional arguments:\n  -f FOO, --foo FOO  an argument\n')
+    assert_equal(getattr(foo, 'argcmd_name', None), None)
+    assert_equal(real_name(foo), 'foo')
+    assert_equal(foo(None, ''), argparse.Namespace(foo=None))
+    assert hasattr(foo, 'has_arguments')

IPython/core/tests/test_prefilter.py

@@ -6,7 +6,6 b''
 import nose.tools as nt
 
 from IPython.core.prefilter import AutocallChecker
-from IPython.testing import decorators as dec
 from IPython.testing.globalipapp import get_ipython
 
 #-----------------------------------------------------------------------------
@@ -14,7 +13,6 b' from IPython.testing.globalipapp import get_ipython'
 #-----------------------------------------------------------------------------
 ip = get_ipython()
 
[e-mail]
 def test_prefilter():
     """Test user input conversions"""
 
@@ -23,19 +21,18 b' def test_prefilter():'
              ]
 
     for raw, correct in pairs:
-        yield nt.assert_equal(ip.prefilter(raw), correct)
+        nt.assert_equal(ip.prefilter(raw), correct)
 
 
[e-mail]
 def test_autocall_binops():
     """See https://github.com/ipython/ipython/issues/81"""
     ip.magic('autocall 2')
     f = lambda x: x
     ip.user_ns['f'] = f
     try:
-        yield nt.assert_equal(ip.prefilter('f 1'),'f(1)')
+        nt.assert_equal(ip.prefilter('f 1'),'f(1)')
         for t in ['f +1', 'f -1']:
-            yield nt.assert_equal(ip.prefilter(t), t)
+            nt.assert_equal(ip.prefilter(t), t)
 
         # Run tests again with a more permissive exclude_regexp, which will
         # allow transformation of binary operations ('f -1' -> 'f(-1)').
@@ -47,8 +44,8 b' def test_autocall_binops():'
             ac.exclude_regexp = r'^[,&^\|\*/]|^is |^not |^in |^and |^or '
             pm.sort_checkers()
 
-            yield nt.assert_equal(ip.prefilter('f -1'), 'f(-1)')
-            yield nt.assert_equal(ip.prefilter('f +1'), 'f(+1)')
+            nt.assert_equal(ip.prefilter('f -1'), 'f(-1)')
+            nt.assert_equal(ip.prefilter('f +1'), 'f(+1)')
         finally:
             pm.unregister_checker(ac)
     finally:
@@ -56,7 +53,6 b' def test_autocall_binops():'
         del ip.user_ns['f']
 
 
[e-mail]
 def test_issue_114():
     """Check that multiline string literals don't expand as magic
     see http://github.com/ipython/ipython/issues/114"""
@@ -70,7 +66,7 b' def test_issue_114():'
     try:
         for mgk in ip.magics_manager.lsmagic()['line']:
             raw = template % mgk
-            yield nt.assert_equal(ip.prefilter(raw), raw)
+            nt.assert_equal(ip.prefilter(raw), raw)
     finally:
         ip.prefilter_manager.multi_line_specials = msp
 

IPython/core/tests/test_pylabtools.py

@@ -24,7 +24,6 b' import numpy as np'
 
 # Our own imports
 from IPython.core.interactiveshell import InteractiveShell
-from IPython.testing import decorators as dec
 from .. import pylabtools as pt
 
 #-----------------------------------------------------------------------------
@@ -39,11 +38,10 b' from .. import pylabtools as pt'
 # Classes and functions
 #-----------------------------------------------------------------------------
 
[e-mail]
 def test_figure_to_svg():
     # simple empty-figure test
     fig = plt.figure()
-    yield nt.assert_equal(pt.print_figure(fig, 'svg'), None)
+    nt.assert_equal(pt.print_figure(fig, 'svg'), None)
 
     plt.close('all')
 
@@ -53,7 +51,7 b' def test_figure_to_svg():'
     ax.plot([1,2,3])
     plt.draw()
     svg = pt.print_figure(fig, 'svg')[:100].lower()
-    yield nt.assert_true('doctype svg' in svg)
+    nt.assert_in('doctype svg', svg)
 
 
 def test_import_pylab():

IPython/external/mathjax.py

@@ -275,7 +275,7 b' def main() :'
 if __name__ == '__main__' :
     sys.exit(main())
 
-__all__ = ['install_mathjax', 'main', 'dest']
+__all__ = ['install_mathjax', 'main', 'default_dest']
 
 """
 Test notes:

IPython/kernel/tests/test_launcher.py

@@ -20,14 +20,12 b' Authors'
 import nose.tools as nt
 
 # Our own imports
-from IPython.testing import decorators as dec
 from IPython.kernel.launcher import swallow_argv
 
 #-----------------------------------------------------------------------------
 # Classes and functions
 #-----------------------------------------------------------------------------
 
[e-mail]
 def test_swallow_argv():
     tests = [
         # expected  , argv       , aliases, flags
@@ -56,5 +54,5 b' def test_swallow_argv():'
             "expected : %r" % expected,
             "returned : %r" % stripped,
         ])
-        yield nt.assert_equal(expected, stripped, message)
+        nt.assert_equal(expected, stripped, message)
 

IPython/kernel/tests/test_message_spec.py

@@ -15,7 +15,6 b' import nose.tools as nt'
 
 from IPython.kernel import KernelManager
 
-from IPython.testing import decorators as dec
 from IPython.utils.traitlets import (
     HasTraits, TraitError, Bool, Unicode, Dict, Integer, List, Enum, Any,
 )
@@ -60,7 +59,7 b' def flush_channels(kc=None):'
             except Empty:
                 break
             else:
-                list(validate_message(msg))
+                validate_message(msg)
 
 
 def execute(code='', kc=None, **kwargs):
@@ -69,14 +68,14 b" def execute(code='', kc=None, **kwargs):"
         kc = KC
     msg_id = kc.execute(code=code, **kwargs)
     reply = kc.get_shell_msg(timeout=TIMEOUT)
-    list(validate_message(reply, 'execute_reply', msg_id))
+    validate_message(reply, 'execute_reply', msg_id)
     busy = kc.get_iopub_msg(timeout=TIMEOUT)
-    list(validate_message(busy, 'status', msg_id))
+    validate_message(busy, 'status', msg_id)
     nt.assert_equal(busy['content']['execution_state'], 'busy')
     
     if not kwargs.get('silent'):
         pyin = kc.get_iopub_msg(timeout=TIMEOUT)
-        list(validate_message(pyin, 'pyin', msg_id))
+        validate_message(pyin, 'pyin', msg_id)
         nt.assert_equal(pyin['content']['code'], code)
     
     return msg_id, reply['content']
@@ -101,14 +100,14 b' class Reference(HasTraits):'
     def check(self, d):
         """validate a dict against our traits"""
         for key in self.trait_names():
-            yield nt.assert_true(key in d, "Missing key: %r, should be found in %s" % (key, d))
+            nt.assert_in(key, d)
             # FIXME: always allow None, probably not a good idea
             if d[key] is None:
                 continue
             try:
                 setattr(self, key, d[key])
             except TraitError as e:
-                yield nt.assert_true(False, str(e))
+                nt.assert_true(False, str(e))
 
 
 class RMessage(Reference):
@@ -133,14 +132,11 b' class ExecuteReply(Reference):'
     status = Enum((u'ok', u'error'))
     
     def check(self, d):
-        for tst in Reference.check(self, d):
-            yield tst
+        Reference.check(self, d)
         if d['status'] == 'ok':
-            for tst in ExecuteReplyOkay().check(d):
-                yield tst
+            ExecuteReplyOkay().check(d)
         elif d['status'] == 'error':
-            for tst in ExecuteReplyError().check(d):
-                yield tst
+            ExecuteReplyError().check(d)
 
 
 class ExecuteReplyOkay(Reference):
@@ -177,11 +173,9 b' class OInfoReply(Reference):'
     source = Unicode()
     
     def check(self, d):
-        for tst in Reference.check(self, d):
-            yield tst
+        Reference.check(self, d)
         if d['argspec'] is not None:
-            for tst in ArgSpec().check(d['argspec']):
-                yield tst
+            ArgSpec().check(d['argspec'])
 
 
 class ArgSpec(Reference):
@@ -212,10 +206,8 b' class KernelInfoReply(Reference):'
 
     def _ipython_version_changed(self, name, old, new):
         for v in new:
-            nt.assert_true(
-                isinstance(v, int) or isinstance(v, basestring),
-                'expected int or string as version component, got {0!r}'
-                .format(v))
+            assert isinstance(v, int) or isinstance(v, basestring), \
+            'expected int or string as version component, got {0!r}'.format(v)
 
 
 # IOPub messages
@@ -241,8 +233,8 b' class DisplayData(Reference):'
     data = Dict()
     def _data_changed(self, name, old, new):
         for k,v in new.iteritems():
-            nt.assert_true(mime_pat.match(k))
-            nt.assert_true(isinstance(v, basestring), "expected string data, got %r" % v)
+            assert mime_pat.match(k)
+            nt.assert_is_instance(v, basestring)
 
 
 class PyOut(Reference):
@@ -250,8 +242,8 b' class PyOut(Reference):'
     data = Dict()
     def _data_changed(self, name, old, new):
         for k,v in new.iteritems():
-            nt.assert_true(mime_pat.match(k))
-            nt.assert_true(isinstance(v, basestring), "expected string data, got %r" % v)
+            assert mime_pat.match(k)
+            nt.assert_is_instance(v, basestring)
 
 
 references = {
@@ -282,13 +274,12 b' def validate_message(msg, msg_type=None, parent=None):'
     """
     RMessage().check(msg)
     if msg_type:
-        yield nt.assert_equal(msg['msg_type'], msg_type)
+        nt.assert_equal(msg['msg_type'], msg_type)
     if parent:
-        yield nt.assert_equal(msg['parent_header']['msg_id'], parent)
+        nt.assert_equal(msg['parent_header']['msg_id'], parent)
     content = msg['content']
     ref = references[msg['msg_type']]
-    for tst in ref.check(content):
-        yield tst
+    ref.check(content)
 
 
 #-----------------------------------------------------------------------------
@@ -297,54 +288,47 b' def validate_message(msg, msg_type=None, parent=None):'
 
 # Shell channel
 
[e-mail]
 def test_execute():
     flush_channels()
     
     msg_id = KC.execute(code='x=1')
     reply = KC.get_shell_msg(timeout=TIMEOUT)
-    for tst in validate_message(reply, 'execute_reply', msg_id):
-        yield tst
+    validate_message(reply, 'execute_reply', msg_id)
 
 
[e-mail]
 def test_execute_silent():
     flush_channels()
     msg_id, reply = execute(code='x=1', silent=True)
     
     # flush status=idle
     status = KC.iopub_channel.get_msg(timeout=TIMEOUT)
-    for tst in validate_message(status, 'status', msg_id):
-        yield tst
+    validate_message(status, 'status', msg_id)
     nt.assert_equal(status['content']['execution_state'], 'idle')
 
-    yield nt.assert_raises(Empty, KC.iopub_channel.get_msg, timeout=0.1)
+    nt.assert_raises(Empty, KC.iopub_channel.get_msg, timeout=0.1)
     count = reply['execution_count']
     
     msg_id, reply = execute(code='x=2', silent=True)
     
     # flush status=idle
     status = KC.iopub_channel.get_msg(timeout=TIMEOUT)
-    for tst in validate_message(status, 'status', msg_id):
-        yield tst
-    yield nt.assert_equal(status['content']['execution_state'], 'idle')
+    validate_message(status, 'status', msg_id)
+    nt.assert_equal(status['content']['execution_state'], 'idle')
     
-    yield nt.assert_raises(Empty, KC.iopub_channel.get_msg, timeout=0.1)
+    nt.assert_raises(Empty, KC.iopub_channel.get_msg, timeout=0.1)
     count_2 = reply['execution_count']
-    yield nt.assert_equal(count_2, count)
+    nt.assert_equal(count_2, count)
 
 
[e-mail]
 def test_execute_error():
     flush_channels()
     
     msg_id, reply = execute(code='1/0')
-    yield nt.assert_equal(reply['status'], 'error')
-    yield nt.assert_equal(reply['ename'], 'ZeroDivisionError')
+    nt.assert_equal(reply['status'], 'error')
+    nt.assert_equal(reply['ename'], 'ZeroDivisionError')
     
     pyerr = KC.iopub_channel.get_msg(timeout=TIMEOUT)
-    for tst in validate_message(pyerr, 'pyerr', msg_id):
-        yield tst
+    validate_message(pyerr, 'pyerr', msg_id)
 
 
 def test_execute_inc():
@@ -405,17 +389,14 b' def test_user_expressions_fail():'
     nt.assert_equal(foo['ename'], 'NameError')
 
 
[e-mail]
 def test_oinfo():
     flush_channels()
 
     msg_id = KC.object_info('a')
     reply = KC.get_shell_msg(timeout=TIMEOUT)
-    for tst in validate_message(reply, 'object_info_reply', msg_id):
-        yield tst
+    validate_message(reply, 'object_info_reply', msg_id)
 
 
[e-mail]
 def test_oinfo_found():
     flush_channels()
 
@@ -423,15 +404,13 b' def test_oinfo_found():'
     
     msg_id = KC.object_info('a')
     reply = KC.get_shell_msg(timeout=TIMEOUT)
-    for tst in validate_message(reply, 'object_info_reply', msg_id):
-        yield tst
+    validate_message(reply, 'object_info_reply', msg_id)
     content = reply['content']
-    yield nt.assert_true(content['found'])
+    assert content['found']
     argspec = content['argspec']
-    yield nt.assert_true(argspec is None, "didn't expect argspec dict, got %r" % argspec)
+    nt.assert_is(argspec, None)
 
 
[e-mail]
 def test_oinfo_detail():
     flush_channels()
 
@@ -439,28 +418,24 b' def test_oinfo_detail():'
     
     msg_id = KC.object_info('ip.object_inspect', detail_level=2)
     reply = KC.get_shell_msg(timeout=TIMEOUT)
-    for tst in validate_message(reply, 'object_info_reply', msg_id):
-        yield tst
+    validate_message(reply, 'object_info_reply', msg_id)
     content = reply['content']
-    yield nt.assert_true(content['found'])
+    assert content['found']
     argspec = content['argspec']
-    yield nt.assert_true(isinstance(argspec, dict), "expected non-empty argspec dict, got %r" % argspec)
-    yield nt.assert_equal(argspec['defaults'], [0])
+    nt.assert_is_instance(argspec, dict, "expected non-empty argspec dict, got %r" % argspec)
+    nt.assert_equal(argspec['defaults'], [0])
 
 
[e-mail]
 def test_oinfo_not_found():
     flush_channels()
 
     msg_id = KC.object_info('dne')
     reply = KC.get_shell_msg(timeout=TIMEOUT)
-    for tst in validate_message(reply, 'object_info_reply', msg_id):
-        yield tst
+    validate_message(reply, 'object_info_reply', msg_id)
     content = reply['content']
-    yield nt.assert_false(content['found'])
+    nt.assert_false(content['found'])
 
 
[e-mail]
 def test_complete():
     flush_channels()
 
@@ -468,49 +443,42 b' def test_complete():'
     
     msg_id = KC.complete('al', 'al', 2)
     reply = KC.get_shell_msg(timeout=TIMEOUT)
-    for tst in validate_message(reply, 'complete_reply', msg_id):
-        yield tst
+    validate_message(reply, 'complete_reply', msg_id)
     matches = reply['content']['matches']
     for name in ('alpha', 'albert'):
-        yield nt.assert_true(name in matches, "Missing match: %r" % name)
+        nt.assert_in(name, matches)
 
 
[e-mail]
 def test_kernel_info_request():
     flush_channels()
 
     msg_id = KC.kernel_info()
     reply = KC.get_shell_msg(timeout=TIMEOUT)
-    for tst in validate_message(reply, 'kernel_info_reply', msg_id):
-        yield tst
+    validate_message(reply, 'kernel_info_reply', msg_id)
 
 
 # IOPub channel
 
 
[e-mail]
 def test_stream():
     flush_channels()
 
     msg_id, reply = execute("print('hi')")
 
     stdout = KC.iopub_channel.get_msg(timeout=TIMEOUT)
-    for tst in validate_message(stdout, 'stream', msg_id):
-        yield tst
+    validate_message(stdout, 'stream', msg_id)
     content = stdout['content']
-    yield nt.assert_equal(content['name'], u'stdout')
-    yield nt.assert_equal(content['data'], u'hi\n')
+    nt.assert_equal(content['name'], u'stdout')
+    nt.assert_equal(content['data'], u'hi\n')
 
 
[e-mail]
 def test_display_data():
     flush_channels()
 
     msg_id, reply = execute("from IPython.core.display import display; display(1)")
     
     display = KC.iopub_channel.get_msg(timeout=TIMEOUT)
-    for tst in validate_message(display, 'display_data', parent=msg_id):
-        yield tst
+    validate_message(display, 'display_data', parent=msg_id)
     data = display['content']['data']
-    yield nt.assert_equal(data['text/plain'], u'1')
+    nt.assert_equal(data['text/plain'], u'1')
 

IPython/kernel/tests/test_public_api.py

@@ -14,8 +14,6 b' Authors'
 
 import nose.tools as nt
 
-from IPython.testing import decorators as dec
-
 from IPython.kernel import launcher, connect
 from IPython import kernel
 
@@ -23,25 +21,21 b' from IPython import kernel'
 # Classes and functions
 #-----------------------------------------------------------------------------
 
[e-mail]
 def test_kms():
     for base in ("", "Multi"):
         KM = base + "KernelManager"
-        yield nt.assert_true(KM in dir(kernel), KM)
+        nt.assert_in(KM, dir(kernel))
 
[e-mail]
 def test_kcs():
     for base in ("", "Blocking"):
         KM = base + "KernelClient"
-        yield nt.assert_true(KM in dir(kernel), KM)
+        nt.assert_in(KM, dir(kernel))
 
[e-mail]
 def test_launcher():
     for name in launcher.__all__:
-        yield nt.assert_true(name in dir(kernel), name)
+        nt.assert_in(name, dir(kernel))
 
[e-mail]
 def test_connect():
     for name in connect.__all__:
-        yield nt.assert_true(name in dir(kernel), name)
+        nt.assert_in(name, dir(kernel))
 

IPython/kernel/zmq/tests/test_serialize.py

@@ -46,7 +46,6 b" DTYPES = ('uint8', 'float64', 'int32', [('g', 'float32')], '|S10')"
 # Tests
 #-------------------------------------------------------------------------------
 
[e-mail]
 def test_roundtrip_simple():
     for obj in [
         'hello',
@@ -55,18 +54,16 b' def test_roundtrip_simple():'
         (b'123', 'hello'),
     ]:
         obj2 = roundtrip(obj)
-        yield nt.assert_equals(obj, obj2)
+        nt.assert_equal(obj, obj2)
 
[e-mail]
 def test_roundtrip_nested():
     for obj in [
         dict(a=range(5), b={1:b'hello'}),
         [range(5),[range(3),(1,[b'whoda'])]],
     ]:
         obj2 = roundtrip(obj)
-        yield nt.assert_equals(obj, obj2)
+        nt.assert_equal(obj, obj2)
 
[e-mail]
 def test_roundtrip_buffered():
     for obj in [
         dict(a=b"x"*1025),
@@ -74,10 +71,10 b' def test_roundtrip_buffered():'
         [b"hello"*501, 1,2,3]
     ]:
         bufs = serialize_object(obj)
-        yield nt.assert_equals(len(bufs), 2)
+        nt.assert_equal(len(bufs), 2)
         obj2, remainder = unserialize_object(bufs)
-        yield nt.assert_equals(remainder, [])
-        yield nt.assert_equals(obj, obj2)
+        nt.assert_equal(remainder, [])
+        nt.assert_equal(obj, obj2)
 
 def _scrub_nan(A):
     """scrub nans out of empty arrays
@@ -93,7 +90,6 b' def _scrub_nan(A):'
                 # e.g. str dtype
                 pass
 
[e-mail]
 @dec.skip_without('numpy')
 def test_numpy():
     import numpy
@@ -104,12 +100,11 b' def test_numpy():'
             _scrub_nan(A)
             bufs = serialize_object(A)
             B, r = unserialize_object(bufs)
-            yield nt.assert_equals(r, [])
-            yield nt.assert_equals(A.shape, B.shape)
-            yield nt.assert_equals(A.dtype, B.dtype)
-            yield assert_array_equal(A,B)
+            nt.assert_equal(r, [])
+            nt.assert_equal(A.shape, B.shape)
+            nt.assert_equal(A.dtype, B.dtype)
+            assert_array_equal(A,B)
 
[e-mail]
 @dec.skip_without('numpy')
 def test_recarray():
     import numpy
@@ -124,12 +119,11 b' def test_recarray():'
             
             bufs = serialize_object(A)
             B, r = unserialize_object(bufs)
-            yield nt.assert_equals(r, [])
-            yield nt.assert_equals(A.shape, B.shape)
-            yield nt.assert_equals(A.dtype, B.dtype)
-            yield assert_array_equal(A,B)
+            nt.assert_equal(r, [])
+            nt.assert_equal(A.shape, B.shape)
+            nt.assert_equal(A.dtype, B.dtype)
+            assert_array_equal(A,B)
 
[e-mail]
 @dec.skip_without('numpy')
 def test_numpy_in_seq():
     import numpy
@@ -140,15 +134,14 b' def test_numpy_in_seq():'
             _scrub_nan(A)
             bufs = serialize_object((A,1,2,b'hello'))
             canned = pickle.loads(bufs[0])
-            yield nt.assert_true(canned[0], CannedArray)
+            nt.assert_is_instance(canned[0], CannedArray)
             tup, r = unserialize_object(bufs)
             B = tup[0]
-            yield nt.assert_equals(r, [])
-            yield nt.assert_equals(A.shape, B.shape)
-            yield nt.assert_equals(A.dtype, B.dtype)
-            yield assert_array_equal(A,B)
+            nt.assert_equal(r, [])
+            nt.assert_equal(A.shape, B.shape)
+            nt.assert_equal(A.dtype, B.dtype)
+            assert_array_equal(A,B)
 
[e-mail]
 @dec.skip_without('numpy')
 def test_numpy_in_dict():
     import numpy
@@ -159,27 +152,25 b' def test_numpy_in_dict():'
             _scrub_nan(A)
             bufs = serialize_object(dict(a=A,b=1,c=range(20)))
             canned = pickle.loads(bufs[0])
-            yield nt.assert_true(canned['a'], CannedArray)
+            nt.assert_is_instance(canned['a'], CannedArray)
             d, r = unserialize_object(bufs)
             B = d['a']
-            yield nt.assert_equals(r, [])
-            yield nt.assert_equals(A.shape, B.shape)
-            yield nt.assert_equals(A.dtype, B.dtype)
-            yield assert_array_equal(A,B)
+            nt.assert_equal(r, [])
+            nt.assert_equal(A.shape, B.shape)
+            nt.assert_equal(A.dtype, B.dtype)
+            assert_array_equal(A,B)
 
[e-mail]
 def test_class():
     @interactive
     class C(object):
         a=5
     bufs = serialize_object(dict(C=C))
     canned = pickle.loads(bufs[0])
-    yield nt.assert_true(canned['C'], CannedClass)
+    nt.assert_is_instance(canned['C'], CannedClass)
     d, r = unserialize_object(bufs)
     C2 = d['C']
-    yield nt.assert_equal(C2.a, C.a)
+    nt.assert_equal(C2.a, C.a)
 
[e-mail]
 def test_class_oldstyle():
     @interactive
     class C:
@@ -187,42 +178,38 b' def test_class_oldstyle():'
     
     bufs = serialize_object(dict(C=C))
     canned = pickle.loads(bufs[0])
-    yield nt.assert_true(isinstance(canned['C'], CannedClass))
+    nt.assert_is_instance(canned['C'], CannedClass)
     d, r = unserialize_object(bufs)
     C2 = d['C']
-    yield nt.assert_equal(C2.a, C.a)
+    nt.assert_equal(C2.a, C.a)
 
[e-mail]
 def test_tuple():
     tup = (lambda x:x, 1)
     bufs = serialize_object(tup)
     canned = pickle.loads(bufs[0])
-    yield nt.assert_true(isinstance(canned, tuple))
+    nt.assert_is_instance(canned, tuple)
     t2, r = unserialize_object(bufs)
-    yield nt.assert_equal(t2[0](t2[1]), tup[0](tup[1]))
+    nt.assert_equal(t2[0](t2[1]), tup[0](tup[1]))
 
 point = namedtuple('point', 'x y')
 
[e-mail]
 def test_namedtuple():
     p = point(1,2)
     bufs = serialize_object(p)
     canned = pickle.loads(bufs[0])
-    yield nt.assert_true(isinstance(canned, point))
+    nt.assert_is_instance(canned, point)
     p2, r = unserialize_object(bufs, globals())
-    yield nt.assert_equal(p2.x, p.x)
-    yield nt.assert_equal(p2.y, p.y)
+    nt.assert_equal(p2.x, p.x)
+    nt.assert_equal(p2.y, p.y)
 
[e-mail]
 def test_list():
     lis = [lambda x:x, 1]
     bufs = serialize_object(lis)
     canned = pickle.loads(bufs[0])
-    yield nt.assert_true(isinstance(canned, list))
+    nt.assert_is_instance(canned, list)
     l2, r = unserialize_object(bufs)
-    yield nt.assert_equal(l2[0](l2[1]), lis[0](lis[1]))
+    nt.assert_equal(l2[0](l2[1]), lis[0](lis[1]))
 
[e-mail]
 def test_class_inheritance():
     @interactive
     class C(object):
@@ -234,8 +221,8 b' def test_class_inheritance():'
     
     bufs = serialize_object(dict(D=D))
     canned = pickle.loads(bufs[0])
-    yield nt.assert_true(canned['D'], CannedClass)
+    nt.assert_is_instance(canned['D'], CannedClass)
     d, r = unserialize_object(bufs)
     D2 = d['D']
-    yield nt.assert_equal(D2.a, D.a)
-    yield nt.assert_equal(D2.b, D.b)
+    nt.assert_equal(D2.a, D.a)
+    nt.assert_equal(D2.b, D.b)

IPython/nbconvert/filters/tests/test_ansi.py

@@ -39,7 +39,7 b' class TestAnsi(TestsBase):'
             'hello' : 'hello'}
 
         for inval, outval in correct_outputs.items():
-            yield self._try_strip_ansi(inval, outval)
+            self._try_strip_ansi(inval, outval)
 
 
     def _try_strip_ansi(self, inval, outval):
@@ -58,7 +58,7 b' class TestAnsi(TestsBase):'
             'hello' : 'hello'}
 
         for inval, outval in correct_outputs.items():
-            yield self._try_ansi2html(inval, outval)
+            self._try_ansi2html(inval, outval)
 
 
     def _try_ansi2html(self, inval, outval):
@@ -77,7 +77,7 b' class TestAnsi(TestsBase):'
             'hello' : 'hello'}
 
         for inval, outval in correct_outputs.items():
-            yield self._try_ansi2latex(inval, outval)
+            self._try_ansi2latex(inval, outval)
 
 
     def _try_ansi2latex(self, inval, outval):

IPython/nbconvert/filters/tests/test_highlight.py

@@ -49,13 +49,13 b' class TestHighlight(TestsBase):'
     def test_highlight2html(self):
         """highlight2html test"""
         for index, test in enumerate(self.tests):
-            yield self._try_highlight(highlight2html, test, self.tokens[index])
+            self._try_highlight(highlight2html, test, self.tokens[index])
 
 
     def test_highlight2latex(self):
         """highlight2latex test"""
         for index, test in enumerate(self.tests):
-            yield self._try_highlight(highlight2latex, test, self.tokens[index])
+            self._try_highlight(highlight2latex, test, self.tokens[index])
 
 
     def _try_highlight(self, method, test, tokens):

IPython/nbconvert/filters/tests/test_latex.py

@@ -35,7 +35,7 b' class TestLatex(TestsBase):'
             ('','')]
 
         for test in tests:
-            yield self._try_escape_latex(test[0], test[1])
+            self._try_escape_latex(test[0], test[1])
 
 
     def _try_escape_latex(self, test, result):
@@ -56,7 +56,7 b' class TestLatex(TestsBase):'
             ('','')]
 
         for test in tests:
-            yield self._try_strip_math_space(test[0], test[1])
+            self._try_strip_math_space(test[0], test[1])
 
 
     def _try_strip_math_space(self, test, result):

IPython/nbconvert/filters/tests/test_markdown.py

@@ -61,14 +61,14 b' class TestMarkdown(TestsBase):'
     def test_markdown2latex(self):
         """markdown2latex test"""
         for index, test in enumerate(self.tests):
-            yield self._try_markdown(markdown2latex, test, self.tokens[index])
+            self._try_markdown(markdown2latex, test, self.tokens[index])
 
 
     @dec.onlyif_cmds_exist('pandoc')
     def test_markdown2html(self):
         """markdown2html test"""
         for index, test in enumerate(self.tests):
-            yield self._try_markdown(markdown2html, test, self.tokens[index])
+            self._try_markdown(markdown2html, test, self.tokens[index])
 
 
     @dec.onlyif_cmds_exist('pandoc')
@@ -81,7 +81,7 b' class TestMarkdown(TestsBase):'
         tokens[1] = r'\*\*test'
 
         for index, test in enumerate(self.tests):
-            yield self._try_markdown(markdown2rst, test, tokens[index])
+            self._try_markdown(markdown2rst, test, tokens[index])
 
 
     def _try_markdown(self, method, test, tokens):

IPython/nbconvert/filters/tests/test_strings.py

@@ -15,7 +15,6 b' Module with tests for Strings'
 #-----------------------------------------------------------------------------
 import os
 
-from IPython.testing import decorators as dec
 from ...tests.base import TestsBase
 from ..strings import (wrap_text, html2text, add_anchor, strip_dollars, 
     strip_files_prefix, get_lines, comment_lines, ipython2python, posix_path,
@@ -36,7 +35,7 b' class TestStrings(TestsBase):'
         As if the strings were thine, shouldst know of this.
         """
         for length in [30,5,1]:
-            yield self._confirm_wrap_text(test_text, length)
+            self._confirm_wrap_text(test_text, length)
     
 
     def _confirm_wrap_text(self, text, length):
@@ -73,7 +72,7 b' class TestStrings(TestsBase):'
             ('Hello', 'Hello'),
             ('W$o$rld', 'W$o$rld')]
         for test in tests:
-            yield self._try_strip_dollars(test[0], test[1])
+            self._try_strip_dollars(test[0], test[1])
 
 
     def _try_strip_dollars(self, test, result):
@@ -89,7 +88,7 b' class TestStrings(TestsBase):'
             ('My files are in `files/`', 'My files are in `files/`'),
             ('<a href="files/test.html">files/test.html</a>', '<a href="test.html">files/test.html</a>')]
         for test in tests:
-            yield self._try_files_prefix(test[0], test[1])
+            self._try_files_prefix(test[0], test[1])
 
 
     def _try_files_prefix(self, test, result):

IPython/nbconvert/tests/base.py

@@ -16,12 +16,12 b' Contains base test class for nbconvert'
 import os
 import glob
 import shutil
+import unittest
 
 import IPython
 from IPython.utils.tempdir import TemporaryWorkingDirectory
 from IPython.utils.process import get_output_error_code
 from IPython.testing.tools import get_ipython_cmd
-from IPython.testing.ipunittest import ParametricTestCase
 
 # a trailing space allows for simpler concatenation with the other arguments
 ipy_cmd = get_ipython_cmd(as_string=True) + " "
@@ -31,7 +31,7 b' ipy_cmd = get_ipython_cmd(as_string=True) + " "'
 #-----------------------------------------------------------------------------
 
 
-class TestsBase(ParametricTestCase):
+class TestsBase(unittest.TestCase):
     """Base tests class.  Contains useful fuzzy comparison and nbconvert
     functions."""
 
@@ -86,7 +86,7 b' class TestsBase(ParametricTestCase):'
 
         For example:
            Replace "ii" with "i" in the string "Hiiii" yields "Hii"
-           Another replacement yields "Hi" (the desired output)
+           Another replacement cds "Hi" (the desired output)
 
         Parameters:
         -----------

IPython/parallel/tests/test_magics.py

@@ -17,20 +17,14 b' Authors:'
 #-------------------------------------------------------------------------------
 
 import re
-import sys
 import time
 
-import zmq
-from nose import SkipTest
 
 from IPython.testing import decorators as dec
-from IPython.testing.ipunittest import ParametricTestCase
 from IPython.utils.io import capture_output
 
 from IPython import parallel  as pmod
-from IPython.parallel import error
 from IPython.parallel import AsyncResult
-from IPython.parallel.util import interactive
 
 from IPython.parallel.tests import add_engines
 
@@ -39,7 +33,7 b' from .clienttest import ClusterTestCase, generate_output'
 def setup():
     add_engines(3, total=True)
 
-class TestParallelMagics(ClusterTestCase, ParametricTestCase):
+class TestParallelMagics(ClusterTestCase):
     
     def test_px_blocking(self):
         ip = get_ipython()

IPython/parallel/tests/test_view.py

@@ -22,20 +22,16 b' import platform'
 import time
 from collections import namedtuple
 from tempfile import mktemp
-from StringIO import StringIO
 
 import zmq
-from nose import SkipTest
 from nose.plugins.attrib import attr
 
 from IPython.testing import decorators as dec
-from IPython.testing.ipunittest import ParametricTestCase
 from IPython.utils.io import capture_output
 
 from IPython import parallel  as pmod
 from IPython.parallel import error
 from IPython.parallel import AsyncResult, AsyncHubResult, AsyncMapResult
-from IPython.parallel import DirectView
 from IPython.parallel.util import interactive
 
 from IPython.parallel.tests import add_engines
@@ -47,7 +43,7 b' def setup():'
 
 point = namedtuple("point", "x y")
 
-class TestView(ClusterTestCase, ParametricTestCase):
+class TestView(ClusterTestCase):
     
     def setUp(self):
         # On Win XP, wait for resource cleanup, else parallel test group fails
@@ -242,7 +238,7 b' class TestView(ClusterTestCase, ParametricTestCase):'
     @skip_without('numpy')
     def test_scatter_gather_numpy(self):
         import numpy
-        from numpy.testing.utils import assert_array_equal, assert_array_almost_equal
+        from numpy.testing.utils import assert_array_equal
         view = self.client[:]
         a = numpy.arange(64)
         view.scatter('a', a, block=True)
@@ -280,7 +276,7 b' class TestView(ClusterTestCase, ParametricTestCase):'
     def test_apply_numpy(self):
         """view.apply(f, ndarray)"""
         import numpy
-        from numpy.testing.utils import assert_array_equal, assert_array_almost_equal
+        from numpy.testing.utils import assert_array_equal
         
         A = numpy.random.random((100,100))
         view = self.client[-1]
@@ -368,7 +364,7 b' class TestView(ClusterTestCase, ParametricTestCase):'
     @skip_without('numpy')
     def test_scatter_gather_numpy_nonblocking(self):
         import numpy
-        from numpy.testing.utils import assert_array_equal, assert_array_almost_equal
+        from numpy.testing.utils import assert_array_equal
         a = numpy.arange(64)
         view = self.client[:]
         ar = view.scatter('a', a, block=False)
@@ -512,19 +508,17 b' class TestView(ClusterTestCase, ParametricTestCase):'
     def test_len(self):
         """len(view) makes sense"""
         e0 = self.client[self.client.ids[0]]
-        yield self.assertEqual(len(e0), 1)
+        self.assertEqual(len(e0), 1)
         v = self.client[:]
-        yield self.assertEqual(len(v), len(self.client.ids))
+        self.assertEqual(len(v), len(self.client.ids))
         v = self.client.direct_view('all')
-        yield self.assertEqual(len(v), len(self.client.ids))
+        self.assertEqual(len(v), len(self.client.ids))
         v = self.client[:2]
-        yield self.assertEqual(len(v), 2)
+        self.assertEqual(len(v), 2)
         v = self.client[:1]
-        yield self.assertEqual(len(v), 1)
+        self.assertEqual(len(v), 1)
         v = self.client.load_balanced_view()
-        yield self.assertEqual(len(v), len(self.client.ids))
-        # parametric tests seem to require manual closing?
-        self.client.close()
+        self.assertEqual(len(v), len(self.client.ids))
 
     
     # begin execute tests

IPython/testing/decorators.py

@@ -16,10 +16,6 b' Included decorators:'
 
 Lightweight testing that remains unittest-compatible.
 
-- @parametric, for parametric test support that is vastly easier to use than
-  nose's for debugging. With ours, if a test fails, the stack under inspection
-  is that of the test and not that of the test framework.
-
 - An @as_unittest decorator can be used to tag any normal parameter-less
   function as a unittest TestCase.  Then, both nose and normal unittest will
   recognize it as such.  This will make it easier to migrate away from Nose if
@@ -58,12 +54,6 b' import unittest'
 # This is Michele Simionato's decorator module, kept verbatim.
 from IPython.external.decorator import decorator
 
-# We already have python3-compliant code for parametric tests
-if sys.version[0]=='2':
-    from _paramtestpy2 import parametric
-else:
-    from _paramtestpy3 import parametric
-
 # Expose the unittest-driven decorators
 from ipunittest import ipdoctest, ipdocstring
 

IPython/testing/ipunittest.py

@@ -37,16 +37,9 b' from __future__ import absolute_import'
 
 # Stdlib
 import re
-import sys
 import unittest
 from doctest import DocTestFinder, DocTestRunner, TestResults
 
-# We already have python3-compliant code for parametric tests
-if sys.version[0]=='2':
-    from ._paramtestpy2 import ParametricTestCase
-else:
-    from ._paramtestpy3 import ParametricTestCase
-
 #-----------------------------------------------------------------------------
 # Classes and functions
 #-----------------------------------------------------------------------------

IPython/testing/tests/test_decorators.py

@@ -12,7 +12,6 b' import nose.tools as nt'
 # Our own
 from IPython.testing import decorators as dec
 from IPython.testing.skipdoctest import skip_doctest
-from IPython.testing.ipunittest import ParametricTestCase
 
 #-----------------------------------------------------------------------------
 # Utilities
@@ -47,24 +46,6 b' def trivial():'
     """A trivial test"""
     pass
 
-# Some examples of parametric tests.
-
-def is_smaller(i,j):
-    assert i<j,"%s !< %s" % (i,j)
-
-class Tester(ParametricTestCase):
-
-    def test_parametric(self):
-        yield is_smaller(3, 4)
-        x, y = 1, 2
-        yield is_smaller(x, y)
-
[e-mail]
-def test_par_standalone():
-    yield is_smaller(3, 4)
-    x, y = 1, 2
-    yield is_smaller(x, y)
-
 
 @dec.skip
 def test_deliberately_broken():

IPython/testing/tests/test_tools.py

@@ -51,26 +51,24 b' def test_full_path_win32():'
     nt.assert_equal(result, ['c:\\a.txt'])
 
     
[e-mail]
 def test_parser():
     err = ("FAILED (errors=1)", 1, 0)
     fail = ("FAILED (failures=1)", 0, 1)
     both = ("FAILED (errors=1, failures=1)", 1, 1)
     for txt, nerr, nfail in [err, fail, both]:
         nerr1, nfail1 = tt.parse_test_output(txt)
-        yield nt.assert_equal(nerr, nerr1)
-        yield nt.assert_equal(nfail, nfail1)
+        nt.assert_equal(nerr, nerr1)
+        nt.assert_equal(nfail, nfail1)
 
         
[e-mail]
 def test_temp_pyfile():
     src = 'pass\n'
     fname, fh = tt.temp_pyfile(src)
-    yield nt.assert_true(os.path.isfile(fname))
+    assert os.path.isfile(fname)
     fh.close()
     with open(fname) as fh2:
         src2 = fh2.read()
-    yield nt.assert_equal(src2, src)
+    nt.assert_equal(src2, src)
 
 class TestAssertPrints(unittest.TestCase):
     def test_passing(self):

IPython/utils/tests/test_io.py

@@ -17,10 +17,10 b' import sys'
 
 from StringIO import StringIO
 from subprocess import Popen, PIPE
+import unittest
 
 import nose.tools as nt
 
-from IPython.testing.ipunittest import ParametricTestCase
 from IPython.utils.io import Tee, capture_output
 from IPython.utils.py3compat import doctest_refactor_print
 
@@ -38,7 +38,7 b' def test_tee_simple():'
     nt.assert_equal(chan.getvalue(), text+"\n")
 
 
-class TeeTestCase(ParametricTestCase):
+class TeeTestCase(unittest.TestCase):
 
     def tchan(self, channel, check='close'):
         trap = StringIO()
@@ -61,7 +61,7 b' class TeeTestCase(ParametricTestCase):'
     def test(self):
         for chan in ['stdout', 'stderr']:
             for check in ['close', 'del']:
-                yield self.tchan(chan, check)
+                self.tchan(chan, check)
 
 def test_io_init():
     """Test that io.stdin/out/err exist at startup"""

IPython/utils/tests/test_jsonutil.py

@@ -19,7 +19,6 b' from base64 import decodestring'
 import nose.tools as nt
 
 # our own
-from IPython.testing import decorators as dec
 from IPython.utils import jsonutil, tz
 from ..jsonutil import json_clean, encode_images
 from ..py3compat import unicode_to_str, str_to_bytes
@@ -62,7 +61,6 b' def test():'
 
 
 
[e-mail]
 def test_encode_images():
     # invalid data, but the header and footer are from real files
     pngdata = b'\x89PNG\r\n\x1a\nblahblahnotactuallyvalidIEND\xaeB`\x82'
@@ -76,19 +74,19 b' def test_encode_images():'
     for key, value in fmt.iteritems():
         # encoded has unicode, want bytes
         decoded = decodestring(encoded[key].encode('ascii'))
-        yield nt.assert_equal(decoded, value)
+        nt.assert_equal(decoded, value)
     encoded2 = encode_images(encoded)
-    yield nt.assert_equal(encoded, encoded2)
+    nt.assert_equal(encoded, encoded2)
     
     b64_str = {}
     for key, encoded in encoded.iteritems():
         b64_str[key] = unicode_to_str(encoded)
     encoded3 = encode_images(b64_str)
-    yield nt.assert_equal(encoded3, b64_str)
+    nt.assert_equal(encoded3, b64_str)
     for key, value in fmt.iteritems():
         # encoded3 has str, want bytes
         decoded = decodestring(str_to_bytes(encoded3[key]))
-        yield nt.assert_equal(decoded, value)
+        nt.assert_equal(decoded, value)
 
 def test_lambda():
     jc = json_clean(lambda : 1)