diff --git a/Lib/test/test_builtin.py b/Lib/test/test_builtin.py
index d47a9da..1953f29 100644
--- a/Lib/test/test_builtin.py
+++ b/Lib/test/test_builtin.py
@@ -437,8 +437,7 @@
     def test_hex(self):
         self.assertEqual(hex(16), '0x10')
         self.assertEqual(hex(16L), '0x10L')
-        self.assertEqual(len(hex(-1)), len(hex(sys.maxint)))
-        self.assert_(hex(-16) in ('0xfffffff0', '0xfffffffffffffff0'))
+        self.assertEqual(hex(-16), '-0x10')
         self.assertEqual(hex(-16L), '-0x10L')
         self.assertRaises(TypeError, hex, {})
 
@@ -757,7 +756,7 @@
     def test_oct(self):
         self.assertEqual(oct(100), '0144')
         self.assertEqual(oct(100L), '0144L')
-        self.assert_(oct(-100) in ('037777777634', '01777777777777777777634'))
+        self.assertEqual(oct(-100), '-0144')
         self.assertEqual(oct(-100L), '-0144L')
         self.assertRaises(TypeError, oct, ())
 
diff --git a/Lib/test/test_compile.py b/Lib/test/test_compile.py
index 4d4ba4f..e2b1c95 100644
--- a/Lib/test/test_compile.py
+++ b/Lib/test/test_compile.py
@@ -119,15 +119,18 @@
 
     def test_unary_minus(self):
         # Verify treatment of unary minus on negative numbers SF bug #660455
-        warnings.filterwarnings("ignore", "hex/oct constants", FutureWarning)
-        warnings.filterwarnings("ignore", "hex.* of negative int", FutureWarning)
-        # XXX Of course the following test will have to be changed in Python 2.4
-        # This test is in a <string> so the filterwarnings() can affect it
-        all_one_bits = '0xffffffff'
-        if sys.maxint != 2147483647:
+        if sys.maxint == 2147483647:
+            # 32-bit machine
+            all_one_bits = '0xffffffff'
+            self.assertEqual(eval(all_one_bits), 4294967295L)
+            self.assertEqual(eval("-" + all_one_bits), -4294967295L)
+        elif sys.maxint == 9223372036854775807:
+            # 64-bit machine
             all_one_bits = '0xffffffffffffffff'
-        self.assertEqual(eval(all_one_bits), -1)
-        self.assertEqual(eval("-" + all_one_bits), 1)
+            self.assertEqual(eval(all_one_bits), 18446744073709551615L)
+            self.assertEqual(eval("-" + all_one_bits), -18446744073709551615L)
+        else:
+            self.fail("How many bits *does* this machine have???")
 
     def test_sequence_unpacking_error(self):
         # Verify sequence packing/unpacking with "or".  SF bug #757818
diff --git a/Lib/test/test_format.py b/Lib/test/test_format.py
index f791874..0a51231 100644
--- a/Lib/test/test_format.py
+++ b/Lib/test/test_format.py
@@ -183,12 +183,12 @@
 testboth("%#X", 0L, "0X0")
 
 testboth("%x", 0x42, "42")
-# testboth("%x", -0x42, "ffffffbe") # specific to 32-bit boxes; see below
+testboth("%x", -0x42, "-42")
 testboth("%x", 0x42L, "42")
 testboth("%x", -0x42L, "-42")
 
 testboth("%o", 042, "42")
-# testboth("%o", -042, "37777777736") # specific to 32-bit boxes; see below
+testboth("%o", -042, "-42")
 testboth("%o", 042L, "42")
 testboth("%o", -042L, "-42")
 
@@ -238,6 +238,3 @@
         pass
     else:
         raise TestFailed, '"%*d"%(sys.maxint, -127) should fail'
-    # (different things go wrong on a 64 bit box...)
-    testboth("%x", -0x42, "ffffffbe")
-    testboth("%o", -042, "37777777736")
diff --git a/Lib/test/test_grammar.py b/Lib/test/test_grammar.py
index c57bbed..6666c13 100644
--- a/Lib/test/test_grammar.py
+++ b/Lib/test/test_grammar.py
@@ -39,20 +39,20 @@
 if maxint == 2147483647:
     # The following test will start to fail in Python 2.4;
     # change the 020000000000 to -020000000000
-    if -2147483647-1 != 020000000000: raise TestFailed, 'max negative int'
+    if -2147483647-1 != -020000000000: raise TestFailed, 'max negative int'
     # XXX -2147483648
-    if 037777777777 != -1: raise TestFailed, 'oct -1'
-    if 0xffffffff != -1: raise TestFailed, 'hex -1'
+    if 037777777777 < 0: raise TestFailed, 'large oct'
+    if 0xffffffff < 0: raise TestFailed, 'large hex'
     for s in '2147483648', '040000000000', '0x100000000':
         try:
             x = eval(s)
         except OverflowError:
             print "OverflowError on huge integer literal " + `s`
 elif eval('maxint == 9223372036854775807'):
-    if eval('-9223372036854775807-1 != 01000000000000000000000'):
+    if eval('-9223372036854775807-1 != -01000000000000000000000'):
         raise TestFailed, 'max negative int'
-    if eval('01777777777777777777777') != -1: raise TestFailed, 'oct -1'
-    if eval('0xffffffffffffffff') != -1: raise TestFailed, 'hex -1'
+    if eval('01777777777777777777777') < 0: raise TestFailed, 'large oct'
+    if eval('0xffffffffffffffff') < 0: raise TestFailed, 'large hex'
     for s in '9223372036854775808', '02000000000000000000000', \
              '0x10000000000000000':
         try:
diff --git a/Lib/test/test_hexoct.py b/Lib/test/test_hexoct.py
index 8a57906..f71dbe0 100644
--- a/Lib/test/test_hexoct.py
+++ b/Lib/test/test_hexoct.py
@@ -1,8 +1,6 @@
 """Test correct treatment of hex/oct constants.
 
 This is complex because of changes due to PEP 237.
-
-Some of these tests will have to change in Python 2.4!
 """
 
 import sys
@@ -41,31 +39,28 @@
             self.assertEqual(-0x7fffffffffffffff, -9223372036854775807)
 
     def test_hex_unsigned(self):
-        # This test is in a <string> so we can ignore the warnings
-        exec """if 1:
         if platform_long_is_32_bits:
-            # Positive-looking constants with negavive values
-            self.assertEqual(0x80000000, -2147483648L)
-            self.assertEqual(0xffffffff, -1)
+            # Positive constants
+            self.assertEqual(0x80000000, 2147483648L)
+            self.assertEqual(0xffffffff, 4294967295L)
             # Ditto with a minus sign and parentheses
-            self.assertEqual(-(0x80000000), 2147483648L)
-            self.assertEqual(-(0xffffffff), 1)
+            self.assertEqual(-(0x80000000), -2147483648L)
+            self.assertEqual(-(0xffffffff), -4294967295L)
             # Ditto with a minus sign and NO parentheses
             # This failed in Python 2.2 through 2.2.2 and in 2.3a1
-            self.assertEqual(-0x80000000, 2147483648L)
-            self.assertEqual(-0xffffffff, 1)
+            self.assertEqual(-0x80000000, -2147483648L)
+            self.assertEqual(-0xffffffff, -4294967295L)
         else:
-            # Positive-looking constants with negavive values
-            self.assertEqual(0x8000000000000000, -9223372036854775808L)
-            self.assertEqual(0xffffffffffffffff, -1)
+            # Positive constants
+            self.assertEqual(0x8000000000000000, 9223372036854775808L)
+            self.assertEqual(0xffffffffffffffff, 18446744073709551615L)
             # Ditto with a minus sign and parentheses
-            self.assertEqual(-(0x8000000000000000), 9223372036854775808L)
-            self.assertEqual(-(0xffffffffffffffff), 1)
+            self.assertEqual(-(0x8000000000000000), -9223372036854775808L)
+            self.assertEqual(-(0xffffffffffffffff), -18446744073709551615L)
             # Ditto with a minus sign and NO parentheses
             # This failed in Python 2.2 through 2.2.2 and in 2.3a1
-            self.assertEqual(-0x8000000000000000, 9223372036854775808L)
-            self.assertEqual(-0xffffffffffffffff, 1)
-        \n"""
+            self.assertEqual(-0x8000000000000000, -9223372036854775808L)
+            self.assertEqual(-0xffffffffffffffff, -18446744073709551615L)
 
     def test_oct_baseline(self):
         # Baseline tests
@@ -91,31 +86,28 @@
             self.assertEqual(-0777777777777777777777, -9223372036854775807)
 
     def test_oct_unsigned(self):
-        # This test is in a <string> so we can ignore the warnings
-        exec """if 1:
         if platform_long_is_32_bits:
-            # Positive-looking constants with negavive values
-            self.assertEqual(020000000000, -2147483648L)
-            self.assertEqual(037777777777, -1)
+            # Positive constants
+            self.assertEqual(020000000000, 2147483648L)
+            self.assertEqual(037777777777, 4294967295L)
             # Ditto with a minus sign and parentheses
-            self.assertEqual(-(020000000000), 2147483648L)
-            self.assertEqual(-(037777777777), 1)
+            self.assertEqual(-(020000000000), -2147483648L)
+            self.assertEqual(-(037777777777), -4294967295L)
             # Ditto with a minus sign and NO parentheses
             # This failed in Python 2.2 through 2.2.2 and in 2.3a1
-            self.assertEqual(-020000000000, 2147483648L)
-            self.assertEqual(-037777777777, 1)
+            self.assertEqual(-020000000000, -2147483648L)
+            self.assertEqual(-037777777777, -4294967295L)
         else:
-            # Positive-looking constants with negavive values
-            self.assertEqual(01000000000000000000000, -9223372036854775808L)
-            self.assertEqual(01777777777777777777777, -1)
+            # Positive constants
+            self.assertEqual(01000000000000000000000, 9223372036854775808L)
+            self.assertEqual(01777777777777777777777, 18446744073709551615L)
             # Ditto with a minus sign and parentheses
-            self.assertEqual(-(01000000000000000000000), 9223372036854775808L)
-            self.assertEqual(-(01777777777777777777777), 1)
+            self.assertEqual(-(01000000000000000000000), -9223372036854775808L)
+            self.assertEqual(-(01777777777777777777777), -18446744073709551615L)
             # Ditto with a minus sign and NO parentheses
             # This failed in Python 2.2 through 2.2.2 and in 2.3a1
-            self.assertEqual(-01000000000000000000000, 9223372036854775808L)
-            self.assertEqual(-01777777777777777777777, 1)
-        \n"""
+            self.assertEqual(-01000000000000000000000, -9223372036854775808L)
+            self.assertEqual(-01777777777777777777777, -18446744073709551615L)
 
 def test_main():
     test_support.run_unittest(TextHexOct)