def test_readinto(self):
import _io
a = bytearray(b'x' * 10)
f = _io.FileIO(self.tmpfile, 'r+')
assert f.readinto(a) == 5
f.seek(0)
m = memoryview(bytearray(b"helloworld"))
assert f.readinto(m) == 5
#
exc = raises(TypeError, f.readinto, u"hello")
msg = str(exc.value)
# print(msg)
assert " read-write b" in msg and msg.endswith(", not str")
#
exc = raises(TypeError, f.readinto, memoryview(b"hello"))
msg = str(exc.value)
# print(msg)
assert " read-write b" in msg and msg.endswith(", not memoryview")
#
f.close()
assert a == b'a\nb\ncxxxxx'
#
a = bytearray(b'x' * 10)
f = _io.FileIO(self.tmpfile, 'r+')
f.truncate(3)
assert f.readinto(a) == 3
f.close()
assert a == b'a\nbxxxxxxx'
def test_writelines(self):
import _io
filename = self.tmpfile + '_w'
f = _io.FileIO(filename, 'wb')
f.writelines([b"line1\n", b"line2", b"line3"])
f2 = _io.FileIO(filename, 'rb')
assert f2.read() == b"line1\nline2line3"
f.close()
f2.close()
def test_write(self):
import _io
filename = self.tmpfile + '_w'
f = _io.FileIO(filename, 'wb')
f.write(b"test")
# try without flushing
f2 = _io.FileIO(filename, 'rb')
assert f2.read() == b"test"
f.close()
f2.close()
def test_FileIO_fd_does_not_change_inheritable(self):
import _io, posix
fd1, fd2 = posix.pipe()
posix.set_inheritable(fd1, True)
posix.set_inheritable(fd2, False)
f1 = _io.FileIO(fd1, 'r')
f2 = _io.FileIO(fd2, 'w')
assert posix.get_inheritable(fd1) == True
assert posix.get_inheritable(fd2) == False
f1.close()
f2.close()
def test_simple_read(self):
import _io
raw = _io.FileIO(self.tmpfile)
f = _io.BufferedReader(raw)
assert f.read() == "a\nb\nc"
raises(ValueError, f.read, -2)
f.close()
#
raw = _io.FileIO(self.tmpfile)
f = _io.BufferedReader(raw)
r = f.read(4)
assert r == "a\nb\n"
f.close()
def test_readinto(self):
import _io
a = bytearray('x' * 10)
f = _io.FileIO(self.tmpfile, 'r+')
assert f.readinto(a) == 10
f.close()
assert a == 'a\nb\nc\0\0\0\0\0'
#
a = bytearray('x' * 10)
f = _io.FileIO(self.tmpfile, 'r+')
f.truncate(3)
assert f.readinto(a) == 3
f.close()
assert a == 'a\nbxxxxxxx'
def test_simple_read(self):
import _io
raw = _io.FileIO(self.tmpfile)
f = _io.BufferedReader(raw)
assert f.read() == b"a\nb\nc"
raises(ValueError, f.read, -2)
f.close()
#
raw = _io.FileIO(self.tmpfile, 'r+')
f = _io.BufferedReader(raw)
r = f.read(4)
assert r == b"a\nb\n"
assert f.readable() is True
assert f.writable() is False
f.close()
def test_readlines(self):
import _io
f = _io.FileIO(self.tmpfile, 'rb')
assert f.readlines() == [b"a\n", b"b\n", b"c"]
f.seek(0)
assert f.readlines(3) == [b"a\n", b"b\n"]
f.close()
def test_constructor(self):
import _io
f = _io.FileIO(self.tmpfile, 'a')
assert f.name.endswith('tmpfile')
assert f.mode == 'wb'
assert f.closefd is True
f.close()
def test_truncate(self):
import _io
f = _io.FileIO(self.tmpfile, 'r+b')
assert f.truncate(100) == 100 # grow the file
f.close()
f = _io.FileIO(self.tmpfile)
assert len(f.read()) == 100
f.close()
#
f = _io.FileIO(self.tmpfile, 'r+b')
f.seek(50)
assert f.truncate() == 50
f.close()
f = _io.FileIO(self.tmpfile)
assert len(f.read()) == 50
f.close()
def test_simple_read_after_write(self):
import _io
raw = _io.FileIO(self.tmpfile, 'wb+')
f = _io.BufferedRandom(raw)
f.write('abc')
f.seek(0)
assert f.read() == 'abc'
def get_bench_module(bench_file):
name = bench_file.rpartition("/")[2].partition(".")[0].replace(
'.py', '')
directory = bench_file.rpartition("/")[0]
pkg = []
while any(f.endswith("__init__.py") for f in os.listdir(directory)):
directory, slash, postfix = directory.rpartition("/")
pkg.insert(0, postfix)
if pkg:
sys.path.insert(0, directory)
bench_module = __import__(".".join(pkg + [name]))
for p in pkg[1:]:
bench_module = getattr(bench_module, p)
bench_module = getattr(bench_module, name)
return bench_module
else:
bench_module = types.ModuleType(name, bench_file)
with _io.FileIO(bench_file, "r") as f:
bench_module.__file__ = bench_file
bench_module.ccompile = ccompile
exec(compile(f.readall(), bench_file, "exec"),
bench_module.__dict__)
return bench_module
def test_modules(self):
for testfile in self.testfiles:
name = testfile.rpartition("/")[2].partition(".")[0].replace(
'.py', '')
directory = testfile.rpartition("/")[0]
pkg = []
while any(
f.endswith("__init__.py") for f in os.listdir(directory)):
directory, slash, postfix = directory.rpartition("/")
pkg.insert(0, postfix)
if pkg:
sys.path.insert(0, directory)
try:
test_module = __import__(".".join(pkg + [name]))
for p in pkg[1:]:
test_module = getattr(test_module, p)
test_module = getattr(test_module, name)
except BaseException as e:
self.exceptions.append((testfile, e))
else:
yield test_module
sys.path.pop(0)
else:
test_module = type(sys)(name, testfile)
try:
with _io.FileIO(testfile, "r") as f:
test_module.__file__ = testfile
exec(compile(f.readall(), testfile, "exec"),
test_module.__dict__)
except BaseException as e:
self.exceptions.append((testfile, e))
else:
yield test_module
def test_weakrefable(self):
import _io
from weakref import proxy
f = _io.FileIO(self.tmpfile)
p = proxy(f)
assert p.mode == 'rb'
f.close()
def test_largewrite(self):
import _io
raw = _io.FileIO(self.tmpfile, 'w')
f = _io.BufferedWriter(raw)
f.write("abcd" * 5000)
f.close()
assert self.readfile() == "abcd" * 5000
def test_readinto_array(self):
import _io, array
buffer = array.array('i', [0] * 10)
m = memoryview(buffer)
f = _io.FileIO(self.tmpfile, 'r+')
assert f.readinto(m[1:9]) == 5
assert buffer[1] in (0x610a620a, 0x0a620a61)
def test_peek(self):
import _io
raw = _io.FileIO(self.tmpfile)
f = _io.BufferedReader(raw)
assert f.read(2) == 'a\n'
assert f.peek().startswith('b\nc')
assert f.read(3) == 'b\nc'
assert f.peek() == ''
def test_readinto(self):
import _io
a = bytearray('x' * 10)
raw = _io.FileIO(self.tmpfile)
f = _io.BufferedReader(raw)
assert f.readinto(a) == 5
f.close()
assert a == 'a\nb\ncxxxxx'
def test_monkeypatch_works(self):
import _io, os
raw = _io.FileIO(os.devnull)
f = _io.BufferedReader(raw)
with raises(ValueError) as e:
f.read(1024)
assert e.value.args[
0] == "rgc.nonmoving_raw_ptr_for_resizable_list() not supported under RevDB"
def test_readline(self):
import _io
f = _io.FileIO(self.tmpfile, 'rb')
assert f.readline() == b'a\n'
assert f.readline() == b'b\n'
assert f.readline() == b'c'
assert f.readline() == b''
f.close()
def test_close_upon_reinit(self):
import _io, posix
f = _io.FileIO(self.tmpfile, 'r')
fd1 = f.fileno()
f.__init__(self.tmpfile, 'w')
fd2 = f.fileno()
if fd1 != fd2:
raises(OSError, posix.close, fd1)
def test_truncate_after_close(self):
import _io
raw = _io.FileIO(self.tmpfile, 'w+')
b = _io.BufferedWriter(raw)
b.close()
with raises(ValueError) as exc:
b.truncate()
assert exc.value.args[0] == "truncate of closed file"
def test_write(self):
import _io
raw = _io.FileIO(self.tmpfile, 'w')
f = _io.BufferedWriter(raw)
f.write(b"abcd")
raises(TypeError, f.write, u"cd")
f.close()
assert self.readfile() == b"abcd"
def test_simple_read(self):
import _io
raw = _io.FileIO(self.tmpfile, 'rb+')
f = _io.BufferedRandom(raw)
assert f.read(3) == 'a\nb'
f.write('xxxx')
f.seek(0)
assert f.read() == 'a\nbxxxx'
def test_truncate(self):
import _io
raw = _io.FileIO(self.tmpfile, 'w+')
raw.write('x' * 20)
b = _io.BufferedReader(raw)
assert b.seek(8) == 8
assert b.truncate() == 8
assert b.tell() == 8
def test_incomplete(self):
import _io
raw = _io.FileIO(self.tmpfile)
b = _io.BufferedWriter.__new__(_io.BufferedWriter)
raises(IOError, b.__init__, raw) # because file is not writable
raises(ValueError, getattr, b, 'closed')
raises(ValueError, b.flush)
raises(ValueError, b.close)
def test_open_fd(self):
import _io
os = self.posix
fd = os.open(self.tmpfile, os.O_RDONLY, 0o666)
f = _io.FileIO(fd, "rb", closefd=False)
assert f.fileno() == fd
assert f.closefd is False
f.close()
os.close(fd)
def test_read_pieces(self):
import _io
raw = _io.FileIO(self.tmpfile)
f = _io.BufferedReader(raw)
assert f.read(3) == "a\nb"
assert f.read(3) == "\nc"
assert f.read(3) == ""
assert f.read(3) == ""
f.close()
def test_check_several_writes(self):
import _io
raw = _io.FileIO(self.tmpfile, 'w')
b = _io.BufferedWriter(raw, 13)
for i in range(4):
assert b.write('x' * 10) == 10
b.flush()
assert self.readfile() == 'x' * 40
def test_constructor(self):
import _io
f = _io.FileIO(self.tmpfile, 'a')
assert f.name.endswith('tmpfile')
assert f.mode == 'ab'
assert f.closefd is True
assert f._blksize >= 1024
assert f._blksize % 1024 == 0
f.close()
