diff -r 6c186caa6285 Lib/ctypes/test/test_bitfields.py
--- a/Lib/ctypes/test/test_bitfields.py	Wed Dec 26 01:45:22 2012 -0800
+++ b/Lib/ctypes/test/test_bitfields.py	Thu Dec 27 18:33:36 2012 +0200
@@ -246,9 +246,9 @@
             _fields_ = [("a", c_uint32, 32)]
         x = X()
         x.a = 10
-        self.assertEquals(x.a, 10)
+        self.assertEqual(x.a, 10)
         x.a = 0xFDCBA987
-        self.assertEquals(x.a, 0xFDCBA987)
+        self.assertEqual(x.a, 0xFDCBA987)
 
     @unittest.skipUnless(hasattr(ctypes, "c_uint64"), "c_int64 is required")
     def test_uint64(self):
@@ -256,9 +256,9 @@
             _fields_ = [("a", c_uint64, 64)]
         x = X()
         x.a = 10
-        self.assertEquals(x.a, 10)
+        self.assertEqual(x.a, 10)
         x.a = 0xFEDCBA9876543211
-        self.assertEquals(x.a, 0xFEDCBA9876543211)
+        self.assertEqual(x.a, 0xFEDCBA9876543211)
 
 if __name__ == "__main__":
     unittest.main()
diff -r 6c186caa6285 Lib/lib2to3/tests/data/py2_test_grammar.py
--- a/Lib/lib2to3/tests/data/py2_test_grammar.py	Wed Dec 26 01:45:22 2012 -0800
+++ b/Lib/lib2to3/tests/data/py2_test_grammar.py	Thu Dec 27 18:33:36 2012 +0200
@@ -20,33 +20,33 @@
         # Backslash means line continuation:
         x = 1 \
         + 1
-        self.assertEquals(x, 2, 'backslash for line continuation')
+        self.assertEqual(x, 2, 'backslash for line continuation')
 
         # Backslash does not means continuation in comments :\
         x = 0
-        self.assertEquals(x, 0, 'backslash ending comment')
+        self.assertEqual(x, 0, 'backslash ending comment')
 
     def testPlainIntegers(self):
-        self.assertEquals(0xff, 255)
-        self.assertEquals(0377, 255)
-        self.assertEquals(2147483647, 017777777777)
+        self.assertEqual(0xff, 255)
+        self.assertEqual(0377, 255)
+        self.assertEqual(2147483647, 017777777777)
         # "0x" is not a valid literal
         self.assertRaises(SyntaxError, eval, "0x")
         from sys import maxint
         if maxint == 2147483647:
-            self.assertEquals(-2147483647-1, -020000000000)
+            self.assertEqual(-2147483647-1, -020000000000)
             # XXX -2147483648
-            self.assert_(037777777777 > 0)
-            self.assert_(0xffffffff > 0)
+            self.assertTrue(037777777777 > 0)
+            self.assertTrue(0xffffffff > 0)
             for s in '2147483648', '040000000000', '0x100000000':
                 try:
                     x = eval(s)
                 except OverflowError:
                     self.fail("OverflowError on huge integer literal %r" % s)
         elif maxint == 9223372036854775807:
-            self.assertEquals(-9223372036854775807-1, -01000000000000000000000)
-            self.assert_(01777777777777777777777 > 0)
-            self.assert_(0xffffffffffffffff > 0)
+            self.assertEqual(-9223372036854775807-1, -01000000000000000000000)
+            self.assertTrue(01777777777777777777777 > 0)
+            self.assertTrue(0xffffffffffffffff > 0)
             for s in '9223372036854775808', '02000000000000000000000', \
                      '0x10000000000000000':
                 try:
@@ -81,15 +81,15 @@
         x = 3.1e4
 
     def testStringLiterals(self):
-        x = ''; y = ""; self.assert_(len(x) == 0 and x == y)
-        x = '\''; y = "'"; self.assert_(len(x) == 1 and x == y and ord(x) == 39)
-        x = '"'; y = "\""; self.assert_(len(x) == 1 and x == y and ord(x) == 34)
+        x = ''; y = ""; self.assertTrue(len(x) == 0 and x == y)
+        x = '\''; y = "'"; self.assertTrue(len(x) == 1 and x == y and ord(x) == 39)
+        x = '"'; y = "\""; self.assertTrue(len(x) == 1 and x == y and ord(x) == 34)
         x = "doesn't \"shrink\" does it"
         y = 'doesn\'t "shrink" does it'
-        self.assert_(len(x) == 24 and x == y)
+        self.assertTrue(len(x) == 24 and x == y)
         x = "does \"shrink\" doesn't it"
         y = 'does "shrink" doesn\'t it'
-        self.assert_(len(x) == 24 and x == y)
+        self.assertTrue(len(x) == 24 and x == y)
         x = """
 The "quick"
 brown fox
@@ -97,28 +97,28 @@
 the 'lazy' dog.
 """
         y = '\nThe "quick"\nbrown fox\njumps over\nthe \'lazy\' dog.\n'
-        self.assertEquals(x, y)
+        self.assertEqual(x, y)
         y = '''
 The "quick"
 brown fox
 jumps over
 the 'lazy' dog.
 '''
-        self.assertEquals(x, y)
+        self.assertEqual(x, y)
         y = "\n\
 The \"quick\"\n\
 brown fox\n\
 jumps over\n\
 the 'lazy' dog.\n\
 "
-        self.assertEquals(x, y)
+        self.assertEqual(x, y)
         y = '\n\
 The \"quick\"\n\
 brown fox\n\
 jumps over\n\
 the \'lazy\' dog.\n\
 '
-        self.assertEquals(x, y)
+        self.assertEqual(x, y)
 
 
 class GrammarTests(unittest.TestCase):
@@ -154,18 +154,18 @@
         def f3(two, arguments): pass
         def f4(two, (compound, (argument, list))): pass
         def f5((compound, first), two): pass
-        self.assertEquals(f2.func_code.co_varnames, ('one_argument',))
-        self.assertEquals(f3.func_code.co_varnames, ('two', 'arguments'))
+        self.assertEqual(f2.func_code.co_varnames, ('one_argument',))
+        self.assertEqual(f3.func_code.co_varnames, ('two', 'arguments'))
         if sys.platform.startswith('java'):
-            self.assertEquals(f4.func_code.co_varnames,
+            self.assertEqual(f4.func_code.co_varnames,
                    ('two', '(compound, (argument, list))', 'compound', 'argument',
                                 'list',))
-            self.assertEquals(f5.func_code.co_varnames,
+            self.assertEqual(f5.func_code.co_varnames,
                    ('(compound, first)', 'two', 'compound', 'first'))
         else:
-            self.assertEquals(f4.func_code.co_varnames,
+            self.assertEqual(f4.func_code.co_varnames,
                   ('two', '.1', 'compound', 'argument',  'list'))
-            self.assertEquals(f5.func_code.co_varnames,
+            self.assertEqual(f5.func_code.co_varnames,
                   ('.0', 'two', 'compound', 'first'))
         def a1(one_arg,): pass
         def a2(two, args,): pass
@@ -201,10 +201,10 @@
         # ceval unpacks the formal arguments into the first argcount names;
         # thus, the names nested inside tuples must appear after these names.
         if sys.platform.startswith('java'):
-            self.assertEquals(v3.func_code.co_varnames, ('a', '(b, c)', 'rest', 'b', 'c'))
+            self.assertEqual(v3.func_code.co_varnames, ('a', '(b, c)', 'rest', 'b', 'c'))
         else:
-            self.assertEquals(v3.func_code.co_varnames, ('a', '.1', 'rest', 'b', 'c'))
-        self.assertEquals(v3(1, (2, 3), 4), (1, 2, 3, (4,)))
+            self.assertEqual(v3.func_code.co_varnames, ('a', '.1', 'rest', 'b', 'c'))
+        self.assertEqual(v3(1, (2, 3), 4), (1, 2, 3, (4,)))
         def d01(a=1): pass
         d01()
         d01(1)
@@ -285,7 +285,7 @@
         # keyword arguments after *arglist
         def f(*args, **kwargs):
             return args, kwargs
-        self.assertEquals(f(1, x=2, *[3, 4], y=5), ((1, 3, 4),
+        self.assertEqual(f(1, x=2, *[3, 4], y=5), ((1, 3, 4),
                                                     {'x':2, 'y':5}))
         self.assertRaises(SyntaxError, eval, "f(1, *(2,3), 4)")
         self.assertRaises(SyntaxError, eval, "f(1, x=2, *(3,4), x=5)")
@@ -297,15 +297,15 @@
     def testLambdef(self):
         ### lambdef: 'lambda' [varargslist] ':' test
         l1 = lambda : 0
-        self.assertEquals(l1(), 0)
+        self.assertEqual(l1(), 0)
         l2 = lambda : a[d] # XXX just testing the expression
         l3 = lambda : [2 < x for x in [-1, 3, 0L]]
-        self.assertEquals(l3(), [0, 1, 0])
+        self.assertEqual(l3(), [0, 1, 0])
         l4 = lambda x = lambda y = lambda z=1 : z : y() : x()
-        self.assertEquals(l4(), 1)
+        self.assertEqual(l4(), 1)
         l5 = lambda x, y, z=2: x + y + z
-        self.assertEquals(l5(1, 2), 5)
-        self.assertEquals(l5(1, 2, 3), 6)
+        self.assertEqual(l5(1, 2), 5)
+        self.assertEqual(l5(1, 2, 3), 6)
         check_syntax_error(self, "lambda x: x = 2")
         check_syntax_error(self, "lambda (None,): None")
 
@@ -558,7 +558,7 @@
         try:
             assert 0, "msg"
         except AssertionError, e:
-            self.assertEquals(e.args[0], "msg")
+            self.assertEqual(e.args[0], "msg")
         else:
             if __debug__:
                 self.fail("AssertionError not raised by assert 0")
@@ -592,7 +592,7 @@
             x = 1
         else:
             x = 2
-        self.assertEquals(x, 2)
+        self.assertEqual(x, 2)
 
     def testFor(self):
         # 'for' exprlist 'in' exprlist ':' suite ['else' ':' suite]
@@ -745,7 +745,7 @@
         d[1,2,3] = 4
         L = list(d)
         L.sort()
-        self.assertEquals(str(L), '[1, (1,), (1, 2), (1, 2, 3)]')
+        self.assertEqual(str(L), '[1, (1,), (1, 2), (1, 2, 3)]')
 
     def testAtoms(self):
         ### atom: '(' [testlist] ')' | '[' [testlist] ']' | '{' [dictmaker] '}' | '`' testlist '`' | NAME | NUMBER | STRING
diff -r 6c186caa6285 Lib/lib2to3/tests/data/py3_test_grammar.py
--- a/Lib/lib2to3/tests/data/py3_test_grammar.py	Wed Dec 26 01:45:22 2012 -0800
+++ b/Lib/lib2to3/tests/data/py3_test_grammar.py	Thu Dec 27 18:33:36 2012 +0200
@@ -20,27 +20,27 @@
         # Backslash means line continuation:
         x = 1 \
         + 1
-        self.assertEquals(x, 2, 'backslash for line continuation')
+        self.assertEqual(x, 2, 'backslash for line continuation')
 
         # Backslash does not means continuation in comments :\
         x = 0
-        self.assertEquals(x, 0, 'backslash ending comment')
+        self.assertEqual(x, 0, 'backslash ending comment')
 
     def testPlainIntegers(self):
-        self.assertEquals(type(000), type(0))
-        self.assertEquals(0xff, 255)
-        self.assertEquals(0o377, 255)
-        self.assertEquals(2147483647, 0o17777777777)
-        self.assertEquals(0b1001, 9)
+        self.assertEqual(type(000), type(0))
+        self.assertEqual(0xff, 255)
+        self.assertEqual(0o377, 255)
+        self.assertEqual(2147483647, 0o17777777777)
+        self.assertEqual(0b1001, 9)
         # "0x" is not a valid literal
         self.assertRaises(SyntaxError, eval, "0x")
         from sys import maxsize
         if maxsize == 2147483647:
-            self.assertEquals(-2147483647-1, -0o20000000000)
+            self.assertEqual(-2147483647-1, -0o20000000000)
             # XXX -2147483648
-            self.assert_(0o37777777777 > 0)
-            self.assert_(0xffffffff > 0)
-            self.assert_(0b1111111111111111111111111111111 > 0)
+            self.assertTrue(0o37777777777 > 0)
+            self.assertTrue(0xffffffff > 0)
+            self.assertTrue(0b1111111111111111111111111111111 > 0)
             for s in ('2147483648', '0o40000000000', '0x100000000',
                       '0b10000000000000000000000000000000'):
                 try:
@@ -48,10 +48,10 @@
                 except OverflowError:
                     self.fail("OverflowError on huge integer literal %r" % s)
         elif maxsize == 9223372036854775807:
-            self.assertEquals(-9223372036854775807-1, -0o1000000000000000000000)
-            self.assert_(0o1777777777777777777777 > 0)
-            self.assert_(0xffffffffffffffff > 0)
-            self.assert_(0b11111111111111111111111111111111111111111111111111111111111111 > 0)
+            self.assertEqual(-9223372036854775807-1, -0o1000000000000000000000)
+            self.assertTrue(0o1777777777777777777777 > 0)
+            self.assertTrue(0xffffffffffffffff > 0)
+            self.assertTrue(0b11111111111111111111111111111111111111111111111111111111111111 > 0)
             for s in '9223372036854775808', '0o2000000000000000000000', \
                      '0x10000000000000000', \
                      '0b100000000000000000000000000000000000000000000000000000000000000':
@@ -87,15 +87,15 @@
         x = 3.1e4
 
     def testStringLiterals(self):
-        x = ''; y = ""; self.assert_(len(x) == 0 and x == y)
-        x = '\''; y = "'"; self.assert_(len(x) == 1 and x == y and ord(x) == 39)
-        x = '"'; y = "\""; self.assert_(len(x) == 1 and x == y and ord(x) == 34)
+        x = ''; y = ""; self.assertTrue(len(x) == 0 and x == y)
+        x = '\''; y = "'"; self.assertTrue(len(x) == 1 and x == y and ord(x) == 39)
+        x = '"'; y = "\""; self.assertTrue(len(x) == 1 and x == y and ord(x) == 34)
         x = "doesn't \"shrink\" does it"
         y = 'doesn\'t "shrink" does it'
-        self.assert_(len(x) == 24 and x == y)
+        self.assertTrue(len(x) == 24 and x == y)
         x = "does \"shrink\" doesn't it"
         y = 'does "shrink" doesn\'t it'
-        self.assert_(len(x) == 24 and x == y)
+        self.assertTrue(len(x) == 24 and x == y)
         x = """
 The "quick"
 brown fox
@@ -103,32 +103,32 @@
 the 'lazy' dog.
 """
         y = '\nThe "quick"\nbrown fox\njumps over\nthe \'lazy\' dog.\n'
-        self.assertEquals(x, y)
+        self.assertEqual(x, y)
         y = '''
 The "quick"
 brown fox
 jumps over
 the 'lazy' dog.
 '''
-        self.assertEquals(x, y)
+        self.assertEqual(x, y)
         y = "\n\
 The \"quick\"\n\
 brown fox\n\
 jumps over\n\
 the 'lazy' dog.\n\
 "
-        self.assertEquals(x, y)
+        self.assertEqual(x, y)
         y = '\n\
 The \"quick\"\n\
 brown fox\n\
 jumps over\n\
 the \'lazy\' dog.\n\
 '
-        self.assertEquals(x, y)
+        self.assertEqual(x, y)
 
     def testEllipsis(self):
         x = ...
-        self.assert_(x is Ellipsis)
+        self.assertTrue(x is Ellipsis)
         self.assertRaises(SyntaxError, eval, ".. .")
 
 class GrammarTests(unittest.TestCase):
@@ -165,8 +165,8 @@
         f1(*(), **{})
         def f2(one_argument): pass
         def f3(two, arguments): pass
-        self.assertEquals(f2.__code__.co_varnames, ('one_argument',))
-        self.assertEquals(f3.__code__.co_varnames, ('two', 'arguments'))
+        self.assertEqual(f2.__code__.co_varnames, ('one_argument',))
+        self.assertEqual(f3.__code__.co_varnames, ('two', 'arguments'))
         def a1(one_arg,): pass
         def a2(two, args,): pass
         def v0(*rest): pass
@@ -287,37 +287,37 @@
         # keyword arguments after *arglist
         def f(*args, **kwargs):
             return args, kwargs
-        self.assertEquals(f(1, x=2, *[3, 4], y=5), ((1, 3, 4),
+        self.assertEqual(f(1, x=2, *[3, 4], y=5), ((1, 3, 4),
                                                     {'x':2, 'y':5}))
         self.assertRaises(SyntaxError, eval, "f(1, *(2,3), 4)")
         self.assertRaises(SyntaxError, eval, "f(1, x=2, *(3,4), x=5)")
 
         # argument annotation tests
         def f(x) -> list: pass
-        self.assertEquals(f.__annotations__, {'return': list})
+        self.assertEqual(f.__annotations__, {'return': list})
         def f(x:int): pass
-        self.assertEquals(f.__annotations__, {'x': int})
+        self.assertEqual(f.__annotations__, {'x': int})
         def f(*x:str): pass
-        self.assertEquals(f.__annotations__, {'x': str})
+        self.assertEqual(f.__annotations__, {'x': str})
         def f(**x:float): pass
-        self.assertEquals(f.__annotations__, {'x': float})
+        self.assertEqual(f.__annotations__, {'x': float})
         def f(x, y:1+2): pass
-        self.assertEquals(f.__annotations__, {'y': 3})
+        self.assertEqual(f.__annotations__, {'y': 3})
         def f(a, b:1, c:2, d): pass
-        self.assertEquals(f.__annotations__, {'b': 1, 'c': 2})
+        self.assertEqual(f.__annotations__, {'b': 1, 'c': 2})
         def f(a, b:1, c:2, d, e:3=4, f=5, *g:6): pass
-        self.assertEquals(f.__annotations__,
+        self.assertEqual(f.__annotations__,
                           {'b': 1, 'c': 2, 'e': 3, 'g': 6})
         def f(a, b:1, c:2, d, e:3=4, f=5, *g:6, h:7, i=8, j:9=10,
               **k:11) -> 12: pass
-        self.assertEquals(f.__annotations__,
+        self.assertEqual(f.__annotations__,
                           {'b': 1, 'c': 2, 'e': 3, 'g': 6, 'h': 7, 'j': 9,
                            'k': 11, 'return': 12})
         # Check for SF Bug #1697248 - mixing decorators and a return annotation
         def null(x): return x
         @null
         def f(x) -> list: pass
-        self.assertEquals(f.__annotations__, {'return': list})
+        self.assertEqual(f.__annotations__, {'return': list})
 
         # test MAKE_CLOSURE with a variety of oparg's
         closure = 1
@@ -333,20 +333,20 @@
     def testLambdef(self):
         ### lambdef: 'lambda' [varargslist] ':' test
         l1 = lambda : 0
-        self.assertEquals(l1(), 0)
+        self.assertEqual(l1(), 0)
         l2 = lambda : a[d] # XXX just testing the expression
         l3 = lambda : [2 < x for x in [-1, 3, 0]]
-        self.assertEquals(l3(), [0, 1, 0])
+        self.assertEqual(l3(), [0, 1, 0])
         l4 = lambda x = lambda y = lambda z=1 : z : y() : x()
-        self.assertEquals(l4(), 1)
+        self.assertEqual(l4(), 1)
         l5 = lambda x, y, z=2: x + y + z
-        self.assertEquals(l5(1, 2), 5)
-        self.assertEquals(l5(1, 2, 3), 6)
+        self.assertEqual(l5(1, 2), 5)
+        self.assertEqual(l5(1, 2, 3), 6)
         check_syntax_error(self, "lambda x: x = 2")
         check_syntax_error(self, "lambda (None,): None")
         l6 = lambda x, y, *, k=20: x+y+k
-        self.assertEquals(l6(1,2), 1+2+20)
-        self.assertEquals(l6(1,2,k=10), 1+2+10)
+        self.assertEqual(l6(1,2), 1+2+20)
+        self.assertEqual(l6(1,2,k=10), 1+2+10)
 
 
     ### stmt: simple_stmt | compound_stmt
@@ -502,7 +502,7 @@
         try:
             assert 0, "msg"
         except AssertionError as e:
-            self.assertEquals(e.args[0], "msg")
+            self.assertEqual(e.args[0], "msg")
         else:
             if __debug__:
                 self.fail("AssertionError not raised by assert 0")
@@ -536,7 +536,7 @@
             x = 1
         else:
             x = 2
-        self.assertEquals(x, 2)
+        self.assertEqual(x, 2)
 
     def testFor(self):
         # 'for' exprlist 'in' exprlist ':' suite ['else' ':' suite]
@@ -688,7 +688,7 @@
         d[1,2,3] = 4
         L = list(d)
         L.sort(key=lambda x: x if isinstance(x, tuple) else ())
-        self.assertEquals(str(L), '[1, (1,), (1, 2), (1, 2, 3)]')
+        self.assertEqual(str(L), '[1, (1,), (1, 2), (1, 2, 3)]')
 
     def testAtoms(self):
         ### atom: '(' [testlist] ')' | '[' [testlist] ']' | '{' [dictsetmaker] '}' | NAME | NUMBER | STRING
diff -r 6c186caa6285 Lib/test/test_calendar.py
--- a/Lib/test/test_calendar.py	Wed Dec 26 01:45:22 2012 -0800
+++ b/Lib/test/test_calendar.py	Thu Dec 27 18:33:36 2012 +0200
@@ -261,7 +261,7 @@
             return
         calendar.LocaleHTMLCalendar(locale='').formatmonthname(2010, 10)
         new_october = calendar.TextCalendar().formatmonthname(2010, 10, 10)
-        self.assertEquals(old_october, new_october)
+        self.assertEqual(old_october, new_october)
 
     def test_itermonthdates(self):
         # ensure itermonthdates doesn't overflow after datetime.MAXYEAR
diff -r 6c186caa6285 Lib/test/test_int.py
--- a/Lib/test/test_int.py	Wed Dec 26 01:45:22 2012 -0800
+++ b/Lib/test/test_int.py	Thu Dec 27 18:33:36 2012 +0200
@@ -317,13 +317,13 @@
         self.assertEqual(int(float(2**54+11)), 2**54+12)
 
     def test_no_args(self):
-        self.assertEquals(int(), 0)
+        self.assertEqual(int(), 0)
 
     def test_keyword_args(self):
         # Test invoking int() using keyword arguments.
-        self.assertEquals(int(x=1.2), 1)
-        self.assertEquals(int('100', base=2), 4)
-        self.assertEquals(int(x='100', base=2), 4)
+        self.assertEqual(int(x=1.2), 1)
+        self.assertEqual(int('100', base=2), 4)
+        self.assertEqual(int(x='100', base=2), 4)
 
     def test_valid_non_numeric_input_types_for_x(self):
         # Test possible valid non-numeric types for x, including subclasses
@@ -338,8 +338,8 @@
         for x in values:
             msg = 'x has value %s and type %s' % (x, type(x).__name__)
             try:
-                self.assertEquals(int(x), 100, msg=msg)
-                self.assertEquals(int(x, 2), 4, msg=msg)
+                self.assertEqual(int(x), 100, msg=msg)
+                self.assertEqual(int(x, 2), 4, msg=msg)
             except TypeError, err:
                 raise AssertionError('For %s got TypeError: %s' %
                                      (type(x).__name__, err))
@@ -364,10 +364,10 @@
     # expects x to be a string if base is given.
     @test_support.cpython_only
     def test_int_base_without_x_returns_0(self):
-        self.assertEquals(int(base=6), 0)
+        self.assertEqual(int(base=6), 0)
         # Even invalid bases don't raise an exception.
-        self.assertEquals(int(base=1), 0)
-        self.assertEquals(int(base=1000), 0)
+        self.assertEqual(int(base=1), 0)
+        self.assertEqual(int(base=1000), 0)
 
     def test_intconversion(self):
         # Test __int__()
diff -r 6c186caa6285 Lib/test/test_mutex.py
--- a/Lib/test/test_mutex.py	Wed Dec 26 01:45:22 2012 -0800
+++ b/Lib/test/test_mutex.py	Thu Dec 27 18:33:36 2012 +0200
@@ -14,7 +14,7 @@
             m.lock(called_by_mutex2, "eggs")
 
         def called_by_mutex2(some_data):
-            self.assertEquals(some_data, "eggs")
+            self.assertEqual(some_data, "eggs")
             self.assertTrue(m.test(), "mutex not held")
             self.assertTrue(ready_for_2,
                          "called_by_mutex2 called too soon")
diff -r 6c186caa6285 Lib/test/test_tarfile.py
--- a/Lib/test/test_tarfile.py	Wed Dec 26 01:45:22 2012 -0800
+++ b/Lib/test/test_tarfile.py	Thu Dec 27 18:33:36 2012 +0200
@@ -858,7 +858,7 @@
 
             tar = tarfile.open(tmpname, "r")
             for t in tar:
-                self.assert_(t.name == "." or t.name.startswith("./"))
+                self.assertTrue(t.name == "." or t.name.startswith("./"))
             tar.close()
         finally:
             os.chdir(cwd)