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
39 namespace panda::test {
40 using Array = ecmascript::builtins::BuiltinsArray;
41 class BuiltinsArrayTest : public testing::Test {
42 public:
SetUpTestCase()43 static void SetUpTestCase()
44 {
45 GTEST_LOG_(INFO) << "SetUpTestCase";
46 }
47
TearDownTestCase()48 static void TearDownTestCase()
49 {
50 GTEST_LOG_(INFO) << "TearDownCase";
51 }
52
SetUp()53 void SetUp() override
54 {
55 TestHelper::CreateEcmaVMWithScope(instance, thread, scope);
56 }
57
TearDown()58 void TearDown() override
59 {
60 TestHelper::DestroyEcmaVMWithScope(instance, scope);
61 }
62
63 EcmaVM *instance {nullptr};
64 EcmaHandleScope *scope {nullptr};
65 JSThread *thread {nullptr};
66
67 class TestClass : public base::BuiltinsBase {
68 public:
TestForEachFunc(EcmaRuntimeCallInfo * argv)69 static JSTaggedValue TestForEachFunc(EcmaRuntimeCallInfo *argv)
70 {
71 JSHandle<JSTaggedValue> key = GetCallArg(argv, 0);
72 if (key->IsUndefined()) {
73 return JSTaggedValue::Undefined();
74 }
75 JSArray *jsArray = JSArray::Cast(GetThis(argv)->GetTaggedObject());
76 uint32_t length = jsArray->GetArrayLength() + 1U;
77 jsArray->SetArrayLength(argv->GetThread(), length);
78 return JSTaggedValue::Undefined();
79 }
80
TestEveryFunc(EcmaRuntimeCallInfo * argv)81 static JSTaggedValue TestEveryFunc(EcmaRuntimeCallInfo *argv)
82 {
83 uint32_t argc = argv->GetArgsNumber();
84 if (argc > 0) {
85 if (GetCallArg(argv, 0)->GetInt() > 10) { // 10 : test case
86 return GetTaggedBoolean(true);
87 }
88 }
89 return GetTaggedBoolean(false);
90 }
91
TestMapFunc(EcmaRuntimeCallInfo * argv)92 static JSTaggedValue TestMapFunc(EcmaRuntimeCallInfo *argv)
93 {
94 int accumulator = GetCallArg(argv, 0)->GetInt();
95 accumulator = accumulator * 2; // 2 : mapped to 2 times the original value
96 return BuiltinsBase::GetTaggedInt(accumulator);
97 }
98
TestFlatMapFunc(EcmaRuntimeCallInfo * argv)99 static JSTaggedValue TestFlatMapFunc(EcmaRuntimeCallInfo *argv)
100 {
101 int accumulator = GetCallArg(argv, 0)->GetInt();
102 accumulator = accumulator * 2; // 2 : mapped to 2 times the original value
103
104 JSThread *thread = argv->GetThread();
105 JSHandle<JSTaggedValue> lengthKeyHandle = thread->GlobalConstants()->GetHandledLengthString();
106 JSArray *arr =
107 JSArray::Cast(JSArray::ArrayCreate(thread, JSTaggedNumber(0)).GetTaggedValue().GetTaggedObject());
108 EXPECT_TRUE(arr != nullptr);
109 JSHandle<JSObject> obj(thread, arr);
110 auto property = JSArray::GetProperty(thread, JSHandle<JSTaggedValue>(obj), lengthKeyHandle);
111 EXPECT_EQ(property.GetValue()->GetInt(), 0);
112
113 JSHandle<JSTaggedValue> key(thread, JSTaggedValue(0));
114 PropertyDescriptor desc(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(accumulator)),
115 true, true, true);
116 JSArray::DefineOwnProperty(thread, obj, key, desc);
117 return obj.GetTaggedValue();
118 }
119
TestFindFunc(EcmaRuntimeCallInfo * argv)120 static JSTaggedValue TestFindFunc(EcmaRuntimeCallInfo *argv)
121 {
122 uint32_t argc = argv->GetArgsNumber();
123 if (argc > 0) {
124 // 10 : test case
125 if (GetCallArg(argv, 0)->GetInt() > 10) {
126 return GetTaggedBoolean(true);
127 }
128 }
129 return GetTaggedBoolean(false);
130 }
131
TestFindIndexFunc(EcmaRuntimeCallInfo * argv)132 static JSTaggedValue TestFindIndexFunc(EcmaRuntimeCallInfo *argv)
133 {
134 uint32_t argc = argv->GetArgsNumber();
135 if (argc > 0) {
136 // 10 : test case
137 if (GetCallArg(argv, 0)->GetInt() > 10) {
138 return GetTaggedBoolean(true);
139 }
140 }
141 return GetTaggedBoolean(false);
142 }
143
TestReduceFunc(EcmaRuntimeCallInfo * argv)144 static JSTaggedValue TestReduceFunc(EcmaRuntimeCallInfo *argv)
145 {
146 int accumulator = GetCallArg(argv, 0)->GetInt();
147 accumulator = accumulator + GetCallArg(argv, 1)->GetInt();
148 return BuiltinsBase::GetTaggedInt(accumulator);
149 }
150
TestReduceRightFunc(EcmaRuntimeCallInfo * argv)151 static JSTaggedValue TestReduceRightFunc(EcmaRuntimeCallInfo *argv)
152 {
153 int accumulator = GetCallArg(argv, 0)->GetInt();
154 accumulator = accumulator + GetCallArg(argv, 1)->GetInt();
155 return BuiltinsBase::GetTaggedInt(accumulator);
156 }
157
TestSomeFunc(EcmaRuntimeCallInfo * argv)158 static JSTaggedValue TestSomeFunc(EcmaRuntimeCallInfo *argv)
159 {
160 uint32_t argc = argv->GetArgsNumber();
161 if (argc > 0) {
162 if (GetCallArg(argv, 0)->GetInt() > 10) { // 10 : test case
163 return GetTaggedBoolean(true);
164 }
165 }
166 return GetTaggedBoolean(false);
167 }
168 };
169 };
170
CreateBuiltinsArrayJSObject(JSThread * thread,const CString keyCStr)171 JSTaggedValue CreateBuiltinsArrayJSObject(JSThread *thread, const CString keyCStr)
172 {
173 EcmaVM *ecmaVM = thread->GetEcmaVM();
174 JSHandle<GlobalEnv> globalEnv = ecmaVM->GetGlobalEnv();
175
176 JSHandle<JSTaggedValue> hclass = globalEnv->GetObjectFunction();
177 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
178
179 JSHandle<JSTaggedValue> obj(factory->NewJSObjectByConstructor(JSHandle<JSFunction>(hclass), hclass));
180 JSHandle<JSTaggedValue> key(factory->NewFromASCII(&keyCStr[0]));
181 JSHandle<JSTaggedValue> value(thread, JSTaggedValue(1));
182 JSObject::SetProperty(thread, obj, key, value);
183 return obj.GetTaggedValue();
184 }
185
HWTEST_F_L0(BuiltinsArrayTest,ArrayConstructor)186 HWTEST_F_L0(BuiltinsArrayTest, ArrayConstructor)
187 {
188 auto ecmaVM = thread->GetEcmaVM();
189 JSHandle<GlobalEnv> env = ecmaVM->GetGlobalEnv();
190 JSHandle<JSFunction> array(env->GetArrayFunction());
191 JSHandle<JSObject> globalObject(thread, env->GetGlobalObject());
192
193 auto ecmaRuntimeCallInfo1 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 10);
194 ecmaRuntimeCallInfo1->SetFunction(array.GetTaggedValue());
195 ecmaRuntimeCallInfo1->SetThis(globalObject.GetTaggedValue());
196 ecmaRuntimeCallInfo1->SetCallArg(0, JSTaggedValue(static_cast<int32_t>(1)));
197 ecmaRuntimeCallInfo1->SetCallArg(1, JSTaggedValue(static_cast<int32_t>(3)));
198 ecmaRuntimeCallInfo1->SetCallArg(2, JSTaggedValue(static_cast<int32_t>(5)));
199
200 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo1);
201 JSTaggedValue result = Array::ArrayConstructor(ecmaRuntimeCallInfo1);
202 TestHelper::TearDownFrame(thread, prev);
203 JSTaggedValue value(static_cast<JSTaggedType>(result.GetRawData()));
204 ASSERT_TRUE(value.IsECMAObject());
205 PropertyDescriptor descRes(thread);
206 JSHandle<JSObject> valueHandle(thread, value);
207 JSHandle<JSTaggedValue> key0(thread, JSTaggedValue(0));
208 JSHandle<JSTaggedValue> key1(thread, JSTaggedValue(1));
209 JSHandle<JSTaggedValue> key2(thread, JSTaggedValue(2));
210 JSObject::GetOwnProperty(thread, valueHandle, key0, descRes);
211 ASSERT_EQ(descRes.GetValue().GetTaggedValue(), JSTaggedValue(1));
212 JSObject::GetOwnProperty(thread, valueHandle, key1, descRes);
213 ASSERT_EQ(descRes.GetValue().GetTaggedValue(), JSTaggedValue(3));
214 JSObject::GetOwnProperty(thread, valueHandle, key2, descRes);
215 ASSERT_EQ(descRes.GetValue().GetTaggedValue(), JSTaggedValue(5));
216 }
217
218 // 22.1.2.1 Array.from ( items [ , mapfn [ , thisArg ] ] )
HWTEST_F_L0(BuiltinsArrayTest,From)219 HWTEST_F_L0(BuiltinsArrayTest, From)
220 {
221 JSHandle<JSTaggedValue> lengthKeyHandle = thread->GlobalConstants()->GetHandledLengthString();
222 JSArray *arr = JSArray::Cast(JSArray::ArrayCreate(thread, JSTaggedNumber(0))->GetTaggedObject());
223 EXPECT_TRUE(arr != nullptr);
224 JSHandle<JSObject> obj(thread, arr);
225 EXPECT_EQ(JSArray::GetProperty(thread, JSHandle<JSTaggedValue>(obj), lengthKeyHandle).GetValue()->GetInt(), 0);
226
227 JSHandle<JSTaggedValue> key0(thread, JSTaggedValue(0));
228 PropertyDescriptor desc0(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(1)), true, true, true);
229 JSArray::DefineOwnProperty(thread, obj, key0, desc0);
230 JSHandle<JSTaggedValue> key1(thread, JSTaggedValue(1));
231 PropertyDescriptor desc1(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(2)), true, true, true);
232 JSArray::DefineOwnProperty(thread, obj, key1, desc1);
233 JSHandle<JSTaggedValue> key2(thread, JSTaggedValue(2));
234 PropertyDescriptor desc2(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(3)), true, true, true);
235 JSArray::DefineOwnProperty(thread, obj, key2, desc2);
236 JSHandle<JSTaggedValue> key3(thread, JSTaggedValue(3));
237 PropertyDescriptor desc3(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(4)), true, true, true);
238 JSArray::DefineOwnProperty(thread, obj, key3, desc3);
239 JSHandle<JSTaggedValue> key4(thread, JSTaggedValue(4));
240 PropertyDescriptor desc4(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(5)), true, true, true);
241 JSArray::DefineOwnProperty(thread, obj, key4, desc4);
242
243 auto ecmaRuntimeCallInfo1 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 6);
244 ecmaRuntimeCallInfo1->SetFunction(JSTaggedValue::Undefined());
245 ecmaRuntimeCallInfo1->SetThis(obj.GetTaggedValue());
246 ecmaRuntimeCallInfo1->SetCallArg(0, obj.GetTaggedValue());
247
248 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo1);
249 JSTaggedValue result = Array::From(ecmaRuntimeCallInfo1);
250 TestHelper::TearDownFrame(thread, prev);
251 JSTaggedValue value(static_cast<JSTaggedType>(result.GetRawData()));
252 ASSERT_TRUE(value.IsECMAObject());
253 PropertyDescriptor descRes(thread);
254 JSHandle<JSObject> valueHandle(thread, value);
255 JSObject::GetOwnProperty(thread, valueHandle, key0, descRes);
256 ASSERT_EQ(descRes.GetValue().GetTaggedValue(), JSTaggedValue(1));
257 JSObject::GetOwnProperty(thread, valueHandle, key1, descRes);
258 ASSERT_EQ(descRes.GetValue().GetTaggedValue(), JSTaggedValue(2));
259 JSObject::GetOwnProperty(thread, valueHandle, key2, descRes);
260 ASSERT_EQ(descRes.GetValue().GetTaggedValue(), JSTaggedValue(3));
261 JSObject::GetOwnProperty(thread, valueHandle, key3, descRes);
262 ASSERT_EQ(descRes.GetValue().GetTaggedValue(), JSTaggedValue(4));
263 JSObject::GetOwnProperty(thread, valueHandle, key4, descRes);
264 ASSERT_EQ(descRes.GetValue().GetTaggedValue(), JSTaggedValue(5));
265 }
266
267 // 22.1.2.2 Array.isArray(arg)
HWTEST_F_L0(BuiltinsArrayTest,IsArray)268 HWTEST_F_L0(BuiltinsArrayTest, IsArray)
269 {
270 JSHandle<JSTaggedValue> lengthKeyHandle = thread->GlobalConstants()->GetHandledLengthString();
271 JSArray *arr = JSArray::Cast(JSArray::ArrayCreate(thread, JSTaggedNumber(0)).GetTaggedValue().GetTaggedObject());
272 EXPECT_TRUE(arr != nullptr);
273 JSHandle<JSObject> obj(thread, arr);
274 EXPECT_EQ(JSArray::GetProperty(thread, JSHandle<JSTaggedValue>(obj), lengthKeyHandle).GetValue()->GetInt(), 0);
275
276 auto ecmaRuntimeCallInfo1 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 6);
277 ecmaRuntimeCallInfo1->SetFunction(JSTaggedValue::Undefined());
278 ecmaRuntimeCallInfo1->SetThis(JSTaggedValue::Undefined());
279 ecmaRuntimeCallInfo1->SetCallArg(0, obj.GetTaggedValue());
280
281 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo1);
282 JSTaggedValue result = Array::IsArray(ecmaRuntimeCallInfo1);
283 TestHelper::TearDownFrame(thread, prev);
284 ASSERT_EQ(result.GetRawData(), JSTaggedValue::True().GetRawData());
285
286 auto ecmaRuntimeCallInfo2 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 6);
287 ecmaRuntimeCallInfo2->SetFunction(JSTaggedValue::Undefined());
288 ecmaRuntimeCallInfo2->SetThis(JSTaggedValue::Undefined());
289 ecmaRuntimeCallInfo2->SetCallArg(0, JSTaggedValue(static_cast<int32_t>(1)));
290
291 prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo2);
292 result = Array::IsArray(ecmaRuntimeCallInfo2);
293 TestHelper::TearDownFrame(thread, prev);
294 ASSERT_EQ(result.GetRawData(), JSTaggedValue::False().GetRawData());
295 }
296
HWTEST_F_L0(BuiltinsArrayTest,Of)297 HWTEST_F_L0(BuiltinsArrayTest, Of)
298 {
299 auto ecmaVM = thread->GetEcmaVM();
300 JSHandle<GlobalEnv> env = ecmaVM->GetGlobalEnv();
301 JSHandle<JSFunction> array(env->GetArrayFunction());
302 JSHandle<JSObject> globalObject(thread, env->GetGlobalObject());
303
304 auto ecmaRuntimeCallInfo1 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 10);
305 ecmaRuntimeCallInfo1->SetFunction(array.GetTaggedValue());
306 ecmaRuntimeCallInfo1->SetThis(globalObject.GetTaggedValue());
307 ecmaRuntimeCallInfo1->SetCallArg(0, JSTaggedValue(static_cast<int32_t>(1)));
308 ecmaRuntimeCallInfo1->SetCallArg(1, JSTaggedValue(static_cast<int32_t>(3)));
309 ecmaRuntimeCallInfo1->SetCallArg(2, JSTaggedValue(static_cast<int32_t>(5)));
310
311 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo1);
312 JSTaggedValue result = Array::Of(ecmaRuntimeCallInfo1);
313 TestHelper::TearDownFrame(thread, prev);
314 JSTaggedValue value(static_cast<JSTaggedType>(result.GetRawData()));
315 ASSERT_TRUE(value.IsECMAObject());
316 PropertyDescriptor descRes(thread);
317 JSHandle<JSObject> valueHandle(thread, value);
318 JSHandle<JSTaggedValue> key0(thread, JSTaggedValue(0));
319 JSHandle<JSTaggedValue> key1(thread, JSTaggedValue(1));
320 JSHandle<JSTaggedValue> key2(thread, JSTaggedValue(2));
321
322 JSObject::GetOwnProperty(thread, valueHandle, key0, descRes);
323 ASSERT_EQ(descRes.GetValue().GetTaggedValue(), JSTaggedValue(1));
324 JSObject::GetOwnProperty(thread, valueHandle, key1, descRes);
325 ASSERT_EQ(descRes.GetValue().GetTaggedValue(), JSTaggedValue(3));
326 JSObject::GetOwnProperty(thread, valueHandle, key2, descRes);
327 ASSERT_EQ(descRes.GetValue().GetTaggedValue(), JSTaggedValue(5));
328 }
329
HWTEST_F_L0(BuiltinsArrayTest,Species)330 HWTEST_F_L0(BuiltinsArrayTest, Species)
331 {
332 auto ecmaVM = thread->GetEcmaVM();
333 JSHandle<GlobalEnv> env = ecmaVM->GetGlobalEnv();
334 JSHandle<JSFunction> array(env->GetArrayFunction());
335 JSHandle<JSObject> globalObject(thread, env->GetGlobalObject());
336
337 auto ecmaRuntimeCallInfo1 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 4);
338 ecmaRuntimeCallInfo1->SetFunction(array.GetTaggedValue());
339 ecmaRuntimeCallInfo1->SetThis(globalObject.GetTaggedValue());
340
341 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo1);
342 JSTaggedValue result = Array::Species(ecmaRuntimeCallInfo1);
343 TestHelper::TearDownFrame(thread, prev);
344 ASSERT_TRUE(result.IsECMAObject());
345 }
346
HWTEST_F_L0(BuiltinsArrayTest,Concat)347 HWTEST_F_L0(BuiltinsArrayTest, Concat)
348 {
349 JSHandle<JSTaggedValue> lengthKeyHandle = thread->GlobalConstants()->GetHandledLengthString();
350 JSArray *arr = JSArray::Cast(JSArray::ArrayCreate(thread, JSTaggedNumber(0)).GetTaggedValue().GetTaggedObject());
351 EXPECT_TRUE(arr != nullptr);
352 JSHandle<JSObject> obj(thread, arr);
353 JSHandle<JSTaggedValue> key0(thread, JSTaggedValue(0));
354 PropertyDescriptor desc0(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(1)), true, true, true);
355 JSArray::DefineOwnProperty(thread, obj, key0, desc0);
356 JSHandle<JSTaggedValue> key1(thread, JSTaggedValue(1));
357 PropertyDescriptor desc1(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(2)), true, true, true);
358 JSArray::DefineOwnProperty(thread, obj, key1, desc1);
359 JSHandle<JSTaggedValue> key2(thread, JSTaggedValue(2));
360 PropertyDescriptor desc2(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(3)), true, true, true);
361 JSArray::DefineOwnProperty(thread, obj, key2, desc2);
362
363 JSArray *arr1 = JSArray::ArrayCreate(thread, JSTaggedNumber(0)).GetObject<JSArray>();
364 EXPECT_TRUE(arr1 != nullptr);
365 JSHandle<JSObject> obj1(thread, arr1);
366 JSHandle<JSTaggedValue> key4(thread, JSTaggedValue(0));
367 PropertyDescriptor desc4(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(4)), true, true, true);
368 JSArray::DefineOwnProperty(thread, obj1, key4, desc4);
369 JSHandle<JSTaggedValue> key5(thread, JSTaggedValue(1));
370 PropertyDescriptor desc5(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(5)), true, true, true);
371 JSArray::DefineOwnProperty(thread, obj1, key5, desc5);
372 JSHandle<JSTaggedValue> key6(thread, JSTaggedValue(2));
373 PropertyDescriptor desc6(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(6)), true, true, true);
374 JSArray::DefineOwnProperty(thread, obj1, key6, desc6);
375
376 auto ecmaRuntimeCallInfo1 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 6);
377 ecmaRuntimeCallInfo1->SetFunction(JSTaggedValue::Undefined());
378 ecmaRuntimeCallInfo1->SetThis(obj.GetTaggedValue());
379 ecmaRuntimeCallInfo1->SetCallArg(0, obj1.GetTaggedValue());
380
381 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo1);
382 JSTaggedValue result = Array::Concat(ecmaRuntimeCallInfo1);
383 TestHelper::TearDownFrame(thread, prev);
384 JSTaggedValue value(static_cast<JSTaggedType>(result.GetRawData()));
385 ASSERT_TRUE(value.IsECMAObject());
386
387 PropertyDescriptor descRes(thread);
388 JSHandle<JSObject> valueHandle(thread, value);
389 JSHandle<JSTaggedValue> key7(thread, JSTaggedValue(5));
390 EXPECT_EQ(
391 JSArray::GetProperty(thread, JSHandle<JSTaggedValue>(valueHandle), lengthKeyHandle).GetValue()->GetInt(), 6);
392 JSObject::GetOwnProperty(thread, valueHandle, key7, descRes);
393 ASSERT_EQ(descRes.GetValue().GetTaggedValue(), JSTaggedValue(6));
394 }
395
396 // 22.1.3.3 new Array(1,2,3,4,5).CopyWithin(0,3,5)
HWTEST_F_L0(BuiltinsArrayTest,CopyWithin)397 HWTEST_F_L0(BuiltinsArrayTest, CopyWithin)
398 {
399 JSHandle<JSTaggedValue> lengthKeyHandle = thread->GlobalConstants()->GetHandledLengthString();
400 JSArray *arr = JSArray::Cast(JSArray::ArrayCreate(thread, JSTaggedNumber(0)).GetTaggedValue().GetTaggedObject());
401 EXPECT_TRUE(arr != nullptr);
402 JSHandle<JSObject> obj(thread, arr);
403 EXPECT_EQ(JSArray::GetProperty(thread, JSHandle<JSTaggedValue>(obj), lengthKeyHandle).GetValue()->GetInt(), 0);
404
405 JSHandle<JSTaggedValue> key0(thread, JSTaggedValue(0));
406 PropertyDescriptor desc0(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(1)), true, true, true);
407 JSArray::DefineOwnProperty(thread, obj, key0, desc0);
408 JSHandle<JSTaggedValue> key1(thread, JSTaggedValue(1));
409 PropertyDescriptor desc1(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(2)), true, true, true);
410 JSArray::DefineOwnProperty(thread, obj, key1, desc1);
411 JSHandle<JSTaggedValue> key2(thread, JSTaggedValue(2));
412 PropertyDescriptor desc2(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(3)), true, true, true);
413 JSArray::DefineOwnProperty(thread, obj, key2, desc2);
414 JSHandle<JSTaggedValue> key3(thread, JSTaggedValue(3));
415 PropertyDescriptor desc3(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(4)), true, true, true);
416 JSArray::DefineOwnProperty(thread, obj, key3, desc3);
417 JSHandle<JSTaggedValue> key4(thread, JSTaggedValue(4));
418 PropertyDescriptor desc4(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(5)), true, true, true);
419 JSArray::DefineOwnProperty(thread, obj, key4, desc4);
420
421 auto ecmaRuntimeCallInfo1 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 10);
422 ecmaRuntimeCallInfo1->SetFunction(JSTaggedValue::Undefined());
423 ecmaRuntimeCallInfo1->SetThis(obj.GetTaggedValue());
424 ecmaRuntimeCallInfo1->SetCallArg(0, JSTaggedValue(static_cast<int32_t>(0)));
425 ecmaRuntimeCallInfo1->SetCallArg(1, JSTaggedValue(static_cast<int32_t>(3)));
426 ecmaRuntimeCallInfo1->SetCallArg(2, JSTaggedValue(static_cast<int32_t>(5)));
427
428 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo1);
429 JSTaggedValue result = Array::CopyWithin(ecmaRuntimeCallInfo1);
430 TestHelper::TearDownFrame(thread, prev);
431 JSTaggedValue value(static_cast<JSTaggedType>(result.GetRawData()));
432 ASSERT_TRUE(value.IsECMAObject());
433 PropertyDescriptor descRes(thread);
434 JSHandle<JSObject> valueHandle(thread, value);
435 JSObject::GetOwnProperty(thread, valueHandle, key0, descRes);
436 ASSERT_EQ(descRes.GetValue().GetTaggedValue(), JSTaggedValue(4));
437 JSObject::GetOwnProperty(thread, valueHandle, key1, descRes);
438 ASSERT_EQ(descRes.GetValue().GetTaggedValue(), JSTaggedValue(5));
439 JSObject::GetOwnProperty(thread, valueHandle, key2, descRes);
440 ASSERT_EQ(descRes.GetValue().GetTaggedValue(), JSTaggedValue(3));
441 JSObject::GetOwnProperty(thread, valueHandle, key3, descRes);
442 ASSERT_EQ(descRes.GetValue().GetTaggedValue(), JSTaggedValue(4));
443 JSObject::GetOwnProperty(thread, valueHandle, key4, descRes);
444 ASSERT_EQ(descRes.GetValue().GetTaggedValue(), JSTaggedValue(5));
445 }
446
HWTEST_F_L0(BuiltinsArrayTest,Every)447 HWTEST_F_L0(BuiltinsArrayTest, Every)
448 {
449 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
450 auto ecmaVM = thread->GetEcmaVM();
451 JSHandle<GlobalEnv> env = ecmaVM->GetGlobalEnv();
452
453 JSHandle<JSTaggedValue> lengthKeyHandle = thread->GlobalConstants()->GetHandledLengthString();
454 JSArray *arr = JSArray::Cast(JSArray::ArrayCreate(thread, JSTaggedNumber(0)).GetTaggedValue().GetTaggedObject());
455 EXPECT_TRUE(arr != nullptr);
456 JSHandle<JSObject> obj(thread, arr);
457 EXPECT_EQ(JSArray::GetProperty(thread, JSHandle<JSTaggedValue>(obj), lengthKeyHandle).GetValue()->GetInt(), 0);
458
459 JSHandle<JSTaggedValue> key0(thread, JSTaggedValue(0));
460 PropertyDescriptor desc0(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(100)), true, true, true);
461 JSArray::DefineOwnProperty(thread, obj, key0, desc0);
462
463 JSHandle<JSTaggedValue> key1(thread, JSTaggedValue(1));
464 PropertyDescriptor desc1(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(200)), true, true, true);
465 JSArray::DefineOwnProperty(thread, obj, key1, desc1);
466 JSHandle<JSTaggedValue> key2(thread, JSTaggedValue(2));
467 PropertyDescriptor desc2(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(300)), true, true, true);
468 JSArray::DefineOwnProperty(thread, obj, key2, desc2);
469
470 JSHandle<JSArray> jsArray = factory->NewJSArray();
471 JSHandle<JSFunction> func = factory->NewJSFunction(env, reinterpret_cast<void *>(TestClass::TestEveryFunc));
472
473 auto ecmaRuntimeCallInfo1 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 8);
474 ecmaRuntimeCallInfo1->SetFunction(JSTaggedValue::Undefined());
475 ecmaRuntimeCallInfo1->SetThis(obj.GetTaggedValue());
476 ecmaRuntimeCallInfo1->SetCallArg(0, func.GetTaggedValue());
477 ecmaRuntimeCallInfo1->SetCallArg(1, jsArray.GetTaggedValue());
478
479 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo1);
480 JSTaggedValue result2 = Array::Every(ecmaRuntimeCallInfo1);
481 TestHelper::TearDownFrame(thread, prev);
482
483 ASSERT_EQ(result2.GetRawData(), JSTaggedValue::True().GetRawData());
484 }
485
HWTEST_F_L0(BuiltinsArrayTest,Map)486 HWTEST_F_L0(BuiltinsArrayTest, Map)
487 {
488 auto ecmaVM = thread->GetEcmaVM();
489 JSHandle<GlobalEnv> env = ecmaVM->GetGlobalEnv();
490 ObjectFactory *factory = ecmaVM->GetFactory();
491
492 JSHandle<JSTaggedValue> lengthKeyHandle = thread->GlobalConstants()->GetHandledLengthString();
493 JSArray *arr = JSArray::Cast(JSArray::ArrayCreate(thread, JSTaggedNumber(0)).GetTaggedValue().GetTaggedObject());
494 EXPECT_TRUE(arr != nullptr);
495 JSHandle<JSObject> obj(thread, arr);
496 EXPECT_EQ(JSArray::GetProperty(thread, JSHandle<JSTaggedValue>(obj), lengthKeyHandle).GetValue()->GetInt(), 0);
497 JSHandle<JSTaggedValue> key0(thread, JSTaggedValue(0));
498 PropertyDescriptor desc0(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(50)), true, true, true);
499 JSArray::DefineOwnProperty(thread, obj, key0, desc0);
500 JSHandle<JSTaggedValue> key1(thread, JSTaggedValue(1));
501 PropertyDescriptor desc1(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(200)), true, true, true);
502 JSArray::DefineOwnProperty(thread, obj, key1, desc1);
503 JSHandle<JSTaggedValue> key2(thread, JSTaggedValue(2));
504 PropertyDescriptor desc2(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(3)), true, true, true);
505 JSArray::DefineOwnProperty(thread, obj, key2, desc2);
506 JSHandle<JSArray> jsArray(JSArray::ArrayCreate(thread, JSTaggedNumber(0)));
507 JSHandle<JSFunction> func = factory->NewJSFunction(env, reinterpret_cast<void *>(TestClass::TestMapFunc));
508
509 auto ecmaRuntimeCallInfo1 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 8);
510 ecmaRuntimeCallInfo1->SetFunction(JSTaggedValue::Undefined());
511 ecmaRuntimeCallInfo1->SetThis(obj.GetTaggedValue());
512 ecmaRuntimeCallInfo1->SetCallArg(0, func.GetTaggedValue());
513 ecmaRuntimeCallInfo1->SetCallArg(1, jsArray.GetTaggedValue());
514
515 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo1);
516 JSTaggedValue result = Array::Map(ecmaRuntimeCallInfo1);
517 TestHelper::TearDownFrame(thread, prev);
518 JSTaggedValue value(static_cast<JSTaggedType>(result.GetRawData()));
519 ASSERT_TRUE(value.IsECMAObject());
520
521 PropertyDescriptor descRes(thread);
522 JSHandle<JSObject> valueHandle(thread, value);
523 EXPECT_EQ(
524 JSArray::GetProperty(thread, JSHandle<JSTaggedValue>(valueHandle), lengthKeyHandle).GetValue()->GetInt(), 3);
525 JSObject::GetOwnProperty(thread, valueHandle, key0, descRes);
526
527 ASSERT_EQ(descRes.GetValue()->GetInt(), 100);
528 JSObject::GetOwnProperty(thread, valueHandle, key1, descRes);
529 ASSERT_EQ(descRes.GetValue()->GetInt(), 400);
530 JSObject::GetOwnProperty(thread, valueHandle, key2, descRes);
531 ASSERT_EQ(descRes.GetValue()->GetInt(), 6);
532 }
533
HWTEST_F_L0(BuiltinsArrayTest,Reverse)534 HWTEST_F_L0(BuiltinsArrayTest, Reverse)
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
551 auto ecmaRuntimeCallInfo1 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 4);
552 ecmaRuntimeCallInfo1->SetFunction(JSTaggedValue::Undefined());
553 ecmaRuntimeCallInfo1->SetThis(obj.GetTaggedValue());
554
555 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo1);
556 JSTaggedValue result = Array::Reverse(ecmaRuntimeCallInfo1);
557 TestHelper::TearDownFrame(thread, prev);
558 JSTaggedValue value(static_cast<JSTaggedType>(result.GetRawData()));
559 ASSERT_TRUE(value.IsECMAObject());
560
561 PropertyDescriptor descRes(thread);
562 JSHandle<JSObject> valueHandle(thread, value);
563 EXPECT_EQ(
564 JSArray::GetProperty(thread, JSHandle<JSTaggedValue>(valueHandle), lengthKeyHandle).GetValue()->GetInt(), 3);
565 JSObject::GetOwnProperty(thread, valueHandle, key0, descRes);
566 ASSERT_EQ(descRes.GetValue().GetTaggedValue(), JSTaggedValue(3));
567 JSObject::GetOwnProperty(thread, valueHandle, key1, descRes);
568 ASSERT_EQ(descRes.GetValue().GetTaggedValue(), JSTaggedValue(200));
569 JSObject::GetOwnProperty(thread, valueHandle, key2, descRes);
570 ASSERT_EQ(descRes.GetValue().GetTaggedValue(), JSTaggedValue(50));
571 EXPECT_EQ(JSArray::GetProperty(thread, JSHandle<JSTaggedValue>(obj), lengthKeyHandle).GetValue()->GetInt(), 3);
572 JSObject::GetOwnProperty(thread, obj, key0, descRes);
573 ASSERT_EQ(descRes.GetValue().GetTaggedValue(), JSTaggedValue(3));
574 JSObject::GetOwnProperty(thread, obj, key1, descRes);
575 ASSERT_EQ(descRes.GetValue().GetTaggedValue(), JSTaggedValue(200));
576 JSObject::GetOwnProperty(thread, obj, key2, descRes);
577 ASSERT_EQ(descRes.GetValue().GetTaggedValue(), JSTaggedValue(50));
578 }
579
HWTEST_F_L0(BuiltinsArrayTest,COWArrayReverse)580 HWTEST_F_L0(BuiltinsArrayTest, COWArrayReverse)
581 {
582 JSHandle<JSTaggedValue> lengthKeyHandle = thread->GlobalConstants()->GetHandledLengthString();
583 JSArray *arr = JSArray::Cast(JSArray::ArrayCreate(thread, JSTaggedNumber(0)).GetTaggedValue().GetTaggedObject());
584 EXPECT_TRUE(arr != nullptr);
585 JSHandle<JSObject> obj(thread, arr);
586 EXPECT_EQ(JSArray::GetProperty(thread, JSHandle<JSTaggedValue>(obj), lengthKeyHandle).GetValue()->GetInt(), 0);
587 JSHandle<JSTaggedValue> key0(thread, JSTaggedValue(0));
588 PropertyDescriptor desc0(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(50)), true, true, true);
589 JSArray::DefineOwnProperty(thread, obj, key0, desc0);
590 JSHandle<JSTaggedValue> key1(thread, JSTaggedValue(1));
591 PropertyDescriptor desc1(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(200)), true, true, true);
592 JSArray::DefineOwnProperty(thread, obj, key1, desc1);
593 JSHandle<JSTaggedValue> key2(thread, JSTaggedValue(2));
594 PropertyDescriptor desc2(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(3)), true, true, true);
595 JSArray::DefineOwnProperty(thread, obj, key2, desc2);
596
597 JSHandle<JSArray> cloneArray = thread->GetEcmaVM()->GetFactory()->CloneArrayLiteral(JSHandle<JSArray>(obj));
598
599 auto ecmaRuntimeCallInfo1 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 4);
600 ecmaRuntimeCallInfo1->SetFunction(JSTaggedValue::Undefined());
601 ecmaRuntimeCallInfo1->SetThis(cloneArray.GetTaggedValue());
602
603 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo1);
604 JSTaggedValue result = Array::Reverse(ecmaRuntimeCallInfo1);
605 TestHelper::TearDownFrame(thread, prev);
606 JSTaggedValue value(static_cast<JSTaggedType>(result.GetRawData()));
607 ASSERT_TRUE(value.IsECMAObject());
608
609 PropertyDescriptor descRes(thread);
610 JSHandle<JSObject> valueHandle(thread, value);
611 EXPECT_EQ(
612 JSArray::GetProperty(thread, JSHandle<JSTaggedValue>(valueHandle), lengthKeyHandle).GetValue()->GetInt(), 3);
613 JSObject::GetOwnProperty(thread, valueHandle, key0, descRes);
614 ASSERT_EQ(descRes.GetValue().GetTaggedValue(), JSTaggedValue(3));
615 JSObject::GetOwnProperty(thread, valueHandle, key1, descRes);
616 ASSERT_EQ(descRes.GetValue().GetTaggedValue(), JSTaggedValue(200));
617 JSObject::GetOwnProperty(thread, valueHandle, key2, descRes);
618 ASSERT_EQ(descRes.GetValue().GetTaggedValue(), JSTaggedValue(50));
619 EXPECT_EQ(JSArray::GetProperty(thread, JSHandle<JSTaggedValue>(cloneArray),
620 lengthKeyHandle).GetValue()->GetInt(), 3);
621 JSObject::GetOwnProperty(thread, JSHandle<JSObject>(cloneArray), key0, descRes);
622 ASSERT_EQ(descRes.GetValue().GetTaggedValue(), JSTaggedValue(3));
623 JSObject::GetOwnProperty(thread, JSHandle<JSObject>(cloneArray), key1, descRes);
624 ASSERT_EQ(descRes.GetValue().GetTaggedValue(), JSTaggedValue(200));
625 JSObject::GetOwnProperty(thread, JSHandle<JSObject>(cloneArray), key2, descRes);
626 ASSERT_EQ(descRes.GetValue().GetTaggedValue(), JSTaggedValue(50));
627 }
628
HWTEST_F_L0(BuiltinsArrayTest,Slice)629 HWTEST_F_L0(BuiltinsArrayTest, Slice)
630 {
631 JSHandle<JSTaggedValue> lengthKeyHandle = thread->GlobalConstants()->GetHandledLengthString();
632 JSArray *arr = JSArray::Cast(JSArray::ArrayCreate(thread, JSTaggedNumber(0)).GetTaggedValue().GetTaggedObject());
633 EXPECT_TRUE(arr != nullptr);
634 JSHandle<JSObject> obj(thread, arr);
635 EXPECT_EQ(JSArray::GetProperty(thread, JSHandle<JSTaggedValue>(obj), lengthKeyHandle).GetValue()->GetInt(), 0);
636 JSHandle<JSTaggedValue> key0(thread, JSTaggedValue(0));
637 PropertyDescriptor desc0(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(1)), true, true, true);
638 JSArray::DefineOwnProperty(thread, obj, key0, desc0);
639 JSHandle<JSTaggedValue> key1(thread, JSTaggedValue(1));
640 PropertyDescriptor desc1(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(2)), true, true, true);
641 JSArray::DefineOwnProperty(thread, obj, key1, desc1);
642 JSHandle<JSTaggedValue> key2(thread, JSTaggedValue(2));
643 PropertyDescriptor desc2(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(3)), true, true, true);
644 JSArray::DefineOwnProperty(thread, obj, key2, desc2);
645 JSHandle<JSTaggedValue> key3(thread, JSTaggedValue(3));
646 PropertyDescriptor desc3(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(4)), true, true, true);
647 JSArray::DefineOwnProperty(thread, obj, key3, desc3);
648 JSHandle<JSTaggedValue> key4(thread, JSTaggedValue(4));
649 PropertyDescriptor desc4(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(3)), true, true, true);
650 JSArray::DefineOwnProperty(thread, obj, key4, desc4);
651
652 auto ecmaRuntimeCallInfo1 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 8);
653 ecmaRuntimeCallInfo1->SetFunction(JSTaggedValue::Undefined());
654 ecmaRuntimeCallInfo1->SetThis(obj.GetTaggedValue());
655 ecmaRuntimeCallInfo1->SetCallArg(0, JSTaggedValue(static_cast<int32_t>(1)));
656 ecmaRuntimeCallInfo1->SetCallArg(1, JSTaggedValue(static_cast<int32_t>(4)));
657
658 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo1);
659 JSTaggedValue result = Array::Slice(ecmaRuntimeCallInfo1);
660 TestHelper::TearDownFrame(thread, prev);
661 JSTaggedValue value(static_cast<JSTaggedType>(result.GetRawData()));
662 ASSERT_TRUE(value.IsECMAObject());
663
664 PropertyDescriptor descRes(thread);
665 JSHandle<JSObject> valueHandle(thread, value);
666 EXPECT_EQ(
667 JSArray::GetProperty(thread, JSHandle<JSTaggedValue>(valueHandle), lengthKeyHandle).GetValue()->GetInt(), 3);
668 JSObject::GetOwnProperty(thread, valueHandle, key0, descRes);
669 ASSERT_EQ(descRes.GetValue().GetTaggedValue(), JSTaggedValue(2));
670 JSObject::GetOwnProperty(thread, valueHandle, key1, descRes);
671 ASSERT_EQ(descRes.GetValue().GetTaggedValue(), JSTaggedValue(3));
672 JSObject::GetOwnProperty(thread, valueHandle, key2, descRes);
673 ASSERT_EQ(descRes.GetValue().GetTaggedValue(), JSTaggedValue(4));
674 }
675
HWTEST_F_L0(BuiltinsArrayTest,Splice)676 HWTEST_F_L0(BuiltinsArrayTest, Splice)
677 {
678 JSHandle<JSTaggedValue> lengthKeyHandle = thread->GlobalConstants()->GetHandledLengthString();
679 JSArray *arr = JSArray::Cast(JSArray::ArrayCreate(thread, JSTaggedNumber(0)).GetTaggedValue().GetTaggedObject());
680 EXPECT_TRUE(arr != nullptr);
681 JSHandle<JSObject> obj(thread, arr);
682 EXPECT_EQ(JSArray::GetProperty(thread, JSHandle<JSTaggedValue>(obj), lengthKeyHandle).GetValue()->GetInt(), 0);
683 JSHandle<JSTaggedValue> key0(thread, JSTaggedValue(0));
684 PropertyDescriptor desc0(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(1)), true, true, true);
685 JSArray::DefineOwnProperty(thread, obj, key0, desc0);
686 JSHandle<JSTaggedValue> key1(thread, JSTaggedValue(1));
687 PropertyDescriptor desc1(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(2)), true, true, true);
688 JSArray::DefineOwnProperty(thread, obj, key1, desc1);
689 JSHandle<JSTaggedValue> key2(thread, JSTaggedValue(2));
690 PropertyDescriptor desc2(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(3)), true, true, true);
691 JSArray::DefineOwnProperty(thread, obj, key2, desc2);
692 JSHandle<JSTaggedValue> key3(thread, JSTaggedValue(3));
693 PropertyDescriptor desc3(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(4)), true, true, true);
694 JSArray::DefineOwnProperty(thread, obj, key3, desc3);
695 JSHandle<JSTaggedValue> key4(thread, JSTaggedValue(4));
696 PropertyDescriptor desc4(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(5)), true, true, true);
697 JSArray::DefineOwnProperty(thread, obj, key4, desc4);
698
699 auto ecmaRuntimeCallInfo1 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 10);
700 ecmaRuntimeCallInfo1->SetFunction(JSTaggedValue::Undefined());
701 ecmaRuntimeCallInfo1->SetThis(obj.GetTaggedValue());
702 ecmaRuntimeCallInfo1->SetCallArg(0, JSTaggedValue(static_cast<int32_t>(1)));
703 ecmaRuntimeCallInfo1->SetCallArg(1, JSTaggedValue(static_cast<int32_t>(2)));
704 ecmaRuntimeCallInfo1->SetCallArg(2, JSTaggedValue(static_cast<int32_t>(100)));
705
706 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo1);
707 JSTaggedValue result = Array::Splice(ecmaRuntimeCallInfo1);
708 TestHelper::TearDownFrame(thread, prev);
709 JSTaggedValue value(static_cast<JSTaggedType>(result.GetRawData()));
710 ASSERT_TRUE(value.IsECMAObject());
711 EXPECT_EQ(JSArray::GetProperty(thread, JSHandle<JSTaggedValue>(obj), lengthKeyHandle).GetValue()->GetInt(), 4);
712
713 PropertyDescriptor descRes(thread);
714 JSHandle<JSObject> valueHandle(thread, value);
715 EXPECT_EQ(
716 JSArray::GetProperty(thread, JSHandle<JSTaggedValue>(valueHandle), lengthKeyHandle).GetValue()->GetInt(), 2);
717 JSObject::GetOwnProperty(thread, valueHandle, key0, descRes);
718 ASSERT_EQ(descRes.GetValue().GetTaggedValue(), JSTaggedValue(2));
719 }
720
721 // 22.1.3.6 new Array(1,2,3,4,5).Fill(0,1,3)
HWTEST_F_L0(BuiltinsArrayTest,Fill)722 HWTEST_F_L0(BuiltinsArrayTest, Fill)
723 {
724 JSHandle<JSTaggedValue> lengthKeyHandle = thread->GlobalConstants()->GetHandledLengthString();
725 JSArray *arr = JSArray::Cast(JSArray::ArrayCreate(thread, JSTaggedNumber(0)).GetTaggedValue().GetTaggedObject());
726 EXPECT_TRUE(arr != nullptr);
727 JSHandle<JSObject> obj(thread, arr);
728 EXPECT_EQ(JSArray::GetProperty(thread, JSHandle<JSTaggedValue>(obj), lengthKeyHandle).GetValue()->GetInt(), 0);
729
730 JSHandle<JSTaggedValue> key0(thread, JSTaggedValue(0));
731 PropertyDescriptor desc0(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(1)), true, true, true);
732 JSArray::DefineOwnProperty(thread, obj, key0, desc0);
733 JSHandle<JSTaggedValue> key1(thread, JSTaggedValue(1));
734 PropertyDescriptor desc1(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(2)), true, true, true);
735 JSArray::DefineOwnProperty(thread, obj, key1, desc1);
736 JSHandle<JSTaggedValue> key2(thread, JSTaggedValue(2));
737 PropertyDescriptor desc2(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(3)), true, true, true);
738 JSArray::DefineOwnProperty(thread, obj, key2, desc2);
739 JSHandle<JSTaggedValue> key3(thread, JSTaggedValue(3));
740 PropertyDescriptor desc3(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(4)), true, true, true);
741 JSArray::DefineOwnProperty(thread, obj, key3, desc3);
742 JSHandle<JSTaggedValue> key4(thread, JSTaggedValue(4));
743 PropertyDescriptor desc4(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(5)), true, true, true);
744 JSArray::DefineOwnProperty(thread, obj, key4, desc4);
745
746 auto ecmaRuntimeCallInfo1 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 10);
747 ecmaRuntimeCallInfo1->SetFunction(JSTaggedValue::Undefined());
748 ecmaRuntimeCallInfo1->SetThis(obj.GetTaggedValue());
749 ecmaRuntimeCallInfo1->SetCallArg(0, JSTaggedValue(static_cast<int32_t>(0)));
750 ecmaRuntimeCallInfo1->SetCallArg(1, JSTaggedValue(static_cast<int32_t>(1)));
751 ecmaRuntimeCallInfo1->SetCallArg(2, JSTaggedValue(static_cast<int32_t>(3)));
752
753 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo1);
754 JSTaggedValue result = Array::Fill(ecmaRuntimeCallInfo1);
755 TestHelper::TearDownFrame(thread, prev);
756 JSTaggedValue value(static_cast<JSTaggedType>(result.GetRawData()));
757 ASSERT_TRUE(value.IsECMAObject());
758 PropertyDescriptor descRes(thread);
759 JSHandle<JSObject> valueHandle(thread, value);
760 JSObject::GetOwnProperty(thread, valueHandle, key0, descRes);
761 ASSERT_EQ(descRes.GetValue().GetTaggedValue(), JSTaggedValue(1));
762 JSObject::GetOwnProperty(thread, valueHandle, key1, descRes);
763 ASSERT_EQ(descRes.GetValue().GetTaggedValue(), JSTaggedValue(0));
764 JSObject::GetOwnProperty(thread, valueHandle, key2, descRes);
765 ASSERT_EQ(descRes.GetValue().GetTaggedValue(), JSTaggedValue(0));
766 JSObject::GetOwnProperty(thread, valueHandle, key3, descRes);
767 ASSERT_EQ(descRes.GetValue().GetTaggedValue(), JSTaggedValue(4));
768 JSObject::GetOwnProperty(thread, valueHandle, key4, descRes);
769 ASSERT_EQ(descRes.GetValue().GetTaggedValue(), JSTaggedValue(5));
770 }
771
772 // 22.1.3.6 new Array(1,2,3,4,5).Fill(0,1,3)
HWTEST_F_L0(BuiltinsArrayTest,COWArrayFill)773 HWTEST_F_L0(BuiltinsArrayTest, COWArrayFill)
774 {
775 auto ecmaVM = thread->GetEcmaVM();
776 ObjectFactory *factory = ecmaVM->GetFactory();
777
778 JSHandle<TaggedArray> values(factory->NewTaggedArray(5));
779
780 for (int i = 0; i < 5; i++) {
781 values->Set(thread, i, JSTaggedValue(i + 1));
782 }
783 JSHandle<JSArray> array(JSArray::CreateArrayFromList(thread, values));
784 JSHandle<JSArray> cloneArray = factory->CloneArrayLiteral(array);
785
786 auto ecmaRuntimeCallInfo1 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 10);
787 ecmaRuntimeCallInfo1->SetFunction(JSTaggedValue::Undefined());
788 ecmaRuntimeCallInfo1->SetThis(cloneArray.GetTaggedValue());
789 ecmaRuntimeCallInfo1->SetCallArg(0, JSTaggedValue(static_cast<int32_t>(0)));
790 ecmaRuntimeCallInfo1->SetCallArg(1, JSTaggedValue(static_cast<int32_t>(1)));
791 ecmaRuntimeCallInfo1->SetCallArg(2, JSTaggedValue(static_cast<int32_t>(3)));
792
793 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo1);
794 JSTaggedValue result = Array::Fill(ecmaRuntimeCallInfo1);
795 TestHelper::TearDownFrame(thread, prev);
796 JSTaggedValue value(static_cast<JSTaggedType>(result.GetRawData()));
797 ASSERT_TRUE(value.IsECMAObject());
798 PropertyDescriptor descRes(thread);
799 JSHandle<JSObject> valueHandle(thread, value);
800 JSHandle<JSTaggedValue> key0(thread, JSTaggedValue(0));
801 JSHandle<JSTaggedValue> key1(thread, JSTaggedValue(1));
802 JSHandle<JSTaggedValue> key2(thread, JSTaggedValue(2));
803 JSHandle<JSTaggedValue> key3(thread, JSTaggedValue(3));
804 JSHandle<JSTaggedValue> key4(thread, JSTaggedValue(4));
805
806 JSObject::GetOwnProperty(thread, valueHandle, key0, descRes);
807 ASSERT_EQ(descRes.GetValue().GetTaggedValue(), JSTaggedValue(1));
808 JSObject::GetOwnProperty(thread, valueHandle, key1, descRes);
809 ASSERT_EQ(descRes.GetValue().GetTaggedValue(), JSTaggedValue(0));
810 JSObject::GetOwnProperty(thread, valueHandle, key2, descRes);
811 ASSERT_EQ(descRes.GetValue().GetTaggedValue(), JSTaggedValue(0));
812 JSObject::GetOwnProperty(thread, valueHandle, key3, descRes);
813 ASSERT_EQ(descRes.GetValue().GetTaggedValue(), JSTaggedValue(4));
814 JSObject::GetOwnProperty(thread, valueHandle, key4, descRes);
815 ASSERT_EQ(descRes.GetValue().GetTaggedValue(), JSTaggedValue(5));
816 }
817
HWTEST_F_L0(BuiltinsArrayTest,Find)818 HWTEST_F_L0(BuiltinsArrayTest, Find)
819 {
820 auto ecmaVM = thread->GetEcmaVM();
821 JSHandle<GlobalEnv> env = ecmaVM->GetGlobalEnv();
822 ObjectFactory *factory = ecmaVM->GetFactory();
823
824 JSHandle<JSTaggedValue> lengthKeyHandle = thread->GlobalConstants()->GetHandledLengthString();
825 JSArray *arr = JSArray::Cast(JSArray::ArrayCreate(thread, JSTaggedNumber(0)).GetTaggedValue().GetTaggedObject());
826 EXPECT_TRUE(arr != nullptr);
827 JSHandle<JSObject> obj(thread, arr);
828 EXPECT_EQ(JSArray::GetProperty(thread, JSHandle<JSTaggedValue>(obj), lengthKeyHandle).GetValue()->GetInt(), 0);
829 JSHandle<JSTaggedValue> key0(thread, JSTaggedValue(0));
830 PropertyDescriptor desc0(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(1)), true, true, true);
831 JSArray::DefineOwnProperty(thread, obj, key0, desc0);
832 JSHandle<JSTaggedValue> key1(thread, JSTaggedValue(1));
833 PropertyDescriptor desc1(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(102)), true, true, true);
834 JSArray::DefineOwnProperty(thread, obj, key1, desc1);
835 JSHandle<JSTaggedValue> key2(thread, JSTaggedValue(2));
836 PropertyDescriptor desc2(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(3)), true, true, true);
837 JSArray::DefineOwnProperty(thread, obj, key2, desc2);
838 JSHandle<JSArray> jsArray(JSArray::ArrayCreate(thread, JSTaggedNumber(0)));
839 JSHandle<JSFunction> func = factory->NewJSFunction(env, reinterpret_cast<void *>(TestClass::TestFindFunc));
840
841 auto ecmaRuntimeCallInfo1 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 8);
842 ecmaRuntimeCallInfo1->SetFunction(JSTaggedValue::Undefined());
843 ecmaRuntimeCallInfo1->SetThis(obj.GetTaggedValue());
844 ecmaRuntimeCallInfo1->SetCallArg(0, func.GetTaggedValue());
845 ecmaRuntimeCallInfo1->SetCallArg(1, jsArray.GetTaggedValue());
846
847 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo1);
848 JSTaggedValue result2 = Array::Find(ecmaRuntimeCallInfo1);
849 TestHelper::TearDownFrame(thread, prev);
850
851 EXPECT_EQ(result2.GetRawData(), JSTaggedValue(102).GetRawData());
852 }
853
HWTEST_F_L0(BuiltinsArrayTest,FindIndex)854 HWTEST_F_L0(BuiltinsArrayTest, FindIndex)
855 {
856 auto ecmaVM = thread->GetEcmaVM();
857 JSHandle<GlobalEnv> env = ecmaVM->GetGlobalEnv();
858 ObjectFactory *factory = ecmaVM->GetFactory();
859
860 JSHandle<JSTaggedValue> lengthKeyHandle = thread->GlobalConstants()->GetHandledLengthString();
861 JSArray *arr = JSArray::Cast(JSArray::ArrayCreate(thread, JSTaggedNumber(0)).GetTaggedValue().GetTaggedObject());
862 EXPECT_TRUE(arr != nullptr);
863 JSHandle<JSObject> obj(thread, arr);
864 EXPECT_EQ(JSArray::GetProperty(thread, JSHandle<JSTaggedValue>(obj), lengthKeyHandle).GetValue()->GetInt(), 0);
865
866 JSHandle<JSTaggedValue> key0(thread, JSTaggedValue(0));
867 PropertyDescriptor desc0(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(1)), true, true, true);
868 JSArray::DefineOwnProperty(thread, obj, key0, desc0);
869
870 JSHandle<JSTaggedValue> key1(thread, JSTaggedValue(1));
871 PropertyDescriptor desc1(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(2)), true, true, true);
872 JSArray::DefineOwnProperty(thread, obj, key1, desc1);
873 JSHandle<JSTaggedValue> key2(thread, JSTaggedValue(2));
874 PropertyDescriptor desc2(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(30)), true, true, true);
875 JSArray::DefineOwnProperty(thread, obj, key2, desc2);
876
877 JSHandle<JSArray> jsArray(JSArray::ArrayCreate(thread, JSTaggedNumber(0)));
878 JSHandle<JSFunction> func = factory->NewJSFunction(env, reinterpret_cast<void *>(TestClass::TestFindIndexFunc));
879
880 auto ecmaRuntimeCallInfo1 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 8);
881 ecmaRuntimeCallInfo1->SetFunction(JSTaggedValue::Undefined());
882 ecmaRuntimeCallInfo1->SetThis(obj.GetTaggedValue());
883 ecmaRuntimeCallInfo1->SetCallArg(0, func.GetTaggedValue());
884 ecmaRuntimeCallInfo1->SetCallArg(1, jsArray.GetTaggedValue());
885
886 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo1);
887 JSTaggedValue result2 = Array::FindIndex(ecmaRuntimeCallInfo1);
888 TestHelper::TearDownFrame(thread, prev);
889
890 EXPECT_EQ(result2.GetRawData(), JSTaggedValue(static_cast<double>(2)).GetRawData());
891 }
892
HWTEST_F_L0(BuiltinsArrayTest,ForEach)893 HWTEST_F_L0(BuiltinsArrayTest, ForEach)
894 {
895 auto ecmaVM = thread->GetEcmaVM();
896 JSHandle<GlobalEnv> env = ecmaVM->GetGlobalEnv();
897 ObjectFactory *factory = ecmaVM->GetFactory();
898
899 JSHandle<JSTaggedValue> lengthKeyHandle = thread->GlobalConstants()->GetHandledLengthString();
900 JSArray *arr = JSArray::Cast(JSArray::ArrayCreate(thread, JSTaggedNumber(0)).GetTaggedValue().GetTaggedObject());
901 EXPECT_TRUE(arr != nullptr);
902 JSHandle<JSObject> obj(thread, arr);
903 EXPECT_EQ(JSArray::GetProperty(thread, JSHandle<JSTaggedValue>(obj), lengthKeyHandle).GetValue()->GetInt(), 0);
904
905 JSHandle<JSTaggedValue> key0(thread, JSTaggedValue(0));
906 PropertyDescriptor desc0(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(1)), true, true, true);
907 JSArray::DefineOwnProperty(thread, obj, key0, desc0);
908 JSHandle<JSTaggedValue> key1(thread, JSTaggedValue(1));
909 PropertyDescriptor desc1(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(2)), true, true, true);
910 JSArray::DefineOwnProperty(thread, obj, key1, desc1);
911 JSHandle<JSTaggedValue> key2(thread, JSTaggedValue(2));
912 PropertyDescriptor desc2(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(3)), true, true, true);
913 JSArray::DefineOwnProperty(thread, obj, key2, desc2);
914
915 JSHandle<JSArray> jsArray(JSArray::ArrayCreate(thread, JSTaggedNumber(0)));
916 JSHandle<JSFunction> func = factory->NewJSFunction(env, reinterpret_cast<void *>(TestClass::TestForEachFunc));
917
918 auto ecmaRuntimeCallInfo1 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 8);
919 ecmaRuntimeCallInfo1->SetFunction(JSTaggedValue::Undefined());
920 ecmaRuntimeCallInfo1->SetThis(obj.GetTaggedValue());
921 ecmaRuntimeCallInfo1->SetCallArg(0, func.GetTaggedValue());
922 ecmaRuntimeCallInfo1->SetCallArg(1, jsArray.GetTaggedValue());
923
924 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo1);
925 JSTaggedValue result2 = Array::ForEach(ecmaRuntimeCallInfo1);
926 TestHelper::TearDownFrame(thread, prev);
927 EXPECT_EQ(result2.GetRawData(), JSTaggedValue::VALUE_UNDEFINED);
928 EXPECT_EQ(jsArray->GetArrayLength(), 3U);
929 }
930
931 // 22.1.3.11 new Array(1,2,3,4,3).IndexOf(searchElement [ , fromIndex ])
HWTEST_F_L0(BuiltinsArrayTest,IndexOf)932 HWTEST_F_L0(BuiltinsArrayTest, IndexOf)
933 {
934 JSHandle<JSTaggedValue> lengthKeyHandle = thread->GlobalConstants()->GetHandledLengthString();
935 JSArray *arr = JSArray::Cast(JSArray::ArrayCreate(thread, JSTaggedNumber(0)).GetTaggedValue().GetTaggedObject());
936 EXPECT_TRUE(arr != nullptr);
937 JSHandle<JSObject> obj(thread, arr);
938 EXPECT_EQ(JSArray::GetProperty(thread, JSHandle<JSTaggedValue>(obj), lengthKeyHandle).GetValue()->GetInt(), 0);
939
940 JSHandle<JSTaggedValue> key0(thread, JSTaggedValue(0));
941 PropertyDescriptor desc0(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(1)), true, true, true);
942 JSArray::DefineOwnProperty(thread, obj, key0, desc0);
943 JSHandle<JSTaggedValue> key1(thread, JSTaggedValue(1));
944 PropertyDescriptor desc1(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(2)), true, true, true);
945 JSArray::DefineOwnProperty(thread, obj, key1, desc1);
946 JSHandle<JSTaggedValue> key2(thread, JSTaggedValue(2));
947 PropertyDescriptor desc2(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(3)), true, true, true);
948 JSArray::DefineOwnProperty(thread, obj, key2, desc2);
949 JSHandle<JSTaggedValue> key3(thread, JSTaggedValue(3));
950 PropertyDescriptor desc3(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(4)), true, true, true);
951 JSArray::DefineOwnProperty(thread, obj, key3, desc3);
952 JSHandle<JSTaggedValue> key4(thread, JSTaggedValue(4));
953 PropertyDescriptor desc4(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(3)), true, true, true);
954 JSArray::DefineOwnProperty(thread, obj, key4, desc4);
955
956 auto ecmaRuntimeCallInfo1 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 8);
957 ecmaRuntimeCallInfo1->SetFunction(JSTaggedValue::Undefined());
958 ecmaRuntimeCallInfo1->SetThis(obj.GetTaggedValue());
959 ecmaRuntimeCallInfo1->SetCallArg(0, JSTaggedValue(static_cast<int32_t>(3)));
960 ecmaRuntimeCallInfo1->SetCallArg(1, JSTaggedValue(static_cast<int32_t>(0)));
961
962 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo1);
963 JSTaggedValue result = Array::IndexOf(ecmaRuntimeCallInfo1);
964 TestHelper::TearDownFrame(thread, prev);
965 ASSERT_EQ(result.GetRawData(), JSTaggedValue(2).GetRawData());
966
967 auto ecmaRuntimeCallInfo2 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 8);
968 ecmaRuntimeCallInfo2->SetFunction(JSTaggedValue::Undefined());
969 ecmaRuntimeCallInfo2->SetThis(obj.GetTaggedValue());
970 ecmaRuntimeCallInfo2->SetCallArg(0, JSTaggedValue(static_cast<int32_t>(3)));
971 ecmaRuntimeCallInfo2->SetCallArg(1, JSTaggedValue(static_cast<int32_t>(3)));
972
973 prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo2);
974 result = Array::IndexOf(ecmaRuntimeCallInfo2);
975 TestHelper::TearDownFrame(thread, prev);
976 ASSERT_EQ(result.GetRawData(), JSTaggedValue(4).GetRawData());
977
978 auto ecmaRuntimeCallInfo3 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 8);
979 ecmaRuntimeCallInfo3->SetFunction(JSTaggedValue::Undefined());
980 ecmaRuntimeCallInfo3->SetThis(obj.GetTaggedValue());
981 ecmaRuntimeCallInfo3->SetCallArg(0, JSTaggedValue(static_cast<int32_t>(5)));
982 ecmaRuntimeCallInfo3->SetCallArg(1, JSTaggedValue(static_cast<int32_t>(0)));
983
984 prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo3);
985 result = Array::IndexOf(ecmaRuntimeCallInfo3);
986 TestHelper::TearDownFrame(thread, prev);
987 ASSERT_EQ(result.GetRawData(), JSTaggedValue(-1).GetRawData());
988
989 auto ecmaRuntimeCallInfo4 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 6);
990 ecmaRuntimeCallInfo4->SetFunction(JSTaggedValue::Undefined());
991 ecmaRuntimeCallInfo4->SetThis(obj.GetTaggedValue());
992 ecmaRuntimeCallInfo4->SetCallArg(0, JSTaggedValue(static_cast<int32_t>(3)));
993
994 prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo4);
995 result = Array::IndexOf(ecmaRuntimeCallInfo4);
996 TestHelper::TearDownFrame(thread, prev);
997 ASSERT_EQ(result.GetRawData(), JSTaggedValue(2).GetRawData());
998 }
999
1000 // 22.1.3.14 new Array(1,2,3,4,3).LastIndexOf(searchElement [ , fromIndex ])
HWTEST_F_L0(BuiltinsArrayTest,LastIndexOf)1001 HWTEST_F_L0(BuiltinsArrayTest, LastIndexOf)
1002 {
1003 JSHandle<JSTaggedValue> lengthKeyHandle = thread->GlobalConstants()->GetHandledLengthString();
1004 JSArray *arr = JSArray::Cast(JSArray::ArrayCreate(thread, JSTaggedNumber(0)).GetTaggedValue().GetTaggedObject());
1005 EXPECT_TRUE(arr != nullptr);
1006 JSHandle<JSObject> obj(thread, arr);
1007 EXPECT_EQ(JSArray::GetProperty(thread, JSHandle<JSTaggedValue>(obj), lengthKeyHandle).GetValue()->GetInt(), 0);
1008
1009 JSHandle<JSTaggedValue> key0(thread, JSTaggedValue(0));
1010 PropertyDescriptor desc0(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(1)), true, true, true);
1011 JSArray::DefineOwnProperty(thread, obj, key0, desc0);
1012 JSHandle<JSTaggedValue> key1(thread, JSTaggedValue(1));
1013 PropertyDescriptor desc1(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(2)), true, true, true);
1014 JSArray::DefineOwnProperty(thread, obj, key1, desc1);
1015 JSHandle<JSTaggedValue> key2(thread, JSTaggedValue(2));
1016 PropertyDescriptor desc2(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(3)), true, true, true);
1017 JSArray::DefineOwnProperty(thread, obj, key2, desc2);
1018 JSHandle<JSTaggedValue> key3(thread, JSTaggedValue(3));
1019 PropertyDescriptor desc3(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(4)), true, true, true);
1020 JSArray::DefineOwnProperty(thread, obj, key3, desc3);
1021 JSHandle<JSTaggedValue> key4(thread, JSTaggedValue(4));
1022 PropertyDescriptor desc4(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(3)), true, true, true);
1023 JSArray::DefineOwnProperty(thread, obj, key4, desc4);
1024
1025 // new Array(1,2,3,4,3).LastIndexOf(3,4)
1026 auto ecmaRuntimeCallInfo1 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 8);
1027 ecmaRuntimeCallInfo1->SetFunction(JSTaggedValue::Undefined());
1028 ecmaRuntimeCallInfo1->SetThis(obj.GetTaggedValue());
1029 ecmaRuntimeCallInfo1->SetCallArg(0, JSTaggedValue(static_cast<int32_t>(3)));
1030 ecmaRuntimeCallInfo1->SetCallArg(1, JSTaggedValue(static_cast<int32_t>(4)));
1031
1032 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo1);
1033 JSTaggedValue result = Array::LastIndexOf(ecmaRuntimeCallInfo1);
1034 TestHelper::TearDownFrame(thread, prev);
1035 ASSERT_EQ(result.GetRawData(), JSTaggedValue(static_cast<double>(4)).GetRawData());
1036
1037 // new Array(1,2,3,4,3).LastIndexOf(3,3)
1038 auto ecmaRuntimeCallInfo2 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 8);
1039 ecmaRuntimeCallInfo2->SetFunction(JSTaggedValue::Undefined());
1040 ecmaRuntimeCallInfo2->SetThis(obj.GetTaggedValue());
1041 ecmaRuntimeCallInfo2->SetCallArg(0, JSTaggedValue(static_cast<int32_t>(3)));
1042 ecmaRuntimeCallInfo2->SetCallArg(1, JSTaggedValue(static_cast<int32_t>(3)));
1043
1044 prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo2);
1045 result = Array::LastIndexOf(ecmaRuntimeCallInfo2);
1046 TestHelper::TearDownFrame(thread, prev);
1047 ASSERT_EQ(result.GetRawData(), JSTaggedValue(static_cast<double>(2)).GetRawData());
1048
1049 // new Array(1,2,3,4,3).LastIndexOf(5,4)
1050 auto ecmaRuntimeCallInfo3 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 8);
1051 ecmaRuntimeCallInfo3->SetFunction(JSTaggedValue::Undefined());
1052 ecmaRuntimeCallInfo3->SetThis(obj.GetTaggedValue());
1053 ecmaRuntimeCallInfo3->SetCallArg(0, JSTaggedValue(static_cast<int32_t>(5)));
1054 ecmaRuntimeCallInfo3->SetCallArg(1, JSTaggedValue(static_cast<int32_t>(4)));
1055
1056 prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo3);
1057 result = Array::LastIndexOf(ecmaRuntimeCallInfo3);
1058 TestHelper::TearDownFrame(thread, prev);
1059 ASSERT_EQ(result.GetRawData(), JSTaggedValue(-1).GetRawData());
1060
1061 // new Array(1,2,3,4,3).LastIndexOf(3)
1062 auto ecmaRuntimeCallInfo4 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 6);
1063 ecmaRuntimeCallInfo4->SetFunction(JSTaggedValue::Undefined());
1064 ecmaRuntimeCallInfo4->SetThis(obj.GetTaggedValue());
1065 ecmaRuntimeCallInfo4->SetCallArg(0, JSTaggedValue(static_cast<int32_t>(3)));
1066
1067 prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo4);
1068 result = Array::LastIndexOf(ecmaRuntimeCallInfo4);
1069 TestHelper::TearDownFrame(thread, prev);
1070 ASSERT_EQ(result.GetRawData(), JSTaggedValue(static_cast<double>(4)).GetRawData());
1071 }
1072
1073 // 22.1.3.11 new Array().Pop()
HWTEST_F_L0(BuiltinsArrayTest,Pop)1074 HWTEST_F_L0(BuiltinsArrayTest, Pop)
1075 {
1076 JSHandle<JSTaggedValue> lengthKeyHandle = thread->GlobalConstants()->GetHandledLengthString();
1077 JSArray *arr = JSArray::Cast(JSArray::ArrayCreate(thread, JSTaggedNumber(0)).GetTaggedValue().GetTaggedObject());
1078 EXPECT_TRUE(arr != nullptr);
1079 JSHandle<JSObject> obj(thread, arr);
1080 EXPECT_EQ(JSArray::GetProperty(thread, JSHandle<JSTaggedValue>(obj), lengthKeyHandle).GetValue()->GetInt(), 0);
1081
1082 auto ecmaRuntimeCallInfo1 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 4);
1083 ecmaRuntimeCallInfo1->SetFunction(JSTaggedValue::Undefined());
1084 ecmaRuntimeCallInfo1->SetThis(obj.GetTaggedValue());
1085
1086 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo1);
1087 JSTaggedValue result = Array::Pop(ecmaRuntimeCallInfo1);
1088 TestHelper::TearDownFrame(thread, prev);
1089 ASSERT_EQ(result.GetRawData(), JSTaggedValue::VALUE_UNDEFINED);
1090 ASSERT_EQ(result.GetRawData(), JSTaggedValue::VALUE_UNDEFINED);
1091
1092 JSHandle<JSTaggedValue> key0(thread, JSTaggedValue(0));
1093 PropertyDescriptor desc0(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(1)), true, true, true);
1094 JSArray::DefineOwnProperty(thread, obj, key0, desc0);
1095 JSHandle<JSTaggedValue> key1(thread, JSTaggedValue(1));
1096 PropertyDescriptor desc1(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(2)), true, true, true);
1097 JSArray::DefineOwnProperty(thread, obj, key1, desc1);
1098 JSHandle<JSTaggedValue> key2(thread, JSTaggedValue(2));
1099 PropertyDescriptor desc2(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(3)), true, true, true);
1100 JSArray::DefineOwnProperty(thread, obj, key2, desc2);
1101
1102 auto ecmaRuntimeCallInfo2 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 4);
1103 ecmaRuntimeCallInfo2->SetFunction(JSTaggedValue::Undefined());
1104 ecmaRuntimeCallInfo2->SetThis(obj.GetTaggedValue());
1105
1106 prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo2);
1107 result = Array::Pop(ecmaRuntimeCallInfo2);
1108 TestHelper::TearDownFrame(thread, prev);
1109 ASSERT_EQ(result.GetRawData(), JSTaggedValue(3).GetRawData());
1110 }
1111
1112 // 22.1.3.11 new Array().Pop()
HWTEST_F_L0(BuiltinsArrayTest,COWArrayPop)1113 HWTEST_F_L0(BuiltinsArrayTest, COWArrayPop)
1114 {
1115 auto ecmaVM = thread->GetEcmaVM();
1116 ObjectFactory *factory = ecmaVM->GetFactory();
1117
1118 JSHandle<TaggedArray> values(factory->NewTaggedArray(3));
1119
1120 for (int i = 0; i < 3; i++) {
1121 values->Set(thread, i, JSTaggedValue(i + 1));
1122 }
1123 JSHandle<JSArray> array(JSArray::CreateArrayFromList(thread, values));
1124 JSHandle<JSArray> cloneArray = factory->CloneArrayLiteral(array);
1125
1126 auto ecmaRuntimeCallInfo1 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 4);
1127 ecmaRuntimeCallInfo1->SetFunction(JSTaggedValue::Undefined());
1128 ecmaRuntimeCallInfo1->SetThis(cloneArray.GetTaggedValue());
1129
1130 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo1);
1131 auto result = Array::Pop(ecmaRuntimeCallInfo1);
1132 TestHelper::TearDownFrame(thread, prev);
1133 ASSERT_EQ(result.GetRawData(), JSTaggedValue(3).GetRawData());
1134 }
1135
1136 // 22.1.3.11 new Array(1,2,3).Push(...items)
HWTEST_F_L0(BuiltinsArrayTest,Push)1137 HWTEST_F_L0(BuiltinsArrayTest, Push)
1138 {
1139 JSHandle<JSTaggedValue> lengthKeyHandle = thread->GlobalConstants()->GetHandledLengthString();
1140 JSArray *arr = JSArray::Cast(JSArray::ArrayCreate(thread, JSTaggedNumber(0)).GetTaggedValue().GetTaggedObject());
1141 EXPECT_TRUE(arr != nullptr);
1142 JSHandle<JSObject> obj(thread, arr);
1143 EXPECT_EQ(JSArray::GetProperty(thread, JSHandle<JSTaggedValue>(obj), lengthKeyHandle).GetValue()->GetInt(), 0);
1144
1145 JSHandle<JSTaggedValue> key0(thread, JSTaggedValue(0));
1146 PropertyDescriptor desc0(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(1)), true, true, true);
1147 JSArray::DefineOwnProperty(thread, obj, key0, desc0);
1148 JSHandle<JSTaggedValue> key1(thread, JSTaggedValue(1));
1149 PropertyDescriptor desc1(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(2)), true, true, true);
1150 JSArray::DefineOwnProperty(thread, obj, key1, desc1);
1151 JSHandle<JSTaggedValue> key2(thread, JSTaggedValue(2));
1152 PropertyDescriptor desc2(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(3)), true, true, true);
1153 JSArray::DefineOwnProperty(thread, obj, key2, desc2);
1154
1155 auto ecmaRuntimeCallInfo1 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 8);
1156 ecmaRuntimeCallInfo1->SetFunction(JSTaggedValue::Undefined());
1157 ecmaRuntimeCallInfo1->SetThis(obj.GetTaggedValue());
1158 ecmaRuntimeCallInfo1->SetCallArg(0, JSTaggedValue(static_cast<int32_t>(4)));
1159 ecmaRuntimeCallInfo1->SetCallArg(1, JSTaggedValue(static_cast<int32_t>(5)));
1160
1161 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo1);
1162 JSTaggedValue result = Array::Push(ecmaRuntimeCallInfo1);
1163 TestHelper::TearDownFrame(thread, prev);
1164 ASSERT_EQ(result.GetNumber(), 5);
1165
1166 EXPECT_EQ(JSArray::GetProperty(thread, JSHandle<JSTaggedValue>(obj), lengthKeyHandle).GetValue()->GetInt(), 5);
1167 JSHandle<JSTaggedValue> key3(thread, JSTaggedValue(3));
1168 EXPECT_EQ(JSArray::GetProperty(thread, JSHandle<JSTaggedValue>(obj), key3).GetValue()->GetInt(), 4);
1169 JSHandle<JSTaggedValue> key4(thread, JSTaggedValue(4));
1170 EXPECT_EQ(JSArray::GetProperty(thread, JSHandle<JSTaggedValue>(obj), key4).GetValue()->GetInt(), 5);
1171 }
1172
HWTEST_F_L0(BuiltinsArrayTest,Reduce)1173 HWTEST_F_L0(BuiltinsArrayTest, Reduce)
1174 {
1175 auto ecmaVM = thread->GetEcmaVM();
1176 JSHandle<GlobalEnv> env = ecmaVM->GetGlobalEnv();
1177 ObjectFactory *factory = ecmaVM->GetFactory();
1178
1179 JSHandle<JSTaggedValue> lengthKeyHandle = thread->GlobalConstants()->GetHandledLengthString();
1180 JSArray *arr = JSArray::Cast(JSArray::ArrayCreate(thread, JSTaggedNumber(0)).GetTaggedValue().GetTaggedObject());
1181 EXPECT_TRUE(arr != nullptr);
1182 JSHandle<JSObject> obj(thread, arr);
1183 EXPECT_EQ(JSArray::GetProperty(thread, JSHandle<JSTaggedValue>(obj), lengthKeyHandle).GetValue()->GetInt(), 0);
1184 JSHandle<JSTaggedValue> key0(thread, JSTaggedValue(0));
1185 PropertyDescriptor desc0(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(1)), true, true, true);
1186 JSArray::DefineOwnProperty(thread, obj, key0, desc0);
1187 JSHandle<JSTaggedValue> key1(thread, JSTaggedValue(1));
1188 PropertyDescriptor desc1(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(2)), true, true, true);
1189 JSArray::DefineOwnProperty(thread, obj, key1, desc1);
1190 JSHandle<JSTaggedValue> key2(thread, JSTaggedValue(2));
1191 PropertyDescriptor desc2(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(3)), true, true, true);
1192 JSArray::DefineOwnProperty(thread, obj, key2, desc2);
1193
1194 JSHandle<JSFunction> func = factory->NewJSFunction(env, reinterpret_cast<void *>(TestClass::TestReduceFunc));
1195
1196 auto ecmaRuntimeCallInfo1 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 8);
1197 ecmaRuntimeCallInfo1->SetFunction(JSTaggedValue::Undefined());
1198 ecmaRuntimeCallInfo1->SetThis(obj.GetTaggedValue());
1199 ecmaRuntimeCallInfo1->SetCallArg(0, func.GetTaggedValue());
1200 ecmaRuntimeCallInfo1->SetCallArg(1, JSTaggedValue(static_cast<int32_t>(10)));
1201
1202 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo1);
1203 JSTaggedValue result = Array::Reduce(ecmaRuntimeCallInfo1);
1204 TestHelper::TearDownFrame(thread, prev);
1205 ASSERT_EQ(result.GetRawData(), JSTaggedValue(16).GetRawData());
1206 }
1207
HWTEST_F_L0(BuiltinsArrayTest,ReduceRight)1208 HWTEST_F_L0(BuiltinsArrayTest, ReduceRight)
1209 {
1210 auto ecmaVM = thread->GetEcmaVM();
1211 JSHandle<GlobalEnv> env = ecmaVM->GetGlobalEnv();
1212 ObjectFactory *factory = ecmaVM->GetFactory();
1213
1214 JSHandle<JSTaggedValue> lengthKeyHandle = thread->GlobalConstants()->GetHandledLengthString();
1215 JSArray *arr = JSArray::Cast(JSArray::ArrayCreate(thread, JSTaggedNumber(0)).GetTaggedValue().GetTaggedObject());
1216 EXPECT_TRUE(arr != nullptr);
1217 JSHandle<JSObject> obj(thread, arr);
1218 EXPECT_EQ(JSArray::GetProperty(thread, JSHandle<JSTaggedValue>(obj), lengthKeyHandle).GetValue()->GetInt(), 0);
1219 JSHandle<JSTaggedValue> key0(thread, JSTaggedValue(0));
1220 PropertyDescriptor desc0(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(1)), true, true, true);
1221 JSArray::DefineOwnProperty(thread, obj, key0, desc0);
1222 JSHandle<JSTaggedValue> key1(thread, JSTaggedValue(1));
1223 PropertyDescriptor desc1(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(2)), true, true, true);
1224 JSArray::DefineOwnProperty(thread, obj, key1, desc1);
1225 JSHandle<JSTaggedValue> key2(thread, JSTaggedValue(2));
1226 PropertyDescriptor desc2(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(3)), true, true, true);
1227 JSArray::DefineOwnProperty(thread, obj, key2, desc2);
1228
1229 JSHandle<JSFunction> func = factory->NewJSFunction(env, reinterpret_cast<void *>(TestClass::TestReduceRightFunc));
1230
1231 auto ecmaRuntimeCallInfo1 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 8);
1232 ecmaRuntimeCallInfo1->SetFunction(JSTaggedValue::Undefined());
1233 ecmaRuntimeCallInfo1->SetThis(obj.GetTaggedValue());
1234 ecmaRuntimeCallInfo1->SetCallArg(0, func.GetTaggedValue());
1235 ecmaRuntimeCallInfo1->SetCallArg(1, JSTaggedValue(static_cast<int32_t>(10)));
1236
1237 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo1);
1238 JSTaggedValue result = Array::ReduceRight(ecmaRuntimeCallInfo1);
1239 TestHelper::TearDownFrame(thread, prev);
1240 ASSERT_EQ(result.GetRawData(), JSTaggedValue(16).GetRawData());
1241 }
1242
HWTEST_F_L0(BuiltinsArrayTest,Shift)1243 HWTEST_F_L0(BuiltinsArrayTest, Shift)
1244 {
1245 JSHandle<JSTaggedValue> lengthKeyHandle = thread->GlobalConstants()->GetHandledLengthString();
1246 JSArray *arr = JSArray::Cast(JSArray::ArrayCreate(thread, JSTaggedNumber(0)).GetTaggedValue().GetTaggedObject());
1247 EXPECT_TRUE(arr != nullptr);
1248 JSHandle<JSObject> obj(thread, arr);
1249 EXPECT_EQ(JSArray::GetProperty(thread, JSHandle<JSTaggedValue>(obj), lengthKeyHandle).GetValue()->GetInt(), 0);
1250
1251 JSHandle<JSTaggedValue> key0(thread, JSTaggedValue(0));
1252 PropertyDescriptor desc0(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(1)), true, true, true);
1253 JSArray::DefineOwnProperty(thread, obj, key0, desc0);
1254 JSHandle<JSTaggedValue> key1(thread, JSTaggedValue(1));
1255 PropertyDescriptor desc1(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(2)), true, true, true);
1256 JSArray::DefineOwnProperty(thread, obj, key1, desc1);
1257 JSHandle<JSTaggedValue> key2(thread, JSTaggedValue(2));
1258 PropertyDescriptor desc2(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(3)), true, true, true);
1259 JSArray::DefineOwnProperty(thread, obj, key2, desc2);
1260
1261 auto ecmaRuntimeCallInfo1 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 4);
1262 ecmaRuntimeCallInfo1->SetFunction(JSTaggedValue::Undefined());
1263 ecmaRuntimeCallInfo1->SetThis(obj.GetTaggedValue());
1264
1265 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo1);
1266 JSTaggedValue result = Array::Shift(ecmaRuntimeCallInfo1);
1267 TestHelper::TearDownFrame(thread, prev);
1268 ASSERT_EQ(result.GetRawData(), JSTaggedValue(1).GetRawData());
1269 }
1270
HWTEST_F_L0(BuiltinsArrayTest,COWArrayShift)1271 HWTEST_F_L0(BuiltinsArrayTest, COWArrayShift)
1272 {
1273 auto ecmaVM = thread->GetEcmaVM();
1274 ObjectFactory *factory = ecmaVM->GetFactory();
1275
1276 JSHandle<TaggedArray> values(factory->NewTaggedArray(3));
1277
1278 for (int i = 0; i < 3; i++) {
1279 values->Set(thread, i, JSTaggedValue(i + 1));
1280 }
1281 JSHandle<JSArray> array(JSArray::CreateArrayFromList(thread, values));
1282 JSHandle<JSArray> cloneArray = factory->CloneArrayLiteral(array);
1283
1284 auto ecmaRuntimeCallInfo1 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 4);
1285 ecmaRuntimeCallInfo1->SetFunction(JSTaggedValue::Undefined());
1286 ecmaRuntimeCallInfo1->SetThis(cloneArray.GetTaggedValue());
1287
1288 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo1);
1289 JSTaggedValue result = Array::Shift(ecmaRuntimeCallInfo1);
1290 TestHelper::TearDownFrame(thread, prev);
1291 ASSERT_EQ(result.GetRawData(), JSTaggedValue(1).GetRawData());
1292 }
1293
HWTEST_F_L0(BuiltinsArrayTest,Some)1294 HWTEST_F_L0(BuiltinsArrayTest, Some)
1295 {
1296 auto ecmaVM = thread->GetEcmaVM();
1297 JSHandle<GlobalEnv> env = ecmaVM->GetGlobalEnv();
1298 ObjectFactory *factory = ecmaVM->GetFactory();
1299
1300 JSHandle<JSTaggedValue> lengthKeyHandle = thread->GlobalConstants()->GetHandledLengthString();
1301 JSArray *arr = JSArray::Cast(JSArray::ArrayCreate(thread, JSTaggedNumber(0)).GetTaggedValue().GetTaggedObject());
1302 EXPECT_TRUE(arr != nullptr);
1303 JSHandle<JSObject> obj(thread, arr);
1304 EXPECT_EQ(JSArray::GetProperty(thread, JSHandle<JSTaggedValue>(obj), lengthKeyHandle).GetValue()->GetInt(), 0);
1305
1306 JSHandle<JSTaggedValue> key0(thread, JSTaggedValue(0));
1307 PropertyDescriptor desc0(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(1)), true, true, true);
1308 JSArray::DefineOwnProperty(thread, obj, key0, desc0);
1309 JSHandle<JSTaggedValue> key1(thread, JSTaggedValue(1));
1310 PropertyDescriptor desc1(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(20)), true, true, true);
1311 JSArray::DefineOwnProperty(thread, obj, key1, desc1);
1312 JSHandle<JSTaggedValue> key2(thread, JSTaggedValue(2));
1313 PropertyDescriptor desc2(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(3)), true, true, true);
1314 JSArray::DefineOwnProperty(thread, obj, key2, desc2);
1315
1316 JSHandle<JSArray> jsArray(JSArray::ArrayCreate(thread, JSTaggedNumber(0)));
1317 JSHandle<JSFunction> func = factory->NewJSFunction(env, reinterpret_cast<void *>(TestClass::TestSomeFunc));
1318
1319 auto ecmaRuntimeCallInfo1 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 8);
1320 ecmaRuntimeCallInfo1->SetFunction(JSTaggedValue::Undefined());
1321 ecmaRuntimeCallInfo1->SetThis(obj.GetTaggedValue());
1322 ecmaRuntimeCallInfo1->SetCallArg(0, func.GetTaggedValue());
1323 ecmaRuntimeCallInfo1->SetCallArg(1, jsArray.GetTaggedValue());
1324
1325 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo1);
1326 JSTaggedValue result2 = Array::Some(ecmaRuntimeCallInfo1);
1327 TestHelper::TearDownFrame(thread, prev);
1328 ASSERT_EQ(result2.GetRawData(), JSTaggedValue::True().GetRawData());
1329 }
1330
HWTEST_F_L0(BuiltinsArrayTest,Sort)1331 HWTEST_F_L0(BuiltinsArrayTest, Sort)
1332 {
1333 JSHandle<JSTaggedValue> lengthKeyHandle = thread->GlobalConstants()->GetHandledLengthString();
1334 JSArray *arr = JSArray::Cast(JSArray::ArrayCreate(thread, JSTaggedNumber(0)).GetTaggedValue().GetTaggedObject());
1335 EXPECT_TRUE(arr != nullptr);
1336 JSHandle<JSObject> obj(thread, arr);
1337 EXPECT_EQ(JSArray::GetProperty(thread, JSHandle<JSTaggedValue>(obj), lengthKeyHandle).GetValue()->GetInt(), 0);
1338
1339 JSHandle<JSTaggedValue> key0(thread, JSTaggedValue(0));
1340 PropertyDescriptor desc0(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(3)), true, true, true);
1341 JSArray::DefineOwnProperty(thread, obj, key0, desc0);
1342 JSHandle<JSTaggedValue> key1(thread, JSTaggedValue(1));
1343 PropertyDescriptor desc1(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(2)), true, true, true);
1344 JSArray::DefineOwnProperty(thread, obj, key1, desc1);
1345 JSHandle<JSTaggedValue> key2(thread, JSTaggedValue(2));
1346 PropertyDescriptor desc2(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(1)), true, true, true);
1347 JSArray::DefineOwnProperty(thread, obj, key2, desc2);
1348
1349 auto ecmaRuntimeCallInfo1 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 4);
1350 ecmaRuntimeCallInfo1->SetFunction(JSTaggedValue::Undefined());
1351 ecmaRuntimeCallInfo1->SetThis(obj.GetTaggedValue());
1352
1353 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo1);
1354 JSTaggedValue result2 = Array::Sort(ecmaRuntimeCallInfo1);
1355 TestHelper::TearDownFrame(thread, prev);
1356
1357 EXPECT_TRUE(result2.IsECMAObject());
1358 JSHandle<JSTaggedValue> resultArr =
1359 JSHandle<JSTaggedValue>(thread, JSTaggedValue(static_cast<JSTaggedType>(result2.GetRawData())));
1360 EXPECT_EQ(JSArray::GetProperty(thread, resultArr, key0).GetValue()->GetInt(), 1);
1361 EXPECT_EQ(JSArray::GetProperty(thread, resultArr, key1).GetValue()->GetInt(), 2);
1362 EXPECT_EQ(JSArray::GetProperty(thread, resultArr, key2).GetValue()->GetInt(), 3);
1363 }
1364
HWTEST_F_L0(BuiltinsArrayTest,Unshift)1365 HWTEST_F_L0(BuiltinsArrayTest, Unshift)
1366 {
1367 JSHandle<JSTaggedValue> lengthKeyHandle = thread->GlobalConstants()->GetHandledLengthString();
1368 JSArray *arr = JSArray::Cast(JSArray::ArrayCreate(thread, JSTaggedNumber(0)).GetTaggedValue().GetTaggedObject());
1369 EXPECT_TRUE(arr != nullptr);
1370 JSHandle<JSObject> obj(thread, arr);
1371 EXPECT_EQ(JSArray::GetProperty(thread, JSHandle<JSTaggedValue>(obj), lengthKeyHandle).GetValue()->GetInt(), 0);
1372
1373 JSHandle<JSTaggedValue> key0(thread, JSTaggedValue(0));
1374 PropertyDescriptor desc0(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(1)), true, true, true);
1375 JSArray::DefineOwnProperty(thread, obj, key0, desc0);
1376 JSHandle<JSTaggedValue> key1(thread, JSTaggedValue(1));
1377 PropertyDescriptor desc1(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(2)), true, true, true);
1378 JSArray::DefineOwnProperty(thread, obj, key1, desc1);
1379 JSHandle<JSTaggedValue> key2(thread, JSTaggedValue(2));
1380 PropertyDescriptor desc2(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(3)), true, true, true);
1381 JSArray::DefineOwnProperty(thread, obj, key2, desc2);
1382
1383 auto ecmaRuntimeCallInfo1 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 8);
1384 ecmaRuntimeCallInfo1->SetFunction(JSTaggedValue::Undefined());
1385 ecmaRuntimeCallInfo1->SetThis(obj.GetTaggedValue());
1386 ecmaRuntimeCallInfo1->SetCallArg(0, JSTaggedValue(static_cast<int32_t>(4)));
1387 ecmaRuntimeCallInfo1->SetCallArg(1, JSTaggedValue(static_cast<int32_t>(5)));
1388
1389 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo1);
1390 JSTaggedValue result = Array::Unshift(ecmaRuntimeCallInfo1);
1391 TestHelper::TearDownFrame(thread, prev);
1392
1393 ASSERT_EQ(result.GetRawData(), JSTaggedValue(static_cast<double>(5)).GetRawData());
1394
1395 EXPECT_EQ(JSArray::GetProperty(thread, JSHandle<JSTaggedValue>(obj), lengthKeyHandle).GetValue()->GetInt(), 5);
1396 JSHandle<JSTaggedValue> key3(thread, JSTaggedValue(0));
1397 EXPECT_EQ(JSArray::GetProperty(thread, JSHandle<JSTaggedValue>(obj), key3).GetValue()->GetInt(), 4);
1398 JSHandle<JSTaggedValue> key4(thread, JSTaggedValue(1));
1399 EXPECT_EQ(JSArray::GetProperty(thread, JSHandle<JSTaggedValue>(obj), key4).GetValue()->GetInt(), 5);
1400 }
1401
HWTEST_F_L0(BuiltinsArrayTest,Join)1402 HWTEST_F_L0(BuiltinsArrayTest, Join)
1403 {
1404 JSHandle<JSTaggedValue> lengthKeyHandle = thread->GlobalConstants()->GetHandledLengthString();
1405 JSArray *arr = JSArray::Cast(JSArray::ArrayCreate(thread, JSTaggedNumber(0)).GetTaggedValue().GetTaggedObject());
1406 EXPECT_TRUE(arr != nullptr);
1407 JSHandle<JSTaggedValue> obj(thread, arr);
1408 EXPECT_EQ(JSArray::GetProperty(thread, obj, lengthKeyHandle).GetValue()->GetInt(), 0);
1409
1410 JSHandle<JSTaggedValue> key0(thread, JSTaggedValue(0));
1411 PropertyDescriptor desc0(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(2)));
1412 JSArray::DefineOwnProperty(thread, JSHandle<JSObject>(obj), key0, desc0);
1413 JSHandle<JSTaggedValue> key1(thread, JSTaggedValue(1));
1414 PropertyDescriptor desc1(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(3)));
1415 JSArray::DefineOwnProperty(thread, JSHandle<JSObject>(obj), key1, desc1);
1416 JSHandle<JSTaggedValue> key2(thread, JSTaggedValue(2));
1417 PropertyDescriptor desc2(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(4)));
1418 JSArray::DefineOwnProperty(thread, JSHandle<JSObject>(obj), key2, desc2);
1419
1420 JSHandle<EcmaString> str = thread->GetEcmaVM()->GetFactory()->NewFromASCII("2,3,4");
1421 auto ecmaRuntimeCallInfo1 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 4);
1422 ecmaRuntimeCallInfo1->SetFunction(JSTaggedValue::Undefined());
1423 ecmaRuntimeCallInfo1->SetThis(obj.GetTaggedValue());
1424
1425 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo1);
1426 JSTaggedValue result = Array::Join(ecmaRuntimeCallInfo1);
1427 TestHelper::TearDownFrame(thread, prev);
1428 JSHandle<EcmaString> resultHandle(thread, reinterpret_cast<EcmaString *>(result.GetRawData()));
1429 [[maybe_unused]] auto *res = EcmaString::Cast(resultHandle.GetTaggedValue().GetTaggedObject());
1430
1431 ASSERT_EQ(EcmaStringAccessor::Compare(res, *str), 0);
1432 }
1433
HWTEST_F_L0(BuiltinsArrayTest,ToString)1434 HWTEST_F_L0(BuiltinsArrayTest, ToString)
1435 {
1436 JSHandle<JSTaggedValue> lengthKeyHandle = thread->GlobalConstants()->GetHandledLengthString();
1437 JSArray *arr = JSArray::Cast(JSArray::ArrayCreate(thread, JSTaggedNumber(0)).GetTaggedValue().GetTaggedObject());
1438 EXPECT_TRUE(arr != nullptr);
1439 JSHandle<JSTaggedValue> obj(thread, arr);
1440 EXPECT_EQ(JSArray::GetProperty(thread, obj, lengthKeyHandle).GetValue()->GetInt(), 0);
1441
1442 JSHandle<JSTaggedValue> key0(thread, JSTaggedValue(0));
1443 PropertyDescriptor desc0(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(2)));
1444 JSArray::DefineOwnProperty(thread, JSHandle<JSObject>(obj), key0, desc0);
1445 JSHandle<JSTaggedValue> key1(thread, JSTaggedValue(1));
1446 PropertyDescriptor desc1(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(3)));
1447 JSArray::DefineOwnProperty(thread, JSHandle<JSObject>(obj), key1, desc1);
1448 JSHandle<JSTaggedValue> key2(thread, JSTaggedValue(2));
1449 PropertyDescriptor desc2(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(4)));
1450 JSArray::DefineOwnProperty(thread, JSHandle<JSObject>(obj), key2, desc2);
1451
1452 JSHandle<EcmaString> str = thread->GetEcmaVM()->GetFactory()->NewFromASCII("2,3,4");
1453 auto ecmaRuntimeCallInfo1 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 4);
1454 ecmaRuntimeCallInfo1->SetFunction(JSTaggedValue::Undefined());
1455 ecmaRuntimeCallInfo1->SetThis(obj.GetTaggedValue());
1456
1457 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo1);
1458 JSTaggedValue result = Array::ToString(ecmaRuntimeCallInfo1);
1459 TestHelper::TearDownFrame(thread, prev);
1460 JSHandle<EcmaString> resultHandle(thread, reinterpret_cast<EcmaString *>(result.GetRawData()));
1461 [[maybe_unused]] auto *res = EcmaString::Cast(resultHandle.GetTaggedValue().GetTaggedObject());
1462
1463 ASSERT_EQ(EcmaStringAccessor::Compare(res, *str), 0);
1464 }
1465
HWTEST_F_L0(BuiltinsArrayTest,Includes)1466 HWTEST_F_L0(BuiltinsArrayTest, Includes)
1467 {
1468 JSHandle<JSTaggedValue> lengthKeyHandle = thread->GlobalConstants()->GetHandledLengthString();
1469 JSArray *arr = JSArray::Cast(JSArray::ArrayCreate(thread, JSTaggedNumber(0)).GetTaggedValue().GetTaggedObject());
1470 EXPECT_TRUE(arr != nullptr);
1471 JSHandle<JSTaggedValue> obj(thread, arr);
1472 EXPECT_EQ(JSArray::GetProperty(thread, obj, lengthKeyHandle).GetValue()->GetInt(), 0);
1473
1474 JSHandle<JSTaggedValue> key0(thread, JSTaggedValue(0));
1475 PropertyDescriptor desc0(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(2)));
1476 JSArray::DefineOwnProperty(thread, JSHandle<JSObject>(obj), key0, desc0);
1477 JSHandle<JSTaggedValue> key1(thread, JSTaggedValue(1));
1478 PropertyDescriptor desc1(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(3)));
1479 JSArray::DefineOwnProperty(thread, JSHandle<JSObject>(obj), key1, desc1);
1480 JSHandle<JSTaggedValue> key2(thread, JSTaggedValue(2));
1481 PropertyDescriptor desc2(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(4)));
1482 JSArray::DefineOwnProperty(thread, JSHandle<JSObject>(obj), key2, desc2);
1483
1484 auto ecmaRuntimeCallInfo1 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 6);
1485 ecmaRuntimeCallInfo1->SetFunction(JSTaggedValue::Undefined());
1486 ecmaRuntimeCallInfo1->SetThis(obj.GetTaggedValue());
1487 ecmaRuntimeCallInfo1->SetCallArg(0, JSTaggedValue(static_cast<int32_t>(2)));
1488
1489 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo1);
1490 [[maybe_unused]] JSTaggedValue result = Array::Includes(ecmaRuntimeCallInfo1);
1491 TestHelper::TearDownFrame(thread, prev);
1492
1493 ASSERT_TRUE(result.JSTaggedValue::ToBoolean()); // new Int8Array[2,3,4].includes(2)
1494
1495 auto ecmaRuntimeCallInfo2 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 6);
1496 ecmaRuntimeCallInfo2->SetFunction(JSTaggedValue::Undefined());
1497 ecmaRuntimeCallInfo2->SetThis(obj.GetTaggedValue());
1498 ecmaRuntimeCallInfo2->SetCallArg(0, JSTaggedValue(static_cast<int32_t>(1)));
1499
1500 prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo2);
1501 result = Array::Includes(ecmaRuntimeCallInfo2);
1502 TestHelper::TearDownFrame(thread, prev);
1503
1504 ASSERT_TRUE(!result.JSTaggedValue::ToBoolean()); // new Int8Array[2,3,4].includes(1)
1505
1506 auto ecmaRuntimeCallInfo3 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 8);
1507 ecmaRuntimeCallInfo3->SetFunction(JSTaggedValue::Undefined());
1508 ecmaRuntimeCallInfo3->SetThis(obj.GetTaggedValue());
1509 ecmaRuntimeCallInfo3->SetCallArg(0, JSTaggedValue(static_cast<int32_t>(3)));
1510 ecmaRuntimeCallInfo3->SetCallArg(1, JSTaggedValue(static_cast<int32_t>(1)));
1511
1512 prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo3);
1513 result = Array::Includes(ecmaRuntimeCallInfo3);
1514 TestHelper::TearDownFrame(thread, prev);
1515
1516 ASSERT_TRUE(result.JSTaggedValue::ToBoolean()); // new Int8Array[2,3,4].includes(3, 1)
1517
1518 auto ecmaRuntimeCallInfo4 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 8);
1519 ecmaRuntimeCallInfo4->SetFunction(JSTaggedValue::Undefined());
1520 ecmaRuntimeCallInfo4->SetThis(obj.GetTaggedValue());
1521 ecmaRuntimeCallInfo4->SetCallArg(0, JSTaggedValue(static_cast<int32_t>(2)));
1522 ecmaRuntimeCallInfo4->SetCallArg(1, JSTaggedValue(static_cast<int32_t>(5)));
1523
1524 prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo4);
1525 result = Array::Includes(ecmaRuntimeCallInfo4);
1526 TestHelper::TearDownFrame(thread, prev);
1527
1528 ASSERT_TRUE(!result.JSTaggedValue::ToBoolean()); // new Int8Array[2,3,4].includes(2, 5)
1529
1530 auto ecmaRuntimeCallInfo5 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 8);
1531 ecmaRuntimeCallInfo5->SetFunction(JSTaggedValue::Undefined());
1532 ecmaRuntimeCallInfo5->SetThis(obj.GetTaggedValue());
1533 ecmaRuntimeCallInfo5->SetCallArg(0, JSTaggedValue(static_cast<int32_t>(2)));
1534 ecmaRuntimeCallInfo5->SetCallArg(1, JSTaggedValue(static_cast<int32_t>(-2)));
1535
1536 prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo5);
1537 result = Array::Includes(ecmaRuntimeCallInfo5);
1538 TestHelper::TearDownFrame(thread, prev);
1539
1540 ASSERT_TRUE(!result.JSTaggedValue::ToBoolean()); // new Int8Array[2,3,4].includes(2, -2)
1541 }
1542
1543 // es12 23.1.3.10 new Array(1,[2,3]).flat()
HWTEST_F_L0(BuiltinsArrayTest,Flat)1544 HWTEST_F_L0(BuiltinsArrayTest, Flat)
1545 {
1546 JSHandle<JSTaggedValue> lengthKeyHandle = thread->GlobalConstants()->GetHandledLengthString();
1547 JSArray *arr1 = JSArray::Cast(JSArray::ArrayCreate(thread, JSTaggedNumber(0)).GetTaggedValue().GetTaggedObject());
1548 EXPECT_TRUE(arr1 != nullptr);
1549 JSHandle<JSObject> obj1(thread, arr1);
1550 EXPECT_EQ(JSArray::GetProperty(thread, JSHandle<JSTaggedValue>(obj1), lengthKeyHandle).GetValue()->GetInt(), 0);
1551
1552 JSHandle<JSTaggedValue> key0(thread, JSTaggedValue(0));
1553 PropertyDescriptor desc0(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(1)), true, true, true);
1554 JSArray::DefineOwnProperty(thread, obj1, key0, desc0);
1555
1556 JSArray *arr2 = JSArray::Cast(JSArray::ArrayCreate(thread, JSTaggedNumber(0)).GetTaggedValue().GetTaggedObject());
1557 EXPECT_TRUE(arr2 != nullptr);
1558 JSHandle<JSObject> obj2(thread, arr2);
1559 EXPECT_EQ(JSArray::GetProperty(thread, JSHandle<JSTaggedValue>(obj2), lengthKeyHandle).GetValue()->GetInt(), 0);
1560
1561 PropertyDescriptor desc1(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(2)), true, true, true);
1562 JSArray::DefineOwnProperty(thread, obj2, key0, desc1);
1563
1564 JSHandle<JSTaggedValue> key1(thread, JSTaggedValue(1));
1565 PropertyDescriptor desc2(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(3)), true, true, true);
1566 JSArray::DefineOwnProperty(thread, obj2, key1, desc2);
1567
1568 PropertyDescriptor desc3(thread, JSHandle<JSTaggedValue>(thread, obj2.GetTaggedValue()), true, true, true);
1569 JSArray::DefineOwnProperty(thread, obj1, key1, desc3);
1570
1571 auto ecmaRuntimeCallInfo1 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 4);
1572 ecmaRuntimeCallInfo1->SetFunction(JSTaggedValue::Undefined());
1573 ecmaRuntimeCallInfo1->SetThis(obj1.GetTaggedValue());
1574 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo1);
1575 JSTaggedValue result = Array::Flat(ecmaRuntimeCallInfo1);
1576 TestHelper::TearDownFrame(thread, prev);
1577 JSTaggedValue value(static_cast<JSTaggedType>(result.GetRawData()));
1578 ASSERT_TRUE(value.IsECMAObject());
1579 PropertyDescriptor descRes(thread);
1580 JSHandle<JSObject> valueHandle(thread, value);
1581 JSObject::GetOwnProperty(thread, valueHandle, key0, descRes);
1582 ASSERT_EQ(descRes.GetValue().GetTaggedValue(), JSTaggedValue(1));
1583 JSObject::GetOwnProperty(thread, valueHandle, key1, descRes);
1584 ASSERT_EQ(descRes.GetValue().GetTaggedValue(), JSTaggedValue(2));
1585 JSHandle<JSTaggedValue> key2(thread, JSTaggedValue(2));
1586 JSObject::GetOwnProperty(thread, valueHandle, key2, descRes);
1587 ASSERT_EQ(descRes.GetValue().GetTaggedValue(), JSTaggedValue(3));
1588 }
1589
1590 // es12 23.1.3.10 new Array(1,50,3]).flatMap(x => [x * 2])
HWTEST_F_L0(BuiltinsArrayTest,FlatMap)1591 HWTEST_F_L0(BuiltinsArrayTest, FlatMap)
1592 {
1593 auto ecmaVM = thread->GetEcmaVM();
1594 JSHandle<GlobalEnv> env = ecmaVM->GetGlobalEnv();
1595 ObjectFactory *factory = ecmaVM->GetFactory();
1596
1597 JSHandle<JSTaggedValue> lengthKeyHandle = thread->GlobalConstants()->GetHandledLengthString();
1598 JSArray *arr = JSArray::Cast(JSArray::ArrayCreate(thread, JSTaggedNumber(0)).GetTaggedValue().GetTaggedObject());
1599 EXPECT_TRUE(arr != nullptr);
1600 JSHandle<JSObject> obj(thread, arr);
1601 EXPECT_EQ(JSArray::GetProperty(thread, JSHandle<JSTaggedValue>(obj), lengthKeyHandle).GetValue()->GetInt(), 0);
1602 JSHandle<JSTaggedValue> key0(thread, JSTaggedValue(0));
1603 PropertyDescriptor desc0(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(1)), true, true, true);
1604 JSArray::DefineOwnProperty(thread, obj, key0, desc0);
1605 JSHandle<JSTaggedValue> key1(thread, JSTaggedValue(1));
1606 PropertyDescriptor desc1(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(50)), true, true, true);
1607 JSArray::DefineOwnProperty(thread, obj, key1, desc1);
1608 JSHandle<JSTaggedValue> key2(thread, JSTaggedValue(2));
1609 PropertyDescriptor desc2(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(3)), true, true, true);
1610 JSArray::DefineOwnProperty(thread, obj, key2, desc2);
1611 JSHandle<JSArray> jsArray(JSArray::ArrayCreate(thread, JSTaggedNumber(0)));
1612 JSHandle<JSFunction> func = factory->NewJSFunction(env, reinterpret_cast<void *>(TestClass::TestFlatMapFunc));
1613
1614 auto ecmaRuntimeCallInfo1 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 8);
1615 ecmaRuntimeCallInfo1->SetFunction(JSTaggedValue::Undefined());
1616 ecmaRuntimeCallInfo1->SetThis(obj.GetTaggedValue());
1617 ecmaRuntimeCallInfo1->SetCallArg(0, func.GetTaggedValue());
1618 ecmaRuntimeCallInfo1->SetCallArg(1, jsArray.GetTaggedValue());
1619
1620 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo1);
1621 JSTaggedValue result = Array::FlatMap(ecmaRuntimeCallInfo1);
1622 TestHelper::TearDownFrame(thread, prev);
1623 JSTaggedValue value(static_cast<JSTaggedType>(result.GetRawData()));
1624 ASSERT_TRUE(value.IsECMAObject());
1625
1626 PropertyDescriptor descRes(thread);
1627 JSHandle<JSObject> valueHandle(thread, value);
1628 EXPECT_EQ(
1629 JSArray::GetProperty(thread, JSHandle<JSTaggedValue>(valueHandle), lengthKeyHandle).GetValue()->GetInt(), 3);
1630 JSObject::GetOwnProperty(thread, valueHandle, key0, descRes);
1631
1632 ASSERT_EQ(descRes.GetValue()->GetInt(), 2);
1633 JSObject::GetOwnProperty(thread, valueHandle, key1, descRes);
1634 ASSERT_EQ(descRes.GetValue()->GetInt(), 100);
1635 JSObject::GetOwnProperty(thread, valueHandle, key2, descRes);
1636 ASSERT_EQ(descRes.GetValue()->GetInt(), 6);
1637 }
1638 } // namespace panda::test
1639