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_array.h"
17
18 #include "ecmascript/ecma_string.h"
19 #include "ecmascript/ecma_vm.h"
20 #include "ecmascript/global_env.h"
21 #include "ecmascript/js_array.h"
22 #include "ecmascript/js_array_iterator.h"
23
24 #include "ecmascript/js_handle.h"
25 #include "ecmascript/js_hclass.h"
26 #include "ecmascript/js_object-inl.h"
27 #include "ecmascript/js_tagged_value-inl.h"
28 #include "ecmascript/js_tagged_value.h"
29 #include "ecmascript/js_thread.h"
30
31 #include "ecmascript/object_factory.h"
32 #include "ecmascript/object_operator.h"
33 #include "ecmascript/tests/test_helper.h"
34
35 using namespace panda::ecmascript;
36 using namespace panda::ecmascript::builtins;
37 using namespace panda::ecmascript::base;
38 constexpr int32_t INT_VALUE_0 = 0;
39 constexpr int32_t INT_VALUE_1 = 1;
40 constexpr int32_t INT_VALUE_2 = 2;
41 constexpr int32_t INT_VALUE_3 = 3;
42 constexpr int32_t INT_VALUE_4 = 4;
43 constexpr int32_t INT_VALUE_50 = 50;
44 constexpr int32_t INT_VALUE_200 = 200;
45 constexpr int32_t INT_VALUE_666 = 666;
46 constexpr uint32_t RUNTIME_CALL_INFO_PARA_0 = 0;
47 constexpr uint32_t RUNTIME_CALL_INFO_PARA_1 = 1;
48 constexpr uint32_t RUNTIME_CALL_INFO_PARA_NUM_4 = 4;
49 constexpr uint32_t RUNTIME_CALL_INFO_PARA_NUM_8 = 8;
50 constexpr uint32_t RUNTIME_CALL_INFO_PARA_NUM_10 = 10;
51
52 enum class ArrayIndex {
53 ARRAY_INDEX_0,
54 ARRAY_INDEX_1,
55 ARRAY_INDEX_2,
56 ARRAY_INDEX_3
57 };
58
59 namespace panda::test {
60 using Array = ecmascript::builtins::BuiltinsArray;
61 class BuiltinsArrayTest : public testing::Test {
62 public:
SetUpTestCase()63 static void SetUpTestCase()
64 {
65 GTEST_LOG_(INFO) << "SetUpTestCase";
66 }
67
TearDownTestCase()68 static void TearDownTestCase()
69 {
70 GTEST_LOG_(INFO) << "TearDownCase";
71 }
72
SetUp()73 void SetUp() override
74 {
75 TestHelper::CreateEcmaVMWithScope(instance, thread, scope);
76 }
77
TearDown()78 void TearDown() override
79 {
80 TestHelper::DestroyEcmaVMWithScope(instance, scope);
81 }
82
83 EcmaVM *instance {nullptr};
84 EcmaHandleScope *scope {nullptr};
85 JSThread *thread {nullptr};
86
87 class TestClass : public base::BuiltinsBase {
88 public:
TestForEachFunc(EcmaRuntimeCallInfo * argv)89 static JSTaggedValue TestForEachFunc(EcmaRuntimeCallInfo *argv)
90 {
91 JSHandle<JSTaggedValue> key = GetCallArg(argv, 0);
92 if (key->IsUndefined()) {
93 return JSTaggedValue::Undefined();
94 }
95 JSArray *jsArray = JSArray::Cast(GetThis(argv)->GetTaggedObject());
96 uint32_t length = jsArray->GetArrayLength() + 1U;
97 jsArray->SetArrayLength(argv->GetThread(), length);
98 return JSTaggedValue::Undefined();
99 }
100
TestEveryFunc(EcmaRuntimeCallInfo * argv)101 static JSTaggedValue TestEveryFunc(EcmaRuntimeCallInfo *argv)
102 {
103 uint32_t argc = argv->GetArgsNumber();
104 if (argc > 0) {
105 if (GetCallArg(argv, 0)->GetInt() > 10) { // 10 : test case
106 return GetTaggedBoolean(true);
107 }
108 }
109 return GetTaggedBoolean(false);
110 }
111
TestMapFunc(EcmaRuntimeCallInfo * argv)112 static JSTaggedValue TestMapFunc(EcmaRuntimeCallInfo *argv)
113 {
114 int accumulator = GetCallArg(argv, 0)->GetInt();
115 accumulator = accumulator * 2; // 2 : mapped to 2 times the original value
116 return BuiltinsBase::GetTaggedInt(accumulator);
117 }
118
TestFlatMapFunc(EcmaRuntimeCallInfo * argv)119 static JSTaggedValue TestFlatMapFunc(EcmaRuntimeCallInfo *argv)
120 {
121 int accumulator = GetCallArg(argv, 0)->GetInt();
122 accumulator = accumulator * 2; // 2 : mapped to 2 times the original value
123
124 JSThread *thread = argv->GetThread();
125 JSHandle<JSTaggedValue> lengthKeyHandle = thread->GlobalConstants()->GetHandledLengthString();
126 JSArray *arr =
127 JSArray::Cast(JSArray::ArrayCreate(thread, JSTaggedNumber(0)).GetTaggedValue().GetTaggedObject());
128 EXPECT_TRUE(arr != nullptr);
129 JSHandle<JSObject> obj(thread, arr);
130 auto property = JSArray::GetProperty(thread, JSHandle<JSTaggedValue>(obj), lengthKeyHandle);
131 EXPECT_EQ(property.GetValue()->GetInt(), 0);
132
133 JSHandle<JSTaggedValue> key(thread, JSTaggedValue(0));
134 PropertyDescriptor desc(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(accumulator)),
135 true, true, true);
136 JSArray::DefineOwnProperty(thread, obj, key, desc);
137 return obj.GetTaggedValue();
138 }
139
TestFindFunc(EcmaRuntimeCallInfo * argv)140 static JSTaggedValue TestFindFunc(EcmaRuntimeCallInfo *argv)
141 {
142 uint32_t argc = argv->GetArgsNumber();
143 if (argc > 0) {
144 // 10 : test case
145 if (GetCallArg(argv, 0)->GetInt() > 10) {
146 return GetTaggedBoolean(true);
147 }
148 }
149 return GetTaggedBoolean(false);
150 }
151
TestFindIndexFunc(EcmaRuntimeCallInfo * argv)152 static JSTaggedValue TestFindIndexFunc(EcmaRuntimeCallInfo *argv)
153 {
154 uint32_t argc = argv->GetArgsNumber();
155 if (argc > 0) {
156 // 10 : test case
157 if (GetCallArg(argv, 0)->GetInt() > 10) {
158 return GetTaggedBoolean(true);
159 }
160 }
161 return GetTaggedBoolean(false);
162 }
163
TestFindLastFunc(EcmaRuntimeCallInfo * argv)164 static JSTaggedValue TestFindLastFunc(EcmaRuntimeCallInfo *argv)
165 {
166 uint32_t argc = argv->GetArgsNumber();
167 if (argc > 0) {
168 // 20 : test case
169 if (GetCallArg(argv, 0)->GetInt() > 20) {
170 return GetTaggedBoolean(true);
171 }
172 }
173 return GetTaggedBoolean(false);
174 }
175
TestFindLastIndexFunc(EcmaRuntimeCallInfo * argv)176 static JSTaggedValue TestFindLastIndexFunc(EcmaRuntimeCallInfo *argv)
177 {
178 uint32_t argc = argv->GetArgsNumber();
179 if (argc > 0) {
180 // 20 : test case
181 if (GetCallArg(argv, 0)->GetInt() > 20) {
182 return GetTaggedBoolean(true);
183 }
184 }
185 return GetTaggedBoolean(false);
186 }
187
TestReduceFunc(EcmaRuntimeCallInfo * argv)188 static JSTaggedValue TestReduceFunc(EcmaRuntimeCallInfo *argv)
189 {
190 int accumulator = GetCallArg(argv, 0)->GetInt();
191 accumulator = accumulator + GetCallArg(argv, 1)->GetInt();
192 return BuiltinsBase::GetTaggedInt(accumulator);
193 }
194
TestReduceRightFunc(EcmaRuntimeCallInfo * argv)195 static JSTaggedValue TestReduceRightFunc(EcmaRuntimeCallInfo *argv)
196 {
197 int accumulator = GetCallArg(argv, 0)->GetInt();
198 accumulator = accumulator + GetCallArg(argv, 1)->GetInt();
199 return BuiltinsBase::GetTaggedInt(accumulator);
200 }
201
TestSomeFunc(EcmaRuntimeCallInfo * argv)202 static JSTaggedValue TestSomeFunc(EcmaRuntimeCallInfo *argv)
203 {
204 uint32_t argc = argv->GetArgsNumber();
205 if (argc > 0) {
206 if (GetCallArg(argv, 0)->GetInt() > 10) { // 10 : test case
207 return GetTaggedBoolean(true);
208 }
209 }
210 return GetTaggedBoolean(false);
211 }
212 };
213 };
214
CreateBuiltinsArrayJSObject(JSThread * thread,const CString keyCStr)215 JSTaggedValue CreateBuiltinsArrayJSObject(JSThread *thread, const CString keyCStr)
216 {
217 EcmaVM *ecmaVM = thread->GetEcmaVM();
218 JSHandle<GlobalEnv> globalEnv = ecmaVM->GetGlobalEnv();
219
220 JSHandle<JSTaggedValue> hclass = globalEnv->GetObjectFunction();
221 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
222
223 JSHandle<JSTaggedValue> obj(factory->NewJSObjectByConstructor(JSHandle<JSFunction>(hclass), hclass));
224 JSHandle<JSTaggedValue> key(factory->NewFromASCII(&keyCStr[0]));
225 JSHandle<JSTaggedValue> value(thread, JSTaggedValue(1));
226 JSObject::SetProperty(thread, obj, key, value);
227 return obj.GetTaggedValue();
228 }
229
HWTEST_F_L0(BuiltinsArrayTest,ArrayConstructor)230 HWTEST_F_L0(BuiltinsArrayTest, ArrayConstructor)
231 {
232 auto ecmaVM = thread->GetEcmaVM();
233 JSHandle<GlobalEnv> env = ecmaVM->GetGlobalEnv();
234 JSHandle<JSFunction> array(env->GetArrayFunction());
235 JSHandle<JSObject> globalObject(thread, env->GetGlobalObject());
236
237 auto ecmaRuntimeCallInfo1 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 10);
238 ecmaRuntimeCallInfo1->SetFunction(array.GetTaggedValue());
239 ecmaRuntimeCallInfo1->SetThis(globalObject.GetTaggedValue());
240 ecmaRuntimeCallInfo1->SetCallArg(0, JSTaggedValue(static_cast<int32_t>(1)));
241 ecmaRuntimeCallInfo1->SetCallArg(1, JSTaggedValue(static_cast<int32_t>(3)));
242 ecmaRuntimeCallInfo1->SetCallArg(2, JSTaggedValue(static_cast<int32_t>(5)));
243
244 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo1);
245 JSTaggedValue result = Array::ArrayConstructor(ecmaRuntimeCallInfo1);
246 TestHelper::TearDownFrame(thread, prev);
247 JSTaggedValue value(static_cast<JSTaggedType>(result.GetRawData()));
248 ASSERT_TRUE(value.IsECMAObject());
249 PropertyDescriptor descRes(thread);
250 JSHandle<JSObject> valueHandle(thread, value);
251 JSHandle<JSTaggedValue> key0(thread, JSTaggedValue(0));
252 JSHandle<JSTaggedValue> key1(thread, JSTaggedValue(1));
253 JSHandle<JSTaggedValue> key2(thread, JSTaggedValue(2));
254 JSObject::GetOwnProperty(thread, valueHandle, key0, descRes);
255 ASSERT_EQ(descRes.GetValue().GetTaggedValue(), JSTaggedValue(1));
256 JSObject::GetOwnProperty(thread, valueHandle, key1, descRes);
257 ASSERT_EQ(descRes.GetValue().GetTaggedValue(), JSTaggedValue(3));
258 JSObject::GetOwnProperty(thread, valueHandle, key2, descRes);
259 ASSERT_EQ(descRes.GetValue().GetTaggedValue(), JSTaggedValue(5));
260 }
261
262 // 22.1.2.1 Array.from ( items [ , mapfn [ , thisArg ] ] )
HWTEST_F_L0(BuiltinsArrayTest,From)263 HWTEST_F_L0(BuiltinsArrayTest, From)
264 {
265 JSHandle<JSTaggedValue> lengthKeyHandle = thread->GlobalConstants()->GetHandledLengthString();
266 JSArray *arr = JSArray::Cast(JSArray::ArrayCreate(thread, JSTaggedNumber(0))->GetTaggedObject());
267 EXPECT_TRUE(arr != nullptr);
268 JSHandle<JSObject> obj(thread, arr);
269 EXPECT_EQ(JSArray::GetProperty(thread, JSHandle<JSTaggedValue>(obj), lengthKeyHandle).GetValue()->GetInt(), 0);
270
271 JSHandle<JSTaggedValue> key0(thread, JSTaggedValue(0));
272 PropertyDescriptor desc0(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(1)), true, true, true);
273 JSArray::DefineOwnProperty(thread, obj, key0, desc0);
274 JSHandle<JSTaggedValue> key1(thread, JSTaggedValue(1));
275 PropertyDescriptor desc1(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(2)), true, true, true);
276 JSArray::DefineOwnProperty(thread, obj, key1, desc1);
277 JSHandle<JSTaggedValue> key2(thread, JSTaggedValue(2));
278 PropertyDescriptor desc2(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(3)), true, true, true);
279 JSArray::DefineOwnProperty(thread, obj, key2, desc2);
280 JSHandle<JSTaggedValue> key3(thread, JSTaggedValue(3));
281 PropertyDescriptor desc3(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(4)), true, true, true);
282 JSArray::DefineOwnProperty(thread, obj, key3, desc3);
283 JSHandle<JSTaggedValue> key4(thread, JSTaggedValue(4));
284 PropertyDescriptor desc4(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(5)), true, true, true);
285 JSArray::DefineOwnProperty(thread, obj, key4, desc4);
286
287 auto ecmaRuntimeCallInfo1 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 6);
288 ecmaRuntimeCallInfo1->SetFunction(JSTaggedValue::Undefined());
289 ecmaRuntimeCallInfo1->SetThis(obj.GetTaggedValue());
290 ecmaRuntimeCallInfo1->SetCallArg(0, obj.GetTaggedValue());
291
292 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo1);
293 JSTaggedValue result = Array::From(ecmaRuntimeCallInfo1);
294 TestHelper::TearDownFrame(thread, prev);
295 JSTaggedValue value(static_cast<JSTaggedType>(result.GetRawData()));
296 ASSERT_TRUE(value.IsECMAObject());
297 PropertyDescriptor descRes(thread);
298 JSHandle<JSObject> valueHandle(thread, value);
299 JSObject::GetOwnProperty(thread, valueHandle, key0, descRes);
300 ASSERT_EQ(descRes.GetValue().GetTaggedValue(), JSTaggedValue(1));
301 JSObject::GetOwnProperty(thread, valueHandle, key1, descRes);
302 ASSERT_EQ(descRes.GetValue().GetTaggedValue(), JSTaggedValue(2));
303 JSObject::GetOwnProperty(thread, valueHandle, key2, descRes);
304 ASSERT_EQ(descRes.GetValue().GetTaggedValue(), JSTaggedValue(3));
305 JSObject::GetOwnProperty(thread, valueHandle, key3, descRes);
306 ASSERT_EQ(descRes.GetValue().GetTaggedValue(), JSTaggedValue(4));
307 JSObject::GetOwnProperty(thread, valueHandle, key4, descRes);
308 ASSERT_EQ(descRes.GetValue().GetTaggedValue(), JSTaggedValue(5));
309 }
310
311 // 22.1.2.2 Array.isArray(arg)
HWTEST_F_L0(BuiltinsArrayTest,IsArray)312 HWTEST_F_L0(BuiltinsArrayTest, IsArray)
313 {
314 JSHandle<JSTaggedValue> lengthKeyHandle = thread->GlobalConstants()->GetHandledLengthString();
315 JSArray *arr = JSArray::Cast(JSArray::ArrayCreate(thread, JSTaggedNumber(0)).GetTaggedValue().GetTaggedObject());
316 EXPECT_TRUE(arr != nullptr);
317 JSHandle<JSObject> obj(thread, arr);
318 EXPECT_EQ(JSArray::GetProperty(thread, JSHandle<JSTaggedValue>(obj), lengthKeyHandle).GetValue()->GetInt(), 0);
319
320 auto ecmaRuntimeCallInfo1 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 6);
321 ecmaRuntimeCallInfo1->SetFunction(JSTaggedValue::Undefined());
322 ecmaRuntimeCallInfo1->SetThis(JSTaggedValue::Undefined());
323 ecmaRuntimeCallInfo1->SetCallArg(0, obj.GetTaggedValue());
324
325 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo1);
326 JSTaggedValue result = Array::IsArray(ecmaRuntimeCallInfo1);
327 TestHelper::TearDownFrame(thread, prev);
328 ASSERT_EQ(result.GetRawData(), JSTaggedValue::True().GetRawData());
329
330 auto ecmaRuntimeCallInfo2 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 6);
331 ecmaRuntimeCallInfo2->SetFunction(JSTaggedValue::Undefined());
332 ecmaRuntimeCallInfo2->SetThis(JSTaggedValue::Undefined());
333 ecmaRuntimeCallInfo2->SetCallArg(0, JSTaggedValue(static_cast<int32_t>(1)));
334
335 prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo2);
336 result = Array::IsArray(ecmaRuntimeCallInfo2);
337 TestHelper::TearDownFrame(thread, prev);
338 ASSERT_EQ(result.GetRawData(), JSTaggedValue::False().GetRawData());
339 }
340
HWTEST_F_L0(BuiltinsArrayTest,Of)341 HWTEST_F_L0(BuiltinsArrayTest, Of)
342 {
343 auto ecmaVM = thread->GetEcmaVM();
344 JSHandle<GlobalEnv> env = ecmaVM->GetGlobalEnv();
345 JSHandle<JSFunction> array(env->GetArrayFunction());
346 JSHandle<JSObject> globalObject(thread, env->GetGlobalObject());
347
348 auto ecmaRuntimeCallInfo1 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 10);
349 ecmaRuntimeCallInfo1->SetFunction(array.GetTaggedValue());
350 ecmaRuntimeCallInfo1->SetThis(globalObject.GetTaggedValue());
351 ecmaRuntimeCallInfo1->SetCallArg(0, JSTaggedValue(static_cast<int32_t>(1)));
352 ecmaRuntimeCallInfo1->SetCallArg(1, JSTaggedValue(static_cast<int32_t>(3)));
353 ecmaRuntimeCallInfo1->SetCallArg(2, JSTaggedValue(static_cast<int32_t>(5)));
354
355 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo1);
356 JSTaggedValue result = Array::Of(ecmaRuntimeCallInfo1);
357 TestHelper::TearDownFrame(thread, prev);
358 JSTaggedValue value(static_cast<JSTaggedType>(result.GetRawData()));
359 ASSERT_TRUE(value.IsECMAObject());
360 PropertyDescriptor descRes(thread);
361 JSHandle<JSObject> valueHandle(thread, value);
362 JSHandle<JSTaggedValue> key0(thread, JSTaggedValue(0));
363 JSHandle<JSTaggedValue> key1(thread, JSTaggedValue(1));
364 JSHandle<JSTaggedValue> key2(thread, JSTaggedValue(2));
365
366 JSObject::GetOwnProperty(thread, valueHandle, key0, descRes);
367 ASSERT_EQ(descRes.GetValue().GetTaggedValue(), JSTaggedValue(1));
368 JSObject::GetOwnProperty(thread, valueHandle, key1, descRes);
369 ASSERT_EQ(descRes.GetValue().GetTaggedValue(), JSTaggedValue(3));
370 JSObject::GetOwnProperty(thread, valueHandle, key2, descRes);
371 ASSERT_EQ(descRes.GetValue().GetTaggedValue(), JSTaggedValue(5));
372 }
373
HWTEST_F_L0(BuiltinsArrayTest,Species)374 HWTEST_F_L0(BuiltinsArrayTest, Species)
375 {
376 auto ecmaVM = thread->GetEcmaVM();
377 JSHandle<GlobalEnv> env = ecmaVM->GetGlobalEnv();
378 JSHandle<JSFunction> array(env->GetArrayFunction());
379 JSHandle<JSObject> globalObject(thread, env->GetGlobalObject());
380
381 auto ecmaRuntimeCallInfo1 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 4);
382 ecmaRuntimeCallInfo1->SetFunction(array.GetTaggedValue());
383 ecmaRuntimeCallInfo1->SetThis(globalObject.GetTaggedValue());
384
385 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo1);
386 JSTaggedValue result = Array::Species(ecmaRuntimeCallInfo1);
387 TestHelper::TearDownFrame(thread, prev);
388 ASSERT_TRUE(result.IsECMAObject());
389 }
390
HWTEST_F_L0(BuiltinsArrayTest,Concat)391 HWTEST_F_L0(BuiltinsArrayTest, Concat)
392 {
393 JSHandle<JSTaggedValue> lengthKeyHandle = thread->GlobalConstants()->GetHandledLengthString();
394 JSArray *arr = JSArray::Cast(JSArray::ArrayCreate(thread, JSTaggedNumber(0)).GetTaggedValue().GetTaggedObject());
395 EXPECT_TRUE(arr != nullptr);
396 JSHandle<JSObject> obj(thread, arr);
397 JSHandle<JSTaggedValue> key0(thread, JSTaggedValue(0));
398 PropertyDescriptor desc0(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(1)), true, true, true);
399 JSArray::DefineOwnProperty(thread, obj, key0, desc0);
400 JSHandle<JSTaggedValue> key1(thread, JSTaggedValue(1));
401 PropertyDescriptor desc1(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(2)), true, true, true);
402 JSArray::DefineOwnProperty(thread, obj, key1, desc1);
403 JSHandle<JSTaggedValue> key2(thread, JSTaggedValue(2));
404 PropertyDescriptor desc2(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(3)), true, true, true);
405 JSArray::DefineOwnProperty(thread, obj, key2, desc2);
406
407 JSArray *arr1 = JSArray::ArrayCreate(thread, JSTaggedNumber(0)).GetObject<JSArray>();
408 EXPECT_TRUE(arr1 != nullptr);
409 JSHandle<JSObject> obj1(thread, arr1);
410 JSHandle<JSTaggedValue> key4(thread, JSTaggedValue(0));
411 PropertyDescriptor desc4(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(4)), true, true, true);
412 JSArray::DefineOwnProperty(thread, obj1, key4, desc4);
413 JSHandle<JSTaggedValue> key5(thread, JSTaggedValue(1));
414 PropertyDescriptor desc5(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(5)), true, true, true);
415 JSArray::DefineOwnProperty(thread, obj1, key5, desc5);
416 JSHandle<JSTaggedValue> key6(thread, JSTaggedValue(2));
417 PropertyDescriptor desc6(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(6)), true, true, true);
418 JSArray::DefineOwnProperty(thread, obj1, key6, desc6);
419
420 auto ecmaRuntimeCallInfo1 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 6);
421 ecmaRuntimeCallInfo1->SetFunction(JSTaggedValue::Undefined());
422 ecmaRuntimeCallInfo1->SetThis(obj.GetTaggedValue());
423 ecmaRuntimeCallInfo1->SetCallArg(0, obj1.GetTaggedValue());
424
425 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo1);
426 JSTaggedValue result = Array::Concat(ecmaRuntimeCallInfo1);
427 TestHelper::TearDownFrame(thread, prev);
428 JSTaggedValue value(static_cast<JSTaggedType>(result.GetRawData()));
429 ASSERT_TRUE(value.IsECMAObject());
430
431 PropertyDescriptor descRes(thread);
432 JSHandle<JSObject> valueHandle(thread, value);
433 JSHandle<JSTaggedValue> key7(thread, JSTaggedValue(5));
434 EXPECT_EQ(
435 JSArray::GetProperty(thread, JSHandle<JSTaggedValue>(valueHandle), lengthKeyHandle).GetValue()->GetInt(), 6);
436 JSObject::GetOwnProperty(thread, valueHandle, key7, descRes);
437 ASSERT_EQ(descRes.GetValue().GetTaggedValue(), JSTaggedValue(6));
438 }
439
440 // 22.1.3.3 new Array(1,2,3,4,5).CopyWithin(0,3,5)
HWTEST_F_L0(BuiltinsArrayTest,CopyWithin)441 HWTEST_F_L0(BuiltinsArrayTest, CopyWithin)
442 {
443 JSHandle<JSTaggedValue> lengthKeyHandle = thread->GlobalConstants()->GetHandledLengthString();
444 JSArray *arr = JSArray::Cast(JSArray::ArrayCreate(thread, JSTaggedNumber(0)).GetTaggedValue().GetTaggedObject());
445 EXPECT_TRUE(arr != nullptr);
446 JSHandle<JSObject> obj(thread, arr);
447 EXPECT_EQ(JSArray::GetProperty(thread, JSHandle<JSTaggedValue>(obj), lengthKeyHandle).GetValue()->GetInt(), 0);
448
449 JSHandle<JSTaggedValue> key0(thread, JSTaggedValue(0));
450 PropertyDescriptor desc0(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(1)), true, true, true);
451 JSArray::DefineOwnProperty(thread, obj, key0, desc0);
452 JSHandle<JSTaggedValue> key1(thread, JSTaggedValue(1));
453 PropertyDescriptor desc1(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(2)), true, true, true);
454 JSArray::DefineOwnProperty(thread, obj, key1, desc1);
455 JSHandle<JSTaggedValue> key2(thread, JSTaggedValue(2));
456 PropertyDescriptor desc2(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(3)), true, true, true);
457 JSArray::DefineOwnProperty(thread, obj, key2, desc2);
458 JSHandle<JSTaggedValue> key3(thread, JSTaggedValue(3));
459 PropertyDescriptor desc3(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(4)), true, true, true);
460 JSArray::DefineOwnProperty(thread, obj, key3, desc3);
461 JSHandle<JSTaggedValue> key4(thread, JSTaggedValue(4));
462 PropertyDescriptor desc4(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(5)), true, true, true);
463 JSArray::DefineOwnProperty(thread, obj, key4, desc4);
464
465 auto ecmaRuntimeCallInfo1 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 10);
466 ecmaRuntimeCallInfo1->SetFunction(JSTaggedValue::Undefined());
467 ecmaRuntimeCallInfo1->SetThis(obj.GetTaggedValue());
468 ecmaRuntimeCallInfo1->SetCallArg(0, JSTaggedValue(static_cast<int32_t>(0)));
469 ecmaRuntimeCallInfo1->SetCallArg(1, JSTaggedValue(static_cast<int32_t>(3)));
470 ecmaRuntimeCallInfo1->SetCallArg(2, JSTaggedValue(static_cast<int32_t>(5)));
471
472 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo1);
473 JSTaggedValue result = Array::CopyWithin(ecmaRuntimeCallInfo1);
474 TestHelper::TearDownFrame(thread, prev);
475 JSTaggedValue value(static_cast<JSTaggedType>(result.GetRawData()));
476 ASSERT_TRUE(value.IsECMAObject());
477 PropertyDescriptor descRes(thread);
478 JSHandle<JSObject> valueHandle(thread, value);
479 JSObject::GetOwnProperty(thread, valueHandle, key0, descRes);
480 ASSERT_EQ(descRes.GetValue().GetTaggedValue(), JSTaggedValue(4));
481 JSObject::GetOwnProperty(thread, valueHandle, key1, descRes);
482 ASSERT_EQ(descRes.GetValue().GetTaggedValue(), JSTaggedValue(5));
483 JSObject::GetOwnProperty(thread, valueHandle, key2, descRes);
484 ASSERT_EQ(descRes.GetValue().GetTaggedValue(), JSTaggedValue(3));
485 JSObject::GetOwnProperty(thread, valueHandle, key3, descRes);
486 ASSERT_EQ(descRes.GetValue().GetTaggedValue(), JSTaggedValue(4));
487 JSObject::GetOwnProperty(thread, valueHandle, key4, descRes);
488 ASSERT_EQ(descRes.GetValue().GetTaggedValue(), JSTaggedValue(5));
489 }
490
HWTEST_F_L0(BuiltinsArrayTest,Every)491 HWTEST_F_L0(BuiltinsArrayTest, Every)
492 {
493 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
494 auto ecmaVM = thread->GetEcmaVM();
495 JSHandle<GlobalEnv> env = ecmaVM->GetGlobalEnv();
496
497 JSHandle<JSTaggedValue> lengthKeyHandle = thread->GlobalConstants()->GetHandledLengthString();
498 JSArray *arr = JSArray::Cast(JSArray::ArrayCreate(thread, JSTaggedNumber(0)).GetTaggedValue().GetTaggedObject());
499 EXPECT_TRUE(arr != nullptr);
500 JSHandle<JSObject> obj(thread, arr);
501 EXPECT_EQ(JSArray::GetProperty(thread, JSHandle<JSTaggedValue>(obj), lengthKeyHandle).GetValue()->GetInt(), 0);
502
503 JSHandle<JSTaggedValue> key0(thread, JSTaggedValue(0));
504 PropertyDescriptor desc0(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(100)), true, true, true);
505 JSArray::DefineOwnProperty(thread, obj, key0, desc0);
506
507 JSHandle<JSTaggedValue> key1(thread, JSTaggedValue(1));
508 PropertyDescriptor desc1(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(200)), true, true, true);
509 JSArray::DefineOwnProperty(thread, obj, key1, desc1);
510 JSHandle<JSTaggedValue> key2(thread, JSTaggedValue(2));
511 PropertyDescriptor desc2(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(300)), true, true, true);
512 JSArray::DefineOwnProperty(thread, obj, key2, desc2);
513
514 JSHandle<JSArray> jsArray = factory->NewJSArray();
515 JSHandle<JSFunction> func = factory->NewJSFunction(env, reinterpret_cast<void *>(TestClass::TestEveryFunc));
516
517 auto ecmaRuntimeCallInfo1 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 8);
518 ecmaRuntimeCallInfo1->SetFunction(JSTaggedValue::Undefined());
519 ecmaRuntimeCallInfo1->SetThis(obj.GetTaggedValue());
520 ecmaRuntimeCallInfo1->SetCallArg(0, func.GetTaggedValue());
521 ecmaRuntimeCallInfo1->SetCallArg(1, jsArray.GetTaggedValue());
522
523 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo1);
524 JSTaggedValue result2 = Array::Every(ecmaRuntimeCallInfo1);
525 TestHelper::TearDownFrame(thread, prev);
526
527 ASSERT_EQ(result2.GetRawData(), JSTaggedValue::True().GetRawData());
528 }
529
HWTEST_F_L0(BuiltinsArrayTest,Map)530 HWTEST_F_L0(BuiltinsArrayTest, Map)
531 {
532 auto ecmaVM = thread->GetEcmaVM();
533 JSHandle<GlobalEnv> env = ecmaVM->GetGlobalEnv();
534 ObjectFactory *factory = ecmaVM->GetFactory();
535
536 JSHandle<JSTaggedValue> lengthKeyHandle = thread->GlobalConstants()->GetHandledLengthString();
537 JSArray *arr = JSArray::Cast(JSArray::ArrayCreate(thread, JSTaggedNumber(0)).GetTaggedValue().GetTaggedObject());
538 EXPECT_TRUE(arr != nullptr);
539 JSHandle<JSObject> obj(thread, arr);
540 EXPECT_EQ(JSArray::GetProperty(thread, JSHandle<JSTaggedValue>(obj), lengthKeyHandle).GetValue()->GetInt(), 0);
541 JSHandle<JSTaggedValue> key0(thread, JSTaggedValue(0));
542 PropertyDescriptor desc0(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(50)), true, true, true);
543 JSArray::DefineOwnProperty(thread, obj, key0, desc0);
544 JSHandle<JSTaggedValue> key1(thread, JSTaggedValue(1));
545 PropertyDescriptor desc1(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(200)), true, true, true);
546 JSArray::DefineOwnProperty(thread, obj, key1, desc1);
547 JSHandle<JSTaggedValue> key2(thread, JSTaggedValue(2));
548 PropertyDescriptor desc2(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(3)), true, true, true);
549 JSArray::DefineOwnProperty(thread, obj, key2, desc2);
550 JSHandle<JSArray> jsArray(JSArray::ArrayCreate(thread, JSTaggedNumber(0)));
551 JSHandle<JSFunction> func = factory->NewJSFunction(env, reinterpret_cast<void *>(TestClass::TestMapFunc));
552
553 auto ecmaRuntimeCallInfo1 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 8);
554 ecmaRuntimeCallInfo1->SetFunction(JSTaggedValue::Undefined());
555 ecmaRuntimeCallInfo1->SetThis(obj.GetTaggedValue());
556 ecmaRuntimeCallInfo1->SetCallArg(0, func.GetTaggedValue());
557 ecmaRuntimeCallInfo1->SetCallArg(1, jsArray.GetTaggedValue());
558
559 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo1);
560 JSTaggedValue result = Array::Map(ecmaRuntimeCallInfo1);
561 TestHelper::TearDownFrame(thread, prev);
562 JSTaggedValue value(static_cast<JSTaggedType>(result.GetRawData()));
563 ASSERT_TRUE(value.IsECMAObject());
564
565 PropertyDescriptor descRes(thread);
566 JSHandle<JSObject> valueHandle(thread, value);
567 EXPECT_EQ(
568 JSArray::GetProperty(thread, JSHandle<JSTaggedValue>(valueHandle), lengthKeyHandle).GetValue()->GetInt(), 3);
569 JSObject::GetOwnProperty(thread, valueHandle, key0, descRes);
570
571 ASSERT_EQ(descRes.GetValue()->GetInt(), 100);
572 JSObject::GetOwnProperty(thread, valueHandle, key1, descRes);
573 ASSERT_EQ(descRes.GetValue()->GetInt(), 400);
574 JSObject::GetOwnProperty(thread, valueHandle, key2, descRes);
575 ASSERT_EQ(descRes.GetValue()->GetInt(), 6);
576 }
577
HWTEST_F_L0(BuiltinsArrayTest,Reverse)578 HWTEST_F_L0(BuiltinsArrayTest, Reverse)
579 {
580 JSHandle<JSTaggedValue> lengthKeyHandle = thread->GlobalConstants()->GetHandledLengthString();
581 JSArray *arr = JSArray::Cast(JSArray::ArrayCreate(thread, JSTaggedNumber(0)).GetTaggedValue().GetTaggedObject());
582 EXPECT_TRUE(arr != nullptr);
583 JSHandle<JSObject> obj(thread, arr);
584 EXPECT_EQ(JSArray::GetProperty(thread, JSHandle<JSTaggedValue>(obj), lengthKeyHandle).GetValue()->GetInt(), 0);
585 JSHandle<JSTaggedValue> key0(thread, JSTaggedValue(0));
586 PropertyDescriptor desc0(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(50)), true, true, true);
587 JSArray::DefineOwnProperty(thread, obj, key0, desc0);
588 JSHandle<JSTaggedValue> key1(thread, JSTaggedValue(1));
589 PropertyDescriptor desc1(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(200)), true, true, true);
590 JSArray::DefineOwnProperty(thread, obj, key1, desc1);
591 JSHandle<JSTaggedValue> key2(thread, JSTaggedValue(2));
592 PropertyDescriptor desc2(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(3)), true, true, true);
593 JSArray::DefineOwnProperty(thread, obj, key2, desc2);
594
595 auto ecmaRuntimeCallInfo1 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 4);
596 ecmaRuntimeCallInfo1->SetFunction(JSTaggedValue::Undefined());
597 ecmaRuntimeCallInfo1->SetThis(obj.GetTaggedValue());
598
599 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo1);
600 JSTaggedValue result = Array::Reverse(ecmaRuntimeCallInfo1);
601 TestHelper::TearDownFrame(thread, prev);
602 JSTaggedValue value(static_cast<JSTaggedType>(result.GetRawData()));
603 ASSERT_TRUE(value.IsECMAObject());
604
605 PropertyDescriptor descRes(thread);
606 JSHandle<JSObject> valueHandle(thread, value);
607 EXPECT_EQ(
608 JSArray::GetProperty(thread, JSHandle<JSTaggedValue>(valueHandle), lengthKeyHandle).GetValue()->GetInt(), 3);
609 JSObject::GetOwnProperty(thread, valueHandle, key0, descRes);
610 ASSERT_EQ(descRes.GetValue().GetTaggedValue(), JSTaggedValue(3));
611 JSObject::GetOwnProperty(thread, valueHandle, key1, descRes);
612 ASSERT_EQ(descRes.GetValue().GetTaggedValue(), JSTaggedValue(200));
613 JSObject::GetOwnProperty(thread, valueHandle, key2, descRes);
614 ASSERT_EQ(descRes.GetValue().GetTaggedValue(), JSTaggedValue(50));
615 EXPECT_EQ(JSArray::GetProperty(thread, JSHandle<JSTaggedValue>(obj), lengthKeyHandle).GetValue()->GetInt(), 3);
616 JSObject::GetOwnProperty(thread, obj, key0, descRes);
617 ASSERT_EQ(descRes.GetValue().GetTaggedValue(), JSTaggedValue(3));
618 JSObject::GetOwnProperty(thread, obj, key1, descRes);
619 ASSERT_EQ(descRes.GetValue().GetTaggedValue(), JSTaggedValue(200));
620 JSObject::GetOwnProperty(thread, obj, key2, descRes);
621 ASSERT_EQ(descRes.GetValue().GetTaggedValue(), JSTaggedValue(50));
622 }
623
HWTEST_F_L0(BuiltinsArrayTest,COWArrayReverse)624 HWTEST_F_L0(BuiltinsArrayTest, COWArrayReverse)
625 {
626 JSHandle<JSTaggedValue> lengthKeyHandle = thread->GlobalConstants()->GetHandledLengthString();
627 JSArray *arr = JSArray::Cast(JSArray::ArrayCreate(thread, JSTaggedNumber(0)).GetTaggedValue().GetTaggedObject());
628 EXPECT_TRUE(arr != nullptr);
629 JSHandle<JSObject> obj(thread, arr);
630 EXPECT_EQ(JSArray::GetProperty(thread, JSHandle<JSTaggedValue>(obj), lengthKeyHandle).GetValue()->GetInt(), 0);
631 JSHandle<JSTaggedValue> key0(thread, JSTaggedValue(0));
632 PropertyDescriptor desc0(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(50)), true, true, true);
633 JSArray::DefineOwnProperty(thread, obj, key0, desc0);
634 JSHandle<JSTaggedValue> key1(thread, JSTaggedValue(1));
635 PropertyDescriptor desc1(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(200)), true, true, true);
636 JSArray::DefineOwnProperty(thread, obj, key1, desc1);
637 JSHandle<JSTaggedValue> key2(thread, JSTaggedValue(2));
638 PropertyDescriptor desc2(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(3)), true, true, true);
639 JSArray::DefineOwnProperty(thread, obj, key2, desc2);
640
641 JSHandle<JSArray> cloneArray = thread->GetEcmaVM()->GetFactory()->CloneArrayLiteral(JSHandle<JSArray>(obj));
642
643 auto ecmaRuntimeCallInfo1 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 4);
644 ecmaRuntimeCallInfo1->SetFunction(JSTaggedValue::Undefined());
645 ecmaRuntimeCallInfo1->SetThis(cloneArray.GetTaggedValue());
646
647 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo1);
648 JSTaggedValue result = Array::Reverse(ecmaRuntimeCallInfo1);
649 TestHelper::TearDownFrame(thread, prev);
650 JSTaggedValue value(static_cast<JSTaggedType>(result.GetRawData()));
651 ASSERT_TRUE(value.IsECMAObject());
652
653 PropertyDescriptor descRes(thread);
654 JSHandle<JSObject> valueHandle(thread, value);
655 EXPECT_EQ(
656 JSArray::GetProperty(thread, JSHandle<JSTaggedValue>(valueHandle), lengthKeyHandle).GetValue()->GetInt(), 3);
657 JSObject::GetOwnProperty(thread, valueHandle, key0, descRes);
658 ASSERT_EQ(descRes.GetValue().GetTaggedValue(), JSTaggedValue(3));
659 JSObject::GetOwnProperty(thread, valueHandle, key1, descRes);
660 ASSERT_EQ(descRes.GetValue().GetTaggedValue(), JSTaggedValue(200));
661 JSObject::GetOwnProperty(thread, valueHandle, key2, descRes);
662 ASSERT_EQ(descRes.GetValue().GetTaggedValue(), JSTaggedValue(50));
663 EXPECT_EQ(JSArray::GetProperty(thread, JSHandle<JSTaggedValue>(cloneArray),
664 lengthKeyHandle).GetValue()->GetInt(), 3);
665 JSObject::GetOwnProperty(thread, JSHandle<JSObject>(cloneArray), key0, descRes);
666 ASSERT_EQ(descRes.GetValue().GetTaggedValue(), JSTaggedValue(3));
667 JSObject::GetOwnProperty(thread, JSHandle<JSObject>(cloneArray), key1, descRes);
668 ASSERT_EQ(descRes.GetValue().GetTaggedValue(), JSTaggedValue(200));
669 JSObject::GetOwnProperty(thread, JSHandle<JSObject>(cloneArray), key2, descRes);
670 ASSERT_EQ(descRes.GetValue().GetTaggedValue(), JSTaggedValue(50));
671 }
672
HWTEST_F_L0(BuiltinsArrayTest,Slice)673 HWTEST_F_L0(BuiltinsArrayTest, Slice)
674 {
675 JSHandle<JSTaggedValue> lengthKeyHandle = thread->GlobalConstants()->GetHandledLengthString();
676 JSArray *arr = JSArray::Cast(JSArray::ArrayCreate(thread, JSTaggedNumber(0)).GetTaggedValue().GetTaggedObject());
677 EXPECT_TRUE(arr != nullptr);
678 JSHandle<JSObject> obj(thread, arr);
679 EXPECT_EQ(JSArray::GetProperty(thread, JSHandle<JSTaggedValue>(obj), lengthKeyHandle).GetValue()->GetInt(), 0);
680 JSHandle<JSTaggedValue> key0(thread, JSTaggedValue(0));
681 PropertyDescriptor desc0(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(1)), true, true, true);
682 JSArray::DefineOwnProperty(thread, obj, key0, desc0);
683 JSHandle<JSTaggedValue> key1(thread, JSTaggedValue(1));
684 PropertyDescriptor desc1(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(2)), true, true, true);
685 JSArray::DefineOwnProperty(thread, obj, key1, desc1);
686 JSHandle<JSTaggedValue> key2(thread, JSTaggedValue(2));
687 PropertyDescriptor desc2(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(3)), true, true, true);
688 JSArray::DefineOwnProperty(thread, obj, key2, desc2);
689 JSHandle<JSTaggedValue> key3(thread, JSTaggedValue(3));
690 PropertyDescriptor desc3(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(4)), true, true, true);
691 JSArray::DefineOwnProperty(thread, obj, key3, desc3);
692 JSHandle<JSTaggedValue> key4(thread, JSTaggedValue(4));
693 PropertyDescriptor desc4(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(3)), true, true, true);
694 JSArray::DefineOwnProperty(thread, obj, key4, desc4);
695
696 auto ecmaRuntimeCallInfo1 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 8);
697 ecmaRuntimeCallInfo1->SetFunction(JSTaggedValue::Undefined());
698 ecmaRuntimeCallInfo1->SetThis(obj.GetTaggedValue());
699 ecmaRuntimeCallInfo1->SetCallArg(0, JSTaggedValue(static_cast<int32_t>(1)));
700 ecmaRuntimeCallInfo1->SetCallArg(1, JSTaggedValue(static_cast<int32_t>(4)));
701
702 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo1);
703 JSTaggedValue result = Array::Slice(ecmaRuntimeCallInfo1);
704 TestHelper::TearDownFrame(thread, prev);
705 JSTaggedValue value(static_cast<JSTaggedType>(result.GetRawData()));
706 ASSERT_TRUE(value.IsECMAObject());
707
708 PropertyDescriptor descRes(thread);
709 JSHandle<JSObject> valueHandle(thread, value);
710 EXPECT_EQ(
711 JSArray::GetProperty(thread, JSHandle<JSTaggedValue>(valueHandle), lengthKeyHandle).GetValue()->GetInt(), 3);
712 JSObject::GetOwnProperty(thread, valueHandle, key0, descRes);
713 ASSERT_EQ(descRes.GetValue().GetTaggedValue(), JSTaggedValue(2));
714 JSObject::GetOwnProperty(thread, valueHandle, key1, descRes);
715 ASSERT_EQ(descRes.GetValue().GetTaggedValue(), JSTaggedValue(3));
716 JSObject::GetOwnProperty(thread, valueHandle, key2, descRes);
717 ASSERT_EQ(descRes.GetValue().GetTaggedValue(), JSTaggedValue(4));
718 }
719
HWTEST_F_L0(BuiltinsArrayTest,Splice)720 HWTEST_F_L0(BuiltinsArrayTest, Splice)
721 {
722 JSHandle<JSTaggedValue> lengthKeyHandle = thread->GlobalConstants()->GetHandledLengthString();
723 JSArray *arr = JSArray::Cast(JSArray::ArrayCreate(thread, JSTaggedNumber(0)).GetTaggedValue().GetTaggedObject());
724 EXPECT_TRUE(arr != nullptr);
725 JSHandle<JSObject> obj(thread, arr);
726 EXPECT_EQ(JSArray::GetProperty(thread, JSHandle<JSTaggedValue>(obj), lengthKeyHandle).GetValue()->GetInt(), 0);
727 JSHandle<JSTaggedValue> key0(thread, JSTaggedValue(0));
728 PropertyDescriptor desc0(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(1)), true, true, true);
729 JSArray::DefineOwnProperty(thread, obj, key0, desc0);
730 JSHandle<JSTaggedValue> key1(thread, JSTaggedValue(1));
731 PropertyDescriptor desc1(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(2)), true, true, true);
732 JSArray::DefineOwnProperty(thread, obj, key1, desc1);
733 JSHandle<JSTaggedValue> key2(thread, JSTaggedValue(2));
734 PropertyDescriptor desc2(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(3)), true, true, true);
735 JSArray::DefineOwnProperty(thread, obj, key2, desc2);
736 JSHandle<JSTaggedValue> key3(thread, JSTaggedValue(3));
737 PropertyDescriptor desc3(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(4)), true, true, true);
738 JSArray::DefineOwnProperty(thread, obj, key3, desc3);
739 JSHandle<JSTaggedValue> key4(thread, JSTaggedValue(4));
740 PropertyDescriptor desc4(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(5)), true, true, true);
741 JSArray::DefineOwnProperty(thread, obj, key4, desc4);
742
743 auto ecmaRuntimeCallInfo1 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 10);
744 ecmaRuntimeCallInfo1->SetFunction(JSTaggedValue::Undefined());
745 ecmaRuntimeCallInfo1->SetThis(obj.GetTaggedValue());
746 ecmaRuntimeCallInfo1->SetCallArg(0, JSTaggedValue(static_cast<int32_t>(1)));
747 ecmaRuntimeCallInfo1->SetCallArg(1, JSTaggedValue(static_cast<int32_t>(2)));
748 ecmaRuntimeCallInfo1->SetCallArg(2, JSTaggedValue(static_cast<int32_t>(100)));
749
750 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo1);
751 JSTaggedValue result = Array::Splice(ecmaRuntimeCallInfo1);
752 TestHelper::TearDownFrame(thread, prev);
753 JSTaggedValue value(static_cast<JSTaggedType>(result.GetRawData()));
754 ASSERT_TRUE(value.IsECMAObject());
755 EXPECT_EQ(JSArray::GetProperty(thread, JSHandle<JSTaggedValue>(obj), lengthKeyHandle).GetValue()->GetInt(), 4);
756
757 PropertyDescriptor descRes(thread);
758 JSHandle<JSObject> valueHandle(thread, value);
759 EXPECT_EQ(
760 JSArray::GetProperty(thread, JSHandle<JSTaggedValue>(valueHandle), lengthKeyHandle).GetValue()->GetInt(), 2);
761 JSObject::GetOwnProperty(thread, valueHandle, key0, descRes);
762 ASSERT_EQ(descRes.GetValue().GetTaggedValue(), JSTaggedValue(2));
763 }
764
765 // 22.1.3.6 new Array(1,2,3,4,5).Fill(0,1,3)
HWTEST_F_L0(BuiltinsArrayTest,Fill)766 HWTEST_F_L0(BuiltinsArrayTest, Fill)
767 {
768 JSHandle<JSTaggedValue> lengthKeyHandle = thread->GlobalConstants()->GetHandledLengthString();
769 JSArray *arr = JSArray::Cast(JSArray::ArrayCreate(thread, JSTaggedNumber(0)).GetTaggedValue().GetTaggedObject());
770 EXPECT_TRUE(arr != nullptr);
771 JSHandle<JSObject> obj(thread, arr);
772 EXPECT_EQ(JSArray::GetProperty(thread, JSHandle<JSTaggedValue>(obj), lengthKeyHandle).GetValue()->GetInt(), 0);
773
774 JSHandle<JSTaggedValue> key0(thread, JSTaggedValue(0));
775 PropertyDescriptor desc0(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(1)), true, true, true);
776 JSArray::DefineOwnProperty(thread, obj, key0, desc0);
777 JSHandle<JSTaggedValue> key1(thread, JSTaggedValue(1));
778 PropertyDescriptor desc1(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(2)), true, true, true);
779 JSArray::DefineOwnProperty(thread, obj, key1, desc1);
780 JSHandle<JSTaggedValue> key2(thread, JSTaggedValue(2));
781 PropertyDescriptor desc2(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(3)), true, true, true);
782 JSArray::DefineOwnProperty(thread, obj, key2, desc2);
783 JSHandle<JSTaggedValue> key3(thread, JSTaggedValue(3));
784 PropertyDescriptor desc3(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(4)), true, true, true);
785 JSArray::DefineOwnProperty(thread, obj, key3, desc3);
786 JSHandle<JSTaggedValue> key4(thread, JSTaggedValue(4));
787 PropertyDescriptor desc4(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(5)), true, true, true);
788 JSArray::DefineOwnProperty(thread, obj, key4, desc4);
789
790 auto ecmaRuntimeCallInfo1 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 10);
791 ecmaRuntimeCallInfo1->SetFunction(JSTaggedValue::Undefined());
792 ecmaRuntimeCallInfo1->SetThis(obj.GetTaggedValue());
793 ecmaRuntimeCallInfo1->SetCallArg(0, JSTaggedValue(static_cast<int32_t>(0)));
794 ecmaRuntimeCallInfo1->SetCallArg(1, JSTaggedValue(static_cast<int32_t>(1)));
795 ecmaRuntimeCallInfo1->SetCallArg(2, JSTaggedValue(static_cast<int32_t>(3)));
796
797 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo1);
798 JSTaggedValue result = Array::Fill(ecmaRuntimeCallInfo1);
799 TestHelper::TearDownFrame(thread, prev);
800 JSTaggedValue value(static_cast<JSTaggedType>(result.GetRawData()));
801 ASSERT_TRUE(value.IsECMAObject());
802 PropertyDescriptor descRes(thread);
803 JSHandle<JSObject> valueHandle(thread, value);
804 JSObject::GetOwnProperty(thread, valueHandle, key0, descRes);
805 ASSERT_EQ(descRes.GetValue().GetTaggedValue(), JSTaggedValue(1));
806 JSObject::GetOwnProperty(thread, valueHandle, key1, descRes);
807 ASSERT_EQ(descRes.GetValue().GetTaggedValue(), JSTaggedValue(0));
808 JSObject::GetOwnProperty(thread, valueHandle, key2, descRes);
809 ASSERT_EQ(descRes.GetValue().GetTaggedValue(), JSTaggedValue(0));
810 JSObject::GetOwnProperty(thread, valueHandle, key3, descRes);
811 ASSERT_EQ(descRes.GetValue().GetTaggedValue(), JSTaggedValue(4));
812 JSObject::GetOwnProperty(thread, valueHandle, key4, descRes);
813 ASSERT_EQ(descRes.GetValue().GetTaggedValue(), JSTaggedValue(5));
814 }
815
816 // 22.1.3.6 new Array(1,2,3,4,5).Fill(0,1,3)
HWTEST_F_L0(BuiltinsArrayTest,COWArrayFill)817 HWTEST_F_L0(BuiltinsArrayTest, COWArrayFill)
818 {
819 auto ecmaVM = thread->GetEcmaVM();
820 ObjectFactory *factory = ecmaVM->GetFactory();
821
822 JSHandle<TaggedArray> values(factory->NewTaggedArray(5));
823
824 for (int i = 0; i < 5; i++) {
825 values->Set(thread, i, JSTaggedValue(i + 1));
826 }
827 JSHandle<JSArray> array(JSArray::CreateArrayFromList(thread, values));
828 JSHandle<JSArray> cloneArray = factory->CloneArrayLiteral(array);
829
830 auto ecmaRuntimeCallInfo1 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 10);
831 ecmaRuntimeCallInfo1->SetFunction(JSTaggedValue::Undefined());
832 ecmaRuntimeCallInfo1->SetThis(cloneArray.GetTaggedValue());
833 ecmaRuntimeCallInfo1->SetCallArg(0, JSTaggedValue(static_cast<int32_t>(0)));
834 ecmaRuntimeCallInfo1->SetCallArg(1, JSTaggedValue(static_cast<int32_t>(1)));
835 ecmaRuntimeCallInfo1->SetCallArg(2, JSTaggedValue(static_cast<int32_t>(3)));
836
837 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo1);
838 JSTaggedValue result = Array::Fill(ecmaRuntimeCallInfo1);
839 TestHelper::TearDownFrame(thread, prev);
840 JSTaggedValue value(static_cast<JSTaggedType>(result.GetRawData()));
841 ASSERT_TRUE(value.IsECMAObject());
842 PropertyDescriptor descRes(thread);
843 JSHandle<JSObject> valueHandle(thread, value);
844 JSHandle<JSTaggedValue> key0(thread, JSTaggedValue(0));
845 JSHandle<JSTaggedValue> key1(thread, JSTaggedValue(1));
846 JSHandle<JSTaggedValue> key2(thread, JSTaggedValue(2));
847 JSHandle<JSTaggedValue> key3(thread, JSTaggedValue(3));
848 JSHandle<JSTaggedValue> key4(thread, JSTaggedValue(4));
849
850 JSObject::GetOwnProperty(thread, valueHandle, key0, descRes);
851 ASSERT_EQ(descRes.GetValue().GetTaggedValue(), JSTaggedValue(1));
852 JSObject::GetOwnProperty(thread, valueHandle, key1, descRes);
853 ASSERT_EQ(descRes.GetValue().GetTaggedValue(), JSTaggedValue(0));
854 JSObject::GetOwnProperty(thread, valueHandle, key2, descRes);
855 ASSERT_EQ(descRes.GetValue().GetTaggedValue(), JSTaggedValue(0));
856 JSObject::GetOwnProperty(thread, valueHandle, key3, descRes);
857 ASSERT_EQ(descRes.GetValue().GetTaggedValue(), JSTaggedValue(4));
858 JSObject::GetOwnProperty(thread, valueHandle, key4, descRes);
859 ASSERT_EQ(descRes.GetValue().GetTaggedValue(), JSTaggedValue(5));
860 }
861
HWTEST_F_L0(BuiltinsArrayTest,Find)862 HWTEST_F_L0(BuiltinsArrayTest, Find)
863 {
864 auto ecmaVM = thread->GetEcmaVM();
865 JSHandle<GlobalEnv> env = ecmaVM->GetGlobalEnv();
866 ObjectFactory *factory = ecmaVM->GetFactory();
867
868 JSHandle<JSTaggedValue> lengthKeyHandle = thread->GlobalConstants()->GetHandledLengthString();
869 JSArray *arr = JSArray::Cast(JSArray::ArrayCreate(thread, JSTaggedNumber(0)).GetTaggedValue().GetTaggedObject());
870 EXPECT_TRUE(arr != nullptr);
871 JSHandle<JSObject> obj(thread, arr);
872 EXPECT_EQ(JSArray::GetProperty(thread, JSHandle<JSTaggedValue>(obj), lengthKeyHandle).GetValue()->GetInt(), 0);
873 JSHandle<JSTaggedValue> key0(thread, JSTaggedValue(0));
874 PropertyDescriptor desc0(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(1)), true, true, true);
875 JSArray::DefineOwnProperty(thread, obj, key0, desc0);
876 JSHandle<JSTaggedValue> key1(thread, JSTaggedValue(1));
877 PropertyDescriptor desc1(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(102)), true, true, true);
878 JSArray::DefineOwnProperty(thread, obj, key1, desc1);
879 JSHandle<JSTaggedValue> key2(thread, JSTaggedValue(2));
880 PropertyDescriptor desc2(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(3)), true, true, true);
881 JSArray::DefineOwnProperty(thread, obj, key2, desc2);
882 JSHandle<JSArray> jsArray(JSArray::ArrayCreate(thread, JSTaggedNumber(0)));
883 JSHandle<JSFunction> func = factory->NewJSFunction(env, reinterpret_cast<void *>(TestClass::TestFindFunc));
884
885 auto ecmaRuntimeCallInfo1 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 8);
886 ecmaRuntimeCallInfo1->SetFunction(JSTaggedValue::Undefined());
887 ecmaRuntimeCallInfo1->SetThis(obj.GetTaggedValue());
888 ecmaRuntimeCallInfo1->SetCallArg(0, func.GetTaggedValue());
889 ecmaRuntimeCallInfo1->SetCallArg(1, jsArray.GetTaggedValue());
890
891 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo1);
892 JSTaggedValue result2 = Array::Find(ecmaRuntimeCallInfo1);
893 TestHelper::TearDownFrame(thread, prev);
894
895 EXPECT_EQ(result2.GetRawData(), JSTaggedValue(102).GetRawData());
896 }
897
HWTEST_F_L0(BuiltinsArrayTest,FindIndex)898 HWTEST_F_L0(BuiltinsArrayTest, FindIndex)
899 {
900 auto ecmaVM = thread->GetEcmaVM();
901 JSHandle<GlobalEnv> env = ecmaVM->GetGlobalEnv();
902 ObjectFactory *factory = ecmaVM->GetFactory();
903
904 JSHandle<JSTaggedValue> lengthKeyHandle = thread->GlobalConstants()->GetHandledLengthString();
905 JSArray *arr = JSArray::Cast(JSArray::ArrayCreate(thread, JSTaggedNumber(0)).GetTaggedValue().GetTaggedObject());
906 EXPECT_TRUE(arr != nullptr);
907 JSHandle<JSObject> obj(thread, arr);
908 EXPECT_EQ(JSArray::GetProperty(thread, JSHandle<JSTaggedValue>(obj), lengthKeyHandle).GetValue()->GetInt(), 0);
909
910 JSHandle<JSTaggedValue> key0(thread, JSTaggedValue(0));
911 PropertyDescriptor desc0(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(1)), true, true, true);
912 JSArray::DefineOwnProperty(thread, obj, key0, desc0);
913
914 JSHandle<JSTaggedValue> key1(thread, JSTaggedValue(1));
915 PropertyDescriptor desc1(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(2)), true, true, true);
916 JSArray::DefineOwnProperty(thread, obj, key1, desc1);
917 JSHandle<JSTaggedValue> key2(thread, JSTaggedValue(2));
918 PropertyDescriptor desc2(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(30)), true, true, true);
919 JSArray::DefineOwnProperty(thread, obj, key2, desc2);
920
921 JSHandle<JSArray> jsArray(JSArray::ArrayCreate(thread, JSTaggedNumber(0)));
922 JSHandle<JSFunction> func = factory->NewJSFunction(env, reinterpret_cast<void *>(TestClass::TestFindIndexFunc));
923
924 auto ecmaRuntimeCallInfo1 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 8);
925 ecmaRuntimeCallInfo1->SetFunction(JSTaggedValue::Undefined());
926 ecmaRuntimeCallInfo1->SetThis(obj.GetTaggedValue());
927 ecmaRuntimeCallInfo1->SetCallArg(0, func.GetTaggedValue());
928 ecmaRuntimeCallInfo1->SetCallArg(1, jsArray.GetTaggedValue());
929
930 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo1);
931 JSTaggedValue result2 = Array::FindIndex(ecmaRuntimeCallInfo1);
932 TestHelper::TearDownFrame(thread, prev);
933
934 EXPECT_EQ(result2.GetRawData(), JSTaggedValue(static_cast<double>(2)).GetRawData());
935 }
936
HWTEST_F_L0(BuiltinsArrayTest,ForEach)937 HWTEST_F_L0(BuiltinsArrayTest, ForEach)
938 {
939 auto ecmaVM = thread->GetEcmaVM();
940 JSHandle<GlobalEnv> env = ecmaVM->GetGlobalEnv();
941 ObjectFactory *factory = ecmaVM->GetFactory();
942
943 JSHandle<JSTaggedValue> lengthKeyHandle = thread->GlobalConstants()->GetHandledLengthString();
944 JSArray *arr = JSArray::Cast(JSArray::ArrayCreate(thread, JSTaggedNumber(0)).GetTaggedValue().GetTaggedObject());
945 EXPECT_TRUE(arr != nullptr);
946 JSHandle<JSObject> obj(thread, arr);
947 EXPECT_EQ(JSArray::GetProperty(thread, JSHandle<JSTaggedValue>(obj), lengthKeyHandle).GetValue()->GetInt(), 0);
948
949 JSHandle<JSTaggedValue> key0(thread, JSTaggedValue(0));
950 PropertyDescriptor desc0(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(1)), true, true, true);
951 JSArray::DefineOwnProperty(thread, obj, key0, desc0);
952 JSHandle<JSTaggedValue> key1(thread, JSTaggedValue(1));
953 PropertyDescriptor desc1(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(2)), true, true, true);
954 JSArray::DefineOwnProperty(thread, obj, key1, desc1);
955 JSHandle<JSTaggedValue> key2(thread, JSTaggedValue(2));
956 PropertyDescriptor desc2(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(3)), true, true, true);
957 JSArray::DefineOwnProperty(thread, obj, key2, desc2);
958
959 JSHandle<JSArray> jsArray(JSArray::ArrayCreate(thread, JSTaggedNumber(0)));
960 JSHandle<JSFunction> func = factory->NewJSFunction(env, reinterpret_cast<void *>(TestClass::TestForEachFunc));
961
962 auto ecmaRuntimeCallInfo1 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 8);
963 ecmaRuntimeCallInfo1->SetFunction(JSTaggedValue::Undefined());
964 ecmaRuntimeCallInfo1->SetThis(obj.GetTaggedValue());
965 ecmaRuntimeCallInfo1->SetCallArg(0, func.GetTaggedValue());
966 ecmaRuntimeCallInfo1->SetCallArg(1, jsArray.GetTaggedValue());
967
968 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo1);
969 JSTaggedValue result2 = Array::ForEach(ecmaRuntimeCallInfo1);
970 TestHelper::TearDownFrame(thread, prev);
971 EXPECT_EQ(result2.GetRawData(), JSTaggedValue::VALUE_UNDEFINED);
972 EXPECT_EQ(jsArray->GetArrayLength(), 3U);
973 }
974
975 #define ARRAY_DEFINE_OWN_PROPERTY(dest, index, value) \
976 do { \
977 JSHandle<JSTaggedValue> key(thread, JSTaggedValue(index)); \
978 PropertyDescriptor desc(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(value)), true, true, true); \
979 JSArray::DefineOwnProperty(thread, dest, key, desc); \
980 } while (false)
981
982 #define ARRAY_BUILTIN_METHOD_TEST_CASE_ARG0(method, target, expected) \
983 do { \
984 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 6); \
985 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined()); \
986 ecmaRuntimeCallInfo->SetThis((target).GetTaggedValue()); \
987 \
988 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo); \
989 JSTaggedValue result = Array::method(ecmaRuntimeCallInfo); \
990 TestHelper::TearDownFrame(thread, prev); \
991 ASSERT_TRUE(JSTaggedValue::StrictEqual(result, JSTaggedValue(expected))); \
992 } while (false)
993
994 #define ARRAY_BUILTIN_METHOD_TEST_CASE_ARG1(method, target, expected, arg0) \
995 do { \
996 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 6); \
997 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined()); \
998 ecmaRuntimeCallInfo->SetThis((target).GetTaggedValue()); \
999 ecmaRuntimeCallInfo->SetCallArg(0, JSTaggedValue(arg0)); \
1000 \
1001 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo); \
1002 JSTaggedValue result = Array::method(ecmaRuntimeCallInfo); \
1003 TestHelper::TearDownFrame(thread, prev); \
1004 ASSERT_TRUE(JSTaggedValue::StrictEqual(result, JSTaggedValue(expected))); \
1005 } while (false)
1006
1007 #define ARRAY_BUILTIN_METHOD_TEST_CASE_ARG2(method, target, expected, arg0, arg1) \
1008 do { \
1009 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 8); \
1010 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined()); \
1011 ecmaRuntimeCallInfo->SetThis((target).GetTaggedValue()); \
1012 ecmaRuntimeCallInfo->SetCallArg(0, JSTaggedValue(arg0)); \
1013 ecmaRuntimeCallInfo->SetCallArg(1, JSTaggedValue(arg1)); \
1014 \
1015 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo); \
1016 JSTaggedValue result = Array::method(ecmaRuntimeCallInfo); \
1017 TestHelper::TearDownFrame(thread, prev); \
1018 ASSERT_TRUE(JSTaggedValue::StrictEqual(result, JSTaggedValue(expected))); \
1019 } while (false)
1020
1021 // 22.1.3.11 Array.IndexOf(searchElement [ , fromIndex ])
HWTEST_F_L0(BuiltinsArrayTest,IndexOf)1022 HWTEST_F_L0(BuiltinsArrayTest, IndexOf)
1023 {
1024 JSHandle<JSTaggedValue> lengthKeyHandle = thread->GlobalConstants()->GetHandledLengthString();
1025 JSArray *arr = JSArray::Cast(JSArray::ArrayCreate(thread, JSTaggedNumber(0)).GetTaggedValue().GetTaggedObject());
1026 EXPECT_TRUE(arr != nullptr);
1027 JSHandle<JSObject> obj(thread, arr);
1028 EXPECT_EQ(JSArray::GetProperty(thread, JSHandle<JSTaggedValue>(obj), lengthKeyHandle).GetValue()->GetInt(), 0);
1029
1030 // arr = [1, 2, 3, 4, 3, 0, 2.0, +0.0, 3.0, -0.0, <hole>, <hole>, undefined]
1031 ARRAY_DEFINE_OWN_PROPERTY(obj, 0, 1);
1032 ARRAY_DEFINE_OWN_PROPERTY(obj, 1, 2);
1033 ARRAY_DEFINE_OWN_PROPERTY(obj, 2, 3);
1034 ARRAY_DEFINE_OWN_PROPERTY(obj, 3, 4);
1035 ARRAY_DEFINE_OWN_PROPERTY(obj, 4, 3);
1036 ARRAY_DEFINE_OWN_PROPERTY(obj, 5, 0);
1037 ARRAY_DEFINE_OWN_PROPERTY(obj, 6, 2.0);
1038 ARRAY_DEFINE_OWN_PROPERTY(obj, 7, +0.0);
1039 ARRAY_DEFINE_OWN_PROPERTY(obj, 8, 3.0);
1040 ARRAY_DEFINE_OWN_PROPERTY(obj, 9, -0.0);
1041 ARRAY_DEFINE_OWN_PROPERTY(obj, 12, JSTaggedValue::Undefined());
1042
1043 // arr.indexOf(3, 0) == 2
1044 ARRAY_BUILTIN_METHOD_TEST_CASE_ARG2(IndexOf, obj, 2, 3, 0);
1045 // arr.indexOf(3, 3) == 4
1046 ARRAY_BUILTIN_METHOD_TEST_CASE_ARG2(IndexOf, obj, 4, 3, 3);
1047 // arr.indexOf(5, 0) == -1
1048 ARRAY_BUILTIN_METHOD_TEST_CASE_ARG2(IndexOf, obj, -1, 5, 0);
1049 // arr.indexOf(3) == 2
1050 ARRAY_BUILTIN_METHOD_TEST_CASE_ARG1(IndexOf, obj, 2, 3);
1051
1052 // Expects int32_t(x) and double(x) to be strictly equal
1053 // arr.indexOf(3.0) == 2
1054 ARRAY_BUILTIN_METHOD_TEST_CASE_ARG1(IndexOf, obj, 2, 3.0);
1055 // arr.indexOf(3, 5) == 8
1056 ARRAY_BUILTIN_METHOD_TEST_CASE_ARG2(IndexOf, obj, 8, 3, 5);
1057
1058 // Expects 0, +0.0, -0.0 to be strictly equal
1059 // arr.indexOf(+0.0) == 5
1060 ARRAY_BUILTIN_METHOD_TEST_CASE_ARG1(IndexOf, obj, 5, +0.0);
1061 // arr.indexOf(-0.0) == 5
1062 ARRAY_BUILTIN_METHOD_TEST_CASE_ARG1(IndexOf, obj, 5, -0.0);
1063 // arr.indexOf(0, 6) == 7
1064 ARRAY_BUILTIN_METHOD_TEST_CASE_ARG2(IndexOf, obj, 7, 0, 6);
1065 // arr.indexOf(-0.0, 6) == 7
1066 ARRAY_BUILTIN_METHOD_TEST_CASE_ARG2(IndexOf, obj, 7, -0.0, 6);
1067 // arr.indexOf(0, 8) == 9
1068 ARRAY_BUILTIN_METHOD_TEST_CASE_ARG2(IndexOf, obj, 9, 0, 8);
1069 // arr.indexOf(+0.0, 8) == 9
1070 ARRAY_BUILTIN_METHOD_TEST_CASE_ARG2(IndexOf, obj, 9, +0.0, 8);
1071
1072 // Expects undefined to be found
1073 // arr.indexOf() == 12, where the first argument is undefined
1074 ARRAY_BUILTIN_METHOD_TEST_CASE_ARG0(IndexOf, obj, 12);
1075 }
1076
1077 // 22.1.3.14 Array.LastIndexOf(searchElement [ , fromIndex ])
HWTEST_F_L0(BuiltinsArrayTest,LastIndexOf)1078 HWTEST_F_L0(BuiltinsArrayTest, LastIndexOf)
1079 {
1080 JSHandle<JSTaggedValue> lengthKeyHandle = thread->GlobalConstants()->GetHandledLengthString();
1081 JSArray *arr = JSArray::Cast(JSArray::ArrayCreate(thread, JSTaggedNumber(0)).GetTaggedValue().GetTaggedObject());
1082 EXPECT_TRUE(arr != nullptr);
1083 JSHandle<JSObject> obj(thread, arr);
1084 EXPECT_EQ(JSArray::GetProperty(thread, JSHandle<JSTaggedValue>(obj), lengthKeyHandle).GetValue()->GetInt(), 0);
1085
1086 // arr = [1, 2, 3, 4, 3, 0, 2.0, +0.0, 3.0, -0.0, <hole>, <hole>, undefined, <hole>, <hole>, -1]
1087 ARRAY_DEFINE_OWN_PROPERTY(obj, 0, 1);
1088 ARRAY_DEFINE_OWN_PROPERTY(obj, 1, 2);
1089 ARRAY_DEFINE_OWN_PROPERTY(obj, 2, 3);
1090 ARRAY_DEFINE_OWN_PROPERTY(obj, 3, 4);
1091 ARRAY_DEFINE_OWN_PROPERTY(obj, 4, 3);
1092 ARRAY_DEFINE_OWN_PROPERTY(obj, 5, 0);
1093 ARRAY_DEFINE_OWN_PROPERTY(obj, 6, 2.0);
1094 ARRAY_DEFINE_OWN_PROPERTY(obj, 7, +0.0);
1095 ARRAY_DEFINE_OWN_PROPERTY(obj, 8, 3.0);
1096 ARRAY_DEFINE_OWN_PROPERTY(obj, 9, -0.0);
1097 ARRAY_DEFINE_OWN_PROPERTY(obj, 12, JSTaggedValue::Undefined());
1098 ARRAY_DEFINE_OWN_PROPERTY(obj, 15, -1);
1099
1100 // arr.lastIndexOf(3, 4) == 4
1101 ARRAY_BUILTIN_METHOD_TEST_CASE_ARG2(LastIndexOf, obj, 4, 3, 4);
1102 // arr.lastIndexOf(3, 3) == 2
1103 ARRAY_BUILTIN_METHOD_TEST_CASE_ARG2(LastIndexOf, obj, 2, 3, 3);
1104 // arr.lastIndexOf(5, 4) == -1
1105 ARRAY_BUILTIN_METHOD_TEST_CASE_ARG2(LastIndexOf, obj, -1, 5, 4);
1106
1107 // Expects int32_t(x) and double(x) to be strictly equal
1108 // arr.lastIndexOf(3) == 8
1109 ARRAY_BUILTIN_METHOD_TEST_CASE_ARG1(LastIndexOf, obj, 8, 3);
1110 // arr.lastIndexOf(1.0) == 0
1111 ARRAY_BUILTIN_METHOD_TEST_CASE_ARG1(LastIndexOf, obj, 0, 1.0);
1112
1113 // Expects 0, +0.0, -0.0 to be strictly equal
1114 // arr.indexOf(+0.0) == 9
1115 ARRAY_BUILTIN_METHOD_TEST_CASE_ARG1(LastIndexOf, obj, 9, +0.0);
1116 // arr.indexOf(0) == 9
1117 ARRAY_BUILTIN_METHOD_TEST_CASE_ARG1(LastIndexOf, obj, 9, 0);
1118 // arr.indexOf(0, 8) == 7
1119 ARRAY_BUILTIN_METHOD_TEST_CASE_ARG2(LastIndexOf, obj, 7, 0, 8);
1120 // arr.indexOf(-0.0, 8) == 7
1121 ARRAY_BUILTIN_METHOD_TEST_CASE_ARG2(LastIndexOf, obj, 7, -0.0, 8);
1122 // arr.indexOf(-0.0, 6) == 5
1123 ARRAY_BUILTIN_METHOD_TEST_CASE_ARG2(LastIndexOf, obj, 5, -0.0, 6);
1124 // arr.indexOf(+0.0, 6) == 5
1125 ARRAY_BUILTIN_METHOD_TEST_CASE_ARG2(LastIndexOf, obj, 5, +0.0, 6);
1126
1127 // Expects undefined to be found
1128 // arr.indexOf() == 12, where the first argument is undefined
1129 ARRAY_BUILTIN_METHOD_TEST_CASE_ARG0(LastIndexOf, obj, 12);
1130 }
1131
1132 // 22.1.3.11 new Array().Pop()
HWTEST_F_L0(BuiltinsArrayTest,Pop)1133 HWTEST_F_L0(BuiltinsArrayTest, Pop)
1134 {
1135 JSHandle<JSTaggedValue> lengthKeyHandle = thread->GlobalConstants()->GetHandledLengthString();
1136 JSArray *arr = JSArray::Cast(JSArray::ArrayCreate(thread, JSTaggedNumber(0)).GetTaggedValue().GetTaggedObject());
1137 EXPECT_TRUE(arr != nullptr);
1138 JSHandle<JSObject> obj(thread, arr);
1139 EXPECT_EQ(JSArray::GetProperty(thread, JSHandle<JSTaggedValue>(obj), lengthKeyHandle).GetValue()->GetInt(), 0);
1140
1141 auto ecmaRuntimeCallInfo1 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 4);
1142 ecmaRuntimeCallInfo1->SetFunction(JSTaggedValue::Undefined());
1143 ecmaRuntimeCallInfo1->SetThis(obj.GetTaggedValue());
1144
1145 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo1);
1146 JSTaggedValue result = Array::Pop(ecmaRuntimeCallInfo1);
1147 TestHelper::TearDownFrame(thread, prev);
1148 ASSERT_EQ(result.GetRawData(), JSTaggedValue::VALUE_UNDEFINED);
1149 ASSERT_EQ(result.GetRawData(), JSTaggedValue::VALUE_UNDEFINED);
1150
1151 JSHandle<JSTaggedValue> key0(thread, JSTaggedValue(0));
1152 PropertyDescriptor desc0(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(1)), true, true, true);
1153 JSArray::DefineOwnProperty(thread, obj, key0, desc0);
1154 JSHandle<JSTaggedValue> key1(thread, JSTaggedValue(1));
1155 PropertyDescriptor desc1(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(2)), true, true, true);
1156 JSArray::DefineOwnProperty(thread, obj, key1, desc1);
1157 JSHandle<JSTaggedValue> key2(thread, JSTaggedValue(2));
1158 PropertyDescriptor desc2(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(3)), true, true, true);
1159 JSArray::DefineOwnProperty(thread, obj, key2, desc2);
1160
1161 auto ecmaRuntimeCallInfo2 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 4);
1162 ecmaRuntimeCallInfo2->SetFunction(JSTaggedValue::Undefined());
1163 ecmaRuntimeCallInfo2->SetThis(obj.GetTaggedValue());
1164
1165 prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo2);
1166 result = Array::Pop(ecmaRuntimeCallInfo2);
1167 TestHelper::TearDownFrame(thread, prev);
1168 ASSERT_EQ(result.GetRawData(), JSTaggedValue(3).GetRawData());
1169 }
1170
1171 // 22.1.3.11 new Array().Pop()
HWTEST_F_L0(BuiltinsArrayTest,COWArrayPop)1172 HWTEST_F_L0(BuiltinsArrayTest, COWArrayPop)
1173 {
1174 auto ecmaVM = thread->GetEcmaVM();
1175 ObjectFactory *factory = ecmaVM->GetFactory();
1176
1177 JSHandle<TaggedArray> values(factory->NewTaggedArray(3));
1178
1179 for (int i = 0; i < 3; i++) {
1180 values->Set(thread, i, JSTaggedValue(i + 1));
1181 }
1182 JSHandle<JSArray> array(JSArray::CreateArrayFromList(thread, values));
1183 JSHandle<JSArray> cloneArray = factory->CloneArrayLiteral(array);
1184
1185 auto ecmaRuntimeCallInfo1 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 4);
1186 ecmaRuntimeCallInfo1->SetFunction(JSTaggedValue::Undefined());
1187 ecmaRuntimeCallInfo1->SetThis(cloneArray.GetTaggedValue());
1188
1189 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo1);
1190 auto result = Array::Pop(ecmaRuntimeCallInfo1);
1191 TestHelper::TearDownFrame(thread, prev);
1192 ASSERT_EQ(result.GetRawData(), JSTaggedValue(3).GetRawData());
1193 }
1194
1195 // 22.1.3.11 new Array(1,2,3).Push(...items)
HWTEST_F_L0(BuiltinsArrayTest,Push)1196 HWTEST_F_L0(BuiltinsArrayTest, Push)
1197 {
1198 JSHandle<JSTaggedValue> lengthKeyHandle = thread->GlobalConstants()->GetHandledLengthString();
1199 JSArray *arr = JSArray::Cast(JSArray::ArrayCreate(thread, JSTaggedNumber(0)).GetTaggedValue().GetTaggedObject());
1200 EXPECT_TRUE(arr != nullptr);
1201 JSHandle<JSObject> obj(thread, arr);
1202 EXPECT_EQ(JSArray::GetProperty(thread, JSHandle<JSTaggedValue>(obj), lengthKeyHandle).GetValue()->GetInt(), 0);
1203
1204 JSHandle<JSTaggedValue> key0(thread, JSTaggedValue(0));
1205 PropertyDescriptor desc0(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(1)), true, true, true);
1206 JSArray::DefineOwnProperty(thread, obj, key0, desc0);
1207 JSHandle<JSTaggedValue> key1(thread, JSTaggedValue(1));
1208 PropertyDescriptor desc1(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(2)), true, true, true);
1209 JSArray::DefineOwnProperty(thread, obj, key1, desc1);
1210 JSHandle<JSTaggedValue> key2(thread, JSTaggedValue(2));
1211 PropertyDescriptor desc2(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(3)), true, true, true);
1212 JSArray::DefineOwnProperty(thread, obj, key2, desc2);
1213
1214 auto ecmaRuntimeCallInfo1 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 8);
1215 ecmaRuntimeCallInfo1->SetFunction(JSTaggedValue::Undefined());
1216 ecmaRuntimeCallInfo1->SetThis(obj.GetTaggedValue());
1217 ecmaRuntimeCallInfo1->SetCallArg(0, JSTaggedValue(static_cast<int32_t>(4)));
1218 ecmaRuntimeCallInfo1->SetCallArg(1, JSTaggedValue(static_cast<int32_t>(5)));
1219
1220 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo1);
1221 JSTaggedValue result = Array::Push(ecmaRuntimeCallInfo1);
1222 TestHelper::TearDownFrame(thread, prev);
1223 ASSERT_EQ(result.GetNumber(), 5);
1224
1225 EXPECT_EQ(JSArray::GetProperty(thread, JSHandle<JSTaggedValue>(obj), lengthKeyHandle).GetValue()->GetInt(), 5);
1226 JSHandle<JSTaggedValue> key3(thread, JSTaggedValue(3));
1227 EXPECT_EQ(JSArray::GetProperty(thread, JSHandle<JSTaggedValue>(obj), key3).GetValue()->GetInt(), 4);
1228 JSHandle<JSTaggedValue> key4(thread, JSTaggedValue(4));
1229 EXPECT_EQ(JSArray::GetProperty(thread, JSHandle<JSTaggedValue>(obj), key4).GetValue()->GetInt(), 5);
1230 }
1231
HWTEST_F_L0(BuiltinsArrayTest,Reduce)1232 HWTEST_F_L0(BuiltinsArrayTest, Reduce)
1233 {
1234 auto ecmaVM = thread->GetEcmaVM();
1235 JSHandle<GlobalEnv> env = ecmaVM->GetGlobalEnv();
1236 ObjectFactory *factory = ecmaVM->GetFactory();
1237
1238 JSHandle<JSTaggedValue> lengthKeyHandle = thread->GlobalConstants()->GetHandledLengthString();
1239 JSArray *arr = JSArray::Cast(JSArray::ArrayCreate(thread, JSTaggedNumber(0)).GetTaggedValue().GetTaggedObject());
1240 EXPECT_TRUE(arr != nullptr);
1241 JSHandle<JSObject> obj(thread, arr);
1242 EXPECT_EQ(JSArray::GetProperty(thread, JSHandle<JSTaggedValue>(obj), lengthKeyHandle).GetValue()->GetInt(), 0);
1243 JSHandle<JSTaggedValue> key0(thread, JSTaggedValue(0));
1244 PropertyDescriptor desc0(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(1)), true, true, true);
1245 JSArray::DefineOwnProperty(thread, obj, key0, desc0);
1246 JSHandle<JSTaggedValue> key1(thread, JSTaggedValue(1));
1247 PropertyDescriptor desc1(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(2)), true, true, true);
1248 JSArray::DefineOwnProperty(thread, obj, key1, desc1);
1249 JSHandle<JSTaggedValue> key2(thread, JSTaggedValue(2));
1250 PropertyDescriptor desc2(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(3)), true, true, true);
1251 JSArray::DefineOwnProperty(thread, obj, key2, desc2);
1252
1253 JSHandle<JSFunction> func = factory->NewJSFunction(env, reinterpret_cast<void *>(TestClass::TestReduceFunc));
1254
1255 auto ecmaRuntimeCallInfo1 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 8);
1256 ecmaRuntimeCallInfo1->SetFunction(JSTaggedValue::Undefined());
1257 ecmaRuntimeCallInfo1->SetThis(obj.GetTaggedValue());
1258 ecmaRuntimeCallInfo1->SetCallArg(0, func.GetTaggedValue());
1259 ecmaRuntimeCallInfo1->SetCallArg(1, JSTaggedValue(static_cast<int32_t>(10)));
1260
1261 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo1);
1262 JSTaggedValue result = Array::Reduce(ecmaRuntimeCallInfo1);
1263 TestHelper::TearDownFrame(thread, prev);
1264 ASSERT_EQ(result.GetRawData(), JSTaggedValue(16).GetRawData());
1265 }
1266
HWTEST_F_L0(BuiltinsArrayTest,ReduceRight)1267 HWTEST_F_L0(BuiltinsArrayTest, ReduceRight)
1268 {
1269 auto ecmaVM = thread->GetEcmaVM();
1270 JSHandle<GlobalEnv> env = ecmaVM->GetGlobalEnv();
1271 ObjectFactory *factory = ecmaVM->GetFactory();
1272
1273 JSHandle<JSTaggedValue> lengthKeyHandle = thread->GlobalConstants()->GetHandledLengthString();
1274 JSArray *arr = JSArray::Cast(JSArray::ArrayCreate(thread, JSTaggedNumber(0)).GetTaggedValue().GetTaggedObject());
1275 EXPECT_TRUE(arr != nullptr);
1276 JSHandle<JSObject> obj(thread, arr);
1277 EXPECT_EQ(JSArray::GetProperty(thread, JSHandle<JSTaggedValue>(obj), lengthKeyHandle).GetValue()->GetInt(), 0);
1278 JSHandle<JSTaggedValue> key0(thread, JSTaggedValue(0));
1279 PropertyDescriptor desc0(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(1)), true, true, true);
1280 JSArray::DefineOwnProperty(thread, obj, key0, desc0);
1281 JSHandle<JSTaggedValue> key1(thread, JSTaggedValue(1));
1282 PropertyDescriptor desc1(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(2)), true, true, true);
1283 JSArray::DefineOwnProperty(thread, obj, key1, desc1);
1284 JSHandle<JSTaggedValue> key2(thread, JSTaggedValue(2));
1285 PropertyDescriptor desc2(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(3)), true, true, true);
1286 JSArray::DefineOwnProperty(thread, obj, key2, desc2);
1287
1288 JSHandle<JSFunction> func = factory->NewJSFunction(env, reinterpret_cast<void *>(TestClass::TestReduceRightFunc));
1289
1290 auto ecmaRuntimeCallInfo1 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 8);
1291 ecmaRuntimeCallInfo1->SetFunction(JSTaggedValue::Undefined());
1292 ecmaRuntimeCallInfo1->SetThis(obj.GetTaggedValue());
1293 ecmaRuntimeCallInfo1->SetCallArg(0, func.GetTaggedValue());
1294 ecmaRuntimeCallInfo1->SetCallArg(1, JSTaggedValue(static_cast<int32_t>(10)));
1295
1296 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo1);
1297 JSTaggedValue result = Array::ReduceRight(ecmaRuntimeCallInfo1);
1298 TestHelper::TearDownFrame(thread, prev);
1299 ASSERT_EQ(result.GetRawData(), JSTaggedValue(16).GetRawData());
1300 }
1301
HWTEST_F_L0(BuiltinsArrayTest,Shift)1302 HWTEST_F_L0(BuiltinsArrayTest, Shift)
1303 {
1304 JSHandle<JSTaggedValue> lengthKeyHandle = thread->GlobalConstants()->GetHandledLengthString();
1305 JSArray *arr = JSArray::Cast(JSArray::ArrayCreate(thread, JSTaggedNumber(0)).GetTaggedValue().GetTaggedObject());
1306 EXPECT_TRUE(arr != nullptr);
1307 JSHandle<JSObject> obj(thread, arr);
1308 EXPECT_EQ(JSArray::GetProperty(thread, JSHandle<JSTaggedValue>(obj), lengthKeyHandle).GetValue()->GetInt(), 0);
1309
1310 JSHandle<JSTaggedValue> key0(thread, JSTaggedValue(0));
1311 PropertyDescriptor desc0(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(1)), true, true, true);
1312 JSArray::DefineOwnProperty(thread, obj, key0, desc0);
1313 JSHandle<JSTaggedValue> key1(thread, JSTaggedValue(1));
1314 PropertyDescriptor desc1(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(2)), true, true, true);
1315 JSArray::DefineOwnProperty(thread, obj, key1, desc1);
1316 JSHandle<JSTaggedValue> key2(thread, JSTaggedValue(2));
1317 PropertyDescriptor desc2(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(3)), true, true, true);
1318 JSArray::DefineOwnProperty(thread, obj, key2, desc2);
1319
1320 auto ecmaRuntimeCallInfo1 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 4);
1321 ecmaRuntimeCallInfo1->SetFunction(JSTaggedValue::Undefined());
1322 ecmaRuntimeCallInfo1->SetThis(obj.GetTaggedValue());
1323
1324 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo1);
1325 JSTaggedValue result = Array::Shift(ecmaRuntimeCallInfo1);
1326 TestHelper::TearDownFrame(thread, prev);
1327 ASSERT_EQ(result.GetRawData(), JSTaggedValue(1).GetRawData());
1328 }
1329
HWTEST_F_L0(BuiltinsArrayTest,COWArrayShift)1330 HWTEST_F_L0(BuiltinsArrayTest, COWArrayShift)
1331 {
1332 auto ecmaVM = thread->GetEcmaVM();
1333 ObjectFactory *factory = ecmaVM->GetFactory();
1334
1335 JSHandle<TaggedArray> values(factory->NewTaggedArray(3));
1336
1337 for (int i = 0; i < 3; i++) {
1338 values->Set(thread, i, JSTaggedValue(i + 1));
1339 }
1340 JSHandle<JSArray> array(JSArray::CreateArrayFromList(thread, values));
1341 JSHandle<JSArray> cloneArray = factory->CloneArrayLiteral(array);
1342
1343 auto ecmaRuntimeCallInfo1 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 4);
1344 ecmaRuntimeCallInfo1->SetFunction(JSTaggedValue::Undefined());
1345 ecmaRuntimeCallInfo1->SetThis(cloneArray.GetTaggedValue());
1346
1347 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo1);
1348 JSTaggedValue result = Array::Shift(ecmaRuntimeCallInfo1);
1349 TestHelper::TearDownFrame(thread, prev);
1350 ASSERT_EQ(result.GetRawData(), JSTaggedValue(1).GetRawData());
1351 }
1352
HWTEST_F_L0(BuiltinsArrayTest,Some)1353 HWTEST_F_L0(BuiltinsArrayTest, Some)
1354 {
1355 auto ecmaVM = thread->GetEcmaVM();
1356 JSHandle<GlobalEnv> env = ecmaVM->GetGlobalEnv();
1357 ObjectFactory *factory = ecmaVM->GetFactory();
1358
1359 JSHandle<JSTaggedValue> lengthKeyHandle = thread->GlobalConstants()->GetHandledLengthString();
1360 JSArray *arr = JSArray::Cast(JSArray::ArrayCreate(thread, JSTaggedNumber(0)).GetTaggedValue().GetTaggedObject());
1361 EXPECT_TRUE(arr != nullptr);
1362 JSHandle<JSObject> obj(thread, arr);
1363 EXPECT_EQ(JSArray::GetProperty(thread, JSHandle<JSTaggedValue>(obj), lengthKeyHandle).GetValue()->GetInt(), 0);
1364
1365 JSHandle<JSTaggedValue> key0(thread, JSTaggedValue(0));
1366 PropertyDescriptor desc0(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(1)), true, true, true);
1367 JSArray::DefineOwnProperty(thread, obj, key0, desc0);
1368 JSHandle<JSTaggedValue> key1(thread, JSTaggedValue(1));
1369 PropertyDescriptor desc1(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(20)), true, true, true);
1370 JSArray::DefineOwnProperty(thread, obj, key1, desc1);
1371 JSHandle<JSTaggedValue> key2(thread, JSTaggedValue(2));
1372 PropertyDescriptor desc2(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(3)), true, true, true);
1373 JSArray::DefineOwnProperty(thread, obj, key2, desc2);
1374
1375 JSHandle<JSArray> jsArray(JSArray::ArrayCreate(thread, JSTaggedNumber(0)));
1376 JSHandle<JSFunction> func = factory->NewJSFunction(env, reinterpret_cast<void *>(TestClass::TestSomeFunc));
1377
1378 auto ecmaRuntimeCallInfo1 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 8);
1379 ecmaRuntimeCallInfo1->SetFunction(JSTaggedValue::Undefined());
1380 ecmaRuntimeCallInfo1->SetThis(obj.GetTaggedValue());
1381 ecmaRuntimeCallInfo1->SetCallArg(0, func.GetTaggedValue());
1382 ecmaRuntimeCallInfo1->SetCallArg(1, jsArray.GetTaggedValue());
1383
1384 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo1);
1385 JSTaggedValue result2 = Array::Some(ecmaRuntimeCallInfo1);
1386 TestHelper::TearDownFrame(thread, prev);
1387 ASSERT_EQ(result2.GetRawData(), JSTaggedValue::True().GetRawData());
1388 }
1389
HWTEST_F_L0(BuiltinsArrayTest,Sort)1390 HWTEST_F_L0(BuiltinsArrayTest, Sort)
1391 {
1392 JSHandle<JSTaggedValue> lengthKeyHandle = thread->GlobalConstants()->GetHandledLengthString();
1393 JSArray *arr = JSArray::Cast(JSArray::ArrayCreate(thread, JSTaggedNumber(0)).GetTaggedValue().GetTaggedObject());
1394 EXPECT_TRUE(arr != nullptr);
1395 JSHandle<JSObject> obj(thread, arr);
1396 EXPECT_EQ(JSArray::GetProperty(thread, JSHandle<JSTaggedValue>(obj), lengthKeyHandle).GetValue()->GetInt(), 0);
1397
1398 JSHandle<JSTaggedValue> key0(thread, JSTaggedValue(0));
1399 PropertyDescriptor desc0(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(3)), true, true, true);
1400 JSArray::DefineOwnProperty(thread, obj, key0, desc0);
1401 JSHandle<JSTaggedValue> key1(thread, JSTaggedValue(1));
1402 PropertyDescriptor desc1(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(2)), true, true, true);
1403 JSArray::DefineOwnProperty(thread, obj, key1, desc1);
1404 JSHandle<JSTaggedValue> key2(thread, JSTaggedValue(2));
1405 PropertyDescriptor desc2(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(1)), true, true, true);
1406 JSArray::DefineOwnProperty(thread, obj, key2, desc2);
1407
1408 auto ecmaRuntimeCallInfo1 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 4);
1409 ecmaRuntimeCallInfo1->SetFunction(JSTaggedValue::Undefined());
1410 ecmaRuntimeCallInfo1->SetThis(obj.GetTaggedValue());
1411
1412 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo1);
1413 JSTaggedValue result2 = Array::Sort(ecmaRuntimeCallInfo1);
1414 TestHelper::TearDownFrame(thread, prev);
1415
1416 EXPECT_TRUE(result2.IsECMAObject());
1417 JSHandle<JSTaggedValue> resultArr =
1418 JSHandle<JSTaggedValue>(thread, JSTaggedValue(static_cast<JSTaggedType>(result2.GetRawData())));
1419 EXPECT_EQ(JSArray::GetProperty(thread, resultArr, key0).GetValue()->GetInt(), 1);
1420 EXPECT_EQ(JSArray::GetProperty(thread, resultArr, key1).GetValue()->GetInt(), 2);
1421 EXPECT_EQ(JSArray::GetProperty(thread, resultArr, key2).GetValue()->GetInt(), 3);
1422 }
1423
HWTEST_F_L0(BuiltinsArrayTest,Unshift)1424 HWTEST_F_L0(BuiltinsArrayTest, Unshift)
1425 {
1426 JSHandle<JSTaggedValue> lengthKeyHandle = thread->GlobalConstants()->GetHandledLengthString();
1427 JSArray *arr = JSArray::Cast(JSArray::ArrayCreate(thread, JSTaggedNumber(0)).GetTaggedValue().GetTaggedObject());
1428 EXPECT_TRUE(arr != nullptr);
1429 JSHandle<JSObject> obj(thread, arr);
1430 EXPECT_EQ(JSArray::GetProperty(thread, JSHandle<JSTaggedValue>(obj), lengthKeyHandle).GetValue()->GetInt(), 0);
1431
1432 JSHandle<JSTaggedValue> key0(thread, JSTaggedValue(0));
1433 PropertyDescriptor desc0(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(1)), true, true, true);
1434 JSArray::DefineOwnProperty(thread, obj, key0, desc0);
1435 JSHandle<JSTaggedValue> key1(thread, JSTaggedValue(1));
1436 PropertyDescriptor desc1(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(2)), true, true, true);
1437 JSArray::DefineOwnProperty(thread, obj, key1, desc1);
1438 JSHandle<JSTaggedValue> key2(thread, JSTaggedValue(2));
1439 PropertyDescriptor desc2(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(3)), true, true, true);
1440 JSArray::DefineOwnProperty(thread, obj, key2, desc2);
1441
1442 auto ecmaRuntimeCallInfo1 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 8);
1443 ecmaRuntimeCallInfo1->SetFunction(JSTaggedValue::Undefined());
1444 ecmaRuntimeCallInfo1->SetThis(obj.GetTaggedValue());
1445 ecmaRuntimeCallInfo1->SetCallArg(0, JSTaggedValue(static_cast<int32_t>(4)));
1446 ecmaRuntimeCallInfo1->SetCallArg(1, JSTaggedValue(static_cast<int32_t>(5)));
1447
1448 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo1);
1449 JSTaggedValue result = Array::Unshift(ecmaRuntimeCallInfo1);
1450 TestHelper::TearDownFrame(thread, prev);
1451
1452 ASSERT_EQ(result.GetRawData(), JSTaggedValue(static_cast<double>(5)).GetRawData());
1453
1454 EXPECT_EQ(JSArray::GetProperty(thread, JSHandle<JSTaggedValue>(obj), lengthKeyHandle).GetValue()->GetInt(), 5);
1455 JSHandle<JSTaggedValue> key3(thread, JSTaggedValue(0));
1456 EXPECT_EQ(JSArray::GetProperty(thread, JSHandle<JSTaggedValue>(obj), key3).GetValue()->GetInt(), 4);
1457 JSHandle<JSTaggedValue> key4(thread, JSTaggedValue(1));
1458 EXPECT_EQ(JSArray::GetProperty(thread, JSHandle<JSTaggedValue>(obj), key4).GetValue()->GetInt(), 5);
1459 }
1460
HWTEST_F_L0(BuiltinsArrayTest,Join)1461 HWTEST_F_L0(BuiltinsArrayTest, Join)
1462 {
1463 JSHandle<JSTaggedValue> lengthKeyHandle = thread->GlobalConstants()->GetHandledLengthString();
1464 JSArray *arr = JSArray::Cast(JSArray::ArrayCreate(thread, JSTaggedNumber(0)).GetTaggedValue().GetTaggedObject());
1465 EXPECT_TRUE(arr != nullptr);
1466 JSHandle<JSTaggedValue> obj(thread, arr);
1467 EXPECT_EQ(JSArray::GetProperty(thread, obj, lengthKeyHandle).GetValue()->GetInt(), 0);
1468
1469 JSHandle<JSTaggedValue> key0(thread, JSTaggedValue(0));
1470 PropertyDescriptor desc0(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(2)));
1471 JSArray::DefineOwnProperty(thread, JSHandle<JSObject>(obj), key0, desc0);
1472 JSHandle<JSTaggedValue> key1(thread, JSTaggedValue(1));
1473 PropertyDescriptor desc1(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(3)));
1474 JSArray::DefineOwnProperty(thread, JSHandle<JSObject>(obj), key1, desc1);
1475 JSHandle<JSTaggedValue> key2(thread, JSTaggedValue(2));
1476 PropertyDescriptor desc2(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(4)));
1477 JSArray::DefineOwnProperty(thread, JSHandle<JSObject>(obj), key2, desc2);
1478
1479 JSHandle<EcmaString> str = thread->GetEcmaVM()->GetFactory()->NewFromASCII("2,3,4");
1480 auto ecmaRuntimeCallInfo1 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 4);
1481 ecmaRuntimeCallInfo1->SetFunction(JSTaggedValue::Undefined());
1482 ecmaRuntimeCallInfo1->SetThis(obj.GetTaggedValue());
1483
1484 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo1);
1485 JSTaggedValue result = Array::Join(ecmaRuntimeCallInfo1);
1486 TestHelper::TearDownFrame(thread, prev);
1487 JSHandle<EcmaString> resultHandle(thread, reinterpret_cast<EcmaString *>(result.GetRawData()));
1488
1489 ASSERT_EQ(EcmaStringAccessor::Compare(instance, resultHandle, str), 0);
1490 }
1491
HWTEST_F_L0(BuiltinsArrayTest,ToString)1492 HWTEST_F_L0(BuiltinsArrayTest, ToString)
1493 {
1494 JSHandle<JSTaggedValue> lengthKeyHandle = thread->GlobalConstants()->GetHandledLengthString();
1495 JSArray *arr = JSArray::Cast(JSArray::ArrayCreate(thread, JSTaggedNumber(0)).GetTaggedValue().GetTaggedObject());
1496 EXPECT_TRUE(arr != nullptr);
1497 JSHandle<JSTaggedValue> obj(thread, arr);
1498 EXPECT_EQ(JSArray::GetProperty(thread, obj, lengthKeyHandle).GetValue()->GetInt(), 0);
1499
1500 JSHandle<JSTaggedValue> key0(thread, JSTaggedValue(0));
1501 PropertyDescriptor desc0(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(2)));
1502 JSArray::DefineOwnProperty(thread, JSHandle<JSObject>(obj), key0, desc0);
1503 JSHandle<JSTaggedValue> key1(thread, JSTaggedValue(1));
1504 PropertyDescriptor desc1(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(3)));
1505 JSArray::DefineOwnProperty(thread, JSHandle<JSObject>(obj), key1, desc1);
1506 JSHandle<JSTaggedValue> key2(thread, JSTaggedValue(2));
1507 PropertyDescriptor desc2(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(4)));
1508 JSArray::DefineOwnProperty(thread, JSHandle<JSObject>(obj), key2, desc2);
1509
1510 JSHandle<EcmaString> str = thread->GetEcmaVM()->GetFactory()->NewFromASCII("2,3,4");
1511 auto ecmaRuntimeCallInfo1 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 4);
1512 ecmaRuntimeCallInfo1->SetFunction(JSTaggedValue::Undefined());
1513 ecmaRuntimeCallInfo1->SetThis(obj.GetTaggedValue());
1514
1515 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo1);
1516 JSTaggedValue result = Array::ToString(ecmaRuntimeCallInfo1);
1517 TestHelper::TearDownFrame(thread, prev);
1518 JSHandle<EcmaString> resultHandle(thread, reinterpret_cast<EcmaString *>(result.GetRawData()));
1519
1520 ASSERT_EQ(EcmaStringAccessor::Compare(instance, resultHandle, str), 0);
1521 }
1522
HWTEST_F_L0(BuiltinsArrayTest,Includes)1523 HWTEST_F_L0(BuiltinsArrayTest, Includes)
1524 {
1525 JSHandle<JSTaggedValue> lengthKeyHandle = thread->GlobalConstants()->GetHandledLengthString();
1526 JSArray *arr = JSArray::Cast(JSArray::ArrayCreate(thread, JSTaggedNumber(0)).GetTaggedValue().GetTaggedObject());
1527 EXPECT_TRUE(arr != nullptr);
1528 JSHandle<JSTaggedValue> obj(thread, arr);
1529 EXPECT_EQ(JSArray::GetProperty(thread, obj, lengthKeyHandle).GetValue()->GetInt(), 0);
1530
1531 JSHandle<JSTaggedValue> key0(thread, JSTaggedValue(0));
1532 PropertyDescriptor desc0(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(2)));
1533 JSArray::DefineOwnProperty(thread, JSHandle<JSObject>(obj), key0, desc0);
1534 JSHandle<JSTaggedValue> key1(thread, JSTaggedValue(1));
1535 PropertyDescriptor desc1(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(3)));
1536 JSArray::DefineOwnProperty(thread, JSHandle<JSObject>(obj), key1, desc1);
1537 JSHandle<JSTaggedValue> key2(thread, JSTaggedValue(2));
1538 PropertyDescriptor desc2(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(4)));
1539 JSArray::DefineOwnProperty(thread, JSHandle<JSObject>(obj), key2, desc2);
1540
1541 auto ecmaRuntimeCallInfo1 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 6);
1542 ecmaRuntimeCallInfo1->SetFunction(JSTaggedValue::Undefined());
1543 ecmaRuntimeCallInfo1->SetThis(obj.GetTaggedValue());
1544 ecmaRuntimeCallInfo1->SetCallArg(0, JSTaggedValue(static_cast<int32_t>(2)));
1545
1546 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo1);
1547 [[maybe_unused]] JSTaggedValue result = Array::Includes(ecmaRuntimeCallInfo1);
1548 TestHelper::TearDownFrame(thread, prev);
1549
1550 ASSERT_TRUE(result.JSTaggedValue::ToBoolean()); // new Int8Array[2,3,4].includes(2)
1551
1552 auto ecmaRuntimeCallInfo2 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 6);
1553 ecmaRuntimeCallInfo2->SetFunction(JSTaggedValue::Undefined());
1554 ecmaRuntimeCallInfo2->SetThis(obj.GetTaggedValue());
1555 ecmaRuntimeCallInfo2->SetCallArg(0, JSTaggedValue(static_cast<int32_t>(1)));
1556
1557 prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo2);
1558 result = Array::Includes(ecmaRuntimeCallInfo2);
1559 TestHelper::TearDownFrame(thread, prev);
1560
1561 ASSERT_TRUE(!result.JSTaggedValue::ToBoolean()); // new Int8Array[2,3,4].includes(1)
1562
1563 auto ecmaRuntimeCallInfo3 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 8);
1564 ecmaRuntimeCallInfo3->SetFunction(JSTaggedValue::Undefined());
1565 ecmaRuntimeCallInfo3->SetThis(obj.GetTaggedValue());
1566 ecmaRuntimeCallInfo3->SetCallArg(0, JSTaggedValue(static_cast<int32_t>(3)));
1567 ecmaRuntimeCallInfo3->SetCallArg(1, JSTaggedValue(static_cast<int32_t>(1)));
1568
1569 prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo3);
1570 result = Array::Includes(ecmaRuntimeCallInfo3);
1571 TestHelper::TearDownFrame(thread, prev);
1572
1573 ASSERT_TRUE(result.JSTaggedValue::ToBoolean()); // new Int8Array[2,3,4].includes(3, 1)
1574
1575 auto ecmaRuntimeCallInfo4 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 8);
1576 ecmaRuntimeCallInfo4->SetFunction(JSTaggedValue::Undefined());
1577 ecmaRuntimeCallInfo4->SetThis(obj.GetTaggedValue());
1578 ecmaRuntimeCallInfo4->SetCallArg(0, JSTaggedValue(static_cast<int32_t>(2)));
1579 ecmaRuntimeCallInfo4->SetCallArg(1, JSTaggedValue(static_cast<int32_t>(5)));
1580
1581 prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo4);
1582 result = Array::Includes(ecmaRuntimeCallInfo4);
1583 TestHelper::TearDownFrame(thread, prev);
1584
1585 ASSERT_TRUE(!result.JSTaggedValue::ToBoolean()); // new Int8Array[2,3,4].includes(2, 5)
1586
1587 auto ecmaRuntimeCallInfo5 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 8);
1588 ecmaRuntimeCallInfo5->SetFunction(JSTaggedValue::Undefined());
1589 ecmaRuntimeCallInfo5->SetThis(obj.GetTaggedValue());
1590 ecmaRuntimeCallInfo5->SetCallArg(0, JSTaggedValue(static_cast<int32_t>(2)));
1591 ecmaRuntimeCallInfo5->SetCallArg(1, JSTaggedValue(static_cast<int32_t>(-2)));
1592
1593 prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo5);
1594 result = Array::Includes(ecmaRuntimeCallInfo5);
1595 TestHelper::TearDownFrame(thread, prev);
1596
1597 ASSERT_TRUE(!result.JSTaggedValue::ToBoolean()); // new Int8Array[2,3,4].includes(2, -2)
1598 }
1599
1600 // es12 23.1.3.10 new Array(1,[2,3]).flat()
HWTEST_F_L0(BuiltinsArrayTest,Flat)1601 HWTEST_F_L0(BuiltinsArrayTest, Flat)
1602 {
1603 JSHandle<JSTaggedValue> lengthKeyHandle = thread->GlobalConstants()->GetHandledLengthString();
1604 JSArray *arr1 = JSArray::Cast(JSArray::ArrayCreate(thread, JSTaggedNumber(0)).GetTaggedValue().GetTaggedObject());
1605 EXPECT_TRUE(arr1 != nullptr);
1606 JSHandle<JSObject> obj1(thread, arr1);
1607 EXPECT_EQ(JSArray::GetProperty(thread, JSHandle<JSTaggedValue>(obj1), lengthKeyHandle).GetValue()->GetInt(), 0);
1608
1609 JSHandle<JSTaggedValue> key0(thread, JSTaggedValue(0));
1610 PropertyDescriptor desc0(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(1)), true, true, true);
1611 JSArray::DefineOwnProperty(thread, obj1, key0, desc0);
1612
1613 JSArray *arr2 = JSArray::Cast(JSArray::ArrayCreate(thread, JSTaggedNumber(0)).GetTaggedValue().GetTaggedObject());
1614 EXPECT_TRUE(arr2 != nullptr);
1615 JSHandle<JSObject> obj2(thread, arr2);
1616 EXPECT_EQ(JSArray::GetProperty(thread, JSHandle<JSTaggedValue>(obj2), lengthKeyHandle).GetValue()->GetInt(), 0);
1617
1618 PropertyDescriptor desc1(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(2)), true, true, true);
1619 JSArray::DefineOwnProperty(thread, obj2, key0, desc1);
1620
1621 JSHandle<JSTaggedValue> key1(thread, JSTaggedValue(1));
1622 PropertyDescriptor desc2(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(3)), true, true, true);
1623 JSArray::DefineOwnProperty(thread, obj2, key1, desc2);
1624
1625 PropertyDescriptor desc3(thread, JSHandle<JSTaggedValue>(thread, obj2.GetTaggedValue()), true, true, true);
1626 JSArray::DefineOwnProperty(thread, obj1, key1, desc3);
1627
1628 auto ecmaRuntimeCallInfo1 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 4);
1629 ecmaRuntimeCallInfo1->SetFunction(JSTaggedValue::Undefined());
1630 ecmaRuntimeCallInfo1->SetThis(obj1.GetTaggedValue());
1631 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo1);
1632 JSTaggedValue result = Array::Flat(ecmaRuntimeCallInfo1);
1633 TestHelper::TearDownFrame(thread, prev);
1634 JSTaggedValue value(static_cast<JSTaggedType>(result.GetRawData()));
1635 ASSERT_TRUE(value.IsECMAObject());
1636 PropertyDescriptor descRes(thread);
1637 JSHandle<JSObject> valueHandle(thread, value);
1638 JSObject::GetOwnProperty(thread, valueHandle, key0, descRes);
1639 ASSERT_EQ(descRes.GetValue().GetTaggedValue(), JSTaggedValue(1));
1640 JSObject::GetOwnProperty(thread, valueHandle, key1, descRes);
1641 ASSERT_EQ(descRes.GetValue().GetTaggedValue(), JSTaggedValue(2));
1642 JSHandle<JSTaggedValue> key2(thread, JSTaggedValue(2));
1643 JSObject::GetOwnProperty(thread, valueHandle, key2, descRes);
1644 ASSERT_EQ(descRes.GetValue().GetTaggedValue(), JSTaggedValue(3));
1645 }
1646
1647 // es12 23.1.3.10 new Array(1,50,3]).flatMap(x => [x * 2])
HWTEST_F_L0(BuiltinsArrayTest,FlatMap)1648 HWTEST_F_L0(BuiltinsArrayTest, FlatMap)
1649 {
1650 auto ecmaVM = thread->GetEcmaVM();
1651 JSHandle<GlobalEnv> env = ecmaVM->GetGlobalEnv();
1652 ObjectFactory *factory = ecmaVM->GetFactory();
1653
1654 JSHandle<JSTaggedValue> lengthKeyHandle = thread->GlobalConstants()->GetHandledLengthString();
1655 JSArray *arr = JSArray::Cast(JSArray::ArrayCreate(thread, JSTaggedNumber(0)).GetTaggedValue().GetTaggedObject());
1656 EXPECT_TRUE(arr != nullptr);
1657 JSHandle<JSObject> obj(thread, arr);
1658 EXPECT_EQ(JSArray::GetProperty(thread, JSHandle<JSTaggedValue>(obj), lengthKeyHandle).GetValue()->GetInt(), 0);
1659 JSHandle<JSTaggedValue> key0(thread, JSTaggedValue(0));
1660 PropertyDescriptor desc0(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(1)), true, true, true);
1661 JSArray::DefineOwnProperty(thread, obj, key0, desc0);
1662 JSHandle<JSTaggedValue> key1(thread, JSTaggedValue(1));
1663 PropertyDescriptor desc1(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(50)), true, true, true);
1664 JSArray::DefineOwnProperty(thread, obj, key1, desc1);
1665 JSHandle<JSTaggedValue> key2(thread, JSTaggedValue(2));
1666 PropertyDescriptor desc2(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(3)), true, true, true);
1667 JSArray::DefineOwnProperty(thread, obj, key2, desc2);
1668 JSHandle<JSArray> jsArray(JSArray::ArrayCreate(thread, JSTaggedNumber(0)));
1669 JSHandle<JSFunction> func = factory->NewJSFunction(env, reinterpret_cast<void *>(TestClass::TestFlatMapFunc));
1670
1671 auto ecmaRuntimeCallInfo1 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 8);
1672 ecmaRuntimeCallInfo1->SetFunction(JSTaggedValue::Undefined());
1673 ecmaRuntimeCallInfo1->SetThis(obj.GetTaggedValue());
1674 ecmaRuntimeCallInfo1->SetCallArg(0, func.GetTaggedValue());
1675 ecmaRuntimeCallInfo1->SetCallArg(1, jsArray.GetTaggedValue());
1676
1677 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo1);
1678 JSTaggedValue result = Array::FlatMap(ecmaRuntimeCallInfo1);
1679 TestHelper::TearDownFrame(thread, prev);
1680 JSTaggedValue value(static_cast<JSTaggedType>(result.GetRawData()));
1681 ASSERT_TRUE(value.IsECMAObject());
1682
1683 PropertyDescriptor descRes(thread);
1684 JSHandle<JSObject> valueHandle(thread, value);
1685 EXPECT_EQ(
1686 JSArray::GetProperty(thread, JSHandle<JSTaggedValue>(valueHandle), lengthKeyHandle).GetValue()->GetInt(), 3);
1687 JSObject::GetOwnProperty(thread, valueHandle, key0, descRes);
1688
1689 ASSERT_EQ(descRes.GetValue()->GetInt(), 2);
1690 JSObject::GetOwnProperty(thread, valueHandle, key1, descRes);
1691 ASSERT_EQ(descRes.GetValue()->GetInt(), 100);
1692 JSObject::GetOwnProperty(thread, valueHandle, key2, descRes);
1693 ASSERT_EQ(descRes.GetValue()->GetInt(), 6);
1694 }
1695
HWTEST_F_L0(BuiltinsArrayTest,At)1696 HWTEST_F_L0(BuiltinsArrayTest, At)
1697 {
1698 JSHandle<JSTaggedValue> lengthKeyHandle = thread->GlobalConstants()->GetHandledLengthString();
1699 JSArray *arr = JSArray::Cast(JSArray::ArrayCreate(thread, JSTaggedNumber(0)).GetTaggedValue().GetTaggedObject());
1700 EXPECT_TRUE(arr != nullptr);
1701 JSHandle<JSTaggedValue> obj(thread, arr);
1702 EXPECT_EQ(JSArray::GetProperty(thread, obj, lengthKeyHandle).GetValue()->GetInt(), 0);
1703
1704 JSHandle<JSTaggedValue> key0(thread, JSTaggedValue(0));
1705 PropertyDescriptor desc0(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(2)));
1706 JSArray::DefineOwnProperty(thread, JSHandle<JSObject>(obj), key0, desc0);
1707 JSHandle<JSTaggedValue> key1(thread, JSTaggedValue(1));
1708 PropertyDescriptor desc1(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(3)));
1709 JSArray::DefineOwnProperty(thread, JSHandle<JSObject>(obj), key1, desc1);
1710 JSHandle<JSTaggedValue> key2(thread, JSTaggedValue(2));
1711 PropertyDescriptor desc2(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(4)));
1712 JSArray::DefineOwnProperty(thread, JSHandle<JSObject>(obj), key2, desc2);
1713
1714 auto ecmaRuntimeCallInfo1 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 6);
1715 ecmaRuntimeCallInfo1->SetFunction(JSTaggedValue::Undefined());
1716 ecmaRuntimeCallInfo1->SetThis(obj.GetTaggedValue());
1717 ecmaRuntimeCallInfo1->SetCallArg(0, JSTaggedValue(static_cast<int32_t>(0)));
1718 [[maybe_unused]] auto prev1 = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo1);
1719 JSTaggedValue result = Array::At(ecmaRuntimeCallInfo1);
1720 TestHelper::TearDownFrame(thread, prev1);
1721 ASSERT_EQ(result.GetRawData(), JSTaggedValue(2).GetRawData());
1722
1723 auto ecmaRuntimeCallInfo2 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 6);
1724 ecmaRuntimeCallInfo2->SetFunction(JSTaggedValue::Undefined());
1725 ecmaRuntimeCallInfo2->SetThis(obj.GetTaggedValue());
1726 ecmaRuntimeCallInfo2->SetCallArg(0, JSTaggedValue(static_cast<int32_t>(2)));
1727 [[maybe_unused]] auto prev2 = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo2);
1728 result = Array::At(ecmaRuntimeCallInfo2);
1729 TestHelper::TearDownFrame(thread, prev2);
1730 ASSERT_EQ(result.GetRawData(), JSTaggedValue(4).GetRawData());
1731
1732 auto ecmaRuntimeCallInfo3 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 6);
1733 ecmaRuntimeCallInfo3->SetFunction(JSTaggedValue::Undefined());
1734 ecmaRuntimeCallInfo3->SetThis(obj.GetTaggedValue());
1735 ecmaRuntimeCallInfo3->SetCallArg(0, JSTaggedValue(static_cast<int32_t>(3)));
1736 [[maybe_unused]] auto prev3 = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo3);
1737 result = Array::At(ecmaRuntimeCallInfo3);
1738 TestHelper::TearDownFrame(thread, prev3);
1739 ASSERT_EQ(result, JSTaggedValue::Undefined());
1740
1741 auto ecmaRuntimeCallInfo4 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 6);
1742 ecmaRuntimeCallInfo4->SetFunction(JSTaggedValue::Undefined());
1743 ecmaRuntimeCallInfo4->SetThis(obj.GetTaggedValue());
1744 ecmaRuntimeCallInfo4->SetCallArg(0, JSTaggedValue(static_cast<int32_t>(-1)));
1745 [[maybe_unused]] auto prev4 = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo4);
1746 result = Array::At(ecmaRuntimeCallInfo4);
1747 TestHelper::TearDownFrame(thread, prev4);
1748 ASSERT_EQ(result.GetRawData(), JSTaggedValue(4).GetRawData());
1749
1750 auto ecmaRuntimeCallInfo5 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 6);
1751 ecmaRuntimeCallInfo5->SetFunction(JSTaggedValue::Undefined());
1752 ecmaRuntimeCallInfo5->SetThis(obj.GetTaggedValue());
1753 ecmaRuntimeCallInfo5->SetCallArg(0, JSTaggedValue(static_cast<int32_t>(-3)));
1754 [[maybe_unused]] auto prev5 = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo5);
1755 result = Array::At(ecmaRuntimeCallInfo5);
1756 TestHelper::TearDownFrame(thread, prev5);
1757 ASSERT_EQ(result.GetRawData(), JSTaggedValue(2).GetRawData());
1758
1759 auto ecmaRuntimeCallInfo6 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 6);
1760 ecmaRuntimeCallInfo6->SetFunction(JSTaggedValue::Undefined());
1761 ecmaRuntimeCallInfo6->SetThis(obj.GetTaggedValue());
1762 ecmaRuntimeCallInfo6->SetCallArg(0, JSTaggedValue(static_cast<int32_t>(-4)));
1763 [[maybe_unused]] auto prev6 = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo6);
1764 result = Array::At(ecmaRuntimeCallInfo6);
1765 TestHelper::TearDownFrame(thread, prev6);
1766 ASSERT_EQ(result, JSTaggedValue::Undefined());
1767 }
1768
HWTEST_F_L0(BuiltinsArrayTest,With)1769 HWTEST_F_L0(BuiltinsArrayTest, With)
1770 {
1771 JSHandle<JSTaggedValue> lengthKeyHandle = thread->GlobalConstants()->GetHandledLengthString();
1772 JSArray *arr =
1773 JSArray::Cast(JSArray::ArrayCreate(thread, JSTaggedNumber(INT_VALUE_0)).GetTaggedValue().GetTaggedObject());
1774 EXPECT_TRUE(arr != nullptr);
1775 JSHandle<JSObject> obj(thread, arr);
1776 EXPECT_EQ(JSArray::GetProperty(thread, JSHandle<JSTaggedValue>(obj),
1777 lengthKeyHandle).GetValue()->GetInt(), INT_VALUE_0);
1778
1779 JSHandle<JSTaggedValue> key0(thread, JSTaggedValue(static_cast<uint32_t>(ArrayIndex::ARRAY_INDEX_0)));
1780 PropertyDescriptor desc0(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(INT_VALUE_0)), true, true, true);
1781 JSArray::DefineOwnProperty(thread, obj, key0, desc0);
1782 JSHandle<JSTaggedValue> key1(thread, JSTaggedValue(static_cast<uint32_t>(ArrayIndex::ARRAY_INDEX_1)));
1783 PropertyDescriptor desc1(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(INT_VALUE_1)), true, true, true);
1784 JSArray::DefineOwnProperty(thread, obj, key1, desc1);
1785 JSHandle<JSTaggedValue> key2(thread, JSTaggedValue(static_cast<uint32_t>(ArrayIndex::ARRAY_INDEX_2)));
1786 PropertyDescriptor desc2(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(INT_VALUE_2)), true, true, true);
1787 JSArray::DefineOwnProperty(thread, obj, key2, desc2);
1788
1789 auto ecmaRuntimeCallInfo1 =
1790 TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), RUNTIME_CALL_INFO_PARA_NUM_8);
1791 ecmaRuntimeCallInfo1->SetFunction(JSTaggedValue::Undefined());
1792 ecmaRuntimeCallInfo1->SetThis(obj.GetTaggedValue());
1793 ecmaRuntimeCallInfo1->SetCallArg(RUNTIME_CALL_INFO_PARA_0,
1794 JSTaggedValue(static_cast<uint32_t>((ArrayIndex::ARRAY_INDEX_1))));
1795 ecmaRuntimeCallInfo1->SetCallArg(RUNTIME_CALL_INFO_PARA_1, JSTaggedValue(INT_VALUE_3));
1796
1797 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo1);
1798 JSTaggedValue result = Array::With(ecmaRuntimeCallInfo1);
1799 TestHelper::TearDownFrame(thread, prev);
1800
1801 EXPECT_TRUE(result.IsECMAObject());
1802 JSHandle<JSTaggedValue> resultArr =
1803 JSHandle<JSTaggedValue>(thread, JSTaggedValue(static_cast<JSTaggedType>(result.GetRawData())));
1804 EXPECT_EQ(JSArray::GetProperty(thread, resultArr, key0).GetValue()->GetInt(), INT_VALUE_0);
1805 EXPECT_EQ(JSArray::GetProperty(thread, resultArr, key1).GetValue()->GetInt(), INT_VALUE_3);
1806 EXPECT_EQ(JSArray::GetProperty(thread, resultArr, key2).GetValue()->GetInt(), INT_VALUE_2);
1807 }
1808
HWTEST_F_L0(BuiltinsArrayTest,ToSorted)1809 HWTEST_F_L0(BuiltinsArrayTest, ToSorted)
1810 {
1811 JSHandle<JSTaggedValue> lengthKeyHandle = thread->GlobalConstants()->GetHandledLengthString();
1812 JSArray *arr =
1813 JSArray::Cast(JSArray::ArrayCreate(thread, JSTaggedNumber(INT_VALUE_0)).GetTaggedValue().GetTaggedObject());
1814 EXPECT_TRUE(arr != nullptr);
1815 JSHandle<JSObject> obj(thread, arr);
1816 EXPECT_EQ(JSArray::GetProperty(thread, JSHandle<JSTaggedValue>(obj),
1817 lengthKeyHandle).GetValue()->GetInt(), INT_VALUE_0);
1818 JSHandle<JSTaggedValue> key0(thread, JSTaggedValue(INT_VALUE_0));
1819 PropertyDescriptor desc0(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(INT_VALUE_3)), true, true, true);
1820 JSArray::DefineOwnProperty(thread, obj, key0, desc0);
1821 JSHandle<JSTaggedValue> key1(thread, JSTaggedValue(INT_VALUE_1));
1822 PropertyDescriptor desc1(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(INT_VALUE_2)), true, true, true);
1823 JSArray::DefineOwnProperty(thread, obj, key1, desc1);
1824 JSHandle<JSTaggedValue> key2(thread, JSTaggedValue(INT_VALUE_2));
1825 PropertyDescriptor desc2(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(INT_VALUE_1)), true, true, true);
1826 JSArray::DefineOwnProperty(thread, obj, key2, desc2);
1827
1828 auto ecmaRuntimeCallInfo1 =
1829 TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), RUNTIME_CALL_INFO_PARA_NUM_4);
1830 ecmaRuntimeCallInfo1->SetFunction(JSTaggedValue::Undefined());
1831 ecmaRuntimeCallInfo1->SetThis(obj.GetTaggedValue());
1832
1833 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo1);
1834 JSTaggedValue result2 = Array::ToSorted(ecmaRuntimeCallInfo1);
1835 TestHelper::TearDownFrame(thread, prev);
1836
1837 EXPECT_TRUE(result2.IsECMAObject());
1838 JSHandle<JSTaggedValue> resultArr =
1839 JSHandle<JSTaggedValue>(thread, JSTaggedValue(static_cast<JSTaggedType>(result2.GetRawData())));
1840 EXPECT_EQ(JSArray::GetProperty(thread, resultArr, key0).GetValue()->GetInt(), INT_VALUE_1);
1841 EXPECT_EQ(JSArray::GetProperty(thread, resultArr, key1).GetValue()->GetInt(), INT_VALUE_2);
1842 EXPECT_EQ(JSArray::GetProperty(thread, resultArr, key2).GetValue()->GetInt(), INT_VALUE_3);
1843 }
1844
HWTEST_F_L0(BuiltinsArrayTest,ToSpliced)1845 HWTEST_F_L0(BuiltinsArrayTest, ToSpliced)
1846 {
1847 JSHandle<JSTaggedValue> lengthKeyHandle = thread->GlobalConstants()->GetHandledLengthString();
1848 JSArray *arr =
1849 JSArray::Cast(JSArray::ArrayCreate(thread, JSTaggedNumber(INT_VALUE_0)).GetTaggedValue().GetTaggedObject());
1850 EXPECT_TRUE(arr != nullptr);
1851 JSHandle<JSObject> obj(thread, arr);
1852 EXPECT_EQ(JSArray::GetProperty(thread, JSHandle<JSTaggedValue>(obj),
1853 lengthKeyHandle).GetValue()->GetInt(), INT_VALUE_0);
1854 JSHandle<JSTaggedValue> key0(thread, JSTaggedValue(INT_VALUE_0));
1855 PropertyDescriptor desc0(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(INT_VALUE_0)), true, true, true);
1856 JSArray::DefineOwnProperty(thread, obj, key0, desc0);
1857 JSHandle<JSTaggedValue> key1(thread, JSTaggedValue(INT_VALUE_1));
1858 PropertyDescriptor desc1(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(INT_VALUE_1)), true, true, true);
1859 JSArray::DefineOwnProperty(thread, obj, key1, desc1);
1860 JSHandle<JSTaggedValue> key2(thread, JSTaggedValue(INT_VALUE_2));
1861 PropertyDescriptor desc2(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(INT_VALUE_2)), true, true, true);
1862 JSArray::DefineOwnProperty(thread, obj, key2, desc2);
1863
1864 auto ecmaRuntimeCallInfo1 =
1865 TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), RUNTIME_CALL_INFO_PARA_NUM_10);
1866 ecmaRuntimeCallInfo1->SetFunction(JSTaggedValue::Undefined());
1867 ecmaRuntimeCallInfo1->SetThis(obj.GetTaggedValue());
1868 ecmaRuntimeCallInfo1->SetCallArg(INT_VALUE_0, JSTaggedValue(INT_VALUE_1));
1869 ecmaRuntimeCallInfo1->SetCallArg(INT_VALUE_1, JSTaggedValue(INT_VALUE_1));
1870 ecmaRuntimeCallInfo1->SetCallArg(INT_VALUE_2, JSTaggedValue(INT_VALUE_666));
1871
1872 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo1);
1873 JSTaggedValue result2 = Array::ToSpliced(ecmaRuntimeCallInfo1);
1874 TestHelper::TearDownFrame(thread, prev);
1875
1876 EXPECT_TRUE(result2.IsECMAObject());
1877 JSHandle<JSTaggedValue> resultArr =
1878 JSHandle<JSTaggedValue>(thread, JSTaggedValue(static_cast<JSTaggedType>(result2.GetRawData())));
1879 EXPECT_EQ(JSArray::GetProperty(thread, resultArr, key0).GetValue()->GetInt(), INT_VALUE_0);
1880 EXPECT_EQ(JSArray::GetProperty(thread, resultArr, key1).GetValue()->GetInt(), INT_VALUE_666);
1881 EXPECT_EQ(JSArray::GetProperty(thread, resultArr, key2).GetValue()->GetInt(), INT_VALUE_2);
1882 }
1883
HWTEST_F_L0(BuiltinsArrayTest,FindLast)1884 HWTEST_F_L0(BuiltinsArrayTest, FindLast)
1885 {
1886 auto ecmaVM = thread->GetEcmaVM();
1887 JSHandle<GlobalEnv> env = ecmaVM->GetGlobalEnv();
1888 ObjectFactory *factory = ecmaVM->GetFactory();
1889
1890 JSHandle<JSTaggedValue> lengthKeyHandle = thread->GlobalConstants()->GetHandledLengthString();
1891 JSArray *arr = JSArray::Cast(JSArray::ArrayCreate(thread, JSTaggedNumber(0)).GetTaggedValue().GetTaggedObject());
1892 EXPECT_TRUE(arr != nullptr);
1893 JSHandle<JSObject> obj(thread, arr);
1894 EXPECT_EQ(JSArray::GetProperty(thread, JSHandle<JSTaggedValue>(obj), lengthKeyHandle).GetValue()->GetInt(), 0);
1895 // arr [50, 40, 2]
1896 JSHandle<JSTaggedValue> key0(thread, JSTaggedValue(0));
1897 PropertyDescriptor desc0(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(50)), true, true, true);
1898 JSArray::DefineOwnProperty(thread, obj, key0, desc0);
1899 JSHandle<JSTaggedValue> key1(thread, JSTaggedValue(1));
1900 PropertyDescriptor desc1(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(40)), true, true, true);
1901 JSArray::DefineOwnProperty(thread, obj, key1, desc1);
1902 JSHandle<JSTaggedValue> key2(thread, JSTaggedValue(2));
1903 PropertyDescriptor desc2(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(2)), true, true, true);
1904 JSArray::DefineOwnProperty(thread, obj, key2, desc2);
1905 JSHandle<JSArray> jsArray(JSArray::ArrayCreate(thread, JSTaggedNumber(0)));
1906 JSHandle<JSFunction> func = factory->NewJSFunction(env, reinterpret_cast<void *>(TestClass::TestFindLastFunc));
1907
1908 auto ecmaRuntimeCallInfo1 =
1909 TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 8); // 8 means 2 call args
1910 ecmaRuntimeCallInfo1->SetFunction(JSTaggedValue::Undefined());
1911 ecmaRuntimeCallInfo1->SetThis(obj.GetTaggedValue());
1912 ecmaRuntimeCallInfo1->SetCallArg(0, func.GetTaggedValue());
1913 ecmaRuntimeCallInfo1->SetCallArg(1, jsArray.GetTaggedValue());
1914
1915 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo1);
1916 JSTaggedValue result = Array::FindLast(ecmaRuntimeCallInfo1);
1917 TestHelper::TearDownFrame(thread, prev);
1918
1919 EXPECT_EQ(result.GetRawData(), JSTaggedValue(40).GetRawData());
1920 }
1921
HWTEST_F_L0(BuiltinsArrayTest,FindLastIndex)1922 HWTEST_F_L0(BuiltinsArrayTest, FindLastIndex)
1923 {
1924 auto ecmaVM = thread->GetEcmaVM();
1925 JSHandle<GlobalEnv> env = ecmaVM->GetGlobalEnv();
1926 ObjectFactory *factory = ecmaVM->GetFactory();
1927
1928 JSHandle<JSTaggedValue> lengthKeyHandle = thread->GlobalConstants()->GetHandledLengthString();
1929 JSArray *arr = JSArray::Cast(JSArray::ArrayCreate(thread, JSTaggedNumber(0)).GetTaggedValue().GetTaggedObject());
1930 EXPECT_TRUE(arr != nullptr);
1931 JSHandle<JSObject> obj(thread, arr);
1932 EXPECT_EQ(JSArray::GetProperty(thread, JSHandle<JSTaggedValue>(obj), lengthKeyHandle).GetValue()->GetInt(), 0);
1933
1934 // arr [50, 40, 30]
1935 JSHandle<JSTaggedValue> key0(thread, JSTaggedValue(0));
1936 PropertyDescriptor desc0(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(50)), true, true, true);
1937 JSArray::DefineOwnProperty(thread, obj, key0, desc0);
1938
1939 JSHandle<JSTaggedValue> key1(thread, JSTaggedValue(1));
1940 PropertyDescriptor desc1(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(40)), true, true, true);
1941 JSArray::DefineOwnProperty(thread, obj, key1, desc1);
1942
1943 JSHandle<JSTaggedValue> key2(thread, JSTaggedValue(2));
1944 PropertyDescriptor desc2(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(30)), true, true, true);
1945 JSArray::DefineOwnProperty(thread, obj, key2, desc2);
1946
1947 JSHandle<JSArray> jsArray(JSArray::ArrayCreate(thread, JSTaggedNumber(0)));
1948 JSHandle<JSFunction> func = factory->NewJSFunction(env, reinterpret_cast<void *>(TestClass::TestFindLastIndexFunc));
1949
1950 auto ecmaRuntimeCallInfo1 =
1951 TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 8); // 8 means 2 call args
1952 ecmaRuntimeCallInfo1->SetFunction(JSTaggedValue::Undefined());
1953 ecmaRuntimeCallInfo1->SetThis(obj.GetTaggedValue());
1954 ecmaRuntimeCallInfo1->SetCallArg(0, func.GetTaggedValue());
1955 ecmaRuntimeCallInfo1->SetCallArg(1, jsArray.GetTaggedValue());
1956
1957 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo1);
1958 JSTaggedValue result = Array::FindLastIndex(ecmaRuntimeCallInfo1);
1959 TestHelper::TearDownFrame(thread, prev);
1960
1961 EXPECT_EQ(result.GetRawData(), JSTaggedValue(static_cast<double>(2)).GetRawData());
1962 }
1963
HWTEST_F_L0(BuiltinsArrayTest,ToReversed)1964 HWTEST_F_L0(BuiltinsArrayTest, ToReversed)
1965 {
1966 JSHandle<JSTaggedValue> lengthKeyHandle = thread->GlobalConstants()->GetHandledLengthString();
1967 JSArray *arr = JSArray::Cast(JSArray::ArrayCreate(thread, JSTaggedNumber(0)).GetTaggedValue().GetTaggedObject());
1968 EXPECT_TRUE(arr != nullptr);
1969 JSHandle<JSObject> obj(thread, arr);
1970 EXPECT_EQ(JSArray::GetProperty(thread, JSHandle<JSTaggedValue>(obj),
1971 lengthKeyHandle).GetValue()->GetInt(), INT_VALUE_0);
1972 JSHandle<JSTaggedValue> key0(thread, JSTaggedValue(INT_VALUE_0));
1973 PropertyDescriptor desc0(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(INT_VALUE_50)), true, true, true);
1974 JSArray::DefineOwnProperty(thread, obj, key0, desc0);
1975 JSHandle<JSTaggedValue> key1(thread, JSTaggedValue(INT_VALUE_1));
1976 PropertyDescriptor desc1(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(INT_VALUE_200)), true, true, true);
1977 JSArray::DefineOwnProperty(thread, obj, key1, desc1);
1978 JSHandle<JSTaggedValue> key2(thread, JSTaggedValue(INT_VALUE_2));
1979 PropertyDescriptor desc2(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(INT_VALUE_3)), true, true, true);
1980 JSArray::DefineOwnProperty(thread, obj, key2, desc2);
1981
1982 auto ecmaRuntimeCallInfo1 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), INT_VALUE_4);
1983 ecmaRuntimeCallInfo1->SetFunction(JSTaggedValue::Undefined());
1984 ecmaRuntimeCallInfo1->SetThis(obj.GetTaggedValue());
1985
1986 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo1);
1987 JSTaggedValue result = Array::ToReversed(ecmaRuntimeCallInfo1);
1988 TestHelper::TearDownFrame(thread, prev);
1989 JSTaggedValue value(static_cast<JSTaggedType>(result.GetRawData()));
1990 ASSERT_TRUE(value.IsECMAObject());
1991
1992 PropertyDescriptor descRes(thread);
1993 JSHandle<JSObject> valueHandle(thread, value);
1994 EXPECT_EQ(JSArray::GetProperty(thread, JSHandle<JSTaggedValue>(valueHandle),
1995 lengthKeyHandle).GetValue()->GetInt(), INT_VALUE_3);
1996 JSObject::GetOwnProperty(thread, valueHandle, key0, descRes);
1997 ASSERT_EQ(descRes.GetValue().GetTaggedValue(), JSTaggedValue(INT_VALUE_3));
1998 JSObject::GetOwnProperty(thread, valueHandle, key1, descRes);
1999 ASSERT_EQ(descRes.GetValue().GetTaggedValue(), JSTaggedValue(INT_VALUE_200));
2000 JSObject::GetOwnProperty(thread, valueHandle, key2, descRes);
2001 ASSERT_EQ(descRes.GetValue().GetTaggedValue(), JSTaggedValue(INT_VALUE_50));
2002 EXPECT_EQ(JSArray::GetProperty(thread, JSHandle<JSTaggedValue>(obj),
2003 lengthKeyHandle).GetValue()->GetInt(), INT_VALUE_3);
2004 JSObject::GetOwnProperty(thread, obj, key0, descRes);
2005 ASSERT_EQ(descRes.GetValue().GetTaggedValue(), JSTaggedValue(INT_VALUE_50));
2006 JSObject::GetOwnProperty(thread, obj, key1, descRes);
2007 ASSERT_EQ(descRes.GetValue().GetTaggedValue(), JSTaggedValue(INT_VALUE_200));
2008 JSObject::GetOwnProperty(thread, obj, key2, descRes);
2009 ASSERT_EQ(descRes.GetValue().GetTaggedValue(), JSTaggedValue(INT_VALUE_3));
2010 }
2011 } // namespace panda::test
2012