convert old fail* assertions to assert*

1 files changed, 56 insertions, 56 deletions

diff --git a/Lib/test/test_bytes.py b/Lib/test/test_bytes.py
index 992f3d2..caea909 100644
--- a/Lib/test/test_bytes.py
+++ b/Lib/test/test_bytes.py
@@ -102,22 +102,22 @@ class BaseBytesTest(unittest.TestCase):
         b3 = self.type2test([1, 3])
 
         self.assertEqual(b1, b2)
-        self.failUnless(b2 != b3)
-        self.failUnless(b1 <= b2)
-        self.failUnless(b1 <= b3)
-        self.failUnless(b1 <  b3)
-        self.failUnless(b1 >= b2)
-        self.failUnless(b3 >= b2)
-        self.failUnless(b3 >  b2)
-
-        self.failIf(b1 != b2)
-        self.failIf(b2 == b3)
-        self.failIf(b1 >  b2)
-        self.failIf(b1 >  b3)
-        self.failIf(b1 >= b3)
-        self.failIf(b1 <  b2)
-        self.failIf(b3 <  b2)
-        self.failIf(b3 <= b2)
+        self.assertTrue(b2 != b3)
+        self.assertTrue(b1 <= b2)
+        self.assertTrue(b1 <= b3)
+        self.assertTrue(b1 <  b3)
+        self.assertTrue(b1 >= b2)
+        self.assertTrue(b3 >= b2)
+        self.assertTrue(b3 >  b2)
+
+        self.assertFalse(b1 != b2)
+        self.assertFalse(b2 == b3)
+        self.assertFalse(b1 >  b2)
+        self.assertFalse(b1 >  b3)
+        self.assertFalse(b1 >= b3)
+        self.assertFalse(b1 <  b2)
+        self.assertFalse(b3 <  b2)
+        self.assertFalse(b3 <= b2)
 
     def test_compare_to_str(self):
         warnings.simplefilter('ignore', BytesWarning)
@@ -220,27 +220,27 @@ class BaseBytesTest(unittest.TestCase):
 
     def test_contains(self):
         b = self.type2test(b"abc")
-        self.failUnless(ord('a') in b)
-        self.failUnless(int(ord('a')) in b)
-        self.failIf(200 in b)
-        self.failIf(200 in b)
+        self.assertTrue(ord('a') in b)
+        self.assertTrue(int(ord('a')) in b)
+        self.assertFalse(200 in b)
+        self.assertFalse(200 in b)
         self.assertRaises(ValueError, lambda: 300 in b)
         self.assertRaises(ValueError, lambda: -1 in b)
         self.assertRaises(TypeError, lambda: None in b)
         self.assertRaises(TypeError, lambda: float(ord('a')) in b)
         self.assertRaises(TypeError, lambda: "a" in b)
         for f in bytes, bytearray:
-            self.failUnless(f(b"") in b)
-            self.failUnless(f(b"a") in b)
-            self.failUnless(f(b"b") in b)
-            self.failUnless(f(b"c") in b)
-            self.failUnless(f(b"ab") in b)
-            self.failUnless(f(b"bc") in b)
-            self.failUnless(f(b"abc") in b)
-            self.failIf(f(b"ac") in b)
-            self.failIf(f(b"d") in b)
-            self.failIf(f(b"dab") in b)
-            self.failIf(f(b"abd") in b)
+            self.assertTrue(f(b"") in b)
+            self.assertTrue(f(b"a") in b)
+            self.assertTrue(f(b"b") in b)
+            self.assertTrue(f(b"c") in b)
+            self.assertTrue(f(b"ab") in b)
+            self.assertTrue(f(b"bc") in b)
+            self.assertTrue(f(b"abc") in b)
+            self.assertFalse(f(b"ac") in b)
+            self.assertFalse(f(b"d") in b)
+            self.assertFalse(f(b"dab") in b)
+            self.assertFalse(f(b"abd") in b)
 
     def test_fromhex(self):
         self.assertRaises(TypeError, self.type2test.fromhex)
@@ -626,7 +626,7 @@ class ByteArrayTest(BaseBytesTest):
         b += b"def"
         self.assertEqual(b, b"abcdef")
         self.assertEqual(b, b1)
-        self.failUnless(b is b1)
+        self.assertTrue(b is b1)
         b += b"xyz"
         self.assertEqual(b, b"abcdefxyz")
         try:
@@ -642,7 +642,7 @@ class ByteArrayTest(BaseBytesTest):
         b *= 3
         self.assertEqual(b, b"abcabcabc")
         self.assertEqual(b, b1)
-        self.failUnless(b is b1)
+        self.assertTrue(b is b1)
 
     def test_irepeat_1char(self):
         b = bytearray(b"x")
@@ -650,17 +650,17 @@ class ByteArrayTest(BaseBytesTest):
         b *= 100
         self.assertEqual(b, b"x"*100)
         self.assertEqual(b, b1)
-        self.failUnless(b is b1)
+        self.assertTrue(b is b1)
 
     def test_alloc(self):
         b = bytearray()
         alloc = b.__alloc__()
-        self.assert_(alloc >= 0)
+        self.assertTrue(alloc >= 0)
         seq = [alloc]
         for i in range(100):
             b += b"x"
             alloc = b.__alloc__()
-            self.assert_(alloc >= len(b))
+            self.assertTrue(alloc >= len(b))
             if alloc not in seq:
                 seq.append(alloc)
 
@@ -759,7 +759,7 @@ class ByteArrayTest(BaseBytesTest):
         a, b, c = bytearray(b"x").partition(b"y")
         self.assertEqual(b, b"")
         self.assertEqual(c, b"")
-        self.assert_(b is not c)
+        self.assertTrue(b is not c)
         b += b"!"
         self.assertEqual(c, b"")
         a, b, c = bytearray(b"x").partition(b"y")
@@ -769,7 +769,7 @@ class ByteArrayTest(BaseBytesTest):
         b, c, a = bytearray(b"x").rpartition(b"y")
         self.assertEqual(b, b"")
         self.assertEqual(c, b"")
-        self.assert_(b is not c)
+        self.assertTrue(b is not c)
         b += b"!"
         self.assertEqual(c, b"")
         c, b, a = bytearray(b"x").rpartition(b"y")
@@ -860,10 +860,10 @@ class AssortedBytesTest(unittest.TestCase):
         self.assertEqual(bytes(b"abc") <= b"ab", False)
 
     def test_doc(self):
-        self.failUnless(bytearray.__doc__ != None)
-        self.failUnless(bytearray.__doc__.startswith("bytearray("), bytearray.__doc__)
-        self.failUnless(bytes.__doc__ != None)
-        self.failUnless(bytes.__doc__.startswith("bytes("), bytes.__doc__)
+        self.assertTrue(bytearray.__doc__ != None)
+        self.assertTrue(bytearray.__doc__.startswith("bytearray("), bytearray.__doc__)
+        self.assertTrue(bytes.__doc__ != None)
+        self.assertTrue(bytes.__doc__.startswith("bytes("), bytes.__doc__)
 
     def test_from_bytearray(self):
         sample = bytes(b"Hello world\n\x80\x81\xfe\xff")
@@ -920,7 +920,7 @@ class AssortedBytesTest(unittest.TestCase):
     def test_return_self(self):
         # bytearray.replace must always return a new bytearray
         b = bytearray()
-        self.failIf(b.replace(b'', b'') is b)
+        self.assertFalse(b.replace(b'', b'') is b)
 
     def test_compare(self):
         if sys.flags.bytes_warning:
@@ -997,20 +997,20 @@ class ByteArraySubclass(bytearray):
 class ByteArraySubclassTest(unittest.TestCase):
 
     def test_basic(self):
-        self.assert_(issubclass(ByteArraySubclass, bytearray))
-        self.assert_(isinstance(ByteArraySubclass(), bytearray))
+        self.assertTrue(issubclass(ByteArraySubclass, bytearray))
+        self.assertTrue(isinstance(ByteArraySubclass(), bytearray))
 
         a, b = b"abcd", b"efgh"
         _a, _b = ByteArraySubclass(a), ByteArraySubclass(b)
 
         # test comparison operators with subclass instances
-        self.assert_(_a == _a)
-        self.assert_(_a != _b)
-        self.assert_(_a < _b)
-        self.assert_(_a <= _b)
-        self.assert_(_b >= _a)
-        self.assert_(_b > _a)
-        self.assert_(_a is not a)
+        self.assertTrue(_a == _a)
+        self.assertTrue(_a != _b)
+        self.assertTrue(_a < _b)
+        self.assertTrue(_a <= _b)
+        self.assertTrue(_b >= _a)
+        self.assertTrue(_b > _a)
+        self.assertTrue(_a is not a)
 
         # test concat of subclass instances
         self.assertEqual(a + b, _a + _b)
@@ -1018,7 +1018,7 @@ class ByteArraySubclassTest(unittest.TestCase):
         self.assertEqual(a + b, _a + b)
 
         # test repeat
-        self.assert_(a*5 == _a*5)
+        self.assertTrue(a*5 == _a*5)
 
     def test_join(self):
         # Make sure join returns a NEW object for single item sequences
@@ -1026,12 +1026,12 @@ class ByteArraySubclassTest(unittest.TestCase):
         # Make sure that it is of the appropriate type.
         s1 = ByteArraySubclass(b"abcd")
         s2 = bytearray().join([s1])
-        self.assert_(s1 is not s2)
-        self.assert_(type(s2) is bytearray, type(s2))
+        self.assertTrue(s1 is not s2)
+        self.assertTrue(type(s2) is bytearray, type(s2))
 
         # Test reverse, calling join on subclass
         s3 = s1.join([b"abcd"])
-        self.assert_(type(s3) is bytearray)
+        self.assertTrue(type(s3) is bytearray)
 
     def test_pickle(self):
         a = ByteArraySubclass(b"abcd")