]> git.proxmox.com Git - mirror_edk2.git/blame - AppPkg/Applications/Python/Python-2.7.2/Lib/test/test_unicode.py
projects / mirror_edk2.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
EmbeddedPkg: Extend NvVarStoreFormattedLib LIBRARY_CLASS
[mirror_edk2.git] / AppPkg / Applications / Python / Python-2.7.2 / Lib / test / test_unicode.py
CommitLineData
4710c53d 1""" Test script for the Unicode implementation.\r
2\r
3Written by Marc-Andre Lemburg (mal@lemburg.com).\r
4\r
5(c) Copyright CNRI, All Rights Reserved. NO WARRANTY.\r
6\r
7"""#"\r
8import sys, struct, codecs\r
9from test import test_support, string_tests\r
10\r
11# Error handling (bad decoder return)\r
12def search_function(encoding):\r
13 def decode1(input, errors="strict"):\r
14 return 42 # not a tuple\r
15 def encode1(input, errors="strict"):\r
16 return 42 # not a tuple\r
17 def encode2(input, errors="strict"):\r
18 return (42, 42) # no unicode\r
19 def decode2(input, errors="strict"):\r
20 return (42, 42) # no unicode\r
21 if encoding=="test.unicode1":\r
22 return (encode1, decode1, None, None)\r
23 elif encoding=="test.unicode2":\r
24 return (encode2, decode2, None, None)\r
25 else:\r
26 return None\r
27codecs.register(search_function)\r
28\r
29class UnicodeTest(\r
30 string_tests.CommonTest,\r
31 string_tests.MixinStrUnicodeUserStringTest,\r
32 string_tests.MixinStrUnicodeTest,\r
33 ):\r
34 type2test = unicode\r
35\r
36 def assertEqual(self, first, second, msg=None):\r
37 # strict assertEqual method: reject implicit bytes/unicode equality\r
38 super(UnicodeTest, self).assertEqual(first, second, msg)\r
39 if isinstance(first, unicode) or isinstance(second, unicode):\r
40 self.assertIsInstance(first, unicode)\r
41 self.assertIsInstance(second, unicode)\r
42 elif isinstance(first, str) or isinstance(second, str):\r
43 self.assertIsInstance(first, str)\r
44 self.assertIsInstance(second, str)\r
45\r
46 def checkequalnofix(self, result, object, methodname, *args):\r
47 method = getattr(object, methodname)\r
48 realresult = method(*args)\r
49 self.assertEqual(realresult, result)\r
50 self.assertTrue(type(realresult) is type(result))\r
51\r
52 # if the original is returned make sure that\r
53 # this doesn't happen with subclasses\r
54 if realresult is object:\r
55 class usub(unicode):\r
56 def __repr__(self):\r
57 return 'usub(%r)' % unicode.__repr__(self)\r
58 object = usub(object)\r
59 method = getattr(object, methodname)\r
60 realresult = method(*args)\r
61 self.assertEqual(realresult, result)\r
62 self.assertTrue(object is not realresult)\r
63\r
64 def test_literals(self):\r
65 self.assertEqual(u'\xff', u'\u00ff')\r
66 self.assertEqual(u'\uffff', u'\U0000ffff')\r
67 self.assertRaises(SyntaxError, eval, 'u\'\\Ufffffffe\'')\r
68 self.assertRaises(SyntaxError, eval, 'u\'\\Uffffffff\'')\r
69 self.assertRaises(SyntaxError, eval, 'u\'\\U%08x\'' % 0x110000)\r
70\r
71 def test_repr(self):\r
72 if not sys.platform.startswith('java'):\r
73 # Test basic sanity of repr()\r
74 self.assertEqual(repr(u'abc'), "u'abc'")\r
75 self.assertEqual(repr(u'ab\\c'), "u'ab\\\\c'")\r
76 self.assertEqual(repr(u'ab\\'), "u'ab\\\\'")\r
77 self.assertEqual(repr(u'\\c'), "u'\\\\c'")\r
78 self.assertEqual(repr(u'\\'), "u'\\\\'")\r
79 self.assertEqual(repr(u'\n'), "u'\\n'")\r
80 self.assertEqual(repr(u'\r'), "u'\\r'")\r
81 self.assertEqual(repr(u'\t'), "u'\\t'")\r
82 self.assertEqual(repr(u'\b'), "u'\\x08'")\r
83 self.assertEqual(repr(u"'\""), """u'\\'"'""")\r
84 self.assertEqual(repr(u"'\""), """u'\\'"'""")\r
85 self.assertEqual(repr(u"'"), '''u"'"''')\r
86 self.assertEqual(repr(u'"'), """u'"'""")\r
87 latin1repr = (\r
88 "u'\\x00\\x01\\x02\\x03\\x04\\x05\\x06\\x07\\x08\\t\\n\\x0b\\x0c\\r"\r
89 "\\x0e\\x0f\\x10\\x11\\x12\\x13\\x14\\x15\\x16\\x17\\x18\\x19\\x1a"\r
90 "\\x1b\\x1c\\x1d\\x1e\\x1f !\"#$%&\\'()*+,-./0123456789:;<=>?@ABCDEFGHI"\r
91 "JKLMNOPQRSTUVWXYZ[\\\\]^_`abcdefghijklmnopqrstuvwxyz{|}~\\x7f"\r
92 "\\x80\\x81\\x82\\x83\\x84\\x85\\x86\\x87\\x88\\x89\\x8a\\x8b\\x8c\\x8d"\r
93 "\\x8e\\x8f\\x90\\x91\\x92\\x93\\x94\\x95\\x96\\x97\\x98\\x99\\x9a\\x9b"\r
94 "\\x9c\\x9d\\x9e\\x9f\\xa0\\xa1\\xa2\\xa3\\xa4\\xa5\\xa6\\xa7\\xa8\\xa9"\r
95 "\\xaa\\xab\\xac\\xad\\xae\\xaf\\xb0\\xb1\\xb2\\xb3\\xb4\\xb5\\xb6\\xb7"\r
96 "\\xb8\\xb9\\xba\\xbb\\xbc\\xbd\\xbe\\xbf\\xc0\\xc1\\xc2\\xc3\\xc4\\xc5"\r
97 "\\xc6\\xc7\\xc8\\xc9\\xca\\xcb\\xcc\\xcd\\xce\\xcf\\xd0\\xd1\\xd2\\xd3"\r
98 "\\xd4\\xd5\\xd6\\xd7\\xd8\\xd9\\xda\\xdb\\xdc\\xdd\\xde\\xdf\\xe0\\xe1"\r
99 "\\xe2\\xe3\\xe4\\xe5\\xe6\\xe7\\xe8\\xe9\\xea\\xeb\\xec\\xed\\xee\\xef"\r
100 "\\xf0\\xf1\\xf2\\xf3\\xf4\\xf5\\xf6\\xf7\\xf8\\xf9\\xfa\\xfb\\xfc\\xfd"\r
101 "\\xfe\\xff'")\r
102 testrepr = repr(u''.join(map(unichr, xrange(256))))\r
103 self.assertEqual(testrepr, latin1repr)\r
104 # Test repr works on wide unicode escapes without overflow.\r
105 self.assertEqual(repr(u"\U00010000" * 39 + u"\uffff" * 4096),\r
106 repr(u"\U00010000" * 39 + u"\uffff" * 4096))\r
107\r
108\r
109 def test_count(self):\r
110 string_tests.CommonTest.test_count(self)\r
111 # check mixed argument types\r
112 self.checkequalnofix(3, 'aaa', 'count', u'a')\r
113 self.checkequalnofix(0, 'aaa', 'count', u'b')\r
114 self.checkequalnofix(3, u'aaa', 'count', 'a')\r
115 self.checkequalnofix(0, u'aaa', 'count', 'b')\r
116 self.checkequalnofix(0, u'aaa', 'count', 'b')\r
117 self.checkequalnofix(1, u'aaa', 'count', 'a', -1)\r
118 self.checkequalnofix(3, u'aaa', 'count', 'a', -10)\r
119 self.checkequalnofix(2, u'aaa', 'count', 'a', 0, -1)\r
120 self.checkequalnofix(0, u'aaa', 'count', 'a', 0, -10)\r
121\r
122 def test_find(self):\r
123 self.checkequalnofix(0, u'abcdefghiabc', 'find', u'abc')\r
124 self.checkequalnofix(9, u'abcdefghiabc', 'find', u'abc', 1)\r
125 self.checkequalnofix(-1, u'abcdefghiabc', 'find', u'def', 4)\r
126\r
127 self.assertRaises(TypeError, u'hello'.find)\r
128 self.assertRaises(TypeError, u'hello'.find, 42)\r
129\r
130 def test_rfind(self):\r
131 string_tests.CommonTest.test_rfind(self)\r
132 # check mixed argument types\r
133 self.checkequalnofix(9, 'abcdefghiabc', 'rfind', u'abc')\r
134 self.checkequalnofix(12, 'abcdefghiabc', 'rfind', u'')\r
135 self.checkequalnofix(12, u'abcdefghiabc', 'rfind', '')\r
136\r
137 def test_index(self):\r
138 string_tests.CommonTest.test_index(self)\r
139 # check mixed argument types\r
140 for (t1, t2) in ((str, unicode), (unicode, str)):\r
141 self.checkequalnofix(0, t1('abcdefghiabc'), 'index', t2(''))\r
142 self.checkequalnofix(3, t1('abcdefghiabc'), 'index', t2('def'))\r
143 self.checkequalnofix(0, t1('abcdefghiabc'), 'index', t2('abc'))\r
144 self.checkequalnofix(9, t1('abcdefghiabc'), 'index', t2('abc'), 1)\r
145 self.assertRaises(ValueError, t1('abcdefghiabc').index, t2('hib'))\r
146 self.assertRaises(ValueError, t1('abcdefghiab').index, t2('abc'), 1)\r
147 self.assertRaises(ValueError, t1('abcdefghi').index, t2('ghi'), 8)\r
148 self.assertRaises(ValueError, t1('abcdefghi').index, t2('ghi'), -1)\r
149\r
150 def test_rindex(self):\r
151 string_tests.CommonTest.test_rindex(self)\r
152 # check mixed argument types\r
153 for (t1, t2) in ((str, unicode), (unicode, str)):\r
154 self.checkequalnofix(12, t1('abcdefghiabc'), 'rindex', t2(''))\r
155 self.checkequalnofix(3, t1('abcdefghiabc'), 'rindex', t2('def'))\r
156 self.checkequalnofix(9, t1('abcdefghiabc'), 'rindex', t2('abc'))\r
157 self.checkequalnofix(0, t1('abcdefghiabc'), 'rindex', t2('abc'), 0, -1)\r
158\r
159 self.assertRaises(ValueError, t1('abcdefghiabc').rindex, t2('hib'))\r
160 self.assertRaises(ValueError, t1('defghiabc').rindex, t2('def'), 1)\r
161 self.assertRaises(ValueError, t1('defghiabc').rindex, t2('abc'), 0, -1)\r
162 self.assertRaises(ValueError, t1('abcdefghi').rindex, t2('ghi'), 0, 8)\r
163 self.assertRaises(ValueError, t1('abcdefghi').rindex, t2('ghi'), 0, -1)\r
164\r
165 def test_translate(self):\r
166 self.checkequalnofix(u'bbbc', u'abababc', 'translate', {ord('a'):None})\r
167 self.checkequalnofix(u'iiic', u'abababc', 'translate', {ord('a'):None, ord('b'):ord('i')})\r
168 self.checkequalnofix(u'iiix', u'abababc', 'translate', {ord('a'):None, ord('b'):ord('i'), ord('c'):u'x'})\r
169 self.checkequalnofix(u'<i><i><i>c', u'abababc', 'translate', {ord('a'):None, ord('b'):u'<i>'})\r
170 self.checkequalnofix(u'c', u'abababc', 'translate', {ord('a'):None, ord('b'):u''})\r
171 self.checkequalnofix(u'xyyx', u'xzx', 'translate', {ord('z'):u'yy'})\r
172\r
173 self.assertRaises(TypeError, u'hello'.translate)\r
174 self.assertRaises(TypeError, u'abababc'.translate, {ord('a'):''})\r
175\r
176 def test_split(self):\r
177 string_tests.CommonTest.test_split(self)\r
178\r
179 # Mixed arguments\r
180 self.checkequalnofix([u'a', u'b', u'c', u'd'], u'a//b//c//d', 'split', '//')\r
181 self.checkequalnofix([u'a', u'b', u'c', u'd'], 'a//b//c//d', 'split', u'//')\r
182 self.checkequalnofix([u'endcase ', u''], u'endcase test', 'split', 'test')\r
183\r
184 def test_join(self):\r
185 string_tests.MixinStrUnicodeUserStringTest.test_join(self)\r
186\r
187 # mixed arguments\r
188 self.checkequalnofix(u'a b c d', u' ', 'join', ['a', 'b', u'c', u'd'])\r
189 self.checkequalnofix(u'abcd', u'', 'join', (u'a', u'b', u'c', u'd'))\r
190 self.checkequalnofix(u'w x y z', u' ', 'join', string_tests.Sequence('wxyz'))\r
191 self.checkequalnofix(u'a b c d', ' ', 'join', [u'a', u'b', u'c', u'd'])\r
192 self.checkequalnofix(u'a b c d', ' ', 'join', ['a', 'b', u'c', u'd'])\r
193 self.checkequalnofix(u'abcd', '', 'join', (u'a', u'b', u'c', u'd'))\r
194 self.checkequalnofix(u'w x y z', ' ', 'join', string_tests.Sequence(u'wxyz'))\r
195\r
196 def test_strip(self):\r
197 string_tests.CommonTest.test_strip(self)\r
198 self.assertRaises(UnicodeError, u"hello".strip, "\xff")\r
199\r
200 def test_replace(self):\r
201 string_tests.CommonTest.test_replace(self)\r
202\r
203 # method call forwarded from str implementation because of unicode argument\r
204 self.checkequalnofix(u'one@two!three!', 'one!two!three!', 'replace', u'!', u'@', 1)\r
205 self.assertRaises(TypeError, 'replace'.replace, u"r", 42)\r
206\r
207 def test_comparison(self):\r
208 # Comparisons:\r
209 self.assertTrue(u'abc' == 'abc')\r
210 self.assertTrue('abc' == u'abc')\r
211 self.assertTrue(u'abc' == u'abc')\r
212 self.assertTrue(u'abcd' > 'abc')\r
213 self.assertTrue('abcd' > u'abc')\r
214 self.assertTrue(u'abcd' > u'abc')\r
215 self.assertTrue(u'abc' < 'abcd')\r
216 self.assertTrue('abc' < u'abcd')\r
217 self.assertTrue(u'abc' < u'abcd')\r
218\r
219 if 0:\r
220 # Move these tests to a Unicode collation module test...\r
221 # Testing UTF-16 code point order comparisons...\r
222\r
223 # No surrogates, no fixup required.\r
224 self.assertTrue(u'\u0061' < u'\u20ac')\r
225 # Non surrogate below surrogate value, no fixup required\r
226 self.assertTrue(u'\u0061' < u'\ud800\udc02')\r
227\r
228 # Non surrogate above surrogate value, fixup required\r
229 def test_lecmp(s, s2):\r
230 self.assertTrue(s < s2)\r
231\r
232 def test_fixup(s):\r
233 s2 = u'\ud800\udc01'\r
234 test_lecmp(s, s2)\r
235 s2 = u'\ud900\udc01'\r
236 test_lecmp(s, s2)\r
237 s2 = u'\uda00\udc01'\r
238 test_lecmp(s, s2)\r
239 s2 = u'\udb00\udc01'\r
240 test_lecmp(s, s2)\r
241 s2 = u'\ud800\udd01'\r
242 test_lecmp(s, s2)\r
243 s2 = u'\ud900\udd01'\r
244 test_lecmp(s, s2)\r
245 s2 = u'\uda00\udd01'\r
246 test_lecmp(s, s2)\r
247 s2 = u'\udb00\udd01'\r
248 test_lecmp(s, s2)\r
249 s2 = u'\ud800\ude01'\r
250 test_lecmp(s, s2)\r
251 s2 = u'\ud900\ude01'\r
252 test_lecmp(s, s2)\r
253 s2 = u'\uda00\ude01'\r
254 test_lecmp(s, s2)\r
255 s2 = u'\udb00\ude01'\r
256 test_lecmp(s, s2)\r
257 s2 = u'\ud800\udfff'\r
258 test_lecmp(s, s2)\r
259 s2 = u'\ud900\udfff'\r
260 test_lecmp(s, s2)\r
261 s2 = u'\uda00\udfff'\r
262 test_lecmp(s, s2)\r
263 s2 = u'\udb00\udfff'\r
264 test_lecmp(s, s2)\r
265\r
266 test_fixup(u'\ue000')\r
267 test_fixup(u'\uff61')\r
268\r
269 # Surrogates on both sides, no fixup required\r
270 self.assertTrue(u'\ud800\udc02' < u'\ud84d\udc56')\r
271\r
272 def test_islower(self):\r
273 string_tests.MixinStrUnicodeUserStringTest.test_islower(self)\r
274 self.checkequalnofix(False, u'\u1FFc', 'islower')\r
275\r
276 def test_isupper(self):\r
277 string_tests.MixinStrUnicodeUserStringTest.test_isupper(self)\r
278 if not sys.platform.startswith('java'):\r
279 self.checkequalnofix(False, u'\u1FFc', 'isupper')\r
280\r
281 def test_istitle(self):\r
282 string_tests.MixinStrUnicodeUserStringTest.test_title(self)\r
283 self.checkequalnofix(True, u'\u1FFc', 'istitle')\r
284 self.checkequalnofix(True, u'Greek \u1FFcitlecases ...', 'istitle')\r
285\r
286 def test_isspace(self):\r
287 string_tests.MixinStrUnicodeUserStringTest.test_isspace(self)\r
288 self.checkequalnofix(True, u'\u2000', 'isspace')\r
289 self.checkequalnofix(True, u'\u200a', 'isspace')\r
290 self.checkequalnofix(False, u'\u2014', 'isspace')\r
291\r
292 def test_isalpha(self):\r
293 string_tests.MixinStrUnicodeUserStringTest.test_isalpha(self)\r
294 self.checkequalnofix(True, u'\u1FFc', 'isalpha')\r
295\r
296 def test_isdecimal(self):\r
297 self.checkequalnofix(False, u'', 'isdecimal')\r
298 self.checkequalnofix(False, u'a', 'isdecimal')\r
299 self.checkequalnofix(True, u'0', 'isdecimal')\r
300 self.checkequalnofix(False, u'\u2460', 'isdecimal') # CIRCLED DIGIT ONE\r
301 self.checkequalnofix(False, u'\xbc', 'isdecimal') # VULGAR FRACTION ONE QUARTER\r
302 self.checkequalnofix(True, u'\u0660', 'isdecimal') # ARABIC-INDIC DIGIT ZERO\r
303 self.checkequalnofix(True, u'0123456789', 'isdecimal')\r
304 self.checkequalnofix(False, u'0123456789a', 'isdecimal')\r
305\r
306 self.checkraises(TypeError, 'abc', 'isdecimal', 42)\r
307\r
308 def test_isdigit(self):\r
309 string_tests.MixinStrUnicodeUserStringTest.test_isdigit(self)\r
310 self.checkequalnofix(True, u'\u2460', 'isdigit')\r
311 self.checkequalnofix(False, u'\xbc', 'isdigit')\r
312 self.checkequalnofix(True, u'\u0660', 'isdigit')\r
313\r
314 def test_isnumeric(self):\r
315 self.checkequalnofix(False, u'', 'isnumeric')\r
316 self.checkequalnofix(False, u'a', 'isnumeric')\r
317 self.checkequalnofix(True, u'0', 'isnumeric')\r
318 self.checkequalnofix(True, u'\u2460', 'isnumeric')\r
319 self.checkequalnofix(True, u'\xbc', 'isnumeric')\r
320 self.checkequalnofix(True, u'\u0660', 'isnumeric')\r
321 self.checkequalnofix(True, u'0123456789', 'isnumeric')\r
322 self.checkequalnofix(False, u'0123456789a', 'isnumeric')\r
323\r
324 self.assertRaises(TypeError, u"abc".isnumeric, 42)\r
325\r
326 def test_contains(self):\r
327 # Testing Unicode contains method\r
328 self.assertIn('a', u'abdb')\r
329 self.assertIn('a', u'bdab')\r
330 self.assertIn('a', u'bdaba')\r
331 self.assertIn('a', u'bdba')\r
332 self.assertIn('a', u'bdba')\r
333 self.assertIn(u'a', u'bdba')\r
334 self.assertNotIn(u'a', u'bdb')\r
335 self.assertNotIn(u'a', 'bdb')\r
336 self.assertIn(u'a', 'bdba')\r
337 self.assertIn(u'a', ('a',1,None))\r
338 self.assertIn(u'a', (1,None,'a'))\r
339 self.assertIn(u'a', (1,None,u'a'))\r
340 self.assertIn('a', ('a',1,None))\r
341 self.assertIn('a', (1,None,'a'))\r
342 self.assertIn('a', (1,None,u'a'))\r
343 self.assertNotIn('a', ('x',1,u'y'))\r
344 self.assertNotIn('a', ('x',1,None))\r
345 self.assertNotIn(u'abcd', u'abcxxxx')\r
346 self.assertIn(u'ab', u'abcd')\r
347 self.assertIn('ab', u'abc')\r
348 self.assertIn(u'ab', 'abc')\r
349 self.assertIn(u'ab', (1,None,u'ab'))\r
350 self.assertIn(u'', u'abc')\r
351 self.assertIn('', u'abc')\r
352\r
353 # If the following fails either\r
354 # the contains operator does not propagate UnicodeErrors or\r
355 # someone has changed the default encoding\r
356 self.assertRaises(UnicodeDecodeError, 'g\xe2teau'.__contains__, u'\xe2')\r
357 self.assertRaises(UnicodeDecodeError, u'g\xe2teau'.__contains__, '\xe2')\r
358\r
359 self.assertIn(u'', '')\r
360 self.assertIn('', u'')\r
361 self.assertIn(u'', u'')\r
362 self.assertIn(u'', 'abc')\r
363 self.assertIn('', u'abc')\r
364 self.assertIn(u'', u'abc')\r
365 self.assertNotIn(u'\0', 'abc')\r
366 self.assertNotIn('\0', u'abc')\r
367 self.assertNotIn(u'\0', u'abc')\r
368 self.assertIn(u'\0', '\0abc')\r
369 self.assertIn('\0', u'\0abc')\r
370 self.assertIn(u'\0', u'\0abc')\r
371 self.assertIn(u'\0', 'abc\0')\r
372 self.assertIn('\0', u'abc\0')\r
373 self.assertIn(u'\0', u'abc\0')\r
374 self.assertIn(u'a', '\0abc')\r
375 self.assertIn('a', u'\0abc')\r
376 self.assertIn(u'a', u'\0abc')\r
377 self.assertIn(u'asdf', 'asdf')\r
378 self.assertIn('asdf', u'asdf')\r
379 self.assertIn(u'asdf', u'asdf')\r
380 self.assertNotIn(u'asdf', 'asd')\r
381 self.assertNotIn('asdf', u'asd')\r
382 self.assertNotIn(u'asdf', u'asd')\r
383 self.assertNotIn(u'asdf', '')\r
384 self.assertNotIn('asdf', u'')\r
385 self.assertNotIn(u'asdf', u'')\r
386\r
387 self.assertRaises(TypeError, u"abc".__contains__)\r
388 self.assertRaises(TypeError, u"abc".__contains__, object())\r
389\r
390 def test_formatting(self):\r
391 string_tests.MixinStrUnicodeUserStringTest.test_formatting(self)\r
392 # Testing Unicode formatting strings...\r
393 self.assertEqual(u"%s, %s" % (u"abc", "abc"), u'abc, abc')\r
394 self.assertEqual(u"%s, %s, %i, %f, %5.2f" % (u"abc", "abc", 1, 2, 3), u'abc, abc, 1, 2.000000, 3.00')\r
395 self.assertEqual(u"%s, %s, %i, %f, %5.2f" % (u"abc", "abc", 1, -2, 3), u'abc, abc, 1, -2.000000, 3.00')\r
396 self.assertEqual(u"%s, %s, %i, %f, %5.2f" % (u"abc", "abc", -1, -2, 3.5), u'abc, abc, -1, -2.000000, 3.50')\r
397 self.assertEqual(u"%s, %s, %i, %f, %5.2f" % (u"abc", "abc", -1, -2, 3.57), u'abc, abc, -1, -2.000000, 3.57')\r
398 self.assertEqual(u"%s, %s, %i, %f, %5.2f" % (u"abc", "abc", -1, -2, 1003.57), u'abc, abc, -1, -2.000000, 1003.57')\r
399 if not sys.platform.startswith('java'):\r
400 self.assertEqual(u"%r, %r" % (u"abc", "abc"), u"u'abc', 'abc'")\r
401 self.assertEqual(u"%(x)s, %(y)s" % {'x':u"abc", 'y':"def"}, u'abc, def')\r
402 self.assertEqual(u"%(x)s, %(\xfc)s" % {'x':u"abc", u'\xfc':"def"}, u'abc, def')\r
403\r
404 self.assertEqual(u'%c' % 0x1234, u'\u1234')\r
405 self.assertRaises(OverflowError, u"%c".__mod__, (sys.maxunicode+1,))\r
406 self.assertRaises(ValueError, u"%.1\u1032f".__mod__, (1.0/3))\r
407\r
408 for num in range(0x00,0x80):\r
409 char = chr(num)\r
410 self.assertEqual(u"%c" % char, unicode(char))\r
411 self.assertEqual(u"%c" % num, unicode(char))\r
412 self.assertTrue(char == u"%c" % char)\r
413 self.assertTrue(char == u"%c" % num)\r
414 # Issue 7649\r
415 for num in range(0x80,0x100):\r
416 uchar = unichr(num)\r
417 self.assertEqual(uchar, u"%c" % num) # works only with ints\r
418 self.assertEqual(uchar, u"%c" % uchar) # and unicode chars\r
419 # the implicit decoding should fail for non-ascii chars\r
420 self.assertRaises(UnicodeDecodeError, u"%c".__mod__, chr(num))\r
421 self.assertRaises(UnicodeDecodeError, u"%s".__mod__, chr(num))\r
422\r
423 # formatting jobs delegated from the string implementation:\r
424 self.assertEqual('...%(foo)s...' % {'foo':u"abc"}, u'...abc...')\r
425 self.assertEqual('...%(foo)s...' % {'foo':"abc"}, '...abc...')\r
426 self.assertEqual('...%(foo)s...' % {u'foo':"abc"}, '...abc...')\r
427 self.assertEqual('...%(foo)s...' % {u'foo':u"abc"}, u'...abc...')\r
428 self.assertEqual('...%(foo)s...' % {u'foo':u"abc",'def':123}, u'...abc...')\r
429 self.assertEqual('...%(foo)s...' % {u'foo':u"abc",u'def':123}, u'...abc...')\r
430 self.assertEqual('...%s...%s...%s...%s...' % (1,2,3,u"abc"), u'...1...2...3...abc...')\r
431 self.assertEqual('...%%...%%s...%s...%s...%s...%s...' % (1,2,3,u"abc"), u'...%...%s...1...2...3...abc...')\r
432 self.assertEqual('...%s...' % u"abc", u'...abc...')\r
433 self.assertEqual('%*s' % (5,u'abc',), u' abc')\r
434 self.assertEqual('%*s' % (-5,u'abc',), u'abc ')\r
435 self.assertEqual('%*.*s' % (5,2,u'abc',), u' ab')\r
436 self.assertEqual('%*.*s' % (5,3,u'abc',), u' abc')\r
437 self.assertEqual('%i %*.*s' % (10, 5,3,u'abc',), u'10 abc')\r
438 self.assertEqual('%i%s %*.*s' % (10, 3, 5, 3, u'abc',), u'103 abc')\r
439 self.assertEqual('%c' % u'a', u'a')\r
440 class Wrapper:\r
441 def __str__(self):\r
442 return u'\u1234'\r
443 self.assertEqual('%s' % Wrapper(), u'\u1234')\r
444\r
445 def test_startswith_endswith_errors(self):\r
446 for meth in (u'foo'.startswith, u'foo'.endswith):\r
447 with self.assertRaises(UnicodeDecodeError):\r
448 meth('\xff')\r
449 with self.assertRaises(TypeError) as cm:\r
450 meth(['f'])\r
451 exc = str(cm.exception)\r
452 self.assertIn('unicode', exc)\r
453 self.assertIn('str', exc)\r
454 self.assertIn('tuple', exc)\r
455\r
456 @test_support.run_with_locale('LC_ALL', 'de_DE', 'fr_FR')\r
457 def test_format_float(self):\r
458 # should not format with a comma, but always with C locale\r
459 self.assertEqual(u'1.0', u'%.1f' % 1.0)\r
460\r
461 def test_constructor(self):\r
462 # unicode(obj) tests (this maps to PyObject_Unicode() at C level)\r
463\r
464 self.assertEqual(\r
465 unicode(u'unicode remains unicode'),\r
466 u'unicode remains unicode'\r
467 )\r
468\r
469 class UnicodeSubclass(unicode):\r
470 pass\r
471\r
472 self.assertEqual(\r
473 unicode(UnicodeSubclass('unicode subclass becomes unicode')),\r
474 u'unicode subclass becomes unicode'\r
475 )\r
476\r
477 self.assertEqual(\r
478 unicode('strings are converted to unicode'),\r
479 u'strings are converted to unicode'\r
480 )\r
481\r
482 class UnicodeCompat:\r
483 def __init__(self, x):\r
484 self.x = x\r
485 def __unicode__(self):\r
486 return self.x\r
487\r
488 self.assertEqual(\r
489 unicode(UnicodeCompat('__unicode__ compatible objects are recognized')),\r
490 u'__unicode__ compatible objects are recognized')\r
491\r
492 class StringCompat:\r
493 def __init__(self, x):\r
494 self.x = x\r
495 def __str__(self):\r
496 return self.x\r
497\r
498 self.assertEqual(\r
499 unicode(StringCompat('__str__ compatible objects are recognized')),\r
500 u'__str__ compatible objects are recognized'\r
501 )\r
502\r
503 # unicode(obj) is compatible to str():\r
504\r
505 o = StringCompat('unicode(obj) is compatible to str()')\r
506 self.assertEqual(unicode(o), u'unicode(obj) is compatible to str()')\r
507 self.assertEqual(str(o), 'unicode(obj) is compatible to str()')\r
508\r
509 # %-formatting and .__unicode__()\r
510 self.assertEqual(u'%s' %\r
511 UnicodeCompat(u"u'%s' % obj uses obj.__unicode__()"),\r
512 u"u'%s' % obj uses obj.__unicode__()")\r
513 self.assertEqual(u'%s' %\r
514 UnicodeCompat(u"u'%s' % obj falls back to obj.__str__()"),\r
515 u"u'%s' % obj falls back to obj.__str__()")\r
516\r
517 for obj in (123, 123.45, 123L):\r
518 self.assertEqual(unicode(obj), unicode(str(obj)))\r
519\r
520 # unicode(obj, encoding, error) tests (this maps to\r
521 # PyUnicode_FromEncodedObject() at C level)\r
522\r
523 if not sys.platform.startswith('java'):\r
524 self.assertRaises(\r
525 TypeError,\r
526 unicode,\r
527 u'decoding unicode is not supported',\r
528 'utf-8',\r
529 'strict'\r
530 )\r
531\r
532 self.assertEqual(\r
533 unicode('strings are decoded to unicode', 'utf-8', 'strict'),\r
534 u'strings are decoded to unicode'\r
535 )\r
536\r
537 if not sys.platform.startswith('java'):\r
538 with test_support.check_py3k_warnings():\r
539 buf = buffer('character buffers are decoded to unicode')\r
540 self.assertEqual(\r
541 unicode(\r
542 buf,\r
543 'utf-8',\r
544 'strict'\r
545 ),\r
546 u'character buffers are decoded to unicode'\r
547 )\r
548\r
549 self.assertRaises(TypeError, unicode, 42, 42, 42)\r
550\r
551 def test_codecs_utf7(self):\r
552 utfTests = [\r
553 (u'A\u2262\u0391.', 'A+ImIDkQ.'), # RFC2152 example\r
554 (u'Hi Mom -\u263a-!', 'Hi Mom -+Jjo--!'), # RFC2152 example\r
555 (u'\u65E5\u672C\u8A9E', '+ZeVnLIqe-'), # RFC2152 example\r
556 (u'Item 3 is \u00a31.', 'Item 3 is +AKM-1.'), # RFC2152 example\r
557 (u'+', '+-'),\r
558 (u'+-', '+--'),\r
559 (u'+?', '+-?'),\r
560 (u'\?', '+AFw?'),\r
561 (u'+?', '+-?'),\r
562 (ur'\\?', '+AFwAXA?'),\r
563 (ur'\\\?', '+AFwAXABc?'),\r
564 (ur'++--', '+-+---'),\r
565 (u'\U000abcde', '+2m/c3g-'), # surrogate pairs\r
566 (u'/', '/'),\r
567 ]\r
568\r
569 for (x, y) in utfTests:\r
570 self.assertEqual(x.encode('utf-7'), y)\r
571\r
572 # Unpaired surrogates not supported\r
573 self.assertRaises(UnicodeError, unicode, '+3ADYAA-', 'utf-7')\r
574\r
575 self.assertEqual(unicode('+3ADYAA-', 'utf-7', 'replace'), u'\ufffd\ufffd')\r
576\r
577 # Direct encoded characters\r
578 set_d = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789'(),-./:?"\r
579 # Optional direct characters\r
580 set_o = '!"#$%&*;<=>@[]^_`{|}'\r
581 for c in set_d:\r
582 self.assertEqual(c.encode('utf7'), c.encode('ascii'))\r
583 self.assertEqual(c.encode('ascii').decode('utf7'), unicode(c))\r
584 self.assertTrue(c == c.encode('ascii').decode('utf7'))\r
585 for c in set_o:\r
586 self.assertEqual(c.encode('ascii').decode('utf7'), unicode(c))\r
587 self.assertTrue(c == c.encode('ascii').decode('utf7'))\r
588\r
589 def test_codecs_utf8(self):\r
590 self.assertEqual(u''.encode('utf-8'), '')\r
591 self.assertEqual(u'\u20ac'.encode('utf-8'), '\xe2\x82\xac')\r
592 self.assertEqual(u'\ud800\udc02'.encode('utf-8'), '\xf0\x90\x80\x82')\r
593 self.assertEqual(u'\ud84d\udc56'.encode('utf-8'), '\xf0\xa3\x91\x96')\r
594 self.assertEqual(u'\ud800'.encode('utf-8'), '\xed\xa0\x80')\r
595 self.assertEqual(u'\udc00'.encode('utf-8'), '\xed\xb0\x80')\r
596 self.assertEqual(\r
597 (u'\ud800\udc02'*1000).encode('utf-8'),\r
598 '\xf0\x90\x80\x82'*1000\r
599 )\r
600 self.assertEqual(\r
601 u'\u6b63\u78ba\u306b\u8a00\u3046\u3068\u7ffb\u8a33\u306f'\r
602 u'\u3055\u308c\u3066\u3044\u307e\u305b\u3093\u3002\u4e00'\r
603 u'\u90e8\u306f\u30c9\u30a4\u30c4\u8a9e\u3067\u3059\u304c'\r
604 u'\u3001\u3042\u3068\u306f\u3067\u305f\u3089\u3081\u3067'\r
605 u'\u3059\u3002\u5b9f\u969b\u306b\u306f\u300cWenn ist das'\r
606 u' Nunstuck git und'.encode('utf-8'),\r
607 '\xe6\xad\xa3\xe7\xa2\xba\xe3\x81\xab\xe8\xa8\x80\xe3\x81'\r
608 '\x86\xe3\x81\xa8\xe7\xbf\xbb\xe8\xa8\xb3\xe3\x81\xaf\xe3'\r
609 '\x81\x95\xe3\x82\x8c\xe3\x81\xa6\xe3\x81\x84\xe3\x81\xbe'\r
610 '\xe3\x81\x9b\xe3\x82\x93\xe3\x80\x82\xe4\xb8\x80\xe9\x83'\r
611 '\xa8\xe3\x81\xaf\xe3\x83\x89\xe3\x82\xa4\xe3\x83\x84\xe8'\r
612 '\xaa\x9e\xe3\x81\xa7\xe3\x81\x99\xe3\x81\x8c\xe3\x80\x81'\r
613 '\xe3\x81\x82\xe3\x81\xa8\xe3\x81\xaf\xe3\x81\xa7\xe3\x81'\r
614 '\x9f\xe3\x82\x89\xe3\x82\x81\xe3\x81\xa7\xe3\x81\x99\xe3'\r
615 '\x80\x82\xe5\xae\x9f\xe9\x9a\x9b\xe3\x81\xab\xe3\x81\xaf'\r
616 '\xe3\x80\x8cWenn ist das Nunstuck git und'\r
617 )\r
618\r
619 # UTF-8 specific decoding tests\r
620 self.assertEqual(unicode('\xf0\xa3\x91\x96', 'utf-8'), u'\U00023456')\r
621 self.assertEqual(unicode('\xf0\x90\x80\x82', 'utf-8'), u'\U00010002')\r
622 self.assertEqual(unicode('\xe2\x82\xac', 'utf-8'), u'\u20ac')\r
623\r
624 # Other possible utf-8 test cases:\r
625 # * strict decoding testing for all of the\r
626 # UTF8_ERROR cases in PyUnicode_DecodeUTF8\r
627\r
628 def test_utf8_decode_valid_sequences(self):\r
629 sequences = [\r
630 # single byte\r
631 ('\x00', u'\x00'), ('a', u'a'), ('\x7f', u'\x7f'),\r
632 # 2 bytes\r
633 ('\xc2\x80', u'\x80'), ('\xdf\xbf', u'\u07ff'),\r
634 # 3 bytes\r
635 ('\xe0\xa0\x80', u'\u0800'), ('\xed\x9f\xbf', u'\ud7ff'),\r
636 ('\xee\x80\x80', u'\uE000'), ('\xef\xbf\xbf', u'\uffff'),\r
637 # 4 bytes\r
638 ('\xF0\x90\x80\x80', u'\U00010000'),\r
639 ('\xf4\x8f\xbf\xbf', u'\U0010FFFF')\r
640 ]\r
641 for seq, res in sequences:\r
642 self.assertEqual(seq.decode('utf-8'), res)\r
643\r
644 for ch in map(unichr, range(0, sys.maxunicode)):\r
645 self.assertEqual(ch, ch.encode('utf-8').decode('utf-8'))\r
646\r
647 def test_utf8_decode_invalid_sequences(self):\r
648 # continuation bytes in a sequence of 2, 3, or 4 bytes\r
649 continuation_bytes = map(chr, range(0x80, 0xC0))\r
650 # start bytes of a 2-byte sequence equivalent to codepoints < 0x7F\r
651 invalid_2B_seq_start_bytes = map(chr, range(0xC0, 0xC2))\r
652 # start bytes of a 4-byte sequence equivalent to codepoints > 0x10FFFF\r
653 invalid_4B_seq_start_bytes = map(chr, range(0xF5, 0xF8))\r
654 invalid_start_bytes = (\r
655 continuation_bytes + invalid_2B_seq_start_bytes +\r
656 invalid_4B_seq_start_bytes + map(chr, range(0xF7, 0x100))\r
657 )\r
658\r
659 for byte in invalid_start_bytes:\r
660 self.assertRaises(UnicodeDecodeError, byte.decode, 'utf-8')\r
661\r
662 for sb in invalid_2B_seq_start_bytes:\r
663 for cb in continuation_bytes:\r
664 self.assertRaises(UnicodeDecodeError, (sb+cb).decode, 'utf-8')\r
665\r
666 for sb in invalid_4B_seq_start_bytes:\r
667 for cb1 in continuation_bytes[:3]:\r
668 for cb3 in continuation_bytes[:3]:\r
669 self.assertRaises(UnicodeDecodeError,\r
670 (sb+cb1+'\x80'+cb3).decode, 'utf-8')\r
671\r
672 for cb in map(chr, range(0x80, 0xA0)):\r
673 self.assertRaises(UnicodeDecodeError,\r
674 ('\xE0'+cb+'\x80').decode, 'utf-8')\r
675 self.assertRaises(UnicodeDecodeError,\r
676 ('\xE0'+cb+'\xBF').decode, 'utf-8')\r
677 # XXX: surrogates shouldn't be valid UTF-8!\r
678 # see http://www.unicode.org/versions/Unicode5.2.0/ch03.pdf\r
679 # (table 3-7) and http://www.rfc-editor.org/rfc/rfc3629.txt\r
680 #for cb in map(chr, range(0xA0, 0xC0)):\r
681 #self.assertRaises(UnicodeDecodeError,\r
682 #('\xED'+cb+'\x80').decode, 'utf-8')\r
683 #self.assertRaises(UnicodeDecodeError,\r
684 #('\xED'+cb+'\xBF').decode, 'utf-8')\r
685 # but since they are valid on Python 2 add a test for that:\r
686 for cb, surrogate in zip(map(chr, range(0xA0, 0xC0)),\r
687 map(unichr, range(0xd800, 0xe000, 64))):\r
688 encoded = '\xED'+cb+'\x80'\r
689 self.assertEqual(encoded.decode('utf-8'), surrogate)\r
690 self.assertEqual(surrogate.encode('utf-8'), encoded)\r
691\r
692 for cb in map(chr, range(0x80, 0x90)):\r
693 self.assertRaises(UnicodeDecodeError,\r
694 ('\xF0'+cb+'\x80\x80').decode, 'utf-8')\r
695 self.assertRaises(UnicodeDecodeError,\r
696 ('\xF0'+cb+'\xBF\xBF').decode, 'utf-8')\r
697 for cb in map(chr, range(0x90, 0xC0)):\r
698 self.assertRaises(UnicodeDecodeError,\r
699 ('\xF4'+cb+'\x80\x80').decode, 'utf-8')\r
700 self.assertRaises(UnicodeDecodeError,\r
701 ('\xF4'+cb+'\xBF\xBF').decode, 'utf-8')\r
702\r
703 def test_issue8271(self):\r
704 # Issue #8271: during the decoding of an invalid UTF-8 byte sequence,\r
705 # only the start byte and the continuation byte(s) are now considered\r
706 # invalid, instead of the number of bytes specified by the start byte.\r
707 # See http://www.unicode.org/versions/Unicode5.2.0/ch03.pdf (page 95,\r
708 # table 3-8, Row 2) for more information about the algorithm used.\r
709 FFFD = u'\ufffd'\r
710 sequences = [\r
711 # invalid start bytes\r
712 ('\x80', FFFD), # continuation byte\r
713 ('\x80\x80', FFFD*2), # 2 continuation bytes\r
714 ('\xc0', FFFD),\r
715 ('\xc0\xc0', FFFD*2),\r
716 ('\xc1', FFFD),\r
717 ('\xc1\xc0', FFFD*2),\r
718 ('\xc0\xc1', FFFD*2),\r
719 # with start byte of a 2-byte sequence\r
720 ('\xc2', FFFD), # only the start byte\r
721 ('\xc2\xc2', FFFD*2), # 2 start bytes\r
722 ('\xc2\xc2\xc2', FFFD*3), # 2 start bytes\r
723 ('\xc2\x41', FFFD+'A'), # invalid continuation byte\r
724 # with start byte of a 3-byte sequence\r
725 ('\xe1', FFFD), # only the start byte\r
726 ('\xe1\xe1', FFFD*2), # 2 start bytes\r
727 ('\xe1\xe1\xe1', FFFD*3), # 3 start bytes\r
728 ('\xe1\xe1\xe1\xe1', FFFD*4), # 4 start bytes\r
729 ('\xe1\x80', FFFD), # only 1 continuation byte\r
730 ('\xe1\x41', FFFD+'A'), # invalid continuation byte\r
731 ('\xe1\x41\x80', FFFD+'A'+FFFD), # invalid cb followed by valid cb\r
732 ('\xe1\x41\x41', FFFD+'AA'), # 2 invalid continuation bytes\r
733 ('\xe1\x80\x41', FFFD+'A'), # only 1 valid continuation byte\r
734 ('\xe1\x80\xe1\x41', FFFD*2+'A'), # 1 valid and the other invalid\r
735 ('\xe1\x41\xe1\x80', FFFD+'A'+FFFD), # 1 invalid and the other valid\r
736 # with start byte of a 4-byte sequence\r
737 ('\xf1', FFFD), # only the start byte\r
738 ('\xf1\xf1', FFFD*2), # 2 start bytes\r
739 ('\xf1\xf1\xf1', FFFD*3), # 3 start bytes\r
740 ('\xf1\xf1\xf1\xf1', FFFD*4), # 4 start bytes\r
741 ('\xf1\xf1\xf1\xf1\xf1', FFFD*5), # 5 start bytes\r
742 ('\xf1\x80', FFFD), # only 1 continuation bytes\r
743 ('\xf1\x80\x80', FFFD), # only 2 continuation bytes\r
744 ('\xf1\x80\x41', FFFD+'A'), # 1 valid cb and 1 invalid\r
745 ('\xf1\x80\x41\x41', FFFD+'AA'), # 1 valid cb and 1 invalid\r
746 ('\xf1\x80\x80\x41', FFFD+'A'), # 2 valid cb and 1 invalid\r
747 ('\xf1\x41\x80', FFFD+'A'+FFFD), # 1 invalid cv and 1 valid\r
748 ('\xf1\x41\x80\x80', FFFD+'A'+FFFD*2), # 1 invalid cb and 2 invalid\r
749 ('\xf1\x41\x80\x41', FFFD+'A'+FFFD+'A'), # 2 invalid cb and 1 invalid\r
750 ('\xf1\x41\x41\x80', FFFD+'AA'+FFFD), # 1 valid cb and 1 invalid\r
751 ('\xf1\x41\xf1\x80', FFFD+'A'+FFFD),\r
752 ('\xf1\x41\x80\xf1', FFFD+'A'+FFFD*2),\r
753 ('\xf1\xf1\x80\x41', FFFD*2+'A'),\r
754 ('\xf1\x41\xf1\xf1', FFFD+'A'+FFFD*2),\r
755 # with invalid start byte of a 4-byte sequence (rfc2279)\r
756 ('\xf5', FFFD), # only the start byte\r
757 ('\xf5\xf5', FFFD*2), # 2 start bytes\r
758 ('\xf5\x80', FFFD*2), # only 1 continuation byte\r
759 ('\xf5\x80\x80', FFFD*3), # only 2 continuation byte\r
760 ('\xf5\x80\x80\x80', FFFD*4), # 3 continuation bytes\r
761 ('\xf5\x80\x41', FFFD*2+'A'), # 1 valid cb and 1 invalid\r
762 ('\xf5\x80\x41\xf5', FFFD*2+'A'+FFFD),\r
763 ('\xf5\x41\x80\x80\x41', FFFD+'A'+FFFD*2+'A'),\r
764 # with invalid start byte of a 5-byte sequence (rfc2279)\r
765 ('\xf8', FFFD), # only the start byte\r
766 ('\xf8\xf8', FFFD*2), # 2 start bytes\r
767 ('\xf8\x80', FFFD*2), # only one continuation byte\r
768 ('\xf8\x80\x41', FFFD*2 + 'A'), # 1 valid cb and 1 invalid\r
769 ('\xf8\x80\x80\x80\x80', FFFD*5), # invalid 5 bytes seq with 5 bytes\r
770 # with invalid start byte of a 6-byte sequence (rfc2279)\r
771 ('\xfc', FFFD), # only the start byte\r
772 ('\xfc\xfc', FFFD*2), # 2 start bytes\r
773 ('\xfc\x80\x80', FFFD*3), # only 2 continuation bytes\r
774 ('\xfc\x80\x80\x80\x80\x80', FFFD*6), # 6 continuation bytes\r
775 # invalid start byte\r
776 ('\xfe', FFFD),\r
777 ('\xfe\x80\x80', FFFD*3),\r
778 # other sequences\r
779 ('\xf1\x80\x41\x42\x43', u'\ufffd\x41\x42\x43'),\r
780 ('\xf1\x80\xff\x42\x43', u'\ufffd\ufffd\x42\x43'),\r
781 ('\xf1\x80\xc2\x81\x43', u'\ufffd\x81\x43'),\r
782 ('\x61\xF1\x80\x80\xE1\x80\xC2\x62\x80\x63\x80\xBF\x64',\r
783 u'\x61\uFFFD\uFFFD\uFFFD\x62\uFFFD\x63\uFFFD\uFFFD\x64'),\r
784 ]\r
785 for n, (seq, res) in enumerate(sequences):\r
786 self.assertRaises(UnicodeDecodeError, seq.decode, 'utf-8', 'strict')\r
787 self.assertEqual(seq.decode('utf-8', 'replace'), res)\r
788 self.assertEqual((seq+'b').decode('utf-8', 'replace'), res+'b')\r
789 self.assertEqual(seq.decode('utf-8', 'ignore'),\r
790 res.replace(u'\uFFFD', ''))\r
791\r
792 def test_codecs_idna(self):\r
793 # Test whether trailing dot is preserved\r
794 self.assertEqual(u"www.python.org.".encode("idna"), "www.python.org.")\r
795\r
796 def test_codecs_errors(self):\r
797 # Error handling (encoding)\r
798 self.assertRaises(UnicodeError, u'Andr\202 x'.encode, 'ascii')\r
799 self.assertRaises(UnicodeError, u'Andr\202 x'.encode, 'ascii','strict')\r
800 self.assertEqual(u'Andr\202 x'.encode('ascii','ignore'), "Andr x")\r
801 self.assertEqual(u'Andr\202 x'.encode('ascii','replace'), "Andr? x")\r
802 self.assertEqual(u'Andr\202 x'.encode('ascii', 'replace'),\r
803 u'Andr\202 x'.encode('ascii', errors='replace'))\r
804 self.assertEqual(u'Andr\202 x'.encode('ascii', 'ignore'),\r
805 u'Andr\202 x'.encode(encoding='ascii', errors='ignore'))\r
806\r
807 # Error handling (decoding)\r
808 self.assertRaises(UnicodeError, unicode, 'Andr\202 x', 'ascii')\r
809 self.assertRaises(UnicodeError, unicode, 'Andr\202 x', 'ascii','strict')\r
810 self.assertEqual(unicode('Andr\202 x','ascii','ignore'), u"Andr x")\r
811 self.assertEqual(unicode('Andr\202 x','ascii','replace'), u'Andr\uFFFD x')\r
812 self.assertEqual(u'abcde'.decode('ascii', 'ignore'),\r
813 u'abcde'.decode('ascii', errors='ignore'))\r
814 self.assertEqual(u'abcde'.decode('ascii', 'replace'),\r
815 u'abcde'.decode(encoding='ascii', errors='replace'))\r
816\r
817 # Error handling (unknown character names)\r
818 self.assertEqual("\\N{foo}xx".decode("unicode-escape", "ignore"), u"xx")\r
819\r
820 # Error handling (truncated escape sequence)\r
821 self.assertRaises(UnicodeError, "\\".decode, "unicode-escape")\r
822\r
823 self.assertRaises(TypeError, "hello".decode, "test.unicode1")\r
824 self.assertRaises(TypeError, unicode, "hello", "test.unicode2")\r
825 self.assertRaises(TypeError, u"hello".encode, "test.unicode1")\r
826 self.assertRaises(TypeError, u"hello".encode, "test.unicode2")\r
827 # executes PyUnicode_Encode()\r
828 import imp\r
829 self.assertRaises(\r
830 ImportError,\r
831 imp.find_module,\r
832 "non-existing module",\r
833 [u"non-existing dir"]\r
834 )\r
835\r
836 # Error handling (wrong arguments)\r
837 self.assertRaises(TypeError, u"hello".encode, 42, 42, 42)\r
838\r
839 # Error handling (PyUnicode_EncodeDecimal())\r
840 self.assertRaises(UnicodeError, int, u"\u0200")\r
841\r
842 def test_codecs(self):\r
843 # Encoding\r
844 self.assertEqual(u'hello'.encode('ascii'), 'hello')\r
845 self.assertEqual(u'hello'.encode('utf-7'), 'hello')\r
846 self.assertEqual(u'hello'.encode('utf-8'), 'hello')\r
847 self.assertEqual(u'hello'.encode('utf8'), 'hello')\r
848 self.assertEqual(u'hello'.encode('utf-16-le'), 'h\000e\000l\000l\000o\000')\r
849 self.assertEqual(u'hello'.encode('utf-16-be'), '\000h\000e\000l\000l\000o')\r
850 self.assertEqual(u'hello'.encode('latin-1'), 'hello')\r
851\r
852 # Roundtrip safety for BMP (just the first 1024 chars)\r
853 for c in xrange(1024):\r
854 u = unichr(c)\r
855 for encoding in ('utf-7', 'utf-8', 'utf-16', 'utf-16-le',\r
856 'utf-16-be', 'raw_unicode_escape',\r
857 'unicode_escape', 'unicode_internal'):\r
858 self.assertEqual(unicode(u.encode(encoding),encoding), u)\r
859\r
860 # Roundtrip safety for BMP (just the first 256 chars)\r
861 for c in xrange(256):\r
862 u = unichr(c)\r
863 for encoding in ('latin-1',):\r
864 self.assertEqual(unicode(u.encode(encoding),encoding), u)\r
865\r
866 # Roundtrip safety for BMP (just the first 128 chars)\r
867 for c in xrange(128):\r
868 u = unichr(c)\r
869 for encoding in ('ascii',):\r
870 self.assertEqual(unicode(u.encode(encoding),encoding), u)\r
871\r
872 # Roundtrip safety for non-BMP (just a few chars)\r
873 u = u'\U00010001\U00020002\U00030003\U00040004\U00050005'\r
874 for encoding in ('utf-8', 'utf-16', 'utf-16-le', 'utf-16-be',\r
875 #'raw_unicode_escape',\r
876 'unicode_escape', 'unicode_internal'):\r
877 self.assertEqual(unicode(u.encode(encoding),encoding), u)\r
878\r
879 # UTF-8 must be roundtrip safe for all UCS-2 code points\r
880 # This excludes surrogates: in the full range, there would be\r
881 # a surrogate pair (\udbff\udc00), which gets converted back\r
882 # to a non-BMP character (\U0010fc00)\r
883 u = u''.join(map(unichr, range(0,0xd800)+range(0xe000,0x10000)))\r
884 for encoding in ('utf-8',):\r
885 self.assertEqual(unicode(u.encode(encoding),encoding), u)\r
886\r
887 def test_codecs_charmap(self):\r
888 # 0-127\r
889 s = ''.join(map(chr, xrange(128)))\r
890 for encoding in (\r
891 'cp037', 'cp1026',\r
892 'cp437', 'cp500', 'cp720', 'cp737', 'cp775', 'cp850',\r
893 'cp852', 'cp855', 'cp858', 'cp860', 'cp861', 'cp862',\r
894 'cp863', 'cp865', 'cp866',\r
895 'iso8859_10', 'iso8859_13', 'iso8859_14', 'iso8859_15',\r
896 'iso8859_2', 'iso8859_3', 'iso8859_4', 'iso8859_5', 'iso8859_6',\r
897 'iso8859_7', 'iso8859_9', 'koi8_r', 'latin_1',\r
898 'mac_cyrillic', 'mac_latin2',\r
899\r
900 'cp1250', 'cp1251', 'cp1252', 'cp1253', 'cp1254', 'cp1255',\r
901 'cp1256', 'cp1257', 'cp1258',\r
902 'cp856', 'cp857', 'cp864', 'cp869', 'cp874',\r
903\r
904 'mac_greek', 'mac_iceland','mac_roman', 'mac_turkish',\r
905 'cp1006', 'iso8859_8',\r
906\r
907 ### These have undefined mappings:\r
908 #'cp424',\r
909\r
910 ### These fail the round-trip:\r
911 #'cp875'\r
912\r
913 ):\r
914 self.assertEqual(unicode(s, encoding).encode(encoding), s)\r
915\r
916 # 128-255\r
917 s = ''.join(map(chr, xrange(128, 256)))\r
918 for encoding in (\r
919 'cp037', 'cp1026',\r
920 'cp437', 'cp500', 'cp720', 'cp737', 'cp775', 'cp850',\r
921 'cp852', 'cp855', 'cp858', 'cp860', 'cp861', 'cp862',\r
922 'cp863', 'cp865', 'cp866',\r
923 'iso8859_10', 'iso8859_13', 'iso8859_14', 'iso8859_15',\r
924 'iso8859_2', 'iso8859_4', 'iso8859_5',\r
925 'iso8859_9', 'koi8_r', 'latin_1',\r
926 'mac_cyrillic', 'mac_latin2',\r
927\r
928 ### These have undefined mappings:\r
929 #'cp1250', 'cp1251', 'cp1252', 'cp1253', 'cp1254', 'cp1255',\r
930 #'cp1256', 'cp1257', 'cp1258',\r
931 #'cp424', 'cp856', 'cp857', 'cp864', 'cp869', 'cp874',\r
932 #'iso8859_3', 'iso8859_6', 'iso8859_7',\r
933 #'mac_greek', 'mac_iceland','mac_roman', 'mac_turkish',\r
934\r
935 ### These fail the round-trip:\r
936 #'cp1006', 'cp875', 'iso8859_8',\r
937\r
938 ):\r
939 self.assertEqual(unicode(s, encoding).encode(encoding), s)\r
940\r
941 def test_concatenation(self):\r
942 self.assertEqual((u"abc" u"def"), u"abcdef")\r
943 self.assertEqual(("abc" u"def"), u"abcdef")\r
944 self.assertEqual((u"abc" "def"), u"abcdef")\r
945 self.assertEqual((u"abc" u"def" "ghi"), u"abcdefghi")\r
946 self.assertEqual(("abc" "def" u"ghi"), u"abcdefghi")\r
947\r
948 def test_printing(self):\r
949 class BitBucket:\r
950 def write(self, text):\r
951 pass\r
952\r
953 out = BitBucket()\r
954 print >>out, u'abc'\r
955 print >>out, u'abc', u'def'\r
956 print >>out, u'abc', 'def'\r
957 print >>out, 'abc', u'def'\r
958 print >>out, u'abc\n'\r
959 print >>out, u'abc\n',\r
960 print >>out, u'abc\n',\r
961 print >>out, u'def\n'\r
962 print >>out, u'def\n'\r
963\r
964 def test_ucs4(self):\r
965 x = u'\U00100000'\r
966 y = x.encode("raw-unicode-escape").decode("raw-unicode-escape")\r
967 self.assertEqual(x, y)\r
968\r
969 y = r'\U00100000'\r
970 x = y.decode("raw-unicode-escape").encode("raw-unicode-escape")\r
971 self.assertEqual(x, y)\r
972 y = r'\U00010000'\r
973 x = y.decode("raw-unicode-escape").encode("raw-unicode-escape")\r
974 self.assertEqual(x, y)\r
975\r
976 try:\r
977 '\U11111111'.decode("raw-unicode-escape")\r
978 except UnicodeDecodeError as e:\r
979 self.assertEqual(e.start, 0)\r
980 self.assertEqual(e.end, 10)\r
981 else:\r
982 self.fail("Should have raised UnicodeDecodeError")\r
983\r
984 def test_conversion(self):\r
985 # Make sure __unicode__() works properly\r
986 class Foo0:\r
987 def __str__(self):\r
988 return "foo"\r
989\r
990 class Foo1:\r
991 def __unicode__(self):\r
992 return u"foo"\r
993\r
994 class Foo2(object):\r
995 def __unicode__(self):\r
996 return u"foo"\r
997\r
998 class Foo3(object):\r
999 def __unicode__(self):\r
1000 return "foo"\r
1001\r
1002 class Foo4(str):\r
1003 def __unicode__(self):\r
1004 return "foo"\r
1005\r
1006 class Foo5(unicode):\r
1007 def __unicode__(self):\r
1008 return "foo"\r
1009\r
1010 class Foo6(str):\r
1011 def __str__(self):\r
1012 return "foos"\r
1013\r
1014 def __unicode__(self):\r
1015 return u"foou"\r
1016\r
1017 class Foo7(unicode):\r
1018 def __str__(self):\r
1019 return "foos"\r
1020 def __unicode__(self):\r
1021 return u"foou"\r
1022\r
1023 class Foo8(unicode):\r
1024 def __new__(cls, content=""):\r
1025 return unicode.__new__(cls, 2*content)\r
1026 def __unicode__(self):\r
1027 return self\r
1028\r
1029 class Foo9(unicode):\r
1030 def __str__(self):\r
1031 return "string"\r
1032 def __unicode__(self):\r
1033 return "not unicode"\r
1034\r
1035 self.assertEqual(unicode(Foo0()), u"foo")\r
1036 self.assertEqual(unicode(Foo1()), u"foo")\r
1037 self.assertEqual(unicode(Foo2()), u"foo")\r
1038 self.assertEqual(unicode(Foo3()), u"foo")\r
1039 self.assertEqual(unicode(Foo4("bar")), u"foo")\r
1040 self.assertEqual(unicode(Foo5("bar")), u"foo")\r
1041 self.assertEqual(unicode(Foo6("bar")), u"foou")\r
1042 self.assertEqual(unicode(Foo7("bar")), u"foou")\r
1043 self.assertEqual(unicode(Foo8("foo")), u"foofoo")\r
1044 self.assertEqual(str(Foo9("foo")), "string")\r
1045 self.assertEqual(unicode(Foo9("foo")), u"not unicode")\r
1046\r
1047 def test_unicode_repr(self):\r
1048 class s1:\r
1049 def __repr__(self):\r
1050 return '\\n'\r
1051\r
1052 class s2:\r
1053 def __repr__(self):\r
1054 return u'\\n'\r
1055\r
1056 self.assertEqual(repr(s1()), '\\n')\r
1057 self.assertEqual(repr(s2()), '\\n')\r
1058\r
1059 def test_expandtabs_overflows_gracefully(self):\r
1060 # This test only affects 32-bit platforms because expandtabs can only take\r
1061 # an int as the max value, not a 64-bit C long. If expandtabs is changed\r
1062 # to take a 64-bit long, this test should apply to all platforms.\r
1063 if sys.maxint > (1 << 32) or struct.calcsize('P') != 4:\r
1064 return\r
1065 self.assertRaises(OverflowError, u't\tt\t'.expandtabs, sys.maxint)\r
1066\r
1067 def test__format__(self):\r
1068 def test(value, format, expected):\r
1069 # test both with and without the trailing 's'\r
1070 self.assertEqual(value.__format__(format), expected)\r
1071 self.assertEqual(value.__format__(format + u's'), expected)\r
1072\r
1073 test(u'', u'', u'')\r
1074 test(u'abc', u'', u'abc')\r
1075 test(u'abc', u'.3', u'abc')\r
1076 test(u'ab', u'.3', u'ab')\r
1077 test(u'abcdef', u'.3', u'abc')\r
1078 test(u'abcdef', u'.0', u'')\r
1079 test(u'abc', u'3.3', u'abc')\r
1080 test(u'abc', u'2.3', u'abc')\r
1081 test(u'abc', u'2.2', u'ab')\r
1082 test(u'abc', u'3.2', u'ab ')\r
1083 test(u'result', u'x<0', u'result')\r
1084 test(u'result', u'x<5', u'result')\r
1085 test(u'result', u'x<6', u'result')\r
1086 test(u'result', u'x<7', u'resultx')\r
1087 test(u'result', u'x<8', u'resultxx')\r
1088 test(u'result', u' <7', u'result ')\r
1089 test(u'result', u'<7', u'result ')\r
1090 test(u'result', u'>7', u' result')\r
1091 test(u'result', u'>8', u' result')\r
1092 test(u'result', u'^8', u' result ')\r
1093 test(u'result', u'^9', u' result ')\r
1094 test(u'result', u'^10', u' result ')\r
1095 test(u'a', u'10000', u'a' + u' ' * 9999)\r
1096 test(u'', u'10000', u' ' * 10000)\r
1097 test(u'', u'10000000', u' ' * 10000000)\r
1098\r
1099 # test mixing unicode and str\r
1100 self.assertEqual(u'abc'.__format__('s'), u'abc')\r
1101 self.assertEqual(u'abc'.__format__('->10s'), u'-------abc')\r
1102\r
1103 def test_format(self):\r
1104 self.assertEqual(u''.format(), u'')\r
1105 self.assertEqual(u'a'.format(), u'a')\r
1106 self.assertEqual(u'ab'.format(), u'ab')\r
1107 self.assertEqual(u'a{{'.format(), u'a{')\r
1108 self.assertEqual(u'a}}'.format(), u'a}')\r
1109 self.assertEqual(u'{{b'.format(), u'{b')\r
1110 self.assertEqual(u'}}b'.format(), u'}b')\r
1111 self.assertEqual(u'a{{b'.format(), u'a{b')\r
1112\r
1113 # examples from the PEP:\r
1114 import datetime\r
1115 self.assertEqual(u"My name is {0}".format(u'Fred'), u"My name is Fred")\r
1116 self.assertEqual(u"My name is {0[name]}".format(dict(name=u'Fred')),\r
1117 u"My name is Fred")\r
1118 self.assertEqual(u"My name is {0} :-{{}}".format(u'Fred'),\r
1119 u"My name is Fred :-{}")\r
1120\r
1121 # datetime.__format__ doesn't work with unicode\r
1122 #d = datetime.date(2007, 8, 18)\r
1123 #self.assertEqual("The year is {0.year}".format(d),\r
1124 # "The year is 2007")\r
1125\r
1126 # classes we'll use for testing\r
1127 class C:\r
1128 def __init__(self, x=100):\r
1129 self._x = x\r
1130 def __format__(self, spec):\r
1131 return spec\r
1132\r
1133 class D:\r
1134 def __init__(self, x):\r
1135 self.x = x\r
1136 def __format__(self, spec):\r
1137 return str(self.x)\r
1138\r
1139 # class with __str__, but no __format__\r
1140 class E:\r
1141 def __init__(self, x):\r
1142 self.x = x\r
1143 def __str__(self):\r
1144 return u'E(' + self.x + u')'\r
1145\r
1146 # class with __repr__, but no __format__ or __str__\r
1147 class F:\r
1148 def __init__(self, x):\r
1149 self.x = x\r
1150 def __repr__(self):\r
1151 return u'F(' + self.x + u')'\r
1152\r
1153 # class with __format__ that forwards to string, for some format_spec's\r
1154 class G:\r
1155 def __init__(self, x):\r
1156 self.x = x\r
1157 def __str__(self):\r
1158 return u"string is " + self.x\r
1159 def __format__(self, format_spec):\r
1160 if format_spec == 'd':\r
1161 return u'G(' + self.x + u')'\r
1162 return object.__format__(self, format_spec)\r
1163\r
1164 # class that returns a bad type from __format__\r
1165 class H:\r
1166 def __format__(self, format_spec):\r
1167 return 1.0\r
1168\r
1169 class I(datetime.date):\r
1170 def __format__(self, format_spec):\r
1171 return self.strftime(format_spec)\r
1172\r
1173 class J(int):\r
1174 def __format__(self, format_spec):\r
1175 return int.__format__(self * 2, format_spec)\r
1176\r
1177\r
1178 self.assertEqual(u''.format(), u'')\r
1179 self.assertEqual(u'abc'.format(), u'abc')\r
1180 self.assertEqual(u'{0}'.format(u'abc'), u'abc')\r
1181 self.assertEqual(u'{0:}'.format(u'abc'), u'abc')\r
1182 self.assertEqual(u'X{0}'.format(u'abc'), u'Xabc')\r
1183 self.assertEqual(u'{0}X'.format(u'abc'), u'abcX')\r
1184 self.assertEqual(u'X{0}Y'.format(u'abc'), u'XabcY')\r
1185 self.assertEqual(u'{1}'.format(1, u'abc'), u'abc')\r
1186 self.assertEqual(u'X{1}'.format(1, u'abc'), u'Xabc')\r
1187 self.assertEqual(u'{1}X'.format(1, u'abc'), u'abcX')\r
1188 self.assertEqual(u'X{1}Y'.format(1, u'abc'), u'XabcY')\r
1189 self.assertEqual(u'{0}'.format(-15), u'-15')\r
1190 self.assertEqual(u'{0}{1}'.format(-15, u'abc'), u'-15abc')\r
1191 self.assertEqual(u'{0}X{1}'.format(-15, u'abc'), u'-15Xabc')\r
1192 self.assertEqual(u'{{'.format(), u'{')\r
1193 self.assertEqual(u'}}'.format(), u'}')\r
1194 self.assertEqual(u'{{}}'.format(), u'{}')\r
1195 self.assertEqual(u'{{x}}'.format(), u'{x}')\r
1196 self.assertEqual(u'{{{0}}}'.format(123), u'{123}')\r
1197 self.assertEqual(u'{{{{0}}}}'.format(), u'{{0}}')\r
1198 self.assertEqual(u'}}{{'.format(), u'}{')\r
1199 self.assertEqual(u'}}x{{'.format(), u'}x{')\r
1200\r
1201 # weird field names\r
1202 self.assertEqual(u"{0[foo-bar]}".format({u'foo-bar':u'baz'}), u'baz')\r
1203 self.assertEqual(u"{0[foo bar]}".format({u'foo bar':u'baz'}), u'baz')\r
1204 self.assertEqual(u"{0[ ]}".format({u' ':3}), u'3')\r
1205\r
1206 self.assertEqual(u'{foo._x}'.format(foo=C(20)), u'20')\r
1207 self.assertEqual(u'{1}{0}'.format(D(10), D(20)), u'2010')\r
1208 self.assertEqual(u'{0._x.x}'.format(C(D(u'abc'))), u'abc')\r
1209 self.assertEqual(u'{0[0]}'.format([u'abc', u'def']), u'abc')\r
1210 self.assertEqual(u'{0[1]}'.format([u'abc', u'def']), u'def')\r
1211 self.assertEqual(u'{0[1][0]}'.format([u'abc', [u'def']]), u'def')\r
1212 self.assertEqual(u'{0[1][0].x}'.format(['abc', [D(u'def')]]), u'def')\r
1213\r
1214 # strings\r
1215 self.assertEqual(u'{0:.3s}'.format(u'abc'), u'abc')\r
1216 self.assertEqual(u'{0:.3s}'.format(u'ab'), u'ab')\r
1217 self.assertEqual(u'{0:.3s}'.format(u'abcdef'), u'abc')\r
1218 self.assertEqual(u'{0:.0s}'.format(u'abcdef'), u'')\r
1219 self.assertEqual(u'{0:3.3s}'.format(u'abc'), u'abc')\r
1220 self.assertEqual(u'{0:2.3s}'.format(u'abc'), u'abc')\r
1221 self.assertEqual(u'{0:2.2s}'.format(u'abc'), u'ab')\r
1222 self.assertEqual(u'{0:3.2s}'.format(u'abc'), u'ab ')\r
1223 self.assertEqual(u'{0:x<0s}'.format(u'result'), u'result')\r
1224 self.assertEqual(u'{0:x<5s}'.format(u'result'), u'result')\r
1225 self.assertEqual(u'{0:x<6s}'.format(u'result'), u'result')\r
1226 self.assertEqual(u'{0:x<7s}'.format(u'result'), u'resultx')\r
1227 self.assertEqual(u'{0:x<8s}'.format(u'result'), u'resultxx')\r
1228 self.assertEqual(u'{0: <7s}'.format(u'result'), u'result ')\r
1229 self.assertEqual(u'{0:<7s}'.format(u'result'), u'result ')\r
1230 self.assertEqual(u'{0:>7s}'.format(u'result'), u' result')\r
1231 self.assertEqual(u'{0:>8s}'.format(u'result'), u' result')\r
1232 self.assertEqual(u'{0:^8s}'.format(u'result'), u' result ')\r
1233 self.assertEqual(u'{0:^9s}'.format(u'result'), u' result ')\r
1234 self.assertEqual(u'{0:^10s}'.format(u'result'), u' result ')\r
1235 self.assertEqual(u'{0:10000}'.format(u'a'), u'a' + u' ' * 9999)\r
1236 self.assertEqual(u'{0:10000}'.format(u''), u' ' * 10000)\r
1237 self.assertEqual(u'{0:10000000}'.format(u''), u' ' * 10000000)\r
1238\r
1239 # format specifiers for user defined type\r
1240 self.assertEqual(u'{0:abc}'.format(C()), u'abc')\r
1241\r
1242 # !r and !s coercions\r
1243 self.assertEqual(u'{0!s}'.format(u'Hello'), u'Hello')\r
1244 self.assertEqual(u'{0!s:}'.format(u'Hello'), u'Hello')\r
1245 self.assertEqual(u'{0!s:15}'.format(u'Hello'), u'Hello ')\r
1246 self.assertEqual(u'{0!s:15s}'.format(u'Hello'), u'Hello ')\r
1247 self.assertEqual(u'{0!r}'.format(u'Hello'), u"u'Hello'")\r
1248 self.assertEqual(u'{0!r:}'.format(u'Hello'), u"u'Hello'")\r
1249 self.assertEqual(u'{0!r}'.format(F(u'Hello')), u'F(Hello)')\r
1250\r
1251 # test fallback to object.__format__\r
1252 self.assertEqual(u'{0}'.format({}), u'{}')\r
1253 self.assertEqual(u'{0}'.format([]), u'[]')\r
1254 self.assertEqual(u'{0}'.format([1]), u'[1]')\r
1255 self.assertEqual(u'{0}'.format(E(u'data')), u'E(data)')\r
1256 self.assertEqual(u'{0:d}'.format(G(u'data')), u'G(data)')\r
1257 self.assertEqual(u'{0!s}'.format(G(u'data')), u'string is data')\r
1258\r
1259 msg = 'object.__format__ with a non-empty format string is deprecated'\r
1260 with test_support.check_warnings((msg, PendingDeprecationWarning)):\r
1261 self.assertEqual(u'{0:^10}'.format(E(u'data')), u' E(data) ')\r
1262 self.assertEqual(u'{0:^10s}'.format(E(u'data')), u' E(data) ')\r
1263 self.assertEqual(u'{0:>15s}'.format(G(u'data')), u' string is data')\r
1264\r
1265 self.assertEqual(u"{0:date: %Y-%m-%d}".format(I(year=2007,\r
1266 month=8,\r
1267 day=27)),\r
1268 u"date: 2007-08-27")\r
1269\r
1270 # test deriving from a builtin type and overriding __format__\r
1271 self.assertEqual(u"{0}".format(J(10)), u"20")\r
1272\r
1273\r
1274 # string format specifiers\r
1275 self.assertEqual(u'{0:}'.format('a'), u'a')\r
1276\r
1277 # computed format specifiers\r
1278 self.assertEqual(u"{0:.{1}}".format(u'hello world', 5), u'hello')\r
1279 self.assertEqual(u"{0:.{1}s}".format(u'hello world', 5), u'hello')\r
1280 self.assertEqual(u"{0:.{precision}s}".format('hello world', precision=5), u'hello')\r
1281 self.assertEqual(u"{0:{width}.{precision}s}".format('hello world', width=10, precision=5), u'hello ')\r
1282 self.assertEqual(u"{0:{width}.{precision}s}".format('hello world', width='10', precision='5'), u'hello ')\r
1283\r
1284 # test various errors\r
1285 self.assertRaises(ValueError, u'{'.format)\r
1286 self.assertRaises(ValueError, u'}'.format)\r
1287 self.assertRaises(ValueError, u'a{'.format)\r
1288 self.assertRaises(ValueError, u'a}'.format)\r
1289 self.assertRaises(ValueError, u'{a'.format)\r
1290 self.assertRaises(ValueError, u'}a'.format)\r
1291 self.assertRaises(IndexError, u'{0}'.format)\r
1292 self.assertRaises(IndexError, u'{1}'.format, u'abc')\r
1293 self.assertRaises(KeyError, u'{x}'.format)\r
1294 self.assertRaises(ValueError, u"}{".format)\r
1295 self.assertRaises(ValueError, u"{".format)\r
1296 self.assertRaises(ValueError, u"}".format)\r
1297 self.assertRaises(ValueError, u"abc{0:{}".format)\r
1298 self.assertRaises(ValueError, u"{0".format)\r
1299 self.assertRaises(IndexError, u"{0.}".format)\r
1300 self.assertRaises(ValueError, u"{0.}".format, 0)\r
1301 self.assertRaises(IndexError, u"{0[}".format)\r
1302 self.assertRaises(ValueError, u"{0[}".format, [])\r
1303 self.assertRaises(KeyError, u"{0]}".format)\r
1304 self.assertRaises(ValueError, u"{0.[]}".format, 0)\r
1305 self.assertRaises(ValueError, u"{0..foo}".format, 0)\r
1306 self.assertRaises(ValueError, u"{0[0}".format, 0)\r
1307 self.assertRaises(ValueError, u"{0[0:foo}".format, 0)\r
1308 self.assertRaises(KeyError, u"{c]}".format)\r
1309 self.assertRaises(ValueError, u"{{ {{{0}}".format, 0)\r
1310 self.assertRaises(ValueError, u"{0}}".format, 0)\r
1311 self.assertRaises(KeyError, u"{foo}".format, bar=3)\r
1312 self.assertRaises(ValueError, u"{0!x}".format, 3)\r
1313 self.assertRaises(ValueError, u"{0!}".format, 0)\r
1314 self.assertRaises(ValueError, u"{0!rs}".format, 0)\r
1315 self.assertRaises(ValueError, u"{!}".format)\r
1316 self.assertRaises(IndexError, u"{:}".format)\r
1317 self.assertRaises(IndexError, u"{:s}".format)\r
1318 self.assertRaises(IndexError, u"{}".format)\r
1319 big = u"23098475029384702983476098230754973209482573"\r
1320 self.assertRaises(ValueError, (u"{" + big + u"}").format)\r
1321 self.assertRaises(ValueError, (u"{[" + big + u"]}").format, [0])\r
1322\r
1323 # issue 6089\r
1324 self.assertRaises(ValueError, u"{0[0]x}".format, [None])\r
1325 self.assertRaises(ValueError, u"{0[0](10)}".format, [None])\r
1326\r
1327 # can't have a replacement on the field name portion\r
1328 self.assertRaises(TypeError, u'{0[{1}]}'.format, u'abcdefg', 4)\r
1329\r
1330 # exceed maximum recursion depth\r
1331 self.assertRaises(ValueError, u"{0:{1:{2}}}".format, u'abc', u's', u'')\r
1332 self.assertRaises(ValueError, u"{0:{1:{2:{3:{4:{5:{6}}}}}}}".format,\r
1333 0, 1, 2, 3, 4, 5, 6, 7)\r
1334\r
1335 # string format spec errors\r
1336 self.assertRaises(ValueError, u"{0:-s}".format, u'')\r
1337 self.assertRaises(ValueError, format, u"", u"-")\r
1338 self.assertRaises(ValueError, u"{0:=s}".format, u'')\r
1339\r
1340 # test combining string and unicode\r
1341 self.assertEqual(u"foo{0}".format('bar'), u'foobar')\r
1342 # This will try to convert the argument from unicode to str, which\r
1343 # will succeed\r
1344 self.assertEqual("foo{0}".format(u'bar'), 'foobar')\r
1345 # This will try to convert the argument from unicode to str, which\r
1346 # will fail\r
1347 self.assertRaises(UnicodeEncodeError, "foo{0}".format, u'\u1000bar')\r
1348\r
1349 def test_format_auto_numbering(self):\r
1350 class C:\r
1351 def __init__(self, x=100):\r
1352 self._x = x\r
1353 def __format__(self, spec):\r
1354 return spec\r
1355\r
1356 self.assertEqual(u'{}'.format(10), u'10')\r
1357 self.assertEqual(u'{:5}'.format('s'), u's ')\r
1358 self.assertEqual(u'{!r}'.format('s'), u"'s'")\r
1359 self.assertEqual(u'{._x}'.format(C(10)), u'10')\r
1360 self.assertEqual(u'{[1]}'.format([1, 2]), u'2')\r
1361 self.assertEqual(u'{[a]}'.format({'a':4, 'b':2}), u'4')\r
1362 self.assertEqual(u'a{}b{}c'.format(0, 1), u'a0b1c')\r
1363\r
1364 self.assertEqual(u'a{:{}}b'.format('x', '^10'), u'a x b')\r
1365 self.assertEqual(u'a{:{}x}b'.format(20, '#'), u'a0x14b')\r
1366\r
1367 # can't mix and match numbering and auto-numbering\r
1368 self.assertRaises(ValueError, u'{}{1}'.format, 1, 2)\r
1369 self.assertRaises(ValueError, u'{1}{}'.format, 1, 2)\r
1370 self.assertRaises(ValueError, u'{:{1}}'.format, 1, 2)\r
1371 self.assertRaises(ValueError, u'{0:{}}'.format, 1, 2)\r
1372\r
1373 # can mix and match auto-numbering and named\r
1374 self.assertEqual(u'{f}{}'.format(4, f='test'), u'test4')\r
1375 self.assertEqual(u'{}{f}'.format(4, f='test'), u'4test')\r
1376 self.assertEqual(u'{:{f}}{g}{}'.format(1, 3, g='g', f=2), u' 1g3')\r
1377 self.assertEqual(u'{f:{}}{}{g}'.format(2, 4, f=1, g='g'), u' 14g')\r
1378\r
1379 def test_raiseMemError(self):\r
1380 # Ensure that the freelist contains a consistent object, even\r
1381 # when a string allocation fails with a MemoryError.\r
1382 # This used to crash the interpreter,\r
1383 # or leak references when the number was smaller.\r
1384 charwidth = 4 if sys.maxunicode >= 0x10000 else 2\r
1385 # Note: sys.maxsize is half of the actual max allocation because of\r
1386 # the signedness of Py_ssize_t.\r
1387 alloc = lambda: u"a" * (sys.maxsize // charwidth * 2)\r
1388 self.assertRaises(MemoryError, alloc)\r
1389 self.assertRaises(MemoryError, alloc)\r
1390\r
1391 def test_format_subclass(self):\r
1392 class U(unicode):\r
1393 def __unicode__(self):\r
1394 return u'__unicode__ overridden'\r
1395 u = U(u'xxx')\r
1396 self.assertEqual("%s" % u, u'__unicode__ overridden')\r
1397 self.assertEqual("{}".format(u), '__unicode__ overridden')\r
1398\r
1399\r
1400def test_main():\r
1401 test_support.run_unittest(__name__)\r
1402\r
1403if __name__ == "__main__":\r
1404 test_main()\r
EFI Development Kit II mirror for PVE