Merged revisions 86596 via svnmerge from
svn+ssh://pythondev@svn.python.org/python/branches/py3k
........
r86596 | ezio.melotti | 2010-11-20 21:04:17 +0200 (Sat, 20 Nov 2010) | 1 line
#9424: Replace deprecated assert* methods in the Python test suite.
........
diff --git a/Lib/test/test_io.py b/Lib/test/test_io.py
index 2b4a3a9..ad2919b 100644
--- a/Lib/test/test_io.py
+++ b/Lib/test/test_io.py
@@ -606,7 +606,7 @@
rawio = self.MockRawIO()
bufio = self.tp(rawio)
- self.assertEquals(42, bufio.fileno())
+ self.assertEqual(42, bufio.fileno())
def test_no_fileno(self):
# XXX will we always have fileno() function? If so, kill
@@ -711,36 +711,36 @@
bufio.__init__(rawio)
bufio.__init__(rawio, buffer_size=1024)
bufio.__init__(rawio, buffer_size=16)
- self.assertEquals(b"abc", bufio.read())
+ self.assertEqual(b"abc", bufio.read())
self.assertRaises(ValueError, bufio.__init__, rawio, buffer_size=0)
self.assertRaises(ValueError, bufio.__init__, rawio, buffer_size=-16)
self.assertRaises(ValueError, bufio.__init__, rawio, buffer_size=-1)
rawio = self.MockRawIO([b"abc"])
bufio.__init__(rawio)
- self.assertEquals(b"abc", bufio.read())
+ self.assertEqual(b"abc", bufio.read())
def test_read(self):
for arg in (None, 7):
rawio = self.MockRawIO((b"abc", b"d", b"efg"))
bufio = self.tp(rawio)
- self.assertEquals(b"abcdefg", bufio.read(arg))
+ self.assertEqual(b"abcdefg", bufio.read(arg))
# Invalid args
self.assertRaises(ValueError, bufio.read, -2)
def test_read1(self):
rawio = self.MockRawIO((b"abc", b"d", b"efg"))
bufio = self.tp(rawio)
- self.assertEquals(b"a", bufio.read(1))
- self.assertEquals(b"b", bufio.read1(1))
- self.assertEquals(rawio._reads, 1)
- self.assertEquals(b"c", bufio.read1(100))
- self.assertEquals(rawio._reads, 1)
- self.assertEquals(b"d", bufio.read1(100))
- self.assertEquals(rawio._reads, 2)
- self.assertEquals(b"efg", bufio.read1(100))
- self.assertEquals(rawio._reads, 3)
- self.assertEquals(b"", bufio.read1(100))
- self.assertEquals(rawio._reads, 4)
+ self.assertEqual(b"a", bufio.read(1))
+ self.assertEqual(b"b", bufio.read1(1))
+ self.assertEqual(rawio._reads, 1)
+ self.assertEqual(b"c", bufio.read1(100))
+ self.assertEqual(rawio._reads, 1)
+ self.assertEqual(b"d", bufio.read1(100))
+ self.assertEqual(rawio._reads, 2)
+ self.assertEqual(b"efg", bufio.read1(100))
+ self.assertEqual(rawio._reads, 3)
+ self.assertEqual(b"", bufio.read1(100))
+ self.assertEqual(rawio._reads, 4)
# Invalid args
self.assertRaises(ValueError, bufio.read1, -1)
@@ -748,24 +748,24 @@
rawio = self.MockRawIO((b"abc", b"d", b"efg"))
bufio = self.tp(rawio)
b = bytearray(2)
- self.assertEquals(bufio.readinto(b), 2)
- self.assertEquals(b, b"ab")
- self.assertEquals(bufio.readinto(b), 2)
- self.assertEquals(b, b"cd")
- self.assertEquals(bufio.readinto(b), 2)
- self.assertEquals(b, b"ef")
- self.assertEquals(bufio.readinto(b), 1)
- self.assertEquals(b, b"gf")
- self.assertEquals(bufio.readinto(b), 0)
- self.assertEquals(b, b"gf")
+ self.assertEqual(bufio.readinto(b), 2)
+ self.assertEqual(b, b"ab")
+ self.assertEqual(bufio.readinto(b), 2)
+ self.assertEqual(b, b"cd")
+ self.assertEqual(bufio.readinto(b), 2)
+ self.assertEqual(b, b"ef")
+ self.assertEqual(bufio.readinto(b), 1)
+ self.assertEqual(b, b"gf")
+ self.assertEqual(bufio.readinto(b), 0)
+ self.assertEqual(b, b"gf")
def test_readlines(self):
def bufio():
rawio = self.MockRawIO((b"abc\n", b"d\n", b"ef"))
return self.tp(rawio)
- self.assertEquals(bufio().readlines(), [b"abc\n", b"d\n", b"ef"])
- self.assertEquals(bufio().readlines(5), [b"abc\n", b"d\n"])
- self.assertEquals(bufio().readlines(None), [b"abc\n", b"d\n", b"ef"])
+ self.assertEqual(bufio().readlines(), [b"abc\n", b"d\n", b"ef"])
+ self.assertEqual(bufio().readlines(5), [b"abc\n", b"d\n"])
+ self.assertEqual(bufio().readlines(None), [b"abc\n", b"d\n", b"ef"])
def test_buffering(self):
data = b"abcdefghi"
@@ -782,34 +782,34 @@
bufio = self.tp(rawio, buffer_size=bufsize)
pos = 0
for nbytes in buf_read_sizes:
- self.assertEquals(bufio.read(nbytes), data[pos:pos+nbytes])
+ self.assertEqual(bufio.read(nbytes), data[pos:pos+nbytes])
pos += nbytes
# this is mildly implementation-dependent
- self.assertEquals(rawio.read_history, raw_read_sizes)
+ self.assertEqual(rawio.read_history, raw_read_sizes)
def test_read_non_blocking(self):
# Inject some None's in there to simulate EWOULDBLOCK
rawio = self.MockRawIO((b"abc", b"d", None, b"efg", None, None, None))
bufio = self.tp(rawio)
- self.assertEquals(b"abcd", bufio.read(6))
- self.assertEquals(b"e", bufio.read(1))
- self.assertEquals(b"fg", bufio.read())
- self.assertEquals(b"", bufio.peek(1))
+ self.assertEqual(b"abcd", bufio.read(6))
+ self.assertEqual(b"e", bufio.read(1))
+ self.assertEqual(b"fg", bufio.read())
+ self.assertEqual(b"", bufio.peek(1))
self.assertTrue(None is bufio.read())
- self.assertEquals(b"", bufio.read())
+ self.assertEqual(b"", bufio.read())
def test_read_past_eof(self):
rawio = self.MockRawIO((b"abc", b"d", b"efg"))
bufio = self.tp(rawio)
- self.assertEquals(b"abcdefg", bufio.read(9000))
+ self.assertEqual(b"abcdefg", bufio.read(9000))
def test_read_all(self):
rawio = self.MockRawIO((b"abc", b"d", b"efg"))
bufio = self.tp(rawio)
- self.assertEquals(b"abcdefg", bufio.read())
+ self.assertEqual(b"abcdefg", bufio.read())
@unittest.skipUnless(threading, 'Threading required for this test.')
@support.requires_resource('cpu')
@@ -936,15 +936,15 @@
bufio.__init__(rawio)
bufio.__init__(rawio, buffer_size=1024)
bufio.__init__(rawio, buffer_size=16)
- self.assertEquals(3, bufio.write(b"abc"))
+ self.assertEqual(3, bufio.write(b"abc"))
bufio.flush()
self.assertRaises(ValueError, bufio.__init__, rawio, buffer_size=0)
self.assertRaises(ValueError, bufio.__init__, rawio, buffer_size=-16)
self.assertRaises(ValueError, bufio.__init__, rawio, buffer_size=-1)
bufio.__init__(rawio)
- self.assertEquals(3, bufio.write(b"ghi"))
+ self.assertEqual(3, bufio.write(b"ghi"))
bufio.flush()
- self.assertEquals(b"".join(rawio._write_stack), b"abcghi")
+ self.assertEqual(b"".join(rawio._write_stack), b"abcghi")
def test_detach_flush(self):
raw = self.MockRawIO()
@@ -986,11 +986,11 @@
sizes = gen_sizes()
while n < len(contents):
size = min(next(sizes), len(contents) - n)
- self.assertEquals(bufio.write(contents[n:n+size]), size)
+ self.assertEqual(bufio.write(contents[n:n+size]), size)
intermediate_func(bufio)
n += size
bufio.flush()
- self.assertEquals(contents,
+ self.assertEqual(contents,
b"".join(writer._write_stack))
def test_writes(self):
@@ -1020,11 +1020,11 @@
raw = self.MockNonBlockWriterIO()
bufio = self.tp(raw, 8)
- self.assertEquals(bufio.write(b"abcd"), 4)
- self.assertEquals(bufio.write(b"efghi"), 5)
+ self.assertEqual(bufio.write(b"abcd"), 4)
+ self.assertEqual(bufio.write(b"efghi"), 5)
# 1 byte will be written, the rest will be buffered
raw.block_on(b"k")
- self.assertEquals(bufio.write(b"jklmn"), 5)
+ self.assertEqual(bufio.write(b"jklmn"), 5)
# 8 bytes will be written, 8 will be buffered and the rest will be lost
raw.block_on(b"0")
@@ -1034,11 +1034,11 @@
written = e.characters_written
else:
self.fail("BlockingIOError should have been raised")
- self.assertEquals(written, 16)
- self.assertEquals(raw.pop_written(),
+ self.assertEqual(written, 16)
+ self.assertEqual(raw.pop_written(),
b"abcdefghijklmnopqrwxyz")
- self.assertEquals(bufio.write(b"ABCDEFGHI"), 9)
+ self.assertEqual(bufio.write(b"ABCDEFGHI"), 9)
s = raw.pop_written()
# Previously buffered bytes were flushed
self.assertTrue(s.startswith(b"01234567A"), s)
@@ -1061,7 +1061,7 @@
bufio = self.tp(writer, 8)
bufio.write(b"abc")
bufio.flush()
- self.assertEquals(b"abc", writer._write_stack[0])
+ self.assertEqual(b"abc", writer._write_stack[0])
def test_destructor(self):
writer = self.MockRawIO()
@@ -1069,7 +1069,7 @@
bufio.write(b"abc")
del bufio
support.gc_collect()
- self.assertEquals(b"abc", writer._write_stack[0])
+ self.assertEqual(b"abc", writer._write_stack[0])
def test_truncate(self):
# Truncate implicitly flushes the buffer.
@@ -1128,7 +1128,7 @@
with self.open(support.TESTFN, "rb") as f:
s = f.read()
for i in range(256):
- self.assertEquals(s.count(bytes([i])), N)
+ self.assertEqual(s.count(bytes([i])), N)
finally:
support.unlink(support.TESTFN)
@@ -1329,45 +1329,45 @@
rw.write(b"eee")
self.assertFalse(raw._write_stack) # Buffer writes
self.assertEqual(b"ghjk", rw.read())
- self.assertEquals(b"dddeee", raw._write_stack[0])
+ self.assertEqual(b"dddeee", raw._write_stack[0])
def test_seek_and_tell(self):
raw = self.BytesIO(b"asdfghjkl")
rw = self.tp(raw)
- self.assertEquals(b"as", rw.read(2))
- self.assertEquals(2, rw.tell())
+ self.assertEqual(b"as", rw.read(2))
+ self.assertEqual(2, rw.tell())
rw.seek(0, 0)
- self.assertEquals(b"asdf", rw.read(4))
+ self.assertEqual(b"asdf", rw.read(4))
rw.write(b"asdf")
rw.seek(0, 0)
- self.assertEquals(b"asdfasdfl", rw.read())
- self.assertEquals(9, rw.tell())
+ self.assertEqual(b"asdfasdfl", rw.read())
+ self.assertEqual(9, rw.tell())
rw.seek(-4, 2)
- self.assertEquals(5, rw.tell())
+ self.assertEqual(5, rw.tell())
rw.seek(2, 1)
- self.assertEquals(7, rw.tell())
- self.assertEquals(b"fl", rw.read(11))
+ self.assertEqual(7, rw.tell())
+ self.assertEqual(b"fl", rw.read(11))
self.assertRaises(TypeError, rw.seek, 0.0)
def check_flush_and_read(self, read_func):
raw = self.BytesIO(b"abcdefghi")
bufio = self.tp(raw)
- self.assertEquals(b"ab", read_func(bufio, 2))
+ self.assertEqual(b"ab", read_func(bufio, 2))
bufio.write(b"12")
- self.assertEquals(b"ef", read_func(bufio, 2))
- self.assertEquals(6, bufio.tell())
+ self.assertEqual(b"ef", read_func(bufio, 2))
+ self.assertEqual(6, bufio.tell())
bufio.flush()
- self.assertEquals(6, bufio.tell())
- self.assertEquals(b"ghi", read_func(bufio))
+ self.assertEqual(6, bufio.tell())
+ self.assertEqual(b"ghi", read_func(bufio))
raw.seek(0, 0)
raw.write(b"XYZ")
# flush() resets the read buffer
bufio.flush()
bufio.seek(0, 0)
- self.assertEquals(b"XYZ", read_func(bufio, 3))
+ self.assertEqual(b"XYZ", read_func(bufio, 3))
def test_flush_and_read(self):
self.check_flush_and_read(lambda bufio, *args: bufio.read(*args))
@@ -1399,8 +1399,8 @@
bufio.write(b"45")
bufio.flush()
bufio.seek(0, 0)
- self.assertEquals(b"12345fghi", raw.getvalue())
- self.assertEquals(b"12345fghi", bufio.read())
+ self.assertEqual(b"12345fghi", raw.getvalue())
+ self.assertEqual(b"12345fghi", bufio.read())
def test_threads(self):
BufferedReaderTest.test_threads(self)
@@ -1625,12 +1625,12 @@
# Try a few one-shot test cases.
for input, eof, output in self.test_cases:
d = StatefulIncrementalDecoder()
- self.assertEquals(d.decode(input, eof), output)
+ self.assertEqual(d.decode(input, eof), output)
# Also test an unfinished decode, followed by forcing EOF.
d = StatefulIncrementalDecoder()
- self.assertEquals(d.decode(b'oiabcd'), '')
- self.assertEquals(d.decode(b'', 1), 'abcd.')
+ self.assertEqual(d.decode(b'oiabcd'), '')
+ self.assertEqual(d.decode(b'', 1), 'abcd.')
class TextIOWrapperTest(unittest.TestCase):
@@ -1647,12 +1647,12 @@
b = self.BufferedReader(r, 1000)
t = self.TextIOWrapper(b)
t.__init__(b, encoding="latin1", newline="\r\n")
- self.assertEquals(t.encoding, "latin1")
- self.assertEquals(t.line_buffering, False)
+ self.assertEqual(t.encoding, "latin1")
+ self.assertEqual(t.line_buffering, False)
t.__init__(b, encoding="utf8", line_buffering=True)
- self.assertEquals(t.encoding, "utf8")
- self.assertEquals(t.line_buffering, True)
- self.assertEquals("\xe9\n", t.readline())
+ self.assertEqual(t.encoding, "utf8")
+ self.assertEqual(t.line_buffering, True)
+ self.assertEqual("\xe9\n", t.readline())
self.assertRaises(TypeError, t.__init__, b, newline=42)
self.assertRaises(ValueError, t.__init__, b, newline='xyzzy')
@@ -1688,11 +1688,11 @@
b = self.BufferedWriter(r, 1000)
t = self.TextIOWrapper(b, newline="\n", line_buffering=True)
t.write("X")
- self.assertEquals(r.getvalue(), b"") # No flush happened
+ self.assertEqual(r.getvalue(), b"") # No flush happened
t.write("Y\nZ")
- self.assertEquals(r.getvalue(), b"XY\nZ") # All got flushed
+ self.assertEqual(r.getvalue(), b"XY\nZ") # All got flushed
t.write("A\rB")
- self.assertEquals(r.getvalue(), b"XY\nZA\rB")
+ self.assertEqual(r.getvalue(), b"XY\nZA\rB")
def test_encoding(self):
# Check the encoding attribute is always set, and valid
@@ -1715,11 +1715,11 @@
# (3) ignore
b = self.BytesIO(b"abc\n\xff\n")
t = self.TextIOWrapper(b, encoding="ascii", errors="ignore")
- self.assertEquals(t.read(), "abc\n\n")
+ self.assertEqual(t.read(), "abc\n\n")
# (4) replace
b = self.BytesIO(b"abc\n\xff\n")
t = self.TextIOWrapper(b, encoding="ascii", errors="replace")
- self.assertEquals(t.read(), "abc\n\ufffd\n")
+ self.assertEqual(t.read(), "abc\n\ufffd\n")
def test_encoding_errors_writing(self):
# (1) default
@@ -1736,14 +1736,14 @@
newline="\n")
t.write("abc\xffdef\n")
t.flush()
- self.assertEquals(b.getvalue(), b"abcdef\n")
+ self.assertEqual(b.getvalue(), b"abcdef\n")
# (4) replace
b = self.BytesIO()
t = self.TextIOWrapper(b, encoding="ascii", errors="replace",
newline="\n")
t.write("abc\xffdef\n")
t.flush()
- self.assertEquals(b.getvalue(), b"abc?def\n")
+ self.assertEqual(b.getvalue(), b"abc?def\n")
def test_newlines(self):
input_lines = [ "unix\n", "windows\r\n", "os9\r", "last\n", "nonl" ]
@@ -1778,14 +1778,14 @@
c2 = textio.read(2)
if c2 == '':
break
- self.assertEquals(len(c2), 2)
+ self.assertEqual(len(c2), 2)
got_lines.append(c2 + textio.readline())
else:
got_lines = list(textio)
for got_line, exp_line in zip(got_lines, exp_lines):
- self.assertEquals(got_line, exp_line)
- self.assertEquals(len(got_lines), len(exp_lines))
+ self.assertEqual(got_line, exp_line)
+ self.assertEqual(len(got_lines), len(exp_lines))
def test_newlines_input(self):
testdata = b"AAA\nBB\x00B\nCCC\rDDD\rEEE\r\nFFF\r\nGGG"
@@ -1799,9 +1799,9 @@
]:
buf = self.BytesIO(testdata)
txt = self.TextIOWrapper(buf, encoding="ascii", newline=newline)
- self.assertEquals(txt.readlines(), expected)
+ self.assertEqual(txt.readlines(), expected)
txt.seek(0)
- self.assertEquals(txt.read(), "".join(expected))
+ self.assertEqual(txt.read(), "".join(expected))
def test_newlines_output(self):
testdict = {
@@ -1818,8 +1818,8 @@
txt.write("BB\nCCC\n")
txt.write("X\rY\r\nZ")
txt.flush()
- self.assertEquals(buf.closed, False)
- self.assertEquals(buf.getvalue(), expected)
+ self.assertEqual(buf.closed, False)
+ self.assertEqual(buf.getvalue(), expected)
def test_destructor(self):
l = []
@@ -1833,7 +1833,7 @@
t.write("abc")
del t
support.gc_collect()
- self.assertEquals([b"abc"], l)
+ self.assertEqual([b"abc"], l)
def test_override_destructor(self):
record = []
@@ -1880,26 +1880,26 @@
for enc in "ascii", "latin1", "utf8" :# , "utf-16-be", "utf-16-le":
f = self.open(support.TESTFN, "w+", encoding=enc)
f._CHUNK_SIZE = chunksize
- self.assertEquals(f.write("abc"), 3)
+ self.assertEqual(f.write("abc"), 3)
f.close()
f = self.open(support.TESTFN, "r+", encoding=enc)
f._CHUNK_SIZE = chunksize
- self.assertEquals(f.tell(), 0)
- self.assertEquals(f.read(), "abc")
+ self.assertEqual(f.tell(), 0)
+ self.assertEqual(f.read(), "abc")
cookie = f.tell()
- self.assertEquals(f.seek(0), 0)
- self.assertEquals(f.read(None), "abc")
+ self.assertEqual(f.seek(0), 0)
+ self.assertEqual(f.read(None), "abc")
f.seek(0)
- self.assertEquals(f.read(2), "ab")
- self.assertEquals(f.read(1), "c")
- self.assertEquals(f.read(1), "")
- self.assertEquals(f.read(), "")
- self.assertEquals(f.tell(), cookie)
- self.assertEquals(f.seek(0), 0)
- self.assertEquals(f.seek(0, 2), cookie)
- self.assertEquals(f.write("def"), 3)
- self.assertEquals(f.seek(cookie), cookie)
- self.assertEquals(f.read(), "def")
+ self.assertEqual(f.read(2), "ab")
+ self.assertEqual(f.read(1), "c")
+ self.assertEqual(f.read(1), "")
+ self.assertEqual(f.read(), "")
+ self.assertEqual(f.tell(), cookie)
+ self.assertEqual(f.seek(0), 0)
+ self.assertEqual(f.seek(0, 2), cookie)
+ self.assertEqual(f.write("def"), 3)
+ self.assertEqual(f.seek(cookie), cookie)
+ self.assertEqual(f.read(), "def")
if enc.startswith("utf"):
self.multi_line_test(f, enc)
f.close()
@@ -1924,7 +1924,7 @@
if not line:
break
rlines.append((pos, line))
- self.assertEquals(rlines, wlines)
+ self.assertEqual(rlines, wlines)
def test_telling(self):
f = self.open(support.TESTFN, "w+", encoding="utf8")
@@ -1934,16 +1934,16 @@
f.write("\xff\n")
p2 = f.tell()
f.seek(0)
- self.assertEquals(f.tell(), p0)
- self.assertEquals(f.readline(), "\xff\n")
- self.assertEquals(f.tell(), p1)
- self.assertEquals(f.readline(), "\xff\n")
- self.assertEquals(f.tell(), p2)
+ self.assertEqual(f.tell(), p0)
+ self.assertEqual(f.readline(), "\xff\n")
+ self.assertEqual(f.tell(), p1)
+ self.assertEqual(f.readline(), "\xff\n")
+ self.assertEqual(f.tell(), p2)
f.seek(0)
for line in f:
- self.assertEquals(line, "\xff\n")
+ self.assertEqual(line, "\xff\n")
self.assertRaises(IOError, f.tell)
- self.assertEquals(f.tell(), p2)
+ self.assertEqual(f.tell(), p2)
f.close()
def test_seeking(self):
@@ -1951,7 +1951,7 @@
prefix_size = chunk_size - 2
u_prefix = "a" * prefix_size
prefix = bytes(u_prefix.encode("utf-8"))
- self.assertEquals(len(u_prefix), len(prefix))
+ self.assertEqual(len(u_prefix), len(prefix))
u_suffix = "\u8888\n"
suffix = bytes(u_suffix.encode("utf-8"))
line = prefix + suffix
@@ -1960,9 +1960,9 @@
f.close()
f = self.open(support.TESTFN, "r", encoding="utf-8")
s = f.read(prefix_size)
- self.assertEquals(s, prefix.decode("ascii"))
- self.assertEquals(f.tell(), prefix_size)
- self.assertEquals(f.readline(), u_suffix)
+ self.assertEqual(s, prefix.decode("ascii"))
+ self.assertEqual(f.tell(), prefix_size)
+ self.assertEqual(f.readline(), u_suffix)
def test_seeking_too(self):
# Regression test for a specific bug
@@ -1995,11 +1995,11 @@
for i in range(min_pos, len(decoded) + 1): # seek positions
for j in [1, 5, len(decoded) - i]: # read lengths
f = self.open(support.TESTFN, encoding='test_decoder')
- self.assertEquals(f.read(i), decoded[:i])
+ self.assertEqual(f.read(i), decoded[:i])
cookie = f.tell()
- self.assertEquals(f.read(j), decoded[i:i + j])
+ self.assertEqual(f.read(j), decoded[i:i + j])
f.seek(cookie)
- self.assertEquals(f.read(), decoded[i:])
+ self.assertEqual(f.read(), decoded[i:])
f.close()
# Enable the test decoder.
@@ -2038,10 +2038,10 @@
f.write(data)
f.write(data)
f.seek(0)
- self.assertEquals(f.read(), data * 2)
+ self.assertEqual(f.read(), data * 2)
f.seek(0)
- self.assertEquals(f.read(), data * 2)
- self.assertEquals(buf.getvalue(), (data * 2).encode(encoding))
+ self.assertEqual(f.read(), data * 2)
+ self.assertEqual(buf.getvalue(), (data * 2).encode(encoding))
def test_unreadable(self):
class UnReadable(self.BytesIO):
@@ -2058,7 +2058,7 @@
if not c:
break
reads += c
- self.assertEquals(reads, "AA\nBB")
+ self.assertEqual(reads, "AA\nBB")
def test_readlines(self):
txt = self.TextIOWrapper(self.BytesIO(b"AA\nBB\nCC"))
@@ -2078,7 +2078,7 @@
if not c:
break
reads += c
- self.assertEquals(reads, "A"*127+"\nB")
+ self.assertEqual(reads, "A"*127+"\nB")
def test_issue1395_1(self):
txt = self.TextIOWrapper(self.BytesIO(self.testdata), encoding="ascii")
@@ -2090,7 +2090,7 @@
if not c:
break
reads += c
- self.assertEquals(reads, self.normalized)
+ self.assertEqual(reads, self.normalized)
def test_issue1395_2(self):
txt = self.TextIOWrapper(self.BytesIO(self.testdata), encoding="ascii")
@@ -2102,7 +2102,7 @@
if not c:
break
reads += c
- self.assertEquals(reads, self.normalized)
+ self.assertEqual(reads, self.normalized)
def test_issue1395_3(self):
txt = self.TextIOWrapper(self.BytesIO(self.testdata), encoding="ascii")
@@ -2113,7 +2113,7 @@
reads += txt.readline()
reads += txt.readline()
reads += txt.readline()
- self.assertEquals(reads, self.normalized)
+ self.assertEqual(reads, self.normalized)
def test_issue1395_4(self):
txt = self.TextIOWrapper(self.BytesIO(self.testdata), encoding="ascii")
@@ -2121,7 +2121,7 @@
reads = txt.read(4)
reads += txt.read()
- self.assertEquals(reads, self.normalized)
+ self.assertEqual(reads, self.normalized)
def test_issue1395_5(self):
txt = self.TextIOWrapper(self.BytesIO(self.testdata), encoding="ascii")
@@ -2131,7 +2131,7 @@
pos = txt.tell()
txt.seek(0)
txt.seek(pos)
- self.assertEquals(txt.read(4), "BBB\n")
+ self.assertEqual(txt.read(4), "BBB\n")
def test_issue2282(self):
buffer = self.BytesIO(self.testdata)
@@ -2147,12 +2147,12 @@
f.write('aaa')
pos = f.tell()
with self.open(filename, 'rb') as f:
- self.assertEquals(f.read(), 'aaa'.encode(charset))
+ self.assertEqual(f.read(), 'aaa'.encode(charset))
with self.open(filename, 'a', encoding=charset) as f:
f.write('xxx')
with self.open(filename, 'rb') as f:
- self.assertEquals(f.read(), 'aaaxxx'.encode(charset))
+ self.assertEqual(f.read(), 'aaaxxx'.encode(charset))
def test_seek_bom(self):
# Same test, but when seeking manually
@@ -2167,7 +2167,7 @@
f.seek(0)
f.write('bbb')
with self.open(filename, 'rb') as f:
- self.assertEquals(f.read(), 'bbbzzz'.encode(charset))
+ self.assertEqual(f.read(), 'bbbzzz'.encode(charset))
def test_errors_property(self):
with self.open(support.TESTFN, "w") as f:
@@ -2195,7 +2195,7 @@
with self.open(support.TESTFN) as f:
content = f.read()
for n in range(20):
- self.assertEquals(content.count("Thread%03d\n" % n), 1)
+ self.assertEqual(content.count("Thread%03d\n" % n), 1)
def test_flush_error_on_close(self):
txt = self.TextIOWrapper(self.BytesIO(self.testdata), encoding="ascii")
@@ -2249,9 +2249,9 @@
def _check_decode(b, s, **kwargs):
# We exercise getstate() / setstate() as well as decode()
state = decoder.getstate()
- self.assertEquals(decoder.decode(b, **kwargs), s)
+ self.assertEqual(decoder.decode(b, **kwargs), s)
decoder.setstate(state)
- self.assertEquals(decoder.decode(b, **kwargs), s)
+ self.assertEqual(decoder.decode(b, **kwargs), s)
_check_decode(b'\xe8\xa2\x88', "\u8888")
@@ -2300,24 +2300,24 @@
# Decode one char at a time
for c in s:
result.append(decoder.decode(c))
- self.assertEquals(decoder.newlines, None)
+ self.assertEqual(decoder.newlines, None)
_decode_bytewise("abc\n\r")
- self.assertEquals(decoder.newlines, '\n')
+ self.assertEqual(decoder.newlines, '\n')
_decode_bytewise("\nabc")
- self.assertEquals(decoder.newlines, ('\n', '\r\n'))
+ self.assertEqual(decoder.newlines, ('\n', '\r\n'))
_decode_bytewise("abc\r")
- self.assertEquals(decoder.newlines, ('\n', '\r\n'))
+ self.assertEqual(decoder.newlines, ('\n', '\r\n'))
_decode_bytewise("abc")
- self.assertEquals(decoder.newlines, ('\r', '\n', '\r\n'))
+ self.assertEqual(decoder.newlines, ('\r', '\n', '\r\n'))
_decode_bytewise("abc\r")
- self.assertEquals("".join(result), "abc\n\nabcabc\nabcabc")
+ self.assertEqual("".join(result), "abc\n\nabcabc\nabcabc")
decoder.reset()
input = "abc"
if encoder is not None:
encoder.reset()
input = encoder.encode(input)
- self.assertEquals(decoder.decode(input), "abc")
- self.assertEquals(decoder.newlines, None)
+ self.assertEqual(decoder.decode(input), "abc")
+ self.assertEqual(decoder.newlines, None)
def test_newline_decoder(self):
encodings = (
@@ -2338,11 +2338,11 @@
def test_newline_bytes(self):
# Issue 5433: Excessive optimization in IncrementalNewlineDecoder
def _check(dec):
- self.assertEquals(dec.newlines, None)
- self.assertEquals(dec.decode("\u0D00"), "\u0D00")
- self.assertEquals(dec.newlines, None)
- self.assertEquals(dec.decode("\u0A00"), "\u0A00")
- self.assertEquals(dec.newlines, None)
+ self.assertEqual(dec.newlines, None)
+ self.assertEqual(dec.decode("\u0D00"), "\u0D00")
+ self.assertEqual(dec.newlines, None)
+ self.assertEqual(dec.decode("\u0A00"), "\u0A00")
+ self.assertEqual(dec.newlines, None)
dec = self.IncrementalNewlineDecoder(None, translate=False)
_check(dec)
dec = self.IncrementalNewlineDecoder(None, translate=True)
@@ -2375,28 +2375,28 @@
def test_attributes(self):
f = self.open(support.TESTFN, "wb", buffering=0)
- self.assertEquals(f.mode, "wb")
+ self.assertEqual(f.mode, "wb")
f.close()
f = self.open(support.TESTFN, "U")
- self.assertEquals(f.name, support.TESTFN)
- self.assertEquals(f.buffer.name, support.TESTFN)
- self.assertEquals(f.buffer.raw.name, support.TESTFN)
- self.assertEquals(f.mode, "U")
- self.assertEquals(f.buffer.mode, "rb")
- self.assertEquals(f.buffer.raw.mode, "rb")
+ self.assertEqual(f.name, support.TESTFN)
+ self.assertEqual(f.buffer.name, support.TESTFN)
+ self.assertEqual(f.buffer.raw.name, support.TESTFN)
+ self.assertEqual(f.mode, "U")
+ self.assertEqual(f.buffer.mode, "rb")
+ self.assertEqual(f.buffer.raw.mode, "rb")
f.close()
f = self.open(support.TESTFN, "w+")
- self.assertEquals(f.mode, "w+")
- self.assertEquals(f.buffer.mode, "rb+") # Does it really matter?
- self.assertEquals(f.buffer.raw.mode, "rb+")
+ self.assertEqual(f.mode, "w+")
+ self.assertEqual(f.buffer.mode, "rb+") # Does it really matter?
+ self.assertEqual(f.buffer.raw.mode, "rb+")
g = self.open(f.fileno(), "wb", closefd=False)
- self.assertEquals(g.mode, "wb")
- self.assertEquals(g.raw.mode, "wb")
- self.assertEquals(g.name, f.fileno())
- self.assertEquals(g.raw.name, f.fileno())
+ self.assertEqual(g.mode, "wb")
+ self.assertEqual(g.raw.mode, "wb")
+ self.assertEqual(g.name, f.fileno())
+ self.assertEqual(g.raw.name, f.fileno())
f.close()
g.close()