1 /*
2 * Copyright (c) 2022 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_atomics.h"
17
18 #include "ecmascript/builtins/builtins_array.h"
19 #include "ecmascript/builtins/builtins_typedarray.h"
20 #include "ecmascript/builtins/builtins_sharedarraybuffer.h"
21 #include "ecmascript/js_arraybuffer.h"
22 #include "ecmascript/base/atomic_helper.h"
23 #include "ecmascript/js_tagged_value.h"
24 #include "ecmascript/ecma_vm.h"
25 #include "ecmascript/global_env.h"
26 #include "ecmascript/js_array.h"
27 #include "ecmascript/js_handle.h"
28 #include "ecmascript/js_thread.h"
29 #include "ecmascript/js_typed_array.h"
30 #include "ecmascript/tests/test_helper.h"
31
32 using namespace panda::ecmascript;
33 using namespace panda::ecmascript::builtins;
34
35 namespace panda::test {
36 using TypedArray = ecmascript::builtins::BuiltinsTypedArray;
37 class BuiltinsAtomicsTest : public testing::Test {
38 public:
SetUpTestCase()39 static void SetUpTestCase()
40 {
41 GTEST_LOG_(INFO) << "SetUpTestCase";
42 }
43
TearDownTestCase()44 static void TearDownTestCase()
45 {
46 GTEST_LOG_(INFO) << "TearDownCase";
47 }
48
SetUp()49 void SetUp() override
50 {
51 TestHelper::CreateEcmaVMWithScope(instance, thread, scope);
52 }
53
TearDown()54 void TearDown() override
55 {
56 TestHelper::DestroyEcmaVMWithScope(instance, scope);
57 }
58
59 EcmaVM *instance {nullptr};
60 EcmaHandleScope *scope {nullptr};
61 JSThread *thread {nullptr};
62 };
63
CreateTypedArray(JSThread * thread,const JSHandle<TaggedArray> & array)64 JSTypedArray *CreateTypedArray(JSThread *thread, const JSHandle<TaggedArray> &array)
65 {
66 auto ecmaVM = thread->GetEcmaVM();
67 JSHandle<GlobalEnv> env = ecmaVM->GetGlobalEnv();
68
69 JSHandle<JSTaggedValue> jsarray(JSArray::CreateArrayFromList(thread, array));
70 JSHandle<JSFunction> int8_array(env->GetInt8ArrayFunction());
71 JSHandle<JSObject> globalObject(thread, env->GetGlobalObject());
72 // 6 : test case
73 auto ecmaRuntimeCallInfo1 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue(*int8_array), 6);
74 ecmaRuntimeCallInfo1->SetFunction(JSTaggedValue(*int8_array));
75 ecmaRuntimeCallInfo1->SetThis(JSTaggedValue(*globalObject));
76 ecmaRuntimeCallInfo1->SetCallArg(0, jsarray.GetTaggedValue());
77
78 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo1);
79 JSTaggedValue result = TypedArray::Int8ArrayConstructor(ecmaRuntimeCallInfo1);
80 TestHelper::TearDownFrame(thread, prev);
81
82 EXPECT_TRUE(result.IsECMAObject());
83 JSTypedArray *int8arr = JSTypedArray::Cast(reinterpret_cast<TaggedObject *>(result.GetRawData()));
84 return int8arr;
85 }
86
CreateTypedArray(JSThread * thread,const JSHandle<TaggedArray> & array,DataViewType type)87 JSTypedArray *CreateTypedArray(JSThread *thread, const JSHandle<TaggedArray> &array, DataViewType type)
88 {
89 auto vm = thread->GetEcmaVM();
90 auto env = vm->GetGlobalEnv();
91 JSHandle<JSTaggedValue> jsarray(JSArray::CreateArrayFromList(thread, array));
92 JSHandle<JSObject> globalObject(thread, env->GetGlobalObject());
93 JSHandle<JSFunction> arrayFunc;
94 JSTaggedValue result = JSTaggedValue::Hole();
95 switch (type) {
96 case DataViewType::BIGINT64: {
97 arrayFunc = JSHandle<JSFunction>(env->GetBigInt64ArrayFunction());
98 auto ecmaRuntimeCallInfo1 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue(*arrayFunc), 6);
99 ecmaRuntimeCallInfo1->SetFunction(JSTaggedValue(*arrayFunc));
100 ecmaRuntimeCallInfo1->SetThis(JSTaggedValue(*globalObject));
101 ecmaRuntimeCallInfo1->SetCallArg(0, jsarray.GetTaggedValue());
102
103 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo1);
104 result = TypedArray::BigInt64ArrayConstructor(ecmaRuntimeCallInfo1);
105 TestHelper::TearDownFrame(thread, prev);
106 break;
107 }
108 case DataViewType::BIGUINT64: {
109 arrayFunc = JSHandle<JSFunction>(env->GetBigUint64ArrayFunction());
110 auto ecmaRuntimeCallInfo1 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue(*arrayFunc), 6);
111 ecmaRuntimeCallInfo1->SetFunction(JSTaggedValue(*arrayFunc));
112 ecmaRuntimeCallInfo1->SetThis(JSTaggedValue(*globalObject));
113 ecmaRuntimeCallInfo1->SetCallArg(0, jsarray.GetTaggedValue());
114
115 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo1);
116 result = TypedArray::BigUint64ArrayConstructor(ecmaRuntimeCallInfo1);
117 TestHelper::TearDownFrame(thread, prev);
118 break;
119 }
120 case DataViewType::INT16: {
121 arrayFunc = JSHandle<JSFunction>(env->GetInt16ArrayFunction());
122 auto ecmaRuntimeCallInfo1 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue(*arrayFunc), 6);
123 ecmaRuntimeCallInfo1->SetFunction(JSTaggedValue(*arrayFunc));
124 ecmaRuntimeCallInfo1->SetThis(JSTaggedValue(*globalObject));
125 ecmaRuntimeCallInfo1->SetCallArg(0, jsarray.GetTaggedValue());
126
127 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo1);
128 result = TypedArray::Int16ArrayConstructor(ecmaRuntimeCallInfo1);
129 TestHelper::TearDownFrame(thread, prev);
130 break;
131 }
132 case DataViewType::INT32: {
133 arrayFunc = JSHandle<JSFunction>(env->GetInt32ArrayFunction());
134 auto ecmaRuntimeCallInfo1 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue(*arrayFunc), 6);
135 ecmaRuntimeCallInfo1->SetFunction(JSTaggedValue(*arrayFunc));
136 ecmaRuntimeCallInfo1->SetThis(JSTaggedValue(*globalObject));
137 ecmaRuntimeCallInfo1->SetCallArg(0, jsarray.GetTaggedValue());
138
139 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo1);
140 result = TypedArray::Int32ArrayConstructor(ecmaRuntimeCallInfo1);
141 TestHelper::TearDownFrame(thread, prev);
142 break;
143 }
144 case DataViewType::INT8: {
145 arrayFunc = JSHandle<JSFunction>(env->GetInt8ArrayFunction());
146 auto ecmaRuntimeCallInfo1 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue(*arrayFunc), 6);
147 ecmaRuntimeCallInfo1->SetFunction(JSTaggedValue(*arrayFunc));
148 ecmaRuntimeCallInfo1->SetThis(JSTaggedValue(*globalObject));
149 ecmaRuntimeCallInfo1->SetCallArg(0, jsarray.GetTaggedValue());
150
151 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo1);
152 result = TypedArray::Int8ArrayConstructor(ecmaRuntimeCallInfo1);
153 TestHelper::TearDownFrame(thread, prev);
154 break;
155 }
156 case DataViewType::UINT16: {
157 arrayFunc = JSHandle<JSFunction>(env->GetUint16ArrayFunction());
158 auto ecmaRuntimeCallInfo1 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue(*arrayFunc), 6);
159 ecmaRuntimeCallInfo1->SetFunction(JSTaggedValue(*arrayFunc));
160 ecmaRuntimeCallInfo1->SetThis(JSTaggedValue(*globalObject));
161 ecmaRuntimeCallInfo1->SetCallArg(0, jsarray.GetTaggedValue());
162
163 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo1);
164 result = TypedArray::Uint16ArrayConstructor(ecmaRuntimeCallInfo1);
165 TestHelper::TearDownFrame(thread, prev);
166 break;
167 }
168 case DataViewType::UINT32: {
169 arrayFunc = JSHandle<JSFunction>(env->GetUint32ArrayFunction());
170 auto ecmaRuntimeCallInfo1 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue(*arrayFunc), 6);
171 ecmaRuntimeCallInfo1->SetFunction(JSTaggedValue(*arrayFunc));
172 ecmaRuntimeCallInfo1->SetThis(JSTaggedValue(*globalObject));
173 ecmaRuntimeCallInfo1->SetCallArg(0, jsarray.GetTaggedValue());
174
175 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo1);
176 result = TypedArray::Uint32ArrayConstructor(ecmaRuntimeCallInfo1);
177 TestHelper::TearDownFrame(thread, prev);
178 break;
179 }
180 case DataViewType::UINT8: {
181 arrayFunc = JSHandle<JSFunction>(env->GetUint8ArrayFunction());
182 auto ecmaRuntimeCallInfo1 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue(*arrayFunc), 6);
183 ecmaRuntimeCallInfo1->SetFunction(JSTaggedValue(*arrayFunc));
184 ecmaRuntimeCallInfo1->SetThis(JSTaggedValue(*globalObject));
185 ecmaRuntimeCallInfo1->SetCallArg(0, jsarray.GetTaggedValue());
186
187 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo1);
188 result = TypedArray::Uint8ArrayConstructor(ecmaRuntimeCallInfo1);
189 TestHelper::TearDownFrame(thread, prev);
190 break;
191 }
192 default: {
193 JSHandle<JSTaggedValue> undefined(thread, JSTaggedValue::Undefined());
194 arrayFunc = JSHandle<JSFunction>(undefined);
195 break;
196 }
197 }
198 EXPECT_TRUE(result.IsECMAObject());
199 JSTypedArray *arr = JSTypedArray::Cast(reinterpret_cast<TaggedObject *>(result.GetRawData()));
200 return arr;
201 }
202
CreateSharedArrayBuffer(JSThread * thread,int32_t length)203 JSTaggedValue CreateSharedArrayBuffer(JSThread *thread, int32_t length)
204 {
205 JSHandle<GlobalEnv> env = thread->GetEcmaVM()->GetGlobalEnv();
206 JSHandle<JSFunction> sharedArrayBuffer(thread, env->GetSharedArrayBufferFunction().GetTaggedValue());
207 JSHandle<JSObject> globalObject(thread, env->GetGlobalObject());
208 // 6 : test case
209 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, sharedArrayBuffer.GetTaggedValue(), 6);
210 ecmaRuntimeCallInfo->SetFunction(sharedArrayBuffer.GetTaggedValue());
211 ecmaRuntimeCallInfo->SetThis(globalObject.GetTaggedValue());
212 ecmaRuntimeCallInfo->SetCallArg(0, JSTaggedValue(length));
213
214 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo);
215 JSTaggedValue result = BuiltinsSharedArrayBuffer::SharedArrayBufferConstructor(ecmaRuntimeCallInfo);
216 TestHelper::TearDownFrame(thread, prev);
217 return result;
218 }
219
CreateInt32TypedArray(JSThread * thread,const JSHandle<JSArrayBuffer> & arrBuf)220 JSTypedArray *CreateInt32TypedArray(JSThread *thread, const JSHandle<JSArrayBuffer> &arrBuf)
221 {
222 auto ecmaVM = thread->GetEcmaVM();
223 JSHandle<GlobalEnv> env = ecmaVM->GetGlobalEnv();
224
225 JSHandle<JSFunction> int32_array(env->GetInt32ArrayFunction());
226 JSHandle<JSObject> globalObject(thread, env->GetGlobalObject());
227 // 6 : test case
228 auto ecmaRuntimeCallInfo1 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue(*int32_array), 6);
229 ecmaRuntimeCallInfo1->SetFunction(JSTaggedValue(*int32_array));
230 ecmaRuntimeCallInfo1->SetThis(JSTaggedValue(*globalObject));
231 ecmaRuntimeCallInfo1->SetCallArg(0, arrBuf.GetTaggedValue());
232
233 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo1);
234 JSTaggedValue result = TypedArray::Int32ArrayConstructor(ecmaRuntimeCallInfo1);
235 TestHelper::TearDownFrame(thread, prev);
236
237 EXPECT_TRUE(result.IsECMAObject());
238 JSTypedArray *int32arr = JSTypedArray::Cast(reinterpret_cast<TaggedObject *>(result.GetRawData()));
239 return int32arr;
240 }
241
HWTEST_F_L0(BuiltinsAtomicsTest,Add_1)242 HWTEST_F_L0(BuiltinsAtomicsTest, Add_1)
243 {
244 ASSERT_NE(thread, nullptr);
245 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
246 [[maybe_unused]] JSHandle<TaggedArray> array(factory->NewTaggedArray(3));
247 array->Set(thread, 0, JSTaggedValue(7));
248 array->Set(thread, 1, JSTaggedValue(8));
249 array->Set(thread, 2, JSTaggedValue(9));
250
251 JSHandle<JSTaggedValue> obj = JSHandle<JSTaggedValue>(thread, CreateTypedArray(thread, array, DataViewType::UINT8));
252 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 10);
253 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
254 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
255 ecmaRuntimeCallInfo->SetCallArg(0, obj.GetTaggedValue());
256 ecmaRuntimeCallInfo->SetCallArg(1, JSTaggedValue(static_cast<int32_t>(0)));
257 ecmaRuntimeCallInfo->SetCallArg(2, JSTaggedValue(static_cast<int32_t>(5)));
258
259 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo);
260 JSTaggedValue result = BuiltinsAtomics::Add(ecmaRuntimeCallInfo);
261 TestHelper::TearDownFrame(thread, prev);
262 ASSERT_EQ(result.GetInt(), 7);
263 }
264
HWTEST_F_L0(BuiltinsAtomicsTest,Add_2)265 HWTEST_F_L0(BuiltinsAtomicsTest, Add_2)
266 {
267 ASSERT_NE(thread, nullptr);
268 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
269 [[maybe_unused]] JSHandle<TaggedArray> array(factory->NewTaggedArray(10));
270
271 JSHandle<JSTaggedValue> obj = JSHandle<JSTaggedValue>(thread, CreateTypedArray(thread, array, DataViewType::INT8));
272 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 10);
273 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
274 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
275 ecmaRuntimeCallInfo->SetCallArg(0, obj.GetTaggedValue());
276 ecmaRuntimeCallInfo->SetCallArg(1, JSTaggedValue(static_cast<int32_t>(0)));
277 ecmaRuntimeCallInfo->SetCallArg(2, JSTaggedValue(static_cast<int32_t>(2)));
278
279 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo);
280 JSTaggedValue result = BuiltinsAtomics::Add(ecmaRuntimeCallInfo);
281 TestHelper::TearDownFrame(thread, prev);
282 ASSERT_EQ(result.GetInt(), 0);
283 }
284
HWTEST_F_L0(BuiltinsAtomicsTest,Add_3)285 HWTEST_F_L0(BuiltinsAtomicsTest, Add_3)
286 {
287 ASSERT_NE(thread, nullptr);
288 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
289 [[maybe_unused]] JSHandle<TaggedArray> array(factory->NewTaggedArray(3));
290
291 JSHandle<JSTaggedValue> obj = JSHandle<JSTaggedValue>(thread, CreateTypedArray(thread, array,
292 DataViewType::UINT16));
293 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 10);
294 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
295 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
296 ecmaRuntimeCallInfo->SetCallArg(0, obj.GetTaggedValue());
297 ecmaRuntimeCallInfo->SetCallArg(1, JSTaggedValue(static_cast<int32_t>(0)));
298 ecmaRuntimeCallInfo->SetCallArg(2, JSTaggedValue(static_cast<int32_t>(2)));
299
300 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo);
301 JSTaggedValue result = BuiltinsAtomics::Add(ecmaRuntimeCallInfo);
302 TestHelper::TearDownFrame(thread, prev);
303 ASSERT_EQ(result.GetInt(), 0);
304
305
306 auto ecmaRuntimeCallInfos = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 8);
307 ecmaRuntimeCallInfos->SetFunction(JSTaggedValue::Undefined());
308 ecmaRuntimeCallInfos->SetThis(JSTaggedValue::Undefined());
309 ecmaRuntimeCallInfos->SetCallArg(0, obj.GetTaggedValue());
310 ecmaRuntimeCallInfos->SetCallArg(1, JSTaggedValue(static_cast<int32_t>(0)));
311
312 prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfos);
313 JSTaggedValue results = BuiltinsAtomics::Load(ecmaRuntimeCallInfos);
314 TestHelper::TearDownFrame(thread, prev);
315 ASSERT_EQ(results.GetInt(), 2);
316 }
317
HWTEST_F_L0(BuiltinsAtomicsTest,SubAndAdd_1)318 HWTEST_F_L0(BuiltinsAtomicsTest, SubAndAdd_1)
319 {
320 ASSERT_NE(thread, nullptr);
321 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
322 [[maybe_unused]] JSHandle<TaggedArray> array(factory->NewTaggedArray(3));
323 array->Set(thread, 0, JSTaggedValue(5));
324 array->Set(thread, 1, JSTaggedValue(0));
325 array->Set(thread, 2, JSTaggedValue(0));
326 JSHandle<JSTaggedValue> obj = JSHandle<JSTaggedValue>(thread, CreateTypedArray(thread, array, DataViewType::INT16));
327 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 10);
328 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
329 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
330 ecmaRuntimeCallInfo->SetCallArg(0, obj.GetTaggedValue());
331 ecmaRuntimeCallInfo->SetCallArg(1, JSTaggedValue(static_cast<int32_t>(0)));
332 ecmaRuntimeCallInfo->SetCallArg(2, JSTaggedValue(static_cast<int32_t>(2)));
333
334 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo);
335 BuiltinsAtomics::Sub(ecmaRuntimeCallInfo);
336 JSTaggedValue addResult = BuiltinsAtomics::Add(ecmaRuntimeCallInfo);
337 TestHelper::TearDownFrame(thread, prev);
338 ASSERT_EQ(addResult.GetInt(), 3);
339 }
340
HWTEST_F_L0(BuiltinsAtomicsTest,And_1)341 HWTEST_F_L0(BuiltinsAtomicsTest, And_1)
342 {
343 ASSERT_NE(thread, nullptr);
344 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
345 [[maybe_unused]] JSHandle<TaggedArray> array(factory->NewTaggedArray(10));
346 array->Set(thread, 0, JSTaggedValue(7));
347 array->Set(thread, 1, JSTaggedValue(0));
348 array->Set(thread, 2, JSTaggedValue(0));
349
350 JSHandle<JSTaggedValue> obj = JSHandle<JSTaggedValue>(thread, CreateTypedArray(thread, array, DataViewType::INT32));
351 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 10);
352 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
353 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
354 ecmaRuntimeCallInfo->SetCallArg(0, obj.GetTaggedValue());
355 ecmaRuntimeCallInfo->SetCallArg(1, JSTaggedValue(static_cast<int32_t>(0)));
356 ecmaRuntimeCallInfo->SetCallArg(2, JSTaggedValue(static_cast<int32_t>(2)));
357
358 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo);
359 JSTaggedValue result = BuiltinsAtomics::Add(ecmaRuntimeCallInfo);
360 TestHelper::TearDownFrame(thread, prev);
361 ASSERT_EQ(result.GetInt(), 7);
362 }
363
HWTEST_F_L0(BuiltinsAtomicsTest,And_2)364 HWTEST_F_L0(BuiltinsAtomicsTest, And_2)
365 {
366 ASSERT_NE(thread, nullptr);
367 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
368 [[maybe_unused]] JSHandle<TaggedArray> array(factory->NewTaggedArray(10));
369 array->Set(thread, 0, JSTaggedValue(7));
370 array->Set(thread, 1, JSTaggedValue(0));
371 array->Set(thread, 2, JSTaggedValue(0));
372
373 JSHandle<JSTaggedValue> obj = JSHandle<JSTaggedValue>(thread, CreateTypedArray(thread, array,
374 DataViewType::UINT32));
375 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 10);
376 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
377 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
378 ecmaRuntimeCallInfo->SetCallArg(0, obj.GetTaggedValue());
379 ecmaRuntimeCallInfo->SetCallArg(1, JSTaggedValue(static_cast<int32_t>(0)));
380 ecmaRuntimeCallInfo->SetCallArg(2, JSTaggedValue(static_cast<int32_t>(2)));
381
382 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo);
383 JSTaggedValue result = BuiltinsAtomics::And(ecmaRuntimeCallInfo);
384 TestHelper::TearDownFrame(thread, prev);
385 ASSERT_EQ(result.GetInt(), 7);
386
387
388 auto ecmaRuntimeCallInfos = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 8);
389 ecmaRuntimeCallInfos->SetFunction(JSTaggedValue::Undefined());
390 ecmaRuntimeCallInfos->SetThis(JSTaggedValue::Undefined());
391 ecmaRuntimeCallInfos->SetCallArg(0, obj.GetTaggedValue());
392 ecmaRuntimeCallInfos->SetCallArg(1, JSTaggedValue(static_cast<int32_t>(0)));
393
394 prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfos);
395 result = BuiltinsAtomics::Load(ecmaRuntimeCallInfos);
396 TestHelper::TearDownFrame(thread, prev);
397 ASSERT_EQ(result.GetInt(), 2);
398 }
399
HWTEST_F_L0(BuiltinsAtomicsTest,CompareExchange_1)400 HWTEST_F_L0(BuiltinsAtomicsTest, CompareExchange_1)
401 {
402 ASSERT_NE(thread, nullptr);
403 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
404 [[maybe_unused]] JSHandle<TaggedArray> array(factory->NewTaggedArray(3));
405 array->Set(thread, 0, JSTaggedValue(5));
406 array->Set(thread, 1, JSTaggedValue(0));
407 array->Set(thread, 2, JSTaggedValue(0));
408
409 JSHandle<JSTaggedValue> obj = JSHandle<JSTaggedValue>(thread, CreateTypedArray(thread, array, DataViewType::UINT8));
410 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 12);
411 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
412 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
413 ecmaRuntimeCallInfo->SetCallArg(0, obj.GetTaggedValue());
414 ecmaRuntimeCallInfo->SetCallArg(1, JSTaggedValue(static_cast<int32_t>(0)));
415 ecmaRuntimeCallInfo->SetCallArg(2, JSTaggedValue(static_cast<int32_t>(5)));
416 ecmaRuntimeCallInfo->SetCallArg(3, JSTaggedValue(static_cast<int32_t>(2)));
417
418 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo);
419 JSTaggedValue result = BuiltinsAtomics::CompareExchange(ecmaRuntimeCallInfo);
420 TestHelper::TearDownFrame(thread, prev);
421 ASSERT_EQ(result.GetInt(), 5);
422 }
423
HWTEST_F_L0(BuiltinsAtomicsTest,CompareExchange_2)424 HWTEST_F_L0(BuiltinsAtomicsTest, CompareExchange_2)
425 {
426 ASSERT_NE(thread, nullptr);
427 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
428 [[maybe_unused]] JSHandle<TaggedArray> array(factory->NewTaggedArray(3));
429 array->Set(thread, 0, JSTaggedValue(5));
430 array->Set(thread, 1, JSTaggedValue(0));
431 array->Set(thread, 2, JSTaggedValue(0));
432
433 JSHandle<JSTaggedValue> obj = JSHandle<JSTaggedValue>(thread, CreateTypedArray(thread, array, DataViewType::INT8));
434 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 12);
435 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
436 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
437 ecmaRuntimeCallInfo->SetCallArg(0, obj.GetTaggedValue());
438 ecmaRuntimeCallInfo->SetCallArg(1, JSTaggedValue(static_cast<int32_t>(0)));
439 ecmaRuntimeCallInfo->SetCallArg(2, JSTaggedValue(static_cast<int32_t>(5)));
440 ecmaRuntimeCallInfo->SetCallArg(3, JSTaggedValue(static_cast<int32_t>(2)));
441
442 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo);
443 JSTaggedValue result = BuiltinsAtomics::CompareExchange(ecmaRuntimeCallInfo);
444 TestHelper::TearDownFrame(thread, prev);
445 ASSERT_EQ(result.GetInt(), 5);
446
447
448 auto ecmaRuntimeCallInfos = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 8);
449 ecmaRuntimeCallInfos->SetFunction(JSTaggedValue::Undefined());
450 ecmaRuntimeCallInfos->SetThis(JSTaggedValue::Undefined());
451 ecmaRuntimeCallInfos->SetCallArg(0, obj.GetTaggedValue());
452 ecmaRuntimeCallInfos->SetCallArg(1, JSTaggedValue(static_cast<int32_t>(0)));
453
454 prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfos);
455 result = BuiltinsAtomics::Load(ecmaRuntimeCallInfos);
456 TestHelper::TearDownFrame(thread, prev);
457 ASSERT_EQ(result.GetInt(), 2);
458 }
459
HWTEST_F_L0(BuiltinsAtomicsTest,TypedArrayCover)460 HWTEST_F_L0(BuiltinsAtomicsTest, TypedArrayCover)
461 {
462 ASSERT_NE(thread, nullptr);
463 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
464 [[maybe_unused]] JSHandle<TaggedArray> array(factory->NewTaggedArray(3));
465 array->Set(thread, 0, JSTaggedValue(2));
466 array->Set(thread, 1, JSTaggedValue(0));
467 array->Set(thread, 2, JSTaggedValue(0));
468 // UINT16
469 JSHandle<JSTaggedValue> obj = JSHandle<JSTaggedValue>(thread, CreateTypedArray(thread, array,
470 DataViewType::UINT16));
471 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 12);
472 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
473 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
474 ecmaRuntimeCallInfo->SetCallArg(0, obj.GetTaggedValue());
475 ecmaRuntimeCallInfo->SetCallArg(1, JSTaggedValue(static_cast<int32_t>(0)));
476 ecmaRuntimeCallInfo->SetCallArg(2, JSTaggedValue(static_cast<int32_t>(2)));
477 ecmaRuntimeCallInfo->SetCallArg(3, JSTaggedValue(static_cast<int32_t>(2)));
478
479 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo);
480 JSTaggedValue result = BuiltinsAtomics::CompareExchange(ecmaRuntimeCallInfo);
481 TestHelper::TearDownFrame(thread, prev);
482 ASSERT_EQ(result.GetInt(), 2);
483 // INT16
484 obj = JSHandle<JSTaggedValue>(thread, CreateTypedArray(thread, array, DataViewType::INT16));
485 ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 12);
486 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
487 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
488 ecmaRuntimeCallInfo->SetCallArg(0, obj.GetTaggedValue());
489 ecmaRuntimeCallInfo->SetCallArg(1, JSTaggedValue(static_cast<int32_t>(0)));
490 ecmaRuntimeCallInfo->SetCallArg(2, JSTaggedValue(static_cast<int32_t>(2)));
491 ecmaRuntimeCallInfo->SetCallArg(3, JSTaggedValue(static_cast<int32_t>(2)));
492
493 prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo);
494 result = BuiltinsAtomics::CompareExchange(ecmaRuntimeCallInfo);
495 TestHelper::TearDownFrame(thread, prev);
496 ASSERT_EQ(result.GetInt(), 2);
497 // UINT32
498 obj = JSHandle<JSTaggedValue>(thread, CreateTypedArray(thread, array, DataViewType::UINT32));
499 ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 12);
500 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
501 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
502 ecmaRuntimeCallInfo->SetCallArg(0, obj.GetTaggedValue());
503 ecmaRuntimeCallInfo->SetCallArg(1, JSTaggedValue(static_cast<int32_t>(0)));
504 ecmaRuntimeCallInfo->SetCallArg(2, JSTaggedValue(static_cast<int32_t>(2)));
505 ecmaRuntimeCallInfo->SetCallArg(3, JSTaggedValue(static_cast<int32_t>(2)));
506
507 prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo);
508 result = BuiltinsAtomics::CompareExchange(ecmaRuntimeCallInfo);
509 TestHelper::TearDownFrame(thread, prev);
510 ASSERT_EQ(result.GetInt(), 2);
511 // INT32
512 obj = JSHandle<JSTaggedValue>(thread, CreateTypedArray(thread, array, DataViewType::INT32));
513 ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 12);
514 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
515 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
516 ecmaRuntimeCallInfo->SetCallArg(0, obj.GetTaggedValue());
517 ecmaRuntimeCallInfo->SetCallArg(1, JSTaggedValue(static_cast<int32_t>(0)));
518 ecmaRuntimeCallInfo->SetCallArg(2, JSTaggedValue(static_cast<int32_t>(2)));
519 ecmaRuntimeCallInfo->SetCallArg(3, JSTaggedValue(static_cast<int32_t>(2)));
520
521 prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo);
522 result = BuiltinsAtomics::CompareExchange(ecmaRuntimeCallInfo);
523 TestHelper::TearDownFrame(thread, prev);
524 ASSERT_EQ(result.GetInt(), 2);
525
526 // Detached Buffer
527 JSTaggedValue tagged = CreateSharedArrayBuffer(thread, 0);
528 JSHandle<JSArrayBuffer> arrBuf(thread, JSArrayBuffer::Cast(reinterpret_cast<TaggedObject *>(tagged.GetRawData())));
529 obj = JSHandle<JSTaggedValue>(thread, CreateInt32TypedArray(thread, arrBuf));
530 arrBuf->SetArrayBufferData(thread, JSTaggedValue::Null());
531 ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 12);
532 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
533 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
534 ecmaRuntimeCallInfo->SetCallArg(0, obj.GetTaggedValue());
535 ecmaRuntimeCallInfo->SetCallArg(1, JSTaggedValue(static_cast<int32_t>(0)));
536 ecmaRuntimeCallInfo->SetCallArg(2, JSTaggedValue(static_cast<int32_t>(2)));
537 ecmaRuntimeCallInfo->SetCallArg(3, JSTaggedValue(static_cast<int32_t>(2)));
538
539 prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo);
540 result = BuiltinsAtomics::CompareExchange(ecmaRuntimeCallInfo);
541 TestHelper::TearDownFrame(thread, prev);
542 EXPECT_TRUE(thread->HasPendingException());
543 EXPECT_EQ(result, JSTaggedValue::Exception());
544 thread->ClearException();
545 }
546
HWTEST_F_L0(BuiltinsAtomicsTest,Exchange_1)547 HWTEST_F_L0(BuiltinsAtomicsTest, Exchange_1)
548 {
549 ASSERT_NE(thread, nullptr);
550 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
551 [[maybe_unused]] JSHandle<TaggedArray> array(factory->NewTaggedArray(3));
552 array->Set(thread, 0, JSTaggedValue(3));
553 array->Set(thread, 1, JSTaggedValue(0));
554 array->Set(thread, 2, JSTaggedValue(0));
555
556 JSHandle<JSTaggedValue> obj = JSHandle<JSTaggedValue>(thread, CreateTypedArray(thread, array));
557 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 10);
558 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
559 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
560 ecmaRuntimeCallInfo->SetCallArg(0, obj.GetTaggedValue());
561 ecmaRuntimeCallInfo->SetCallArg(1, JSTaggedValue(static_cast<int32_t>(0)));
562 ecmaRuntimeCallInfo->SetCallArg(2, JSTaggedValue(static_cast<int32_t>(6)));
563
564 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo);
565 JSTaggedValue result = BuiltinsAtomics::Exchange(ecmaRuntimeCallInfo);
566 TestHelper::TearDownFrame(thread, prev);
567 ASSERT_EQ(result.GetInt(), 3);
568 }
569
HWTEST_F_L0(BuiltinsAtomicsTest,Exchange_2)570 HWTEST_F_L0(BuiltinsAtomicsTest, Exchange_2)
571 {
572 ASSERT_NE(thread, nullptr);
573 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
574 [[maybe_unused]] JSHandle<TaggedArray> array(factory->NewTaggedArray(3));
575 array->Set(thread, 0, JSTaggedValue(3));
576 array->Set(thread, 1, JSTaggedValue(0));
577 array->Set(thread, 2, JSTaggedValue(0));
578
579 JSHandle<JSTaggedValue> obj = JSHandle<JSTaggedValue>(thread, CreateTypedArray(thread, array));
580 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 10);
581 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
582 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
583 ecmaRuntimeCallInfo->SetCallArg(0, obj.GetTaggedValue());
584 ecmaRuntimeCallInfo->SetCallArg(1, JSTaggedValue(static_cast<int32_t>(0)));
585 ecmaRuntimeCallInfo->SetCallArg(2, JSTaggedValue(static_cast<int32_t>(6)));
586
587 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo);
588 JSTaggedValue result = BuiltinsAtomics::Exchange(ecmaRuntimeCallInfo);
589 TestHelper::TearDownFrame(thread, prev);
590 ASSERT_EQ(result.GetInt(), 3);
591
592
593 auto ecmaRuntimeCallInfos = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 8);
594 ecmaRuntimeCallInfos->SetFunction(JSTaggedValue::Undefined());
595 ecmaRuntimeCallInfos->SetThis(JSTaggedValue::Undefined());
596 ecmaRuntimeCallInfos->SetCallArg(0, obj.GetTaggedValue());
597 ecmaRuntimeCallInfos->SetCallArg(1, JSTaggedValue(static_cast<int32_t>(0)));
598
599 prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfos);
600 result = BuiltinsAtomics::Load(ecmaRuntimeCallInfos);
601 TestHelper::TearDownFrame(thread, prev);
602 ASSERT_EQ(result.GetInt(), 6);
603 }
604
HWTEST_F_L0(BuiltinsAtomicsTest,Or_1)605 HWTEST_F_L0(BuiltinsAtomicsTest, Or_1)
606 {
607 ASSERT_NE(thread, nullptr);
608 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
609 [[maybe_unused]] JSHandle<TaggedArray> array(factory->NewTaggedArray(3));
610 array->Set(thread, 0, JSTaggedValue(5));
611 array->Set(thread, 1, JSTaggedValue(0));
612 array->Set(thread, 2, JSTaggedValue(0));
613
614 JSHandle<JSTaggedValue> obj = JSHandle<JSTaggedValue>(thread, CreateTypedArray(thread, array));
615 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 10);
616 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
617 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
618 ecmaRuntimeCallInfo->SetCallArg(0, obj.GetTaggedValue());
619 ecmaRuntimeCallInfo->SetCallArg(1, JSTaggedValue(static_cast<int32_t>(0)));
620 ecmaRuntimeCallInfo->SetCallArg(2, JSTaggedValue(static_cast<int32_t>(2)));
621
622 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo);
623 JSTaggedValue result = BuiltinsAtomics::Or(ecmaRuntimeCallInfo);
624 TestHelper::TearDownFrame(thread, prev);
625 ASSERT_EQ(result.GetInt(), 5);
626 }
627
HWTEST_F_L0(BuiltinsAtomicsTest,Or_2)628 HWTEST_F_L0(BuiltinsAtomicsTest, Or_2)
629 {
630 ASSERT_NE(thread, nullptr);
631 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
632 [[maybe_unused]] JSHandle<TaggedArray> array(factory->NewTaggedArray(3));
633 array->Set(thread, 0, JSTaggedValue(5));
634 array->Set(thread, 1, JSTaggedValue(0));
635 array->Set(thread, 2, JSTaggedValue(0));
636
637 JSHandle<JSTaggedValue> obj = JSHandle<JSTaggedValue>(thread, CreateTypedArray(thread, array));
638 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 12);
639 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
640 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
641 ecmaRuntimeCallInfo->SetCallArg(0, obj.GetTaggedValue());
642 ecmaRuntimeCallInfo->SetCallArg(1, JSTaggedValue(static_cast<int32_t>(0)));
643 ecmaRuntimeCallInfo->SetCallArg(2, JSTaggedValue(static_cast<int32_t>(2)));
644
645 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo);
646 JSTaggedValue result = BuiltinsAtomics::Or(ecmaRuntimeCallInfo);
647 TestHelper::TearDownFrame(thread, prev);
648 ASSERT_EQ(result.GetInt(), 5);
649
650
651 auto ecmaRuntimeCallInfos = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 8);
652 ecmaRuntimeCallInfos->SetFunction(JSTaggedValue::Undefined());
653 ecmaRuntimeCallInfos->SetThis(JSTaggedValue::Undefined());
654 ecmaRuntimeCallInfos->SetCallArg(0, obj.GetTaggedValue());
655 ecmaRuntimeCallInfos->SetCallArg(1, JSTaggedValue(static_cast<int32_t>(0)));
656
657 prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfos);
658 result = BuiltinsAtomics::Load(ecmaRuntimeCallInfos);
659 TestHelper::TearDownFrame(thread, prev);
660 ASSERT_EQ(result.GetInt(), 7);
661 }
662
HWTEST_F_L0(BuiltinsAtomicsTest,Sub_1)663 HWTEST_F_L0(BuiltinsAtomicsTest, Sub_1)
664 {
665 ASSERT_NE(thread, nullptr);
666 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
667 [[maybe_unused]] JSHandle<TaggedArray> array(factory->NewTaggedArray(3));
668 array->Set(thread, 0, JSTaggedValue(5));
669 array->Set(thread, 1, JSTaggedValue(0));
670 array->Set(thread, 2, JSTaggedValue(0));
671
672 JSHandle<JSTaggedValue> obj = JSHandle<JSTaggedValue>(thread, CreateTypedArray(thread, array));
673 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 10);
674 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
675 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
676 ecmaRuntimeCallInfo->SetCallArg(0, obj.GetTaggedValue());
677 ecmaRuntimeCallInfo->SetCallArg(1, JSTaggedValue(static_cast<int32_t>(0)));
678 ecmaRuntimeCallInfo->SetCallArg(2, JSTaggedValue(static_cast<int32_t>(2)));
679
680 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo);
681 JSTaggedValue result = BuiltinsAtomics::Sub(ecmaRuntimeCallInfo);
682 TestHelper::TearDownFrame(thread, prev);
683 ASSERT_EQ(result.GetInt(), 5);
684 }
685
HWTEST_F_L0(BuiltinsAtomicsTest,Sub_2)686 HWTEST_F_L0(BuiltinsAtomicsTest, Sub_2)
687 {
688 ASSERT_NE(thread, nullptr);
689 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
690 [[maybe_unused]] JSHandle<TaggedArray> array(factory->NewTaggedArray(3));
691 array->Set(thread, 0, JSTaggedValue(0));
692 array->Set(thread, 1, JSTaggedValue(5));
693 array->Set(thread, 2, JSTaggedValue(0));
694
695 JSHandle<JSTaggedValue> obj = JSHandle<JSTaggedValue>(thread, CreateTypedArray(thread, array));
696 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 10);
697 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
698 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
699 ecmaRuntimeCallInfo->SetCallArg(0, obj.GetTaggedValue());
700 ecmaRuntimeCallInfo->SetCallArg(1, JSTaggedValue(static_cast<int32_t>(1)));
701 ecmaRuntimeCallInfo->SetCallArg(2, JSTaggedValue(static_cast<int32_t>(2)));
702
703 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo);
704 JSTaggedValue result = BuiltinsAtomics::Sub(ecmaRuntimeCallInfo);
705 TestHelper::TearDownFrame(thread, prev);
706 ASSERT_EQ(result.GetInt(), 5);
707
708 auto ecmaRuntimeCallInfos = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 8);
709 ecmaRuntimeCallInfos->SetFunction(JSTaggedValue::Undefined());
710 ecmaRuntimeCallInfos->SetThis(JSTaggedValue::Undefined());
711 ecmaRuntimeCallInfos->SetCallArg(0, obj.GetTaggedValue());
712 ecmaRuntimeCallInfos->SetCallArg(1, JSTaggedValue(static_cast<int32_t>(1)));
713
714 prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfos);
715 result = BuiltinsAtomics::Load(ecmaRuntimeCallInfos);
716 TestHelper::TearDownFrame(thread, prev);
717 ASSERT_EQ(result.GetInt(), 3);
718 }
719
HWTEST_F_L0(BuiltinsAtomicsTest,Xor_1)720 HWTEST_F_L0(BuiltinsAtomicsTest, Xor_1)
721 {
722 ASSERT_NE(thread, nullptr);
723 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
724 [[maybe_unused]] JSHandle<TaggedArray> array(factory->NewTaggedArray(3));
725 array->Set(thread, 0, JSTaggedValue(5));
726 array->Set(thread, 1, JSTaggedValue(7));
727 array->Set(thread, 2, JSTaggedValue(0));
728
729 JSHandle<JSTaggedValue> obj = JSHandle<JSTaggedValue>(thread, CreateTypedArray(thread, array));
730 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 10);
731 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
732 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
733 ecmaRuntimeCallInfo->SetCallArg(0, obj.GetTaggedValue());
734 ecmaRuntimeCallInfo->SetCallArg(1, JSTaggedValue(static_cast<int32_t>(1)));
735 ecmaRuntimeCallInfo->SetCallArg(2, JSTaggedValue(static_cast<int32_t>(2)));
736
737 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo);
738 JSTaggedValue result = BuiltinsAtomics::Xor(ecmaRuntimeCallInfo);
739 TestHelper::TearDownFrame(thread, prev);
740 ASSERT_EQ(result.GetInt(), 7);
741 }
742
HWTEST_F_L0(BuiltinsAtomicsTest,Xor_2)743 HWTEST_F_L0(BuiltinsAtomicsTest, Xor_2)
744 {
745 ASSERT_NE(thread, nullptr);
746 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
747 [[maybe_unused]] JSHandle<TaggedArray> array(factory->NewTaggedArray(3));
748 array->Set(thread, 0, JSTaggedValue(5));
749 array->Set(thread, 1, JSTaggedValue(7));
750 array->Set(thread, 2, JSTaggedValue(0));
751
752 JSHandle<JSTaggedValue> obj = JSHandle<JSTaggedValue>(thread, CreateTypedArray(thread, array));
753 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 10);
754 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
755 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
756 ecmaRuntimeCallInfo->SetCallArg(0, obj.GetTaggedValue());
757 ecmaRuntimeCallInfo->SetCallArg(1, JSTaggedValue(static_cast<int32_t>(1)));
758 ecmaRuntimeCallInfo->SetCallArg(2, JSTaggedValue(static_cast<int32_t>(2)));
759
760 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo);
761 JSTaggedValue result = BuiltinsAtomics::Xor(ecmaRuntimeCallInfo);
762 TestHelper::TearDownFrame(thread, prev);
763 ASSERT_EQ(result.GetInt(), 7);
764
765 auto ecmaRuntimeCallInfos = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 8);
766 ecmaRuntimeCallInfos->SetFunction(JSTaggedValue::Undefined());
767 ecmaRuntimeCallInfos->SetThis(JSTaggedValue::Undefined());
768 ecmaRuntimeCallInfos->SetCallArg(0, obj.GetTaggedValue());
769 ecmaRuntimeCallInfos->SetCallArg(1, JSTaggedValue(static_cast<int32_t>(1)));
770
771 prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfos);
772 result = BuiltinsAtomics::Load(ecmaRuntimeCallInfos);
773 TestHelper::TearDownFrame(thread, prev);
774 ASSERT_EQ(result.GetInt(), 5);
775 }
776
HWTEST_F_L0(BuiltinsAtomicsTest,IsLockFree_1)777 HWTEST_F_L0(BuiltinsAtomicsTest, IsLockFree_1)
778 {
779 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 6);
780 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
781 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
782 ecmaRuntimeCallInfo->SetCallArg(0, JSTaggedValue(static_cast<int32_t>(1)));
783
784 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo);
785 JSTaggedValue result = BuiltinsAtomics::IsLockFree(ecmaRuntimeCallInfo);
786 TestHelper::TearDownFrame(thread, prev);
787 ASSERT_TRUE(result.ToBoolean());
788 }
789
HWTEST_F_L0(BuiltinsAtomicsTest,IsLockFree_2)790 HWTEST_F_L0(BuiltinsAtomicsTest, IsLockFree_2)
791 {
792 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 6);
793 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
794 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
795 ecmaRuntimeCallInfo->SetCallArg(0, JSTaggedValue(static_cast<int32_t>(2)));
796
797 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo);
798 JSTaggedValue result = BuiltinsAtomics::IsLockFree(ecmaRuntimeCallInfo);
799 TestHelper::TearDownFrame(thread, prev);
800 ASSERT_TRUE(result.ToBoolean());
801 }
802
HWTEST_F_L0(BuiltinsAtomicsTest,IsLockFree_3)803 HWTEST_F_L0(BuiltinsAtomicsTest, IsLockFree_3)
804 {
805 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 6);
806 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
807 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
808 ecmaRuntimeCallInfo->SetCallArg(0, JSTaggedValue(static_cast<int32_t>(4)));
809
810 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo);
811 JSTaggedValue result = BuiltinsAtomics::IsLockFree(ecmaRuntimeCallInfo);
812 TestHelper::TearDownFrame(thread, prev);
813 ASSERT_TRUE(result.ToBoolean());
814 }
815
HWTEST_F_L0(BuiltinsAtomicsTest,IsLockFree_4)816 HWTEST_F_L0(BuiltinsAtomicsTest, IsLockFree_4)
817 {
818 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 6);
819 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
820 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
821 ecmaRuntimeCallInfo->SetCallArg(0, JSTaggedValue(static_cast<int32_t>(-3)));
822
823 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo);
824 JSTaggedValue result = BuiltinsAtomics::IsLockFree(ecmaRuntimeCallInfo);
825 TestHelper::TearDownFrame(thread, prev);
826 ASSERT_FALSE(result.ToBoolean());
827 }
828
HWTEST_F_L0(BuiltinsAtomicsTest,IsLockFree_5)829 HWTEST_F_L0(BuiltinsAtomicsTest, IsLockFree_5)
830 {
831 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 6);
832 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
833 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
834 ecmaRuntimeCallInfo->SetCallArg(0, JSTaggedValue(static_cast<int32_t>(8)));
835
836 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo);
837 JSTaggedValue result = BuiltinsAtomics::IsLockFree(ecmaRuntimeCallInfo);
838 TestHelper::TearDownFrame(thread, prev);
839 ASSERT_TRUE(result.ToBoolean());
840 }
841
842
HWTEST_F_L0(BuiltinsAtomicsTest,Store_1)843 HWTEST_F_L0(BuiltinsAtomicsTest, Store_1)
844 {
845 ASSERT_NE(thread, nullptr);
846 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
847 [[maybe_unused]] JSHandle<TaggedArray> array(factory->NewTaggedArray(3));
848 array->Set(thread, 0, JSTaggedValue(5));
849 array->Set(thread, 1, JSTaggedValue(6));
850 array->Set(thread, 2, JSTaggedValue(7));
851
852 JSHandle<JSTaggedValue> obj = JSHandle<JSTaggedValue>(thread, CreateTypedArray(thread, array));
853 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 10);
854 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
855 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
856 ecmaRuntimeCallInfo->SetCallArg(0, obj.GetTaggedValue());
857 ecmaRuntimeCallInfo->SetCallArg(1, JSTaggedValue(static_cast<int32_t>(0)));
858 ecmaRuntimeCallInfo->SetCallArg(2, JSTaggedValue(static_cast<int32_t>(2)));
859
860 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo);
861 JSTaggedValue result = BuiltinsAtomics::Store(ecmaRuntimeCallInfo);
862 TestHelper::TearDownFrame(thread, prev);
863 ASSERT_EQ(result.GetDouble(), 2);
864 }
865
HWTEST_F_L0(BuiltinsAtomicsTest,Store_2)866 HWTEST_F_L0(BuiltinsAtomicsTest, Store_2)
867 {
868 ASSERT_NE(thread, nullptr);
869 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
870 [[maybe_unused]] JSHandle<TaggedArray> array(factory->NewTaggedArray(3));
871 array->Set(thread, 0, JSTaggedValue(5));
872 array->Set(thread, 1, JSTaggedValue(6));
873 array->Set(thread, 2, JSTaggedValue(7));
874
875 JSHandle<JSTaggedValue> obj = JSHandle<JSTaggedValue>(thread, CreateTypedArray(thread, array));
876 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 10);
877 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
878 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
879 ecmaRuntimeCallInfo->SetCallArg(0, obj.GetTaggedValue());
880 ecmaRuntimeCallInfo->SetCallArg(1, JSTaggedValue(static_cast<int32_t>(0)));
881 ecmaRuntimeCallInfo->SetCallArg(2, JSTaggedValue(static_cast<int32_t>(2)));
882
883 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo);
884 JSTaggedValue result = BuiltinsAtomics::Store(ecmaRuntimeCallInfo);
885 TestHelper::TearDownFrame(thread, prev);
886 ASSERT_EQ(result.GetDouble(), 2);
887
888 auto ecmaRuntimeCallInfos = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 8);
889 ecmaRuntimeCallInfos->SetFunction(JSTaggedValue::Undefined());
890 ecmaRuntimeCallInfos->SetThis(JSTaggedValue::Undefined());
891 ecmaRuntimeCallInfos->SetCallArg(0, obj.GetTaggedValue());
892 ecmaRuntimeCallInfos->SetCallArg(1, JSTaggedValue(static_cast<int32_t>(0)));
893
894 prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfos);
895 result = BuiltinsAtomics::Load(ecmaRuntimeCallInfos);
896 TestHelper::TearDownFrame(thread, prev);
897 ASSERT_EQ(result.GetInt(), 2);
898 }
899
HWTEST_F_L0(BuiltinsAtomicsTest,Wait)900 HWTEST_F_L0(BuiltinsAtomicsTest, Wait)
901 {
902 ASSERT_NE(thread, nullptr);
903 JSTaggedValue tagged = CreateSharedArrayBuffer(thread, 4);
904 JSHandle<JSArrayBuffer> arrBuf(thread, JSArrayBuffer::Cast(reinterpret_cast<TaggedObject *>(tagged.GetRawData())));
905 JSHandle<JSTaggedValue> obj = JSHandle<JSTaggedValue>(thread, CreateInt32TypedArray(thread, arrBuf));
906
907 // Not Equal
908 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 12);
909 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
910 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
911 ecmaRuntimeCallInfo->SetCallArg(0, obj.GetTaggedValue());
912 ecmaRuntimeCallInfo->SetCallArg(1, JSTaggedValue(static_cast<int32_t>(0)));
913 ecmaRuntimeCallInfo->SetCallArg(2, JSTaggedValue(static_cast<int32_t>(2)));
914 ecmaRuntimeCallInfo->SetCallArg(3, JSTaggedValue(static_cast<int32_t>(2)));
915
916 auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo);
917 JSTaggedValue result = BuiltinsAtomics::Wait(ecmaRuntimeCallInfo);
918 TestHelper::TearDownFrame(thread, prev);
919 ASSERT_EQ(result, thread->GlobalConstants()->GetNotEqualString());
920
921 // timeout
922 ecmaRuntimeCallInfo->SetCallArg(2, JSTaggedValue(static_cast<int32_t>(0)));
923 ecmaRuntimeCallInfo->SetCallArg(3, JSTaggedValue(static_cast<int32_t>(100)));
924
925 prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo);
926 result = BuiltinsAtomics::Wait(ecmaRuntimeCallInfo);
927 TestHelper::TearDownFrame(thread, prev);
928 ASSERT_EQ(result, thread->GlobalConstants()->GetTimeoutString());
929 }
930
HWTEST_F_L0(BuiltinsAtomicsTest,Notify)931 HWTEST_F_L0(BuiltinsAtomicsTest, Notify)
932 {
933 ASSERT_NE(thread, nullptr);
934 JSTaggedValue tagged = CreateSharedArrayBuffer(thread, 4);
935 JSHandle<JSArrayBuffer> arrBuf(thread, JSArrayBuffer::Cast(reinterpret_cast<TaggedObject *>(tagged.GetRawData())));
936 JSHandle<JSTaggedValue> obj = JSHandle<JSTaggedValue>(thread, CreateInt32TypedArray(thread, arrBuf));
937
938 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 10);
939 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
940 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
941 ecmaRuntimeCallInfo->SetCallArg(0, obj.GetTaggedValue());
942 ecmaRuntimeCallInfo->SetCallArg(1, JSTaggedValue(static_cast<int32_t>(0)));
943 ecmaRuntimeCallInfo->SetCallArg(2, JSTaggedValue(static_cast<int32_t>(2)));
944
945 auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo);
946 [[maybe_unused]]JSTaggedValue result = BuiltinsAtomics::Notify(ecmaRuntimeCallInfo);
947 TestHelper::TearDownFrame(thread, prev);
948 ASSERT_EQ(result, JSTaggedValue(0));
949 }
950 }