mirror of
https://github.com/python/cpython.git
synced 2025-08-03 08:34:29 +00:00
convert usage of fail* to assert*
This commit is contained in:
Benjamin Peterson
parent
be96cf608f
commit
5c8da86f3a
268 changed files with 5017 additions and 5017 deletions
|
|
@ -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):
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue