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/builtins/builtins_errors.h"
17 
18 #include "ecmascript/base/error_helper.h"
19 #include "ecmascript/ecma_string.h"
20 #include "ecmascript/ecma_vm.h"
21 #include "ecmascript/global_env.h"
22 
23 #include "ecmascript/js_handle.h"
24 #include "ecmascript/js_hclass.h"
25 #include "ecmascript/js_object-inl.h"
26 #include "ecmascript/js_tagged_value-inl.h"
27 
28 #include "ecmascript/js_thread.h"
29 #include "ecmascript/object_factory.h"
30 #include "ecmascript/tests/test_helper.h"
31 
32 using namespace panda::ecmascript;
33 using namespace panda::ecmascript::builtins;
34 
35 namespace panda::test {
36 using Error = ecmascript::builtins::BuiltinsError;
37 using RangeError = builtins::BuiltinsRangeError;
38 using ReferenceError = builtins::BuiltinsReferenceError;
39 using TypeError = builtins::BuiltinsTypeError;
40 using URIError = builtins::BuiltinsURIError;
41 using EvalError = builtins::BuiltinsEvalError;
42 using SyntaxError = builtins::BuiltinsSyntaxError;
43 using AggregateError = builtins::BuiltinsAggregateError;
44 using JSType = ecmascript::JSType;
45 
46 class BuiltinsErrorsTest : public BaseTestWithScope<false> {
47 };
48 
49 /*
50  * @tc.name: GetJSErrorObject
51  * @tc.desc: get JSError Object
52  * @tc.type: FUNC
53  */
HWTEST_F_L0(BuiltinsErrorsTest, GetJSErrorObject)54 HWTEST_F_L0(BuiltinsErrorsTest, GetJSErrorObject)
55 {
56     /**
57      * @tc.steps: step1. Create JSError object
58      */
59     ObjectFactory *factory = instance->GetFactory();
60 
61     JSHandle<JSObject> handleObj = factory->GetJSError(ErrorType::TYPE_ERROR);
62     JSHandle<JSTaggedValue> msgKey(factory->NewFromASCII("message"));
63     JSHandle<JSTaggedValue> nameKey = thread->GlobalConstants()->GetHandledNameString();
64 
65     /**
66      * @tc.steps: step2. obtain JSError object prototype chain name property and message property
67      */
68     JSHandle<JSTaggedValue> msgValue(
69         JSObject::GetProperty(thread, JSHandle<JSTaggedValue>(handleObj), msgKey).GetValue());
70     EXPECT_EQ(EcmaStringAccessor::Compare(instance,
71         JSHandle<EcmaString>(msgValue), factory->NewFromASCII("")), 0);
72     JSHandle<JSTaggedValue> nameValue(
73         JSObject::GetProperty(thread, JSHandle<JSTaggedValue>(handleObj), nameKey).GetValue());
74     ASSERT_EQ(EcmaStringAccessor::Compare(instance,
75         factory->NewFromASCII("TypeError"), JSHandle<EcmaString>(nameValue)), 0);
76 }
77 
78 /*
79  * @tc.name: GetJSErrorWithMessage
80  * @tc.desc: Obtains the TypeError object.
81  * @tc.type: FUNC
82  */
HWTEST_F_L0(BuiltinsErrorsTest, GetJSErrorWithMessage)83 HWTEST_F_L0(BuiltinsErrorsTest, GetJSErrorWithMessage)
84 {
85     ObjectFactory *factory = instance->GetFactory();
86 
87     JSHandle<JSObject> handleObj = factory->GetJSError(ErrorType::TYPE_ERROR, "I am type error");
88     JSHandle<JSTaggedValue> msgKey(factory->NewFromASCII("message"));
89     JSHandle<JSTaggedValue> nameKey = thread->GlobalConstants()->GetHandledNameString();
90     JSHandle<JSTaggedValue> msgValue(
91         JSObject::GetProperty(thread, JSHandle<JSTaggedValue>(handleObj), msgKey).GetValue());
92     ASSERT_EQ(EcmaStringAccessor::Compare(instance,
93         factory->NewFromASCII("I am type error"), JSHandle<EcmaString>(msgValue)), 0);
94     JSHandle<JSTaggedValue> nameValue(
95         JSObject::GetProperty(thread, JSHandle<JSTaggedValue>(handleObj), nameKey).GetValue());
96     ASSERT_EQ(EcmaStringAccessor::Compare(instance,
97         factory->NewFromASCII("TypeError"), JSHandle<EcmaString>(nameValue)), 0);
98 }
99 
100 /*
101  * @tc.name: ErrorNoParameterConstructor
102  * @tc.desc: new Error()
103  * @tc.type: FUNC
104  */
HWTEST_F_L0(BuiltinsErrorsTest, ErrorNoParameterConstructor)105 HWTEST_F_L0(BuiltinsErrorsTest, ErrorNoParameterConstructor)
106 {
107     ObjectFactory *factory = instance->GetFactory();
108     JSHandle<GlobalEnv> env = instance->GetGlobalEnv();
109 
110     JSHandle<JSFunction> error(env->GetErrorFunction());
111 
112     auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue(*error), 4);
113     ecmaRuntimeCallInfo->SetFunction(error.GetTaggedValue());
114     ecmaRuntimeCallInfo->SetThis(JSTaggedValue(*error));
115 
116     [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo);
117     JSTaggedValue result = Error::ErrorConstructor(ecmaRuntimeCallInfo);
118 
119     EXPECT_TRUE(result.IsECMAObject());
120 
121     JSHandle<JSTaggedValue> errorObject(thread, reinterpret_cast<TaggedObject *>(result.GetRawData()));
122     JSHandle<JSTaggedValue> msgKey(factory->NewFromASCII("message"));
123     JSHandle<JSTaggedValue> nameKey = thread->GlobalConstants()->GetHandledNameString();
124 
125     JSHandle<JSTaggedValue> msgValue(JSObject::GetProperty(thread, errorObject, msgKey).GetValue());
126     ASSERT_EQ(EcmaStringAccessor::Compare(instance,
127         factory->NewFromASCII(""), JSHandle<EcmaString>(msgValue)), 0);
128 
129     JSHandle<JSTaggedValue> nameValue(JSObject::GetProperty(thread, errorObject, nameKey).GetValue());
130     ASSERT_EQ(EcmaStringAccessor::Compare(instance,
131         factory->NewFromASCII("Error"), JSHandle<EcmaString>(nameValue)), 0);
132 }
133 
134 /*
135  * @tc.name: ErrorParameterConstructor
136  * @tc.desc: new Error("Hello Error!")
137  * @tc.type: FUNC
138  */
HWTEST_F_L0(BuiltinsErrorsTest, ErrorParameterConstructor)139 HWTEST_F_L0(BuiltinsErrorsTest, ErrorParameterConstructor)
140 {
141     ObjectFactory *factory = instance->GetFactory();
142     JSHandle<GlobalEnv> env = instance->GetGlobalEnv();
143 
144     JSHandle<JSFunction> error(env->GetErrorFunction());
145     JSHandle<JSTaggedValue> paramMsg(factory->NewFromASCII("Hello Error!"));
146 
147     auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue(*error), 6);
148     ecmaRuntimeCallInfo->SetFunction(error.GetTaggedValue());
149     ecmaRuntimeCallInfo->SetThis(JSTaggedValue(*error));
150     ecmaRuntimeCallInfo->SetCallArg(0, paramMsg.GetTaggedValue());
151 
152     [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo);
153     JSTaggedValue result = Error::ErrorConstructor(ecmaRuntimeCallInfo);
154 
155     EXPECT_TRUE(result.IsECMAObject());
156 
157     JSHandle<JSTaggedValue> errorObject(thread, reinterpret_cast<TaggedObject *>(result.GetRawData()));
158     JSHandle<JSTaggedValue> msgKey(factory->NewFromASCII("message"));
159     JSHandle<JSTaggedValue> nameKey = thread->GlobalConstants()->GetHandledNameString();
160     JSHandle<JSTaggedValue> msgValue(JSObject::GetProperty(thread, errorObject, msgKey).GetValue());
161 
162     ASSERT_EQ(EcmaStringAccessor::Compare(instance,
163         factory->NewFromASCII("Hello Error!"), JSHandle<EcmaString>(msgValue)), 0);
164 
165     JSHandle<JSTaggedValue> nameValue(JSObject::GetProperty(thread, errorObject, nameKey).GetValue());
166     ASSERT_EQ(EcmaStringAccessor::Compare(instance,
167         factory->NewFromASCII("Error"), JSHandle<EcmaString>(nameValue)), 0);
168 }
169 
170 /*
171  * @tc.name: ErrorNoParameterToString
172  * @tc.desc: new Error().toString()
173  * @tc.type: FUNC
174  */
HWTEST_F_L0(BuiltinsErrorsTest, ErrorNoParameterToString)175 HWTEST_F_L0(BuiltinsErrorsTest, ErrorNoParameterToString)
176 {
177     ObjectFactory *factory = instance->GetFactory();
178     JSHandle<GlobalEnv> env = instance->GetGlobalEnv();
179 
180     JSHandle<JSTaggedValue> errorObject = env->GetErrorFunction();
181     JSHandle<JSObject> error = factory->NewJSObjectByConstructor(JSHandle<JSFunction>(errorObject), errorObject);
182 
183     auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 4);
184     ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
185     ecmaRuntimeCallInfo->SetThis(JSTaggedValue(*error));
186 
187     [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo);
188     JSTaggedValue result = Error::ToString(ecmaRuntimeCallInfo);
189 
190     JSHandle<EcmaString> resultHandle(thread, reinterpret_cast<EcmaString *>(result.GetRawData()));
191     EXPECT_TRUE(result.IsString());
192     EXPECT_EQ(EcmaStringAccessor::Compare(instance, factory->NewFromASCII("Error"), resultHandle), 0);
193 }
194 
195 /*
196  * @tc.name: ErrorToString
197  * @tc.desc: new Error("This is Error!").toString()
198  * @tc.type: FUNC
199  */
HWTEST_F_L0(BuiltinsErrorsTest, ErrorToString)200 HWTEST_F_L0(BuiltinsErrorsTest, ErrorToString)
201 {
202     ObjectFactory *factory = instance->GetFactory();
203     JSHandle<GlobalEnv> env = instance->GetGlobalEnv();
204 
205     JSHandle<JSTaggedValue> errorObject = env->GetErrorFunction();
206     JSHandle<JSObject> error = factory->NewJSObjectByConstructor(JSHandle<JSFunction>(errorObject), errorObject);
207 
208     JSHandle<JSTaggedValue> handleMsgKey(factory->NewFromASCII("message"));
209     JSObject::SetProperty(
210         thread, JSHandle<JSTaggedValue>(error), handleMsgKey,
211         JSHandle<JSTaggedValue>(thread, factory->NewFromASCII("This is Error!").GetTaggedValue()));
212 
213     auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 4);
214     ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
215     ecmaRuntimeCallInfo->SetThis(JSTaggedValue(*error));
216 
217     [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo);
218     JSTaggedValue result = Error::ToString(ecmaRuntimeCallInfo);
219 
220     JSHandle<EcmaString> resultHandle(thread, reinterpret_cast<EcmaString *>(result.GetRawData()));
221     EXPECT_TRUE(result.IsString());
222     EXPECT_EQ(EcmaStringAccessor::Compare(instance, factory->NewFromASCII("Error: This is Error!"), resultHandle), 0);
223 }
224 
225 /*
226  * @tc.name: RangeErrorNoParameterConstructor
227  * @tc.desc: new RangeError()
228  * @tc.type: FUNC
229  */
HWTEST_F_L0(BuiltinsErrorsTest, RangeErrorNoParameterConstructor)230 HWTEST_F_L0(BuiltinsErrorsTest, RangeErrorNoParameterConstructor)
231 {
232     ObjectFactory *factory = instance->GetFactory();
233     JSHandle<GlobalEnv> env = instance->GetGlobalEnv();
234 
235     JSHandle<JSFunction> error(env->GetRangeErrorFunction());
236 
237     auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 4);
238     ecmaRuntimeCallInfo->SetFunction(error.GetTaggedValue());
239     ecmaRuntimeCallInfo->SetThis(JSTaggedValue(*error));
240 
241     [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo);
242     JSTaggedValue result = RangeError::RangeErrorConstructor(ecmaRuntimeCallInfo);
243 
244     EXPECT_TRUE(result.IsECMAObject());
245 
246     JSHandle<JSTaggedValue> errorObject(thread, reinterpret_cast<TaggedObject *>(result.GetRawData()));
247     JSHandle<JSTaggedValue> msgKey(factory->NewFromASCII("message"));
248     JSHandle<JSTaggedValue> nameKey = thread->GlobalConstants()->GetHandledNameString();
249 
250     JSHandle<JSTaggedValue> msgValue(JSObject::GetProperty(thread, errorObject, msgKey).GetValue());
251     ASSERT_EQ(EcmaStringAccessor::Compare(instance,
252         factory->NewFromASCII(""), JSHandle<EcmaString>(msgValue)), 0);
253     JSHandle<JSTaggedValue> nameValue(JSObject::GetProperty(thread, errorObject, nameKey).GetValue());
254     ASSERT_EQ(EcmaStringAccessor::Compare(instance,
255         factory->NewFromASCII("RangeError"), JSHandle<EcmaString>(nameValue)), 0);
256 }
257 
258 /*
259  * @tc.name: RangeErrorParameterConstructor
260  * @tc.desc: new RangeError("Hello RangeError!")
261  * @tc.type: FUNC
262  */
HWTEST_F_L0(BuiltinsErrorsTest, RangeErrorParameterConstructor)263 HWTEST_F_L0(BuiltinsErrorsTest, RangeErrorParameterConstructor)
264 {
265     ObjectFactory *factory = instance->GetFactory();
266     JSHandle<GlobalEnv> env = instance->GetGlobalEnv();
267 
268     JSHandle<JSFunction> error(env->GetRangeErrorFunction());
269     JSHandle<JSTaggedValue> paramMsg(factory->NewFromASCII("Hello RangeError!"));
270 
271     auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue(*error), 6);
272     ecmaRuntimeCallInfo->SetFunction(error.GetTaggedValue());
273     ecmaRuntimeCallInfo->SetThis(JSTaggedValue(*error));
274     ecmaRuntimeCallInfo->SetCallArg(0, paramMsg.GetTaggedValue());
275 
276     [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo);
277     JSTaggedValue result = RangeError::RangeErrorConstructor(ecmaRuntimeCallInfo);
278 
279     EXPECT_TRUE(result.IsECMAObject());
280 
281     JSHandle<JSTaggedValue> errorObject(thread, reinterpret_cast<TaggedObject *>(result.GetRawData()));
282     JSHandle<JSTaggedValue> msgKey(factory->NewFromASCII("message"));
283     JSHandle<JSTaggedValue> nameKey = thread->GlobalConstants()->GetHandledNameString();
284 
285     JSHandle<JSTaggedValue> msgValue(JSObject::GetProperty(thread, errorObject, msgKey).GetValue());
286     ASSERT_EQ(EcmaStringAccessor::Compare(instance,
287         factory->NewFromASCII("Hello RangeError!"), JSHandle<EcmaString>(msgValue)), 0);
288 
289     JSHandle<JSTaggedValue> nameValue(JSObject::GetProperty(thread, errorObject, nameKey).GetValue());
290     ASSERT_EQ(EcmaStringAccessor::Compare(instance,
291         factory->NewFromASCII("RangeError"), JSHandle<EcmaString>(nameValue)), 0);
292 }
293 
294 /*
295  * @tc.name: RangeErrorNoParameterToString
296  * @tc.desc: new RangeError().toString()
297  * @tc.type: FUNC
298  */
HWTEST_F_L0(BuiltinsErrorsTest, RangeErrorNoParameterToString)299 HWTEST_F_L0(BuiltinsErrorsTest, RangeErrorNoParameterToString)
300 {
301     ObjectFactory *factory = instance->GetFactory();
302     JSHandle<GlobalEnv> env = instance->GetGlobalEnv();
303 
304     JSHandle<JSTaggedValue> errorObject = env->GetRangeErrorFunction();
305     JSHandle<JSObject> error = factory->NewJSObjectByConstructor(JSHandle<JSFunction>(errorObject), errorObject);
306 
307     auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 4);
308     ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
309     ecmaRuntimeCallInfo->SetThis(JSTaggedValue(*error));
310 
311     [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo);
312     JSTaggedValue result = RangeError::ToString(ecmaRuntimeCallInfo);
313     JSHandle<JSTaggedValue> resultHandle(thread, result);
314 
315     EXPECT_TRUE(result.IsString());
316 
317     EXPECT_EQ(EcmaStringAccessor::Compare(instance,
318         factory->NewFromASCII("RangeError"), JSHandle<EcmaString>(resultHandle)), 0);
319 }
320 
321 /*
322  * @tc.name: RangeErrorToString
323  * @tc.desc: new RangeError("This is RangeError!").toString()
324  * @tc.type: FUNC
325  */
HWTEST_F_L0(BuiltinsErrorsTest, RangeErrorToString)326 HWTEST_F_L0(BuiltinsErrorsTest, RangeErrorToString)
327 {
328     ObjectFactory *factory = instance->GetFactory();
329     JSHandle<GlobalEnv> env = instance->GetGlobalEnv();
330 
331     JSHandle<JSTaggedValue> errorObject = env->GetRangeErrorFunction();
332     JSHandle<JSObject> error = factory->NewJSObjectByConstructor(JSHandle<JSFunction>(errorObject), errorObject);
333 
334     JSHandle<JSTaggedValue> handleMsgKey(factory->NewFromASCII("message"));
335     JSObject::SetProperty(thread, JSHandle<JSTaggedValue>(error), handleMsgKey,
336                           JSHandle<JSTaggedValue>(factory->NewFromASCII("This is RangeError!")));
337 
338     auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 4);
339     ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
340     ecmaRuntimeCallInfo->SetThis(JSTaggedValue(*error));
341 
342     [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo);
343     JSTaggedValue result = RangeError::ToString(ecmaRuntimeCallInfo);
344 
345     JSHandle<EcmaString> resultHandle(thread, reinterpret_cast<EcmaString *>(result.GetRawData()));
346     EXPECT_TRUE(result.IsString());
347     EXPECT_EQ(EcmaStringAccessor::Compare(instance,
348         factory->NewFromASCII("RangeError: This is RangeError!"), resultHandle), 0);
349 }
350 
351 // new ReferenceError()
352 /*
353  * @tc.name: ReferenceErrorNoParameterConstructor
354  * @tc.desc: new ReferenceError()
355  * @tc.type: FUNC
356  */
HWTEST_F_L0(BuiltinsErrorsTest, ReferenceErrorNoParameterConstructor)357 HWTEST_F_L0(BuiltinsErrorsTest, ReferenceErrorNoParameterConstructor)
358 {
359     ObjectFactory *factory = instance->GetFactory();
360     JSHandle<GlobalEnv> env = instance->GetGlobalEnv();
361 
362     JSHandle<JSFunction> error(env->GetReferenceErrorFunction());
363 
364     auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue(*error), 4);
365     ecmaRuntimeCallInfo->SetFunction(error.GetTaggedValue());
366     ecmaRuntimeCallInfo->SetThis(JSTaggedValue(*error));
367 
368     [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo);
369     JSTaggedValue result = ReferenceError::ReferenceErrorConstructor(ecmaRuntimeCallInfo);
370     EXPECT_TRUE(result.IsECMAObject());
371 
372     JSHandle<JSTaggedValue> errorObject(thread, reinterpret_cast<TaggedObject *>(result.GetRawData()));
373     JSHandle<JSTaggedValue> msgKey(factory->NewFromASCII("message"));
374     JSHandle<JSTaggedValue> nameKey = thread->GlobalConstants()->GetHandledNameString();
375 
376     JSHandle<JSTaggedValue> msgValue(JSObject::GetProperty(thread, errorObject, msgKey).GetValue());
377     ASSERT_EQ(EcmaStringAccessor::Compare(instance,
378         factory->NewFromASCII(""), JSHandle<EcmaString>(msgValue)), 0);
379 
380     JSHandle<JSTaggedValue> nameValue(JSObject::GetProperty(thread, errorObject, nameKey).GetValue());
381     ASSERT_EQ(EcmaStringAccessor::Compare(instance,
382         factory->NewFromASCII("ReferenceError"), JSHandle<EcmaString>(nameValue)), 0);
383 }
384 
385 /*
386  * @tc.name: ReferenceErrorParameterConstructor
387  * @tc.desc: new ReferenceError("Hello RangeError!")
388  * @tc.type: FUNC
389  */
HWTEST_F_L0(BuiltinsErrorsTest, ReferenceErrorParameterConstructor)390 HWTEST_F_L0(BuiltinsErrorsTest, ReferenceErrorParameterConstructor)
391 {
392     ObjectFactory *factory = instance->GetFactory();
393     JSHandle<GlobalEnv> env = instance->GetGlobalEnv();
394 
395     JSHandle<JSFunction> error(env->GetReferenceErrorFunction());
396     JSHandle<JSTaggedValue> paramMsg(factory->NewFromASCII("Hello ReferenceError!"));
397 
398     auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue(*error), 6);
399     ecmaRuntimeCallInfo->SetFunction(error.GetTaggedValue());
400     ecmaRuntimeCallInfo->SetThis(JSTaggedValue(*error));
401     ecmaRuntimeCallInfo->SetCallArg(0, paramMsg.GetTaggedValue());
402 
403     [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo);
404     JSTaggedValue result = ReferenceError::ReferenceErrorConstructor(ecmaRuntimeCallInfo);
405     EXPECT_TRUE(result.IsECMAObject());
406 
407     JSHandle<JSTaggedValue> errorObject(thread, reinterpret_cast<TaggedObject *>(result.GetRawData()));
408     JSHandle<JSTaggedValue> msgKey(factory->NewFromASCII("message"));
409     JSHandle<JSTaggedValue> nameKey = thread->GlobalConstants()->GetHandledNameString();
410     JSHandle<JSTaggedValue> msgValue(JSObject::GetProperty(thread, errorObject, msgKey).GetValue());
411     ASSERT_EQ(EcmaStringAccessor::Compare(instance,
412         factory->NewFromASCII("Hello ReferenceError!"), JSHandle<EcmaString>(msgValue)), 0);
413 
414     JSHandle<JSTaggedValue> nameValue(JSObject::GetProperty(thread, errorObject, nameKey).GetValue());
415     ASSERT_EQ(EcmaStringAccessor::Compare(instance,
416         factory->NewFromASCII("ReferenceError"), JSHandle<EcmaString>(nameValue)), 0);
417 }
418 
419 /*
420  * @tc.name: ReferenceErrorNoParameterToString
421  * @tc.desc: new ReferenceError().toString()
422  * @tc.type: FUNC
423  */
HWTEST_F_L0(BuiltinsErrorsTest, ReferenceErrorNoParameterToString)424 HWTEST_F_L0(BuiltinsErrorsTest, ReferenceErrorNoParameterToString)
425 {
426     ObjectFactory *factory = instance->GetFactory();
427     JSHandle<GlobalEnv> env = instance->GetGlobalEnv();
428 
429     JSHandle<JSTaggedValue> errorObject = env->GetReferenceErrorFunction();
430     JSHandle<JSObject> error = factory->NewJSObjectByConstructor(JSHandle<JSFunction>(errorObject), errorObject);
431 
432     auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 4);
433     ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
434     ecmaRuntimeCallInfo->SetThis(JSTaggedValue(*error));
435 
436     [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo);
437     JSTaggedValue result = ReferenceError::ToString(ecmaRuntimeCallInfo);
438     JSHandle<EcmaString> resultHandle(thread, reinterpret_cast<EcmaString *>(result.GetRawData()));
439     EXPECT_TRUE(result.IsString());
440     EXPECT_EQ(EcmaStringAccessor::Compare(instance, factory->NewFromASCII("ReferenceError"), resultHandle), 0);
441 }
442 
443 /*
444  * @tc.name: ReferenceErrorToString
445  * @tc.desc: new ReferenceError("This is ReferenceError!").toString()
446  * @tc.type: FUNC
447  */
HWTEST_F_L0(BuiltinsErrorsTest, ReferenceErrorToString)448 HWTEST_F_L0(BuiltinsErrorsTest, ReferenceErrorToString)
449 {
450     ObjectFactory *factory = instance->GetFactory();
451     JSHandle<GlobalEnv> env = instance->GetGlobalEnv();
452 
453     JSHandle<JSTaggedValue> errorObject = env->GetReferenceErrorFunction();
454     JSHandle<JSObject> error = factory->NewJSObjectByConstructor(JSHandle<JSFunction>(errorObject), errorObject);
455 
456     JSHandle<JSTaggedValue> handleMsgKey(factory->NewFromASCII("message"));
457     JSObject::SetProperty(thread, JSHandle<JSTaggedValue>(error), handleMsgKey,
458                           JSHandle<JSTaggedValue>(factory->NewFromASCII("This is ReferenceError!")));
459 
460     auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 4);
461     ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
462     ecmaRuntimeCallInfo->SetThis(JSTaggedValue(*error));
463 
464     [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo);
465     JSTaggedValue result = ReferenceError::ToString(ecmaRuntimeCallInfo);
466     JSHandle<EcmaString> resultHandle(thread, reinterpret_cast<EcmaString *>(result.GetRawData()));
467     EXPECT_TRUE(result.IsString());
468     EXPECT_EQ(EcmaStringAccessor::Compare(instance,
469         factory->NewFromASCII("ReferenceError: This is ReferenceError!"), resultHandle), 0);
470 }
471 
472 /*
473  * @tc.name: TypeErrorNoParameterConstructor
474  * @tc.desc: new TypeError()
475  * @tc.type: FUNC
476  */
HWTEST_F_L0(BuiltinsErrorsTest, TypeErrorNoParameterConstructor)477 HWTEST_F_L0(BuiltinsErrorsTest, TypeErrorNoParameterConstructor)
478 {
479     ObjectFactory *factory = instance->GetFactory();
480     JSHandle<GlobalEnv> env = instance->GetGlobalEnv();
481 
482     JSHandle<JSFunction> error(env->GetTypeErrorFunction());
483 
484     auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue(*error), 4);
485     ecmaRuntimeCallInfo->SetFunction(error.GetTaggedValue());
486     ecmaRuntimeCallInfo->SetThis(JSTaggedValue(*error));
487 
488     [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo);
489     JSTaggedValue result = TypeError::TypeErrorConstructor(ecmaRuntimeCallInfo);
490     EXPECT_TRUE(result.IsECMAObject());
491 
492     JSHandle<JSTaggedValue> errorObject(thread, reinterpret_cast<TaggedObject *>(result.GetRawData()));
493     JSHandle<JSTaggedValue> msgKey(factory->NewFromASCII("message"));
494     JSHandle<JSTaggedValue> nameKey = thread->GlobalConstants()->GetHandledNameString();
495 
496     JSHandle<JSTaggedValue> msgValue(JSObject::GetProperty(thread, errorObject, msgKey).GetValue());
497     ASSERT_EQ(EcmaStringAccessor::Compare(instance,
498         factory->NewFromASCII(""), JSHandle<EcmaString>(msgValue)), 0);
499 
500     JSHandle<JSTaggedValue> nameValue(JSObject::GetProperty(thread, errorObject, nameKey).GetValue());
501     EXPECT_EQ(EcmaStringAccessor::Compare(instance,
502         JSHandle<EcmaString>(nameValue), JSHandle<EcmaString>(nameValue)), 0);
503 }
504 
505 /*
506  * @tc.name: TypeErrorParameterConstructor
507  * @tc.desc: new TypeError("Hello RangeError!")
508  * @tc.type: FUNC
509  */
HWTEST_F_L0(BuiltinsErrorsTest, TypeErrorParameterConstructor)510 HWTEST_F_L0(BuiltinsErrorsTest, TypeErrorParameterConstructor)
511 {
512     ObjectFactory *factory = instance->GetFactory();
513     JSHandle<GlobalEnv> env = instance->GetGlobalEnv();
514 
515     JSHandle<JSFunction> error(env->GetTypeErrorFunction());
516     JSHandle<JSTaggedValue> paramMsg(factory->NewFromASCII("Hello TypeError!"));
517 
518     auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue(*error), 6);
519     ecmaRuntimeCallInfo->SetFunction(error.GetTaggedValue());
520     ecmaRuntimeCallInfo->SetThis(JSTaggedValue(*error));
521     ecmaRuntimeCallInfo->SetCallArg(0, paramMsg.GetTaggedValue());
522 
523     [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo);
524     JSTaggedValue result = TypeError::TypeErrorConstructor(ecmaRuntimeCallInfo);
525     EXPECT_TRUE(result.IsECMAObject());
526 
527     JSHandle<JSTaggedValue> errorObject(thread, reinterpret_cast<TaggedObject *>(result.GetRawData()));
528     JSHandle<JSTaggedValue> msgKey(factory->NewFromASCII("message"));
529     JSHandle<JSTaggedValue> nameKey = thread->GlobalConstants()->GetHandledNameString();
530 
531     JSHandle<JSTaggedValue> msgValue(JSObject::GetProperty(thread, errorObject, msgKey).GetValue());
532     ASSERT_EQ(EcmaStringAccessor::Compare(instance,
533         factory->NewFromASCII("Hello TypeError!"), JSHandle<EcmaString>(msgValue)), 0);
534 
535     JSHandle<JSTaggedValue> nameValue(JSObject::GetProperty(thread, errorObject, nameKey).GetValue());
536     ASSERT_EQ(EcmaStringAccessor::Compare(instance,
537         factory->NewFromASCII("TypeError"), JSHandle<EcmaString>(nameValue)), 0);
538 }
539 
540 /*
541  * @tc.name: TypeErrorNoParameterToString
542  * @tc.desc: new TypeError().toString()
543  * @tc.type: FUNC
544  */
HWTEST_F_L0(BuiltinsErrorsTest, TypeErrorNoParameterToString)545 HWTEST_F_L0(BuiltinsErrorsTest, TypeErrorNoParameterToString)
546 {
547     ObjectFactory *factory = instance->GetFactory();
548     JSHandle<GlobalEnv> env = instance->GetGlobalEnv();
549 
550     JSHandle<JSTaggedValue> errorObject = env->GetTypeErrorFunction();
551     JSHandle<JSObject> error = factory->NewJSObjectByConstructor(JSHandle<JSFunction>(errorObject), errorObject);
552 
553     auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 4);
554     ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
555     ecmaRuntimeCallInfo->SetThis(JSTaggedValue(*error));
556 
557     [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo);
558     JSTaggedValue result = TypeError::ToString(ecmaRuntimeCallInfo);
559     JSHandle<EcmaString> resultHandle(thread, reinterpret_cast<EcmaString *>(result.GetRawData()));
560     EXPECT_TRUE(result.IsString());
561     EXPECT_EQ(EcmaStringAccessor::Compare(instance, factory->NewFromASCII("TypeError"), resultHandle), 0);
562 }
563 
564 /*
565  * @tc.name: TypeErrorToString
566  * @tc.desc: new TypeError("This is TypeError!").toString()
567  * @tc.type: FUNC
568  */
HWTEST_F_L0(BuiltinsErrorsTest, TypeErrorToString)569 HWTEST_F_L0(BuiltinsErrorsTest, TypeErrorToString)
570 {
571     ObjectFactory *factory = instance->GetFactory();
572     JSHandle<GlobalEnv> env = instance->GetGlobalEnv();
573 
574     JSHandle<JSTaggedValue> errorObject = env->GetTypeErrorFunction();
575     JSHandle<JSObject> error = factory->NewJSObjectByConstructor(JSHandle<JSFunction>(errorObject), errorObject);
576 
577     JSHandle<JSTaggedValue> value(factory->NewFromASCII("This is TypeError!"));
578     JSHandle<JSTaggedValue> handleMsgKey(factory->NewFromASCII("message"));
579     JSObject::SetProperty(thread, JSHandle<JSTaggedValue>(error), handleMsgKey, value);
580 
581     auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 4);
582     ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
583     ecmaRuntimeCallInfo->SetThis(JSTaggedValue(*error));
584 
585     [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo);
586     JSTaggedValue result = TypeError::ToString(ecmaRuntimeCallInfo);
587     JSHandle<EcmaString> resultHandle(thread, reinterpret_cast<EcmaString *>(result.GetRawData()));
588     EXPECT_TRUE(result.IsString());
589     EXPECT_EQ(EcmaStringAccessor::Compare(instance,
590         factory->NewFromASCII("TypeError: This is TypeError!"), resultHandle), 0);
591 }
592 
593 /*
594  * @tc.name: URIErrorNoParameterConstructor
595  * @tc.desc: new URIError()
596  * @tc.type: FUNC
597  */
HWTEST_F_L0(BuiltinsErrorsTest, URIErrorNoParameterConstructor)598 HWTEST_F_L0(BuiltinsErrorsTest, URIErrorNoParameterConstructor)
599 {
600     ObjectFactory *factory = instance->GetFactory();
601     JSHandle<GlobalEnv> env = instance->GetGlobalEnv();
602 
603     JSHandle<JSFunction> error(env->GetURIErrorFunction());
604 
605     auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue(*error), 4);
606     ecmaRuntimeCallInfo->SetFunction(error.GetTaggedValue());
607     ecmaRuntimeCallInfo->SetThis(JSTaggedValue(*error));
608 
609     [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo);
610     JSTaggedValue result = URIError::URIErrorConstructor(ecmaRuntimeCallInfo);
611     EXPECT_TRUE(result.IsECMAObject());
612 
613     JSHandle<JSTaggedValue> errorObject(thread, reinterpret_cast<TaggedObject *>(result.GetRawData()));
614     JSHandle<JSTaggedValue> msgKey(factory->NewFromASCII("message"));
615     JSHandle<JSTaggedValue> nameKey = thread->GlobalConstants()->GetHandledNameString();
616 
617     JSHandle<JSTaggedValue> msgValue(JSObject::GetProperty(thread, errorObject, msgKey).GetValue());
618     ASSERT_EQ(EcmaStringAccessor::Compare(instance,
619         factory->NewFromASCII(""), JSHandle<EcmaString>(msgValue)), 0);
620 
621     JSHandle<JSTaggedValue> nameValue(JSObject::GetProperty(thread, errorObject, nameKey).GetValue());
622     ASSERT_EQ(EcmaStringAccessor::Compare(instance,
623         factory->NewFromASCII("URIError"), JSHandle<EcmaString>(nameValue)), 0);
624 }
625 
626 /*
627  * @tc.name: URIErrorParameterConstructor
628  * @tc.desc: new URIError("Hello RangeError!")
629  * @tc.type: FUNC
630  */
HWTEST_F_L0(BuiltinsErrorsTest, URIErrorParameterConstructor)631 HWTEST_F_L0(BuiltinsErrorsTest, URIErrorParameterConstructor)
632 {
633     ObjectFactory *factory = instance->GetFactory();
634     JSHandle<GlobalEnv> env = instance->GetGlobalEnv();
635 
636     JSHandle<JSFunction> error(env->GetURIErrorFunction());
637     JSHandle<JSTaggedValue> paramMsg(factory->NewFromASCII("Hello URIError!"));
638 
639     auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue(*error), 6);
640     ecmaRuntimeCallInfo->SetFunction(error.GetTaggedValue());
641     ecmaRuntimeCallInfo->SetThis(JSTaggedValue(*error));
642     ecmaRuntimeCallInfo->SetCallArg(0, paramMsg.GetTaggedValue());
643 
644     [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo);
645     JSTaggedValue result = URIError::URIErrorConstructor(ecmaRuntimeCallInfo);
646     EXPECT_TRUE(result.IsECMAObject());
647 
648     JSHandle<JSTaggedValue> errorObject(thread, reinterpret_cast<TaggedObject *>(result.GetRawData()));
649     JSHandle<JSTaggedValue> msgKey(factory->NewFromASCII("message"));
650     JSHandle<JSTaggedValue> nameKey = thread->GlobalConstants()->GetHandledNameString();
651 
652     JSHandle<JSTaggedValue> msgValue(JSObject::GetProperty(thread, errorObject, msgKey).GetValue());
653     ASSERT_EQ(EcmaStringAccessor::Compare(instance,
654         factory->NewFromASCII("Hello URIError!"), JSHandle<EcmaString>(msgValue)), 0);
655 
656     JSHandle<JSTaggedValue> nameValue(JSObject::GetProperty(thread, errorObject, nameKey).GetValue());
657     ASSERT_EQ(EcmaStringAccessor::Compare(instance,
658         factory->NewFromASCII("URIError"), JSHandle<EcmaString>(nameValue)), 0);
659 }
660 
661 /*
662  * @tc.name: URIErrorNoParameterToString
663  * @tc.desc: new URIError().toString()
664  * @tc.type: FUNC
665  */
HWTEST_F_L0(BuiltinsErrorsTest, URIErrorNoParameterToString)666 HWTEST_F_L0(BuiltinsErrorsTest, URIErrorNoParameterToString)
667 {
668     ObjectFactory *factory = instance->GetFactory();
669     JSHandle<GlobalEnv> env = instance->GetGlobalEnv();
670 
671     JSHandle<JSTaggedValue> errorObject = env->GetURIErrorFunction();
672     JSHandle<JSObject> error = factory->NewJSObjectByConstructor(JSHandle<JSFunction>(errorObject), errorObject);
673 
674     auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 4);
675     ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
676     ecmaRuntimeCallInfo->SetThis(JSTaggedValue(*error));
677 
678     [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo);
679     JSTaggedValue result = URIError::ToString(ecmaRuntimeCallInfo);
680     JSHandle<EcmaString> resultHandle(thread, reinterpret_cast<EcmaString *>(result.GetRawData()));
681     EXPECT_TRUE(result.IsString());
682 
683     EXPECT_EQ(EcmaStringAccessor::Compare(instance, factory->NewFromASCII("URIError"), resultHandle), 0);
684 }
685 
686 /*
687  * @tc.name: URIErrorToString
688  * @tc.desc: new URIError("This is URIError!").toString()
689  * @tc.type: FUNC
690  */
HWTEST_F_L0(BuiltinsErrorsTest, URIErrorToString)691 HWTEST_F_L0(BuiltinsErrorsTest, URIErrorToString)
692 {
693     ObjectFactory *factory = instance->GetFactory();
694     JSHandle<GlobalEnv> env = instance->GetGlobalEnv();
695 
696     JSHandle<JSTaggedValue> errorObject = env->GetURIErrorFunction();
697     JSHandle<JSObject> error = factory->NewJSObjectByConstructor(JSHandle<JSFunction>(errorObject), errorObject);
698 
699     JSHandle<JSTaggedValue> handleMsgKey(factory->NewFromASCII("message"));
700     JSObject::SetProperty(
701         thread, JSHandle<JSTaggedValue>(error), handleMsgKey,
702         JSHandle<JSTaggedValue>(thread, factory->NewFromASCII("This is URIError!").GetTaggedValue()));
703 
704     auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 4);
705     ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
706     ecmaRuntimeCallInfo->SetThis(JSTaggedValue(*error));
707 
708     [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo);
709     JSTaggedValue result = URIError::ToString(ecmaRuntimeCallInfo);
710     JSHandle<EcmaString> resultHandle(thread, reinterpret_cast<EcmaString *>(result.GetRawData()));
711     EXPECT_TRUE(result.IsString());
712 
713     EXPECT_EQ(EcmaStringAccessor::Compare(instance,
714         factory->NewFromASCII("URIError: This is URIError!"), resultHandle), 0);
715 }
716 
717 /*
718  * @tc.name: SyntaxErrorNoParameterConstructor
719  * @tc.desc: new SyntaxError()
720  * @tc.type: FUNC
721  */
HWTEST_F_L0(BuiltinsErrorsTest, SyntaxErrorNoParameterConstructor)722 HWTEST_F_L0(BuiltinsErrorsTest, SyntaxErrorNoParameterConstructor)
723 {
724     ObjectFactory *factory = instance->GetFactory();
725     JSHandle<GlobalEnv> env = instance->GetGlobalEnv();
726 
727     JSHandle<JSFunction> error(env->GetSyntaxErrorFunction());
728 
729     auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue(*error), 4);
730     ecmaRuntimeCallInfo->SetFunction(error.GetTaggedValue());
731     ecmaRuntimeCallInfo->SetThis(JSTaggedValue(*error));
732 
733     [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo);
734     JSTaggedValue result = SyntaxError::SyntaxErrorConstructor(ecmaRuntimeCallInfo);
735     EXPECT_TRUE(result.IsECMAObject());
736 
737     JSHandle<JSTaggedValue> errorObject(thread, reinterpret_cast<TaggedObject *>(result.GetRawData()));
738     JSHandle<JSTaggedValue> msgKey(factory->NewFromASCII("message"));
739     JSHandle<JSTaggedValue> nameKey = thread->GlobalConstants()->GetHandledNameString();
740 
741     JSHandle<JSTaggedValue> msgValue(JSObject::GetProperty(thread, errorObject, msgKey).GetValue());
742     ASSERT_EQ(EcmaStringAccessor::Compare(instance,
743         factory->NewFromASCII(""), JSHandle<EcmaString>(msgValue)), 0);
744 
745     JSHandle<JSTaggedValue> nameValue(JSObject::GetProperty(thread, errorObject, nameKey).GetValue());
746     ASSERT_EQ(EcmaStringAccessor::Compare(instance,
747         factory->NewFromASCII("SyntaxError"), JSHandle<EcmaString>(nameValue)), 0);
748 }
749 
750 /*
751  * @tc.name: SyntaxErrorParameterConstructor
752  * @tc.desc: new SyntaxError("Hello RangeError!")
753  * @tc.type: FUNC
754  */
HWTEST_F_L0(BuiltinsErrorsTest, SyntaxErrorParameterConstructor)755 HWTEST_F_L0(BuiltinsErrorsTest, SyntaxErrorParameterConstructor)
756 {
757     ObjectFactory *factory = instance->GetFactory();
758     JSHandle<GlobalEnv> env = instance->GetGlobalEnv();
759 
760     JSHandle<JSFunction> error(env->GetSyntaxErrorFunction());
761     JSHandle<JSTaggedValue> paramMsg(factory->NewFromASCII("Hello SyntaxError!"));
762 
763     auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue(*error), 6);
764     ecmaRuntimeCallInfo->SetFunction(error.GetTaggedValue());
765     ecmaRuntimeCallInfo->SetThis(JSTaggedValue(*error));
766     ecmaRuntimeCallInfo->SetCallArg(0, paramMsg.GetTaggedValue());
767 
768     [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo);
769     JSTaggedValue result = SyntaxError::SyntaxErrorConstructor(ecmaRuntimeCallInfo);
770     EXPECT_TRUE(result.IsECMAObject());
771 
772     JSHandle<JSTaggedValue> errorObject(thread, reinterpret_cast<TaggedObject *>(result.GetRawData()));
773     JSHandle<JSTaggedValue> msgKey(factory->NewFromASCII("message"));
774     JSHandle<JSTaggedValue> nameKey = thread->GlobalConstants()->GetHandledNameString();
775 
776     JSHandle<JSTaggedValue> msgValue(JSObject::GetProperty(thread, errorObject, msgKey).GetValue());
777     ASSERT_EQ(EcmaStringAccessor::Compare(instance,
778         factory->NewFromASCII("Hello SyntaxError!"), JSHandle<EcmaString>(msgValue)), 0);
779 
780     JSHandle<JSTaggedValue> nameValue(JSObject::GetProperty(thread, errorObject, nameKey).GetValue());
781     ASSERT_EQ(EcmaStringAccessor::Compare(instance,
782         factory->NewFromASCII("SyntaxError"), JSHandle<EcmaString>(nameValue)), 0);
783 }
784 
785 /*
786  * @tc.name: SyntaxErrorNoParameterToString
787  * @tc.desc: new SyntaxError().toString()
788  * @tc.type: FUNC
789  */
HWTEST_F_L0(BuiltinsErrorsTest, SyntaxErrorNoParameterToString)790 HWTEST_F_L0(BuiltinsErrorsTest, SyntaxErrorNoParameterToString)
791 {
792     ObjectFactory *factory = instance->GetFactory();
793     JSHandle<GlobalEnv> env = instance->GetGlobalEnv();
794 
795     JSHandle<JSTaggedValue> errorObject = env->GetSyntaxErrorFunction();
796     JSHandle<JSObject> error = factory->NewJSObjectByConstructor(JSHandle<JSFunction>(errorObject), errorObject);
797 
798     auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 4);
799     ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
800     ecmaRuntimeCallInfo->SetThis(JSTaggedValue(*error));
801 
802     [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo);
803     JSTaggedValue result = SyntaxError::ToString(ecmaRuntimeCallInfo);
804     JSHandle<EcmaString> resultHandle(thread, reinterpret_cast<EcmaString *>(result.GetRawData()));
805     EXPECT_TRUE(result.IsString());
806 
807     EXPECT_EQ(EcmaStringAccessor::Compare(instance, factory->NewFromASCII("SyntaxError"), resultHandle), 0);
808 }
809 
810 /*
811  * @tc.name: SyntaxErrorToString
812  * @tc.desc: new SyntaxError("This is SyntaxError!").toString()
813  * @tc.type: FUNC
814  */
HWTEST_F_L0(BuiltinsErrorsTest, SyntaxErrorToString)815 HWTEST_F_L0(BuiltinsErrorsTest, SyntaxErrorToString)
816 {
817     ObjectFactory *factory = instance->GetFactory();
818     JSHandle<GlobalEnv> env = instance->GetGlobalEnv();
819 
820     JSHandle<JSTaggedValue> errorObject = env->GetSyntaxErrorFunction();
821     JSHandle<JSObject> error = factory->NewJSObjectByConstructor(JSHandle<JSFunction>(errorObject), errorObject);
822 
823     JSHandle<JSTaggedValue> handleMsgKey(factory->NewFromASCII("message"));
824     JSObject::SetProperty(thread, JSHandle<JSTaggedValue>(error), handleMsgKey,
825                           JSHandle<JSTaggedValue>(factory->NewFromASCII("This is SyntaxError!")));
826 
827     auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 4);
828     ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
829     ecmaRuntimeCallInfo->SetThis(JSTaggedValue(*error));
830 
831     [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo);
832     JSTaggedValue result = SyntaxError::ToString(ecmaRuntimeCallInfo);
833     JSHandle<EcmaString> resultHandle(thread, reinterpret_cast<EcmaString *>(result.GetRawData()));
834     EXPECT_TRUE(result.IsString());
835 
836     EXPECT_EQ(EcmaStringAccessor::Compare(instance,
837         factory->NewFromASCII("SyntaxError: This is SyntaxError!"), resultHandle), 0);
838 }
839 
840 /*
841  * @tc.name: EvalErrorNoParameterConstructor
842  * @tc.desc: new EvalError()
843  * @tc.type: FUNC
844  */
HWTEST_F_L0(BuiltinsErrorsTest, EvalErrorNoParameterConstructor)845 HWTEST_F_L0(BuiltinsErrorsTest, EvalErrorNoParameterConstructor)
846 {
847     ObjectFactory *factory = instance->GetFactory();
848     JSHandle<GlobalEnv> env = instance->GetGlobalEnv();
849 
850     JSHandle<JSFunction> error(env->GetEvalErrorFunction());
851 
852     auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue(*error), 4);
853     ecmaRuntimeCallInfo->SetFunction(error.GetTaggedValue());
854     ecmaRuntimeCallInfo->SetThis(JSTaggedValue(*error));
855 
856     [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo);
857     JSTaggedValue result = EvalError::EvalErrorConstructor(ecmaRuntimeCallInfo);
858     EXPECT_TRUE(result.IsECMAObject());
859 
860     JSHandle<JSTaggedValue> errorObject(thread, reinterpret_cast<TaggedObject *>(result.GetRawData()));
861     JSHandle<JSTaggedValue> msgKey(factory->NewFromASCII("message"));
862     JSHandle<JSTaggedValue> nameKey = thread->GlobalConstants()->GetHandledNameString();
863 
864     JSHandle<JSTaggedValue> msgValue(JSObject::GetProperty(thread, errorObject, msgKey).GetValue());
865     ASSERT_EQ(EcmaStringAccessor::Compare(instance,
866         factory->NewFromASCII(""), JSHandle<EcmaString>(msgValue)), 0);
867 
868     JSHandle<JSTaggedValue> nameValue(JSObject::GetProperty(thread, errorObject, nameKey).GetValue());
869     ASSERT_EQ(EcmaStringAccessor::Compare(instance,
870         factory->NewFromASCII("EvalError"), JSHandle<EcmaString>(nameValue)), 0);
871 }
872 
873 /*
874  * @tc.name: EvalErrorParameterConstructor
875  * @tc.desc: new EvalError("Hello RangeError!")
876  * @tc.type: FUNC
877  */
HWTEST_F_L0(BuiltinsErrorsTest, EvalErrorParameterConstructor)878 HWTEST_F_L0(BuiltinsErrorsTest, EvalErrorParameterConstructor)
879 {
880     ObjectFactory *factory = instance->GetFactory();
881     JSHandle<GlobalEnv> env = instance->GetGlobalEnv();
882 
883     JSHandle<JSFunction> error(env->GetEvalErrorFunction());
884     JSHandle<JSTaggedValue> paramMsg(factory->NewFromASCII("Hello EvalError!"));
885 
886     auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue(*error), 6);
887     ecmaRuntimeCallInfo->SetFunction(error.GetTaggedValue());
888     ecmaRuntimeCallInfo->SetThis(JSTaggedValue(*error));
889     ecmaRuntimeCallInfo->SetCallArg(0, paramMsg.GetTaggedValue());
890 
891     [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo);
892     JSTaggedValue result = EvalError::EvalErrorConstructor(ecmaRuntimeCallInfo);
893     EXPECT_TRUE(result.IsECMAObject());
894 
895     JSHandle<JSTaggedValue> errorObject(thread, reinterpret_cast<TaggedObject *>(result.GetRawData()));
896     JSHandle<JSTaggedValue> msgKey(factory->NewFromASCII("message"));
897     JSHandle<JSTaggedValue> nameKey = thread->GlobalConstants()->GetHandledNameString();
898 
899     JSHandle<JSTaggedValue> msgValue(JSObject::GetProperty(thread, errorObject, msgKey).GetValue());
900     ASSERT_EQ(EcmaStringAccessor::Compare(instance,
901         factory->NewFromASCII("Hello EvalError!"), JSHandle<EcmaString>(msgValue)), 0);
902 
903     JSHandle<JSTaggedValue> nameValue(JSObject::GetProperty(thread, errorObject, nameKey).GetValue());
904     ASSERT_EQ(EcmaStringAccessor::Compare(instance,
905         factory->NewFromASCII("EvalError"), JSHandle<EcmaString>(nameValue)), 0);
906 }
907 
908 /*
909  * @tc.name: EvalErrorNoParameterToString
910  * @tc.desc: new EvalError().toString()
911  * @tc.type: FUNC
912  */
HWTEST_F_L0(BuiltinsErrorsTest, EvalErrorNoParameterToString)913 HWTEST_F_L0(BuiltinsErrorsTest, EvalErrorNoParameterToString)
914 {
915     ObjectFactory *factory = instance->GetFactory();
916     JSHandle<GlobalEnv> env = instance->GetGlobalEnv();
917     JSHandle<JSTaggedValue> errorObject = env->GetEvalErrorFunction();
918     JSHandle<JSObject> error = factory->NewJSObjectByConstructor(JSHandle<JSFunction>(errorObject), errorObject);
919 
920     auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 4);
921     ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
922     ecmaRuntimeCallInfo->SetThis(JSTaggedValue(*error));
923 
924     [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo);
925     JSTaggedValue result = EvalError::ToString(ecmaRuntimeCallInfo);
926     JSHandle<EcmaString> resultHandle(thread, reinterpret_cast<EcmaString *>(result.GetRawData()));
927     EXPECT_TRUE(result.IsString());
928     EXPECT_EQ(EcmaStringAccessor::Compare(instance, factory->NewFromASCII("EvalError"), resultHandle), 0);
929 }
930 
931 /*
932  * @tc.name: EvalErrorToString
933  * @tc.desc: new EvalError("This is EvalError!").toString()
934  * @tc.type: FUNC
935  */
HWTEST_F_L0(BuiltinsErrorsTest, EvalErrorToString)936 HWTEST_F_L0(BuiltinsErrorsTest, EvalErrorToString)
937 {
938     ObjectFactory *factory = instance->GetFactory();
939     JSHandle<GlobalEnv> env = instance->GetGlobalEnv();
940 
941     JSHandle<JSTaggedValue> errorObject = env->GetEvalErrorFunction();
942     JSHandle<JSObject> error = factory->NewJSObjectByConstructor(JSHandle<JSFunction>(errorObject), errorObject);
943 
944     JSHandle<JSTaggedValue> handleMsgKey(factory->NewFromASCII("message"));
945     JSObject::SetProperty(
946         thread, JSHandle<JSTaggedValue>(error), handleMsgKey,
947         JSHandle<JSTaggedValue>(thread, factory->NewFromASCII("This is EvalError!").GetTaggedValue()));
948 
949     auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 4);
950     ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
951     ecmaRuntimeCallInfo->SetThis(JSTaggedValue(*error));
952 
953     [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo);
954     JSTaggedValue result = EvalError::ToString(ecmaRuntimeCallInfo);
955     JSHandle<EcmaString> resultHandle(thread, reinterpret_cast<EcmaString *>(result.GetRawData()));
956     EXPECT_TRUE(result.IsString());
957     EXPECT_EQ(EcmaStringAccessor::Compare(instance,
958         factory->NewFromASCII("EvalError: This is EvalError!"), resultHandle), 0);
959 }
960 
961 /*
962  * @tc.name: AggregateErrorParameterConstructor
963  * @tc.desc: new AggregateError([], "Hello AggregateError", {cause: "error cause"})
964  * @tc.type: FUNC
965  */
HWTEST_F_L0(BuiltinsErrorsTest, AggregateErrorParameterConstructor)966 HWTEST_F_L0(BuiltinsErrorsTest, AggregateErrorParameterConstructor)
967 {
968     ObjectFactory *factory = instance->GetFactory();
969     JSHandle<GlobalEnv> env = instance->GetGlobalEnv();
970 
971     JSHandle<JSFunction> error(env->GetAggregateErrorFunction());
972     JSHandle<JSTaggedValue> paramMsg(factory->NewFromASCII("Hello AggregateError!"));
973 
974     JSHandle<JSTaggedValue> errayFunc = env->GetArrayFunction();
975     JSHandle<JSObject> newArray = factory->NewJSObjectByConstructor(JSHandle<JSFunction>(errayFunc), errayFunc);
976 
977     JSHandle<JSTaggedValue> causeKey = thread->GlobalConstants()->GetHandledCauseString();
978     JSHandle<JSTaggedValue> objFun = env->GetObjectFunction();
979     JSHandle<JSObject> optionsObj = factory->NewJSObjectByConstructor(JSHandle<JSFunction>(objFun), objFun);
980     JSHandle<JSTaggedValue> causeValue(factory->NewFromASCII("error cause")); // test error cause
981     JSObject::SetProperty(thread, optionsObj, causeKey, causeValue);
982 
983     auto ecmaRuntimeCallInfo =
984         TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue(*error), 10); // 10 means 3 call args
985     ecmaRuntimeCallInfo->SetFunction(error.GetTaggedValue());
986     ecmaRuntimeCallInfo->SetThis(JSTaggedValue(*error));
987     ecmaRuntimeCallInfo->SetCallArg(0, newArray.GetTaggedValue());
988     ecmaRuntimeCallInfo->SetCallArg(1, paramMsg.GetTaggedValue());
989     ecmaRuntimeCallInfo->SetCallArg(2, optionsObj.GetTaggedValue()); // 2 means the options arg
990 
991     [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo);
992     JSTaggedValue result = AggregateError::AggregateErrorConstructor(ecmaRuntimeCallInfo);
993     EXPECT_TRUE(result.IsECMAObject());
994 
995     JSHandle<JSTaggedValue> errorObject(thread, reinterpret_cast<TaggedObject *>(result.GetRawData()));
996     JSHandle<JSTaggedValue> msgKey(factory->NewFromASCII("message"));
997     JSHandle<JSTaggedValue> nameKey = thread->GlobalConstants()->GetHandledNameString();
998 
999     JSHandle<JSTaggedValue> msgValue(JSObject::GetProperty(thread, errorObject, msgKey).GetValue());
1000     ASSERT_EQ(EcmaStringAccessor::Compare(instance,
1001         factory->NewFromASCII("Hello AggregateError!"), JSHandle<EcmaString>(msgValue)), 0);
1002 
1003     JSHandle<JSTaggedValue> nameValue(JSObject::GetProperty(thread, errorObject, nameKey).GetValue());
1004     ASSERT_EQ(EcmaStringAccessor::Compare(instance,
1005         factory->NewFromASCII("AggregateError"), JSHandle<EcmaString>(nameValue)), 0);
1006 
1007     JSHandle<JSTaggedValue> errCauseValue(JSObject::GetProperty(thread, errorObject, causeKey).GetValue());
1008     ASSERT_EQ(EcmaStringAccessor::Compare(instance,
1009         factory->NewFromASCII("error cause"), JSHandle<EcmaString>(errCauseValue)), 0);
1010 }
1011 }  // namespace panda::test
1012