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