test_file.py

importio
importos
importunittest
fromtestimportsupport
fromtest.supportimportimport_helper, os_helper, warnings_helper


_testcapi=import_helper.import_module('_testcapi')
_testlimitedcapi=import_helper.import_module('_testlimitedcapi')
_io=import_helper.import_module('_io')
NULL=None
STDOUT_FD=1

withopen(__file__, 'rb') asfp:
FIRST_LINE=next(fp).decode()
FIRST_LINE_NORM=FIRST_LINE.rstrip() +'\n'


classCAPIFileTest(unittest.TestCase):
deftest_pyfile_fromfd(self):
# Test PyFile_FromFd() which is a thin wrapper to _io.open()
pyfile_fromfd=_testlimitedcapi.pyfile_fromfd
filename=__file__
withopen(filename, "rb") asfp:
fd=fp.fileno()

# FileIO
fp.seek(0)
obj=pyfile_fromfd(fd, filename, "rb", 0, NULL, NULL, NULL, 0)
try:
self.assertIsInstance(obj, _io.FileIO)
self.assertEqual(obj.readline(), FIRST_LINE.encode())
finally:
obj.close()

# BufferedReader
fp.seek(0)
obj=pyfile_fromfd(fd, filename, "rb", 1024, NULL, NULL, NULL, 0)
try:
self.assertIsInstance(obj, _io.BufferedReader)
self.assertEqual(obj.readline(), FIRST_LINE.encode())
finally:
obj.close()

# TextIOWrapper
fp.seek(0)
obj=pyfile_fromfd(fd, filename, "r", 1,
"utf-8", "replace", NULL, 0)
try:
self.assertIsInstance(obj, _io.TextIOWrapper)
self.assertEqual(obj.encoding, "utf-8")
self.assertEqual(obj.errors, "replace")
self.assertEqual(obj.readline(), FIRST_LINE_NORM)
finally:
obj.close()

deftest_pyfile_getline(self):
# Test PyFile_GetLine(file, n): call file.readline()
# and strip "\n" suffix if n < 0.
pyfile_getline=_testlimitedcapi.pyfile_getline

# Test Unicode
withopen(__file__, "r") asfp:
fp.seek(0)
self.assertEqual(pyfile_getline(fp, -1),
FIRST_LINE_NORM.rstrip('\n'))
fp.seek(0)
self.assertEqual(pyfile_getline(fp, 0),
FIRST_LINE_NORM)
fp.seek(0)
self.assertEqual(pyfile_getline(fp, 6),
FIRST_LINE_NORM[:6])

# Test bytes
withopen(__file__, "rb") asfp:
fp.seek(0)
self.assertEqual(pyfile_getline(fp, -1),
FIRST_LINE.rstrip('\n').encode())
fp.seek(0)
self.assertEqual(pyfile_getline(fp, 0),
FIRST_LINE.encode())
fp.seek(0)
self.assertEqual(pyfile_getline(fp, 6),
FIRST_LINE.encode()[:6])

deftest_pyfile_writestring(self):
# Test PyFile_WriteString(str, file): call file.write(str)
writestr=_testlimitedcapi.pyfile_writestring

withio.StringIO() asfp:
self.assertEqual(writestr("a\xe9\u20ac\U0010FFFF".encode(), fp), 0)
withself.assertRaises(UnicodeDecodeError):
writestr(b"\xff", fp)
withself.assertRaises(UnicodeDecodeError):
writestr("\udc80".encode("utf-8", "surrogatepass"), fp)

text=fp.getvalue()
self.assertEqual(text, "a\xe9\u20ac\U0010FFFF")

withself.assertRaises(SystemError):
writestr(b"abc", NULL)

deftest_pyfile_writeobject(self):
# Test PyFile_WriteObject(obj, file, flags):
# - Call file.write(str(obj)) if flags equals Py_PRINT_RAW.
# - Call file.write(repr(obj)) otherwise.
writeobject=_testlimitedcapi.pyfile_writeobject
Py_PRINT_RAW=1

withio.StringIO() asfp:
# Test flags=Py_PRINT_RAW
self.assertEqual(writeobject("raw", fp, Py_PRINT_RAW), 0)
writeobject(NULL, fp, Py_PRINT_RAW)

# Test flags=0
self.assertEqual(writeobject("repr", fp, 0), 0)
writeobject(NULL, fp, 0)

text=fp.getvalue()
self.assertEqual(text, "raw<NULL>'repr'<NULL>")

# invalid file type
forinvalid_filein (123, "abc", object()):
withself.subTest(file=invalid_file):
withself.assertRaises(AttributeError):
writeobject("abc", invalid_file, Py_PRINT_RAW)

withself.assertRaises(TypeError):
writeobject("abc", NULL, 0)

deftest_pyobject_asfiledescriptor(self):
# Test PyObject_AsFileDescriptor(obj):
# - Return obj if obj is an integer.
# - Return obj.fileno() otherwise.
# File descriptor must be >= 0.
asfd=_testlimitedcapi.pyobject_asfiledescriptor

self.assertEqual(asfd(123), 123)
self.assertEqual(asfd(0), 0)

withopen(__file__, "rb") asfp:
self.assertEqual(asfd(fp), fp.fileno())

# bool emits RuntimeWarning
msg=r"bool is used as a file descriptor"
withwarnings_helper.check_warnings((msg, RuntimeWarning)):
self.assertEqual(asfd(True), 1)

classFakeFile:
def__init__(self, fd):
self.fd=fd
deffileno(self):
returnself.fd

# file descriptor must be positive
withself.assertRaises(ValueError):
asfd(-1)
withself.assertRaises(ValueError):
asfd(FakeFile(-1))

# fileno() result must be an integer
withself.assertRaises(TypeError):
asfd(FakeFile("text"))

# unsupported types
forobjin ("string", ["list"], object()):
withself.subTest(obj=obj):
withself.assertRaises(TypeError):
asfd(obj)

# CRASHES asfd(NULL)

deftest_pyfile_newstdprinter(self):
# Test PyFile_NewStdPrinter()
pyfile_newstdprinter=_testcapi.pyfile_newstdprinter

file=pyfile_newstdprinter(STDOUT_FD)
self.assertEqual(file.closed, False)
self.assertIsNone(file.encoding)
self.assertEqual(file.mode, "w")

self.assertEqual(file.fileno(), STDOUT_FD)
self.assertEqual(file.isatty(), os.isatty(STDOUT_FD))

# flush() is a no-op
self.assertIsNone(file.flush())

# close() is a no-op
self.assertIsNone(file.close())
self.assertEqual(file.closed, False)

support.check_disallow_instantiation(self, type(file))

deftest_pyfile_newstdprinter_write(self):
# Test the write() method of PyFile_NewStdPrinter()
pyfile_newstdprinter=_testcapi.pyfile_newstdprinter

filename=os_helper.TESTFN
self.addCleanup(os_helper.unlink, filename)

try:
old_stdout=os.dup(STDOUT_FD)
exceptOSErrorasexc:
# os.dup(STDOUT_FD) is not supported on WASI
self.skipTest(f"os.dup() failed with {exc!r}")

try:
withopen(filename, "wb") asfp:
# PyFile_NewStdPrinter() only accepts fileno(stdout)
# or fileno(stderr) file descriptor.
fd=fp.fileno()
os.dup2(fd, STDOUT_FD)

file=pyfile_newstdprinter(STDOUT_FD)
self.assertEqual(file.write("text"), 4)
# The surrogate character is encoded with
# the "surrogateescape" error handler
self.assertEqual(file.write("[\udc80]"), 8)
finally:
os.dup2(old_stdout, STDOUT_FD)
os.close(old_stdout)

withopen(filename, "r") asfp:
self.assertEqual(fp.read(), "text[\\udc80]")

deftest_py_fopen(self):
# Test Py_fopen() and Py_fclose()
py_fopen=_testcapi.py_fopen

withopen(__file__, "rb") asfp:
source=fp.read()

forfilenamein (__file__, os.fsencode(__file__)):
withself.subTest(filename=filename):
data=py_fopen(filename, "rb")
self.assertEqual(data, source[:256])

data=py_fopen(os_helper.FakePath(filename), "rb")
self.assertEqual(data, source[:256])

filenames= [
os_helper.TESTFN,
os.fsencode(os_helper.TESTFN),
 ]
ifos_helper.TESTFN_UNDECODABLEisnotNone:
filenames.append(os_helper.TESTFN_UNDECODABLE)
filenames.append(os.fsdecode(os_helper.TESTFN_UNDECODABLE))
ifos_helper.TESTFN_UNENCODABLEisnotNone:
filenames.append(os_helper.TESTFN_UNENCODABLE)
forfilenameinfilenames:
withself.subTest(filename=filename):
try:
withopen(filename, "wb") asfp:
fp.write(source)
exceptOSError:
# TESTFN_UNDECODABLE cannot be used to create a file
# on macOS/WASI.
filename=None
continue
try:
data=py_fopen(filename, "rb")
self.assertEqual(data, source[:256])
finally:
os_helper.unlink(filename)

# embedded null character/byte in the filename
withself.assertRaises(ValueError):
py_fopen("a\x00b", "rb")
withself.assertRaises(ValueError):
py_fopen(b"a\x00b", "rb")

# non-ASCII mode failing with "Invalid argument"
withself.assertRaises(OSError):
py_fopen(__file__, b"\xc2\x80")
withself.assertRaises(OSError):
# \x98 is invalid in cp1250, cp1251, cp1257
# \x9d is invalid in cp1252-cp1255, cp1258
py_fopen(__file__, b"\xc2\x98\xc2\x9d")
# UnicodeDecodeError can come from the audit hook code
withself.assertRaises((UnicodeDecodeError, OSError)):
py_fopen(__file__, b"\x98\x9d")

# invalid filename type
forinvalid_typein (123, object()):
withself.subTest(filename=invalid_type):
withself.assertRaises(TypeError):
py_fopen(invalid_type, "rb")

ifsupport.MS_WINDOWS:
withself.assertRaises(OSError):
# On Windows, the file mode is limited to 10 characters
py_fopen(__file__, "rt+, ccs=UTF-8")

# CRASHES py_fopen(NULL, 'rb')
# CRASHES py_fopen(__file__, NULL)

deftest_py_universalnewlinefgets(self):
py_universalnewlinefgets=_testcapi.py_universalnewlinefgets
filename=os_helper.TESTFN
self.addCleanup(os_helper.unlink, filename)

withopen(filename, "wb") asfp:
fp.write(b"line1\nline2")

line=py_universalnewlinefgets(filename, 1000)
self.assertEqual(line, b"line1\n")

withopen(filename, "wb") asfp:
fp.write(b"line2\r\nline3")

line=py_universalnewlinefgets(filename, 1000)
self.assertEqual(line, b"line2\n")

withopen(filename, "wb") asfp:
fp.write(b"line3\rline4")

line=py_universalnewlinefgets(filename, 1000)
self.assertEqual(line, b"line3\n")

# PyFile_SetOpenCodeHook() and PyFile_OpenCode() are tested by
# test_embed.test_open_code_hook()


if__name__=="__main__":
unittest.main()