Lines Matching refs:size
18 # its size. To make sure whether a result has the right contents, better
32 # passed-in 'size', and don't rely on the size being very large. Also,
33 # memuse-per-size should remain sane (less than a few thousand); if your
34 # test uses more, adjust 'size' upward, instead.
38 def test_capitalize(self, size):
40 s = '-' * size + SUBSTR
47 def test_center(self, size):
49 s = SUBSTR.center(size)
50 self.assertEqual(len(s), size)
57 @precisionbigmemtest(size=_2G - 1, memuse=1)
58 def test_center_unicode(self, size):
61 s = SUBSTR.center(size)
65 self.assertEqual(len(s), size)
74 def test_count(self, size):
76 s = '.' * size + SUBSTR
77 self.assertEqual(s.count('.'), size)
79 self.assertEqual(s.count('.'), size + 1)
85 def test_decode(self, size):
86 s = '.' * size
87 self.assertEqual(len(s.decode('utf-8')), size)
89 def basic_encode_test(self, size, enc, c=u'.', expectedsize=None):
91 expectedsize = size
93 s = c * size
97 def test_encode(self, size):
98 return self.basic_encode_test(size, 'utf-8')
100 @precisionbigmemtest(size=_4G // 6 + 2, memuse=2)
101 def test_encode_raw_unicode_escape(self, size):
103 return self.basic_encode_test(size, 'raw_unicode_escape')
107 @precisionbigmemtest(size=_4G // 5 + 70, memuse=3)
108 def test_encode_utf7(self, size):
110 return self.basic_encode_test(size, 'utf7')
114 @precisionbigmemtest(size=_4G // 4 + 5, memuse=6)
115 def test_encode_utf32(self, size):
117 return self.basic_encode_test(size, 'utf32', expectedsize=4*size+4)
121 @precisionbigmemtest(size=_2G-1, memuse=4)
122 def test_decodeascii(self, size):
123 return self.basic_encode_test(size, 'ascii', c='A')
125 @precisionbigmemtest(size=_4G // 5, memuse=6+2)
126 def test_unicode_repr_oflw(self, size):
129 s = u"\uAAAA"*size
137 def test_endswith(self, size):
139 s = '-' * size + SUBSTR
148 def test_expandtabs(self, size):
149 s = '-' * size
153 slen, remainder = divmod(size, tabsize)
156 self.assertEqual(len(s), size - remainder)
160 def test_find(self, size):
163 s = ''.join([SUBSTR, '-' * size, SUBSTR])
166 self.assertEqual(s.find(' ', sublen), sublen + size)
167 self.assertEqual(s.find(SUBSTR, len(SUBSTR)), sublen + size)
170 sublen + size + SUBSTR.find('i'))
171 self.assertEqual(s.find('i', size),
172 sublen + size + SUBSTR.find('i'))
176 def test_index(self, size):
179 s = ''.join([SUBSTR, '-' * size, SUBSTR])
182 self.assertEqual(s.index(' ', sublen), sublen + size)
183 self.assertEqual(s.index(SUBSTR, sublen), sublen + size)
186 sublen + size + SUBSTR.index('i'))
187 self.assertEqual(s.index('i', size),
188 sublen + size + SUBSTR.index('i'))
192 def test_isalnum(self, size):
194 s = 'a' * size + SUBSTR
200 def test_isalpha(self, size):
202 s = 'a' * size + SUBSTR
208 def test_isdigit(self, size):
210 s = '9' * size + SUBSTR
216 def test_islower(self, size):
218 repeats = size // len(chars) + 2
225 def test_isspace(self, size):
227 repeats = size // len(whitespace) + 2
234 def test_istitle(self, size):
236 s = ''.join(['A', 'a' * size, SUBSTR])
244 def test_isupper(self, size):
246 repeats = size // len(chars) + 2
253 def test_join(self, size):
254 s = 'A' * size
262 def test_ljust(self, size):
264 s = SUBSTR.ljust(size)
266 self.assertEqual(len(s), size)
270 def test_lower(self, size):
271 s = 'A' * size
273 self.assertEqual(len(s), size)
274 self.assertEqual(s.count('a'), size)
277 def test_lstrip(self, size):
279 s = SUBSTR.rjust(size)
280 self.assertEqual(len(s), size)
283 s = SUBSTR.ljust(size)
284 self.assertEqual(len(s), size)
289 def test_replace(self, size):
291 s = ' ' * size
293 self.assertEqual(len(s), size)
294 self.assertEqual(s.count(replacement), size)
295 s = s.replace(replacement, ' ', size - 4)
296 self.assertEqual(len(s), size)
301 def test_rfind(self, size):
304 s = ''.join([SUBSTR, '-' * size, SUBSTR])
305 self.assertEqual(s.rfind(' '), sublen + size + SUBSTR.rfind(' '))
306 self.assertEqual(s.rfind(SUBSTR), sublen + size)
307 self.assertEqual(s.rfind(' ', 0, size), SUBSTR.rfind(' '))
308 self.assertEqual(s.rfind(SUBSTR, 0, sublen + size), 0)
309 self.assertEqual(s.rfind('i'), sublen + size + SUBSTR.rfind('i'))
311 self.assertEqual(s.rfind('i', 0, sublen + size),
316 def test_rindex(self, size):
319 s = ''.join([SUBSTR, '-' * size, SUBSTR])
321 sublen + size + SUBSTR.rindex(' '))
322 self.assertEqual(s.rindex(SUBSTR), sublen + size)
323 self.assertEqual(s.rindex(' ', 0, sublen + size - 1),
325 self.assertEqual(s.rindex(SUBSTR, 0, sublen + size), 0)
327 sublen + size + SUBSTR.rindex('i'))
329 self.assertEqual(s.rindex('i', 0, sublen + size),
334 def test_rjust(self, size):
336 s = SUBSTR.ljust(size)
338 self.assertEqual(len(s), size)
342 def test_rstrip(self, size):
344 s = SUBSTR.ljust(size)
345 self.assertEqual(len(s), size)
348 s = SUBSTR.rjust(size)
349 self.assertEqual(len(s), size)
353 # The test takes about size bytes to build a string, and then about
354 # sqrt(size) substrings of sqrt(size) in size and a list to
355 # hold sqrt(size) items. It's close but just over 2x size.
357 def test_split_small(self, size):
360 chunksize = int(size ** 0.5 + 2)
371 # Allocates a string of twice size (and briefly two) and a list of
372 # size. Because of internal affairs, the s.split() call produces a
373 # list of size times the same one-character string, so we only
374 # suffer for the list size. (Otherwise, it'd cost another 48 times
375 # size in bytes!) Nevertheless, a list of size takes
376 # 8*size bytes.
378 def test_split_large(self, size):
379 s = ' a' * size + ' '
381 self.assertEqual(len(l), size)
385 self.assertEqual(len(l), size + 1)
389 def test_splitlines(self, size):
392 chunksize = int(size ** 0.5 + 2) // 2
400 def test_startswith(self, size):
402 s = '-' * size + SUBSTR
404 self.assertTrue(s.startswith('-' * size))
408 def test_strip(self, size):
410 s = SUBSTR.rjust(size)
411 self.assertEqual(len(s), size)
414 s = SUBSTR.ljust(size)
415 self.assertEqual(len(s), size)
419 def test_swapcase(self, size):
422 repeats = size // sublen + 2
430 def test_title(self, size):
432 s = SUBSTR * (size // len(SUBSTR) + 2)
438 def test_translate(self, size):
442 repeats = size // sublen + 2
453 def test_upper(self, size):
454 s = 'a' * size
456 self.assertEqual(len(s), size)
457 self.assertEqual(s.count('A'), size)
460 def test_zfill(self, size):
462 s = SUBSTR.zfill(size)
465 self.assertEqual(len(s), size)
466 self.assertEqual(s.count('0'), size - len(SUBSTR))
469 def test_format(self, size):
470 s = '-' * size
480 size //= 2
481 edge = '-' * size
485 self.assertEqual(len(s), size * 2 + 3)
487 self.assertEqual(s.count('-'), size * 2)
490 def test_repr_small(self, size):
491 s = '-' * size
493 self.assertEqual(len(s), size + 2)
496 self.assertEqual(s.count('-'), size)
500 # size in total. (We do extra testing in test_repr_large())
501 s = '\x00' * size
503 self.assertEqual(len(s), size * 4 + 2)
506 self.assertEqual(s.count('\\'), size)
507 self.assertEqual(s.count('0'), size * 2)
510 def test_repr_large(self, size):
511 s = '\x00' * size
513 self.assertEqual(len(s), size * 4 + 2)
516 self.assertEqual(s.count('\\'), size)
517 self.assertEqual(s.count('0'), size * 2)
520 def test_unicode_repr(self, size):
521 s = u"\uAAAA" * size
522 self.assertTrue(len(repr(s)) > size)
524 # This test is meaningful even with size < 2G, as long as the
527 def test_concat(self, size):
528 s = '.' * size
529 self.assertEqual(len(s), size)
531 self.assertEqual(len(s), size * 2)
532 self.assertEqual(s.count('.'), size * 2)
534 # This test is meaningful even with size < 2G, as long as the
537 def test_repeat(self, size):
538 s = '.' * size
539 self.assertEqual(len(s), size)
541 self.assertEqual(len(s), size * 2)
542 self.assertEqual(s.count('.'), size * 2)
545 def test_slice_and_getitem(self, size):
548 s = SUBSTR * (size // sublen)
578 def test_contains(self, size):
580 edge = '-' * (size // 2)
591 def test_compare(self, size):
592 s1 = '-' * size
593 s2 = '-' * size
599 s2 = '.' * size
603 def test_hash(self, size):
606 # different depending on the size of the C 'long int'. Even this
610 s = '\x00' * size
613 s = '\x00' * (size + 1)
621 # per size.
628 def test_compare(self, size):
629 t1 = (u'',) * size
630 t2 = (u'',) * size
633 t2 = (u'',) * (size + 1)
636 t2 = (1,) * size
644 def basic_concat_test(self, size):
645 t = ((),) * size
646 self.assertEqual(len(t), size)
648 self.assertEqual(len(t), size * 2)
651 def test_concat_small(self, size):
652 return self.basic_concat_test(size)
655 def test_concat_large(self, size):
656 return self.basic_concat_test(size)
659 def test_contains(self, size):
660 t = (1, 2, 3, 4, 5) * size
661 self.assertEqual(len(t), size * 5)
667 def test_hash(self, size):
668 t1 = (0,) * size
671 t2 = (0,) * (size + 1)
675 def test_index_and_slice(self, size):
676 t = (None,) * size
677 self.assertEqual(len(t), size)
680 self.assertEqual(t[size - 1], None)
681 self.assertRaises(IndexError, operator.getitem, t, size)
686 self.assertEqual(t[size - 5:], (None,) * 5)
687 self.assertEqual(t[size - 5:size], (None,) * 5)
688 self.assertEqual(t[size - 6:size - 2], (None,) * 4)
689 self.assertEqual(t[size:size], ())
690 self.assertEqual(t[size:size+5], ())
693 def basic_test_repeat(self, size):
694 t = ('',) * size
695 self.assertEqual(len(t), size)
697 self.assertEqual(len(t), size * 2)
700 def test_repeat_small(self, size):
701 return self.basic_test_repeat(size)
704 def test_repeat_large(self, size):
705 return self.basic_test_repeat(size)
708 def test_repeat_large_2(self, size):
709 return self.basic_test_repeat(size)
711 @precisionbigmemtest(size=_1G - 1, memuse=9)
712 def test_from_2G_generator(self, size):
714 t = tuple(xrange(size))
722 self.assertEqual(count, size)
724 @precisionbigmemtest(size=_1G - 25, memuse=9)
725 def test_from_almost_2G_generator(self, size):
727 t = tuple(xrange(size))
732 self.assertEqual(count, size)
737 def basic_test_repr(self, size):
738 t = (0,) * size
741 self.assertEqual(len(s), size * 3)
744 self.assertEqual(s.count('0'), size)
747 def test_repr_small(self, size):
748 return self.basic_test_repr(size)
751 def test_repr_large(self, size):
752 return self.basic_test_repr(size)
757 # pointers to data, so 8 bytes per size. Also like tuples, we make the
762 def test_compare(self, size):
763 l1 = [u''] * size
764 l2 = [u''] * size
767 l2 = [u''] * (size + 1)
770 l2 = [2] * size
778 def basic_test_concat(self, size):
779 l = [[]] * size
780 self.assertEqual(len(l), size)
782 self.assertEqual(len(l), size * 2)
785 def test_concat_small(self, size):
786 return self.basic_test_concat(size)
789 def test_concat_large(self, size):
790 return self.basic_test_concat(size)
792 def basic_test_inplace_concat(self, size):
793 l = [sys.stdout] * size
795 self.assertEqual(len(l), size * 2)
797 self.assertTrue(l[size - 1] is l[size + 1])
800 def test_inplace_concat_small(self, size):
801 return self.basic_test_inplace_concat(size)
804 def test_inplace_concat_large(self, size):
805 return self.basic_test_inplace_concat(size)
808 def test_contains(self, size):
809 l = [1, 2, 3, 4, 5] * size
810 self.assertEqual(len(l), size * 5)
816 def test_hash(self, size):
817 l = [0] * size
821 def test_index_and_slice(self, size):
822 l = [None] * size
823 self.assertEqual(len(l), size)
826 self.assertEqual(l[size - 1], None)
827 self.assertRaises(IndexError, operator.getitem, l, size)
832 self.assertEqual(l[size - 5:], [None] * 5)
833 self.assertEqual(l[size - 5:size], [None] * 5)
834 self.assertEqual(l[size - 6:size - 2], [None] * 4)
835 self.assertEqual(l[size:size], [])
836 self.assertEqual(l[size:size+5], [])
838 l[size - 2] = 5
839 self.assertEqual(len(l), size)
842 self.assertRaises(IndexError, operator.setitem, l, size, 6)
843 self.assertEqual(len(l), size)
845 l[size - 7:] = [1, 2, 3, 4, 5]
846 size -= 2
847 self.assertEqual(len(l), size)
851 size -= 2
852 self.assertEqual(len(l), size)
855 del l[size - 1]
856 size -= 1
857 self.assertEqual(len(l), size)
861 size -= 2
862 self.assertEqual(len(l), size)
866 size -= 1
867 self.assertEqual(len(l), size)
871 size -= 2
872 self.assertEqual(len(l), size)
876 def basic_test_repeat(self, size):
877 l = [] * size
879 l = [''] * size
880 self.assertEqual(len(l), size)
882 self.assertEqual(len(l), size * 2)
885 def test_repeat_small(self, size):
886 return self.basic_test_repeat(size)
889 def test_repeat_large(self, size):
890 return self.basic_test_repeat(size)
892 def basic_test_inplace_repeat(self, size):
894 l *= size
895 self.assertEqual(len(l), size)
899 l = [''] * size
901 self.assertEqual(len(l), size * 2)
902 self.assertTrue(l[size - 1] is l[-1])
905 def test_inplace_repeat_small(self, size):
906 size)
909 def test_inplace_repeat_large(self, size):
910 return self.basic_test_inplace_repeat(size)
912 def basic_test_repr(self, size):
913 l = [0] * size
916 self.assertEqual(len(s), size * 3)
919 self.assertEqual(s.count('0'), size)
922 def test_repr_small(self, size):
923 return self.basic_test_repr(size)
926 def test_repr_large(self, size):
927 return self.basic_test_repr(size)
929 # list overallocates ~1/8th of the total size (on first expansion) so
930 # the single list.append call puts memuse at 9 bytes per size.
932 def test_append(self, size):
933 l = [object()] * size
935 self.assertEqual(len(l), size+1)
940 def test_count(self, size):
941 l = [1, 2, 3, 4, 5] * size
942 self.assertEqual(l.count(1), size)
945 def basic_test_extend(self, size):
946 l = [file] * size
948 self.assertEqual(len(l), size * 2)
950 self.assertTrue(l[size - 1] is l[size + 1])
953 def test_extend_small(self, size):
954 return self.basic_test_extend(size)
957 def test_extend_large(self, size):
958 return self.basic_test_extend(size)
961 def test_index(self, size):
962 l = [1L, 2L, 3L, 4L, 5L] * size
963 size *= 5
965 self.assertEqual(l.index(5, size - 5), size - 1)
966 self.assertEqual(l.index(5, size - 5, size), size - 1)
967 self.assertRaises(ValueError, l.index, 1, size - 4, size)
972 def test_insert(self, size):
973 l = [1.0] * size
974 l.insert(size - 1, "A")
975 size += 1
976 self.assertEqual(len(l), size)
979 l.insert(size + 1, "B")
980 size += 1
981 self.assertEqual(len(l), size)
985 size += 1
986 self.assertEqual(len(l), size)
988 self.assertEqual(l[size - 3:], ["A", 1.0, "B"])
991 def test_pop(self, size):
992 l = [u"a", u"b", u"c", u"d", u"e"] * size
993 size *= 5
994 self.assertEqual(len(l), size)
997 size -= 1
998 self.assertEqual(len(l), size)
1003 size -= 1
1004 self.assertEqual(len(l), size)
1008 item = l.pop(size - 2)
1009 size -= 1
1010 self.assertEqual(len(l), size)
1015 def test_remove(self, size):
1016 l = [10] * size
1017 self.assertEqual(len(l), size)
1020 size -= 1
1021 self.assertEqual(len(l), size)
1026 size += 1
1027 self.assertEqual(len(l), size)
1030 size -= 1
1031 self.assertEqual(len(l), size)
1035 def test_reverse(self, size):
1036 l = [1, 2, 3, 4, 5] * size
1038 self.assertEqual(len(l), size * 5)
1043 def test_sort(self, size):
1044 l = [1, 2, 3, 4, 5] * size
1046 self.assertEqual(len(l), size * 5)
1047 self.assertEqual(l.count(1), size)
1053 @precisionbigmemtest(size=_1G, memuse=4)
1054 def test_repeat(self, size):
1057 b = buffer("AAAA")*size
1065 self.assertEqual(count, size*4)
