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"
25namespace OHOS {
26namespace MMI {
27namespace {
28using namespace testing::ext;
29} // namespace
30
31class DelegateTasksTest : public testing::Test {
32public:
33    static void SetUpTestCase(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 */
43HWTEST_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 */
58HWTEST_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 */
72HWTEST_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 */
86HWTEST_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 */
100HWTEST_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 */
114HWTEST_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 */
127HWTEST_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 */
141HWTEST_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 */
158HWTEST_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 */
175HWTEST_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 */
190HWTEST_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 */
207HWTEST_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 */
224HWTEST_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 */
244HWTEST_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