s/assertEquals/assertEqual/

IPython/config/tests/test_application.py

@@ -1,175 +1,175 b''
 """
 Tests for IPython.config.application.Application
 
 Authors:
 
 * Brian Granger
 """
 
 #-----------------------------------------------------------------------------
 #  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 logging
 from unittest import TestCase
 
 from IPython.config.configurable import Configurable
 from IPython.config.loader import Config
 
 from IPython.config.application import (
     Application
 )
 
 from IPython.utils.traitlets import (
     Bool, Unicode, Integer, Float, List, Dict
 )
 
 #-----------------------------------------------------------------------------
 # Code
 #-----------------------------------------------------------------------------
 
 class Foo(Configurable):
 
     i = Integer(0, config=True, help="The integer i.")
     j = Integer(1, config=True, help="The integer j.")
     name = Unicode(u'Brian', config=True, help="First name.")
 
 
 class Bar(Configurable):
 
     b = Integer(0, config=True, help="The integer b.")
     enabled = Bool(True, config=True, help="Enable bar.")
 
 
 class MyApp(Application):
 
     name = Unicode(u'myapp')
     running = Bool(False, config=True,
                    help="Is the app running?")
     classes = List([Bar, Foo])
     config_file = Unicode(u'', config=True,
                    help="Load this config file")
 
     aliases = Dict({
                     'i' : 'Foo.i',
                     'j' : 'Foo.j',
                     'name' : 'Foo.name',
                     'enabled' : 'Bar.enabled',
                     'log-level' : 'Application.log_level',
                 })
     
     flags = Dict(dict(enable=({'Bar': {'enabled' : True}}, "Set Bar.enabled to True"),
                   disable=({'Bar': {'enabled' : False}}, "Set Bar.enabled to False"),
                   crit=({'Application' : {'log_level' : logging.CRITICAL}},
                         "set level=CRITICAL"),
             ))
     
     def init_foo(self):
         self.foo = Foo(config=self.config)
 
     def init_bar(self):
         self.bar = Bar(config=self.config)
 
 
 class TestApplication(TestCase):
 
     def test_basic(self):
         app = MyApp()
-        self.assertEquals(app.name, u'myapp')
-        self.assertEquals(app.running, False)
-        self.assertEquals(app.classes, [MyApp,Bar,Foo])
-        self.assertEquals(app.config_file, u'')
+        self.assertEqual(app.name, u'myapp')
+        self.assertEqual(app.running, False)
+        self.assertEqual(app.classes, [MyApp,Bar,Foo])
+        self.assertEqual(app.config_file, u'')
 
     def test_config(self):
         app = MyApp()
         app.parse_command_line(["--i=10","--Foo.j=10","--enabled=False","--log-level=50"])
         config = app.config
-        self.assertEquals(config.Foo.i, 10)
-        self.assertEquals(config.Foo.j, 10)
-        self.assertEquals(config.Bar.enabled, False)
-        self.assertEquals(config.MyApp.log_level,50)
+        self.assertEqual(config.Foo.i, 10)
+        self.assertEqual(config.Foo.j, 10)
+        self.assertEqual(config.Bar.enabled, False)
+        self.assertEqual(config.MyApp.log_level,50)
 
     def test_config_propagation(self):
         app = MyApp()
         app.parse_command_line(["--i=10","--Foo.j=10","--enabled=False","--log-level=50"])
         app.init_foo()
         app.init_bar()
-        self.assertEquals(app.foo.i, 10)
-        self.assertEquals(app.foo.j, 10)
-        self.assertEquals(app.bar.enabled, False)
+        self.assertEqual(app.foo.i, 10)
+        self.assertEqual(app.foo.j, 10)
+        self.assertEqual(app.bar.enabled, False)
 
     def test_flags(self):
         app = MyApp()
         app.parse_command_line(["--disable"])
         app.init_bar()
-        self.assertEquals(app.bar.enabled, False)
+        self.assertEqual(app.bar.enabled, False)
         app.parse_command_line(["--enable"])
         app.init_bar()
-        self.assertEquals(app.bar.enabled, True)
+        self.assertEqual(app.bar.enabled, True)
     
     def test_aliases(self):
         app = MyApp()
         app.parse_command_line(["--i=5", "--j=10"])
         app.init_foo()
-        self.assertEquals(app.foo.i, 5)
+        self.assertEqual(app.foo.i, 5)
         app.init_foo()
-        self.assertEquals(app.foo.j, 10)
+        self.assertEqual(app.foo.j, 10)
     
     def test_flag_clobber(self):
         """test that setting flags doesn't clobber existing settings"""
         app = MyApp()
         app.parse_command_line(["--Bar.b=5", "--disable"])
         app.init_bar()
-        self.assertEquals(app.bar.enabled, False)
-        self.assertEquals(app.bar.b, 5)
+        self.assertEqual(app.bar.enabled, False)
+        self.assertEqual(app.bar.b, 5)
         app.parse_command_line(["--enable", "--Bar.b=10"])
         app.init_bar()
-        self.assertEquals(app.bar.enabled, True)
-        self.assertEquals(app.bar.b, 10)
+        self.assertEqual(app.bar.enabled, True)
+        self.assertEqual(app.bar.b, 10)
     
     def test_flatten_flags(self):
         cfg = Config()
         cfg.MyApp.log_level = logging.WARN
         app = MyApp()
         app.update_config(cfg)
-        self.assertEquals(app.log_level, logging.WARN)
-        self.assertEquals(app.config.MyApp.log_level, logging.WARN)
+        self.assertEqual(app.log_level, logging.WARN)
+        self.assertEqual(app.config.MyApp.log_level, logging.WARN)
         app.initialize(["--crit"])
-        self.assertEquals(app.log_level, logging.CRITICAL)
+        self.assertEqual(app.log_level, logging.CRITICAL)
         # this would be app.config.Application.log_level if it failed:
-        self.assertEquals(app.config.MyApp.log_level, logging.CRITICAL)
+        self.assertEqual(app.config.MyApp.log_level, logging.CRITICAL)
     
     def test_flatten_aliases(self):
         cfg = Config()
         cfg.MyApp.log_level = logging.WARN
         app = MyApp()
         app.update_config(cfg)
-        self.assertEquals(app.log_level, logging.WARN)
-        self.assertEquals(app.config.MyApp.log_level, logging.WARN)
+        self.assertEqual(app.log_level, logging.WARN)
+        self.assertEqual(app.config.MyApp.log_level, logging.WARN)
         app.initialize(["--log-level", "CRITICAL"])
-        self.assertEquals(app.log_level, logging.CRITICAL)
+        self.assertEqual(app.log_level, logging.CRITICAL)
         # this would be app.config.Application.log_level if it failed:
-        self.assertEquals(app.config.MyApp.log_level, "CRITICAL")
+        self.assertEqual(app.config.MyApp.log_level, "CRITICAL")
     
     def test_extra_args(self):
         app = MyApp()
         app.parse_command_line(["--Bar.b=5", 'extra', "--disable", 'args'])
         app.init_bar()
-        self.assertEquals(app.bar.enabled, False)
-        self.assertEquals(app.bar.b, 5)
-        self.assertEquals(app.extra_args, ['extra', 'args'])
+        self.assertEqual(app.bar.enabled, False)
+        self.assertEqual(app.bar.b, 5)
+        self.assertEqual(app.extra_args, ['extra', 'args'])
         app = MyApp()
         app.parse_command_line(["--Bar.b=5", '--', 'extra', "--disable", 'args'])
         app.init_bar()
-        self.assertEquals(app.bar.enabled, True)
-        self.assertEquals(app.bar.b, 5)
-        self.assertEquals(app.extra_args, ['extra', '--disable', 'args'])
+        self.assertEqual(app.bar.enabled, True)
+        self.assertEqual(app.bar.b, 5)
+        self.assertEqual(app.extra_args, ['extra', '--disable', 'args'])
     
 

IPython/config/tests/test_configurable.py

@@ -1,183 +1,183 b''
 # encoding: utf-8
 """
 Tests for IPython.config.configurable
 
 Authors:
 
 * Brian Granger
 * Fernando Perez (design help)
 """
 
 #-----------------------------------------------------------------------------
 #  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
 #-----------------------------------------------------------------------------
 
 from unittest import TestCase
 
 from IPython.config.configurable import (
     Configurable, 
     SingletonConfigurable
 )
 
 from IPython.utils.traitlets import (
     Integer, Float, Unicode
 )
 
 from IPython.config.loader import Config
 from IPython.utils.py3compat import PY3
 
 #-----------------------------------------------------------------------------
 # Test cases
 #-----------------------------------------------------------------------------
 
 
 class MyConfigurable(Configurable):
     a = Integer(1, config=True, help="The integer a.")
     b = Float(1.0, config=True, help="The integer b.")
     c = Unicode('no config')
 
 
 mc_help=u"""MyConfigurable options
 ----------------------
 --MyConfigurable.a=<Integer>
     Default: 1
     The integer a.
 --MyConfigurable.b=<Float>
     Default: 1.0
     The integer b."""
 
 mc_help_inst=u"""MyConfigurable options
 ----------------------
 --MyConfigurable.a=<Integer>
     Current: 5
     The integer a.
 --MyConfigurable.b=<Float>
     Current: 4.0
     The integer b."""
 
 # On Python 3, the Integer trait is a synonym for Int
 if PY3:
     mc_help = mc_help.replace(u"<Integer>", u"<Int>")
     mc_help_inst = mc_help_inst.replace(u"<Integer>", u"<Int>")
 
 class Foo(Configurable):
     a = Integer(0, config=True, help="The integer a.")
     b = Unicode('nope', config=True)
 
 
 class Bar(Foo):
     b = Unicode('gotit', config=False, help="The string b.")
     c = Float(config=True, help="The string c.")
 
 
 class TestConfigurable(TestCase):
 
     def test_default(self):
         c1 = Configurable()
         c2 = Configurable(config=c1.config)
         c3 = Configurable(config=c2.config)
-        self.assertEquals(c1.config, c2.config)
-        self.assertEquals(c2.config, c3.config)
+        self.assertEqual(c1.config, c2.config)
+        self.assertEqual(c2.config, c3.config)
 
     def test_custom(self):
         config = Config()
         config.foo = 'foo'
         config.bar = 'bar'
         c1 = Configurable(config=config)
         c2 = Configurable(config=c1.config)
         c3 = Configurable(config=c2.config)
-        self.assertEquals(c1.config, config)
-        self.assertEquals(c2.config, config)
-        self.assertEquals(c3.config, config)
+        self.assertEqual(c1.config, config)
+        self.assertEqual(c2.config, config)
+        self.assertEqual(c3.config, config)
         # Test that copies are not made
         self.assert_(c1.config is config)
         self.assert_(c2.config is config)
         self.assert_(c3.config is config)
         self.assert_(c1.config is c2.config)
         self.assert_(c2.config is c3.config)
         
     def test_inheritance(self):
         config = Config()
         config.MyConfigurable.a = 2
         config.MyConfigurable.b = 2.0
         c1 = MyConfigurable(config=config)
         c2 = MyConfigurable(config=c1.config)
-        self.assertEquals(c1.a, config.MyConfigurable.a)
-        self.assertEquals(c1.b, config.MyConfigurable.b)
-        self.assertEquals(c2.a, config.MyConfigurable.a)
-        self.assertEquals(c2.b, config.MyConfigurable.b)
+        self.assertEqual(c1.a, config.MyConfigurable.a)
+        self.assertEqual(c1.b, config.MyConfigurable.b)
+        self.assertEqual(c2.a, config.MyConfigurable.a)
+        self.assertEqual(c2.b, config.MyConfigurable.b)
 
     def test_parent(self):
         config = Config()
         config.Foo.a = 10
         config.Foo.b = "wow"
         config.Bar.b = 'later'
         config.Bar.c = 100.0
         f = Foo(config=config)
         b = Bar(config=f.config)
-        self.assertEquals(f.a, 10)
-        self.assertEquals(f.b, 'wow')
-        self.assertEquals(b.b, 'gotit')
-        self.assertEquals(b.c, 100.0)
+        self.assertEqual(f.a, 10)
+        self.assertEqual(f.b, 'wow')
+        self.assertEqual(b.b, 'gotit')
+        self.assertEqual(b.c, 100.0)
 
     def test_override1(self):
         config = Config()
         config.MyConfigurable.a = 2
         config.MyConfigurable.b = 2.0
         c = MyConfigurable(a=3, config=config)
-        self.assertEquals(c.a, 3)
-        self.assertEquals(c.b, config.MyConfigurable.b)
-        self.assertEquals(c.c, 'no config')
+        self.assertEqual(c.a, 3)
+        self.assertEqual(c.b, config.MyConfigurable.b)
+        self.assertEqual(c.c, 'no config')
 
     def test_override2(self):
         config = Config()
         config.Foo.a = 1
         config.Bar.b = 'or'  # Up above b is config=False, so this won't do it.
         config.Bar.c = 10.0
         c = Bar(config=config)
-        self.assertEquals(c.a, config.Foo.a)
-        self.assertEquals(c.b, 'gotit')
-        self.assertEquals(c.c, config.Bar.c)
+        self.assertEqual(c.a, config.Foo.a)
+        self.assertEqual(c.b, 'gotit')
+        self.assertEqual(c.c, config.Bar.c)
         c = Bar(a=2, b='and', c=20.0, config=config)
-        self.assertEquals(c.a, 2)
-        self.assertEquals(c.b, 'and')
-        self.assertEquals(c.c, 20.0)
+        self.assertEqual(c.a, 2)
+        self.assertEqual(c.b, 'and')
+        self.assertEqual(c.c, 20.0)
 
     def test_help(self):
-        self.assertEquals(MyConfigurable.class_get_help(), mc_help)
+        self.assertEqual(MyConfigurable.class_get_help(), mc_help)
 
     def test_help_inst(self):
         inst = MyConfigurable(a=5, b=4)
-        self.assertEquals(MyConfigurable.class_get_help(inst), mc_help_inst)
+        self.assertEqual(MyConfigurable.class_get_help(inst), mc_help_inst)
 
 
 class TestSingletonConfigurable(TestCase):
 
     def test_instance(self):
         from IPython.config.configurable import SingletonConfigurable
         class Foo(SingletonConfigurable): pass
-        self.assertEquals(Foo.initialized(), False)
+        self.assertEqual(Foo.initialized(), False)
         foo = Foo.instance()
-        self.assertEquals(Foo.initialized(), True)
-        self.assertEquals(foo, Foo.instance())
-        self.assertEquals(SingletonConfigurable._instance, None)
+        self.assertEqual(Foo.initialized(), True)
+        self.assertEqual(foo, Foo.instance())
+        self.assertEqual(SingletonConfigurable._instance, None)
 
     def test_inheritance(self):
         class Bar(SingletonConfigurable): pass
         class Bam(Bar): pass
-        self.assertEquals(Bar.initialized(), False)
-        self.assertEquals(Bam.initialized(), False)
+        self.assertEqual(Bar.initialized(), False)
+        self.assertEqual(Bam.initialized(), False)
         bam = Bam.instance()
         bam == Bar.instance()
-        self.assertEquals(Bar.initialized(), True)
-        self.assertEquals(Bam.initialized(), True)
-        self.assertEquals(bam, Bam._instance)
-        self.assertEquals(bam, Bar._instance)
-        self.assertEquals(SingletonConfigurable._instance, None)
+        self.assertEqual(Bar.initialized(), True)
+        self.assertEqual(Bam.initialized(), True)
+        self.assertEqual(bam, Bam._instance)
+        self.assertEqual(bam, Bar._instance)
+        self.assertEqual(SingletonConfigurable._instance, None)

IPython/config/tests/test_loader.py

@@ -1,263 +1,263 b''
 # encoding: utf-8
 """
 Tests for IPython.config.loader
 
 Authors:
 
 * Brian Granger
 * Fernando Perez (design help)
 """
 
 #-----------------------------------------------------------------------------
 #  Copyright (C) 2008-2011  The IPython Development Team
 #
 #  Distributed under the terms of the BSD License.  The full license is in
 #  the file COPYING, distributed as part of this software.
 #-----------------------------------------------------------------------------
 
 #-----------------------------------------------------------------------------
 # Imports
 #-----------------------------------------------------------------------------
 
 import os
 import sys
 from tempfile import mkstemp
 from unittest import TestCase
 
 from nose import SkipTest
 
 from IPython.testing.tools import mute_warn
 
 from IPython.utils.traitlets import Unicode
 from IPython.config.configurable import Configurable
 from IPython.config.loader import (
     Config,
     PyFileConfigLoader,
     KeyValueConfigLoader,
     ArgParseConfigLoader,
     KVArgParseConfigLoader,
     ConfigError
 )
 
 #-----------------------------------------------------------------------------
 # Actual tests
 #-----------------------------------------------------------------------------
 
 
 pyfile = """
 c = get_config()
 c.a=10
 c.b=20
 c.Foo.Bar.value=10
 c.Foo.Bam.value=list(range(10))  # list() is just so it's the same on Python 3
 c.D.C.value='hi there'
 """
 
 class TestPyFileCL(TestCase):
 
     def test_basic(self):
         fd, fname = mkstemp('.py')
         f = os.fdopen(fd, 'w')
         f.write(pyfile)
         f.close()
         # Unlink the file
         cl = PyFileConfigLoader(fname)
         config = cl.load_config()
-        self.assertEquals(config.a, 10)
-        self.assertEquals(config.b, 20)
-        self.assertEquals(config.Foo.Bar.value, 10)
-        self.assertEquals(config.Foo.Bam.value, range(10))
-        self.assertEquals(config.D.C.value, 'hi there')
+        self.assertEqual(config.a, 10)
+        self.assertEqual(config.b, 20)
+        self.assertEqual(config.Foo.Bar.value, 10)
+        self.assertEqual(config.Foo.Bam.value, range(10))
+        self.assertEqual(config.D.C.value, 'hi there')
 
 class MyLoader1(ArgParseConfigLoader):
     def _add_arguments(self, aliases=None, flags=None):
         p = self.parser
         p.add_argument('-f', '--foo', dest='Global.foo', type=str)
         p.add_argument('-b', dest='MyClass.bar', type=int)
         p.add_argument('-n', dest='n', action='store_true')
         p.add_argument('Global.bam', type=str)
 
 class MyLoader2(ArgParseConfigLoader):
     def _add_arguments(self, aliases=None, flags=None):
         subparsers = self.parser.add_subparsers(dest='subparser_name')
         subparser1 = subparsers.add_parser('1')
         subparser1.add_argument('-x',dest='Global.x')
         subparser2 = subparsers.add_parser('2')
         subparser2.add_argument('y')
 
 class TestArgParseCL(TestCase):
 
     def test_basic(self):
         cl = MyLoader1()
         config = cl.load_config('-f hi -b 10 -n wow'.split())
-        self.assertEquals(config.Global.foo, 'hi')
-        self.assertEquals(config.MyClass.bar, 10)
-        self.assertEquals(config.n, True)
-        self.assertEquals(config.Global.bam, 'wow')
+        self.assertEqual(config.Global.foo, 'hi')
+        self.assertEqual(config.MyClass.bar, 10)
+        self.assertEqual(config.n, True)
+        self.assertEqual(config.Global.bam, 'wow')
         config = cl.load_config(['wow'])
-        self.assertEquals(config.keys(), ['Global'])
-        self.assertEquals(config.Global.keys(), ['bam'])
-        self.assertEquals(config.Global.bam, 'wow')
+        self.assertEqual(config.keys(), ['Global'])
+        self.assertEqual(config.Global.keys(), ['bam'])
+        self.assertEqual(config.Global.bam, 'wow')
 
     def test_add_arguments(self):
         cl = MyLoader2()
         config = cl.load_config('2 frobble'.split())
-        self.assertEquals(config.subparser_name, '2')
-        self.assertEquals(config.y, 'frobble')
+        self.assertEqual(config.subparser_name, '2')
+        self.assertEqual(config.y, 'frobble')
         config = cl.load_config('1 -x frobble'.split())
-        self.assertEquals(config.subparser_name, '1')
-        self.assertEquals(config.Global.x, 'frobble')
+        self.assertEqual(config.subparser_name, '1')
+        self.assertEqual(config.Global.x, 'frobble')
 
     def test_argv(self):
         cl = MyLoader1(argv='-f hi -b 10 -n wow'.split())
         config = cl.load_config()
-        self.assertEquals(config.Global.foo, 'hi')
-        self.assertEquals(config.MyClass.bar, 10)
-        self.assertEquals(config.n, True)
-        self.assertEquals(config.Global.bam, 'wow')
+        self.assertEqual(config.Global.foo, 'hi')
+        self.assertEqual(config.MyClass.bar, 10)
+        self.assertEqual(config.n, True)
+        self.assertEqual(config.Global.bam, 'wow')
 
 
 class TestKeyValueCL(TestCase):
     klass = KeyValueConfigLoader
 
     def test_basic(self):
         cl = self.klass()
         argv = ['--'+s.strip('c.') for s in pyfile.split('\n')[2:-1]]
         with mute_warn():
             config = cl.load_config(argv)
-        self.assertEquals(config.a, 10)
-        self.assertEquals(config.b, 20)
-        self.assertEquals(config.Foo.Bar.value, 10)
-        self.assertEquals(config.Foo.Bam.value, range(10))
-        self.assertEquals(config.D.C.value, 'hi there')
+        self.assertEqual(config.a, 10)
+        self.assertEqual(config.b, 20)
+        self.assertEqual(config.Foo.Bar.value, 10)
+        self.assertEqual(config.Foo.Bam.value, range(10))
+        self.assertEqual(config.D.C.value, 'hi there')
     
     def test_expanduser(self):
         cl = self.klass()
         argv = ['--a=~/1/2/3', '--b=~', '--c=~/', '--d="~/"']
         with mute_warn():
             config = cl.load_config(argv)
-        self.assertEquals(config.a, os.path.expanduser('~/1/2/3'))
-        self.assertEquals(config.b, os.path.expanduser('~'))
-        self.assertEquals(config.c, os.path.expanduser('~/'))
-        self.assertEquals(config.d, '~/')
+        self.assertEqual(config.a, os.path.expanduser('~/1/2/3'))
+        self.assertEqual(config.b, os.path.expanduser('~'))
+        self.assertEqual(config.c, os.path.expanduser('~/'))
+        self.assertEqual(config.d, '~/')
     
     def test_extra_args(self):
         cl = self.klass()
         with mute_warn():
             config = cl.load_config(['--a=5', 'b', '--c=10', 'd'])
-        self.assertEquals(cl.extra_args, ['b', 'd'])
-        self.assertEquals(config.a, 5)
-        self.assertEquals(config.c, 10)
+        self.assertEqual(cl.extra_args, ['b', 'd'])
+        self.assertEqual(config.a, 5)
+        self.assertEqual(config.c, 10)
         with mute_warn():
             config = cl.load_config(['--', '--a=5', '--c=10'])
-        self.assertEquals(cl.extra_args, ['--a=5', '--c=10'])
+        self.assertEqual(cl.extra_args, ['--a=5', '--c=10'])
     
     def test_unicode_args(self):
         cl = self.klass()
         argv = [u'--a=épsîlön']
         with mute_warn():
             config = cl.load_config(argv)
-        self.assertEquals(config.a, u'épsîlön')
+        self.assertEqual(config.a, u'épsîlön')
     
     def test_unicode_bytes_args(self):
         uarg = u'--a=é'
         try:
             barg = uarg.encode(sys.stdin.encoding)
         except (TypeError, UnicodeEncodeError):
             raise SkipTest("sys.stdin.encoding can't handle 'é'")
         
         cl = self.klass()
         with mute_warn():
             config = cl.load_config([barg])
-        self.assertEquals(config.a, u'é')
+        self.assertEqual(config.a, u'é')
     
     def test_unicode_alias(self):
         cl = self.klass()
         argv = [u'--a=épsîlön']
         with mute_warn():
             config = cl.load_config(argv, aliases=dict(a='A.a'))
-        self.assertEquals(config.A.a, u'épsîlön')
+        self.assertEqual(config.A.a, u'épsîlön')
 
 
 class TestArgParseKVCL(TestKeyValueCL):
     klass = KVArgParseConfigLoader
 
     def test_expanduser2(self):
         cl = self.klass()
         argv = ['-a', '~/1/2/3', '--b', "'~/1/2/3'"]
         with mute_warn():
             config = cl.load_config(argv, aliases=dict(a='A.a', b='A.b'))
-        self.assertEquals(config.A.a, os.path.expanduser('~/1/2/3'))
-        self.assertEquals(config.A.b, '~/1/2/3')
+        self.assertEqual(config.A.a, os.path.expanduser('~/1/2/3'))
+        self.assertEqual(config.A.b, '~/1/2/3')
     
     def test_eval(self):
         cl = self.klass()
         argv = ['-c', 'a=5']
         with mute_warn():
             config = cl.load_config(argv, aliases=dict(c='A.c'))
-        self.assertEquals(config.A.c, u"a=5")
+        self.assertEqual(config.A.c, u"a=5")
     
 
 class TestConfig(TestCase):
 
     def test_setget(self):
         c = Config()
         c.a = 10
-        self.assertEquals(c.a, 10)
-        self.assertEquals('b' in c, False)
+        self.assertEqual(c.a, 10)
+        self.assertEqual('b' in c, False)
 
     def test_auto_section(self):
         c = Config()
-        self.assertEquals('A' in c, True)
-        self.assertEquals(c._has_section('A'), False)
+        self.assertEqual('A' in c, True)
+        self.assertEqual(c._has_section('A'), False)
         A = c.A
         A.foo = 'hi there'
-        self.assertEquals(c._has_section('A'), True)
-        self.assertEquals(c.A.foo, 'hi there')
+        self.assertEqual(c._has_section('A'), True)
+        self.assertEqual(c.A.foo, 'hi there')
         del c.A
-        self.assertEquals(len(c.A.keys()),0)
+        self.assertEqual(len(c.A.keys()),0)
 
     def test_merge_doesnt_exist(self):
         c1 = Config()
         c2 = Config()
         c2.bar = 10
         c2.Foo.bar = 10
         c1._merge(c2)
-        self.assertEquals(c1.Foo.bar, 10)
-        self.assertEquals(c1.bar, 10)
+        self.assertEqual(c1.Foo.bar, 10)
+        self.assertEqual(c1.bar, 10)
         c2.Bar.bar = 10
         c1._merge(c2)
-        self.assertEquals(c1.Bar.bar, 10)
+        self.assertEqual(c1.Bar.bar, 10)
 
     def test_merge_exists(self):
         c1 = Config()
         c2 = Config()
         c1.Foo.bar = 10
         c1.Foo.bam = 30
         c2.Foo.bar = 20
         c2.Foo.wow = 40
         c1._merge(c2)
-        self.assertEquals(c1.Foo.bam, 30)
-        self.assertEquals(c1.Foo.bar, 20)
-        self.assertEquals(c1.Foo.wow, 40)
+        self.assertEqual(c1.Foo.bam, 30)
+        self.assertEqual(c1.Foo.bar, 20)
+        self.assertEqual(c1.Foo.wow, 40)
         c2.Foo.Bam.bam = 10
         c1._merge(c2)
-        self.assertEquals(c1.Foo.Bam.bam, 10)
+        self.assertEqual(c1.Foo.Bam.bam, 10)
 
     def test_deepcopy(self):
         c1 = Config()
         c1.Foo.bar = 10
         c1.Foo.bam = 30
         c1.a = 'asdf'
         c1.b = range(10)
         import copy
         c2 = copy.deepcopy(c1)
-        self.assertEquals(c1, c2)
+        self.assertEqual(c1, c2)
         self.assert_(c1 is not c2)
         self.assert_(c1.Foo is not c2.Foo)
 
     def test_builtin(self):
         c1 = Config()
         exec 'foo = True' in c1
-        self.assertEquals(c1.foo, True)
+        self.assertEqual(c1.foo, True)
         self.assertRaises(ConfigError, setattr, c1, 'ValueError', 10)

IPython/core/tests/test_interactiveshell.py

@@ -1,407 +1,407 b''
 # -*- coding: utf-8 -*-
 """Tests for the key interactiveshell module.
 
 Historically the main classes in interactiveshell have been under-tested.  This
 module should grow as many single-method tests as possible to trap many of the
 recurring bugs we seem to encounter with high-level interaction.
 
 Authors
 -------
 * Fernando Perez
 """
 #-----------------------------------------------------------------------------
 #  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
 #-----------------------------------------------------------------------------
 # stdlib
 import os
 import shutil
 import sys
 import tempfile
 import unittest
 from os.path import join
 from StringIO import StringIO
 
 # third-party
 import nose.tools as nt
 
 # Our own
 from IPython.testing.decorators import skipif
 from IPython.utils import io
 
 #-----------------------------------------------------------------------------
 # Globals
 #-----------------------------------------------------------------------------
 # This is used by every single test, no point repeating it ad nauseam
 ip = get_ipython()
 
 #-----------------------------------------------------------------------------
 # Tests
 #-----------------------------------------------------------------------------
 
 class InteractiveShellTestCase(unittest.TestCase):
     def test_naked_string_cells(self):
         """Test that cells with only naked strings are fully executed"""
         # First, single-line inputs
         ip.run_cell('"a"\n')
-        self.assertEquals(ip.user_ns['_'], 'a')
+        self.assertEqual(ip.user_ns['_'], 'a')
         # And also multi-line cells
         ip.run_cell('"""a\nb"""\n')
-        self.assertEquals(ip.user_ns['_'], 'a\nb')
+        self.assertEqual(ip.user_ns['_'], 'a\nb')
 
     def test_run_empty_cell(self):
         """Just make sure we don't get a horrible error with a blank
         cell of input. Yes, I did overlook that."""
         old_xc = ip.execution_count
         ip.run_cell('')
-        self.assertEquals(ip.execution_count, old_xc)
+        self.assertEqual(ip.execution_count, old_xc)
 
     def test_run_cell_multiline(self):
         """Multi-block, multi-line cells must execute correctly.
         """
         src = '\n'.join(["x=1",
                          "y=2",
                          "if 1:",
                          "    x += 1",
                          "    y += 1",])
         ip.run_cell(src)
-        self.assertEquals(ip.user_ns['x'], 2)
-        self.assertEquals(ip.user_ns['y'], 3)
+        self.assertEqual(ip.user_ns['x'], 2)
+        self.assertEqual(ip.user_ns['y'], 3)
 
     def test_multiline_string_cells(self):
         "Code sprinkled with multiline strings should execute (GH-306)"
         ip.run_cell('tmp=0')
-        self.assertEquals(ip.user_ns['tmp'], 0)
+        self.assertEqual(ip.user_ns['tmp'], 0)
         ip.run_cell('tmp=1;"""a\nb"""\n')
-        self.assertEquals(ip.user_ns['tmp'], 1)
+        self.assertEqual(ip.user_ns['tmp'], 1)
 
     def test_dont_cache_with_semicolon(self):
         "Ending a line with semicolon should not cache the returned object (GH-307)"
         oldlen = len(ip.user_ns['Out'])
         a = ip.run_cell('1;', store_history=True)
         newlen = len(ip.user_ns['Out'])
-        self.assertEquals(oldlen, newlen)
+        self.assertEqual(oldlen, newlen)
         #also test the default caching behavior
         ip.run_cell('1', store_history=True)
         newlen = len(ip.user_ns['Out'])
-        self.assertEquals(oldlen+1, newlen)
+        self.assertEqual(oldlen+1, newlen)
 
     def test_In_variable(self):
         "Verify that In variable grows with user input (GH-284)"
         oldlen = len(ip.user_ns['In'])
         ip.run_cell('1;', store_history=True)
         newlen = len(ip.user_ns['In'])
-        self.assertEquals(oldlen+1, newlen)
-        self.assertEquals(ip.user_ns['In'][-1],'1;')
+        self.assertEqual(oldlen+1, newlen)
+        self.assertEqual(ip.user_ns['In'][-1],'1;')
         
     def test_magic_names_in_string(self):
         ip.run_cell('a = """\n%exit\n"""')
-        self.assertEquals(ip.user_ns['a'], '\n%exit\n')
+        self.assertEqual(ip.user_ns['a'], '\n%exit\n')
     
     def test_alias_crash(self):
         """Errors in prefilter can't crash IPython"""
         ip.run_cell('%alias parts echo first %s second %s')
         # capture stderr:
         save_err = io.stderr
         io.stderr = StringIO()
         ip.run_cell('parts 1')
         err = io.stderr.getvalue()
         io.stderr = save_err
-        self.assertEquals(err.split(':')[0], 'ERROR')
+        self.assertEqual(err.split(':')[0], 'ERROR')
     
     def test_trailing_newline(self):
         """test that running !(command) does not raise a SyntaxError"""
         ip.run_cell('!(true)\n', False)
         ip.run_cell('!(true)\n\n\n', False)
     
     def test_gh_597(self):
         """Pretty-printing lists of objects with non-ascii reprs may cause
         problems."""
         class Spam(object):
           def __repr__(self):
             return "\xe9"*50
         import IPython.core.formatters
         f = IPython.core.formatters.PlainTextFormatter()
         f([Spam(),Spam()])
     
 
     def test_future_flags(self):
         """Check that future flags are used for parsing code (gh-777)"""
         ip.run_cell('from __future__ import print_function')
         try:
             ip.run_cell('prfunc_return_val = print(1,2, sep=" ")')
             assert 'prfunc_return_val' in ip.user_ns
         finally:
             # Reset compiler flags so we don't mess up other tests.
             ip.compile.reset_compiler_flags()
 
     def test_future_unicode(self):
         """Check that unicode_literals is imported from __future__ (gh #786)"""
         try:
             ip.run_cell(u'byte_str = "a"')
             assert isinstance(ip.user_ns['byte_str'], str) # string literals are byte strings by default
             ip.run_cell('from __future__ import unicode_literals')
             ip.run_cell(u'unicode_str = "a"')
             assert isinstance(ip.user_ns['unicode_str'], unicode) # strings literals are now unicode
         finally:
             # Reset compiler flags so we don't mess up other tests.
             ip.compile.reset_compiler_flags()
     
     def test_can_pickle(self):
         "Can we pickle objects defined interactively (GH-29)"
         ip = get_ipython()
         ip.reset()
         ip.run_cell(("class Mylist(list):\n"
                      "    def __init__(self,x=[]):\n"
                      "        list.__init__(self,x)"))
         ip.run_cell("w=Mylist([1,2,3])")
         
         from cPickle import dumps
         
         # We need to swap in our main module - this is only necessary
         # inside the test framework, because IPython puts the interactive module
         # in place (but the test framework undoes this).
         _main = sys.modules['__main__']
         sys.modules['__main__'] = ip.user_module
         try:
             res = dumps(ip.user_ns["w"])
         finally:
             sys.modules['__main__'] = _main
         self.assertTrue(isinstance(res, bytes))
         
     def test_global_ns(self):
         "Code in functions must be able to access variables outside them."
         ip = get_ipython()
         ip.run_cell("a = 10")
         ip.run_cell(("def f(x):\n"
                      "    return x + a"))
         ip.run_cell("b = f(12)")
         self.assertEqual(ip.user_ns["b"], 22)
 
     def test_bad_custom_tb(self):
         """Check that InteractiveShell is protected from bad custom exception handlers"""
         from IPython.utils import io
         save_stderr = io.stderr
         try:
             # capture stderr
             io.stderr = StringIO()
             ip.set_custom_exc((IOError,), lambda etype,value,tb: 1/0)
-            self.assertEquals(ip.custom_exceptions, (IOError,))
+            self.assertEqual(ip.custom_exceptions, (IOError,))
             ip.run_cell(u'raise IOError("foo")')
-            self.assertEquals(ip.custom_exceptions, ())
+            self.assertEqual(ip.custom_exceptions, ())
             self.assertTrue("Custom TB Handler failed" in io.stderr.getvalue())
         finally:
             io.stderr = save_stderr
 
     def test_bad_custom_tb_return(self):
         """Check that InteractiveShell is protected from bad return types in custom exception handlers"""
         from IPython.utils import io
         save_stderr = io.stderr
         try:
             # capture stderr
             io.stderr = StringIO()
             ip.set_custom_exc((NameError,),lambda etype,value,tb, tb_offset=None: 1)
-            self.assertEquals(ip.custom_exceptions, (NameError,))
+            self.assertEqual(ip.custom_exceptions, (NameError,))
             ip.run_cell(u'a=abracadabra')
-            self.assertEquals(ip.custom_exceptions, ())
+            self.assertEqual(ip.custom_exceptions, ())
             self.assertTrue("Custom TB Handler failed" in io.stderr.getvalue())
         finally:
             io.stderr = save_stderr
 
     def test_drop_by_id(self):
         myvars = {"a":object(), "b":object(), "c": object()}
         ip.push(myvars, interactive=False)
         for name in myvars:
             assert name in ip.user_ns, name
             assert name in ip.user_ns_hidden, name
         ip.user_ns['b'] = 12
         ip.drop_by_id(myvars)
         for name in ["a", "c"]:
             assert name not in ip.user_ns, name
             assert name not in ip.user_ns_hidden, name
         assert ip.user_ns['b'] == 12
         ip.reset()
 
     def test_var_expand(self):
         ip.user_ns['f'] = u'Ca\xf1o'
         self.assertEqual(ip.var_expand(u'echo $f'), u'echo Ca\xf1o')
         self.assertEqual(ip.var_expand(u'echo {f}'), u'echo Ca\xf1o')
         self.assertEqual(ip.var_expand(u'echo {f[:-1]}'), u'echo Ca\xf1')
         self.assertEqual(ip.var_expand(u'echo {1*2}'), u'echo 2')
 
         ip.user_ns['f'] = b'Ca\xc3\xb1o'
         # This should not raise any exception:
         ip.var_expand(u'echo $f')
     
     def test_var_expand_local(self):
         """Test local variable expansion in !system and %magic calls"""
         # !system
         ip.run_cell('def test():\n'
                     '    lvar = "ttt"\n'
                     '    ret = !echo {lvar}\n'
                     '    return ret[0]\n')
         res = ip.user_ns['test']()
         nt.assert_in('ttt', res)
         
         # %magic
         ip.run_cell('def makemacro():\n'
                     '    macroname = "macro_var_expand_locals"\n'
                     '    %macro {macroname} codestr\n')
         ip.user_ns['codestr'] = "str(12)"
         ip.run_cell('makemacro()')
         nt.assert_in('macro_var_expand_locals', ip.user_ns)
     
     def test_bad_var_expand(self):
         """var_expand on invalid formats shouldn't raise"""
         # SyntaxError
         self.assertEqual(ip.var_expand(u"{'a':5}"), u"{'a':5}")
         # NameError
         self.assertEqual(ip.var_expand(u"{asdf}"), u"{asdf}")
         # ZeroDivisionError
         self.assertEqual(ip.var_expand(u"{1/0}"), u"{1/0}")
     
     def test_silent_nopostexec(self):
         """run_cell(silent=True) doesn't invoke post-exec funcs"""
         d = dict(called=False)
         def set_called():
             d['called'] = True
         
         ip.register_post_execute(set_called)
         ip.run_cell("1", silent=True)
         self.assertFalse(d['called'])
         # double-check that non-silent exec did what we expected
         # silent to avoid
         ip.run_cell("1")
         self.assertTrue(d['called'])
         # remove post-exec
         ip._post_execute.pop(set_called)
     
     def test_silent_noadvance(self):
         """run_cell(silent=True) doesn't advance execution_count"""
         ec = ip.execution_count
         # silent should force store_history=False
         ip.run_cell("1", store_history=True, silent=True)
         
-        self.assertEquals(ec, ip.execution_count)
+        self.assertEqual(ec, ip.execution_count)
         # double-check that non-silent exec did what we expected
         # silent to avoid
         ip.run_cell("1", store_history=True)
-        self.assertEquals(ec+1, ip.execution_count)
+        self.assertEqual(ec+1, ip.execution_count)
     
     def test_silent_nodisplayhook(self):
         """run_cell(silent=True) doesn't trigger displayhook"""
         d = dict(called=False)
         
         trap = ip.display_trap
         save_hook = trap.hook
         
         def failing_hook(*args, **kwargs):
             d['called'] = True
         
         try:
             trap.hook = failing_hook
             ip.run_cell("1", silent=True)
             self.assertFalse(d['called'])
             # double-check that non-silent exec did what we expected
             # silent to avoid
             ip.run_cell("1")
             self.assertTrue(d['called'])
         finally:
             trap.hook = save_hook
 
     @skipif(sys.version_info[0] >= 3, "softspace removed in py3")
     def test_print_softspace(self):
         """Verify that softspace is handled correctly when executing multiple
         statements.
 
         In [1]: print 1; print 2
         1
         2
 
         In [2]: print 1,; print 2
         1 2
         """
         
     def test_ofind_line_magic(self):
         from IPython.core.magic import register_line_magic
         
         @register_line_magic
         def lmagic(line):
             "A line magic"
 
         # Get info on line magic
         lfind = ip._ofind('lmagic')
         info = dict(found=True, isalias=False, ismagic=True,
                     namespace = 'IPython internal', obj= lmagic.__wrapped__,
                     parent = None)
         nt.assert_equal(lfind, info)
         
     def test_ofind_cell_magic(self):
         from IPython.core.magic import register_cell_magic
         
         @register_cell_magic
         def cmagic(line, cell):
             "A cell magic"
 
         # Get info on cell magic
         find = ip._ofind('cmagic')
         info = dict(found=True, isalias=False, ismagic=True,
                     namespace = 'IPython internal', obj= cmagic.__wrapped__,
                     parent = None)
         nt.assert_equal(find, info)
     
     def test_custom_exception(self):
         called = []
         def my_handler(shell, etype, value, tb, tb_offset=None):
             called.append(etype)
             shell.showtraceback((etype, value, tb), tb_offset=tb_offset)
         
         ip.set_custom_exc((ValueError,), my_handler)
         try:
             ip.run_cell("raise ValueError('test')")
             # Check that this was called, and only once.
             self.assertEqual(called, [ValueError])
         finally:
             # Reset the custom exception hook
             ip.set_custom_exc((), None)
 
 
 class TestSafeExecfileNonAsciiPath(unittest.TestCase):
 
     def setUp(self):
         self.BASETESTDIR = tempfile.mkdtemp()
         self.TESTDIR = join(self.BASETESTDIR, u"åäö")
         os.mkdir(self.TESTDIR)
         with open(join(self.TESTDIR, u"åäötestscript.py"), "w") as sfile:
             sfile.write("pass\n")
         self.oldpath = os.getcwdu()
         os.chdir(self.TESTDIR)
         self.fname = u"åäötestscript.py"
 
     def tearDown(self):
         os.chdir(self.oldpath)
         shutil.rmtree(self.BASETESTDIR)
 
     def test_1(self):
         """Test safe_execfile with non-ascii path
         """
         ip.safe_execfile(self.fname, {}, raise_exceptions=True)
 
 
 class TestSystemRaw(unittest.TestCase):
     def test_1(self):
         """Test system_raw with non-ascii cmd
         """
         cmd = ur'''python -c "'åäö'"   '''
         ip.system_raw(cmd)
 
 
 def test__IPYTHON__():
     # This shouldn't raise a NameError, that's all
     __IPYTHON__

IPython/core/tests/test_plugin.py

@@ -1,46 +1,46 b''
 """Tests for plugin.py"""
 
 #-----------------------------------------------------------------------------
 # Imports
 #-----------------------------------------------------------------------------
 
 from unittest import TestCase
 
 from IPython.core.plugin import Plugin, PluginManager
 
 #-----------------------------------------------------------------------------
 # Tests
 #-----------------------------------------------------------------------------
 
 class FooPlugin(Plugin):
     pass
 
 
 class BarPlugin(Plugin):
     pass
 
 
 class BadPlugin(object):
     pass
 
 
 class PluginTest(TestCase):
 
     def setUp(self):
         self.manager = PluginManager()
 
     def test_register_get(self):
-        self.assertEquals(None, self.manager.get_plugin('foo'))
+        self.assertEqual(None, self.manager.get_plugin('foo'))
         foo = FooPlugin()
         self.manager.register_plugin('foo', foo)
-        self.assertEquals(foo, self.manager.get_plugin('foo'))
+        self.assertEqual(foo, self.manager.get_plugin('foo'))
         bar = BarPlugin()
         self.assertRaises(KeyError, self.manager.register_plugin, 'foo', bar)
         bad = BadPlugin()
         self.assertRaises(TypeError, self.manager.register_plugin, 'bad')
 
     def test_unregister(self):
         foo = FooPlugin()
         self.manager.register_plugin('foo', foo)
         self.manager.unregister_plugin('foo')
-        self.assertEquals(None, self.manager.get_plugin('foo'))
+        self.assertEqual(None, self.manager.get_plugin('foo'))

IPython/core/tests/test_prompts.py

@@ -1,111 +1,111 b''
 # -*- coding: utf-8
 """Tests for prompt generation."""
 
 import unittest
 
 import os
 import nose.tools as nt
 
 from IPython.testing import tools as tt, decorators as dec
 from IPython.core.prompts import PromptManager, LazyEvaluate
 from IPython.testing.globalipapp import get_ipython
 from IPython.utils import py3compat
 from IPython.utils.tempdir import TemporaryDirectory
 
 ip = get_ipython()
 
 
 class PromptTests(unittest.TestCase):
     def setUp(self):
         self.pm = PromptManager(shell=ip, config=ip.config)
     
     def test_multiline_prompt(self):
         self.pm.in_template = "[In]\n>>>"
         self.pm.render('in')
         self.assertEqual(self.pm.width, 3)
         self.assertEqual(self.pm.txtwidth, 3)
         
         self.pm.in_template = '[In]\n'
         self.pm.render('in')
         self.assertEqual(self.pm.width, 0)
         self.assertEqual(self.pm.txtwidth, 0)
     
     def test_translate_abbreviations(self):
         def do_translate(template):
             self.pm.in_template = template
             return self.pm.templates['in']
         
         pairs = [(r'%n>', '{color.number}{count}{color.prompt}>'),
                  (r'\T', '{time}'),
                  (r'\n', '\n')
                 ]
     
         tt.check_pairs(do_translate, pairs)
     
     def test_user_ns(self):
         self.pm.color_scheme = 'NoColor'
         ip.ex("foo='bar'")
         self.pm.in_template = "In [{foo}]"
         prompt = self.pm.render('in')
-        self.assertEquals(prompt, u'In [bar]')
+        self.assertEqual(prompt, u'In [bar]')
 
     def test_builtins(self):
         self.pm.color_scheme = 'NoColor'
         self.pm.in_template = "In [{int}]"
         prompt = self.pm.render('in')
-        self.assertEquals(prompt, u"In [%r]" % int)
+        self.assertEqual(prompt, u"In [%r]" % int)
 
     def test_undefined(self):
         self.pm.color_scheme = 'NoColor'
         self.pm.in_template = "In [{foo_dne}]"
         prompt = self.pm.render('in')
-        self.assertEquals(prompt, u"In [<ERROR: 'foo_dne' not found>]")
+        self.assertEqual(prompt, u"In [<ERROR: 'foo_dne' not found>]")
 
     def test_render(self):
         self.pm.in_template = r'\#>'
         self.assertEqual(self.pm.render('in',color=False), '%d>' % ip.execution_count)
     
     def test_render_unicode_cwd(self):
         save = os.getcwdu()
         with TemporaryDirectory(u'ünicødé') as td:
             os.chdir(td)
             self.pm.in_template = r'\w [\#]'
             p = self.pm.render('in', color=False)
-            self.assertEquals(p, u"%s [%i]" % (os.getcwdu(), ip.execution_count))
+            self.assertEqual(p, u"%s [%i]" % (os.getcwdu(), ip.execution_count))
         os.chdir(save)
     
     def test_lazy_eval_unicode(self):
         u = u'ünicødé'
         lz = LazyEvaluate(lambda : u)
         # str(lz) would fail
-        self.assertEquals(unicode(lz), u)
-        self.assertEquals(format(lz), u)
+        self.assertEqual(unicode(lz), u)
+        self.assertEqual(format(lz), u)
     
     def test_lazy_eval_nonascii_bytes(self):
         u = u'ünicødé'
         b = u.encode('utf8')
         lz = LazyEvaluate(lambda : b)
         # unicode(lz) would fail
-        self.assertEquals(str(lz), str(b))
-        self.assertEquals(format(lz), str(b))
+        self.assertEqual(str(lz), str(b))
+        self.assertEqual(format(lz), str(b))
     
     def test_lazy_eval_float(self):
         f = 0.503
         lz = LazyEvaluate(lambda : f)
         
-        self.assertEquals(str(lz), str(f))
-        self.assertEquals(unicode(lz), unicode(f))
-        self.assertEquals(format(lz), str(f))
-        self.assertEquals(format(lz, '.1'), '0.5')
+        self.assertEqual(str(lz), str(f))
+        self.assertEqual(unicode(lz), unicode(f))
+        self.assertEqual(format(lz), str(f))
+        self.assertEqual(format(lz, '.1'), '0.5')
     
     @dec.skip_win32
     def test_cwd_x(self):
         self.pm.in_template = r"\X0"
         save = os.getcwdu()
         os.chdir(os.path.expanduser('~'))
         p = self.pm.render('in', color=False)
         try:
-            self.assertEquals(p, '~')
+            self.assertEqual(p, '~')
         finally:
             os.chdir(save)
     

IPython/frontend/html/notebook/tests/test_kernelsession.py

@@ -1,27 +1,27 b''
 """Tests for the notebook kernel and session manager."""
 
 from unittest import TestCase
 
 from IPython.frontend.html.notebook.kernelmanager import MultiKernelManager
 
 class TestKernelManager(TestCase):
 
     def test_km_lifecycle(self):
         km = MultiKernelManager()
         kid = km.start_kernel()
         self.assert_(kid in km)
-        self.assertEquals(len(km),1)
+        self.assertEqual(len(km),1)
         km.kill_kernel(kid)
         self.assert_(not kid in km)
 
         kid = km.start_kernel()
-        self.assertEquals('127.0.0.1',km.get_kernel_ip(kid))
+        self.assertEqual('127.0.0.1',km.get_kernel_ip(kid))
         port_dict = km.get_kernel_ports(kid)
         self.assert_('stdin_port' in port_dict)
         self.assert_('iopub_port' in port_dict)
         self.assert_('shell_port' in port_dict)
         self.assert_('hb_port' in port_dict)
         km.get_kernel(kid)
         km.kill_kernel(kid)
 
 

IPython/frontend/html/notebook/tests/test_nbmanager.py

@@ -1,34 +1,34 b''
 """Tests for the notebook manager."""
 
 import os
 from unittest import TestCase
 from tempfile import NamedTemporaryFile
 
 from IPython.utils.tempdir import TemporaryDirectory
 from IPython.utils.traitlets import TraitError
 
 from IPython.frontend.html.notebook.notebookmanager import NotebookManager
 
 class TestNotebookManager(TestCase):
 
     def test_nb_dir(self):
         with TemporaryDirectory() as td:
             km = NotebookManager(notebook_dir=td)
-            self.assertEquals(km.notebook_dir, td)
+            self.assertEqual(km.notebook_dir, td)
 
     def test_create_nb_dir(self):
         with TemporaryDirectory() as td:
             nbdir = os.path.join(td, 'notebooks')
             km = NotebookManager(notebook_dir=nbdir)
-            self.assertEquals(km.notebook_dir, nbdir)
+            self.assertEqual(km.notebook_dir, nbdir)
 
     def test_missing_nb_dir(self):
         with TemporaryDirectory() as td:
             nbdir = os.path.join(td, 'notebook', 'dir', 'is', 'missing')
             self.assertRaises(TraitError, NotebookManager, notebook_dir=nbdir)
 
     def test_invalid_nb_dir(self):
         with NamedTemporaryFile() as tf:
             self.assertRaises(TraitError, NotebookManager, notebook_dir=tf.name)
 
 

IPython/frontend/qt/console/tests/test_ansi_code_processor.py

@@ -1,171 +1,171 b''
 # Standard library imports
 import unittest
 
 # Local imports
 from IPython.frontend.qt.console.ansi_code_processor import AnsiCodeProcessor
 
 
 class TestAnsiCodeProcessor(unittest.TestCase):
 
     def setUp(self):
         self.processor = AnsiCodeProcessor()
 
     def test_clear(self):
         """ Do control sequences for clearing the console work?
         """
         string = '\x1b[2J\x1b[K'
         i = -1
         for i, substring in enumerate(self.processor.split_string(string)):
             if i == 0:
-                self.assertEquals(len(self.processor.actions), 1)
+                self.assertEqual(len(self.processor.actions), 1)
                 action = self.processor.actions[0]
-                self.assertEquals(action.action, 'erase')
-                self.assertEquals(action.area, 'screen')
-                self.assertEquals(action.erase_to, 'all')
+                self.assertEqual(action.action, 'erase')
+                self.assertEqual(action.area, 'screen')
+                self.assertEqual(action.erase_to, 'all')
             elif i == 1:
-                self.assertEquals(len(self.processor.actions), 1)
+                self.assertEqual(len(self.processor.actions), 1)
                 action = self.processor.actions[0]
-                self.assertEquals(action.action, 'erase')
-                self.assertEquals(action.area, 'line')
-                self.assertEquals(action.erase_to, 'end')
+                self.assertEqual(action.action, 'erase')
+                self.assertEqual(action.area, 'line')
+                self.assertEqual(action.erase_to, 'end')
             else:
                 self.fail('Too many substrings.')
-        self.assertEquals(i, 1, 'Too few substrings.')
+        self.assertEqual(i, 1, 'Too few substrings.')
 
     def test_colors(self):
         """ Do basic controls sequences for colors work?
         """
         string = 'first\x1b[34mblue\x1b[0mlast'
         i = -1
         for i, substring in enumerate(self.processor.split_string(string)):
             if i == 0:
-                self.assertEquals(substring, 'first')
-                self.assertEquals(self.processor.foreground_color, None)
+                self.assertEqual(substring, 'first')
+                self.assertEqual(self.processor.foreground_color, None)
             elif i == 1:
-                self.assertEquals(substring, 'blue')
-                self.assertEquals(self.processor.foreground_color, 4)
+                self.assertEqual(substring, 'blue')
+                self.assertEqual(self.processor.foreground_color, 4)
             elif i == 2:
-                self.assertEquals(substring, 'last')
-                self.assertEquals(self.processor.foreground_color, None)
+                self.assertEqual(substring, 'last')
+                self.assertEqual(self.processor.foreground_color, None)
             else:
                 self.fail('Too many substrings.')
-        self.assertEquals(i, 2, 'Too few substrings.')
+        self.assertEqual(i, 2, 'Too few substrings.')
 
     def test_colors_xterm(self):
         """ Do xterm-specific control sequences for colors work?
         """
         string = '\x1b]4;20;rgb:ff/ff/ff\x1b' \
             '\x1b]4;25;rgbi:1.0/1.0/1.0\x1b'
         substrings = list(self.processor.split_string(string))
         desired = { 20 : (255, 255, 255),
                     25 : (255, 255, 255) }
-        self.assertEquals(self.processor.color_map, desired)
+        self.assertEqual(self.processor.color_map, desired)
 
         string = '\x1b[38;5;20m\x1b[48;5;25m'
         substrings = list(self.processor.split_string(string))
-        self.assertEquals(self.processor.foreground_color, 20)
-        self.assertEquals(self.processor.background_color, 25)
+        self.assertEqual(self.processor.foreground_color, 20)
+        self.assertEqual(self.processor.background_color, 25)
 
     def test_scroll(self):
         """ Do control sequences for scrolling the buffer work?
         """
         string = '\x1b[5S\x1b[T'
         i = -1
         for i, substring in enumerate(self.processor.split_string(string)):
             if i == 0:
-                self.assertEquals(len(self.processor.actions), 1)
+                self.assertEqual(len(self.processor.actions), 1)
                 action = self.processor.actions[0]
-                self.assertEquals(action.action, 'scroll')
-                self.assertEquals(action.dir, 'up')
-                self.assertEquals(action.unit, 'line')
-                self.assertEquals(action.count, 5)
+                self.assertEqual(action.action, 'scroll')
+                self.assertEqual(action.dir, 'up')
+                self.assertEqual(action.unit, 'line')
+                self.assertEqual(action.count, 5)
             elif i == 1:
-                self.assertEquals(len(self.processor.actions), 1)
+                self.assertEqual(len(self.processor.actions), 1)
                 action = self.processor.actions[0]
-                self.assertEquals(action.action, 'scroll')
-                self.assertEquals(action.dir, 'down')
-                self.assertEquals(action.unit, 'line')
-                self.assertEquals(action.count, 1)
+                self.assertEqual(action.action, 'scroll')
+                self.assertEqual(action.dir, 'down')
+                self.assertEqual(action.unit, 'line')
+                self.assertEqual(action.count, 1)
             else:
                 self.fail('Too many substrings.')
-        self.assertEquals(i, 1, 'Too few substrings.')
+        self.assertEqual(i, 1, 'Too few substrings.')
 
     def test_formfeed(self):
         """ Are formfeed characters processed correctly?
         """
         string = '\f' # form feed
-        self.assertEquals(list(self.processor.split_string(string)), [''])
-        self.assertEquals(len(self.processor.actions), 1)
+        self.assertEqual(list(self.processor.split_string(string)), [''])
+        self.assertEqual(len(self.processor.actions), 1)
         action = self.processor.actions[0]
-        self.assertEquals(action.action, 'scroll')
-        self.assertEquals(action.dir, 'down')
-        self.assertEquals(action.unit, 'page')
-        self.assertEquals(action.count, 1)
+        self.assertEqual(action.action, 'scroll')
+        self.assertEqual(action.dir, 'down')
+        self.assertEqual(action.unit, 'page')
+        self.assertEqual(action.count, 1)
 
     def test_carriage_return(self):
         """ Are carriage return characters processed correctly?
         """
         string = 'foo\rbar' # carriage return
         splits = []
         actions = []
         for split in self.processor.split_string(string):
             splits.append(split)
             actions.append([action.action for action in self.processor.actions])
-        self.assertEquals(splits, ['foo', None, 'bar'])
-        self.assertEquals(actions, [[], ['carriage-return'], []])
+        self.assertEqual(splits, ['foo', None, 'bar'])
+        self.assertEqual(actions, [[], ['carriage-return'], []])
 
     def test_carriage_return_newline(self):
         """transform CRLF to LF"""
         string = 'foo\rbar\r\ncat\r\n\n' # carriage return and newline
         # only one CR action should occur, and '\r\n' should transform to '\n'
         splits = []
         actions = []
         for split in self.processor.split_string(string):
             splits.append(split)
             actions.append([action.action for action in self.processor.actions])
-        self.assertEquals(splits, ['foo', None, 'bar', '\r\n', 'cat', '\r\n', '\n'])
-        self.assertEquals(actions, [[], ['carriage-return'], [], ['newline'], [], ['newline'], ['newline']])
+        self.assertEqual(splits, ['foo', None, 'bar', '\r\n', 'cat', '\r\n', '\n'])
+        self.assertEqual(actions, [[], ['carriage-return'], [], ['newline'], [], ['newline'], ['newline']])
 
     def test_beep(self):
         """ Are beep characters processed correctly?
         """
         string = 'foo\abar' # bell
         splits = []
         actions = []
         for split in self.processor.split_string(string):
             splits.append(split)
             actions.append([action.action for action in self.processor.actions])
-        self.assertEquals(splits, ['foo', None, 'bar'])
-        self.assertEquals(actions, [[], ['beep'], []])
+        self.assertEqual(splits, ['foo', None, 'bar'])
+        self.assertEqual(actions, [[], ['beep'], []])
 
     def test_backspace(self):
         """ Are backspace characters processed correctly?
         """
         string = 'foo\bbar' # backspace
         splits = []
         actions = []
         for split in self.processor.split_string(string):
             splits.append(split)
             actions.append([action.action for action in self.processor.actions])
-        self.assertEquals(splits, ['foo', None, 'bar'])
-        self.assertEquals(actions, [[], ['backspace'], []])
+        self.assertEqual(splits, ['foo', None, 'bar'])
+        self.assertEqual(actions, [[], ['backspace'], []])
 
     def test_combined(self):
         """ Are CR and BS characters processed correctly in combination?
 
         BS is treated as a change in print position, rather than a
         backwards character deletion.  Therefore a BS at EOL is
         effectively ignored.
         """
         string = 'abc\rdef\b' # CR and backspace
         splits = []
         actions = []
         for split in self.processor.split_string(string):
             splits.append(split)
             actions.append([action.action for action in self.processor.actions])
-        self.assertEquals(splits, ['abc', None, 'def', None])
-        self.assertEquals(actions, [[], ['carriage-return'], [], ['backspace']])
+        self.assertEqual(splits, ['abc', None, 'def', None])
+        self.assertEqual(actions, [[], ['carriage-return'], [], ['backspace']])
 
 
 if __name__ == '__main__':
     unittest.main()

IPython/frontend/qt/console/tests/test_completion_lexer.py

@@ -1,47 +1,47 b''
 # Standard library imports
 import unittest
 
 # System library imports
 from pygments.lexers import CLexer, CppLexer, PythonLexer
 
 # Local imports
 from IPython.frontend.qt.console.completion_lexer import CompletionLexer
 
 
 class TestCompletionLexer(unittest.TestCase):
     
     def testPython(self):
         """ Does the CompletionLexer work for Python?
         """
         lexer = CompletionLexer(PythonLexer())
 
         # Test simplest case.
-        self.assertEquals(lexer.get_context("foo.bar.baz"),
+        self.assertEqual(lexer.get_context("foo.bar.baz"),
                           [ "foo", "bar", "baz" ])
 
         # Test trailing period.
-        self.assertEquals(lexer.get_context("foo.bar."), [ "foo", "bar", "" ])
+        self.assertEqual(lexer.get_context("foo.bar."), [ "foo", "bar", "" ])
 
         # Test with prompt present.
-        self.assertEquals(lexer.get_context(">>> foo.bar.baz"),
+        self.assertEqual(lexer.get_context(">>> foo.bar.baz"),
                           [ "foo", "bar", "baz" ])
 
         # Test spacing in name.
-        self.assertEquals(lexer.get_context("foo.bar. baz"), [ "baz" ])
+        self.assertEqual(lexer.get_context("foo.bar. baz"), [ "baz" ])
 
         # Test parenthesis.
-        self.assertEquals(lexer.get_context("foo("), [])
+        self.assertEqual(lexer.get_context("foo("), [])
 
     def testC(self):
         """ Does the CompletionLexer work for C/C++?
         """
         lexer = CompletionLexer(CLexer())
-        self.assertEquals(lexer.get_context("foo.bar"), [ "foo", "bar" ])
-        self.assertEquals(lexer.get_context("foo->bar"), [ "foo", "bar" ])
+        self.assertEqual(lexer.get_context("foo.bar"), [ "foo", "bar" ])
+        self.assertEqual(lexer.get_context("foo->bar"), [ "foo", "bar" ])
 
         lexer = CompletionLexer(CppLexer())
-        self.assertEquals(lexer.get_context("Foo::Bar"), [ "Foo", "Bar" ])
+        self.assertEqual(lexer.get_context("Foo::Bar"), [ "Foo", "Bar" ])
 
 
 if __name__ == '__main__':
     unittest.main()

IPython/frontend/qt/console/tests/test_console_widget.py

@@ -1,42 +1,42 b''
 # Standard library imports
 import unittest
 
 # System library imports
 from IPython.external.qt import QtGui
 
 # Local imports
 from IPython.frontend.qt.console.console_widget import ConsoleWidget
 
 
 class TestConsoleWidget(unittest.TestCase):
 
     @classmethod
     def setUpClass(cls):
         """ Create the application for the test case.
         """
         cls._app = QtGui.QApplication.instance()
         if cls._app is None:
             cls._app = QtGui.QApplication([])
         cls._app.setQuitOnLastWindowClosed(False)
 
     @classmethod
     def tearDownClass(cls):
         """ Exit the application.
         """
         QtGui.QApplication.quit()
 
     def test_special_characters(self):
         """ Are special characters displayed correctly?
         """
         w = ConsoleWidget()
         cursor = w._get_prompt_cursor()
 
         test_inputs = ['xyz\b\b=\n', 'foo\b\nbar\n', 'foo\b\nbar\r\n', 'abc\rxyz\b\b=']
         expected_outputs = [u'x=z\u2029', u'foo\u2029bar\u2029', u'foo\u2029bar\u2029', 'x=z']
         for i, text in enumerate(test_inputs):
             w._insert_plain_text(cursor, text)
             cursor.select(cursor.Document)
             selection = cursor.selectedText()
-            self.assertEquals(expected_outputs[i], selection)
+            self.assertEqual(expected_outputs[i], selection)
             # clear all the text
             cursor.insertText('')

IPython/frontend/terminal/tests/test_interactivshell.py

@@ -1,171 +1,171 b''
 # -*- coding: utf-8 -*-
 """Tests for the key interactiveshell module.
 
 Authors
 -------
 * Julian Taylor
 """
 #-----------------------------------------------------------------------------
 #  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
 #-----------------------------------------------------------------------------
 # stdlib
 import sys
 import unittest
 
 from IPython.testing.decorators import skipif
 from IPython.utils import py3compat
 
 class InteractiveShellTestCase(unittest.TestCase):
     def rl_hist_entries(self, rl, n):
         """Get last n readline history entries as a list"""
         return [rl.get_history_item(rl.get_current_history_length() - x)
                 for x in range(n - 1, -1, -1)]
 
     def test_runs_without_rl(self):
         """Test that function does not throw without readline"""
         ip = get_ipython()
         ip.has_readline = False
         ip.readline = None
         ip._replace_rlhist_multiline(u'source', 0)
 
     @skipif(not get_ipython().has_readline, 'no readline')
     def test_runs_without_remove_history_item(self):
         """Test that function does not throw on windows without
            remove_history_item"""
         ip = get_ipython()
         if hasattr(ip.readline, 'remove_history_item'):
             del ip.readline.remove_history_item
         ip._replace_rlhist_multiline(u'source', 0)
 
     @skipif(not get_ipython().has_readline, 'no readline')
     @skipif(not hasattr(get_ipython().readline, 'remove_history_item'),
             'no remove_history_item')
     def test_replace_multiline_hist_disabled(self):
         """Test that multiline replace does nothing if disabled"""
         ip = get_ipython()
         ip.multiline_history = False
 
         ghist = [u'line1', u'line2']
         for h in ghist:
            ip.readline.add_history(h)
         hlen_b4_cell = ip.readline.get_current_history_length()
         hlen_b4_cell = ip._replace_rlhist_multiline(u'sourc€\nsource2',
                                                     hlen_b4_cell)
 
-        self.assertEquals(ip.readline.get_current_history_length(),
+        self.assertEqual(ip.readline.get_current_history_length(),
                           hlen_b4_cell)
         hist = self.rl_hist_entries(ip.readline, 2)
-        self.assertEquals(hist, ghist)
+        self.assertEqual(hist, ghist)
 
     @skipif(not get_ipython().has_readline, 'no readline')
     @skipif(not hasattr(get_ipython().readline, 'remove_history_item'),
             'no remove_history_item')
     def test_replace_multiline_hist_adds(self):
         """Test that multiline replace function adds history"""
         ip = get_ipython()
 
         hlen_b4_cell = ip.readline.get_current_history_length()
         hlen_b4_cell = ip._replace_rlhist_multiline(u'sourc€', hlen_b4_cell)
 
-        self.assertEquals(hlen_b4_cell,
+        self.assertEqual(hlen_b4_cell,
                           ip.readline.get_current_history_length())
 
     @skipif(not get_ipython().has_readline, 'no readline')
     @skipif(not hasattr(get_ipython().readline, 'remove_history_item'),
             'no remove_history_item')
     def test_replace_multiline_hist_keeps_history(self):
         """Test that multiline replace does not delete history"""
         ip = get_ipython()
         ip.multiline_history = True
 
         ghist = [u'line1', u'line2']
         for h in ghist:
            ip.readline.add_history(h)
 
         #start cell
         hlen_b4_cell = ip.readline.get_current_history_length()
 		# nothing added to rl history, should do nothing
         hlen_b4_cell = ip._replace_rlhist_multiline(u'sourc€\nsource2',
                                                     hlen_b4_cell)
 
-        self.assertEquals(ip.readline.get_current_history_length(),
+        self.assertEqual(ip.readline.get_current_history_length(),
                           hlen_b4_cell)
         hist = self.rl_hist_entries(ip.readline, 2)
-        self.assertEquals(hist, ghist)
+        self.assertEqual(hist, ghist)
 
 
     @skipif(not get_ipython().has_readline, 'no readline')
     @skipif(not hasattr(get_ipython().readline, 'remove_history_item'),
             'no remove_history_item')
     def test_replace_multiline_hist_replaces_twice(self):
         """Test that multiline entries are replaced twice"""
         ip = get_ipython()
         ip.multiline_history = True
 
         ip.readline.add_history(u'line0')
         #start cell
         hlen_b4_cell = ip.readline.get_current_history_length()
         ip.readline.add_history('l€ne1')
         ip.readline.add_history('line2')
         #replace cell with single line
         hlen_b4_cell = ip._replace_rlhist_multiline(u'l€ne1\nline2',
                                                     hlen_b4_cell)
         ip.readline.add_history('l€ne3')
         ip.readline.add_history('line4')
         #replace cell with single line
         hlen_b4_cell = ip._replace_rlhist_multiline(u'l€ne3\nline4',
                                                     hlen_b4_cell)
 
-        self.assertEquals(ip.readline.get_current_history_length(),
+        self.assertEqual(ip.readline.get_current_history_length(),
                           hlen_b4_cell)
         hist = self.rl_hist_entries(ip.readline, 3)
         expected = [u'line0', u'l€ne1\nline2', u'l€ne3\nline4']
         # perform encoding, in case of casting due to ASCII locale
         enc = sys.stdin.encoding or "utf-8"
         expected = [ py3compat.unicode_to_str(e, enc) for e in expected ]
-        self.assertEquals(hist, expected)
+        self.assertEqual(hist, expected)
 
 
     @skipif(not get_ipython().has_readline, 'no readline')
     @skipif(not hasattr(get_ipython().readline, 'remove_history_item'),
             'no remove_history_item')
     def test_replace_multiline_hist_replaces_empty_line(self):
         """Test that multiline history skips empty line cells"""
         ip = get_ipython()
         ip.multiline_history = True
 
         ip.readline.add_history(u'line0')
         #start cell
         hlen_b4_cell = ip.readline.get_current_history_length()
         ip.readline.add_history('l€ne1')
         ip.readline.add_history('line2')
         hlen_b4_cell = ip._replace_rlhist_multiline(u'l€ne1\nline2',
                                                     hlen_b4_cell)
         ip.readline.add_history('')
         hlen_b4_cell = ip._replace_rlhist_multiline(u'', hlen_b4_cell)
         ip.readline.add_history('l€ne3')
         hlen_b4_cell = ip._replace_rlhist_multiline(u'l€ne3', hlen_b4_cell)
         ip.readline.add_history('  ')
         hlen_b4_cell = ip._replace_rlhist_multiline('  ', hlen_b4_cell)
         ip.readline.add_history('\t')
         ip.readline.add_history('\t ')
         hlen_b4_cell = ip._replace_rlhist_multiline('\t', hlen_b4_cell)
         ip.readline.add_history('line4')
         hlen_b4_cell = ip._replace_rlhist_multiline(u'line4', hlen_b4_cell)
 
-        self.assertEquals(ip.readline.get_current_history_length(),
+        self.assertEqual(ip.readline.get_current_history_length(),
                           hlen_b4_cell)
         hist = self.rl_hist_entries(ip.readline, 4)
         # expect no empty cells in history
         expected = [u'line0', u'l€ne1\nline2', u'l€ne3', u'line4']
         # perform encoding, in case of casting due to ASCII locale
         enc = sys.stdin.encoding or "utf-8"
         expected = [ py3compat.unicode_to_str(e, enc) for e in expected ]
-        self.assertEquals(hist, expected)
+        self.assertEqual(hist, expected)

IPython/nbformat/v1/tests/test_json.py

@@ -1,14 +1,14 b''
 from unittest import TestCase
 
 from ..nbjson import reads, writes
 from .nbexamples import nb0
 
 
 class TestJSON(TestCase):
 
     def test_roundtrip(self):
         s = writes(nb0)
-        self.assertEquals(reads(s),nb0)
+        self.assertEqual(reads(s),nb0)
 
 
 

IPython/nbformat/v1/tests/test_nbbase.py

@@ -1,41 +1,41 b''
 from unittest import TestCase
 
 from ..nbbase import (
     NotebookNode,
     new_code_cell, new_text_cell, new_notebook
 )
 
 class TestCell(TestCase):
 
     def test_empty_code_cell(self):
         cc = new_code_cell()
-        self.assertEquals(cc.cell_type,'code')
-        self.assertEquals('code' not in cc, True)
-        self.assertEquals('prompt_number' not in cc, True)
+        self.assertEqual(cc.cell_type,'code')
+        self.assertEqual('code' not in cc, True)
+        self.assertEqual('prompt_number' not in cc, True)
 
     def test_code_cell(self):
         cc = new_code_cell(code='a=10', prompt_number=0)
-        self.assertEquals(cc.code, u'a=10')
-        self.assertEquals(cc.prompt_number, 0)
+        self.assertEqual(cc.code, u'a=10')
+        self.assertEqual(cc.prompt_number, 0)
 
     def test_empty_text_cell(self):
         tc = new_text_cell()
-        self.assertEquals(tc.cell_type, 'text')
-        self.assertEquals('text' not in tc, True)
+        self.assertEqual(tc.cell_type, 'text')
+        self.assertEqual('text' not in tc, True)
 
     def test_text_cell(self):
         tc = new_text_cell('hi')
-        self.assertEquals(tc.text, u'hi')
+        self.assertEqual(tc.text, u'hi')
 
 
 class TestNotebook(TestCase):
 
     def test_empty_notebook(self):
         nb = new_notebook()
-        self.assertEquals(nb.cells, [])
+        self.assertEqual(nb.cells, [])
 
     def test_notebooke(self):
         cells = [new_code_cell(),new_text_cell()]
         nb = new_notebook(cells=cells)
-        self.assertEquals(nb.cells,cells)
+        self.assertEqual(nb.cells,cells)
 

IPython/nbformat/v2/tests/test_json.py

@@ -1,34 +1,34 b''
 import pprint
 from unittest import TestCase
 
 from ..nbjson import reads, writes
 from .nbexamples import nb0
 
 
 class TestJSON(TestCase):
 
     def test_roundtrip(self):
         s = writes(nb0)
 #        print
 #        print pprint.pformat(nb0,indent=2)
 #        print
 #        print pprint.pformat(reads(s),indent=2)
 #        print
 #        print s
-        self.assertEquals(reads(s),nb0)
+        self.assertEqual(reads(s),nb0)
     
     def test_roundtrip_nosplit(self):
         """Ensure that multiline blobs are still readable"""
         # ensures that notebooks written prior to splitlines change
         # are still readable.
         s = writes(nb0, split_lines=False)
-        self.assertEquals(reads(s),nb0)
+        self.assertEqual(reads(s),nb0)
 
     def test_roundtrip_split(self):
         """Ensure that splitting multiline blocks is safe"""
         # This won't differ from test_roundtrip unless the default changes
         s = writes(nb0, split_lines=True)
-        self.assertEquals(reads(s),nb0)
+        self.assertEqual(reads(s),nb0)
 
 
 

IPython/nbformat/v2/tests/test_nbbase.py

@@ -1,113 +1,113 b''
 from unittest import TestCase
 
 from ..nbbase import (
     NotebookNode,
     new_code_cell, new_text_cell, new_worksheet, new_notebook, new_output,
     new_author, new_metadata
 )
 
 class TestCell(TestCase):
 
     def test_empty_code_cell(self):
         cc = new_code_cell()
-        self.assertEquals(cc.cell_type,u'code')
-        self.assertEquals(u'input' not in cc, True)
-        self.assertEquals(u'prompt_number' not in cc, True)
-        self.assertEquals(cc.outputs, [])
-        self.assertEquals(cc.collapsed, False)
+        self.assertEqual(cc.cell_type,u'code')
+        self.assertEqual(u'input' not in cc, True)
+        self.assertEqual(u'prompt_number' not in cc, True)
+        self.assertEqual(cc.outputs, [])
+        self.assertEqual(cc.collapsed, False)
 
     def test_code_cell(self):
         cc = new_code_cell(input='a=10', prompt_number=0, collapsed=True)
         cc.outputs = [new_output(output_type=u'pyout',
             output_svg=u'foo',output_text=u'10',prompt_number=0)]
-        self.assertEquals(cc.input, u'a=10')
-        self.assertEquals(cc.prompt_number, 0)
-        self.assertEquals(cc.language, u'python')
-        self.assertEquals(cc.outputs[0].svg, u'foo')
-        self.assertEquals(cc.outputs[0].text, u'10')
-        self.assertEquals(cc.outputs[0].prompt_number, 0)
-        self.assertEquals(cc.collapsed, True)
+        self.assertEqual(cc.input, u'a=10')
+        self.assertEqual(cc.prompt_number, 0)
+        self.assertEqual(cc.language, u'python')
+        self.assertEqual(cc.outputs[0].svg, u'foo')
+        self.assertEqual(cc.outputs[0].text, u'10')
+        self.assertEqual(cc.outputs[0].prompt_number, 0)
+        self.assertEqual(cc.collapsed, True)
 
     def test_pyerr(self):
         o = new_output(output_type=u'pyerr', etype=u'NameError',
             evalue=u'Name not found', traceback=[u'frame 0', u'frame 1', u'frame 2']
         )
-        self.assertEquals(o.output_type, u'pyerr')
-        self.assertEquals(o.etype, u'NameError')
-        self.assertEquals(o.evalue, u'Name not found')
-        self.assertEquals(o.traceback, [u'frame 0', u'frame 1', u'frame 2'])
+        self.assertEqual(o.output_type, u'pyerr')
+        self.assertEqual(o.etype, u'NameError')
+        self.assertEqual(o.evalue, u'Name not found')
+        self.assertEqual(o.traceback, [u'frame 0', u'frame 1', u'frame 2'])
 
     def test_empty_html_cell(self):
         tc = new_text_cell(u'html')
-        self.assertEquals(tc.cell_type, u'html')
-        self.assertEquals(u'source' not in tc, True)
-        self.assertEquals(u'rendered' not in tc, True)
+        self.assertEqual(tc.cell_type, u'html')
+        self.assertEqual(u'source' not in tc, True)
+        self.assertEqual(u'rendered' not in tc, True)
 
     def test_html_cell(self):
         tc = new_text_cell(u'html', 'hi', 'hi')
-        self.assertEquals(tc.source, u'hi')
-        self.assertEquals(tc.rendered, u'hi')
+        self.assertEqual(tc.source, u'hi')
+        self.assertEqual(tc.rendered, u'hi')
 
     def test_empty_markdown_cell(self):
         tc = new_text_cell(u'markdown')
-        self.assertEquals(tc.cell_type, u'markdown')
-        self.assertEquals(u'source' not in tc, True)
-        self.assertEquals(u'rendered' not in tc, True)
+        self.assertEqual(tc.cell_type, u'markdown')
+        self.assertEqual(u'source' not in tc, True)
+        self.assertEqual(u'rendered' not in tc, True)
 
     def test_markdown_cell(self):
         tc = new_text_cell(u'markdown', 'hi', 'hi')
-        self.assertEquals(tc.source, u'hi')
-        self.assertEquals(tc.rendered, u'hi')
+        self.assertEqual(tc.source, u'hi')
+        self.assertEqual(tc.rendered, u'hi')
 
 
 class TestWorksheet(TestCase):
 
     def test_empty_worksheet(self):
         ws = new_worksheet()
-        self.assertEquals(ws.cells,[])
-        self.assertEquals(u'name' not in ws, True)
+        self.assertEqual(ws.cells,[])
+        self.assertEqual(u'name' not in ws, True)
 
     def test_worksheet(self):
         cells = [new_code_cell(), new_text_cell(u'html')]
         ws = new_worksheet(cells=cells,name=u'foo')
-        self.assertEquals(ws.cells,cells)
-        self.assertEquals(ws.name,u'foo')
+        self.assertEqual(ws.cells,cells)
+        self.assertEqual(ws.name,u'foo')
 
 class TestNotebook(TestCase):
 
     def test_empty_notebook(self):
         nb = new_notebook()
-        self.assertEquals(nb.worksheets, [])
-        self.assertEquals(nb.metadata, NotebookNode())
-        self.assertEquals(nb.nbformat,2)
+        self.assertEqual(nb.worksheets, [])
+        self.assertEqual(nb.metadata, NotebookNode())
+        self.assertEqual(nb.nbformat,2)
 
     def test_notebook(self):
         worksheets = [new_worksheet(),new_worksheet()]
         metadata = new_metadata(name=u'foo')
         nb = new_notebook(metadata=metadata,worksheets=worksheets)
-        self.assertEquals(nb.metadata.name,u'foo')
-        self.assertEquals(nb.worksheets,worksheets)
-        self.assertEquals(nb.nbformat,2)
+        self.assertEqual(nb.metadata.name,u'foo')
+        self.assertEqual(nb.worksheets,worksheets)
+        self.assertEqual(nb.nbformat,2)
 
 class TestMetadata(TestCase):
 
     def test_empty_metadata(self):
         md = new_metadata()
-        self.assertEquals(u'name' not in md, True)
-        self.assertEquals(u'authors' not in md, True)
-        self.assertEquals(u'license' not in md, True)
-        self.assertEquals(u'saved' not in md, True)
-        self.assertEquals(u'modified' not in md, True)
-        self.assertEquals(u'gistid' not in md, True)
+        self.assertEqual(u'name' not in md, True)
+        self.assertEqual(u'authors' not in md, True)
+        self.assertEqual(u'license' not in md, True)
+        self.assertEqual(u'saved' not in md, True)
+        self.assertEqual(u'modified' not in md, True)
+        self.assertEqual(u'gistid' not in md, True)
 
     def test_metadata(self):
         authors = [new_author(name='Bart Simpson',email='[e-mail]')]
         md = new_metadata(name=u'foo',license=u'BSD',created=u'today',
             modified=u'now',gistid=u'21341231',authors=authors)
-        self.assertEquals(md.name, u'foo')
-        self.assertEquals(md.license, u'BSD')
-        self.assertEquals(md.created, u'today')
-        self.assertEquals(md.modified, u'now')
-        self.assertEquals(md.gistid, u'21341231')
-        self.assertEquals(md.authors, authors)
+        self.assertEqual(md.name, u'foo')
+        self.assertEqual(md.license, u'BSD')
+        self.assertEqual(md.created, u'today')
+        self.assertEqual(md.modified, u'now')
+        self.assertEqual(md.gistid, u'21341231')
+        self.assertEqual(md.authors, authors)
 

IPython/nbformat/v2/tests/test_nbpy.py

@@ -1,17 +1,17 b''
 from unittest import TestCase
 
 from ..nbbase import (
     NotebookNode,
     new_code_cell, new_text_cell, new_worksheet, new_notebook
 )
 
 from ..nbpy import reads, writes
 from .nbexamples import nb0, nb0_py
 
 
 class TestPy(TestCase):
 
     def test_write(self):
         s = writes(nb0)
-        self.assertEquals(s,nb0_py)
+        self.assertEqual(s,nb0_py)
 

IPython/nbformat/v3/tests/formattest.py

@@ -1,63 +1,63 b''
 # -*- coding: utf8 -*-
 import io
 import os
 import shutil
 import tempfile
 
 pjoin = os.path.join
 
 from ..nbbase import (
     NotebookNode,
     new_code_cell, new_text_cell, new_worksheet, new_notebook
 )
 
 from ..nbpy import reads, writes, read, write
 from .nbexamples import nb0, nb0_py
 
 
 def open_utf8(fname, mode):
     return io.open(fname, mode=mode, encoding='utf-8')
 
 class NBFormatTest:
     """Mixin for writing notebook format tests"""
 
     # override with appropriate values in subclasses
     nb0_ref = None
     ext = None
     mod = None
     
     def setUp(self):
         self.wd = tempfile.mkdtemp()
     
     def tearDown(self):
         shutil.rmtree(self.wd)
     
     def assertNBEquals(self, nba, nbb):
-        self.assertEquals(nba, nbb)
+        self.assertEqual(nba, nbb)
         
     def test_writes(self):
         s = self.mod.writes(nb0)
         if self.nb0_ref:
-            self.assertEquals(s, self.nb0_ref)
+            self.assertEqual(s, self.nb0_ref)
 
     def test_reads(self):
         s = self.mod.writes(nb0)
         nb = self.mod.reads(s)
 
     def test_roundtrip(self):
         s = self.mod.writes(nb0)
         self.assertNBEquals(self.mod.reads(s),nb0)
 
     def test_write_file(self):
         with open_utf8(pjoin(self.wd, "nb0.%s" % self.ext), 'w') as f:
             self.mod.write(nb0, f)
     
     def test_read_file(self):
         with open_utf8(pjoin(self.wd, "nb0.%s" % self.ext), 'w') as f:
             self.mod.write(nb0, f)
         
         with open_utf8(pjoin(self.wd, "nb0.%s" % self.ext), 'r') as f:
             nb = self.mod.read(f)
         
 
 

IPython/nbformat/v3/tests/test_json.py

@@ -1,33 +1,33 b''
 import pprint
 from unittest import TestCase
 
 from ..nbjson import reads, writes
 from .. import nbjson
 from .nbexamples import nb0
 
 from . import formattest
 
 from .nbexamples import nb0
 
 
 class TestJSON(formattest.NBFormatTest, TestCase):
 
     nb0_ref = None
     ext = 'ipynb'
     mod = nbjson
 
     def test_roundtrip_nosplit(self):
         """Ensure that multiline blobs are still readable"""
         # ensures that notebooks written prior to splitlines change
         # are still readable.
         s = writes(nb0, split_lines=False)
-        self.assertEquals(nbjson.reads(s),nb0)
+        self.assertEqual(nbjson.reads(s),nb0)
 
     def test_roundtrip_split(self):
         """Ensure that splitting multiline blocks is safe"""
         # This won't differ from test_roundtrip unless the default changes
         s = writes(nb0, split_lines=True)
-        self.assertEquals(nbjson.reads(s),nb0)
+        self.assertEqual(nbjson.reads(s),nb0)
 
 
 

IPython/nbformat/v3/tests/test_nbbase.py

@@ -1,143 +1,143 b''
 from unittest import TestCase
 
 from ..nbbase import (
     NotebookNode,
     new_code_cell, new_text_cell, new_worksheet, new_notebook, new_output,
     new_author, new_metadata, new_heading_cell, nbformat
 )
 
 class TestCell(TestCase):
 
     def test_empty_code_cell(self):
         cc = new_code_cell()
-        self.assertEquals(cc.cell_type,u'code')
-        self.assertEquals(u'input' not in cc, True)
-        self.assertEquals(u'prompt_number' not in cc, True)
-        self.assertEquals(cc.outputs, [])
-        self.assertEquals(cc.collapsed, False)
+        self.assertEqual(cc.cell_type,u'code')
+        self.assertEqual(u'input' not in cc, True)
+        self.assertEqual(u'prompt_number' not in cc, True)
+        self.assertEqual(cc.outputs, [])
+        self.assertEqual(cc.collapsed, False)
 
     def test_code_cell(self):
         cc = new_code_cell(input='a=10', prompt_number=0, collapsed=True)
         cc.outputs = [new_output(output_type=u'pyout',
             output_svg=u'foo',output_text=u'10',prompt_number=0)]
-        self.assertEquals(cc.input, u'a=10')
-        self.assertEquals(cc.prompt_number, 0)
-        self.assertEquals(cc.language, u'python')
-        self.assertEquals(cc.outputs[0].svg, u'foo')
-        self.assertEquals(cc.outputs[0].text, u'10')
-        self.assertEquals(cc.outputs[0].prompt_number, 0)
-        self.assertEquals(cc.collapsed, True)
+        self.assertEqual(cc.input, u'a=10')
+        self.assertEqual(cc.prompt_number, 0)
+        self.assertEqual(cc.language, u'python')
+        self.assertEqual(cc.outputs[0].svg, u'foo')
+        self.assertEqual(cc.outputs[0].text, u'10')
+        self.assertEqual(cc.outputs[0].prompt_number, 0)
+        self.assertEqual(cc.collapsed, True)
 
     def test_pyerr(self):
         o = new_output(output_type=u'pyerr', etype=u'NameError',
             evalue=u'Name not found', traceback=[u'frame 0', u'frame 1', u'frame 2']
         )
-        self.assertEquals(o.output_type, u'pyerr')
-        self.assertEquals(o.etype, u'NameError')
-        self.assertEquals(o.evalue, u'Name not found')
-        self.assertEquals(o.traceback, [u'frame 0', u'frame 1', u'frame 2'])
+        self.assertEqual(o.output_type, u'pyerr')
+        self.assertEqual(o.etype, u'NameError')
+        self.assertEqual(o.evalue, u'Name not found')
+        self.assertEqual(o.traceback, [u'frame 0', u'frame 1', u'frame 2'])
 
     def test_empty_html_cell(self):
         tc = new_text_cell(u'html')
-        self.assertEquals(tc.cell_type, u'html')
-        self.assertEquals(u'source' not in tc, True)
-        self.assertEquals(u'rendered' not in tc, True)
+        self.assertEqual(tc.cell_type, u'html')
+        self.assertEqual(u'source' not in tc, True)
+        self.assertEqual(u'rendered' not in tc, True)
 
     def test_html_cell(self):
         tc = new_text_cell(u'html', 'hi', 'hi')
-        self.assertEquals(tc.source, u'hi')
-        self.assertEquals(tc.rendered, u'hi')
+        self.assertEqual(tc.source, u'hi')
+        self.assertEqual(tc.rendered, u'hi')
 
     def test_empty_markdown_cell(self):
         tc = new_text_cell(u'markdown')
-        self.assertEquals(tc.cell_type, u'markdown')
-        self.assertEquals(u'source' not in tc, True)
-        self.assertEquals(u'rendered' not in tc, True)
+        self.assertEqual(tc.cell_type, u'markdown')
+        self.assertEqual(u'source' not in tc, True)
+        self.assertEqual(u'rendered' not in tc, True)
 
     def test_markdown_cell(self):
         tc = new_text_cell(u'markdown', 'hi', 'hi')
-        self.assertEquals(tc.source, u'hi')
-        self.assertEquals(tc.rendered, u'hi')
+        self.assertEqual(tc.source, u'hi')
+        self.assertEqual(tc.rendered, u'hi')
 
     def test_empty_raw_cell(self):
         tc = new_text_cell(u'raw')
-        self.assertEquals(tc.cell_type, u'raw')
-        self.assertEquals(u'source' not in tc, True)
-        self.assertEquals(u'rendered' not in tc, True)
+        self.assertEqual(tc.cell_type, u'raw')
+        self.assertEqual(u'source' not in tc, True)
+        self.assertEqual(u'rendered' not in tc, True)
 
     def test_raw_cell(self):
         tc = new_text_cell(u'raw', 'hi', 'hi')
-        self.assertEquals(tc.source, u'hi')
-        self.assertEquals(tc.rendered, u'hi')
+        self.assertEqual(tc.source, u'hi')
+        self.assertEqual(tc.rendered, u'hi')
 
     def test_empty_heading_cell(self):
         tc = new_heading_cell()
-        self.assertEquals(tc.cell_type, u'heading')
-        self.assertEquals(u'source' not in tc, True)
-        self.assertEquals(u'rendered' not in tc, True)
+        self.assertEqual(tc.cell_type, u'heading')
+        self.assertEqual(u'source' not in tc, True)
+        self.assertEqual(u'rendered' not in tc, True)
 
     def test_heading_cell(self):
         tc = new_heading_cell(u'hi', u'hi', level=2)
-        self.assertEquals(tc.source, u'hi')
-        self.assertEquals(tc.rendered, u'hi')
-        self.assertEquals(tc.level, 2)
+        self.assertEqual(tc.source, u'hi')
+        self.assertEqual(tc.rendered, u'hi')
+        self.assertEqual(tc.level, 2)
 
 
 class TestWorksheet(TestCase):
 
     def test_empty_worksheet(self):
         ws = new_worksheet()
-        self.assertEquals(ws.cells,[])
-        self.assertEquals(u'name' not in ws, True)
+        self.assertEqual(ws.cells,[])
+        self.assertEqual(u'name' not in ws, True)
 
     def test_worksheet(self):
         cells = [new_code_cell(), new_text_cell(u'html')]
         ws = new_worksheet(cells=cells,name=u'foo')
-        self.assertEquals(ws.cells,cells)
-        self.assertEquals(ws.name,u'foo')
+        self.assertEqual(ws.cells,cells)
+        self.assertEqual(ws.name,u'foo')
 
 class TestNotebook(TestCase):
 
     def test_empty_notebook(self):
         nb = new_notebook()
-        self.assertEquals(nb.worksheets, [])
-        self.assertEquals(nb.metadata, NotebookNode())
-        self.assertEquals(nb.nbformat,nbformat)
+        self.assertEqual(nb.worksheets, [])
+        self.assertEqual(nb.metadata, NotebookNode())
+        self.assertEqual(nb.nbformat,nbformat)
 
     def test_notebook(self):
         worksheets = [new_worksheet(),new_worksheet()]
         metadata = new_metadata(name=u'foo')
         nb = new_notebook(metadata=metadata,worksheets=worksheets)
-        self.assertEquals(nb.metadata.name,u'foo')
-        self.assertEquals(nb.worksheets,worksheets)
-        self.assertEquals(nb.nbformat,nbformat)
+        self.assertEqual(nb.metadata.name,u'foo')
+        self.assertEqual(nb.worksheets,worksheets)
+        self.assertEqual(nb.nbformat,nbformat)
 
     def test_notebook_name(self):
         worksheets = [new_worksheet(),new_worksheet()]
         nb = new_notebook(name='foo',worksheets=worksheets)
-        self.assertEquals(nb.metadata.name,u'foo')
-        self.assertEquals(nb.worksheets,worksheets)
-        self.assertEquals(nb.nbformat,nbformat)
+        self.assertEqual(nb.metadata.name,u'foo')
+        self.assertEqual(nb.worksheets,worksheets)
+        self.assertEqual(nb.nbformat,nbformat)
 
 class TestMetadata(TestCase):
 
     def test_empty_metadata(self):
         md = new_metadata()
-        self.assertEquals(u'name' not in md, True)
-        self.assertEquals(u'authors' not in md, True)
-        self.assertEquals(u'license' not in md, True)
-        self.assertEquals(u'saved' not in md, True)
-        self.assertEquals(u'modified' not in md, True)
-        self.assertEquals(u'gistid' not in md, True)
+        self.assertEqual(u'name' not in md, True)
+        self.assertEqual(u'authors' not in md, True)
+        self.assertEqual(u'license' not in md, True)
+        self.assertEqual(u'saved' not in md, True)
+        self.assertEqual(u'modified' not in md, True)
+        self.assertEqual(u'gistid' not in md, True)
 
     def test_metadata(self):
         authors = [new_author(name='Bart Simpson',email='[e-mail]')]
         md = new_metadata(name=u'foo',license=u'BSD',created=u'today',
             modified=u'now',gistid=u'21341231',authors=authors)
-        self.assertEquals(md.name, u'foo')
-        self.assertEquals(md.license, u'BSD')
-        self.assertEquals(md.created, u'today')
-        self.assertEquals(md.modified, u'now')
-        self.assertEquals(md.gistid, u'21341231')
-        self.assertEquals(md.authors, authors)
+        self.assertEqual(md.name, u'foo')
+        self.assertEqual(md.license, u'BSD')
+        self.assertEqual(md.created, u'today')
+        self.assertEqual(md.modified, u'now')
+        self.assertEqual(md.gistid, u'21341231')
+        self.assertEqual(md.authors, authors)
 

IPython/nbformat/v3/tests/test_nbpy.py

@@ -1,46 +1,46 b''
 # -*- coding: utf8 -*-
 
 from unittest import TestCase
 
 from . import formattest
 
 from .. import nbpy
 from .nbexamples import nb0, nb0_py
 
 
 class TestPy(formattest.NBFormatTest, TestCase):
 
     nb0_ref = nb0_py
     ext = 'py'
     mod = nbpy
     ignored_keys = ['collapsed', 'outputs', 'prompt_number', 'metadata']
 
     def assertSubset(self, da, db):
         """assert that da is a subset of db, ignoring self.ignored_keys.
         
         Called recursively on containers, ultimately comparing individual
         elements.
         """
         if isinstance(da, dict):
             for k,v in da.iteritems():
                 if k in self.ignored_keys:
                     continue
                 self.assertTrue(k in db)
                 self.assertSubset(v, db[k])
         elif isinstance(da, list):
             for a,b in zip(da, db):
                 self.assertSubset(a,b)
         else:
             if isinstance(da, basestring) and isinstance(db, basestring):
                 # pyfile is not sensitive to preserving leading/trailing
                 # newlines in blocks through roundtrip
                 da = da.strip('\n')
                 db = db.strip('\n')
-            self.assertEquals(da, db)
+            self.assertEqual(da, db)
         return True
     
     def assertNBEquals(self, nba, nbb):
         # since roundtrip is lossy, only compare keys that are preserved
         # assumes nba is read from my file format
         return self.assertSubset(nba, nbb)
         

IPython/parallel/tests/clienttest.py

@@ -1,184 +1,184 b''
 """base class for parallel client tests
 
 Authors:
 
 * Min RK
 """
 
 #-------------------------------------------------------------------------------
 #  Copyright (C) 2011  The IPython Development Team
 #
 #  Distributed under the terms of the BSD License.  The full license is in
 #  the file COPYING, distributed as part of this software.
 #-------------------------------------------------------------------------------
 from __future__ import print_function
 
 import sys
 import tempfile
 import time
 from StringIO import StringIO
 
 from nose import SkipTest
 
 import zmq
 from zmq.tests import BaseZMQTestCase
 
 from IPython.external.decorator import decorator
 
 from IPython.parallel import error
 from IPython.parallel import Client
 
 from IPython.parallel.tests import launchers, add_engines
 
 # simple tasks for use in apply tests
 
 def segfault():
     """this will segfault"""
     import ctypes
     ctypes.memset(-1,0,1)
 
 def crash():
     """from stdlib crashers in the test suite"""
     import types
     if sys.platform.startswith('win'):
         import ctypes
         ctypes.windll.kernel32.SetErrorMode(0x0002);
     args = [ 0, 0, 0, 0, b'\x04\x71\x00\x00', (), (), (), '', '', 1, b'']
     if sys.version_info[0] >= 3:
         # Python3 adds 'kwonlyargcount' as the second argument to Code
         args.insert(1, 0)
         
     co = types.CodeType(*args)
     exec(co)
 
 def wait(n):
     """sleep for a time"""
     import time
     time.sleep(n)
     return n
 
 def raiser(eclass):
     """raise an exception"""
     raise eclass()
 
 def generate_output():
     """function for testing output
     
     publishes two outputs of each type, and returns
     a rich displayable object.
     """
     
     import sys
     from IPython.core.display import display, HTML, Math
     
     print("stdout")
     print("stderr", file=sys.stderr)
     
     display(HTML("<b>HTML</b>"))
     
     print("stdout2")
     print("stderr2", file=sys.stderr)
     
     display(Math(r"\alpha=\beta"))
     
     return Math("42")
 
 # test decorator for skipping tests when libraries are unavailable
 def skip_without(*names):
     """skip a test if some names are not importable"""
     @decorator
     def skip_without_names(f, *args, **kwargs):
         """decorator to skip tests in the absence of numpy."""
         for name in names:
             try:
                 __import__(name)
             except ImportError:
                 raise SkipTest
         return f(*args, **kwargs)
     return skip_without_names
 
 #-------------------------------------------------------------------------------
 # Classes
 #-------------------------------------------------------------------------------
 
 
 class ClusterTestCase(BaseZMQTestCase):
     
     def add_engines(self, n=1, block=True):
         """add multiple engines to our cluster"""
         self.engines.extend(add_engines(n))
         if block:
             self.wait_on_engines()
 
     def minimum_engines(self, n=1, block=True):
         """add engines until there are at least n connected"""
         self.engines.extend(add_engines(n, total=True))
         if block:
             self.wait_on_engines()
             
     
     def wait_on_engines(self, timeout=5):
         """wait for our engines to connect."""
         n = len(self.engines)+self.base_engine_count
         tic = time.time()
         while time.time()-tic < timeout and len(self.client.ids) < n:
             time.sleep(0.1)
         
         assert not len(self.client.ids) < n, "waiting for engines timed out"
     
     def connect_client(self):
         """connect a client with my Context, and track its sockets for cleanup"""
         c = Client(profile='iptest', context=self.context)
         for name in filter(lambda n:n.endswith('socket'), dir(c)):
             s = getattr(c, name)
             s.setsockopt(zmq.LINGER, 0)
             self.sockets.append(s)
         return c
     
     def assertRaisesRemote(self, etype, f, *args, **kwargs):
         try:
             try:
                 f(*args, **kwargs)
             except error.CompositeError as e:
                 e.raise_exception()
         except error.RemoteError as e:
-            self.assertEquals(etype.__name__, e.ename, "Should have raised %r, but raised %r"%(etype.__name__, e.ename))
+            self.assertEqual(etype.__name__, e.ename, "Should have raised %r, but raised %r"%(etype.__name__, e.ename))
         else:
             self.fail("should have raised a RemoteError")
             
     def _wait_for(self, f, timeout=10):
         """wait for a condition"""
         tic = time.time()
         while time.time() <= tic + timeout:
             if f():
                 return
             time.sleep(0.1)
             self.client.spin()
         if not f():
             print("Warning: Awaited condition never arrived")
     
     def setUp(self):
         BaseZMQTestCase.setUp(self)
         self.client = self.connect_client()
         # start every test with clean engine namespaces:
         self.client.clear(block=True)
         self.base_engine_count=len(self.client.ids)
         self.engines=[]
     
     def tearDown(self):
         # self.client.clear(block=True)
         # close fds:
         for e in filter(lambda e: e.poll() is not None, launchers):
             launchers.remove(e)
         
         # allow flushing of incoming messages to prevent crash on socket close
         self.client.wait(timeout=2)
         # time.sleep(2)
         self.client.spin()
         self.client.close()
         BaseZMQTestCase.tearDown(self)
         # this will be redundant when pyzmq merges PR #88
         # self.context.term()
         # print tempfile.TemporaryFile().fileno(),
         # sys.stdout.flush()
         

IPython/parallel/tests/test_asyncresult.py

@@ -1,267 +1,267 b''
 """Tests for asyncresult.py
 
 Authors:
 
 * Min RK
 """
 
 #-------------------------------------------------------------------------------
 #  Copyright (C) 2011  The IPython Development Team
 #
 #  Distributed under the terms of the BSD License.  The full license is in
 #  the file COPYING, distributed as part of this software.
 #-------------------------------------------------------------------------------
 
 #-------------------------------------------------------------------------------
 # Imports
 #-------------------------------------------------------------------------------
 
 import time
 
 from IPython.utils.io import capture_output
 
 from IPython.parallel.error import TimeoutError
 from IPython.parallel import error, Client
 from IPython.parallel.tests import add_engines
 from .clienttest import ClusterTestCase
 
 def setup():
     add_engines(2, total=True)
 
 def wait(n):
     import time
     time.sleep(n)
     return n
 
 class AsyncResultTest(ClusterTestCase):
 
     def test_single_result_view(self):
         """various one-target views get the right value for single_result"""
         eid = self.client.ids[-1]
         ar = self.client[eid].apply_async(lambda : 42)
-        self.assertEquals(ar.get(), 42)
+        self.assertEqual(ar.get(), 42)
         ar = self.client[[eid]].apply_async(lambda : 42)
-        self.assertEquals(ar.get(), [42])
+        self.assertEqual(ar.get(), [42])
         ar = self.client[-1:].apply_async(lambda : 42)
-        self.assertEquals(ar.get(), [42])
+        self.assertEqual(ar.get(), [42])
 
     def test_get_after_done(self):
         ar = self.client[-1].apply_async(lambda : 42)
         ar.wait()
         self.assertTrue(ar.ready())
-        self.assertEquals(ar.get(), 42)
-        self.assertEquals(ar.get(), 42)
+        self.assertEqual(ar.get(), 42)
+        self.assertEqual(ar.get(), 42)
 
     def test_get_before_done(self):
         ar = self.client[-1].apply_async(wait, 0.1)
         self.assertRaises(TimeoutError, ar.get, 0)
         ar.wait(0)
         self.assertFalse(ar.ready())
-        self.assertEquals(ar.get(), 0.1)
+        self.assertEqual(ar.get(), 0.1)
 
     def test_get_after_error(self):
         ar = self.client[-1].apply_async(lambda : 1/0)
         ar.wait(10)
         self.assertRaisesRemote(ZeroDivisionError, ar.get)
         self.assertRaisesRemote(ZeroDivisionError, ar.get)
         self.assertRaisesRemote(ZeroDivisionError, ar.get_dict)
     
     def test_get_dict(self):
         n = len(self.client)
         ar = self.client[:].apply_async(lambda : 5)
-        self.assertEquals(ar.get(), [5]*n)
+        self.assertEqual(ar.get(), [5]*n)
         d = ar.get_dict()
-        self.assertEquals(sorted(d.keys()), sorted(self.client.ids))
+        self.assertEqual(sorted(d.keys()), sorted(self.client.ids))
         for eid,r in d.iteritems():
-            self.assertEquals(r, 5)
+            self.assertEqual(r, 5)
     
     def test_list_amr(self):
         ar = self.client.load_balanced_view().map_async(wait, [0.1]*5)
         rlist = list(ar)
     
     def test_getattr(self):
         ar = self.client[:].apply_async(wait, 0.5)
         self.assertRaises(AttributeError, lambda : ar._foo)
         self.assertRaises(AttributeError, lambda : ar.__length_hint__())
         self.assertRaises(AttributeError, lambda : ar.foo)
         self.assertRaises(AttributeError, lambda : ar.engine_id)
         self.assertFalse(hasattr(ar, '__length_hint__'))
         self.assertFalse(hasattr(ar, 'foo'))
         self.assertFalse(hasattr(ar, 'engine_id'))
         ar.get(5)
         self.assertRaises(AttributeError, lambda : ar._foo)
         self.assertRaises(AttributeError, lambda : ar.__length_hint__())
         self.assertRaises(AttributeError, lambda : ar.foo)
         self.assertTrue(isinstance(ar.engine_id, list))
-        self.assertEquals(ar.engine_id, ar['engine_id'])
+        self.assertEqual(ar.engine_id, ar['engine_id'])
         self.assertFalse(hasattr(ar, '__length_hint__'))
         self.assertFalse(hasattr(ar, 'foo'))
         self.assertTrue(hasattr(ar, 'engine_id'))
 
     def test_getitem(self):
         ar = self.client[:].apply_async(wait, 0.5)
         self.assertRaises(TimeoutError, lambda : ar['foo'])
         self.assertRaises(TimeoutError, lambda : ar['engine_id'])
         ar.get(5)
         self.assertRaises(KeyError, lambda : ar['foo'])
         self.assertTrue(isinstance(ar['engine_id'], list))
-        self.assertEquals(ar.engine_id, ar['engine_id'])
+        self.assertEqual(ar.engine_id, ar['engine_id'])
     
     def test_single_result(self):
         ar = self.client[-1].apply_async(wait, 0.5)
         self.assertRaises(TimeoutError, lambda : ar['foo'])
         self.assertRaises(TimeoutError, lambda : ar['engine_id'])
         self.assertTrue(ar.get(5) == 0.5)
         self.assertTrue(isinstance(ar['engine_id'], int))
         self.assertTrue(isinstance(ar.engine_id, int))
-        self.assertEquals(ar.engine_id, ar['engine_id'])
+        self.assertEqual(ar.engine_id, ar['engine_id'])
     
     def test_abort(self):
         e = self.client[-1]
         ar = e.execute('import time; time.sleep(1)', block=False)
         ar2 = e.apply_async(lambda : 2)
         ar2.abort()
         self.assertRaises(error.TaskAborted, ar2.get)
         ar.get()
     
     def test_len(self):
         v = self.client.load_balanced_view()
         ar = v.map_async(lambda x: x, range(10))
-        self.assertEquals(len(ar), 10)
+        self.assertEqual(len(ar), 10)
         ar = v.apply_async(lambda x: x, range(10))
-        self.assertEquals(len(ar), 1)
+        self.assertEqual(len(ar), 1)
         ar = self.client[:].apply_async(lambda x: x, range(10))
-        self.assertEquals(len(ar), len(self.client.ids))
+        self.assertEqual(len(ar), len(self.client.ids))
     
     def test_wall_time_single(self):
         v = self.client.load_balanced_view()
         ar = v.apply_async(time.sleep, 0.25)
         self.assertRaises(TimeoutError, getattr, ar, 'wall_time')
         ar.get(2)
         self.assertTrue(ar.wall_time < 1.)
         self.assertTrue(ar.wall_time > 0.2)
 
     def test_wall_time_multi(self):
         self.minimum_engines(4)
         v = self.client[:]
         ar = v.apply_async(time.sleep, 0.25)
         self.assertRaises(TimeoutError, getattr, ar, 'wall_time')
         ar.get(2)
         self.assertTrue(ar.wall_time < 1.)
         self.assertTrue(ar.wall_time > 0.2)
 
     def test_serial_time_single(self):
         v = self.client.load_balanced_view()
         ar = v.apply_async(time.sleep, 0.25)
         self.assertRaises(TimeoutError, getattr, ar, 'serial_time')
         ar.get(2)
         self.assertTrue(ar.serial_time < 1.)
         self.assertTrue(ar.serial_time > 0.2)
 
     def test_serial_time_multi(self):
         self.minimum_engines(4)
         v = self.client[:]
         ar = v.apply_async(time.sleep, 0.25)
         self.assertRaises(TimeoutError, getattr, ar, 'serial_time')
         ar.get(2)
         self.assertTrue(ar.serial_time < 2.)
         self.assertTrue(ar.serial_time > 0.8)
 
     def test_elapsed_single(self):
         v = self.client.load_balanced_view()
         ar = v.apply_async(time.sleep, 0.25)
         while not ar.ready():
             time.sleep(0.01)
             self.assertTrue(ar.elapsed < 1)
         self.assertTrue(ar.elapsed < 1)
         ar.get(2)
 
     def test_elapsed_multi(self):
         v = self.client[:]
         ar = v.apply_async(time.sleep, 0.25)
         while not ar.ready():
             time.sleep(0.01)
             self.assertTrue(ar.elapsed < 1)
         self.assertTrue(ar.elapsed < 1)
         ar.get(2)
 
     def test_hubresult_timestamps(self):
         self.minimum_engines(4)
         v = self.client[:]
         ar = v.apply_async(time.sleep, 0.25)
         ar.get(2)
         rc2 = Client(profile='iptest')
         # must have try/finally to close second Client, otherwise
         # will have dangling sockets causing problems
         try:
             time.sleep(0.25)
             hr = rc2.get_result(ar.msg_ids)
             self.assertTrue(hr.elapsed > 0., "got bad elapsed: %s" % hr.elapsed)
             hr.get(1)
             self.assertTrue(hr.wall_time < ar.wall_time + 0.2, "got bad wall_time: %s > %s" % (hr.wall_time, ar.wall_time))
-            self.assertEquals(hr.serial_time, ar.serial_time)
+            self.assertEqual(hr.serial_time, ar.serial_time)
         finally:
             rc2.close()
 
     def test_display_empty_streams_single(self):
         """empty stdout/err are not displayed (single result)"""
         self.minimum_engines(1)
         
         v = self.client[-1]
         ar = v.execute("print (5555)")
         ar.get(5)
         with capture_output() as io:
             ar.display_outputs()
-        self.assertEquals(io.stderr, '')
-        self.assertEquals('5555\n', io.stdout)
+        self.assertEqual(io.stderr, '')
+        self.assertEqual('5555\n', io.stdout)
 
         ar = v.execute("a=5")
         ar.get(5)
         with capture_output() as io:
             ar.display_outputs()
-        self.assertEquals(io.stderr, '')
-        self.assertEquals(io.stdout, '')
+        self.assertEqual(io.stderr, '')
+        self.assertEqual(io.stdout, '')
         
     def test_display_empty_streams_type(self):
         """empty stdout/err are not displayed (groupby type)"""
         self.minimum_engines(1)
         
         v = self.client[:]
         ar = v.execute("print (5555)")
         ar.get(5)
         with capture_output() as io:
             ar.display_outputs()
-        self.assertEquals(io.stderr, '')
-        self.assertEquals(io.stdout.count('5555'), len(v), io.stdout)
+        self.assertEqual(io.stderr, '')
+        self.assertEqual(io.stdout.count('5555'), len(v), io.stdout)
         self.assertFalse('\n\n' in io.stdout, io.stdout)
-        self.assertEquals(io.stdout.count('[stdout:'), len(v), io.stdout)
+        self.assertEqual(io.stdout.count('[stdout:'), len(v), io.stdout)
 
         ar = v.execute("a=5")
         ar.get(5)
         with capture_output() as io:
             ar.display_outputs()
-        self.assertEquals(io.stderr, '')
-        self.assertEquals(io.stdout, '')
+        self.assertEqual(io.stderr, '')
+        self.assertEqual(io.stdout, '')
 
     def test_display_empty_streams_engine(self):
         """empty stdout/err are not displayed (groupby engine)"""
         self.minimum_engines(1)
         
         v = self.client[:]
         ar = v.execute("print (5555)")
         ar.get(5)
         with capture_output() as io:
             ar.display_outputs('engine')
-        self.assertEquals(io.stderr, '')
-        self.assertEquals(io.stdout.count('5555'), len(v), io.stdout)
+        self.assertEqual(io.stderr, '')
+        self.assertEqual(io.stdout.count('5555'), len(v), io.stdout)
         self.assertFalse('\n\n' in io.stdout, io.stdout)
-        self.assertEquals(io.stdout.count('[stdout:'), len(v), io.stdout)
+        self.assertEqual(io.stdout.count('[stdout:'), len(v), io.stdout)
 
         ar = v.execute("a=5")
         ar.get(5)
         with capture_output() as io:
             ar.display_outputs('engine')
-        self.assertEquals(io.stderr, '')
-        self.assertEquals(io.stdout, '')
+        self.assertEqual(io.stderr, '')
+        self.assertEqual(io.stdout, '')
         
 

IPython/parallel/tests/test_client.py

@@ -1,455 +1,455 b''
 """Tests for parallel client.py
 
 Authors:
 
 * Min RK
 """
 
 #-------------------------------------------------------------------------------
 #  Copyright (C) 2011  The IPython Development Team
 #
 #  Distributed under the terms of the BSD License.  The full license is in
 #  the file COPYING, distributed as part of this software.
 #-------------------------------------------------------------------------------
 
 #-------------------------------------------------------------------------------
 # Imports
 #-------------------------------------------------------------------------------
 
 from __future__ import division
 
 import time
 from datetime import datetime
 from tempfile import mktemp
 
 import zmq
 
 from IPython import parallel
 from IPython.parallel.client import client as clientmod
 from IPython.parallel import error
 from IPython.parallel import AsyncResult, AsyncHubResult
 from IPython.parallel import LoadBalancedView, DirectView
 
 from clienttest import ClusterTestCase, segfault, wait, add_engines
 
 def setup():
     add_engines(4, total=True)
 
 class TestClient(ClusterTestCase):
     
     def test_ids(self):
         n = len(self.client.ids)
         self.add_engines(2)
-        self.assertEquals(len(self.client.ids), n+2)
+        self.assertEqual(len(self.client.ids), n+2)
     
     def test_view_indexing(self):
         """test index access for views"""
         self.minimum_engines(4)
         targets = self.client._build_targets('all')[-1]
         v = self.client[:]
-        self.assertEquals(v.targets, targets)
+        self.assertEqual(v.targets, targets)
         t = self.client.ids[2]
         v = self.client[t]
         self.assert_(isinstance(v, DirectView))
-        self.assertEquals(v.targets, t)
+        self.assertEqual(v.targets, t)
         t = self.client.ids[2:4]
         v = self.client[t]
         self.assert_(isinstance(v, DirectView))
-        self.assertEquals(v.targets, t)
+        self.assertEqual(v.targets, t)
         v = self.client[::2]
         self.assert_(isinstance(v, DirectView))
-        self.assertEquals(v.targets, targets[::2])
+        self.assertEqual(v.targets, targets[::2])
         v = self.client[1::3]
         self.assert_(isinstance(v, DirectView))
-        self.assertEquals(v.targets, targets[1::3])
+        self.assertEqual(v.targets, targets[1::3])
         v = self.client[:-3]
         self.assert_(isinstance(v, DirectView))
-        self.assertEquals(v.targets, targets[:-3])
+        self.assertEqual(v.targets, targets[:-3])
         v = self.client[-1]
         self.assert_(isinstance(v, DirectView))
-        self.assertEquals(v.targets, targets[-1])
+        self.assertEqual(v.targets, targets[-1])
         self.assertRaises(TypeError, lambda : self.client[None])
     
     def test_lbview_targets(self):
         """test load_balanced_view targets"""
         v = self.client.load_balanced_view()
-        self.assertEquals(v.targets, None)
+        self.assertEqual(v.targets, None)
         v = self.client.load_balanced_view(-1)
-        self.assertEquals(v.targets, [self.client.ids[-1]])
+        self.assertEqual(v.targets, [self.client.ids[-1]])
         v = self.client.load_balanced_view('all')
-        self.assertEquals(v.targets, None)
+        self.assertEqual(v.targets, None)
     
     def test_dview_targets(self):
         """test direct_view targets"""
         v = self.client.direct_view()
-        self.assertEquals(v.targets, 'all')
+        self.assertEqual(v.targets, 'all')
         v = self.client.direct_view('all')
-        self.assertEquals(v.targets, 'all')
+        self.assertEqual(v.targets, 'all')
         v = self.client.direct_view(-1)
-        self.assertEquals(v.targets, self.client.ids[-1])
+        self.assertEqual(v.targets, self.client.ids[-1])
     
     def test_lazy_all_targets(self):
         """test lazy evaluation of rc.direct_view('all')"""
         v = self.client.direct_view()
-        self.assertEquals(v.targets, 'all')
+        self.assertEqual(v.targets, 'all')
         
         def double(x):
             return x*2
         seq = range(100)
         ref = [ double(x) for x in seq ]
         
         # add some engines, which should be used
         self.add_engines(1)
         n1 = len(self.client.ids)
         
         # simple apply
         r = v.apply_sync(lambda : 1)
-        self.assertEquals(r, [1] * n1)
+        self.assertEqual(r, [1] * n1)
         
         # map goes through remotefunction
         r = v.map_sync(double, seq)
-        self.assertEquals(r, ref)
+        self.assertEqual(r, ref)
 
         # add a couple more engines, and try again
         self.add_engines(2)
         n2 = len(self.client.ids)
         self.assertNotEquals(n2, n1)
         
         # apply
         r = v.apply_sync(lambda : 1)
-        self.assertEquals(r, [1] * n2)
+        self.assertEqual(r, [1] * n2)
         
         # map
         r = v.map_sync(double, seq)
-        self.assertEquals(r, ref)
+        self.assertEqual(r, ref)
     
     def test_targets(self):
         """test various valid targets arguments"""
         build = self.client._build_targets
         ids = self.client.ids
         idents,targets = build(None)
-        self.assertEquals(ids, targets)
+        self.assertEqual(ids, targets)
     
     def test_clear(self):
         """test clear behavior"""
         self.minimum_engines(2)
         v = self.client[:]
         v.block=True
         v.push(dict(a=5))
         v.pull('a')
         id0 = self.client.ids[-1]
         self.client.clear(targets=id0, block=True)
         a = self.client[:-1].get('a')
         self.assertRaisesRemote(NameError, self.client[id0].get, 'a')
         self.client.clear(block=True)
         for i in self.client.ids:
             self.assertRaisesRemote(NameError, self.client[i].get, 'a')
     
     def test_get_result(self):
         """test getting results from the Hub."""
         c = clientmod.Client(profile='iptest')
         t = c.ids[-1]
         ar = c[t].apply_async(wait, 1)
         # give the monitor time to notice the message
         time.sleep(.25)
         ahr = self.client.get_result(ar.msg_ids)
         self.assertTrue(isinstance(ahr, AsyncHubResult))
-        self.assertEquals(ahr.get(), ar.get())
+        self.assertEqual(ahr.get(), ar.get())
         ar2 = self.client.get_result(ar.msg_ids)
         self.assertFalse(isinstance(ar2, AsyncHubResult))
         c.close()
     
     def test_get_execute_result(self):
         """test getting execute results from the Hub."""
         c = clientmod.Client(profile='iptest')
         t = c.ids[-1]
         cell = '\n'.join([
             'import time',
             'time.sleep(0.25)',
             '5'
         ])
         ar = c[t].execute("import time; time.sleep(1)", silent=False)
         # give the monitor time to notice the message
         time.sleep(.25)
         ahr = self.client.get_result(ar.msg_ids)
         self.assertTrue(isinstance(ahr, AsyncHubResult))
-        self.assertEquals(ahr.get().pyout, ar.get().pyout)
+        self.assertEqual(ahr.get().pyout, ar.get().pyout)
         ar2 = self.client.get_result(ar.msg_ids)
         self.assertFalse(isinstance(ar2, AsyncHubResult))
         c.close()
     
     def test_ids_list(self):
         """test client.ids"""
         ids = self.client.ids
-        self.assertEquals(ids, self.client._ids)
+        self.assertEqual(ids, self.client._ids)
         self.assertFalse(ids is self.client._ids)
         ids.remove(ids[-1])
         self.assertNotEquals(ids, self.client._ids)
     
     def test_queue_status(self):
         ids = self.client.ids
         id0 = ids[0]
         qs = self.client.queue_status(targets=id0)
         self.assertTrue(isinstance(qs, dict))
-        self.assertEquals(sorted(qs.keys()), ['completed', 'queue', 'tasks'])
+        self.assertEqual(sorted(qs.keys()), ['completed', 'queue', 'tasks'])
         allqs = self.client.queue_status()
         self.assertTrue(isinstance(allqs, dict))
         intkeys = list(allqs.keys())
         intkeys.remove('unassigned')
-        self.assertEquals(sorted(intkeys), sorted(self.client.ids))
+        self.assertEqual(sorted(intkeys), sorted(self.client.ids))
         unassigned = allqs.pop('unassigned')
         for eid,qs in allqs.items():
             self.assertTrue(isinstance(qs, dict))
-            self.assertEquals(sorted(qs.keys()), ['completed', 'queue', 'tasks'])
+            self.assertEqual(sorted(qs.keys()), ['completed', 'queue', 'tasks'])
 
     def test_shutdown(self):
         ids = self.client.ids
         id0 = ids[0]
         self.client.shutdown(id0, block=True)
         while id0 in self.client.ids:
             time.sleep(0.1)
             self.client.spin()
         
         self.assertRaises(IndexError, lambda : self.client[id0])
         
     def test_result_status(self):
         pass
         # to be written
     
     def test_db_query_dt(self):
         """test db query by date"""
         hist = self.client.hub_history()
         middle = self.client.db_query({'msg_id' : hist[len(hist)//2]})[0]
         tic = middle['submitted']
         before = self.client.db_query({'submitted' : {'$lt' : tic}})
         after = self.client.db_query({'submitted' : {'$gte' : tic}})
-        self.assertEquals(len(before)+len(after),len(hist))
+        self.assertEqual(len(before)+len(after),len(hist))
         for b in before:
             self.assertTrue(b['submitted'] < tic)
         for a in after:
             self.assertTrue(a['submitted'] >= tic)
         same = self.client.db_query({'submitted' : tic})
         for s in same:
             self.assertTrue(s['submitted'] == tic)
     
     def test_db_query_keys(self):
         """test extracting subset of record keys"""
         found = self.client.db_query({'msg_id': {'$ne' : ''}},keys=['submitted', 'completed'])
         for rec in found:
-            self.assertEquals(set(rec.keys()), set(['msg_id', 'submitted', 'completed']))
+            self.assertEqual(set(rec.keys()), set(['msg_id', 'submitted', 'completed']))
     
     def test_db_query_default_keys(self):
         """default db_query excludes buffers"""
         found = self.client.db_query({'msg_id': {'$ne' : ''}})
         for rec in found:
             keys = set(rec.keys())
             self.assertFalse('buffers' in keys, "'buffers' should not be in: %s" % keys)
             self.assertFalse('result_buffers' in keys, "'result_buffers' should not be in: %s" % keys)
     
     def test_db_query_msg_id(self):
         """ensure msg_id is always in db queries"""
         found = self.client.db_query({'msg_id': {'$ne' : ''}},keys=['submitted', 'completed'])
         for rec in found:
             self.assertTrue('msg_id' in rec.keys())
         found = self.client.db_query({'msg_id': {'$ne' : ''}},keys=['submitted'])
         for rec in found:
             self.assertTrue('msg_id' in rec.keys())
         found = self.client.db_query({'msg_id': {'$ne' : ''}},keys=['msg_id'])
         for rec in found:
             self.assertTrue('msg_id' in rec.keys())
     
     def test_db_query_get_result(self):
         """pop in db_query shouldn't pop from result itself"""
         self.client[:].apply_sync(lambda : 1)
         found = self.client.db_query({'msg_id': {'$ne' : ''}})
         rc2 = clientmod.Client(profile='iptest')
         # If this bug is not fixed, this call will hang:
         ar = rc2.get_result(self.client.history[-1])
         ar.wait(2)
         self.assertTrue(ar.ready())
         ar.get()
         rc2.close()
     
     def test_db_query_in(self):
         """test db query with '$in','$nin' operators"""
         hist = self.client.hub_history()
         even = hist[::2]
         odd = hist[1::2]
         recs = self.client.db_query({ 'msg_id' : {'$in' : even}})
         found = [ r['msg_id'] for r in recs ]
-        self.assertEquals(set(even), set(found))
+        self.assertEqual(set(even), set(found))
         recs = self.client.db_query({ 'msg_id' : {'$nin' : even}})
         found = [ r['msg_id'] for r in recs ]
-        self.assertEquals(set(odd), set(found))
+        self.assertEqual(set(odd), set(found))
     
     def test_hub_history(self):
         hist = self.client.hub_history()
         recs = self.client.db_query({ 'msg_id' : {"$ne":''}})
         recdict = {}
         for rec in recs:
             recdict[rec['msg_id']] = rec
         
         latest = datetime(1984,1,1)
         for msg_id in hist:
             rec = recdict[msg_id]
             newt = rec['submitted']
             self.assertTrue(newt >= latest)
             latest = newt
         ar = self.client[-1].apply_async(lambda : 1)
         ar.get()
         time.sleep(0.25)
-        self.assertEquals(self.client.hub_history()[-1:],ar.msg_ids)
+        self.assertEqual(self.client.hub_history()[-1:],ar.msg_ids)
     
     def _wait_for_idle(self):
         """wait for an engine to become idle, according to the Hub"""
         rc = self.client
         
         # timeout 5s, polling every 100ms
         qs = rc.queue_status()
         for i in range(50):
             if qs['unassigned'] or any(qs[eid]['tasks'] for eid in rc.ids):
                 time.sleep(0.1)
                 qs = rc.queue_status()
             else:
                 break
         
         # ensure Hub up to date:
-        self.assertEquals(qs['unassigned'], 0)
+        self.assertEqual(qs['unassigned'], 0)
         for eid in rc.ids:
-            self.assertEquals(qs[eid]['tasks'], 0)
+            self.assertEqual(qs[eid]['tasks'], 0)
     
     
     def test_resubmit(self):
         def f():
             import random
             return random.random()
         v = self.client.load_balanced_view()
         ar = v.apply_async(f)
         r1 = ar.get(1)
         # give the Hub a chance to notice:
         self._wait_for_idle()
         ahr = self.client.resubmit(ar.msg_ids)
         r2 = ahr.get(1)
         self.assertFalse(r1 == r2)
 
     def test_resubmit_chain(self):
         """resubmit resubmitted tasks"""
         v = self.client.load_balanced_view()
         ar = v.apply_async(lambda x: x, 'x'*1024)
         ar.get()
         self._wait_for_idle()
         ars = [ar]
         
         for i in range(10):
             ar = ars[-1]
             ar2 = self.client.resubmit(ar.msg_ids)
         
         [ ar.get() for ar in ars ]
 
     def test_resubmit_header(self):
         """resubmit shouldn't clobber the whole header"""
         def f():
             import random
             return random.random()
         v = self.client.load_balanced_view()
         v.retries = 1
         ar = v.apply_async(f)
         r1 = ar.get(1)
         # give the Hub a chance to notice:
         self._wait_for_idle()
         ahr = self.client.resubmit(ar.msg_ids)
         ahr.get(1)
         time.sleep(0.5)
         records = self.client.db_query({'msg_id': {'$in': ar.msg_ids + ahr.msg_ids}}, keys='header')
         h1,h2 = [ r['header'] for r in records ]
         for key in set(h1.keys()).union(set(h2.keys())):
             if key in ('msg_id', 'date'):
                 self.assertNotEquals(h1[key], h2[key])
             else:
-                self.assertEquals(h1[key], h2[key])
+                self.assertEqual(h1[key], h2[key])
 
     def test_resubmit_aborted(self):
         def f():
             import random
             return random.random()
         v = self.client.load_balanced_view()
         # restrict to one engine, so we can put a sleep
         # ahead of the task, so it will get aborted
         eid = self.client.ids[-1]
         v.targets = [eid]
         sleep = v.apply_async(time.sleep, 0.5)
         ar = v.apply_async(f)
         ar.abort()
         self.assertRaises(error.TaskAborted, ar.get)
         # Give the Hub a chance to get up to date:
         self._wait_for_idle()
         ahr = self.client.resubmit(ar.msg_ids)
         r2 = ahr.get(1)
 
     def test_resubmit_inflight(self):
         """resubmit of inflight task"""
         v = self.client.load_balanced_view()
         ar = v.apply_async(time.sleep,1)
         # give the message a chance to arrive
         time.sleep(0.2)
         ahr = self.client.resubmit(ar.msg_ids)
         ar.get(2)
         ahr.get(2)
 
     def test_resubmit_badkey(self):
         """ensure KeyError on resubmit of nonexistant task"""
         self.assertRaisesRemote(KeyError, self.client.resubmit, ['invalid'])
 
     def test_purge_results(self):
         # ensure there are some tasks
         for i in range(5):
             self.client[:].apply_sync(lambda : 1)
         # Wait for the Hub to realise the result is done:
         # This prevents a race condition, where we
         # might purge a result the Hub still thinks is pending.
         time.sleep(0.1)
         rc2 = clientmod.Client(profile='iptest')
         hist = self.client.hub_history()
         ahr = rc2.get_result([hist[-1]])
         ahr.wait(10)
         self.client.purge_results(hist[-1])
         newhist = self.client.hub_history()
-        self.assertEquals(len(newhist)+1,len(hist))
+        self.assertEqual(len(newhist)+1,len(hist))
         rc2.spin()
         rc2.close()
         
     def test_purge_all_results(self):
         self.client.purge_results('all')
         hist = self.client.hub_history()
-        self.assertEquals(len(hist), 0)
+        self.assertEqual(len(hist), 0)
     
     def test_spin_thread(self):
         self.client.spin_thread(0.01)
         ar = self.client[-1].apply_async(lambda : 1)
         time.sleep(0.1)
         self.assertTrue(ar.wall_time < 0.1,
             "spin should have kept wall_time < 0.1, but got %f" % ar.wall_time
         )
     
     def test_stop_spin_thread(self):
         self.client.spin_thread(0.01)
         self.client.stop_spin_thread()
         ar = self.client[-1].apply_async(lambda : 1)
         time.sleep(0.15)
         self.assertTrue(ar.wall_time > 0.1,
             "Shouldn't be spinning, but got wall_time=%f" % ar.wall_time
         )
     
     def test_activate(self):
         ip = get_ipython()
         magics = ip.magics_manager.magics
         self.assertTrue('px' in magics['line'])
         self.assertTrue('px' in magics['cell'])
         v0 = self.client.activate(-1, '0')
         self.assertTrue('px0' in magics['line'])
         self.assertTrue('px0' in magics['cell'])
-        self.assertEquals(v0.targets, self.client.ids[-1])
+        self.assertEqual(v0.targets, self.client.ids[-1])
         v0 = self.client.activate('all', 'all')
         self.assertTrue('pxall' in magics['line'])
         self.assertTrue('pxall' in magics['cell'])
-        self.assertEquals(v0.targets, 'all')
+        self.assertEqual(v0.targets, 'all')

IPython/parallel/tests/test_db.py

@@ -1,249 +1,249 b''
 """Tests for db backends
 
 Authors:
 
 * Min RK
 """
 
 #-------------------------------------------------------------------------------
 #  Copyright (C) 2011  The IPython Development Team
 #
 #  Distributed under the terms of the BSD License.  The full license is in
 #  the file COPYING, distributed as part of this software.
 #-------------------------------------------------------------------------------
 
 #-------------------------------------------------------------------------------
 # Imports
 #-------------------------------------------------------------------------------
 
 from __future__ import division
 
 import logging
 import os
 import tempfile
 import time
 
 from datetime import datetime, timedelta
 from unittest import TestCase
 
 from IPython.parallel import error
 from IPython.parallel.controller.dictdb import DictDB
 from IPython.parallel.controller.sqlitedb import SQLiteDB
 from IPython.parallel.controller.hub import init_record, empty_record
 
 from IPython.testing import decorators as dec
 from IPython.zmq.session import Session
 
 
 #-------------------------------------------------------------------------------
 # TestCases
 #-------------------------------------------------------------------------------
 
 
 def setup():
     global temp_db
     temp_db = tempfile.NamedTemporaryFile(suffix='.db').name
 
 
 class TestDictBackend(TestCase):
     def setUp(self):
         self.session = Session()
         self.db = self.create_db()
         self.load_records(16)
     
     def create_db(self):
         return DictDB()
     
     def load_records(self, n=1):
         """load n records for testing"""
         #sleep 1/10 s, to ensure timestamp is different to previous calls
         time.sleep(0.1)
         msg_ids = []
         for i in range(n):
             msg = self.session.msg('apply_request', content=dict(a=5))
             msg['buffers'] = []
             rec = init_record(msg)
             msg_id = msg['header']['msg_id']
             msg_ids.append(msg_id)
             self.db.add_record(msg_id, rec)
         return msg_ids
     
     def test_add_record(self):
         before = self.db.get_history()
         self.load_records(5)
         after = self.db.get_history()
-        self.assertEquals(len(after), len(before)+5)
-        self.assertEquals(after[:-5],before)
+        self.assertEqual(len(after), len(before)+5)
+        self.assertEqual(after[:-5],before)
         
     def test_drop_record(self):
         msg_id = self.load_records()[-1]
         rec = self.db.get_record(msg_id)
         self.db.drop_record(msg_id)
         self.assertRaises(KeyError,self.db.get_record, msg_id)
     
     def _round_to_millisecond(self, dt):
         """necessary because mongodb rounds microseconds"""
         micro = dt.microsecond
         extra = int(str(micro)[-3:])
         return dt - timedelta(microseconds=extra)
     
     def test_update_record(self):
         now = self._round_to_millisecond(datetime.now())
         # 
         msg_id = self.db.get_history()[-1]
         rec1 = self.db.get_record(msg_id)
         data = {'stdout': 'hello there', 'completed' : now}
         self.db.update_record(msg_id, data)
         rec2 = self.db.get_record(msg_id)
-        self.assertEquals(rec2['stdout'], 'hello there')
-        self.assertEquals(rec2['completed'], now)
+        self.assertEqual(rec2['stdout'], 'hello there')
+        self.assertEqual(rec2['completed'], now)
         rec1.update(data)
-        self.assertEquals(rec1, rec2)
+        self.assertEqual(rec1, rec2)
     
     # def test_update_record_bad(self):
     #     """test updating nonexistant records"""
     #     msg_id = str(uuid.uuid4())
     #     data = {'stdout': 'hello there'}
     #     self.assertRaises(KeyError, self.db.update_record, msg_id, data)
 
     def test_find_records_dt(self):
         """test finding records by date"""
         hist = self.db.get_history()
         middle = self.db.get_record(hist[len(hist)//2])
         tic = middle['submitted']
         before = self.db.find_records({'submitted' : {'$lt' : tic}})
         after = self.db.find_records({'submitted' : {'$gte' : tic}})
-        self.assertEquals(len(before)+len(after),len(hist))
+        self.assertEqual(len(before)+len(after),len(hist))
         for b in before:
             self.assertTrue(b['submitted'] < tic)
         for a in after:
             self.assertTrue(a['submitted'] >= tic)
         same = self.db.find_records({'submitted' : tic})
         for s in same:
             self.assertTrue(s['submitted'] == tic)
     
     def test_find_records_keys(self):
         """test extracting subset of record keys"""
         found = self.db.find_records({'msg_id': {'$ne' : ''}},keys=['submitted', 'completed'])
         for rec in found:
-            self.assertEquals(set(rec.keys()), set(['msg_id', 'submitted', 'completed']))
+            self.assertEqual(set(rec.keys()), set(['msg_id', 'submitted', 'completed']))
     
     def test_find_records_msg_id(self):
         """ensure msg_id is always in found records"""
         found = self.db.find_records({'msg_id': {'$ne' : ''}},keys=['submitted', 'completed'])
         for rec in found:
             self.assertTrue('msg_id' in rec.keys())
         found = self.db.find_records({'msg_id': {'$ne' : ''}},keys=['submitted'])
         for rec in found:
             self.assertTrue('msg_id' in rec.keys())
         found = self.db.find_records({'msg_id': {'$ne' : ''}},keys=['msg_id'])
         for rec in found:
             self.assertTrue('msg_id' in rec.keys())
     
     def test_find_records_in(self):
         """test finding records with '$in','$nin' operators"""
         hist = self.db.get_history()
         even = hist[::2]
         odd = hist[1::2]
         recs = self.db.find_records({ 'msg_id' : {'$in' : even}})
         found = [ r['msg_id'] for r in recs ]
-        self.assertEquals(set(even), set(found))
+        self.assertEqual(set(even), set(found))
         recs = self.db.find_records({ 'msg_id' : {'$nin' : even}})
         found = [ r['msg_id'] for r in recs ]
-        self.assertEquals(set(odd), set(found))
+        self.assertEqual(set(odd), set(found))
     
     def test_get_history(self):
         msg_ids = self.db.get_history()
         latest = datetime(1984,1,1)
         for msg_id in msg_ids:
             rec = self.db.get_record(msg_id)
             newt = rec['submitted']
             self.assertTrue(newt >= latest)
             latest = newt
         msg_id = self.load_records(1)[-1]
-        self.assertEquals(self.db.get_history()[-1],msg_id)
+        self.assertEqual(self.db.get_history()[-1],msg_id)
     
     def test_datetime(self):
         """get/set timestamps with datetime objects"""
         msg_id = self.db.get_history()[-1]
         rec = self.db.get_record(msg_id)
         self.assertTrue(isinstance(rec['submitted'], datetime))
         self.db.update_record(msg_id, dict(completed=datetime.now()))
         rec = self.db.get_record(msg_id)
         self.assertTrue(isinstance(rec['completed'], datetime))
 
     def test_drop_matching(self):
         msg_ids = self.load_records(10)
         query = {'msg_id' : {'$in':msg_ids}}
         self.db.drop_matching_records(query)
         recs = self.db.find_records(query)
-        self.assertEquals(len(recs), 0)
+        self.assertEqual(len(recs), 0)
     
     def test_null(self):
         """test None comparison queries"""
         msg_ids = self.load_records(10)
 
         query = {'msg_id' : None}
         recs = self.db.find_records(query)
-        self.assertEquals(len(recs), 0)
+        self.assertEqual(len(recs), 0)
 
         query = {'msg_id' : {'$ne' : None}}
         recs = self.db.find_records(query)
         self.assertTrue(len(recs) >= 10)
     
     def test_pop_safe_get(self):
         """editing query results shouldn't affect record [get]"""
         msg_id = self.db.get_history()[-1]
         rec = self.db.get_record(msg_id)
         rec.pop('buffers')
         rec['garbage'] = 'hello'
         rec['header']['msg_id'] = 'fubar'
         rec2 = self.db.get_record(msg_id)
         self.assertTrue('buffers' in rec2)
         self.assertFalse('garbage' in rec2)
-        self.assertEquals(rec2['header']['msg_id'], msg_id)
+        self.assertEqual(rec2['header']['msg_id'], msg_id)
     
     def test_pop_safe_find(self):
         """editing query results shouldn't affect record [find]"""
         msg_id = self.db.get_history()[-1]
         rec = self.db.find_records({'msg_id' : msg_id})[0]
         rec.pop('buffers')
         rec['garbage'] = 'hello'
         rec['header']['msg_id'] = 'fubar'
         rec2 = self.db.find_records({'msg_id' : msg_id})[0]
         self.assertTrue('buffers' in rec2)
         self.assertFalse('garbage' in rec2)
-        self.assertEquals(rec2['header']['msg_id'], msg_id)
+        self.assertEqual(rec2['header']['msg_id'], msg_id)
 
     def test_pop_safe_find_keys(self):
         """editing query results shouldn't affect record [find+keys]"""
         msg_id = self.db.get_history()[-1]
         rec = self.db.find_records({'msg_id' : msg_id}, keys=['buffers', 'header'])[0]
         rec.pop('buffers')
         rec['garbage'] = 'hello'
         rec['header']['msg_id'] = 'fubar'
         rec2 = self.db.find_records({'msg_id' : msg_id})[0]
         self.assertTrue('buffers' in rec2)
         self.assertFalse('garbage' in rec2)
-        self.assertEquals(rec2['header']['msg_id'], msg_id)
+        self.assertEqual(rec2['header']['msg_id'], msg_id)
 
 
 class TestSQLiteBackend(TestDictBackend):
 
     @dec.skip_without('sqlite3')
     def create_db(self):
         location, fname = os.path.split(temp_db)
         log = logging.getLogger('test')
         log.setLevel(logging.CRITICAL)
         return SQLiteDB(location=location, fname=fname, log=log)
     
     def tearDown(self):
         self.db._db.close()
 
 
 def teardown():
     """cleanup task db file after all tests have run"""
     try:
         os.remove(temp_db)
     except:
         pass

IPython/parallel/tests/test_dependency.py

@@ -1,106 +1,106 b''
 """Tests for dependency.py
 
 Authors:
 
 * Min RK
 """
 
 __docformat__ = "restructuredtext en"
 
 #-------------------------------------------------------------------------------
 #  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
 import os
 
 from IPython.utils.pickleutil import can, uncan
 
 import IPython.parallel as pmod
 from IPython.parallel.util import interactive
 
 from IPython.parallel.tests import add_engines
 from .clienttest import ClusterTestCase
 
 def setup():
     add_engines(1, total=True)
 
 @pmod.require('time')
 def wait(n):
     time.sleep(n)
     return n
 
 mixed = map(str, range(10))
 completed = map(str, range(0,10,2))
 failed = map(str, range(1,10,2))
 
 class DependencyTest(ClusterTestCase):
     
     def setUp(self):
         ClusterTestCase.setUp(self)
         self.user_ns = {'__builtins__' : __builtins__}
         self.view = self.client.load_balanced_view()
         self.dview = self.client[-1]
         self.succeeded = set(map(str, range(0,25,2)))
         self.failed = set(map(str, range(1,25,2)))
     
     def assertMet(self, dep):
         self.assertTrue(dep.check(self.succeeded, self.failed), "Dependency should be met")
         
     def assertUnmet(self, dep):
         self.assertFalse(dep.check(self.succeeded, self.failed), "Dependency should not be met")
         
     def assertUnreachable(self, dep):
         self.assertTrue(dep.unreachable(self.succeeded, self.failed), "Dependency should be unreachable")
     
     def assertReachable(self, dep):
         self.assertFalse(dep.unreachable(self.succeeded, self.failed), "Dependency should be reachable")
     
     def cancan(self, f):
         """decorator to pass through canning into self.user_ns"""
         return uncan(can(f), self.user_ns)
     
     def test_require_imports(self):
         """test that @require imports names"""
         @self.cancan
         @pmod.require('urllib')
         @interactive
         def encode(dikt):
             return urllib.urlencode(dikt)
         # must pass through canning to properly connect namespaces
-        self.assertEquals(encode(dict(a=5)), 'a=5')
+        self.assertEqual(encode(dict(a=5)), 'a=5')
     
     def test_success_only(self):
         dep = pmod.Dependency(mixed, success=True, failure=False)
         self.assertUnmet(dep)
         self.assertUnreachable(dep)
         dep.all=False
         self.assertMet(dep)
         self.assertReachable(dep)
         dep = pmod.Dependency(completed, success=True, failure=False)
         self.assertMet(dep)
         self.assertReachable(dep)
         dep.all=False
         self.assertMet(dep)
         self.assertReachable(dep)
 
     def test_failure_only(self):
         dep = pmod.Dependency(mixed, success=False, failure=True)
         self.assertUnmet(dep)
         self.assertUnreachable(dep)
         dep.all=False
         self.assertMet(dep)
         self.assertReachable(dep)
         dep = pmod.Dependency(completed, success=False, failure=True)
         self.assertUnmet(dep)
         self.assertUnreachable(dep)
         dep.all=False
         self.assertUnmet(dep)
         self.assertUnreachable(dep)

IPython/parallel/tests/test_lbview.py

@@ -1,176 +1,176 b''
 # -*- coding: utf-8 -*-
 """test LoadBalancedView objects
 
 Authors:
 
 * Min RK
 """
 #-------------------------------------------------------------------------------
 #  Copyright (C) 2011  The IPython Development Team
 #
 #  Distributed under the terms of the BSD License.  The full license is in
 #  the file COPYING, distributed as part of this software.
 #-------------------------------------------------------------------------------
 
 #-------------------------------------------------------------------------------
 # Imports
 #-------------------------------------------------------------------------------
 
 import sys
 import time
 
 import zmq
 from nose import SkipTest
 
 from IPython import parallel  as pmod
 from IPython.parallel import error
 
 from IPython.parallel.tests import add_engines
 
 from .clienttest import ClusterTestCase, crash, wait, skip_without
 
 def setup():
     add_engines(3, total=True)
 
 class TestLoadBalancedView(ClusterTestCase):
 
     def setUp(self):
         ClusterTestCase.setUp(self)
         self.view = self.client.load_balanced_view()
 
     def test_z_crash_task(self):
         """test graceful handling of engine death (balanced)"""
         raise SkipTest("crash tests disabled, due to undesirable crash reports")
         # self.add_engines(1)
         ar = self.view.apply_async(crash)
         self.assertRaisesRemote(error.EngineError, ar.get, 10)
         eid = ar.engine_id
         tic = time.time()
         while eid in self.client.ids and time.time()-tic < 5:
             time.sleep(.01)
             self.client.spin()
         self.assertFalse(eid in self.client.ids, "Engine should have died")
 
     def test_map(self):
         def f(x):
             return x**2
         data = range(16)
         r = self.view.map_sync(f, data)
-        self.assertEquals(r, map(f, data))
+        self.assertEqual(r, map(f, data))
 
     def test_map_unordered(self):
         def f(x):
             return x**2
         def slow_f(x):
             import time
             time.sleep(0.05*x)
             return x**2
         data = range(16,0,-1)
         reference = map(f, data)
         
         amr = self.view.map_async(slow_f, data, ordered=False)
         self.assertTrue(isinstance(amr, pmod.AsyncMapResult))
         # check individual elements, retrieved as they come
         # list comprehension uses __iter__
         astheycame = [ r for r in amr ]
         # Ensure that at least one result came out of order:
         self.assertNotEquals(astheycame, reference, "should not have preserved order")
-        self.assertEquals(sorted(astheycame, reverse=True), reference, "result corrupted")
+        self.assertEqual(sorted(astheycame, reverse=True), reference, "result corrupted")
 
     def test_map_ordered(self):
         def f(x):
             return x**2
         def slow_f(x):
             import time
             time.sleep(0.05*x)
             return x**2
         data = range(16,0,-1)
         reference = map(f, data)
         
         amr = self.view.map_async(slow_f, data)
         self.assertTrue(isinstance(amr, pmod.AsyncMapResult))
         # check individual elements, retrieved as they come
         # list(amr) uses __iter__
         astheycame = list(amr)
         # Ensure that results came in order
-        self.assertEquals(astheycame, reference)
-        self.assertEquals(amr.result, reference)
+        self.assertEqual(astheycame, reference)
+        self.assertEqual(amr.result, reference)
 
     def test_map_iterable(self):
         """test map on iterables (balanced)"""
         view = self.view
         # 101 is prime, so it won't be evenly distributed
         arr = range(101)
         # so that it will be an iterator, even in Python 3
         it = iter(arr)
         r = view.map_sync(lambda x:x, arr)
-        self.assertEquals(r, list(arr))
+        self.assertEqual(r, list(arr))
 
     
     def test_abort(self):
         view = self.view
         ar = self.client[:].apply_async(time.sleep, .5)
         ar = self.client[:].apply_async(time.sleep, .5)
         time.sleep(0.2)
         ar2 = view.apply_async(lambda : 2)
         ar3 = view.apply_async(lambda : 3)
         view.abort(ar2)
         view.abort(ar3.msg_ids)
         self.assertRaises(error.TaskAborted, ar2.get)
         self.assertRaises(error.TaskAborted, ar3.get)
 
     def test_retries(self):
         view = self.view
         view.timeout = 1 # prevent hang if this doesn't behave
         def fail():
             assert False
         for r in range(len(self.client)-1):
             with view.temp_flags(retries=r):
                 self.assertRaisesRemote(AssertionError, view.apply_sync, fail)
 
         with view.temp_flags(retries=len(self.client), timeout=0.25):
             self.assertRaisesRemote(error.TaskTimeout, view.apply_sync, fail)
 
     def test_invalid_dependency(self):
         view = self.view
         with view.temp_flags(after='12345'):
             self.assertRaisesRemote(error.InvalidDependency, view.apply_sync, lambda : 1)
 
     def test_impossible_dependency(self):
         self.minimum_engines(2)
         view = self.client.load_balanced_view()
         ar1 = view.apply_async(lambda : 1)
         ar1.get()
         e1 = ar1.engine_id
         e2 = e1
         while e2 == e1:
             ar2 = view.apply_async(lambda : 1)
             ar2.get()
             e2 = ar2.engine_id
 
         with view.temp_flags(follow=[ar1, ar2]):
             self.assertRaisesRemote(error.ImpossibleDependency, view.apply_sync, lambda : 1)
 
 
     def test_follow(self):
         ar = self.view.apply_async(lambda : 1)
         ar.get()
         ars = []
         first_id = ar.engine_id
 
         self.view.follow = ar
         for i in range(5):
             ars.append(self.view.apply_async(lambda : 1))
         self.view.wait(ars)
         for ar in ars:
-            self.assertEquals(ar.engine_id, first_id)
+            self.assertEqual(ar.engine_id, first_id)
 
     def test_after(self):
         view = self.view
         ar = view.apply_async(time.sleep, 0.5)
         with view.temp_flags(after=ar):
             ar2 = view.apply_async(lambda : 1)
 
         ar.wait()
         ar2.wait()
         self.assertTrue(ar2.started >= ar.completed, "%s not >= %s"%(ar.started, ar.completed))

IPython/parallel/tests/test_magics.py

@@ -1,386 +1,386 b''
 # -*- coding: utf-8 -*-
 """Test Parallel magics
 
 Authors:
 
 * Min RK
 """
 #-------------------------------------------------------------------------------
 #  Copyright (C) 2011  The IPython Development Team
 #
 #  Distributed under the terms of the BSD License.  The full license is in
 #  the file COPYING, distributed as part of this software.
 #-------------------------------------------------------------------------------
 
 #-------------------------------------------------------------------------------
 # Imports
 #-------------------------------------------------------------------------------
 
 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
 
 from .clienttest import ClusterTestCase, generate_output
 
 def setup():
     add_engines(3, total=True)
 
 class TestParallelMagics(ClusterTestCase, ParametricTestCase):
     
     def test_px_blocking(self):
         ip = get_ipython()
         v = self.client[-1:]
         v.activate()
         v.block=True
 
         ip.magic('px a=5')
-        self.assertEquals(v['a'], [5])
+        self.assertEqual(v['a'], [5])
         ip.magic('px a=10')
-        self.assertEquals(v['a'], [10])
+        self.assertEqual(v['a'], [10])
         # just 'print a' works ~99% of the time, but this ensures that
         # the stdout message has arrived when the result is finished:
         with capture_output() as io:
             ip.magic(
                 'px import sys,time;print(a);sys.stdout.flush();time.sleep(0.2)'
             )
         out = io.stdout
         self.assertTrue('[stdout:' in out, out)
         self.assertFalse('\n\n' in out)
         self.assertTrue(out.rstrip().endswith('10'))
         self.assertRaisesRemote(ZeroDivisionError, ip.magic, 'px 1/0')
     
     def _check_generated_stderr(self, stderr, n):
         expected = [
             r'\[stderr:\d+\]',
             '^stderr$',
             '^stderr2$',
         ] * n
         
         self.assertFalse('\n\n' in stderr, stderr)
         lines = stderr.splitlines()
-        self.assertEquals(len(lines), len(expected), stderr)
+        self.assertEqual(len(lines), len(expected), stderr)
         for line,expect in zip(lines, expected):
             if isinstance(expect, str):
                 expect = [expect]
             for ex in expect:
                 self.assertTrue(re.search(ex, line) is not None, "Expected %r in %r" % (ex, line))
         
     def test_cellpx_block_args(self):
         """%%px --[no]block flags work"""
         ip = get_ipython()
         v = self.client[-1:]
         v.activate()
         v.block=False
         
         for block in (True, False):
             v.block = block
             ip.magic("pxconfig --verbose")
             with capture_output() as io:
                 ip.run_cell_magic("px", "", "1")
             if block:
                 self.assertTrue(io.stdout.startswith("Parallel"), io.stdout)
             else:
                 self.assertTrue(io.stdout.startswith("Async"), io.stdout)
             
             with capture_output() as io:
                 ip.run_cell_magic("px", "--block", "1")
             self.assertTrue(io.stdout.startswith("Parallel"), io.stdout)
 
             with capture_output() as io:
                 ip.run_cell_magic("px", "--noblock", "1")
             self.assertTrue(io.stdout.startswith("Async"), io.stdout)
     
     def test_cellpx_groupby_engine(self):
         """%%px --group-outputs=engine"""
         ip = get_ipython()
         v = self.client[:]
         v.block = True
         v.activate()
         
         v['generate_output'] = generate_output
         
         with capture_output() as io:
             ip.run_cell_magic('px', '--group-outputs=engine', 'generate_output()')
         
         self.assertFalse('\n\n' in io.stdout)
         lines = io.stdout.splitlines()
         expected = [
             r'\[stdout:\d+\]',
             'stdout',
             'stdout2',
             r'\[output:\d+\]',
             r'IPython\.core\.display\.HTML',
             r'IPython\.core\.display\.Math',
             r'Out\[\d+:\d+\]:.*IPython\.core\.display\.Math',
             ] * len(v)
         
-        self.assertEquals(len(lines), len(expected), io.stdout)
+        self.assertEqual(len(lines), len(expected), io.stdout)
         for line,expect in zip(lines, expected):
             if isinstance(expect, str):
                 expect = [expect]
             for ex in expect:
                 self.assertTrue(re.search(ex, line) is not None, "Expected %r in %r" % (ex, line))
         
         self._check_generated_stderr(io.stderr, len(v))
 
 
     def test_cellpx_groupby_order(self):
         """%%px --group-outputs=order"""
         ip = get_ipython()
         v = self.client[:]
         v.block = True
         v.activate()
         
         v['generate_output'] = generate_output
         
         with capture_output() as io:
             ip.run_cell_magic('px', '--group-outputs=order', 'generate_output()')
         
         self.assertFalse('\n\n' in io.stdout)
         lines = io.stdout.splitlines()
         expected = []
         expected.extend([
             r'\[stdout:\d+\]',
             'stdout',
             'stdout2',
         ] * len(v))
         expected.extend([
             r'\[output:\d+\]',
             'IPython.core.display.HTML',
         ] * len(v))
         expected.extend([
             r'\[output:\d+\]',
             'IPython.core.display.Math',
         ] * len(v))
         expected.extend([
             r'Out\[\d+:\d+\]:.*IPython\.core\.display\.Math'
         ] * len(v))
         
-        self.assertEquals(len(lines), len(expected), io.stdout)
+        self.assertEqual(len(lines), len(expected), io.stdout)
         for line,expect in zip(lines, expected):
             if isinstance(expect, str):
                 expect = [expect]
             for ex in expect:
                 self.assertTrue(re.search(ex, line) is not None, "Expected %r in %r" % (ex, line))
         
         self._check_generated_stderr(io.stderr, len(v))
 
     def test_cellpx_groupby_type(self):
         """%%px --group-outputs=type"""
         ip = get_ipython()
         v = self.client[:]
         v.block = True
         v.activate()
         
         v['generate_output'] = generate_output
         
         with capture_output() as io:
             ip.run_cell_magic('px', '--group-outputs=type', 'generate_output()')
         
         self.assertFalse('\n\n' in io.stdout)
         lines = io.stdout.splitlines()
         
         expected = []
         expected.extend([
             r'\[stdout:\d+\]',
             'stdout',
             'stdout2',
         ] * len(v))
         expected.extend([
             r'\[output:\d+\]',
             r'IPython\.core\.display\.HTML',
             r'IPython\.core\.display\.Math',
         ] * len(v))
         expected.extend([
             (r'Out\[\d+:\d+\]', r'IPython\.core\.display\.Math')
         ] * len(v))
         
-        self.assertEquals(len(lines), len(expected), io.stdout)
+        self.assertEqual(len(lines), len(expected), io.stdout)
         for line,expect in zip(lines, expected):
             if isinstance(expect, str):
                 expect = [expect]
             for ex in expect:
                 self.assertTrue(re.search(ex, line) is not None, "Expected %r in %r" % (ex, line))
         
         self._check_generated_stderr(io.stderr, len(v))
 
 
     def test_px_nonblocking(self):
         ip = get_ipython()
         v = self.client[-1:]
         v.activate()
         v.block=False
 
         ip.magic('px a=5')
-        self.assertEquals(v['a'], [5])
+        self.assertEqual(v['a'], [5])
         ip.magic('px a=10')
-        self.assertEquals(v['a'], [10])
+        self.assertEqual(v['a'], [10])
         ip.magic('pxconfig --verbose')
         with capture_output() as io:
             ar = ip.magic('px print (a)')
         self.assertTrue(isinstance(ar, AsyncResult))
         self.assertTrue('Async' in io.stdout)
         self.assertFalse('[stdout:' in io.stdout)
         self.assertFalse('\n\n' in io.stdout)
         
         ar = ip.magic('px 1/0')
         self.assertRaisesRemote(ZeroDivisionError, ar.get)
     
     def test_autopx_blocking(self):
         ip = get_ipython()
         v = self.client[-1]
         v.activate()
         v.block=True
 
         with capture_output() as io:
             ip.magic('autopx')
             ip.run_cell('\n'.join(('a=5','b=12345','c=0')))
             ip.run_cell('b*=2')
             ip.run_cell('print (b)')
             ip.run_cell('b')
             ip.run_cell("b/c")
             ip.magic('autopx')
         
         output = io.stdout
         
         self.assertTrue(output.startswith('%autopx enabled'), output)
         self.assertTrue(output.rstrip().endswith('%autopx disabled'), output)
         self.assertTrue('ZeroDivisionError' in output, output)
         self.assertTrue('\nOut[' in output, output)
         self.assertTrue(': 24690' in output, output)
         ar = v.get_result(-1)
-        self.assertEquals(v['a'], 5)
-        self.assertEquals(v['b'], 24690)
+        self.assertEqual(v['a'], 5)
+        self.assertEqual(v['b'], 24690)
         self.assertRaisesRemote(ZeroDivisionError, ar.get)
 
     def test_autopx_nonblocking(self):
         ip = get_ipython()
         v = self.client[-1]
         v.activate()
         v.block=False
 
         with capture_output() as io:
             ip.magic('autopx')
             ip.run_cell('\n'.join(('a=5','b=10','c=0')))
             ip.run_cell('print (b)')
             ip.run_cell('import time; time.sleep(0.1)')
             ip.run_cell("b/c")
             ip.run_cell('b*=2')
             ip.magic('autopx')
         
         output = io.stdout.rstrip()
         
         self.assertTrue(output.startswith('%autopx enabled'))
         self.assertTrue(output.endswith('%autopx disabled'))
         self.assertFalse('ZeroDivisionError' in output)
         ar = v.get_result(-2)
         self.assertRaisesRemote(ZeroDivisionError, ar.get)
         # prevent TaskAborted on pulls, due to ZeroDivisionError
         time.sleep(0.5)
-        self.assertEquals(v['a'], 5)
+        self.assertEqual(v['a'], 5)
         # b*=2 will not fire, due to abort
-        self.assertEquals(v['b'], 10)
+        self.assertEqual(v['b'], 10)
     
     def test_result(self):
         ip = get_ipython()
         v = self.client[-1]
         v.activate()
         data = dict(a=111,b=222)
         v.push(data, block=True)
 
         for name in ('a', 'b'):
             ip.magic('px ' + name)
             with capture_output() as io:
                 ip.magic('pxresult')
             output = io.stdout
             msg = "expected %s output to include %s, but got: %s" % \
                 ('%pxresult', str(data[name]), output)
             self.assertTrue(str(data[name]) in output, msg)
         
     @dec.skipif_not_matplotlib
     def test_px_pylab(self):
         """%pylab works on engines"""
         ip = get_ipython()
         v = self.client[-1]
         v.block = True
         v.activate()
         
         with capture_output() as io:
             ip.magic("px %pylab inline")
         
         self.assertTrue("Welcome to pylab" in io.stdout, io.stdout)
         self.assertTrue("backend_inline" in io.stdout, io.stdout)
         
         with capture_output() as io:
             ip.magic("px plot(rand(100))")
         
         self.assertTrue('Out[' in io.stdout, io.stdout)
         self.assertTrue('matplotlib.lines' in io.stdout, io.stdout)
     
     def test_pxconfig(self):
         ip = get_ipython()
         rc = self.client
         v = rc.activate(-1, '_tst')
-        self.assertEquals(v.targets, rc.ids[-1])
+        self.assertEqual(v.targets, rc.ids[-1])
         ip.magic("%pxconfig_tst -t :")
-        self.assertEquals(v.targets, rc.ids)
+        self.assertEqual(v.targets, rc.ids)
         ip.magic("%pxconfig_tst -t ::2")
-        self.assertEquals(v.targets, rc.ids[::2])
+        self.assertEqual(v.targets, rc.ids[::2])
         ip.magic("%pxconfig_tst -t 1::2")
-        self.assertEquals(v.targets, rc.ids[1::2])
+        self.assertEqual(v.targets, rc.ids[1::2])
         ip.magic("%pxconfig_tst -t 1")
-        self.assertEquals(v.targets, 1)
+        self.assertEqual(v.targets, 1)
         ip.magic("%pxconfig_tst --block")
-        self.assertEquals(v.block, True)
+        self.assertEqual(v.block, True)
         ip.magic("%pxconfig_tst --noblock")
-        self.assertEquals(v.block, False)
+        self.assertEqual(v.block, False)
     
     def test_cellpx_targets(self):
         """%%px --targets doesn't change defaults"""
         ip = get_ipython()
         rc = self.client
         view = rc.activate(rc.ids)
-        self.assertEquals(view.targets, rc.ids)
+        self.assertEqual(view.targets, rc.ids)
         ip.magic('pxconfig --verbose')
         for cell in ("pass", "1/0"):
             with capture_output() as io:
                 try:
                     ip.run_cell_magic("px", "--targets all", cell)
                 except pmod.RemoteError:
                     pass
             self.assertTrue('engine(s): all' in io.stdout)
-            self.assertEquals(view.targets, rc.ids)
+            self.assertEqual(view.targets, rc.ids)
 
 
     def test_cellpx_block(self):
         """%%px --block doesn't change default"""
         ip = get_ipython()
         rc = self.client
         view = rc.activate(rc.ids)
         view.block = False
-        self.assertEquals(view.targets, rc.ids)
+        self.assertEqual(view.targets, rc.ids)
         ip.magic('pxconfig --verbose')
         for cell in ("pass", "1/0"):
             with capture_output() as io:
                 try:
                     ip.run_cell_magic("px", "--block", cell)
                 except pmod.RemoteError:
                     pass
             self.assertFalse('Async' in io.stdout)
             self.assertFalse(view.block)
 
 

IPython/parallel/tests/test_newserialized.py

@@ -1,117 +1,117 b''
 """test serialization with newserialized
 
 Authors:
 
 * Min RK
 """
 
 #-------------------------------------------------------------------------------
 #  Copyright (C) 2011  The IPython Development Team
 #
 #  Distributed under the terms of the BSD License.  The full license is in
 #  the file COPYING, distributed as part of this software.
 #-------------------------------------------------------------------------------
 
 #-------------------------------------------------------------------------------
 # Imports
 #-------------------------------------------------------------------------------
 
 import sys
 
 from unittest import TestCase
 
 from IPython.testing.decorators import parametric
 from IPython.utils import newserialized as ns
 from IPython.utils.pickleutil import can, uncan, CannedObject, CannedFunction
 from IPython.parallel.tests.clienttest import skip_without
 
 if sys.version_info[0] >= 3:
     buffer = memoryview
 
 class CanningTestCase(TestCase):
     def test_canning(self):
         d = dict(a=5,b=6)
         cd = can(d)
         self.assertTrue(isinstance(cd, dict))
 
     def test_canned_function(self):
         f = lambda : 7
         cf = can(f)
         self.assertTrue(isinstance(cf, CannedFunction))
     
     @parametric
     def test_can_roundtrip(cls):
         objs = [
             dict(),
             set(),
             list(),
             ['a',1,['a',1],u'e'],
         ]
         return map(cls.run_roundtrip, objs)
     
     @classmethod
     def run_roundtrip(self, obj):
         o = uncan(can(obj))
         assert o == obj, "failed assertion: %r == %r"%(o,obj)
     
     def test_serialized_interfaces(self):
 
         us = {'a':10, 'b':range(10)}
         s = ns.serialize(us)
         uus = ns.unserialize(s)
         self.assertTrue(isinstance(s, ns.SerializeIt))
-        self.assertEquals(uus, us)
+        self.assertEqual(uus, us)
 
     def test_pickle_serialized(self):
         obj = {'a':1.45345, 'b':'asdfsdf', 'c':10000L}
         original = ns.UnSerialized(obj)
         originalSer = ns.SerializeIt(original)
         firstData = originalSer.getData()
         firstTD = originalSer.getTypeDescriptor()
         firstMD = originalSer.getMetadata()
-        self.assertEquals(firstTD, 'pickle')
-        self.assertEquals(firstMD, {})
+        self.assertEqual(firstTD, 'pickle')
+        self.assertEqual(firstMD, {})
         unSerialized = ns.UnSerializeIt(originalSer)
         secondObj = unSerialized.getObject()
         for k, v in secondObj.iteritems():
-            self.assertEquals(obj[k], v)
+            self.assertEqual(obj[k], v)
         secondSer = ns.SerializeIt(ns.UnSerialized(secondObj))
-        self.assertEquals(firstData, secondSer.getData())
-        self.assertEquals(firstTD, secondSer.getTypeDescriptor() )
-        self.assertEquals(firstMD, secondSer.getMetadata())
+        self.assertEqual(firstData, secondSer.getData())
+        self.assertEqual(firstTD, secondSer.getTypeDescriptor() )
+        self.assertEqual(firstMD, secondSer.getMetadata())
     
     @skip_without('numpy')
     def test_ndarray_serialized(self):
         import numpy
         a = numpy.linspace(0.0, 1.0, 1000)
         unSer1 = ns.UnSerialized(a)
         ser1 = ns.SerializeIt(unSer1)
         td = ser1.getTypeDescriptor()
-        self.assertEquals(td, 'ndarray')
+        self.assertEqual(td, 'ndarray')
         md = ser1.getMetadata()
-        self.assertEquals(md['shape'], a.shape)
-        self.assertEquals(md['dtype'], a.dtype)
+        self.assertEqual(md['shape'], a.shape)
+        self.assertEqual(md['dtype'], a.dtype)
         buff = ser1.getData()
-        self.assertEquals(buff, buffer(a))
+        self.assertEqual(buff, buffer(a))
         s = ns.Serialized(buff, td, md)
         final = ns.unserialize(s)
-        self.assertEquals(buffer(a), buffer(final))
+        self.assertEqual(buffer(a), buffer(final))
         self.assertTrue((a==final).all())
-        self.assertEquals(a.dtype, final.dtype)
-        self.assertEquals(a.shape, final.shape)
+        self.assertEqual(a.dtype, final.dtype)
+        self.assertEqual(a.shape, final.shape)
         # test non-copying:
         a[2] = 1e9
         self.assertTrue((a==final).all())
     
     def test_uncan_function_globals(self):
         """test that uncanning a module function restores it into its module"""
         from re import search
         cf = can(search)
         csearch = uncan(cf)
         self.assertEqual(csearch.__module__, search.__module__)
         self.assertNotEqual(csearch('asd', 'asdf'), None)
         csearch = uncan(cf, dict(a=5))
         self.assertEqual(csearch.__module__, search.__module__)
         self.assertNotEqual(csearch('asd', 'asdf'), None)
         
         
  No newline at end of file

IPython/parallel/tests/test_view.py

@@ -1,597 +1,597 b''
 # -*- coding: utf-8 -*-
 """test View objects
 
 Authors:
 
 * Min RK
 """
 #-------------------------------------------------------------------------------
 #  Copyright (C) 2011  The IPython Development Team
 #
 #  Distributed under the terms of the BSD License.  The full license is in
 #  the file COPYING, distributed as part of this software.
 #-------------------------------------------------------------------------------
 
 #-------------------------------------------------------------------------------
 # Imports
 #-------------------------------------------------------------------------------
 
 import sys
 import platform
 import time
 from tempfile import mktemp
 from StringIO import StringIO
 
 import zmq
 from nose import SkipTest
 
 from IPython.testing import decorators as dec
 from IPython.testing.ipunittest import ParametricTestCase
 
 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
 
 from .clienttest import ClusterTestCase, crash, wait, skip_without
 
 def setup():
     add_engines(3, total=True)
 
 class TestView(ClusterTestCase, ParametricTestCase):
     
     def setUp(self):
         # On Win XP, wait for resource cleanup, else parallel test group fails
         if platform.system() == "Windows" and platform.win32_ver()[0] == "XP":
             # 1 sec fails. 1.5 sec seems ok. Using 2 sec for margin of safety
             time.sleep(2)
         super(TestView, self).setUp()
 
     def test_z_crash_mux(self):
         """test graceful handling of engine death (direct)"""
         raise SkipTest("crash tests disabled, due to undesirable crash reports")
         # self.add_engines(1)
         eid = self.client.ids[-1]
         ar = self.client[eid].apply_async(crash)
         self.assertRaisesRemote(error.EngineError, ar.get, 10)
         eid = ar.engine_id
         tic = time.time()
         while eid in self.client.ids and time.time()-tic < 5:
             time.sleep(.01)
             self.client.spin()
         self.assertFalse(eid in self.client.ids, "Engine should have died")
     
     def test_push_pull(self):
         """test pushing and pulling"""
         data = dict(a=10, b=1.05, c=range(10), d={'e':(1,2),'f':'hi'})
         t = self.client.ids[-1]
         v = self.client[t]
         push = v.push
         pull = v.pull
         v.block=True
         nengines = len(self.client)
         push({'data':data})
         d = pull('data')
-        self.assertEquals(d, data)
+        self.assertEqual(d, data)
         self.client[:].push({'data':data})
         d = self.client[:].pull('data', block=True)
-        self.assertEquals(d, nengines*[data])
+        self.assertEqual(d, nengines*[data])
         ar = push({'data':data}, block=False)
         self.assertTrue(isinstance(ar, AsyncResult))
         r = ar.get()
         ar = self.client[:].pull('data', block=False)
         self.assertTrue(isinstance(ar, AsyncResult))
         r = ar.get()
-        self.assertEquals(r, nengines*[data])
+        self.assertEqual(r, nengines*[data])
         self.client[:].push(dict(a=10,b=20))
         r = self.client[:].pull(('a','b'), block=True)
-        self.assertEquals(r, nengines*[[10,20]])
+        self.assertEqual(r, nengines*[[10,20]])
     
     def test_push_pull_function(self):
         "test pushing and pulling functions"
         def testf(x):
             return 2.0*x
         
         t = self.client.ids[-1]
         v = self.client[t]
         v.block=True
         push = v.push
         pull = v.pull
         execute = v.execute
         push({'testf':testf})
         r = pull('testf')
         self.assertEqual(r(1.0), testf(1.0))
         execute('r = testf(10)')
         r = pull('r')
-        self.assertEquals(r, testf(10))
+        self.assertEqual(r, testf(10))
         ar = self.client[:].push({'testf':testf}, block=False)
         ar.get()
         ar = self.client[:].pull('testf', block=False)
         rlist = ar.get()
         for r in rlist:
             self.assertEqual(r(1.0), testf(1.0))
         execute("def g(x): return x*x")
         r = pull(('testf','g'))
-        self.assertEquals((r[0](10),r[1](10)), (testf(10), 100))
+        self.assertEqual((r[0](10),r[1](10)), (testf(10), 100))
     
     def test_push_function_globals(self):
         """test that pushed functions have access to globals"""
         @interactive
         def geta():
             return a
         # self.add_engines(1)
         v = self.client[-1]
         v.block=True
         v['f'] = geta
         self.assertRaisesRemote(NameError, v.execute, 'b=f()')
         v.execute('a=5')
         v.execute('b=f()')
-        self.assertEquals(v['b'], 5)
+        self.assertEqual(v['b'], 5)
     
     def test_push_function_defaults(self):
         """test that pushed functions preserve default args"""
         def echo(a=10):
             return a
         v = self.client[-1]
         v.block=True
         v['f'] = echo
         v.execute('b=f()')
-        self.assertEquals(v['b'], 10)
+        self.assertEqual(v['b'], 10)
 
     def test_get_result(self):
         """test getting results from the Hub."""
         c = pmod.Client(profile='iptest')
         # self.add_engines(1)
         t = c.ids[-1]
         v = c[t]
         v2 = self.client[t]
         ar = v.apply_async(wait, 1)
         # give the monitor time to notice the message
         time.sleep(.25)
         ahr = v2.get_result(ar.msg_ids)
         self.assertTrue(isinstance(ahr, AsyncHubResult))
-        self.assertEquals(ahr.get(), ar.get())
+        self.assertEqual(ahr.get(), ar.get())
         ar2 = v2.get_result(ar.msg_ids)
         self.assertFalse(isinstance(ar2, AsyncHubResult))
         c.spin()
         c.close()
     
     def test_run_newline(self):
         """test that run appends newline to files"""
         tmpfile = mktemp()
         with open(tmpfile, 'w') as f:
             f.write("""def g():
                 return 5
                 """)
         v = self.client[-1]
         v.run(tmpfile, block=True)
-        self.assertEquals(v.apply_sync(lambda f: f(), pmod.Reference('g')), 5)
+        self.assertEqual(v.apply_sync(lambda f: f(), pmod.Reference('g')), 5)
 
     def test_apply_tracked(self):
         """test tracking for apply"""
         # self.add_engines(1)
         t = self.client.ids[-1]
         v = self.client[t]
         v.block=False
         def echo(n=1024*1024, **kwargs):
             with v.temp_flags(**kwargs):
                 return v.apply(lambda x: x, 'x'*n)
         ar = echo(1, track=False)
         self.assertTrue(isinstance(ar._tracker, zmq.MessageTracker))
         self.assertTrue(ar.sent)
         ar = echo(track=True)
         self.assertTrue(isinstance(ar._tracker, zmq.MessageTracker))
-        self.assertEquals(ar.sent, ar._tracker.done)
+        self.assertEqual(ar.sent, ar._tracker.done)
         ar._tracker.wait()
         self.assertTrue(ar.sent)
         
     def test_push_tracked(self):
         t = self.client.ids[-1]
         ns = dict(x='x'*1024*1024)
         v = self.client[t]
         ar = v.push(ns, block=False, track=False)
         self.assertTrue(isinstance(ar._tracker, zmq.MessageTracker))
         self.assertTrue(ar.sent)
         
         ar = v.push(ns, block=False, track=True)
         self.assertTrue(isinstance(ar._tracker, zmq.MessageTracker))
         ar._tracker.wait()
-        self.assertEquals(ar.sent, ar._tracker.done)
+        self.assertEqual(ar.sent, ar._tracker.done)
         self.assertTrue(ar.sent)
         ar.get()
         
     def test_scatter_tracked(self):
         t = self.client.ids
         x='x'*1024*1024
         ar = self.client[t].scatter('x', x, block=False, track=False)
         self.assertTrue(isinstance(ar._tracker, zmq.MessageTracker))
         self.assertTrue(ar.sent)
         
         ar = self.client[t].scatter('x', x, block=False, track=True)
         self.assertTrue(isinstance(ar._tracker, zmq.MessageTracker))
-        self.assertEquals(ar.sent, ar._tracker.done)
+        self.assertEqual(ar.sent, ar._tracker.done)
         ar._tracker.wait()
         self.assertTrue(ar.sent)
         ar.get()
     
     def test_remote_reference(self):
         v = self.client[-1]
         v['a'] = 123
         ra = pmod.Reference('a')
         b = v.apply_sync(lambda x: x, ra)
-        self.assertEquals(b, 123)
+        self.assertEqual(b, 123)
 
 
     def test_scatter_gather(self):
         view = self.client[:]
         seq1 = range(16)
         view.scatter('a', seq1)
         seq2 = view.gather('a', block=True)
-        self.assertEquals(seq2, seq1)
+        self.assertEqual(seq2, seq1)
         self.assertRaisesRemote(NameError, view.gather, 'asdf', block=True)
     
     @skip_without('numpy')
     def test_scatter_gather_numpy(self):
         import numpy
         from numpy.testing.utils import assert_array_equal, assert_array_almost_equal
         view = self.client[:]
         a = numpy.arange(64)
         view.scatter('a', a)
         b = view.gather('a', block=True)
         assert_array_equal(b, a)
     
     def test_scatter_gather_lazy(self):
         """scatter/gather with targets='all'"""
         view = self.client.direct_view(targets='all')
         x = range(64)
         view.scatter('x', x)
         gathered = view.gather('x', block=True)
-        self.assertEquals(gathered, x)
+        self.assertEqual(gathered, x)
         
 
     @dec.known_failure_py3
     @skip_without('numpy')
     def test_push_numpy_nocopy(self):
         import numpy
         view = self.client[:]
         a = numpy.arange(64)
         view['A'] = a
         @interactive
         def check_writeable(x):
             return x.flags.writeable
         
         for flag in view.apply_sync(check_writeable, pmod.Reference('A')):
             self.assertFalse(flag, "array is writeable, push shouldn't have pickled it")
         
         view.push(dict(B=a))
         for flag in view.apply_sync(check_writeable, pmod.Reference('B')):
             self.assertFalse(flag, "array is writeable, push shouldn't have pickled it")
     
     @skip_without('numpy')
     def test_apply_numpy(self):
         """view.apply(f, ndarray)"""
         import numpy
         from numpy.testing.utils import assert_array_equal, assert_array_almost_equal
         
         A = numpy.random.random((100,100))
         view = self.client[-1]
         for dt in [ 'int32', 'uint8', 'float32', 'float64' ]:
             B = A.astype(dt)
             C = view.apply_sync(lambda x:x, B)
             assert_array_equal(B,C)
     
     @skip_without('numpy')
     def test_push_pull_recarray(self):
         """push/pull recarrays"""
         import numpy
         from numpy.testing.utils import assert_array_equal
         
         view = self.client[-1]
         
         R = numpy.array([
             (1, 'hi', 0.),
             (2**30, 'there', 2.5),
             (-99999, 'world', -12345.6789),
         ], [('n', int), ('s', '|S10'), ('f', float)])
         
         view['RR'] = R
         R2 = view['RR']
         
         r_dtype, r_shape = view.apply_sync(interactive(lambda : (RR.dtype, RR.shape)))
-        self.assertEquals(r_dtype, R.dtype)
-        self.assertEquals(r_shape, R.shape)
-        self.assertEquals(R2.dtype, R.dtype)
-        self.assertEquals(R2.shape, R.shape)
+        self.assertEqual(r_dtype, R.dtype)
+        self.assertEqual(r_shape, R.shape)
+        self.assertEqual(R2.dtype, R.dtype)
+        self.assertEqual(R2.shape, R.shape)
         assert_array_equal(R2, R)
     
     def test_map(self):
         view = self.client[:]
         def f(x):
             return x**2
         data = range(16)
         r = view.map_sync(f, data)
-        self.assertEquals(r, map(f, data))
+        self.assertEqual(r, map(f, data))
     
     def test_map_iterable(self):
         """test map on iterables (direct)"""
         view = self.client[:]
         # 101 is prime, so it won't be evenly distributed
         arr = range(101)
         # ensure it will be an iterator, even in Python 3
         it = iter(arr)
         r = view.map_sync(lambda x:x, arr)
-        self.assertEquals(r, list(arr))
+        self.assertEqual(r, list(arr))
     
     def test_scatterGatherNonblocking(self):
         data = range(16)
         view = self.client[:]
         view.scatter('a', data, block=False)
         ar = view.gather('a', block=False)
-        self.assertEquals(ar.get(), data)
+        self.assertEqual(ar.get(), data)
     
     @skip_without('numpy')
     def test_scatter_gather_numpy_nonblocking(self):
         import numpy
         from numpy.testing.utils import assert_array_equal, assert_array_almost_equal
         a = numpy.arange(64)
         view = self.client[:]
         ar = view.scatter('a', a, block=False)
         self.assertTrue(isinstance(ar, AsyncResult))
         amr = view.gather('a', block=False)
         self.assertTrue(isinstance(amr, AsyncMapResult))
         assert_array_equal(amr.get(), a)
 
     def test_execute(self):
         view = self.client[:]
         # self.client.debug=True
         execute = view.execute
         ar = execute('c=30', block=False)
         self.assertTrue(isinstance(ar, AsyncResult))
         ar = execute('d=[0,1,2]', block=False)
         self.client.wait(ar, 1)
-        self.assertEquals(len(ar.get()), len(self.client))
+        self.assertEqual(len(ar.get()), len(self.client))
         for c in view['c']:
-            self.assertEquals(c, 30)
+            self.assertEqual(c, 30)
     
     def test_abort(self):
         view = self.client[-1]
         ar = view.execute('import time; time.sleep(1)', block=False)
         ar2 = view.apply_async(lambda : 2)
         ar3 = view.apply_async(lambda : 3)
         view.abort(ar2)
         view.abort(ar3.msg_ids)
         self.assertRaises(error.TaskAborted, ar2.get)
         self.assertRaises(error.TaskAborted, ar3.get)
     
     def test_abort_all(self):
         """view.abort() aborts all outstanding tasks"""
         view = self.client[-1]
         ars = [ view.apply_async(time.sleep, 0.25) for i in range(10) ]
         view.abort()
         view.wait(timeout=5)
         for ar in ars[5:]:
             self.assertRaises(error.TaskAborted, ar.get)
     
     def test_temp_flags(self):
         view = self.client[-1]
         view.block=True
         with view.temp_flags(block=False):
             self.assertFalse(view.block)
         self.assertTrue(view.block)
     
     @dec.known_failure_py3
     def test_importer(self):
         view = self.client[-1]
         view.clear(block=True)
         with view.importer:
             import re
         
         @interactive
         def findall(pat, s):
             # this globals() step isn't necessary in real code
             # only to prevent a closure in the test
             re = globals()['re']
             return re.findall(pat, s)
         
-        self.assertEquals(view.apply_sync(findall, '\w+', 'hello world'), 'hello world'.split())
+        self.assertEqual(view.apply_sync(findall, '\w+', 'hello world'), 'hello world'.split())
     
     def test_unicode_execute(self):
         """test executing unicode strings"""
         v = self.client[-1]
         v.block=True
         if sys.version_info[0] >= 3:
             code="a='é'"
         else:
             code=u"a=u'é'"
         v.execute(code)
-        self.assertEquals(v['a'], u'é')
+        self.assertEqual(v['a'], u'é')
         
     def test_unicode_apply_result(self):
         """test unicode apply results"""
         v = self.client[-1]
         r = v.apply_sync(lambda : u'é')
-        self.assertEquals(r, u'é')
+        self.assertEqual(r, u'é')
     
     def test_unicode_apply_arg(self):
         """test passing unicode arguments to apply"""
         v = self.client[-1]
         
         @interactive
         def check_unicode(a, check):
             assert isinstance(a, unicode), "%r is not unicode"%a
             assert isinstance(check, bytes), "%r is not bytes"%check
             assert a.encode('utf8') == check, "%s != %s"%(a,check)
         
         for s in [ u'é', u'ßø®∫',u'asdf' ]:
             try:
                 v.apply_sync(check_unicode, s, s.encode('utf8'))
             except error.RemoteError as e:
                 if e.ename == 'AssertionError':
                     self.fail(e.evalue)
                 else:
                     raise e
     
     def test_map_reference(self):
         """view.map(<Reference>, *seqs) should work"""
         v = self.client[:]
         v.scatter('n', self.client.ids, flatten=True)
         v.execute("f = lambda x,y: x*y")
         rf = pmod.Reference('f')
         nlist = list(range(10))
         mlist = nlist[::-1]
         expected = [ m*n for m,n in zip(mlist, nlist) ]
         result = v.map_sync(rf, mlist, nlist)
-        self.assertEquals(result, expected)
+        self.assertEqual(result, expected)
 
     def test_apply_reference(self):
         """view.apply(<Reference>, *args) should work"""
         v = self.client[:]
         v.scatter('n', self.client.ids, flatten=True)
         v.execute("f = lambda x: n*x")
         rf = pmod.Reference('f')
         result = v.apply_sync(rf, 5)
         expected = [ 5*id for id in self.client.ids ]
-        self.assertEquals(result, expected)
+        self.assertEqual(result, expected)
     
     def test_eval_reference(self):
         v = self.client[self.client.ids[0]]
         v['g'] = range(5)
         rg = pmod.Reference('g[0]')
         echo = lambda x:x
-        self.assertEquals(v.apply_sync(echo, rg), 0)
+        self.assertEqual(v.apply_sync(echo, rg), 0)
     
     def test_reference_nameerror(self):
         v = self.client[self.client.ids[0]]
         r = pmod.Reference('elvis_has_left')
         echo = lambda x:x
         self.assertRaisesRemote(NameError, v.apply_sync, echo, r)
 
     def test_single_engine_map(self):
         e0 = self.client[self.client.ids[0]]
         r = range(5)
         check = [ -1*i for i in r ]
         result = e0.map_sync(lambda x: -1*x, r)
-        self.assertEquals(result, check)
+        self.assertEqual(result, check)
     
     def test_len(self):
         """len(view) makes sense"""
         e0 = self.client[self.client.ids[0]]
-        yield self.assertEquals(len(e0), 1)
+        yield self.assertEqual(len(e0), 1)
         v = self.client[:]
-        yield self.assertEquals(len(v), len(self.client.ids))
+        yield self.assertEqual(len(v), len(self.client.ids))
         v = self.client.direct_view('all')
-        yield self.assertEquals(len(v), len(self.client.ids))
+        yield self.assertEqual(len(v), len(self.client.ids))
         v = self.client[:2]
-        yield self.assertEquals(len(v), 2)
+        yield self.assertEqual(len(v), 2)
         v = self.client[:1]
-        yield self.assertEquals(len(v), 1)
+        yield self.assertEqual(len(v), 1)
         v = self.client.load_balanced_view()
-        yield self.assertEquals(len(v), len(self.client.ids))
+        yield self.assertEqual(len(v), len(self.client.ids))
         # parametric tests seem to require manual closing?
         self.client.close()
 
     
     # begin execute tests
     
     def test_execute_reply(self):
         e0 = self.client[self.client.ids[0]]
         e0.block = True
         ar = e0.execute("5", silent=False)
         er = ar.get()
-        self.assertEquals(str(er), "<ExecuteReply[%i]: 5>" % er.execution_count)
-        self.assertEquals(er.pyout['data']['text/plain'], '5')
+        self.assertEqual(str(er), "<ExecuteReply[%i]: 5>" % er.execution_count)
+        self.assertEqual(er.pyout['data']['text/plain'], '5')
 
     def test_execute_reply_stdout(self):
         e0 = self.client[self.client.ids[0]]
         e0.block = True
         ar = e0.execute("print (5)", silent=False)
         er = ar.get()
-        self.assertEquals(er.stdout.strip(), '5')
+        self.assertEqual(er.stdout.strip(), '5')
         
     def test_execute_pyout(self):
         """execute triggers pyout with silent=False"""
         view = self.client[:]
         ar = view.execute("5", silent=False, block=True)
         
         expected = [{'text/plain' : '5'}] * len(view)
         mimes = [ out['data'] for out in ar.pyout ]
-        self.assertEquals(mimes, expected)
+        self.assertEqual(mimes, expected)
     
     def test_execute_silent(self):
         """execute does not trigger pyout with silent=True"""
         view = self.client[:]
         ar = view.execute("5", block=True)
         expected = [None] * len(view)
-        self.assertEquals(ar.pyout, expected)
+        self.assertEqual(ar.pyout, expected)
     
     def test_execute_magic(self):
         """execute accepts IPython commands"""
         view = self.client[:]
         view.execute("a = 5")
         ar = view.execute("%whos", block=True)
         # this will raise, if that failed
         ar.get(5)
         for stdout in ar.stdout:
             lines = stdout.splitlines()
-            self.assertEquals(lines[0].split(), ['Variable', 'Type', 'Data/Info'])
+            self.assertEqual(lines[0].split(), ['Variable', 'Type', 'Data/Info'])
             found = False
             for line in lines[2:]:
                 split = line.split()
                 if split == ['a', 'int', '5']:
                     found = True
                     break
             self.assertTrue(found, "whos output wrong: %s" % stdout)
     
     def test_execute_displaypub(self):
         """execute tracks display_pub output"""
         view = self.client[:]
         view.execute("from IPython.core.display import *")
         ar = view.execute("[ display(i) for i in range(5) ]", block=True)
         
         expected = [ {u'text/plain' : unicode(j)} for j in range(5) ]
         for outputs in ar.outputs:
             mimes = [ out['data'] for out in outputs ]
-            self.assertEquals(mimes, expected)
+            self.assertEqual(mimes, expected)
     
     def test_apply_displaypub(self):
         """apply tracks display_pub output"""
         view = self.client[:]
         view.execute("from IPython.core.display import *")
         
         @interactive
         def publish():
             [ display(i) for i in range(5) ]
         
         ar = view.apply_async(publish)
         ar.get(5)
         expected = [ {u'text/plain' : unicode(j)} for j in range(5) ]
         for outputs in ar.outputs:
             mimes = [ out['data'] for out in outputs ]
-            self.assertEquals(mimes, expected)
+            self.assertEqual(mimes, expected)
     
     def test_execute_raises(self):
         """exceptions in execute requests raise appropriately"""
         view = self.client[-1]
         ar = view.execute("1/0")
         self.assertRaisesRemote(ZeroDivisionError, ar.get, 2)
     
     @dec.skipif_not_matplotlib
     def test_magic_pylab(self):
         """%pylab works on engines"""
         view = self.client[-1]
         ar = view.execute("%pylab inline")
         # at least check if this raised:
         reply = ar.get(5)
         # include imports, in case user config
         ar = view.execute("plot(rand(100))", silent=False)
         reply = ar.get(5)
-        self.assertEquals(len(reply.outputs), 1)
+        self.assertEqual(len(reply.outputs), 1)
         output = reply.outputs[0]
         self.assertTrue("data" in output)
         data = output['data']
         self.assertTrue("image/png" in data)
         
 

IPython/utils/tests/test_process.py

@@ -1,131 +1,131 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
 from unittest import TestCase
 
 import nose.tools as nt
 
 from IPython.utils.process import (find_cmd, FindCmdError, arg_split,
                                    system, getoutput, getoutputerror)
 from IPython.testing import decorators as dec
 from IPython.testing import tools as tt
 
 #-----------------------------------------------------------------------------
 # Tests
 #-----------------------------------------------------------------------------
 
 def test_find_cmd_python():
     """Make sure we find sys.exectable for python."""
     nt.assert_equals(find_cmd('python'), sys.executable)
 
     
 @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')
     nt.assert_true(path.endswith('pythonw.exe'))
 
 
 @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')
 
     
 @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)
     
 @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)
 
 
 class SubProcessTestCase(TestCase, tt.TempFileMixin):
     def setUp(self):
         """Make a valid python temp file."""
         lines = ["from __future__ import print_function",
                  "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('python "%s"' % self.fname)
-        self.assertEquals(status, 0)
+        self.assertEqual(status, 0)
 
     def test_system_quotes(self):
         status = system('python -c "import sys"')
-        self.assertEquals(status, 0)
+        self.assertEqual(status, 0)
 
     def test_getoutput(self):
         out = getoutput('python "%s"' % self.fname)
-        self.assertEquals(out, 'on stdout')
+        self.assertEqual(out, 'on stdout')
 
     def test_getoutput_quoted(self):
         out = getoutput('python -c "print (1)"')
-        self.assertEquals(out.strip(), '1')
+        self.assertEqual(out.strip(), '1')
 
     #Invalid quoting on windows
     @dec.skip_win32
     def test_getoutput_quoted2(self):
         out = getoutput("python -c 'print (1)'")
-        self.assertEquals(out.strip(), '1')
+        self.assertEqual(out.strip(), '1')
         out = getoutput("python -c 'print (\"1\")'")
-        self.assertEquals(out.strip(), '1')
+        self.assertEqual(out.strip(), '1')
 
     def test_getoutput(self):
         out, err = getoutputerror('python "%s"' % self.fname)
-        self.assertEquals(out, 'on stdout')
-        self.assertEquals(err, 'on stderr')
+        self.assertEqual(out, 'on stdout')
+        self.assertEqual(err, 'on stderr')

IPython/utils/tests/test_traitlets.py

@@ -1,908 +1,908 b''
 # encoding: utf-8
 """
 Tests for IPython.utils.traitlets.
 
 Authors:
 
 * Brian Granger
 * Enthought, Inc.  Some of the code in this file comes from enthought.traits
   and is licensed under the BSD license.  Also, many of the ideas also come
   from enthought.traits even though our implementation is very different.
 """
 
 #-----------------------------------------------------------------------------
 #  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 re
 import sys
 from unittest import TestCase
 
 from nose import SkipTest
 
 from IPython.utils.traitlets import (
     HasTraits, MetaHasTraits, TraitType, Any, CBytes,
     Int, Long, Integer, Float, Complex, Bytes, Unicode, TraitError,
     Undefined, Type, This, Instance, TCPAddress, List, Tuple,
     ObjectName, DottedObjectName, CRegExp
 )
 from IPython.utils import py3compat
 from IPython.testing.decorators import skipif
 
 #-----------------------------------------------------------------------------
 # Helper classes for testing
 #-----------------------------------------------------------------------------
 
 
 class HasTraitsStub(HasTraits):
 
     def _notify_trait(self, name, old, new):
         self._notify_name = name
         self._notify_old = old
         self._notify_new = new
 
 
 #-----------------------------------------------------------------------------
 # Test classes
 #-----------------------------------------------------------------------------
 
 
 class TestTraitType(TestCase):
 
     def test_get_undefined(self):
         class A(HasTraits):
             a = TraitType
         a = A()
-        self.assertEquals(a.a, Undefined)
+        self.assertEqual(a.a, Undefined)
 
     def test_set(self):
         class A(HasTraitsStub):
             a = TraitType
 
         a = A()
         a.a = 10
-        self.assertEquals(a.a, 10)
-        self.assertEquals(a._notify_name, 'a')
-        self.assertEquals(a._notify_old, Undefined)
-        self.assertEquals(a._notify_new, 10)
+        self.assertEqual(a.a, 10)
+        self.assertEqual(a._notify_name, 'a')
+        self.assertEqual(a._notify_old, Undefined)
+        self.assertEqual(a._notify_new, 10)
 
     def test_validate(self):
         class MyTT(TraitType):
             def validate(self, inst, value):
                 return -1
         class A(HasTraitsStub):
             tt = MyTT
 
         a = A()
         a.tt = 10
-        self.assertEquals(a.tt, -1)
+        self.assertEqual(a.tt, -1)
 
     def test_default_validate(self):
         class MyIntTT(TraitType):
             def validate(self, obj, value):
                 if isinstance(value, int):
                     return value
                 self.error(obj, value)
         class A(HasTraits):
             tt = MyIntTT(10)
         a = A()
-        self.assertEquals(a.tt, 10)
+        self.assertEqual(a.tt, 10)
 
         # Defaults are validated when the HasTraits is instantiated
         class B(HasTraits):
             tt = MyIntTT('bad default')
         self.assertRaises(TraitError, B)
 
     def test_is_valid_for(self):
         class MyTT(TraitType):
             def is_valid_for(self, value):
                 return True
         class A(HasTraits):
             tt = MyTT
 
         a = A()
         a.tt = 10
-        self.assertEquals(a.tt, 10)
+        self.assertEqual(a.tt, 10)
 
     def test_value_for(self):
         class MyTT(TraitType):
             def value_for(self, value):
                 return 20
         class A(HasTraits):
             tt = MyTT
 
         a = A()
         a.tt = 10
-        self.assertEquals(a.tt, 20)
+        self.assertEqual(a.tt, 20)
 
     def test_info(self):
         class A(HasTraits):
             tt = TraitType
         a = A()
-        self.assertEquals(A.tt.info(), 'any value')
+        self.assertEqual(A.tt.info(), 'any value')
 
     def test_error(self):
         class A(HasTraits):
             tt = TraitType
         a = A()
         self.assertRaises(TraitError, A.tt.error, a, 10)
 
     def test_dynamic_initializer(self):
         class A(HasTraits):
             x = Int(10)
             def _x_default(self):
                 return 11
         class B(A):
             x = Int(20)
         class C(A):
             def _x_default(self):
                 return 21
 
         a = A()
-        self.assertEquals(a._trait_values, {})
-        self.assertEquals(a._trait_dyn_inits.keys(), ['x'])
-        self.assertEquals(a.x, 11)
-        self.assertEquals(a._trait_values, {'x': 11})
+        self.assertEqual(a._trait_values, {})
+        self.assertEqual(a._trait_dyn_inits.keys(), ['x'])
+        self.assertEqual(a.x, 11)
+        self.assertEqual(a._trait_values, {'x': 11})
         b = B()
-        self.assertEquals(b._trait_values, {'x': 20})
-        self.assertEquals(a._trait_dyn_inits.keys(), ['x'])
-        self.assertEquals(b.x, 20)
+        self.assertEqual(b._trait_values, {'x': 20})
+        self.assertEqual(a._trait_dyn_inits.keys(), ['x'])
+        self.assertEqual(b.x, 20)
         c = C()
-        self.assertEquals(c._trait_values, {})
-        self.assertEquals(a._trait_dyn_inits.keys(), ['x'])
-        self.assertEquals(c.x, 21)
-        self.assertEquals(c._trait_values, {'x': 21})
+        self.assertEqual(c._trait_values, {})
+        self.assertEqual(a._trait_dyn_inits.keys(), ['x'])
+        self.assertEqual(c.x, 21)
+        self.assertEqual(c._trait_values, {'x': 21})
         # Ensure that the base class remains unmolested when the _default
         # initializer gets overridden in a subclass.
         a = A()
         c = C()
-        self.assertEquals(a._trait_values, {})
-        self.assertEquals(a._trait_dyn_inits.keys(), ['x'])
-        self.assertEquals(a.x, 11)
-        self.assertEquals(a._trait_values, {'x': 11})
+        self.assertEqual(a._trait_values, {})
+        self.assertEqual(a._trait_dyn_inits.keys(), ['x'])
+        self.assertEqual(a.x, 11)
+        self.assertEqual(a._trait_values, {'x': 11})
 
 
 
 class TestHasTraitsMeta(TestCase):
 
     def test_metaclass(self):
-        self.assertEquals(type(HasTraits), MetaHasTraits)
+        self.assertEqual(type(HasTraits), MetaHasTraits)
 
         class A(HasTraits):
             a = Int
 
         a = A()
-        self.assertEquals(type(a.__class__), MetaHasTraits)
-        self.assertEquals(a.a,0)
+        self.assertEqual(type(a.__class__), MetaHasTraits)
+        self.assertEqual(a.a,0)
         a.a = 10
-        self.assertEquals(a.a,10)
+        self.assertEqual(a.a,10)
 
         class B(HasTraits):
             b = Int()
 
         b = B()
-        self.assertEquals(b.b,0)
+        self.assertEqual(b.b,0)
         b.b = 10
-        self.assertEquals(b.b,10)
+        self.assertEqual(b.b,10)
 
         class C(HasTraits):
             c = Int(30)
 
         c = C()
-        self.assertEquals(c.c,30)
+        self.assertEqual(c.c,30)
         c.c = 10
-        self.assertEquals(c.c,10)
+        self.assertEqual(c.c,10)
 
     def test_this_class(self):
         class A(HasTraits):
             t = This()
             tt = This()
         class B(A):
             tt = This()
             ttt = This()
-        self.assertEquals(A.t.this_class, A)
-        self.assertEquals(B.t.this_class, A)
-        self.assertEquals(B.tt.this_class, B)
-        self.assertEquals(B.ttt.this_class, B)
+        self.assertEqual(A.t.this_class, A)
+        self.assertEqual(B.t.this_class, A)
+        self.assertEqual(B.tt.this_class, B)
+        self.assertEqual(B.ttt.this_class, B)
 
 class TestHasTraitsNotify(TestCase):
 
     def setUp(self):
         self._notify1 = []
         self._notify2 = []
 
     def notify1(self, name, old, new):
         self._notify1.append((name, old, new))
 
     def notify2(self, name, old, new):
         self._notify2.append((name, old, new))
 
     def test_notify_all(self):
 
         class A(HasTraits):
             a = Int
             b = Float
 
         a = A()
         a.on_trait_change(self.notify1)
         a.a = 0
-        self.assertEquals(len(self._notify1),0)
+        self.assertEqual(len(self._notify1),0)
         a.b = 0.0
-        self.assertEquals(len(self._notify1),0)
+        self.assertEqual(len(self._notify1),0)
         a.a = 10
         self.assert_(('a',0,10) in self._notify1)
         a.b = 10.0
         self.assert_(('b',0.0,10.0) in self._notify1)
         self.assertRaises(TraitError,setattr,a,'a','bad string')
         self.assertRaises(TraitError,setattr,a,'b','bad string')
         self._notify1 = []
         a.on_trait_change(self.notify1,remove=True)
         a.a = 20
         a.b = 20.0
-        self.assertEquals(len(self._notify1),0)
+        self.assertEqual(len(self._notify1),0)
 
     def test_notify_one(self):
 
         class A(HasTraits):
             a = Int
             b = Float
 
         a = A()
         a.on_trait_change(self.notify1, 'a')
         a.a = 0
-        self.assertEquals(len(self._notify1),0)
+        self.assertEqual(len(self._notify1),0)
         a.a = 10
         self.assert_(('a',0,10) in self._notify1)
         self.assertRaises(TraitError,setattr,a,'a','bad string')
 
     def test_subclass(self):
 
         class A(HasTraits):
             a = Int
 
         class B(A):
             b = Float
 
         b = B()
-        self.assertEquals(b.a,0)
-        self.assertEquals(b.b,0.0)
+        self.assertEqual(b.a,0)
+        self.assertEqual(b.b,0.0)
         b.a = 100
         b.b = 100.0
-        self.assertEquals(b.a,100)
-        self.assertEquals(b.b,100.0)
+        self.assertEqual(b.a,100)
+        self.assertEqual(b.b,100.0)
 
     def test_notify_subclass(self):
 
         class A(HasTraits):
             a = Int
 
         class B(A):
             b = Float
 
         b = B()
         b.on_trait_change(self.notify1, 'a')
         b.on_trait_change(self.notify2, 'b')
         b.a = 0
         b.b = 0.0
-        self.assertEquals(len(self._notify1),0)
-        self.assertEquals(len(self._notify2),0)
+        self.assertEqual(len(self._notify1),0)
+        self.assertEqual(len(self._notify2),0)
         b.a = 10
         b.b = 10.0
         self.assert_(('a',0,10) in self._notify1)
         self.assert_(('b',0.0,10.0) in self._notify2)
 
     def test_static_notify(self):
 
         class A(HasTraits):
             a = Int
             _notify1 = []
             def _a_changed(self, name, old, new):
                 self._notify1.append((name, old, new))
 
         a = A()
         a.a = 0
         # This is broken!!!
-        self.assertEquals(len(a._notify1),0)
+        self.assertEqual(len(a._notify1),0)
         a.a = 10
         self.assert_(('a',0,10) in a._notify1)
 
         class B(A):
             b = Float
             _notify2 = []
             def _b_changed(self, name, old, new):
                 self._notify2.append((name, old, new))
 
         b = B()
         b.a = 10
         b.b = 10.0
         self.assert_(('a',0,10) in b._notify1)
         self.assert_(('b',0.0,10.0) in b._notify2)
 
     def test_notify_args(self):
 
         def callback0():
             self.cb = ()
         def callback1(name):
             self.cb = (name,)
         def callback2(name, new):
             self.cb = (name, new)
         def callback3(name, old, new):
             self.cb = (name, old, new)
 
         class A(HasTraits):
             a = Int
 
         a = A()
         a.on_trait_change(callback0, 'a')
         a.a = 10
-        self.assertEquals(self.cb,())
+        self.assertEqual(self.cb,())
         a.on_trait_change(callback0, 'a', remove=True)
 
         a.on_trait_change(callback1, 'a')
         a.a = 100
-        self.assertEquals(self.cb,('a',))
+        self.assertEqual(self.cb,('a',))
         a.on_trait_change(callback1, 'a', remove=True)
 
         a.on_trait_change(callback2, 'a')
         a.a = 1000
-        self.assertEquals(self.cb,('a',1000))
+        self.assertEqual(self.cb,('a',1000))
         a.on_trait_change(callback2, 'a', remove=True)
 
         a.on_trait_change(callback3, 'a')
         a.a = 10000
-        self.assertEquals(self.cb,('a',1000,10000))
+        self.assertEqual(self.cb,('a',1000,10000))
         a.on_trait_change(callback3, 'a', remove=True)
 
-        self.assertEquals(len(a._trait_notifiers['a']),0)
+        self.assertEqual(len(a._trait_notifiers['a']),0)
 
 
 class TestHasTraits(TestCase):
 
     def test_trait_names(self):
         class A(HasTraits):
             i = Int
             f = Float
         a = A()
-        self.assertEquals(sorted(a.trait_names()),['f','i'])
-        self.assertEquals(sorted(A.class_trait_names()),['f','i'])
+        self.assertEqual(sorted(a.trait_names()),['f','i'])
+        self.assertEqual(sorted(A.class_trait_names()),['f','i'])
 
     def test_trait_metadata(self):
         class A(HasTraits):
             i = Int(config_key='MY_VALUE')
         a = A()
-        self.assertEquals(a.trait_metadata('i','config_key'), 'MY_VALUE')
+        self.assertEqual(a.trait_metadata('i','config_key'), 'MY_VALUE')
 
     def test_traits(self):
         class A(HasTraits):
             i = Int
             f = Float
         a = A()
-        self.assertEquals(a.traits(), dict(i=A.i, f=A.f))
-        self.assertEquals(A.class_traits(), dict(i=A.i, f=A.f))
+        self.assertEqual(a.traits(), dict(i=A.i, f=A.f))
+        self.assertEqual(A.class_traits(), dict(i=A.i, f=A.f))
 
     def test_traits_metadata(self):
         class A(HasTraits):
             i = Int(config_key='VALUE1', other_thing='VALUE2')
             f = Float(config_key='VALUE3', other_thing='VALUE2')
             j = Int(0)
         a = A()
-        self.assertEquals(a.traits(), dict(i=A.i, f=A.f, j=A.j))
+        self.assertEqual(a.traits(), dict(i=A.i, f=A.f, j=A.j))
         traits = a.traits(config_key='VALUE1', other_thing='VALUE2')
-        self.assertEquals(traits, dict(i=A.i))
+        self.assertEqual(traits, dict(i=A.i))
 
         # This passes, but it shouldn't because I am replicating a bug in
         # traits.
         traits = a.traits(config_key=lambda v: True)
-        self.assertEquals(traits, dict(i=A.i, f=A.f, j=A.j))
+        self.assertEqual(traits, dict(i=A.i, f=A.f, j=A.j))
 
     def test_init(self):
         class A(HasTraits):
             i = Int()
             x = Float()
         a = A(i=1, x=10.0)
-        self.assertEquals(a.i, 1)
-        self.assertEquals(a.x, 10.0)
+        self.assertEqual(a.i, 1)
+        self.assertEqual(a.x, 10.0)
 
 #-----------------------------------------------------------------------------
 # Tests for specific trait types
 #-----------------------------------------------------------------------------
 
 
 class TestType(TestCase):
 
     def test_default(self):
 
         class B(object): pass
         class A(HasTraits):
             klass = Type
 
         a = A()
-        self.assertEquals(a.klass, None)
+        self.assertEqual(a.klass, None)
 
         a.klass = B
-        self.assertEquals(a.klass, B)
+        self.assertEqual(a.klass, B)
         self.assertRaises(TraitError, setattr, a, 'klass', 10)
 
     def test_value(self):
 
         class B(object): pass
         class C(object): pass
         class A(HasTraits):
             klass = Type(B)
 
         a = A()
-        self.assertEquals(a.klass, B)
+        self.assertEqual(a.klass, B)
         self.assertRaises(TraitError, setattr, a, 'klass', C)
         self.assertRaises(TraitError, setattr, a, 'klass', object)
         a.klass = B
 
     def test_allow_none(self):
 
         class B(object): pass
         class C(B): pass
         class A(HasTraits):
             klass = Type(B, allow_none=False)
 
         a = A()
-        self.assertEquals(a.klass, B)
+        self.assertEqual(a.klass, B)
         self.assertRaises(TraitError, setattr, a, 'klass', None)
         a.klass = C
-        self.assertEquals(a.klass, C)
+        self.assertEqual(a.klass, C)
 
     def test_validate_klass(self):
 
         class A(HasTraits):
             klass = Type('no strings allowed')
 
         self.assertRaises(ImportError, A)
 
         class A(HasTraits):
             klass = Type('rub.adub.Duck')
 
         self.assertRaises(ImportError, A)
 
     def test_validate_default(self):
 
         class B(object): pass
         class A(HasTraits):
             klass = Type('bad default', B)
 
         self.assertRaises(ImportError, A)
 
         class C(HasTraits):
             klass = Type(None, B, allow_none=False)
 
         self.assertRaises(TraitError, C)
 
     def test_str_klass(self):
 
         class A(HasTraits):
             klass = Type('IPython.utils.ipstruct.Struct')
 
         from IPython.utils.ipstruct import Struct
         a = A()
         a.klass = Struct
-        self.assertEquals(a.klass, Struct)
+        self.assertEqual(a.klass, Struct)
 
         self.assertRaises(TraitError, setattr, a, 'klass', 10)
 
 class TestInstance(TestCase):
 
     def test_basic(self):
         class Foo(object): pass
         class Bar(Foo): pass
         class Bah(object): pass
 
         class A(HasTraits):
             inst = Instance(Foo)
 
         a = A()
         self.assert_(a.inst is None)
         a.inst = Foo()
         self.assert_(isinstance(a.inst, Foo))
         a.inst = Bar()
         self.assert_(isinstance(a.inst, Foo))
         self.assertRaises(TraitError, setattr, a, 'inst', Foo)
         self.assertRaises(TraitError, setattr, a, 'inst', Bar)
         self.assertRaises(TraitError, setattr, a, 'inst', Bah())
 
     def test_unique_default_value(self):
         class Foo(object): pass
         class A(HasTraits):
             inst = Instance(Foo,(),{})
 
         a = A()
         b = A()
         self.assert_(a.inst is not b.inst)
 
     def test_args_kw(self):
         class Foo(object):
             def __init__(self, c): self.c = c
         class Bar(object): pass
         class Bah(object):
             def __init__(self, c, d):
                 self.c = c; self.d = d
 
         class A(HasTraits):
             inst = Instance(Foo, (10,))
         a = A()
-        self.assertEquals(a.inst.c, 10)
+        self.assertEqual(a.inst.c, 10)
 
         class B(HasTraits):
             inst = Instance(Bah, args=(10,), kw=dict(d=20))
         b = B()
-        self.assertEquals(b.inst.c, 10)
-        self.assertEquals(b.inst.d, 20)
+        self.assertEqual(b.inst.c, 10)
+        self.assertEqual(b.inst.d, 20)
 
         class C(HasTraits):
             inst = Instance(Foo)
         c = C()
         self.assert_(c.inst is None)
 
     def test_bad_default(self):
         class Foo(object): pass
 
         class A(HasTraits):
             inst = Instance(Foo, allow_none=False)
 
         self.assertRaises(TraitError, A)
 
     def test_instance(self):
         class Foo(object): pass
 
         def inner():
             class A(HasTraits):
                 inst = Instance(Foo())
 
         self.assertRaises(TraitError, inner)
 
 
 class TestThis(TestCase):
 
     def test_this_class(self):
         class Foo(HasTraits):
             this = This
 
         f = Foo()
-        self.assertEquals(f.this, None)
+        self.assertEqual(f.this, None)
         g = Foo()
         f.this = g
-        self.assertEquals(f.this, g)
+        self.assertEqual(f.this, g)
         self.assertRaises(TraitError, setattr, f, 'this', 10)
 
     def test_this_inst(self):
         class Foo(HasTraits):
             this = This()
 
         f = Foo()
         f.this = Foo()
         self.assert_(isinstance(f.this, Foo))
 
     def test_subclass(self):
         class Foo(HasTraits):
             t = This()
         class Bar(Foo):
             pass
         f = Foo()
         b = Bar()
         f.t = b
         b.t = f
-        self.assertEquals(f.t, b)
-        self.assertEquals(b.t, f)
+        self.assertEqual(f.t, b)
+        self.assertEqual(b.t, f)
 
     def test_subclass_override(self):
         class Foo(HasTraits):
             t = This()
         class Bar(Foo):
             t = This()
         f = Foo()
         b = Bar()
         f.t = b
-        self.assertEquals(f.t, b)
+        self.assertEqual(f.t, b)
         self.assertRaises(TraitError, setattr, b, 't', f)
 
 class TraitTestBase(TestCase):
     """A best testing class for basic trait types."""
 
     def assign(self, value):
         self.obj.value = value
 
     def coerce(self, value):
         return value
 
     def test_good_values(self):
         if hasattr(self, '_good_values'):
             for value in self._good_values:
                 self.assign(value)
-                self.assertEquals(self.obj.value, self.coerce(value))
+                self.assertEqual(self.obj.value, self.coerce(value))
 
     def test_bad_values(self):
         if hasattr(self, '_bad_values'):
             for value in self._bad_values:
                 try:
                     self.assertRaises(TraitError, self.assign, value)
                 except AssertionError:
                     assert False, value
 
     def test_default_value(self):
         if hasattr(self, '_default_value'):
-            self.assertEquals(self._default_value, self.obj.value)
+            self.assertEqual(self._default_value, self.obj.value)
 
     def tearDown(self):
         # restore default value after tests, if set
         if hasattr(self, '_default_value'):
             self.obj.value = self._default_value
 
 
 class AnyTrait(HasTraits):
 
     value = Any
 
 class AnyTraitTest(TraitTestBase):
 
     obj = AnyTrait()
 
     _default_value = None
     _good_values   = [10.0, 'ten', u'ten', [10], {'ten': 10},(10,), None, 1j]
     _bad_values    = []
 
 
 class IntTrait(HasTraits):
 
     value = Int(99)
 
 class TestInt(TraitTestBase):
 
     obj = IntTrait()
     _default_value = 99
     _good_values   = [10, -10]
     _bad_values    = ['ten', u'ten', [10], {'ten': 10},(10,), None, 1j,
                       10.1, -10.1, '10L', '-10L', '10.1', '-10.1', u'10L',
                       u'-10L', u'10.1', u'-10.1',  '10', '-10', u'10', u'-10']
     if not py3compat.PY3:
         _bad_values.extend([10L, -10L, 10*sys.maxint, -10*sys.maxint])
 
 
 class LongTrait(HasTraits):
 
     value = Long(99L)
 
 class TestLong(TraitTestBase):
 
     obj = LongTrait()
 
     _default_value = 99L
     _good_values   = [10, -10, 10L, -10L]
     _bad_values    = ['ten', u'ten', [10], [10l], {'ten': 10},(10,),(10L,),
                       None, 1j, 10.1, -10.1, '10', '-10', '10L', '-10L', '10.1',
                       '-10.1', u'10', u'-10', u'10L', u'-10L', u'10.1',
                       u'-10.1']
     if not py3compat.PY3:
         # maxint undefined on py3, because int == long
         _good_values.extend([10*sys.maxint, -10*sys.maxint])
 
     @skipif(py3compat.PY3, "not relevant on py3")
     def test_cast_small(self):
         """Long casts ints to long"""
         self.obj.value = 10
-        self.assertEquals(type(self.obj.value), long)
+        self.assertEqual(type(self.obj.value), long)
 
 
 class IntegerTrait(HasTraits):
     value = Integer(1)
 
 class TestInteger(TestLong):
     obj = IntegerTrait()
     _default_value = 1
 
     def coerce(self, n):
         return int(n)
 
     @skipif(py3compat.PY3, "not relevant on py3")
     def test_cast_small(self):
         """Integer casts small longs to int"""
         if py3compat.PY3:
             raise SkipTest("not relevant on py3")
 
         self.obj.value = 100L
-        self.assertEquals(type(self.obj.value), int)
+        self.assertEqual(type(self.obj.value), int)
 
 
 class FloatTrait(HasTraits):
 
     value = Float(99.0)
 
 class TestFloat(TraitTestBase):
 
     obj = FloatTrait()
 
     _default_value = 99.0
     _good_values   = [10, -10, 10.1, -10.1]
     _bad_values    = ['ten', u'ten', [10], {'ten': 10},(10,), None,
                       1j, '10', '-10', '10L', '-10L', '10.1', '-10.1', u'10',
                       u'-10', u'10L', u'-10L', u'10.1', u'-10.1']
     if not py3compat.PY3:
         _bad_values.extend([10L, -10L])
 
 
 class ComplexTrait(HasTraits):
 
     value = Complex(99.0-99.0j)
 
 class TestComplex(TraitTestBase):
 
     obj = ComplexTrait()
 
     _default_value = 99.0-99.0j
     _good_values   = [10, -10, 10.1, -10.1, 10j, 10+10j, 10-10j,
                       10.1j, 10.1+10.1j, 10.1-10.1j]
     _bad_values    = [u'10L', u'-10L', 'ten', [10], {'ten': 10},(10,), None]
     if not py3compat.PY3:
         _bad_values.extend([10L, -10L])
 
 
 class BytesTrait(HasTraits):
 
     value = Bytes(b'string')
 
 class TestBytes(TraitTestBase):
 
     obj = BytesTrait()
 
     _default_value = b'string'
     _good_values   = [b'10', b'-10', b'10L',
                       b'-10L', b'10.1', b'-10.1', b'string']
     _bad_values    = [10, -10, 10L, -10L, 10.1, -10.1, 1j, [10],
                       ['ten'],{'ten': 10},(10,), None,  u'string']
 
 
 class UnicodeTrait(HasTraits):
 
     value = Unicode(u'unicode')
 
 class TestUnicode(TraitTestBase):
 
     obj = UnicodeTrait()
 
     _default_value = u'unicode'
     _good_values   = ['10', '-10', '10L', '-10L', '10.1',
                       '-10.1', '', u'', 'string', u'string', u"€"]
     _bad_values    = [10, -10, 10L, -10L, 10.1, -10.1, 1j,
                       [10], ['ten'], [u'ten'], {'ten': 10},(10,), None]
 
 
 class ObjectNameTrait(HasTraits):
     value = ObjectName("abc")
 
 class TestObjectName(TraitTestBase):
     obj = ObjectNameTrait()
 
     _default_value = "abc"
     _good_values = ["a", "gh", "g9", "g_", "_G", u"a345_"]
     _bad_values = [1, "", u"€", "9g", "!", "#abc", "aj@", "a.b", "a()", "a[0]",
                                                             object(), object]
     if sys.version_info[0] < 3:
         _bad_values.append(u"þ")
     else:
         _good_values.append(u"þ")  # þ=1 is valid in Python 3 (PEP 3131).
 
 
 class DottedObjectNameTrait(HasTraits):
     value = DottedObjectName("a.b")
 
 class TestDottedObjectName(TraitTestBase):
     obj = DottedObjectNameTrait()
 
     _default_value = "a.b"
     _good_values = ["A", "y.t", "y765.__repr__", "os.path.join", u"os.path.join"]
     _bad_values = [1, u"abc.€", "_.@", ".", ".abc", "abc.", ".abc."]
     if sys.version_info[0] < 3:
         _bad_values.append(u"t.þ")
     else:
         _good_values.append(u"t.þ")
 
 
 class TCPAddressTrait(HasTraits):
 
     value = TCPAddress()
 
 class TestTCPAddress(TraitTestBase):
 
     obj = TCPAddressTrait()
 
     _default_value = ('127.0.0.1',0)
     _good_values = [('localhost',0),('192.168.0.1',1000),('www.google.com',80)]
     _bad_values = [(0,0),('localhost',10.0),('localhost',-1)]
 
 class ListTrait(HasTraits):
 
     value = List(Int)
 
 class TestList(TraitTestBase):
 
     obj = ListTrait()
 
     _default_value = []
     _good_values = [[], [1], range(10)]
     _bad_values = [10, [1,'a'], 'a', (1,2)]
 
 class LenListTrait(HasTraits):
 
     value = List(Int, [0], minlen=1, maxlen=2)
 
 class TestLenList(TraitTestBase):
 
     obj = LenListTrait()
 
     _default_value = [0]
     _good_values = [[1], range(2)]
     _bad_values = [10, [1,'a'], 'a', (1,2), [], range(3)]
 
 class TupleTrait(HasTraits):
 
     value = Tuple(Int)
 
 class TestTupleTrait(TraitTestBase):
 
     obj = TupleTrait()
 
     _default_value = None
     _good_values = [(1,), None,(0,)]
     _bad_values = [10, (1,2), [1],('a'), ()]
 
     def test_invalid_args(self):
         self.assertRaises(TypeError, Tuple, 5)
         self.assertRaises(TypeError, Tuple, default_value='hello')
         t = Tuple(Int, CBytes, default_value=(1,5))
 
 class LooseTupleTrait(HasTraits):
 
     value = Tuple((1,2,3))
 
 class TestLooseTupleTrait(TraitTestBase):
 
     obj = LooseTupleTrait()
 
     _default_value = (1,2,3)
     _good_values = [(1,), None, (0,), tuple(range(5)), tuple('hello'), ('a',5), ()]
     _bad_values = [10, 'hello', [1], []]
 
     def test_invalid_args(self):
         self.assertRaises(TypeError, Tuple, 5)
         self.assertRaises(TypeError, Tuple, default_value='hello')
         t = Tuple(Int, CBytes, default_value=(1,5))
 
 
 class MultiTupleTrait(HasTraits):
 
     value = Tuple(Int, Bytes, default_value=[99,b'bottles'])
 
 class TestMultiTuple(TraitTestBase):
 
     obj = MultiTupleTrait()
 
     _default_value = (99,b'bottles')
     _good_values = [(1,b'a'), (2,b'b')]
     _bad_values = ((),10, b'a', (1,b'a',3), (b'a',1), (1, u'a'))
 
 class CRegExpTrait(HasTraits):
 
     value = CRegExp(r'')
 
 class TestCRegExp(TraitTestBase):
 
     def coerce(self, value):
         return re.compile(value)
 
     obj = CRegExpTrait()
 
     _default_value = re.compile(r'')
     _good_values = [r'\d+', re.compile(r'\d+')]
     _bad_values = [r'(', None, ()]

IPython/zmq/tests/test_session.py

@@ -1,212 +1,212 b''
 """test building messages with streamsession"""
 
 #-------------------------------------------------------------------------------
 #  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 uuid
 import zmq
 
 from zmq.tests import BaseZMQTestCase
 from zmq.eventloop.zmqstream import ZMQStream
 
 from IPython.zmq import session as ss
 
 class SessionTestCase(BaseZMQTestCase):
 
     def setUp(self):
         BaseZMQTestCase.setUp(self)
         self.session = ss.Session()
 
 
 class MockSocket(zmq.Socket):
 
     def __init__(self, *args, **kwargs):
         super(MockSocket,self).__init__(*args,**kwargs)
         self.data = []
 
     def send_multipart(self, msgparts, *args, **kwargs):
         self.data.extend(msgparts)
 
     def send(self, part, *args, **kwargs):
         self.data.append(part)
 
     def recv_multipart(self, *args, **kwargs):
         return self.data
 
 class TestSession(SessionTestCase):
 
     def test_msg(self):
         """message format"""
         msg = self.session.msg('execute')
         thekeys = set('header parent_header content msg_type msg_id'.split())
         s = set(msg.keys())
-        self.assertEquals(s, thekeys)
+        self.assertEqual(s, thekeys)
         self.assertTrue(isinstance(msg['content'],dict))
         self.assertTrue(isinstance(msg['header'],dict))
         self.assertTrue(isinstance(msg['parent_header'],dict))
         self.assertTrue(isinstance(msg['msg_id'],str))
         self.assertTrue(isinstance(msg['msg_type'],str))
-        self.assertEquals(msg['header']['msg_type'], 'execute')
-        self.assertEquals(msg['msg_type'], 'execute')
+        self.assertEqual(msg['header']['msg_type'], 'execute')
+        self.assertEqual(msg['msg_type'], 'execute')
 
     def test_serialize(self):
         msg = self.session.msg('execute', content=dict(a=10, b=1.1))
         msg_list = self.session.serialize(msg, ident=b'foo')
         ident, msg_list = self.session.feed_identities(msg_list)
         new_msg = self.session.unserialize(msg_list)
-        self.assertEquals(ident[0], b'foo')
-        self.assertEquals(new_msg['msg_id'],msg['msg_id'])
-        self.assertEquals(new_msg['msg_type'],msg['msg_type'])
-        self.assertEquals(new_msg['header'],msg['header'])
-        self.assertEquals(new_msg['content'],msg['content'])
-        self.assertEquals(new_msg['parent_header'],msg['parent_header'])
+        self.assertEqual(ident[0], b'foo')
+        self.assertEqual(new_msg['msg_id'],msg['msg_id'])
+        self.assertEqual(new_msg['msg_type'],msg['msg_type'])
+        self.assertEqual(new_msg['header'],msg['header'])
+        self.assertEqual(new_msg['content'],msg['content'])
+        self.assertEqual(new_msg['parent_header'],msg['parent_header'])
         # ensure floats don't come out as Decimal:
-        self.assertEquals(type(new_msg['content']['b']),type(new_msg['content']['b']))
+        self.assertEqual(type(new_msg['content']['b']),type(new_msg['content']['b']))
 
     def test_send(self):
         socket = MockSocket(zmq.Context.instance(),zmq.PAIR)
 
         msg = self.session.msg('execute', content=dict(a=10))
         self.session.send(socket, msg, ident=b'foo', buffers=[b'bar'])
         ident, msg_list = self.session.feed_identities(socket.data)
         new_msg = self.session.unserialize(msg_list)
-        self.assertEquals(ident[0], b'foo')
-        self.assertEquals(new_msg['msg_id'],msg['msg_id'])
-        self.assertEquals(new_msg['msg_type'],msg['msg_type'])
-        self.assertEquals(new_msg['header'],msg['header'])
-        self.assertEquals(new_msg['content'],msg['content'])
-        self.assertEquals(new_msg['parent_header'],msg['parent_header'])
-        self.assertEquals(new_msg['buffers'],[b'bar'])
+        self.assertEqual(ident[0], b'foo')
+        self.assertEqual(new_msg['msg_id'],msg['msg_id'])
+        self.assertEqual(new_msg['msg_type'],msg['msg_type'])
+        self.assertEqual(new_msg['header'],msg['header'])
+        self.assertEqual(new_msg['content'],msg['content'])
+        self.assertEqual(new_msg['parent_header'],msg['parent_header'])
+        self.assertEqual(new_msg['buffers'],[b'bar'])
 
         socket.data = []
 
         content = msg['content']
         header = msg['header']
         parent = msg['parent_header']
         msg_type = header['msg_type']
         self.session.send(socket, None, content=content, parent=parent,
             header=header, ident=b'foo', buffers=[b'bar'])
         ident, msg_list = self.session.feed_identities(socket.data)
         new_msg = self.session.unserialize(msg_list)
-        self.assertEquals(ident[0], b'foo')
-        self.assertEquals(new_msg['msg_id'],msg['msg_id'])
-        self.assertEquals(new_msg['msg_type'],msg['msg_type'])
-        self.assertEquals(new_msg['header'],msg['header'])
-        self.assertEquals(new_msg['content'],msg['content'])
-        self.assertEquals(new_msg['parent_header'],msg['parent_header'])
-        self.assertEquals(new_msg['buffers'],[b'bar'])
+        self.assertEqual(ident[0], b'foo')
+        self.assertEqual(new_msg['msg_id'],msg['msg_id'])
+        self.assertEqual(new_msg['msg_type'],msg['msg_type'])
+        self.assertEqual(new_msg['header'],msg['header'])
+        self.assertEqual(new_msg['content'],msg['content'])
+        self.assertEqual(new_msg['parent_header'],msg['parent_header'])
+        self.assertEqual(new_msg['buffers'],[b'bar'])
 
         socket.data = []
 
         self.session.send(socket, msg, ident=b'foo', buffers=[b'bar'])
         ident, new_msg = self.session.recv(socket)
-        self.assertEquals(ident[0], b'foo')
-        self.assertEquals(new_msg['msg_id'],msg['msg_id'])
-        self.assertEquals(new_msg['msg_type'],msg['msg_type'])
-        self.assertEquals(new_msg['header'],msg['header'])
-        self.assertEquals(new_msg['content'],msg['content'])
-        self.assertEquals(new_msg['parent_header'],msg['parent_header'])
-        self.assertEquals(new_msg['buffers'],[b'bar'])
+        self.assertEqual(ident[0], b'foo')
+        self.assertEqual(new_msg['msg_id'],msg['msg_id'])
+        self.assertEqual(new_msg['msg_type'],msg['msg_type'])
+        self.assertEqual(new_msg['header'],msg['header'])
+        self.assertEqual(new_msg['content'],msg['content'])
+        self.assertEqual(new_msg['parent_header'],msg['parent_header'])
+        self.assertEqual(new_msg['buffers'],[b'bar'])
 
         socket.close()
 
     def test_args(self):
         """initialization arguments for Session"""
         s = self.session
         self.assertTrue(s.pack is ss.default_packer)
         self.assertTrue(s.unpack is ss.default_unpacker)
-        self.assertEquals(s.username, os.environ.get('USER', u'username'))
+        self.assertEqual(s.username, os.environ.get('USER', u'username'))
 
         s = ss.Session()
-        self.assertEquals(s.username, os.environ.get('USER', u'username'))
+        self.assertEqual(s.username, os.environ.get('USER', u'username'))
 
         self.assertRaises(TypeError, ss.Session, pack='hi')
         self.assertRaises(TypeError, ss.Session, unpack='hi')
         u = str(uuid.uuid4())
         s = ss.Session(username=u'carrot', session=u)
-        self.assertEquals(s.session, u)
-        self.assertEquals(s.username, u'carrot')
+        self.assertEqual(s.session, u)
+        self.assertEqual(s.username, u'carrot')
 
     def test_tracking(self):
         """test tracking messages"""
         a,b = self.create_bound_pair(zmq.PAIR, zmq.PAIR)
         s = self.session
         stream = ZMQStream(a)
         msg = s.send(a, 'hello', track=False)
         self.assertTrue(msg['tracker'] is None)
         msg = s.send(a, 'hello', track=True)
         self.assertTrue(isinstance(msg['tracker'], zmq.MessageTracker))
         M = zmq.Message(b'hi there', track=True)
         msg = s.send(a, 'hello', buffers=[M], track=True)
         t = msg['tracker']
         self.assertTrue(isinstance(t, zmq.MessageTracker))
         self.assertRaises(zmq.NotDone, t.wait, .1)
         del M
         t.wait(1) # this will raise
 
 
     # def test_rekey(self):
     #     """rekeying dict around json str keys"""
     #     d = {'0': uuid.uuid4(), 0:uuid.uuid4()}
     #     self.assertRaises(KeyError, ss.rekey, d)
     #
     #     d = {'0': uuid.uuid4(), 1:uuid.uuid4(), 'asdf':uuid.uuid4()}
     #     d2 = {0:d['0'],1:d[1],'asdf':d['asdf']}
     #     rd = ss.rekey(d)
-    #     self.assertEquals(d2,rd)
+    #     self.assertEqual(d2,rd)
     #
     #     d = {'1.5':uuid.uuid4(),'1':uuid.uuid4()}
     #     d2 = {1.5:d['1.5'],1:d['1']}
     #     rd = ss.rekey(d)
-    #     self.assertEquals(d2,rd)
+    #     self.assertEqual(d2,rd)
     #
     #     d = {'1.0':uuid.uuid4(),'1':uuid.uuid4()}
     #     self.assertRaises(KeyError, ss.rekey, d)
     #
     def test_unique_msg_ids(self):
         """test that messages receive unique ids"""
         ids = set()
         for i in range(2**12):
             h = self.session.msg_header('test')
             msg_id = h['msg_id']
             self.assertTrue(msg_id not in ids)
             ids.add(msg_id)
 
     def test_feed_identities(self):
         """scrub the front for zmq IDENTITIES"""
         theids = "engine client other".split()
         content = dict(code='whoda',stuff=object())
         themsg = self.session.msg('execute',content=content)
         pmsg = theids
 
     def test_session_id(self):
         session = ss.Session()
         # get bs before us
         bs = session.bsession
         us = session.session
-        self.assertEquals(us.encode('ascii'), bs)
+        self.assertEqual(us.encode('ascii'), bs)
         session = ss.Session()
         # get us before bs
         us = session.session
         bs = session.bsession
-        self.assertEquals(us.encode('ascii'), bs)
+        self.assertEqual(us.encode('ascii'), bs)
         # change propagates:
         session.session = 'something else'
         bs = session.bsession
         us = session.session
-        self.assertEquals(us.encode('ascii'), bs)
+        self.assertEqual(us.encode('ascii'), bs)
         session = ss.Session(session='stuff')
         # get us before bs
-        self.assertEquals(session.bsession, session.session.encode('ascii'))
-        self.assertEquals(b'stuff', session.bsession)
+        self.assertEqual(session.bsession, session.session.encode('ascii'))
+        self.assertEqual(b'stuff', session.bsession)