# HG changeset patch
# User Bob Ippolito <bob@redivi.com>
# Date 1357241456 28800
# Thu Jan 03 11:30:56 2013 -0800
# Node ID 4682e9d80cbb53ba595086eb57d23a06cad062e9
# Parent 45b33ff64d5ebc53b3677f8274a9cb354c0ab507
bump to v3.0.5, fix deprecations in tests
diff --git a/.travis.yml b/.travis.yml
--- a/.travis.yml
+++ b/.travis.yml
@@ -7,4 +7,5 @@
- "pypy"
script:
- python setup.py build_ext -i
+ - python -m compileall -f .
- python setup.py test
diff --git a/CHANGES.txt b/CHANGES.txt
--- 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.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
--- a/conf.py
+++ b/conf.py
@@ -44,7 +44,7 @@
# 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
--- 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 @@
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 @@
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
--- a/simplejson/__init__.py
+++ b/simplejson/__init__.py
@@ -99,7 +99,7 @@
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
--- 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 @@
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 @@
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 @@
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
--- a/simplejson/tests/test_decimal.py
+++ b/simplejson/tests/test_decimal.py
@@ -11,27 +11,27 @@
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 @@
# 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
--- a/simplejson/tests/test_decode.py
+++ b/simplejson/tests/test_decode.py
@@ -14,19 +14,19 @@
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
--- a/simplejson/tests/test_default.py
+++ b/simplejson/tests/test_default.py
@@ -4,6 +4,6 @@
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
--- a/simplejson/tests/test_dump.py
+++ b/simplejson/tests/test_dump.py
@@ -11,13 +11,13 @@
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 @@
(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 @@
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
--- a/simplejson/tests/test_encode_basestring_ascii.py
+++ b/simplejson/tests/test_encode_basestring_ascii.py
@@ -35,10 +35,10 @@
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
--- a/simplejson/tests/test_errors.py
+++ b/simplejson/tests/test_errors.py
@@ -17,10 +17,10 @@
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 @@
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
--- a/simplejson/tests/test_fail.py
+++ b/simplejson/tests/test_fail.py
@@ -109,9 +109,9 @@
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
--- a/simplejson/tests/test_float.py
+++ b/simplejson/tests/test_float.py
@@ -7,21 +7,21 @@
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
--- a/simplejson/tests/test_indent.py
+++ b/simplejson/tests/test_indent.py
@@ -42,26 +42,26 @@
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 @@
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
--- a/simplejson/tests/test_item_sort_key.py
+++ b/simplejson/tests/test_item_sort_key.py
@@ -6,15 +6,15 @@
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
--- a/simplejson/tests/test_pass1.py
+++ b/simplejson/tests/test_pass1.py
@@ -67,7 +67,7 @@
# 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
--- a/simplejson/tests/test_pass2.py
+++ b/simplejson/tests/test_pass2.py
@@ -11,4 +11,4 @@
# 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
--- a/simplejson/tests/test_pass3.py
+++ b/simplejson/tests/test_pass3.py
@@ -17,4 +17,4 @@
# 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
--- a/simplejson/tests/test_recursion.py
+++ b/simplejson/tests/test_recursion.py
@@ -57,7 +57,7 @@
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
--- a/simplejson/tests/test_scanstring.py
+++ b/simplejson/tests/test_scanstring.py
@@ -23,97 +23,97 @@
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
--- a/simplejson/tests/test_separators.py
+++ b/simplejson/tests/test_separators.py
@@ -37,6 +37,6 @@
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
--- a/simplejson/tests/test_unicode.py
+++ b/simplejson/tests/test_unicode.py
@@ -11,51 +11,51 @@
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 @@
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 @@
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
--- a/simplejson/tool.py
+++ b/simplejson/tool.py
@@ -29,8 +29,8 @@
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')