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
TestFromFunc(EcmaRuntimeCallInfo * argv)192 static JSTaggedValue TestFromFunc(EcmaRuntimeCallInfo *argv)
193 {
194 int accumulator = GetCallArg(argv, 0)->GetInt();
195 int coefficient = 2;
196 accumulator = accumulator * coefficient;
197 return BuiltinsBase::GetTaggedInt(accumulator);
198 }
199 };
200 };
201
HWTEST_F_L0(BuiltinsSharedArrayTest,ArrayConstructor)202 HWTEST_F_L0(BuiltinsSharedArrayTest, ArrayConstructor)
203 {
204 JSHandle<JSFunction> array(thread->GetEcmaVM()->GetGlobalEnv()->GetSharedArrayFunction());
205 JSHandle<JSObject> globalObject(thread, thread->GetEcmaVM()->GetGlobalEnv()->GetGlobalObject());
206
207 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, array.GetTaggedValue(), 10);
208 ecmaRuntimeCallInfo->SetFunction(array.GetTaggedValue());
209 ecmaRuntimeCallInfo->SetThis(globalObject.GetTaggedValue());
210 ecmaRuntimeCallInfo->SetCallArg(0, JSTaggedValue(static_cast<int32_t>(1)));
211 ecmaRuntimeCallInfo->SetCallArg(1, JSTaggedValue(static_cast<int32_t>(3)));
212 ecmaRuntimeCallInfo->SetCallArg(2, JSTaggedValue(static_cast<int32_t>(5)));
213
214 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo);
215 JSTaggedValue result = Array::ArrayConstructor(ecmaRuntimeCallInfo);
216 TestHelper::TearDownFrame(thread, prev);
217 JSTaggedValue value(static_cast<JSTaggedType>(result.GetRawData()));
218 ASSERT_TRUE(value.IsECMAObject());
219 PropertyDescriptor descRes(thread);
220 JSHandle<JSObject> valueHandle(thread, value);
221 JSHandle<JSTaggedValue> key0(thread, JSTaggedValue(0));
222 JSHandle<JSTaggedValue> key1(thread, JSTaggedValue(1));
223 JSHandle<JSTaggedValue> key2(thread, JSTaggedValue(2));
224 JSObject::GetOwnProperty(thread, valueHandle, key0, descRes);
225 ASSERT_EQ(descRes.GetValue().GetTaggedValue(), JSTaggedValue(1));
226 JSObject::GetOwnProperty(thread, valueHandle, key1, descRes);
227 ASSERT_EQ(descRes.GetValue().GetTaggedValue(), JSTaggedValue(3));
228 JSObject::GetOwnProperty(thread, valueHandle, key2, descRes);
229 ASSERT_EQ(descRes.GetValue().GetTaggedValue(), JSTaggedValue(5));
230 }
231
SharedArrayDefineOwnPropertyTest(JSThread * thread,JSHandle<JSObject> & obj,std::vector<int> & vals)232 std::vector<JSHandle<JSTaggedValue>> SharedArrayDefineOwnPropertyTest(JSThread* thread, JSHandle<JSObject>& obj,
233 std::vector<int>& vals)
234 {
235 std::vector<JSHandle<JSTaggedValue>> keys;
236 for (size_t i = 0; i < vals.size(); i++) {
237 keys.push_back(JSHandle<JSTaggedValue>(thread, JSTaggedValue(static_cast<int>(i))));
238 PropertyDescriptor desc0(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(vals[i])), true, true, true);
239 JSArray::DefineOwnProperty(thread, obj, keys[i], desc0);
240 }
241 return keys;
242 }
243
SharedArrayDefineOwnPropertyTest(JSThread * thread,JSHandle<JSTaggedValue> & obj,std::vector<int> & vals)244 std::vector<JSHandle<JSTaggedValue>> SharedArrayDefineOwnPropertyTest(JSThread* thread, JSHandle<JSTaggedValue>& obj,
245 std::vector<int>& vals)
246 {
247 JSHandle<JSObject> jsObj(obj);
248 std::vector<JSHandle<JSTaggedValue>> keys;
249 for (size_t i = 0; i < vals.size(); i++) {
250 keys.push_back(JSHandle<JSTaggedValue>(thread, JSTaggedValue(static_cast<int>(i))));
251 PropertyDescriptor desc0(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(vals[i])), true, true, true);
252 JSArray::DefineOwnProperty(thread, jsObj, keys[i], desc0);
253 }
254 return keys;
255 }
256
SharedArrayCheckKeyValueCommon(JSThread * thread,JSHandle<JSObject> & valueHandle,PropertyDescriptor & descRes,std::vector<JSHandle<JSTaggedValue>> & keys,std::vector<int32_t> & vals)257 void SharedArrayCheckKeyValueCommon(JSThread* thread, JSHandle<JSObject>& valueHandle, PropertyDescriptor& descRes,
258 std::vector<JSHandle<JSTaggedValue>>& keys, std::vector<int32_t>& vals)
259 {
260 for (size_t i = 0; i < vals.size(); i++) {
261 JSObject::GetOwnProperty(thread, valueHandle, keys[i], descRes);
262 ASSERT_EQ(descRes.GetValue().GetTaggedValue(), JSTaggedValue(vals[i]));
263 }
264 }
265
266 // Array.from ( items [ , mapfn [ , thisArg ] ] )
HWTEST_F_L0(BuiltinsSharedArrayTest,From)267 HWTEST_F_L0(BuiltinsSharedArrayTest, From)
268 {
269 JSHandle<JSTaggedValue> lengthKeyHandle = thread->GlobalConstants()->GetHandledLengthString();
270 JSSharedArray *arr = JSSharedArray::Cast(JSSharedArray::ArrayCreate(thread, JSTaggedNumber(0))->GetTaggedObject());
271 EXPECT_TRUE(arr != nullptr);
272 JSHandle<JSObject> obj(thread, arr);
273 EXPECT_EQ(JSSharedArray::GetProperty(thread, JSHandle<JSTaggedValue>(obj), lengthKeyHandle, SCheckMode::SKIP) \
274 .GetValue()->GetInt(), 0);
275
276 std::vector<int> descVals{1, 2, 3, 4, 5};
277 auto keys = SharedArrayDefineOwnPropertyTest(thread, obj, descVals);
278
279 JSHandle<JSFunction> array(thread->GetEcmaVM()->GetGlobalEnv()->GetSharedArrayFunction());
280 auto ecmaRuntimeCallInfo1 = TestHelper::CreateEcmaRuntimeCallInfo(thread, array.GetTaggedValue(), 6);
281 ecmaRuntimeCallInfo1->SetFunction(array.GetTaggedValue());
282 ecmaRuntimeCallInfo1->SetThis(obj.GetTaggedValue());
283 ecmaRuntimeCallInfo1->SetCallArg(0, obj.GetTaggedValue());
284
285 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo1);
286 JSTaggedValue result = Array::From(ecmaRuntimeCallInfo1);
287 TestHelper::TearDownFrame(thread, prev);
288 JSTaggedValue value(static_cast<JSTaggedType>(result.GetRawData()));
289 ASSERT_TRUE(value.IsECMAObject());
290 PropertyDescriptor descRes(thread);
291 JSHandle<JSObject> valueHandle(thread, value);
292 std::vector<int> vals{1, 2, 3, 4, 5};
293 SharedArrayCheckKeyValueCommon(thread, valueHandle, descRes, keys, vals);
294 }
295
296 // Array.from ( items [ , mapfn [ , thisArg ] ] )
HWTEST_F_L0(BuiltinsSharedArrayTest,From_Two)297 HWTEST_F_L0(BuiltinsSharedArrayTest, From_Two)
298 {
299 auto ecmaVM = thread->GetEcmaVM();
300 JSHandle<GlobalEnv> env = ecmaVM->GetGlobalEnv();
301 ObjectFactory *factory = ecmaVM->GetFactory();
302
303 JSHandle<JSTaggedValue> lengthKeyHandle = thread->GlobalConstants()->GetHandledLengthString();
304 JSSharedArray *arr = JSSharedArray::Cast(JSSharedArray::ArrayCreate(thread, JSTaggedNumber(0))->GetTaggedObject());
305 EXPECT_TRUE(arr != nullptr);
306 JSHandle<JSObject> obj(thread, arr);
307 EXPECT_EQ(JSSharedArray::GetProperty(thread, JSHandle<JSTaggedValue>(obj), lengthKeyHandle, SCheckMode::SKIP) \
308 .GetValue()->GetInt(), 0);
309
310 std::vector<int> descVals{1, 2, 3, 4, 5};
311 auto keys = SharedArrayDefineOwnPropertyTest(thread, obj, descVals);
312
313 JSHandle<JSFunction> func = factory->NewJSFunction(env, reinterpret_cast<void *>(TestClass::TestFromFunc));
314
315 JSHandle<JSFunction> array(thread->GetEcmaVM()->GetGlobalEnv()->GetSharedArrayFunction());
316 auto ecmaRuntimeCallInfo1 = TestHelper::CreateEcmaRuntimeCallInfo(thread, array.GetTaggedValue(), 8);
317 ecmaRuntimeCallInfo1->SetFunction(array.GetTaggedValue());
318 ecmaRuntimeCallInfo1->SetThis(obj.GetTaggedValue());
319 ecmaRuntimeCallInfo1->SetCallArg(0, obj.GetTaggedValue());
320 ecmaRuntimeCallInfo1->SetCallArg(1, func.GetTaggedValue());
321
322 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo1);
323 JSTaggedValue result = Array::From(ecmaRuntimeCallInfo1);
324 TestHelper::TearDownFrame(thread, prev);
325 JSTaggedValue value(static_cast<JSTaggedType>(result.GetRawData()));
326 ASSERT_TRUE(value.IsECMAObject());
327 PropertyDescriptor descRes(thread);
328 JSHandle<JSObject> valueHandle(thread, value);
329 std::vector<int> vals{2, 4, 6, 8, 10};
330 SharedArrayCheckKeyValueCommon(thread, valueHandle, descRes, keys, vals);
331 }
332
HWTEST_F_L0(BuiltinsSharedArrayTest,Species)333 HWTEST_F_L0(BuiltinsSharedArrayTest, Species)
334 {
335 auto ecmaVM = thread->GetEcmaVM();
336 JSHandle<GlobalEnv> env = ecmaVM->GetGlobalEnv();
337 JSHandle<JSFunction> array(env->GetArrayFunction());
338 JSHandle<JSObject> globalObject(thread, env->GetGlobalObject());
339
340 auto ecmaRuntimeCallInfo1 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 4);
341 ecmaRuntimeCallInfo1->SetFunction(array.GetTaggedValue());
342 ecmaRuntimeCallInfo1->SetThis(globalObject.GetTaggedValue());
343
344 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo1);
345 JSTaggedValue result = Array::Species(ecmaRuntimeCallInfo1);
346 TestHelper::TearDownFrame(thread, prev);
347 ASSERT_TRUE(result.IsECMAObject());
348 }
349
HWTEST_F_L0(BuiltinsSharedArrayTest,Concat)350 HWTEST_F_L0(BuiltinsSharedArrayTest, Concat)
351 {
352 JSHandle<JSTaggedValue> lengthKeyHandle = thread->GlobalConstants()->GetHandledLengthString();
353 JSSharedArray *arr = JSSharedArray::Cast(JSSharedArray::ArrayCreate(thread, JSTaggedNumber(0)) \
354 .GetTaggedValue().GetTaggedObject());
355 EXPECT_TRUE(arr != nullptr);
356 JSHandle<JSObject> obj(thread, arr);
357
358 std::vector<int> descVals{1, 2, 3};
359 auto keys = SharedArrayDefineOwnPropertyTest(thread, obj, descVals);
360
361 JSSharedArray *arr1 = JSSharedArray::ArrayCreate(thread, JSTaggedNumber(0)).GetObject<JSSharedArray>();
362 EXPECT_TRUE(arr1 != nullptr);
363 JSHandle<JSObject> obj1(thread, arr1);
364
365 std::vector<int> descVals2{4, 5, 6};
366 keys = SharedArrayDefineOwnPropertyTest(thread, obj1, descVals2);
367
368 auto ecmaRuntimeCallInfo1 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 6);
369 ecmaRuntimeCallInfo1->SetFunction(JSTaggedValue::Undefined());
370 ecmaRuntimeCallInfo1->SetThis(obj.GetTaggedValue());
371 ecmaRuntimeCallInfo1->SetCallArg(0, obj1.GetTaggedValue());
372
373 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo1);
374 JSTaggedValue result = Array::Concat(ecmaRuntimeCallInfo1);
375 TestHelper::TearDownFrame(thread, prev);
376 JSTaggedValue value(static_cast<JSTaggedType>(result.GetRawData()));
377 ASSERT_TRUE(value.IsECMAObject());
378
379 PropertyDescriptor descRes(thread);
380 JSHandle<JSObject> valueHandle(thread, value);
381 JSHandle<JSTaggedValue> key7(thread, JSTaggedValue(5));
382 EXPECT_EQ(
383 JSSharedArray::GetProperty(thread, JSHandle<JSTaggedValue>(valueHandle), lengthKeyHandle,
384 SCheckMode::SKIP).GetValue()->GetInt(), 6);
385
386 JSObject::GetOwnProperty(thread, valueHandle, key7, descRes);
387 }
388
HWTEST_F_L0(BuiltinsSharedArrayTest,Map)389 HWTEST_F_L0(BuiltinsSharedArrayTest, Map)
390 {
391 auto ecmaVM = thread->GetEcmaVM();
392 JSHandle<GlobalEnv> env = ecmaVM->GetGlobalEnv();
393 ObjectFactory *factory = ecmaVM->GetFactory();
394
395 JSHandle<JSTaggedValue> lengthKeyHandle = thread->GlobalConstants()->GetHandledLengthString();
396 JSSharedArray *arr = JSSharedArray::Cast(JSSharedArray::ArrayCreate(thread, JSTaggedNumber(0)) \
397 .GetTaggedValue().GetTaggedObject());
398 EXPECT_TRUE(arr != nullptr);
399 JSHandle<JSObject> obj(thread, arr);
400 EXPECT_EQ(JSSharedArray::GetProperty(thread, JSHandle<JSTaggedValue>(obj), lengthKeyHandle, SCheckMode::SKIP) \
401 .GetValue()->GetInt(), 0);
402
403 std::vector<int> descVals{50, 200, 3};
404 auto keys = SharedArrayDefineOwnPropertyTest(thread, obj, descVals);
405
406 JSHandle<JSSharedArray> JSSharedArray(JSSharedArray::ArrayCreate(thread, JSTaggedNumber(0)));
407 JSHandle<JSFunction> func = factory->NewJSFunction(env, reinterpret_cast<void *>(TestClass::TestMapFunc));
408
409 auto ecmaRuntimeCallInfo1 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 8);
410 ecmaRuntimeCallInfo1->SetFunction(JSTaggedValue::Undefined());
411 ecmaRuntimeCallInfo1->SetThis(obj.GetTaggedValue());
412 ecmaRuntimeCallInfo1->SetCallArg(0, func.GetTaggedValue());
413 ecmaRuntimeCallInfo1->SetCallArg(1, JSSharedArray.GetTaggedValue());
414
415 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo1);
416 JSTaggedValue result = Array::Map(ecmaRuntimeCallInfo1);
417 TestHelper::TearDownFrame(thread, prev);
418 JSTaggedValue value(static_cast<JSTaggedType>(result.GetRawData()));
419 ASSERT_TRUE(value.IsECMAObject());
420
421 PropertyDescriptor descRes(thread);
422 JSHandle<JSObject> valueHandle(thread, value);
423 std::vector<int> vals{100, 400, 6};
424 EXPECT_EQ(
425 JSSharedArray::GetProperty(thread, JSHandle<JSTaggedValue>(valueHandle), lengthKeyHandle,
426 SCheckMode::SKIP).GetValue()->GetInt(), 3);
427 SharedArrayCheckKeyValueCommon(thread, valueHandle, descRes, keys, vals);
428 }
429
HWTEST_F_L0(BuiltinsSharedArrayTest,Slice)430 HWTEST_F_L0(BuiltinsSharedArrayTest, Slice)
431 {
432 JSHandle<JSTaggedValue> lengthKeyHandle = thread->GlobalConstants()->GetHandledLengthString();
433 JSSharedArray *arr = JSSharedArray::Cast(JSSharedArray::ArrayCreate(thread, JSTaggedNumber(0)) \
434 .GetTaggedValue().GetTaggedObject());
435 EXPECT_TRUE(arr != nullptr);
436 JSHandle<JSObject> obj(thread, arr);
437 EXPECT_EQ(JSSharedArray::GetProperty(thread, JSHandle<JSTaggedValue>(obj), lengthKeyHandle, SCheckMode::SKIP) \
438 .GetValue()->GetInt(), 0);
439 std::vector<int> descVals{1, 2, 3, 4, 5};
440 auto keys = SharedArrayDefineOwnPropertyTest(thread, obj, descVals);
441
442 auto ecmaRuntimeCallInfo1 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 8);
443 ecmaRuntimeCallInfo1->SetFunction(JSTaggedValue::Undefined());
444 ecmaRuntimeCallInfo1->SetThis(obj.GetTaggedValue());
445 ecmaRuntimeCallInfo1->SetCallArg(0, JSTaggedValue(static_cast<int32_t>(1)));
446 ecmaRuntimeCallInfo1->SetCallArg(1, JSTaggedValue(static_cast<int32_t>(4)));
447
448 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo1);
449 JSTaggedValue result = Array::Slice(ecmaRuntimeCallInfo1);
450 TestHelper::TearDownFrame(thread, prev);
451 JSTaggedValue value(static_cast<JSTaggedType>(result.GetRawData()));
452 ASSERT_TRUE(value.IsECMAObject());
453
454 PropertyDescriptor descRes(thread);
455 JSHandle<JSObject> valueHandle(thread, value);
456 EXPECT_EQ(JSSharedArray::GetProperty(thread, JSHandle<JSTaggedValue>(valueHandle), lengthKeyHandle,
457 SCheckMode::SKIP).GetValue()->GetInt(), 3);
458 std::vector<int> vals{2, 3, 4};
459 SharedArrayCheckKeyValueCommon(thread, valueHandle, descRes, keys, vals);
460 }
461
HWTEST_F_L0(BuiltinsSharedArrayTest,Splice)462 HWTEST_F_L0(BuiltinsSharedArrayTest, Splice)
463 {
464 JSHandle<JSTaggedValue> lengthKeyHandle = thread->GlobalConstants()->GetHandledLengthString();
465 JSSharedArray *arr = JSSharedArray::Cast(JSSharedArray::ArrayCreate(thread, JSTaggedNumber(0)) \
466 .GetTaggedValue().GetTaggedObject());
467 EXPECT_TRUE(arr != nullptr);
468 JSHandle<JSObject> obj(thread, arr);
469 EXPECT_EQ(JSSharedArray::GetProperty(thread, JSHandle<JSTaggedValue>(obj), lengthKeyHandle, SCheckMode::SKIP) \
470 .GetValue()->GetInt(), 0);
471 std::vector<int> descVals{1, 2, 3, 4, 5};
472 auto keys = SharedArrayDefineOwnPropertyTest(thread, obj, descVals);
473
474 auto ecmaRuntimeCallInfo1 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 10);
475 ecmaRuntimeCallInfo1->SetFunction(JSTaggedValue::Undefined());
476 ecmaRuntimeCallInfo1->SetThis(obj.GetTaggedValue());
477 ecmaRuntimeCallInfo1->SetCallArg(0, JSTaggedValue(static_cast<int32_t>(1)));
478 ecmaRuntimeCallInfo1->SetCallArg(1, JSTaggedValue(static_cast<int32_t>(2)));
479 ecmaRuntimeCallInfo1->SetCallArg(2, JSTaggedValue(static_cast<int32_t>(100)));
480
481 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo1);
482 JSTaggedValue result = Array::Splice(ecmaRuntimeCallInfo1);
483 TestHelper::TearDownFrame(thread, prev);
484 JSTaggedValue value(static_cast<JSTaggedType>(result.GetRawData()));
485 ASSERT_TRUE(value.IsECMAObject());
486 EXPECT_EQ(JSSharedArray::GetProperty(thread, JSHandle<JSTaggedValue>(obj), lengthKeyHandle,
487 SCheckMode::SKIP).GetValue()->GetInt(), 4);
488
489 PropertyDescriptor descRes(thread);
490 JSHandle<JSObject> valueHandle(thread, value);
491 EXPECT_EQ(
492 JSSharedArray::GetProperty(thread, JSHandle<JSTaggedValue>(valueHandle), lengthKeyHandle,
493 SCheckMode::SKIP).GetValue()->GetInt(), 2);
494 JSObject::GetOwnProperty(thread, valueHandle, keys[0], descRes);
495 ASSERT_EQ(descRes.GetValue().GetTaggedValue(), JSTaggedValue(2));
496 }
497
498 // new Array(1,2,3,4,5).Fill(0,1,3)
HWTEST_F_L0(BuiltinsSharedArrayTest,Fill)499 HWTEST_F_L0(BuiltinsSharedArrayTest, Fill)
500 {
501 JSHandle<JSTaggedValue> lengthKeyHandle = thread->GlobalConstants()->GetHandledLengthString();
502 JSSharedArray *arr = JSSharedArray::Cast(JSSharedArray::ArrayCreate(thread, JSTaggedNumber(0)) \
503 .GetTaggedValue().GetTaggedObject());
504 EXPECT_TRUE(arr != nullptr);
505 JSHandle<JSObject> obj(thread, arr);
506 EXPECT_EQ(JSSharedArray::GetProperty(thread, JSHandle<JSTaggedValue>(obj), lengthKeyHandle, SCheckMode::SKIP) \
507 .GetValue()->GetInt(), 0);
508
509 std::vector<int> descVals{1, 2, 3, 4, 5};
510 auto keys = SharedArrayDefineOwnPropertyTest(thread, obj, descVals);
511
512 auto ecmaRuntimeCallInfo1 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 10);
513 ecmaRuntimeCallInfo1->SetFunction(JSTaggedValue::Undefined());
514 ecmaRuntimeCallInfo1->SetThis(obj.GetTaggedValue());
515 ecmaRuntimeCallInfo1->SetCallArg(0, JSTaggedValue(static_cast<int32_t>(0)));
516 ecmaRuntimeCallInfo1->SetCallArg(1, JSTaggedValue(static_cast<int32_t>(1)));
517 ecmaRuntimeCallInfo1->SetCallArg(2, JSTaggedValue(static_cast<int32_t>(3)));
518
519 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo1);
520 JSTaggedValue result = Array::Fill(ecmaRuntimeCallInfo1);
521 TestHelper::TearDownFrame(thread, prev);
522 JSTaggedValue value(static_cast<JSTaggedType>(result.GetRawData()));
523 ASSERT_TRUE(value.IsECMAObject());
524 PropertyDescriptor descRes(thread);
525 JSHandle<JSObject> valueHandle(thread, value);
526 std::vector<int32_t> vals{1, 0, 0, 4, 5};
527 SharedArrayCheckKeyValueCommon(thread, valueHandle, descRes, keys, vals);
528 }
529
HWTEST_F_L0(BuiltinsSharedArrayTest,Find)530 HWTEST_F_L0(BuiltinsSharedArrayTest, Find)
531 {
532 auto ecmaVM = thread->GetEcmaVM();
533 JSHandle<GlobalEnv> env = ecmaVM->GetGlobalEnv();
534 ObjectFactory *factory = ecmaVM->GetFactory();
535
536 JSHandle<JSTaggedValue> lengthKeyHandle = thread->GlobalConstants()->GetHandledLengthString();
537 JSSharedArray *arr = JSSharedArray::Cast(JSSharedArray::ArrayCreate(thread, JSTaggedNumber(0)) \
538 .GetTaggedValue().GetTaggedObject());
539 EXPECT_TRUE(arr != nullptr);
540 JSHandle<JSObject> obj(thread, arr);
541 EXPECT_EQ(JSSharedArray::GetProperty(thread, JSHandle<JSTaggedValue>(obj), lengthKeyHandle, SCheckMode::SKIP) \
542 .GetValue()->GetInt(), 0);
543
544 std::vector<int> vals{1, 102, 3};
545 auto keys = SharedArrayDefineOwnPropertyTest(thread, obj, vals);
546 JSHandle<JSSharedArray> JSSharedArray(JSSharedArray::ArrayCreate(thread, JSTaggedNumber(0)));
547 JSHandle<JSFunction> func = factory->NewJSFunction(env, reinterpret_cast<void *>(TestClass::TestFindFunc));
548
549 auto ecmaRuntimeCallInfo1 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 8);
550 ecmaRuntimeCallInfo1->SetFunction(JSTaggedValue::Undefined());
551 ecmaRuntimeCallInfo1->SetThis(obj.GetTaggedValue());
552 ecmaRuntimeCallInfo1->SetCallArg(0, func.GetTaggedValue());
553 ecmaRuntimeCallInfo1->SetCallArg(1, JSSharedArray.GetTaggedValue());
554
555 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo1);
556 JSTaggedValue result2 = Array::Find(ecmaRuntimeCallInfo1);
557 TestHelper::TearDownFrame(thread, prev);
558
559 EXPECT_EQ(result2.GetRawData(), JSTaggedValue(102).GetRawData());
560 }
561
HWTEST_F_L0(BuiltinsSharedArrayTest,FindLast_One)562 HWTEST_F_L0(BuiltinsSharedArrayTest, FindLast_One)
563 {
564 auto ecmaVM = thread->GetEcmaVM();
565 JSHandle<GlobalEnv> env = ecmaVM->GetGlobalEnv();
566 ObjectFactory *factory = ecmaVM->GetFactory();
567
568 JSHandle<JSTaggedValue> lengthKeyHandle = thread->GlobalConstants()->GetHandledLengthString();
569 JSSharedArray *arr = JSSharedArray::Cast(
570 JSSharedArray::ArrayCreate(thread, JSTaggedNumber(0)).GetTaggedValue().GetTaggedObject());
571 EXPECT_TRUE(arr != nullptr);
572 JSHandle<JSObject> obj(thread, arr);
573 EXPECT_EQ(JSSharedArray::GetProperty(thread, JSHandle<JSTaggedValue>(obj), lengthKeyHandle, SCheckMode::SKIP) \
574 .GetValue()->GetInt(), 0);
575 // arr [50, 40, 2]
576 std::vector<int> descVals{50, 40, 2};
577 auto keys = SharedArrayDefineOwnPropertyTest(thread, obj, descVals);
578
579 JSHandle<JSSharedArray> JSSharedArray(JSSharedArray::ArrayCreate(thread, JSTaggedNumber(0)));
580 JSHandle<JSFunction> func = factory->NewJSFunction(env, reinterpret_cast<void *>(TestClass::TestFindLastFunc));
581
582 auto ecmaRuntimeCallInfo1 =
583 TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 8); // 8 means 2 call args
584 ecmaRuntimeCallInfo1->SetFunction(JSTaggedValue::Undefined());
585 ecmaRuntimeCallInfo1->SetThis(obj.GetTaggedValue());
586 ecmaRuntimeCallInfo1->SetCallArg(0, func.GetTaggedValue());
587 ecmaRuntimeCallInfo1->SetCallArg(1, JSSharedArray.GetTaggedValue());
588
589 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo1);
590 JSTaggedValue result = Array::FindLast(ecmaRuntimeCallInfo1);
591 TestHelper::TearDownFrame(thread, prev);
592
593 EXPECT_EQ(result.GetRawData(), JSTaggedValue(40).GetRawData());
594 }
595
HWTEST_F_L0(BuiltinsSharedArrayTest,FindLast_Two)596 HWTEST_F_L0(BuiltinsSharedArrayTest, FindLast_Two)
597 {
598 auto ecmaVM = thread->GetEcmaVM();
599 JSHandle<GlobalEnv> env = ecmaVM->GetGlobalEnv();
600 ObjectFactory *factory = ecmaVM->GetFactory();
601
602 JSHandle<JSTaggedValue> lengthKeyHandle = thread->GlobalConstants()->GetHandledLengthString();
603 JSSharedArray *arr = JSSharedArray::Cast(
604 JSSharedArray::ArrayCreate(thread, JSTaggedNumber(0)).GetTaggedValue().GetTaggedObject());
605 EXPECT_TRUE(arr != nullptr);
606 JSHandle<JSObject> obj(thread, arr);
607 EXPECT_EQ(JSSharedArray::GetProperty(thread, JSHandle<JSTaggedValue>(obj), lengthKeyHandle, SCheckMode::SKIP) \
608 .GetValue()->GetInt(), 0);
609 // arr [5, 7, 9]
610 std::vector<int> descVals{5, 7, 9};
611 auto keys = SharedArrayDefineOwnPropertyTest(thread, obj, descVals);
612
613 JSHandle<JSSharedArray> JSSharedArray(JSSharedArray::ArrayCreate(thread, JSTaggedNumber(0)));
614 JSHandle<JSFunction> func = factory->NewJSFunction(env, reinterpret_cast<void *>(TestClass::TestFindLastFunc));
615
616 auto ecmaRuntimeCallInfo1 =
617 TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 8); // 8 means 2 call args
618 ecmaRuntimeCallInfo1->SetFunction(JSTaggedValue::Undefined());
619 ecmaRuntimeCallInfo1->SetThis(obj.GetTaggedValue());
620 ecmaRuntimeCallInfo1->SetCallArg(0, func.GetTaggedValue());
621 ecmaRuntimeCallInfo1->SetCallArg(1, JSSharedArray.GetTaggedValue());
622
623 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo1);
624 JSTaggedValue result = Array::FindLast(ecmaRuntimeCallInfo1);
625 TestHelper::TearDownFrame(thread, prev);
626
627 ASSERT_EQ(result.GetRawData(), JSTaggedValue::VALUE_UNDEFINED);
628 }
629
HWTEST_F_L0(BuiltinsSharedArrayTest,FindLastIndex_One)630 HWTEST_F_L0(BuiltinsSharedArrayTest, FindLastIndex_One)
631 {
632 auto ecmaVM = thread->GetEcmaVM();
633 JSHandle<GlobalEnv> env = ecmaVM->GetGlobalEnv();
634 ObjectFactory *factory = ecmaVM->GetFactory();
635
636 JSHandle<JSTaggedValue> lengthKeyHandle = thread->GlobalConstants()->GetHandledLengthString();
637 JSSharedArray *arr = JSSharedArray::Cast(
638 JSSharedArray::ArrayCreate(thread, JSTaggedNumber(0)).GetTaggedValue().GetTaggedObject());
639 EXPECT_TRUE(arr != nullptr);
640 JSHandle<JSObject> obj(thread, arr);
641 EXPECT_EQ(JSSharedArray::GetProperty(thread, JSHandle<JSTaggedValue>(obj), lengthKeyHandle, SCheckMode::SKIP) \
642 .GetValue()->GetInt(), 0);
643 // arr [50, 40, 2]
644 std::vector<int> descVals{50, 40, 2};
645 auto keys = SharedArrayDefineOwnPropertyTest(thread, obj, descVals);
646
647 JSHandle<JSSharedArray> JSSharedArray(JSSharedArray::ArrayCreate(thread, JSTaggedNumber(0)));
648 JSHandle<JSFunction> func = factory->NewJSFunction(env, reinterpret_cast<void *>(TestClass::TestFindLastIndexFunc));
649
650 auto ecmaRuntimeCallInfo1 =
651 TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 8); // 8 means 2 call args
652 ecmaRuntimeCallInfo1->SetFunction(JSTaggedValue::Undefined());
653 ecmaRuntimeCallInfo1->SetThis(obj.GetTaggedValue());
654 ecmaRuntimeCallInfo1->SetCallArg(0, func.GetTaggedValue());
655 ecmaRuntimeCallInfo1->SetCallArg(1, JSSharedArray.GetTaggedValue());
656
657 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo1);
658 JSTaggedValue result = Array::FindLastIndex(ecmaRuntimeCallInfo1);
659 TestHelper::TearDownFrame(thread, prev);
660
661 EXPECT_EQ(result.GetRawData(), JSTaggedValue(static_cast<double>(1)).GetRawData());
662 }
663
HWTEST_F_L0(BuiltinsSharedArrayTest,FindLastIndex_Two)664 HWTEST_F_L0(BuiltinsSharedArrayTest, FindLastIndex_Two)
665 {
666 auto ecmaVM = thread->GetEcmaVM();
667 JSHandle<GlobalEnv> env = ecmaVM->GetGlobalEnv();
668 ObjectFactory *factory = ecmaVM->GetFactory();
669
670 JSHandle<JSTaggedValue> lengthKeyHandle = thread->GlobalConstants()->GetHandledLengthString();
671 JSSharedArray *arr = JSSharedArray::Cast(
672 JSSharedArray::ArrayCreate(thread, JSTaggedNumber(0)).GetTaggedValue().GetTaggedObject());
673 EXPECT_TRUE(arr != nullptr);
674 JSHandle<JSObject> obj(thread, arr);
675 EXPECT_EQ(JSSharedArray::GetProperty(thread, JSHandle<JSTaggedValue>(obj), lengthKeyHandle, SCheckMode::SKIP) \
676 .GetValue()->GetInt(), 0);
677 // arr [5, 7, 9]
678 std::vector<int> descVals{5, 7, 9};
679 auto keys = SharedArrayDefineOwnPropertyTest(thread, obj, descVals);
680
681 JSHandle<JSSharedArray> JSSharedArray(JSSharedArray::ArrayCreate(thread, JSTaggedNumber(0)));
682 JSHandle<JSFunction> func = factory->NewJSFunction(env,
683 reinterpret_cast<void *>(TestClass::TestFindLastIndexFunc));
684
685 auto ecmaRuntimeCallInfo1 =
686 TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 8); // 8 means 2 call args
687 ecmaRuntimeCallInfo1->SetFunction(JSTaggedValue::Undefined());
688 ecmaRuntimeCallInfo1->SetThis(obj.GetTaggedValue());
689 ecmaRuntimeCallInfo1->SetCallArg(0, func.GetTaggedValue());
690 ecmaRuntimeCallInfo1->SetCallArg(1, JSSharedArray.GetTaggedValue());
691
692 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo1);
693 JSTaggedValue result = Array::FindLastIndex(ecmaRuntimeCallInfo1);
694 TestHelper::TearDownFrame(thread, prev);
695
696 EXPECT_EQ(result.GetRawData(), JSTaggedValue(static_cast<double>(-1)).GetRawData());
697 }
698
HWTEST_F_L0(BuiltinsSharedArrayTest,FindIndex)699 HWTEST_F_L0(BuiltinsSharedArrayTest, FindIndex)
700 {
701 auto ecmaVM = thread->GetEcmaVM();
702 JSHandle<GlobalEnv> env = ecmaVM->GetGlobalEnv();
703 ObjectFactory *factory = ecmaVM->GetFactory();
704
705 JSHandle<JSTaggedValue> lengthKeyHandle = thread->GlobalConstants()->GetHandledLengthString();
706 JSSharedArray *arr = JSSharedArray::Cast(JSSharedArray::ArrayCreate(thread, JSTaggedNumber(0)) \
707 .GetTaggedValue().GetTaggedObject());
708 EXPECT_TRUE(arr != nullptr);
709 JSHandle<JSObject> obj(thread, arr);
710 EXPECT_EQ(JSSharedArray::GetProperty(thread, JSHandle<JSTaggedValue>(obj), lengthKeyHandle, SCheckMode::SKIP) \
711 .GetValue()->GetInt(), 0);
712
713 std::vector<int> descVals{1, 2, 30};
714 auto keys = SharedArrayDefineOwnPropertyTest(thread, obj, descVals);
715
716 JSHandle<JSSharedArray> JSSharedArray(JSSharedArray::ArrayCreate(thread, JSTaggedNumber(0)));
717 JSHandle<JSFunction> func = factory->NewJSFunction(env, reinterpret_cast<void *>(TestClass::TestFindIndexFunc));
718
719 auto ecmaRuntimeCallInfo1 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 8);
720 ecmaRuntimeCallInfo1->SetFunction(JSTaggedValue::Undefined());
721 ecmaRuntimeCallInfo1->SetThis(obj.GetTaggedValue());
722 ecmaRuntimeCallInfo1->SetCallArg(0, func.GetTaggedValue());
723 ecmaRuntimeCallInfo1->SetCallArg(1, JSSharedArray.GetTaggedValue());
724
725 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo1);
726 JSTaggedValue result2 = Array::FindIndex(ecmaRuntimeCallInfo1);
727 TestHelper::TearDownFrame(thread, prev);
728
729 EXPECT_EQ(result2.GetRawData(), JSTaggedValue(static_cast<double>(2)).GetRawData());
730 }
731
HWTEST_F_L0(BuiltinsSharedArrayTest,ForEach)732 HWTEST_F_L0(BuiltinsSharedArrayTest, ForEach)
733 {
734 auto ecmaVM = thread->GetEcmaVM();
735 JSHandle<GlobalEnv> env = ecmaVM->GetGlobalEnv();
736 ObjectFactory *factory = ecmaVM->GetFactory();
737
738 JSHandle<JSTaggedValue> lengthKeyHandle = thread->GlobalConstants()->GetHandledLengthString();
739 JSSharedArray *arr = JSSharedArray::Cast(JSSharedArray::ArrayCreate(thread, JSTaggedNumber(0)) \
740 .GetTaggedValue().GetTaggedObject());
741 EXPECT_TRUE(arr != nullptr);
742 JSHandle<JSObject> obj(thread, arr);
743 EXPECT_EQ(JSSharedArray::GetProperty(thread, JSHandle<JSTaggedValue>(obj), lengthKeyHandle, SCheckMode::SKIP) \
744 .GetValue()->GetInt(), 0);
745
746 std::vector<int> descVals{1, 2, 3};
747 auto keys = SharedArrayDefineOwnPropertyTest(thread, obj, descVals);
748
749 JSHandle<JSSharedArray> JSSharedArray(JSSharedArray::ArrayCreate(thread, JSTaggedNumber(0)));
750 JSHandle<JSFunction> func = factory->NewJSFunction(env, reinterpret_cast<void *>(TestClass::TestForEachFunc));
751
752 auto ecmaRuntimeCallInfo1 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 8);
753 ecmaRuntimeCallInfo1->SetFunction(JSTaggedValue::Undefined());
754 ecmaRuntimeCallInfo1->SetThis(obj.GetTaggedValue());
755 ecmaRuntimeCallInfo1->SetCallArg(0, func.GetTaggedValue());
756 ecmaRuntimeCallInfo1->SetCallArg(1, JSSharedArray.GetTaggedValue());
757
758 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo1);
759 JSTaggedValue result2 = Array::ForEach(ecmaRuntimeCallInfo1);
760 TestHelper::TearDownFrame(thread, prev);
761 EXPECT_EQ(result2.GetRawData(), JSTaggedValue::VALUE_UNDEFINED);
762 EXPECT_EQ(JSSharedArray->GetArrayLength(), 3U);
763 }
764
765 #define ARRAY_DEFINE_OWN_PROPERTY(dest, index, value) \
766 do { \
767 JSHandle<JSTaggedValue> key(thread, JSTaggedValue(index)); \
768 PropertyDescriptor desc(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(value)), true, true, true); \
769 JSSharedArray::DefineOwnProperty(thread, dest, key, desc, SCheckMode::SKIP); \
770 } while (false)
771
772 #define ARRAY_BUILTIN_METHOD_TEST_CASE_ARG0(method, target, expected) \
773 do { \
774 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 6); \
775 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined()); \
776 ecmaRuntimeCallInfo->SetThis((target).GetTaggedValue()); \
777 \
778 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo); \
779 JSTaggedValue result = Array::method(ecmaRuntimeCallInfo); \
780 TestHelper::TearDownFrame(thread, prev); \
781 ASSERT_TRUE(JSTaggedValue::StrictEqual(thread, result, JSTaggedValue(expected))); \
782 } while (false)
783
784 #define ARRAY_BUILTIN_METHOD_TEST_CASE_ARG1(method, target, expected, arg0) \
785 do { \
786 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 6); \
787 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined()); \
788 ecmaRuntimeCallInfo->SetThis((target).GetTaggedValue()); \
789 ecmaRuntimeCallInfo->SetCallArg(0, JSTaggedValue(arg0)); \
790 \
791 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo); \
792 JSTaggedValue result = Array::method(ecmaRuntimeCallInfo); \
793 TestHelper::TearDownFrame(thread, prev); \
794 ASSERT_TRUE(JSTaggedValue::StrictEqual(thread, result, JSTaggedValue(expected))); \
795 } while (false)
796
797 #define ARRAY_BUILTIN_METHOD_TEST_CASE_ARG2(method, target, expected, arg0, arg1) \
798 do { \
799 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 8); \
800 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined()); \
801 ecmaRuntimeCallInfo->SetThis((target).GetTaggedValue()); \
802 ecmaRuntimeCallInfo->SetCallArg(0, JSTaggedValue(arg0)); \
803 ecmaRuntimeCallInfo->SetCallArg(1, JSTaggedValue(arg1)); \
804 \
805 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo); \
806 JSTaggedValue result = Array::method(ecmaRuntimeCallInfo); \
807 TestHelper::TearDownFrame(thread, prev); \
808 ASSERT_TRUE(JSTaggedValue::StrictEqual(thread, result, JSTaggedValue(expected))); \
809 } while (false)
810
811 // Array.IndexOf(searchElement [ , fromIndex ])
HWTEST_F_L0(BuiltinsSharedArrayTest,IndexOf)812 HWTEST_F_L0(BuiltinsSharedArrayTest, IndexOf)
813 {
814 JSHandle<JSTaggedValue> lengthKeyHandle = thread->GlobalConstants()->GetHandledLengthString();
815 JSSharedArray *arr = JSSharedArray::Cast(JSSharedArray::ArrayCreate(thread, JSTaggedNumber(20)) \
816 .GetTaggedValue().GetTaggedObject());
817 EXPECT_TRUE(arr != nullptr);
818 JSHandle<JSObject> obj(thread, arr);
819 EXPECT_EQ(JSSharedArray::GetProperty(thread, JSHandle<JSTaggedValue>(obj), lengthKeyHandle, SCheckMode::SKIP) \
820 .GetValue()->GetInt(), 20);
821
822 // arr = [1, 2, 3, 4, 3, 0, 2.0, +0.0, 3.0, -0.0, <hole>, <hole>, undefined]
823 ARRAY_DEFINE_OWN_PROPERTY(obj, 0, 1);
824 ARRAY_DEFINE_OWN_PROPERTY(obj, 1, 2);
825 ARRAY_DEFINE_OWN_PROPERTY(obj, 2, 3);
826 ARRAY_DEFINE_OWN_PROPERTY(obj, 3, 4);
827 ARRAY_DEFINE_OWN_PROPERTY(obj, 4, 3);
828 ARRAY_DEFINE_OWN_PROPERTY(obj, 5, 0);
829 ARRAY_DEFINE_OWN_PROPERTY(obj, 6, 2.0);
830 ARRAY_DEFINE_OWN_PROPERTY(obj, 7, +0.0);
831 ARRAY_DEFINE_OWN_PROPERTY(obj, 8, 3.0);
832 ARRAY_DEFINE_OWN_PROPERTY(obj, 9, -0.0);
833 ARRAY_DEFINE_OWN_PROPERTY(obj, 12, JSTaggedValue::Undefined());
834
835 // arr.indexOf(3, 0) == 2
836 ARRAY_BUILTIN_METHOD_TEST_CASE_ARG2(IndexOf, obj, 2, 3, 0);
837 // arr.indexOf(3, 3) == 4
838 ARRAY_BUILTIN_METHOD_TEST_CASE_ARG2(IndexOf, obj, 4, 3, 3);
839 // arr.indexOf(5, 0) == -1
840 ARRAY_BUILTIN_METHOD_TEST_CASE_ARG2(IndexOf, obj, -1, 5, 0);
841 // arr.indexOf(3) == 2
842 ARRAY_BUILTIN_METHOD_TEST_CASE_ARG1(IndexOf, obj, 2, 3);
843
844 // Expects int32_t(x) and double(x) to be strictly equal
845 // arr.indexOf(3.0) == 2
846 ARRAY_BUILTIN_METHOD_TEST_CASE_ARG1(IndexOf, obj, 2, 3.0);
847 // arr.indexOf(3, 5) == 8
848 ARRAY_BUILTIN_METHOD_TEST_CASE_ARG2(IndexOf, obj, 8, 3, 5);
849
850 // Expects 0, +0.0, -0.0 to be strictly equal
851 // arr.indexOf(+0.0) == 5
852 ARRAY_BUILTIN_METHOD_TEST_CASE_ARG1(IndexOf, obj, 5, +0.0);
853 // arr.indexOf(-0.0) == 5
854 ARRAY_BUILTIN_METHOD_TEST_CASE_ARG1(IndexOf, obj, 5, -0.0);
855 // arr.indexOf(0, 6) == 7
856 ARRAY_BUILTIN_METHOD_TEST_CASE_ARG2(IndexOf, obj, 7, 0, 6);
857 // arr.indexOf(-0.0, 6) == 7
858 ARRAY_BUILTIN_METHOD_TEST_CASE_ARG2(IndexOf, obj, 7, -0.0, 6);
859 // arr.indexOf(0, 8) == 9
860 ARRAY_BUILTIN_METHOD_TEST_CASE_ARG2(IndexOf, obj, 9, 0, 8);
861 // arr.indexOf(+0.0, 8) == 9
862 ARRAY_BUILTIN_METHOD_TEST_CASE_ARG2(IndexOf, obj, 9, +0.0, 8);
863
864 // Expects undefined to be found
865 // arr.indexOf() == 12, where the first argument is undefined
866 ARRAY_BUILTIN_METHOD_TEST_CASE_ARG0(IndexOf, obj, 12);
867 }
868
869 // Array.LastIndexOf(searchElement [ , fromIndex ])
HWTEST_F_L0(BuiltinsSharedArrayTest,LastIndexOf)870 HWTEST_F_L0(BuiltinsSharedArrayTest, LastIndexOf)
871 {
872 JSSharedArray *arr = JSSharedArray::Cast(JSSharedArray::ArrayCreate(thread, JSTaggedNumber(0))->GetTaggedObject());
873 EXPECT_TRUE(arr != nullptr);
874 JSHandle<JSObject> obj(thread, arr);
875 JSHandle<JSTaggedValue> lengthKeyHandle = thread->GlobalConstants()->GetHandledLengthString();
876 EXPECT_EQ(JSSharedArray::GetProperty(thread, JSHandle<JSTaggedValue>(obj), lengthKeyHandle, SCheckMode::SKIP)
877 .GetValue()
878 ->GetInt(),
879 0);
880
881 // arr.lastIndexOf(0) == -1
882 ARRAY_BUILTIN_METHOD_TEST_CASE_ARG1(LastIndexOf, obj, -1, 0);
883
884 // arr = [1, 2, 3, 4, 3, 0, 2.0, +0.0, 3.0, -0.0, <hole>, <hole>, undefined, <hole>, <hole>, -1]
885 ARRAY_DEFINE_OWN_PROPERTY(obj, 0, 1);
886 ARRAY_DEFINE_OWN_PROPERTY(obj, 1, 2);
887 ARRAY_DEFINE_OWN_PROPERTY(obj, 2, 3);
888 ARRAY_DEFINE_OWN_PROPERTY(obj, 3, 4);
889 ARRAY_DEFINE_OWN_PROPERTY(obj, 4, 3);
890 ARRAY_DEFINE_OWN_PROPERTY(obj, 5, 0);
891 ARRAY_DEFINE_OWN_PROPERTY(obj, 6, 2.0);
892 ARRAY_DEFINE_OWN_PROPERTY(obj, 7, +0.0);
893 ARRAY_DEFINE_OWN_PROPERTY(obj, 8, 3.0);
894 ARRAY_DEFINE_OWN_PROPERTY(obj, 9, -0.0);
895 ARRAY_DEFINE_OWN_PROPERTY(obj, 12, JSTaggedValue::Undefined());
896 ARRAY_DEFINE_OWN_PROPERTY(obj, 15, -1);
897
898 // arr.lastIndexOf(1, -17) == -1
899 ARRAY_BUILTIN_METHOD_TEST_CASE_ARG2(LastIndexOf, obj, -1, 1, -17);
900
901 // arr.lastIndexOf(3, 4) == 4
902 ARRAY_BUILTIN_METHOD_TEST_CASE_ARG2(LastIndexOf, obj, 4, 3, 4);
903 // arr.lastIndexOf(3, 3) == 2
904 ARRAY_BUILTIN_METHOD_TEST_CASE_ARG2(LastIndexOf, obj, 2, 3, 3);
905 // arr.lastIndexOf(5, 4) == -1
906 ARRAY_BUILTIN_METHOD_TEST_CASE_ARG2(LastIndexOf, obj, -1, 5, 4);
907
908 // Expects int32_t(x) and double(x) to be strictly equal
909 // arr.lastIndexOf(3) == 8
910 ARRAY_BUILTIN_METHOD_TEST_CASE_ARG1(LastIndexOf, obj, 8, 3);
911 // arr.lastIndexOf(1.0) == 0
912 ARRAY_BUILTIN_METHOD_TEST_CASE_ARG1(LastIndexOf, obj, 0, 1.0);
913
914 // Expects 0, +0.0, -0.0 to be strictly equal
915 // arr.indexOf(+0.0) == 9
916 ARRAY_BUILTIN_METHOD_TEST_CASE_ARG1(LastIndexOf, obj, 9, +0.0);
917 // arr.indexOf(0) == 9
918 ARRAY_BUILTIN_METHOD_TEST_CASE_ARG1(LastIndexOf, obj, 9, 0);
919 // arr.indexOf(0, 8) == 7
920 ARRAY_BUILTIN_METHOD_TEST_CASE_ARG2(LastIndexOf, obj, 7, 0, 8);
921 // arr.indexOf(-0.0, 8) == 7
922 ARRAY_BUILTIN_METHOD_TEST_CASE_ARG2(LastIndexOf, obj, 7, -0.0, 8);
923 // arr.indexOf(-0.0, 6) == 5
924 ARRAY_BUILTIN_METHOD_TEST_CASE_ARG2(LastIndexOf, obj, 5, -0.0, 6);
925 // arr.indexOf(+0.0, 6) == 5
926 ARRAY_BUILTIN_METHOD_TEST_CASE_ARG2(LastIndexOf, obj, 5, +0.0, 6);
927
928 // Expects undefined to be found
929 // arr.indexOf() == 12, where the first argument is undefined
930 ARRAY_BUILTIN_METHOD_TEST_CASE_ARG0(LastIndexOf, obj, 12);
931 }
932
933 // new Array().Pop()
HWTEST_F_L0(BuiltinsSharedArrayTest,Pop)934 HWTEST_F_L0(BuiltinsSharedArrayTest, Pop)
935 {
936 JSHandle<JSTaggedValue> lengthKeyHandle = thread->GlobalConstants()->GetHandledLengthString();
937 JSSharedArray *arr = JSSharedArray::Cast(JSSharedArray::ArrayCreate(thread, JSTaggedNumber(0)) \
938 .GetTaggedValue().GetTaggedObject());
939 EXPECT_TRUE(arr != nullptr);
940 JSHandle<JSObject> obj(thread, arr);
941 EXPECT_EQ(JSSharedArray::GetProperty(thread, JSHandle<JSTaggedValue>(obj), lengthKeyHandle,
942 SCheckMode::SKIP).GetValue()->GetInt(), 0);
943
944 auto ecmaRuntimeCallInfo1 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 4);
945 ecmaRuntimeCallInfo1->SetFunction(JSTaggedValue::Undefined());
946 ecmaRuntimeCallInfo1->SetThis(obj.GetTaggedValue());
947
948 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo1);
949 JSTaggedValue result = Array::Pop(ecmaRuntimeCallInfo1);
950 TestHelper::TearDownFrame(thread, prev);
951 ASSERT_EQ(result.GetRawData(), JSTaggedValue::VALUE_UNDEFINED);
952 ASSERT_EQ(result.GetRawData(), JSTaggedValue::VALUE_UNDEFINED);
953
954 JSHandle<JSTaggedValue> key0(thread, JSTaggedValue(0));
955 PropertyDescriptor desc0(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(1)), true, true, true);
956 JSSharedArray::DefineOwnProperty(thread, obj, key0, desc0, SCheckMode::SKIP);
957 JSHandle<JSTaggedValue> key1(thread, JSTaggedValue(1));
958 PropertyDescriptor desc1(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(2)), true, true, true);
959 JSSharedArray::DefineOwnProperty(thread, obj, key1, desc1, SCheckMode::SKIP);
960 JSHandle<JSTaggedValue> key2(thread, JSTaggedValue(2));
961 PropertyDescriptor desc2(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(3)), true, true, true);
962 JSSharedArray::DefineOwnProperty(thread, obj, key2, desc2, SCheckMode::SKIP);
963
964 auto ecmaRuntimeCallInfo2 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 4);
965 ecmaRuntimeCallInfo2->SetFunction(JSTaggedValue::Undefined());
966 ecmaRuntimeCallInfo2->SetThis(obj.GetTaggedValue());
967
968 prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo2);
969 result = Array::Pop(ecmaRuntimeCallInfo2);
970 TestHelper::TearDownFrame(thread, prev);
971 ASSERT_EQ(result.GetRawData(), JSTaggedValue(3).GetRawData());
972 }
973
974 // new Array(1,2,3).Push(...items)
HWTEST_F_L0(BuiltinsSharedArrayTest,Push)975 HWTEST_F_L0(BuiltinsSharedArrayTest, Push)
976 {
977 JSHandle<JSTaggedValue> lengthKeyHandle = thread->GlobalConstants()->GetHandledLengthString();
978 JSSharedArray *arr = JSSharedArray::Cast(JSSharedArray::ArrayCreate(thread, JSTaggedNumber(0)) \
979 .GetTaggedValue().GetTaggedObject());
980 EXPECT_TRUE(arr != nullptr);
981 JSHandle<JSObject> obj(thread, arr);
982 EXPECT_EQ(JSSharedArray::GetProperty(thread, JSHandle<JSTaggedValue>(obj), lengthKeyHandle, SCheckMode::SKIP) \
983 .GetValue()->GetInt(), 0);
984
985 JSHandle<JSTaggedValue> key0(thread, JSTaggedValue(0));
986 PropertyDescriptor desc0(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(1)), true, true, true);
987 JSSharedArray::DefineOwnProperty(thread, obj, key0, desc0, SCheckMode::SKIP);
988 JSHandle<JSTaggedValue> key1(thread, JSTaggedValue(1));
989 PropertyDescriptor desc1(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(2)), true, true, true);
990 JSSharedArray::DefineOwnProperty(thread, obj, key1, desc1, SCheckMode::SKIP);
991 JSHandle<JSTaggedValue> key2(thread, JSTaggedValue(2));
992 PropertyDescriptor desc2(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(3)), true, true, true);
993 JSSharedArray::DefineOwnProperty(thread, obj, key2, desc2, SCheckMode::SKIP);
994
995 auto ecmaRuntimeCallInfo1 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 8);
996 ecmaRuntimeCallInfo1->SetFunction(JSTaggedValue::Undefined());
997 ecmaRuntimeCallInfo1->SetThis(obj.GetTaggedValue());
998 ecmaRuntimeCallInfo1->SetCallArg(0, JSTaggedValue(static_cast<int32_t>(4)));
999 ecmaRuntimeCallInfo1->SetCallArg(1, JSTaggedValue(static_cast<int32_t>(5)));
1000
1001 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo1);
1002 JSTaggedValue result = Array::Push(ecmaRuntimeCallInfo1);
1003 TestHelper::TearDownFrame(thread, prev);
1004 ASSERT_EQ(result.GetNumber(), 5);
1005
1006 EXPECT_EQ(JSSharedArray::GetProperty(thread, JSHandle<JSTaggedValue>(obj), lengthKeyHandle,
1007 SCheckMode::SKIP).GetValue()->GetInt(), 5);
1008 JSHandle<JSTaggedValue> key3(thread, JSTaggedValue(3));
1009 EXPECT_EQ(JSSharedArray::GetProperty(thread, JSHandle<JSTaggedValue>(obj), key3, SCheckMode::SKIP) \
1010 .GetValue()->GetInt(), 4);
1011 JSHandle<JSTaggedValue> key4(thread, JSTaggedValue(4));
1012 EXPECT_EQ(JSSharedArray::GetProperty(thread, JSHandle<JSTaggedValue>(obj), key4, SCheckMode::SKIP) \
1013 .GetValue()->GetInt(), 5);
1014 }
1015
HWTEST_F_L0(BuiltinsSharedArrayTest,DefineOwnProperty_Array)1016 HWTEST_F_L0(BuiltinsSharedArrayTest, DefineOwnProperty_Array)
1017 {
1018 JSArray *arr = JSArray::Cast(JSArray::ArrayCreate(thread, JSTaggedNumber(0)) \
1019 .GetTaggedValue().GetTaggedObject());
1020 EXPECT_TRUE(arr != nullptr);
1021 JSHandle<JSObject> obj(thread, arr);
1022
1023 JSHandle<JSTaggedValue> key0(thread, JSTaggedValue(0));
1024 PropertyDescriptor desc0(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(arr)), true, true, true);
1025 bool res = JSSharedArray::DefineOwnProperty(thread, obj, key0, desc0, SCheckMode::SKIP);
1026 ASSERT_TRUE(!res);
1027 }
1028
HWTEST_F_L0(BuiltinsSharedArrayTest,Reduce)1029 HWTEST_F_L0(BuiltinsSharedArrayTest, Reduce)
1030 {
1031 auto ecmaVM = thread->GetEcmaVM();
1032 JSHandle<GlobalEnv> env = ecmaVM->GetGlobalEnv();
1033 ObjectFactory *factory = ecmaVM->GetFactory();
1034
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<JSObject> obj(thread, arr);
1040 EXPECT_EQ(JSSharedArray::GetProperty(thread, JSHandle<JSTaggedValue>(obj), lengthKeyHandle, SCheckMode::SKIP) \
1041 .GetValue()->GetInt(), 0);
1042
1043 std::vector<int> descVals{1, 2, 3};
1044 auto keys = SharedArrayDefineOwnPropertyTest(thread, obj, descVals);
1045
1046 JSHandle<JSFunction> func = factory->NewJSFunction(env, reinterpret_cast<void *>(TestClass::TestReduceFunc));
1047
1048 auto ecmaRuntimeCallInfo1 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 8);
1049 ecmaRuntimeCallInfo1->SetFunction(JSTaggedValue::Undefined());
1050 ecmaRuntimeCallInfo1->SetThis(obj.GetTaggedValue());
1051 ecmaRuntimeCallInfo1->SetCallArg(0, func.GetTaggedValue());
1052 ecmaRuntimeCallInfo1->SetCallArg(1, JSTaggedValue(static_cast<int32_t>(10)));
1053
1054 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo1);
1055 JSTaggedValue result = Array::Reduce(ecmaRuntimeCallInfo1);
1056 TestHelper::TearDownFrame(thread, prev);
1057 ASSERT_EQ(result.GetRawData(), JSTaggedValue(16).GetRawData());
1058 }
1059
HWTEST_F_L0(BuiltinsSharedArrayTest,ReduceRight_One)1060 HWTEST_F_L0(BuiltinsSharedArrayTest, ReduceRight_One)
1061 {
1062 auto ecmaVM = thread->GetEcmaVM();
1063 JSHandle<GlobalEnv> env = ecmaVM->GetGlobalEnv();
1064 ObjectFactory *factory = ecmaVM->GetFactory();
1065
1066 JSHandle<JSTaggedValue> lengthKeyHandle = thread->GlobalConstants()->GetHandledLengthString();
1067 JSSharedArray *arr = JSSharedArray::Cast(
1068 JSSharedArray::ArrayCreate(thread, JSTaggedNumber(0)).GetTaggedValue().GetTaggedObject());
1069 EXPECT_TRUE(arr != nullptr);
1070 JSHandle<JSObject> obj(thread, arr);
1071 EXPECT_EQ(JSSharedArray::GetProperty(thread, JSHandle<JSTaggedValue>(obj), lengthKeyHandle,
1072 SCheckMode::SKIP).GetValue()->GetInt(), 0);
1073
1074 std::vector<int> descVals{1, 2, 3};
1075 auto keys = SharedArrayDefineOwnPropertyTest(thread, obj, descVals);
1076
1077 JSHandle<JSFunction> func = factory->NewJSFunction(env, reinterpret_cast<void *>(TestClass::TestReduceRightFunc));
1078
1079 auto ecmaRuntimeCallInfo1 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 8);
1080 ecmaRuntimeCallInfo1->SetFunction(JSTaggedValue::Undefined());
1081 ecmaRuntimeCallInfo1->SetThis(obj.GetTaggedValue());
1082 ecmaRuntimeCallInfo1->SetCallArg(0, func.GetTaggedValue());
1083 // set initial value to 10
1084 ecmaRuntimeCallInfo1->SetCallArg(1, JSTaggedValue(static_cast<int32_t>(10)));
1085
1086 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo1);
1087 JSTaggedValue result = Array::ReduceRight(ecmaRuntimeCallInfo1);
1088 TestHelper::TearDownFrame(thread, prev);
1089 ASSERT_EQ(result.GetRawData(), JSTaggedValue(16).GetRawData());
1090 }
1091
HWTEST_F_L0(BuiltinsSharedArrayTest,ReduceRight_Two)1092 HWTEST_F_L0(BuiltinsSharedArrayTest, ReduceRight_Two)
1093 {
1094 auto ecmaVM = thread->GetEcmaVM();
1095 JSHandle<GlobalEnv> env = ecmaVM->GetGlobalEnv();
1096 ObjectFactory *factory = ecmaVM->GetFactory();
1097
1098 JSHandle<JSTaggedValue> lengthKeyHandle = thread->GlobalConstants()->GetHandledLengthString();
1099 JSSharedArray *arr = JSSharedArray::Cast(
1100 JSSharedArray::ArrayCreate(thread, JSTaggedNumber(0)).GetTaggedValue().GetTaggedObject());
1101 EXPECT_TRUE(arr != nullptr);
1102 JSHandle<JSObject> obj(thread, arr);
1103 EXPECT_EQ(JSSharedArray::GetProperty(thread, JSHandle<JSTaggedValue>(obj), lengthKeyHandle,
1104 SCheckMode::SKIP).GetValue()->GetInt(), 0);
1105
1106 std::vector<int> descVals{1, 2, 3};
1107 auto keys = SharedArrayDefineOwnPropertyTest(thread, obj, descVals);
1108
1109 JSHandle<JSFunction> func = factory->NewJSFunction(env, reinterpret_cast<void *>(TestClass::TestReduceRightFunc));
1110 // no initial value
1111 auto ecmaRuntimeCallInfo1 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 6);
1112 ecmaRuntimeCallInfo1->SetFunction(JSTaggedValue::Undefined());
1113 ecmaRuntimeCallInfo1->SetThis(obj.GetTaggedValue());
1114 ecmaRuntimeCallInfo1->SetCallArg(0, func.GetTaggedValue());
1115
1116 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo1);
1117 JSTaggedValue result = Array::ReduceRight(ecmaRuntimeCallInfo1);
1118 TestHelper::TearDownFrame(thread, prev);
1119 ASSERT_EQ(result.GetRawData(), JSTaggedValue(6).GetRawData());
1120 }
1121
HWTEST_F_L0(BuiltinsSharedArrayTest,Shift)1122 HWTEST_F_L0(BuiltinsSharedArrayTest, Shift)
1123 {
1124 JSHandle<JSTaggedValue> lengthKeyHandle = thread->GlobalConstants()->GetHandledLengthString();
1125 JSSharedArray *arr = JSSharedArray::Cast(JSSharedArray::ArrayCreate(thread, JSTaggedNumber(0)) \
1126 .GetTaggedValue().GetTaggedObject());
1127 EXPECT_TRUE(arr != nullptr);
1128 JSHandle<JSObject> obj(thread, arr);
1129 EXPECT_EQ(JSSharedArray::GetProperty(thread, JSHandle<JSTaggedValue>(obj), lengthKeyHandle, SCheckMode::SKIP) \
1130 .GetValue()->GetInt(), 0);
1131
1132 std::vector<int> descVals{1, 2, 3};
1133 auto keys = SharedArrayDefineOwnPropertyTest(thread, obj, descVals);
1134
1135 auto ecmaRuntimeCallInfo1 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 4);
1136 ecmaRuntimeCallInfo1->SetFunction(JSTaggedValue::Undefined());
1137 ecmaRuntimeCallInfo1->SetThis(obj.GetTaggedValue());
1138
1139 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo1);
1140 JSTaggedValue result = Array::Shift(ecmaRuntimeCallInfo1);
1141 TestHelper::TearDownFrame(thread, prev);
1142 ASSERT_EQ(result.GetRawData(), JSTaggedValue(1).GetRawData());
1143 }
1144
HWTEST_F_L0(BuiltinsSharedArrayTest,Sort)1145 HWTEST_F_L0(BuiltinsSharedArrayTest, Sort)
1146 {
1147 JSHandle<JSTaggedValue> lengthKeyHandle = thread->GlobalConstants()->GetHandledLengthString();
1148 JSSharedArray *arr = JSSharedArray::Cast(JSSharedArray::ArrayCreate(thread, JSTaggedNumber(0)) \
1149 .GetTaggedValue().GetTaggedObject());
1150 EXPECT_TRUE(arr != nullptr);
1151 JSHandle<JSObject> obj(thread, arr);
1152 EXPECT_EQ(JSSharedArray::GetProperty(thread, JSHandle<JSTaggedValue>(obj), lengthKeyHandle, SCheckMode::SKIP) \
1153 .GetValue()->GetInt(), 0);
1154
1155 std::vector<int> descVals{3, 2, 1};
1156 auto keys = SharedArrayDefineOwnPropertyTest(thread, obj, descVals);
1157
1158 auto ecmaRuntimeCallInfo1 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 4);
1159 ecmaRuntimeCallInfo1->SetFunction(JSTaggedValue::Undefined());
1160 ecmaRuntimeCallInfo1->SetThis(obj.GetTaggedValue());
1161
1162 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo1);
1163 JSTaggedValue result2 = Array::Sort(ecmaRuntimeCallInfo1);
1164 TestHelper::TearDownFrame(thread, prev);
1165
1166 EXPECT_TRUE(result2.IsECMAObject());
1167 JSHandle<JSTaggedValue> resultArr =
1168 JSHandle<JSTaggedValue>(thread, JSTaggedValue(static_cast<JSTaggedType>(result2.GetRawData())));
1169 EXPECT_EQ(JSSharedArray::GetProperty(thread, resultArr, keys[0], SCheckMode::SKIP).GetValue()->GetInt(), 1);
1170 EXPECT_EQ(JSSharedArray::GetProperty(thread, resultArr, keys[1], SCheckMode::SKIP).GetValue()->GetInt(), 2);
1171 EXPECT_EQ(JSSharedArray::GetProperty(thread, resultArr, keys[2], SCheckMode::SKIP).GetValue()->GetInt(), 3);
1172 }
1173
HWTEST_F_L0(BuiltinsSharedArrayTest,Sort_Exception)1174 HWTEST_F_L0(BuiltinsSharedArrayTest, Sort_Exception)
1175 {
1176 JSHandle<JSTaggedValue> lengthKeyHandle = thread->GlobalConstants()->GetHandledLengthString();
1177 JSSharedArray *arr = JSSharedArray::Cast(JSSharedArray::ArrayCreate(thread, JSTaggedNumber(0)) \
1178 .GetTaggedValue().GetTaggedObject());
1179 EXPECT_TRUE(arr != nullptr);
1180 JSHandle<JSObject> obj(thread, arr);
1181 EXPECT_EQ(JSSharedArray::GetProperty(thread, JSHandle<JSTaggedValue>(obj), lengthKeyHandle, SCheckMode::SKIP) \
1182 .GetValue()->GetInt(), 0);
1183
1184 auto ecmaRuntimeCallInfo1 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 4);
1185 ecmaRuntimeCallInfo1->SetFunction(JSTaggedValue::Undefined());
1186 ecmaRuntimeCallInfo1->SetThis(obj.GetTaggedValue());
1187
1188 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo1);
1189 JSTaggedValue result2 = Array::Sort(ecmaRuntimeCallInfo1);
1190 TestHelper::TearDownFrame(thread, prev);
1191
1192 EXPECT_TRUE(result2.IsECMAObject());
1193 }
1194
HWTEST_F_L0(BuiltinsSharedArrayTest,Sort_Exception_1)1195 HWTEST_F_L0(BuiltinsSharedArrayTest, Sort_Exception_1)
1196 {
1197 JSHandle<JSTaggedValue> lengthKeyHandle = thread->GlobalConstants()->GetHandledLengthString();
1198 JSSharedArray *arr = JSSharedArray::Cast(JSSharedArray::ArrayCreate(thread, JSTaggedNumber(1)) \
1199 .GetTaggedValue().GetTaggedObject());
1200 EXPECT_TRUE(arr != nullptr);
1201 JSHandle<JSObject> obj(thread, arr);
1202 EXPECT_EQ(JSSharedArray::GetProperty(thread, JSHandle<JSTaggedValue>(obj), lengthKeyHandle, SCheckMode::SKIP) \
1203 .GetValue()->GetInt(), 1);
1204
1205 auto ecmaRuntimeCallInfo1 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 4);
1206 ecmaRuntimeCallInfo1->SetFunction(JSTaggedValue::Undefined());
1207 ecmaRuntimeCallInfo1->SetThis(obj.GetTaggedValue());
1208
1209 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo1);
1210 JSTaggedValue result2 = Array::Sort(ecmaRuntimeCallInfo1);
1211 TestHelper::TearDownFrame(thread, prev);
1212
1213 EXPECT_TRUE(result2.IsECMAObject());
1214 }
1215
HWTEST_F_L0(BuiltinsSharedArrayTest,Unshift)1216 HWTEST_F_L0(BuiltinsSharedArrayTest, Unshift)
1217 {
1218 JSHandle<JSTaggedValue> lengthKeyHandle = thread->GlobalConstants()->GetHandledLengthString();
1219 JSSharedArray *arr = JSSharedArray::Cast(JSSharedArray::ArrayCreate(thread, JSTaggedNumber(0)) \
1220 .GetTaggedValue().GetTaggedObject());
1221 EXPECT_TRUE(arr != nullptr);
1222 JSHandle<JSObject> obj(thread, arr);
1223 EXPECT_EQ(JSSharedArray::GetProperty(thread, JSHandle<JSTaggedValue>(obj), lengthKeyHandle, SCheckMode::SKIP) \
1224 .GetValue()->GetInt(), 0);
1225
1226 std::vector<int> descVals{1, 2, 3};
1227 auto keys = SharedArrayDefineOwnPropertyTest(thread, obj, descVals);
1228
1229 auto ecmaRuntimeCallInfo1 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 8);
1230 ecmaRuntimeCallInfo1->SetFunction(JSTaggedValue::Undefined());
1231 ecmaRuntimeCallInfo1->SetThis(obj.GetTaggedValue());
1232 ecmaRuntimeCallInfo1->SetCallArg(0, JSTaggedValue(static_cast<int32_t>(4)));
1233 ecmaRuntimeCallInfo1->SetCallArg(1, JSTaggedValue(static_cast<int32_t>(5)));
1234
1235 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo1);
1236 JSTaggedValue result = Array::Unshift(ecmaRuntimeCallInfo1);
1237 TestHelper::TearDownFrame(thread, prev);
1238
1239 ASSERT_EQ(result.GetRawData(), JSTaggedValue(static_cast<double>(5)).GetRawData());
1240
1241 EXPECT_EQ(JSSharedArray::GetProperty(thread, JSHandle<JSTaggedValue>(obj), lengthKeyHandle, SCheckMode::SKIP) \
1242 .GetValue()->GetInt(), 5);
1243 JSHandle<JSTaggedValue> key3(thread, JSTaggedValue(0));
1244 EXPECT_EQ(JSSharedArray::GetProperty(thread, JSHandle<JSTaggedValue>(obj), key3, SCheckMode::SKIP) \
1245 .GetValue()->GetInt(), 4);
1246 JSHandle<JSTaggedValue> key4(thread, JSTaggedValue(1));
1247 EXPECT_EQ(JSSharedArray::GetProperty(thread, JSHandle<JSTaggedValue>(obj), key4, SCheckMode::SKIP) \
1248 .GetValue()->GetInt(), 5);
1249 }
1250
HWTEST_F_L0(BuiltinsSharedArrayTest,Join)1251 HWTEST_F_L0(BuiltinsSharedArrayTest, Join)
1252 {
1253 JSHandle<JSTaggedValue> lengthKeyHandle = thread->GlobalConstants()->GetHandledLengthString();
1254 JSSharedArray *arr = JSSharedArray::Cast(JSSharedArray::ArrayCreate(thread, JSTaggedNumber(0)) \
1255 .GetTaggedValue().GetTaggedObject());
1256 EXPECT_TRUE(arr != nullptr);
1257 JSHandle<JSTaggedValue> obj(thread, arr);
1258 EXPECT_EQ(JSSharedArray::GetProperty(thread, obj, lengthKeyHandle, SCheckMode::SKIP).GetValue()->GetInt(), 0);
1259
1260 std::vector<int> descVals{2, 3, 4};
1261 auto keys = SharedArrayDefineOwnPropertyTest(thread, obj, descVals);
1262
1263 JSHandle<EcmaString> str = thread->GetEcmaVM()->GetFactory()->NewFromASCII("2,3,4");
1264 auto ecmaRuntimeCallInfo1 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 4);
1265 ecmaRuntimeCallInfo1->SetFunction(JSTaggedValue::Undefined());
1266 ecmaRuntimeCallInfo1->SetThis(obj.GetTaggedValue());
1267
1268 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo1);
1269 JSTaggedValue result = Array::Join(ecmaRuntimeCallInfo1);
1270 TestHelper::TearDownFrame(thread, prev);
1271 JSHandle<EcmaString> resultHandle(thread, reinterpret_cast<EcmaString *>(result.GetRawData()));
1272
1273 ASSERT_EQ(EcmaStringAccessor::Compare(instance, resultHandle, str), 0);
1274 }
1275
HWTEST_F_L0(BuiltinsSharedArrayTest,ToString)1276 HWTEST_F_L0(BuiltinsSharedArrayTest, ToString)
1277 {
1278 std::vector<int> descVals{2, 3, 4};
1279 JSHandle<JSTaggedValue> lengthKeyHandle = thread->GlobalConstants()->GetHandledLengthString();
1280 JSSharedArray *arr = JSSharedArray::Cast(JSSharedArray::ArrayCreate(thread, JSTaggedNumber(0)) \
1281 .GetTaggedValue().GetTaggedObject());
1282 EXPECT_TRUE(arr != nullptr);
1283 JSHandle<JSTaggedValue> obj(thread, arr);
1284 EXPECT_EQ(JSSharedArray::GetProperty(thread, obj, lengthKeyHandle, SCheckMode::SKIP).GetValue()->GetInt(), 0);
1285 auto keys = SharedArrayDefineOwnPropertyTest(thread, obj, descVals);
1286
1287 JSHandle<EcmaString> str = thread->GetEcmaVM()->GetFactory()->NewFromASCII("2,3,4");
1288 auto ecmaRuntimeCallInfo1 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 4);
1289 ecmaRuntimeCallInfo1->SetFunction(JSTaggedValue::Undefined());
1290 ecmaRuntimeCallInfo1->SetThis(obj.GetTaggedValue());
1291
1292 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo1);
1293 JSTaggedValue result = Array::ToString(ecmaRuntimeCallInfo1);
1294 TestHelper::TearDownFrame(thread, prev);
1295 JSHandle<EcmaString> resultHandle(thread, reinterpret_cast<EcmaString *>(result.GetRawData()));
1296
1297 ASSERT_EQ(EcmaStringAccessor::Compare(instance, resultHandle, str), 0);
1298 }
1299
HWTEST_F_L0(BuiltinsSharedArrayTest,Includes_one)1300 HWTEST_F_L0(BuiltinsSharedArrayTest, Includes_one)
1301 {
1302 JSHandle<JSTaggedValue> lengthKeyHandle = thread->GlobalConstants()->GetHandledLengthString();
1303 JSSharedArray *arr = JSSharedArray::Cast(JSSharedArray::ArrayCreate(thread, JSTaggedNumber(0)) \
1304 .GetTaggedValue().GetTaggedObject());
1305 EXPECT_TRUE(arr != nullptr);
1306 JSHandle<JSTaggedValue> obj(thread, arr);
1307 std::vector<int> descVals{2, 3, 4};
1308 EXPECT_EQ(JSSharedArray::GetProperty(thread, obj, lengthKeyHandle, SCheckMode::SKIP).GetValue()->GetInt(), 0);
1309 auto keys = SharedArrayDefineOwnPropertyTest(thread, obj, descVals);
1310
1311 auto ecmaRuntimeCallInfo1 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 6);
1312 ecmaRuntimeCallInfo1->SetFunction(JSTaggedValue::Undefined());
1313 ecmaRuntimeCallInfo1->SetThis(obj.GetTaggedValue());
1314 ecmaRuntimeCallInfo1->SetCallArg(0, JSTaggedValue(static_cast<int32_t>(2)));
1315
1316 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo1);
1317 [[maybe_unused]] JSTaggedValue result = Array::Includes(ecmaRuntimeCallInfo1);
1318 TestHelper::TearDownFrame(thread, prev);
1319
1320 ASSERT_TRUE(result.JSTaggedValue::ToBoolean()); // new Int8Array[2,3,4].includes(2)
1321
1322 auto ecmaRuntimeCallInfo2 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 6);
1323 ecmaRuntimeCallInfo2->SetFunction(JSTaggedValue::Undefined());
1324 ecmaRuntimeCallInfo2->SetThis(obj.GetTaggedValue());
1325 ecmaRuntimeCallInfo2->SetCallArg(0, JSTaggedValue(static_cast<int32_t>(1)));
1326
1327 prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo2);
1328 result = Array::Includes(ecmaRuntimeCallInfo2);
1329 TestHelper::TearDownFrame(thread, prev);
1330
1331 ASSERT_TRUE(!result.JSTaggedValue::ToBoolean()); // new Int8Array[2,3,4].includes(1)
1332
1333 auto ecmaRuntimeCallInfo3 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 8);
1334 ecmaRuntimeCallInfo3->SetFunction(JSTaggedValue::Undefined());
1335 ecmaRuntimeCallInfo3->SetThis(obj.GetTaggedValue());
1336 ecmaRuntimeCallInfo3->SetCallArg(0, JSTaggedValue(static_cast<int32_t>(3)));
1337 ecmaRuntimeCallInfo3->SetCallArg(1, JSTaggedValue(static_cast<int32_t>(1)));
1338
1339 prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo3);
1340 result = Array::Includes(ecmaRuntimeCallInfo3);
1341 TestHelper::TearDownFrame(thread, prev);
1342
1343 ASSERT_TRUE(result.JSTaggedValue::ToBoolean()); // new Int8Array[2,3,4].includes(3, 1)
1344 }
1345
HWTEST_F_L0(BuiltinsSharedArrayTest,Includes_two)1346 HWTEST_F_L0(BuiltinsSharedArrayTest, Includes_two)
1347 {
1348 JSHandle<JSTaggedValue> lengthKeyHandle = thread->GlobalConstants()->GetHandledLengthString();
1349 JSSharedArray *arr = JSSharedArray::Cast(JSSharedArray::ArrayCreate(thread, JSTaggedNumber(0)) \
1350 .GetTaggedValue().GetTaggedObject());
1351 EXPECT_TRUE(arr != nullptr);
1352 JSHandle<JSTaggedValue> obj(thread, arr);
1353 std::vector<int> descVals{2, 3, 4};
1354 EXPECT_EQ(JSSharedArray::GetProperty(thread, obj, lengthKeyHandle, SCheckMode::SKIP).GetValue()->GetInt(), 0);
1355 auto keys = SharedArrayDefineOwnPropertyTest(thread, obj, descVals);
1356
1357 auto ecmaRuntimeCallInfo4 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 8);
1358 ecmaRuntimeCallInfo4->SetFunction(JSTaggedValue::Undefined());
1359 ecmaRuntimeCallInfo4->SetThis(obj.GetTaggedValue());
1360 ecmaRuntimeCallInfo4->SetCallArg(0, JSTaggedValue(static_cast<int32_t>(2)));
1361 ecmaRuntimeCallInfo4->SetCallArg(1, JSTaggedValue(static_cast<int32_t>(5)));
1362
1363 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo4);
1364 [[maybe_unused]] JSTaggedValue result = Array::Includes(ecmaRuntimeCallInfo4);
1365 TestHelper::TearDownFrame(thread, prev);
1366
1367 ASSERT_TRUE(!result.JSTaggedValue::ToBoolean()); // new Int8Array[2,3,4].includes(2, 5)
1368
1369 auto ecmaRuntimeCallInfo5 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 8);
1370 ecmaRuntimeCallInfo5->SetFunction(JSTaggedValue::Undefined());
1371 ecmaRuntimeCallInfo5->SetThis(obj.GetTaggedValue());
1372 ecmaRuntimeCallInfo5->SetCallArg(0, JSTaggedValue(static_cast<int32_t>(2)));
1373 ecmaRuntimeCallInfo5->SetCallArg(1, JSTaggedValue(static_cast<int32_t>(-2)));
1374
1375 prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo5);
1376 result = Array::Includes(ecmaRuntimeCallInfo5);
1377 TestHelper::TearDownFrame(thread, prev);
1378
1379 ASSERT_TRUE(!result.JSTaggedValue::ToBoolean()); // new Int8Array[2,3,4].includes(2, -2)
1380 }
1381
HWTEST_F_L0(BuiltinsSharedArrayTest,At_ONE)1382 HWTEST_F_L0(BuiltinsSharedArrayTest, At_ONE)
1383 {
1384 JSHandle<JSTaggedValue> lengthKeyHandle = thread->GlobalConstants()->GetHandledLengthString();
1385 JSSharedArray *arr = JSSharedArray::Cast(JSSharedArray::ArrayCreate(thread, JSTaggedNumber(0)) \
1386 .GetTaggedValue().GetTaggedObject());
1387 EXPECT_TRUE(arr != nullptr);
1388 std::vector<int> descVals{2, 3, 4};
1389 JSHandle<JSTaggedValue> obj(thread, arr);
1390 EXPECT_EQ(JSSharedArray::GetProperty(thread, obj, lengthKeyHandle, SCheckMode::SKIP).GetValue()->GetInt(), 0);
1391
1392 auto keys = SharedArrayDefineOwnPropertyTest(thread, obj, descVals);
1393
1394 auto ecmaRuntimeCallInfo1 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 6);
1395 ecmaRuntimeCallInfo1->SetFunction(JSTaggedValue::Undefined());
1396 ecmaRuntimeCallInfo1->SetThis(obj.GetTaggedValue());
1397 ecmaRuntimeCallInfo1->SetCallArg(0, JSTaggedValue(static_cast<int32_t>(0)));
1398 [[maybe_unused]] auto prev1 = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo1);
1399 JSTaggedValue result = Array::At(ecmaRuntimeCallInfo1);
1400 TestHelper::TearDownFrame(thread, prev1);
1401 ASSERT_EQ(result.GetRawData(), JSTaggedValue(2).GetRawData());
1402
1403 auto ecmaRuntimeCallInfo2 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 6);
1404 ecmaRuntimeCallInfo2->SetFunction(JSTaggedValue::Undefined());
1405 ecmaRuntimeCallInfo2->SetThis(obj.GetTaggedValue());
1406 ecmaRuntimeCallInfo2->SetCallArg(0, JSTaggedValue(static_cast<int32_t>(2)));
1407 [[maybe_unused]] auto prev2 = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo2);
1408 result = Array::At(ecmaRuntimeCallInfo2);
1409 TestHelper::TearDownFrame(thread, prev2);
1410 ASSERT_EQ(result.GetRawData(), JSTaggedValue(4).GetRawData());
1411
1412 auto ecmaRuntimeCallInfo3 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 6);
1413 ecmaRuntimeCallInfo3->SetFunction(JSTaggedValue::Undefined());
1414 ecmaRuntimeCallInfo3->SetThis(obj.GetTaggedValue());
1415 ecmaRuntimeCallInfo3->SetCallArg(0, JSTaggedValue(static_cast<int32_t>(3)));
1416 [[maybe_unused]] auto prev3 = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo3);
1417 result = Array::At(ecmaRuntimeCallInfo3);
1418 TestHelper::TearDownFrame(thread, prev3);
1419 ASSERT_EQ(result, JSTaggedValue::Undefined());
1420 }
1421
HWTEST_F_L0(BuiltinsSharedArrayTest,At_TWO)1422 HWTEST_F_L0(BuiltinsSharedArrayTest, At_TWO)
1423 {
1424 JSHandle<JSTaggedValue> lengthKeyHandle = thread->GlobalConstants()->GetHandledLengthString();
1425 JSSharedArray *arr = JSSharedArray::Cast(JSSharedArray::ArrayCreate(thread, JSTaggedNumber(0)) \
1426 .GetTaggedValue().GetTaggedObject());
1427 EXPECT_TRUE(arr != nullptr);
1428 std::vector<int> descVals{2, 3, 4};
1429 JSHandle<JSTaggedValue> obj(thread, arr);
1430 EXPECT_EQ(JSSharedArray::GetProperty(thread, obj, lengthKeyHandle, SCheckMode::SKIP).GetValue()->GetInt(), 0);
1431
1432 auto keys = SharedArrayDefineOwnPropertyTest(thread, obj, descVals);
1433
1434 auto ecmaRuntimeCallInfo4 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 6);
1435 ecmaRuntimeCallInfo4->SetFunction(JSTaggedValue::Undefined());
1436 ecmaRuntimeCallInfo4->SetThis(obj.GetTaggedValue());
1437 ecmaRuntimeCallInfo4->SetCallArg(0, JSTaggedValue(static_cast<int32_t>(-1)));
1438 [[maybe_unused]] auto prev4 = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo4);
1439 JSTaggedValue result = Array::At(ecmaRuntimeCallInfo4);
1440 TestHelper::TearDownFrame(thread, prev4);
1441 ASSERT_EQ(result.GetRawData(), JSTaggedValue(4).GetRawData());
1442
1443 auto ecmaRuntimeCallInfo5 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 6);
1444 ecmaRuntimeCallInfo5->SetFunction(JSTaggedValue::Undefined());
1445 ecmaRuntimeCallInfo5->SetThis(obj.GetTaggedValue());
1446 ecmaRuntimeCallInfo5->SetCallArg(0, JSTaggedValue(static_cast<int32_t>(-3)));
1447 [[maybe_unused]] auto prev5 = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo5);
1448 result = Array::At(ecmaRuntimeCallInfo5);
1449 TestHelper::TearDownFrame(thread, prev5);
1450 ASSERT_EQ(result.GetRawData(), JSTaggedValue(2).GetRawData());
1451
1452 auto ecmaRuntimeCallInfo6 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 6);
1453 ecmaRuntimeCallInfo6->SetFunction(JSTaggedValue::Undefined());
1454 ecmaRuntimeCallInfo6->SetThis(obj.GetTaggedValue());
1455 ecmaRuntimeCallInfo6->SetCallArg(0, JSTaggedValue(static_cast<int32_t>(-4)));
1456 [[maybe_unused]] auto prev6 = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo6);
1457 result = Array::At(ecmaRuntimeCallInfo6);
1458 TestHelper::TearDownFrame(thread, prev6);
1459 ASSERT_EQ(result, JSTaggedValue::Undefined());
1460 }
1461
HWTEST_F_L0(BuiltinsSharedArrayTest,Create1)1462 HWTEST_F_L0(BuiltinsSharedArrayTest, Create1)
1463 {
1464 static int32_t len = 3;
1465 JSSharedArray *arr = JSSharedArray::Cast(JSSharedArray::ArrayCreate(thread, JSTaggedNumber(0))->GetTaggedObject());
1466 EXPECT_TRUE(arr != nullptr);
1467 JSHandle<JSObject> obj(thread, arr);
1468 JSHandle<JSTaggedValue> lengthKeyHandle = thread->GlobalConstants()->GetHandledLengthString();
1469 EXPECT_EQ(JSSharedArray::GetProperty(thread, JSHandle<JSTaggedValue>(obj), lengthKeyHandle, SCheckMode::SKIP) \
1470 .GetValue()->GetInt(), 0);
1471
1472 JSHandle<JSFunction> array(thread->GetEcmaVM()->GetGlobalEnv()->GetSharedArrayFunction());
1473 auto ecmaRuntimeCallInfo1 = TestHelper::CreateEcmaRuntimeCallInfo(thread, array.GetTaggedValue(), 8);
1474 ecmaRuntimeCallInfo1->SetFunction(array.GetTaggedValue());
1475 ecmaRuntimeCallInfo1->SetThis(JSTaggedValue::Undefined());
1476 ecmaRuntimeCallInfo1->SetCallArg(0, JSTaggedValue(len));
1477 ecmaRuntimeCallInfo1->SetCallArg(1, obj.GetTaggedValue());
1478
1479 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo1);
1480 JSTaggedValue result = Array::Create(ecmaRuntimeCallInfo1);
1481 TestHelper::TearDownFrame(thread, prev);
1482 ASSERT_TRUE(result.IsECMAObject());
1483 EXPECT_EQ(JSSharedArray::Cast(result.GetTaggedObject())->GetArrayLength(), len);
1484 }
1485
HWTEST_F_L0(BuiltinsSharedArrayTest,Create2)1486 HWTEST_F_L0(BuiltinsSharedArrayTest, Create2)
1487 {
1488 static double len = 100;
1489 JSSharedArray *arr = JSSharedArray::Cast(JSSharedArray::ArrayCreate(thread, JSTaggedNumber(0))->GetTaggedObject());
1490 EXPECT_TRUE(arr != nullptr);
1491 JSHandle<JSObject> obj(thread, arr);
1492 JSHandle<JSTaggedValue> lengthKeyHandle = thread->GlobalConstants()->GetHandledLengthString();
1493 EXPECT_EQ(JSSharedArray::GetProperty(thread, JSHandle<JSTaggedValue>(obj), lengthKeyHandle, SCheckMode::SKIP) \
1494 .GetValue()->GetInt(), 0);
1495
1496 JSHandle<JSFunction> array(thread->GetEcmaVM()->GetGlobalEnv()->GetSharedArrayFunction());
1497 auto ecmaRuntimeCallInfo1 = TestHelper::CreateEcmaRuntimeCallInfo(thread, array.GetTaggedValue(), 8);
1498 ecmaRuntimeCallInfo1->SetFunction(array.GetTaggedValue());
1499 ecmaRuntimeCallInfo1->SetThis(JSTaggedValue::Undefined());
1500 ecmaRuntimeCallInfo1->SetCallArg(0, JSTaggedValue(len));
1501 ecmaRuntimeCallInfo1->SetCallArg(1, obj.GetTaggedValue());
1502
1503 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo1);
1504 JSTaggedValue result = Array::Create(ecmaRuntimeCallInfo1);
1505 TestHelper::TearDownFrame(thread, prev);
1506 ASSERT_TRUE(result.IsECMAObject());
1507 EXPECT_EQ(JSSharedArray::Cast(result.GetTaggedObject())->GetArrayLength(), len);
1508 }
1509
1510 // Array.isArray(arg)
HWTEST_F_L0(BuiltinsSharedArrayTest,IsArray)1511 HWTEST_F_L0(BuiltinsSharedArrayTest, IsArray)
1512 {
1513 JSSharedArray *arr = JSSharedArray::Cast(JSSharedArray::ArrayCreate(thread, JSTaggedNumber(0))->GetTaggedObject());
1514 EXPECT_TRUE(arr != nullptr);
1515 JSHandle<JSObject> obj(thread, arr);
1516 JSHandle<JSTaggedValue> lengthKeyHandle = thread->GlobalConstants()->GetHandledLengthString();
1517 EXPECT_EQ(JSSharedArray::GetProperty(thread, JSHandle<JSTaggedValue>(obj), lengthKeyHandle, SCheckMode::SKIP)
1518 .GetValue()
1519 ->GetInt(),
1520 0);
1521
1522 auto ecmaRuntimeCallInfo1 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 6);
1523 ecmaRuntimeCallInfo1->SetFunction(JSTaggedValue::Undefined());
1524 ecmaRuntimeCallInfo1->SetThis(JSTaggedValue::Undefined());
1525 ecmaRuntimeCallInfo1->SetCallArg(0, obj.GetTaggedValue());
1526
1527 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo1);
1528 JSTaggedValue result = Array::IsArray(ecmaRuntimeCallInfo1);
1529 TestHelper::TearDownFrame(thread, prev);
1530 ASSERT_EQ(result.GetRawData(), JSTaggedValue::True().GetRawData());
1531
1532 auto ecmaRuntimeCallInfo2 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 6);
1533 ecmaRuntimeCallInfo2->SetFunction(JSTaggedValue::Undefined());
1534 ecmaRuntimeCallInfo2->SetThis(JSTaggedValue::Undefined());
1535 ecmaRuntimeCallInfo2->SetCallArg(0, JSTaggedValue(static_cast<int32_t>(1)));
1536
1537 prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo2);
1538 result = Array::IsArray(ecmaRuntimeCallInfo2);
1539 TestHelper::TearDownFrame(thread, prev);
1540 ASSERT_EQ(result.GetRawData(), JSTaggedValue::False().GetRawData());
1541 }
1542
HWTEST_F_L0(BuiltinsSharedArrayTest,GetIterator)1543 HWTEST_F_L0(BuiltinsSharedArrayTest, GetIterator)
1544 {
1545 JSSharedArray *arr = JSSharedArray::Cast(JSSharedArray::ArrayCreate(thread, JSTaggedNumber(0))->GetTaggedObject());
1546 EXPECT_TRUE(arr != nullptr);
1547 JSHandle<JSTaggedValue> obj(thread, arr);
1548
1549 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 4);
1550 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
1551 ecmaRuntimeCallInfo->SetThis(obj.GetTaggedValue());
1552 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo);
1553
1554 // test Values()
1555 JSTaggedValue result = Array::Values(ecmaRuntimeCallInfo);
1556 JSHandle<JSSharedArrayIterator> iter(thread, result);
1557 EXPECT_EQ(IterationKind::VALUE, iter->GetIterationKind());
1558
1559 // test Keys()
1560 JSTaggedValue result1 = Array::Keys(ecmaRuntimeCallInfo);
1561 JSHandle<JSArrayIterator> iter1(thread, result1);
1562 EXPECT_EQ(IterationKind::KEY, iter1->GetIterationKind());
1563
1564 // test entries()
1565 JSTaggedValue result2 = Array::Entries(ecmaRuntimeCallInfo);
1566 JSHandle<JSSharedArrayIterator> iter2(thread, result2);
1567 EXPECT_EQ(IterationKind::KEY_AND_VALUE, iter2->GetIterationKind());
1568 TestHelper::TearDownFrame(thread, prev);
1569 }
1570
1571
HWTEST_F_L0(BuiltinsSharedArrayTest,Unscopables)1572 HWTEST_F_L0(BuiltinsSharedArrayTest, Unscopables)
1573 {
1574 JSHandle<JSFunction> array(thread->GetEcmaVM()->GetGlobalEnv()->GetSharedArrayFunction());
1575 auto ecmaRuntimeCallInfo1 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 8);
1576 ecmaRuntimeCallInfo1->SetFunction(JSTaggedValue::Undefined());
1577 ecmaRuntimeCallInfo1->SetThis(JSTaggedValue::Undefined());
1578
1579 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo1);
1580 JSTaggedValue result = Array::Unscopables(ecmaRuntimeCallInfo1);
1581 TestHelper::TearDownFrame(thread, prev);
1582 JSTaggedValue value(static_cast<JSTaggedType>(result.GetRawData()));
1583 ASSERT_TRUE(value.IsECMAObject());
1584 }
1585
HWTEST_F_L0(BuiltinsSharedArrayTest,ShrinkTo1)1586 HWTEST_F_L0(BuiltinsSharedArrayTest, ShrinkTo1)
1587 {
1588 JSSharedArray *arr = JSSharedArray::Cast(JSSharedArray::ArrayCreate(thread, JSTaggedNumber(10))->GetTaggedObject());
1589 EXPECT_TRUE(arr != nullptr);
1590 JSHandle<JSObject> obj(thread, arr);
1591
1592 std::vector<int> descVals{1, 2, 3, 4, 5};
1593 auto keys = SharedArrayDefineOwnPropertyTest(thread, obj, descVals);
1594
1595 JSHandle<JSFunction> array(thread->GetEcmaVM()->GetGlobalEnv()->GetSharedArrayFunction());
1596 auto ecmaRuntimeCallInfo1 = TestHelper::CreateEcmaRuntimeCallInfo(thread, array.GetTaggedValue(), 6);
1597 ecmaRuntimeCallInfo1->SetFunction(array.GetTaggedValue());
1598 ecmaRuntimeCallInfo1->SetThis(obj.GetTaggedValue());
1599 ecmaRuntimeCallInfo1->SetCallArg(0, JSTaggedValue(static_cast<int32_t>(3)));
1600
1601 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo1);
1602 JSTaggedValue result = Array::ShrinkTo(ecmaRuntimeCallInfo1);
1603 EXPECT_EQ(result, JSTaggedValue::Undefined());
1604 EXPECT_EQ(arr->GetArrayLength(), 3U);
1605 TestHelper::TearDownFrame(thread, prev);
1606 }
1607
HWTEST_F_L0(BuiltinsSharedArrayTest,ShrinkTo2)1608 HWTEST_F_L0(BuiltinsSharedArrayTest, ShrinkTo2)
1609 {
1610 JSSharedArray *arr = JSSharedArray::Cast(JSSharedArray::ArrayCreate(thread, JSTaggedNumber(10))->GetTaggedObject());
1611 EXPECT_TRUE(arr != nullptr);
1612 JSHandle<JSObject> obj(thread, arr);
1613
1614 std::vector<int> descVals{1, 2, 3, 4, 5};
1615 auto keys = SharedArrayDefineOwnPropertyTest(thread, obj, descVals);
1616
1617 JSHandle<JSFunction> array(thread->GetEcmaVM()->GetGlobalEnv()->GetSharedArrayFunction());
1618 auto ecmaRuntimeCallInfo1 = TestHelper::CreateEcmaRuntimeCallInfo(thread, array.GetTaggedValue(), 6);
1619 ecmaRuntimeCallInfo1->SetFunction(array.GetTaggedValue());
1620 ecmaRuntimeCallInfo1->SetThis(obj.GetTaggedValue());
1621 ecmaRuntimeCallInfo1->SetCallArg(0, JSTaggedValue(static_cast<double>(3)));
1622
1623 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo1);
1624 JSTaggedValue result = Array::ShrinkTo(ecmaRuntimeCallInfo1);
1625 EXPECT_EQ(result, JSTaggedValue::Undefined());
1626 EXPECT_EQ(arr->GetArrayLength(), 3U);
1627 TestHelper::TearDownFrame(thread, prev);
1628 }
1629
HWTEST_F_L0(BuiltinsSharedArrayTest,ExtendTo1)1630 HWTEST_F_L0(BuiltinsSharedArrayTest, ExtendTo1)
1631 {
1632 JSSharedArray *arr = JSSharedArray::Cast(JSSharedArray::ArrayCreate(thread, JSTaggedNumber(0))->GetTaggedObject());
1633 EXPECT_TRUE(arr != nullptr);
1634 JSHandle<JSObject> obj(thread, arr);
1635
1636 JSHandle<JSFunction> array(thread->GetEcmaVM()->GetGlobalEnv()->GetSharedArrayFunction());
1637 auto ecmaRuntimeCallInfo1 = TestHelper::CreateEcmaRuntimeCallInfo(thread, array.GetTaggedValue(), 8);
1638 ecmaRuntimeCallInfo1->SetFunction(array.GetTaggedValue());
1639 ecmaRuntimeCallInfo1->SetThis(obj.GetTaggedValue());
1640 ecmaRuntimeCallInfo1->SetCallArg(0, JSTaggedValue(static_cast<int32_t>(3)));
1641 ecmaRuntimeCallInfo1->SetCallArg(1, obj.GetTaggedValue());
1642
1643 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo1);
1644 JSTaggedValue result = Array::ExtendTo(ecmaRuntimeCallInfo1);
1645 ASSERT_EQ(result, JSTaggedValue::Undefined());
1646 EXPECT_EQ(arr->GetArrayLength(), 3U);
1647 TestHelper::TearDownFrame(thread, prev);
1648 }
1649
HWTEST_F_L0(BuiltinsSharedArrayTest,ExtendTo2)1650 HWTEST_F_L0(BuiltinsSharedArrayTest, ExtendTo2)
1651 {
1652 JSSharedArray *arr = JSSharedArray::Cast(JSSharedArray::ArrayCreate(thread, JSTaggedNumber(0))->GetTaggedObject());
1653 EXPECT_TRUE(arr != nullptr);
1654 JSHandle<JSObject> obj(thread, arr);
1655
1656 JSHandle<JSFunction> array(thread->GetEcmaVM()->GetGlobalEnv()->GetSharedArrayFunction());
1657 auto ecmaRuntimeCallInfo1 = TestHelper::CreateEcmaRuntimeCallInfo(thread, array.GetTaggedValue(), 8);
1658 ecmaRuntimeCallInfo1->SetFunction(array.GetTaggedValue());
1659 ecmaRuntimeCallInfo1->SetThis(obj.GetTaggedValue());
1660 ecmaRuntimeCallInfo1->SetCallArg(0, JSTaggedValue(static_cast<double>(3)));
1661 ecmaRuntimeCallInfo1->SetCallArg(1, obj.GetTaggedValue());
1662
1663 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo1);
1664 JSTaggedValue result = Array::ExtendTo(ecmaRuntimeCallInfo1);
1665 ASSERT_EQ(result, JSTaggedValue::Undefined());
1666 EXPECT_EQ(arr->GetArrayLength(), 3U);
1667 TestHelper::TearDownFrame(thread, prev);
1668 }
1669
HWTEST_F_L0(BuiltinsSharedArrayTest,SetPropertyTest001)1670 HWTEST_F_L0(BuiltinsSharedArrayTest, SetPropertyTest001)
1671 {
1672 JSSharedArray *arr = JSSharedArray::Cast(JSSharedArray::ArrayCreate(thread, JSTaggedNumber(5)) \
1673 .GetTaggedValue().GetTaggedObject());
1674 EXPECT_TRUE(arr != nullptr);
1675 JSHandle<JSTaggedValue> obj(thread, arr);
1676
1677 std::vector<int> descVals{2, 3, 4, 5, 7};
1678 auto keys = SharedArrayDefineOwnPropertyTest(thread, obj, descVals);
1679 JSHandle<JSTaggedValue> value(thread, JSTaggedValue(static_cast<int32_t>(5)));
1680 EXPECT_EQ(true, JSSharedArray::SetProperty(thread, obj, 0, value, true, SCheckMode::CHECK));
1681 }
1682
HWTEST_F_L0(BuiltinsSharedArrayTest,SetPropertyTest002)1683 HWTEST_F_L0(BuiltinsSharedArrayTest, SetPropertyTest002)
1684 {
1685 JSSharedArray *arr = JSSharedArray::Cast(JSSharedArray::ArrayCreate(thread, JSTaggedNumber(5)) \
1686 .GetTaggedValue().GetTaggedObject());
1687 EXPECT_TRUE(arr != nullptr);
1688 JSHandle<JSTaggedValue> obj(thread, arr);
1689
1690 std::vector<int> descVals{2, 3, 4, 5, 7};
1691 auto keys = SharedArrayDefineOwnPropertyTest(thread, obj, descVals);
1692 JSHandle<JSTaggedValue> value(thread, JSTaggedValue(static_cast<int32_t>(10)));
1693 EXPECT_EQ(false, JSSharedArray::SetProperty(thread, obj, 5, value, true, SCheckMode::CHECK));
1694 }
1695
HWTEST_F_L0(BuiltinsSharedArrayTest,IncludeInSortedValue)1696 HWTEST_F_L0(BuiltinsSharedArrayTest, IncludeInSortedValue)
1697 {
1698 auto ecmaVM = thread->GetEcmaVM();
1699 JSHandle<GlobalEnv> env = ecmaVM->GetGlobalEnv();
1700 ObjectFactory *factory = ecmaVM->GetFactory();
1701
1702 JSSharedArray *arr = JSSharedArray::Cast(JSSharedArray::ArrayCreate(thread, JSTaggedNumber(7)) \
1703 .GetTaggedValue().GetTaggedObject());
1704 EXPECT_TRUE(arr != nullptr);
1705 JSHandle<JSObject> obj(thread, arr);
1706
1707 std::vector<int> descVals{2, 3, 4, 5, 7, 500, 600};
1708 auto keys = SharedArrayDefineOwnPropertyTest(thread, obj, descVals);
1709
1710 JSHandle<JSFunction> func = factory->NewJSFunction(env, reinterpret_cast<void *>(TestClass::TestToSortedFunc));
1711 JSHandle<JSTaggedValue> funcValue(thread, func.GetTaggedValue());
1712
1713 auto objCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 0);
1714 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, objCallInfo);
1715
1716 JSHandle<JSTaggedValue> value(thread, JSTaggedValue(7));
1717 auto res = JSSharedArray::IncludeInSortedValue(thread, JSHandle<JSTaggedValue>(obj), value);
1718 ASSERT_TRUE(res);
1719 JSHandle<JSTaggedValue> value1(thread, JSTaggedValue(100));
1720 res = JSSharedArray::IncludeInSortedValue(thread, JSHandle<JSTaggedValue>(obj), value1);
1721 ASSERT_TRUE(!res);
1722 TestHelper::TearDownFrame(thread, prev);
1723 }
1724
HWTEST_F_L0(BuiltinsSharedArrayTest,IncludeInSortedValue_Len_0)1725 HWTEST_F_L0(BuiltinsSharedArrayTest, IncludeInSortedValue_Len_0)
1726 {
1727 JSSharedArray *arr = JSSharedArray::Cast(JSSharedArray::ArrayCreate(thread, JSTaggedNumber(0)) \
1728 .GetTaggedValue().GetTaggedObject());
1729 EXPECT_TRUE(arr != nullptr);
1730 JSHandle<JSObject> obj(thread, arr);
1731
1732 auto objCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 0);
1733 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, objCallInfo);
1734
1735 JSHandle<JSTaggedValue> value1(thread, JSTaggedValue(0));
1736 auto res = JSSharedArray::IncludeInSortedValue(thread, JSHandle<JSTaggedValue>(obj), value1);
1737 ASSERT_TRUE(!res);
1738 TestHelper::TearDownFrame(thread, prev);
1739 }
1740
1741
HWTEST_F_L0(BuiltinsSharedArrayTest,DefineProperty)1742 HWTEST_F_L0(BuiltinsSharedArrayTest, DefineProperty)
1743 {
1744 JSSharedArray *arr = JSSharedArray::Cast(JSSharedArray::ArrayCreate(thread, JSTaggedNumber(2))->GetTaggedObject());
1745 EXPECT_TRUE(arr != nullptr);
1746 JSHandle<JSObject> obj(thread, arr);
1747
1748 EcmaVM *ecmaVM = thread->GetEcmaVM();
1749 JSHandle<GlobalEnv> globalEnv = ecmaVM->GetGlobalEnv();
1750 JSHandle<JSTaggedValue> function(thread, globalEnv->GetObjectFunction().GetObject<JSFunction>());
1751
1752 JSHandle<JSFunction> objFunc(globalEnv->GetObjectFunction());
1753 JSHandle<JSObject> attHandle =
1754 ecmaVM->GetFactory()->NewJSObjectByConstructor(JSHandle<JSFunction>(function), function);
1755
1756 JSHandle<JSTaggedValue> key(thread, JSTaggedValue(1));
1757
1758 auto objCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 10);
1759 objCallInfo->SetFunction(JSTaggedValue::Undefined());
1760 objCallInfo->SetThis(JSTaggedValue::Undefined());
1761 objCallInfo->SetCallArg(0, obj.GetTaggedValue());
1762 objCallInfo->SetCallArg(1, key.GetTaggedValue());
1763 objCallInfo->SetCallArg(2, attHandle.GetTaggedValue());
1764
1765 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, objCallInfo);
1766 JSTaggedValue result = BuiltinsObject::DefineProperty(objCallInfo);
1767 TestHelper::TearDownFrame(thread, prev);
1768
1769 ASSERT_TRUE(result.IsECMAObject());
1770 EXPECT_EQ(arr->GetArrayLength(), 2U);
1771 }
1772
HWTEST_F_L0(BuiltinsSharedArrayTest,Some)1773 HWTEST_F_L0(BuiltinsSharedArrayTest, Some)
1774 {
1775 auto ecmaVM = thread->GetEcmaVM();
1776 JSHandle<GlobalEnv> env = ecmaVM->GetGlobalEnv();
1777 ObjectFactory *factory = ecmaVM->GetFactory();
1778
1779 JSHandle<JSTaggedValue> lengthKeyHandle = thread->GlobalConstants()->GetHandledLengthString();
1780 JSSharedArray *arr =
1781 JSSharedArray::Cast(JSSharedArray::ArrayCreate(thread, JSTaggedNumber(0)).GetTaggedValue().GetTaggedObject());
1782 EXPECT_TRUE(arr != nullptr);
1783 JSHandle<JSObject> obj(thread, arr);
1784 EXPECT_EQ(JSSharedArray::GetProperty(thread, JSHandle<JSTaggedValue>(obj), lengthKeyHandle,
1785 SCheckMode::SKIP).GetValue()->GetInt(), 0);
1786
1787 std::vector<int> descVals{1, 20, 3};
1788 auto keys = SharedArrayDefineOwnPropertyTest(thread, obj, descVals);
1789
1790 JSHandle<JSSharedArray> jsSharedArray(JSSharedArray::ArrayCreate(thread, JSTaggedNumber(0)));
1791 JSHandle<JSFunction> func = factory->NewJSFunction(env, reinterpret_cast<void *>(TestClass::TestSomeFunc));
1792
1793 auto ecmaRuntimeCallInfo1 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 8);
1794 ecmaRuntimeCallInfo1->SetFunction(JSTaggedValue::Undefined());
1795 ecmaRuntimeCallInfo1->SetThis(obj.GetTaggedValue());
1796 ecmaRuntimeCallInfo1->SetCallArg(0, func.GetTaggedValue());
1797 ecmaRuntimeCallInfo1->SetCallArg(1, jsSharedArray.GetTaggedValue());
1798
1799 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo1);
1800 JSTaggedValue result2 = Array::Some(ecmaRuntimeCallInfo1);
1801 TestHelper::TearDownFrame(thread, prev);
1802 ASSERT_EQ(result2.GetRawData(), JSTaggedValue::True().GetRawData());
1803 }
1804
HWTEST_F_L0(BuiltinsSharedArrayTest,Every)1805 HWTEST_F_L0(BuiltinsSharedArrayTest, Every)
1806 {
1807 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
1808 auto ecmaVM = thread->GetEcmaVM();
1809 JSHandle<GlobalEnv> env = ecmaVM->GetGlobalEnv();
1810
1811 JSHandle<JSTaggedValue> lengthKeyHandle = thread->GlobalConstants()->GetHandledLengthString();
1812 JSSharedArray *arr = JSSharedArray::Cast(JSSharedArray::ArrayCreate(thread,
1813 JSTaggedNumber(0)).GetTaggedValue().GetTaggedObject());
1814 EXPECT_TRUE(arr != nullptr);
1815 JSHandle<JSObject> obj(thread, arr);
1816 EXPECT_EQ(JSSharedArray::GetProperty(thread, JSHandle<JSTaggedValue>(obj),
1817 lengthKeyHandle, SCheckMode::SKIP).GetValue()->GetInt(), 0);
1818
1819 std::vector<int> descVals{100, 200, 300};
1820 auto keys = SharedArrayDefineOwnPropertyTest(thread, obj, descVals);
1821
1822 JSHandle<JSSharedArray> jsSharedArray(JSSharedArray::ArrayCreate(thread, JSTaggedNumber(0)));
1823 JSHandle<JSFunction> func = factory->NewJSFunction(env, reinterpret_cast<void *>(TestClass::TestEveryFunc));
1824
1825 auto ecmaRuntimeCallInfo1 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 8);
1826 ecmaRuntimeCallInfo1->SetFunction(JSTaggedValue::Undefined());
1827 ecmaRuntimeCallInfo1->SetThis(obj.GetTaggedValue());
1828 ecmaRuntimeCallInfo1->SetCallArg(0, func.GetTaggedValue());
1829 ecmaRuntimeCallInfo1->SetCallArg(1, jsSharedArray.GetTaggedValue());
1830
1831 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo1);
1832 JSTaggedValue result2 = Array::Every(ecmaRuntimeCallInfo1);
1833 TestHelper::TearDownFrame(thread, prev);
1834
1835 ASSERT_EQ(result2.GetRawData(), JSTaggedValue::True().GetRawData());
1836 EXPECT_EQ(JSSharedArrayIterator::Next(ecmaRuntimeCallInfo1), JSTaggedValue::Exception());
1837 }
1838
1839 template<typename T=int>
DefineSharedArrProperty(JSThread * thread,JSHandle<JSObject> & obj,std::vector<T> & vals)1840 std::vector<JSHandle<JSTaggedValue>> DefineSharedArrProperty(JSThread* thread, JSHandle<JSObject>& obj,
1841 std::vector<T>& vals)
1842 {
1843 std::vector<JSHandle<JSTaggedValue>> keys;
1844 for (size_t i = 0; i < vals.size(); i++) {
1845 keys.push_back(JSHandle<JSTaggedValue>(thread, JSTaggedValue(static_cast<int>(i))));
1846 ARRAY_DEFINE_OWN_PROPERTY(obj, static_cast<int>(i), vals[i]);
1847 }
1848 return keys;
1849 }
1850
1851 template<typename T=int>
CheckSharedArrKeyValue(JSThread * thread,JSHandle<JSObject> & valueHandle,PropertyDescriptor & descRes,std::vector<JSHandle<JSTaggedValue>> & keys,std::vector<T> & vals)1852 void CheckSharedArrKeyValue(JSThread* thread, JSHandle<JSObject>& valueHandle, PropertyDescriptor& descRes,
1853 std::vector<JSHandle<JSTaggedValue>>& keys, std::vector<T>& vals)
1854 {
1855 for (size_t i = 0; i < vals.size(); i++) {
1856 JSObject::GetOwnProperty(thread, valueHandle, keys[i], descRes);
1857 ASSERT_EQ(descRes.GetValue().GetTaggedValue(), JSTaggedValue(vals[i]));
1858 }
1859 }
1860
HWTEST_F_L0(BuiltinsSharedArrayTest,Of_One)1861 HWTEST_F_L0(BuiltinsSharedArrayTest, Of_One)
1862 {
1863 auto ecmaVM = thread->GetEcmaVM();
1864 JSHandle<GlobalEnv> env = ecmaVM->GetGlobalEnv();
1865 JSHandle<JSFunction> array(env->GetSharedArrayFunction());
1866
1867 auto ecmaRuntimeCallInfo1 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 10);
1868 ecmaRuntimeCallInfo1->SetFunction(array.GetTaggedValue());
1869 ecmaRuntimeCallInfo1->SetThis(array.GetTaggedValue());
1870 ecmaRuntimeCallInfo1->SetCallArg(0, JSTaggedValue(static_cast<int32_t>(1)));
1871 ecmaRuntimeCallInfo1->SetCallArg(1, JSTaggedValue(static_cast<int32_t>(3)));
1872 ecmaRuntimeCallInfo1->SetCallArg(2, JSTaggedValue(static_cast<int32_t>(5)));
1873
1874 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo1);
1875 JSTaggedValue result = Array::Of(ecmaRuntimeCallInfo1);
1876 TestHelper::TearDownFrame(thread, prev);
1877 JSTaggedValue value(static_cast<JSTaggedType>(result.GetRawData()));
1878 ASSERT_TRUE(value.IsECMAObject());
1879 PropertyDescriptor descRes(thread);
1880 JSHandle<JSObject> valueHandle(thread, value);
1881 JSHandle<JSTaggedValue> key0(thread, JSTaggedValue(0));
1882 JSHandle<JSTaggedValue> key1(thread, JSTaggedValue(1));
1883 JSHandle<JSTaggedValue> key2(thread, JSTaggedValue(2));
1884 std::vector<JSHandle<JSTaggedValue>> keys{key0, key1, key2};
1885 std::vector<int> vals{1, 3, 5};
1886 CheckSharedArrKeyValue(thread, valueHandle, descRes, keys, vals);
1887 }
1888
HWTEST_F_L0(BuiltinsSharedArrayTest,Of_Two)1889 HWTEST_F_L0(BuiltinsSharedArrayTest, Of_Two)
1890 {
1891 auto ecmaVM = thread->GetEcmaVM();
1892 JSHandle<GlobalEnv> env = ecmaVM->GetGlobalEnv();
1893 JSHandle<JSFunction> array(env->GetSharedArrayFunction());
1894 JSHandle<JSObject> globalObject(thread, env->GetGlobalObject());
1895
1896 auto ecmaRuntimeCallInfo1 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 10);
1897 ecmaRuntimeCallInfo1->SetFunction(array.GetTaggedValue());
1898 ecmaRuntimeCallInfo1->SetThis(JSTaggedValue::Undefined());
1899 ecmaRuntimeCallInfo1->SetCallArg(0, JSTaggedValue(static_cast<int32_t>(2)));
1900 ecmaRuntimeCallInfo1->SetCallArg(1, JSTaggedValue(static_cast<int32_t>(4)));
1901 ecmaRuntimeCallInfo1->SetCallArg(2, JSTaggedValue(static_cast<int32_t>(6)));
1902
1903 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo1);
1904 JSTaggedValue result = Array::Of(ecmaRuntimeCallInfo1);
1905 TestHelper::TearDownFrame(thread, prev);
1906 JSTaggedValue value(static_cast<JSTaggedType>(result.GetRawData()));
1907 ASSERT_TRUE(value.IsECMAObject());
1908 PropertyDescriptor descRes(thread);
1909 JSHandle<JSObject> valueHandle(thread, value);
1910 JSHandle<JSTaggedValue> key0(thread, JSTaggedValue(0));
1911 JSHandle<JSTaggedValue> key1(thread, JSTaggedValue(1));
1912 JSHandle<JSTaggedValue> key2(thread, JSTaggedValue(2));
1913 std::vector<JSHandle<JSTaggedValue>> keys{key0, key1, key2};
1914 std::vector<int> vals{2, 4, 6};
1915 CheckSharedArrKeyValue(thread, valueHandle, descRes, keys, vals);
1916 }
1917
HWTEST_F_L0(BuiltinsSharedArrayTest,Of_Three)1918 HWTEST_F_L0(BuiltinsSharedArrayTest, Of_Three)
1919 {
1920 auto ecmaVM = thread->GetEcmaVM();
1921 JSHandle<GlobalEnv> env = ecmaVM->GetGlobalEnv();
1922 JSHandle<JSFunction> array(env->GetSharedArrayFunction());
1923 JSHandle<JSObject> globalObject(thread, env->GetGlobalObject());
1924
1925 auto ecmaRuntimeCallInfo1 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 10);
1926 ecmaRuntimeCallInfo1->SetFunction(array.GetTaggedValue());
1927 ecmaRuntimeCallInfo1->SetThis(JSTaggedValue::Undefined());
1928 ecmaRuntimeCallInfo1->SetCallArg(0, JSTaggedValue(static_cast<int32_t>(2)));
1929 ecmaRuntimeCallInfo1->SetCallArg(1, env->GetArrayFunction().GetTaggedValue());
1930 ecmaRuntimeCallInfo1->SetCallArg(2, JSTaggedValue(static_cast<int32_t>(6)));
1931
1932 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo1);
1933 JSTaggedValue result = Array::Of(ecmaRuntimeCallInfo1);
1934 TestHelper::TearDownFrame(thread, prev);
1935 JSTaggedValue value(static_cast<JSTaggedType>(result.GetRawData()));
1936 ASSERT_TRUE(value.IsException());
1937 }
1938
HWTEST_F_L0(BuiltinsSharedArrayTest,Of_Four)1939 HWTEST_F_L0(BuiltinsSharedArrayTest, Of_Four)
1940 {
1941 auto ecmaVM = thread->GetEcmaVM();
1942 JSHandle<GlobalEnv> env = ecmaVM->GetGlobalEnv();
1943 JSHandle<JSFunction> array(env->GetArrayFunction());
1944 JSHandle<JSObject> globalObject(thread, env->GetGlobalObject());
1945
1946 auto ecmaRuntimeCallInfo1 = TestHelper::CreateEcmaRuntimeCallInfo(thread, array.GetTaggedValue(), 10);
1947 ecmaRuntimeCallInfo1->SetFunction(array.GetTaggedValue());
1948 ecmaRuntimeCallInfo1->SetThis(array.GetTaggedValue());
1949 ecmaRuntimeCallInfo1->SetCallArg(0, JSTaggedValue(static_cast<int32_t>(2)));
1950 ecmaRuntimeCallInfo1->SetCallArg(1, env->GetArrayFunction().GetTaggedValue());
1951 ecmaRuntimeCallInfo1->SetCallArg(2, JSTaggedValue(static_cast<int32_t>(6)));
1952
1953 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo1);
1954 JSTaggedValue result = Array::Of(ecmaRuntimeCallInfo1);
1955 TestHelper::TearDownFrame(thread, prev);
1956 JSTaggedValue value(static_cast<JSTaggedType>(result.GetRawData()));
1957 ASSERT_TRUE(value.IsException());
1958 }
1959
HWTEST_F_L0(BuiltinsSharedArrayTest,CopyWithin_One)1960 HWTEST_F_L0(BuiltinsSharedArrayTest, CopyWithin_One)
1961 {
1962 std::vector<int> descVals{1, 2, 3, 4, 5};
1963 JSHandle<JSTaggedValue> lengthKeyHandle = thread->GlobalConstants()->GetHandledLengthString();
1964 JSSharedArray *arr = JSSharedArray::Cast(JSSharedArray::ArrayCreate(thread,
1965 JSTaggedNumber(0)).GetTaggedValue().GetTaggedObject());
1966 EXPECT_TRUE(arr != nullptr);
1967 JSHandle<JSObject> obj(thread, arr);
1968 EXPECT_EQ(JSSharedArray::GetProperty(thread, JSHandle<JSTaggedValue>(obj), lengthKeyHandle,
1969 SCheckMode::SKIP).GetValue()->GetInt(), 0);
1970 auto keys = DefineSharedArrProperty(thread, obj, descVals);
1971
1972 auto ecmaRuntimeCallInfo1 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 10);
1973 ecmaRuntimeCallInfo1->SetFunction(JSTaggedValue::Undefined());
1974 ecmaRuntimeCallInfo1->SetThis(obj.GetTaggedValue());
1975 ecmaRuntimeCallInfo1->SetCallArg(0, JSTaggedValue(static_cast<int32_t>(0)));
1976 ecmaRuntimeCallInfo1->SetCallArg(1, JSTaggedValue(static_cast<int32_t>(3)));
1977 ecmaRuntimeCallInfo1->SetCallArg(2, JSTaggedValue(static_cast<int32_t>(5)));
1978
1979 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo1);
1980 JSTaggedValue result = Array::CopyWithin(ecmaRuntimeCallInfo1);
1981 TestHelper::TearDownFrame(thread, prev);
1982 JSTaggedValue value(static_cast<JSTaggedType>(result.GetRawData()));
1983 ASSERT_TRUE(value.IsECMAObject());
1984 PropertyDescriptor descRes(thread);
1985 JSHandle<JSObject> valueHandle(thread, value);
1986 std::vector<int> vals{4, 5, 3, 4, 5};
1987 CheckSharedArrKeyValue(thread, valueHandle, descRes, keys, vals);
1988 }
1989
HWTEST_F_L0(BuiltinsSharedArrayTest,CopyWithin_Two)1990 HWTEST_F_L0(BuiltinsSharedArrayTest, CopyWithin_Two)
1991 {
1992 std::vector<int> descVals{1, 2, 3, 4, 5};
1993 JSHandle<JSTaggedValue> lengthKeyHandle = thread->GlobalConstants()->GetHandledLengthString();
1994 JSSharedArray *arr = JSSharedArray::Cast(JSSharedArray::ArrayCreate(thread,
1995 JSTaggedNumber(0)).GetTaggedValue().GetTaggedObject());
1996 EXPECT_TRUE(arr != nullptr);
1997 JSHandle<JSObject> obj(thread, arr);
1998 EXPECT_EQ(JSSharedArray::GetProperty(thread, JSHandle<JSTaggedValue>(obj), lengthKeyHandle,
1999 SCheckMode::SKIP).GetValue()->GetInt(), 0);
2000 auto keys = DefineSharedArrProperty(thread, obj, descVals);
2001
2002 auto ecmaRuntimeCallInfo1 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 10);
2003 ecmaRuntimeCallInfo1->SetFunction(JSTaggedValue::Undefined());
2004 ecmaRuntimeCallInfo1->SetThis(obj.GetTaggedValue());
2005 ecmaRuntimeCallInfo1->SetCallArg(0, JSTaggedValue::Undefined());
2006
2007 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo1);
2008 JSTaggedValue result = Array::CopyWithin(ecmaRuntimeCallInfo1);
2009 TestHelper::TearDownFrame(thread, prev);
2010 JSTaggedValue value(static_cast<JSTaggedType>(result.GetRawData()));
2011 ASSERT_TRUE(value.IsException());
2012 }
2013
HWTEST_F_L0(BuiltinsSharedArrayTest,CopyWithin_Three)2014 HWTEST_F_L0(BuiltinsSharedArrayTest, CopyWithin_Three)
2015 {
2016 std::vector<int> descVals{1, 2, 3, 4, 5};
2017 JSHandle<JSTaggedValue> lengthKeyHandle = thread->GlobalConstants()->GetHandledLengthString();
2018 JSSharedArray *arr = JSSharedArray::Cast(JSSharedArray::ArrayCreate(thread,
2019 JSTaggedNumber(0)).GetTaggedValue().GetTaggedObject());
2020 EXPECT_TRUE(arr != nullptr);
2021 JSHandle<JSObject> obj(thread, arr);
2022 EXPECT_EQ(JSSharedArray::GetProperty(thread, JSHandle<JSTaggedValue>(obj), lengthKeyHandle,
2023 SCheckMode::SKIP).GetValue()->GetInt(), 0);
2024 auto keys = DefineSharedArrProperty(thread, obj, descVals);
2025
2026 auto ecmaRuntimeCallInfo1 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 10);
2027 ecmaRuntimeCallInfo1->SetFunction(JSTaggedValue::Undefined());
2028 ecmaRuntimeCallInfo1->SetThis(obj.GetTaggedValue());
2029 ecmaRuntimeCallInfo1->SetCallArg(0, JSTaggedValue(static_cast<int32_t>(0)));
2030 ecmaRuntimeCallInfo1->SetCallArg(1, JSTaggedValue::Undefined());
2031 ecmaRuntimeCallInfo1->SetCallArg(2, JSTaggedValue::Undefined());
2032
2033 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo1);
2034 JSTaggedValue result = Array::CopyWithin(ecmaRuntimeCallInfo1);
2035 TestHelper::TearDownFrame(thread, prev);
2036 JSTaggedValue value(static_cast<JSTaggedType>(result.GetRawData()));
2037 ASSERT_TRUE(value.IsECMAObject());
2038 PropertyDescriptor descRes(thread);
2039 JSHandle<JSObject> valueHandle(thread, value);
2040 std::vector<int> vals{1, 2, 3, 4, 5};
2041 CheckSharedArrKeyValue(thread, valueHandle, descRes, keys, vals);
2042 }
2043
HWTEST_F_L0(BuiltinsSharedArrayTest,CopyWithin_Four)2044 HWTEST_F_L0(BuiltinsSharedArrayTest, CopyWithin_Four)
2045 {
2046 std::vector<int> descVals{1, 2, 3, 4, 5, 6};
2047 JSHandle<JSTaggedValue> lengthKeyHandle = thread->GlobalConstants()->GetHandledLengthString();
2048 JSSharedArray *arr = JSSharedArray::Cast(JSSharedArray::ArrayCreate(thread,
2049 JSTaggedNumber(0)).GetTaggedValue().GetTaggedObject());
2050 EXPECT_TRUE(arr != nullptr);
2051 JSHandle<JSObject> obj(thread, arr);
2052 EXPECT_EQ(JSSharedArray::GetProperty(thread, JSHandle<JSTaggedValue>(obj), lengthKeyHandle,
2053 SCheckMode::SKIP).GetValue()->GetInt(), 0);
2054 auto keys = DefineSharedArrProperty(thread, obj, descVals);
2055
2056 auto ecmaRuntimeCallInfo1 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 10);
2057 ecmaRuntimeCallInfo1->SetFunction(JSTaggedValue::Undefined());
2058 ecmaRuntimeCallInfo1->SetThis(obj.GetTaggedValue());
2059 ecmaRuntimeCallInfo1->SetCallArg(0, JSTaggedValue(static_cast<int32_t>(1)));
2060 ecmaRuntimeCallInfo1->SetCallArg(1, JSTaggedValue(static_cast<int32_t>(-3)));
2061 ecmaRuntimeCallInfo1->SetCallArg(2, JSTaggedValue(static_cast<int32_t>(5)));
2062
2063 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo1);
2064 JSTaggedValue result = Array::CopyWithin(ecmaRuntimeCallInfo1);
2065 TestHelper::TearDownFrame(thread, prev);
2066 JSTaggedValue value(static_cast<JSTaggedType>(result.GetRawData()));
2067 ASSERT_TRUE(value.IsECMAObject());
2068 PropertyDescriptor descRes(thread);
2069 JSHandle<JSObject> valueHandle(thread, value);
2070 std::vector<int> vals{1, 4, 5, 4, 5, 6};
2071 CheckSharedArrKeyValue(thread, valueHandle, descRes, keys, vals);
2072 }
2073
HWTEST_F_L0(BuiltinsSharedArrayTest,CopyWithin_Five)2074 HWTEST_F_L0(BuiltinsSharedArrayTest, CopyWithin_Five)
2075 {
2076 std::vector<int> descVals{1, 2, 3, 4, 5, 6, 7, 8};
2077 JSHandle<JSTaggedValue> lengthKeyHandle = thread->GlobalConstants()->GetHandledLengthString();
2078 JSSharedArray *arr = JSSharedArray::Cast(JSSharedArray::ArrayCreate(thread,
2079 JSTaggedNumber(0)).GetTaggedValue().GetTaggedObject());
2080 EXPECT_TRUE(arr != nullptr);
2081 JSHandle<JSObject> obj(thread, arr);
2082 EXPECT_EQ(JSSharedArray::GetProperty(thread, JSHandle<JSTaggedValue>(obj), lengthKeyHandle,
2083 SCheckMode::SKIP).GetValue()->GetInt(), 0);
2084 auto keys = DefineSharedArrProperty(thread, obj, descVals);
2085
2086 auto ecmaRuntimeCallInfo1 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 10);
2087 ecmaRuntimeCallInfo1->SetFunction(JSTaggedValue::Undefined());
2088 ecmaRuntimeCallInfo1->SetThis(obj.GetTaggedValue());
2089 ecmaRuntimeCallInfo1->SetCallArg(0, JSTaggedValue(static_cast<int32_t>(4)));
2090 ecmaRuntimeCallInfo1->SetCallArg(1, JSTaggedValue(static_cast<int32_t>(2)));
2091 ecmaRuntimeCallInfo1->SetCallArg(2, JSTaggedValue(JSTaggedValue::Undefined()));
2092
2093 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo1);
2094 JSTaggedValue result = Array::CopyWithin(ecmaRuntimeCallInfo1);
2095 TestHelper::TearDownFrame(thread, prev);
2096 JSTaggedValue value(static_cast<JSTaggedType>(result.GetRawData()));
2097 ASSERT_TRUE(value.IsECMAObject());
2098 PropertyDescriptor descRes(thread);
2099 JSHandle<JSObject> valueHandle(thread, value);
2100 std::vector<int> vals{1, 2, 3, 4, 3, 4, 5, 6};
2101 CheckSharedArrKeyValue(thread, valueHandle, descRes, keys, vals);
2102 }
2103
HWTEST_F_L0(BuiltinsSharedArrayTest,Reverse)2104 HWTEST_F_L0(BuiltinsSharedArrayTest, Reverse)
2105 {
2106 std::vector<int> descVals{1, 2, 3, 4, 5};
2107 JSHandle<JSTaggedValue> lengthKeyHandle = thread->GlobalConstants()->GetHandledLengthString();
2108 JSSharedArray *arr = JSSharedArray::Cast(JSSharedArray::ArrayCreate(thread,
2109 JSTaggedNumber(0)).GetTaggedValue().GetTaggedObject());
2110 EXPECT_TRUE(arr != nullptr);
2111 JSHandle<JSObject> obj(thread, arr);
2112 EXPECT_EQ(JSSharedArray::GetProperty(thread, JSHandle<JSTaggedValue>(obj), lengthKeyHandle,
2113 SCheckMode::SKIP).GetValue()->GetInt(), 0);
2114 auto keys = DefineSharedArrProperty(thread, obj, descVals);
2115
2116 auto ecmaRuntimeCallInfo1 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 4);
2117 ecmaRuntimeCallInfo1->SetFunction(JSTaggedValue::Undefined());
2118 ecmaRuntimeCallInfo1->SetThis(obj.GetTaggedValue());
2119
2120 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo1);
2121 JSTaggedValue result = Array::Reverse(ecmaRuntimeCallInfo1);
2122 TestHelper::TearDownFrame(thread, prev);
2123 JSTaggedValue value(static_cast<JSTaggedType>(result.GetRawData()));
2124 ASSERT_TRUE(value.IsECMAObject());
2125 PropertyDescriptor descRes(thread);
2126 JSHandle<JSObject> valueHandle(thread, value);
2127 std::vector<int> vals{5, 4, 3, 2, 1};
2128 CheckSharedArrKeyValue(thread, valueHandle, descRes, keys, vals);
2129 }
2130
HWTEST_F_L0(BuiltinsSharedArrayTest,Reverse_one)2131 HWTEST_F_L0(BuiltinsSharedArrayTest, Reverse_one)
2132 {
2133 std::vector<double> descVals{1.5, 2.3, 3.6, 4.4, 5.9};
2134 JSHandle<JSTaggedValue> lengthKeyHandle = thread->GlobalConstants()->GetHandledLengthString();
2135 JSSharedArray *arr = JSSharedArray::Cast(JSSharedArray::ArrayCreate(thread,
2136 JSTaggedNumber(0)).GetTaggedValue().GetTaggedObject());
2137 EXPECT_TRUE(arr != nullptr);
2138 JSHandle<JSObject> obj(thread, arr);
2139 EXPECT_EQ(JSSharedArray::GetProperty(thread, JSHandle<JSTaggedValue>(obj), lengthKeyHandle,
2140 SCheckMode::SKIP).GetValue()->GetInt(), 0);
2141 auto keys = DefineSharedArrProperty<double>(thread, obj, descVals);
2142
2143 auto ecmaRuntimeCallInfo1 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 4);
2144 ecmaRuntimeCallInfo1->SetFunction(JSTaggedValue::Undefined());
2145 ecmaRuntimeCallInfo1->SetThis(obj.GetTaggedValue());
2146
2147 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo1);
2148 JSTaggedValue result = Array::Reverse(ecmaRuntimeCallInfo1);
2149 TestHelper::TearDownFrame(thread, prev);
2150 JSTaggedValue value(static_cast<JSTaggedType>(result.GetRawData()));
2151 ASSERT_TRUE(value.IsECMAObject());
2152 PropertyDescriptor descRes(thread);
2153 JSHandle<JSObject> valueHandle(thread, value);
2154 std::vector<double> vals{5.9, 4.4, 3.6, 2.3, 1.5};
2155 CheckSharedArrKeyValue<double>(thread, valueHandle, descRes, keys, vals);
2156 }
2157 } // namespace panda::test
2158