|
1 import unittest |
|
2 from test import test_support |
|
3 import base64 |
|
4 |
|
5 |
|
6 |
|
7 class 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 |
|
58 class 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 |
|
186 def test_main(): |
|
187 test_support.run_unittest(__name__) |
|
188 |
|
189 if __name__ == '__main__': |
|
190 test_main() |