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