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(0)) \
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(), 0);
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(20)) \
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(), 20);
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, DefineOwnProperty_Array)834 HWTEST_F_L0(BuiltinsSharedArrayTest, DefineOwnProperty_Array)
835 {
836 JSArray *arr = JSArray::Cast(JSArray::ArrayCreate(thread, JSTaggedNumber(0)) \
837 .GetTaggedValue().GetTaggedObject());
838 EXPECT_TRUE(arr != nullptr);
839 JSHandle<JSObject> obj(thread, arr);
840
841 JSHandle<JSTaggedValue> key0(thread, JSTaggedValue(0));
842 PropertyDescriptor desc0(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(arr)), true, true, true);
843 bool res = JSSharedArray::DefineOwnProperty(thread, obj, key0, desc0, SCheckMode::SKIP);
844 ASSERT_TRUE(!res);
845 }
846
HWTEST_F_L0(BuiltinsSharedArrayTest, Reduce)847 HWTEST_F_L0(BuiltinsSharedArrayTest, Reduce)
848 {
849 auto ecmaVM = thread->GetEcmaVM();
850 JSHandle<GlobalEnv> env = ecmaVM->GetGlobalEnv();
851 ObjectFactory *factory = ecmaVM->GetFactory();
852
853 JSHandle<JSTaggedValue> lengthKeyHandle = thread->GlobalConstants()->GetHandledLengthString();
854 JSSharedArray *arr = JSSharedArray::Cast(JSSharedArray::ArrayCreate(thread, JSTaggedNumber(0)) \
855 .GetTaggedValue().GetTaggedObject());
856 EXPECT_TRUE(arr != nullptr);
857 JSHandle<JSObject> obj(thread, arr);
858 EXPECT_EQ(JSSharedArray::GetProperty(thread, JSHandle<JSTaggedValue>(obj), lengthKeyHandle, SCheckMode::SKIP) \
859 .GetValue()->GetInt(), 0);
860
861 std::vector<int> descVals{1, 2, 3};
862 auto keys = SharedArrayDefineOwnPropertyTest(thread, obj, descVals);
863
864 JSHandle<JSFunction> func = factory->NewJSFunction(env, reinterpret_cast<void *>(TestClass::TestReduceFunc));
865
866 auto ecmaRuntimeCallInfo1 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 8);
867 ecmaRuntimeCallInfo1->SetFunction(JSTaggedValue::Undefined());
868 ecmaRuntimeCallInfo1->SetThis(obj.GetTaggedValue());
869 ecmaRuntimeCallInfo1->SetCallArg(0, func.GetTaggedValue());
870 ecmaRuntimeCallInfo1->SetCallArg(1, JSTaggedValue(static_cast<int32_t>(10)));
871
872 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo1);
873 JSTaggedValue result = Array::Reduce(ecmaRuntimeCallInfo1);
874 TestHelper::TearDownFrame(thread, prev);
875 ASSERT_EQ(result.GetRawData(), JSTaggedValue(16).GetRawData());
876 }
877
HWTEST_F_L0(BuiltinsSharedArrayTest, Shift)878 HWTEST_F_L0(BuiltinsSharedArrayTest, Shift)
879 {
880 JSHandle<JSTaggedValue> lengthKeyHandle = thread->GlobalConstants()->GetHandledLengthString();
881 JSSharedArray *arr = JSSharedArray::Cast(JSSharedArray::ArrayCreate(thread, JSTaggedNumber(0)) \
882 .GetTaggedValue().GetTaggedObject());
883 EXPECT_TRUE(arr != nullptr);
884 JSHandle<JSObject> obj(thread, arr);
885 EXPECT_EQ(JSSharedArray::GetProperty(thread, JSHandle<JSTaggedValue>(obj), lengthKeyHandle, SCheckMode::SKIP) \
886 .GetValue()->GetInt(), 0);
887
888 std::vector<int> descVals{1, 2, 3};
889 auto keys = SharedArrayDefineOwnPropertyTest(thread, obj, descVals);
890
891 auto ecmaRuntimeCallInfo1 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 4);
892 ecmaRuntimeCallInfo1->SetFunction(JSTaggedValue::Undefined());
893 ecmaRuntimeCallInfo1->SetThis(obj.GetTaggedValue());
894
895 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo1);
896 JSTaggedValue result = Array::Shift(ecmaRuntimeCallInfo1);
897 TestHelper::TearDownFrame(thread, prev);
898 ASSERT_EQ(result.GetRawData(), JSTaggedValue(1).GetRawData());
899 }
900
HWTEST_F_L0(BuiltinsSharedArrayTest, Sort)901 HWTEST_F_L0(BuiltinsSharedArrayTest, Sort)
902 {
903 JSHandle<JSTaggedValue> lengthKeyHandle = thread->GlobalConstants()->GetHandledLengthString();
904 JSSharedArray *arr = JSSharedArray::Cast(JSSharedArray::ArrayCreate(thread, JSTaggedNumber(0)) \
905 .GetTaggedValue().GetTaggedObject());
906 EXPECT_TRUE(arr != nullptr);
907 JSHandle<JSObject> obj(thread, arr);
908 EXPECT_EQ(JSSharedArray::GetProperty(thread, JSHandle<JSTaggedValue>(obj), lengthKeyHandle, SCheckMode::SKIP) \
909 .GetValue()->GetInt(), 0);
910
911 std::vector<int> descVals{3, 2, 1};
912 auto keys = SharedArrayDefineOwnPropertyTest(thread, obj, descVals);
913
914 auto ecmaRuntimeCallInfo1 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 4);
915 ecmaRuntimeCallInfo1->SetFunction(JSTaggedValue::Undefined());
916 ecmaRuntimeCallInfo1->SetThis(obj.GetTaggedValue());
917
918 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo1);
919 JSTaggedValue result2 = Array::Sort(ecmaRuntimeCallInfo1);
920 TestHelper::TearDownFrame(thread, prev);
921
922 EXPECT_TRUE(result2.IsECMAObject());
923 JSHandle<JSTaggedValue> resultArr =
924 JSHandle<JSTaggedValue>(thread, JSTaggedValue(static_cast<JSTaggedType>(result2.GetRawData())));
925 EXPECT_EQ(JSSharedArray::GetProperty(thread, resultArr, keys[0], SCheckMode::SKIP).GetValue()->GetInt(), 1);
926 EXPECT_EQ(JSSharedArray::GetProperty(thread, resultArr, keys[1], SCheckMode::SKIP).GetValue()->GetInt(), 2);
927 EXPECT_EQ(JSSharedArray::GetProperty(thread, resultArr, keys[2], SCheckMode::SKIP).GetValue()->GetInt(), 3);
928 }
929
HWTEST_F_L0(BuiltinsSharedArrayTest, Sort_Exception)930 HWTEST_F_L0(BuiltinsSharedArrayTest, Sort_Exception)
931 {
932 JSHandle<JSTaggedValue> lengthKeyHandle = thread->GlobalConstants()->GetHandledLengthString();
933 JSSharedArray *arr = JSSharedArray::Cast(JSSharedArray::ArrayCreate(thread, JSTaggedNumber(0)) \
934 .GetTaggedValue().GetTaggedObject());
935 EXPECT_TRUE(arr != nullptr);
936 JSHandle<JSObject> obj(thread, arr);
937 EXPECT_EQ(JSSharedArray::GetProperty(thread, JSHandle<JSTaggedValue>(obj), lengthKeyHandle, SCheckMode::SKIP) \
938 .GetValue()->GetInt(), 0);
939
940 auto ecmaRuntimeCallInfo1 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 4);
941 ecmaRuntimeCallInfo1->SetFunction(JSTaggedValue::Undefined());
942 ecmaRuntimeCallInfo1->SetThis(obj.GetTaggedValue());
943
944 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo1);
945 JSTaggedValue result2 = Array::Sort(ecmaRuntimeCallInfo1);
946 TestHelper::TearDownFrame(thread, prev);
947
948 EXPECT_TRUE(result2.IsECMAObject());
949 }
950
HWTEST_F_L0(BuiltinsSharedArrayTest, Sort_Exception_1)951 HWTEST_F_L0(BuiltinsSharedArrayTest, Sort_Exception_1)
952 {
953 JSHandle<JSTaggedValue> lengthKeyHandle = thread->GlobalConstants()->GetHandledLengthString();
954 JSSharedArray *arr = JSSharedArray::Cast(JSSharedArray::ArrayCreate(thread, JSTaggedNumber(1)) \
955 .GetTaggedValue().GetTaggedObject());
956 EXPECT_TRUE(arr != nullptr);
957 JSHandle<JSObject> obj(thread, arr);
958 EXPECT_EQ(JSSharedArray::GetProperty(thread, JSHandle<JSTaggedValue>(obj), lengthKeyHandle, SCheckMode::SKIP) \
959 .GetValue()->GetInt(), 1);
960
961 auto ecmaRuntimeCallInfo1 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 4);
962 ecmaRuntimeCallInfo1->SetFunction(JSTaggedValue::Undefined());
963 ecmaRuntimeCallInfo1->SetThis(obj.GetTaggedValue());
964
965 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo1);
966 JSTaggedValue result2 = Array::Sort(ecmaRuntimeCallInfo1);
967 TestHelper::TearDownFrame(thread, prev);
968
969 EXPECT_TRUE(result2.IsECMAObject());
970 }
971
HWTEST_F_L0(BuiltinsSharedArrayTest, Unshift)972 HWTEST_F_L0(BuiltinsSharedArrayTest, Unshift)
973 {
974 JSHandle<JSTaggedValue> lengthKeyHandle = thread->GlobalConstants()->GetHandledLengthString();
975 JSSharedArray *arr = JSSharedArray::Cast(JSSharedArray::ArrayCreate(thread, JSTaggedNumber(0)) \
976 .GetTaggedValue().GetTaggedObject());
977 EXPECT_TRUE(arr != nullptr);
978 JSHandle<JSObject> obj(thread, arr);
979 EXPECT_EQ(JSSharedArray::GetProperty(thread, JSHandle<JSTaggedValue>(obj), lengthKeyHandle, SCheckMode::SKIP) \
980 .GetValue()->GetInt(), 0);
981
982 std::vector<int> descVals{1, 2, 3};
983 auto keys = SharedArrayDefineOwnPropertyTest(thread, obj, descVals);
984
985 auto ecmaRuntimeCallInfo1 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 8);
986 ecmaRuntimeCallInfo1->SetFunction(JSTaggedValue::Undefined());
987 ecmaRuntimeCallInfo1->SetThis(obj.GetTaggedValue());
988 ecmaRuntimeCallInfo1->SetCallArg(0, JSTaggedValue(static_cast<int32_t>(4)));
989 ecmaRuntimeCallInfo1->SetCallArg(1, JSTaggedValue(static_cast<int32_t>(5)));
990
991 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo1);
992 JSTaggedValue result = Array::Unshift(ecmaRuntimeCallInfo1);
993 TestHelper::TearDownFrame(thread, prev);
994
995 ASSERT_EQ(result.GetRawData(), JSTaggedValue(static_cast<double>(5)).GetRawData());
996
997 EXPECT_EQ(JSSharedArray::GetProperty(thread, JSHandle<JSTaggedValue>(obj), lengthKeyHandle, SCheckMode::SKIP) \
998 .GetValue()->GetInt(), 5);
999 JSHandle<JSTaggedValue> key3(thread, JSTaggedValue(0));
1000 EXPECT_EQ(JSSharedArray::GetProperty(thread, JSHandle<JSTaggedValue>(obj), key3, SCheckMode::SKIP) \
1001 .GetValue()->GetInt(), 4);
1002 JSHandle<JSTaggedValue> key4(thread, JSTaggedValue(1));
1003 EXPECT_EQ(JSSharedArray::GetProperty(thread, JSHandle<JSTaggedValue>(obj), key4, SCheckMode::SKIP) \
1004 .GetValue()->GetInt(), 5);
1005 }
1006
HWTEST_F_L0(BuiltinsSharedArrayTest, Join)1007 HWTEST_F_L0(BuiltinsSharedArrayTest, Join)
1008 {
1009 JSHandle<JSTaggedValue> lengthKeyHandle = thread->GlobalConstants()->GetHandledLengthString();
1010 JSSharedArray *arr = JSSharedArray::Cast(JSSharedArray::ArrayCreate(thread, JSTaggedNumber(0)) \
1011 .GetTaggedValue().GetTaggedObject());
1012 EXPECT_TRUE(arr != nullptr);
1013 JSHandle<JSTaggedValue> obj(thread, arr);
1014 EXPECT_EQ(JSSharedArray::GetProperty(thread, obj, lengthKeyHandle, SCheckMode::SKIP).GetValue()->GetInt(), 0);
1015
1016 std::vector<int> descVals{2, 3, 4};
1017 auto keys = SharedArrayDefineOwnPropertyTest(thread, obj, descVals);
1018
1019 JSHandle<EcmaString> str = thread->GetEcmaVM()->GetFactory()->NewFromASCII("2,3,4");
1020 auto ecmaRuntimeCallInfo1 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 4);
1021 ecmaRuntimeCallInfo1->SetFunction(JSTaggedValue::Undefined());
1022 ecmaRuntimeCallInfo1->SetThis(obj.GetTaggedValue());
1023
1024 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo1);
1025 JSTaggedValue result = Array::Join(ecmaRuntimeCallInfo1);
1026 TestHelper::TearDownFrame(thread, prev);
1027 JSHandle<EcmaString> resultHandle(thread, reinterpret_cast<EcmaString *>(result.GetRawData()));
1028
1029 ASSERT_EQ(EcmaStringAccessor::Compare(instance, resultHandle, str), 0);
1030 }
1031
HWTEST_F_L0(BuiltinsSharedArrayTest, ToString)1032 HWTEST_F_L0(BuiltinsSharedArrayTest, ToString)
1033 {
1034 std::vector<int> descVals{2, 3, 4};
1035 JSHandle<JSTaggedValue> lengthKeyHandle = thread->GlobalConstants()->GetHandledLengthString();
1036 JSSharedArray *arr = JSSharedArray::Cast(JSSharedArray::ArrayCreate(thread, JSTaggedNumber(0)) \
1037 .GetTaggedValue().GetTaggedObject());
1038 EXPECT_TRUE(arr != nullptr);
1039 JSHandle<JSTaggedValue> obj(thread, arr);
1040 EXPECT_EQ(JSSharedArray::GetProperty(thread, obj, lengthKeyHandle, SCheckMode::SKIP).GetValue()->GetInt(), 0);
1041 auto keys = SharedArrayDefineOwnPropertyTest(thread, obj, descVals);
1042
1043 JSHandle<EcmaString> str = thread->GetEcmaVM()->GetFactory()->NewFromASCII("2,3,4");
1044 auto ecmaRuntimeCallInfo1 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 4);
1045 ecmaRuntimeCallInfo1->SetFunction(JSTaggedValue::Undefined());
1046 ecmaRuntimeCallInfo1->SetThis(obj.GetTaggedValue());
1047
1048 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo1);
1049 JSTaggedValue result = Array::ToString(ecmaRuntimeCallInfo1);
1050 TestHelper::TearDownFrame(thread, prev);
1051 JSHandle<EcmaString> resultHandle(thread, reinterpret_cast<EcmaString *>(result.GetRawData()));
1052
1053 ASSERT_EQ(EcmaStringAccessor::Compare(instance, resultHandle, str), 0);
1054 }
1055
HWTEST_F_L0(BuiltinsSharedArrayTest, Includes_one)1056 HWTEST_F_L0(BuiltinsSharedArrayTest, Includes_one)
1057 {
1058 JSHandle<JSTaggedValue> lengthKeyHandle = thread->GlobalConstants()->GetHandledLengthString();
1059 JSSharedArray *arr = JSSharedArray::Cast(JSSharedArray::ArrayCreate(thread, JSTaggedNumber(0)) \
1060 .GetTaggedValue().GetTaggedObject());
1061 EXPECT_TRUE(arr != nullptr);
1062 JSHandle<JSTaggedValue> obj(thread, arr);
1063 std::vector<int> descVals{2, 3, 4};
1064 EXPECT_EQ(JSSharedArray::GetProperty(thread, obj, lengthKeyHandle, SCheckMode::SKIP).GetValue()->GetInt(), 0);
1065 auto keys = SharedArrayDefineOwnPropertyTest(thread, obj, descVals);
1066
1067 auto ecmaRuntimeCallInfo1 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 6);
1068 ecmaRuntimeCallInfo1->SetFunction(JSTaggedValue::Undefined());
1069 ecmaRuntimeCallInfo1->SetThis(obj.GetTaggedValue());
1070 ecmaRuntimeCallInfo1->SetCallArg(0, JSTaggedValue(static_cast<int32_t>(2)));
1071
1072 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo1);
1073 [[maybe_unused]] JSTaggedValue result = Array::Includes(ecmaRuntimeCallInfo1);
1074 TestHelper::TearDownFrame(thread, prev);
1075
1076 ASSERT_TRUE(result.JSTaggedValue::ToBoolean()); // new Int8Array[2,3,4].includes(2)
1077
1078 auto ecmaRuntimeCallInfo2 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 6);
1079 ecmaRuntimeCallInfo2->SetFunction(JSTaggedValue::Undefined());
1080 ecmaRuntimeCallInfo2->SetThis(obj.GetTaggedValue());
1081 ecmaRuntimeCallInfo2->SetCallArg(0, JSTaggedValue(static_cast<int32_t>(1)));
1082
1083 prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo2);
1084 result = Array::Includes(ecmaRuntimeCallInfo2);
1085 TestHelper::TearDownFrame(thread, prev);
1086
1087 ASSERT_TRUE(!result.JSTaggedValue::ToBoolean()); // new Int8Array[2,3,4].includes(1)
1088
1089 auto ecmaRuntimeCallInfo3 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 8);
1090 ecmaRuntimeCallInfo3->SetFunction(JSTaggedValue::Undefined());
1091 ecmaRuntimeCallInfo3->SetThis(obj.GetTaggedValue());
1092 ecmaRuntimeCallInfo3->SetCallArg(0, JSTaggedValue(static_cast<int32_t>(3)));
1093 ecmaRuntimeCallInfo3->SetCallArg(1, JSTaggedValue(static_cast<int32_t>(1)));
1094
1095 prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo3);
1096 result = Array::Includes(ecmaRuntimeCallInfo3);
1097 TestHelper::TearDownFrame(thread, prev);
1098
1099 ASSERT_TRUE(result.JSTaggedValue::ToBoolean()); // new Int8Array[2,3,4].includes(3, 1)
1100 }
1101
HWTEST_F_L0(BuiltinsSharedArrayTest, Includes_two)1102 HWTEST_F_L0(BuiltinsSharedArrayTest, Includes_two)
1103 {
1104 JSHandle<JSTaggedValue> lengthKeyHandle = thread->GlobalConstants()->GetHandledLengthString();
1105 JSSharedArray *arr = JSSharedArray::Cast(JSSharedArray::ArrayCreate(thread, JSTaggedNumber(0)) \
1106 .GetTaggedValue().GetTaggedObject());
1107 EXPECT_TRUE(arr != nullptr);
1108 JSHandle<JSTaggedValue> obj(thread, arr);
1109 std::vector<int> descVals{2, 3, 4};
1110 EXPECT_EQ(JSSharedArray::GetProperty(thread, obj, lengthKeyHandle, SCheckMode::SKIP).GetValue()->GetInt(), 0);
1111 auto keys = SharedArrayDefineOwnPropertyTest(thread, obj, descVals);
1112
1113 auto ecmaRuntimeCallInfo4 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 8);
1114 ecmaRuntimeCallInfo4->SetFunction(JSTaggedValue::Undefined());
1115 ecmaRuntimeCallInfo4->SetThis(obj.GetTaggedValue());
1116 ecmaRuntimeCallInfo4->SetCallArg(0, JSTaggedValue(static_cast<int32_t>(2)));
1117 ecmaRuntimeCallInfo4->SetCallArg(1, JSTaggedValue(static_cast<int32_t>(5)));
1118
1119 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo4);
1120 [[maybe_unused]] JSTaggedValue result = Array::Includes(ecmaRuntimeCallInfo4);
1121 TestHelper::TearDownFrame(thread, prev);
1122
1123 ASSERT_TRUE(!result.JSTaggedValue::ToBoolean()); // new Int8Array[2,3,4].includes(2, 5)
1124
1125 auto ecmaRuntimeCallInfo5 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 8);
1126 ecmaRuntimeCallInfo5->SetFunction(JSTaggedValue::Undefined());
1127 ecmaRuntimeCallInfo5->SetThis(obj.GetTaggedValue());
1128 ecmaRuntimeCallInfo5->SetCallArg(0, JSTaggedValue(static_cast<int32_t>(2)));
1129 ecmaRuntimeCallInfo5->SetCallArg(1, JSTaggedValue(static_cast<int32_t>(-2)));
1130
1131 prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo5);
1132 result = Array::Includes(ecmaRuntimeCallInfo5);
1133 TestHelper::TearDownFrame(thread, prev);
1134
1135 ASSERT_TRUE(!result.JSTaggedValue::ToBoolean()); // new Int8Array[2,3,4].includes(2, -2)
1136 }
1137
HWTEST_F_L0(BuiltinsSharedArrayTest, At_ONE)1138 HWTEST_F_L0(BuiltinsSharedArrayTest, At_ONE)
1139 {
1140 JSHandle<JSTaggedValue> lengthKeyHandle = thread->GlobalConstants()->GetHandledLengthString();
1141 JSSharedArray *arr = JSSharedArray::Cast(JSSharedArray::ArrayCreate(thread, JSTaggedNumber(0)) \
1142 .GetTaggedValue().GetTaggedObject());
1143 EXPECT_TRUE(arr != nullptr);
1144 std::vector<int> descVals{2, 3, 4};
1145 JSHandle<JSTaggedValue> obj(thread, arr);
1146 EXPECT_EQ(JSSharedArray::GetProperty(thread, obj, lengthKeyHandle, SCheckMode::SKIP).GetValue()->GetInt(), 0);
1147
1148 auto keys = SharedArrayDefineOwnPropertyTest(thread, obj, descVals);
1149
1150 auto ecmaRuntimeCallInfo1 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 6);
1151 ecmaRuntimeCallInfo1->SetFunction(JSTaggedValue::Undefined());
1152 ecmaRuntimeCallInfo1->SetThis(obj.GetTaggedValue());
1153 ecmaRuntimeCallInfo1->SetCallArg(0, JSTaggedValue(static_cast<int32_t>(0)));
1154 [[maybe_unused]] auto prev1 = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo1);
1155 JSTaggedValue result = Array::At(ecmaRuntimeCallInfo1);
1156 TestHelper::TearDownFrame(thread, prev1);
1157 ASSERT_EQ(result.GetRawData(), JSTaggedValue(2).GetRawData());
1158
1159 auto ecmaRuntimeCallInfo2 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 6);
1160 ecmaRuntimeCallInfo2->SetFunction(JSTaggedValue::Undefined());
1161 ecmaRuntimeCallInfo2->SetThis(obj.GetTaggedValue());
1162 ecmaRuntimeCallInfo2->SetCallArg(0, JSTaggedValue(static_cast<int32_t>(2)));
1163 [[maybe_unused]] auto prev2 = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo2);
1164 result = Array::At(ecmaRuntimeCallInfo2);
1165 TestHelper::TearDownFrame(thread, prev2);
1166 ASSERT_EQ(result.GetRawData(), JSTaggedValue(4).GetRawData());
1167
1168 auto ecmaRuntimeCallInfo3 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 6);
1169 ecmaRuntimeCallInfo3->SetFunction(JSTaggedValue::Undefined());
1170 ecmaRuntimeCallInfo3->SetThis(obj.GetTaggedValue());
1171 ecmaRuntimeCallInfo3->SetCallArg(0, JSTaggedValue(static_cast<int32_t>(3)));
1172 [[maybe_unused]] auto prev3 = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo3);
1173 result = Array::At(ecmaRuntimeCallInfo3);
1174 TestHelper::TearDownFrame(thread, prev3);
1175 ASSERT_EQ(result, JSTaggedValue::Undefined());
1176 }
1177
HWTEST_F_L0(BuiltinsSharedArrayTest, At_TWO)1178 HWTEST_F_L0(BuiltinsSharedArrayTest, At_TWO)
1179 {
1180 JSHandle<JSTaggedValue> lengthKeyHandle = thread->GlobalConstants()->GetHandledLengthString();
1181 JSSharedArray *arr = JSSharedArray::Cast(JSSharedArray::ArrayCreate(thread, JSTaggedNumber(0)) \
1182 .GetTaggedValue().GetTaggedObject());
1183 EXPECT_TRUE(arr != nullptr);
1184 std::vector<int> descVals{2, 3, 4};
1185 JSHandle<JSTaggedValue> obj(thread, arr);
1186 EXPECT_EQ(JSSharedArray::GetProperty(thread, obj, lengthKeyHandle, SCheckMode::SKIP).GetValue()->GetInt(), 0);
1187
1188 auto keys = SharedArrayDefineOwnPropertyTest(thread, obj, descVals);
1189
1190 auto ecmaRuntimeCallInfo4 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 6);
1191 ecmaRuntimeCallInfo4->SetFunction(JSTaggedValue::Undefined());
1192 ecmaRuntimeCallInfo4->SetThis(obj.GetTaggedValue());
1193 ecmaRuntimeCallInfo4->SetCallArg(0, JSTaggedValue(static_cast<int32_t>(-1)));
1194 [[maybe_unused]] auto prev4 = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo4);
1195 JSTaggedValue result = Array::At(ecmaRuntimeCallInfo4);
1196 TestHelper::TearDownFrame(thread, prev4);
1197 ASSERT_EQ(result.GetRawData(), JSTaggedValue(4).GetRawData());
1198
1199 auto ecmaRuntimeCallInfo5 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 6);
1200 ecmaRuntimeCallInfo5->SetFunction(JSTaggedValue::Undefined());
1201 ecmaRuntimeCallInfo5->SetThis(obj.GetTaggedValue());
1202 ecmaRuntimeCallInfo5->SetCallArg(0, JSTaggedValue(static_cast<int32_t>(-3)));
1203 [[maybe_unused]] auto prev5 = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo5);
1204 result = Array::At(ecmaRuntimeCallInfo5);
1205 TestHelper::TearDownFrame(thread, prev5);
1206 ASSERT_EQ(result.GetRawData(), JSTaggedValue(2).GetRawData());
1207
1208 auto ecmaRuntimeCallInfo6 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 6);
1209 ecmaRuntimeCallInfo6->SetFunction(JSTaggedValue::Undefined());
1210 ecmaRuntimeCallInfo6->SetThis(obj.GetTaggedValue());
1211 ecmaRuntimeCallInfo6->SetCallArg(0, JSTaggedValue(static_cast<int32_t>(-4)));
1212 [[maybe_unused]] auto prev6 = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo6);
1213 result = Array::At(ecmaRuntimeCallInfo6);
1214 TestHelper::TearDownFrame(thread, prev6);
1215 ASSERT_EQ(result, JSTaggedValue::Undefined());
1216 }
1217
HWTEST_F_L0(BuiltinsSharedArrayTest, Create1)1218 HWTEST_F_L0(BuiltinsSharedArrayTest, Create1)
1219 {
1220 static int32_t len = 3;
1221 JSSharedArray *arr = JSSharedArray::Cast(JSSharedArray::ArrayCreate(thread, JSTaggedNumber(0))->GetTaggedObject());
1222 EXPECT_TRUE(arr != nullptr);
1223 JSHandle<JSObject> obj(thread, arr);
1224 JSHandle<JSTaggedValue> lengthKeyHandle = thread->GlobalConstants()->GetHandledLengthString();
1225 EXPECT_EQ(JSSharedArray::GetProperty(thread, JSHandle<JSTaggedValue>(obj), lengthKeyHandle, SCheckMode::SKIP) \
1226 .GetValue()->GetInt(), 0);
1227
1228 JSHandle<JSFunction> array(thread->GetEcmaVM()->GetGlobalEnv()->GetSharedArrayFunction());
1229 auto ecmaRuntimeCallInfo1 = TestHelper::CreateEcmaRuntimeCallInfo(thread, array.GetTaggedValue(), 8);
1230 ecmaRuntimeCallInfo1->SetFunction(array.GetTaggedValue());
1231 ecmaRuntimeCallInfo1->SetThis(JSTaggedValue::Undefined());
1232 ecmaRuntimeCallInfo1->SetCallArg(0, JSTaggedValue(len));
1233 ecmaRuntimeCallInfo1->SetCallArg(1, obj.GetTaggedValue());
1234
1235 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo1);
1236 JSTaggedValue result = Array::Create(ecmaRuntimeCallInfo1);
1237 TestHelper::TearDownFrame(thread, prev);
1238 ASSERT_TRUE(result.IsECMAObject());
1239 EXPECT_EQ(JSSharedArray::Cast(result.GetTaggedObject())->GetArrayLength(), len);
1240 }
1241
HWTEST_F_L0(BuiltinsSharedArrayTest, Create2)1242 HWTEST_F_L0(BuiltinsSharedArrayTest, Create2)
1243 {
1244 static double len = 100;
1245 JSSharedArray *arr = JSSharedArray::Cast(JSSharedArray::ArrayCreate(thread, JSTaggedNumber(0))->GetTaggedObject());
1246 EXPECT_TRUE(arr != nullptr);
1247 JSHandle<JSObject> obj(thread, arr);
1248 JSHandle<JSTaggedValue> lengthKeyHandle = thread->GlobalConstants()->GetHandledLengthString();
1249 EXPECT_EQ(JSSharedArray::GetProperty(thread, JSHandle<JSTaggedValue>(obj), lengthKeyHandle, SCheckMode::SKIP) \
1250 .GetValue()->GetInt(), 0);
1251
1252 JSHandle<JSFunction> array(thread->GetEcmaVM()->GetGlobalEnv()->GetSharedArrayFunction());
1253 auto ecmaRuntimeCallInfo1 = TestHelper::CreateEcmaRuntimeCallInfo(thread, array.GetTaggedValue(), 8);
1254 ecmaRuntimeCallInfo1->SetFunction(array.GetTaggedValue());
1255 ecmaRuntimeCallInfo1->SetThis(JSTaggedValue::Undefined());
1256 ecmaRuntimeCallInfo1->SetCallArg(0, JSTaggedValue(len));
1257 ecmaRuntimeCallInfo1->SetCallArg(1, obj.GetTaggedValue());
1258
1259 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo1);
1260 JSTaggedValue result = Array::Create(ecmaRuntimeCallInfo1);
1261 TestHelper::TearDownFrame(thread, prev);
1262 ASSERT_TRUE(result.IsECMAObject());
1263 EXPECT_EQ(JSSharedArray::Cast(result.GetTaggedObject())->GetArrayLength(), len);
1264 }
1265
1266 // Array.isArray(arg)
HWTEST_F_L0(BuiltinsSharedArrayTest, IsArray)1267 HWTEST_F_L0(BuiltinsSharedArrayTest, IsArray)
1268 {
1269 JSSharedArray *arr = JSSharedArray::Cast(JSSharedArray::ArrayCreate(thread, JSTaggedNumber(0))->GetTaggedObject());
1270 EXPECT_TRUE(arr != nullptr);
1271 JSHandle<JSObject> obj(thread, arr);
1272 JSHandle<JSTaggedValue> lengthKeyHandle = thread->GlobalConstants()->GetHandledLengthString();
1273 EXPECT_EQ(JSSharedArray::GetProperty(thread, JSHandle<JSTaggedValue>(obj), lengthKeyHandle, SCheckMode::SKIP)
1274 .GetValue()
1275 ->GetInt(),
1276 0);
1277
1278 auto ecmaRuntimeCallInfo1 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 6);
1279 ecmaRuntimeCallInfo1->SetFunction(JSTaggedValue::Undefined());
1280 ecmaRuntimeCallInfo1->SetThis(JSTaggedValue::Undefined());
1281 ecmaRuntimeCallInfo1->SetCallArg(0, obj.GetTaggedValue());
1282
1283 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo1);
1284 JSTaggedValue result = Array::IsArray(ecmaRuntimeCallInfo1);
1285 TestHelper::TearDownFrame(thread, prev);
1286 ASSERT_EQ(result.GetRawData(), JSTaggedValue::True().GetRawData());
1287
1288 auto ecmaRuntimeCallInfo2 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 6);
1289 ecmaRuntimeCallInfo2->SetFunction(JSTaggedValue::Undefined());
1290 ecmaRuntimeCallInfo2->SetThis(JSTaggedValue::Undefined());
1291 ecmaRuntimeCallInfo2->SetCallArg(0, JSTaggedValue(static_cast<int32_t>(1)));
1292
1293 prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo2);
1294 result = Array::IsArray(ecmaRuntimeCallInfo2);
1295 TestHelper::TearDownFrame(thread, prev);
1296 ASSERT_EQ(result.GetRawData(), JSTaggedValue::False().GetRawData());
1297 }
1298
HWTEST_F_L0(BuiltinsSharedArrayTest, GetIterator)1299 HWTEST_F_L0(BuiltinsSharedArrayTest, GetIterator)
1300 {
1301 JSSharedArray *arr = JSSharedArray::Cast(JSSharedArray::ArrayCreate(thread, JSTaggedNumber(0))->GetTaggedObject());
1302 EXPECT_TRUE(arr != nullptr);
1303 JSHandle<JSTaggedValue> obj(thread, arr);
1304
1305 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 4);
1306 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
1307 ecmaRuntimeCallInfo->SetThis(obj.GetTaggedValue());
1308 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo);
1309
1310 // test Values()
1311 JSTaggedValue result = Array::Values(ecmaRuntimeCallInfo);
1312 JSHandle<JSSharedArrayIterator> iter(thread, result);
1313 EXPECT_EQ(IterationKind::VALUE, iter->GetIterationKind());
1314
1315 // test Keys()
1316 JSTaggedValue result1 = Array::Keys(ecmaRuntimeCallInfo);
1317 JSHandle<JSArrayIterator> iter1(thread, result1);
1318 EXPECT_EQ(IterationKind::KEY, iter1->GetIterationKind());
1319
1320 // test entries()
1321 JSTaggedValue result2 = Array::Entries(ecmaRuntimeCallInfo);
1322 JSHandle<JSSharedArrayIterator> iter2(thread, result2);
1323 EXPECT_EQ(IterationKind::KEY_AND_VALUE, iter2->GetIterationKind());
1324 TestHelper::TearDownFrame(thread, prev);
1325 }
1326
1327
HWTEST_F_L0(BuiltinsSharedArrayTest, Unscopables)1328 HWTEST_F_L0(BuiltinsSharedArrayTest, Unscopables)
1329 {
1330 JSHandle<JSFunction> array(thread->GetEcmaVM()->GetGlobalEnv()->GetSharedArrayFunction());
1331 auto ecmaRuntimeCallInfo1 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 8);
1332 ecmaRuntimeCallInfo1->SetFunction(JSTaggedValue::Undefined());
1333 ecmaRuntimeCallInfo1->SetThis(JSTaggedValue::Undefined());
1334
1335 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo1);
1336 JSTaggedValue result = Array::Unscopables(ecmaRuntimeCallInfo1);
1337 TestHelper::TearDownFrame(thread, prev);
1338 JSTaggedValue value(static_cast<JSTaggedType>(result.GetRawData()));
1339 ASSERT_TRUE(value.IsECMAObject());
1340 }
1341
HWTEST_F_L0(BuiltinsSharedArrayTest, ShrinkTo1)1342 HWTEST_F_L0(BuiltinsSharedArrayTest, ShrinkTo1)
1343 {
1344 JSSharedArray *arr = JSSharedArray::Cast(JSSharedArray::ArrayCreate(thread, JSTaggedNumber(10))->GetTaggedObject());
1345 EXPECT_TRUE(arr != nullptr);
1346 JSHandle<JSObject> obj(thread, arr);
1347
1348 std::vector<int> descVals{1, 2, 3, 4, 5};
1349 auto keys = SharedArrayDefineOwnPropertyTest(thread, obj, descVals);
1350
1351 JSHandle<JSFunction> array(thread->GetEcmaVM()->GetGlobalEnv()->GetSharedArrayFunction());
1352 auto ecmaRuntimeCallInfo1 = TestHelper::CreateEcmaRuntimeCallInfo(thread, array.GetTaggedValue(), 6);
1353 ecmaRuntimeCallInfo1->SetFunction(array.GetTaggedValue());
1354 ecmaRuntimeCallInfo1->SetThis(obj.GetTaggedValue());
1355 ecmaRuntimeCallInfo1->SetCallArg(0, JSTaggedValue(static_cast<int32_t>(3)));
1356
1357 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo1);
1358 JSTaggedValue result = Array::ShrinkTo(ecmaRuntimeCallInfo1);
1359 EXPECT_EQ(result, JSTaggedValue::Undefined());
1360 EXPECT_EQ(arr->GetArrayLength(), 3U);
1361 TestHelper::TearDownFrame(thread, prev);
1362 }
1363
HWTEST_F_L0(BuiltinsSharedArrayTest, ShrinkTo2)1364 HWTEST_F_L0(BuiltinsSharedArrayTest, ShrinkTo2)
1365 {
1366 JSSharedArray *arr = JSSharedArray::Cast(JSSharedArray::ArrayCreate(thread, JSTaggedNumber(10))->GetTaggedObject());
1367 EXPECT_TRUE(arr != nullptr);
1368 JSHandle<JSObject> obj(thread, arr);
1369
1370 std::vector<int> descVals{1, 2, 3, 4, 5};
1371 auto keys = SharedArrayDefineOwnPropertyTest(thread, obj, descVals);
1372
1373 JSHandle<JSFunction> array(thread->GetEcmaVM()->GetGlobalEnv()->GetSharedArrayFunction());
1374 auto ecmaRuntimeCallInfo1 = TestHelper::CreateEcmaRuntimeCallInfo(thread, array.GetTaggedValue(), 6);
1375 ecmaRuntimeCallInfo1->SetFunction(array.GetTaggedValue());
1376 ecmaRuntimeCallInfo1->SetThis(obj.GetTaggedValue());
1377 ecmaRuntimeCallInfo1->SetCallArg(0, JSTaggedValue(static_cast<double>(3)));
1378
1379 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo1);
1380 JSTaggedValue result = Array::ShrinkTo(ecmaRuntimeCallInfo1);
1381 EXPECT_EQ(result, JSTaggedValue::Undefined());
1382 EXPECT_EQ(arr->GetArrayLength(), 3U);
1383 TestHelper::TearDownFrame(thread, prev);
1384 }
1385
HWTEST_F_L0(BuiltinsSharedArrayTest, ExtendTo1)1386 HWTEST_F_L0(BuiltinsSharedArrayTest, ExtendTo1)
1387 {
1388 JSSharedArray *arr = JSSharedArray::Cast(JSSharedArray::ArrayCreate(thread, JSTaggedNumber(0))->GetTaggedObject());
1389 EXPECT_TRUE(arr != nullptr);
1390 JSHandle<JSObject> obj(thread, arr);
1391
1392 JSHandle<JSFunction> array(thread->GetEcmaVM()->GetGlobalEnv()->GetSharedArrayFunction());
1393 auto ecmaRuntimeCallInfo1 = TestHelper::CreateEcmaRuntimeCallInfo(thread, array.GetTaggedValue(), 8);
1394 ecmaRuntimeCallInfo1->SetFunction(array.GetTaggedValue());
1395 ecmaRuntimeCallInfo1->SetThis(obj.GetTaggedValue());
1396 ecmaRuntimeCallInfo1->SetCallArg(0, JSTaggedValue(static_cast<int32_t>(3)));
1397 ecmaRuntimeCallInfo1->SetCallArg(1, obj.GetTaggedValue());
1398
1399 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo1);
1400 JSTaggedValue result = Array::ExtendTo(ecmaRuntimeCallInfo1);
1401 ASSERT_EQ(result, JSTaggedValue::Undefined());
1402 EXPECT_EQ(arr->GetArrayLength(), 3U);
1403 TestHelper::TearDownFrame(thread, prev);
1404 }
1405
HWTEST_F_L0(BuiltinsSharedArrayTest, ExtendTo2)1406 HWTEST_F_L0(BuiltinsSharedArrayTest, ExtendTo2)
1407 {
1408 JSSharedArray *arr = JSSharedArray::Cast(JSSharedArray::ArrayCreate(thread, JSTaggedNumber(0))->GetTaggedObject());
1409 EXPECT_TRUE(arr != nullptr);
1410 JSHandle<JSObject> obj(thread, arr);
1411
1412 JSHandle<JSFunction> array(thread->GetEcmaVM()->GetGlobalEnv()->GetSharedArrayFunction());
1413 auto ecmaRuntimeCallInfo1 = TestHelper::CreateEcmaRuntimeCallInfo(thread, array.GetTaggedValue(), 8);
1414 ecmaRuntimeCallInfo1->SetFunction(array.GetTaggedValue());
1415 ecmaRuntimeCallInfo1->SetThis(obj.GetTaggedValue());
1416 ecmaRuntimeCallInfo1->SetCallArg(0, JSTaggedValue(static_cast<double>(3)));
1417 ecmaRuntimeCallInfo1->SetCallArg(1, obj.GetTaggedValue());
1418
1419 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo1);
1420 JSTaggedValue result = Array::ExtendTo(ecmaRuntimeCallInfo1);
1421 ASSERT_EQ(result, JSTaggedValue::Undefined());
1422 EXPECT_EQ(arr->GetArrayLength(), 3U);
1423 TestHelper::TearDownFrame(thread, prev);
1424 }
1425
TestSharedArraySetProperty(EcmaRuntimeCallInfo *argv)1426 bool TestSharedArraySetProperty(EcmaRuntimeCallInfo *argv)
1427 {
1428 JSThread *thread = argv->GetThread();
1429 [[maybe_unused]] EcmaHandleScope handleScope(thread);
1430 JSHandle<JSTaggedValue> thisHandle = BuiltinsBase::GetThis(argv);
1431 if (!thisHandle->IsJSSharedArray()) {
1432 return false;
1433 }
1434
1435 JSHandle<JSTaggedValue> value = BuiltinsBase::GetCallArg(argv, 1);
1436 uint32_t key = static_cast<uint32_t>(BuiltinsBase::GetCallArg(argv, 0)->GetInt());
1437
1438 return JSSharedArray::SetProperty(thread, thisHandle, key, value, true, SCheckMode::CHECK);
1439 }
1440
HWTEST_F_L0(BuiltinsSharedArrayTest, SetPropertyTest001)1441 HWTEST_F_L0(BuiltinsSharedArrayTest, SetPropertyTest001)
1442 {
1443 JSSharedArray *arr = JSSharedArray::Cast(JSSharedArray::ArrayCreate(thread, JSTaggedNumber(5)) \
1444 .GetTaggedValue().GetTaggedObject());
1445 EXPECT_TRUE(arr != nullptr);
1446 JSHandle<JSTaggedValue> obj(thread, arr);
1447
1448 std::vector<int> descVals{2, 3, 4, 5, 7};
1449 auto keys = SharedArrayDefineOwnPropertyTest(thread, obj, descVals);
1450
1451
1452 JSHandle<JSFunction> array(thread->GetEcmaVM()->GetGlobalEnv()->GetSharedArrayFunction());
1453 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, array.GetTaggedValue(), 8);
1454 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
1455 ecmaRuntimeCallInfo->SetThis(obj.GetTaggedValue());
1456 ecmaRuntimeCallInfo->SetCallArg(0, JSTaggedValue(static_cast<int32_t>(0)));
1457 ecmaRuntimeCallInfo->SetCallArg(1, JSTaggedValue(static_cast<int32_t>(5)));
1458
1459 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo);
1460 ASSERT_EQ(true, TestSharedArraySetProperty(ecmaRuntimeCallInfo));
1461 TestHelper::TearDownFrame(thread, prev);
1462
1463 auto ecmaRuntimeCallInfo1 = TestHelper::CreateEcmaRuntimeCallInfo(thread, array.GetTaggedValue(), 8);
1464 ecmaRuntimeCallInfo1->SetFunction(JSTaggedValue::Undefined());
1465 ecmaRuntimeCallInfo1->SetThis(obj.GetTaggedValue());
1466 ecmaRuntimeCallInfo1->SetCallArg(0, JSTaggedValue(static_cast<int32_t>(10)));
1467 ecmaRuntimeCallInfo1->SetCallArg(1, JSTaggedValue(static_cast<int32_t>(5)));
1468
1469 [[maybe_unused]] auto prev1 = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo1);
1470 ASSERT_EQ(false, TestSharedArraySetProperty(ecmaRuntimeCallInfo1));
1471 TestHelper::TearDownFrame(thread, prev1);
1472 }
1473
HWTEST_F_L0(BuiltinsSharedArrayTest, IncludeInSortedValue)1474 HWTEST_F_L0(BuiltinsSharedArrayTest, IncludeInSortedValue)
1475 {
1476 auto ecmaVM = thread->GetEcmaVM();
1477 JSHandle<GlobalEnv> env = ecmaVM->GetGlobalEnv();
1478 ObjectFactory *factory = ecmaVM->GetFactory();
1479
1480 JSSharedArray *arr = JSSharedArray::Cast(JSSharedArray::ArrayCreate(thread, JSTaggedNumber(7)) \
1481 .GetTaggedValue().GetTaggedObject());
1482 EXPECT_TRUE(arr != nullptr);
1483 JSHandle<JSObject> obj(thread, arr);
1484
1485 std::vector<int> descVals{2, 3, 4, 5, 7, 500, 600};
1486 auto keys = SharedArrayDefineOwnPropertyTest(thread, obj, descVals);
1487
1488 JSHandle<JSFunction> func = factory->NewJSFunction(env, reinterpret_cast<void *>(TestClass::TestToSortedFunc));
1489 JSHandle<JSTaggedValue> funcValue(thread, func.GetTaggedValue());
1490
1491 auto objCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 0);
1492 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, objCallInfo);
1493
1494 JSHandle<JSTaggedValue> value(thread, JSTaggedValue(7));
1495 auto res = JSSharedArray::IncludeInSortedValue(thread, JSHandle<JSTaggedValue>(obj), value);
1496 ASSERT_TRUE(res);
1497 JSHandle<JSTaggedValue> value1(thread, JSTaggedValue(100));
1498 res = JSSharedArray::IncludeInSortedValue(thread, JSHandle<JSTaggedValue>(obj), value1);
1499 ASSERT_TRUE(!res);
1500 TestHelper::TearDownFrame(thread, prev);
1501 }
1502
HWTEST_F_L0(BuiltinsSharedArrayTest, IncludeInSortedValue_Len_0)1503 HWTEST_F_L0(BuiltinsSharedArrayTest, IncludeInSortedValue_Len_0)
1504 {
1505 JSSharedArray *arr = JSSharedArray::Cast(JSSharedArray::ArrayCreate(thread, JSTaggedNumber(0)) \
1506 .GetTaggedValue().GetTaggedObject());
1507 EXPECT_TRUE(arr != nullptr);
1508 JSHandle<JSObject> obj(thread, arr);
1509
1510 auto objCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 0);
1511 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, objCallInfo);
1512
1513 JSHandle<JSTaggedValue> value1(thread, JSTaggedValue(0));
1514 auto res = JSSharedArray::IncludeInSortedValue(thread, JSHandle<JSTaggedValue>(obj), value1);
1515 ASSERT_TRUE(!res);
1516 TestHelper::TearDownFrame(thread, prev);
1517 }
1518
1519
HWTEST_F_L0(BuiltinsSharedArrayTest, DefineProperty)1520 HWTEST_F_L0(BuiltinsSharedArrayTest, DefineProperty)
1521 {
1522 JSSharedArray *arr = JSSharedArray::Cast(JSSharedArray::ArrayCreate(thread, JSTaggedNumber(2))->GetTaggedObject());
1523 EXPECT_TRUE(arr != nullptr);
1524 JSHandle<JSObject> obj(thread, arr);
1525
1526 EcmaVM *ecmaVM = thread->GetEcmaVM();
1527 JSHandle<GlobalEnv> globalEnv = ecmaVM->GetGlobalEnv();
1528 JSHandle<JSTaggedValue> function(thread, globalEnv->GetObjectFunction().GetObject<JSFunction>());
1529
1530 JSHandle<JSFunction> objFunc(globalEnv->GetObjectFunction());
1531 JSHandle<JSObject> attHandle =
1532 ecmaVM->GetFactory()->NewJSObjectByConstructor(JSHandle<JSFunction>(function), function);
1533
1534 JSHandle<JSTaggedValue> key(thread, JSTaggedValue(1));
1535
1536 auto objCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 10);
1537 objCallInfo->SetFunction(JSTaggedValue::Undefined());
1538 objCallInfo->SetThis(JSTaggedValue::Undefined());
1539 objCallInfo->SetCallArg(0, obj.GetTaggedValue());
1540 objCallInfo->SetCallArg(1, key.GetTaggedValue());
1541 objCallInfo->SetCallArg(2, attHandle.GetTaggedValue());
1542
1543 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, objCallInfo);
1544 JSTaggedValue result = BuiltinsObject::DefineProperty(objCallInfo);
1545 TestHelper::TearDownFrame(thread, prev);
1546
1547 ASSERT_TRUE(result.IsECMAObject());
1548 EXPECT_EQ(arr->GetArrayLength(), 2U);
1549 }
1550
HWTEST_F_L0(BuiltinsSharedArrayTest, Some)1551 HWTEST_F_L0(BuiltinsSharedArrayTest, Some)
1552 {
1553 auto ecmaVM = thread->GetEcmaVM();
1554 JSHandle<GlobalEnv> env = ecmaVM->GetGlobalEnv();
1555 ObjectFactory *factory = ecmaVM->GetFactory();
1556
1557 JSHandle<JSTaggedValue> lengthKeyHandle = thread->GlobalConstants()->GetHandledLengthString();
1558 JSSharedArray *arr =
1559 JSSharedArray::Cast(JSSharedArray::ArrayCreate(thread, JSTaggedNumber(0)).GetTaggedValue().GetTaggedObject());
1560 EXPECT_TRUE(arr != nullptr);
1561 JSHandle<JSObject> obj(thread, arr);
1562 EXPECT_EQ(JSSharedArray::GetProperty(thread, JSHandle<JSTaggedValue>(obj), lengthKeyHandle,
1563 SCheckMode::SKIP).GetValue()->GetInt(), 0);
1564
1565 std::vector<int> descVals{1, 20, 3};
1566 auto keys = SharedArrayDefineOwnPropertyTest(thread, obj, descVals);
1567
1568 JSHandle<JSSharedArray> jsSharedArray(JSSharedArray::ArrayCreate(thread, JSTaggedNumber(0)));
1569 JSHandle<JSFunction> func = factory->NewJSFunction(env, reinterpret_cast<void *>(TestClass::TestSomeFunc));
1570
1571 auto ecmaRuntimeCallInfo1 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 8);
1572 ecmaRuntimeCallInfo1->SetFunction(JSTaggedValue::Undefined());
1573 ecmaRuntimeCallInfo1->SetThis(obj.GetTaggedValue());
1574 ecmaRuntimeCallInfo1->SetCallArg(0, func.GetTaggedValue());
1575 ecmaRuntimeCallInfo1->SetCallArg(1, jsSharedArray.GetTaggedValue());
1576
1577 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo1);
1578 JSTaggedValue result2 = Array::Some(ecmaRuntimeCallInfo1);
1579 TestHelper::TearDownFrame(thread, prev);
1580 ASSERT_EQ(result2.GetRawData(), JSTaggedValue::True().GetRawData());
1581 }
1582
HWTEST_F_L0(BuiltinsSharedArrayTest, CheckAndCopyArray)1583 HWTEST_F_L0(BuiltinsSharedArrayTest, CheckAndCopyArray)
1584 {
1585 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
1586 JSHandle<TaggedArray> array(factory->NewCOWTaggedArray(2));
1587 JSHandle<JSTaggedValue> val0(thread, JSTaggedValue(1));
1588 JSHandle<JSTaggedValue> val1(thread, JSTaggedValue(2));
1589 array->Set(thread, 0, val0);
1590 array->Set(thread, 1, val1);
1591
1592 JSSharedArray *arr = JSSharedArray::Cast(JSSharedArray::ArrayCreate(thread, JSTaggedNumber(0)) \
1593 .GetTaggedValue().GetTaggedObject());
1594 JSHandle<JSObject> arrObj(thread, arr);
1595 JSHandle<JSTaggedValue> arrayH(arrObj);
1596
1597 JSHandle<JSObject> obj(thread, arr);
1598 obj->SetElements(thread, array, SKIP_BARRIER);
1599
1600 JSHandle<JSSharedArray> jsSharedArray(arrayH);
1601 JSSharedArray::CheckAndCopyArray(thread, jsSharedArray);
1602 EXPECT_TRUE(arrayH->IsECMAObject());
1603 }
1604
HWTEST_F_L0(BuiltinsSharedArrayTest, Every)1605 HWTEST_F_L0(BuiltinsSharedArrayTest, Every)
1606 {
1607 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
1608 auto ecmaVM = thread->GetEcmaVM();
1609 JSHandle<GlobalEnv> env = ecmaVM->GetGlobalEnv();
1610
1611 JSHandle<JSTaggedValue> lengthKeyHandle = thread->GlobalConstants()->GetHandledLengthString();
1612 JSSharedArray *arr = JSSharedArray::Cast(JSSharedArray::ArrayCreate(thread,
1613 JSTaggedNumber(0)).GetTaggedValue().GetTaggedObject());
1614 EXPECT_TRUE(arr != nullptr);
1615 JSHandle<JSObject> obj(thread, arr);
1616 EXPECT_EQ(JSSharedArray::GetProperty(thread, JSHandle<JSTaggedValue>(obj),
1617 lengthKeyHandle, SCheckMode::SKIP).GetValue()->GetInt(), 0);
1618
1619 std::vector<int> descVals{100, 200, 300};
1620 auto keys = SharedArrayDefineOwnPropertyTest(thread, obj, descVals);
1621
1622 JSHandle<JSSharedArray> jsSharedArray(JSSharedArray::ArrayCreate(thread, JSTaggedNumber(0)));
1623 JSHandle<JSFunction> func = factory->NewJSFunction(env, reinterpret_cast<void *>(TestClass::TestEveryFunc));
1624
1625 auto ecmaRuntimeCallInfo1 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 8);
1626 ecmaRuntimeCallInfo1->SetFunction(JSTaggedValue::Undefined());
1627 ecmaRuntimeCallInfo1->SetThis(obj.GetTaggedValue());
1628 ecmaRuntimeCallInfo1->SetCallArg(0, func.GetTaggedValue());
1629 ecmaRuntimeCallInfo1->SetCallArg(1, jsSharedArray.GetTaggedValue());
1630
1631 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo1);
1632 JSTaggedValue result2 = Array::Every(ecmaRuntimeCallInfo1);
1633 TestHelper::TearDownFrame(thread, prev);
1634
1635 ASSERT_EQ(result2.GetRawData(), JSTaggedValue::True().GetRawData());
1636 EXPECT_EQ(JSSharedArrayIterator::Next(ecmaRuntimeCallInfo1), JSTaggedValue::Exception());
1637 }
1638
1639 } // namespace panda::test
1640