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