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