Debian Codegraph @

Lib/test/test_capi/test_file.py

raw
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()