diff --git a/Lib/lib2to3/fixes/fix_dict.py b/Lib/lib2to3/fixes/fix_dict.py
index ce973fd..7c37fad 100644
--- a/Lib/lib2to3/fixes/fix_dict.py
+++ b/Lib/lib2to3/fixes/fix_dict.py
@@ -66,7 +66,7 @@
         new = pytree.Node(syms.power, args)
         if not special:
             new.prefix = ""
-            new = Call(Name(isiter and "iter" or "list"), [new])
+            new = Call(Name("iter" if isiter else "list"), [new])
         if tail:
             new = pytree.Node(syms.power, [new] + tail)
         new.prefix = node.prefix
diff --git a/Lib/lib2to3/refactor.py b/Lib/lib2to3/refactor.py
old mode 100755
new mode 100644
diff --git a/Lib/lib2to3/tests/test_fixers.py b/Lib/lib2to3/tests/test_fixers.py
index 2f87fb2..c0f1e37 100755
--- a/Lib/lib2to3/tests/test_fixers.py
+++ b/Lib/lib2to3/tests/test_fixers.py
@@ -32,20 +32,20 @@
         before = support.reformat(before)
         after = support.reformat(after)
         tree = self.refactor.refactor_string(before, self.filename)
-        self.failUnlessEqual(after, str(tree))
+        self.assertEqual(after, str(tree))
         return tree
 
     def check(self, before, after, ignore_warnings=False):
         tree = self._check(before, after)
-        self.failUnless(tree.was_changed)
+        self.assertTrue(tree.was_changed)
         if not ignore_warnings:
-            self.failUnlessEqual(self.fixer_log, [])
+            self.assertEqual(self.fixer_log, [])
 
     def warns(self, before, after, message, unchanged=False):
         tree = self._check(before, after)
-        self.failUnless(message in "".join(self.fixer_log))
+        self.assertTrue(message in "".join(self.fixer_log))
         if not unchanged:
-            self.failUnless(tree.was_changed)
+            self.assertTrue(tree.was_changed)
 
     def warns_unchanged(self, before, message):
         self.warns(before, before, message, unchanged=True)
@@ -53,7 +53,7 @@
     def unchanged(self, before, ignore_warnings=False):
         self._check(before, before)
         if not ignore_warnings:
-            self.failUnlessEqual(self.fixer_log, [])
+            self.assertEqual(self.fixer_log, [])
 
     def assert_runs_after(self, *names):
         fixes = [self.fixer]
diff --git a/Lib/lib2to3/tests/test_pytree.py b/Lib/lib2to3/tests/test_pytree.py
index 83a9b18..a162aae 100755
--- a/Lib/lib2to3/tests/test_pytree.py
+++ b/Lib/lib2to3/tests/test_pytree.py
@@ -81,10 +81,10 @@
     def test_leaf_prefix(self):
         l1 = pytree.Leaf(100, "foo")
         self.assertEqual(l1.prefix, "")
-        self.failIf(l1.was_changed)
+        self.assertFalse(l1.was_changed)
         l1.prefix = "  ##\n\n"
         self.assertEqual(l1.prefix, "  ##\n\n")
-        self.failUnless(l1.was_changed)
+        self.assertTrue(l1.was_changed)
 
     def test_node(self):
         l1 = pytree.Leaf(100, "foo")
@@ -154,13 +154,13 @@
         l3 = pytree.Leaf(100, "bar")
         n1 = pytree.Node(1000, [l1, l2, l3])
         self.assertEqual(n1.children, [l1, l2, l3])
-        self.failUnless(isinstance(n1.children, list))
-        self.failIf(n1.was_changed)
+        self.assertTrue(isinstance(n1.children, list))
+        self.assertFalse(n1.was_changed)
         l2new = pytree.Leaf(100, "-")
         l2.replace(l2new)
         self.assertEqual(n1.children, [l1, l2new, l3])
-        self.failUnless(isinstance(n1.children, list))
-        self.failUnless(n1.was_changed)
+        self.assertTrue(isinstance(n1.children, list))
+        self.assertTrue(n1.was_changed)
 
     def test_replace_with_list(self):
         l1 = pytree.Leaf(100, "foo")
@@ -170,7 +170,7 @@
 
         l2.replace([pytree.Leaf(100, "*"), pytree.Leaf(100, "*")])
         self.assertEqual(str(n1), "foo**bar")
-        self.failUnless(isinstance(n1.children, list))
+        self.assertTrue(isinstance(n1.children, list))
 
     def test_post_order(self):
         l1 = pytree.Leaf(100, "foo")
@@ -186,34 +186,34 @@
 
     def test_changed(self):
         l1 = pytree.Leaf(100, "f")
-        self.failIf(l1.was_changed)
+        self.assertFalse(l1.was_changed)
         l1.changed()
-        self.failUnless(l1.was_changed)
+        self.assertTrue(l1.was_changed)
 
         l1 = pytree.Leaf(100, "f")
         n1 = pytree.Node(1000, [l1])
-        self.failIf(n1.was_changed)
+        self.assertFalse(n1.was_changed)
         n1.changed()
-        self.failUnless(n1.was_changed)
+        self.assertTrue(n1.was_changed)
 
         l1 = pytree.Leaf(100, "foo")
         l2 = pytree.Leaf(100, "+")
         l3 = pytree.Leaf(100, "bar")
         n1 = pytree.Node(1000, [l1, l2, l3])
         n2 = pytree.Node(1000, [n1])
-        self.failIf(l1.was_changed)
-        self.failIf(n1.was_changed)
-        self.failIf(n2.was_changed)
+        self.assertFalse(l1.was_changed)
+        self.assertFalse(n1.was_changed)
+        self.assertFalse(n2.was_changed)
 
         n1.changed()
-        self.failUnless(n1.was_changed)
-        self.failUnless(n2.was_changed)
-        self.failIf(l1.was_changed)
+        self.assertTrue(n1.was_changed)
+        self.assertTrue(n2.was_changed)
+        self.assertFalse(l1.was_changed)
 
     def test_leaf_constructor_prefix(self):
         for prefix in ("xyz_", ""):
             l1 = pytree.Leaf(100, "self", prefix=prefix)
-            self.failUnless(str(l1), prefix + "self")
+            self.assertTrue(str(l1), prefix + "self")
             self.assertEqual(l1.prefix, prefix)
 
     def test_node_constructor_prefix(self):
@@ -221,7 +221,7 @@
             l1 = pytree.Leaf(100, "self")
             l2 = pytree.Leaf(100, "foo", prefix="_")
             n1 = pytree.Node(1000, [l1, l2], prefix=prefix)
-            self.failUnless(str(n1), prefix + "self_foo")
+            self.assertTrue(str(n1), prefix + "self_foo")
             self.assertEqual(n1.prefix, prefix)
             self.assertEqual(l1.prefix, prefix)
             self.assertEqual(l2.prefix, "_")
@@ -237,8 +237,8 @@
         self.assertEqual(l1.parent, n1)
         self.assertEqual(n1.parent, None)
         self.assertEqual(n2.parent, None)
-        self.failIf(n1.was_changed)
-        self.failUnless(n2.was_changed)
+        self.assertFalse(n1.was_changed)
+        self.assertTrue(n2.was_changed)
 
         self.assertEqual(l2.remove(), 1)
         self.assertEqual(l1.remove(), 0)
@@ -246,8 +246,8 @@
         self.assertEqual(l1.parent, None)
         self.assertEqual(n1.parent, None)
         self.assertEqual(n2.parent, None)
-        self.failUnless(n1.was_changed)
-        self.failUnless(n2.was_changed)
+        self.assertTrue(n1.was_changed)
+        self.assertTrue(n2.was_changed)
 
     def test_remove_parentless(self):
         n1 = pytree.Node(1000, [])
@@ -316,7 +316,7 @@
         n2 = pytree.Node(1000, [])
         p1 = pytree.Node(1000, [n1, n2])
 
-        self.failUnless(n1.next_sibling is n2)
+        self.assertTrue(n1.next_sibling is n2)
         self.assertEqual(n2.next_sibling, None)
         self.assertEqual(p1.next_sibling, None)
 
@@ -325,7 +325,7 @@
         l2 = pytree.Leaf(100, "b")
         p1 = pytree.Node(1000, [l1, l2])
 
-        self.failUnless(l1.next_sibling is l2)
+        self.assertTrue(l1.next_sibling is l2)
         self.assertEqual(l2.next_sibling, None)
         self.assertEqual(p1.next_sibling, None)
 
@@ -334,7 +334,7 @@
         n2 = pytree.Node(1000, [])
         p1 = pytree.Node(1000, [n1, n2])
 
-        self.failUnless(n2.prev_sibling is n1)
+        self.assertTrue(n2.prev_sibling is n1)
         self.assertEqual(n1.prev_sibling, None)
         self.assertEqual(p1.prev_sibling, None)
 
@@ -343,7 +343,7 @@
         l2 = pytree.Leaf(100, "b")
         p1 = pytree.Node(1000, [l1, l2])
 
-        self.failUnless(l2.prev_sibling is l1)
+        self.assertTrue(l2.prev_sibling is l1)
         self.assertEqual(l1.prev_sibling, None)
         self.assertEqual(p1.prev_sibling, None)
 
@@ -416,7 +416,7 @@
         r = {}
         self.assertTrue(pw.match_seq([l1, l3], r))
         self.assertEqual(r, {"pl": l3, "pw": [l1, l3]})
-        self.assert_(r["pl"] is l3)
+        self.assertTrue(r["pl"] is l3)
         r = {}
 
     def test_generate_matches(self):
@@ -459,5 +459,5 @@
         l3 = pytree.Leaf(8, ")")
         node = pytree.Node(331, [l1, l2, l3])
         r = {}
-        self.assert_(pattern.match(node, r))
+        self.assertTrue(pattern.match(node, r))
         self.assertEqual(r["args"], [l2])
diff --git a/Lib/lib2to3/tests/test_util.py b/Lib/lib2to3/tests/test_util.py
index 1de7a83..ef3256d 100644
--- a/Lib/lib2to3/tests/test_util.py
+++ b/Lib/lib2to3/tests/test_util.py
@@ -33,15 +33,15 @@
         return fixer_util.is_tuple(parse(string, strip_levels=2))
 
     def test_valid(self):
-        self.failUnless(self.is_tuple("(a, b)"))
-        self.failUnless(self.is_tuple("(a, (b, c))"))
-        self.failUnless(self.is_tuple("((a, (b, c)),)"))
-        self.failUnless(self.is_tuple("(a,)"))
-        self.failUnless(self.is_tuple("()"))
+        self.assertTrue(self.is_tuple("(a, b)"))
+        self.assertTrue(self.is_tuple("(a, (b, c))"))
+        self.assertTrue(self.is_tuple("((a, (b, c)),)"))
+        self.assertTrue(self.is_tuple("(a,)"))
+        self.assertTrue(self.is_tuple("()"))
 
     def test_invalid(self):
-        self.failIf(self.is_tuple("(a)"))
-        self.failIf(self.is_tuple("('foo') % (b, c)"))
+        self.assertFalse(self.is_tuple("(a)"))
+        self.assertFalse(self.is_tuple("('foo') % (b, c)"))
 
 
 class Test_is_list(support.TestCase):
@@ -49,14 +49,14 @@
         return fixer_util.is_list(parse(string, strip_levels=2))
 
     def test_valid(self):
-        self.failUnless(self.is_list("[]"))
-        self.failUnless(self.is_list("[a]"))
-        self.failUnless(self.is_list("[a, b]"))
-        self.failUnless(self.is_list("[a, [b, c]]"))
-        self.failUnless(self.is_list("[[a, [b, c]],]"))
+        self.assertTrue(self.is_list("[]"))
+        self.assertTrue(self.is_list("[a]"))
+        self.assertTrue(self.is_list("[a, b]"))
+        self.assertTrue(self.is_list("[a, [b, c]]"))
+        self.assertTrue(self.is_list("[[a, [b, c]],]"))
 
     def test_invalid(self):
-        self.failIf(self.is_list("[]+[]"))
+        self.assertFalse(self.is_list("[]+[]"))
 
 
 class Test_Attr(MacroTestCase):
@@ -102,9 +102,9 @@
                          (None, "a", "import b, c, d"))
         for package, name, import_ in failing_tests:
             n = self.does_tree_import(package, name, import_ + "\n" + string)
-            self.failIf(n)
+            self.assertFalse(n)
             n = self.does_tree_import(package, name, string + "\n" + import_)
-            self.failIf(n)
+            self.assertFalse(n)
 
         passing_tests = (("a", "a", "from a import a"),
                          ("x", "a", "from x import a"),
@@ -115,9 +115,9 @@
                          (None, "a", "import b, c, a, d"))
         for package, name, import_ in passing_tests:
             n = self.does_tree_import(package, name, import_ + "\n" + string)
-            self.failUnless(n)
+            self.assertTrue(n)
             n = self.does_tree_import(package, name, string + "\n" + import_)
-            self.failUnless(n)
+            self.assertTrue(n)
 
     def test_in_function(self):
         self.try_with("def foo():\n\tbar.baz()\n\tstart=3")
@@ -127,226 +127,226 @@
         return fixer_util.find_binding(name, parse(string), package)
 
     def test_simple_assignment(self):
-        self.failUnless(self.find_binding("a", "a = b"))
-        self.failUnless(self.find_binding("a", "a = [b, c, d]"))
-        self.failUnless(self.find_binding("a", "a = foo()"))
-        self.failUnless(self.find_binding("a", "a = foo().foo.foo[6][foo]"))
-        self.failIf(self.find_binding("a", "foo = a"))
-        self.failIf(self.find_binding("a", "foo = (a, b, c)"))
+        self.assertTrue(self.find_binding("a", "a = b"))
+        self.assertTrue(self.find_binding("a", "a = [b, c, d]"))
+        self.assertTrue(self.find_binding("a", "a = foo()"))
+        self.assertTrue(self.find_binding("a", "a = foo().foo.foo[6][foo]"))
+        self.assertFalse(self.find_binding("a", "foo = a"))
+        self.assertFalse(self.find_binding("a", "foo = (a, b, c)"))
 
     def test_tuple_assignment(self):
-        self.failUnless(self.find_binding("a", "(a,) = b"))
-        self.failUnless(self.find_binding("a", "(a, b, c) = [b, c, d]"))
-        self.failUnless(self.find_binding("a", "(c, (d, a), b) = foo()"))
-        self.failUnless(self.find_binding("a", "(a, b) = foo().foo[6][foo]"))
-        self.failIf(self.find_binding("a", "(foo, b) = (b, a)"))
-        self.failIf(self.find_binding("a", "(foo, (b, c)) = (a, b, c)"))
+        self.assertTrue(self.find_binding("a", "(a,) = b"))
+        self.assertTrue(self.find_binding("a", "(a, b, c) = [b, c, d]"))
+        self.assertTrue(self.find_binding("a", "(c, (d, a), b) = foo()"))
+        self.assertTrue(self.find_binding("a", "(a, b) = foo().foo[6][foo]"))
+        self.assertFalse(self.find_binding("a", "(foo, b) = (b, a)"))
+        self.assertFalse(self.find_binding("a", "(foo, (b, c)) = (a, b, c)"))
 
     def test_list_assignment(self):
-        self.failUnless(self.find_binding("a", "[a] = b"))
-        self.failUnless(self.find_binding("a", "[a, b, c] = [b, c, d]"))
-        self.failUnless(self.find_binding("a", "[c, [d, a], b] = foo()"))
-        self.failUnless(self.find_binding("a", "[a, b] = foo().foo[a][foo]"))
-        self.failIf(self.find_binding("a", "[foo, b] = (b, a)"))
-        self.failIf(self.find_binding("a", "[foo, [b, c]] = (a, b, c)"))
+        self.assertTrue(self.find_binding("a", "[a] = b"))
+        self.assertTrue(self.find_binding("a", "[a, b, c] = [b, c, d]"))
+        self.assertTrue(self.find_binding("a", "[c, [d, a], b] = foo()"))
+        self.assertTrue(self.find_binding("a", "[a, b] = foo().foo[a][foo]"))
+        self.assertFalse(self.find_binding("a", "[foo, b] = (b, a)"))
+        self.assertFalse(self.find_binding("a", "[foo, [b, c]] = (a, b, c)"))
 
     def test_invalid_assignments(self):
-        self.failIf(self.find_binding("a", "foo.a = 5"))
-        self.failIf(self.find_binding("a", "foo[a] = 5"))
-        self.failIf(self.find_binding("a", "foo(a) = 5"))
-        self.failIf(self.find_binding("a", "foo(a, b) = 5"))
+        self.assertFalse(self.find_binding("a", "foo.a = 5"))
+        self.assertFalse(self.find_binding("a", "foo[a] = 5"))
+        self.assertFalse(self.find_binding("a", "foo(a) = 5"))
+        self.assertFalse(self.find_binding("a", "foo(a, b) = 5"))
 
     def test_simple_import(self):
-        self.failUnless(self.find_binding("a", "import a"))
-        self.failUnless(self.find_binding("a", "import b, c, a, d"))
-        self.failIf(self.find_binding("a", "import b"))
-        self.failIf(self.find_binding("a", "import b, c, d"))
+        self.assertTrue(self.find_binding("a", "import a"))
+        self.assertTrue(self.find_binding("a", "import b, c, a, d"))
+        self.assertFalse(self.find_binding("a", "import b"))
+        self.assertFalse(self.find_binding("a", "import b, c, d"))
 
     def test_from_import(self):
-        self.failUnless(self.find_binding("a", "from x import a"))
-        self.failUnless(self.find_binding("a", "from a import a"))
-        self.failUnless(self.find_binding("a", "from x import b, c, a, d"))
-        self.failUnless(self.find_binding("a", "from x.b import a"))
-        self.failUnless(self.find_binding("a", "from x.b import b, c, a, d"))
-        self.failIf(self.find_binding("a", "from a import b"))
-        self.failIf(self.find_binding("a", "from a.d import b"))
-        self.failIf(self.find_binding("a", "from d.a import b"))
+        self.assertTrue(self.find_binding("a", "from x import a"))
+        self.assertTrue(self.find_binding("a", "from a import a"))
+        self.assertTrue(self.find_binding("a", "from x import b, c, a, d"))
+        self.assertTrue(self.find_binding("a", "from x.b import a"))
+        self.assertTrue(self.find_binding("a", "from x.b import b, c, a, d"))
+        self.assertFalse(self.find_binding("a", "from a import b"))
+        self.assertFalse(self.find_binding("a", "from a.d import b"))
+        self.assertFalse(self.find_binding("a", "from d.a import b"))
 
     def test_import_as(self):
-        self.failUnless(self.find_binding("a", "import b as a"))
-        self.failUnless(self.find_binding("a", "import b as a, c, a as f, d"))
-        self.failIf(self.find_binding("a", "import a as f"))
-        self.failIf(self.find_binding("a", "import b, c as f, d as e"))
+        self.assertTrue(self.find_binding("a", "import b as a"))
+        self.assertTrue(self.find_binding("a", "import b as a, c, a as f, d"))
+        self.assertFalse(self.find_binding("a", "import a as f"))
+        self.assertFalse(self.find_binding("a", "import b, c as f, d as e"))
 
     def test_from_import_as(self):
-        self.failUnless(self.find_binding("a", "from x import b as a"))
-        self.failUnless(self.find_binding("a", "from x import g as a, d as b"))
-        self.failUnless(self.find_binding("a", "from x.b import t as a"))
-        self.failUnless(self.find_binding("a", "from x.b import g as a, d"))
-        self.failIf(self.find_binding("a", "from a import b as t"))
-        self.failIf(self.find_binding("a", "from a.d import b as t"))
-        self.failIf(self.find_binding("a", "from d.a import b as t"))
+        self.assertTrue(self.find_binding("a", "from x import b as a"))
+        self.assertTrue(self.find_binding("a", "from x import g as a, d as b"))
+        self.assertTrue(self.find_binding("a", "from x.b import t as a"))
+        self.assertTrue(self.find_binding("a", "from x.b import g as a, d"))
+        self.assertFalse(self.find_binding("a", "from a import b as t"))
+        self.assertFalse(self.find_binding("a", "from a.d import b as t"))
+        self.assertFalse(self.find_binding("a", "from d.a import b as t"))
 
     def test_simple_import_with_package(self):
-        self.failUnless(self.find_binding("b", "import b"))
-        self.failUnless(self.find_binding("b", "import b, c, d"))
-        self.failIf(self.find_binding("b", "import b", "b"))
-        self.failIf(self.find_binding("b", "import b, c, d", "c"))
+        self.assertTrue(self.find_binding("b", "import b"))
+        self.assertTrue(self.find_binding("b", "import b, c, d"))
+        self.assertFalse(self.find_binding("b", "import b", "b"))
+        self.assertFalse(self.find_binding("b", "import b, c, d", "c"))
 
     def test_from_import_with_package(self):
-        self.failUnless(self.find_binding("a", "from x import a", "x"))
-        self.failUnless(self.find_binding("a", "from a import a", "a"))
-        self.failUnless(self.find_binding("a", "from x import *", "x"))
-        self.failUnless(self.find_binding("a", "from x import b, c, a, d", "x"))
-        self.failUnless(self.find_binding("a", "from x.b import a", "x.b"))
-        self.failUnless(self.find_binding("a", "from x.b import *", "x.b"))
-        self.failUnless(self.find_binding("a", "from x.b import b, c, a, d", "x.b"))
-        self.failIf(self.find_binding("a", "from a import b", "a"))
-        self.failIf(self.find_binding("a", "from a.d import b", "a.d"))
-        self.failIf(self.find_binding("a", "from d.a import b", "a.d"))
-        self.failIf(self.find_binding("a", "from x.y import *", "a.b"))
+        self.assertTrue(self.find_binding("a", "from x import a", "x"))
+        self.assertTrue(self.find_binding("a", "from a import a", "a"))
+        self.assertTrue(self.find_binding("a", "from x import *", "x"))
+        self.assertTrue(self.find_binding("a", "from x import b, c, a, d", "x"))
+        self.assertTrue(self.find_binding("a", "from x.b import a", "x.b"))
+        self.assertTrue(self.find_binding("a", "from x.b import *", "x.b"))
+        self.assertTrue(self.find_binding("a", "from x.b import b, c, a, d", "x.b"))
+        self.assertFalse(self.find_binding("a", "from a import b", "a"))
+        self.assertFalse(self.find_binding("a", "from a.d import b", "a.d"))
+        self.assertFalse(self.find_binding("a", "from d.a import b", "a.d"))
+        self.assertFalse(self.find_binding("a", "from x.y import *", "a.b"))
 
     def test_import_as_with_package(self):
-        self.failIf(self.find_binding("a", "import b.c as a", "b.c"))
-        self.failIf(self.find_binding("a", "import a as f", "f"))
-        self.failIf(self.find_binding("a", "import a as f", "a"))
+        self.assertFalse(self.find_binding("a", "import b.c as a", "b.c"))
+        self.assertFalse(self.find_binding("a", "import a as f", "f"))
+        self.assertFalse(self.find_binding("a", "import a as f", "a"))
 
     def test_from_import_as_with_package(self):
         # Because it would take a lot of special-case code in the fixers
         # to deal with from foo import bar as baz, we'll simply always
         # fail if there is an "from ... import ... as ..."
-        self.failIf(self.find_binding("a", "from x import b as a", "x"))
-        self.failIf(self.find_binding("a", "from x import g as a, d as b", "x"))
-        self.failIf(self.find_binding("a", "from x.b import t as a", "x.b"))
-        self.failIf(self.find_binding("a", "from x.b import g as a, d", "x.b"))
-        self.failIf(self.find_binding("a", "from a import b as t", "a"))
-        self.failIf(self.find_binding("a", "from a import b as t", "b"))
-        self.failIf(self.find_binding("a", "from a import b as t", "t"))
+        self.assertFalse(self.find_binding("a", "from x import b as a", "x"))
+        self.assertFalse(self.find_binding("a", "from x import g as a, d as b", "x"))
+        self.assertFalse(self.find_binding("a", "from x.b import t as a", "x.b"))
+        self.assertFalse(self.find_binding("a", "from x.b import g as a, d", "x.b"))
+        self.assertFalse(self.find_binding("a", "from a import b as t", "a"))
+        self.assertFalse(self.find_binding("a", "from a import b as t", "b"))
+        self.assertFalse(self.find_binding("a", "from a import b as t", "t"))
 
     def test_function_def(self):
-        self.failUnless(self.find_binding("a", "def a(): pass"))
-        self.failUnless(self.find_binding("a", "def a(b, c, d): pass"))
-        self.failUnless(self.find_binding("a", "def a(): b = 7"))
-        self.failIf(self.find_binding("a", "def d(b, (c, a), e): pass"))
-        self.failIf(self.find_binding("a", "def d(a=7): pass"))
-        self.failIf(self.find_binding("a", "def d(a): pass"))
-        self.failIf(self.find_binding("a", "def d(): a = 7"))
+        self.assertTrue(self.find_binding("a", "def a(): pass"))
+        self.assertTrue(self.find_binding("a", "def a(b, c, d): pass"))
+        self.assertTrue(self.find_binding("a", "def a(): b = 7"))
+        self.assertFalse(self.find_binding("a", "def d(b, (c, a), e): pass"))
+        self.assertFalse(self.find_binding("a", "def d(a=7): pass"))
+        self.assertFalse(self.find_binding("a", "def d(a): pass"))
+        self.assertFalse(self.find_binding("a", "def d(): a = 7"))
 
         s = """
             def d():
                 def a():
                     pass"""
-        self.failIf(self.find_binding("a", s))
+        self.assertFalse(self.find_binding("a", s))
 
     def test_class_def(self):
-        self.failUnless(self.find_binding("a", "class a: pass"))
-        self.failUnless(self.find_binding("a", "class a(): pass"))
-        self.failUnless(self.find_binding("a", "class a(b): pass"))
-        self.failUnless(self.find_binding("a", "class a(b, c=8): pass"))
-        self.failIf(self.find_binding("a", "class d: pass"))
-        self.failIf(self.find_binding("a", "class d(a): pass"))
-        self.failIf(self.find_binding("a", "class d(b, a=7): pass"))
-        self.failIf(self.find_binding("a", "class d(b, *a): pass"))
-        self.failIf(self.find_binding("a", "class d(b, **a): pass"))
-        self.failIf(self.find_binding("a", "class d: a = 7"))
+        self.assertTrue(self.find_binding("a", "class a: pass"))
+        self.assertTrue(self.find_binding("a", "class a(): pass"))
+        self.assertTrue(self.find_binding("a", "class a(b): pass"))
+        self.assertTrue(self.find_binding("a", "class a(b, c=8): pass"))
+        self.assertFalse(self.find_binding("a", "class d: pass"))
+        self.assertFalse(self.find_binding("a", "class d(a): pass"))
+        self.assertFalse(self.find_binding("a", "class d(b, a=7): pass"))
+        self.assertFalse(self.find_binding("a", "class d(b, *a): pass"))
+        self.assertFalse(self.find_binding("a", "class d(b, **a): pass"))
+        self.assertFalse(self.find_binding("a", "class d: a = 7"))
 
         s = """
             class d():
                 class a():
                     pass"""
-        self.failIf(self.find_binding("a", s))
+        self.assertFalse(self.find_binding("a", s))
 
     def test_for(self):
-        self.failUnless(self.find_binding("a", "for a in r: pass"))
-        self.failUnless(self.find_binding("a", "for a, b in r: pass"))
-        self.failUnless(self.find_binding("a", "for (a, b) in r: pass"))
-        self.failUnless(self.find_binding("a", "for c, (a,) in r: pass"))
-        self.failUnless(self.find_binding("a", "for c, (a, b) in r: pass"))
-        self.failUnless(self.find_binding("a", "for c in r: a = c"))
-        self.failIf(self.find_binding("a", "for c in a: pass"))
+        self.assertTrue(self.find_binding("a", "for a in r: pass"))
+        self.assertTrue(self.find_binding("a", "for a, b in r: pass"))
+        self.assertTrue(self.find_binding("a", "for (a, b) in r: pass"))
+        self.assertTrue(self.find_binding("a", "for c, (a,) in r: pass"))
+        self.assertTrue(self.find_binding("a", "for c, (a, b) in r: pass"))
+        self.assertTrue(self.find_binding("a", "for c in r: a = c"))
+        self.assertFalse(self.find_binding("a", "for c in a: pass"))
 
     def test_for_nested(self):
         s = """
             for b in r:
                 for a in b:
                     pass"""
-        self.failUnless(self.find_binding("a", s))
+        self.assertTrue(self.find_binding("a", s))
 
         s = """
             for b in r:
                 for a, c in b:
                     pass"""
-        self.failUnless(self.find_binding("a", s))
+        self.assertTrue(self.find_binding("a", s))
 
         s = """
             for b in r:
                 for (a, c) in b:
                     pass"""
-        self.failUnless(self.find_binding("a", s))
+        self.assertTrue(self.find_binding("a", s))
 
         s = """
             for b in r:
                 for (a,) in b:
                     pass"""
-        self.failUnless(self.find_binding("a", s))
+        self.assertTrue(self.find_binding("a", s))
 
         s = """
             for b in r:
                 for c, (a, d) in b:
                     pass"""
-        self.failUnless(self.find_binding("a", s))
+        self.assertTrue(self.find_binding("a", s))
 
         s = """
             for b in r:
                 for c in b:
                     a = 7"""
-        self.failUnless(self.find_binding("a", s))
+        self.assertTrue(self.find_binding("a", s))
 
         s = """
             for b in r:
                 for c in b:
                     d = a"""
-        self.failIf(self.find_binding("a", s))
+        self.assertFalse(self.find_binding("a", s))
 
         s = """
             for b in r:
                 for c in a:
                     d = 7"""
-        self.failIf(self.find_binding("a", s))
+        self.assertFalse(self.find_binding("a", s))
 
     def test_if(self):
-        self.failUnless(self.find_binding("a", "if b in r: a = c"))
-        self.failIf(self.find_binding("a", "if a in r: d = e"))
+        self.assertTrue(self.find_binding("a", "if b in r: a = c"))
+        self.assertFalse(self.find_binding("a", "if a in r: d = e"))
 
     def test_if_nested(self):
         s = """
             if b in r:
                 if c in d:
                     a = c"""
-        self.failUnless(self.find_binding("a", s))
+        self.assertTrue(self.find_binding("a", s))
 
         s = """
             if b in r:
                 if c in d:
                     c = a"""
-        self.failIf(self.find_binding("a", s))
+        self.assertFalse(self.find_binding("a", s))
 
     def test_while(self):
-        self.failUnless(self.find_binding("a", "while b in r: a = c"))
-        self.failIf(self.find_binding("a", "while a in r: d = e"))
+        self.assertTrue(self.find_binding("a", "while b in r: a = c"))
+        self.assertFalse(self.find_binding("a", "while a in r: d = e"))
 
     def test_while_nested(self):
         s = """
             while b in r:
                 while c in d:
                     a = c"""
-        self.failUnless(self.find_binding("a", s))
+        self.assertTrue(self.find_binding("a", s))
 
         s = """
             while b in r:
                 while c in d:
                     c = a"""
-        self.failIf(self.find_binding("a", s))
+        self.assertFalse(self.find_binding("a", s))
 
     def test_try_except(self):
         s = """
@@ -354,14 +354,14 @@
                 a = 6
             except:
                 b = 8"""
-        self.failUnless(self.find_binding("a", s))
+        self.assertTrue(self.find_binding("a", s))
 
         s = """
             try:
                 b = 8
             except:
                 a = 6"""
-        self.failUnless(self.find_binding("a", s))
+        self.assertTrue(self.find_binding("a", s))
 
         s = """
             try:
@@ -370,14 +370,14 @@
                 pass
             except:
                 a = 6"""
-        self.failUnless(self.find_binding("a", s))
+        self.assertTrue(self.find_binding("a", s))
 
         s = """
             try:
                 b = 8
             except:
                 b = 6"""
-        self.failIf(self.find_binding("a", s))
+        self.assertFalse(self.find_binding("a", s))
 
     def test_try_except_nested(self):
         s = """
@@ -388,7 +388,7 @@
                     pass
             except:
                 b = 8"""
-        self.failUnless(self.find_binding("a", s))
+        self.assertTrue(self.find_binding("a", s))
 
         s = """
             try:
@@ -398,7 +398,7 @@
                     a = 6
                 except:
                     pass"""
-        self.failUnless(self.find_binding("a", s))
+        self.assertTrue(self.find_binding("a", s))
 
         s = """
             try:
@@ -408,7 +408,7 @@
                     pass
                 except:
                     a = 6"""
-        self.failUnless(self.find_binding("a", s))
+        self.assertTrue(self.find_binding("a", s))
 
         s = """
             try:
@@ -420,7 +420,7 @@
                     a = 6
             except:
                 pass"""
-        self.failUnless(self.find_binding("a", s))
+        self.assertTrue(self.find_binding("a", s))
 
         s = """
             try:
@@ -432,14 +432,14 @@
                     pass
                 except:
                     a = 6"""
-        self.failUnless(self.find_binding("a", s))
+        self.assertTrue(self.find_binding("a", s))
 
         s = """
             try:
                 b = 8
             except:
                 b = 6"""
-        self.failIf(self.find_binding("a", s))
+        self.assertFalse(self.find_binding("a", s))
 
         s = """
             try:
@@ -454,7 +454,7 @@
                     t = 8
                 except:
                     o = y"""
-        self.failIf(self.find_binding("a", s))
+        self.assertFalse(self.find_binding("a", s))
 
     def test_try_except_finally(self):
         s = """
@@ -464,21 +464,21 @@
                 b = 8
             finally:
                 a = 9"""
-        self.failUnless(self.find_binding("a", s))
+        self.assertTrue(self.find_binding("a", s))
 
         s = """
             try:
                 b = 8
             finally:
                 a = 6"""
-        self.failUnless(self.find_binding("a", s))
+        self.assertTrue(self.find_binding("a", s))
 
         s = """
             try:
                 b = 8
             finally:
                 b = 6"""
-        self.failIf(self.find_binding("a", s))
+        self.assertFalse(self.find_binding("a", s))
 
         s = """
             try:
@@ -487,7 +487,7 @@
                 b = 9
             finally:
                 b = 6"""
-        self.failIf(self.find_binding("a", s))
+        self.assertFalse(self.find_binding("a", s))
 
     def test_try_except_finally_nested(self):
         s = """
@@ -502,7 +502,7 @@
                     b = 9
                 finally:
                     c = 9"""
-        self.failUnless(self.find_binding("a", s))
+        self.assertTrue(self.find_binding("a", s))
 
         s = """
             try:
@@ -512,7 +512,7 @@
                     pass
                 finally:
                     a = 6"""
-        self.failUnless(self.find_binding("a", s))
+        self.assertTrue(self.find_binding("a", s))
 
         s = """
             try:
@@ -522,7 +522,7 @@
                     b = 6
                 finally:
                     b = 7"""
-        self.failIf(self.find_binding("a", s))
+        self.assertFalse(self.find_binding("a", s))
 
 class Test_touch_import(support.TestCase):