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 auto ecmaRuntimeCallInfos = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 8);
388 ecmaRuntimeCallInfos->SetFunction(JSTaggedValue::Undefined());
389 ecmaRuntimeCallInfos->SetThis(JSTaggedValue::Undefined());
390 ecmaRuntimeCallInfos->SetCallArg(0, obj.GetTaggedValue());
391 ecmaRuntimeCallInfos->SetCallArg(1, JSTaggedValue(static_cast<int32_t>(0)));
392
393 prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfos);
394 result = BuiltinsAtomics::Load(ecmaRuntimeCallInfos);
395 TestHelper::TearDownFrame(thread, prev);
396 ASSERT_EQ(result.GetInt(), 2);
397 }
398
HWTEST_F_L0(BuiltinsAtomicsTest,CompareExchange_1)399 HWTEST_F_L0(BuiltinsAtomicsTest, CompareExchange_1)
400 {
401 ASSERT_NE(thread, nullptr);
402 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
403 [[maybe_unused]] JSHandle<TaggedArray> array(factory->NewTaggedArray(3));
404 array->Set(thread, 0, JSTaggedValue(5));
405 array->Set(thread, 1, JSTaggedValue(0));
406 array->Set(thread, 2, JSTaggedValue(0));
407
408 JSHandle<JSTaggedValue> obj = JSHandle<JSTaggedValue>(thread, CreateTypedArray(thread, array, DataViewType::UINT8));
409 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 12);
410 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
411 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
412 ecmaRuntimeCallInfo->SetCallArg(0, obj.GetTaggedValue());
413 ecmaRuntimeCallInfo->SetCallArg(1, JSTaggedValue(static_cast<int32_t>(0)));
414 ecmaRuntimeCallInfo->SetCallArg(2, JSTaggedValue(static_cast<int32_t>(5)));
415 ecmaRuntimeCallInfo->SetCallArg(3, JSTaggedValue(static_cast<int32_t>(2)));
416
417 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo);
418 JSTaggedValue result = BuiltinsAtomics::CompareExchange(ecmaRuntimeCallInfo);
419 TestHelper::TearDownFrame(thread, prev);
420 ASSERT_EQ(result.GetInt(), 5);
421 }
422
HWTEST_F_L0(BuiltinsAtomicsTest,CompareExchange_2)423 HWTEST_F_L0(BuiltinsAtomicsTest, CompareExchange_2)
424 {
425 ASSERT_NE(thread, nullptr);
426 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
427 [[maybe_unused]] JSHandle<TaggedArray> array(factory->NewTaggedArray(3));
428 array->Set(thread, 0, JSTaggedValue(5));
429 array->Set(thread, 1, JSTaggedValue(0));
430 array->Set(thread, 2, JSTaggedValue(0));
431
432 JSHandle<JSTaggedValue> obj = JSHandle<JSTaggedValue>(thread, CreateTypedArray(thread, array, DataViewType::INT8));
433 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 12);
434 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
435 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
436 ecmaRuntimeCallInfo->SetCallArg(0, obj.GetTaggedValue());
437 ecmaRuntimeCallInfo->SetCallArg(1, JSTaggedValue(static_cast<int32_t>(0)));
438 ecmaRuntimeCallInfo->SetCallArg(2, JSTaggedValue(static_cast<int32_t>(5)));
439 ecmaRuntimeCallInfo->SetCallArg(3, JSTaggedValue(static_cast<int32_t>(2)));
440
441 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo);
442 JSTaggedValue result = BuiltinsAtomics::CompareExchange(ecmaRuntimeCallInfo);
443 TestHelper::TearDownFrame(thread, prev);
444 ASSERT_EQ(result.GetInt(), 5);
445
446 auto ecmaRuntimeCallInfos = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 8);
447 ecmaRuntimeCallInfos->SetFunction(JSTaggedValue::Undefined());
448 ecmaRuntimeCallInfos->SetThis(JSTaggedValue::Undefined());
449 ecmaRuntimeCallInfos->SetCallArg(0, obj.GetTaggedValue());
450 ecmaRuntimeCallInfos->SetCallArg(1, JSTaggedValue(static_cast<int32_t>(0)));
451
452 prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfos);
453 result = BuiltinsAtomics::Load(ecmaRuntimeCallInfos);
454 TestHelper::TearDownFrame(thread, prev);
455 ASSERT_EQ(result.GetInt(), 2);
456 }
457
HWTEST_F_L0(BuiltinsAtomicsTest,TypedArrayCover)458 HWTEST_F_L0(BuiltinsAtomicsTest, TypedArrayCover)
459 {
460 ASSERT_NE(thread, nullptr);
461 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
462 [[maybe_unused]] JSHandle<TaggedArray> array(factory->NewTaggedArray(3));
463 array->Set(thread, 0, JSTaggedValue(2));
464 array->Set(thread, 1, JSTaggedValue(0));
465 array->Set(thread, 2, JSTaggedValue(0));
466 // UINT16
467 JSHandle<JSTaggedValue> obj = JSHandle<JSTaggedValue>(thread, CreateTypedArray(thread, array,
468 DataViewType::UINT16));
469 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 12);
470 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
471 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
472 ecmaRuntimeCallInfo->SetCallArg(0, obj.GetTaggedValue());
473 ecmaRuntimeCallInfo->SetCallArg(1, JSTaggedValue(static_cast<int32_t>(0)));
474 ecmaRuntimeCallInfo->SetCallArg(2, JSTaggedValue(static_cast<int32_t>(2)));
475 ecmaRuntimeCallInfo->SetCallArg(3, JSTaggedValue(static_cast<int32_t>(2)));
476
477 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo);
478 JSTaggedValue result = BuiltinsAtomics::CompareExchange(ecmaRuntimeCallInfo);
479 TestHelper::TearDownFrame(thread, prev);
480 ASSERT_EQ(result.GetInt(), 2);
481 // INT16
482 obj = JSHandle<JSTaggedValue>(thread, CreateTypedArray(thread, array, DataViewType::INT16));
483 ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 12);
484 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
485 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
486 ecmaRuntimeCallInfo->SetCallArg(0, obj.GetTaggedValue());
487 ecmaRuntimeCallInfo->SetCallArg(1, JSTaggedValue(static_cast<int32_t>(0)));
488 ecmaRuntimeCallInfo->SetCallArg(2, JSTaggedValue(static_cast<int32_t>(2)));
489 ecmaRuntimeCallInfo->SetCallArg(3, JSTaggedValue(static_cast<int32_t>(2)));
490
491 prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo);
492 result = BuiltinsAtomics::CompareExchange(ecmaRuntimeCallInfo);
493 TestHelper::TearDownFrame(thread, prev);
494 ASSERT_EQ(result.GetInt(), 2);
495 // UINT32
496 obj = JSHandle<JSTaggedValue>(thread, CreateTypedArray(thread, array, DataViewType::UINT32));
497 ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 12);
498 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
499 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
500 ecmaRuntimeCallInfo->SetCallArg(0, obj.GetTaggedValue());
501 ecmaRuntimeCallInfo->SetCallArg(1, JSTaggedValue(static_cast<int32_t>(0)));
502 ecmaRuntimeCallInfo->SetCallArg(2, JSTaggedValue(static_cast<int32_t>(2)));
503 ecmaRuntimeCallInfo->SetCallArg(3, JSTaggedValue(static_cast<int32_t>(2)));
504
505 prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo);
506 result = BuiltinsAtomics::CompareExchange(ecmaRuntimeCallInfo);
507 TestHelper::TearDownFrame(thread, prev);
508 ASSERT_EQ(result.GetInt(), 2);
509 // INT32
510 obj = JSHandle<JSTaggedValue>(thread, CreateTypedArray(thread, array, DataViewType::INT32));
511 ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 12);
512 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
513 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
514 ecmaRuntimeCallInfo->SetCallArg(0, obj.GetTaggedValue());
515 ecmaRuntimeCallInfo->SetCallArg(1, JSTaggedValue(static_cast<int32_t>(0)));
516 ecmaRuntimeCallInfo->SetCallArg(2, JSTaggedValue(static_cast<int32_t>(2)));
517 ecmaRuntimeCallInfo->SetCallArg(3, JSTaggedValue(static_cast<int32_t>(2)));
518
519 prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo);
520 result = BuiltinsAtomics::CompareExchange(ecmaRuntimeCallInfo);
521 TestHelper::TearDownFrame(thread, prev);
522 ASSERT_EQ(result.GetInt(), 2);
523
524 // Detached Buffer
525 JSTaggedValue tagged = CreateSharedArrayBuffer(thread, 0);
526 JSHandle<JSArrayBuffer> arrBuf(thread, JSArrayBuffer::Cast(reinterpret_cast<TaggedObject *>(tagged.GetRawData())));
527 obj = JSHandle<JSTaggedValue>(thread, CreateInt32TypedArray(thread, arrBuf));
528 arrBuf->SetArrayBufferData(thread, JSTaggedValue::Null());
529 ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 12);
530 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
531 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
532 ecmaRuntimeCallInfo->SetCallArg(0, obj.GetTaggedValue());
533 ecmaRuntimeCallInfo->SetCallArg(1, JSTaggedValue(static_cast<int32_t>(0)));
534 ecmaRuntimeCallInfo->SetCallArg(2, JSTaggedValue(static_cast<int32_t>(2)));
535 ecmaRuntimeCallInfo->SetCallArg(3, JSTaggedValue(static_cast<int32_t>(2)));
536
537 prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo);
538 result = BuiltinsAtomics::CompareExchange(ecmaRuntimeCallInfo);
539 TestHelper::TearDownFrame(thread, prev);
540 EXPECT_TRUE(thread->HasPendingException());
541 EXPECT_EQ(result, JSTaggedValue::Exception());
542 thread->ClearException();
543 }
544
HWTEST_F_L0(BuiltinsAtomicsTest,Exchange_1)545 HWTEST_F_L0(BuiltinsAtomicsTest, Exchange_1)
546 {
547 ASSERT_NE(thread, nullptr);
548 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
549 [[maybe_unused]] JSHandle<TaggedArray> array(factory->NewTaggedArray(3));
550 array->Set(thread, 0, JSTaggedValue(3));
551 array->Set(thread, 1, JSTaggedValue(0));
552 array->Set(thread, 2, JSTaggedValue(0));
553
554 JSHandle<JSTaggedValue> obj = JSHandle<JSTaggedValue>(thread, CreateTypedArray(thread, array));
555 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 10);
556 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
557 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
558 ecmaRuntimeCallInfo->SetCallArg(0, obj.GetTaggedValue());
559 ecmaRuntimeCallInfo->SetCallArg(1, JSTaggedValue(static_cast<int32_t>(0)));
560 ecmaRuntimeCallInfo->SetCallArg(2, JSTaggedValue(static_cast<int32_t>(6)));
561
562 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo);
563 JSTaggedValue result = BuiltinsAtomics::Exchange(ecmaRuntimeCallInfo);
564 TestHelper::TearDownFrame(thread, prev);
565 ASSERT_EQ(result.GetInt(), 3);
566 }
567
HWTEST_F_L0(BuiltinsAtomicsTest,Exchange_2)568 HWTEST_F_L0(BuiltinsAtomicsTest, Exchange_2)
569 {
570 ASSERT_NE(thread, nullptr);
571 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
572 [[maybe_unused]] JSHandle<TaggedArray> array(factory->NewTaggedArray(3));
573 array->Set(thread, 0, JSTaggedValue(3));
574 array->Set(thread, 1, JSTaggedValue(0));
575 array->Set(thread, 2, JSTaggedValue(0));
576
577 JSHandle<JSTaggedValue> obj = JSHandle<JSTaggedValue>(thread, CreateTypedArray(thread, array));
578 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 10);
579 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
580 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
581 ecmaRuntimeCallInfo->SetCallArg(0, obj.GetTaggedValue());
582 ecmaRuntimeCallInfo->SetCallArg(1, JSTaggedValue(static_cast<int32_t>(0)));
583 ecmaRuntimeCallInfo->SetCallArg(2, JSTaggedValue(static_cast<int32_t>(6)));
584
585 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo);
586 JSTaggedValue result = BuiltinsAtomics::Exchange(ecmaRuntimeCallInfo);
587 TestHelper::TearDownFrame(thread, prev);
588 ASSERT_EQ(result.GetInt(), 3);
589
590 auto ecmaRuntimeCallInfos = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 8);
591 ecmaRuntimeCallInfos->SetFunction(JSTaggedValue::Undefined());
592 ecmaRuntimeCallInfos->SetThis(JSTaggedValue::Undefined());
593 ecmaRuntimeCallInfos->SetCallArg(0, obj.GetTaggedValue());
594 ecmaRuntimeCallInfos->SetCallArg(1, JSTaggedValue(static_cast<int32_t>(0)));
595
596 prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfos);
597 result = BuiltinsAtomics::Load(ecmaRuntimeCallInfos);
598 TestHelper::TearDownFrame(thread, prev);
599 ASSERT_EQ(result.GetInt(), 6);
600 }
601
HWTEST_F_L0(BuiltinsAtomicsTest,Or_1)602 HWTEST_F_L0(BuiltinsAtomicsTest, Or_1)
603 {
604 ASSERT_NE(thread, nullptr);
605 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
606 [[maybe_unused]] JSHandle<TaggedArray> array(factory->NewTaggedArray(3));
607 array->Set(thread, 0, JSTaggedValue(5));
608 array->Set(thread, 1, JSTaggedValue(0));
609 array->Set(thread, 2, JSTaggedValue(0));
610
611 JSHandle<JSTaggedValue> obj = JSHandle<JSTaggedValue>(thread, CreateTypedArray(thread, array));
612 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 10);
613 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
614 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
615 ecmaRuntimeCallInfo->SetCallArg(0, obj.GetTaggedValue());
616 ecmaRuntimeCallInfo->SetCallArg(1, JSTaggedValue(static_cast<int32_t>(0)));
617 ecmaRuntimeCallInfo->SetCallArg(2, JSTaggedValue(static_cast<int32_t>(2)));
618
619 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo);
620 JSTaggedValue result = BuiltinsAtomics::Or(ecmaRuntimeCallInfo);
621 TestHelper::TearDownFrame(thread, prev);
622 ASSERT_EQ(result.GetInt(), 5);
623 }
624
HWTEST_F_L0(BuiltinsAtomicsTest,Or_2)625 HWTEST_F_L0(BuiltinsAtomicsTest, Or_2)
626 {
627 ASSERT_NE(thread, nullptr);
628 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
629 [[maybe_unused]] JSHandle<TaggedArray> array(factory->NewTaggedArray(3));
630 array->Set(thread, 0, JSTaggedValue(5));
631 array->Set(thread, 1, JSTaggedValue(0));
632 array->Set(thread, 2, JSTaggedValue(0));
633
634 JSHandle<JSTaggedValue> obj = JSHandle<JSTaggedValue>(thread, CreateTypedArray(thread, array));
635 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 12);
636 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
637 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
638 ecmaRuntimeCallInfo->SetCallArg(0, obj.GetTaggedValue());
639 ecmaRuntimeCallInfo->SetCallArg(1, JSTaggedValue(static_cast<int32_t>(0)));
640 ecmaRuntimeCallInfo->SetCallArg(2, JSTaggedValue(static_cast<int32_t>(2)));
641
642 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo);
643 JSTaggedValue result = BuiltinsAtomics::Or(ecmaRuntimeCallInfo);
644 TestHelper::TearDownFrame(thread, prev);
645 ASSERT_EQ(result.GetInt(), 5);
646
647 auto ecmaRuntimeCallInfos = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 8);
648 ecmaRuntimeCallInfos->SetFunction(JSTaggedValue::Undefined());
649 ecmaRuntimeCallInfos->SetThis(JSTaggedValue::Undefined());
650 ecmaRuntimeCallInfos->SetCallArg(0, obj.GetTaggedValue());
651 ecmaRuntimeCallInfos->SetCallArg(1, JSTaggedValue(static_cast<int32_t>(0)));
652
653 prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfos);
654 result = BuiltinsAtomics::Load(ecmaRuntimeCallInfos);
655 TestHelper::TearDownFrame(thread, prev);
656 ASSERT_EQ(result.GetInt(), 7);
657 }
658
HWTEST_F_L0(BuiltinsAtomicsTest,Sub_1)659 HWTEST_F_L0(BuiltinsAtomicsTest, Sub_1)
660 {
661 ASSERT_NE(thread, nullptr);
662 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
663 [[maybe_unused]] JSHandle<TaggedArray> array(factory->NewTaggedArray(3));
664 array->Set(thread, 0, JSTaggedValue(5));
665 array->Set(thread, 1, JSTaggedValue(0));
666 array->Set(thread, 2, JSTaggedValue(0));
667
668 JSHandle<JSTaggedValue> obj = JSHandle<JSTaggedValue>(thread, CreateTypedArray(thread, array));
669 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 10);
670 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
671 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
672 ecmaRuntimeCallInfo->SetCallArg(0, obj.GetTaggedValue());
673 ecmaRuntimeCallInfo->SetCallArg(1, JSTaggedValue(static_cast<int32_t>(0)));
674 ecmaRuntimeCallInfo->SetCallArg(2, JSTaggedValue(static_cast<int32_t>(2)));
675
676 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo);
677 JSTaggedValue result = BuiltinsAtomics::Sub(ecmaRuntimeCallInfo);
678 TestHelper::TearDownFrame(thread, prev);
679 ASSERT_EQ(result.GetInt(), 5);
680 }
681
HWTEST_F_L0(BuiltinsAtomicsTest,Sub_2)682 HWTEST_F_L0(BuiltinsAtomicsTest, Sub_2)
683 {
684 ASSERT_NE(thread, nullptr);
685 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
686 [[maybe_unused]] JSHandle<TaggedArray> array(factory->NewTaggedArray(3));
687 array->Set(thread, 0, JSTaggedValue(0));
688 array->Set(thread, 1, JSTaggedValue(5));
689 array->Set(thread, 2, JSTaggedValue(0));
690
691 JSHandle<JSTaggedValue> obj = JSHandle<JSTaggedValue>(thread, CreateTypedArray(thread, array));
692 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 10);
693 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
694 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
695 ecmaRuntimeCallInfo->SetCallArg(0, obj.GetTaggedValue());
696 ecmaRuntimeCallInfo->SetCallArg(1, JSTaggedValue(static_cast<int32_t>(1)));
697 ecmaRuntimeCallInfo->SetCallArg(2, JSTaggedValue(static_cast<int32_t>(2)));
698
699 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo);
700 JSTaggedValue result = BuiltinsAtomics::Sub(ecmaRuntimeCallInfo);
701 TestHelper::TearDownFrame(thread, prev);
702 ASSERT_EQ(result.GetInt(), 5);
703
704 auto ecmaRuntimeCallInfos = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 8);
705 ecmaRuntimeCallInfos->SetFunction(JSTaggedValue::Undefined());
706 ecmaRuntimeCallInfos->SetThis(JSTaggedValue::Undefined());
707 ecmaRuntimeCallInfos->SetCallArg(0, obj.GetTaggedValue());
708 ecmaRuntimeCallInfos->SetCallArg(1, JSTaggedValue(static_cast<int32_t>(1)));
709
710 prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfos);
711 result = BuiltinsAtomics::Load(ecmaRuntimeCallInfos);
712 TestHelper::TearDownFrame(thread, prev);
713 ASSERT_EQ(result.GetInt(), 3);
714 }
715
HWTEST_F_L0(BuiltinsAtomicsTest,Xor_1)716 HWTEST_F_L0(BuiltinsAtomicsTest, Xor_1)
717 {
718 ASSERT_NE(thread, nullptr);
719 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
720 [[maybe_unused]] JSHandle<TaggedArray> array(factory->NewTaggedArray(3));
721 array->Set(thread, 0, JSTaggedValue(5));
722 array->Set(thread, 1, JSTaggedValue(7));
723 array->Set(thread, 2, JSTaggedValue(0));
724
725 JSHandle<JSTaggedValue> obj = JSHandle<JSTaggedValue>(thread, CreateTypedArray(thread, array));
726 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 10);
727 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
728 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
729 ecmaRuntimeCallInfo->SetCallArg(0, obj.GetTaggedValue());
730 ecmaRuntimeCallInfo->SetCallArg(1, JSTaggedValue(static_cast<int32_t>(1)));
731 ecmaRuntimeCallInfo->SetCallArg(2, JSTaggedValue(static_cast<int32_t>(2)));
732
733 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo);
734 JSTaggedValue result = BuiltinsAtomics::Xor(ecmaRuntimeCallInfo);
735 TestHelper::TearDownFrame(thread, prev);
736 ASSERT_EQ(result.GetInt(), 7);
737 }
738
HWTEST_F_L0(BuiltinsAtomicsTest,Xor_2)739 HWTEST_F_L0(BuiltinsAtomicsTest, Xor_2)
740 {
741 ASSERT_NE(thread, nullptr);
742 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
743 [[maybe_unused]] JSHandle<TaggedArray> array(factory->NewTaggedArray(3));
744 array->Set(thread, 0, JSTaggedValue(5));
745 array->Set(thread, 1, JSTaggedValue(7));
746 array->Set(thread, 2, JSTaggedValue(0));
747
748 JSHandle<JSTaggedValue> obj = JSHandle<JSTaggedValue>(thread, CreateTypedArray(thread, array));
749 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 10);
750 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
751 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
752 ecmaRuntimeCallInfo->SetCallArg(0, obj.GetTaggedValue());
753 ecmaRuntimeCallInfo->SetCallArg(1, JSTaggedValue(static_cast<int32_t>(1)));
754 ecmaRuntimeCallInfo->SetCallArg(2, JSTaggedValue(static_cast<int32_t>(2)));
755
756 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo);
757 JSTaggedValue result = BuiltinsAtomics::Xor(ecmaRuntimeCallInfo);
758 TestHelper::TearDownFrame(thread, prev);
759 ASSERT_EQ(result.GetInt(), 7);
760
761 auto ecmaRuntimeCallInfos = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 8);
762 ecmaRuntimeCallInfos->SetFunction(JSTaggedValue::Undefined());
763 ecmaRuntimeCallInfos->SetThis(JSTaggedValue::Undefined());
764 ecmaRuntimeCallInfos->SetCallArg(0, obj.GetTaggedValue());
765 ecmaRuntimeCallInfos->SetCallArg(1, JSTaggedValue(static_cast<int32_t>(1)));
766
767 prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfos);
768 result = BuiltinsAtomics::Load(ecmaRuntimeCallInfos);
769 TestHelper::TearDownFrame(thread, prev);
770 ASSERT_EQ(result.GetInt(), 5);
771 }
772
HWTEST_F_L0(BuiltinsAtomicsTest,IsLockFree_1)773 HWTEST_F_L0(BuiltinsAtomicsTest, IsLockFree_1)
774 {
775 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 6);
776 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
777 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
778 ecmaRuntimeCallInfo->SetCallArg(0, JSTaggedValue(static_cast<int32_t>(1)));
779
780 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo);
781 JSTaggedValue result = BuiltinsAtomics::IsLockFree(ecmaRuntimeCallInfo);
782 TestHelper::TearDownFrame(thread, prev);
783 ASSERT_TRUE(result.ToBoolean());
784 }
785
HWTEST_F_L0(BuiltinsAtomicsTest,IsLockFree_2)786 HWTEST_F_L0(BuiltinsAtomicsTest, IsLockFree_2)
787 {
788 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 6);
789 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
790 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
791 ecmaRuntimeCallInfo->SetCallArg(0, JSTaggedValue(static_cast<int32_t>(2)));
792
793 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo);
794 JSTaggedValue result = BuiltinsAtomics::IsLockFree(ecmaRuntimeCallInfo);
795 TestHelper::TearDownFrame(thread, prev);
796 ASSERT_TRUE(result.ToBoolean());
797 }
798
HWTEST_F_L0(BuiltinsAtomicsTest,IsLockFree_3)799 HWTEST_F_L0(BuiltinsAtomicsTest, IsLockFree_3)
800 {
801 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 6);
802 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
803 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
804 ecmaRuntimeCallInfo->SetCallArg(0, JSTaggedValue(static_cast<int32_t>(4)));
805
806 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo);
807 JSTaggedValue result = BuiltinsAtomics::IsLockFree(ecmaRuntimeCallInfo);
808 TestHelper::TearDownFrame(thread, prev);
809 ASSERT_TRUE(result.ToBoolean());
810 }
811
HWTEST_F_L0(BuiltinsAtomicsTest,IsLockFree_4)812 HWTEST_F_L0(BuiltinsAtomicsTest, IsLockFree_4)
813 {
814 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 6);
815 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
816 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
817 ecmaRuntimeCallInfo->SetCallArg(0, JSTaggedValue(static_cast<int32_t>(-3)));
818
819 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo);
820 JSTaggedValue result = BuiltinsAtomics::IsLockFree(ecmaRuntimeCallInfo);
821 TestHelper::TearDownFrame(thread, prev);
822 ASSERT_FALSE(result.ToBoolean());
823 }
824
HWTEST_F_L0(BuiltinsAtomicsTest,IsLockFree_5)825 HWTEST_F_L0(BuiltinsAtomicsTest, IsLockFree_5)
826 {
827 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 6);
828 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
829 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
830 ecmaRuntimeCallInfo->SetCallArg(0, JSTaggedValue(static_cast<int32_t>(8)));
831
832 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo);
833 JSTaggedValue result = BuiltinsAtomics::IsLockFree(ecmaRuntimeCallInfo);
834 TestHelper::TearDownFrame(thread, prev);
835 ASSERT_TRUE(result.ToBoolean());
836 }
837
838
HWTEST_F_L0(BuiltinsAtomicsTest,Store_1)839 HWTEST_F_L0(BuiltinsAtomicsTest, Store_1)
840 {
841 ASSERT_NE(thread, nullptr);
842 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
843 [[maybe_unused]] JSHandle<TaggedArray> array(factory->NewTaggedArray(3));
844 array->Set(thread, 0, JSTaggedValue(5));
845 array->Set(thread, 1, JSTaggedValue(6));
846 array->Set(thread, 2, JSTaggedValue(7));
847
848 JSHandle<JSTaggedValue> obj = JSHandle<JSTaggedValue>(thread, CreateTypedArray(thread, array));
849 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 10);
850 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
851 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
852 ecmaRuntimeCallInfo->SetCallArg(0, obj.GetTaggedValue());
853 ecmaRuntimeCallInfo->SetCallArg(1, JSTaggedValue(static_cast<int32_t>(0)));
854 ecmaRuntimeCallInfo->SetCallArg(2, JSTaggedValue(static_cast<int32_t>(2)));
855
856 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo);
857 JSTaggedValue result = BuiltinsAtomics::Store(ecmaRuntimeCallInfo);
858 TestHelper::TearDownFrame(thread, prev);
859 ASSERT_EQ(result.GetDouble(), 2);
860 }
861
HWTEST_F_L0(BuiltinsAtomicsTest,Store_2)862 HWTEST_F_L0(BuiltinsAtomicsTest, Store_2)
863 {
864 ASSERT_NE(thread, nullptr);
865 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
866 [[maybe_unused]] JSHandle<TaggedArray> array(factory->NewTaggedArray(3));
867 array->Set(thread, 0, JSTaggedValue(5));
868 array->Set(thread, 1, JSTaggedValue(6));
869 array->Set(thread, 2, JSTaggedValue(7));
870
871 JSHandle<JSTaggedValue> obj = JSHandle<JSTaggedValue>(thread, CreateTypedArray(thread, array));
872 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 10);
873 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
874 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
875 ecmaRuntimeCallInfo->SetCallArg(0, obj.GetTaggedValue());
876 ecmaRuntimeCallInfo->SetCallArg(1, JSTaggedValue(static_cast<int32_t>(0)));
877 ecmaRuntimeCallInfo->SetCallArg(2, JSTaggedValue(static_cast<int32_t>(2)));
878
879 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo);
880 JSTaggedValue result = BuiltinsAtomics::Store(ecmaRuntimeCallInfo);
881 TestHelper::TearDownFrame(thread, prev);
882 ASSERT_EQ(result.GetDouble(), 2);
883
884 auto ecmaRuntimeCallInfos = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 8);
885 ecmaRuntimeCallInfos->SetFunction(JSTaggedValue::Undefined());
886 ecmaRuntimeCallInfos->SetThis(JSTaggedValue::Undefined());
887 ecmaRuntimeCallInfos->SetCallArg(0, obj.GetTaggedValue());
888 ecmaRuntimeCallInfos->SetCallArg(1, JSTaggedValue(static_cast<int32_t>(0)));
889
890 prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfos);
891 result = BuiltinsAtomics::Load(ecmaRuntimeCallInfos);
892 TestHelper::TearDownFrame(thread, prev);
893 ASSERT_EQ(result.GetInt(), 2);
894 }
895
HWTEST_F_L0(BuiltinsAtomicsTest,Wait)896 HWTEST_F_L0(BuiltinsAtomicsTest, Wait)
897 {
898 ASSERT_NE(thread, nullptr);
899 JSTaggedValue tagged = CreateSharedArrayBuffer(thread, 4);
900 JSHandle<JSArrayBuffer> arrBuf(thread, JSArrayBuffer::Cast(reinterpret_cast<TaggedObject *>(tagged.GetRawData())));
901 JSHandle<JSTaggedValue> obj = JSHandle<JSTaggedValue>(thread, CreateInt32TypedArray(thread, arrBuf));
902
903 // Not Equal
904 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 12);
905 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
906 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
907 ecmaRuntimeCallInfo->SetCallArg(0, obj.GetTaggedValue());
908 ecmaRuntimeCallInfo->SetCallArg(1, JSTaggedValue(static_cast<int32_t>(0)));
909 ecmaRuntimeCallInfo->SetCallArg(2, JSTaggedValue(static_cast<int32_t>(2)));
910 ecmaRuntimeCallInfo->SetCallArg(3, JSTaggedValue(static_cast<int32_t>(2)));
911
912 auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo);
913 JSTaggedValue result = BuiltinsAtomics::Wait(ecmaRuntimeCallInfo);
914 TestHelper::TearDownFrame(thread, prev);
915 ASSERT_EQ(result, thread->GlobalConstants()->GetNotEqualString());
916
917 // timeout
918 ecmaRuntimeCallInfo->SetCallArg(2, JSTaggedValue(static_cast<int32_t>(0)));
919 ecmaRuntimeCallInfo->SetCallArg(3, JSTaggedValue(static_cast<int32_t>(100)));
920
921 prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo);
922 result = BuiltinsAtomics::Wait(ecmaRuntimeCallInfo);
923 TestHelper::TearDownFrame(thread, prev);
924 ASSERT_EQ(result, thread->GlobalConstants()->GetTimeoutString());
925 }
926
HWTEST_F_L0(BuiltinsAtomicsTest,Notify)927 HWTEST_F_L0(BuiltinsAtomicsTest, Notify)
928 {
929 ASSERT_NE(thread, nullptr);
930 JSTaggedValue tagged = CreateSharedArrayBuffer(thread, 4);
931 JSHandle<JSArrayBuffer> arrBuf(thread, JSArrayBuffer::Cast(reinterpret_cast<TaggedObject *>(tagged.GetRawData())));
932 JSHandle<JSTaggedValue> obj = JSHandle<JSTaggedValue>(thread, CreateInt32TypedArray(thread, arrBuf));
933
934 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 10);
935 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
936 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
937 ecmaRuntimeCallInfo->SetCallArg(0, obj.GetTaggedValue());
938 ecmaRuntimeCallInfo->SetCallArg(1, JSTaggedValue(static_cast<int32_t>(0)));
939 ecmaRuntimeCallInfo->SetCallArg(2, JSTaggedValue(static_cast<int32_t>(2)));
940
941 auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo);
942 [[maybe_unused]] JSTaggedValue result = BuiltinsAtomics::Notify(ecmaRuntimeCallInfo);
943 TestHelper::TearDownFrame(thread, prev);
944 ASSERT_EQ(result, JSTaggedValue(0));
945 }
946 }
947