text: import base64
  import datetime
  import decimal
  import sys
  import time
  import unittest
  from unittest import mock
  import xmlrpc.client as xmlrpclib
  import xmlrpc.server
  import http.client
  import http, http.server
  import socket
  import re
  import io
  import contextlib
  from test import support
  
  try:
      import gzip
  except ImportError:
      gzip = None
  try:
      import threading
  except ImportError:
      threading = None
  
  alist = [{'astring': 'foo@bar.baz.spam',
            'afloat': 7283.43,
            'anint': 2**20,
            'ashortlong': 2,
            'anotherlist': ['.zyx.41'],
            'abase64': xmlrpclib.Binary(b"my dog has fleas"),
            'b64bytes': b"my dog has fleas",
            'b64bytearray': bytearray(b"my dog has fleas"),
            'boolean': False,
            'unicode': '\u4000\u6000\u8000',
            'ukey\u4000': 'regular value',
            'datetime1': xmlrpclib.DateTime('20050210T11:41:23'),
            'datetime2': xmlrpclib.DateTime(
                          (2005, 2, 10, 11, 41, 23, 0, 1, -1)),
            'datetime3': xmlrpclib.DateTime(
                          datetime.datetime(2005, 2, 10, 11, 41, 23)),
            }]
  
  class XMLRPCTestCase(unittest.TestCase):
  
      def test_dump_load(self):
          dump = xmlrpclib.dumps((alist,))
          load = xmlrpclib.loads(dump)
          self.assertEqual(alist, load[0][0])
  
      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()
          # since with use_builtin_types set to 1 the unmarshaller would create
          # datetime objects for the 'datetime[123]' keys as well
          dt = datetime.datetime(2005, 2, 10, 11, 41, 23)
          self.assertEqual(dt, xmlrpclib.DateTime('20050210T11:41:23'))
          s = xmlrpclib.dumps((dt,))
  
          result, m = xmlrpclib.loads(s, use_builtin_types=True)
          (newdt,) = result
          self.assertEqual(newdt, dt)
          self.assertIs(type(newdt), datetime.datetime)
          self.assertIsNone(m)
  
          result, m = xmlrpclib.loads(s, use_builtin_types=False)
          (newdt,) = result
          self.assertEqual(newdt, dt)
          self.assertIs(type(newdt), xmlrpclib.DateTime)
          self.assertIsNone(m)
  
          result, m = xmlrpclib.loads(s, use_datetime=True)
          (newdt,) = result
          self.assertEqual(newdt, dt)
          self.assertIs(type(newdt), datetime.datetime)
          self.assertIsNone(m)
  
          result, m = xmlrpclib.loads(s, use_datetime=False)
          (newdt,) = result
          self.assertEqual(newdt, dt)
          self.assertIs(type(newdt), xmlrpclib.DateTime)
          self.assertIsNone(m)
  
  
      def test_datetime_before_1900(self):
          # same as before but with a date before 1900
          dt = datetime.datetime(1,  2, 10, 11, 41, 23)
          self.assertEqual(dt, xmlrpclib.DateTime('00010210T11:41:23'))
          s = xmlrpclib.dumps((dt,))
  
          result, m = xmlrpclib.loads(s, use_builtin_types=True)
          (newdt,) = result
          self.assertEqual(newdt, dt)
          self.assertIs(type(newdt), datetime.datetime)
          self.assertIsNone(m)
  
          result, m = xmlrpclib.loads(s, use_builtin_types=False)
          (newdt,) = result
          self.assertEqual(newdt, dt)
          self.assertIs(type(newdt), xmlrpclib.DateTime)
          self.assertIsNone(m)
  
      def test_bug_1164912 (self):
          d = xmlrpclib.DateTime()
          ((new_d,), dummy) = xmlrpclib.loads(xmlrpclib.dumps((d,),
                                              methodresponse=True))
          self.assertIsInstance(new_d.value, str)
  
          # Check that the output of dumps() is still an 8-bit string
          s = xmlrpclib.dumps((new_d,), methodresponse=True)
          self.assertIsInstance(s, str)
  
      def test_newstyle_class(self):
          class T(object):
              pass
          t = T()
          t.x = 100
          t.y = "Hello"
          ((t2,), dummy) = xmlrpclib.loads(xmlrpclib.dumps((t,)))
          self.assertEqual(t2, t.__dict__)
  
      def test_dump_big_long(self):
          self.assertRaises(OverflowError, xmlrpclib.dumps, (2**99,))
  
      def test_dump_bad_dict(self):
          self.assertRaises(TypeError, xmlrpclib.dumps, ({(1,2,3): 1},))
  
      def test_dump_recursive_seq(self):
          l = [1,2,3]
          t = [3,4,5,l]
          l.append(t)
          self.assertRaises(TypeError, xmlrpclib.dumps, (l,))
  
      def test_dump_recursive_dict(self):
          d = {'1':1, '2':1}
          t = {'3':3, 'd':d}
          d['t'] = t
          self.assertRaises(TypeError, xmlrpclib.dumps, (d,))
  
      def test_dump_big_int(self):
          if sys.maxsize > 2**31-1:
              self.assertRaises(OverflowError, xmlrpclib.dumps,
                                (int(2**34),))
  
          xmlrpclib.dumps((xmlrpclib.MAXINT, xmlrpclib.MININT))
          self.assertRaises(OverflowError, xmlrpclib.dumps,
                            (xmlrpclib.MAXINT+1,))
          self.assertRaises(OverflowError, xmlrpclib.dumps,
                            (xmlrpclib.MININT-1,))
  
          def dummy_write(s):
              pass
  
          m = xmlrpclib.Marshaller()
          m.dump_int(xmlrpclib.MAXINT, dummy_write)
          m.dump_int(xmlrpclib.MININT, dummy_write)
          self.assertRaises(OverflowError, m.dump_int,
                            xmlrpclib.MAXINT+1, dummy_write)
          self.assertRaises(OverflowError, m.dump_int,
                            xmlrpclib.MININT-1, dummy_write)
  
      def test_dump_double(self):
          xmlrpclib.dumps((float(2 ** 34),))
          xmlrpclib.dumps((float(xmlrpclib.MAXINT),
                           float(xmlrpclib.MININT)))
          xmlrpclib.dumps((float(xmlrpclib.MAXINT + 42),
                           float(xmlrpclib.MININT - 42)))
  
          def dummy_write(s):
              pass
  
          m = xmlrpclib.Marshaller()
          m.dump_double(xmlrpclib.MAXINT, dummy_write)
          m.dump_double(xmlrpclib.MININT, dummy_write)
          m.dump_double(xmlrpclib.MAXINT + 42, dummy_write)
          m.dump_double(xmlrpclib.MININT - 42, dummy_write)
  
      def test_dump_none(self):
          value = alist + [None]
          arg1 = (alist + [None],)
          strg = xmlrpclib.dumps(arg1, allow_none=True)
          self.assertEqual(value,
                            xmlrpclib.loads(strg)[0][0])
          self.assertRaises(TypeError, xmlrpclib.dumps, (arg1,))
  
      def test_dump_encoding(self):
          value = {'key\u20ac\xa4':
                   'value\u20ac\xa4'}
          strg = xmlrpclib.dumps((value,), encoding='iso-8859-15')
          strg = "<?xml version='1.0' encoding='iso-8859-15'?>" + strg
          self.assertEqual(xmlrpclib.loads(strg)[0][0], value)
          strg = strg.encode('iso-8859-15', 'xmlcharrefreplace')
          self.assertEqual(xmlrpclib.loads(strg)[0][0], value)
  
          strg = xmlrpclib.dumps((value,), encoding='iso-8859-15',
                                 methodresponse=True)
          self.assertEqual(xmlrpclib.loads(strg)[0][0], value)
          strg = strg.encode('iso-8859-15', 'xmlcharrefreplace')
          self.assertEqual(xmlrpclib.loads(strg)[0][0], value)
  
          methodname = 'method\u20ac\xa4'
          strg = xmlrpclib.dumps((value,), encoding='iso-8859-15',
                                 methodname=methodname)
          self.assertEqual(xmlrpclib.loads(strg)[0][0], value)
          self.assertEqual(xmlrpclib.loads(strg)[1], methodname)
  
      def test_dump_bytes(self):
          sample = b"my dog has fleas"
          self.assertEqual(sample, xmlrpclib.Binary(sample))
          for type_ in bytes, bytearray, xmlrpclib.Binary:
              value = type_(sample)
              s = xmlrpclib.dumps((value,))
  
              result, m = xmlrpclib.loads(s, use_builtin_types=True)
              (newvalue,) = result
              self.assertEqual(newvalue, sample)
              self.assertIs(type(newvalue), bytes)
              self.assertIsNone(m)
  
              result, m = xmlrpclib.loads(s, use_builtin_types=False)
              (newvalue,) = result
              self.assertEqual(newvalue, sample)
              self.assertIs(type(newvalue), xmlrpclib.Binary)
              self.assertIsNone(m)
  
      def test_loads_unsupported(self):
          ResponseError = xmlrpclib.ResponseError
          data = '<params><param><value><spam/></value></param></params>'
          self.assertRaises(ResponseError, xmlrpclib.loads, data)
          data = ('<params><param><value><array>'
                  '<value><spam/></value>'
                  '</array></value></param></params>')
          self.assertRaises(ResponseError, xmlrpclib.loads, data)
          data = ('<params><param><value><struct>'
                  '<member><name>a</name><value><spam/></value></member>'
                  '<member><name>b</name><value><spam/></value></member>'
                  '</struct></value></param></params>')
          self.assertRaises(ResponseError, xmlrpclib.loads, data)
  
      def check_loads(self, s, value, **kwargs):
          dump = '<params><param><value>%s</value></param></params>' % s
          result, m = xmlrpclib.loads(dump, **kwargs)
          (newvalue,) = result
          self.assertEqual(newvalue, value)
          self.assertIs(type(newvalue), type(value))
          self.assertIsNone(m)
  
      def test_load_standard_types(self):
          check = self.check_loads
          check('string', 'string')
          check('<string>string</string>', 'string')
          check('<string>𝔘𝔫𝔦𝔠𝔬𝔡𝔢 string</string>', '𝔘𝔫𝔦𝔠𝔬𝔡𝔢 string')
          check('<int>2056183947</int>', 2056183947)
          check('<int>-2056183947</int>', -2056183947)
          check('<i4>2056183947</i4>', 2056183947)
          check('<double>46093.78125</double>', 46093.78125)
          check('<boolean>0</boolean>', False)
          check('<base64>AGJ5dGUgc3RyaW5n/w==</base64>',
                xmlrpclib.Binary(b'\x00byte string\xff'))
          check('<base64>AGJ5dGUgc3RyaW5n/w==</base64>',
                b'\x00byte string\xff', use_builtin_types=True)
          check('<dateTime.iso8601>20050210T11:41:23</dateTime.iso8601>',
                xmlrpclib.DateTime('20050210T11:41:23'))
          check('<dateTime.iso8601>20050210T11:41:23</dateTime.iso8601>',
                datetime.datetime(2005, 2, 10, 11, 41, 23),
                use_builtin_types=True)
          check('<array><data>'
                '<value><int>1</int></value><value><int>2</int></value>'
                '</data></array>', [1, 2])
          check('<struct>'
                '<member><name>b</name><value><int>2</int></value></member>'
                '<member><name>a</name><value><int>1</int></value></member>'
                '</struct>', {'a': 1, 'b': 2})
  
      def test_load_extension_types(self):
          check = self.check_loads
          check('<nil/>', None)
          check('<ex:nil/>', None)
          check('<i1>205</i1>', 205)
          check('<i2>20561</i2>', 20561)
          check('<i8>9876543210</i8>', 9876543210)
          check('<biginteger>98765432100123456789</biginteger>',
                98765432100123456789)
          check('<float>93.78125</float>', 93.78125)
          check('<bigdecimal>9876543210.0123456789</bigdecimal>',
                decimal.Decimal('9876543210.0123456789'))
  
      def test_get_host_info(self):
          # see bug #3613, this raised a TypeError
          transp = xmlrpc.client.Transport()
          self.assertEqual(transp.get_host_info("user@host.tld"),
                            ('host.tld',
                             [('Authorization', 'Basic dXNlcg==')], {}))
  
      def test_ssl_presence(self):
          try:
              import ssl
          except ImportError:
              has_ssl = False
          else:
              has_ssl = True
          try:
              xmlrpc.client.ServerProxy('https://localhost:9999').bad_function()
          except NotImplementedError:
              self.assertFalse(has_ssl, "xmlrpc client's error with SSL support")
          except OSError:
              self.assertTrue(has_ssl)
  
      @unittest.skipUnless(threading, "Threading required for this test.")
      def test_keepalive_disconnect(self):
          class RequestHandler(http.server.BaseHTTPRequestHandler):
              protocol_version = "HTTP/1.1"
              handled = False
  
              def do_POST(self):
                  length = int(self.headers.get("Content-Length"))
                  self.rfile.read(length)
                  if self.handled:
                      self.close_connection = True
                      return
                  response = xmlrpclib.dumps((5,), methodresponse=True)
                  response = response.encode()
                  self.send_response(http.HTTPStatus.OK)
                  self.send_header("Content-Length", len(response))
                  self.end_headers()
                  self.wfile.write(response)
                  self.handled = True
                  self.close_connection = False
  
          def run_server():
              server.socket.settimeout(float(1))  # Don't hang if client fails
              server.handle_request()  # First request and attempt at second
              server.handle_request()  # Retried second request
  
          server = http.server.HTTPServer((support.HOST, 0), RequestHandler)
          self.addCleanup(server.server_close)
          thread = threading.Thread(target=run_server)
          thread.start()
          self.addCleanup(thread.join)
          url = "http://{}:{}/".format(*server.server_address)
          with xmlrpclib.ServerProxy(url) as p:
              self.assertEqual(p.method(), 5)
              self.assertEqual(p.method(), 5)
  
  
  class SimpleXMLRPCDispatcherTestCase(unittest.TestCase):
      class DispatchExc(Exception):
          """Raised inside the dispatched functions when checking for
          chained exceptions"""
  
      def test_call_registered_func(self):
          """Calls explicitly registered function"""
          # Makes sure any exception raised inside the function has no other
          # exception chained to it
  
          exp_params = 1, 2, 3
  
          def dispatched_func(*params):
              raise self.DispatchExc(params)
  
          dispatcher = xmlrpc.server.SimpleXMLRPCDispatcher()
          dispatcher.register_function(dispatched_func)
          with self.assertRaises(self.DispatchExc) as exc_ctx:
              dispatcher._dispatch('dispatched_func', exp_params)
          self.assertEqual(exc_ctx.exception.args, (exp_params,))
          self.assertIsNone(exc_ctx.exception.__cause__)
          self.assertIsNone(exc_ctx.exception.__context__)
  
      def test_call_instance_func(self):
          """Calls a registered instance attribute as a function"""
          # Makes sure any exception raised inside the function has no other
          # exception chained to it
  
          exp_params = 1, 2, 3
  
          class DispatchedClass:
              def dispatched_func(self, *params):
                  raise SimpleXMLRPCDispatcherTestCase.DispatchExc(params)
  
          dispatcher = xmlrpc.server.SimpleXMLRPCDispatcher()
          dispatcher.register_instance(DispatchedClass())
          with self.assertRaises(self.DispatchExc) as exc_ctx:
              dispatcher._dispatch('dispatched_func', exp_params)
          self.assertEqual(exc_ctx.exception.args, (exp_params,))
          self.assertIsNone(exc_ctx.exception.__cause__)
          self.assertIsNone(exc_ctx.exception.__context__)
  
      def test_call_dispatch_func(self):
          """Calls the registered instance's `_dispatch` function"""
          # Makes sure any exception raised inside the function has no other
          # exception chained to it
  
          exp_method = 'method'
          exp_params = 1, 2, 3
  
          class TestInstance:
              def _dispatch(self, method, params):
                  raise SimpleXMLRPCDispatcherTestCase.DispatchExc(
                      method, params)
  
          dispatcher = xmlrpc.server.SimpleXMLRPCDispatcher()
          dispatcher.register_instance(TestInstance())
          with self.assertRaises(self.DispatchExc) as exc_ctx:
              dispatcher._dispatch(exp_method, exp_params)
          self.assertEqual(exc_ctx.exception.args, (exp_method, exp_params))
          self.assertIsNone(exc_ctx.exception.__cause__)
          self.assertIsNone(exc_ctx.exception.__context__)
  
      def test_registered_func_is_none(self):
          """Calls explicitly registered function which is None"""
  
          dispatcher = xmlrpc.server.SimpleXMLRPCDispatcher()
          dispatcher.register_function(None, name='method')
          with self.assertRaises(Exception, expected_regex='method'):
              dispatcher._dispatch('method', ('param',))
  
      def test_instance_has_no_func(self):
          """Attempts to call nonexistent function on a registered instance"""
  
          dispatcher = xmlrpc.server.SimpleXMLRPCDispatcher()
          dispatcher.register_instance(object())
          with self.assertRaises(Exception, expected_regex='method'):
              dispatcher._dispatch('method', ('param',))
  
      def test_cannot_locate_func(self):
          """Calls a function that the dispatcher cannot locate"""
  
          dispatcher = xmlrpc.server.SimpleXMLRPCDispatcher()
          with self.assertRaises(Exception, expected_regex='method'):
              dispatcher._dispatch('method', ('param',))
  
  
  class HelperTestCase(unittest.TestCase):
      def test_escape(self):
          self.assertEqual(xmlrpclib.escape("a&b"), "a&amp;b")
          self.assertEqual(xmlrpclib.escape("a<b"), "a&lt;b")
          self.assertEqual(xmlrpclib.escape("a>b"), "a&gt;b")
  
  class FaultTestCase(unittest.TestCase):
      def test_repr(self):
          f = xmlrpclib.Fault(42, 'Test Fault')
          self.assertEqual(repr(f), "<Fault 42: 'Test Fault'>")
          self.assertEqual(repr(f), str(f))
  
      def test_dump_fault(self):
          f = xmlrpclib.Fault(42, 'Test Fault')
          s = xmlrpclib.dumps((f,))
          (newf,), m = xmlrpclib.loads(s)
          self.assertEqual(newf, {'faultCode': 42, 'faultString': 'Test Fault'})
          self.assertEqual(m, None)
  
          s = xmlrpclib.Marshaller().dumps(f)
          self.assertRaises(xmlrpclib.Fault, xmlrpclib.loads, s)
  
      def test_dotted_attribute(self):
          # this will raise AttributeError because code don't want us to use
          # private methods
          self.assertRaises(AttributeError,
                            xmlrpc.server.resolve_dotted_attribute, str, '__add')
          self.assertTrue(xmlrpc.server.resolve_dotted_attribute(str, 'title'))
  
  class DateTimeTestCase(unittest.TestCase):
      def test_default(self):
          with mock.patch('time.localtime') as localtime_mock:
              time_struct = time.struct_time(
                  [2013, 7, 15, 0, 24, 49, 0, 196, 0])
              localtime_mock.return_value = time_struct
              localtime = time.localtime()
              t = xmlrpclib.DateTime()
              self.assertEqual(str(t),
                               time.strftime("%Y%m%dT%H:%M:%S", localtime))
  
      def test_time(self):
          d = 1181399930.036952
          t = xmlrpclib.DateTime(d)
          self.assertEqual(str(t),
                           time.strftime("%Y%m%dT%H:%M:%S", time.localtime(d)))
  
      def test_time_tuple(self):
          d = (2007,6,9,10,38,50,5,160,0)
          t = xmlrpclib.DateTime(d)
          self.assertEqual(str(t), '20070609T10:38:50')
  
      def test_time_struct(self):
          d = time.localtime(1181399930.036952)
          t = xmlrpclib.DateTime(d)
          self.assertEqual(str(t), time.strftime("%Y%m%dT%H:%M:%S", d))
  
      def test_datetime_datetime(self):
          d = datetime.datetime(2007,1,2,3,4,5)
          t = xmlrpclib.DateTime(d)
          self.assertEqual(str(t), '20070102T03:04:05')
  
      def test_repr(self):
          d = datetime.datetime(2007,1,2,3,4,5)
          t = xmlrpclib.DateTime(d)
          val ="<DateTime '20070102T03:04:05' at %#x>" % id(t)
          self.assertEqual(repr(t), val)
  
      def test_decode(self):
          d = ' 20070908T07:11:13  '
          t1 = xmlrpclib.DateTime()
          t1.decode(d)
          tref = xmlrpclib.DateTime(datetime.datetime(2007,9,8,7,11,13))
          self.assertEqual(t1, tref)
  
          t2 = xmlrpclib._datetime(d)
          self.assertEqual(t2, tref)
  
      def test_comparison(self):
          now = datetime.datetime.now()
          dtime = xmlrpclib.DateTime(now.timetuple())
  
          # datetime vs. DateTime
          self.assertTrue(dtime == now)
          self.assertTrue(now == dtime)
          then = now + datetime.timedelta(seconds=4)
          self.assertTrue(then >= dtime)
          self.assertTrue(dtime < then)
  
          # str vs. DateTime
          dstr = now.strftime("%Y%m%dT%H:%M:%S")
          self.assertTrue(dtime == dstr)
          self.assertTrue(dstr == dtime)
          dtime_then = xmlrpclib.DateTime(then.timetuple())
          self.assertTrue(dtime_then >= dstr)
          self.assertTrue(dstr < dtime_then)
  
          # some other types
          dbytes = dstr.encode('ascii')
          dtuple = now.timetuple()
          with self.assertRaises(TypeError):
              dtime == 1970
          with self.assertRaises(TypeError):
              dtime != dbytes
          with self.assertRaises(TypeError):
              dtime == bytearray(dbytes)
          with self.assertRaises(TypeError):
              dtime != dtuple
          with self.assertRaises(TypeError):
              dtime < float(1970)
          with self.assertRaises(TypeError):
              dtime > dbytes
          with self.assertRaises(TypeError):
              dtime <= bytearray(dbytes)
          with self.assertRaises(TypeError):
              dtime >= dtuple
  
  class BinaryTestCase(unittest.TestCase):
  
      # XXX What should str(Binary(b"\xff")) return?  I'm chosing "\xff"
      # for now (i.e. interpreting the binary data as Latin-1-encoded
      # text).  But this feels very unsatisfactory.  Perhaps we should
      # only define repr(), and return r"Binary(b'\xff')" instead?
  
      def test_default(self):
          t = xmlrpclib.Binary()
          self.assertEqual(str(t), '')
  
      def test_string(self):
          d = b'\x01\x02\x03abc123\xff\xfe'
          t = xmlrpclib.Binary(d)
          self.assertEqual(str(t), str(d, "latin-1"))
  
      def test_decode(self):
          d = b'\x01\x02\x03abc123\xff\xfe'
          de = base64.encodebytes(d)
          t1 = xmlrpclib.Binary()
          t1.decode(de)
          self.assertEqual(str(t1), str(d, "latin-1"))
  
          t2 = xmlrpclib._binary(de)
          self.assertEqual(str(t2), str(d, "latin-1"))
  
  
  ADDR = PORT = URL = None
  
  # The evt is set twice.  First when the server is ready to serve.
  # Second when the server has been shutdown.  The user must clear
  # the event after it has been set the first time to catch the second set.
  def http_server(evt, numrequests, requestHandler=None, encoding=None):
      class TestInstanceClass:
          def div(self, x, y):
              return x // y
  
          def _methodHelp(self, name):
              if name == 'div':
                  return 'This is the div function'
  
          class Fixture:
              @staticmethod
              def getData():
                  return '42'
  
      class MyXMLRPCServer(xmlrpc.server.SimpleXMLRPCServer):
          def get_request(self):
              # Ensure the socket is always non-blocking.  On Linux, socket
              # attributes are not inherited like they are on *BSD and Windows.
              s, port = self.socket.accept()
              s.setblocking(True)
              return s, port
  
      if not requestHandler:
          requestHandler = xmlrpc.server.SimpleXMLRPCRequestHandler
      serv = MyXMLRPCServer(("localhost", 0), requestHandler,
                            encoding=encoding,
                            logRequests=False, bind_and_activate=False)
      try:
          serv.server_bind()
          global ADDR, PORT, URL
          ADDR, PORT = serv.socket.getsockname()
          #connect to IP address directly.  This avoids socket.create_connection()
          #trying to connect to "localhost" using all address families, which
          #causes slowdown e.g. on vista which supports AF_INET6.  The server listens
          #on AF_INET only.
          URL = "http://%s:%d"%(ADDR, PORT)
          serv.server_activate()
          serv.register_introspection_functions()
          serv.register_multicall_functions()
          serv.register_function(pow)
          serv.register_function(lambda x: x, 'têšt')
          @serv.register_function
          def my_function():
              '''This is my function'''
              return True
          @serv.register_function(name='add')
          def _(x, y):
              return x + y
          testInstance = TestInstanceClass()
          serv.register_instance(testInstance, allow_dotted_names=True)
          evt.set()
  
          # handle up to 'numrequests' requests
          while numrequests > 0:
              serv.handle_request()
              numrequests -= 1
  
      except socket.timeout:
          pass
      finally:
          serv.socket.close()
          PORT = None
          evt.set()
  
  def http_multi_server(evt, numrequests, requestHandler=None):
      class TestInstanceClass:
          def div(self, x, y):
              return x // y
  
          def _methodHelp(self, name):
              if name == 'div':
                  return 'This is the div function'
  
      def my_function():
          '''This is my function'''
          return True
  
      class MyXMLRPCServer(xmlrpc.server.MultiPathXMLRPCServer):
          def get_request(self):
              # Ensure the socket is always non-blocking.  On Linux, socket
              # attributes are not inherited like they are on *BSD and Windows.
              s, port = self.socket.accept()
              s.setblocking(True)
              return s, port
  
      if not requestHandler:
          requestHandler = xmlrpc.server.SimpleXMLRPCRequestHandler
      class MyRequestHandler(requestHandler):
          rpc_paths = []
  
      class BrokenDispatcher:
          def _marshaled_dispatch(self, data, dispatch_method=None, path=None):
              raise RuntimeError("broken dispatcher")
  
      serv = MyXMLRPCServer(("localhost", 0), MyRequestHandler,
                            logRequests=False, bind_and_activate=False)
      serv.socket.settimeout(3)
      serv.server_bind()
      try:
          global ADDR, PORT, URL
          ADDR, PORT = serv.socket.getsockname()
          #connect to IP address directly.  This avoids socket.create_connection()
          #trying to connect to "localhost" using all address families, which
          #causes slowdown e.g. on vista which supports AF_INET6.  The server listens
          #on AF_INET only.
          URL = "http://%s:%d"%(ADDR, PORT)
          serv.server_activate()
          paths = ["/foo", "/foo/bar"]
          for path in paths:
              d = serv.add_dispatcher(path, xmlrpc.server.SimpleXMLRPCDispatcher())
              d.register_introspection_functions()
              d.register_multicall_functions()
          serv.get_dispatcher(paths[0]).register_function(pow)
          serv.get_dispatcher(paths[1]).register_function(lambda x,y: x+y, 'add')
          serv.add_dispatcher("/is/broken", BrokenDispatcher())
          evt.set()
  
          # handle up to 'numrequests' requests
          while numrequests > 0:
              serv.handle_request()
              numrequests -= 1
  
      except socket.timeout:
          pass
      finally:
          serv.socket.close()
          PORT = None
          evt.set()
  
  # This function prevents errors like:
  #    <ProtocolError for localhost:57527/RPC2: 500 Internal Server Error>
  def is_unavailable_exception(e):
      '''Returns True if the given ProtocolError is the product of a server-side
         exception caused by the 'temporarily unavailable' response sometimes
         given by operations on non-blocking sockets.'''
  
      # sometimes we get a -1 error code and/or empty headers
      try:
          if e.errcode == -1 or e.headers is None:
              return True
          exc_mess = e.headers.get('X-exception')
      except AttributeError:
          # Ignore OSErrors here.
          exc_mess = str(e)
  
      if exc_mess and 'temporarily unavailable' in exc_mess.lower():
          return True
  
  def make_request_and_skipIf(condition, reason):
      # If we skip the test, we have to make a request because
      # the server created in setUp blocks expecting one to come in.
      if not condition:
          return lambda func: func
      def decorator(func):
          def make_request_and_skip(self):
              try:
                  xmlrpclib.ServerProxy(URL).my_function()
              except (xmlrpclib.ProtocolError, OSError) as e:
                  if not is_unavailable_exception(e):
                      raise
              raise unittest.SkipTest(reason)
          return make_request_and_skip
      return decorator
  
  @unittest.skipUnless(threading, 'Threading required for this test.')
  class BaseServerTestCase(unittest.TestCase):
      requestHandler = None
      request_count = 1
      threadFunc = staticmethod(http_server)
  
      def setUp(self):
          # enable traceback reporting
          xmlrpc.server.SimpleXMLRPCServer._send_traceback_header = True
  
          self.evt = threading.Event()
          # start server thread to handle requests
          serv_args = (self.evt, self.request_count, self.requestHandler)
          threading.Thread(target=self.threadFunc, args=serv_args).start()
  
          # wait for the server to be ready
          self.evt.wait()
          self.evt.clear()
  
      def tearDown(self):
          # wait on the server thread to terminate
          self.evt.wait()
  
          # disable traceback reporting
          xmlrpc.server.SimpleXMLRPCServer._send_traceback_header = False
  
  class SimpleServerTestCase(BaseServerTestCase):
      def test_simple1(self):
          try:
              p = xmlrpclib.ServerProxy(URL)
              self.assertEqual(p.pow(6,8), 6**8)
          except (xmlrpclib.ProtocolError, OSError) as e:
              # ignore failures due to non-blocking socket 'unavailable' errors
              if not is_unavailable_exception(e):
                  # protocol error; provide additional information in test output
                  self.fail("%s\n%s" % (e, getattr(e, "headers", "")))
  
      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'
          try:
              p = xmlrpclib.ServerProxy(URL)
              self.assertEqual(p.add(start_string, end_string),
                               start_string + end_string)
          except (xmlrpclib.ProtocolError, OSError) as e:
              # ignore failures due to non-blocking socket 'unavailable' errors
              if not is_unavailable_exception(e):
                  # protocol error; provide additional information in test output
                  self.fail("%s\n%s" % (e, getattr(e, "headers", "")))
  
      def test_client_encoding(self):
          start_string = '\u20ac'
          end_string = '\xa4'
  
          try:
              p = xmlrpclib.ServerProxy(URL, encoding='iso-8859-15')
              self.assertEqual(p.add(start_string, end_string),
                               start_string + end_string)
          except (xmlrpclib.ProtocolError, socket.error) as e:
              # ignore failures due to non-blocking socket unavailable errors.
              if not is_unavailable_exception(e):
                  # protocol error; provide additional information in test output
                  self.fail("%s\n%s" % (e, getattr(e, "headers", "")))
  
      def test_nonascii_methodname(self):
          try:
              p = xmlrpclib.ServerProxy(URL, encoding='ascii')
              self.assertEqual(p.têšt(42), 42)
          except (xmlrpclib.ProtocolError, socket.error) as e:
              # ignore failures due to non-blocking socket unavailable errors.
              if not is_unavailable_exception(e):
                  # protocol error; provide additional information in test output
                  self.fail("%s\n%s" % (e, getattr(e, "headers", "")))
  
      # [ch] The test 404 is causing lots of false alarms.
      def XXXtest_404(self):
          # send POST with http.client, it should return 404 header and
          # 'Not Found' message.
          conn = httplib.client.HTTPConnection(ADDR, PORT)
          conn.request('POST', '/this-is-not-valid')
          response = conn.getresponse()
          conn.close()
  
          self.assertEqual(response.status, 404)
          self.assertEqual(response.reason, 'Not Found')
  
      def test_introspection1(self):
          expected_methods = set(['pow', 'div', 'my_function', 'add', 'têšt',
                                  'system.listMethods', 'system.methodHelp',
                                  'system.methodSignature', 'system.multicall',
                                  'Fixture'])
          try:
              p = xmlrpclib.ServerProxy(URL)
              meth = p.system.listMethods()
              self.assertEqual(set(meth), expected_methods)
          except (xmlrpclib.ProtocolError, OSError) as e:
              # ignore failures due to non-blocking socket 'unavailable' errors
              if not is_unavailable_exception(e):
                  # protocol error; provide additional information in test output
                  self.fail("%s\n%s" % (e, getattr(e, "headers", "")))
  
  
      def test_introspection2(self):
          try:
              # test _methodHelp()
              p = xmlrpclib.ServerProxy(URL)
              divhelp = p.system.methodHelp('div')
              self.assertEqual(divhelp, 'This is the div function')
          except (xmlrpclib.ProtocolError, OSError) as e:
              # ignore failures due to non-blocking socket 'unavailable' errors
              if not is_unavailable_exception(e):
                  # protocol error; provide additional information in test output
                  self.fail("%s\n%s" % (e, getattr(e, "headers", "")))
  
      @make_request_and_skipIf(sys.flags.optimize >= 2,
                       "Docstrings are omitted with -O2 and above")
      def test_introspection3(self):
          try:
              # test native doc
              p = xmlrpclib.ServerProxy(URL)
              myfunction = p.system.methodHelp('my_function')
              self.assertEqual(myfunction, 'This is my function')
          except (xmlrpclib.ProtocolError, OSError) as e:
              # ignore failures due to non-blocking socket 'unavailable' errors
              if not is_unavailable_exception(e):
                  # protocol error; provide additional information in test output
                  self.fail("%s\n%s" % (e, getattr(e, "headers", "")))
  
      def test_introspection4(self):
          # the SimpleXMLRPCServer doesn't support signatures, but
          # at least check that we can try making the call
          try:
              p = xmlrpclib.ServerProxy(URL)
              divsig = p.system.methodSignature('div')
              self.assertEqual(divsig, 'signatures not supported')
          except (xmlrpclib.ProtocolError, OSError) as e:
              # ignore failures due to non-blocking socket 'unavailable' errors
              if not is_unavailable_exception(e):
                  # protocol error; provide additional information in test output
                  self.fail("%s\n%s" % (e, getattr(e, "headers", "")))
  
      def test_multicall(self):
          try:
              p = xmlrpclib.ServerProxy(URL)
              multicall = xmlrpclib.MultiCall(p)
              multicall.add(2,3)
              multicall.pow(6,8)
              multicall.div(127,42)
              add_result, pow_result, div_result = multicall()
              self.assertEqual(add_result, 2+3)
              self.assertEqual(pow_result, 6**8)
              self.assertEqual(div_result, 127//42)
          except (xmlrpclib.ProtocolError, OSError) as e:
              # ignore failures due to non-blocking socket 'unavailable' errors
              if not is_unavailable_exception(e):
                  # protocol error; provide additional information in test output
                  self.fail("%s\n%s" % (e, getattr(e, "headers", "")))
  
      def test_non_existing_multicall(self):
          try:
              p = xmlrpclib.ServerProxy(URL)
              multicall = xmlrpclib.MultiCall(p)
              multicall.this_is_not_exists()
              result = multicall()
  
              # result.results contains;
              # [{'faultCode': 1, 'faultString': '<class \'exceptions.Exception\'>:'
              #   'method "this_is_not_exists" is not supported'>}]
  
              self.assertEqual(result.results[0]['faultCode'], 1)
              self.assertEqual(result.results[0]['faultString'],
                  '<class \'Exception\'>:method "this_is_not_exists" '
                  'is not supported')
          except (xmlrpclib.ProtocolError, OSError) as e:
              # ignore failures due to non-blocking socket 'unavailable' errors
              if not is_unavailable_exception(e):
                  # protocol error; provide additional information in test output
                  self.fail("%s\n%s" % (e, getattr(e, "headers", "")))
  
      def test_dotted_attribute(self):
          # Raises an AttributeError because private methods are not allowed.
          self.assertRaises(AttributeError,
                            xmlrpc.server.resolve_dotted_attribute, str, '__add')
  
          self.assertTrue(xmlrpc.server.resolve_dotted_attribute(str, 'title'))
          # Get the test to run faster by sending a request with test_simple1.
          # This avoids waiting for the socket timeout.
          self.test_simple1()
  
      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')
  
      def test_unicode_host(self):
          server = xmlrpclib.ServerProxy("http://%s:%d/RPC2" % (ADDR, PORT))
          self.assertEqual(server.add("a", "\xe9"), "a\xe9")
  
      def test_partial_post(self):
          # Check that a partial POST doesn't make the server loop: issue #14001.
          conn = http.client.HTTPConnection(ADDR, PORT)
          conn.request('POST', '/RPC2 HTTP/1.0\r\nContent-Length: 100\r\n\r\nbye')
          conn.close()
  
      def test_context_manager(self):
          with xmlrpclib.ServerProxy(URL) as server:
              server.add(2, 3)
              self.assertNotEqual(server('transport')._connection,
                                  (None, None))
          self.assertEqual(server('transport')._connection,
                           (None, None))
  
      def test_context_manager_method_error(self):
          try:
              with xmlrpclib.ServerProxy(URL) as server:
                  server.add(2, "a")
          except xmlrpclib.Fault:
              pass
          self.assertEqual(server('transport')._connection,
                           (None, None))
  
  
  class SimpleServerEncodingTestCase(BaseServerTestCase):
      @staticmethod
      def threadFunc(evt, numrequests, requestHandler=None, encoding=None):
          http_server(evt, numrequests, requestHandler, 'iso-8859-15')
  
      def test_server_encoding(self):
          start_string = '\u20ac'
          end_string = '\xa4'
  
          try:
              p = xmlrpclib.ServerProxy(URL)
              self.assertEqual(p.add(start_string, end_string),
                               start_string + end_string)
          except (xmlrpclib.ProtocolError, socket.error) as e:
              # ignore failures due to non-blocking socket unavailable errors.
              if not is_unavailable_exception(e):
                  # protocol error; provide additional information in test output
                  self.fail("%s\n%s" % (e, getattr(e, "headers", "")))
  
  
  class MultiPathServerTestCase(BaseServerTestCase):
      threadFunc = staticmethod(http_multi_server)
      request_count = 2
      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)
  
      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)
  
      def test_path3(self):
          p = xmlrpclib.ServerProxy(URL+"/is/broken")
          self.assertRaises(xmlrpclib.Fault, p.add, 6, 8)
  
  #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 BaseKeepaliveServerTestCase(BaseServerTestCase):
      #a request handler that supports keep-alive and logs requests into a
      #class variable
      class RequestHandler(xmlrpc.server.SimpleXMLRPCRequestHandler):
          parentClass = xmlrpc.server.SimpleXMLRPCRequestHandler
          protocol_version = 'HTTP/1.1'
          myRequests = []
          def handle(self):
              self.myRequests.append([])
              self.reqidx = len(self.myRequests)-1
              return self.parentClass.handle(self)
          def handle_one_request(self):
              result = self.parentClass.handle_one_request(self)
              self.myRequests[self.reqidx].append(self.raw_requestline)
              return result
  
      requestHandler = RequestHandler
      def setUp(self):
          #clear request log
          self.RequestHandler.myRequests = []
          return BaseServerTestCase.setUp(self)
  
  #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):
      def test_two(self):
          p = xmlrpclib.ServerProxy(URL)
          #do three requests.
          self.assertEqual(p.pow(6,8), 6**8)
          self.assertEqual(p.pow(6,8), 6**8)
          self.assertEqual(p.pow(6,8), 6**8)
          p("close")()
  
          #they should have all been handled by a single request handler
          self.assertEqual(len(self.RequestHandler.myRequests), 1)
  
          #check that we did at least two (the third may be pending append
          #due to thread scheduling)
          self.assertGreaterEqual(len(self.RequestHandler.myRequests[-1]), 2)
  
  
  #test special attribute access on the serverproxy, through the __call__
  #function.
  class KeepaliveServerTestCase2(BaseKeepaliveServerTestCase):
      #ask for two keepalive requests to be handled.
      request_count=2
  
      def test_close(self):
          p = xmlrpclib.ServerProxy(URL)
          #do some requests with close.
          self.assertEqual(p.pow(6,8), 6**8)
          self.assertEqual(p.pow(6,8), 6**8)
          self.assertEqual(p.pow(6,8), 6**8)
          p("close")() #this should trigger a new keep-alive request
          self.assertEqual(p.pow(6,8), 6**8)
          self.assertEqual(p.pow(6,8), 6**8)
          self.assertEqual(p.pow(6,8), 6**8)
          p("close")()
  
          #they should have all been two request handlers, each having logged at least
          #two complete requests
          self.assertEqual(len(self.RequestHandler.myRequests), 2)
          self.assertGreaterEqual(len(self.RequestHandler.myRequests[-1]), 2)
          self.assertGreaterEqual(len(self.RequestHandler.myRequests[-2]), 2)
  
  
      def test_transport(self):
          p = xmlrpclib.ServerProxy(URL)
          #do some requests with close.
          self.assertEqual(p.pow(6,8), 6**8)
          p("transport").close() #same as above, really.
          self.assertEqual(p.pow(6,8), 6**8)
          p("close")()
          self.assertEqual(len(self.RequestHandler.myRequests), 2)
  
  #A test case that verifies that gzip encoding works in both directions
  #(for a request and the response)
  @unittest.skipIf(gzip is None, 'requires gzip')
  class GzipServerTestCase(BaseServerTestCase):
      #a request handler that supports keep-alive and logs requests into a
      #class variable
      class RequestHandler(xmlrpc.server.SimpleXMLRPCRequestHandler):
          parentClass = xmlrpc.server.SimpleXMLRPCRequestHandler
          protocol_version = 'HTTP/1.1'
  
          def do_POST(self):
              #store content of last request in class
              self.__class__.content_length = int(self.headers["content-length"])
              return self.parentClass.do_POST(self)
      requestHandler = RequestHandler
  
      class Transport(xmlrpclib.Transport):
          #custom transport, stores the response length for our perusal
          fake_gzip = False
          def parse_response(self, response):
              self.response_length=int(response.getheader("content-length", 0))
              return xmlrpclib.Transport.parse_response(self, response)
  
          def send_content(self, connection, body):
              if self.fake_gzip:
                  #add a lone gzip header to induce decode error remotely
                  connection.putheader("Content-Encoding", "gzip")
              return xmlrpclib.Transport.send_content(self, connection, body)
  
      def setUp(self):
          BaseServerTestCase.setUp(self)
  
      def test_gzip_request(self):
          t = self.Transport()
          t.encode_threshold = None
          p = xmlrpclib.ServerProxy(URL, transport=t)
          self.assertEqual(p.pow(6,8), 6**8)
          a = self.RequestHandler.content_length
          t.encode_threshold = 0 #turn on request encoding
          self.assertEqual(p.pow(6,8), 6**8)
          b = self.RequestHandler.content_length
          self.assertTrue(a>b)
          p("close")()
  
      def test_bad_gzip_request(self):
          t = self.Transport()
          t.encode_threshold = None
          t.fake_gzip = True
          p = xmlrpclib.ServerProxy(URL, transport=t)
          cm = self.assertRaisesRegex(xmlrpclib.ProtocolError,
                                      re.compile(r"\b400\b"))
          with cm:
              p.pow(6, 8)
          p("close")()
  
      def test_gzip_response(self):
          t = self.Transport()
          p = xmlrpclib.ServerProxy(URL, transport=t)
          old = self.requestHandler.encode_threshold
          self.requestHandler.encode_threshold = None #no encoding
          self.assertEqual(p.pow(6,8), 6**8)
          a = t.response_length
          self.requestHandler.encode_threshold = 0 #always encode
          self.assertEqual(p.pow(6,8), 6**8)
          p("close")()
          b = t.response_length
          self.requestHandler.encode_threshold = old
          self.assertTrue(a>b)
  
  
  @unittest.skipIf(gzip is None, 'requires gzip')
  class GzipUtilTestCase(unittest.TestCase):
  
      def test_gzip_decode_limit(self):
          max_gzip_decode = 20 * 1024 * 1024
          data = b'\0' * max_gzip_decode
          encoded = xmlrpclib.gzip_encode(data)
          decoded = xmlrpclib.gzip_decode(encoded)
          self.assertEqual(len(decoded), max_gzip_decode)
  
          data = b'\0' * (max_gzip_decode + 1)
          encoded = xmlrpclib.gzip_encode(data)
  
          with self.assertRaisesRegex(ValueError,
                                      "max gzipped payload length exceeded"):
              xmlrpclib.gzip_decode(encoded)
  
          xmlrpclib.gzip_decode(encoded, max_decode=-1)
  
  
  #Test special attributes of the ServerProxy object
  class ServerProxyTestCase(unittest.TestCase):
      def setUp(self):
          unittest.TestCase.setUp(self)
          if threading:
              self.url = URL
          else:
              # Without threading, http_server() and http_multi_server() will not
              # be executed and URL is still equal to None. 'http://' is a just
              # enough to choose the scheme (HTTP)
              self.url = 'http://'
  
      def test_close(self):
          p = xmlrpclib.ServerProxy(self.url)
          self.assertEqual(p('close')(), None)
  
      def test_transport(self):
          t = xmlrpclib.Transport()
          p = xmlrpclib.ServerProxy(self.url, transport=t)
          self.assertEqual(p('transport'), t)
  
  
  # This is a contrived way to make a failure occur on the server side
  # in order to test the _send_traceback_header flag on the server
  class FailingMessageClass(http.client.HTTPMessage):
      def get(self, key, failobj=None):
          key = key.lower()
          if key == 'content-length':
              return 'I am broken'
          return super().get(key, failobj)
  
  
  @unittest.skipUnless(threading, 'Threading required for this test.')
  class FailingServerTestCase(unittest.TestCase):
      def setUp(self):
          self.evt = threading.Event()
          # start server thread to handle requests
          serv_args = (self.evt, 1)
          threading.Thread(target=http_server, args=serv_args).start()
  
          # wait for the server to be ready
          self.evt.wait()
          self.evt.clear()
  
      def tearDown(self):
          # wait on the server thread to terminate
          self.evt.wait()
          # reset flag
          xmlrpc.server.SimpleXMLRPCServer._send_traceback_header = False
          # reset message class
          default_class = http.client.HTTPMessage
          xmlrpc.server.SimpleXMLRPCRequestHandler.MessageClass = default_class
  
      def test_basic(self):
          # check that flag is false by default
          flagval = xmlrpc.server.SimpleXMLRPCServer._send_traceback_header
          self.assertEqual(flagval, False)
  
          # enable traceback reporting
          xmlrpc.server.SimpleXMLRPCServer._send_traceback_header = True
  
          # test a call that shouldn't fail just as a smoke test
          try:
              p = xmlrpclib.ServerProxy(URL)
              self.assertEqual(p.pow(6,8), 6**8)
          except (xmlrpclib.ProtocolError, OSError) as e:
              # ignore failures due to non-blocking socket 'unavailable' errors
              if not is_unavailable_exception(e):
                  # protocol error; provide additional information in test output
                  self.fail("%s\n%s" % (e, getattr(e, "headers", "")))
  
      def test_fail_no_info(self):
          # use the broken message class
          xmlrpc.server.SimpleXMLRPCRequestHandler.MessageClass = FailingMessageClass
  
          try:
              p = xmlrpclib.ServerProxy(URL)
              p.pow(6,8)
          except (xmlrpclib.ProtocolError, OSError) as e:
              # ignore failures due to non-blocking socket 'unavailable' errors
              if not is_unavailable_exception(e) and hasattr(e, "headers"):
                  # The two server-side error headers shouldn't be sent back in this case
                  self.assertTrue(e.headers.get("X-exception") is None)
                  self.assertTrue(e.headers.get("X-traceback") is None)
          else:
              self.fail('ProtocolError not raised')
  
      def test_fail_with_info(self):
          # use the broken message class
          xmlrpc.server.SimpleXMLRPCRequestHandler.MessageClass = FailingMessageClass
  
          # Check that errors in the server send back exception/traceback
          # info when flag is set
          xmlrpc.server.SimpleXMLRPCServer._send_traceback_header = True
  
          try:
              p = xmlrpclib.ServerProxy(URL)
              p.pow(6,8)
          except (xmlrpclib.ProtocolError, OSError) as e:
              # ignore failures due to non-blocking socket 'unavailable' errors
              if not is_unavailable_exception(e) and hasattr(e, "headers"):
                  # We should get error info in the response
                  expected_err = "invalid literal for int() with base 10: 'I am broken'"
                  self.assertEqual(e.headers.get("X-exception"), expected_err)
                  self.assertTrue(e.headers.get("X-traceback") is not None)
          else:
              self.fail('ProtocolError not raised')
  
  
  @contextlib.contextmanager
  def captured_stdout(encoding='utf-8'):
      """A variation on support.captured_stdout() which gives a text stream
      having a `buffer` attribute.
      """
      orig_stdout = sys.stdout
      sys.stdout = io.TextIOWrapper(io.BytesIO(), encoding=encoding)
      try:
          yield sys.stdout
      finally:
          sys.stdout = orig_stdout
  
  
  class CGIHandlerTestCase(unittest.TestCase):
      def setUp(self):
          self.cgi = xmlrpc.server.CGIXMLRPCRequestHandler()
  
      def tearDown(self):
          self.cgi = None
  
      def test_cgi_get(self):
          with support.EnvironmentVarGuard() as env:
              env['REQUEST_METHOD'] = 'GET'
              # if the method is GET and no request_text is given, it runs handle_get
              # get sysout output
              with captured_stdout(encoding=self.cgi.encoding) as data_out:
                  self.cgi.handle_request()
  
              # parse Status header
              data_out.seek(0)
              handle = data_out.read()
              status = handle.split()[1]
              message = ' '.join(handle.split()[2:4])
  
              self.assertEqual(status, '400')
              self.assertEqual(message, 'Bad Request')
  
  
      def test_cgi_xmlrpc_response(self):
          data = """<?xml version='1.0'?>
          <methodCall>
              <methodName>test_method</methodName>
              <params>
                  <param>
                      <value><string>foo</string></value>
                  </param>
                  <param>
                      <value><string>bar</string></value>
                  </param>
              </params>
          </methodCall>
          """
  
          with support.EnvironmentVarGuard() as env, \
               captured_stdout(encoding=self.cgi.encoding) as data_out, \
               support.captured_stdin() as data_in:
              data_in.write(data)
              data_in.seek(0)
              env['CONTENT_LENGTH'] = str(len(data))
              self.cgi.handle_request()
          data_out.seek(0)
  
          # will respond exception, if so, our goal is achieved ;)
          handle = data_out.read()
  
          # start with 44th char so as not to get http header, we just
          # need only xml
          self.assertRaises(xmlrpclib.Fault, xmlrpclib.loads, handle[44:])
  
          # Also test the content-length returned  by handle_request
          # Using the same test method inorder to avoid all the datapassing
          # boilerplate code.
          # Test for bug: http://bugs.python.org/issue5040
  
          content = handle[handle.find("<?xml"):]
  
          self.assertEqual(
              int(re.search(r'Content-Length: (\d+)', handle).group(1)),
              len(content))
  
  
  class UseBuiltinTypesTestCase(unittest.TestCase):
  
      def test_use_builtin_types(self):
          # SimpleXMLRPCDispatcher.__init__ accepts use_builtin_types, which
          # makes all dispatch of binary data as bytes instances, and all
          # dispatch of datetime argument as datetime.datetime instances.
          self.log = []
          expected_bytes = b"my dog has fleas"
          expected_date = datetime.datetime(2008, 5, 26, 18, 25, 12)
          marshaled = xmlrpclib.dumps((expected_bytes, expected_date), 'foobar')
          def foobar(*args):
              self.log.extend(args)
          handler = xmlrpc.server.SimpleXMLRPCDispatcher(
              allow_none=True, encoding=None, use_builtin_types=True)
          handler.register_function(foobar)
          handler._marshaled_dispatch(marshaled)
          self.assertEqual(len(self.log), 2)
          mybytes, mydate = self.log
          self.assertEqual(self.log, [expected_bytes, expected_date])
          self.assertIs(type(mydate), datetime.datetime)
          self.assertIs(type(mybytes), bytes)
  
      def test_cgihandler_has_use_builtin_types_flag(self):
          handler = xmlrpc.server.CGIXMLRPCRequestHandler(use_builtin_types=True)
          self.assertTrue(handler.use_builtin_types)
  
      def test_xmlrpcserver_has_use_builtin_types_flag(self):
          server = xmlrpc.server.SimpleXMLRPCServer(("localhost", 0),
              use_builtin_types=True)
          server.server_close()
          self.assertTrue(server.use_builtin_types)
  
  
  @support.reap_threads
  def test_main():
      support.run_unittest(XMLRPCTestCase, HelperTestCase, DateTimeTestCase,
              BinaryTestCase, FaultTestCase, UseBuiltinTypesTestCase,
              SimpleServerTestCase, SimpleServerEncodingTestCase,
              KeepaliveServerTestCase1, KeepaliveServerTestCase2,
              GzipServerTestCase, GzipUtilTestCase,
              MultiPathServerTestCase, ServerProxyTestCase, FailingServerTestCase,
              CGIHandlerTestCase, SimpleXMLRPCDispatcherTestCase)
  
  
  if __name__ == "__main__":
      test_main()
  