1 /*
2 * Copyright (c) 2021 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include "ecmascript/base/typed_array_helper-inl.h"
17 #include "ecmascript/tests/test_helper.h"
18
19 using namespace panda::ecmascript;
20
21 namespace panda::test {
22 class JSTypedArrayTest : public testing::Test {
23 public:
SetUpTestCase()24 static void SetUpTestCase()
25 {
26 GTEST_LOG_(INFO) << "SetUpTestCase";
27 }
28
TearDownTestCase()29 static void TearDownTestCase()
30 {
31 GTEST_LOG_(INFO) << "TearDownCase";
32 }
33
SetUp()34 void SetUp() override
35 {
36 TestHelper::CreateEcmaVMWithScope(instance, thread, scope);
37 }
38
TearDown()39 void TearDown() override
40 {
41 TestHelper::DestroyEcmaVMWithScope(instance, scope);
42 }
43 PandaVM *instance {nullptr};
44 EcmaHandleScope *scope {nullptr};
45 JSThread *thread {nullptr};
46
47 const CVector<JSType> cVecJSType {
48 JSType::JS_INT8_ARRAY, JSType::JS_UINT8_ARRAY, JSType::JS_UINT8_CLAMPED_ARRAY,
49 JSType::JS_INT16_ARRAY, JSType::JS_UINT16_ARRAY,
50 JSType::JS_INT32_ARRAY, JSType::JS_UINT32_ARRAY,
51 JSType::JS_FLOAT32_ARRAY, JSType::JS_FLOAT64_ARRAY};
52
53 // CVector pushed with JSTaggedValue made from compatible input value for the JSType
54 const CVector<JSTaggedValue> cVecHandleTagValValueForTypedArray {
55 // Use "(S)(...)" cast to make v in "JSTaggedValue(T v) : coretypes::TaggedValue(v) {}" compatible with S
56 JSTaggedValue((int8_t)(-111)), JSTaggedValue((uint8_t)(222)), JSTaggedValue((uint8_t)(222)),
57 JSTaggedValue((int16_t)(-31111)), JSTaggedValue((uint16_t)(61111)),
58 // int32 : -2147483648->2147483647, uint32 : 0->4294967295
59 JSTaggedValue((int32_t)(2111111111)), JSTaggedValue((uint32_t)(4111111111)),
60 JSTaggedValue((float)(4321.1234)), JSTaggedValue((double)(987654321.123456789))
61 };
62 };
63
CreateNumberTypedArray(JSThread * thread,JSType jsType)64 JSHandle<JSTypedArray> CreateNumberTypedArray(JSThread *thread, JSType jsType)
65 {
66 JSHandle<GlobalEnv> env = thread->GetEcmaVM()->GetGlobalEnv();
67 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
68
69 JSHandle<JSTaggedValue> handleTagValFunc = env->GetInt8ArrayFunction();
70 switch (jsType) {
71 case JSType::JS_INT8_ARRAY:
72 break;
73 case JSType::JS_UINT8_ARRAY:
74 handleTagValFunc = env->GetUint8ArrayFunction();
75 break;
76 case JSType::JS_UINT8_CLAMPED_ARRAY:
77 handleTagValFunc = env->GetUint8ClampedArrayFunction();
78 break;
79 case JSType::JS_INT16_ARRAY:
80 handleTagValFunc = env->GetInt16ArrayFunction();
81 break;
82 case JSType::JS_UINT16_ARRAY:
83 handleTagValFunc = env->GetUint16ArrayFunction();
84 break;
85 case JSType::JS_INT32_ARRAY:
86 handleTagValFunc = env->GetInt32ArrayFunction();
87 break;
88 case JSType::JS_UINT32_ARRAY:
89 handleTagValFunc = env->GetUint32ArrayFunction();
90 break;
91 case JSType::JS_FLOAT32_ARRAY:
92 handleTagValFunc = env->GetFloat32ArrayFunction();
93 break;
94 case JSType::JS_FLOAT64_ARRAY:
95 handleTagValFunc = env->GetFloat64ArrayFunction();
96 break;
97 default:
98 ASSERT_PRINT(false, "the second argument is a wrong JSType for CreateNumberTypedArray function");
99 break;
100 }
101
102 return JSHandle<JSTypedArray>::Cast(
103 factory->NewJSObjectByConstructor(JSHandle<JSFunction>::Cast(handleTagValFunc), handleTagValFunc));
104 }
105
106 /*
107 * Feature: JSTypedArray
108 * Function: ToPropKey
109 * SubFunction: EcmaString::GetCString
110 * FunctionPoints: TaggedType Signs To EcmaString Signs
111 * CaseDescription: Check whether the EcmaStrings transformed through calling ToPropKey function from TaggedTypes are
112 * within expectations.
113 */
HWTEST_F_L0(JSTypedArrayTest,ToPropKey_001)114 HWTEST_F_L0(JSTypedArrayTest, ToPropKey_001)
115 {
116 JSHandle<JSTaggedValue> handleUndefined(thread, JSTaggedValue::Undefined());
117 JSHandle<JSTaggedValue> handleHole(thread, JSTaggedValue::Hole());
118 JSHandle<JSTaggedValue> hnadleTagValEcmaStrPropKeyTo1 = JSTypedArray::ToPropKey(thread, handleUndefined);
119 JSHandle<JSTaggedValue> hnadleTagValEcmaStrPropKeyTo2 = JSTypedArray::ToPropKey(thread, handleHole);
120 JSHandle<EcmaString> handleEcmaStrPropKeyTo1 = JSHandle<EcmaString>::Cast(hnadleTagValEcmaStrPropKeyTo1);
121 JSHandle<EcmaString> handleEcmaStrPropKeyTo2 = JSHandle<EcmaString>::Cast(hnadleTagValEcmaStrPropKeyTo2);
122 EXPECT_NE(0, sizeof(handleUndefined));
123 EXPECT_NE(0, sizeof(handleHole));
124 std::unique_ptr<char[]> uniCharArrTo1(handleEcmaStrPropKeyTo1->GetCString());
125 std::unique_ptr<char[]> uniCharArrTo2(handleEcmaStrPropKeyTo2->GetCString());
126 EXPECT_EQ(uniCharArrTo1[0], 'u');
127 EXPECT_EQ(uniCharArrTo1[1], 'n');
128 EXPECT_EQ(uniCharArrTo1[2], 'd');
129 EXPECT_EQ(uniCharArrTo1[3], 'e');
130 EXPECT_EQ(uniCharArrTo1[4], 'f');
131 EXPECT_EQ(uniCharArrTo1[5], 'i');
132 EXPECT_EQ(uniCharArrTo1[6], 'n');
133 EXPECT_EQ(uniCharArrTo1[7], 'e');
134 EXPECT_EQ(uniCharArrTo1[8], 'd');
135 EXPECT_EQ(uniCharArrTo1[9], 0); // "undefined"
136 EXPECT_EQ(uniCharArrTo2[0], 0); // ""
137 }
138
139 /*
140 * Feature: JSTypedArray
141 * Function: ToPropKey
142 * SubFunction: EcmaString::GetCString
143 * FunctionPoints: Number Signs To EcmaString Signs
144 * CaseDescription: Check whether the EcmaStrings transformed through calling ToPropKey function from Numbers are
145 * within expectations.
146 */
HWTEST_F_L0(JSTypedArrayTest,ToPropKey_002)147 HWTEST_F_L0(JSTypedArrayTest, ToPropKey_002)
148 {
149 JSHandle<JSTaggedValue> handleTagVal1(thread, JSTaggedValue(0));
150 JSHandle<JSTaggedValue> handleTagVal2(thread, JSTaggedValue(-1));
151 JSHandle<JSTaggedValue> handleTagVal3(thread, JSTaggedValue(1.789));
152 JSHandle<JSTaggedValue> handleTagVal4(thread, JSTaggedValue(-789.1));
153 JSHandle<JSTaggedValue> hnadleTagValEcmaStrPropKeyTo1 = JSTypedArray::ToPropKey(thread, handleTagVal1);
154 JSHandle<JSTaggedValue> hnadleTagValEcmaStrPropKeyTo2 = JSTypedArray::ToPropKey(thread, handleTagVal2);
155 JSHandle<JSTaggedValue> hnadleTagValEcmaStrPropKeyTo3 = JSTypedArray::ToPropKey(thread, handleTagVal3);
156 JSHandle<JSTaggedValue> hnadleTagValEcmaStrPropKeyTo4 = JSTypedArray::ToPropKey(thread, handleTagVal4);
157 JSHandle<EcmaString> handleEcmaStrPropKeyTo1 = JSHandle<EcmaString>::Cast(hnadleTagValEcmaStrPropKeyTo1);
158 JSHandle<EcmaString> handleEcmaStrPropKeyTo2 = JSHandle<EcmaString>::Cast(hnadleTagValEcmaStrPropKeyTo2);
159 JSHandle<EcmaString> handleEcmaStrPropKeyTo3 = JSHandle<EcmaString>::Cast(hnadleTagValEcmaStrPropKeyTo3);
160 JSHandle<EcmaString> handleEcmaStrPropKeyTo4 = JSHandle<EcmaString>::Cast(hnadleTagValEcmaStrPropKeyTo4);
161 std::unique_ptr<char[]> uniCharArrTo1(handleEcmaStrPropKeyTo1->GetCString());
162 std::unique_ptr<char[]> uniCharArrTo2(handleEcmaStrPropKeyTo2->GetCString());
163 std::unique_ptr<char[]> uniCharArrTo3(handleEcmaStrPropKeyTo3->GetCString());
164 std::unique_ptr<char[]> uniCharArrTo4(handleEcmaStrPropKeyTo4->GetCString());
165 EXPECT_EQ(uniCharArrTo1[0], '0');
166 EXPECT_EQ(uniCharArrTo1[1], 0); // "0"
167 EXPECT_EQ(uniCharArrTo2[0], '-');
168 EXPECT_EQ(uniCharArrTo2[1], '1');
169 EXPECT_EQ(uniCharArrTo2[2], 0); // "-1"
170 EXPECT_EQ(uniCharArrTo3[0], '1');
171 EXPECT_EQ(uniCharArrTo3[1], '.');
172 EXPECT_EQ(uniCharArrTo3[2], '7');
173 EXPECT_EQ(uniCharArrTo3[3], '8');
174 EXPECT_EQ(uniCharArrTo3[4], '9');
175 EXPECT_EQ(uniCharArrTo3[5], 0); // "1.789"
176 EXPECT_EQ(uniCharArrTo4[0], '-');
177 EXPECT_EQ(uniCharArrTo4[1], '7');
178 EXPECT_EQ(uniCharArrTo4[2], '8');
179 EXPECT_EQ(uniCharArrTo4[3], '9');
180 EXPECT_EQ(uniCharArrTo4[4], '.');
181 EXPECT_EQ(uniCharArrTo4[5], '1');
182 EXPECT_EQ(uniCharArrTo4[6], 0); // "-789.1"
183 }
184
185 /*
186 * Feature: JSTypedArray
187 * Function: CreateJSTypedArray(GlobalEnv::GetInt8ArrayFunction.../ObjectFactory::NewJSObjectByConstructor)
188 * SubFunction: JSTaggedValue::IsTypedArray/IsJSInt8Array...
189 * FunctionPoints: Create JSTypedArray(JSInt8Array...)
190 * CaseDescription: Check whether the bools returned through calling IsTypedArray/IsInt8Array... functions from the
191 * JSTypedArrays created through calling NewJSObjectByConstructor function are within expectations.
192 */
HWTEST_F_L0(JSTypedArrayTest,TypedArrayCreate)193 HWTEST_F_L0(JSTypedArrayTest, TypedArrayCreate)
194 {
195 JSHandle<JSTypedArray> handleInt8Array = CreateNumberTypedArray(thread, JSType::JS_INT8_ARRAY);
196 JSHandle<JSTaggedValue> handleTagValInt8Array = JSHandle<JSTaggedValue>::Cast(handleInt8Array);
197 EXPECT_TRUE(handleTagValInt8Array->IsJSInt8Array() && handleTagValInt8Array->IsTypedArray());
198
199 JSHandle<JSTypedArray> handleUint8Array = CreateNumberTypedArray(thread, JSType::JS_UINT8_ARRAY);
200 JSHandle<JSTaggedValue> handleTagValUint8Array = JSHandle<JSTaggedValue>::Cast(handleUint8Array);
201 EXPECT_TRUE(handleTagValUint8Array->IsJSUint8Array() && handleTagValUint8Array->IsTypedArray());
202
203 JSHandle<JSTypedArray> handleUint8ClampedArray = CreateNumberTypedArray(thread, JSType::JS_UINT8_CLAMPED_ARRAY);
204 JSHandle<JSTaggedValue> handleTagValUint8ClampedArray = JSHandle<JSTaggedValue>::Cast(handleUint8ClampedArray);
205 EXPECT_TRUE(handleTagValUint8ClampedArray->IsJSUint8ClampedArray() &&
206 handleTagValUint8ClampedArray->IsTypedArray());
207
208 JSHandle<JSTypedArray> handleInt16Array = CreateNumberTypedArray(thread, JSType::JS_INT16_ARRAY);
209 JSHandle<JSTaggedValue> handleTagValInt16Array = JSHandle<JSTaggedValue>::Cast(handleInt16Array);
210 EXPECT_TRUE(handleTagValInt16Array->IsJSInt16Array() && handleTagValInt16Array->IsTypedArray());
211
212 JSHandle<JSTypedArray> handleUint16Array = CreateNumberTypedArray(thread, JSType::JS_UINT16_ARRAY);
213 JSHandle<JSTaggedValue> handleTagValUint16Array = JSHandle<JSTaggedValue>::Cast(handleUint16Array);
214 EXPECT_TRUE(handleTagValUint16Array->IsJSUint16Array() && handleTagValUint16Array->IsTypedArray());
215
216 JSHandle<JSTypedArray> handleInt32Array = CreateNumberTypedArray(thread, JSType::JS_INT32_ARRAY);
217 JSHandle<JSTaggedValue> handleTagValInt32Array = JSHandle<JSTaggedValue>::Cast(handleInt32Array);
218 EXPECT_TRUE(handleTagValInt32Array->IsJSInt32Array() && handleTagValInt32Array->IsTypedArray());
219
220 JSHandle<JSTypedArray> handleUint32Array = CreateNumberTypedArray(thread, JSType::JS_UINT32_ARRAY);
221 JSHandle<JSTaggedValue> handleTagValUint32Array = JSHandle<JSTaggedValue>::Cast(handleUint32Array);
222 EXPECT_TRUE(handleTagValUint32Array->IsJSUint32Array() && handleTagValUint32Array->IsTypedArray());
223
224 JSHandle<JSTypedArray> handleFloat32Array = CreateNumberTypedArray(thread, JSType::JS_FLOAT32_ARRAY);
225 JSHandle<JSTaggedValue> handleTagValFloat32Array = JSHandle<JSTaggedValue>::Cast(handleFloat32Array);
226 EXPECT_TRUE(handleTagValFloat32Array->IsJSFloat32Array() && handleTagValFloat32Array->IsTypedArray());
227
228 JSHandle<JSTypedArray> handleFloat64Array = CreateNumberTypedArray(thread, JSType::JS_FLOAT64_ARRAY);
229 JSHandle<JSTaggedValue> handleTagValFloat64Array = JSHandle<JSTaggedValue>::Cast(handleFloat64Array);
230 EXPECT_TRUE(handleTagValFloat64Array->IsJSFloat64Array() && handleTagValFloat64Array->IsTypedArray());
231 }
232
233 /*
234 * Feature: JSTypedArray
235 * Function: SetViewedArrayBuffer
236 * SubFunction: GetViewedArrayBuffer/ObjectFactory::NewJSArrayBuffer
237 * FunctionPoints: Set ViewedArrayBuffer
238 * CaseDescription: Check whether the JSArrayBuffer returned through calling GetViewedArrayBuffer function from the
239 * JSTypedArray changed through calling SetViewedArrayBuffer function is within expectations.
240 */
HWTEST_F_L0(JSTypedArrayTest,SetViewedArrayBuffer)241 HWTEST_F_L0(JSTypedArrayTest, SetViewedArrayBuffer)
242 {
243 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
244 JSHandle<JSArrayBuffer> handleArrayBufferFrom = factory->NewJSArrayBuffer(10);
245 JSHandle<JSTaggedValue> handleTagValArrayBufferFrom = JSHandle<JSTaggedValue>::Cast(handleArrayBufferFrom);
246
247 for (int i = 0; i < cVecJSType.size(); i++) {
248 JSHandle<JSTypedArray> handleTypedArray = CreateNumberTypedArray(thread, cVecJSType.at(i));
249
250 EXPECT_EQ(handleTypedArray->GetViewedArrayBuffer(), JSTaggedValue::Undefined());
251 handleTypedArray->SetViewedArrayBuffer(thread, handleTagValArrayBufferFrom);
252 EXPECT_EQ(handleTypedArray->GetViewedArrayBuffer(), handleTagValArrayBufferFrom.GetTaggedValue());
253 }
254 }
255
256 /*
257 * Feature: JSTypedArray
258 * Function: SetTypedArrayName
259 * SubFunction: GetTypedArrayName
260 * FunctionPoints: Set TypedArrayName
261 * CaseDescription: Check whether the JSTaggedValue returned through calling GetTypedArrayName function from the
262 * JSTypedArray changed through calling SetTypedArrayName function is within expectations.
263 */
HWTEST_F_L0(JSTypedArrayTest,SetTypedArrayName)264 HWTEST_F_L0(JSTypedArrayTest, SetTypedArrayName)
265 {
266 CString cStrName = "cStrName";
267 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
268 JSHandle<EcmaString> handleEcmaStrNameFrom = factory->NewFromString(cStrName);
269 JSHandle<JSTaggedValue> handleTagValEcmaStrNameFrom = JSHandle<JSTaggedValue>::Cast(handleEcmaStrNameFrom);
270
271 for (int i = 0; i < cVecJSType.size(); i++) {
272 JSHandle<JSTypedArray> handleTypedArray = CreateNumberTypedArray(thread, cVecJSType.at(i));
273
274 EXPECT_EQ(handleTypedArray->GetTypedArrayName(), JSTaggedValue::Undefined());
275 handleTypedArray->SetTypedArrayName(thread, handleTagValEcmaStrNameFrom);
276 EXPECT_EQ(handleTypedArray->GetTypedArrayName(), handleTagValEcmaStrNameFrom.GetTaggedValue());
277 }
278 }
279
280 /*
281 * Feature: JSTypedArray
282 * Function: SetByteLength
283 * SubFunction: GetByteLength
284 * FunctionPoints: Set ByteLength
285 * CaseDescription: Check whether the Number returned through calling GetByteLength function from the JSTypedArray
286 * changed through calling SetByteLength function is within expectations.
287 */
HWTEST_F_L0(JSTypedArrayTest,SetByteLength)288 HWTEST_F_L0(JSTypedArrayTest, SetByteLength)
289 {
290 uint32_t u32ByteLength = 2;
291 JSHandle<JSTaggedValue> handleTagValByteLengthFrom(thread, JSTaggedValue(u32ByteLength));
292
293 for (int i = 0; i < cVecJSType.size(); i++) {
294 JSHandle<JSTypedArray> handleTypedArray = CreateNumberTypedArray(thread, cVecJSType.at(i));
295
296 EXPECT_EQ(handleTypedArray->GetByteLength(), JSTaggedValue(0));
297 handleTypedArray->SetByteLength(thread, handleTagValByteLengthFrom);
298 EXPECT_EQ(handleTypedArray->GetByteLength(), handleTagValByteLengthFrom.GetTaggedValue());
299 }
300 }
301
302 /*
303 * Feature: JSTypedArray
304 * Function: SetByteOffset
305 * SubFunction: GetByteOffset
306 * FunctionPoints: Set ByteOffset
307 * CaseDescription: Check whether the Number returned through calling GetByteOffset function from the JSTypedArray
308 * changed through calling SetByteOffset function is within expectations.
309 */
HWTEST_F_L0(JSTypedArrayTest,SetByteOffset)310 HWTEST_F_L0(JSTypedArrayTest, SetByteOffset)
311 {
312 uint32_t u32ByteOffset = 2;
313 JSHandle<JSTaggedValue> handleTagValByteOffsetFrom(thread, JSTaggedValue(u32ByteOffset));
314
315 for (int i = 0; i < cVecJSType.size(); i++) {
316 JSHandle<JSTypedArray> handleTypedArray = CreateNumberTypedArray(thread, cVecJSType.at(i));
317
318 EXPECT_EQ(handleTypedArray->GetByteOffset(), JSTaggedValue(0));
319 handleTypedArray->SetByteOffset(thread, handleTagValByteOffsetFrom);
320 EXPECT_EQ(handleTypedArray->GetByteOffset(), handleTagValByteOffsetFrom.GetTaggedValue());
321 }
322 }
323
324 /*
325 * Feature: JSTypedArray
326 * Function: SetArrayLength
327 * SubFunction: GetArrayLength
328 * FunctionPoints: Set ArrayLength
329 * CaseDescription: Check whether the Number returned through calling GetArrayLength function from the JSTypedArray
330 * changed through calling SetArrayLength function is within expectations.
331 */
HWTEST_F_L0(JSTypedArrayTest,SetArrayLength)332 HWTEST_F_L0(JSTypedArrayTest, SetArrayLength)
333 {
334 uint32_t u32ArrayLength = 2;
335 JSHandle<JSTaggedValue> handleTagValArrayLengthFrom(thread, JSTaggedValue(u32ArrayLength));
336
337 for (int i = 0; i < cVecJSType.size(); i++) {
338 JSHandle<JSTypedArray> handleTypedArray = CreateNumberTypedArray(thread, cVecJSType.at(i));
339
340 EXPECT_EQ(handleTypedArray->GetArrayLength(), JSTaggedValue(0));
341 handleTypedArray->SetArrayLength(thread, handleTagValArrayLengthFrom);
342 EXPECT_EQ(handleTypedArray->GetArrayLength(), handleTagValArrayLengthFrom.GetTaggedValue());
343 }
344 }
345
346 /*
347 * Feature: JSTypedArray
348 * Function: IntegerIndexedElementSet
349 * SubFunction: IntegerIndexedElementGet
350 * FunctionPoints: Set Element At Integer Index(JSTaggedValue) Of JSTypedArray
351 * CaseDescription: Check whether the OperationResults returned through calling IntegerIndexedElementGet function from
352 * the JSTypedArray changed through calling IntegerIndexedElementSet function are within expectations.
353 */
HWTEST_F_L0(JSTypedArrayTest,IntegerIndexedElementSet_Int8Array_001)354 HWTEST_F_L0(JSTypedArrayTest, IntegerIndexedElementSet_Int8Array_001)
355 {
356 uint32_t numElementsInt8Array = 256;
357 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
358 JSHandle<JSTypedArray> handleInt8Array = CreateNumberTypedArray(thread, JSType::JS_INT8_ARRAY);
359 JSHandle<JSTaggedValue> handleTagValInt8Array = JSHandle<JSTaggedValue>::Cast(handleInt8Array);
360
361 uint32_t sizeElement = ecmascript::base::TypedArrayHelper::GetElementSize(
362 JSHandle<JSObject>::Cast(handleInt8Array));
363 uint32_t byteLengthViewdArrayBuffer = sizeElement * numElementsInt8Array;
364 JSHandle<JSTaggedValue> handleTagValArrayBufferFrom = JSHandle<JSTaggedValue>::Cast(
365 factory->NewJSArrayBuffer(byteLengthViewdArrayBuffer));
366 handleInt8Array->SetViewedArrayBuffer(thread, handleTagValArrayBufferFrom);
367 handleInt8Array->SetArrayLength(thread, JSTaggedValue(numElementsInt8Array));
368
369 CVector<OperationResult> cVecOpResult = {};
370 for (int32_t i = 0; i < numElementsInt8Array; i++) {
371 EXPECT_TRUE(JSTypedArray::IntegerIndexedElementSet(thread, handleTagValInt8Array, JSTaggedValue(i),
372 JSHandle<JSTaggedValue>(thread, JSTaggedValue(std::numeric_limits<int8_t>::min() + i))));
373 OperationResult opResult = JSTypedArray::IntegerIndexedElementGet(thread, handleTagValInt8Array,
374 JSTaggedValue(i));
375 cVecOpResult.push_back(opResult);
376 }
377 for (int32_t i = 0; i < numElementsInt8Array; i++) {
378 EXPECT_EQ(cVecOpResult.at(i).GetValue().GetTaggedValue().GetNumber(), std::numeric_limits<int8_t>::min() + i);
379 }
380 cVecOpResult.clear();
381
382 OperationResult opResult1 = JSTypedArray::IntegerIndexedElementGet(thread, handleTagValInt8Array,
383 JSTaggedValue(-1));
384 OperationResult opResult2 = JSTypedArray::IntegerIndexedElementGet(thread, handleTagValInt8Array,
385 JSTaggedValue(-0.0));
386 OperationResult opResult3 = JSTypedArray::IntegerIndexedElementGet(thread, handleTagValInt8Array,
387 JSTaggedValue(1.1));
388 OperationResult opResult4 = JSTypedArray::IntegerIndexedElementGet(thread, handleTagValInt8Array,
389 JSTaggedValue(numElementsInt8Array));
390 EXPECT_EQ(opResult1.GetValue().GetTaggedValue(), JSTaggedValue::Undefined());
391 EXPECT_EQ(opResult2.GetValue().GetTaggedValue(), JSTaggedValue::Undefined());
392 EXPECT_EQ(opResult3.GetValue().GetTaggedValue(), JSTaggedValue::Undefined());
393 EXPECT_EQ(opResult4.GetValue().GetTaggedValue(), JSTaggedValue::Undefined());
394
395 EXPECT_FALSE(JSTypedArray::IntegerIndexedElementSet(thread, handleTagValInt8Array, JSTaggedValue(-1),
396 JSHandle<JSTaggedValue>(thread, JSTaggedValue(0))));
397 EXPECT_FALSE(JSTypedArray::IntegerIndexedElementSet(thread, handleTagValInt8Array,
398 JSTaggedValue(numElementsInt8Array), JSHandle<JSTaggedValue>(thread, JSTaggedValue(0))));
399 }
400
401 // Nonstandard input value for Int8Array
HWTEST_F_L0(JSTypedArrayTest,IntegerIndexedElementSet_Int8Array_002)402 HWTEST_F_L0(JSTypedArrayTest, IntegerIndexedElementSet_Int8Array_002)
403 {
404 uint32_t numElementsInt8Array = 16;
405 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
406 JSHandle<JSTypedArray> handleInt8Array = CreateNumberTypedArray(thread, JSType::JS_INT8_ARRAY);
407 JSHandle<JSTaggedValue> handleTagValInt8Array = JSHandle<JSTaggedValue>::Cast(handleInt8Array);
408
409 uint32_t sizeElement = ecmascript::base::TypedArrayHelper::GetElementSize(
410 JSHandle<JSObject>::Cast(handleInt8Array));
411 uint32_t byteLengthViewdArrayBuffer = sizeElement * numElementsInt8Array;
412 JSHandle<JSTaggedValue> handleTagValArrayBufferFrom = JSHandle<JSTaggedValue>::Cast(
413 factory->NewJSArrayBuffer(byteLengthViewdArrayBuffer));
414 handleInt8Array->SetViewedArrayBuffer(thread, handleTagValArrayBufferFrom);
415 handleInt8Array->SetArrayLength(thread, JSTaggedValue(numElementsInt8Array));
416
417 int64_t value1 = -129; // to int8 : 127
418 int64_t value2 = 128; // to int8 : -128
419 double value3 = 13.4; // to int8 : 13
420 double value4 = 13.6; // to int8 : 13
421 JSHandle<JSTaggedValue> handleTagValValueSet1(thread, JSTaggedValue(value1));
422 JSHandle<JSTaggedValue> handleTagValValueSet2(thread, JSTaggedValue(value2));
423 JSHandle<JSTaggedValue> handleTagValValueSet3(thread, JSTaggedValue(value3));
424 JSHandle<JSTaggedValue> handleTagValValueSet4(thread, JSTaggedValue(value4));
425
426 EXPECT_TRUE(JSTypedArray::IntegerIndexedElementSet(thread, handleTagValInt8Array, JSTaggedValue(0),
427 handleTagValValueSet1));
428 OperationResult opResult1 = JSTypedArray::IntegerIndexedElementGet(thread, handleTagValInt8Array,
429 JSTaggedValue(0));
430 EXPECT_TRUE(JSTypedArray::IntegerIndexedElementSet(thread, handleTagValInt8Array, JSTaggedValue(0),
431 handleTagValValueSet2));
432 OperationResult opResult2 = JSTypedArray::IntegerIndexedElementGet(thread, handleTagValInt8Array,
433 JSTaggedValue(0));
434 EXPECT_TRUE(JSTypedArray::IntegerIndexedElementSet(thread, handleTagValInt8Array, JSTaggedValue(0),
435 handleTagValValueSet3));
436 OperationResult opResult3 = JSTypedArray::IntegerIndexedElementGet(thread, handleTagValInt8Array,
437 JSTaggedValue(0));
438 EXPECT_TRUE(JSTypedArray::IntegerIndexedElementSet(thread, handleTagValInt8Array, JSTaggedValue(0),
439 handleTagValValueSet4));
440 OperationResult opResult4 = JSTypedArray::IntegerIndexedElementGet(thread, handleTagValInt8Array,
441 JSTaggedValue(0));
442
443 EXPECT_NE(value1, opResult1.GetValue().GetTaggedValue().GetNumber());
444 EXPECT_NE(value2, opResult2.GetValue().GetTaggedValue().GetNumber());
445 EXPECT_NE(value3, opResult3.GetValue().GetTaggedValue().GetNumber());
446 EXPECT_NE(value4, opResult4.GetValue().GetTaggedValue().GetNumber());
447 EXPECT_EQ(127, opResult1.GetValue().GetTaggedValue().GetNumber());
448 EXPECT_EQ(-128, opResult2.GetValue().GetTaggedValue().GetNumber());
449 EXPECT_EQ(13, opResult3.GetValue().GetTaggedValue().GetNumber());
450 EXPECT_EQ(13, opResult4.GetValue().GetTaggedValue().GetNumber());
451 }
452
HWTEST_F_L0(JSTypedArrayTest,IntegerIndexedElementSet_Uint8Array_001)453 HWTEST_F_L0(JSTypedArrayTest, IntegerIndexedElementSet_Uint8Array_001)
454 {
455 uint32_t numElementsUint8Array = 256;
456 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
457 JSHandle<JSTypedArray> handleUint8Array = CreateNumberTypedArray(thread, JSType::JS_UINT8_ARRAY);
458 JSHandle<JSTaggedValue> handleTagValUint8Array = JSHandle<JSTaggedValue>::Cast(handleUint8Array);
459
460 uint32_t sizeElement = ecmascript::base::TypedArrayHelper::GetElementSize(
461 JSHandle<JSObject>::Cast(handleUint8Array));
462 uint32_t byteLengthViewdArrayBuffer = sizeElement * numElementsUint8Array;
463 JSHandle<JSTaggedValue> handleTagValArrayBufferFrom = JSHandle<JSTaggedValue>::Cast(
464 factory->NewJSArrayBuffer(byteLengthViewdArrayBuffer));
465 handleUint8Array->SetViewedArrayBuffer(thread, handleTagValArrayBufferFrom);
466 handleUint8Array->SetArrayLength(thread, JSTaggedValue(numElementsUint8Array));
467
468 CVector<OperationResult> cVecOpResult = {};
469 for (uint32_t i = 0; i < numElementsUint8Array; i++) {
470 EXPECT_TRUE(JSTypedArray::IntegerIndexedElementSet(thread, handleTagValUint8Array, JSTaggedValue(i),
471 JSHandle<JSTaggedValue>(thread, JSTaggedValue(std::numeric_limits<uint8_t>::min() + i))));
472 OperationResult opResult = JSTypedArray::IntegerIndexedElementGet(thread, handleTagValUint8Array,
473 JSTaggedValue(i));
474 cVecOpResult.push_back(opResult);
475 }
476 for (uint32_t i = 0; i < numElementsUint8Array; i++) {
477 EXPECT_EQ(cVecOpResult.at(i).GetValue().GetTaggedValue().GetNumber(), std::numeric_limits<uint8_t>::min() + i);
478 }
479 cVecOpResult.clear();
480
481 OperationResult opResult1 = JSTypedArray::IntegerIndexedElementGet(thread, handleTagValUint8Array,
482 JSTaggedValue(-1));
483 OperationResult opResult2 = JSTypedArray::IntegerIndexedElementGet(thread, handleTagValUint8Array,
484 JSTaggedValue(-0.0));
485 OperationResult opResult3 = JSTypedArray::IntegerIndexedElementGet(thread, handleTagValUint8Array,
486 JSTaggedValue(1.1));
487 OperationResult opResult4 = JSTypedArray::IntegerIndexedElementGet(thread, handleTagValUint8Array,
488 JSTaggedValue(numElementsUint8Array));
489 EXPECT_EQ(opResult1.GetValue().GetTaggedValue(), JSTaggedValue::Undefined());
490 EXPECT_EQ(opResult2.GetValue().GetTaggedValue(), JSTaggedValue::Undefined());
491 EXPECT_EQ(opResult3.GetValue().GetTaggedValue(), JSTaggedValue::Undefined());
492 EXPECT_EQ(opResult4.GetValue().GetTaggedValue(), JSTaggedValue::Undefined());
493
494 EXPECT_FALSE(JSTypedArray::IntegerIndexedElementSet(thread, handleTagValUint8Array, JSTaggedValue(-1),
495 JSHandle<JSTaggedValue>(thread, JSTaggedValue(0))));
496 EXPECT_FALSE(JSTypedArray::IntegerIndexedElementSet(thread, handleTagValUint8Array,
497 JSTaggedValue(numElementsUint8Array), JSHandle<JSTaggedValue>(thread, JSTaggedValue(0))));
498 }
499
500 // Nonstandard input value for Uint8Array
HWTEST_F_L0(JSTypedArrayTest,IntegerIndexedElementSet_Uint8Array_002)501 HWTEST_F_L0(JSTypedArrayTest, IntegerIndexedElementSet_Uint8Array_002)
502 {
503 uint32_t numElementsUint8Array = 16;
504 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
505 JSHandle<JSTypedArray> handleUint8Array = CreateNumberTypedArray(thread, JSType::JS_UINT8_ARRAY);
506 JSHandle<JSTaggedValue> handleTagValUint8Array = JSHandle<JSTaggedValue>::Cast(handleUint8Array);
507
508 uint32_t sizeElement = ecmascript::base::TypedArrayHelper::GetElementSize(
509 JSHandle<JSObject>::Cast(handleUint8Array));
510 uint32_t byteLengthViewdArrayBuffer = sizeElement * numElementsUint8Array;
511 JSHandle<JSTaggedValue> handleTagValArrayBufferFrom = JSHandle<JSTaggedValue>::Cast(
512 factory->NewJSArrayBuffer(byteLengthViewdArrayBuffer));
513 handleUint8Array->SetViewedArrayBuffer(thread, handleTagValArrayBufferFrom);
514 handleUint8Array->SetArrayLength(thread, JSTaggedValue(numElementsUint8Array));
515
516 int64_t value1 = -1; // to uint8 : 255
517 int64_t value2 = 256; // to uint8 : 0
518 double value3 = 13.4; // to uint8 : 13
519 double value4 = 13.6; // to uint8 : 13
520 JSHandle<JSTaggedValue> handleTagValValueSet1(thread, JSTaggedValue(value1));
521 JSHandle<JSTaggedValue> handleTagValValueSet2(thread, JSTaggedValue(value2));
522 JSHandle<JSTaggedValue> handleTagValValueSet3(thread, JSTaggedValue(value3));
523 JSHandle<JSTaggedValue> handleTagValValueSet4(thread, JSTaggedValue(value4));
524
525 EXPECT_TRUE(JSTypedArray::IntegerIndexedElementSet(thread, handleTagValUint8Array, JSTaggedValue(0),
526 handleTagValValueSet1));
527 OperationResult opResult1 = JSTypedArray::IntegerIndexedElementGet(thread, handleTagValUint8Array,
528 JSTaggedValue(0));
529 EXPECT_TRUE(JSTypedArray::IntegerIndexedElementSet(thread, handleTagValUint8Array, JSTaggedValue(0),
530 handleTagValValueSet2));
531 OperationResult opResult2 = JSTypedArray::IntegerIndexedElementGet(thread, handleTagValUint8Array,
532 JSTaggedValue(0));
533 EXPECT_TRUE(JSTypedArray::IntegerIndexedElementSet(thread, handleTagValUint8Array, JSTaggedValue(0),
534 handleTagValValueSet3));
535 OperationResult opResult3 = JSTypedArray::IntegerIndexedElementGet(thread, handleTagValUint8Array,
536 JSTaggedValue(0));
537 EXPECT_TRUE(JSTypedArray::IntegerIndexedElementSet(thread, handleTagValUint8Array, JSTaggedValue(0),
538 handleTagValValueSet4));
539 OperationResult opResult4 = JSTypedArray::IntegerIndexedElementGet(thread, handleTagValUint8Array,
540 JSTaggedValue(0));
541
542 EXPECT_NE(value1, opResult1.GetValue().GetTaggedValue().GetNumber());
543 EXPECT_NE(value2, opResult2.GetValue().GetTaggedValue().GetNumber());
544 EXPECT_NE(value3, opResult3.GetValue().GetTaggedValue().GetNumber());
545 EXPECT_NE(value4, opResult4.GetValue().GetTaggedValue().GetNumber());
546 EXPECT_EQ(255, opResult1.GetValue().GetTaggedValue().GetNumber());
547 EXPECT_EQ(0, opResult2.GetValue().GetTaggedValue().GetNumber());
548 EXPECT_EQ(13, opResult3.GetValue().GetTaggedValue().GetNumber());
549 EXPECT_EQ(13, opResult4.GetValue().GetTaggedValue().GetNumber());
550 }
551
HWTEST_F_L0(JSTypedArrayTest,IntegerIndexedElementSet_Uint8ClampedArray_001)552 HWTEST_F_L0(JSTypedArrayTest, IntegerIndexedElementSet_Uint8ClampedArray_001)
553 {
554 uint32_t numElementsUint8ClampedArray = 256;
555 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
556 JSHandle<JSTypedArray> handleUint8ClampedArray = CreateNumberTypedArray(thread, JSType::JS_UINT8_CLAMPED_ARRAY);
557 JSHandle<JSTaggedValue> handleTagValUint8ClampedArray = JSHandle<JSTaggedValue>::Cast(handleUint8ClampedArray);
558
559 uint32_t sizeElement = ecmascript::base::TypedArrayHelper::GetElementSize(
560 JSHandle<JSObject>::Cast(handleUint8ClampedArray));
561 uint32_t byteLengthViewdArrayBuffer = sizeElement * numElementsUint8ClampedArray;
562 JSHandle<JSTaggedValue> handleTagValArrayBufferFrom = JSHandle<JSTaggedValue>::Cast(
563 factory->NewJSArrayBuffer(byteLengthViewdArrayBuffer));
564 handleUint8ClampedArray->SetViewedArrayBuffer(thread, handleTagValArrayBufferFrom);
565 handleUint8ClampedArray->SetArrayLength(thread, JSTaggedValue(numElementsUint8ClampedArray));
566
567 CVector<OperationResult> cVecOpResult = {};
568 for (uint32_t i = 0; i < numElementsUint8ClampedArray; i++) {
569 EXPECT_TRUE(JSTypedArray::IntegerIndexedElementSet(thread, handleTagValUint8ClampedArray, JSTaggedValue(i),
570 JSHandle<JSTaggedValue>(thread, JSTaggedValue(std::numeric_limits<uint8_t>::min() + i))));
571 OperationResult opResult = JSTypedArray::IntegerIndexedElementGet(thread, handleTagValUint8ClampedArray,
572 JSTaggedValue(i));
573 cVecOpResult.push_back(opResult);
574 }
575 for (uint32_t i = 0; i < numElementsUint8ClampedArray; i++) {
576 EXPECT_EQ(cVecOpResult.at(i).GetValue().GetTaggedValue().GetNumber(), std::numeric_limits<uint8_t>::min() + i);
577 }
578 cVecOpResult.clear();
579
580 OperationResult opResult1 = JSTypedArray::IntegerIndexedElementGet(thread, handleTagValUint8ClampedArray,
581 JSTaggedValue(-1));
582 OperationResult opResult2 = JSTypedArray::IntegerIndexedElementGet(thread, handleTagValUint8ClampedArray,
583 JSTaggedValue(-0.0));
584 OperationResult opResult3 = JSTypedArray::IntegerIndexedElementGet(thread, handleTagValUint8ClampedArray,
585 JSTaggedValue(1.1));
586 OperationResult opResult4 = JSTypedArray::IntegerIndexedElementGet(thread, handleTagValUint8ClampedArray,
587 JSTaggedValue(numElementsUint8ClampedArray));
588 EXPECT_EQ(opResult1.GetValue().GetTaggedValue(), JSTaggedValue::Undefined());
589 EXPECT_EQ(opResult2.GetValue().GetTaggedValue(), JSTaggedValue::Undefined());
590 EXPECT_EQ(opResult3.GetValue().GetTaggedValue(), JSTaggedValue::Undefined());
591 EXPECT_EQ(opResult4.GetValue().GetTaggedValue(), JSTaggedValue::Undefined());
592
593 EXPECT_FALSE(JSTypedArray::IntegerIndexedElementSet(thread, handleTagValUint8ClampedArray, JSTaggedValue(-1),
594 JSHandle<JSTaggedValue>(thread, JSTaggedValue(0))));
595 EXPECT_FALSE(JSTypedArray::IntegerIndexedElementSet(thread, handleTagValUint8ClampedArray,
596 JSTaggedValue(numElementsUint8ClampedArray), JSHandle<JSTaggedValue>(thread, JSTaggedValue(0))));
597 }
598
599 // Nonstandard input value for Uint8ClampedArray
HWTEST_F_L0(JSTypedArrayTest,IntegerIndexedElementSet_Uint8ClampedArray_002)600 HWTEST_F_L0(JSTypedArrayTest, IntegerIndexedElementSet_Uint8ClampedArray_002)
601 {
602 uint32_t numElementsUint8ClampedArray = 16;
603 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
604 JSHandle<JSTypedArray> handleUint8ClampedArray = CreateNumberTypedArray(thread, JSType::JS_UINT8_CLAMPED_ARRAY);
605 JSHandle<JSTaggedValue> handleTagValUint8ClampedArray = JSHandle<JSTaggedValue>::Cast(handleUint8ClampedArray);
606
607 uint32_t sizeElement = ecmascript::base::TypedArrayHelper::GetElementSize(
608 JSHandle<JSObject>::Cast(handleUint8ClampedArray));
609 uint32_t byteLengthViewdArrayBuffer = sizeElement * numElementsUint8ClampedArray;
610 JSHandle<JSTaggedValue> handleTagValArrayBufferFrom = JSHandle<JSTaggedValue>::Cast(
611 factory->NewJSArrayBuffer(byteLengthViewdArrayBuffer));
612 handleUint8ClampedArray->SetViewedArrayBuffer(thread, handleTagValArrayBufferFrom);
613 handleUint8ClampedArray->SetArrayLength(thread, JSTaggedValue(numElementsUint8ClampedArray));
614
615 int64_t value1 = -1; // to uint8_clamped : 0
616 int64_t value2 = 256; // to uint8_clamped : 255
617 double value3 = 13.4; // to uint8_clamped : 13
618 double value4 = 13.6; // to uint8_clamped : 14
619 JSHandle<JSTaggedValue> handleTagValValueSet1(thread, JSTaggedValue(value1));
620 JSHandle<JSTaggedValue> handleTagValValueSet2(thread, JSTaggedValue(value2));
621 JSHandle<JSTaggedValue> handleTagValValueSet3(thread, JSTaggedValue(value3));
622 JSHandle<JSTaggedValue> handleTagValValueSet4(thread, JSTaggedValue(value4));
623
624 EXPECT_TRUE(JSTypedArray::IntegerIndexedElementSet(thread, handleTagValUint8ClampedArray, JSTaggedValue(0),
625 handleTagValValueSet1));
626 OperationResult opResult1 = JSTypedArray::IntegerIndexedElementGet(thread, handleTagValUint8ClampedArray,
627 JSTaggedValue(0));
628 EXPECT_TRUE(JSTypedArray::IntegerIndexedElementSet(thread, handleTagValUint8ClampedArray, JSTaggedValue(0),
629 handleTagValValueSet2));
630 OperationResult opResult2 = JSTypedArray::IntegerIndexedElementGet(thread, handleTagValUint8ClampedArray,
631 JSTaggedValue(0));
632 EXPECT_TRUE(JSTypedArray::IntegerIndexedElementSet(thread, handleTagValUint8ClampedArray, JSTaggedValue(0),
633 handleTagValValueSet3));
634 OperationResult opResult3 = JSTypedArray::IntegerIndexedElementGet(thread, handleTagValUint8ClampedArray,
635 JSTaggedValue(0));
636 EXPECT_TRUE(JSTypedArray::IntegerIndexedElementSet(thread, handleTagValUint8ClampedArray, JSTaggedValue(0),
637 handleTagValValueSet4));
638 OperationResult opResult4 = JSTypedArray::IntegerIndexedElementGet(thread, handleTagValUint8ClampedArray,
639 JSTaggedValue(0));
640
641 EXPECT_NE(value1, opResult1.GetValue().GetTaggedValue().GetNumber());
642 EXPECT_NE(value2, opResult2.GetValue().GetTaggedValue().GetNumber());
643 EXPECT_NE(value3, opResult3.GetValue().GetTaggedValue().GetNumber());
644 EXPECT_NE(value4, opResult4.GetValue().GetTaggedValue().GetNumber());
645 EXPECT_EQ(0, opResult1.GetValue().GetTaggedValue().GetNumber());
646 EXPECT_EQ(255, opResult2.GetValue().GetTaggedValue().GetNumber());
647 EXPECT_EQ(13, opResult3.GetValue().GetTaggedValue().GetNumber());
648 EXPECT_EQ(14, opResult4.GetValue().GetTaggedValue().GetNumber());
649 }
650
HWTEST_F_L0(JSTypedArrayTest,IntegerIndexedElementSet_Int16Array_001)651 HWTEST_F_L0(JSTypedArrayTest, IntegerIndexedElementSet_Int16Array_001)
652 {
653 uint32_t numElementsInt16Array = 100;
654 int16_t scaleForInt16ValueSet = 100;
655 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
656 JSHandle<JSTypedArray> handleInt16Array = CreateNumberTypedArray(thread, JSType::JS_INT16_ARRAY);
657 JSHandle<JSTaggedValue> handleTagValInt16Array = JSHandle<JSTaggedValue>::Cast(handleInt16Array);
658
659 uint32_t sizeElement = ecmascript::base::TypedArrayHelper::GetElementSize(
660 JSHandle<JSObject>::Cast(handleInt16Array));
661 uint32_t byteLengthViewdArrayBuffer = sizeElement * numElementsInt16Array;
662 JSHandle<JSTaggedValue> handleTagValArrayBufferFrom = JSHandle<JSTaggedValue>::Cast(
663 factory->NewJSArrayBuffer(byteLengthViewdArrayBuffer));
664 handleInt16Array->SetViewedArrayBuffer(thread, handleTagValArrayBufferFrom);
665 handleInt16Array->SetArrayLength(thread, JSTaggedValue(numElementsInt16Array));
666
667 CVector<OperationResult> cVecOpResult = {};
668 for (int32_t i = 0; i < numElementsInt16Array; i++) {
669 EXPECT_TRUE(JSTypedArray::IntegerIndexedElementSet(thread, handleTagValInt16Array, JSTaggedValue(i),
670 JSHandle<JSTaggedValue>(thread,
671 JSTaggedValue(std::numeric_limits<int16_t>::min() + i * scaleForInt16ValueSet))));
672 OperationResult opResult = JSTypedArray::IntegerIndexedElementGet(thread, handleTagValInt16Array,
673 JSTaggedValue(i));
674 cVecOpResult.push_back(opResult);
675 }
676 for (int32_t i = 0; i < numElementsInt16Array; i++) {
677 EXPECT_EQ(cVecOpResult.at(i).GetValue().GetTaggedValue().GetNumber(),
678 std::numeric_limits<int16_t>::min() + i * scaleForInt16ValueSet);
679 }
680 cVecOpResult.clear();
681
682 OperationResult opResult1 = JSTypedArray::IntegerIndexedElementGet(thread, handleTagValInt16Array,
683 JSTaggedValue(-1));
684 OperationResult opResult2 = JSTypedArray::IntegerIndexedElementGet(thread, handleTagValInt16Array,
685 JSTaggedValue(-0.0));
686 OperationResult opResult3 = JSTypedArray::IntegerIndexedElementGet(thread, handleTagValInt16Array,
687 JSTaggedValue(1.1));
688 OperationResult opResult4 = JSTypedArray::IntegerIndexedElementGet(thread, handleTagValInt16Array,
689 JSTaggedValue(numElementsInt16Array));
690 EXPECT_EQ(opResult1.GetValue().GetTaggedValue(), JSTaggedValue::Undefined());
691 EXPECT_EQ(opResult2.GetValue().GetTaggedValue(), JSTaggedValue::Undefined());
692 EXPECT_EQ(opResult3.GetValue().GetTaggedValue(), JSTaggedValue::Undefined());
693 EXPECT_EQ(opResult4.GetValue().GetTaggedValue(), JSTaggedValue::Undefined());
694
695 EXPECT_FALSE(JSTypedArray::IntegerIndexedElementSet(thread, handleTagValInt16Array, JSTaggedValue(-1),
696 JSHandle<JSTaggedValue>(thread, JSTaggedValue(0))));
697 EXPECT_FALSE(JSTypedArray::IntegerIndexedElementSet(thread, handleTagValInt16Array,
698 JSTaggedValue(numElementsInt16Array), JSHandle<JSTaggedValue>(thread, JSTaggedValue(0))));
699 }
700
701 // Nonstandard input value for Int16Array
HWTEST_F_L0(JSTypedArrayTest,IntegerIndexedElementSet_Int16Array_002)702 HWTEST_F_L0(JSTypedArrayTest, IntegerIndexedElementSet_Int16Array_002)
703 {
704 uint32_t numElementsInt16Array = 16;
705 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
706 JSHandle<JSTypedArray> handleInt16Array = CreateNumberTypedArray(thread, JSType::JS_INT16_ARRAY);
707 JSHandle<JSTaggedValue> handleTagValInt16Array = JSHandle<JSTaggedValue>::Cast(handleInt16Array);
708
709 uint32_t sizeElement = ecmascript::base::TypedArrayHelper::GetElementSize(
710 JSHandle<JSObject>::Cast(handleInt16Array));
711 uint32_t byteLengthViewdArrayBuffer = sizeElement * numElementsInt16Array;
712 JSHandle<JSTaggedValue> handleTagValArrayBufferFrom = JSHandle<JSTaggedValue>::Cast(
713 factory->NewJSArrayBuffer(byteLengthViewdArrayBuffer));
714 handleInt16Array->SetViewedArrayBuffer(thread, handleTagValArrayBufferFrom);
715 handleInt16Array->SetArrayLength(thread, JSTaggedValue(numElementsInt16Array));
716
717 int64_t value1 = -32769; // to int16 : 32767
718 int64_t value2 = 32768; // to int16 : -32768
719 double value3 = 13.4; // to int16 : 13
720 double value4 = 13.6; // to int16 : 13
721 JSHandle<JSTaggedValue> handleTagValValueSet1(thread, JSTaggedValue(value1));
722 JSHandle<JSTaggedValue> handleTagValValueSet2(thread, JSTaggedValue(value2));
723 JSHandle<JSTaggedValue> handleTagValValueSet3(thread, JSTaggedValue(value3));
724 JSHandle<JSTaggedValue> handleTagValValueSet4(thread, JSTaggedValue(value4));
725
726 EXPECT_TRUE(JSTypedArray::IntegerIndexedElementSet(thread, handleTagValInt16Array, JSTaggedValue(0),
727 handleTagValValueSet1));
728 OperationResult opResult1 = JSTypedArray::IntegerIndexedElementGet(thread, handleTagValInt16Array,
729 JSTaggedValue(0));
730 EXPECT_TRUE(JSTypedArray::IntegerIndexedElementSet(thread, handleTagValInt16Array, JSTaggedValue(0),
731 handleTagValValueSet2));
732 OperationResult opResult2 = JSTypedArray::IntegerIndexedElementGet(thread, handleTagValInt16Array,
733 JSTaggedValue(0));
734 EXPECT_TRUE(JSTypedArray::IntegerIndexedElementSet(thread, handleTagValInt16Array, JSTaggedValue(0),
735 handleTagValValueSet3));
736 OperationResult opResult3 = JSTypedArray::IntegerIndexedElementGet(thread, handleTagValInt16Array,
737 JSTaggedValue(0));
738 EXPECT_TRUE(JSTypedArray::IntegerIndexedElementSet(thread, handleTagValInt16Array, JSTaggedValue(0),
739 handleTagValValueSet4));
740 OperationResult opResult4 = JSTypedArray::IntegerIndexedElementGet(thread, handleTagValInt16Array,
741 JSTaggedValue(0));
742
743 EXPECT_NE(value1, opResult1.GetValue().GetTaggedValue().GetNumber());
744 EXPECT_NE(value2, opResult2.GetValue().GetTaggedValue().GetNumber());
745 EXPECT_NE(value3, opResult3.GetValue().GetTaggedValue().GetNumber());
746 EXPECT_NE(value4, opResult4.GetValue().GetTaggedValue().GetNumber());
747 EXPECT_EQ(32767, opResult1.GetValue().GetTaggedValue().GetNumber());
748 EXPECT_EQ(-32768, opResult2.GetValue().GetTaggedValue().GetNumber());
749 EXPECT_EQ(13, opResult3.GetValue().GetTaggedValue().GetNumber());
750 EXPECT_EQ(13, opResult4.GetValue().GetTaggedValue().GetNumber());
751 }
752
HWTEST_F_L0(JSTypedArrayTest,IntegerIndexedElementSet_Uint16Array_001)753 HWTEST_F_L0(JSTypedArrayTest, IntegerIndexedElementSet_Uint16Array_001)
754 {
755 uint32_t numElementsUint16Array = 100;
756 uint32_t scaleForUint16ValueSet = 100;
757 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
758 JSHandle<JSTypedArray> handleUint16Array = CreateNumberTypedArray(thread, JSType::JS_UINT16_ARRAY);
759 JSHandle<JSTaggedValue> handleTagValUint16Array = JSHandle<JSTaggedValue>::Cast(handleUint16Array);
760
761 uint32_t sizeElement = ecmascript::base::TypedArrayHelper::GetElementSize(
762 JSHandle<JSObject>::Cast(handleUint16Array));
763 uint32_t byteLengthViewdArrayBuffer = sizeElement * numElementsUint16Array;
764 JSHandle<JSTaggedValue> handleTagValArrayBufferFrom = JSHandle<JSTaggedValue>::Cast(
765 factory->NewJSArrayBuffer(byteLengthViewdArrayBuffer));
766 handleUint16Array->SetViewedArrayBuffer(thread, handleTagValArrayBufferFrom);
767 handleUint16Array->SetArrayLength(thread, JSTaggedValue(numElementsUint16Array));
768
769 CVector<OperationResult> cVecOpResult = {};
770 for (uint32_t i = 0; i < numElementsUint16Array; i++) {
771 EXPECT_TRUE(JSTypedArray::IntegerIndexedElementSet(thread, handleTagValUint16Array, JSTaggedValue(i),
772 JSHandle<JSTaggedValue>(thread,
773 JSTaggedValue(std::numeric_limits<uint16_t>::min() + i * scaleForUint16ValueSet))));
774 OperationResult opResult = JSTypedArray::IntegerIndexedElementGet(thread, handleTagValUint16Array,
775 JSTaggedValue(i));
776 cVecOpResult.push_back(opResult);
777 }
778 for (uint32_t i = 0; i < numElementsUint16Array; i++) {
779 EXPECT_EQ(cVecOpResult.at(i).GetValue().GetTaggedValue().GetNumber(),
780 std::numeric_limits<uint16_t>::min() + i * scaleForUint16ValueSet);
781 }
782 cVecOpResult.clear();
783
784 OperationResult opResult1 = JSTypedArray::IntegerIndexedElementGet(thread, handleTagValUint16Array,
785 JSTaggedValue(-1));
786 OperationResult opResult2 = JSTypedArray::IntegerIndexedElementGet(thread, handleTagValUint16Array,
787 JSTaggedValue(-0.0));
788 OperationResult opResult3 = JSTypedArray::IntegerIndexedElementGet(thread, handleTagValUint16Array,
789 JSTaggedValue(1.1));
790 OperationResult opResult4 = JSTypedArray::IntegerIndexedElementGet(thread, handleTagValUint16Array,
791 JSTaggedValue(numElementsUint16Array));
792 EXPECT_EQ(opResult1.GetValue().GetTaggedValue(), JSTaggedValue::Undefined());
793 EXPECT_EQ(opResult2.GetValue().GetTaggedValue(), JSTaggedValue::Undefined());
794 EXPECT_EQ(opResult3.GetValue().GetTaggedValue(), JSTaggedValue::Undefined());
795 EXPECT_EQ(opResult4.GetValue().GetTaggedValue(), JSTaggedValue::Undefined());
796
797 EXPECT_FALSE(JSTypedArray::IntegerIndexedElementSet(thread, handleTagValUint16Array, JSTaggedValue(-1),
798 JSHandle<JSTaggedValue>(thread, JSTaggedValue(0))));
799 EXPECT_FALSE(JSTypedArray::IntegerIndexedElementSet(thread, handleTagValUint16Array,
800 JSTaggedValue(numElementsUint16Array), JSHandle<JSTaggedValue>(thread, JSTaggedValue(0))));
801 }
802
803 // Nonstandard input value for Uint16Array
HWTEST_F_L0(JSTypedArrayTest,IntegerIndexedElementSet_Uint16Array_002)804 HWTEST_F_L0(JSTypedArrayTest, IntegerIndexedElementSet_Uint16Array_002)
805 {
806 uint32_t numElementsUint16Array = 16;
807 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
808 JSHandle<JSTypedArray> handleUint16Array = CreateNumberTypedArray(thread, JSType::JS_UINT16_ARRAY);
809 JSHandle<JSTaggedValue> handleTagValUint16Array = JSHandle<JSTaggedValue>::Cast(handleUint16Array);
810
811 uint32_t sizeElement = ecmascript::base::TypedArrayHelper::GetElementSize(
812 JSHandle<JSObject>::Cast(handleUint16Array));
813 uint32_t byteLengthViewdArrayBuffer = sizeElement * numElementsUint16Array;
814 JSHandle<JSTaggedValue> handleTagValArrayBufferFrom = JSHandle<JSTaggedValue>::Cast(
815 factory->NewJSArrayBuffer(byteLengthViewdArrayBuffer));
816 handleUint16Array->SetViewedArrayBuffer(thread, handleTagValArrayBufferFrom);
817 handleUint16Array->SetArrayLength(thread, JSTaggedValue(numElementsUint16Array));
818
819 int64_t value1 = -1; // to uint16 : 65535
820 int64_t value2 = 65536; // to uint16 : 0
821 double value3 = 13.4; // to uint16 : 13
822 double value4 = 13.6; // to uint16 : 13
823 JSHandle<JSTaggedValue> handleTagValValueSet1(thread, JSTaggedValue(value1));
824 JSHandle<JSTaggedValue> handleTagValValueSet2(thread, JSTaggedValue(value2));
825 JSHandle<JSTaggedValue> handleTagValValueSet3(thread, JSTaggedValue(value3));
826 JSHandle<JSTaggedValue> handleTagValValueSet4(thread, JSTaggedValue(value4));
827
828 EXPECT_TRUE(JSTypedArray::IntegerIndexedElementSet(thread, handleTagValUint16Array, JSTaggedValue(0),
829 handleTagValValueSet1));
830 OperationResult opResult1 = JSTypedArray::IntegerIndexedElementGet(thread, handleTagValUint16Array,
831 JSTaggedValue(0));
832 EXPECT_TRUE(JSTypedArray::IntegerIndexedElementSet(thread, handleTagValUint16Array, JSTaggedValue(0),
833 handleTagValValueSet2));
834 OperationResult opResult2 = JSTypedArray::IntegerIndexedElementGet(thread, handleTagValUint16Array,
835 JSTaggedValue(0));
836 EXPECT_TRUE(JSTypedArray::IntegerIndexedElementSet(thread, handleTagValUint16Array, JSTaggedValue(0),
837 handleTagValValueSet3));
838 OperationResult opResult3 = JSTypedArray::IntegerIndexedElementGet(thread, handleTagValUint16Array,
839 JSTaggedValue(0));
840 EXPECT_TRUE(JSTypedArray::IntegerIndexedElementSet(thread, handleTagValUint16Array, JSTaggedValue(0),
841 handleTagValValueSet4));
842 OperationResult opResult4 = JSTypedArray::IntegerIndexedElementGet(thread, handleTagValUint16Array,
843 JSTaggedValue(0));
844
845 EXPECT_NE(value1, opResult1.GetValue().GetTaggedValue().GetNumber());
846 EXPECT_NE(value2, opResult2.GetValue().GetTaggedValue().GetNumber());
847 EXPECT_NE(value3, opResult3.GetValue().GetTaggedValue().GetNumber());
848 EXPECT_NE(value4, opResult4.GetValue().GetTaggedValue().GetNumber());
849 EXPECT_EQ(65535, opResult1.GetValue().GetTaggedValue().GetNumber());
850 EXPECT_EQ(0, opResult2.GetValue().GetTaggedValue().GetNumber());
851 EXPECT_EQ(13, opResult3.GetValue().GetTaggedValue().GetNumber());
852 EXPECT_EQ(13, opResult4.GetValue().GetTaggedValue().GetNumber());
853 }
854
HWTEST_F_L0(JSTypedArrayTest,IntegerIndexedElementSet_Int32Array_001)855 HWTEST_F_L0(JSTypedArrayTest, IntegerIndexedElementSet_Int32Array_001)
856 {
857 uint32_t numElementsInt32Array = 100;
858 int32_t scaleForInt32ValueSet = 100000;
859 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
860 JSHandle<JSTypedArray> handleInt32Array = CreateNumberTypedArray(thread, JSType::JS_INT32_ARRAY);
861 JSHandle<JSTaggedValue> handleTagValInt32Array = JSHandle<JSTaggedValue>::Cast(handleInt32Array);
862
863 uint32_t sizeElement = ecmascript::base::TypedArrayHelper::GetElementSize(
864 JSHandle<JSObject>::Cast(handleInt32Array));
865 uint32_t byteLengthViewdArrayBuffer = sizeElement * numElementsInt32Array;
866 JSHandle<JSTaggedValue> handleTagValArrayBufferFrom = JSHandle<JSTaggedValue>::Cast(
867 factory->NewJSArrayBuffer(byteLengthViewdArrayBuffer));
868 handleInt32Array->SetViewedArrayBuffer(thread, handleTagValArrayBufferFrom);
869 handleInt32Array->SetArrayLength(thread, JSTaggedValue(numElementsInt32Array));
870
871 CVector<OperationResult> cVecOpResult = {};
872 for (int32_t i = 0; i < numElementsInt32Array; i++) {
873 EXPECT_TRUE(JSTypedArray::IntegerIndexedElementSet(thread, handleTagValInt32Array, JSTaggedValue(i),
874 JSHandle<JSTaggedValue>(thread,
875 JSTaggedValue(std::numeric_limits<int32_t>::min() + i * scaleForInt32ValueSet))));
876 OperationResult opResult = JSTypedArray::IntegerIndexedElementGet(thread, handleTagValInt32Array,
877 JSTaggedValue(i));
878 cVecOpResult.push_back(opResult);
879 }
880 for (int32_t i = 0; i < numElementsInt32Array; i++) {
881 EXPECT_EQ(cVecOpResult.at(i).GetValue().GetTaggedValue().GetNumber(),
882 std::numeric_limits<int32_t>::min() + i * scaleForInt32ValueSet);
883 }
884 cVecOpResult.clear();
885
886 OperationResult opResult1 = JSTypedArray::IntegerIndexedElementGet(thread, handleTagValInt32Array,
887 JSTaggedValue(-1));
888 OperationResult opResult2 = JSTypedArray::IntegerIndexedElementGet(thread, handleTagValInt32Array,
889 JSTaggedValue(-0.0));
890 OperationResult opResult3 = JSTypedArray::IntegerIndexedElementGet(thread, handleTagValInt32Array,
891 JSTaggedValue(1.1));
892 OperationResult opResult4 = JSTypedArray::IntegerIndexedElementGet(thread, handleTagValInt32Array,
893 JSTaggedValue(numElementsInt32Array));
894 EXPECT_EQ(opResult1.GetValue().GetTaggedValue(), JSTaggedValue::Undefined());
895 EXPECT_EQ(opResult2.GetValue().GetTaggedValue(), JSTaggedValue::Undefined());
896 EXPECT_EQ(opResult3.GetValue().GetTaggedValue(), JSTaggedValue::Undefined());
897 EXPECT_EQ(opResult4.GetValue().GetTaggedValue(), JSTaggedValue::Undefined());
898
899 EXPECT_FALSE(JSTypedArray::IntegerIndexedElementSet(thread, handleTagValInt32Array, JSTaggedValue(-1),
900 JSHandle<JSTaggedValue>(thread, JSTaggedValue(0))));
901 EXPECT_FALSE(JSTypedArray::IntegerIndexedElementSet(thread, handleTagValInt32Array,
902 JSTaggedValue(numElementsInt32Array), JSHandle<JSTaggedValue>(thread, JSTaggedValue(0))));
903 }
904
905 // Nonstandard input value for Int32Array
HWTEST_F_L0(JSTypedArrayTest,IntegerIndexedElementSet_Int32Array_002)906 HWTEST_F_L0(JSTypedArrayTest, IntegerIndexedElementSet_Int32Array_002)
907 {
908 uint32_t numElementsInt32Array = 16;
909 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
910 JSHandle<JSTypedArray> handleInt32Array = CreateNumberTypedArray(thread, JSType::JS_INT32_ARRAY);
911 JSHandle<JSTaggedValue> handleTagValInt32Array = JSHandle<JSTaggedValue>::Cast(handleInt32Array);
912
913 uint32_t sizeElement = ecmascript::base::TypedArrayHelper::GetElementSize(
914 JSHandle<JSObject>::Cast(handleInt32Array));
915 uint32_t byteLengthViewdArrayBuffer = sizeElement * numElementsInt32Array;
916 JSHandle<JSTaggedValue> handleTagValArrayBufferFrom = JSHandle<JSTaggedValue>::Cast(
917 factory->NewJSArrayBuffer(byteLengthViewdArrayBuffer));
918 handleInt32Array->SetViewedArrayBuffer(thread, handleTagValArrayBufferFrom);
919 handleInt32Array->SetArrayLength(thread, JSTaggedValue(numElementsInt32Array));
920
921 int64_t value1 = -2147483649; // to int32 : 2147483647
922 int64_t value2 = 2147483648; // to int32 : -2147483648
923 double value3 = 13.4; // to int32 : 13
924 double value4 = 13.6; // to int32 : 13
925 JSHandle<JSTaggedValue> handleTagValValueSet1(thread, JSTaggedValue(value1));
926 JSHandle<JSTaggedValue> handleTagValValueSet2(thread, JSTaggedValue(value2));
927 JSHandle<JSTaggedValue> handleTagValValueSet3(thread, JSTaggedValue(value3));
928 JSHandle<JSTaggedValue> handleTagValValueSet4(thread, JSTaggedValue(value4));
929
930 EXPECT_TRUE(JSTypedArray::IntegerIndexedElementSet(thread, handleTagValInt32Array, JSTaggedValue(0),
931 handleTagValValueSet1));
932 OperationResult opResult1 = JSTypedArray::IntegerIndexedElementGet(thread, handleTagValInt32Array,
933 JSTaggedValue(0));
934 EXPECT_TRUE(JSTypedArray::IntegerIndexedElementSet(thread, handleTagValInt32Array, JSTaggedValue(0),
935 handleTagValValueSet2));
936 OperationResult opResult2 = JSTypedArray::IntegerIndexedElementGet(thread, handleTagValInt32Array,
937 JSTaggedValue(0));
938 EXPECT_TRUE(JSTypedArray::IntegerIndexedElementSet(thread, handleTagValInt32Array, JSTaggedValue(0),
939 handleTagValValueSet3));
940 OperationResult opResult3 = JSTypedArray::IntegerIndexedElementGet(thread, handleTagValInt32Array,
941 JSTaggedValue(0));
942 EXPECT_TRUE(JSTypedArray::IntegerIndexedElementSet(thread, handleTagValInt32Array, JSTaggedValue(0),
943 handleTagValValueSet4));
944 OperationResult opResult4 = JSTypedArray::IntegerIndexedElementGet(thread, handleTagValInt32Array,
945 JSTaggedValue(0));
946
947 EXPECT_NE(value1, opResult1.GetValue().GetTaggedValue().GetNumber());
948 EXPECT_NE(value2, opResult2.GetValue().GetTaggedValue().GetNumber());
949 EXPECT_NE(value3, opResult3.GetValue().GetTaggedValue().GetNumber());
950 EXPECT_NE(value4, opResult4.GetValue().GetTaggedValue().GetNumber());
951 EXPECT_EQ(2147483647, opResult1.GetValue().GetTaggedValue().GetNumber());
952 EXPECT_EQ(-2147483648, opResult2.GetValue().GetTaggedValue().GetNumber());
953 EXPECT_EQ(13, opResult3.GetValue().GetTaggedValue().GetNumber());
954 EXPECT_EQ(13, opResult4.GetValue().GetTaggedValue().GetNumber());
955 }
956
HWTEST_F_L0(JSTypedArrayTest,IntegerIndexedElementSet_Uint32Array_001)957 HWTEST_F_L0(JSTypedArrayTest, IntegerIndexedElementSet_Uint32Array_001)
958 {
959 uint32_t numElementsUint32Array = 100;
960 uint32_t scaleForUint32ValueSet = 100000;
961 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
962 JSHandle<JSTypedArray> handleUint32Array = CreateNumberTypedArray(thread, JSType::JS_UINT32_ARRAY);
963 JSHandle<JSTaggedValue> handleTagValUint32Array = JSHandle<JSTaggedValue>::Cast(handleUint32Array);
964
965 uint32_t sizeElement = ecmascript::base::TypedArrayHelper::GetElementSize(
966 JSHandle<JSObject>::Cast(handleUint32Array));
967 uint32_t byteLengthViewdArrayBuffer = sizeElement * numElementsUint32Array;
968 JSHandle<JSTaggedValue> handleTagValArrayBufferFrom = JSHandle<JSTaggedValue>::Cast(
969 factory->NewJSArrayBuffer(byteLengthViewdArrayBuffer));
970 handleUint32Array->SetViewedArrayBuffer(thread, handleTagValArrayBufferFrom);
971 handleUint32Array->SetArrayLength(thread, JSTaggedValue(numElementsUint32Array));
972
973 CVector<OperationResult> cVecOpResult = {};
974 for (uint32_t i = 0; i < numElementsUint32Array; i++) {
975 EXPECT_TRUE(JSTypedArray::IntegerIndexedElementSet(thread, handleTagValUint32Array, JSTaggedValue(i),
976 JSHandle<JSTaggedValue>(thread,
977 JSTaggedValue(std::numeric_limits<uint32_t>::min() + i * scaleForUint32ValueSet))));
978 OperationResult opResult = JSTypedArray::IntegerIndexedElementGet(thread, handleTagValUint32Array,
979 JSTaggedValue(i));
980 cVecOpResult.push_back(opResult);
981 }
982 for (uint32_t i = 0; i < numElementsUint32Array; i++) {
983 EXPECT_EQ(cVecOpResult.at(i).GetValue().GetTaggedValue().GetNumber(),
984 std::numeric_limits<uint32_t>::min() + i * scaleForUint32ValueSet);
985 }
986 cVecOpResult.clear();
987
988 OperationResult opResult1 = JSTypedArray::IntegerIndexedElementGet(thread, handleTagValUint32Array,
989 JSTaggedValue(-1));
990 OperationResult opResult2 = JSTypedArray::IntegerIndexedElementGet(thread, handleTagValUint32Array,
991 JSTaggedValue(-0.0));
992 OperationResult opResult3 = JSTypedArray::IntegerIndexedElementGet(thread, handleTagValUint32Array,
993 JSTaggedValue(1.1));
994 OperationResult opResult4 = JSTypedArray::IntegerIndexedElementGet(thread, handleTagValUint32Array,
995 JSTaggedValue(numElementsUint32Array));
996 EXPECT_EQ(opResult1.GetValue().GetTaggedValue(), JSTaggedValue::Undefined());
997 EXPECT_EQ(opResult2.GetValue().GetTaggedValue(), JSTaggedValue::Undefined());
998 EXPECT_EQ(opResult3.GetValue().GetTaggedValue(), JSTaggedValue::Undefined());
999 EXPECT_EQ(opResult4.GetValue().GetTaggedValue(), JSTaggedValue::Undefined());
1000
1001 EXPECT_FALSE(JSTypedArray::IntegerIndexedElementSet(thread, handleTagValUint32Array, JSTaggedValue(-1),
1002 JSHandle<JSTaggedValue>(thread, JSTaggedValue(0))));
1003 EXPECT_FALSE(JSTypedArray::IntegerIndexedElementSet(thread, handleTagValUint32Array,
1004 JSTaggedValue(numElementsUint32Array), JSHandle<JSTaggedValue>(thread, JSTaggedValue(0))));
1005 }
1006
1007 // Nonstandard input value for Uint32Array
HWTEST_F_L0(JSTypedArrayTest,IntegerIndexedElementSet_Uint32Array_002)1008 HWTEST_F_L0(JSTypedArrayTest, IntegerIndexedElementSet_Uint32Array_002)
1009 {
1010 int32_t numElementsUint32Array = 16;
1011 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
1012 JSHandle<JSTypedArray> handleUint32Array = CreateNumberTypedArray(thread, JSType::JS_UINT32_ARRAY);
1013 JSHandle<JSTaggedValue> handleTagValUint32Array = JSHandle<JSTaggedValue>::Cast(handleUint32Array);
1014
1015 uint32_t sizeElement = ecmascript::base::TypedArrayHelper::GetElementSize(
1016 JSHandle<JSObject>::Cast(handleUint32Array));
1017 int32_t byteLengthViewdArrayBuffer = sizeElement * numElementsUint32Array;
1018 JSHandle<JSTaggedValue> handleTagValArrayBufferFrom = JSHandle<JSTaggedValue>::Cast(
1019 factory->NewJSArrayBuffer(byteLengthViewdArrayBuffer));
1020 handleUint32Array->SetViewedArrayBuffer(thread, handleTagValArrayBufferFrom);
1021 handleUint32Array->SetArrayLength(thread, JSTaggedValue(numElementsUint32Array));
1022
1023 int64_t value1 = -1; // to uint32 : 4294967295
1024 int64_t value2 = 4294967296; // to uint32 : 0
1025 double value3 = 13.4; // to uint32 : 13
1026 double value4 = 13.6; // to uint32 : 13
1027 JSHandle<JSTaggedValue> handleTagValValueSet1(thread, JSTaggedValue(value1));
1028 JSHandle<JSTaggedValue> handleTagValValueSet2(thread, JSTaggedValue(value2));
1029 JSHandle<JSTaggedValue> handleTagValValueSet3(thread, JSTaggedValue(value3));
1030 JSHandle<JSTaggedValue> handleTagValValueSet4(thread, JSTaggedValue(value4));
1031
1032 EXPECT_TRUE(JSTypedArray::IntegerIndexedElementSet(thread, handleTagValUint32Array, JSTaggedValue(0),
1033 handleTagValValueSet1));
1034 OperationResult opResult1 = JSTypedArray::IntegerIndexedElementGet(thread, handleTagValUint32Array,
1035 JSTaggedValue(0));
1036 EXPECT_TRUE(JSTypedArray::IntegerIndexedElementSet(thread, handleTagValUint32Array, JSTaggedValue(0),
1037 handleTagValValueSet2));
1038 OperationResult opResult2 = JSTypedArray::IntegerIndexedElementGet(thread, handleTagValUint32Array,
1039 JSTaggedValue(0));
1040 EXPECT_TRUE(JSTypedArray::IntegerIndexedElementSet(thread, handleTagValUint32Array, JSTaggedValue(0),
1041 handleTagValValueSet3));
1042 OperationResult opResult3 = JSTypedArray::IntegerIndexedElementGet(thread, handleTagValUint32Array,
1043 JSTaggedValue(0));
1044 EXPECT_TRUE(JSTypedArray::IntegerIndexedElementSet(thread, handleTagValUint32Array, JSTaggedValue(0),
1045 handleTagValValueSet4));
1046 OperationResult opResult4 = JSTypedArray::IntegerIndexedElementGet(thread, handleTagValUint32Array,
1047 JSTaggedValue(0));
1048
1049 EXPECT_NE(value1, opResult1.GetValue().GetTaggedValue().GetNumber());
1050 EXPECT_NE(value2, opResult2.GetValue().GetTaggedValue().GetNumber());
1051 EXPECT_NE(value3, opResult3.GetValue().GetTaggedValue().GetNumber());
1052 EXPECT_NE(value4, opResult4.GetValue().GetTaggedValue().GetNumber());
1053 EXPECT_EQ(4294967295, opResult1.GetValue().GetTaggedValue().GetNumber());
1054 EXPECT_EQ(0, opResult2.GetValue().GetTaggedValue().GetNumber());
1055 EXPECT_EQ(13, opResult3.GetValue().GetTaggedValue().GetNumber());
1056 EXPECT_EQ(13, opResult4.GetValue().GetTaggedValue().GetNumber());
1057 }
1058
HWTEST_F_L0(JSTypedArrayTest,IntegerIndexedElementSet_Float32Array)1059 HWTEST_F_L0(JSTypedArrayTest, IntegerIndexedElementSet_Float32Array)
1060 {
1061 uint32_t numElementsFloat32Array = 100;
1062 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
1063 JSHandle<JSTypedArray> handleFloat32Array = CreateNumberTypedArray(thread, JSType::JS_FLOAT32_ARRAY);
1064 JSHandle<JSTaggedValue> handleTagValFloat32Array = JSHandle<JSTaggedValue>::Cast(handleFloat32Array);
1065
1066 uint32_t sizeElement = ecmascript::base::TypedArrayHelper::GetElementSize(
1067 JSHandle<JSObject>::Cast(handleFloat32Array));
1068 uint32_t byteLengthViewdArrayBuffer = sizeElement * numElementsFloat32Array;
1069 JSHandle<JSTaggedValue> handleTagValArrayBufferFrom = JSHandle<JSTaggedValue>::Cast(
1070 factory->NewJSArrayBuffer(byteLengthViewdArrayBuffer));
1071 handleFloat32Array->SetViewedArrayBuffer(thread, handleTagValArrayBufferFrom);
1072 handleFloat32Array->SetArrayLength(thread, JSTaggedValue(numElementsFloat32Array));
1073
1074 CVector<OperationResult> cVecOpResult = {};
1075 float floatMaxValue = std::numeric_limits<float>::max();
1076 for (uint32_t i = 0; i < numElementsFloat32Array; i++) {
1077 EXPECT_TRUE(JSTypedArray::IntegerIndexedElementSet(thread, handleTagValFloat32Array, JSTaggedValue(i),
1078 JSHandle<JSTaggedValue>(thread,
1079 JSTaggedValue(floatMaxValue - (i * (floatMaxValue / numElementsFloat32Array))))));
1080 OperationResult opResult = JSTypedArray::IntegerIndexedElementGet(thread, handleTagValFloat32Array,
1081 JSTaggedValue(i));
1082 cVecOpResult.push_back(opResult);
1083 }
1084 for (uint32_t i = 0; i < numElementsFloat32Array; i++) {
1085 EXPECT_EQ(cVecOpResult.at(i).GetValue().GetTaggedValue().GetNumber(),
1086 floatMaxValue - (i * (floatMaxValue / numElementsFloat32Array)));
1087 }
1088 cVecOpResult.clear();
1089
1090 OperationResult opResult1 = JSTypedArray::IntegerIndexedElementGet(thread, handleTagValFloat32Array,
1091 JSTaggedValue(-1));
1092 OperationResult opResult2 = JSTypedArray::IntegerIndexedElementGet(thread, handleTagValFloat32Array,
1093 JSTaggedValue(-0.0));
1094 OperationResult opResult3 = JSTypedArray::IntegerIndexedElementGet(thread, handleTagValFloat32Array,
1095 JSTaggedValue(1.1));
1096 OperationResult opResult4 = JSTypedArray::IntegerIndexedElementGet(thread, handleTagValFloat32Array,
1097 JSTaggedValue(numElementsFloat32Array));
1098 EXPECT_EQ(opResult1.GetValue().GetTaggedValue(), JSTaggedValue::Undefined());
1099 EXPECT_EQ(opResult2.GetValue().GetTaggedValue(), JSTaggedValue::Undefined());
1100 EXPECT_EQ(opResult3.GetValue().GetTaggedValue(), JSTaggedValue::Undefined());
1101 EXPECT_EQ(opResult4.GetValue().GetTaggedValue(), JSTaggedValue::Undefined());
1102
1103 EXPECT_FALSE(JSTypedArray::IntegerIndexedElementSet(thread, handleTagValFloat32Array, JSTaggedValue(-1),
1104 JSHandle<JSTaggedValue>(thread, JSTaggedValue(0))));
1105 EXPECT_FALSE(JSTypedArray::IntegerIndexedElementSet(thread, handleTagValFloat32Array,
1106 JSTaggedValue(numElementsFloat32Array), JSHandle<JSTaggedValue>(thread, JSTaggedValue(0))));
1107 }
1108
HWTEST_F_L0(JSTypedArrayTest,IntegerIndexedElementSet_Float64Array)1109 HWTEST_F_L0(JSTypedArrayTest, IntegerIndexedElementSet_Float64Array)
1110 {
1111 uint32_t numElementsFloat64Array = 100;
1112 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
1113 JSHandle<JSTypedArray> handleFloat64Array = CreateNumberTypedArray(thread, JSType::JS_FLOAT64_ARRAY);
1114 JSHandle<JSTaggedValue> handleTagValFloat64Array = JSHandle<JSTaggedValue>::Cast(handleFloat64Array);
1115
1116 uint32_t sizeElement = ecmascript::base::TypedArrayHelper::GetElementSize(
1117 JSHandle<JSObject>::Cast(handleFloat64Array));
1118 uint32_t byteLengthViewdArrayBuffer = sizeElement * numElementsFloat64Array;
1119 JSHandle<JSTaggedValue> handleTagValArrayBufferFrom = JSHandle<JSTaggedValue>::Cast(
1120 factory->NewJSArrayBuffer(byteLengthViewdArrayBuffer));
1121 handleFloat64Array->SetViewedArrayBuffer(thread, handleTagValArrayBufferFrom);
1122 handleFloat64Array->SetArrayLength(thread, JSTaggedValue(numElementsFloat64Array));
1123
1124 CVector<OperationResult> cVecOpResult = {};
1125 double doubleMaxValue = std::numeric_limits<double>::max();
1126 for (uint32_t i = 0; i < numElementsFloat64Array; i++) {
1127 EXPECT_TRUE(JSTypedArray::IntegerIndexedElementSet(thread, handleTagValFloat64Array, JSTaggedValue(i),
1128 JSHandle<JSTaggedValue>(thread, JSTaggedValue(
1129 doubleMaxValue - (i * (doubleMaxValue / numElementsFloat64Array))))));
1130 OperationResult opResult = JSTypedArray::IntegerIndexedElementGet(thread, handleTagValFloat64Array,
1131 JSTaggedValue(i));
1132 cVecOpResult.push_back(opResult);
1133 }
1134 for (uint32_t i = 0; i < numElementsFloat64Array; i++) {
1135 EXPECT_EQ(cVecOpResult.at(i).GetValue().GetTaggedValue().GetNumber(),
1136 doubleMaxValue - (i * (doubleMaxValue / numElementsFloat64Array)));
1137 }
1138 cVecOpResult.clear();
1139
1140 OperationResult opResult1 = JSTypedArray::IntegerIndexedElementGet(thread, handleTagValFloat64Array,
1141 JSTaggedValue(-1));
1142 OperationResult opResult2 = JSTypedArray::IntegerIndexedElementGet(thread, handleTagValFloat64Array,
1143 JSTaggedValue(-0.0));
1144 OperationResult opResult3 = JSTypedArray::IntegerIndexedElementGet(thread, handleTagValFloat64Array,
1145 JSTaggedValue(1.1));
1146 OperationResult opResult4 = JSTypedArray::IntegerIndexedElementGet(thread, handleTagValFloat64Array,
1147 JSTaggedValue(numElementsFloat64Array));
1148 EXPECT_EQ(opResult1.GetValue().GetTaggedValue(), JSTaggedValue::Undefined());
1149 EXPECT_EQ(opResult2.GetValue().GetTaggedValue(), JSTaggedValue::Undefined());
1150 EXPECT_EQ(opResult3.GetValue().GetTaggedValue(), JSTaggedValue::Undefined());
1151 EXPECT_EQ(opResult4.GetValue().GetTaggedValue(), JSTaggedValue::Undefined());
1152
1153 EXPECT_FALSE(JSTypedArray::IntegerIndexedElementSet(thread, handleTagValFloat64Array, JSTaggedValue(-1),
1154 JSHandle<JSTaggedValue>(thread, JSTaggedValue(0))));
1155 EXPECT_FALSE(JSTypedArray::IntegerIndexedElementSet(thread, handleTagValFloat64Array,
1156 JSTaggedValue(numElementsFloat64Array), JSHandle<JSTaggedValue>(thread, JSTaggedValue(0))));
1157 }
1158
1159 /*
1160 * Feature: JSTypedArray
1161 * Function: FastElementGet
1162 * SubFunction: IntegerIndexedElementSet
1163 * FunctionPoints: Get Element At Index(uint32_t) Of JSTypedArray
1164 * CaseDescription: Check whether the OperationResults returned through calling FastElementGet function from the
1165 * JSTypedArray changed through calling IntegerIndexedElementSet function are within expectations.
1166 */
HWTEST_F_L0(JSTypedArrayTest,FastElementGet_TypedArray)1167 HWTEST_F_L0(JSTypedArrayTest, FastElementGet_TypedArray)
1168 {
1169 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
1170
1171 for (uint32_t j = 0; j < cVecJSType.size(); j++) {
1172 uint32_t numElementsTypedArray = 10;
1173 JSHandle<JSTypedArray> handleTypedArray = CreateNumberTypedArray(thread, cVecJSType.at(j));
1174 JSHandle<JSTaggedValue> handleTagValTypedArray = JSHandle<JSTaggedValue>::Cast(handleTypedArray);
1175
1176 uint32_t sizeElement = ecmascript::base::TypedArrayHelper::GetElementSize(
1177 JSHandle<JSObject>::Cast(handleTypedArray));
1178 uint32_t byteLengthViewdArrayBuffer = sizeElement * numElementsTypedArray;
1179 JSHandle<JSTaggedValue> handleTagValArrayBufferFrom =
1180 JSHandle<JSTaggedValue>::Cast(factory->NewJSArrayBuffer(byteLengthViewdArrayBuffer));
1181 handleTypedArray->SetViewedArrayBuffer(thread, handleTagValArrayBufferFrom);
1182 handleTypedArray->SetArrayLength(thread, JSTaggedValue(numElementsTypedArray));
1183
1184 JSHandle<JSTaggedValue> handleTagValValueSet(thread, JSTaggedValue(cVecHandleTagValValueForTypedArray.at(j)));
1185 for (uint32_t i = 0; i < numElementsTypedArray; i++) {
1186 EXPECT_TRUE(JSTypedArray::IntegerIndexedElementSet(thread, handleTagValTypedArray, JSTaggedValue(i),
1187 handleTagValValueSet));
1188 }
1189 for (uint32_t i = 0; i < numElementsTypedArray; i++) {
1190 OperationResult opResult = JSTypedArray::FastElementGet(thread, handleTagValTypedArray, i);
1191 EXPECT_EQ(opResult.GetValue().GetTaggedValue().GetNumber(),
1192 handleTagValValueSet.GetTaggedValue().GetNumber());
1193 }
1194
1195 OperationResult opResult1 = JSTypedArray::FastElementGet(thread, handleTagValTypedArray, -1);
1196 OperationResult opResult2 = JSTypedArray::FastElementGet(thread, handleTagValTypedArray,
1197 numElementsTypedArray);
1198 EXPECT_EQ(opResult1.GetValue().GetTaggedValue(), JSTaggedValue::Undefined());
1199 EXPECT_EQ(opResult2.GetValue().GetTaggedValue(), JSTaggedValue::Undefined());
1200 }
1201 }
1202
1203 /*
1204 * Feature: JSTypedArray
1205 * Function: DefineOwnProperty
1206 * SubFunction: GetOwnProperty/HasProperty
1207 * PropertyDescriptor::HasWritable/HasEnumerable/HasConfigurable/IsWritable/IsEnumerable/IsConfigurable
1208 * FunctionPoints: Define Own Property For Element At Index(JSTaggedValue) Of JSTypedArray
1209 * CaseDescription: Call DefineOwnProperty function with a JSTypedArray, a index(JSTaggedValue) and a source
1210 * PropertyDescriptor, check whether the bool returned through calling HasProperty function with the
1211 * JSTypedArray and the index(JSTaggedValue) is within expectations, check whether the target
1212 * PropertyDescriptor changed through GetOwnProperty function is with expectations.
1213 */
HWTEST_F_L0(JSTypedArrayTest,DefineOwnProperty_TypedArray)1214 HWTEST_F_L0(JSTypedArrayTest, DefineOwnProperty_TypedArray)
1215 {
1216 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
1217
1218 for (int j = 0; j < cVecJSType.size(); j++) {
1219 int32_t numElementsTypedArray = 10;
1220 JSHandle<JSTaggedValue> handleTagValValueDef(thread, cVecHandleTagValValueForTypedArray.at(j));
1221 PropertyDescriptor descFrom1(thread, handleTagValValueDef, true, true, true);
1222 JSHandle<JSTypedArray> handleTypedArray = CreateNumberTypedArray(thread, cVecJSType.at(j));
1223 JSHandle<JSTaggedValue> handleTagValTypedArray = JSHandle<JSTaggedValue>::Cast(handleTypedArray);
1224
1225 uint32_t sizeElement = ecmascript::base::TypedArrayHelper::GetElementSize(
1226 JSHandle<JSObject>::Cast(handleTypedArray));
1227 int32_t byteLengthViewdArrayBuffer = sizeElement * numElementsTypedArray;
1228 JSHandle<JSTaggedValue> handleTagValArrayBufferFrom =
1229 JSHandle<JSTaggedValue>::Cast(factory->NewJSArrayBuffer(byteLengthViewdArrayBuffer));
1230 handleTypedArray->SetViewedArrayBuffer(thread, handleTagValArrayBufferFrom);
1231 handleTypedArray->SetArrayLength(thread, JSTaggedValue(numElementsTypedArray));
1232
1233 for (uint32_t i = 0; i < numElementsTypedArray; i++) {
1234 JSHandle<JSTaggedValue> handleTagValKey(thread, JSTaggedValue(i));
1235 EXPECT_FALSE(JSTypedArray::HasProperty(thread, handleTagValTypedArray, handleTagValKey));
1236 EXPECT_TRUE(JSTypedArray::DefineOwnProperty(thread, handleTagValTypedArray, handleTagValKey, descFrom1));
1237 EXPECT_TRUE(JSTypedArray::HasProperty(thread, handleTagValTypedArray, handleTagValKey));
1238 EXPECT_TRUE(JSTaggedValue::StrictEqual(thread, handleTagValValueDef,
1239 JSTypedArray::GetProperty(thread, handleTagValTypedArray, handleTagValKey).GetValue()));
1240
1241 PropertyDescriptor descTo1(thread);
1242 EXPECT_FALSE(descTo1.HasWritable() || descTo1.HasEnumerable() || descTo1.HasConfigurable());
1243 EXPECT_TRUE(JSTypedArray::GetOwnProperty(thread, handleTagValTypedArray, handleTagValKey, descTo1));
1244 EXPECT_TRUE(descTo1.HasWritable() && descTo1.HasEnumerable() && descTo1.HasConfigurable());
1245 EXPECT_TRUE(descTo1.IsWritable() && descTo1.IsEnumerable() && descTo1.IsConfigurable());
1246 EXPECT_TRUE(JSTaggedValue::StrictEqual(thread, descTo1.GetValue(), handleTagValValueDef));
1247 }
1248 }
1249 }
1250
1251 /*
1252 * Feature: JSTypedArray
1253 * Function: SetProperty
1254 * SubFunction: GetProperty/HasProperty
1255 * FunctionPoints: Set Property For Element At Index(JSTaggedValue) Of JSTypedArray
1256 * CaseDescription: Call SetProperty function with a JSTypedArray, a index(JSTaggedValue) and a source
1257 * value(JSTaggedValue), check whether the bool returned through calling HasProperty function with the
1258 * JSTypedArray and the index(JSTaggedValue) is within expectations, check whether the
1259 * value(JSTaggedValue) of the OperationResult returned through calling GetProperty function with the
1260 * JSTypedArray and the index(JSTaggedValue) is the same with the source value(JSTaggedValue).
1261 */
HWTEST_F_L0(JSTypedArrayTest,SetProperty_TypedArray)1262 HWTEST_F_L0(JSTypedArrayTest, SetProperty_TypedArray)
1263 {
1264 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
1265
1266 for (int j = 0; j < cVecJSType.size(); j++) {
1267 int32_t numElementsTypedArray = 10;
1268 JSHandle<JSTaggedValue> handleTagValValueSet(thread, cVecHandleTagValValueForTypedArray.at(j));
1269 JSHandle<JSTypedArray> handleTypedArray = CreateNumberTypedArray(thread, cVecJSType.at(j));
1270 JSHandle<JSTaggedValue> handleTagValTypedArray = JSHandle<JSTaggedValue>::Cast(handleTypedArray);
1271
1272 uint32_t sizeElement = ecmascript::base::TypedArrayHelper::GetElementSize(
1273 JSHandle<JSObject>::Cast(handleTypedArray));
1274 int32_t byteLengthViewdArrayBuffer = sizeElement * numElementsTypedArray;
1275 JSHandle<JSTaggedValue> handleTagValArrayBufferFrom =
1276 JSHandle<JSTaggedValue>::Cast(factory->NewJSArrayBuffer(byteLengthViewdArrayBuffer));
1277 handleTypedArray->SetViewedArrayBuffer(thread, handleTagValArrayBufferFrom);
1278 handleTypedArray->SetArrayLength(thread, JSTaggedValue(numElementsTypedArray));
1279
1280 for (uint32_t i = 0; i < numElementsTypedArray; i++) {
1281 JSHandle<JSTaggedValue> handleTagValKey(thread, JSTaggedValue(i));
1282 EXPECT_FALSE(JSTypedArray::HasProperty(thread, handleTagValTypedArray, handleTagValKey));
1283 EXPECT_TRUE(JSTypedArray::SetProperty(thread, handleTagValTypedArray, handleTagValKey,
1284 handleTagValValueSet));
1285 EXPECT_TRUE(JSTypedArray::HasProperty(thread, handleTagValTypedArray, handleTagValKey));
1286 EXPECT_TRUE(JSTaggedValue::StrictEqual(thread, handleTagValValueSet,
1287 JSTypedArray::GetProperty(thread, handleTagValTypedArray, handleTagValKey).GetValue()));
1288 }
1289 }
1290 }
1291
1292 /*
1293 * Feature: JSTypedArray
1294 * Function: FastCopyElementToArray
1295 * SubFunction: IntegerIndexedElementSet/TaggedArray::Get
1296 * FunctionPoints: Copy All Elements Of JSTypedArray To TaggedArray Fast
1297 * CaseDescription: Create a source JSTypedArray and a target TaggedArray, init the elements of the source JSTypedArray
1298 * with a certain value(JSTaggedValue) through calling IntegerIndexedElementSet function. Call
1299 * FastCopyElementToArray function with the source JSTypedArray and the target TaggedArray. Check
1300 * whether the values(JSTaggedValue) returned through Get(TaggedArray) function are the same with the
1301 * certain value(JSTaggedValue).
1302 */
HWTEST_F_L0(JSTypedArrayTest,FastCopyElementToArray_TypedArray)1303 HWTEST_F_L0(JSTypedArrayTest, FastCopyElementToArray_TypedArray)
1304 {
1305 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
1306
1307 for (int j = 0; j < cVecJSType.size(); j++) {
1308 int32_t numElementsTypedArray = 10;
1309 JSHandle<JSTaggedValue> handleTagValValueSet(thread, cVecHandleTagValValueForTypedArray.at(j));
1310 JSHandle<JSTypedArray> handleTypedArrayFrom =
1311 CreateNumberTypedArray(thread, cVecJSType.at(j));
1312 JSHandle<JSTaggedValue> handleTagValTypedArrayFrom = JSHandle<JSTaggedValue>::Cast(handleTypedArrayFrom);
1313
1314 uint32_t sizeElement = ecmascript::base::TypedArrayHelper::GetElementSize(
1315 JSHandle<JSObject>::Cast(handleTypedArrayFrom));
1316 int32_t byteLengthViewdArrayBuffer = sizeElement * numElementsTypedArray;
1317 JSHandle<JSTaggedValue> handleTagValArrayBuffer =
1318 JSHandle<JSTaggedValue>::Cast(factory->NewJSArrayBuffer(byteLengthViewdArrayBuffer));
1319 JSHandle<TaggedArray> handleTagArrTo = factory->NewTaggedArray(byteLengthViewdArrayBuffer);
1320 handleTypedArrayFrom->SetViewedArrayBuffer(thread, handleTagValArrayBuffer);
1321 handleTypedArrayFrom->SetArrayLength(thread, JSTaggedValue(numElementsTypedArray));
1322
1323 for (uint32_t i = 0; i < numElementsTypedArray; i++) {
1324 EXPECT_TRUE(JSTypedArray::IntegerIndexedElementSet(thread, handleTagValTypedArrayFrom, JSTaggedValue(i),
1325 handleTagValValueSet));
1326 }
1327 EXPECT_TRUE(JSTypedArray::FastCopyElementToArray(thread, handleTagValTypedArrayFrom, handleTagArrTo));
1328 for (uint32_t i = 0; i < numElementsTypedArray; i++) {
1329 EXPECT_EQ(handleTagArrTo->Get(i), handleTagValValueSet.GetTaggedValue());
1330 }
1331 }
1332 }
1333 } // namespace panda::test
1334