| 1 |
import io |
| 2 |
import os |
| 3 |
import unittest |
| 4 |
from test import support |
| 5 |
from test.support import import_helper, os_helper, warnings_helper |
| 6 |
|
| 7 |
|
| 8 |
_testcapi = import_helper.import_module('_testcapi') |
| 9 |
_testlimitedcapi = import_helper.import_module('_testlimitedcapi') |
| 10 |
_io = import_helper.import_module('_io') |
| 11 |
NULL = None |
| 12 |
STDOUT_FD = 1 |
| 13 |
|
| 14 |
with open(__file__, 'rb') as fp: |
| 15 |
FIRST_LINE = next(fp).decode() |
| 16 |
FIRST_LINE_NORM = FIRST_LINE.rstrip() + '\n' |
| 17 |
|
| 18 |
|
| 19 |
class CAPIFileTest(unittest.TestCase): |
| 20 |
def test_pyfile_fromfd(self): |
| 21 |
# Test PyFile_FromFd() which is a thin wrapper to _io.open() |
| 22 |
pyfile_fromfd = _testlimitedcapi.pyfile_fromfd |
| 23 |
filename = __file__ |
| 24 |
with open(filename, "rb") as fp: |
| 25 |
fd = fp.fileno() |
| 26 |
|
| 27 |
# FileIO |
| 28 |
fp.seek(0) |
| 29 |
obj = pyfile_fromfd(fd, filename, "rb", 0, NULL, NULL, NULL, 0) |
| 30 |
try: |
| 31 |
self.assertIsInstance(obj, _io.FileIO) |
| 32 |
self.assertEqual(obj.readline(), FIRST_LINE.encode()) |
| 33 |
finally: |
| 34 |
obj.close() |
| 35 |
|
| 36 |
# BufferedReader |
| 37 |
fp.seek(0) |
| 38 |
obj = pyfile_fromfd(fd, filename, "rb", 1024, NULL, NULL, NULL, 0) |
| 39 |
try: |
| 40 |
self.assertIsInstance(obj, _io.BufferedReader) |
| 41 |
self.assertEqual(obj.readline(), FIRST_LINE.encode()) |
| 42 |
finally: |
| 43 |
obj.close() |
| 44 |
|
| 45 |
# TextIOWrapper |
| 46 |
fp.seek(0) |
| 47 |
obj = pyfile_fromfd(fd, filename, "r", 1, |
| 48 |
"utf-8", "replace", NULL, 0) |
| 49 |
try: |
| 50 |
self.assertIsInstance(obj, _io.TextIOWrapper) |
| 51 |
self.assertEqual(obj.encoding, "utf-8") |
| 52 |
self.assertEqual(obj.errors, "replace") |
| 53 |
self.assertEqual(obj.readline(), FIRST_LINE_NORM) |
| 54 |
finally: |
| 55 |
obj.close() |
| 56 |
|
| 57 |
def test_pyfile_getline(self): |
| 58 |
# Test PyFile_GetLine(file, n): call file.readline() |
| 59 |
# and strip "\n" suffix if n < 0. |
| 60 |
pyfile_getline = _testlimitedcapi.pyfile_getline |
| 61 |
|
| 62 |
# Test Unicode |
| 63 |
with open(__file__, "r") as fp: |
| 64 |
fp.seek(0) |
| 65 |
self.assertEqual(pyfile_getline(fp, -1), |
| 66 |
FIRST_LINE_NORM.rstrip('\n')) |
| 67 |
fp.seek(0) |
| 68 |
self.assertEqual(pyfile_getline(fp, 0), |
| 69 |
FIRST_LINE_NORM) |
| 70 |
fp.seek(0) |
| 71 |
self.assertEqual(pyfile_getline(fp, 6), |
| 72 |
FIRST_LINE_NORM[:6]) |
| 73 |
|
| 74 |
# Test bytes |
| 75 |
with open(__file__, "rb") as fp: |
| 76 |
fp.seek(0) |
| 77 |
self.assertEqual(pyfile_getline(fp, -1), |
| 78 |
FIRST_LINE.rstrip('\n').encode()) |
| 79 |
fp.seek(0) |
| 80 |
self.assertEqual(pyfile_getline(fp, 0), |
| 81 |
FIRST_LINE.encode()) |
| 82 |
fp.seek(0) |
| 83 |
self.assertEqual(pyfile_getline(fp, 6), |
| 84 |
FIRST_LINE.encode()[:6]) |
| 85 |
|
| 86 |
def test_pyfile_writestring(self): |
| 87 |
# Test PyFile_WriteString(str, file): call file.write(str) |
| 88 |
writestr = _testlimitedcapi.pyfile_writestring |
| 89 |
|
| 90 |
with io.StringIO() as fp: |
| 91 |
self.assertEqual(writestr("a\xe9\u20ac\U0010FFFF".encode(), fp), 0) |
| 92 |
with self.assertRaises(UnicodeDecodeError): |
| 93 |
writestr(b"\xff", fp) |
| 94 |
with self.assertRaises(UnicodeDecodeError): |
| 95 |
writestr("\udc80".encode("utf-8", "surrogatepass"), fp) |
| 96 |
|
| 97 |
text = fp.getvalue() |
| 98 |
self.assertEqual(text, "a\xe9\u20ac\U0010FFFF") |
| 99 |
|
| 100 |
with self.assertRaises(SystemError): |
| 101 |
writestr(b"abc", NULL) |
| 102 |
|
| 103 |
def test_pyfile_writeobject(self): |
| 104 |
# Test PyFile_WriteObject(obj, file, flags): |
| 105 |
# - Call file.write(str(obj)) if flags equals Py_PRINT_RAW. |
| 106 |
# - Call file.write(repr(obj)) otherwise. |
| 107 |
writeobject = _testlimitedcapi.pyfile_writeobject |
| 108 |
Py_PRINT_RAW = 1 |
| 109 |
|
| 110 |
with io.StringIO() as fp: |
| 111 |
# Test flags=Py_PRINT_RAW |
| 112 |
self.assertEqual(writeobject("raw", fp, Py_PRINT_RAW), 0) |
| 113 |
writeobject(NULL, fp, Py_PRINT_RAW) |
| 114 |
|
| 115 |
# Test flags=0 |
| 116 |
self.assertEqual(writeobject("repr", fp, 0), 0) |
| 117 |
writeobject(NULL, fp, 0) |
| 118 |
|
| 119 |
text = fp.getvalue() |
| 120 |
self.assertEqual(text, "raw<NULL>'repr'<NULL>") |
| 121 |
|
| 122 |
# invalid file type |
| 123 |
for invalid_file in (123, "abc", object()): |
| 124 |
with self.subTest(file=invalid_file): |
| 125 |
with self.assertRaises(AttributeError): |
| 126 |
writeobject("abc", invalid_file, Py_PRINT_RAW) |
| 127 |
|
| 128 |
with self.assertRaises(TypeError): |
| 129 |
writeobject("abc", NULL, 0) |
| 130 |
|
| 131 |
def test_pyobject_asfiledescriptor(self): |
| 132 |
# Test PyObject_AsFileDescriptor(obj): |
| 133 |
# - Return obj if obj is an integer. |
| 134 |
# - Return obj.fileno() otherwise. |
| 135 |
# File descriptor must be >= 0. |
| 136 |
asfd = _testlimitedcapi.pyobject_asfiledescriptor |
| 137 |
|
| 138 |
self.assertEqual(asfd(123), 123) |
| 139 |
self.assertEqual(asfd(0), 0) |
| 140 |
|
| 141 |
with open(__file__, "rb") as fp: |
| 142 |
self.assertEqual(asfd(fp), fp.fileno()) |
| 143 |
|
| 144 |
# bool emits RuntimeWarning |
| 145 |
msg = r"bool is used as a file descriptor" |
| 146 |
with warnings_helper.check_warnings((msg, RuntimeWarning)): |
| 147 |
self.assertEqual(asfd(True), 1) |
| 148 |
|
| 149 |
class FakeFile: |
| 150 |
def __init__(self, fd): |
| 151 |
self.fd = fd |
| 152 |
def fileno(self): |
| 153 |
return self.fd |
| 154 |
|
| 155 |
# file descriptor must be positive |
| 156 |
with self.assertRaises(ValueError): |
| 157 |
asfd(-1) |
| 158 |
with self.assertRaises(ValueError): |
| 159 |
asfd(FakeFile(-1)) |
| 160 |
|
| 161 |
# fileno() result must be an integer |
| 162 |
with self.assertRaises(TypeError): |
| 163 |
asfd(FakeFile("text")) |
| 164 |
|
| 165 |
# unsupported types |
| 166 |
for obj in ("string", ["list"], object()): |
| 167 |
with self.subTest(obj=obj): |
| 168 |
with self.assertRaises(TypeError): |
| 169 |
asfd(obj) |
| 170 |
|
| 171 |
# CRASHES asfd(NULL) |
| 172 |
|
| 173 |
def test_pyfile_newstdprinter(self): |
| 174 |
# Test PyFile_NewStdPrinter() |
| 175 |
pyfile_newstdprinter = _testcapi.pyfile_newstdprinter |
| 176 |
|
| 177 |
file = pyfile_newstdprinter(STDOUT_FD) |
| 178 |
self.assertEqual(file.closed, False) |
| 179 |
self.assertIsNone(file.encoding) |
| 180 |
self.assertEqual(file.mode, "w") |
| 181 |
|
| 182 |
self.assertEqual(file.fileno(), STDOUT_FD) |
| 183 |
self.assertEqual(file.isatty(), os.isatty(STDOUT_FD)) |
| 184 |
|
| 185 |
# flush() is a no-op |
| 186 |
self.assertIsNone(file.flush()) |
| 187 |
|
| 188 |
# close() is a no-op |
| 189 |
self.assertIsNone(file.close()) |
| 190 |
self.assertEqual(file.closed, False) |
| 191 |
|
| 192 |
support.check_disallow_instantiation(self, type(file)) |
| 193 |
|
| 194 |
def test_pyfile_newstdprinter_write(self): |
| 195 |
# Test the write() method of PyFile_NewStdPrinter() |
| 196 |
pyfile_newstdprinter = _testcapi.pyfile_newstdprinter |
| 197 |
|
| 198 |
filename = os_helper.TESTFN |
| 199 |
self.addCleanup(os_helper.unlink, filename) |
| 200 |
|
| 201 |
try: |
| 202 |
old_stdout = os.dup(STDOUT_FD) |
| 203 |
except OSError as exc: |
| 204 |
# os.dup(STDOUT_FD) is not supported on WASI |
| 205 |
self.skipTest(f"os.dup() failed with {exc!r}") |
| 206 |
|
| 207 |
try: |
| 208 |
with open(filename, "wb") as fp: |
| 209 |
# PyFile_NewStdPrinter() only accepts fileno(stdout) |
| 210 |
# or fileno(stderr) file descriptor. |
| 211 |
fd = fp.fileno() |
| 212 |
os.dup2(fd, STDOUT_FD) |
| 213 |
|
| 214 |
file = pyfile_newstdprinter(STDOUT_FD) |
| 215 |
self.assertEqual(file.write("text"), 4) |
| 216 |
# The surrogate character is encoded with |
| 217 |
# the "surrogateescape" error handler |
| 218 |
self.assertEqual(file.write("[\udc80]"), 8) |
| 219 |
finally: |
| 220 |
os.dup2(old_stdout, STDOUT_FD) |
| 221 |
os.close(old_stdout) |
| 222 |
|
| 223 |
with open(filename, "r") as fp: |
| 224 |
self.assertEqual(fp.read(), "text[\\udc80]") |
| 225 |
|
| 226 |
def test_py_fopen(self): |
| 227 |
# Test Py_fopen() and Py_fclose() |
| 228 |
py_fopen = _testcapi.py_fopen |
| 229 |
|
| 230 |
with open(__file__, "rb") as fp: |
| 231 |
source = fp.read() |
| 232 |
|
| 233 |
for filename in (__file__, os.fsencode(__file__)): |
| 234 |
with self.subTest(filename=filename): |
| 235 |
data = py_fopen(filename, "rb") |
| 236 |
self.assertEqual(data, source[:256]) |
| 237 |
|
| 238 |
data = py_fopen(os_helper.FakePath(filename), "rb") |
| 239 |
self.assertEqual(data, source[:256]) |
| 240 |
|
| 241 |
filenames = [ |
| 242 |
os_helper.TESTFN, |
| 243 |
os.fsencode(os_helper.TESTFN), |
| 244 |
] |
| 245 |
if os_helper.TESTFN_UNDECODABLE is not None: |
| 246 |
filenames.append(os_helper.TESTFN_UNDECODABLE) |
| 247 |
filenames.append(os.fsdecode(os_helper.TESTFN_UNDECODABLE)) |
| 248 |
if os_helper.TESTFN_UNENCODABLE is not None: |
| 249 |
filenames.append(os_helper.TESTFN_UNENCODABLE) |
| 250 |
for filename in filenames: |
| 251 |
with self.subTest(filename=filename): |
| 252 |
try: |
| 253 |
with open(filename, "wb") as fp: |
| 254 |
fp.write(source) |
| 255 |
except OSError: |
| 256 |
# TESTFN_UNDECODABLE cannot be used to create a file |
| 257 |
# on macOS/WASI. |
| 258 |
filename = None |
| 259 |
continue |
| 260 |
try: |
| 261 |
data = py_fopen(filename, "rb") |
| 262 |
self.assertEqual(data, source[:256]) |
| 263 |
finally: |
| 264 |
os_helper.unlink(filename) |
| 265 |
|
| 266 |
# embedded null character/byte in the filename |
| 267 |
with self.assertRaises(ValueError): |
| 268 |
py_fopen("a\x00b", "rb") |
| 269 |
with self.assertRaises(ValueError): |
| 270 |
py_fopen(b"a\x00b", "rb") |
| 271 |
|
| 272 |
# non-ASCII mode failing with "Invalid argument" |
| 273 |
with self.assertRaises(OSError): |
| 274 |
py_fopen(__file__, b"\xc2\x80") |
| 275 |
with self.assertRaises(OSError): |
| 276 |
# \x98 is invalid in cp1250, cp1251, cp1257 |
| 277 |
# \x9d is invalid in cp1252-cp1255, cp1258 |
| 278 |
py_fopen(__file__, b"\xc2\x98\xc2\x9d") |
| 279 |
# UnicodeDecodeError can come from the audit hook code |
| 280 |
with self.assertRaises((UnicodeDecodeError, OSError)): |
| 281 |
py_fopen(__file__, b"\x98\x9d") |
| 282 |
|
| 283 |
# invalid filename type |
| 284 |
for invalid_type in (123, object()): |
| 285 |
with self.subTest(filename=invalid_type): |
| 286 |
with self.assertRaises(TypeError): |
| 287 |
py_fopen(invalid_type, "rb") |
| 288 |
|
| 289 |
if support.MS_WINDOWS: |
| 290 |
with self.assertRaises(OSError): |
| 291 |
# On Windows, the file mode is limited to 10 characters |
| 292 |
py_fopen(__file__, "rt+, ccs=UTF-8") |
| 293 |
|
| 294 |
# CRASHES py_fopen(NULL, 'rb') |
| 295 |
# CRASHES py_fopen(__file__, NULL) |
| 296 |
|
| 297 |
def test_py_universalnewlinefgets(self): |
| 298 |
py_universalnewlinefgets = _testcapi.py_universalnewlinefgets |
| 299 |
filename = os_helper.TESTFN |
| 300 |
self.addCleanup(os_helper.unlink, filename) |
| 301 |
|
| 302 |
with open(filename, "wb") as fp: |
| 303 |
fp.write(b"line1\nline2") |
| 304 |
|
| 305 |
line = py_universalnewlinefgets(filename, 1000) |
| 306 |
self.assertEqual(line, b"line1\n") |
| 307 |
|
| 308 |
with open(filename, "wb") as fp: |
| 309 |
fp.write(b"line2\r\nline3") |
| 310 |
|
| 311 |
line = py_universalnewlinefgets(filename, 1000) |
| 312 |
self.assertEqual(line, b"line2\n") |
| 313 |
|
| 314 |
with open(filename, "wb") as fp: |
| 315 |
fp.write(b"line3\rline4") |
| 316 |
|
| 317 |
line = py_universalnewlinefgets(filename, 1000) |
| 318 |
self.assertEqual(line, b"line3\n") |
| 319 |
|
| 320 |
# PyFile_SetOpenCodeHook() and PyFile_OpenCode() are tested by |
| 321 |
# test_embed.test_open_code_hook() |
| 322 |
|
| 323 |
|
| 324 |
if __name__ == "__main__": |
| 325 |
unittest.main() |