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