Lib/test/test_base64.py

   1 import unittest
   2 from test import support
   3 import base64
   4 import binascii
   5
   6
   7 \f
   8 class LegacyBase64TestCase(unittest.TestCase):
   9     def test_encodebytes(self):
  10         eq = self.assertEqual
  11         eq(base64.encodebytes(b"www.python.org"), b"d3d3LnB5dGhvbi5vcmc=\n")
  12         eq(base64.encodebytes(b"a"), b"YQ==\n")
  13         eq(base64.encodebytes(b"ab"), b"YWI=\n")
  14         eq(base64.encodebytes(b"abc"), b"YWJj\n")
  15         eq(base64.encodebytes(b""), b"")
  16         eq(base64.encodebytes(b"abcdefghijklmnopqrstuvwxyz"
  17                                b"ABCDEFGHIJKLMNOPQRSTUVWXYZ"
  18                                b"0123456789!@#0^&*();:<>,. []{}"),
  19            b"YWJjZGVmZ2hpamtsbW5vcHFyc3R1dnd4eXpBQkNE"
  20            b"RUZHSElKS0xNTk9QUVJTVFVWV1hZWjAxMjM0\nNT"
  21            b"Y3ODkhQCMwXiYqKCk7Ojw+LC4gW117fQ==\n")
  22         self.assertRaises(TypeError, base64.encodebytes, "")
  23
  24     def test_decodebytes(self):
  25         eq = self.assertEqual
  26         eq(base64.decodebytes(b"d3d3LnB5dGhvbi5vcmc=\n"), b"www.python.org")
  27         eq(base64.decodebytes(b"YQ==\n"), b"a")
  28         eq(base64.decodebytes(b"YWI=\n"), b"ab")
  29         eq(base64.decodebytes(b"YWJj\n"), b"abc")
  30         eq(base64.decodebytes(b"YWJjZGVmZ2hpamtsbW5vcHFyc3R1dnd4eXpBQkNE"
  31                                b"RUZHSElKS0xNTk9QUVJTVFVWV1hZWjAxMjM0\nNT"
  32                                b"Y3ODkhQCMwXiYqKCk7Ojw+LC4gW117fQ==\n"),
  33            b"abcdefghijklmnopqrstuvwxyz"
  34            b"ABCDEFGHIJKLMNOPQRSTUVWXYZ"
  35            b"0123456789!@#0^&*();:<>,. []{}")
  36         eq(base64.decodebytes(b''), b'')
  37         self.assertRaises(TypeError, base64.decodebytes, "")
  38
  39     def test_encode(self):
  40         eq = self.assertEqual
  41         from io import BytesIO
  42         infp = BytesIO(b'abcdefghijklmnopqrstuvwxyz'
  43                        b'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
  44                        b'0123456789!@#0^&*();:<>,. []{}')
  45         outfp = BytesIO()
  46         base64.encode(infp, outfp)
  47         eq(outfp.getvalue(),
  48            b'YWJjZGVmZ2hpamtsbW5vcHFyc3R1dnd4eXpBQkNE'
  49            b'RUZHSElKS0xNTk9QUVJTVFVWV1hZWjAxMjM0\nNT'
  50            b'Y3ODkhQCMwXiYqKCk7Ojw+LC4gW117fQ==\n')
  51
  52     def test_decode(self):
  53         from io import BytesIO
  54         infp = BytesIO(b'd3d3LnB5dGhvbi5vcmc=')
  55         outfp = BytesIO()
  56         base64.decode(infp, outfp)
  57         self.assertEqual(outfp.getvalue(), b'www.python.org')
  58
  59 \f
  60 class BaseXYTestCase(unittest.TestCase):
  61     def test_b64encode(self):
  62         eq = self.assertEqual
  63         # Test default alphabet
  64         eq(base64.b64encode(b"www.python.org"), b"d3d3LnB5dGhvbi5vcmc=")
  65         eq(base64.b64encode(b'\x00'), b'AA==')
  66         eq(base64.b64encode(b"a"), b"YQ==")
  67         eq(base64.b64encode(b"ab"), b"YWI=")
  68         eq(base64.b64encode(b"abc"), b"YWJj")
  69         eq(base64.b64encode(b""), b"")
  70         eq(base64.b64encode(b"abcdefghijklmnopqrstuvwxyz"
  71                             b"ABCDEFGHIJKLMNOPQRSTUVWXYZ"
  72                             b"0123456789!@#0^&*();:<>,. []{}"),
  73            b"YWJjZGVmZ2hpamtsbW5vcHFyc3R1dnd4eXpBQkNE"
  74            b"RUZHSElKS0xNTk9QUVJTVFVWV1hZWjAxMjM0NT"
  75            b"Y3ODkhQCMwXiYqKCk7Ojw+LC4gW117fQ==")
  76         # Test with arbitrary alternative characters
  77         eq(base64.b64encode(b'\xd3V\xbeo\xf7\x1d', altchars=b'*$'), b'01a*b$cd')
  78         # Check if passing a str object raises an error
  79         self.assertRaises(TypeError, base64.b64encode, "")
  80         self.assertRaises(TypeError, base64.b64encode, b"", altchars="")
  81         # Test standard alphabet
  82         eq(base64.standard_b64encode(b"www.python.org"), b"d3d3LnB5dGhvbi5vcmc=")
  83         eq(base64.standard_b64encode(b"a"), b"YQ==")
  84         eq(base64.standard_b64encode(b"ab"), b"YWI=")
  85         eq(base64.standard_b64encode(b"abc"), b"YWJj")
  86         eq(base64.standard_b64encode(b""), b"")
  87         eq(base64.standard_b64encode(b"abcdefghijklmnopqrstuvwxyz"
  88                                      b"ABCDEFGHIJKLMNOPQRSTUVWXYZ"
  89                                      b"0123456789!@#0^&*();:<>,. []{}"),
  90            b"YWJjZGVmZ2hpamtsbW5vcHFyc3R1dnd4eXpBQkNE"
  91            b"RUZHSElKS0xNTk9QUVJTVFVWV1hZWjAxMjM0NT"
  92            b"Y3ODkhQCMwXiYqKCk7Ojw+LC4gW117fQ==")
  93         # Check if passing a str object raises an error
  94         self.assertRaises(TypeError, base64.standard_b64encode, "")
  95         self.assertRaises(TypeError, base64.standard_b64encode, b"", altchars="")
  96         # Test with 'URL safe' alternative characters
  97         eq(base64.urlsafe_b64encode(b'\xd3V\xbeo\xf7\x1d'), b'01a-b_cd')
  98         # Check if passing a str object raises an error
  99         self.assertRaises(TypeError, base64.urlsafe_b64encode, "")
 100
 101     def test_b64decode(self):
 102         eq = self.assertEqual
 103         eq(base64.b64decode(b"d3d3LnB5dGhvbi5vcmc="), b"www.python.org")
 104         eq(base64.b64decode(b'AA=='), b'\x00')
 105         eq(base64.b64decode(b"YQ=="), b"a")
 106         eq(base64.b64decode(b"YWI="), b"ab")
 107         eq(base64.b64decode(b"YWJj"), b"abc")
 108         eq(base64.b64decode(b"YWJjZGVmZ2hpamtsbW5vcHFyc3R1dnd4eXpBQkNE"
 109                             b"RUZHSElKS0xNTk9QUVJTVFVWV1hZWjAxMjM0\nNT"
 110                             b"Y3ODkhQCMwXiYqKCk7Ojw+LC4gW117fQ=="),
 111            b"abcdefghijklmnopqrstuvwxyz"
 112            b"ABCDEFGHIJKLMNOPQRSTUVWXYZ"
 113            b"0123456789!@#0^&*();:<>,. []{}")
 114         eq(base64.b64decode(b''), b'')
 115         # Test with arbitrary alternative characters
 116         eq(base64.b64decode(b'01a*b$cd', altchars=b'*$'), b'\xd3V\xbeo\xf7\x1d')
 117         # Check if passing a str object raises an error
 118         self.assertRaises(TypeError, base64.b64decode, "")
 119         self.assertRaises(TypeError, base64.b64decode, b"", altchars="")
 120         # Test standard alphabet
 121         eq(base64.standard_b64decode(b"d3d3LnB5dGhvbi5vcmc="), b"www.python.org")
 122         eq(base64.standard_b64decode(b"YQ=="), b"a")
 123         eq(base64.standard_b64decode(b"YWI="), b"ab")
 124         eq(base64.standard_b64decode(b"YWJj"), b"abc")
 125         eq(base64.standard_b64decode(b""), b"")
 126         eq(base64.standard_b64decode(b"YWJjZGVmZ2hpamtsbW5vcHFyc3R1dnd4eXpBQkNE"
 127                                      b"RUZHSElKS0xNTk9QUVJTVFVWV1hZWjAxMjM0NT"
 128                                      b"Y3ODkhQCMwXiYqKCk7Ojw+LC4gW117fQ=="),
 129            b"abcdefghijklmnopqrstuvwxyz"
 130            b"ABCDEFGHIJKLMNOPQRSTUVWXYZ"
 131            b"0123456789!@#0^&*();:<>,. []{}")
 132         # Check if passing a str object raises an error
 133         self.assertRaises(TypeError, base64.standard_b64decode, "")
 134         self.assertRaises(TypeError, base64.standard_b64decode, b"", altchars="")
 135         # Test with 'URL safe' alternative characters
 136         eq(base64.urlsafe_b64decode(b'01a-b_cd'), b'\xd3V\xbeo\xf7\x1d')
 137         self.assertRaises(TypeError, base64.urlsafe_b64decode, "")
 138
 139     def test_b64decode_error(self):
 140         self.assertRaises(binascii.Error, base64.b64decode, b'abc')
 141
 142     def test_b32encode(self):
 143         eq = self.assertEqual
 144         eq(base64.b32encode(b''), b'')
 145         eq(base64.b32encode(b'\x00'), b'AA======')
 146         eq(base64.b32encode(b'a'), b'ME======')
 147         eq(base64.b32encode(b'ab'), b'MFRA====')
 148         eq(base64.b32encode(b'abc'), b'MFRGG===')
 149         eq(base64.b32encode(b'abcd'), b'MFRGGZA=')
 150         eq(base64.b32encode(b'abcde'), b'MFRGGZDF')
 151         self.assertRaises(TypeError, base64.b32encode, "")
 152
 153     def test_b32decode(self):
 154         eq = self.assertEqual
 155         eq(base64.b32decode(b''), b'')
 156         eq(base64.b32decode(b'AA======'), b'\x00')
 157         eq(base64.b32decode(b'ME======'), b'a')
 158         eq(base64.b32decode(b'MFRA===='), b'ab')
 159         eq(base64.b32decode(b'MFRGG==='), b'abc')
 160         eq(base64.b32decode(b'MFRGGZA='), b'abcd')
 161         eq(base64.b32decode(b'MFRGGZDF'), b'abcde')
 162         self.assertRaises(TypeError, base64.b32decode, "")
 163
 164     def test_b32decode_casefold(self):
 165         eq = self.assertEqual
 166         eq(base64.b32decode(b'', True), b'')
 167         eq(base64.b32decode(b'ME======', True), b'a')
 168         eq(base64.b32decode(b'MFRA====', True), b'ab')
 169         eq(base64.b32decode(b'MFRGG===', True), b'abc')
 170         eq(base64.b32decode(b'MFRGGZA=', True), b'abcd')
 171         eq(base64.b32decode(b'MFRGGZDF', True), b'abcde')
 172         # Lower cases
 173         eq(base64.b32decode(b'me======', True), b'a')
 174         eq(base64.b32decode(b'mfra====', True), b'ab')
 175         eq(base64.b32decode(b'mfrgg===', True), b'abc')
 176         eq(base64.b32decode(b'mfrggza=', True), b'abcd')
 177         eq(base64.b32decode(b'mfrggzdf', True), b'abcde')
 178         # Expected exceptions
 179         self.assertRaises(TypeError, base64.b32decode, b'me======')
 180         # Mapping zero and one
 181         eq(base64.b32decode(b'MLO23456'), b'b\xdd\xad\xf3\xbe')
 182         eq(base64.b32decode(b'M1023456', map01=b'L'), b'b\xdd\xad\xf3\xbe')
 183         eq(base64.b32decode(b'M1023456', map01=b'I'), b'b\x1d\xad\xf3\xbe')
 184         self.assertRaises(TypeError, base64.b32decode, b"", map01="")
 185
 186     def test_b32decode_error(self):
 187         self.assertRaises(binascii.Error, base64.b32decode, b'abc')
 188         self.assertRaises(binascii.Error, base64.b32decode, b'ABCDEF==')
 189
 190     def test_b16encode(self):
 191         eq = self.assertEqual
 192         eq(base64.b16encode(b'\x01\x02\xab\xcd\xef'), b'0102ABCDEF')
 193         eq(base64.b16encode(b'\x00'), b'00')
 194         self.assertRaises(TypeError, base64.b16encode, "")
 195
 196     def test_b16decode(self):
 197         eq = self.assertEqual
 198         eq(base64.b16decode(b'0102ABCDEF'), b'\x01\x02\xab\xcd\xef')
 199         eq(base64.b16decode(b'00'), b'\x00')
 200         # Lower case is not allowed without a flag
 201         self.assertRaises(binascii.Error, base64.b16decode, b'0102abcdef')
 202         # Case fold
 203         eq(base64.b16decode(b'0102abcdef', True), b'\x01\x02\xab\xcd\xef')
 204         self.assertRaises(TypeError, base64.b16decode, "")
 205
 206     def test_ErrorHeritage(self):
 207         self.assert_(issubclass(binascii.Error, ValueError))
 208
 209
 210 \f
 211 def test_main():
 212     support.run_unittest(__name__)
 213
 214 if __name__ == '__main__':
 215     test_main()