Index: Lib/test/test_csv.py
===================================================================
--- Lib/test/test_csv.py	(revision 77598)
+++ Lib/test/test_csv.py	(working copy)
@@ -811,7 +811,7 @@
         # given that all three lines in sample3 are equal,
         # I think that any character could have been 'guessed' as the
         # delimiter, depending on dictionary order
-        self.assertTrue(dialect.delimiter in self.sample3)
+        self.assertIn(dialect.delimiter, self.sample3)
         dialect = sniffer.sniff(self.sample3, delimiters="?,")
         self.assertEqual(dialect.delimiter, "?")
         dialect = sniffer.sniff(self.sample3, delimiters="/,")
Index: Lib/test/test_dictviews.py
===================================================================
--- Lib/test/test_dictviews.py	(revision 77598)
+++ Lib/test/test_dictviews.py	(working copy)
@@ -24,10 +24,10 @@
         self.assertNotEqual(keys, {1, "b"})
         self.assertNotEqual(keys, {1})
         self.assertNotEqual(keys, 42)
-        self.assertTrue(1 in keys)
-        self.assertTrue("a" in keys)
-        self.assertTrue(10 not in keys)
-        self.assertTrue("Z" not in keys)
+        self.assertIn(1, keys)
+        self.assertIn("a", keys)
+        self.assertNotIn(10, keys)
+        self.assertNotIn("Z", keys)
         self.assertEqual(d.keys(), d.keys())
         e = {1: 11, "a": "def"}
         self.assertEqual(d.keys(), e.keys())
@@ -44,13 +44,13 @@
         self.assertNotEqual(items, {(1, 10), ("a", "def")})
         self.assertNotEqual(items, {(1, 10)})
         self.assertNotEqual(items, 42)
-        self.assertTrue((1, 10) in items)
-        self.assertTrue(("a", "ABC") in items)
-        self.assertTrue((1, 11) not in items)
-        self.assertTrue(1 not in items)
-        self.assertTrue(() not in items)
-        self.assertTrue((1,) not in items)
-        self.assertTrue((1, 2, 3) not in items)
+        self.assertIn((1, 10), items)
+        self.assertIn(("a", "ABC"), items)
+        self.assertNotIn((1, 11), items)
+        self.assertNotIn(1, items)
+        self.assertNotIn((), items)
+        self.assertNotIn((1,), items)
+        self.assertNotIn((1, 2, 3), items)
         self.assertEqual(d.items(), d.items())
         e = d.copy()
         self.assertEqual(d.items(), e.items())
Index: Lib/test/test_pep352.py
===================================================================
--- Lib/test/test_pep352.py	(revision 77598)
+++ Lib/test/test_pep352.py	(working copy)
@@ -73,7 +73,7 @@
                     self.verify_instance_interface(exc())
                 except TypeError:
                     pass
-                self.assertTrue(exc_name in exc_set)
+                self.assertIn(exc_name, exc_set)
                 exc_set.discard(exc_name)
                 last_exc = exc
                 last_depth = depth
Index: Lib/test/test_exceptions.py
===================================================================
--- Lib/test/test_exceptions.py	(revision 77598)
+++ Lib/test/test_exceptions.py	(working copy)
@@ -337,7 +337,7 @@
         try:
             Exception().__traceback__ = 5
         except TypeError as e:
-            self.assertTrue("__traceback__ must be a traceback" in str(e))
+            self.assertIn("__traceback__ must be a traceback", str(e))
         else:
             self.fail("No exception raised")
 
@@ -597,7 +597,7 @@
                 return sys.exc_info()
         e, v, tb = g()
         self.assertTrue(isinstance(v, RuntimeError), type(v))
-        self.assertTrue("maximum recursion depth exceeded" in str(v), str(v))
+        self.assertIn("maximum recursion depth exceeded", str(v))
 
 
     def test_MemoryError(self):
Index: Lib/test/test_warnings.py
===================================================================
--- Lib/test/test_warnings.py	(revision 77598)
+++ Lib/test/test_warnings.py	(working copy)
@@ -483,7 +483,7 @@
             with support.captured_output('stderr') as stream:
                 self.module.warn(text)
                 result = stream.getvalue()
-        self.assertTrue(text in result)
+        self.assertIn(text, result)
 
     def test_showwarning_not_callable(self):
         with original_warnings.catch_warnings(module=self.module):
Index: Lib/test/test_traceback.py
===================================================================
--- Lib/test/test_traceback.py	(revision 77598)
+++ Lib/test/test_traceback.py	(working copy)
@@ -41,12 +41,12 @@
                                         SyntaxError)
         self.assertEqual(len(err), 4)
         self.assertTrue(err[1].strip() == "return x!")
-        self.assertTrue("^" in err[2]) # third line has caret
+        self.assertIn("^", err[2]) # third line has caret
         self.assertEqual(err[1].find("!"), err[2].find("^")) # in the right place
 
         err = self.get_exception_format(self.syntax_error_with_caret_2,
                                         SyntaxError)
-        self.assertTrue("^" in err[2]) # third line has caret
+        self.assertIn("^", err[2]) # third line has caret
         self.assertTrue(err[2].count('\n') == 1) # and no additional newline
         self.assertTrue(err[1].find("+") == err[2].find("^")) # in the right place
 
@@ -64,7 +64,7 @@
                                         IndentationError)
         self.assertEqual(len(err), 4)
         self.assertEqual(err[1].strip(), "print(2)")
-        self.assertTrue("^" in err[2])
+        self.assertIn("^", err[2])
         self.assertEqual(err[1].find(")"), err[2].find("^"))
 
     def test_base_exception(self):
@@ -210,7 +210,7 @@
     def check_zero_div(self, msg):
         lines = msg.splitlines()
         self.assertTrue(lines[-3].startswith('  File'))
-        self.assertTrue('1/0 # In zero_div' in lines[-2], lines[-2])
+        self.assertIn('1/0 # In zero_div', lines[-2])
         self.assertTrue(lines[-1].startswith('ZeroDivisionError'), lines[-1])
 
     def test_simple(self):
@@ -222,7 +222,7 @@
         self.assertEquals(len(lines), 4)
         self.assertTrue(lines[0].startswith('Traceback'))
         self.assertTrue(lines[1].startswith('  File'))
-        self.assertTrue('1/0 # Marker' in lines[2])
+        self.assertIn('1/0 # Marker', lines[2])
         self.assertTrue(lines[3].startswith('ZeroDivisionError'))
 
     def test_cause(self):
@@ -237,7 +237,7 @@
         self.assertEquals(len(blocks), 3)
         self.assertEquals(blocks[1], cause_message)
         self.check_zero_div(blocks[0])
-        self.assertTrue('inner_raise() # Marker' in blocks[2])
+        self.assertIn('inner_raise() # Marker', blocks[2])
 
     def test_context(self):
         def inner_raise():
@@ -251,7 +251,7 @@
         self.assertEquals(len(blocks), 3)
         self.assertEquals(blocks[1], context_message)
         self.check_zero_div(blocks[0])
-        self.assertTrue('inner_raise() # Marker' in blocks[2])
+        self.assertIn('inner_raise() # Marker', blocks[2])
 
     def test_cause_and_context(self):
         # When both a cause and a context are set, only the cause should be
@@ -289,11 +289,11 @@
         self.assertEquals(len(blocks), 3)
         self.assertEquals(blocks[1], cause_message)
         # The first block is the KeyError raised from the ZeroDivisionError
-        self.assertTrue('raise KeyError from e' in blocks[0])
-        self.assertTrue('1/0' not in blocks[0])
+        self.assertIn('raise KeyError from e', blocks[0])
+        self.assertNotIn('1/0', blocks[0])
         # The second block (apart from the boundary) is the ZeroDivisionError
         # re-raised from the KeyError
-        self.assertTrue('inner_raise() # Marker' in blocks[2])
+        self.assertIn('inner_raise() # Marker', blocks[2])
         self.check_zero_div(blocks[2])
 
 
Index: Lib/test/test_dict.py
===================================================================
--- Lib/test/test_dict.py	(revision 77598)
+++ Lib/test/test_dict.py	(working copy)
@@ -35,7 +35,9 @@
         d = {'a': 1, 'b': 2}
         k = d.keys()
         self.assertTrue('a' in d)
+        self.assertIn('a', d)
         self.assertTrue('b' in d)
+        self.assertIn('b', d)
         self.assertRaises(TypeError, d.keys, None)
         self.assertEqual(repr(dict(a=1).keys()), "dict_keys(['a'])")
 
@@ -60,10 +62,14 @@
         d = {}
         self.assertTrue(not ('a' in d))
         self.assertTrue('a' not in d)
+        self.assertNotIn('a', d)
         d = {'a': 1, 'b': 2}
         self.assertTrue('a' in d)
+        self.assertIn('a', d)
         self.assertTrue('b' in d)
+        self.assertIn('b', d)
         self.assertTrue('c' not in d)
+        self.assertNotIn('c', d)
 
         self.assertRaises(TypeError, d.__contains__)
 
@@ -519,7 +525,9 @@
         self.assertEqual(d[1], 2)
         self.assertEqual(d[3], 4)
         self.assertTrue(2 not in d)
+        self.assertNotIn(2, d)
         self.assertTrue(2 not in d.keys())
+        self.assertNotIn(2, d.keys())
         self.assertEqual(d[2], 42)
         class E(dict):
             def __missing__(self, key):
Index: Lib/test/test_set.py
===================================================================
--- Lib/test/test_set.py	(revision 77598)
+++ Lib/test/test_set.py	(working copy)
@@ -65,7 +65,7 @@
             self.assertEqual(c in self.s, c in self.d)
         self.assertRaises(TypeError, self.s.__contains__, [[]])
         s = self.thetype([frozenset(self.letters)])
-        self.assertTrue(self.thetype(self.letters) in s)
+        self.assertIn(self.thetype(self.letters), s)
 
     def test_union(self):
         u = self.s.union(self.otherword)
@@ -269,7 +269,7 @@
         s=H()
         f=set()
         f.add(s)
-        self.assertTrue(s in f)
+        self.assertIn(s, f)
         f.remove(s)
         f.add(s)
         f.discard(s)
@@ -379,7 +379,7 @@
 
     def test_add(self):
         self.s.add('Q')
-        self.assertTrue('Q' in self.s)
+        self.assertIn('Q', self.s)
         dup = self.s.copy()
         self.s.add('Q')
         self.assertEqual(self.s, dup)
@@ -387,13 +387,13 @@
 
     def test_remove(self):
         self.s.remove('a')
-        self.assertTrue('a' not in self.s)
+        self.assertNotIn('a', self.s)
         self.assertRaises(KeyError, self.s.remove, 'Q')
         self.assertRaises(TypeError, self.s.remove, [])
         s = self.thetype([frozenset(self.word)])
-        self.assertTrue(self.thetype(self.word) in s)
+        self.assertIn(self.thetype(self.word), s)
         s.remove(self.thetype(self.word))
-        self.assertTrue(self.thetype(self.word) not in s)
+        self.assertNotIn(self.thetype(self.word), s)
         self.assertRaises(KeyError, self.s.remove, self.thetype(self.word))
 
     def test_remove_keyerror_unpacking(self):
@@ -420,26 +420,26 @@
 
     def test_discard(self):
         self.s.discard('a')
-        self.assertTrue('a' not in self.s)
+        self.assertNotIn('a', self.s)
         self.s.discard('Q')
         self.assertRaises(TypeError, self.s.discard, [])
         s = self.thetype([frozenset(self.word)])
-        self.assertTrue(self.thetype(self.word) in s)
+        self.assertIn(self.thetype(self.word), s)
         s.discard(self.thetype(self.word))
-        self.assertTrue(self.thetype(self.word) not in s)
+        self.assertNotIn(self.thetype(self.word), s)
         s.discard(self.thetype(self.word))
 
     def test_pop(self):
         for i in range(len(self.s)):
             elem = self.s.pop()
-            self.assertTrue(elem not in self.s)
+            self.assertNotIn(elem, self.s)
         self.assertRaises(KeyError, self.s.pop)
 
     def test_update(self):
         retval = self.s.update(self.otherword)
         self.assertEqual(retval, None)
         for c in (self.word + self.otherword):
-            self.assertTrue(c in self.s)
+            self.assertIn(c, self.s)
         self.assertRaises(PassThru, self.s.update, check_pass_thru())
         self.assertRaises(TypeError, self.s.update, [[]])
         for p, q in (('cdc', 'abcd'), ('efgfe', 'abcefg'), ('ccb', 'abc'), ('ef', 'abcef')):
@@ -457,16 +457,16 @@
     def test_ior(self):
         self.s |= set(self.otherword)
         for c in (self.word + self.otherword):
-            self.assertTrue(c in self.s)
+            self.assertIn(c, self.s)
 
     def test_intersection_update(self):
         retval = self.s.intersection_update(self.otherword)
         self.assertEqual(retval, None)
         for c in (self.word + self.otherword):
             if c in self.otherword and c in self.word:
-                self.assertTrue(c in self.s)
+                self.assertIn(c, self.s)
             else:
-                self.assertTrue(c not in self.s)
+                self.assertNotIn(c, self.s)
         self.assertRaises(PassThru, self.s.intersection_update, check_pass_thru())
         self.assertRaises(TypeError, self.s.intersection_update, [[]])
         for p, q in (('cdc', 'c'), ('efgfe', ''), ('ccb', 'bc'), ('ef', '')):
@@ -484,18 +484,18 @@
         self.s &= set(self.otherword)
         for c in (self.word + self.otherword):
             if c in self.otherword and c in self.word:
-                self.assertTrue(c in self.s)
+                self.assertIn(c, self.s)
             else:
-                self.assertTrue(c not in self.s)
+                self.assertNotIn(c, self.s)
 
     def test_difference_update(self):
         retval = self.s.difference_update(self.otherword)
         self.assertEqual(retval, None)
         for c in (self.word + self.otherword):
             if c in self.word and c not in self.otherword:
-                self.assertTrue(c in self.s)
+                self.assertIn(c, self.s)
             else:
-                self.assertTrue(c not in self.s)
+                self.assertNotIn(c, self.s)
         self.assertRaises(PassThru, self.s.difference_update, check_pass_thru())
         self.assertRaises(TypeError, self.s.difference_update, [[]])
         self.assertRaises(TypeError, self.s.symmetric_difference_update, [[]])
@@ -521,18 +521,18 @@
         self.s -= set(self.otherword)
         for c in (self.word + self.otherword):
             if c in self.word and c not in self.otherword:
-                self.assertTrue(c in self.s)
+                self.assertIn(c, self.s)
             else:
-                self.assertTrue(c not in self.s)
+                self.assertNotIn(c, self.s)
 
     def test_symmetric_difference_update(self):
         retval = self.s.symmetric_difference_update(self.otherword)
         self.assertEqual(retval, None)
         for c in (self.word + self.otherword):
             if (c in self.word) ^ (c in self.otherword):
-                self.assertTrue(c in self.s)
+                self.assertIn(c, self.s)
             else:
-                self.assertTrue(c not in self.s)
+                self.assertNotIn(c, self.s)
         self.assertRaises(PassThru, self.s.symmetric_difference_update, check_pass_thru())
         self.assertRaises(TypeError, self.s.symmetric_difference_update, [[]])
         for p, q in (('cdc', 'abd'), ('efgfe', 'abcefg'), ('ccb', 'a'), ('ef', 'abcef')):
@@ -545,9 +545,9 @@
         self.s ^= set(self.otherword)
         for c in (self.word + self.otherword):
             if (c in self.word) ^ (c in self.otherword):
-                self.assertTrue(c in self.s)
+                self.assertIn(c, self.s)
             else:
-                self.assertTrue(c not in self.s)
+                self.assertNotIn(c, self.s)
 
     def test_inplace_on_self(self):
         t = self.s.copy()
@@ -814,7 +814,7 @@
 
     def test_iteration(self):
         for v in self.set:
-            self.assertTrue(v in self.values)
+            self.assertIn(v, self.values)
         setiter = iter(self.set)
         # note: __length_hint__ is an internal undocumented API,
         # don't rely on it in your own programs
@@ -849,10 +849,10 @@
         self.repr   = "{3}"
 
     def test_in(self):
-        self.assertTrue(3 in self.set)
+        self.assertIn(3, self.set)
 
     def test_not_in(self):
-        self.assertTrue(2 not in self.set)
+        self.assertNotIn(2, self.set)
 
 #------------------------------------------------------------------------------
 
@@ -866,10 +866,10 @@
         self.repr   = "{(0, 'zero')}"
 
     def test_in(self):
-        self.assertTrue((0, "zero") in self.set)
+        self.assertIn((0, "zero"), self.set)
 
     def test_not_in(self):
-        self.assertTrue(9 not in self.set)
+        self.assertNotIn(9, self.set)
 
 #------------------------------------------------------------------------------
 
@@ -1186,7 +1186,7 @@
             popped[self.set.pop()] = None
         self.assertEqual(len(popped), len(self.values))
         for v in self.values:
-            self.assertTrue(v in popped)
+            self.assertIn(v, popped)
 
     def test_update_empty_tuple(self):
         self.set.update(())
@@ -1760,7 +1760,7 @@
             edge = vertex                       # Cuboctahedron vertices are edges in Cube
             self.assertEqual(len(edge), 2)      # Two cube vertices define an edge
             for cubevert in edge:
-                self.assertTrue(cubevert in g)
+                self.assertIn(cubevert, g)
 
 
 #==============================================================================
Index: Lib/test/test_descr.py
===================================================================
--- Lib/test/test_descr.py	(revision 77598)
+++ Lib/test/test_descr.py	(working copy)
@@ -500,7 +500,7 @@
                 return 42
         self.assertEqual(C.name, 'C')
         self.assertEqual(C.bases, ())
-        self.assertTrue('spam' in C.dict)
+        self.assertIn('spam', C.dict)
         c = C()
         self.assertEqual(c.spam(), 42)
 
@@ -1651,9 +1651,9 @@
         # depending on whether this test is run standalone or from a framework.
         self.assertTrue(str(c1).find('C object at ') >= 0)
         self.assertEqual(str(c1), repr(c1))
-        self.assertTrue(-1 not in c1)
+        self.assertNotIn(-1, c1)
         for i in range(10):
-            self.assertTrue(i in c1)
+            self.assertIn(i, c1)
         self.assertFalse(10 in c1)
         # Test the default behavior for dynamic classes
         class D(object):
@@ -1674,9 +1674,9 @@
         # depending on whether this test is run standalone or from a framework.
         self.assertTrue(str(d1).find('D object at ') >= 0)
         self.assertEqual(str(d1), repr(d1))
-        self.assertTrue(-1 not in d1)
+        self.assertNotIn(-1, d1)
         for i in range(10):
-            self.assertTrue(i in d1)
+            self.assertIn(i, d1)
         self.assertFalse(10 in d1)
         # Test overridden behavior
         class Proxy(object):
@@ -1723,7 +1723,7 @@
         p10 = Proxy(range(10))
         self.assertFalse(-1 in p10)
         for i in range(10):
-            self.assertTrue(i in p10)
+            self.assertIn(i, p10)
         self.assertFalse(10 in p10)
 
     def test_weakrefs(self):
@@ -1784,10 +1784,10 @@
         self.assertTrue(isinstance(raw, property))
 
         attrs = dir(raw)
-        self.assertTrue("__doc__" in attrs)
-        self.assertTrue("fget" in attrs)
-        self.assertTrue("fset" in attrs)
-        self.assertTrue("fdel" in attrs)
+        self.assertIn("__doc__", attrs)
+        self.assertIn("fget", attrs)
+        self.assertIn("fset", attrs)
+        self.assertIn("fdel", attrs)
 
         self.assertEqual(raw.__doc__, "I'm the x property.")
         self.assertTrue(raw.fget is C.__dict__['getx'])
@@ -2012,12 +2012,12 @@
 
         c = C()
         self.assertEqual(interesting(dir(c)), cstuff)
-        ## self.assertTrue('__self__' in dir(C.Cmethod))
+        ## self.assertIn('__self__', dir(C.Cmethod))
 
         c.cdata = 2
         c.cmethod = lambda self: 0
         self.assertEqual(interesting(dir(c)), cstuff + ['cdata', 'cmethod'])
-        ## self.assertTrue('__self__' in dir(c.Cmethod))
+        ## self.assertIn('__self__', dir(c.Cmethod))
 
         class A(C):
             Adata = 1
@@ -2025,13 +2025,13 @@
 
         astuff = ['Adata', 'Amethod'] + cstuff
         self.assertEqual(interesting(dir(A)), astuff)
-        ## self.assertTrue('__self__' in dir(A.Amethod))
+        ## self.assertIn('__self__', dir(A.Amethod))
         a = A()
         self.assertEqual(interesting(dir(a)), astuff)
         a.adata = 42
         a.amethod = lambda self: 3
         self.assertEqual(interesting(dir(a)), astuff + ['adata', 'amethod'])
-        ## self.assertTrue('__self__' in dir(a.Amethod))
+        ## self.assertIn('__self__', dir(a.Amethod))
 
         # Try a module subclass.
         import sys
@@ -2583,7 +2583,7 @@
         self.assertEqual(d[cistr('one')], 1)
         self.assertEqual(d[cistr('tWo')], 2)
         self.assertEqual(d[cistr('THrEE')], 3)
-        self.assertTrue(cistr('ONe') in d)
+        self.assertIn(cistr('ONe'), d)
         self.assertEqual(d.get(cistr('thrEE')), 3)
 
     def test_classic_comparisons(self):
Index: Lib/test/test_raise.py
===================================================================
--- Lib/test/test_raise.py	(revision 77598)
+++ Lib/test/test_raise.py	(working copy)
@@ -28,7 +28,7 @@
         try:
             raise
         except RuntimeError as e:
-            self.assertTrue("No active exception" in str(e))
+            self.assertIn("No active exception", str(e))
         else:
             self.fail("No exception raised")
 
@@ -127,7 +127,7 @@
         try:
             raise IndexError from 5
         except TypeError as e:
-            self.assertTrue("exception cause" in str(e))
+            self.assertIn("exception cause", str(e))
         else:
             self.fail("No exception raised")
 
Index: Lib/test/test_site.py
===================================================================
--- Lib/test/test_site.py	(revision 77598)
+++ Lib/test/test_site.py	(working copy)
@@ -270,7 +270,7 @@
         site.removeduppaths()
         seen_paths = set()
         for path in sys.path:
-            self.assertTrue(path not in seen_paths)
+            self.assertNotIn(path, seen_paths)
             seen_paths.add(path)
 
     def test_add_build_dir(self):
Index: Lib/test/test_inspect.py
===================================================================
--- Lib/test/test_inspect.py	(revision 77598)
+++ Lib/test/test_inspect.py	(working copy)
@@ -117,8 +117,8 @@
         x = C()
         x.a = 42
         members = dict(inspect.getmembers(x))
-        self.assertTrue('a' in members)
-        self.assertTrue('b' not in members)
+        self.assertIn('a', members)
+        self.assertNotIn('b', members)
 
     def test_isabstract(self):
         from abc import ABCMeta, abstractmethod
@@ -471,25 +471,25 @@
             datablob = '1'
 
         attrs = attrs_wo_objs(A)
-        self.assertTrue(('s', 'static method', A) in attrs, 'missing static method')
-        self.assertTrue(('c', 'class method', A) in attrs, 'missing class method')
-        self.assertTrue(('p', 'property', A) in attrs, 'missing property')
+        self.assertIn(('s', 'static method', A), attrs, 'missing static method')
+        self.assertIn(('c', 'class method', A), attrs, 'missing class method')
+        self.assertIn(('p', 'property', A), attrs, 'missing property')
         self.assertTrue(('m', 'method', A) in attrs,
             'missing plain method: %r' % attrs)
-        self.assertTrue(('m1', 'method', A) in attrs, 'missing plain method')
-        self.assertTrue(('datablob', 'data', A) in attrs, 'missing data')
+        self.assertIn(('m1', 'method', A), attrs, 'missing plain method')
+        self.assertIn(('datablob', 'data', A), attrs, 'missing data')
 
         class B(A):
 
             def m(self): pass
 
         attrs = attrs_wo_objs(B)
-        self.assertTrue(('s', 'static method', A) in attrs, 'missing static method')
-        self.assertTrue(('c', 'class method', A) in attrs, 'missing class method')
-        self.assertTrue(('p', 'property', A) in attrs, 'missing property')
-        self.assertTrue(('m', 'method', B) in attrs, 'missing plain method')
-        self.assertTrue(('m1', 'method', A) in attrs, 'missing plain method')
-        self.assertTrue(('datablob', 'data', A) in attrs, 'missing data')
+        self.assertIn(('s', 'static method', A), attrs, 'missing static method')
+        self.assertIn(('c', 'class method', A), attrs, 'missing class method')
+        self.assertIn(('p', 'property', A), attrs, 'missing property')
+        self.assertIn(('m', 'method', B), attrs, 'missing plain method')
+        self.assertIn(('m1', 'method', A), attrs, 'missing plain method')
+        self.assertIn(('datablob', 'data', A), attrs, 'missing data')
 
 
         class C(A):
@@ -498,24 +498,24 @@
             def c(self): pass
 
         attrs = attrs_wo_objs(C)
-        self.assertTrue(('s', 'static method', A) in attrs, 'missing static method')
-        self.assertTrue(('c', 'method', C) in attrs, 'missing plain method')
-        self.assertTrue(('p', 'property', A) in attrs, 'missing property')
-        self.assertTrue(('m', 'method', C) in attrs, 'missing plain method')
-        self.assertTrue(('m1', 'method', A) in attrs, 'missing plain method')
-        self.assertTrue(('datablob', 'data', A) in attrs, 'missing data')
+        self.assertIn(('s', 'static method', A), attrs, 'missing static method')
+        self.assertIn(('c', 'method', C), attrs, 'missing plain method')
+        self.assertIn(('p', 'property', A), attrs, 'missing property')
+        self.assertIn(('m', 'method', C), attrs, 'missing plain method')
+        self.assertIn(('m1', 'method', A), attrs, 'missing plain method')
+        self.assertIn(('datablob', 'data', A), attrs, 'missing data')
 
         class D(B, C):
 
             def m1(self): pass
 
         attrs = attrs_wo_objs(D)
-        self.assertTrue(('s', 'static method', A) in attrs, 'missing static method')
-        self.assertTrue(('c', 'method', C) in attrs, 'missing plain method')
-        self.assertTrue(('p', 'property', A) in attrs, 'missing property')
-        self.assertTrue(('m', 'method', B) in attrs, 'missing plain method')
-        self.assertTrue(('m1', 'method', D) in attrs, 'missing plain method')
-        self.assertTrue(('datablob', 'data', A) in attrs, 'missing data')
+        self.assertIn(('s', 'static method', A), attrs, 'missing static method')
+        self.assertIn(('c', 'method', C), attrs, 'missing plain method')
+        self.assertIn(('p', 'property', A), attrs, 'missing property')
+        self.assertIn(('m', 'method', B), attrs, 'missing plain method')
+        self.assertIn(('m1', 'method', D), attrs, 'missing plain method')
+        self.assertIn(('datablob', 'data', A), attrs, 'missing data')
 
 def test_main():
     run_unittest(TestDecorators, TestRetrievingSourceCode, TestOneliners,
Index: Lib/test/test_http_cookiejar.py
===================================================================
--- Lib/test/test_http_cookiejar.py	(revision 77598)
+++ Lib/test/test_http_cookiejar.py	(working copy)
@@ -441,8 +441,8 @@
         interact_netscape(c, "http://www.acme.com/", 'version=eggs; spam=eggs')
 
         cookies = c._cookies["www.acme.com"]["/"]
-        self.assertTrue('expires' in cookies)
-        self.assertTrue('version' in cookies)
+        self.assertIn('expires', cookies)
+        self.assertIn('version', cookies)
 
     def test_expires(self):
         # if expires is in future, keep cookie...
@@ -457,7 +457,8 @@
                           now)
         h = interact_netscape(c, "http://www.acme.com/")
         self.assertEquals(len(c), 1)
-        self.assertTrue('spam="bar"' in h and "foo" not in h)
+        self.assertIn('spam="bar"', h)
+        self.assertNotIn("foo", h)
 
         # max-age takes precedence over expires, and zero max-age is request to
         # delete both new cookie and any old matching cookie
@@ -478,7 +479,7 @@
         self.assertEquals(len(c), 2)
         c.clear_session_cookies()
         self.assertEquals(len(c), 1)
-        self.assertTrue('spam="bar"' in h)
+        self.assertIn('spam="bar"', h)
 
         # XXX RFC 2965 expiry rules (some apply to V0 too)
 
@@ -488,39 +489,39 @@
 
         c = CookieJar(pol)
         interact_2965(c, "http://www.acme.com/", 'spam="bar"; Version="1"')
-        self.assertTrue("/" in c._cookies["www.acme.com"])
+        self.assertIn("/", c._cookies["www.acme.com"])
 
         c = CookieJar(pol)
         interact_2965(c, "http://www.acme.com/blah", 'eggs="bar"; Version="1"')
-        self.assertTrue("/" in c._cookies["www.acme.com"])
+        self.assertIn("/", c._cookies["www.acme.com"])
 
         c = CookieJar(pol)
         interact_2965(c, "http://www.acme.com/blah/rhubarb",
                       'eggs="bar"; Version="1"')
-        self.assertTrue("/blah/" in c._cookies["www.acme.com"])
+        self.assertIn("/blah/", c._cookies["www.acme.com"])
 
         c = CookieJar(pol)
         interact_2965(c, "http://www.acme.com/blah/rhubarb/",
                       'eggs="bar"; Version="1"')
-        self.assertTrue("/blah/rhubarb/" in c._cookies["www.acme.com"])
+        self.assertIn("/blah/rhubarb/", c._cookies["www.acme.com"])
 
         # Netscape
 
         c = CookieJar()
         interact_netscape(c, "http://www.acme.com/", 'spam="bar"')
-        self.assertTrue("/" in c._cookies["www.acme.com"])
+        self.assertIn("/", c._cookies["www.acme.com"])
 
         c = CookieJar()
         interact_netscape(c, "http://www.acme.com/blah", 'eggs="bar"')
-        self.assertTrue("/" in c._cookies["www.acme.com"])
+        self.assertIn("/", c._cookies["www.acme.com"])
 
         c = CookieJar()
         interact_netscape(c, "http://www.acme.com/blah/rhubarb", 'eggs="bar"')
-        self.assertTrue("/blah" in c._cookies["www.acme.com"])
+        self.assertIn("/blah", c._cookies["www.acme.com"])
 
         c = CookieJar()
         interact_netscape(c, "http://www.acme.com/blah/rhubarb/", 'eggs="bar"')
-        self.assertTrue("/blah/rhubarb" in c._cookies["www.acme.com"])
+        self.assertIn("/blah/rhubarb", c._cookies["www.acme.com"])
 
     def test_escape_path(self):
         cases = [
@@ -877,21 +878,21 @@
         url = "http://foo.bar.com/"
         interact_2965(c, url, "spam=eggs; Version=1")
         h = interact_2965(c, url)
-        self.assertTrue("Domain" not in h,
+        self.assertNotIn("Domain", h,
                      "absent domain returned with domain present")
 
         c = CookieJar(pol)
         url = "http://foo.bar.com/"
         interact_2965(c, url, 'spam=eggs; Version=1; Domain=.bar.com')
         h = interact_2965(c, url)
-        self.assertTrue('$Domain=".bar.com"' in h, "domain not returned")
+        self.assertIn('$Domain=".bar.com"', h, "domain not returned")
 
         c = CookieJar(pol)
         url = "http://foo.bar.com/"
         # note missing initial dot in Domain
         interact_2965(c, url, 'spam=eggs; Version=1; Domain=bar.com')
         h = interact_2965(c, url)
-        self.assertTrue('$Domain="bar.com"' in h, "domain not returned")
+        self.assertIn('$Domain="bar.com"', h, "domain not returned")
 
     def test_path_mirror(self):
         pol = DefaultCookiePolicy(rfc2965=True)
@@ -907,7 +908,7 @@
         url = "http://foo.bar.com/"
         interact_2965(c, url, 'spam=eggs; Version=1; Path=/')
         h = interact_2965(c, url)
-        self.assertTrue('$Path="/"' in h, "path not returned")
+        self.assertIn('$Path="/"', h, "path not returned")
 
     def test_port_mirror(self):
         pol = DefaultCookiePolicy(rfc2965=True)
@@ -1449,7 +1450,8 @@
             c, "http://www.acme.com/foo%2f%25/<<%0anew\345/\346\370\345",
             'bar=baz; path="/foo/"; version=1');
         version_re = re.compile(r'^\$version=\"?1\"?', re.I)
-        self.assertTrue("foo=bar" in cookie and version_re.search(cookie))
+        self.assertIn("foo=bar", cookie)
+        self.assertTrue(version_re.search(cookie))
 
         cookie = interact_2965(
             c, "http://www.acme.com/foo/%25/<<%0anew\345/\346\370\345")
@@ -1493,11 +1495,11 @@
 
         new_c = save_and_restore(c, True)
         self.assertEquals(len(new_c), 6)  # none discarded
-        self.assertTrue("name='foo1', value='bar'" in repr(new_c))
+        self.assertIn("name='foo1', value='bar'", repr(new_c))
 
         new_c = save_and_restore(c, False)
         self.assertEquals(len(new_c), 4)  # 2 of them discarded on save
-        self.assertTrue("name='foo1', value='bar'" in repr(new_c))
+        self.assertIn("name='foo1', value='bar'", repr(new_c))
 
     def test_netscape_misc(self):
         # Some additional Netscape cookies tests.
@@ -1519,9 +1521,8 @@
 
         req = urllib.request.Request("http://foo.bar.acme.com/foo")
         c.add_cookie_header(req)
-        self.assertTrue(
-            "PART_NUMBER=3,4" in req.get_header("Cookie") and
-            "Customer=WILE_E_COYOTE" in req.get_header("Cookie"))
+        self.assertIn("PART_NUMBER=3,4", req.get_header("Cookie"))
+        self.assertIn("Customer=WILE_E_COYOTE",req.get_header("Cookie"))
 
     def test_intranet_domains_2965(self):
         # Test handling of local intranet hostnames without a dot.
@@ -1530,11 +1531,12 @@
                       "foo1=bar; PORT; Discard; Version=1;")
         cookie = interact_2965(c, "http://example/",
                                'foo2=bar; domain=".local"; Version=1')
-        self.assertTrue("foo1=bar" in cookie)
+        self.assertIn("foo1=bar", cookie)
 
         interact_2965(c, "http://example/", 'foo3=bar; Version=1')
         cookie = interact_2965(c, "http://example/")
-        self.assertTrue("foo2=bar" in cookie and len(c) == 3)
+        self.assertIn("foo2=bar", cookie)
+        self.assertEquals(len(c), 3)
 
     def test_intranet_domains_ns(self):
         c = CookieJar(DefaultCookiePolicy(rfc2965 = False))
@@ -1542,10 +1544,10 @@
         cookie = interact_netscape(c, "http://example/",
                                    'foo2=bar; domain=.local')
         self.assertEquals(len(c), 2)
-        self.assertTrue("foo1=bar" in cookie)
+        self.assertIn("foo1=bar", cookie)
 
         cookie = interact_netscape(c, "http://example/")
-        self.assertTrue("foo2=bar" in cookie)
+        self.assertIn("foo2=bar", cookie)
         self.assertEquals(len(c), 2)
 
     def test_empty_path(self):
Index: Lib/test/test_dbm_dumb.py
===================================================================
--- Lib/test/test_dbm_dumb.py	(revision 77598)
+++ Lib/test/test_dbm_dumb.py	(working copy)
@@ -93,7 +93,7 @@
     def test_write_contains(self):
         f = dumbdbm.open(_fname)
         f[b'1'] = b'hello'
-        self.assertTrue(b'1' in f)
+        self.assertIn(b'1', f)
         f.close()
 
     def test_write_write_read(self):
@@ -118,7 +118,7 @@
         f['1'] = 'a'
         f.close()
         f = dumbdbm.open(_fname, 'r')
-        self.assertTrue('\u00fc' in f)
+        self.assertIn('\u00fc', f)
         self.assertEqual(f['\u00fc'.encode('utf-8')],
                          self._dict['\u00fc'.encode('utf-8')])
         self.assertEqual(f[b'1'], b'a')
Index: Lib/test/test_ioctl.py
===================================================================
--- Lib/test/test_ioctl.py	(revision 77598)
+++ Lib/test/test_ioctl.py	(working copy)
@@ -24,7 +24,7 @@
         tty = open("/dev/tty", "r")
         r = fcntl.ioctl(tty, termios.TIOCGPGRP, "    ")
         rpgrp = struct.unpack("i", r)[0]
-        self.assertTrue(rpgrp in ids, "%s not in %s" % (rpgrp, ids))
+        self.assertIn(rpgrp, ids)
 
     def test_ioctl_mutate(self):
         import array
@@ -34,7 +34,7 @@
         r = fcntl.ioctl(tty, termios.TIOCGPGRP, buf, 1)
         rpgrp = buf[0]
         self.assertEquals(r, 0)
-        self.assertTrue(rpgrp in ids, "%s not in %s" % (rpgrp, ids))
+        self.assertIn(rpgrp, ids)
 
     def test_ioctl_signed_unsigned_code_param(self):
         if not pty:
Index: Lib/test/test_contains.py
===================================================================
--- Lib/test/test_contains.py	(revision 77598)
+++ Lib/test/test_contains.py	(working copy)
@@ -20,19 +20,19 @@
         a = base_set(1)
         b = myset(1)
         c = seq(1)
-        self.assertTrue(1 in b)
-        self.assertTrue(0 not in b)
-        self.assertTrue(1 in c)
-        self.assertTrue(0 not in c)
+        self.assertIn(1, b)
+        self.assertNotIn(0, b)
+        self.assertIn(1, c)
+        self.assertNotIn(0, c)
         self.assertRaises(TypeError, lambda: 1 in a)
         self.assertRaises(TypeError, lambda: 1 not in a)
 
         # test char in string
-        self.assertTrue('c' in 'abc')
-        self.assertTrue('d' not in 'abc')
+        self.assertIn('c', 'abc')
+        self.assertNotIn('d', 'abc')
 
-        self.assertTrue('' in '')
-        self.assertTrue('' in 'abc')
+        self.assertIn('', '')
+        self.assertIn('', 'abc')
 
         self.assertRaises(TypeError, lambda: None in 'abc')
 
@@ -40,15 +40,15 @@
         # a collection of tests on builtin sequence types
         a = range(10)
         for i in a:
-            self.assertTrue(i in a)
-        self.assertTrue(16 not in a)
-        self.assertTrue(a not in a)
+            self.assertIn(i, a)
+        self.assertNotIn(16, a)
+        self.assertNotIn(a, a)
 
         a = tuple(a)
         for i in a:
-            self.assertTrue(i in a)
-        self.assertTrue(16 not in a)
-        self.assertTrue(a not in a)
+            self.assertIn(i, a)
+        self.assertNotIn(16, a)
+        self.assertNotIn(a, a)
 
         class Deviant1:
             """Behaves strangely when compared
@@ -64,7 +64,7 @@
                     self.aList.remove(14)
                 return 0
 
-        self.assertTrue(Deviant1() not in Deviant1.aList)
+        self.assertNotIn(Deviant1(), Deviant1.aList)
 
     def test_nonreflexive(self):
         # containment and equality tests involving elements that are
@@ -81,7 +81,7 @@
         for constructor in constructors:
             container = constructor(values)
             for elem in container:
-                self.assertTrue(elem in container)
+                self.assertIn(elem, container)
             self.assertTrue(container == constructor(values))
             self.assertTrue(container == container)
 
Index: Lib/test/test_unicode.py
===================================================================
--- Lib/test/test_unicode.py	(revision 77598)
+++ Lib/test/test_unicode.py	(working copy)
@@ -436,32 +436,32 @@
 
     def test_contains(self):
         # Testing Unicode contains method
-        self.assertTrue('a' in 'abdb')
-        self.assertTrue('a' in 'bdab')
-        self.assertTrue('a' in 'bdaba')
-        self.assertTrue('a' in 'bdba')
-        self.assertTrue('a' not in 'bdb')
-        self.assertTrue('a' in 'bdba')
-        self.assertTrue('a' in ('a',1,None))
-        self.assertTrue('a' in (1,None,'a'))
-        self.assertTrue('a' in ('a',1,None))
-        self.assertTrue('a' in (1,None,'a'))
-        self.assertTrue('a' not in ('x',1,'y'))
-        self.assertTrue('a' not in ('x',1,None))
-        self.assertTrue('abcd' not in 'abcxxxx')
-        self.assertTrue('ab' in 'abcd')
-        self.assertTrue('ab' in 'abc')
-        self.assertTrue('ab' in (1,None,'ab'))
-        self.assertTrue('' in 'abc')
-        self.assertTrue('' in '')
-        self.assertTrue('' in 'abc')
-        self.assertTrue('\0' not in 'abc')
-        self.assertTrue('\0' in '\0abc')
-        self.assertTrue('\0' in 'abc\0')
-        self.assertTrue('a' in '\0abc')
-        self.assertTrue('asdf' in 'asdf')
-        self.assertTrue('asdf' not in 'asd')
-        self.assertTrue('asdf' not in '')
+        self.assertIn('a', 'abdb')
+        self.assertIn('a', 'bdab')
+        self.assertIn('a', 'bdaba')
+        self.assertIn('a', 'bdba')
+        self.assertNotIn('a', 'bdb')
+        self.assertIn('a', 'bdba')
+        self.assertIn('a', ('a',1,None))
+        self.assertIn('a', (1,None,'a'))
+        self.assertIn('a', ('a',1,None))
+        self.assertIn('a', (1,None,'a'))
+        self.assertNotIn('a', ('x',1,'y'))
+        self.assertNotIn('a', ('x',1,None))
+        self.assertNotIn('abcd', 'abcxxxx')
+        self.assertIn('ab', 'abcd')
+        self.assertIn('ab', 'abc')
+        self.assertIn('ab', (1,None,'ab'))
+        self.assertIn('', 'abc')
+        self.assertIn('', '')
+        self.assertIn('', 'abc')
+        self.assertNotIn('\0', 'abc')
+        self.assertIn('\0', '\0abc')
+        self.assertIn('\0', 'abc\0')
+        self.assertIn('a', '\0abc')
+        self.assertIn('asdf', 'asdf')
+        self.assertNotIn('asdf', 'asd')
+        self.assertNotIn('asdf', '')
 
         self.assertRaises(TypeError, "abc".__contains__)
 
Index: Lib/test/test_socket.py
===================================================================
--- Lib/test/test_socket.py	(revision 77598)
+++ Lib/test/test_socket.py	(working copy)
@@ -502,7 +502,7 @@
         # it reasonable to get the host's addr in addition to 0.0.0.0.
         # At least for eCos.  This is required for the S/390 to pass.
         my_ip_addr = socket.gethostbyname(socket.gethostname())
-        self.assertTrue(name[0] in ("0.0.0.0", my_ip_addr), '%s invalid' % name[0])
+        self.assertIn(name[0], ("0.0.0.0", my_ip_addr), '%s invalid' % name[0])
         self.assertEqual(name[1], port)
 
     def testGetSockOpt(self):
Index: Lib/test/test_float.py
===================================================================
--- Lib/test/test_float.py	(revision 77598)
+++ Lib/test/test_float.py	(working copy)
@@ -213,11 +213,16 @@
     def test_float_containment(self):
         floats = (INF, -INF, 0.0, 1.0, NAN)
         for f in floats:
+            self.assertIn(f, [f])
             self.assertTrue(f in [f], "'%r' not in []" % f)
+            self.assertIn(f, (f,))
             self.assertTrue(f in (f,), "'%r' not in ()" % f)
+            self.assertIn(f, {f})
             self.assertTrue(f in {f}, "'%r' not in set()" % f)
+            self.assertIn(f, {f: None})
             self.assertTrue(f in {f: None}, "'%r' not in {}" % f)
             self.assertEqual([f].count(f), 1, "[].count('%r') != 1" % f)
+            self.assertIn(f, floats)
             self.assertTrue(f in floats, "'%r' not in container" % f)
 
         for f in floats:
Index: Lib/test/test_pyclbr.py
===================================================================
--- Lib/test/test_pyclbr.py	(revision 77598)
+++ Lib/test/test_pyclbr.py	(working copy)
@@ -40,6 +40,7 @@
         if key in ignore: return
         if key not in obj:
             print("***",key, file=sys.stderr)
+        self.assertIn(key, obj)
         self.assertTrue(key in obj, "%r in %r" % (key, obj))
 
     def assertEqualsOrIgnored(self, a, b, ignore):
Index: Lib/test/test_dbm.py
===================================================================
--- Lib/test/test_dbm.py	(revision 77598)
+++ Lib/test/test_dbm.py	(working copy)
@@ -131,7 +131,7 @@
             f = module.open(_fname, 'w')
             f[b"1"] = b"1"
             # and test that we can find it
-            self.assertTrue(b"1" in f)
+            self.assertIn(b"1", f)
             # and read it
             self.assertTrue(f[b"1"] == b"1")
             f.close()
@@ -154,9 +154,9 @@
             self.d[k] = v
         self.assertEqual(sorted(self.d.keys()), sorted(k for (k, v) in a))
         for k, v in a:
-            self.assertTrue(k in self.d)
+            self.assertIn(k, self.d)
             self.assertEqual(self.d[k], v)
-        self.assertTrue(b'xxx' not in self.d)
+        self.assertNotIn(b'xxx', self.d)
         self.assertRaises(KeyError, lambda: self.d[b'xxx'])
         self.d.close()
 
Index: Lib/test/test_cmd_line.py
===================================================================
--- Lib/test/test_cmd_line.py	(revision 77598)
+++ Lib/test/test_cmd_line.py	(working copy)
@@ -49,7 +49,7 @@
     def verify_valid_flag(self, cmd_line):
         data = self.start_python(cmd_line)
         self.assertTrue(data == b'' or data.endswith(b'\n'))
-        self.assertTrue(b'Traceback' not in data)
+        self.assertNotIn(b'Traceback', data)
 
     def test_optimize(self):
         self.verify_valid_flag('-O')
@@ -65,7 +65,7 @@
         self.verify_valid_flag('-S')
 
     def test_usage(self):
-        self.assertTrue(b'usage' in self.start_python('-h'))
+        self.assertIn(b'usage', self.start_python('-h'))
 
     def test_version(self):
         version = ('Python %d.%d' % sys.version_info[:2]).encode("ascii")
@@ -77,10 +77,10 @@
         # codec), a recursion loop can occur.
         data, rc = self.start_python_and_exit_code('-v')
         self.assertEqual(rc, 0)
-        self.assertTrue(b'stack overflow' not in data)
+        self.assertNotIn(b'stack overflow', data)
         data, rc = self.start_python_and_exit_code('-vv')
         self.assertEqual(rc, 0)
-        self.assertTrue(b'stack overflow' not in data)
+        self.assertNotIn(b'stack overflow', data)
 
     def test_run_module(self):
         # Test expected operation of the '-m' switch
@@ -166,8 +166,8 @@
             p = _spawn_python_with_env('-S', '-c',
                                        'import sys; print(sys.path)')
             stdout, _ = p.communicate()
-            self.assertTrue(path1.encode('ascii') in stdout)
-            self.assertTrue(path2.encode('ascii') in stdout)
+            self.assertIn(path1.encode('ascii'), stdout)
+            self.assertIn(path2.encode('ascii'), stdout)
 
 
 def test_main():
Index: Lib/test/test_runpy.py
===================================================================
--- Lib/test/test_runpy.py	(revision 77598)
+++ Lib/test/test_runpy.py	(working copy)
@@ -165,14 +165,14 @@
         try:
             if verbose: print("Running from source:", mod_name)
             d1 = run_module(mod_name) # Read from source
-            self.assertTrue("x" in d1)
+            self.assertIn("x", d1)
             self.assertEqual(d1["x"], 1)
             del d1 # Ensure __loader__ entry doesn't keep file open
             __import__(mod_name)
             os.remove(mod_fname)
             if verbose: print("Running from compiled:", mod_name)
             d2 = run_module(mod_name) # Read from bytecode
-            self.assertTrue("x" in d2)
+            self.assertIn("x", d2)
             self.assertEqual(d2["x"], 1)
             del d2 # Ensure __loader__ entry doesn't keep file open
         finally:
@@ -187,14 +187,14 @@
         try:
             if verbose: print("Running from source:", pkg_name)
             d1 = run_module(pkg_name) # Read from source
-            self.assertTrue("x" in d1)
+            self.assertIn("x", d1)
             self.assertTrue(d1["x"] == 1)
             del d1 # Ensure __loader__ entry doesn't keep file open
             __import__(mod_name)
             os.remove(mod_fname)
             if verbose: print("Running from compiled:", pkg_name)
             d2 = run_module(pkg_name) # Read from bytecode
-            self.assertTrue("x" in d2)
+            self.assertIn("x", d2)
             self.assertTrue(d2["x"] == 1)
             del d2 # Ensure __loader__ entry doesn't keep file open
         finally:
@@ -239,19 +239,19 @@
             pkg_name = mod_name.rpartition('.')[0]
             if verbose: print("Running from source:", mod_name)
             d1 = run_module(mod_name, run_name=run_name) # Read from source
-            self.assertTrue("__package__" in d1)
+            self.assertIn("__package__", d1)
             self.assertTrue(d1["__package__"] == pkg_name)
-            self.assertTrue("sibling" in d1)
-            self.assertTrue("nephew" in d1)
+            self.assertIn("sibling", d1)
+            self.assertIn("nephew", d1)
             del d1 # Ensure __loader__ entry doesn't keep file open
             __import__(mod_name)
             os.remove(mod_fname)
             if verbose: print("Running from compiled:", mod_name)
             d2 = run_module(mod_name, run_name=run_name) # Read from bytecode
-            self.assertTrue("__package__" in d2)
+            self.assertIn("__package__", d2)
             self.assertTrue(d2["__package__"] == pkg_name)
-            self.assertTrue("sibling" in d2)
-            self.assertTrue("nephew" in d2)
+            self.assertIn("sibling", d2)
+            self.assertIn("nephew", d2)
             del d2 # Ensure __loader__ entry doesn't keep file open
         finally:
             self._del_pkg(pkg_dir, depth, mod_name)
Index: Lib/test/test_os.py
===================================================================
--- Lib/test/test_os.py	(revision 77598)
+++ Lib/test/test_os.py	(working copy)
@@ -228,7 +228,7 @@
                     def trunc(x): return x
                 self.assertEquals(trunc(getattr(result, attr)),
                                   result[getattr(stat, name)])
-                self.assertTrue(attr in members)
+                self.assertIn(attr, members)
 
         try:
             result[200]
Index: Lib/test/test_tarfile.py
===================================================================
--- Lib/test/test_tarfile.py	(revision 77598)
+++ Lib/test/test_tarfile.py	(working copy)
@@ -485,7 +485,7 @@
 
     def test_find_ustar_longname(self):
         name = "ustar/" + "12345/" * 39 + "1234567/longname"
-        self.assertTrue(name in self.tar.getnames())
+        self.assertIn(name, self.tar.getnames())
 
     def test_find_regtype_oldv7(self):
         tarinfo = self.tar.getmember("misc/regtype-old-v7")
Index: Lib/test/test_compile.py
===================================================================
--- Lib/test/test_compile.py	(revision 77598)
+++ Lib/test/test_compile.py	(working copy)
@@ -389,10 +389,10 @@
                 import __mangled_mod
                 import __package__.module
 
-        self.assertTrue("_A__mangled" in A.f.__code__.co_varnames)
-        self.assertTrue("__not_mangled__" in A.f.__code__.co_varnames)
-        self.assertTrue("_A__mangled_mod" in A.f.__code__.co_varnames)
-        self.assertTrue("__package__" in A.f.__code__.co_varnames)
+        self.assertIn("_A__mangled", A.f.__code__.co_varnames)
+        self.assertIn("__not_mangled__", A.f.__code__.co_varnames)
+        self.assertIn("_A__mangled_mod", A.f.__code__.co_varnames)
+        self.assertIn("__package__", A.f.__code__.co_varnames)
 
     def test_compile_ast(self):
         fname = __file__
Index: Lib/test/test_pydoc.py
===================================================================
--- Lib/test/test_pydoc.py	(revision 77598)
+++ Lib/test/test_pydoc.py	(working copy)
@@ -313,7 +313,7 @@
         # Check that pydocfodder module can be described
         from test import pydocfodder
         doc = pydoc.render_doc(pydocfodder)
-        self.assertTrue("pydocfodder" in doc)
+        self.assertIn("pydocfodder", doc)
 
     def test_classic_class(self):
         class C: "Classic class"
@@ -321,7 +321,7 @@
         self.assertEqual(pydoc.describe(C), 'class C')
         self.assertEqual(pydoc.describe(c), 'C')
         expected = 'C in module %s' % __name__
-        self.assertTrue(expected in pydoc.render_doc(c))
+        self.assertIn(expected, pydoc.render_doc(c))
 
     def test_class(self):
         class C(object): "New-style class"
@@ -330,7 +330,7 @@
         self.assertEqual(pydoc.describe(C), 'class C')
         self.assertEqual(pydoc.describe(c), 'C')
         expected = 'C in module %s object' % __name__
-        self.assertTrue(expected in pydoc.render_doc(c))
+        self.assertIn(expected, pydoc.render_doc(c))
 
 
 def test_main():
Index: Lib/test/test_defaultdict.py
===================================================================
--- Lib/test/test_defaultdict.py	(revision 77598)
+++ Lib/test/test_defaultdict.py	(working copy)
@@ -32,14 +32,14 @@
         self.assertEqual(d2["foo"], 1)
         self.assertEqual(d2["bar"], 2)
         self.assertEqual(d2[42], [])
-        self.assertTrue("foo" in d2)
-        self.assertTrue("foo" in d2.keys())
-        self.assertTrue("bar" in d2)
-        self.assertTrue("bar" in d2.keys())
-        self.assertTrue(42 in d2)
-        self.assertTrue(42 in d2.keys())
-        self.assertTrue(12 not in d2)
-        self.assertTrue(12 not in d2.keys())
+        self.assertIn("foo", d2)
+        self.assertIn("foo", d2.keys())
+        self.assertIn("bar", d2)
+        self.assertIn("bar", d2.keys())
+        self.assertIn(42, d2)
+        self.assertIn(42, d2.keys())
+        self.assertNotIn(12, d2)
+        self.assertNotIn(12, d2.keys())
         d2.default_factory = None
         self.assertEqual(d2.default_factory, None)
         try:
Index: Lib/test/test_types.py
===================================================================
--- Lib/test/test_types.py	(revision 77598)
+++ Lib/test/test_types.py	(working copy)
@@ -434,13 +434,13 @@
             result = f.__format__(fmt)
             self.assertEqual(len(result), 98)
             self.assertEqual(result[-7], '.')
-            self.assertTrue(result[:12] in ('112340000000', '112339999999'))
+            self.assertIn(result[:12], ('112340000000', '112339999999'))
         f = 1.1234e200
         for fmt in 'f', 'F':
             result = f.__format__(fmt)
             self.assertEqual(len(result), 208)
             self.assertEqual(result[-7], '.')
-            self.assertTrue(result[:12] in ('112340000000', '112339999999'))
+            self.assertIn(result[:12], ('112340000000', '112339999999'))
 
 
         test( 1.0, 'e', '1.000000e+00')
Index: Lib/test/test_peepholer.py
===================================================================
--- Lib/test/test_peepholer.py	(revision 77598)
+++ Lib/test/test_peepholer.py	(working copy)
@@ -26,9 +26,9 @@
                 del x
         asm = disassemble(unot)
         for elem in ('UNARY_NOT', 'POP_JUMP_IF_FALSE'):
-            self.assertTrue(elem not in asm)
+            self.assertNotIn(elem, asm)
         for elem in ('POP_JUMP_IF_TRUE',):
-            self.assertTrue(elem in asm)
+            self.assertIn(elem, asm)
 
     def test_elim_inversion_of_is_or_in(self):
         for line, elem in (
@@ -38,7 +38,7 @@
             ('not a not in b', '(in)',),
             ):
             asm = dis_single(line)
-            self.assertTrue(elem in asm)
+            self.assertIn(elem, asm)
 
     def test_global_as_constant(self):
         # LOAD_GLOBAL None/True/False  -->  LOAD_CONST None/True/False
@@ -55,14 +55,14 @@
         for func, name in ((f, 'None'), (g, 'True'), (h, 'False')):
             asm = disassemble(func)
             for elem in ('LOAD_GLOBAL',):
-                self.assertTrue(elem not in asm)
+                self.assertNotIn(elem, asm)
             for elem in ('LOAD_CONST', '('+name+')'):
-                self.assertTrue(elem in asm)
+                self.assertIn(elem, asm)
         def f():
             'Adding a docstring made this test fail in Py2.5.0'
             return None
-        self.assertTrue('LOAD_CONST' in disassemble(f))
-        self.assertTrue('LOAD_GLOBAL' not in disassemble(f))
+        self.assertIn('LOAD_CONST', disassemble(f))
+        self.assertNotIn('LOAD_GLOBAL', disassemble(f))
 
     def test_while_one(self):
         # Skip over:  LOAD_CONST trueconst  POP_JUMP_IF_FALSE xx
@@ -72,9 +72,9 @@
             return list
         asm = disassemble(f)
         for elem in ('LOAD_CONST', 'POP_JUMP_IF_FALSE'):
-            self.assertTrue(elem not in asm)
+            self.assertNotIn(elem, asm)
         for elem in ('JUMP_ABSOLUTE',):
-            self.assertTrue(elem in asm)
+            self.assertIn(elem, asm)
 
     def test_pack_unpack(self):
         for line, elem in (
@@ -83,9 +83,9 @@
             ('a, b, c = a, b, c', 'ROT_THREE',),
             ):
             asm = dis_single(line)
-            self.assertTrue(elem in asm)
-            self.assertTrue('BUILD_TUPLE' not in asm)
-            self.assertTrue('UNPACK_TUPLE' not in asm)
+            self.assertIn(elem, asm)
+            self.assertNotIn('BUILD_TUPLE', asm)
+            self.assertNotIn('UNPACK_TUPLE', asm)
 
     def test_folding_of_tuples_of_constants(self):
         for line, elem in (
@@ -96,8 +96,8 @@
             ('((1, 2), 3, 4)', '(((1, 2), 3, 4))'),
             ):
             asm = dis_single(line)
-            self.assertTrue(elem in asm)
-            self.assertTrue('BUILD_TUPLE' not in asm)
+            self.assertIn(elem, asm)
+            self.assertNotIn('BUILD_TUPLE', asm)
 
         # Bug 1053819:  Tuple of constants misidentified when presented with:
         # . . . opcode_with_arg 100   unary_opcode   BUILD_TUPLE 1  . . .
@@ -183,17 +183,17 @@
             ('a = 13 | 7', '(15)'),                 # binary or
             ):
             asm = dis_single(line)
-            self.assertTrue(elem in asm, asm)
-            self.assertTrue('BINARY_' not in asm)
+            self.assertIn(elem, asm, asm)
+            self.assertNotIn('BINARY_', asm)
 
         # Verify that unfoldables are skipped
         asm = dis_single('a=2+"b"')
-        self.assertTrue('(2)' in asm)
-        self.assertTrue("('b')" in asm)
+        self.assertIn('(2)', asm)
+        self.assertIn("('b')", asm)
 
         # Verify that large sequences do not result from folding
         asm = dis_single('a="x"*1000')
-        self.assertTrue('(1000)' in asm)
+        self.assertIn('(1000)', asm)
 
     def test_folding_of_unaryops_on_constants(self):
         for line, elem in (
@@ -202,8 +202,8 @@
             ('+1', '(1)'),                          # unary positive
         ):
             asm = dis_single(line)
-            self.assertTrue(elem in asm, asm)
-            self.assertTrue('UNARY_' not in asm)
+            self.assertIn(elem, asm, asm)
+            self.assertNotIn('UNARY_', asm)
 
         # Verify that unfoldables are skipped
         for line, elem in (
@@ -211,16 +211,16 @@
             ('~"abc"', "('abc')"),                  # unary invert
         ):
             asm = dis_single(line)
-            self.assertTrue(elem in asm, asm)
-            self.assertTrue('UNARY_' in asm)
+            self.assertIn(elem, asm, asm)
+            self.assertIn('UNARY_', asm)
 
     def test_elim_extra_return(self):
         # RETURN LOAD_CONST None RETURN  -->  RETURN
         def f(x):
             return x
         asm = disassemble(f)
-        self.assertTrue('LOAD_CONST' not in asm)
-        self.assertTrue('(None)' not in asm)
+        self.assertNotIn('LOAD_CONST', asm)
+        self.assertNotIn('(None)', asm)
         self.assertEqual(asm.split().count('RETURN_VALUE'), 1)
 
     def test_elim_jump_to_return(self):
@@ -228,8 +228,8 @@
         def f(cond, true_value, false_value):
             return true_value if cond else false_value
         asm = disassemble(f)
-        self.assertTrue('JUMP_FORWARD' not in asm)
-        self.assertTrue('JUMP_ABSOLUTE' not in asm)
+        self.assertNotIn('JUMP_FORWARD', asm)
+        self.assertNotIn('JUMP_ABSOLUTE', asm)
         self.assertEqual(asm.split().count('RETURN_VALUE'), 2)
 
     def test_elim_jump_after_return1(self):
@@ -244,8 +244,8 @@
                 return 5
             return 6
         asm = disassemble(f)
-        self.assertTrue('JUMP_FORWARD' not in asm)
-        self.assertTrue('JUMP_ABSOLUTE' not in asm)
+        self.assertNotIn('JUMP_FORWARD', asm)
+        self.assertNotIn('JUMP_ABSOLUTE', asm)
         self.assertEqual(asm.split().count('RETURN_VALUE'), 6)
 
     def test_elim_jump_after_return2(self):
@@ -254,7 +254,7 @@
             while 1:
                 if cond1: return 4
         asm = disassemble(f)
-        self.assertTrue('JUMP_FORWARD' not in asm)
+        self.assertNotIn('JUMP_FORWARD', 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)
@@ -265,7 +265,7 @@
                 pass
             return g
         asm = disassemble(f)
-        self.assertTrue('BINARY_ADD' not in asm)
+        self.assertNotIn('BINARY_ADD', asm)
 
 
 def test_main(verbose=None):
Index: Lib/test/test_zipimport_support.py
===================================================================
--- Lib/test/test_zipimport_support.py	(revision 77598)
+++ Lib/test/test_zipimport_support.py	(working copy)
@@ -185,7 +185,7 @@
                 print ("Expected line", expected)
                 print ("Got stdout:")
                 print (data)
-            self.assertTrue(expected.encode('utf-8') in data)
+            self.assertIn(expected.encode('utf-8'), data)
             zip_name, run_name = make_zip_script(d, "test_zip",
                                                 script_name, '__main__.py')
             exit_code, data = run_python(zip_name)
@@ -194,7 +194,7 @@
                 print ("Expected line", expected)
                 print ("Got stdout:")
                 print (data)
-            self.assertTrue(expected.encode('utf-8') in data)
+            self.assertIn(expected.encode('utf-8'), data)
 
     def test_pdb_issue4201(self):
         test_src = textwrap.dedent("""\
@@ -209,13 +209,13 @@
             p = spawn_python(script_name)
             p.stdin.write(b'l\n')
             data = kill_python(p)
-            self.assertTrue(script_name.encode('utf-8') in data)
+            self.assertIn(script_name.encode('utf-8'), data)
             zip_name, run_name = make_zip_script(d, "test_zip",
                                                 script_name, '__main__.py')
             p = spawn_python(zip_name)
             p.stdin.write(b'l\n')
             data = kill_python(p)
-            self.assertTrue(run_name.encode('utf-8') in data)
+            self.assertIn(run_name.encode('utf-8'), data)
 
 
 def test_main():
Index: Lib/test/test_mmap.py
===================================================================
--- Lib/test/test_mmap.py	(revision 77598)
+++ Lib/test/test_mmap.py	(working copy)
@@ -502,7 +502,7 @@
 
     def test_error(self):
         self.assertTrue(issubclass(mmap.error, EnvironmentError))
-        self.assertTrue("mmap.error" in str(mmap.error))
+        self.assertIn("mmap.error", str(mmap.error))
 
     def test_io_methods(self):
         data = b"0123456789"
Index: Lib/test/test_structseq.py
===================================================================
--- Lib/test/test_structseq.py	(revision 77598)
+++ Lib/test/test_structseq.py	(working copy)
@@ -50,8 +50,8 @@
     def test_contains(self):
         t1 = time.gmtime()
         for item in t1:
-            self.assertTrue(item in t1)
-        self.assertTrue(-42 not in t1)
+            self.assertIn(item, t1)
+        self.assertNotIn(-42, t1)
 
     def test_hash(self):
         t1 = time.gmtime()
Index: Lib/test/test_reprlib.py
===================================================================
--- Lib/test/test_reprlib.py	(revision 77598)
+++ Lib/test/test_reprlib.py	(working copy)
@@ -125,7 +125,7 @@
         s = r(ClassWithFailingRepr)
         self.assertTrue(s.startswith("<class "))
         self.assertTrue(s.endswith(">"))
-        self.assertTrue(s.find("...") in [12, 13])
+        self.assertIn(s.find("..."), [12, 13])
 
     def test_lambda(self):
         self.assertTrue(repr(lambda x: x).startswith(
Index: Lib/test/test_cgi.py
===================================================================
--- Lib/test/test_cgi.py	(revision 77598)
+++ Lib/test/test_cgi.py	(working copy)
@@ -143,7 +143,7 @@
                 # test individual fields
                 for key in expect.keys():
                     expect_val = expect[key]
-                    self.assertTrue(key in fs)
+                    self.assertIn(key, fs)
                     if len(expect_val) > 1:
                         self.assertEqual(fs.getvalue(key), expect_val)
                     else:
Index: Lib/test/test_copyreg.py
===================================================================
--- Lib/test/test_copyreg.py	(revision 77598)
+++ Lib/test/test_copyreg.py	(working copy)
@@ -54,7 +54,7 @@
             self.assertTrue(copyreg._extension_registry[mod, func] == code)
             self.assertTrue(copyreg._inverted_registry[code] == (mod, func))
             # Shouldn't be in the cache.
-            self.assertTrue(code not in copyreg._extension_cache)
+            self.assertNotIn(code, copyreg._extension_cache)
             # Redundant registration should be OK.
             copyreg.add_extension(mod, func, code)  # shouldn't blow up
             # Conflicting code.
@@ -81,7 +81,7 @@
             e.restore()
 
         # Shouldn't be there anymore.
-        self.assertTrue((mod, func) not in copyreg._extension_registry)
+        self.assertNotIn((mod, func), copyreg._extension_registry)
         # The code *may* be in copyreg._extension_registry, though, if
         # we happened to pick on a registered code.  So don't check for
         # that.
Index: Lib/test/test_scope.py
===================================================================
--- Lib/test/test_scope.py	(revision 77598)
+++ Lib/test/test_scope.py	(working copy)
@@ -447,7 +447,7 @@
             return g
 
         d = f(2)(4)
-        self.assertTrue('h' in d)
+        self.assertIn('h', d)
         del d['h']
         self.assertEqual(d, {'x': 2, 'y': 7, 'w': 6})
 
@@ -481,8 +481,8 @@
             return C
 
         varnames = f(1).z
-        self.assertTrue("x" not in varnames)
-        self.assertTrue("y" in varnames)
+        self.assertNotIn("x", varnames)
+        self.assertIn("y", varnames)
 
     def testLocalsClass_WithTrace(self):
         # Issue23728: after the trace function returns, the locals()
@@ -660,7 +660,7 @@
 
         c = f(0)
         self.assertEqual(c.get(), 1)
-        self.assertTrue("x" not in c.__class__.__dict__)
+        self.assertNotIn("x", c.__class__.__dict__)
 
 
     def testNonLocalGenerator(self):
Index: Lib/test/test_unicodedata.py
===================================================================
--- Lib/test/test_unicodedata.py	(revision 77598)
+++ Lib/test/test_unicodedata.py	(working copy)
@@ -220,7 +220,7 @@
         self.assertEqual(popen.returncode, 1)
         error = "SyntaxError: (unicode error) \\N escapes not supported " \
             "(can't load unicodedata module)"
-        self.assertTrue(error in popen.stderr.read().decode("ascii"))
+        self.assertIn(error, popen.stderr.read().decode("ascii"))
 
     def test_decimal_numeric_consistent(self):
         # Test that decimal and numeric are consistent,
Index: Lib/test/test_poplib.py
===================================================================
--- Lib/test/test_poplib.py	(revision 77598)
+++ Lib/test/test_poplib.py	(working copy)
@@ -258,7 +258,7 @@
             self.client = poplib.POP3_SSL(self.server.host, self.server.port)
 
         def test__all__(self):
-            self.assertTrue('POP3_SSL' in poplib.__all__)
+            self.assertIn('POP3_SSL', poplib.__all__)
 
 
 class TestTimeouts(TestCase):
Index: Lib/test/test_iter.py
===================================================================
--- Lib/test/test_iter.py	(revision 77598)
+++ Lib/test/test_iter.py	(working copy)
@@ -542,23 +542,23 @@
     def test_in_and_not_in(self):
         for sc5 in IteratingSequenceClass(5), SequenceClass(5):
             for i in range(5):
-                self.assertTrue(i in sc5)
+                self.assertIn(i, sc5)
             for i in "abc", -1, 5, 42.42, (3, 4), [], {1: 1}, 3-12j, sc5:
-                self.assertTrue(i not in sc5)
+                self.assertNotIn(i, sc5)
 
         self.assertRaises(TypeError, lambda: 3 in 12)
         self.assertRaises(TypeError, lambda: 3 not in map)
 
         d = {"one": 1, "two": 2, "three": 3, 1j: 2j}
         for k in d:
-            self.assertTrue(k in d)
-            self.assertTrue(k not in d.values())
+            self.assertIn(k, d)
+            self.assertNotIn(k, d.values())
         for v in d.values():
-            self.assertTrue(v in d.values())
-            self.assertTrue(v not in d)
+            self.assertIn(v, d.values())
+            self.assertNotIn(v, d)
         for k, v in d.items():
-            self.assertTrue((k, v) in d.items())
-            self.assertTrue((v, k) not in d.items())
+            self.assertIn((k, v), d.items())
+            self.assertNotIn((v, k), d.items())
 
         f = open(TESTFN, "w")
         try:
@@ -569,9 +569,9 @@
         try:
             for chunk in "abc":
                 f.seek(0, 0)
-                self.assertTrue(chunk not in f)
+                self.assertNotIn(chunk, f)
                 f.seek(0, 0)
-                self.assertTrue((chunk + "\n") in f)
+                self.assertIn((chunk + "\n"), f)
         finally:
             f.close()
             try:
Index: Lib/test/test_deque.py
===================================================================
--- Lib/test/test_deque.py	(revision 77598)
+++ Lib/test/test_deque.py	(working copy)
@@ -199,9 +199,9 @@
             self.assertEqual(len(d), n-i)
             j = random.randrange(-len(d), len(d))
             val = d[j]
-            self.assertTrue(val in d)
+            self.assertIn(val, d)
             del d[j]
-            self.assertTrue(val not in d)
+            self.assertNotIn(val, d)
         self.assertEqual(len(d), 0)
 
     def test_reverse(self):
@@ -328,7 +328,7 @@
         e = eval(repr(d))
         self.assertEqual(list(d), list(e))
         d.append(d)
-        self.assertTrue('...' in repr(d))
+        self.assertIn('...', repr(d))
 
     def test_print(self):
         d = deque(range(200))
Index: Lib/test/test_datetime.py
===================================================================
--- Lib/test/test_datetime.py	(revision 77598)
+++ Lib/test/test_datetime.py	(working copy)
@@ -139,10 +139,10 @@
         self.assertFalse(() == me)
         self.assertTrue(() != me)
 
-        self.assertTrue(me in [1, 20, [], me])
+        self.assertIn(me, [1, 20, [], me])
         self.assertFalse(me not in [1, 20, [], me])
 
-        self.assertTrue([] in [me, 1, 20, []])
+        self.assertIn([], [me, 1, 20, []])
         self.assertFalse([] not in [me, 1, 20, []])
 
     def test_harmful_mixed_comparison(self):
Index: Lib/test/test_wsgiref.py
===================================================================
--- Lib/test/test_wsgiref.py	(revision 77598)
+++ Lib/test/test_wsgiref.py	(working copy)
@@ -440,7 +440,7 @@
             h.get("content-disposition"))
 
         del h['content-disposition']
-        self.assertTrue(b'content-disposition' not in h)
+        self.assertNotIn(b'content-disposition', h)
 
 
 class ErrorHandler(BaseCGIHandler):
@@ -493,7 +493,7 @@
             if k not in empty:
                 self.assertEqual(env[k],v)
         for k,v in empty.items():
-            self.assertTrue(k in env)
+            self.assertIn(k, env)
 
     def testEnviron(self):
         h = TestHandler(X="Y")
@@ -506,7 +506,7 @@
         h = BaseCGIHandler(None,None,None,{})
         h.setup_environ()
         for key in 'wsgi.url_scheme', 'wsgi.input', 'wsgi.errors':
-            self.assertTrue(key in h.environ)
+            self.assertIn(key, h.environ)
 
     def testScheme(self):
         h=TestHandler(HTTPS="on"); h.setup_environ()
@@ -593,7 +593,7 @@
             "\r\n%s" % (h.error_status,len(h.error_body),h.error_body)
             ).encode("iso-8859-1"))
 
-        self.assertTrue("AssertionError" in h.stderr.getvalue())
+        self.assertIn("AssertionError", h.stderr.getvalue())
 
     def testErrorAfterOutput(self):
         MSG = "Some output has been sent"
@@ -606,7 +606,7 @@
         self.assertEqual(h.stdout.getvalue(),
             ("Status: 200 OK\r\n"
             "\r\n"+MSG).encode("iso-8859-1"))
-        self.assertTrue("AssertionError" in h.stderr.getvalue())
+        self.assertIn("AssertionError", h.stderr.getvalue())
 
 
     def testHeaderFormats(self):
Index: Lib/test/test_unicode_file.py
===================================================================
--- Lib/test/test_unicode_file.py	(revision 77598)
+++ Lib/test/test_unicode_file.py	(working copy)
@@ -47,7 +47,7 @@
         base = unicodedata.normalize("NFD", base)
         file_list = [unicodedata.normalize("NFD", f) for f in file_list]
 
-        self.assertTrue(base in file_list)
+        self.assertIn(base, file_list)
 
     # Do as many "equivalancy' tests as we can - ie, check that although we
     # have different types for the filename, they refer to the same file.
Index: Lib/test/test_pwd.py
===================================================================
--- Lib/test/test_pwd.py	(revision 77598)
+++ Lib/test/test_pwd.py	(working copy)
@@ -43,8 +43,8 @@
         for e in entries:
             if not e[0] or e[0] == '+':
                 continue # skip NIS entries etc.
-            self.assertTrue(pwd.getpwnam(e.pw_name) in entriesbyname[e.pw_name])
-            self.assertTrue(pwd.getpwuid(e.pw_uid) in entriesbyuid[e.pw_uid])
+            self.assertIn(pwd.getpwnam(e.pw_name), entriesbyname[e.pw_name])
+            self.assertIn(pwd.getpwuid(e.pw_uid), entriesbyuid[e.pw_uid])
 
     def test_errors(self):
         self.assertRaises(TypeError, pwd.getpwuid)
Index: Lib/test/test_decimal.py
===================================================================
--- Lib/test/test_decimal.py	(revision 77598)
+++ Lib/test/test_decimal.py	(working copy)
@@ -1673,8 +1673,8 @@
             self.assertEqual(v1, v2)
 
     def test_equality_with_other_types(self):
-        self.assertTrue(Decimal(10) in ['a', 1.0, Decimal(10), (1,2), {}])
-        self.assertTrue(Decimal(10) not in ['a', 1.0, (1,2), {}])
+        self.assertIn(Decimal(10), ['a', 1.0, Decimal(10), (1,2), {}])
+        self.assertNotIn(Decimal(10), ['a', 1.0, (1,2), {}])
 
     def test_copy(self):
         # All copies should be deep
Index: Lib/test/test_weakset.py
===================================================================
--- Lib/test/test_weakset.py	(revision 77598)
+++ Lib/test/test_weakset.py	(working copy)
@@ -51,9 +51,9 @@
         for c in self.letters:
             self.assertEqual(c in self.s, c in self.d)
         self.assertRaises(TypeError, self.s.__contains__, [[]])
-        self.assertTrue(self.obj in self.fs)
+        self.assertIn(self.obj, self.fs)
         del self.obj
-        self.assertTrue(ustr('F') not in self.fs)
+        self.assertNotIn(ustr('F'), self.fs)
 
     def test_union(self):
         u = self.s.union(self.items2)
@@ -150,7 +150,7 @@
         s=H()
         f=set()
         f.add(s)
-        self.assertTrue(s in f)
+        self.assertIn(s, f)
         f.remove(s)
         f.add(s)
         f.discard(s)
@@ -185,7 +185,7 @@
     def test_add(self):
         x = ustr('Q')
         self.s.add(x)
-        self.assertTrue(x in self.s)
+        self.assertIn(x, self.s)
         dup = self.s.copy()
         self.s.add(x)
         self.assertEqual(self.s, dup)
@@ -198,66 +198,66 @@
     def test_remove(self):
         x = ustr('a')
         self.s.remove(x)
-        self.assertTrue(x not in self.s)
+        self.assertNotIn(x, self.s)
         self.assertRaises(KeyError, self.s.remove, x)
         self.assertRaises(TypeError, self.s.remove, [])
 
     def test_discard(self):
         a, q = ustr('a'), ustr('Q')
         self.s.discard(a)
-        self.assertTrue(a not in self.s)
+        self.assertNotIn(a, self.s)
         self.s.discard(q)
         self.assertRaises(TypeError, self.s.discard, [])
 
     def test_pop(self):
         for i in range(len(self.s)):
             elem = self.s.pop()
-            self.assertTrue(elem not in self.s)
+            self.assertNotIn(elem, self.s)
         self.assertRaises(KeyError, self.s.pop)
 
     def test_update(self):
         retval = self.s.update(self.items2)
         self.assertEqual(retval, None)
         for c in (self.items + self.items2):
-            self.assertTrue(c in self.s)
+            self.assertIn(c, self.s)
         self.assertRaises(TypeError, self.s.update, [[]])
 
     def test_update_set(self):
         self.s.update(set(self.items2))
         for c in (self.items + self.items2):
-            self.assertTrue(c in self.s)
+            self.assertIn(c, self.s)
 
     def test_ior(self):
         self.s |= set(self.items2)
         for c in (self.items + self.items2):
-            self.assertTrue(c in self.s)
+            self.assertIn(c, self.s)
 
     def test_intersection_update(self):
         retval = self.s.intersection_update(self.items2)
         self.assertEqual(retval, None)
         for c in (self.items + self.items2):
             if c in self.items2 and c in self.items:
-                self.assertTrue(c in self.s)
+                self.assertIn(c, self.s)
             else:
-                self.assertTrue(c not in self.s)
+                self.assertNotIn(c, self.s)
         self.assertRaises(TypeError, self.s.intersection_update, [[]])
 
     def test_iand(self):
         self.s &= set(self.items2)
         for c in (self.items + self.items2):
             if c in self.items2 and c in self.items:
-                self.assertTrue(c in self.s)
+                self.assertIn(c, self.s)
             else:
-                self.assertTrue(c not in self.s)
+                self.assertNotIn(c, self.s)
 
     def test_difference_update(self):
         retval = self.s.difference_update(self.items2)
         self.assertEqual(retval, None)
         for c in (self.items + self.items2):
             if c in self.items and c not in self.items2:
-                self.assertTrue(c in self.s)
+                self.assertIn(c, self.s)
             else:
-                self.assertTrue(c not in self.s)
+                self.assertNotIn(c, self.s)
         self.assertRaises(TypeError, self.s.difference_update, [[]])
         self.assertRaises(TypeError, self.s.symmetric_difference_update, [[]])
 
@@ -265,27 +265,27 @@
         self.s -= set(self.items2)
         for c in (self.items + self.items2):
             if c in self.items and c not in self.items2:
-                self.assertTrue(c in self.s)
+                self.assertIn(c, self.s)
             else:
-                self.assertTrue(c not in self.s)
+                self.assertNotIn(c, self.s)
 
     def test_symmetric_difference_update(self):
         retval = self.s.symmetric_difference_update(self.items2)
         self.assertEqual(retval, None)
         for c in (self.items + self.items2):
             if (c in self.items) ^ (c in self.items2):
-                self.assertTrue(c in self.s)
+                self.assertIn(c, self.s)
             else:
-                self.assertTrue(c not in self.s)
+                self.assertNotIn(c, self.s)
         self.assertRaises(TypeError, self.s.symmetric_difference_update, [[]])
 
     def test_ixor(self):
         self.s ^= set(self.items2)
         for c in (self.items + self.items2):
             if (c in self.items) ^ (c in self.items2):
-                self.assertTrue(c in self.s)
+                self.assertIn(c, self.s)
             else:
-                self.assertTrue(c not in self.s)
+                self.assertNotIn(c, self.s)
 
     def test_inplace_on_self(self):
         t = self.s.copy()
@@ -348,7 +348,7 @@
         self.assertFalse(u in s)
         with testcontext() as u:
             s.add(u)
-        self.assertTrue(u in s)
+        self.assertIn(u, s)
         t = s.copy()
         with testcontext() as u:
             s.update(t)
Index: Lib/test/test_tempfile.py
===================================================================
--- Lib/test/test_tempfile.py	(revision 77598)
+++ Lib/test/test_tempfile.py	(working copy)
@@ -160,14 +160,14 @@
             for envname in 'TMPDIR', 'TEMP', 'TMP':
                 dirname = os.getenv(envname)
                 if not dirname: raise ValueError
-                self.assertTrue(dirname in cand)
+                self.assertIn(dirname, cand)
 
             try:
                 dirname = os.getcwd()
             except (AttributeError, os.error):
                 dirname = os.curdir
 
-            self.assertTrue(dirname in cand)
+            self.assertIn(dirname, cand)
 
             # Not practical to try to verify the presence of OS-specific
             # paths in this list.
Index: Lib/test/test_random.py
===================================================================
--- Lib/test/test_random.py	(revision 77598)
+++ Lib/test/test_random.py	(working copy)
@@ -211,7 +211,7 @@
 
             n += n - 1      # check 1 below the next power of two
             k = int(1.00001 + _log(n, 2))
-            self.assertTrue(k in [numbits, numbits+1])
+            self.assertIn(k, [numbits, numbits+1])
             self.assertTrue(2**k > n > 2**(k-2))
 
             n -= n >> 15     # check a little farther below the next power of two
@@ -367,7 +367,7 @@
 
             n += n - 1      # check 1 below the next power of two
             k = int(1.00001 + _log(n, 2))
-            self.assertTrue(k in [numbits, numbits+1])
+            self.assertIn(k, [numbits, numbits+1])
             self.assertTrue(2**k > n > 2**(k-2))
 
             n -= n >> 15     # check a little farther below the next power of two
Index: Lib/test/test_telnetlib.py
===================================================================
--- Lib/test/test_telnetlib.py	(revision 77598)
+++ Lib/test/test_telnetlib.py	(working copy)
@@ -284,7 +284,7 @@
         txt = telnet.read_all()
         cmd = nego.seen
         self.assertTrue(len(cmd) > 0) # we expect at least one command
-        self.assertTrue(cmd[:1] in self.cmds)
+        self.assertIn(cmd[:1], self.cmds)
         self.assertEqual(cmd[1:2], tl.NOOPT)
         self.assertEqual(data_len, len(txt + cmd))
         nego.sb_getter = None # break the nego => telnet cycle
@@ -331,7 +331,7 @@
             telnet = test_telnet([a])
             telnet.set_debuglevel(1)
             txt = telnet.read_all()
-            self.assertTrue(b in telnet._messages)
+            self.assertIn(b, telnet._messages)
         return
 
     def test_debuglevel_write(self):
@@ -339,7 +339,7 @@
         telnet.set_debuglevel(1)
         telnet.write(b'xxx')
         expected = "send b'xxx'\n"
-        self.assertTrue(expected in telnet._messages)
+        self.assertIn(expected, telnet._messages)
 
 def test_main(verbose=None):
     support.run_unittest(GeneralTests, ReadTests, WriteTests, OptionTests)
Index: Lib/test/test_weakref.py
===================================================================
--- Lib/test/test_weakref.py	(revision 77598)
+++ Lib/test/test_weakref.py	(working copy)
@@ -193,7 +193,7 @@
             def __bytes__(self):
                 return b"bytes"
         instance = C()
-        self.assertTrue("__bytes__" in dir(weakref.proxy(instance)))
+        self.assertIn("__bytes__", dir(weakref.proxy(instance)))
         self.assertEqual(bytes(weakref.proxy(instance)), b"bytes")
 
     def test_proxy_index(self):
@@ -715,8 +715,8 @@
         refs = weakref.getweakrefs(o)
         self.assertEqual(len(refs), 3)
         self.assertTrue(r2 is refs[0])
-        self.assertTrue(r1 in refs[1:])
-        self.assertTrue(r3 in refs[1:])
+        self.assertIn(r1, refs[1:])
+        self.assertIn(r3, refs[1:])
 
     def test_subclass_refs_dont_conflate_callbacks(self):
         class MyRef(weakref.ref):
@@ -726,8 +726,8 @@
         r2 = MyRef(o, str)
         self.assertTrue(r1 is not r2)
         refs = weakref.getweakrefs(o)
-        self.assertTrue(r1 in refs)
-        self.assertTrue(r2 in refs)
+        self.assertIn(r1, refs)
+        self.assertIn(r2, refs)
 
     def test_subclass_refs_with_slots(self):
         class MyRef(weakref.ref):
@@ -860,8 +860,8 @@
                      "deleting the keys did not clear the dictionary")
         o = Object(42)
         dict[o] = "What is the meaning of the universe?"
-        self.assertTrue(o in dict)
-        self.assertTrue(34 not in dict)
+        self.assertIn(o, dict)
+        self.assertNotIn(34, dict)
 
     def test_weak_keyed_iters(self):
         dict, objects = self.make_weak_keyed_dict()
@@ -873,8 +873,8 @@
         objects2 = list(objects)
         for wr in refs:
             ob = wr()
-            self.assertTrue(ob in dict)
-            self.assertTrue(ob in dict)
+            self.assertIn(ob, dict)
+            self.assertIn(ob, dict)
             self.assertEqual(ob.arg, dict[ob])
             objects2.remove(ob)
         self.assertEqual(len(objects2), 0)
@@ -884,8 +884,8 @@
         self.assertEqual(len(list(dict.keyrefs())), len(objects))
         for wr in dict.keyrefs():
             ob = wr()
-            self.assertTrue(ob in dict)
-            self.assertTrue(ob in dict)
+            self.assertIn(ob, dict)
+            self.assertIn(ob, dict)
             self.assertEqual(ob.arg, dict[ob])
             objects2.remove(ob)
         self.assertEqual(len(objects2), 0)
@@ -1091,13 +1091,13 @@
         weakdict = klass()
         o = weakdict.setdefault(key, value1)
         self.assertTrue(o is value1)
-        self.assertTrue(key in weakdict)
+        self.assertIn(key, weakdict)
         self.assertTrue(weakdict.get(key) is value1)
         self.assertTrue(weakdict[key] is value1)
 
         o = weakdict.setdefault(key, value2)
         self.assertTrue(o is value1)
-        self.assertTrue(key in weakdict)
+        self.assertIn(key, weakdict)
         self.assertTrue(weakdict.get(key) is value1)
         self.assertTrue(weakdict[key] is value1)
 
Index: Lib/test/test_subprocess.py
===================================================================
--- Lib/test/test_subprocess.py	(revision 77598)
+++ Lib/test/test_subprocess.py	(working copy)
@@ -77,7 +77,7 @@
         # check_output() function with zero return code
         output = subprocess.check_output(
                 [sys.executable, "-c", "print('BDFL')"])
-        self.assertTrue(b'BDFL' in output)
+        self.assertIn(b'BDFL', output)
 
     def test_check_output_nonzero(self):
         # check_call() function with non-zero return code
@@ -94,7 +94,7 @@
         output = subprocess.check_output(
                 [sys.executable, "-c", "import sys; sys.stderr.write('BDFL')"],
                 stderr=subprocess.STDOUT)
-        self.assertTrue(b'BDFL' in output)
+        self.assertIn(b'BDFL', output)
 
     def test_check_output_stdout_arg(self):
         # check_output() function stderr redirected to stdout
@@ -103,7 +103,7 @@
                     [sys.executable, "-c", "print('will not be run')"],
                     stdout=sys.stdout)
         except ValueError as e:
-            self.assertTrue('stdout' in e.args[0])
+            self.assertIn('stdout', e.args[0])
         else:
             self.fail("Expected ValueError when stdout arg supplied.")
 
Index: Lib/test/test_range.py
===================================================================
--- Lib/test/test_range.py	(revision 77598)
+++ Lib/test/test_range.py	(working copy)
@@ -59,18 +59,18 @@
         self.assertEqual(list(range(a+4, a, -2)), [a+4, a+2])
 
         seq = list(range(a, b, c))
-        self.assertTrue(a in seq)
-        self.assertTrue(b not in seq)
+        self.assertIn(a, seq)
+        self.assertNotIn(b, seq)
         self.assertEqual(len(seq), 2)
 
         seq = list(range(b, a, -c))
-        self.assertTrue(b in seq)
-        self.assertTrue(a not in seq)
+        self.assertIn(b, seq)
+        self.assertNotIn(a, seq)
         self.assertEqual(len(seq), 2)
 
         seq = list(range(-a, -b, -c))
-        self.assertTrue(-a in seq)
-        self.assertTrue(-b not in seq)
+        self.assertIn(-a, seq)
+        self.assertNotIn(-b, seq)
         self.assertEqual(len(seq), 2)
 
         self.assertRaises(TypeError, range)
@@ -114,13 +114,13 @@
     def test_types(self):
         # Non-integer objects *equal* to any of the range's items are supposed
         # to be contained in the range.
-        self.assertTrue(1.0 in range(3))
-        self.assertTrue(True in range(3))
-        self.assertTrue(1+0j in range(3))
+        self.assertIn(1.0, range(3))
+        self.assertIn(True, range(3))
+        self.assertIn(1+0j, range(3))
 
         class C1:
             def __eq__(self, other): return True
-        self.assertTrue(C1() in range(3))
+        self.assertIn(C1(), range(3))
 
         # Objects are never coerced into other types for comparison.
         class C2:
@@ -128,32 +128,32 @@
             def __index__(self): return 1
         self.assertFalse(C2() in range(3))
         # ..except if explicitly told so.
-        self.assertTrue(int(C2()) in range(3))
+        self.assertIn(int(C2()), range(3))
 
         # Check that the range.__contains__ optimization is only
         # used for ints, not for instances of subclasses of int.
         class C3(int):
             def __eq__(self, other): return True
-        self.assertTrue(C3(11) in range(10))
-        self.assertTrue(C3(11) in list(range(10)))
+        self.assertIn(C3(11), range(10))
+        self.assertIn(C3(11), list(range(10)))
 
     def test_strided_limits(self):
         r = range(0, 101, 2)
-        self.assertTrue(0 in r)
+        self.assertIn(0, r)
         self.assertFalse(1 in r)
-        self.assertTrue(2 in r)
+        self.assertIn(2, r)
         self.assertFalse(99 in r)
-        self.assertTrue(100 in r)
+        self.assertIn(100, r)
         self.assertFalse(101 in r)
 
         r = range(0, -20, -1)
-        self.assertTrue(0 in r)
-        self.assertTrue(-1 in r)
-        self.assertTrue(-19 in r)
+        self.assertIn(0, r)
+        self.assertIn(-1, r)
+        self.assertIn(-19, r)
         self.assertFalse(-20 in r)
 
         r = range(0, -20, -2)
-        self.assertTrue(-18 in r)
+        self.assertIn(-18, r)
         self.assertFalse(-19 in r)
         self.assertFalse(-20 in r)
 
Index: Lib/test/test_zipimport.py
===================================================================
--- Lib/test/test_zipimport.py	(revision 77598)
+++ Lib/test/test_zipimport.py	(working copy)
@@ -294,7 +294,7 @@
             z.close()
             zi = zipimport.zipimporter(TEMP_ZIP)
             self.assertEquals(data, zi.get_data(name))
-            self.assertTrue('zipimporter object' in repr(zi))
+            self.assertIn('zipimporter object', repr(zi))
         finally:
             z.close()
             os.remove(TEMP_ZIP)
Index: Lib/test/test_cmd_line_script.py
===================================================================
--- Lib/test/test_cmd_line_script.py	(revision 77598)
+++ Lib/test/test_cmd_line_script.py	(working copy)
@@ -80,9 +80,9 @@
             print(printed_file)
             print(printed_package)
             print(printed_argv0)
-        self.assertTrue(printed_file.encode('utf-8') in data)
-        self.assertTrue(printed_package.encode('utf-8') in data)
-        self.assertTrue(printed_argv0.encode('utf-8') in data)
+        self.assertIn(printed_file.encode('utf-8'), data)
+        self.assertIn(printed_package.encode('utf-8'), data)
+        self.assertIn(printed_argv0.encode('utf-8'), data)
 
     def _check_import_error(self, script_name, expected_msg,
                             *cmd_line_switches):
@@ -92,7 +92,7 @@
             print('Output from test script %r:' % script_name)
             print(data)
             print('Expected output: %r' % expected_msg)
-        self.assertTrue(expected_msg.encode('utf-8') in data)
+        self.assertIn(expected_msg.encode('utf-8'), data)
 
     def test_basic_script(self):
         with temp_dir() as script_dir:
Index: Lib/test/test_import.py
===================================================================
--- Lib/test/test_import.py	(revision 77598)
+++ Lib/test/test_import.py	(working copy)
@@ -209,7 +209,7 @@
         sys.path.insert(0, os.curdir)
         try:
             mod = __import__(TESTFN)
-            self.assertTrue(TESTFN in sys.modules, "expected module in sys.modules")
+            self.assertIn(TESTFN, sys.modules)
             self.assertEquals(mod.a, 1, "module has wrong attribute values")
             self.assertEquals(mod.b, 2, "module has wrong attribute values")
 
@@ -253,7 +253,7 @@
             del sys.modules[TESTFN]
             mod = __import__(TESTFN)
             ext = mod.__file__[-4:]
-            self.assertTrue(ext in ('.pyc', '.pyo'), ext)
+            self.assertIn(ext, ('.pyc', '.pyo'))
         finally:
             sys.path.pop(0)
             remove_files(TESTFN)
Index: Lib/test/test_unittest.py
===================================================================
--- Lib/test/test_unittest.py	(revision 77598)
+++ Lib/test/test_unittest.py	(working copy)
@@ -636,7 +636,7 @@
             self.assertEqual(list(suite), [])
 
             # audioop should now be loaded, thanks to loadTestsFromName()
-            self.assertTrue(module_name in sys.modules)
+            self.assertIn(module_name, sys.modules)
         finally:
             if module_name in sys.modules:
                 del sys.modules[module_name]
@@ -1024,7 +1024,7 @@
             self.assertEqual(list(suite), [unittest.TestSuite()])
 
             # audioop should now be loaded, thanks to loadTestsFromName()
-            self.assertTrue(module_name in sys.modules)
+            self.assertIn(module_name, sys.modules)
         finally:
             if module_name in sys.modules:
                 del sys.modules[module_name]
Index: Lib/test/test_glob.py
===================================================================
--- Lib/test/test_glob.py	(revision 77598)
+++ Lib/test/test_glob.py	(working copy)
@@ -96,7 +96,7 @@
         res = glob.glob(self.tempdir + '*' + os.sep)
         self.assertEqual(len(res), 1)
         # either of these results are reasonable
-        self.assertTrue(res[0] in [self.tempdir, self.tempdir + os.sep])
+        self.assertIn(res[0], [self.tempdir, self.tempdir + os.sep])
 
     def test_glob_broken_symlinks(self):
         if hasattr(os, 'symlink'):
Index: Lib/test/test_bytes.py
===================================================================
--- Lib/test/test_bytes.py	(revision 77598)
+++ Lib/test/test_bytes.py	(working copy)
@@ -229,8 +229,8 @@
 
     def test_contains(self):
         b = self.type2test(b"abc")
-        self.assertTrue(ord('a') in b)
-        self.assertTrue(int(ord('a')) in b)
+        self.assertIn(ord('a'), b)
+        self.assertIn(int(ord('a')), b)
         self.assertFalse(200 in b)
         self.assertFalse(200 in b)
         self.assertRaises(ValueError, lambda: 300 in b)
@@ -239,13 +239,13 @@
         self.assertRaises(TypeError, lambda: float(ord('a')) in b)
         self.assertRaises(TypeError, lambda: "a" in b)
         for f in bytes, bytearray:
-            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.assertIn(f(b""), b)
+            self.assertIn(f(b"a"), b)
+            self.assertIn(f(b"b"), b)
+            self.assertIn(f(b"c"), b)
+            self.assertIn(f(b"ab"), b)
+            self.assertIn(f(b"bc"), b)
+            self.assertIn(f(b"abc"), b)
             self.assertFalse(f(b"ac") in b)
             self.assertFalse(f(b"d") in b)
             self.assertFalse(f(b"dab") in b)
Index: Lib/test/test_posix.py
===================================================================
--- Lib/test/test_posix.py	(revision 77598)
+++ Lib/test/test_posix.py	(working copy)
@@ -251,7 +251,7 @@
 
     def test_lsdir(self):
         if hasattr(posix, 'lsdir'):
-            self.assertTrue(support.TESTFN in posix.lsdir(os.curdir))
+            self.assertIn(support.TESTFN, posix.lsdir(os.curdir))
 
     def test_access(self):
         if hasattr(posix, 'access'):
Index: Lib/test/test_threading_local.py
===================================================================
--- Lib/test/test_threading_local.py	(revision 77598)
+++ Lib/test/test_threading_local.py	(working copy)
@@ -40,7 +40,7 @@
         local.someothervar = None
         gc.collect()
         deadlist = [weak for weak in weaklist if weak() is None]
-        self.assertTrue(len(deadlist) in (n-1, n), (n, len(deadlist)))
+        self.assertIn(len(deadlist), (n-1, n), (n, len(deadlist)))
 
     def test_derived(self):
         # Issue 3088: if there is a threads switch inside the __init__
Index: Lib/test/test_multiprocessing.py
===================================================================
--- Lib/test/test_multiprocessing.py	(revision 77598)
+++ Lib/test/test_multiprocessing.py	(working copy)
@@ -163,7 +163,7 @@
             self.assertEquals(p.authkey, current.authkey)
         self.assertEquals(p.is_alive(), False)
         self.assertEquals(p.daemon, True)
-        self.assertTrue(p not in self.active_children())
+        self.assertNotIn(p, self.active_children())
         self.assertTrue(type(self.active_children()) is list)
         self.assertEqual(p.exitcode, None)
 
@@ -171,7 +171,7 @@
 
         self.assertEquals(p.exitcode, None)
         self.assertEquals(p.is_alive(), True)
-        self.assertTrue(p in self.active_children())
+        self.assertIn(p, self.active_children())
 
         self.assertEquals(q.get(), args[1:])
         self.assertEquals(q.get(), kwargs)
@@ -184,7 +184,7 @@
 
         self.assertEquals(p.exitcode, 0)
         self.assertEquals(p.is_alive(), False)
-        self.assertTrue(p not in self.active_children())
+        self.assertNotIn(p, self.active_children())
 
     def _test_terminate(self):
         time.sleep(1000)
@@ -198,7 +198,7 @@
         p.start()
 
         self.assertEqual(p.is_alive(), True)
-        self.assertTrue(p in self.active_children())
+        self.assertIn(p, self.active_children())
         self.assertEqual(p.exitcode, None)
 
         p.terminate()
@@ -208,7 +208,7 @@
         self.assertTimingAlmostEqual(join.elapsed, 0.0)
 
         self.assertEqual(p.is_alive(), False)
-        self.assertTrue(p not in self.active_children())
+        self.assertNotIn(p, self.active_children())
 
         p.join()
 
@@ -227,13 +227,13 @@
         self.assertEqual(type(self.active_children()), list)
 
         p = self.Process(target=time.sleep, args=(DELTA,))
-        self.assertTrue(p not in self.active_children())
+        self.assertNotIn(p, self.active_children())
 
         p.start()
-        self.assertTrue(p in self.active_children())
+        self.assertIn(p, self.active_children())
 
         p.join()
-        self.assertTrue(p not in self.active_children())
+        self.assertNotIn(p, self.active_children())
 
     def _test_recursion(self, wconn, id):
         from multiprocessing import forking
Index: Lib/test/test_sax.py
===================================================================
--- Lib/test/test_sax.py	(revision 77598)
+++ Lib/test/test_sax.py	(working copy)
@@ -59,7 +59,7 @@
         self.assertEquals(attrs.getNames(), ["attr"])
         self.assertEquals(attrs.getQNames(), ["attr"])
         self.assertEquals(len(attrs), 1)
-        self.assertTrue("attr" in attrs)
+        self.assertIn("attr", attrs)
         self.assertEquals(list(attrs.keys()), ["attr"])
         self.assertEquals(attrs.get("attr"), "val")
         self.assertEquals(attrs.get("attr", 25), "val")
@@ -436,7 +436,7 @@
         self.assertTrue((attrs.getQNames() == [] or
                          attrs.getQNames() == ["ns:attr"]))
         self.assertEquals(len(attrs), 1)
-        self.assertTrue((ns_uri, "attr") in attrs)
+        self.assertIn((ns_uri, "attr"), attrs)
         self.assertEquals(attrs.get((ns_uri, "attr")), "val")
         self.assertEquals(attrs.get((ns_uri, "attr"), 25), "val")
         self.assertEquals(list(attrs.items()), [((ns_uri, "attr"), "val")])
@@ -626,7 +626,7 @@
         self.assertEquals(attrs.getNames(), [(ns_uri, "attr")])
         self.assertEquals(attrs.getQNames(), ["ns:attr"])
         self.assertEquals(len(attrs), 1)
-        self.assertTrue((ns_uri, "attr") in attrs)
+        self.assertIn((ns_uri, "attr"), attrs)
         self.assertEquals(list(attrs.keys()), [(ns_uri, "attr")])
         self.assertEquals(attrs.get((ns_uri, "attr")), "val")
         self.assertEquals(attrs.get((ns_uri, "attr"), 25), "val")
Index: Lib/test/test_bigmem.py
===================================================================
--- Lib/test/test_bigmem.py	(revision 77598)
+++ Lib/test/test_bigmem.py	(working copy)
@@ -519,12 +519,12 @@
         edge = _('-') * (size // 2)
         s = _('').join([edge, SUBSTR, edge])
         del edge
-        self.assertTrue(SUBSTR in s)
+        self.assertIn(SUBSTR, s)
         self.assertFalse(SUBSTR * 2 in s)
-        self.assertTrue(_('-') in s)
+        self.assertIn(_('-'), s)
         self.assertFalse(_('a') in s)
         s += _('a')
-        self.assertTrue(_('a') in s)
+        self.assertIn(_('a'), s)
 
     @bigmemtest(minsize=_2G + 10, memuse=2)
     def test_compare(self, size):
@@ -768,7 +768,7 @@
     def test_contains(self, size):
         t = (1, 2, 3, 4, 5) * size
         self.assertEquals(len(t), size * 5)
-        self.assertTrue(5 in t)
+        self.assertIn(5, t)
         self.assertFalse((1, 2, 3, 4, 5) in t)
         self.assertFalse(0 in t)
 
@@ -917,7 +917,7 @@
     def test_contains(self, size):
         l = [1, 2, 3, 4, 5] * size
         self.assertEquals(len(l), size * 5)
-        self.assertTrue(5 in l)
+        self.assertIn(5, l)
         self.assertFalse([1, 2, 3, 4, 5] in l)
         self.assertFalse(0 in l)
 
Index: Lib/test/test_zipfile.py
===================================================================
--- Lib/test/test_zipfile.py	(revision 77598)
+++ Lib/test/test_zipfile.py	(working copy)
@@ -63,9 +63,9 @@
             lines = directory.splitlines()
             self.assertEqual(len(lines), 4) # Number of files + header
 
-            self.assertTrue('File Name' in lines[0])
-            self.assertTrue('Modified' in lines[0])
-            self.assertTrue('Size' in lines[0])
+            self.assertIn('File Name', lines[0])
+            self.assertIn('Modified', lines[0])
+            self.assertIn('Size', lines[0])
 
             fn, date, time_, size = lines[1].split()
             self.assertEqual(fn, 'another.name')
@@ -76,17 +76,17 @@
             # Check the namelist
             names = zipfp.namelist()
             self.assertEqual(len(names), 3)
-            self.assertTrue(TESTFN in names)
-            self.assertTrue("another.name" in names)
-            self.assertTrue("strfile" in names)
+            self.assertIn(TESTFN, names)
+            self.assertIn("another.name", names)
+            self.assertIn("strfile", names)
 
             # Check infolist
             infos = zipfp.infolist()
             names = [i.filename for i in infos]
             self.assertEqual(len(names), 3)
-            self.assertTrue(TESTFN in names)
-            self.assertTrue("another.name" in names)
-            self.assertTrue("strfile" in names)
+            self.assertIn(TESTFN, names)
+            self.assertIn("another.name", names)
+            self.assertIn("strfile", names)
             for i in infos:
                 self.assertEqual(i.file_size, len(self.data))
 
@@ -459,9 +459,9 @@
             lines = directory.splitlines()
             self.assertEqual(len(lines), 4) # Number of files + header
 
-            self.assertTrue('File Name' in lines[0])
-            self.assertTrue('Modified' in lines[0])
-            self.assertTrue('Size' in lines[0])
+            self.assertIn('File Name', lines[0])
+            self.assertIn('Modified', lines[0])
+            self.assertIn('Size', lines[0])
 
             fn, date, time_, size = lines[1].split()
             self.assertEqual(fn, 'another.name')
@@ -472,17 +472,17 @@
             # Check the namelist
             names = zipfp.namelist()
             self.assertEqual(len(names), 3)
-            self.assertTrue(TESTFN in names)
-            self.assertTrue("another.name" in names)
-            self.assertTrue("strfile" in names)
+            self.assertIn(TESTFN, names)
+            self.assertIn("another.name", names)
+            self.assertIn("strfile", names)
 
             # Check infolist
             infos = zipfp.infolist()
             names = [i.filename for i in infos]
             self.assertEqual(len(names), 3)
-            self.assertTrue(TESTFN in names)
-            self.assertTrue("another.name" in names)
-            self.assertTrue("strfile" in names)
+            self.assertIn(TESTFN, names)
+            self.assertIn("another.name", names)
+            self.assertIn("strfile", names)
             for i in infos:
                 self.assertEqual(i.file_size, len(self.data))
 
@@ -528,7 +528,7 @@
             zipfp.writepy(fn)
 
             bn = os.path.basename(fn)
-            self.assertTrue(bn not in zipfp.namelist())
+            self.assertNotIn(bn, zipfp.namelist())
             self.assertTrue(bn + 'o' in zipfp.namelist() or
                             bn + 'c' in zipfp.namelist())
 
@@ -540,7 +540,7 @@
             zipfp.writepy(fn, "testpackage")
 
             bn = "%s/%s" % ("testpackage", os.path.basename(fn))
-            self.assertTrue(bn not in zipfp.namelist())
+            self.assertNotIn(bn, zipfp.namelist())
             self.assertTrue(bn + 'o' in zipfp.namelist() or
                             bn + 'c' in zipfp.namelist())
 
@@ -577,7 +577,7 @@
             names = zipfp.namelist()
             self.assertTrue('mod1.pyc' in names or 'mod1.pyo' in names)
             self.assertTrue('mod2.pyc' in names or 'mod2.pyo' in names)
-            self.assertTrue('mod2.txt' not in names)
+            self.assertNotIn('mod2.txt', names)
 
         finally:
             shutil.rmtree(TESTFN2)
Index: Lib/test/test_dbm_gnu.py
===================================================================
--- Lib/test/test_dbm_gnu.py	(revision 77598)
+++ Lib/test/test_dbm_gnu.py	(working copy)
@@ -24,11 +24,11 @@
         self.g[b'bytes'] = b'data'
         key_set = set(self.g.keys())
         self.assertEqual(key_set, set([b'a', b'bytes', b'12345678910']))
-        self.assertTrue(b'a' in self.g)
+        self.assertIn(b'a', self.g)
         self.assertEqual(self.g[b'bytes'], b'data')
         key = self.g.firstkey()
         while key:
-            self.assertTrue(key in key_set)
+            self.assertIn(key, key_set)
             key_set.remove(key)
             key = self.g.nextkey(key)
         self.assertRaises(KeyError, lambda: self.g['xxx'])
Index: Lib/test/test_urllib2.py
===================================================================
--- Lib/test/test_urllib2.py	(revision 77598)
+++ Lib/test/test_urllib2.py	(working copy)
@@ -787,8 +787,8 @@
             r = MockResponse(200, "OK", {}, "")
             newreq = h.do_request_(req)
             if data is None:  # GET
-                self.assertTrue("Content-length" not in req.unredirected_hdrs)
-                self.assertTrue("Content-type" not in req.unredirected_hdrs)
+                self.assertNotIn("Content-length", req.unredirected_hdrs)
+                self.assertNotIn("Content-type", req.unredirected_hdrs)
             else:  # POST
                 self.assertEqual(req.unredirected_hdrs["Content-length"], "0")
                 self.assertEqual(req.unredirected_hdrs["Content-type"],
@@ -907,13 +907,13 @@
                 # now it's a GET, there should not be headers regarding content
                 # (possibly dragged from before being a POST)
                 headers = [x.lower() for x in o.req.headers]
-                self.assertTrue("content-length" not in headers)
-                self.assertTrue("content-type" not in headers)
+                self.assertNotIn("content-length", headers)
+                self.assertNotIn("content-type", headers)
 
                 self.assertEqual(o.req.headers["Nonsense"],
                                  "viking=withhold")
-                self.assertTrue("Spam" not in o.req.headers)
-                self.assertTrue("Spam" not in o.req.unredirected_hdrs)
+                self.assertNotIn("Spam", o.req.headers)
+                self.assertNotIn("Spam", o.req.unredirected_hdrs)
 
         # loop detection
         req = Request(from_url)
Index: Lib/test/test_userdict.py
===================================================================
--- Lib/test/test_userdict.py	(revision 77598)
+++ Lib/test/test_userdict.py	(working copy)
@@ -95,7 +95,7 @@
 
         # Test "in".
         for i in u2.keys():
-            self.assertTrue(i in u2)
+            self.assertIn(i, u2)
             self.assertEqual(i in u1, i in d1)
             self.assertEqual(i in u0, i in d0)
 
@@ -122,7 +122,7 @@
         # Test setdefault
         t = collections.UserDict()
         self.assertEqual(t.setdefault("x", 42), 42)
-        self.assertTrue("x" in t)
+        self.assertIn("x", t)
         self.assertEqual(t.setdefault("x", 23), 42)
 
         # Test pop
@@ -152,8 +152,8 @@
         d = D({1: 2, 3: 4})
         self.assertEqual(d[1], 2)
         self.assertEqual(d[3], 4)
-        self.assertTrue(2 not in d)
-        self.assertTrue(2 not in d.keys())
+        self.assertNotIn(2, d)
+        self.assertNotIn(2, d.keys())
         self.assertEqual(d[2], 42)
         class E(collections.UserDict):
             def __missing__(self, key):
Index: Lib/test/test_dbm_ndbm.py
===================================================================
--- Lib/test/test_dbm_ndbm.py	(revision 77598)
+++ Lib/test/test_dbm_ndbm.py	(working copy)
@@ -24,7 +24,7 @@
         self.d[b'bytes'] = b'data'
         self.d['12345678910'] = '019237410982340912840198242'
         self.d.keys()
-        self.assertTrue(b'a' in self.d)
+        self.assertIn(b'a', self.d)
         self.assertEqual(self.d[b'bytes'], b'data')
         self.d.close()
 
Index: Lib/test/test_threading.py
===================================================================
--- Lib/test/test_threading.py	(revision 77598)
+++ Lib/test/test_threading.py	(working copy)
@@ -153,7 +153,7 @@
         tid = _thread.start_new_thread(f, (mutex,))
         # Wait for the thread to finish.
         mutex.acquire()
-        self.assertTrue(tid in threading._active)
+        self.assertIn(tid, threading._active)
         self.assertTrue(isinstance(threading._active[tid],
                                 threading._DummyThread))
         del threading._active[tid]
Index: Lib/test/test_builtin.py
===================================================================
--- Lib/test/test_builtin.py	(revision 77598)
+++ Lib/test/test_builtin.py	(working copy)
@@ -248,11 +248,11 @@
 
         # dir() - local scope
         local_var = 1
-        self.assertTrue('local_var' in dir())
+        self.assertIn('local_var', dir())
 
         # dir(module)
         import sys
-        self.assertTrue('exit' in dir(sys))
+        self.assertIn('exit', dir(sys))
 
         # dir(module_with_invalid__dict__)
         import types
@@ -262,8 +262,8 @@
         self.assertRaises(TypeError, dir, f)
 
         # dir(type)
-        self.assertTrue("strip" in dir(str))
-        self.assertTrue("__mro__" not in dir(str))
+        self.assertIn("strip", dir(str))
+        self.assertNotIn("__mro__", dir(str))
 
         # dir(obj)
         class Foo(object):
@@ -272,13 +272,13 @@
                 self.y = 8
                 self.z = 9
         f = Foo()
-        self.assertTrue("y" in dir(f))
+        self.assertIn("y", dir(f))
 
         # dir(obj_no__dict__)
         class Foo(object):
             __slots__ = []
         f = Foo()
-        self.assertTrue("__repr__" in dir(f))
+        self.assertIn("__repr__", dir(f))
 
         # dir(obj_no__class__with__dict__)
         # (an ugly trick to cause getattr(f, "__class__") to fail)
@@ -287,8 +287,8 @@
             def __init__(self):
                 self.bar = "wow"
         f = Foo()
-        self.assertTrue("__repr__" not in dir(f))
-        self.assertTrue("bar" in dir(f))
+        self.assertNotIn("__repr__", dir(f))
+        self.assertIn("bar", dir(f))
 
         # dir(obj_using __dir__)
         class Foo(object):
@@ -914,18 +914,18 @@
         self.assertEqual(list(range(a+4, a, -2)), [a+4, a+2])
 
         seq = list(range(a, b, c))
-        self.assertTrue(a in seq)
-        self.assertTrue(b not in seq)
+        self.assertIn(a, seq)
+        self.assertNotIn(b, seq)
         self.assertEqual(len(seq), 2)
 
         seq = list(range(b, a, -c))
-        self.assertTrue(b in seq)
-        self.assertTrue(a not in seq)
+        self.assertIn(b, seq)
+        self.assertNotIn(a, seq)
         self.assertEqual(len(seq), 2)
 
         seq = list(range(-a, -b, -c))
-        self.assertTrue(-a in seq)
-        self.assertTrue(-b not in seq)
+        self.assertIn(-a, seq)
+        self.assertNotIn(-b, seq)
         self.assertEqual(len(seq), 2)
 
         self.assertRaises(TypeError, range)
Index: Lib/test/test_funcattrs.py
===================================================================
--- Lib/test/test_funcattrs.py	(revision 77598)
+++ Lib/test/test_funcattrs.py	(working copy)
@@ -35,11 +35,11 @@
 
     def test_dir_includes_correct_attrs(self):
         self.b.known_attr = 7
-        self.assertTrue('known_attr' in dir(self.b),
+        self.assertIn('known_attr', dir(self.b),
             "set attributes not in dir listing of method")
         # Test on underlying function object of method
         self.F.a.known_attr = 7
-        self.assertTrue('known_attr' in dir(self.fi.a), "set attribute on function "
+        self.assertIn('known_attr', dir(self.fi.a), "set attribute on function "
                      "implementations, should show up in next dir")
 
     def test_duplicate_function_equality(self):
Index: Lib/test/test_collections.py
===================================================================
--- Lib/test/test_collections.py	(revision 77598)
+++ Lib/test/test_collections.py	(working copy)
@@ -44,9 +44,9 @@
         namedtuple('_', 'a b c')        # Test leading underscores in a typename
 
         nt = namedtuple('nt', 'the quick brown fox')                       # check unicode input
-        self.assertTrue("u'" not in repr(nt._fields))
+        self.assertNotIn("u'", repr(nt._fields))
         nt = namedtuple('nt', ('the', 'quick'))                           # check unicode input
-        self.assertTrue("u'" not in repr(nt._fields))
+        self.assertNotIn("u'", repr(nt._fields))
 
         self.assertRaises(TypeError, Point._make, [11])                     # catch too few args
         self.assertRaises(TypeError, Point._make, [11, 22, 33])             # catch too many args
@@ -75,8 +75,8 @@
         self.assertRaises(TypeError, eval, 'Point(XXX=1, y=2)', locals())   # wrong keyword argument
         self.assertRaises(TypeError, eval, 'Point(x=1)', locals())          # missing keyword argument
         self.assertEqual(repr(p), 'Point(x=11, y=22)')
-        self.assertTrue('__dict__' not in dir(p))                              # verify instance has no dict
-        self.assertTrue('__weakref__' not in dir(p))
+        self.assertNotIn('__dict__', dir(p))                              # verify instance has no dict
+        self.assertNotIn('__weakref__', dir(p))
         self.assertEqual(p, Point._make([11, 22]))                          # test _make classmethod
         self.assertEqual(p._fields, ('x', 'y'))                             # test _fields attribute
         self.assertEqual(p._replace(x=1), (1, 22))                          # test _replace method
@@ -598,6 +598,7 @@
         c = Counter(a=10, b=-2, c=0)
         for elem in c:
             self.assertTrue(elem in c)
+            self.assertIn(elem, c)
 
     def test_multiset_operations(self):
         # Verify that adding a zero counter will strip zeros and negatives
@@ -697,7 +698,7 @@
         pairs = [('c', 1), ('b', 2), ('a', 3), ('d', 4), ('e', 5), ('f', 6)]
         od = OrderedDict(pairs)
         del od['a']
-        self.assertTrue('a' not in od)
+        self.assertNotIn('a', od)
         with self.assertRaises(KeyError):
             del od['a']
         self.assertEqual(list(od.items()), pairs[:2] + pairs[3:])
Index: Lib/test/test_sys.py
===================================================================
--- Lib/test/test_sys.py	(revision 77598)
+++ Lib/test/test_sys.py	(working copy)
@@ -318,8 +318,8 @@
         d = sys._current_frames()
 
         main_id = _thread.get_ident()
-        self.assertTrue(main_id in d)
-        self.assertTrue(thread_id in d)
+        self.assertIn(main_id, d)
+        self.assertIn(thread_id, d)
 
         # Verify that the captured main-thread frame is _this_ frame.
         frame = d.pop(main_id)
@@ -341,7 +341,7 @@
         # And the next record must be for g456().
         filename, lineno, funcname, sourceline = stack[i+1]
         self.assertEqual(funcname, "g456")
-        self.assertTrue(sourceline in ["leave_g.wait()", "entered_g.set()"])
+        self.assertIn(sourceline, ["leave_g.wait()", "entered_g.set()"])
 
         # Reap the spawned thread.
         leave_g.set()
@@ -353,13 +353,13 @@
         # "thread id" 0.
         d = sys._current_frames()
         self.assertEqual(len(d), 1)
-        self.assertTrue(0 in d)
+        self.assertIn(0, d)
         self.assertTrue(d[0] is sys._getframe())
 
     def test_attributes(self):
         self.assertTrue(isinstance(sys.api_version, int))
         self.assertTrue(isinstance(sys.argv, list))
-        self.assertTrue(sys.byteorder in ("little", "big"))
+        self.assertIn(sys.byteorder, ("little", "big"))
         self.assertTrue(isinstance(sys.builtin_module_names, tuple))
         self.assertTrue(isinstance(sys.copyright, str))
         self.assertTrue(isinstance(sys.exec_prefix, str))
@@ -383,7 +383,7 @@
         self.assertTrue(isinstance(vi[0], int))
         self.assertTrue(isinstance(vi[1], int))
         self.assertTrue(isinstance(vi[2], int))
-        self.assertTrue(vi[3] in ("alpha", "beta", "candidate", "final"))
+        self.assertIn(vi[3], ("alpha", "beta", "candidate", "final"))
         self.assertTrue(isinstance(vi[4], int))
         self.assertTrue(isinstance(vi.major, int))
         self.assertTrue(isinstance(vi.minor, int))
@@ -398,7 +398,7 @@
         self.assertEqual(vi[4], vi.serial)
         self.assertTrue(vi > (1,0,0))
         self.assertIsInstance(sys.float_repr_style, str)
-        self.assertTrue(sys.float_repr_style in ('short', 'legacy'))
+        self.assertIn(sys.float_repr_style, ('short', 'legacy'))
 
     def test_43581(self):
         # Can't use sys.stdout, as this is a StringIO object when
Index: Lib/test/test_posixpath.py
===================================================================
--- Lib/test/test_posixpath.py	(revision 77598)
+++ Lib/test/test_posixpath.py	(working copy)
@@ -481,14 +481,14 @@
         self.assertRaises(TypeError, posixpath.normpath)
 
     def test_abspath(self):
-        self.assertTrue("foo" in posixpath.abspath("foo"))
-        self.assertTrue(b"foo" in posixpath.abspath(b"foo"))
+        self.assertIn("foo", posixpath.abspath("foo"))
+        self.assertIn(b"foo", posixpath.abspath(b"foo"))
 
         self.assertRaises(TypeError, posixpath.abspath)
 
     def test_realpath(self):
-        self.assertTrue("foo" in realpath("foo"))
-        self.assertTrue(b"foo" in realpath(b"foo"))
+        self.assertIn("foo", realpath("foo"))
+        self.assertIn(b"foo", realpath(b"foo"))
         self.assertRaises(TypeError, posixpath.realpath)
 
     if hasattr(os, "symlink"):