File size: 4,437 Bytes
9c6594c
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
from __future__ import absolute_import

import decimal
from unittest import TestCase

import hjson as json
from hjson import OrderedDict
from hjson.compat import StringIO


class TestDecode(TestCase):
    if not hasattr(TestCase, "assertIs"):

        def assertIs(self, a, b):
            self.assertTrue(a is b, "%r is %r" % (a, b))

    def test_decimal(self):
        rval = json.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)
        self.assertTrue(isinstance(rval, float))
        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.assertEqual(rval, {"key": "value", "k": "v"})

    def test_empty_objects(self):
        s = "{}"
        self.assertEqual(json.loads(s), eval(s))
        s = "[]"
        self.assertEqual(json.loads(s), eval(s))
        s = '""'
        self.assertEqual(json.loads(s), eval(s))

    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(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),
            OrderedDict(p),
        )

    def check_keys_reuse(self, source, loads):
        rval = loads(source)
        (a, b), (c, d) = sorted(rval[0]), sorted(rval[1])
        self.assertIs(a, c)
        self.assertIs(b, d)

    def test_keys_reuse_str(self):
        s = u'[{"a_key": 1, "b_\xe9": 2}, {"a_key": 3, "b_\xe9": 4}]'.encode("utf8")
        self.check_keys_reuse(s, json.loads)

    def test_keys_reuse_unicode(self):
        s = u'[{"a_key": 1, "b_\xe9": 2}, {"a_key": 3, "b_\xe9": 4}]'
        self.check_keys_reuse(s, json.loads)

    def test_empty_strings(self):
        self.assertEqual(json.loads('""'), "")
        self.assertEqual(json.loads(u'""'), u"")
        self.assertEqual(json.loads('[""]'), [""])
        self.assertEqual(json.loads(u'[""]'), [u""])

    def test_multiline_string(self):
        s1 = """

hello: '''

'''

"""
        s2 = """

hello: '''
'''

"""
        s3 = """

hello: ''''''

"""
        s4 = """

hello: ''

"""
        s5 = """

hello: ""

"""
        self.assertEqual(json.loads(s1), {"hello": ""})
        self.assertEqual(json.loads(s2), {"hello": ""})
        self.assertEqual(json.loads(s3), {"hello": ""})
        self.assertEqual(json.loads(s4), {"hello": ""})
        self.assertEqual(json.loads(s5), {"hello": ""})

    def test_raw_decode(self):
        cls = json.decoder.HjsonDecoder
        self.assertEqual(({"a": {}}, 9), cls().raw_decode('{"a": {}}'))
        # http://code.google.com/p/simplejson/issues/detail?id=85
        self.assertEqual(
            ({"a": {}}, 9), cls(object_pairs_hook=dict).raw_decode('{"a": {}}')
        )
        # https://github.com/simplejson/simplejson/pull/38
        self.assertEqual(({"a": {}}, 11), cls().raw_decode(' \n{"a": {}}'))

    def test_bounds_checking(self):
        # https://github.com/simplejson/simplejson/issues/98
        j = json.decoder.HjsonDecoder()
        for i in [4, 5, 6, -1, -2, -3, -4, -5, -6]:
            self.assertRaises(ValueError, j.scan_once, "1234", i)
            self.assertRaises(ValueError, j.raw_decode, "1234", i)
        x, y = sorted(["128931233", "472389423"], key=id)
        diff = id(x) - id(y)
        self.assertRaises(ValueError, j.scan_once, y, diff)
        self.assertRaises(ValueError, j.raw_decode, y, i)