bump to v3.0.5, fix deprecations in testsv3.0.5

24 files changed, 157 insertions, 136 deletions

diff --git a/.travis.yml b/.travis.yml
index 1476005..30d9f58 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -7,4 +7,5 @@ python:
   - "pypy"
 script:
   - python setup.py build_ext -i
+  - python -m compileall -f .
   - python setup.py test
diff --git a/CHANGES.txt b/CHANGES.txt
index 7a12171..375b28a 100644
--- a/CHANGES.txt
+++ b/CHANGES.txt
@@ -1,3 +1,13 @@
+Version 3.0.5 released 2013-01-03
+
+* NOTE: this release only changes the tests, it is
+  not essential to upgrade
+* Tests now run with deprecation warnings printed
+* Fixed Python 3 syntax error in simplejson.tool
+  https://github.com/simplejson/simplejson/issues/49
+* Fixed Python 3.3 deprecation warnings in test suite
+  https://github.com/simplejson/simplejson/issues/48
+
 Version 3.0.4 released 2013-01-02
 
 * MSVC compatibility for Python 3.3
@@ -24,7 +34,8 @@ Version 3.0.1 released 2013-01-01
 
 Version 3.0.0 released 2012-12-30
 
-* Python 3.3 is now supported, thanks to Vinay Sajip #8
+* Python 3.3 is now supported, thanks to Vinay Sajip
+  https://github.com/simplejson/simplejson/issues/8
 * `sort_keys`/`item_sort_key` now sort on the stringified verison of the
   key, rather than the original object. This ensures that the sort
   only compares string types and makes the behavior consistent between
diff --git a/conf.py b/conf.py
index 2f80e59..b5b7448 100644
--- a/conf.py
+++ b/conf.py
@@ -44,7 +44,7 @@ copyright = '2012, Bob Ippolito'
 # The short X.Y version.
 version = '3.0'
 # The full version, including alpha/beta/rc tags.
-release = '3.0.4'
+release = '3.0.5'
 
 # There are two options for replacing |today|: either, you set today to some
 # non-false value, then it is used:
diff --git a/setup.py b/setup.py
index e61bac3..607e7bc 100644
--- a/setup.py
+++ b/setup.py
@@ -1,4 +1,5 @@
 #!/usr/bin/env python
+from __future__ import with_statement
 
 import sys
 from distutils.core import setup, Extension, Command
@@ -7,9 +8,11 @@ from distutils.errors import CCompilerError, DistutilsExecError, \
     DistutilsPlatformError
 
 IS_PYPY = hasattr(sys, 'pypy_translation_info')
-VERSION = '3.0.4'
+VERSION = '3.0.5'
 DESCRIPTION = "Simple, fast, extensible JSON encoder/decoder for Python"
-LONG_DESCRIPTION = open('README.rst', 'r').read()
+
+with open('README.rst', 'r') as f:
+   LONG_DESCRIPTION = f.read()
 
 CLASSIFIERS = filter(None, map(str.strip,
 """
@@ -67,7 +70,10 @@ class TestCommand(Command):
     def run(self):
         import sys, subprocess
         raise SystemExit(
-            subprocess.call([sys.executable, 'simplejson/tests/__init__.py']))
+            subprocess.call([sys.executable,
+                             # Turn on deprecation warnings
+                             '-Wd',
+                             'simplejson/tests/__init__.py']))
 
 def run_setup(with_binary):
     cmdclass = dict(test=TestCommand)
diff --git a/simplejson/__init__.py b/simplejson/__init__.py
index 4455dd1..955d786 100644
--- a/simplejson/__init__.py
+++ b/simplejson/__init__.py
@@ -99,7 +99,7 @@ Using simplejson.tool from the shell to validate and pretty-print::
     Expecting property name: line 1 column 2 (char 2)
 """
 from __future__ import absolute_import
-__version__ = '3.0.4'
+__version__ = '3.0.5'
 __all__ = [
     'dump', 'dumps', 'load', 'loads',
     'JSONDecoder', 'JSONDecodeError', 'JSONEncoder',
diff --git a/simplejson/tests/test_bigint_as_string.py b/simplejson/tests/test_bigint_as_string.py
index f74f75d..20ea64c 100644
--- a/simplejson/tests/test_bigint_as_string.py
+++ b/simplejson/tests/test_bigint_as_string.py
@@ -1,23 +1,26 @@
 from unittest import TestCase
 
 import simplejson as json
+from simplejson.compat import long_type
 
 class TestBigintAsString(TestCase):
+    # Python 2.5, at least the one that ships on Mac OS X, calculates
+    # 2 ** 53 as 0! It manages to calculate 1 << 53 correctly.
     values = [(200, 200),
-              ((2 ** 53) - 1, 9007199254740991),
-              ((2 ** 53), '9007199254740992'),
-              ((2 ** 53) + 1, '9007199254740993'),
+              ((1 << 53) - 1, 9007199254740991),
+              ((1 << 53), '9007199254740992'),
+              ((1 << 53) + 1, '9007199254740993'),
               (-100, -100),
-              ((-2 ** 53), '-9007199254740992'),
-              ((-2 ** 53) - 1, '-9007199254740993'),
-              ((-2 ** 53) + 1, -9007199254740991)]
+              ((-1 << 53), '-9007199254740992'),
+              ((-1 << 53) - 1, '-9007199254740993'),
+              ((-1 << 53) + 1, -9007199254740991)]
 
     def test_ints(self):
         for val, expect in self.values:
-            self.assertEquals(
+            self.assertEqual(
                 val,
                 json.loads(json.dumps(val)))
-            self.assertEquals(
+            self.assertEqual(
                 expect,
                 json.loads(json.dumps(val, bigint_as_string=True)))
 
@@ -25,10 +28,10 @@ class TestBigintAsString(TestCase):
         for val, expect in self.values:
             val = [val, val]
             expect = [expect, expect]
-            self.assertEquals(
+            self.assertEqual(
                 val,
                 json.loads(json.dumps(val)))
-            self.assertEquals(
+            self.assertEqual(
                 expect,
                 json.loads(json.dumps(val, bigint_as_string=True)))
 
@@ -36,10 +39,10 @@ class TestBigintAsString(TestCase):
         for val, expect in self.values:
             val = {'k': val}
             expect = {'k': expect}
-            self.assertEquals(
+            self.assertEqual(
                 val,
                 json.loads(json.dumps(val)))
-            self.assertEquals(
+            self.assertEqual(
                 expect,
                 json.loads(json.dumps(val, bigint_as_string=True)))
 
@@ -47,9 +50,9 @@ class TestBigintAsString(TestCase):
         for val, _ in self.values:
             expect = {str(val): 'value'}
             val = {val: 'value'}
-            self.assertEquals(
+            self.assertEqual(
                 expect,
                 json.loads(json.dumps(val)))
-            self.assertEquals(
+            self.assertEqual(
                 expect,
                 json.loads(json.dumps(val, bigint_as_string=True)))
diff --git a/simplejson/tests/test_decimal.py b/simplejson/tests/test_decimal.py
index ed1dada..2b0940b 100644
--- a/simplejson/tests/test_decimal.py
+++ b/simplejson/tests/test_decimal.py
@@ -11,27 +11,27 @@ class TestDecimal(TestCase):
         sio = StringIO()
         json.dump(obj, sio, **kw)
         res = json.dumps(obj, **kw)
-        self.assertEquals(res, sio.getvalue())
+        self.assertEqual(res, sio.getvalue())
         return res
 
     def loads(self, s, **kw):
         sio = StringIO(s)
         res = json.loads(s, **kw)
-        self.assertEquals(res, json.load(sio, **kw))
+        self.assertEqual(res, json.load(sio, **kw))
         return res
 
     def test_decimal_encode(self):
         for d in map(Decimal, self.NUMS):
-            self.assertEquals(self.dumps(d, use_decimal=True), str(d))
+            self.assertEqual(self.dumps(d, use_decimal=True), str(d))
 
     def test_decimal_decode(self):
         for s in self.NUMS:
-            self.assertEquals(self.loads(s, parse_float=Decimal), Decimal(s))
+            self.assertEqual(self.loads(s, parse_float=Decimal), Decimal(s))
 
     def test_stringify_key(self):
         for d in map(Decimal, self.NUMS):
             v = {d: d}
-            self.assertEquals(
+            self.assertEqual(
                 self.loads(
                     self.dumps(v, use_decimal=True), parse_float=Decimal),
                 {str(d): d})
@@ -41,7 +41,7 @@ class TestDecimal(TestCase):
             # The type might not be the same (int and Decimal) but they
             # should still compare equal.
             for v in [d, [d], {'': d}]:
-                self.assertEquals(
+                self.assertEqual(
                     self.loads(
                         self.dumps(v, use_decimal=True), parse_float=Decimal),
                     v)
diff --git a/simplejson/tests/test_decode.py b/simplejson/tests/test_decode.py
index 5c488c6..ea5c90a 100644
--- a/simplejson/tests/test_decode.py
+++ b/simplejson/tests/test_decode.py
@@ -14,19 +14,19 @@ class TestDecode(TestCase):
     def test_decimal(self):
         rval = json.loads('1.1', parse_float=decimal.Decimal)
         self.assertTrue(isinstance(rval, decimal.Decimal))
-        self.assertEquals(rval, decimal.Decimal('1.1'))
+        self.assertEqual(rval, decimal.Decimal('1.1'))
 
     def test_float(self):
         rval = json.loads('1', parse_int=float)
         self.assertTrue(isinstance(rval, float))
-        self.assertEquals(rval, 1.0)
+        self.assertEqual(rval, 1.0)
 
     def test_decoder_optimizations(self):
         # Several optimizations were made that skip over calls to
         # the whitespace regex, so this test is designed to try and
         # exercise the uncommon cases. The array cases are already covered.
         rval = json.loads('{   "key"    :    "value"    ,  "k":"v"    }')
-        self.assertEquals(rval, {"key":"value", "k":"v"})
+        self.assertEqual(rval, {"key":"value", "k":"v"})
 
     def test_empty_objects(self):
         s = '{}'
diff --git a/simplejson/tests/test_default.py b/simplejson/tests/test_default.py
index 139e42b..d1eacb8 100644
--- a/simplejson/tests/test_default.py
+++ b/simplejson/tests/test_default.py
@@ -4,6 +4,6 @@ import simplejson as json
 
 class TestDefault(TestCase):
     def test_default(self):
-        self.assertEquals(
+        self.assertEqual(
             json.dumps(type, default=repr),
             json.dumps(repr(type)))
diff --git a/simplejson/tests/test_dump.py b/simplejson/tests/test_dump.py
index 0ad2c40..1d118d9 100644
--- a/simplejson/tests/test_dump.py
+++ b/simplejson/tests/test_dump.py
@@ -11,13 +11,13 @@ class TestDump(TestCase):
     def test_dump(self):
         sio = StringIO()
         json.dump({}, sio)
-        self.assertEquals(sio.getvalue(), '{}')
+        self.assertEqual(sio.getvalue(), '{}')
 
     def test_constants(self):
         for c in [None, True, False]:
-            self.assert_(json.loads(json.dumps(c)) is c)
-            self.assert_(json.loads(json.dumps([c]))[0] is c)
-            self.assert_(json.loads(json.dumps({'a': c}))['a'] is c)
+            self.assertTrue(json.loads(json.dumps(c)) is c)
+            self.assertTrue(json.loads(json.dumps([c]))[0] is c)
+            self.assertTrue(json.loads(json.dumps({'a': c}))['a'] is c)
 
     def test_stringify_key(self):
         items = [(b('bytes'), 'bytes'),
@@ -28,10 +28,10 @@ class TestDump(TestCase):
                  (None, 'null'),
                  (long_type(100), '100')]
         for k, expect in items:
-            self.assertEquals(
+            self.assertEqual(
                 json.loads(json.dumps({k: expect})),
                 {expect: expect})
-            self.assertEquals(
+            self.assertEqual(
                 json.loads(json.dumps({k: expect}, sort_keys=True)),
                 {expect: expect})
         self.assertRaises(TypeError, json.dumps, {json: 1})
@@ -40,24 +40,24 @@ class TestDump(TestCase):
                 v0 = dict(v)
                 v0[json] = 1
                 v1 = dict((as_text_type(key), val) for (key, val) in v.items())
-                self.assertEquals(
+                self.assertEqual(
                     json.loads(json.dumps(v0, skipkeys=True, sort_keys=sort_keys)),
                     v1)
-                self.assertEquals(
+                self.assertEqual(
                     json.loads(json.dumps({'': v0}, skipkeys=True, sort_keys=sort_keys)),
                     {'': v1})
-                self.assertEquals(
+                self.assertEqual(
                     json.loads(json.dumps([v0], skipkeys=True, sort_keys=sort_keys)),
                     [v1])
 
     def test_dumps(self):
-        self.assertEquals(json.dumps({}), '{}')
+        self.assertEqual(json.dumps({}), '{}')
 
     def test_encode_truefalse(self):
-        self.assertEquals(json.dumps(
+        self.assertEqual(json.dumps(
                  {True: False, False: True}, sort_keys=True),
                  '{"false": true, "true": false}')
-        self.assertEquals(
+        self.assertEqual(
             json.dumps(
                 {2: 3.0,
                  4.0: long_type(5),
diff --git a/simplejson/tests/test_encode_basestring_ascii.py b/simplejson/tests/test_encode_basestring_ascii.py
index 780bb0a..49706bf 100644
--- a/simplejson/tests/test_encode_basestring_ascii.py
+++ b/simplejson/tests/test_encode_basestring_ascii.py
@@ -35,10 +35,10 @@ class TestEncodeBaseStringAscii(TestCase):
         fname = encode_basestring_ascii.__name__
         for input_string, expect in CASES:
             result = encode_basestring_ascii(input_string)
-            #self.assertEquals(result, expect,
+            #self.assertEqual(result, expect,
             #    '{0!r} != {1!r} for {2}({3!r})'.format(
             #        result, expect, fname, input_string))
-            self.assertEquals(result, expect,
+            self.assertEqual(result, expect,
                 '%r != %r for %s(%r)' % (result, expect, fname, input_string))
 
     def test_sorted_dict(self):
diff --git a/simplejson/tests/test_errors.py b/simplejson/tests/test_errors.py
index 86c14e5..4d3891a 100644
--- a/simplejson/tests/test_errors.py
+++ b/simplejson/tests/test_errors.py
@@ -17,10 +17,10 @@ class TestErrors(TestCase):
             err = sys.exc_info()[1]
         else:
             self.fail('Expected JSONDecodeError')
-        self.assertEquals(err.lineno, 2)
-        self.assertEquals(err.colno, 1)
-        self.assertEquals(err.endlineno, 3)
-        self.assertEquals(err.endcolno, 2)
+        self.assertEqual(err.lineno, 2)
+        self.assertEqual(err.colno, 1)
+        self.assertEqual(err.endlineno, 3)
+        self.assertEqual(err.endcolno, 2)
 
     def test_scan_error(self):
         err = None
@@ -31,5 +31,5 @@ class TestErrors(TestCase):
                 err = sys.exc_info()[1]
             else:
                 self.fail('Expected JSONDecodeError')
-            self.assertEquals(err.lineno, 1)
-            self.assertEquals(err.colno, 9)
+            self.assertEqual(err.lineno, 1)
+            self.assertEqual(err.colno, 9)
diff --git a/simplejson/tests/test_fail.py b/simplejson/tests/test_fail.py
index 8d281b7..dfc7207 100644
--- a/simplejson/tests/test_fail.py
+++ b/simplejson/tests/test_fail.py
@@ -109,9 +109,9 @@ class TestFail(TestCase):
                 json.loads(doc)
             except json.JSONDecodeError:
                 e = sys.exc_info()[1]
-                self.assertEquals(e.pos, 1)
-                self.assertEquals(e.lineno, 1)
-                self.assertEquals(e.colno, 1)
+                self.assertEqual(e.pos, 1)
+                self.assertEqual(e.lineno, 1)
+                self.assertEqual(e.colno, 1)
             except Exception:
                 e = sys.exc_info()[1]
                 self.fail("Unexpected exception raised %r %s" % (e, e))
diff --git a/simplejson/tests/test_float.py b/simplejson/tests/test_float.py
index 5d50223..f61ed68 100644
--- a/simplejson/tests/test_float.py
+++ b/simplejson/tests/test_float.py
@@ -7,21 +7,21 @@ from simplejson.decoder import NaN, PosInf, NegInf
 class TestFloat(TestCase):
     def test_degenerates(self):
         for inf in (PosInf, NegInf):
-            self.assertEquals(json.loads(json.dumps(inf)), inf)
+            self.assertEqual(json.loads(json.dumps(inf)), inf)
         # Python 2.5 doesn't have math.isnan
         nan = json.loads(json.dumps(NaN))
-        self.assert_((0 + nan) != nan)
+        self.assertTrue((0 + nan) != nan)
 
     def test_floats(self):
         for num in [1617161771.7650001, math.pi, math.pi**100,
                     math.pi**-100, 3.1]:
-            self.assertEquals(float(json.dumps(num)), num)
-            self.assertEquals(json.loads(json.dumps(num)), num)
-            self.assertEquals(json.loads(text_type(json.dumps(num))), num)
+            self.assertEqual(float(json.dumps(num)), num)
+            self.assertEqual(json.loads(json.dumps(num)), num)
+            self.assertEqual(json.loads(text_type(json.dumps(num))), num)
 
     def test_ints(self):
         for num in [1, long_type(1), 1<<32, 1<<64]:
-            self.assertEquals(json.dumps(num), str(num))
-            self.assertEquals(int(json.dumps(num)), num)
-            self.assertEquals(json.loads(json.dumps(num)), num)
-            self.assertEquals(json.loads(text_type(json.dumps(num))), num)
+            self.assertEqual(json.dumps(num), str(num))
+            self.assertEqual(int(json.dumps(num)), num)
+            self.assertEqual(json.loads(json.dumps(num)), num)
+            self.assertEqual(json.loads(text_type(json.dumps(num))), num)
diff --git a/simplejson/tests/test_indent.py b/simplejson/tests/test_indent.py
index a397cca..cea25a5 100644
--- a/simplejson/tests/test_indent.py
+++ b/simplejson/tests/test_indent.py
@@ -42,26 +42,26 @@ class TestIndent(TestCase):
         h3 = json.loads(d3)
         h4 = json.loads(d4)
 
-        self.assertEquals(h1, h)
-        self.assertEquals(h2, h)
-        self.assertEquals(h3, h)
-        self.assertEquals(h4, h)
-        self.assertEquals(d3, expect.replace('\t', '  '))
-        self.assertEquals(d4, expect.replace('\t', '  '))
+        self.assertEqual(h1, h)
+        self.assertEqual(h2, h)
+        self.assertEqual(h3, h)
+        self.assertEqual(h4, h)
+        self.assertEqual(d3, expect.replace('\t', '  '))
+        self.assertEqual(d4, expect.replace('\t', '  '))
         # NOTE: Python 2.4 textwrap.dedent converts tabs to spaces,
         #       so the following is expected to fail. Python 2.4 is not a
         #       supported platform in simplejson 2.1.0+.
-        self.assertEquals(d2, expect)
+        self.assertEqual(d2, expect)
 
     def test_indent0(self):
         h = {3: 1}
         def check(indent, expected):
             d1 = json.dumps(h, indent=indent)
-            self.assertEquals(d1, expected)
+            self.assertEqual(d1, expected)
 
             sio = StringIO()
             json.dump(h, sio, indent=indent)
-            self.assertEquals(sio.getvalue(), expected)
+            self.assertEqual(sio.getvalue(), expected)
 
         # indent=0 should emit newlines
         check(0, '{\n"3": 1\n}')
@@ -73,14 +73,14 @@ class TestIndent(TestCase):
         expect = '[\n1,\n2,\n3,\n4\n]'
         expect_spaces = '[\n1, \n2, \n3, \n4\n]'
         # Ensure that separators still works
-        self.assertEquals(
+        self.assertEqual(
             expect_spaces,
             json.dumps(lst, indent=0, separators=(', ', ': ')))
         # Force the new defaults
-        self.assertEquals(
+        self.assertEqual(
             expect,
             json.dumps(lst, indent=0, separators=(',', ': ')))
         # Added in 2.1.4
-        self.assertEquals(
+        self.assertEqual(
             expect,
             json.dumps(lst, indent=0))
diff --git a/simplejson/tests/test_item_sort_key.py b/simplejson/tests/test_item_sort_key.py
index 83bea1e..b05bfc8 100644
--- a/simplejson/tests/test_item_sort_key.py
+++ b/simplejson/tests/test_item_sort_key.py
@@ -6,15 +6,15 @@ from operator import itemgetter
 class TestItemSortKey(TestCase):
     def test_simple_first(self):
         a = {'a': 1, 'c': 5, 'jack': 'jill', 'pick': 'axe', 'array': [1, 5, 6, 9], 'tuple': (83, 12, 3), 'crate': 'dog', 'zeak': 'oh'}
-        self.assertEquals(
+        self.assertEqual(
             '{"a": 1, "c": 5, "crate": "dog", "jack": "jill", "pick": "axe", "zeak": "oh", "array": [1, 5, 6, 9], "tuple": [83, 12, 3]}',
             json.dumps(a, item_sort_key=json.simple_first))
 
     def test_case(self):
         a = {'a': 1, 'c': 5, 'Jack': 'jill', 'pick': 'axe', 'Array': [1, 5, 6, 9], 'tuple': (83, 12, 3), 'crate': 'dog', 'zeak': 'oh'}
-        self.assertEquals(
+        self.assertEqual(
             '{"Array": [1, 5, 6, 9], "Jack": "jill", "a": 1, "c": 5, "crate": "dog", "pick": "axe", "tuple": [83, 12, 3], "zeak": "oh"}',
             json.dumps(a, item_sort_key=itemgetter(0)))
-        self.assertEquals(
+        self.assertEqual(
             '{"a": 1, "Array": [1, 5, 6, 9], "c": 5, "crate": "dog", "Jack": "jill", "pick": "axe", "tuple": [83, 12, 3], "zeak": "oh"}',
             json.dumps(a, item_sort_key=lambda kv: kv[0].lower()))
diff --git a/simplejson/tests/test_pass1.py b/simplejson/tests/test_pass1.py
index c3d6302..b5e0588 100644
--- a/simplejson/tests/test_pass1.py
+++ b/simplejson/tests/test_pass1.py
@@ -67,7 +67,7 @@ class TestPass1(TestCase):
         # test in/out equivalence and parsing
         res = json.loads(JSON)
         out = json.dumps(res)
-        self.assertEquals(res, json.loads(out))
+        self.assertEqual(res, json.loads(out))
         try:
             json.dumps(res, allow_nan=False)
         except ValueError:
diff --git a/simplejson/tests/test_pass2.py b/simplejson/tests/test_pass2.py
index de4ee00..5d812b3 100644
--- a/simplejson/tests/test_pass2.py
+++ b/simplejson/tests/test_pass2.py
@@ -11,4 +11,4 @@ class TestPass2(TestCase):
         # test in/out equivalence and parsing
         res = json.loads(JSON)
         out = json.dumps(res)
-        self.assertEquals(res, json.loads(out))
+        self.assertEqual(res, json.loads(out))
diff --git a/simplejson/tests/test_pass3.py b/simplejson/tests/test_pass3.py
index f591aba..821d60b 100644
--- a/simplejson/tests/test_pass3.py
+++ b/simplejson/tests/test_pass3.py
@@ -17,4 +17,4 @@ class TestPass3(TestCase):
         # test in/out equivalence and parsing
         res = json.loads(JSON)
         out = json.dumps(res)
-        self.assertEquals(res, json.loads(out))
+        self.assertEqual(res, json.loads(out))
diff --git a/simplejson/tests/test_recursion.py b/simplejson/tests/test_recursion.py
index 83a1d88..662eb66 100644
--- a/simplejson/tests/test_recursion.py
+++ b/simplejson/tests/test_recursion.py
@@ -57,7 +57,7 @@ class TestRecursion(TestCase):
 
     def test_defaultrecursion(self):
         enc = RecursiveJSONEncoder()
-        self.assertEquals(enc.encode(JSONTestObject), '"JSONTestObject"')
+        self.assertEqual(enc.encode(JSONTestObject), '"JSONTestObject"')
         enc.recurse = True
         try:
             enc.encode(JSONTestObject)
diff --git a/simplejson/tests/test_scanstring.py b/simplejson/tests/test_scanstring.py
index 045725a..3b63d6b 100644
--- a/simplejson/tests/test_scanstring.py
+++ b/simplejson/tests/test_scanstring.py
@@ -23,97 +23,97 @@ class TestScanString(TestCase):
         self._test_scanstring(simplejson.decoder.c_scanstring)
 
     def _test_scanstring(self, scanstring):
-        self.assertEquals(
+        self.assertEqual(
             scanstring('"z\\ud834\\udd20x"', 1, None, True),
             (u'z\U0001d120x', 16))
 
         if sys.maxunicode == 65535:
-            self.assertEquals(
+            self.assertEqual(
                 scanstring(u'"z\U0001d120x"', 1, None, True),
                 (u'z\U0001d120x', 6))
         else:
-            self.assertEquals(
+            self.assertEqual(
                 scanstring(u'"z\U0001d120x"', 1, None, True),
                 (u'z\U0001d120x', 5))
 
-        self.assertEquals(
+        self.assertEqual(
             scanstring('"\\u007b"', 1, None, True),
             (u'{', 8))
 
-        self.assertEquals(
+        self.assertEqual(
             scanstring('"A JSON payload should be an object or array, not a string."', 1, None, True),
             (u'A JSON payload should be an object or array, not a string.', 60))
 
-        self.assertEquals(
+        self.assertEqual(
             scanstring('["Unclosed array"', 2, None, True),
             (u'Unclosed array', 17))
 
-        self.assertEquals(
+        self.assertEqual(
             scanstring('["extra comma",]', 2, None, True),
             (u'extra comma', 14))
 
-        self.assertEquals(
+        self.assertEqual(
             scanstring('["double extra comma",,]', 2, None, True),
             (u'double extra comma', 21))
 
-        self.assertEquals(
+        self.assertEqual(
             scanstring('["Comma after the close"],', 2, None, True),
             (u'Comma after the close', 24))
 
-        self.assertEquals(
+        self.assertEqual(
             scanstring('["Extra close"]]', 2, None, True),
             (u'Extra close', 14))
 
-        self.assertEquals(
+        self.assertEqual(
             scanstring('{"Extra comma": true,}', 2, None, True),
             (u'Extra comma', 14))
 
-        self.assertEquals(
+        self.assertEqual(
             scanstring('{"Extra value after close": true} "misplaced quoted value"', 2, None, True),
             (u'Extra value after close', 26))
 
-        self.assertEquals(
+        self.assertEqual(
             scanstring('{"Illegal expression": 1 + 2}', 2, None, True),
             (u'Illegal expression', 21))
 
-        self.assertEquals(
+        self.assertEqual(
             scanstring('{"Illegal invocation": alert()}', 2, None, True),
             (u'Illegal invocation', 21))
 
-        self.assertEquals(
+        self.assertEqual(
             scanstring('{"Numbers cannot have leading zeroes": 013}', 2, None, True),
             (u'Numbers cannot have leading zeroes', 37))
 
-        self.assertEquals(
+        self.assertEqual(
             scanstring('{"Numbers cannot be hex": 0x14}', 2, None, True),
             (u'Numbers cannot be hex', 24))
 
-        self.assertEquals(
+        self.assertEqual(
             scanstring('[[[[[[[[[[[[[[[[[[[["Too deep"]]]]]]]]]]]]]]]]]]]]', 21, None, True),
             (u'Too deep', 30))
 
-        self.assertEquals(
+        self.assertEqual(
             scanstring('{"Missing colon" null}', 2, None, True),
             (u'Missing colon', 16))
 
-        self.assertEquals(
+        self.assertEqual(
             scanstring('{"Double colon":: null}', 2, None, True),
             (u'Double colon', 15))
 
-        self.assertEquals(
+        self.assertEqual(
             scanstring('{"Comma instead of colon", null}', 2, None, True),
             (u'Comma instead of colon', 25))
 
-        self.assertEquals(
+        self.assertEqual(
             scanstring('["Colon instead of comma": false]', 2, None, True),
             (u'Colon instead of comma', 25))
 
-        self.assertEquals(
+        self.assertEqual(
             scanstring('["Bad value", truth]', 2, None, True),
             (u'Bad value', 12))
 
         for c in map(chr, range(0x00, 0x1f)):
-            self.assertEquals(
+            self.assertEqual(
                 scanstring(c + '"', 0, None, False),
                 (c, 2))
             self.assertRaises(
diff --git a/simplejson/tests/test_separators.py b/simplejson/tests/test_separators.py
index cbda93c..91b4d4f 100644
--- a/simplejson/tests/test_separators.py
+++ b/simplejson/tests/test_separators.py
@@ -37,6 +37,6 @@ class TestSeparators(TestCase):
         h1 = json.loads(d1)
         h2 = json.loads(d2)
 
-        self.assertEquals(h1, h)
-        self.assertEquals(h2, h)
-        self.assertEquals(d2, expect)
+        self.assertEqual(h1, h)
+        self.assertEqual(h2, h)
+        self.assertEqual(d2, expect)
diff --git a/simplejson/tests/test_unicode.py b/simplejson/tests/test_unicode.py
index 9afc3ac..bade96c 100644
--- a/simplejson/tests/test_unicode.py
+++ b/simplejson/tests/test_unicode.py
@@ -11,51 +11,51 @@ class TestUnicode(TestCase):
         s = u.encode('utf-8')
         ju = encoder.encode(u)
         js = encoder.encode(s)
-        self.assertEquals(ju, js)
+        self.assertEqual(ju, js)
 
     def test_encoding2(self):
         u = u'\N{GREEK SMALL LETTER ALPHA}\N{GREEK CAPITAL LETTER OMEGA}'
         s = u.encode('utf-8')
         ju = json.dumps(u, encoding='utf-8')
         js = json.dumps(s, encoding='utf-8')
-        self.assertEquals(ju, js)
+        self.assertEqual(ju, js)
 
     def test_encoding3(self):
         u = u'\N{GREEK SMALL LETTER ALPHA}\N{GREEK CAPITAL LETTER OMEGA}'
         j = json.dumps(u)
-        self.assertEquals(j, '"\\u03b1\\u03a9"')
+        self.assertEqual(j, '"\\u03b1\\u03a9"')
 
     def test_encoding4(self):
         u = u'\N{GREEK SMALL LETTER ALPHA}\N{GREEK CAPITAL LETTER OMEGA}'
         j = json.dumps([u])
-        self.assertEquals(j, '["\\u03b1\\u03a9"]')
+        self.assertEqual(j, '["\\u03b1\\u03a9"]')
 
     def test_encoding5(self):
         u = u'\N{GREEK SMALL LETTER ALPHA}\N{GREEK CAPITAL LETTER OMEGA}'
         j = json.dumps(u, ensure_ascii=False)
-        self.assertEquals(j, u'"' + u + u'"')
+        self.assertEqual(j, u'"' + u + u'"')
 
     def test_encoding6(self):
         u = u'\N{GREEK SMALL LETTER ALPHA}\N{GREEK CAPITAL LETTER OMEGA}'
         j = json.dumps([u], ensure_ascii=False)
-        self.assertEquals(j, u'["' + u + u'"]')
+        self.assertEqual(j, u'["' + u + u'"]')
 
     def test_big_unicode_encode(self):
         u = u'\U0001d120'
-        self.assertEquals(json.dumps(u), '"\\ud834\\udd20"')
-        self.assertEquals(json.dumps(u, ensure_ascii=False), u'"\U0001d120"')
+        self.assertEqual(json.dumps(u), '"\\ud834\\udd20"')
+        self.assertEqual(json.dumps(u, ensure_ascii=False), u'"\U0001d120"')
 
     def test_big_unicode_decode(self):
         u = u'z\U0001d120x'
-        self.assertEquals(json.loads('"' + u + '"'), u)
-        self.assertEquals(json.loads('"z\\ud834\\udd20x"'), u)
+        self.assertEqual(json.loads('"' + u + '"'), u)
+        self.assertEqual(json.loads('"z\\ud834\\udd20x"'), u)
 
     def test_unicode_decode(self):
         for i in range(0, 0xd7ff):
             u = unichr(i)
             #s = '"\\u{0:04x}"'.format(i)
             s = '"\\u%04x"' % (i,)
-            self.assertEquals(json.loads(s), u)
+            self.assertEqual(json.loads(s), u)
 
     def test_object_pairs_hook_with_unicode(self):
         s = u'{"xkd":1, "kcw":2, "art":3, "hxm":4, "qrt":5, "pad":6, "hoy":7}'
@@ -74,20 +74,20 @@ class TestUnicode(TestCase):
 
 
     def test_default_encoding(self):
-        self.assertEquals(json.loads(u'{"a": "\xe9"}'.encode('utf-8')),
+        self.assertEqual(json.loads(u'{"a": "\xe9"}'.encode('utf-8')),
             {'a': u'\xe9'})
 
     def test_unicode_preservation(self):
-        self.assertEquals(type(json.loads(u'""')), text_type)
-        self.assertEquals(type(json.loads(u'"a"')), text_type)
-        self.assertEquals(type(json.loads(u'["a"]')[0]), text_type)
+        self.assertEqual(type(json.loads(u'""')), text_type)
+        self.assertEqual(type(json.loads(u'"a"')), text_type)
+        self.assertEqual(type(json.loads(u'["a"]')[0]), text_type)
 
     def test_ensure_ascii_false_returns_unicode(self):
         # http://code.google.com/p/simplejson/issues/detail?id=48
-        self.assertEquals(type(json.dumps([], ensure_ascii=False)), text_type)
-        self.assertEquals(type(json.dumps(0, ensure_ascii=False)), text_type)
-        self.assertEquals(type(json.dumps({}, ensure_ascii=False)), text_type)
-        self.assertEquals(type(json.dumps("", ensure_ascii=False)), text_type)
+        self.assertEqual(type(json.dumps([], ensure_ascii=False)), text_type)
+        self.assertEqual(type(json.dumps(0, ensure_ascii=False)), text_type)
+        self.assertEqual(type(json.dumps({}, ensure_ascii=False)), text_type)
+        self.assertEqual(type(json.dumps("", ensure_ascii=False)), text_type)
 
     def test_ensure_ascii_false_bytestring_encoding(self):
         # http://code.google.com/p/simplejson/issues/detail?id=48
@@ -95,20 +95,20 @@ class TestUnicode(TestCase):
         doc2 = {u'quux': u('Arr\xeat sur images')}
         doc_ascii = '{"quux": "Arr\\u00eat sur images"}'
         doc_unicode = u'{"quux": "Arr\xeat sur images"}'
-        self.assertEquals(json.dumps(doc1), doc_ascii)
-        self.assertEquals(json.dumps(doc2), doc_ascii)
-        self.assertEquals(json.dumps(doc1, ensure_ascii=False), doc_unicode)
-        self.assertEquals(json.dumps(doc2, ensure_ascii=False), doc_unicode)
+        self.assertEqual(json.dumps(doc1), doc_ascii)
+        self.assertEqual(json.dumps(doc2), doc_ascii)
+        self.assertEqual(json.dumps(doc1, ensure_ascii=False), doc_unicode)
+        self.assertEqual(json.dumps(doc2, ensure_ascii=False), doc_unicode)
 
     def test_ensure_ascii_linebreak_encoding(self):
         # http://timelessrepo.com/json-isnt-a-javascript-subset
         s1 = u'\u2029\u2028'
         s2 = s1.encode('utf8')
         expect = '"\\u2029\\u2028"'
-        self.assertEquals(json.dumps(s1), expect)
-        self.assertEquals(json.dumps(s2), expect)
-        self.assertEquals(json.dumps(s1, ensure_ascii=False), expect)
-        self.assertEquals(json.dumps(s2, ensure_ascii=False), expect)
+        self.assertEqual(json.dumps(s1), expect)
+        self.assertEqual(json.dumps(s2), expect)
+        self.assertEqual(json.dumps(s1, ensure_ascii=False), expect)
+        self.assertEqual(json.dumps(s2, ensure_ascii=False), expect)
 
     def test_invalid_escape_sequences(self):
         # incomplete escape sequence
diff --git a/simplejson/tool.py b/simplejson/tool.py
index 73370db..f00e592 100644
--- a/simplejson/tool.py
+++ b/simplejson/tool.py
@@ -29,8 +29,8 @@ def main():
         obj = json.load(infile,
                         object_pairs_hook=json.OrderedDict,
                         use_decimal=True)
-    except ValueError, e:
-        raise SystemExit(e)
+    except ValueError:
+        raise SystemExit(sys.exc_info()[1])
     json.dump(obj, outfile, sort_keys=True, indent='    ', use_decimal=True)
     outfile.write('\n')