s/assertEquals/assertEqual/

IPython/config/tests/test_application.py

@@ -82,94 +82,94 b' 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

@@ -83,8 +83,8 b' class TestConfigurable(TestCase):'
         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()
@@ -93,9 +93,9 b' class TestConfigurable(TestCase):'
         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)
@@ -109,10 +109,10 b' class TestConfigurable(TestCase):'
         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()
@@ -122,19 +122,19 b' class TestConfigurable(TestCase):'
         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()
@@ -142,20 +142,20 b' class TestConfigurable(TestCase):'
         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):
@@ -163,21 +163,21 b' 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

@@ -63,11 +63,11 b' class TestPyFileCL(TestCase):'
         # 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):
@@ -90,31 +90,31 b' 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):
@@ -125,39 +125,39 b' class TestKeyValueCL(TestCase):'
         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=é'
@@ -169,14 +169,14 b' class TestKeyValueCL(TestCase):'
         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):
@@ -187,15 +187,15 b' class TestArgParseKVCL(TestKeyValueCL):'
         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):
@@ -203,19 +203,19 b' 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()
@@ -223,11 +223,11 b' class TestConfig(TestCase):'
         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()
@@ -237,12 +237,12 b' class TestConfig(TestCase):'
         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()
@@ -252,12 +252,12 b' class TestConfig(TestCase):'
         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

@@ -50,17 +50,17 b' class InteractiveShellTestCase(unittest.TestCase):'
         """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.
@@ -71,38 +71,38 b' class InteractiveShellTestCase(unittest.TestCase):'
                          "    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"""
@@ -113,7 +113,7 b' class InteractiveShellTestCase(unittest.TestCase):'
         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"""
@@ -192,9 +192,9 b' class InteractiveShellTestCase(unittest.TestCase):'
             # 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
@@ -207,9 +207,9 b' class InteractiveShellTestCase(unittest.TestCase):'
             # 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
@@ -288,11 +288,11 b' class InteractiveShellTestCase(unittest.TestCase):'
         # 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"""

IPython/core/tests/test_plugin.py

@@ -30,10 +30,10 b' class PluginTest(TestCase):'
         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()
@@ -43,4 +43,4 b' class PluginTest(TestCase):'
         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

@@ -47,19 +47,19 b' class PromptTests(unittest.TestCase):'
         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'\#>'
@@ -71,32 +71,32 b' class PromptTests(unittest.TestCase):'
             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):
@@ -105,7 +105,7 b' class PromptTests(unittest.TestCase):'
         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

@@ -10,12 +10,12 b' class TestKernelManager(TestCase):'
         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)

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

@@ -14,13 +14,13 b' 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:

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

@@ -17,20 +17,20 b' class TestAnsiCodeProcessor(unittest.TestCase):'
         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?
@@ -39,17 +39,17 b' class TestAnsiCodeProcessor(unittest.TestCase):'
         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?
@@ -59,12 +59,12 b' class TestAnsiCodeProcessor(unittest.TestCase):'
         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?
@@ -73,34 +73,34 b' class TestAnsiCodeProcessor(unittest.TestCase):'
         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?
@@ -111,8 +111,8 b' class TestAnsiCodeProcessor(unittest.TestCase):'
         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"""
@@ -123,8 +123,8 b' class TestAnsiCodeProcessor(unittest.TestCase):'
         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?
@@ -135,8 +135,8 b' class TestAnsiCodeProcessor(unittest.TestCase):'
         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?
@@ -147,8 +147,8 b' class TestAnsiCodeProcessor(unittest.TestCase):'
         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?
@@ -163,8 +163,8 b' class TestAnsiCodeProcessor(unittest.TestCase):'
         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__':

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

@@ -16,31 +16,31 b' class TestCompletionLexer(unittest.TestCase):'
         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__':

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

@@ -37,6 +37,6 b' class TestConsoleWidget(unittest.TestCase):'
             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

@@ -59,10 +59,10 b' class InteractiveShellTestCase(unittest.TestCase):'
         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'),
@@ -74,7 +74,7 b' class InteractiveShellTestCase(unittest.TestCase):'
         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')
@@ -95,10 +95,10 b' class InteractiveShellTestCase(unittest.TestCase):'
         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')
@@ -123,14 +123,14 b' class InteractiveShellTestCase(unittest.TestCase):'
         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')
@@ -160,7 +160,7 b' class InteractiveShellTestCase(unittest.TestCase):'
         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
@@ -168,4 +168,4 b' class InteractiveShellTestCase(unittest.TestCase):'
         # 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

@@ -8,7 +8,7 b' 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

@@ -9,33 +9,33 b' 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

@@ -15,20 +15,20 b' class TestJSON(TestCase):'
 #        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

@@ -10,104 +10,104 b' 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

@@ -13,5 +13,5 b' 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

@@ -33,12 +33,12 b' class NBFormatTest:'
         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)

IPython/nbformat/v3/tests/test_json.py

@@ -21,13 +21,13 b' class TestJSON(formattest.NBFormatTest, TestCase):'
         # 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

@@ -10,134 +10,134 b' 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

@@ -36,7 +36,7 b' class TestPy(formattest.NBFormatTest, TestCase):'
                 # 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):

IPython/parallel/tests/clienttest.py

@@ -142,7 +142,7 b' class ClusterTestCase(BaseZMQTestCase):'
             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")
             

IPython/parallel/tests/test_asyncresult.py

@@ -39,25 +39,25 b' class AsyncResultTest(ClusterTestCase):'
         """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)
@@ -69,11 +69,11 b' class AsyncResultTest(ClusterTestCase):'
     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)
@@ -93,7 +93,7 b' class AsyncResultTest(ClusterTestCase):'
         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'))
@@ -105,7 +105,7 b' class AsyncResultTest(ClusterTestCase):'
         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)
@@ -114,7 +114,7 b' class AsyncResultTest(ClusterTestCase):'
         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]
@@ -127,11 +127,11 b' class AsyncResultTest(ClusterTestCase):'
     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()
@@ -199,7 +199,7 b' class AsyncResultTest(ClusterTestCase):'
             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()
 
@@ -212,15 +212,15 b' class AsyncResultTest(ClusterTestCase):'
         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)"""
@@ -231,17 +231,17 b' class AsyncResultTest(ClusterTestCase):'
         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)"""
@@ -252,16 +252,16 b' class AsyncResultTest(ClusterTestCase):'
         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

@@ -40,58 +40,58 b' 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
@@ -104,11 +104,11 b' class TestClient(ClusterTestCase):'
         
         # 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)
@@ -117,18 +117,18 b' class TestClient(ClusterTestCase):'
         
         # 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"""
@@ -154,7 +154,7 b' class TestClient(ClusterTestCase):'
         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()
@@ -173,7 +173,7 b' class TestClient(ClusterTestCase):'
         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()
@@ -181,7 +181,7 b' class TestClient(ClusterTestCase):'
     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)
@@ -191,16 +191,16 b' class TestClient(ClusterTestCase):'
         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
@@ -223,7 +223,7 b' class TestClient(ClusterTestCase):'
         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:
@@ -236,7 +236,7 b' class TestClient(ClusterTestCase):'
         """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"""
@@ -277,10 +277,10 b' class TestClient(ClusterTestCase):'
         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()
@@ -298,7 +298,7 b' class TestClient(ClusterTestCase):'
         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"""
@@ -314,9 +314,9 b' class TestClient(ClusterTestCase):'
                 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):
@@ -366,7 +366,7 b' class TestClient(ClusterTestCase):'
             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():
@@ -414,14 +414,14 b' class TestClient(ClusterTestCase):'
         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)
@@ -448,8 +448,8 b' class TestClient(ClusterTestCase):'
         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

@@ -72,8 +72,8 b' class TestDictBackend(TestCase):'
         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]
@@ -95,10 +95,10 b' class TestDictBackend(TestCase):'
         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"""
@@ -113,7 +113,7 b' class TestDictBackend(TestCase):'
         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:
@@ -126,7 +126,7 b' class TestDictBackend(TestCase):'
         """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"""
@@ -147,10 +147,10 b' class TestDictBackend(TestCase):'
         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()
@@ -161,7 +161,7 b' class TestDictBackend(TestCase):'
             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"""
@@ -177,7 +177,7 b' class TestDictBackend(TestCase):'
         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"""
@@ -185,7 +185,7 b' class TestDictBackend(TestCase):'
 
         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)
@@ -201,7 +201,7 b' class TestDictBackend(TestCase):'
         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]"""
@@ -213,7 +213,7 b' class TestDictBackend(TestCase):'
         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]"""
@@ -225,7 +225,7 b' class TestDictBackend(TestCase):'
         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):

IPython/parallel/tests/test_dependency.py

@@ -75,7 +75,7 b' class DependencyTest(ClusterTestCase):'
         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)

IPython/parallel/tests/test_lbview.py

@@ -56,7 +56,7 b' class TestLoadBalancedView(ClusterTestCase):'
             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):
@@ -75,7 +75,7 b' class TestLoadBalancedView(ClusterTestCase):'
         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):
@@ -93,8 +93,8 b' class TestLoadBalancedView(ClusterTestCase):'
         # 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)"""
@@ -104,7 +104,7 b' class TestLoadBalancedView(ClusterTestCase):'
         # 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):
@@ -163,7 +163,7 b' class TestLoadBalancedView(ClusterTestCase):'
             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

IPython/parallel/tests/test_magics.py

@@ -48,9 +48,9 b' class TestParallelMagics(ClusterTestCase, ParametricTestCase):'
         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:
@@ -72,7 +72,7 b' class TestParallelMagics(ClusterTestCase, ParametricTestCase):'
         
         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]
@@ -128,7 +128,7 b' class TestParallelMagics(ClusterTestCase, ParametricTestCase):'
             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]
@@ -170,7 +170,7 b' class TestParallelMagics(ClusterTestCase, ParametricTestCase):'
             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]
@@ -209,7 +209,7 b' class TestParallelMagics(ClusterTestCase, ParametricTestCase):'
             (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]
@@ -226,9 +226,9 b' class TestParallelMagics(ClusterTestCase, ParametricTestCase):'
         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)')
@@ -263,8 +263,8 b' class TestParallelMagics(ClusterTestCase, ParametricTestCase):'
         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):
@@ -291,9 +291,9 b' class TestParallelMagics(ClusterTestCase, ParametricTestCase):'
         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()
@@ -335,26 +335,26 b' class TestParallelMagics(ClusterTestCase, ParametricTestCase):'
         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:
@@ -363,7 +363,7 b' class TestParallelMagics(ClusterTestCase, ParametricTestCase):'
                 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):
@@ -372,7 +372,7 b' class TestParallelMagics(ClusterTestCase, ParametricTestCase):'
         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:

IPython/parallel/tests/test_newserialized.py

@@ -60,7 +60,7 b' class CanningTestCase(TestCase):'
         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}
@@ -69,16 +69,16 b' class CanningTestCase(TestCase):'
         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):
@@ -87,18 +87,18 b' class CanningTestCase(TestCase):'
         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())

IPython/parallel/tests/test_view.py

@@ -75,20 +75,20 b' class TestView(ClusterTestCase, ParametricTestCase):'
         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"
@@ -106,7 +106,7 b' class TestView(ClusterTestCase, ParametricTestCase):'
         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)
@@ -115,7 +115,7 b' class TestView(ClusterTestCase, ParametricTestCase):'
             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"""
@@ -129,7 +129,7 b' class TestView(ClusterTestCase, ParametricTestCase):'
         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"""
@@ -139,7 +139,7 b' class TestView(ClusterTestCase, ParametricTestCase):'
         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."""
@@ -153,7 +153,7 b' class TestView(ClusterTestCase, ParametricTestCase):'
         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()
@@ -168,7 +168,7 b' class TestView(ClusterTestCase, ParametricTestCase):'
                 """)
         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"""
@@ -184,7 +184,7 b' class TestView(ClusterTestCase, ParametricTestCase):'
         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)
         
@@ -199,7 +199,7 b' class TestView(ClusterTestCase, ParametricTestCase):'
         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()
         
@@ -212,7 +212,7 b' class TestView(ClusterTestCase, ParametricTestCase):'
         
         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()
@@ -222,7 +222,7 b' class TestView(ClusterTestCase, ParametricTestCase):'
         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):
@@ -230,7 +230,7 b' class TestView(ClusterTestCase, ParametricTestCase):'
         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')
@@ -249,7 +249,7 b' class TestView(ClusterTestCase, ParametricTestCase):'
         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
@@ -301,10 +301,10 b' class TestView(ClusterTestCase, ParametricTestCase):'
         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):
@@ -313,7 +313,7 b' class TestView(ClusterTestCase, ParametricTestCase):'
             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)"""
@@ -323,14 +323,14 b' class TestView(ClusterTestCase, ParametricTestCase):'
         # 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):
@@ -352,9 +352,9 b' class TestView(ClusterTestCase, ParametricTestCase):'
         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]
@@ -396,7 +396,7 b' class TestView(ClusterTestCase, ParametricTestCase):'
             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"""
@@ -407,13 +407,13 b' class TestView(ClusterTestCase, ParametricTestCase):'
         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"""
@@ -444,7 +444,7 b' class TestView(ClusterTestCase, ParametricTestCase):'
         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"""
@@ -454,14 +454,14 b' class TestView(ClusterTestCase, ParametricTestCase):'
         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]]
@@ -474,22 +474,22 b' class TestView(ClusterTestCase, ParametricTestCase):'
         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()
 
@@ -501,15 +501,15 b' class TestView(ClusterTestCase, ParametricTestCase):'
         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"""
@@ -518,14 +518,14 b' class TestView(ClusterTestCase, ParametricTestCase):'
         
         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"""
@@ -536,7 +536,7 b' class TestView(ClusterTestCase, ParametricTestCase):'
         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()
@@ -554,7 +554,7 b' class TestView(ClusterTestCase, ParametricTestCase):'
         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"""
@@ -570,7 +570,7 b' class TestView(ClusterTestCase, ParametricTestCase):'
         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"""
@@ -588,7 +588,7 b' class TestView(ClusterTestCase, ParametricTestCase):'
         # 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']

IPython/utils/tests/test_process.py

@@ -103,29 +103,29 b' class SubProcessTestCase(TestCase, tt.TempFileMixin):'
 
     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

@@ -60,7 +60,7 b' class TestTraitType(TestCase):'
         class A(HasTraits):
             a = TraitType
         a = A()
-        self.assertEquals(a.a, Undefined)
+        self.assertEqual(a.a, Undefined)
 
     def test_set(self):
         class A(HasTraitsStub):
@@ -68,10 +68,10 b' class TestTraitType(TestCase):'
 
         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):
@@ -82,7 +82,7 b' class TestTraitType(TestCase):'
 
         a = A()
         a.tt = 10
-        self.assertEquals(a.tt, -1)
+        self.assertEqual(a.tt, -1)
 
     def test_default_validate(self):
         class MyIntTT(TraitType):
@@ -93,7 +93,7 b' class TestTraitType(TestCase):'
         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):
@@ -109,7 +109,7 b' class TestTraitType(TestCase):'
 
         a = A()
         a.tt = 10
-        self.assertEquals(a.tt, 10)
+        self.assertEqual(a.tt, 10)
 
     def test_value_for(self):
         class MyTT(TraitType):
@@ -120,13 +120,13 b' class TestTraitType(TestCase):'
 
         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):
@@ -146,59 +146,59 b' class TestTraitType(TestCase):'
                 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):
@@ -207,10 +207,10 b' class TestHasTraitsMeta(TestCase):'
         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):
 
@@ -233,9 +233,9 b' class TestHasTraitsNotify(TestCase):'
         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
@@ -246,7 +246,7 b' class TestHasTraitsNotify(TestCase):'
         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):
 
@@ -257,7 +257,7 b' class TestHasTraitsNotify(TestCase):'
         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')
@@ -271,12 +271,12 b' class TestHasTraitsNotify(TestCase):'
             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):
 
@@ -291,8 +291,8 b' class TestHasTraitsNotify(TestCase):'
         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)
@@ -309,7 +309,7 b' class TestHasTraitsNotify(TestCase):'
         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)
 
@@ -342,25 +342,25 b' class TestHasTraitsNotify(TestCase):'
         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):
@@ -370,22 +370,22 b' class TestHasTraits(TestCase):'
             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):
@@ -393,22 +393,22 b' class TestHasTraits(TestCase):'
             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
@@ -424,10 +424,10 b' class TestType(TestCase):'
             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):
@@ -438,7 +438,7 b' class TestType(TestCase):'
             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
@@ -451,10 +451,10 b' class TestType(TestCase):'
             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):
 
@@ -489,7 +489,7 b' class TestType(TestCase):'
         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)
 
@@ -533,13 +533,13 b' class TestInstance(TestCase):'
         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)
@@ -571,10 +571,10 b' class TestThis(TestCase):'
             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):
@@ -594,8 +594,8 b' class TestThis(TestCase):'
         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):
@@ -605,7 +605,7 b' class TestThis(TestCase):'
         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):
@@ -621,7 +621,7 b' class TraitTestBase(TestCase):'
         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'):
@@ -633,7 +633,7 b' class TraitTestBase(TestCase):'
 
     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
@@ -692,7 +692,7 b' class TestLong(TraitTestBase):'
     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):
@@ -712,7 +712,7 b' class TestInteger(TestLong):'
             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):

IPython/zmq/tests/test_session.py

@@ -49,28 +49,28 b' class TestSession(SessionTestCase):'
         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)
@@ -79,13 +79,13 b' class TestSession(SessionTestCase):'
         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 = []
 
@@ -97,25 +97,25 b' class TestSession(SessionTestCase):'
             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()
 
@@ -124,17 +124,17 b' class TestSession(SessionTestCase):'
         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"""
@@ -162,12 +162,12 b' class TestSession(SessionTestCase):'
     #     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)
@@ -193,20 +193,20 b' class TestSession(SessionTestCase):'
         # 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)