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
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 };
48
HWTEST_F_L0(BuiltinsSharedTypedArrayTest,TypedArrayBaseConstructor_Test1)49 HWTEST_F_L0(BuiltinsSharedTypedArrayTest, TypedArrayBaseConstructor_Test1)
50 {
51 JSHandle<GlobalEnv> env = thread->GetEcmaVM()->GetGlobalEnv();
52
53 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
54 JSHandle<TaggedArray> array(factory->NewTaggedArray(2));
55 JSHandle<JSTaggedValue> val0(thread, JSTaggedValue(1));
56 JSHandle<JSTaggedValue> val1(thread, JSTaggedValue(2));
57
58 array->Set(thread, 0, val0);
59 array->Set(thread, 1, val1);
60
61 JSHandle<JSTaggedValue> jsarray(JSArray::CreateArrayFromList(thread, array));
62 JSHandle<JSFunction> typed_array(env->GetTypedArrayFunction());
63 JSHandle<JSObject> globalObject(thread, env->GetGlobalObject());
64 auto ecmaRuntimeCallInfo1 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue(*typed_array), 6);
65 ecmaRuntimeCallInfo1->SetFunction(JSTaggedValue(*typed_array));
66 ecmaRuntimeCallInfo1->SetThis(JSTaggedValue(*globalObject));
67 ecmaRuntimeCallInfo1->SetCallArg(0, jsarray.GetTaggedValue());
68 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo1);
69 JSTaggedValue result = BuiltinsSharedTypedArray::TypedArrayBaseConstructor(ecmaRuntimeCallInfo1);
70 ASSERT_TRUE(!result.IsECMAObject());
71 }
72
HWTEST_F_L0(BuiltinsSharedTypedArrayTest,Int8ArrayConstructor1_Test1)73 HWTEST_F_L0(BuiltinsSharedTypedArrayTest, Int8ArrayConstructor1_Test1)
74 {
75 JSHandle<GlobalEnv> env = thread->GetEcmaVM()->GetGlobalEnv();
76
77 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
78 JSHandle<TaggedArray> array(factory->NewTaggedArray(2));
79 JSHandle<JSTaggedValue> val0(thread, JSTaggedValue(1));
80 JSHandle<JSTaggedValue> val1(thread, JSTaggedValue(2));
81 array->Set(thread, 0, val0);
82 array->Set(thread, 1, val1);
83
84 JSHandle<JSTaggedValue> jsarray(JSArray::CreateArrayFromList(thread, array));
85 JSHandle<JSFunction> int8_array(env->GetInt8ArrayFunction());
86 JSHandle<JSObject> globalObject(thread, env->GetGlobalObject());
87 auto ecmaRuntimeCallInfo1 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue(*int8_array), 6);
88 ecmaRuntimeCallInfo1->SetFunction(JSTaggedValue(*int8_array));
89 ecmaRuntimeCallInfo1->SetThis(JSTaggedValue(*globalObject));
90 ecmaRuntimeCallInfo1->SetCallArg(0, jsarray.GetTaggedValue());
91 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo1);
92 JSTaggedValue result = BuiltinsSharedTypedArray::Int8ArrayConstructor(ecmaRuntimeCallInfo1);
93 ASSERT_TRUE(!result.IsECMAObject());
94 }
95
96
97 // Scenario2: Test when argv is not nullptr then Uint8ArrayConstructor returns not nullptr.
HWTEST_F_L0(BuiltinsSharedTypedArrayTest,Uint8ArrayConstructor_Test1)98 HWTEST_F_L0(BuiltinsSharedTypedArrayTest, Uint8ArrayConstructor_Test1)
99 {
100 JSHandle<GlobalEnv> env = thread->GetEcmaVM()->GetGlobalEnv();
101
102 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
103 JSHandle<TaggedArray> array(factory->NewTaggedArray(2));
104 JSHandle<JSTaggedValue> val0(thread, JSTaggedValue(1));
105 JSHandle<JSTaggedValue> val1(thread, JSTaggedValue(2));
106 array->Set(thread, 0, val0);
107 array->Set(thread, 1, val1);
108
109 JSHandle<JSTaggedValue> jsarray(JSArray::CreateArrayFromList(thread, array));
110 JSHandle<JSFunction> uint8_array(env->GetUint8ArrayFunction());
111 JSHandle<JSObject> globalObject(thread, env->GetGlobalObject());
112 auto ecmaRuntimeCallInfo1 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue(*uint8_array), 6);
113 ecmaRuntimeCallInfo1->SetFunction(JSTaggedValue(*uint8_array));
114 ecmaRuntimeCallInfo1->SetThis(JSTaggedValue(*globalObject));
115 ecmaRuntimeCallInfo1->SetCallArg(0, jsarray.GetTaggedValue());
116 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo1);
117 JSTaggedValue result = BuiltinsSharedTypedArray::Uint8ArrayConstructor(ecmaRuntimeCallInfo1);
118 ASSERT_TRUE(!result.IsECMAObject());
119 }
120
HWTEST_F_L0(BuiltinsSharedTypedArrayTest,Uint8ClampedArrayConstructor_Test1)121 HWTEST_F_L0(BuiltinsSharedTypedArrayTest, Uint8ClampedArrayConstructor_Test1)
122 {
123 JSHandle<GlobalEnv> env = thread->GetEcmaVM()->GetGlobalEnv();
124
125 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
126 JSHandle<TaggedArray> array(factory->NewTaggedArray(2));
127 JSHandle<JSTaggedValue> val0(thread, JSTaggedValue(1));
128 JSHandle<JSTaggedValue> val1(thread, JSTaggedValue(2));
129 array->Set(thread, 0, val0);
130 array->Set(thread, 1, val1);
131
132 JSHandle<JSTaggedValue> jsarray(JSArray::CreateArrayFromList(thread, array));
133 JSHandle<JSFunction> int8c_array(env->GetUint8ClampedArrayFunction());
134 JSHandle<JSObject> globalObject(thread, env->GetGlobalObject());
135 auto ecmaRuntimeCallInfo1 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue(*int8c_array), 6);
136 ecmaRuntimeCallInfo1->SetFunction(JSTaggedValue(*int8c_array));
137 ecmaRuntimeCallInfo1->SetThis(JSTaggedValue(*globalObject));
138 ecmaRuntimeCallInfo1->SetCallArg(0, jsarray.GetTaggedValue());
139 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo1);
140 JSTaggedValue result = BuiltinsSharedTypedArray::Uint8ClampedArrayConstructor(ecmaRuntimeCallInfo1);
141 ASSERT_TRUE(!result.IsECMAObject());
142 }
143
HWTEST_F_L0(BuiltinsSharedTypedArrayTest,Int16ArrayConstructor_Test1)144 HWTEST_F_L0(BuiltinsSharedTypedArrayTest, Int16ArrayConstructor_Test1)
145 {
146 JSHandle<GlobalEnv> env = thread->GetEcmaVM()->GetGlobalEnv();
147
148 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
149 JSHandle<TaggedArray> array(factory->NewTaggedArray(2));
150 JSHandle<JSTaggedValue> val0(thread, JSTaggedValue(1));
151 JSHandle<JSTaggedValue> val1(thread, JSTaggedValue(2));
152 array->Set(thread, 0, val0);
153 array->Set(thread, 1, val1);
154
155 JSHandle<JSTaggedValue> jsarray(JSArray::CreateArrayFromList(thread, array));
156 JSHandle<JSFunction> int16_array(env->GetInt16ArrayFunction());
157 JSHandle<JSObject> globalObject(thread, env->GetGlobalObject());
158 auto ecmaRuntimeCallInfo1 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue(*int16_array), 6);
159 ecmaRuntimeCallInfo1->SetFunction(JSTaggedValue(*int16_array));
160 ecmaRuntimeCallInfo1->SetThis(JSTaggedValue(*globalObject));
161 ecmaRuntimeCallInfo1->SetCallArg(0, jsarray.GetTaggedValue());
162 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo1);
163 JSTaggedValue result = BuiltinsSharedTypedArray::Int16ArrayConstructor(ecmaRuntimeCallInfo1);
164 ASSERT_TRUE(!result.IsECMAObject());
165 }
166
HWTEST_F_L0(BuiltinsSharedTypedArrayTest,Uint16ArrayConstructor_Test1)167 HWTEST_F_L0(BuiltinsSharedTypedArrayTest, Uint16ArrayConstructor_Test1)
168 {
169 JSHandle<GlobalEnv> env = thread->GetEcmaVM()->GetGlobalEnv();
170
171 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
172 JSHandle<TaggedArray> array(factory->NewTaggedArray(2));
173 JSHandle<JSTaggedValue> val0(thread, JSTaggedValue(1));
174 JSHandle<JSTaggedValue> val1(thread, JSTaggedValue(2));
175 array->Set(thread, 0, val0);
176 array->Set(thread, 1, val1);
177
178 JSHandle<JSTaggedValue> jsarray(JSArray::CreateArrayFromList(thread, array));
179 JSHandle<JSFunction> uint16_array(env->GetUint16ArrayFunction());
180 JSHandle<JSObject> globalObject(thread, env->GetGlobalObject());
181 auto ecmaRuntimeCallInfo1 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue(*uint16_array), 6);
182 ecmaRuntimeCallInfo1->SetFunction(JSTaggedValue(*uint16_array));
183 ecmaRuntimeCallInfo1->SetThis(JSTaggedValue(*globalObject));
184 ecmaRuntimeCallInfo1->SetCallArg(0, jsarray.GetTaggedValue());
185 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo1);
186 JSTaggedValue result = BuiltinsSharedTypedArray::Uint16ArrayConstructor(ecmaRuntimeCallInfo1);
187 ASSERT_TRUE(!result.IsECMAObject());
188 }
189
HWTEST_F_L0(BuiltinsSharedTypedArrayTest,Int32ArrayConstructor_Test1)190 HWTEST_F_L0(BuiltinsSharedTypedArrayTest, Int32ArrayConstructor_Test1)
191 {
192 JSHandle<GlobalEnv> env = thread->GetEcmaVM()->GetGlobalEnv();
193
194 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
195 JSHandle<TaggedArray> array(factory->NewTaggedArray(2));
196 JSHandle<JSTaggedValue> val0(thread, JSTaggedValue(1));
197 JSHandle<JSTaggedValue> val1(thread, JSTaggedValue(2));
198 array->Set(thread, 0, val0);
199 array->Set(thread, 1, val1);
200
201 JSHandle<JSTaggedValue> jsarray(JSArray::CreateArrayFromList(thread, array));
202 JSHandle<JSFunction> int32_array(env->GetInt32ArrayFunction());
203 JSHandle<JSObject> globalObject(thread, env->GetGlobalObject());
204 auto ecmaRuntimeCallInfo1 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue(*int32_array), 6);
205 ecmaRuntimeCallInfo1->SetFunction(JSTaggedValue(*int32_array));
206 ecmaRuntimeCallInfo1->SetThis(JSTaggedValue(*globalObject));
207 ecmaRuntimeCallInfo1->SetCallArg(0, jsarray.GetTaggedValue());
208 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo1);
209 JSTaggedValue result = BuiltinsSharedTypedArray::Int32ArrayConstructor(ecmaRuntimeCallInfo1);
210 ASSERT_TRUE(!result.IsECMAObject());
211 }
212
HWTEST_F_L0(BuiltinsSharedTypedArrayTest,Uint32ArrayConstructor_Test1)213 HWTEST_F_L0(BuiltinsSharedTypedArrayTest, Uint32ArrayConstructor_Test1)
214 {
215 JSHandle<GlobalEnv> env = thread->GetEcmaVM()->GetGlobalEnv();
216
217 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
218 JSHandle<TaggedArray> array(factory->NewTaggedArray(2));
219 JSHandle<JSTaggedValue> val0(thread, JSTaggedValue(1));
220 JSHandle<JSTaggedValue> val1(thread, JSTaggedValue(2));
221 array->Set(thread, 0, val0);
222 array->Set(thread, 1, val1);
223
224 JSHandle<JSTaggedValue> jsarray(JSArray::CreateArrayFromList(thread, array));
225 JSHandle<JSFunction> uint32_array(env->GetUint32ArrayFunction());
226 JSHandle<JSObject> globalObject(thread, env->GetGlobalObject());
227 auto ecmaRuntimeCallInfo1 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue(*uint32_array), 6);
228 ecmaRuntimeCallInfo1->SetFunction(JSTaggedValue(*uint32_array));
229 ecmaRuntimeCallInfo1->SetThis(JSTaggedValue(*globalObject));
230 ecmaRuntimeCallInfo1->SetCallArg(0, jsarray.GetTaggedValue());
231 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo1);
232 JSTaggedValue result = BuiltinsSharedTypedArray::Uint32ArrayConstructor(ecmaRuntimeCallInfo1);
233 ASSERT_TRUE(!result.IsECMAObject());
234 }
235
HWTEST_F_L0(BuiltinsSharedTypedArrayTest,Float32ArrayConstructor_Test1)236 HWTEST_F_L0(BuiltinsSharedTypedArrayTest, Float32ArrayConstructor_Test1)
237 {
238 JSHandle<GlobalEnv> env = thread->GetEcmaVM()->GetGlobalEnv();
239
240 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
241 JSHandle<TaggedArray> array(factory->NewTaggedArray(2));
242 JSHandle<JSTaggedValue> val0(thread, JSTaggedValue(1));
243 JSHandle<JSTaggedValue> val1(thread, JSTaggedValue(2));
244 array->Set(thread, 0, val0);
245 array->Set(thread, 1, val1);
246
247 JSHandle<JSTaggedValue> jsarray(JSArray::CreateArrayFromList(thread, array));
248 JSHandle<JSFunction> float32_array(env->GetFloat32ArrayFunction());
249 JSHandle<JSObject> globalObject(thread, env->GetGlobalObject());
250 auto ecmaRuntimeCallInfo1 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue(*float32_array), 6);
251 ecmaRuntimeCallInfo1->SetFunction(JSTaggedValue(*float32_array));
252 ecmaRuntimeCallInfo1->SetThis(JSTaggedValue(*globalObject));
253 ecmaRuntimeCallInfo1->SetCallArg(0, jsarray.GetTaggedValue());
254 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo1);
255 JSTaggedValue result = BuiltinsSharedTypedArray::Float32ArrayConstructor(ecmaRuntimeCallInfo1);
256 ASSERT_TRUE(!result.IsECMAObject());
257 }
258
HWTEST_F_L0(BuiltinsSharedTypedArrayTest,Float64ArrayConstructor_Test1)259 HWTEST_F_L0(BuiltinsSharedTypedArrayTest, Float64ArrayConstructor_Test1)
260 {
261 JSHandle<GlobalEnv> env = thread->GetEcmaVM()->GetGlobalEnv();
262
263 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
264 JSHandle<TaggedArray> array(factory->NewTaggedArray(2));
265 JSHandle<JSTaggedValue> val0(thread, JSTaggedValue(1));
266 JSHandle<JSTaggedValue> val1(thread, JSTaggedValue(2));
267 array->Set(thread, 0, val0);
268 array->Set(thread, 1, val1);
269
270 JSHandle<JSTaggedValue> jsarray(JSArray::CreateArrayFromList(thread, array));
271 JSHandle<JSFunction> float64_array(env->GetFloat64ArrayFunction());
272 JSHandle<JSObject> globalObject(thread, env->GetGlobalObject());
273 auto ecmaRuntimeCallInfo1 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue(*float64_array), 6);
274 ecmaRuntimeCallInfo1->SetFunction(JSTaggedValue(*float64_array));
275 ecmaRuntimeCallInfo1->SetThis(JSTaggedValue(*globalObject));
276 ecmaRuntimeCallInfo1->SetCallArg(0, jsarray.GetTaggedValue());
277 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo1);
278 JSTaggedValue result = BuiltinsSharedTypedArray::Float64ArrayConstructor(ecmaRuntimeCallInfo1);
279 ASSERT_TRUE(!result.IsECMAObject());
280 }
281
HWTEST_F_L0(BuiltinsSharedTypedArrayTest,BigInt64ArrayConstructor_Test1)282 HWTEST_F_L0(BuiltinsSharedTypedArrayTest, BigInt64ArrayConstructor_Test1)
283 {
284 JSHandle<GlobalEnv> env = thread->GetEcmaVM()->GetGlobalEnv();
285
286 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
287 JSHandle<TaggedArray> array(factory->NewTaggedArray(2));
288 JSHandle<JSTaggedValue> val0(thread, JSTaggedValue(1));
289 JSHandle<JSTaggedValue> val1(thread, JSTaggedValue(2));
290 array->Set(thread, 0, val0);
291 array->Set(thread, 1, val1);
292
293 JSHandle<JSTaggedValue> jsarray(JSArray::CreateArrayFromList(thread, array));
294 JSHandle<JSFunction> bigint64_array(env->GetBigInt64ArrayFunction());
295 JSHandle<JSObject> globalObject(thread, env->GetGlobalObject());
296 auto ecmaRuntimeCallInfo1 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue(*bigint64_array), 6);
297 ecmaRuntimeCallInfo1->SetFunction(JSTaggedValue(*bigint64_array));
298 ecmaRuntimeCallInfo1->SetThis(JSTaggedValue(*globalObject));
299 ecmaRuntimeCallInfo1->SetCallArg(0, jsarray.GetTaggedValue());
300 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo1);
301 JSTaggedValue result = BuiltinsSharedTypedArray::BigInt64ArrayConstructor(ecmaRuntimeCallInfo1);
302 ASSERT_TRUE(!result.IsECMAObject());
303 }
304
HWTEST_F_L0(BuiltinsSharedTypedArrayTest,BigUint64ArrayConstructor_Test1)305 HWTEST_F_L0(BuiltinsSharedTypedArrayTest, BigUint64ArrayConstructor_Test1)
306 {
307 JSHandle<GlobalEnv> env = thread->GetEcmaVM()->GetGlobalEnv();
308
309 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
310 JSHandle<TaggedArray> array(factory->NewTaggedArray(2));
311 JSHandle<JSTaggedValue> val0(thread, JSTaggedValue(1));
312 JSHandle<JSTaggedValue> val1(thread, JSTaggedValue(2));
313 array->Set(thread, 0, val0);
314 array->Set(thread, 1, val1);
315
316 JSHandle<JSTaggedValue> jsarray(JSArray::CreateArrayFromList(thread, array));
317 JSHandle<JSFunction> biguint64_array(env->GetBigUint64ArrayFunction());
318 JSHandle<JSObject> globalObject(thread, env->GetGlobalObject());
319 auto ecmaRuntimeCallInfo1 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue(*biguint64_array), 6);
320 ecmaRuntimeCallInfo1->SetFunction(JSTaggedValue(*biguint64_array));
321 ecmaRuntimeCallInfo1->SetThis(JSTaggedValue(*globalObject));
322 ecmaRuntimeCallInfo1->SetCallArg(0, jsarray.GetTaggedValue());
323 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo1);
324 JSTaggedValue result = BuiltinsSharedTypedArray::BigUint64ArrayConstructor(ecmaRuntimeCallInfo1);
325 ASSERT_TRUE(!result.IsECMAObject());
326 }
327
HWTEST_F_L0(BuiltinsSharedTypedArrayTest,Of_Test1)328 HWTEST_F_L0(BuiltinsSharedTypedArrayTest, Of_Test1)
329 {
330 JSHandle<GlobalEnv> env = thread->GetEcmaVM()->GetGlobalEnv();
331
332 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
333 JSHandle<TaggedArray> array(factory->NewTaggedArray(2));
334 JSHandle<JSTaggedValue> val0(thread, JSTaggedValue(1));
335 JSHandle<JSTaggedValue> val1(thread, JSTaggedValue(2));
336
337 array->Set(thread, 0, val0);
338 array->Set(thread, 1, val1);
339
340 JSHandle<JSTaggedValue> jsarray(JSArray::CreateArrayFromList(thread, array));
341 JSHandle<JSFunction> typed_array(env->GetTypedArrayFunction());
342 JSHandle<JSObject> globalObject(thread, env->GetGlobalObject());
343 auto argv = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue(*typed_array), 6);
344 argv->SetFunction(JSTaggedValue(*typed_array));
345 argv->SetThis(JSTaggedValue(*globalObject));
346 argv->SetCallArg(0, jsarray.GetTaggedValue());
347 JSTaggedValue result = BuiltinsSharedTypedArray::Of(argv);
348 ASSERT_TRUE(!result.IsECMAObject());
349 }
350
HWTEST_F_L0(BuiltinsSharedTypedArrayTest,Species_Test1)351 HWTEST_F_L0(BuiltinsSharedTypedArrayTest, Species_Test1)
352 {
353 JSHandle<GlobalEnv> env = thread->GetEcmaVM()->GetGlobalEnv();
354
355 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
356 JSHandle<TaggedArray> array(factory->NewTaggedArray(2));
357 JSHandle<JSTaggedValue> val0(thread, JSTaggedValue(1));
358 JSHandle<JSTaggedValue> val1(thread, JSTaggedValue(2));
359
360 array->Set(thread, 0, val0);
361 array->Set(thread, 1, val1);
362
363 JSHandle<JSTaggedValue> jsarray(JSArray::CreateArrayFromList(thread, array));
364 JSHandle<JSFunction> typed_array(env->GetTypedArrayFunction());
365 JSHandle<JSObject> globalObject(thread, env->GetGlobalObject());
366 auto argv = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue(*typed_array), 6);
367 argv->SetFunction(JSTaggedValue(*typed_array));
368 argv->SetThis(JSTaggedValue(*globalObject));
369 argv->SetCallArg(0, jsarray.GetTaggedValue());
370 JSTaggedValue result = BuiltinsSharedTypedArray::Species(argv);
371 ASSERT_TRUE(result.IsECMAObject());
372 }
373
HWTEST_F_L0(BuiltinsSharedTypedArrayTest,GetBuffer_Test1)374 HWTEST_F_L0(BuiltinsSharedTypedArrayTest, GetBuffer_Test1)
375 {
376 JSHandle<GlobalEnv> env = thread->GetEcmaVM()->GetGlobalEnv();
377
378 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
379 JSHandle<TaggedArray> array(factory->NewTaggedArray(2));
380 JSHandle<JSTaggedValue> val0(thread, JSTaggedValue(1));
381 JSHandle<JSTaggedValue> val1(thread, JSTaggedValue(2));
382
383 array->Set(thread, 0, val0);
384 array->Set(thread, 1, val1);
385
386 JSHandle<JSTaggedValue> jsarray(JSArray::CreateArrayFromList(thread, array));
387 JSHandle<JSFunction> typed_array(env->GetTypedArrayFunction());
388 JSHandle<JSObject> globalObject(thread, env->GetGlobalObject());
389 auto argv = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue(*typed_array), 6);
390 argv->SetFunction(JSTaggedValue(*typed_array));
391 argv->SetThis(JSTaggedValue(*globalObject));
392 argv->SetCallArg(0, jsarray.GetTaggedValue());
393 JSTaggedValue result = BuiltinsSharedTypedArray::GetBuffer(argv);
394 ASSERT_TRUE(!result.IsECMAObject());
395 }
396
HWTEST_F_L0(BuiltinsSharedTypedArrayTest,GetByteLength_Test1)397 HWTEST_F_L0(BuiltinsSharedTypedArrayTest, GetByteLength_Test1)
398 {
399 JSHandle<GlobalEnv> env = thread->GetEcmaVM()->GetGlobalEnv();
400
401 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
402 JSHandle<TaggedArray> array(factory->NewTaggedArray(2));
403 JSHandle<JSTaggedValue> val0(thread, JSTaggedValue(1));
404 JSHandle<JSTaggedValue> val1(thread, JSTaggedValue(2));
405
406 array->Set(thread, 0, val0);
407 array->Set(thread, 1, val1);
408
409 JSHandle<JSTaggedValue> jsarray(JSArray::CreateArrayFromList(thread, array));
410 JSHandle<JSFunction> typed_array(env->GetTypedArrayFunction());
411 JSHandle<JSObject> globalObject(thread, env->GetGlobalObject());
412 auto argv = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue(*typed_array), 6);
413 argv->SetFunction(JSTaggedValue(*typed_array));
414 argv->SetThis(JSTaggedValue(*globalObject));
415 argv->SetCallArg(0, jsarray.GetTaggedValue());
416 JSTaggedValue result = BuiltinsSharedTypedArray::GetByteLength(argv);
417 ASSERT_TRUE(!result.IsECMAObject());
418 }
419
HWTEST_F_L0(BuiltinsSharedTypedArrayTest,GetByteOffset_Test1)420 HWTEST_F_L0(BuiltinsSharedTypedArrayTest, GetByteOffset_Test1)
421 {
422 JSHandle<GlobalEnv> env = thread->GetEcmaVM()->GetGlobalEnv();
423
424 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
425 JSHandle<TaggedArray> array(factory->NewTaggedArray(2));
426 JSHandle<JSTaggedValue> val0(thread, JSTaggedValue(1));
427 JSHandle<JSTaggedValue> val1(thread, JSTaggedValue(2));
428
429 array->Set(thread, 0, val0);
430 array->Set(thread, 1, val1);
431
432 JSHandle<JSTaggedValue> jsarray(JSArray::CreateArrayFromList(thread, array));
433 JSHandle<JSFunction> typed_array(env->GetTypedArrayFunction());
434 JSHandle<JSObject> globalObject(thread, env->GetGlobalObject());
435 auto argv = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue(*typed_array), 6);
436 argv->SetFunction(JSTaggedValue(*typed_array));
437 argv->SetThis(JSTaggedValue(*globalObject));
438 argv->SetCallArg(0, jsarray.GetTaggedValue());
439 JSTaggedValue result = BuiltinsSharedTypedArray::GetByteOffset(argv);
440 ASSERT_TRUE(!result.IsECMAObject());
441 }
442
HWTEST_F_L0(BuiltinsSharedTypedArrayTest,CopyWithin_Test1)443 HWTEST_F_L0(BuiltinsSharedTypedArrayTest, CopyWithin_Test1)
444 {
445 JSHandle<GlobalEnv> env = thread->GetEcmaVM()->GetGlobalEnv();
446
447 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
448 JSHandle<TaggedArray> array(factory->NewTaggedArray(2));
449 JSHandle<JSTaggedValue> val0(thread, JSTaggedValue(1));
450 JSHandle<JSTaggedValue> val1(thread, JSTaggedValue(2));
451
452 array->Set(thread, 0, val0);
453 array->Set(thread, 1, val1);
454
455 JSHandle<JSTaggedValue> jsarray(JSArray::CreateArrayFromList(thread, array));
456 JSHandle<JSFunction> typed_array(env->GetTypedArrayFunction());
457 JSHandle<JSObject> globalObject(thread, env->GetGlobalObject());
458 auto argv = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue(*typed_array), 6);
459 argv->SetFunction(JSTaggedValue(*typed_array));
460 argv->SetThis(JSTaggedValue(*globalObject));
461 argv->SetCallArg(0, jsarray.GetTaggedValue());
462 JSTaggedValue result = BuiltinsSharedTypedArray::CopyWithin(argv);
463 ASSERT_TRUE(!result.IsECMAObject());
464 }
465
HWTEST_F_L0(BuiltinsSharedTypedArrayTest,Entries_Test1)466 HWTEST_F_L0(BuiltinsSharedTypedArrayTest, Entries_Test1)
467 {
468 JSHandle<GlobalEnv> env = thread->GetEcmaVM()->GetGlobalEnv();
469
470 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
471 JSHandle<TaggedArray> array(factory->NewTaggedArray(2));
472 JSHandle<JSTaggedValue> val0(thread, JSTaggedValue(1));
473 JSHandle<JSTaggedValue> val1(thread, JSTaggedValue(2));
474
475 array->Set(thread, 0, val0);
476 array->Set(thread, 1, val1);
477
478 JSHandle<JSTaggedValue> jsarray(JSArray::CreateArrayFromList(thread, array));
479 JSHandle<JSFunction> typed_array(env->GetTypedArrayFunction());
480 JSHandle<JSObject> globalObject(thread, env->GetGlobalObject());
481 auto argv = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue(*typed_array), 6);
482 argv->SetFunction(JSTaggedValue(*typed_array));
483 argv->SetThis(JSTaggedValue(*globalObject));
484 argv->SetCallArg(0, jsarray.GetTaggedValue());
485 JSTaggedValue result = BuiltinsSharedTypedArray::Entries(argv);
486 ASSERT_TRUE(!result.IsECMAObject());
487 }
488
HWTEST_F_L0(BuiltinsSharedTypedArrayTest,Every_Test1)489 HWTEST_F_L0(BuiltinsSharedTypedArrayTest, Every_Test1)
490 {
491 JSHandle<GlobalEnv> env = thread->GetEcmaVM()->GetGlobalEnv();
492
493 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
494 JSHandle<TaggedArray> array(factory->NewTaggedArray(2));
495 JSHandle<JSTaggedValue> val0(thread, JSTaggedValue(1));
496 JSHandle<JSTaggedValue> val1(thread, JSTaggedValue(2));
497
498 array->Set(thread, 0, val0);
499 array->Set(thread, 1, val1);
500
501 JSHandle<JSTaggedValue> jsarray(JSArray::CreateArrayFromList(thread, array));
502 JSHandle<JSFunction> typed_array(env->GetTypedArrayFunction());
503 JSHandle<JSObject> globalObject(thread, env->GetGlobalObject());
504 auto argv = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue(*typed_array), 6);
505 argv->SetFunction(JSTaggedValue(*typed_array));
506 argv->SetThis(JSTaggedValue(*globalObject));
507 argv->SetCallArg(0, jsarray.GetTaggedValue());
508 JSTaggedValue result = BuiltinsSharedTypedArray::Every(argv);
509 ASSERT_TRUE(!result.IsECMAObject());
510 }
511
HWTEST_F_L0(BuiltinsSharedTypedArrayTest,Fill_Test1)512 HWTEST_F_L0(BuiltinsSharedTypedArrayTest, Fill_Test1)
513 {
514 JSHandle<GlobalEnv> env = thread->GetEcmaVM()->GetGlobalEnv();
515
516 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
517 JSHandle<TaggedArray> array(factory->NewTaggedArray(2));
518 JSHandle<JSTaggedValue> val0(thread, JSTaggedValue(1));
519 JSHandle<JSTaggedValue> val1(thread, JSTaggedValue(2));
520
521 array->Set(thread, 0, val0);
522 array->Set(thread, 1, val1);
523
524 JSHandle<JSTaggedValue> jsarray(JSArray::CreateArrayFromList(thread, array));
525 JSHandle<JSFunction> typed_array(env->GetTypedArrayFunction());
526 JSHandle<JSObject> globalObject(thread, env->GetGlobalObject());
527 auto argv = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue(*typed_array), 6);
528 argv->SetFunction(JSTaggedValue(*typed_array));
529 argv->SetThis(JSTaggedValue(*globalObject));
530 argv->SetCallArg(0, jsarray.GetTaggedValue());
531 JSTaggedValue result = BuiltinsSharedTypedArray::Fill(argv);
532 ASSERT_TRUE(!result.IsECMAObject());
533 }
534
HWTEST_F_L0(BuiltinsSharedTypedArrayTest,Filter_Test1)535 HWTEST_F_L0(BuiltinsSharedTypedArrayTest, Filter_Test1)
536 {
537 JSHandle<GlobalEnv> env = thread->GetEcmaVM()->GetGlobalEnv();
538
539 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
540 JSHandle<TaggedArray> array(factory->NewTaggedArray(2));
541 JSHandle<JSTaggedValue> val0(thread, JSTaggedValue(1));
542 JSHandle<JSTaggedValue> val1(thread, JSTaggedValue(2));
543
544 array->Set(thread, 0, val0);
545 array->Set(thread, 1, val1);
546
547 JSHandle<JSTaggedValue> jsarray(JSArray::CreateArrayFromList(thread, array));
548 JSHandle<JSFunction> typed_array(env->GetTypedArrayFunction());
549 JSHandle<JSObject> globalObject(thread, env->GetGlobalObject());
550 auto argv = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue(*typed_array), 6);
551 argv->SetFunction(JSTaggedValue(*typed_array));
552 argv->SetThis(JSTaggedValue(*globalObject));
553 argv->SetCallArg(0, jsarray.GetTaggedValue());
554 JSTaggedValue result = BuiltinsSharedTypedArray::Filter(argv);
555 ASSERT_TRUE(!result.IsECMAObject());
556 }
557
HWTEST_F_L0(BuiltinsSharedTypedArrayTest,Find_Test1)558 HWTEST_F_L0(BuiltinsSharedTypedArrayTest, Find_Test1)
559 {
560 JSHandle<GlobalEnv> env = thread->GetEcmaVM()->GetGlobalEnv();
561
562 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
563 JSHandle<TaggedArray> array(factory->NewTaggedArray(2));
564 JSHandle<JSTaggedValue> val0(thread, JSTaggedValue(1));
565 JSHandle<JSTaggedValue> val1(thread, JSTaggedValue(2));
566
567 array->Set(thread, 0, val0);
568 array->Set(thread, 1, val1);
569
570 JSHandle<JSTaggedValue> jsarray(JSArray::CreateArrayFromList(thread, array));
571 JSHandle<JSFunction> typed_array(env->GetTypedArrayFunction());
572 JSHandle<JSObject> globalObject(thread, env->GetGlobalObject());
573 auto argv = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue(*typed_array), 6);
574 argv->SetFunction(JSTaggedValue(*typed_array));
575 argv->SetThis(JSTaggedValue(*globalObject));
576 argv->SetCallArg(0, jsarray.GetTaggedValue());
577 JSTaggedValue result = BuiltinsSharedTypedArray::Find(argv);
578 ASSERT_TRUE(!result.IsECMAObject());
579 }
580
HWTEST_F_L0(BuiltinsSharedTypedArrayTest,FindIndex_Test1)581 HWTEST_F_L0(BuiltinsSharedTypedArrayTest, FindIndex_Test1)
582 {
583 JSHandle<GlobalEnv> env = thread->GetEcmaVM()->GetGlobalEnv();
584
585 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
586 JSHandle<TaggedArray> array(factory->NewTaggedArray(2));
587 JSHandle<JSTaggedValue> val0(thread, JSTaggedValue(1));
588 JSHandle<JSTaggedValue> val1(thread, JSTaggedValue(2));
589
590 array->Set(thread, 0, val0);
591 array->Set(thread, 1, val1);
592
593 JSHandle<JSTaggedValue> jsarray(JSArray::CreateArrayFromList(thread, array));
594 JSHandle<JSFunction> typed_array(env->GetTypedArrayFunction());
595 JSHandle<JSObject> globalObject(thread, env->GetGlobalObject());
596 auto argv = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue(*typed_array), 6);
597 argv->SetFunction(JSTaggedValue(*typed_array));
598 argv->SetThis(JSTaggedValue(*globalObject));
599 argv->SetCallArg(0, jsarray.GetTaggedValue());
600 JSTaggedValue result = BuiltinsSharedTypedArray::FindIndex(argv);
601 ASSERT_TRUE(!result.IsECMAObject());
602 }
603
HWTEST_F_L0(BuiltinsSharedTypedArrayTest,ForEach_Test1)604 HWTEST_F_L0(BuiltinsSharedTypedArrayTest, ForEach_Test1)
605 {
606 JSHandle<GlobalEnv> env = thread->GetEcmaVM()->GetGlobalEnv();
607
608 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
609 JSHandle<TaggedArray> array(factory->NewTaggedArray(2));
610 JSHandle<JSTaggedValue> val0(thread, JSTaggedValue(1));
611 JSHandle<JSTaggedValue> val1(thread, JSTaggedValue(2));
612
613 array->Set(thread, 0, val0);
614 array->Set(thread, 1, val1);
615
616 JSHandle<JSTaggedValue> jsarray(JSArray::CreateArrayFromList(thread, array));
617 JSHandle<JSFunction> typed_array(env->GetTypedArrayFunction());
618 JSHandle<JSObject> globalObject(thread, env->GetGlobalObject());
619 auto argv = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue(*typed_array), 6);
620 argv->SetFunction(JSTaggedValue(*typed_array));
621 argv->SetThis(JSTaggedValue(*globalObject));
622 argv->SetCallArg(0, jsarray.GetTaggedValue());
623 JSTaggedValue result = BuiltinsSharedTypedArray::ForEach(argv);
624 ASSERT_TRUE(!result.IsECMAObject());
625 }
626
HWTEST_F_L0(BuiltinsSharedTypedArrayTest,IndexOf_Test1)627 HWTEST_F_L0(BuiltinsSharedTypedArrayTest, IndexOf_Test1)
628 {
629 JSHandle<GlobalEnv> env = thread->GetEcmaVM()->GetGlobalEnv();
630
631 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
632 JSHandle<TaggedArray> array(factory->NewTaggedArray(2));
633 JSHandle<JSTaggedValue> val0(thread, JSTaggedValue(1));
634 JSHandle<JSTaggedValue> val1(thread, JSTaggedValue(2));
635
636 array->Set(thread, 0, val0);
637 array->Set(thread, 1, val1);
638
639 JSHandle<JSTaggedValue> jsarray(JSArray::CreateArrayFromList(thread, array));
640 JSHandle<JSFunction> typed_array(env->GetTypedArrayFunction());
641 JSHandle<JSObject> globalObject(thread, env->GetGlobalObject());
642 auto argv = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue(*typed_array), 6);
643 argv->SetFunction(JSTaggedValue(*typed_array));
644 argv->SetThis(JSTaggedValue(*globalObject));
645 argv->SetCallArg(0, jsarray.GetTaggedValue());
646 JSTaggedValue result = BuiltinsSharedTypedArray::IndexOf(argv);
647 ASSERT_TRUE(!result.IsECMAObject());
648 }
649
HWTEST_F_L0(BuiltinsSharedTypedArrayTest,Join_Test1)650 HWTEST_F_L0(BuiltinsSharedTypedArrayTest, Join_Test1)
651 {
652 JSHandle<GlobalEnv> env = thread->GetEcmaVM()->GetGlobalEnv();
653
654 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
655 JSHandle<TaggedArray> array(factory->NewTaggedArray(2));
656 JSHandle<JSTaggedValue> val0(thread, JSTaggedValue(1));
657 JSHandle<JSTaggedValue> val1(thread, JSTaggedValue(2));
658
659 array->Set(thread, 0, val0);
660 array->Set(thread, 1, val1);
661
662 JSHandle<JSTaggedValue> jsarray(JSArray::CreateArrayFromList(thread, array));
663 JSHandle<JSFunction> typed_array(env->GetTypedArrayFunction());
664 JSHandle<JSObject> globalObject(thread, env->GetGlobalObject());
665 auto argv = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue(*typed_array), 6);
666 argv->SetFunction(JSTaggedValue(*typed_array));
667 argv->SetThis(JSTaggedValue(*globalObject));
668 argv->SetCallArg(0, jsarray.GetTaggedValue());
669 JSTaggedValue result = BuiltinsSharedTypedArray::Join(argv);
670 ASSERT_TRUE(!result.IsECMAObject());
671 }
672
HWTEST_F_L0(BuiltinsSharedTypedArrayTest,Keys_Test1)673 HWTEST_F_L0(BuiltinsSharedTypedArrayTest, Keys_Test1)
674 {
675 JSHandle<GlobalEnv> env = thread->GetEcmaVM()->GetGlobalEnv();
676
677 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
678 JSHandle<TaggedArray> array(factory->NewTaggedArray(2));
679 JSHandle<JSTaggedValue> val0(thread, JSTaggedValue(1));
680 JSHandle<JSTaggedValue> val1(thread, JSTaggedValue(2));
681
682 array->Set(thread, 0, val0);
683 array->Set(thread, 1, val1);
684
685 JSHandle<JSTaggedValue> jsarray(JSArray::CreateArrayFromList(thread, array));
686 JSHandle<JSFunction> typed_array(env->GetTypedArrayFunction());
687 JSHandle<JSObject> globalObject(thread, env->GetGlobalObject());
688 auto argv = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue(*typed_array), 6);
689 argv->SetFunction(JSTaggedValue(*typed_array));
690 argv->SetThis(JSTaggedValue(*globalObject));
691 argv->SetCallArg(0, jsarray.GetTaggedValue());
692 JSTaggedValue result = BuiltinsSharedTypedArray::Keys(argv);
693 ASSERT_TRUE(!result.IsECMAObject());
694 }
695
HWTEST_F_L0(BuiltinsSharedTypedArrayTest,GetLength_Test1)696 HWTEST_F_L0(BuiltinsSharedTypedArrayTest, GetLength_Test1)
697 {
698 JSHandle<GlobalEnv> env = thread->GetEcmaVM()->GetGlobalEnv();
699
700 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
701 JSHandle<TaggedArray> array(factory->NewTaggedArray(2));
702 JSHandle<JSTaggedValue> val0(thread, JSTaggedValue(1));
703 JSHandle<JSTaggedValue> val1(thread, JSTaggedValue(2));
704
705 array->Set(thread, 0, val0);
706 array->Set(thread, 1, val1);
707
708 JSHandle<JSTaggedValue> jsarray(JSArray::CreateArrayFromList(thread, array));
709 JSHandle<JSFunction> typed_array(env->GetTypedArrayFunction());
710 JSHandle<JSObject> globalObject(thread, env->GetGlobalObject());
711 auto argv = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue(*typed_array), 6);
712 argv->SetFunction(JSTaggedValue(*typed_array));
713 argv->SetThis(JSTaggedValue(*globalObject));
714 argv->SetCallArg(0, jsarray.GetTaggedValue());
715 JSTaggedValue result = BuiltinsSharedTypedArray::GetLength(argv);
716 ASSERT_TRUE(!result.IsECMAObject());
717 }
718
HWTEST_F_L0(BuiltinsSharedTypedArrayTest,Map_Test1)719 HWTEST_F_L0(BuiltinsSharedTypedArrayTest, Map_Test1)
720 {
721 JSHandle<GlobalEnv> env = thread->GetEcmaVM()->GetGlobalEnv();
722
723 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
724 JSHandle<TaggedArray> array(factory->NewTaggedArray(2));
725 JSHandle<JSTaggedValue> val0(thread, JSTaggedValue(1));
726 JSHandle<JSTaggedValue> val1(thread, JSTaggedValue(2));
727
728 array->Set(thread, 0, val0);
729 array->Set(thread, 1, val1);
730
731 JSHandle<JSTaggedValue> jsarray(JSArray::CreateArrayFromList(thread, array));
732 JSHandle<JSFunction> typed_array(env->GetTypedArrayFunction());
733 JSHandle<JSObject> globalObject(thread, env->GetGlobalObject());
734 auto argv = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue(*typed_array), 6);
735 argv->SetFunction(JSTaggedValue(*typed_array));
736 argv->SetThis(JSTaggedValue(*globalObject));
737 argv->SetCallArg(0, jsarray.GetTaggedValue());
738 JSTaggedValue result = BuiltinsSharedTypedArray::Map(argv);
739 ASSERT_TRUE(!result.IsECMAObject());
740 }
741
HWTEST_F_L0(BuiltinsSharedTypedArrayTest,Reduce_Test1)742 HWTEST_F_L0(BuiltinsSharedTypedArrayTest, Reduce_Test1)
743 {
744 JSHandle<GlobalEnv> env = thread->GetEcmaVM()->GetGlobalEnv();
745
746 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
747 JSHandle<TaggedArray> array(factory->NewTaggedArray(2));
748 JSHandle<JSTaggedValue> val0(thread, JSTaggedValue(1));
749 JSHandle<JSTaggedValue> val1(thread, JSTaggedValue(2));
750
751 array->Set(thread, 0, val0);
752 array->Set(thread, 1, val1);
753
754 JSHandle<JSTaggedValue> jsarray(JSArray::CreateArrayFromList(thread, array));
755 JSHandle<JSFunction> typed_array(env->GetTypedArrayFunction());
756 JSHandle<JSObject> globalObject(thread, env->GetGlobalObject());
757 auto argv = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue(*typed_array), 6);
758 argv->SetFunction(JSTaggedValue(*typed_array));
759 argv->SetThis(JSTaggedValue(*globalObject));
760 argv->SetCallArg(0, jsarray.GetTaggedValue());
761 JSTaggedValue result = BuiltinsSharedTypedArray::Reduce(argv);
762 ASSERT_TRUE(!result.IsECMAObject());
763 }
764
HWTEST_F_L0(BuiltinsSharedTypedArrayTest,Reverse_Test1)765 HWTEST_F_L0(BuiltinsSharedTypedArrayTest, Reverse_Test1)
766 {
767 JSHandle<GlobalEnv> env = thread->GetEcmaVM()->GetGlobalEnv();
768
769 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
770 JSHandle<TaggedArray> array(factory->NewTaggedArray(2));
771 JSHandle<JSTaggedValue> val0(thread, JSTaggedValue(1));
772 JSHandle<JSTaggedValue> val1(thread, JSTaggedValue(2));
773
774 array->Set(thread, 0, val0);
775 array->Set(thread, 1, val1);
776
777 JSHandle<JSTaggedValue> jsarray(JSArray::CreateArrayFromList(thread, array));
778 JSHandle<JSFunction> typed_array(env->GetTypedArrayFunction());
779 JSHandle<JSObject> globalObject(thread, env->GetGlobalObject());
780 auto argv = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue(*typed_array), 6);
781 argv->SetFunction(JSTaggedValue(*typed_array));
782 argv->SetThis(JSTaggedValue(*globalObject));
783 argv->SetCallArg(0, jsarray.GetTaggedValue());
784 JSTaggedValue result = BuiltinsSharedTypedArray::Reverse(argv);
785 ASSERT_TRUE(!result.IsECMAObject());
786 }
787
HWTEST_F_L0(BuiltinsSharedTypedArrayTest,Set_Test1)788 HWTEST_F_L0(BuiltinsSharedTypedArrayTest, Set_Test1)
789 {
790 JSHandle<GlobalEnv> env = thread->GetEcmaVM()->GetGlobalEnv();
791
792 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
793 JSHandle<TaggedArray> array(factory->NewTaggedArray(2));
794 JSHandle<JSTaggedValue> val0(thread, JSTaggedValue(1));
795 JSHandle<JSTaggedValue> val1(thread, JSTaggedValue(2));
796
797 array->Set(thread, 0, val0);
798 array->Set(thread, 1, val1);
799
800 JSHandle<JSTaggedValue> jsarray(JSArray::CreateArrayFromList(thread, array));
801 JSHandle<JSFunction> typed_array(env->GetTypedArrayFunction());
802 JSHandle<JSObject> globalObject(thread, env->GetGlobalObject());
803 auto argv = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue(*typed_array), 6);
804 argv->SetFunction(JSTaggedValue(*typed_array));
805 argv->SetThis(JSTaggedValue(*globalObject));
806 argv->SetCallArg(0, jsarray.GetTaggedValue());
807 JSTaggedValue result = BuiltinsSharedTypedArray::Set(argv);
808 ASSERT_TRUE(!result.IsECMAObject());
809 }
810
HWTEST_F_L0(BuiltinsSharedTypedArrayTest,Slice_Test1)811 HWTEST_F_L0(BuiltinsSharedTypedArrayTest, Slice_Test1)
812 {
813 JSHandle<GlobalEnv> env = thread->GetEcmaVM()->GetGlobalEnv();
814
815 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
816 JSHandle<TaggedArray> array(factory->NewTaggedArray(2));
817 JSHandle<JSTaggedValue> val0(thread, JSTaggedValue(1));
818 JSHandle<JSTaggedValue> val1(thread, JSTaggedValue(2));
819
820 array->Set(thread, 0, val0);
821 array->Set(thread, 1, val1);
822
823 JSHandle<JSTaggedValue> jsarray(JSArray::CreateArrayFromList(thread, array));
824 JSHandle<JSFunction> typed_array(env->GetTypedArrayFunction());
825 JSHandle<JSObject> globalObject(thread, env->GetGlobalObject());
826 auto argv = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue(*typed_array), 6);
827 argv->SetFunction(JSTaggedValue(*typed_array));
828 argv->SetThis(JSTaggedValue(*globalObject));
829 argv->SetCallArg(0, jsarray.GetTaggedValue());
830 JSTaggedValue result = BuiltinsSharedTypedArray::Slice(argv);
831 ASSERT_TRUE(!result.IsECMAObject());
832 }
833
HWTEST_F_L0(BuiltinsSharedTypedArrayTest,Some_Test1)834 HWTEST_F_L0(BuiltinsSharedTypedArrayTest, Some_Test1)
835 {
836 JSHandle<GlobalEnv> env = thread->GetEcmaVM()->GetGlobalEnv();
837
838 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
839 JSHandle<TaggedArray> array(factory->NewTaggedArray(2));
840 JSHandle<JSTaggedValue> val0(thread, JSTaggedValue(1));
841 JSHandle<JSTaggedValue> val1(thread, JSTaggedValue(2));
842
843 array->Set(thread, 0, val0);
844 array->Set(thread, 1, val1);
845
846 JSHandle<JSTaggedValue> jsarray(JSArray::CreateArrayFromList(thread, array));
847 JSHandle<JSFunction> typed_array(env->GetTypedArrayFunction());
848 JSHandle<JSObject> globalObject(thread, env->GetGlobalObject());
849 auto argv = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue(*typed_array), 6);
850 argv->SetFunction(JSTaggedValue(*typed_array));
851 argv->SetThis(JSTaggedValue(*globalObject));
852 argv->SetCallArg(0, jsarray.GetTaggedValue());
853 JSTaggedValue result = BuiltinsSharedTypedArray::Some(argv);
854 ASSERT_TRUE(!result.IsECMAObject());
855 }
856
HWTEST_F_L0(BuiltinsSharedTypedArrayTest,Sort_Test1)857 HWTEST_F_L0(BuiltinsSharedTypedArrayTest, Sort_Test1)
858 {
859 JSHandle<GlobalEnv> env = thread->GetEcmaVM()->GetGlobalEnv();
860
861 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
862 JSHandle<TaggedArray> array(factory->NewTaggedArray(2));
863 JSHandle<JSTaggedValue> val0(thread, JSTaggedValue(1));
864 JSHandle<JSTaggedValue> val1(thread, JSTaggedValue(2));
865
866 array->Set(thread, 0, val0);
867 array->Set(thread, 1, val1);
868
869 JSHandle<JSTaggedValue> jsarray(JSArray::CreateArrayFromList(thread, array));
870 JSHandle<JSFunction> typed_array(env->GetTypedArrayFunction());
871 JSHandle<JSObject> globalObject(thread, env->GetGlobalObject());
872 auto argv = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue(*typed_array), 6);
873 argv->SetFunction(JSTaggedValue(*typed_array));
874 argv->SetThis(JSTaggedValue(*globalObject));
875 argv->SetCallArg(0, jsarray.GetTaggedValue());
876 JSTaggedValue result = BuiltinsSharedTypedArray::Sort(argv);
877 ASSERT_TRUE(!result.IsECMAObject());
878 }
879
HWTEST_F_L0(BuiltinsSharedTypedArrayTest,Subarray_Test1)880 HWTEST_F_L0(BuiltinsSharedTypedArrayTest, Subarray_Test1)
881 {
882 JSHandle<GlobalEnv> env = thread->GetEcmaVM()->GetGlobalEnv();
883
884 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
885 JSHandle<TaggedArray> array(factory->NewTaggedArray(2));
886 JSHandle<JSTaggedValue> val0(thread, JSTaggedValue(1));
887 JSHandle<JSTaggedValue> val1(thread, JSTaggedValue(2));
888
889 array->Set(thread, 0, val0);
890 array->Set(thread, 1, val1);
891
892 JSHandle<JSTaggedValue> jsarray(JSArray::CreateArrayFromList(thread, array));
893 JSHandle<JSFunction> typed_array(env->GetTypedArrayFunction());
894 JSHandle<JSObject> globalObject(thread, env->GetGlobalObject());
895 auto argv = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue(*typed_array), 6);
896 argv->SetFunction(JSTaggedValue(*typed_array));
897 argv->SetThis(JSTaggedValue(*globalObject));
898 argv->SetCallArg(0, jsarray.GetTaggedValue());
899 JSTaggedValue result = BuiltinsSharedTypedArray::Subarray(argv);
900 ASSERT_TRUE(!result.IsECMAObject());
901 }
902
HWTEST_F_L0(BuiltinsSharedTypedArrayTest,ToString_Test1)903 HWTEST_F_L0(BuiltinsSharedTypedArrayTest, ToString_Test1)
904 {
905 JSHandle<GlobalEnv> env = thread->GetEcmaVM()->GetGlobalEnv();
906
907 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
908 JSHandle<TaggedArray> array(factory->NewTaggedArray(2));
909 JSHandle<JSTaggedValue> val0(thread, JSTaggedValue(1));
910 JSHandle<JSTaggedValue> val1(thread, JSTaggedValue(2));
911
912 array->Set(thread, 0, val0);
913 array->Set(thread, 1, val1);
914
915 JSHandle<JSTaggedValue> jsarray(JSArray::CreateArrayFromList(thread, array));
916 JSHandle<JSFunction> typed_array(env->GetTypedArrayFunction());
917 JSHandle<JSObject> globalObject(thread, env->GetGlobalObject());
918 auto argv = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue(*typed_array), 6);
919 argv->SetFunction(JSTaggedValue(*typed_array));
920 argv->SetThis(JSTaggedValue(*globalObject));
921 argv->SetCallArg(0, jsarray.GetTaggedValue());
922 JSTaggedValue result = BuiltinsSharedTypedArray::ToLocaleString(argv);
923 ASSERT_TRUE(!result.IsECMAObject());
924 }
925
HWTEST_F_L0(BuiltinsSharedTypedArrayTest,Values_Test1)926 HWTEST_F_L0(BuiltinsSharedTypedArrayTest, Values_Test1)
927 {
928 JSHandle<GlobalEnv> env = thread->GetEcmaVM()->GetGlobalEnv();
929
930 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
931 JSHandle<TaggedArray> array(factory->NewTaggedArray(2));
932 JSHandle<JSTaggedValue> val0(thread, JSTaggedValue(1));
933 JSHandle<JSTaggedValue> val1(thread, JSTaggedValue(2));
934
935 array->Set(thread, 0, val0);
936 array->Set(thread, 1, val1);
937
938 JSHandle<JSTaggedValue> jsarray(JSArray::CreateArrayFromList(thread, array));
939 JSHandle<JSFunction> typed_array(env->GetTypedArrayFunction());
940 JSHandle<JSObject> globalObject(thread, env->GetGlobalObject());
941 auto argv = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue(*typed_array), 6);
942 argv->SetFunction(JSTaggedValue(*typed_array));
943 argv->SetThis(JSTaggedValue(*globalObject));
944 argv->SetCallArg(0, jsarray.GetTaggedValue());
945 JSTaggedValue result = BuiltinsSharedTypedArray::Values(argv);
946 ASSERT_TRUE(!result.IsECMAObject());
947 }
948
HWTEST_F_L0(BuiltinsSharedTypedArrayTest,ToStringTag_Test1)949 HWTEST_F_L0(BuiltinsSharedTypedArrayTest, ToStringTag_Test1)
950 {
951 JSHandle<GlobalEnv> env = thread->GetEcmaVM()->GetGlobalEnv();
952
953 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
954 JSHandle<TaggedArray> array(factory->NewTaggedArray(2));
955 JSHandle<JSTaggedValue> val0(thread, JSTaggedValue(1));
956 JSHandle<JSTaggedValue> val1(thread, JSTaggedValue(2));
957
958 array->Set(thread, 0, val0);
959 array->Set(thread, 1, val1);
960
961 JSHandle<JSTaggedValue> jsarray(JSArray::CreateArrayFromList(thread, array));
962 JSHandle<JSFunction> typed_array(env->GetTypedArrayFunction());
963 JSHandle<JSObject> globalObject(thread, env->GetGlobalObject());
964 auto argv = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue(*typed_array), 6);
965 argv->SetFunction(JSTaggedValue(*typed_array));
966 argv->SetThis(JSTaggedValue(*globalObject));
967 argv->SetCallArg(0, jsarray.GetTaggedValue());
968 JSTaggedValue result = BuiltinsSharedTypedArray::ToStringTag(argv);
969 ASSERT_TRUE(!result.IsECMAObject());
970 }
971
HWTEST_F_L0(BuiltinsSharedTypedArrayTest,At_Test1)972 HWTEST_F_L0(BuiltinsSharedTypedArrayTest, At_Test1)
973 {
974 JSHandle<GlobalEnv> env = thread->GetEcmaVM()->GetGlobalEnv();
975
976 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
977 JSHandle<TaggedArray> array(factory->NewTaggedArray(2));
978 JSHandle<JSTaggedValue> val0(thread, JSTaggedValue(1));
979 JSHandle<JSTaggedValue> val1(thread, JSTaggedValue(2));
980
981 array->Set(thread, 0, val0);
982 array->Set(thread, 1, val1);
983
984 JSHandle<JSTaggedValue> jsarray(JSArray::CreateArrayFromList(thread, array));
985 JSHandle<JSFunction> typed_array(env->GetTypedArrayFunction());
986 JSHandle<JSObject> globalObject(thread, env->GetGlobalObject());
987 auto argv = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue(*typed_array), 6);
988 argv->SetFunction(JSTaggedValue(*typed_array));
989 argv->SetThis(JSTaggedValue(*globalObject));
990 argv->SetCallArg(0, jsarray.GetTaggedValue());
991 JSTaggedValue result = BuiltinsSharedTypedArray::At(argv);
992 ASSERT_TRUE(!result.IsECMAObject());
993 }
994
HWTEST_F_L0(BuiltinsSharedTypedArrayTest,Includes_Test1)995 HWTEST_F_L0(BuiltinsSharedTypedArrayTest, Includes_Test1)
996 {
997 JSHandle<GlobalEnv> env = thread->GetEcmaVM()->GetGlobalEnv();
998
999 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
1000 JSHandle<TaggedArray> array(factory->NewTaggedArray(2));
1001 JSHandle<JSTaggedValue> val0(thread, JSTaggedValue(1));
1002 JSHandle<JSTaggedValue> val1(thread, JSTaggedValue(2));
1003
1004 array->Set(thread, 0, val0);
1005 array->Set(thread, 1, val1);
1006
1007 JSHandle<JSTaggedValue> jsarray(JSArray::CreateArrayFromList(thread, array));
1008 JSHandle<JSFunction> typed_array(env->GetTypedArrayFunction());
1009 JSHandle<JSObject> globalObject(thread, env->GetGlobalObject());
1010 auto argv = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue(*typed_array), 6);
1011 argv->SetFunction(JSTaggedValue(*typed_array));
1012 argv->SetThis(JSTaggedValue(*globalObject));
1013 argv->SetCallArg(0, jsarray.GetTaggedValue());
1014 JSTaggedValue result = BuiltinsSharedTypedArray::Includes(argv);
1015 ASSERT_TRUE(!result.IsECMAObject());
1016 }
1017
HWTEST_F_L0(BuiltinsSharedTypedArrayTest,From_Test1)1018 HWTEST_F_L0(BuiltinsSharedTypedArrayTest, From_Test1)
1019 {
1020 JSHandle<GlobalEnv> env = thread->GetEcmaVM()->GetGlobalEnv();
1021
1022 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
1023 JSHandle<TaggedArray> array(factory->NewTaggedArray(2));
1024 JSHandle<JSTaggedValue> val0(thread, JSTaggedValue(1));
1025 JSHandle<JSTaggedValue> val1(thread, JSTaggedValue(2));
1026
1027 array->Set(thread, 0, val0);
1028 array->Set(thread, 1, val1);
1029
1030 JSHandle<JSTaggedValue> jsarray(JSArray::CreateArrayFromList(thread, array));
1031 JSHandle<JSFunction> typed_array(env->GetTypedArrayFunction());
1032 JSHandle<JSObject> globalObject(thread, env->GetGlobalObject());
1033 auto argv = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue(*typed_array), 6);
1034 argv->SetFunction(JSTaggedValue(*typed_array));
1035 argv->SetThis(JSTaggedValue(*globalObject));
1036 argv->SetCallArg(0, jsarray.GetTaggedValue());
1037 JSTaggedValue result = BuiltinsSharedTypedArray::From(argv);
1038 ASSERT_TRUE(!result.IsECMAObject());
1039 }
1040
1041 } // namespace panda::test