1 /*
2 * Copyright (c) 2025 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 "test.h"
17 #include "js_native_api_types.h"
18 #include "js_native_api.h"
19 #include "napi/native_api.h"
20 #include "napi/native_node_api.h"
21 #include "native_engine.h"
22
23 static char g_defaultName[] = "defaultName";
24 static char g_defaultData[] = "testData";
Task(void * data)25 static void Task(void* data)
26 {
27 }
28
29 class NapiSendEventTest : public NativeEngineTest {
30 public:
SetUpTestSuite()31 static void SetUpTestSuite() {}
TearDownTestSuite()32 static void TearDownTestSuite() {}
SetUp()33 void SetUp() override {}
TearDown()34 void TearDown() override {}
35 };
36
37 /**
38 * @tc.name: SendEventTest001
39 * @tc.desc: Test napi_send_event invalidParams
40 * @tc.type:FUNC
41 */
42 HWTEST_F(NapiSendEventTest, SendEventTest001, testing::ext::TestSize.Level1)
43 {
__anonf721cdf20102() 44 const std::function<void()> cb = []() -> void {};
45 auto status = napi_send_event(nullptr, cb, napi_eprio_high);
46 EXPECT_EQ(status, napi_status::napi_invalid_arg);
47 }
48
49 /**
50 * @tc.name: SendEventTest002
51 * @tc.desc: Test napi_send_event invalidParams
52 * @tc.type:FUNC
53 */
54 HWTEST_F(NapiSendEventTest, SendEventTest002, testing::ext::TestSize.Level1)
55 {
56 ASSERT_NE(engine_, nullptr);
57 napi_env env = (napi_env)engine_;
58 auto status = napi_send_event(env, nullptr, napi_eprio_high);
59 EXPECT_EQ(status, napi_status::napi_invalid_arg);
60 }
61
62 /**
63 * @tc.name: SendEventTest003
64 * @tc.desc: Test napi_send_event invalidParams
65 * @tc.type:FUNC
66 */
67 HWTEST_F(NapiSendEventTest, SendEventTest003, testing::ext::TestSize.Level1)
68 {
69 ASSERT_NE(engine_, nullptr);
70 napi_env env = (napi_env)engine_;
__anonf721cdf20202() 71 const std::function<void()> cb = []() -> void {};
72 auto status = napi_send_event(env, cb, napi_event_priority(napi_eprio_vip - 1));
73 EXPECT_EQ(status, napi_status::napi_invalid_arg);
74 status = napi_send_event(env, cb, napi_event_priority(napi_eprio_idle + 1));
75 EXPECT_EQ(status, napi_status::napi_invalid_arg);
76 }
77
78 /**
79 * @tc.name: SendEventTest004
80 * @tc.desc: Test napi_send_event sendEventByHandler
81 * @tc.type:FUNC
82 */
83 HWTEST_F(NapiSendEventTest, SendEventTest004, testing::ext::TestSize.Level1)
84 {
85 ASSERT_NE(engine_, nullptr);
86 napi_env env = (napi_env)engine_;
__anonf721cdf20302() 87 const std::function<void()> cb = []() -> void {};
88 if (eventHandler_ == nullptr) {
89 auto runner = OHOS::AppExecFwk::EventRunner::Create(false);
90 EXPECT_NE(runner, nullptr);
91 eventHandler_ = std::make_shared<OHOS::AppExecFwk::EventHandler>(runner);
92 }
93 EXPECT_NE(eventHandler_, nullptr);
94 auto status = napi_send_event(env, cb, napi_eprio_high);
95 EXPECT_EQ(status, napi_status::napi_ok);
96 }
97
98 /**
99 * @tc.name: SendEventTest005
100 * @tc.desc: Test napi_send_event sendEventByUv
101 * @tc.type:FUNC
102 */
103 HWTEST_F(NapiSendEventTest, SendEventTest005, testing::ext::TestSize.Level1)
104 {
105 ASSERT_NE(engine_, nullptr);
106 napi_env env = (napi_env)engine_;
__anonf721cdf20402() 107 const std::function<void()> cb = []() -> void {};
108 eventHandler_ = nullptr;
109 auto status = napi_send_event(env, cb, napi_eprio_high);
110 EXPECT_EQ(status, napi_status::napi_ok);
111 }
112
113 /**
114 * @tc.name: SendCancelableEent001
115 * @tc.desc: Test napi_send_cancelable_event invalidParams
116 * @tc.type:FUNC
117 */
118 HWTEST_F(NapiSendEventTest, SendCancelableEent001, testing::ext::TestSize.Level1)
119 {
120 ASSERT_NE(engine_, nullptr);
121 napi_env env = reinterpret_cast<napi_env>(engine_);
122 uint64_t handleId = 0;
123 auto status = napi_send_cancelable_event(nullptr, Task, g_defaultData, napi_eprio_high, &handleId, g_defaultName);
124 EXPECT_EQ(status, napi_status::napi_invalid_arg);
125 status = napi_send_cancelable_event(env, nullptr, g_defaultData, napi_eprio_high, &handleId, g_defaultName);
126 EXPECT_EQ(status, napi_status::napi_invalid_arg);
127 status = napi_send_cancelable_event(env, Task, g_defaultData, napi_event_priority(napi_eprio_idle + 1),
128 &handleId, g_defaultName);
129 EXPECT_EQ(status, napi_status::napi_invalid_arg);
130 status = napi_send_cancelable_event(env, Task, g_defaultData, napi_eprio_high, nullptr, g_defaultName);
131 EXPECT_EQ(status, napi_status::napi_invalid_arg);
132 }
133
134 /**
135 * @tc.name: SendCancelableEent002
136 * @tc.desc: Test napi_send_cancelable_event sendEventByHandler
137 * @tc.type:FUNC
138 */
139 HWTEST_F(NapiSendEventTest, SendCancelableEent002, testing::ext::TestSize.Level1)
140 {
141 ASSERT_NE(engine_, nullptr);
142 napi_env env = (napi_env)engine_;
143 uint64_t handleId = 0;
144 if (eventHandler_ == nullptr) {
145 auto runner = OHOS::AppExecFwk::EventRunner::Create(false);
146 ASSERT_NE(runner, nullptr);
147 eventHandler_ = std::make_shared<OHOS::AppExecFwk::EventHandler>(runner);
148 ASSERT_NE(eventHandler_, nullptr);
149 }
150 auto status = napi_send_cancelable_event(env, Task, g_defaultData, napi_eprio_high, &handleId, g_defaultName);
151 ASSERT_EQ(status, napi_status::napi_ok);
152 }
153
154 /**
155 * @tc.name: SendCancelableEent003
156 * @tc.desc: Test napi_send_cancelable_event sendEventByUv
157 * @tc.type:FUNC
158 */
159 HWTEST_F(NapiSendEventTest, SendCancelableEent003, testing::ext::TestSize.Level1)
160 {
161 ASSERT_NE(engine_, nullptr);
162 napi_env env = (napi_env)engine_;
163
164 uint64_t handleId = 0;
165 eventHandler_ = nullptr;
166 auto status = napi_send_cancelable_event(env, Task, g_defaultData, napi_eprio_high, &handleId, g_defaultName);
167 ASSERT_EQ(status, napi_status::napi_ok);
168 }
169
170 /**
171 * @tc.name: CancelEvent001
172 * @tc.desc: Test napi_cancel_event invalidParams
173 * @tc.type:FUNC
174 */
175 HWTEST_F(NapiSendEventTest, CancelEvent001, testing::ext::TestSize.Level1)
176 {
177 ASSERT_NE(engine_, nullptr);
178 napi_env env = reinterpret_cast<napi_env>(engine_);
179 uint64_t handleId = 0;
180 auto result = napi_cancel_event(env, handleId, g_defaultName);
181 ASSERT_EQ(result, napi_status::napi_invalid_arg);
182 auto status = napi_send_cancelable_event(env, Task, g_defaultData, napi_eprio_high, &handleId, g_defaultName);
183 ASSERT_NE(handleId, 0);
184 ASSERT_EQ(status, napi_status::napi_ok);
185 result = napi_cancel_event(nullptr, handleId, g_defaultName);
186 ASSERT_EQ(result, napi_status::napi_invalid_arg);
187 }
188
189 /**
190 * @tc.name: CancelEvent002
191 * @tc.desc: Test napi_cancel_event eventHandler_ -> RemoveTask
192 * @tc.type:FUNC
193 */
194 HWTEST_F(NapiSendEventTest, CancelEvent002, testing::ext::TestSize.Level1)
195 {
196 ASSERT_NE(engine_, nullptr);
197 napi_env env = (napi_env)engine_;
198 uint64_t handleId = 0;
199 if (eventHandler_ == nullptr) {
200 auto runner = OHOS::AppExecFwk::EventRunner::Create(false);
201 EXPECT_NE(runner, nullptr);
202 eventHandler_ = std::make_shared<OHOS::AppExecFwk::EventHandler>(runner);
203 ASSERT_NE(eventHandler_, nullptr);
204 }
205 auto status = napi_send_cancelable_event(env, Task, g_defaultData, napi_eprio_high, &handleId, g_defaultName);
206 ASSERT_NE(handleId, 0);
207 ASSERT_EQ(status, napi_status::napi_ok);
208 auto result = napi_cancel_event(env, handleId, g_defaultName);
209 ASSERT_EQ(result, napi_status::napi_ok);
210 }
211
212 /**
213 * @tc.name: CancelEvent003
214 * @tc.desc: Test napi_cancel_event sendEventByUv
215 * @tc.type:FUNC
216 */
217 HWTEST_F(NapiSendEventTest, CancelEvent003, testing::ext::TestSize.Level1)
218 {
219 ASSERT_NE(engine_, nullptr);
220 napi_env env = (napi_env)engine_;
221 uint64_t handleId = 0;
222 eventHandler_ = nullptr;
223 auto status = napi_send_cancelable_event(env, Task, g_defaultData, napi_eprio_high, &handleId, g_defaultName);
224 ASSERT_EQ(status, napi_status::napi_ok);
225 ASSERT_NE(handleId, 0);
226 auto result = napi_cancel_event(env, handleId, g_defaultName);
227 ASSERT_EQ(result, napi_status::napi_ok);
228 }