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
__anon35b464c60402(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",
__anon35b464c60502() 199 [](napi_env env, napi_callback_info info) -> napi_value { return nullptr; }),
__anon35b464c60602() 200 DECLARE_NAPI_FUNCTION("func", [](napi_env env, napi_callback_info info) -> napi_value { return nullptr; }),
201 DECLARE_NAPI_GETTER_SETTER(
__anon35b464c60702() 202 "getterSetter", [](napi_env env, napi_callback_info info) -> napi_value { return nullptr; },
__anon35b464c60802() 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
__anon35b464c60902(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 HWTEST_F(NapiSendableTest, SendableClassTest006, testing::ext::TestSize.Level1)
442 {
443 napi_env env = reinterpret_cast<napi_env>(engine_);
444 napi_value parentClass = nullptr;
445 napi_status parentStatus = napi_define_sendable_class(
446 env, "ParentClass", NAPI_AUTO_LENGTH,
__anon35b464c60a02(napi_env env, napi_callback_info info) 447 [](napi_env env, napi_callback_info info) -> napi_value {
448 napi_value thisVar = nullptr;
449 napi_get_cb_info(env, info, nullptr, nullptr, &thisVar, nullptr);
450 return thisVar;
451 },
452 nullptr, 0, nullptr, nullptr, &parentClass);
453 ASSERT_EQ(parentStatus, napi_ok);
454 napi_value childClass = nullptr;
455 napi_status childStatus = napi_define_sendable_class(
456 env, "ChildClass", NAPI_AUTO_LENGTH,
__anon35b464c60b02(napi_env env, napi_callback_info info) 457 [](napi_env env, napi_callback_info info) -> napi_value {
458 napi_value thisVar = nullptr;
459 napi_get_cb_info(env, info, nullptr, nullptr, &thisVar, nullptr);
460 return thisVar;
461 },
462 nullptr, 0, nullptr, parentClass, &childClass);
463 ASSERT_EQ(childStatus, napi_ok);
464
465 napi_value childInstance = nullptr;
466 ASSERT_CHECK_CALL(napi_new_instance(env, childClass, 0, nullptr, &childInstance));
467
468 bool isInstanceOfParent = false;
469 ASSERT_CHECK_CALL(napi_instanceof(env, childInstance, parentClass, &isInstanceOfParent));
470 ASSERT_TRUE(isInstanceOfParent);
471
472 bool isInstanceOfChild = false;
473 ASSERT_CHECK_CALL(napi_instanceof(env, childInstance, childClass, &isInstanceOfChild));
474 ASSERT_TRUE(isInstanceOfChild);
475 }
476
477 /**
478 * @tc.name: CreateSendableMap001
479 * @tc.desc: Test napi_create_sendable_map.
480 * @tc.type: FUNC
481 */
482 HWTEST_F(NapiSendableTest, CreateSendableMap001, testing::ext::TestSize.Level1)
483 {
484 ASSERT_NE(engine_, nullptr);
485 napi_env env = reinterpret_cast<napi_env>(engine_);
486 napi_status res = napi_ok;
487
488 res = napi_create_sendable_map(env, nullptr);
489 ASSERT_EQ(res, napi_invalid_arg);
490
491 napi_value result = nullptr;
492 ASSERT_CHECK_CALL(napi_create_sendable_map(env, &result));
493
494 bool isShared = false;
495 ASSERT_CHECK_CALL(napi_is_sendable(env, result, &isShared));
496 ASSERT_EQ(isShared, true);
497
498 bool isMap = false;
499 ASSERT_CHECK_CALL(napi_is_map(env, result, &isMap));
500 ASSERT_EQ(isMap, true);
501 }
502
503 /**
504 * @tc.name: CreateSendableMap002
505 * @tc.desc: Test napi_create_sendable_map.
506 * @tc.type: FUNC
507 */
508 HWTEST_F(NapiSendableTest, CreateSendableMap002, testing::ext::TestSize.Level1)
509 {
510 ASSERT_NE(engine_, nullptr);
511 napi_env env = reinterpret_cast<napi_env>(engine_);
512
513 napi_value result = nullptr;
514 ASSERT_CHECK_CALL(napi_create_sendable_map(env, &result));
515
516 uint32_t length = 0;
517 napi_value value = nullptr;
518 bool hasKey = false;
519
520 napi_value key = nullptr;
521 ASSERT_CHECK_CALL(napi_create_string_utf8(env, "null", NAPI_AUTO_LENGTH, &key));
522 napi_value null = nullptr;
523 ASSERT_CHECK_CALL(napi_get_null(env, &null));
524 napi_value undefined = nullptr;
525 ASSERT_CHECK_CALL(napi_get_undefined(env, &undefined));
526
527 ASSERT_CHECK_CALL(napi_map_set_property(env, result, key, null));
528 ASSERT_CHECK_CALL(napi_map_get_size(env, result, &length));
529 ASSERT_EQ(length, 1);
530 ASSERT_CHECK_CALL(napi_map_has_property(env, result, key, &hasKey));
531 ASSERT_TRUE(hasKey);
532 ASSERT_CHECK_CALL(napi_map_get_property(env, result, key, &value));
533 ASSERT_CHECK_VALUE_TYPE(env, value, napi_null);
534
535 ASSERT_CHECK_CALL(napi_map_delete_property(env, result, key));
536 ASSERT_CHECK_CALL(napi_map_get_size(env, result, &length));
537 ASSERT_EQ(length, 0);
538 ASSERT_CHECK_CALL(napi_map_has_property(env, result, key, &hasKey));
539 ASSERT_FALSE(hasKey);
540 ASSERT_CHECK_CALL(napi_map_get_property(env, result, key, &value));
541 ASSERT_CHECK_VALUE_TYPE(env, value, napi_undefined);
542 }
543
544 /**
545 * @tc.name: CreateSendableMap003
546 * @tc.desc: Test napi_create_sendable_map.
547 * @tc.type: FUNC
548 */
549 HWTEST_F(NapiSendableTest, CreateSendableMap003, testing::ext::TestSize.Level1)
550 {
551 ASSERT_NE(engine_, nullptr);
552 napi_env env = reinterpret_cast<napi_env>(engine_);
553
554 napi_value result = nullptr;
555 ASSERT_CHECK_CALL(napi_create_sendable_map(env, &result));
556
557 uint32_t length = 0;
558 napi_value value = nullptr;
559 bool hasKey = false;
560
561 const char* key = "null";
562 napi_value null = nullptr;
563 ASSERT_CHECK_CALL(napi_get_null(env, &null));
564 napi_value undefined = nullptr;
565 ASSERT_CHECK_CALL(napi_get_undefined(env, &undefined));
566
567 ASSERT_CHECK_CALL(napi_map_set_named_property(env, result, key, null));
568 ASSERT_CHECK_CALL(napi_map_get_size(env, result, &length));
569 ASSERT_EQ(length, 1);
570 ASSERT_CHECK_CALL(napi_map_has_named_property(env, result, key, &hasKey));
571 ASSERT_TRUE(hasKey);
572 ASSERT_CHECK_CALL(napi_map_get_named_property(env, result, key, &value));
573 ASSERT_CHECK_VALUE_TYPE(env, value, napi_null);
574
575 ASSERT_CHECK_CALL(napi_map_clear(env, result));
576 ASSERT_CHECK_CALL(napi_map_get_size(env, result, &length));
577 ASSERT_EQ(length, 0);
578 ASSERT_CHECK_CALL(napi_map_has_named_property(env, result, key, &hasKey));
579 ASSERT_FALSE(hasKey);
580 ASSERT_CHECK_CALL(napi_map_get_named_property(env, result, key, &value));
581 ASSERT_CHECK_VALUE_TYPE(env, value, napi_undefined);
582
583 bool isExceptionPending = false;
584 napi_is_exception_pending(env, &isExceptionPending);
585 ASSERT_FALSE(isExceptionPending);
586
587 napi_value object = nullptr;
588 ASSERT_CHECK_CALL(napi_create_object(env, &object));
589 napi_status res = napi_map_set_named_property(env, result, key, object);
590 ASSERT_TRUE(res == napi_pending_exception);
591 }
592
593 /**
594 * @tc.name: CreateSendableMap004
595 * @tc.desc: Test napi_create_sendable_map.
596 * @tc.type: FUNC
597 */
598 HWTEST_F(NapiSendableTest, CreateSendableMap004, testing::ext::TestSize.Level1)
599 {
600 ASSERT_NE(engine_, nullptr);
601 napi_env env = reinterpret_cast<napi_env>(engine_);
602
603 napi_value map = nullptr;
604 ASSERT_CHECK_CALL(napi_create_sendable_map(env, &map));
605
606 napi_value zero = nullptr;
607 ASSERT_CHECK_CALL(napi_create_int32(env, 0, &zero));
608 napi_value one = nullptr;
609 ASSERT_CHECK_CALL(napi_create_int32(env, 1, &one));
610
611 ASSERT_CHECK_CALL(napi_map_set_property(env, map, zero, one));
612
613 napi_value entries;
614 ASSERT_CHECK_CALL(napi_map_get_entries(env, map, &entries));
615
616 napi_value entries0;
617 ASSERT_CHECK_CALL(napi_map_iterator_get_next(env, entries, &entries0));
618 napi_value entries0Value = nullptr;
619 ASSERT_CHECK_CALL(napi_get_named_property(env, entries0, "value", &entries0Value));
620 napi_value key = nullptr;
621 ASSERT_CHECK_CALL(napi_get_element(env, entries0Value, 0, &key));
622 int32_t nativeKey;
623 ASSERT_CHECK_CALL(napi_get_value_int32(env, key, &nativeKey));
624 ASSERT_EQ(nativeKey, 0);
625 napi_value value = nullptr;
626 ASSERT_CHECK_CALL(napi_get_element(env, entries0Value, 1, &value));
627 int32_t nativeValue;
628 ASSERT_CHECK_CALL(napi_get_value_int32(env, value, &nativeValue));
629 ASSERT_EQ(nativeValue, 1);
630
631 napi_value end;
632 ASSERT_CHECK_CALL(napi_map_iterator_get_next(env, entries, &end));
633 napi_value done = nullptr;
634 ASSERT_CHECK_CALL(napi_get_named_property(env, end, "done", &done));
635 bool isDone;
636 ASSERT_CHECK_CALL(napi_get_value_bool(env, done, &isDone));
637 ASSERT_TRUE(isDone);
638 }
639
640 /**
641 * @tc.name: CreateSendableMap005
642 * @tc.desc: Test napi_create_sendable_map.
643 * @tc.type: FUNC
644 */
645 HWTEST_F(NapiSendableTest, CreateSendableMap005, testing::ext::TestSize.Level1)
646 {
647 ASSERT_NE(engine_, nullptr);
648 napi_env env = reinterpret_cast<napi_env>(engine_);
649
650 napi_value map = nullptr;
651 ASSERT_CHECK_CALL(napi_create_sendable_map(env, &map));
652
653 napi_value zero = nullptr;
654 ASSERT_CHECK_CALL(napi_create_int32(env, 0, &zero));
655 napi_value one = nullptr;
656 ASSERT_CHECK_CALL(napi_create_int32(env, 1, &one));
657
658 ASSERT_CHECK_CALL(napi_map_set_property(env, map, zero, one));
659
660 napi_value keys;
661 ASSERT_CHECK_CALL(napi_map_get_keys(env, map, &keys));
662
663 napi_value keys0;
664 ASSERT_CHECK_CALL(napi_map_iterator_get_next(env, keys, &keys0));
665 napi_value key = nullptr;
666 ASSERT_CHECK_CALL(napi_get_named_property(env, keys0, "value", &key));
667 int32_t nativeKey;
668 ASSERT_CHECK_CALL(napi_get_value_int32(env, key, &nativeKey));
669 ASSERT_EQ(nativeKey, 0);
670
671 napi_value end;
672 ASSERT_CHECK_CALL(napi_map_iterator_get_next(env, keys, &end));
673 napi_value done = nullptr;
674 ASSERT_CHECK_CALL(napi_get_named_property(env, end, "done", &done));
675 bool isDone;
676 ASSERT_CHECK_CALL(napi_get_value_bool(env, done, &isDone));
677 ASSERT_TRUE(isDone);
678 }
679
680 /**
681 * @tc.name: CreateSendableMap006
682 * @tc.desc: Test napi_create_sendable_map.
683 * @tc.type: FUNC
684 */
685 HWTEST_F(NapiSendableTest, CreateSendableMap006, testing::ext::TestSize.Level1)
686 {
687 ASSERT_NE(engine_, nullptr);
688 napi_env env = reinterpret_cast<napi_env>(engine_);
689
690 napi_value map = nullptr;
691 ASSERT_CHECK_CALL(napi_create_sendable_map(env, &map));
692
693 napi_value zero = nullptr;
694 ASSERT_CHECK_CALL(napi_create_int32(env, 0, &zero));
695 napi_value one = nullptr;
696 ASSERT_CHECK_CALL(napi_create_int32(env, 1, &one));
697
698 ASSERT_CHECK_CALL(napi_map_set_property(env, map, zero, one));
699
700 napi_value values;
701 ASSERT_CHECK_CALL(napi_map_get_values(env, map, &values));
702
703 napi_value values0;
704 ASSERT_CHECK_CALL(napi_map_iterator_get_next(env, values, &values0));
705 napi_value value = nullptr;
706 ASSERT_CHECK_CALL(napi_get_named_property(env, values0, "value", &value));
707 int32_t nativeValue;
708 ASSERT_CHECK_CALL(napi_get_value_int32(env, value, &nativeValue));
709 ASSERT_EQ(nativeValue, 1);
710
711 napi_value end;
712 ASSERT_CHECK_CALL(napi_map_iterator_get_next(env, values, &end));
713 napi_value done = nullptr;
714 ASSERT_CHECK_CALL(napi_get_named_property(env, end, "done", &done));
715 bool isDone;
716 ASSERT_CHECK_CALL(napi_get_value_bool(env, done, &isDone));
717 ASSERT_TRUE(isDone);
718 }
719
720 HWTEST_F(NapiSendableTest, WrapSendableTest001, testing::ext::TestSize.Level1)
721 {
722 napi_env env = (napi_env)engine_;
723 napi_status res = napi_ok;
724
725 napi_value testClass = nullptr;
726 res = napi_define_sendable_class(
727 env, "TestClass", NAPI_AUTO_LENGTH,
__anon35b464c60c02(napi_env env, napi_callback_info info) 728 [](napi_env env, napi_callback_info info) -> napi_value {
729 napi_value thisVar = nullptr;
730 napi_get_cb_info(env, info, nullptr, nullptr, &thisVar, nullptr);
731 return thisVar;
732 },
733 nullptr, 0, nullptr, nullptr, &testClass);
734 ASSERT_EQ(res, napi_ok);
735
736 napi_value instanceValue = nullptr;
737 res = napi_new_instance(env, testClass, 0, nullptr, &instanceValue);
738 ASSERT_EQ(res, napi_ok);
739
740 const char* testStr = "test";
741 res = napi_wrap_sendable(
__anon35b464c60d02(napi_env env, void* data, void* hint) 742 env, instanceValue, (void*)testStr, [](napi_env env, void* data, void* hint) {}, nullptr);
743 ASSERT_EQ(res, napi_ok);
744
745 char* tmpTestStr = nullptr;
746 res = napi_unwrap_sendable(env, instanceValue, (void**)&tmpTestStr);
747 ASSERT_EQ(res, napi_ok);
748 ASSERT_STREQ(testStr, tmpTestStr);
749
750 char* tmpTestStr1 = nullptr;
751 res = napi_remove_wrap_sendable(env, instanceValue, (void**)&tmpTestStr1);
752 ASSERT_EQ(res, napi_ok);
753 ASSERT_STREQ(testStr, tmpTestStr1);
754 }
755
756 HWTEST_F(NapiSendableTest, WrapSendableWithSizeTest001, testing::ext::TestSize.Level1)
757 {
758 napi_env env = (napi_env)engine_;
759
760 napi_value testWrapClass = nullptr;
761 napi_define_sendable_class(
762 env, "TestWrapClass", NAPI_AUTO_LENGTH,
__anon35b464c60e02(napi_env env, napi_callback_info info) 763 [](napi_env env, napi_callback_info info) -> napi_value {
764 napi_value thisVar = nullptr;
765 napi_get_cb_info(env, info, nullptr, nullptr, &thisVar, nullptr);
766 return thisVar;
767 },
768 nullptr, 0, nullptr, nullptr, &testWrapClass);
769
770 napi_value instanceValue = nullptr;
771 napi_new_instance(env, testWrapClass, 0, nullptr, &instanceValue);
772
773 const char* testWrapStr = "testWrapStr";
774 size_t size = sizeof(*testWrapStr) / sizeof(char);
775 napi_wrap_sendable_with_size(
__anon35b464c60f02(napi_env env, void* data, void* hint) 776 env, instanceValue, (void*)testWrapStr, [](napi_env env, void* data, void* hint) {}, nullptr, size);
777
778 char* tempTestStr = nullptr;
779 napi_unwrap_sendable(env, instanceValue, (void**)&tempTestStr);
780 ASSERT_STREQ(testWrapStr, tempTestStr);
781
782 char* tempTestStr1 = nullptr;
783 napi_remove_wrap_sendable(env, instanceValue, (void**)&tempTestStr1);
784 ASSERT_STREQ(testWrapStr, tempTestStr1);
785 }
786
787 /**
788 * @tc.name: SharedArrayBufferTest001
789 * @tc.desc: Test is shared array buffer.
790 * @tc.type: FUNC
791 */
792 HWTEST_F(NapiSendableTest, SharedArrayBufferTest001, testing::ext::TestSize.Level1) {
793 napi_env env = (napi_env) engine_;
794
795 napi_value arrayBuffer = nullptr;
796 void* arrayBufferPtr = nullptr;
797 size_t arrayBufferSize = 1024;
798 napi_create_arraybuffer(env, arrayBufferSize, &arrayBufferPtr, &arrayBuffer);
799
800 bool isSharedArrayBuffer = true;
801 napi_is_shared_array_buffer(env, arrayBuffer, &isSharedArrayBuffer);
802 ASSERT_EQ(isSharedArrayBuffer, false);
803 }
804
805
806 /**
807 * @tc.name: CreateSendableArray001
808 * @tc.desc: Test napi_create_sendable_array abnormal argument.
809 * @tc.type: FUNC
810 */
811 HWTEST_F(NapiSendableTest, CreateSendableArray001, testing::ext::TestSize.Level1)
812 {
813 ASSERT_NE(engine_, nullptr);
814 napi_env env = reinterpret_cast<napi_env>(engine_);
815 napi_status res = napi_ok;
816
817 res = napi_create_sendable_array(env, nullptr);
818 ASSERT_EQ(res, napi_invalid_arg);
819 }
820
821 /**
822 * @tc.name: CreateSendableArray002
823 * @tc.desc: Test napi_create_sendable_array.
824 * @tc.type: FUNC
825 */
826 HWTEST_F(NapiSendableTest, CreateSendableArray002, testing::ext::TestSize.Level1)
827 {
828 ASSERT_NE(engine_, nullptr);
829 napi_env env = reinterpret_cast<napi_env>(engine_);
830 napi_status res = napi_ok;
831
832 napi_value result = nullptr;
833 res = napi_create_sendable_array(env, &result);
834 ASSERT_EQ(res, napi_ok);
835
836 bool isShared = false;
837 res = napi_is_sendable(env, result, &isShared);
838 ASSERT_EQ(res, napi_ok);
839 ASSERT_EQ(isShared, true);
840
841 bool isArray = false;
842 res = napi_is_array(env, result, &isArray);
843 ASSERT_EQ(res, napi_ok);
844 ASSERT_EQ(isArray, true);
845
846 uint32_t length = 0;
847 res = napi_get_array_length(env, result, &length);
848 ASSERT_EQ(res, napi_ok);
849 ASSERT_EQ(length, 0);
850
851 napi_value undefined = nullptr;
852 res = napi_get_undefined(env, &undefined);
853 ASSERT_EQ(res, napi_ok);
854
855 res = napi_set_element(env, result, 0, undefined);
856 ASSERT_EQ(res, napi_ok);
857 }
858
859 /**
860 * @tc.name: CreateSendableArrayWithLength001
861 * @tc.desc: Test napi_create_sendable_array_with_length.
862 * @tc.type: FUNC
863 */
864 HWTEST_F(NapiSendableTest, CreateSendableArrayWithLength001, testing::ext::TestSize.Level1)
865 {
866 ASSERT_NE(engine_, nullptr);
867 napi_env env = reinterpret_cast<napi_env>(engine_);
868 napi_status res = napi_ok;
869
870 res = napi_create_sendable_array_with_length(env, 0, nullptr);
871 ASSERT_EQ(res, napi_invalid_arg);
872 }
873
874 /**
875 * @tc.name: CreateSendableArrayWithLength002
876 * @tc.desc: Test napi_create_sendable_array_with_length.
877 * @tc.type: FUNC
878 */
879 HWTEST_F(NapiSendableTest, CreateSendableArrayWithLength002, testing::ext::TestSize.Level1)
880 {
881 ASSERT_NE(engine_, nullptr);
882 napi_env env = reinterpret_cast<napi_env>(engine_);
883 napi_status res = napi_ok;
884
885 napi_value result = nullptr;
886 res = napi_create_sendable_array_with_length(env, 0, &result);
887 ASSERT_EQ(res, napi_ok);
888
889 bool isShared = false;
890 res = napi_is_sendable(env, result, &isShared);
891 ASSERT_EQ(res, napi_ok);
892 ASSERT_EQ(isShared, true);
893
894 bool isArray = false;
895 res = napi_is_array(env, result, &isArray);
896 ASSERT_EQ(res, napi_ok);
897 ASSERT_EQ(isArray, true);
898
899 uint32_t length = 0;
900 res = napi_get_array_length(env, result, &length);
901 ASSERT_EQ(res, napi_ok);
902 ASSERT_EQ(length, 0);
903 }
904
905 /**
906 * @tc.name: CreateSendableArrayWithLength003
907 * @tc.desc: Test napi_create_sendable_array_with_length.
908 * @tc.type: FUNC
909 */
910 HWTEST_F(NapiSendableTest, CreateSendableArrayWithLength003, testing::ext::TestSize.Level1)
911 {
912 static uint32_t LENGTH = 1024;
913 ASSERT_NE(engine_, nullptr);
914 napi_env env = reinterpret_cast<napi_env>(engine_);
915 napi_status res = napi_ok;
916
917 napi_value result = nullptr;
918 res = napi_create_sendable_array_with_length(env, LENGTH, &result);
919 ASSERT_EQ(res, napi_ok);
920
921 bool isShared = false;
922 res = napi_is_sendable(env, result, &isShared);
923 ASSERT_EQ(res, napi_ok);
924 ASSERT_EQ(isShared, true);
925
926 bool isArray = false;
927 res = napi_is_array(env, result, &isArray);
928 ASSERT_EQ(res, napi_ok);
929 ASSERT_EQ(isArray, true);
930
931 uint32_t length = 0;
932 res = napi_get_array_length(env, result, &length);
933 ASSERT_EQ(res, napi_ok);
934 ASSERT_EQ(length, LENGTH);
935
936 napi_value value = nullptr;
937 napi_value boolTrue = nullptr;
938 bool ret = false;
939 res = napi_get_boolean(env, true, &boolTrue);
940 ASSERT_EQ(res, napi_ok);
941
942 res = napi_set_element(env, result, 0, boolTrue);
943 ASSERT_EQ(res, napi_ok);
944 res = napi_get_element(env, result, 0, &value);
945 ASSERT_EQ(res, napi_ok);
946 res = napi_get_value_bool(env, value, &ret);
947 ASSERT_EQ(res, napi_ok);
948 ASSERT_EQ(ret, true);
949
950 res = napi_set_element(env, result, LENGTH - 1, boolTrue);
951 ASSERT_EQ(res, napi_ok);
952 res = napi_get_element(env, result, LENGTH - 1, &value);
953 ASSERT_EQ(res, napi_ok);
954 res = napi_get_value_bool(env, value, &ret);
955 ASSERT_EQ(res, napi_ok);
956 ASSERT_EQ(ret, true);
957 }
958
959 /**
960 * @tc.name: CreateSendableArrayWithLength004
961 * @tc.desc: Test napi_create_sendable_array_with_length.
962 * @tc.type: FUNC
963 */
964 HWTEST_F(NapiSendableTest, CreateSendableArrayWithLength004, testing::ext::TestSize.Level1)
965 {
966 static uint32_t LENGTH = 1024;
967 ASSERT_NE(engine_, nullptr);
968 napi_env env = reinterpret_cast<napi_env>(engine_);
969 napi_status res = napi_ok;
970
971 napi_value result = nullptr;
972 res = napi_create_sendable_array_with_length(env, LENGTH, &result);
973 ASSERT_EQ(res, napi_ok);
974
975 bool isShared = false;
976 res = napi_is_sendable(env, result, &isShared);
977 ASSERT_EQ(res, napi_ok);
978 ASSERT_EQ(isShared, true);
979
980 bool isArray = false;
981 res = napi_is_array(env, result, &isArray);
982 ASSERT_EQ(res, napi_ok);
983 ASSERT_EQ(isArray, true);
984
985 uint32_t length = 0;
986 res = napi_get_array_length(env, result, &length);
987 ASSERT_EQ(res, napi_ok);
988 ASSERT_EQ(length, LENGTH);
989
990 napi_value value = nullptr;
991 napi_value boolTrue = nullptr;
992 bool ret = false;
993 res = napi_get_boolean(env, true, &boolTrue);
994 ASSERT_EQ(res, napi_ok);
995
996 res = napi_get_element(env, result, 1, &value);
997 ASSERT_EQ(res, napi_ok);
998 napi_valuetype type = napi_undefined;
999 res = napi_typeof(env, value, &type);
1000 ASSERT_EQ(res, napi_ok);
1001 ASSERT_EQ(napi_undefined, napi_undefined);
1002
1003 res = napi_set_element(env, result, LENGTH, boolTrue);
1004 ASSERT_EQ(res, napi_ok);
1005 res = napi_get_element(env, result, LENGTH, &value);
1006 ASSERT_EQ(res, napi_ok);
1007 res = napi_get_value_bool(env, value, &ret);
1008 ASSERT_EQ(res, napi_ok);
1009 ASSERT_EQ(ret, true);
1010
1011 res = napi_get_element(env, result, LENGTH + 1, &value);
1012 ASSERT_EQ(res, napi_ok);
1013 napi_valuetype getType = napi_undefined;
1014 res = napi_typeof(env, value, &getType);
1015 ASSERT_EQ(res, napi_ok);
1016 ASSERT_EQ(getType, napi_undefined);
1017 }
1018
1019 /**
1020 * @tc.name: CreateSendableArrayBuffer001
1021 * @tc.desc: Test napi_create_sendable_arraybuffer.
1022 * @tc.type: FUNC
1023 */
1024 HWTEST_F(NapiSendableTest, CreateSendableArrayBuffer001, testing::ext::TestSize.Level1)
1025 {
1026 static size_t LENGTH = 1024;
1027 ASSERT_NE(engine_, nullptr);
1028 napi_env env = reinterpret_cast<napi_env>(engine_);
1029 napi_status res = napi_ok;
1030
1031 napi_value result = nullptr;
1032 res = napi_create_sendable_arraybuffer(env, LENGTH, nullptr, &result);
1033 ASSERT_EQ(res, napi_invalid_arg);
1034
1035 void *data;
1036 res = napi_create_sendable_arraybuffer(env, LENGTH, &data, nullptr);
1037 ASSERT_EQ(res, napi_invalid_arg);
1038
1039 res = napi_create_sendable_arraybuffer(env, LENGTH, nullptr, nullptr);
1040 ASSERT_EQ(res, napi_invalid_arg);
1041 }
1042
1043 /**
1044 * @tc.name: CreateSendableArrayBuffer002
1045 * @tc.desc: Test napi_create_sendable_arraybuffer.
1046 * @tc.type: FUNC
1047 */
1048 HWTEST_F(NapiSendableTest, CreateSendableArrayBuffer002, testing::ext::TestSize.Level1)
1049 {
1050 static size_t LENGTH = 1024;
1051 ASSERT_NE(engine_, nullptr);
1052 napi_env env = reinterpret_cast<napi_env>(engine_);
1053 napi_status res = napi_ok;
1054
1055 void *data;
1056 napi_value result = nullptr;
1057 res = napi_create_sendable_arraybuffer(env, LENGTH, &data, &result);
1058 ASSERT_EQ(res, napi_ok);
1059
1060 bool isShared = false;
1061 res = napi_is_sendable(env, result, &isShared);
1062 ASSERT_EQ(res, napi_ok);
1063 ASSERT_EQ(isShared, true);
1064
1065 bool isArrayBuffer = false;
1066 res = napi_is_arraybuffer(env, result, &isArrayBuffer);
1067 ASSERT_EQ(res, napi_ok);
1068 ASSERT_EQ(isArrayBuffer, true);
1069
1070 void *getData = nullptr;
1071 size_t length = 0;
1072 res = napi_get_arraybuffer_info(env, result, &getData, &length);
1073 ASSERT_EQ(res, napi_ok);
1074 ASSERT_EQ(length, LENGTH);
1075 ASSERT_EQ(getData, data);
1076 }
1077
1078 /**
1079 * @tc.name: CreateSendableTypedArray001
1080 * @tc.desc: Test napi_create_sendable_arraybuffer.
1081 * @tc.type: FUNC
1082 */
1083 HWTEST_F(NapiSendableTest, CreateSendableTypedArray001, testing::ext::TestSize.Level1)
1084 {
1085 static size_t LENGTH = 1024;
1086 ASSERT_NE(engine_, nullptr);
1087 napi_env env = reinterpret_cast<napi_env>(engine_);
1088 napi_status res = napi_ok;
1089
1090 void *data;
1091 napi_value arraybuffer = nullptr;
1092 napi_value result = nullptr;
1093 res = napi_create_sendable_arraybuffer(env, LENGTH, &data, &arraybuffer);
1094 ASSERT_EQ(res, napi_ok);
1095
1096 bool isShared = false;
1097 res = napi_is_sendable(env, arraybuffer, &isShared);
1098 ASSERT_EQ(res, napi_ok);
1099 ASSERT_EQ(isShared, true);
1100
1101 res = napi_create_sendable_typedarray(env, napi_uint8_clamped_array, LENGTH / 2, arraybuffer, 1, &result);
1102 ASSERT_EQ(res, napi_ok);
1103
1104 res = napi_create_sendable_typedarray(env, napi_uint8_array, LENGTH / 2, arraybuffer, 1, nullptr);
1105 ASSERT_EQ(res, napi_invalid_arg);
1106
1107 res = napi_create_sendable_typedarray(env, napi_uint8_array, LENGTH / 2, nullptr, 1, &result);
1108 ASSERT_EQ(res, napi_invalid_arg);
1109
1110 res = napi_create_sendable_typedarray(env, napi_int8_array, LENGTH / 2, nullptr, 1, &result);
1111 ASSERT_EQ(res, napi_invalid_arg);
1112
1113 res = napi_create_sendable_typedarray(env, napi_int8_array, LENGTH / 2, nullptr, 1, &result);
1114 ASSERT_EQ(res, napi_invalid_arg);
1115
1116 res = napi_create_sendable_typedarray(env, napi_uint16_array, LENGTH / 2, nullptr, 1, &result);
1117 ASSERT_EQ(res, napi_invalid_arg);
1118
1119 res = napi_create_sendable_typedarray(env, napi_uint16_array, LENGTH / 2, nullptr, 1, &result);
1120 ASSERT_EQ(res, napi_invalid_arg);
1121
1122 res = napi_create_sendable_typedarray(env, napi_int32_array, LENGTH / 2, nullptr, 1, &result);
1123 ASSERT_EQ(res, napi_invalid_arg);
1124
1125 res = napi_create_sendable_typedarray(env, napi_int32_array, LENGTH / 2, nullptr, 1, &result);
1126 ASSERT_EQ(res, napi_invalid_arg);
1127
1128 res = napi_create_sendable_typedarray(env, napi_uint32_array, LENGTH / 2, nullptr, 1, &result);
1129 ASSERT_EQ(res, napi_invalid_arg);
1130
1131 res = napi_create_sendable_typedarray(env, napi_uint32_array, LENGTH / 2, nullptr, 1, &result);
1132 ASSERT_EQ(res, napi_invalid_arg);
1133
1134 res = napi_create_sendable_typedarray(env, napi_float32_array, LENGTH / 2, nullptr, 1, &result);
1135 ASSERT_EQ(res, napi_invalid_arg);
1136
1137 res = napi_create_sendable_typedarray(env, napi_float32_array, LENGTH / 2, nullptr, 1, &result);
1138 ASSERT_EQ(res, napi_invalid_arg);
1139 }
1140
1141 /**
1142 * @tc.name: CreateSendableTypedArray002
1143 * @tc.desc: Test napi_create_sendable_arraybuffer.
1144 * @tc.type: FUNC
1145 */
1146 HWTEST_F(NapiSendableTest, CreateSendableTypedArray002, testing::ext::TestSize.Level1)
1147 {
1148 static size_t LENGTH = 1024;
1149 static size_t OFFSET = 128;
1150 ASSERT_NE(engine_, nullptr);
1151 napi_env env = reinterpret_cast<napi_env>(engine_);
1152 napi_status res = napi_ok;
1153
1154 void *data;
1155 napi_value arraybuffer = nullptr;
1156 res = napi_create_sendable_arraybuffer(env, LENGTH, &data, &arraybuffer);
1157 ASSERT_EQ(res, napi_ok);
1158
1159 napi_value result = nullptr;
1160 res = napi_create_sendable_typedarray(env, napi_uint8_array, LENGTH / 2, arraybuffer, OFFSET, &result);
1161 ASSERT_EQ(res, napi_ok);
1162
1163 bool isShared = false;
1164 res = napi_is_sendable(env, result, &isShared);
1165 ASSERT_EQ(res, napi_ok);
1166 ASSERT_EQ(isShared, true);
1167
1168 bool isTypedArray = false;
1169 res = napi_is_typedarray(env, result, &isTypedArray);
1170 ASSERT_EQ(res, napi_ok);
1171 ASSERT_EQ(isTypedArray, true);
1172
1173 napi_typedarray_type type = napi_int8_array;
1174 size_t length = 0;
1175 void *getData = nullptr;
1176 napi_value getArrayBuffer = nullptr;
1177 size_t byteOffset = 0;
1178 res = napi_get_typedarray_info(env, result, &type, &length, &getData, &getArrayBuffer, &byteOffset);
1179 ASSERT_EQ(res, napi_ok);
1180
1181 bool isEqual = false;
1182 res = napi_strict_equals(env, arraybuffer, getArrayBuffer, &isEqual);
1183 ASSERT_EQ(res, napi_ok);
1184
1185 ASSERT_EQ(type, napi_uint8_array);
1186 ASSERT_EQ(length, LENGTH / 2);
1187 ASSERT_EQ(reinterpret_cast<size_t>(getData), reinterpret_cast<size_t>(data) + OFFSET);
1188 ASSERT_EQ(isEqual, true);
1189 ASSERT_EQ(byteOffset, OFFSET);
1190 }
1191
1192 /**
1193 * @tc.name: CreateSendableTypedArray003
1194 * @tc.desc: Test napi_create_sendable_arraybuffer.
1195 * @tc.type: FUNC
1196 */
1197 HWTEST_F(NapiSendableTest, CreateSendableTypedArray003, testing::ext::TestSize.Level1)
1198 {
1199 static size_t LENGTH = 1024;
1200 static size_t OFFSET = 128;
1201 ASSERT_NE(engine_, nullptr);
1202 napi_env env = reinterpret_cast<napi_env>(engine_);
1203 napi_status res = napi_ok;
1204
1205 void *data;
1206 napi_value arraybuffer = nullptr;
1207 res = napi_create_sendable_arraybuffer(env, LENGTH, &data, &arraybuffer);
1208 ASSERT_EQ(res, napi_ok);
1209
1210 napi_value result = nullptr;
1211 res = napi_create_sendable_typedarray(env, napi_int8_array, LENGTH / 2, arraybuffer, OFFSET, &result);
1212 ASSERT_EQ(res, napi_ok);
1213
1214 bool isShared = false;
1215 res = napi_is_sendable(env, result, &isShared);
1216 ASSERT_EQ(res, napi_ok);
1217 ASSERT_EQ(isShared, true);
1218
1219 bool isTypedArray = false;
1220 res = napi_is_typedarray(env, result, &isTypedArray);
1221 ASSERT_EQ(res, napi_ok);
1222 ASSERT_EQ(isTypedArray, true);
1223
1224 napi_typedarray_type type = napi_uint8_array;
1225 size_t length = 0;
1226 void *getData = nullptr;
1227 napi_value getArrayBuffer = nullptr;
1228 size_t byteOffset = 0;
1229 res = napi_get_typedarray_info(env, result, &type, &length, &getData, &getArrayBuffer, &byteOffset);
1230 ASSERT_EQ(res, napi_ok);
1231
1232 bool isEqual = false;
1233 res = napi_strict_equals(env, arraybuffer, getArrayBuffer, &isEqual);
1234 ASSERT_EQ(res, napi_ok);
1235
1236 ASSERT_EQ(type, napi_int8_array);
1237 ASSERT_EQ(length, LENGTH / 2);
1238 ASSERT_EQ(reinterpret_cast<size_t>(getData), reinterpret_cast<size_t>(data) + OFFSET);
1239 ASSERT_EQ(isEqual, true);
1240 ASSERT_EQ(byteOffset, OFFSET);
1241 }
1242
1243 /**
1244 * @tc.name: CreateSendableTypedArray004
1245 * @tc.desc: Test napi_create_sendable_arraybuffer.
1246 * @tc.type: FUNC
1247 */
1248 HWTEST_F(NapiSendableTest, CreateSendableTypedArray004, testing::ext::TestSize.Level1)
1249 {
1250 static size_t LENGTH = 1024;
1251 static size_t OFFSET = 0;
1252 ASSERT_NE(engine_, nullptr);
1253 napi_env env = reinterpret_cast<napi_env>(engine_);
1254 napi_status res = napi_ok;
1255
1256 void *data;
1257 napi_value arraybuffer = nullptr;
1258 res = napi_create_sendable_arraybuffer(env, LENGTH, &data, &arraybuffer);
1259 ASSERT_EQ(res, napi_ok);
1260
1261 napi_value result = nullptr;
1262 res = napi_create_sendable_typedarray(env, napi_int16_array, LENGTH / 2, arraybuffer, OFFSET, &result);
1263 ASSERT_EQ(res, napi_ok);
1264
1265 bool isShared = false;
1266 res = napi_is_sendable(env, result, &isShared);
1267 ASSERT_EQ(res, napi_ok);
1268 ASSERT_EQ(isShared, true);
1269
1270 bool isTypedArray = false;
1271 res = napi_is_typedarray(env, result, &isTypedArray);
1272 ASSERT_EQ(res, napi_ok);
1273 ASSERT_EQ(isTypedArray, true);
1274
1275 napi_typedarray_type type = napi_uint8_array;
1276 size_t length = 0;
1277 void *getData = nullptr;
1278 napi_value getArrayBuffer = nullptr;
1279 size_t byteOffset = 0;
1280 res = napi_get_typedarray_info(env, result, &type, &length, &getData, &getArrayBuffer, &byteOffset);
1281 ASSERT_EQ(res, napi_ok);
1282
1283 bool isEqual = false;
1284 res = napi_strict_equals(env, arraybuffer, getArrayBuffer, &isEqual);
1285 ASSERT_EQ(res, napi_ok);
1286
1287 ASSERT_EQ(type, napi_int16_array);
1288 ASSERT_EQ(length, LENGTH);
1289 ASSERT_EQ(reinterpret_cast<size_t>(getData), reinterpret_cast<size_t>(data) + OFFSET);
1290 ASSERT_EQ(isEqual, true);
1291 ASSERT_EQ(byteOffset, OFFSET);
1292 }
1293
1294 /**
1295 * @tc.name: CreateSendableTypedArray005
1296 * @tc.desc: Test napi_create_sendable_arraybuffer.
1297 * @tc.type: FUNC
1298 */
1299 HWTEST_F(NapiSendableTest, CreateSendableTypedArray005, testing::ext::TestSize.Level1)
1300 {
1301 static size_t LENGTH = 1024;
1302 static size_t OFFSET = 0;
1303 ASSERT_NE(engine_, nullptr);
1304 napi_env env = reinterpret_cast<napi_env>(engine_);
1305 napi_status res = napi_ok;
1306
1307 void *data;
1308 napi_value arraybuffer = nullptr;
1309 res = napi_create_sendable_arraybuffer(env, LENGTH, &data, &arraybuffer);
1310 ASSERT_EQ(res, napi_ok);
1311
1312 napi_value result = nullptr;
1313 res = napi_create_sendable_typedarray(env, napi_uint16_array, LENGTH / 2, arraybuffer, OFFSET, &result);
1314 ASSERT_EQ(res, napi_ok);
1315
1316 bool isShared = false;
1317 res = napi_is_sendable(env, result, &isShared);
1318 ASSERT_EQ(res, napi_ok);
1319 ASSERT_EQ(isShared, true);
1320
1321 bool isTypedArray = false;
1322 res = napi_is_typedarray(env, result, &isTypedArray);
1323 ASSERT_EQ(res, napi_ok);
1324 ASSERT_EQ(isTypedArray, true);
1325
1326 napi_typedarray_type type = napi_uint8_array;
1327 size_t length = 0;
1328 void *getData = nullptr;
1329 napi_value getArrayBuffer = nullptr;
1330 size_t byteOffset = 0;
1331 res = napi_get_typedarray_info(env, result, &type, &length, &getData, &getArrayBuffer, &byteOffset);
1332 ASSERT_EQ(res, napi_ok);
1333
1334 bool isEqual = false;
1335 res = napi_strict_equals(env, arraybuffer, getArrayBuffer, &isEqual);
1336 ASSERT_EQ(res, napi_ok);
1337
1338 ASSERT_EQ(type, napi_uint16_array);
1339 ASSERT_EQ(length, LENGTH);
1340 ASSERT_EQ(reinterpret_cast<size_t>(getData), reinterpret_cast<size_t>(data) + OFFSET);
1341 ASSERT_EQ(isEqual, true);
1342 ASSERT_EQ(byteOffset, OFFSET);
1343 }
1344
1345 /**
1346 * @tc.name: CreateSendableTypedArray006
1347 * @tc.desc: Test napi_create_sendable_arraybuffer.
1348 * @tc.type: FUNC
1349 */
1350 HWTEST_F(NapiSendableTest, CreateSendableTypedArray006, testing::ext::TestSize.Level1)
1351 {
1352 static size_t LENGTH = 1024;
1353 static size_t OFFSET = 0;
1354 ASSERT_NE(engine_, nullptr);
1355 napi_env env = reinterpret_cast<napi_env>(engine_);
1356 napi_status res = napi_ok;
1357
1358 void *data;
1359 napi_value arraybuffer = nullptr;
1360 res = napi_create_sendable_arraybuffer(env, LENGTH * 2, &data, &arraybuffer);
1361 ASSERT_EQ(res, napi_ok);
1362
1363 napi_value result = nullptr;
1364 res = napi_create_sendable_typedarray(env, napi_uint32_array, LENGTH / 2, arraybuffer, OFFSET, &result);
1365 ASSERT_EQ(res, napi_ok);
1366
1367 bool isShared = false;
1368 res = napi_is_sendable(env, result, &isShared);
1369 ASSERT_EQ(res, napi_ok);
1370 ASSERT_EQ(isShared, true);
1371
1372 bool isTypedArray = false;
1373 res = napi_is_typedarray(env, result, &isTypedArray);
1374 ASSERT_EQ(res, napi_ok);
1375 ASSERT_EQ(isTypedArray, true);
1376
1377 napi_typedarray_type type = napi_int8_array;
1378 size_t length = 0;
1379 void *getData = nullptr;
1380 napi_value getArrayBuffer = nullptr;
1381 size_t byteOffset = 0;
1382 res = napi_get_typedarray_info(env, result, &type, &length, &getData, &getArrayBuffer, &byteOffset);
1383 ASSERT_EQ(res, napi_ok);
1384
1385 bool isEqual = false;
1386 res = napi_strict_equals(env, arraybuffer, getArrayBuffer, &isEqual);
1387 ASSERT_EQ(res, napi_ok);
1388
1389 ASSERT_EQ(type, napi_uint32_array);
1390 ASSERT_EQ(length, LENGTH * 2);
1391 ASSERT_EQ(reinterpret_cast<size_t>(getData), reinterpret_cast<size_t>(data) + OFFSET);
1392 ASSERT_EQ(isEqual, true);
1393 ASSERT_EQ(byteOffset, OFFSET);
1394 }
1395
1396 /**
1397 * @tc.name: CreateSendableTypedArray007
1398 * @tc.desc: Test napi_create_sendable_arraybuffer.
1399 * @tc.type: FUNC
1400 */
1401 HWTEST_F(NapiSendableTest, CreateSendableTypedArray007, testing::ext::TestSize.Level1)
1402 {
1403 static size_t LENGTH = 1024;
1404 static size_t OFFSET = 0;
1405 ASSERT_NE(engine_, nullptr);
1406 napi_env env = reinterpret_cast<napi_env>(engine_);
1407 napi_status res = napi_ok;
1408
1409 void *data;
1410 napi_value arraybuffer = nullptr;
1411 res = napi_create_sendable_arraybuffer(env, LENGTH * 2, &data, &arraybuffer);
1412 ASSERT_EQ(res, napi_ok);
1413
1414 napi_value result = nullptr;
1415 res = napi_create_sendable_typedarray(env, napi_int32_array, LENGTH / 2, arraybuffer, OFFSET, &result);
1416 ASSERT_EQ(res, napi_ok);
1417
1418 bool isShared = false;
1419 res = napi_is_sendable(env, result, &isShared);
1420 ASSERT_EQ(res, napi_ok);
1421 ASSERT_EQ(isShared, true);
1422
1423 bool isTypedArray = false;
1424 res = napi_is_typedarray(env, result, &isTypedArray);
1425 ASSERT_EQ(res, napi_ok);
1426 ASSERT_EQ(isTypedArray, true);
1427
1428 napi_typedarray_type type = napi_int8_array;
1429 size_t length = 0;
1430 void *getData = nullptr;
1431 napi_value getArrayBuffer = nullptr;
1432 size_t byteOffset = 0;
1433 res = napi_get_typedarray_info(env, result, &type, &length, &getData, &getArrayBuffer, &byteOffset);
1434 ASSERT_EQ(res, napi_ok);
1435
1436 bool isEqual = false;
1437 res = napi_strict_equals(env, arraybuffer, getArrayBuffer, &isEqual);
1438 ASSERT_EQ(res, napi_ok);
1439
1440 ASSERT_EQ(type, napi_int32_array);
1441 ASSERT_EQ(length, LENGTH * 2);
1442 ASSERT_EQ(reinterpret_cast<size_t>(getData), reinterpret_cast<size_t>(data) + OFFSET);
1443 ASSERT_EQ(isEqual, true);
1444 ASSERT_EQ(byteOffset, OFFSET);
1445 }
1446
1447 /**
1448 * @tc.name: CreateSendableTypedArray008
1449 * @tc.desc: Test napi_create_sendable_arraybuffer.
1450 * @tc.type: FUNC
1451 */
1452 HWTEST_F(NapiSendableTest, CreateSendableTypedArray008, testing::ext::TestSize.Level1)
1453 {
1454 static size_t LENGTH = 1024;
1455 static size_t OFFSET = 0;
1456 ASSERT_NE(engine_, nullptr);
1457 napi_env env = reinterpret_cast<napi_env>(engine_);
1458 napi_status res = napi_ok;
1459
1460 void *data;
1461 napi_value arraybuffer = nullptr;
1462 res = napi_create_sendable_arraybuffer(env, LENGTH * 2, &data, &arraybuffer);
1463 ASSERT_EQ(res, napi_ok);
1464
1465 napi_value result = nullptr;
1466 res = napi_create_sendable_typedarray(env, napi_float32_array, LENGTH / 2, arraybuffer, OFFSET, &result);
1467 ASSERT_EQ(res, napi_ok);
1468
1469 bool isShared = false;
1470 res = napi_is_sendable(env, result, &isShared);
1471 ASSERT_EQ(res, napi_ok);
1472 ASSERT_EQ(isShared, true);
1473
1474 bool isTypedArray = false;
1475 res = napi_is_typedarray(env, result, &isTypedArray);
1476 ASSERT_EQ(res, napi_ok);
1477 ASSERT_EQ(isTypedArray, true);
1478
1479 napi_typedarray_type type = napi_int8_array;
1480 size_t length = 0;
1481 void *getData = nullptr;
1482 napi_value getArrayBuffer = nullptr;
1483 size_t byteOffset = 0;
1484 res = napi_get_typedarray_info(env, result, &type, &length, &getData, &getArrayBuffer, &byteOffset);
1485 ASSERT_EQ(res, napi_ok);
1486
1487 bool isEqual = false;
1488 res = napi_strict_equals(env, arraybuffer, getArrayBuffer, &isEqual);
1489 ASSERT_EQ(res, napi_ok);
1490
1491 ASSERT_EQ(type, napi_float32_array);
1492 ASSERT_EQ(length, LENGTH * 2);
1493 ASSERT_EQ(reinterpret_cast<size_t>(getData), reinterpret_cast<size_t>(data) + OFFSET);
1494 ASSERT_EQ(isEqual, true);
1495 ASSERT_EQ(byteOffset, OFFSET);
1496 }
1497
1498 /**
1499 * @tc.name: CreateSendableTypedArray009
1500 * @tc.desc: Test napi_create_sendable_arraybuffer.
1501 * @tc.type: FUNC
1502 */
1503 HWTEST_F(NapiSendableTest, CreateSendableTypedArray009, testing::ext::TestSize.Level1)
1504 {
1505 static size_t LENGTH = 1024;
1506 static size_t OFFSET = 128;
1507 ASSERT_NE(engine_, nullptr);
1508 napi_env env = reinterpret_cast<napi_env>(engine_);
1509 napi_status res = napi_ok;
1510
1511 void *data;
1512 napi_value arraybuffer = nullptr;
1513 res = napi_create_sendable_arraybuffer(env, LENGTH, &data, &arraybuffer);
1514 ASSERT_EQ(res, napi_ok);
1515
1516 napi_value result = nullptr;
1517 res = napi_create_sendable_typedarray(env, napi_uint8_clamped_array, LENGTH / 2, arraybuffer, OFFSET, &result);
1518 ASSERT_EQ(res, napi_ok);
1519
1520 bool isShared = false;
1521 res = napi_is_sendable(env, result, &isShared);
1522 ASSERT_EQ(res, napi_ok);
1523 ASSERT_EQ(isShared, true);
1524
1525 bool isTypedArray = false;
1526 res = napi_is_typedarray(env, result, &isTypedArray);
1527 ASSERT_EQ(res, napi_ok);
1528 ASSERT_EQ(isTypedArray, true);
1529
1530 napi_typedarray_type type = napi_uint8_array;
1531 size_t length = 0;
1532 void *getData = nullptr;
1533 napi_value getArrayBuffer = nullptr;
1534 size_t byteOffset = 0;
1535 res = napi_get_typedarray_info(env, result, &type, &length, &getData, &getArrayBuffer, &byteOffset);
1536 ASSERT_EQ(res, napi_ok);
1537
1538 bool isEqual = false;
1539 res = napi_strict_equals(env, arraybuffer, getArrayBuffer, &isEqual);
1540 ASSERT_EQ(res, napi_ok);
1541
1542 ASSERT_EQ(type, napi_uint8_clamped_array);
1543 ASSERT_EQ(length, LENGTH / 2);
1544 ASSERT_EQ(reinterpret_cast<size_t>(getData), reinterpret_cast<size_t>(data) + OFFSET);
1545 ASSERT_EQ(isEqual, true);
1546 ASSERT_EQ(byteOffset, OFFSET);
1547 }
1548
1549 /**
1550 * @tc.name: CreateSendableTypedArray010
1551 * @tc.desc: Test napi_create_sendable_typedarray with non-sendable arraybuffer.
1552 * @tc.type: FUNC
1553 */
1554 HWTEST_F(NapiSendableTest, CreateSendableTypedArray010, testing::ext::TestSize.Level1)
1555 {
1556 static size_t LENGTH = 1024;
1557 ASSERT_NE(engine_, nullptr);
1558 napi_env env = reinterpret_cast<napi_env>(engine_);
1559 napi_status res = napi_ok;
1560
1561 void *data;
1562 napi_value arraybuffer = nullptr;
1563 napi_value result = nullptr;
1564 res = napi_create_arraybuffer(env, LENGTH, &data, &arraybuffer);
1565 ASSERT_EQ(res, napi_ok);
1566
1567 bool isShared = false;
1568 res = napi_is_sendable(env, arraybuffer, &isShared);
1569 ASSERT_EQ(res, napi_ok);
1570 ASSERT_EQ(isShared, false);
1571
1572 res = napi_create_sendable_typedarray(env, napi_uint8_clamped_array, LENGTH / 2, arraybuffer, 1, &result);
1573 ASSERT_EQ(res, napi_arraybuffer_expected);
1574 }
1575
1576 /**
1577 * @tc.name: CreateSendableTypedArray011
1578 * @tc.desc: Test napi_create_sendable_typedarray with non-sendable arraybuffer.
1579 * @tc.type: FUNC
1580 */
1581 HWTEST_F(NapiSendableTest, CreateSendableTypedArray011, testing::ext::TestSize.Level1)
1582 {
1583 static size_t LENGTH = 1024;
1584 ASSERT_NE(engine_, nullptr);
1585 napi_env env = reinterpret_cast<napi_env>(engine_);
1586 napi_status res = napi_ok;
1587
1588 void *data;
1589 napi_value arraybuffer = nullptr;
1590 napi_value result = nullptr;
1591 res = napi_create_arraybuffer(env, LENGTH, &data, &arraybuffer);
1592 ASSERT_EQ(res, napi_ok);
1593
1594 bool isShared = false;
1595 res = napi_is_sendable(env, arraybuffer, &isShared);
1596 ASSERT_EQ(res, napi_ok);
1597 ASSERT_EQ(isShared, false);
1598
1599 res = napi_create_sendable_typedarray(env, napi_uint8_array, LENGTH / 2, arraybuffer, 1, &result);
1600 ASSERT_EQ(res, napi_arraybuffer_expected);
1601 }
1602
1603 /**
1604 * @tc.name: CreateSendableTypedArray012
1605 * @tc.desc: Test napi_create_sendable_typedarray with non-sendable arraybuffer.
1606 * @tc.type: FUNC
1607 */
1608 HWTEST_F(NapiSendableTest, CreateSendableTypedArray012, testing::ext::TestSize.Level1)
1609 {
1610 static size_t LENGTH = 1024;
1611 ASSERT_NE(engine_, nullptr);
1612 napi_env env = reinterpret_cast<napi_env>(engine_);
1613 napi_status res = napi_ok;
1614
1615 void *data;
1616 napi_value arraybuffer = nullptr;
1617 napi_value result = nullptr;
1618 res = napi_create_arraybuffer(env, LENGTH, &data, &arraybuffer);
1619 ASSERT_EQ(res, napi_ok);
1620
1621 bool isShared = false;
1622 res = napi_is_sendable(env, arraybuffer, &isShared);
1623 ASSERT_EQ(res, napi_ok);
1624 ASSERT_EQ(isShared, false);
1625
1626 res = napi_create_sendable_typedarray(env, napi_int8_array, LENGTH / 2, arraybuffer, 1, &result);
1627 ASSERT_EQ(res, napi_arraybuffer_expected);
1628 }
1629
1630 /**
1631 * @tc.name: CreateSendableTypedArray013
1632 * @tc.desc: Test napi_create_sendable_typedarray with non-sendable arraybuffer.
1633 * @tc.type: FUNC
1634 */
1635 HWTEST_F(NapiSendableTest, CreateSendableTypedArray013, testing::ext::TestSize.Level1)
1636 {
1637 static size_t LENGTH = 1024;
1638 ASSERT_NE(engine_, nullptr);
1639 napi_env env = reinterpret_cast<napi_env>(engine_);
1640 napi_status res = napi_ok;
1641
1642 void *data;
1643 napi_value arraybuffer = nullptr;
1644 napi_value result = nullptr;
1645 res = napi_create_arraybuffer(env, LENGTH, &data, &arraybuffer);
1646 ASSERT_EQ(res, napi_ok);
1647
1648 bool isShared = false;
1649 res = napi_is_sendable(env, arraybuffer, &isShared);
1650 ASSERT_EQ(res, napi_ok);
1651 ASSERT_EQ(isShared, false);
1652
1653 res = napi_create_sendable_typedarray(env, napi_uint16_array, LENGTH / 2, arraybuffer, 1, &result);
1654 ASSERT_EQ(res, napi_arraybuffer_expected);
1655 }
1656
1657 /**
1658 * @tc.name: CreateSendableTypedArray014
1659 * @tc.desc: Test napi_create_sendable_typedarray with non-sendable arraybuffer.
1660 * @tc.type: FUNC
1661 */
1662 HWTEST_F(NapiSendableTest, CreateSendableTypedArray014, testing::ext::TestSize.Level1)
1663 {
1664 static size_t LENGTH = 1024;
1665 ASSERT_NE(engine_, nullptr);
1666 napi_env env = reinterpret_cast<napi_env>(engine_);
1667 napi_status res = napi_ok;
1668
1669 void *data;
1670 napi_value arraybuffer = nullptr;
1671 napi_value result = nullptr;
1672 res = napi_create_arraybuffer(env, LENGTH, &data, &arraybuffer);
1673 ASSERT_EQ(res, napi_ok);
1674
1675 bool isShared = false;
1676 res = napi_is_sendable(env, arraybuffer, &isShared);
1677 ASSERT_EQ(res, napi_ok);
1678 ASSERT_EQ(isShared, false);
1679
1680 res = napi_create_sendable_typedarray(env, napi_int16_array, LENGTH / 2, arraybuffer, 1, &result);
1681 ASSERT_EQ(res, napi_arraybuffer_expected);
1682 }
1683
1684 /**
1685 * @tc.name: CreateSendableTypedArray015
1686 * @tc.desc: Test napi_create_sendable_typedarray with non-sendable arraybuffer.
1687 * @tc.type: FUNC
1688 */
1689 HWTEST_F(NapiSendableTest, CreateSendableTypedArray015, testing::ext::TestSize.Level1)
1690 {
1691 static size_t LENGTH = 1024;
1692 ASSERT_NE(engine_, nullptr);
1693 napi_env env = reinterpret_cast<napi_env>(engine_);
1694 napi_status res = napi_ok;
1695
1696 void *data;
1697 napi_value arraybuffer = nullptr;
1698 napi_value result = nullptr;
1699 res = napi_create_arraybuffer(env, LENGTH, &data, &arraybuffer);
1700 ASSERT_EQ(res, napi_ok);
1701
1702 bool isShared = false;
1703 res = napi_is_sendable(env, arraybuffer, &isShared);
1704 ASSERT_EQ(res, napi_ok);
1705 ASSERT_EQ(isShared, false);
1706
1707 res = napi_create_sendable_typedarray(env, napi_uint32_array, LENGTH / 2, arraybuffer, 1, &result);
1708 ASSERT_EQ(res, napi_arraybuffer_expected);
1709 }
1710
1711 /**
1712 * @tc.name: CreateSendableTypedArray016
1713 * @tc.desc: Test napi_create_sendable_typedarray with non-sendable arraybuffer.
1714 * @tc.type: FUNC
1715 */
1716 HWTEST_F(NapiSendableTest, CreateSendableTypedArray016, testing::ext::TestSize.Level1)
1717 {
1718 static size_t LENGTH = 1024;
1719 ASSERT_NE(engine_, nullptr);
1720 napi_env env = reinterpret_cast<napi_env>(engine_);
1721 napi_status res = napi_ok;
1722
1723 void *data;
1724 napi_value arraybuffer = nullptr;
1725 napi_value result = nullptr;
1726 res = napi_create_arraybuffer(env, LENGTH, &data, &arraybuffer);
1727 ASSERT_EQ(res, napi_ok);
1728
1729 bool isShared = false;
1730 res = napi_is_sendable(env, arraybuffer, &isShared);
1731 ASSERT_EQ(res, napi_ok);
1732 ASSERT_EQ(isShared, false);
1733
1734 res = napi_create_sendable_typedarray(env, napi_int32_array, LENGTH / 2, arraybuffer, 1, &result);
1735 ASSERT_EQ(res, napi_arraybuffer_expected);
1736 }
1737
1738 /**
1739 * @tc.name: CreateSendableTypedArray017
1740 * @tc.desc: Test napi_create_sendable_typedarray with non-sendable arraybuffer.
1741 * @tc.type: FUNC
1742 */
1743 HWTEST_F(NapiSendableTest, CreateSendableTypedArray017, testing::ext::TestSize.Level1)
1744 {
1745 static size_t LENGTH = 1024;
1746 ASSERT_NE(engine_, nullptr);
1747 napi_env env = reinterpret_cast<napi_env>(engine_);
1748 napi_status res = napi_ok;
1749
1750 void *data;
1751 napi_value arraybuffer = nullptr;
1752 napi_value result = nullptr;
1753 res = napi_create_arraybuffer(env, LENGTH, &data, &arraybuffer);
1754 ASSERT_EQ(res, napi_ok);
1755
1756 bool isShared = false;
1757 res = napi_is_sendable(env, arraybuffer, &isShared);
1758 ASSERT_EQ(res, napi_ok);
1759 ASSERT_EQ(isShared, false);
1760
1761 res = napi_create_sendable_typedarray(env, napi_float32_array, LENGTH / 2, arraybuffer, 1, &result);
1762 ASSERT_EQ(res, napi_arraybuffer_expected);
1763 }
1764
1765 /**
1766 * @tc.name: CreateSendableTypedArray018
1767 * @tc.desc: Test napi_create_sendable_arraybuffer.
1768 * @tc.type: FUNC
1769 */
1770 HWTEST_F(NapiSendableTest, CreateSendableTypedArray018, testing::ext::TestSize.Level1)
1771 {
1772 static size_t LENGTH = 1024;
1773 static size_t OFFSET = 0;
1774 ASSERT_NE(engine_, nullptr);
1775 napi_env env = reinterpret_cast<napi_env>(engine_);
1776
1777 void* data;
1778 napi_value arraybuffer = nullptr;
1779 ASSERT_CHECK_CALL(napi_create_sendable_arraybuffer(env, LENGTH, &data, &arraybuffer));
1780
1781 for (int type = napi_int8_array; type <= napi_float32_array; ++type) {
1782 napi_value result = nullptr;
1783 ASSERT_CHECK_CALL(napi_create_sendable_typedarray(env, static_cast<napi_typedarray_type>(type), LENGTH / 4,
1784 arraybuffer, OFFSET, &result));
1785 bool isTypedArray = false;
1786 ASSERT_CHECK_CALL(napi_is_typedarray(env, result, &isTypedArray));
1787 ASSERT_EQ(isTypedArray, true);
1788 }
1789 }
1790
1791 /**
1792 * @tc.name: IsDetachedSendableArrayBufferTest001
1793 * @tc.desc: Test is DetachedSendableArrayBuffer.
1794 * @tc.type: FUNC
1795 */
1796 HWTEST_F(NapiSendableTest, IsDetachedSendableArrayBufferTest001, testing::ext::TestSize.Level1)
1797 {
1798 static constexpr size_t arrayBufferSize = 1024;
1799 napi_env env = (napi_env)engine_;
1800 napi_value arrayBuffer = nullptr;
1801 void* arrayBufferPtr = nullptr;
1802 napi_create_sendable_arraybuffer(env, arrayBufferSize, &arrayBufferPtr, &arrayBuffer);
1803
1804 auto out = napi_detach_arraybuffer(env, arrayBuffer);
1805 if (out == napi_ok) {
1806 arrayBufferPtr = nullptr;
1807 }
1808 ASSERT_EQ(out, napi_ok);
1809 }
1810
SendableGetter(napi_env env,napi_callback_info info)1811 static napi_value SendableGetter(napi_env env, napi_callback_info info)
1812 {
1813 napi_value res;
1814 napi_get_boolean(env, false, &res);
1815 return res;
1816 }
1817
SendableSetter(napi_env env,napi_callback_info info)1818 static napi_value SendableSetter(napi_env env, napi_callback_info info)
1819 {
1820 napi_value res;
1821 napi_get_boolean(env, true, &res);
1822 return res;
1823 }
1824
1825 HWTEST_F(NapiSendableTest, CreateSendableObjectWithPropertiesTest001, testing::ext::TestSize.Level1)
1826 {
1827 napi_env env = (napi_env)engine_;
1828 napi_value excep;
1829 ASSERT_CHECK_CALL(napi_get_and_clear_last_exception(env, &excep));
1830 napi_value val_false;
1831 napi_value val_true;
1832 ASSERT_CHECK_CALL(napi_get_boolean(env, false, &val_false));
1833 ASSERT_CHECK_CALL(napi_get_boolean(env, true, &val_true));
1834 napi_property_descriptor desc1[] = {
1835 DECLARE_NAPI_DEFAULT_PROPERTY("x", val_true),
1836 };
1837 napi_value obj1;
1838 ASSERT_CHECK_CALL(napi_create_sendable_object_with_properties(env, 1, desc1, &obj1));
1839 napi_value obj2;
1840 napi_property_descriptor desc2[] = {
1841 DECLARE_NAPI_DEFAULT_PROPERTY("a", val_false),
1842 DECLARE_NAPI_GETTER_SETTER("b", SendableGetter, SendableSetter),
1843 DECLARE_NAPI_DEFAULT_PROPERTY("c", obj1),
1844 };
1845 ASSERT_CHECK_CALL(napi_create_sendable_object_with_properties(env, 3, desc2, &obj2));
1846 ASSERT_CHECK_VALUE_TYPE(env, obj1, napi_object);
1847 ASSERT_CHECK_VALUE_TYPE(env, obj2, napi_object);
__anon35b464c61002(napi_value obj, const char* keyStr, napi_value expect) 1848 auto checkPropertyEqualsTo = [env](napi_value obj, const char* keyStr, napi_value expect) -> bool {
1849 napi_value result;
1850 napi_get_named_property(env, obj, keyStr, &result);
1851 bool equal = false;
1852 napi_strict_equals(env, result, expect, &equal);
1853 return equal;
1854 };
1855 // get obj1.x == true
1856 ASSERT_TRUE(checkPropertyEqualsTo(obj1, "x", val_true));
1857 // set obj1.x = false
1858 ASSERT_CHECK_CALL(napi_set_named_property(env, obj1, "x", val_false));
1859 // get obj1.x == false
1860 ASSERT_TRUE(checkPropertyEqualsTo(obj1, "x", val_false));
1861 // get obj2.a == false
1862 ASSERT_TRUE(checkPropertyEqualsTo(obj2, "a", val_false));
1863 // get obj2.b == false
1864 ASSERT_TRUE(checkPropertyEqualsTo(obj2, "b", val_false));
1865 // set obj2.b = true (useless)
1866 ASSERT_CHECK_CALL(napi_set_named_property(env, obj2, "b", val_true));
1867 // get obj2.b == false
1868 ASSERT_TRUE(checkPropertyEqualsTo(obj2, "b", val_false));
1869 // get obj2.c == obj1
1870 ASSERT_TRUE(checkPropertyEqualsTo(obj2, "c", obj1));
1871 // get obj2.c.x == false
1872 napi_value val_res;
1873 ASSERT_CHECK_CALL(napi_get_named_property(env, obj2, "c", &val_res));
1874 ASSERT_TRUE(checkPropertyEqualsTo(val_res, "x", val_false));
1875 }
1876
1877 bool g_funcCalled = false;
Func(napi_env env,napi_callback_info info)1878 static napi_value Func(napi_env env, napi_callback_info info)
1879 {
1880 napi_value boolTrue = nullptr;
1881 napi_value boolFalse = nullptr;
1882 napi_get_boolean(env, true, &boolTrue);
1883 napi_get_boolean(env, false, &boolFalse);
1884
1885 if (g_funcCalled) {
1886 return boolFalse;
1887 }
1888
1889 char *data = nullptr;
1890 napi_value thisVar = nullptr;
1891 napi_get_cb_info(env, info, nullptr, nullptr, &thisVar, nullptr);
1892 napi_unwrap_sendable(env, thisVar, reinterpret_cast<void**>(&data));
1893 if (*data == 'a') {
1894 g_funcCalled = true;
1895 delete [] data;
1896 }
1897
1898 return boolTrue;
1899 }
1900
1901 HWTEST_F(NapiSendableTest, CreateSendableObjectWithPropertiesTest002, testing::ext::TestSize.Level1)
1902 {
1903 napi_env env = (napi_env)engine_;
1904 napi_value excep;
1905 ASSERT_CHECK_CALL(napi_get_and_clear_last_exception(env, &excep));
1906
1907 napi_value obj2;
1908 napi_property_descriptor desc2[] = {
1909 DECLARE_NAPI_FUNCTION("func", Func),
1910 };
1911 ASSERT_CHECK_CALL(napi_create_sendable_object_with_properties(env, 1, desc2, &obj2));
1912 bool isShared = false;
1913 napi_is_sendable(env, obj2, &isShared);
1914 ASSERT_EQ(isShared, true);
1915
1916 auto data = new char[2];
1917 *data = 'a';
1918 *(data + 1) = 0;
1919 napi_wrap_sendable(env, obj2, data, nullptr, nullptr);
1920 ASSERT_CHECK_VALUE_TYPE(env, obj2, napi_object);
1921 napi_value func = nullptr;
1922 napi_value ret = nullptr;
1923 napi_get_named_property(env, obj2, "func", &func);
1924 ASSERT_EQ(g_funcCalled, false);
1925 napi_call_function(env, obj2, func, 0, nullptr, &ret);
1926 bool resultBool = false;
1927 napi_get_value_bool(env, ret, &resultBool);
1928 ASSERT_EQ(resultBool, true);
1929 ASSERT_EQ(g_funcCalled, true);
1930 }
1931
1932 /**
1933 * @tc.name: SerializeDeSerializeSendableDataTest001
1934 * @tc.desc: Test serialize & deserialize sendableArray.
1935 * @tc.type: FUNC
1936 */
1937 HWTEST_F(NapiSendableTest, SerializeDeSerializeSendableDataTest001, testing::ext::TestSize.Level1)
1938 {
1939 napi_env env = (napi_env)engine_;
1940 napi_status res = napi_ok;
1941 napi_value excep;
1942 ASSERT_CHECK_CALL(napi_get_and_clear_last_exception(env, &excep));
1943 napi_value num = nullptr;
1944 uint32_t value = 1000;
1945 res = napi_create_uint32(env, value, &num);
1946 ASSERT_EQ(res, napi_ok);
1947 napi_property_descriptor desc[] = {
1948 DECLARE_NAPI_DEFAULT_PROPERTY("a", num),
1949 };
1950 napi_value obj;
1951 ASSERT_CHECK_CALL(napi_create_sendable_object_with_properties(env, 1, desc, &obj));
1952 ASSERT_CHECK_VALUE_TYPE(env, obj, napi_object);
1953
1954 napi_value undefined = nullptr;
1955 napi_get_undefined(env, &undefined);
1956 void* data = nullptr;
1957 res = napi_serialize(env, obj, undefined, undefined, &data);
1958 ASSERT_NE(data, nullptr);
1959 ASSERT_EQ(res, napi_ok);
1960
1961 napi_value result1 = nullptr;
1962 res = napi_deserialize(env, data, &result1);
1963 ASSERT_CHECK_VALUE_TYPE(env, result1, napi_object);
1964
1965 napi_value number1 = nullptr;;
1966 napi_get_named_property(env, result1, "a", &number1);
1967 ASSERT_CHECK_VALUE_TYPE(env, number1, napi_number);
1968
1969 napi_delete_serialization_data(env, data);
1970 }
1971
1972 /**
1973 * @tc.name: SerializeDeSerializeSendableDataTest002
1974 * @tc.desc: Test serialize & deserialize sendableArray.
1975 * @tc.type: FUNC
1976 */
1977 HWTEST_F(NapiSendableTest, SerializeDeSerializeSendableDataTest002, testing::ext::TestSize.Level1)
1978 {
1979 napi_env env = (napi_env) engine_;
1980
1981 napi_status res = napi_ok;
1982 napi_value sendableArray = nullptr;
1983 napi_create_sendable_array(env, &sendableArray);
1984 ASSERT_NE(sendableArray, nullptr);
1985 bool isShared = false;
1986 res = napi_is_sendable(env, sendableArray, &isShared);
1987 ASSERT_EQ(res, napi_ok);
1988 ASSERT_EQ(isShared, true);
1989 bool isArray = false;
1990 napi_is_array(env, sendableArray, &isArray);
1991 ASSERT_TRUE(isArray);
1992 for (size_t i = 0; i < 10; i++) {
1993 napi_value num = nullptr;
1994 napi_create_uint32(env, i, &num);
1995 napi_set_element(env, sendableArray, i, num);
1996 }
1997
1998 uint32_t length = 0;
1999 res = napi_get_array_length(env, sendableArray, &length);
2000 ASSERT_EQ(res, napi_ok);
2001 ASSERT_EQ(length, 10u);
2002
2003 napi_value undefined = nullptr;
2004 napi_get_undefined(env, &undefined);
2005 void* data = nullptr;
2006 res = napi_serialize(env, sendableArray, undefined, undefined, &data);
2007 ASSERT_NE(data, nullptr);
2008 ASSERT_EQ(res, napi_ok);
2009
2010 napi_value result1 = nullptr;
2011 napi_deserialize(env, data, &result1);
2012 ASSERT_CHECK_VALUE_TYPE(env, result1, napi_object);
2013
2014 res = napi_get_array_length(env, result1, &length);
2015 ASSERT_EQ(res, napi_ok);
2016 ASSERT_EQ(length, 10u);
2017
2018 napi_delete_serialization_data(env, data);
2019 }
2020
2021 /**
2022 * @tc.name: SerializeDeSerializeSendableDataTest003
2023 * @tc.desc: Test serialize & deserialize sendableArrayWithLength.
2024 * @tc.type: FUNC
2025 */
2026 HWTEST_F(NapiSendableTest, SerializeDeSerializeSendableDataTest003, testing::ext::TestSize.Level1)
2027 {
2028 static uint32_t LENGTH = 1024;
2029 ASSERT_NE(engine_, nullptr);
2030 napi_env env = reinterpret_cast<napi_env>(engine_);
2031 napi_status res = napi_ok;
2032
2033 napi_value sendableArray = nullptr;
2034 res = napi_create_sendable_array_with_length(env, LENGTH, &sendableArray);
2035 ASSERT_EQ(res, napi_ok);
2036
2037 bool isShared = false;
2038 res = napi_is_sendable(env, sendableArray, &isShared);
2039 ASSERT_EQ(res, napi_ok);
2040 ASSERT_EQ(isShared, true);
2041 bool isArray = false;
2042 napi_is_array(env, sendableArray, &isArray);
2043 ASSERT_TRUE(isArray);
2044 for (size_t i = 0; i < 100; i++) {
2045 napi_value num = nullptr;
2046 napi_create_uint32(env, i, &num);
2047 napi_set_element(env, sendableArray, i, num);
2048 }
2049
2050 uint32_t length = 0;
2051 res = napi_get_array_length(env, sendableArray, &length);
2052 ASSERT_EQ(res, napi_ok);
2053 ASSERT_EQ(length, 1024);
2054
2055 napi_value undefined = nullptr;
2056 napi_get_undefined(env, &undefined);
2057 void* data = nullptr;
2058 res = napi_serialize(env, sendableArray, undefined, undefined, &data);
2059 ASSERT_NE(data, nullptr);
2060 ASSERT_EQ(res, napi_ok);
2061
2062 napi_value result1 = nullptr;
2063 napi_deserialize(env, data, &result1);
2064 ASSERT_CHECK_VALUE_TYPE(env, result1, napi_object);
2065
2066 res = napi_get_array_length(env, result1, &length);
2067 ASSERT_EQ(res, napi_ok);
2068 ASSERT_EQ(length, 1024);
2069
2070 napi_delete_serialization_data(env, data);
2071 }
2072
2073 /**
2074 * @tc.name: SerializeDeSerializeSendableDataTest004
2075 * @tc.desc: Test serialize & deserialize sendableTypedArray.
2076 * @tc.type: FUNC
2077 */
2078 HWTEST_F(NapiSendableTest, SerializeDeSerializeSendableDataTest004, testing::ext::TestSize.Level1)
2079 {
2080 static size_t LENGTH = 1024;
2081 static size_t OFFSET = 128;
2082 ASSERT_NE(engine_, nullptr);
2083 napi_env env = reinterpret_cast<napi_env>(engine_);
2084 napi_status res = napi_ok;
2085
2086 void *tmpData;
2087 napi_value sendableArraybuffer = nullptr;
2088 napi_value sendableTypedarray = nullptr;
2089 res = napi_create_sendable_arraybuffer(env, LENGTH, &tmpData, &sendableArraybuffer);
2090 ASSERT_EQ(res, napi_ok);
2091
2092 bool isShared = false;
2093 res = napi_is_sendable(env, sendableArraybuffer, &isShared);
2094 ASSERT_EQ(res, napi_ok);
2095 ASSERT_EQ(isShared, true);
2096
2097 res = napi_create_sendable_typedarray(env, napi_int8_array, LENGTH / 2,
2098 sendableArraybuffer, OFFSET, &sendableTypedarray);
2099 ASSERT_EQ(res, napi_ok);
2100
2101 isShared = false;
2102 res = napi_is_sendable(env, sendableArraybuffer, &isShared);
2103 ASSERT_EQ(res, napi_ok);
2104 ASSERT_EQ(isShared, true);
2105
2106 bool isTypedArray = false;
2107 res = napi_is_typedarray(env, sendableTypedarray, &isTypedArray);
2108 ASSERT_EQ(res, napi_ok);
2109 ASSERT_EQ(isTypedArray, true);
2110
2111 napi_value undefined = nullptr;
2112 napi_get_undefined(env, &undefined);
2113 void* data = nullptr;
2114 res = napi_serialize(env, sendableTypedarray, undefined, undefined, &data);
2115 ASSERT_NE(data, nullptr);
2116 ASSERT_EQ(res, napi_ok);
2117
2118 napi_value result = nullptr;
2119 res = napi_deserialize(env, data, &result);
2120 ASSERT_CHECK_VALUE_TYPE(env, result, napi_object);
2121
2122 napi_typedarray_type type = napi_uint8_array;
2123 size_t length = 0;
2124 void *getData = nullptr;
2125 napi_value getArrayBuffer = nullptr;
2126 size_t byteOffset = 0;
2127 res = napi_get_typedarray_info(env, result, &type, &length, &getData, &getArrayBuffer, &byteOffset);
2128 ASSERT_EQ(res, napi_ok);
2129
2130 ASSERT_EQ(type, napi_int8_array);
2131 ASSERT_EQ(length, LENGTH / 2);
2132 ASSERT_EQ(reinterpret_cast<size_t>(getData), reinterpret_cast<size_t>(tmpData) + OFFSET);
2133 ASSERT_EQ(byteOffset, OFFSET);
2134
2135 napi_delete_serialization_data(env, data);
2136 }
2137
2138 /**
2139 * @tc.name: SerializeDeSerializeSendableDataTest005
2140 * @tc.desc: Test serialize & deserialize sendableArrayBuffer.
2141 * @tc.type: FUNC
2142 */
2143 HWTEST_F(NapiSendableTest, SerializeDeSerializeSendableDataTest005, testing::ext::TestSize.Level1)
2144 {
2145 static size_t LENGTH = 1024;
2146 ASSERT_NE(engine_, nullptr);
2147 napi_env env = reinterpret_cast<napi_env>(engine_);
2148 napi_status res = napi_ok;
2149
2150 void *tmpData;
2151 napi_value sendableBuffer = nullptr;
2152 res = napi_create_sendable_arraybuffer(env, LENGTH, &tmpData, &sendableBuffer);
2153 ASSERT_EQ(res, napi_ok);
2154
2155 bool isShared = false;
2156 res = napi_is_sendable(env, sendableBuffer, &isShared);
2157 ASSERT_EQ(res, napi_ok);
2158 ASSERT_EQ(isShared, true);
2159
2160 bool isArrayBuffer = false;
2161 res = napi_is_arraybuffer(env, sendableBuffer, &isArrayBuffer);
2162 ASSERT_EQ(res, napi_ok);
2163 ASSERT_EQ(isArrayBuffer, true);
2164
2165 napi_value undefined = nullptr;
2166 napi_get_undefined(env, &undefined);
2167 void* data = nullptr;
2168 res = napi_serialize(env, sendableBuffer, undefined, undefined, &data);
2169 ASSERT_EQ(res, napi_ok);
2170 ASSERT_NE(data, nullptr);
2171
2172 napi_delete_serialization_data(env, data);
2173 }