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