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 
21 using namespace panda::ecmascript;
22 using namespace panda::ecmascript::base;
23 
24 namespace panda::test {
25 class AsonParserTest : public BaseTestWithScope<false> {
26 public:
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 
CheckSendableConstraint(JSTaggedValue value) const32     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 
CheckSendableProps(JSTaggedValue value, TaggedObject *obj) const61     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 
HWTEST_F_L0(AsonParserTest, Parser_001)95 HWTEST_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 
HWTEST_F_L0(AsonParserTest, Parser_002)121 HWTEST_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 
HWTEST_F_L0(AsonParserTest, Parser_003)150 HWTEST_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 
HWTEST_F_L0(AsonParserTest, Parser_004)163 HWTEST_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 
HWTEST_F_L0(AsonParserTest, Parser_005)174 HWTEST_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 
HWTEST_F_L0(AsonParserTest, Parser_006)184 HWTEST_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 
HWTEST_F_L0(AsonParserTest, Parser_007)192 HWTEST_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 
HWTEST_F_L0(AsonParserTest, Parser_008)202 HWTEST_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 
HWTEST_F_L0(AsonParserTest, Parser_009)215 HWTEST_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 
HWTEST_F_L0(AsonParserTest, Parser_010)226 HWTEST_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 
HWTEST_F_L0(AsonParserTest, Parser_011)237 HWTEST_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 
HWTEST_F_L0(AsonParserTest, Parser_012)248 HWTEST_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 
HWTEST_F_L0(AsonParserTest, Parser_013)260 HWTEST_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 
HWTEST_F_L0(AsonParserTest, Parser_014)274 HWTEST_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 
HWTEST_F_L0(AsonParserTest, Parser_015)295 HWTEST_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 
HWTEST_F_L0(AsonParserTest, Parser_016)326 HWTEST_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 
HWTEST_F_L0(AsonParserTest, Parser_017)355 HWTEST_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 
HWTEST_F_L0(AsonParserTest, Parser_018)383 HWTEST_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 
HWTEST_F_L0(AsonParserTest, Parser_019)402 HWTEST_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 
HWTEST_F_L0(AsonParserTest, Parser_020)421 HWTEST_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