diff -r 0d9837985725 Lib/json/decoder.py --- a/Lib/json/decoder.py Wed May 11 14:02:13 2011 -0400 +++ b/Lib/json/decoder.py Thu May 12 08:41:11 2011 +0300 @@ -5,7 +5,7 @@ import sys import struct -from json.scanner import make_scanner +from json import scanner try: from _json import scanstring as c_scanstring except ImportError: @@ -340,7 +340,7 @@ self.parse_array = JSONArray self.parse_string = scanstring self.memo = {} - self.scan_once = make_scanner(self) + self.scan_once = scanner.make_scanner(self) def decode(self, s, _w=WHITESPACE.match): diff -r 0d9837985725 Lib/test/json_tests/__init__.py --- a/Lib/test/json_tests/__init__.py Wed May 11 14:02:13 2011 -0400 +++ b/Lib/test/json_tests/__init__.py Thu May 12 08:41:11 2011 +0300 @@ -1,7 +1,44 @@ import os import sys +import json +import doctest import unittest -import doctest + +from test import support + +# import json with and without accelerations and let the other test modules +# use these +cjson = support.import_fresh_module('json', fresh=['_json']) +pyjson = support.import_fresh_module('json', blocked=['_json']) + + +if cjson is None: + # create a decorator to skip C tests if cjson is None + def skip_unless_cjson(cls): + cls.__unittest_skip__ = True + cls.__unittest_skip_why__ = 'requires _json' + return cls +else: + # no-op if we have cjson + def skip_unless_cjson(cls): + return cls + +# make sure all this works +class TestModules(unittest.TestCase): + def test_pyjson(self): + self.assertEqual(pyjson.scanner.make_scanner.__module__, 'json.scanner') + self.assertEqual(pyjson.decoder.scanstring.__module__, 'json.decoder') + self.assertEqual(pyjson.encoder.encode_basestring_ascii.__module__, + 'json.encoder') + + @skip_unless_cjson + def test_cjson(self): + self.assertEqual(cjson.scanner.make_scanner.__module__, '_json') + self.assertEqual(cjson.decoder.scanstring.__module__, '_json') + self.assertEqual(cjson.encoder.c_make_encoder.__module__, '_json') + self.assertEqual(cjson.encoder.encode_basestring_ascii.__module__, + '_json') + here = os.path.dirname(__file__) @@ -17,12 +54,11 @@ return suite def additional_tests(): - import json - import json.encoder - import json.decoder suite = unittest.TestSuite() for mod in (json, json.encoder, json.decoder): suite.addTest(doctest.DocTestSuite(mod)) + suite.addTest(TestModules('test_pyjson')) + suite.addTest(TestModules('test_cjson')) return suite def main(): diff -r 0d9837985725 Lib/test/json_tests/test_decode.py --- a/Lib/test/json_tests/test_decode.py Wed May 11 14:02:13 2011 -0400 +++ b/Lib/test/json_tests/test_decode.py Thu May 12 08:41:11 2011 +0300 @@ -1,63 +1,50 @@ import decimal +from io import StringIO from unittest import TestCase -from io import StringIO from contextlib import contextmanager +from collections import OrderedDict +from test.json_tests import pyjson, cjson, skip_unless_cjson -import json -import json.decoder -import json.scanner -from collections import OrderedDict +class TestPyDecode(TestCase): + mod = pyjson -@contextmanager -def use_python_scanner(): - py_scanner = json.scanner.py_make_scanner - old_scanner = json.decoder.make_scanner - json.decoder.make_scanner = py_scanner - try: - yield - finally: - json.decoder.make_scanner = old_scanner - - -class TestDecode(TestCase): def test_decimal(self): - rval = json.loads('1.1', parse_float=decimal.Decimal) + rval = self.mod.loads('1.1', parse_float=decimal.Decimal) self.assertTrue(isinstance(rval, decimal.Decimal)) self.assertEqual(rval, decimal.Decimal('1.1')) def test_float(self): - rval = json.loads('1', parse_int=float) + rval = self.mod.loads('1', parse_int=float) self.assertTrue(isinstance(rval, float)) self.assertEqual(rval, 1.0) def test_empty_objects(self): - self.assertEqual(json.loads('{}'), {}) - self.assertEqual(json.loads('[]'), []) - self.assertEqual(json.loads('""'), "") + self.assertEqual(self.mod.loads('{}'), {}) + self.assertEqual(self.mod.loads('[]'), []) + self.assertEqual(self.mod.loads('""'), "") def test_object_pairs_hook(self): s = '{"xkd":1, "kcw":2, "art":3, "hxm":4, "qrt":5, "pad":6, "hoy":7}' p = [("xkd", 1), ("kcw", 2), ("art", 3), ("hxm", 4), ("qrt", 5), ("pad", 6), ("hoy", 7)] - self.assertEqual(json.loads(s), eval(s)) - self.assertEqual(json.loads(s, object_pairs_hook = lambda x: x), p) - self.assertEqual(json.load(StringIO(s), - object_pairs_hook=lambda x: x), p) - od = json.loads(s, object_pairs_hook = OrderedDict) + self.assertEqual(self.mod.loads(s), eval(s)) + self.assertEqual(self.mod.loads(s, object_pairs_hook = lambda x: x), p) + self.assertEqual(self.mod.load(StringIO(s), + object_pairs_hook=lambda x: x), p) + od = self.mod.loads(s, object_pairs_hook = OrderedDict) self.assertEqual(od, OrderedDict(p)) self.assertEqual(type(od), OrderedDict) # the object_pairs_hook takes priority over the object_hook - self.assertEqual(json.loads(s, - object_pairs_hook = OrderedDict, - object_hook = lambda x: None), + self.assertEqual(self.mod.loads(s, object_pairs_hook = OrderedDict, + object_hook = lambda x: None), OrderedDict(p)) 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" }') + rval = self.mod.loads('{ "key" : "value" , "k":"v" }') self.assertEqual(rval, {"key":"value", "k":"v"}) def check_keys_reuse(self, source, loads): @@ -68,7 +55,10 @@ def test_keys_reuse(self): s = '[{"a_key": 1, "b_\xe9": 2}, {"a_key": 3, "b_\xe9": 4}]' - self.check_keys_reuse(s, json.loads) - # Disabled: the pure Python version of json simply doesn't work - with use_python_scanner(): - self.check_keys_reuse(s, json.decoder.JSONDecoder().decode) + self.check_keys_reuse(s, self.mod.loads) + self.check_keys_reuse(s, self.mod.decoder.JSONDecoder().decode) + + +@skip_unless_cjson +class TestCDecode(TestPyDecode): + mod = cjson diff -r 0d9837985725 Lib/test/json_tests/test_default.py --- a/Lib/test/json_tests/test_default.py Wed May 11 14:02:13 2011 -0400 +++ b/Lib/test/json_tests/test_default.py Thu May 12 08:41:11 2011 +0300 @@ -1,9 +1,14 @@ from unittest import TestCase +from test.json_tests import pyjson, cjson, skip_unless_cjson -import json +class TestPyDefault(TestCase): + mod = pyjson -class TestDefault(TestCase): def test_default(self): self.assertEqual( - json.dumps(type, default=repr), - json.dumps(repr(type))) + self.mod.dumps(type, default=repr), + self.mod.dumps(repr(type))) + +@skip_unless_cjson +class TestCDefault(TestPyDefault): + mod = cjson diff -r 0d9837985725 Lib/test/json_tests/test_dump.py --- a/Lib/test/json_tests/test_dump.py Wed May 11 14:02:13 2011 -0400 +++ b/Lib/test/json_tests/test_dump.py Thu May 12 08:41:11 2011 +0300 @@ -1,21 +1,27 @@ +from io import StringIO from unittest import TestCase -from io import StringIO +from test.json_tests import pyjson, cjson, skip_unless_cjson -import json -class TestDump(TestCase): +class TestPyDump(TestCase): + mod = pyjson + def test_dump(self): sio = StringIO() - json.dump({}, sio) + self.mod.dump({}, sio) self.assertEqual(sio.getvalue(), '{}') def test_dumps(self): - self.assertEqual(json.dumps({}), '{}') + self.assertEqual(self.mod.dumps({}), '{}') def test_encode_truefalse(self): - self.assertEqual(json.dumps( + self.assertEqual(self.mod.dumps( {True: False, False: True}, sort_keys=True), '{"false": true, "true": false}') - self.assertEqual(json.dumps( + self.assertEqual(self.mod.dumps( {2: 3.0, 4.0: 5, False: 1, 6: True}, sort_keys=True), '{"false": 1, "2": 3.0, "4.0": 5, "6": true}') + +@skip_unless_cjson +class TestCDump(TestPyDump): + mod = cjson diff -r 0d9837985725 Lib/test/json_tests/test_encode_basestring_ascii.py --- a/Lib/test/json_tests/test_encode_basestring_ascii.py Wed May 11 14:02:13 2011 -0400 +++ b/Lib/test/json_tests/test_encode_basestring_ascii.py Thu May 12 08:41:11 2011 +0300 @@ -1,8 +1,7 @@ from unittest import TestCase +from collections import OrderedDict +from test.json_tests import pyjson, cjson, skip_unless_cjson -import json.encoder -from json import dumps -from collections import OrderedDict CASES = [ ('/\\"\ucafe\ubabe\uab98\ufcde\ubcda\uef4a\x08\x0c\n\r\t`1~!@#$%^&*()_+-=[]{}|;:\',./<>?', '"/\\\\\\"\\ucafe\\ubabe\\uab98\\ufcde\\ubcda\\uef4a\\b\\f\\n\\r\\t`1~!@#$%^&*()_+-=[]{}|;:\',./<>?"'), @@ -21,19 +20,13 @@ ('\u0123\u4567\u89ab\ucdef\uabcd\uef4a', '"\\u0123\\u4567\\u89ab\\ucdef\\uabcd\\uef4a"'), ] -class TestEncodeBaseStringAscii(TestCase): - def test_py_encode_basestring_ascii(self): - self._test_encode_basestring_ascii(json.encoder.py_encode_basestring_ascii) +class TestPyEncodeBasestringAscii(TestCase): + mod = pyjson - def test_c_encode_basestring_ascii(self): - if not json.encoder.c_encode_basestring_ascii: - return - self._test_encode_basestring_ascii(json.encoder.c_encode_basestring_ascii) - - def _test_encode_basestring_ascii(self, encode_basestring_ascii): - fname = encode_basestring_ascii.__name__ + def test_encode_basestring_ascii(self): + fname = self.mod.encoder.encode_basestring_ascii.__name__ for input_string, expect in CASES: - result = encode_basestring_ascii(input_string) + result = self.mod.encoder.encode_basestring_ascii(input_string) self.assertEqual(result, expect, '{0!r} != {1!r} for {2}({3!r})'.format( result, expect, fname, input_string)) @@ -41,10 +34,15 @@ def test_ordered_dict(self): # See issue 6105 items = [('one', 1), ('two', 2), ('three', 3), ('four', 4), ('five', 5)] - s = json.dumps(OrderedDict(items)) + s = self.mod.dumps(OrderedDict(items)) self.assertEqual(s, '{"one": 1, "two": 2, "three": 3, "four": 4, "five": 5}') def test_sorted_dict(self): items = [('one', 1), ('two', 2), ('three', 3), ('four', 4), ('five', 5)] - s = json.dumps(dict(items), sort_keys=True) + s = self.mod.dumps(dict(items), sort_keys=True) self.assertEqual(s, '{"five": 5, "four": 4, "one": 1, "three": 3, "two": 2}') + + +@skip_unless_cjson +class TestCEncodeBasestringAscii(TestPyEncodeBasestringAscii): + mod = cjson diff -r 0d9837985725 Lib/test/json_tests/test_fail.py --- a/Lib/test/json_tests/test_fail.py Wed May 11 14:02:13 2011 -0400 +++ b/Lib/test/json_tests/test_fail.py Thu May 12 08:41:11 2011 +0300 @@ -1,6 +1,5 @@ from unittest import TestCase - -import json +from test.json_tests import pyjson, cjson, skip_unless_cjson # Fri Dec 30 18:57:26 2005 JSONDOCS = [ @@ -61,15 +60,17 @@ 18: "spec doesn't specify any nesting limitations", } -class TestFail(TestCase): +class TestPyFail(TestCase): + mod = pyjson + def test_failures(self): for idx, doc in enumerate(JSONDOCS): idx = idx + 1 if idx in SKIPS: - json.loads(doc) + self.mod.loads(doc) continue try: - json.loads(doc) + self.mod.loads(doc) except ValueError: pass else: @@ -79,7 +80,12 @@ data = {'a' : 1, (1, 2) : 2} #This is for c encoder - self.assertRaises(TypeError, json.dumps, data) + self.assertRaises(TypeError, self.mod.dumps, data) #This is for python encoder - self.assertRaises(TypeError, json.dumps, data, indent=True) + self.assertRaises(TypeError, self.mod.dumps, data, indent=True) + + +@skip_unless_cjson +class TestCFail(TestPyFail): + mod = cjson diff -r 0d9837985725 Lib/test/json_tests/test_float.py --- a/Lib/test/json_tests/test_float.py Wed May 11 14:02:13 2011 -0400 +++ b/Lib/test/json_tests/test_float.py Thu May 12 08:41:11 2011 +0300 @@ -1,15 +1,21 @@ import math from unittest import TestCase +from test.json_tests import pyjson, cjson, skip_unless_cjson -import json -class TestFloat(TestCase): +class TestPyFloat(TestCase): + mod = pyjson + def test_floats(self): for num in [1617161771.7650001, math.pi, math.pi**100, math.pi**-100, 3.1]: - self.assertEqual(float(json.dumps(num)), num) - self.assertEqual(json.loads(json.dumps(num)), num) + self.assertEqual(float(self.mod.dumps(num)), num) + self.assertEqual(self.mod.loads(self.mod.dumps(num)), num) def test_ints(self): for num in [1, 1<<32, 1<<64]: - self.assertEqual(json.dumps(num), str(num)) - self.assertEqual(int(json.dumps(num)), num) + self.assertEqual(self.mod.dumps(num), str(num)) + self.assertEqual(int(self.mod.dumps(num)), num) + +@skip_unless_cjson +class TestCFloat(TestPyFloat): + mod = cjson diff -r 0d9837985725 Lib/test/json_tests/test_indent.py --- a/Lib/test/json_tests/test_indent.py Wed May 11 14:02:13 2011 -0400 +++ b/Lib/test/json_tests/test_indent.py Thu May 12 08:41:11 2011 +0300 @@ -1,10 +1,12 @@ -from unittest import TestCase - -import json import textwrap from io import StringIO +from unittest import TestCase +from test.json_tests import pyjson, cjson, skip_unless_cjson -class TestIndent(TestCase): + +class TestPyIndent(TestCase): + mod = pyjson + def test_indent(self): h = [['blorpie'], ['whoops'], [], 'd-shtaeou', 'd-nthiouh', 'i-vhbjkhnth', {'nifty': 87}, {'field': 'yes', 'morefield': False} ] @@ -30,14 +32,15 @@ \t} ]""") + dumps = self.mod.dumps + d1 = dumps(h) + d2 = dumps(h, indent=2, sort_keys=True, separators=(',', ': ')) + d3 = dumps(h, indent='\t', sort_keys=True, separators=(',', ': ')) - d1 = json.dumps(h) - d2 = json.dumps(h, indent=2, sort_keys=True, separators=(',', ': ')) - d3 = json.dumps(h, indent='\t', sort_keys=True, separators=(',', ': ')) - - h1 = json.loads(d1) - h2 = json.loads(d2) - h3 = json.loads(d3) + loads = self.mod.loads + h1 = loads(d1) + h2 = loads(d2) + h3 = loads(d3) self.assertEqual(h1, h) self.assertEqual(h2, h) @@ -48,14 +51,19 @@ def test_indent0(self): h = {3: 1} def check(indent, expected): - d1 = json.dumps(h, indent=indent) + d1 = self.mod.dumps(h, indent=indent) self.assertEqual(d1, expected) sio = StringIO() - json.dump(h, sio, indent=indent) + self.mod.dump(h, sio, indent=indent) self.assertEqual(sio.getvalue(), expected) # indent=0 should emit newlines check(0, '{\n"3": 1\n}') # indent=None is more compact check(None, '{"3": 1}') + + +@skip_unless_cjson +class TestCIndent(TestPyIndent): + mod = cjson diff -r 0d9837985725 Lib/test/json_tests/test_pass1.py --- a/Lib/test/json_tests/test_pass1.py Wed May 11 14:02:13 2011 -0400 +++ b/Lib/test/json_tests/test_pass1.py Thu May 12 08:41:11 2011 +0300 @@ -1,6 +1,5 @@ from unittest import TestCase - -import json +from test.json_tests import pyjson, cjson, skip_unless_cjson # from http://json.org/JSON_checker/test/pass1.json JSON = r''' @@ -62,15 +61,21 @@ ,"rosebud"] ''' -class TestPass1(TestCase): +class TestPyPass1(TestCase): + mod = pyjson + def test_parse(self): # test in/out equivalence and parsing - res = json.loads(JSON) - out = json.dumps(res) - self.assertEqual(res, json.loads(out)) + res = self.mod.loads(JSON) + out = self.mod.dumps(res) + self.assertEqual(res, self.mod.loads(out)) try: - json.dumps(res, allow_nan=False) + self.mod.dumps(res, allow_nan=False) except ValueError: pass else: self.fail("23456789012E666 should be out of range") + +@skip_unless_cjson +class TestCPass1(TestPyPass1): + mod = cjson diff -r 0d9837985725 Lib/test/json_tests/test_pass2.py --- a/Lib/test/json_tests/test_pass2.py Wed May 11 14:02:13 2011 -0400 +++ b/Lib/test/json_tests/test_pass2.py Thu May 12 08:41:11 2011 +0300 @@ -1,14 +1,20 @@ from unittest import TestCase -import json +from test.json_tests import pyjson, cjson, skip_unless_cjson # from http://json.org/JSON_checker/test/pass2.json JSON = r''' [[[[[[[[[[[[[[[[[[["Not too deep"]]]]]]]]]]]]]]]]]]] ''' -class TestPass2(TestCase): +class TestPyPass2(TestCase): + mod = pyjson + def test_parse(self): # test in/out equivalence and parsing - res = json.loads(JSON) - out = json.dumps(res) - self.assertEqual(res, json.loads(out)) + res = self.mod.loads(JSON) + out = self.mod.dumps(res) + self.assertEqual(res, self.mod.loads(out)) + +@skip_unless_cjson +class TestCPass2(TestPyPass2): + mod = cjson diff -r 0d9837985725 Lib/test/json_tests/test_pass3.py --- a/Lib/test/json_tests/test_pass3.py Wed May 11 14:02:13 2011 -0400 +++ b/Lib/test/json_tests/test_pass3.py Thu May 12 08:41:11 2011 +0300 @@ -1,6 +1,5 @@ from unittest import TestCase - -import json +from test.json_tests import pyjson, cjson, skip_unless_cjson # from http://json.org/JSON_checker/test/pass3.json JSON = r''' @@ -12,9 +11,17 @@ } ''' -class TestPass3(TestCase): + +class TestPyPass3(TestCase): + mod = pyjson + def test_parse(self): # test in/out equivalence and parsing - res = json.loads(JSON) - out = json.dumps(res) - self.assertEqual(res, json.loads(out)) + res = self.mod.loads(JSON) + out = self.mod.dumps(res) + self.assertEqual(res, self.mod.loads(out)) + + +@skip_unless_cjson +class TestCPass3(TestPyPass3): + mod = cjson diff -r 0d9837985725 Lib/test/json_tests/test_recursion.py --- a/Lib/test/json_tests/test_recursion.py Wed May 11 14:02:13 2011 -0400 +++ b/Lib/test/json_tests/test_recursion.py Thu May 12 08:41:11 2011 +0300 @@ -1,12 +1,11 @@ from unittest import TestCase +from test.json_tests import pyjson, cjson, skip_unless_cjson -import json class JSONTestObject: pass - -class RecursiveJSONEncoder(json.JSONEncoder): +class RecursiveJSONEncoder(pyjson.JSONEncoder): recurse = False def default(self, o): if o is JSONTestObject: @@ -14,20 +13,22 @@ return [JSONTestObject] else: return 'JSONTestObject' - return json.JSONEncoder.default(o) + return pyjson.JSONEncoder.default(o) -class EndlessJSONEncoder(json.JSONEncoder): +class EndlessJSONEncoder(pyjson.JSONEncoder): def default(self, o): """If check_circular is False, this will keep adding another list.""" return [o] -class TestRecursion(TestCase): +class TestPyRecursion(TestCase): + mod = pyjson + def test_listrecursion(self): x = [] x.append(x) try: - json.dumps(x) + self.mod.dumps(x) except ValueError: pass else: @@ -36,7 +37,7 @@ y = [x] x.append(y) try: - json.dumps(x) + self.mod.dumps(x) except ValueError: pass else: @@ -44,13 +45,13 @@ y = [] x = [y, y] # ensure that the marker is cleared - json.dumps(x) + self.mod.dumps(x) def test_dictrecursion(self): x = {} x["test"] = x try: - json.dumps(x) + self.mod.dumps(x) except ValueError: pass else: @@ -58,7 +59,7 @@ x = {} y = {"a": x, "b": x} # ensure that the marker is cleared - json.dumps(x) + self.mod.dumps(x) def test_defaultrecursion(self): enc = RecursiveJSONEncoder() @@ -76,11 +77,11 @@ # test that loading highly-nested objects doesn't segfault when C # accelerations are used. See #12017 with self.assertRaises(RuntimeError): - json.loads('{"a":' * 100000 + '1' + '}' * 100000) + self.mod.loads('{"a":' * 100000 + '1' + '}' * 100000) with self.assertRaises(RuntimeError): - json.loads('{"a":' * 100000 + '[1]' + '}' * 100000) + self.mod.loads('{"a":' * 100000 + '[1]' + '}' * 100000) with self.assertRaises(RuntimeError): - json.loads('[' * 100000 + '1' + ']' * 100000) + self.mod.loads('[' * 100000 + '1' + ']' * 100000) def test_highly_nested_objects_encoding(self): # See #12051 @@ -88,11 +89,16 @@ for x in range(100000): l, d = [l], {'k':d} with self.assertRaises(RuntimeError): - json.dumps(l) + self.mod.dumps(l) with self.assertRaises(RuntimeError): - json.dumps(d) + self.mod.dumps(d) def test_endless_recursion(self): # See #12051 with self.assertRaises(RuntimeError): EndlessJSONEncoder(check_circular=False).encode(5j) + + +@skip_unless_cjson +class TestCRecursion(TestPyRecursion): + mod = cjson diff -r 0d9837985725 Lib/test/json_tests/test_scanstring.py --- a/Lib/test/json_tests/test_scanstring.py Wed May 11 14:02:13 2011 -0400 +++ b/Lib/test/json_tests/test_scanstring.py Thu May 12 08:41:11 2011 +0300 @@ -1,24 +1,13 @@ import sys -from unittest import TestCase, skipUnless +from unittest import TestCase +from test.json_tests import pyjson, cjson, skip_unless_cjson -import json -import json.decoder -try: - import _json -except ImportError: - _json = None +class TestPyScanstring(TestCase): + mod = pyjson -class TestScanString(TestCase): - def test_py_scanstring(self): - self._test_scanstring(json.decoder.py_scanstring) - - @skipUnless(_json, 'test requires the _json module') - def test_c_scanstring(self): - if json.decoder.c_scanstring is not None: - self._test_scanstring(json.decoder.c_scanstring) - - def _test_scanstring(self, scanstring): + def test_scanstring(self): + scanstring = self.mod.decoder.scanstring self.assertEqual( scanstring('"z\\ud834\\udd20x"', 1, True), ('z\U0001d120x', 16)) @@ -109,4 +98,10 @@ ('Bad value', 12)) def test_overflow(self): - self.assertRaises(OverflowError, json.decoder.scanstring, b"xxx", sys.maxsize+1) + with self.assertRaises(OverflowError): + self.mod.decoder.scanstring(b"xxx", sys.maxsize+1) + + +@skip_unless_cjson +class TestCScanstring(TestPyScanstring): + mod = cjson diff -r 0d9837985725 Lib/test/json_tests/test_separators.py --- a/Lib/test/json_tests/test_separators.py Wed May 11 14:02:13 2011 -0400 +++ b/Lib/test/json_tests/test_separators.py Thu May 12 08:41:11 2011 +0300 @@ -1,10 +1,11 @@ import textwrap from unittest import TestCase +from test.json_tests import pyjson, cjson, skip_unless_cjson -import json +class TestPySeparators(TestCase): + mod = pyjson -class TestSeparators(TestCase): def test_separators(self): h = [['blorpie'], ['whoops'], [], 'd-shtaeou', 'd-nthiouh', 'i-vhbjkhnth', {'nifty': 87}, {'field': 'yes', 'morefield': False} ] @@ -31,12 +32,17 @@ ]""") - d1 = json.dumps(h) - d2 = json.dumps(h, indent=2, sort_keys=True, separators=(' ,', ' : ')) + d1 = self.mod.dumps(h) + d2 = self.mod.dumps(h, indent=2, sort_keys=True, separators=(' ,', ' : ')) - h1 = json.loads(d1) - h2 = json.loads(d2) + h1 = self.mod.loads(d1) + h2 = self.mod.loads(d2) self.assertEqual(h1, h) self.assertEqual(h2, h) self.assertEqual(d2, expect) + + +@skip_unless_cjson +class TestCSeparators(TestPySeparators): + mod = cjson diff -r 0d9837985725 Lib/test/json_tests/test_speedups.py --- a/Lib/test/json_tests/test_speedups.py Wed May 11 14:02:13 2011 -0400 +++ b/Lib/test/json_tests/test_speedups.py Thu May 12 08:41:11 2011 +0300 @@ -1,29 +1,26 @@ -from unittest import TestCase, skipUnless +from unittest import TestCase +from test.json_tests import cjson, skip_unless_cjson -from json import decoder, encoder, scanner -try: - import _json -except ImportError: - _json = None - -@skipUnless(_json, 'test requires the _json module') +@skip_unless_cjson class TestSpeedups(TestCase): def test_scanstring(self): - self.assertEqual(decoder.scanstring.__module__, "_json") - self.assertIs(decoder.scanstring, decoder.c_scanstring) + self.assertEqual(cjson.decoder.scanstring.__module__, "_json") + self.assertIs(cjson.decoder.scanstring, cjson.decoder.c_scanstring) def test_encode_basestring_ascii(self): - self.assertEqual(encoder.encode_basestring_ascii.__module__, "_json") - self.assertIs(encoder.encode_basestring_ascii, - encoder.c_encode_basestring_ascii) + self.assertEqual(cjson.encoder.encode_basestring_ascii.__module__, + "_json") + self.assertIs(cjson.encoder.encode_basestring_ascii, + cjson.encoder.c_encode_basestring_ascii) +@skip_unless_cjson class TestDecode(TestCase): def test_make_scanner(self): - self.assertRaises(AttributeError, scanner.c_make_scanner, 1) + self.assertRaises(AttributeError, cjson.scanner.c_make_scanner, 1) def test_make_encoder(self): - self.assertRaises(TypeError, encoder.c_make_encoder, + self.assertRaises(TypeError, cjson.encoder.c_make_encoder, (True, False), b"\xCD\x7D\x3D\x4E\x12\x4C\xF9\x79\xD7\x52\xBA\x82\xF2\x27\x4A\x7D\xA0\xCA\x75", None) diff -r 0d9837985725 Lib/test/json_tests/test_unicode.py --- a/Lib/test/json_tests/test_unicode.py Wed May 11 14:02:13 2011 -0400 +++ b/Lib/test/json_tests/test_unicode.py Thu May 12 08:41:11 2011 +0300 @@ -1,73 +1,77 @@ from unittest import TestCase +from collections import OrderedDict +from test.json_tests import pyjson, cjson, skip_unless_cjson -import json -from collections import OrderedDict -class TestUnicode(TestCase): +class TestPyUnicode(TestCase): # test_encoding1 and test_encoding2 from 2.x are irrelevant (only str # is supported as input, not bytes). + mod = pyjson def test_encoding3(self): u = '\N{GREEK SMALL LETTER ALPHA}\N{GREEK CAPITAL LETTER OMEGA}' - j = json.dumps(u) + j = self.mod.dumps(u) self.assertEqual(j, '"\\u03b1\\u03a9"') def test_encoding4(self): u = '\N{GREEK SMALL LETTER ALPHA}\N{GREEK CAPITAL LETTER OMEGA}' - j = json.dumps([u]) + j = self.mod.dumps([u]) self.assertEqual(j, '["\\u03b1\\u03a9"]') def test_encoding5(self): u = '\N{GREEK SMALL LETTER ALPHA}\N{GREEK CAPITAL LETTER OMEGA}' - j = json.dumps(u, ensure_ascii=False) + j = self.mod.dumps(u, ensure_ascii=False) self.assertEqual(j, '"{0}"'.format(u)) def test_encoding6(self): u = '\N{GREEK SMALL LETTER ALPHA}\N{GREEK CAPITAL LETTER OMEGA}' - j = json.dumps([u], ensure_ascii=False) + j = self.mod.dumps([u], ensure_ascii=False) self.assertEqual(j, '["{0}"]'.format(u)) def test_big_unicode_encode(self): u = '\U0001d120' - self.assertEqual(json.dumps(u), '"\\ud834\\udd20"') - self.assertEqual(json.dumps(u, ensure_ascii=False), '"\U0001d120"') + self.assertEqual(self.mod.dumps(u), '"\\ud834\\udd20"') + self.assertEqual(self.mod.dumps(u, ensure_ascii=False), '"\U0001d120"') def test_big_unicode_decode(self): u = 'z\U0001d120x' - self.assertEqual(json.loads('"' + u + '"'), u) - self.assertEqual(json.loads('"z\\ud834\\udd20x"'), u) + self.assertEqual(self.mod.loads('"' + u + '"'), u) + self.assertEqual(self.mod.loads('"z\\ud834\\udd20x"'), u) def test_unicode_decode(self): for i in range(0, 0xd7ff): u = chr(i) s = '"\\u{0:04x}"'.format(i) - self.assertEqual(json.loads(s), u) + self.assertEqual(self.mod.loads(s), u) def test_unicode_preservation(self): - self.assertEqual(type(json.loads('""')), str) - self.assertEqual(type(json.loads('"a"')), str) - self.assertEqual(type(json.loads('["a"]')[0]), str) + self.assertEqual(type(self.mod.loads('""')), str) + self.assertEqual(type(self.mod.loads('"a"')), str) + self.assertEqual(type(self.mod.loads('["a"]')[0]), str) def test_bytes_encode(self): - self.assertRaises(TypeError, json.dumps, b"hi") - self.assertRaises(TypeError, json.dumps, [b"hi"]) + self.assertRaises(TypeError, self.mod.dumps, b"hi") + self.assertRaises(TypeError, self.mod.dumps, [b"hi"]) def test_bytes_decode(self): - self.assertRaises(TypeError, json.loads, b'"hi"') - self.assertRaises(TypeError, json.loads, b'["hi"]') + self.assertRaises(TypeError, self.mod.loads, b'"hi"') + self.assertRaises(TypeError, self.mod.loads, b'["hi"]') def test_object_pairs_hook_with_unicode(self): s = '{"xkd":1, "kcw":2, "art":3, "hxm":4, "qrt":5, "pad":6, "hoy":7}' p = [("xkd", 1), ("kcw", 2), ("art", 3), ("hxm", 4), ("qrt", 5), ("pad", 6), ("hoy", 7)] - self.assertEqual(json.loads(s), eval(s)) - self.assertEqual(json.loads(s, object_pairs_hook = lambda x: x), p) - od = json.loads(s, object_pairs_hook = OrderedDict) + self.assertEqual(self.mod.loads(s), eval(s)) + self.assertEqual(self.mod.loads(s, object_pairs_hook = lambda x: x), p) + od = self.mod.loads(s, object_pairs_hook = OrderedDict) self.assertEqual(od, OrderedDict(p)) self.assertEqual(type(od), OrderedDict) # the object_pairs_hook takes priority over the object_hook - self.assertEqual(json.loads(s, - object_pairs_hook = OrderedDict, - object_hook = lambda x: None), + self.assertEqual(self.mod.loads(s, object_pairs_hook = OrderedDict, + object_hook = lambda x: None), OrderedDict(p)) + +@skip_unless_cjson +class TestCUnicode(TestPyUnicode): + mod = cjson diff -r 0d9837985725 Lib/test/support.py --- a/Lib/test/support.py Wed May 11 14:02:13 2011 -0400 +++ b/Lib/test/support.py Thu May 12 08:41:11 2011 +0300 @@ -92,18 +92,15 @@ def _save_and_remove_module(name, orig_modules): """Helper function to save and remove a module from sys.modules - Return True if the module was in sys.modules, False otherwise. Raise ImportError if the module can't be imported.""" - saved = True - try: - orig_modules[name] = sys.modules[name] - except KeyError: - # try to import the module and raise an error if it can't be imported + # try to import the module and raise an error if it can't be imported + if name not in sys.modules: __import__(name) - saved = False - else: del sys.modules[name] - return saved + for modname in list(sys.modules): + if modname == name or modname.startswith(name + '.'): + orig_modules[modname] = sys.modules[modname] + del sys.modules[modname] def _save_and_block_module(name, orig_modules):