Force test_xmlrpc to pass. I'm not happy with how I did this, but I don't

see a better way; the 'Binary' class is poorly specified so it's unclear
what behavior is relied upon.

3 files changed, 35 insertions, 15 deletions

diff --git a/Lib/base64.py b/Lib/base64.py
index 5d42065..1b9f560 100755
--- a/Lib/base64.py
+++ b/Lib/base64.py
@@ -298,7 +298,7 @@ MAXLINESIZE = 76 # Excluding the CRLF
 MAXBINSIZE = (MAXLINESIZE//4)*3
 
 def encode(input, output):
-    """Encode a file."""
+    """Encode a file; input and output are binary files."""
     while True:
         s = input.read(MAXBINSIZE)
         if not s:
@@ -313,7 +313,7 @@ def encode(input, output):
 
 
 def decode(input, output):
-    """Decode a file."""
+    """Decode a file; input and output are binary files."""
     while True:
         line = input.readline()
         if not line:
@@ -323,7 +323,10 @@ def decode(input, output):
 
 
 def encodestring(s):
-    """Encode a string into multiple lines of base-64 data."""
+    """Encode a string into multiple lines of base-64 data.
+
+    Argument and return value are bytes.
+    """
     if not isinstance(s, bytes):
         raise TypeError("expected bytes, not %s" % s.__class__.__name__)
     pieces = []
@@ -334,7 +337,10 @@ def encodestring(s):
 
 
 def decodestring(s):
-    """Decode a string."""
+    """Decode a string.
+
+    Argument and return value are bytes.
+    """
     if not isinstance(s, bytes):
         raise TypeError("expected bytes, not %s" % s.__class__.__name__)
     return binascii.a2b_base64(s)
diff --git a/Lib/test/test_xmlrpc.py b/Lib/test/test_xmlrpc.py
index 03080ab..ef61c55 100644
--- a/Lib/test/test_xmlrpc.py
+++ b/Lib/test/test_xmlrpc.py
@@ -14,7 +14,7 @@ alist = [{'astring': 'foo@bar.baz.spam',
           'anint': 2**20,
           'ashortlong': 2,
           'anotherlist': ['.zyx.41'],
-          'abase64': xmlrpclib.Binary("my dog has fleas"),
+          'abase64': xmlrpclib.Binary(b"my dog has fleas"),
           'boolean': False,
           'unicode': '\u4000\u6000\u8000',
           'ukey\u4000': 'regular value',
@@ -32,8 +32,9 @@ alist = [{'astring': 'foo@bar.baz.spam',
 class XMLRPCTestCase(unittest.TestCase):
 
     def test_dump_load(self):
-        self.assertEquals(alist,
-                          xmlrpclib.loads(xmlrpclib.dumps((alist,)))[0][0])
+        dump = xmlrpclib.dumps((alist,))
+        load = xmlrpclib.loads(dump)
+        self.assertEquals(alist, load[0][0])
 
     def test_dump_bare_datetime(self):
         # This checks that an unwrapped datetime.date object can be handled
@@ -222,24 +223,30 @@ class DateTimeTestCase(unittest.TestCase):
         self.assertEqual(t1, tref)
 
 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 = '\x01\x02\x03abc123\xff\xfe'
+        d = b'\x01\x02\x03abc123\xff\xfe'
         t = xmlrpclib.Binary(d)
-        self.assertEqual(str(t), d)
+        self.assertEqual(str(t), str(d, "latin-1"))
 
     def test_decode(self):
-        d = '\x01\x02\x03abc123\xff\xfe'
+        d = b'\x01\x02\x03abc123\xff\xfe'
         de = base64.encodestring(d)
         t1 = xmlrpclib.Binary()
         t1.decode(de)
-        self.assertEqual(str(t1), d)
+        self.assertEqual(str(t1), str(d, "latin-1"))
 
         t2 = xmlrpclib._binary(de)
-        self.assertEqual(str(t2), d)
+        self.assertEqual(str(t2), str(d, "latin-1"))
 
 
 PORT = None
diff --git a/Lib/xmlrpclib.py b/Lib/xmlrpclib.py
index abd1a07..586dc4c 100644
--- a/Lib/xmlrpclib.py
+++ b/Lib/xmlrpclib.py
@@ -364,6 +364,13 @@ class Binary:
     """Wrapper for binary data."""
 
     def __init__(self, data=None):
+        if data is None:
+            data = b""
+        else:
+            if not isinstance(data, bytes):
+                raise TypeError("expected bytes, not %s" %
+                                data.__class__.__name__)
+            data = bytes(data)  # Make a copy of the bytes!
         self.data = data
 
     ##
@@ -372,7 +379,7 @@ class Binary:
     # @return Buffer contents, as an 8-bit string.
 
     def __str__(self):
-        return self.data or ""
+        return str(self.data, "latin-1")  # XXX encoding?!
 
     def __eq__(self, other):
         if isinstance(other, Binary):
@@ -385,7 +392,7 @@ class Binary:
         return self.data != other
 
     def decode(self, data):
-        self.data = str8(base64.decodestring(data))
+        self.data = base64.decodestring(data)
 
     def encode(self, out):
         out.write("<value><base64>\n")
@@ -827,7 +834,7 @@ class Unmarshaller:
 
     def end_base64(self, data):
         value = Binary()
-        value.decode(data)
+        value.decode(data.encode("ascii"))
         self.append(value)
         self._value = 0
     dispatch["base64"] = end_base64