diff options
author | Benjamin Peterson <benjamin@python.org> | 2009-06-30 22:57:08 (GMT) |
---|---|---|
committer | Benjamin Peterson <benjamin@python.org> | 2009-06-30 22:57:08 (GMT) |
commit | 5c8da86f3a515ce1a6d5f27fd15e3c5f4d8e931e (patch) | |
tree | 41f38aca16748628d53906337f06fdf087f52314 /Lib/test/test_bigmem.py | |
parent | be96cf608fa656d7e53144cf85082ed5661e8c13 (diff) | |
download | cpython-5c8da86f3a515ce1a6d5f27fd15e3c5f4d8e931e.zip cpython-5c8da86f3a515ce1a6d5f27fd15e3c5f4d8e931e.tar.gz cpython-5c8da86f3a515ce1a6d5f27fd15e3c5f4d8e931e.tar.bz2 |
convert usage of fail* to assert*
Diffstat (limited to 'Lib/test/test_bigmem.py')
-rw-r--r-- | Lib/test/test_bigmem.py | 140 |
1 files changed, 70 insertions, 70 deletions
diff --git a/Lib/test/test_bigmem.py b/Lib/test/test_bigmem.py index 360bcb2..cb1b2f5 100644 --- a/Lib/test/test_bigmem.py +++ b/Lib/test/test_bigmem.py @@ -130,18 +130,18 @@ class StrTest(unittest.TestCase): except MemoryError: pass # acceptable on 32-bit else: - self.failUnless(s == eval(r)) + self.assertTrue(s == eval(r)) @bigmemtest(minsize=_2G, memuse=2) def test_endswith(self, size): SUBSTR = ' abc def ghi' s = '-' * size + SUBSTR - self.failUnless(s.endswith(SUBSTR)) - self.failUnless(s.endswith(s)) + self.assertTrue(s.endswith(SUBSTR)) + self.assertTrue(s.endswith(s)) s2 = '...' + s - self.failUnless(s2.endswith(s)) - self.failIf(s.endswith('a' + SUBSTR)) - self.failIf(SUBSTR.endswith(s)) + self.assertTrue(s2.endswith(s)) + self.assertFalse(s.endswith('a' + SUBSTR)) + self.assertFalse(SUBSTR.endswith(s)) @bigmemtest(minsize=_2G + 10, memuse=2) def test_expandtabs(self, size): @@ -191,62 +191,62 @@ class StrTest(unittest.TestCase): def test_isalnum(self, size): SUBSTR = '123456' s = 'a' * size + SUBSTR - self.failUnless(s.isalnum()) + self.assertTrue(s.isalnum()) s += '.' - self.failIf(s.isalnum()) + self.assertFalse(s.isalnum()) @bigmemtest(minsize=_2G, memuse=2) def test_isalpha(self, size): SUBSTR = 'zzzzzzz' s = 'a' * size + SUBSTR - self.failUnless(s.isalpha()) + self.assertTrue(s.isalpha()) s += '.' - self.failIf(s.isalpha()) + self.assertFalse(s.isalpha()) @bigmemtest(minsize=_2G, memuse=2) def test_isdigit(self, size): SUBSTR = '123456' s = '9' * size + SUBSTR - self.failUnless(s.isdigit()) + self.assertTrue(s.isdigit()) s += 'z' - self.failIf(s.isdigit()) + self.assertFalse(s.isdigit()) @bigmemtest(minsize=_2G, memuse=2) def test_islower(self, size): chars = ''.join([ chr(c) for c in range(255) if not chr(c).isupper() ]) repeats = size // len(chars) + 2 s = chars * repeats - self.failUnless(s.islower()) + self.assertTrue(s.islower()) s += 'A' - self.failIf(s.islower()) + self.assertFalse(s.islower()) @bigmemtest(minsize=_2G, memuse=2) def test_isspace(self, size): whitespace = ' \f\n\r\t\v' repeats = size // len(whitespace) + 2 s = whitespace * repeats - self.failUnless(s.isspace()) + self.assertTrue(s.isspace()) s += 'j' - self.failIf(s.isspace()) + self.assertFalse(s.isspace()) @bigmemtest(minsize=_2G, memuse=2) def test_istitle(self, size): SUBSTR = '123456' s = ''.join(['A', 'a' * size, SUBSTR]) - self.failUnless(s.istitle()) + self.assertTrue(s.istitle()) s += 'A' - self.failUnless(s.istitle()) + self.assertTrue(s.istitle()) s += 'aA' - self.failIf(s.istitle()) + self.assertFalse(s.istitle()) @bigmemtest(minsize=_2G, memuse=2) def test_isupper(self, size): chars = ''.join([ chr(c) for c in range(255) if not chr(c).islower() ]) repeats = size // len(chars) + 2 s = chars * repeats - self.failUnless(s.isupper()) + self.assertTrue(s.isupper()) s += 'a' - self.failIf(s.isupper()) + self.assertFalse(s.isupper()) @bigmemtest(minsize=_2G, memuse=2) def test_join(self, size): @@ -254,14 +254,14 @@ class StrTest(unittest.TestCase): x = s.join(['aaaaa', 'bbbbb']) self.assertEquals(x.count('a'), 5) self.assertEquals(x.count('b'), 5) - self.failUnless(x.startswith('aaaaaA')) - self.failUnless(x.endswith('Abbbbb')) + self.assertTrue(x.startswith('aaaaaA')) + self.assertTrue(x.endswith('Abbbbb')) @bigmemtest(minsize=_2G + 10, memuse=1) def test_ljust(self, size): SUBSTR = ' abc def ghi' s = SUBSTR.ljust(size) - self.failUnless(s.startswith(SUBSTR + ' ')) + self.assertTrue(s.startswith(SUBSTR + ' ')) self.assertEquals(len(s), size) self.assertEquals(s.strip(), SUBSTR.strip()) @@ -282,7 +282,7 @@ class StrTest(unittest.TestCase): s = SUBSTR.ljust(size) self.assertEquals(len(s), size) stripped = s.lstrip() - self.failUnless(stripped is s) + self.assertTrue(stripped is s) @bigmemtest(minsize=_2G + 10, memuse=2) def test_replace(self, size): @@ -333,7 +333,7 @@ class StrTest(unittest.TestCase): def test_rjust(self, size): SUBSTR = ' abc def ghi' s = SUBSTR.ljust(size) - self.failUnless(s.startswith(SUBSTR + ' ')) + self.assertTrue(s.startswith(SUBSTR + ' ')) self.assertEquals(len(s), size) self.assertEquals(s.strip(), SUBSTR.strip()) @@ -347,7 +347,7 @@ class StrTest(unittest.TestCase): s = SUBSTR.rjust(size) self.assertEquals(len(s), size) stripped = s.rstrip() - self.failUnless(stripped is s) + self.assertTrue(stripped is s) # The test takes about size bytes to build a string, and then about # sqrt(size) substrings of sqrt(size) in size and a list to @@ -399,9 +399,9 @@ class StrTest(unittest.TestCase): def test_startswith(self, size): SUBSTR = ' abc def ghi' s = '-' * size + SUBSTR - self.failUnless(s.startswith(s)) - self.failUnless(s.startswith('-' * size)) - self.failIf(s.startswith(SUBSTR)) + self.assertTrue(s.startswith(s)) + self.assertTrue(s.startswith('-' * size)) + self.assertFalse(s.startswith(SUBSTR)) @bigmemtest(minsize=_2G, memuse=1) def test_strip(self, size): @@ -430,8 +430,8 @@ class StrTest(unittest.TestCase): SUBSTR = 'SpaaHAaaAaham' s = SUBSTR * (size // len(SUBSTR) + 2) s = s.title() - self.failUnless(s.startswith((SUBSTR * 3).title())) - self.failUnless(s.endswith(SUBSTR.lower() * 3)) + self.assertTrue(s.startswith((SUBSTR * 3).title())) + self.assertTrue(s.endswith(SUBSTR.lower() * 3)) @bigmemtest(minsize=_2G, memuse=2) def test_translate(self, size): @@ -459,8 +459,8 @@ class StrTest(unittest.TestCase): def test_zfill(self, size): SUBSTR = '-568324723598234' s = SUBSTR.zfill(size) - self.failUnless(s.endswith('0' + SUBSTR[1:])) - self.failUnless(s.startswith('-0')) + self.assertTrue(s.endswith('0' + SUBSTR[1:])) + self.assertTrue(s.startswith('-0')) self.assertEquals(len(s), size) self.assertEquals(s.count('0'), size - len(SUBSTR)) @@ -468,12 +468,12 @@ class StrTest(unittest.TestCase): def test_format(self, size): s = '-' * size sf = '%s' % (s,) - self.failUnless(s == sf) + self.assertTrue(s == sf) del sf sf = '..%s..' % (s,) self.assertEquals(len(sf), len(s) + 4) - self.failUnless(sf.startswith('..-')) - self.failUnless(sf.endswith('-..')) + self.assertTrue(sf.startswith('..-')) + self.assertTrue(sf.endswith('-..')) del s, sf size //= 2 @@ -519,7 +519,7 @@ class StrTest(unittest.TestCase): @bigmemtest(minsize=2**32 / 5, memuse=6+2) def test_unicode_repr(self, size): s = u"\uAAAA" * size - self.failUnless(len(repr(s)) > size) + self.assertTrue(len(repr(s)) > size) # This test is meaningful even with size < 2G, as long as the # doubled string is > 2G (but it tests more if both are > 2G :) @@ -580,24 +580,24 @@ class StrTest(unittest.TestCase): edge = '-' * (size // 2) s = ''.join([edge, SUBSTR, edge]) del edge - self.failUnless(SUBSTR in s) - self.failIf(SUBSTR * 2 in s) - self.failUnless('-' in s) - self.failIf('a' in s) + self.assertTrue(SUBSTR in s) + self.assertFalse(SUBSTR * 2 in s) + self.assertTrue('-' in s) + self.assertFalse('a' in s) s += 'a' - self.failUnless('a' in s) + self.assertTrue('a' in s) @bigmemtest(minsize=_2G + 10, memuse=2) def test_compare(self, size): s1 = '-' * size s2 = '-' * size - self.failUnless(s1 == s2) + self.assertTrue(s1 == s2) del s2 s2 = s1 + 'a' - self.failIf(s1 == s2) + self.assertFalse(s1 == s2) del s2 s2 = '.' * size - self.failIf(s1 == s2) + self.assertFalse(s1 == s2) @bigmemtest(minsize=_2G + 10, memuse=1) def test_hash(self, size): @@ -611,7 +611,7 @@ class StrTest(unittest.TestCase): h1 = hash(s) del s s = '\x00' * (size + 1) - self.failIf(h1 == hash(s)) + self.assertFalse(h1 == hash(s)) class TupleTest(unittest.TestCase): @@ -628,13 +628,13 @@ class TupleTest(unittest.TestCase): def test_compare(self, size): t1 = (u'',) * size t2 = (u'',) * size - self.failUnless(t1 == t2) + self.assertTrue(t1 == t2) del t2 t2 = (u'',) * (size + 1) - self.failIf(t1 == t2) + self.assertFalse(t1 == t2) del t2 t2 = (1,) * size - self.failIf(t1 == t2) + self.assertFalse(t1 == t2) # Test concatenating into a single tuple of more than 2G in length, # and concatenating a tuple of more than 2G in length separately, so @@ -659,9 +659,9 @@ class TupleTest(unittest.TestCase): def test_contains(self, size): t = (1, 2, 3, 4, 5) * size self.assertEquals(len(t), size * 5) - self.failUnless(5 in t) - self.failIf((1, 2, 3, 4, 5) in t) - self.failIf(0 in t) + self.assertTrue(5 in t) + self.assertFalse((1, 2, 3, 4, 5) in t) + self.assertFalse(0 in t) @bigmemtest(minsize=_2G + 10, memuse=8) def test_hash(self, size): @@ -669,7 +669,7 @@ class TupleTest(unittest.TestCase): h1 = hash(t1) del t1 t2 = (0,) * (size + 1) - self.failIf(h1 == hash(t2)) + self.assertFalse(h1 == hash(t2)) @bigmemtest(minsize=_2G + 10, memuse=8) def test_index_and_slice(self, size): @@ -762,13 +762,13 @@ class ListTest(unittest.TestCase): def test_compare(self, size): l1 = [u''] * size l2 = [u''] * size - self.failUnless(l1 == l2) + self.assertTrue(l1 == l2) del l2 l2 = [u''] * (size + 1) - self.failIf(l1 == l2) + self.assertFalse(l1 == l2) del l2 l2 = [2] * size - self.failIf(l1 == l2) + self.assertFalse(l1 == l2) # Test concatenating into a single list of more than 2G in length, # and concatenating a list of more than 2G in length separately, so @@ -793,8 +793,8 @@ class ListTest(unittest.TestCase): l = [sys.stdout] * size l += l self.assertEquals(len(l), size * 2) - self.failUnless(l[0] is l[-1]) - self.failUnless(l[size - 1] is l[size + 1]) + self.assertTrue(l[0] is l[-1]) + self.assertTrue(l[size - 1] is l[size + 1]) @bigmemtest(minsize=_2G // 2 + 2, memuse=24) def test_inplace_concat_small(self, size): @@ -808,14 +808,14 @@ class ListTest(unittest.TestCase): def test_contains(self, size): l = [1, 2, 3, 4, 5] * size self.assertEquals(len(l), size * 5) - self.failUnless(5 in l) - self.failIf([1, 2, 3, 4, 5] in l) - self.failIf(0 in l) + self.assertTrue(5 in l) + self.assertFalse([1, 2, 3, 4, 5] in l) + self.assertFalse(0 in l) @bigmemtest(minsize=_2G + 10, memuse=8) def test_hash(self, size): l = [0] * size - self.failUnlessRaises(TypeError, hash, l) + self.assertRaises(TypeError, hash, l) @bigmemtest(minsize=_2G + 10, memuse=8) def test_index_and_slice(self, size): @@ -875,7 +875,7 @@ class ListTest(unittest.TestCase): # Like test_concat, split in two. def basic_test_repeat(self, size): l = [] * size - self.failIf(l) + self.assertFalse(l) l = [''] * size self.assertEquals(len(l), size) l = l * 2 @@ -893,13 +893,13 @@ class ListTest(unittest.TestCase): l = [''] l *= size self.assertEquals(len(l), size) - self.failUnless(l[0] is l[-1]) + self.assertTrue(l[0] is l[-1]) del l l = [''] * size l *= 2 self.assertEquals(len(l), size * 2) - self.failUnless(l[size - 1] is l[-1]) + self.assertTrue(l[size - 1] is l[-1]) @bigmemtest(minsize=_2G // 2 + 2, memuse=16) def test_inplace_repeat_small(self, size): @@ -933,8 +933,8 @@ class ListTest(unittest.TestCase): l = [object()] * size l.append(object()) self.assertEquals(len(l), size+1) - self.failUnless(l[-3] is l[-2]) - self.failIf(l[-2] is l[-1]) + self.assertTrue(l[-3] is l[-2]) + self.assertFalse(l[-2] is l[-1]) @bigmemtest(minsize=_2G // 5 + 2, memuse=8 * 5) def test_count(self, size): @@ -946,8 +946,8 @@ class ListTest(unittest.TestCase): l = [file] * size l.extend(l) self.assertEquals(len(l), size * 2) - self.failUnless(l[0] is l[-1]) - self.failUnless(l[size - 1] is l[size + 1]) + self.assertTrue(l[0] is l[-1]) + self.assertTrue(l[size - 1] is l[size + 1]) @bigmemtest(minsize=_2G // 2 + 2, memuse=16) def test_extend_small(self, size): |