1/*
2 * Copyright (c) 2021 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 *     http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16#include "ecmascript/base/json_parser.h"
17#include "ecmascript/base/json_helper.h"
18#include "ecmascript/ecma_string.h"
19#include "ecmascript/tests/test_helper.h"
20
21using namespace panda::ecmascript;
22using namespace panda::ecmascript::base;
23
24namespace panda::test {
25class AsonParserTest : public BaseTestWithScope<false> {
26public:
27    using BigIntMode = base::JsonHelper::BigIntMode;
28    using ParseOptions =  base::JsonHelper::ParseOptions;
29    using ParseReturnType = base::JsonHelper::ParseReturnType;
30    using TransformType = base::JsonHelper::TransformType;
31
32    bool CheckSendableConstraint(JSTaggedValue value) const
33    {
34        if (!value.IsHeapObject()) {
35            // tagged value always follow sendable constraint.
36            return true;
37        }
38        TaggedObject *obj = value.IsWeak() ? value.GetTaggedWeakRef() : value.GetTaggedObject();
39        auto *jsHClass = obj->GetClass();
40        if (!jsHClass->IsJSShared()) {
41            return false;
42        }
43        if (jsHClass->IsExtensible()) {
44            LOG_ECMA(ERROR) << "sendable check failed. obj is extensible";
45            value.D();
46            return false;
47        }
48        if (!CheckSendableProps(value, obj)) {
49            return false;
50        }
51        // trace proto chain
52        auto proto = jsHClass->GetPrototype();
53        if (!proto.IsNull() && !proto.IsJSShared()) {
54            LOG_ECMA(ERROR) << "sendable check failed. proto is not sendable.";
55            value.D();
56            return false;
57        }
58        return true;
59    }
60
61    bool CheckSendableProps(JSTaggedValue value, TaggedObject *obj) const
62    {
63        auto *jsHClass = obj->GetClass();
64        auto layoutValue = jsHClass->GetLayout();
65        if (layoutValue.IsNull()) {
66            return true;
67        }
68        auto *layoutInfo = LayoutInfo::Cast(layoutValue.GetTaggedObject());
69        auto *jsObj = JSObject::Cast(obj);
70        auto *propsValue = TaggedArray::Cast(jsObj->GetProperties());
71        if (propsValue->IsDictionaryMode()) {
72            for (int idx = 0; idx < static_cast<int>(jsHClass->NumberOfProps()); idx++) {
73                auto attr = layoutInfo->GetAttr(idx);
74                if (attr.IsInlinedProps()) {
75                    // Do not check inline props
76                    continue;
77                }
78                if (attr.IsWritable()) {
79                    LOG_ECMA(ERROR) << "sendable check failed. supposed to be un-writable. idx: " << idx;
80                    value.D();
81                    return false;
82                }
83                auto val = propsValue->Get(thread, idx - jsHClass->GetInlinedProperties());
84                if (!CheckSendableConstraint(val)) {
85                    LOG_ECMA(ERROR) << "sendable check failed. supposed to be sendable. idx: " << idx;
86                    value.D();
87                    return false;
88                }
89            }
90        }
91        return true;
92    }
93};
94
95HWTEST_F_L0(AsonParserTest, Parser_001)
96{
97    ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
98    Utf8JsonParser parser(thread, TransformType::SENDABLE);
99    // JSON Number
100    JSHandle<JSTaggedValue> handleMsg2(factory->NewFromASCII("1234"));
101    JSHandle<EcmaString> handleStr2(JSTaggedValue::ToString(thread, handleMsg2));
102    JSHandle<JSTaggedValue> result2 = parser.Parse(handleStr2);
103    EXPECT_EQ(result2->GetNumber(), 1234);
104    // JSON Literal
105    JSHandle<JSTaggedValue> handleMsg3(factory->NewFromASCII("true"));
106    JSHandle<EcmaString> handleStr3(JSTaggedValue::ToString(thread, handleMsg3));
107    JSHandle<JSTaggedValue> result3 = parser.Parse(handleStr3);
108    EXPECT_EQ(result3.GetTaggedValue(), JSTaggedValue::True());
109    // JSON LiteraF
110    JSHandle<JSTaggedValue> handleMsg4(factory->NewFromASCII("false"));
111    JSHandle<EcmaString> handleStr4(JSTaggedValue::ToString(thread, handleMsg4));
112    JSHandle<JSTaggedValue> result4 = parser.Parse(handleStr4);
113    EXPECT_EQ(result4.GetTaggedValue(), JSTaggedValue::False());
114    // JSON Unexpected
115    JSHandle<JSTaggedValue> handleMsg5(factory->NewFromASCII("trus"));
116    JSHandle<EcmaString> handleStr5(JSTaggedValue::ToString(thread, handleMsg5));
117    JSHandle<JSTaggedValue> result5 = parser.Parse(handleStr5);
118    EXPECT_EQ(result5.GetTaggedValue(), JSTaggedValue::Exception());
119}
120
121HWTEST_F_L0(AsonParserTest, Parser_002)
122{
123    ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
124    Utf16JsonParser parser(thread, TransformType::SENDABLE);
125
126    // JSON Number
127    uint16_t array1Utf16[] = {0x31, 0x32, 0x33, 0x34}; // "1234"
128    uint32_t array1Utf16Len = sizeof(array1Utf16) / sizeof(array1Utf16[0]);
129    JSHandle<JSTaggedValue> handleMsg2(factory->NewFromUtf16(&array1Utf16[0], array1Utf16Len));
130    JSHandle<EcmaString> handleStr2(JSTaggedValue::ToString(thread, handleMsg2));
131    JSHandle<JSTaggedValue> result2 = parser.Parse(*handleStr2);
132    EXPECT_EQ(result2->GetNumber(), 1234);
133    // JSON Literal
134    uint16_t array2Utf16[] = {0x74, 0x72, 0x75, 0x65}; // "true"
135    uint32_t array2Utf16Len = sizeof(array2Utf16) / sizeof(array2Utf16[0]);
136    JSHandle<JSTaggedValue> handleMsg3(factory->NewFromUtf16(&array2Utf16[0], array2Utf16Len));
137    JSHandle<EcmaString> handleStr3(JSTaggedValue::ToString(thread, handleMsg3));
138    JSHandle<JSTaggedValue> result3 = parser.Parse(*handleStr3);
139    EXPECT_EQ(result3.GetTaggedValue(), JSTaggedValue::True());
140    // JSON String
141    uint16_t array3Utf16[] = {0x22, 0x73, 0x74, 0x72, 0x69, 0x6E, 0X67, 0x22}; // "string"
142    uint32_t array3Utf16Len = sizeof(array3Utf16) / sizeof(array3Utf16[0]);
143    JSHandle<JSTaggedValue> handleMsg4(factory->NewFromUtf16(&array3Utf16[0], array3Utf16Len));
144    JSHandle<EcmaString> handleStr4(JSTaggedValue::ToString(thread, handleMsg4));
145    JSHandle<JSTaggedValue> result4 = parser.Parse(*handleStr4);
146    JSHandle<EcmaString> handleEcmaStr(result4);
147    EXPECT_STREQ("string", EcmaStringAccessor(handleEcmaStr).ToCString().c_str());
148}
149
150HWTEST_F_L0(AsonParserTest, Parser_003)
151{
152    ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
153    Utf8JsonParser parser(thread, TransformType::SENDABLE);
154    JSHandle<JSTaggedValue> handleMsg(factory->NewFromASCII(
155        "\t\r \n{\t\r \n \"json\"\t\r\n:\t\r \n{\t\r \n}\t\r \n,\t\r \n \"prop2\"\t\r \n:\t\r \n [\t\r \nfalse\t\r"
156        "\n,\t\r \nnull\t\r, \ntrue\t\r,123.456\t\r \n]\t\r \n}\t\r \n"));
157    JSHandle<EcmaString> handleStr(JSTaggedValue::ToString(thread, handleMsg)); // JSON Object
158    JSHandle<JSTaggedValue> result = parser.Parse(handleStr);
159    result->D();
160    EXPECT_TRUE(CheckSendableConstraint(result.GetTaggedValue()));
161}
162
163HWTEST_F_L0(AsonParserTest, Parser_004)
164{
165    ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
166    Utf8JsonParser parser(thread, TransformType::SENDABLE);
167    JSHandle<JSTaggedValue> handleMsg(factory->NewFromASCII("[100,2.5,\"abc\"]"));
168    JSHandle<EcmaString> handleStr(JSTaggedValue::ToString(thread, handleMsg)); // JSON Array
169    JSHandle<JSTaggedValue> result = parser.Parse(handleStr);
170    result->D();
171    EXPECT_TRUE(CheckSendableConstraint(result.GetTaggedValue()));
172}
173
174HWTEST_F_L0(AsonParserTest, Parser_005)
175{
176    ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
177    Utf8JsonParser parser(thread, TransformType::SENDABLE);
178    JSHandle<JSTaggedValue> handleMsg(factory->NewFromASCII("{\"epf\":100,\"key1\":400}"));
179    JSHandle<EcmaString> handleStr(JSTaggedValue::ToString(thread, handleMsg));
180    JSHandle<JSTaggedValue> result = parser.Parse(handleStr);
181    EXPECT_TRUE(CheckSendableConstraint(result.GetTaggedValue()));
182}
183
184HWTEST_F_L0(AsonParserTest, Parser_006)
185{
186    Utf8JsonParser parser(thread, TransformType::SENDABLE);
187    JSHandle<EcmaString> emptyString(thread->GlobalConstants()->GetHandledEmptyString());
188    JSHandle<JSTaggedValue> result = parser.Parse(emptyString);
189    EXPECT_TRUE(result->IsException());
190}
191
192HWTEST_F_L0(AsonParserTest, Parser_007)
193{
194    ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
195    Utf8JsonParser parser(thread, TransformType::SENDABLE);
196
197    JSHandle<EcmaString> handleStr(factory->NewFromASCII("\"\""));
198    JSHandle<JSTaggedValue> result = parser.Parse(handleStr);
199    EXPECT_FALSE(result->IsException());
200}
201
202HWTEST_F_L0(AsonParserTest, Parser_008)
203{
204    ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
205    Utf8JsonParser parser(thread, TransformType::SENDABLE);
206    JSHandle<JSTaggedValue> handleMsg(
207        factory->NewFromASCII(R"({"innerEntry": {"x":1, "y":"abc", "str": "innerStr"}, "x": 1, "str": "outerStr"})"));
208    JSHandle<EcmaString> handleStr(JSTaggedValue::ToString(thread, handleMsg));
209    JSHandle<JSTaggedValue> result = parser.Parse(handleStr);
210    result->D();
211    EXPECT_FALSE(result->IsException());
212    EXPECT_TRUE(CheckSendableConstraint(result.GetTaggedValue()));
213}
214
215HWTEST_F_L0(AsonParserTest, Parser_009)
216{
217    ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
218    Utf8JsonParser parser(thread, TransformType::SENDABLE);
219    JSHandle<JSTaggedValue> handleMsg(factory->NewFromASCII(R"({})"));
220    JSHandle<EcmaString> handleStr(JSTaggedValue::ToString(thread, handleMsg));
221    JSHandle<JSTaggedValue> result = parser.Parse(handleStr);
222    result->D();
223    EXPECT_TRUE(CheckSendableConstraint(result.GetTaggedValue()));
224}
225
226HWTEST_F_L0(AsonParserTest, Parser_010)
227{
228    ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
229    Utf8JsonParser parser(thread, TransformType::SENDABLE);
230    JSHandle<JSTaggedValue> handleMsg(factory->NewFromASCII(R"([])"));
231    JSHandle<EcmaString> handleStr(JSTaggedValue::ToString(thread, handleMsg));
232    JSHandle<JSTaggedValue> result = parser.Parse(handleStr);
233    result->D();
234    EXPECT_TRUE(CheckSendableConstraint(result.GetTaggedValue()));
235}
236
237HWTEST_F_L0(AsonParserTest, Parser_011)
238{
239    ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
240    Utf8JsonParser parser(thread, TransformType::SENDABLE);
241    JSHandle<JSTaggedValue> handleMsg(factory->NewFromASCII(R"([1, 2, 3])"));
242    JSHandle<EcmaString> handleStr(JSTaggedValue::ToString(thread, handleMsg));
243    JSHandle<JSTaggedValue> result = parser.Parse(handleStr);
244    result->D();
245    EXPECT_TRUE(CheckSendableConstraint(result.GetTaggedValue()));
246}
247
248HWTEST_F_L0(AsonParserTest, Parser_012)
249{
250    ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
251    Utf8JsonParser parser(thread, TransformType::SENDABLE);
252    JSHandle<JSTaggedValue> handleMsg(
253        factory->NewFromASCII(R"({"innerEntry": {"array": [1, 2, 3]}, "x": 1, "str": "outerStr"})"));
254    JSHandle<EcmaString> handleStr(JSTaggedValue::ToString(thread, handleMsg));
255    JSHandle<JSTaggedValue> result = parser.Parse(handleStr);
256    result->D();
257    EXPECT_TRUE(CheckSendableConstraint(result.GetTaggedValue()));
258}
259
260HWTEST_F_L0(AsonParserTest, Parser_013)
261{
262    JSHandle<GlobalEnv> env = thread->GetEcmaVM()->GetGlobalEnv();
263    JSMutableHandle<JSFunction> constructor(thread, JSTaggedValue::Undefined());
264    constructor.Update(env->GetSObjectFunction());
265    ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
266    JSHandle<JSObject> root = factory->NewJSObjectByConstructor(constructor);
267    JSHandle<JSTaggedValue> rootName(factory->GetEmptyString());
268    JSHandle<JSTaggedValue> result;
269    JSHandle<JSTaggedValue> undefined = JSHandle<JSTaggedValue>(thread, JSTaggedValue::Undefined());
270    result = Internalize::InternalizeJsonProperty(thread, root, rootName, undefined, TransformType::SENDABLE);
271    ASSERT_TRUE(!result->IsUndefined());
272}
273
274HWTEST_F_L0(AsonParserTest, Parser_014)
275{
276    ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
277    Utf8JsonParser parser(thread, TransformType::SENDABLE);
278    // JSON Unexpected
279    JSHandle<JSTaggedValue> handleMsg1(factory->NewFromASCII("tr"));
280    JSHandle<EcmaString> handleStr1(JSTaggedValue::ToString(thread, handleMsg1));
281    JSHandle<JSTaggedValue> result1 = parser.Parse(handleStr1);
282    EXPECT_EQ(result1.GetTaggedValue(), JSTaggedValue::Exception());
283    // JSON Unexpected
284    JSHandle<JSTaggedValue> handleMsg2(factory->NewFromASCII("fa"));
285    JSHandle<EcmaString> handleStr2(JSTaggedValue::ToString(thread, handleMsg2));
286    JSHandle<JSTaggedValue> result2 = parser.Parse(handleStr2);
287    EXPECT_EQ(result2.GetTaggedValue(), JSTaggedValue::Exception());
288    // JSON Unexpected
289    JSHandle<JSTaggedValue> handleMsg3(factory->NewFromASCII("falss"));
290    JSHandle<EcmaString> handleStr3(JSTaggedValue::ToString(thread, handleMsg3));
291    JSHandle<JSTaggedValue> result3 = parser.Parse(handleStr3);
292    EXPECT_EQ(result3.GetTaggedValue(), JSTaggedValue::Exception());
293}
294
295HWTEST_F_L0(AsonParserTest, Parser_015)
296{
297    ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
298    Utf8JsonParser parser(thread, TransformType::SENDABLE);
299    // JSON Unexpected
300    JSHandle<JSTaggedValue> handleMsg1(factory->NewFromASCII(R"([1, 2, 3})"));
301    JSHandle<EcmaString> handleStr1(JSTaggedValue::ToString(thread, handleMsg1));
302    JSHandle<JSTaggedValue> result1 = parser.Parse(handleStr1);
303    EXPECT_EQ(result1.GetTaggedValue(), JSTaggedValue::Exception());
304    // JSON Unexpected
305    JSHandle<JSTaggedValue> handleMsg2(factory->NewFromASCII(R"({"innerEntry""entry"})"));
306    JSHandle<EcmaString> handleStr2(JSTaggedValue::ToString(thread, handleMsg2));
307    JSHandle<JSTaggedValue> result2 = parser.Parse(handleStr2);
308    EXPECT_EQ(result2.GetTaggedValue(), JSTaggedValue::Exception());
309    // JSON Unexpected
310    JSHandle<JSTaggedValue> handleMsg3(factory->NewFromASCII("1s2"));
311    JSHandle<EcmaString> handleStr3(JSTaggedValue::ToString(thread, handleMsg3));
312    JSHandle<JSTaggedValue> result3 = parser.Parse(handleStr3);
313    EXPECT_EQ(result3.GetTaggedValue(), JSTaggedValue::Exception());
314    // JSON Unexpected
315    JSHandle<JSTaggedValue> handleMsg4(factory->NewFromASCII("122-"));
316    JSHandle<EcmaString> handleStr4(JSTaggedValue::ToString(thread, handleMsg4));
317    JSHandle<JSTaggedValue> result4 = parser.Parse(handleStr4);
318    EXPECT_EQ(result4.GetTaggedValue(), JSTaggedValue::Exception());
319    // JSON Unexpected
320    JSHandle<JSTaggedValue> handleMsg5(factory->NewFromASCII("122+"));
321    JSHandle<EcmaString> handleStr5(JSTaggedValue::ToString(thread, handleMsg5));
322    JSHandle<JSTaggedValue> result5 = parser.Parse(handleStr5);
323    EXPECT_EQ(result5.GetTaggedValue(), JSTaggedValue::Exception());
324}
325
326HWTEST_F_L0(AsonParserTest, Parser_016)
327{
328    ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
329    ParseOptions options1;
330    Utf8JsonParser parser1(thread, TransformType::SENDABLE, options1);
331
332    JSHandle<JSTaggedValue> handleMsg1(
333        factory->NewFromASCII(R"({"small":1234})"));
334    JSHandle<EcmaString> handleStr1(JSTaggedValue::ToString(thread, handleMsg1));
335    JSHandle<JSTaggedValue> result1 = parser1.Parse(handleStr1);
336    EXPECT_NE(result1.GetTaggedValue(), JSTaggedValue::Exception());
337
338    ParseOptions options2;
339    options2.bigIntMode = BigIntMode::PARSE_AS_BIGINT;
340    Utf8JsonParser parser2(thread, TransformType::SENDABLE, options2);
341    JSHandle<JSTaggedValue> handleMsg2(factory->NewFromASCII(R"({"big":1122334455667788999})"));
342    JSHandle<EcmaString> handleStr2(JSTaggedValue::ToString(thread, handleMsg2));
343    JSHandle<JSTaggedValue> result2 = parser2.Parse(handleStr2);
344    EXPECT_NE(result2.GetTaggedValue(), JSTaggedValue::Exception());
345
346    ParseOptions options3;
347    options3.bigIntMode = BigIntMode::ALWAYS_PARSE_AS_BIGINT;
348    Utf8JsonParser parser3(thread, TransformType::SENDABLE, options3);
349    JSHandle<JSTaggedValue> handleMsg3(factory->NewFromASCII(R"({"large":1122334455667788999})"));
350    JSHandle<EcmaString> handleStr3(JSTaggedValue::ToString(thread, handleMsg3));
351    JSHandle<JSTaggedValue> result3 = parser3.Parse(handleStr3);
352    EXPECT_NE(result3.GetTaggedValue(), JSTaggedValue::Exception());
353}
354
355HWTEST_F_L0(AsonParserTest, Parser_017)
356{
357    ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
358    ParseOptions options;
359    options.returnType = ParseReturnType::MAP;
360    Utf8JsonParser parser(thread, TransformType::SENDABLE, options);
361
362    JSHandle<JSTaggedValue> handleMsg1(factory->NewFromASCII(R"({})"));
363    JSHandle<EcmaString> handleStr1(JSTaggedValue::ToString(thread, handleMsg1));
364    JSHandle<JSTaggedValue> result1 = parser.Parse(handleStr1);
365    EXPECT_NE(result1.GetTaggedValue(), JSTaggedValue::Exception());
366
367    JSHandle<JSTaggedValue> handleMsg2(factory->NewFromASCII(R"({"innerEntry""entry"})"));
368    JSHandle<EcmaString> handleStr2(JSTaggedValue::ToString(thread, handleMsg2));
369    JSHandle<JSTaggedValue> result2 = parser.Parse(handleStr2);
370    EXPECT_EQ(result2.GetTaggedValue(), JSTaggedValue::Exception());
371
372    JSHandle<JSTaggedValue> handleMsg3(factory->NewFromASCII(R"({"innerEntry"})"));
373    JSHandle<EcmaString> handleStr3(JSTaggedValue::ToString(thread, handleMsg3));
374    JSHandle<JSTaggedValue> result3 = parser.Parse(handleStr3);
375    EXPECT_EQ(result3.GetTaggedValue(), JSTaggedValue::Exception());
376
377    JSHandle<JSTaggedValue> handleMsg4(factory->NewFromASCII(R"({)"));
378    JSHandle<EcmaString> handleStr4(JSTaggedValue::ToString(thread, handleMsg4));
379    JSHandle<JSTaggedValue> result4 = parser.Parse(handleStr4);
380    EXPECT_EQ(result4.GetTaggedValue(), JSTaggedValue::Exception());
381}
382
383HWTEST_F_L0(AsonParserTest, Parser_018)
384{
385    ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
386    ParseOptions options;
387    options.returnType = ParseReturnType::MAP;
388    Utf8JsonParser parser(thread, TransformType::NORMAL, options);
389
390    JSHandle<JSTaggedValue> handleMsg1(factory->NewFromASCII(R"({})"));
391    JSHandle<EcmaString> handleStr1(JSTaggedValue::ToString(thread, handleMsg1));
392    JSHandle<JSTaggedValue> result1 = parser.Parse(handleStr1);
393    EXPECT_NE(result1.GetTaggedValue(), JSTaggedValue::Exception());
394
395    JSHandle<JSTaggedValue> handleMsg2(
396        factory->NewFromASCII(R"({"innerEntry": {"array": [1, 2, 3]}, "x": 1, "str": "outerStr"})"));
397    JSHandle<EcmaString> handleStr2(JSTaggedValue::ToString(thread, handleMsg2));
398    JSHandle<JSTaggedValue> result2 = parser.Parse(handleStr2);
399    EXPECT_NE(result2.GetTaggedValue(), JSTaggedValue::Exception());
400}
401
402HWTEST_F_L0(AsonParserTest, Parser_019)
403{
404    ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
405    ParseOptions options;
406    options.bigIntMode = BigIntMode::PARSE_AS_BIGINT;
407    Utf8JsonParser parser(thread, TransformType::NORMAL, options);
408
409    JSHandle<JSTaggedValue> handleMsg1(factory->NewFromASCII(R"({"shortExp":1.79e+308})"));
410    JSHandle<EcmaString> handleStr1(JSTaggedValue::ToString(thread, handleMsg1));
411    JSHandle<JSTaggedValue> result1 = parser.Parse(handleStr1);
412    EXPECT_NE(result1.GetTaggedValue(), JSTaggedValue::Exception());
413
414    JSHandle<JSTaggedValue> handleMsg2(
415        factory->NewFromASCII(R"({"longExp":1.7976931348623157e+308})"));
416    JSHandle<EcmaString> handleStr2(JSTaggedValue::ToString(thread, handleMsg2));
417    JSHandle<JSTaggedValue> result2 = parser.Parse(handleStr2);
418    EXPECT_NE(result2.GetTaggedValue(), JSTaggedValue::Exception());
419}
420
421HWTEST_F_L0(AsonParserTest, Parser_020)
422{
423    ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
424    ParseOptions options;
425    options.returnType = ParseReturnType::MAP;
426    Utf8JsonParser parser(thread, TransformType::SENDABLE, options);
427
428    JSHandle<JSTaggedValue> handleMsg(
429        factory->NewFromASCII(R"({"innerEntry": {"array": [1, 2, 3]}, "x": 1, "str": "outerStr"})"));
430    JSHandle<EcmaString> handleStr(JSTaggedValue::ToString(thread, handleMsg));
431    JSHandle<JSTaggedValue> result = parser.Parse(handleStr);
432    EXPECT_NE(result.GetTaggedValue(), JSTaggedValue::Exception());
433}
434
435} // namespace panda::test
436