update windows build to Python 3.7

Lib/site-packages/simplejson/tests/__init__.py

@@ -1,7 +1,7 @@
 from __future__ import absolute_import
 import unittest
-import doctest
 import sys
+import os
 
 
 class NoExtensionTestSuite(unittest.TestSuite):
@@ -27,6 +27,13 @@ def additional_tests(suite=None):
     import simplejson.decoder
     if suite is None:
         suite = unittest.TestSuite()
+    try:
+        import doctest
+    except ImportError:
+        if sys.version_info < (2, 7):
+            # doctests in 2.6 depends on cStringIO
+            return suite
+        raise
     for mod in (simplejson, simplejson.encoder, simplejson.decoder):
         suite.addTest(doctest.DocTestSuite(mod))
     suite.addTest(doctest.DocFileSuite('../../index.rst'))
@@ -35,36 +42,13 @@ def additional_tests(suite=None):
 
 def all_tests_suite():
     def get_suite():
+        suite_names = [
+            'simplejson.tests.%s' % (os.path.splitext(f)[0],)
+            for f in os.listdir(os.path.dirname(__file__))
+            if f.startswith('test_') and f.endswith('.py')
+        ]
         return additional_tests(
-            unittest.TestLoader().loadTestsFromNames([
-                'simplejson.tests.test_bitsize_int_as_string',
-                'simplejson.tests.test_bigint_as_string',
-                'simplejson.tests.test_check_circular',
-                'simplejson.tests.test_decode',
-                'simplejson.tests.test_default',
-                'simplejson.tests.test_dump',
-                'simplejson.tests.test_encode_basestring_ascii',
-                'simplejson.tests.test_encode_for_html',
-                'simplejson.tests.test_errors',
-                'simplejson.tests.test_fail',
-                'simplejson.tests.test_float',
-                'simplejson.tests.test_indent',
-                'simplejson.tests.test_iterable',
-                'simplejson.tests.test_pass1',
-                'simplejson.tests.test_pass2',
-                'simplejson.tests.test_pass3',
-                'simplejson.tests.test_recursion',
-                'simplejson.tests.test_scanstring',
-                'simplejson.tests.test_separators',
-                'simplejson.tests.test_speedups',
-                'simplejson.tests.test_unicode',
-                'simplejson.tests.test_decimal',
-                'simplejson.tests.test_tuple',
-                'simplejson.tests.test_namedtuple',
-                'simplejson.tests.test_tool',
-                'simplejson.tests.test_for_json',
-                'simplejson.tests.test_subclass',
-            ]))
+            unittest.TestLoader().loadTestsFromNames(suite_names))
     suite = get_suite()
     import simplejson
     if simplejson._import_c_make_encoder() is None:

Lib/site-packages/simplejson/tests/test_decode.py

@@ -3,9 +3,17 @@ import decimal
 from unittest import TestCase
 
 import simplejson as json
-from simplejson.compat import StringIO
+from simplejson.compat import StringIO, b, binary_type
 from simplejson import OrderedDict
 
+class MisbehavingBytesSubtype(binary_type):
+    def decode(self, encoding=None):
+        return "bad decode"
+    def __str__(self):
+        return "bad __str__"
+    def __bytes__(self):
+        return b("bad __bytes__")
+
 class TestDecode(TestCase):
     if not hasattr(TestCase, 'assertIs'):
         def assertIs(self, a, b):
@@ -87,6 +95,18 @@ class TestDecode(TestCase):
             ({'a': {}}, 11),
             cls().raw_decode(" \n{\"a\": {}}"))
 
+    def test_bytes_decode(self):
+        cls = json.decoder.JSONDecoder
+        data = b('"\xe2\x82\xac"')
+        self.assertEqual(cls().decode(data), u'\u20ac')
+        self.assertEqual(cls(encoding='latin1').decode(data), u'\xe2\x82\xac')
+        self.assertEqual(cls(encoding=None).decode(data), u'\u20ac')
+
+        data = MisbehavingBytesSubtype(b('"\xe2\x82\xac"'))
+        self.assertEqual(cls().decode(data), u'\u20ac')
+        self.assertEqual(cls(encoding='latin1').decode(data), u'\xe2\x82\xac')
+        self.assertEqual(cls(encoding=None).decode(data), u'\u20ac')
+
     def test_bounds_checking(self):
         # https://github.com/simplejson/simplejson/issues/98
         j = json.decoder.JSONDecoder()

Lib/site-packages/simplejson/tests/test_dump.py

@@ -1,12 +1,27 @@
 from unittest import TestCase
-from simplejson.compat import StringIO, long_type, b, binary_type, PY3
+from simplejson.compat import StringIO, long_type, b, binary_type, text_type, PY3
 import simplejson as json
 
+class MisbehavingTextSubtype(text_type):
+    def __str__(self):
+        return "FAIL!"
+
+class MisbehavingBytesSubtype(binary_type):
+    def decode(self, encoding=None):
+        return "bad decode"
+    def __str__(self):
+        return "bad __str__"
+    def __bytes__(self):
+        return b("bad __bytes__")
+
 def as_text_type(s):
-    if PY3 and isinstance(s, binary_type):
+    if PY3 and isinstance(s, bytes):
         return s.decode('ascii')
     return s
 
+def decode_iso_8859_15(b):
+    return b.decode('iso-8859-15')
+
 class TestDump(TestCase):
     def test_dump(self):
         sio = StringIO()
@@ -128,3 +143,107 @@ class TestDump(TestCase):
             json.dump(p, sio, sort_keys=True)
             self.assertEqual(sio.getvalue(), json.dumps(p, sort_keys=True))
             self.assertEqual(json.loads(sio.getvalue()), p)
+
+    def test_misbehaving_text_subtype(self):
+        # https://github.com/simplejson/simplejson/issues/185
+        text = "this is some text"
+        self.assertEqual(
+            json.dumps(MisbehavingTextSubtype(text)),
+            json.dumps(text)
+        )
+        self.assertEqual(
+            json.dumps([MisbehavingTextSubtype(text)]),
+            json.dumps([text])
+        )
+        self.assertEqual(
+            json.dumps({MisbehavingTextSubtype(text): 42}),
+            json.dumps({text: 42})
+        )
+
+    def test_misbehaving_bytes_subtype(self):
+        data = b("this is some data \xe2\x82\xac")
+        self.assertEqual(
+            json.dumps(MisbehavingBytesSubtype(data)),
+            json.dumps(data)
+        )
+        self.assertEqual(
+            json.dumps([MisbehavingBytesSubtype(data)]),
+            json.dumps([data])
+        )
+        self.assertEqual(
+            json.dumps({MisbehavingBytesSubtype(data): 42}),
+            json.dumps({data: 42})
+        )
+
+    def test_bytes_toplevel(self):
+        self.assertEqual(json.dumps(b('\xe2\x82\xac')), r'"\u20ac"')
+        self.assertRaises(UnicodeDecodeError, json.dumps, b('\xa4'))
+        self.assertEqual(json.dumps(b('\xa4'), encoding='iso-8859-1'),
+                         r'"\u00a4"')
+        self.assertEqual(json.dumps(b('\xa4'), encoding='iso-8859-15'),
+                         r'"\u20ac"')
+        if PY3:
+            self.assertRaises(TypeError, json.dumps, b('\xe2\x82\xac'),
+                              encoding=None)
+            self.assertRaises(TypeError, json.dumps, b('\xa4'),
+                              encoding=None)
+            self.assertEqual(json.dumps(b('\xa4'), encoding=None,
+                                        default=decode_iso_8859_15),
+                            r'"\u20ac"')
+        else:
+            self.assertEqual(json.dumps(b('\xe2\x82\xac'), encoding=None),
+                             r'"\u20ac"')
+            self.assertRaises(UnicodeDecodeError, json.dumps, b('\xa4'),
+                              encoding=None)
+            self.assertRaises(UnicodeDecodeError, json.dumps, b('\xa4'),
+                              encoding=None, default=decode_iso_8859_15)
+
+    def test_bytes_nested(self):
+        self.assertEqual(json.dumps([b('\xe2\x82\xac')]), r'["\u20ac"]')
+        self.assertRaises(UnicodeDecodeError, json.dumps, [b('\xa4')])
+        self.assertEqual(json.dumps([b('\xa4')], encoding='iso-8859-1'),
+                         r'["\u00a4"]')
+        self.assertEqual(json.dumps([b('\xa4')], encoding='iso-8859-15'),
+                         r'["\u20ac"]')
+        if PY3:
+            self.assertRaises(TypeError, json.dumps, [b('\xe2\x82\xac')],
+                              encoding=None)
+            self.assertRaises(TypeError, json.dumps, [b('\xa4')],
+                              encoding=None)
+            self.assertEqual(json.dumps([b('\xa4')], encoding=None,
+                                        default=decode_iso_8859_15),
+                             r'["\u20ac"]')
+        else:
+            self.assertEqual(json.dumps([b('\xe2\x82\xac')], encoding=None),
+                             r'["\u20ac"]')
+            self.assertRaises(UnicodeDecodeError, json.dumps, [b('\xa4')],
+                              encoding=None)
+            self.assertRaises(UnicodeDecodeError, json.dumps, [b('\xa4')],
+                              encoding=None, default=decode_iso_8859_15)
+
+    def test_bytes_key(self):
+        self.assertEqual(json.dumps({b('\xe2\x82\xac'): 42}), r'{"\u20ac": 42}')
+        self.assertRaises(UnicodeDecodeError, json.dumps, {b('\xa4'): 42})
+        self.assertEqual(json.dumps({b('\xa4'): 42}, encoding='iso-8859-1'),
+                         r'{"\u00a4": 42}')
+        self.assertEqual(json.dumps({b('\xa4'): 42}, encoding='iso-8859-15'),
+                         r'{"\u20ac": 42}')
+        if PY3:
+            self.assertRaises(TypeError, json.dumps, {b('\xe2\x82\xac'): 42},
+                              encoding=None)
+            self.assertRaises(TypeError, json.dumps, {b('\xa4'): 42},
+                              encoding=None)
+            self.assertRaises(TypeError, json.dumps, {b('\xa4'): 42},
+                              encoding=None, default=decode_iso_8859_15)
+            self.assertEqual(json.dumps({b('\xa4'): 42}, encoding=None,
+                                        skipkeys=True),
+                             r'{}')
+        else:
+            self.assertEqual(json.dumps({b('\xe2\x82\xac'): 42}, encoding=None),
+                             r'{"\u20ac": 42}')
+            self.assertRaises(UnicodeDecodeError, json.dumps, {b('\xa4'): 42},
+                              encoding=None)
+            self.assertRaises(UnicodeDecodeError, json.dumps, {b('\xa4'): 42},
+                              encoding=None, default=decode_iso_8859_15)
+            self.assertRaises(UnicodeDecodeError, json.dumps, {b('\xa4'): 42},
+                              encoding=None, skipkeys=True)

Lib/site-packages/simplejson/tests/test_encode_for_html.py

@@ -7,11 +7,19 @@ class TestEncodeForHTML(unittest.TestCase):
     def setUp(self):
         self.decoder = json.JSONDecoder()
         self.encoder = json.JSONEncoderForHTML()
+        self.non_ascii_encoder = json.JSONEncoderForHTML(ensure_ascii=False)
 
     def test_basic_encode(self):
         self.assertEqual(r'"\u0026"', self.encoder.encode('&'))
         self.assertEqual(r'"\u003c"', self.encoder.encode('<'))
         self.assertEqual(r'"\u003e"', self.encoder.encode('>'))
+        self.assertEqual(r'"\u2028"', self.encoder.encode(u'\u2028'))
+
+    def test_non_ascii_basic_encode(self):
+        self.assertEqual(r'"\u0026"', self.non_ascii_encoder.encode('&'))
+        self.assertEqual(r'"\u003c"', self.non_ascii_encoder.encode('<'))
+        self.assertEqual(r'"\u003e"', self.non_ascii_encoder.encode('>'))
+        self.assertEqual(r'"\u2028"', self.non_ascii_encoder.encode(u'\u2028'))
 
     def test_basic_roundtrip(self):
         for char in '&<>':

Lib/site-packages/simplejson/tests/test_errors.py

@@ -2,12 +2,29 @@ import sys, pickle
 from unittest import TestCase
 
 import simplejson as json
-from simplejson.compat import u, b
+from simplejson.compat import text_type, b
 
 class TestErrors(TestCase):
     def test_string_keys_error(self):
         data = [{'a': 'A', 'b': (2, 4), 'c': 3.0, ('d',): 'D tuple'}]
-        self.assertRaises(TypeError, json.dumps, data)
+        try:
+            json.dumps(data)
+        except TypeError:
+            err = sys.exc_info()[1]
+        else:
+            self.fail('Expected TypeError')
+        self.assertEqual(str(err),
+                'keys must be str, int, float, bool or None, not tuple')
+
+    def test_not_serializable(self):
+        try:
+            json.dumps(json)
+        except TypeError:
+            err = sys.exc_info()[1]
+        else:
+            self.fail('Expected TypeError')
+        self.assertEqual(str(err),
+                'Object of type module is not JSON serializable')
 
     def test_decode_error(self):
         err = None
@@ -24,7 +41,7 @@ class TestErrors(TestCase):
 
     def test_scan_error(self):
         err = None
-        for t in (u, b):
+        for t in (text_type, b):
             try:
                 json.loads(t('{"asdf": "'))
             except json.JSONDecodeError:

Lib/site-packages/simplejson/tests/test_item_sort_key.py

@@ -18,3 +18,10 @@ class TestItemSortKey(TestCase):
         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()))
+
+    def test_item_sort_key_value(self):
+        # https://github.com/simplejson/simplejson/issues/173
+        a = {'a': 1, 'b': 0}
+        self.assertEqual(
+            '{"b": 0, "a": 1}',
+            json.dumps(a, item_sort_key=lambda kv: kv[1]))

Lib/site-packages/simplejson/tests/test_raw_json.py

@@ -0,0 +1,47 @@
+import unittest
+import simplejson as json
+
+dct1 = {
+    'key1': 'value1'
+}
+
+dct2 = {
+    'key2': 'value2',
+    'd1': dct1
+}
+
+dct3 = {
+    'key2': 'value2',
+    'd1': json.dumps(dct1)
+}
+
+dct4 = {
+    'key2': 'value2',
+    'd1': json.RawJSON(json.dumps(dct1))
+}
+
+
+class TestRawJson(unittest.TestCase):
+
+    def test_normal_str(self):
+        self.assertNotEqual(json.dumps(dct2), json.dumps(dct3))
+
+    def test_raw_json_str(self):
+        self.assertEqual(json.dumps(dct2), json.dumps(dct4))
+        self.assertEqual(dct2, json.loads(json.dumps(dct4)))
+
+    def test_list(self):
+        self.assertEqual(
+            json.dumps([dct2]),
+            json.dumps([json.RawJSON(json.dumps(dct2))]))
+        self.assertEqual(
+            [dct2],
+            json.loads(json.dumps([json.RawJSON(json.dumps(dct2))])))
+
+    def test_direct(self):
+        self.assertEqual(
+            json.dumps(dct2),
+            json.dumps(json.RawJSON(json.dumps(dct2))))
+        self.assertEqual(
+            dct2,
+            json.loads(json.dumps(json.RawJSON(json.dumps(dct2)))))

Lib/site-packages/simplejson/tests/test_scanstring.py

@@ -22,6 +22,8 @@ class TestScanString(TestCase):
             return
         self._test_scanstring(simplejson.decoder.c_scanstring)
 
+        self.assertTrue(isinstance(simplejson.decoder.c_scanstring('""', 0)[0], str))
+
     def _test_scanstring(self, scanstring):
         if sys.maxunicode == 65535:
             self.assertEqual(

Lib/site-packages/simplejson/tests/test_speedups.py

@@ -1,8 +1,12 @@
+from __future__ import with_statement
+
 import sys
 import unittest
 from unittest import TestCase
 
-from simplejson import encoder, scanner
+import simplejson
+from simplejson import encoder, decoder, scanner
+from simplejson.compat import PY3, long_type, b
 
 
 def has_speedups():
@@ -22,11 +26,28 @@ def skip_if_speedups_missing(func):
     return wrapper
 
 
+class BadBool:
+    def __bool__(self):
+        1/0
+    __nonzero__ = __bool__
+
+
 class TestDecode(TestCase):
     @skip_if_speedups_missing
     def test_make_scanner(self):
         self.assertRaises(AttributeError, scanner.c_make_scanner, 1)
 
+    @skip_if_speedups_missing
+    def test_bad_bool_args(self):
+        def test(value):
+            decoder.JSONDecoder(strict=BadBool()).decode(value)
+        self.assertRaises(ZeroDivisionError, test, '""')
+        self.assertRaises(ZeroDivisionError, test, '{}')
+        if not PY3:
+            self.assertRaises(ZeroDivisionError, test, u'""')
+            self.assertRaises(ZeroDivisionError, test, u'{}')
+
+class TestEncode(TestCase):
     @skip_if_speedups_missing
     def test_make_encoder(self):
         self.assertRaises(
@@ -37,3 +58,57 @@ class TestDecode(TestCase):
              "\x52\xBA\x82\xF2\x27\x4A\x7D\xA0\xCA\x75"),
             None
         )
+
+    @skip_if_speedups_missing
+    def test_bad_str_encoder(self):
+        # Issue #31505: There shouldn't be an assertion failure in case
+        # c_make_encoder() receives a bad encoder() argument.
+        import decimal
+        def bad_encoder1(*args):
+            return None
+        enc = encoder.c_make_encoder(
+                None, lambda obj: str(obj),
+                bad_encoder1, None, ': ', ', ',
+                False, False, False, {}, False, False, False,
+                None, None, 'utf-8', False, False, decimal.Decimal, False)
+        self.assertRaises(TypeError, enc, 'spam', 4)
+        self.assertRaises(TypeError, enc, {'spam': 42}, 4)
+
+        def bad_encoder2(*args):
+            1/0
+        enc = encoder.c_make_encoder(
+                None, lambda obj: str(obj),
+                bad_encoder2, None, ': ', ', ',
+                False, False, False, {}, False, False, False,
+                None, None, 'utf-8', False, False, decimal.Decimal, False)
+        self.assertRaises(ZeroDivisionError, enc, 'spam', 4)
+
+    @skip_if_speedups_missing
+    def test_bad_bool_args(self):
+        def test(name):
+            encoder.JSONEncoder(**{name: BadBool()}).encode({})
+        self.assertRaises(ZeroDivisionError, test, 'skipkeys')
+        self.assertRaises(ZeroDivisionError, test, 'ensure_ascii')
+        self.assertRaises(ZeroDivisionError, test, 'check_circular')
+        self.assertRaises(ZeroDivisionError, test, 'allow_nan')
+        self.assertRaises(ZeroDivisionError, test, 'sort_keys')
+        self.assertRaises(ZeroDivisionError, test, 'use_decimal')
+        self.assertRaises(ZeroDivisionError, test, 'namedtuple_as_object')
+        self.assertRaises(ZeroDivisionError, test, 'tuple_as_array')
+        self.assertRaises(ZeroDivisionError, test, 'bigint_as_string')
+        self.assertRaises(ZeroDivisionError, test, 'for_json')
+        self.assertRaises(ZeroDivisionError, test, 'ignore_nan')
+        self.assertRaises(ZeroDivisionError, test, 'iterable_as_array')
+
+    @skip_if_speedups_missing
+    def test_int_as_string_bitcount_overflow(self):
+        long_count = long_type(2)**32+31
+        def test():
+            encoder.JSONEncoder(int_as_string_bitcount=long_count).encode(0)
+        self.assertRaises((TypeError, OverflowError), test)
+
+    if PY3:
+        @skip_if_speedups_missing
+        def test_bad_encoding(self):
+            with self.assertRaises(UnicodeEncodeError):
+                encoder.JSONEncoder(encoding='\udcff').encode({b('key'): 123})

Lib/site-packages/simplejson/tests/test_str_subclass.py

@@ -0,0 +1,21 @@
+from unittest import TestCase
+
+import simplejson
+from simplejson.compat import text_type
+
+# Tests for issue demonstrated in https://github.com/simplejson/simplejson/issues/144
+class WonkyTextSubclass(text_type):
+    def __getslice__(self, start, end):
+        return self.__class__('not what you wanted!')
+
+class TestStrSubclass(TestCase):
+    def test_dump_load(self):
+        for s in ['', '"hello"', 'text', u'\u005c']:
+            self.assertEqual(
+                s,
+                simplejson.loads(simplejson.dumps(WonkyTextSubclass(s))))
+
+            self.assertEqual(
+                s,
+                simplejson.loads(simplejson.dumps(WonkyTextSubclass(s),
+                                                  ensure_ascii=False)))

Lib/site-packages/simplejson/tests/test_tool.py

@@ -21,6 +21,15 @@ except ImportError:
                 "".encode(),
                 stderr).strip()
 
+def open_temp_file():
+    if sys.version_info >= (2, 6):
+        file = tempfile.NamedTemporaryFile(delete=False)
+        filename = file.name
+    else:
+        fd, filename = tempfile.mkstemp()
+        file = os.fdopen(fd, 'w+b')
+    return file, filename
+
 class TestTool(unittest.TestCase):
     data = """
 
@@ -63,35 +72,43 @@ class TestTool(unittest.TestCase):
         out, err = proc.communicate(data)
         self.assertEqual(strip_python_stderr(err), ''.encode())
         self.assertEqual(proc.returncode, 0)
-        return out
+        return out.decode('utf8').splitlines()
 
     def test_stdin_stdout(self):
         self.assertEqual(
             self.runTool(data=self.data.encode()),
-            self.expect.encode())
+            self.expect.splitlines())
 
     def test_infile_stdout(self):
-        with tempfile.NamedTemporaryFile() as infile:
+        infile, infile_name = open_temp_file()
+        try:
             infile.write(self.data.encode())
-            infile.flush()
+            infile.close()
             self.assertEqual(
-                self.runTool(args=[infile.name]),
-                self.expect.encode())
+                self.runTool(args=[infile_name]),
+                self.expect.splitlines())
+        finally:
+            os.unlink(infile_name)
 
     def test_infile_outfile(self):
-        with tempfile.NamedTemporaryFile() as infile:
+        infile, infile_name = open_temp_file()
+        try:
             infile.write(self.data.encode())
-            infile.flush()
+            infile.close()
             # outfile will get overwritten by tool, so the delete
             # may not work on some platforms. Do it manually.
-            outfile = tempfile.NamedTemporaryFile()
+            outfile, outfile_name = open_temp_file()
             try:
-                self.assertEqual(
-                    self.runTool(args=[infile.name, outfile.name]),
-                    ''.encode())
-                with open(outfile.name, 'rb') as f:
-                    self.assertEqual(f.read(), self.expect.encode())
-            finally:
                 outfile.close()
-                if os.path.exists(outfile.name):
-                    os.unlink(outfile.name)
+                self.assertEqual(
+                    self.runTool(args=[infile_name, outfile_name]),
+                    [])
+                with open(outfile_name, 'rb') as f:
+                    self.assertEqual(
+                        f.read().decode('utf8').splitlines(),
+                        self.expect.splitlines()
+                    )
+            finally:
+                os.unlink(outfile_name)
+        finally:
+            os.unlink(infile_name)

Lib/site-packages/simplejson/tests/test_unicode.py

@@ -3,7 +3,7 @@ import codecs
 from unittest import TestCase
 
 import simplejson as json
-from simplejson.compat import unichr, text_type, b, u, BytesIO
+from simplejson.compat import unichr, text_type, b, BytesIO
 
 class TestUnicode(TestCase):
     def test_encoding1(self):
@@ -93,7 +93,7 @@ class TestUnicode(TestCase):
     def test_ensure_ascii_false_bytestring_encoding(self):
         # http://code.google.com/p/simplejson/issues/detail?id=48
         doc1 = {u'quux': b('Arr\xc3\xaat sur images')}
-        doc2 = {u'quux': u('Arr\xeat sur images')}
+        doc2 = {u'quux': u'Arr\xeat sur images'}
         doc_ascii = '{"quux": "Arr\\u00eat sur images"}'
         doc_unicode = u'{"quux": "Arr\xeat sur images"}'
         self.assertEqual(json.dumps(doc1), doc_ascii)
@@ -106,10 +106,11 @@ class TestUnicode(TestCase):
         s1 = u'\u2029\u2028'
         s2 = s1.encode('utf8')
         expect = '"\\u2029\\u2028"'
+        expect_non_ascii = u'"\u2029\u2028"'
         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)
+        self.assertEqual(json.dumps(s1, ensure_ascii=False), expect_non_ascii)
+        self.assertEqual(json.dumps(s2, ensure_ascii=False), expect_non_ascii)
 
     def test_invalid_escape_sequences(self):
         # incomplete escape sequence