diff --git a/Lib/test/test_io.py b/Lib/test/test_io.py index bea4342e7f..ba514814fc 100644 --- a/Lib/test/test_io.py +++ b/Lib/test/test_io.py @@ -421,6 +421,8 @@ class IOTest(unittest.TestCase): self.assertRaises(exc, fp.seek, 1, self.SEEK_CUR) self.assertRaises(exc, fp.seek, -1, self.SEEK_END) + # TODO: RUSTPYTHON + @unittest.expectedFailure def test_optional_abilities(self): # Test for OSError when optional APIs are not supported # The purpose of this test is to try fileno(), reading, writing and @@ -624,6 +626,8 @@ class IOTest(unittest.TestCase): else: self.fail("1/0 didn't raise an exception") + # TODO: RUSTPYTHON + # @unittest.expectedFailure # issue 5008 def test_append_mode_tell(self): with self.open(support.TESTFN, "wb") as f: @@ -635,6 +639,8 @@ class IOTest(unittest.TestCase): with self.open(support.TESTFN, "a") as f: self.assertGreater(f.tell(), 0) + # TODO: RUSTPYTHON + @unittest.expectedFailure def test_destructor(self): record = [] class MyFileIO(self.FileIO): @@ -726,6 +732,8 @@ class IOTest(unittest.TestCase): self.assertRaises(ValueError, self.open, support.TESTFN, 'w', closefd=False) + # TODO: RUSTPYTHON + @unittest.expectedFailure def test_read_closed(self): with self.open(support.TESTFN, "w") as f: f.write("egg\n") @@ -753,6 +761,8 @@ class IOTest(unittest.TestCase): file = self.open(f.fileno(), "r", closefd=False) self.assertEqual(file.buffer.raw.closefd, False) + # TODO: RUSTPYTHON + @unittest.expectedFailure def test_garbage_collection(self): # FileIO objects are collected, and collecting them flushes # all data to disk. @@ -798,6 +808,7 @@ class IOTest(unittest.TestCase): self.assertFalse(closed[0]) # flush() called before file closed f.flush = lambda: None # break reference loop + @unittest.skip("TODO: RUSTPYTHON, specifics of operation order in close()") def test_flush_error_on_close(self): # raw file # Issue #5700: io.FileIO calls flush() after file closed @@ -862,6 +873,8 @@ class IOTest(unittest.TestCase): with self.open("non-existent", "r", opener=opener) as f: self.assertEqual(f.read(), "egg\n") + # TODO: RUSTPYTHON + @unittest.expectedFailure def test_bad_opener_negative_1(self): # Issue #27066. def badopener(fname, flags): @@ -870,6 +883,8 @@ class IOTest(unittest.TestCase): open('non-existent', 'r', opener=badopener) self.assertEqual(str(cm.exception), 'opener returned -1') + # TODO: RUSTPYTHON + @unittest.expectedFailure def test_bad_opener_other_negative(self): # Issue #27066. def badopener(fname, flags): @@ -878,6 +893,8 @@ class IOTest(unittest.TestCase): open('non-existent', 'r', opener=badopener) self.assertEqual(str(cm.exception), 'opener returned -2') + # TODO: RUSTPYTHON + @unittest.expectedFailure def test_fileio_closefd(self): # Issue #4841 with self.open(__file__, 'rb') as f1, \ @@ -1006,6 +1023,8 @@ class IOTest(unittest.TestCase): class CIOTest(IOTest): + # TODO: RUSTPYTHON, cyclic gc + @unittest.expectedFailure def test_IOBase_finalize(self): # Issue #12149: segmentation fault on _PyIOBase_finalize when both a # class which inherits IOBase and an object of this class are caught @@ -1024,6 +1043,7 @@ class CIOTest(IOTest): support.gc_collect() self.assertIsNone(wr(), wr) +@unittest.skip("TODO: RUSTPYTHON, pyio version depends on memoryview.cast()") class PyIOTest(IOTest): pass @@ -1103,6 +1123,8 @@ class CommonBufferedTests: # a ValueError. self.assertRaises(ValueError, _with) + # TODO: RUSTPYTHON, sys.unraisablehook + @unittest.expectedFailure def test_error_through_destructor(self): # Test that the exception state is not modified by a destructor, # even if close() fails. @@ -1136,6 +1158,7 @@ class CommonBufferedTests: except RuntimeError: pass + @unittest.skip("TODO: RUSTPYTHON, specifics of operation order in close()") def test_flush_error_on_close(self): # Test that buffered file is closed despite failed flush # and that flush() is called before file closed. @@ -1344,6 +1367,8 @@ class BufferedReaderTest(unittest.TestCase, CommonBufferedTests): self.assertEqual(b[:6], b"fghjkl") self.assertEqual(rawio._reads, 4) + # TODO: RUSTPYTHON + @unittest.expectedFailure def test_readinto_array(self): buffer_size = 60 data = b"a" * 26 @@ -1365,6 +1390,8 @@ class BufferedReaderTest(unittest.TestCase, CommonBufferedTests): self.assertEqual(bm[:n], data[:n]) self.assertEqual(bm[n:], b'x' * (len(bm[n:]))) + # TODO: RUSTPYTHON + @unittest.expectedFailure def test_readinto1_array(self): buffer_size = 60 data = b"a" * 26 @@ -1530,6 +1557,7 @@ class BufferedReaderTest(unittest.TestCase, CommonBufferedTests): class CBufferedReaderTest(BufferedReaderTest, SizeofTest): tp = io.BufferedReader + @unittest.skip("TODO: RUSTPYTHON, fallible allocation") @unittest.skipIf(MEMORY_SANITIZER, "MSan defaults to crashing " "instead of returning NULL for malloc failure.") def test_constructor(self): @@ -1559,6 +1587,8 @@ class CBufferedReaderTest(BufferedReaderTest, SizeofTest): # checking this is not so easy. self.assertRaises(OSError, bufio.read, 10) + # TODO: RUSTPYTHON + @unittest.expectedFailure def test_garbage_collection(self): # C BufferedReader objects are collected. # The Python version has __del__, so it ends into gc.garbage instead @@ -1572,12 +1602,15 @@ class CBufferedReaderTest(BufferedReaderTest, SizeofTest): support.gc_collect() self.assertIsNone(wr(), wr) + # TODO: RUSTPYTHON + @unittest.expectedFailure def test_args_error(self): # Issue #17275 with self.assertRaisesRegex(TypeError, "BufferedReader"): self.tp(io.BytesIO(), 1024, 1024, 1024) +@unittest.skip("TODO: RUSTPYTHON, pyio version depends on memoryview.cast()") class PyBufferedReaderTest(BufferedReaderTest): tp = pyio.BufferedReader @@ -1685,6 +1718,8 @@ class BufferedWriterTest(unittest.TestCase, CommonBufferedTests): def test_writes_and_truncates(self): self.check_writes(lambda bufio: bufio.truncate(bufio.tell())) + # TODO: RUSTPYTHON + @unittest.expectedFailure def test_write_non_blocking(self): raw = self.MockNonBlockWriterIO() bufio = self.tp(raw, 8) @@ -1863,6 +1898,7 @@ class BufferedWriterTest(unittest.TestCase, CommonBufferedTests): self.assertRaises(OSError, b.close) # exception not swallowed self.assertTrue(b.closed) + @unittest.skip("TODO: RUSTPYTHON") def test_slow_close_from_thread(self): # Issue #31976 rawio = self.SlowFlushRawIO() @@ -1879,6 +1915,7 @@ class BufferedWriterTest(unittest.TestCase, CommonBufferedTests): class CBufferedWriterTest(BufferedWriterTest, SizeofTest): tp = io.BufferedWriter + @unittest.skip("TODO: RUSTPYTHON, fallible allocation") @unittest.skipIf(MEMORY_SANITIZER, "MSan defaults to crashing " "instead of returning NULL for malloc failure.") def test_constructor(self): @@ -1901,6 +1938,8 @@ class CBufferedWriterTest(BufferedWriterTest, SizeofTest): self.assertRaises(ValueError, bufio.__init__, rawio, buffer_size=-1) self.assertRaises(ValueError, bufio.write, b"def") + # TODO: RUSTPYTHON + @unittest.expectedFailure def test_garbage_collection(self): # C BufferedWriter objects are collected, and collecting them flushes # all data to disk. @@ -1918,12 +1957,15 @@ class CBufferedWriterTest(BufferedWriterTest, SizeofTest): with self.open(support.TESTFN, "rb") as f: self.assertEqual(f.read(), b"123xxx") + # TODO: RUSTPYTHON + @unittest.expectedFailure def test_args_error(self): # Issue #17275 with self.assertRaisesRegex(TypeError, "BufferedWriter"): self.tp(io.BytesIO(), 1024, 1024, 1024) +@unittest.skip("TODO: RUSTPYTHON, pyio version depends on memoryview.cast()") class PyBufferedWriterTest(BufferedWriterTest): tp = pyio.BufferedWriter @@ -2059,6 +2101,8 @@ class BufferedRWPairTest(unittest.TestCase): # Silence destructor error reader.close = lambda: None + # TODO: RUSTPYTHON, sys.unraisablehook + @unittest.expectedFailure def test_writer_close_error_on_close(self): def writer_close(): writer_non_existing @@ -2138,6 +2182,7 @@ class BufferedRWPairTest(unittest.TestCase): class CBufferedRWPairTest(BufferedRWPairTest): tp = io.BufferedRWPair +@unittest.skip("TODO: RUSTPYTHON, pyio version depends on memoryview.cast()") class PyBufferedRWPairTest(BufferedRWPairTest): tp = pyio.BufferedRWPair @@ -2374,6 +2419,7 @@ class BufferedRandomTest(BufferedReaderTest, BufferedWriterTest): class CBufferedRandomTest(BufferedRandomTest, SizeofTest): tp = io.BufferedRandom + @unittest.skip("TODO: RUSTPYTHON, fallible allocation") @unittest.skipIf(MEMORY_SANITIZER, "MSan defaults to crashing " "instead of returning NULL for malloc failure.") def test_constructor(self): @@ -2386,16 +2432,21 @@ class CBufferedRandomTest(BufferedRandomTest, SizeofTest): self.assertRaises((OverflowError, MemoryError, ValueError), bufio.__init__, rawio, sys.maxsize) + # TODO: RUSTPYTHON + @unittest.expectedFailure def test_garbage_collection(self): CBufferedReaderTest.test_garbage_collection(self) CBufferedWriterTest.test_garbage_collection(self) + # TODO: RUSTPYTHON + @unittest.expectedFailure def test_args_error(self): # Issue #17275 with self.assertRaisesRegex(TypeError, "BufferedRandom"): self.tp(io.BytesIO(), 1024, 1024, 1024) +@unittest.skip("TODO: RUSTPYTHON, pyio version depends on memoryview.cast()") class PyBufferedRandomTest(BufferedRandomTest): tp = pyio.BufferedRandom @@ -2544,6 +2595,7 @@ class StatefulIncrementalDecoderTest(unittest.TestCase): self.assertEqual(d.decode(b'oiabcd'), '') self.assertEqual(d.decode(b'', 1), 'abcd.') +@unittest.skip("TODO: RUSTPYTHON") class TextIOWrapperTest(unittest.TestCase): def setUp(self): @@ -2847,6 +2899,7 @@ class TextIOWrapperTest(unittest.TestCase): support.gc_collect() self.assertEqual([b"abc"], l) + @unittest.skip("TODO: RUSTPYTHON") def test_override_destructor(self): record = [] class MyTextIO(self.TextIOWrapper): @@ -2870,6 +2923,8 @@ class TextIOWrapperTest(unittest.TestCase): support.gc_collect() self.assertEqual(record, [1, 2, 3]) + # TODO: RUSTPYTHON, sys.unraisablehook + @unittest.expectedFailure def test_error_through_destructor(self): # Test that the exception state is not modified by a destructor, # even if close() fails. @@ -3700,6 +3755,8 @@ class CTextIOWrapperTest(TextIOWrapperTest): t = self.TextIOWrapper.__new__(self.TextIOWrapper) self.assertRaises(Exception, repr, t) + # TODO: RUSTPYTHON + @unittest.expectedFailure def test_garbage_collection(self): # C TextIOWrapper objects are collected, and collecting them flushes # all data to disk. @@ -3742,6 +3799,7 @@ class PyTextIOWrapperTest(TextIOWrapperTest): shutdown_error = "LookupError: unknown encoding: ascii" +@unittest.skip("TODO: RUSTPYTHON, incremental decoder") class IncrementalNewlineDecoderTest(unittest.TestCase): def check_newline_decoding_utf8(self, decoder): @@ -3889,15 +3947,17 @@ class MiscIOTest(unittest.TestCase): self.assertEqual(f.mode, "wb") f.close() - with support.check_warnings(('', DeprecationWarning)): - f = self.open(support.TESTFN, "U") - self.assertEqual(f.name, support.TESTFN) - self.assertEqual(f.buffer.name, support.TESTFN) - self.assertEqual(f.buffer.raw.name, support.TESTFN) - self.assertEqual(f.mode, "U") - self.assertEqual(f.buffer.mode, "rb") - self.assertEqual(f.buffer.raw.mode, "rb") - f.close() + # XXX RUSTPYTHON: universal mode is deprecated anyway, so I + # feel fine about skipping it + # with support.check_warnings(('', DeprecationWarning)): + # f = self.open(support.TESTFN, "U") + # self.assertEqual(f.name, support.TESTFN) + # self.assertEqual(f.buffer.name, support.TESTFN) + # self.assertEqual(f.buffer.raw.name, support.TESTFN) + # self.assertEqual(f.mode, "U") + # self.assertEqual(f.buffer.mode, "rb") + # self.assertEqual(f.buffer.raw.mode, "rb") + # f.close() f = self.open(support.TESTFN, "w+") self.assertEqual(f.mode, "w+") @@ -3912,6 +3972,7 @@ class MiscIOTest(unittest.TestCase): f.close() g.close() + @unittest.skip("TODO: RUSTPYTHON, check if fd is seekable fileio") def test_open_pipe_with_append(self): # bpo-27805: Ignore ESPIPE from lseek() in open(). r, w = os.pipe() @@ -3970,6 +4031,8 @@ class MiscIOTest(unittest.TestCase): self.assertRaises(ValueError, f.writelines, []) self.assertRaises(ValueError, next, f) + # TODO: RUSTPYTHON, cyclic gc + @unittest.expectedFailure def test_blockingioerror(self): # Various BlockingIOError issues class C(str): @@ -4024,6 +4087,8 @@ class MiscIOTest(unittest.TestCase): support.gc_collect() self.assertIn(r, str(cm.warning.args[0])) + # TODO: RUSTPYTHON + @unittest.expectedFailure def test_warn_on_dealloc(self): self._check_warn_on_dealloc(support.TESTFN, "wb", buffering=0) self._check_warn_on_dealloc(support.TESTFN, "wb") @@ -4048,6 +4113,8 @@ class MiscIOTest(unittest.TestCase): with support.check_no_resource_warning(self): open(r, *args, closefd=False, **kwargs) + # TODO: RUSTPYTHON + @unittest.expectedFailure def test_warn_on_dealloc_fd(self): self._check_warn_on_dealloc_fd("rb", buffering=0) self._check_warn_on_dealloc_fd("rb") @@ -4071,9 +4138,11 @@ class MiscIOTest(unittest.TestCase): with self.open(support.TESTFN, **kwargs) as f: self.assertRaises(TypeError, pickle.dumps, f, protocol) + @unittest.skip("TODO: RUSTPYTHON") def test_nonblock_pipe_write_bigbuf(self): self._test_nonblock_pipe_write(16*1024) + @unittest.skip("TODO: RUSTPYTHON") def test_nonblock_pipe_write_smallbuf(self): self._test_nonblock_pipe_write(1024) @@ -4199,17 +4268,22 @@ class CMiscIOTest(MiscIOTest): else: self.assertFalse(err.strip('.!')) + @unittest.skip("TODO: RUSTPYTHON") def test_daemon_threads_shutdown_stdout_deadlock(self): self.check_daemon_threads_shutdown_deadlock('stdout') + @unittest.skip("TODO: RUSTPYTHON") def test_daemon_threads_shutdown_stderr_deadlock(self): self.check_daemon_threads_shutdown_deadlock('stderr') +@unittest.skip("TODO: RUSTPYTHON, pyio version depends on memoryview.cast()") class PyMiscIOTest(MiscIOTest): io = pyio + +@unittest.skip("TODO: RUSTPYTHON") @unittest.skipIf(os.name == 'nt', 'POSIX signals required for this test.') class SignalsTest(unittest.TestCase): @@ -4454,7 +4528,7 @@ def load_tests(*args): mocks = (MockRawIO, MisbehavedRawIO, MockFileIO, CloseFailureIO, MockNonBlockWriterIO, MockUnseekableIO, MockRawIOWithoutRead, SlowFlushRawIO) - all_members = io.__all__ + ["IncrementalNewlineDecoder"] + all_members = io.__all__# + ["IncrementalNewlineDecoder"] XXX RUSTPYTHON c_io_ns = {name : getattr(io, name) for name in all_members} py_io_ns = {name : getattr(pyio, name) for name in all_members} globs = globals()