diff --git a/Lib/test/test_pyexpat.py b/Lib/test/test_pyexpat.py
index b2b4dea06..6e34f369d 100644
--- a/Lib/test/test_pyexpat.py
+++ b/Lib/test/test_pyexpat.py
@@ -19,30 +19,40 @@ class SetAttributeTest(unittest.TestCase):
     def setUp(self):
         self.parser = expat.ParserCreate(namespace_separator='!')
 
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
     def test_buffer_text(self):
         self.assertIs(self.parser.buffer_text, False)
         for x in 0, 1, 2, 0:
             self.parser.buffer_text = x
             self.assertIs(self.parser.buffer_text, bool(x))
 
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
     def test_namespace_prefixes(self):
         self.assertIs(self.parser.namespace_prefixes, False)
         for x in 0, 1, 2, 0:
             self.parser.namespace_prefixes = x
             self.assertIs(self.parser.namespace_prefixes, bool(x))
 
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
     def test_ordered_attributes(self):
         self.assertIs(self.parser.ordered_attributes, False)
         for x in 0, 1, 2, 0:
             self.parser.ordered_attributes = x
             self.assertIs(self.parser.ordered_attributes, bool(x))
 
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
     def test_specified_attributes(self):
         self.assertIs(self.parser.specified_attributes, False)
         for x in 0, 1, 2, 0:
             self.parser.specified_attributes = x
             self.assertIs(self.parser.specified_attributes, bool(x))
 
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
     def test_invalid_attributes(self):
         with self.assertRaises(AttributeError):
             self.parser.returns_unicode = 1
@@ -226,6 +236,8 @@ class ParseTest(unittest.TestCase):
         for operation, expected_operation in zip(operations, expected_operations):
             self.assertEqual(operation, expected_operation)
 
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
     def test_parse_bytes(self):
         out = self.Outputter()
         parser = expat.ParserCreate(namespace_separator='!')
@@ -238,6 +250,8 @@ class ParseTest(unittest.TestCase):
         # Issue #6697.
         self.assertRaises(AttributeError, getattr, parser, '\uD800')
 
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
     def test_parse_str(self):
         out = self.Outputter()
         parser = expat.ParserCreate(namespace_separator='!')
@@ -248,6 +262,8 @@ class ParseTest(unittest.TestCase):
         operations = out.out
         self._verify_parse_output(operations)
 
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
     def test_parse_file(self):
         # Try parsing a file
         out = self.Outputter()
@@ -260,6 +276,8 @@ class ParseTest(unittest.TestCase):
         operations = out.out
         self._verify_parse_output(operations)
 
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
     def test_parse_again(self):
         parser = expat.ParserCreate()
         file = BytesIO(data)
@@ -273,6 +291,8 @@ class ParseTest(unittest.TestCase):
                           expat.errors.XML_ERROR_FINISHED)
 
 class NamespaceSeparatorTest(unittest.TestCase):
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
     def test_legal(self):
         # Tests that make sure we get errors when the namespace_separator value
         # is illegal, and that we don't for good values:
@@ -280,6 +300,8 @@ class NamespaceSeparatorTest(unittest.TestCase):
         expat.ParserCreate(namespace_separator=None)
         expat.ParserCreate(namespace_separator=' ')
 
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
     def test_illegal(self):
         try:
             expat.ParserCreate(namespace_separator=42)
@@ -295,6 +317,8 @@ class NamespaceSeparatorTest(unittest.TestCase):
             self.assertEqual(str(e),
                 'namespace_separator must be at most one character, omitted, or None')
 
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
     def test_zero_length(self):
         # ParserCreate() needs to accept a namespace_separator of zero length
         # to satisfy the requirements of RDF applications that are required
@@ -308,6 +332,9 @@ class NamespaceSeparatorTest(unittest.TestCase):
 
 
 class InterningTest(unittest.TestCase):
+
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
     def test(self):
         # Test the interning machinery.
         p = expat.ParserCreate()
@@ -323,6 +350,8 @@ class InterningTest(unittest.TestCase):
             # L should have the same string repeated over and over.
             self.assertTrue(tag is entry)
 
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
     def test_issue9402(self):
         # create an ExternalEntityParserCreate with buffer text
         class ExternalOutputter:
@@ -376,10 +405,14 @@ class BufferTextTest(unittest.TestCase):
         for name in handlers:
             setattr(self.parser, name, getattr(self, name))
 
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
     def test_default_to_disabled(self):
         parser = expat.ParserCreate()
         self.assertFalse(parser.buffer_text)
 
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
     def test_buffering_enabled(self):
         # Make sure buffering is turned on
         self.assertTrue(self.parser.buffer_text)
@@ -387,6 +420,8 @@ class BufferTextTest(unittest.TestCase):
         self.assertEqual(self.stuff, ['123'],
                          "buffered text not properly collapsed")
 
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
     def test1(self):
         # XXX This test exposes more detail of Expat's text chunking than we
         # XXX like, but it tests what we need to concisely.
@@ -396,17 +431,23 @@ class BufferTextTest(unittest.TestCase):
                          ["<a>", "1", "<b>", "2", "\n", "3", "<c>", "4\n5"],
                          "buffering control not reacting as expected")
 
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
     def test2(self):
         self.parser.Parse(b"<a>1<b/>&lt;2&gt;<c/>&#32;\n&#x20;3</a>", True)
         self.assertEqual(self.stuff, ["1<2> \n 3"],
                          "buffered text not properly collapsed")
 
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
     def test3(self):
         self.setHandlers(["StartElementHandler"])
         self.parser.Parse(b"<a>1<b/>2<c/>3</a>", True)
         self.assertEqual(self.stuff, ["<a>", "1", "<b>", "2", "<c>", "3"],
                          "buffered text not properly split")
 
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
     def test4(self):
         self.setHandlers(["StartElementHandler", "EndElementHandler"])
         self.parser.CharacterDataHandler = None
@@ -414,12 +455,16 @@ class BufferTextTest(unittest.TestCase):
         self.assertEqual(self.stuff,
                          ["<a>", "<b>", "</b>", "<c>", "</c>", "</a>"])
 
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
     def test5(self):
         self.setHandlers(["StartElementHandler", "EndElementHandler"])
         self.parser.Parse(b"<a>1<b></b>2<c/>3</a>", True)
         self.assertEqual(self.stuff,
             ["<a>", "1", "<b>", "</b>", "2", "<c>", "</c>", "3", "</a>"])
 
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
     def test6(self):
         self.setHandlers(["CommentHandler", "EndElementHandler",
                     "StartElementHandler"])
@@ -428,6 +473,8 @@ class BufferTextTest(unittest.TestCase):
             ["<a>", "1", "<b>", "</b>", "2", "<c>", "</c>", "345", "</a>"],
             "buffered text not properly split")
 
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
     def test7(self):
         self.setHandlers(["CommentHandler", "EndElementHandler",
                     "StartElementHandler"])
@@ -447,6 +494,8 @@ class HandlerExceptionTest(unittest.TestCase):
         self.assertEqual(os.path.basename(entry[0]), filename)
         self.assertEqual(entry[2], funcname)
 
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
     def test_exception(self):
         parser = expat.ParserCreate()
         parser.StartElementHandler = self.StartElementHandler
@@ -490,6 +539,8 @@ class PositionTest(unittest.TestCase):
                 'Expected position %s, got position %s' %(pos, expected))
         self.upto += 1
 
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
     def test(self):
         self.parser = expat.ParserCreate()
         self.parser.StartElementHandler = self.StartElementHandler
@@ -503,6 +554,9 @@ class PositionTest(unittest.TestCase):
 
 
 class sf1296433Test(unittest.TestCase):
+
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
     def test_parse_only_xml_data(self):
         # http://python.org/sf/1296433
         #
@@ -526,12 +580,18 @@ class ChardataBufferTest(unittest.TestCase):
     test setting of chardata buffer size
     """
 
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
     def test_1025_bytes(self):
         self.assertEqual(self.small_buffer_test(1025), 2)
 
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
     def test_1000_bytes(self):
         self.assertEqual(self.small_buffer_test(1000), 1)
 
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
     def test_wrong_size(self):
         parser = expat.ParserCreate()
         parser.buffer_text = 1
@@ -544,6 +604,8 @@ class ChardataBufferTest(unittest.TestCase):
         with self.assertRaises(TypeError):
             parser.buffer_size = 512.0
 
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
     def test_unchanged_size(self):
         xml1 = b"<?xml version='1.0' encoding='iso8859'?><s>" + b'a' * 512
         xml2 = b'a'*512 + b'</s>'
@@ -566,7 +628,8 @@ class ChardataBufferTest(unittest.TestCase):
         parser.Parse(xml2)
         self.assertEqual(self.n, 2)
 
-
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
     def test_disabling_buffer(self):
         xml1 = b"<?xml version='1.0' encoding='iso8859'?><a>" + b'a' * 512
         xml2 = b'b' * 1024
@@ -611,6 +674,8 @@ class ChardataBufferTest(unittest.TestCase):
         parser.Parse(xml)
         return self.n
 
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
     def test_change_size_1(self):
         xml1 = b"<?xml version='1.0' encoding='iso8859'?><a><s>" + b'a' * 1024
         xml2 = b'aaa</s><s>' + b'a' * 1025 + b'</s></a>'
@@ -627,6 +692,8 @@ class ChardataBufferTest(unittest.TestCase):
         parser.Parse(xml2, True)
         self.assertEqual(self.n, 2)
 
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
     def test_change_size_2(self):
         xml1 = b"<?xml version='1.0' encoding='iso8859'?><a>a<s>" + b'a' * 1023
         xml2 = b'aaa</s><s>' + b'a' * 1025 + b'</s></a>'
@@ -644,6 +711,9 @@ class ChardataBufferTest(unittest.TestCase):
         self.assertEqual(self.n, 4)
 
 class MalformedInputTest(unittest.TestCase):
+
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
     def test1(self):
         xml = b"\0\r\n"
         parser = expat.ParserCreate()
@@ -653,6 +723,8 @@ class MalformedInputTest(unittest.TestCase):
         except expat.ExpatError as e:
             self.assertEqual(str(e), 'unclosed token: line 2, column 0')
 
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
     def test2(self):
         # \xc2\x85 is UTF-8 encoded U+0085 (NEXT LINE)
         xml = b"<?xml version\xc2\x85='1.0'?>\r\n"
@@ -662,11 +734,16 @@ class MalformedInputTest(unittest.TestCase):
             parser.Parse(xml, True)
 
 class ErrorMessageTest(unittest.TestCase):
+
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
     def test_codes(self):
         # verify mapping of errors.codes and errors.messages
         self.assertEqual(errors.XML_ERROR_SYNTAX,
                          errors.messages[errors.codes[errors.XML_ERROR_SYNTAX]])
 
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
     def test_expaterror(self):
         xml = b'<'
         parser = expat.ParserCreate()
@@ -682,6 +759,9 @@ class ForeignDTDTests(unittest.TestCase):
     """
     Tests for the UseForeignDTD method of expat parser objects.
     """
+
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
     def test_use_foreign_dtd(self):
         """
         If UseForeignDTD is passed True and a document without an external
@@ -710,6 +790,8 @@ class ForeignDTDTests(unittest.TestCase):
         parser.Parse(b"<?xml version='1.0'?><element/>")
         self.assertEqual(handler_call_args, [(None, None)])
 
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
     def test_ignore_use_foreign_dtd(self):
         """
         If UseForeignDTD is passed True and a document with an external