1 /*
2  * Copyright (c) 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 <gtest/gtest.h>
17 
18 #include "delegate_tasks.h"
19 #include "error_multimodal.h"
20 #include "key_event_napi.h"
21 #include "mmi_log.h"
22 
23 #undef MMI_LOG_TAG
24 #define MMI_LOG_TAG "DelegateTasksTest"
25 namespace OHOS {
26 namespace MMI {
27 namespace {
28 using namespace testing::ext;
29 } // namespace
30 
31 class DelegateTasksTest : public testing::Test {
32 public:
SetUpTestCase(void)33     static void SetUpTestCase(void) {}
TearDownTestCase(void)34     static void TearDownTestCase(void) {}
35 };
36 
37 /**
38  * @tc.name: DelegateTasksTest_Init_001
39  * @tc.desc: Test the function Init
40  * @tc.type: FUNC
41  * @tc.require:
42  */
HWTEST_F(DelegateTasksTest, DelegateTasksTest_Init_001, TestSize.Level1)43 HWTEST_F(DelegateTasksTest, DelegateTasksTest_Init_001, TestSize.Level1)
44 {
45     CALL_TEST_DEBUG;
46     DelegateTasks delegateTasks;
47     ASSERT_NO_FATAL_FAILURE(delegateTasks.Init());
48     ASSERT_NO_FATAL_FAILURE(delegateTasks.ProcessTasks());
49     EXPECT_EQ(delegateTasks.PostSyncTask(nullptr), ERROR_NULL_POINTER);
50 }
51 
52 /**
53  * @tc.name: DelegateTasksTest_PostSyncTask_002
54  * @tc.desc: Test the function PostSyncTask
55  * @tc.type: FUNC
56  * @tc.require:
57  */
HWTEST_F(DelegateTasksTest, DelegateTasksTest_PostSyncTask_002, TestSize.Level1)58 HWTEST_F(DelegateTasksTest, DelegateTasksTest_PostSyncTask_002, TestSize.Level1)
59 {
60     CALL_TEST_DEBUG;
61     DelegateTasks delegateTasks;
62     auto callback = []() { return 0; };
63     EXPECT_EQ(delegateTasks.PostSyncTask(callback), 65142804);
64 }
65 
66 /**
67  * @tc.name: DelegateTasksTest_PostSyncTask_003
68  * @tc.desc: Test the function PostSyncTask
69  * @tc.type: FUNC
70  * @tc.require:
71  */
HWTEST_F(DelegateTasksTest, DelegateTasksTest_PostSyncTask_003, TestSize.Level1)72 HWTEST_F(DelegateTasksTest, DelegateTasksTest_PostSyncTask_003, TestSize.Level1)
73 {
74     CALL_TEST_DEBUG;
75     DelegateTasks delegateTasks;
76     auto callback = []() { return 0; };
77     EXPECT_EQ(delegateTasks.PostSyncTask(callback), ETASKS_POST_SYNCTASK_FAIL);
78 }
79 
80 /**
81  * @tc.name: DelegateTasksTest_PostSyncTask_004
82  * @tc.desc: Test the function PostSyncTask
83  * @tc.type: FUNC
84  * @tc.require:
85  */
HWTEST_F(DelegateTasksTest, DelegateTasksTest_PostSyncTask_004, TestSize.Level1)86 HWTEST_F(DelegateTasksTest, DelegateTasksTest_PostSyncTask_004, TestSize.Level1)
87 {
88     CALL_TEST_DEBUG;
89     DelegateTasks delegateTasks;
90     auto callback = []() { std::this_thread::sleep_for(std::chrono::seconds(4)); return 0; };
91     EXPECT_NE(delegateTasks.PostSyncTask(callback), ETASKS_WAIT_TIMEOUT);
92 }
93 
94 /**
95  * @tc.name: DelegateTasksTest_PostSyncTask_005
96  * @tc.desc: Test the function PostSyncTask
97  * @tc.type: FUNC
98  * @tc.require:
99  */
HWTEST_F(DelegateTasksTest, DelegateTasksTest_PostSyncTask_005, TestSize.Level1)100 HWTEST_F(DelegateTasksTest, DelegateTasksTest_PostSyncTask_005, TestSize.Level1)
101 {
102     CALL_TEST_DEBUG;
103     DelegateTasks delegateTasks;
104     auto callback = []() { return 0; };
105     EXPECT_NE(delegateTasks.PostSyncTask(callback), ETASKS_WAIT_DEFERRED);
106 }
107 
108 /**
109  * @tc.name: DelegateTasksTest_PostAsyncTask_001
110  * @tc.desc: Test the function PostAsyncTask
111  * @tc.type: FUNC
112  * @tc.require:
113  */
HWTEST_F(DelegateTasksTest, DelegateTasksTest_PostAsyncTask_001, TestSize.Level1)114 HWTEST_F(DelegateTasksTest, DelegateTasksTest_PostAsyncTask_001, TestSize.Level1)
115 {
116     CALL_TEST_DEBUG;
117     DelegateTasks delegateTasks;
118     EXPECT_EQ(delegateTasks.PostAsyncTask(nullptr), ERROR_NULL_POINTER);
119 }
120 
121 /**
122  * @tc.name: DelegateTasksTest_PopPendingTaskList_001
123  * @tc.desc: Test the function PopPendingTaskList
124  * @tc.type: FUNC
125  * @tc.require:
126  */
HWTEST_F(DelegateTasksTest, DelegateTasksTest_PopPendingTaskList_001, TestSize.Level1)127 HWTEST_F(DelegateTasksTest, DelegateTasksTest_PopPendingTaskList_001, TestSize.Level1)
128 {
129     CALL_TEST_DEBUG;
130     DelegateTasks delegateTasks;
131     std::vector<DelegateTasks::TaskPtr> tasks;
132     ASSERT_NO_FATAL_FAILURE(delegateTasks.PopPendingTaskList(tasks));
133 }
134 
135 /**
136  * @tc.name: DelegateTasksTest_PopPendingTaskList_002
137  * @tc.desc: Test the function PopPendingTaskList
138  * @tc.type: FUNC
139  * @tc.require:
140  */
HWTEST_F(DelegateTasksTest, DelegateTasksTest_PopPendingTaskList_002, TestSize.Level1)141 HWTEST_F(DelegateTasksTest, DelegateTasksTest_PopPendingTaskList_002, TestSize.Level1)
142 {
143     CALL_TEST_DEBUG;
144     DelegateTasks delegateTasks;
145     std::vector<DelegateTasks::TaskPtr> tasks;
146     for (int32_t i = 0; i < 15; i++) {
147         delegateTasks.PopPendingTaskList(tasks);
148     }
149     ASSERT_NO_FATAL_FAILURE(delegateTasks.PopPendingTaskList(tasks));
150 }
151 
152 /**
153  * @tc.name: DelegateTasksTest_PostTask_001
154  * @tc.desc: Test the function PostTask
155  * @tc.type: FUNC
156  * @tc.require:
157  */
HWTEST_F(DelegateTasksTest, DelegateTasksTest_PostTask_001, TestSize.Level1)158 HWTEST_F(DelegateTasksTest, DelegateTasksTest_PostTask_001, TestSize.Level1)
159 {
160     CALL_TEST_DEBUG;
161     DelegateTasks delegateTasks;
162     for (int32_t i = 0; i < 1001; i++) {
163         delegateTasks.PostTask(nullptr, nullptr);
164     }
165     auto task = delegateTasks.PostTask(nullptr, nullptr);
166     EXPECT_EQ(task, nullptr);
167 }
168 
169 /**
170  * @tc.name: DelegateTasksTest_PostTask_002
171  * @tc.desc: Test the function PostTask
172  * @tc.type: FUNC
173  * @tc.require:
174  */
HWTEST_F(DelegateTasksTest, DelegateTasksTest_PostTask_002, TestSize.Level1)175 HWTEST_F(DelegateTasksTest, DelegateTasksTest_PostTask_002, TestSize.Level1)
176 {
177     CALL_TEST_DEBUG;
178     DelegateTasks delegateTasks;
179     DelegateTasks::Promise promise;
180     auto task = delegateTasks.PostTask(nullptr, &promise);
181     EXPECT_EQ(task, nullptr);
182 }
183 
184 /**
185  * @tc.name:DelegateTasksTest_CreateKeyEvent_001
186  * @tc.desc:Test the funcation CreateKeyEvent
187  * @tc.type: FUNC
188  * @tc.require:
189  */
HWTEST_F(DelegateTasksTest, DelegateTasksTest_CreateKeyEvent_001, TestSize.Level1)190 HWTEST_F(DelegateTasksTest, DelegateTasksTest_CreateKeyEvent_001, TestSize.Level1)
191 {
192     KeyEventNapi napi;
193     napi_env env = nullptr;
194     std::shared_ptr<KeyEvent> in = KeyEvent::Create();
195     ASSERT_NE(in, nullptr);
196     napi_value out = nullptr;
197     napi_status status = napi.CreateKeyEvent(env, in, out);
198     ASSERT_NE(status, napi_ok);
199 }
200 
201 /**
202  * @tc.name:DelegateTasksTest_GetKeyEvent_001
203  * @tc.desc:Test the funcation GetKeyEvent
204  * @tc.type: FUNC
205  * @tc.require:
206  */
HWTEST_F(DelegateTasksTest, DelegateTasksTest_GetKeyEvent_001, TestSize.Level1)207 HWTEST_F(DelegateTasksTest, DelegateTasksTest_GetKeyEvent_001, TestSize.Level1)
208 {
209     KeyEventNapi napi;
210     napi_env env = nullptr;
211     napi_value in = nullptr;
212     std::shared_ptr<KeyEvent> out = KeyEvent::Create();
213     ASSERT_NE(out, nullptr);
214     napi_status status = napi.GetKeyEvent(env, in, out);
215     ASSERT_NE(status, napi_ok);
216 }
217 
218 /**
219  * @tc.name:DelegateTasksTest_CreateKeyItem_001
220  * @tc.desc:Test the funcation CreateKeyItem
221  * @tc.type: FUNC
222  * @tc.require:
223  */
HWTEST_F(DelegateTasksTest, DelegateTasksTest_CreateKeyItem_001, TestSize.Level1)224 HWTEST_F(DelegateTasksTest, DelegateTasksTest_CreateKeyItem_001, TestSize.Level1)
225 {
226     KeyEventNapi napi;
227     napi_env env = nullptr;
228     KeyEvent::KeyItem item;
229     std::optional<KeyEvent::KeyItem> in;
230     item.SetKeyCode(2018);
231     item.SetPressed(false);
232     in.emplace(item);
233     napi_value out = nullptr;
234     napi_status status = napi.CreateKeyItem(env, in, out);
235     ASSERT_NE(status, napi_ok);
236 }
237 
238 /**
239  * @tc.name:DelegateTasksTest_GetKeyItem_001
240  * @tc.desc:Test the funcation GetKeyItem
241  * @tc.type: FUNC
242  * @tc.require:
243  */
HWTEST_F(DelegateTasksTest, DelegateTasksTest_GetKeyItem_001, TestSize.Level1)244 HWTEST_F(DelegateTasksTest, DelegateTasksTest_GetKeyItem_001, TestSize.Level1)
245 {
246     KeyEventNapi napi;
247     napi_env env = nullptr;
248     napi_value in = nullptr;
249     KeyEvent::KeyItem out;
250     out.SetKeyCode(2024);
251     out.SetPressed(false);
252     napi_status status = napi.GetKeyItem(env, in, out);
253     ASSERT_EQ(status, napi_ok);
254 }
255 } // namespace MMI
256 } // namespace OHOS