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
32using namespace panda::ecmascript;
33using namespace panda::ecmascript::builtins;
34
35namespace panda::test {
36using Error = ecmascript::builtins::BuiltinsError;
37using RangeError = builtins::BuiltinsRangeError;
38using ReferenceError = builtins::BuiltinsReferenceError;
39using TypeError = builtins::BuiltinsTypeError;
40using URIError = builtins::BuiltinsURIError;
41using EvalError = builtins::BuiltinsEvalError;
42using SyntaxError = builtins::BuiltinsSyntaxError;
43using AggregateError = builtins::BuiltinsAggregateError;
44using JSType = ecmascript::JSType;
45
46class BuiltinsErrorsTest : public BaseTestWithScope<false> {
47};
48
49/*
50 * @tc.name: GetJSErrorObject
51 * @tc.desc: get JSError Object
52 * @tc.type: FUNC
53 */
54HWTEST_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 */
83HWTEST_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 */
105HWTEST_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 */
139HWTEST_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 */
175HWTEST_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 */
200HWTEST_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 */
230HWTEST_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 */
263HWTEST_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 */
299HWTEST_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 */
326HWTEST_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 */
357HWTEST_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 */
390HWTEST_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 */
424HWTEST_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 */
448HWTEST_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 */
477HWTEST_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 */
510HWTEST_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 */
545HWTEST_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 */
569HWTEST_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 */
598HWTEST_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 */
631HWTEST_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 */
666HWTEST_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 */
691HWTEST_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 */
722HWTEST_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 */
755HWTEST_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 */
790HWTEST_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 */
815HWTEST_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 */
845HWTEST_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 */
878HWTEST_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 */
913HWTEST_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 */
936HWTEST_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 */
966HWTEST_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