diff options
| author | Ezio Melotti <ezio.melotti@gmail.com> | 2010-11-20 19:04:17 (GMT) |
|---|---|---|
| committer | Ezio Melotti <ezio.melotti@gmail.com> | 2010-11-20 19:04:17 (GMT) |
| commit | b3aedd48621ed9d33b5f42f946b256bce4a50673 (patch) | |
| tree | 2297c8ebce1b09621e1d98096c1603896d9a0f0c /Lib | |
| parent | b8bc439b2093add9b313bcca2cc507a2d0e87764 (diff) | |
| download | cpython-b3aedd48621ed9d33b5f42f946b256bce4a50673.zip cpython-b3aedd48621ed9d33b5f42f946b256bce4a50673.tar.gz cpython-b3aedd48621ed9d33b5f42f946b256bce4a50673.tar.bz2 | |
#9424: Replace deprecated assert* methods in the Python test suite.
Diffstat (limited to 'Lib')
169 files changed, 2389 insertions, 2395 deletions
diff --git a/Lib/ctypes/test/test_keeprefs.py b/Lib/ctypes/test/test_keeprefs.py index ef3e6eb..db8adfb 100644 --- a/Lib/ctypes/test/test_keeprefs.py +++ b/Lib/ctypes/test/test_keeprefs.py @@ -4,19 +4,19 @@ import unittest class SimpleTestCase(unittest.TestCase): def test_cint(self): x = c_int() - self.assertEquals(x._objects, None) + self.assertEqual(x._objects, None) x.value = 42 - self.assertEquals(x._objects, None) + self.assertEqual(x._objects, None) x = c_int(99) - self.assertEquals(x._objects, None) + self.assertEqual(x._objects, None) def test_ccharp(self): x = c_char_p() - self.assertEquals(x._objects, None) + self.assertEqual(x._objects, None) x.value = b"abc" - self.assertEquals(x._objects, b"abc") + self.assertEqual(x._objects, b"abc") x = c_char_p(b"spam") - self.assertEquals(x._objects, b"spam") + self.assertEqual(x._objects, b"spam") class StructureTestCase(unittest.TestCase): def test_cint_struct(self): @@ -25,21 +25,21 @@ class StructureTestCase(unittest.TestCase): ("b", c_int)] x = X() - self.assertEquals(x._objects, None) + self.assertEqual(x._objects, None) x.a = 42 x.b = 99 - self.assertEquals(x._objects, None) + self.assertEqual(x._objects, None) def test_ccharp_struct(self): class X(Structure): _fields_ = [("a", c_char_p), ("b", c_char_p)] x = X() - self.assertEquals(x._objects, None) + self.assertEqual(x._objects, None) x.a = b"spam" x.b = b"foo" - self.assertEquals(x._objects, {"0": b"spam", "1": b"foo"}) + self.assertEqual(x._objects, {"0": b"spam", "1": b"foo"}) def test_struct_struct(self): class POINT(Structure): @@ -52,28 +52,28 @@ class StructureTestCase(unittest.TestCase): r.ul.y = 1 r.lr.x = 2 r.lr.y = 3 - self.assertEquals(r._objects, None) + self.assertEqual(r._objects, None) r = RECT() pt = POINT(1, 2) r.ul = pt - self.assertEquals(r._objects, {'0': {}}) + self.assertEqual(r._objects, {'0': {}}) r.ul.x = 22 r.ul.y = 44 - self.assertEquals(r._objects, {'0': {}}) + self.assertEqual(r._objects, {'0': {}}) r.lr = POINT() - self.assertEquals(r._objects, {'0': {}, '1': {}}) + self.assertEqual(r._objects, {'0': {}, '1': {}}) class ArrayTestCase(unittest.TestCase): def test_cint_array(self): INTARR = c_int * 3 ia = INTARR() - self.assertEquals(ia._objects, None) + self.assertEqual(ia._objects, None) ia[0] = 1 ia[1] = 2 ia[2] = 3 - self.assertEquals(ia._objects, None) + self.assertEqual(ia._objects, None) class X(Structure): _fields_ = [("x", c_int), @@ -83,9 +83,9 @@ class ArrayTestCase(unittest.TestCase): x.x = 1000 x.a[0] = 42 x.a[1] = 96 - self.assertEquals(x._objects, None) + self.assertEqual(x._objects, None) x.a = ia - self.assertEquals(x._objects, {'1': {}}) + self.assertEqual(x._objects, {'1': {}}) class PointerTestCase(unittest.TestCase): def test_p_cint(self): diff --git a/Lib/distutils/tests/test_archive_util.py b/Lib/distutils/tests/test_archive_util.py index 9e6264a..aff4265 100644 --- a/Lib/distutils/tests/test_archive_util.py +++ b/Lib/distutils/tests/test_archive_util.py @@ -113,7 +113,7 @@ class ArchiveUtilTestCase(support.TempdirManager, self.assertTrue(os.path.exists(tarball2)) # let's compare both tarballs - self.assertEquals(self._tarinfo(tarball), self._tarinfo(tarball2)) + self.assertEqual(self._tarinfo(tarball), self._tarinfo(tarball2)) # trying an uncompressed one base_name = os.path.join(tmpdir2, 'archive') @@ -153,7 +153,7 @@ class ArchiveUtilTestCase(support.TempdirManager, os.chdir(old_dir) tarball = base_name + '.tar.Z' self.assertTrue(os.path.exists(tarball)) - self.assertEquals(len(w.warnings), 1) + self.assertEqual(len(w.warnings), 1) # same test with dry_run os.remove(tarball) @@ -167,7 +167,7 @@ class ArchiveUtilTestCase(support.TempdirManager, finally: os.chdir(old_dir) self.assertTrue(not os.path.exists(tarball)) - self.assertEquals(len(w.warnings), 1) + self.assertEqual(len(w.warnings), 1) @unittest.skipUnless(ZIP_SUPPORT, 'Need zip support to run') def test_make_zipfile(self): @@ -184,9 +184,9 @@ class ArchiveUtilTestCase(support.TempdirManager, tarball = base_name + '.zip' def test_check_archive_formats(self): - self.assertEquals(check_archive_formats(['gztar', 'xxx', 'zip']), - 'xxx') - self.assertEquals(check_archive_formats(['gztar', 'zip']), None) + self.assertEqual(check_archive_formats(['gztar', 'xxx', 'zip']), + 'xxx') + self.assertEqual(check_archive_formats(['gztar', 'zip']), None) def test_make_archive(self): tmpdir = self.mkdtemp() @@ -203,7 +203,7 @@ class ArchiveUtilTestCase(support.TempdirManager, make_archive('xxx', 'xxx', root_dir=self.mkdtemp()) except: pass - self.assertEquals(os.getcwd(), current_dir) + self.assertEqual(os.getcwd(), current_dir) finally: del ARCHIVE_FORMATS['xxx'] diff --git a/Lib/distutils/tests/test_bdist.py b/Lib/distutils/tests/test_bdist.py index bf56e84..94d40cc 100644 --- a/Lib/distutils/tests/test_bdist.py +++ b/Lib/distutils/tests/test_bdist.py @@ -24,7 +24,7 @@ class BuildTestCase(support.TempdirManager, cmd = bdist(dist) cmd.formats = ['msi'] cmd.ensure_finalized() - self.assertEquals(cmd.formats, ['msi']) + self.assertEqual(cmd.formats, ['msi']) # what format bdist offers ? # XXX an explicit list in bdist is @@ -35,7 +35,7 @@ class BuildTestCase(support.TempdirManager, formats.sort() founded = list(cmd.format_command.keys()) founded.sort() - self.assertEquals(founded, formats) + self.assertEqual(founded, formats) def test_suite(): return unittest.makeSuite(BuildTestCase) diff --git a/Lib/distutils/tests/test_bdist_dumb.py b/Lib/distutils/tests/test_bdist_dumb.py index 7d9d0aa..cc37fef 100644 --- a/Lib/distutils/tests/test_bdist_dumb.py +++ b/Lib/distutils/tests/test_bdist_dumb.py @@ -69,7 +69,7 @@ class BuildDumbTestCase(support.TempdirManager, base = base.replace(':', '-') wanted = ['%s.zip' % base] - self.assertEquals(dist_created, wanted) + self.assertEqual(dist_created, wanted) # now let's check what we have in the zip file # XXX to be done diff --git a/Lib/distutils/tests/test_build.py b/Lib/distutils/tests/test_build.py index 9f0e0ad..3391f36 100644 --- a/Lib/distutils/tests/test_build.py +++ b/Lib/distutils/tests/test_build.py @@ -18,11 +18,11 @@ class BuildTestCase(support.TempdirManager, cmd.finalize_options() # if not specified, plat_name gets the current platform - self.assertEquals(cmd.plat_name, get_platform()) + self.assertEqual(cmd.plat_name, get_platform()) # build_purelib is build + lib wanted = os.path.join(cmd.build_base, 'lib') - self.assertEquals(cmd.build_purelib, wanted) + self.assertEqual(cmd.build_purelib, wanted) # build_platlib is 'build/lib.platform-x.x[-pydebug]' # examples: @@ -32,21 +32,21 @@ class BuildTestCase(support.TempdirManager, self.assertTrue(cmd.build_platlib.endswith('-pydebug')) plat_spec += '-pydebug' wanted = os.path.join(cmd.build_base, 'lib' + plat_spec) - self.assertEquals(cmd.build_platlib, wanted) + self.assertEqual(cmd.build_platlib, wanted) # by default, build_lib = build_purelib - self.assertEquals(cmd.build_lib, cmd.build_purelib) + self.assertEqual(cmd.build_lib, cmd.build_purelib) # build_temp is build/temp.<plat> wanted = os.path.join(cmd.build_base, 'temp' + plat_spec) - self.assertEquals(cmd.build_temp, wanted) + self.assertEqual(cmd.build_temp, wanted) # build_scripts is build/scripts-x.x wanted = os.path.join(cmd.build_base, 'scripts-' + sys.version[0:3]) - self.assertEquals(cmd.build_scripts, wanted) + self.assertEqual(cmd.build_scripts, wanted) # executable is os.path.normpath(sys.executable) - self.assertEquals(cmd.executable, os.path.normpath(sys.executable)) + self.assertEqual(cmd.executable, os.path.normpath(sys.executable)) def test_suite(): return unittest.makeSuite(BuildTestCase) diff --git a/Lib/distutils/tests/test_build_clib.py b/Lib/distutils/tests/test_build_clib.py index e59b8f9..69bd2bf 100644 --- a/Lib/distutils/tests/test_build_clib.py +++ b/Lib/distutils/tests/test_build_clib.py @@ -57,14 +57,14 @@ class BuildCLibTestCase(support.TempdirManager, self.assertRaises(DistutilsSetupError, cmd.get_source_files) cmd.libraries = [('name', {'sources': ['a', 'b']})] - self.assertEquals(cmd.get_source_files(), ['a', 'b']) + self.assertEqual(cmd.get_source_files(), ['a', 'b']) cmd.libraries = [('name', {'sources': ('a', 'b')})] - self.assertEquals(cmd.get_source_files(), ['a', 'b']) + self.assertEqual(cmd.get_source_files(), ['a', 'b']) cmd.libraries = [('name', {'sources': ('a', 'b')}), ('name2', {'sources': ['c', 'd']})] - self.assertEquals(cmd.get_source_files(), ['a', 'b', 'c', 'd']) + self.assertEqual(cmd.get_source_files(), ['a', 'b', 'c', 'd']) def test_build_libraries(self): @@ -93,11 +93,11 @@ class BuildCLibTestCase(support.TempdirManager, cmd.include_dirs = 'one-dir' cmd.finalize_options() - self.assertEquals(cmd.include_dirs, ['one-dir']) + self.assertEqual(cmd.include_dirs, ['one-dir']) cmd.include_dirs = None cmd.finalize_options() - self.assertEquals(cmd.include_dirs, []) + self.assertEqual(cmd.include_dirs, []) cmd.distribution.libraries = 'WONTWORK' self.assertRaises(DistutilsSetupError, cmd.finalize_options) diff --git a/Lib/distutils/tests/test_build_ext.py b/Lib/distutils/tests/test_build_ext.py index 203cbc9..dcba75f 100644 --- a/Lib/distutils/tests/test_build_ext.py +++ b/Lib/distutils/tests/test_build_ext.py @@ -96,11 +96,11 @@ class BuildExtTestCase(TempdirManager, for attr in ('error', 'foo', 'new', 'roj'): self.assertTrue(hasattr(xx, attr)) - self.assertEquals(xx.foo(2, 5), 7) - self.assertEquals(xx.foo(13,15), 28) - self.assertEquals(xx.new().demo(), None) + self.assertEqual(xx.foo(2, 5), 7) + self.assertEqual(xx.foo(13,15), 28) + self.assertEqual(xx.new().demo(), None) doc = 'This is a template module just for instruction.' - self.assertEquals(xx.__doc__, doc) + self.assertEqual(xx.__doc__, doc) self.assertTrue(isinstance(xx.Null(), xx.Null)) self.assertTrue(isinstance(xx.Str(), xx.Str)) @@ -206,7 +206,7 @@ class BuildExtTestCase(TempdirManager, cmd = build_ext(dist) cmd.libraries = 'my_lib' cmd.finalize_options() - self.assertEquals(cmd.libraries, ['my_lib']) + self.assertEqual(cmd.libraries, ['my_lib']) # make sure cmd.library_dirs is turned into a list # if it's a string @@ -220,7 +220,7 @@ class BuildExtTestCase(TempdirManager, cmd = build_ext(dist) cmd.rpath = os.pathsep.join(['one', 'two']) cmd.finalize_options() - self.assertEquals(cmd.rpath, ['one', 'two']) + self.assertEqual(cmd.rpath, ['one', 'two']) # XXX more tests to perform for win32 @@ -229,25 +229,25 @@ class BuildExtTestCase(TempdirManager, cmd = build_ext(dist) cmd.define = 'one,two' cmd.finalize_options() - self.assertEquals(cmd.define, [('one', '1'), ('two', '1')]) + self.assertEqual(cmd.define, [('one', '1'), ('two', '1')]) # make sure undef is turned into a list of # strings if they are ','-separated strings cmd = build_ext(dist) cmd.undef = 'one,two' cmd.finalize_options() - self.assertEquals(cmd.undef, ['one', 'two']) + self.assertEqual(cmd.undef, ['one', 'two']) # make sure swig_opts is turned into a list cmd = build_ext(dist) cmd.swig_opts = None cmd.finalize_options() - self.assertEquals(cmd.swig_opts, []) + self.assertEqual(cmd.swig_opts, []) cmd = build_ext(dist) cmd.swig_opts = '1 2' cmd.finalize_options() - self.assertEquals(cmd.swig_opts, ['1', '2']) + self.assertEqual(cmd.swig_opts, ['1', '2']) def test_check_extensions_list(self): dist = Distribution() @@ -284,7 +284,7 @@ class BuildExtTestCase(TempdirManager, # check_extensions_list adds in ext the values passed # when they are in ('include_dirs', 'library_dirs', 'libraries' # 'extra_objects', 'extra_compile_args', 'extra_link_args') - self.assertEquals(ext.libraries, 'foo') + self.assertEqual(ext.libraries, 'foo') self.assertTrue(not hasattr(ext, 'some')) # 'macros' element of build info dict must be 1- or 2-tuple @@ -294,15 +294,15 @@ class BuildExtTestCase(TempdirManager, exts[0][1]['macros'] = [('1', '2'), ('3',)] cmd.check_extensions_list(exts) - self.assertEquals(exts[0].undef_macros, ['3']) - self.assertEquals(exts[0].define_macros, [('1', '2')]) + self.assertEqual(exts[0].undef_macros, ['3']) + self.assertEqual(exts[0].define_macros, [('1', '2')]) def test_get_source_files(self): modules = [Extension('foo', ['xxx'], optional=False)] dist = Distribution({'name': 'xx', 'ext_modules': modules}) cmd = build_ext(dist) cmd.ensure_finalized() - self.assertEquals(cmd.get_source_files(), ['xxx']) + self.assertEqual(cmd.get_source_files(), ['xxx']) def test_compiler_option(self): # cmd.compiler is an option and @@ -313,7 +313,7 @@ class BuildExtTestCase(TempdirManager, cmd.compiler = 'unix' cmd.ensure_finalized() cmd.run() - self.assertEquals(cmd.compiler, 'unix') + self.assertEqual(cmd.compiler, 'unix') def test_get_outputs(self): tmp_dir = self.mkdtemp() @@ -325,7 +325,7 @@ class BuildExtTestCase(TempdirManager, cmd = build_ext(dist) self._fixup_command(cmd) cmd.ensure_finalized() - self.assertEquals(len(cmd.get_outputs()), 1) + self.assertEqual(len(cmd.get_outputs()), 1) if os.name == "nt": cmd.debug = sys.executable.endswith("_d.exe") @@ -348,7 +348,7 @@ class BuildExtTestCase(TempdirManager, so_ext = sysconfig.get_config_var('SO') self.assertTrue(so_file.endswith(so_ext)) so_dir = os.path.dirname(so_file) - self.assertEquals(so_dir, other_tmp_dir) + self.assertEqual(so_dir, other_tmp_dir) cmd.inplace = 0 cmd.compiler = None @@ -357,7 +357,7 @@ class BuildExtTestCase(TempdirManager, self.assertTrue(os.path.exists(so_file)) self.assertTrue(so_file.endswith(so_ext)) so_dir = os.path.dirname(so_file) - self.assertEquals(so_dir, cmd.build_lib) + self.assertEqual(so_dir, cmd.build_lib) # inplace = 0, cmd.package = 'bar' build_py = cmd.get_finalized_command('build_py') @@ -365,7 +365,7 @@ class BuildExtTestCase(TempdirManager, path = cmd.get_ext_fullpath('foo') # checking that the last directory is the build_dir path = os.path.split(path)[0] - self.assertEquals(path, cmd.build_lib) + self.assertEqual(path, cmd.build_lib) # inplace = 1, cmd.package = 'bar' cmd.inplace = 1 @@ -379,7 +379,7 @@ class BuildExtTestCase(TempdirManager, # checking that the last directory is bar path = os.path.split(path)[0] lastdir = os.path.split(path)[-1] - self.assertEquals(lastdir, 'bar') + self.assertEqual(lastdir, 'bar') def test_ext_fullpath(self): ext = sysconfig.get_config_vars()['SO'] @@ -395,14 +395,14 @@ class BuildExtTestCase(TempdirManager, curdir = os.getcwd() wanted = os.path.join(curdir, 'src', 'lxml', 'etree' + ext) path = cmd.get_ext_fullpath('lxml.etree') - self.assertEquals(wanted, path) + self.assertEqual(wanted, path) # building lxml.etree not inplace cmd.inplace = 0 cmd.build_lib = os.path.join(curdir, 'tmpdir') wanted = os.path.join(curdir, 'tmpdir', 'lxml', 'etree' + ext) path = cmd.get_ext_fullpath('lxml.etree') - self.assertEquals(wanted, path) + self.assertEqual(wanted, path) # building twisted.runner.portmap not inplace build_py = cmd.get_finalized_command('build_py') @@ -411,13 +411,13 @@ class BuildExtTestCase(TempdirManager, path = cmd.get_ext_fullpath('twisted.runner.portmap') wanted = os.path.join(curdir, 'tmpdir', 'twisted', 'runner', 'portmap' + ext) - self.assertEquals(wanted, path) + self.assertEqual(wanted, path) # building twisted.runner.portmap inplace cmd.inplace = 1 path = cmd.get_ext_fullpath('twisted.runner.portmap') wanted = os.path.join(curdir, 'twisted', 'runner', 'portmap' + ext) - self.assertEquals(wanted, path) + self.assertEqual(wanted, path) def test_suite(): src = _get_source_filename() diff --git a/Lib/distutils/tests/test_check.py b/Lib/distutils/tests/test_check.py index 6ad2fe3..229ae25 100644 --- a/Lib/distutils/tests/test_check.py +++ b/Lib/distutils/tests/test_check.py @@ -27,7 +27,7 @@ class CheckTestCase(support.LoggingSilencer, # by default, check is checking the metadata # should have some warnings cmd = self._run() - self.assertEquals(cmd._warnings, 2) + self.assertEqual(cmd._warnings, 2) # now let's add the required fields # and run it again, to make sure we don't get @@ -36,7 +36,7 @@ class CheckTestCase(support.LoggingSilencer, 'author_email': 'xxx', 'name': 'xxx', 'version': 'xxx'} cmd = self._run(metadata) - self.assertEquals(cmd._warnings, 0) + self.assertEqual(cmd._warnings, 0) # now with the strict mode, we should # get an error if there are missing metadata @@ -44,7 +44,7 @@ class CheckTestCase(support.LoggingSilencer, # and of course, no error when all metadata are present cmd = self._run(metadata, strict=1) - self.assertEquals(cmd._warnings, 0) + self.assertEqual(cmd._warnings, 0) def test_check_document(self): if not HAS_DOCUTILS: # won't test without docutils @@ -55,12 +55,12 @@ class CheckTestCase(support.LoggingSilencer, # let's see if it detects broken rest broken_rest = 'title\n===\n\ntest' msgs = cmd._check_rst_data(broken_rest) - self.assertEquals(len(msgs), 1) + self.assertEqual(len(msgs), 1) # and non-broken rest rest = 'title\n=====\n\ntest' msgs = cmd._check_rst_data(rest) - self.assertEquals(len(msgs), 0) + self.assertEqual(len(msgs), 0) def test_check_restructuredtext(self): if not HAS_DOCUTILS: # won't test without docutils @@ -70,7 +70,7 @@ class CheckTestCase(support.LoggingSilencer, pkg_info, dist = self.create_dist(long_description=broken_rest) cmd = check(dist) cmd.check_restructuredtext() - self.assertEquals(cmd._warnings, 1) + self.assertEqual(cmd._warnings, 1) # let's see if we have an error with strict=1 metadata = {'url': 'xxx', 'author': 'xxx', @@ -83,7 +83,7 @@ class CheckTestCase(support.LoggingSilencer, # and non-broken rest metadata['long_description'] = 'title\n=====\n\ntest' cmd = self._run(metadata, strict=1, restructuredtext=1) - self.assertEquals(cmd._warnings, 0) + self.assertEqual(cmd._warnings, 0) def test_check_all(self): diff --git a/Lib/distutils/tests/test_cmd.py b/Lib/distutils/tests/test_cmd.py index 969f82b..195045c 100644 --- a/Lib/distutils/tests/test_cmd.py +++ b/Lib/distutils/tests/test_cmd.py @@ -44,7 +44,7 @@ class CommandTestCase(unittest.TestCase): # making sure execute gets called properly def _execute(func, args, exec_msg, level): - self.assertEquals(exec_msg, 'generating out from in') + self.assertEqual(exec_msg, 'generating out from in') cmd.force = True cmd.execute = _execute cmd.make_file(infiles='in', outfile='out', func='func', args=()) @@ -63,7 +63,7 @@ class CommandTestCase(unittest.TestCase): wanted = ["command options for 'MyCmd':", ' option1 = 1', ' option2 = 1'] - self.assertEquals(msgs, wanted) + self.assertEqual(msgs, wanted) def test_ensure_string(self): cmd = self.cmd @@ -81,7 +81,7 @@ class CommandTestCase(unittest.TestCase): cmd = self.cmd cmd.option1 = 'ok,dok' cmd.ensure_string_list('option1') - self.assertEquals(cmd.option1, ['ok', 'dok']) + self.assertEqual(cmd.option1, ['ok', 'dok']) cmd.option2 = ['xxx', 'www'] cmd.ensure_string_list('option2') @@ -109,14 +109,14 @@ class CommandTestCase(unittest.TestCase): with captured_stdout() as stdout: cmd.debug_print('xxx') stdout.seek(0) - self.assertEquals(stdout.read(), '') + self.assertEqual(stdout.read(), '') debug.DEBUG = True try: with captured_stdout() as stdout: cmd.debug_print('xxx') stdout.seek(0) - self.assertEquals(stdout.read(), 'xxx\n') + self.assertEqual(stdout.read(), 'xxx\n') finally: debug.DEBUG = False diff --git a/Lib/distutils/tests/test_config.py b/Lib/distutils/tests/test_config.py index 05a35da..525bee9 100644 --- a/Lib/distutils/tests/test_config.py +++ b/Lib/distutils/tests/test_config.py @@ -89,7 +89,7 @@ class PyPIRCCommandTestCase(support.TempdirManager, waited = [('password', 'secret'), ('realm', 'pypi'), ('repository', 'http://pypi.python.org/pypi'), ('server', 'server1'), ('username', 'me')] - self.assertEquals(config, waited) + self.assertEqual(config, waited) # old format self.write_file(self.rc, PYPIRC_OLD) @@ -98,7 +98,7 @@ class PyPIRCCommandTestCase(support.TempdirManager, waited = [('password', 'secret'), ('realm', 'pypi'), ('repository', 'http://pypi.python.org/pypi'), ('server', 'server-login'), ('username', 'tarek')] - self.assertEquals(config, waited) + self.assertEqual(config, waited) def test_server_empty_registration(self): cmd = self._cmd(self.dist) @@ -109,7 +109,7 @@ class PyPIRCCommandTestCase(support.TempdirManager, f = open(rc) try: content = f.read() - self.assertEquals(content, WANTED) + self.assertEqual(content, WANTED) finally: f.close() diff --git a/Lib/distutils/tests/test_config_cmd.py b/Lib/distutils/tests/test_config_cmd.py index c224a5c..4f7ebdd 100644 --- a/Lib/distutils/tests/test_config_cmd.py +++ b/Lib/distutils/tests/test_config_cmd.py @@ -35,7 +35,7 @@ class ConfigTestCase(support.LoggingSilencer, f.close() dump_file(this_file, 'I am the header') - self.assertEquals(len(self._logs), numlines+1) + self.assertEqual(len(self._logs), numlines+1) def test_search_cpp(self): if sys.platform == 'win32': @@ -45,10 +45,10 @@ class ConfigTestCase(support.LoggingSilencer, # simple pattern searches match = cmd.search_cpp(pattern='xxx', body='// xxx') - self.assertEquals(match, 0) + self.assertEqual(match, 0) match = cmd.search_cpp(pattern='_configtest', body='// xxx') - self.assertEquals(match, 1) + self.assertEqual(match, 1) def test_finalize_options(self): # finalize_options does a bit of transformation @@ -60,9 +60,9 @@ class ConfigTestCase(support.LoggingSilencer, cmd.library_dirs = 'three%sfour' % os.pathsep cmd.ensure_finalized() - self.assertEquals(cmd.include_dirs, ['one', 'two']) - self.assertEquals(cmd.libraries, ['one']) - self.assertEquals(cmd.library_dirs, ['three', 'four']) + self.assertEqual(cmd.include_dirs, ['one', 'two']) + self.assertEqual(cmd.libraries, ['one']) + self.assertEqual(cmd.library_dirs, ['three', 'four']) def test_clean(self): # _clean removes files diff --git a/Lib/distutils/tests/test_core.py b/Lib/distutils/tests/test_core.py index 47fae24..41321f7 100644 --- a/Lib/distutils/tests/test_core.py +++ b/Lib/distutils/tests/test_core.py @@ -89,7 +89,7 @@ class CoreTestCase(support.EnvironGuard, unittest.TestCase): with captured_stdout() as stdout: distutils.core.setup(name='bar') stdout.seek(0) - self.assertEquals(stdout.read(), 'bar\n') + self.assertEqual(stdout.read(), 'bar\n') distutils.core.DEBUG = True try: @@ -99,7 +99,7 @@ class CoreTestCase(support.EnvironGuard, unittest.TestCase): distutils.core.DEBUG = False stdout.seek(0) wanted = "options (after parsing config files):\n" - self.assertEquals(stdout.readlines()[0], wanted) + self.assertEqual(stdout.readlines()[0], wanted) def test_suite(): return unittest.makeSuite(CoreTestCase) diff --git a/Lib/distutils/tests/test_cygwinccompiler.py b/Lib/distutils/tests/test_cygwinccompiler.py index e57bab2..8569216 100644 --- a/Lib/distutils/tests/test_cygwinccompiler.py +++ b/Lib/distutils/tests/test_cygwinccompiler.py @@ -66,82 +66,82 @@ class CygwinCCompilerTestCase(support.TempdirManager, sys.version = ('2.6.1 (r261:67515, Dec 6 2008, 16:42:21) \n[GCC ' '4.0.1 (Apple Computer, Inc. build 5370)]') - self.assertEquals(check_config_h()[0], CONFIG_H_OK) + self.assertEqual(check_config_h()[0], CONFIG_H_OK) # then it tries to see if it can find "__GNUC__" in pyconfig.h sys.version = 'something without the *CC word' # if the file doesn't exist it returns CONFIG_H_UNCERTAIN - self.assertEquals(check_config_h()[0], CONFIG_H_UNCERTAIN) + self.assertEqual(check_config_h()[0], CONFIG_H_UNCERTAIN) # if it exists but does not contain __GNUC__, it returns CONFIG_H_NOTOK self.write_file(self.python_h, 'xxx') - self.assertEquals(check_config_h()[0], CONFIG_H_NOTOK) + self.assertEqual(check_config_h()[0], CONFIG_H_NOTOK) # and CONFIG_H_OK if __GNUC__ is found self.write_file(self.python_h, 'xxx __GNUC__ xxx') - self.assertEquals(check_config_h()[0], CONFIG_H_OK) + self.assertEqual(check_config_h()[0], CONFIG_H_OK) def test_get_versions(self): # get_versions calls distutils.spawn.find_executable on # 'gcc', 'ld' and 'dllwrap' - self.assertEquals(get_versions(), (None, None, None)) + self.assertEqual(get_versions(), (None, None, None)) # Let's fake we have 'gcc' and it returns '3.4.5' self._exes['gcc'] = b'gcc (GCC) 3.4.5 (mingw special)\nFSF' res = get_versions() - self.assertEquals(str(res[0]), '3.4.5') + self.assertEqual(str(res[0]), '3.4.5') # and let's see what happens when the version # doesn't match the regular expression # (\d+\.\d+(\.\d+)*) self._exes['gcc'] = b'very strange output' res = get_versions() - self.assertEquals(res[0], None) + self.assertEqual(res[0], None) # same thing for ld self._exes['ld'] = b'GNU ld version 2.17.50 20060824' res = get_versions() - self.assertEquals(str(res[1]), '2.17.50') + self.assertEqual(str(res[1]), '2.17.50') self._exes['ld'] = b'@(#)PROGRAM:ld PROJECT:ld64-77' res = get_versions() - self.assertEquals(res[1], None) + self.assertEqual(res[1], None) # and dllwrap self._exes['dllwrap'] = b'GNU dllwrap 2.17.50 20060824\nFSF' res = get_versions() - self.assertEquals(str(res[2]), '2.17.50') + self.assertEqual(str(res[2]), '2.17.50') self._exes['dllwrap'] = b'Cheese Wrap' res = get_versions() - self.assertEquals(res[2], None) + self.assertEqual(res[2], None) def test_get_msvcr(self): # none sys.version = ('2.6.1 (r261:67515, Dec 6 2008, 16:42:21) ' '\n[GCC 4.0.1 (Apple Computer, Inc. build 5370)]') - self.assertEquals(get_msvcr(), None) + self.assertEqual(get_msvcr(), None) # MSVC 7.0 sys.version = ('2.5.1 (r251:54863, Apr 18 2007, 08:51:08) ' '[MSC v.1300 32 bits (Intel)]') - self.assertEquals(get_msvcr(), ['msvcr70']) + self.assertEqual(get_msvcr(), ['msvcr70']) # MSVC 7.1 sys.version = ('2.5.1 (r251:54863, Apr 18 2007, 08:51:08) ' '[MSC v.1310 32 bits (Intel)]') - self.assertEquals(get_msvcr(), ['msvcr71']) + self.assertEqual(get_msvcr(), ['msvcr71']) # VS2005 / MSVC 8.0 sys.version = ('2.5.1 (r251:54863, Apr 18 2007, 08:51:08) ' '[MSC v.1400 32 bits (Intel)]') - self.assertEquals(get_msvcr(), ['msvcr80']) + self.assertEqual(get_msvcr(), ['msvcr80']) # VS2008 / MSVC 9.0 sys.version = ('2.5.1 (r251:54863, Apr 18 2007, 08:51:08) ' '[MSC v.1500 32 bits (Intel)]') - self.assertEquals(get_msvcr(), ['msvcr90']) + self.assertEqual(get_msvcr(), ['msvcr90']) # unknown sys.version = ('2.5.1 (r251:54863, Apr 18 2007, 08:51:08) ' diff --git a/Lib/distutils/tests/test_dep_util.py b/Lib/distutils/tests/test_dep_util.py index 390ed9b..3e1c366 100644 --- a/Lib/distutils/tests/test_dep_util.py +++ b/Lib/distutils/tests/test_dep_util.py @@ -43,8 +43,8 @@ class DepUtilTestCase(support.TempdirManager, unittest.TestCase): self.write_file(two) self.write_file(four) - self.assertEquals(newer_pairwise([one, two], [three, four]), - ([one],[three])) + self.assertEqual(newer_pairwise([one, two], [three, four]), + ([one],[three])) def test_newer_group(self): tmpdir = self.mkdtemp() diff --git a/Lib/distutils/tests/test_dir_util.py b/Lib/distutils/tests/test_dir_util.py index 7356c76..ce74589 100644 --- a/Lib/distutils/tests/test_dir_util.py +++ b/Lib/distutils/tests/test_dir_util.py @@ -38,18 +38,18 @@ class DirUtilTestCase(support.TempdirManager, unittest.TestCase): mkpath(self.target, verbose=0) wanted = [] - self.assertEquals(self._logs, wanted) + self.assertEqual(self._logs, wanted) remove_tree(self.root_target, verbose=0) mkpath(self.target, verbose=1) wanted = ['creating %s' % self.root_target, 'creating %s' % self.target] - self.assertEquals(self._logs, wanted) + self.assertEqual(self._logs, wanted) self._logs = [] remove_tree(self.root_target, verbose=1) wanted = ["removing '%s' (and everything under it)" % self.root_target] - self.assertEquals(self._logs, wanted) + self.assertEqual(self._logs, wanted) @unittest.skipIf(sys.platform.startswith('win'), "This test is only appropriate for POSIX-like systems.") @@ -67,12 +67,12 @@ class DirUtilTestCase(support.TempdirManager, unittest.TestCase): def test_create_tree_verbosity(self): create_tree(self.root_target, ['one', 'two', 'three'], verbose=0) - self.assertEquals(self._logs, []) + self.assertEqual(self._logs, []) remove_tree(self.root_target, verbose=0) wanted = ['creating %s' % self.root_target] create_tree(self.root_target, ['one', 'two', 'three'], verbose=1) - self.assertEquals(self._logs, wanted) + self.assertEqual(self._logs, wanted) remove_tree(self.root_target, verbose=0) @@ -82,7 +82,7 @@ class DirUtilTestCase(support.TempdirManager, unittest.TestCase): mkpath(self.target, verbose=0) copy_tree(self.target, self.target2, verbose=0) - self.assertEquals(self._logs, []) + self.assertEqual(self._logs, []) remove_tree(self.root_target, verbose=0) @@ -96,18 +96,18 @@ class DirUtilTestCase(support.TempdirManager, unittest.TestCase): wanted = ['copying %s -> %s' % (a_file, self.target2)] copy_tree(self.target, self.target2, verbose=1) - self.assertEquals(self._logs, wanted) + self.assertEqual(self._logs, wanted) remove_tree(self.root_target, verbose=0) remove_tree(self.target2, verbose=0) def test_ensure_relative(self): if os.sep == '/': - self.assertEquals(ensure_relative('/home/foo'), 'home/foo') - self.assertEquals(ensure_relative('some/path'), 'some/path') + self.assertEqual(ensure_relative('/home/foo'), 'home/foo') + self.assertEqual(ensure_relative('some/path'), 'some/path') else: # \\ - self.assertEquals(ensure_relative('c:\\home\\foo'), 'c:home\\foo') - self.assertEquals(ensure_relative('home\\foo'), 'home\\foo') + self.assertEqual(ensure_relative('c:\\home\\foo'), 'c:home\\foo') + self.assertEqual(ensure_relative('home\\foo'), 'home\\foo') def test_suite(): return unittest.makeSuite(DirUtilTestCase) diff --git a/Lib/distutils/tests/test_dist.py b/Lib/distutils/tests/test_dist.py index a8eb8b1..a20d6c8 100644 --- a/Lib/distutils/tests/test_dist.py +++ b/Lib/distutils/tests/test_dist.py @@ -124,7 +124,7 @@ class DistributionTestCase(support.LoggingSilencer, finally: warnings.warn = old_warn - self.assertEquals(len(warns), 0) + self.assertEqual(len(warns), 0) def test_finalize_options(self): @@ -135,20 +135,20 @@ class DistributionTestCase(support.LoggingSilencer, dist.finalize_options() # finalize_option splits platforms and keywords - self.assertEquals(dist.metadata.platforms, ['one', 'two']) - self.assertEquals(dist.metadata.keywords, ['one', 'two']) + self.assertEqual(dist.metadata.platforms, ['one', 'two']) + self.assertEqual(dist.metadata.keywords, ['one', 'two']) def test_get_command_packages(self): dist = Distribution() - self.assertEquals(dist.command_packages, None) + self.assertEqual(dist.command_packages, None) cmds = dist.get_command_packages() - self.assertEquals(cmds, ['distutils.command']) - self.assertEquals(dist.command_packages, - ['distutils.command']) + self.assertEqual(cmds, ['distutils.command']) + self.assertEqual(dist.command_packages, + ['distutils.command']) dist.command_packages = 'one,two' cmds = dist.get_command_packages() - self.assertEquals(cmds, ['distutils.command', 'one', 'two']) + self.assertEqual(cmds, ['distutils.command', 'one', 'two']) def test_announce(self): @@ -287,8 +287,8 @@ class MetadataTestCase(support.TempdirManager, support.EnvironGuard, def test_fix_help_options(self): help_tuples = [('a', 'b', 'c', 'd'), (1, 2, 3, 4)] fancy_options = fix_help_options(help_tuples) - self.assertEquals(fancy_options[0], ('a', 'b', 'c')) - self.assertEquals(fancy_options[1], (1, 2, 3)) + self.assertEqual(fancy_options[0], ('a', 'b', 'c')) + self.assertEqual(fancy_options[1], (1, 2, 3)) def test_show_help(self): # smoke test, just makes sure some help is displayed diff --git a/Lib/distutils/tests/test_extension.py b/Lib/distutils/tests/test_extension.py index c9c8965..e35f273 100755 --- a/Lib/distutils/tests/test_extension.py +++ b/Lib/distutils/tests/test_extension.py @@ -28,38 +28,38 @@ class ExtensionTestCase(unittest.TestCase): 'rect', 'rwobject', 'scrap', 'surface', 'surflock', 'time', 'transform'] - self.assertEquals(names, wanted) + self.assertEqual(names, wanted) def test_extension_init(self): # the first argument, which is the name, must be a string self.assertRaises(AssertionError, Extension, 1, []) ext = Extension('name', []) - self.assertEquals(ext.name, 'name') + self.assertEqual(ext.name, 'name') # the second argument, which is the list of files, must # be a list of strings self.assertRaises(AssertionError, Extension, 'name', 'file') self.assertRaises(AssertionError, Extension, 'name', ['file', 1]) ext = Extension('name', ['file1', 'file2']) - self.assertEquals(ext.sources, ['file1', 'file2']) + self.assertEqual(ext.sources, ['file1', 'file2']) # others arguments have defaults for attr in ('include_dirs', 'define_macros', 'undef_macros', 'library_dirs', 'libraries', 'runtime_library_dirs', 'extra_objects', 'extra_compile_args', 'extra_link_args', 'export_symbols', 'swig_opts', 'depends'): - self.assertEquals(getattr(ext, attr), []) + self.assertEqual(getattr(ext, attr), []) - self.assertEquals(ext.language, None) - self.assertEquals(ext.optional, None) + self.assertEqual(ext.language, None) + self.assertEqual(ext.optional, None) # if there are unknown keyword options, warn about them with check_warnings() as w: warnings.simplefilter('always') ext = Extension('name', ['file1', 'file2'], chic=True) - self.assertEquals(len(w.warnings), 1) - self.assertEquals(str(w.warnings[0].message), + self.assertEqual(len(w.warnings), 1) + self.assertEqual(str(w.warnings[0].message), "Unknown Extension options: 'chic'") def test_suite(): diff --git a/Lib/distutils/tests/test_file_util.py b/Lib/distutils/tests/test_file_util.py index be743f3..3c3e3dc 100644 --- a/Lib/distutils/tests/test_file_util.py +++ b/Lib/distutils/tests/test_file_util.py @@ -39,14 +39,14 @@ class FileUtilTestCase(support.TempdirManager, unittest.TestCase): move_file(self.source, self.target, verbose=0) wanted = [] - self.assertEquals(self._logs, wanted) + self.assertEqual(self._logs, wanted) # back to original state move_file(self.target, self.source, verbose=0) move_file(self.source, self.target, verbose=1) wanted = ['moving %s -> %s' % (self.source, self.target)] - self.assertEquals(self._logs, wanted) + self.assertEqual(self._logs, wanted) # back to original state move_file(self.target, self.source, verbose=0) @@ -56,7 +56,7 @@ class FileUtilTestCase(support.TempdirManager, unittest.TestCase): os.mkdir(self.target_dir) move_file(self.source, self.target_dir, verbose=1) wanted = ['moving %s -> %s' % (self.source, self.target_dir)] - self.assertEquals(self._logs, wanted) + self.assertEqual(self._logs, wanted) def test_suite(): diff --git a/Lib/distutils/tests/test_filelist.py b/Lib/distutils/tests/test_filelist.py index 6312a29..c7e5201 100644 --- a/Lib/distutils/tests/test_filelist.py +++ b/Lib/distutils/tests/test_filelist.py @@ -9,29 +9,29 @@ class FileListTestCase(unittest.TestCase): def test_glob_to_re(self): # simple cases - self.assertEquals(glob_to_re('foo*'), 'foo[^/]*\\Z(?ms)') - self.assertEquals(glob_to_re('foo?'), 'foo[^/]\\Z(?ms)') - self.assertEquals(glob_to_re('foo??'), 'foo[^/][^/]\\Z(?ms)') + self.assertEqual(glob_to_re('foo*'), 'foo[^/]*\\Z(?ms)') + self.assertEqual(glob_to_re('foo?'), 'foo[^/]\\Z(?ms)') + self.assertEqual(glob_to_re('foo??'), 'foo[^/][^/]\\Z(?ms)') # special cases - self.assertEquals(glob_to_re(r'foo\\*'), r'foo\\\\[^/]*\Z(?ms)') - self.assertEquals(glob_to_re(r'foo\\\*'), r'foo\\\\\\[^/]*\Z(?ms)') - self.assertEquals(glob_to_re('foo????'), r'foo[^/][^/][^/][^/]\Z(?ms)') - self.assertEquals(glob_to_re(r'foo\\??'), r'foo\\\\[^/][^/]\Z(?ms)') + self.assertEqual(glob_to_re(r'foo\\*'), r'foo\\\\[^/]*\Z(?ms)') + self.assertEqual(glob_to_re(r'foo\\\*'), r'foo\\\\\\[^/]*\Z(?ms)') + self.assertEqual(glob_to_re('foo????'), r'foo[^/][^/][^/][^/]\Z(?ms)') + self.assertEqual(glob_to_re(r'foo\\??'), r'foo\\\\[^/][^/]\Z(?ms)') def test_debug_print(self): file_list = FileList() with captured_stdout() as stdout: file_list.debug_print('xxx') stdout.seek(0) - self.assertEquals(stdout.read(), '') + self.assertEqual(stdout.read(), '') debug.DEBUG = True try: with captured_stdout() as stdout: file_list.debug_print('xxx') stdout.seek(0) - self.assertEquals(stdout.read(), 'xxx\n') + self.assertEqual(stdout.read(), 'xxx\n') finally: debug.DEBUG = False diff --git a/Lib/distutils/tests/test_install.py b/Lib/distutils/tests/test_install.py index 22e79b8..a76e3e7 100644 --- a/Lib/distutils/tests/test_install.py +++ b/Lib/distutils/tests/test_install.py @@ -123,23 +123,23 @@ class InstallTestCase(support.TempdirManager, # two elements cmd.handle_extra_path() - self.assertEquals(cmd.extra_path, ['path', 'dirs']) - self.assertEquals(cmd.extra_dirs, 'dirs') - self.assertEquals(cmd.path_file, 'path') + self.assertEqual(cmd.extra_path, ['path', 'dirs']) + self.assertEqual(cmd.extra_dirs, 'dirs') + self.assertEqual(cmd.path_file, 'path') # one element cmd.extra_path = ['path'] cmd.handle_extra_path() - self.assertEquals(cmd.extra_path, ['path']) - self.assertEquals(cmd.extra_dirs, 'path') - self.assertEquals(cmd.path_file, 'path') + self.assertEqual(cmd.extra_path, ['path']) + self.assertEqual(cmd.extra_dirs, 'path') + self.assertEqual(cmd.path_file, 'path') # none dist.extra_path = cmd.extra_path = None cmd.handle_extra_path() - self.assertEquals(cmd.extra_path, None) - self.assertEquals(cmd.extra_dirs, '') - self.assertEquals(cmd.path_file, None) + self.assertEqual(cmd.extra_path, None) + self.assertEqual(cmd.extra_dirs, '') + self.assertEqual(cmd.path_file, None) # three elements (no way !) cmd.extra_path = 'path,dirs,again' @@ -184,7 +184,7 @@ class InstallTestCase(support.TempdirManager, # line (the egg info file) f = open(cmd.record) try: - self.assertEquals(len(f.readlines()), 1) + self.assertEqual(len(f.readlines()), 1) finally: f.close() diff --git a/Lib/distutils/tests/test_install_data.py b/Lib/distutils/tests/test_install_data.py index 6b3b4c8..4d8c00a 100644 --- a/Lib/distutils/tests/test_install_data.py +++ b/Lib/distutils/tests/test_install_data.py @@ -28,14 +28,14 @@ class InstallDataTestCase(support.TempdirManager, self.write_file(two, 'xxx') cmd.data_files = [one, (inst2, [two])] - self.assertEquals(cmd.get_inputs(), [one, (inst2, [two])]) + self.assertEqual(cmd.get_inputs(), [one, (inst2, [two])]) # let's run the command cmd.ensure_finalized() cmd.run() # let's check the result - self.assertEquals(len(cmd.get_outputs()), 2) + self.assertEqual(len(cmd.get_outputs()), 2) rtwo = os.path.split(two)[-1] self.assertTrue(os.path.exists(os.path.join(inst2, rtwo))) rone = os.path.split(one)[-1] @@ -48,7 +48,7 @@ class InstallDataTestCase(support.TempdirManager, cmd.run() # let's check the result - self.assertEquals(len(cmd.get_outputs()), 2) + self.assertEqual(len(cmd.get_outputs()), 2) self.assertTrue(os.path.exists(os.path.join(inst2, rtwo))) self.assertTrue(os.path.exists(os.path.join(inst, rone))) cmd.outfiles = [] @@ -66,7 +66,7 @@ class InstallDataTestCase(support.TempdirManager, cmd.run() # let's check the result - self.assertEquals(len(cmd.get_outputs()), 4) + self.assertEqual(len(cmd.get_outputs()), 4) self.assertTrue(os.path.exists(os.path.join(inst2, rtwo))) self.assertTrue(os.path.exists(os.path.join(inst, rone))) diff --git a/Lib/distutils/tests/test_install_headers.py b/Lib/distutils/tests/test_install_headers.py index dc74c58..d953157 100644 --- a/Lib/distutils/tests/test_install_headers.py +++ b/Lib/distutils/tests/test_install_headers.py @@ -24,7 +24,7 @@ class InstallHeadersTestCase(support.TempdirManager, pkg_dir, dist = self.create_dist(headers=headers) cmd = install_headers(dist) - self.assertEquals(cmd.get_inputs(), headers) + self.assertEqual(cmd.get_inputs(), headers) # let's run the command cmd.install_dir = os.path.join(pkg_dir, 'inst') @@ -32,7 +32,7 @@ class InstallHeadersTestCase(support.TempdirManager, cmd.run() # let's check the results - self.assertEquals(len(cmd.get_outputs()), 2) + self.assertEqual(len(cmd.get_outputs()), 2) def test_suite(): return unittest.makeSuite(InstallHeadersTestCase) diff --git a/Lib/distutils/tests/test_install_lib.py b/Lib/distutils/tests/test_install_lib.py index 790d4ce..fddaabe 100644 --- a/Lib/distutils/tests/test_install_lib.py +++ b/Lib/distutils/tests/test_install_lib.py @@ -19,8 +19,8 @@ class InstallLibTestCase(support.TempdirManager, cmd = install_lib(dist) cmd.finalize_options() - self.assertEquals(cmd.compile, 1) - self.assertEquals(cmd.optimize, 0) + self.assertEqual(cmd.compile, 1) + self.assertEqual(cmd.optimize, 0) # optimize must be 0, 1, or 2 cmd.optimize = 'foo' @@ -30,7 +30,7 @@ class InstallLibTestCase(support.TempdirManager, cmd.optimize = '2' cmd.finalize_options() - self.assertEquals(cmd.optimize, 2) + self.assertEqual(cmd.optimize, 2) @unittest.skipUnless(not sys.dont_write_bytecode, 'byte-compile not supported') @@ -77,7 +77,7 @@ class InstallLibTestCase(support.TempdirManager, cmd.distribution.script_name = 'setup.py' # get_input should return 2 elements - self.assertEquals(len(cmd.get_inputs()), 2) + self.assertEqual(len(cmd.get_inputs()), 2) def test_dont_write_bytecode(self): # makes sure byte_compile is not used diff --git a/Lib/distutils/tests/test_log.py b/Lib/distutils/tests/test_log.py index 5f87076..ce66ee5 100644 --- a/Lib/distutils/tests/test_log.py +++ b/Lib/distutils/tests/test_log.py @@ -23,9 +23,9 @@ class TestLog(unittest.TestCase): log.debug("debug:\xe9") log.fatal("fatal:\xe9") stdout.seek(0) - self.assertEquals(stdout.read().rstrip(), "debug:\\xe9") + self.assertEqual(stdout.read().rstrip(), "debug:\\xe9") stderr.seek(0) - self.assertEquals(stderr.read().rstrip(), "fatal:\\xe9") + self.assertEqual(stderr.read().rstrip(), "fatal:\\xe9") finally: sys.stdout = old_stdout sys.stderr = old_stderr diff --git a/Lib/distutils/tests/test_msvc9compiler.py b/Lib/distutils/tests/test_msvc9compiler.py index 45bae77..a0d62ef 100644 --- a/Lib/distutils/tests/test_msvc9compiler.py +++ b/Lib/distutils/tests/test_msvc9compiler.py @@ -104,7 +104,7 @@ class msvc9compilerTestCase(support.TempdirManager, import winreg HKCU = winreg.HKEY_CURRENT_USER keys = Reg.read_keys(HKCU, 'xxxx') - self.assertEquals(keys, None) + self.assertEqual(keys, None) keys = Reg.read_keys(HKCU, r'Control Panel') self.assertTrue('Desktop' in keys) @@ -131,7 +131,7 @@ class msvc9compilerTestCase(support.TempdirManager, f.close() # makes sure the manifest was properly cleaned - self.assertEquals(content, _CLEANED_MANIFEST) + self.assertEqual(content, _CLEANED_MANIFEST) def test_suite(): diff --git a/Lib/distutils/tests/test_register.py b/Lib/distutils/tests/test_register.py index 9336ac8..c712f56 100644 --- a/Lib/distutils/tests/test_register.py +++ b/Lib/distutils/tests/test_register.py @@ -121,7 +121,7 @@ class RegisterTestCase(PyPIRCCommandTestCase): f = open(self.rc) try: content = f.read() - self.assertEquals(content, WANTED_PYPIRC) + self.assertEqual(content, WANTED_PYPIRC) finally: f.close() @@ -141,8 +141,8 @@ class RegisterTestCase(PyPIRCCommandTestCase): req1 = dict(self.conn.reqs[0].headers) req2 = dict(self.conn.reqs[1].headers) - self.assertEquals(req1['Content-length'], '1374') - self.assertEquals(req2['Content-length'], '1374') + self.assertEqual(req1['Content-length'], '1374') + self.assertEqual(req2['Content-length'], '1374') self.assertTrue((b'xxx') in self.conn.reqs[1].data) def test_password_not_in_file(self): @@ -155,7 +155,7 @@ class RegisterTestCase(PyPIRCCommandTestCase): # dist.password should be set # therefore used afterwards by other commands - self.assertEquals(cmd.distribution.password, 'password') + self.assertEqual(cmd.distribution.password, 'password') def test_registering(self): # this test runs choice 2 @@ -172,7 +172,7 @@ class RegisterTestCase(PyPIRCCommandTestCase): self.assertTrue(self.conn.reqs, 1) req = self.conn.reqs[0] headers = dict(req.headers) - self.assertEquals(headers['Content-length'], '608') + self.assertEqual(headers['Content-length'], '608') self.assertTrue((b'tarek') in req.data) def test_password_reset(self): @@ -190,7 +190,7 @@ class RegisterTestCase(PyPIRCCommandTestCase): self.assertTrue(self.conn.reqs, 1) req = self.conn.reqs[0] headers = dict(req.headers) - self.assertEquals(headers['Content-length'], '290') + self.assertEqual(headers['Content-length'], '290') self.assertTrue((b'tarek') in req.data) def test_strict(self): @@ -253,7 +253,7 @@ class RegisterTestCase(PyPIRCCommandTestCase): with check_warnings() as w: warnings.simplefilter("always") cmd.check_metadata() - self.assertEquals(len(w.warnings), 1) + self.assertEqual(len(w.warnings), 1) def test_suite(): return unittest.makeSuite(RegisterTestCase) diff --git a/Lib/distutils/tests/test_sdist.py b/Lib/distutils/tests/test_sdist.py index 73962d3..655e50d 100644 --- a/Lib/distutils/tests/test_sdist.py +++ b/Lib/distutils/tests/test_sdist.py @@ -108,7 +108,7 @@ class SDistTestCase(PyPIRCCommandTestCase): # now let's check what we have dist_folder = join(self.tmp_dir, 'dist') files = os.listdir(dist_folder) - self.assertEquals(files, ['fake-1.0.zip']) + self.assertEqual(files, ['fake-1.0.zip']) zip_file = zipfile.ZipFile(join(dist_folder, 'fake-1.0.zip')) try: @@ -117,7 +117,7 @@ class SDistTestCase(PyPIRCCommandTestCase): zip_file.close() # making sure everything has been pruned correctly - self.assertEquals(len(content), 4) + self.assertEqual(len(content), 4) def test_make_distribution(self): @@ -138,8 +138,7 @@ class SDistTestCase(PyPIRCCommandTestCase): dist_folder = join(self.tmp_dir, 'dist') result = os.listdir(dist_folder) result.sort() - self.assertEquals(result, - ['fake-1.0.tar', 'fake-1.0.tar.gz'] ) + self.assertEqual(result, ['fake-1.0.tar', 'fake-1.0.tar.gz'] ) os.remove(join(dist_folder, 'fake-1.0.tar')) os.remove(join(dist_folder, 'fake-1.0.tar.gz')) @@ -152,8 +151,7 @@ class SDistTestCase(PyPIRCCommandTestCase): result = os.listdir(dist_folder) result.sort() - self.assertEquals(result, - ['fake-1.0.tar', 'fake-1.0.tar.gz']) + self.assertEqual(result, ['fake-1.0.tar', 'fake-1.0.tar.gz']) def test_add_defaults(self): @@ -201,7 +199,7 @@ class SDistTestCase(PyPIRCCommandTestCase): # now let's check what we have dist_folder = join(self.tmp_dir, 'dist') files = os.listdir(dist_folder) - self.assertEquals(files, ['fake-1.0.zip']) + self.assertEqual(files, ['fake-1.0.zip']) zip_file = zipfile.ZipFile(join(dist_folder, 'fake-1.0.zip')) try: @@ -210,13 +208,13 @@ class SDistTestCase(PyPIRCCommandTestCase): zip_file.close() # making sure everything was added - self.assertEquals(len(content), 11) + self.assertEqual(len(content), 11) # checking the MANIFEST f = open(join(self.tmp_dir, 'MANIFEST')) try: manifest = f.read() - self.assertEquals(manifest, MANIFEST % {'sep': os.sep}) + self.assertEqual(manifest, MANIFEST % {'sep': os.sep}) finally: f.close() @@ -229,7 +227,7 @@ class SDistTestCase(PyPIRCCommandTestCase): cmd.ensure_finalized() cmd.run() warnings = self.get_logs(WARN) - self.assertEquals(len(warnings), 2) + self.assertEqual(len(warnings), 2) # trying with a complete set of metadata self.clear_logs() @@ -238,7 +236,7 @@ class SDistTestCase(PyPIRCCommandTestCase): cmd.metadata_check = 0 cmd.run() warnings = self.get_logs(WARN) - self.assertEquals(len(warnings), 0) + self.assertEqual(len(warnings), 0) def test_check_metadata_deprecated(self): # makes sure make_metadata is deprecated @@ -246,7 +244,7 @@ class SDistTestCase(PyPIRCCommandTestCase): with check_warnings() as w: warnings.simplefilter("always") cmd.check_metadata() - self.assertEquals(len(w.warnings), 1) + self.assertEqual(len(w.warnings), 1) def test_show_formats(self): with captured_stdout() as stdout: @@ -256,7 +254,7 @@ class SDistTestCase(PyPIRCCommandTestCase): num_formats = len(ARCHIVE_FORMATS.keys()) output = [line for line in stdout.getvalue().split('\n') if line.strip().startswith('--formats=')] - self.assertEquals(len(output), num_formats) + self.assertEqual(len(output), num_formats) def test_finalize_options(self): @@ -264,9 +262,9 @@ class SDistTestCase(PyPIRCCommandTestCase): cmd.finalize_options() # default options set by finalize - self.assertEquals(cmd.manifest, 'MANIFEST') - self.assertEquals(cmd.template, 'MANIFEST.in') - self.assertEquals(cmd.dist_dir, 'dist') + self.assertEqual(cmd.manifest, 'MANIFEST') + self.assertEqual(cmd.template, 'MANIFEST.in') + self.assertEqual(cmd.dist_dir, 'dist') # formats has to be a string splitable on (' ', ',') or # a stringlist @@ -297,7 +295,7 @@ class SDistTestCase(PyPIRCCommandTestCase): finally: f.close() - self.assertEquals(len(manifest), 5) + self.assertEqual(len(manifest), 5) # adding a file self.write_file((self.tmp_dir, 'somecode', 'doc2.txt'), '#') @@ -317,7 +315,7 @@ class SDistTestCase(PyPIRCCommandTestCase): f.close() # do we have the new file in MANIFEST ? - self.assertEquals(len(manifest2), 6) + self.assertEqual(len(manifest2), 6) self.assertIn('doc2.txt', manifest2[-1]) def test_manifest_marker(self): diff --git a/Lib/distutils/tests/test_spawn.py b/Lib/distutils/tests/test_spawn.py index 5b91aa5..6c7eb20 100644 --- a/Lib/distutils/tests/test_spawn.py +++ b/Lib/distutils/tests/test_spawn.py @@ -20,7 +20,7 @@ class SpawnTestCase(support.TempdirManager, (['nochange', 'nospace'], ['nochange', 'nospace'])): res = _nt_quote_args(args) - self.assertEquals(res, wanted) + self.assertEqual(res, wanted) @unittest.skipUnless(os.name in ('nt', 'posix'), diff --git a/Lib/distutils/tests/test_sysconfig.py b/Lib/distutils/tests/test_sysconfig.py index 215dc82..336c6a5 100644 --- a/Lib/distutils/tests/test_sysconfig.py +++ b/Lib/distutils/tests/test_sysconfig.py @@ -70,7 +70,7 @@ class SysconfigTestCase(support.EnvironGuard, comp = compiler() sysconfig.customize_compiler(comp) - self.assertEquals(comp.exes['archiver'], 'my_ar -arflags') + self.assertEqual(comp.exes['archiver'], 'my_ar -arflags') def test_parse_makefile_base(self): self.makefile = TESTFN @@ -81,8 +81,8 @@ class SysconfigTestCase(support.EnvironGuard, finally: fd.close() d = sysconfig.parse_makefile(self.makefile) - self.assertEquals(d, {'CONFIG_ARGS': "'--arg1=optarg1' 'ENV=LIB'", - 'OTHER': 'foo'}) + self.assertEqual(d, {'CONFIG_ARGS': "'--arg1=optarg1' 'ENV=LIB'", + 'OTHER': 'foo'}) def test_parse_makefile_literal_dollar(self): self.makefile = TESTFN @@ -93,16 +93,16 @@ class SysconfigTestCase(support.EnvironGuard, finally: fd.close() d = sysconfig.parse_makefile(self.makefile) - self.assertEquals(d, {'CONFIG_ARGS': r"'--arg1=optarg1' 'ENV=\$LIB'", - 'OTHER': 'foo'}) + self.assertEqual(d, {'CONFIG_ARGS': r"'--arg1=optarg1' 'ENV=\$LIB'", + 'OTHER': 'foo'}) def test_sysconfig_module(self): import sysconfig as global_sysconfig - self.assertEquals(global_sysconfig.get_config_var('CFLAGS'), sysconfig.get_config_var('CFLAGS')) - self.assertEquals(global_sysconfig.get_config_var('LDFLAGS'), sysconfig.get_config_var('LDFLAGS')) - self.assertEquals(global_sysconfig.get_config_var('LDSHARED'),sysconfig.get_config_var('LDSHARED')) - self.assertEquals(global_sysconfig.get_config_var('CC'), sysconfig.get_config_var('CC')) + self.assertEqual(global_sysconfig.get_config_var('CFLAGS'), sysconfig.get_config_var('CFLAGS')) + self.assertEqual(global_sysconfig.get_config_var('LDFLAGS'), sysconfig.get_config_var('LDFLAGS')) + self.assertEqual(global_sysconfig.get_config_var('LDSHARED'),sysconfig.get_config_var('LDSHARED')) + self.assertEqual(global_sysconfig.get_config_var('CC'), sysconfig.get_config_var('CC')) diff --git a/Lib/distutils/tests/test_text_file.py b/Lib/distutils/tests/test_text_file.py index 953cb8e..7e76240 100644 --- a/Lib/distutils/tests/test_text_file.py +++ b/Lib/distutils/tests/test_text_file.py @@ -49,7 +49,7 @@ class TextFileTestCase(support.TempdirManager, unittest.TestCase): def test_input(count, description, file, expected_result): result = file.readlines() - self.assertEquals(result, expected_result) + self.assertEqual(result, expected_result) tmpdir = self.mkdtemp() filename = os.path.join(tmpdir, "test.txt") diff --git a/Lib/distutils/tests/test_upload.py b/Lib/distutils/tests/test_upload.py index 4661ed3..4c6464a 100644 --- a/Lib/distutils/tests/test_upload.py +++ b/Lib/distutils/tests/test_upload.py @@ -89,7 +89,7 @@ class uploadTestCase(PyPIRCCommandTestCase): for attr, waited in (('username', 'me'), ('password', 'secret'), ('realm', 'pypi'), ('repository', 'http://pypi.python.org/pypi')): - self.assertEquals(getattr(cmd, attr), waited) + self.assertEqual(getattr(cmd, attr), waited) def test_saved_password(self): # file with no password @@ -99,14 +99,14 @@ class uploadTestCase(PyPIRCCommandTestCase): dist = Distribution() cmd = upload(dist) cmd.finalize_options() - self.assertEquals(cmd.password, None) + self.assertEqual(cmd.password, None) # make sure we get it as well, if another command # initialized it at the dist level dist.password = 'xxx' cmd = upload(dist) cmd.finalize_options() - self.assertEquals(cmd.password, 'xxx') + self.assertEqual(cmd.password, 'xxx') def test_upload(self): tmp = self.mkdtemp() @@ -124,12 +124,12 @@ class uploadTestCase(PyPIRCCommandTestCase): # what did we send ? headers = dict(self.conn.headers) - self.assertEquals(headers['Content-length'], '2087') + self.assertEqual(headers['Content-length'], '2087') self.assertTrue(headers['Content-type'].startswith('multipart/form-data')) self.assertFalse('\n' in headers['Authorization']) - self.assertEquals(self.conn.requests, [('POST', '/pypi')]) - self.assert_((b'xxx') in self.conn.body) + self.assertEqual(self.conn.requests, [('POST', '/pypi')]) + self.assertTrue((b'xxx') in self.conn.body) def test_suite(): return unittest.makeSuite(uploadTestCase) diff --git a/Lib/distutils/tests/test_util.py b/Lib/distutils/tests/test_util.py index 3b7159d..8ff5ae2 100644 --- a/Lib/distutils/tests/test_util.py +++ b/Lib/distutils/tests/test_util.py @@ -67,21 +67,21 @@ class UtilTestCase(support.EnvironGuard, unittest.TestCase): sys.version = ('2.4.4 (#71, Oct 18 2006, 08:34:43) ' '[MSC v.1310 32 bit (Intel)]') sys.platform = 'win32' - self.assertEquals(get_platform(), 'win32') + self.assertEqual(get_platform(), 'win32') # windows XP, amd64 os.name = 'nt' sys.version = ('2.4.4 (#71, Oct 18 2006, 08:34:43) ' '[MSC v.1310 32 bit (Amd64)]') sys.platform = 'win32' - self.assertEquals(get_platform(), 'win-amd64') + self.assertEqual(get_platform(), 'win-amd64') # windows XP, itanium os.name = 'nt' sys.version = ('2.4.4 (#71, Oct 18 2006, 08:34:43) ' '[MSC v.1310 32 bit (Itanium)]') sys.platform = 'win32' - self.assertEquals(get_platform(), 'win-ia64') + self.assertEqual(get_platform(), 'win-ia64') # macbook os.name = 'posix' @@ -100,7 +100,7 @@ class UtilTestCase(support.EnvironGuard, unittest.TestCase): cursize = sys.maxsize sys.maxsize = (2 ** 31)-1 try: - self.assertEquals(get_platform(), 'macosx-10.3-i386') + self.assertEqual(get_platform(), 'macosx-10.3-i386') finally: sys.maxsize = cursize @@ -111,33 +111,33 @@ class UtilTestCase(support.EnvironGuard, unittest.TestCase): '-fno-strict-aliasing -fno-common ' '-dynamic -DNDEBUG -g -O3') - self.assertEquals(get_platform(), 'macosx-10.4-fat') + self.assertEqual(get_platform(), 'macosx-10.4-fat') get_config_vars()['CFLAGS'] = ('-arch x86_64 -arch i386 -isysroot ' '/Developer/SDKs/MacOSX10.4u.sdk ' '-fno-strict-aliasing -fno-common ' '-dynamic -DNDEBUG -g -O3') - self.assertEquals(get_platform(), 'macosx-10.4-intel') + self.assertEqual(get_platform(), 'macosx-10.4-intel') get_config_vars()['CFLAGS'] = ('-arch x86_64 -arch ppc -arch i386 -isysroot ' '/Developer/SDKs/MacOSX10.4u.sdk ' '-fno-strict-aliasing -fno-common ' '-dynamic -DNDEBUG -g -O3') - self.assertEquals(get_platform(), 'macosx-10.4-fat3') + self.assertEqual(get_platform(), 'macosx-10.4-fat3') get_config_vars()['CFLAGS'] = ('-arch ppc64 -arch x86_64 -arch ppc -arch i386 -isysroot ' '/Developer/SDKs/MacOSX10.4u.sdk ' '-fno-strict-aliasing -fno-common ' '-dynamic -DNDEBUG -g -O3') - self.assertEquals(get_platform(), 'macosx-10.4-universal') + self.assertEqual(get_platform(), 'macosx-10.4-universal') get_config_vars()['CFLAGS'] = ('-arch x86_64 -arch ppc64 -isysroot ' '/Developer/SDKs/MacOSX10.4u.sdk ' '-fno-strict-aliasing -fno-common ' '-dynamic -DNDEBUG -g -O3') - self.assertEquals(get_platform(), 'macosx-10.4-fat64') + self.assertEqual(get_platform(), 'macosx-10.4-fat64') for arch in ('ppc', 'i386', 'x86_64', 'ppc64'): get_config_vars()['CFLAGS'] = ('-arch %s -isysroot ' @@ -145,7 +145,7 @@ class UtilTestCase(support.EnvironGuard, unittest.TestCase): '-fno-strict-aliasing -fno-common ' '-dynamic -DNDEBUG -g -O3'%(arch,)) - self.assertEquals(get_platform(), 'macosx-10.4-%s'%(arch,)) + self.assertEqual(get_platform(), 'macosx-10.4-%s'%(arch,)) # linux debian sarge os.name = 'posix' @@ -155,7 +155,7 @@ class UtilTestCase(support.EnvironGuard, unittest.TestCase): self._set_uname(('Linux', 'aglae', '2.6.21.1dedibox-r7', '#1 Mon Apr 30 17:25:38 CEST 2007', 'i686')) - self.assertEquals(get_platform(), 'linux-i686') + self.assertEqual(get_platform(), 'linux-i686') # XXX more platforms to tests here @@ -166,8 +166,8 @@ class UtilTestCase(support.EnvironGuard, unittest.TestCase): return '/'.join(path) os.path.join = _join - self.assertEquals(convert_path('/home/to/my/stuff'), - '/home/to/my/stuff') + self.assertEqual(convert_path('/home/to/my/stuff'), + '/home/to/my/stuff') # win os.sep = '\\' @@ -178,10 +178,10 @@ class UtilTestCase(support.EnvironGuard, unittest.TestCase): self.assertRaises(ValueError, convert_path, '/home/to/my/stuff') self.assertRaises(ValueError, convert_path, 'home/to/my/stuff/') - self.assertEquals(convert_path('home/to/my/stuff'), - 'home\\to\\my\\stuff') - self.assertEquals(convert_path('.'), - os.curdir) + self.assertEqual(convert_path('home/to/my/stuff'), + 'home\\to\\my\\stuff') + self.assertEqual(convert_path('.'), + os.curdir) def test_change_root(self): # linux/mac @@ -193,10 +193,10 @@ class UtilTestCase(support.EnvironGuard, unittest.TestCase): return '/'.join(path) os.path.join = _join - self.assertEquals(change_root('/root', '/old/its/here'), - '/root/old/its/here') - self.assertEquals(change_root('/root', 'its/here'), - '/root/its/here') + self.assertEqual(change_root('/root', '/old/its/here'), + '/root/old/its/here') + self.assertEqual(change_root('/root', 'its/here'), + '/root/its/here') # windows os.name = 'nt' @@ -212,10 +212,10 @@ class UtilTestCase(support.EnvironGuard, unittest.TestCase): return '\\'.join(path) os.path.join = _join - self.assertEquals(change_root('c:\\root', 'c:\\old\\its\\here'), - 'c:\\root\\old\\its\\here') - self.assertEquals(change_root('c:\\root', 'its\\here'), - 'c:\\root\\its\\here') + self.assertEqual(change_root('c:\\root', 'c:\\old\\its\\here'), + 'c:\\root\\old\\its\\here') + self.assertEqual(change_root('c:\\root', 'its\\here'), + 'c:\\root\\its\\here') # BugsBunny os (it's a great os) os.name = 'BugsBunny' @@ -233,16 +233,16 @@ class UtilTestCase(support.EnvironGuard, unittest.TestCase): if os.name == 'posix': # this test won't run on windows check_environ() import pwd - self.assertEquals(os.environ['HOME'], pwd.getpwuid(os.getuid())[5]) + self.assertEqual(os.environ['HOME'], pwd.getpwuid(os.getuid())[5]) else: check_environ() - self.assertEquals(os.environ['PLAT'], get_platform()) - self.assertEquals(util._environ_checked, 1) + self.assertEqual(os.environ['PLAT'], get_platform()) + self.assertEqual(util._environ_checked, 1) def test_split_quoted(self): - self.assertEquals(split_quoted('""one"" "two" \'three\' \\four'), - ['one', 'two', 'three', 'four']) + self.assertEqual(split_quoted('""one"" "two" \'three\' \\four'), + ['one', 'two', 'three', 'four']) def test_strtobool(self): yes = ('y', 'Y', 'yes', 'True', 't', 'true', 'True', 'On', 'on', '1') @@ -259,7 +259,7 @@ class UtilTestCase(support.EnvironGuard, unittest.TestCase): res = rfc822_escape(header) wanted = ('I am a%(8s)spoor%(8s)slonesome%(8s)s' 'header%(8s)s') % {'8s': '\n'+8*' '} - self.assertEquals(res, wanted) + self.assertEqual(res, wanted) def test_dont_write_bytecode(self): # makes sure byte_compile raise a DistutilsError diff --git a/Lib/distutils/tests/test_version.py b/Lib/distutils/tests/test_version.py index ff40f6b..15f14c7 100644 --- a/Lib/distutils/tests/test_version.py +++ b/Lib/distutils/tests/test_version.py @@ -8,12 +8,12 @@ class VersionTestCase(unittest.TestCase): def test_prerelease(self): version = StrictVersion('1.2.3a1') - self.assertEquals(version.version, (1, 2, 3)) - self.assertEquals(version.prerelease, ('a', 1)) - self.assertEquals(str(version), '1.2.3a1') + self.assertEqual(version.version, (1, 2, 3)) + self.assertEqual(version.prerelease, ('a', 1)) + self.assertEqual(str(version), '1.2.3a1') version = StrictVersion('1.2.0') - self.assertEquals(str(version), '1.2') + self.assertEqual(str(version), '1.2') def test_cmp_strict(self): versions = (('1.5.1', '1.5.2b2', -1), @@ -42,9 +42,9 @@ class VersionTestCase(unittest.TestCase): raise AssertionError(("cmp(%s, %s) " "shouldn't raise ValueError") % (v1, v2)) - self.assertEquals(res, wanted, - 'cmp(%s, %s) should be %s, got %s' % - (v1, v2, wanted, res)) + self.assertEqual(res, wanted, + 'cmp(%s, %s) should be %s, got %s' % + (v1, v2, wanted, res)) def test_cmp(self): @@ -60,9 +60,9 @@ class VersionTestCase(unittest.TestCase): for v1, v2, wanted in versions: res = LooseVersion(v1)._cmp(LooseVersion(v2)) - self.assertEquals(res, wanted, - 'cmp(%s, %s) should be %s, got %s' % - (v1, v2, wanted, res)) + self.assertEqual(res, wanted, + 'cmp(%s, %s) should be %s, got %s' % + (v1, v2, wanted, res)) def test_suite(): return unittest.makeSuite(VersionTestCase) diff --git a/Lib/email/test/test_email.py b/Lib/email/test/test_email.py index 89effcb..8702815 100644 --- a/Lib/email/test/test_email.py +++ b/Lib/email/test/test_email.py @@ -44,13 +44,13 @@ EMPTYSTRING = '' SPACE = ' ' - + def openfile(filename, *args, **kws): path = os.path.join(os.path.dirname(landmark), 'data', filename) return open(path, *args, **kws) - + # Base test class class TestEmailBase(unittest.TestCase): def ndiffAssertEqual(self, first, second): @@ -68,7 +68,7 @@ class TestEmailBase(unittest.TestCase): return email.message_from_file(fp) - + # Test various aspects of the Message class's API class TestMessageAPI(TestEmailBase): def test_get_all(self): @@ -510,7 +510,7 @@ class TestMessageAPI(TestEmailBase): bytes(x, 'raw-unicode-escape')) - + # Test the email.encoders module class TestEncoders(unittest.TestCase): def test_encode_empty_payload(self): @@ -539,7 +539,7 @@ class TestEncoders(unittest.TestCase): msg = MIMEText('文', _charset='euc-jp') eq(msg['content-transfer-encoding'], '7bit') - + # Test long header wrapping class TestLongHeaders(TestEmailBase): def test_split_long_continuation(self): @@ -918,7 +918,7 @@ List: List-Unsubscribe: <http://lists.sourceforge.net/lists/listinfo/spamassassi """) - + # Test mangling of "From " lines in the body of a message class TestFromMangling(unittest.TestCase): def setUp(self): @@ -952,7 +952,7 @@ Blah blah blah """) - + # Test the basic MIMEAudio class class TestMIMEAudio(unittest.TestCase): def setUp(self): @@ -999,7 +999,7 @@ class TestMIMEAudio(unittest.TestCase): header='foobar') is missing) - + # Test the basic MIMEImage class class TestMIMEImage(unittest.TestCase): def setUp(self): @@ -1040,7 +1040,7 @@ class TestMIMEImage(unittest.TestCase): header='foobar') is missing) - + # Test the basic MIMEApplication class class TestMIMEApplication(unittest.TestCase): def test_headers(self): @@ -1057,7 +1057,7 @@ class TestMIMEApplication(unittest.TestCase): eq(msg.get_payload(decode=True), bytes) - + # Test the basic MIMEText class class TestMIMEText(unittest.TestCase): def setUp(self): @@ -1111,7 +1111,7 @@ class TestMIMEText(unittest.TestCase): self.assertRaises(UnicodeEncodeError, MIMEText, teststr) - + # Test complicated multipart/* messages class TestMultipart(TestEmailBase): def setUp(self): @@ -1483,10 +1483,10 @@ Content-Transfer-Encoding: base64 YXNkZg== --===============0012394164==--""") - self.assertEquals(m.get_payload(0).get_payload(), 'YXNkZg==') + self.assertEqual(m.get_payload(0).get_payload(), 'YXNkZg==') + - # Test some badly formatted messages class TestNonConformant(TestEmailBase): def test_parse_missing_minor_type(self): @@ -1600,7 +1600,7 @@ counter to RFC 2822, there's no separating newline here eq(msg.defects[0].line, ' Line 1\n') - + # Test RFC 2047 header encoding and decoding class TestRFC2047(TestEmailBase): def test_rfc2047_multiline(self): @@ -1666,7 +1666,7 @@ Re: =?mac-iceland?q?r=8Aksm=9Arg=8Cs?= baz foo bar =?mac-iceland?q?r=8Aksm?= self.assertEqual(decode_header(s), [(b'andr\xe9=zz', 'iso-8659-1')]) - + # Test the MIMEMessage class class TestMIMEMessage(TestEmailBase): def setUp(self): @@ -1967,7 +1967,7 @@ message 2 msg = MIMEMultipart() self.assertTrue(msg.is_multipart()) - + # A general test of parser->model->generator idempotency. IOW, read a message # in, parse it into a message object tree, then without touching the tree, # regenerate the plain text. The original text and the transformed text @@ -1988,7 +1988,7 @@ class TestIdempotent(TestEmailBase): eq(text, s.getvalue()) def test_parse_text_message(self): - eq = self.assertEquals + eq = self.assertEqual msg, text = self._msgobj('msg_01.txt') eq(msg.get_content_type(), 'text/plain') eq(msg.get_content_maintype(), 'text') @@ -2000,7 +2000,7 @@ class TestIdempotent(TestEmailBase): self._idempotent(msg, text) def test_parse_untyped_message(self): - eq = self.assertEquals + eq = self.assertEqual msg, text = self._msgobj('msg_03.txt') eq(msg.get_content_type(), 'text/plain') eq(msg.get_params(), None) @@ -2076,7 +2076,7 @@ class TestIdempotent(TestEmailBase): self._idempotent(msg, text) def test_content_type(self): - eq = self.assertEquals + eq = self.assertEqual unless = self.assertTrue # Get a message object and reset the seek pointer for other tests msg, text = self._msgobj('msg_05.txt') @@ -2108,7 +2108,7 @@ class TestIdempotent(TestEmailBase): eq(msg4.get_payload(), 'Yadda yadda yadda\n') def test_parser(self): - eq = self.assertEquals + eq = self.assertEqual unless = self.assertTrue msg, text = self._msgobj('msg_06.txt') # Check some of the outer headers @@ -2125,7 +2125,7 @@ class TestIdempotent(TestEmailBase): eq(msg1.get_payload(), '\n') - + # Test various other bits of the package's functionality class TestMiscellaneous(TestEmailBase): def test_message_from_string(self): @@ -2450,7 +2450,7 @@ multipart/report """) - + # Test the iterator/generators class TestIterators(TestEmailBase): def test_body_line_iterator(self): @@ -2540,7 +2540,7 @@ Do you like this message? self.assertTrue(''.join([il for il, n in imt]) == ''.join(om)) - + class TestParsers(TestEmailBase): def test_header_parser(self): eq = self.assertEqual @@ -2704,7 +2704,7 @@ Here's the message body msg = email.message_from_string(m) self.assertTrue(msg.get_payload(0).get_payload().endswith('\r\n')) - + class Test8BitBytesHandling(unittest.TestCase): # In Python3 all input is string, but that doesn't work if the actual input # uses an 8bit transfer encoding. To hack around that, in email 5.1 we @@ -2954,7 +2954,7 @@ class Test8BitBytesHandling(unittest.TestCase): self.assertEqual(s.getvalue(), text) maxDiff = None - + class TestBytesGeneratorIdempotent(TestIdempotent): maxDiff = None @@ -2977,7 +2977,7 @@ class TestBytesGeneratorIdempotent(TestIdempotent): self.assertListEqual(str1.split(b'\n'), str2.split(b'\n')) - + class TestBase64(unittest.TestCase): def test_len(self): eq = self.assertEqual @@ -3030,7 +3030,7 @@ eHh4eCB4eHh4IA==\r eq(he('hello\nworld'), '=?iso-8859-1?b?aGVsbG8Kd29ybGQ=?=') - + class TestQuopri(unittest.TestCase): def setUp(self): # Set of characters (as byte integers) that don't need to be encoded @@ -3149,7 +3149,7 @@ one line two line""") - + # Test the Charset class class TestCharset(unittest.TestCase): def tearDown(self): @@ -3207,7 +3207,7 @@ class TestCharset(unittest.TestCase): self.assertRaises(errors.CharsetError, Charset, 'asc\xffii') - + # Test multilingual MIME headers. class TestHeader(TestEmailBase): def test_simple(self): @@ -3517,7 +3517,7 @@ A very long line that must get split to something other than at the raises(errors.HeaderParseError, decode_header, s) - + # Test RFC 2231 header parameters (en/de)coding class TestRFC2231(TestEmailBase): def test_get_param(self): @@ -3829,7 +3829,7 @@ Content-Type: application/x-foo; eq(s, 'My Document For You') - + # Tests to ensure that signed parts of an email are completely preserved, as # required by RFC1847 section 2.1. Note that these are incomplete, because the # email package does not currently always preserve the body. See issue 1670765. @@ -3867,7 +3867,7 @@ class TestSigned(TestEmailBase): self._signed_parts_eq(original, result) - + def _testclasses(): mod = sys.modules[__name__] return [getattr(mod, name) for name in dir(mod) if name.startswith('Test')] @@ -3885,6 +3885,6 @@ def test_main(): run_unittest(testclass) - + if __name__ == '__main__': unittest.main(defaultTest='suite') diff --git a/Lib/importlib/test/import_/test___package__.py b/Lib/importlib/test/import_/test___package__.py index 02679ef..5056ae5 100644 --- a/Lib/importlib/test/import_/test___package__.py +++ b/Lib/importlib/test/import_/test___package__.py @@ -42,7 +42,7 @@ class Using__package__(unittest.TestCase): module = import_util.import_('', globals={'__package__': 'pkg.fake'}, fromlist=['attr'], level=2) - self.assertEquals(module.__name__, 'pkg') + self.assertEqual(module.__name__, 'pkg') def test_using___name__(self, package_as_None=False): # [__name__] @@ -54,7 +54,7 @@ class Using__package__(unittest.TestCase): import_util.import_('pkg.fake') module = import_util.import_('', globals= globals_, fromlist=['attr'], level=2) - self.assertEquals(module.__name__, 'pkg') + self.assertEqual(module.__name__, 'pkg') def test_None_as___package__(self): # [None] diff --git a/Lib/importlib/test/import_/test_caching.py b/Lib/importlib/test/import_/test_caching.py index 530b1a0..48dc643 100644 --- a/Lib/importlib/test/import_/test_caching.py +++ b/Lib/importlib/test/import_/test_caching.py @@ -54,7 +54,7 @@ class UseCache(unittest.TestCase): with self.create_mock('module') as mock: with util.import_state(meta_path=[mock]): module = import_util.import_('module') - self.assertEquals(id(module), id(sys.modules['module'])) + self.assertEqual(id(module), id(sys.modules['module'])) # See test_using_cache_after_loader() for reasoning. @import_util.importlib_only @@ -74,8 +74,8 @@ class UseCache(unittest.TestCase): with util.import_state(meta_path=[importer]): module = import_util.import_('pkg', fromlist=['module']) self.assertTrue(hasattr(module, 'module')) - self.assertEquals(id(module.module), - id(sys.modules['pkg.module'])) + self.assertEqual(id(module.module), + id(sys.modules['pkg.module'])) def test_main(): diff --git a/Lib/importlib/test/import_/test_fromlist.py b/Lib/importlib/test/import_/test_fromlist.py index 14ea5bf..b903e8e 100644 --- a/Lib/importlib/test/import_/test_fromlist.py +++ b/Lib/importlib/test/import_/test_fromlist.py @@ -19,14 +19,14 @@ class ReturnValue(unittest.TestCase): with util.mock_modules('pkg.__init__', 'pkg.module') as importer: with util.import_state(meta_path=[importer]): module = import_util.import_('pkg.module') - self.assertEquals(module.__name__, 'pkg') + self.assertEqual(module.__name__, 'pkg') def test_return_from_from_import(self): # [from return] with util.mock_modules('pkg.__init__', 'pkg.module')as importer: with util.import_state(meta_path=[importer]): module = import_util.import_('pkg.module', fromlist=['attr']) - self.assertEquals(module.__name__, 'pkg.module') + self.assertEqual(module.__name__, 'pkg.module') class HandlingFromlist(unittest.TestCase): @@ -51,14 +51,14 @@ class HandlingFromlist(unittest.TestCase): with util.mock_modules('module') as importer: with util.import_state(meta_path=[importer]): module = import_util.import_('module', fromlist=['attr']) - self.assertEquals(module.__name__, 'module') + self.assertEqual(module.__name__, 'module') def test_unexistent_object(self): # [bad object] with util.mock_modules('module') as importer: with util.import_state(meta_path=[importer]): module = import_util.import_('module', fromlist=['non_existent']) - self.assertEquals(module.__name__, 'module') + self.assertEqual(module.__name__, 'module') self.assertTrue(not hasattr(module, 'non_existent')) def test_module_from_package(self): @@ -66,23 +66,23 @@ class HandlingFromlist(unittest.TestCase): with util.mock_modules('pkg.__init__', 'pkg.module') as importer: with util.import_state(meta_path=[importer]): module = import_util.import_('pkg', fromlist=['module']) - self.assertEquals(module.__name__, 'pkg') + self.assertEqual(module.__name__, 'pkg') self.assertTrue(hasattr(module, 'module')) - self.assertEquals(module.module.__name__, 'pkg.module') + self.assertEqual(module.module.__name__, 'pkg.module') def test_no_module_from_package(self): # [no module] with util.mock_modules('pkg.__init__') as importer: with util.import_state(meta_path=[importer]): module = import_util.import_('pkg', fromlist='non_existent') - self.assertEquals(module.__name__, 'pkg') + self.assertEqual(module.__name__, 'pkg') self.assertTrue(not hasattr(module, 'non_existent')) def test_empty_string(self): with util.mock_modules('pkg.__init__', 'pkg.mod') as importer: with util.import_state(meta_path=[importer]): module = import_util.import_('pkg.mod', fromlist=['']) - self.assertEquals(module.__name__, 'pkg.mod') + self.assertEqual(module.__name__, 'pkg.mod') def basic_star_test(self, fromlist=['*']): # [using *] @@ -90,7 +90,7 @@ class HandlingFromlist(unittest.TestCase): with util.import_state(meta_path=[mock]): mock['pkg'].__all__ = ['module'] module = import_util.import_('pkg', fromlist=fromlist) - self.assertEquals(module.__name__, 'pkg') + self.assertEqual(module.__name__, 'pkg') self.assertTrue(hasattr(module, 'module')) self.assertEqual(module.module.__name__, 'pkg.module') @@ -108,11 +108,11 @@ class HandlingFromlist(unittest.TestCase): with util.import_state(meta_path=[mock]): mock['pkg'].__all__ = ['module1'] module = import_util.import_('pkg', fromlist=['module2', '*']) - self.assertEquals(module.__name__, 'pkg') + self.assertEqual(module.__name__, 'pkg') self.assertTrue(hasattr(module, 'module1')) self.assertTrue(hasattr(module, 'module2')) - self.assertEquals(module.module1.__name__, 'pkg.module1') - self.assertEquals(module.module2.__name__, 'pkg.module2') + self.assertEqual(module.module1.__name__, 'pkg.module1') + self.assertEqual(module.module2.__name__, 'pkg.module2') def test_main(): diff --git a/Lib/importlib/test/import_/test_meta_path.py b/Lib/importlib/test/import_/test_meta_path.py index 5486694..3b130c9 100644 --- a/Lib/importlib/test/import_/test_meta_path.py +++ b/Lib/importlib/test/import_/test_meta_path.py @@ -21,7 +21,7 @@ class CallingOrder(unittest.TestCase): first.modules[mod] = 42 second.modules[mod] = -13 with util.import_state(meta_path=[first, second]): - self.assertEquals(import_util.import_(mod), 42) + self.assertEqual(import_util.import_(mod), 42) def test_continuing(self): # [continuing] @@ -31,7 +31,7 @@ class CallingOrder(unittest.TestCase): first.find_module = lambda self, fullname, path=None: None second.modules[mod_name] = 42 with util.import_state(meta_path=[first, second]): - self.assertEquals(import_util.import_(mod_name), 42) + self.assertEqual(import_util.import_(mod_name), 42) class CallSignature(unittest.TestCase): @@ -61,9 +61,9 @@ class CallSignature(unittest.TestCase): args = log[0][0] kwargs = log[0][1] # Assuming all arguments are positional. - self.assertEquals(len(args), 2) - self.assertEquals(len(kwargs), 0) - self.assertEquals(args[0], mod_name) + self.assertEqual(len(args), 2) + self.assertEqual(len(kwargs), 0) + self.assertEqual(args[0], mod_name) self.assertTrue(args[1] is None) def test_with_path(self): @@ -83,7 +83,7 @@ class CallSignature(unittest.TestCase): kwargs = log[1][1] # Assuming all arguments are positional. self.assertTrue(not kwargs) - self.assertEquals(args[0], mod_name) + self.assertEqual(args[0], mod_name) self.assertTrue(args[1] is path) diff --git a/Lib/json/tests/test_decode.py b/Lib/json/tests/test_decode.py index beb82a7..f41e5b7 100644 --- a/Lib/json/tests/test_decode.py +++ b/Lib/json/tests/test_decode.py @@ -24,12 +24,12 @@ class TestDecode(TestCase): def test_decimal(self): rval = json.loads('1.1', parse_float=decimal.Decimal) self.assertTrue(isinstance(rval, decimal.Decimal)) - self.assertEquals(rval, decimal.Decimal('1.1')) + self.assertEqual(rval, decimal.Decimal('1.1')) def test_float(self): rval = json.loads('1', parse_int=float) self.assertTrue(isinstance(rval, float)) - self.assertEquals(rval, 1.0) + self.assertEqual(rval, 1.0) def test_object_pairs_hook(self): s = '{"xkd":1, "kcw":2, "art":3, "hxm":4, "qrt":5, "pad":6, "hoy":7}' @@ -53,7 +53,7 @@ class TestDecode(TestCase): # the whitespace regex, so this test is designed to try and # exercise the uncommon cases. The array cases are already covered. rval = json.loads('{ "key" : "value" , "k":"v" }') - self.assertEquals(rval, {"key":"value", "k":"v"}) + self.assertEqual(rval, {"key":"value", "k":"v"}) def check_keys_reuse(self, source, loads): rval = loads(source) diff --git a/Lib/json/tests/test_default.py b/Lib/json/tests/test_default.py index 49f05ad..6a03eeb 100644 --- a/Lib/json/tests/test_default.py +++ b/Lib/json/tests/test_default.py @@ -4,6 +4,6 @@ import json class TestDefault(TestCase): def test_default(self): - self.assertEquals( + self.assertEqual( json.dumps(type, default=repr), json.dumps(repr(type))) diff --git a/Lib/json/tests/test_dump.py b/Lib/json/tests/test_dump.py index 54e218f..8df234b 100644 --- a/Lib/json/tests/test_dump.py +++ b/Lib/json/tests/test_dump.py @@ -7,15 +7,15 @@ class TestDump(TestCase): def test_dump(self): sio = StringIO() json.dump({}, sio) - self.assertEquals(sio.getvalue(), '{}') + self.assertEqual(sio.getvalue(), '{}') def test_dumps(self): - self.assertEquals(json.dumps({}), '{}') + self.assertEqual(json.dumps({}), '{}') def test_encode_truefalse(self): - self.assertEquals(json.dumps( + self.assertEqual(json.dumps( {True: False, False: True}, sort_keys=True), '{"false": true, "true": false}') - self.assertEquals(json.dumps( + self.assertEqual(json.dumps( {2: 3.0, 4.0: 5, False: 1, 6: True}, sort_keys=True), '{"false": 1, "2": 3.0, "4.0": 5, "6": true}') diff --git a/Lib/json/tests/test_encode_basestring_ascii.py b/Lib/json/tests/test_encode_basestring_ascii.py index dbcb09a..4fddd12 100644 --- a/Lib/json/tests/test_encode_basestring_ascii.py +++ b/Lib/json/tests/test_encode_basestring_ascii.py @@ -34,7 +34,7 @@ class TestEncodeBaseStringAscii(TestCase): fname = encode_basestring_ascii.__name__ for input_string, expect in CASES: result = encode_basestring_ascii(input_string) - self.assertEquals(result, expect, + self.assertEqual(result, expect, '{0!r} != {1!r} for {2}({3!r})'.format( result, expect, fname, input_string)) diff --git a/Lib/json/tests/test_float.py b/Lib/json/tests/test_float.py index 2d4aea2..ca4a506 100644 --- a/Lib/json/tests/test_float.py +++ b/Lib/json/tests/test_float.py @@ -6,10 +6,10 @@ import json class TestFloat(TestCase): def test_floats(self): for num in [1617161771.7650001, math.pi, math.pi**100, math.pi**-100, 3.1]: - self.assertEquals(float(json.dumps(num)), num) - self.assertEquals(json.loads(json.dumps(num)), num) + self.assertEqual(float(json.dumps(num)), num) + self.assertEqual(json.loads(json.dumps(num)), num) def test_ints(self): for num in [1, 1<<32, 1<<64]: - self.assertEquals(json.dumps(num), str(num)) - self.assertEquals(int(json.dumps(num)), num) + self.assertEqual(json.dumps(num), str(num)) + self.assertEqual(int(json.dumps(num)), num) diff --git a/Lib/json/tests/test_indent.py b/Lib/json/tests/test_indent.py index ddf88cd..d8030aa 100644 --- a/Lib/json/tests/test_indent.py +++ b/Lib/json/tests/test_indent.py @@ -38,8 +38,8 @@ class TestIndent(TestCase): h2 = json.loads(d2) h3 = json.loads(d3) - self.assertEquals(h1, h) - self.assertEquals(h2, h) - self.assertEquals(h3, h) - self.assertEquals(d2, expect.expandtabs(2)) - self.assertEquals(d3, expect) + self.assertEqual(h1, h) + self.assertEqual(h2, h) + self.assertEqual(h3, h) + self.assertEqual(d2, expect.expandtabs(2)) + self.assertEqual(d3, expect) diff --git a/Lib/json/tests/test_pass1.py b/Lib/json/tests/test_pass1.py index 216e252..719c113 100644 --- a/Lib/json/tests/test_pass1.py +++ b/Lib/json/tests/test_pass1.py @@ -67,7 +67,7 @@ class TestPass1(TestCase): # test in/out equivalence and parsing res = json.loads(JSON) out = json.dumps(res) - self.assertEquals(res, json.loads(out)) + self.assertEqual(res, json.loads(out)) try: json.dumps(res, allow_nan=False) except ValueError: diff --git a/Lib/json/tests/test_pass2.py b/Lib/json/tests/test_pass2.py index 80d8433..379117e 100644 --- a/Lib/json/tests/test_pass2.py +++ b/Lib/json/tests/test_pass2.py @@ -11,4 +11,4 @@ class TestPass2(TestCase): # test in/out equivalence and parsing res = json.loads(JSON) out = json.dumps(res) - self.assertEquals(res, json.loads(out)) + self.assertEqual(res, json.loads(out)) diff --git a/Lib/json/tests/test_pass3.py b/Lib/json/tests/test_pass3.py index 77d87b2..9151c43 100644 --- a/Lib/json/tests/test_pass3.py +++ b/Lib/json/tests/test_pass3.py @@ -17,4 +17,4 @@ class TestPass3(TestCase): # test in/out equivalence and parsing res = json.loads(JSON) out = json.dumps(res) - self.assertEquals(res, json.loads(out)) + self.assertEqual(res, json.loads(out)) diff --git a/Lib/json/tests/test_recursion.py b/Lib/json/tests/test_recursion.py index 073d3c1..1e9b8ab 100644 --- a/Lib/json/tests/test_recursion.py +++ b/Lib/json/tests/test_recursion.py @@ -57,7 +57,7 @@ class TestRecursion(TestCase): def test_defaultrecursion(self): enc = RecursiveJSONEncoder() - self.assertEquals(enc.encode(JSONTestObject), '"JSONTestObject"') + self.assertEqual(enc.encode(JSONTestObject), '"JSONTestObject"') enc.recurse = True try: enc.encode(JSONTestObject) diff --git a/Lib/json/tests/test_scanstring.py b/Lib/json/tests/test_scanstring.py index 2e9136b..d503851 100644 --- a/Lib/json/tests/test_scanstring.py +++ b/Lib/json/tests/test_scanstring.py @@ -14,92 +14,92 @@ class TestScanString(TestCase): self._test_scanstring(json.decoder.c_scanstring) def _test_scanstring(self, scanstring): - self.assertEquals( + self.assertEqual( scanstring('"z\\ud834\\udd20x"', 1, True), ('z\U0001d120x', 16)) if sys.maxunicode == 65535: - self.assertEquals( + self.assertEqual( scanstring('"z\U0001d120x"', 1, True), ('z\U0001d120x', 6)) else: - self.assertEquals( + self.assertEqual( scanstring('"z\U0001d120x"', 1, True), ('z\U0001d120x', 5)) - self.assertEquals( + self.assertEqual( scanstring('"\\u007b"', 1, True), ('{', 8)) - self.assertEquals( + self.assertEqual( scanstring('"A JSON payload should be an object or array, not a string."', 1, True), ('A JSON payload should be an object or array, not a string.', 60)) - self.assertEquals( + self.assertEqual( scanstring('["Unclosed array"', 2, True), ('Unclosed array', 17)) - self.assertEquals( + self.assertEqual( scanstring('["extra comma",]', 2, True), ('extra comma', 14)) - self.assertEquals( + self.assertEqual( scanstring('["double extra comma",,]', 2, True), ('double extra comma', 21)) - self.assertEquals( + self.assertEqual( scanstring('["Comma after the close"],', 2, True), ('Comma after the close', 24)) - self.assertEquals( + self.assertEqual( scanstring('["Extra close"]]', 2, True), ('Extra close', 14)) - self.assertEquals( + self.assertEqual( scanstring('{"Extra comma": true,}', 2, True), ('Extra comma', 14)) - self.assertEquals( + self.assertEqual( scanstring('{"Extra value after close": true} "misplaced quoted value"', 2, True), ('Extra value after close', 26)) - self.assertEquals( + self.assertEqual( scanstring('{"Illegal expression": 1 + 2}', 2, True), ('Illegal expression', 21)) - self.assertEquals( + self.assertEqual( scanstring('{"Illegal invocation": alert()}', 2, True), ('Illegal invocation', 21)) - self.assertEquals( + self.assertEqual( scanstring('{"Numbers cannot have leading zeroes": 013}', 2, True), ('Numbers cannot have leading zeroes', 37)) - self.assertEquals( + self.assertEqual( scanstring('{"Numbers cannot be hex": 0x14}', 2, True), ('Numbers cannot be hex', 24)) - self.assertEquals( + self.assertEqual( scanstring('[[[[[[[[[[[[[[[[[[[["Too deep"]]]]]]]]]]]]]]]]]]]]', 21, True), ('Too deep', 30)) - self.assertEquals( + self.assertEqual( scanstring('{"Missing colon" null}', 2, True), ('Missing colon', 16)) - self.assertEquals( + self.assertEqual( scanstring('{"Double colon":: null}', 2, True), ('Double colon', 15)) - self.assertEquals( + self.assertEqual( scanstring('{"Comma instead of colon", null}', 2, True), ('Comma instead of colon', 25)) - self.assertEquals( + self.assertEqual( scanstring('["Colon instead of comma": false]', 2, True), ('Colon instead of comma', 25)) - self.assertEquals( + self.assertEqual( scanstring('["Bad value", truth]', 2, True), ('Bad value', 12)) diff --git a/Lib/json/tests/test_separators.py b/Lib/json/tests/test_separators.py index 32db341..d5b92bd 100644 --- a/Lib/json/tests/test_separators.py +++ b/Lib/json/tests/test_separators.py @@ -37,6 +37,6 @@ class TestSeparators(TestCase): h1 = json.loads(d1) h2 = json.loads(d2) - self.assertEquals(h1, h) - self.assertEquals(h2, h) - self.assertEquals(d2, expect) + self.assertEqual(h1, h) + self.assertEqual(h2, h) + self.assertEqual(d2, expect) diff --git a/Lib/json/tests/test_speedups.py b/Lib/json/tests/test_speedups.py index 29e40ac..9438154 100644 --- a/Lib/json/tests/test_speedups.py +++ b/Lib/json/tests/test_speedups.py @@ -5,11 +5,11 @@ from json import decoder, encoder, scanner class TestSpeedups(TestCase): def test_scanstring(self): - self.assertEquals(decoder.scanstring.__module__, "_json") + self.assertEqual(decoder.scanstring.__module__, "_json") self.assertTrue(decoder.scanstring is decoder.c_scanstring) def test_encode_basestring_ascii(self): - self.assertEquals(encoder.encode_basestring_ascii.__module__, "_json") + self.assertEqual(encoder.encode_basestring_ascii.__module__, "_json") self.assertTrue(encoder.encode_basestring_ascii is encoder.c_encode_basestring_ascii) diff --git a/Lib/json/tests/test_unicode.py b/Lib/json/tests/test_unicode.py index 12de83c..e336c91 100644 --- a/Lib/json/tests/test_unicode.py +++ b/Lib/json/tests/test_unicode.py @@ -10,43 +10,43 @@ class TestUnicode(TestCase): def test_encoding3(self): u = '\N{GREEK SMALL LETTER ALPHA}\N{GREEK CAPITAL LETTER OMEGA}' j = json.dumps(u) - self.assertEquals(j, '"\\u03b1\\u03a9"') + self.assertEqual(j, '"\\u03b1\\u03a9"') def test_encoding4(self): u = '\N{GREEK SMALL LETTER ALPHA}\N{GREEK CAPITAL LETTER OMEGA}' j = json.dumps([u]) - self.assertEquals(j, '["\\u03b1\\u03a9"]') + self.assertEqual(j, '["\\u03b1\\u03a9"]') def test_encoding5(self): u = '\N{GREEK SMALL LETTER ALPHA}\N{GREEK CAPITAL LETTER OMEGA}' j = json.dumps(u, ensure_ascii=False) - self.assertEquals(j, '"{0}"'.format(u)) + self.assertEqual(j, '"{0}"'.format(u)) def test_encoding6(self): u = '\N{GREEK SMALL LETTER ALPHA}\N{GREEK CAPITAL LETTER OMEGA}' j = json.dumps([u], ensure_ascii=False) - self.assertEquals(j, '["{0}"]'.format(u)) + self.assertEqual(j, '["{0}"]'.format(u)) def test_big_unicode_encode(self): u = '\U0001d120' - self.assertEquals(json.dumps(u), '"\\ud834\\udd20"') - self.assertEquals(json.dumps(u, ensure_ascii=False), '"\U0001d120"') + self.assertEqual(json.dumps(u), '"\\ud834\\udd20"') + self.assertEqual(json.dumps(u, ensure_ascii=False), '"\U0001d120"') def test_big_unicode_decode(self): u = 'z\U0001d120x' - self.assertEquals(json.loads('"' + u + '"'), u) - self.assertEquals(json.loads('"z\\ud834\\udd20x"'), u) + self.assertEqual(json.loads('"' + u + '"'), u) + self.assertEqual(json.loads('"z\\ud834\\udd20x"'), u) def test_unicode_decode(self): for i in range(0, 0xd7ff): u = chr(i) s = '"\\u{0:04x}"'.format(i) - self.assertEquals(json.loads(s), u) + self.assertEqual(json.loads(s), u) def test_unicode_preservation(self): - self.assertEquals(type(json.loads('""')), str) - self.assertEquals(type(json.loads('"a"')), str) - self.assertEquals(type(json.loads('["a"]')[0]), str) + self.assertEqual(type(json.loads('""')), str) + self.assertEqual(type(json.loads('"a"')), str) + self.assertEqual(type(json.loads('["a"]')[0]), str) def test_bytes_encode(self): self.assertRaises(TypeError, json.dumps, b"hi") diff --git a/Lib/lib2to3/tests/data/py2_test_grammar.py b/Lib/lib2to3/tests/data/py2_test_grammar.py index 17f9f4c..153f57c 100644 --- a/Lib/lib2to3/tests/data/py2_test_grammar.py +++ b/Lib/lib2to3/tests/data/py2_test_grammar.py @@ -20,21 +20,21 @@ class TokenTests(unittest.TestCase): # Backslash means line continuation: x = 1 \ + 1 - self.assertEquals(x, 2, 'backslash for line continuation') + self.assertEqual(x, 2, 'backslash for line continuation') # Backslash does not means continuation in comments :\ x = 0 - self.assertEquals(x, 0, 'backslash ending comment') + self.assertEqual(x, 0, 'backslash ending comment') def testPlainIntegers(self): - self.assertEquals(0xff, 255) - self.assertEquals(0377, 255) - self.assertEquals(2147483647, 017777777777) + self.assertEqual(0xff, 255) + self.assertEqual(0377, 255) + self.assertEqual(2147483647, 017777777777) # "0x" is not a valid literal self.assertRaises(SyntaxError, eval, "0x") from sys import maxint if maxint == 2147483647: - self.assertEquals(-2147483647-1, -020000000000) + self.assertEqual(-2147483647-1, -020000000000) # XXX -2147483648 self.assert_(037777777777 > 0) self.assert_(0xffffffff > 0) @@ -44,7 +44,7 @@ class TokenTests(unittest.TestCase): except OverflowError: self.fail("OverflowError on huge integer literal %r" % s) elif maxint == 9223372036854775807: - self.assertEquals(-9223372036854775807-1, -01000000000000000000000) + self.assertEqual(-9223372036854775807-1, -01000000000000000000000) self.assert_(01777777777777777777777 > 0) self.assert_(0xffffffffffffffff > 0) for s in '9223372036854775808', '02000000000000000000000', \ @@ -97,28 +97,28 @@ jumps over the 'lazy' dog. """ y = '\nThe "quick"\nbrown fox\njumps over\nthe \'lazy\' dog.\n' - self.assertEquals(x, y) + self.assertEqual(x, y) y = ''' The "quick" brown fox jumps over the 'lazy' dog. ''' - self.assertEquals(x, y) + self.assertEqual(x, y) y = "\n\ The \"quick\"\n\ brown fox\n\ jumps over\n\ the 'lazy' dog.\n\ " - self.assertEquals(x, y) + self.assertEqual(x, y) y = '\n\ The \"quick\"\n\ brown fox\n\ jumps over\n\ the \'lazy\' dog.\n\ ' - self.assertEquals(x, y) + self.assertEqual(x, y) class GrammarTests(unittest.TestCase): @@ -154,18 +154,18 @@ class GrammarTests(unittest.TestCase): def f3(two, arguments): pass def f4(two, (compound, (argument, list))): pass def f5((compound, first), two): pass - self.assertEquals(f2.func_code.co_varnames, ('one_argument',)) - self.assertEquals(f3.func_code.co_varnames, ('two', 'arguments')) + self.assertEqual(f2.func_code.co_varnames, ('one_argument',)) + self.assertEqual(f3.func_code.co_varnames, ('two', 'arguments')) if sys.platform.startswith('java'): - self.assertEquals(f4.func_code.co_varnames, + self.assertEqual(f4.func_code.co_varnames, ('two', '(compound, (argument, list))', 'compound', 'argument', 'list',)) - self.assertEquals(f5.func_code.co_varnames, + self.assertEqual(f5.func_code.co_varnames, ('(compound, first)', 'two', 'compound', 'first')) else: - self.assertEquals(f4.func_code.co_varnames, + self.assertEqual(f4.func_code.co_varnames, ('two', '.1', 'compound', 'argument', 'list')) - self.assertEquals(f5.func_code.co_varnames, + self.assertEqual(f5.func_code.co_varnames, ('.0', 'two', 'compound', 'first')) def a1(one_arg,): pass def a2(two, args,): pass @@ -201,10 +201,10 @@ class GrammarTests(unittest.TestCase): # ceval unpacks the formal arguments into the first argcount names; # thus, the names nested inside tuples must appear after these names. if sys.platform.startswith('java'): - self.assertEquals(v3.func_code.co_varnames, ('a', '(b, c)', 'rest', 'b', 'c')) + self.assertEqual(v3.func_code.co_varnames, ('a', '(b, c)', 'rest', 'b', 'c')) else: - self.assertEquals(v3.func_code.co_varnames, ('a', '.1', 'rest', 'b', 'c')) - self.assertEquals(v3(1, (2, 3), 4), (1, 2, 3, (4,))) + self.assertEqual(v3.func_code.co_varnames, ('a', '.1', 'rest', 'b', 'c')) + self.assertEqual(v3(1, (2, 3), 4), (1, 2, 3, (4,))) def d01(a=1): pass d01() d01(1) @@ -285,7 +285,7 @@ class GrammarTests(unittest.TestCase): # keyword arguments after *arglist def f(*args, **kwargs): return args, kwargs - self.assertEquals(f(1, x=2, *[3, 4], y=5), ((1, 3, 4), + self.assertEqual(f(1, x=2, *[3, 4], y=5), ((1, 3, 4), {'x':2, 'y':5})) self.assertRaises(SyntaxError, eval, "f(1, *(2,3), 4)") self.assertRaises(SyntaxError, eval, "f(1, x=2, *(3,4), x=5)") @@ -297,15 +297,15 @@ class GrammarTests(unittest.TestCase): def testLambdef(self): ### lambdef: 'lambda' [varargslist] ':' test l1 = lambda : 0 - self.assertEquals(l1(), 0) + self.assertEqual(l1(), 0) l2 = lambda : a[d] # XXX just testing the expression l3 = lambda : [2 < x for x in [-1, 3, 0L]] - self.assertEquals(l3(), [0, 1, 0]) + self.assertEqual(l3(), [0, 1, 0]) l4 = lambda x = lambda y = lambda z=1 : z : y() : x() - self.assertEquals(l4(), 1) + self.assertEqual(l4(), 1) l5 = lambda x, y, z=2: x + y + z - self.assertEquals(l5(1, 2), 5) - self.assertEquals(l5(1, 2, 3), 6) + self.assertEqual(l5(1, 2), 5) + self.assertEqual(l5(1, 2, 3), 6) check_syntax_error(self, "lambda x: x = 2") check_syntax_error(self, "lambda (None,): None") @@ -558,7 +558,7 @@ hello world try: assert 0, "msg" except AssertionError, e: - self.assertEquals(e.args[0], "msg") + self.assertEqual(e.args[0], "msg") else: if __debug__: self.fail("AssertionError not raised by assert 0") @@ -592,7 +592,7 @@ hello world x = 1 else: x = 2 - self.assertEquals(x, 2) + self.assertEqual(x, 2) def testFor(self): # 'for' exprlist 'in' exprlist ':' suite ['else' ':' suite] @@ -745,7 +745,7 @@ hello world d[1,2,3] = 4 L = list(d) L.sort() - self.assertEquals(str(L), '[1, (1,), (1, 2), (1, 2, 3)]') + self.assertEqual(str(L), '[1, (1,), (1, 2), (1, 2, 3)]') def testAtoms(self): ### atom: '(' [testlist] ')' | '[' [testlist] ']' | '{' [dictmaker] '}' | '`' testlist '`' | NAME | NUMBER | STRING diff --git a/Lib/lib2to3/tests/data/py3_test_grammar.py b/Lib/lib2to3/tests/data/py3_test_grammar.py index 977f0b8..8079de0 100644 --- a/Lib/lib2to3/tests/data/py3_test_grammar.py +++ b/Lib/lib2to3/tests/data/py3_test_grammar.py @@ -20,23 +20,23 @@ class TokenTests(unittest.TestCase): # Backslash means line continuation: x = 1 \ + 1 - self.assertEquals(x, 2, 'backslash for line continuation') + self.assertEqual(x, 2, 'backslash for line continuation') # Backslash does not means continuation in comments :\ x = 0 - self.assertEquals(x, 0, 'backslash ending comment') + self.assertEqual(x, 0, 'backslash ending comment') def testPlainIntegers(self): - self.assertEquals(type(000), type(0)) - self.assertEquals(0xff, 255) - self.assertEquals(0o377, 255) - self.assertEquals(2147483647, 0o17777777777) - self.assertEquals(0b1001, 9) + self.assertEqual(type(000), type(0)) + self.assertEqual(0xff, 255) + self.assertEqual(0o377, 255) + self.assertEqual(2147483647, 0o17777777777) + self.assertEqual(0b1001, 9) # "0x" is not a valid literal self.assertRaises(SyntaxError, eval, "0x") from sys import maxsize if maxsize == 2147483647: - self.assertEquals(-2147483647-1, -0o20000000000) + self.assertEqual(-2147483647-1, -0o20000000000) # XXX -2147483648 self.assert_(0o37777777777 > 0) self.assert_(0xffffffff > 0) @@ -48,7 +48,7 @@ class TokenTests(unittest.TestCase): except OverflowError: self.fail("OverflowError on huge integer literal %r" % s) elif maxsize == 9223372036854775807: - self.assertEquals(-9223372036854775807-1, -0o1000000000000000000000) + self.assertEqual(-9223372036854775807-1, -0o1000000000000000000000) self.assert_(0o1777777777777777777777 > 0) self.assert_(0xffffffffffffffff > 0) self.assert_(0b11111111111111111111111111111111111111111111111111111111111111 > 0) @@ -103,28 +103,28 @@ jumps over the 'lazy' dog. """ y = '\nThe "quick"\nbrown fox\njumps over\nthe \'lazy\' dog.\n' - self.assertEquals(x, y) + self.assertEqual(x, y) y = ''' The "quick" brown fox jumps over the 'lazy' dog. ''' - self.assertEquals(x, y) + self.assertEqual(x, y) y = "\n\ The \"quick\"\n\ brown fox\n\ jumps over\n\ the 'lazy' dog.\n\ " - self.assertEquals(x, y) + self.assertEqual(x, y) y = '\n\ The \"quick\"\n\ brown fox\n\ jumps over\n\ the \'lazy\' dog.\n\ ' - self.assertEquals(x, y) + self.assertEqual(x, y) def testEllipsis(self): x = ... @@ -165,8 +165,8 @@ class GrammarTests(unittest.TestCase): f1(*(), **{}) def f2(one_argument): pass def f3(two, arguments): pass - self.assertEquals(f2.__code__.co_varnames, ('one_argument',)) - self.assertEquals(f3.__code__.co_varnames, ('two', 'arguments')) + self.assertEqual(f2.__code__.co_varnames, ('one_argument',)) + self.assertEqual(f3.__code__.co_varnames, ('two', 'arguments')) def a1(one_arg,): pass def a2(two, args,): pass def v0(*rest): pass @@ -287,37 +287,37 @@ class GrammarTests(unittest.TestCase): # keyword arguments after *arglist def f(*args, **kwargs): return args, kwargs - self.assertEquals(f(1, x=2, *[3, 4], y=5), ((1, 3, 4), + self.assertEqual(f(1, x=2, *[3, 4], y=5), ((1, 3, 4), {'x':2, 'y':5})) self.assertRaises(SyntaxError, eval, "f(1, *(2,3), 4)") self.assertRaises(SyntaxError, eval, "f(1, x=2, *(3,4), x=5)") # argument annotation tests def f(x) -> list: pass - self.assertEquals(f.__annotations__, {'return': list}) + self.assertEqual(f.__annotations__, {'return': list}) def f(x:int): pass - self.assertEquals(f.__annotations__, {'x': int}) + self.assertEqual(f.__annotations__, {'x': int}) def f(*x:str): pass - self.assertEquals(f.__annotations__, {'x': str}) + self.assertEqual(f.__annotations__, {'x': str}) def f(**x:float): pass - self.assertEquals(f.__annotations__, {'x': float}) + self.assertEqual(f.__annotations__, {'x': float}) def f(x, y:1+2): pass - self.assertEquals(f.__annotations__, {'y': 3}) + self.assertEqual(f.__annotations__, {'y': 3}) def f(a, b:1, c:2, d): pass - self.assertEquals(f.__annotations__, {'b': 1, 'c': 2}) + self.assertEqual(f.__annotations__, {'b': 1, 'c': 2}) def f(a, b:1, c:2, d, e:3=4, f=5, *g:6): pass - self.assertEquals(f.__annotations__, - {'b': 1, 'c': 2, 'e': 3, 'g': 6}) + self.assertEqual(f.__annotations__, + {'b': 1, 'c': 2, 'e': 3, 'g': 6}) def f(a, b:1, c:2, d, e:3=4, f=5, *g:6, h:7, i=8, j:9=10, **k:11) -> 12: pass - self.assertEquals(f.__annotations__, - {'b': 1, 'c': 2, 'e': 3, 'g': 6, 'h': 7, 'j': 9, - 'k': 11, 'return': 12}) + self.assertEqual(f.__annotations__, + {'b': 1, 'c': 2, 'e': 3, 'g': 6, 'h': 7, 'j': 9, + 'k': 11, 'return': 12}) # Check for SF Bug #1697248 - mixing decorators and a return annotation def null(x): return x @null def f(x) -> list: pass - self.assertEquals(f.__annotations__, {'return': list}) + self.assertEqual(f.__annotations__, {'return': list}) # test MAKE_CLOSURE with a variety of oparg's closure = 1 @@ -333,20 +333,20 @@ class GrammarTests(unittest.TestCase): def testLambdef(self): ### lambdef: 'lambda' [varargslist] ':' test l1 = lambda : 0 - self.assertEquals(l1(), 0) + self.assertEqual(l1(), 0) l2 = lambda : a[d] # XXX just testing the expression l3 = lambda : [2 < x for x in [-1, 3, 0]] - self.assertEquals(l3(), [0, 1, 0]) + self.assertEqual(l3(), [0, 1, 0]) l4 = lambda x = lambda y = lambda z=1 : z : y() : x() - self.assertEquals(l4(), 1) + self.assertEqual(l4(), 1) l5 = lambda x, y, z=2: x + y + z - self.assertEquals(l5(1, 2), 5) - self.assertEquals(l5(1, 2, 3), 6) + self.assertEqual(l5(1, 2), 5) + self.assertEqual(l5(1, 2, 3), 6) check_syntax_error(self, "lambda x: x = 2") check_syntax_error(self, "lambda (None,): None") l6 = lambda x, y, *, k=20: x+y+k - self.assertEquals(l6(1,2), 1+2+20) - self.assertEquals(l6(1,2,k=10), 1+2+10) + self.assertEqual(l6(1,2), 1+2+20) + self.assertEqual(l6(1,2,k=10), 1+2+10) ### stmt: simple_stmt | compound_stmt @@ -502,7 +502,7 @@ class GrammarTests(unittest.TestCase): try: assert 0, "msg" except AssertionError as e: - self.assertEquals(e.args[0], "msg") + self.assertEqual(e.args[0], "msg") else: if __debug__: self.fail("AssertionError not raised by assert 0") @@ -536,7 +536,7 @@ class GrammarTests(unittest.TestCase): x = 1 else: x = 2 - self.assertEquals(x, 2) + self.assertEqual(x, 2) def testFor(self): # 'for' exprlist 'in' exprlist ':' suite ['else' ':' suite] @@ -688,7 +688,7 @@ class GrammarTests(unittest.TestCase): d[1,2,3] = 4 L = list(d) L.sort(key=lambda x: x if isinstance(x, tuple) else ()) - self.assertEquals(str(L), '[1, (1,), (1, 2), (1, 2, 3)]') + self.assertEqual(str(L), '[1, (1,), (1, 2), (1, 2, 3)]') def testAtoms(self): ### atom: '(' [testlist] ')' | '[' [testlist] ']' | '{' [dictsetmaker] '}' | NAME | NUMBER | STRING diff --git a/Lib/sqlite3/test/dbapi.py b/Lib/sqlite3/test/dbapi.py index 51253d0..518b8ae 100644 --- a/Lib/sqlite3/test/dbapi.py +++ b/Lib/sqlite3/test/dbapi.py @@ -43,7 +43,7 @@ class ModuleTests(unittest.TestCase): sqlite.paramstyle) def CheckWarning(self): - self.assert_(issubclass(sqlite.Warning, Exception), + self.assertTrue(issubclass(sqlite.Warning, Exception), "Warning is not a subclass of Exception") def CheckError(self): diff --git a/Lib/sqlite3/test/types.py b/Lib/sqlite3/test/types.py index 26494e1..29413e1 100644 --- a/Lib/sqlite3/test/types.py +++ b/Lib/sqlite3/test/types.py @@ -291,7 +291,7 @@ class ColNamesTests(unittest.TestCase): no row returned. """ self.cur.execute("select * from test where 0 = 1") - self.assert_(self.cur.description[0][0] == "x") + self.assertEqual(self.cur.description[0][0], "x") class ObjectAdaptationTests(unittest.TestCase): def cast(obj): diff --git a/Lib/test/buffer_tests.py b/Lib/test/buffer_tests.py index 58689cd..6d20f7d 100644 --- a/Lib/test/buffer_tests.py +++ b/Lib/test/buffer_tests.py @@ -15,32 +15,32 @@ class MixinBytesBufferCommonTests(object): def test_islower(self): self.assertFalse(self.marshal(b'').islower()) - self.assert_(self.marshal(b'a').islower()) + self.assertTrue(self.marshal(b'a').islower()) self.assertFalse(self.marshal(b'A').islower()) self.assertFalse(self.marshal(b'\n').islower()) - self.assert_(self.marshal(b'abc').islower()) + self.assertTrue(self.marshal(b'abc').islower()) self.assertFalse(self.marshal(b'aBc').islower()) - self.assert_(self.marshal(b'abc\n').islower()) + self.assertTrue(self.marshal(b'abc\n').islower()) self.assertRaises(TypeError, self.marshal(b'abc').islower, 42) def test_isupper(self): self.assertFalse(self.marshal(b'').isupper()) self.assertFalse(self.marshal(b'a').isupper()) - self.assert_(self.marshal(b'A').isupper()) + self.assertTrue(self.marshal(b'A').isupper()) self.assertFalse(self.marshal(b'\n').isupper()) - self.assert_(self.marshal(b'ABC').isupper()) + self.assertTrue(self.marshal(b'ABC').isupper()) self.assertFalse(self.marshal(b'AbC').isupper()) - self.assert_(self.marshal(b'ABC\n').isupper()) + self.assertTrue(self.marshal(b'ABC\n').isupper()) self.assertRaises(TypeError, self.marshal(b'abc').isupper, 42) def test_istitle(self): self.assertFalse(self.marshal(b'').istitle()) self.assertFalse(self.marshal(b'a').istitle()) - self.assert_(self.marshal(b'A').istitle()) + self.assertTrue(self.marshal(b'A').istitle()) self.assertFalse(self.marshal(b'\n').istitle()) - self.assert_(self.marshal(b'A Titlecased Line').istitle()) - self.assert_(self.marshal(b'A\nTitlecased Line').istitle()) - self.assert_(self.marshal(b'A Titlecased, Line').istitle()) + self.assertTrue(self.marshal(b'A Titlecased Line').istitle()) + self.assertTrue(self.marshal(b'A\nTitlecased Line').istitle()) + self.assertTrue(self.marshal(b'A Titlecased, Line').istitle()) self.assertFalse(self.marshal(b'Not a capitalized String').istitle()) self.assertFalse(self.marshal(b'Not\ta Titlecase String').istitle()) self.assertFalse(self.marshal(b'Not--a Titlecase String').istitle()) @@ -50,31 +50,31 @@ class MixinBytesBufferCommonTests(object): def test_isspace(self): self.assertFalse(self.marshal(b'').isspace()) self.assertFalse(self.marshal(b'a').isspace()) - self.assert_(self.marshal(b' ').isspace()) - self.assert_(self.marshal(b'\t').isspace()) - self.assert_(self.marshal(b'\r').isspace()) - self.assert_(self.marshal(b'\n').isspace()) - self.assert_(self.marshal(b' \t\r\n').isspace()) + self.assertTrue(self.marshal(b' ').isspace()) + self.assertTrue(self.marshal(b'\t').isspace()) + self.assertTrue(self.marshal(b'\r').isspace()) + self.assertTrue(self.marshal(b'\n').isspace()) + self.assertTrue(self.marshal(b' \t\r\n').isspace()) self.assertFalse(self.marshal(b' \t\r\na').isspace()) self.assertRaises(TypeError, self.marshal(b'abc').isspace, 42) def test_isalpha(self): self.assertFalse(self.marshal(b'').isalpha()) - self.assert_(self.marshal(b'a').isalpha()) - self.assert_(self.marshal(b'A').isalpha()) + self.assertTrue(self.marshal(b'a').isalpha()) + self.assertTrue(self.marshal(b'A').isalpha()) self.assertFalse(self.marshal(b'\n').isalpha()) - self.assert_(self.marshal(b'abc').isalpha()) + self.assertTrue(self.marshal(b'abc').isalpha()) self.assertFalse(self.marshal(b'aBc123').isalpha()) self.assertFalse(self.marshal(b'abc\n').isalpha()) self.assertRaises(TypeError, self.marshal(b'abc').isalpha, 42) def test_isalnum(self): self.assertFalse(self.marshal(b'').isalnum()) - self.assert_(self.marshal(b'a').isalnum()) - self.assert_(self.marshal(b'A').isalnum()) + self.assertTrue(self.marshal(b'a').isalnum()) + self.assertTrue(self.marshal(b'A').isalnum()) self.assertFalse(self.marshal(b'\n').isalnum()) - self.assert_(self.marshal(b'123abc456').isalnum()) - self.assert_(self.marshal(b'a1b3c').isalnum()) + self.assertTrue(self.marshal(b'123abc456').isalnum()) + self.assertTrue(self.marshal(b'a1b3c').isalnum()) self.assertFalse(self.marshal(b'aBc000 ').isalnum()) self.assertFalse(self.marshal(b'abc\n').isalnum()) self.assertRaises(TypeError, self.marshal(b'abc').isalnum, 42) @@ -82,8 +82,8 @@ class MixinBytesBufferCommonTests(object): def test_isdigit(self): self.assertFalse(self.marshal(b'').isdigit()) self.assertFalse(self.marshal(b'a').isdigit()) - self.assert_(self.marshal(b'0').isdigit()) - self.assert_(self.marshal(b'0123456789').isdigit()) + self.assertTrue(self.marshal(b'0').isdigit()) + self.assertTrue(self.marshal(b'0123456789').isdigit()) self.assertFalse(self.marshal(b'0123456789a').isdigit()) self.assertRaises(TypeError, self.marshal(b'abc').isdigit, 42) diff --git a/Lib/test/fork_wait.py b/Lib/test/fork_wait.py index 533c0c2..1caab1c 100644 --- a/Lib/test/fork_wait.py +++ b/Lib/test/fork_wait.py @@ -40,8 +40,8 @@ class ForkWait(unittest.TestCase): break time.sleep(2 * SHORTSLEEP) - self.assertEquals(spid, cpid) - self.assertEquals(status, 0, "cause = %d, exit = %d" % (status&0xff, status>>8)) + self.assertEqual(spid, cpid) + self.assertEqual(status, 0, "cause = %d, exit = %d" % (status&0xff, status>>8)) def test_wait(self): for i in range(NUM_THREADS): @@ -50,7 +50,7 @@ class ForkWait(unittest.TestCase): time.sleep(LONGSLEEP) a = sorted(self.alive.keys()) - self.assertEquals(a, list(range(NUM_THREADS))) + self.assertEqual(a, list(range(NUM_THREADS))) prefork_lives = self.alive.copy() diff --git a/Lib/test/list_tests.py b/Lib/test/list_tests.py index 12f4e8f..e3a7845 100644 --- a/Lib/test/list_tests.py +++ b/Lib/test/list_tests.py @@ -337,7 +337,7 @@ class CommonTest(seq_tests.CommonTest): self.assertRaises(BadExc, d.remove, 'c') for x, y in zip(d, e): # verify that original order and values are retained. - self.assert_(x is y) + self.assertIs(x, y) def test_count(self): a = self.type2test([0, 1, 2])*3 @@ -482,7 +482,7 @@ class CommonTest(seq_tests.CommonTest): u = self.type2test([0, 1]) u2 = u u += [2, 3] - self.assert_(u is u2) + self.assertIs(u, u2) u = self.type2test("spam") u += "eggs" diff --git a/Lib/test/outstanding_bugs.py b/Lib/test/outstanding_bugs.py index 9e4784c..0849ee5 100644 --- a/Lib/test/outstanding_bugs.py +++ b/Lib/test/outstanding_bugs.py @@ -35,7 +35,7 @@ class TextIOWrapperTest(unittest.TestCase): if not c: break reads += c - self.assertEquals(reads, self.normalized) + self.assertEqual(reads, self.normalized) def test_issue1395_2(self): txt = io.TextIOWrapper(io.BytesIO(self.testdata), encoding="ASCII") @@ -47,7 +47,7 @@ class TextIOWrapperTest(unittest.TestCase): if not c: break reads += c - self.assertEquals(reads, self.normalized) + self.assertEqual(reads, self.normalized) def test_issue1395_3(self): txt = io.TextIOWrapper(io.BytesIO(self.testdata), encoding="ASCII") @@ -58,7 +58,7 @@ class TextIOWrapperTest(unittest.TestCase): reads += txt.readline() reads += txt.readline() reads += txt.readline() - self.assertEquals(reads, self.normalized) + self.assertEqual(reads, self.normalized) def test_issue1395_4(self): txt = io.TextIOWrapper(io.BytesIO(self.testdata), encoding="ASCII") @@ -66,7 +66,7 @@ class TextIOWrapperTest(unittest.TestCase): reads = txt.read(4) reads += txt.read() - self.assertEquals(reads, self.normalized) + self.assertEqual(reads, self.normalized) def test_issue1395_5(self): txt = io.TextIOWrapper(io.BytesIO(self.testdata), encoding="ASCII") @@ -76,7 +76,7 @@ class TextIOWrapperTest(unittest.TestCase): pos = txt.tell() txt.seek(0) txt.seek(pos) - self.assertEquals(txt.read(4), "BBB\n") + self.assertEqual(txt.read(4), "BBB\n") diff --git a/Lib/test/pickletester.py b/Lib/test/pickletester.py index 7645b54..3ae7def 100644 --- a/Lib/test/pickletester.py +++ b/Lib/test/pickletester.py @@ -579,7 +579,7 @@ class AbstractPickleTests(unittest.TestCase): def test_get(self): self.assertRaises(KeyError, self.loads, b'g0\np0') - self.assertEquals(self.loads(b'((Kdtp0\nh\x00l.))'), [(100,), (100,)]) + self.assertEqual(self.loads(b'((Kdtp0\nh\x00l.))'), [(100,), (100,)]) def test_insecure_strings(self): # XXX Some of these tests are temporarily disabled diff --git a/Lib/test/seq_tests.py b/Lib/test/seq_tests.py index d181e19..f655c29 100644 --- a/Lib/test/seq_tests.py +++ b/Lib/test/seq_tests.py @@ -131,8 +131,8 @@ class CommonTest(unittest.TestCase): self.assertRaises(ZeroDivisionError, self.type2test, IterGenExc(s)) def test_truth(self): - self.assert_(not self.type2test()) - self.assert_(self.type2test([42])) + self.assertFalse(self.type2test()) + self.assertTrue(self.type2test([42])) def test_getitem(self): u = self.type2test([0, 1, 2, 3, 4]) @@ -268,7 +268,7 @@ class CommonTest(unittest.TestCase): pass u3 = subclass([0, 1]) self.assertEqual(u3, u3*1) - self.assert_(u3 is not u3*1) + self.assertIsNot(u3, u3*1) def test_iadd(self): u = self.type2test([0, 1]) diff --git a/Lib/test/string_tests.py b/Lib/test/string_tests.py index 4c6515b..1cc36d8 100644 --- a/Lib/test/string_tests.py +++ b/Lib/test/string_tests.py @@ -67,7 +67,7 @@ class BaseTest(unittest.TestCase): else: obj = subtype(obj) realresult = getattr(obj, methodname)(*args) - self.assert_(obj is not realresult) + self.assertIsNot(obj, realresult) # check that obj.method(*args) raises exc def checkraises(self, exc, obj, methodname, *args): @@ -1197,34 +1197,34 @@ class MixinStrUnicodeTest: pass s1 = subclass("abcd") s2 = t().join([s1]) - self.assert_(s1 is not s2) - self.assert_(type(s2) is t) + self.assertIsNot(s1, s2) + self.assertIs(type(s2), t) s1 = t("abcd") s2 = t().join([s1]) - self.assert_(s1 is s2) + self.assertIs(s1, s2) # Should also test mixed-type join. if t is str: s1 = subclass("abcd") s2 = "".join([s1]) - self.assert_(s1 is not s2) - self.assert_(type(s2) is t) + self.assertIsNot(s1, s2) + self.assertIs(type(s2), t) s1 = t("abcd") s2 = "".join([s1]) - self.assert_(s1 is s2) + self.assertIs(s1, s2) ## elif t is str8: ## s1 = subclass("abcd") ## s2 = "".join([s1]) -## self.assert_(s1 is not s2) -## self.assert_(type(s2) is str) # promotes! +## self.assertIsNot(s1, s2) +## self.assertIs(type(s2), str) # promotes! ## s1 = t("abcd") ## s2 = "".join([s1]) -## self.assert_(s1 is not s2) -## self.assert_(type(s2) is str) # promotes! +## self.assertIsNot(s1, s2) +## self.assertIs(type(s2), str) # promotes! else: self.fail("unexpected type for MixinStrUnicodeTest %r" % t) diff --git a/Lib/test/test__locale.py b/Lib/test/test__locale.py index cbb97fe..3fadb57 100644 --- a/Lib/test/test__locale.py +++ b/Lib/test/test__locale.py @@ -59,7 +59,7 @@ class _LocaleTests(unittest.TestCase): known_value = known_numerics.get(used_locale, ('', ''))[data_type == 'thousands_sep'] if known_value and calc_value: - self.assertEquals(calc_value, known_value, + self.assertEqual(calc_value, known_value, self.lc_numeric_err_msg % ( calc_value, known_value, calc_type, data_type, set_locale, @@ -107,7 +107,7 @@ class _LocaleTests(unittest.TestCase): set_locale = setlocale(LC_NUMERIC) except Error: set_locale = "<not able to determine>" - self.assertEquals(nl_radixchar, li_radixchar, + self.assertEqual(nl_radixchar, li_radixchar, "%s (nl_langinfo) != %s (localeconv) " "(set to %s, using %s)" % ( nl_radixchar, li_radixchar, @@ -127,9 +127,9 @@ class _LocaleTests(unittest.TestCase): if loc == 'eu_ES' and localeconv()['decimal_point'] == "' ": continue - self.assertEquals(int(eval('3.14') * 100), 314, + self.assertEqual(int(eval('3.14') * 100), 314, "using eval('3.14') failed for %s" % loc) - self.assertEquals(int(float('3.14') * 100), 314, + self.assertEqual(int(float('3.14') * 100), 314, "using float('3.14') failed for %s" % loc) if localeconv()['decimal_point'] != '.': self.assertRaises(ValueError, float, diff --git a/Lib/test/test_argparse.py b/Lib/test/test_argparse.py index 2f2dd4d..7e76237 100644 --- a/Lib/test/test_argparse.py +++ b/Lib/test/test_argparse.py @@ -2698,18 +2698,18 @@ class TestNamespaceContainsSimple(TestCase): def test_empty(self): ns = argparse.Namespace() - self.assertEquals('' in ns, False) - self.assertEquals('' not in ns, True) - self.assertEquals('x' in ns, False) + self.assertEqual('' in ns, False) + self.assertEqual('' not in ns, True) + self.assertEqual('x' in ns, False) def test_non_empty(self): ns = argparse.Namespace(x=1, y=2) - self.assertEquals('x' in ns, True) - self.assertEquals('x' not in ns, False) - self.assertEquals('y' in ns, True) - self.assertEquals('' in ns, False) - self.assertEquals('xx' in ns, False) - self.assertEquals('z' in ns, False) + self.assertEqual('x' in ns, True) + self.assertEqual('x' not in ns, False) + self.assertEqual('y' in ns, True) + self.assertEqual('' in ns, False) + self.assertEqual('xx' in ns, False) + self.assertEqual('z' in ns, False) # ===================== # Help formatting tests diff --git a/Lib/test/test_array.py b/Lib/test/test_array.py index d7b4fa8..1cce991 100755 --- a/Lib/test/test_array.py +++ b/Lib/test/test_array.py @@ -238,9 +238,9 @@ class BaseTest(unittest.TestCase): def test_reduce_ex(self): a = array.array(self.typecode, self.example) for protocol in range(3): - self.assert_(a.__reduce_ex__(protocol)[0] is array.array) + self.assertIs(a.__reduce_ex__(protocol)[0], array.array) for protocol in range(3, pickle.HIGHEST_PROTOCOL): - self.assert_(a.__reduce_ex__(protocol)[0] is array_reconstructor) + self.assertIs(a.__reduce_ex__(protocol)[0], array_reconstructor) def test_pickle(self): for protocol in range(pickle.HIGHEST_PROTOCOL + 1): @@ -785,11 +785,11 @@ class BaseTest(unittest.TestCase): data.reverse() L[start:stop:step] = data a[start:stop:step] = array.array(self.typecode, data) - self.assertEquals(a, array.array(self.typecode, L)) + self.assertEqual(a, array.array(self.typecode, L)) del L[start:stop:step] del a[start:stop:step] - self.assertEquals(a, array.array(self.typecode, L)) + self.assertEqual(a, array.array(self.typecode, L)) def test_index(self): example = 2*self.example diff --git a/Lib/test/test_ast.py b/Lib/test/test_ast.py index 75af646..34456bc 100644 --- a/Lib/test/test_ast.py +++ b/Lib/test/test_ast.py @@ -141,7 +141,7 @@ class AST_Tests(unittest.TestCase): (eval_tests, eval_results, "eval")): for i, o in zip(input, output): ast_tree = compile(i, "?", kind, ast.PyCF_ONLY_AST) - self.assertEquals(to_tuple(ast_tree), o) + self.assertEqual(to_tuple(ast_tree), o) self._assertTrueorder(ast_tree, (0, 0)) def test_slice(self): @@ -164,20 +164,20 @@ class AST_Tests(unittest.TestCase): def test_nodeclasses(self): x = ast.BinOp(1, 2, 3, lineno=0) - self.assertEquals(x.left, 1) - self.assertEquals(x.op, 2) - self.assertEquals(x.right, 3) - self.assertEquals(x.lineno, 0) + self.assertEqual(x.left, 1) + self.assertEqual(x.op, 2) + self.assertEqual(x.right, 3) + self.assertEqual(x.lineno, 0) # node raises exception when not given enough arguments self.assertRaises(TypeError, ast.BinOp, 1, 2) # can set attributes through kwargs too x = ast.BinOp(left=1, op=2, right=3, lineno=0) - self.assertEquals(x.left, 1) - self.assertEquals(x.op, 2) - self.assertEquals(x.right, 3) - self.assertEquals(x.lineno, 0) + self.assertEqual(x.left, 1) + self.assertEqual(x.op, 2) + self.assertEqual(x.right, 3) + self.assertEqual(x.lineno, 0) # this used to fail because Sub._fields was None x = ast.Sub() @@ -195,7 +195,7 @@ class AST_Tests(unittest.TestCase): for protocol in protocols: for ast in (compile(i, "?", "exec", 0x400) for i in exec_tests): ast2 = mod.loads(mod.dumps(ast, protocol)) - self.assertEquals(to_tuple(ast2), to_tuple(ast)) + self.assertEqual(to_tuple(ast2), to_tuple(ast)) def test_invalid_sum(self): pos = dict(lineno=2, col_offset=3) diff --git a/Lib/test/test_augassign.py b/Lib/test/test_augassign.py index 3305308..9a59c58 100644 --- a/Lib/test/test_augassign.py +++ b/Lib/test/test_augassign.py @@ -17,7 +17,7 @@ class AugAssignTest(unittest.TestCase): x |= 5 x ^= 1 x /= 2 - self.assertEquals(x, 3.0) + self.assertEqual(x, 3.0) def test_with_unpacking(self): self.assertRaises(SyntaxError, compile, "x, b += 3", "<test>", "exec") @@ -34,7 +34,7 @@ class AugAssignTest(unittest.TestCase): x[0] |= 5 x[0] ^= 1 x[0] /= 2 - self.assertEquals(x[0], 3.0) + self.assertEqual(x[0], 3.0) def testInDict(self): x = {0: 2} @@ -48,21 +48,21 @@ class AugAssignTest(unittest.TestCase): x[0] |= 5 x[0] ^= 1 x[0] /= 2 - self.assertEquals(x[0], 3.0) + self.assertEqual(x[0], 3.0) def testSequences(self): x = [1,2] x += [3,4] x *= 2 - self.assertEquals(x, [1, 2, 3, 4, 1, 2, 3, 4]) + self.assertEqual(x, [1, 2, 3, 4, 1, 2, 3, 4]) x = [1, 2, 3] y = x x[1:2] *= 2 y[1:2] += [1] - self.assertEquals(x, [1, 2, 1, 2, 3]) + self.assertEqual(x, [1, 2, 1, 2, 3]) self.assertTrue(x is y) def testCustomMethods1(self): @@ -90,14 +90,14 @@ class AugAssignTest(unittest.TestCase): self.assertIsInstance(x, aug_test) self.assertTrue(y is not x) - self.assertEquals(x.val, 11) + self.assertEqual(x.val, 11) x = aug_test2(2) y = x x += 10 self.assertTrue(y is x) - self.assertEquals(x.val, 12) + self.assertEqual(x.val, 12) x = aug_test3(3) y = x @@ -105,7 +105,7 @@ class AugAssignTest(unittest.TestCase): self.assertIsInstance(x, aug_test3) self.assertTrue(y is not x) - self.assertEquals(x.val, 13) + self.assertEqual(x.val, 13) def testCustomMethods2(test_self): @@ -269,7 +269,7 @@ class AugAssignTest(unittest.TestCase): 1 << x x <<= 1 - test_self.assertEquals(output, '''\ + test_self.assertEqual(output, '''\ __add__ called __radd__ called __iadd__ called diff --git a/Lib/test/test_base64.py b/Lib/test/test_base64.py index 228a0fb..93c623c 100644 --- a/Lib/test/test_base64.py +++ b/Lib/test/test_base64.py @@ -6,7 +6,7 @@ import sys import subprocess - + class LegacyBase64TestCase(unittest.TestCase): def test_encodebytes(self): eq = self.assertEqual @@ -58,7 +58,7 @@ class LegacyBase64TestCase(unittest.TestCase): base64.decode(infp, outfp) self.assertEqual(outfp.getvalue(), b'www.python.org') - + class BaseXYTestCase(unittest.TestCase): def test_b64encode(self): eq = self.assertEqual @@ -153,7 +153,7 @@ class BaseXYTestCase(unittest.TestCase): (b'!', b''), (b'YWJj\nYWI=', b'abcab')) for bstr, res in tests: - self.assertEquals(base64.b64decode(bstr), res) + self.assertEqual(base64.b64decode(bstr), res) with self.assertRaises(binascii.Error): base64.b64decode(bstr, validate=True) @@ -225,7 +225,7 @@ class BaseXYTestCase(unittest.TestCase): self.assertTrue(issubclass(binascii.Error, ValueError)) - + class TestMain(unittest.TestCase): def get_output(self, *args, **options): args = (sys.executable, '-m', 'base64') + args @@ -244,20 +244,20 @@ class TestMain(unittest.TestCase): fp.write(b'a\xffb\n') output = self.get_output('-e', support.TESTFN) - self.assertEquals(output.rstrip(), b'Yf9iCg==') + self.assertEqual(output.rstrip(), b'Yf9iCg==') with open(support.TESTFN, 'rb') as fp: output = self.get_output('-e', stdin=fp) - self.assertEquals(output.rstrip(), b'Yf9iCg==') + self.assertEqual(output.rstrip(), b'Yf9iCg==') def test_decode(self): with open(support.TESTFN, 'wb') as fp: fp.write(b'Yf9iCg==') output = self.get_output('-d', support.TESTFN) - self.assertEquals(output.rstrip(), b'a\xffb') + self.assertEqual(output.rstrip(), b'a\xffb') + - def test_main(): support.run_unittest(__name__) diff --git a/Lib/test/test_bigmem.py b/Lib/test/test_bigmem.py index c2357ee..e2b5521 100644 --- a/Lib/test/test_bigmem.py +++ b/Lib/test/test_bigmem.py @@ -13,7 +13,7 @@ import functools # doesn't release the old 's' (if it exists) until well after its new # value has been created. Use 'del s' before the create_largestring call. # -# - Do *not* compare large objects using assertEquals or similar. It's a +# - Do *not* compare large objects using assertEqual or similar. It's a # lengthy operation and the errormessage will be utterly useless due to # its size. To make sure whether a result has the right contents, better # to use the strip or count methods, or compare meaningful slices. @@ -48,32 +48,32 @@ class BaseStrTest: SUBSTR = self.from_latin1(' abc def ghi') s = _('-') * size + SUBSTR caps = s.capitalize() - self.assertEquals(caps[-len(SUBSTR):], + self.assertEqual(caps[-len(SUBSTR):], SUBSTR.capitalize()) - self.assertEquals(caps.lstrip(_('-')), SUBSTR) + self.assertEqual(caps.lstrip(_('-')), SUBSTR) @bigmemtest(minsize=_2G + 10, memuse=1) def test_center(self, size): SUBSTR = self.from_latin1(' abc def ghi') s = SUBSTR.center(size) - self.assertEquals(len(s), size) + self.assertEqual(len(s), size) lpadsize = rpadsize = (len(s) - len(SUBSTR)) // 2 if len(s) % 2: lpadsize += 1 - self.assertEquals(s[lpadsize:-rpadsize], SUBSTR) - self.assertEquals(s.strip(), SUBSTR.strip()) + self.assertEqual(s[lpadsize:-rpadsize], SUBSTR) + self.assertEqual(s.strip(), SUBSTR.strip()) @bigmemtest(minsize=_2G, memuse=2) def test_count(self, size): _ = self.from_latin1 SUBSTR = _(' abc def ghi') s = _('.') * size + SUBSTR - self.assertEquals(s.count(_('.')), size) + self.assertEqual(s.count(_('.')), size) s += _('.') - self.assertEquals(s.count(_('.')), size + 1) - self.assertEquals(s.count(_(' ')), 3) - self.assertEquals(s.count(_('i')), 1) - self.assertEquals(s.count(_('j')), 0) + self.assertEqual(s.count(_('.')), size + 1) + self.assertEqual(s.count(_(' ')), 3) + self.assertEqual(s.count(_('i')), 1) + self.assertEqual(s.count(_('j')), 0) @bigmemtest(minsize=_2G, memuse=2) def test_endswith(self, size): @@ -92,13 +92,13 @@ class BaseStrTest: _ = self.from_latin1 s = _('-') * size tabsize = 8 - self.assertEquals(s.expandtabs(), s) + self.assertEqual(s.expandtabs(), s) del s slen, remainder = divmod(size, tabsize) s = _(' \t') * slen s = s.expandtabs(tabsize) - self.assertEquals(len(s), size - remainder) - self.assertEquals(len(s.strip(_(' '))), 0) + self.assertEqual(len(s), size - remainder) + self.assertEqual(len(s.strip(_(' '))), 0) @bigmemtest(minsize=_2G, memuse=2) def test_find(self, size): @@ -106,16 +106,16 @@ class BaseStrTest: SUBSTR = _(' abc def ghi') sublen = len(SUBSTR) s = _('').join([SUBSTR, _('-') * size, SUBSTR]) - self.assertEquals(s.find(_(' ')), 0) - self.assertEquals(s.find(SUBSTR), 0) - self.assertEquals(s.find(_(' '), sublen), sublen + size) - self.assertEquals(s.find(SUBSTR, len(SUBSTR)), sublen + size) - self.assertEquals(s.find(_('i')), SUBSTR.find(_('i'))) - self.assertEquals(s.find(_('i'), sublen), + self.assertEqual(s.find(_(' ')), 0) + self.assertEqual(s.find(SUBSTR), 0) + self.assertEqual(s.find(_(' '), sublen), sublen + size) + self.assertEqual(s.find(SUBSTR, len(SUBSTR)), sublen + size) + self.assertEqual(s.find(_('i')), SUBSTR.find(_('i'))) + self.assertEqual(s.find(_('i'), sublen), sublen + size + SUBSTR.find(_('i'))) - self.assertEquals(s.find(_('i'), size), + self.assertEqual(s.find(_('i'), size), sublen + size + SUBSTR.find(_('i'))) - self.assertEquals(s.find(_('j')), -1) + self.assertEqual(s.find(_('j')), -1) @bigmemtest(minsize=_2G, memuse=2) def test_index(self, size): @@ -123,14 +123,14 @@ class BaseStrTest: SUBSTR = _(' abc def ghi') sublen = len(SUBSTR) s = _('').join([SUBSTR, _('-') * size, SUBSTR]) - self.assertEquals(s.index(_(' ')), 0) - self.assertEquals(s.index(SUBSTR), 0) - self.assertEquals(s.index(_(' '), sublen), sublen + size) - self.assertEquals(s.index(SUBSTR, sublen), sublen + size) - self.assertEquals(s.index(_('i')), SUBSTR.index(_('i'))) - self.assertEquals(s.index(_('i'), sublen), + self.assertEqual(s.index(_(' ')), 0) + self.assertEqual(s.index(SUBSTR), 0) + self.assertEqual(s.index(_(' '), sublen), sublen + size) + self.assertEqual(s.index(SUBSTR, sublen), sublen + size) + self.assertEqual(s.index(_('i')), SUBSTR.index(_('i'))) + self.assertEqual(s.index(_('i'), sublen), sublen + size + SUBSTR.index(_('i'))) - self.assertEquals(s.index(_('i'), size), + self.assertEqual(s.index(_('i'), size), sublen + size + SUBSTR.index(_('i'))) self.assertRaises(ValueError, s.index, _('j')) @@ -209,8 +209,8 @@ class BaseStrTest: _ = self.from_latin1 s = _('A') * size x = s.join([_('aaaaa'), _('bbbbb')]) - self.assertEquals(x.count(_('a')), 5) - self.assertEquals(x.count(_('b')), 5) + self.assertEqual(x.count(_('a')), 5) + self.assertEqual(x.count(_('b')), 5) self.assertTrue(x.startswith(_('aaaaaA'))) self.assertTrue(x.endswith(_('Abbbbb'))) @@ -220,27 +220,27 @@ class BaseStrTest: SUBSTR = _(' abc def ghi') s = SUBSTR.ljust(size) self.assertTrue(s.startswith(SUBSTR + _(' '))) - self.assertEquals(len(s), size) - self.assertEquals(s.strip(), SUBSTR.strip()) + self.assertEqual(len(s), size) + self.assertEqual(s.strip(), SUBSTR.strip()) @bigmemtest(minsize=_2G + 10, memuse=2) def test_lower(self, size): _ = self.from_latin1 s = _('A') * size s = s.lower() - self.assertEquals(len(s), size) - self.assertEquals(s.count(_('a')), size) + self.assertEqual(len(s), size) + self.assertEqual(s.count(_('a')), size) @bigmemtest(minsize=_2G + 10, memuse=1) def test_lstrip(self, size): _ = self.from_latin1 SUBSTR = _('abc def ghi') s = SUBSTR.rjust(size) - self.assertEquals(len(s), size) - self.assertEquals(s.lstrip(), SUBSTR.lstrip()) + self.assertEqual(len(s), size) + self.assertEqual(s.lstrip(), SUBSTR.lstrip()) del s s = SUBSTR.ljust(size) - self.assertEquals(len(s), size) + self.assertEqual(len(s), size) # Type-specific optimization if isinstance(s, (str, bytes)): stripped = s.lstrip() @@ -252,12 +252,12 @@ class BaseStrTest: replacement = _('a') s = _(' ') * size s = s.replace(_(' '), replacement) - self.assertEquals(len(s), size) - self.assertEquals(s.count(replacement), size) + self.assertEqual(len(s), size) + self.assertEqual(s.count(replacement), size) s = s.replace(replacement, _(' '), size - 4) - self.assertEquals(len(s), size) - self.assertEquals(s.count(replacement), 4) - self.assertEquals(s[-10:], _(' aaaa')) + self.assertEqual(len(s), size) + self.assertEqual(s.count(replacement), 4) + self.assertEqual(s[-10:], _(' aaaa')) @bigmemtest(minsize=_2G, memuse=2) def test_rfind(self, size): @@ -265,15 +265,15 @@ class BaseStrTest: SUBSTR = _(' abc def ghi') sublen = len(SUBSTR) s = _('').join([SUBSTR, _('-') * size, SUBSTR]) - self.assertEquals(s.rfind(_(' ')), sublen + size + SUBSTR.rfind(_(' '))) - self.assertEquals(s.rfind(SUBSTR), sublen + size) - self.assertEquals(s.rfind(_(' '), 0, size), SUBSTR.rfind(_(' '))) - self.assertEquals(s.rfind(SUBSTR, 0, sublen + size), 0) - self.assertEquals(s.rfind(_('i')), sublen + size + SUBSTR.rfind(_('i'))) - self.assertEquals(s.rfind(_('i'), 0, sublen), SUBSTR.rfind(_('i'))) - self.assertEquals(s.rfind(_('i'), 0, sublen + size), - SUBSTR.rfind(_('i'))) - self.assertEquals(s.rfind(_('j')), -1) + self.assertEqual(s.rfind(_(' ')), sublen + size + SUBSTR.rfind(_(' '))) + self.assertEqual(s.rfind(SUBSTR), sublen + size) + self.assertEqual(s.rfind(_(' '), 0, size), SUBSTR.rfind(_(' '))) + self.assertEqual(s.rfind(SUBSTR, 0, sublen + size), 0) + self.assertEqual(s.rfind(_('i')), sublen + size + SUBSTR.rfind(_('i'))) + self.assertEqual(s.rfind(_('i'), 0, sublen), SUBSTR.rfind(_('i'))) + self.assertEqual(s.rfind(_('i'), 0, sublen + size), + SUBSTR.rfind(_('i'))) + self.assertEqual(s.rfind(_('j')), -1) @bigmemtest(minsize=_2G, memuse=2) def test_rindex(self, size): @@ -281,17 +281,17 @@ class BaseStrTest: SUBSTR = _(' abc def ghi') sublen = len(SUBSTR) s = _('').join([SUBSTR, _('-') * size, SUBSTR]) - self.assertEquals(s.rindex(_(' ')), - sublen + size + SUBSTR.rindex(_(' '))) - self.assertEquals(s.rindex(SUBSTR), sublen + size) - self.assertEquals(s.rindex(_(' '), 0, sublen + size - 1), - SUBSTR.rindex(_(' '))) - self.assertEquals(s.rindex(SUBSTR, 0, sublen + size), 0) - self.assertEquals(s.rindex(_('i')), - sublen + size + SUBSTR.rindex(_('i'))) - self.assertEquals(s.rindex(_('i'), 0, sublen), SUBSTR.rindex(_('i'))) - self.assertEquals(s.rindex(_('i'), 0, sublen + size), - SUBSTR.rindex(_('i'))) + self.assertEqual(s.rindex(_(' ')), + sublen + size + SUBSTR.rindex(_(' '))) + self.assertEqual(s.rindex(SUBSTR), sublen + size) + self.assertEqual(s.rindex(_(' '), 0, sublen + size - 1), + SUBSTR.rindex(_(' '))) + self.assertEqual(s.rindex(SUBSTR, 0, sublen + size), 0) + self.assertEqual(s.rindex(_('i')), + sublen + size + SUBSTR.rindex(_('i'))) + self.assertEqual(s.rindex(_('i'), 0, sublen), SUBSTR.rindex(_('i'))) + self.assertEqual(s.rindex(_('i'), 0, sublen + size), + SUBSTR.rindex(_('i'))) self.assertRaises(ValueError, s.rindex, _('j')) @bigmemtest(minsize=_2G + 10, memuse=1) @@ -300,19 +300,19 @@ class BaseStrTest: SUBSTR = _(' abc def ghi') s = SUBSTR.ljust(size) self.assertTrue(s.startswith(SUBSTR + _(' '))) - self.assertEquals(len(s), size) - self.assertEquals(s.strip(), SUBSTR.strip()) + self.assertEqual(len(s), size) + self.assertEqual(s.strip(), SUBSTR.strip()) @bigmemtest(minsize=_2G + 10, memuse=1) def test_rstrip(self, size): _ = self.from_latin1 SUBSTR = _(' abc def ghi') s = SUBSTR.ljust(size) - self.assertEquals(len(s), size) - self.assertEquals(s.rstrip(), SUBSTR.rstrip()) + self.assertEqual(len(s), size) + self.assertEqual(s.rstrip(), SUBSTR.rstrip()) del s s = SUBSTR.rjust(size) - self.assertEquals(len(s), size) + self.assertEqual(len(s), size) # Type-specific optimization if isinstance(s, (str, bytes)): stripped = s.rstrip() @@ -330,16 +330,16 @@ class BaseStrTest: SUBSTR = _('a') + _(' ') * chunksize s = SUBSTR * chunksize l = s.split() - self.assertEquals(len(l), chunksize) + self.assertEqual(len(l), chunksize) expected = _('a') for item in l: - self.assertEquals(item, expected) + self.assertEqual(item, expected) del l l = s.split(_('a')) - self.assertEquals(len(l), chunksize + 1) + self.assertEqual(len(l), chunksize + 1) expected = _(' ') * chunksize for item in filter(None, l): - self.assertEquals(item, expected) + self.assertEqual(item, expected) # Allocates a string of twice size (and briefly two) and a list of # size. Because of internal affairs, the s.split() call produces a @@ -352,12 +352,12 @@ class BaseStrTest: _ = self.from_latin1 s = _(' a') * size + _(' ') l = s.split() - self.assertEquals(len(l), size) - self.assertEquals(set(l), set([_('a')])) + self.assertEqual(len(l), size) + self.assertEqual(set(l), set([_('a')])) del l l = s.split(_('a')) - self.assertEquals(len(l), size + 1) - self.assertEquals(set(l), set([_(' ')])) + self.assertEqual(len(l), size + 1) + self.assertEqual(set(l), set([_(' ')])) @bigmemtest(minsize=_2G, memuse=2.1) def test_splitlines(self, size): @@ -368,10 +368,10 @@ class BaseStrTest: SUBSTR = _(' ') * chunksize + _('\n') + _(' ') * chunksize + _('\r\n') s = SUBSTR * chunksize l = s.splitlines() - self.assertEquals(len(l), chunksize * 2) + self.assertEqual(len(l), chunksize * 2) expected = _(' ') * chunksize for item in l: - self.assertEquals(item, expected) + self.assertEqual(item, expected) @bigmemtest(minsize=_2G, memuse=2) def test_startswith(self, size): @@ -387,12 +387,12 @@ class BaseStrTest: _ = self.from_latin1 SUBSTR = _(' abc def ghi ') s = SUBSTR.rjust(size) - self.assertEquals(len(s), size) - self.assertEquals(s.strip(), SUBSTR.strip()) + self.assertEqual(len(s), size) + self.assertEqual(s.strip(), SUBSTR.strip()) del s s = SUBSTR.ljust(size) - self.assertEquals(len(s), size) - self.assertEquals(s.strip(), SUBSTR.strip()) + self.assertEqual(len(s), size) + self.assertEqual(s.strip(), SUBSTR.strip()) @bigmemtest(minsize=_2G, memuse=2) def test_swapcase(self, size): @@ -402,9 +402,9 @@ class BaseStrTest: repeats = size // sublen + 2 s = SUBSTR * repeats s = s.swapcase() - self.assertEquals(len(s), sublen * repeats) - self.assertEquals(s[:sublen * 3], SUBSTR.swapcase() * 3) - self.assertEquals(s[-sublen * 3:], SUBSTR.swapcase() * 3) + self.assertEqual(len(s), sublen * repeats) + self.assertEqual(s[:sublen * 3], SUBSTR.swapcase() * 3) + self.assertEqual(s[-sublen * 3:], SUBSTR.swapcase() * 3) @bigmemtest(minsize=_2G, memuse=2) def test_title(self, size): @@ -431,20 +431,20 @@ class BaseStrTest: repeats = size // sublen + 2 s = SUBSTR * repeats s = s.translate(trans) - self.assertEquals(len(s), repeats * sublen) - self.assertEquals(s[:sublen], SUBSTR.translate(trans)) - self.assertEquals(s[-sublen:], SUBSTR.translate(trans)) - self.assertEquals(s.count(_('.')), 0) - self.assertEquals(s.count(_('!')), repeats * 2) - self.assertEquals(s.count(_('z')), repeats * 3) + self.assertEqual(len(s), repeats * sublen) + self.assertEqual(s[:sublen], SUBSTR.translate(trans)) + self.assertEqual(s[-sublen:], SUBSTR.translate(trans)) + self.assertEqual(s.count(_('.')), 0) + self.assertEqual(s.count(_('!')), repeats * 2) + self.assertEqual(s.count(_('z')), repeats * 3) @bigmemtest(minsize=_2G + 5, memuse=2) def test_upper(self, size): _ = self.from_latin1 s = _('a') * size s = s.upper() - self.assertEquals(len(s), size) - self.assertEquals(s.count(_('A')), size) + self.assertEqual(len(s), size) + self.assertEqual(s.count(_('A')), size) @bigmemtest(minsize=_2G + 20, memuse=1) def test_zfill(self, size): @@ -453,8 +453,8 @@ class BaseStrTest: s = SUBSTR.zfill(size) self.assertTrue(s.endswith(_('0') + SUBSTR[1:])) self.assertTrue(s.startswith(_('-0'))) - self.assertEquals(len(s), size) - self.assertEquals(s.count(_('0')), size - len(SUBSTR)) + self.assertEqual(len(s), size) + self.assertEqual(s.count(_('0')), size - len(SUBSTR)) # This test is meaningful even with size < 2G, as long as the # doubled string is > 2G (but it tests more if both are > 2G :) @@ -462,10 +462,10 @@ class BaseStrTest: def test_concat(self, size): _ = self.from_latin1 s = _('.') * size - self.assertEquals(len(s), size) + self.assertEqual(len(s), size) s = s + s - self.assertEquals(len(s), size * 2) - self.assertEquals(s.count(_('.')), size * 2) + self.assertEqual(len(s), size * 2) + self.assertEqual(s.count(_('.')), size * 2) # This test is meaningful even with size < 2G, as long as the # repeated string is > 2G (but it tests more if both are > 2G :) @@ -473,10 +473,10 @@ class BaseStrTest: def test_repeat(self, size): _ = self.from_latin1 s = _('.') * size - self.assertEquals(len(s), size) + self.assertEqual(len(s), size) s = s * 2 - self.assertEquals(len(s), size * 2) - self.assertEquals(s.count(_('.')), size * 2) + self.assertEqual(len(s), size * 2) + self.assertEqual(s.count(_('.')), size * 2) @bigmemtest(minsize=_2G + 20, memuse=2) def test_slice_and_getitem(self, size): @@ -487,26 +487,26 @@ class BaseStrTest: stepsize = len(s) // 100 stepsize = stepsize - (stepsize % sublen) for i in range(0, len(s) - stepsize, stepsize): - self.assertEquals(s[i], SUBSTR[0]) - self.assertEquals(s[i:i + sublen], SUBSTR) - self.assertEquals(s[i:i + sublen:2], SUBSTR[::2]) + self.assertEqual(s[i], SUBSTR[0]) + self.assertEqual(s[i:i + sublen], SUBSTR) + self.assertEqual(s[i:i + sublen:2], SUBSTR[::2]) if i > 0: - self.assertEquals(s[i + sublen - 1:i - 1:-3], - SUBSTR[sublen::-3]) + self.assertEqual(s[i + sublen - 1:i - 1:-3], + SUBSTR[sublen::-3]) # Make sure we do some slicing and indexing near the end of the # string, too. - self.assertEquals(s[len(s) - 1], SUBSTR[-1]) - self.assertEquals(s[-1], SUBSTR[-1]) - self.assertEquals(s[len(s) - 10], SUBSTR[0]) - self.assertEquals(s[-sublen], SUBSTR[0]) - self.assertEquals(s[len(s):], _('')) - self.assertEquals(s[len(s) - 1:], SUBSTR[-1:]) - self.assertEquals(s[-1:], SUBSTR[-1:]) - self.assertEquals(s[len(s) - sublen:], SUBSTR) - self.assertEquals(s[-sublen:], SUBSTR) - self.assertEquals(len(s[:]), len(s)) - self.assertEquals(len(s[:len(s) - 5]), len(s) - 5) - self.assertEquals(len(s[5:-5]), len(s) - 10) + self.assertEqual(s[len(s) - 1], SUBSTR[-1]) + self.assertEqual(s[-1], SUBSTR[-1]) + self.assertEqual(s[len(s) - 10], SUBSTR[0]) + self.assertEqual(s[-sublen], SUBSTR[0]) + self.assertEqual(s[len(s):], _('')) + self.assertEqual(s[len(s) - 1:], SUBSTR[-1:]) + self.assertEqual(s[-1:], SUBSTR[-1:]) + self.assertEqual(s[len(s) - sublen:], SUBSTR) + self.assertEqual(s[-sublen:], SUBSTR) + self.assertEqual(len(s[:]), len(s)) + self.assertEqual(len(s[:len(s) - 5]), len(s) - 5) + self.assertEqual(len(s[5:-5]), len(s) - 10) self.assertRaises(IndexError, operator.getitem, s, len(s)) self.assertRaises(IndexError, operator.getitem, s, len(s) + 1) @@ -565,7 +565,7 @@ class StrTest(unittest.TestCase, BaseStrTest): expectedsize = size s = c * size - self.assertEquals(len(s.encode(enc)), expectedsize) + self.assertEqual(len(s.encode(enc)), expectedsize) def setUp(self): # HACK: adjust memory use of tests inherited from BaseStrTest @@ -632,7 +632,7 @@ class StrTest(unittest.TestCase, BaseStrTest): self.assertEqual(s, sf) del sf sf = '..%s..' % (s,) - self.assertEquals(len(sf), len(s) + 4) + self.assertEqual(len(sf), len(s) + 4) self.assertTrue(sf.startswith('..-')) self.assertTrue(sf.endswith('-..')) del s, sf @@ -642,18 +642,18 @@ class StrTest(unittest.TestCase, BaseStrTest): s = ''.join([edge, '%s', edge]) del edge s = s % '...' - self.assertEquals(len(s), size * 2 + 3) - self.assertEquals(s.count('.'), 3) - self.assertEquals(s.count('-'), size * 2) + self.assertEqual(len(s), size * 2 + 3) + self.assertEqual(s.count('.'), 3) + self.assertEqual(s.count('-'), size * 2) @bigmemtest(minsize=_2G + 10, memuse=character_size * 2) def test_repr_small(self, size): s = '-' * size s = repr(s) - self.assertEquals(len(s), size + 2) - self.assertEquals(s[0], "'") - self.assertEquals(s[-1], "'") - self.assertEquals(s.count('-'), size) + self.assertEqual(len(s), size + 2) + self.assertEqual(s[0], "'") + self.assertEqual(s[-1], "'") + self.assertEqual(s.count('-'), size) del s # repr() will create a string four times as large as this 'binary # string', but we don't want to allocate much more than twice @@ -661,21 +661,21 @@ class StrTest(unittest.TestCase, BaseStrTest): size = size // 5 * 2 s = '\x00' * size s = repr(s) - self.assertEquals(len(s), size * 4 + 2) - self.assertEquals(s[0], "'") - self.assertEquals(s[-1], "'") - self.assertEquals(s.count('\\'), size) - self.assertEquals(s.count('0'), size * 2) + self.assertEqual(len(s), size * 4 + 2) + self.assertEqual(s[0], "'") + self.assertEqual(s[-1], "'") + self.assertEqual(s.count('\\'), size) + self.assertEqual(s.count('0'), size * 2) @bigmemtest(minsize=_2G + 10, memuse=character_size * 5) def test_repr_large(self, size): s = '\x00' * size s = repr(s) - self.assertEquals(len(s), size * 4 + 2) - self.assertEquals(s[0], "'") - self.assertEquals(s[-1], "'") - self.assertEquals(s.count('\\'), size) - self.assertEquals(s.count('0'), size * 2) + self.assertEqual(len(s), size * 4 + 2) + self.assertEqual(s[0], "'") + self.assertEqual(s[-1], "'") + self.assertEqual(s.count('\\'), size) + self.assertEqual(s.count('0'), size * 2) @bigmemtest(minsize=2**32 / 5, memuse=character_size * 7) def test_unicode_repr(self, size): @@ -708,7 +708,7 @@ class BytesTest(unittest.TestCase, BaseStrTest): @bigmemtest(minsize=_2G + 2, memuse=1 + character_size) def test_decode(self, size): s = self.from_latin1('.') * size - self.assertEquals(len(s.decode('utf-8')), size) + self.assertEqual(len(s.decode('utf-8')), size) class BytearrayTest(unittest.TestCase, BaseStrTest): @@ -719,7 +719,7 @@ class BytearrayTest(unittest.TestCase, BaseStrTest): @bigmemtest(minsize=_2G + 2, memuse=1 + character_size) def test_decode(self, size): s = self.from_latin1('.') * size - self.assertEquals(len(s.decode('utf-8')), size) + self.assertEqual(len(s.decode('utf-8')), size) test_hash = None test_split_large = None @@ -754,9 +754,9 @@ class TupleTest(unittest.TestCase): # skipped, in verbose mode.) def basic_concat_test(self, size): t = ((),) * size - self.assertEquals(len(t), size) + self.assertEqual(len(t), size) t = t + t - self.assertEquals(len(t), size * 2) + self.assertEqual(len(t), size * 2) @bigmemtest(minsize=_2G // 2 + 2, memuse=24) def test_concat_small(self, size): @@ -769,7 +769,7 @@ class TupleTest(unittest.TestCase): @bigmemtest(minsize=_2G // 5 + 10, memuse=8 * 5) def test_contains(self, size): t = (1, 2, 3, 4, 5) * size - self.assertEquals(len(t), size * 5) + self.assertEqual(len(t), size * 5) self.assertIn(5, t) self.assertNotIn((1, 2, 3, 4, 5), t) self.assertNotIn(0, t) @@ -785,27 +785,27 @@ class TupleTest(unittest.TestCase): @bigmemtest(minsize=_2G + 10, memuse=8) def test_index_and_slice(self, size): t = (None,) * size - self.assertEquals(len(t), size) - self.assertEquals(t[-1], None) - self.assertEquals(t[5], None) - self.assertEquals(t[size - 1], None) + self.assertEqual(len(t), size) + self.assertEqual(t[-1], None) + self.assertEqual(t[5], None) + self.assertEqual(t[size - 1], None) self.assertRaises(IndexError, operator.getitem, t, size) - self.assertEquals(t[:5], (None,) * 5) - self.assertEquals(t[-5:], (None,) * 5) - self.assertEquals(t[20:25], (None,) * 5) - self.assertEquals(t[-25:-20], (None,) * 5) - self.assertEquals(t[size - 5:], (None,) * 5) - self.assertEquals(t[size - 5:size], (None,) * 5) - self.assertEquals(t[size - 6:size - 2], (None,) * 4) - self.assertEquals(t[size:size], ()) - self.assertEquals(t[size:size+5], ()) + self.assertEqual(t[:5], (None,) * 5) + self.assertEqual(t[-5:], (None,) * 5) + self.assertEqual(t[20:25], (None,) * 5) + self.assertEqual(t[-25:-20], (None,) * 5) + self.assertEqual(t[size - 5:], (None,) * 5) + self.assertEqual(t[size - 5:size], (None,) * 5) + self.assertEqual(t[size - 6:size - 2], (None,) * 4) + self.assertEqual(t[size:size], ()) + self.assertEqual(t[size:size+5], ()) # Like test_concat, split in two. def basic_test_repeat(self, size): t = ('',) * size - self.assertEquals(len(t), size) + self.assertEqual(len(t), size) t = t * 2 - self.assertEquals(len(t), size * 2) + self.assertEqual(len(t), size * 2) @bigmemtest(minsize=_2G // 2 + 2, memuse=24) def test_repeat_small(self, size): @@ -829,9 +829,9 @@ class TupleTest(unittest.TestCase): else: count = 0 for item in t: - self.assertEquals(item, count) + self.assertEqual(item, count) count += 1 - self.assertEquals(count, size) + self.assertEqual(count, size) @precisionbigmemtest(size=_1G - 25, memuse=9) def test_from_almost_2G_generator(self, size): @@ -840,9 +840,9 @@ class TupleTest(unittest.TestCase): t = tuple(range(size)) count = 0 for item in t: - self.assertEquals(item, count) + self.assertEqual(item, count) count += 1 - self.assertEquals(count, size) + self.assertEqual(count, size) except MemoryError: pass # acceptable, expected on 32-bit @@ -851,10 +851,10 @@ class TupleTest(unittest.TestCase): t = (0,) * size s = repr(t) # The repr of a tuple of 0's is exactly three times the tuple length. - self.assertEquals(len(s), size * 3) - self.assertEquals(s[:5], '(0, 0') - self.assertEquals(s[-5:], '0, 0)') - self.assertEquals(s.count('0'), size) + self.assertEqual(len(s), size * 3) + self.assertEqual(s[:5], '(0, 0') + self.assertEqual(s[-5:], '0, 0)') + self.assertEqual(s.count('0'), size) @bigmemtest(minsize=_2G // 3 + 2, memuse=8 + 3 * character_size) def test_repr_small(self, size): @@ -890,9 +890,9 @@ class ListTest(unittest.TestCase): # skipped, in verbose mode.) def basic_test_concat(self, size): l = [[]] * size - self.assertEquals(len(l), size) + self.assertEqual(len(l), size) l = l + l - self.assertEquals(len(l), size * 2) + self.assertEqual(len(l), size * 2) @bigmemtest(minsize=_2G // 2 + 2, memuse=24) def test_concat_small(self, size): @@ -905,7 +905,7 @@ class ListTest(unittest.TestCase): def basic_test_inplace_concat(self, size): l = [sys.stdout] * size l += l - self.assertEquals(len(l), size * 2) + self.assertEqual(len(l), size * 2) self.assertTrue(l[0] is l[-1]) self.assertTrue(l[size - 1] is l[size + 1]) @@ -920,7 +920,7 @@ class ListTest(unittest.TestCase): @bigmemtest(minsize=_2G // 5 + 10, memuse=8 * 5) def test_contains(self, size): l = [1, 2, 3, 4, 5] * size - self.assertEquals(len(l), size * 5) + self.assertEqual(len(l), size * 5) self.assertIn(5, l) self.assertNotIn([1, 2, 3, 4, 5], l) self.assertNotIn(0, l) @@ -933,66 +933,66 @@ class ListTest(unittest.TestCase): @bigmemtest(minsize=_2G + 10, memuse=8) def test_index_and_slice(self, size): l = [None] * size - self.assertEquals(len(l), size) - self.assertEquals(l[-1], None) - self.assertEquals(l[5], None) - self.assertEquals(l[size - 1], None) + self.assertEqual(len(l), size) + self.assertEqual(l[-1], None) + self.assertEqual(l[5], None) + self.assertEqual(l[size - 1], None) self.assertRaises(IndexError, operator.getitem, l, size) - self.assertEquals(l[:5], [None] * 5) - self.assertEquals(l[-5:], [None] * 5) - self.assertEquals(l[20:25], [None] * 5) - self.assertEquals(l[-25:-20], [None] * 5) - self.assertEquals(l[size - 5:], [None] * 5) - self.assertEquals(l[size - 5:size], [None] * 5) - self.assertEquals(l[size - 6:size - 2], [None] * 4) - self.assertEquals(l[size:size], []) - self.assertEquals(l[size:size+5], []) + self.assertEqual(l[:5], [None] * 5) + self.assertEqual(l[-5:], [None] * 5) + self.assertEqual(l[20:25], [None] * 5) + self.assertEqual(l[-25:-20], [None] * 5) + self.assertEqual(l[size - 5:], [None] * 5) + self.assertEqual(l[size - 5:size], [None] * 5) + self.assertEqual(l[size - 6:size - 2], [None] * 4) + self.assertEqual(l[size:size], []) + self.assertEqual(l[size:size+5], []) l[size - 2] = 5 - self.assertEquals(len(l), size) - self.assertEquals(l[-3:], [None, 5, None]) - self.assertEquals(l.count(5), 1) + self.assertEqual(len(l), size) + self.assertEqual(l[-3:], [None, 5, None]) + self.assertEqual(l.count(5), 1) self.assertRaises(IndexError, operator.setitem, l, size, 6) - self.assertEquals(len(l), size) + self.assertEqual(len(l), size) l[size - 7:] = [1, 2, 3, 4, 5] size -= 2 - self.assertEquals(len(l), size) - self.assertEquals(l[-7:], [None, None, 1, 2, 3, 4, 5]) + self.assertEqual(len(l), size) + self.assertEqual(l[-7:], [None, None, 1, 2, 3, 4, 5]) l[:7] = [1, 2, 3, 4, 5] size -= 2 - self.assertEquals(len(l), size) - self.assertEquals(l[:7], [1, 2, 3, 4, 5, None, None]) + self.assertEqual(len(l), size) + self.assertEqual(l[:7], [1, 2, 3, 4, 5, None, None]) del l[size - 1] size -= 1 - self.assertEquals(len(l), size) - self.assertEquals(l[-1], 4) + self.assertEqual(len(l), size) + self.assertEqual(l[-1], 4) del l[-2:] size -= 2 - self.assertEquals(len(l), size) - self.assertEquals(l[-1], 2) + self.assertEqual(len(l), size) + self.assertEqual(l[-1], 2) del l[0] size -= 1 - self.assertEquals(len(l), size) - self.assertEquals(l[0], 2) + self.assertEqual(len(l), size) + self.assertEqual(l[0], 2) del l[:2] size -= 2 - self.assertEquals(len(l), size) - self.assertEquals(l[0], 4) + self.assertEqual(len(l), size) + self.assertEqual(l[0], 4) # Like test_concat, split in two. def basic_test_repeat(self, size): l = [] * size self.assertFalse(l) l = [''] * size - self.assertEquals(len(l), size) + self.assertEqual(len(l), size) l = l * 2 - self.assertEquals(len(l), size * 2) + self.assertEqual(len(l), size * 2) @bigmemtest(minsize=_2G // 2 + 2, memuse=24) def test_repeat_small(self, size): @@ -1005,13 +1005,13 @@ class ListTest(unittest.TestCase): def basic_test_inplace_repeat(self, size): l = [''] l *= size - self.assertEquals(len(l), size) + self.assertEqual(len(l), size) self.assertTrue(l[0] is l[-1]) del l l = [''] * size l *= 2 - self.assertEquals(len(l), size * 2) + self.assertEqual(len(l), size * 2) self.assertTrue(l[size - 1] is l[-1]) @bigmemtest(minsize=_2G // 2 + 2, memuse=16) @@ -1026,10 +1026,10 @@ class ListTest(unittest.TestCase): l = [0] * size s = repr(l) # The repr of a list of 0's is exactly three times the list length. - self.assertEquals(len(s), size * 3) - self.assertEquals(s[:5], '[0, 0') - self.assertEquals(s[-5:], '0, 0]') - self.assertEquals(s.count('0'), size) + self.assertEqual(len(s), size * 3) + self.assertEqual(s[:5], '[0, 0') + self.assertEqual(s[-5:], '0, 0]') + self.assertEqual(s.count('0'), size) @bigmemtest(minsize=_2G // 3 + 2, memuse=8 + 3 * character_size) def test_repr_small(self, size): @@ -1045,20 +1045,20 @@ class ListTest(unittest.TestCase): def test_append(self, size): l = [object()] * size l.append(object()) - self.assertEquals(len(l), size+1) + self.assertEqual(len(l), size+1) self.assertTrue(l[-3] is l[-2]) self.assertFalse(l[-2] is l[-1]) @bigmemtest(minsize=_2G // 5 + 2, memuse=8 * 5) def test_count(self, size): l = [1, 2, 3, 4, 5] * size - self.assertEquals(l.count(1), size) - self.assertEquals(l.count("1"), 0) + self.assertEqual(l.count(1), size) + self.assertEqual(l.count("1"), 0) def basic_test_extend(self, size): l = [object] * size l.extend(l) - self.assertEquals(len(l), size * 2) + self.assertEqual(len(l), size * 2) self.assertTrue(l[0] is l[-1]) self.assertTrue(l[size - 1] is l[size + 1]) @@ -1074,9 +1074,9 @@ class ListTest(unittest.TestCase): def test_index(self, size): l = [1, 2, 3, 4, 5] * size size *= 5 - self.assertEquals(l.index(1), 0) - self.assertEquals(l.index(5, size - 5), size - 1) - self.assertEquals(l.index(5, size - 5, size), size - 1) + self.assertEqual(l.index(1), 0) + self.assertEqual(l.index(5, size - 5), size - 1) + self.assertEqual(l.index(5, size - 5, size), size - 1) self.assertRaises(ValueError, l.index, 1, size - 4, size) self.assertRaises(ValueError, l.index, 6) @@ -1086,80 +1086,80 @@ class ListTest(unittest.TestCase): l = [1.0] * size l.insert(size - 1, "A") size += 1 - self.assertEquals(len(l), size) - self.assertEquals(l[-3:], [1.0, "A", 1.0]) + self.assertEqual(len(l), size) + self.assertEqual(l[-3:], [1.0, "A", 1.0]) l.insert(size + 1, "B") size += 1 - self.assertEquals(len(l), size) - self.assertEquals(l[-3:], ["A", 1.0, "B"]) + self.assertEqual(len(l), size) + self.assertEqual(l[-3:], ["A", 1.0, "B"]) l.insert(1, "C") size += 1 - self.assertEquals(len(l), size) - self.assertEquals(l[:3], [1.0, "C", 1.0]) - self.assertEquals(l[size - 3:], ["A", 1.0, "B"]) + self.assertEqual(len(l), size) + self.assertEqual(l[:3], [1.0, "C", 1.0]) + self.assertEqual(l[size - 3:], ["A", 1.0, "B"]) @bigmemtest(minsize=_2G // 5 + 4, memuse=8 * 5) def test_pop(self, size): l = ["a", "b", "c", "d", "e"] * size size *= 5 - self.assertEquals(len(l), size) + self.assertEqual(len(l), size) item = l.pop() size -= 1 - self.assertEquals(len(l), size) - self.assertEquals(item, "e") - self.assertEquals(l[-2:], ["c", "d"]) + self.assertEqual(len(l), size) + self.assertEqual(item, "e") + self.assertEqual(l[-2:], ["c", "d"]) item = l.pop(0) size -= 1 - self.assertEquals(len(l), size) - self.assertEquals(item, "a") - self.assertEquals(l[:2], ["b", "c"]) + self.assertEqual(len(l), size) + self.assertEqual(item, "a") + self.assertEqual(l[:2], ["b", "c"]) item = l.pop(size - 2) size -= 1 - self.assertEquals(len(l), size) - self.assertEquals(item, "c") - self.assertEquals(l[-2:], ["b", "d"]) + self.assertEqual(len(l), size) + self.assertEqual(item, "c") + self.assertEqual(l[-2:], ["b", "d"]) @bigmemtest(minsize=_2G + 10, memuse=8) def test_remove(self, size): l = [10] * size - self.assertEquals(len(l), size) + self.assertEqual(len(l), size) l.remove(10) size -= 1 - self.assertEquals(len(l), size) + self.assertEqual(len(l), size) # Because of the earlier l.remove(), this append doesn't trigger # a resize. l.append(5) size += 1 - self.assertEquals(len(l), size) - self.assertEquals(l[-2:], [10, 5]) + self.assertEqual(len(l), size) + self.assertEqual(l[-2:], [10, 5]) l.remove(5) size -= 1 - self.assertEquals(len(l), size) - self.assertEquals(l[-2:], [10, 10]) + self.assertEqual(len(l), size) + self.assertEqual(l[-2:], [10, 10]) @bigmemtest(minsize=_2G // 5 + 2, memuse=8 * 5) def test_reverse(self, size): l = [1, 2, 3, 4, 5] * size l.reverse() - self.assertEquals(len(l), size * 5) - self.assertEquals(l[-5:], [5, 4, 3, 2, 1]) - self.assertEquals(l[:5], [5, 4, 3, 2, 1]) + self.assertEqual(len(l), size * 5) + self.assertEqual(l[-5:], [5, 4, 3, 2, 1]) + self.assertEqual(l[:5], [5, 4, 3, 2, 1]) @bigmemtest(minsize=_2G // 5 + 2, memuse=8 * 5) def test_sort(self, size): l = [1, 2, 3, 4, 5] * size l.sort() - self.assertEquals(len(l), size * 5) - self.assertEquals(l.count(1), size) - self.assertEquals(l[:10], [1] * 10) - self.assertEquals(l[-10:], [5] * 10) + self.assertEqual(len(l), size * 5) + self.assertEqual(l.count(1), size) + self.assertEqual(l[:10], [1] * 10) + self.assertEqual(l[-10:], [5] * 10) def test_main(): support.run_unittest(StrTest, BytesTest, BytearrayTest, diff --git a/Lib/test/test_builtin.py b/Lib/test/test_builtin.py index 5a3c35a..d2d4fa9 100644 --- a/Lib/test/test_builtin.py +++ b/Lib/test/test_builtin.py @@ -542,11 +542,11 @@ class BuiltinTest(unittest.TestCase): class X: def __hash__(self): return 2**100 - self.assertEquals(type(hash(X())), int) + self.assertEqual(type(hash(X())), int) class Z(int): def __hash__(self): return self - self.assertEquals(hash(Z(42)), hash(42)) + self.assertEqual(hash(Z(42)), hash(42)) def test_hex(self): self.assertEqual(hex(16), '0x10') @@ -777,7 +777,7 @@ class BuiltinTest(unittest.TestCase): self.assertEqual(next(it), 1) self.assertRaises(StopIteration, next, it) self.assertRaises(StopIteration, next, it) - self.assertEquals(next(it, 42), 42) + self.assertEqual(next(it, 42), 42) class Iter(object): def __iter__(self): @@ -786,7 +786,7 @@ class BuiltinTest(unittest.TestCase): raise StopIteration it = iter(Iter()) - self.assertEquals(next(it, 42), 42) + self.assertEqual(next(it, 42), 42) self.assertRaises(StopIteration, next, it) def gen(): @@ -794,9 +794,9 @@ class BuiltinTest(unittest.TestCase): return it = gen() - self.assertEquals(next(it), 1) + self.assertEqual(next(it), 1) self.assertRaises(StopIteration, next, it) - self.assertEquals(next(it, 42), 42) + self.assertEqual(next(it, 42), 42) def test_oct(self): self.assertEqual(oct(100), '0o144') diff --git a/Lib/test/test_bytes.py b/Lib/test/test_bytes.py index 0695084..24ee487 100644 --- a/Lib/test/test_bytes.py +++ b/Lib/test/test_bytes.py @@ -266,11 +266,11 @@ class BaseBytesTest(unittest.TestCase): def test_fromhex(self): self.assertRaises(TypeError, self.type2test.fromhex) self.assertRaises(TypeError, self.type2test.fromhex, 1) - self.assertEquals(self.type2test.fromhex(''), self.type2test()) + self.assertEqual(self.type2test.fromhex(''), self.type2test()) b = bytearray([0x1a, 0x2b, 0x30]) - self.assertEquals(self.type2test.fromhex('1a2B30'), b) - self.assertEquals(self.type2test.fromhex(' 1A 2B 30 '), b) - self.assertEquals(self.type2test.fromhex('0000'), b'\0\0') + self.assertEqual(self.type2test.fromhex('1a2B30'), b) + self.assertEqual(self.type2test.fromhex(' 1A 2B 30 '), b) + self.assertEqual(self.type2test.fromhex('0000'), b'\0\0') self.assertRaises(TypeError, self.type2test.fromhex, b'1B') self.assertRaises(ValueError, self.type2test.fromhex, 'a') self.assertRaises(ValueError, self.type2test.fromhex, 'rt') @@ -626,11 +626,11 @@ class ByteArrayTest(BaseBytesTest): data.reverse() L[start:stop:step] = data b[start:stop:step] = data - self.assertEquals(b, bytearray(L)) + self.assertEqual(b, bytearray(L)) del L[start:stop:step] del b[start:stop:step] - self.assertEquals(b, bytearray(L)) + self.assertEqual(b, bytearray(L)) def test_setslice_trap(self): # This test verifies that we correctly handle assigning self @@ -809,25 +809,25 @@ class ByteArrayTest(BaseBytesTest): resize(10) orig = b[:] self.assertRaises(BufferError, resize, 11) - self.assertEquals(b, orig) + self.assertEqual(b, orig) self.assertRaises(BufferError, resize, 9) - self.assertEquals(b, orig) + self.assertEqual(b, orig) self.assertRaises(BufferError, resize, 0) - self.assertEquals(b, orig) + self.assertEqual(b, orig) # Other operations implying resize self.assertRaises(BufferError, b.pop, 0) - self.assertEquals(b, orig) + self.assertEqual(b, orig) self.assertRaises(BufferError, b.remove, b[1]) - self.assertEquals(b, orig) + self.assertEqual(b, orig) def delitem(): del b[1] self.assertRaises(BufferError, delitem) - self.assertEquals(b, orig) + self.assertEqual(b, orig) # deleting a non-contiguous slice def delslice(): b[1:-1:2] = b"" self.assertRaises(BufferError, delslice) - self.assertEquals(b, orig) + self.assertEqual(b, orig) class AssortedBytesTest(unittest.TestCase): diff --git a/Lib/test/test_calendar.py b/Lib/test/test_calendar.py index 9ba7f0c..8d7f185 100644 --- a/Lib/test/test_calendar.py +++ b/Lib/test/test_calendar.py @@ -262,7 +262,7 @@ class CalendarTestCase(unittest.TestCase): return calendar.LocaleHTMLCalendar(locale='').formatmonthname(2010, 10) new_october = calendar.TextCalendar().formatmonthname(2010, 10, 10) - self.assertEquals(old_october, new_october) + self.assertEqual(old_october, new_october) class MonthCalendarTestCase(unittest.TestCase): diff --git a/Lib/test/test_cfgparser.py b/Lib/test/test_cfgparser.py index efa1233..ad6600f 100644 --- a/Lib/test/test_cfgparser.py +++ b/Lib/test/test_cfgparser.py @@ -897,8 +897,7 @@ class SafeConfigParserTestCaseTrickyFile(CfgParserTestCaseClass): self.assertEqual(len(cf.get('corruption', 'value').split('\n')), 10) longname = 'yeah, sections can be indented as well' self.assertFalse(cf.getboolean(longname, 'are they subsections')) - self.assertEquals(cf.get(longname, 'lets use some Unicode'), - '片仮名') + self.assertEqual(cf.get(longname, 'lets use some Unicode'), '片仮名') self.assertEqual(len(cf.items('another one!')), 5) # 4 in section and # `go` from DEFAULT with self.assertRaises(configparser.InterpolationMissingOptionError): @@ -955,14 +954,14 @@ class SortedTestCase(RawConfigParserTestCase): "k=v\n") output = io.StringIO() cf.write(output) - self.assertEquals(output.getvalue(), - "[a]\n" - "k = v\n\n" - "[b]\n" - "o1 = 4\n" - "o2 = 3\n" - "o3 = 2\n" - "o4 = 1\n\n") + self.assertEqual(output.getvalue(), + "[a]\n" + "k = v\n\n" + "[b]\n" + "o1 = 4\n" + "o2 = 3\n" + "o3 = 2\n" + "o4 = 1\n\n") class CompatibleTestCase(CfgParserTestCaseClass): diff --git a/Lib/test/test_cgi.py b/Lib/test/test_cgi.py index 4347668..a7b9ea3 100644 --- a/Lib/test/test_cgi.py +++ b/Lib/test/test_cgi.py @@ -217,7 +217,7 @@ Content-Disposition: form-data; name="submit" -----------------------------721837373350705526688164684-- """ fs = cgi.FieldStorage(fp=StringIO(postdata), environ=env) - self.assertEquals(len(fs.list), 4) + self.assertEqual(len(fs.list), 4) expect = [{'name':'id', 'filename':None, 'value':'1234'}, {'name':'title', 'filename':None, 'value':''}, {'name':'file', 'filename':'test.txt', 'value':'Testing 123.'}, @@ -225,7 +225,7 @@ Content-Disposition: form-data; name="submit" for x in range(len(fs.list)): for k, exp in expect[x].items(): got = getattr(fs.list[x], k) - self.assertEquals(got, exp) + self.assertEqual(got, exp) _qs_result = { 'key1': 'value1', diff --git a/Lib/test/test_charmapcodec.py b/Lib/test/test_charmapcodec.py index 8b79bde..6226587 100644 --- a/Lib/test/test_charmapcodec.py +++ b/Lib/test/test_charmapcodec.py @@ -27,24 +27,24 @@ codecname = 'testcodec' class CharmapCodecTest(unittest.TestCase): def test_constructorx(self): - self.assertEquals(str(b'abc', codecname), 'abc') - self.assertEquals(str(b'xdef', codecname), 'abcdef') - self.assertEquals(str(b'defx', codecname), 'defabc') - self.assertEquals(str(b'dxf', codecname), 'dabcf') - self.assertEquals(str(b'dxfx', codecname), 'dabcfabc') + self.assertEqual(str(b'abc', codecname), 'abc') + self.assertEqual(str(b'xdef', codecname), 'abcdef') + self.assertEqual(str(b'defx', codecname), 'defabc') + self.assertEqual(str(b'dxf', codecname), 'dabcf') + self.assertEqual(str(b'dxfx', codecname), 'dabcfabc') def test_encodex(self): - self.assertEquals('abc'.encode(codecname), b'abc') - self.assertEquals('xdef'.encode(codecname), b'abcdef') - self.assertEquals('defx'.encode(codecname), b'defabc') - self.assertEquals('dxf'.encode(codecname), b'dabcf') - self.assertEquals('dxfx'.encode(codecname), b'dabcfabc') + self.assertEqual('abc'.encode(codecname), b'abc') + self.assertEqual('xdef'.encode(codecname), b'abcdef') + self.assertEqual('defx'.encode(codecname), b'defabc') + self.assertEqual('dxf'.encode(codecname), b'dabcf') + self.assertEqual('dxfx'.encode(codecname), b'dabcfabc') def test_constructory(self): - self.assertEquals(str(b'ydef', codecname), 'def') - self.assertEquals(str(b'defy', codecname), 'def') - self.assertEquals(str(b'dyf', codecname), 'df') - self.assertEquals(str(b'dyfy', codecname), 'df') + self.assertEqual(str(b'ydef', codecname), 'def') + self.assertEqual(str(b'defy', codecname), 'def') + self.assertEqual(str(b'dyf', codecname), 'df') + self.assertEqual(str(b'dyfy', codecname), 'df') def test_maptoundefined(self): self.assertRaises(UnicodeError, str, b'abc\001', codecname) diff --git a/Lib/test/test_class.py b/Lib/test/test_class.py index 552c521..c7003fb 100644 --- a/Lib/test/test_class.py +++ b/Lib/test/test_class.py @@ -436,7 +436,7 @@ class ClassTests(unittest.TestCase): del testme import gc gc.collect() - self.assertEquals(["crab people, crab people"], x) + self.assertEqual(["crab people, crab people"], x) def testBadTypeReturned(self): # return values of some method are type-checked @@ -529,17 +529,17 @@ class ClassTests(unittest.TestCase): a1 = A(1) a2 = A(2) - self.assertEquals(a1.f, a1.f) - self.assertNotEquals(a1.f, a2.f) - self.assertNotEquals(a1.f, a1.g) - self.assertEquals(a1.f, A(1).f) - self.assertEquals(hash(a1.f), hash(a1.f)) - self.assertEquals(hash(a1.f), hash(A(1).f)) - - self.assertNotEquals(A.f, a1.f) - self.assertNotEquals(A.f, A.g) - self.assertEquals(B.f, A.f) - self.assertEquals(hash(B.f), hash(A.f)) + self.assertEqual(a1.f, a1.f) + self.assertNotEqual(a1.f, a2.f) + self.assertNotEqual(a1.f, a1.g) + self.assertEqual(a1.f, A(1).f) + self.assertEqual(hash(a1.f), hash(a1.f)) + self.assertEqual(hash(a1.f), hash(A(1).f)) + + self.assertNotEqual(A.f, a1.f) + self.assertNotEqual(A.f, A.g) + self.assertEqual(B.f, A.f) + self.assertEqual(hash(B.f), hash(A.f)) # the following triggers a SystemError in 2.4 a = A(hash(A.f)^(-1)) diff --git a/Lib/test/test_code.py b/Lib/test/test_code.py index 1a8af0d..e1c7a78 100644 --- a/Lib/test/test_code.py +++ b/Lib/test/test_code.py @@ -128,9 +128,9 @@ class CodeTest(unittest.TestCase): def test_newempty(self): co = _testcapi.code_newempty("filename", "funcname", 15) - self.assertEquals(co.co_filename, "filename") - self.assertEquals(co.co_name, "funcname") - self.assertEquals(co.co_firstlineno, 15) + self.assertEqual(co.co_filename, "filename") + self.assertEqual(co.co_name, "funcname") + self.assertEqual(co.co_firstlineno, 15) class CodeWeakRefTest(unittest.TestCase): diff --git a/Lib/test/test_codeccallbacks.py b/Lib/test/test_codeccallbacks.py index 6105fc0..c5b1e25 100644 --- a/Lib/test/test_codeccallbacks.py +++ b/Lib/test/test_codeccallbacks.py @@ -186,7 +186,7 @@ class CodecCallbackTest(unittest.TestCase): charmap = dict((ord(c), bytes(2*c.upper(), 'ascii')) for c in "abcdefgh") sin = "abc" sout = b"AABBCC" - self.assertEquals(codecs.charmap_encode(sin, "strict", charmap)[0], sout) + self.assertEqual(codecs.charmap_encode(sin, "strict", charmap)[0], sout) sin = "abcA" self.assertRaises(UnicodeError, codecs.charmap_encode, sin, "strict", charmap) @@ -194,7 +194,7 @@ class CodecCallbackTest(unittest.TestCase): charmap[ord("?")] = b"XYZ" sin = "abcDEF" sout = b"AABBCCXYZXYZXYZ" - self.assertEquals(codecs.charmap_encode(sin, "replace", charmap)[0], sout) + self.assertEqual(codecs.charmap_encode(sin, "replace", charmap)[0], sout) charmap[ord("?")] = "XYZ" # wrong type in mapping self.assertRaises(TypeError, codecs.charmap_encode, sin, "replace", charmap) @@ -327,7 +327,7 @@ class CodecCallbackTest(unittest.TestCase): # check with the correct number and type of arguments exc = exctype(*args) - self.assertEquals(str(exc), msg) + self.assertEqual(str(exc), msg) def test_unicodeencodeerror(self): self.check_exceptionobjectargs( @@ -437,17 +437,17 @@ class CodecCallbackTest(unittest.TestCase): UnicodeError("ouch") ) # If the correct exception is passed in, "ignore" returns an empty replacement - self.assertEquals( + self.assertEqual( codecs.ignore_errors( UnicodeEncodeError("ascii", "\u3042", 0, 1, "ouch")), ("", 1) ) - self.assertEquals( + self.assertEqual( codecs.ignore_errors( UnicodeDecodeError("ascii", bytearray(b"\xff"), 0, 1, "ouch")), ("", 1) ) - self.assertEquals( + self.assertEqual( codecs.ignore_errors( UnicodeTranslateError("\u3042", 0, 1, "ouch")), ("", 1) @@ -477,17 +477,17 @@ class CodecCallbackTest(unittest.TestCase): BadObjectUnicodeDecodeError() ) # With the correct exception, "replace" returns an "?" or "\ufffd" replacement - self.assertEquals( + self.assertEqual( codecs.replace_errors( UnicodeEncodeError("ascii", "\u3042", 0, 1, "ouch")), ("?", 1) ) - self.assertEquals( + self.assertEqual( codecs.replace_errors( UnicodeDecodeError("ascii", bytearray(b"\xff"), 0, 1, "ouch")), ("\ufffd", 1) ) - self.assertEquals( + self.assertEqual( codecs.replace_errors( UnicodeTranslateError("\u3042", 0, 1, "ouch")), ("\ufffd", 1) @@ -520,7 +520,7 @@ class CodecCallbackTest(unittest.TestCase): # Use the correct exception cs = (0, 1, 9, 10, 99, 100, 999, 1000, 9999, 10000, 0x3042) s = "".join(chr(c) for c in cs) - self.assertEquals( + self.assertEqual( codecs.xmlcharrefreplace_errors( UnicodeEncodeError("ascii", s, 0, len(s), "ouch") ), @@ -552,52 +552,52 @@ class CodecCallbackTest(unittest.TestCase): UnicodeTranslateError("\u3042", 0, 1, "ouch") ) # Use the correct exception - self.assertEquals( + self.assertEqual( codecs.backslashreplace_errors( UnicodeEncodeError("ascii", "\u3042", 0, 1, "ouch")), ("\\u3042", 1) ) - self.assertEquals( + self.assertEqual( codecs.backslashreplace_errors( UnicodeEncodeError("ascii", "\x00", 0, 1, "ouch")), ("\\x00", 1) ) - self.assertEquals( + self.assertEqual( codecs.backslashreplace_errors( UnicodeEncodeError("ascii", "\xff", 0, 1, "ouch")), ("\\xff", 1) ) - self.assertEquals( + self.assertEqual( codecs.backslashreplace_errors( UnicodeEncodeError("ascii", "\u0100", 0, 1, "ouch")), ("\\u0100", 1) ) - self.assertEquals( + self.assertEqual( codecs.backslashreplace_errors( UnicodeEncodeError("ascii", "\uffff", 0, 1, "ouch")), ("\\uffff", 1) ) # 1 on UCS-4 builds, 2 on UCS-2 len_wide = len("\U00010000") - self.assertEquals( + self.assertEqual( codecs.backslashreplace_errors( UnicodeEncodeError("ascii", "\U00010000", 0, len_wide, "ouch")), ("\\U00010000", len_wide) ) - self.assertEquals( + self.assertEqual( codecs.backslashreplace_errors( UnicodeEncodeError("ascii", "\U0010ffff", 0, len_wide, "ouch")), ("\\U0010ffff", len_wide) ) # Lone surrogates (regardless of unicode width) - self.assertEquals( + self.assertEqual( codecs.backslashreplace_errors( UnicodeEncodeError("ascii", "\ud800", 0, 1, "ouch")), ("\\ud800", 1) ) - self.assertEquals( + self.assertEqual( codecs.backslashreplace_errors( UnicodeEncodeError("ascii", "\udfff", 0, 1, "ouch")), ("\\udfff", 1) @@ -630,14 +630,14 @@ class CodecCallbackTest(unittest.TestCase): ) def test_lookup(self): - self.assertEquals(codecs.strict_errors, codecs.lookup_error("strict")) - self.assertEquals(codecs.ignore_errors, codecs.lookup_error("ignore")) - self.assertEquals(codecs.strict_errors, codecs.lookup_error("strict")) - self.assertEquals( + self.assertEqual(codecs.strict_errors, codecs.lookup_error("strict")) + self.assertEqual(codecs.ignore_errors, codecs.lookup_error("ignore")) + self.assertEqual(codecs.strict_errors, codecs.lookup_error("strict")) + self.assertEqual( codecs.xmlcharrefreplace_errors, codecs.lookup_error("xmlcharrefreplace") ) - self.assertEquals( + self.assertEqual( codecs.backslashreplace_errors, codecs.lookup_error("backslashreplace") ) @@ -713,11 +713,11 @@ class CodecCallbackTest(unittest.TestCase): # Valid negative position handler.pos = -1 - self.assertEquals(b"\xff0".decode("ascii", "test.posreturn"), "<?>0") + self.assertEqual(b"\xff0".decode("ascii", "test.posreturn"), "<?>0") # Valid negative position handler.pos = -2 - self.assertEquals(b"\xff0".decode("ascii", "test.posreturn"), "<?><?>") + self.assertEqual(b"\xff0".decode("ascii", "test.posreturn"), "<?><?>") # Negative position out of bounds handler.pos = -3 @@ -725,11 +725,11 @@ class CodecCallbackTest(unittest.TestCase): # Valid positive position handler.pos = 1 - self.assertEquals(b"\xff0".decode("ascii", "test.posreturn"), "<?>0") + self.assertEqual(b"\xff0".decode("ascii", "test.posreturn"), "<?>0") # Largest valid positive position (one beyond end of input) handler.pos = 2 - self.assertEquals(b"\xff0".decode("ascii", "test.posreturn"), "<?>") + self.assertEqual(b"\xff0".decode("ascii", "test.posreturn"), "<?>") # Invalid positive position handler.pos = 3 @@ -737,7 +737,7 @@ class CodecCallbackTest(unittest.TestCase): # Restart at the "0" handler.pos = 6 - self.assertEquals(b"\\uyyyy0".decode("raw-unicode-escape", "test.posreturn"), "<?>0") + self.assertEqual(b"\\uyyyy0".decode("raw-unicode-escape", "test.posreturn"), "<?>0") class D(dict): def __getitem__(self, key): @@ -767,11 +767,11 @@ class CodecCallbackTest(unittest.TestCase): # Valid negative position handler.pos = -1 - self.assertEquals("\xff0".encode("ascii", "test.posreturn"), b"<?>0") + self.assertEqual("\xff0".encode("ascii", "test.posreturn"), b"<?>0") # Valid negative position handler.pos = -2 - self.assertEquals("\xff0".encode("ascii", "test.posreturn"), b"<?><?>") + self.assertEqual("\xff0".encode("ascii", "test.posreturn"), b"<?><?>") # Negative position out of bounds handler.pos = -3 @@ -779,11 +779,11 @@ class CodecCallbackTest(unittest.TestCase): # Valid positive position handler.pos = 1 - self.assertEquals("\xff0".encode("ascii", "test.posreturn"), b"<?>0") + self.assertEqual("\xff0".encode("ascii", "test.posreturn"), b"<?>0") # Largest valid positive position (one beyond end of input handler.pos = 2 - self.assertEquals("\xff0".encode("ascii", "test.posreturn"), b"<?>") + self.assertEqual("\xff0".encode("ascii", "test.posreturn"), b"<?>") # Invalid positive position handler.pos = 3 diff --git a/Lib/test/test_codecs.py b/Lib/test/test_codecs.py index 77564b8..f989a55 100644 --- a/Lib/test/test_codecs.py +++ b/Lib/test/test_codecs.py @@ -299,7 +299,7 @@ class UTF32Test(ReadTest): # try to read it back s = io.BytesIO(d) f = reader(s) - self.assertEquals(f.read(), "spamspam") + self.assertEqual(f.read(), "spamspam") def test_badbom(self): s = io.BytesIO(4*b"\xff") @@ -463,7 +463,7 @@ class UTF16Test(ReadTest): # try to read it back s = io.BytesIO(d) f = reader(s) - self.assertEquals(f.read(), "spamspam") + self.assertEqual(f.read(), "spamspam") def test_badbom(self): s = io.BytesIO(b"\xff\xff") @@ -607,10 +607,10 @@ class UTF8Test(ReadTest): b'[?]') def test_surrogatepass_handler(self): - self.assertEquals("abc\ud800def".encode("utf-8", "surrogatepass"), - b"abc\xed\xa0\x80def") - self.assertEquals(b"abc\xed\xa0\x80def".decode("utf-8", "surrogatepass"), - "abc\ud800def") + self.assertEqual("abc\ud800def".encode("utf-8", "surrogatepass"), + b"abc\xed\xa0\x80def") + self.assertEqual(b"abc\xed\xa0\x80def".decode("utf-8", "surrogatepass"), + "abc\ud800def") self.assertTrue(codecs.lookup_error("surrogatepass")) class UTF7Test(ReadTest): @@ -681,7 +681,7 @@ class UTF8SigTest(ReadTest): def test_bug1601501(self): # SF bug #1601501: check that the codec works with a buffer - self.assertEquals(str(b"\xef\xbb\xbf", "utf-8-sig"), "") + self.assertEqual(str(b"\xef\xbb\xbf", "utf-8-sig"), "") def test_bom(self): d = codecs.getincrementaldecoder("utf-8-sig")() @@ -734,7 +734,7 @@ class UTF8SigTest(ReadTest): class EscapeDecodeTest(unittest.TestCase): def test_empty(self): - self.assertEquals(codecs.escape_decode(""), ("", 0)) + self.assertEqual(codecs.escape_decode(""), ("", 0)) class RecodingTest(unittest.TestCase): def test_recoding(self): @@ -861,16 +861,16 @@ class PunycodeTest(unittest.TestCase): # code produces only lower case. Converting just puny to # lower is also insufficient, since some of the input characters # are upper case. - self.assertEquals( + self.assertEqual( str(uni.encode("punycode"), "ascii").lower(), str(puny, "ascii").lower() ) def test_decode(self): for uni, puny in punycode_testcases: - self.assertEquals(uni, puny.decode("punycode")) + self.assertEqual(uni, puny.decode("punycode")) puny = puny.decode("ascii").encode("ascii") - self.assertEquals(uni, puny.decode("punycode")) + self.assertEqual(uni, puny.decode("punycode")) class UnicodeInternalTest(unittest.TestCase): def test_bug1251300(self): @@ -892,7 +892,7 @@ class UnicodeInternalTest(unittest.TestCase): for internal, uni in ok: if sys.byteorder == "little": internal = bytes(reversed(internal)) - self.assertEquals(uni, internal.decode("unicode_internal")) + self.assertEqual(uni, internal.decode("unicode_internal")) for internal in not_ok: if sys.byteorder == "little": internal = bytes(reversed(internal)) @@ -904,10 +904,10 @@ class UnicodeInternalTest(unittest.TestCase): try: b"\x00\x00\x00\x00\x00\x11\x11\x00".decode("unicode_internal") except UnicodeDecodeError as ex: - self.assertEquals("unicode_internal", ex.encoding) - self.assertEquals(b"\x00\x00\x00\x00\x00\x11\x11\x00", ex.object) - self.assertEquals(4, ex.start) - self.assertEquals(8, ex.end) + self.assertEqual("unicode_internal", ex.encoding) + self.assertEqual(b"\x00\x00\x00\x00\x00\x11\x11\x00", ex.object) + self.assertEqual(4, ex.start) + self.assertEqual(8, ex.end) else: self.fail() @@ -919,15 +919,15 @@ class UnicodeInternalTest(unittest.TestCase): ignored = decoder(bytes("%s\x22\x22\x22\x22%s" % (ab[:4], ab[4:]), "ascii"), "UnicodeInternalTest") - self.assertEquals(("ab", 12), ignored) + self.assertEqual(("ab", 12), ignored) def test_encode_length(self): # Issue 3739 encoder = codecs.getencoder("unicode_internal") - self.assertEquals(encoder("a")[1], 1) - self.assertEquals(encoder("\xe9\u0142")[1], 2) + self.assertEqual(encoder("a")[1], 1) + self.assertEqual(encoder("\xe9\u0142")[1], 2) - self.assertEquals(codecs.escape_encode(br'\x00')[1], 4) + self.assertEqual(codecs.escape_encode(br'\x00')[1], 4) # From http://www.gnu.org/software/libidn/draft-josefsson-idn-test-vectors.html nameprep_tests = [ @@ -1098,101 +1098,101 @@ class NameprepTest(unittest.TestCase): else: prepped = str(prepped, "utf-8", "surrogatepass") try: - self.assertEquals(nameprep(orig), prepped) + self.assertEqual(nameprep(orig), prepped) except Exception as e: raise support.TestFailed("Test 3.%d: %s" % (pos+1, str(e))) class IDNACodecTest(unittest.TestCase): def test_builtin_decode(self): - self.assertEquals(str(b"python.org", "idna"), "python.org") - self.assertEquals(str(b"python.org.", "idna"), "python.org.") - self.assertEquals(str(b"xn--pythn-mua.org", "idna"), "pyth\xf6n.org") - self.assertEquals(str(b"xn--pythn-mua.org.", "idna"), "pyth\xf6n.org.") + self.assertEqual(str(b"python.org", "idna"), "python.org") + self.assertEqual(str(b"python.org.", "idna"), "python.org.") + self.assertEqual(str(b"xn--pythn-mua.org", "idna"), "pyth\xf6n.org") + self.assertEqual(str(b"xn--pythn-mua.org.", "idna"), "pyth\xf6n.org.") def test_builtin_encode(self): - self.assertEquals("python.org".encode("idna"), b"python.org") - self.assertEquals("python.org.".encode("idna"), b"python.org.") - self.assertEquals("pyth\xf6n.org".encode("idna"), b"xn--pythn-mua.org") - self.assertEquals("pyth\xf6n.org.".encode("idna"), b"xn--pythn-mua.org.") + self.assertEqual("python.org".encode("idna"), b"python.org") + self.assertEqual("python.org.".encode("idna"), b"python.org.") + self.assertEqual("pyth\xf6n.org".encode("idna"), b"xn--pythn-mua.org") + self.assertEqual("pyth\xf6n.org.".encode("idna"), b"xn--pythn-mua.org.") def test_stream(self): r = codecs.getreader("idna")(io.BytesIO(b"abc")) r.read(3) - self.assertEquals(r.read(), "") + self.assertEqual(r.read(), "") def test_incremental_decode(self): - self.assertEquals( + self.assertEqual( "".join(codecs.iterdecode((bytes([c]) for c in b"python.org"), "idna")), "python.org" ) - self.assertEquals( + self.assertEqual( "".join(codecs.iterdecode((bytes([c]) for c in b"python.org."), "idna")), "python.org." ) - self.assertEquals( + self.assertEqual( "".join(codecs.iterdecode((bytes([c]) for c in b"xn--pythn-mua.org."), "idna")), "pyth\xf6n.org." ) - self.assertEquals( + self.assertEqual( "".join(codecs.iterdecode((bytes([c]) for c in b"xn--pythn-mua.org."), "idna")), "pyth\xf6n.org." ) decoder = codecs.getincrementaldecoder("idna")() - self.assertEquals(decoder.decode(b"xn--xam", ), "") - self.assertEquals(decoder.decode(b"ple-9ta.o", ), "\xe4xample.") - self.assertEquals(decoder.decode(b"rg"), "") - self.assertEquals(decoder.decode(b"", True), "org") + self.assertEqual(decoder.decode(b"xn--xam", ), "") + self.assertEqual(decoder.decode(b"ple-9ta.o", ), "\xe4xample.") + self.assertEqual(decoder.decode(b"rg"), "") + self.assertEqual(decoder.decode(b"", True), "org") decoder.reset() - self.assertEquals(decoder.decode(b"xn--xam", ), "") - self.assertEquals(decoder.decode(b"ple-9ta.o", ), "\xe4xample.") - self.assertEquals(decoder.decode(b"rg."), "org.") - self.assertEquals(decoder.decode(b"", True), "") + self.assertEqual(decoder.decode(b"xn--xam", ), "") + self.assertEqual(decoder.decode(b"ple-9ta.o", ), "\xe4xample.") + self.assertEqual(decoder.decode(b"rg."), "org.") + self.assertEqual(decoder.decode(b"", True), "") def test_incremental_encode(self): - self.assertEquals( + self.assertEqual( b"".join(codecs.iterencode("python.org", "idna")), b"python.org" ) - self.assertEquals( + self.assertEqual( b"".join(codecs.iterencode("python.org.", "idna")), b"python.org." ) - self.assertEquals( + self.assertEqual( b"".join(codecs.iterencode("pyth\xf6n.org.", "idna")), b"xn--pythn-mua.org." ) - self.assertEquals( + self.assertEqual( b"".join(codecs.iterencode("pyth\xf6n.org.", "idna")), b"xn--pythn-mua.org." ) encoder = codecs.getincrementalencoder("idna")() - self.assertEquals(encoder.encode("\xe4x"), b"") - self.assertEquals(encoder.encode("ample.org"), b"xn--xample-9ta.") - self.assertEquals(encoder.encode("", True), b"org") + self.assertEqual(encoder.encode("\xe4x"), b"") + self.assertEqual(encoder.encode("ample.org"), b"xn--xample-9ta.") + self.assertEqual(encoder.encode("", True), b"org") encoder.reset() - self.assertEquals(encoder.encode("\xe4x"), b"") - self.assertEquals(encoder.encode("ample.org."), b"xn--xample-9ta.org.") - self.assertEquals(encoder.encode("", True), b"") + self.assertEqual(encoder.encode("\xe4x"), b"") + self.assertEqual(encoder.encode("ample.org."), b"xn--xample-9ta.org.") + self.assertEqual(encoder.encode("", True), b"") class CodecsModuleTest(unittest.TestCase): def test_decode(self): - self.assertEquals(codecs.decode(b'\xe4\xf6\xfc', 'latin-1'), - '\xe4\xf6\xfc') + self.assertEqual(codecs.decode(b'\xe4\xf6\xfc', 'latin-1'), + '\xe4\xf6\xfc') self.assertRaises(TypeError, codecs.decode) - self.assertEquals(codecs.decode(b'abc'), 'abc') + self.assertEqual(codecs.decode(b'abc'), 'abc') self.assertRaises(UnicodeDecodeError, codecs.decode, b'\xff', 'ascii') def test_encode(self): - self.assertEquals(codecs.encode('\xe4\xf6\xfc', 'latin-1'), - b'\xe4\xf6\xfc') + self.assertEqual(codecs.encode('\xe4\xf6\xfc', 'latin-1'), + b'\xe4\xf6\xfc') self.assertRaises(TypeError, codecs.encode) self.assertRaises(LookupError, codecs.encode, "foo", "__spam__") - self.assertEquals(codecs.encode('abc'), b'abc') + self.assertEqual(codecs.encode('abc'), b'abc') self.assertRaises(UnicodeEncodeError, codecs.encode, '\xffff', 'ascii') def test_register(self): @@ -1228,19 +1228,19 @@ class StreamReaderTest(unittest.TestCase): def test_readlines(self): f = self.reader(self.stream) - self.assertEquals(f.readlines(), ['\ud55c\n', '\uae00']) + self.assertEqual(f.readlines(), ['\ud55c\n', '\uae00']) class EncodedFileTest(unittest.TestCase): def test_basic(self): f = io.BytesIO(b'\xed\x95\x9c\n\xea\xb8\x80') ef = codecs.EncodedFile(f, 'utf-16-le', 'utf-8') - self.assertEquals(ef.read(), b'\\\xd5\n\x00\x00\xae') + self.assertEqual(ef.read(), b'\\\xd5\n\x00\x00\xae') f = io.BytesIO() ef = codecs.EncodedFile(f, 'utf-8', 'latin1') ef.write(b'\xc3\xbc') - self.assertEquals(f.getvalue(), b'\xfc') + self.assertEqual(f.getvalue(), b'\xfc') all_unicode_encodings = [ "ascii", @@ -1495,33 +1495,33 @@ class BasicUnicodeTest(unittest.TestCase, MixInCheckStateHandling): class CharmapTest(unittest.TestCase): def test_decode_with_string_map(self): - self.assertEquals( + self.assertEqual( codecs.charmap_decode(b"\x00\x01\x02", "strict", "abc"), ("abc", 3) ) - self.assertEquals( + self.assertEqual( codecs.charmap_decode(b"\x00\x01\x02", "replace", "ab"), ("ab\ufffd", 3) ) - self.assertEquals( + self.assertEqual( codecs.charmap_decode(b"\x00\x01\x02", "replace", "ab\ufffe"), ("ab\ufffd", 3) ) - self.assertEquals( + self.assertEqual( codecs.charmap_decode(b"\x00\x01\x02", "ignore", "ab"), ("ab", 3) ) - self.assertEquals( + self.assertEqual( codecs.charmap_decode(b"\x00\x01\x02", "ignore", "ab\ufffe"), ("ab", 3) ) allbytes = bytes(range(256)) - self.assertEquals( + self.assertEqual( codecs.charmap_decode(allbytes, "ignore", ""), ("", len(allbytes)) ) @@ -1530,14 +1530,14 @@ class WithStmtTest(unittest.TestCase): def test_encodedfile(self): f = io.BytesIO(b"\xc3\xbc") with codecs.EncodedFile(f, "latin-1", "utf-8") as ef: - self.assertEquals(ef.read(), b"\xfc") + self.assertEqual(ef.read(), b"\xfc") def test_streamreaderwriter(self): f = io.BytesIO(b"\xc3\xbc") info = codecs.lookup("utf-8") with codecs.StreamReaderWriter(f, info.streamreader, info.streamwriter, 'strict') as srw: - self.assertEquals(srw.read(), "\xfc") + self.assertEqual(srw.read(), "\xfc") class TypesTest(unittest.TestCase): def test_decode_unicode(self): @@ -1564,10 +1564,10 @@ class TypesTest(unittest.TestCase): def test_unicode_escape(self): # Escape-decoding an unicode string is supported ang gives the same # result as decoding the equivalent ASCII bytes string. - self.assertEquals(codecs.unicode_escape_decode(r"\u1234"), ("\u1234", 6)) - self.assertEquals(codecs.unicode_escape_decode(br"\u1234"), ("\u1234", 6)) - self.assertEquals(codecs.raw_unicode_escape_decode(r"\u1234"), ("\u1234", 6)) - self.assertEquals(codecs.raw_unicode_escape_decode(br"\u1234"), ("\u1234", 6)) + self.assertEqual(codecs.unicode_escape_decode(r"\u1234"), ("\u1234", 6)) + self.assertEqual(codecs.unicode_escape_decode(br"\u1234"), ("\u1234", 6)) + self.assertEqual(codecs.raw_unicode_escape_decode(r"\u1234"), ("\u1234", 6)) + self.assertEqual(codecs.raw_unicode_escape_decode(br"\u1234"), ("\u1234", 6)) class SurrogateEscapeTest(unittest.TestCase): @@ -1618,27 +1618,27 @@ class BomTest(unittest.TestCase): f.write(data) f.write(data) f.seek(0) - self.assertEquals(f.read(), data * 2) + self.assertEqual(f.read(), data * 2) f.seek(0) - self.assertEquals(f.read(), data * 2) + self.assertEqual(f.read(), data * 2) # Check that the BOM is written after a seek(0) with codecs.open(support.TESTFN, 'w+', encoding=encoding) as f: f.write(data[0]) - self.assertNotEquals(f.tell(), 0) + self.assertNotEqual(f.tell(), 0) f.seek(0) f.write(data) f.seek(0) - self.assertEquals(f.read(), data) + self.assertEqual(f.read(), data) # (StreamWriter) Check that the BOM is written after a seek(0) with codecs.open(support.TESTFN, 'w+', encoding=encoding) as f: f.writer.write(data[0]) - self.assertNotEquals(f.writer.tell(), 0) + self.assertNotEqual(f.writer.tell(), 0) f.writer.seek(0) f.writer.write(data) f.seek(0) - self.assertEquals(f.read(), data) + self.assertEqual(f.read(), data) # Check that the BOM is not written after a seek() at a position # different than the start @@ -1647,7 +1647,7 @@ class BomTest(unittest.TestCase): f.seek(f.tell()) f.write(data) f.seek(0) - self.assertEquals(f.read(), data * 2) + self.assertEqual(f.read(), data * 2) # (StreamWriter) Check that the BOM is not written after a seek() # at a position different than the start @@ -1656,7 +1656,7 @@ class BomTest(unittest.TestCase): f.writer.seek(f.writer.tell()) f.writer.write(data) f.seek(0) - self.assertEquals(f.read(), data * 2) + self.assertEqual(f.read(), data * 2) def test_main(): diff --git a/Lib/test/test_codeop.py b/Lib/test/test_codeop.py index 80a73f3..d096293 100644 --- a/Lib/test/test_codeop.py +++ b/Lib/test/test_codeop.py @@ -37,14 +37,14 @@ class CodeopTests(unittest.TestCase): ctx = {'a': 2} d = { 'value': eval(code,ctx) } r = { 'value': eval(str,ctx) } - self.assertEquals(unify_callables(r),unify_callables(d)) + self.assertEqual(unify_callables(r),unify_callables(d)) else: expected = compile(str, "<input>", symbol, PyCF_DONT_IMPLY_DEDENT) - self.assertEquals( compile_command(str, "<input>", symbol), expected) + self.assertEqual(compile_command(str, "<input>", symbol), expected) def assertIncomplete(self, str, symbol='single'): '''succeed iff str is the start of a valid piece of code''' - self.assertEquals( compile_command(str, symbol=symbol), None) + self.assertEqual(compile_command(str, symbol=symbol), None) def assertInvalid(self, str, symbol='single', is_syntax=1): '''succeed iff str is the start of an invalid piece of code''' @@ -61,12 +61,12 @@ class CodeopTests(unittest.TestCase): # special case if not is_jython: - self.assertEquals(compile_command(""), - compile("pass", "<input>", 'single', - PyCF_DONT_IMPLY_DEDENT)) - self.assertEquals(compile_command("\n"), - compile("pass", "<input>", 'single', - PyCF_DONT_IMPLY_DEDENT)) + self.assertEqual(compile_command(""), + compile("pass", "<input>", 'single', + PyCF_DONT_IMPLY_DEDENT)) + self.assertEqual(compile_command("\n"), + compile("pass", "<input>", 'single', + PyCF_DONT_IMPLY_DEDENT)) else: av("") av("\n") @@ -290,10 +290,10 @@ class CodeopTests(unittest.TestCase): ai("[i for i in range(10)] = (1, 2, 3)") def test_filename(self): - self.assertEquals(compile_command("a = 1\n", "abc").co_filename, - compile("a = 1\n", "abc", 'single').co_filename) - self.assertNotEquals(compile_command("a = 1\n", "abc").co_filename, - compile("a = 1\n", "def", 'single').co_filename) + self.assertEqual(compile_command("a = 1\n", "abc").co_filename, + compile("a = 1\n", "abc", 'single').co_filename) + self.assertNotEqual(compile_command("a = 1\n", "abc").co_filename, + compile("a = 1\n", "def", 'single').co_filename) def test_main(): diff --git a/Lib/test/test_collections.py b/Lib/test/test_collections.py index 51e93e4..f3f8b03 100644 --- a/Lib/test/test_collections.py +++ b/Lib/test/test_collections.py @@ -701,9 +701,9 @@ class TestCounter(unittest.TestCase): ]): msg = (i, dup, words) self.assertTrue(dup is not words) - self.assertEquals(dup, words) - self.assertEquals(len(dup), len(words)) - self.assertEquals(type(dup), type(words)) + self.assertEqual(dup, words) + self.assertEqual(len(dup), len(words)) + self.assertEqual(type(dup), type(words)) def test_conversions(self): # Convert to: set, list, dict @@ -922,10 +922,10 @@ class TestOrderedDict(unittest.TestCase): OrderedDict(od), ]): self.assertTrue(dup is not od) - self.assertEquals(dup, od) - self.assertEquals(list(dup.items()), list(od.items())) - self.assertEquals(len(dup), len(od)) - self.assertEquals(type(dup), type(od)) + self.assertEqual(dup, od) + self.assertEqual(list(dup.items()), list(od.items())) + self.assertEqual(len(dup), len(od)) + self.assertEqual(type(dup), type(od)) def test_yaml_linkage(self): # Verify that __reduce__ is setup in a way that supports PyYAML's dump() feature. diff --git a/Lib/test/test_complex.py b/Lib/test/test_complex.py index 1564e89..2810b36 100644 --- a/Lib/test/test_complex.py +++ b/Lib/test/test_complex.py @@ -432,8 +432,8 @@ class ComplexTest(unittest.TestCase): def test_plus_minus_0j(self): # test that -0j and 0j literals are not identified z1, z2 = 0j, -0j - self.assertEquals(atan2(z1.imag, -1.), atan2(0., -1.)) - self.assertEquals(atan2(z2.imag, -1.), atan2(-0., -1.)) + self.assertEqual(atan2(z1.imag, -1.), atan2(0., -1.)) + self.assertEqual(atan2(z2.imag, -1.), atan2(-0., -1.)) @unittest.skipUnless(float.__getformat__("double").startswith("IEEE"), "test requires IEEE 754 doubles") diff --git a/Lib/test/test_concurrent_futures.py b/Lib/test/test_concurrent_futures.py index 85e47d8..430a9be 100644 --- a/Lib/test/test_concurrent_futures.py +++ b/Lib/test/test_concurrent_futures.py @@ -249,8 +249,8 @@ class WaitTests(unittest.TestCase): [CANCELLED_FUTURE, future1, future2], return_when=futures.FIRST_COMPLETED) - self.assertEquals(set([future1]), done) - self.assertEquals(set([CANCELLED_FUTURE, future2]), not_done) + self.assertEqual(set([future1]), done) + self.assertEqual(set([CANCELLED_FUTURE, future2]), not_done) finally: call1.close() call2.close() @@ -264,8 +264,8 @@ class WaitTests(unittest.TestCase): [SUCCESSFUL_FUTURE, future1], return_when=futures.FIRST_COMPLETED) - self.assertEquals(set([SUCCESSFUL_FUTURE]), finished) - self.assertEquals(set([future1]), pending) + self.assertEqual(set([SUCCESSFUL_FUTURE]), finished) + self.assertEqual(set([future1]), pending) finally: call1.close() @@ -290,8 +290,8 @@ class WaitTests(unittest.TestCase): [future1, future2, future3], return_when=futures.FIRST_EXCEPTION) - self.assertEquals(set([future1, future2]), finished) - self.assertEquals(set([future3]), pending) + self.assertEqual(set([future1, future2]), finished) + self.assertEqual(set([future3]), pending) finally: call1.close() call2.close() @@ -318,10 +318,10 @@ class WaitTests(unittest.TestCase): future1, future2], return_when=futures.FIRST_EXCEPTION) - self.assertEquals(set([SUCCESSFUL_FUTURE, - CANCELLED_AND_NOTIFIED_FUTURE, - future1]), finished) - self.assertEquals(set([CANCELLED_FUTURE, future2]), pending) + self.assertEqual(set([SUCCESSFUL_FUTURE, + CANCELLED_AND_NOTIFIED_FUTURE, + future1]), finished) + self.assertEqual(set([CANCELLED_FUTURE, future2]), pending) finally: @@ -337,8 +337,8 @@ class WaitTests(unittest.TestCase): [EXCEPTION_FUTURE, future1], return_when=futures.FIRST_EXCEPTION) - self.assertEquals(set([EXCEPTION_FUTURE]), finished) - self.assertEquals(set([future1]), pending) + self.assertEqual(set([EXCEPTION_FUTURE]), finished) + self.assertEqual(set([future1]), pending) finally: call1.close() @@ -361,8 +361,8 @@ class WaitTests(unittest.TestCase): [future1, future2], return_when=futures.ALL_COMPLETED) - self.assertEquals(set([future1, future2]), finished) - self.assertEquals(set(), pending) + self.assertEqual(set([future1, future2]), finished) + self.assertEqual(set(), pending) finally: @@ -403,11 +403,11 @@ class WaitTests(unittest.TestCase): future1, future2, future3, future4], return_when=futures.ALL_COMPLETED) - self.assertEquals(set([SUCCESSFUL_FUTURE, - CANCELLED_AND_NOTIFIED_FUTURE, - future1, future2, future3, future4]), - finished) - self.assertEquals(set(), pending) + self.assertEqual(set([SUCCESSFUL_FUTURE, + CANCELLED_AND_NOTIFIED_FUTURE, + future1, future2, future3, future4]), + finished) + self.assertEqual(set(), pending) finally: call1.close() call2.close() @@ -436,11 +436,11 @@ class WaitTests(unittest.TestCase): timeout=5, return_when=futures.ALL_COMPLETED) - self.assertEquals(set([CANCELLED_AND_NOTIFIED_FUTURE, - EXCEPTION_FUTURE, - SUCCESSFUL_FUTURE, - future1]), finished) - self.assertEquals(set([future2]), pending) + self.assertEqual(set([CANCELLED_AND_NOTIFIED_FUTURE, + EXCEPTION_FUTURE, + SUCCESSFUL_FUTURE, + future1]), finished) + self.assertEqual(set([future2]), pending) finally: @@ -484,7 +484,7 @@ class AsCompletedTests(unittest.TestCase): EXCEPTION_FUTURE, SUCCESSFUL_FUTURE, future1, future2])) - self.assertEquals(set( + self.assertEqual(set( [CANCELLED_AND_NOTIFIED_FUTURE, EXCEPTION_FUTURE, SUCCESSFUL_FUTURE, @@ -510,10 +510,10 @@ class AsCompletedTests(unittest.TestCase): except futures.TimeoutError: pass - self.assertEquals(set([CANCELLED_AND_NOTIFIED_FUTURE, - EXCEPTION_FUTURE, - SUCCESSFUL_FUTURE]), - completed_futures) + self.assertEqual(set([CANCELLED_AND_NOTIFIED_FUTURE, + EXCEPTION_FUTURE, + SUCCESSFUL_FUTURE]), + completed_futures) finally: call1.close() @@ -536,11 +536,11 @@ class ExecutorTest(unittest.TestCase): # ExecutorShutdownTest. def test_submit(self): future = self.executor.submit(pow, 2, 8) - self.assertEquals(256, future.result()) + self.assertEqual(256, future.result()) def test_submit_keyword(self): future = self.executor.submit(mul, 2, y=8) - self.assertEquals(16, future.result()) + self.assertEqual(16, future.result()) def test_map(self): self.assertEqual( @@ -569,7 +569,7 @@ class ExecutorTest(unittest.TestCase): finally: timeout_call.close() - self.assertEquals([42, 42], results) + self.assertEqual([42, 42], results) class ThreadPoolExecutorTest(ExecutorTest): def setUp(self): @@ -595,7 +595,7 @@ class FutureTests(unittest.TestCase): f = Future() f.add_done_callback(fn) f.set_result(5) - self.assertEquals(5, callback_result) + self.assertEqual(5, callback_result) def test_done_callback_with_exception(self): callback_exception = None @@ -606,7 +606,7 @@ class FutureTests(unittest.TestCase): f = Future() f.add_done_callback(fn) f.set_exception(Exception('test')) - self.assertEquals(('test',), callback_exception.args) + self.assertEqual(('test',), callback_exception.args) def test_done_callback_with_cancel(self): was_cancelled = None @@ -657,7 +657,7 @@ class FutureTests(unittest.TestCase): f = Future() f.set_result(5) f.add_done_callback(fn) - self.assertEquals(5, callback_result) + self.assertEqual(5, callback_result) def test_done_callback_already_failed(self): callback_exception = None @@ -668,7 +668,7 @@ class FutureTests(unittest.TestCase): f = Future() f.set_exception(Exception('test')) f.add_done_callback(fn) - self.assertEquals(('test',), callback_exception.args) + self.assertEqual(('test',), callback_exception.args) def test_done_callback_already_cancelled(self): was_cancelled = None @@ -707,22 +707,22 @@ class FutureTests(unittest.TestCase): f6 = create_future(state=FINISHED, result=5) self.assertTrue(f1.cancel()) - self.assertEquals(f1._state, CANCELLED) + self.assertEqual(f1._state, CANCELLED) self.assertFalse(f2.cancel()) - self.assertEquals(f2._state, RUNNING) + self.assertEqual(f2._state, RUNNING) self.assertTrue(f3.cancel()) - self.assertEquals(f3._state, CANCELLED) + self.assertEqual(f3._state, CANCELLED) self.assertTrue(f4.cancel()) - self.assertEquals(f4._state, CANCELLED_AND_NOTIFIED) + self.assertEqual(f4._state, CANCELLED_AND_NOTIFIED) self.assertFalse(f5.cancel()) - self.assertEquals(f5._state, FINISHED) + self.assertEqual(f5._state, FINISHED) self.assertFalse(f6.cancel()) - self.assertEquals(f6._state, FINISHED) + self.assertEqual(f6._state, FINISHED) def test_cancelled(self): self.assertFalse(PENDING_FUTURE.cancelled()) @@ -771,7 +771,7 @@ class FutureTests(unittest.TestCase): t = threading.Thread(target=notification) t.start() - self.assertEquals(f1.result(timeout=5), 42) + self.assertEqual(f1.result(timeout=5), 42) def test_result_with_cancel(self): # TODO(brian@sweetapp.com): This test is timing dependant. diff --git a/Lib/test/test_copyreg.py b/Lib/test/test_copyreg.py index 8359e28..abe0748 100644 --- a/Lib/test/test_copyreg.py +++ b/Lib/test/test_copyreg.py @@ -40,7 +40,7 @@ class CopyRegTestCase(unittest.TestCase): def test_bool(self): import copy - self.assertEquals(True, copy.copy(True)) + self.assertEqual(True, copy.copy(True)) def test_extension_registry(self): mod, func, code = 'junk1 ', ' junk2', 0xabcd @@ -101,16 +101,16 @@ class CopyRegTestCase(unittest.TestCase): mod, func, code) def test_slotnames(self): - self.assertEquals(copyreg._slotnames(WithoutSlots), []) - self.assertEquals(copyreg._slotnames(WithWeakref), []) + self.assertEqual(copyreg._slotnames(WithoutSlots), []) + self.assertEqual(copyreg._slotnames(WithWeakref), []) expected = ['_WithPrivate__spam'] - self.assertEquals(copyreg._slotnames(WithPrivate), expected) - self.assertEquals(copyreg._slotnames(WithSingleString), ['spam']) + self.assertEqual(copyreg._slotnames(WithPrivate), expected) + self.assertEqual(copyreg._slotnames(WithSingleString), ['spam']) expected = ['eggs', 'spam'] expected.sort() result = copyreg._slotnames(WithInherited) result.sort() - self.assertEquals(result, expected) + self.assertEqual(result, expected) def test_main(): diff --git a/Lib/test/test_deque.py b/Lib/test/test_deque.py index 17d724c..da00c0d 100644 --- a/Lib/test/test_deque.py +++ b/Lib/test/test_deque.py @@ -234,7 +234,7 @@ class TestBasic(unittest.TestCase): d = deque(data[:i]) r = d.reverse() self.assertEqual(list(d), list(reversed(data[:i]))) - self.assert_(r is None) + self.assertIs(r, None) d.reverse() self.assertEqual(list(d), data[:i]) self.assertRaises(TypeError, d.reverse, 1) # Arity is zero diff --git a/Lib/test/test_descr.py b/Lib/test/test_descr.py index 47fecfe..932214d 100644 --- a/Lib/test/test_descr.py +++ b/Lib/test/test_descr.py @@ -4205,11 +4205,11 @@ order (MRO) for bases """ __getattr__ = descr self.assertRaises(AttributeError, getattr, A(), "attr") - self.assertEquals(descr.counter, 1) + self.assertEqual(descr.counter, 1) self.assertRaises(AttributeError, getattr, B(), "attr") - self.assertEquals(descr.counter, 2) + self.assertEqual(descr.counter, 2) self.assertRaises(AttributeError, getattr, C(), "attr") - self.assertEquals(descr.counter, 4) + self.assertEqual(descr.counter, 4) import gc class EvilGetattribute(object): @@ -4236,7 +4236,7 @@ class DictProxyTests(unittest.TestCase): # Testing dict-proxy iterkeys... keys = [ key for key in self.C.__dict__.keys() ] keys.sort() - self.assertEquals(keys, ['__dict__', '__doc__', '__module__', + self.assertEqual(keys, ['__dict__', '__doc__', '__module__', '__weakref__', 'meth']) def test_iter_values(self): diff --git a/Lib/test/test_epoll.py b/Lib/test/test_epoll.py index 04140ef..275e598 100644 --- a/Lib/test/test_epoll.py +++ b/Lib/test/test_epoll.py @@ -56,7 +56,7 @@ class TestEPoll(unittest.TestCase): try: client.connect(('127.0.0.1', self.serverSocket.getsockname()[1])) except socket.error as e: - self.assertEquals(e.args[0], errno.EINPROGRESS) + self.assertEqual(e.args[0], errno.EINPROGRESS) else: raise AssertionError("Connect should have raised EINPROGRESS") server, addr = self.serverSocket.accept() @@ -162,7 +162,7 @@ class TestEPoll(unittest.TestCase): (server.fileno(), select.EPOLLOUT)] expected.sort() - self.assertEquals(events, expected) + self.assertEqual(events, expected) self.assertFalse(then - now > 0.01, then - now) now = time.time() @@ -183,7 +183,7 @@ class TestEPoll(unittest.TestCase): (server.fileno(), select.EPOLLIN | select.EPOLLOUT)] expected.sort() - self.assertEquals(events, expected) + self.assertEqual(events, expected) ep.unregister(client.fileno()) ep.modify(server.fileno(), select.EPOLLOUT) @@ -193,7 +193,7 @@ class TestEPoll(unittest.TestCase): self.assertFalse(then - now > 0.01) expected = [(server.fileno(), select.EPOLLOUT)] - self.assertEquals(events, expected) + self.assertEqual(events, expected) def test_errors(self): self.assertRaises(ValueError, select.epoll, -2) diff --git a/Lib/test/test_exceptions.py b/Lib/test/test_exceptions.py index 2cbd972..76f4249 100644 --- a/Lib/test/test_exceptions.py +++ b/Lib/test/test_exceptions.py @@ -22,8 +22,8 @@ class ExceptionTests(unittest.TestCase): raise exc("spam") except exc as err: buf2 = str(err) - self.assertEquals(buf1, buf2) - self.assertEquals(exc.__name__, excname) + self.assertEqual(buf1, buf2) + self.assertEqual(exc.__name__, excname) def testRaising(self): self.raise_catch(AttributeError, "AttributeError") @@ -156,7 +156,7 @@ class ExceptionTests(unittest.TestCase): except TypeError as err: exc, err, tb = sys.exc_info() co = tb.tb_frame.f_code - self.assertEquals(co.co_name, "test_capi1") + self.assertEqual(co.co_name, "test_capi1") self.assertTrue(co.co_filename.endswith('test_exceptions.py')) else: self.fail("Expected exception") @@ -168,10 +168,10 @@ class ExceptionTests(unittest.TestCase): except RuntimeError as err: exc, err, tb = sys.exc_info() co = tb.tb_frame.f_code - self.assertEquals(co.co_name, "__init__") + self.assertEqual(co.co_name, "__init__") self.assertTrue(co.co_filename.endswith('test_exceptions.py')) co2 = tb.tb_frame.f_back.f_code - self.assertEquals(co2.co_name, "test_capi2") + self.assertEqual(co2.co_name, "test_capi2") else: self.fail("Expected exception") @@ -191,10 +191,9 @@ class ExceptionTests(unittest.TestCase): except NameError: pass else: - self.assertEqual(str(WindowsError(1001)), - "1001") + self.assertEqual(str(WindowsError(1001)), "1001") self.assertEqual(str(WindowsError(1001, "message")), - "[Error 1001] message") + "[Error 1001] message") self.assertEqual(WindowsError(1001, "message").errno, 22) self.assertEqual(WindowsError(1001, "message").winerror, 1001) @@ -291,16 +290,16 @@ class ExceptionTests(unittest.TestCase): raise else: # Verify module name - self.assertEquals(type(e).__module__, 'builtins') + self.assertEqual(type(e).__module__, 'builtins') # Verify no ref leaks in Exc_str() s = str(e) for checkArgName in expected: value = getattr(e, checkArgName) - self.assertEquals(repr(value), - repr(expected[checkArgName]), - '%r.%s == %r, expected %r' % ( - e, checkArgName, - value, expected[checkArgName])) + self.assertEqual(repr(value), + repr(expected[checkArgName]), + '%r.%s == %r, expected %r' % ( + e, checkArgName, + value, expected[checkArgName])) # test for pickling support for p in [pickle]: @@ -310,9 +309,9 @@ class ExceptionTests(unittest.TestCase): for checkArgName in expected: got = repr(getattr(new, checkArgName)) want = repr(expected[checkArgName]) - self.assertEquals(got, want, - 'pickled "%r", attribute "%s' % - (e, checkArgName)) + self.assertEqual(got, want, + 'pickled "%r", attribute "%s' % + (e, checkArgName)) def testWithTraceback(self): try: @@ -387,7 +386,7 @@ class ExceptionTests(unittest.TestCase): self.fancy_arg = fancy_arg x = DerivedException(fancy_arg=42) - self.assertEquals(x.fancy_arg, 42) + self.assertEqual(x.fancy_arg, 42) def testInfiniteRecursion(self): def f(): @@ -548,24 +547,24 @@ class ExceptionTests(unittest.TestCase): yield sys.exc_info()[0] yield sys.exc_info()[0] g = yield_raise() - self.assertEquals(next(g), KeyError) - self.assertEquals(sys.exc_info()[0], None) - self.assertEquals(next(g), KeyError) - self.assertEquals(sys.exc_info()[0], None) - self.assertEquals(next(g), None) + self.assertEqual(next(g), KeyError) + self.assertEqual(sys.exc_info()[0], None) + self.assertEqual(next(g), KeyError) + self.assertEqual(sys.exc_info()[0], None) + self.assertEqual(next(g), None) # Same test, but inside an exception handler try: raise TypeError("foo") except TypeError: g = yield_raise() - self.assertEquals(next(g), KeyError) - self.assertEquals(sys.exc_info()[0], TypeError) - self.assertEquals(next(g), KeyError) - self.assertEquals(sys.exc_info()[0], TypeError) - self.assertEquals(next(g), TypeError) + self.assertEqual(next(g), KeyError) + self.assertEqual(sys.exc_info()[0], TypeError) + self.assertEqual(next(g), KeyError) + self.assertEqual(sys.exc_info()[0], TypeError) + self.assertEqual(next(g), TypeError) del g - self.assertEquals(sys.exc_info()[0], TypeError) + self.assertEqual(sys.exc_info()[0], TypeError) def test_generator_finalizing_and_exc_info(self): # See #7173 @@ -593,7 +592,7 @@ class ExceptionTests(unittest.TestCase): raise Exception(MyObject()) except: pass - self.assertEquals(e, (None, None, None)) + self.assertEqual(e, (None, None, None)) def testUnicodeChangeAttributes(self): # See issue 7309. This was a crasher. diff --git a/Lib/test/test_file.py b/Lib/test/test_file.py index c48b8d0..bb0da79 100644 --- a/Lib/test/test_file.py +++ b/Lib/test/test_file.py @@ -25,7 +25,7 @@ class AutoFileTests(unittest.TestCase): # verify weak references p = proxy(self.f) p.write(b'teststring') - self.assertEquals(self.f.tell(), p.tell()) + self.assertEqual(self.f.tell(), p.tell()) self.f.close() self.f = None self.assertRaises(ReferenceError, getattr, p, 'tell') @@ -44,7 +44,7 @@ class AutoFileTests(unittest.TestCase): a = array('b', b'x'*10) self.f = self.open(TESTFN, 'rb') n = self.f.readinto(a) - self.assertEquals(b'12', a.tobytes()[:n]) + self.assertEqual(b'12', a.tobytes()[:n]) def testReadinto_text(self): # verify readinto refuses text files @@ -61,7 +61,7 @@ class AutoFileTests(unittest.TestCase): self.f.close() self.f = self.open(TESTFN, 'rb') buf = self.f.read() - self.assertEquals(buf, b'12') + self.assertEqual(buf, b'12') def testWritelinesIntegers(self): # verify writelines with integers @@ -82,7 +82,7 @@ class AutoFileTests(unittest.TestCase): def testErrors(self): f = self.f - self.assertEquals(f.name, TESTFN) + self.assertEqual(f.name, TESTFN) self.assertTrue(not f.isatty()) self.assertTrue(not f.closed) @@ -118,12 +118,12 @@ class AutoFileTests(unittest.TestCase): self.assertRaises(ValueError, method, *args) # file is closed, __exit__ shouldn't do anything - self.assertEquals(self.f.__exit__(None, None, None), None) + self.assertEqual(self.f.__exit__(None, None, None), None) # it must also return None if an exception was given try: 1/0 except: - self.assertEquals(self.f.__exit__(*sys.exc_info()), None) + self.assertEqual(self.f.__exit__(*sys.exc_info()), None) def testReadWhenWriting(self): self.assertRaises(IOError, self.f.read) @@ -189,7 +189,7 @@ class OtherFileTests(unittest.TestCase): f.close() except IOError as msg: self.fail('error setting buffer size %d: %s' % (s, str(msg))) - self.assertEquals(d, s) + self.assertEqual(d, s) def testTruncateOnWindows(self): # SF bug <http://www.python.org/sf/801631> diff --git a/Lib/test/test_fileio.py b/Lib/test/test_fileio.py index 154cdd3..103365d 100644 --- a/Lib/test/test_fileio.py +++ b/Lib/test/test_fileio.py @@ -27,31 +27,31 @@ class AutoFileTests(unittest.TestCase): # verify weak references p = proxy(self.f) p.write(bytes(range(10))) - self.assertEquals(self.f.tell(), p.tell()) + self.assertEqual(self.f.tell(), p.tell()) self.f.close() self.f = None self.assertRaises(ReferenceError, getattr, p, 'tell') def testSeekTell(self): self.f.write(bytes(range(20))) - self.assertEquals(self.f.tell(), 20) + self.assertEqual(self.f.tell(), 20) self.f.seek(0) - self.assertEquals(self.f.tell(), 0) + self.assertEqual(self.f.tell(), 0) self.f.seek(10) - self.assertEquals(self.f.tell(), 10) + self.assertEqual(self.f.tell(), 10) self.f.seek(5, 1) - self.assertEquals(self.f.tell(), 15) + self.assertEqual(self.f.tell(), 15) self.f.seek(-5, 1) - self.assertEquals(self.f.tell(), 10) + self.assertEqual(self.f.tell(), 10) self.f.seek(-5, 2) - self.assertEquals(self.f.tell(), 15) + self.assertEqual(self.f.tell(), 15) def testAttributes(self): # verify expected attributes exist f = self.f - self.assertEquals(f.mode, "wb") - self.assertEquals(f.closed, False) + self.assertEqual(f.mode, "wb") + self.assertEqual(f.closed, False) # verify the attributes are readonly for attr in 'mode', 'closed': @@ -65,7 +65,7 @@ class AutoFileTests(unittest.TestCase): a = array('b', b'x'*10) self.f = _FileIO(TESTFN, 'r') n = self.f.readinto(a) - self.assertEquals(array('b', [1, 2]), a[:n]) + self.assertEqual(array('b', [1, 2]), a[:n]) def test_none_args(self): self.f.write(b"hi\nbye\nabc") @@ -80,19 +80,19 @@ class AutoFileTests(unittest.TestCase): self.assertRaises(TypeError, self.f.write, "Hello!") def testRepr(self): - self.assertEquals(repr(self.f), "<_io.FileIO name=%r mode=%r>" + self.assertEqual(repr(self.f), "<_io.FileIO name=%r mode=%r>" % (self.f.name, self.f.mode)) del self.f.name - self.assertEquals(repr(self.f), "<_io.FileIO fd=%r mode=%r>" + self.assertEqual(repr(self.f), "<_io.FileIO fd=%r mode=%r>" % (self.f.fileno(), self.f.mode)) self.f.close() - self.assertEquals(repr(self.f), "<_io.FileIO [closed]>") + self.assertEqual(repr(self.f), "<_io.FileIO [closed]>") def testErrors(self): f = self.f self.assertTrue(not f.isatty()) self.assertTrue(not f.closed) - #self.assertEquals(f.name, TESTFN) + #self.assertEqual(f.name, TESTFN) self.assertRaises(ValueError, f.read, 10) # Open for reading f.close() self.assertTrue(f.closed) @@ -233,22 +233,22 @@ class OtherFileTests(unittest.TestCase): def testAbles(self): try: f = _FileIO(TESTFN, "w") - self.assertEquals(f.readable(), False) - self.assertEquals(f.writable(), True) - self.assertEquals(f.seekable(), True) + self.assertEqual(f.readable(), False) + self.assertEqual(f.writable(), True) + self.assertEqual(f.seekable(), True) f.close() f = _FileIO(TESTFN, "r") - self.assertEquals(f.readable(), True) - self.assertEquals(f.writable(), False) - self.assertEquals(f.seekable(), True) + self.assertEqual(f.readable(), True) + self.assertEqual(f.writable(), False) + self.assertEqual(f.seekable(), True) f.close() f = _FileIO(TESTFN, "a+") - self.assertEquals(f.readable(), True) - self.assertEquals(f.writable(), True) - self.assertEquals(f.seekable(), True) - self.assertEquals(f.isatty(), False) + self.assertEqual(f.readable(), True) + self.assertEqual(f.writable(), True) + self.assertEqual(f.seekable(), True) + self.assertEqual(f.isatty(), False) f.close() if sys.platform != "win32": @@ -260,14 +260,14 @@ class OtherFileTests(unittest.TestCase): # OS'es that don't support /dev/tty. pass else: - self.assertEquals(f.readable(), False) - self.assertEquals(f.writable(), True) + self.assertEqual(f.readable(), False) + self.assertEqual(f.writable(), True) if sys.platform != "darwin" and \ 'bsd' not in sys.platform and \ not sys.platform.startswith('sunos'): # Somehow /dev/tty appears seekable on some BSDs - self.assertEquals(f.seekable(), False) - self.assertEquals(f.isatty(), True) + self.assertEqual(f.seekable(), False) + self.assertEqual(f.isatty(), True) f.close() finally: os.unlink(TESTFN) @@ -301,7 +301,7 @@ class OtherFileTests(unittest.TestCase): f.write(b"abc") f.close() with open(TESTFN, "rb") as f: - self.assertEquals(f.read(), b"abc") + self.assertEqual(f.read(), b"abc") finally: os.unlink(TESTFN) diff --git a/Lib/test/test_float.py b/Lib/test/test_float.py index 61e71fc..e0479db 100644 --- a/Lib/test/test_float.py +++ b/Lib/test/test_float.py @@ -554,9 +554,9 @@ class FormatTestCase(unittest.TestCase): self.assertEqual(fmt % -float(arg), '-' + rhs) def test_issue5864(self): - self.assertEquals(format(123.456, '.4'), '123.5') - self.assertEquals(format(1234.56, '.4'), '1.235e+03') - self.assertEquals(format(12345.6, '.4'), '1.235e+04') + self.assertEqual(format(123.456, '.4'), '123.5') + self.assertEqual(format(1234.56, '.4'), '1.235e+03') + self.assertEqual(format(12345.6, '.4'), '1.235e+04') class ReprTestCase(unittest.TestCase): def test_repr(self): diff --git a/Lib/test/test_fractions.py b/Lib/test/test_fractions.py index c28f06c..a63ee89 100644 --- a/Lib/test/test_fractions.py +++ b/Lib/test/test_fractions.py @@ -84,16 +84,16 @@ class DummyRational(object): class GcdTest(unittest.TestCase): def testMisc(self): - self.assertEquals(0, gcd(0, 0)) - self.assertEquals(1, gcd(1, 0)) - self.assertEquals(-1, gcd(-1, 0)) - self.assertEquals(1, gcd(0, 1)) - self.assertEquals(-1, gcd(0, -1)) - self.assertEquals(1, gcd(7, 1)) - self.assertEquals(-1, gcd(7, -1)) - self.assertEquals(1, gcd(-23, 15)) - self.assertEquals(12, gcd(120, 84)) - self.assertEquals(-12, gcd(84, -120)) + self.assertEqual(0, gcd(0, 0)) + self.assertEqual(1, gcd(1, 0)) + self.assertEqual(-1, gcd(-1, 0)) + self.assertEqual(1, gcd(0, 1)) + self.assertEqual(-1, gcd(0, -1)) + self.assertEqual(1, gcd(7, 1)) + self.assertEqual(-1, gcd(7, -1)) + self.assertEqual(1, gcd(-23, 15)) + self.assertEqual(12, gcd(120, 84)) + self.assertEqual(-12, gcd(84, -120)) def _components(r): @@ -104,8 +104,8 @@ class FractionTest(unittest.TestCase): def assertTypedEquals(self, expected, actual): """Asserts that both the types and values are the same.""" - self.assertEquals(type(expected), type(actual)) - self.assertEquals(expected, actual) + self.assertEqual(type(expected), type(actual)) + self.assertEqual(expected, actual) def assertRaisesMessage(self, exc_type, message, callable, *args, **kwargs): @@ -113,25 +113,25 @@ class FractionTest(unittest.TestCase): try: callable(*args, **kwargs) except exc_type as e: - self.assertEquals(message, str(e)) + self.assertEqual(message, str(e)) else: self.fail("%s not raised" % exc_type.__name__) def testInit(self): - self.assertEquals((0, 1), _components(F())) - self.assertEquals((7, 1), _components(F(7))) - self.assertEquals((7, 3), _components(F(F(7, 3)))) + self.assertEqual((0, 1), _components(F())) + self.assertEqual((7, 1), _components(F(7))) + self.assertEqual((7, 3), _components(F(F(7, 3)))) - self.assertEquals((-1, 1), _components(F(-1, 1))) - self.assertEquals((-1, 1), _components(F(1, -1))) - self.assertEquals((1, 1), _components(F(-2, -2))) - self.assertEquals((1, 2), _components(F(5, 10))) - self.assertEquals((7, 15), _components(F(7, 15))) - self.assertEquals((10**23, 1), _components(F(10**23))) + self.assertEqual((-1, 1), _components(F(-1, 1))) + self.assertEqual((-1, 1), _components(F(1, -1))) + self.assertEqual((1, 1), _components(F(-2, -2))) + self.assertEqual((1, 2), _components(F(5, 10))) + self.assertEqual((7, 15), _components(F(7, 15))) + self.assertEqual((10**23, 1), _components(F(10**23))) - self.assertEquals((3, 77), _components(F(F(3, 7), 11))) - self.assertEquals((-9, 5), _components(F(2, F(-10, 9)))) - self.assertEquals((2486, 2485), _components(F(F(22, 7), F(355, 113)))) + self.assertEqual((3, 77), _components(F(F(3, 7), 11))) + self.assertEqual((-9, 5), _components(F(2, F(-10, 9)))) + self.assertEqual((2486, 2485), _components(F(F(22, 7), F(355, 113)))) self.assertRaisesMessage(ZeroDivisionError, "Fraction(12, 0)", F, 12, 0) @@ -143,41 +143,41 @@ class FractionTest(unittest.TestCase): @requires_IEEE_754 def testInitFromFloat(self): - self.assertEquals((5, 2), _components(F(2.5))) - self.assertEquals((0, 1), _components(F(-0.0))) - self.assertEquals((3602879701896397, 36028797018963968), - _components(F(0.1))) + self.assertEqual((5, 2), _components(F(2.5))) + self.assertEqual((0, 1), _components(F(-0.0))) + self.assertEqual((3602879701896397, 36028797018963968), + _components(F(0.1))) self.assertRaises(TypeError, F, float('nan')) self.assertRaises(TypeError, F, float('inf')) self.assertRaises(TypeError, F, float('-inf')) def testInitFromDecimal(self): - self.assertEquals((11, 10), - _components(F(Decimal('1.1')))) - self.assertEquals((7, 200), - _components(F(Decimal('3.5e-2')))) - self.assertEquals((0, 1), - _components(F(Decimal('.000e20')))) + self.assertEqual((11, 10), + _components(F(Decimal('1.1')))) + self.assertEqual((7, 200), + _components(F(Decimal('3.5e-2')))) + self.assertEqual((0, 1), + _components(F(Decimal('.000e20')))) self.assertRaises(TypeError, F, Decimal('nan')) self.assertRaises(TypeError, F, Decimal('snan')) self.assertRaises(TypeError, F, Decimal('inf')) self.assertRaises(TypeError, F, Decimal('-inf')) def testFromString(self): - self.assertEquals((5, 1), _components(F("5"))) - self.assertEquals((3, 2), _components(F("3/2"))) - self.assertEquals((3, 2), _components(F(" \n +3/2"))) - self.assertEquals((-3, 2), _components(F("-3/2 "))) - self.assertEquals((13, 2), _components(F(" 013/02 \n "))) - self.assertEquals((16, 5), _components(F(" 3.2 "))) - self.assertEquals((-16, 5), _components(F(" -3.2 "))) - self.assertEquals((-3, 1), _components(F(" -3. "))) - self.assertEquals((3, 5), _components(F(" .6 "))) - self.assertEquals((1, 3125), _components(F("32.e-5"))) - self.assertEquals((1000000, 1), _components(F("1E+06"))) - self.assertEquals((-12300, 1), _components(F("-1.23e4"))) - self.assertEquals((0, 1), _components(F(" .0e+0\t"))) - self.assertEquals((0, 1), _components(F("-0.000e0"))) + self.assertEqual((5, 1), _components(F("5"))) + self.assertEqual((3, 2), _components(F("3/2"))) + self.assertEqual((3, 2), _components(F(" \n +3/2"))) + self.assertEqual((-3, 2), _components(F("-3/2 "))) + self.assertEqual((13, 2), _components(F(" 013/02 \n "))) + self.assertEqual((16, 5), _components(F(" 3.2 "))) + self.assertEqual((-16, 5), _components(F(" -3.2 "))) + self.assertEqual((-3, 1), _components(F(" -3. "))) + self.assertEqual((3, 5), _components(F(" .6 "))) + self.assertEqual((1, 3125), _components(F("32.e-5"))) + self.assertEqual((1000000, 1), _components(F("1E+06"))) + self.assertEqual((-12300, 1), _components(F("-1.23e4"))) + self.assertEqual((0, 1), _components(F(" .0e+0\t"))) + self.assertEqual((0, 1), _components(F("-0.000e0"))) self.assertRaisesMessage( ZeroDivisionError, "Fraction(3, 0)", @@ -219,33 +219,33 @@ class FractionTest(unittest.TestCase): def testImmutable(self): r = F(7, 3) r.__init__(2, 15) - self.assertEquals((7, 3), _components(r)) + self.assertEqual((7, 3), _components(r)) self.assertRaises(AttributeError, setattr, r, 'numerator', 12) self.assertRaises(AttributeError, setattr, r, 'denominator', 6) - self.assertEquals((7, 3), _components(r)) + self.assertEqual((7, 3), _components(r)) # But if you _really_ need to: r._numerator = 4 r._denominator = 2 - self.assertEquals((4, 2), _components(r)) + self.assertEqual((4, 2), _components(r)) # Which breaks some important operations: - self.assertNotEquals(F(4, 2), r) + self.assertNotEqual(F(4, 2), r) def testFromFloat(self): self.assertRaises(TypeError, F.from_float, 3+4j) - self.assertEquals((10, 1), _components(F.from_float(10))) + self.assertEqual((10, 1), _components(F.from_float(10))) bigint = 1234567890123456789 - self.assertEquals((bigint, 1), _components(F.from_float(bigint))) - self.assertEquals((0, 1), _components(F.from_float(-0.0))) - self.assertEquals((10, 1), _components(F.from_float(10.0))) - self.assertEquals((-5, 2), _components(F.from_float(-2.5))) - self.assertEquals((99999999999999991611392, 1), - _components(F.from_float(1e23))) - self.assertEquals(float(10**23), float(F.from_float(1e23))) - self.assertEquals((3602879701896397, 1125899906842624), - _components(F.from_float(3.2))) - self.assertEquals(3.2, float(F.from_float(3.2))) + self.assertEqual((bigint, 1), _components(F.from_float(bigint))) + self.assertEqual((0, 1), _components(F.from_float(-0.0))) + self.assertEqual((10, 1), _components(F.from_float(10.0))) + self.assertEqual((-5, 2), _components(F.from_float(-2.5))) + self.assertEqual((99999999999999991611392, 1), + _components(F.from_float(1e23))) + self.assertEqual(float(10**23), float(F.from_float(1e23))) + self.assertEqual((3602879701896397, 1125899906842624), + _components(F.from_float(3.2))) + self.assertEqual(3.2, float(F.from_float(3.2))) inf = 1e1000 nan = inf - inf @@ -261,13 +261,13 @@ class FractionTest(unittest.TestCase): def testFromDecimal(self): self.assertRaises(TypeError, F.from_decimal, 3+4j) - self.assertEquals(F(10, 1), F.from_decimal(10)) - self.assertEquals(F(0), F.from_decimal(Decimal("-0"))) - self.assertEquals(F(5, 10), F.from_decimal(Decimal("0.5"))) - self.assertEquals(F(5, 1000), F.from_decimal(Decimal("5e-3"))) - self.assertEquals(F(5000), F.from_decimal(Decimal("5e3"))) - self.assertEquals(1 - F(1, 10**30), - F.from_decimal(Decimal("0." + "9" * 30))) + self.assertEqual(F(10, 1), F.from_decimal(10)) + self.assertEqual(F(0), F.from_decimal(Decimal("-0"))) + self.assertEqual(F(5, 10), F.from_decimal(Decimal("0.5"))) + self.assertEqual(F(5, 1000), F.from_decimal(Decimal("5e-3"))) + self.assertEqual(F(5000), F.from_decimal(Decimal("5e3"))) + self.assertEqual(1 - F(1, 10**30), + F.from_decimal(Decimal("0." + "9" * 30))) self.assertRaisesMessage( TypeError, "Cannot convert Infinity to Fraction.", @@ -303,15 +303,15 @@ class FractionTest(unittest.TestCase): self.assertTypedEquals(-2, round(F(-15, 10))) self.assertTypedEquals(-1, round(F(-7, 10))) - self.assertEquals(False, bool(F(0, 1))) - self.assertEquals(True, bool(F(3, 2))) + self.assertEqual(False, bool(F(0, 1))) + self.assertEqual(True, bool(F(3, 2))) self.assertTypedEquals(0.1, float(F(1, 10))) # Check that __float__ isn't implemented by converting the # numerator and denominator to float before dividing. self.assertRaises(OverflowError, float, int('2'*400+'7')) - self.assertAlmostEquals(2.0/3, - float(F(int('2'*400+'7'), int('3'*400+'1')))) + self.assertAlmostEqual(2.0/3, + float(F(int('2'*400+'7'), int('3'*400+'1')))) self.assertTypedEquals(0.1+0j, complex(F(1,10))) @@ -324,19 +324,19 @@ class FractionTest(unittest.TestCase): def testArithmetic(self): - self.assertEquals(F(1, 2), F(1, 10) + F(2, 5)) - self.assertEquals(F(-3, 10), F(1, 10) - F(2, 5)) - self.assertEquals(F(1, 25), F(1, 10) * F(2, 5)) - self.assertEquals(F(1, 4), F(1, 10) / F(2, 5)) + self.assertEqual(F(1, 2), F(1, 10) + F(2, 5)) + self.assertEqual(F(-3, 10), F(1, 10) - F(2, 5)) + self.assertEqual(F(1, 25), F(1, 10) * F(2, 5)) + self.assertEqual(F(1, 4), F(1, 10) / F(2, 5)) self.assertTypedEquals(2, F(9, 10) // F(2, 5)) self.assertTypedEquals(10**23, F(10**23, 1) // F(1)) - self.assertEquals(F(2, 3), F(-7, 3) % F(3, 2)) - self.assertEquals(F(8, 27), F(2, 3) ** F(3)) - self.assertEquals(F(27, 8), F(2, 3) ** F(-3)) + self.assertEqual(F(2, 3), F(-7, 3) % F(3, 2)) + self.assertEqual(F(8, 27), F(2, 3) ** F(3)) + self.assertEqual(F(27, 8), F(2, 3) ** F(-3)) self.assertTypedEquals(2.0, F(4) ** F(1, 2)) z = pow(F(-1), F(1, 2)) - self.assertAlmostEquals(z.real, 0) - self.assertEquals(z.imag, 1) + self.assertAlmostEqual(z.real, 0) + self.assertEqual(z.imag, 1) def testMixedArithmetic(self): self.assertTypedEquals(F(11, 10), F(1, 10) + 1) @@ -387,8 +387,8 @@ class FractionTest(unittest.TestCase): self.assertTypedEquals(0.1 + 0j, F(1, 10) ** (1.0 + 0j)) self.assertTypedEquals(4 , 2 ** F(2, 1)) z = pow(-1, F(1, 2)) - self.assertAlmostEquals(0, z.real) - self.assertEquals(1, z.imag) + self.assertAlmostEqual(0, z.real) + self.assertEqual(1, z.imag) self.assertTypedEquals(F(1, 4) , 2 ** F(-2, 1)) self.assertTypedEquals(2.0 , 4 ** F(1, 2)) self.assertTypedEquals(0.25, 2.0 ** F(-2, 1)) @@ -534,21 +534,21 @@ class FractionTest(unittest.TestCase): self.assertFalse(float('-inf') == F(2, 5)) def testStringification(self): - self.assertEquals("Fraction(7, 3)", repr(F(7, 3))) - self.assertEquals("Fraction(6283185307, 2000000000)", - repr(F('3.1415926535'))) - self.assertEquals("Fraction(-1, 100000000000000000000)", - repr(F(1, -10**20))) - self.assertEquals("7/3", str(F(7, 3))) - self.assertEquals("7", str(F(7, 1))) + self.assertEqual("Fraction(7, 3)", repr(F(7, 3))) + self.assertEqual("Fraction(6283185307, 2000000000)", + repr(F('3.1415926535'))) + self.assertEqual("Fraction(-1, 100000000000000000000)", + repr(F(1, -10**20))) + self.assertEqual("7/3", str(F(7, 3))) + self.assertEqual("7", str(F(7, 1))) def testHash(self): - self.assertEquals(hash(2.5), hash(F(5, 2))) - self.assertEquals(hash(10**50), hash(F(10**50))) - self.assertNotEquals(hash(float(10**23)), hash(F(10**23))) + self.assertEqual(hash(2.5), hash(F(5, 2))) + self.assertEqual(hash(10**50), hash(F(10**50))) + self.assertNotEqual(hash(float(10**23)), hash(F(10**23))) # Check that __hash__ produces the same value as hash(), for # consistency with int and Decimal. (See issue #10356.) - self.assertEquals(hash(F(-1)), F(-1).__hash__()) + self.assertEqual(hash(F(-1)), F(-1).__hash__()) def testApproximatePi(self): # Algorithm borrowed from @@ -561,7 +561,7 @@ class FractionTest(unittest.TestCase): d, da = d+da, da+32 t = (t * n) / d s += t - self.assertAlmostEquals(math.pi, s) + self.assertAlmostEqual(math.pi, s) def testApproximateCos1(self): # Algorithm borrowed from @@ -575,7 +575,7 @@ class FractionTest(unittest.TestCase): num *= x * x sign *= -1 s += num / fact * sign - self.assertAlmostEquals(math.cos(1), s) + self.assertAlmostEqual(math.cos(1), s) def test_copy_deepcopy_pickle(self): r = F(13, 7) diff --git a/Lib/test/test_frozen.py b/Lib/test/test_frozen.py index 11a366c..07131af 100644 --- a/Lib/test/test_frozen.py +++ b/Lib/test/test_frozen.py @@ -22,7 +22,7 @@ class FrozenTests(unittest.TestCase): self.assertEqual(len(dir(__phello__)), 8, dir(__phello__)) else: self.assertEqual(len(dir(__phello__)), 9, dir(__phello__)) - self.assertEquals(__phello__.__path__, [__phello__.__name__]) + self.assertEqual(__phello__.__path__, [__phello__.__name__]) try: import __phello__.spam diff --git a/Lib/test/test_functools.py b/Lib/test/test_functools.py index 82ad889..65ef9b4 100644 --- a/Lib/test/test_functools.py +++ b/Lib/test/test_functools.py @@ -428,12 +428,12 @@ class TestTotalOrdering(unittest.TestCase): self.value = value def __lt__(self, other): return self.value < other.value - self.assert_(A(1) < A(2)) - self.assert_(A(2) > A(1)) - self.assert_(A(1) <= A(2)) - self.assert_(A(2) >= A(1)) - self.assert_(A(2) <= A(2)) - self.assert_(A(2) >= A(2)) + self.assertTrue(A(1) < A(2)) + self.assertTrue(A(2) > A(1)) + self.assertTrue(A(1) <= A(2)) + self.assertTrue(A(2) >= A(1)) + self.assertTrue(A(2) <= A(2)) + self.assertTrue(A(2) >= A(2)) def test_total_ordering_le(self): @functools.total_ordering @@ -442,12 +442,12 @@ class TestTotalOrdering(unittest.TestCase): self.value = value def __le__(self, other): return self.value <= other.value - self.assert_(A(1) < A(2)) - self.assert_(A(2) > A(1)) - self.assert_(A(1) <= A(2)) - self.assert_(A(2) >= A(1)) - self.assert_(A(2) <= A(2)) - self.assert_(A(2) >= A(2)) + self.assertTrue(A(1) < A(2)) + self.assertTrue(A(2) > A(1)) + self.assertTrue(A(1) <= A(2)) + self.assertTrue(A(2) >= A(1)) + self.assertTrue(A(2) <= A(2)) + self.assertTrue(A(2) >= A(2)) def test_total_ordering_gt(self): @functools.total_ordering @@ -456,12 +456,12 @@ class TestTotalOrdering(unittest.TestCase): self.value = value def __gt__(self, other): return self.value > other.value - self.assert_(A(1) < A(2)) - self.assert_(A(2) > A(1)) - self.assert_(A(1) <= A(2)) - self.assert_(A(2) >= A(1)) - self.assert_(A(2) <= A(2)) - self.assert_(A(2) >= A(2)) + self.assertTrue(A(1) < A(2)) + self.assertTrue(A(2) > A(1)) + self.assertTrue(A(1) <= A(2)) + self.assertTrue(A(2) >= A(1)) + self.assertTrue(A(2) <= A(2)) + self.assertTrue(A(2) >= A(2)) def test_total_ordering_ge(self): @functools.total_ordering @@ -470,24 +470,24 @@ class TestTotalOrdering(unittest.TestCase): self.value = value def __ge__(self, other): return self.value >= other.value - self.assert_(A(1) < A(2)) - self.assert_(A(2) > A(1)) - self.assert_(A(1) <= A(2)) - self.assert_(A(2) >= A(1)) - self.assert_(A(2) <= A(2)) - self.assert_(A(2) >= A(2)) + self.assertTrue(A(1) < A(2)) + self.assertTrue(A(2) > A(1)) + self.assertTrue(A(1) <= A(2)) + self.assertTrue(A(2) >= A(1)) + self.assertTrue(A(2) <= A(2)) + self.assertTrue(A(2) >= A(2)) def test_total_ordering_no_overwrite(self): # new methods should not overwrite existing @functools.total_ordering class A(int): pass - self.assert_(A(1) < A(2)) - self.assert_(A(2) > A(1)) - self.assert_(A(1) <= A(2)) - self.assert_(A(2) >= A(1)) - self.assert_(A(2) <= A(2)) - self.assert_(A(2) >= A(2)) + self.assertTrue(A(1) < A(2)) + self.assertTrue(A(2) > A(1)) + self.assertTrue(A(1) <= A(2)) + self.assertTrue(A(2) >= A(1)) + self.assertTrue(A(2) <= A(2)) + self.assertTrue(A(2) >= A(2)) def test_no_operations_defined(self): with self.assertRaises(ValueError): @@ -507,9 +507,9 @@ class TestLRU(unittest.TestCase): x, y = choice(domain), choice(domain) actual = f(x, y) expected = orig(x, y) - self.assertEquals(actual, expected) - self.assert_(f.cache_hits > f.cache_misses) - self.assertEquals(f.cache_hits + f.cache_misses, 1000) + self.assertEqual(actual, expected) + self.assertTrue(f.cache_hits > f.cache_misses) + self.assertEqual(f.cache_hits + f.cache_misses, 1000) f.cache_clear() # test clearing self.assertEqual(f.cache_hits, 0) diff --git a/Lib/test/test_gdb.py b/Lib/test/test_gdb.py index 55597ce..5127a6f 100644 --- a/Lib/test/test_gdb.py +++ b/Lib/test/test_gdb.py @@ -129,7 +129,7 @@ class DebuggerTests(unittest.TestCase): '') # Ensure no unexpected error messages: - self.assertEquals(err, '') + self.assertEqual(err, '') return out @@ -159,8 +159,8 @@ class DebuggerTests(unittest.TestCase): def assertEndsWith(self, actual, exp_end): '''Ensure that the given "actual" string ends with "exp_end"''' - self.assert_(actual.endswith(exp_end), - msg='%r did not end with %r' % (actual, exp_end)) + self.assertTrue(actual.endswith(exp_end), + msg='%r did not end with %r' % (actual, exp_end)) def assertMultilineMatches(self, actual, pattern): m = re.match(pattern, actual, re.DOTALL) @@ -182,9 +182,9 @@ class PrettyPrintTests(DebuggerTests): cmds_after_breakpoint) if not exp_repr: exp_repr = repr(val) - self.assertEquals(gdb_repr, exp_repr, - ('%r did not equal expected %r; full output was:\n%s' - % (gdb_repr, exp_repr, gdb_output))) + self.assertEqual(gdb_repr, exp_repr, + ('%r did not equal expected %r; full output was:\n%s' + % (gdb_repr, exp_repr, gdb_output))) def test_int(self): 'Verify the pretty-printing of various "int"/long values' @@ -274,7 +274,7 @@ class PrettyPrintTests(DebuggerTests): gdb_repr, gdb_output = self.get_gdb_repr('''s = set(['a','b']) s.pop() id(s)''') - self.assertEquals(gdb_repr, "{'b'}") + self.assertEqual(gdb_repr, "{'b'}") def test_frozensets(self): 'Verify the pretty-printing of frozensets' @@ -290,8 +290,8 @@ try: except RuntimeError as e: id(e) ''') - self.assertEquals(gdb_repr, - "RuntimeError('I am an error',)") + self.assertEqual(gdb_repr, + "RuntimeError('I am an error',)") # Test division by zero: @@ -301,8 +301,8 @@ try: except ZeroDivisionError as e: id(e) ''') - self.assertEquals(gdb_repr, - "ZeroDivisionError('division by zero',)") + self.assertEqual(gdb_repr, + "ZeroDivisionError('division by zero',)") def test_modern_class(self): 'Verify the pretty-printing of new-style class instances' @@ -382,7 +382,7 @@ id(foo)''') 'backtrace']) ) - self.assertEquals(gdb_repr, '0x0') + self.assertEqual(gdb_repr, '0x0') def test_NULL_ob_type(self): 'Ensure that a PyObject* with NULL ob_type is handled gracefully' @@ -422,11 +422,11 @@ id(foo)''') into an infinite loop:''' gdb_repr, gdb_output = \ self.get_gdb_repr("a = [3, 4, 5] ; a.append(a) ; id(a)") - self.assertEquals(gdb_repr, '[3, 4, 5, [...]]') + self.assertEqual(gdb_repr, '[3, 4, 5, [...]]') gdb_repr, gdb_output = \ self.get_gdb_repr("a = [3, 4, 5] ; b = [a] ; a.append(b) ; id(a)") - self.assertEquals(gdb_repr, '[3, 4, 5, [[...]]]') + self.assertEqual(gdb_repr, '[3, 4, 5, [[...]]]') def test_selfreferential_dict(self): '''Ensure that a reference loop involving a dict doesn't lead proxyval @@ -434,7 +434,7 @@ id(foo)''') gdb_repr, gdb_output = \ self.get_gdb_repr("a = {} ; b = {'bar':a} ; a['foo'] = b ; id(a)") - self.assertEquals(gdb_repr, "{'foo': {'bar': {...}}}") + self.assertEqual(gdb_repr, "{'foo': {'bar': {...}}}") def test_selfreferential_old_style_instance(self): gdb_repr, gdb_output = \ @@ -479,30 +479,30 @@ id(a)''') def test_truncation(self): 'Verify that very long output is truncated' gdb_repr, gdb_output = self.get_gdb_repr('id(list(range(1000)))') - self.assertEquals(gdb_repr, - "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, " - "14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, " - "27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, " - "40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, " - "53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, " - "66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, " - "79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, " - "92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, " - "104, 105, 106, 107, 108, 109, 110, 111, 112, 113, " - "114, 115, 116, 117, 118, 119, 120, 121, 122, 123, " - "124, 125, 126, 127, 128, 129, 130, 131, 132, 133, " - "134, 135, 136, 137, 138, 139, 140, 141, 142, 143, " - "144, 145, 146, 147, 148, 149, 150, 151, 152, 153, " - "154, 155, 156, 157, 158, 159, 160, 161, 162, 163, " - "164, 165, 166, 167, 168, 169, 170, 171, 172, 173, " - "174, 175, 176, 177, 178, 179, 180, 181, 182, 183, " - "184, 185, 186, 187, 188, 189, 190, 191, 192, 193, " - "194, 195, 196, 197, 198, 199, 200, 201, 202, 203, " - "204, 205, 206, 207, 208, 209, 210, 211, 212, 213, " - "214, 215, 216, 217, 218, 219, 220, 221, 222, 223, " - "224, 225, 226...(truncated)") - self.assertEquals(len(gdb_repr), - 1024 + len('...(truncated)')) + self.assertEqual(gdb_repr, + "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, " + "14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, " + "27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, " + "40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, " + "53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, " + "66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, " + "79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, " + "92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, " + "104, 105, 106, 107, 108, 109, 110, 111, 112, 113, " + "114, 115, 116, 117, 118, 119, 120, 121, 122, 123, " + "124, 125, 126, 127, 128, 129, 130, 131, 132, 133, " + "134, 135, 136, 137, 138, 139, 140, 141, 142, 143, " + "144, 145, 146, 147, 148, 149, 150, 151, 152, 153, " + "154, 155, 156, 157, 158, 159, 160, 161, 162, 163, " + "164, 165, 166, 167, 168, 169, 170, 171, 172, 173, " + "174, 175, 176, 177, 178, 179, 180, 181, 182, 183, " + "184, 185, 186, 187, 188, 189, 190, 191, 192, 193, " + "194, 195, 196, 197, 198, 199, 200, 201, 202, 203, " + "204, 205, 206, 207, 208, 209, 210, 211, 212, 213, " + "214, 215, 216, 217, 218, 219, 220, 221, 222, 223, " + "224, 225, 226...(truncated)") + self.assertEqual(len(gdb_repr), + 1024 + len('...(truncated)')) def test_builtin_method(self): gdb_repr, gdb_output = self.get_gdb_repr('import sys; id(sys.stdout.readlines)') diff --git a/Lib/test/test_getargs2.py b/Lib/test/test_getargs2.py index d751c1a..e8f4fc2 100644 --- a/Lib/test/test_getargs2.py +++ b/Lib/test/test_getargs2.py @@ -220,7 +220,7 @@ class Tuple_TestCase(unittest.TestCase): from _testcapi import getargs_tuple ret = getargs_tuple(1, (2, 3)) - self.assertEquals(ret, (1,2,3)) + self.assertEqual(ret, (1,2,3)) # make sure invalid tuple arguments are handled correctly class seq: @@ -233,28 +233,28 @@ class Tuple_TestCase(unittest.TestCase): class Keywords_TestCase(unittest.TestCase): def test_positional_args(self): # using all positional args - self.assertEquals( + self.assertEqual( getargs_keywords((1,2), 3, (4,(5,6)), (7,8,9), 10), (1, 2, 3, 4, 5, 6, 7, 8, 9, 10) ) def test_mixed_args(self): # positional and keyword args - self.assertEquals( + self.assertEqual( getargs_keywords((1,2), 3, (4,(5,6)), arg4=(7,8,9), arg5=10), (1, 2, 3, 4, 5, 6, 7, 8, 9, 10) ) def test_keyword_args(self): # all keywords - self.assertEquals( + self.assertEqual( getargs_keywords(arg1=(1,2), arg2=3, arg3=(4,(5,6)), arg4=(7,8,9), arg5=10), (1, 2, 3, 4, 5, 6, 7, 8, 9, 10) ) def test_optional_args(self): # missing optional keyword args, skipping tuples - self.assertEquals( + self.assertEqual( getargs_keywords(arg1=(1,2), arg2=3, arg5=10), (1, 2, 3, -1, -1, -1, -1, -1, -1, 10) ) @@ -264,7 +264,7 @@ class Keywords_TestCase(unittest.TestCase): try: getargs_keywords(arg1=(1,2)) except TypeError as err: - self.assertEquals(str(err), "Required argument 'arg2' (pos 2) not found") + self.assertEqual(str(err), "Required argument 'arg2' (pos 2) not found") else: self.fail('TypeError should have been raised') @@ -272,7 +272,7 @@ class Keywords_TestCase(unittest.TestCase): try: getargs_keywords((1,2),3,(4,(5,6)),(7,8,9),10,111) except TypeError as err: - self.assertEquals(str(err), "function takes at most 5 arguments (6 given)") + self.assertEqual(str(err), "function takes at most 5 arguments (6 given)") else: self.fail('TypeError should have been raised') @@ -281,7 +281,7 @@ class Keywords_TestCase(unittest.TestCase): try: getargs_keywords((1,2),3,arg5=10,arg666=666) except TypeError as err: - self.assertEquals(str(err), "'arg666' is an invalid keyword argument for this function") + self.assertEqual(str(err), "'arg666' is an invalid keyword argument for this function") else: self.fail('TypeError should have been raised') @@ -289,7 +289,7 @@ class Keywords_TestCase(unittest.TestCase): try: getargs_keywords((1,2), 3, (4,(5,6)), (7,8,9), **{'\uDC80': 10}) except TypeError as err: - self.assertEquals(str(err), "'\udc80' is an invalid keyword argument for this function") + self.assertEqual(str(err), "'\udc80' is an invalid keyword argument for this function") else: self.fail('TypeError should have been raised') diff --git a/Lib/test/test_getopt.py b/Lib/test/test_getopt.py index a265b6b..fa5701f 100644 --- a/Lib/test/test_getopt.py +++ b/Lib/test/test_getopt.py @@ -175,9 +175,9 @@ class GetoptTests(unittest.TestCase): def test_issue4629(self): longopts, shortopts = getopt.getopt(['--help='], '', ['help=']) - self.assertEquals(longopts, [('--help', '')]) + self.assertEqual(longopts, [('--help', '')]) longopts, shortopts = getopt.getopt(['--help=x'], '', ['help=']) - self.assertEquals(longopts, [('--help', 'x')]) + self.assertEqual(longopts, [('--help', 'x')]) self.assertRaises(getopt.GetoptError, getopt.getopt, ['--help='], '', ['help']) def test_main(): diff --git a/Lib/test/test_glob.py b/Lib/test/test_glob.py index 05e29b5..1560a6b 100644 --- a/Lib/test/test_glob.py +++ b/Lib/test/test_glob.py @@ -59,8 +59,8 @@ class GlobTests(unittest.TestCase): if set(type(x) for x in tmp) == uniset: u1 = glob.glob('*') u2 = glob.glob('./*') - self.assertEquals(set(type(r) for r in u1), uniset) - self.assertEquals(set(type(r) for r in u2), uniset) + self.assertEqual(set(type(r) for r in u1), uniset) + self.assertEqual(set(type(r) for r in u2), uniset) def test_glob_one_directory(self): eq = self.assertSequencesEqual_noorder diff --git a/Lib/test/test_gzip.py b/Lib/test/test_gzip.py index 8af6d2b..2b0ac36 100644 --- a/Lib/test/test_gzip.py +++ b/Lib/test/test_gzip.py @@ -113,7 +113,7 @@ class TestGzip(unittest.TestCase): ztxt = zgfile.read(8192) contents += ztxt if not ztxt: break - self.assertEquals(contents, b'a'*201) + self.assertEqual(contents, b'a'*201) def test_buffered_reader(self): # Issue #7471: a GzipFile can be wrapped in a BufferedReader for @@ -177,7 +177,7 @@ class TestGzip(unittest.TestCase): f.read(10) f.seek(10, whence=1) y = f.read(10) - self.assertEquals(y, data1[20:30]) + self.assertEqual(y, data1[20:30]) def test_seek_write(self): # Try seek, write test diff --git a/Lib/test/test_hashlib.py b/Lib/test/test_hashlib.py index 1db2e1f..1f5a8be 100644 --- a/Lib/test/test_hashlib.py +++ b/Lib/test/test_hashlib.py @@ -310,10 +310,10 @@ class HashLibTestCase(unittest.TestCase): m.update(b'1') m.update(b'#' * gil_minsize) m.update(b'1') - self.assertEquals(m.hexdigest(), 'cb1e1a2cbc80be75e19935d621fb9b21') + self.assertEqual(m.hexdigest(), 'cb1e1a2cbc80be75e19935d621fb9b21') m = hashlib.md5(b'x' * gil_minsize) - self.assertEquals(m.hexdigest(), 'cfb767f225d58469c5de3632a8803958') + self.assertEqual(m.hexdigest(), 'cfb767f225d58469c5de3632a8803958') @unittest.skipUnless(threading, 'Threading required for this test.') @support.reap_threads diff --git a/Lib/test/test_http_cookiejar.py b/Lib/test/test_http_cookiejar.py index fca6710..712a4ae 100644 --- a/Lib/test/test_http_cookiejar.py +++ b/Lib/test/test_http_cookiejar.py @@ -20,28 +20,28 @@ class DateTimeTests(unittest.TestCase): def test_time2isoz(self): base = 1019227000 day = 24*3600 - self.assertEquals(time2isoz(base), "2002-04-19 14:36:40Z") - self.assertEquals(time2isoz(base+day), "2002-04-20 14:36:40Z") - self.assertEquals(time2isoz(base+2*day), "2002-04-21 14:36:40Z") - self.assertEquals(time2isoz(base+3*day), "2002-04-22 14:36:40Z") + self.assertEqual(time2isoz(base), "2002-04-19 14:36:40Z") + self.assertEqual(time2isoz(base+day), "2002-04-20 14:36:40Z") + self.assertEqual(time2isoz(base+2*day), "2002-04-21 14:36:40Z") + self.assertEqual(time2isoz(base+3*day), "2002-04-22 14:36:40Z") az = time2isoz() bz = time2isoz(500000) for text in (az, bz): self.assertTrue(re.search(r"^\d{4}-\d\d-\d\d \d\d:\d\d:\d\dZ$", text), - "bad time2isoz format: %s %s" % (az, bz)) + "bad time2isoz format: %s %s" % (az, bz)) def test_http2time(self): def parse_date(text): return time.gmtime(http2time(text))[:6] - self.assertEquals(parse_date("01 Jan 2001"), (2001, 1, 1, 0, 0, 0.0)) + self.assertEqual(parse_date("01 Jan 2001"), (2001, 1, 1, 0, 0, 0.0)) # this test will break around year 2070 - self.assertEquals(parse_date("03-Feb-20"), (2020, 2, 3, 0, 0, 0.0)) + self.assertEqual(parse_date("03-Feb-20"), (2020, 2, 3, 0, 0, 0.0)) # this test will break around year 2048 - self.assertEquals(parse_date("03-Feb-98"), (1998, 2, 3, 0, 0, 0.0)) + self.assertEqual(parse_date("03-Feb-98"), (1998, 2, 3, 0, 0, 0.0)) def test_http2time_formats(self): # test http2time for supported dates. Test cases with 2 digit year @@ -69,8 +69,8 @@ class DateTimeTests(unittest.TestCase): test_t = 760233600 # assume broken POSIX counting of seconds result = time2isoz(test_t) expected = "1994-02-03 00:00:00Z" - self.assertEquals(result, expected, - "%s => '%s' (%s)" % (test_t, result, expected)) + self.assertEqual(result, expected, + "%s => '%s' (%s)" % (test_t, result, expected)) for s in tests: t = http2time(s) @@ -108,7 +108,7 @@ class HeaderTests(unittest.TestCase): 'foo=bar; expires=01 Jan 2040 22:23:32 GMT', 'foo=bar; expires="01 Jan 2040 22:23:32 GMT"', ]: - self.assertEquals(parse_ns_headers([hdr]), expected) + self.assertEqual(parse_ns_headers([hdr]), expected) def test_parse_ns_headers_version(self): @@ -118,7 +118,7 @@ class HeaderTests(unittest.TestCase): 'foo=bar; version="1"', 'foo=bar; Version="1"', ]: - self.assertEquals(parse_ns_headers([hdr]), expected) + self.assertEqual(parse_ns_headers([hdr]), expected) def test_parse_ns_headers_special_names(self): # names such as 'expires' are not special in first name=value pair @@ -126,13 +126,13 @@ class HeaderTests(unittest.TestCase): # Cookie with name 'expires' hdr = 'expires=01 Jan 2040 22:23:32 GMT' expected = [[("expires", "01 Jan 2040 22:23:32 GMT"), ("version", "0")]] - self.assertEquals(parse_ns_headers([hdr]), expected) + self.assertEqual(parse_ns_headers([hdr]), expected) def test_join_header_words(self): joined = join_header_words([[("foo", None), ("bar", "baz")]]) - self.assertEquals(joined, "foo; bar=baz") + self.assertEqual(joined, "foo; bar=baz") - self.assertEquals(join_header_words([[]]), "") + self.assertEqual(join_header_words([[]]), "") def test_split_header_words(self): tests = [ @@ -162,7 +162,7 @@ class HeaderTests(unittest.TestCase): f = io.StringIO() traceback.print_exc(None, f) result = "(error -- traceback follows)\n\n%s" % f.getvalue() - self.assertEquals(result, expect, """ + self.assertEqual(result, expect, """ When parsing: '%s' Expected: '%s' Got: '%s' @@ -194,7 +194,7 @@ Got: '%s' for arg, expect in tests: input = split_header_words([arg]) res = join_header_words(input) - self.assertEquals(res, expect, """ + self.assertEqual(res, expect, """ When parsing: '%s' Expected: '%s' Got: '%s' @@ -358,11 +358,11 @@ class CookieTests(unittest.TestCase): interact_netscape(c, "http://www.acme.com/", '"spam"; path=/foo/') cookie = c._cookies["www.acme.com"]["/"]["eggs"] self.assertTrue(cookie.value is None) - self.assertEquals(cookie.name, "eggs") + self.assertEqual(cookie.name, "eggs") cookie = c._cookies["www.acme.com"]['/foo/']['"spam"'] self.assertTrue(cookie.value is None) - self.assertEquals(cookie.name, '"spam"') - self.assertEquals(lwp_cookie_str(cookie), ( + self.assertEqual(cookie.name, '"spam"') + self.assertEqual(lwp_cookie_str(cookie), ( r'"spam"; path="/foo/"; domain="www.acme.com"; ' 'path_spec; discard; version=0')) old_str = repr(c) @@ -373,13 +373,13 @@ class CookieTests(unittest.TestCase): finally: os.unlink(c.filename) # cookies unchanged apart from lost info re. whether path was specified - self.assertEquals( + self.assertEqual( repr(c), re.sub("path_specified=%s" % True, "path_specified=%s" % False, old_str) ) - self.assertEquals(interact_netscape(c, "http://www.acme.com/foo/"), - '"spam"; eggs') + self.assertEqual(interact_netscape(c, "http://www.acme.com/foo/"), + '"spam"; eggs') def test_rfc2109_handling(self): # RFC 2109 cookies are handled as RFC 2965 or Netscape cookies, @@ -423,18 +423,18 @@ class CookieTests(unittest.TestCase): 'expires="Foo Bar 25 33:22:11 3022"') cookie = c._cookies[".acme.com"]["/"]["spam"] - self.assertEquals(cookie.domain, ".acme.com") + self.assertEqual(cookie.domain, ".acme.com") self.assertTrue(cookie.domain_specified) - self.assertEquals(cookie.port, DEFAULT_HTTP_PORT) + self.assertEqual(cookie.port, DEFAULT_HTTP_PORT) self.assertTrue(not cookie.port_specified) # case is preserved self.assertTrue(cookie.has_nonstandard_attr("blArgh") and not cookie.has_nonstandard_attr("blargh")) cookie = c._cookies["www.acme.com"]["/"]["ni"] - self.assertEquals(cookie.domain, "www.acme.com") + self.assertEqual(cookie.domain, "www.acme.com") self.assertTrue(not cookie.domain_specified) - self.assertEquals(cookie.port, "80,8080") + self.assertEqual(cookie.port, "80,8080") self.assertTrue(cookie.port_specified) cookie = c._cookies["www.acme.com"]["/"]["nini"] @@ -464,13 +464,13 @@ class CookieTests(unittest.TestCase): future = time2netscape(time.time()+3600) interact_netscape(c, "http://www.acme.com/", 'spam="bar"; expires=%s' % future) - self.assertEquals(len(c), 1) + self.assertEqual(len(c), 1) now = time2netscape(time.time()-1) # ... and if in past or present, discard it interact_netscape(c, "http://www.acme.com/", 'foo="eggs"; expires=%s' % now) h = interact_netscape(c, "http://www.acme.com/") - self.assertEquals(len(c), 1) + self.assertEqual(len(c), 1) self.assertIn('spam="bar"', h) self.assertNotIn("foo", h) @@ -480,19 +480,19 @@ class CookieTests(unittest.TestCase): future) interact_netscape(c, "http://www.acme.com/", 'bar="bar"; expires=%s' % future) - self.assertEquals(len(c), 3) + self.assertEqual(len(c), 3) interact_netscape(c, "http://www.acme.com/", 'eggs="bar"; ' 'expires=%s; max-age=0' % future) interact_netscape(c, "http://www.acme.com/", 'bar="bar"; ' 'max-age=0; expires=%s' % future) h = interact_netscape(c, "http://www.acme.com/") - self.assertEquals(len(c), 1) + self.assertEqual(len(c), 1) # test expiry at end of session for cookies with no expires attribute interact_netscape(c, "http://www.rhubarb.net/", 'whum="fizz"') - self.assertEquals(len(c), 2) + self.assertEqual(len(c), 2) c.clear_session_cookies() - self.assertEquals(len(c), 1) + self.assertEqual(len(c), 1) self.assertIn('spam="bar"', h) # XXX RFC 2965 expiry rules (some apply to V0 too) @@ -545,7 +545,7 @@ class CookieTests(unittest.TestCase): # Default path does not include query, so is "/", not "/?spam". self.assertIn("/", cj._cookies["example.com"]) # Cookie is sent back to the same URI. - self.assertEquals(interact_netscape(cj, uri), value) + self.assertEqual(interact_netscape(cj, uri), value) def test_escape_path(self): cases = [ @@ -570,31 +570,31 @@ class CookieTests(unittest.TestCase): ("/foo/bar\uabcd", "/foo/bar%EA%AF%8D"), # UTF-8 encoded ] for arg, result in cases: - self.assertEquals(escape_path(arg), result) + self.assertEqual(escape_path(arg), result) def test_request_path(self): # with parameters req = urllib.request.Request( "http://www.example.com/rheum/rhaponticum;" "foo=bar;sing=song?apples=pears&spam=eggs#ni") - self.assertEquals(request_path(req), - "/rheum/rhaponticum;foo=bar;sing=song") + self.assertEqual(request_path(req), + "/rheum/rhaponticum;foo=bar;sing=song") # without parameters req = urllib.request.Request( "http://www.example.com/rheum/rhaponticum?" "apples=pears&spam=eggs#ni") - self.assertEquals(request_path(req), "/rheum/rhaponticum") + self.assertEqual(request_path(req), "/rheum/rhaponticum") # missing final slash req = urllib.request.Request("http://www.example.com") - self.assertEquals(request_path(req), "/") + self.assertEqual(request_path(req), "/") def test_request_port(self): req = urllib.request.Request("http://www.acme.com:1234/", headers={"Host": "www.acme.com:4321"}) - self.assertEquals(request_port(req), "1234") + self.assertEqual(request_port(req), "1234") req = urllib.request.Request("http://www.acme.com/", headers={"Host": "www.acme.com:4321"}) - self.assertEquals(request_port(req), DEFAULT_HTTP_PORT) + self.assertEqual(request_port(req), DEFAULT_HTTP_PORT) def test_request_host(self): # this request is illegal (RFC2616, 14.2.3) @@ -602,15 +602,15 @@ class CookieTests(unittest.TestCase): headers={"Host": "www.acme.com:80"}) # libwww-perl wants this response, but that seems wrong (RFC 2616, # section 5.2, point 1., and RFC 2965 section 1, paragraph 3) - #self.assertEquals(request_host(req), "www.acme.com") - self.assertEquals(request_host(req), "1.1.1.1") + #self.assertEqual(request_host(req), "www.acme.com") + self.assertEqual(request_host(req), "1.1.1.1") req = urllib.request.Request("http://www.acme.com/", headers={"Host": "irrelevant.com"}) - self.assertEquals(request_host(req), "www.acme.com") + self.assertEqual(request_host(req), "www.acme.com") # port shouldn't be in request-host req = urllib.request.Request("http://www.acme.com:2345/resource.html", headers={"Host": "www.acme.com:5432"}) - self.assertEquals(request_host(req), "www.acme.com") + self.assertEqual(request_host(req), "www.acme.com") def test_is_HDN(self): self.assertTrue(is_HDN("foo.bar.com")) @@ -623,14 +623,14 @@ class CookieTests(unittest.TestCase): self.assertTrue(not is_HDN("foo.")) def test_reach(self): - self.assertEquals(reach("www.acme.com"), ".acme.com") - self.assertEquals(reach("acme.com"), "acme.com") - self.assertEquals(reach("acme.local"), ".local") - self.assertEquals(reach(".local"), ".local") - self.assertEquals(reach(".com"), ".com") - self.assertEquals(reach("."), ".") - self.assertEquals(reach(""), "") - self.assertEquals(reach("192.168.0.1"), "192.168.0.1") + self.assertEqual(reach("www.acme.com"), ".acme.com") + self.assertEqual(reach("acme.com"), "acme.com") + self.assertEqual(reach("acme.local"), ".local") + self.assertEqual(reach(".local"), ".local") + self.assertEqual(reach(".com"), ".com") + self.assertEqual(reach("."), ".") + self.assertEqual(reach(""), "") + self.assertEqual(reach("192.168.0.1"), "192.168.0.1") def test_domain_match(self): self.assertTrue(domain_match("192.168.1.1", "192.168.1.1")) @@ -676,7 +676,7 @@ class CookieTests(unittest.TestCase): c = CookieJar() interact_2965(c, "http://www.nasty.com/", 'foo=bar; domain=friendly.org; Version="1"') - self.assertEquals(len(c), 0) + self.assertEqual(len(c), 0) def test_strict_domain(self): # Cookies whose domain is a country-code tld like .co.uk should @@ -686,11 +686,11 @@ class CookieTests(unittest.TestCase): interact_netscape(cj, "http://example.co.uk/", 'no=problemo') interact_netscape(cj, "http://example.co.uk/", 'okey=dokey; Domain=.example.co.uk') - self.assertEquals(len(cj), 2) + self.assertEqual(len(cj), 2) for pseudo_tld in [".co.uk", ".org.za", ".tx.us", ".name.us"]: interact_netscape(cj, "http://example.%s/" % pseudo_tld, 'spam=eggs; Domain=.co.uk') - self.assertEquals(len(cj), 2) + self.assertEqual(len(cj), 2) def test_two_component_domain_ns(self): # Netscape: .www.bar.com, www.bar.com, .bar.com, bar.com, no domain @@ -700,17 +700,17 @@ class CookieTests(unittest.TestCase): # two-component V0 domain is OK interact_netscape(c, "http://foo.net/", 'ns=bar') - self.assertEquals(len(c), 1) - self.assertEquals(c._cookies["foo.net"]["/"]["ns"].value, "bar") - self.assertEquals(interact_netscape(c, "http://foo.net/"), "ns=bar") + self.assertEqual(len(c), 1) + self.assertEqual(c._cookies["foo.net"]["/"]["ns"].value, "bar") + self.assertEqual(interact_netscape(c, "http://foo.net/"), "ns=bar") # *will* be returned to any other domain (unlike RFC 2965)... - self.assertEquals(interact_netscape(c, "http://www.foo.net/"), - "ns=bar") + self.assertEqual(interact_netscape(c, "http://www.foo.net/"), + "ns=bar") # ...unless requested otherwise pol = DefaultCookiePolicy( strict_ns_domain=DefaultCookiePolicy.DomainStrictNonDomain) c.set_policy(pol) - self.assertEquals(interact_netscape(c, "http://www.foo.net/"), "") + self.assertEqual(interact_netscape(c, "http://www.foo.net/"), "") # unlike RFC 2965, even explicit two-component domain is OK, # because .foo.net matches foo.net @@ -719,17 +719,17 @@ class CookieTests(unittest.TestCase): # even if starts with a dot -- in NS rules, .foo.net matches foo.net! interact_netscape(c, "http://foo.net/foo/bar/", 'spam2=eggs; domain=.foo.net') - self.assertEquals(len(c), 3) - self.assertEquals(c._cookies[".foo.net"]["/foo"]["spam1"].value, - "eggs") - self.assertEquals(c._cookies[".foo.net"]["/foo/bar"]["spam2"].value, - "eggs") - self.assertEquals(interact_netscape(c, "http://foo.net/foo/bar/"), - "spam2=eggs; spam1=eggs; ns=bar") + self.assertEqual(len(c), 3) + self.assertEqual(c._cookies[".foo.net"]["/foo"]["spam1"].value, + "eggs") + self.assertEqual(c._cookies[".foo.net"]["/foo/bar"]["spam2"].value, + "eggs") + self.assertEqual(interact_netscape(c, "http://foo.net/foo/bar/"), + "spam2=eggs; spam1=eggs; ns=bar") # top-level domain is too general interact_netscape(c, "http://foo.net/", 'nini="ni"; domain=.net') - self.assertEquals(len(c), 3) + self.assertEqual(len(c), 3) ## # Netscape protocol doesn't allow non-special top level domains (such ## # as co.uk) in the domain attribute unless there are at least three @@ -737,8 +737,8 @@ class CookieTests(unittest.TestCase): # Oh yes it does! Real implementations don't check this, and real # cookies (of course) rely on that behaviour. interact_netscape(c, "http://foo.co.uk", 'nasty=trick; domain=.co.uk') -## self.assertEquals(len(c), 2) - self.assertEquals(len(c), 4) +## self.assertEqual(len(c), 2) + self.assertEqual(len(c), 4) def test_two_component_domain_rfc2965(self): pol = DefaultCookiePolicy(rfc2965=True) @@ -746,43 +746,43 @@ class CookieTests(unittest.TestCase): # two-component V1 domain is OK interact_2965(c, "http://foo.net/", 'foo=bar; Version="1"') - self.assertEquals(len(c), 1) - self.assertEquals(c._cookies["foo.net"]["/"]["foo"].value, "bar") - self.assertEquals(interact_2965(c, "http://foo.net/"), - "$Version=1; foo=bar") + self.assertEqual(len(c), 1) + self.assertEqual(c._cookies["foo.net"]["/"]["foo"].value, "bar") + self.assertEqual(interact_2965(c, "http://foo.net/"), + "$Version=1; foo=bar") # won't be returned to any other domain (because domain was implied) - self.assertEquals(interact_2965(c, "http://www.foo.net/"), "") + self.assertEqual(interact_2965(c, "http://www.foo.net/"), "") # unless domain is given explicitly, because then it must be # rewritten to start with a dot: foo.net --> .foo.net, which does # not domain-match foo.net interact_2965(c, "http://foo.net/foo", 'spam=eggs; domain=foo.net; path=/foo; Version="1"') - self.assertEquals(len(c), 1) - self.assertEquals(interact_2965(c, "http://foo.net/foo"), - "$Version=1; foo=bar") + self.assertEqual(len(c), 1) + self.assertEqual(interact_2965(c, "http://foo.net/foo"), + "$Version=1; foo=bar") # explicit foo.net from three-component domain www.foo.net *does* get # set, because .foo.net domain-matches .foo.net interact_2965(c, "http://www.foo.net/foo/", 'spam=eggs; domain=foo.net; Version="1"') - self.assertEquals(c._cookies[".foo.net"]["/foo/"]["spam"].value, - "eggs") - self.assertEquals(len(c), 2) - self.assertEquals(interact_2965(c, "http://foo.net/foo/"), - "$Version=1; foo=bar") - self.assertEquals(interact_2965(c, "http://www.foo.net/foo/"), - '$Version=1; spam=eggs; $Domain="foo.net"') + self.assertEqual(c._cookies[".foo.net"]["/foo/"]["spam"].value, + "eggs") + self.assertEqual(len(c), 2) + self.assertEqual(interact_2965(c, "http://foo.net/foo/"), + "$Version=1; foo=bar") + self.assertEqual(interact_2965(c, "http://www.foo.net/foo/"), + '$Version=1; spam=eggs; $Domain="foo.net"') # top-level domain is too general interact_2965(c, "http://foo.net/", 'ni="ni"; domain=".net"; Version="1"') - self.assertEquals(len(c), 2) + self.assertEqual(len(c), 2) # RFC 2965 doesn't require blocking this interact_2965(c, "http://foo.co.uk/", 'nasty=trick; domain=.co.uk; Version="1"') - self.assertEquals(len(c), 3) + self.assertEqual(len(c), 3) def test_domain_allow(self): c = CookieJar(policy=DefaultCookiePolicy( @@ -793,24 +793,24 @@ class CookieTests(unittest.TestCase): headers = ["Set-Cookie: CUSTOMER=WILE_E_COYOTE; path=/"] res = FakeResponse(headers, "http://acme.com/") c.extract_cookies(res, req) - self.assertEquals(len(c), 0) + self.assertEqual(len(c), 0) req = urllib.request.Request("http://www.acme.com/") res = FakeResponse(headers, "http://www.acme.com/") c.extract_cookies(res, req) - self.assertEquals(len(c), 1) + self.assertEqual(len(c), 1) req = urllib.request.Request("http://www.coyote.com/") res = FakeResponse(headers, "http://www.coyote.com/") c.extract_cookies(res, req) - self.assertEquals(len(c), 1) + self.assertEqual(len(c), 1) # set a cookie with non-allowed domain... req = urllib.request.Request("http://www.coyote.com/") res = FakeResponse(headers, "http://www.coyote.com/") cookies = c.make_cookies(res, req) c.set_cookie(cookies[0]) - self.assertEquals(len(c), 2) + self.assertEqual(len(c), 2) # ... and check is doesn't get returned c.add_cookie_header(req) self.assertTrue(not req.has_header("Cookie")) @@ -824,17 +824,17 @@ class CookieTests(unittest.TestCase): req = urllib.request.Request("http://www.acme.com/") res = FakeResponse(headers, "http://www.acme.com/") c.extract_cookies(res, req) - self.assertEquals(len(c), 0) + self.assertEqual(len(c), 0) p = pol.set_blocked_domains(["acme.com"]) c.extract_cookies(res, req) - self.assertEquals(len(c), 1) + self.assertEqual(len(c), 1) c.clear() req = urllib.request.Request("http://www.roadrunner.net/") res = FakeResponse(headers, "http://www.roadrunner.net/") c.extract_cookies(res, req) - self.assertEquals(len(c), 1) + self.assertEqual(len(c), 1) req = urllib.request.Request("http://www.roadrunner.net/") c.add_cookie_header(req) self.assertTrue((req.has_header("Cookie") and @@ -843,14 +843,14 @@ class CookieTests(unittest.TestCase): c.clear() pol.set_blocked_domains([".acme.com"]) c.extract_cookies(res, req) - self.assertEquals(len(c), 1) + self.assertEqual(len(c), 1) # set a cookie with blocked domain... req = urllib.request.Request("http://www.acme.com/") res = FakeResponse(headers, "http://www.acme.com/") cookies = c.make_cookies(res, req) c.set_cookie(cookies[0]) - self.assertEquals(len(c), 2) + self.assertEqual(len(c), 2) # ... and check is doesn't get returned c.add_cookie_header(req) self.assertTrue(not req.has_header("Cookie")) @@ -882,7 +882,7 @@ class CookieTests(unittest.TestCase): c = CookieJar(policy=DefaultCookiePolicy(rfc2965=True)) interact_2965(c, "http://www.acme.com/", r'foo=\b"a"r; Version=1') h = interact_2965(c, "http://www.acme.com/") - self.assertEquals(h, r'$Version=1; foo=\\b\"a\"r') + self.assertEqual(h, r'$Version=1; foo=\\b\"a\"r') def test_missing_final_slash(self): # Missing slash from request URL's abs_path should be assumed present. @@ -890,7 +890,7 @@ class CookieTests(unittest.TestCase): c = CookieJar(DefaultCookiePolicy(rfc2965=True)) interact_2965(c, url, "foo=bar; Version=1") req = urllib.request.Request(url) - self.assertEquals(len(c), 1) + self.assertEqual(len(c), 1) c.add_cookie_header(req) self.assertTrue(req.has_header("Cookie")) @@ -1000,31 +1000,31 @@ class CookieTests(unittest.TestCase): i = 0 for c in cs: self.assertTrue(isinstance(c, Cookie)) - self.assertEquals(c.version, versions[i]) - self.assertEquals(c.name, names[i]) - self.assertEquals(c.domain, domains[i]) - self.assertEquals(c.path, paths[i]) + self.assertEqual(c.version, versions[i]) + self.assertEqual(c.name, names[i]) + self.assertEqual(c.domain, domains[i]) + self.assertEqual(c.path, paths[i]) i = i + 1 def test_parse_ns_headers(self): # missing domain value (invalid cookie) - self.assertEquals( + self.assertEqual( parse_ns_headers(["foo=bar; path=/; domain"]), [[("foo", "bar"), ("path", "/"), ("domain", None), ("version", "0")]] ) # invalid expires value - self.assertEquals( + self.assertEqual( parse_ns_headers(["foo=bar; expires=Foo Bar 12 33:22:11 2000"]), [[("foo", "bar"), ("expires", None), ("version", "0")]] ) # missing cookie value (valid cookie) - self.assertEquals( + self.assertEqual( parse_ns_headers(["foo"]), [[("foo", None), ("version", "0")]] ) # shouldn't add version if header is empty - self.assertEquals(parse_ns_headers([""]), []) + self.assertEqual(parse_ns_headers([""]), []) def test_bad_cookie_header(self): @@ -1048,7 +1048,7 @@ class CookieTests(unittest.TestCase): ]: c = cookiejar_from_cookie_headers(headers) # these bad cookies shouldn't be set - self.assertEquals(len(c), 0) + self.assertEqual(len(c), 0) # cookie with invalid expires is treated as session cookie headers = ["Set-Cookie: c=foo; expires=Foo Bar 12 33:22:11 2000"] @@ -1187,8 +1187,8 @@ class LWPCookieTests(unittest.TestCase): req = urllib.request.Request("http://www.acme.com/") c.add_cookie_header(req) - self.assertEquals(req.get_header("Cookie"), - "PART_NUMBER=ROCKET_LAUNCHER_0001") + self.assertEqual(req.get_header("Cookie"), + "PART_NUMBER=ROCKET_LAUNCHER_0001") headers.append( "Set-Cookie: PART_NUMBER=RIDING_ROCKET_0023; path=/ammo") @@ -1386,40 +1386,40 @@ class LWPCookieTests(unittest.TestCase): # legal domain cookie = interact_2965(c, "http://www.acme.com", 'ping=pong; domain="acme.com"; version=1') - self.assertEquals(len(c), 1) + self.assertEqual(len(c), 1) # illegal domain (host prefix "www.a" contains a dot) cookie = interact_2965(c, "http://www.a.acme.com", 'whiz=bang; domain="acme.com"; version=1') - self.assertEquals(len(c), 1) + self.assertEqual(len(c), 1) # legal domain cookie = interact_2965(c, "http://www.a.acme.com", 'wow=flutter; domain=".a.acme.com"; version=1') - self.assertEquals(len(c), 2) + self.assertEqual(len(c), 2) # can't partially match an IP-address cookie = interact_2965(c, "http://125.125.125.125", 'zzzz=ping; domain="125.125.125"; version=1') - self.assertEquals(len(c), 2) + self.assertEqual(len(c), 2) # illegal path (must be prefix of request path) cookie = interact_2965(c, "http://www.sol.no", 'blah=rhubarb; domain=".sol.no"; path="/foo"; ' 'version=1') - self.assertEquals(len(c), 2) + self.assertEqual(len(c), 2) # legal path cookie = interact_2965(c, "http://www.sol.no/foo/bar", 'bing=bong; domain=".sol.no"; path="/foo"; ' 'version=1') - self.assertEquals(len(c), 3) + self.assertEqual(len(c), 3) # illegal port (request-port not in list) cookie = interact_2965(c, "http://www.sol.no", 'whiz=ffft; domain=".sol.no"; port="90,100"; ' 'version=1') - self.assertEquals(len(c), 3) + self.assertEqual(len(c), 3) # legal port cookie = interact_2965( @@ -1427,13 +1427,13 @@ class LWPCookieTests(unittest.TestCase): r'bang=wallop; version=1; domain=".sol.no"; ' r'port="90,100, 80,8080"; ' r'max-age=100; Comment = "Just kidding! (\"|\\\\) "') - self.assertEquals(len(c), 4) + self.assertEqual(len(c), 4) # port attribute without any value (current port) cookie = interact_2965(c, "http://www.sol.no", 'foo9=bar; version=1; domain=".sol.no"; port; ' 'max-age=100;') - self.assertEquals(len(c), 5) + self.assertEqual(len(c), 5) # encoded path # LWP has this test, but unescaping allowed path characters seems @@ -1444,7 +1444,7 @@ class LWPCookieTests(unittest.TestCase): # character: cookie = interact_2965(c, "http://www.sol.no/<oo/", r'foo8=bar; version=1; path="/%3coo"') - self.assertEquals(len(c), 6) + self.assertEqual(len(c), 6) # save and restore filename = test.support.TESTFN @@ -1459,7 +1459,7 @@ class LWPCookieTests(unittest.TestCase): try: os.unlink(filename) except OSError: pass - self.assertEquals(old, repr(c)) + self.assertEqual(old, repr(c)) def test_url_encoding(self): # Try some URL encodings of the PATHs. @@ -1517,11 +1517,11 @@ class LWPCookieTests(unittest.TestCase): return new_c new_c = save_and_restore(c, True) - self.assertEquals(len(new_c), 6) # none discarded + self.assertEqual(len(new_c), 6) # none discarded self.assertIn("name='foo1', value='bar'", repr(new_c)) new_c = save_and_restore(c, False) - self.assertEquals(len(new_c), 4) # 2 of them discarded on save + self.assertEqual(len(new_c), 4) # 2 of them discarded on save self.assertIn("name='foo1', value='bar'", repr(new_c)) def test_netscape_misc(self): @@ -1559,19 +1559,19 @@ class LWPCookieTests(unittest.TestCase): interact_2965(c, "http://example/", 'foo3=bar; Version=1') cookie = interact_2965(c, "http://example/") self.assertIn("foo2=bar", cookie) - self.assertEquals(len(c), 3) + self.assertEqual(len(c), 3) def test_intranet_domains_ns(self): c = CookieJar(DefaultCookiePolicy(rfc2965 = False)) interact_netscape(c, "http://example/", "foo1=bar") cookie = interact_netscape(c, "http://example/", 'foo2=bar; domain=.local') - self.assertEquals(len(c), 2) + self.assertEqual(len(c), 2) self.assertIn("foo1=bar", cookie) cookie = interact_netscape(c, "http://example/") self.assertIn("foo2=bar", cookie) - self.assertEquals(len(c), 2) + self.assertEqual(len(c), 2) def test_empty_path(self): # Test for empty path @@ -1592,17 +1592,17 @@ class LWPCookieTests(unittest.TestCase): req = urllib.request.Request("http://www.ants.com/") c.add_cookie_header(req) - self.assertEquals(req.get_header("Cookie"), - "JSESSIONID=ABCDERANDOM123") - self.assertEquals(req.get_header("Cookie2"), '$Version="1"') + self.assertEqual(req.get_header("Cookie"), + "JSESSIONID=ABCDERANDOM123") + self.assertEqual(req.get_header("Cookie2"), '$Version="1"') # missing path in the request URI req = urllib.request.Request("http://www.ants.com:8080") c.add_cookie_header(req) - self.assertEquals(req.get_header("Cookie"), - "JSESSIONID=ABCDERANDOM123") - self.assertEquals(req.get_header("Cookie2"), '$Version="1"') + self.assertEqual(req.get_header("Cookie"), + "JSESSIONID=ABCDERANDOM123") + self.assertEqual(req.get_header("Cookie2"), '$Version="1"') def test_session_cookies(self): year_plus_one = time.localtime()[0] + 1 diff --git a/Lib/test/test_httplib.py b/Lib/test/test_httplib.py index c5c0f7a..426995b 100644 --- a/Lib/test/test_httplib.py +++ b/Lib/test/test_httplib.py @@ -144,7 +144,7 @@ class BasicTest(TestCase): def test_bad_status_repr(self): exc = client.BadStatusLine('') - self.assertEquals(repr(exc), '''BadStatusLine("\'\'",)''') + self.assertEqual(repr(exc), '''BadStatusLine("\'\'",)''') def test_partial_reads(self): # if we have a lenght, the system knows when to close itself @@ -222,13 +222,13 @@ class BasicTest(TestCase): sock = FakeSocket(None) conn.sock = sock conn.send(expected) - self.assertEquals(expected, sock.data) + self.assertEqual(expected, sock.data) sock.data = b'' conn.send(array.array('b', expected)) - self.assertEquals(expected, sock.data) + self.assertEqual(expected, sock.data) sock.data = b'' conn.send(io.BytesIO(expected)) - self.assertEquals(expected, sock.data) + self.assertEqual(expected, sock.data) def test_chunked(self): chunked_start = ( @@ -242,7 +242,7 @@ class BasicTest(TestCase): sock = FakeSocket(chunked_start + '0\r\n') resp = client.HTTPResponse(sock, method="GET") resp.begin() - self.assertEquals(resp.read(), b'hello world') + self.assertEqual(resp.read(), b'hello world') resp.close() for x in ('', 'foo\r\n'): @@ -252,7 +252,7 @@ class BasicTest(TestCase): try: resp.read() except client.IncompleteRead as i: - self.assertEquals(i.partial, b'hello world') + self.assertEqual(i.partial, b'hello world') self.assertEqual(repr(i),'IncompleteRead(11 bytes read)') self.assertEqual(str(i),'IncompleteRead(11 bytes read)') else: @@ -272,9 +272,9 @@ class BasicTest(TestCase): sock = FakeSocket(chunked_start + '0\r\n') resp = client.HTTPResponse(sock, method="HEAD") resp.begin() - self.assertEquals(resp.read(), b'') - self.assertEquals(resp.status, 200) - self.assertEquals(resp.reason, 'OK') + self.assertEqual(resp.read(), b'') + self.assertEqual(resp.status, 200) + self.assertEqual(resp.reason, 'OK') self.assertTrue(resp.isclosed()) def test_negative_content_length(self): @@ -282,7 +282,7 @@ class BasicTest(TestCase): 'HTTP/1.1 200 OK\r\nContent-Length: -1\r\n\r\nHello\r\n') resp = client.HTTPResponse(sock, method="GET") resp.begin() - self.assertEquals(resp.read(), b'Hello\r\n') + self.assertEqual(resp.read(), b'Hello\r\n') resp.close() def test_incomplete_read(self): @@ -292,7 +292,7 @@ class BasicTest(TestCase): try: resp.read() except client.IncompleteRead as i: - self.assertEquals(i.partial, b'Hello\r\n') + self.assertEqual(i.partial, b'Hello\r\n') self.assertEqual(repr(i), "IncompleteRead(7 bytes read, 3 more expected)") self.assertEqual(str(i), @@ -319,7 +319,7 @@ class BasicTest(TestCase): class OfflineTest(TestCase): def test_responses(self): - self.assertEquals(client.responses[client.NOT_FOUND], "Not Found") + self.assertEqual(client.responses[client.NOT_FOUND], "Not Found") class SourceAddressTest(TestCase): diff --git a/Lib/test/test_imaplib.py b/Lib/test/test_imaplib.py index b97989f..f9fbe96 100644 --- a/Lib/test/test_imaplib.py +++ b/Lib/test/test_imaplib.py @@ -112,7 +112,7 @@ class BaseThreadedNetworkedTests(unittest.TestCase): if verbose: print("creating server") server = MyServer(addr, hdlr) - self.assertEquals(server.server_address, server.socket.getsockname()) + self.assertEqual(server.server_address, server.socket.getsockname()) if verbose: print("server created") diff --git a/Lib/test/test_imp.py b/Lib/test/test_imp.py index 3aa0fc0..d745ae9 100644 --- a/Lib/test/test_imp.py +++ b/Lib/test/test_imp.py @@ -85,7 +85,7 @@ class ImportTests(unittest.TestCase): file.write("# coding: cp1252\nu = 'test.test_imp'\n") file, filename, info = imp.find_module(temp_mod_name) file.close() - self.assertEquals(file.encoding, 'cp1252') + self.assertEqual(file.encoding, 'cp1252') finally: del sys.path[0] support.unlink(temp_mod_name + '.py') diff --git a/Lib/test/test_inspect.py b/Lib/test/test_inspect.py index df480b8..cba6f13 100644 --- a/Lib/test/test_inspect.py +++ b/Lib/test/test_inspect.py @@ -385,8 +385,8 @@ class TestBuggyCases(GetSourceBase): self.assertRaises(IOError, inspect.findsource, co) self.assertRaises(IOError, inspect.getsource, co) linecache.cache[co.co_filename] = (1, None, lines, co.co_filename) - self.assertEquals(inspect.findsource(co), (lines,0)) - self.assertEquals(inspect.getsource(co), lines[0]) + self.assertEqual(inspect.findsource(co), (lines,0)) + self.assertEqual(inspect.getsource(co), lines[0]) # Helper for testing classify_class_attrs. def attrs_wo_objs(cls): diff --git a/Lib/test/test_int.py b/Lib/test/test_int.py index 0ea5772..86c4dd7 100644 --- a/Lib/test/test_int.py +++ b/Lib/test/test_int.py @@ -295,7 +295,7 @@ class IntTestCases(unittest.TestCase): try: int(TruncReturnsNonIntegral()) except TypeError as e: - self.assertEquals(str(e), + self.assertEqual(str(e), "__trunc__ returned non-Integral" " (type NonIntegral)") else: diff --git a/Lib/test/test_io.py b/Lib/test/test_io.py index 91dd803..bcf435f 100644 --- a/Lib/test/test_io.py +++ b/Lib/test/test_io.py @@ -630,7 +630,7 @@ class CommonBufferedTests: rawio = self.MockRawIO() bufio = self.tp(rawio) - self.assertEquals(42, bufio.fileno()) + self.assertEqual(42, bufio.fileno()) def test_no_fileno(self): # XXX will we always have fileno() function? If so, kill @@ -740,36 +740,36 @@ class BufferedReaderTest(unittest.TestCase, CommonBufferedTests): bufio.__init__(rawio) bufio.__init__(rawio, buffer_size=1024) bufio.__init__(rawio, buffer_size=16) - self.assertEquals(b"abc", bufio.read()) + self.assertEqual(b"abc", bufio.read()) self.assertRaises(ValueError, bufio.__init__, rawio, buffer_size=0) self.assertRaises(ValueError, bufio.__init__, rawio, buffer_size=-16) self.assertRaises(ValueError, bufio.__init__, rawio, buffer_size=-1) rawio = self.MockRawIO([b"abc"]) bufio.__init__(rawio) - self.assertEquals(b"abc", bufio.read()) + self.assertEqual(b"abc", bufio.read()) def test_read(self): for arg in (None, 7): rawio = self.MockRawIO((b"abc", b"d", b"efg")) bufio = self.tp(rawio) - self.assertEquals(b"abcdefg", bufio.read(arg)) + self.assertEqual(b"abcdefg", bufio.read(arg)) # Invalid args self.assertRaises(ValueError, bufio.read, -2) def test_read1(self): rawio = self.MockRawIO((b"abc", b"d", b"efg")) bufio = self.tp(rawio) - self.assertEquals(b"a", bufio.read(1)) - self.assertEquals(b"b", bufio.read1(1)) - self.assertEquals(rawio._reads, 1) - self.assertEquals(b"c", bufio.read1(100)) - self.assertEquals(rawio._reads, 1) - self.assertEquals(b"d", bufio.read1(100)) - self.assertEquals(rawio._reads, 2) - self.assertEquals(b"efg", bufio.read1(100)) - self.assertEquals(rawio._reads, 3) - self.assertEquals(b"", bufio.read1(100)) - self.assertEquals(rawio._reads, 4) + self.assertEqual(b"a", bufio.read(1)) + self.assertEqual(b"b", bufio.read1(1)) + self.assertEqual(rawio._reads, 1) + self.assertEqual(b"c", bufio.read1(100)) + self.assertEqual(rawio._reads, 1) + self.assertEqual(b"d", bufio.read1(100)) + self.assertEqual(rawio._reads, 2) + self.assertEqual(b"efg", bufio.read1(100)) + self.assertEqual(rawio._reads, 3) + self.assertEqual(b"", bufio.read1(100)) + self.assertEqual(rawio._reads, 4) # Invalid args self.assertRaises(ValueError, bufio.read1, -1) @@ -777,24 +777,24 @@ class BufferedReaderTest(unittest.TestCase, CommonBufferedTests): rawio = self.MockRawIO((b"abc", b"d", b"efg")) bufio = self.tp(rawio) b = bytearray(2) - self.assertEquals(bufio.readinto(b), 2) - self.assertEquals(b, b"ab") - self.assertEquals(bufio.readinto(b), 2) - self.assertEquals(b, b"cd") - self.assertEquals(bufio.readinto(b), 2) - self.assertEquals(b, b"ef") - self.assertEquals(bufio.readinto(b), 1) - self.assertEquals(b, b"gf") - self.assertEquals(bufio.readinto(b), 0) - self.assertEquals(b, b"gf") + self.assertEqual(bufio.readinto(b), 2) + self.assertEqual(b, b"ab") + self.assertEqual(bufio.readinto(b), 2) + self.assertEqual(b, b"cd") + self.assertEqual(bufio.readinto(b), 2) + self.assertEqual(b, b"ef") + self.assertEqual(bufio.readinto(b), 1) + self.assertEqual(b, b"gf") + self.assertEqual(bufio.readinto(b), 0) + self.assertEqual(b, b"gf") def test_readlines(self): def bufio(): rawio = self.MockRawIO((b"abc\n", b"d\n", b"ef")) return self.tp(rawio) - self.assertEquals(bufio().readlines(), [b"abc\n", b"d\n", b"ef"]) - self.assertEquals(bufio().readlines(5), [b"abc\n", b"d\n"]) - self.assertEquals(bufio().readlines(None), [b"abc\n", b"d\n", b"ef"]) + self.assertEqual(bufio().readlines(), [b"abc\n", b"d\n", b"ef"]) + self.assertEqual(bufio().readlines(5), [b"abc\n", b"d\n"]) + self.assertEqual(bufio().readlines(None), [b"abc\n", b"d\n", b"ef"]) def test_buffering(self): data = b"abcdefghi" @@ -811,34 +811,34 @@ class BufferedReaderTest(unittest.TestCase, CommonBufferedTests): bufio = self.tp(rawio, buffer_size=bufsize) pos = 0 for nbytes in buf_read_sizes: - self.assertEquals(bufio.read(nbytes), data[pos:pos+nbytes]) + self.assertEqual(bufio.read(nbytes), data[pos:pos+nbytes]) pos += nbytes # this is mildly implementation-dependent - self.assertEquals(rawio.read_history, raw_read_sizes) + self.assertEqual(rawio.read_history, raw_read_sizes) def test_read_non_blocking(self): # Inject some None's in there to simulate EWOULDBLOCK rawio = self.MockRawIO((b"abc", b"d", None, b"efg", None, None, None)) bufio = self.tp(rawio) - self.assertEquals(b"abcd", bufio.read(6)) - self.assertEquals(b"e", bufio.read(1)) - self.assertEquals(b"fg", bufio.read()) - self.assertEquals(b"", bufio.peek(1)) + self.assertEqual(b"abcd", bufio.read(6)) + self.assertEqual(b"e", bufio.read(1)) + self.assertEqual(b"fg", bufio.read()) + self.assertEqual(b"", bufio.peek(1)) self.assertTrue(None is bufio.read()) - self.assertEquals(b"", bufio.read()) + self.assertEqual(b"", bufio.read()) def test_read_past_eof(self): rawio = self.MockRawIO((b"abc", b"d", b"efg")) bufio = self.tp(rawio) - self.assertEquals(b"abcdefg", bufio.read(9000)) + self.assertEqual(b"abcdefg", bufio.read(9000)) def test_read_all(self): rawio = self.MockRawIO((b"abc", b"d", b"efg")) bufio = self.tp(rawio) - self.assertEquals(b"abcdefg", bufio.read()) + self.assertEqual(b"abcdefg", bufio.read()) @unittest.skipUnless(threading, 'Threading required for this test.') @support.requires_resource('cpu') @@ -965,15 +965,15 @@ class BufferedWriterTest(unittest.TestCase, CommonBufferedTests): bufio.__init__(rawio) bufio.__init__(rawio, buffer_size=1024) bufio.__init__(rawio, buffer_size=16) - self.assertEquals(3, bufio.write(b"abc")) + self.assertEqual(3, bufio.write(b"abc")) bufio.flush() self.assertRaises(ValueError, bufio.__init__, rawio, buffer_size=0) self.assertRaises(ValueError, bufio.__init__, rawio, buffer_size=-16) self.assertRaises(ValueError, bufio.__init__, rawio, buffer_size=-1) bufio.__init__(rawio) - self.assertEquals(3, bufio.write(b"ghi")) + self.assertEqual(3, bufio.write(b"ghi")) bufio.flush() - self.assertEquals(b"".join(rawio._write_stack), b"abcghi") + self.assertEqual(b"".join(rawio._write_stack), b"abcghi") def test_detach_flush(self): raw = self.MockRawIO() @@ -1015,11 +1015,11 @@ class BufferedWriterTest(unittest.TestCase, CommonBufferedTests): sizes = gen_sizes() while n < len(contents): size = min(next(sizes), len(contents) - n) - self.assertEquals(bufio.write(contents[n:n+size]), size) + self.assertEqual(bufio.write(contents[n:n+size]), size) intermediate_func(bufio) n += size bufio.flush() - self.assertEquals(contents, b"".join(writer._write_stack)) + self.assertEqual(contents, b"".join(writer._write_stack)) def test_writes(self): self.check_writes(lambda bufio: None) @@ -1048,11 +1048,11 @@ class BufferedWriterTest(unittest.TestCase, CommonBufferedTests): raw = self.MockNonBlockWriterIO() bufio = self.tp(raw, 8) - self.assertEquals(bufio.write(b"abcd"), 4) - self.assertEquals(bufio.write(b"efghi"), 5) + self.assertEqual(bufio.write(b"abcd"), 4) + self.assertEqual(bufio.write(b"efghi"), 5) # 1 byte will be written, the rest will be buffered raw.block_on(b"k") - self.assertEquals(bufio.write(b"jklmn"), 5) + self.assertEqual(bufio.write(b"jklmn"), 5) # 8 bytes will be written, 8 will be buffered and the rest will be lost raw.block_on(b"0") @@ -1062,11 +1062,11 @@ class BufferedWriterTest(unittest.TestCase, CommonBufferedTests): written = e.characters_written else: self.fail("BlockingIOError should have been raised") - self.assertEquals(written, 16) - self.assertEquals(raw.pop_written(), + self.assertEqual(written, 16) + self.assertEqual(raw.pop_written(), b"abcdefghijklmnopqrwxyz") - self.assertEquals(bufio.write(b"ABCDEFGHI"), 9) + self.assertEqual(bufio.write(b"ABCDEFGHI"), 9) s = raw.pop_written() # Previously buffered bytes were flushed self.assertTrue(s.startswith(b"01234567A"), s) @@ -1089,7 +1089,7 @@ class BufferedWriterTest(unittest.TestCase, CommonBufferedTests): bufio = self.tp(writer, 8) bufio.write(b"abc") bufio.flush() - self.assertEquals(b"abc", writer._write_stack[0]) + self.assertEqual(b"abc", writer._write_stack[0]) def test_destructor(self): writer = self.MockRawIO() @@ -1097,7 +1097,7 @@ class BufferedWriterTest(unittest.TestCase, CommonBufferedTests): bufio.write(b"abc") del bufio support.gc_collect() - self.assertEquals(b"abc", writer._write_stack[0]) + self.assertEqual(b"abc", writer._write_stack[0]) def test_truncate(self): # Truncate implicitly flushes the buffer. @@ -1156,7 +1156,7 @@ class BufferedWriterTest(unittest.TestCase, CommonBufferedTests): with self.open(support.TESTFN, "rb") as f: s = f.read() for i in range(256): - self.assertEquals(s.count(bytes([i])), N) + self.assertEqual(s.count(bytes([i])), N) finally: support.unlink(support.TESTFN) @@ -1357,45 +1357,45 @@ class BufferedRandomTest(BufferedReaderTest, BufferedWriterTest): rw.write(b"eee") self.assertFalse(raw._write_stack) # Buffer writes self.assertEqual(b"ghjk", rw.read()) - self.assertEquals(b"dddeee", raw._write_stack[0]) + self.assertEqual(b"dddeee", raw._write_stack[0]) def test_seek_and_tell(self): raw = self.BytesIO(b"asdfghjkl") rw = self.tp(raw) - self.assertEquals(b"as", rw.read(2)) - self.assertEquals(2, rw.tell()) + self.assertEqual(b"as", rw.read(2)) + self.assertEqual(2, rw.tell()) rw.seek(0, 0) - self.assertEquals(b"asdf", rw.read(4)) + self.assertEqual(b"asdf", rw.read(4)) rw.write(b"asdf") rw.seek(0, 0) - self.assertEquals(b"asdfasdfl", rw.read()) - self.assertEquals(9, rw.tell()) + self.assertEqual(b"asdfasdfl", rw.read()) + self.assertEqual(9, rw.tell()) rw.seek(-4, 2) - self.assertEquals(5, rw.tell()) + self.assertEqual(5, rw.tell()) rw.seek(2, 1) - self.assertEquals(7, rw.tell()) - self.assertEquals(b"fl", rw.read(11)) + self.assertEqual(7, rw.tell()) + self.assertEqual(b"fl", rw.read(11)) self.assertRaises(TypeError, rw.seek, 0.0) def check_flush_and_read(self, read_func): raw = self.BytesIO(b"abcdefghi") bufio = self.tp(raw) - self.assertEquals(b"ab", read_func(bufio, 2)) + self.assertEqual(b"ab", read_func(bufio, 2)) bufio.write(b"12") - self.assertEquals(b"ef", read_func(bufio, 2)) - self.assertEquals(6, bufio.tell()) + self.assertEqual(b"ef", read_func(bufio, 2)) + self.assertEqual(6, bufio.tell()) bufio.flush() - self.assertEquals(6, bufio.tell()) - self.assertEquals(b"ghi", read_func(bufio)) + self.assertEqual(6, bufio.tell()) + self.assertEqual(b"ghi", read_func(bufio)) raw.seek(0, 0) raw.write(b"XYZ") # flush() resets the read buffer bufio.flush() bufio.seek(0, 0) - self.assertEquals(b"XYZ", read_func(bufio, 3)) + self.assertEqual(b"XYZ", read_func(bufio, 3)) def test_flush_and_read(self): self.check_flush_and_read(lambda bufio, *args: bufio.read(*args)) @@ -1427,8 +1427,8 @@ class BufferedRandomTest(BufferedReaderTest, BufferedWriterTest): bufio.write(b"45") bufio.flush() bufio.seek(0, 0) - self.assertEquals(b"12345fghi", raw.getvalue()) - self.assertEquals(b"12345fghi", bufio.read()) + self.assertEqual(b"12345fghi", raw.getvalue()) + self.assertEqual(b"12345fghi", bufio.read()) def test_threads(self): BufferedReaderTest.test_threads(self) @@ -1656,12 +1656,12 @@ class StatefulIncrementalDecoderTest(unittest.TestCase): # Try a few one-shot test cases. for input, eof, output in self.test_cases: d = StatefulIncrementalDecoder() - self.assertEquals(d.decode(input, eof), output) + self.assertEqual(d.decode(input, eof), output) # Also test an unfinished decode, followed by forcing EOF. d = StatefulIncrementalDecoder() - self.assertEquals(d.decode(b'oiabcd'), '') - self.assertEquals(d.decode(b'', 1), 'abcd.') + self.assertEqual(d.decode(b'oiabcd'), '') + self.assertEqual(d.decode(b'', 1), 'abcd.') class TextIOWrapperTest(unittest.TestCase): @@ -1678,12 +1678,12 @@ class TextIOWrapperTest(unittest.TestCase): b = self.BufferedReader(r, 1000) t = self.TextIOWrapper(b) t.__init__(b, encoding="latin1", newline="\r\n") - self.assertEquals(t.encoding, "latin1") - self.assertEquals(t.line_buffering, False) + self.assertEqual(t.encoding, "latin1") + self.assertEqual(t.line_buffering, False) t.__init__(b, encoding="utf8", line_buffering=True) - self.assertEquals(t.encoding, "utf8") - self.assertEquals(t.line_buffering, True) - self.assertEquals("\xe9\n", t.readline()) + self.assertEqual(t.encoding, "utf8") + self.assertEqual(t.line_buffering, True) + self.assertEqual("\xe9\n", t.readline()) self.assertRaises(TypeError, t.__init__, b, newline=42) self.assertRaises(ValueError, t.__init__, b, newline='xyzzy') @@ -1719,11 +1719,11 @@ class TextIOWrapperTest(unittest.TestCase): b = self.BufferedWriter(r, 1000) t = self.TextIOWrapper(b, newline="\n", line_buffering=True) t.write("X") - self.assertEquals(r.getvalue(), b"") # No flush happened + self.assertEqual(r.getvalue(), b"") # No flush happened t.write("Y\nZ") - self.assertEquals(r.getvalue(), b"XY\nZ") # All got flushed + self.assertEqual(r.getvalue(), b"XY\nZ") # All got flushed t.write("A\rB") - self.assertEquals(r.getvalue(), b"XY\nZA\rB") + self.assertEqual(r.getvalue(), b"XY\nZA\rB") def test_encoding(self): # Check the encoding attribute is always set, and valid @@ -1746,11 +1746,11 @@ class TextIOWrapperTest(unittest.TestCase): # (3) ignore b = self.BytesIO(b"abc\n\xff\n") t = self.TextIOWrapper(b, encoding="ascii", errors="ignore") - self.assertEquals(t.read(), "abc\n\n") + self.assertEqual(t.read(), "abc\n\n") # (4) replace b = self.BytesIO(b"abc\n\xff\n") t = self.TextIOWrapper(b, encoding="ascii", errors="replace") - self.assertEquals(t.read(), "abc\n\ufffd\n") + self.assertEqual(t.read(), "abc\n\ufffd\n") def test_encoding_errors_writing(self): # (1) default @@ -1767,14 +1767,14 @@ class TextIOWrapperTest(unittest.TestCase): newline="\n") t.write("abc\xffdef\n") t.flush() - self.assertEquals(b.getvalue(), b"abcdef\n") + self.assertEqual(b.getvalue(), b"abcdef\n") # (4) replace b = self.BytesIO() t = self.TextIOWrapper(b, encoding="ascii", errors="replace", newline="\n") t.write("abc\xffdef\n") t.flush() - self.assertEquals(b.getvalue(), b"abc?def\n") + self.assertEqual(b.getvalue(), b"abc?def\n") def test_newlines(self): input_lines = [ "unix\n", "windows\r\n", "os9\r", "last\n", "nonl" ] @@ -1809,14 +1809,14 @@ class TextIOWrapperTest(unittest.TestCase): c2 = textio.read(2) if c2 == '': break - self.assertEquals(len(c2), 2) + self.assertEqual(len(c2), 2) got_lines.append(c2 + textio.readline()) else: got_lines = list(textio) for got_line, exp_line in zip(got_lines, exp_lines): - self.assertEquals(got_line, exp_line) - self.assertEquals(len(got_lines), len(exp_lines)) + self.assertEqual(got_line, exp_line) + self.assertEqual(len(got_lines), len(exp_lines)) def test_newlines_input(self): testdata = b"AAA\nBB\x00B\nCCC\rDDD\rEEE\r\nFFF\r\nGGG" @@ -1830,9 +1830,9 @@ class TextIOWrapperTest(unittest.TestCase): ]: buf = self.BytesIO(testdata) txt = self.TextIOWrapper(buf, encoding="ascii", newline=newline) - self.assertEquals(txt.readlines(), expected) + self.assertEqual(txt.readlines(), expected) txt.seek(0) - self.assertEquals(txt.read(), "".join(expected)) + self.assertEqual(txt.read(), "".join(expected)) def test_newlines_output(self): testdict = { @@ -1849,8 +1849,8 @@ class TextIOWrapperTest(unittest.TestCase): txt.write("BB\nCCC\n") txt.write("X\rY\r\nZ") txt.flush() - self.assertEquals(buf.closed, False) - self.assertEquals(buf.getvalue(), expected) + self.assertEqual(buf.closed, False) + self.assertEqual(buf.getvalue(), expected) def test_destructor(self): l = [] @@ -1864,7 +1864,7 @@ class TextIOWrapperTest(unittest.TestCase): t.write("abc") del t support.gc_collect() - self.assertEquals([b"abc"], l) + self.assertEqual([b"abc"], l) def test_override_destructor(self): record = [] @@ -1911,26 +1911,26 @@ class TextIOWrapperTest(unittest.TestCase): for enc in "ascii", "latin1", "utf8" :# , "utf-16-be", "utf-16-le": f = self.open(support.TESTFN, "w+", encoding=enc) f._CHUNK_SIZE = chunksize - self.assertEquals(f.write("abc"), 3) + self.assertEqual(f.write("abc"), 3) f.close() f = self.open(support.TESTFN, "r+", encoding=enc) f._CHUNK_SIZE = chunksize - self.assertEquals(f.tell(), 0) - self.assertEquals(f.read(), "abc") + self.assertEqual(f.tell(), 0) + self.assertEqual(f.read(), "abc") cookie = f.tell() - self.assertEquals(f.seek(0), 0) - self.assertEquals(f.read(None), "abc") + self.assertEqual(f.seek(0), 0) + self.assertEqual(f.read(None), "abc") f.seek(0) - self.assertEquals(f.read(2), "ab") - self.assertEquals(f.read(1), "c") - self.assertEquals(f.read(1), "") - self.assertEquals(f.read(), "") - self.assertEquals(f.tell(), cookie) - self.assertEquals(f.seek(0), 0) - self.assertEquals(f.seek(0, 2), cookie) - self.assertEquals(f.write("def"), 3) - self.assertEquals(f.seek(cookie), cookie) - self.assertEquals(f.read(), "def") + self.assertEqual(f.read(2), "ab") + self.assertEqual(f.read(1), "c") + self.assertEqual(f.read(1), "") + self.assertEqual(f.read(), "") + self.assertEqual(f.tell(), cookie) + self.assertEqual(f.seek(0), 0) + self.assertEqual(f.seek(0, 2), cookie) + self.assertEqual(f.write("def"), 3) + self.assertEqual(f.seek(cookie), cookie) + self.assertEqual(f.read(), "def") if enc.startswith("utf"): self.multi_line_test(f, enc) f.close() @@ -1955,7 +1955,7 @@ class TextIOWrapperTest(unittest.TestCase): if not line: break rlines.append((pos, line)) - self.assertEquals(rlines, wlines) + self.assertEqual(rlines, wlines) def test_telling(self): f = self.open(support.TESTFN, "w+", encoding="utf8") @@ -1965,16 +1965,16 @@ class TextIOWrapperTest(unittest.TestCase): f.write("\xff\n") p2 = f.tell() f.seek(0) - self.assertEquals(f.tell(), p0) - self.assertEquals(f.readline(), "\xff\n") - self.assertEquals(f.tell(), p1) - self.assertEquals(f.readline(), "\xff\n") - self.assertEquals(f.tell(), p2) + self.assertEqual(f.tell(), p0) + self.assertEqual(f.readline(), "\xff\n") + self.assertEqual(f.tell(), p1) + self.assertEqual(f.readline(), "\xff\n") + self.assertEqual(f.tell(), p2) f.seek(0) for line in f: - self.assertEquals(line, "\xff\n") + self.assertEqual(line, "\xff\n") self.assertRaises(IOError, f.tell) - self.assertEquals(f.tell(), p2) + self.assertEqual(f.tell(), p2) f.close() def test_seeking(self): @@ -1982,7 +1982,7 @@ class TextIOWrapperTest(unittest.TestCase): prefix_size = chunk_size - 2 u_prefix = "a" * prefix_size prefix = bytes(u_prefix.encode("utf-8")) - self.assertEquals(len(u_prefix), len(prefix)) + self.assertEqual(len(u_prefix), len(prefix)) u_suffix = "\u8888\n" suffix = bytes(u_suffix.encode("utf-8")) line = prefix + suffix @@ -1990,9 +1990,9 @@ class TextIOWrapperTest(unittest.TestCase): f.write(line*2) with self.open(support.TESTFN, "r", encoding="utf-8") as f: s = f.read(prefix_size) - self.assertEquals(s, str(prefix, "ascii")) - self.assertEquals(f.tell(), prefix_size) - self.assertEquals(f.readline(), u_suffix) + self.assertEqual(s, str(prefix, "ascii")) + self.assertEqual(f.tell(), prefix_size) + self.assertEqual(f.readline(), u_suffix) def test_seeking_too(self): # Regression test for a specific bug @@ -2024,11 +2024,11 @@ class TextIOWrapperTest(unittest.TestCase): for i in range(min_pos, len(decoded) + 1): # seek positions for j in [1, 5, len(decoded) - i]: # read lengths f = self.open(support.TESTFN, encoding='test_decoder') - self.assertEquals(f.read(i), decoded[:i]) + self.assertEqual(f.read(i), decoded[:i]) cookie = f.tell() - self.assertEquals(f.read(j), decoded[i:i + j]) + self.assertEqual(f.read(j), decoded[i:i + j]) f.seek(cookie) - self.assertEquals(f.read(), decoded[i:]) + self.assertEqual(f.read(), decoded[i:]) f.close() # Enable the test decoder. @@ -2067,10 +2067,10 @@ class TextIOWrapperTest(unittest.TestCase): f.write(data) f.write(data) f.seek(0) - self.assertEquals(f.read(), data * 2) + self.assertEqual(f.read(), data * 2) f.seek(0) - self.assertEquals(f.read(), data * 2) - self.assertEquals(buf.getvalue(), (data * 2).encode(encoding)) + self.assertEqual(f.read(), data * 2) + self.assertEqual(buf.getvalue(), (data * 2).encode(encoding)) def test_unreadable(self): class UnReadable(self.BytesIO): @@ -2087,7 +2087,7 @@ class TextIOWrapperTest(unittest.TestCase): if not c: break reads += c - self.assertEquals(reads, "AA\nBB") + self.assertEqual(reads, "AA\nBB") def test_readlines(self): txt = self.TextIOWrapper(self.BytesIO(b"AA\nBB\nCC")) @@ -2107,7 +2107,7 @@ class TextIOWrapperTest(unittest.TestCase): if not c: break reads += c - self.assertEquals(reads, "A"*127+"\nB") + self.assertEqual(reads, "A"*127+"\nB") def test_issue1395_1(self): txt = self.TextIOWrapper(self.BytesIO(self.testdata), encoding="ascii") @@ -2119,7 +2119,7 @@ class TextIOWrapperTest(unittest.TestCase): if not c: break reads += c - self.assertEquals(reads, self.normalized) + self.assertEqual(reads, self.normalized) def test_issue1395_2(self): txt = self.TextIOWrapper(self.BytesIO(self.testdata), encoding="ascii") @@ -2131,7 +2131,7 @@ class TextIOWrapperTest(unittest.TestCase): if not c: break reads += c - self.assertEquals(reads, self.normalized) + self.assertEqual(reads, self.normalized) def test_issue1395_3(self): txt = self.TextIOWrapper(self.BytesIO(self.testdata), encoding="ascii") @@ -2142,7 +2142,7 @@ class TextIOWrapperTest(unittest.TestCase): reads += txt.readline() reads += txt.readline() reads += txt.readline() - self.assertEquals(reads, self.normalized) + self.assertEqual(reads, self.normalized) def test_issue1395_4(self): txt = self.TextIOWrapper(self.BytesIO(self.testdata), encoding="ascii") @@ -2150,7 +2150,7 @@ class TextIOWrapperTest(unittest.TestCase): reads = txt.read(4) reads += txt.read() - self.assertEquals(reads, self.normalized) + self.assertEqual(reads, self.normalized) def test_issue1395_5(self): txt = self.TextIOWrapper(self.BytesIO(self.testdata), encoding="ascii") @@ -2160,7 +2160,7 @@ class TextIOWrapperTest(unittest.TestCase): pos = txt.tell() txt.seek(0) txt.seek(pos) - self.assertEquals(txt.read(4), "BBB\n") + self.assertEqual(txt.read(4), "BBB\n") def test_issue2282(self): buffer = self.BytesIO(self.testdata) @@ -2176,12 +2176,12 @@ class TextIOWrapperTest(unittest.TestCase): f.write('aaa') pos = f.tell() with self.open(filename, 'rb') as f: - self.assertEquals(f.read(), 'aaa'.encode(charset)) + self.assertEqual(f.read(), 'aaa'.encode(charset)) with self.open(filename, 'a', encoding=charset) as f: f.write('xxx') with self.open(filename, 'rb') as f: - self.assertEquals(f.read(), 'aaaxxx'.encode(charset)) + self.assertEqual(f.read(), 'aaaxxx'.encode(charset)) def test_seek_bom(self): # Same test, but when seeking manually @@ -2196,7 +2196,7 @@ class TextIOWrapperTest(unittest.TestCase): f.seek(0) f.write('bbb') with self.open(filename, 'rb') as f: - self.assertEquals(f.read(), 'bbbzzz'.encode(charset)) + self.assertEqual(f.read(), 'bbbzzz'.encode(charset)) def test_errors_property(self): with self.open(support.TESTFN, "w") as f: @@ -2224,7 +2224,7 @@ class TextIOWrapperTest(unittest.TestCase): with self.open(support.TESTFN) as f: content = f.read() for n in range(20): - self.assertEquals(content.count("Thread%03d\n" % n), 1) + self.assertEqual(content.count("Thread%03d\n" % n), 1) def test_flush_error_on_close(self): txt = self.TextIOWrapper(self.BytesIO(self.testdata), encoding="ascii") @@ -2283,9 +2283,9 @@ class IncrementalNewlineDecoderTest(unittest.TestCase): def _check_decode(b, s, **kwargs): # We exercise getstate() / setstate() as well as decode() state = decoder.getstate() - self.assertEquals(decoder.decode(b, **kwargs), s) + self.assertEqual(decoder.decode(b, **kwargs), s) decoder.setstate(state) - self.assertEquals(decoder.decode(b, **kwargs), s) + self.assertEqual(decoder.decode(b, **kwargs), s) _check_decode(b'\xe8\xa2\x88', "\u8888") @@ -2334,24 +2334,24 @@ class IncrementalNewlineDecoderTest(unittest.TestCase): # Decode one char at a time for c in s: result.append(decoder.decode(c)) - self.assertEquals(decoder.newlines, None) + self.assertEqual(decoder.newlines, None) _decode_bytewise("abc\n\r") - self.assertEquals(decoder.newlines, '\n') + self.assertEqual(decoder.newlines, '\n') _decode_bytewise("\nabc") - self.assertEquals(decoder.newlines, ('\n', '\r\n')) + self.assertEqual(decoder.newlines, ('\n', '\r\n')) _decode_bytewise("abc\r") - self.assertEquals(decoder.newlines, ('\n', '\r\n')) + self.assertEqual(decoder.newlines, ('\n', '\r\n')) _decode_bytewise("abc") - self.assertEquals(decoder.newlines, ('\r', '\n', '\r\n')) + self.assertEqual(decoder.newlines, ('\r', '\n', '\r\n')) _decode_bytewise("abc\r") - self.assertEquals("".join(result), "abc\n\nabcabc\nabcabc") + self.assertEqual("".join(result), "abc\n\nabcabc\nabcabc") decoder.reset() input = "abc" if encoder is not None: encoder.reset() input = encoder.encode(input) - self.assertEquals(decoder.decode(input), "abc") - self.assertEquals(decoder.newlines, None) + self.assertEqual(decoder.decode(input), "abc") + self.assertEqual(decoder.newlines, None) def test_newline_decoder(self): encodings = ( @@ -2372,11 +2372,11 @@ class IncrementalNewlineDecoderTest(unittest.TestCase): def test_newline_bytes(self): # Issue 5433: Excessive optimization in IncrementalNewlineDecoder def _check(dec): - self.assertEquals(dec.newlines, None) - self.assertEquals(dec.decode("\u0D00"), "\u0D00") - self.assertEquals(dec.newlines, None) - self.assertEquals(dec.decode("\u0A00"), "\u0A00") - self.assertEquals(dec.newlines, None) + self.assertEqual(dec.newlines, None) + self.assertEqual(dec.decode("\u0D00"), "\u0D00") + self.assertEqual(dec.newlines, None) + self.assertEqual(dec.decode("\u0A00"), "\u0A00") + self.assertEqual(dec.newlines, None) dec = self.IncrementalNewlineDecoder(None, translate=False) _check(dec) dec = self.IncrementalNewlineDecoder(None, translate=True) @@ -2409,28 +2409,28 @@ class MiscIOTest(unittest.TestCase): def test_attributes(self): f = self.open(support.TESTFN, "wb", buffering=0) - self.assertEquals(f.mode, "wb") + self.assertEqual(f.mode, "wb") f.close() f = self.open(support.TESTFN, "U") - self.assertEquals(f.name, support.TESTFN) - self.assertEquals(f.buffer.name, support.TESTFN) - self.assertEquals(f.buffer.raw.name, support.TESTFN) - self.assertEquals(f.mode, "U") - self.assertEquals(f.buffer.mode, "rb") - self.assertEquals(f.buffer.raw.mode, "rb") + self.assertEqual(f.name, support.TESTFN) + self.assertEqual(f.buffer.name, support.TESTFN) + self.assertEqual(f.buffer.raw.name, support.TESTFN) + self.assertEqual(f.mode, "U") + self.assertEqual(f.buffer.mode, "rb") + self.assertEqual(f.buffer.raw.mode, "rb") f.close() f = self.open(support.TESTFN, "w+") - self.assertEquals(f.mode, "w+") - self.assertEquals(f.buffer.mode, "rb+") # Does it really matter? - self.assertEquals(f.buffer.raw.mode, "rb+") + self.assertEqual(f.mode, "w+") + self.assertEqual(f.buffer.mode, "rb+") # Does it really matter? + self.assertEqual(f.buffer.raw.mode, "rb+") g = self.open(f.fileno(), "wb", closefd=False) - self.assertEquals(g.mode, "wb") - self.assertEquals(g.raw.mode, "wb") - self.assertEquals(g.name, f.fileno()) - self.assertEquals(g.raw.name, f.fileno()) + self.assertEqual(g.mode, "wb") + self.assertEqual(g.raw.mode, "wb") + self.assertEqual(g.name, f.fileno()) + self.assertEqual(g.raw.name, f.fileno()) f.close() g.close() diff --git a/Lib/test/test_ioctl.py b/Lib/test/test_ioctl.py index 817d626..d4d5a22 100644 --- a/Lib/test/test_ioctl.py +++ b/Lib/test/test_ioctl.py @@ -50,7 +50,7 @@ class IoctlTests(unittest.TestCase): with open("/dev/tty", "r") as tty: r = fcntl.ioctl(tty, termios.TIOCGPGRP, buf, 1) rpgrp = buf[0] - self.assertEquals(r, 0) + self.assertEqual(r, 0) self.assertIn(rpgrp, ids) def test_ioctl_mutate(self): diff --git a/Lib/test/test_itertools.py b/Lib/test/test_itertools.py index 553eacf..06777a1 100644 --- a/Lib/test/test_itertools.py +++ b/Lib/test/test_itertools.py @@ -195,7 +195,7 @@ class TestBasicOps(unittest.TestCase): regular_combs = list(combinations(values, r)) # compare to combs without replacement if n == 0 or r <= 1: - self.assertEquals(result, regular_combs) # cases that should be identical + self.assertEqual(result, regular_combs) # cases that should be identical else: self.assertTrue(set(result) >= set(regular_combs)) # rest should be supersets of regular combs @@ -291,20 +291,20 @@ class TestBasicOps(unittest.TestCase): comb = list(combinations(s, r)) # Check size - self.assertEquals(len(prod), n**r) - self.assertEquals(len(cwr), (fact(n+r-1) / fact(r)/ fact(n-1)) if n else (not r)) - self.assertEquals(len(perm), 0 if r>n else fact(n) / fact(n-r)) - self.assertEquals(len(comb), 0 if r>n else fact(n) / fact(r) / fact(n-r)) + self.assertEqual(len(prod), n**r) + self.assertEqual(len(cwr), (fact(n+r-1) / fact(r)/ fact(n-1)) if n else (not r)) + self.assertEqual(len(perm), 0 if r>n else fact(n) / fact(n-r)) + self.assertEqual(len(comb), 0 if r>n else fact(n) / fact(r) / fact(n-r)) # Check lexicographic order without repeated tuples - self.assertEquals(prod, sorted(set(prod))) - self.assertEquals(cwr, sorted(set(cwr))) - self.assertEquals(perm, sorted(set(perm))) - self.assertEquals(comb, sorted(set(comb))) + self.assertEqual(prod, sorted(set(prod))) + self.assertEqual(cwr, sorted(set(cwr))) + self.assertEqual(perm, sorted(set(perm))) + self.assertEqual(comb, sorted(set(comb))) # Check interrelationships - self.assertEquals(cwr, [t for t in prod if sorted(t)==list(t)]) # cwr: prods which are sorted - self.assertEquals(perm, [t for t in prod if len(set(t))==r]) # perm: prods with no dups + self.assertEqual(cwr, [t for t in prod if sorted(t)==list(t)]) # cwr: prods which are sorted + self.assertEqual(perm, [t for t in prod if len(set(t))==r]) # perm: prods with no dups self.assertEqual(comb, [t for t in perm if sorted(t)==list(t)]) # comb: perms that are sorted self.assertEqual(comb, [t for t in cwr if len(set(t))==r]) # comb: cwrs without dups self.assertEqual(comb, list(filter(set(cwr).__contains__, perm))) # comb: perm that is a cwr diff --git a/Lib/test/test_keywordonlyarg.py b/Lib/test/test_keywordonlyarg.py index bdcc4c6..d7f7541 100644 --- a/Lib/test/test_keywordonlyarg.py +++ b/Lib/test/test_keywordonlyarg.py @@ -101,51 +101,51 @@ class KeywordOnlyArgTestCase(unittest.TestCase): pass def testFunctionCall(self): - self.assertEquals(1, posonly_sum(1)) - self.assertEquals(1+2, posonly_sum(1,**{"2":2})) - self.assertEquals(1+2+3, posonly_sum(1,*(2,3))) - self.assertEquals(1+2+3+4, posonly_sum(1,*(2,3),**{"4":4})) - - self.assertEquals(1, keywordonly_sum(k2=1)) - self.assertEquals(1+2, keywordonly_sum(k1=1, k2=2)) - - self.assertEquals(1+2, keywordonly_and_kwarg_sum(k1=1, k2=2)) - self.assertEquals(1+2+3, keywordonly_and_kwarg_sum(k1=1, k2=2, k3=3)) - self.assertEquals(1+2+3+4, - keywordonly_and_kwarg_sum(k1=1, k2=2, + self.assertEqual(1, posonly_sum(1)) + self.assertEqual(1+2, posonly_sum(1,**{"2":2})) + self.assertEqual(1+2+3, posonly_sum(1,*(2,3))) + self.assertEqual(1+2+3+4, posonly_sum(1,*(2,3),**{"4":4})) + + self.assertEqual(1, keywordonly_sum(k2=1)) + self.assertEqual(1+2, keywordonly_sum(k1=1, k2=2)) + + self.assertEqual(1+2, keywordonly_and_kwarg_sum(k1=1, k2=2)) + self.assertEqual(1+2+3, keywordonly_and_kwarg_sum(k1=1, k2=2, k3=3)) + self.assertEqual(1+2+3+4, + keywordonly_and_kwarg_sum(k1=1, k2=2, **{"a":3,"b":4})) - self.assertEquals(1+2, mixedargs_sum(1, k1=2)) - self.assertEquals(1+2+3, mixedargs_sum(1, 2, k1=3)) - self.assertEquals(1+2+3+4, mixedargs_sum(1, 2, k1=3, k2=4)) - self.assertEquals(1+2+3+4+5, mixedargs_sum(1, 2, 3, k1=4, k2=5)) + self.assertEqual(1+2, mixedargs_sum(1, k1=2)) + self.assertEqual(1+2+3, mixedargs_sum(1, 2, k1=3)) + self.assertEqual(1+2+3+4, mixedargs_sum(1, 2, k1=3, k2=4)) + self.assertEqual(1+2+3+4+5, mixedargs_sum(1, 2, 3, k1=4, k2=5)) - self.assertEquals(1+2, mixedargs_sum2(1, k1=2)) - self.assertEquals(1+2+3, mixedargs_sum2(1, 2, k1=3)) - self.assertEquals(1+2+3+4, mixedargs_sum2(1, 2, k1=3, k2=4)) - self.assertEquals(1+2+3+4+5, mixedargs_sum2(1, 2, 3, k1=4, k2=5)) - self.assertEquals(1+2+3+4+5+6, - mixedargs_sum2(1, 2, 3, k1=4, k2=5, k3=6)) - self.assertEquals(1+2+3+4+5+6, - mixedargs_sum2(1, 2, 3, k1=4, **{'k2':5, 'k3':6})) + self.assertEqual(1+2, mixedargs_sum2(1, k1=2)) + self.assertEqual(1+2+3, mixedargs_sum2(1, 2, k1=3)) + self.assertEqual(1+2+3+4, mixedargs_sum2(1, 2, k1=3, k2=4)) + self.assertEqual(1+2+3+4+5, mixedargs_sum2(1, 2, 3, k1=4, k2=5)) + self.assertEqual(1+2+3+4+5+6, + mixedargs_sum2(1, 2, 3, k1=4, k2=5, k3=6)) + self.assertEqual(1+2+3+4+5+6, + mixedargs_sum2(1, 2, 3, k1=4, **{'k2':5, 'k3':6})) - self.assertEquals(1, Foo(k1=1).sum()) - self.assertEquals(1+2, Foo(k1=1,k2=2).sum()) + self.assertEqual(1, Foo(k1=1).sum()) + self.assertEqual(1+2, Foo(k1=1,k2=2).sum()) - self.assertEquals([1,2,3], sortnum(3,2,1)) - self.assertEquals([3,2,1], sortnum(1,2,3, reverse=True)) + self.assertEqual([1,2,3], sortnum(3,2,1)) + self.assertEqual([3,2,1], sortnum(1,2,3, reverse=True)) - self.assertEquals(['a','b','c'], sortwords('a','c','b')) - self.assertEquals(['c','b','a'], sortwords('a','c','b', reverse=True)) - self.assertEquals(['c','b','a'], - sortwords('a','c','b', reverse=True, ignore='ignore')) + self.assertEqual(['a','b','c'], sortwords('a','c','b')) + self.assertEqual(['c','b','a'], sortwords('a','c','b', reverse=True)) + self.assertEqual(['c','b','a'], + sortwords('a','c','b', reverse=True, ignore='ignore')) def testKwDefaults(self): def foo(p1,p2=0, *, k1, k2=0): return p1 + p2 + k1 + k2 - self.assertEquals(2, foo.__code__.co_kwonlyargcount) - self.assertEquals({"k2":0}, foo.__kwdefaults__) + self.assertEqual(2, foo.__code__.co_kwonlyargcount) + self.assertEqual({"k2":0}, foo.__kwdefaults__) foo.__kwdefaults__ = {"k1":0} try: foo(1,k1=10) diff --git a/Lib/test/test_kqueue.py b/Lib/test/test_kqueue.py index 3d0428e..9cb0a85 100644 --- a/Lib/test/test_kqueue.py +++ b/Lib/test/test_kqueue.py @@ -91,7 +91,7 @@ class TestKQueue(unittest.TestCase): try: client.connect(('127.0.0.1', serverSocket.getsockname()[1])) except socket.error as e: - self.assertEquals(e.args[0], errno.EINPROGRESS) + self.assertEqual(e.args[0], errno.EINPROGRESS) else: #raise AssertionError("Connect should have raised EINPROGRESS") pass # FreeBSD doesn't raise an exception here @@ -125,7 +125,7 @@ class TestKQueue(unittest.TestCase): events = kq.control(None, 4, 1) events = [(e.ident, e.filter, e.flags) for e in events] events.sort() - self.assertEquals(events, [ + self.assertEqual(events, [ (client.fileno(), select.KQ_FILTER_WRITE, flags), (server.fileno(), select.KQ_FILTER_WRITE, flags)]) @@ -144,7 +144,7 @@ class TestKQueue(unittest.TestCase): events = [(e.ident, e.filter, e.flags) for e in events] events.sort() - self.assertEquals(events, [ + self.assertEqual(events, [ (client.fileno(), select.KQ_FILTER_WRITE, flags), (client.fileno(), select.KQ_FILTER_READ, flags), (server.fileno(), select.KQ_FILTER_WRITE, flags), @@ -167,7 +167,7 @@ class TestKQueue(unittest.TestCase): events = kq.control([], 4, 0.99) events = [(e.ident, e.filter, e.flags) for e in events] events.sort() - self.assertEquals(events, [ + self.assertEqual(events, [ (server.fileno(), select.KQ_FILTER_WRITE, flags)]) client.close() @@ -184,7 +184,7 @@ class TestKQueue(unittest.TestCase): r = kq.control([event1, event2], 1, 1) self.assertTrue(r) self.assertFalse(r[0].flags & select.KQ_EV_ERROR) - self.assertEquals(b.recv(r[0].data), b'foo') + self.assertEqual(b.recv(r[0].data), b'foo') a.close() b.close() diff --git a/Lib/test/test_linecache.py b/Lib/test/test_linecache.py index 83901e7..fcc390a 100644 --- a/Lib/test/test_linecache.py +++ b/Lib/test/test_linecache.py @@ -42,33 +42,33 @@ class LineCacheTests(unittest.TestCase): getline = linecache.getline # Bad values for line number should return an empty string - self.assertEquals(getline(FILENAME, 2**15), EMPTY) - self.assertEquals(getline(FILENAME, -1), EMPTY) + self.assertEqual(getline(FILENAME, 2**15), EMPTY) + self.assertEqual(getline(FILENAME, -1), EMPTY) # Float values currently raise TypeError, should it? self.assertRaises(TypeError, getline, FILENAME, 1.1) # Bad filenames should return an empty string - self.assertEquals(getline(EMPTY, 1), EMPTY) - self.assertEquals(getline(INVALID_NAME, 1), EMPTY) + self.assertEqual(getline(EMPTY, 1), EMPTY) + self.assertEqual(getline(INVALID_NAME, 1), EMPTY) # Check whether lines correspond to those from file iteration for entry in TESTS: filename = os.path.join(TEST_PATH, entry) + '.py' with open(filename) as file: for index, line in enumerate(file): - self.assertEquals(line, getline(filename, index + 1)) + self.assertEqual(line, getline(filename, index + 1)) # Check module loading for entry in MODULES: filename = os.path.join(MODULE_PATH, entry) + '.py' with open(filename) as file: for index, line in enumerate(file): - self.assertEquals(line, getline(filename, index + 1)) + self.assertEqual(line, getline(filename, index + 1)) # Check that bogus data isn't returned (issue #1309567) empty = linecache.getlines('a/b/c/__init__.py') - self.assertEquals(empty, []) + self.assertEqual(empty, []) def test_no_ending_newline(self): self.addCleanup(support.unlink, support.TESTFN) @@ -86,12 +86,12 @@ class LineCacheTests(unittest.TestCase): # Are all files cached? cached_empty = [fn for fn in cached if fn not in linecache.cache] - self.assertEquals(cached_empty, []) + self.assertEqual(cached_empty, []) # Can we clear the cache? linecache.clearcache() cached_empty = [fn for fn in cached if fn in linecache.cache] - self.assertEquals(cached_empty, []) + self.assertEqual(cached_empty, []) def test_checkcache(self): getline = linecache.getline @@ -106,7 +106,7 @@ class LineCacheTests(unittest.TestCase): source_list = [] with open(source_name) as source: for index, line in enumerate(source): - self.assertEquals(line, getline(source_name, index + 1)) + self.assertEqual(line, getline(source_name, index + 1)) source_list.append(line) with open(source_name, 'w') as source: @@ -117,13 +117,13 @@ class LineCacheTests(unittest.TestCase): # Check that the cache matches the old contents for index, line in enumerate(source_list): - self.assertEquals(line, getline(source_name, index + 1)) + self.assertEqual(line, getline(source_name, index + 1)) # Update the cache and check whether it matches the new source file linecache.checkcache(source_name) with open(source_name) as source: for index, line in enumerate(source): - self.assertEquals(line, getline(source_name, index + 1)) + self.assertEqual(line, getline(source_name, index + 1)) source_list.append(line) def test_main(): diff --git a/Lib/test/test_logging.py b/Lib/test/test_logging.py index 07c96e7..01c3336 100644 --- a/Lib/test/test_logging.py +++ b/Lib/test/test_logging.py @@ -127,14 +127,14 @@ class BaseTest(unittest.TestCase): except AttributeError: # StringIO.StringIO lacks a reset() method. actual_lines = stream.getvalue().splitlines() - self.assertEquals(len(actual_lines), len(expected_values), + self.assertEqual(len(actual_lines), len(expected_values), '%s vs. %s' % (actual_lines, expected_values)) for actual, expected in zip(actual_lines, expected_values): match = pat.search(actual) if not match: self.fail("Log line does not match expected pattern:\n" + actual) - self.assertEquals(tuple(match.groups()), expected) + self.assertEqual(tuple(match.groups()), expected) s = stream.read() if s: self.fail("Remaining output at end of log stream:\n" + s) @@ -729,7 +729,7 @@ class ConfigFileTest(BaseTest): except RuntimeError: logging.exception("just testing") sys.stdout.seek(0) - self.assertEquals(output.getvalue(), + self.assertEqual(output.getvalue(), "ERROR:root:just testing\nGot a [RuntimeError]\n") # Original logger output is empty self.assert_log_lines([]) @@ -848,7 +848,7 @@ class SocketHandlerTest(BaseTest): logger = logging.getLogger("tcp") logger.error("spam") logger.debug("eggs") - self.assertEquals(self.get_output(), "spam\neggs\n") + self.assertEqual(self.get_output(), "spam\neggs\n") class MemoryTest(BaseTest): @@ -1564,7 +1564,7 @@ class ConfigDictTest(BaseTest): except RuntimeError: logging.exception("just testing") sys.stdout.seek(0) - self.assertEquals(output.getvalue(), + self.assertEqual(output.getvalue(), "ERROR:root:just testing\nGot a [RuntimeError]\n") # Original logger output is empty self.assert_log_lines([]) @@ -1579,7 +1579,7 @@ class ConfigDictTest(BaseTest): except RuntimeError: logging.exception("just testing") sys.stdout.seek(0) - self.assertEquals(output.getvalue(), + self.assertEqual(output.getvalue(), "ERROR:root:just testing\nGot a [RuntimeError]\n") # Original logger output is empty self.assert_log_lines([]) @@ -2001,7 +2001,7 @@ for when, exp in (('S', 1), def test_compute_rollover(self, when=when, exp=exp): rh = logging.handlers.TimedRotatingFileHandler( self.fn, when=when, interval=1, backupCount=0) - self.assertEquals(exp, rh.computeRollover(0.0)) + self.assertEqual(exp, rh.computeRollover(0.0)) rh.close() setattr(TimedRotatingFileHandlerTest, "test_compute_rollover_%s" % when, test_compute_rollover) diff --git a/Lib/test/test_marshal.py b/Lib/test/test_marshal.py index a79a357..f9b1900 100644 --- a/Lib/test/test_marshal.py +++ b/Lib/test/test_marshal.py @@ -149,8 +149,8 @@ class BugsTestCase(unittest.TestCase): def test_version_argument(self): # Python 2.4.0 crashes for any call to marshal.dumps(x, y) - self.assertEquals(marshal.loads(marshal.dumps(5, 0)), 5) - self.assertEquals(marshal.loads(marshal.dumps(5, 1)), 5) + self.assertEqual(marshal.loads(marshal.dumps(5, 0)), 5) + self.assertEqual(marshal.loads(marshal.dumps(5, 1)), 5) def test_fuzz(self): # simple test that it's at least not *totally* trivial to diff --git a/Lib/test/test_math.py b/Lib/test/test_math.py index b7a516c..2a734fd 100644 --- a/Lib/test/test_math.py +++ b/Lib/test/test_math.py @@ -209,7 +209,7 @@ class MathTests(unittest.TestCase): self.ftest('acosh(2)', math.acosh(2), 1.3169578969248168) self.assertRaises(ValueError, math.acosh, 0) self.assertRaises(ValueError, math.acosh, -1) - self.assertEquals(math.acosh(INF), INF) + self.assertEqual(math.acosh(INF), INF) self.assertRaises(ValueError, math.acosh, NINF) self.assertTrue(math.isnan(math.acosh(NAN))) @@ -227,8 +227,8 @@ class MathTests(unittest.TestCase): self.ftest('asinh(0)', math.asinh(0), 0) self.ftest('asinh(1)', math.asinh(1), 0.88137358701954305) self.ftest('asinh(-1)', math.asinh(-1), -0.88137358701954305) - self.assertEquals(math.asinh(INF), INF) - self.assertEquals(math.asinh(NINF), NINF) + self.assertEqual(math.asinh(INF), INF) + self.assertEqual(math.asinh(NINF), NINF) self.assertTrue(math.isnan(math.asinh(NAN))) def testAtan(self): @@ -314,15 +314,15 @@ class MathTests(unittest.TestCase): def testCeil(self): self.assertRaises(TypeError, math.ceil) - self.assertEquals(int, type(math.ceil(0.5))) + self.assertEqual(int, type(math.ceil(0.5))) self.ftest('ceil(0.5)', math.ceil(0.5), 1) self.ftest('ceil(1.0)', math.ceil(1.0), 1) self.ftest('ceil(1.5)', math.ceil(1.5), 2) self.ftest('ceil(-0.5)', math.ceil(-0.5), 0) self.ftest('ceil(-1.0)', math.ceil(-1.0), -1) self.ftest('ceil(-1.5)', math.ceil(-1.5), -1) - #self.assertEquals(math.ceil(INF), INF) - #self.assertEquals(math.ceil(NINF), NINF) + #self.assertEqual(math.ceil(INF), INF) + #self.assertEqual(math.ceil(NINF), NINF) #self.assertTrue(math.isnan(math.ceil(NAN))) class TestCeil: @@ -348,19 +348,19 @@ class MathTests(unittest.TestCase): self.assertRaises(TypeError, math.copysign) # copysign should let us distinguish signs of zeros - self.assertEquals(math.copysign(1., 0.), 1.) - self.assertEquals(math.copysign(1., -0.), -1.) - self.assertEquals(math.copysign(INF, 0.), INF) - self.assertEquals(math.copysign(INF, -0.), NINF) - self.assertEquals(math.copysign(NINF, 0.), INF) - self.assertEquals(math.copysign(NINF, -0.), NINF) + self.assertEqual(math.copysign(1., 0.), 1.) + self.assertEqual(math.copysign(1., -0.), -1.) + self.assertEqual(math.copysign(INF, 0.), INF) + self.assertEqual(math.copysign(INF, -0.), NINF) + self.assertEqual(math.copysign(NINF, 0.), INF) + self.assertEqual(math.copysign(NINF, -0.), NINF) # and of infinities - self.assertEquals(math.copysign(1., INF), 1.) - self.assertEquals(math.copysign(1., NINF), -1.) - self.assertEquals(math.copysign(INF, INF), INF) - self.assertEquals(math.copysign(INF, NINF), NINF) - self.assertEquals(math.copysign(NINF, INF), INF) - self.assertEquals(math.copysign(NINF, NINF), NINF) + self.assertEqual(math.copysign(1., INF), 1.) + self.assertEqual(math.copysign(1., NINF), -1.) + self.assertEqual(math.copysign(INF, INF), INF) + self.assertEqual(math.copysign(INF, NINF), NINF) + self.assertEqual(math.copysign(NINF, INF), INF) + self.assertEqual(math.copysign(NINF, NINF), NINF) self.assertTrue(math.isnan(math.copysign(NAN, 1.))) self.assertTrue(math.isnan(math.copysign(NAN, INF))) self.assertTrue(math.isnan(math.copysign(NAN, NINF))) @@ -370,7 +370,7 @@ class MathTests(unittest.TestCase): # given platform. self.assertTrue(math.isinf(math.copysign(INF, NAN))) # similarly, copysign(2., NAN) could be 2. or -2. - self.assertEquals(abs(math.copysign(2., NAN)), 2.) + self.assertEqual(abs(math.copysign(2., NAN)), 2.) def testCos(self): self.assertRaises(TypeError, math.cos) @@ -390,8 +390,8 @@ class MathTests(unittest.TestCase): self.assertRaises(TypeError, math.cosh) self.ftest('cosh(0)', math.cosh(0), 1) self.ftest('cosh(2)-2*cosh(1)**2', math.cosh(2)-2*math.cosh(1)**2, -1) # Thanks to Lambert - self.assertEquals(math.cosh(INF), INF) - self.assertEquals(math.cosh(NINF), INF) + self.assertEqual(math.cosh(INF), INF) + self.assertEqual(math.cosh(NINF), INF) self.assertTrue(math.isnan(math.cosh(NAN))) def testDegrees(self): @@ -405,8 +405,8 @@ class MathTests(unittest.TestCase): self.ftest('exp(-1)', math.exp(-1), 1/math.e) self.ftest('exp(0)', math.exp(0), 1) self.ftest('exp(1)', math.exp(1), math.e) - self.assertEquals(math.exp(INF), INF) - self.assertEquals(math.exp(NINF), 0.) + self.assertEqual(math.exp(INF), INF) + self.assertEqual(math.exp(NINF), 0.) self.assertTrue(math.isnan(math.exp(NAN))) def testFabs(self): @@ -432,7 +432,7 @@ class MathTests(unittest.TestCase): def testFloor(self): self.assertRaises(TypeError, math.floor) - self.assertEquals(int, type(math.floor(0.5))) + self.assertEqual(int, type(math.floor(0.5))) self.ftest('floor(0.5)', math.floor(0.5), 0) self.ftest('floor(1.0)', math.floor(1.0), 1) self.ftest('floor(1.5)', math.floor(1.5), 1) @@ -443,8 +443,8 @@ class MathTests(unittest.TestCase): # This fails on some platforms - so check it here self.ftest('floor(1.23e167)', math.floor(1.23e167), 1.23e167) self.ftest('floor(-1.23e167)', math.floor(-1.23e167), -1.23e167) - #self.assertEquals(math.ceil(INF), INF) - #self.assertEquals(math.ceil(NINF), NINF) + #self.assertEqual(math.ceil(INF), INF) + #self.assertEqual(math.ceil(NINF), NINF) #self.assertTrue(math.isnan(math.floor(NAN))) class TestFloor: @@ -475,12 +475,12 @@ class MathTests(unittest.TestCase): self.assertRaises(ValueError, math.fmod, INF, 1.) self.assertRaises(ValueError, math.fmod, NINF, 1.) self.assertRaises(ValueError, math.fmod, INF, 0.) - self.assertEquals(math.fmod(3.0, INF), 3.0) - self.assertEquals(math.fmod(-3.0, INF), -3.0) - self.assertEquals(math.fmod(3.0, NINF), 3.0) - self.assertEquals(math.fmod(-3.0, NINF), -3.0) - self.assertEquals(math.fmod(0.0, 3.0), 0.0) - self.assertEquals(math.fmod(0.0, NINF), 0.0) + self.assertEqual(math.fmod(3.0, INF), 3.0) + self.assertEqual(math.fmod(-3.0, INF), -3.0) + self.assertEqual(math.fmod(3.0, NINF), 3.0) + self.assertEqual(math.fmod(-3.0, NINF), -3.0) + self.assertEqual(math.fmod(0.0, 3.0), 0.0) + self.assertEqual(math.fmod(0.0, NINF), 0.0) def testFrexp(self): self.assertRaises(TypeError, math.frexp) @@ -496,8 +496,8 @@ class MathTests(unittest.TestCase): testfrexp('frexp(1)', math.frexp(1), (0.5, 1)) testfrexp('frexp(2)', math.frexp(2), (0.5, 2)) - self.assertEquals(math.frexp(INF)[0], INF) - self.assertEquals(math.frexp(NINF)[0], NINF) + self.assertEqual(math.frexp(INF)[0], INF) + self.assertEqual(math.frexp(NINF)[0], NINF) self.assertTrue(math.isnan(math.frexp(NAN)[0])) @requires_IEEE_754 @@ -610,28 +610,28 @@ class MathTests(unittest.TestCase): self.ftest('ldexp(-1,1)', math.ldexp(-1,1), -2) self.assertRaises(OverflowError, math.ldexp, 1., 1000000) self.assertRaises(OverflowError, math.ldexp, -1., 1000000) - self.assertEquals(math.ldexp(1., -1000000), 0.) - self.assertEquals(math.ldexp(-1., -1000000), -0.) - self.assertEquals(math.ldexp(INF, 30), INF) - self.assertEquals(math.ldexp(NINF, -213), NINF) + self.assertEqual(math.ldexp(1., -1000000), 0.) + self.assertEqual(math.ldexp(-1., -1000000), -0.) + self.assertEqual(math.ldexp(INF, 30), INF) + self.assertEqual(math.ldexp(NINF, -213), NINF) self.assertTrue(math.isnan(math.ldexp(NAN, 0))) # large second argument for n in [10**5, 10**10, 10**20, 10**40]: - self.assertEquals(math.ldexp(INF, -n), INF) - self.assertEquals(math.ldexp(NINF, -n), NINF) - self.assertEquals(math.ldexp(1., -n), 0.) - self.assertEquals(math.ldexp(-1., -n), -0.) - self.assertEquals(math.ldexp(0., -n), 0.) - self.assertEquals(math.ldexp(-0., -n), -0.) + self.assertEqual(math.ldexp(INF, -n), INF) + self.assertEqual(math.ldexp(NINF, -n), NINF) + self.assertEqual(math.ldexp(1., -n), 0.) + self.assertEqual(math.ldexp(-1., -n), -0.) + self.assertEqual(math.ldexp(0., -n), 0.) + self.assertEqual(math.ldexp(-0., -n), -0.) self.assertTrue(math.isnan(math.ldexp(NAN, -n))) self.assertRaises(OverflowError, math.ldexp, 1., n) self.assertRaises(OverflowError, math.ldexp, -1., n) - self.assertEquals(math.ldexp(0., n), 0.) - self.assertEquals(math.ldexp(-0., n), -0.) - self.assertEquals(math.ldexp(INF, n), INF) - self.assertEquals(math.ldexp(NINF, n), NINF) + self.assertEqual(math.ldexp(0., n), 0.) + self.assertEqual(math.ldexp(-0., n), -0.) + self.assertEqual(math.ldexp(INF, n), INF) + self.assertEqual(math.ldexp(NINF, n), NINF) self.assertTrue(math.isnan(math.ldexp(NAN, n))) def testLog(self): @@ -647,13 +647,13 @@ class MathTests(unittest.TestCase): self.assertRaises(ValueError, math.log, -1.5) self.assertRaises(ValueError, math.log, -10**1000) self.assertRaises(ValueError, math.log, NINF) - self.assertEquals(math.log(INF), INF) + self.assertEqual(math.log(INF), INF) self.assertTrue(math.isnan(math.log(NAN))) def testLog1p(self): self.assertRaises(TypeError, math.log1p) n= 2**90 - self.assertAlmostEquals(math.log1p(n), math.log1p(float(n))) + self.assertAlmostEqual(math.log1p(n), math.log1p(float(n))) def testLog10(self): self.assertRaises(TypeError, math.log10) @@ -664,7 +664,7 @@ class MathTests(unittest.TestCase): self.assertRaises(ValueError, math.log10, -1.5) self.assertRaises(ValueError, math.log10, -10**1000) self.assertRaises(ValueError, math.log10, NINF) - self.assertEquals(math.log(INF), INF) + self.assertEqual(math.log(INF), INF) self.assertTrue(math.isnan(math.log10(NAN))) def testModf(self): @@ -679,8 +679,8 @@ class MathTests(unittest.TestCase): testmodf('modf(1.5)', math.modf(1.5), (0.5, 1.0)) testmodf('modf(-1.5)', math.modf(-1.5), (-0.5, -1.0)) - self.assertEquals(math.modf(INF), (0.0, INF)) - self.assertEquals(math.modf(NINF), (-0.0, NINF)) + self.assertEqual(math.modf(INF), (0.0, INF)) + self.assertEqual(math.modf(NINF), (-0.0, NINF)) modf_nan = math.modf(NAN) self.assertTrue(math.isnan(modf_nan[0])) @@ -859,8 +859,8 @@ class MathTests(unittest.TestCase): self.ftest('sinh(0)', math.sinh(0), 0) self.ftest('sinh(1)**2-cosh(1)**2', math.sinh(1)**2-math.cosh(1)**2, -1) self.ftest('sinh(1)+sinh(-1)', math.sinh(1)+math.sinh(-1), 0) - self.assertEquals(math.sinh(INF), INF) - self.assertEquals(math.sinh(NINF), NINF) + self.assertEqual(math.sinh(INF), INF) + self.assertEqual(math.sinh(NINF), NINF) self.assertTrue(math.isnan(math.sinh(NAN))) def testSqrt(self): @@ -868,7 +868,7 @@ class MathTests(unittest.TestCase): self.ftest('sqrt(0)', math.sqrt(0), 0) self.ftest('sqrt(1)', math.sqrt(1), 1) self.ftest('sqrt(4)', math.sqrt(4), 2) - self.assertEquals(math.sqrt(INF), INF) + self.assertEqual(math.sqrt(INF), INF) self.assertRaises(ValueError, math.sqrt, NINF) self.assertTrue(math.isnan(math.sqrt(NAN))) diff --git a/Lib/test/test_memoryio.py b/Lib/test/test_memoryio.py index 13d7e17..49ca44f 100644 --- a/Lib/test/test_memoryio.py +++ b/Lib/test/test_memoryio.py @@ -20,17 +20,17 @@ class MemorySeekTestMixin: buf = self.buftype("1234567890") bytesIo = self.ioclass(buf) - self.assertEquals(buf[:1], bytesIo.read(1)) - self.assertEquals(buf[1:5], bytesIo.read(4)) - self.assertEquals(buf[5:], bytesIo.read(900)) - self.assertEquals(self.EOF, bytesIo.read()) + self.assertEqual(buf[:1], bytesIo.read(1)) + self.assertEqual(buf[1:5], bytesIo.read(4)) + self.assertEqual(buf[5:], bytesIo.read(900)) + self.assertEqual(self.EOF, bytesIo.read()) def testReadNoArgs(self): buf = self.buftype("1234567890") bytesIo = self.ioclass(buf) - self.assertEquals(buf, bytesIo.read()) - self.assertEquals(self.EOF, bytesIo.read()) + self.assertEqual(buf, bytesIo.read()) + self.assertEqual(self.EOF, bytesIo.read()) def testSeek(self): buf = self.buftype("1234567890") @@ -38,21 +38,21 @@ class MemorySeekTestMixin: bytesIo.read(5) bytesIo.seek(0) - self.assertEquals(buf, bytesIo.read()) + self.assertEqual(buf, bytesIo.read()) bytesIo.seek(3) - self.assertEquals(buf[3:], bytesIo.read()) + self.assertEqual(buf[3:], bytesIo.read()) self.assertRaises(TypeError, bytesIo.seek, 0.0) def testTell(self): buf = self.buftype("1234567890") bytesIo = self.ioclass(buf) - self.assertEquals(0, bytesIo.tell()) + self.assertEqual(0, bytesIo.tell()) bytesIo.seek(5) - self.assertEquals(5, bytesIo.tell()) + self.assertEqual(5, bytesIo.tell()) bytesIo.seek(10000) - self.assertEquals(10000, bytesIo.tell()) + self.assertEqual(10000, bytesIo.tell()) class MemoryTestMixin: @@ -634,7 +634,7 @@ class CBytesIOTest(PyBytesIOTest): self.assertEqual(len(state), 3) bytearray(state[0]) # Check if state[0] supports the buffer interface. self.assertIsInstance(state[1], int) - self.assert_(isinstance(state[2], dict) or state[2] is None) + self.assertTrue(isinstance(state[2], dict) or state[2] is None) memio.close() self.assertRaises(ValueError, memio.__getstate__) @@ -680,7 +680,7 @@ class CStringIOTest(PyStringIOTest): self.assertIsInstance(state[0], str) self.assertIsInstance(state[1], str) self.assertIsInstance(state[2], int) - self.assert_(isinstance(state[3], dict) or state[3] is None) + self.assertTrue(isinstance(state[3], dict) or state[3] is None) memio.close() self.assertRaises(ValueError, memio.__getstate__) diff --git a/Lib/test/test_memoryview.py b/Lib/test/test_memoryview.py index d56d64f..7bccf8b 100644 --- a/Lib/test/test_memoryview.py +++ b/Lib/test/test_memoryview.py @@ -27,11 +27,11 @@ class AbstractMemoryTests: b = tp(self._source) oldrefcount = sys.getrefcount(b) m = self._view(b) - self.assertEquals(m[0], item(b"a")) + self.assertEqual(m[0], item(b"a")) self.assertIsInstance(m[0], bytes) - self.assertEquals(m[5], item(b"f")) - self.assertEquals(m[-1], item(b"f")) - self.assertEquals(m[-6], item(b"a")) + self.assertEqual(m[5], item(b"f")) + self.assertEqual(m[-1], item(b"f")) + self.assertEqual(m[-6], item(b"a")) # Bounds checking self.assertRaises(IndexError, lambda: m[6]) self.assertRaises(IndexError, lambda: m[-7]) @@ -42,7 +42,7 @@ class AbstractMemoryTests: self.assertRaises(TypeError, lambda: m[0.0]) self.assertRaises(TypeError, lambda: m["a"]) m = None - self.assertEquals(sys.getrefcount(b), oldrefcount) + self.assertEqual(sys.getrefcount(b), oldrefcount) def test_getitem(self): for tp in self._types: @@ -66,7 +66,7 @@ class AbstractMemoryTests: self.assertRaises(TypeError, setitem, 65) self.assertRaises(TypeError, setitem, memoryview(b"a")) m = None - self.assertEquals(sys.getrefcount(b), oldrefcount) + self.assertEqual(sys.getrefcount(b), oldrefcount) def test_setitem_writable(self): if not self.rw_type: @@ -109,7 +109,7 @@ class AbstractMemoryTests: self.assertRaises(ValueError, setitem, slice(0,2), b"a") m = None - self.assertEquals(sys.getrefcount(b), oldrefcount) + self.assertEqual(sys.getrefcount(b), oldrefcount) def test_delitem(self): for tp in self._types: @@ -127,14 +127,14 @@ class AbstractMemoryTests: # This calls self.getitem_type() on each separate byte of b"abcdef" expected = b"".join( self.getitem_type(bytes([c])) for c in b"abcdef") - self.assertEquals(b, expected) + self.assertEqual(b, expected) self.assertIsInstance(b, bytes) def test_tolist(self): for tp in self._types: m = self._view(tp(self._source)) l = m.tolist() - self.assertEquals(l, list(b"abcdef")) + self.assertEqual(l, list(b"abcdef")) def test_compare(self): # memoryviews can compare for equality with other objects @@ -168,26 +168,26 @@ class AbstractMemoryTests: def check_attributes_with_type(self, tp): m = self._view(tp(self._source)) - self.assertEquals(m.format, self.format) - self.assertEquals(m.itemsize, self.itemsize) - self.assertEquals(m.ndim, 1) - self.assertEquals(m.shape, (6,)) - self.assertEquals(len(m), 6) - self.assertEquals(m.strides, (self.itemsize,)) - self.assertEquals(m.suboffsets, None) + self.assertEqual(m.format, self.format) + self.assertEqual(m.itemsize, self.itemsize) + self.assertEqual(m.ndim, 1) + self.assertEqual(m.shape, (6,)) + self.assertEqual(len(m), 6) + self.assertEqual(m.strides, (self.itemsize,)) + self.assertEqual(m.suboffsets, None) return m def test_attributes_readonly(self): if not self.ro_type: return m = self.check_attributes_with_type(self.ro_type) - self.assertEquals(m.readonly, True) + self.assertEqual(m.readonly, True) def test_attributes_writable(self): if not self.rw_type: return m = self.check_attributes_with_type(self.rw_type) - self.assertEquals(m.readonly, False) + self.assertEqual(m.readonly, False) def test_getbuffer(self): # Test PyObject_GetBuffer() on a memoryview object. @@ -198,9 +198,9 @@ class AbstractMemoryTests: oldviewrefcount = sys.getrefcount(m) s = str(m, "utf-8") self._check_contents(tp, b, s.encode("utf-8")) - self.assertEquals(sys.getrefcount(m), oldviewrefcount) + self.assertEqual(sys.getrefcount(m), oldviewrefcount) m = None - self.assertEquals(sys.getrefcount(b), oldrefcount) + self.assertEqual(sys.getrefcount(b), oldrefcount) def test_gc(self): for tp in self._types: @@ -307,7 +307,7 @@ class BaseMemoryviewTests: return memoryview(obj) def _check_contents(self, tp, obj, contents): - self.assertEquals(obj, tp(contents)) + self.assertEqual(obj, tp(contents)) class BaseMemorySliceTests: source_bytes = b"XabcdefY" @@ -317,14 +317,14 @@ class BaseMemorySliceTests: return m[1:7] def _check_contents(self, tp, obj, contents): - self.assertEquals(obj[1:7], tp(contents)) + self.assertEqual(obj[1:7], tp(contents)) def test_refs(self): for tp in self._types: m = memoryview(tp(self._source)) oldrefcount = sys.getrefcount(m) m[1:2] - self.assertEquals(sys.getrefcount(m), oldrefcount) + self.assertEqual(sys.getrefcount(m), oldrefcount) class BaseMemorySliceSliceTests: source_bytes = b"XabcdefY" @@ -334,7 +334,7 @@ class BaseMemorySliceSliceTests: return m[:7][1:] def _check_contents(self, tp, obj, contents): - self.assertEquals(obj[1:7], tp(contents)) + self.assertEqual(obj[1:7], tp(contents)) # Concrete test classes @@ -361,7 +361,7 @@ class ArrayMemoryviewTest(unittest.TestCase, m = memoryview(a) new_a = array.array('i', range(9, -1, -1)) m[:] = new_a - self.assertEquals(a, new_a) + self.assertEqual(a, new_a) class BytesMemorySliceTest(unittest.TestCase, diff --git a/Lib/test/test_minidom.py b/Lib/test/test_minidom.py index 7b845ef..4c2b34a 100644 --- a/Lib/test/test_minidom.py +++ b/Lib/test/test_minidom.py @@ -755,7 +755,7 @@ class MinidomTest(unittest.TestCase): def check_clone_pi(self, deep, testName): doc = parseString("<?target data?><doc/>") pi = doc.firstChild - self.assertEquals(pi.nodeType, Node.PROCESSING_INSTRUCTION_NODE) + self.assertEqual(pi.nodeType, Node.PROCESSING_INSTRUCTION_NODE) clone = pi.cloneNode(deep) self.confirm(clone.target == pi.target and clone.data == pi.data) @@ -955,7 +955,7 @@ class MinidomTest(unittest.TestCase): def testBug0777884(self): doc = parseString("<o>text</o>") text = doc.documentElement.childNodes[0] - self.assertEquals(text.nodeType, Node.TEXT_NODE) + self.assertEqual(text.nodeType, Node.TEXT_NODE) # Should run quietly, doing nothing. text.normalize() doc.unlink() @@ -1233,7 +1233,7 @@ class MinidomTest(unittest.TestCase): doc = parseString("<doc>a</doc>") elem = doc.documentElement text = elem.childNodes[0] - self.assertEquals(text.nodeType, Node.TEXT_NODE) + self.assertEqual(text.nodeType, Node.TEXT_NODE) self.checkWholeText(text, "a") elem.appendChild(doc.createTextNode("b")) diff --git a/Lib/test/test_mmap.py b/Lib/test/test_mmap.py index f78fed9..abfde01 100644 --- a/Lib/test/test_mmap.py +++ b/Lib/test/test_mmap.py @@ -413,7 +413,7 @@ class MmapTests(unittest.TestCase): data = bytes(reversed(data)) L[start:stop:step] = data m[start:stop:step] = data - self.assertEquals(m[:], bytes(L)) + self.assertEqual(m[:], bytes(L)) def make_mmap_file (self, f, halfsize): # Write 2 pages worth of data to the file @@ -510,27 +510,27 @@ class MmapTests(unittest.TestCase): f.close() # Test write_byte() for i in range(len(data)): - self.assertEquals(m.tell(), i) + self.assertEqual(m.tell(), i) m.write_byte(data[i]) - self.assertEquals(m.tell(), i+1) + self.assertEqual(m.tell(), i+1) self.assertRaises(ValueError, m.write_byte, b"x"[0]) - self.assertEquals(m[:], data) + self.assertEqual(m[:], data) # Test read_byte() m.seek(0) for i in range(len(data)): - self.assertEquals(m.tell(), i) - self.assertEquals(m.read_byte(), data[i]) - self.assertEquals(m.tell(), i+1) + self.assertEqual(m.tell(), i) + self.assertEqual(m.read_byte(), data[i]) + self.assertEqual(m.tell(), i+1) self.assertRaises(ValueError, m.read_byte) # Test read() m.seek(3) - self.assertEquals(m.read(3), b"345") - self.assertEquals(m.tell(), 6) + self.assertEqual(m.read(3), b"345") + self.assertEqual(m.tell(), 6) # Test write() m.seek(3) m.write(b"bar") - self.assertEquals(m.tell(), 6) - self.assertEquals(m[:], b"012bar6789") + self.assertEqual(m.tell(), 6) + self.assertEqual(m[:], b"012bar6789") m.seek(8) self.assertRaises(ValueError, m.write, b"bar") @@ -538,9 +538,9 @@ class MmapTests(unittest.TestCase): for b in (129, 200, 255): # > 128 m = mmap.mmap(-1, 1) m.write_byte(b) - self.assertEquals(m[0], b) + self.assertEqual(m[0], b) m.seek(0) - self.assertEquals(m.read_byte(), b) + self.assertEqual(m.read_byte(), b) m.close() if os.name == 'nt': @@ -554,8 +554,8 @@ class MmapTests(unittest.TestCase): m1[:] = data1 m2 = mmap.mmap(-1, len(data2), tagname="foo") m2[:] = data2 - self.assertEquals(m1[:], data2) - self.assertEquals(m2[:], data2) + self.assertEqual(m1[:], data2) + self.assertEqual(m2[:], data2) m2.close() m1.close() @@ -564,8 +564,8 @@ class MmapTests(unittest.TestCase): m1[:] = data1 m2 = mmap.mmap(-1, len(data2), tagname="boo") m2[:] = data2 - self.assertEquals(m1[:], data1) - self.assertEquals(m2[:], data2) + self.assertEqual(m1[:], data1) + self.assertEqual(m2[:], data2) m2.close() m1.close() diff --git a/Lib/test/test_multiprocessing.py b/Lib/test/test_multiprocessing.py index bb0f06a..ba565c4 100644 --- a/Lib/test/test_multiprocessing.py +++ b/Lib/test/test_multiprocessing.py @@ -186,30 +186,30 @@ class _TestProcess(BaseTestCase): current = self.current_process() if self.TYPE != 'threads': - self.assertEquals(p.authkey, current.authkey) - self.assertEquals(p.is_alive(), False) - self.assertEquals(p.daemon, True) + self.assertEqual(p.authkey, current.authkey) + self.assertEqual(p.is_alive(), False) + self.assertEqual(p.daemon, True) self.assertNotIn(p, self.active_children()) self.assertTrue(type(self.active_children()) is list) self.assertEqual(p.exitcode, None) p.start() - self.assertEquals(p.exitcode, None) - self.assertEquals(p.is_alive(), True) + self.assertEqual(p.exitcode, None) + self.assertEqual(p.is_alive(), True) self.assertIn(p, self.active_children()) - self.assertEquals(q.get(), args[1:]) - self.assertEquals(q.get(), kwargs) - self.assertEquals(q.get(), p.name) + self.assertEqual(q.get(), args[1:]) + self.assertEqual(q.get(), kwargs) + self.assertEqual(q.get(), p.name) if self.TYPE != 'threads': - self.assertEquals(q.get(), current.authkey) - self.assertEquals(q.get(), p.pid) + self.assertEqual(q.get(), current.authkey) + self.assertEqual(q.get(), p.pid) p.join() - self.assertEquals(p.exitcode, 0) - self.assertEquals(p.is_alive(), False) + self.assertEqual(p.exitcode, 0) + self.assertEqual(p.is_alive(), False) self.assertNotIn(p, self.active_children()) @classmethod diff --git a/Lib/test/test_opcodes.py b/Lib/test/test_opcodes.py index bd123b2..f510bac 100644 --- a/Lib/test/test_opcodes.py +++ b/Lib/test/test_opcodes.py @@ -68,35 +68,35 @@ class OpcodeTest(unittest.TestCase): f = eval('lambda: None') g = eval('lambda: None') - self.assertNotEquals(f, g) + self.assertNotEqual(f, g) f = eval('lambda a: a') g = eval('lambda a: a') - self.assertNotEquals(f, g) + self.assertNotEqual(f, g) f = eval('lambda a=1: a') g = eval('lambda a=1: a') - self.assertNotEquals(f, g) + self.assertNotEqual(f, g) f = eval('lambda: 0') g = eval('lambda: 1') - self.assertNotEquals(f, g) + self.assertNotEqual(f, g) f = eval('lambda: None') g = eval('lambda a: None') - self.assertNotEquals(f, g) + self.assertNotEqual(f, g) f = eval('lambda a: None') g = eval('lambda b: None') - self.assertNotEquals(f, g) + self.assertNotEqual(f, g) f = eval('lambda a: None') g = eval('lambda a=None: None') - self.assertNotEquals(f, g) + self.assertNotEqual(f, g) f = eval('lambda a=0: None') g = eval('lambda a=1: None') - self.assertNotEquals(f, g) + self.assertNotEqual(f, g) def test_modulo_of_string_subclasses(self): class MyString(str): diff --git a/Lib/test/test_operator.py b/Lib/test/test_operator.py index f291e52..fa608b9 100644 --- a/Lib/test/test_operator.py +++ b/Lib/test/test_operator.py @@ -360,12 +360,12 @@ class OperatorTestCase(unittest.TestCase): f = operator.methodcaller('foo') self.assertRaises(IndexError, f, a) f = operator.methodcaller('foo', 1, 2) - self.assertEquals(f(a), 3) + self.assertEqual(f(a), 3) f = operator.methodcaller('bar') - self.assertEquals(f(a), 42) + self.assertEqual(f(a), 42) self.assertRaises(TypeError, f, a, a) f = operator.methodcaller('bar', f=5) - self.assertEquals(f(a), 5) + self.assertEqual(f(a), 5) def test_inplace(self): class C(object): diff --git a/Lib/test/test_optparse.py b/Lib/test/test_optparse.py index 2dc28ed..7b95612 100644 --- a/Lib/test/test_optparse.py +++ b/Lib/test/test_optparse.py @@ -423,13 +423,13 @@ class TestTypeAliases(BaseTest): def test_str_aliases_string(self): self.parser.add_option("-s", type="str") - self.assertEquals(self.parser.get_option("-s").type, "string") + self.assertEqual(self.parser.get_option("-s").type, "string") def test_type_object(self): self.parser.add_option("-s", type=str) - self.assertEquals(self.parser.get_option("-s").type, "string") + self.assertEqual(self.parser.get_option("-s").type, "string") self.parser.add_option("-x", type=int) - self.assertEquals(self.parser.get_option("-x").type, "int") + self.assertEqual(self.parser.get_option("-x").type, "int") # Custom type for testing processing of default values. diff --git a/Lib/test/test_os.py b/Lib/test/test_os.py index c7cf24b..129367e 100644 --- a/Lib/test/test_os.py +++ b/Lib/test/test_os.py @@ -229,8 +229,8 @@ class StatAttributeTests(unittest.TestCase): result = os.stat(fname) # Make sure direct access works - self.assertEquals(result[stat.ST_SIZE], 3) - self.assertEquals(result.st_size, 3) + self.assertEqual(result[stat.ST_SIZE], 3) + self.assertEqual(result.st_size, 3) # Make sure all the attributes are there members = dir(result) @@ -241,7 +241,7 @@ class StatAttributeTests(unittest.TestCase): def trunc(x): return int(x) else: def trunc(x): return x - self.assertEquals(trunc(getattr(result, attr)), + self.assertEqual(trunc(getattr(result, attr)), result[getattr(stat, name)]) self.assertIn(attr, members) @@ -305,13 +305,13 @@ class StatAttributeTests(unittest.TestCase): return # Make sure direct access works - self.assertEquals(result.f_bfree, result[3]) + self.assertEqual(result.f_bfree, result[3]) # Make sure all the attributes are there. members = ('bsize', 'frsize', 'blocks', 'bfree', 'bavail', 'files', 'ffree', 'favail', 'flag', 'namemax') for value, member in enumerate(members): - self.assertEquals(getattr(result, 'f_' + member), result[value]) + self.assertEqual(getattr(result, 'f_' + member), result[value]) # Make sure that assignment really fails try: @@ -346,7 +346,7 @@ class StatAttributeTests(unittest.TestCase): # time stamps in stat, but not in utime. os.utime(support.TESTFN, (st.st_atime, int(st.st_mtime-delta))) st2 = os.stat(support.TESTFN) - self.assertEquals(st2.st_mtime, int(st.st_mtime-delta)) + self.assertEqual(st2.st_mtime, int(st.st_mtime-delta)) # Restrict test to Win32, since there is no guarantee other # systems support centiseconds @@ -363,7 +363,7 @@ class StatAttributeTests(unittest.TestCase): def test_1565150(self): t1 = 1159195039.25 os.utime(self.fname, (t1, t1)) - self.assertEquals(os.stat(self.fname).st_mtime, t1) + self.assertEqual(os.stat(self.fname).st_mtime, t1) def test_1686475(self): # Verify that an open file can be stat'ed @@ -408,24 +408,24 @@ class EnvironTests(mapping_tests.BasicTestMappingProtocol): os.environ.update(HELLO="World") with os.popen("/bin/sh -c 'echo $HELLO'") as popen: value = popen.read().strip() - self.assertEquals(value, "World") + self.assertEqual(value, "World") def test_os_popen_iter(self): if os.path.exists("/bin/sh"): with os.popen( "/bin/sh -c 'echo \"line1\nline2\nline3\"'") as popen: it = iter(popen) - self.assertEquals(next(it), "line1\n") - self.assertEquals(next(it), "line2\n") - self.assertEquals(next(it), "line3\n") + self.assertEqual(next(it), "line1\n") + self.assertEqual(next(it), "line2\n") + self.assertEqual(next(it), "line3\n") self.assertRaises(StopIteration, next, it) # Verify environ keys and values from the OS are of the # correct str type. def test_keyvalue_types(self): for key, val in os.environ.items(): - self.assertEquals(type(key), str) - self.assertEquals(type(val), str) + self.assertEqual(type(key), str) + self.assertEqual(type(val), str) def test_items(self): for key, value in self._reference().items(): @@ -493,15 +493,15 @@ class EnvironTests(mapping_tests.BasicTestMappingProtocol): sys.getfilesystemencoding(),) self.skipTest(msg) os.environ['unicode'] = value - self.assertEquals(os.environ['unicode'], value) - self.assertEquals(os.environb[b'unicode'], value_bytes) + self.assertEqual(os.environ['unicode'], value) + self.assertEqual(os.environb[b'unicode'], value_bytes) # os.environb -> os.environ value = b'\xff' os.environb[b'bytes'] = value - self.assertEquals(os.environb[b'bytes'], value) + self.assertEqual(os.environb[b'bytes'], value) value_str = value.decode(sys.getfilesystemencoding(), 'surrogateescape') - self.assertEquals(os.environ['bytes'], value_str) + self.assertEqual(os.environ['bytes'], value_str) class WalkTests(unittest.TestCase): """Tests for os.walk().""" @@ -958,7 +958,7 @@ if sys.platform != 'win32': def test_listdir(self): expected = self.unicodefn found = set(os.listdir(self.dir)) - self.assertEquals(found, expected) + self.assertEqual(found, expected) def test_open(self): for fn in self.unicodefn: @@ -1168,8 +1168,8 @@ class Win32SymlinkTests(unittest.TestCase): class FSEncodingTests(unittest.TestCase): def test_nop(self): - self.assertEquals(os.fsencode(b'abc\xff'), b'abc\xff') - self.assertEquals(os.fsdecode('abc\u0141'), 'abc\u0141') + self.assertEqual(os.fsencode(b'abc\xff'), b'abc\xff') + self.assertEqual(os.fsdecode('abc\u0141'), 'abc\u0141') def test_identity(self): # assert fsdecode(fsencode(x)) == x @@ -1178,7 +1178,7 @@ class FSEncodingTests(unittest.TestCase): bytesfn = os.fsencode(fn) except UnicodeEncodeError: continue - self.assertEquals(os.fsdecode(bytesfn), fn) + self.assertEqual(os.fsdecode(bytesfn), fn) class PidTests(unittest.TestCase): diff --git a/Lib/test/test_parser.py b/Lib/test/test_parser.py index 7afd08e..020acd5 100644 --- a/Lib/test/test_parser.py +++ b/Lib/test/test_parser.py @@ -20,8 +20,8 @@ class RoundtripLegalSyntaxTestCase(unittest.TestCase): except parser.ParserError as why: self.fail("could not roundtrip %r: %s" % (s, why)) - self.assertEquals(t, st2.totuple(), - "could not re-generate syntax tree") + self.assertEqual(t, st2.totuple(), + "could not re-generate syntax tree") def check_expr(self, s): self.roundtrip(parser.expr, s) @@ -498,14 +498,14 @@ class CompileTestCase(unittest.TestCase): def test_compile_expr(self): st = parser.expr('2 + 3') code = parser.compilest(st) - self.assertEquals(eval(code), 5) + self.assertEqual(eval(code), 5) def test_compile_suite(self): st = parser.suite('x = 2; y = x + 3') code = parser.compilest(st) globs = {} exec(code, globs) - self.assertEquals(globs['y'], 5) + self.assertEqual(globs['y'], 5) def test_compile_error(self): st = parser.suite('1 = 3 + 4') @@ -560,36 +560,36 @@ class STObjectTestCase(unittest.TestCase): st3_copy = parser.expr('list(x**3 for x in range(20))') # exercise fast path for object identity - self.assertEquals(st1 == st1, True) - self.assertEquals(st2 == st2, True) - self.assertEquals(st3 == st3, True) + self.assertEqual(st1 == st1, True) + self.assertEqual(st2 == st2, True) + self.assertEqual(st3 == st3, True) # slow path equality self.assertEqual(st1, st1_copy) self.assertEqual(st2, st2_copy) self.assertEqual(st3, st3_copy) - self.assertEquals(st1 == st2, False) - self.assertEquals(st1 == st3, False) - self.assertEquals(st2 == st3, False) - self.assertEquals(st1 != st1, False) - self.assertEquals(st2 != st2, False) - self.assertEquals(st3 != st3, False) - self.assertEquals(st1 != st1_copy, False) - self.assertEquals(st2 != st2_copy, False) - self.assertEquals(st3 != st3_copy, False) - self.assertEquals(st2 != st1, True) - self.assertEquals(st1 != st3, True) - self.assertEquals(st3 != st2, True) + self.assertEqual(st1 == st2, False) + self.assertEqual(st1 == st3, False) + self.assertEqual(st2 == st3, False) + self.assertEqual(st1 != st1, False) + self.assertEqual(st2 != st2, False) + self.assertEqual(st3 != st3, False) + self.assertEqual(st1 != st1_copy, False) + self.assertEqual(st2 != st2_copy, False) + self.assertEqual(st3 != st3_copy, False) + self.assertEqual(st2 != st1, True) + self.assertEqual(st1 != st3, True) + self.assertEqual(st3 != st2, True) # we don't particularly care what the ordering is; just that # it's usable and self-consistent - self.assertEquals(st1 < st2, not (st2 <= st1)) - self.assertEquals(st1 < st3, not (st3 <= st1)) - self.assertEquals(st2 < st3, not (st3 <= st2)) - self.assertEquals(st1 < st2, st2 > st1) - self.assertEquals(st1 < st3, st3 > st1) - self.assertEquals(st2 < st3, st3 > st2) - self.assertEquals(st1 <= st2, st2 >= st1) - self.assertEquals(st3 <= st1, st1 >= st3) - self.assertEquals(st2 <= st3, st3 >= st2) + self.assertEqual(st1 < st2, not (st2 <= st1)) + self.assertEqual(st1 < st3, not (st3 <= st1)) + self.assertEqual(st2 < st3, not (st3 <= st2)) + self.assertEqual(st1 < st2, st2 > st1) + self.assertEqual(st1 < st3, st3 > st1) + self.assertEqual(st2 < st3, st3 > st2) + self.assertEqual(st1 <= st2, st2 >= st1) + self.assertEqual(st3 <= st1, st1 >= st3) + self.assertEqual(st2 <= st3, st3 >= st2) # transitivity bottom = min(st1, st2, st3) top = max(st1, st2, st3) @@ -604,8 +604,8 @@ class STObjectTestCase(unittest.TestCase): self.assertTrue(mid <= mid) self.assertTrue(top <= top) # interaction with other types - self.assertEquals(st1 == 1588.602459, False) - self.assertEquals('spanish armada' != st2, True) + self.assertEqual(st1 == 1588.602459, False) + self.assertEqual('spanish armada' != st2, True) self.assertRaises(TypeError, operator.ge, st3, None) self.assertRaises(TypeError, operator.le, False, st1) self.assertRaises(TypeError, operator.lt, st1, 1815) diff --git a/Lib/test/test_pep247.py b/Lib/test/test_pep247.py index da8f816..7f10472 100644 --- a/Lib/test/test_pep247.py +++ b/Lib/test/test_pep247.py @@ -30,23 +30,23 @@ class Pep247Test(unittest.TestCase): obj3 = cls() obj3.update(b'string') h2 = obj3.digest() - self.assertEquals(h1, h2) + self.assertEqual(h1, h2) self.assertTrue(hasattr(obj1, 'digest_size')) if digest_size is not None: - self.assertEquals(obj1.digest_size, digest_size) + self.assertEqual(obj1.digest_size, digest_size) - self.assertEquals(obj1.digest_size, len(h1)) + self.assertEqual(obj1.digest_size, len(h1)) obj1.update(b'string') obj_copy = obj1.copy() - self.assertEquals(obj1.digest(), obj_copy.digest()) - self.assertEquals(obj1.hexdigest(), obj_copy.hexdigest()) + self.assertEqual(obj1.digest(), obj_copy.digest()) + self.assertEqual(obj1.hexdigest(), obj_copy.hexdigest()) digest, hexdigest = obj1.digest(), obj1.hexdigest() hd2 = "" for byte in digest: hd2 += '%02x' % byte - self.assertEquals(hd2, hexdigest) + self.assertEqual(hd2, hexdigest) def test_md5(self): self.check_object(md5, None, None) diff --git a/Lib/test/test_pep263.py b/Lib/test/test_pep263.py index e136a9c..598d980 100644 --- a/Lib/test/test_pep263.py +++ b/Lib/test/test_pep263.py @@ -26,7 +26,7 @@ class PEP263Test(unittest.TestCase): try: compile(b"# coding: cp932\nprint '\x94\x4e'", "dummy", "exec") except SyntaxError as v: - self.assertEquals(v.text, "print '\u5e74'\n") + self.assertEqual(v.text, "print '\u5e74'\n") else: self.fail() @@ -34,7 +34,7 @@ class PEP263Test(unittest.TestCase): c = compile("# coding=latin-1\n\u00c6 = '\u00c6'", "dummy", "exec") d = {} exec(c, d) - self.assertEquals(d['\xc6'], '\xc6') + self.assertEqual(d['\xc6'], '\xc6') def test_issue3297(self): c = compile("a, b = '\U0001010F', '\\U0001010F'", "dummy", "exec") diff --git a/Lib/test/test_pep3131.py b/Lib/test/test_pep3131.py index fba1297..9d5f217 100644 --- a/Lib/test/test_pep3131.py +++ b/Lib/test/test_pep3131.py @@ -8,15 +8,15 @@ class PEP3131Test(unittest.TestCase): ä = 1 µ = 2 # this is a compatibility character 蟒 = 3 - self.assertEquals(getattr(T, "\xe4"), 1) - self.assertEquals(getattr(T, "\u03bc"), 2) - self.assertEquals(getattr(T, '\u87d2'), 3) + self.assertEqual(getattr(T, "\xe4"), 1) + self.assertEqual(getattr(T, "\u03bc"), 2) + self.assertEqual(getattr(T, '\u87d2'), 3) def test_invalid(self): try: from test import badsyntax_3131 except SyntaxError as s: - self.assertEquals(str(s), + self.assertEqual(str(s), "invalid character in identifier (badsyntax_3131.py, line 2)") else: self.fail("expected exception didn't occur") diff --git a/Lib/test/test_platform.py b/Lib/test/test_platform.py index 04f1a6a..7dd7eef 100644 --- a/Lib/test/test_platform.py +++ b/Lib/test/test_platform.py @@ -182,17 +182,17 @@ class PlatformTest(unittest.TestCase): # On Snow Leopard, sw_vers reports 10.6.0 as 10.6 if len_diff > 0: expect_list.extend(['0'] * len_diff) - self.assertEquals(result_list, expect_list) + self.assertEqual(result_list, expect_list) # res[1] claims to contain # (version, dev_stage, non_release_version) # That information is no longer available - self.assertEquals(res[1], ('', '', '')) + self.assertEqual(res[1], ('', '', '')) if sys.byteorder == 'little': - self.assertEquals(res[2], 'i386') + self.assertEqual(res[2], 'i386') else: - self.assertEquals(res[2], 'PowerPC') + self.assertEqual(res[2], 'PowerPC') @unittest.skipUnless(sys.platform == 'darwin', "OSX only test") @@ -210,8 +210,8 @@ class PlatformTest(unittest.TestCase): else: # parent cpid, sts = os.waitpid(pid, 0) - self.assertEquals(cpid, pid) - self.assertEquals(sts, 0) + self.assertEqual(cpid, pid) + self.assertEqual(sts, 0) def test_dist(self): res = platform.dist() diff --git a/Lib/test/test_posix.py b/Lib/test/test_posix.py index 902d16a..f9f9fce 100644 --- a/Lib/test/test_posix.py +++ b/Lib/test/test_posix.py @@ -105,7 +105,7 @@ class PosixTester(unittest.TestCase): try: posix.initgroups(name, 13) except OSError as e: - self.assertEquals(e.errno, errno.EPERM) + self.assertEqual(e.errno, errno.EPERM) else: self.fail("Expected OSError to be raised by initgroups") diff --git a/Lib/test/test_pow.py b/Lib/test/test_pow.py index 60bb533..20b1066 100644 --- a/Lib/test/test_pow.py +++ b/Lib/test/test_pow.py @@ -5,17 +5,17 @@ class PowTest(unittest.TestCase): def powtest(self, type): if type != float: for i in range(-1000, 1000): - self.assertEquals(pow(type(i), 0), 1) - self.assertEquals(pow(type(i), 1), type(i)) - self.assertEquals(pow(type(0), 1), type(0)) - self.assertEquals(pow(type(1), 1), type(1)) + self.assertEqual(pow(type(i), 0), 1) + self.assertEqual(pow(type(i), 1), type(i)) + self.assertEqual(pow(type(0), 1), type(0)) + self.assertEqual(pow(type(1), 1), type(1)) for i in range(-100, 100): - self.assertEquals(pow(type(i), 3), i*i*i) + self.assertEqual(pow(type(i), 3), i*i*i) pow2 = 1 for i in range(0, 31): - self.assertEquals(pow(2, i), pow2) + self.assertEqual(pow(2, i), pow2) if i != 30 : pow2 = pow2*2 for othertype in (int,): @@ -67,30 +67,30 @@ class PowTest(unittest.TestCase): def test_other(self): # Other tests-- not very systematic - self.assertEquals(pow(3,3) % 8, pow(3,3,8)) - self.assertEquals(pow(3,3) % -8, pow(3,3,-8)) - self.assertEquals(pow(3,2) % -2, pow(3,2,-2)) - self.assertEquals(pow(-3,3) % 8, pow(-3,3,8)) - self.assertEquals(pow(-3,3) % -8, pow(-3,3,-8)) - self.assertEquals(pow(5,2) % -8, pow(5,2,-8)) - - self.assertEquals(pow(3,3) % 8, pow(3,3,8)) - self.assertEquals(pow(3,3) % -8, pow(3,3,-8)) - self.assertEquals(pow(3,2) % -2, pow(3,2,-2)) - self.assertEquals(pow(-3,3) % 8, pow(-3,3,8)) - self.assertEquals(pow(-3,3) % -8, pow(-3,3,-8)) - self.assertEquals(pow(5,2) % -8, pow(5,2,-8)) + self.assertEqual(pow(3,3) % 8, pow(3,3,8)) + self.assertEqual(pow(3,3) % -8, pow(3,3,-8)) + self.assertEqual(pow(3,2) % -2, pow(3,2,-2)) + self.assertEqual(pow(-3,3) % 8, pow(-3,3,8)) + self.assertEqual(pow(-3,3) % -8, pow(-3,3,-8)) + self.assertEqual(pow(5,2) % -8, pow(5,2,-8)) + + self.assertEqual(pow(3,3) % 8, pow(3,3,8)) + self.assertEqual(pow(3,3) % -8, pow(3,3,-8)) + self.assertEqual(pow(3,2) % -2, pow(3,2,-2)) + self.assertEqual(pow(-3,3) % 8, pow(-3,3,8)) + self.assertEqual(pow(-3,3) % -8, pow(-3,3,-8)) + self.assertEqual(pow(5,2) % -8, pow(5,2,-8)) for i in range(-10, 11): for j in range(0, 6): for k in range(-7, 11): if j >= 0 and k != 0: - self.assertEquals( + self.assertEqual( pow(i,j) % k, pow(i,j,k) ) if j >= 0 and k != 0: - self.assertEquals( + self.assertEqual( pow(int(i),j) % k, pow(int(i),j,k) ) @@ -104,7 +104,7 @@ class PowTest(unittest.TestCase): def test_bug705231(self): # -1.0 raised to an integer should never blow up. It did if the # platform pow() was buggy, and Python didn't worm around it. - eq = self.assertEquals + eq = self.assertEqual a = -1.0 # The next two tests can still fail if the platform floor() # function doesn't treat all large inputs as integers diff --git a/Lib/test/test_pty.py b/Lib/test/test_pty.py index e74ecd5..92039e4 100644 --- a/Lib/test/test_pty.py +++ b/Lib/test/test_pty.py @@ -86,7 +86,7 @@ class PtyTest(unittest.TestCase): fcntl.fcntl(master_fd, fcntl.F_SETFL, orig_flags | os.O_NONBLOCK) try: s1 = os.read(master_fd, 1024) - self.assertEquals(b'', s1) + self.assertEqual(b'', s1) except OSError as e: if e.errno != errno.EAGAIN: raise @@ -96,14 +96,14 @@ class PtyTest(unittest.TestCase): debug("Writing to slave_fd") os.write(slave_fd, TEST_STRING_1) s1 = os.read(master_fd, 1024) - self.assertEquals(b'I wish to buy a fish license.\n', - normalize_output(s1)) + self.assertEqual(b'I wish to buy a fish license.\n', + normalize_output(s1)) debug("Writing chunked output") os.write(slave_fd, TEST_STRING_2[:5]) os.write(slave_fd, TEST_STRING_2[5:]) s2 = os.read(master_fd, 1024) - self.assertEquals(b'For my pet fish, Eric.\n', normalize_output(s2)) + self.assertEqual(b'For my pet fish, Eric.\n', normalize_output(s2)) os.close(slave_fd) os.close(master_fd) diff --git a/Lib/test/test_pyclbr.py b/Lib/test/test_pyclbr.py index d21f88f..3082b29 100644 --- a/Lib/test/test_pyclbr.py +++ b/Lib/test/test_pyclbr.py @@ -45,7 +45,7 @@ class PyclbrTest(TestCase): def assertEqualsOrIgnored(self, a, b, ignore): ''' succeed iff a == b or a in ignore or b in ignore ''' if a not in ignore and b not in ignore: - self.assertEquals(a, b) + self.assertEqual(a, b) def checkModule(self, moduleName, module=None, ignore=()): ''' succeed iff pyclbr.readmodule_ex(modulename) corresponds @@ -87,7 +87,7 @@ class PyclbrTest(TestCase): self.assertIsInstance(py_item, (FunctionType, BuiltinFunctionType)) if py_item.__module__ != moduleName: continue # skip functions that came from somewhere else - self.assertEquals(py_item.__module__, value.module) + self.assertEqual(py_item.__module__, value.module) else: self.assertIsInstance(py_item, type) if py_item.__module__ != moduleName: @@ -116,7 +116,7 @@ class PyclbrTest(TestCase): try: self.assertListEq(foundMethods, actualMethods, ignore) - self.assertEquals(py_item.__module__, value.module) + self.assertEqual(py_item.__module__, value.module) self.assertEqualsOrIgnored(py_item.__name__, value.name, ignore) diff --git a/Lib/test/test_pyexpat.py b/Lib/test/test_pyexpat.py index 49ac23d..5a193bb 100644 --- a/Lib/test/test_pyexpat.py +++ b/Lib/test/test_pyexpat.py @@ -23,12 +23,12 @@ class SetAttributeTest(unittest.TestCase): def test_ordered_attributes(self): for x, y in self.set_get_pairs: self.parser.ordered_attributes = x - self.assertEquals(self.parser.ordered_attributes, y) + self.assertEqual(self.parser.ordered_attributes, y) def test_specified_attributes(self): for x, y in self.set_get_pairs: self.parser.specified_attributes = x - self.assertEquals(self.parser.specified_attributes, y) + self.assertEqual(self.parser.specified_attributes, y) data = b'''\ @@ -190,7 +190,7 @@ class ParseTest(unittest.TestCase): "End element: 'root'", ] for operation, expected_operation in zip(operations, expected_operations): - self.assertEquals(operation, expected_operation) + self.assertEqual(operation, expected_operation) def test_unicode(self): # Try the parse again, this time producing Unicode output @@ -230,14 +230,14 @@ class NamespaceSeparatorTest(unittest.TestCase): expat.ParserCreate(namespace_separator=42) self.fail() except TypeError as e: - self.assertEquals(str(e), + self.assertEqual(str(e), 'ParserCreate() argument 2 must be str or None, not int') try: expat.ParserCreate(namespace_separator='too long') self.fail() except ValueError as e: - self.assertEquals(str(e), + self.assertEqual(str(e), 'namespace_separator must be at most one character, omitted, or None') def test_zero_length(self): @@ -263,7 +263,7 @@ class InterningTest(unittest.TestCase): p.EndElementHandler = collector p.Parse("<e> <e/> <e></e> </e>", 1) tag = L[0] - self.assertEquals(len(L), 6) + self.assertEqual(len(L), 6) for entry in L: # L should have the same string repeated over and over. self.assertTrue(tag is entry) @@ -285,7 +285,7 @@ class InterningTest(unittest.TestCase): out = ExternalOutputter(parser) parser.ExternalEntityRefHandler = out.ExternalEntityRefHandler parser.Parse(data, 1) - self.assertEquals(out.parser_result, 1) + self.assertEqual(out.parser_result, 1) class BufferTextTest(unittest.TestCase): @@ -296,7 +296,7 @@ class BufferTextTest(unittest.TestCase): self.parser.CharacterDataHandler = self.CharacterDataHandler def check(self, expected, label): - self.assertEquals(self.stuff, expected, + self.assertEqual(self.stuff, expected, "%s\nstuff = %r\nexpected = %r" % (label, self.stuff, map(str, expected))) @@ -329,47 +329,47 @@ class BufferTextTest(unittest.TestCase): # Make sure buffering is turned on self.assertTrue(self.parser.buffer_text) self.parser.Parse("<a>1<b/>2<c/>3</a>", 1) - self.assertEquals(self.stuff, ['123'], - "buffered text not properly collapsed") + self.assertEqual(self.stuff, ['123'], + "buffered text not properly collapsed") def test1(self): # XXX This test exposes more detail of Expat's text chunking than we # XXX like, but it tests what we need to concisely. self.setHandlers(["StartElementHandler"]) self.parser.Parse("<a>1<b buffer-text='no'/>2\n3<c buffer-text='yes'/>4\n5</a>", 1) - self.assertEquals(self.stuff, - ["<a>", "1", "<b>", "2", "\n", "3", "<c>", "4\n5"], - "buffering control not reacting as expected") + self.assertEqual(self.stuff, + ["<a>", "1", "<b>", "2", "\n", "3", "<c>", "4\n5"], + "buffering control not reacting as expected") def test2(self): self.parser.Parse("<a>1<b/><2><c/> \n 3</a>", 1) - self.assertEquals(self.stuff, ["1<2> \n 3"], - "buffered text not properly collapsed") + self.assertEqual(self.stuff, ["1<2> \n 3"], + "buffered text not properly collapsed") def test3(self): self.setHandlers(["StartElementHandler"]) self.parser.Parse("<a>1<b/>2<c/>3</a>", 1) - self.assertEquals(self.stuff, ["<a>", "1", "<b>", "2", "<c>", "3"], - "buffered text not properly split") + self.assertEqual(self.stuff, ["<a>", "1", "<b>", "2", "<c>", "3"], + "buffered text not properly split") def test4(self): self.setHandlers(["StartElementHandler", "EndElementHandler"]) self.parser.CharacterDataHandler = None self.parser.Parse("<a>1<b/>2<c/>3</a>", 1) - self.assertEquals(self.stuff, - ["<a>", "<b>", "</b>", "<c>", "</c>", "</a>"]) + self.assertEqual(self.stuff, + ["<a>", "<b>", "</b>", "<c>", "</c>", "</a>"]) def test5(self): self.setHandlers(["StartElementHandler", "EndElementHandler"]) self.parser.Parse("<a>1<b></b>2<c/>3</a>", 1) - self.assertEquals(self.stuff, + self.assertEqual(self.stuff, ["<a>", "1", "<b>", "</b>", "2", "<c>", "</c>", "3", "</a>"]) def test6(self): self.setHandlers(["CommentHandler", "EndElementHandler", "StartElementHandler"]) self.parser.Parse("<a>1<b/>2<c></c>345</a> ", 1) - self.assertEquals(self.stuff, + self.assertEqual(self.stuff, ["<a>", "1", "<b>", "</b>", "2", "<c>", "</c>", "345", "</a>"], "buffered text not properly split") @@ -377,10 +377,10 @@ class BufferTextTest(unittest.TestCase): self.setHandlers(["CommentHandler", "EndElementHandler", "StartElementHandler"]) self.parser.Parse("<a>1<b/>2<c></c>3<!--abc-->4<!--def-->5</a> ", 1) - self.assertEquals(self.stuff, - ["<a>", "1", "<b>", "</b>", "2", "<c>", "</c>", "3", - "<!--abc-->", "4", "<!--def-->", "5", "</a>"], - "buffered text not properly split") + self.assertEqual(self.stuff, + ["<a>", "1", "<b>", "</b>", "2", "<c>", "</c>", "3", + "<!--abc-->", "4", "<!--def-->", "5", "</a>"], + "buffered text not properly split") # Test handling of exception from callback: @@ -395,9 +395,9 @@ class HandlerExceptionTest(unittest.TestCase): parser.Parse("<a><b><c/></b></a>", 1) self.fail() except RuntimeError as e: - self.assertEquals(e.args[0], 'a', - "Expected RuntimeError for element 'a', but" + \ - " found %r" % e.args[0]) + self.assertEqual(e.args[0], 'a', + "Expected RuntimeError for element 'a', but" + \ + " found %r" % e.args[0]) # Test Current* members: @@ -416,7 +416,7 @@ class PositionTest(unittest.TestCase): self.assertTrue(self.upto < len(self.expected_list), 'too many parser events') expected = self.expected_list[self.upto] - self.assertEquals(pos, expected, + self.assertEqual(pos, expected, 'Expected position %s, got position %s' %(pos, expected)) self.upto += 1 @@ -457,10 +457,10 @@ class ChardataBufferTest(unittest.TestCase): """ def test_1025_bytes(self): - self.assertEquals(self.small_buffer_test(1025), 2) + self.assertEqual(self.small_buffer_test(1025), 2) def test_1000_bytes(self): - self.assertEquals(self.small_buffer_test(1000), 1) + self.assertEqual(self.small_buffer_test(1000), 1) def test_wrong_size(self): parser = expat.ParserCreate() @@ -483,15 +483,15 @@ class ChardataBufferTest(unittest.TestCase): # once. self.n = 0 parser.Parse(xml1) - self.assertEquals(self.n, 1) + self.assertEqual(self.n, 1) # Reassign to buffer_size, but assign the same size. parser.buffer_size = parser.buffer_size - self.assertEquals(self.n, 1) + self.assertEqual(self.n, 1) # Try parsing rest of the document parser.Parse(xml2) - self.assertEquals(self.n, 2) + self.assertEqual(self.n, 2) def test_disabling_buffer(self): @@ -502,27 +502,27 @@ class ChardataBufferTest(unittest.TestCase): parser.CharacterDataHandler = self.counting_handler parser.buffer_text = 1 parser.buffer_size = 1024 - self.assertEquals(parser.buffer_size, 1024) + self.assertEqual(parser.buffer_size, 1024) # Parse one chunk of XML self.n = 0 parser.Parse(xml1, 0) - self.assertEquals(parser.buffer_size, 1024) - self.assertEquals(self.n, 1) + self.assertEqual(parser.buffer_size, 1024) + self.assertEqual(self.n, 1) # Turn off buffering and parse the next chunk. parser.buffer_text = 0 self.assertFalse(parser.buffer_text) - self.assertEquals(parser.buffer_size, 1024) + self.assertEqual(parser.buffer_size, 1024) for i in range(10): parser.Parse(xml2, 0) - self.assertEquals(self.n, 11) + self.assertEqual(self.n, 11) parser.buffer_text = 1 self.assertTrue(parser.buffer_text) - self.assertEquals(parser.buffer_size, 1024) + self.assertEqual(parser.buffer_size, 1024) parser.Parse(xml3, 1) - self.assertEquals(self.n, 12) + self.assertEqual(self.n, 12) @@ -550,14 +550,14 @@ class ChardataBufferTest(unittest.TestCase): parser.CharacterDataHandler = self.counting_handler parser.buffer_text = 1 parser.buffer_size = 1024 - self.assertEquals(parser.buffer_size, 1024) + self.assertEqual(parser.buffer_size, 1024) self.n = 0 parser.Parse(xml1, 0) parser.buffer_size *= 2 - self.assertEquals(parser.buffer_size, 2048) + self.assertEqual(parser.buffer_size, 2048) parser.Parse(xml2, 1) - self.assertEquals(self.n, 2) + self.assertEqual(self.n, 2) def test_change_size_2(self): xml1 = "<?xml version='1.0' encoding='iso8859'?><a>a<s>%s" % ('a' * 1023) @@ -566,14 +566,14 @@ class ChardataBufferTest(unittest.TestCase): parser.CharacterDataHandler = self.counting_handler parser.buffer_text = 1 parser.buffer_size = 2048 - self.assertEquals(parser.buffer_size, 2048) + self.assertEqual(parser.buffer_size, 2048) self.n=0 parser.Parse(xml1, 0) parser.buffer_size = parser.buffer_size // 2 - self.assertEquals(parser.buffer_size, 1024) + self.assertEqual(parser.buffer_size, 1024) parser.Parse(xml2, 1) - self.assertEquals(self.n, 4) + self.assertEqual(self.n, 4) class MalformedInputTest(unittest.TestCase): def test1(self): @@ -583,7 +583,7 @@ class MalformedInputTest(unittest.TestCase): parser.Parse(xml, True) self.fail() except expat.ExpatError as e: - self.assertEquals(str(e), 'unclosed token: line 2, column 0') + self.assertEqual(str(e), 'unclosed token: line 2, column 0') def test2(self): xml = "<?xml version\xc2\x85='1.0'?>\r\n" @@ -592,7 +592,7 @@ class MalformedInputTest(unittest.TestCase): parser.Parse(xml, True) self.fail() except expat.ExpatError as e: - self.assertEquals(str(e), 'XML declaration not well-formed: line 1, column 14') + self.assertEqual(str(e), 'XML declaration not well-formed: line 1, column 14') class ErrorMessageTest(unittest.TestCase): def test_codes(self): @@ -607,8 +607,8 @@ class ErrorMessageTest(unittest.TestCase): parser.Parse(xml, True) self.fail() except expat.ExpatError as e: - self.assertEquals(e.code, - errors.codes[errors.XML_ERROR_UNCLOSED_TOKEN]) + self.assertEqual(e.code, + errors.codes[errors.XML_ERROR_UNCLOSED_TOKEN]) def test_main(): diff --git a/Lib/test/test_queue.py b/Lib/test/test_queue.py index 5cef90c..8287a5d 100644 --- a/Lib/test/test_queue.py +++ b/Lib/test/test_queue.py @@ -100,8 +100,8 @@ class BaseQueueTest(unittest.TestCase, BlockingTestMixin): LifoQueue = [222, 333, 111], PriorityQueue = [111, 222, 333]) actual_order = [q.get(), q.get(), q.get()] - self.assertEquals(actual_order, target_order[q.__class__.__name__], - "Didn't seem to queue the correct data!") + self.assertEqual(actual_order, target_order[q.__class__.__name__], + "Didn't seem to queue the correct data!") for i in range(QUEUE_SIZE-1): q.put(i) self.assertTrue(q.qsize(), "Queue should not be empty") @@ -161,8 +161,8 @@ class BaseQueueTest(unittest.TestCase, BlockingTestMixin): for i in range(100): q.put(i) q.join() - self.assertEquals(self.cum, sum(range(100)), - "q.join() did not block until all tasks were done") + self.assertEqual(self.cum, sum(range(100)), + "q.join() did not block until all tasks were done") for i in (0,1): q.put(-1) # instruct the threads to close q.join() # verify that you can join twice diff --git a/Lib/test/test_range.py b/Lib/test/test_range.py index 812b73d..914dd4c 100644 --- a/Lib/test/test_range.py +++ b/Lib/test/test_range.py @@ -101,8 +101,8 @@ class RangeTest(unittest.TestCase): for proto in range(pickle.HIGHEST_PROTOCOL + 1): for t in testcases: r = range(*t) - self.assertEquals(list(pickle.loads(pickle.dumps(r, proto))), - list(r)) + self.assertEqual(list(pickle.loads(pickle.dumps(r, proto))), + list(r)) def test_odd_bug(self): # This used to raise a "SystemError: NULL result without error" diff --git a/Lib/test/test_reprlib.py b/Lib/test/test_reprlib.py index 4271482..b0dc4d7 100644 --- a/Lib/test/test_reprlib.py +++ b/Lib/test/test_reprlib.py @@ -23,7 +23,7 @@ def nestedTuple(nesting): class ReprTests(unittest.TestCase): def test_string(self): - eq = self.assertEquals + eq = self.assertEqual eq(r("abc"), "'abc'") eq(r("abcdefghijklmnop"),"'abcdefghijklmnop'") @@ -37,7 +37,7 @@ class ReprTests(unittest.TestCase): eq(r(s), expected) def test_tuple(self): - eq = self.assertEquals + eq = self.assertEqual eq(r((1,)), "(1,)") t3 = (1, 2, 3) @@ -52,7 +52,7 @@ class ReprTests(unittest.TestCase): from array import array from collections import deque - eq = self.assertEquals + eq = self.assertEqual # Tuples give up after 6 elements eq(r(()), "()") eq(r((1,)), "(1,)") @@ -102,7 +102,7 @@ class ReprTests(unittest.TestCase): "array('i', [1, 2, 3, 4, 5, ...])") def test_numbers(self): - eq = self.assertEquals + eq = self.assertEqual eq(r(123), repr(123)) eq(r(123), repr(123)) eq(r(1.0/3), repr(1.0/3)) @@ -112,7 +112,7 @@ class ReprTests(unittest.TestCase): eq(r(n), expected) def test_instance(self): - eq = self.assertEquals + eq = self.assertEqual i1 = ClassWithRepr("a") eq(r(i1), repr(i1)) @@ -134,7 +134,7 @@ class ReprTests(unittest.TestCase): # XXX anonymous functions? see func_repr def test_builtin_function(self): - eq = self.assertEquals + eq = self.assertEqual # Functions eq(repr(hash), '<built-in function hash>') # Methods @@ -142,13 +142,13 @@ class ReprTests(unittest.TestCase): '<built-in method split of str object at 0x')) def test_range(self): - eq = self.assertEquals + eq = self.assertEqual eq(repr(range(1)), 'range(0, 1)') eq(repr(range(1, 2)), 'range(1, 2)') eq(repr(range(1, 4, 3)), 'range(1, 4, 3)') def test_nesting(self): - eq = self.assertEquals + eq = self.assertEqual # everything is meant to give up after 6 levels. eq(r([[[[[[[]]]]]]]), "[[[[[[[]]]]]]]") eq(r([[[[[[[[]]]]]]]]), "[[[[[[[...]]]]]]]") @@ -169,7 +169,7 @@ class ReprTests(unittest.TestCase): pass def test_descriptors(self): - eq = self.assertEquals + eq = self.assertEqual # method descriptors eq(repr(dict.items), "<method 'items' of 'dict' objects>") # XXX member descriptors @@ -230,7 +230,7 @@ class LongReprTest(unittest.TestCase): del sys.path[0] def test_module(self): - eq = self.assertEquals + eq = self.assertEqual touch(os.path.join(self.subpkgname, self.pkgname + '.py')) from areallylongpackageandmodulenametotestreprtruncation.areallylongpackageandmodulenametotestreprtruncation import areallylongpackageandmodulenametotestreprtruncation eq(repr(areallylongpackageandmodulenametotestreprtruncation), @@ -238,7 +238,7 @@ class LongReprTest(unittest.TestCase): eq(repr(sys), "<module 'sys' (built-in)>") def test_type(self): - eq = self.assertEquals + eq = self.assertEqual touch(os.path.join(self.subpkgname, 'foo.py'), '''\ class foo(object): pass @@ -259,7 +259,7 @@ class bar: ''') from areallylongpackageandmodulenametotestreprtruncation.areallylongpackageandmodulenametotestreprtruncation import bar # Module name may be prefixed with "test.", depending on how run. - self.assertEquals(repr(bar.bar), "<class '%s.bar'>" % bar.__name__) + self.assertEqual(repr(bar.bar), "<class '%s.bar'>" % bar.__name__) def test_instance(self): touch(os.path.join(self.subpkgname, 'baz.py'), '''\ @@ -272,7 +272,7 @@ class baz: "<%s.baz object at 0x" % baz.__name__)) def test_method(self): - eq = self.assertEquals + eq = self.assertEqual touch(os.path.join(self.subpkgname, 'qux.py'), '''\ class aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa: def amethod(self): pass diff --git a/Lib/test/test_sax.py b/Lib/test/test_sax.py index dff2131..0f6a1ca 100644 --- a/Lib/test/test_sax.py +++ b/Lib/test/test_sax.py @@ -34,16 +34,16 @@ class XmlTestBase(unittest.TestCase): self.assertRaises(KeyError, attrs.getNameByQName, "attr") self.assertRaises(KeyError, attrs.getQNameByName, "attr") self.assertRaises(KeyError, attrs.__getitem__, "attr") - self.assertEquals(attrs.getLength(), 0) - self.assertEquals(attrs.getNames(), []) - self.assertEquals(attrs.getQNames(), []) - self.assertEquals(len(attrs), 0) + self.assertEqual(attrs.getLength(), 0) + self.assertEqual(attrs.getNames(), []) + self.assertEqual(attrs.getQNames(), []) + self.assertEqual(len(attrs), 0) self.assertNotIn("attr", attrs) - self.assertEquals(list(attrs.keys()), []) - self.assertEquals(attrs.get("attrs"), None) - self.assertEquals(attrs.get("attrs", 25), 25) - self.assertEquals(list(attrs.items()), []) - self.assertEquals(list(attrs.values()), []) + self.assertEqual(list(attrs.keys()), []) + self.assertEqual(attrs.get("attrs"), None) + self.assertEqual(attrs.get("attrs", 25), 25) + self.assertEqual(list(attrs.items()), []) + self.assertEqual(list(attrs.values()), []) def verify_empty_nsattrs(self, attrs): self.assertRaises(KeyError, attrs.getValue, (ns_uri, "attr")) @@ -51,33 +51,33 @@ class XmlTestBase(unittest.TestCase): self.assertRaises(KeyError, attrs.getNameByQName, "ns:attr") self.assertRaises(KeyError, attrs.getQNameByName, (ns_uri, "attr")) self.assertRaises(KeyError, attrs.__getitem__, (ns_uri, "attr")) - self.assertEquals(attrs.getLength(), 0) - self.assertEquals(attrs.getNames(), []) - self.assertEquals(attrs.getQNames(), []) - self.assertEquals(len(attrs), 0) + self.assertEqual(attrs.getLength(), 0) + self.assertEqual(attrs.getNames(), []) + self.assertEqual(attrs.getQNames(), []) + self.assertEqual(len(attrs), 0) self.assertNotIn((ns_uri, "attr"), attrs) - self.assertEquals(list(attrs.keys()), []) - self.assertEquals(attrs.get((ns_uri, "attr")), None) - self.assertEquals(attrs.get((ns_uri, "attr"), 25), 25) - self.assertEquals(list(attrs.items()), []) - self.assertEquals(list(attrs.values()), []) + self.assertEqual(list(attrs.keys()), []) + self.assertEqual(attrs.get((ns_uri, "attr")), None) + self.assertEqual(attrs.get((ns_uri, "attr"), 25), 25) + self.assertEqual(list(attrs.items()), []) + self.assertEqual(list(attrs.values()), []) def verify_attrs_wattr(self, attrs): - self.assertEquals(attrs.getLength(), 1) - self.assertEquals(attrs.getNames(), ["attr"]) - self.assertEquals(attrs.getQNames(), ["attr"]) - self.assertEquals(len(attrs), 1) + self.assertEqual(attrs.getLength(), 1) + self.assertEqual(attrs.getNames(), ["attr"]) + self.assertEqual(attrs.getQNames(), ["attr"]) + self.assertEqual(len(attrs), 1) self.assertIn("attr", attrs) - self.assertEquals(list(attrs.keys()), ["attr"]) - self.assertEquals(attrs.get("attr"), "val") - self.assertEquals(attrs.get("attr", 25), "val") - self.assertEquals(list(attrs.items()), [("attr", "val")]) - self.assertEquals(list(attrs.values()), ["val"]) - self.assertEquals(attrs.getValue("attr"), "val") - self.assertEquals(attrs.getValueByQName("attr"), "val") - self.assertEquals(attrs.getNameByQName("attr"), "attr") - self.assertEquals(attrs["attr"], "val") - self.assertEquals(attrs.getQNameByName("attr"), "attr") + self.assertEqual(list(attrs.keys()), ["attr"]) + self.assertEqual(attrs.get("attr"), "val") + self.assertEqual(attrs.get("attr", 25), "val") + self.assertEqual(list(attrs.items()), [("attr", "val")]) + self.assertEqual(list(attrs.values()), ["val"]) + self.assertEqual(attrs.getValue("attr"), "val") + self.assertEqual(attrs.getValueByQName("attr"), "val") + self.assertEqual(attrs.getNameByQName("attr"), "attr") + self.assertEqual(attrs["attr"], "val") + self.assertEqual(attrs.getQNameByName("attr"), "attr") class MakeParserTest(unittest.TestCase): def test_make_parser2(self): @@ -107,47 +107,47 @@ class MakeParserTest(unittest.TestCase): class SaxutilsTest(unittest.TestCase): # ===== escape def test_escape_basic(self): - self.assertEquals(escape("Donald Duck & Co"), "Donald Duck & Co") + self.assertEqual(escape("Donald Duck & Co"), "Donald Duck & Co") def test_escape_all(self): - self.assertEquals(escape("<Donald Duck & Co>"), - "<Donald Duck & Co>") + self.assertEqual(escape("<Donald Duck & Co>"), + "<Donald Duck & Co>") def test_escape_extra(self): - self.assertEquals(escape("Hei på deg", {"å" : "å"}), - "Hei på deg") + self.assertEqual(escape("Hei på deg", {"å" : "å"}), + "Hei på deg") # ===== unescape def test_unescape_basic(self): - self.assertEquals(unescape("Donald Duck & Co"), "Donald Duck & Co") + self.assertEqual(unescape("Donald Duck & Co"), "Donald Duck & Co") def test_unescape_all(self): - self.assertEquals(unescape("<Donald Duck & Co>"), - "<Donald Duck & Co>") + self.assertEqual(unescape("<Donald Duck & Co>"), + "<Donald Duck & Co>") def test_unescape_extra(self): - self.assertEquals(unescape("Hei på deg", {"å" : "å"}), - "Hei på deg") + self.assertEqual(unescape("Hei på deg", {"å" : "å"}), + "Hei på deg") def test_unescape_amp_extra(self): - self.assertEquals(unescape("&foo;", {"&foo;": "splat"}), "&foo;") + self.assertEqual(unescape("&foo;", {"&foo;": "splat"}), "&foo;") # ===== quoteattr def test_quoteattr_basic(self): - self.assertEquals(quoteattr("Donald Duck & Co"), - '"Donald Duck & Co"') + self.assertEqual(quoteattr("Donald Duck & Co"), + '"Donald Duck & Co"') def test_single_quoteattr(self): - self.assertEquals(quoteattr('Includes "double" quotes'), - '\'Includes "double" quotes\'') + self.assertEqual(quoteattr('Includes "double" quotes'), + '\'Includes "double" quotes\'') def test_double_quoteattr(self): - self.assertEquals(quoteattr("Includes 'single' quotes"), - "\"Includes 'single' quotes\"") + self.assertEqual(quoteattr("Includes 'single' quotes"), + "\"Includes 'single' quotes\"") def test_single_double_quoteattr(self): - self.assertEquals(quoteattr("Includes 'single' and \"double\" quotes"), - "\"Includes 'single' and "double" quotes\"") + self.assertEqual(quoteattr("Includes 'single' and \"double\" quotes"), + "\"Includes 'single' and "double" quotes\"") # ===== make_parser def test_make_parser(self): @@ -169,7 +169,7 @@ class XmlgenTest(unittest.TestCase): gen.endElement("doc") gen.endDocument() - self.assertEquals(result.getvalue(), start + "<doc></doc>") + self.assertEqual(result.getvalue(), start + "<doc></doc>") def test_xmlgen_basic_empty(self): result = StringIO() @@ -179,7 +179,7 @@ class XmlgenTest(unittest.TestCase): gen.endElement("doc") gen.endDocument() - self.assertEquals(result.getvalue(), start + "<doc/>") + self.assertEqual(result.getvalue(), start + "<doc/>") def test_xmlgen_content(self): result = StringIO() @@ -191,7 +191,7 @@ class XmlgenTest(unittest.TestCase): gen.endElement("doc") gen.endDocument() - self.assertEquals(result.getvalue(), start + "<doc>huhei</doc>") + self.assertEqual(result.getvalue(), start + "<doc>huhei</doc>") def test_xmlgen_content_empty(self): result = StringIO() @@ -203,7 +203,7 @@ class XmlgenTest(unittest.TestCase): gen.endElement("doc") gen.endDocument() - self.assertEquals(result.getvalue(), start + "<doc>huhei</doc>") + self.assertEqual(result.getvalue(), start + "<doc>huhei</doc>") def test_xmlgen_pi(self): result = StringIO() @@ -215,7 +215,7 @@ class XmlgenTest(unittest.TestCase): gen.endElement("doc") gen.endDocument() - self.assertEquals(result.getvalue(), start + "<?test data?><doc></doc>") + self.assertEqual(result.getvalue(), start + "<?test data?><doc></doc>") def test_xmlgen_content_escape(self): result = StringIO() @@ -227,7 +227,7 @@ class XmlgenTest(unittest.TestCase): gen.endElement("doc") gen.endDocument() - self.assertEquals(result.getvalue(), + self.assertEqual(result.getvalue(), start + "<doc><huhei&</doc>") def test_xmlgen_attr_escape(self): @@ -245,7 +245,7 @@ class XmlgenTest(unittest.TestCase): gen.endElement("doc") gen.endDocument() - self.assertEquals(result.getvalue(), start + + self.assertEqual(result.getvalue(), start + ("<doc a='\"'><e a=\"'\"></e>" "<e a=\"'"\"></e>" "<e a=\" 	\"></e></doc>")) @@ -260,7 +260,7 @@ class XmlgenTest(unittest.TestCase): gen.endElement("doc") gen.endDocument() - self.assertEquals(result.getvalue(), start + "<doc> </doc>") + self.assertEqual(result.getvalue(), start + "<doc> </doc>") def test_xmlgen_ignorable_empty(self): result = StringIO() @@ -272,7 +272,7 @@ class XmlgenTest(unittest.TestCase): gen.endElement("doc") gen.endDocument() - self.assertEquals(result.getvalue(), start + "<doc> </doc>") + self.assertEqual(result.getvalue(), start + "<doc> </doc>") def test_xmlgen_ns(self): result = StringIO() @@ -288,7 +288,7 @@ class XmlgenTest(unittest.TestCase): gen.endPrefixMapping("ns1") gen.endDocument() - self.assertEquals(result.getvalue(), start + \ + self.assertEqual(result.getvalue(), start + \ ('<ns1:doc xmlns:ns1="%s"><udoc></udoc></ns1:doc>' % ns_uri)) @@ -306,7 +306,7 @@ class XmlgenTest(unittest.TestCase): gen.endPrefixMapping("ns1") gen.endDocument() - self.assertEquals(result.getvalue(), start + \ + self.assertEqual(result.getvalue(), start + \ ('<ns1:doc xmlns:ns1="%s"><udoc/></ns1:doc>' % ns_uri)) @@ -319,7 +319,7 @@ class XmlgenTest(unittest.TestCase): gen.endElementNS((None, 'a'), 'a') gen.endDocument() - self.assertEquals(result.getvalue(), start+'<a b="c"></a>') + self.assertEqual(result.getvalue(), start+'<a b="c"></a>') def test_1463026_1_empty(self): result = StringIO() @@ -330,7 +330,7 @@ class XmlgenTest(unittest.TestCase): gen.endElementNS((None, 'a'), 'a') gen.endDocument() - self.assertEquals(result.getvalue(), start+'<a b="c"/>') + self.assertEqual(result.getvalue(), start+'<a b="c"/>') def test_1463026_2(self): result = StringIO() @@ -343,7 +343,7 @@ class XmlgenTest(unittest.TestCase): gen.endPrefixMapping(None) gen.endDocument() - self.assertEquals(result.getvalue(), start+'<a xmlns="qux"></a>') + self.assertEqual(result.getvalue(), start+'<a xmlns="qux"></a>') def test_1463026_2_empty(self): result = StringIO() @@ -356,7 +356,7 @@ class XmlgenTest(unittest.TestCase): gen.endPrefixMapping(None) gen.endDocument() - self.assertEquals(result.getvalue(), start+'<a xmlns="qux"/>') + self.assertEqual(result.getvalue(), start+'<a xmlns="qux"/>') def test_1463026_3(self): result = StringIO() @@ -369,7 +369,7 @@ class XmlgenTest(unittest.TestCase): gen.endPrefixMapping('my') gen.endDocument() - self.assertEquals(result.getvalue(), + self.assertEqual(result.getvalue(), start+'<my:a xmlns:my="qux" b="c"></my:a>') def test_1463026_3_empty(self): @@ -383,7 +383,7 @@ class XmlgenTest(unittest.TestCase): gen.endPrefixMapping('my') gen.endDocument() - self.assertEquals(result.getvalue(), + self.assertEqual(result.getvalue(), start+'<my:a xmlns:my="qux" b="c"/>') def test_5027_1(self): @@ -406,11 +406,11 @@ class XmlgenTest(unittest.TestCase): parser.setContentHandler(gen) parser.parse(test_xml) - self.assertEquals(result.getvalue(), - start + ( - '<a:g1 xmlns:a="http://example.com/ns">' - '<a:g2 xml:lang="en">Hello</a:g2>' - '</a:g1>')) + self.assertEqual(result.getvalue(), + start + ( + '<a:g1 xmlns:a="http://example.com/ns">' + '<a:g2 xml:lang="en">Hello</a:g2>' + '</a:g1>')) def test_5027_2(self): # The xml prefix (as in xml:lang below) is reserved and bound by @@ -434,11 +434,11 @@ class XmlgenTest(unittest.TestCase): gen.endPrefixMapping('a') gen.endDocument() - self.assertEquals(result.getvalue(), - start + ( - '<a:g1 xmlns:a="http://example.com/ns">' - '<a:g2 xml:lang="en">Hello</a:g2>' - '</a:g1>')) + self.assertEqual(result.getvalue(), + start + ( + '<a:g1 xmlns:a="http://example.com/ns">' + '<a:g2 xml:lang="en">Hello</a:g2>' + '</a:g1>')) class XMLFilterBaseTest(unittest.TestCase): @@ -455,7 +455,7 @@ class XMLFilterBaseTest(unittest.TestCase): filter.endElement("doc") filter.endDocument() - self.assertEquals(result.getvalue(), start + "<doc>content </doc>") + self.assertEqual(result.getvalue(), start + "<doc>content </doc>") # =========================================================================== # @@ -479,7 +479,7 @@ class ExpatReaderTest(XmlTestBase): with open(TEST_XMLFILE) as f: parser.parse(f) - self.assertEquals(result.getvalue(), xml_test_out) + self.assertEqual(result.getvalue(), xml_test_out) # ===== DTDHandler support @@ -507,9 +507,9 @@ class ExpatReaderTest(XmlTestBase): parser.feed('<doc></doc>') parser.close() - self.assertEquals(handler._notations, + self.assertEqual(handler._notations, [("GIF", "-//CompuServe//NOTATION Graphics Interchange Format 89a//EN", None)]) - self.assertEquals(handler._entities, [("img", None, "expat.gif", "GIF")]) + self.assertEqual(handler._entities, [("img", None, "expat.gif", "GIF")]) # ===== EntityResolver support @@ -532,8 +532,8 @@ class ExpatReaderTest(XmlTestBase): parser.feed('<doc>&test;</doc>') parser.close() - self.assertEquals(result.getvalue(), start + - "<doc><entity></entity></doc>") + self.assertEqual(result.getvalue(), start + + "<doc><entity></entity></doc>") # ===== Attributes support @@ -585,18 +585,18 @@ class ExpatReaderTest(XmlTestBase): attrs = gather._attrs - self.assertEquals(attrs.getLength(), 1) - self.assertEquals(attrs.getNames(), [(ns_uri, "attr")]) + self.assertEqual(attrs.getLength(), 1) + self.assertEqual(attrs.getNames(), [(ns_uri, "attr")]) self.assertTrue((attrs.getQNames() == [] or attrs.getQNames() == ["ns:attr"])) - self.assertEquals(len(attrs), 1) + self.assertEqual(len(attrs), 1) self.assertIn((ns_uri, "attr"), attrs) - self.assertEquals(attrs.get((ns_uri, "attr")), "val") - self.assertEquals(attrs.get((ns_uri, "attr"), 25), "val") - self.assertEquals(list(attrs.items()), [((ns_uri, "attr"), "val")]) - self.assertEquals(list(attrs.values()), ["val"]) - self.assertEquals(attrs.getValue((ns_uri, "attr")), "val") - self.assertEquals(attrs[(ns_uri, "attr")], "val") + self.assertEqual(attrs.get((ns_uri, "attr")), "val") + self.assertEqual(attrs.get((ns_uri, "attr"), 25), "val") + self.assertEqual(list(attrs.items()), [((ns_uri, "attr"), "val")]) + self.assertEqual(list(attrs.values()), ["val"]) + self.assertEqual(attrs.getValue((ns_uri, "attr")), "val") + self.assertEqual(attrs[(ns_uri, "attr")], "val") # ===== InputSource support @@ -608,7 +608,7 @@ class ExpatReaderTest(XmlTestBase): parser.setContentHandler(xmlgen) parser.parse(TEST_XMLFILE) - self.assertEquals(result.getvalue(), xml_test_out) + self.assertEqual(result.getvalue(), xml_test_out) def test_expat_inpsource_sysid(self): parser = create_parser() @@ -618,7 +618,7 @@ class ExpatReaderTest(XmlTestBase): parser.setContentHandler(xmlgen) parser.parse(InputSource(TEST_XMLFILE)) - self.assertEquals(result.getvalue(), xml_test_out) + self.assertEqual(result.getvalue(), xml_test_out) def test_expat_inpsource_stream(self): parser = create_parser() @@ -631,7 +631,7 @@ class ExpatReaderTest(XmlTestBase): inpsrc.setByteStream(f) parser.parse(inpsrc) - self.assertEquals(result.getvalue(), xml_test_out) + self.assertEqual(result.getvalue(), xml_test_out) # ===== IncrementalParser support @@ -645,7 +645,7 @@ class ExpatReaderTest(XmlTestBase): parser.feed("</doc>") parser.close() - self.assertEquals(result.getvalue(), start + "<doc></doc>") + self.assertEqual(result.getvalue(), start + "<doc></doc>") def test_expat_incremental_reset(self): result = StringIO() @@ -666,7 +666,7 @@ class ExpatReaderTest(XmlTestBase): parser.feed("</doc>") parser.close() - self.assertEquals(result.getvalue(), start + "<doc>text</doc>") + self.assertEqual(result.getvalue(), start + "<doc>text</doc>") # ===== Locator support @@ -680,9 +680,9 @@ class ExpatReaderTest(XmlTestBase): parser.feed("</doc>") parser.close() - self.assertEquals(parser.getSystemId(), None) - self.assertEquals(parser.getPublicId(), None) - self.assertEquals(parser.getLineNumber(), 1) + self.assertEqual(parser.getSystemId(), None) + self.assertEqual(parser.getPublicId(), None) + self.assertEqual(parser.getLineNumber(), 1) def test_expat_locator_withinfo(self): result = StringIO() @@ -691,8 +691,8 @@ class ExpatReaderTest(XmlTestBase): parser.setContentHandler(xmlgen) parser.parse(TEST_XMLFILE) - self.assertEquals(parser.getSystemId(), TEST_XMLFILE) - self.assertEquals(parser.getPublicId(), None) + self.assertEqual(parser.getSystemId(), TEST_XMLFILE) + self.assertEqual(parser.getPublicId(), None) # =========================================================================== @@ -713,7 +713,7 @@ class ErrorReportingTest(unittest.TestCase): parser.parse(source) self.fail() except SAXException as e: - self.assertEquals(e.getSystemId(), name) + self.assertEqual(e.getSystemId(), name) def test_expat_incomplete(self): parser = create_parser() @@ -777,21 +777,21 @@ class XmlReaderTest(XmlTestBase): attrs = AttributesNSImpl({(ns_uri, "attr") : "val"}, {(ns_uri, "attr") : "ns:attr"}) - self.assertEquals(attrs.getLength(), 1) - self.assertEquals(attrs.getNames(), [(ns_uri, "attr")]) - self.assertEquals(attrs.getQNames(), ["ns:attr"]) - self.assertEquals(len(attrs), 1) + self.assertEqual(attrs.getLength(), 1) + self.assertEqual(attrs.getNames(), [(ns_uri, "attr")]) + self.assertEqual(attrs.getQNames(), ["ns:attr"]) + self.assertEqual(len(attrs), 1) self.assertIn((ns_uri, "attr"), attrs) - self.assertEquals(list(attrs.keys()), [(ns_uri, "attr")]) - self.assertEquals(attrs.get((ns_uri, "attr")), "val") - self.assertEquals(attrs.get((ns_uri, "attr"), 25), "val") - self.assertEquals(list(attrs.items()), [((ns_uri, "attr"), "val")]) - self.assertEquals(list(attrs.values()), ["val"]) - self.assertEquals(attrs.getValue((ns_uri, "attr")), "val") - self.assertEquals(attrs.getValueByQName("ns:attr"), "val") - self.assertEquals(attrs.getNameByQName("ns:attr"), (ns_uri, "attr")) - self.assertEquals(attrs[(ns_uri, "attr")], "val") - self.assertEquals(attrs.getQNameByName((ns_uri, "attr")), "ns:attr") + self.assertEqual(list(attrs.keys()), [(ns_uri, "attr")]) + self.assertEqual(attrs.get((ns_uri, "attr")), "val") + self.assertEqual(attrs.get((ns_uri, "attr"), 25), "val") + self.assertEqual(list(attrs.items()), [((ns_uri, "attr"), "val")]) + self.assertEqual(list(attrs.values()), ["val"]) + self.assertEqual(attrs.getValue((ns_uri, "attr")), "val") + self.assertEqual(attrs.getValueByQName("ns:attr"), "val") + self.assertEqual(attrs.getNameByQName("ns:attr"), (ns_uri, "attr")) + self.assertEqual(attrs[(ns_uri, "attr")], "val") + self.assertEqual(attrs.getQNameByName((ns_uri, "attr")), "ns:attr") # During the development of Python 2.5, an attempt to move the "xml" @@ -827,7 +827,7 @@ class XmlReaderTest(XmlTestBase): try: import xml.sax.expatreader module = xml.sax.expatreader - self.assertEquals(module.__name__, "xml.sax.expatreader") + self.assertEqual(module.__name__, "xml.sax.expatreader") finally: sys.modules.update(old_modules) diff --git a/Lib/test/test_scope.py b/Lib/test/test_scope.py index 390e39f..fbc87aa 100644 --- a/Lib/test/test_scope.py +++ b/Lib/test/test_scope.py @@ -510,7 +510,7 @@ class ScopeTests(unittest.TestCase): def f(self): return x - self.assertEquals(x, 12) # Used to raise UnboundLocalError + self.assertEqual(x, 12) # Used to raise UnboundLocalError finally: sys.settrace(None) diff --git a/Lib/test/test_shutil.py b/Lib/test/test_shutil.py index 270293a..d80acfa 100644 --- a/Lib/test/test_shutil.py +++ b/Lib/test/test_shutil.py @@ -362,7 +362,7 @@ class TestShutil(unittest.TestCase): copied.append((src, dst)) shutil.copytree(src_dir, dst_dir, copy_function=_copy) - self.assertEquals(len(copied), 2) + self.assertEqual(len(copied), 2) @support.skip_unless_symlink def test_copytree_dangling_symlinks(self): @@ -477,7 +477,7 @@ class TestShutil(unittest.TestCase): self.assertTrue(os.path.exists(tarball2)) # let's compare both tarballs - self.assertEquals(self._tarinfo(tarball), self._tarinfo(tarball2)) + self.assertEqual(self._tarinfo(tarball), self._tarinfo(tarball2)) # trying an uncompressed one base_name = os.path.join(tmpdir2, 'archive') @@ -572,8 +572,8 @@ class TestShutil(unittest.TestCase): archive = tarfile.open(archive_name) try: for member in archive.getmembers(): - self.assertEquals(member.uid, 0) - self.assertEquals(member.gid, 0) + self.assertEqual(member.uid, 0) + self.assertEqual(member.gid, 0) finally: archive.close() @@ -588,7 +588,7 @@ class TestShutil(unittest.TestCase): make_archive('xxx', 'xxx', root_dir=self.mkdtemp()) except Exception: pass - self.assertEquals(os.getcwd(), current_dir) + self.assertEqual(os.getcwd(), current_dir) finally: unregister_archive_format('xxx') @@ -635,16 +635,16 @@ class TestShutil(unittest.TestCase): # let's try to unpack it now unpack_archive(filename, tmpdir2) diff = self._compare_dirs(tmpdir, tmpdir2) - self.assertEquals(diff, []) + self.assertEqual(diff, []) def test_unpack_registery(self): formats = get_unpack_formats() def _boo(filename, extract_dir, extra): - self.assertEquals(extra, 1) - self.assertEquals(filename, 'stuff.boo') - self.assertEquals(extract_dir, 'xx') + self.assertEqual(extra, 1) + self.assertEqual(filename, 'stuff.boo') + self.assertEqual(extract_dir, 'xx') register_unpack_format('Boo', ['.boo', '.b2'], _boo, [('extra', 1)]) unpack_archive('stuff.boo', 'xx') @@ -661,7 +661,7 @@ class TestShutil(unittest.TestCase): # let's leave a clean state unregister_unpack_format('Boo2') - self.assertEquals(get_unpack_formats(), formats) + self.assertEqual(get_unpack_formats(), formats) class TestMove(unittest.TestCase): diff --git a/Lib/test/test_signal.py b/Lib/test/test_signal.py index 83ac669..8f9b064 100644 --- a/Lib/test/test_signal.py +++ b/Lib/test/test_signal.py @@ -203,10 +203,10 @@ class BasicSignalTests(unittest.TestCase): def test_getsignal(self): hup = signal.signal(signal.SIGHUP, self.trivial_signal_handler) - self.assertEquals(signal.getsignal(signal.SIGHUP), - self.trivial_signal_handler) + self.assertEqual(signal.getsignal(signal.SIGHUP), + self.trivial_signal_handler) signal.signal(signal.SIGHUP, hup) - self.assertEquals(signal.getsignal(signal.SIGHUP), hup) + self.assertEqual(signal.getsignal(signal.SIGHUP), hup) @unittest.skipUnless(sys.platform == "win32", "Windows specific") @@ -456,9 +456,9 @@ class ItimerTest(unittest.TestCase): "high") # virtual itimer should be (0.0, 0.0) now - self.assertEquals(signal.getitimer(self.itimer), (0.0, 0.0)) + self.assertEqual(signal.getitimer(self.itimer), (0.0, 0.0)) # and the handler should have been called - self.assertEquals(self.hndl_called, True) + self.assertEqual(self.hndl_called, True) # Issue 3864, unknown if this affects earlier versions of freebsd also @unittest.skipIf(sys.platform=='freebsd6', @@ -479,7 +479,7 @@ class ItimerTest(unittest.TestCase): "high") # profiling itimer should be (0.0, 0.0) now - self.assertEquals(signal.getitimer(self.itimer), (0.0, 0.0)) + self.assertEqual(signal.getitimer(self.itimer), (0.0, 0.0)) # and the handler should have been called self.assertEqual(self.hndl_called, True) diff --git a/Lib/test/test_site.py b/Lib/test/test_site.py index 8d03224..94d6699 100644 --- a/Lib/test/test_site.py +++ b/Lib/test/test_site.py @@ -134,7 +134,7 @@ class HelperFunctionsTests(unittest.TestCase): user_base = site.getuserbase() # the call sets site.USER_BASE - self.assertEquals(site.USER_BASE, user_base) + self.assertEqual(site.USER_BASE, user_base) # let's set PYTHONUSERBASE and see if it uses it site.USER_BASE = None @@ -152,7 +152,7 @@ class HelperFunctionsTests(unittest.TestCase): user_site = site.getusersitepackages() # the call sets USER_BASE *and* USER_SITE - self.assertEquals(site.USER_SITE, user_site) + self.assertEqual(site.USER_SITE, user_site) self.assertTrue(user_site.startswith(site.USER_BASE), user_site) def test_getsitepackages(self): @@ -162,19 +162,19 @@ class HelperFunctionsTests(unittest.TestCase): if sys.platform in ('os2emx', 'riscos'): self.assertEqual(len(dirs), 1) wanted = os.path.join('xoxo', 'Lib', 'site-packages') - self.assertEquals(dirs[0], wanted) + self.assertEqual(dirs[0], wanted) elif os.sep == '/': self.assertEqual(len(dirs), 2) wanted = os.path.join('xoxo', 'lib', 'python' + sys.version[:3], 'site-packages') - self.assertEquals(dirs[0], wanted) + self.assertEqual(dirs[0], wanted) wanted = os.path.join('xoxo', 'lib', 'site-python') - self.assertEquals(dirs[1], wanted) + self.assertEqual(dirs[1], wanted) else: self.assertEqual(len(dirs), 2) - self.assertEquals(dirs[0], 'xoxo') + self.assertEqual(dirs[0], 'xoxo') wanted = os.path.join('xoxo', 'lib', 'site-packages') - self.assertEquals(dirs[1], wanted) + self.assertEqual(dirs[1], wanted) # let's try the specific Apple location if (sys.platform == "darwin" and @@ -184,7 +184,7 @@ class HelperFunctionsTests(unittest.TestCase): self.assertEqual(len(dirs), 3) wanted = os.path.join('/Library', 'Python', sys.version[:3], 'site-packages') - self.assertEquals(dirs[2], wanted) + self.assertEqual(dirs[2], wanted) class PthFile(object): """Helper class for handling testing of .pth files""" diff --git a/Lib/test/test_slice.py b/Lib/test/test_slice.py index 2ecb59a..2df9271 100644 --- a/Lib/test/test_slice.py +++ b/Lib/test/test_slice.py @@ -118,7 +118,7 @@ class SliceTest(unittest.TestCase): x = X() x[1:2] = 42 - self.assertEquals(tmp, [(slice(1, 2), 42)]) + self.assertEqual(tmp, [(slice(1, 2), 42)]) def test_pickle(self): s = slice(10, 20, 3) diff --git a/Lib/test/test_socket.py b/Lib/test/test_socket.py index 9f27a51..32084da 100644 --- a/Lib/test/test_socket.py +++ b/Lib/test/test_socket.py @@ -446,8 +446,8 @@ class GeneralModuleTests(unittest.TestCase): return # No inet_aton, nothing to check # Test that issue1008086 and issue767150 are fixed. # It must return 4 bytes. - self.assertEquals(b'\x00'*4, socket.inet_aton('0.0.0.0')) - self.assertEquals(b'\xff'*4, socket.inet_aton('255.255.255.255')) + self.assertEqual(b'\x00'*4, socket.inet_aton('0.0.0.0')) + self.assertEqual(b'\xff'*4, socket.inet_aton('255.255.255.255')) def testIPv4toString(self): if not hasattr(socket, 'inet_pton'): @@ -455,16 +455,16 @@ class GeneralModuleTests(unittest.TestCase): from socket import inet_aton as f, inet_pton, AF_INET g = lambda a: inet_pton(AF_INET, a) - self.assertEquals(b'\x00\x00\x00\x00', f('0.0.0.0')) - self.assertEquals(b'\xff\x00\xff\x00', f('255.0.255.0')) - self.assertEquals(b'\xaa\xaa\xaa\xaa', f('170.170.170.170')) - self.assertEquals(b'\x01\x02\x03\x04', f('1.2.3.4')) - self.assertEquals(b'\xff\xff\xff\xff', f('255.255.255.255')) + self.assertEqual(b'\x00\x00\x00\x00', f('0.0.0.0')) + self.assertEqual(b'\xff\x00\xff\x00', f('255.0.255.0')) + self.assertEqual(b'\xaa\xaa\xaa\xaa', f('170.170.170.170')) + self.assertEqual(b'\x01\x02\x03\x04', f('1.2.3.4')) + self.assertEqual(b'\xff\xff\xff\xff', f('255.255.255.255')) - self.assertEquals(b'\x00\x00\x00\x00', g('0.0.0.0')) - self.assertEquals(b'\xff\x00\xff\x00', g('255.0.255.0')) - self.assertEquals(b'\xaa\xaa\xaa\xaa', g('170.170.170.170')) - self.assertEquals(b'\xff\xff\xff\xff', g('255.255.255.255')) + self.assertEqual(b'\x00\x00\x00\x00', g('0.0.0.0')) + self.assertEqual(b'\xff\x00\xff\x00', g('255.0.255.0')) + self.assertEqual(b'\xaa\xaa\xaa\xaa', g('170.170.170.170')) + self.assertEqual(b'\xff\xff\xff\xff', g('255.255.255.255')) def testIPv6toString(self): if not hasattr(socket, 'inet_pton'): @@ -477,10 +477,10 @@ class GeneralModuleTests(unittest.TestCase): return f = lambda a: inet_pton(AF_INET6, a) - self.assertEquals(b'\x00' * 16, f('::')) - self.assertEquals(b'\x00' * 16, f('0::0')) - self.assertEquals(b'\x00\x01' + b'\x00' * 14, f('1::')) - self.assertEquals( + self.assertEqual(b'\x00' * 16, f('::')) + self.assertEqual(b'\x00' * 16, f('0::0')) + self.assertEqual(b'\x00\x01' + b'\x00' * 14, f('1::')) + self.assertEqual( b'\x45\xef\x76\xcb\x00\x1a\x56\xef\xaf\xeb\x0b\xac\x19\x24\xae\xae', f('45ef:76cb:1a:56ef:afeb:bac:1924:aeae') ) @@ -491,14 +491,14 @@ class GeneralModuleTests(unittest.TestCase): from socket import inet_ntoa as f, inet_ntop, AF_INET g = lambda a: inet_ntop(AF_INET, a) - self.assertEquals('1.0.1.0', f(b'\x01\x00\x01\x00')) - self.assertEquals('170.85.170.85', f(b'\xaa\x55\xaa\x55')) - self.assertEquals('255.255.255.255', f(b'\xff\xff\xff\xff')) - self.assertEquals('1.2.3.4', f(b'\x01\x02\x03\x04')) + self.assertEqual('1.0.1.0', f(b'\x01\x00\x01\x00')) + self.assertEqual('170.85.170.85', f(b'\xaa\x55\xaa\x55')) + self.assertEqual('255.255.255.255', f(b'\xff\xff\xff\xff')) + self.assertEqual('1.2.3.4', f(b'\x01\x02\x03\x04')) - self.assertEquals('1.0.1.0', g(b'\x01\x00\x01\x00')) - self.assertEquals('170.85.170.85', g(b'\xaa\x55\xaa\x55')) - self.assertEquals('255.255.255.255', g(b'\xff\xff\xff\xff')) + self.assertEqual('1.0.1.0', g(b'\x01\x00\x01\x00')) + self.assertEqual('170.85.170.85', g(b'\xaa\x55\xaa\x55')) + self.assertEqual('255.255.255.255', g(b'\xff\xff\xff\xff')) def testStringToIPv6(self): if not hasattr(socket, 'inet_ntop'): @@ -511,9 +511,9 @@ class GeneralModuleTests(unittest.TestCase): return f = lambda a: inet_ntop(AF_INET6, a) - self.assertEquals('::', f(b'\x00' * 16)) - self.assertEquals('::1', f(b'\x00' * 15 + b'\x01')) - self.assertEquals( + self.assertEqual('::', f(b'\x00' * 16)) + self.assertEqual('::1', f(b'\x00' * 15 + b'\x01')) + self.assertEqual( 'aef:b01:506:1001:ffff:9997:55:170', f(b'\x0a\xef\x0b\x01\x05\x06\x10\x01\xff\xff\x99\x97\x00\x55\x01\x70') ) @@ -1226,8 +1226,8 @@ class FileObjectInterruptedTestCase(unittest.TestCase): lambda : b"", # XXX(gps): io library does an extra EOF read ]) fo = mock_sock._textiowrap_for_test(buffering=buffering) - self.assertEquals(fo.readline(size), "This is the first line\n") - self.assertEquals(fo.readline(size), "And the second line is here\n") + self.assertEqual(fo.readline(size), "This is the first line\n") + self.assertEqual(fo.readline(size), "And the second line is here\n") def _test_read(self, size=-1, buffering=-1): mock_sock = self.MockSocket(recv_funcs=[ @@ -1250,7 +1250,7 @@ class FileObjectInterruptedTestCase(unittest.TestCase): if not part: break data += part - self.assertEquals(data, expecting) + self.assertEqual(data, expecting) def test_default(self): self._test_readline() @@ -1274,8 +1274,8 @@ class FileObjectInterruptedTestCase(unittest.TestCase): lambda : b"", ]) fo = mock_sock._textiowrap_for_test(buffering=0) - self.assertEquals(fo.readline(size), b"a\n") - self.assertEquals(fo.readline(size), b"Bb") + self.assertEqual(fo.readline(size), b"a\n") + self.assertEqual(fo.readline(size), b"Bb") def test_no_buffer(self): self._test_readline_no_buffer() @@ -1525,7 +1525,7 @@ class NetworkConnectionAttributesTest(SocketTCPTest, ThreadableTest): self.addCleanup(self.cli.close) finally: socket.setdefaulttimeout(None) - self.assertEquals(self.cli.gettimeout(), 42) + self.assertEqual(self.cli.gettimeout(), 42) testTimeoutNone = _justAccept def _testTimeoutNone(self): diff --git a/Lib/test/test_socketserver.py b/Lib/test/test_socketserver.py index deaeee1..1907800 100644 --- a/Lib/test/test_socketserver.py +++ b/Lib/test/test_socketserver.py @@ -57,8 +57,8 @@ def simple_subprocess(testcase): os._exit(72) yield None pid2, status = os.waitpid(pid, 0) - testcase.assertEquals(pid2, pid) - testcase.assertEquals(72 << 8, status) + testcase.assertEqual(pid2, pid) + testcase.assertEqual(72 << 8, status) @unittest.skipUnless(threading, 'Threading required for this test.') @@ -120,7 +120,7 @@ class SocketServerTest(unittest.TestCase): if verbose: print("creating server") server = MyServer(addr, MyHandler) - self.assertEquals(server.server_address, server.socket.getsockname()) + self.assertEqual(server.server_address, server.socket.getsockname()) return server @unittest.skipUnless(threading, 'Threading required for this test.') @@ -161,7 +161,7 @@ class SocketServerTest(unittest.TestCase): while data and b'\n' not in buf: data = receive(s, 100) buf += data - self.assertEquals(buf, TEST_STR) + self.assertEqual(buf, TEST_STR) s.close() def dgram_examine(self, proto, addr): @@ -171,7 +171,7 @@ class SocketServerTest(unittest.TestCase): while data and b'\n' not in buf: data = receive(s, 100) buf += data - self.assertEquals(buf, TEST_STR) + self.assertEqual(buf, TEST_STR) s.close() def test_TCPServer(self): diff --git a/Lib/test/test_structmembers.py b/Lib/test/test_structmembers.py index 726acd8..18fecc3 100644 --- a/Lib/test/test_structmembers.py +++ b/Lib/test/test_structmembers.py @@ -28,64 +28,64 @@ class ReadWriteTests(unittest.TestCase): def test_bool(self): ts.T_BOOL = True - self.assertEquals(ts.T_BOOL, True) + self.assertEqual(ts.T_BOOL, True) ts.T_BOOL = False - self.assertEquals(ts.T_BOOL, False) + self.assertEqual(ts.T_BOOL, False) self.assertRaises(TypeError, setattr, ts, 'T_BOOL', 1) def test_byte(self): ts.T_BYTE = CHAR_MAX - self.assertEquals(ts.T_BYTE, CHAR_MAX) + self.assertEqual(ts.T_BYTE, CHAR_MAX) ts.T_BYTE = CHAR_MIN - self.assertEquals(ts.T_BYTE, CHAR_MIN) + self.assertEqual(ts.T_BYTE, CHAR_MIN) ts.T_UBYTE = UCHAR_MAX - self.assertEquals(ts.T_UBYTE, UCHAR_MAX) + self.assertEqual(ts.T_UBYTE, UCHAR_MAX) def test_short(self): ts.T_SHORT = SHRT_MAX - self.assertEquals(ts.T_SHORT, SHRT_MAX) + self.assertEqual(ts.T_SHORT, SHRT_MAX) ts.T_SHORT = SHRT_MIN - self.assertEquals(ts.T_SHORT, SHRT_MIN) + self.assertEqual(ts.T_SHORT, SHRT_MIN) ts.T_USHORT = USHRT_MAX - self.assertEquals(ts.T_USHORT, USHRT_MAX) + self.assertEqual(ts.T_USHORT, USHRT_MAX) def test_int(self): ts.T_INT = INT_MAX - self.assertEquals(ts.T_INT, INT_MAX) + self.assertEqual(ts.T_INT, INT_MAX) ts.T_INT = INT_MIN - self.assertEquals(ts.T_INT, INT_MIN) + self.assertEqual(ts.T_INT, INT_MIN) ts.T_UINT = UINT_MAX - self.assertEquals(ts.T_UINT, UINT_MAX) + self.assertEqual(ts.T_UINT, UINT_MAX) def test_long(self): ts.T_LONG = LONG_MAX - self.assertEquals(ts.T_LONG, LONG_MAX) + self.assertEqual(ts.T_LONG, LONG_MAX) ts.T_LONG = LONG_MIN - self.assertEquals(ts.T_LONG, LONG_MIN) + self.assertEqual(ts.T_LONG, LONG_MIN) ts.T_ULONG = ULONG_MAX - self.assertEquals(ts.T_ULONG, ULONG_MAX) + self.assertEqual(ts.T_ULONG, ULONG_MAX) def test_py_ssize_t(self): ts.T_PYSSIZET = PY_SSIZE_T_MAX - self.assertEquals(ts.T_PYSSIZET, PY_SSIZE_T_MAX) + self.assertEqual(ts.T_PYSSIZET, PY_SSIZE_T_MAX) ts.T_PYSSIZET = PY_SSIZE_T_MIN - self.assertEquals(ts.T_PYSSIZET, PY_SSIZE_T_MIN) + self.assertEqual(ts.T_PYSSIZET, PY_SSIZE_T_MIN) @unittest.skipUnless(hasattr(ts, "T_LONGLONG"), "long long not present") def test_longlong(self): ts.T_LONGLONG = LLONG_MAX - self.assertEquals(ts.T_LONGLONG, LLONG_MAX) + self.assertEqual(ts.T_LONGLONG, LLONG_MAX) ts.T_LONGLONG = LLONG_MIN - self.assertEquals(ts.T_LONGLONG, LLONG_MIN) + self.assertEqual(ts.T_LONGLONG, LLONG_MIN) ts.T_ULONGLONG = ULLONG_MAX - self.assertEquals(ts.T_ULONGLONG, ULLONG_MAX) + self.assertEqual(ts.T_ULONGLONG, ULLONG_MAX) ## make sure these will accept a plain int as well as a long ts.T_LONGLONG = 3 - self.assertEquals(ts.T_LONGLONG, 3) + self.assertEqual(ts.T_LONGLONG, 3) ts.T_ULONGLONG = 4 - self.assertEquals(ts.T_ULONGLONG, 4) + self.assertEqual(ts.T_ULONGLONG, 4) def test_bad_assignments(self): integer_attributes = [ @@ -106,7 +106,7 @@ class ReadWriteTests(unittest.TestCase): self.assertRaises(TypeError, setattr, ts, attr, nonint) def test_inplace_string(self): - self.assertEquals(ts.T_STRING_INPLACE, "hi") + self.assertEqual(ts.T_STRING_INPLACE, "hi") self.assertRaises(TypeError, setattr, ts, "T_STRING_INPLACE", "s") self.assertRaises(TypeError, delattr, ts, "T_STRING_INPLACE") diff --git a/Lib/test/test_subprocess.py b/Lib/test/test_subprocess.py index f8ecb4d..d1812e5 100644 --- a/Lib/test/test_subprocess.py +++ b/Lib/test/test_subprocess.py @@ -591,7 +591,7 @@ class ProcessTestCase(BaseTestCase): "[sys.executable, '-c', 'print(\"Hello World!\")'])", 'assert retcode == 0')) output = subprocess.check_output([sys.executable, '-c', code]) - self.assert_(output.startswith(b'Hello World!'), ascii(output)) + self.assertTrue(output.startswith(b'Hello World!'), ascii(output)) def test_handles_closed_on_exception(self): # If CreateProcess exits with an error, ensure the @@ -928,7 +928,7 @@ class POSIXProcessTestCase(BaseTestCase): [sys.executable, "-c", script], env=env) stdout = stdout.rstrip(b'\n\r') - self.assertEquals(stdout.decode('ascii'), ascii(value)) + self.assertEqual(stdout.decode('ascii'), ascii(value)) # test bytes key = key.encode("ascii", "surrogateescape") @@ -940,7 +940,7 @@ class POSIXProcessTestCase(BaseTestCase): [sys.executable, "-c", script], env=env) stdout = stdout.rstrip(b'\n\r') - self.assertEquals(stdout.decode('ascii'), ascii(value)) + self.assertEqual(stdout.decode('ascii'), ascii(value)) def test_bytes_program(self): abs_program = os.fsencode(sys.executable) @@ -949,19 +949,19 @@ class POSIXProcessTestCase(BaseTestCase): # absolute bytes path exitcode = subprocess.call([abs_program, "-c", "pass"]) - self.assertEquals(exitcode, 0) + self.assertEqual(exitcode, 0) # bytes program, unicode PATH env = os.environ.copy() env["PATH"] = path exitcode = subprocess.call([program, "-c", "pass"], env=env) - self.assertEquals(exitcode, 0) + self.assertEqual(exitcode, 0) # bytes program, bytes PATH envb = os.environb.copy() envb[b"PATH"] = os.fsencode(path) exitcode = subprocess.call([program, "-c", "pass"], env=envb) - self.assertEquals(exitcode, 0) + self.assertEqual(exitcode, 0) @unittest.skipUnless(mswindows, "Windows specific tests") diff --git a/Lib/test/test_sys.py b/Lib/test/test_sys.py index a5c9115..21f0edc 100644 --- a/Lib/test/test_sys.py +++ b/Lib/test/test_sys.py @@ -93,7 +93,7 @@ class SysModuleTest(unittest.TestCase): try: sys.exit(0) except SystemExit as exc: - self.assertEquals(exc.code, 0) + self.assertEqual(exc.code, 0) except: self.fail("wrong exception") else: @@ -104,7 +104,7 @@ class SysModuleTest(unittest.TestCase): try: sys.exit(42) except SystemExit as exc: - self.assertEquals(exc.code, 42) + self.assertEqual(exc.code, 42) except: self.fail("wrong exception") else: @@ -114,7 +114,7 @@ class SysModuleTest(unittest.TestCase): try: sys.exit((42,)) except SystemExit as exc: - self.assertEquals(exc.code, 42) + self.assertEqual(exc.code, 42) except: self.fail("wrong exception") else: @@ -124,7 +124,7 @@ class SysModuleTest(unittest.TestCase): try: sys.exit("exit") except SystemExit as exc: - self.assertEquals(exc.code, "exit") + self.assertEqual(exc.code, "exit") except: self.fail("wrong exception") else: @@ -134,7 +134,7 @@ class SysModuleTest(unittest.TestCase): try: sys.exit((17, 23)) except SystemExit as exc: - self.assertEquals(exc.code, (17, 23)) + self.assertEqual(exc.code, (17, 23)) except: self.fail("wrong exception") else: @@ -188,7 +188,7 @@ class SysModuleTest(unittest.TestCase): orig = sys.getcheckinterval() for n in 0, 100, 120, orig: # orig last to restore starting state sys.setcheckinterval(n) - self.assertEquals(sys.getcheckinterval(), n) + self.assertEqual(sys.getcheckinterval(), n) @unittest.skipUnless(threading, 'Threading required for this test.') def test_switchinterval(self): @@ -202,7 +202,7 @@ class SysModuleTest(unittest.TestCase): try: for n in 0.00001, 0.05, 3.0, orig: sys.setswitchinterval(n) - self.assertAlmostEquals(sys.getswitchinterval(), n) + self.assertAlmostEqual(sys.getswitchinterval(), n) finally: sys.setswitchinterval(orig) diff --git a/Lib/test/test_sysconfig.py b/Lib/test/test_sysconfig.py index 241f365..193b5f0 100644 --- a/Lib/test/test_sysconfig.py +++ b/Lib/test/test_sysconfig.py @@ -88,7 +88,7 @@ class TestSysConfig(unittest.TestCase): shutil.rmtree(path) def test_get_path_names(self): - self.assertEquals(get_path_names(), sysconfig._SCHEME_KEYS) + self.assertEqual(get_path_names(), sysconfig._SCHEME_KEYS) def test_get_paths(self): scheme = get_paths() @@ -98,7 +98,7 @@ class TestSysConfig(unittest.TestCase): wanted.sort() scheme = list(scheme.items()) scheme.sort() - self.assertEquals(scheme, wanted) + self.assertEqual(scheme, wanted) def test_get_path(self): # xxx make real tests here @@ -117,21 +117,21 @@ class TestSysConfig(unittest.TestCase): sys.version = ('2.4.4 (#71, Oct 18 2006, 08:34:43) ' '[MSC v.1310 32 bit (Intel)]') sys.platform = 'win32' - self.assertEquals(get_platform(), 'win32') + self.assertEqual(get_platform(), 'win32') # windows XP, amd64 os.name = 'nt' sys.version = ('2.4.4 (#71, Oct 18 2006, 08:34:43) ' '[MSC v.1310 32 bit (Amd64)]') sys.platform = 'win32' - self.assertEquals(get_platform(), 'win-amd64') + self.assertEqual(get_platform(), 'win-amd64') # windows XP, itanium os.name = 'nt' sys.version = ('2.4.4 (#71, Oct 18 2006, 08:34:43) ' '[MSC v.1310 32 bit (Itanium)]') sys.platform = 'win32' - self.assertEquals(get_platform(), 'win-ia64') + self.assertEqual(get_platform(), 'win-ia64') # macbook os.name = 'posix' @@ -150,9 +150,9 @@ class TestSysConfig(unittest.TestCase): maxint = sys.maxsize try: sys.maxsize = 2147483647 - self.assertEquals(get_platform(), 'macosx-10.3-ppc') + self.assertEqual(get_platform(), 'macosx-10.3-ppc') sys.maxsize = 9223372036854775807 - self.assertEquals(get_platform(), 'macosx-10.3-ppc64') + self.assertEqual(get_platform(), 'macosx-10.3-ppc64') finally: sys.maxsize = maxint @@ -169,9 +169,9 @@ class TestSysConfig(unittest.TestCase): maxint = sys.maxsize try: sys.maxsize = 2147483647 - self.assertEquals(get_platform(), 'macosx-10.3-i386') + self.assertEqual(get_platform(), 'macosx-10.3-i386') sys.maxsize = 9223372036854775807 - self.assertEquals(get_platform(), 'macosx-10.3-x86_64') + self.assertEqual(get_platform(), 'macosx-10.3-x86_64') finally: sys.maxsize = maxint @@ -182,33 +182,33 @@ class TestSysConfig(unittest.TestCase): '-fno-strict-aliasing -fno-common ' '-dynamic -DNDEBUG -g -O3') - self.assertEquals(get_platform(), 'macosx-10.4-fat') + self.assertEqual(get_platform(), 'macosx-10.4-fat') get_config_vars()['CFLAGS'] = ('-arch x86_64 -arch i386 -isysroot ' '/Developer/SDKs/MacOSX10.4u.sdk ' '-fno-strict-aliasing -fno-common ' '-dynamic -DNDEBUG -g -O3') - self.assertEquals(get_platform(), 'macosx-10.4-intel') + self.assertEqual(get_platform(), 'macosx-10.4-intel') get_config_vars()['CFLAGS'] = ('-arch x86_64 -arch ppc -arch i386 -isysroot ' '/Developer/SDKs/MacOSX10.4u.sdk ' '-fno-strict-aliasing -fno-common ' '-dynamic -DNDEBUG -g -O3') - self.assertEquals(get_platform(), 'macosx-10.4-fat3') + self.assertEqual(get_platform(), 'macosx-10.4-fat3') get_config_vars()['CFLAGS'] = ('-arch ppc64 -arch x86_64 -arch ppc -arch i386 -isysroot ' '/Developer/SDKs/MacOSX10.4u.sdk ' '-fno-strict-aliasing -fno-common ' '-dynamic -DNDEBUG -g -O3') - self.assertEquals(get_platform(), 'macosx-10.4-universal') + self.assertEqual(get_platform(), 'macosx-10.4-universal') get_config_vars()['CFLAGS'] = ('-arch x86_64 -arch ppc64 -isysroot ' '/Developer/SDKs/MacOSX10.4u.sdk ' '-fno-strict-aliasing -fno-common ' '-dynamic -DNDEBUG -g -O3') - self.assertEquals(get_platform(), 'macosx-10.4-fat64') + self.assertEqual(get_platform(), 'macosx-10.4-fat64') for arch in ('ppc', 'i386', 'x86_64', 'ppc64'): get_config_vars()['CFLAGS'] = ('-arch %s -isysroot ' @@ -216,7 +216,7 @@ class TestSysConfig(unittest.TestCase): '-fno-strict-aliasing -fno-common ' '-dynamic -DNDEBUG -g -O3'%(arch,)) - self.assertEquals(get_platform(), 'macosx-10.4-%s'%(arch,)) + self.assertEqual(get_platform(), 'macosx-10.4-%s'%(arch,)) # linux debian sarge os.name = 'posix' @@ -226,7 +226,7 @@ class TestSysConfig(unittest.TestCase): self._set_uname(('Linux', 'aglae', '2.6.21.1dedibox-r7', '#1 Mon Apr 30 17:25:38 CEST 2007', 'i686')) - self.assertEquals(get_platform(), 'linux-i686') + self.assertEqual(get_platform(), 'linux-i686') # XXX more platforms to tests here @@ -243,7 +243,7 @@ class TestSysConfig(unittest.TestCase): def test_get_scheme_names(self): wanted = ('nt', 'nt_user', 'os2', 'os2_home', 'osx_framework_user', 'posix_home', 'posix_prefix', 'posix_user') - self.assertEquals(get_scheme_names(), wanted) + self.assertEqual(get_scheme_names(), wanted) @skip_unless_symlink def test_symlink(self): @@ -275,7 +275,7 @@ class TestSysConfig(unittest.TestCase): for name in ('stdlib', 'platstdlib', 'purelib', 'platlib'): global_path = get_path(name, 'posix_prefix') user_path = get_path(name, 'posix_user') - self.assertEquals(user_path, global_path.replace(base, user)) + self.assertEqual(user_path, global_path.replace(base, user)) def test_main(self): # just making sure _main() runs and returns things in the stdout diff --git a/Lib/test/test_tarfile.py b/Lib/test/test_tarfile.py index 0605139..ff02c69 100644 --- a/Lib/test/test_tarfile.py +++ b/Lib/test/test_tarfile.py @@ -1000,7 +1000,7 @@ class WriteTest(WriteTestBase): tar = tarfile.open(tmpname, "r") try: for t in tar: - self.assert_(t.name == "." or t.name.startswith("./")) + self.assertTrue(t.name == "." or t.name.startswith("./")) finally: tar.close() finally: diff --git a/Lib/test/test_tempfile.py b/Lib/test/test_tempfile.py index 03e9a46..802db1f 100644 --- a/Lib/test/test_tempfile.py +++ b/Lib/test/test_tempfile.py @@ -319,7 +319,7 @@ class test__mkstemp_inner(TC): f.write(b"blat\x1a") f.write(b"extra\n") os.lseek(f.fd, 0, os.SEEK_SET) - self.assertEquals(os.read(f.fd, 20), b"blat") + self.assertEqual(os.read(f.fd, 20), b"blat") test_classes.append(test__mkstemp_inner) @@ -879,7 +879,7 @@ class test_TemporaryFile(TC): with tempfile.TemporaryFile(*args, **kwargs) as fileobj: fileobj.write(input) fileobj.seek(0) - self.assertEquals(input, fileobj.read()) + self.assertEqual(input, fileobj.read()) roundtrip(b"1234", "w+b") roundtrip("abdc\n", "w+") diff --git a/Lib/test/test_textwrap.py b/Lib/test/test_textwrap.py index ffd59c3..905dd4c 100644 --- a/Lib/test/test_textwrap.py +++ b/Lib/test/test_textwrap.py @@ -29,7 +29,7 @@ class BaseTestCase(unittest.TestCase): def check(self, result, expect): - self.assertEquals(result, expect, + self.assertEqual(result, expect, 'expected:\n%s\nbut got:\n%s' % ( self.show(expect), self.show(result))) @@ -39,9 +39,9 @@ class BaseTestCase(unittest.TestCase): def check_split(self, text, expect): result = self.wrapper._split(text) - self.assertEquals(result, expect, - "\nexpected %r\n" - "but got %r" % (expect, result)) + self.assertEqual(result, expect, + "\nexpected %r\n" + "but got %r" % (expect, result)) class WrapTestCase(BaseTestCase): @@ -490,7 +490,7 @@ class DedentTestCase(unittest.TestCase): def assertUnchanged(self, text): """assert that dedent() has no effect on 'text'""" - self.assertEquals(text, dedent(text)) + self.assertEqual(text, dedent(text)) def test_dedent_nomargin(self): # No lines indented. @@ -513,17 +513,17 @@ class DedentTestCase(unittest.TestCase): # All lines indented by two spaces. text = " Hello there.\n How are ya?\n Oh good." expect = "Hello there.\nHow are ya?\nOh good." - self.assertEquals(expect, dedent(text)) + self.assertEqual(expect, dedent(text)) # Same, with blank lines. text = " Hello there.\n\n How are ya?\n Oh good.\n" expect = "Hello there.\n\nHow are ya?\nOh good.\n" - self.assertEquals(expect, dedent(text)) + self.assertEqual(expect, dedent(text)) # Now indent one of the blank lines. text = " Hello there.\n \n How are ya?\n Oh good.\n" expect = "Hello there.\n\nHow are ya?\nOh good.\n" - self.assertEquals(expect, dedent(text)) + self.assertEqual(expect, dedent(text)) def test_dedent_uneven(self): # Lines indented unevenly. @@ -537,27 +537,27 @@ def foo(): while 1: return foo ''' - self.assertEquals(expect, dedent(text)) + self.assertEqual(expect, dedent(text)) # Uneven indentation with a blank line. text = " Foo\n Bar\n\n Baz\n" expect = "Foo\n Bar\n\n Baz\n" - self.assertEquals(expect, dedent(text)) + self.assertEqual(expect, dedent(text)) # Uneven indentation with a whitespace-only line. text = " Foo\n Bar\n \n Baz\n" expect = "Foo\n Bar\n\n Baz\n" - self.assertEquals(expect, dedent(text)) + self.assertEqual(expect, dedent(text)) # dedent() should not mangle internal tabs def test_dedent_preserve_internal_tabs(self): text = " hello\tthere\n how are\tyou?" expect = "hello\tthere\nhow are\tyou?" - self.assertEquals(expect, dedent(text)) + self.assertEqual(expect, dedent(text)) # make sure that it preserves tabs when it's not making any # changes at all - self.assertEquals(expect, dedent(expect)) + self.assertEqual(expect, dedent(expect)) # dedent() should not mangle tabs in the margin (i.e. # tabs and spaces both count as margin, but are *not* @@ -573,17 +573,17 @@ def foo(): # dedent() only removes whitespace that can be uniformly removed! text = "\thello there\n\thow are you?" expect = "hello there\nhow are you?" - self.assertEquals(expect, dedent(text)) + self.assertEqual(expect, dedent(text)) text = " \thello there\n \thow are you?" - self.assertEquals(expect, dedent(text)) + self.assertEqual(expect, dedent(text)) text = " \t hello there\n \t how are you?" - self.assertEquals(expect, dedent(text)) + self.assertEqual(expect, dedent(text)) text = " \thello there\n \t how are you?" expect = "hello there\n how are you?" - self.assertEquals(expect, dedent(text)) + self.assertEqual(expect, dedent(text)) def test_main(): diff --git a/Lib/test/test_threadedtempfile.py b/Lib/test/test_threadedtempfile.py index 6386b55..2dfd3a0 100644 --- a/Lib/test/test_threadedtempfile.py +++ b/Lib/test/test_threadedtempfile.py @@ -68,8 +68,8 @@ class ThreadedTempFileTest(unittest.TestCase): msg = "Errors: errors %d ok %d\n%s" % (len(errors), ok, '\n'.join(errors)) - self.assertEquals(errors, [], msg) - self.assertEquals(ok, NUM_THREADS * FILES_PER_THREAD) + self.assertEqual(errors, [], msg) + self.assertEqual(ok, NUM_THREADS * FILES_PER_THREAD) def test_main(): run_unittest(ThreadedTempFileTest) diff --git a/Lib/test/test_threading.py b/Lib/test/test_threading.py index b2a5881..12edf42 100644 --- a/Lib/test/test_threading.py +++ b/Lib/test/test_threading.py @@ -398,17 +398,17 @@ class ThreadTests(BaseTestCase): weak_cyclic_object = weakref.ref(cyclic_object) cyclic_object.thread.join() del cyclic_object - self.assertEquals(None, weak_cyclic_object(), - msg=('%d references still around' % - sys.getrefcount(weak_cyclic_object()))) + self.assertEqual(None, weak_cyclic_object(), + msg=('%d references still around' % + sys.getrefcount(weak_cyclic_object()))) raising_cyclic_object = RunSelfFunction(should_raise=True) weak_raising_cyclic_object = weakref.ref(raising_cyclic_object) raising_cyclic_object.thread.join() del raising_cyclic_object - self.assertEquals(None, weak_raising_cyclic_object(), - msg=('%d references still around' % - sys.getrefcount(weak_raising_cyclic_object()))) + self.assertEqual(None, weak_raising_cyclic_object(), + msg=('%d references still around' % + sys.getrefcount(weak_raising_cyclic_object()))) def test_old_threading_api(self): # Just a quick sanity check to make sure the old method names are diff --git a/Lib/test/test_time.py b/Lib/test/test_time.py index fbf07eb..eaa4e83 100644 --- a/Lib/test/test_time.py +++ b/Lib/test/test_time.py @@ -97,7 +97,7 @@ class TimeTestCase(unittest.TestCase): # based on its value. expected = "2000 01 01 00 00 00 1 001" result = time.strftime("%Y %m %d %H %M %S %w %j", (0,)*9) - self.assertEquals(expected, result) + self.assertEqual(expected, result) def test_strptime(self): # Should be able to go round-trip from strftime to strptime without diff --git a/Lib/test/test_tokenize.py b/Lib/test/test_tokenize.py index da2138a..11e6fb4 100644 --- a/Lib/test/test_tokenize.py +++ b/Lib/test/test_tokenize.py @@ -689,8 +689,8 @@ class Test_Tokenize(TestCase): # skip the initial encoding token and the end token tokens = list(_tokenize(readline, encoding='utf-8'))[1:-1] expected_tokens = [(3, '"ЉЊЈЁЂ"', (1, 0), (1, 7), '"ЉЊЈЁЂ"')] - self.assertEquals(tokens, expected_tokens, - "bytes not decoded with encoding") + self.assertEqual(tokens, expected_tokens, + "bytes not decoded with encoding") def test__tokenize_does_not_decode_with_encoding_none(self): literal = '"ЉЊЈЁЂ"' @@ -706,8 +706,8 @@ class Test_Tokenize(TestCase): # skip the end token tokens = list(_tokenize(readline, encoding=None))[:-1] expected_tokens = [(3, '"ЉЊЈЁЂ"', (1, 0), (1, 7), '"ЉЊЈЁЂ"')] - self.assertEquals(tokens, expected_tokens, - "string not tokenized when encoding is None") + self.assertEqual(tokens, expected_tokens, + "string not tokenized when encoding is None") class TestDetectEncoding(TestCase): @@ -730,8 +730,8 @@ class TestDetectEncoding(TestCase): b'do_something(else)\n' ) encoding, consumed_lines = detect_encoding(self.get_readline(lines)) - self.assertEquals(encoding, 'utf-8') - self.assertEquals(consumed_lines, list(lines[:2])) + self.assertEqual(encoding, 'utf-8') + self.assertEqual(consumed_lines, list(lines[:2])) def test_bom_no_cookie(self): lines = ( @@ -740,9 +740,9 @@ class TestDetectEncoding(TestCase): b'do_something(else)\n' ) encoding, consumed_lines = detect_encoding(self.get_readline(lines)) - self.assertEquals(encoding, 'utf-8-sig') - self.assertEquals(consumed_lines, - [b'# something\n', b'print(something)\n']) + self.assertEqual(encoding, 'utf-8-sig') + self.assertEqual(consumed_lines, + [b'# something\n', b'print(something)\n']) def test_cookie_first_line_no_bom(self): lines = ( @@ -751,8 +751,8 @@ class TestDetectEncoding(TestCase): b'do_something(else)\n' ) encoding, consumed_lines = detect_encoding(self.get_readline(lines)) - self.assertEquals(encoding, 'iso-8859-1') - self.assertEquals(consumed_lines, [b'# -*- coding: latin-1 -*-\n']) + self.assertEqual(encoding, 'iso-8859-1') + self.assertEqual(consumed_lines, [b'# -*- coding: latin-1 -*-\n']) def test_matched_bom_and_cookie_first_line(self): lines = ( @@ -761,8 +761,8 @@ class TestDetectEncoding(TestCase): b'do_something(else)\n' ) encoding, consumed_lines = detect_encoding(self.get_readline(lines)) - self.assertEquals(encoding, 'utf-8-sig') - self.assertEquals(consumed_lines, [b'# coding=utf-8\n']) + self.assertEqual(encoding, 'utf-8-sig') + self.assertEqual(consumed_lines, [b'# coding=utf-8\n']) def test_mismatched_bom_and_cookie_first_line_raises_syntaxerror(self): lines = ( @@ -781,9 +781,9 @@ class TestDetectEncoding(TestCase): b'do_something(else)\n' ) encoding, consumed_lines = detect_encoding(self.get_readline(lines)) - self.assertEquals(encoding, 'ascii') + self.assertEqual(encoding, 'ascii') expected = [b'#! something\n', b'# vim: set fileencoding=ascii :\n'] - self.assertEquals(consumed_lines, expected) + self.assertEqual(consumed_lines, expected) def test_matched_bom_and_cookie_second_line(self): lines = ( @@ -793,9 +793,9 @@ class TestDetectEncoding(TestCase): b'do_something(else)\n' ) encoding, consumed_lines = detect_encoding(self.get_readline(lines)) - self.assertEquals(encoding, 'utf-8-sig') - self.assertEquals(consumed_lines, - [b'#! something\n', b'f# coding=utf-8\n']) + self.assertEqual(encoding, 'utf-8-sig') + self.assertEqual(consumed_lines, + [b'#! something\n', b'f# coding=utf-8\n']) def test_mismatched_bom_and_cookie_second_line_raises_syntaxerror(self): lines = ( @@ -820,7 +820,7 @@ class TestDetectEncoding(TestCase): b"do_something += 4\n") rl = self.get_readline(lines) found, consumed_lines = detect_encoding(rl) - self.assertEquals(found, "iso-8859-1") + self.assertEqual(found, "iso-8859-1") def test_utf8_normalization(self): # See get_normal_name() in tokenizer.c. @@ -833,27 +833,27 @@ class TestDetectEncoding(TestCase): b"1 + 3\n") rl = self.get_readline(lines) found, consumed_lines = detect_encoding(rl) - self.assertEquals(found, "utf-8") + self.assertEqual(found, "utf-8") def test_short_files(self): readline = self.get_readline((b'print(something)\n',)) encoding, consumed_lines = detect_encoding(readline) - self.assertEquals(encoding, 'utf-8') - self.assertEquals(consumed_lines, [b'print(something)\n']) + self.assertEqual(encoding, 'utf-8') + self.assertEqual(consumed_lines, [b'print(something)\n']) encoding, consumed_lines = detect_encoding(self.get_readline(())) - self.assertEquals(encoding, 'utf-8') - self.assertEquals(consumed_lines, []) + self.assertEqual(encoding, 'utf-8') + self.assertEqual(consumed_lines, []) readline = self.get_readline((b'\xef\xbb\xbfprint(something)\n',)) encoding, consumed_lines = detect_encoding(readline) - self.assertEquals(encoding, 'utf-8-sig') - self.assertEquals(consumed_lines, [b'print(something)\n']) + self.assertEqual(encoding, 'utf-8-sig') + self.assertEqual(consumed_lines, [b'print(something)\n']) readline = self.get_readline((b'\xef\xbb\xbf',)) encoding, consumed_lines = detect_encoding(readline) - self.assertEquals(encoding, 'utf-8-sig') - self.assertEquals(consumed_lines, []) + self.assertEqual(encoding, 'utf-8-sig') + self.assertEqual(consumed_lines, []) readline = self.get_readline((b'# coding: bad\n',)) self.assertRaises(SyntaxError, detect_encoding, readline) @@ -912,7 +912,7 @@ class TestTokenize(TestCase): tokenize_module._tokenize = mock__tokenize try: results = tokenize(mock_readline) - self.assertEquals(list(results), ['first', 'second', 1, 2, 3, 4]) + self.assertEqual(list(results), ['first', 'second', 1, 2, 3, 4]) finally: tokenize_module.detect_encoding = orig_detect_encoding tokenize_module._tokenize = orig__tokenize diff --git a/Lib/test/test_trace.py b/Lib/test/test_trace.py index 1311547..6c1d404 100644 --- a/Lib/test/test_trace.py +++ b/Lib/test/test_trace.py @@ -311,7 +311,7 @@ class TestCoverage(unittest.TestCase): self._coverage(tracer) if os.path.exists(TESTFN): files = os.listdir(TESTFN) - self.assertEquals(files, []) + self.assertEqual(files, []) def test_issue9936(self): tracer = trace.Trace(trace=0, count=1) diff --git a/Lib/test/test_traceback.py b/Lib/test/test_traceback.py index 7567849..4752d37 100644 --- a/Lib/test/test_traceback.py +++ b/Lib/test/test_traceback.py @@ -164,11 +164,11 @@ class TracebackFormatTests(unittest.TestCase): raise Error("unable to create test traceback string") # Make sure that Python and the traceback module format the same thing - self.assertEquals(traceback_fmt, python_fmt) + self.assertEqual(traceback_fmt, python_fmt) # Make sure that the traceback is properly indented. tb_lines = python_fmt.splitlines() - self.assertEquals(len(tb_lines), 3) + self.assertEqual(len(tb_lines), 3) banner, location, source_line = tb_lines self.assertTrue(banner.startswith('Traceback')) self.assertTrue(location.startswith(' File')) @@ -212,7 +212,7 @@ class BaseExceptionReportingTests: except ZeroDivisionError as _: e = _ lines = self.get_report(e).splitlines() - self.assertEquals(len(lines), 4) + self.assertEqual(len(lines), 4) self.assertTrue(lines[0].startswith('Traceback')) self.assertTrue(lines[1].startswith(' File')) self.assertIn('1/0 # Marker', lines[2]) @@ -227,8 +227,8 @@ class BaseExceptionReportingTests: def outer_raise(): inner_raise() # Marker blocks = boundaries.split(self.get_report(outer_raise)) - self.assertEquals(len(blocks), 3) - self.assertEquals(blocks[1], cause_message) + self.assertEqual(len(blocks), 3) + self.assertEqual(blocks[1], cause_message) self.check_zero_div(blocks[0]) self.assertIn('inner_raise() # Marker', blocks[2]) @@ -241,8 +241,8 @@ class BaseExceptionReportingTests: def outer_raise(): inner_raise() # Marker blocks = boundaries.split(self.get_report(outer_raise)) - self.assertEquals(len(blocks), 3) - self.assertEquals(blocks[1], context_message) + self.assertEqual(len(blocks), 3) + self.assertEqual(blocks[1], context_message) self.check_zero_div(blocks[0]) self.assertIn('inner_raise() # Marker', blocks[2]) @@ -261,8 +261,8 @@ class BaseExceptionReportingTests: def outer_raise(): inner_raise() # Marker blocks = boundaries.split(self.get_report(outer_raise)) - self.assertEquals(len(blocks), 3) - self.assertEquals(blocks[1], cause_message) + self.assertEqual(len(blocks), 3) + self.assertEqual(blocks[1], cause_message) self.check_zero_div(blocks[0]) self.assertIn('inner_raise() # Marker', blocks[2]) @@ -279,8 +279,8 @@ class BaseExceptionReportingTests: def outer_raise(): inner_raise() # Marker blocks = boundaries.split(self.get_report(outer_raise)) - self.assertEquals(len(blocks), 3) - self.assertEquals(blocks[1], cause_message) + self.assertEqual(len(blocks), 3) + self.assertEqual(blocks[1], cause_message) # The first block is the KeyError raised from the ZeroDivisionError self.assertIn('raise KeyError from e', blocks[0]) self.assertNotIn('1/0', blocks[0]) @@ -313,7 +313,7 @@ class PyExcReportingTests(BaseExceptionReportingTests, unittest.TestCase): traceback.format_exception(type(e), e, e.__traceback__)) with captured_output("stderr") as sio: traceback.print_exception(type(e), e, e.__traceback__) - self.assertEquals(sio.getvalue(), s) + self.assertEqual(sio.getvalue(), s) return s diff --git a/Lib/test/test_unicode.py b/Lib/test/test_unicode.py index b2794fd..8f50800 100644 --- a/Lib/test/test_unicode.py +++ b/Lib/test/test_unicode.py @@ -1442,24 +1442,24 @@ class UnicodeTest(string_tests.CommonTest, from ctypes import c_wchar, sizeof wchar, size = unicode_aswidechar('abcdef', 2) - self.assertEquals(size, 2) - self.assertEquals(wchar, 'ab') + self.assertEqual(size, 2) + self.assertEqual(wchar, 'ab') wchar, size = unicode_aswidechar('abc', 3) - self.assertEquals(size, 3) - self.assertEquals(wchar, 'abc') + self.assertEqual(size, 3) + self.assertEqual(wchar, 'abc') wchar, size = unicode_aswidechar('abc', 4) - self.assertEquals(size, 3) - self.assertEquals(wchar, 'abc\0') + self.assertEqual(size, 3) + self.assertEqual(wchar, 'abc\0') wchar, size = unicode_aswidechar('abc', 10) - self.assertEquals(size, 3) - self.assertEquals(wchar, 'abc\0') + self.assertEqual(size, 3) + self.assertEqual(wchar, 'abc\0') wchar, size = unicode_aswidechar('abc\0def', 20) - self.assertEquals(size, 7) - self.assertEquals(wchar, 'abc\0def\0') + self.assertEqual(size, 7) + self.assertEqual(wchar, 'abc\0def\0') nonbmp = chr(0x10ffff) if sizeof(c_wchar) == 2: @@ -1469,8 +1469,8 @@ class UnicodeTest(string_tests.CommonTest, buflen = 2 nchar = 1 wchar, size = unicode_aswidechar(nonbmp, buflen) - self.assertEquals(size, nchar) - self.assertEquals(wchar, nonbmp + '\0') + self.assertEqual(size, nchar) + self.assertEqual(wchar, nonbmp + '\0') # Test PyUnicode_AsWideCharString() def test_aswidecharstring(self): @@ -1478,12 +1478,12 @@ class UnicodeTest(string_tests.CommonTest, from ctypes import c_wchar, sizeof wchar, size = unicode_aswidecharstring('abc') - self.assertEquals(size, 3) - self.assertEquals(wchar, 'abc\0') + self.assertEqual(size, 3) + self.assertEqual(wchar, 'abc\0') wchar, size = unicode_aswidecharstring('abc\0def') - self.assertEquals(size, 7) - self.assertEquals(wchar, 'abc\0def\0') + self.assertEqual(size, 7) + self.assertEqual(wchar, 'abc\0def\0') nonbmp = chr(0x10ffff) if sizeof(c_wchar) == 2: @@ -1491,8 +1491,8 @@ class UnicodeTest(string_tests.CommonTest, else: # sizeof(c_wchar) == 4 nchar = 1 wchar, size = unicode_aswidecharstring(nonbmp) - self.assertEquals(size, nchar) - self.assertEquals(wchar, nonbmp + '\0') + self.assertEqual(size, nchar) + self.assertEqual(wchar, nonbmp + '\0') def test_main(): diff --git a/Lib/test/test_unicodedata.py b/Lib/test/test_unicodedata.py index 209b3e0..1cb36fe 100644 --- a/Lib/test/test_unicodedata.py +++ b/Lib/test/test_unicodedata.py @@ -254,7 +254,7 @@ class UnicodeMiscTest(UnicodeDatabaseTest): self.assertTrue(count >= 10) # should have tested at least the ASCII digits def test_bug_1704793(self): - self.assertEquals(self.db.lookup("GOTHIC LETTER FAIHU"), '\U00010346') + self.assertEqual(self.db.lookup("GOTHIC LETTER FAIHU"), '\U00010346') def test_ucd_510(self): import unicodedata diff --git a/Lib/test/test_warnings.py b/Lib/test/test_warnings.py index 111ff79..2ce7764 100644 --- a/Lib/test/test_warnings.py +++ b/Lib/test/test_warnings.py @@ -80,7 +80,7 @@ class FilterTests(object): self.module.resetwarnings() self.module.filterwarnings("ignore", category=UserWarning) self.module.warn("FilterTests.test_ignore", UserWarning) - self.assertEquals(len(w), 0) + self.assertEqual(len(w), 0) def test_always(self): with original_warnings.catch_warnings(record=True, @@ -102,10 +102,10 @@ class FilterTests(object): for x in range(2): self.module.warn(message, UserWarning) if x == 0: - self.assertEquals(w[-1].message, message) + self.assertEqual(w[-1].message, message) del w[:] elif x == 1: - self.assertEquals(len(w), 0) + self.assertEqual(len(w), 0) else: raise ValueError("loop variant unhandled") @@ -116,10 +116,10 @@ class FilterTests(object): self.module.filterwarnings("module", category=UserWarning) message = UserWarning("FilterTests.test_module") self.module.warn(message, UserWarning) - self.assertEquals(w[-1].message, message) + self.assertEqual(w[-1].message, message) del w[:] self.module.warn(message, UserWarning) - self.assertEquals(len(w), 0) + self.assertEqual(len(w), 0) def test_once(self): with original_warnings.catch_warnings(record=True, @@ -129,14 +129,14 @@ class FilterTests(object): message = UserWarning("FilterTests.test_once") self.module.warn_explicit(message, UserWarning, "test_warnings.py", 42) - self.assertEquals(w[-1].message, message) + self.assertEqual(w[-1].message, message) del w[:] self.module.warn_explicit(message, UserWarning, "test_warnings.py", 13) - self.assertEquals(len(w), 0) + self.assertEqual(len(w), 0) self.module.warn_explicit(message, UserWarning, "test_warnings2.py", 42) - self.assertEquals(len(w), 0) + self.assertEqual(len(w), 0) def test_inheritance(self): with original_warnings.catch_warnings(module=self.module) as w: @@ -157,7 +157,7 @@ class FilterTests(object): self.module.warn("FilterTests.test_ordering", UserWarning) except UserWarning: self.fail("order handling for actions failed") - self.assertEquals(len(w), 0) + self.assertEqual(len(w), 0) def test_filterwarnings(self): # Test filterwarnings(). @@ -217,7 +217,7 @@ class WarnTests(unittest.TestCase): self.module.warn(ob) # Don't directly compare objects since # ``Warning() != Warning()``. - self.assertEquals(str(w[-1].message), str(UserWarning(ob))) + self.assertEqual(str(w[-1].message), str(UserWarning(ob))) def test_filename(self): with warnings_state(self.module): @@ -448,7 +448,7 @@ class _WarningsTests(BaseTest): self.assertEqual(w[-1].message, message) del w[:] self.module.warn_explicit(message, UserWarning, "file", 42) - self.assertEquals(len(w), 0) + self.assertEqual(len(w), 0) # Test the resetting of onceregistry. self.module.onceregistry = {} __warningregistry__ = {} @@ -459,7 +459,7 @@ class _WarningsTests(BaseTest): del self.module.onceregistry __warningregistry__ = {} self.module.warn_explicit(message, UserWarning, "file", 42) - self.assertEquals(len(w), 0) + self.assertEqual(len(w), 0) finally: self.module.onceregistry = original_registry diff --git a/Lib/test/test_winreg.py b/Lib/test/test_winreg.py index b4524db..b6b23c8 100644 --- a/Lib/test/test_winreg.py +++ b/Lib/test/test_winreg.py @@ -82,12 +82,12 @@ class BaseWinregTests(unittest.TestCase): # Check we wrote as many items as we thought. nkeys, nvalues, since_mod = QueryInfoKey(key) - self.assertEquals(nkeys, 1, "Not the correct number of sub keys") - self.assertEquals(nvalues, 1, "Not the correct number of values") + self.assertEqual(nkeys, 1, "Not the correct number of sub keys") + self.assertEqual(nvalues, 1, "Not the correct number of values") nkeys, nvalues, since_mod = QueryInfoKey(sub_key) - self.assertEquals(nkeys, 0, "Not the correct number of sub keys") - self.assertEquals(nvalues, len(test_data), - "Not the correct number of values") + self.assertEqual(nkeys, 0, "Not the correct number of sub keys") + self.assertEqual(nvalues, len(test_data), + "Not the correct number of values") # Close this key this way... # (but before we do, copy the key as an integer - this allows # us to test that the key really gets closed). @@ -112,8 +112,8 @@ class BaseWinregTests(unittest.TestCase): def _read_test_data(self, root_key, subkeystr="sub_key", OpenKey=OpenKey): # Check we can get default value for this key. val = QueryValue(root_key, test_key_name) - self.assertEquals(val, "Default value", - "Registry didn't give back the correct value") + self.assertEqual(val, "Default value", + "Registry didn't give back the correct value") key = OpenKey(root_key, test_key_name) # Read the sub-keys @@ -125,22 +125,22 @@ class BaseWinregTests(unittest.TestCase): data = EnumValue(sub_key, index) except EnvironmentError: break - self.assertEquals(data in test_data, True, - "Didn't read back the correct test data") + self.assertEqual(data in test_data, True, + "Didn't read back the correct test data") index = index + 1 - self.assertEquals(index, len(test_data), - "Didn't read the correct number of items") + self.assertEqual(index, len(test_data), + "Didn't read the correct number of items") # Check I can directly access each item for value_name, value_data, value_type in test_data: read_val, read_typ = QueryValueEx(sub_key, value_name) - self.assertEquals(read_val, value_data, - "Could not directly read the value") - self.assertEquals(read_typ, value_type, - "Could not directly read the value") + self.assertEqual(read_val, value_data, + "Could not directly read the value") + self.assertEqual(read_typ, value_type, + "Could not directly read the value") sub_key.Close() # Enumerate our main key. read_val = EnumKey(key, 0) - self.assertEquals(read_val, subkeystr, "Read subkey value wrong") + self.assertEqual(read_val, subkeystr, "Read subkey value wrong") try: EnumKey(key, 1) self.fail("Was able to get a second key when I only have one!") @@ -159,8 +159,8 @@ class BaseWinregTests(unittest.TestCase): DeleteValue(sub_key, value_name) nkeys, nvalues, since_mod = QueryInfoKey(sub_key) - self.assertEquals(nkeys, 0, "subkey not empty before delete") - self.assertEquals(nvalues, 0, "subkey not empty before delete") + self.assertEqual(nkeys, 0, "subkey not empty before delete") + self.assertEqual(nvalues, 0, "subkey not empty before delete") sub_key.Close() DeleteKey(key, subkeystr) @@ -341,8 +341,8 @@ class Win64WinregTests(BaseWinregTests): with OpenKey(HKEY_LOCAL_MACHINE, "Software") as key: # HKLM\Software is redirected but not reflected in all OSes self.assertTrue(QueryReflectionKey(key)) - self.assertEquals(None, EnableReflectionKey(key)) - self.assertEquals(None, DisableReflectionKey(key)) + self.assertEqual(None, EnableReflectionKey(key)) + self.assertEqual(None, DisableReflectionKey(key)) self.assertTrue(QueryReflectionKey(key)) @unittest.skipUnless(HAS_REFLECTION, "OS doesn't support reflection") diff --git a/Lib/test/test_with.py b/Lib/test/test_with.py index 74b5f19..d6308e4 100644 --- a/Lib/test/test_with.py +++ b/Lib/test/test_with.py @@ -734,10 +734,10 @@ class NestedWith(unittest.TestCase): def testEnterReturnsTuple(self): with self.Dummy(value=(1,2)) as (a1, a2), \ self.Dummy(value=(10, 20)) as (b1, b2): - self.assertEquals(1, a1) - self.assertEquals(2, a2) - self.assertEquals(10, b1) - self.assertEquals(20, b2) + self.assertEqual(1, a1) + self.assertEqual(2, a2) + self.assertEqual(10, b1) + self.assertEqual(20, b2) def test_main(): run_unittest(FailureTestCase, NonexceptionalTestCase, diff --git a/Lib/test/test_xmlrpc.py b/Lib/test/test_xmlrpc.py index 6fe8224..ca8db86 100644 --- a/Lib/test/test_xmlrpc.py +++ b/Lib/test/test_xmlrpc.py @@ -39,7 +39,7 @@ class XMLRPCTestCase(unittest.TestCase): def test_dump_load(self): dump = xmlrpclib.dumps((alist,)) load = xmlrpclib.loads(dump) - self.assertEquals(alist, load[0][0]) + self.assertEqual(alist, load[0][0]) def test_dump_bare_datetime(self): # This checks that an unwrapped datetime.date object can be handled @@ -49,22 +49,22 @@ class XMLRPCTestCase(unittest.TestCase): dt = datetime.datetime(2005, 2, 10, 11, 41, 23) s = xmlrpclib.dumps((dt,)) (newdt,), m = xmlrpclib.loads(s, use_datetime=1) - self.assertEquals(newdt, dt) - self.assertEquals(m, None) + self.assertEqual(newdt, dt) + self.assertEqual(m, None) (newdt,), m = xmlrpclib.loads(s, use_datetime=0) - self.assertEquals(newdt, xmlrpclib.DateTime('20050210T11:41:23')) + self.assertEqual(newdt, xmlrpclib.DateTime('20050210T11:41:23')) def test_datetime_before_1900(self): # same as before but with a date before 1900 dt = datetime.datetime(1, 2, 10, 11, 41, 23) s = xmlrpclib.dumps((dt,)) (newdt,), m = xmlrpclib.loads(s, use_datetime=1) - self.assertEquals(newdt, dt) - self.assertEquals(m, None) + self.assertEqual(newdt, dt) + self.assertEqual(m, None) (newdt,), m = xmlrpclib.loads(s, use_datetime=0) - self.assertEquals(newdt, xmlrpclib.DateTime('00010210T11:41:23')) + self.assertEqual(newdt, xmlrpclib.DateTime('00010210T11:41:23')) def test_cmp_datetime_DateTime(self): now = datetime.datetime.now() @@ -92,7 +92,7 @@ class XMLRPCTestCase(unittest.TestCase): t.x = 100 t.y = "Hello" ((t2,), dummy) = xmlrpclib.loads(xmlrpclib.dumps((t,))) - self.assertEquals(t2, t.__dict__) + self.assertEqual(t2, t.__dict__) def test_dump_big_long(self): self.assertRaises(OverflowError, xmlrpclib.dumps, (2**99,)) @@ -138,14 +138,14 @@ class XMLRPCTestCase(unittest.TestCase): value = alist + [None] arg1 = (alist + [None],) strg = xmlrpclib.dumps(arg1, allow_none=True) - self.assertEquals(value, + self.assertEqual(value, xmlrpclib.loads(strg)[0][0]) self.assertRaises(TypeError, xmlrpclib.dumps, (arg1,)) def test_get_host_info(self): # see bug #3613, this raised a TypeError transp = xmlrpc.client.Transport() - self.assertEquals(transp.get_host_info("user@host.tld"), + self.assertEqual(transp.get_host_info("user@host.tld"), ('host.tld', [('Authorization', 'Basic dXNlcg==')], {})) @@ -179,8 +179,8 @@ class FaultTestCase(unittest.TestCase): f = xmlrpclib.Fault(42, 'Test Fault') s = xmlrpclib.dumps((f,)) (newf,), m = xmlrpclib.loads(s) - self.assertEquals(newf, {'faultCode': 42, 'faultString': 'Test Fault'}) - self.assertEquals(m, None) + self.assertEqual(newf, {'faultCode': 42, 'faultString': 'Test Fault'}) + self.assertEqual(m, None) s = xmlrpclib.Marshaller().dumps(f) self.assertRaises(xmlrpclib.Fault, xmlrpclib.loads, s) @@ -918,7 +918,7 @@ class CGIHandlerTestCase(unittest.TestCase): content = handle[handle.find("<?xml"):] - self.assertEquals( + self.assertEqual( int(re.search('Content-Length: (\d+)', handle).group(1)), len(content)) diff --git a/Lib/test/test_zipimport.py b/Lib/test/test_zipimport.py index 838e1b5..090f0f3 100644 --- a/Lib/test/test_zipimport.py +++ b/Lib/test/test_zipimport.py @@ -97,8 +97,8 @@ class UncompressedZipImportTestCase(ImportHooksBaseTestCase): if expected_ext: file = mod.get_file() - self.assertEquals(file, os.path.join(TEMP_ZIP, - *modules) + expected_ext) + self.assertEqual(file, os.path.join(TEMP_ZIP, + *modules) + expected_ext) finally: z.close() os.remove(TEMP_ZIP) @@ -211,32 +211,32 @@ class UncompressedZipImportTestCase(ImportHooksBaseTestCase): z.close() zi = zipimport.zipimporter(TEMP_ZIP) - self.assertEquals(zi.archive, TEMP_ZIP) - self.assertEquals(zi.is_package(TESTPACK), True) + self.assertEqual(zi.archive, TEMP_ZIP) + self.assertEqual(zi.is_package(TESTPACK), True) mod = zi.load_module(TESTPACK) - self.assertEquals(zi.get_filename(TESTPACK), mod.__file__) + self.assertEqual(zi.get_filename(TESTPACK), mod.__file__) - self.assertEquals(zi.is_package(packdir + '__init__'), False) - self.assertEquals(zi.is_package(packdir + TESTPACK2), True) - self.assertEquals(zi.is_package(packdir2 + TESTMOD), False) + self.assertEqual(zi.is_package(packdir + '__init__'), False) + self.assertEqual(zi.is_package(packdir + TESTPACK2), True) + self.assertEqual(zi.is_package(packdir2 + TESTMOD), False) mod_path = packdir2 + TESTMOD mod_name = module_path_to_dotted_name(mod_path) __import__(mod_name) mod = sys.modules[mod_name] - self.assertEquals(zi.get_source(TESTPACK), None) - self.assertEquals(zi.get_source(mod_path), None) - self.assertEquals(zi.get_filename(mod_path), mod.__file__) + self.assertEqual(zi.get_source(TESTPACK), None) + self.assertEqual(zi.get_source(mod_path), None) + self.assertEqual(zi.get_filename(mod_path), mod.__file__) # To pass in the module name instead of the path, we must use the # right importer loader = mod.__loader__ - self.assertEquals(loader.get_source(mod_name), None) - self.assertEquals(loader.get_filename(mod_name), mod.__file__) + self.assertEqual(loader.get_source(mod_name), None) + self.assertEqual(loader.get_filename(mod_name), mod.__file__) # test prefix and archivepath members zi2 = zipimport.zipimporter(TEMP_ZIP + os.sep + TESTPACK) - self.assertEquals(zi2.archive, TEMP_ZIP) - self.assertEquals(zi2.prefix, TESTPACK + os.sep) + self.assertEqual(zi2.archive, TEMP_ZIP) + self.assertEqual(zi2.prefix, TESTPACK + os.sep) finally: z.close() os.remove(TEMP_ZIP) @@ -256,29 +256,29 @@ class UncompressedZipImportTestCase(ImportHooksBaseTestCase): z.close() zi = zipimport.zipimporter(TEMP_ZIP + os.sep + packdir) - self.assertEquals(zi.archive, TEMP_ZIP) - self.assertEquals(zi.prefix, packdir) - self.assertEquals(zi.is_package(TESTPACK2), True) + self.assertEqual(zi.archive, TEMP_ZIP) + self.assertEqual(zi.prefix, packdir) + self.assertEqual(zi.is_package(TESTPACK2), True) mod = zi.load_module(TESTPACK2) - self.assertEquals(zi.get_filename(TESTPACK2), mod.__file__) + self.assertEqual(zi.get_filename(TESTPACK2), mod.__file__) - self.assertEquals( + self.assertEqual( zi.is_package(TESTPACK2 + os.sep + '__init__'), False) - self.assertEquals( + self.assertEqual( zi.is_package(TESTPACK2 + os.sep + TESTMOD), False) mod_path = TESTPACK2 + os.sep + TESTMOD mod_name = module_path_to_dotted_name(mod_path) __import__(mod_name) mod = sys.modules[mod_name] - self.assertEquals(zi.get_source(TESTPACK2), None) - self.assertEquals(zi.get_source(mod_path), None) - self.assertEquals(zi.get_filename(mod_path), mod.__file__) + self.assertEqual(zi.get_source(TESTPACK2), None) + self.assertEqual(zi.get_source(mod_path), None) + self.assertEqual(zi.get_filename(mod_path), mod.__file__) # To pass in the module name instead of the path, we must use the # right importer loader = mod.__loader__ - self.assertEquals(loader.get_source(mod_name), None) - self.assertEquals(loader.get_filename(mod_name), mod.__file__) + self.assertEqual(loader.get_source(mod_name), None) + self.assertEqual(loader.get_filename(mod_name), mod.__file__) finally: z.close() os.remove(TEMP_ZIP) @@ -292,7 +292,7 @@ class UncompressedZipImportTestCase(ImportHooksBaseTestCase): z.writestr(name, data) z.close() zi = zipimport.zipimporter(TEMP_ZIP) - self.assertEquals(data, zi.get_data(name)) + self.assertEqual(data, zi.get_data(name)) self.assertIn('zipimporter object', repr(zi)) finally: z.close() diff --git a/Lib/unittest/case.py b/Lib/unittest/case.py index 1df19dc..68f6715 100644 --- a/Lib/unittest/case.py +++ b/Lib/unittest/case.py @@ -920,8 +920,8 @@ class TestCase(object): self.fail(self._formatMessage(msg, standardMsg)) def assertDictEqual(self, d1, d2, msg=None): - self.assert_(isinstance(d1, dict), 'First argument is not a dictionary') - self.assert_(isinstance(d2, dict), 'Second argument is not a dictionary') + self.assertIsInstance(d1, dict, 'First argument is not a dictionary') + self.assertIsInstance(d2, dict, 'Second argument is not a dictionary') if d1 != d2: standardMsg = '%s != %s' % (safe_repr(d1, True), safe_repr(d2, True)) @@ -1039,10 +1039,8 @@ class TestCase(object): def assertMultiLineEqual(self, first, second, msg=None): """Assert that two multi-line strings are equal.""" - self.assert_(isinstance(first, str), ( - 'First argument is not a string')) - self.assert_(isinstance(second, str), ( - 'Second argument is not a string')) + self.assertIsInstance(first, str, 'First argument is not a string') + self.assertIsInstance(second, str, 'Second argument is not a string') if first != second: firstlines = first.splitlines(True) diff --git a/Lib/unittest/test/test_assertions.py b/Lib/unittest/test/test_assertions.py index 06b1ab8e5..91eb8bf 100644 --- a/Lib/unittest/test/test_assertions.py +++ b/Lib/unittest/test/test_assertions.py @@ -130,11 +130,11 @@ class TestLongMessage(unittest.TestCase): self.assertFalse(unittest.TestCase.longMessage) def test_formatMsg(self): - self.assertEquals(self.testableFalse._formatMessage(None, "foo"), "foo") - self.assertEquals(self.testableFalse._formatMessage("foo", "bar"), "foo") + self.assertEqual(self.testableFalse._formatMessage(None, "foo"), "foo") + self.assertEqual(self.testableFalse._formatMessage("foo", "bar"), "foo") - self.assertEquals(self.testableTrue._formatMessage(None, "foo"), "foo") - self.assertEquals(self.testableTrue._formatMessage("foo", "bar"), "bar : foo") + self.assertEqual(self.testableTrue._formatMessage(None, "foo"), "foo") + self.assertEqual(self.testableTrue._formatMessage("foo", "bar"), "bar : foo") # This blows up if _formatMessage uses string concatenation self.testableTrue._formatMessage(object(), 'foo') diff --git a/Lib/unittest/test/test_loader.py b/Lib/unittest/test/test_loader.py index 7def474..2fa1d50 100644 --- a/Lib/unittest/test/test_loader.py +++ b/Lib/unittest/test/test_loader.py @@ -167,11 +167,11 @@ class Test_TestLoader(unittest.TestCase): loader = unittest.TestLoader() suite = loader.loadTestsFromModule(m) self.assertIsInstance(suite, unittest.TestSuite) - self.assertEquals(load_tests_args, [loader, suite, None]) + self.assertEqual(load_tests_args, [loader, suite, None]) load_tests_args = [] suite = loader.loadTestsFromModule(m, use_load_tests=False) - self.assertEquals(load_tests_args, []) + self.assertEqual(load_tests_args, []) def test_loadTestsFromModule__faulty_load_tests(self): m = types.ModuleType('m') |