Commit | Line | Data |
---|---|---|
920dae64 AT |
1 | import unittest |
2 | from test import test_support | |
3 | import base64 | |
4 | ||
5 | ||
6 | \f | |
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 | \f | |
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 | \f | |
186 | def suite(): | |
187 | suite = unittest.TestSuite() | |
188 | suite.addTest(unittest.makeSuite(LegacyBase64TestCase)) | |
189 | suite.addTest(unittest.makeSuite(BaseXYTestCase)) | |
190 | return suite | |
191 | ||
192 | ||
193 | def test_main(): | |
194 | test_support.run_suite(suite()) | |
195 | ||
196 | ||
197 | if __name__ == '__main__': | |
198 | unittest.main(defaultTest='suite') |