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(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(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(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,CheckAndCopyArray)1805 HWTEST_F_L0(BuiltinsSharedArrayTest, CheckAndCopyArray)
1806 {
1807 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
1808 JSHandle<TaggedArray> array(factory->NewCOWTaggedArray(2));
1809 JSHandle<JSTaggedValue> val0(thread, JSTaggedValue(1));
1810 JSHandle<JSTaggedValue> val1(thread, JSTaggedValue(2));
1811 array->Set(thread, 0, val0);
1812 array->Set(thread, 1, val1);
1813
1814 JSSharedArray *arr = JSSharedArray::Cast(JSSharedArray::ArrayCreate(thread, JSTaggedNumber(0)) \
1815 .GetTaggedValue().GetTaggedObject());
1816 JSHandle<JSObject> arrObj(thread, arr);
1817 JSHandle<JSTaggedValue> arrayH(arrObj);
1818
1819 JSHandle<JSObject> obj(thread, arr);
1820 obj->SetElements(thread, array, SKIP_BARRIER);
1821
1822 JSHandle<JSSharedArray> jsSharedArray(arrayH);
1823 JSSharedArray::CheckAndCopyArray(thread, jsSharedArray);
1824 EXPECT_TRUE(arrayH->IsECMAObject());
1825 }
1826
HWTEST_F_L0(BuiltinsSharedArrayTest,Every)1827 HWTEST_F_L0(BuiltinsSharedArrayTest, Every)
1828 {
1829 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
1830 auto ecmaVM = thread->GetEcmaVM();
1831 JSHandle<GlobalEnv> env = ecmaVM->GetGlobalEnv();
1832
1833 JSHandle<JSTaggedValue> lengthKeyHandle = thread->GlobalConstants()->GetHandledLengthString();
1834 JSSharedArray *arr = JSSharedArray::Cast(JSSharedArray::ArrayCreate(thread,
1835 JSTaggedNumber(0)).GetTaggedValue().GetTaggedObject());
1836 EXPECT_TRUE(arr != nullptr);
1837 JSHandle<JSObject> obj(thread, arr);
1838 EXPECT_EQ(JSSharedArray::GetProperty(thread, JSHandle<JSTaggedValue>(obj),
1839 lengthKeyHandle, SCheckMode::SKIP).GetValue()->GetInt(), 0);
1840
1841 std::vector<int> descVals{100, 200, 300};
1842 auto keys = SharedArrayDefineOwnPropertyTest(thread, obj, descVals);
1843
1844 JSHandle<JSSharedArray> jsSharedArray(JSSharedArray::ArrayCreate(thread, JSTaggedNumber(0)));
1845 JSHandle<JSFunction> func = factory->NewJSFunction(env, reinterpret_cast<void *>(TestClass::TestEveryFunc));
1846
1847 auto ecmaRuntimeCallInfo1 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 8);
1848 ecmaRuntimeCallInfo1->SetFunction(JSTaggedValue::Undefined());
1849 ecmaRuntimeCallInfo1->SetThis(obj.GetTaggedValue());
1850 ecmaRuntimeCallInfo1->SetCallArg(0, func.GetTaggedValue());
1851 ecmaRuntimeCallInfo1->SetCallArg(1, jsSharedArray.GetTaggedValue());
1852
1853 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo1);
1854 JSTaggedValue result2 = Array::Every(ecmaRuntimeCallInfo1);
1855 TestHelper::TearDownFrame(thread, prev);
1856
1857 ASSERT_EQ(result2.GetRawData(), JSTaggedValue::True().GetRawData());
1858 EXPECT_EQ(JSSharedArrayIterator::Next(ecmaRuntimeCallInfo1), JSTaggedValue::Exception());
1859 }
1860
1861 template<typename T=int>
DefineSharedArrProperty(JSThread * thread,JSHandle<JSObject> & obj,std::vector<T> & vals)1862 std::vector<JSHandle<JSTaggedValue>> DefineSharedArrProperty(JSThread* thread, JSHandle<JSObject>& obj,
1863 std::vector<T>& vals)
1864 {
1865 std::vector<JSHandle<JSTaggedValue>> keys;
1866 for (size_t i = 0; i < vals.size(); i++) {
1867 keys.push_back(JSHandle<JSTaggedValue>(thread, JSTaggedValue(static_cast<int>(i))));
1868 ARRAY_DEFINE_OWN_PROPERTY(obj, static_cast<int>(i), vals[i]);
1869 }
1870 return keys;
1871 }
1872
1873 template<typename T=int>
CheckSharedArrKeyValue(JSThread * thread,JSHandle<JSObject> & valueHandle,PropertyDescriptor & descRes,std::vector<JSHandle<JSTaggedValue>> & keys,std::vector<T> & vals)1874 void CheckSharedArrKeyValue(JSThread* thread, JSHandle<JSObject>& valueHandle, PropertyDescriptor& descRes,
1875 std::vector<JSHandle<JSTaggedValue>>& keys, std::vector<T>& vals)
1876 {
1877 for (size_t i = 0; i < vals.size(); i++) {
1878 JSObject::GetOwnProperty(thread, valueHandle, keys[i], descRes);
1879 ASSERT_EQ(descRes.GetValue().GetTaggedValue(), JSTaggedValue(vals[i]));
1880 }
1881 }
1882
HWTEST_F_L0(BuiltinsSharedArrayTest,Of_One)1883 HWTEST_F_L0(BuiltinsSharedArrayTest, Of_One)
1884 {
1885 auto ecmaVM = thread->GetEcmaVM();
1886 JSHandle<GlobalEnv> env = ecmaVM->GetGlobalEnv();
1887 JSHandle<JSFunction> array(env->GetSharedArrayFunction());
1888
1889 auto ecmaRuntimeCallInfo1 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 10);
1890 ecmaRuntimeCallInfo1->SetFunction(array.GetTaggedValue());
1891 ecmaRuntimeCallInfo1->SetThis(array.GetTaggedValue());
1892 ecmaRuntimeCallInfo1->SetCallArg(0, JSTaggedValue(static_cast<int32_t>(1)));
1893 ecmaRuntimeCallInfo1->SetCallArg(1, JSTaggedValue(static_cast<int32_t>(3)));
1894 ecmaRuntimeCallInfo1->SetCallArg(2, JSTaggedValue(static_cast<int32_t>(5)));
1895
1896 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo1);
1897 JSTaggedValue result = Array::Of(ecmaRuntimeCallInfo1);
1898 TestHelper::TearDownFrame(thread, prev);
1899 JSTaggedValue value(static_cast<JSTaggedType>(result.GetRawData()));
1900 ASSERT_TRUE(value.IsECMAObject());
1901 PropertyDescriptor descRes(thread);
1902 JSHandle<JSObject> valueHandle(thread, value);
1903 JSHandle<JSTaggedValue> key0(thread, JSTaggedValue(0));
1904 JSHandle<JSTaggedValue> key1(thread, JSTaggedValue(1));
1905 JSHandle<JSTaggedValue> key2(thread, JSTaggedValue(2));
1906 std::vector<JSHandle<JSTaggedValue>> keys{key0, key1, key2};
1907 std::vector<int> vals{1, 3, 5};
1908 CheckSharedArrKeyValue(thread, valueHandle, descRes, keys, vals);
1909 }
1910
HWTEST_F_L0(BuiltinsSharedArrayTest,Of_Two)1911 HWTEST_F_L0(BuiltinsSharedArrayTest, Of_Two)
1912 {
1913 auto ecmaVM = thread->GetEcmaVM();
1914 JSHandle<GlobalEnv> env = ecmaVM->GetGlobalEnv();
1915 JSHandle<JSFunction> array(env->GetSharedArrayFunction());
1916 JSHandle<JSObject> globalObject(thread, env->GetGlobalObject());
1917
1918 auto ecmaRuntimeCallInfo1 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 10);
1919 ecmaRuntimeCallInfo1->SetFunction(array.GetTaggedValue());
1920 ecmaRuntimeCallInfo1->SetThis(JSTaggedValue::Undefined());
1921 ecmaRuntimeCallInfo1->SetCallArg(0, JSTaggedValue(static_cast<int32_t>(2)));
1922 ecmaRuntimeCallInfo1->SetCallArg(1, JSTaggedValue(static_cast<int32_t>(4)));
1923 ecmaRuntimeCallInfo1->SetCallArg(2, JSTaggedValue(static_cast<int32_t>(6)));
1924
1925 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo1);
1926 JSTaggedValue result = Array::Of(ecmaRuntimeCallInfo1);
1927 TestHelper::TearDownFrame(thread, prev);
1928 JSTaggedValue value(static_cast<JSTaggedType>(result.GetRawData()));
1929 ASSERT_TRUE(value.IsECMAObject());
1930 PropertyDescriptor descRes(thread);
1931 JSHandle<JSObject> valueHandle(thread, value);
1932 JSHandle<JSTaggedValue> key0(thread, JSTaggedValue(0));
1933 JSHandle<JSTaggedValue> key1(thread, JSTaggedValue(1));
1934 JSHandle<JSTaggedValue> key2(thread, JSTaggedValue(2));
1935 std::vector<JSHandle<JSTaggedValue>> keys{key0, key1, key2};
1936 std::vector<int> vals{2, 4, 6};
1937 CheckSharedArrKeyValue(thread, valueHandle, descRes, keys, vals);
1938 }
1939
HWTEST_F_L0(BuiltinsSharedArrayTest,Of_Three)1940 HWTEST_F_L0(BuiltinsSharedArrayTest, Of_Three)
1941 {
1942 auto ecmaVM = thread->GetEcmaVM();
1943 JSHandle<GlobalEnv> env = ecmaVM->GetGlobalEnv();
1944 JSHandle<JSFunction> array(env->GetSharedArrayFunction());
1945 JSHandle<JSObject> globalObject(thread, env->GetGlobalObject());
1946
1947 auto ecmaRuntimeCallInfo1 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 10);
1948 ecmaRuntimeCallInfo1->SetFunction(array.GetTaggedValue());
1949 ecmaRuntimeCallInfo1->SetThis(JSTaggedValue::Undefined());
1950 ecmaRuntimeCallInfo1->SetCallArg(0, JSTaggedValue(static_cast<int32_t>(2)));
1951 ecmaRuntimeCallInfo1->SetCallArg(1, env->GetArrayFunction().GetTaggedValue());
1952 ecmaRuntimeCallInfo1->SetCallArg(2, JSTaggedValue(static_cast<int32_t>(6)));
1953
1954 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo1);
1955 JSTaggedValue result = Array::Of(ecmaRuntimeCallInfo1);
1956 TestHelper::TearDownFrame(thread, prev);
1957 JSTaggedValue value(static_cast<JSTaggedType>(result.GetRawData()));
1958 ASSERT_TRUE(value.IsException());
1959 }
1960
HWTEST_F_L0(BuiltinsSharedArrayTest,Of_Four)1961 HWTEST_F_L0(BuiltinsSharedArrayTest, Of_Four)
1962 {
1963 auto ecmaVM = thread->GetEcmaVM();
1964 JSHandle<GlobalEnv> env = ecmaVM->GetGlobalEnv();
1965 JSHandle<JSFunction> array(env->GetArrayFunction());
1966 JSHandle<JSObject> globalObject(thread, env->GetGlobalObject());
1967
1968 auto ecmaRuntimeCallInfo1 = TestHelper::CreateEcmaRuntimeCallInfo(thread, array.GetTaggedValue(), 10);
1969 ecmaRuntimeCallInfo1->SetFunction(array.GetTaggedValue());
1970 ecmaRuntimeCallInfo1->SetThis(array.GetTaggedValue());
1971 ecmaRuntimeCallInfo1->SetCallArg(0, JSTaggedValue(static_cast<int32_t>(2)));
1972 ecmaRuntimeCallInfo1->SetCallArg(1, env->GetArrayFunction().GetTaggedValue());
1973 ecmaRuntimeCallInfo1->SetCallArg(2, JSTaggedValue(static_cast<int32_t>(6)));
1974
1975 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo1);
1976 JSTaggedValue result = Array::Of(ecmaRuntimeCallInfo1);
1977 TestHelper::TearDownFrame(thread, prev);
1978 JSTaggedValue value(static_cast<JSTaggedType>(result.GetRawData()));
1979 ASSERT_TRUE(value.IsException());
1980 }
1981
HWTEST_F_L0(BuiltinsSharedArrayTest,CopyWithin_One)1982 HWTEST_F_L0(BuiltinsSharedArrayTest, CopyWithin_One)
1983 {
1984 std::vector<int> descVals{1, 2, 3, 4, 5};
1985 JSHandle<JSTaggedValue> lengthKeyHandle = thread->GlobalConstants()->GetHandledLengthString();
1986 JSSharedArray *arr = JSSharedArray::Cast(JSSharedArray::ArrayCreate(thread,
1987 JSTaggedNumber(0)).GetTaggedValue().GetTaggedObject());
1988 EXPECT_TRUE(arr != nullptr);
1989 JSHandle<JSObject> obj(thread, arr);
1990 EXPECT_EQ(JSSharedArray::GetProperty(thread, JSHandle<JSTaggedValue>(obj), lengthKeyHandle,
1991 SCheckMode::SKIP).GetValue()->GetInt(), 0);
1992 auto keys = DefineSharedArrProperty(thread, obj, descVals);
1993
1994 auto ecmaRuntimeCallInfo1 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 10);
1995 ecmaRuntimeCallInfo1->SetFunction(JSTaggedValue::Undefined());
1996 ecmaRuntimeCallInfo1->SetThis(obj.GetTaggedValue());
1997 ecmaRuntimeCallInfo1->SetCallArg(0, JSTaggedValue(static_cast<int32_t>(0)));
1998 ecmaRuntimeCallInfo1->SetCallArg(1, JSTaggedValue(static_cast<int32_t>(3)));
1999 ecmaRuntimeCallInfo1->SetCallArg(2, JSTaggedValue(static_cast<int32_t>(5)));
2000
2001 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo1);
2002 JSTaggedValue result = Array::CopyWithin(ecmaRuntimeCallInfo1);
2003 TestHelper::TearDownFrame(thread, prev);
2004 JSTaggedValue value(static_cast<JSTaggedType>(result.GetRawData()));
2005 ASSERT_TRUE(value.IsECMAObject());
2006 PropertyDescriptor descRes(thread);
2007 JSHandle<JSObject> valueHandle(thread, value);
2008 std::vector<int> vals{4, 5, 3, 4, 5};
2009 CheckSharedArrKeyValue(thread, valueHandle, descRes, keys, vals);
2010 }
2011
HWTEST_F_L0(BuiltinsSharedArrayTest,CopyWithin_Two)2012 HWTEST_F_L0(BuiltinsSharedArrayTest, CopyWithin_Two)
2013 {
2014 std::vector<int> descVals{1, 2, 3, 4, 5};
2015 JSHandle<JSTaggedValue> lengthKeyHandle = thread->GlobalConstants()->GetHandledLengthString();
2016 JSSharedArray *arr = JSSharedArray::Cast(JSSharedArray::ArrayCreate(thread,
2017 JSTaggedNumber(0)).GetTaggedValue().GetTaggedObject());
2018 EXPECT_TRUE(arr != nullptr);
2019 JSHandle<JSObject> obj(thread, arr);
2020 EXPECT_EQ(JSSharedArray::GetProperty(thread, JSHandle<JSTaggedValue>(obj), lengthKeyHandle,
2021 SCheckMode::SKIP).GetValue()->GetInt(), 0);
2022 auto keys = DefineSharedArrProperty(thread, obj, descVals);
2023
2024 auto ecmaRuntimeCallInfo1 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 10);
2025 ecmaRuntimeCallInfo1->SetFunction(JSTaggedValue::Undefined());
2026 ecmaRuntimeCallInfo1->SetThis(obj.GetTaggedValue());
2027 ecmaRuntimeCallInfo1->SetCallArg(0, JSTaggedValue::Undefined());
2028
2029 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo1);
2030 JSTaggedValue result = Array::CopyWithin(ecmaRuntimeCallInfo1);
2031 TestHelper::TearDownFrame(thread, prev);
2032 JSTaggedValue value(static_cast<JSTaggedType>(result.GetRawData()));
2033 ASSERT_TRUE(value.IsException());
2034 }
2035
HWTEST_F_L0(BuiltinsSharedArrayTest,CopyWithin_Three)2036 HWTEST_F_L0(BuiltinsSharedArrayTest, CopyWithin_Three)
2037 {
2038 std::vector<int> descVals{1, 2, 3, 4, 5};
2039 JSHandle<JSTaggedValue> lengthKeyHandle = thread->GlobalConstants()->GetHandledLengthString();
2040 JSSharedArray *arr = JSSharedArray::Cast(JSSharedArray::ArrayCreate(thread,
2041 JSTaggedNumber(0)).GetTaggedValue().GetTaggedObject());
2042 EXPECT_TRUE(arr != nullptr);
2043 JSHandle<JSObject> obj(thread, arr);
2044 EXPECT_EQ(JSSharedArray::GetProperty(thread, JSHandle<JSTaggedValue>(obj), lengthKeyHandle,
2045 SCheckMode::SKIP).GetValue()->GetInt(), 0);
2046 auto keys = DefineSharedArrProperty(thread, obj, descVals);
2047
2048 auto ecmaRuntimeCallInfo1 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 10);
2049 ecmaRuntimeCallInfo1->SetFunction(JSTaggedValue::Undefined());
2050 ecmaRuntimeCallInfo1->SetThis(obj.GetTaggedValue());
2051 ecmaRuntimeCallInfo1->SetCallArg(0, JSTaggedValue(static_cast<int32_t>(0)));
2052 ecmaRuntimeCallInfo1->SetCallArg(1, JSTaggedValue::Undefined());
2053 ecmaRuntimeCallInfo1->SetCallArg(2, JSTaggedValue::Undefined());
2054
2055 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo1);
2056 JSTaggedValue result = Array::CopyWithin(ecmaRuntimeCallInfo1);
2057 TestHelper::TearDownFrame(thread, prev);
2058 JSTaggedValue value(static_cast<JSTaggedType>(result.GetRawData()));
2059 ASSERT_TRUE(value.IsECMAObject());
2060 PropertyDescriptor descRes(thread);
2061 JSHandle<JSObject> valueHandle(thread, value);
2062 std::vector<int> vals{1, 2, 3, 4, 5};
2063 CheckSharedArrKeyValue(thread, valueHandle, descRes, keys, vals);
2064 }
2065
HWTEST_F_L0(BuiltinsSharedArrayTest,CopyWithin_Four)2066 HWTEST_F_L0(BuiltinsSharedArrayTest, CopyWithin_Four)
2067 {
2068 std::vector<int> descVals{1, 2, 3, 4, 5, 6};
2069 JSHandle<JSTaggedValue> lengthKeyHandle = thread->GlobalConstants()->GetHandledLengthString();
2070 JSSharedArray *arr = JSSharedArray::Cast(JSSharedArray::ArrayCreate(thread,
2071 JSTaggedNumber(0)).GetTaggedValue().GetTaggedObject());
2072 EXPECT_TRUE(arr != nullptr);
2073 JSHandle<JSObject> obj(thread, arr);
2074 EXPECT_EQ(JSSharedArray::GetProperty(thread, JSHandle<JSTaggedValue>(obj), lengthKeyHandle,
2075 SCheckMode::SKIP).GetValue()->GetInt(), 0);
2076 auto keys = DefineSharedArrProperty(thread, obj, descVals);
2077
2078 auto ecmaRuntimeCallInfo1 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 10);
2079 ecmaRuntimeCallInfo1->SetFunction(JSTaggedValue::Undefined());
2080 ecmaRuntimeCallInfo1->SetThis(obj.GetTaggedValue());
2081 ecmaRuntimeCallInfo1->SetCallArg(0, JSTaggedValue(static_cast<int32_t>(1)));
2082 ecmaRuntimeCallInfo1->SetCallArg(1, JSTaggedValue(static_cast<int32_t>(-3)));
2083 ecmaRuntimeCallInfo1->SetCallArg(2, JSTaggedValue(static_cast<int32_t>(5)));
2084
2085 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo1);
2086 JSTaggedValue result = Array::CopyWithin(ecmaRuntimeCallInfo1);
2087 TestHelper::TearDownFrame(thread, prev);
2088 JSTaggedValue value(static_cast<JSTaggedType>(result.GetRawData()));
2089 ASSERT_TRUE(value.IsECMAObject());
2090 PropertyDescriptor descRes(thread);
2091 JSHandle<JSObject> valueHandle(thread, value);
2092 std::vector<int> vals{1, 4, 5, 4, 5, 6};
2093 CheckSharedArrKeyValue(thread, valueHandle, descRes, keys, vals);
2094 }
2095
HWTEST_F_L0(BuiltinsSharedArrayTest,CopyWithin_Five)2096 HWTEST_F_L0(BuiltinsSharedArrayTest, CopyWithin_Five)
2097 {
2098 std::vector<int> descVals{1, 2, 3, 4, 5, 6, 7, 8};
2099 JSHandle<JSTaggedValue> lengthKeyHandle = thread->GlobalConstants()->GetHandledLengthString();
2100 JSSharedArray *arr = JSSharedArray::Cast(JSSharedArray::ArrayCreate(thread,
2101 JSTaggedNumber(0)).GetTaggedValue().GetTaggedObject());
2102 EXPECT_TRUE(arr != nullptr);
2103 JSHandle<JSObject> obj(thread, arr);
2104 EXPECT_EQ(JSSharedArray::GetProperty(thread, JSHandle<JSTaggedValue>(obj), lengthKeyHandle,
2105 SCheckMode::SKIP).GetValue()->GetInt(), 0);
2106 auto keys = DefineSharedArrProperty(thread, obj, descVals);
2107
2108 auto ecmaRuntimeCallInfo1 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 10);
2109 ecmaRuntimeCallInfo1->SetFunction(JSTaggedValue::Undefined());
2110 ecmaRuntimeCallInfo1->SetThis(obj.GetTaggedValue());
2111 ecmaRuntimeCallInfo1->SetCallArg(0, JSTaggedValue(static_cast<int32_t>(4)));
2112 ecmaRuntimeCallInfo1->SetCallArg(1, JSTaggedValue(static_cast<int32_t>(2)));
2113 ecmaRuntimeCallInfo1->SetCallArg(2, JSTaggedValue(JSTaggedValue::Undefined()));
2114
2115 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo1);
2116 JSTaggedValue result = Array::CopyWithin(ecmaRuntimeCallInfo1);
2117 TestHelper::TearDownFrame(thread, prev);
2118 JSTaggedValue value(static_cast<JSTaggedType>(result.GetRawData()));
2119 ASSERT_TRUE(value.IsECMAObject());
2120 PropertyDescriptor descRes(thread);
2121 JSHandle<JSObject> valueHandle(thread, value);
2122 std::vector<int> vals{1, 2, 3, 4, 3, 4, 5, 6};
2123 CheckSharedArrKeyValue(thread, valueHandle, descRes, keys, vals);
2124 }
2125
HWTEST_F_L0(BuiltinsSharedArrayTest,Reverse)2126 HWTEST_F_L0(BuiltinsSharedArrayTest, Reverse)
2127 {
2128 std::vector<int> descVals{1, 2, 3, 4, 5};
2129 JSHandle<JSTaggedValue> lengthKeyHandle = thread->GlobalConstants()->GetHandledLengthString();
2130 JSSharedArray *arr = JSSharedArray::Cast(JSSharedArray::ArrayCreate(thread,
2131 JSTaggedNumber(0)).GetTaggedValue().GetTaggedObject());
2132 EXPECT_TRUE(arr != nullptr);
2133 JSHandle<JSObject> obj(thread, arr);
2134 EXPECT_EQ(JSSharedArray::GetProperty(thread, JSHandle<JSTaggedValue>(obj), lengthKeyHandle,
2135 SCheckMode::SKIP).GetValue()->GetInt(), 0);
2136 auto keys = DefineSharedArrProperty(thread, obj, descVals);
2137
2138 auto ecmaRuntimeCallInfo1 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 4);
2139 ecmaRuntimeCallInfo1->SetFunction(JSTaggedValue::Undefined());
2140 ecmaRuntimeCallInfo1->SetThis(obj.GetTaggedValue());
2141
2142 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo1);
2143 JSTaggedValue result = Array::Reverse(ecmaRuntimeCallInfo1);
2144 TestHelper::TearDownFrame(thread, prev);
2145 JSTaggedValue value(static_cast<JSTaggedType>(result.GetRawData()));
2146 ASSERT_TRUE(value.IsECMAObject());
2147 PropertyDescriptor descRes(thread);
2148 JSHandle<JSObject> valueHandle(thread, value);
2149 std::vector<int> vals{5, 4, 3, 2, 1};
2150 CheckSharedArrKeyValue(thread, valueHandle, descRes, keys, vals);
2151 }
2152
HWTEST_F_L0(BuiltinsSharedArrayTest,Reverse_one)2153 HWTEST_F_L0(BuiltinsSharedArrayTest, Reverse_one)
2154 {
2155 std::vector<double> descVals{1.5, 2.3, 3.6, 4.4, 5.9};
2156 JSHandle<JSTaggedValue> lengthKeyHandle = thread->GlobalConstants()->GetHandledLengthString();
2157 JSSharedArray *arr = JSSharedArray::Cast(JSSharedArray::ArrayCreate(thread,
2158 JSTaggedNumber(0)).GetTaggedValue().GetTaggedObject());
2159 EXPECT_TRUE(arr != nullptr);
2160 JSHandle<JSObject> obj(thread, arr);
2161 EXPECT_EQ(JSSharedArray::GetProperty(thread, JSHandle<JSTaggedValue>(obj), lengthKeyHandle,
2162 SCheckMode::SKIP).GetValue()->GetInt(), 0);
2163 auto keys = DefineSharedArrProperty<double>(thread, obj, descVals);
2164
2165 auto ecmaRuntimeCallInfo1 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 4);
2166 ecmaRuntimeCallInfo1->SetFunction(JSTaggedValue::Undefined());
2167 ecmaRuntimeCallInfo1->SetThis(obj.GetTaggedValue());
2168
2169 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo1);
2170 JSTaggedValue result = Array::Reverse(ecmaRuntimeCallInfo1);
2171 TestHelper::TearDownFrame(thread, prev);
2172 JSTaggedValue value(static_cast<JSTaggedType>(result.GetRawData()));
2173 ASSERT_TRUE(value.IsECMAObject());
2174 PropertyDescriptor descRes(thread);
2175 JSHandle<JSObject> valueHandle(thread, value);
2176 std::vector<double> vals{5.9, 4.4, 3.6, 2.3, 1.5};
2177 CheckSharedArrKeyValue<double>(thread, valueHandle, descRes, keys, vals);
2178 }
2179 } // namespace panda::test
2180