convert usage of fail* to assert*

1 files changed, 30 insertions, 30 deletions

diff --git a/Lib/test/test_peepholer.py b/Lib/test/test_peepholer.py
index 6638a5a..1f6efb5 100644
--- a/Lib/test/test_peepholer.py
+++ b/Lib/test/test_peepholer.py
@@ -25,8 +25,8 @@ class TestTranforms(unittest.TestCase):
                 del x
         asm = disassemble(unot)
         for elem in ('UNARY_NOT', 'POP_JUMP_IF_FALSE'):
-            self.assert_(elem not in asm)
-        self.assert_('POP_JUMP_IF_TRUE' in asm)
+            self.assertTrue(elem not in asm)
+        self.assertTrue('POP_JUMP_IF_TRUE' in asm)
 
     def test_elim_inversion_of_is_or_in(self):
         for line, elem in (
@@ -36,7 +36,7 @@ class TestTranforms(unittest.TestCase):
             ('not a not in b', '(in)',),
             ):
             asm = dis_single(line)
-            self.assert_(elem in asm)
+            self.assertTrue(elem in asm)
 
     def test_none_as_constant(self):
         # LOAD_GLOBAL None  -->  LOAD_CONST None
@@ -45,14 +45,14 @@ class TestTranforms(unittest.TestCase):
             return x
         asm = disassemble(f)
         for elem in ('LOAD_GLOBAL',):
-            self.assert_(elem not in asm)
+            self.assertTrue(elem not in asm)
         for elem in ('LOAD_CONST', '(None)'):
-            self.assert_(elem in asm)
+            self.assertTrue(elem in asm)
         def f():
             'Adding a docstring made this test fail in Py2.5.0'
             return None
-        self.assert_('LOAD_CONST' in disassemble(f))
-        self.assert_('LOAD_GLOBAL' not in disassemble(f))
+        self.assertTrue('LOAD_CONST' in disassemble(f))
+        self.assertTrue('LOAD_GLOBAL' not in disassemble(f))
 
     def test_while_one(self):
         # Skip over:  LOAD_CONST trueconst  POP_JUMP_IF_FALSE xx
@@ -62,9 +62,9 @@ class TestTranforms(unittest.TestCase):
             return list
         asm = disassemble(f)
         for elem in ('LOAD_CONST', 'POP_JUMP_IF_FALSE'):
-            self.assert_(elem not in asm)
+            self.assertTrue(elem not in asm)
         for elem in ('JUMP_ABSOLUTE',):
-            self.assert_(elem in asm)
+            self.assertTrue(elem in asm)
 
     def test_pack_unpack(self):
         for line, elem in (
@@ -73,9 +73,9 @@ class TestTranforms(unittest.TestCase):
             ('a, b, c = a, b, c', 'ROT_THREE',),
             ):
             asm = dis_single(line)
-            self.assert_(elem in asm)
-            self.assert_('BUILD_TUPLE' not in asm)
-            self.assert_('UNPACK_TUPLE' not in asm)
+            self.assertTrue(elem in asm)
+            self.assertTrue('BUILD_TUPLE' not in asm)
+            self.assertTrue('UNPACK_TUPLE' not in asm)
 
     def test_folding_of_tuples_of_constants(self):
         for line, elem in (
@@ -86,8 +86,8 @@ class TestTranforms(unittest.TestCase):
             ('((1, 2), 3, 4)', '(((1, 2), 3, 4))'),
             ):
             asm = dis_single(line)
-            self.assert_(elem in asm)
-            self.assert_('BUILD_TUPLE' not in asm)
+            self.assertTrue(elem in asm)
+            self.assertTrue('BUILD_TUPLE' not in asm)
 
         # Bug 1053819:  Tuple of constants misidentified when presented with:
         # . . . opcode_with_arg 100   unary_opcode   BUILD_TUPLE 1  . . .
@@ -125,17 +125,17 @@ class TestTranforms(unittest.TestCase):
             ('a = 13 | 7', '(15)'),                 # binary or
             ):
             asm = dis_single(line)
-            self.assert_(elem in asm, asm)
-            self.assert_('BINARY_' not in asm)
+            self.assertTrue(elem in asm, asm)
+            self.assertTrue('BINARY_' not in asm)
 
         # Verify that unfoldables are skipped
         asm = dis_single('a=2+"b"')
-        self.assert_('(2)' in asm)
-        self.assert_("('b')" in asm)
+        self.assertTrue('(2)' in asm)
+        self.assertTrue("('b')" in asm)
 
         # Verify that large sequences do not result from folding
         asm = dis_single('a="x"*1000')
-        self.assert_('(1000)' in asm)
+        self.assertTrue('(1000)' in asm)
 
     def test_folding_of_unaryops_on_constants(self):
         for line, elem in (
@@ -144,8 +144,8 @@ class TestTranforms(unittest.TestCase):
             ('~-2', '(1)'),                         # unary invert
         ):
             asm = dis_single(line)
-            self.assert_(elem in asm, asm)
-            self.assert_('UNARY_' not in asm)
+            self.assertTrue(elem in asm, asm)
+            self.assertTrue('UNARY_' not in asm)
 
         # Verify that unfoldables are skipped
         for line, elem in (
@@ -153,16 +153,16 @@ class TestTranforms(unittest.TestCase):
             ('~"abc"', "('abc')"),                  # unary invert
         ):
             asm = dis_single(line)
-            self.assert_(elem in asm, asm)
-            self.assert_('UNARY_' in asm)
+            self.assertTrue(elem in asm, asm)
+            self.assertTrue('UNARY_' in asm)
 
     def test_elim_extra_return(self):
         # RETURN LOAD_CONST None RETURN  -->  RETURN
         def f(x):
             return x
         asm = disassemble(f)
-        self.assert_('LOAD_CONST' not in asm)
-        self.assert_('(None)' not in asm)
+        self.assertTrue('LOAD_CONST' not in asm)
+        self.assertTrue('(None)' not in asm)
         self.assertEqual(asm.split().count('RETURN_VALUE'), 1)
 
     def test_elim_jump_to_return(self):
@@ -170,8 +170,8 @@ class TestTranforms(unittest.TestCase):
         def f(cond, true_value, false_value):
             return true_value if cond else false_value
         asm = disassemble(f)
-        self.assert_('JUMP_FORWARD' not in asm)
-        self.assert_('JUMP_ABSOLUTE' not in asm)
+        self.assertTrue('JUMP_FORWARD' not in asm)
+        self.assertTrue('JUMP_ABSOLUTE' not in asm)
         self.assertEqual(asm.split().count('RETURN_VALUE'), 2)
 
     def test_elim_jump_after_return1(self):
@@ -186,8 +186,8 @@ class TestTranforms(unittest.TestCase):
                 return 5
             return 6
         asm = disassemble(f)
-        self.assert_('JUMP_FORWARD' not in asm)
-        self.assert_('JUMP_ABSOLUTE' not in asm)
+        self.assertTrue('JUMP_FORWARD' not in asm)
+        self.assertTrue('JUMP_ABSOLUTE' not in asm)
         self.assertEqual(asm.split().count('RETURN_VALUE'), 6)
 
     def test_elim_jump_after_return2(self):
@@ -196,7 +196,7 @@ class TestTranforms(unittest.TestCase):
             while 1:
                 if cond1: return 4
         asm = disassemble(f)
-        self.assert_('JUMP_FORWARD' not in asm)
+        self.assertTrue('JUMP_FORWARD' not in asm)
         # There should be one jump for the while loop.
         self.assertEqual(asm.split().count('JUMP_ABSOLUTE'), 1)
         self.assertEqual(asm.split().count('RETURN_VALUE'), 2)