/Lib/test/test_base64.py

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