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