1 /*
2 * Copyright (c) 2024 SwanLink (Jiangsu) Technology Development 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 "napi/native_api.h"
17 #include "napi_arraytest.h"
18
19 const int DIFF_VALUE_FOUR = 4;
20 const int DIFF_VALUE_TWELVE = 12;
21
22 //OH_JSVM_CreateArrayWithLength Test
23 //lenth 0 + result nonnull
TestCreateArrayWithLength_01(JSVM_Env env,JSVM_CallbackInfo info)24 [[maybe_unused]] JSVM_Value TestCreateArrayWithLength_01(JSVM_Env env, JSVM_CallbackInfo info)
25 {
26 const size_t arrayLength = 0;
27 JSVM_Value value0 = nullptr;
28 JSVM_Status status = OH_JSVM_CreateArrayWithLength(env, arrayLength, &value0);
29 if (status != JSVM_OK) {
30 OH_JSVM_ThrowError(env, nullptr, "TestCreateArrayWithLength_01: CreateArrayWithLength Failed");
31 return nullptr;
32 }
33
34 bool setvalue = true;
35 JSVM_Value retvalue = nullptr;
36 OH_JSVM_GetBoolean(env, setvalue, &retvalue);
37 return retvalue;
38 }
39 //length 10 + result nonnull
TestCreateArrayWithLength_02(JSVM_Env env,JSVM_CallbackInfo info)40 [[maybe_unused]] JSVM_Value TestCreateArrayWithLength_02(JSVM_Env env, JSVM_CallbackInfo info)
41 {
42 const size_t arrayLength = 10;
43 JSVM_Value value1 = nullptr;
44 JSVM_Status status = OH_JSVM_CreateArrayWithLength(env, arrayLength, &value1);
45 if (status != JSVM_OK) {
46 OH_JSVM_ThrowError(env, nullptr, "TestCreateArrayWithLength_02: CreateArrayWithLength Failed");
47 return nullptr;
48 }
49
50 bool setValue = true;
51 JSVM_Value retValue = nullptr;
52 OH_JSVM_GetBoolean(env, setValue, &retValue);
53 return retValue;
54 }
55 //lenth JSVM_AUTO_LENGTH + result nonnull
TestCreateArrayWithLength_03(JSVM_Env env,JSVM_CallbackInfo info)56 [[maybe_unused]] JSVM_Value TestCreateArrayWithLength_03(JSVM_Env env, JSVM_CallbackInfo info)
57 {
58 JSVM_Value value2 = nullptr;
59 JSVM_Status status = OH_JSVM_CreateArrayWithLength(env, JSVM_AUTO_LENGTH, &value2);
60 if (status != JSVM_OK) {
61 OH_JSVM_ThrowError(env, nullptr, "TestCreateArrayWithLength_03: CreateArrayWithLength Failed");
62 return nullptr;
63 }
64
65 bool setValue = true;
66 JSVM_Value retValue = nullptr;
67 OH_JSVM_GetBoolean(env, setValue, &retValue);
68 return retValue;
69 }
70 //lenth 10 + result NULL
TestCreateArrayWithLength_04(JSVM_Env env,JSVM_CallbackInfo info)71 [[maybe_unused]] JSVM_Value TestCreateArrayWithLength_04(JSVM_Env env, JSVM_CallbackInfo info)
72 {
73 const size_t arrayLength = 10;
74
75 JSVM_Status status = OH_JSVM_CreateArrayWithLength(env, arrayLength, nullptr);
76 if (status != JSVM_INVALID_ARG) {
77 OH_JSVM_ThrowError(env, nullptr, "TestCreateArrayWithLength_04: CreateArrayWithLength Failed");
78 return nullptr;
79 }
80
81 bool setValue = true;
82 JSVM_Value retValue = nullptr;
83 OH_JSVM_GetBoolean(env, setValue, &retValue);
84 return retValue;
85 }
86 //OH_JSVM_GetArrayLength
87 //array object CreateArray + result nonnull
TestGetArrayLength_01(JSVM_Env env,JSVM_CallbackInfo info)88 [[maybe_unused]] JSVM_Value TestGetArrayLength_01(JSVM_Env env, JSVM_CallbackInfo info)
89 {
90 JSVM_Value ret;
91 OH_JSVM_CreateArray(env, &ret);
92 bool isArray = false;
93 OH_JSVM_IsArray(env, ret, &isArray);
94 if (!isArray) {
95 OH_JSVM_ThrowError(env, nullptr, "TestGetArrayLength_01: CreateArray Failed");
96 return nullptr;
97 }
98 uint32_t length;
99 JSVM_Status status = OH_JSVM_GetArrayLength(env, ret, &length);
100 if (status != JSVM_OK) {
101 OH_JSVM_ThrowError(env, nullptr, "TestGetArrayLength_01: GetArrayLength Failed");
102 return nullptr;
103 }
104
105 bool setValue = true;
106 JSVM_Value retValue = nullptr;
107 OH_JSVM_GetBoolean(env, setValue, &retValue);
108 return retValue;
109 }
110 //array object CreateArrayWithLength + result nonnull
TestGetArrayLength_02(JSVM_Env env,JSVM_CallbackInfo info)111 [[maybe_unused]] JSVM_Value TestGetArrayLength_02(JSVM_Env env, JSVM_CallbackInfo info)
112 {
113 const size_t arrayLength = 10;
114 JSVM_Value value = nullptr;
115 JSVM_Status status = OH_JSVM_CreateArrayWithLength(env, arrayLength, &value);
116 bool isArray = false;
117 OH_JSVM_IsArray(env, value, &isArray);
118 if (!isArray) {
119 OH_JSVM_ThrowError(env, nullptr, "TestGetArrayLength_02: CreateArrayWithLength Failed");
120 return nullptr;
121 }
122 uint32_t length;
123 status = OH_JSVM_GetArrayLength(env, value, &length);
124 if (status != JSVM_OK) {
125 OH_JSVM_ThrowError(env, nullptr, "TestGetArrayLength_02: GetArrayLength Failed");
126 return nullptr;
127 }
128
129 bool setValue = true;
130 JSVM_Value retValue = nullptr;
131 OH_JSVM_GetBoolean(env, setValue, &retValue);
132 return retValue;
133 }
134 //not array object + result nonnull
TestGetArrayLength_03(JSVM_Env env,JSVM_CallbackInfo info)135 [[maybe_unused]] JSVM_Value TestGetArrayLength_03(JSVM_Env env, JSVM_CallbackInfo info)
136 {
137 uint32_t length;
138 JSVM_Value object;
139 OH_JSVM_CreateObject(env, &object);
140 JSVM_Status status = OH_JSVM_GetArrayLength(env, object, &length);
141 if (status != JSVM_ARRAY_EXPECTED) {
142 OH_JSVM_ThrowError(env, nullptr, "TestGetArrayLength_03: GetArrayLength Failed");
143 return nullptr;
144 }
145
146 bool setValue = true;
147 JSVM_Value retValue = nullptr;
148 OH_JSVM_GetBoolean(env, setValue, &retValue);
149 return retValue;
150 }
151 //array object + result NULL
TestGetArrayLength_04(JSVM_Env env,JSVM_CallbackInfo info)152 [[maybe_unused]] JSVM_Value TestGetArrayLength_04(JSVM_Env env, JSVM_CallbackInfo info)
153 {
154 const size_t arrayLength = 4;
155 JSVM_Value testArray = nullptr;
156 JSVM_Status status = OH_JSVM_CreateArrayWithLength(env, arrayLength, &testArray);
157 if (status != JSVM_OK) {
158 OH_JSVM_ThrowError(env, nullptr, "TestGetArrayLength_04:OH_JSVM_CreateArrayWithLength Failed");
159 return nullptr;
160 }
161
162 status = OH_JSVM_GetArrayLength(env, testArray, nullptr);
163 if (status != JSVM_INVALID_ARG) {
164 OH_JSVM_ThrowError(env, nullptr, "TestGetArrayLength_04: GetArrayLength Failed");
165 return nullptr;
166 }
167
168 bool setValue = true;
169 JSVM_Value retValue = nullptr;
170 OH_JSVM_GetBoolean(env, setValue, &retValue);
171 return retValue;
172 }
173 //OH_JSVM_CreateTypedarray
174 //type INT8_ARRAY + length 0 + arraybuffer obj + "byteOffset + sizeof(type) * length <= sizeof(arraybuffer)" + nonnull
TestCreateTypedarray_01(JSVM_Env env,JSVM_CallbackInfo info)175 [[maybe_unused]] JSVM_Value TestCreateTypedarray_01(JSVM_Env env, JSVM_CallbackInfo info)
176 {
177 JSVM_Value arrayBuffer = nullptr;
178 void *arrayBufferPtr = nullptr;
179 const size_t arrayBufferSize = 16;
180 const size_t typedArrayLength = 0;
181 JSVM_Value value = nullptr;
182
183 JSVM_Status status = OH_JSVM_CreateArraybuffer(env, arrayBufferSize, &arrayBufferPtr, &arrayBuffer);
184 if (status != JSVM_OK) {
185 OH_JSVM_ThrowError(env, nullptr, "TestCreateTypedarray_01:OH_JSVM_Createarraybuffer Failed");
186 return nullptr;
187 }
188
189 status = OH_JSVM_CreateTypedarray(env,
190 JSVM_TypedarrayType::JSVM_INT8_ARRAY,
191 typedArrayLength,
192 arrayBuffer,
193 0,
194 &value);
195 if (status != JSVM_OK) {
196 OH_JSVM_ThrowError(env, nullptr, "TestCreateTypedarray_01:OH_JSVM_CreateTypedarray Failed");
197 return nullptr;
198 }
199
200 bool setValue = true;
201 JSVM_Value retValue = nullptr;
202 OH_JSVM_GetBoolean(env, setValue, &retValue);
203 return retValue;
204 }
205 //type UINT8_ARRAY + length not 0 + arrayBuffer obj + "byteOffset +
206 //sizeof(type) * length <= sizeof(arraybuffer)" + nonnull
TestCreateTypedarray_02(JSVM_Env env,JSVM_CallbackInfo info)207 [[maybe_unused]] JSVM_Value TestCreateTypedarray_02(JSVM_Env env, JSVM_CallbackInfo info)
208 {
209 JSVM_Value arrayBuffer = nullptr;
210 void *arrayBufferPtr = nullptr;
211 const size_t arrayBufferSize = 16;
212 const size_t typedArrayLength = 4;
213 JSVM_Value value = nullptr;
214
215 JSVM_Status status = OH_JSVM_CreateArraybuffer(env, arrayBufferSize, &arrayBufferPtr, &arrayBuffer);
216 if (status != JSVM_OK) {
217 OH_JSVM_ThrowError(env, nullptr, "TestCreateTypedarray_02:OH_JSVM_Createarraybuffer Failed");
218 return nullptr;
219 }
220
221 status = OH_JSVM_CreateTypedarray(env,
222 JSVM_TypedarrayType::JSVM_INT8_ARRAY,
223 typedArrayLength,
224 arrayBuffer,
225 typedArrayLength,
226 &value);
227 if (status != JSVM_OK) {
228 OH_JSVM_ThrowError(env, nullptr, "TestCreateTypedarray_02:OH_JSVM_CreateTypedarray Failed");
229 return nullptr;
230 }
231
232 bool setValue = true;
233 JSVM_Value retValue = nullptr;
234 OH_JSVM_GetBoolean(env, setValue, &retValue);
235 return retValue;
236 }
237 //type UINT8_CLAMPED_ARRAY + length not 0 + nullptr + "byteOffset +
238 //sizeof(type) * length <= sizeof(arraybuffer)" + nonnull
TestCreateTypedarray_03(JSVM_Env env,JSVM_CallbackInfo info)239 [[maybe_unused]] JSVM_Value TestCreateTypedarray_03(JSVM_Env env, JSVM_CallbackInfo info)
240 {
241 const size_t typedArrayLength = 4;
242 JSVM_Value value = nullptr;
243
244 JSVM_Status status = OH_JSVM_CreateTypedarray(env,
245 JSVM_TypedarrayType::JSVM_UINT8_CLAMPED_ARRAY,
246 typedArrayLength,
247 nullptr,
248 0,
249 &value);
250 if (status != JSVM_INVALID_ARG) {
251 OH_JSVM_ThrowError(env, nullptr, "TestCreateTypedarray_03:OH_JSVM_CreateTypedarray Failed");
252 return nullptr;
253 }
254
255 bool setValue = true;
256 JSVM_Value retValue = nullptr;
257 OH_JSVM_GetBoolean(env, setValue, &retValue);
258 return retValue;
259 }
260 //type INT16_ARRAY + length not 0 + other obj + "byteOffset + sizeof(type) * length <= sizeof(arraybuffer)" + nonnull
TestCreateTypedarray_04(JSVM_Env env,JSVM_CallbackInfo info)261 [[maybe_unused]] JSVM_Value TestCreateTypedarray_04(JSVM_Env env, JSVM_CallbackInfo info)
262 {
263 const size_t typedArrayLength = 4;
264 JSVM_Value value = nullptr;
265 JSVM_Value object;
266 OH_JSVM_CreateObject(env, &object);
267
268 JSVM_Status status = OH_JSVM_CreateTypedarray(env,
269 JSVM_TypedarrayType::JSVM_INT16_ARRAY,
270 typedArrayLength,
271 object,
272 0,
273 &value);
274 if (status != JSVM_INVALID_ARG) {
275 OH_JSVM_ThrowError(env, nullptr, "TestCreateTypedarray_04:OH_JSVM_CreateTypedarray Failed");
276 return nullptr;
277 }
278
279 bool setValue = true;
280 JSVM_Value retValue = nullptr;
281 OH_JSVM_GetBoolean(env, setValue, &retValue);
282 return retValue;
283 }
284 //type UINT16_ARRAY + length not 0 + arraybuffer obj +
285 //"byteOffset + sizeof(type) * length > sizeof(arraybuffer)" + nonnull
TestCreateTypedarray_05(JSVM_Env env,JSVM_CallbackInfo info)286 [[maybe_unused]] JSVM_Value TestCreateTypedarray_05(JSVM_Env env, JSVM_CallbackInfo info)
287 {
288 JSVM_Value arrayBuffer = nullptr;
289 void *arrayBufferPtr = nullptr;
290 const size_t arrayBufferSize = 16;
291 const size_t typedArrayLength = 2;
292 JSVM_Value value = nullptr;
293
294 JSVM_Status status = OH_JSVM_CreateArraybuffer(env, arrayBufferSize, &arrayBufferPtr, &arrayBuffer);
295 if (status != JSVM_OK) {
296 OH_JSVM_ThrowError(env, nullptr, "TestCreateTypedarray_05:OH_JSVM_Create array buffer Failed");
297 return nullptr;
298 }
299 status = OH_JSVM_CreateTypedarray(env,
300 JSVM_TypedarrayType::JSVM_UINT16_ARRAY,
301 typedArrayLength,
302 arrayBuffer,
303 arrayBufferSize,
304 &value);
305 if (status != JSVM_GENERIC_FAILURE) {
306 OH_JSVM_ThrowError(env, nullptr, "TestCreateTypedarray_05:OH_JSVM_Create type array buffer error.");
307 return nullptr;
308 }
309 JSVM_Value result = nullptr;
310 status = OH_JSVM_GetAndClearLastException(env, &result);
311
312 bool setValue = true;
313 JSVM_Value retValue = nullptr;
314 OH_JSVM_GetBoolean(env, setValue, &retValue);
315 return retValue;
316 }
317 //type INT32_ARRAY + length not 0 + arraybuffer obj +
318 //"byteOffset + sizeof(type) * length <= sizeof(arraybuffer)" + NULL
TestCreateTypedarray_06(JSVM_Env env,JSVM_CallbackInfo info)319 [[maybe_unused]] JSVM_Value TestCreateTypedarray_06(JSVM_Env env, JSVM_CallbackInfo info)
320 {
321 JSVM_Value arrayBuffer = nullptr;
322 void *arrayBufferPtr = nullptr;
323 const size_t arrayBufferSize = 16;
324 const size_t typedArrayLength = 2;
325
326 JSVM_Status status = OH_JSVM_CreateArraybuffer(env,
327 arrayBufferSize,
328 &arrayBufferPtr,
329 &arrayBuffer);
330 if (status != JSVM_OK) {
331 OH_JSVM_ThrowError(env, nullptr, "TestCreateTypedarray_06:OH_JSVM_Createarraybuffer Failed");
332 return nullptr;
333 }
334 status = OH_JSVM_CreateTypedarray(env,
335 JSVM_TypedarrayType::JSVM_INT32_ARRAY,
336 typedArrayLength,
337 arrayBuffer,
338 0,
339 nullptr);
340 if (status != JSVM_INVALID_ARG) {
341 OH_JSVM_ThrowError(env, nullptr, "TestCreateTypedarray_06:OH_JSVM_CreateTypedarray Failed");
342 return nullptr;
343 }
344
345 bool setValue = true;
346 JSVM_Value retValue = nullptr;
347 OH_JSVM_GetBoolean(env, setValue, &retValue);
348 return retValue;
349 }
350 //OH_JSVM_GetTypedarrayInfo
351 //typedarray obj
TestGetTypedarrayInfo_01(JSVM_Env env,JSVM_CallbackInfo info)352 [[maybe_unused]] JSVM_Value TestGetTypedarrayInfo_01(JSVM_Env env, JSVM_CallbackInfo info)
353 {
354 void *data;
355 JSVM_TypedarrayType type;
356 size_t byteOffset;
357 size_t length;
358 JSVM_Value arrayBuffer = nullptr;
359 void *arrayBufferPtr = nullptr;
360 const size_t arrayBufferSize = 16;
361 const size_t typedArrayLength = 4;
362 JSVM_Value _value;
363 JSVM_Status status = OH_JSVM_CreateArraybuffer(env, arrayBufferSize, &arrayBufferPtr, &arrayBuffer);
364 if (status != JSVM_OK) {
365 OH_JSVM_ThrowError(env, nullptr, "TestGetTypedarrayInfo_01:OH_JSVM_Createarraybuffer Failed");
366 return nullptr;
367 }
368
369 status = OH_JSVM_CreateTypedarray(env,
370 JSVM_TypedarrayType::JSVM_INT32_ARRAY,
371 typedArrayLength,
372 arrayBuffer,
373 0,
374 &_value);
375 if (status != JSVM_OK) {
376 OH_JSVM_ThrowError(env, nullptr, "TestGetTypedarrayInfo_01:OH_JSVM_GetTypedarrayInfo Failed");
377 return nullptr;
378 }
379
380 status = OH_JSVM_GetTypedarrayInfo(env, _value, &type, &length, &data, &arrayBuffer, &byteOffset);
381 if (status != JSVM_OK) {
382 OH_JSVM_ThrowError(env, nullptr, "TestGetTypedarrayInfo_01:OH_JSVM_GetTypedarrayInfo Failed");
383 return nullptr;
384 }
385
386 bool setValue = true;
387 JSVM_Value retValue = nullptr;
388 OH_JSVM_GetBoolean(env, setValue, &retValue);
389 return retValue;
390 }
391 //not typedarray obj
TestGetTypedarrayInfo_02(JSVM_Env env,JSVM_CallbackInfo info)392 [[maybe_unused]] JSVM_Value TestGetTypedarrayInfo_02(JSVM_Env env, JSVM_CallbackInfo info)
393 {
394 void *data;
395 JSVM_TypedarrayType type;
396 size_t byteOffset;
397 JSVM_Value arrayBuffer;
398 size_t length;
399 JSVM_Value object;
400 OH_JSVM_CreateObject(env, &object);
401
402 JSVM_Status status = OH_JSVM_GetTypedarrayInfo(env, object, &type, &length, &data, &arrayBuffer, &byteOffset);
403 if (status != JSVM_INVALID_ARG) {
404 OH_JSVM_ThrowError(env, nullptr, "testGetTypedarrayInfo_02:OH_JSVM_GetTypedarrayInfo Failed");
405 return nullptr;
406 }
407
408 bool setValue = true;
409 JSVM_Value retValue = nullptr;
410 OH_JSVM_GetBoolean(env, setValue, &retValue);
411 return retValue;
412 }
413 //OH_JSVM_CreateDataview
414 //length 0 + arraybuffer obj + "byteOffset + length <= sizeof(arraybuffer)" + nonnull
TestCreateDataview_01(JSVM_Env env,JSVM_CallbackInfo info)415 [[maybe_unused]] JSVM_Value TestCreateDataview_01(JSVM_Env env, JSVM_CallbackInfo info)
416 {
417 JSVM_Value arrayBuffer = nullptr;
418 void *arrayBufferPtr = nullptr;
419 const size_t arrayBufferSize = 16;
420 JSVM_Status status = OH_JSVM_CreateArraybuffer(env, arrayBufferSize, &arrayBufferPtr, &arrayBuffer);
421 if (status != JSVM_OK) {
422 OH_JSVM_ThrowError(env, nullptr, "TestCreateDataview_01:OH_JSVM_Createarraybuffer Failed");
423 return nullptr;
424 }
425
426 JSVM_Value result = nullptr;
427 status = OH_JSVM_CreateDataview(env, 0, arrayBuffer, 0, &result);
428 if (status != JSVM_OK) {
429 OH_JSVM_ThrowError(env, nullptr, "TestCreateDataview_01:OH_JSVM_CreateDataview Failed");
430 return nullptr;
431 }
432 bool isDataView = false;
433 OH_JSVM_IsDataview(env, result, &isDataView);
434 if (!isDataView) {
435 OH_JSVM_ThrowError(env, nullptr, "TestCreateDataview_01:OH_JSVM_CreateDataview isn't DataView Failed");
436 return nullptr;
437 }
438
439 bool setValue = true;
440 JSVM_Value retValue = nullptr;
441 OH_JSVM_GetBoolean(env, setValue, &retValue);
442 return retValue;
443 }
444 //length not 0 + array obj + "byteOffset + length <= sizeof(arraybuffer)" + nonnull
TestCreateDataview_02(JSVM_Env env,JSVM_CallbackInfo info)445 [[maybe_unused]] JSVM_Value TestCreateDataview_02(JSVM_Env env, JSVM_CallbackInfo info)
446 {
447 JSVM_Value arrayBuffer = nullptr;
448 void *arrayBufferPtr = nullptr;
449 const size_t arrayBufferSize = 16;
450 JSVM_Status status = OH_JSVM_CreateArraybuffer(env, arrayBufferSize, &arrayBufferPtr, &arrayBuffer);
451 if (arrayBuffer == nullptr) {
452 OH_JSVM_ThrowError(env, nullptr, "TestCreateDataview_02:OH_JSVM_Createarraybuffer Failed");
453 return nullptr;
454 }
455
456 JSVM_Value result = nullptr;
457 status = OH_JSVM_CreateDataview(env, arrayBufferSize, arrayBuffer, 0, &result);
458 if (status != JSVM_OK) {
459 OH_JSVM_ThrowError(env, nullptr, "TestCreateDataview_02:OH_JSVM_CreateDataview Failed");
460 return nullptr;
461 }
462
463 bool setValue = true;
464 JSVM_Value retValue = nullptr;
465 OH_JSVM_GetBoolean(env, setValue, &retValue);
466 return retValue;
467 }
468 // length not 0 + nullptr + "byteOffset + length <= sizeof(arraybuffer)" + nonnull
TestCreateDataview_03(JSVM_Env env,JSVM_CallbackInfo info)469 [[maybe_unused]] JSVM_Value TestCreateDataview_03(JSVM_Env env, JSVM_CallbackInfo info)
470 {
471 JSVM_Value arrayBuffer = nullptr;
472 void *arrayBufferPtr = nullptr;
473 const size_t arrayBufferSize = 16;
474 JSVM_Status status = OH_JSVM_CreateArraybuffer(env, arrayBufferSize, &arrayBufferPtr, &arrayBuffer);
475 if (status != JSVM_OK || arrayBuffer == nullptr) {
476 OH_JSVM_ThrowError(env, nullptr, "TestCreateDataview_03:OH_JSVM_Createarraybuffer Failed");
477 return nullptr;
478 }
479
480 JSVM_Value result = nullptr;
481 status = OH_JSVM_CreateDataview(env, arrayBufferSize, nullptr, 0, &result);
482 if (status != JSVM_INVALID_ARG) {
483 OH_JSVM_ThrowError(env, nullptr, "TestCreateDataview_03:OH_JSVM_CreateDataview Failed");
484 return nullptr;
485 }
486
487 bool setValue = true;
488 JSVM_Value retValue = nullptr;
489 OH_JSVM_GetBoolean(env, setValue, &retValue);
490 return retValue;
491 }
492 // length not 0 + other obj + "byteOffset + length <= sizeof(arraybuffer)" + nonnull
TestCreateDataview_04(JSVM_Env env,JSVM_CallbackInfo info)493 [[maybe_unused]] JSVM_Value TestCreateDataview_04(JSVM_Env env, JSVM_CallbackInfo info)
494 {
495 JSVM_Value arrayBuffer = nullptr;
496 void *arrayBufferPtr = nullptr;
497 const size_t arrayBufferSize = 16;
498 JSVM_Status status = OH_JSVM_CreateArraybuffer(env, arrayBufferSize, &arrayBufferPtr, &arrayBuffer);
499 if (status != JSVM_OK || arrayBuffer == nullptr) {
500 OH_JSVM_ThrowError(env, nullptr, "TestCreateDataview_04:OH_JSVM_Createarraybuffer Failed");
501 return nullptr;
502 }
503
504 JSVM_Value object;
505 OH_JSVM_CreateObject(env, &object);
506 JSVM_Value result = nullptr;
507 status = OH_JSVM_CreateDataview(env, arrayBufferSize, object, 0, &result);
508 if (status != JSVM_INVALID_ARG) {
509 OH_JSVM_ThrowError(env, nullptr, "TestCreateDataview_04:OH_JSVM_CreateDataview Failed");
510 return nullptr;
511 }
512
513 bool setValue = true;
514 JSVM_Value retValue = nullptr;
515 OH_JSVM_GetBoolean(env, setValue, &retValue);
516 return retValue;
517 }
518 //length not 0 + arraybuffer obj + "byteOffset + length > sizeof(arraybuffer)" + nonnull
TestCreateDataview_05(JSVM_Env env,JSVM_CallbackInfo info)519 [[maybe_unused]] JSVM_Value TestCreateDataview_05(JSVM_Env env, JSVM_CallbackInfo info)
520 {
521 JSVM_Value arrayBuffer = nullptr;
522 void *arrayBufferPtr = nullptr;
523 const size_t arrayBufferSize = 16;
524 JSVM_Status status = OH_JSVM_CreateArraybuffer(env, arrayBufferSize, &arrayBufferPtr, &arrayBuffer);
525 if (status != JSVM_OK || arrayBuffer == nullptr) {
526 OH_JSVM_ThrowError(env, nullptr, "TestCreateDataview_05:OH_JSVM_Createarraybuffer Failed");
527 return nullptr;
528 }
529
530 JSVM_Value result = nullptr;
531 status = OH_JSVM_CreateDataview(env, arrayBufferSize, arrayBuffer, arrayBufferSize, &result);
532 if (status != JSVM_PENDING_EXCEPTION) {
533 OH_JSVM_ThrowError(env, nullptr, "TestCreateDataview_05:OH_JSVM_CreateDataview Failed");
534 return nullptr;
535 }
536
537 JSVM_Value recvMsg = nullptr;
538 status = OH_JSVM_GetAndClearLastException(env, & recvMsg);
539
540 bool setValue = true;
541 JSVM_Value retValue = nullptr;
542 OH_JSVM_GetBoolean(env, setValue, &retValue);
543 return retValue;
544 }
545 // length not 0 + arraybuffer obj + "byteOffset + length <= sizeof(arraybuffer)" + NULL
TestCreateDataview_06(JSVM_Env env,JSVM_CallbackInfo info)546 [[maybe_unused]] JSVM_Value TestCreateDataview_06(JSVM_Env env, JSVM_CallbackInfo info)
547 {
548 JSVM_Value arrayBuffer = nullptr;
549 void *arrayBufferPtr = nullptr;
550 const size_t arrayBufferSize = 16;
551 JSVM_Status status = OH_JSVM_CreateArraybuffer(env, arrayBufferSize, &arrayBufferPtr, &arrayBuffer);
552 if (status != JSVM_OK || arrayBuffer == nullptr) {
553 OH_JSVM_ThrowError(env, nullptr, "TestCreateDataview_06:OH_JSVM_Createarraybuffer Failed");
554 return nullptr;
555 }
556
557 status = OH_JSVM_CreateDataview(env, arrayBufferSize, arrayBuffer, 0, nullptr);
558 if (status == JSVM_OK) {
559 OH_JSVM_ThrowError(env, nullptr, "TestCreateDataview_06:OH_JSVM_CreateDataview Failed");
560 return nullptr;
561 }
562
563 bool setValue = true;
564 JSVM_Value retValue = nullptr;
565 OH_JSVM_GetBoolean(env, setValue, &retValue);
566 return retValue;
567 }
568 //OH_JSVM_GetDataviewInfo
569 //dataview obj
TestGetDataview_01(JSVM_Env env,JSVM_CallbackInfo info)570 [[maybe_unused]] JSVM_Value TestGetDataview_01(JSVM_Env env, JSVM_CallbackInfo info)
571 {
572 JSVM_Value arrayBuffer = nullptr;
573 void *arrayBufferPtr = nullptr;
574 const size_t arrayBufferSize = 16;
575 JSVM_Status status = OH_JSVM_CreateArraybuffer(env, arrayBufferSize, &arrayBufferPtr, &arrayBuffer);
576 if (status != JSVM_OK) {
577 OH_JSVM_ThrowError(env, nullptr, "TestGetDataview_01:OH_JSVM_Createarraybuffer Failed");
578 return nullptr;
579 }
580
581 JSVM_Value result = nullptr;
582 status = OH_JSVM_CreateDataview(env, 0, arrayBuffer, 0, &result);
583 if (status != JSVM_OK) {
584 OH_JSVM_ThrowError(env, nullptr, "TestGetDataview_01:OH_JSVM_CreateDataview Failed");
585 return nullptr;
586 }
587 bool isDataView = false;
588 OH_JSVM_IsDataview(env, result, &isDataView);
589 if (!isDataView) {
590 OH_JSVM_ThrowError(env, nullptr, "TestGetDataview_01:OH_JSVM_CreateDataview isn't DataView Failed");
591 return nullptr;
592 }
593
594 JSVM_Value retArrayBuffer = nullptr;
595 void *data = nullptr;
596 size_t byteLength = 0;
597 size_t byteOffset = -1;
598 status = OH_JSVM_GetDataviewInfo(env, result, &byteLength, &data, &retArrayBuffer, &byteOffset);
599 if (status != JSVM_OK) {
600 OH_JSVM_ThrowError(env, nullptr, "TestGetDataview_01:OH_JSVM_CreateDataview GetDataviewInfo Failed");
601 return nullptr;
602 }
603
604 bool setValue = true;
605 JSVM_Value retValue = nullptr;
606 OH_JSVM_GetBoolean(env, setValue, &retValue);
607 return retValue;
608 }
609 //not dataview obj
TestGetDataview_02(JSVM_Env env,JSVM_CallbackInfo info)610 [[maybe_unused]] JSVM_Value TestGetDataview_02(JSVM_Env env, JSVM_CallbackInfo info)
611 {
612 JSVM_Value arrayBuffer = nullptr;
613 void *arrayBufferPtr = nullptr;
614 const size_t arrayBufferSize = 16;
615 JSVM_Status status = OH_JSVM_CreateArraybuffer(env, arrayBufferSize, &arrayBufferPtr, &arrayBuffer);
616 if (status != JSVM_OK) {
617 OH_JSVM_ThrowError(env, nullptr, "TestGetDataview_02:OH_JSVM_Createarraybuffer Failed");
618 return nullptr;
619 }
620
621 JSVM_Value retArrayBuffer = nullptr;
622 void *data = nullptr;
623 size_t byteLength = 0;
624 size_t byteOffset = 0;
625 status = OH_JSVM_GetDataviewInfo(env, arrayBuffer, &byteLength, &data, &retArrayBuffer, &byteOffset);
626 if (status == JSVM_OK) {
627 OH_JSVM_ThrowError(env, nullptr, "TestGetDataview_02:OH_JSVM_CreateDataview GetDataviewInfo abnormal");
628 return nullptr;
629 }
630
631 bool setValue = true;
632 JSVM_Value retValue = nullptr;
633 OH_JSVM_GetBoolean(env, setValue, &retValue);
634 return retValue;
635 }
636 //OH_JSVM_SetElement
637 //arraybuffer obj + index 0 + NULL
TestSetElement_01(JSVM_Env env,JSVM_CallbackInfo info)638 [[maybe_unused]] JSVM_Value TestSetElement_01(JSVM_Env env, JSVM_CallbackInfo info)
639 {
640 JSVM_Value arrayBuffer = nullptr;
641 void *arrayBufferPtr = nullptr;
642 const size_t arrayBufferSize = 4;
643 JSVM_Status status = OH_JSVM_CreateArraybuffer(env, arrayBufferSize, &arrayBufferPtr, &arrayBuffer);
644 if (status != JSVM_OK) {
645 OH_JSVM_ThrowError(env, nullptr, "TestSetElement_01:CreateArraybuffer Failed");
646 return nullptr;
647 }
648
649 status = OH_JSVM_SetElement(env, arrayBuffer, 0, nullptr);
650 if (status != JSVM_INVALID_ARG) {
651 OH_JSVM_ThrowError(env, nullptr, "TestSetElement_01:OH_JSVM_SetElement Failed");
652 return nullptr;
653 }
654
655 bool setValue = true;
656 JSVM_Value retValue = nullptr;
657 OH_JSVM_GetBoolean(env, setValue, &retValue);
658 return retValue;
659 }
660 //arraybuffer obj + index sizeof(obj) + nonnull
TestSetElement_02(JSVM_Env env,JSVM_CallbackInfo info)661 [[maybe_unused]] JSVM_Value TestSetElement_02(JSVM_Env env, JSVM_CallbackInfo info)
662 {
663 JSVM_Value testArray = nullptr;
664 void *arrayBufferPtr = nullptr;
665 const size_t arrayBufferSize = 4;
666 OH_JSVM_CreateArraybuffer(env, arrayBufferSize, &arrayBufferPtr, &testArray);
667 JSVM_Value name1 = nullptr;
668 JSVM_Status status = OH_JSVM_SetElement(env, testArray, arrayBufferSize, name1);
669 if (status != JSVM_INVALID_ARG) {
670 OH_JSVM_ThrowError(env, nullptr, "TestSetElement_02:OH_JSVM_SetElement Failed");
671 return nullptr;
672 }
673
674 bool setValue = true;
675 JSVM_Value retValue = nullptr;
676 OH_JSVM_GetBoolean(env, setValue, &retValue);
677 return retValue;
678 }
679 //typedarray obj + index sizeof(obj) +1 + nonnull
TestSetElement_03(JSVM_Env env,JSVM_CallbackInfo info)680 [[maybe_unused]] JSVM_Value TestSetElement_03(JSVM_Env env, JSVM_CallbackInfo info)
681 {
682 JSVM_Value arrayBuffer = nullptr;
683 void *arrayBufferPtr = nullptr;
684 const size_t arrayBufferSize = 1;
685 const size_t typedArrayLength = 0;
686 JSVM_Value _value;
687 JSVM_Status status = OH_JSVM_CreateArraybuffer(env, arrayBufferSize, &arrayBufferPtr, &arrayBuffer);
688 if (status != JSVM_OK) {
689 OH_JSVM_ThrowError(env, nullptr, "TestSetElement_03:OH_JSVM_CreateTypedarray Failed");
690 return nullptr;
691 }
692
693 JSVM_Value index1 = nullptr;
694 OH_JSVM_CreateUint32(env, 1, &index1);
695 status = OH_JSVM_CreateTypedarray(env,
696 JSVM_TypedarrayType::JSVM_UINT32_ARRAY,
697 typedArrayLength,
698 arrayBuffer,
699 0,
700 &_value);
701 if (status != JSVM_OK) {
702 OH_JSVM_ThrowError(env, nullptr, "TestSetElement_03:OH_JSVM_CreateTypedarray Failed");
703 return nullptr;
704 }
705 status = OH_JSVM_SetElement(env, _value, arrayBufferSize+1, index1);
706 if (status != JSVM_OK) {
707 OH_JSVM_ThrowError(env, nullptr, "TestSetElement_03:OH_JSVM_SetElement 1 Failed");
708 return nullptr;
709 }
710
711 bool setValue = true;
712 JSVM_Value retValue = nullptr;
713 OH_JSVM_GetBoolean(env, setValue, &retValue);
714 return retValue;
715 }
716 //typedarray obj + index 0 + NULL
TestSetElement_04(JSVM_Env env,JSVM_CallbackInfo info)717 [[maybe_unused]] JSVM_Value TestSetElement_04(JSVM_Env env, JSVM_CallbackInfo info)
718 {
719 JSVM_Value testArray = nullptr;
720 const size_t typedArrayLength = 2;
721 OH_JSVM_CreateArrayWithLength(env, typedArrayLength, &testArray);
722 char newStr1[] = "hahaha";
723 JSVM_Value name1 = nullptr;
724 OH_JSVM_CreateStringUtf8(env, newStr1, strlen(newStr1), &name1);
725 JSVM_Status status = OH_JSVM_SetElement(env, testArray, 0, nullptr);
726 if (status != JSVM_INVALID_ARG) {
727 OH_JSVM_ThrowError(env, nullptr, "TestSetElement_04:OH_JSVM_SetElement Failed");
728 return nullptr;
729 }
730
731 bool setValue = true;
732 JSVM_Value retValue = nullptr;
733 OH_JSVM_GetBoolean(env, setValue, &retValue);
734 return retValue;
735 }
736 //dataview obj + index sizeof(obj) + nonnull
TestSetElement_05(JSVM_Env env,JSVM_CallbackInfo info)737 [[maybe_unused]] JSVM_Value TestSetElement_05(JSVM_Env env, JSVM_CallbackInfo info)
738 {
739 size_t argc = 2;
740 JSVM_Value args[2] = {nullptr};
741 JSVM_Value arraybuffer = nullptr;
742 JSVM_Value result = nullptr;
743 OH_JSVM_GetCbInfo(env, info, &argc, args, nullptr, nullptr);
744 OH_JSVM_CoerceToObject(env, args[0], &arraybuffer);
745 OH_JSVM_CreateDataview(env, DIFF_VALUE_TWELVE, arraybuffer, DIFF_VALUE_FOUR, &result);
746 JSVM_Value name = nullptr;
747 JSVM_Status status = OH_JSVM_SetElement(env, result, sizeof(result), name);
748 if (status != JSVM_PENDING_EXCEPTION) {
749 OH_JSVM_ThrowError(env, nullptr, "TestSetElement_05:OH_JSVM_SetElement Failed");
750 return nullptr;
751 }
752 JSVM_Value recvMsg = nullptr;
753 OH_JSVM_GetAndClearLastException(env, &recvMsg);
754
755 bool setValue = true;
756 JSVM_Value retValue = nullptr;
757 OH_JSVM_GetBoolean(env, setValue, &retValue);
758 return retValue;
759 }
760 //not array obj + index 0 + nonnull
TestSetElement_06(JSVM_Env env,JSVM_CallbackInfo info)761 [[maybe_unused]] JSVM_Value TestSetElement_06(JSVM_Env env, JSVM_CallbackInfo info)
762 {
763 JSVM_Value name = nullptr;
764 JSVM_Value object;
765 OH_JSVM_CreateObject(env, &object);
766 JSVM_Status status = OH_JSVM_SetElement(env, object, 0, name);
767 if (status != JSVM_INVALID_ARG) {
768 OH_JSVM_ThrowError(env, nullptr, "TestSetElement_06:OH_JSVM_SetElement index 0 Failed");
769 return nullptr;
770 }
771
772 bool setValue = true;
773 JSVM_Value retValue = nullptr;
774 OH_JSVM_GetBoolean(env, setValue, &retValue);
775 return retValue;
776 }
777 //not array obj + index 1 + nonnull
TestSetElement_07(JSVM_Env env,JSVM_CallbackInfo info)778 [[maybe_unused]] JSVM_Value TestSetElement_07(JSVM_Env env, JSVM_CallbackInfo info)
779 {
780 JSVM_Value name = nullptr;
781 const char newStr[] = "test";
782 OH_JSVM_CreateStringUtf8(env, newStr, strlen(newStr), &name);
783 JSVM_Value object;
784 OH_JSVM_CreateObject(env, &object);
785 JSVM_Status status = OH_JSVM_SetElement(env, object, 1, name);
786 if (status != JSVM_OK) {
787 OH_JSVM_ThrowError(env, nullptr, "TestSetElement_07:OH_JSVM_SetElement index 1 Failed");
788 return nullptr;
789 }
790
791 bool setValue = true;
792 JSVM_Value retValue = nullptr;
793 OH_JSVM_GetBoolean(env, setValue, &retValue);
794 return retValue;
795 }
796 //OH_JSVM_GetElement
797 //arraybuffer obj + set index + nonnull
TestGetElement_01(JSVM_Env env,JSVM_CallbackInfo info)798 [[maybe_unused]] JSVM_Value TestGetElement_01(JSVM_Env env, JSVM_CallbackInfo info)
799 {
800 JSVM_Value testArray = nullptr;
801 void *arrayBufferPtr = nullptr;
802 const size_t arrayBufferSize = 4;
803 OH_JSVM_CreateArraybuffer(env, arrayBufferSize, &arrayBufferPtr, &testArray);
804 JSVM_Value name = nullptr;
805 OH_JSVM_SetElement(env, testArray, arrayBufferSize, name);
806 JSVM_Value result = nullptr;
807 JSVM_Status status = OH_JSVM_GetElement(env, testArray, sizeof(testArray), &result);
808 if (status != JSVM_OK) {
809 OH_JSVM_ThrowError(env, nullptr, "TestGetElement_01:OH_JSVM_GetElement 0 Failed");
810 return nullptr;
811 }
812
813 bool setValue = true;
814 JSVM_Value retValue = nullptr;
815 OH_JSVM_GetBoolean(env, setValue, &retValue);
816 return retValue;
817 }
818 //arraybuffer obj + set index + NULL
TestGetElement_02(JSVM_Env env,JSVM_CallbackInfo info)819 [[maybe_unused]] JSVM_Value TestGetElement_02(JSVM_Env env, JSVM_CallbackInfo info)
820 {
821 JSVM_Value arrayBuffer = nullptr;
822 void *arrayBufferPtr = nullptr;
823 const size_t arrayBufferSize = 4;
824 JSVM_Status status = OH_JSVM_CreateArraybuffer(env, arrayBufferSize, &arrayBufferPtr, &arrayBuffer);
825 if (status != JSVM_OK) {
826 OH_JSVM_ThrowError(env, nullptr, "TestGetElement_02:CreateArraybuffer Failed");
827 return nullptr;
828 }
829
830 status = OH_JSVM_SetElement(env, arrayBuffer, 0, nullptr);
831 if (status != JSVM_INVALID_ARG) {
832 OH_JSVM_ThrowError(env, nullptr, "TestGetElement_02:OH_JSVM_SetElement Failed");
833 return nullptr;
834 }
835
836 JSVM_Value propName = nullptr;
837 status = OH_JSVM_GetElement(env, arrayBuffer, sizeof(arrayBuffer), &propName);
838 if (status != JSVM_OK) {
839 OH_JSVM_ThrowError(env, nullptr, "TestGetElement_02:OH_JSVM_GetElement 1 Failed");
840 return nullptr;
841 }
842
843 bool setValue = true;
844 JSVM_Value retValue = nullptr;
845 OH_JSVM_GetBoolean(env, setValue, &retValue);
846 return retValue;
847 }
848 //typedarray obj + set index + nonnull
TestGetElement_03(JSVM_Env env,JSVM_CallbackInfo info)849 [[maybe_unused]] JSVM_Value TestGetElement_03(JSVM_Env env, JSVM_CallbackInfo info)
850 {
851 JSVM_Value testArray = nullptr;
852 const size_t arrayLen = 2;
853 OH_JSVM_CreateArrayWithLength(env, arrayLen, &testArray);
854 JSVM_Value name = nullptr;
855 char newStr1[] = "test";
856 OH_JSVM_CreateStringUtf8(env, newStr1, strlen(newStr1), &name);
857 OH_JSVM_SetElement(env, testArray, arrayLen, name);
858
859 JSVM_Value result = nullptr;
860 JSVM_Status status = OH_JSVM_GetElement(env, testArray, sizeof(testArray), &result);
861 if (status != JSVM_OK) {
862 OH_JSVM_ThrowError(env, nullptr, "TestGetElement_03:OH_JSVM_GetElement Failed");
863 return nullptr;
864 }
865
866 bool setValue = true;
867 JSVM_Value retValue = nullptr;
868 OH_JSVM_GetBoolean(env, setValue, &retValue);
869 return retValue;
870 }
871 //dataview obj + set index + nonnull
TestGetElement_04(JSVM_Env env,JSVM_CallbackInfo info)872 [[maybe_unused]] JSVM_Value TestGetElement_04(JSVM_Env env, JSVM_CallbackInfo info)
873 {
874 size_t argc = 2;
875 JSVM_Value args[2] = {nullptr};
876 JSVM_Value arrayBuffer = nullptr;
877 JSVM_Value result = nullptr;
878 OH_JSVM_GetCbInfo(env, info, &argc, args, nullptr, nullptr);
879 OH_JSVM_CoerceToObject(env, args[0], &arrayBuffer);
880 OH_JSVM_CreateDataview(env, DIFF_VALUE_TWELVE, arrayBuffer, DIFF_VALUE_FOUR, &result);
881 JSVM_Value value = nullptr;
882 JSVM_Status status = OH_JSVM_SetElement(env, result, sizeof(result), value);
883 if (status != JSVM_PENDING_EXCEPTION) {
884 OH_JSVM_ThrowError(env, nullptr, "TestGetElement_04:OH_JSVM_SetElement 0 Failed");
885 return nullptr;
886 }
887
888 JSVM_Value recvMsg = nullptr;
889 OH_JSVM_GetAndClearLastException(env, &recvMsg);
890
891 JSVM_Value rst = nullptr;
892 status = OH_JSVM_GetElement(env, result, sizeof(result), &rst);
893 if (status != JSVM_INVALID_ARG) {
894 OH_JSVM_ThrowError(env, nullptr, "testSetElement_04:OH_JSVM_GetElement 1 Failed");
895 return nullptr;
896 }
897
898 bool setValue = true;
899 JSVM_Value retValue = nullptr;
900 OH_JSVM_GetBoolean(env, setValue, &retValue);
901 return retValue;
902 }
903 //not array obj + set index + nonnull
TestGetElement_05(JSVM_Env env,JSVM_CallbackInfo info)904 [[maybe_unused]] JSVM_Value TestGetElement_05(JSVM_Env env, JSVM_CallbackInfo info)
905 {
906 JSVM_Value name = nullptr;
907 char newStr[] = "test";
908 OH_JSVM_CreateStringUtf8(env, newStr, strlen(newStr), &name);
909 JSVM_Value object;
910 OH_JSVM_CreateObject(env, &object);
911 JSVM_Status status = OH_JSVM_SetElement(env, object, 0, name);
912 if (status != JSVM_OK) {
913 OH_JSVM_ThrowError(env, nullptr, "TestGetElement_05:OH_JSVM_SetElement index 0 Failed");
914 return nullptr;
915 }
916
917 JSVM_Value result = nullptr;
918 status = OH_JSVM_GetElement(env, object, 1, &result);
919 if (status != JSVM_OK) {
920 OH_JSVM_ThrowError(env, nullptr, "TestGetElement_05:OH_JSVM_GetElement Failed");
921 return nullptr;
922 }
923
924 bool setValue = true;
925 JSVM_Value retValue = nullptr;
926 OH_JSVM_GetBoolean(env, setValue, &retValue);
927 return retValue;
928 }
929 //arraybuffer obj + set index + nonnull
TestGetElement_06(JSVM_Env env,JSVM_CallbackInfo info)930 [[maybe_unused]] JSVM_Value TestGetElement_06(JSVM_Env env, JSVM_CallbackInfo info)
931 {
932 JSVM_Value testArray = nullptr;
933 void *arrayBufferPtr = nullptr;
934 const size_t arrayBufferSize = 4;
935 OH_JSVM_CreateArraybuffer(env, arrayBufferSize, &arrayBufferPtr, &testArray);
936
937 JSVM_Value result = nullptr;
938 JSVM_Status status = OH_JSVM_GetElement(env, testArray, sizeof(testArray), &result);
939 if (status != JSVM_OK) {
940 OH_JSVM_ThrowError(env, nullptr, "TestGetElement_06:OH_JSVM_GetElement Failed");
941 return nullptr;
942 }
943
944 bool setValue = true;
945 JSVM_Value retValue = nullptr;
946 OH_JSVM_GetBoolean(env, setValue, &retValue);
947 return retValue;
948 }
949 //OH_JSVM_HasElement
950 //arraybuffer obj + set index + nonnull
TestHasElement_01(JSVM_Env env,JSVM_CallbackInfo info)951 [[maybe_unused]] JSVM_Value TestHasElement_01(JSVM_Env env, JSVM_CallbackInfo info)
952 {
953 JSVM_Value testArray = nullptr;
954 void *arrayBufferPtr = nullptr;
955 const size_t arrayBufferSize = 4;
956 size_t eleIndex = 2;
957 OH_JSVM_CreateArraybuffer(env, arrayBufferSize, &arrayBufferPtr, &testArray);
958 for (uint32_t i = 0; i < arrayBufferSize; i++) {
959 JSVM_Value element;
960 OH_JSVM_CreateUint32(env, i * eleIndex, &element);
961 OH_JSVM_SetElement(env, testArray, i, element);
962 }
963
964 bool hasElement = false;
965 JSVM_Status status = OH_JSVM_HasElement(env, testArray, 0, &hasElement);
966
967 if (!hasElement) {
968 OH_JSVM_ThrowError(env, nullptr, "TestHasElement_01:OH_JSVM_HasElement Failed");
969 return nullptr;
970 }
971
972 bool setValue = true;
973 JSVM_Value retValue = nullptr;
974 OH_JSVM_GetBoolean(env, setValue, &retValue);
975 return retValue;
976 }
977 //typedarray obj + set index + nonnull
TestHasElement_02(JSVM_Env env,JSVM_CallbackInfo info)978 [[maybe_unused]] JSVM_Value TestHasElement_02(JSVM_Env env, JSVM_CallbackInfo info)
979 {
980 const size_t arrayLen = 2;
981 JSVM_Value testArray = nullptr;
982 OH_JSVM_CreateArrayWithLength(env, arrayLen, &testArray);
983 JSVM_Value name = nullptr;
984 char newStr1[] = "test";
985 OH_JSVM_CreateStringUtf8(env, newStr1, strlen(newStr1), &name);
986 JSVM_Status status = OH_JSVM_SetElement(env, testArray, 0, name);
987 bool hasElement = false;
988 OH_JSVM_HasElement(env, testArray, 0, &hasElement);
989 if (!hasElement) {
990 OH_JSVM_ThrowError(env, nullptr, "TestHasElement_02:OH_JSVM_HasElement Failed");
991 return nullptr;
992 }
993
994 bool setValue = true;
995 JSVM_Value retValue = nullptr;
996 OH_JSVM_GetBoolean(env, setValue, &retValue);
997 return retValue;
998 }
999 //dataview obj + set index + nonnull
TestHasElement_03(JSVM_Env env,JSVM_CallbackInfo info)1000 [[maybe_unused]] JSVM_Value TestHasElement_03(JSVM_Env env, JSVM_CallbackInfo info)
1001 {
1002 size_t argc = 2;
1003 JSVM_Value args[2] = {nullptr};
1004 JSVM_Value arrayBuffer = nullptr;
1005 JSVM_Value result = nullptr;
1006 OH_JSVM_GetCbInfo(env, info, &argc, args, nullptr, nullptr);
1007 OH_JSVM_CoerceToObject(env, args[0], &arrayBuffer);
1008 OH_JSVM_CreateDataview(env, DIFF_VALUE_TWELVE, arrayBuffer, DIFF_VALUE_FOUR, &result);
1009 JSVM_Value Value = nullptr;
1010 JSVM_Status status = OH_JSVM_SetElement(env, result, sizeof(result), Value);
1011 if (status != JSVM_PENDING_EXCEPTION) {
1012 OH_JSVM_ThrowError(env, nullptr, "TestHasElement_03:OH_JSVM_SetElement 0 Failed");
1013 return nullptr;
1014 }
1015
1016 JSVM_Value recvMsg = nullptr;
1017 OH_JSVM_GetAndClearLastException(env, &recvMsg);
1018
1019 bool hasElement = false;
1020 OH_JSVM_HasElement(env, result, 0, &hasElement);
1021 if (hasElement) {
1022 OH_JSVM_ThrowError(env, nullptr, "TestHasElement_03:OH_JSVM_HasElement Failed");
1023 return nullptr;
1024 }
1025
1026 bool setValue = true;
1027 JSVM_Value retValue = nullptr;
1028 OH_JSVM_GetBoolean(env, setValue, &retValue);
1029 return retValue;
1030 }
1031 //not array obj + set index + nonnull
TestHasElement_04(JSVM_Env env,JSVM_CallbackInfo info)1032 [[maybe_unused]] JSVM_Value TestHasElement_04(JSVM_Env env, JSVM_CallbackInfo info)
1033 {
1034 JSVM_Value name = nullptr;
1035 char newStr[] = "test";
1036 OH_JSVM_CreateStringUtf8(env, newStr, strlen(newStr), &name);
1037 JSVM_Value object;
1038 OH_JSVM_CreateObject(env, &object);
1039 JSVM_Status status = OH_JSVM_SetElement(env, object, 0, name);
1040 if (status != JSVM_OK) {
1041 OH_JSVM_ThrowError(env, nullptr, "TestHasElement_04:OH_JSVM_SetElement index 0 Failed");
1042 return nullptr;
1043 }
1044
1045 bool hasElement = false;
1046 OH_JSVM_HasElement(env, object, 0, &hasElement);
1047 if (!hasElement) {
1048 OH_JSVM_ThrowError(env, nullptr, "TestHasElement_04:OH_JSVM_HasElement Failed");
1049 return nullptr;
1050 }
1051
1052 bool setValue = true;
1053 JSVM_Value retValue = nullptr;
1054 OH_JSVM_GetBoolean(env, setValue, &retValue);
1055 return retValue;
1056 }
1057 //arraybuffer obj + not set index + nonnull
TestHasElement_05(JSVM_Env env,JSVM_CallbackInfo info)1058 [[maybe_unused]] JSVM_Value TestHasElement_05(JSVM_Env env, JSVM_CallbackInfo info)
1059 {
1060 JSVM_Value testArray = nullptr;
1061 void *arrayBufferPtr = nullptr;
1062 const size_t arrayBufferSize = 4;
1063 OH_JSVM_CreateArraybuffer(env, arrayBufferSize, &arrayBufferPtr, &testArray);
1064 bool hasElement = false;
1065 OH_JSVM_HasElement(env, testArray, 0, &hasElement);
1066 if (hasElement) {
1067 OH_JSVM_ThrowError(env, nullptr, "TestHasElement_05:OH_JSVM_HasElement Failed");
1068 return nullptr;
1069 }
1070
1071 bool setValue = true;
1072 JSVM_Value retValue = nullptr;
1073 OH_JSVM_GetBoolean(env, setValue, &retValue);
1074 return retValue;
1075 }
1076 //arraybuffer obj + set index + NULL
TestHasElement_06(JSVM_Env env,JSVM_CallbackInfo info)1077 [[maybe_unused]] JSVM_Value TestHasElement_06(JSVM_Env env, JSVM_CallbackInfo info)
1078 {
1079 JSVM_Value arrayBuffer = nullptr;
1080 void *arrayBufferPtr = nullptr;
1081 const size_t arrayBufferSize = 4;
1082 JSVM_Status status = OH_JSVM_CreateArraybuffer(env, arrayBufferSize, &arrayBufferPtr, &arrayBuffer);
1083 if (status != JSVM_OK) {
1084 OH_JSVM_ThrowError(env, nullptr, "TestHasElement_06:CreateArraybuffer Failed");
1085 return nullptr;
1086 }
1087
1088 status = OH_JSVM_SetElement(env, arrayBuffer, 0, nullptr);
1089 if (status != JSVM_INVALID_ARG) {
1090 OH_JSVM_ThrowError(env, nullptr, "TestHasElement_06:OH_JSVM_SetElement Failed");
1091 return nullptr;
1092 }
1093
1094 bool hasElement = false;
1095 OH_JSVM_HasElement(env, arrayBuffer, 0, &hasElement);
1096 if (hasElement) {
1097 OH_JSVM_ThrowError(env, nullptr, "TestHasElement_06:OH_JSVM_HasElement Failed");
1098 return nullptr;
1099 }
1100
1101 bool setValue = true;
1102 JSVM_Value retValue = nullptr;
1103 OH_JSVM_GetBoolean(env, setValue, &retValue);
1104 return retValue;
1105 }
1106 //OH_JSVM_DeleteElement
1107 //arraybuffer obj + set index + nonnull
TestDeleteElement_01(JSVM_Env env,JSVM_CallbackInfo info)1108 [[maybe_unused]] JSVM_Value TestDeleteElement_01(JSVM_Env env, JSVM_CallbackInfo info)
1109 {
1110 JSVM_Value testArray = nullptr;
1111 void *arrayBufferPtr = nullptr;
1112 const size_t arrayBufferSize = 4;
1113 OH_JSVM_CreateArraybuffer(env, arrayBufferSize, &arrayBufferPtr, &testArray);
1114 JSVM_Value name = nullptr;
1115 OH_JSVM_SetElement(env, testArray, arrayBufferSize, name);
1116 JSVM_Value result = nullptr;
1117 JSVM_Status status = OH_JSVM_GetElement(env, testArray, sizeof(testArray), &result);
1118 if (status != JSVM_OK) {
1119 OH_JSVM_ThrowError(env, nullptr, "TestDeleteElement_01:OH_JSVM_GetElement 0 Failed");
1120 return nullptr;
1121 }
1122
1123 bool rst = false;
1124 OH_JSVM_DeleteElement(env, testArray, 0, &rst);
1125 if (!rst) {
1126 OH_JSVM_ThrowError(env, nullptr, "TestDeleteElement_01:OH_JSVM_DeleteElement Failed");
1127 return nullptr;
1128 }
1129
1130 bool setValue = true;
1131 JSVM_Value retValue = nullptr;
1132 OH_JSVM_GetBoolean(env, setValue, &retValue);
1133 return retValue;
1134 }
1135 //typedarray obj + set index + nonnull
TestDeleteElement_02(JSVM_Env env,JSVM_CallbackInfo info)1136 [[maybe_unused]] JSVM_Value TestDeleteElement_02(JSVM_Env env, JSVM_CallbackInfo info)
1137 {
1138 JSVM_Value testArray = nullptr;
1139 const size_t arrayLen = 4;
1140 OH_JSVM_CreateArrayWithLength(env, arrayLen, &testArray);
1141 uint32_t data = 1;
1142 JSVM_Value value = nullptr;
1143 OH_JSVM_CreateUint32(env, data, &value);
1144 JSVM_Status status = OH_JSVM_CreateTypedarray(env,
1145 JSVM_TypedarrayType::JSVM_INT32_ARRAY,
1146 arrayLen,
1147 testArray,
1148 0,
1149 &value);
1150 OH_JSVM_SetElement(env, testArray, 0, value);
1151 bool hasElement = false;
1152 status = OH_JSVM_HasElement(env, testArray, 0, &hasElement);
1153 if (!hasElement) {
1154 OH_JSVM_ThrowError(env, nullptr, "TestDeleteElement_02:OH_JSVM_HasElement Failed");
1155 return nullptr;
1156 }
1157
1158 bool rst = false;
1159 OH_JSVM_DeleteElement(env, testArray, 0, &rst);
1160 if (!rst) {
1161 OH_JSVM_ThrowError(env, nullptr, "TestDeleteElement_02:OH_JSVM_DeleteElement Failed");
1162 return nullptr;
1163 }
1164
1165 bool setValue = true;
1166 JSVM_Value retValue = nullptr;
1167 OH_JSVM_GetBoolean(env, setValue, &retValue);
1168 return retValue;
1169 }
1170 //dataview obj + set index + nonnull
TestDeleteElement_03(JSVM_Env env,JSVM_CallbackInfo info)1171 [[maybe_unused]] JSVM_Value TestDeleteElement_03(JSVM_Env env, JSVM_CallbackInfo info)
1172 {
1173 size_t argc = 2;
1174 JSVM_Value args[2] = {nullptr};
1175 JSVM_Value arraybuffer = nullptr;
1176 JSVM_Value result = nullptr;
1177 OH_JSVM_GetCbInfo(env, info, &argc, args, nullptr, nullptr);
1178 OH_JSVM_CoerceToObject(env, args[0], &arraybuffer);
1179 OH_JSVM_CreateDataview(env, DIFF_VALUE_TWELVE, arraybuffer, DIFF_VALUE_FOUR, &result);
1180
1181 JSVM_Status status = OH_JSVM_SetElement(env, result, sizeof(result), nullptr);
1182 if (status != JSVM_PENDING_EXCEPTION) {
1183 OH_JSVM_ThrowError(env, nullptr, "TestDeleteElement_03:OH_JSVM_SetElement 0 Failed");
1184 return nullptr;
1185 }
1186
1187 JSVM_Value recvMsg = nullptr;
1188 OH_JSVM_GetAndClearLastException(env, &recvMsg);
1189
1190 bool rst = false;
1191 OH_JSVM_DeleteElement(env, result, 0, &rst);
1192 if (rst) {
1193 OH_JSVM_ThrowError(env, nullptr, "TestDeleteElement_03:OH_JSVM_DeleteElement Failed");
1194 return nullptr;
1195 }
1196
1197 recvMsg = nullptr;
1198 OH_JSVM_GetAndClearLastException(env, &recvMsg);
1199
1200 bool setValue = true;
1201 JSVM_Value retValue = nullptr;
1202 OH_JSVM_GetBoolean(env, setValue, &retValue);
1203 return retValue;
1204 }
1205 //not array obj + set index + nonnull
TestDeleteElement_04(JSVM_Env env,JSVM_CallbackInfo info)1206 [[maybe_unused]] JSVM_Value TestDeleteElement_04(JSVM_Env env, JSVM_CallbackInfo info)
1207 {
1208 JSVM_Value name = nullptr;
1209 char newStr[] = "test";
1210 OH_JSVM_CreateStringUtf8(env, newStr, strlen(newStr), &name);
1211 JSVM_Value object;
1212 OH_JSVM_CreateObject(env, &object);
1213 JSVM_Status status = OH_JSVM_SetElement(env, object, 0, name);
1214 if (status != JSVM_OK) {
1215 OH_JSVM_ThrowError(env, nullptr, "TestDeleteElement_04:OH_JSVM_SetElement index 0 Failed");
1216 return nullptr;
1217 }
1218
1219 bool rst = false;
1220 OH_JSVM_DeleteElement(env, object, 0, &rst);
1221 if (!rst) {
1222 OH_JSVM_ThrowError(env, nullptr, "TestDeleteElement_04:OH_JSVM_DeleteElement Failed");
1223 return nullptr;
1224 }
1225
1226 bool setValue = true;
1227 JSVM_Value retValue = nullptr;
1228 OH_JSVM_GetBoolean(env, setValue, &retValue);
1229 return retValue;
1230 }
1231 //arraybuffer obj + set index + nonnull
TestDeleteElement_05(JSVM_Env env,JSVM_CallbackInfo info)1232 [[maybe_unused]] JSVM_Value TestDeleteElement_05(JSVM_Env env, JSVM_CallbackInfo info)
1233 {
1234 JSVM_Value testArray = nullptr;
1235 void *arrayBufferPtr = nullptr;
1236 const size_t arrayBufferSize = 4;
1237 OH_JSVM_CreateArraybuffer(env, arrayBufferSize, &arrayBufferPtr, &testArray);
1238
1239 bool rst = false;
1240 OH_JSVM_DeleteElement(env, testArray, 0, &rst);
1241 if (!rst) {
1242 OH_JSVM_ThrowError(env, nullptr, "TestDeleteElement_05:OH_JSVM_DeleteElement Failed");
1243 return nullptr;
1244 }
1245
1246 bool setValue = true;
1247 JSVM_Value retValue = nullptr;
1248 OH_JSVM_GetBoolean(env, setValue, &retValue);
1249 return retValue;
1250 }
1251 //arraybuffer obj + set index + NULL
TestDeleteElement_06(JSVM_Env env,JSVM_CallbackInfo info)1252 [[maybe_unused]] JSVM_Value TestDeleteElement_06(JSVM_Env env, JSVM_CallbackInfo info)
1253 {
1254 JSVM_Value arrayBuffer = nullptr;
1255 void *arrayBufferPtr = nullptr;
1256 const size_t arrayBufferSize = 4;
1257 JSVM_Status status = OH_JSVM_CreateArraybuffer(env, arrayBufferSize, &arrayBufferPtr, &arrayBuffer);
1258 if (status != JSVM_OK) {
1259 OH_JSVM_ThrowError(env, nullptr, "TestDeleteElement_06:CreateArraybuffer Failed");
1260 return nullptr;
1261 }
1262
1263 status = OH_JSVM_SetElement(env, arrayBuffer, 0, nullptr);
1264 if (status != JSVM_INVALID_ARG) {
1265 OH_JSVM_ThrowError(env, nullptr, "TestDeleteElement_06:OH_JSVM_SetElement Failed");
1266 return nullptr;
1267 }
1268
1269 bool rst = false;
1270 OH_JSVM_DeleteElement(env, arrayBuffer, 0, &rst);
1271 if (!rst) {
1272 OH_JSVM_ThrowError(env, nullptr, "TestDeleteElement_06:OH_JSVM_DeleteElement Failed");
1273 return nullptr;
1274 }
1275
1276 bool setValue = true;
1277 JSVM_Value retValue = nullptr;
1278 OH_JSVM_GetBoolean(env, setValue, &retValue);
1279 return retValue;
1280 }
1281 //API Combination Call Case
1282 //CreatArray/CreateArrayWithLength-> GetArrayLength，Check if it meets expectations ->
1283 //IsArray Determine whether it is an array,
1284 //return true -> SetElement -> GetElement, Consistent with set -> HasElement Determine whether
1285 //there are array elements present,
1286 //If set, return true; if not set, return false -> DeleteElement，If set, return true; if not set, return false
1287 //The following 01 case represents the situation of set, and 02 represents the situation of not set.
TestArrayProcessSteps_01(JSVM_Env env,JSVM_CallbackInfo info)1288 [[maybe_unused]] JSVM_Value TestArrayProcessSteps_01(JSVM_Env env, JSVM_CallbackInfo info)
1289 {
1290 const size_t arrayLength = 4;
1291 JSVM_Value testArray = nullptr;
1292 JSVM_Status status = OH_JSVM_CreateArrayWithLength(env, arrayLength, &testArray);
1293 bool isArray = false;
1294 OH_JSVM_IsArray(env, testArray, &isArray);
1295 if (!isArray) {
1296 OH_JSVM_ThrowError(env, nullptr, "TestArrayProcessSteps_01: is_array Failed");
1297 return nullptr;
1298 }
1299 uint32_t calcNum = 4;
1300 uint32_t length;
1301 status = OH_JSVM_GetArrayLength(env, testArray, &length);
1302 if (length != calcNum) {
1303 OH_JSVM_ThrowError(env, nullptr, "TestArrayProcessSteps_01: GetArrayLength 02 Failed");
1304 return nullptr;
1305 }
1306 for (uint32_t i = 0; i < calcNum; i++) {
1307 JSVM_Value element;
1308 OH_JSVM_CreateUint32(env, i, &element);
1309 status = OH_JSVM_SetElement(env, testArray, i, element);
1310 if (status != JSVM_OK) {
1311 OH_JSVM_ThrowError(env, nullptr, "TestArrayProcessSteps_01:OH_JSVM_SetElement Failed");
1312 return nullptr;
1313 }
1314 }
1315
1316 JSVM_Value result = nullptr;
1317 status = OH_JSVM_GetElement(env, testArray, sizeof(testArray), &result);
1318 bool hasElement = false;
1319 OH_JSVM_HasElement(env, testArray, 0, &hasElement);
1320 if (!hasElement) {
1321 OH_JSVM_ThrowError(env, nullptr, "TestArrayProcessSteps_01:OH_JSVM_HasElement Failed");
1322 return nullptr;
1323 }
1324
1325 bool rst = false;
1326 OH_JSVM_DeleteElement(env, testArray, 0, &rst);
1327 if (!rst) {
1328 OH_JSVM_ThrowError(env, nullptr, "TestArrayProcessSteps_01:OH_JSVM_DeleteElement Failed");
1329 return nullptr;
1330 }
1331
1332 bool setValue = true;
1333 JSVM_Value retValue = nullptr;
1334 OH_JSVM_GetBoolean(env, setValue, &retValue);
1335 return retValue;
1336 }
1337
TestArrayProcessSteps_02(JSVM_Env env,JSVM_CallbackInfo info)1338 [[maybe_unused]] JSVM_Value TestArrayProcessSteps_02(JSVM_Env env, JSVM_CallbackInfo info)
1339 {
1340 size_t arrayLength = 4;
1341 JSVM_Value testArray = nullptr;
1342 JSVM_Status status = OH_JSVM_CreateArrayWithLength(env, arrayLength, &testArray);
1343 if (status != JSVM_OK) {
1344 OH_JSVM_ThrowError(env, nullptr, "testArrayProcessSteps_02:OH_JSVM_CreateArrayWithLength Failed");
1345 return nullptr;
1346 }
1347
1348 bool isArray = false;
1349 OH_JSVM_IsArray(env, testArray, &isArray);
1350 if (!isArray) {
1351 OH_JSVM_ThrowError(env, nullptr, "testArrayProcessSteps_02: is_array Failed");
1352 return nullptr;
1353 }
1354
1355 uint32_t length;
1356 status = OH_JSVM_GetArrayLength(env, testArray, &length);
1357 if (status != JSVM_OK) {
1358 OH_JSVM_ThrowError(env, nullptr, "testArrayProcessSteps_02: GetArrayLength 01 Failed");
1359 return nullptr;
1360 }
1361 if (length != arrayLength) {
1362 OH_JSVM_ThrowError(env, nullptr, "testArrayProcessSteps_02: GetArrayLength 02 Failed");
1363 return nullptr;
1364 }
1365
1366 bool hasElement = true;
1367 OH_JSVM_HasElement(env, testArray, 0, &hasElement);
1368 if (hasElement) {
1369 OH_JSVM_ThrowError(env, nullptr, "testArrayProcessSteps_02:OH_JSVM_HasElement Failed");
1370 return nullptr;
1371 }
1372
1373 bool rst = true;
1374 OH_JSVM_DeleteElement(env, testArray, 0, &rst);
1375 if (!rst) {
1376 OH_JSVM_ThrowError(env, nullptr, "testArrayProcessSteps_02:OH_JSVM_DeleteElement Failed");
1377 return nullptr;
1378 }
1379
1380 bool setValue = true;
1381 JSVM_Value retValue = nullptr;
1382 OH_JSVM_GetBoolean(env, setValue, &retValue);
1383 return retValue;
1384 }
1385 //CreatArraybuffer -> createTypedarray -> GetTypedarrayInfo get Typedarray,
1386 //Consistent with creation -> IsTypedarray if it is a Typedarray, return true ->
1387 //IsArray，return false -> SetElement -> GetElement,
1388 //Consistent with set -> HasElement,
1389 //If set, return true; if not set, return false -> DeleteElement，If set, return true; if not set, return false.
1390 //The following 01 case represents the situation of set, and 02 represents the situation of not set.
CreateTypedarrayDataAndCheck(JSVM_Env env,JSVM_CallbackInfo info)1391 [[maybe_unused]] JSVM_Value CreateTypedarrayDataAndCheck(JSVM_Env env, JSVM_CallbackInfo info)
1392 {
1393 void *data;
1394 JSVM_TypedarrayType type;
1395 size_t byteOffset;
1396 size_t length;
1397 JSVM_Value arrayBuffer = nullptr;
1398 void *arrayBufferPtr = nullptr;
1399 const size_t arrayBufferSize = 16;
1400 const size_t typedArrayLength = 4;
1401 JSVM_Value value;
1402 JSVM_Status status = OH_JSVM_CreateArraybuffer(env, arrayBufferSize, &arrayBufferPtr, &arrayBuffer);
1403 if (status != JSVM_OK) {
1404 OH_JSVM_ThrowError(env, nullptr, "TestTypedarrayProcessSteps_01:OH_JSVM_CreateTypedarray Failed");
1405 return nullptr;
1406 }
1407 status = OH_JSVM_CreateTypedarray(env,
1408 JSVM_TypedarrayType::JSVM_INT32_ARRAY,
1409 typedArrayLength,
1410 arrayBuffer,
1411 0,
1412 &value);
1413 if (status != JSVM_OK) {
1414 OH_JSVM_ThrowError(env, nullptr, "TestTypedarrayProcessSteps_01:OH_JSVM_CreateTypedarray Failed");
1415 return nullptr;
1416 }
1417 status = OH_JSVM_GetTypedarrayInfo(env, value, &type, &length, &data, &arrayBuffer, &byteOffset);
1418 if (status != JSVM_OK) {
1419 OH_JSVM_ThrowError(env, nullptr, "TestTypedarrayProcessSteps_01:OH_JSVM_GetTypedarrayInfo Failed");
1420 return nullptr;
1421 }
1422 if (length != typedArrayLength) {
1423 OH_JSVM_ThrowError(env, nullptr, "TestTypedarrayProcessSteps_01:OH_JSVM_GetTypedarrayInfo Failed");
1424 return nullptr;
1425 }
1426
1427 bool isTypedArray = false;
1428 OH_JSVM_IsTypedarray(env, value, &isTypedArray);
1429 if (!isTypedArray) {
1430 OH_JSVM_ThrowError(env, nullptr, "TestTypedarrayProcessSteps_01:is not typed array Failed");
1431 return nullptr;
1432 }
1433
1434 bool isArray = true;
1435 OH_JSVM_IsArray(env, value, &isArray);
1436 if (isArray) {
1437 OH_JSVM_ThrowError(env, nullptr, "TestTypedarrayProcessSteps_01: is array");
1438 return nullptr;
1439 }
1440
1441 return value;
1442 }
TestTypedarrayProcessSteps_01(JSVM_Env env,JSVM_CallbackInfo info)1443 [[maybe_unused]] JSVM_Value TestTypedarrayProcessSteps_01(JSVM_Env env, JSVM_CallbackInfo info)
1444 {
1445 const size_t typedArrayLength = 4;
1446 JSVM_Value value;
1447 JSVM_Status status;
1448 value = CreateTypedarrayDataAndCheck(env, info);
1449 if (value == nullptr) {
1450 return nullptr;
1451 }
1452 uint32_t calcNum = 16;
1453 for (uint32_t i = 0; i < calcNum; i++) {
1454 JSVM_Value element;
1455 OH_JSVM_CreateUint32(env, 1, &element);
1456 status = OH_JSVM_SetElement(env, value, i, element);
1457 if (status != JSVM_OK) {
1458 OH_JSVM_ThrowError(env, nullptr, "TestTypedarrayProcessSteps_01:OH_JSVM_SetElement Failed");
1459 return nullptr;
1460 }
1461 }
1462
1463 JSVM_Value result = nullptr;
1464 status = OH_JSVM_GetElement(env, value, 0, &result);
1465 if (status != JSVM_OK) {
1466 OH_JSVM_ThrowError(env, nullptr, "TestTypedarrayProcessSteps_01:OH_JSVM_GetElement 1 Failed");
1467 return nullptr;
1468 }
1469
1470 bool hasElement = false;
1471 OH_JSVM_HasElement(env, value, 0, &hasElement);
1472 if (!hasElement) {
1473 OH_JSVM_ThrowError(env, nullptr, "TestTypedarrayProcessSteps_01:OH_JSVM_HasElement Failed");
1474 return nullptr;
1475 }
1476
1477 bool rst = false;
1478 status = OH_JSVM_DeleteElement(env, value, typedArrayLength, &rst);
1479 if (!rst) {
1480 OH_JSVM_ThrowError(env, nullptr, "TestTypedarrayProcessSteps_01:OH_JSVM_DeleteElement Failed");
1481 return nullptr;
1482 }
1483
1484 bool setValue = true;
1485 JSVM_Value retValue = nullptr;
1486 OH_JSVM_GetBoolean(env, setValue, &retValue);
1487 return retValue;
1488 }
TestTypedarrayProcessSteps_02(JSVM_Env env,JSVM_CallbackInfo info)1489 [[maybe_unused]] JSVM_Value TestTypedarrayProcessSteps_02(JSVM_Env env, JSVM_CallbackInfo info)
1490 {
1491 void *data;
1492 JSVM_TypedarrayType type;
1493 size_t byteOffset;
1494 size_t length;
1495 JSVM_Value arrayBuffer = nullptr;
1496 void *arrayBufferPtr = nullptr;
1497 const size_t arrayBufferSize = 16;
1498 const size_t typedArrayLength = 4;
1499 JSVM_Value value;
1500 JSVM_Status status = OH_JSVM_CreateArraybuffer(env, arrayBufferSize, &arrayBufferPtr, &arrayBuffer);
1501 status = OH_JSVM_CreateTypedarray(env,
1502 JSVM_TypedarrayType::JSVM_INT32_ARRAY,
1503 typedArrayLength,
1504 arrayBuffer,
1505 0,
1506 &value);
1507 status = OH_JSVM_GetTypedarrayInfo(env, value, &type, &length, &data, &arrayBuffer, &byteOffset);
1508 if (length != typedArrayLength) {
1509 OH_JSVM_ThrowError(env, nullptr, "TestTypedarrayProcessSteps_02:OH_JSVM_GetTypedarrayInfo Failed");
1510 return nullptr;
1511 }
1512 bool isTypedArray = false;
1513 OH_JSVM_IsTypedarray(env, value, &isTypedArray);
1514 if (!isTypedArray) {
1515 OH_JSVM_ThrowError(env, nullptr, "TestTypedarrayProcessSteps_02:is not typed array Failed");
1516 return nullptr;
1517 }
1518 bool hasElement = true;
1519 OH_JSVM_HasElement(env, value, 0, &hasElement);
1520 if (!hasElement) {
1521 OH_JSVM_ThrowError(env, nullptr, "TestTypedarrayProcessSteps_02:OH_JSVM_HasElement Failed");
1522 return nullptr;
1523 }
1524
1525 bool rst = true;
1526 status = OH_JSVM_DeleteElement(env, value, 0, &rst);
1527 if (rst) {
1528 OH_JSVM_ThrowError(env, nullptr, "TestTypedarrayProcessSteps_02:OH_JSVM_DeleteElement Failed");
1529 return nullptr;
1530 }
1531
1532 bool setValue = true;
1533 JSVM_Value retValue = nullptr;
1534 OH_JSVM_GetBoolean(env, setValue, &retValue);
1535 return retValue;
1536 }
1537 //CreatArraybuffer-> createDataview -> GetDataviewInfo，
1538 //Consistent with creation -> IsDataview if is Dataview, return true -> IsArray，
1539 //return false -> SetElement -> GetElement , Consistent with set -> HasElement，
1540 //If set, return true; if not set, return false -> DeleteElement，If set, return true; if not set, return false.
1541 //The following 01 case represents the situation of set, and 02 represents the situation of not set.
TestArrayDataviewProcessSteps_01(JSVM_Env env,JSVM_CallbackInfo info)1542 [[maybe_unused]] JSVM_Value TestArrayDataviewProcessSteps_01(JSVM_Env env, JSVM_CallbackInfo info)
1543 {
1544 JSVM_Value arrayBuffer = nullptr;
1545 void *arrayBufferPtr = nullptr;
1546 const size_t arrayBufferSize = 16;
1547 JSVM_Status status = OH_JSVM_CreateArraybuffer(env, arrayBufferSize, &arrayBufferPtr, &arrayBuffer);
1548 if (status != JSVM_OK || arrayBuffer == nullptr) {
1549 OH_JSVM_ThrowError(env, nullptr, "TestArrayDataviewProcessSteps_01:CreateArraybuffer Failed");
1550 return nullptr;
1551 }
1552
1553 JSVM_Value result = nullptr;
1554 status = OH_JSVM_CreateDataview(env, arrayBufferSize, arrayBuffer, 0, &result);
1555 if (status != JSVM_OK) {
1556 OH_JSVM_ThrowError(env, nullptr, "TestArrayDataviewProcessSteps_01:OH_JSVM_CreateDataview Failed");
1557 return nullptr;
1558 }
1559
1560 bool isDataView = false;
1561 OH_JSVM_IsDataview(env, result, &isDataView);
1562 if (!isDataView) {
1563 OH_JSVM_ThrowError(env,
1564 nullptr,
1565 "TestArrayDataviewProcessSteps_01:OH_JSVM_CreateDataview isn't DataView Failed");
1566 return nullptr;
1567 }
1568
1569 JSVM_Value retArrayBuffer = nullptr;
1570 void *data = nullptr;
1571 size_t byteLength = 0;
1572 size_t byteOffset = -1;
1573 status = OH_JSVM_GetDataviewInfo(env, result, &byteLength, &data, &retArrayBuffer, &byteOffset);
1574 if (status != JSVM_OK) {
1575 OH_JSVM_ThrowError(env,
1576 nullptr,
1577 "TestArrayDataviewProcessSteps_01:OH_JSVM_CreateDataview GetDataviewInfo Failed");
1578 return nullptr;
1579 }
1580
1581 bool isArray = true;
1582 OH_JSVM_IsArray(env, result, &isArray);
1583 if (isArray) {
1584 OH_JSVM_ThrowError(env, nullptr, "TestArrayDataviewProcessSteps_01: is array");
1585 return nullptr;
1586 }
1587 int32_t tarNum = 3;
1588 JSVM_Value inputStr = nullptr;
1589 OH_JSVM_CreateInt32(env, tarNum, &inputStr);
1590 status = OH_JSVM_SetElement(env, result, 0, inputStr);
1591 if (status != JSVM_OK) {
1592 OH_JSVM_ThrowError(env, nullptr, "TestArrayDataviewProcessSteps_01:OH_JSVM_SetElement 0 Failed");
1593 return nullptr;
1594 }
1595
1596 bool hasElement = false;
1597 OH_JSVM_HasElement(env, result, 0, &hasElement);
1598 if (!hasElement) {
1599 OH_JSVM_ThrowError(env, nullptr, "TestArrayDataviewProcessSteps_01:OH_JSVM_HasElement Failed");
1600 return nullptr;
1601 }
1602
1603 JSVM_Value rst = nullptr;
1604 status = OH_JSVM_GetElement(env, result, sizeof(result), &rst);
1605 if (status != JSVM_OK) {
1606 OH_JSVM_ThrowError(env, nullptr, "TestArrayDataviewProcessSteps_01:OH_JSVM_GetElement Failed");
1607 return nullptr;
1608 }
1609
1610 bool rstValue = false;
1611 OH_JSVM_DeleteElement(env, result, 0, &rstValue);
1612 if (!rstValue) {
1613 OH_JSVM_ThrowError(env, nullptr, "TestArrayDataviewProcessSteps_01:OH_JSVM_DeleteElement Failed");
1614 return nullptr;
1615 }
1616
1617 bool setValue = true;
1618 JSVM_Value retValue = nullptr;
1619 OH_JSVM_GetBoolean(env, setValue, &retValue);
1620 return retValue;
1621 }
1622
TestArrayDataviewProcessSteps_02(JSVM_Env env,JSVM_CallbackInfo info)1623 [[maybe_unused]] JSVM_Value TestArrayDataviewProcessSteps_02(JSVM_Env env, JSVM_CallbackInfo info)
1624 {
1625 JSVM_Value arrayBuffer = nullptr;
1626 void *arrayBufferPtr = nullptr;
1627 const size_t arrayBufferSize = 16;
1628 JSVM_Status status = OH_JSVM_CreateArraybuffer(env, arrayBufferSize, &arrayBufferPtr, &arrayBuffer);
1629 JSVM_Value result = nullptr;
1630 status = OH_JSVM_CreateDataview(env, arrayBufferSize, arrayBuffer, 0, &result);
1631 bool isDataView = false;
1632 OH_JSVM_IsDataview(env, result, &isDataView);
1633 if (!isDataView) {
1634 OH_JSVM_ThrowError(env,
1635 nullptr,
1636 "TestArrayDataviewProcessSteps_02:OH_JSVM_CreateDataview isn't DataView Failed");
1637 return nullptr;
1638 }
1639 JSVM_Value retArrayBuffer = nullptr;
1640 void *data = nullptr;
1641 size_t byteLength = 0;
1642 size_t byteOffset = -1;
1643 status = OH_JSVM_GetDataviewInfo(env, result, &byteLength, &data, &retArrayBuffer, &byteOffset);
1644 if (status != JSVM_OK) {
1645 OH_JSVM_ThrowError(env,
1646 nullptr,
1647 "TestArrayDataviewProcessSteps_02:OH_JSVM_CreateDataview GetDataviewInfo Failed");
1648 return nullptr;
1649 }
1650 bool isArray = true;
1651 OH_JSVM_IsArray(env, result, &isArray);
1652 if (isArray) {
1653 OH_JSVM_ThrowError(env, nullptr, "TestArrayDataviewProcessSteps_02: is array");
1654 return nullptr;
1655 }
1656 bool hasElement = true;
1657 OH_JSVM_HasElement(env, result, 0, &hasElement);
1658 if (hasElement) {
1659 OH_JSVM_ThrowError(env, nullptr, "TestArrayDataviewProcessSteps_02:OH_JSVM_HasElement");
1660 return nullptr;
1661 }
1662 bool rst = true;
1663 OH_JSVM_DeleteElement(env, result, 0, &rst);
1664 if (!rst) {
1665 OH_JSVM_ThrowError(env, nullptr, "TestArrayDataviewProcessSteps_02:OH_JSVM_DeleteElement Failed.");
1666 return nullptr;
1667 }
1668
1669 bool setValue = true;
1670 JSVM_Value retValue = nullptr;
1671 OH_JSVM_GetBoolean(env, setValue, &retValue);
1672 return retValue;
1673 }
1674 //CreatArraybuffer -> createTypedarray -> GetTypedarrayInfo,
1675 //Consistent with creation -> IsTypedarray if it is Typedarray, return true -> createDataview -> GetDataviewInfo,
1676 //Consistent with creation -> IsDataview if it is Dataview, return true
TestTypeArrayAndDataviewProcessSteps_01(JSVM_Env env,JSVM_CallbackInfo info)1677 [[maybe_unused]] JSVM_Value TestTypeArrayAndDataviewProcessSteps_01(JSVM_Env env, JSVM_CallbackInfo info)
1678 {
1679 JSVM_Value arrayBuffer = nullptr;
1680 void *arrayBufferPtr = nullptr;
1681 size_t arrayBufferSize = 16;
1682 JSVM_Status status = OH_JSVM_CreateArraybuffer(env, arrayBufferSize, &arrayBufferPtr, &arrayBuffer);
1683 JSVM_Value value = nullptr;
1684 size_t typedArrayLength = 0;
1685 OH_JSVM_CreateTypedarray(env,
1686 JSVM_TypedarrayType::JSVM_INT16_ARRAY,
1687 typedArrayLength,
1688 arrayBuffer,
1689 0,
1690 &value);
1691 JSVM_TypedarrayType type;
1692 size_t byteOffset = 0;
1693 void *data = nullptr;
1694 OH_JSVM_GetTypedarrayInfo(env, value, &type, &typedArrayLength, &data, &arrayBuffer, &byteOffset);
1695 bool isTypedArray = false;
1696 OH_JSVM_IsTypedarray(env, value, &isTypedArray);
1697 if (!isTypedArray) {
1698 OH_JSVM_ThrowError(env, nullptr, "TestTypeArrayAndDataviewProcessSteps_01:is not typed array Failed");
1699 return nullptr;
1700 }
1701 JSVM_Value result = nullptr;
1702 status = OH_JSVM_CreateDataview(env, arrayBufferSize, arrayBuffer, 0, &result);
1703 if (status != JSVM_OK) {
1704 OH_JSVM_ThrowError(env, nullptr, "TestTypeArrayAndDataviewProcessSteps_01:OH_JSVM_CreateDataview Failed");
1705 return nullptr;
1706 }
1707 bool isDataView = false;
1708 OH_JSVM_IsDataview(env, result, &isDataView);
1709 if (!isDataView) {
1710 OH_JSVM_ThrowError(env, nullptr,
1711 "TestTypeArrayAndDataviewProcessSteps_01:OH_JSVM_CreateDataview isn't DataView Failed");
1712 return nullptr;
1713 }
1714
1715 JSVM_Value retArrayBuffer = nullptr;
1716 size_t byteLength = 0;
1717 byteOffset = 0;
1718 status = OH_JSVM_GetDataviewInfo(env, result, &byteLength, &data, &retArrayBuffer, &byteOffset);
1719 if (status != JSVM_OK) {
1720 OH_JSVM_ThrowError(env, nullptr, "TestTypeArrayAndDataviewProcessSteps_01:GetDataviewInfo Failed");
1721 return nullptr;
1722 }
1723
1724 bool setValue = true;
1725 JSVM_Value retValue = nullptr;
1726 OH_JSVM_GetBoolean(env, setValue, &retValue);
1727 return retValue;
1728 }
1729 //TypeArray repeated set at the same index
TestTypeArraySetMultipleTimes_01(JSVM_Env env,JSVM_CallbackInfo info)1730 [[maybe_unused]] JSVM_Value TestTypeArraySetMultipleTimes_01(JSVM_Env env, JSVM_CallbackInfo info)
1731 {
1732 const size_t typedArrayLength = 8;
1733 JSVM_Value testArray = nullptr;
1734 OH_JSVM_CreateArrayWithLength(env, typedArrayLength, &testArray);
1735 JSVM_Value name = nullptr;
1736 char newStr1[] = "abc";
1737 OH_JSVM_CreateStringUtf8(env, newStr1, strlen(newStr1), &name);
1738 JSVM_Status status = OH_JSVM_SetElement(env, testArray, typedArrayLength, name);
1739 if (status != JSVM_OK) {
1740 OH_JSVM_ThrowError(env, nullptr, "TestTypeArraySetMultipleTimes_01:OH_JSVM_SetElement 1 Failed");
1741 return nullptr;
1742 }
1743
1744 uint32_t tarNum = 2;
1745 for (uint32_t i = 0; i < tarNum; i++) {
1746 JSVM_Value element;
1747 OH_JSVM_CreateUint32(env, i + 1, &element);
1748 status = OH_JSVM_SetElement(env, testArray, i, element);
1749 if (status != JSVM_OK) {
1750 OH_JSVM_ThrowError(env, nullptr, "TestTypeArraySetMultipleTimes_01:OH_JSVM_SetElement 2 Failed");
1751 return nullptr;
1752 }
1753 }
1754
1755 bool hasElement = false;
1756 OH_JSVM_HasElement(env, testArray, 0, &hasElement);
1757 if (!hasElement) {
1758 OH_JSVM_ThrowError(env, nullptr, "TestTypeArraySetMultipleTimes_01:OH_JSVM_HasElement Failed");
1759 return nullptr;
1760 }
1761
1762 JSVM_Value rst = nullptr;
1763 status = OH_JSVM_GetElement(env, testArray, 0, &rst);
1764 if (status != JSVM_OK) {
1765 OH_JSVM_ThrowError(env, nullptr, "TestTypeArraySetMultipleTimes_01:OH_JSVM_GetElement 1 Failed");
1766 return nullptr;
1767 }
1768
1769 bool setValue = true;
1770 JSVM_Value retValue = nullptr;
1771 OH_JSVM_GetBoolean(env, setValue, &retValue);
1772 return retValue;
1773 }
1774 //Array repeated set at the same index
TestArraySetMultipleTimes_01(JSVM_Env env,JSVM_CallbackInfo info)1775 [[maybe_unused]] JSVM_Value TestArraySetMultipleTimes_01(JSVM_Env env, JSVM_CallbackInfo info)
1776 {
1777 const size_t arrayLength = 2;
1778 JSVM_Value lhs;
1779 OH_JSVM_CreateArrayWithLength(env, arrayLength, &lhs);
1780 for (uint32_t i = 0; i < arrayLength; i++) {
1781 JSVM_Value element;
1782 OH_JSVM_CreateUint32(env, i + 1, &element);
1783 OH_JSVM_SetElement(env, lhs, i, element);
1784 }
1785
1786 size_t testLen = 3;
1787 JSVM_Value element;
1788 OH_JSVM_CreateUint32(env, testLen, &element);
1789 JSVM_Status status = OH_JSVM_SetElement(env, lhs, 3, element);
1790 if (status != JSVM_OK) {
1791 OH_JSVM_ThrowError(env, nullptr, "TestArraySetMultipleTimes_01:OH_JSVM_SetElement 2 Failed");
1792 return nullptr;
1793 }
1794
1795 bool hasElement = false;
1796 OH_JSVM_HasElement(env, lhs, 1, &hasElement);
1797 if (!hasElement) {
1798 OH_JSVM_ThrowError(env, nullptr, "TestArraySetMultipleTimes_01:OH_JSVM_HasElement Failed");
1799 return nullptr;
1800 }
1801
1802 JSVM_Value rst = nullptr;
1803 status = OH_JSVM_GetElement(env, lhs, 1, &rst);
1804 if (status != JSVM_OK) {
1805 OH_JSVM_ThrowError(env, nullptr, "TestArraySetMultipleTimes_01:OH_JSVM_GetElement 1 Failed");
1806 return nullptr;
1807 }
1808
1809 bool setValue = true;
1810 JSVM_Value retValue = nullptr;
1811 OH_JSVM_GetBoolean(env, setValue, &retValue);
1812 return retValue;
1813 }
1814 //TypeArray gets multiple times
TestArrayGetMultipleTimes_01(JSVM_Env env,JSVM_CallbackInfo info)1815 [[maybe_unused]] JSVM_Value TestArrayGetMultipleTimes_01(JSVM_Env env, JSVM_CallbackInfo info)
1816 {
1817 const size_t typedArrayLength = 8;
1818 JSVM_Value testArray = nullptr;
1819 OH_JSVM_CreateArrayWithLength(env, typedArrayLength, &testArray);
1820 JSVM_Value value = nullptr;
1821 const char testStr[] = "ab+c";
1822 OH_JSVM_CreateStringUtf8(env, testStr, strlen(testStr), &value);
1823 JSVM_Status status = OH_JSVM_SetElement(env, testArray, typedArrayLength, value);
1824 if (status != JSVM_OK) {
1825 OH_JSVM_ThrowError(env, nullptr, "TestArrayGetMultipleTimes_01:OH_JSVM_SetElement Failed.");
1826 return nullptr;
1827 }
1828
1829 uint32_t dataIndex = 2;
1830 bool hasElement = false;
1831 OH_JSVM_HasElement(env, testArray, dataIndex, &hasElement);
1832 if (hasElement) {
1833 OH_JSVM_ThrowError(env, nullptr, "TestArrayGetMultipleTimes_01:OH_JSVM_HasElement Abnormal.");
1834 return nullptr;
1835 }
1836
1837 JSVM_Value rst = nullptr;
1838 status = OH_JSVM_GetElement(env, testArray, dataIndex, &rst);
1839 if (status != JSVM_OK) {
1840 OH_JSVM_ThrowError(env, nullptr, "TestArrayGetMultipleTimes_01:OH_JSVM_GetElement 0 Abnormal.");
1841 return nullptr;
1842 }
1843
1844 status = OH_JSVM_GetElement(env, testArray, typedArrayLength, &rst);
1845 if (status != JSVM_OK) {
1846 OH_JSVM_ThrowError(env, nullptr, "TestArrayGetMultipleTimes_01:OH_JSVM_GetElement 2 Failed");
1847 return nullptr;
1848 }
1849
1850 bool setValue = true;
1851 JSVM_Value retValue = nullptr;
1852 OH_JSVM_GetBoolean(env, setValue, &retValue);
1853 return retValue;
1854 }
1855 //Repeat delete, same index
1856 //Return the execution status code JSVM_Status. JSVM-OK indicates successful execution.
1857 //JSVM_GENERIC_SAILURE indicates that there is an unknown reason causing execution failure.
TestArrayDeleteMultipleTimes_01(JSVM_Env env,JSVM_CallbackInfo info)1858 [[maybe_unused]] JSVM_Value TestArrayDeleteMultipleTimes_01(JSVM_Env env, JSVM_CallbackInfo info)
1859 {
1860 size_t testLen = 4;
1861 size_t testLen1 = 2;
1862 JSVM_Value testArray = nullptr;
1863 OH_JSVM_CreateArrayWithLength(env, testLen, &testArray);
1864 JSVM_Value index1 = nullptr;
1865 OH_JSVM_CreateUint32(env, 1, &index1);
1866 JSVM_Value index2 = nullptr;
1867 OH_JSVM_CreateUint32(env, testLen, &index2);
1868 OH_JSVM_SetElement(env, testArray, 0, index1);
1869 OH_JSVM_SetElement(env, testArray, 1, index2);
1870
1871 bool hasElement = false;
1872 OH_JSVM_HasElement(env, testArray, 0, &hasElement);
1873 if (!hasElement) {
1874 OH_JSVM_ThrowError(env, nullptr, "TestArrayDeleteMultipleTimes_01:OH_JSVM_HasElement Failed");
1875 return nullptr;
1876 }
1877
1878 bool rst = true;
1879 OH_JSVM_DeleteElement(env, testArray, 0, &rst);
1880 if (!rst) {
1881 OH_JSVM_ThrowError(env, nullptr, "TestArrayDeleteMultipleTimes_01:OH_JSVM_DeleteElement Failed.");
1882 return nullptr;
1883 }
1884 OH_JSVM_HasElement(env, testArray, 0, &hasElement);
1885 if (hasElement) {
1886 OH_JSVM_ThrowError(env, nullptr, "TestArrayDeleteMultipleTimes_01:OH_JSVM_HasElement 1 Failed");
1887 return nullptr;
1888 }
1889 OH_JSVM_DeleteElement(env, testArray, 0, &rst);
1890 if (!rst) {
1891 OH_JSVM_ThrowError(env, nullptr, "TestArrayDeleteMultipleTimes_01:OH_JSVM_DeleteElement 1 Failed.");
1892 return nullptr;
1893 }
1894
1895 bool setValue = true;
1896 JSVM_Value retValue = nullptr;
1897 OH_JSVM_GetBoolean(env, setValue, &retValue);
1898 return retValue;
1899 }
1900 //Multiple deletions with different indices
TestArrayDeleteMultipleTimes_02(JSVM_Env env,JSVM_CallbackInfo info)1901 [[maybe_unused]] JSVM_Value TestArrayDeleteMultipleTimes_02(JSVM_Env env, JSVM_CallbackInfo info)
1902 {
1903 const size_t testLen0 = 2;
1904 const size_t testLen1 = 5;
1905 JSVM_Value testArray = nullptr;
1906 OH_JSVM_CreateArrayWithLength(env, testLen0, &testArray);
1907 JSVM_Value index1 = nullptr;
1908 OH_JSVM_CreateUint32(env, 1, &index1);
1909 JSVM_Value index2 = nullptr;
1910 OH_JSVM_CreateUint32(env, testLen0, &index2);
1911 OH_JSVM_SetElement(env, testArray, 0, index1);
1912 OH_JSVM_SetElement(env, testArray, 1, index2);
1913
1914 bool hasElement = false;
1915 OH_JSVM_HasElement(env, testArray, 0, &hasElement);
1916 if (!hasElement) {
1917 OH_JSVM_ThrowError(env, nullptr, "TestArrayDeleteMultipleTimes_02:OH_JSVM_HasElement Failed");
1918 return nullptr;
1919 }
1920
1921 bool rst = true;
1922 OH_JSVM_DeleteElement(env, testArray, 0, &rst);
1923 if (!rst) {
1924 OH_JSVM_ThrowError(env, nullptr, "TestArrayDeleteMultipleTimes_02:OH_JSVM_DeleteElement Failed.");
1925 return nullptr;
1926 }
1927
1928 OH_JSVM_HasElement(env, testArray, testLen1, &hasElement);
1929 if (hasElement) {
1930 OH_JSVM_ThrowError(env, nullptr, "TestArrayDeleteMultipleTimes_02:OH_JSVM_HasElement Failed");
1931 return nullptr;
1932 }
1933 JSVM_Status status = OH_JSVM_DeleteElement(env, testArray, testLen1, &rst);
1934 if (status != JSVM_OK) {
1935 OH_JSVM_ThrowError(env, nullptr, "TestArrayDeleteMultipleTimes_02:OH_JSVM_DeleteElement 1 Failed.");
1936 return nullptr;
1937 }
1938
1939 bool setValue = true;
1940 JSVM_Value retValue = nullptr;
1941 OH_JSVM_GetBoolean(env, setValue, &retValue);
1942 return retValue;
1943 }