mirror of
https://github.com/python/cpython.git
synced 2025-08-30 13:38:43 +00:00
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. ........
This commit is contained in:
Ezio Melotti
parent
b65b4937e2
commit
19f2aeba67
164 changed files with 2281 additions and 2279 deletions
|
|
@ -598,7 +598,7 @@ class CommonBufferedTests:
|
|||
rawio = self.MockRawIO()
|
||||
bufio = self.tp(rawio)
|
||||
|
||||
self.assertEquals(42, bufio.fileno())
|
||||
self.assertEqual(42, bufio.fileno())
|
||||
|
||||
def test_no_fileno(self):
|
||||
# XXX will we always have fileno() function? If so, kill
|
||||
|
|
@ -703,36 +703,36 @@ class BufferedReaderTest(unittest.TestCase, CommonBufferedTests):
|
|||
bufio.__init__(rawio)
|
||||
bufio.__init__(rawio, buffer_size=1024)
|
||||
bufio.__init__(rawio, buffer_size=16)
|
||||
self.assertEquals(b"abc", bufio.read())
|
||||
self.assertEqual(b"abc", bufio.read())
|
||||
self.assertRaises(ValueError, bufio.__init__, rawio, buffer_size=0)
|
||||
self.assertRaises(ValueError, bufio.__init__, rawio, buffer_size=-16)
|
||||
self.assertRaises(ValueError, bufio.__init__, rawio, buffer_size=-1)
|
||||
rawio = self.MockRawIO([b"abc"])
|
||||
bufio.__init__(rawio)
|
||||
self.assertEquals(b"abc", bufio.read())
|
||||
self.assertEqual(b"abc", bufio.read())
|
||||
|
||||
def test_read(self):
|
||||
for arg in (None, 7):
|
||||
rawio = self.MockRawIO((b"abc", b"d", b"efg"))
|
||||
bufio = self.tp(rawio)
|
||||
self.assertEquals(b"abcdefg", bufio.read(arg))
|
||||
self.assertEqual(b"abcdefg", bufio.read(arg))
|
||||
# Invalid args
|
||||
self.assertRaises(ValueError, bufio.read, -2)
|
||||
|
||||
def test_read1(self):
|
||||
rawio = self.MockRawIO((b"abc", b"d", b"efg"))
|
||||
bufio = self.tp(rawio)
|
||||
self.assertEquals(b"a", bufio.read(1))
|
||||
self.assertEquals(b"b", bufio.read1(1))
|
||||
self.assertEquals(rawio._reads, 1)
|
||||
self.assertEquals(b"c", bufio.read1(100))
|
||||
self.assertEquals(rawio._reads, 1)
|
||||
self.assertEquals(b"d", bufio.read1(100))
|
||||
self.assertEquals(rawio._reads, 2)
|
||||
self.assertEquals(b"efg", bufio.read1(100))
|
||||
self.assertEquals(rawio._reads, 3)
|
||||
self.assertEquals(b"", bufio.read1(100))
|
||||
self.assertEquals(rawio._reads, 4)
|
||||
self.assertEqual(b"a", bufio.read(1))
|
||||
self.assertEqual(b"b", bufio.read1(1))
|
||||
self.assertEqual(rawio._reads, 1)
|
||||
self.assertEqual(b"c", bufio.read1(100))
|
||||
self.assertEqual(rawio._reads, 1)
|
||||
self.assertEqual(b"d", bufio.read1(100))
|
||||
self.assertEqual(rawio._reads, 2)
|
||||
self.assertEqual(b"efg", bufio.read1(100))
|
||||
self.assertEqual(rawio._reads, 3)
|
||||
self.assertEqual(b"", bufio.read1(100))
|
||||
self.assertEqual(rawio._reads, 4)
|
||||
# Invalid args
|
||||
self.assertRaises(ValueError, bufio.read1, -1)
|
||||
|
||||
|
|
@ -740,24 +740,24 @@ class BufferedReaderTest(unittest.TestCase, CommonBufferedTests):
|
|||
rawio = self.MockRawIO((b"abc", b"d", b"efg"))
|
||||
bufio = self.tp(rawio)
|
||||
b = bytearray(2)
|
||||
self.assertEquals(bufio.readinto(b), 2)
|
||||
self.assertEquals(b, b"ab")
|
||||
self.assertEquals(bufio.readinto(b), 2)
|
||||
self.assertEquals(b, b"cd")
|
||||
self.assertEquals(bufio.readinto(b), 2)
|
||||
self.assertEquals(b, b"ef")
|
||||
self.assertEquals(bufio.readinto(b), 1)
|
||||
self.assertEquals(b, b"gf")
|
||||
self.assertEquals(bufio.readinto(b), 0)
|
||||
self.assertEquals(b, b"gf")
|
||||
self.assertEqual(bufio.readinto(b), 2)
|
||||
self.assertEqual(b, b"ab")
|
||||
self.assertEqual(bufio.readinto(b), 2)
|
||||
self.assertEqual(b, b"cd")
|
||||
self.assertEqual(bufio.readinto(b), 2)
|
||||
self.assertEqual(b, b"ef")
|
||||
self.assertEqual(bufio.readinto(b), 1)
|
||||
self.assertEqual(b, b"gf")
|
||||
self.assertEqual(bufio.readinto(b), 0)
|
||||
self.assertEqual(b, b"gf")
|
||||
|
||||
def test_readlines(self):
|
||||
def bufio():
|
||||
rawio = self.MockRawIO((b"abc\n", b"d\n", b"ef"))
|
||||
return self.tp(rawio)
|
||||
self.assertEquals(bufio().readlines(), [b"abc\n", b"d\n", b"ef"])
|
||||
self.assertEquals(bufio().readlines(5), [b"abc\n", b"d\n"])
|
||||
self.assertEquals(bufio().readlines(None), [b"abc\n", b"d\n", b"ef"])
|
||||
self.assertEqual(bufio().readlines(), [b"abc\n", b"d\n", b"ef"])
|
||||
self.assertEqual(bufio().readlines(5), [b"abc\n", b"d\n"])
|
||||
self.assertEqual(bufio().readlines(None), [b"abc\n", b"d\n", b"ef"])
|
||||
|
||||
def test_buffering(self):
|
||||
data = b"abcdefghi"
|
||||
|
|
@ -774,34 +774,34 @@ class BufferedReaderTest(unittest.TestCase, CommonBufferedTests):
|
|||
bufio = self.tp(rawio, buffer_size=bufsize)
|
||||
pos = 0
|
||||
for nbytes in buf_read_sizes:
|
||||
self.assertEquals(bufio.read(nbytes), data[pos:pos+nbytes])
|
||||
self.assertEqual(bufio.read(nbytes), data[pos:pos+nbytes])
|
||||
pos += nbytes
|
||||
# this is mildly implementation-dependent
|
||||
self.assertEquals(rawio.read_history, raw_read_sizes)
|
||||
self.assertEqual(rawio.read_history, raw_read_sizes)
|
||||
|
||||
def test_read_non_blocking(self):
|
||||
# Inject some None's in there to simulate EWOULDBLOCK
|
||||
rawio = self.MockRawIO((b"abc", b"d", None, b"efg", None, None, None))
|
||||
bufio = self.tp(rawio)
|
||||
|
||||
self.assertEquals(b"abcd", bufio.read(6))
|
||||
self.assertEquals(b"e", bufio.read(1))
|
||||
self.assertEquals(b"fg", bufio.read())
|
||||
self.assertEquals(b"", bufio.peek(1))
|
||||
self.assertEqual(b"abcd", bufio.read(6))
|
||||
self.assertEqual(b"e", bufio.read(1))
|
||||
self.assertEqual(b"fg", bufio.read())
|
||||
self.assertEqual(b"", bufio.peek(1))
|
||||
self.assertTrue(None is bufio.read())
|
||||
self.assertEquals(b"", bufio.read())
|
||||
self.assertEqual(b"", bufio.read())
|
||||
|
||||
def test_read_past_eof(self):
|
||||
rawio = self.MockRawIO((b"abc", b"d", b"efg"))
|
||||
bufio = self.tp(rawio)
|
||||
|
||||
self.assertEquals(b"abcdefg", bufio.read(9000))
|
||||
self.assertEqual(b"abcdefg", bufio.read(9000))
|
||||
|
||||
def test_read_all(self):
|
||||
rawio = self.MockRawIO((b"abc", b"d", b"efg"))
|
||||
bufio = self.tp(rawio)
|
||||
|
||||
self.assertEquals(b"abcdefg", bufio.read())
|
||||
self.assertEqual(b"abcdefg", bufio.read())
|
||||
|
||||
@support.requires_resource('cpu')
|
||||
def test_threads(self):
|
||||
|
|
@ -927,15 +927,15 @@ class BufferedWriterTest(unittest.TestCase, CommonBufferedTests):
|
|||
bufio.__init__(rawio)
|
||||
bufio.__init__(rawio, buffer_size=1024)
|
||||
bufio.__init__(rawio, buffer_size=16)
|
||||
self.assertEquals(3, bufio.write(b"abc"))
|
||||
self.assertEqual(3, bufio.write(b"abc"))
|
||||
bufio.flush()
|
||||
self.assertRaises(ValueError, bufio.__init__, rawio, buffer_size=0)
|
||||
self.assertRaises(ValueError, bufio.__init__, rawio, buffer_size=-16)
|
||||
self.assertRaises(ValueError, bufio.__init__, rawio, buffer_size=-1)
|
||||
bufio.__init__(rawio)
|
||||
self.assertEquals(3, bufio.write(b"ghi"))
|
||||
self.assertEqual(3, bufio.write(b"ghi"))
|
||||
bufio.flush()
|
||||
self.assertEquals(b"".join(rawio._write_stack), b"abcghi")
|
||||
self.assertEqual(b"".join(rawio._write_stack), b"abcghi")
|
||||
|
||||
def test_detach_flush(self):
|
||||
raw = self.MockRawIO()
|
||||
|
|
@ -977,11 +977,11 @@ class BufferedWriterTest(unittest.TestCase, CommonBufferedTests):
|
|||
sizes = gen_sizes()
|
||||
while n < len(contents):
|
||||
size = min(next(sizes), len(contents) - n)
|
||||
self.assertEquals(bufio.write(contents[n:n+size]), size)
|
||||
self.assertEqual(bufio.write(contents[n:n+size]), size)
|
||||
intermediate_func(bufio)
|
||||
n += size
|
||||
bufio.flush()
|
||||
self.assertEquals(contents, b"".join(writer._write_stack))
|
||||
self.assertEqual(contents, b"".join(writer._write_stack))
|
||||
|
||||
def test_writes(self):
|
||||
self.check_writes(lambda bufio: None)
|
||||
|
|
@ -1010,11 +1010,11 @@ class BufferedWriterTest(unittest.TestCase, CommonBufferedTests):
|
|||
raw = self.MockNonBlockWriterIO()
|
||||
bufio = self.tp(raw, 8)
|
||||
|
||||
self.assertEquals(bufio.write(b"abcd"), 4)
|
||||
self.assertEquals(bufio.write(b"efghi"), 5)
|
||||
self.assertEqual(bufio.write(b"abcd"), 4)
|
||||
self.assertEqual(bufio.write(b"efghi"), 5)
|
||||
# 1 byte will be written, the rest will be buffered
|
||||
raw.block_on(b"k")
|
||||
self.assertEquals(bufio.write(b"jklmn"), 5)
|
||||
self.assertEqual(bufio.write(b"jklmn"), 5)
|
||||
|
||||
# 8 bytes will be written, 8 will be buffered and the rest will be lost
|
||||
raw.block_on(b"0")
|
||||
|
|
@ -1024,11 +1024,11 @@ class BufferedWriterTest(unittest.TestCase, CommonBufferedTests):
|
|||
written = e.characters_written
|
||||
else:
|
||||
self.fail("BlockingIOError should have been raised")
|
||||
self.assertEquals(written, 16)
|
||||
self.assertEquals(raw.pop_written(),
|
||||
self.assertEqual(written, 16)
|
||||
self.assertEqual(raw.pop_written(),
|
||||
b"abcdefghijklmnopqrwxyz")
|
||||
|
||||
self.assertEquals(bufio.write(b"ABCDEFGHI"), 9)
|
||||
self.assertEqual(bufio.write(b"ABCDEFGHI"), 9)
|
||||
s = raw.pop_written()
|
||||
# Previously buffered bytes were flushed
|
||||
self.assertTrue(s.startswith(b"01234567A"), s)
|
||||
|
|
@ -1051,7 +1051,7 @@ class BufferedWriterTest(unittest.TestCase, CommonBufferedTests):
|
|||
bufio = self.tp(writer, 8)
|
||||
bufio.write(b"abc")
|
||||
bufio.flush()
|
||||
self.assertEquals(b"abc", writer._write_stack[0])
|
||||
self.assertEqual(b"abc", writer._write_stack[0])
|
||||
|
||||
def test_destructor(self):
|
||||
writer = self.MockRawIO()
|
||||
|
|
@ -1059,7 +1059,7 @@ class BufferedWriterTest(unittest.TestCase, CommonBufferedTests):
|
|||
bufio.write(b"abc")
|
||||
del bufio
|
||||
support.gc_collect()
|
||||
self.assertEquals(b"abc", writer._write_stack[0])
|
||||
self.assertEqual(b"abc", writer._write_stack[0])
|
||||
|
||||
def test_truncate(self):
|
||||
# Truncate implicitly flushes the buffer.
|
||||
|
|
@ -1117,7 +1117,7 @@ class BufferedWriterTest(unittest.TestCase, CommonBufferedTests):
|
|||
with self.open(support.TESTFN, "rb") as f:
|
||||
s = f.read()
|
||||
for i in range(256):
|
||||
self.assertEquals(s.count(bytes([i])), N)
|
||||
self.assertEqual(s.count(bytes([i])), N)
|
||||
finally:
|
||||
support.unlink(support.TESTFN)
|
||||
|
||||
|
|
@ -1328,45 +1328,45 @@ class BufferedRandomTest(BufferedReaderTest, BufferedWriterTest):
|
|||
rw.write(b"eee")
|
||||
self.assertFalse(raw._write_stack) # Buffer writes
|
||||
self.assertEqual(b"ghjk", rw.read())
|
||||
self.assertEquals(b"dddeee", raw._write_stack[0])
|
||||
self.assertEqual(b"dddeee", raw._write_stack[0])
|
||||
|
||||
def test_seek_and_tell(self):
|
||||
raw = self.BytesIO(b"asdfghjkl")
|
||||
rw = self.tp(raw)
|
||||
|
||||
self.assertEquals(b"as", rw.read(2))
|
||||
self.assertEquals(2, rw.tell())
|
||||
self.assertEqual(b"as", rw.read(2))
|
||||
self.assertEqual(2, rw.tell())
|
||||
rw.seek(0, 0)
|
||||
self.assertEquals(b"asdf", rw.read(4))
|
||||
self.assertEqual(b"asdf", rw.read(4))
|
||||
|
||||
rw.write(b"asdf")
|
||||
rw.seek(0, 0)
|
||||
self.assertEquals(b"asdfasdfl", rw.read())
|
||||
self.assertEquals(9, rw.tell())
|
||||
self.assertEqual(b"asdfasdfl", rw.read())
|
||||
self.assertEqual(9, rw.tell())
|
||||
rw.seek(-4, 2)
|
||||
self.assertEquals(5, rw.tell())
|
||||
self.assertEqual(5, rw.tell())
|
||||
rw.seek(2, 1)
|
||||
self.assertEquals(7, rw.tell())
|
||||
self.assertEquals(b"fl", rw.read(11))
|
||||
self.assertEqual(7, rw.tell())
|
||||
self.assertEqual(b"fl", rw.read(11))
|
||||
self.assertRaises(TypeError, rw.seek, 0.0)
|
||||
|
||||
def check_flush_and_read(self, read_func):
|
||||
raw = self.BytesIO(b"abcdefghi")
|
||||
bufio = self.tp(raw)
|
||||
|
||||
self.assertEquals(b"ab", read_func(bufio, 2))
|
||||
self.assertEqual(b"ab", read_func(bufio, 2))
|
||||
bufio.write(b"12")
|
||||
self.assertEquals(b"ef", read_func(bufio, 2))
|
||||
self.assertEquals(6, bufio.tell())
|
||||
self.assertEqual(b"ef", read_func(bufio, 2))
|
||||
self.assertEqual(6, bufio.tell())
|
||||
bufio.flush()
|
||||
self.assertEquals(6, bufio.tell())
|
||||
self.assertEquals(b"ghi", read_func(bufio))
|
||||
self.assertEqual(6, bufio.tell())
|
||||
self.assertEqual(b"ghi", read_func(bufio))
|
||||
raw.seek(0, 0)
|
||||
raw.write(b"XYZ")
|
||||
# flush() resets the read buffer
|
||||
bufio.flush()
|
||||
bufio.seek(0, 0)
|
||||
self.assertEquals(b"XYZ", read_func(bufio, 3))
|
||||
self.assertEqual(b"XYZ", read_func(bufio, 3))
|
||||
|
||||
def test_flush_and_read(self):
|
||||
self.check_flush_and_read(lambda bufio, *args: bufio.read(*args))
|
||||
|
|
@ -1398,8 +1398,8 @@ class BufferedRandomTest(BufferedReaderTest, BufferedWriterTest):
|
|||
bufio.write(b"45")
|
||||
bufio.flush()
|
||||
bufio.seek(0, 0)
|
||||
self.assertEquals(b"12345fghi", raw.getvalue())
|
||||
self.assertEquals(b"12345fghi", bufio.read())
|
||||
self.assertEqual(b"12345fghi", raw.getvalue())
|
||||
self.assertEqual(b"12345fghi", bufio.read())
|
||||
|
||||
def test_threads(self):
|
||||
BufferedReaderTest.test_threads(self)
|
||||
|
|
@ -1624,12 +1624,12 @@ class StatefulIncrementalDecoderTest(unittest.TestCase):
|
|||
# Try a few one-shot test cases.
|
||||
for input, eof, output in self.test_cases:
|
||||
d = StatefulIncrementalDecoder()
|
||||
self.assertEquals(d.decode(input, eof), output)
|
||||
self.assertEqual(d.decode(input, eof), output)
|
||||
|
||||
# Also test an unfinished decode, followed by forcing EOF.
|
||||
d = StatefulIncrementalDecoder()
|
||||
self.assertEquals(d.decode(b'oiabcd'), '')
|
||||
self.assertEquals(d.decode(b'', 1), 'abcd.')
|
||||
self.assertEqual(d.decode(b'oiabcd'), '')
|
||||
self.assertEqual(d.decode(b'', 1), 'abcd.')
|
||||
|
||||
class TextIOWrapperTest(unittest.TestCase):
|
||||
|
||||
|
|
@ -1646,12 +1646,12 @@ class TextIOWrapperTest(unittest.TestCase):
|
|||
b = self.BufferedReader(r, 1000)
|
||||
t = self.TextIOWrapper(b)
|
||||
t.__init__(b, encoding="latin1", newline="\r\n")
|
||||
self.assertEquals(t.encoding, "latin1")
|
||||
self.assertEquals(t.line_buffering, False)
|
||||
self.assertEqual(t.encoding, "latin1")
|
||||
self.assertEqual(t.line_buffering, False)
|
||||
t.__init__(b, encoding="utf8", line_buffering=True)
|
||||
self.assertEquals(t.encoding, "utf8")
|
||||
self.assertEquals(t.line_buffering, True)
|
||||
self.assertEquals("\xe9\n", t.readline())
|
||||
self.assertEqual(t.encoding, "utf8")
|
||||
self.assertEqual(t.line_buffering, True)
|
||||
self.assertEqual("\xe9\n", t.readline())
|
||||
self.assertRaises(TypeError, t.__init__, b, newline=42)
|
||||
self.assertRaises(ValueError, t.__init__, b, newline='xyzzy')
|
||||
|
||||
|
|
@ -1687,11 +1687,11 @@ class TextIOWrapperTest(unittest.TestCase):
|
|||
b = self.BufferedWriter(r, 1000)
|
||||
t = self.TextIOWrapper(b, newline="\n", line_buffering=True)
|
||||
t.write("X")
|
||||
self.assertEquals(r.getvalue(), b"") # No flush happened
|
||||
self.assertEqual(r.getvalue(), b"") # No flush happened
|
||||
t.write("Y\nZ")
|
||||
self.assertEquals(r.getvalue(), b"XY\nZ") # All got flushed
|
||||
self.assertEqual(r.getvalue(), b"XY\nZ") # All got flushed
|
||||
t.write("A\rB")
|
||||
self.assertEquals(r.getvalue(), b"XY\nZA\rB")
|
||||
self.assertEqual(r.getvalue(), b"XY\nZA\rB")
|
||||
|
||||
def test_encoding(self):
|
||||
# Check the encoding attribute is always set, and valid
|
||||
|
|
@ -1714,11 +1714,11 @@ class TextIOWrapperTest(unittest.TestCase):
|
|||
# (3) ignore
|
||||
b = self.BytesIO(b"abc\n\xff\n")
|
||||
t = self.TextIOWrapper(b, encoding="ascii", errors="ignore")
|
||||
self.assertEquals(t.read(), "abc\n\n")
|
||||
self.assertEqual(t.read(), "abc\n\n")
|
||||
# (4) replace
|
||||
b = self.BytesIO(b"abc\n\xff\n")
|
||||
t = self.TextIOWrapper(b, encoding="ascii", errors="replace")
|
||||
self.assertEquals(t.read(), "abc\n\ufffd\n")
|
||||
self.assertEqual(t.read(), "abc\n\ufffd\n")
|
||||
|
||||
def test_encoding_errors_writing(self):
|
||||
# (1) default
|
||||
|
|
@ -1735,14 +1735,14 @@ class TextIOWrapperTest(unittest.TestCase):
|
|||
newline="\n")
|
||||
t.write("abc\xffdef\n")
|
||||
t.flush()
|
||||
self.assertEquals(b.getvalue(), b"abcdef\n")
|
||||
self.assertEqual(b.getvalue(), b"abcdef\n")
|
||||
# (4) replace
|
||||
b = self.BytesIO()
|
||||
t = self.TextIOWrapper(b, encoding="ascii", errors="replace",
|
||||
newline="\n")
|
||||
t.write("abc\xffdef\n")
|
||||
t.flush()
|
||||
self.assertEquals(b.getvalue(), b"abc?def\n")
|
||||
self.assertEqual(b.getvalue(), b"abc?def\n")
|
||||
|
||||
def test_newlines(self):
|
||||
input_lines = [ "unix\n", "windows\r\n", "os9\r", "last\n", "nonl" ]
|
||||
|
|
@ -1777,14 +1777,14 @@ class TextIOWrapperTest(unittest.TestCase):
|
|||
c2 = textio.read(2)
|
||||
if c2 == '':
|
||||
break
|
||||
self.assertEquals(len(c2), 2)
|
||||
self.assertEqual(len(c2), 2)
|
||||
got_lines.append(c2 + textio.readline())
|
||||
else:
|
||||
got_lines = list(textio)
|
||||
|
||||
for got_line, exp_line in zip(got_lines, exp_lines):
|
||||
self.assertEquals(got_line, exp_line)
|
||||
self.assertEquals(len(got_lines), len(exp_lines))
|
||||
self.assertEqual(got_line, exp_line)
|
||||
self.assertEqual(len(got_lines), len(exp_lines))
|
||||
|
||||
def test_newlines_input(self):
|
||||
testdata = b"AAA\nBB\x00B\nCCC\rDDD\rEEE\r\nFFF\r\nGGG"
|
||||
|
|
@ -1798,9 +1798,9 @@ class TextIOWrapperTest(unittest.TestCase):
|
|||
]:
|
||||
buf = self.BytesIO(testdata)
|
||||
txt = self.TextIOWrapper(buf, encoding="ascii", newline=newline)
|
||||
self.assertEquals(txt.readlines(), expected)
|
||||
self.assertEqual(txt.readlines(), expected)
|
||||
txt.seek(0)
|
||||
self.assertEquals(txt.read(), "".join(expected))
|
||||
self.assertEqual(txt.read(), "".join(expected))
|
||||
|
||||
def test_newlines_output(self):
|
||||
testdict = {
|
||||
|
|
@ -1817,8 +1817,8 @@ class TextIOWrapperTest(unittest.TestCase):
|
|||
txt.write("BB\nCCC\n")
|
||||
txt.write("X\rY\r\nZ")
|
||||
txt.flush()
|
||||
self.assertEquals(buf.closed, False)
|
||||
self.assertEquals(buf.getvalue(), expected)
|
||||
self.assertEqual(buf.closed, False)
|
||||
self.assertEqual(buf.getvalue(), expected)
|
||||
|
||||
def test_destructor(self):
|
||||
l = []
|
||||
|
|
@ -1832,7 +1832,7 @@ class TextIOWrapperTest(unittest.TestCase):
|
|||
t.write("abc")
|
||||
del t
|
||||
support.gc_collect()
|
||||
self.assertEquals([b"abc"], l)
|
||||
self.assertEqual([b"abc"], l)
|
||||
|
||||
def test_override_destructor(self):
|
||||
record = []
|
||||
|
|
@ -1879,26 +1879,26 @@ class TextIOWrapperTest(unittest.TestCase):
|
|||
for enc in "ascii", "latin1", "utf8" :# , "utf-16-be", "utf-16-le":
|
||||
f = self.open(support.TESTFN, "w+", encoding=enc)
|
||||
f._CHUNK_SIZE = chunksize
|
||||
self.assertEquals(f.write("abc"), 3)
|
||||
self.assertEqual(f.write("abc"), 3)
|
||||
f.close()
|
||||
f = self.open(support.TESTFN, "r+", encoding=enc)
|
||||
f._CHUNK_SIZE = chunksize
|
||||
self.assertEquals(f.tell(), 0)
|
||||
self.assertEquals(f.read(), "abc")
|
||||
self.assertEqual(f.tell(), 0)
|
||||
self.assertEqual(f.read(), "abc")
|
||||
cookie = f.tell()
|
||||
self.assertEquals(f.seek(0), 0)
|
||||
self.assertEquals(f.read(None), "abc")
|
||||
self.assertEqual(f.seek(0), 0)
|
||||
self.assertEqual(f.read(None), "abc")
|
||||
f.seek(0)
|
||||
self.assertEquals(f.read(2), "ab")
|
||||
self.assertEquals(f.read(1), "c")
|
||||
self.assertEquals(f.read(1), "")
|
||||
self.assertEquals(f.read(), "")
|
||||
self.assertEquals(f.tell(), cookie)
|
||||
self.assertEquals(f.seek(0), 0)
|
||||
self.assertEquals(f.seek(0, 2), cookie)
|
||||
self.assertEquals(f.write("def"), 3)
|
||||
self.assertEquals(f.seek(cookie), cookie)
|
||||
self.assertEquals(f.read(), "def")
|
||||
self.assertEqual(f.read(2), "ab")
|
||||
self.assertEqual(f.read(1), "c")
|
||||
self.assertEqual(f.read(1), "")
|
||||
self.assertEqual(f.read(), "")
|
||||
self.assertEqual(f.tell(), cookie)
|
||||
self.assertEqual(f.seek(0), 0)
|
||||
self.assertEqual(f.seek(0, 2), cookie)
|
||||
self.assertEqual(f.write("def"), 3)
|
||||
self.assertEqual(f.seek(cookie), cookie)
|
||||
self.assertEqual(f.read(), "def")
|
||||
if enc.startswith("utf"):
|
||||
self.multi_line_test(f, enc)
|
||||
f.close()
|
||||
|
|
@ -1923,7 +1923,7 @@ class TextIOWrapperTest(unittest.TestCase):
|
|||
if not line:
|
||||
break
|
||||
rlines.append((pos, line))
|
||||
self.assertEquals(rlines, wlines)
|
||||
self.assertEqual(rlines, wlines)
|
||||
|
||||
def test_telling(self):
|
||||
f = self.open(support.TESTFN, "w+", encoding="utf8")
|
||||
|
|
@ -1933,16 +1933,16 @@ class TextIOWrapperTest(unittest.TestCase):
|
|||
f.write("\xff\n")
|
||||
p2 = f.tell()
|
||||
f.seek(0)
|
||||
self.assertEquals(f.tell(), p0)
|
||||
self.assertEquals(f.readline(), "\xff\n")
|
||||
self.assertEquals(f.tell(), p1)
|
||||
self.assertEquals(f.readline(), "\xff\n")
|
||||
self.assertEquals(f.tell(), p2)
|
||||
self.assertEqual(f.tell(), p0)
|
||||
self.assertEqual(f.readline(), "\xff\n")
|
||||
self.assertEqual(f.tell(), p1)
|
||||
self.assertEqual(f.readline(), "\xff\n")
|
||||
self.assertEqual(f.tell(), p2)
|
||||
f.seek(0)
|
||||
for line in f:
|
||||
self.assertEquals(line, "\xff\n")
|
||||
self.assertEqual(line, "\xff\n")
|
||||
self.assertRaises(IOError, f.tell)
|
||||
self.assertEquals(f.tell(), p2)
|
||||
self.assertEqual(f.tell(), p2)
|
||||
f.close()
|
||||
|
||||
def test_seeking(self):
|
||||
|
|
@ -1950,7 +1950,7 @@ class TextIOWrapperTest(unittest.TestCase):
|
|||
prefix_size = chunk_size - 2
|
||||
u_prefix = "a" * prefix_size
|
||||
prefix = bytes(u_prefix.encode("utf-8"))
|
||||
self.assertEquals(len(u_prefix), len(prefix))
|
||||
self.assertEqual(len(u_prefix), len(prefix))
|
||||
u_suffix = "\u8888\n"
|
||||
suffix = bytes(u_suffix.encode("utf-8"))
|
||||
line = prefix + suffix
|
||||
|
|
@ -1959,9 +1959,9 @@ class TextIOWrapperTest(unittest.TestCase):
|
|||
f.close()
|
||||
f = self.open(support.TESTFN, "r", encoding="utf-8")
|
||||
s = f.read(prefix_size)
|
||||
self.assertEquals(s, str(prefix, "ascii"))
|
||||
self.assertEquals(f.tell(), prefix_size)
|
||||
self.assertEquals(f.readline(), u_suffix)
|
||||
self.assertEqual(s, str(prefix, "ascii"))
|
||||
self.assertEqual(f.tell(), prefix_size)
|
||||
self.assertEqual(f.readline(), u_suffix)
|
||||
|
||||
def test_seeking_too(self):
|
||||
# Regression test for a specific bug
|
||||
|
|
@ -1994,11 +1994,11 @@ class TextIOWrapperTest(unittest.TestCase):
|
|||
for i in range(min_pos, len(decoded) + 1): # seek positions
|
||||
for j in [1, 5, len(decoded) - i]: # read lengths
|
||||
f = self.open(support.TESTFN, encoding='test_decoder')
|
||||
self.assertEquals(f.read(i), decoded[:i])
|
||||
self.assertEqual(f.read(i), decoded[:i])
|
||||
cookie = f.tell()
|
||||
self.assertEquals(f.read(j), decoded[i:i + j])
|
||||
self.assertEqual(f.read(j), decoded[i:i + j])
|
||||
f.seek(cookie)
|
||||
self.assertEquals(f.read(), decoded[i:])
|
||||
self.assertEqual(f.read(), decoded[i:])
|
||||
f.close()
|
||||
|
||||
# Enable the test decoder.
|
||||
|
|
@ -2037,10 +2037,10 @@ class TextIOWrapperTest(unittest.TestCase):
|
|||
f.write(data)
|
||||
f.write(data)
|
||||
f.seek(0)
|
||||
self.assertEquals(f.read(), data * 2)
|
||||
self.assertEqual(f.read(), data * 2)
|
||||
f.seek(0)
|
||||
self.assertEquals(f.read(), data * 2)
|
||||
self.assertEquals(buf.getvalue(), (data * 2).encode(encoding))
|
||||
self.assertEqual(f.read(), data * 2)
|
||||
self.assertEqual(buf.getvalue(), (data * 2).encode(encoding))
|
||||
|
||||
def test_unreadable(self):
|
||||
class UnReadable(self.BytesIO):
|
||||
|
|
@ -2057,7 +2057,7 @@ class TextIOWrapperTest(unittest.TestCase):
|
|||
if not c:
|
||||
break
|
||||
reads += c
|
||||
self.assertEquals(reads, "AA\nBB")
|
||||
self.assertEqual(reads, "AA\nBB")
|
||||
|
||||
def test_readlines(self):
|
||||
txt = self.TextIOWrapper(self.BytesIO(b"AA\nBB\nCC"))
|
||||
|
|
@ -2077,7 +2077,7 @@ class TextIOWrapperTest(unittest.TestCase):
|
|||
if not c:
|
||||
break
|
||||
reads += c
|
||||
self.assertEquals(reads, "A"*127+"\nB")
|
||||
self.assertEqual(reads, "A"*127+"\nB")
|
||||
|
||||
def test_issue1395_1(self):
|
||||
txt = self.TextIOWrapper(self.BytesIO(self.testdata), encoding="ascii")
|
||||
|
|
@ -2089,7 +2089,7 @@ class TextIOWrapperTest(unittest.TestCase):
|
|||
if not c:
|
||||
break
|
||||
reads += c
|
||||
self.assertEquals(reads, self.normalized)
|
||||
self.assertEqual(reads, self.normalized)
|
||||
|
||||
def test_issue1395_2(self):
|
||||
txt = self.TextIOWrapper(self.BytesIO(self.testdata), encoding="ascii")
|
||||
|
|
@ -2101,7 +2101,7 @@ class TextIOWrapperTest(unittest.TestCase):
|
|||
if not c:
|
||||
break
|
||||
reads += c
|
||||
self.assertEquals(reads, self.normalized)
|
||||
self.assertEqual(reads, self.normalized)
|
||||
|
||||
def test_issue1395_3(self):
|
||||
txt = self.TextIOWrapper(self.BytesIO(self.testdata), encoding="ascii")
|
||||
|
|
@ -2112,7 +2112,7 @@ class TextIOWrapperTest(unittest.TestCase):
|
|||
reads += txt.readline()
|
||||
reads += txt.readline()
|
||||
reads += txt.readline()
|
||||
self.assertEquals(reads, self.normalized)
|
||||
self.assertEqual(reads, self.normalized)
|
||||
|
||||
def test_issue1395_4(self):
|
||||
txt = self.TextIOWrapper(self.BytesIO(self.testdata), encoding="ascii")
|
||||
|
|
@ -2120,7 +2120,7 @@ class TextIOWrapperTest(unittest.TestCase):
|
|||
|
||||
reads = txt.read(4)
|
||||
reads += txt.read()
|
||||
self.assertEquals(reads, self.normalized)
|
||||
self.assertEqual(reads, self.normalized)
|
||||
|
||||
def test_issue1395_5(self):
|
||||
txt = self.TextIOWrapper(self.BytesIO(self.testdata), encoding="ascii")
|
||||
|
|
@ -2130,7 +2130,7 @@ class TextIOWrapperTest(unittest.TestCase):
|
|||
pos = txt.tell()
|
||||
txt.seek(0)
|
||||
txt.seek(pos)
|
||||
self.assertEquals(txt.read(4), "BBB\n")
|
||||
self.assertEqual(txt.read(4), "BBB\n")
|
||||
|
||||
def test_issue2282(self):
|
||||
buffer = self.BytesIO(self.testdata)
|
||||
|
|
@ -2146,12 +2146,12 @@ class TextIOWrapperTest(unittest.TestCase):
|
|||
f.write('aaa')
|
||||
pos = f.tell()
|
||||
with self.open(filename, 'rb') as f:
|
||||
self.assertEquals(f.read(), 'aaa'.encode(charset))
|
||||
self.assertEqual(f.read(), 'aaa'.encode(charset))
|
||||
|
||||
with self.open(filename, 'a', encoding=charset) as f:
|
||||
f.write('xxx')
|
||||
with self.open(filename, 'rb') as f:
|
||||
self.assertEquals(f.read(), 'aaaxxx'.encode(charset))
|
||||
self.assertEqual(f.read(), 'aaaxxx'.encode(charset))
|
||||
|
||||
def test_seek_bom(self):
|
||||
# Same test, but when seeking manually
|
||||
|
|
@ -2166,7 +2166,7 @@ class TextIOWrapperTest(unittest.TestCase):
|
|||
f.seek(0)
|
||||
f.write('bbb')
|
||||
with self.open(filename, 'rb') as f:
|
||||
self.assertEquals(f.read(), 'bbbzzz'.encode(charset))
|
||||
self.assertEqual(f.read(), 'bbbzzz'.encode(charset))
|
||||
|
||||
def test_errors_property(self):
|
||||
with self.open(support.TESTFN, "w") as f:
|
||||
|
|
@ -2194,7 +2194,7 @@ class TextIOWrapperTest(unittest.TestCase):
|
|||
with self.open(support.TESTFN) as f:
|
||||
content = f.read()
|
||||
for n in range(20):
|
||||
self.assertEquals(content.count("Thread%03d\n" % n), 1)
|
||||
self.assertEqual(content.count("Thread%03d\n" % n), 1)
|
||||
|
||||
def test_flush_error_on_close(self):
|
||||
txt = self.TextIOWrapper(self.BytesIO(self.testdata), encoding="ascii")
|
||||
|
|
@ -2248,9 +2248,9 @@ class IncrementalNewlineDecoderTest(unittest.TestCase):
|
|||
def _check_decode(b, s, **kwargs):
|
||||
# We exercise getstate() / setstate() as well as decode()
|
||||
state = decoder.getstate()
|
||||
self.assertEquals(decoder.decode(b, **kwargs), s)
|
||||
self.assertEqual(decoder.decode(b, **kwargs), s)
|
||||
decoder.setstate(state)
|
||||
self.assertEquals(decoder.decode(b, **kwargs), s)
|
||||
self.assertEqual(decoder.decode(b, **kwargs), s)
|
||||
|
||||
_check_decode(b'\xe8\xa2\x88', "\u8888")
|
||||
|
||||
|
|
@ -2299,24 +2299,24 @@ class IncrementalNewlineDecoderTest(unittest.TestCase):
|
|||
# Decode one char at a time
|
||||
for c in s:
|
||||
result.append(decoder.decode(c))
|
||||
self.assertEquals(decoder.newlines, None)
|
||||
self.assertEqual(decoder.newlines, None)
|
||||
_decode_bytewise("abc\n\r")
|
||||
self.assertEquals(decoder.newlines, '\n')
|
||||
self.assertEqual(decoder.newlines, '\n')
|
||||
_decode_bytewise("\nabc")
|
||||
self.assertEquals(decoder.newlines, ('\n', '\r\n'))
|
||||
self.assertEqual(decoder.newlines, ('\n', '\r\n'))
|
||||
_decode_bytewise("abc\r")
|
||||
self.assertEquals(decoder.newlines, ('\n', '\r\n'))
|
||||
self.assertEqual(decoder.newlines, ('\n', '\r\n'))
|
||||
_decode_bytewise("abc")
|
||||
self.assertEquals(decoder.newlines, ('\r', '\n', '\r\n'))
|
||||
self.assertEqual(decoder.newlines, ('\r', '\n', '\r\n'))
|
||||
_decode_bytewise("abc\r")
|
||||
self.assertEquals("".join(result), "abc\n\nabcabc\nabcabc")
|
||||
self.assertEqual("".join(result), "abc\n\nabcabc\nabcabc")
|
||||
decoder.reset()
|
||||
input = "abc"
|
||||
if encoder is not None:
|
||||
encoder.reset()
|
||||
input = encoder.encode(input)
|
||||
self.assertEquals(decoder.decode(input), "abc")
|
||||
self.assertEquals(decoder.newlines, None)
|
||||
self.assertEqual(decoder.decode(input), "abc")
|
||||
self.assertEqual(decoder.newlines, None)
|
||||
|
||||
def test_newline_decoder(self):
|
||||
encodings = (
|
||||
|
|
@ -2337,11 +2337,11 @@ class IncrementalNewlineDecoderTest(unittest.TestCase):
|
|||
def test_newline_bytes(self):
|
||||
# Issue 5433: Excessive optimization in IncrementalNewlineDecoder
|
||||
def _check(dec):
|
||||
self.assertEquals(dec.newlines, None)
|
||||
self.assertEquals(dec.decode("\u0D00"), "\u0D00")
|
||||
self.assertEquals(dec.newlines, None)
|
||||
self.assertEquals(dec.decode("\u0A00"), "\u0A00")
|
||||
self.assertEquals(dec.newlines, None)
|
||||
self.assertEqual(dec.newlines, None)
|
||||
self.assertEqual(dec.decode("\u0D00"), "\u0D00")
|
||||
self.assertEqual(dec.newlines, None)
|
||||
self.assertEqual(dec.decode("\u0A00"), "\u0A00")
|
||||
self.assertEqual(dec.newlines, None)
|
||||
dec = self.IncrementalNewlineDecoder(None, translate=False)
|
||||
_check(dec)
|
||||
dec = self.IncrementalNewlineDecoder(None, translate=True)
|
||||
|
|
@ -2374,28 +2374,28 @@ class MiscIOTest(unittest.TestCase):
|
|||
|
||||
def test_attributes(self):
|
||||
f = self.open(support.TESTFN, "wb", buffering=0)
|
||||
self.assertEquals(f.mode, "wb")
|
||||
self.assertEqual(f.mode, "wb")
|
||||
f.close()
|
||||
|
||||
f = self.open(support.TESTFN, "U")
|
||||
self.assertEquals(f.name, support.TESTFN)
|
||||
self.assertEquals(f.buffer.name, support.TESTFN)
|
||||
self.assertEquals(f.buffer.raw.name, support.TESTFN)
|
||||
self.assertEquals(f.mode, "U")
|
||||
self.assertEquals(f.buffer.mode, "rb")
|
||||
self.assertEquals(f.buffer.raw.mode, "rb")
|
||||
self.assertEqual(f.name, support.TESTFN)
|
||||
self.assertEqual(f.buffer.name, support.TESTFN)
|
||||
self.assertEqual(f.buffer.raw.name, support.TESTFN)
|
||||
self.assertEqual(f.mode, "U")
|
||||
self.assertEqual(f.buffer.mode, "rb")
|
||||
self.assertEqual(f.buffer.raw.mode, "rb")
|
||||
f.close()
|
||||
|
||||
f = self.open(support.TESTFN, "w+")
|
||||
self.assertEquals(f.mode, "w+")
|
||||
self.assertEquals(f.buffer.mode, "rb+") # Does it really matter?
|
||||
self.assertEquals(f.buffer.raw.mode, "rb+")
|
||||
self.assertEqual(f.mode, "w+")
|
||||
self.assertEqual(f.buffer.mode, "rb+") # Does it really matter?
|
||||
self.assertEqual(f.buffer.raw.mode, "rb+")
|
||||
|
||||
g = self.open(f.fileno(), "wb", closefd=False)
|
||||
self.assertEquals(g.mode, "wb")
|
||||
self.assertEquals(g.raw.mode, "wb")
|
||||
self.assertEquals(g.name, f.fileno())
|
||||
self.assertEquals(g.raw.name, f.fileno())
|
||||
self.assertEqual(g.mode, "wb")
|
||||
self.assertEqual(g.raw.mode, "wb")
|
||||
self.assertEqual(g.name, f.fileno())
|
||||
self.assertEqual(g.raw.name, f.fileno())
|
||||
f.close()
|
||||
g.close()
|
||||
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue