orjson/test/test_transform.py at master · ITCSsDeveloper/orjson · GitHub

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
# SPDX-License-Identifier: (Apache-2.0 OR MIT)

import unittest

import orjson

from .util import read_fixture_bytes


def _read_file(filename):
    return read_fixture_bytes(filename, "transform").strip(b"\n").strip(b"\r")


class JSONTestSuiteTransformTests(unittest.TestCase):
    def _pass_transform(self, filename, reference=None):
        data = _read_file(filename)
        self.assertEqual(orjson.dumps(orjson.loads(data)), reference or data)

    def _fail_transform(self, filename):
        data = _read_file(filename)
        with self.assertRaises(orjson.JSONDecodeError):
            orjson.loads(data)

    def test_number_1(self):
        """
        number_1.0.json
        """
        self._pass_transform("number_1.0.json")

    def test_number_1e6(self):
        """
        number_1e6.json
        """
        self._pass_transform("number_1e6.json", b"[1000000.0]")

    def test_number_1e_999(self):
        """
        number_1e-999.json
        """
        self._pass_transform("number_1e-999.json", b"[0.0]")

    def test_number_10000000000000000999(self):
        """
        number_10000000000000000999.json
        """
        # cannot serialize due to range
        self.assertEqual(
            orjson.loads(_read_file("number_10000000000000000999.json")),
            [10000000000000000999],
        )

    def test_number_1000000000000000(self):
        """
        number_1000000000000000.json
        """
        self._pass_transform("number_1000000000000000.json")

    def test_object_key_nfc_nfd(self):
        """
        object_key_nfc_nfd.json
        """
        self._pass_transform("object_key_nfc_nfd.json")

    def test_object_key_nfd_nfc(self):
        """
        object_key_nfd_nfc.json
        """
        self._pass_transform("object_key_nfd_nfc.json")

    def test_object_same_key_different_values(self):
        """
        object_same_key_different_values.json
        """
        self._pass_transform("object_same_key_different_values.json", b'{"a":2}')

    def test_object_same_key_same_value(self):
        """
        object_same_key_same_value.json
        """
        self._pass_transform("object_same_key_same_value.json", b'{"a":1}')

    def test_object_same_key_unclear_values(self):
        """
        object_same_key_unclear_values.json
        """
        data = _read_file("object_same_key_unclear_values.json")
        # varies by backend
        assert data in (b'{"a":-0.0}', b'{"a":0, "a":-0}')

    def test_string_1_escaped_invalid_codepoint(self):
        """
        string_1_escaped_invalid_codepoint.json
        """
        self._fail_transform("string_1_escaped_invalid_codepoint.json")

    def test_string_1_invalid_codepoint(self):
        """
        string_1_invalid_codepoint.json
        """
        self._fail_transform("string_1_invalid_codepoint.json")

    def test_string_2_escaped_invalid_codepoints(self):
        """
        string_2_escaped_invalid_codepoints.json
        """
        self._fail_transform("string_2_escaped_invalid_codepoints.json")

    def test_string_2_invalid_codepoints(self):
        """
        string_2_invalid_codepoints.json
        """
        self._fail_transform("string_2_invalid_codepoints.json")

    def test_string_3_escaped_invalid_codepoints(self):
        """
        string_3_escaped_invalid_codepoints.json
        """
        self._fail_transform("string_3_escaped_invalid_codepoints.json")

    def test_string_3_invalid_codepoints(self):
        """
        string_3_invalid_codepoints.json
        """
        self._fail_transform("string_3_invalid_codepoints.json")

    def test_string_with_escaped_NULL(self):
        """
        string_with_escaped_NULL.json
        """
        self._pass_transform("string_with_escaped_NULL.json")