diff options
Diffstat (limited to 'Lib/test/test_io.py')
| -rw-r--r-- | Lib/test/test_io.py | 328 |
1 files changed, 164 insertions, 164 deletions
diff --git a/Lib/test/test_io.py b/Lib/test/test_io.py index fe361be..acf90df 100644 --- a/Lib/test/test_io.py +++ b/Lib/test/test_io.py @@ -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() |