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
28static constexpr size_t TEST_STR_LENGTH = 30;
29
30class NapiSendableTest : public NativeEngineTest {
31public:
32    static void SetUpTestCase()
33    {
34        GTEST_LOG_(INFO) << "NapiSendableTest SetUpTestCase";
35    }
36
37    static void TearDownTestCase()
38    {
39        GTEST_LOG_(INFO) << "NapiSendableTest TearDownTestCase";
40    }
41
42    void SetUp() override
43    {
44        napi_env env = reinterpret_cast<napi_env>(engine_);
45        napi_open_handle_scope(env, &scope_);
46    }
47
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    }
55private:
56    napi_handle_scope scope_ = nullptr;
57};
58
59napi_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
87napi_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
115napi_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
143HWTEST_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
160HWTEST_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
178HWTEST_F(NapiSendableTest, SendableClassTest001, testing::ext::TestSize.Level1)
179{
180    napi_env env = (napi_env)engine_;
181
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",
199                                     [](napi_env env, napi_callback_info info) -> napi_value { return nullptr; }),
200        DECLARE_NAPI_FUNCTION("func", [](napi_env env, napi_callback_info info) -> napi_value { return nullptr; }),
201        DECLARE_NAPI_GETTER_SETTER(
202            "getterSetter", [](napi_env env, napi_callback_info info) -> napi_value { return nullptr; },
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
221HWTEST_F(NapiSendableTest, SendableClassTest002, testing::ext::TestSize.Level1)
222{
223    napi_env env = (napi_env)engine_;
224
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
286HWTEST_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
340HWTEST_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
392HWTEST_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 */
446HWTEST_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 */
472HWTEST_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 */
513HWTEST_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 */
562HWTEST_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 */
609HWTEST_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 */
649HWTEST_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
684HWTEST_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,
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(
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
720HWTEST_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,
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(
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 */
756HWTEST_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 */
775HWTEST_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 */
790HWTEST_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 */
828HWTEST_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 */
843HWTEST_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 */
874HWTEST_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 */
928HWTEST_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 */
988HWTEST_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 */
1012HWTEST_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 */
1047HWTEST_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 */
1110HWTEST_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 */
1161HWTEST_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 */
1212HWTEST_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 */
1263HWTEST_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 */
1314HWTEST_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 */
1365HWTEST_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 */
1416HWTEST_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 */
1467HWTEST_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 */
1518HWTEST_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 */
1545HWTEST_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 */
1572HWTEST_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 */
1599HWTEST_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 */
1626HWTEST_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 */
1653HWTEST_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 */
1680HWTEST_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 */
1707HWTEST_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 */
1734HWTEST_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 */
1760HWTEST_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
1775static 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
1782static 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
1789HWTEST_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);
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
1841bool g_funcCalled = false;
1842static 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
1865HWTEST_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 */
1901HWTEST_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 */
1941HWTEST_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 */
1990HWTEST_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 */
2042HWTEST_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 */
2107HWTEST_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}