Index: Lib/random.py
===================================================================
--- Lib/random.py	(revision 76671)
+++ Lib/random.py	(working copy)
@@ -97,7 +97,7 @@
         None or no argument seeds from current time or from an operating
         system specific randomness source if available.
 
-        If a is not None or an int or long, hash(a) is used instead.
+        If a is not None or an int, hash(a) is used instead.
         """
 
         if a is None:
Index: Lib/test/mapping_tests.py
===================================================================
--- Lib/test/mapping_tests.py	(revision 76671)
+++ Lib/test/mapping_tests.py	(working copy)
@@ -528,13 +528,6 @@
         d = self._empty_mapping()
         k, v = 'abc', 'def'
 
-        # verify longs/ints get same value when key > 32 bits (for 64-bit archs)
-        # see SF bug #689659
-        x = 4503599627370496
-        y = 4503599627370496
-        h = self._full_mapping({x: 'anything', y: 'something else'})
-        self.assertEqual(h[x], h[y])
-
         self.assertEqual(d.pop(k, v), v)
         d[k] = v
         self.assertEqual(d.pop(k, 1), v)
Index: Lib/test/pickletester.py
===================================================================
--- Lib/test/pickletester.py	(revision 76671)
+++ Lib/test/pickletester.py	(working copy)
@@ -1038,9 +1038,6 @@
 
 # Test classes for newobj
 
-class MyInt(int):
-    sample = 1
-
 class MyLong(int):
     sample = 1
 
@@ -1065,7 +1062,7 @@
 class MyDict(dict):
     sample = {"a": 1, "b": 2}
 
-myclasses = [MyInt, MyLong, MyFloat,
+myclasses = [MyLong, MyFloat,
              MyComplex,
              MyStr, MyUnicode,
              MyTuple, MyList, MyDict]
Index: Lib/test/string_tests.py
===================================================================
--- Lib/test/string_tests.py	(revision 76671)
+++ Lib/test/string_tests.py	(working copy)
@@ -1071,7 +1071,6 @@
 
         longvalue = sys.maxsize + 10
         slongvalue = str(longvalue)
-        if slongvalue[-1] in ("L","l"): slongvalue = slongvalue[:-1]
         self.checkequal(' 42', '%3ld', '__mod__', 42)
         self.checkequal('42', '%d', '__mod__', 42.0)
         self.checkequal(slongvalue, '%d', '__mod__', longvalue)
@@ -1086,7 +1085,7 @@
         self.checkraises(ValueError, '%(foo', '__mod__', {})
         self.checkraises(TypeError, '%(foo)s %(bar)s', '__mod__', ('foo', 42))
         self.checkraises(TypeError, '%d', '__mod__', "42") # not numeric
-        self.checkraises(TypeError, '%d', '__mod__', (42+0j)) # no int/long conversion provided
+        self.checkraises(TypeError, '%d', '__mod__', (42+0j)) # no int conversion provided
 
         # argument names with properly nested brackets are supported
         self.checkequal('bar', '%((foo))s', '__mod__', {'(foo)': 'bar'})
Index: Lib/test/test_binop.py
===================================================================
--- Lib/test/test_binop.py	(revision 76671)
+++ Lib/test/test_binop.py	(working copy)
@@ -11,8 +11,8 @@
     return b
 
 def isint(x):
-    """Test whether an object is an instance of int or long."""
-    return isinstance(x, int) or isinstance(x, int)
+    """Test whether an object is an instance of int."""
+    return isinstance(x, int)
 
 def isnum(x):
     """Test whether an object is an instance of a built-in numeric type."""
@@ -27,18 +27,18 @@
 
 class Rat(object):
 
-    """Rational number implemented as a normalized pair of longs."""
+    """Rational number implemented as a normalized pair of ints."""
 
     __slots__ = ['_Rat__num', '_Rat__den']
 
     def __init__(self, num=0, den=1):
         """Constructor: Rat([num[, den]]).
 
-        The arguments must be ints or longs, and default to (0, 1)."""
+        The arguments must be ints, and default to (0, 1)."""
         if not isint(num):
-            raise TypeError("Rat numerator must be int or long (%r)" % num)
+            raise TypeError("Rat numerator must be int (%r)" % num)
         if not isint(den):
-            raise TypeError("Rat denominator must be int or long (%r)" % den)
+            raise TypeError("Rat denominator must be int (%r)" % den)
         # But the zero is always on
         if den == 0:
             raise ZeroDivisionError("zero denominator")
@@ -220,9 +220,6 @@
         a = Rat(10, 15)
         self.assertEqual(a.num, 2)
         self.assertEqual(a.den, 3)
-        a = Rat(10, 15)
-        self.assertEqual(a.num, 2)
-        self.assertEqual(a.den, 3)
         a = Rat(10, -15)
         self.assertEqual(a.num, -2)
         self.assertEqual(a.den, 3)
Index: Lib/test/test_builtin.py
===================================================================
--- Lib/test/test_builtin.py	(revision 76671)
+++ Lib/test/test_builtin.py	(working copy)
@@ -126,10 +126,6 @@
         self.assertEqual(abs(0.0), 0.0)
         self.assertEqual(abs(3.14), 3.14)
         self.assertEqual(abs(-3.14), 3.14)
-        # long
-        self.assertEqual(abs(0), 0)
-        self.assertEqual(abs(1234), 1234)
-        self.assertEqual(abs(-1234), 1234)
         # str
         self.assertRaises(TypeError, abs, 'a')
 
@@ -164,7 +160,6 @@
     def test_ascii(self):
         self.assertEqual(ascii(''), '\'\'')
         self.assertEqual(ascii(0), '0')
-        self.assertEqual(ascii(0), '0')
         self.assertEqual(ascii(()), '()')
         self.assertEqual(ascii([]), '[]')
         self.assertEqual(ascii({}), '{}')
@@ -322,18 +317,7 @@
         self.assertEqual(divmod(12, -7), (-2, -2))
         self.assertEqual(divmod(-12, -7), (1, -5))
 
-        self.assertEqual(divmod(12, 7), (1, 5))
-        self.assertEqual(divmod(-12, 7), (-2, 2))
-        self.assertEqual(divmod(12, -7), (-2, -2))
-        self.assertEqual(divmod(-12, -7), (1, -5))
-
-        self.assertEqual(divmod(12, 7), (1, 5))
-        self.assertEqual(divmod(-12, 7), (-2, 2))
-        self.assertEqual(divmod(12, -7), (-2, -2))
-        self.assertEqual(divmod(-12, -7), (1, -5))
-
-        self.assertEqual(divmod(-sys.maxsize-1, -1),
-                         (sys.maxsize+1, 0))
+        self.assertEqual(divmod(-sys.maxsize-1, -1), (sys.maxsize+1, 0))
 
         self.assertTrue(not fcmp(divmod(3.25, 1.0), (3.0, 0.25)))
         self.assertTrue(not fcmp(divmod(-3.25, 1.0), (-4.0, 0.75)))
@@ -528,10 +512,6 @@
             def __hash__(self):
                 return 2**100
         self.assertEquals(type(hash(X())), int)
-        class Y(object):
-            def __hash__(self):
-                return 2**100
-        self.assertEquals(type(hash(Y())), int)
         class Z(int):
             def __hash__(self):
                 return self
@@ -539,15 +519,12 @@
 
     def test_hex(self):
         self.assertEqual(hex(16), '0x10')
-        self.assertEqual(hex(16), '0x10')
-        self.assertEqual(hex(-16), '-0x10')
         self.assertEqual(hex(-16), '-0x10')
         self.assertRaises(TypeError, hex, {})
 
     def test_id(self):
         id(None)
         id(1)
-        id(1)
         id(1.0)
         id('spam')
         id((0,1,2,3))
@@ -790,8 +767,6 @@
 
     def test_oct(self):
         self.assertEqual(oct(100), '0o144')
-        self.assertEqual(oct(100), '0o144')
-        self.assertEqual(oct(-100), '-0o144')
         self.assertEqual(oct(-100), '-0o144')
         self.assertRaises(TypeError, oct, ())
 
@@ -800,7 +775,6 @@
         fp = open(TESTFN, 'w')
         try:
             fp.write('1+1\n')
-            fp.write('1+1\n')
             fp.write('The quick brown fox jumps over the lazy dog')
             fp.write('.\n')
             fp.write('Dear John\n')
@@ -814,7 +788,6 @@
         fp = open(TESTFN, 'r')
         try:
             self.assertEqual(fp.readline(4), '1+1\n')
-            self.assertEqual(fp.readline(4), '1+1\n')
             self.assertEqual(fp.readline(), 'The quick brown fox jumps over the lazy dog.\n')
             self.assertEqual(fp.readline(4), 'Dear')
             self.assertEqual(fp.readline(100), ' John\n')
@@ -867,21 +840,6 @@
         self.assertEqual(pow(-2,2), 4)
         self.assertEqual(pow(-2,3), -8)
 
-        self.assertEqual(pow(0,0), 1)
-        self.assertEqual(pow(0,1), 0)
-        self.assertEqual(pow(1,0), 1)
-        self.assertEqual(pow(1,1), 1)
-
-        self.assertEqual(pow(2,0), 1)
-        self.assertEqual(pow(2,10), 1024)
-        self.assertEqual(pow(2,20), 1024*1024)
-        self.assertEqual(pow(2,30), 1024*1024*1024)
-
-        self.assertEqual(pow(-2,0), 1)
-        self.assertEqual(pow(-2,1), -2)
-        self.assertEqual(pow(-2,2), 4)
-        self.assertEqual(pow(-2,3), -8)
-
         self.assertAlmostEqual(pow(0.,0), 1.)
         self.assertAlmostEqual(pow(0.,1), 0.)
         self.assertAlmostEqual(pow(1.,0), 1.)
@@ -897,9 +855,9 @@
         self.assertAlmostEqual(pow(-2.,2), 4.)
         self.assertAlmostEqual(pow(-2.,3), -8.)
 
-        for x in 2, 2, 2.0:
-            for y in 10, 10, 10.0:
-                for z in 1000, 1000, 1000.0:
+        for x in 2, 2.0:
+            for y in 10, 10.0:
+                for z in 1000, 1000.0:
                     if isinstance(x, float) or \
                        isinstance(y, float) or \
                        isinstance(z, float):
@@ -912,8 +870,6 @@
 
         self.assertRaises(TypeError, pow, -1, -2, 3)
         self.assertRaises(ValueError, pow, 1, 2, 0)
-        self.assertRaises(TypeError, pow, -1, -2, 3)
-        self.assertRaises(ValueError, pow, 1, 2, 0)
 
         self.assertRaises(TypeError, pow)
 
@@ -943,7 +899,6 @@
         self.assertEqual(len(x), 4)
         self.assertEqual(len(list(x)), 4)
 
-        """ XXX(nnorwitz):
         # Now test range() with longs
         self.assertEqual(list(range(-2**100)), [])
         self.assertEqual(list(range(0, -2**100)), [])
@@ -978,6 +933,7 @@
         self.assertRaises(ValueError, range, 1, 2, 0)
         self.assertRaises(ValueError, range, a, a + 1, int(0))
 
+        """ XXX(nnorwitz):
         class badzero(int):
             def __eq__(self, other):
                 raise RuntimeError
@@ -1008,7 +964,6 @@
             sys.stdin = fp
             sys.stdout = BitBucket()
             self.assertEqual(input(), "1+1")
-            self.assertEqual(input('testing\n'), "1+1")
             self.assertEqual(input(), 'The quick brown fox jumps over the lazy dog.')
             self.assertEqual(input('testing\n'), 'Dear John')
 
@@ -1039,7 +994,6 @@
     def test_repr(self):
         self.assertEqual(repr(''), '\'\'')
         self.assertEqual(repr(0), '0')
-        self.assertEqual(repr(0), '0')
         self.assertEqual(repr(()), '()')
         self.assertEqual(repr([]), '[]')
         self.assertEqual(repr({}), '{}')
Index: Lib/test/test_datetime.py
===================================================================
--- Lib/test/test_datetime.py	(revision 76671)
+++ Lib/test/test_datetime.py	(working copy)
@@ -22,7 +22,7 @@
 
 # An arbitrary collection of objects of non-datetime types, for testing
 # mixed-type comparisons.
-OTHERSTUFF = (10, 10, 34.5, "abc", {}, [], ())
+OTHERSTUFF = (10, 34.5, "abc", {}, [], ())
 
 
 #############################################################################
@@ -232,8 +232,8 @@
     def test_disallowed_computations(self):
         a = timedelta(42)
 
-        # Add/sub ints, longs, floats should be illegal
-        for i in 1, 1, 1.0:
+        # Add/sub ints or floats should be illegal
+        for i in 1, 1.0:
             self.assertRaises(TypeError, lambda: a+i)
             self.assertRaises(TypeError, lambda: a-i)
             self.assertRaises(TypeError, lambda: i+a)
@@ -250,9 +250,9 @@
 
         # Division of int by timedelta doesn't make sense.
         # Division by zero doesn't make sense.
-        for zero in 0, 0:
-            self.assertRaises(TypeError, lambda: zero // a)
-            self.assertRaises(ZeroDivisionError, lambda: a // zero)
+        zero = 0
+        self.assertRaises(TypeError, lambda: zero // a)
+        self.assertRaises(ZeroDivisionError, lambda: a // zero)
 
     def test_basic_attributes(self):
         days, seconds, us = 1, 7, 31
@@ -685,8 +685,8 @@
         self.assertEqual(a - (a - week), week)
         self.assertEqual(a - (a - day), day)
 
-        # Add/sub ints, longs, floats should be illegal
-        for i in 1, 1, 1.0:
+        # Add/sub ints or floats should be illegal
+        for i in 1, 1.0:
             self.assertRaises(TypeError, lambda: a+i)
             self.assertRaises(TypeError, lambda: a-i)
             self.assertRaises(TypeError, lambda: i+a)
@@ -1376,8 +1376,8 @@
                          self.theclass(2002, 2, 22, 16, 5, 59, 999000))
         self.assertEqual(a - (week + day + hour + millisec),
                          (((a - week) - day) - hour) - millisec)
-        # Add/sub ints, longs, floats should be illegal
-        for i in 1, 1, 1.0:
+        # Add/sub ints or floats should be illegal
+        for i in 1, 1.0:
             self.assertRaises(TypeError, lambda: a+i)
             self.assertRaises(TypeError, lambda: a-i)
             self.assertRaises(TypeError, lambda: i+a)
Index: Lib/test/test_decimal.py
===================================================================
--- Lib/test/test_decimal.py	(revision 76671)
+++ Lib/test/test_decimal.py	(working copy)
@@ -1274,7 +1274,7 @@
         self.assertEqual(repr(d), "Decimal('15.32')")   # repr
 
     def test_tonum_methods(self):
-        #Test float, int and long methods.
+        #Test float and int methods.
 
         d1 = Decimal('66')
         d2 = Decimal('15.32')
@@ -1283,10 +1283,6 @@
         self.assertEqual(int(d1), 66)
         self.assertEqual(int(d2), 15)
 
-        #long
-        self.assertEqual(int(d1), 66)
-        self.assertEqual(int(d2), 15)
-
         #float
         self.assertEqual(float(d1), 66)
         self.assertEqual(float(d2), 15.32)
Index: Lib/test/test_descr.py
===================================================================
--- Lib/test/test_descr.py	(revision 76671)
+++ Lib/test/test_descr.py	(working copy)
@@ -248,10 +248,6 @@
         else:
             self.fail("NotImplemented should have caused TypeError")
 
-    def test_longs(self):
-        # Testing long operations...
-        self.number_operators(100, 3)
-
     def test_floats(self):
         # Testing float operations...
         self.number_operators(100.0, 3.0)
@@ -259,7 +255,7 @@
     def test_complexes(self):
         # Testing complex operations...
         self.number_operators(100.0j, 3.0j, skip=['lt', 'le', 'gt', 'ge',
-                                                  'int', 'long', 'float',
+                                                  'int', 'float',
                                                   'divmod', 'mod'])
 
         class Number(complex):
@@ -1162,15 +1158,6 @@
         self.assertEqual(I(3)*2, 6)
         self.assertEqual(I(3)*I(2), 6)
 
-        # Test handling of long*seq and seq*long
-        class L(int):
-            pass
-        self.assertEqual("a"*L(2), "aa")
-        self.assertEqual(L(2)*"a", "aa")
-        self.assertEqual(2*L(3), 6)
-        self.assertEqual(L(3)*2, 6)
-        self.assertEqual(L(3)*L(2), 6)
-
         # Test comparison of classes with dynamic metaclasses
         class dynamicmetaclass(type):
             pass
@@ -2231,10 +2218,7 @@
         class octlong(int):
             __slots__ = []
             def __str__(self):
-                s = oct(self)
-                if s[-1] == 'L':
-                    s = s[:-1]
-                return s
+                return oct(self)
             def __add__(self, other):
                 return self.__class__(super(octlong, self).__add__(other))
             __radd__ = __add__
Index: Lib/test/test_dict.py
===================================================================
--- Lib/test/test_dict.py	(revision 76671)
+++ Lib/test/test_dict.py	(working copy)
@@ -328,13 +328,6 @@
 
         self.assertRaises(KeyError, d.pop, k)
 
-        # verify longs/ints get same value when key > 32 bits (for 64-bit archs)
-        # see SF bug #689659
-        x = 4503599627370496
-        y = 4503599627370496
-        h = {x: 'anything', y: 'something else'}
-        self.assertEqual(h[x], h[y])
-
         self.assertEqual(d.pop(k, v), v)
         d[k] = v
         self.assertEqual(d.pop(k, 1), v)
Index: Lib/test/test_getargs2.py
===================================================================
--- Lib/test/test_getargs2.py	(revision 76671)
+++ Lib/test/test_getargs2.py	(working copy)
@@ -59,17 +59,12 @@
     def __int__(self):
         return 99
 
-class Int:
-    def __int__(self):
-        return 99
-
 class Unsigned_TestCase(unittest.TestCase):
     def test_b(self):
         from _testcapi import getargs_b
         # b returns 'unsigned char', and does range checking (0 ... UCHAR_MAX)
         self.assertRaises(TypeError, getargs_b, 3.14)
         self.assertEqual(99, getargs_b(Long()))
-        self.assertEqual(99, getargs_b(Int()))
 
         self.assertRaises(OverflowError, getargs_b, -1)
         self.assertEqual(0, getargs_b(0))
@@ -77,7 +72,6 @@
         self.assertRaises(OverflowError, getargs_b, UCHAR_MAX + 1)
 
         self.assertEqual(42, getargs_b(42))
-        self.assertEqual(42, getargs_b(42))
         self.assertRaises(OverflowError, getargs_b, VERY_LARGE)
 
     def test_B(self):
@@ -85,16 +79,13 @@
         # B returns 'unsigned char', no range checking
         self.assertRaises(TypeError, getargs_B, 3.14)
         self.assertEqual(99, getargs_B(Long()))
-        self.assertEqual(99, getargs_B(Int()))
 
         self.assertEqual(UCHAR_MAX, getargs_B(-1))
-        self.assertEqual(UCHAR_MAX, getargs_B(-1))
         self.assertEqual(0, getargs_B(0))
         self.assertEqual(UCHAR_MAX, getargs_B(UCHAR_MAX))
         self.assertEqual(0, getargs_B(UCHAR_MAX+1))
 
         self.assertEqual(42, getargs_B(42))
-        self.assertEqual(42, getargs_B(42))
         self.assertEqual(UCHAR_MAX & VERY_LARGE, getargs_B(VERY_LARGE))
 
     def test_H(self):
@@ -102,7 +93,6 @@
         # H returns 'unsigned short', no range checking
         self.assertRaises(TypeError, getargs_H, 3.14)
         self.assertEqual(99, getargs_H(Long()))
-        self.assertEqual(99, getargs_H(Int()))
 
         self.assertEqual(USHRT_MAX, getargs_H(-1))
         self.assertEqual(0, getargs_H(0))
@@ -110,7 +100,6 @@
         self.assertEqual(0, getargs_H(USHRT_MAX+1))
 
         self.assertEqual(42, getargs_H(42))
-        self.assertEqual(42, getargs_H(42))
 
         self.assertEqual(VERY_LARGE & USHRT_MAX, getargs_H(VERY_LARGE))
 
@@ -119,7 +108,6 @@
         # I returns 'unsigned int', no range checking
         self.assertRaises(TypeError, getargs_I, 3.14)
         self.assertEqual(99, getargs_I(Long()))
-        self.assertEqual(99, getargs_I(Int()))
 
         self.assertEqual(UINT_MAX, getargs_I(-1))
         self.assertEqual(0, getargs_I(0))
@@ -127,7 +115,6 @@
         self.assertEqual(0, getargs_I(UINT_MAX+1))
 
         self.assertEqual(42, getargs_I(42))
-        self.assertEqual(42, getargs_I(42))
 
         self.assertEqual(VERY_LARGE & UINT_MAX, getargs_I(VERY_LARGE))
 
@@ -137,7 +124,6 @@
         # it does not accept float, or instances with __int__
         self.assertRaises(TypeError, getargs_k, 3.14)
         self.assertRaises(TypeError, getargs_k, Long())
-        self.assertRaises(TypeError, getargs_k, Int())
 
         self.assertEqual(ULONG_MAX, getargs_k(-1))
         self.assertEqual(0, getargs_k(0))
@@ -145,7 +131,6 @@
         self.assertEqual(0, getargs_k(ULONG_MAX+1))
 
         self.assertEqual(42, getargs_k(42))
-        self.assertEqual(42, getargs_k(42))
 
         self.assertEqual(VERY_LARGE & ULONG_MAX, getargs_k(VERY_LARGE))
 
@@ -155,7 +140,6 @@
         # i returns 'int', and does range checking (INT_MIN ... INT_MAX)
         self.assertRaises(TypeError, getargs_i, 3.14)
         self.assertEqual(99, getargs_i(Long()))
-        self.assertEqual(99, getargs_i(Int()))
 
         self.assertRaises(OverflowError, getargs_i, INT_MIN-1)
         self.assertEqual(INT_MIN, getargs_i(INT_MIN))
@@ -163,7 +147,6 @@
         self.assertRaises(OverflowError, getargs_i, INT_MAX+1)
 
         self.assertEqual(42, getargs_i(42))
-        self.assertEqual(42, getargs_i(42))
         self.assertRaises(OverflowError, getargs_i, VERY_LARGE)
 
     def test_l(self):
@@ -171,7 +154,6 @@
         # l returns 'long', and does range checking (LONG_MIN ... LONG_MAX)
         self.assertRaises(TypeError, getargs_l, 3.14)
         self.assertEqual(99, getargs_l(Long()))
-        self.assertEqual(99, getargs_l(Int()))
 
         self.assertRaises(OverflowError, getargs_l, LONG_MIN-1)
         self.assertEqual(LONG_MIN, getargs_l(LONG_MIN))
@@ -179,7 +161,6 @@
         self.assertRaises(OverflowError, getargs_l, LONG_MAX+1)
 
         self.assertEqual(42, getargs_l(42))
-        self.assertEqual(42, getargs_l(42))
         self.assertRaises(OverflowError, getargs_l, VERY_LARGE)
 
     def test_n(self):
@@ -188,7 +169,6 @@
         # (PY_SSIZE_T_MIN ... PY_SSIZE_T_MAX)
         self.assertRaises(TypeError, getargs_n, 3.14)
         self.assertRaises(TypeError, getargs_n, Long())
-        self.assertRaises(TypeError, getargs_n, Int())
 
         self.assertRaises(OverflowError, getargs_n, PY_SSIZE_T_MIN-1)
         self.assertEqual(PY_SSIZE_T_MIN, getargs_n(PY_SSIZE_T_MIN))
@@ -196,7 +176,6 @@
         self.assertRaises(OverflowError, getargs_n, PY_SSIZE_T_MAX+1)
 
         self.assertEqual(42, getargs_n(42))
-        self.assertEqual(42, getargs_n(42))
         self.assertRaises(OverflowError, getargs_n, VERY_LARGE)
 
 
@@ -207,7 +186,6 @@
         self.assertRaises(TypeError, getargs_L, "Hello")
         self.assertEqual(3, getargs_L(3.14))
         self.assertEqual(99, getargs_L(Long()))
-        self.assertEqual(99, getargs_L(Int()))
 
         self.assertRaises(OverflowError, getargs_L, LLONG_MIN-1)
         self.assertEqual(LLONG_MIN, getargs_L(LLONG_MIN))
@@ -215,7 +193,6 @@
         self.assertRaises(OverflowError, getargs_L, LLONG_MAX+1)
 
         self.assertEqual(42, getargs_L(42))
-        self.assertEqual(42, getargs_L(42))
         self.assertRaises(OverflowError, getargs_L, VERY_LARGE)
 
     def test_K(self):
@@ -223,13 +200,11 @@
         # K return 'unsigned long long', no range checking
         self.assertRaises(TypeError, getargs_K, 3.14)
         self.assertRaises(TypeError, getargs_K, Long())
-        self.assertRaises(TypeError, getargs_K, Int())
         self.assertEqual(ULLONG_MAX, getargs_K(ULLONG_MAX))
         self.assertEqual(0, getargs_K(0))
         self.assertEqual(0, getargs_K(ULLONG_MAX+1))
 
         self.assertEqual(42, getargs_K(42))
-        self.assertEqual(42, getargs_K(42))
 
         self.assertEqual(VERY_LARGE & ULLONG_MAX, getargs_K(VERY_LARGE))
 
Index: Lib/test/test_int.py
===================================================================
--- Lib/test/test_int.py	(revision 76671)
+++ Lib/test/test_int.py	(working copy)
@@ -34,6 +34,7 @@
         self.assertEqual(int(-3.9), -3)
         self.assertEqual(int(3.5), 3)
         self.assertEqual(int(-3.5), -3)
+        self.assertEqual(int("-3"), -3)
         # Different base:
         self.assertEqual(int("10",16), 16)
         # Test conversion from strings and various anomalies
Index: Lib/test/test_long.py
===================================================================
--- Lib/test/test_long.py	(revision 76671)
+++ Lib/test/test_long.py	(working copy)
@@ -35,27 +35,6 @@
 # add complements & negations
 special += [~x for x in special] + [-x for x in special]
 
-L = [
-        ('0', 0),
-        ('1', 1),
-        ('9', 9),
-        ('10', 10),
-        ('99', 99),
-        ('100', 100),
-        ('314', 314),
-        (' 314', 314),
-        ('314 ', 314),
-        ('  \t\t  314  \t\t  ', 314),
-        (repr(sys.maxsize), sys.maxsize),
-        ('  1x', ValueError),
-        ('  1  ', 1),
-        ('  1\02  ', ValueError),
-        ('', ValueError),
-        (' ', ValueError),
-        ('  \t\t  ', ValueError)
-]
-
-
 class LongTest(unittest.TestCase):
 
     # Get quasi-random long consisting of ndigits digits (in base BASE).
@@ -263,7 +242,7 @@
             msg = Frm("%s returned %r but expected %r for %r",
                 mapper.__name__, got, expected, x)
             self.assertEqual(got, expected, msg)
-            self.assertEqual(int(got, 0), x, Frm('long("%s", 0) != %r', got, x))
+            self.assertEqual(int(got, 0), x, Frm('int("%s", 0) != %r', got, x))
         # str() has to be checked a little differently since there's no
         # trailing "L"
         got = str(x)
@@ -281,25 +260,12 @@
                 self.check_format_1(x)
 
     def test_long(self):
-        self.assertEqual(int(314), 314)
-        self.assertEqual(int(3.14), 3)
-        self.assertEqual(int(314), 314)
-        # Check that conversion from float truncates towards zero
-        self.assertEqual(int(-3.14), -3)
-        self.assertEqual(int(3.9), 3)
-        self.assertEqual(int(-3.9), -3)
-        self.assertEqual(int(3.5), 3)
-        self.assertEqual(int(-3.5), -3)
-        self.assertEqual(int("-3"), -3)
-        # Different base:
-        self.assertEqual(int("10",16), 16)
-        # Check conversions from string (same test set as for int(), and then some)
+        # Check conversions from string
         LL = [
                 ('1' + '0'*20, 10**20),
                 ('1' + '0'*100, 10**100)
         ]
-        L2 = L[:]
-        for s, v in L2 + LL:
+        for s, v in LL:
             for sign in "", "+", "-":
                 for prefix in "", " ", "\t", "  \t\t  ":
                     ss = prefix + sign + s
@@ -307,12 +273,10 @@
                     if sign == "-" and v is not ValueError:
                         vv = -v
                     try:
-                        self.assertEqual(int(ss), int(vv))
+                        self.assertEqual(int(ss), vv)
                     except ValueError:
                         pass
 
-        self.assertRaises(ValueError, int, '123\0')
-        self.assertRaises(ValueError, int, '53', 40)
         # trailing L should no longer be accepted...
         self.assertRaises(ValueError, int, '123L')
         self.assertRaises(ValueError, int, '123l')
@@ -323,302 +287,21 @@
         # ... but it's just a normal digit if base >= 22
         self.assertEqual(int('1L', 22), 43)
 
-        self.assertRaises(TypeError, int, 1, 12)
-
-        # SF patch #1638879: embedded NULs were not detected with
-        # explicit base
-        self.assertRaises(ValueError, int, '123\0', 10)
-        self.assertRaises(ValueError, int, '123\x00 245', 20)
-
-        self.assertEqual(int('100000000000000000000000000000000', 2),
-                         4294967296)
-        self.assertEqual(int('102002022201221111211', 3), 4294967296)
-        self.assertEqual(int('10000000000000000', 4), 4294967296)
-        self.assertEqual(int('32244002423141', 5), 4294967296)
-        self.assertEqual(int('1550104015504', 6), 4294967296)
-        self.assertEqual(int('211301422354', 7), 4294967296)
-        self.assertEqual(int('40000000000', 8), 4294967296)
-        self.assertEqual(int('12068657454', 9), 4294967296)
-        self.assertEqual(int('4294967296', 10), 4294967296)
-        self.assertEqual(int('1904440554', 11), 4294967296)
-        self.assertEqual(int('9ba461594', 12), 4294967296)
-        self.assertEqual(int('535a79889', 13), 4294967296)
-        self.assertEqual(int('2ca5b7464', 14), 4294967296)
-        self.assertEqual(int('1a20dcd81', 15), 4294967296)
-        self.assertEqual(int('100000000', 16), 4294967296)
-        self.assertEqual(int('a7ffda91', 17), 4294967296)
-        self.assertEqual(int('704he7g4', 18), 4294967296)
-        self.assertEqual(int('4f5aff66', 19), 4294967296)
-        self.assertEqual(int('3723ai4g', 20), 4294967296)
-        self.assertEqual(int('281d55i4', 21), 4294967296)
-        self.assertEqual(int('1fj8b184', 22), 4294967296)
-        self.assertEqual(int('1606k7ic', 23), 4294967296)
-        self.assertEqual(int('mb994ag', 24), 4294967296)
-        self.assertEqual(int('hek2mgl', 25), 4294967296)
-        self.assertEqual(int('dnchbnm', 26), 4294967296)
-        self.assertEqual(int('b28jpdm', 27), 4294967296)
-        self.assertEqual(int('8pfgih4', 28), 4294967296)
-        self.assertEqual(int('76beigg', 29), 4294967296)
-        self.assertEqual(int('5qmcpqg', 30), 4294967296)
-        self.assertEqual(int('4q0jto4', 31), 4294967296)
-        self.assertEqual(int('4000000', 32), 4294967296)
-        self.assertEqual(int('3aokq94', 33), 4294967296)
-        self.assertEqual(int('2qhxjli', 34), 4294967296)
-        self.assertEqual(int('2br45qb', 35), 4294967296)
-        self.assertEqual(int('1z141z4', 36), 4294967296)
-
-        self.assertEqual(int('100000000000000000000000000000001', 2),
-                         4294967297)
-        self.assertEqual(int('102002022201221111212', 3), 4294967297)
-        self.assertEqual(int('10000000000000001', 4), 4294967297)
-        self.assertEqual(int('32244002423142', 5), 4294967297)
-        self.assertEqual(int('1550104015505', 6), 4294967297)
-        self.assertEqual(int('211301422355', 7), 4294967297)
-        self.assertEqual(int('40000000001', 8), 4294967297)
-        self.assertEqual(int('12068657455', 9), 4294967297)
-        self.assertEqual(int('4294967297', 10), 4294967297)
-        self.assertEqual(int('1904440555', 11), 4294967297)
-        self.assertEqual(int('9ba461595', 12), 4294967297)
-        self.assertEqual(int('535a7988a', 13), 4294967297)
-        self.assertEqual(int('2ca5b7465', 14), 4294967297)
-        self.assertEqual(int('1a20dcd82', 15), 4294967297)
-        self.assertEqual(int('100000001', 16), 4294967297)
-        self.assertEqual(int('a7ffda92', 17), 4294967297)
-        self.assertEqual(int('704he7g5', 18), 4294967297)
-        self.assertEqual(int('4f5aff67', 19), 4294967297)
-        self.assertEqual(int('3723ai4h', 20), 4294967297)
-        self.assertEqual(int('281d55i5', 21), 4294967297)
-        self.assertEqual(int('1fj8b185', 22), 4294967297)
-        self.assertEqual(int('1606k7id', 23), 4294967297)
-        self.assertEqual(int('mb994ah', 24), 4294967297)
-        self.assertEqual(int('hek2mgm', 25), 4294967297)
-        self.assertEqual(int('dnchbnn', 26), 4294967297)
-        self.assertEqual(int('b28jpdn', 27), 4294967297)
-        self.assertEqual(int('8pfgih5', 28), 4294967297)
-        self.assertEqual(int('76beigh', 29), 4294967297)
-        self.assertEqual(int('5qmcpqh', 30), 4294967297)
-        self.assertEqual(int('4q0jto5', 31), 4294967297)
-        self.assertEqual(int('4000001', 32), 4294967297)
-        self.assertEqual(int('3aokq95', 33), 4294967297)
-        self.assertEqual(int('2qhxjlj', 34), 4294967297)
-        self.assertEqual(int('2br45qc', 35), 4294967297)
-        self.assertEqual(int('1z141z5', 36), 4294967297)
-
-
     def test_conversion(self):
-        # Test __int__()
-        class ClassicMissingMethods:
-            pass
-        self.assertRaises(TypeError, int, ClassicMissingMethods())
-
-        class MissingMethods(object):
-            pass
-        self.assertRaises(TypeError, int, MissingMethods())
 
-        class Foo0:
-            def __int__(self):
+        class JustLong:
+            # test that __long__ no longer used in 3.x
+            def __long__(self):
                 return 42
+        self.assertRaises(TypeError, int, JustLong())
 
-        class Foo1(object):
-            def __int__(self):
+        class LongTrunc:
+            # __long__ should be ignored in 3.x
+            def __long__(self):
                 return 42
-
-        class Foo2(int):
-            def __int__(self):
-                return 42
-
-        class Foo3(int):
-            def __int__(self):
-                return self
-
-        class Foo4(int):
-            def __int__(self):
-                return 42
-
-        class Foo5(int):
-            def __int__(self):
-                return 42.
-
-        self.assertEqual(int(Foo0()), 42)
-        self.assertEqual(int(Foo1()), 42)
-        self.assertEqual(int(Foo2()), 42)
-        self.assertEqual(int(Foo3()), 0)
-        self.assertEqual(int(Foo4()), 42)
-        self.assertRaises(TypeError, int, Foo5())
-
-        class Classic:
-            pass
-        for base in (object, Classic):
-            class IntOverridesTrunc(base):
-                def __int__(self):
-                    return 42
-                def __trunc__(self):
-                    return -12
-            self.assertEqual(int(IntOverridesTrunc()), 42)
-
-            class JustTrunc(base):
-                def __trunc__(self):
-                    return 42
-            self.assertEqual(int(JustTrunc()), 42)
-
-            class JustLong(base):
-                # test that __long__ no longer used in 3.x
-                def __long__(self):
-                    return 42
-            self.assertRaises(TypeError, int, JustLong())
-
-            class LongTrunc(base):
-                # __long__ should be ignored in 3.x
-                def __long__(self):
-                    return 42
-                def __trunc__(self):
-                    return 1729
-            self.assertEqual(int(LongTrunc()), 1729)
-
-            for trunc_result_base in (object, Classic):
-                class Integral(trunc_result_base):
-                    def __int__(self):
-                        return 42
-
-                class TruncReturnsNonLong(base):
-                    def __trunc__(self):
-                        return Integral()
-                self.assertEqual(int(TruncReturnsNonLong()), 42)
-
-                class NonIntegral(trunc_result_base):
-                    def __trunc__(self):
-                        # Check that we avoid infinite recursion.
-                        return NonIntegral()
-
-                class TruncReturnsNonIntegral(base):
-                    def __trunc__(self):
-                        return NonIntegral()
-                try:
-                    int(TruncReturnsNonIntegral())
-                except TypeError as e:
-                    self.assertEquals(str(e),
-                                      "__trunc__ returned non-Integral"
-                                      " (type NonIntegral)")
-                else:
-                    self.fail("Failed to raise TypeError with %s" %
-                              ((base, trunc_result_base),))
-
-    def test_misc(self):
-
-        # check the extremes in int<->long conversion
-        hugepos = sys.maxsize
-        hugeneg = -hugepos - 1
-        hugepos_aslong = int(hugepos)
-        hugeneg_aslong = int(hugeneg)
-        self.assertEqual(hugepos, hugepos_aslong, "long(sys.maxsize) != sys.maxsize")
-        self.assertEqual(hugeneg, hugeneg_aslong,
-            "long(-sys.maxsize-1) != -sys.maxsize-1")
-
-        # long -> int should not fail for hugepos_aslong or hugeneg_aslong
-        x = int(hugepos_aslong)
-        try:
-            self.assertEqual(x, hugepos,
-                  "converting sys.maxsize to long and back to int fails")
-        except OverflowError:
-            self.fail("int(long(sys.maxsize)) overflowed!")
-        if not isinstance(x, int):
-            raise TestFailed("int(long(sys.maxsize)) should have returned int")
-        x = int(hugeneg_aslong)
-        try:
-            self.assertEqual(x, hugeneg,
-                  "converting -sys.maxsize-1 to long and back to int fails")
-        except OverflowError:
-            self.fail("int(long(-sys.maxsize-1)) overflowed!")
-        if not isinstance(x, int):
-            raise TestFailed("int(long(-sys.maxsize-1)) should have "
-                             "returned int")
-        # but long -> int should overflow for hugepos+1 and hugeneg-1
-        x = hugepos_aslong + 1
-        try:
-            y = int(x)
-        except OverflowError:
-            self.fail("int(long(sys.maxsize) + 1) mustn't overflow")
-        self.assertTrue(isinstance(y, int),
-            "int(long(sys.maxsize) + 1) should have returned long")
-
-        x = hugeneg_aslong - 1
-        try:
-            y = int(x)
-        except OverflowError:
-            self.fail("int(long(-sys.maxsize-1) - 1) mustn't overflow")
-        self.assertTrue(isinstance(y, int),
-               "int(long(-sys.maxsize-1) - 1) should have returned long")
-
-        class long2(int):
-            pass
-        x = long2(1<<100)
-        y = int(x)
-        self.assertTrue(type(y) is int,
-            "overflowing int conversion must return long not long subtype")
-
-# ----------------------------------- tests of auto int->long conversion
-
-    def test_auto_overflow(self):
-        import math, sys
-
-        special = [0, 1, 2, 3, sys.maxsize-1, sys.maxsize, sys.maxsize+1]
-        sqrt = int(math.sqrt(sys.maxsize))
-        special.extend([sqrt-1, sqrt, sqrt+1])
-        special.extend([-i for i in special])
-
-        def checkit(*args):
-            # Heavy use of nested scopes here!
-            self.assertEqual(got, expected,
-                Frm("for %r expected %r got %r", args, expected, got))
-
-        for x in special:
-            longx = int(x)
-
-            expected = -longx
-            got = -x
-            checkit('-', x)
-
-            for y in special:
-                longy = int(y)
-
-                expected = longx + longy
-                got = x + y
-                checkit(x, '+', y)
-
-                expected = longx - longy
-                got = x - y
-                checkit(x, '-', y)
-
-                expected = longx * longy
-                got = x * y
-                checkit(x, '*', y)
-
-                if y:
-                    expected = longx / longy
-                    got = x / y
-                    checkit(x, '/', y)
-
-                    expected = longx // longy
-                    got = x // y
-                    checkit(x, '//', y)
-
-                    expected = divmod(longx, longy)
-                    got = divmod(longx, longy)
-                    checkit(x, 'divmod', y)
-
-                if abs(y) < 5 and not (x == 0 and y < 0):
-                    expected = longx ** longy
-                    got = x ** y
-                    checkit(x, '**', y)
-
-                    for z in special:
-                        if z != 0 :
-                            if y >= 0:
-                                expected = pow(longx, longy, int(z))
-                                got = pow(x, y, z)
-                                checkit('pow', x, y, '%', z)
-                            else:
-                                self.assertRaises(TypeError, pow,longx, longy, int(z))
+            def __trunc__(self):
+                return 1729
+        self.assertEqual(int(LongTrunc()), 1729)
 
     @unittest.skipUnless(float.__getformat__("double").startswith("IEEE"),
                          "test requires IEEE 754 doubles")
@@ -707,10 +390,10 @@
 
             self.assertRaises(OverflowError, eval, test, namespace)
 
-            # XXX Perhaps float(shuge) can raise OverflowError on some box?
-            # The comparison should not.
-            self.assertNotEqual(float(shuge), int(shuge),
-                "float(shuge) should not equal int(shuge)")
+        # XXX Perhaps float(shuge) can raise OverflowError on some box?
+        # The comparison should not.
+        self.assertNotEqual(float(shuge), int(shuge),
+            "float(shuge) should not equal int(shuge)")
 
     def test_logs(self):
         import math
@@ -807,7 +490,7 @@
             cases.extend([t - 1.0, t - 0.3, t, t + 0.3, t + 1.0,
                           int(t-1), int(t), int(t+1)])
         cases.extend([0, 1, 2, sys.maxsize, float(sys.maxsize)])
-        # 1L<<20000 should exceed all double formats.  long(1e200) is to
+        # 1 << 20000 should exceed all double formats.  int(1e200) is to
         # check that we get equality with 1e200 above.
         t = int(1e200)
         cases.extend([0, 1, 2, 1 << 20000, t-1, t, t+1])
Index: Lib/test/test_types.py
===================================================================
--- Lib/test/test_types.py	(revision 76671)
+++ Lib/test/test_types.py	(working copy)
@@ -10,11 +10,9 @@
     def test_truth_values(self):
         if None: self.fail('None is true instead of false')
         if 0: self.fail('0 is true instead of false')
-        if 0: self.fail('0L is true instead of false')
         if 0.0: self.fail('0.0 is true instead of false')
         if '': self.fail('\'\' is true instead of false')
         if not 1: self.fail('1 is false instead of true')
-        if not 1: self.fail('1L is false instead of true')
         if not 1.0: self.fail('1.0 is false instead of true')
         if not 'x': self.fail('\'x\' is false instead of true')
         if not {'x': 1}: self.fail('{\'x\': 1} is false instead of true')
@@ -36,8 +34,6 @@
     def test_comparisons(self):
         if 0 < 1 <= 1 == 1 >= 1 > 0 != 1: pass
         else: self.fail('int comparisons failed')
-        if 0 < 1 <= 1 == 1 >= 1 > 0 != 1: pass
-        else: self.fail('long int comparisons failed')
         if 0.0 < 1.0 <= 1.0 == 1.0 >= 1.0 > 0.0 != 1.0: pass
         else: self.fail('float comparisons failed')
         if '' < 'a' <= 'a' == 'a' < 'abc' < 'abd' < 'b': pass
@@ -75,18 +71,13 @@
         else: self.fail("5 % 0 didn't raise ZeroDivisionError")
 
     def test_numeric_types(self):
-        if 0 != 0 or 0 != 0.0 or 0 != 0.0: self.fail('mixed comparisons')
-        if 1 != 1 or 1 != 1.0 or 1 != 1.0: self.fail('mixed comparisons')
-        if -1 != -1 or -1 != -1.0 or -1 != -1.0:
-            self.fail('int/long/float value not equal')
+        if 0 != 0.0 or 1 != 1.0 or -1 != -1.0:
+            self.fail('int/float value not equal')
         # calling built-in types without argument must return 0
         if int() != 0: self.fail('int() does not return 0')
-        if int() != 0: self.fail('long() does not return 0')
         if float() != 0.0: self.fail('float() does not return 0.0')
         if int(1.9) == 1 == int(1.1) and int(-1.1) == -1 == int(-1.9): pass
         else: self.fail('int() does not round properly')
-        if int(1.9) == 1 == int(1.1) and int(-1.1) == -1 == int(-1.9): pass
-        else: self.fail('long() does not round properly')
         if float(1) == 1.0 and float(-1) == -1.0 and float(0) == 0.0: pass
         else: self.fail('float() does not work properly')
 
@@ -141,58 +132,39 @@
             if type(prod) is not int:
                 self.fail("expected type(prod) to be int, not %r" %
                                    type(prod))
-        # Check for expected * overflow to long.
+        # Check for unified integral type
         for divisor in 1, 2, 4, 8, 16, 32:
             j = m // divisor - 1
             prod = divisor * j
             if type(prod) is not int:
-                self.fail("expected type(%r) to be long, not %r" %
+                self.fail("expected type(%r) to be int, not %r" %
                                    (prod, type(prod)))
-        # Check for expected * overflow to long.
+        # Check for unified integral type
         m = sys.maxsize
         for divisor in 1, 2, 4, 8, 16, 32:
             j = m // divisor + 1
             prod = divisor * j
             if type(prod) is not int:
-                self.fail("expected type(%r) to be long, not %r" %
+                self.fail("expected type(%r) to be int, not %r" %
                                    (prod, type(prod)))
 
     def test_long_integers(self):
-        if 12 + 24 != 36: self.fail('long op')
-        if 12 + (-24) != -12: self.fail('long op')
-        if (-12) + 24 != 12: self.fail('long op')
-        if (-12) + (-24) != -36: self.fail('long op')
-        if not 12 < 24: self.fail('long op')
-        if not -24 < -12: self.fail('long op')
         x = sys.maxsize
-        if int(int(x)) != x: self.fail('long op')
-        try: y = int(int(x)+1)
-        except OverflowError: self.fail('long op')
-        if not isinstance(y, int): self.fail('long op')
-        x = -x
-        if int(int(x)) != x: self.fail('long op')
-        x = x-1
-        if int(int(x)) != x: self.fail('long op')
-        try: y = int(int(x)-1)
-        except OverflowError: self.fail('long op')
-        if not isinstance(y, int): self.fail('long op')
+        self.assertTrue(isinstance(x + 1, int),
+            "(sys.maxsize + 1) should have returned int")
+        self.assertTrue(isinstance(-x - 1, int),
+            "(-sys.maxsize - 1) should have returned int")
+        self.assertTrue(isinstance(-x - 2, int),
+            "(-sys.maxsize - 2) should have returned int")
 
         try: 5 << -5
         except ValueError: pass
         else: self.fail('int negative shift <<')
 
-        try: 5 << -5
-        except ValueError: pass
-        else: self.fail('long negative shift <<')
-
         try: 5 >> -5
         except ValueError: pass
         else: self.fail('int negative shift >>')
 
-        try: 5 >> -5
-        except ValueError: pass
-        else: self.fail('long negative shift >>')
-
     def test_floats(self):
         if 12.0 + 24.0 != 36.0: self.fail('float op')
         if 12.0 + (-24.0) != -12.0: self.fail('float op')
@@ -232,7 +204,7 @@
 
     def test_int__format__(self):
         def test(i, format_spec, result):
-            # just make sure I'm not accidentally checking longs
+            # just make sure we have the unified type for integers
             assert type(i) == int
             assert type(format_spec) == str
             self.assertEqual(i.__format__(format_spec), result)
@@ -353,6 +325,10 @@
         # issue 5782, commas with no specifier type
         test(1234, '010,', '00,001,234')
 
+        # Unified type for integers
+        test(10**100, 'd', '1' + '0' * 100)
+        test(10**100+100, 'd', '1' + '0' * 97 + '100')
+
         # make sure these are errors
 
         # precision disallowed
@@ -382,96 +358,6 @@
                 self.assertEqual(value.__format__(format_spec),
                                  float(value).__format__(format_spec))
 
-    def test_long__format__(self):
-        def test(i, format_spec, result):
-            # make sure we're not accidentally checking ints
-            assert type(i) == int
-            assert type(format_spec) == str
-            self.assertEqual(i.__format__(format_spec), result)
-
-        test(10**100, 'd', '1' + '0' * 100)
-        test(10**100+100, 'd', '1' + '0' * 97 + '100')
-
-        test(123456789, 'd', '123456789')
-        test(123456789, 'd', '123456789')
-
-        # sign and aligning are interdependent
-        test(1, "-", '1')
-        test(-1, "-", '-1')
-        test(1, "-3", '  1')
-        test(-1, "-3", ' -1')
-        test(1, "+3", ' +1')
-        test(-1, "+3", ' -1')
-        test(1, " 3", '  1')
-        test(-1, " 3", ' -1')
-        test(1, " ", ' 1')
-        test(-1, " ", '-1')
-
-        test(1, 'c', '\01')
-
-        # hex
-        test(3, "x", "3")
-        test(3, "X", "3")
-        test(1234, "x", "4d2")
-        test(-1234, "x", "-4d2")
-        test(1234, "8x", "     4d2")
-        test(-1234, "8x", "    -4d2")
-        test(1234, "x", "4d2")
-        test(-1234, "x", "-4d2")
-        test(-3, "x", "-3")
-        test(-3, "X", "-3")
-
-        # octal
-        test(3, "o", "3")
-        test(-3, "o", "-3")
-        test(65, "o", "101")
-        test(-65, "o", "-101")
-        test(1234, "o", "2322")
-        test(-1234, "o", "-2322")
-        test(1234, "-o", "2322")
-        test(-1234, "-o", "-2322")
-        test(1234, " o", " 2322")
-        test(-1234, " o", "-2322")
-        test(1234, "+o", "+2322")
-        test(-1234, "+o", "-2322")
-
-        # binary
-        test(3, "b", "11")
-        test(-3, "b", "-11")
-        test(1234, "b", "10011010010")
-        test(-1234, "b", "-10011010010")
-        test(1234, "-b", "10011010010")
-        test(-1234, "-b", "-10011010010")
-        test(1234, " b", " 10011010010")
-        test(-1234, " b", "-10011010010")
-        test(1234, "+b", "+10011010010")
-        test(-1234, "+b", "-10011010010")
-
-        # make sure these are errors
-
-        # precision disallowed
-        self.assertRaises(ValueError, 3 .__format__, "1.3")
-        # sign not allowed with 'c'
-        self.assertRaises(ValueError, 3 .__format__, "+c")
-        # format spec must be string
-        self.assertRaises(TypeError, 3 .__format__, None)
-        self.assertRaises(TypeError, 3 .__format__, 0)
-
-        # ensure that only int and float type specifiers work
-        for format_spec in ([chr(x) for x in range(ord('a'), ord('z')+1)] +
-                            [chr(x) for x in range(ord('A'), ord('Z')+1)]):
-            if not format_spec in 'bcdoxXeEfFgGn%':
-                self.assertRaises(ValueError, 0 .__format__, format_spec)
-                self.assertRaises(ValueError, 1 .__format__, format_spec)
-                self.assertRaises(ValueError, (-1) .__format__, format_spec)
-
-        # ensure that float type specifiers work; format converts
-        #  the long to a float
-        for format_spec in 'eEfFgG%':
-            for value in [0, 1, -1, 100, -100, 1234567890, -1234567890]:
-                self.assertEqual(value.__format__(format_spec),
-                                 float(value).__format__(format_spec))
-
     @run_with_locale('LC_NUMERIC', 'en_US.UTF8')
     def test_float__format__locale(self):
         # test locale support for __format__ code 'n'