1 /*
2 * Copyright (c) 2021-2024 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 #include "ecmascript/builtins/builtins_shared_typedarray.h"
16
17 #include "ecmascript/ecma_runtime_call_info.h"
18 #include "ecmascript/ecma_vm.h"
19 #include "ecmascript/global_env.h"
20 #include "ecmascript/js_arraybuffer.h"
21 #include "ecmascript/js_handle.h"
22 #include "ecmascript/js_tagged_value.h"
23 #include "ecmascript/ecma_string.h"
24 #include "ecmascript/ecma_vm.h"
25 #include "ecmascript/global_env.h"
26 #include "ecmascript/js_array.h"
27 #include "ecmascript/js_array_iterator.h"
28
29 #include "ecmascript/js_handle.h"
30 #include "ecmascript/js_hclass.h"
31 #include "ecmascript/js_object-inl.h"
32 #include "ecmascript/js_tagged_value-inl.h"
33 #include "ecmascript/js_tagged_value.h"
34 #include "ecmascript/js_thread.h"
35
36 #include "ecmascript/object_factory.h"
37 #include "ecmascript/object_operator.h"
38 #include "ecmascript/tests/test_helper.h"
39 #include "builtin_test_util.h"
40
41 using namespace panda::ecmascript;
42 using namespace panda::ecmascript::builtins;
43
44 namespace panda::test {
45
46 class BuiltinsSharedTypedArrayTest : public BaseTestWithScope<false> {
47 public:
48 class TestClass : public base::BuiltinsBase {
49 public:
50
TestReduceRightFunc(EcmaRuntimeCallInfo * argv)51 static JSTaggedValue TestReduceRightFunc(EcmaRuntimeCallInfo *argv)
52 {
53 int accumulator = GetCallArg(argv, 0)->GetInt();
54 accumulator = accumulator + GetCallArg(argv, 1)->GetInt();
55 return BuiltinsBase::GetTaggedInt(accumulator);
56 }
57 };
58 };
59
HWTEST_F_L0(BuiltinsSharedTypedArrayTest,TypedArrayBaseConstructor_Test1)60 HWTEST_F_L0(BuiltinsSharedTypedArrayTest, TypedArrayBaseConstructor_Test1)
61 {
62 JSHandle<GlobalEnv> env = thread->GetEcmaVM()->GetGlobalEnv();
63
64 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
65 JSHandle<TaggedArray> array(factory->NewTaggedArray(2));
66 JSHandle<JSTaggedValue> val0(thread, JSTaggedValue(1));
67 JSHandle<JSTaggedValue> val1(thread, JSTaggedValue(2));
68
69 array->Set(thread, 0, val0);
70 array->Set(thread, 1, val1);
71
72 JSHandle<JSTaggedValue> jsarray(JSArray::CreateArrayFromList(thread, array));
73 JSHandle<JSFunction> typed_array(env->GetTypedArrayFunction());
74 JSHandle<JSObject> globalObject(thread, env->GetGlobalObject());
75 auto ecmaRuntimeCallInfo1 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue(*typed_array), 6);
76 ecmaRuntimeCallInfo1->SetFunction(JSTaggedValue(*typed_array));
77 ecmaRuntimeCallInfo1->SetThis(JSTaggedValue(*globalObject));
78 ecmaRuntimeCallInfo1->SetCallArg(0, jsarray.GetTaggedValue());
79 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo1);
80 JSTaggedValue result = BuiltinsSharedTypedArray::TypedArrayBaseConstructor(ecmaRuntimeCallInfo1);
81 ASSERT_TRUE(!result.IsECMAObject());
82 }
83
HWTEST_F_L0(BuiltinsSharedTypedArrayTest,Int8ArrayConstructor1_Test1)84 HWTEST_F_L0(BuiltinsSharedTypedArrayTest, Int8ArrayConstructor1_Test1)
85 {
86 JSHandle<GlobalEnv> env = thread->GetEcmaVM()->GetGlobalEnv();
87
88 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
89 JSHandle<TaggedArray> array(factory->NewTaggedArray(2));
90 JSHandle<JSTaggedValue> val0(thread, JSTaggedValue(1));
91 JSHandle<JSTaggedValue> val1(thread, JSTaggedValue(2));
92 array->Set(thread, 0, val0);
93 array->Set(thread, 1, val1);
94
95 JSHandle<JSTaggedValue> jsarray(JSArray::CreateArrayFromList(thread, array));
96 JSHandle<JSFunction> int8_array(env->GetInt8ArrayFunction());
97 JSHandle<JSObject> globalObject(thread, env->GetGlobalObject());
98 auto ecmaRuntimeCallInfo1 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue(*int8_array), 6);
99 ecmaRuntimeCallInfo1->SetFunction(JSTaggedValue(*int8_array));
100 ecmaRuntimeCallInfo1->SetThis(JSTaggedValue(*globalObject));
101 ecmaRuntimeCallInfo1->SetCallArg(0, jsarray.GetTaggedValue());
102 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo1);
103 JSTaggedValue result = BuiltinsSharedTypedArray::Int8ArrayConstructor(ecmaRuntimeCallInfo1);
104 ASSERT_TRUE(!result.IsECMAObject());
105 }
106
107
108 // Scenario2: Test when argv is not nullptr then Uint8ArrayConstructor returns not nullptr.
HWTEST_F_L0(BuiltinsSharedTypedArrayTest,Uint8ArrayConstructor_Test1)109 HWTEST_F_L0(BuiltinsSharedTypedArrayTest, Uint8ArrayConstructor_Test1)
110 {
111 JSHandle<GlobalEnv> env = thread->GetEcmaVM()->GetGlobalEnv();
112
113 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
114 JSHandle<TaggedArray> array(factory->NewTaggedArray(2));
115 JSHandle<JSTaggedValue> val0(thread, JSTaggedValue(1));
116 JSHandle<JSTaggedValue> val1(thread, JSTaggedValue(2));
117 array->Set(thread, 0, val0);
118 array->Set(thread, 1, val1);
119
120 JSHandle<JSTaggedValue> jsarray(JSArray::CreateArrayFromList(thread, array));
121 JSHandle<JSFunction> uint8_array(env->GetUint8ArrayFunction());
122 JSHandle<JSObject> globalObject(thread, env->GetGlobalObject());
123 auto ecmaRuntimeCallInfo1 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue(*uint8_array), 6);
124 ecmaRuntimeCallInfo1->SetFunction(JSTaggedValue(*uint8_array));
125 ecmaRuntimeCallInfo1->SetThis(JSTaggedValue(*globalObject));
126 ecmaRuntimeCallInfo1->SetCallArg(0, jsarray.GetTaggedValue());
127 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo1);
128 JSTaggedValue result = BuiltinsSharedTypedArray::Uint8ArrayConstructor(ecmaRuntimeCallInfo1);
129 ASSERT_TRUE(!result.IsECMAObject());
130 }
131
HWTEST_F_L0(BuiltinsSharedTypedArrayTest,Uint8ClampedArrayConstructor_Test1)132 HWTEST_F_L0(BuiltinsSharedTypedArrayTest, Uint8ClampedArrayConstructor_Test1)
133 {
134 JSHandle<GlobalEnv> env = thread->GetEcmaVM()->GetGlobalEnv();
135
136 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
137 JSHandle<TaggedArray> array(factory->NewTaggedArray(2));
138 JSHandle<JSTaggedValue> val0(thread, JSTaggedValue(1));
139 JSHandle<JSTaggedValue> val1(thread, JSTaggedValue(2));
140 array->Set(thread, 0, val0);
141 array->Set(thread, 1, val1);
142
143 JSHandle<JSTaggedValue> jsarray(JSArray::CreateArrayFromList(thread, array));
144 JSHandle<JSFunction> int8c_array(env->GetUint8ClampedArrayFunction());
145 JSHandle<JSObject> globalObject(thread, env->GetGlobalObject());
146 auto ecmaRuntimeCallInfo1 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue(*int8c_array), 6);
147 ecmaRuntimeCallInfo1->SetFunction(JSTaggedValue(*int8c_array));
148 ecmaRuntimeCallInfo1->SetThis(JSTaggedValue(*globalObject));
149 ecmaRuntimeCallInfo1->SetCallArg(0, jsarray.GetTaggedValue());
150 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo1);
151 JSTaggedValue result = BuiltinsSharedTypedArray::Uint8ClampedArrayConstructor(ecmaRuntimeCallInfo1);
152 ASSERT_TRUE(!result.IsECMAObject());
153 }
154
HWTEST_F_L0(BuiltinsSharedTypedArrayTest,Int16ArrayConstructor_Test1)155 HWTEST_F_L0(BuiltinsSharedTypedArrayTest, Int16ArrayConstructor_Test1)
156 {
157 JSHandle<GlobalEnv> env = thread->GetEcmaVM()->GetGlobalEnv();
158
159 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
160 JSHandle<TaggedArray> array(factory->NewTaggedArray(2));
161 JSHandle<JSTaggedValue> val0(thread, JSTaggedValue(1));
162 JSHandle<JSTaggedValue> val1(thread, JSTaggedValue(2));
163 array->Set(thread, 0, val0);
164 array->Set(thread, 1, val1);
165
166 JSHandle<JSTaggedValue> jsarray(JSArray::CreateArrayFromList(thread, array));
167 JSHandle<JSFunction> int16_array(env->GetInt16ArrayFunction());
168 JSHandle<JSObject> globalObject(thread, env->GetGlobalObject());
169 auto ecmaRuntimeCallInfo1 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue(*int16_array), 6);
170 ecmaRuntimeCallInfo1->SetFunction(JSTaggedValue(*int16_array));
171 ecmaRuntimeCallInfo1->SetThis(JSTaggedValue(*globalObject));
172 ecmaRuntimeCallInfo1->SetCallArg(0, jsarray.GetTaggedValue());
173 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo1);
174 JSTaggedValue result = BuiltinsSharedTypedArray::Int16ArrayConstructor(ecmaRuntimeCallInfo1);
175 ASSERT_TRUE(!result.IsECMAObject());
176 }
177
HWTEST_F_L0(BuiltinsSharedTypedArrayTest,Uint16ArrayConstructor_Test1)178 HWTEST_F_L0(BuiltinsSharedTypedArrayTest, Uint16ArrayConstructor_Test1)
179 {
180 JSHandle<GlobalEnv> env = thread->GetEcmaVM()->GetGlobalEnv();
181
182 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
183 JSHandle<TaggedArray> array(factory->NewTaggedArray(2));
184 JSHandle<JSTaggedValue> val0(thread, JSTaggedValue(1));
185 JSHandle<JSTaggedValue> val1(thread, JSTaggedValue(2));
186 array->Set(thread, 0, val0);
187 array->Set(thread, 1, val1);
188
189 JSHandle<JSTaggedValue> jsarray(JSArray::CreateArrayFromList(thread, array));
190 JSHandle<JSFunction> uint16_array(env->GetUint16ArrayFunction());
191 JSHandle<JSObject> globalObject(thread, env->GetGlobalObject());
192 auto ecmaRuntimeCallInfo1 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue(*uint16_array), 6);
193 ecmaRuntimeCallInfo1->SetFunction(JSTaggedValue(*uint16_array));
194 ecmaRuntimeCallInfo1->SetThis(JSTaggedValue(*globalObject));
195 ecmaRuntimeCallInfo1->SetCallArg(0, jsarray.GetTaggedValue());
196 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo1);
197 JSTaggedValue result = BuiltinsSharedTypedArray::Uint16ArrayConstructor(ecmaRuntimeCallInfo1);
198 ASSERT_TRUE(!result.IsECMAObject());
199 }
200
HWTEST_F_L0(BuiltinsSharedTypedArrayTest,Int32ArrayConstructor_Test1)201 HWTEST_F_L0(BuiltinsSharedTypedArrayTest, Int32ArrayConstructor_Test1)
202 {
203 JSHandle<GlobalEnv> env = thread->GetEcmaVM()->GetGlobalEnv();
204
205 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
206 JSHandle<TaggedArray> array(factory->NewTaggedArray(2));
207 JSHandle<JSTaggedValue> val0(thread, JSTaggedValue(1));
208 JSHandle<JSTaggedValue> val1(thread, JSTaggedValue(2));
209 array->Set(thread, 0, val0);
210 array->Set(thread, 1, val1);
211
212 JSHandle<JSTaggedValue> jsarray(JSArray::CreateArrayFromList(thread, array));
213 JSHandle<JSFunction> int32_array(env->GetInt32ArrayFunction());
214 JSHandle<JSObject> globalObject(thread, env->GetGlobalObject());
215 auto ecmaRuntimeCallInfo1 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue(*int32_array), 6);
216 ecmaRuntimeCallInfo1->SetFunction(JSTaggedValue(*int32_array));
217 ecmaRuntimeCallInfo1->SetThis(JSTaggedValue(*globalObject));
218 ecmaRuntimeCallInfo1->SetCallArg(0, jsarray.GetTaggedValue());
219 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo1);
220 JSTaggedValue result = BuiltinsSharedTypedArray::Int32ArrayConstructor(ecmaRuntimeCallInfo1);
221 ASSERT_TRUE(!result.IsECMAObject());
222 }
223
HWTEST_F_L0(BuiltinsSharedTypedArrayTest,Uint32ArrayConstructor_Test1)224 HWTEST_F_L0(BuiltinsSharedTypedArrayTest, Uint32ArrayConstructor_Test1)
225 {
226 JSHandle<GlobalEnv> env = thread->GetEcmaVM()->GetGlobalEnv();
227
228 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
229 JSHandle<TaggedArray> array(factory->NewTaggedArray(2));
230 JSHandle<JSTaggedValue> val0(thread, JSTaggedValue(1));
231 JSHandle<JSTaggedValue> val1(thread, JSTaggedValue(2));
232 array->Set(thread, 0, val0);
233 array->Set(thread, 1, val1);
234
235 JSHandle<JSTaggedValue> jsarray(JSArray::CreateArrayFromList(thread, array));
236 JSHandle<JSFunction> uint32_array(env->GetUint32ArrayFunction());
237 JSHandle<JSObject> globalObject(thread, env->GetGlobalObject());
238 auto ecmaRuntimeCallInfo1 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue(*uint32_array), 6);
239 ecmaRuntimeCallInfo1->SetFunction(JSTaggedValue(*uint32_array));
240 ecmaRuntimeCallInfo1->SetThis(JSTaggedValue(*globalObject));
241 ecmaRuntimeCallInfo1->SetCallArg(0, jsarray.GetTaggedValue());
242 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo1);
243 JSTaggedValue result = BuiltinsSharedTypedArray::Uint32ArrayConstructor(ecmaRuntimeCallInfo1);
244 ASSERT_TRUE(!result.IsECMAObject());
245 }
246
HWTEST_F_L0(BuiltinsSharedTypedArrayTest,Float32ArrayConstructor_Test1)247 HWTEST_F_L0(BuiltinsSharedTypedArrayTest, Float32ArrayConstructor_Test1)
248 {
249 JSHandle<GlobalEnv> env = thread->GetEcmaVM()->GetGlobalEnv();
250
251 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
252 JSHandle<TaggedArray> array(factory->NewTaggedArray(2));
253 JSHandle<JSTaggedValue> val0(thread, JSTaggedValue(1));
254 JSHandle<JSTaggedValue> val1(thread, JSTaggedValue(2));
255 array->Set(thread, 0, val0);
256 array->Set(thread, 1, val1);
257
258 JSHandle<JSTaggedValue> jsarray(JSArray::CreateArrayFromList(thread, array));
259 JSHandle<JSFunction> float32_array(env->GetFloat32ArrayFunction());
260 JSHandle<JSObject> globalObject(thread, env->GetGlobalObject());
261 auto ecmaRuntimeCallInfo1 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue(*float32_array), 6);
262 ecmaRuntimeCallInfo1->SetFunction(JSTaggedValue(*float32_array));
263 ecmaRuntimeCallInfo1->SetThis(JSTaggedValue(*globalObject));
264 ecmaRuntimeCallInfo1->SetCallArg(0, jsarray.GetTaggedValue());
265 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo1);
266 JSTaggedValue result = BuiltinsSharedTypedArray::Float32ArrayConstructor(ecmaRuntimeCallInfo1);
267 ASSERT_TRUE(!result.IsECMAObject());
268 }
269
HWTEST_F_L0(BuiltinsSharedTypedArrayTest,Float64ArrayConstructor_Test1)270 HWTEST_F_L0(BuiltinsSharedTypedArrayTest, Float64ArrayConstructor_Test1)
271 {
272 JSHandle<GlobalEnv> env = thread->GetEcmaVM()->GetGlobalEnv();
273
274 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
275 JSHandle<TaggedArray> array(factory->NewTaggedArray(2));
276 JSHandle<JSTaggedValue> val0(thread, JSTaggedValue(1));
277 JSHandle<JSTaggedValue> val1(thread, JSTaggedValue(2));
278 array->Set(thread, 0, val0);
279 array->Set(thread, 1, val1);
280
281 JSHandle<JSTaggedValue> jsarray(JSArray::CreateArrayFromList(thread, array));
282 JSHandle<JSFunction> float64_array(env->GetFloat64ArrayFunction());
283 JSHandle<JSObject> globalObject(thread, env->GetGlobalObject());
284 auto ecmaRuntimeCallInfo1 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue(*float64_array), 6);
285 ecmaRuntimeCallInfo1->SetFunction(JSTaggedValue(*float64_array));
286 ecmaRuntimeCallInfo1->SetThis(JSTaggedValue(*globalObject));
287 ecmaRuntimeCallInfo1->SetCallArg(0, jsarray.GetTaggedValue());
288 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo1);
289 JSTaggedValue result = BuiltinsSharedTypedArray::Float64ArrayConstructor(ecmaRuntimeCallInfo1);
290 ASSERT_TRUE(!result.IsECMAObject());
291 }
292
HWTEST_F_L0(BuiltinsSharedTypedArrayTest,BigInt64ArrayConstructor_Test1)293 HWTEST_F_L0(BuiltinsSharedTypedArrayTest, BigInt64ArrayConstructor_Test1)
294 {
295 JSHandle<GlobalEnv> env = thread->GetEcmaVM()->GetGlobalEnv();
296
297 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
298 JSHandle<TaggedArray> array(factory->NewTaggedArray(2));
299 JSHandle<JSTaggedValue> val0(thread, JSTaggedValue(1));
300 JSHandle<JSTaggedValue> val1(thread, JSTaggedValue(2));
301 array->Set(thread, 0, val0);
302 array->Set(thread, 1, val1);
303
304 JSHandle<JSTaggedValue> jsarray(JSArray::CreateArrayFromList(thread, array));
305 JSHandle<JSFunction> bigint64_array(env->GetBigInt64ArrayFunction());
306 JSHandle<JSObject> globalObject(thread, env->GetGlobalObject());
307 auto ecmaRuntimeCallInfo1 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue(*bigint64_array), 6);
308 ecmaRuntimeCallInfo1->SetFunction(JSTaggedValue(*bigint64_array));
309 ecmaRuntimeCallInfo1->SetThis(JSTaggedValue(*globalObject));
310 ecmaRuntimeCallInfo1->SetCallArg(0, jsarray.GetTaggedValue());
311 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo1);
312 JSTaggedValue result = BuiltinsSharedTypedArray::BigInt64ArrayConstructor(ecmaRuntimeCallInfo1);
313 ASSERT_TRUE(!result.IsECMAObject());
314 }
315
HWTEST_F_L0(BuiltinsSharedTypedArrayTest,BigUint64ArrayConstructor_Test1)316 HWTEST_F_L0(BuiltinsSharedTypedArrayTest, BigUint64ArrayConstructor_Test1)
317 {
318 JSHandle<GlobalEnv> env = thread->GetEcmaVM()->GetGlobalEnv();
319
320 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
321 JSHandle<TaggedArray> array(factory->NewTaggedArray(2));
322 JSHandle<JSTaggedValue> val0(thread, JSTaggedValue(1));
323 JSHandle<JSTaggedValue> val1(thread, JSTaggedValue(2));
324 array->Set(thread, 0, val0);
325 array->Set(thread, 1, val1);
326
327 JSHandle<JSTaggedValue> jsarray(JSArray::CreateArrayFromList(thread, array));
328 JSHandle<JSFunction> biguint64_array(env->GetBigUint64ArrayFunction());
329 JSHandle<JSObject> globalObject(thread, env->GetGlobalObject());
330 auto ecmaRuntimeCallInfo1 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue(*biguint64_array), 6);
331 ecmaRuntimeCallInfo1->SetFunction(JSTaggedValue(*biguint64_array));
332 ecmaRuntimeCallInfo1->SetThis(JSTaggedValue(*globalObject));
333 ecmaRuntimeCallInfo1->SetCallArg(0, jsarray.GetTaggedValue());
334 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo1);
335 JSTaggedValue result = BuiltinsSharedTypedArray::BigUint64ArrayConstructor(ecmaRuntimeCallInfo1);
336 ASSERT_TRUE(!result.IsECMAObject());
337 }
338
HWTEST_F_L0(BuiltinsSharedTypedArrayTest,Of_Test1)339 HWTEST_F_L0(BuiltinsSharedTypedArrayTest, Of_Test1)
340 {
341 JSHandle<GlobalEnv> env = thread->GetEcmaVM()->GetGlobalEnv();
342
343 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
344 JSHandle<TaggedArray> array(factory->NewTaggedArray(2));
345 JSHandle<JSTaggedValue> val0(thread, JSTaggedValue(1));
346 JSHandle<JSTaggedValue> val1(thread, JSTaggedValue(2));
347
348 array->Set(thread, 0, val0);
349 array->Set(thread, 1, val1);
350
351 JSHandle<JSTaggedValue> jsarray(JSArray::CreateArrayFromList(thread, array));
352 JSHandle<JSFunction> typed_array(env->GetTypedArrayFunction());
353 JSHandle<JSObject> globalObject(thread, env->GetGlobalObject());
354 auto argv = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue(*typed_array), 6);
355 argv->SetFunction(JSTaggedValue(*typed_array));
356 argv->SetThis(JSTaggedValue(*globalObject));
357 argv->SetCallArg(0, jsarray.GetTaggedValue());
358 JSTaggedValue result = BuiltinsSharedTypedArray::Of(argv);
359 ASSERT_TRUE(!result.IsECMAObject());
360 }
361
HWTEST_F_L0(BuiltinsSharedTypedArrayTest,Of_Test2)362 HWTEST_F_L0(BuiltinsSharedTypedArrayTest, Of_Test2)
363 {
364 auto ecmaVM = thread->GetEcmaVM();
365 JSHandle<GlobalEnv> env = ecmaVM->GetGlobalEnv();
366 JSHandle<JSFunction> array(env->GetSharedInt8ArrayFunction());
367 JSHandle<JSObject> globalObject(thread, env->GetGlobalObject());
368
369 auto ecmaRuntimeCallInfo1 = TestHelper::CreateEcmaRuntimeCallInfo(thread, array.GetTaggedValue(), 10);
370 ecmaRuntimeCallInfo1->SetFunction(JSTaggedValue::Undefined());
371 ecmaRuntimeCallInfo1->SetThis(array.GetTaggedValue());
372 ecmaRuntimeCallInfo1->SetCallArg(0, JSTaggedValue(static_cast<int32_t>(1)));
373 ecmaRuntimeCallInfo1->SetCallArg(1, JSTaggedValue(static_cast<int32_t>(2)));
374 ecmaRuntimeCallInfo1->SetCallArg(2, JSTaggedValue(static_cast<int32_t>(3)));
375
376 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo1);
377 JSTaggedValue result = BuiltinsSharedTypedArray::Of(ecmaRuntimeCallInfo1);
378 TestHelper::TearDownFrame(thread, prev);
379
380 EXPECT_TRUE(result.IsJSSharedInt8Array());
381 JSHandle<JSTaggedValue> resultArr = JSHandle<JSTaggedValue>(thread, result);
382 EXPECT_EQ(JSSharedTypedArray::GetProperty(thread, resultArr, 0).GetValue()->GetInt(), 1);
383 EXPECT_EQ(JSSharedTypedArray::GetProperty(thread, resultArr, 1).GetValue()->GetInt(), 2);
384 EXPECT_EQ(JSSharedTypedArray::GetProperty(thread, resultArr, 2).GetValue()->GetInt(), 3);
385 }
386
HWTEST_F_L0(BuiltinsSharedTypedArrayTest,Species_Test1)387 HWTEST_F_L0(BuiltinsSharedTypedArrayTest, Species_Test1)
388 {
389 JSHandle<GlobalEnv> env = thread->GetEcmaVM()->GetGlobalEnv();
390
391 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
392 JSHandle<TaggedArray> array(factory->NewTaggedArray(2));
393 JSHandle<JSTaggedValue> val0(thread, JSTaggedValue(1));
394 JSHandle<JSTaggedValue> val1(thread, JSTaggedValue(2));
395
396 array->Set(thread, 0, val0);
397 array->Set(thread, 1, val1);
398
399 JSHandle<JSTaggedValue> jsarray(JSArray::CreateArrayFromList(thread, array));
400 JSHandle<JSFunction> typed_array(env->GetTypedArrayFunction());
401 JSHandle<JSObject> globalObject(thread, env->GetGlobalObject());
402 auto argv = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue(*typed_array), 6);
403 argv->SetFunction(JSTaggedValue(*typed_array));
404 argv->SetThis(JSTaggedValue(*globalObject));
405 argv->SetCallArg(0, jsarray.GetTaggedValue());
406 JSTaggedValue result = BuiltinsSharedTypedArray::Species(argv);
407 ASSERT_TRUE(result.IsECMAObject());
408 }
409
HWTEST_F_L0(BuiltinsSharedTypedArrayTest,GetBuffer_Test1)410 HWTEST_F_L0(BuiltinsSharedTypedArrayTest, GetBuffer_Test1)
411 {
412 JSHandle<GlobalEnv> env = thread->GetEcmaVM()->GetGlobalEnv();
413
414 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
415 JSHandle<TaggedArray> array(factory->NewTaggedArray(2));
416 JSHandle<JSTaggedValue> val0(thread, JSTaggedValue(1));
417 JSHandle<JSTaggedValue> val1(thread, JSTaggedValue(2));
418
419 array->Set(thread, 0, val0);
420 array->Set(thread, 1, val1);
421
422 JSHandle<JSTaggedValue> jsarray(JSArray::CreateArrayFromList(thread, array));
423 JSHandle<JSFunction> typed_array(env->GetTypedArrayFunction());
424 JSHandle<JSObject> globalObject(thread, env->GetGlobalObject());
425 auto argv = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue(*typed_array), 6);
426 argv->SetFunction(JSTaggedValue(*typed_array));
427 argv->SetThis(JSTaggedValue(*globalObject));
428 argv->SetCallArg(0, jsarray.GetTaggedValue());
429 JSTaggedValue result = BuiltinsSharedTypedArray::GetBuffer(argv);
430 ASSERT_TRUE(!result.IsECMAObject());
431 }
432
HWTEST_F_L0(BuiltinsSharedTypedArrayTest,GetByteLength_Test1)433 HWTEST_F_L0(BuiltinsSharedTypedArrayTest, GetByteLength_Test1)
434 {
435 JSHandle<GlobalEnv> env = thread->GetEcmaVM()->GetGlobalEnv();
436
437 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
438 JSHandle<TaggedArray> array(factory->NewTaggedArray(2));
439 JSHandle<JSTaggedValue> val0(thread, JSTaggedValue(1));
440 JSHandle<JSTaggedValue> val1(thread, JSTaggedValue(2));
441
442 array->Set(thread, 0, val0);
443 array->Set(thread, 1, val1);
444
445 JSHandle<JSTaggedValue> jsarray(JSArray::CreateArrayFromList(thread, array));
446 JSHandle<JSFunction> typed_array(env->GetTypedArrayFunction());
447 JSHandle<JSObject> globalObject(thread, env->GetGlobalObject());
448 auto argv = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue(*typed_array), 6);
449 argv->SetFunction(JSTaggedValue(*typed_array));
450 argv->SetThis(JSTaggedValue(*globalObject));
451 argv->SetCallArg(0, jsarray.GetTaggedValue());
452 JSTaggedValue result = BuiltinsSharedTypedArray::GetByteLength(argv);
453 ASSERT_TRUE(!result.IsECMAObject());
454 }
455
HWTEST_F_L0(BuiltinsSharedTypedArrayTest,GetByteOffset_Test1)456 HWTEST_F_L0(BuiltinsSharedTypedArrayTest, GetByteOffset_Test1)
457 {
458 JSHandle<GlobalEnv> env = thread->GetEcmaVM()->GetGlobalEnv();
459
460 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
461 JSHandle<TaggedArray> array(factory->NewTaggedArray(2));
462 JSHandle<JSTaggedValue> val0(thread, JSTaggedValue(1));
463 JSHandle<JSTaggedValue> val1(thread, JSTaggedValue(2));
464
465 array->Set(thread, 0, val0);
466 array->Set(thread, 1, val1);
467
468 JSHandle<JSTaggedValue> jsarray(JSArray::CreateArrayFromList(thread, array));
469 JSHandle<JSFunction> typed_array(env->GetTypedArrayFunction());
470 JSHandle<JSObject> globalObject(thread, env->GetGlobalObject());
471 auto argv = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue(*typed_array), 6);
472 argv->SetFunction(JSTaggedValue(*typed_array));
473 argv->SetThis(JSTaggedValue(*globalObject));
474 argv->SetCallArg(0, jsarray.GetTaggedValue());
475 JSTaggedValue result = BuiltinsSharedTypedArray::GetByteOffset(argv);
476 ASSERT_TRUE(!result.IsECMAObject());
477 }
478
HWTEST_F_L0(BuiltinsSharedTypedArrayTest,CopyWithin_Test1)479 HWTEST_F_L0(BuiltinsSharedTypedArrayTest, CopyWithin_Test1)
480 {
481 JSHandle<GlobalEnv> env = thread->GetEcmaVM()->GetGlobalEnv();
482
483 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
484 JSHandle<TaggedArray> array(factory->NewTaggedArray(2));
485 JSHandle<JSTaggedValue> val0(thread, JSTaggedValue(1));
486 JSHandle<JSTaggedValue> val1(thread, JSTaggedValue(2));
487
488 array->Set(thread, 0, val0);
489 array->Set(thread, 1, val1);
490
491 JSHandle<JSTaggedValue> jsarray(JSArray::CreateArrayFromList(thread, array));
492 JSHandle<JSFunction> typed_array(env->GetTypedArrayFunction());
493 JSHandle<JSObject> globalObject(thread, env->GetGlobalObject());
494 auto argv = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue(*typed_array), 6);
495 argv->SetFunction(JSTaggedValue(*typed_array));
496 argv->SetThis(JSTaggedValue(*globalObject));
497 argv->SetCallArg(0, jsarray.GetTaggedValue());
498 JSTaggedValue result = BuiltinsSharedTypedArray::CopyWithin(argv);
499 ASSERT_TRUE(!result.IsECMAObject());
500 }
501
HWTEST_F_L0(BuiltinsSharedTypedArrayTest,Entries_Test1)502 HWTEST_F_L0(BuiltinsSharedTypedArrayTest, Entries_Test1)
503 {
504 JSHandle<GlobalEnv> env = thread->GetEcmaVM()->GetGlobalEnv();
505
506 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
507 JSHandle<TaggedArray> array(factory->NewTaggedArray(2));
508 JSHandle<JSTaggedValue> val0(thread, JSTaggedValue(1));
509 JSHandle<JSTaggedValue> val1(thread, JSTaggedValue(2));
510
511 array->Set(thread, 0, val0);
512 array->Set(thread, 1, val1);
513
514 JSHandle<JSTaggedValue> jsarray(JSArray::CreateArrayFromList(thread, array));
515 JSHandle<JSFunction> typed_array(env->GetTypedArrayFunction());
516 JSHandle<JSObject> globalObject(thread, env->GetGlobalObject());
517 auto argv = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue(*typed_array), 6);
518 argv->SetFunction(JSTaggedValue(*typed_array));
519 argv->SetThis(JSTaggedValue(*globalObject));
520 argv->SetCallArg(0, jsarray.GetTaggedValue());
521 JSTaggedValue result = BuiltinsSharedTypedArray::Entries(argv);
522 ASSERT_TRUE(!result.IsECMAObject());
523 }
524
HWTEST_F_L0(BuiltinsSharedTypedArrayTest,Every_Test1)525 HWTEST_F_L0(BuiltinsSharedTypedArrayTest, Every_Test1)
526 {
527 JSHandle<GlobalEnv> env = thread->GetEcmaVM()->GetGlobalEnv();
528
529 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
530 JSHandle<TaggedArray> array(factory->NewTaggedArray(2));
531 JSHandle<JSTaggedValue> val0(thread, JSTaggedValue(1));
532 JSHandle<JSTaggedValue> val1(thread, JSTaggedValue(2));
533
534 array->Set(thread, 0, val0);
535 array->Set(thread, 1, val1);
536
537 JSHandle<JSTaggedValue> jsarray(JSArray::CreateArrayFromList(thread, array));
538 JSHandle<JSFunction> typed_array(env->GetTypedArrayFunction());
539 JSHandle<JSObject> globalObject(thread, env->GetGlobalObject());
540 auto argv = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue(*typed_array), 6);
541 argv->SetFunction(JSTaggedValue(*typed_array));
542 argv->SetThis(JSTaggedValue(*globalObject));
543 argv->SetCallArg(0, jsarray.GetTaggedValue());
544 JSTaggedValue result = BuiltinsSharedTypedArray::Every(argv);
545 ASSERT_TRUE(!result.IsECMAObject());
546 }
547
HWTEST_F_L0(BuiltinsSharedTypedArrayTest,Fill_Test1)548 HWTEST_F_L0(BuiltinsSharedTypedArrayTest, Fill_Test1)
549 {
550 JSHandle<GlobalEnv> env = thread->GetEcmaVM()->GetGlobalEnv();
551
552 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
553 JSHandle<TaggedArray> array(factory->NewTaggedArray(2));
554 JSHandle<JSTaggedValue> val0(thread, JSTaggedValue(1));
555 JSHandle<JSTaggedValue> val1(thread, JSTaggedValue(2));
556
557 array->Set(thread, 0, val0);
558 array->Set(thread, 1, val1);
559
560 JSHandle<JSTaggedValue> jsarray(JSArray::CreateArrayFromList(thread, array));
561 JSHandle<JSFunction> typed_array(env->GetTypedArrayFunction());
562 JSHandle<JSObject> globalObject(thread, env->GetGlobalObject());
563 auto argv = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue(*typed_array), 6);
564 argv->SetFunction(JSTaggedValue(*typed_array));
565 argv->SetThis(JSTaggedValue(*globalObject));
566 argv->SetCallArg(0, jsarray.GetTaggedValue());
567 JSTaggedValue result = BuiltinsSharedTypedArray::Fill(argv);
568 ASSERT_TRUE(!result.IsECMAObject());
569 }
570
HWTEST_F_L0(BuiltinsSharedTypedArrayTest,Filter_Test1)571 HWTEST_F_L0(BuiltinsSharedTypedArrayTest, Filter_Test1)
572 {
573 JSHandle<GlobalEnv> env = thread->GetEcmaVM()->GetGlobalEnv();
574
575 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
576 JSHandle<TaggedArray> array(factory->NewTaggedArray(2));
577 JSHandle<JSTaggedValue> val0(thread, JSTaggedValue(1));
578 JSHandle<JSTaggedValue> val1(thread, JSTaggedValue(2));
579
580 array->Set(thread, 0, val0);
581 array->Set(thread, 1, val1);
582
583 JSHandle<JSTaggedValue> jsarray(JSArray::CreateArrayFromList(thread, array));
584 JSHandle<JSFunction> typed_array(env->GetTypedArrayFunction());
585 JSHandle<JSObject> globalObject(thread, env->GetGlobalObject());
586 auto argv = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue(*typed_array), 6);
587 argv->SetFunction(JSTaggedValue(*typed_array));
588 argv->SetThis(JSTaggedValue(*globalObject));
589 argv->SetCallArg(0, jsarray.GetTaggedValue());
590 JSTaggedValue result = BuiltinsSharedTypedArray::Filter(argv);
591 ASSERT_TRUE(!result.IsECMAObject());
592 }
593
HWTEST_F_L0(BuiltinsSharedTypedArrayTest,Find_Test1)594 HWTEST_F_L0(BuiltinsSharedTypedArrayTest, Find_Test1)
595 {
596 JSHandle<GlobalEnv> env = thread->GetEcmaVM()->GetGlobalEnv();
597
598 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
599 JSHandle<TaggedArray> array(factory->NewTaggedArray(2));
600 JSHandle<JSTaggedValue> val0(thread, JSTaggedValue(1));
601 JSHandle<JSTaggedValue> val1(thread, JSTaggedValue(2));
602
603 array->Set(thread, 0, val0);
604 array->Set(thread, 1, val1);
605
606 JSHandle<JSTaggedValue> jsarray(JSArray::CreateArrayFromList(thread, array));
607 JSHandle<JSFunction> typed_array(env->GetTypedArrayFunction());
608 JSHandle<JSObject> globalObject(thread, env->GetGlobalObject());
609 auto argv = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue(*typed_array), 6);
610 argv->SetFunction(JSTaggedValue(*typed_array));
611 argv->SetThis(JSTaggedValue(*globalObject));
612 argv->SetCallArg(0, jsarray.GetTaggedValue());
613 JSTaggedValue result = BuiltinsSharedTypedArray::Find(argv);
614 ASSERT_TRUE(!result.IsECMAObject());
615 }
616
HWTEST_F_L0(BuiltinsSharedTypedArrayTest,FindIndex_Test1)617 HWTEST_F_L0(BuiltinsSharedTypedArrayTest, FindIndex_Test1)
618 {
619 JSHandle<GlobalEnv> env = thread->GetEcmaVM()->GetGlobalEnv();
620
621 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
622 JSHandle<TaggedArray> array(factory->NewTaggedArray(2));
623 JSHandle<JSTaggedValue> val0(thread, JSTaggedValue(1));
624 JSHandle<JSTaggedValue> val1(thread, JSTaggedValue(2));
625
626 array->Set(thread, 0, val0);
627 array->Set(thread, 1, val1);
628
629 JSHandle<JSTaggedValue> jsarray(JSArray::CreateArrayFromList(thread, array));
630 JSHandle<JSFunction> typed_array(env->GetTypedArrayFunction());
631 JSHandle<JSObject> globalObject(thread, env->GetGlobalObject());
632 auto argv = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue(*typed_array), 6);
633 argv->SetFunction(JSTaggedValue(*typed_array));
634 argv->SetThis(JSTaggedValue(*globalObject));
635 argv->SetCallArg(0, jsarray.GetTaggedValue());
636 JSTaggedValue result = BuiltinsSharedTypedArray::FindIndex(argv);
637 ASSERT_TRUE(!result.IsECMAObject());
638 }
639
HWTEST_F_L0(BuiltinsSharedTypedArrayTest,ForEach_Test1)640 HWTEST_F_L0(BuiltinsSharedTypedArrayTest, ForEach_Test1)
641 {
642 JSHandle<GlobalEnv> env = thread->GetEcmaVM()->GetGlobalEnv();
643
644 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
645 JSHandle<TaggedArray> array(factory->NewTaggedArray(2));
646 JSHandle<JSTaggedValue> val0(thread, JSTaggedValue(1));
647 JSHandle<JSTaggedValue> val1(thread, JSTaggedValue(2));
648
649 array->Set(thread, 0, val0);
650 array->Set(thread, 1, val1);
651
652 JSHandle<JSTaggedValue> jsarray(JSArray::CreateArrayFromList(thread, array));
653 JSHandle<JSFunction> typed_array(env->GetTypedArrayFunction());
654 JSHandle<JSObject> globalObject(thread, env->GetGlobalObject());
655 auto argv = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue(*typed_array), 6);
656 argv->SetFunction(JSTaggedValue(*typed_array));
657 argv->SetThis(JSTaggedValue(*globalObject));
658 argv->SetCallArg(0, jsarray.GetTaggedValue());
659 JSTaggedValue result = BuiltinsSharedTypedArray::ForEach(argv);
660 ASSERT_TRUE(!result.IsECMAObject());
661 }
662
HWTEST_F_L0(BuiltinsSharedTypedArrayTest,IndexOf_Test1)663 HWTEST_F_L0(BuiltinsSharedTypedArrayTest, IndexOf_Test1)
664 {
665 JSHandle<GlobalEnv> env = thread->GetEcmaVM()->GetGlobalEnv();
666
667 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
668 JSHandle<TaggedArray> array(factory->NewTaggedArray(2));
669 JSHandle<JSTaggedValue> val0(thread, JSTaggedValue(1));
670 JSHandle<JSTaggedValue> val1(thread, JSTaggedValue(2));
671
672 array->Set(thread, 0, val0);
673 array->Set(thread, 1, val1);
674
675 JSHandle<JSTaggedValue> jsarray(JSArray::CreateArrayFromList(thread, array));
676 JSHandle<JSFunction> typed_array(env->GetTypedArrayFunction());
677 JSHandle<JSObject> globalObject(thread, env->GetGlobalObject());
678 auto argv = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue(*typed_array), 6);
679 argv->SetFunction(JSTaggedValue(*typed_array));
680 argv->SetThis(JSTaggedValue(*globalObject));
681 argv->SetCallArg(0, jsarray.GetTaggedValue());
682 JSTaggedValue result = BuiltinsSharedTypedArray::IndexOf(argv);
683 ASSERT_TRUE(!result.IsECMAObject());
684 }
685
HWTEST_F_L0(BuiltinsSharedTypedArrayTest,LastIndexOf_One)686 HWTEST_F_L0(BuiltinsSharedTypedArrayTest, LastIndexOf_One)
687 {
688 JSHandle<GlobalEnv> env = thread->GetEcmaVM()->GetGlobalEnv();
689
690 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
691 JSHandle<TaggedArray> array(factory->NewTaggedArray(2));
692 JSHandle<JSTaggedValue> val0(thread, JSTaggedValue(1));
693 JSHandle<JSTaggedValue> val1(thread, JSTaggedValue(2));
694
695 array->Set(thread, 0, val0);
696 array->Set(thread, 1, val1);
697
698 JSHandle<JSTaggedValue> jsarray(JSArray::CreateArrayFromList(thread, array));
699 JSHandle<JSFunction> typed_array(env->GetTypedArrayFunction());
700 JSHandle<JSObject> globalObject(thread, env->GetGlobalObject());
701 auto argv = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue(*typed_array), 6);
702 argv->SetFunction(JSTaggedValue(*typed_array));
703 argv->SetThis(JSTaggedValue(*globalObject));
704 argv->SetCallArg(0, jsarray.GetTaggedValue());
705 JSTaggedValue result = BuiltinsSharedTypedArray::LastIndexOf(argv);
706 ASSERT_TRUE(!result.IsECMAObject());
707 }
708
HWTEST_F_L0(BuiltinsSharedTypedArrayTest,LastIndexOf_Two)709 HWTEST_F_L0(BuiltinsSharedTypedArrayTest, LastIndexOf_Two)
710 {
711 auto ecmaVM = thread->GetEcmaVM();
712 ObjectFactory *factory = ecmaVM->GetFactory();
713
714 JSHandle<TaggedArray> array(factory->NewSTaggedArray(3));
715 array->Set(thread, 0, JSTaggedValue(1));
716 array->Set(thread, 1, JSTaggedValue(2));
717 array->Set(thread, 2, JSTaggedValue(3));
718
719 JSHandle<JSTaggedValue> obj = JSHandle<JSTaggedValue>(thread, BuiltTestUtil::CreateSharedTypedArray(thread, array));
720
721 auto ecmaRuntimeCallInfo1 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 6);
722 ecmaRuntimeCallInfo1->SetFunction(JSTaggedValue::Undefined());
723 ecmaRuntimeCallInfo1->SetThis(obj.GetTaggedValue());
724 ecmaRuntimeCallInfo1->SetCallArg(0, JSTaggedValue(2));
725 // find valid index 1
726 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo1);
727 JSTaggedValue result = BuiltinsSharedTypedArray::LastIndexOf(ecmaRuntimeCallInfo1);
728 TestHelper::TearDownFrame(thread, prev);
729 ASSERT_EQ(result.GetRawData(), JSTaggedValue(1).GetRawData());
730
731 // find invalid index -1
732 ecmaRuntimeCallInfo1->SetCallArg(0, JSTaggedValue(5));
733 prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo1);
734 result = BuiltinsSharedTypedArray::LastIndexOf(ecmaRuntimeCallInfo1);
735 TestHelper::TearDownFrame(thread, prev);
736 ASSERT_EQ(result.GetRawData(), JSTaggedValue(-1).GetRawData());
737
738 auto ecmaRuntimeCallInfo2 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 8);
739 ecmaRuntimeCallInfo2->SetFunction(JSTaggedValue::Undefined());
740 ecmaRuntimeCallInfo2->SetThis(obj.GetTaggedValue());
741 // find valid index
742 ecmaRuntimeCallInfo2->SetCallArg(0, JSTaggedValue(1));
743 ecmaRuntimeCallInfo2->SetCallArg(1, JSTaggedValue(2));
744 prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo2);
745 result = BuiltinsSharedTypedArray::LastIndexOf(ecmaRuntimeCallInfo2);
746 TestHelper::TearDownFrame(thread, prev);
747 ASSERT_EQ(result.GetRawData(), JSTaggedValue(0).GetRawData());
748
749 // find valid index
750 ecmaRuntimeCallInfo2->SetCallArg(0, JSTaggedValue(3));
751 ecmaRuntimeCallInfo2->SetCallArg(1, JSTaggedValue(1));
752 prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo2);
753 result = BuiltinsSharedTypedArray::LastIndexOf(ecmaRuntimeCallInfo2);
754 TestHelper::TearDownFrame(thread, prev);
755 ASSERT_EQ(result.GetRawData(), JSTaggedValue(-1).GetRawData());
756 }
757
HWTEST_F_L0(BuiltinsSharedTypedArrayTest,Join_Test1)758 HWTEST_F_L0(BuiltinsSharedTypedArrayTest, Join_Test1)
759 {
760 JSHandle<GlobalEnv> env = thread->GetEcmaVM()->GetGlobalEnv();
761
762 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
763 JSHandle<TaggedArray> array(factory->NewTaggedArray(2));
764 JSHandle<JSTaggedValue> val0(thread, JSTaggedValue(1));
765 JSHandle<JSTaggedValue> val1(thread, JSTaggedValue(2));
766
767 array->Set(thread, 0, val0);
768 array->Set(thread, 1, val1);
769
770 JSHandle<JSTaggedValue> jsarray(JSArray::CreateArrayFromList(thread, array));
771 JSHandle<JSFunction> typed_array(env->GetTypedArrayFunction());
772 JSHandle<JSObject> globalObject(thread, env->GetGlobalObject());
773 auto argv = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue(*typed_array), 6);
774 argv->SetFunction(JSTaggedValue(*typed_array));
775 argv->SetThis(JSTaggedValue(*globalObject));
776 argv->SetCallArg(0, jsarray.GetTaggedValue());
777 JSTaggedValue result = BuiltinsSharedTypedArray::Join(argv);
778 ASSERT_TRUE(!result.IsECMAObject());
779 }
780
HWTEST_F_L0(BuiltinsSharedTypedArrayTest,Keys_Test1)781 HWTEST_F_L0(BuiltinsSharedTypedArrayTest, Keys_Test1)
782 {
783 JSHandle<GlobalEnv> env = thread->GetEcmaVM()->GetGlobalEnv();
784
785 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
786 JSHandle<TaggedArray> array(factory->NewTaggedArray(2));
787 JSHandle<JSTaggedValue> val0(thread, JSTaggedValue(1));
788 JSHandle<JSTaggedValue> val1(thread, JSTaggedValue(2));
789
790 array->Set(thread, 0, val0);
791 array->Set(thread, 1, val1);
792
793 JSHandle<JSTaggedValue> jsarray(JSArray::CreateArrayFromList(thread, array));
794 JSHandle<JSFunction> typed_array(env->GetTypedArrayFunction());
795 JSHandle<JSObject> globalObject(thread, env->GetGlobalObject());
796 auto argv = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue(*typed_array), 6);
797 argv->SetFunction(JSTaggedValue(*typed_array));
798 argv->SetThis(JSTaggedValue(*globalObject));
799 argv->SetCallArg(0, jsarray.GetTaggedValue());
800 JSTaggedValue result = BuiltinsSharedTypedArray::Keys(argv);
801 ASSERT_TRUE(!result.IsECMAObject());
802 }
803
HWTEST_F_L0(BuiltinsSharedTypedArrayTest,GetLength_Test1)804 HWTEST_F_L0(BuiltinsSharedTypedArrayTest, GetLength_Test1)
805 {
806 JSHandle<GlobalEnv> env = thread->GetEcmaVM()->GetGlobalEnv();
807
808 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
809 JSHandle<TaggedArray> array(factory->NewTaggedArray(2));
810 JSHandle<JSTaggedValue> val0(thread, JSTaggedValue(1));
811 JSHandle<JSTaggedValue> val1(thread, JSTaggedValue(2));
812
813 array->Set(thread, 0, val0);
814 array->Set(thread, 1, val1);
815
816 JSHandle<JSTaggedValue> jsarray(JSArray::CreateArrayFromList(thread, array));
817 JSHandle<JSFunction> typed_array(env->GetTypedArrayFunction());
818 JSHandle<JSObject> globalObject(thread, env->GetGlobalObject());
819 auto argv = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue(*typed_array), 6);
820 argv->SetFunction(JSTaggedValue(*typed_array));
821 argv->SetThis(JSTaggedValue(*globalObject));
822 argv->SetCallArg(0, jsarray.GetTaggedValue());
823 JSTaggedValue result = BuiltinsSharedTypedArray::GetLength(argv);
824 ASSERT_TRUE(!result.IsECMAObject());
825 }
826
HWTEST_F_L0(BuiltinsSharedTypedArrayTest,Map_Test1)827 HWTEST_F_L0(BuiltinsSharedTypedArrayTest, Map_Test1)
828 {
829 JSHandle<GlobalEnv> env = thread->GetEcmaVM()->GetGlobalEnv();
830
831 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
832 JSHandle<TaggedArray> array(factory->NewTaggedArray(2));
833 JSHandle<JSTaggedValue> val0(thread, JSTaggedValue(1));
834 JSHandle<JSTaggedValue> val1(thread, JSTaggedValue(2));
835
836 array->Set(thread, 0, val0);
837 array->Set(thread, 1, val1);
838
839 JSHandle<JSTaggedValue> jsarray(JSArray::CreateArrayFromList(thread, array));
840 JSHandle<JSFunction> typed_array(env->GetTypedArrayFunction());
841 JSHandle<JSObject> globalObject(thread, env->GetGlobalObject());
842 auto argv = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue(*typed_array), 6);
843 argv->SetFunction(JSTaggedValue(*typed_array));
844 argv->SetThis(JSTaggedValue(*globalObject));
845 argv->SetCallArg(0, jsarray.GetTaggedValue());
846 JSTaggedValue result = BuiltinsSharedTypedArray::Map(argv);
847 ASSERT_TRUE(!result.IsECMAObject());
848 }
849
HWTEST_F_L0(BuiltinsSharedTypedArrayTest,Reduce_Test1)850 HWTEST_F_L0(BuiltinsSharedTypedArrayTest, Reduce_Test1)
851 {
852 JSHandle<GlobalEnv> env = thread->GetEcmaVM()->GetGlobalEnv();
853
854 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
855 JSHandle<TaggedArray> array(factory->NewTaggedArray(2));
856 JSHandle<JSTaggedValue> val0(thread, JSTaggedValue(1));
857 JSHandle<JSTaggedValue> val1(thread, JSTaggedValue(2));
858
859 array->Set(thread, 0, val0);
860 array->Set(thread, 1, val1);
861
862 JSHandle<JSTaggedValue> jsarray(JSArray::CreateArrayFromList(thread, array));
863 JSHandle<JSFunction> typed_array(env->GetTypedArrayFunction());
864 JSHandle<JSObject> globalObject(thread, env->GetGlobalObject());
865 auto argv = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue(*typed_array), 6);
866 argv->SetFunction(JSTaggedValue(*typed_array));
867 argv->SetThis(JSTaggedValue(*globalObject));
868 argv->SetCallArg(0, jsarray.GetTaggedValue());
869 JSTaggedValue result = BuiltinsSharedTypedArray::Reduce(argv);
870 ASSERT_TRUE(!result.IsECMAObject());
871 }
872
HWTEST_F_L0(BuiltinsSharedTypedArrayTest,ReduceRight_One)873 HWTEST_F_L0(BuiltinsSharedTypedArrayTest, ReduceRight_One)
874 {
875 JSHandle<GlobalEnv> env = thread->GetEcmaVM()->GetGlobalEnv();
876
877 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
878 JSHandle<TaggedArray> array(factory->NewTaggedArray(2));
879 JSHandle<JSTaggedValue> val0(thread, JSTaggedValue(1));
880 JSHandle<JSTaggedValue> val1(thread, JSTaggedValue(2));
881
882 array->Set(thread, 0, val0);
883 array->Set(thread, 1, val1);
884
885 JSHandle<JSTaggedValue> jsarray(JSArray::CreateArrayFromList(thread, array));
886 JSHandle<JSFunction> typed_array(env->GetTypedArrayFunction());
887 JSHandle<JSObject> globalObject(thread, env->GetGlobalObject());
888 auto argv = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue(*typed_array), 6);
889 argv->SetFunction(JSTaggedValue(*typed_array));
890 argv->SetThis(JSTaggedValue(*globalObject));
891 argv->SetCallArg(0, jsarray.GetTaggedValue());
892 JSTaggedValue result = BuiltinsSharedTypedArray::ReduceRight(argv);
893 ASSERT_TRUE(!result.IsECMAObject());
894 }
895
HWTEST_F_L0(BuiltinsSharedTypedArrayTest,ReduceRight_Two)896 HWTEST_F_L0(BuiltinsSharedTypedArrayTest, ReduceRight_Two)
897 {
898 auto ecmaVM = thread->GetEcmaVM();
899 JSHandle<GlobalEnv> env = ecmaVM->GetGlobalEnv();
900 ObjectFactory *factory = ecmaVM->GetFactory();
901
902 JSHandle<TaggedArray> array(factory->NewSTaggedArray(3));
903 array->Set(thread, 0, JSTaggedValue(1));
904 array->Set(thread, 1, JSTaggedValue(2));
905 array->Set(thread, 2, JSTaggedValue(3));
906
907 JSHandle<JSTaggedValue> obj = JSHandle<JSTaggedValue>(thread, BuiltTestUtil::CreateSharedTypedArray(thread, array));
908
909 JSHandle<JSFunction> func = factory->NewJSFunction(env, reinterpret_cast<void *>(TestClass::TestReduceRightFunc));
910
911 auto ecmaRuntimeCallInfo1 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 8);
912 ecmaRuntimeCallInfo1->SetFunction(JSTaggedValue::Undefined());
913 ecmaRuntimeCallInfo1->SetThis(obj.GetTaggedValue());
914 ecmaRuntimeCallInfo1->SetCallArg(0, func.GetTaggedValue());
915 // set initial value to 10
916 ecmaRuntimeCallInfo1->SetCallArg(1, JSTaggedValue(static_cast<int32_t>(10)));
917
918 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo1);
919 JSTaggedValue result = BuiltinsSharedTypedArray::ReduceRight(ecmaRuntimeCallInfo1);
920 TestHelper::TearDownFrame(thread, prev);
921 ASSERT_EQ(result.GetRawData(), JSTaggedValue(16).GetRawData());
922 }
923
HWTEST_F_L0(BuiltinsSharedTypedArrayTest,ReduceRight_Three)924 HWTEST_F_L0(BuiltinsSharedTypedArrayTest, ReduceRight_Three)
925 {
926 auto ecmaVM = thread->GetEcmaVM();
927 JSHandle<GlobalEnv> env = ecmaVM->GetGlobalEnv();
928 ObjectFactory *factory = ecmaVM->GetFactory();
929
930 JSHandle<TaggedArray> array(factory->NewSTaggedArray(3));
931 array->Set(thread, 0, JSTaggedValue(1));
932 array->Set(thread, 1, JSTaggedValue(2));
933 array->Set(thread, 2, JSTaggedValue(3));
934
935 JSHandle<JSTaggedValue> obj = JSHandle<JSTaggedValue>(thread, BuiltTestUtil::CreateSharedTypedArray(thread, array));
936
937 JSHandle<JSFunction> func = factory->NewJSFunction(env, reinterpret_cast<void *>(TestClass::TestReduceRightFunc));
938 // no initial value
939 auto ecmaRuntimeCallInfo1 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 6);
940 ecmaRuntimeCallInfo1->SetFunction(JSTaggedValue::Undefined());
941 ecmaRuntimeCallInfo1->SetThis(obj.GetTaggedValue());
942 ecmaRuntimeCallInfo1->SetCallArg(0, func.GetTaggedValue());
943
944 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo1);
945 JSTaggedValue result = BuiltinsSharedTypedArray::ReduceRight(ecmaRuntimeCallInfo1);
946 TestHelper::TearDownFrame(thread, prev);
947 ASSERT_EQ(result.GetRawData(), JSTaggedValue(6).GetRawData());
948 }
949
HWTEST_F_L0(BuiltinsSharedTypedArrayTest,Reverse_Test1)950 HWTEST_F_L0(BuiltinsSharedTypedArrayTest, Reverse_Test1)
951 {
952 JSHandle<GlobalEnv> env = thread->GetEcmaVM()->GetGlobalEnv();
953
954 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
955 JSHandle<TaggedArray> array(factory->NewTaggedArray(2));
956 JSHandle<JSTaggedValue> val0(thread, JSTaggedValue(1));
957 JSHandle<JSTaggedValue> val1(thread, JSTaggedValue(2));
958
959 array->Set(thread, 0, val0);
960 array->Set(thread, 1, val1);
961
962 JSHandle<JSTaggedValue> jsarray(JSArray::CreateArrayFromList(thread, array));
963 JSHandle<JSFunction> typed_array(env->GetTypedArrayFunction());
964 JSHandle<JSObject> globalObject(thread, env->GetGlobalObject());
965 auto argv = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue(*typed_array), 6);
966 argv->SetFunction(JSTaggedValue(*typed_array));
967 argv->SetThis(JSTaggedValue(*globalObject));
968 argv->SetCallArg(0, jsarray.GetTaggedValue());
969 JSTaggedValue result = BuiltinsSharedTypedArray::Reverse(argv);
970 ASSERT_TRUE(!result.IsECMAObject());
971 }
972
HWTEST_F_L0(BuiltinsSharedTypedArrayTest,Set_Test1)973 HWTEST_F_L0(BuiltinsSharedTypedArrayTest, Set_Test1)
974 {
975 JSHandle<GlobalEnv> env = thread->GetEcmaVM()->GetGlobalEnv();
976
977 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
978 JSHandle<TaggedArray> array(factory->NewTaggedArray(2));
979 JSHandle<JSTaggedValue> val0(thread, JSTaggedValue(1));
980 JSHandle<JSTaggedValue> val1(thread, JSTaggedValue(2));
981
982 array->Set(thread, 0, val0);
983 array->Set(thread, 1, val1);
984
985 JSHandle<JSTaggedValue> jsarray(JSArray::CreateArrayFromList(thread, array));
986 JSHandle<JSFunction> typed_array(env->GetTypedArrayFunction());
987 JSHandle<JSObject> globalObject(thread, env->GetGlobalObject());
988 auto argv = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue(*typed_array), 6);
989 argv->SetFunction(JSTaggedValue(*typed_array));
990 argv->SetThis(JSTaggedValue(*globalObject));
991 argv->SetCallArg(0, jsarray.GetTaggedValue());
992 JSTaggedValue result = BuiltinsSharedTypedArray::Set(argv);
993 ASSERT_TRUE(!result.IsECMAObject());
994 }
995
HWTEST_F_L0(BuiltinsSharedTypedArrayTest,Slice_Test1)996 HWTEST_F_L0(BuiltinsSharedTypedArrayTest, Slice_Test1)
997 {
998 JSHandle<GlobalEnv> env = thread->GetEcmaVM()->GetGlobalEnv();
999
1000 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
1001 JSHandle<TaggedArray> array(factory->NewTaggedArray(2));
1002 JSHandle<JSTaggedValue> val0(thread, JSTaggedValue(1));
1003 JSHandle<JSTaggedValue> val1(thread, JSTaggedValue(2));
1004
1005 array->Set(thread, 0, val0);
1006 array->Set(thread, 1, val1);
1007
1008 JSHandle<JSTaggedValue> jsarray(JSArray::CreateArrayFromList(thread, array));
1009 JSHandle<JSFunction> typed_array(env->GetTypedArrayFunction());
1010 JSHandle<JSObject> globalObject(thread, env->GetGlobalObject());
1011 auto argv = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue(*typed_array), 6);
1012 argv->SetFunction(JSTaggedValue(*typed_array));
1013 argv->SetThis(JSTaggedValue(*globalObject));
1014 argv->SetCallArg(0, jsarray.GetTaggedValue());
1015 JSTaggedValue result = BuiltinsSharedTypedArray::Slice(argv);
1016 ASSERT_TRUE(!result.IsECMAObject());
1017 }
1018
HWTEST_F_L0(BuiltinsSharedTypedArrayTest,Some_Test1)1019 HWTEST_F_L0(BuiltinsSharedTypedArrayTest, Some_Test1)
1020 {
1021 JSHandle<GlobalEnv> env = thread->GetEcmaVM()->GetGlobalEnv();
1022
1023 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
1024 JSHandle<TaggedArray> array(factory->NewTaggedArray(2));
1025 JSHandle<JSTaggedValue> val0(thread, JSTaggedValue(1));
1026 JSHandle<JSTaggedValue> val1(thread, JSTaggedValue(2));
1027
1028 array->Set(thread, 0, val0);
1029 array->Set(thread, 1, val1);
1030
1031 JSHandle<JSTaggedValue> jsarray(JSArray::CreateArrayFromList(thread, array));
1032 JSHandle<JSFunction> typed_array(env->GetTypedArrayFunction());
1033 JSHandle<JSObject> globalObject(thread, env->GetGlobalObject());
1034 auto argv = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue(*typed_array), 6);
1035 argv->SetFunction(JSTaggedValue(*typed_array));
1036 argv->SetThis(JSTaggedValue(*globalObject));
1037 argv->SetCallArg(0, jsarray.GetTaggedValue());
1038 JSTaggedValue result = BuiltinsSharedTypedArray::Some(argv);
1039 ASSERT_TRUE(!result.IsECMAObject());
1040 }
1041
HWTEST_F_L0(BuiltinsSharedTypedArrayTest,Sort_Test1)1042 HWTEST_F_L0(BuiltinsSharedTypedArrayTest, Sort_Test1)
1043 {
1044 JSHandle<GlobalEnv> env = thread->GetEcmaVM()->GetGlobalEnv();
1045
1046 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
1047 JSHandle<TaggedArray> array(factory->NewTaggedArray(2));
1048 JSHandle<JSTaggedValue> val0(thread, JSTaggedValue(1));
1049 JSHandle<JSTaggedValue> val1(thread, JSTaggedValue(2));
1050
1051 array->Set(thread, 0, val0);
1052 array->Set(thread, 1, val1);
1053
1054 JSHandle<JSTaggedValue> jsarray(JSArray::CreateArrayFromList(thread, array));
1055 JSHandle<JSFunction> typed_array(env->GetTypedArrayFunction());
1056 JSHandle<JSObject> globalObject(thread, env->GetGlobalObject());
1057 auto argv = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue(*typed_array), 6);
1058 argv->SetFunction(JSTaggedValue(*typed_array));
1059 argv->SetThis(JSTaggedValue(*globalObject));
1060 argv->SetCallArg(0, jsarray.GetTaggedValue());
1061 JSTaggedValue result = BuiltinsSharedTypedArray::Sort(argv);
1062 ASSERT_TRUE(!result.IsECMAObject());
1063 }
1064
HWTEST_F_L0(BuiltinsSharedTypedArrayTest,Subarray_Test1)1065 HWTEST_F_L0(BuiltinsSharedTypedArrayTest, Subarray_Test1)
1066 {
1067 JSHandle<GlobalEnv> env = thread->GetEcmaVM()->GetGlobalEnv();
1068
1069 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
1070 JSHandle<TaggedArray> array(factory->NewTaggedArray(2));
1071 JSHandle<JSTaggedValue> val0(thread, JSTaggedValue(1));
1072 JSHandle<JSTaggedValue> val1(thread, JSTaggedValue(2));
1073
1074 array->Set(thread, 0, val0);
1075 array->Set(thread, 1, val1);
1076
1077 JSHandle<JSTaggedValue> jsarray(JSArray::CreateArrayFromList(thread, array));
1078 JSHandle<JSFunction> typed_array(env->GetTypedArrayFunction());
1079 JSHandle<JSObject> globalObject(thread, env->GetGlobalObject());
1080 auto argv = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue(*typed_array), 6);
1081 argv->SetFunction(JSTaggedValue(*typed_array));
1082 argv->SetThis(JSTaggedValue(*globalObject));
1083 argv->SetCallArg(0, jsarray.GetTaggedValue());
1084 JSTaggedValue result = BuiltinsSharedTypedArray::Subarray(argv);
1085 ASSERT_TRUE(!result.IsECMAObject());
1086 }
1087
HWTEST_F_L0(BuiltinsSharedTypedArrayTest,ToString_Test1)1088 HWTEST_F_L0(BuiltinsSharedTypedArrayTest, ToString_Test1)
1089 {
1090 JSHandle<GlobalEnv> env = thread->GetEcmaVM()->GetGlobalEnv();
1091
1092 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
1093 JSHandle<TaggedArray> array(factory->NewTaggedArray(2));
1094 JSHandle<JSTaggedValue> val0(thread, JSTaggedValue(1));
1095 JSHandle<JSTaggedValue> val1(thread, JSTaggedValue(2));
1096
1097 array->Set(thread, 0, val0);
1098 array->Set(thread, 1, val1);
1099
1100 JSHandle<JSTaggedValue> jsarray(JSArray::CreateArrayFromList(thread, array));
1101 JSHandle<JSFunction> typed_array(env->GetTypedArrayFunction());
1102 JSHandle<JSObject> globalObject(thread, env->GetGlobalObject());
1103 auto argv = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue(*typed_array), 6);
1104 argv->SetFunction(JSTaggedValue(*typed_array));
1105 argv->SetThis(JSTaggedValue(*globalObject));
1106 argv->SetCallArg(0, jsarray.GetTaggedValue());
1107 JSTaggedValue result = BuiltinsSharedTypedArray::ToLocaleString(argv);
1108 ASSERT_TRUE(!result.IsECMAObject());
1109 }
1110
HWTEST_F_L0(BuiltinsSharedTypedArrayTest,ToString_Test2)1111 HWTEST_F_L0(BuiltinsSharedTypedArrayTest, ToString_Test2)
1112 {
1113 auto ecmaVM = thread->GetEcmaVM();
1114 ObjectFactory *factory = ecmaVM->GetFactory();
1115
1116 JSHandle<TaggedArray> array(factory->NewSTaggedArray(3));
1117 array->Set(thread, 0, JSTaggedValue(1));
1118 array->Set(thread, 1, JSTaggedValue(2));
1119 array->Set(thread, 2, JSTaggedValue(3));
1120
1121 JSHandle<JSTaggedValue> obj = JSHandle<JSTaggedValue>(thread, BuiltTestUtil::CreateSharedTypedArray(thread, array));
1122
1123 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 4);
1124 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
1125 ecmaRuntimeCallInfo->SetThis(obj.GetTaggedValue());
1126
1127 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo);
1128 JSTaggedValue result = BuiltinsSharedTypedArray::ToString(ecmaRuntimeCallInfo);
1129 TestHelper::TearDownFrame(thread, prev);
1130 JSHandle<EcmaString> resultHandle(thread, reinterpret_cast<EcmaString *>(result.GetRawData()));
1131
1132 JSHandle<EcmaString> str = thread->GetEcmaVM()->GetFactory()->NewFromASCII("1,2,3");
1133 ASSERT_EQ(EcmaStringAccessor::Compare(instance, resultHandle, str), 0);
1134 }
1135
HWTEST_F_L0(BuiltinsSharedTypedArrayTest,Values_Test1)1136 HWTEST_F_L0(BuiltinsSharedTypedArrayTest, Values_Test1)
1137 {
1138 JSHandle<GlobalEnv> env = thread->GetEcmaVM()->GetGlobalEnv();
1139
1140 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
1141 JSHandle<TaggedArray> array(factory->NewTaggedArray(2));
1142 JSHandle<JSTaggedValue> val0(thread, JSTaggedValue(1));
1143 JSHandle<JSTaggedValue> val1(thread, JSTaggedValue(2));
1144
1145 array->Set(thread, 0, val0);
1146 array->Set(thread, 1, val1);
1147
1148 JSHandle<JSTaggedValue> jsarray(JSArray::CreateArrayFromList(thread, array));
1149 JSHandle<JSFunction> typed_array(env->GetTypedArrayFunction());
1150 JSHandle<JSObject> globalObject(thread, env->GetGlobalObject());
1151 auto argv = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue(*typed_array), 6);
1152 argv->SetFunction(JSTaggedValue(*typed_array));
1153 argv->SetThis(JSTaggedValue(*globalObject));
1154 argv->SetCallArg(0, jsarray.GetTaggedValue());
1155 JSTaggedValue result = BuiltinsSharedTypedArray::Values(argv);
1156 ASSERT_TRUE(!result.IsECMAObject());
1157 }
1158
HWTEST_F_L0(BuiltinsSharedTypedArrayTest,ToStringTag_Test1)1159 HWTEST_F_L0(BuiltinsSharedTypedArrayTest, ToStringTag_Test1)
1160 {
1161 JSHandle<GlobalEnv> env = thread->GetEcmaVM()->GetGlobalEnv();
1162
1163 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
1164 JSHandle<TaggedArray> array(factory->NewTaggedArray(2));
1165 JSHandle<JSTaggedValue> val0(thread, JSTaggedValue(1));
1166 JSHandle<JSTaggedValue> val1(thread, JSTaggedValue(2));
1167
1168 array->Set(thread, 0, val0);
1169 array->Set(thread, 1, val1);
1170
1171 JSHandle<JSTaggedValue> jsarray(JSArray::CreateArrayFromList(thread, array));
1172 JSHandle<JSFunction> typed_array(env->GetTypedArrayFunction());
1173 JSHandle<JSObject> globalObject(thread, env->GetGlobalObject());
1174 auto argv = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue(*typed_array), 6);
1175 argv->SetFunction(JSTaggedValue(*typed_array));
1176 argv->SetThis(JSTaggedValue(*globalObject));
1177 argv->SetCallArg(0, jsarray.GetTaggedValue());
1178 JSTaggedValue result = BuiltinsSharedTypedArray::ToStringTag(argv);
1179 ASSERT_TRUE(!result.IsECMAObject());
1180 }
1181
HWTEST_F_L0(BuiltinsSharedTypedArrayTest,At_Test1)1182 HWTEST_F_L0(BuiltinsSharedTypedArrayTest, At_Test1)
1183 {
1184 JSHandle<GlobalEnv> env = thread->GetEcmaVM()->GetGlobalEnv();
1185
1186 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
1187 JSHandle<TaggedArray> array(factory->NewTaggedArray(2));
1188 JSHandle<JSTaggedValue> val0(thread, JSTaggedValue(1));
1189 JSHandle<JSTaggedValue> val1(thread, JSTaggedValue(2));
1190
1191 array->Set(thread, 0, val0);
1192 array->Set(thread, 1, val1);
1193
1194 JSHandle<JSTaggedValue> jsarray(JSArray::CreateArrayFromList(thread, array));
1195 JSHandle<JSFunction> typed_array(env->GetTypedArrayFunction());
1196 JSHandle<JSObject> globalObject(thread, env->GetGlobalObject());
1197 auto argv = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue(*typed_array), 6);
1198 argv->SetFunction(JSTaggedValue(*typed_array));
1199 argv->SetThis(JSTaggedValue(*globalObject));
1200 argv->SetCallArg(0, jsarray.GetTaggedValue());
1201 JSTaggedValue result = BuiltinsSharedTypedArray::At(argv);
1202 ASSERT_TRUE(!result.IsECMAObject());
1203 }
1204
HWTEST_F_L0(BuiltinsSharedTypedArrayTest,Includes_Test1)1205 HWTEST_F_L0(BuiltinsSharedTypedArrayTest, Includes_Test1)
1206 {
1207 JSHandle<GlobalEnv> env = thread->GetEcmaVM()->GetGlobalEnv();
1208
1209 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
1210 JSHandle<TaggedArray> array(factory->NewTaggedArray(2));
1211 JSHandle<JSTaggedValue> val0(thread, JSTaggedValue(1));
1212 JSHandle<JSTaggedValue> val1(thread, JSTaggedValue(2));
1213
1214 array->Set(thread, 0, val0);
1215 array->Set(thread, 1, val1);
1216
1217 JSHandle<JSTaggedValue> jsarray(JSArray::CreateArrayFromList(thread, array));
1218 JSHandle<JSFunction> typed_array(env->GetTypedArrayFunction());
1219 JSHandle<JSObject> globalObject(thread, env->GetGlobalObject());
1220 auto argv = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue(*typed_array), 6);
1221 argv->SetFunction(JSTaggedValue(*typed_array));
1222 argv->SetThis(JSTaggedValue(*globalObject));
1223 argv->SetCallArg(0, jsarray.GetTaggedValue());
1224 JSTaggedValue result = BuiltinsSharedTypedArray::Includes(argv);
1225 ASSERT_TRUE(!result.IsECMAObject());
1226 }
1227
HWTEST_F_L0(BuiltinsSharedTypedArrayTest,From_Test1)1228 HWTEST_F_L0(BuiltinsSharedTypedArrayTest, From_Test1)
1229 {
1230 JSHandle<GlobalEnv> env = thread->GetEcmaVM()->GetGlobalEnv();
1231
1232 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
1233 JSHandle<TaggedArray> array(factory->NewTaggedArray(2));
1234 JSHandle<JSTaggedValue> val0(thread, JSTaggedValue(1));
1235 JSHandle<JSTaggedValue> val1(thread, JSTaggedValue(2));
1236
1237 array->Set(thread, 0, val0);
1238 array->Set(thread, 1, val1);
1239
1240 JSHandle<JSTaggedValue> jsarray(JSArray::CreateArrayFromList(thread, array));
1241 JSHandle<JSFunction> typed_array(env->GetTypedArrayFunction());
1242 JSHandle<JSObject> globalObject(thread, env->GetGlobalObject());
1243 auto argv = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue(*typed_array), 6);
1244 argv->SetFunction(JSTaggedValue(*typed_array));
1245 argv->SetThis(JSTaggedValue(*globalObject));
1246 argv->SetCallArg(0, jsarray.GetTaggedValue());
1247 JSTaggedValue result = BuiltinsSharedTypedArray::From(argv);
1248 ASSERT_TRUE(!result.IsECMAObject());
1249 }
1250
1251 } // namespace panda::test