|
1 try: |
|
2 unicode |
|
3 except NameError: |
|
4 raise ImportError |
|
5 |
|
6 from pybench import Test |
|
7 from string import join |
|
8 |
|
9 class ConcatUnicode(Test): |
|
10 |
|
11 version = 2.0 |
|
12 operations = 10 * 5 |
|
13 rounds = 60000 |
|
14 |
|
15 def test(self): |
|
16 |
|
17 # Make sure the strings are *not* interned |
|
18 s = unicode(join(map(str,range(100)))) |
|
19 t = unicode(join(map(str,range(1,101)))) |
|
20 |
|
21 for i in xrange(self.rounds): |
|
22 t + s |
|
23 t + s |
|
24 t + s |
|
25 t + s |
|
26 t + s |
|
27 |
|
28 t + s |
|
29 t + s |
|
30 t + s |
|
31 t + s |
|
32 t + s |
|
33 |
|
34 t + s |
|
35 t + s |
|
36 t + s |
|
37 t + s |
|
38 t + s |
|
39 |
|
40 t + s |
|
41 t + s |
|
42 t + s |
|
43 t + s |
|
44 t + s |
|
45 |
|
46 t + s |
|
47 t + s |
|
48 t + s |
|
49 t + s |
|
50 t + s |
|
51 |
|
52 t + s |
|
53 t + s |
|
54 t + s |
|
55 t + s |
|
56 t + s |
|
57 |
|
58 t + s |
|
59 t + s |
|
60 t + s |
|
61 t + s |
|
62 t + s |
|
63 |
|
64 t + s |
|
65 t + s |
|
66 t + s |
|
67 t + s |
|
68 t + s |
|
69 |
|
70 t + s |
|
71 t + s |
|
72 t + s |
|
73 t + s |
|
74 t + s |
|
75 |
|
76 t + s |
|
77 t + s |
|
78 t + s |
|
79 t + s |
|
80 t + s |
|
81 |
|
82 def calibrate(self): |
|
83 |
|
84 s = unicode(join(map(str,range(100)))) |
|
85 t = unicode(join(map(str,range(1,101)))) |
|
86 |
|
87 for i in xrange(self.rounds): |
|
88 pass |
|
89 |
|
90 |
|
91 class CompareUnicode(Test): |
|
92 |
|
93 version = 2.0 |
|
94 operations = 10 * 5 |
|
95 rounds = 150000 |
|
96 |
|
97 def test(self): |
|
98 |
|
99 # Make sure the strings are *not* interned |
|
100 s = unicode(join(map(str,range(10)))) |
|
101 t = unicode(join(map(str,range(10))) + "abc") |
|
102 |
|
103 for i in xrange(self.rounds): |
|
104 t < s |
|
105 t > s |
|
106 t == s |
|
107 t > s |
|
108 t < s |
|
109 |
|
110 t < s |
|
111 t > s |
|
112 t == s |
|
113 t > s |
|
114 t < s |
|
115 |
|
116 t < s |
|
117 t > s |
|
118 t == s |
|
119 t > s |
|
120 t < s |
|
121 |
|
122 t < s |
|
123 t > s |
|
124 t == s |
|
125 t > s |
|
126 t < s |
|
127 |
|
128 t < s |
|
129 t > s |
|
130 t == s |
|
131 t > s |
|
132 t < s |
|
133 |
|
134 t < s |
|
135 t > s |
|
136 t == s |
|
137 t > s |
|
138 t < s |
|
139 |
|
140 t < s |
|
141 t > s |
|
142 t == s |
|
143 t > s |
|
144 t < s |
|
145 |
|
146 t < s |
|
147 t > s |
|
148 t == s |
|
149 t > s |
|
150 t < s |
|
151 |
|
152 t < s |
|
153 t > s |
|
154 t == s |
|
155 t > s |
|
156 t < s |
|
157 |
|
158 t < s |
|
159 t > s |
|
160 t == s |
|
161 t > s |
|
162 t < s |
|
163 |
|
164 def calibrate(self): |
|
165 |
|
166 s = unicode(join(map(str,range(10)))) |
|
167 t = unicode(join(map(str,range(10))) + "abc") |
|
168 |
|
169 for i in xrange(self.rounds): |
|
170 pass |
|
171 |
|
172 |
|
173 class CreateUnicodeWithConcat(Test): |
|
174 |
|
175 version = 2.0 |
|
176 operations = 10 * 5 |
|
177 rounds = 80000 |
|
178 |
|
179 def test(self): |
|
180 |
|
181 for i in xrange(self.rounds): |
|
182 s = u'om' |
|
183 s = s + u'xbx' |
|
184 s = s + u'xcx' |
|
185 s = s + u'xdx' |
|
186 s = s + u'xex' |
|
187 |
|
188 s = s + u'xax' |
|
189 s = s + u'xbx' |
|
190 s = s + u'xcx' |
|
191 s = s + u'xdx' |
|
192 s = s + u'xex' |
|
193 |
|
194 s = s + u'xax' |
|
195 s = s + u'xbx' |
|
196 s = s + u'xcx' |
|
197 s = s + u'xdx' |
|
198 s = s + u'xex' |
|
199 |
|
200 s = s + u'xax' |
|
201 s = s + u'xbx' |
|
202 s = s + u'xcx' |
|
203 s = s + u'xdx' |
|
204 s = s + u'xex' |
|
205 |
|
206 s = s + u'xax' |
|
207 s = s + u'xbx' |
|
208 s = s + u'xcx' |
|
209 s = s + u'xdx' |
|
210 s = s + u'xex' |
|
211 |
|
212 s = s + u'xax' |
|
213 s = s + u'xbx' |
|
214 s = s + u'xcx' |
|
215 s = s + u'xdx' |
|
216 s = s + u'xex' |
|
217 |
|
218 s = s + u'xax' |
|
219 s = s + u'xbx' |
|
220 s = s + u'xcx' |
|
221 s = s + u'xdx' |
|
222 s = s + u'xex' |
|
223 |
|
224 s = s + u'xax' |
|
225 s = s + u'xbx' |
|
226 s = s + u'xcx' |
|
227 s = s + u'xdx' |
|
228 s = s + u'xex' |
|
229 |
|
230 s = s + u'xax' |
|
231 s = s + u'xbx' |
|
232 s = s + u'xcx' |
|
233 s = s + u'xdx' |
|
234 s = s + u'xex' |
|
235 |
|
236 s = s + u'xax' |
|
237 s = s + u'xbx' |
|
238 s = s + u'xcx' |
|
239 s = s + u'xdx' |
|
240 s = s + u'xex' |
|
241 |
|
242 def calibrate(self): |
|
243 |
|
244 for i in xrange(self.rounds): |
|
245 pass |
|
246 |
|
247 |
|
248 class UnicodeSlicing(Test): |
|
249 |
|
250 version = 2.0 |
|
251 operations = 5 * 7 |
|
252 rounds = 140000 |
|
253 |
|
254 def test(self): |
|
255 |
|
256 s = unicode(join(map(str,range(100)))) |
|
257 |
|
258 for i in xrange(self.rounds): |
|
259 |
|
260 s[50:] |
|
261 s[:25] |
|
262 s[50:55] |
|
263 s[-1:] |
|
264 s[:1] |
|
265 s[2:] |
|
266 s[11:-11] |
|
267 |
|
268 s[50:] |
|
269 s[:25] |
|
270 s[50:55] |
|
271 s[-1:] |
|
272 s[:1] |
|
273 s[2:] |
|
274 s[11:-11] |
|
275 |
|
276 s[50:] |
|
277 s[:25] |
|
278 s[50:55] |
|
279 s[-1:] |
|
280 s[:1] |
|
281 s[2:] |
|
282 s[11:-11] |
|
283 |
|
284 s[50:] |
|
285 s[:25] |
|
286 s[50:55] |
|
287 s[-1:] |
|
288 s[:1] |
|
289 s[2:] |
|
290 s[11:-11] |
|
291 |
|
292 s[50:] |
|
293 s[:25] |
|
294 s[50:55] |
|
295 s[-1:] |
|
296 s[:1] |
|
297 s[2:] |
|
298 s[11:-11] |
|
299 |
|
300 def calibrate(self): |
|
301 |
|
302 s = unicode(join(map(str,range(100)))) |
|
303 |
|
304 for i in xrange(self.rounds): |
|
305 pass |
|
306 |
|
307 ### String methods |
|
308 |
|
309 class UnicodeMappings(Test): |
|
310 |
|
311 version = 2.0 |
|
312 operations = 3 * (5 + 4 + 2 + 1) |
|
313 rounds = 10000 |
|
314 |
|
315 def test(self): |
|
316 |
|
317 s = join(map(unichr,range(20)),'') |
|
318 t = join(map(unichr,range(100)),'') |
|
319 u = join(map(unichr,range(500)),'') |
|
320 v = join(map(unichr,range(1000)),'') |
|
321 |
|
322 for i in xrange(self.rounds): |
|
323 |
|
324 s.lower() |
|
325 s.lower() |
|
326 s.lower() |
|
327 s.lower() |
|
328 s.lower() |
|
329 |
|
330 s.upper() |
|
331 s.upper() |
|
332 s.upper() |
|
333 s.upper() |
|
334 s.upper() |
|
335 |
|
336 s.title() |
|
337 s.title() |
|
338 s.title() |
|
339 s.title() |
|
340 s.title() |
|
341 |
|
342 t.lower() |
|
343 t.lower() |
|
344 t.lower() |
|
345 t.lower() |
|
346 |
|
347 t.upper() |
|
348 t.upper() |
|
349 t.upper() |
|
350 t.upper() |
|
351 |
|
352 t.title() |
|
353 t.title() |
|
354 t.title() |
|
355 t.title() |
|
356 |
|
357 u.lower() |
|
358 u.lower() |
|
359 |
|
360 u.upper() |
|
361 u.upper() |
|
362 |
|
363 u.title() |
|
364 u.title() |
|
365 |
|
366 v.lower() |
|
367 |
|
368 v.upper() |
|
369 |
|
370 v.title() |
|
371 |
|
372 def calibrate(self): |
|
373 |
|
374 s = join(map(unichr,range(20)),'') |
|
375 t = join(map(unichr,range(100)),'') |
|
376 u = join(map(unichr,range(500)),'') |
|
377 v = join(map(unichr,range(1000)),'') |
|
378 |
|
379 for i in xrange(self.rounds): |
|
380 pass |
|
381 |
|
382 class UnicodePredicates(Test): |
|
383 |
|
384 version = 2.0 |
|
385 operations = 5 * 9 |
|
386 rounds = 120000 |
|
387 |
|
388 def test(self): |
|
389 |
|
390 data = (u'abc', u'123', u' ', u'\u1234\u2345\u3456', u'\uFFFF'*10) |
|
391 len_data = len(data) |
|
392 |
|
393 for i in xrange(self.rounds): |
|
394 s = data[i % len_data] |
|
395 |
|
396 s.isalnum() |
|
397 s.isalpha() |
|
398 s.isdecimal() |
|
399 s.isdigit() |
|
400 s.islower() |
|
401 s.isnumeric() |
|
402 s.isspace() |
|
403 s.istitle() |
|
404 s.isupper() |
|
405 |
|
406 s.isalnum() |
|
407 s.isalpha() |
|
408 s.isdecimal() |
|
409 s.isdigit() |
|
410 s.islower() |
|
411 s.isnumeric() |
|
412 s.isspace() |
|
413 s.istitle() |
|
414 s.isupper() |
|
415 |
|
416 s.isalnum() |
|
417 s.isalpha() |
|
418 s.isdecimal() |
|
419 s.isdigit() |
|
420 s.islower() |
|
421 s.isnumeric() |
|
422 s.isspace() |
|
423 s.istitle() |
|
424 s.isupper() |
|
425 |
|
426 s.isalnum() |
|
427 s.isalpha() |
|
428 s.isdecimal() |
|
429 s.isdigit() |
|
430 s.islower() |
|
431 s.isnumeric() |
|
432 s.isspace() |
|
433 s.istitle() |
|
434 s.isupper() |
|
435 |
|
436 s.isalnum() |
|
437 s.isalpha() |
|
438 s.isdecimal() |
|
439 s.isdigit() |
|
440 s.islower() |
|
441 s.isnumeric() |
|
442 s.isspace() |
|
443 s.istitle() |
|
444 s.isupper() |
|
445 |
|
446 def calibrate(self): |
|
447 |
|
448 data = (u'abc', u'123', u' ', u'\u1234\u2345\u3456', u'\uFFFF'*10) |
|
449 len_data = len(data) |
|
450 |
|
451 for i in xrange(self.rounds): |
|
452 s = data[i % len_data] |
|
453 |
|
454 try: |
|
455 import unicodedata |
|
456 except ImportError: |
|
457 pass |
|
458 else: |
|
459 class UnicodeProperties(Test): |
|
460 |
|
461 version = 2.0 |
|
462 operations = 5 * 8 |
|
463 rounds = 100000 |
|
464 |
|
465 def test(self): |
|
466 |
|
467 data = (u'a', u'1', u' ', u'\u1234', u'\uFFFF') |
|
468 len_data = len(data) |
|
469 digit = unicodedata.digit |
|
470 numeric = unicodedata.numeric |
|
471 decimal = unicodedata.decimal |
|
472 category = unicodedata.category |
|
473 bidirectional = unicodedata.bidirectional |
|
474 decomposition = unicodedata.decomposition |
|
475 mirrored = unicodedata.mirrored |
|
476 combining = unicodedata.combining |
|
477 |
|
478 for i in xrange(self.rounds): |
|
479 |
|
480 c = data[i % len_data] |
|
481 |
|
482 digit(c, None) |
|
483 numeric(c, None) |
|
484 decimal(c, None) |
|
485 category(c) |
|
486 bidirectional(c) |
|
487 decomposition(c) |
|
488 mirrored(c) |
|
489 combining(c) |
|
490 |
|
491 digit(c, None) |
|
492 numeric(c, None) |
|
493 decimal(c, None) |
|
494 category(c) |
|
495 bidirectional(c) |
|
496 decomposition(c) |
|
497 mirrored(c) |
|
498 combining(c) |
|
499 |
|
500 digit(c, None) |
|
501 numeric(c, None) |
|
502 decimal(c, None) |
|
503 category(c) |
|
504 bidirectional(c) |
|
505 decomposition(c) |
|
506 mirrored(c) |
|
507 combining(c) |
|
508 |
|
509 digit(c, None) |
|
510 numeric(c, None) |
|
511 decimal(c, None) |
|
512 category(c) |
|
513 bidirectional(c) |
|
514 decomposition(c) |
|
515 mirrored(c) |
|
516 combining(c) |
|
517 |
|
518 digit(c, None) |
|
519 numeric(c, None) |
|
520 decimal(c, None) |
|
521 category(c) |
|
522 bidirectional(c) |
|
523 decomposition(c) |
|
524 mirrored(c) |
|
525 combining(c) |
|
526 |
|
527 def calibrate(self): |
|
528 |
|
529 data = (u'a', u'1', u' ', u'\u1234', u'\uFFFF') |
|
530 len_data = len(data) |
|
531 digit = unicodedata.digit |
|
532 numeric = unicodedata.numeric |
|
533 decimal = unicodedata.decimal |
|
534 category = unicodedata.category |
|
535 bidirectional = unicodedata.bidirectional |
|
536 decomposition = unicodedata.decomposition |
|
537 mirrored = unicodedata.mirrored |
|
538 combining = unicodedata.combining |
|
539 |
|
540 for i in xrange(self.rounds): |
|
541 |
|
542 c = data[i % len_data] |