1 /*
2 * Copyright (c) 2021-2024 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include <chrono>
17 #include <thread>
18
19 #include "test.h"
20 #include "test_common.h"
21 #include "gtest/gtest.h"
22 #include "napi/native_api.h"
23 #include "napi/native_node_api.h"
24 #include "napi/native_common.h"
25 #include "securec.h"
26 #include "utils/log.h"
27
28 static constexpr size_t TEST_STR_LENGTH = 30;
29
30 class NapiSendableTest : public NativeEngineTest {
31 public:
SetUpTestCase()32 static void SetUpTestCase()
33 {
34 GTEST_LOG_(INFO) << "NapiSendableTest SetUpTestCase";
35 }
36
TearDownTestCase()37 static void TearDownTestCase()
38 {
39 GTEST_LOG_(INFO) << "NapiSendableTest TearDownTestCase";
40 }
41
SetUp()42 void SetUp() override
43 {
44 napi_env env = reinterpret_cast<napi_env>(engine_);
45 napi_open_handle_scope(env, &scope_);
46 }
47
TearDown()48 void TearDown() override
49 {
50 napi_env env = reinterpret_cast<napi_env>(engine_);
51 napi_value exception = nullptr;
52 napi_get_and_clear_last_exception(env, &exception);
53 napi_close_handle_scope(env, scope_);
54 }
55 private:
56 napi_handle_scope scope_ = nullptr;
57 };
58
GetSendableClass(napi_env env)59 napi_value GetSendableClass(napi_env env)
60 {
61 auto constructor = [](napi_env env, napi_callback_info info) -> napi_value {
62 napi_value thisVar = nullptr;
63 napi_get_cb_info(env, info, nullptr, nullptr, &thisVar, nullptr);
64 return thisVar;
65 };
66
67 napi_value static_str;
68 napi_value non_static_str;
69 napi_value instance_str;
70 napi_create_string_utf8(env, "static", NAPI_AUTO_LENGTH, &static_str);
71 napi_create_string_utf8(env, "nonStatic", NAPI_AUTO_LENGTH, &non_static_str);
72 napi_create_string_utf8(env, "instance", NAPI_AUTO_LENGTH, &instance_str);
73
74 napi_property_attributes napi_instance = static_cast<napi_property_attributes>(1 << 9 | 1 << 0);
75 napi_property_descriptor desc[] = { DECLARE_NAPI_STATIC_PROPERTY("static", static_str),
76 DECLARE_NAPI_DEFAULT_PROPERTY("nonStatic", non_static_str),
77 { "instance", nullptr, nullptr, nullptr, nullptr, instance_str, napi_instance,
78 nullptr } };
79
80 napi_value sendableClass = nullptr;
81 napi_define_sendable_class(env, "SendableClass", NAPI_AUTO_LENGTH, constructor, nullptr,
82 sizeof(desc) / sizeof(desc[0]), desc, nullptr, &sendableClass);
83
84 return sendableClass;
85 }
86
GetSendableChildClass(napi_env env,napi_value parentClass)87 napi_value GetSendableChildClass(napi_env env, napi_value parentClass)
88 {
89 auto constructor = [](napi_env env, napi_callback_info info) -> napi_value {
90 napi_value thisVar = nullptr;
91 napi_get_cb_info(env, info, nullptr, nullptr, &thisVar, nullptr);
92 return thisVar;
93 };
94
95 napi_value static_str;
96 napi_value non_static_str;
97 napi_value instance_str;
98 napi_create_string_utf8(env, "static", NAPI_AUTO_LENGTH, &static_str);
99 napi_create_string_utf8(env, "nonStatic", NAPI_AUTO_LENGTH, &non_static_str);
100 napi_create_string_utf8(env, "instance", NAPI_AUTO_LENGTH, &instance_str);
101
102 napi_property_attributes napi_instance = static_cast<napi_property_attributes>(1 << 9 | 1 << 0);
103 napi_property_descriptor desc[] = { DECLARE_NAPI_STATIC_PROPERTY("static", static_str),
104 DECLARE_NAPI_DEFAULT_PROPERTY("nonStatic", non_static_str),
105 { "instance", nullptr, nullptr, nullptr, nullptr, instance_str, napi_instance,
106 nullptr } };
107
108 napi_value childClass = nullptr;
109 napi_define_sendable_class(env, "SendableClass", NAPI_AUTO_LENGTH, constructor, nullptr,
110 sizeof(desc) / sizeof(desc[0]), desc, parentClass, &childClass);
111
112 return childClass;
113 }
114
GetSendableParentClass(napi_env env)115 napi_value GetSendableParentClass(napi_env env)
116 {
117 auto constructor = [](napi_env env, napi_callback_info info) -> napi_value {
118 napi_value thisVar = nullptr;
119 napi_get_cb_info(env, info, nullptr, nullptr, &thisVar, nullptr);
120 return thisVar;
121 };
122
123 napi_value parent_static_str;
124 napi_value parent_non_static_str;
125 napi_value parent_instance_str;
126 napi_create_string_utf8(env, "parentStatic", NAPI_AUTO_LENGTH, &parent_static_str);
127 napi_create_string_utf8(env, "parentNonStatic", NAPI_AUTO_LENGTH, &parent_non_static_str);
128 napi_create_string_utf8(env, "parentInstance", NAPI_AUTO_LENGTH, &parent_instance_str);
129
130 napi_property_attributes napi_instance = static_cast<napi_property_attributes>(1 << 9 | 1 << 0);
131 napi_property_descriptor parentDesc[] = { DECLARE_NAPI_STATIC_PROPERTY("parentStatic", parent_static_str),
132 DECLARE_NAPI_DEFAULT_PROPERTY("parentNonStatic", parent_non_static_str),
133 { "parentInstance", nullptr, nullptr, nullptr, nullptr,
134 parent_instance_str, napi_instance, nullptr } };
135
136 napi_value parentClass = nullptr;
137 napi_define_sendable_class(env, "ParentClass", NAPI_AUTO_LENGTH, constructor, nullptr,
138 sizeof(parentDesc) / sizeof(parentDesc[0]), parentDesc, nullptr, &parentClass);
139
140 return parentClass;
141 }
142
143 HWTEST_F(NapiSendableTest, IsSendableTest001, testing::ext::TestSize.Level1)
144 {
145 ASSERT_NE(engine_, nullptr);
146 napi_env env = reinterpret_cast<napi_env>(engine_);
147 napi_status res = napi_ok;
148
149 res = napi_create_sendable_map(env, nullptr);
150 ASSERT_EQ(res, napi_invalid_arg);
151
152 napi_value result = nullptr;
153 ASSERT_CHECK_CALL(napi_create_sendable_map(env, &result));
154
155 bool isShared = false;
156 ASSERT_CHECK_CALL(napi_is_sendable(env, result, &isShared));
157 ASSERT_EQ(isShared, true);
158 }
159
160 HWTEST_F(NapiSendableTest, IsSendableTest002, testing::ext::TestSize.Level1)
161 {
162 static size_t LENGTH = 1024;
163 ASSERT_NE(engine_, nullptr);
164 napi_env env = reinterpret_cast<napi_env>(engine_);
165 napi_status res = napi_ok;
166
167 void *data;
168 napi_value arraybuffer = nullptr;
169 res = napi_create_arraybuffer(env, LENGTH, &data, &arraybuffer);
170 ASSERT_EQ(res, napi_ok);
171
172 bool isShared = false;
173 res = napi_is_sendable(env, arraybuffer, &isShared);
174 ASSERT_EQ(res, napi_ok);
175 ASSERT_EQ(isShared, false);
176 }
177
178 HWTEST_F(NapiSendableTest, SendableClassTest001, testing::ext::TestSize.Level1)
179 {
180 napi_env env = (napi_env)engine_;
181
__anoncd28cf5c0402(napi_env env, napi_callback_info info) 182 auto constructor = [](napi_env env, napi_callback_info info) -> napi_value {
183 napi_value thisVar = nullptr;
184 napi_get_cb_info(env, info, nullptr, nullptr, &thisVar, nullptr);
185 return thisVar;
186 };
187
188 napi_value static_str;
189 napi_value non_static_str;
190 napi_value name_str;
191 ASSERT_CHECK_CALL(napi_create_string_utf8(env, "static", NAPI_AUTO_LENGTH, &static_str));
192 ASSERT_CHECK_CALL(napi_create_string_utf8(env, "nonStatic", NAPI_AUTO_LENGTH, &non_static_str));
193 ASSERT_CHECK_CALL(napi_create_string_utf8(env, "name", NAPI_AUTO_LENGTH, &name_str));
194
195 napi_property_descriptor desc[] = {
196 DECLARE_NAPI_STATIC_PROPERTY("static", static_str),
197 DECLARE_NAPI_DEFAULT_PROPERTY("nonStatic", non_static_str),
198 DECLARE_NAPI_STATIC_FUNCTION("staticFunc",
__anoncd28cf5c0502() 199 [](napi_env env, napi_callback_info info) -> napi_value { return nullptr; }),
__anoncd28cf5c0602() 200 DECLARE_NAPI_FUNCTION("func", [](napi_env env, napi_callback_info info) -> napi_value { return nullptr; }),
201 DECLARE_NAPI_GETTER_SETTER(
__anoncd28cf5c0702() 202 "getterSetter", [](napi_env env, napi_callback_info info) -> napi_value { return nullptr; },
__anoncd28cf5c0802() 203 [](napi_env env, napi_callback_info info) -> napi_value { return nullptr; }),
204 };
205
206 napi_value sendableClass = nullptr;
207 ASSERT_CHECK_CALL(napi_define_sendable_class(env, "SendableClass", NAPI_AUTO_LENGTH, constructor, nullptr,
208 sizeof(desc) / sizeof(desc[0]), desc, nullptr, &sendableClass));
209
210 napi_value value = nullptr;
211 char* str = new char[TEST_STR_LENGTH];
212 size_t length;
213
214 ASSERT_CHECK_CALL(napi_get_property(env, sendableClass, name_str, &value));
215 ASSERT_CHECK_CALL(napi_get_value_string_utf8(env, value, str, TEST_STR_LENGTH, &length));
216 ASSERT_STREQ("SendableClass", str);
217 ASSERT_CHECK_VALUE_TYPE(env, sendableClass, napi_function);
218 }
219
220
221 HWTEST_F(NapiSendableTest, SendableClassTest002, testing::ext::TestSize.Level1)
222 {
223 napi_env env = (napi_env)engine_;
224
__anoncd28cf5c0902(napi_env env, napi_callback_info info) 225 auto constructor = [](napi_env env, napi_callback_info info) -> napi_value {
226 napi_value thisVar = nullptr;
227 napi_get_cb_info(env, info, nullptr, nullptr, &thisVar, nullptr);
228 return thisVar;
229 };
230
231 napi_value static_str;
232 napi_value non_static_str;
233 napi_value invalid_str;
234 ASSERT_CHECK_CALL(napi_create_string_utf8(env, "static", NAPI_AUTO_LENGTH, &static_str));
235 ASSERT_CHECK_CALL(napi_create_string_utf8(env, "nonStatic", NAPI_AUTO_LENGTH, &non_static_str));
236 ASSERT_CHECK_CALL(napi_create_string_utf8(env, "invalid", NAPI_AUTO_LENGTH, &invalid_str));
237
238 napi_property_attributes napi_writable_static = static_cast<napi_property_attributes>(napi_static | napi_writable);
239 napi_property_descriptor desc[] = {
240 { "static", nullptr, nullptr, nullptr, nullptr, static_str, napi_writable_static, nullptr },
241 DECLARE_NAPI_DEFAULT_PROPERTY("nonStatic", non_static_str),
242 };
243
244 napi_value sendableClass = nullptr;
245 ASSERT_CHECK_CALL(napi_define_sendable_class(env, "SendableClass", NAPI_AUTO_LENGTH, constructor, nullptr,
246 sizeof(desc) / sizeof(desc[0]), desc, nullptr, &sendableClass));
247
248 napi_value value = nullptr;
249 char* str = new char[TEST_STR_LENGTH];
250 size_t length;
251
252 // get static property from constructor
253 ASSERT_CHECK_CALL(napi_get_property(env, sendableClass, static_str, &value));
254 ASSERT_CHECK_CALL(napi_get_value_string_utf8(env, value, str, TEST_STR_LENGTH, &length));
255 ASSERT_STREQ("static", str);
256 // get invalid property from constructor
257 ASSERT_CHECK_CALL(napi_get_property(env, sendableClass, invalid_str, &value));
258 ASSERT_CHECK_VALUE_TYPE(env, value, napi_undefined);
259
260 napi_value static_value;
261 napi_value non_static_value;
262 napi_value invalid_value;
263 napi_value exception = nullptr;
264 bool isExceptionPending = false;
265 ASSERT_CHECK_CALL(napi_create_string_utf8(env, "static0", NAPI_AUTO_LENGTH, &static_value));
266 ASSERT_CHECK_CALL(napi_create_string_utf8(env, "nonStatic0", NAPI_AUTO_LENGTH, &non_static_value));
267 ASSERT_CHECK_CALL(napi_create_string_utf8(env, "invalid", NAPI_AUTO_LENGTH, &invalid_value));
268
269 // set static property on constructor
270 napi_set_property(env, sendableClass, static_str, static_value);
271 ASSERT_CHECK_CALL(napi_get_property(env, sendableClass, static_str, &value));
272 ASSERT_CHECK_CALL(napi_get_value_string_utf8(env, value, str, TEST_STR_LENGTH, &length));
273 ASSERT_STREQ("static0", str);
274
275 // set invalid property on constructor
276 napi_is_exception_pending(env, &isExceptionPending);
277 ASSERT_FALSE(isExceptionPending);
278 napi_set_property(env, sendableClass, invalid_str, invalid_value);
279 napi_is_exception_pending(env, &isExceptionPending);
280 ASSERT_TRUE(isExceptionPending);
281 napi_get_and_clear_last_exception(env, &exception);
282 ASSERT_CHECK_CALL(napi_get_property(env, sendableClass, invalid_str, &value));
283 ASSERT_CHECK_VALUE_TYPE(env, value, napi_undefined);
284 }
285
286 HWTEST_F(NapiSendableTest, SendableClassTest003, testing::ext::TestSize.Level1)
287 {
288 napi_env env = (napi_env)engine_;
289
290 napi_value sendableClass = GetSendableClass(env);
291 napi_value non_static_str;
292 napi_value invalid_str;
293 napi_value instance_str;
294 ASSERT_CHECK_CALL(napi_create_string_utf8(env, "nonStatic", NAPI_AUTO_LENGTH, &non_static_str));
295 ASSERT_CHECK_CALL(napi_create_string_utf8(env, "invalid", NAPI_AUTO_LENGTH, &invalid_str));
296 ASSERT_CHECK_CALL(napi_create_string_utf8(env, "instance", NAPI_AUTO_LENGTH, &instance_str));
297
298 // new instance
299 napi_value sendableInstance = nullptr;
300 ASSERT_CHECK_CALL(napi_new_instance(env, sendableClass, 0, nullptr, &sendableInstance));
301 bool isInstanceOf = false;
302 ASSERT_CHECK_CALL(napi_instanceof(env, sendableInstance, sendableClass, &isInstanceOf));
303 ASSERT_TRUE(isInstanceOf);
304
305 // get prototype
306 napi_value prototype = nullptr;
307 ASSERT_CHECK_CALL(napi_get_prototype(env, sendableInstance, &prototype));
308 ASSERT_CHECK_VALUE_TYPE(env, prototype, napi_object);
309
310 napi_value value = nullptr;
311 char* str = new char[TEST_STR_LENGTH];
312 size_t length;
313 napi_value instance_value;
314 napi_value non_static_value;
315 napi_value invalid_value;
316 ASSERT_CHECK_CALL(napi_create_string_utf8(env, "instance", NAPI_AUTO_LENGTH, &instance_value));
317 ASSERT_CHECK_CALL(napi_create_string_utf8(env, "nonStatic0", NAPI_AUTO_LENGTH, &non_static_value));
318 ASSERT_CHECK_CALL(napi_create_string_utf8(env, "invalid", NAPI_AUTO_LENGTH, &invalid_value));
319
320 // get initial instance property
321 ASSERT_CHECK_CALL(napi_get_property(env, sendableInstance, instance_str, &value));
322 ASSERT_CHECK_VALUE_TYPE(env, value, napi_undefined);
323 // set instance property
324 napi_set_property(env, sendableInstance, instance_str, instance_value);
325 ASSERT_CHECK_CALL(napi_get_property(env, sendableInstance, instance_str, &value));
326 ASSERT_CHECK_CALL(napi_get_value_string_utf8(env, value, str, TEST_STR_LENGTH, &length));
327 ASSERT_STREQ("instance", str);
328
329 // get non static property from instance
330 ASSERT_CHECK_CALL(napi_get_property(env, sendableInstance, non_static_str, &value));
331 ASSERT_CHECK_CALL(napi_get_value_string_utf8(env, value, str, TEST_STR_LENGTH, &length));
332 ASSERT_STREQ("nonStatic", str);
333 // set non static property on prototype and get from instance
334 napi_set_property(env, prototype, non_static_str, non_static_value);
335 ASSERT_CHECK_CALL(napi_get_property(env, sendableInstance, non_static_str, &value));
336 ASSERT_CHECK_CALL(napi_get_value_string_utf8(env, value, str, TEST_STR_LENGTH, &length));
337 ASSERT_STREQ("nonStatic0", str);
338 }
339
340 HWTEST_F(NapiSendableTest, SendableClassTest004, testing::ext::TestSize.Level1)
341 {
342 napi_env env = (napi_env)engine_;
343
344 napi_value sendableClass = GetSendableClass(env);
345 napi_value non_static_str;
346 napi_value invalid_str;
347 napi_value instance_str;
348 ASSERT_CHECK_CALL(napi_create_string_utf8(env, "nonStatic", NAPI_AUTO_LENGTH, &non_static_str));
349 ASSERT_CHECK_CALL(napi_create_string_utf8(env, "invalid", NAPI_AUTO_LENGTH, &invalid_str));
350 ASSERT_CHECK_CALL(napi_create_string_utf8(env, "instance", NAPI_AUTO_LENGTH, &instance_str));
351
352 // new instance
353 napi_value sendableInstance = nullptr;
354 ASSERT_CHECK_CALL(napi_new_instance(env, sendableClass, 0, nullptr, &sendableInstance));
355 bool isInstanceOf = false;
356 ASSERT_CHECK_CALL(napi_instanceof(env, sendableInstance, sendableClass, &isInstanceOf));
357 ASSERT_TRUE(isInstanceOf);
358
359 napi_value value = nullptr;
360 char* str = new char[TEST_STR_LENGTH];
361 size_t length;
362 napi_value non_static_value;
363 napi_value invalid_value;
364 napi_value exception = nullptr;
365 bool isExceptionPending = false;
366 ASSERT_CHECK_CALL(napi_create_string_utf8(env, "nonStatic0", NAPI_AUTO_LENGTH, &non_static_value));
367 ASSERT_CHECK_CALL(napi_create_string_utf8(env, "invalid", NAPI_AUTO_LENGTH, &invalid_value));
368
369 // set non static property on instance
370 napi_is_exception_pending(env, &isExceptionPending);
371 ASSERT_FALSE(isExceptionPending);
372 napi_set_property(env, sendableInstance, non_static_str, non_static_value);
373 napi_is_exception_pending(env, &isExceptionPending);
374 ASSERT_TRUE(isExceptionPending);
375 napi_get_and_clear_last_exception(env, &exception);
376 ASSERT_CHECK_CALL(napi_get_property(env, sendableInstance, non_static_str, &value));
377 ASSERT_CHECK_CALL(napi_get_value_string_utf8(env, value, str, TEST_STR_LENGTH, &length));
378 ASSERT_STREQ("nonStatic", str);
379
380 // set invalid property on instance
381 napi_is_exception_pending(env, &isExceptionPending);
382 ASSERT_FALSE(isExceptionPending);
383 napi_set_property(env, sendableInstance, invalid_str, invalid_value);
384 napi_is_exception_pending(env, &isExceptionPending);
385 ASSERT_TRUE(isExceptionPending);
386 napi_get_and_clear_last_exception(env, &exception);
387 ASSERT_CHECK_CALL(napi_get_property(env, sendableInstance, invalid_str, &value));
388 ASSERT_CHECK_VALUE_TYPE(env, value, napi_undefined);
389 }
390
391
392 HWTEST_F(NapiSendableTest, SendableClassTest005, testing::ext::TestSize.Level1)
393 {
394 napi_env env = (napi_env)engine_;
395
396 napi_value parentClass = GetSendableParentClass(env);
397 napi_value sendableClass = GetSendableChildClass(env, parentClass);
398 napi_value parent_static_str;
399 napi_value parent_non_static_str;
400 napi_value parent_instance_str;
401 napi_create_string_utf8(env, "parentStatic", NAPI_AUTO_LENGTH, &parent_static_str);
402 napi_create_string_utf8(env, "parentNonStatic", NAPI_AUTO_LENGTH, &parent_non_static_str);
403 napi_create_string_utf8(env, "parentInstance", NAPI_AUTO_LENGTH, &parent_instance_str);
404
405 // new instance
406 napi_value sendableInstance = nullptr;
407 ASSERT_CHECK_CALL(napi_new_instance(env, sendableClass, 0, nullptr, &sendableInstance));
408 bool isInstanceOf = false;
409 bool isInstanceOfParent = false;
410 ASSERT_CHECK_CALL(napi_instanceof(env, sendableInstance, sendableClass, &isInstanceOf));
411 ASSERT_CHECK_CALL(napi_instanceof(env, sendableInstance, parentClass, &isInstanceOfParent));
412 ASSERT_TRUE(isInstanceOf);
413 ASSERT_TRUE(isInstanceOfParent);
414
415 napi_value value = nullptr;
416 char* str = new char[TEST_STR_LENGTH];
417 size_t length;
418 napi_value parent_instance_value;
419 ASSERT_CHECK_CALL(napi_create_string_utf8(env, "parentInstance", NAPI_AUTO_LENGTH, &parent_instance_value));
420
421 // get parent instance property on instance
422 ASSERT_CHECK_CALL(napi_get_property(env, sendableInstance, parent_instance_str, &value));
423 ASSERT_CHECK_VALUE_TYPE(env, value, napi_undefined);
424 // set parent instance property on instance
425 napi_set_property(env, sendableInstance, parent_instance_str, parent_instance_value);
426 ASSERT_CHECK_CALL(napi_get_property(env, sendableInstance, parent_instance_str, &value));
427 ASSERT_CHECK_CALL(napi_get_value_string_utf8(env, value, str, TEST_STR_LENGTH, &length));
428 ASSERT_STREQ("parentInstance", str);
429
430 // get parent static property from constructor
431 ASSERT_CHECK_CALL(napi_get_property(env, sendableClass, parent_static_str, &value));
432 ASSERT_CHECK_CALL(napi_get_value_string_utf8(env, value, str, TEST_STR_LENGTH, &length));
433 ASSERT_STREQ("parentStatic", str);
434
435 // get parent non static property from instance
436 ASSERT_CHECK_CALL(napi_get_property(env, sendableInstance, parent_non_static_str, &value));
437 ASSERT_CHECK_CALL(napi_get_value_string_utf8(env, value, str, TEST_STR_LENGTH, &length));
438 ASSERT_STREQ("parentNonStatic", str);
439 }
440
441 /**
442 * @tc.name: CreateSendableMap001
443 * @tc.desc: Test napi_create_sendable_map.
444 * @tc.type: FUNC
445 */
446 HWTEST_F(NapiSendableTest, CreateSendableMap001, testing::ext::TestSize.Level1)
447 {
448 ASSERT_NE(engine_, nullptr);
449 napi_env env = reinterpret_cast<napi_env>(engine_);
450 napi_status res = napi_ok;
451
452 res = napi_create_sendable_map(env, nullptr);
453 ASSERT_EQ(res, napi_invalid_arg);
454
455 napi_value result = nullptr;
456 ASSERT_CHECK_CALL(napi_create_sendable_map(env, &result));
457
458 bool isShared = false;
459 ASSERT_CHECK_CALL(napi_is_sendable(env, result, &isShared));
460 ASSERT_EQ(isShared, true);
461
462 bool isMap = false;
463 ASSERT_CHECK_CALL(napi_is_map(env, result, &isMap));
464 ASSERT_EQ(isMap, true);
465 }
466
467 /**
468 * @tc.name: CreateSendableMap002
469 * @tc.desc: Test napi_create_sendable_map.
470 * @tc.type: FUNC
471 */
472 HWTEST_F(NapiSendableTest, CreateSendableMap002, testing::ext::TestSize.Level1)
473 {
474 ASSERT_NE(engine_, nullptr);
475 napi_env env = reinterpret_cast<napi_env>(engine_);
476
477 napi_value result = nullptr;
478 ASSERT_CHECK_CALL(napi_create_sendable_map(env, &result));
479
480 uint32_t length = 0;
481 napi_value value = nullptr;
482 bool hasKey = false;
483
484 napi_value key = nullptr;
485 ASSERT_CHECK_CALL(napi_create_string_utf8(env, "null", NAPI_AUTO_LENGTH, &key));
486 napi_value null = nullptr;
487 ASSERT_CHECK_CALL(napi_get_null(env, &null));
488 napi_value undefined = nullptr;
489 ASSERT_CHECK_CALL(napi_get_undefined(env, &undefined));
490
491 ASSERT_CHECK_CALL(napi_map_set_property(env, result, key, null));
492 ASSERT_CHECK_CALL(napi_map_get_size(env, result, &length));
493 ASSERT_EQ(length, 1);
494 ASSERT_CHECK_CALL(napi_map_has_property(env, result, key, &hasKey));
495 ASSERT_TRUE(hasKey);
496 ASSERT_CHECK_CALL(napi_map_get_property(env, result, key, &value));
497 ASSERT_CHECK_VALUE_TYPE(env, value, napi_null);
498
499 ASSERT_CHECK_CALL(napi_map_delete_property(env, result, key));
500 ASSERT_CHECK_CALL(napi_map_get_size(env, result, &length));
501 ASSERT_EQ(length, 0);
502 ASSERT_CHECK_CALL(napi_map_has_property(env, result, key, &hasKey));
503 ASSERT_FALSE(hasKey);
504 ASSERT_CHECK_CALL(napi_map_get_property(env, result, key, &value));
505 ASSERT_CHECK_VALUE_TYPE(env, value, napi_undefined);
506 }
507
508 /**
509 * @tc.name: CreateSendableMap003
510 * @tc.desc: Test napi_create_sendable_map.
511 * @tc.type: FUNC
512 */
513 HWTEST_F(NapiSendableTest, CreateSendableMap003, testing::ext::TestSize.Level1)
514 {
515 ASSERT_NE(engine_, nullptr);
516 napi_env env = reinterpret_cast<napi_env>(engine_);
517
518 napi_value result = nullptr;
519 ASSERT_CHECK_CALL(napi_create_sendable_map(env, &result));
520
521 uint32_t length = 0;
522 napi_value value = nullptr;
523 bool hasKey = false;
524
525 const char* key = "null";
526 napi_value null = nullptr;
527 ASSERT_CHECK_CALL(napi_get_null(env, &null));
528 napi_value undefined = nullptr;
529 ASSERT_CHECK_CALL(napi_get_undefined(env, &undefined));
530
531 ASSERT_CHECK_CALL(napi_map_set_named_property(env, result, key, null));
532 ASSERT_CHECK_CALL(napi_map_get_size(env, result, &length));
533 ASSERT_EQ(length, 1);
534 ASSERT_CHECK_CALL(napi_map_has_named_property(env, result, key, &hasKey));
535 ASSERT_TRUE(hasKey);
536 ASSERT_CHECK_CALL(napi_map_get_named_property(env, result, key, &value));
537 ASSERT_CHECK_VALUE_TYPE(env, value, napi_null);
538
539 ASSERT_CHECK_CALL(napi_map_clear(env, result));
540 ASSERT_CHECK_CALL(napi_map_get_size(env, result, &length));
541 ASSERT_EQ(length, 0);
542 ASSERT_CHECK_CALL(napi_map_has_named_property(env, result, key, &hasKey));
543 ASSERT_FALSE(hasKey);
544 ASSERT_CHECK_CALL(napi_map_get_named_property(env, result, key, &value));
545 ASSERT_CHECK_VALUE_TYPE(env, value, napi_undefined);
546
547 bool isExceptionPending = false;
548 napi_is_exception_pending(env, &isExceptionPending);
549 ASSERT_FALSE(isExceptionPending);
550
551 napi_value object = nullptr;
552 ASSERT_CHECK_CALL(napi_create_object(env, &object));
553 napi_status res = napi_map_set_named_property(env, result, key, object);
554 ASSERT_TRUE(res == napi_pending_exception);
555 }
556
557 /**
558 * @tc.name: CreateSendableMap004
559 * @tc.desc: Test napi_create_sendable_map.
560 * @tc.type: FUNC
561 */
562 HWTEST_F(NapiSendableTest, CreateSendableMap004, testing::ext::TestSize.Level1)
563 {
564 ASSERT_NE(engine_, nullptr);
565 napi_env env = reinterpret_cast<napi_env>(engine_);
566
567 napi_value map = nullptr;
568 ASSERT_CHECK_CALL(napi_create_sendable_map(env, &map));
569
570 napi_value zero = nullptr;
571 ASSERT_CHECK_CALL(napi_create_int32(env, 0, &zero));
572 napi_value one = nullptr;
573 ASSERT_CHECK_CALL(napi_create_int32(env, 1, &one));
574
575 ASSERT_CHECK_CALL(napi_map_set_property(env, map, zero, one));
576
577 napi_value entries;
578 ASSERT_CHECK_CALL(napi_map_get_entries(env, map, &entries));
579
580 napi_value entries0;
581 ASSERT_CHECK_CALL(napi_map_iterator_get_next(env, entries, &entries0));
582 napi_value entries0Value = nullptr;
583 ASSERT_CHECK_CALL(napi_get_named_property(env, entries0, "value", &entries0Value));
584 napi_value key = nullptr;
585 ASSERT_CHECK_CALL(napi_get_element(env, entries0Value, 0, &key));
586 int32_t nativeKey;
587 ASSERT_CHECK_CALL(napi_get_value_int32(env, key, &nativeKey));
588 ASSERT_EQ(nativeKey, 0);
589 napi_value value = nullptr;
590 ASSERT_CHECK_CALL(napi_get_element(env, entries0Value, 1, &value));
591 int32_t nativeValue;
592 ASSERT_CHECK_CALL(napi_get_value_int32(env, value, &nativeValue));
593 ASSERT_EQ(nativeValue, 1);
594
595 napi_value end;
596 ASSERT_CHECK_CALL(napi_map_iterator_get_next(env, entries, &end));
597 napi_value done = nullptr;
598 ASSERT_CHECK_CALL(napi_get_named_property(env, end, "done", &done));
599 bool isDone;
600 ASSERT_CHECK_CALL(napi_get_value_bool(env, done, &isDone));
601 ASSERT_TRUE(isDone);
602 }
603
604 /**
605 * @tc.name: CreateSendableMap005
606 * @tc.desc: Test napi_create_sendable_map.
607 * @tc.type: FUNC
608 */
609 HWTEST_F(NapiSendableTest, CreateSendableMap005, testing::ext::TestSize.Level1)
610 {
611 ASSERT_NE(engine_, nullptr);
612 napi_env env = reinterpret_cast<napi_env>(engine_);
613
614 napi_value map = nullptr;
615 ASSERT_CHECK_CALL(napi_create_sendable_map(env, &map));
616
617 napi_value zero = nullptr;
618 ASSERT_CHECK_CALL(napi_create_int32(env, 0, &zero));
619 napi_value one = nullptr;
620 ASSERT_CHECK_CALL(napi_create_int32(env, 1, &one));
621
622 ASSERT_CHECK_CALL(napi_map_set_property(env, map, zero, one));
623
624 napi_value keys;
625 ASSERT_CHECK_CALL(napi_map_get_keys(env, map, &keys));
626
627 napi_value keys0;
628 ASSERT_CHECK_CALL(napi_map_iterator_get_next(env, keys, &keys0));
629 napi_value key = nullptr;
630 ASSERT_CHECK_CALL(napi_get_named_property(env, keys0, "value", &key));
631 int32_t nativeKey;
632 ASSERT_CHECK_CALL(napi_get_value_int32(env, key, &nativeKey));
633 ASSERT_EQ(nativeKey, 0);
634
635 napi_value end;
636 ASSERT_CHECK_CALL(napi_map_iterator_get_next(env, keys, &end));
637 napi_value done = nullptr;
638 ASSERT_CHECK_CALL(napi_get_named_property(env, end, "done", &done));
639 bool isDone;
640 ASSERT_CHECK_CALL(napi_get_value_bool(env, done, &isDone));
641 ASSERT_TRUE(isDone);
642 }
643
644 /**
645 * @tc.name: CreateSendableMap006
646 * @tc.desc: Test napi_create_sendable_map.
647 * @tc.type: FUNC
648 */
649 HWTEST_F(NapiSendableTest, CreateSendableMap006, testing::ext::TestSize.Level1)
650 {
651 ASSERT_NE(engine_, nullptr);
652 napi_env env = reinterpret_cast<napi_env>(engine_);
653
654 napi_value map = nullptr;
655 ASSERT_CHECK_CALL(napi_create_sendable_map(env, &map));
656
657 napi_value zero = nullptr;
658 ASSERT_CHECK_CALL(napi_create_int32(env, 0, &zero));
659 napi_value one = nullptr;
660 ASSERT_CHECK_CALL(napi_create_int32(env, 1, &one));
661
662 ASSERT_CHECK_CALL(napi_map_set_property(env, map, zero, one));
663
664 napi_value values;
665 ASSERT_CHECK_CALL(napi_map_get_values(env, map, &values));
666
667 napi_value values0;
668 ASSERT_CHECK_CALL(napi_map_iterator_get_next(env, values, &values0));
669 napi_value value = nullptr;
670 ASSERT_CHECK_CALL(napi_get_named_property(env, values0, "value", &value));
671 int32_t nativeValue;
672 ASSERT_CHECK_CALL(napi_get_value_int32(env, value, &nativeValue));
673 ASSERT_EQ(nativeValue, 1);
674
675 napi_value end;
676 ASSERT_CHECK_CALL(napi_map_iterator_get_next(env, values, &end));
677 napi_value done = nullptr;
678 ASSERT_CHECK_CALL(napi_get_named_property(env, end, "done", &done));
679 bool isDone;
680 ASSERT_CHECK_CALL(napi_get_value_bool(env, done, &isDone));
681 ASSERT_TRUE(isDone);
682 }
683
684 HWTEST_F(NapiSendableTest, WrapSendableTest001, testing::ext::TestSize.Level1)
685 {
686 napi_env env = (napi_env)engine_;
687 napi_status res = napi_ok;
688
689 napi_value testClass = nullptr;
690 res = napi_define_sendable_class(
691 env, "TestClass", NAPI_AUTO_LENGTH,
__anoncd28cf5c0a02(napi_env env, napi_callback_info info) 692 [](napi_env env, napi_callback_info info) -> napi_value {
693 napi_value thisVar = nullptr;
694 napi_get_cb_info(env, info, nullptr, nullptr, &thisVar, nullptr);
695 return thisVar;
696 },
697 nullptr, 0, nullptr, nullptr, &testClass);
698 ASSERT_EQ(res, napi_ok);
699
700 napi_value instanceValue = nullptr;
701 res = napi_new_instance(env, testClass, 0, nullptr, &instanceValue);
702 ASSERT_EQ(res, napi_ok);
703
704 const char* testStr = "test";
705 res = napi_wrap_sendable(
__anoncd28cf5c0b02(napi_env env, void* data, void* hint) 706 env, instanceValue, (void*)testStr, [](napi_env env, void* data, void* hint) {}, nullptr);
707 ASSERT_EQ(res, napi_ok);
708
709 char* tmpTestStr = nullptr;
710 res = napi_unwrap_sendable(env, instanceValue, (void**)&tmpTestStr);
711 ASSERT_EQ(res, napi_ok);
712 ASSERT_STREQ(testStr, tmpTestStr);
713
714 char* tmpTestStr1 = nullptr;
715 res = napi_remove_wrap_sendable(env, instanceValue, (void**)&tmpTestStr1);
716 ASSERT_EQ(res, napi_ok);
717 ASSERT_STREQ(testStr, tmpTestStr1);
718 }
719
720 HWTEST_F(NapiSendableTest, WrapSendableWithSizeTest001, testing::ext::TestSize.Level1)
721 {
722 napi_env env = (napi_env)engine_;
723
724 napi_value testWrapClass = nullptr;
725 napi_define_sendable_class(
726 env, "TestWrapClass", NAPI_AUTO_LENGTH,
__anoncd28cf5c0c02(napi_env env, napi_callback_info info) 727 [](napi_env env, napi_callback_info info) -> napi_value {
728 napi_value thisVar = nullptr;
729 napi_get_cb_info(env, info, nullptr, nullptr, &thisVar, nullptr);
730 return thisVar;
731 },
732 nullptr, 0, nullptr, nullptr, &testWrapClass);
733
734 napi_value instanceValue = nullptr;
735 napi_new_instance(env, testWrapClass, 0, nullptr, &instanceValue);
736
737 const char* testWrapStr = "testWrapStr";
738 size_t size = sizeof(*testWrapStr) / sizeof(char);
739 napi_wrap_sendable_with_size(
__anoncd28cf5c0d02(napi_env env, void* data, void* hint) 740 env, instanceValue, (void*)testWrapStr, [](napi_env env, void* data, void* hint) {}, nullptr, size);
741
742 char* tempTestStr = nullptr;
743 napi_unwrap_sendable(env, instanceValue, (void**)&tempTestStr);
744 ASSERT_STREQ(testWrapStr, tempTestStr);
745
746 char* tempTestStr1 = nullptr;
747 napi_remove_wrap_sendable(env, instanceValue, (void**)&tempTestStr1);
748 ASSERT_STREQ(testWrapStr, tempTestStr1);
749 }
750
751 /**
752 * @tc.name: SharedArrayBufferTest001
753 * @tc.desc: Test is shared array buffer.
754 * @tc.type: FUNC
755 */
756 HWTEST_F(NapiSendableTest, SharedArrayBufferTest001, testing::ext::TestSize.Level1) {
757 napi_env env = (napi_env) engine_;
758
759 napi_value arrayBuffer = nullptr;
760 void* arrayBufferPtr = nullptr;
761 size_t arrayBufferSize = 1024;
762 napi_create_arraybuffer(env, arrayBufferSize, &arrayBufferPtr, &arrayBuffer);
763
764 bool isSharedArrayBuffer = true;
765 napi_is_shared_array_buffer(env, arrayBuffer, &isSharedArrayBuffer);
766 ASSERT_EQ(isSharedArrayBuffer, false);
767 }
768
769
770 /**
771 * @tc.name: CreateSendableArray001
772 * @tc.desc: Test napi_create_sendable_array abnormal argument.
773 * @tc.type: FUNC
774 */
775 HWTEST_F(NapiSendableTest, CreateSendableArray001, testing::ext::TestSize.Level1)
776 {
777 ASSERT_NE(engine_, nullptr);
778 napi_env env = reinterpret_cast<napi_env>(engine_);
779 napi_status res = napi_ok;
780
781 res = napi_create_sendable_array(env, nullptr);
782 ASSERT_EQ(res, napi_invalid_arg);
783 }
784
785 /**
786 * @tc.name: CreateSendableArray002
787 * @tc.desc: Test napi_create_sendable_array.
788 * @tc.type: FUNC
789 */
790 HWTEST_F(NapiSendableTest, CreateSendableArray002, testing::ext::TestSize.Level1)
791 {
792 ASSERT_NE(engine_, nullptr);
793 napi_env env = reinterpret_cast<napi_env>(engine_);
794 napi_status res = napi_ok;
795
796 napi_value result = nullptr;
797 res = napi_create_sendable_array(env, &result);
798 ASSERT_EQ(res, napi_ok);
799
800 bool isShared = false;
801 res = napi_is_sendable(env, result, &isShared);
802 ASSERT_EQ(res, napi_ok);
803 ASSERT_EQ(isShared, true);
804
805 bool isArray = false;
806 res = napi_is_array(env, result, &isArray);
807 ASSERT_EQ(res, napi_ok);
808 ASSERT_EQ(isArray, true);
809
810 uint32_t length = 0;
811 res = napi_get_array_length(env, result, &length);
812 ASSERT_EQ(res, napi_ok);
813 ASSERT_EQ(length, 0);
814
815 napi_value undefined = nullptr;
816 res = napi_get_undefined(env, &undefined);
817 ASSERT_EQ(res, napi_ok);
818
819 res = napi_set_element(env, result, 0, undefined);
820 ASSERT_EQ(res, napi_ok);
821 }
822
823 /**
824 * @tc.name: CreateSendableArrayWithLength001
825 * @tc.desc: Test napi_create_sendable_array_with_length.
826 * @tc.type: FUNC
827 */
828 HWTEST_F(NapiSendableTest, CreateSendableArrayWithLength001, testing::ext::TestSize.Level1)
829 {
830 ASSERT_NE(engine_, nullptr);
831 napi_env env = reinterpret_cast<napi_env>(engine_);
832 napi_status res = napi_ok;
833
834 res = napi_create_sendable_array_with_length(env, 0, nullptr);
835 ASSERT_EQ(res, napi_invalid_arg);
836 }
837
838 /**
839 * @tc.name: CreateSendableArrayWithLength002
840 * @tc.desc: Test napi_create_sendable_array_with_length.
841 * @tc.type: FUNC
842 */
843 HWTEST_F(NapiSendableTest, CreateSendableArrayWithLength002, testing::ext::TestSize.Level1)
844 {
845 ASSERT_NE(engine_, nullptr);
846 napi_env env = reinterpret_cast<napi_env>(engine_);
847 napi_status res = napi_ok;
848
849 napi_value result = nullptr;
850 res = napi_create_sendable_array_with_length(env, 0, &result);
851 ASSERT_EQ(res, napi_ok);
852
853 bool isShared = false;
854 res = napi_is_sendable(env, result, &isShared);
855 ASSERT_EQ(res, napi_ok);
856 ASSERT_EQ(isShared, true);
857
858 bool isArray = false;
859 res = napi_is_array(env, result, &isArray);
860 ASSERT_EQ(res, napi_ok);
861 ASSERT_EQ(isArray, true);
862
863 uint32_t length = 0;
864 res = napi_get_array_length(env, result, &length);
865 ASSERT_EQ(res, napi_ok);
866 ASSERT_EQ(length, 0);
867 }
868
869 /**
870 * @tc.name: CreateSendableArrayWithLength003
871 * @tc.desc: Test napi_create_sendable_array_with_length.
872 * @tc.type: FUNC
873 */
874 HWTEST_F(NapiSendableTest, CreateSendableArrayWithLength003, testing::ext::TestSize.Level1)
875 {
876 static uint32_t LENGTH = 1024;
877 ASSERT_NE(engine_, nullptr);
878 napi_env env = reinterpret_cast<napi_env>(engine_);
879 napi_status res = napi_ok;
880
881 napi_value result = nullptr;
882 res = napi_create_sendable_array_with_length(env, LENGTH, &result);
883 ASSERT_EQ(res, napi_ok);
884
885 bool isShared = false;
886 res = napi_is_sendable(env, result, &isShared);
887 ASSERT_EQ(res, napi_ok);
888 ASSERT_EQ(isShared, true);
889
890 bool isArray = false;
891 res = napi_is_array(env, result, &isArray);
892 ASSERT_EQ(res, napi_ok);
893 ASSERT_EQ(isArray, true);
894
895 uint32_t length = 0;
896 res = napi_get_array_length(env, result, &length);
897 ASSERT_EQ(res, napi_ok);
898 ASSERT_EQ(length, LENGTH);
899
900 napi_value value = nullptr;
901 napi_value boolTrue = nullptr;
902 bool ret = false;
903 res = napi_get_boolean(env, true, &boolTrue);
904 ASSERT_EQ(res, napi_ok);
905
906 res = napi_set_element(env, result, 0, boolTrue);
907 ASSERT_EQ(res, napi_ok);
908 res = napi_get_element(env, result, 0, &value);
909 ASSERT_EQ(res, napi_ok);
910 res = napi_get_value_bool(env, value, &ret);
911 ASSERT_EQ(res, napi_ok);
912 ASSERT_EQ(ret, true);
913
914 res = napi_set_element(env, result, LENGTH - 1, boolTrue);
915 ASSERT_EQ(res, napi_ok);
916 res = napi_get_element(env, result, LENGTH - 1, &value);
917 ASSERT_EQ(res, napi_ok);
918 res = napi_get_value_bool(env, value, &ret);
919 ASSERT_EQ(res, napi_ok);
920 ASSERT_EQ(ret, true);
921 }
922
923 /**
924 * @tc.name: CreateSendableArrayWithLength004
925 * @tc.desc: Test napi_create_sendable_array_with_length.
926 * @tc.type: FUNC
927 */
928 HWTEST_F(NapiSendableTest, CreateSendableArrayWithLength004, testing::ext::TestSize.Level1)
929 {
930 static uint32_t LENGTH = 1024;
931 ASSERT_NE(engine_, nullptr);
932 napi_env env = reinterpret_cast<napi_env>(engine_);
933 napi_status res = napi_ok;
934
935 napi_value result = nullptr;
936 res = napi_create_sendable_array_with_length(env, LENGTH, &result);
937 ASSERT_EQ(res, napi_ok);
938
939 bool isShared = false;
940 res = napi_is_sendable(env, result, &isShared);
941 ASSERT_EQ(res, napi_ok);
942 ASSERT_EQ(isShared, true);
943
944 bool isArray = false;
945 res = napi_is_array(env, result, &isArray);
946 ASSERT_EQ(res, napi_ok);
947 ASSERT_EQ(isArray, true);
948
949 uint32_t length = 0;
950 res = napi_get_array_length(env, result, &length);
951 ASSERT_EQ(res, napi_ok);
952 ASSERT_EQ(length, LENGTH);
953
954 napi_value value = nullptr;
955 napi_value boolTrue = nullptr;
956 bool ret = false;
957 res = napi_get_boolean(env, true, &boolTrue);
958 ASSERT_EQ(res, napi_ok);
959
960 res = napi_get_element(env, result, 1, &value);
961 ASSERT_EQ(res, napi_ok);
962 napi_valuetype type = napi_undefined;
963 res = napi_typeof(env, value, &type);
964 ASSERT_EQ(res, napi_ok);
965 ASSERT_EQ(napi_undefined, napi_undefined);
966
967 res = napi_set_element(env, result, LENGTH, boolTrue);
968 ASSERT_EQ(res, napi_ok);
969 res = napi_get_element(env, result, LENGTH, &value);
970 ASSERT_EQ(res, napi_ok);
971 res = napi_get_value_bool(env, value, &ret);
972 ASSERT_EQ(res, napi_ok);
973 ASSERT_EQ(ret, true);
974
975 res = napi_get_element(env, result, LENGTH + 1, &value);
976 ASSERT_EQ(res, napi_ok);
977 napi_valuetype getType = napi_undefined;
978 res = napi_typeof(env, value, &getType);
979 ASSERT_EQ(res, napi_ok);
980 ASSERT_EQ(getType, napi_undefined);
981 }
982
983 /**
984 * @tc.name: CreateSendableArrayBuffer001
985 * @tc.desc: Test napi_create_sendable_arraybuffer.
986 * @tc.type: FUNC
987 */
988 HWTEST_F(NapiSendableTest, CreateSendableArrayBuffer001, testing::ext::TestSize.Level1)
989 {
990 static size_t LENGTH = 1024;
991 ASSERT_NE(engine_, nullptr);
992 napi_env env = reinterpret_cast<napi_env>(engine_);
993 napi_status res = napi_ok;
994
995 napi_value result = nullptr;
996 res = napi_create_sendable_arraybuffer(env, LENGTH, nullptr, &result);
997 ASSERT_EQ(res, napi_invalid_arg);
998
999 void *data;
1000 res = napi_create_sendable_arraybuffer(env, LENGTH, &data, nullptr);
1001 ASSERT_EQ(res, napi_invalid_arg);
1002
1003 res = napi_create_sendable_arraybuffer(env, LENGTH, nullptr, nullptr);
1004 ASSERT_EQ(res, napi_invalid_arg);
1005 }
1006
1007 /**
1008 * @tc.name: CreateSendableArrayBuffer002
1009 * @tc.desc: Test napi_create_sendable_arraybuffer.
1010 * @tc.type: FUNC
1011 */
1012 HWTEST_F(NapiSendableTest, CreateSendableArrayBuffer002, testing::ext::TestSize.Level1)
1013 {
1014 static size_t LENGTH = 1024;
1015 ASSERT_NE(engine_, nullptr);
1016 napi_env env = reinterpret_cast<napi_env>(engine_);
1017 napi_status res = napi_ok;
1018
1019 void *data;
1020 napi_value result = nullptr;
1021 res = napi_create_sendable_arraybuffer(env, LENGTH, &data, &result);
1022 ASSERT_EQ(res, napi_ok);
1023
1024 bool isShared = false;
1025 res = napi_is_sendable(env, result, &isShared);
1026 ASSERT_EQ(res, napi_ok);
1027 ASSERT_EQ(isShared, true);
1028
1029 bool isArrayBuffer = false;
1030 res = napi_is_arraybuffer(env, result, &isArrayBuffer);
1031 ASSERT_EQ(res, napi_ok);
1032 ASSERT_EQ(isArrayBuffer, true);
1033
1034 void *getData = nullptr;
1035 size_t length = 0;
1036 res = napi_get_arraybuffer_info(env, result, &getData, &length);
1037 ASSERT_EQ(res, napi_ok);
1038 ASSERT_EQ(length, LENGTH);
1039 ASSERT_EQ(getData, data);
1040 }
1041
1042 /**
1043 * @tc.name: CreateSendableTypedArray001
1044 * @tc.desc: Test napi_create_sendable_arraybuffer.
1045 * @tc.type: FUNC
1046 */
1047 HWTEST_F(NapiSendableTest, CreateSendableTypedArray001, testing::ext::TestSize.Level1)
1048 {
1049 static size_t LENGTH = 1024;
1050 ASSERT_NE(engine_, nullptr);
1051 napi_env env = reinterpret_cast<napi_env>(engine_);
1052 napi_status res = napi_ok;
1053
1054 void *data;
1055 napi_value arraybuffer = nullptr;
1056 napi_value result = nullptr;
1057 res = napi_create_sendable_arraybuffer(env, LENGTH, &data, &arraybuffer);
1058 ASSERT_EQ(res, napi_ok);
1059
1060 bool isShared = false;
1061 res = napi_is_sendable(env, arraybuffer, &isShared);
1062 ASSERT_EQ(res, napi_ok);
1063 ASSERT_EQ(isShared, true);
1064
1065 res = napi_create_sendable_typedarray(env, napi_uint8_clamped_array, LENGTH / 2, arraybuffer, 1, &result);
1066 ASSERT_EQ(res, napi_ok);
1067
1068 res = napi_create_sendable_typedarray(env, napi_uint8_array, LENGTH / 2, arraybuffer, 1, nullptr);
1069 ASSERT_EQ(res, napi_invalid_arg);
1070
1071 res = napi_create_sendable_typedarray(env, napi_uint8_array, LENGTH / 2, nullptr, 1, &result);
1072 ASSERT_EQ(res, napi_invalid_arg);
1073
1074 res = napi_create_sendable_typedarray(env, napi_int8_array, LENGTH / 2, nullptr, 1, &result);
1075 ASSERT_EQ(res, napi_invalid_arg);
1076
1077 res = napi_create_sendable_typedarray(env, napi_int8_array, LENGTH / 2, nullptr, 1, &result);
1078 ASSERT_EQ(res, napi_invalid_arg);
1079
1080 res = napi_create_sendable_typedarray(env, napi_uint16_array, LENGTH / 2, nullptr, 1, &result);
1081 ASSERT_EQ(res, napi_invalid_arg);
1082
1083 res = napi_create_sendable_typedarray(env, napi_uint16_array, LENGTH / 2, nullptr, 1, &result);
1084 ASSERT_EQ(res, napi_invalid_arg);
1085
1086 res = napi_create_sendable_typedarray(env, napi_int32_array, LENGTH / 2, nullptr, 1, &result);
1087 ASSERT_EQ(res, napi_invalid_arg);
1088
1089 res = napi_create_sendable_typedarray(env, napi_int32_array, LENGTH / 2, nullptr, 1, &result);
1090 ASSERT_EQ(res, napi_invalid_arg);
1091
1092 res = napi_create_sendable_typedarray(env, napi_uint32_array, LENGTH / 2, nullptr, 1, &result);
1093 ASSERT_EQ(res, napi_invalid_arg);
1094
1095 res = napi_create_sendable_typedarray(env, napi_uint32_array, LENGTH / 2, nullptr, 1, &result);
1096 ASSERT_EQ(res, napi_invalid_arg);
1097
1098 res = napi_create_sendable_typedarray(env, napi_float32_array, LENGTH / 2, nullptr, 1, &result);
1099 ASSERT_EQ(res, napi_invalid_arg);
1100
1101 res = napi_create_sendable_typedarray(env, napi_float32_array, LENGTH / 2, nullptr, 1, &result);
1102 ASSERT_EQ(res, napi_invalid_arg);
1103 }
1104
1105 /**
1106 * @tc.name: CreateSendableTypedArray002
1107 * @tc.desc: Test napi_create_sendable_arraybuffer.
1108 * @tc.type: FUNC
1109 */
1110 HWTEST_F(NapiSendableTest, CreateSendableTypedArray002, testing::ext::TestSize.Level1)
1111 {
1112 static size_t LENGTH = 1024;
1113 static size_t OFFSET = 128;
1114 ASSERT_NE(engine_, nullptr);
1115 napi_env env = reinterpret_cast<napi_env>(engine_);
1116 napi_status res = napi_ok;
1117
1118 void *data;
1119 napi_value arraybuffer = nullptr;
1120 res = napi_create_sendable_arraybuffer(env, LENGTH, &data, &arraybuffer);
1121 ASSERT_EQ(res, napi_ok);
1122
1123 napi_value result = nullptr;
1124 res = napi_create_sendable_typedarray(env, napi_uint8_array, LENGTH / 2, arraybuffer, OFFSET, &result);
1125 ASSERT_EQ(res, napi_ok);
1126
1127 bool isShared = false;
1128 res = napi_is_sendable(env, result, &isShared);
1129 ASSERT_EQ(res, napi_ok);
1130 ASSERT_EQ(isShared, true);
1131
1132 bool isTypedArray = false;
1133 res = napi_is_typedarray(env, result, &isTypedArray);
1134 ASSERT_EQ(res, napi_ok);
1135 ASSERT_EQ(isTypedArray, true);
1136
1137 napi_typedarray_type type = napi_int8_array;
1138 size_t length = 0;
1139 void *getData = nullptr;
1140 napi_value getArrayBuffer = nullptr;
1141 size_t byteOffset = 0;
1142 res = napi_get_typedarray_info(env, result, &type, &length, &getData, &getArrayBuffer, &byteOffset);
1143 ASSERT_EQ(res, napi_ok);
1144
1145 bool isEqual = false;
1146 res = napi_strict_equals(env, arraybuffer, getArrayBuffer, &isEqual);
1147 ASSERT_EQ(res, napi_ok);
1148
1149 ASSERT_EQ(type, napi_uint8_array);
1150 ASSERT_EQ(length, LENGTH / 2);
1151 ASSERT_EQ(reinterpret_cast<size_t>(getData), reinterpret_cast<size_t>(data) + OFFSET);
1152 ASSERT_EQ(isEqual, true);
1153 ASSERT_EQ(byteOffset, OFFSET);
1154 }
1155
1156 /**
1157 * @tc.name: CreateSendableTypedArray003
1158 * @tc.desc: Test napi_create_sendable_arraybuffer.
1159 * @tc.type: FUNC
1160 */
1161 HWTEST_F(NapiSendableTest, CreateSendableTypedArray003, testing::ext::TestSize.Level1)
1162 {
1163 static size_t LENGTH = 1024;
1164 static size_t OFFSET = 128;
1165 ASSERT_NE(engine_, nullptr);
1166 napi_env env = reinterpret_cast<napi_env>(engine_);
1167 napi_status res = napi_ok;
1168
1169 void *data;
1170 napi_value arraybuffer = nullptr;
1171 res = napi_create_sendable_arraybuffer(env, LENGTH, &data, &arraybuffer);
1172 ASSERT_EQ(res, napi_ok);
1173
1174 napi_value result = nullptr;
1175 res = napi_create_sendable_typedarray(env, napi_int8_array, LENGTH / 2, arraybuffer, OFFSET, &result);
1176 ASSERT_EQ(res, napi_ok);
1177
1178 bool isShared = false;
1179 res = napi_is_sendable(env, result, &isShared);
1180 ASSERT_EQ(res, napi_ok);
1181 ASSERT_EQ(isShared, true);
1182
1183 bool isTypedArray = false;
1184 res = napi_is_typedarray(env, result, &isTypedArray);
1185 ASSERT_EQ(res, napi_ok);
1186 ASSERT_EQ(isTypedArray, true);
1187
1188 napi_typedarray_type type = napi_uint8_array;
1189 size_t length = 0;
1190 void *getData = nullptr;
1191 napi_value getArrayBuffer = nullptr;
1192 size_t byteOffset = 0;
1193 res = napi_get_typedarray_info(env, result, &type, &length, &getData, &getArrayBuffer, &byteOffset);
1194 ASSERT_EQ(res, napi_ok);
1195
1196 bool isEqual = false;
1197 res = napi_strict_equals(env, arraybuffer, getArrayBuffer, &isEqual);
1198 ASSERT_EQ(res, napi_ok);
1199
1200 ASSERT_EQ(type, napi_int8_array);
1201 ASSERT_EQ(length, LENGTH / 2);
1202 ASSERT_EQ(reinterpret_cast<size_t>(getData), reinterpret_cast<size_t>(data) + OFFSET);
1203 ASSERT_EQ(isEqual, true);
1204 ASSERT_EQ(byteOffset, OFFSET);
1205 }
1206
1207 /**
1208 * @tc.name: CreateSendableTypedArray004
1209 * @tc.desc: Test napi_create_sendable_arraybuffer.
1210 * @tc.type: FUNC
1211 */
1212 HWTEST_F(NapiSendableTest, CreateSendableTypedArray004, testing::ext::TestSize.Level1)
1213 {
1214 static size_t LENGTH = 1024;
1215 static size_t OFFSET = 0;
1216 ASSERT_NE(engine_, nullptr);
1217 napi_env env = reinterpret_cast<napi_env>(engine_);
1218 napi_status res = napi_ok;
1219
1220 void *data;
1221 napi_value arraybuffer = nullptr;
1222 res = napi_create_sendable_arraybuffer(env, LENGTH, &data, &arraybuffer);
1223 ASSERT_EQ(res, napi_ok);
1224
1225 napi_value result = nullptr;
1226 res = napi_create_sendable_typedarray(env, napi_int16_array, LENGTH / 2, arraybuffer, OFFSET, &result);
1227 ASSERT_EQ(res, napi_ok);
1228
1229 bool isShared = false;
1230 res = napi_is_sendable(env, result, &isShared);
1231 ASSERT_EQ(res, napi_ok);
1232 ASSERT_EQ(isShared, true);
1233
1234 bool isTypedArray = false;
1235 res = napi_is_typedarray(env, result, &isTypedArray);
1236 ASSERT_EQ(res, napi_ok);
1237 ASSERT_EQ(isTypedArray, true);
1238
1239 napi_typedarray_type type = napi_uint8_array;
1240 size_t length = 0;
1241 void *getData = nullptr;
1242 napi_value getArrayBuffer = nullptr;
1243 size_t byteOffset = 0;
1244 res = napi_get_typedarray_info(env, result, &type, &length, &getData, &getArrayBuffer, &byteOffset);
1245 ASSERT_EQ(res, napi_ok);
1246
1247 bool isEqual = false;
1248 res = napi_strict_equals(env, arraybuffer, getArrayBuffer, &isEqual);
1249 ASSERT_EQ(res, napi_ok);
1250
1251 ASSERT_EQ(type, napi_int16_array);
1252 ASSERT_EQ(length, LENGTH);
1253 ASSERT_EQ(reinterpret_cast<size_t>(getData), reinterpret_cast<size_t>(data) + OFFSET);
1254 ASSERT_EQ(isEqual, true);
1255 ASSERT_EQ(byteOffset, OFFSET);
1256 }
1257
1258 /**
1259 * @tc.name: CreateSendableTypedArray005
1260 * @tc.desc: Test napi_create_sendable_arraybuffer.
1261 * @tc.type: FUNC
1262 */
1263 HWTEST_F(NapiSendableTest, CreateSendableTypedArray005, testing::ext::TestSize.Level1)
1264 {
1265 static size_t LENGTH = 1024;
1266 static size_t OFFSET = 0;
1267 ASSERT_NE(engine_, nullptr);
1268 napi_env env = reinterpret_cast<napi_env>(engine_);
1269 napi_status res = napi_ok;
1270
1271 void *data;
1272 napi_value arraybuffer = nullptr;
1273 res = napi_create_sendable_arraybuffer(env, LENGTH, &data, &arraybuffer);
1274 ASSERT_EQ(res, napi_ok);
1275
1276 napi_value result = nullptr;
1277 res = napi_create_sendable_typedarray(env, napi_uint16_array, LENGTH / 2, arraybuffer, OFFSET, &result);
1278 ASSERT_EQ(res, napi_ok);
1279
1280 bool isShared = false;
1281 res = napi_is_sendable(env, result, &isShared);
1282 ASSERT_EQ(res, napi_ok);
1283 ASSERT_EQ(isShared, true);
1284
1285 bool isTypedArray = false;
1286 res = napi_is_typedarray(env, result, &isTypedArray);
1287 ASSERT_EQ(res, napi_ok);
1288 ASSERT_EQ(isTypedArray, true);
1289
1290 napi_typedarray_type type = napi_uint8_array;
1291 size_t length = 0;
1292 void *getData = nullptr;
1293 napi_value getArrayBuffer = nullptr;
1294 size_t byteOffset = 0;
1295 res = napi_get_typedarray_info(env, result, &type, &length, &getData, &getArrayBuffer, &byteOffset);
1296 ASSERT_EQ(res, napi_ok);
1297
1298 bool isEqual = false;
1299 res = napi_strict_equals(env, arraybuffer, getArrayBuffer, &isEqual);
1300 ASSERT_EQ(res, napi_ok);
1301
1302 ASSERT_EQ(type, napi_uint16_array);
1303 ASSERT_EQ(length, LENGTH);
1304 ASSERT_EQ(reinterpret_cast<size_t>(getData), reinterpret_cast<size_t>(data) + OFFSET);
1305 ASSERT_EQ(isEqual, true);
1306 ASSERT_EQ(byteOffset, OFFSET);
1307 }
1308
1309 /**
1310 * @tc.name: CreateSendableTypedArray006
1311 * @tc.desc: Test napi_create_sendable_arraybuffer.
1312 * @tc.type: FUNC
1313 */
1314 HWTEST_F(NapiSendableTest, CreateSendableTypedArray006, testing::ext::TestSize.Level1)
1315 {
1316 static size_t LENGTH = 1024;
1317 static size_t OFFSET = 0;
1318 ASSERT_NE(engine_, nullptr);
1319 napi_env env = reinterpret_cast<napi_env>(engine_);
1320 napi_status res = napi_ok;
1321
1322 void *data;
1323 napi_value arraybuffer = nullptr;
1324 res = napi_create_sendable_arraybuffer(env, LENGTH * 2, &data, &arraybuffer);
1325 ASSERT_EQ(res, napi_ok);
1326
1327 napi_value result = nullptr;
1328 res = napi_create_sendable_typedarray(env, napi_uint32_array, LENGTH / 2, arraybuffer, OFFSET, &result);
1329 ASSERT_EQ(res, napi_ok);
1330
1331 bool isShared = false;
1332 res = napi_is_sendable(env, result, &isShared);
1333 ASSERT_EQ(res, napi_ok);
1334 ASSERT_EQ(isShared, true);
1335
1336 bool isTypedArray = false;
1337 res = napi_is_typedarray(env, result, &isTypedArray);
1338 ASSERT_EQ(res, napi_ok);
1339 ASSERT_EQ(isTypedArray, true);
1340
1341 napi_typedarray_type type = napi_int8_array;
1342 size_t length = 0;
1343 void *getData = nullptr;
1344 napi_value getArrayBuffer = nullptr;
1345 size_t byteOffset = 0;
1346 res = napi_get_typedarray_info(env, result, &type, &length, &getData, &getArrayBuffer, &byteOffset);
1347 ASSERT_EQ(res, napi_ok);
1348
1349 bool isEqual = false;
1350 res = napi_strict_equals(env, arraybuffer, getArrayBuffer, &isEqual);
1351 ASSERT_EQ(res, napi_ok);
1352
1353 ASSERT_EQ(type, napi_uint32_array);
1354 ASSERT_EQ(length, LENGTH * 2);
1355 ASSERT_EQ(reinterpret_cast<size_t>(getData), reinterpret_cast<size_t>(data) + OFFSET);
1356 ASSERT_EQ(isEqual, true);
1357 ASSERT_EQ(byteOffset, OFFSET);
1358 }
1359
1360 /**
1361 * @tc.name: CreateSendableTypedArray007
1362 * @tc.desc: Test napi_create_sendable_arraybuffer.
1363 * @tc.type: FUNC
1364 */
1365 HWTEST_F(NapiSendableTest, CreateSendableTypedArray007, testing::ext::TestSize.Level1)
1366 {
1367 static size_t LENGTH = 1024;
1368 static size_t OFFSET = 0;
1369 ASSERT_NE(engine_, nullptr);
1370 napi_env env = reinterpret_cast<napi_env>(engine_);
1371 napi_status res = napi_ok;
1372
1373 void *data;
1374 napi_value arraybuffer = nullptr;
1375 res = napi_create_sendable_arraybuffer(env, LENGTH * 2, &data, &arraybuffer);
1376 ASSERT_EQ(res, napi_ok);
1377
1378 napi_value result = nullptr;
1379 res = napi_create_sendable_typedarray(env, napi_int32_array, LENGTH / 2, arraybuffer, OFFSET, &result);
1380 ASSERT_EQ(res, napi_ok);
1381
1382 bool isShared = false;
1383 res = napi_is_sendable(env, result, &isShared);
1384 ASSERT_EQ(res, napi_ok);
1385 ASSERT_EQ(isShared, true);
1386
1387 bool isTypedArray = false;
1388 res = napi_is_typedarray(env, result, &isTypedArray);
1389 ASSERT_EQ(res, napi_ok);
1390 ASSERT_EQ(isTypedArray, true);
1391
1392 napi_typedarray_type type = napi_int8_array;
1393 size_t length = 0;
1394 void *getData = nullptr;
1395 napi_value getArrayBuffer = nullptr;
1396 size_t byteOffset = 0;
1397 res = napi_get_typedarray_info(env, result, &type, &length, &getData, &getArrayBuffer, &byteOffset);
1398 ASSERT_EQ(res, napi_ok);
1399
1400 bool isEqual = false;
1401 res = napi_strict_equals(env, arraybuffer, getArrayBuffer, &isEqual);
1402 ASSERT_EQ(res, napi_ok);
1403
1404 ASSERT_EQ(type, napi_int32_array);
1405 ASSERT_EQ(length, LENGTH * 2);
1406 ASSERT_EQ(reinterpret_cast<size_t>(getData), reinterpret_cast<size_t>(data) + OFFSET);
1407 ASSERT_EQ(isEqual, true);
1408 ASSERT_EQ(byteOffset, OFFSET);
1409 }
1410
1411 /**
1412 * @tc.name: CreateSendableTypedArray008
1413 * @tc.desc: Test napi_create_sendable_arraybuffer.
1414 * @tc.type: FUNC
1415 */
1416 HWTEST_F(NapiSendableTest, CreateSendableTypedArray008, testing::ext::TestSize.Level1)
1417 {
1418 static size_t LENGTH = 1024;
1419 static size_t OFFSET = 0;
1420 ASSERT_NE(engine_, nullptr);
1421 napi_env env = reinterpret_cast<napi_env>(engine_);
1422 napi_status res = napi_ok;
1423
1424 void *data;
1425 napi_value arraybuffer = nullptr;
1426 res = napi_create_sendable_arraybuffer(env, LENGTH * 2, &data, &arraybuffer);
1427 ASSERT_EQ(res, napi_ok);
1428
1429 napi_value result = nullptr;
1430 res = napi_create_sendable_typedarray(env, napi_float32_array, LENGTH / 2, arraybuffer, OFFSET, &result);
1431 ASSERT_EQ(res, napi_ok);
1432
1433 bool isShared = false;
1434 res = napi_is_sendable(env, result, &isShared);
1435 ASSERT_EQ(res, napi_ok);
1436 ASSERT_EQ(isShared, true);
1437
1438 bool isTypedArray = false;
1439 res = napi_is_typedarray(env, result, &isTypedArray);
1440 ASSERT_EQ(res, napi_ok);
1441 ASSERT_EQ(isTypedArray, true);
1442
1443 napi_typedarray_type type = napi_int8_array;
1444 size_t length = 0;
1445 void *getData = nullptr;
1446 napi_value getArrayBuffer = nullptr;
1447 size_t byteOffset = 0;
1448 res = napi_get_typedarray_info(env, result, &type, &length, &getData, &getArrayBuffer, &byteOffset);
1449 ASSERT_EQ(res, napi_ok);
1450
1451 bool isEqual = false;
1452 res = napi_strict_equals(env, arraybuffer, getArrayBuffer, &isEqual);
1453 ASSERT_EQ(res, napi_ok);
1454
1455 ASSERT_EQ(type, napi_float32_array);
1456 ASSERT_EQ(length, LENGTH * 2);
1457 ASSERT_EQ(reinterpret_cast<size_t>(getData), reinterpret_cast<size_t>(data) + OFFSET);
1458 ASSERT_EQ(isEqual, true);
1459 ASSERT_EQ(byteOffset, OFFSET);
1460 }
1461
1462 /**
1463 * @tc.name: CreateSendableTypedArray009
1464 * @tc.desc: Test napi_create_sendable_arraybuffer.
1465 * @tc.type: FUNC
1466 */
1467 HWTEST_F(NapiSendableTest, CreateSendableTypedArray009, testing::ext::TestSize.Level1)
1468 {
1469 static size_t LENGTH = 1024;
1470 static size_t OFFSET = 128;
1471 ASSERT_NE(engine_, nullptr);
1472 napi_env env = reinterpret_cast<napi_env>(engine_);
1473 napi_status res = napi_ok;
1474
1475 void *data;
1476 napi_value arraybuffer = nullptr;
1477 res = napi_create_sendable_arraybuffer(env, LENGTH, &data, &arraybuffer);
1478 ASSERT_EQ(res, napi_ok);
1479
1480 napi_value result = nullptr;
1481 res = napi_create_sendable_typedarray(env, napi_uint8_clamped_array, LENGTH / 2, arraybuffer, OFFSET, &result);
1482 ASSERT_EQ(res, napi_ok);
1483
1484 bool isShared = false;
1485 res = napi_is_sendable(env, result, &isShared);
1486 ASSERT_EQ(res, napi_ok);
1487 ASSERT_EQ(isShared, true);
1488
1489 bool isTypedArray = false;
1490 res = napi_is_typedarray(env, result, &isTypedArray);
1491 ASSERT_EQ(res, napi_ok);
1492 ASSERT_EQ(isTypedArray, true);
1493
1494 napi_typedarray_type type = napi_uint8_array;
1495 size_t length = 0;
1496 void *getData = nullptr;
1497 napi_value getArrayBuffer = nullptr;
1498 size_t byteOffset = 0;
1499 res = napi_get_typedarray_info(env, result, &type, &length, &getData, &getArrayBuffer, &byteOffset);
1500 ASSERT_EQ(res, napi_ok);
1501
1502 bool isEqual = false;
1503 res = napi_strict_equals(env, arraybuffer, getArrayBuffer, &isEqual);
1504 ASSERT_EQ(res, napi_ok);
1505
1506 ASSERT_EQ(type, napi_uint8_clamped_array);
1507 ASSERT_EQ(length, LENGTH / 2);
1508 ASSERT_EQ(reinterpret_cast<size_t>(getData), reinterpret_cast<size_t>(data) + OFFSET);
1509 ASSERT_EQ(isEqual, true);
1510 ASSERT_EQ(byteOffset, OFFSET);
1511 }
1512
1513 /**
1514 * @tc.name: CreateSendableTypedArray010
1515 * @tc.desc: Test napi_create_sendable_typedarray with non-sendable arraybuffer.
1516 * @tc.type: FUNC
1517 */
1518 HWTEST_F(NapiSendableTest, CreateSendableTypedArray010, testing::ext::TestSize.Level1)
1519 {
1520 static size_t LENGTH = 1024;
1521 ASSERT_NE(engine_, nullptr);
1522 napi_env env = reinterpret_cast<napi_env>(engine_);
1523 napi_status res = napi_ok;
1524
1525 void *data;
1526 napi_value arraybuffer = nullptr;
1527 napi_value result = nullptr;
1528 res = napi_create_arraybuffer(env, LENGTH, &data, &arraybuffer);
1529 ASSERT_EQ(res, napi_ok);
1530
1531 bool isShared = false;
1532 res = napi_is_sendable(env, arraybuffer, &isShared);
1533 ASSERT_EQ(res, napi_ok);
1534 ASSERT_EQ(isShared, false);
1535
1536 res = napi_create_sendable_typedarray(env, napi_uint8_clamped_array, LENGTH / 2, arraybuffer, 1, &result);
1537 ASSERT_EQ(res, napi_arraybuffer_expected);
1538 }
1539
1540 /**
1541 * @tc.name: CreateSendableTypedArray011
1542 * @tc.desc: Test napi_create_sendable_typedarray with non-sendable arraybuffer.
1543 * @tc.type: FUNC
1544 */
1545 HWTEST_F(NapiSendableTest, CreateSendableTypedArray011, testing::ext::TestSize.Level1)
1546 {
1547 static size_t LENGTH = 1024;
1548 ASSERT_NE(engine_, nullptr);
1549 napi_env env = reinterpret_cast<napi_env>(engine_);
1550 napi_status res = napi_ok;
1551
1552 void *data;
1553 napi_value arraybuffer = nullptr;
1554 napi_value result = nullptr;
1555 res = napi_create_arraybuffer(env, LENGTH, &data, &arraybuffer);
1556 ASSERT_EQ(res, napi_ok);
1557
1558 bool isShared = false;
1559 res = napi_is_sendable(env, arraybuffer, &isShared);
1560 ASSERT_EQ(res, napi_ok);
1561 ASSERT_EQ(isShared, false);
1562
1563 res = napi_create_sendable_typedarray(env, napi_uint8_array, LENGTH / 2, arraybuffer, 1, &result);
1564 ASSERT_EQ(res, napi_arraybuffer_expected);
1565 }
1566
1567 /**
1568 * @tc.name: CreateSendableTypedArray012
1569 * @tc.desc: Test napi_create_sendable_typedarray with non-sendable arraybuffer.
1570 * @tc.type: FUNC
1571 */
1572 HWTEST_F(NapiSendableTest, CreateSendableTypedArray012, testing::ext::TestSize.Level1)
1573 {
1574 static size_t LENGTH = 1024;
1575 ASSERT_NE(engine_, nullptr);
1576 napi_env env = reinterpret_cast<napi_env>(engine_);
1577 napi_status res = napi_ok;
1578
1579 void *data;
1580 napi_value arraybuffer = nullptr;
1581 napi_value result = nullptr;
1582 res = napi_create_arraybuffer(env, LENGTH, &data, &arraybuffer);
1583 ASSERT_EQ(res, napi_ok);
1584
1585 bool isShared = false;
1586 res = napi_is_sendable(env, arraybuffer, &isShared);
1587 ASSERT_EQ(res, napi_ok);
1588 ASSERT_EQ(isShared, false);
1589
1590 res = napi_create_sendable_typedarray(env, napi_int8_array, LENGTH / 2, arraybuffer, 1, &result);
1591 ASSERT_EQ(res, napi_arraybuffer_expected);
1592 }
1593
1594 /**
1595 * @tc.name: CreateSendableTypedArray013
1596 * @tc.desc: Test napi_create_sendable_typedarray with non-sendable arraybuffer.
1597 * @tc.type: FUNC
1598 */
1599 HWTEST_F(NapiSendableTest, CreateSendableTypedArray013, testing::ext::TestSize.Level1)
1600 {
1601 static size_t LENGTH = 1024;
1602 ASSERT_NE(engine_, nullptr);
1603 napi_env env = reinterpret_cast<napi_env>(engine_);
1604 napi_status res = napi_ok;
1605
1606 void *data;
1607 napi_value arraybuffer = nullptr;
1608 napi_value result = nullptr;
1609 res = napi_create_arraybuffer(env, LENGTH, &data, &arraybuffer);
1610 ASSERT_EQ(res, napi_ok);
1611
1612 bool isShared = false;
1613 res = napi_is_sendable(env, arraybuffer, &isShared);
1614 ASSERT_EQ(res, napi_ok);
1615 ASSERT_EQ(isShared, false);
1616
1617 res = napi_create_sendable_typedarray(env, napi_uint16_array, LENGTH / 2, arraybuffer, 1, &result);
1618 ASSERT_EQ(res, napi_arraybuffer_expected);
1619 }
1620
1621 /**
1622 * @tc.name: CreateSendableTypedArray014
1623 * @tc.desc: Test napi_create_sendable_typedarray with non-sendable arraybuffer.
1624 * @tc.type: FUNC
1625 */
1626 HWTEST_F(NapiSendableTest, CreateSendableTypedArray014, testing::ext::TestSize.Level1)
1627 {
1628 static size_t LENGTH = 1024;
1629 ASSERT_NE(engine_, nullptr);
1630 napi_env env = reinterpret_cast<napi_env>(engine_);
1631 napi_status res = napi_ok;
1632
1633 void *data;
1634 napi_value arraybuffer = nullptr;
1635 napi_value result = nullptr;
1636 res = napi_create_arraybuffer(env, LENGTH, &data, &arraybuffer);
1637 ASSERT_EQ(res, napi_ok);
1638
1639 bool isShared = false;
1640 res = napi_is_sendable(env, arraybuffer, &isShared);
1641 ASSERT_EQ(res, napi_ok);
1642 ASSERT_EQ(isShared, false);
1643
1644 res = napi_create_sendable_typedarray(env, napi_int16_array, LENGTH / 2, arraybuffer, 1, &result);
1645 ASSERT_EQ(res, napi_arraybuffer_expected);
1646 }
1647
1648 /**
1649 * @tc.name: CreateSendableTypedArray015
1650 * @tc.desc: Test napi_create_sendable_typedarray with non-sendable arraybuffer.
1651 * @tc.type: FUNC
1652 */
1653 HWTEST_F(NapiSendableTest, CreateSendableTypedArray015, testing::ext::TestSize.Level1)
1654 {
1655 static size_t LENGTH = 1024;
1656 ASSERT_NE(engine_, nullptr);
1657 napi_env env = reinterpret_cast<napi_env>(engine_);
1658 napi_status res = napi_ok;
1659
1660 void *data;
1661 napi_value arraybuffer = nullptr;
1662 napi_value result = nullptr;
1663 res = napi_create_arraybuffer(env, LENGTH, &data, &arraybuffer);
1664 ASSERT_EQ(res, napi_ok);
1665
1666 bool isShared = false;
1667 res = napi_is_sendable(env, arraybuffer, &isShared);
1668 ASSERT_EQ(res, napi_ok);
1669 ASSERT_EQ(isShared, false);
1670
1671 res = napi_create_sendable_typedarray(env, napi_uint32_array, LENGTH / 2, arraybuffer, 1, &result);
1672 ASSERT_EQ(res, napi_arraybuffer_expected);
1673 }
1674
1675 /**
1676 * @tc.name: CreateSendableTypedArray016
1677 * @tc.desc: Test napi_create_sendable_typedarray with non-sendable arraybuffer.
1678 * @tc.type: FUNC
1679 */
1680 HWTEST_F(NapiSendableTest, CreateSendableTypedArray016, testing::ext::TestSize.Level1)
1681 {
1682 static size_t LENGTH = 1024;
1683 ASSERT_NE(engine_, nullptr);
1684 napi_env env = reinterpret_cast<napi_env>(engine_);
1685 napi_status res = napi_ok;
1686
1687 void *data;
1688 napi_value arraybuffer = nullptr;
1689 napi_value result = nullptr;
1690 res = napi_create_arraybuffer(env, LENGTH, &data, &arraybuffer);
1691 ASSERT_EQ(res, napi_ok);
1692
1693 bool isShared = false;
1694 res = napi_is_sendable(env, arraybuffer, &isShared);
1695 ASSERT_EQ(res, napi_ok);
1696 ASSERT_EQ(isShared, false);
1697
1698 res = napi_create_sendable_typedarray(env, napi_int32_array, LENGTH / 2, arraybuffer, 1, &result);
1699 ASSERT_EQ(res, napi_arraybuffer_expected);
1700 }
1701
1702 /**
1703 * @tc.name: CreateSendableTypedArray017
1704 * @tc.desc: Test napi_create_sendable_typedarray with non-sendable arraybuffer.
1705 * @tc.type: FUNC
1706 */
1707 HWTEST_F(NapiSendableTest, CreateSendableTypedArray017, testing::ext::TestSize.Level1)
1708 {
1709 static size_t LENGTH = 1024;
1710 ASSERT_NE(engine_, nullptr);
1711 napi_env env = reinterpret_cast<napi_env>(engine_);
1712 napi_status res = napi_ok;
1713
1714 void *data;
1715 napi_value arraybuffer = nullptr;
1716 napi_value result = nullptr;
1717 res = napi_create_arraybuffer(env, LENGTH, &data, &arraybuffer);
1718 ASSERT_EQ(res, napi_ok);
1719
1720 bool isShared = false;
1721 res = napi_is_sendable(env, arraybuffer, &isShared);
1722 ASSERT_EQ(res, napi_ok);
1723 ASSERT_EQ(isShared, false);
1724
1725 res = napi_create_sendable_typedarray(env, napi_float32_array, LENGTH / 2, arraybuffer, 1, &result);
1726 ASSERT_EQ(res, napi_arraybuffer_expected);
1727 }
1728
1729 /**
1730 * @tc.name: CreateSendableTypedArray018
1731 * @tc.desc: Test napi_create_sendable_arraybuffer.
1732 * @tc.type: FUNC
1733 */
1734 HWTEST_F(NapiSendableTest, CreateSendableTypedArray018, testing::ext::TestSize.Level1)
1735 {
1736 static size_t LENGTH = 1024;
1737 static size_t OFFSET = 0;
1738 ASSERT_NE(engine_, nullptr);
1739 napi_env env = reinterpret_cast<napi_env>(engine_);
1740
1741 void* data;
1742 napi_value arraybuffer = nullptr;
1743 ASSERT_CHECK_CALL(napi_create_sendable_arraybuffer(env, LENGTH, &data, &arraybuffer));
1744
1745 for (int type = napi_int8_array; type <= napi_float32_array; ++type) {
1746 napi_value result = nullptr;
1747 ASSERT_CHECK_CALL(napi_create_sendable_typedarray(env, static_cast<napi_typedarray_type>(type), LENGTH / 4,
1748 arraybuffer, OFFSET, &result));
1749 bool isTypedArray = false;
1750 ASSERT_CHECK_CALL(napi_is_typedarray(env, result, &isTypedArray));
1751 ASSERT_EQ(isTypedArray, true);
1752 }
1753 }
1754
1755 /**
1756 * @tc.name: IsDetachedSendableArrayBufferTest001
1757 * @tc.desc: Test is DetachedSendableArrayBuffer.
1758 * @tc.type: FUNC
1759 */
1760 HWTEST_F(NapiSendableTest, IsDetachedSendableArrayBufferTest001, testing::ext::TestSize.Level1)
1761 {
1762 static constexpr size_t arrayBufferSize = 1024;
1763 napi_env env = (napi_env)engine_;
1764 napi_value arrayBuffer = nullptr;
1765 void* arrayBufferPtr = nullptr;
1766 napi_create_sendable_arraybuffer(env, arrayBufferSize, &arrayBufferPtr, &arrayBuffer);
1767
1768 auto out = napi_detach_arraybuffer(env, arrayBuffer);
1769 if (out == napi_ok) {
1770 arrayBufferPtr = nullptr;
1771 }
1772 ASSERT_EQ(out, napi_ok);
1773 }
1774
SendableGetter(napi_env env,napi_callback_info info)1775 static napi_value SendableGetter(napi_env env, napi_callback_info info)
1776 {
1777 napi_value res;
1778 napi_get_boolean(env, false, &res);
1779 return res;
1780 }
1781
SendableSetter(napi_env env,napi_callback_info info)1782 static napi_value SendableSetter(napi_env env, napi_callback_info info)
1783 {
1784 napi_value res;
1785 napi_get_boolean(env, true, &res);
1786 return res;
1787 }
1788
1789 HWTEST_F(NapiSendableTest, CreateSendableObjectWithPropertiesTest001, testing::ext::TestSize.Level1)
1790 {
1791 napi_env env = (napi_env)engine_;
1792 napi_value excep;
1793 ASSERT_CHECK_CALL(napi_get_and_clear_last_exception(env, &excep));
1794 napi_value val_false;
1795 napi_value val_true;
1796 ASSERT_CHECK_CALL(napi_get_boolean(env, false, &val_false));
1797 ASSERT_CHECK_CALL(napi_get_boolean(env, true, &val_true));
1798 napi_property_descriptor desc1[] = {
1799 DECLARE_NAPI_DEFAULT_PROPERTY("x", val_true),
1800 };
1801 napi_value obj1;
1802 ASSERT_CHECK_CALL(napi_create_sendable_object_with_properties(env, 1, desc1, &obj1));
1803 napi_value obj2;
1804 napi_property_descriptor desc2[] = {
1805 DECLARE_NAPI_DEFAULT_PROPERTY("a", val_false),
1806 DECLARE_NAPI_GETTER_SETTER("b", SendableGetter, SendableSetter),
1807 DECLARE_NAPI_DEFAULT_PROPERTY("c", obj1),
1808 };
1809 ASSERT_CHECK_CALL(napi_create_sendable_object_with_properties(env, 3, desc2, &obj2));
1810 ASSERT_CHECK_VALUE_TYPE(env, obj1, napi_object);
1811 ASSERT_CHECK_VALUE_TYPE(env, obj2, napi_object);
__anoncd28cf5c0e02(napi_value obj, const char* keyStr, napi_value expect) 1812 auto checkPropertyEqualsTo = [env](napi_value obj, const char* keyStr, napi_value expect) -> bool {
1813 napi_value result;
1814 napi_get_named_property(env, obj, keyStr, &result);
1815 bool equal = false;
1816 napi_strict_equals(env, result, expect, &equal);
1817 return equal;
1818 };
1819 // get obj1.x == true
1820 ASSERT_TRUE(checkPropertyEqualsTo(obj1, "x", val_true));
1821 // set obj1.x = false
1822 ASSERT_CHECK_CALL(napi_set_named_property(env, obj1, "x", val_false));
1823 // get obj1.x == false
1824 ASSERT_TRUE(checkPropertyEqualsTo(obj1, "x", val_false));
1825 // get obj2.a == false
1826 ASSERT_TRUE(checkPropertyEqualsTo(obj2, "a", val_false));
1827 // get obj2.b == false
1828 ASSERT_TRUE(checkPropertyEqualsTo(obj2, "b", val_false));
1829 // set obj2.b = true (useless)
1830 ASSERT_CHECK_CALL(napi_set_named_property(env, obj2, "b", val_true));
1831 // get obj2.b == false
1832 ASSERT_TRUE(checkPropertyEqualsTo(obj2, "b", val_false));
1833 // get obj2.c == obj1
1834 ASSERT_TRUE(checkPropertyEqualsTo(obj2, "c", obj1));
1835 // get obj2.c.x == false
1836 napi_value val_res;
1837 ASSERT_CHECK_CALL(napi_get_named_property(env, obj2, "c", &val_res));
1838 ASSERT_TRUE(checkPropertyEqualsTo(val_res, "x", val_false));
1839 }
1840
1841 bool g_funcCalled = false;
Func(napi_env env,napi_callback_info info)1842 static napi_value Func(napi_env env, napi_callback_info info)
1843 {
1844 napi_value boolTrue = nullptr;
1845 napi_value boolFalse = nullptr;
1846 napi_get_boolean(env, true, &boolTrue);
1847 napi_get_boolean(env, false, &boolFalse);
1848
1849 if (g_funcCalled) {
1850 return boolFalse;
1851 }
1852
1853 char *data = nullptr;
1854 napi_value thisVar = nullptr;
1855 napi_get_cb_info(env, info, nullptr, nullptr, &thisVar, nullptr);
1856 napi_unwrap_sendable(env, thisVar, reinterpret_cast<void**>(&data));
1857 if (*data == 'a') {
1858 g_funcCalled = true;
1859 delete [] data;
1860 }
1861
1862 return boolTrue;
1863 }
1864
1865 HWTEST_F(NapiSendableTest, CreateSendableObjectWithPropertiesTest002, testing::ext::TestSize.Level1)
1866 {
1867 napi_env env = (napi_env)engine_;
1868 napi_value excep;
1869 ASSERT_CHECK_CALL(napi_get_and_clear_last_exception(env, &excep));
1870
1871 napi_value obj2;
1872 napi_property_descriptor desc2[] = {
1873 DECLARE_NAPI_FUNCTION("func", Func),
1874 };
1875 ASSERT_CHECK_CALL(napi_create_sendable_object_with_properties(env, 1, desc2, &obj2));
1876 bool isShared = false;
1877 napi_is_sendable(env, obj2, &isShared);
1878 ASSERT_EQ(isShared, true);
1879
1880 auto data = new char[2];
1881 *data = 'a';
1882 *(data + 1) = 0;
1883 napi_wrap_sendable(env, obj2, data, nullptr, nullptr);
1884 ASSERT_CHECK_VALUE_TYPE(env, obj2, napi_object);
1885 napi_value func = nullptr;
1886 napi_value ret = nullptr;
1887 napi_get_named_property(env, obj2, "func", &func);
1888 ASSERT_EQ(g_funcCalled, false);
1889 napi_call_function(env, obj2, func, 0, nullptr, &ret);
1890 bool resultBool = false;
1891 napi_get_value_bool(env, ret, &resultBool);
1892 ASSERT_EQ(resultBool, true);
1893 ASSERT_EQ(g_funcCalled, true);
1894 }
1895
1896 /**
1897 * @tc.name: SerializeDeSerializeSendableDataTest001
1898 * @tc.desc: Test serialize & deserialize sendableArray.
1899 * @tc.type: FUNC
1900 */
1901 HWTEST_F(NapiSendableTest, SerializeDeSerializeSendableDataTest001, testing::ext::TestSize.Level1)
1902 {
1903 napi_env env = (napi_env)engine_;
1904 napi_status res = napi_ok;
1905 napi_value excep;
1906 ASSERT_CHECK_CALL(napi_get_and_clear_last_exception(env, &excep));
1907 napi_value num = nullptr;
1908 uint32_t value = 1000;
1909 res = napi_create_uint32(env, value, &num);
1910 ASSERT_EQ(res, napi_ok);
1911 napi_property_descriptor desc[] = {
1912 DECLARE_NAPI_DEFAULT_PROPERTY("a", num),
1913 };
1914 napi_value obj;
1915 ASSERT_CHECK_CALL(napi_create_sendable_object_with_properties(env, 1, desc, &obj));
1916 ASSERT_CHECK_VALUE_TYPE(env, obj, napi_object);
1917
1918 napi_value undefined = nullptr;
1919 napi_get_undefined(env, &undefined);
1920 void* data = nullptr;
1921 res = napi_serialize(env, obj, undefined, undefined, &data);
1922 ASSERT_NE(data, nullptr);
1923 ASSERT_EQ(res, napi_ok);
1924
1925 napi_value result1 = nullptr;
1926 res = napi_deserialize(env, data, &result1);
1927 ASSERT_CHECK_VALUE_TYPE(env, result1, napi_object);
1928
1929 napi_value number1 = nullptr;;
1930 napi_get_named_property(env, result1, "a", &number1);
1931 ASSERT_CHECK_VALUE_TYPE(env, number1, napi_number);
1932
1933 napi_delete_serialization_data(env, data);
1934 }
1935
1936 /**
1937 * @tc.name: SerializeDeSerializeSendableDataTest002
1938 * @tc.desc: Test serialize & deserialize sendableArray.
1939 * @tc.type: FUNC
1940 */
1941 HWTEST_F(NapiSendableTest, SerializeDeSerializeSendableDataTest002, testing::ext::TestSize.Level1)
1942 {
1943 napi_env env = (napi_env) engine_;
1944
1945 napi_status res = napi_ok;
1946 napi_value sendableArray = nullptr;
1947 napi_create_sendable_array(env, &sendableArray);
1948 ASSERT_NE(sendableArray, nullptr);
1949 bool isShared = false;
1950 res = napi_is_sendable(env, sendableArray, &isShared);
1951 ASSERT_EQ(res, napi_ok);
1952 ASSERT_EQ(isShared, true);
1953 bool isArray = false;
1954 napi_is_array(env, sendableArray, &isArray);
1955 ASSERT_TRUE(isArray);
1956 for (size_t i = 0; i < 10; i++) {
1957 napi_value num = nullptr;
1958 napi_create_uint32(env, i, &num);
1959 napi_set_element(env, sendableArray, i, num);
1960 }
1961
1962 uint32_t length = 0;
1963 res = napi_get_array_length(env, sendableArray, &length);
1964 ASSERT_EQ(res, napi_ok);
1965 ASSERT_EQ(length, 10u);
1966
1967 napi_value undefined = nullptr;
1968 napi_get_undefined(env, &undefined);
1969 void* data = nullptr;
1970 res = napi_serialize(env, sendableArray, undefined, undefined, &data);
1971 ASSERT_NE(data, nullptr);
1972 ASSERT_EQ(res, napi_ok);
1973
1974 napi_value result1 = nullptr;
1975 napi_deserialize(env, data, &result1);
1976 ASSERT_CHECK_VALUE_TYPE(env, result1, napi_object);
1977
1978 res = napi_get_array_length(env, result1, &length);
1979 ASSERT_EQ(res, napi_ok);
1980 ASSERT_EQ(length, 10u);
1981
1982 napi_delete_serialization_data(env, data);
1983 }
1984
1985 /**
1986 * @tc.name: SerializeDeSerializeSendableDataTest003
1987 * @tc.desc: Test serialize & deserialize sendableArrayWithLength.
1988 * @tc.type: FUNC
1989 */
1990 HWTEST_F(NapiSendableTest, SerializeDeSerializeSendableDataTest003, testing::ext::TestSize.Level1)
1991 {
1992 static uint32_t LENGTH = 1024;
1993 ASSERT_NE(engine_, nullptr);
1994 napi_env env = reinterpret_cast<napi_env>(engine_);
1995 napi_status res = napi_ok;
1996
1997 napi_value sendableArray = nullptr;
1998 res = napi_create_sendable_array_with_length(env, LENGTH, &sendableArray);
1999 ASSERT_EQ(res, napi_ok);
2000
2001 bool isShared = false;
2002 res = napi_is_sendable(env, sendableArray, &isShared);
2003 ASSERT_EQ(res, napi_ok);
2004 ASSERT_EQ(isShared, true);
2005 bool isArray = false;
2006 napi_is_array(env, sendableArray, &isArray);
2007 ASSERT_TRUE(isArray);
2008 for (size_t i = 0; i < 100; i++) {
2009 napi_value num = nullptr;
2010 napi_create_uint32(env, i, &num);
2011 napi_set_element(env, sendableArray, i, num);
2012 }
2013
2014 uint32_t length = 0;
2015 res = napi_get_array_length(env, sendableArray, &length);
2016 ASSERT_EQ(res, napi_ok);
2017 ASSERT_EQ(length, 1024);
2018
2019 napi_value undefined = nullptr;
2020 napi_get_undefined(env, &undefined);
2021 void* data = nullptr;
2022 res = napi_serialize(env, sendableArray, undefined, undefined, &data);
2023 ASSERT_NE(data, nullptr);
2024 ASSERT_EQ(res, napi_ok);
2025
2026 napi_value result1 = nullptr;
2027 napi_deserialize(env, data, &result1);
2028 ASSERT_CHECK_VALUE_TYPE(env, result1, napi_object);
2029
2030 res = napi_get_array_length(env, result1, &length);
2031 ASSERT_EQ(res, napi_ok);
2032 ASSERT_EQ(length, 1024);
2033
2034 napi_delete_serialization_data(env, data);
2035 }
2036
2037 /**
2038 * @tc.name: SerializeDeSerializeSendableDataTest004
2039 * @tc.desc: Test serialize & deserialize sendableTypedArray.
2040 * @tc.type: FUNC
2041 */
2042 HWTEST_F(NapiSendableTest, SerializeDeSerializeSendableDataTest004, testing::ext::TestSize.Level1)
2043 {
2044 static size_t LENGTH = 1024;
2045 static size_t OFFSET = 128;
2046 ASSERT_NE(engine_, nullptr);
2047 napi_env env = reinterpret_cast<napi_env>(engine_);
2048 napi_status res = napi_ok;
2049
2050 void *tmpData;
2051 napi_value sendableArraybuffer = nullptr;
2052 napi_value sendableTypedarray = nullptr;
2053 res = napi_create_sendable_arraybuffer(env, LENGTH, &tmpData, &sendableArraybuffer);
2054 ASSERT_EQ(res, napi_ok);
2055
2056 bool isShared = false;
2057 res = napi_is_sendable(env, sendableArraybuffer, &isShared);
2058 ASSERT_EQ(res, napi_ok);
2059 ASSERT_EQ(isShared, true);
2060
2061 res = napi_create_sendable_typedarray(env, napi_int8_array, LENGTH / 2,
2062 sendableArraybuffer, OFFSET, &sendableTypedarray);
2063 ASSERT_EQ(res, napi_ok);
2064
2065 isShared = false;
2066 res = napi_is_sendable(env, sendableArraybuffer, &isShared);
2067 ASSERT_EQ(res, napi_ok);
2068 ASSERT_EQ(isShared, true);
2069
2070 bool isTypedArray = false;
2071 res = napi_is_typedarray(env, sendableTypedarray, &isTypedArray);
2072 ASSERT_EQ(res, napi_ok);
2073 ASSERT_EQ(isTypedArray, true);
2074
2075 napi_value undefined = nullptr;
2076 napi_get_undefined(env, &undefined);
2077 void* data = nullptr;
2078 res = napi_serialize(env, sendableTypedarray, undefined, undefined, &data);
2079 ASSERT_NE(data, nullptr);
2080 ASSERT_EQ(res, napi_ok);
2081
2082 napi_value result = nullptr;
2083 res = napi_deserialize(env, data, &result);
2084 ASSERT_CHECK_VALUE_TYPE(env, result, napi_object);
2085
2086 napi_typedarray_type type = napi_uint8_array;
2087 size_t length = 0;
2088 void *getData = nullptr;
2089 napi_value getArrayBuffer = nullptr;
2090 size_t byteOffset = 0;
2091 res = napi_get_typedarray_info(env, result, &type, &length, &getData, &getArrayBuffer, &byteOffset);
2092 ASSERT_EQ(res, napi_ok);
2093
2094 ASSERT_EQ(type, napi_int8_array);
2095 ASSERT_EQ(length, LENGTH / 2);
2096 ASSERT_EQ(reinterpret_cast<size_t>(getData), reinterpret_cast<size_t>(tmpData) + OFFSET);
2097 ASSERT_EQ(byteOffset, OFFSET);
2098
2099 napi_delete_serialization_data(env, data);
2100 }
2101
2102 /**
2103 * @tc.name: SerializeDeSerializeSendableDataTest005
2104 * @tc.desc: Test serialize & deserialize sendableArrayBuffer.
2105 * @tc.type: FUNC
2106 */
2107 HWTEST_F(NapiSendableTest, SerializeDeSerializeSendableDataTest005, testing::ext::TestSize.Level1)
2108 {
2109 static size_t LENGTH = 1024;
2110 ASSERT_NE(engine_, nullptr);
2111 napi_env env = reinterpret_cast<napi_env>(engine_);
2112 napi_status res = napi_ok;
2113
2114 void *tmpData;
2115 napi_value sendableBuffer = nullptr;
2116 res = napi_create_sendable_arraybuffer(env, LENGTH, &tmpData, &sendableBuffer);
2117 ASSERT_EQ(res, napi_ok);
2118
2119 bool isShared = false;
2120 res = napi_is_sendable(env, sendableBuffer, &isShared);
2121 ASSERT_EQ(res, napi_ok);
2122 ASSERT_EQ(isShared, true);
2123
2124 bool isArrayBuffer = false;
2125 res = napi_is_arraybuffer(env, sendableBuffer, &isArrayBuffer);
2126 ASSERT_EQ(res, napi_ok);
2127 ASSERT_EQ(isArrayBuffer, true);
2128
2129 napi_value undefined = nullptr;
2130 napi_get_undefined(env, &undefined);
2131 void* data = nullptr;
2132 res = napi_serialize(env, sendableBuffer, undefined, undefined, &data);
2133 ASSERT_EQ(res, napi_ok);
2134 ASSERT_NE(data, nullptr);
2135
2136 napi_delete_serialization_data(env, data);
2137 }