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 // 22.1.3.11 new Array(1,2,3,4,3).IndexOf(searchElement [ , fromIndex ])
HWTEST_F_L0(BuiltinsArrayTest,IndexOf)976 HWTEST_F_L0(BuiltinsArrayTest, IndexOf)
977 {
978 JSHandle<JSTaggedValue> lengthKeyHandle = thread->GlobalConstants()->GetHandledLengthString();
979 JSArray *arr = JSArray::Cast(JSArray::ArrayCreate(thread, JSTaggedNumber(0)).GetTaggedValue().GetTaggedObject());
980 EXPECT_TRUE(arr != nullptr);
981 JSHandle<JSObject> obj(thread, arr);
982 EXPECT_EQ(JSArray::GetProperty(thread, JSHandle<JSTaggedValue>(obj), lengthKeyHandle).GetValue()->GetInt(), 0);
983
984 JSHandle<JSTaggedValue> key0(thread, JSTaggedValue(0));
985 PropertyDescriptor desc0(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(1)), true, true, true);
986 JSArray::DefineOwnProperty(thread, obj, key0, desc0);
987 JSHandle<JSTaggedValue> key1(thread, JSTaggedValue(1));
988 PropertyDescriptor desc1(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(2)), true, true, true);
989 JSArray::DefineOwnProperty(thread, obj, key1, desc1);
990 JSHandle<JSTaggedValue> key2(thread, JSTaggedValue(2));
991 PropertyDescriptor desc2(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(3)), true, true, true);
992 JSArray::DefineOwnProperty(thread, obj, key2, desc2);
993 JSHandle<JSTaggedValue> key3(thread, JSTaggedValue(3));
994 PropertyDescriptor desc3(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(4)), true, true, true);
995 JSArray::DefineOwnProperty(thread, obj, key3, desc3);
996 JSHandle<JSTaggedValue> key4(thread, JSTaggedValue(4));
997 PropertyDescriptor desc4(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(3)), true, true, true);
998 JSArray::DefineOwnProperty(thread, obj, key4, desc4);
999
1000 auto ecmaRuntimeCallInfo1 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 8);
1001 ecmaRuntimeCallInfo1->SetFunction(JSTaggedValue::Undefined());
1002 ecmaRuntimeCallInfo1->SetThis(obj.GetTaggedValue());
1003 ecmaRuntimeCallInfo1->SetCallArg(0, JSTaggedValue(static_cast<int32_t>(3)));
1004 ecmaRuntimeCallInfo1->SetCallArg(1, JSTaggedValue(static_cast<int32_t>(0)));
1005
1006 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo1);
1007 JSTaggedValue result = Array::IndexOf(ecmaRuntimeCallInfo1);
1008 TestHelper::TearDownFrame(thread, prev);
1009 ASSERT_EQ(result.GetRawData(), JSTaggedValue(2).GetRawData());
1010
1011 auto ecmaRuntimeCallInfo2 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 8);
1012 ecmaRuntimeCallInfo2->SetFunction(JSTaggedValue::Undefined());
1013 ecmaRuntimeCallInfo2->SetThis(obj.GetTaggedValue());
1014 ecmaRuntimeCallInfo2->SetCallArg(0, JSTaggedValue(static_cast<int32_t>(3)));
1015 ecmaRuntimeCallInfo2->SetCallArg(1, JSTaggedValue(static_cast<int32_t>(3)));
1016
1017 prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo2);
1018 result = Array::IndexOf(ecmaRuntimeCallInfo2);
1019 TestHelper::TearDownFrame(thread, prev);
1020 ASSERT_EQ(result.GetRawData(), JSTaggedValue(4).GetRawData());
1021
1022 auto ecmaRuntimeCallInfo3 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 8);
1023 ecmaRuntimeCallInfo3->SetFunction(JSTaggedValue::Undefined());
1024 ecmaRuntimeCallInfo3->SetThis(obj.GetTaggedValue());
1025 ecmaRuntimeCallInfo3->SetCallArg(0, JSTaggedValue(static_cast<int32_t>(5)));
1026 ecmaRuntimeCallInfo3->SetCallArg(1, JSTaggedValue(static_cast<int32_t>(0)));
1027
1028 prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo3);
1029 result = Array::IndexOf(ecmaRuntimeCallInfo3);
1030 TestHelper::TearDownFrame(thread, prev);
1031 ASSERT_EQ(result.GetRawData(), JSTaggedValue(-1).GetRawData());
1032
1033 auto ecmaRuntimeCallInfo4 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 6);
1034 ecmaRuntimeCallInfo4->SetFunction(JSTaggedValue::Undefined());
1035 ecmaRuntimeCallInfo4->SetThis(obj.GetTaggedValue());
1036 ecmaRuntimeCallInfo4->SetCallArg(0, JSTaggedValue(static_cast<int32_t>(3)));
1037
1038 prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo4);
1039 result = Array::IndexOf(ecmaRuntimeCallInfo4);
1040 TestHelper::TearDownFrame(thread, prev);
1041 ASSERT_EQ(result.GetRawData(), JSTaggedValue(2).GetRawData());
1042 }
1043
1044 // 22.1.3.14 new Array(1,2,3,4,3).LastIndexOf(searchElement [ , fromIndex ])
HWTEST_F_L0(BuiltinsArrayTest,LastIndexOf)1045 HWTEST_F_L0(BuiltinsArrayTest, LastIndexOf)
1046 {
1047 JSHandle<JSTaggedValue> lengthKeyHandle = thread->GlobalConstants()->GetHandledLengthString();
1048 JSArray *arr = JSArray::Cast(JSArray::ArrayCreate(thread, JSTaggedNumber(0)).GetTaggedValue().GetTaggedObject());
1049 EXPECT_TRUE(arr != nullptr);
1050 JSHandle<JSObject> obj(thread, arr);
1051 EXPECT_EQ(JSArray::GetProperty(thread, JSHandle<JSTaggedValue>(obj), lengthKeyHandle).GetValue()->GetInt(), 0);
1052
1053 JSHandle<JSTaggedValue> key0(thread, JSTaggedValue(0));
1054 PropertyDescriptor desc0(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(1)), true, true, true);
1055 JSArray::DefineOwnProperty(thread, obj, key0, desc0);
1056 JSHandle<JSTaggedValue> key1(thread, JSTaggedValue(1));
1057 PropertyDescriptor desc1(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(2)), true, true, true);
1058 JSArray::DefineOwnProperty(thread, obj, key1, desc1);
1059 JSHandle<JSTaggedValue> key2(thread, JSTaggedValue(2));
1060 PropertyDescriptor desc2(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(3)), true, true, true);
1061 JSArray::DefineOwnProperty(thread, obj, key2, desc2);
1062 JSHandle<JSTaggedValue> key3(thread, JSTaggedValue(3));
1063 PropertyDescriptor desc3(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(4)), true, true, true);
1064 JSArray::DefineOwnProperty(thread, obj, key3, desc3);
1065 JSHandle<JSTaggedValue> key4(thread, JSTaggedValue(4));
1066 PropertyDescriptor desc4(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(3)), true, true, true);
1067 JSArray::DefineOwnProperty(thread, obj, key4, desc4);
1068
1069 // new Array(1,2,3,4,3).LastIndexOf(3,4)
1070 auto ecmaRuntimeCallInfo1 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 8);
1071 ecmaRuntimeCallInfo1->SetFunction(JSTaggedValue::Undefined());
1072 ecmaRuntimeCallInfo1->SetThis(obj.GetTaggedValue());
1073 ecmaRuntimeCallInfo1->SetCallArg(0, JSTaggedValue(static_cast<int32_t>(3)));
1074 ecmaRuntimeCallInfo1->SetCallArg(1, JSTaggedValue(static_cast<int32_t>(4)));
1075
1076 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo1);
1077 JSTaggedValue result = Array::LastIndexOf(ecmaRuntimeCallInfo1);
1078 TestHelper::TearDownFrame(thread, prev);
1079 ASSERT_EQ(result.GetRawData(), JSTaggedValue(static_cast<double>(4)).GetRawData());
1080
1081 // new Array(1,2,3,4,3).LastIndexOf(3,3)
1082 auto ecmaRuntimeCallInfo2 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 8);
1083 ecmaRuntimeCallInfo2->SetFunction(JSTaggedValue::Undefined());
1084 ecmaRuntimeCallInfo2->SetThis(obj.GetTaggedValue());
1085 ecmaRuntimeCallInfo2->SetCallArg(0, JSTaggedValue(static_cast<int32_t>(3)));
1086 ecmaRuntimeCallInfo2->SetCallArg(1, JSTaggedValue(static_cast<int32_t>(3)));
1087
1088 prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo2);
1089 result = Array::LastIndexOf(ecmaRuntimeCallInfo2);
1090 TestHelper::TearDownFrame(thread, prev);
1091 ASSERT_EQ(result.GetRawData(), JSTaggedValue(static_cast<double>(2)).GetRawData());
1092
1093 // new Array(1,2,3,4,3).LastIndexOf(5,4)
1094 auto ecmaRuntimeCallInfo3 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 8);
1095 ecmaRuntimeCallInfo3->SetFunction(JSTaggedValue::Undefined());
1096 ecmaRuntimeCallInfo3->SetThis(obj.GetTaggedValue());
1097 ecmaRuntimeCallInfo3->SetCallArg(0, JSTaggedValue(static_cast<int32_t>(5)));
1098 ecmaRuntimeCallInfo3->SetCallArg(1, JSTaggedValue(static_cast<int32_t>(4)));
1099
1100 prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo3);
1101 result = Array::LastIndexOf(ecmaRuntimeCallInfo3);
1102 TestHelper::TearDownFrame(thread, prev);
1103 ASSERT_EQ(result.GetRawData(), JSTaggedValue(-1).GetRawData());
1104
1105 // new Array(1,2,3,4,3).LastIndexOf(3)
1106 auto ecmaRuntimeCallInfo4 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 6);
1107 ecmaRuntimeCallInfo4->SetFunction(JSTaggedValue::Undefined());
1108 ecmaRuntimeCallInfo4->SetThis(obj.GetTaggedValue());
1109 ecmaRuntimeCallInfo4->SetCallArg(0, JSTaggedValue(static_cast<int32_t>(3)));
1110
1111 prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo4);
1112 result = Array::LastIndexOf(ecmaRuntimeCallInfo4);
1113 TestHelper::TearDownFrame(thread, prev);
1114 ASSERT_EQ(result.GetRawData(), JSTaggedValue(static_cast<double>(4)).GetRawData());
1115 }
1116
1117 // 22.1.3.11 new Array().Pop()
HWTEST_F_L0(BuiltinsArrayTest,Pop)1118 HWTEST_F_L0(BuiltinsArrayTest, Pop)
1119 {
1120 JSHandle<JSTaggedValue> lengthKeyHandle = thread->GlobalConstants()->GetHandledLengthString();
1121 JSArray *arr = JSArray::Cast(JSArray::ArrayCreate(thread, JSTaggedNumber(0)).GetTaggedValue().GetTaggedObject());
1122 EXPECT_TRUE(arr != nullptr);
1123 JSHandle<JSObject> obj(thread, arr);
1124 EXPECT_EQ(JSArray::GetProperty(thread, JSHandle<JSTaggedValue>(obj), lengthKeyHandle).GetValue()->GetInt(), 0);
1125
1126 auto ecmaRuntimeCallInfo1 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 4);
1127 ecmaRuntimeCallInfo1->SetFunction(JSTaggedValue::Undefined());
1128 ecmaRuntimeCallInfo1->SetThis(obj.GetTaggedValue());
1129
1130 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo1);
1131 JSTaggedValue result = Array::Pop(ecmaRuntimeCallInfo1);
1132 TestHelper::TearDownFrame(thread, prev);
1133 ASSERT_EQ(result.GetRawData(), JSTaggedValue::VALUE_UNDEFINED);
1134 ASSERT_EQ(result.GetRawData(), JSTaggedValue::VALUE_UNDEFINED);
1135
1136 JSHandle<JSTaggedValue> key0(thread, JSTaggedValue(0));
1137 PropertyDescriptor desc0(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(1)), true, true, true);
1138 JSArray::DefineOwnProperty(thread, obj, key0, desc0);
1139 JSHandle<JSTaggedValue> key1(thread, JSTaggedValue(1));
1140 PropertyDescriptor desc1(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(2)), true, true, true);
1141 JSArray::DefineOwnProperty(thread, obj, key1, desc1);
1142 JSHandle<JSTaggedValue> key2(thread, JSTaggedValue(2));
1143 PropertyDescriptor desc2(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(3)), true, true, true);
1144 JSArray::DefineOwnProperty(thread, obj, key2, desc2);
1145
1146 auto ecmaRuntimeCallInfo2 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 4);
1147 ecmaRuntimeCallInfo2->SetFunction(JSTaggedValue::Undefined());
1148 ecmaRuntimeCallInfo2->SetThis(obj.GetTaggedValue());
1149
1150 prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo2);
1151 result = Array::Pop(ecmaRuntimeCallInfo2);
1152 TestHelper::TearDownFrame(thread, prev);
1153 ASSERT_EQ(result.GetRawData(), JSTaggedValue(3).GetRawData());
1154 }
1155
1156 // 22.1.3.11 new Array().Pop()
HWTEST_F_L0(BuiltinsArrayTest,COWArrayPop)1157 HWTEST_F_L0(BuiltinsArrayTest, COWArrayPop)
1158 {
1159 auto ecmaVM = thread->GetEcmaVM();
1160 ObjectFactory *factory = ecmaVM->GetFactory();
1161
1162 JSHandle<TaggedArray> values(factory->NewTaggedArray(3));
1163
1164 for (int i = 0; i < 3; i++) {
1165 values->Set(thread, i, JSTaggedValue(i + 1));
1166 }
1167 JSHandle<JSArray> array(JSArray::CreateArrayFromList(thread, values));
1168 JSHandle<JSArray> cloneArray = factory->CloneArrayLiteral(array);
1169
1170 auto ecmaRuntimeCallInfo1 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 4);
1171 ecmaRuntimeCallInfo1->SetFunction(JSTaggedValue::Undefined());
1172 ecmaRuntimeCallInfo1->SetThis(cloneArray.GetTaggedValue());
1173
1174 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo1);
1175 auto result = Array::Pop(ecmaRuntimeCallInfo1);
1176 TestHelper::TearDownFrame(thread, prev);
1177 ASSERT_EQ(result.GetRawData(), JSTaggedValue(3).GetRawData());
1178 }
1179
1180 // 22.1.3.11 new Array(1,2,3).Push(...items)
HWTEST_F_L0(BuiltinsArrayTest,Push)1181 HWTEST_F_L0(BuiltinsArrayTest, Push)
1182 {
1183 JSHandle<JSTaggedValue> lengthKeyHandle = thread->GlobalConstants()->GetHandledLengthString();
1184 JSArray *arr = JSArray::Cast(JSArray::ArrayCreate(thread, JSTaggedNumber(0)).GetTaggedValue().GetTaggedObject());
1185 EXPECT_TRUE(arr != nullptr);
1186 JSHandle<JSObject> obj(thread, arr);
1187 EXPECT_EQ(JSArray::GetProperty(thread, JSHandle<JSTaggedValue>(obj), lengthKeyHandle).GetValue()->GetInt(), 0);
1188
1189 JSHandle<JSTaggedValue> key0(thread, JSTaggedValue(0));
1190 PropertyDescriptor desc0(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(1)), true, true, true);
1191 JSArray::DefineOwnProperty(thread, obj, key0, desc0);
1192 JSHandle<JSTaggedValue> key1(thread, JSTaggedValue(1));
1193 PropertyDescriptor desc1(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(2)), true, true, true);
1194 JSArray::DefineOwnProperty(thread, obj, key1, desc1);
1195 JSHandle<JSTaggedValue> key2(thread, JSTaggedValue(2));
1196 PropertyDescriptor desc2(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(3)), true, true, true);
1197 JSArray::DefineOwnProperty(thread, obj, key2, desc2);
1198
1199 auto ecmaRuntimeCallInfo1 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 8);
1200 ecmaRuntimeCallInfo1->SetFunction(JSTaggedValue::Undefined());
1201 ecmaRuntimeCallInfo1->SetThis(obj.GetTaggedValue());
1202 ecmaRuntimeCallInfo1->SetCallArg(0, JSTaggedValue(static_cast<int32_t>(4)));
1203 ecmaRuntimeCallInfo1->SetCallArg(1, JSTaggedValue(static_cast<int32_t>(5)));
1204
1205 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo1);
1206 JSTaggedValue result = Array::Push(ecmaRuntimeCallInfo1);
1207 TestHelper::TearDownFrame(thread, prev);
1208 ASSERT_EQ(result.GetNumber(), 5);
1209
1210 EXPECT_EQ(JSArray::GetProperty(thread, JSHandle<JSTaggedValue>(obj), lengthKeyHandle).GetValue()->GetInt(), 5);
1211 JSHandle<JSTaggedValue> key3(thread, JSTaggedValue(3));
1212 EXPECT_EQ(JSArray::GetProperty(thread, JSHandle<JSTaggedValue>(obj), key3).GetValue()->GetInt(), 4);
1213 JSHandle<JSTaggedValue> key4(thread, JSTaggedValue(4));
1214 EXPECT_EQ(JSArray::GetProperty(thread, JSHandle<JSTaggedValue>(obj), key4).GetValue()->GetInt(), 5);
1215 }
1216
HWTEST_F_L0(BuiltinsArrayTest,Reduce)1217 HWTEST_F_L0(BuiltinsArrayTest, Reduce)
1218 {
1219 auto ecmaVM = thread->GetEcmaVM();
1220 JSHandle<GlobalEnv> env = ecmaVM->GetGlobalEnv();
1221 ObjectFactory *factory = ecmaVM->GetFactory();
1222
1223 JSHandle<JSTaggedValue> lengthKeyHandle = thread->GlobalConstants()->GetHandledLengthString();
1224 JSArray *arr = JSArray::Cast(JSArray::ArrayCreate(thread, JSTaggedNumber(0)).GetTaggedValue().GetTaggedObject());
1225 EXPECT_TRUE(arr != nullptr);
1226 JSHandle<JSObject> obj(thread, arr);
1227 EXPECT_EQ(JSArray::GetProperty(thread, JSHandle<JSTaggedValue>(obj), lengthKeyHandle).GetValue()->GetInt(), 0);
1228 JSHandle<JSTaggedValue> key0(thread, JSTaggedValue(0));
1229 PropertyDescriptor desc0(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(1)), true, true, true);
1230 JSArray::DefineOwnProperty(thread, obj, key0, desc0);
1231 JSHandle<JSTaggedValue> key1(thread, JSTaggedValue(1));
1232 PropertyDescriptor desc1(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(2)), true, true, true);
1233 JSArray::DefineOwnProperty(thread, obj, key1, desc1);
1234 JSHandle<JSTaggedValue> key2(thread, JSTaggedValue(2));
1235 PropertyDescriptor desc2(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(3)), true, true, true);
1236 JSArray::DefineOwnProperty(thread, obj, key2, desc2);
1237
1238 JSHandle<JSFunction> func = factory->NewJSFunction(env, reinterpret_cast<void *>(TestClass::TestReduceFunc));
1239
1240 auto ecmaRuntimeCallInfo1 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 8);
1241 ecmaRuntimeCallInfo1->SetFunction(JSTaggedValue::Undefined());
1242 ecmaRuntimeCallInfo1->SetThis(obj.GetTaggedValue());
1243 ecmaRuntimeCallInfo1->SetCallArg(0, func.GetTaggedValue());
1244 ecmaRuntimeCallInfo1->SetCallArg(1, JSTaggedValue(static_cast<int32_t>(10)));
1245
1246 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo1);
1247 JSTaggedValue result = Array::Reduce(ecmaRuntimeCallInfo1);
1248 TestHelper::TearDownFrame(thread, prev);
1249 ASSERT_EQ(result.GetRawData(), JSTaggedValue(16).GetRawData());
1250 }
1251
HWTEST_F_L0(BuiltinsArrayTest,ReduceRight)1252 HWTEST_F_L0(BuiltinsArrayTest, ReduceRight)
1253 {
1254 auto ecmaVM = thread->GetEcmaVM();
1255 JSHandle<GlobalEnv> env = ecmaVM->GetGlobalEnv();
1256 ObjectFactory *factory = ecmaVM->GetFactory();
1257
1258 JSHandle<JSTaggedValue> lengthKeyHandle = thread->GlobalConstants()->GetHandledLengthString();
1259 JSArray *arr = JSArray::Cast(JSArray::ArrayCreate(thread, JSTaggedNumber(0)).GetTaggedValue().GetTaggedObject());
1260 EXPECT_TRUE(arr != nullptr);
1261 JSHandle<JSObject> obj(thread, arr);
1262 EXPECT_EQ(JSArray::GetProperty(thread, JSHandle<JSTaggedValue>(obj), lengthKeyHandle).GetValue()->GetInt(), 0);
1263 JSHandle<JSTaggedValue> key0(thread, JSTaggedValue(0));
1264 PropertyDescriptor desc0(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(1)), true, true, true);
1265 JSArray::DefineOwnProperty(thread, obj, key0, desc0);
1266 JSHandle<JSTaggedValue> key1(thread, JSTaggedValue(1));
1267 PropertyDescriptor desc1(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(2)), true, true, true);
1268 JSArray::DefineOwnProperty(thread, obj, key1, desc1);
1269 JSHandle<JSTaggedValue> key2(thread, JSTaggedValue(2));
1270 PropertyDescriptor desc2(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(3)), true, true, true);
1271 JSArray::DefineOwnProperty(thread, obj, key2, desc2);
1272
1273 JSHandle<JSFunction> func = factory->NewJSFunction(env, reinterpret_cast<void *>(TestClass::TestReduceRightFunc));
1274
1275 auto ecmaRuntimeCallInfo1 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 8);
1276 ecmaRuntimeCallInfo1->SetFunction(JSTaggedValue::Undefined());
1277 ecmaRuntimeCallInfo1->SetThis(obj.GetTaggedValue());
1278 ecmaRuntimeCallInfo1->SetCallArg(0, func.GetTaggedValue());
1279 ecmaRuntimeCallInfo1->SetCallArg(1, JSTaggedValue(static_cast<int32_t>(10)));
1280
1281 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo1);
1282 JSTaggedValue result = Array::ReduceRight(ecmaRuntimeCallInfo1);
1283 TestHelper::TearDownFrame(thread, prev);
1284 ASSERT_EQ(result.GetRawData(), JSTaggedValue(16).GetRawData());
1285 }
1286
HWTEST_F_L0(BuiltinsArrayTest,Shift)1287 HWTEST_F_L0(BuiltinsArrayTest, Shift)
1288 {
1289 JSHandle<JSTaggedValue> lengthKeyHandle = thread->GlobalConstants()->GetHandledLengthString();
1290 JSArray *arr = JSArray::Cast(JSArray::ArrayCreate(thread, JSTaggedNumber(0)).GetTaggedValue().GetTaggedObject());
1291 EXPECT_TRUE(arr != nullptr);
1292 JSHandle<JSObject> obj(thread, arr);
1293 EXPECT_EQ(JSArray::GetProperty(thread, JSHandle<JSTaggedValue>(obj), lengthKeyHandle).GetValue()->GetInt(), 0);
1294
1295 JSHandle<JSTaggedValue> key0(thread, JSTaggedValue(0));
1296 PropertyDescriptor desc0(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(1)), true, true, true);
1297 JSArray::DefineOwnProperty(thread, obj, key0, desc0);
1298 JSHandle<JSTaggedValue> key1(thread, JSTaggedValue(1));
1299 PropertyDescriptor desc1(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(2)), true, true, true);
1300 JSArray::DefineOwnProperty(thread, obj, key1, desc1);
1301 JSHandle<JSTaggedValue> key2(thread, JSTaggedValue(2));
1302 PropertyDescriptor desc2(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(3)), true, true, true);
1303 JSArray::DefineOwnProperty(thread, obj, key2, desc2);
1304
1305 auto ecmaRuntimeCallInfo1 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 4);
1306 ecmaRuntimeCallInfo1->SetFunction(JSTaggedValue::Undefined());
1307 ecmaRuntimeCallInfo1->SetThis(obj.GetTaggedValue());
1308
1309 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo1);
1310 JSTaggedValue result = Array::Shift(ecmaRuntimeCallInfo1);
1311 TestHelper::TearDownFrame(thread, prev);
1312 ASSERT_EQ(result.GetRawData(), JSTaggedValue(1).GetRawData());
1313 }
1314
HWTEST_F_L0(BuiltinsArrayTest,COWArrayShift)1315 HWTEST_F_L0(BuiltinsArrayTest, COWArrayShift)
1316 {
1317 auto ecmaVM = thread->GetEcmaVM();
1318 ObjectFactory *factory = ecmaVM->GetFactory();
1319
1320 JSHandle<TaggedArray> values(factory->NewTaggedArray(3));
1321
1322 for (int i = 0; i < 3; i++) {
1323 values->Set(thread, i, JSTaggedValue(i + 1));
1324 }
1325 JSHandle<JSArray> array(JSArray::CreateArrayFromList(thread, values));
1326 JSHandle<JSArray> cloneArray = factory->CloneArrayLiteral(array);
1327
1328 auto ecmaRuntimeCallInfo1 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 4);
1329 ecmaRuntimeCallInfo1->SetFunction(JSTaggedValue::Undefined());
1330 ecmaRuntimeCallInfo1->SetThis(cloneArray.GetTaggedValue());
1331
1332 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo1);
1333 JSTaggedValue result = Array::Shift(ecmaRuntimeCallInfo1);
1334 TestHelper::TearDownFrame(thread, prev);
1335 ASSERT_EQ(result.GetRawData(), JSTaggedValue(1).GetRawData());
1336 }
1337
HWTEST_F_L0(BuiltinsArrayTest,Some)1338 HWTEST_F_L0(BuiltinsArrayTest, Some)
1339 {
1340 auto ecmaVM = thread->GetEcmaVM();
1341 JSHandle<GlobalEnv> env = ecmaVM->GetGlobalEnv();
1342 ObjectFactory *factory = ecmaVM->GetFactory();
1343
1344 JSHandle<JSTaggedValue> lengthKeyHandle = thread->GlobalConstants()->GetHandledLengthString();
1345 JSArray *arr = JSArray::Cast(JSArray::ArrayCreate(thread, JSTaggedNumber(0)).GetTaggedValue().GetTaggedObject());
1346 EXPECT_TRUE(arr != nullptr);
1347 JSHandle<JSObject> obj(thread, arr);
1348 EXPECT_EQ(JSArray::GetProperty(thread, JSHandle<JSTaggedValue>(obj), lengthKeyHandle).GetValue()->GetInt(), 0);
1349
1350 JSHandle<JSTaggedValue> key0(thread, JSTaggedValue(0));
1351 PropertyDescriptor desc0(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(1)), true, true, true);
1352 JSArray::DefineOwnProperty(thread, obj, key0, desc0);
1353 JSHandle<JSTaggedValue> key1(thread, JSTaggedValue(1));
1354 PropertyDescriptor desc1(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(20)), true, true, true);
1355 JSArray::DefineOwnProperty(thread, obj, key1, desc1);
1356 JSHandle<JSTaggedValue> key2(thread, JSTaggedValue(2));
1357 PropertyDescriptor desc2(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(3)), true, true, true);
1358 JSArray::DefineOwnProperty(thread, obj, key2, desc2);
1359
1360 JSHandle<JSArray> jsArray(JSArray::ArrayCreate(thread, JSTaggedNumber(0)));
1361 JSHandle<JSFunction> func = factory->NewJSFunction(env, reinterpret_cast<void *>(TestClass::TestSomeFunc));
1362
1363 auto ecmaRuntimeCallInfo1 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 8);
1364 ecmaRuntimeCallInfo1->SetFunction(JSTaggedValue::Undefined());
1365 ecmaRuntimeCallInfo1->SetThis(obj.GetTaggedValue());
1366 ecmaRuntimeCallInfo1->SetCallArg(0, func.GetTaggedValue());
1367 ecmaRuntimeCallInfo1->SetCallArg(1, jsArray.GetTaggedValue());
1368
1369 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo1);
1370 JSTaggedValue result2 = Array::Some(ecmaRuntimeCallInfo1);
1371 TestHelper::TearDownFrame(thread, prev);
1372 ASSERT_EQ(result2.GetRawData(), JSTaggedValue::True().GetRawData());
1373 }
1374
HWTEST_F_L0(BuiltinsArrayTest,Sort)1375 HWTEST_F_L0(BuiltinsArrayTest, Sort)
1376 {
1377 JSHandle<JSTaggedValue> lengthKeyHandle = thread->GlobalConstants()->GetHandledLengthString();
1378 JSArray *arr = JSArray::Cast(JSArray::ArrayCreate(thread, JSTaggedNumber(0)).GetTaggedValue().GetTaggedObject());
1379 EXPECT_TRUE(arr != nullptr);
1380 JSHandle<JSObject> obj(thread, arr);
1381 EXPECT_EQ(JSArray::GetProperty(thread, JSHandle<JSTaggedValue>(obj), lengthKeyHandle).GetValue()->GetInt(), 0);
1382
1383 JSHandle<JSTaggedValue> key0(thread, JSTaggedValue(0));
1384 PropertyDescriptor desc0(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(3)), true, true, true);
1385 JSArray::DefineOwnProperty(thread, obj, key0, desc0);
1386 JSHandle<JSTaggedValue> key1(thread, JSTaggedValue(1));
1387 PropertyDescriptor desc1(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(2)), true, true, true);
1388 JSArray::DefineOwnProperty(thread, obj, key1, desc1);
1389 JSHandle<JSTaggedValue> key2(thread, JSTaggedValue(2));
1390 PropertyDescriptor desc2(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(1)), true, true, true);
1391 JSArray::DefineOwnProperty(thread, obj, key2, desc2);
1392
1393 auto ecmaRuntimeCallInfo1 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 4);
1394 ecmaRuntimeCallInfo1->SetFunction(JSTaggedValue::Undefined());
1395 ecmaRuntimeCallInfo1->SetThis(obj.GetTaggedValue());
1396
1397 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo1);
1398 JSTaggedValue result2 = Array::Sort(ecmaRuntimeCallInfo1);
1399 TestHelper::TearDownFrame(thread, prev);
1400
1401 EXPECT_TRUE(result2.IsECMAObject());
1402 JSHandle<JSTaggedValue> resultArr =
1403 JSHandle<JSTaggedValue>(thread, JSTaggedValue(static_cast<JSTaggedType>(result2.GetRawData())));
1404 EXPECT_EQ(JSArray::GetProperty(thread, resultArr, key0).GetValue()->GetInt(), 1);
1405 EXPECT_EQ(JSArray::GetProperty(thread, resultArr, key1).GetValue()->GetInt(), 2);
1406 EXPECT_EQ(JSArray::GetProperty(thread, resultArr, key2).GetValue()->GetInt(), 3);
1407 }
1408
HWTEST_F_L0(BuiltinsArrayTest,Unshift)1409 HWTEST_F_L0(BuiltinsArrayTest, Unshift)
1410 {
1411 JSHandle<JSTaggedValue> lengthKeyHandle = thread->GlobalConstants()->GetHandledLengthString();
1412 JSArray *arr = JSArray::Cast(JSArray::ArrayCreate(thread, JSTaggedNumber(0)).GetTaggedValue().GetTaggedObject());
1413 EXPECT_TRUE(arr != nullptr);
1414 JSHandle<JSObject> obj(thread, arr);
1415 EXPECT_EQ(JSArray::GetProperty(thread, JSHandle<JSTaggedValue>(obj), lengthKeyHandle).GetValue()->GetInt(), 0);
1416
1417 JSHandle<JSTaggedValue> key0(thread, JSTaggedValue(0));
1418 PropertyDescriptor desc0(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(1)), true, true, true);
1419 JSArray::DefineOwnProperty(thread, obj, key0, desc0);
1420 JSHandle<JSTaggedValue> key1(thread, JSTaggedValue(1));
1421 PropertyDescriptor desc1(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(2)), true, true, true);
1422 JSArray::DefineOwnProperty(thread, obj, key1, desc1);
1423 JSHandle<JSTaggedValue> key2(thread, JSTaggedValue(2));
1424 PropertyDescriptor desc2(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(3)), true, true, true);
1425 JSArray::DefineOwnProperty(thread, obj, key2, desc2);
1426
1427 auto ecmaRuntimeCallInfo1 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 8);
1428 ecmaRuntimeCallInfo1->SetFunction(JSTaggedValue::Undefined());
1429 ecmaRuntimeCallInfo1->SetThis(obj.GetTaggedValue());
1430 ecmaRuntimeCallInfo1->SetCallArg(0, JSTaggedValue(static_cast<int32_t>(4)));
1431 ecmaRuntimeCallInfo1->SetCallArg(1, JSTaggedValue(static_cast<int32_t>(5)));
1432
1433 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo1);
1434 JSTaggedValue result = Array::Unshift(ecmaRuntimeCallInfo1);
1435 TestHelper::TearDownFrame(thread, prev);
1436
1437 ASSERT_EQ(result.GetRawData(), JSTaggedValue(static_cast<double>(5)).GetRawData());
1438
1439 EXPECT_EQ(JSArray::GetProperty(thread, JSHandle<JSTaggedValue>(obj), lengthKeyHandle).GetValue()->GetInt(), 5);
1440 JSHandle<JSTaggedValue> key3(thread, JSTaggedValue(0));
1441 EXPECT_EQ(JSArray::GetProperty(thread, JSHandle<JSTaggedValue>(obj), key3).GetValue()->GetInt(), 4);
1442 JSHandle<JSTaggedValue> key4(thread, JSTaggedValue(1));
1443 EXPECT_EQ(JSArray::GetProperty(thread, JSHandle<JSTaggedValue>(obj), key4).GetValue()->GetInt(), 5);
1444 }
1445
HWTEST_F_L0(BuiltinsArrayTest,Join)1446 HWTEST_F_L0(BuiltinsArrayTest, Join)
1447 {
1448 JSHandle<JSTaggedValue> lengthKeyHandle = thread->GlobalConstants()->GetHandledLengthString();
1449 JSArray *arr = JSArray::Cast(JSArray::ArrayCreate(thread, JSTaggedNumber(0)).GetTaggedValue().GetTaggedObject());
1450 EXPECT_TRUE(arr != nullptr);
1451 JSHandle<JSTaggedValue> obj(thread, arr);
1452 EXPECT_EQ(JSArray::GetProperty(thread, obj, lengthKeyHandle).GetValue()->GetInt(), 0);
1453
1454 JSHandle<JSTaggedValue> key0(thread, JSTaggedValue(0));
1455 PropertyDescriptor desc0(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(2)));
1456 JSArray::DefineOwnProperty(thread, JSHandle<JSObject>(obj), key0, desc0);
1457 JSHandle<JSTaggedValue> key1(thread, JSTaggedValue(1));
1458 PropertyDescriptor desc1(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(3)));
1459 JSArray::DefineOwnProperty(thread, JSHandle<JSObject>(obj), key1, desc1);
1460 JSHandle<JSTaggedValue> key2(thread, JSTaggedValue(2));
1461 PropertyDescriptor desc2(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(4)));
1462 JSArray::DefineOwnProperty(thread, JSHandle<JSObject>(obj), key2, desc2);
1463
1464 JSHandle<EcmaString> str = thread->GetEcmaVM()->GetFactory()->NewFromASCII("2,3,4");
1465 auto ecmaRuntimeCallInfo1 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 4);
1466 ecmaRuntimeCallInfo1->SetFunction(JSTaggedValue::Undefined());
1467 ecmaRuntimeCallInfo1->SetThis(obj.GetTaggedValue());
1468
1469 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo1);
1470 JSTaggedValue result = Array::Join(ecmaRuntimeCallInfo1);
1471 TestHelper::TearDownFrame(thread, prev);
1472 JSHandle<EcmaString> resultHandle(thread, reinterpret_cast<EcmaString *>(result.GetRawData()));
1473
1474 ASSERT_EQ(EcmaStringAccessor::Compare(instance, resultHandle, str), 0);
1475 }
1476
HWTEST_F_L0(BuiltinsArrayTest,ToString)1477 HWTEST_F_L0(BuiltinsArrayTest, ToString)
1478 {
1479 JSHandle<JSTaggedValue> lengthKeyHandle = thread->GlobalConstants()->GetHandledLengthString();
1480 JSArray *arr = JSArray::Cast(JSArray::ArrayCreate(thread, JSTaggedNumber(0)).GetTaggedValue().GetTaggedObject());
1481 EXPECT_TRUE(arr != nullptr);
1482 JSHandle<JSTaggedValue> obj(thread, arr);
1483 EXPECT_EQ(JSArray::GetProperty(thread, obj, lengthKeyHandle).GetValue()->GetInt(), 0);
1484
1485 JSHandle<JSTaggedValue> key0(thread, JSTaggedValue(0));
1486 PropertyDescriptor desc0(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(2)));
1487 JSArray::DefineOwnProperty(thread, JSHandle<JSObject>(obj), key0, desc0);
1488 JSHandle<JSTaggedValue> key1(thread, JSTaggedValue(1));
1489 PropertyDescriptor desc1(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(3)));
1490 JSArray::DefineOwnProperty(thread, JSHandle<JSObject>(obj), key1, desc1);
1491 JSHandle<JSTaggedValue> key2(thread, JSTaggedValue(2));
1492 PropertyDescriptor desc2(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(4)));
1493 JSArray::DefineOwnProperty(thread, JSHandle<JSObject>(obj), key2, desc2);
1494
1495 JSHandle<EcmaString> str = thread->GetEcmaVM()->GetFactory()->NewFromASCII("2,3,4");
1496 auto ecmaRuntimeCallInfo1 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 4);
1497 ecmaRuntimeCallInfo1->SetFunction(JSTaggedValue::Undefined());
1498 ecmaRuntimeCallInfo1->SetThis(obj.GetTaggedValue());
1499
1500 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo1);
1501 JSTaggedValue result = Array::ToString(ecmaRuntimeCallInfo1);
1502 TestHelper::TearDownFrame(thread, prev);
1503 JSHandle<EcmaString> resultHandle(thread, reinterpret_cast<EcmaString *>(result.GetRawData()));
1504
1505 ASSERT_EQ(EcmaStringAccessor::Compare(instance, resultHandle, str), 0);
1506 }
1507
HWTEST_F_L0(BuiltinsArrayTest,Includes)1508 HWTEST_F_L0(BuiltinsArrayTest, Includes)
1509 {
1510 JSHandle<JSTaggedValue> lengthKeyHandle = thread->GlobalConstants()->GetHandledLengthString();
1511 JSArray *arr = JSArray::Cast(JSArray::ArrayCreate(thread, JSTaggedNumber(0)).GetTaggedValue().GetTaggedObject());
1512 EXPECT_TRUE(arr != nullptr);
1513 JSHandle<JSTaggedValue> obj(thread, arr);
1514 EXPECT_EQ(JSArray::GetProperty(thread, obj, lengthKeyHandle).GetValue()->GetInt(), 0);
1515
1516 JSHandle<JSTaggedValue> key0(thread, JSTaggedValue(0));
1517 PropertyDescriptor desc0(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(2)));
1518 JSArray::DefineOwnProperty(thread, JSHandle<JSObject>(obj), key0, desc0);
1519 JSHandle<JSTaggedValue> key1(thread, JSTaggedValue(1));
1520 PropertyDescriptor desc1(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(3)));
1521 JSArray::DefineOwnProperty(thread, JSHandle<JSObject>(obj), key1, desc1);
1522 JSHandle<JSTaggedValue> key2(thread, JSTaggedValue(2));
1523 PropertyDescriptor desc2(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(4)));
1524 JSArray::DefineOwnProperty(thread, JSHandle<JSObject>(obj), key2, desc2);
1525
1526 auto ecmaRuntimeCallInfo1 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 6);
1527 ecmaRuntimeCallInfo1->SetFunction(JSTaggedValue::Undefined());
1528 ecmaRuntimeCallInfo1->SetThis(obj.GetTaggedValue());
1529 ecmaRuntimeCallInfo1->SetCallArg(0, JSTaggedValue(static_cast<int32_t>(2)));
1530
1531 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo1);
1532 [[maybe_unused]] JSTaggedValue result = Array::Includes(ecmaRuntimeCallInfo1);
1533 TestHelper::TearDownFrame(thread, prev);
1534
1535 ASSERT_TRUE(result.JSTaggedValue::ToBoolean()); // new Int8Array[2,3,4].includes(2)
1536
1537 auto ecmaRuntimeCallInfo2 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 6);
1538 ecmaRuntimeCallInfo2->SetFunction(JSTaggedValue::Undefined());
1539 ecmaRuntimeCallInfo2->SetThis(obj.GetTaggedValue());
1540 ecmaRuntimeCallInfo2->SetCallArg(0, JSTaggedValue(static_cast<int32_t>(1)));
1541
1542 prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo2);
1543 result = Array::Includes(ecmaRuntimeCallInfo2);
1544 TestHelper::TearDownFrame(thread, prev);
1545
1546 ASSERT_TRUE(!result.JSTaggedValue::ToBoolean()); // new Int8Array[2,3,4].includes(1)
1547
1548 auto ecmaRuntimeCallInfo3 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 8);
1549 ecmaRuntimeCallInfo3->SetFunction(JSTaggedValue::Undefined());
1550 ecmaRuntimeCallInfo3->SetThis(obj.GetTaggedValue());
1551 ecmaRuntimeCallInfo3->SetCallArg(0, JSTaggedValue(static_cast<int32_t>(3)));
1552 ecmaRuntimeCallInfo3->SetCallArg(1, JSTaggedValue(static_cast<int32_t>(1)));
1553
1554 prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo3);
1555 result = Array::Includes(ecmaRuntimeCallInfo3);
1556 TestHelper::TearDownFrame(thread, prev);
1557
1558 ASSERT_TRUE(result.JSTaggedValue::ToBoolean()); // new Int8Array[2,3,4].includes(3, 1)
1559
1560 auto ecmaRuntimeCallInfo4 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 8);
1561 ecmaRuntimeCallInfo4->SetFunction(JSTaggedValue::Undefined());
1562 ecmaRuntimeCallInfo4->SetThis(obj.GetTaggedValue());
1563 ecmaRuntimeCallInfo4->SetCallArg(0, JSTaggedValue(static_cast<int32_t>(2)));
1564 ecmaRuntimeCallInfo4->SetCallArg(1, JSTaggedValue(static_cast<int32_t>(5)));
1565
1566 prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo4);
1567 result = Array::Includes(ecmaRuntimeCallInfo4);
1568 TestHelper::TearDownFrame(thread, prev);
1569
1570 ASSERT_TRUE(!result.JSTaggedValue::ToBoolean()); // new Int8Array[2,3,4].includes(2, 5)
1571
1572 auto ecmaRuntimeCallInfo5 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 8);
1573 ecmaRuntimeCallInfo5->SetFunction(JSTaggedValue::Undefined());
1574 ecmaRuntimeCallInfo5->SetThis(obj.GetTaggedValue());
1575 ecmaRuntimeCallInfo5->SetCallArg(0, JSTaggedValue(static_cast<int32_t>(2)));
1576 ecmaRuntimeCallInfo5->SetCallArg(1, JSTaggedValue(static_cast<int32_t>(-2)));
1577
1578 prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo5);
1579 result = Array::Includes(ecmaRuntimeCallInfo5);
1580 TestHelper::TearDownFrame(thread, prev);
1581
1582 ASSERT_TRUE(!result.JSTaggedValue::ToBoolean()); // new Int8Array[2,3,4].includes(2, -2)
1583 }
1584
1585 // es12 23.1.3.10 new Array(1,[2,3]).flat()
HWTEST_F_L0(BuiltinsArrayTest,Flat)1586 HWTEST_F_L0(BuiltinsArrayTest, Flat)
1587 {
1588 JSHandle<JSTaggedValue> lengthKeyHandle = thread->GlobalConstants()->GetHandledLengthString();
1589 JSArray *arr1 = JSArray::Cast(JSArray::ArrayCreate(thread, JSTaggedNumber(0)).GetTaggedValue().GetTaggedObject());
1590 EXPECT_TRUE(arr1 != nullptr);
1591 JSHandle<JSObject> obj1(thread, arr1);
1592 EXPECT_EQ(JSArray::GetProperty(thread, JSHandle<JSTaggedValue>(obj1), lengthKeyHandle).GetValue()->GetInt(), 0);
1593
1594 JSHandle<JSTaggedValue> key0(thread, JSTaggedValue(0));
1595 PropertyDescriptor desc0(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(1)), true, true, true);
1596 JSArray::DefineOwnProperty(thread, obj1, key0, desc0);
1597
1598 JSArray *arr2 = JSArray::Cast(JSArray::ArrayCreate(thread, JSTaggedNumber(0)).GetTaggedValue().GetTaggedObject());
1599 EXPECT_TRUE(arr2 != nullptr);
1600 JSHandle<JSObject> obj2(thread, arr2);
1601 EXPECT_EQ(JSArray::GetProperty(thread, JSHandle<JSTaggedValue>(obj2), lengthKeyHandle).GetValue()->GetInt(), 0);
1602
1603 PropertyDescriptor desc1(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(2)), true, true, true);
1604 JSArray::DefineOwnProperty(thread, obj2, key0, desc1);
1605
1606 JSHandle<JSTaggedValue> key1(thread, JSTaggedValue(1));
1607 PropertyDescriptor desc2(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(3)), true, true, true);
1608 JSArray::DefineOwnProperty(thread, obj2, key1, desc2);
1609
1610 PropertyDescriptor desc3(thread, JSHandle<JSTaggedValue>(thread, obj2.GetTaggedValue()), true, true, true);
1611 JSArray::DefineOwnProperty(thread, obj1, key1, desc3);
1612
1613 auto ecmaRuntimeCallInfo1 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 4);
1614 ecmaRuntimeCallInfo1->SetFunction(JSTaggedValue::Undefined());
1615 ecmaRuntimeCallInfo1->SetThis(obj1.GetTaggedValue());
1616 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo1);
1617 JSTaggedValue result = Array::Flat(ecmaRuntimeCallInfo1);
1618 TestHelper::TearDownFrame(thread, prev);
1619 JSTaggedValue value(static_cast<JSTaggedType>(result.GetRawData()));
1620 ASSERT_TRUE(value.IsECMAObject());
1621 PropertyDescriptor descRes(thread);
1622 JSHandle<JSObject> valueHandle(thread, value);
1623 JSObject::GetOwnProperty(thread, valueHandle, key0, descRes);
1624 ASSERT_EQ(descRes.GetValue().GetTaggedValue(), JSTaggedValue(1));
1625 JSObject::GetOwnProperty(thread, valueHandle, key1, descRes);
1626 ASSERT_EQ(descRes.GetValue().GetTaggedValue(), JSTaggedValue(2));
1627 JSHandle<JSTaggedValue> key2(thread, JSTaggedValue(2));
1628 JSObject::GetOwnProperty(thread, valueHandle, key2, descRes);
1629 ASSERT_EQ(descRes.GetValue().GetTaggedValue(), JSTaggedValue(3));
1630 }
1631
1632 // es12 23.1.3.10 new Array(1,50,3]).flatMap(x => [x * 2])
HWTEST_F_L0(BuiltinsArrayTest,FlatMap)1633 HWTEST_F_L0(BuiltinsArrayTest, FlatMap)
1634 {
1635 auto ecmaVM = thread->GetEcmaVM();
1636 JSHandle<GlobalEnv> env = ecmaVM->GetGlobalEnv();
1637 ObjectFactory *factory = ecmaVM->GetFactory();
1638
1639 JSHandle<JSTaggedValue> lengthKeyHandle = thread->GlobalConstants()->GetHandledLengthString();
1640 JSArray *arr = JSArray::Cast(JSArray::ArrayCreate(thread, JSTaggedNumber(0)).GetTaggedValue().GetTaggedObject());
1641 EXPECT_TRUE(arr != nullptr);
1642 JSHandle<JSObject> obj(thread, arr);
1643 EXPECT_EQ(JSArray::GetProperty(thread, JSHandle<JSTaggedValue>(obj), lengthKeyHandle).GetValue()->GetInt(), 0);
1644 JSHandle<JSTaggedValue> key0(thread, JSTaggedValue(0));
1645 PropertyDescriptor desc0(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(1)), true, true, true);
1646 JSArray::DefineOwnProperty(thread, obj, key0, desc0);
1647 JSHandle<JSTaggedValue> key1(thread, JSTaggedValue(1));
1648 PropertyDescriptor desc1(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(50)), true, true, true);
1649 JSArray::DefineOwnProperty(thread, obj, key1, desc1);
1650 JSHandle<JSTaggedValue> key2(thread, JSTaggedValue(2));
1651 PropertyDescriptor desc2(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(3)), true, true, true);
1652 JSArray::DefineOwnProperty(thread, obj, key2, desc2);
1653 JSHandle<JSArray> jsArray(JSArray::ArrayCreate(thread, JSTaggedNumber(0)));
1654 JSHandle<JSFunction> func = factory->NewJSFunction(env, reinterpret_cast<void *>(TestClass::TestFlatMapFunc));
1655
1656 auto ecmaRuntimeCallInfo1 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 8);
1657 ecmaRuntimeCallInfo1->SetFunction(JSTaggedValue::Undefined());
1658 ecmaRuntimeCallInfo1->SetThis(obj.GetTaggedValue());
1659 ecmaRuntimeCallInfo1->SetCallArg(0, func.GetTaggedValue());
1660 ecmaRuntimeCallInfo1->SetCallArg(1, jsArray.GetTaggedValue());
1661
1662 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo1);
1663 JSTaggedValue result = Array::FlatMap(ecmaRuntimeCallInfo1);
1664 TestHelper::TearDownFrame(thread, prev);
1665 JSTaggedValue value(static_cast<JSTaggedType>(result.GetRawData()));
1666 ASSERT_TRUE(value.IsECMAObject());
1667
1668 PropertyDescriptor descRes(thread);
1669 JSHandle<JSObject> valueHandle(thread, value);
1670 EXPECT_EQ(
1671 JSArray::GetProperty(thread, JSHandle<JSTaggedValue>(valueHandle), lengthKeyHandle).GetValue()->GetInt(), 3);
1672 JSObject::GetOwnProperty(thread, valueHandle, key0, descRes);
1673
1674 ASSERT_EQ(descRes.GetValue()->GetInt(), 2);
1675 JSObject::GetOwnProperty(thread, valueHandle, key1, descRes);
1676 ASSERT_EQ(descRes.GetValue()->GetInt(), 100);
1677 JSObject::GetOwnProperty(thread, valueHandle, key2, descRes);
1678 ASSERT_EQ(descRes.GetValue()->GetInt(), 6);
1679 }
1680
HWTEST_F_L0(BuiltinsArrayTest,At)1681 HWTEST_F_L0(BuiltinsArrayTest, At)
1682 {
1683 JSHandle<JSTaggedValue> lengthKeyHandle = thread->GlobalConstants()->GetHandledLengthString();
1684 JSArray *arr = JSArray::Cast(JSArray::ArrayCreate(thread, JSTaggedNumber(0)).GetTaggedValue().GetTaggedObject());
1685 EXPECT_TRUE(arr != nullptr);
1686 JSHandle<JSTaggedValue> obj(thread, arr);
1687 EXPECT_EQ(JSArray::GetProperty(thread, obj, lengthKeyHandle).GetValue()->GetInt(), 0);
1688
1689 JSHandle<JSTaggedValue> key0(thread, JSTaggedValue(0));
1690 PropertyDescriptor desc0(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(2)));
1691 JSArray::DefineOwnProperty(thread, JSHandle<JSObject>(obj), key0, desc0);
1692 JSHandle<JSTaggedValue> key1(thread, JSTaggedValue(1));
1693 PropertyDescriptor desc1(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(3)));
1694 JSArray::DefineOwnProperty(thread, JSHandle<JSObject>(obj), key1, desc1);
1695 JSHandle<JSTaggedValue> key2(thread, JSTaggedValue(2));
1696 PropertyDescriptor desc2(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(4)));
1697 JSArray::DefineOwnProperty(thread, JSHandle<JSObject>(obj), key2, desc2);
1698
1699 auto ecmaRuntimeCallInfo1 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 6);
1700 ecmaRuntimeCallInfo1->SetFunction(JSTaggedValue::Undefined());
1701 ecmaRuntimeCallInfo1->SetThis(obj.GetTaggedValue());
1702 ecmaRuntimeCallInfo1->SetCallArg(0, JSTaggedValue(static_cast<int32_t>(0)));
1703 [[maybe_unused]] auto prev1 = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo1);
1704 JSTaggedValue result = Array::At(ecmaRuntimeCallInfo1);
1705 TestHelper::TearDownFrame(thread, prev1);
1706 ASSERT_EQ(result.GetRawData(), JSTaggedValue(2).GetRawData());
1707
1708 auto ecmaRuntimeCallInfo2 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 6);
1709 ecmaRuntimeCallInfo2->SetFunction(JSTaggedValue::Undefined());
1710 ecmaRuntimeCallInfo2->SetThis(obj.GetTaggedValue());
1711 ecmaRuntimeCallInfo2->SetCallArg(0, JSTaggedValue(static_cast<int32_t>(2)));
1712 [[maybe_unused]] auto prev2 = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo2);
1713 result = Array::At(ecmaRuntimeCallInfo2);
1714 TestHelper::TearDownFrame(thread, prev2);
1715 ASSERT_EQ(result.GetRawData(), JSTaggedValue(4).GetRawData());
1716
1717 auto ecmaRuntimeCallInfo3 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 6);
1718 ecmaRuntimeCallInfo3->SetFunction(JSTaggedValue::Undefined());
1719 ecmaRuntimeCallInfo3->SetThis(obj.GetTaggedValue());
1720 ecmaRuntimeCallInfo3->SetCallArg(0, JSTaggedValue(static_cast<int32_t>(3)));
1721 [[maybe_unused]] auto prev3 = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo3);
1722 result = Array::At(ecmaRuntimeCallInfo3);
1723 TestHelper::TearDownFrame(thread, prev3);
1724 ASSERT_EQ(result, JSTaggedValue::Undefined());
1725
1726 auto ecmaRuntimeCallInfo4 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 6);
1727 ecmaRuntimeCallInfo4->SetFunction(JSTaggedValue::Undefined());
1728 ecmaRuntimeCallInfo4->SetThis(obj.GetTaggedValue());
1729 ecmaRuntimeCallInfo4->SetCallArg(0, JSTaggedValue(static_cast<int32_t>(-1)));
1730 [[maybe_unused]] auto prev4 = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo4);
1731 result = Array::At(ecmaRuntimeCallInfo4);
1732 TestHelper::TearDownFrame(thread, prev4);
1733 ASSERT_EQ(result.GetRawData(), JSTaggedValue(4).GetRawData());
1734
1735 auto ecmaRuntimeCallInfo5 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 6);
1736 ecmaRuntimeCallInfo5->SetFunction(JSTaggedValue::Undefined());
1737 ecmaRuntimeCallInfo5->SetThis(obj.GetTaggedValue());
1738 ecmaRuntimeCallInfo5->SetCallArg(0, JSTaggedValue(static_cast<int32_t>(-3)));
1739 [[maybe_unused]] auto prev5 = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo5);
1740 result = Array::At(ecmaRuntimeCallInfo5);
1741 TestHelper::TearDownFrame(thread, prev5);
1742 ASSERT_EQ(result.GetRawData(), JSTaggedValue(2).GetRawData());
1743
1744 auto ecmaRuntimeCallInfo6 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 6);
1745 ecmaRuntimeCallInfo6->SetFunction(JSTaggedValue::Undefined());
1746 ecmaRuntimeCallInfo6->SetThis(obj.GetTaggedValue());
1747 ecmaRuntimeCallInfo6->SetCallArg(0, JSTaggedValue(static_cast<int32_t>(-4)));
1748 [[maybe_unused]] auto prev6 = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo6);
1749 result = Array::At(ecmaRuntimeCallInfo6);
1750 TestHelper::TearDownFrame(thread, prev6);
1751 ASSERT_EQ(result, JSTaggedValue::Undefined());
1752 }
1753
HWTEST_F_L0(BuiltinsArrayTest,With)1754 HWTEST_F_L0(BuiltinsArrayTest, With)
1755 {
1756 JSHandle<JSTaggedValue> lengthKeyHandle = thread->GlobalConstants()->GetHandledLengthString();
1757 JSArray *arr =
1758 JSArray::Cast(JSArray::ArrayCreate(thread, JSTaggedNumber(INT_VALUE_0)).GetTaggedValue().GetTaggedObject());
1759 EXPECT_TRUE(arr != nullptr);
1760 JSHandle<JSObject> obj(thread, arr);
1761 EXPECT_EQ(JSArray::GetProperty(thread, JSHandle<JSTaggedValue>(obj),
1762 lengthKeyHandle).GetValue()->GetInt(), INT_VALUE_0);
1763
1764 JSHandle<JSTaggedValue> key0(thread, JSTaggedValue(static_cast<uint32_t>(ArrayIndex::ARRAY_INDEX_0)));
1765 PropertyDescriptor desc0(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(INT_VALUE_0)), true, true, true);
1766 JSArray::DefineOwnProperty(thread, obj, key0, desc0);
1767 JSHandle<JSTaggedValue> key1(thread, JSTaggedValue(static_cast<uint32_t>(ArrayIndex::ARRAY_INDEX_1)));
1768 PropertyDescriptor desc1(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(INT_VALUE_1)), true, true, true);
1769 JSArray::DefineOwnProperty(thread, obj, key1, desc1);
1770 JSHandle<JSTaggedValue> key2(thread, JSTaggedValue(static_cast<uint32_t>(ArrayIndex::ARRAY_INDEX_2)));
1771 PropertyDescriptor desc2(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(INT_VALUE_2)), true, true, true);
1772 JSArray::DefineOwnProperty(thread, obj, key2, desc2);
1773
1774 auto ecmaRuntimeCallInfo1 =
1775 TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), RUNTIME_CALL_INFO_PARA_NUM_8);
1776 ecmaRuntimeCallInfo1->SetFunction(JSTaggedValue::Undefined());
1777 ecmaRuntimeCallInfo1->SetThis(obj.GetTaggedValue());
1778 ecmaRuntimeCallInfo1->SetCallArg(RUNTIME_CALL_INFO_PARA_0,
1779 JSTaggedValue(static_cast<uint32_t>((ArrayIndex::ARRAY_INDEX_1))));
1780 ecmaRuntimeCallInfo1->SetCallArg(RUNTIME_CALL_INFO_PARA_1, JSTaggedValue(INT_VALUE_3));
1781
1782 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo1);
1783 JSTaggedValue result = Array::With(ecmaRuntimeCallInfo1);
1784 TestHelper::TearDownFrame(thread, prev);
1785
1786 EXPECT_TRUE(result.IsECMAObject());
1787 JSHandle<JSTaggedValue> resultArr =
1788 JSHandle<JSTaggedValue>(thread, JSTaggedValue(static_cast<JSTaggedType>(result.GetRawData())));
1789 EXPECT_EQ(JSArray::GetProperty(thread, resultArr, key0).GetValue()->GetInt(), INT_VALUE_0);
1790 EXPECT_EQ(JSArray::GetProperty(thread, resultArr, key1).GetValue()->GetInt(), INT_VALUE_3);
1791 EXPECT_EQ(JSArray::GetProperty(thread, resultArr, key2).GetValue()->GetInt(), INT_VALUE_2);
1792 }
1793
HWTEST_F_L0(BuiltinsArrayTest,ToSorted)1794 HWTEST_F_L0(BuiltinsArrayTest, ToSorted)
1795 {
1796 JSHandle<JSTaggedValue> lengthKeyHandle = thread->GlobalConstants()->GetHandledLengthString();
1797 JSArray *arr =
1798 JSArray::Cast(JSArray::ArrayCreate(thread, JSTaggedNumber(INT_VALUE_0)).GetTaggedValue().GetTaggedObject());
1799 EXPECT_TRUE(arr != nullptr);
1800 JSHandle<JSObject> obj(thread, arr);
1801 EXPECT_EQ(JSArray::GetProperty(thread, JSHandle<JSTaggedValue>(obj),
1802 lengthKeyHandle).GetValue()->GetInt(), INT_VALUE_0);
1803 JSHandle<JSTaggedValue> key0(thread, JSTaggedValue(INT_VALUE_0));
1804 PropertyDescriptor desc0(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(INT_VALUE_3)), true, true, true);
1805 JSArray::DefineOwnProperty(thread, obj, key0, desc0);
1806 JSHandle<JSTaggedValue> key1(thread, JSTaggedValue(INT_VALUE_1));
1807 PropertyDescriptor desc1(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(INT_VALUE_2)), true, true, true);
1808 JSArray::DefineOwnProperty(thread, obj, key1, desc1);
1809 JSHandle<JSTaggedValue> key2(thread, JSTaggedValue(INT_VALUE_2));
1810 PropertyDescriptor desc2(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(INT_VALUE_1)), true, true, true);
1811 JSArray::DefineOwnProperty(thread, obj, key2, desc2);
1812
1813 auto ecmaRuntimeCallInfo1 =
1814 TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), RUNTIME_CALL_INFO_PARA_NUM_4);
1815 ecmaRuntimeCallInfo1->SetFunction(JSTaggedValue::Undefined());
1816 ecmaRuntimeCallInfo1->SetThis(obj.GetTaggedValue());
1817
1818 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo1);
1819 JSTaggedValue result2 = Array::ToSorted(ecmaRuntimeCallInfo1);
1820 TestHelper::TearDownFrame(thread, prev);
1821
1822 EXPECT_TRUE(result2.IsECMAObject());
1823 JSHandle<JSTaggedValue> resultArr =
1824 JSHandle<JSTaggedValue>(thread, JSTaggedValue(static_cast<JSTaggedType>(result2.GetRawData())));
1825 EXPECT_EQ(JSArray::GetProperty(thread, resultArr, key0).GetValue()->GetInt(), INT_VALUE_1);
1826 EXPECT_EQ(JSArray::GetProperty(thread, resultArr, key1).GetValue()->GetInt(), INT_VALUE_2);
1827 EXPECT_EQ(JSArray::GetProperty(thread, resultArr, key2).GetValue()->GetInt(), INT_VALUE_3);
1828 }
1829
HWTEST_F_L0(BuiltinsArrayTest,ToSpliced)1830 HWTEST_F_L0(BuiltinsArrayTest, ToSpliced)
1831 {
1832 JSHandle<JSTaggedValue> lengthKeyHandle = thread->GlobalConstants()->GetHandledLengthString();
1833 JSArray *arr =
1834 JSArray::Cast(JSArray::ArrayCreate(thread, JSTaggedNumber(INT_VALUE_0)).GetTaggedValue().GetTaggedObject());
1835 EXPECT_TRUE(arr != nullptr);
1836 JSHandle<JSObject> obj(thread, arr);
1837 EXPECT_EQ(JSArray::GetProperty(thread, JSHandle<JSTaggedValue>(obj),
1838 lengthKeyHandle).GetValue()->GetInt(), INT_VALUE_0);
1839 JSHandle<JSTaggedValue> key0(thread, JSTaggedValue(INT_VALUE_0));
1840 PropertyDescriptor desc0(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(INT_VALUE_0)), true, true, true);
1841 JSArray::DefineOwnProperty(thread, obj, key0, desc0);
1842 JSHandle<JSTaggedValue> key1(thread, JSTaggedValue(INT_VALUE_1));
1843 PropertyDescriptor desc1(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(INT_VALUE_1)), true, true, true);
1844 JSArray::DefineOwnProperty(thread, obj, key1, desc1);
1845 JSHandle<JSTaggedValue> key2(thread, JSTaggedValue(INT_VALUE_2));
1846 PropertyDescriptor desc2(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(INT_VALUE_2)), true, true, true);
1847 JSArray::DefineOwnProperty(thread, obj, key2, desc2);
1848
1849 auto ecmaRuntimeCallInfo1 =
1850 TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), RUNTIME_CALL_INFO_PARA_NUM_10);
1851 ecmaRuntimeCallInfo1->SetFunction(JSTaggedValue::Undefined());
1852 ecmaRuntimeCallInfo1->SetThis(obj.GetTaggedValue());
1853 ecmaRuntimeCallInfo1->SetCallArg(INT_VALUE_0, JSTaggedValue(INT_VALUE_1));
1854 ecmaRuntimeCallInfo1->SetCallArg(INT_VALUE_1, JSTaggedValue(INT_VALUE_1));
1855 ecmaRuntimeCallInfo1->SetCallArg(INT_VALUE_2, JSTaggedValue(INT_VALUE_666));
1856
1857 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo1);
1858 JSTaggedValue result2 = Array::ToSpliced(ecmaRuntimeCallInfo1);
1859 TestHelper::TearDownFrame(thread, prev);
1860
1861 EXPECT_TRUE(result2.IsECMAObject());
1862 JSHandle<JSTaggedValue> resultArr =
1863 JSHandle<JSTaggedValue>(thread, JSTaggedValue(static_cast<JSTaggedType>(result2.GetRawData())));
1864 EXPECT_EQ(JSArray::GetProperty(thread, resultArr, key0).GetValue()->GetInt(), INT_VALUE_0);
1865 EXPECT_EQ(JSArray::GetProperty(thread, resultArr, key1).GetValue()->GetInt(), INT_VALUE_666);
1866 EXPECT_EQ(JSArray::GetProperty(thread, resultArr, key2).GetValue()->GetInt(), INT_VALUE_2);
1867 }
1868
HWTEST_F_L0(BuiltinsArrayTest,FindLast)1869 HWTEST_F_L0(BuiltinsArrayTest, FindLast)
1870 {
1871 auto ecmaVM = thread->GetEcmaVM();
1872 JSHandle<GlobalEnv> env = ecmaVM->GetGlobalEnv();
1873 ObjectFactory *factory = ecmaVM->GetFactory();
1874
1875 JSHandle<JSTaggedValue> lengthKeyHandle = thread->GlobalConstants()->GetHandledLengthString();
1876 JSArray *arr = JSArray::Cast(JSArray::ArrayCreate(thread, JSTaggedNumber(0)).GetTaggedValue().GetTaggedObject());
1877 EXPECT_TRUE(arr != nullptr);
1878 JSHandle<JSObject> obj(thread, arr);
1879 EXPECT_EQ(JSArray::GetProperty(thread, JSHandle<JSTaggedValue>(obj), lengthKeyHandle).GetValue()->GetInt(), 0);
1880 // arr [50, 40, 2]
1881 JSHandle<JSTaggedValue> key0(thread, JSTaggedValue(0));
1882 PropertyDescriptor desc0(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(50)), true, true, true);
1883 JSArray::DefineOwnProperty(thread, obj, key0, desc0);
1884 JSHandle<JSTaggedValue> key1(thread, JSTaggedValue(1));
1885 PropertyDescriptor desc1(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(40)), true, true, true);
1886 JSArray::DefineOwnProperty(thread, obj, key1, desc1);
1887 JSHandle<JSTaggedValue> key2(thread, JSTaggedValue(2));
1888 PropertyDescriptor desc2(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(2)), true, true, true);
1889 JSArray::DefineOwnProperty(thread, obj, key2, desc2);
1890 JSHandle<JSArray> jsArray(JSArray::ArrayCreate(thread, JSTaggedNumber(0)));
1891 JSHandle<JSFunction> func = factory->NewJSFunction(env, reinterpret_cast<void *>(TestClass::TestFindLastFunc));
1892
1893 auto ecmaRuntimeCallInfo1 =
1894 TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 8); // 8 means 2 call args
1895 ecmaRuntimeCallInfo1->SetFunction(JSTaggedValue::Undefined());
1896 ecmaRuntimeCallInfo1->SetThis(obj.GetTaggedValue());
1897 ecmaRuntimeCallInfo1->SetCallArg(0, func.GetTaggedValue());
1898 ecmaRuntimeCallInfo1->SetCallArg(1, jsArray.GetTaggedValue());
1899
1900 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo1);
1901 JSTaggedValue result = Array::FindLast(ecmaRuntimeCallInfo1);
1902 TestHelper::TearDownFrame(thread, prev);
1903
1904 EXPECT_EQ(result.GetRawData(), JSTaggedValue(40).GetRawData());
1905 }
1906
HWTEST_F_L0(BuiltinsArrayTest,FindLastIndex)1907 HWTEST_F_L0(BuiltinsArrayTest, FindLastIndex)
1908 {
1909 auto ecmaVM = thread->GetEcmaVM();
1910 JSHandle<GlobalEnv> env = ecmaVM->GetGlobalEnv();
1911 ObjectFactory *factory = ecmaVM->GetFactory();
1912
1913 JSHandle<JSTaggedValue> lengthKeyHandle = thread->GlobalConstants()->GetHandledLengthString();
1914 JSArray *arr = JSArray::Cast(JSArray::ArrayCreate(thread, JSTaggedNumber(0)).GetTaggedValue().GetTaggedObject());
1915 EXPECT_TRUE(arr != nullptr);
1916 JSHandle<JSObject> obj(thread, arr);
1917 EXPECT_EQ(JSArray::GetProperty(thread, JSHandle<JSTaggedValue>(obj), lengthKeyHandle).GetValue()->GetInt(), 0);
1918
1919 // arr [50, 40, 30]
1920 JSHandle<JSTaggedValue> key0(thread, JSTaggedValue(0));
1921 PropertyDescriptor desc0(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(50)), true, true, true);
1922 JSArray::DefineOwnProperty(thread, obj, key0, desc0);
1923
1924 JSHandle<JSTaggedValue> key1(thread, JSTaggedValue(1));
1925 PropertyDescriptor desc1(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(40)), true, true, true);
1926 JSArray::DefineOwnProperty(thread, obj, key1, desc1);
1927
1928 JSHandle<JSTaggedValue> key2(thread, JSTaggedValue(2));
1929 PropertyDescriptor desc2(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(30)), true, true, true);
1930 JSArray::DefineOwnProperty(thread, obj, key2, desc2);
1931
1932 JSHandle<JSArray> jsArray(JSArray::ArrayCreate(thread, JSTaggedNumber(0)));
1933 JSHandle<JSFunction> func = factory->NewJSFunction(env, reinterpret_cast<void *>(TestClass::TestFindLastIndexFunc));
1934
1935 auto ecmaRuntimeCallInfo1 =
1936 TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 8); // 8 means 2 call args
1937 ecmaRuntimeCallInfo1->SetFunction(JSTaggedValue::Undefined());
1938 ecmaRuntimeCallInfo1->SetThis(obj.GetTaggedValue());
1939 ecmaRuntimeCallInfo1->SetCallArg(0, func.GetTaggedValue());
1940 ecmaRuntimeCallInfo1->SetCallArg(1, jsArray.GetTaggedValue());
1941
1942 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo1);
1943 JSTaggedValue result = Array::FindLastIndex(ecmaRuntimeCallInfo1);
1944 TestHelper::TearDownFrame(thread, prev);
1945
1946 EXPECT_EQ(result.GetRawData(), JSTaggedValue(static_cast<double>(2)).GetRawData());
1947 }
1948
HWTEST_F_L0(BuiltinsArrayTest,ToReversed)1949 HWTEST_F_L0(BuiltinsArrayTest, ToReversed)
1950 {
1951 JSHandle<JSTaggedValue> lengthKeyHandle = thread->GlobalConstants()->GetHandledLengthString();
1952 JSArray *arr = JSArray::Cast(JSArray::ArrayCreate(thread, JSTaggedNumber(0)).GetTaggedValue().GetTaggedObject());
1953 EXPECT_TRUE(arr != nullptr);
1954 JSHandle<JSObject> obj(thread, arr);
1955 EXPECT_EQ(JSArray::GetProperty(thread, JSHandle<JSTaggedValue>(obj),
1956 lengthKeyHandle).GetValue()->GetInt(), INT_VALUE_0);
1957 JSHandle<JSTaggedValue> key0(thread, JSTaggedValue(INT_VALUE_0));
1958 PropertyDescriptor desc0(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(INT_VALUE_50)), true, true, true);
1959 JSArray::DefineOwnProperty(thread, obj, key0, desc0);
1960 JSHandle<JSTaggedValue> key1(thread, JSTaggedValue(INT_VALUE_1));
1961 PropertyDescriptor desc1(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(INT_VALUE_200)), true, true, true);
1962 JSArray::DefineOwnProperty(thread, obj, key1, desc1);
1963 JSHandle<JSTaggedValue> key2(thread, JSTaggedValue(INT_VALUE_2));
1964 PropertyDescriptor desc2(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(INT_VALUE_3)), true, true, true);
1965 JSArray::DefineOwnProperty(thread, obj, key2, desc2);
1966
1967 auto ecmaRuntimeCallInfo1 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), INT_VALUE_4);
1968 ecmaRuntimeCallInfo1->SetFunction(JSTaggedValue::Undefined());
1969 ecmaRuntimeCallInfo1->SetThis(obj.GetTaggedValue());
1970
1971 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo1);
1972 JSTaggedValue result = Array::ToReversed(ecmaRuntimeCallInfo1);
1973 TestHelper::TearDownFrame(thread, prev);
1974 JSTaggedValue value(static_cast<JSTaggedType>(result.GetRawData()));
1975 ASSERT_TRUE(value.IsECMAObject());
1976
1977 PropertyDescriptor descRes(thread);
1978 JSHandle<JSObject> valueHandle(thread, value);
1979 EXPECT_EQ(JSArray::GetProperty(thread, JSHandle<JSTaggedValue>(valueHandle),
1980 lengthKeyHandle).GetValue()->GetInt(), INT_VALUE_3);
1981 JSObject::GetOwnProperty(thread, valueHandle, key0, descRes);
1982 ASSERT_EQ(descRes.GetValue().GetTaggedValue(), JSTaggedValue(INT_VALUE_3));
1983 JSObject::GetOwnProperty(thread, valueHandle, key1, descRes);
1984 ASSERT_EQ(descRes.GetValue().GetTaggedValue(), JSTaggedValue(INT_VALUE_200));
1985 JSObject::GetOwnProperty(thread, valueHandle, key2, descRes);
1986 ASSERT_EQ(descRes.GetValue().GetTaggedValue(), JSTaggedValue(INT_VALUE_50));
1987 EXPECT_EQ(JSArray::GetProperty(thread, JSHandle<JSTaggedValue>(obj),
1988 lengthKeyHandle).GetValue()->GetInt(), INT_VALUE_3);
1989 JSObject::GetOwnProperty(thread, obj, key0, descRes);
1990 ASSERT_EQ(descRes.GetValue().GetTaggedValue(), JSTaggedValue(INT_VALUE_50));
1991 JSObject::GetOwnProperty(thread, obj, key1, descRes);
1992 ASSERT_EQ(descRes.GetValue().GetTaggedValue(), JSTaggedValue(INT_VALUE_200));
1993 JSObject::GetOwnProperty(thread, obj, key2, descRes);
1994 ASSERT_EQ(descRes.GetValue().GetTaggedValue(), JSTaggedValue(INT_VALUE_3));
1995 }
1996 } // namespace panda::test
1997