From 9db603f0c02950de2e5bcdf12673b611955ea32b Mon Sep 17 00:00:00 2001 From: Padraic Fanning Date: Fri, 23 Apr 2021 19:24:47 -0400 Subject: [PATCH] Mark erroring/failing tests --- Lib/test/test_xmlrpc.py | 86 +++++++++++++++++++++++++++++++++++++++++ 1 file changed, 86 insertions(+) diff --git a/Lib/test/test_xmlrpc.py b/Lib/test/test_xmlrpc.py index fc48305b1..9f1921d74 100644 --- a/Lib/test/test_xmlrpc.py +++ b/Lib/test/test_xmlrpc.py @@ -41,11 +41,15 @@ alist = [{'astring': 'foo@bar.baz.spam', class XMLRPCTestCase(unittest.TestCase): + # TODO: RUSTPYTHON + @unittest.expectedFailure def test_dump_load(self): dump = xmlrpclib.dumps((alist,)) load = xmlrpclib.loads(dump) self.assertEqual(alist, load[0][0]) + # TODO: RUSTPYTHON + @unittest.expectedFailure def test_dump_bare_datetime(self): # This checks that an unwrapped datetime.date object can be handled # by the marshalling code. This can't be done via test_dump_load() @@ -80,6 +84,8 @@ class XMLRPCTestCase(unittest.TestCase): self.assertIsNone(m) + # TODO: RUSTPYTHON + @unittest.expectedFailure def test_datetime_before_1900(self): # same as before but with a date before 1900 dt = datetime.datetime(1, 2, 10, 11, 41, 23) @@ -98,6 +104,8 @@ class XMLRPCTestCase(unittest.TestCase): self.assertIs(type(newdt), xmlrpclib.DateTime) self.assertIsNone(m) + # TODO: RUSTPYTHON + @unittest.expectedFailure def test_bug_1164912 (self): d = xmlrpclib.DateTime() ((new_d,), dummy) = xmlrpclib.loads(xmlrpclib.dumps((d,), @@ -108,6 +116,8 @@ class XMLRPCTestCase(unittest.TestCase): s = xmlrpclib.dumps((new_d,), methodresponse=True) self.assertIsInstance(s, str) + # TODO: RUSTPYTHON + @unittest.expectedFailure def test_newstyle_class(self): class T(object): pass @@ -173,6 +183,8 @@ class XMLRPCTestCase(unittest.TestCase): m.dump_double(xmlrpclib.MAXINT + 42, dummy_write) m.dump_double(xmlrpclib.MININT - 42, dummy_write) + # TODO: RUSTPYTHON + @unittest.expectedFailure def test_dump_none(self): value = alist + [None] arg1 = (alist + [None],) @@ -181,6 +193,8 @@ class XMLRPCTestCase(unittest.TestCase): xmlrpclib.loads(strg)[0][0]) self.assertRaises(TypeError, xmlrpclib.dumps, (arg1,)) + # TODO: RUSTPYTHON + @unittest.expectedFailure def test_dump_encoding(self): value = {'key\u20ac\xa4': 'value\u20ac\xa4'} @@ -202,6 +216,8 @@ class XMLRPCTestCase(unittest.TestCase): self.assertEqual(xmlrpclib.loads(strg)[0][0], value) self.assertEqual(xmlrpclib.loads(strg)[1], methodname) + # TODO: RUSTPYTHON + @unittest.expectedFailure def test_dump_bytes(self): sample = b"my dog has fleas" self.assertEqual(sample, xmlrpclib.Binary(sample)) @@ -221,6 +237,8 @@ class XMLRPCTestCase(unittest.TestCase): self.assertIs(type(newvalue), xmlrpclib.Binary) self.assertIsNone(m) + # TODO: RUSTPYTHON + @unittest.expectedFailure def test_loads_unsupported(self): ResponseError = xmlrpclib.ResponseError data = '' @@ -243,6 +261,8 @@ class XMLRPCTestCase(unittest.TestCase): self.assertIs(type(newvalue), type(value)) self.assertIsNone(m) + # TODO: RUSTPYTHON + @unittest.expectedFailure def test_load_standard_types(self): check = self.check_loads check('string', 'string') @@ -270,6 +290,8 @@ class XMLRPCTestCase(unittest.TestCase): 'a1' '', {'a': 1, 'b': 2}) + # TODO: RUSTPYTHON + @unittest.expectedFailure def test_load_extension_types(self): check = self.check_loads check('', None) @@ -304,6 +326,8 @@ class XMLRPCTestCase(unittest.TestCase): except OSError: self.assertTrue(has_ssl) + # TODO: RUSTPYTHON + @unittest.expectedFailure def test_keepalive_disconnect(self): class RequestHandler(http.server.BaseHTTPRequestHandler): protocol_version = "HTTP/1.1" @@ -443,6 +467,8 @@ class FaultTestCase(unittest.TestCase): self.assertEqual(repr(f), "") self.assertEqual(repr(f), str(f)) + # TODO: RUSTPYTHON + @unittest.expectedFailure def test_dump_fault(self): f = xmlrpclib.Fault(42, 'Test Fault') s = xmlrpclib.dumps((f,)) @@ -771,6 +797,8 @@ class BaseServerTestCase(unittest.TestCase): xmlrpc.server.SimpleXMLRPCServer._send_traceback_header = False class SimpleServerTestCase(BaseServerTestCase): + # TODO: RUSTPYTHON + @unittest.expectedFailure def test_simple1(self): try: p = xmlrpclib.ServerProxy(URL) @@ -781,6 +809,8 @@ class SimpleServerTestCase(BaseServerTestCase): # protocol error; provide additional information in test output self.fail("%s\n%s" % (e, getattr(e, "headers", ""))) + # TODO: RUSTPYTHON + @unittest.expectedFailure def test_nonascii(self): start_string = 'P\N{LATIN SMALL LETTER Y WITH CIRCUMFLEX}t' end_string = 'h\N{LATIN SMALL LETTER O WITH HORN}n' @@ -794,6 +824,8 @@ class SimpleServerTestCase(BaseServerTestCase): # protocol error; provide additional information in test output self.fail("%s\n%s" % (e, getattr(e, "headers", ""))) + # TODO: RUSTPYTHON + @unittest.expectedFailure def test_client_encoding(self): start_string = '\u20ac' end_string = '\xa4' @@ -808,6 +840,8 @@ class SimpleServerTestCase(BaseServerTestCase): # protocol error; provide additional information in test output self.fail("%s\n%s" % (e, getattr(e, "headers", ""))) + # TODO: RUSTPYTHON + @unittest.expectedFailure def test_nonascii_methodname(self): try: p = xmlrpclib.ServerProxy(URL, encoding='ascii') @@ -828,6 +862,8 @@ class SimpleServerTestCase(BaseServerTestCase): self.assertEqual(response.status, 404) self.assertEqual(response.reason, 'Not Found') + # TODO: RUSTPYTHON + @unittest.expectedFailure def test_introspection1(self): expected_methods = set(['pow', 'div', 'my_function', 'add', 'têšt', 'system.listMethods', 'system.methodHelp', @@ -844,6 +880,8 @@ class SimpleServerTestCase(BaseServerTestCase): self.fail("%s\n%s" % (e, getattr(e, "headers", ""))) + # TODO: RUSTPYTHON + @unittest.expectedFailure def test_introspection2(self): try: # test _methodHelp() @@ -856,6 +894,8 @@ class SimpleServerTestCase(BaseServerTestCase): # protocol error; provide additional information in test output self.fail("%s\n%s" % (e, getattr(e, "headers", ""))) + # TODO: RUSTPYTHON + @unittest.expectedFailure @make_request_and_skipIf(sys.flags.optimize >= 2, "Docstrings are omitted with -O2 and above") def test_introspection3(self): @@ -870,6 +910,8 @@ class SimpleServerTestCase(BaseServerTestCase): # protocol error; provide additional information in test output self.fail("%s\n%s" % (e, getattr(e, "headers", ""))) + # TODO: RUSTPYTHON + @unittest.expectedFailure def test_introspection4(self): # the SimpleXMLRPCServer doesn't support signatures, but # at least check that we can try making the call @@ -883,6 +925,8 @@ class SimpleServerTestCase(BaseServerTestCase): # protocol error; provide additional information in test output self.fail("%s\n%s" % (e, getattr(e, "headers", ""))) + # TODO: RUSTPYTHON + @unittest.expectedFailure def test_multicall(self): try: p = xmlrpclib.ServerProxy(URL) @@ -900,6 +944,8 @@ class SimpleServerTestCase(BaseServerTestCase): # protocol error; provide additional information in test output self.fail("%s\n%s" % (e, getattr(e, "headers", ""))) + # TODO: RUSTPYTHON + @unittest.expectedFailure def test_non_existing_multicall(self): try: p = xmlrpclib.ServerProxy(URL) @@ -921,6 +967,8 @@ class SimpleServerTestCase(BaseServerTestCase): # protocol error; provide additional information in test output self.fail("%s\n%s" % (e, getattr(e, "headers", ""))) + # TODO: RUSTPYTHON + @unittest.expectedFailure def test_dotted_attribute(self): # Raises an AttributeError because private methods are not allowed. self.assertRaises(AttributeError, @@ -931,12 +979,16 @@ class SimpleServerTestCase(BaseServerTestCase): # This avoids waiting for the socket timeout. self.test_simple1() + # TODO: RUSTPYTHON + @unittest.expectedFailure def test_allow_dotted_names_true(self): # XXX also need allow_dotted_names_false test. server = xmlrpclib.ServerProxy("http://%s:%d/RPC2" % (ADDR, PORT)) data = server.Fixture.getData() self.assertEqual(data, '42') + # TODO: RUSTPYTHON + @unittest.expectedFailure def test_unicode_host(self): server = xmlrpclib.ServerProxy("http://%s:%d/RPC2" % (ADDR, PORT)) self.assertEqual(server.add("a", "\xe9"), "a\xe9") @@ -951,6 +1003,8 @@ class SimpleServerTestCase(BaseServerTestCase): 'Accept-Encoding: identity\r\n' 'Content-Length: 0\r\n\r\n'.encode('ascii')) + # TODO: RUSTPYTHON + @unittest.expectedFailure def test_context_manager(self): with xmlrpclib.ServerProxy(URL) as server: server.add(2, 3) @@ -959,6 +1013,8 @@ class SimpleServerTestCase(BaseServerTestCase): self.assertEqual(server('transport')._connection, (None, None)) + # TODO: RUSTPYTHON + @unittest.expectedFailure def test_context_manager_method_error(self): try: with xmlrpclib.ServerProxy(URL) as server: @@ -974,6 +1030,8 @@ class SimpleServerEncodingTestCase(BaseServerTestCase): def threadFunc(evt, numrequests, requestHandler=None, encoding=None): http_server(evt, numrequests, requestHandler, 'iso-8859-15') + # TODO: RUSTPYTHON + @unittest.expectedFailure def test_server_encoding(self): start_string = '\u20ac' end_string = '\xa4' @@ -992,16 +1050,22 @@ class SimpleServerEncodingTestCase(BaseServerTestCase): class MultiPathServerTestCase(BaseServerTestCase): threadFunc = staticmethod(http_multi_server) request_count = 2 + # TODO: RUSTPYTHON + @unittest.expectedFailure def test_path1(self): p = xmlrpclib.ServerProxy(URL+"/foo") self.assertEqual(p.pow(6,8), 6**8) self.assertRaises(xmlrpclib.Fault, p.add, 6, 8) + # TODO: RUSTPYTHON + @unittest.expectedFailure def test_path2(self): p = xmlrpclib.ServerProxy(URL+"/foo/bar") self.assertEqual(p.add(6,8), 6+8) self.assertRaises(xmlrpclib.Fault, p.pow, 6, 8) + # TODO: RUSTPYTHON + @unittest.expectedFailure def test_path3(self): p = xmlrpclib.ServerProxy(URL+"/is/broken") self.assertRaises(xmlrpclib.Fault, p.add, 6, 8) @@ -1033,6 +1097,8 @@ class BaseKeepaliveServerTestCase(BaseServerTestCase): #A test case that verifies that a server using the HTTP/1.1 keep-alive mechanism #does indeed serve subsequent requests on the same connection class KeepaliveServerTestCase1(BaseKeepaliveServerTestCase): + # TODO: RUSTPYTHON + @unittest.expectedFailure def test_two(self): p = xmlrpclib.ServerProxy(URL) #do three requests. @@ -1116,6 +1182,8 @@ class GzipServerTestCase(BaseServerTestCase): def setUp(self): BaseServerTestCase.setUp(self) + # TODO: RUSTPYTHON + @unittest.expectedFailure def test_gzip_request(self): t = self.Transport() t.encode_threshold = None @@ -1139,6 +1207,8 @@ class GzipServerTestCase(BaseServerTestCase): p.pow(6, 8) p("close")() + # TODO: RUSTPYTHON + @unittest.expectedFailure def test_gzip_response(self): t = self.Transport() p = xmlrpclib.ServerProxy(URL, transport=t) @@ -1197,6 +1267,8 @@ class HeadersServerTestCase(BaseServerTestCase): for key, value in additional.items(): self.assertEqual(headers.get(key), value) + # TODO: RUSTPYTHON + @unittest.expectedFailure def test_header(self): p = xmlrpclib.ServerProxy(URL, headers=[('X-Test', 'foo')]) self.assertEqual(p.pow(6, 8), 6**8) @@ -1204,6 +1276,8 @@ class HeadersServerTestCase(BaseServerTestCase): headers = self.RequestHandler.test_headers self.assertContainsAdditionalHeaders(headers, {'X-Test': 'foo'}) + # TODO: RUSTPYTHON + @unittest.expectedFailure def test_header_many(self): p = xmlrpclib.ServerProxy( URL, headers=[('X-Test', 'foo'), ('X-Test-Second', 'bar')]) @@ -1213,6 +1287,8 @@ class HeadersServerTestCase(BaseServerTestCase): self.assertContainsAdditionalHeaders( headers, {'X-Test': 'foo', 'X-Test-Second': 'bar'}) + # TODO: RUSTPYTHON + @unittest.expectedFailure def test_header_empty(self): p = xmlrpclib.ServerProxy(URL, headers=[]) self.assertEqual(p.pow(6, 8), 6**8) @@ -1220,6 +1296,8 @@ class HeadersServerTestCase(BaseServerTestCase): headers = self.RequestHandler.test_headers self.assertContainsAdditionalHeaders(headers, {}) + # TODO: RUSTPYTHON + @unittest.expectedFailure def test_header_tuple(self): p = xmlrpclib.ServerProxy(URL, headers=(('X-Test', 'foo'),)) self.assertEqual(p.pow(6, 8), 6**8) @@ -1227,6 +1305,8 @@ class HeadersServerTestCase(BaseServerTestCase): headers = self.RequestHandler.test_headers self.assertContainsAdditionalHeaders(headers, {'X-Test': 'foo'}) + # TODO: RUSTPYTHON + @unittest.expectedFailure def test_header_items(self): p = xmlrpclib.ServerProxy(URL, headers={'X-Test': 'foo'}.items()) self.assertEqual(p.pow(6, 8), 6**8) @@ -1285,6 +1365,8 @@ class FailingServerTestCase(unittest.TestCase): default_class = http.client.HTTPMessage xmlrpc.server.SimpleXMLRPCRequestHandler.MessageClass = default_class + # TODO: RUSTPYTHON + @unittest.expectedFailure def test_basic(self): # check that flag is false by default flagval = xmlrpc.server.SimpleXMLRPCServer._send_traceback_header @@ -1379,6 +1461,8 @@ class CGIHandlerTestCase(unittest.TestCase): self.assertEqual(message, 'Bad Request') + # TODO: RUSTPYTHON + @unittest.expectedFailure def test_cgi_xmlrpc_response(self): data = """ @@ -1424,6 +1508,8 @@ class CGIHandlerTestCase(unittest.TestCase): class UseBuiltinTypesTestCase(unittest.TestCase): + # TODO: RUSTPYTHON + @unittest.expectedFailure def test_use_builtin_types(self): # SimpleXMLRPCDispatcher.__init__ accepts use_builtin_types, which # makes all dispatch of binary data as bytes instances, and all