Skip tests in test_io

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