Author: benjamin.peterson
Date: Sat Feb 28 01:26:12 2009
New Revision: 70041
Log:
kill java naming for sanity
Modified:
python/branches/io-c/Lib/test/test_io.py
Modified: python/branches/io-c/Lib/test/test_io.py
==============================================================================
--- python/branches/io-c/Lib/test/test_io.py (original)
+++ python/branches/io-c/Lib/test/test_io.py Sat Feb 28 01:26:12 2009
@@ -516,25 +516,25 @@
class CommonBufferedTests:
# Tests common to BufferedReader, BufferedWriter and BufferedRandom
- def testFileno(self):
+ def test_fileno(self):
rawio = self.MockRawIO()
bufio = self.tp(rawio)
self.assertEquals(42, bufio.fileno())
- def testFilenoNoFileno(self):
+ def test_no_fileno(self):
# XXX will we always have fileno() function? If so, kill
# this test. Else, write it.
pass
- def testInvalidArgs(self):
+ def test_invalid_args(self):
rawio = self.MockRawIO()
bufio = self.tp(rawio)
# Invalid whence
self.assertRaises(ValueError, bufio.seek, 0, -1)
self.assertRaises(ValueError, bufio.seek, 0, 3)
- def testOverrideDestructor(self):
+ def test_override_destructor(self):
tp = self.tp
record = []
class MyBufferedIO(tp):
@@ -561,7 +561,7 @@
else:
self.assertEqual(record, [1, 2])
- def testContext(self):
+ def test_context_manager(self):
# Test usability as a context manager
rawio = self.MockRawIO()
bufio = self.tp(rawio)
@@ -573,7 +573,7 @@
# a ValueError.
self.assertRaises(ValueError, _with)
- def testErrorThroughDestructor(self):
+ def test_error_through_destructor(self):
# Test that the exception state is not modified by a destructor,
# even if close() fails.
rawio = self.CloseFailureIO()
@@ -592,7 +592,7 @@
class BufferedReaderTest(unittest.TestCase, CommonBufferedTests):
read_mode = "rb"
- def testConstructor(self):
+ def test_constructor(self):
rawio = self.MockRawIO([b"abc"])
bufio = self.tp(rawio)
bufio.__init__(rawio)
@@ -606,14 +606,14 @@
bufio.__init__(rawio)
self.assertEquals(b"abc", bufio.read())
- def testRead(self):
+ def test_read(self):
rawio = self.MockRawIO((b"abc", b"d", b"efg"))
bufio = self.tp(rawio)
self.assertEquals(b"abcdef", bufio.read(6))
# Invalid args
self.assertRaises(ValueError, bufio.read, -2)
- def testRead1(self):
+ def test_read1(self):
rawio = self.MockRawIO((b"abc", b"d", b"efg"))
bufio = self.tp(rawio)
self.assertEquals(b"a", bufio.read(1))
@@ -629,7 +629,7 @@
# Invalid args
self.assertRaises(ValueError, bufio.read1, -1)
- def testReadinto(self):
+ def test_readinto(self):
rawio = self.MockRawIO((b"abc", b"d", b"efg"))
bufio = self.tp(rawio)
b = bytearray(2)
@@ -644,7 +644,7 @@
self.assertEquals(bufio.readinto(b), 0)
self.assertEquals(b, b"gf")
- def testBuffering(self):
+ def test_buffering(self):
data = b"abcdefghi"
dlen = len(data)
@@ -664,7 +664,7 @@
# this is mildly implementation-dependent
self.assertEquals(rawio.read_history, raw_read_sizes)
- def testReadNonBlocking(self):
+ 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)
@@ -676,19 +676,19 @@
self.assert_(None is bufio.read())
self.assertEquals(b"", bufio.read())
- def testReadToEof(self):
+ 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))
- def testReadNoArgs(self):
+ def test_read_all(self):
rawio = self.MockRawIO((b"abc", b"d", b"efg"))
bufio = self.tp(rawio)
self.assertEquals(b"abcdefg", bufio.read())
- def testThreads(self):
+ def test_threads(self):
try:
# Write out many bytes with exactly the same number of 0's,
# 1's... 255's. This will help us check that concurrent reading
@@ -730,7 +730,7 @@
finally:
support.unlink(support.TESTFN)
- def testMisbehavedRawIO(self):
+ def test_misbehaved_io(self):
rawio = self.MisbehavedRawIO((b"abc", b"d", b"efg"))
bufio = self.tp(rawio)
self.assertRaises(IOError, bufio.seek, 0)
@@ -739,8 +739,8 @@
class CBufferedReaderTest(BufferedReaderTest):
tp = io.BufferedReader
- def testConstructor(self):
- BufferedReaderTest.testConstructor(self)
+ def test_constructor(self):
+ BufferedReaderTest.test_constructor(self)
# The allocation can succeed on 32-bit builds, e.g. with more
# than 2GB RAM and a 64-bit kernel.
if sys.maxsize > 0x7FFFFFFF:
@@ -759,7 +759,7 @@
self.assertRaises(ValueError, bufio.__init__, rawio, buffer_size=-1)
self.assertRaises(ValueError, bufio.read)
- def testMisbehavedRawIORead(self):
+ def test_misbehaved_io_read(self):
rawio = self.MisbehavedRawIO((b"abc", b"d", b"efg"))
bufio = self.tp(rawio)
# _pyio.BufferedReader seems to implement reading different, so that
@@ -784,7 +784,7 @@
class BufferedWriterTest(unittest.TestCase, CommonBufferedTests):
write_mode = "wb"
- def testConstructor(self):
+ def test_constructor(self):
rawio = self.MockRawIO()
bufio = self.tp(rawio)
bufio.__init__(rawio)
@@ -800,14 +800,14 @@
bufio.flush()
self.assertEquals(b"".join(rawio._write_stack), b"abcghi")
- def testWrite(self):
+ def test_write(self):
# Write to the buffered IO but don't overflow the buffer.
writer = self.MockRawIO()
bufio = self.tp(writer, 8)
bufio.write(b"abc")
self.assertFalse(writer._write_stack)
- def testWriteOverflow(self):
+ def test_write_overflow(self):
writer = self.MockRawIO()
bufio = self.tp(writer, 8)
contents = b"abcdefghijklmnop"
@@ -838,13 +838,13 @@
bufio.flush()
self.assertEquals(contents, b"".join(writer._write_stack))
- def testWrites(self):
+ def test_writes(self):
self.check_writes(lambda bufio: None)
- def testWritesAndFlushes(self):
+ def test_writes_and_flushes(self):
self.check_writes(lambda bufio: bufio.flush())
- def testWritesAndSeeks(self):
+ def test_writes_and_seeks(self):
def _seekabs(bufio):
pos = bufio.tell()
bufio.seek(pos + 1, 0)
@@ -858,10 +858,10 @@
bufio.seek(pos, 0)
self.check_writes(_seekrel)
- def testWritesAndTruncates(self):
+ def test_writes_and_truncates(self):
self.check_writes(lambda bufio: bufio.truncate(bufio.tell()))
- def testWriteNonBlocking(self):
+ def test_write_non_blocking(self):
raw = self.MockNonBlockWriterIO()
bufio = self.tp(raw, 8, 8)
@@ -888,7 +888,7 @@
# Previously buffered bytes were flushed
self.assertTrue(s.startswith(b"01234567A"), s)
- def testWriteAndRewind(self):
+ def test_write_and_rewind(self):
raw = io.BytesIO()
bufio = self.tp(raw, 4)
self.assertEqual(bufio.write(b"abcdef"), 6)
@@ -901,21 +901,21 @@
bufio.flush()
self.assertEqual(raw.getvalue(), b"XYcdef123456")
- def testFlush(self):
+ def test_flush(self):
writer = self.MockRawIO()
bufio = self.tp(writer, 8)
bufio.write(b"abc")
bufio.flush()
self.assertEquals(b"abc", writer._write_stack[0])
- def testDestructor(self):
+ def test_destructor(self):
writer = self.MockRawIO()
bufio = self.tp(writer, 8)
bufio.write(b"abc")
del bufio
self.assertEquals(b"abc", writer._write_stack[0])
- def testTruncate(self):
+ def test_truncate(self):
# Truncate implicitly flushes the buffer.
with io.open(support.TESTFN, self.write_mode, buffering=0) as raw:
bufio = self.tp(raw, 8)
@@ -925,7 +925,7 @@
with io.open(support.TESTFN, "rb", buffering=0) as f:
self.assertEqual(f.read(), b"abc")
- def testThreads(self):
+ def test_threads(self):
try:
# Write out many bytes from many threads and test they were
# all flushed.
@@ -974,7 +974,7 @@
finally:
support.unlink(support.TESTFN)
- def testMisbehavedRawIO(self):
+ def test_misbehaved_io(self):
rawio = self.MisbehavedRawIO()
bufio = self.tp(rawio, 5)
self.assertRaises(IOError, bufio.seek, 0)
@@ -984,8 +984,8 @@
class CBufferedWriterTest(BufferedWriterTest):
tp = io.BufferedWriter
- def testConstructor(self):
- BufferedWriterTest.testConstructor(self)
+ def test_constructor(self):
+ BufferedWriterTest.test_constructor(self)
# The allocation can succeed on 32-bit builds, e.g. with more
# than 2GB RAM and a 64-bit kernel.
if sys.maxsize > 0x7FFFFFFF:
@@ -1025,7 +1025,7 @@
class BufferedRWPairTest(unittest.TestCase):
- def testRWPair(self):
+ def test_basic(self):
r = self.MockRawIO(())
w = self.MockRawIO()
pair = self.tp(r, w)
@@ -1044,11 +1044,11 @@
read_mode = "rb+"
write_mode = "wb+"
- def testConstructor(self):
- BufferedReaderTest.testConstructor(self)
- BufferedWriterTest.testConstructor(self)
+ def test_constructor(self):
+ BufferedReaderTest.test_constructor(self)
+ BufferedWriterTest.test_constructor(self)
- def testReadAndWrite(self):
+ def test_read_and_write(self):
raw = self.MockRawIO((b"asdf", b"ghjk"))
rw = self.tp(raw, 8, 12)
@@ -1059,7 +1059,7 @@
self.assertEqual(b"ghjk", rw.read())
self.assertEquals(b"dddeee", raw._write_stack[0])
- def testSeekAndTell(self):
+ def test_seek_and_tell(self):
raw = self.BytesIO(b"asdfghjkl")
rw = self.tp(raw)
@@ -1097,17 +1097,17 @@
bufio.seek(0, 0)
self.assertEquals(b"XYZ", read_func(bufio, 3))
- def testFlushAndRead(self):
+ def test_flush_and_read(self):
self.check_flush_and_read(lambda bufio, *args: bufio.read(*args))
- def testFlushAndReadinto(self):
+ def test_flush_and_readinto(self):
def _readinto(bufio, n=-1):
b = bytearray(n if n >= 0 else 9999)
n = bufio.readinto(b)
return bytes(b[:n])
self.check_flush_and_read(_readinto)
- def testFlushAndPeek(self):
+ def test_flush_and_peek(self):
def _peek(bufio, n=-1):
# This relies on the fact that the buffer can contain the whole
# raw stream, otherwise peek() can return less.
@@ -1118,7 +1118,7 @@
return b
self.check_flush_and_read(_peek)
- def testFlushAndWrite(self):
+ def test_flush_and_write(self):
raw = self.BytesIO(b"abcdefghi")
bufio = self.tp(raw)
@@ -1130,11 +1130,11 @@
self.assertEquals(b"12345fghi", raw.getvalue())
self.assertEquals(b"12345fghi", bufio.read())
- def testThreads(self):
- BufferedReaderTest.testThreads(self)
- BufferedWriterTest.testThreads(self)
+ def test_threads(self):
+ BufferedReaderTest.test_threads(self)
+ BufferedWriterTest.test_threads(self)
- def testWritesAndPeeks(self):
+ def test_writes_and_peek(self):
def _peek(bufio):
bufio.peek(1)
self.check_writes(_peek)
@@ -1145,33 +1145,33 @@
bufio.seek(pos, 0)
self.check_writes(_peek)
- def testWritesAndReads(self):
+ def test_writes_and_reads(self):
def _read(bufio):
bufio.seek(-1, 1)
bufio.read(1)
self.check_writes(_read)
- def testWritesAndRead1s(self):
+ def test_writes_and_read1s(self):
def _read1(bufio):
bufio.seek(-1, 1)
bufio.read1(1)
self.check_writes(_read1)
- def testWritesAndReadintos(self):
+ def test_writes_and_readintos(self):
def _read(bufio):
bufio.seek(-1, 1)
bufio.readinto(bytearray(1))
self.check_writes(_read)
- def testMisbehavedRawIO(self):
- BufferedReaderTest.testMisbehavedRawIO(self)
- BufferedWriterTest.testMisbehavedRawIO(self)
+ def test_misbehaved_io(self):
+ BufferedReaderTest.test_misbehaved_io(self)
+ BufferedWriterTest.test_misbehaved_io(self)
class CBufferedRandomTest(BufferedRandomTest):
tp = io.BufferedRandom
- def testConstructor(self):
- BufferedRandomTest.testConstructor(self)
+ def test_constructor(self):
+ BufferedRandomTest.test_constructor(self)
# The allocation can succeed on 32-bit builds, e.g. with more
# than 2GB RAM and a 64-bit kernel.
if sys.maxsize > 0x7FFFFFFF:
@@ -1321,7 +1321,7 @@
'm--------------.')
]
- def testDecoder(self):
+ def test_decoder(self):
# Try a few one-shot test cases.
for input, eof, output in self.test_cases:
d = StatefulIncrementalDecoder()
@@ -1342,7 +1342,7 @@
def tearDown(self):
support.unlink(support.TESTFN)
- def testConstructor(self):
+ def test_constructor(self):
r = self.BytesIO(b"\xc3\xa9\n\n")
b = self.BufferedReader(r, 1000)
t = self.TextIOWrapper(b)
@@ -1356,7 +1356,7 @@
self.assertRaises(TypeError, t.__init__, b, newline=42)
self.assertRaises(ValueError, t.__init__, b, newline='xyzzy')
- def testLineBuffering(self):
+ def test_line_buffering(self):
r = self.BytesIO()
b = self.BufferedWriter(r, 1000)
t = self.TextIOWrapper(b, newline="\n", line_buffering=True)
@@ -1367,7 +1367,7 @@
t.write("A\rB")
self.assertEquals(r.getvalue(), b"XY\nZA\rB")
- def testEncoding(self):
+ def test_encoding(self):
# Check the encoding attribute is always set, and valid
b = self.BytesIO()
t = self.TextIOWrapper(b, encoding="utf8")
@@ -1376,7 +1376,7 @@
self.assert_(t.encoding is not None)
codecs.lookup(t.encoding)
- def testEncodingErrorsReading(self):
+ def test_encoding_errors_reading(self):
# (1) default
b = self.BytesIO(b"abc\n\xff\n")
t = self.TextIOWrapper(b, encoding="ascii")
@@ -1394,7 +1394,7 @@
t = self.TextIOWrapper(b, encoding="ascii", errors="replace")
self.assertEquals(t.read(), "abc\n\ufffd\n")
- def testEncodingErrorsWriting(self):
+ def test_encoding_errors_writing(self):
# (1) default
b = self.BytesIO()
t = self.TextIOWrapper(b, encoding="ascii")
@@ -1418,7 +1418,7 @@
t.flush()
self.assertEquals(b.getvalue(), b"abc?def\n")
- def testNewlines(self):
+ def test_newlines(self):
input_lines = [ "unix\n", "windows\r\n", "os9\r", "last\n", "nonl" ]
tests = [
@@ -1460,7 +1460,7 @@
self.assertEquals(got_line, exp_line)
self.assertEquals(len(got_lines), len(exp_lines))
- def testNewlinesInput(self):
+ def test_newlines_input(self):
testdata = b"AAA\nBB\x00B\nCCC\rDDD\rEEE\r\nFFF\r\nGGG"
normalized = testdata.replace(b"\r\n", b"\n").replace(b"\r", b"\n")
for newline, expected in [
@@ -1476,7 +1476,7 @@
txt.seek(0)
self.assertEquals(txt.read(), "".join(expected))
- def testNewlinesOutput(self):
+ def test_newlines_output(self):
testdict = {
"": b"AAA\nBBB\nCCC\nX\rY\r\nZ",
"\n": b"AAA\nBBB\nCCC\nX\rY\r\nZ",
@@ -1494,7 +1494,7 @@
self.assertEquals(buf.closed, False)
self.assertEquals(buf.getvalue(), expected)
- def testDestructor(self):
+ def test_destructor(self):
l = []
base = self.BytesIO
class MyBytesIO(base):
@@ -1507,7 +1507,7 @@
del t
self.assertEquals([b"abc"], l)
- def testOverrideDestructor(self):
+ def test_override_destructor(self):
record = []
class MyTextIO(self.TextIOWrapper):
def __del__(self):
@@ -1529,7 +1529,7 @@
del t
self.assertEqual(record, [1, 2, 3])
- def testErrorThroughDestructor(self):
+ def test_error_through_destructor(self):
# Test that the exception state is not modified by a destructor,
# even if close() fails.
rawio = self.CloseFailureIO()
@@ -1546,7 +1546,7 @@
# Systematic tests of the text I/O API
- def testBasicIO(self):
+ def test_basic_io(self):
for chunksize in (1, 2, 3, 4, 5, 15, 16, 17, 31, 32, 33, 63, 64, 65):
for enc in "ascii", "latin1", "utf8" :# , "utf-16-be", "utf-16-le":
f = self.open(support.TESTFN, "w+", encoding=enc)
@@ -1595,7 +1595,7 @@
rlines.append((pos, line))
self.assertEquals(rlines, wlines)
- def testTelling(self):
+ def test_telling(self):
f = self.open(support.TESTFN, "w+", encoding="utf8")
p0 = f.tell()
f.write("\xff\n")
@@ -1615,7 +1615,7 @@
self.assertEquals(f.tell(), p2)
f.close()
- def testSeeking(self):
+ def test_seeking(self):
chunk_size = _default_chunk_size()
prefix_size = chunk_size - 2
u_prefix = "a" * prefix_size
@@ -1633,7 +1633,7 @@
self.assertEquals(f.tell(), prefix_size)
self.assertEquals(f.readline(), u_suffix)
- def testSeekingToo(self):
+ def test_seeking_too(self):
# Regression test for a specific bug
data = b'\xe0\xbf\xbf\n'
f = self.open(support.TESTFN, "wb")
@@ -1645,7 +1645,7 @@
f.readline()
f.tell()
- def testSeekAndTell(self):
+ def test_seek_and_tell(self):
#Test seek/tell using the StatefulIncrementalDecoder.
# Make test faster by doing smaller seeks
CHUNK_SIZE = 128
@@ -1692,7 +1692,7 @@
finally:
StatefulIncrementalDecoder.codecEnabled = 0
- def testEncodedWrites(self):
+ def test_encoded_writes(self):
data = "1234567890"
tests = ("utf-16",
"utf-16-le",
@@ -1747,7 +1747,7 @@
print("Reading using readline(): %6.3f seconds" % (t3-t2))
print("Using readline()+tell(): %6.3f seconds" % (t4-t3))
- def testReadOneByOne(self):
+ def test_read_one_by_one(self):
txt = self.TextIOWrapper(self.BytesIO(b"AA\r\nBB"))
reads = ""
while True:
@@ -1758,7 +1758,7 @@
self.assertEquals(reads, "AA\nBB")
# read in amounts equal to TextIOWrapper._CHUNK_SIZE which is 128.
- def testReadByChunk(self):
+ def test_read_by_chunk(self):
# make sure "\r\n" straddles 128 char boundary.
txt = self.TextIOWrapper(self.BytesIO(b"A" * 127 + b"\r\nB"))
reads = ""
@@ -1966,7 +1966,7 @@
def tearDown(self):
support.unlink(support.TESTFN)
- def testImport__all__(self):
+ def test___all__(self):
for name in self.io.__all__:
obj = getattr(self.io, name, None)
self.assert_(obj is not None, name)
