Mirror
/
cpython
mirror of https://github.com/python/cpython
4
1
Fork 0
Code Issues Releases Wiki Activity

#9424: Replace deprecated assert* methods in the Python test suite.

This commit is contained in:
Ezio Melotti 2010-11-20 19:04:17 +00:00
parent b8bc439b20
commit b3aedd4862
170 changed files with 2388 additions and 2392 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

36
Lib/ctypes/test/test_keeprefs.py
View File

@ -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):

14
Lib/distutils/tests/test_archive_util.py
View File

@ -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']

4
Lib/distutils/tests/test_bdist.py
View File

@ -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)

2
Lib/distutils/tests/test_bdist_dumb.py
View File

@ -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

14
Lib/distutils/tests/test_build.py
View File

@ -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)

10
Lib/distutils/tests/test_build_clib.py
View File

@ -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)

48
Lib/distutils/tests/test_build_ext.py
View File

@ -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()

14
Lib/distutils/tests/test_check.py
View File

@ -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):

10
Lib/distutils/tests/test_cmd.py
View File

@ -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

6
Lib/distutils/tests/test_config.py
View File

@ -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()

12
Lib/distutils/tests/test_config_cmd.py
View File

@ -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

4
Lib/distutils/tests/test_core.py
View File

@ -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)

32
Lib/distutils/tests/test_cygwinccompiler.py
View File

@ -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) '

4
Lib/distutils/tests/test_dep_util.py
View File

@ -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()

22
Lib/distutils/tests/test_dir_util.py
View File

@ -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)

20
Lib/distutils/tests/test_dist.py
View File

@ -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

16
Lib/distutils/tests/test_extension.py
View File

@ -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():

6
Lib/distutils/tests/test_file_util.py
View File

@ -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():

18
Lib/distutils/tests/test_filelist.py
View File

@ -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

20
Lib/distutils/tests/test_install.py
View File

@ -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()

8
Lib/distutils/tests/test_install_data.py
View File

@ -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)))

4
Lib/distutils/tests/test_install_headers.py
View File

@ -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)

8
Lib/distutils/tests/test_install_lib.py
View File

@ -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

4
Lib/distutils/tests/test_log.py
View File

@ -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

4
Lib/distutils/tests/test_msvc9compiler.py
View File

@ -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():

14
Lib/distutils/tests/test_register.py
View File

@ -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)

34
Lib/distutils/tests/test_sdist.py
View File

@ -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):

2
Lib/distutils/tests/test_spawn.py
View File

@ -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'),

18
Lib/distutils/tests/test_sysconfig.py
View File

@ -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'))

2
Lib/distutils/tests/test_text_file.py
View File

@ -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")

12
Lib/distutils/tests/test_upload.py
View File

@ -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)

62
Lib/distutils/tests/test_util.py
View File

@ -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

20
Lib/distutils/tests/test_version.py
View File

@ -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)

66
Lib/email/test/test_email.py
View File

@ -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')

4
Lib/importlib/test/import_/test___package__.py
View File

@ -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]

6
Lib/importlib/test/import_/test_caching.py
View File

@ -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():

24
Lib/importlib/test/import_/test_fromlist.py
View File

@ -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():

12
Lib/importlib/test/import_/test_meta_path.py
View File

@ -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)

6
Lib/json/tests/test_decode.py
View File

@ -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)

2
Lib/json/tests/test_default.py
View File

@ -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)))

8
Lib/json/tests/test_dump.py
View File

@ -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}')

2
Lib/json/tests/test_encode_basestring_ascii.py
View File

@ -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))

8
Lib/json/tests/test_float.py
View File

@ -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)

10
Lib/json/tests/test_indent.py
View File

@ -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)

2
Lib/json/tests/test_pass1.py
View File

@ -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:

2
Lib/json/tests/test_pass2.py
View File

@ -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))

2
Lib/json/tests/test_pass3.py
View File

@ -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))

2
Lib/json/tests/test_recursion.py
View File

@ -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)

44
Lib/json/tests/test_scanstring.py
View File

@ -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))

6
Lib/json/tests/test_separators.py
View File

@ -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)

4
Lib/json/tests/test_speedups.py
View File

@ -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)

24
Lib/json/tests/test_unicode.py
View File

@ -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")

58
Lib/lib2to3/tests/data/py2_test_grammar.py
View File

@ -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

76
Lib/lib2to3/tests/data/py3_test_grammar.py
View File

@ -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

2
Lib/sqlite3/test/dbapi.py
View File

@ -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):

2
Lib/sqlite3/test/types.py
View File

@ -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):

48
Lib/test/buffer_tests.py
View File

@ -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)

6
Lib/test/fork_wait.py
View File

@ -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()

4
Lib/test/list_tests.py
View File

@ -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"

10
Lib/test/outstanding_bugs.py
View File

@ -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")

2
Lib/test/pickletester.py
View File

@ -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

6
Lib/test/seq_tests.py
View File

@ -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])

22
Lib/test/string_tests.py
View File

@ -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)

8
Lib/test/test__locale.py
View File

@ -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,

18
Lib/test/test_argparse.py
View File

@ -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

8
Lib/test/test_array.py
View File

@ -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

20
Lib/test/test_ast.py
View File

@ -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)

18
Lib/test/test_augassign.py
View File

@ -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

16
Lib/test/test_base64.py
View File

@ -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__)

486
Lib/test/test_bigmem.py
View File

@ -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,

12
Lib/test/test_builtin.py
View File

@ -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')

26
Lib/test/test_bytes.py
View File

@ -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):

2
Lib/test/test_calendar.py
View File

@ -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):

19
Lib/test/test_cfgparser.py
View File

@ -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):

4
Lib/test/test_cgi.py
View File

@ -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',

28
Lib/test/test_charmapcodec.py
View File

@ -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)

22
Lib/test/test_class.py
View File

@ -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.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.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.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))

6
Lib/test/test_code.py
View File

@ -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):

66
Lib/test/test_codeccallbacks.py
View File

@ -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

162
Lib/test/test_codecs.py
View File

@ -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():

26
Lib/test/test_codeop.py
View File

@ -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():

14
Lib/test/test_collections.py
View File

@ -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.

4
Lib/test/test_complex.py
View File

@ -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")

86
Lib/test/test_concurrent_futures.py
View File

@ -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.

12
Lib/test/test_copyreg.py
View File

@ -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():

2
Lib/test/test_deque.py
View File

@ -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

8
Lib/test/test_descr.py
View File

@ -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):

8
Lib/test/test_epoll.py
View File

@ -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)

59
Lib/test/test_exceptions.py
View File

@ -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.

14
Lib/test/test_file.py
View File

@ -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>

58
Lib/test/test_fileio.py
View File

@ -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)

6
Lib/test/test_float.py
View File

@ -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):

198
Lib/test/test_fractions.py
View File

@ -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)

2
Lib/test/test_frozen.py
View File

@ -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

66
Lib/test/test_functools.py
View File

@ -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)

78
Lib/test/test_gdb.py
View File

@ -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)')

18
Lib/test/test_getargs2.py
View File

@ -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')

4
Lib/test/test_getopt.py
View File

@ -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():

4
Lib/test/test_glob.py
View File

@ -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

4
Lib/test/test_gzip.py
View File

@ -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

Some files were not shown because too many files have changed in this diff Show More