1 /*
2 * Copyright (c) 2021-2022 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 <string>
19 #include "task.h"
20
21 namespace OHOS {
22 namespace AppExecFwk {
23 using namespace testing::ext;
24 using namespace OHOS::AppExecFwk;
25
26 class MyTaskListener : public TaskListener {
27 public:
OnChanged(const TaskStage & stage)28 void OnChanged(const TaskStage &stage)
29 {
30 stage_ = stage.GetIndex();
31 }
32 int stage_;
33 };
34
35 class TaskTest : public testing::Test {
36 public:
37 static void SetUpTestCase(void);
38 static void TearDownTestCase(void);
39 void SetUp();
40 void TearDown();
41 std::shared_ptr<Task> CreateTask(std::string &runStr, TaskPriority priority);
42 };
43
SetUpTestCase(void)44 void TaskTest::SetUpTestCase(void)
45 {}
46
TearDownTestCase(void)47 void TaskTest::TearDownTestCase(void)
48 {}
49
SetUp(void)50 void TaskTest::SetUp(void)
51 {}
52
TearDown(void)53 void TaskTest::TearDown(void)
54 {}
55
CreateTask(std::string & runStr,TaskPriority priority)56 std::shared_ptr<Task> CreateTask(std::string &runStr, TaskPriority priority)
57 {
58 std::shared_ptr<Runnable> runnable = std::make_shared<Runnable>([&]() { GTEST_LOG_(INFO) << runStr; });
59 std::shared_ptr<Task> task = std::make_shared<Task>(runnable, priority, nullptr);
60 return task;
61 };
62
63 /**
64 * @tc.number: AppExecFwk_Task_ConstructorTest_001
65 * @tc.name: TaskConstructor
66 * @tc.desc: Test Task Constructor.
67 */
68 HWTEST(TaskTest, AppExecFwk_Task_ConstructorTest_001, TestSize.Level0)
69 {
70 auto name = std::string("AppExecFwk_Task_ConstructorTest_001");
71 GTEST_LOG_(INFO) << name << " start";
72
73 std::string highTaskRun = "Task_Run: HIGH Task";
74 TaskPriority highPriority = TaskPriority::HIGH;
75 std::shared_ptr<Task> highTask = CreateTask(highTaskRun, highPriority);
76 EXPECT_TRUE((highTask != nullptr));
77 EXPECT_EQ(highPriority, highTask->GetPriority());
78 highTask->Run();
79
80 std::string defaultTaskRun = "Task_Run: DEFAULT Task";
81 TaskPriority defaultPriority = TaskPriority::DEFAULT;
82 std::shared_ptr<Task> defaultTask = CreateTask(defaultTaskRun, defaultPriority);
83 EXPECT_TRUE((defaultTask != nullptr));
84 EXPECT_EQ(defaultPriority, defaultTask->GetPriority());
85 defaultTask->Run();
86
87 std::string lowTaskRun = "Task_Run: DEFAULT Task";
88 TaskPriority lowPriority = TaskPriority::LOW;
89 std::shared_ptr<Task> lowTask = CreateTask(lowTaskRun, lowPriority);
90 EXPECT_TRUE((lowTask != nullptr));
91 EXPECT_EQ(lowPriority, lowTask->GetPriority());
92 lowTask->Run();
93
94 GTEST_LOG_(INFO) << name << " end";
95 }
96
97 /**
98 * @tc.number: AppExecFwk_Task_Run_001
99 * @tc.name: Run
100 * @tc.desc: Test task executor Runnable
101 */
102 HWTEST(TaskTest, AppExecFwk_Task_Run_001, TestSize.Level0)
103 {
104 auto name = std::string("AppExecFwk_Task_Run_001");
105 GTEST_LOG_(INFO) << name << " start";
106 std::string taskRun = "Task_Run: task run";
107 std::shared_ptr<Task> task = CreateTask(taskRun, TaskPriority::DEFAULT);
108 task->Run();
109 EXPECT_FALSE(task->Revoke());
110 GTEST_LOG_(INFO) << name << " end";
111 }
112
113 /**
114 * @tc.number: AppExecFwk_Task_Sequence_001
115 * @tc.name: GetSequence,SetSequence
116 * @tc.desc: Test get sequence and set sequence
117 */
118 HWTEST(TaskTest, AppExecFwk_Task_Sequence_001, TestSize.Level0)
119 {
120 auto name = std::string("AppExecFwk_Task_Sequence_001");
121 GTEST_LOG_(INFO) << name << " start";
122 std::string taskRun = "Task_Run: Task_Sequence";
123 std::shared_ptr<Task> task = CreateTask(taskRun, TaskPriority::DEFAULT);
124 long sequence = 10;
125 task->SetSequence(sequence);
126 EXPECT_EQ(10, task->GetSequence());
127 GTEST_LOG_(INFO) << name << " end";
128 }
129
130 /**
131 * @tc.number: AppExecFwk_Task_GetPriority_001
132 * @tc.name: GetPriority
133 * @tc.desc: Test get priority
134 */
135 HWTEST(TaskTest, AppExecFwk_Task_GetPriority_001, TestSize.Level0)
136 {
137 auto name = std::string("AppExecFwk_Task_GetPriority_001");
138 GTEST_LOG_(INFO) << name << " start";
139 std::string taskRun = "Task_Run: GetPriority DEFAULT Task";
140 std::shared_ptr<Task> task = CreateTask(taskRun, TaskPriority::LOW);
141 EXPECT_EQ(TaskPriority::LOW, task->GetPriority());
142 GTEST_LOG_(INFO) << name << " end";
143 }
144
145 /**
146 * @tc.number: AppExecFwk_Task_Revoke_001
147 * @tc.name: Revoke
148 * @tc.desc: Test task revoke true
149 */
150 HWTEST(TaskTest, AppExecFwk_Task_Revoke_001, TestSize.Level0)
151 {
152 auto name = std::string("AppExecFwk_Task_Revoke_001");
153 GTEST_LOG_(INFO) << name << " start";
154 std::string taskRun = "Task_Run: Revoke Task";
155 std::shared_ptr<Task> task = CreateTask(taskRun, TaskPriority::DEFAULT);
156 EXPECT_TRUE(task->Revoke());
157 GTEST_LOG_(INFO) << name << " end";
158 }
159
160 /**
161 * @tc.number: AppExecFwk_Task_Revoke_002
162 * @tc.name: Revoke
163 * @tc.desc: Test task revoke false
164 */
165 HWTEST(TaskTest, AppExecFwk_Task_Revoke_002, TestSize.Level0)
166 {
167 auto name = std::string("AppExecFwk_Task_Revoke_002");
168 GTEST_LOG_(INFO) << name << " start";
169 std::string taskRun = "Task_Run: Revoke Task";
170 std::shared_ptr<Task> task = CreateTask(taskRun, TaskPriority::DEFAULT);
171 task->Run();
172 EXPECT_FALSE(task->Revoke());
173 GTEST_LOG_(INFO) << name << " end";
174 }
175
176 /**
177 * @tc.number: AppExecFwk_Task_AddTaskListener_001
178 * @tc.name: AddTaskListener
179 * @tc.desc: Test task add task listener
180 */
181 HWTEST(TaskTest, AppExecFwk_Task_AddTaskListener_001, TestSize.Level0)
182 {
183 auto name = std::string("AppExecFwk_Task_AddTaskListener_001");
184 GTEST_LOG_(INFO) << name << " start";
185 std::string taskRun = "Task_Run: AddTaskListener";
186 std::shared_ptr<Task> task = CreateTask(taskRun, TaskPriority::DEFAULT);
187 std::shared_ptr<MyTaskListener> taskListener1 = std::make_shared<MyTaskListener>();
188 task->AddTaskListener(taskListener1);
189 std::shared_ptr<MyTaskListener> taskListener2 = std::make_shared<MyTaskListener>();
190 task->AddTaskListener(taskListener2);
191 task->AfterTaskExecute();
192 EXPECT_EQ(taskListener1->stage_, 0);
193 EXPECT_EQ(taskListener2->stage_, 0);
194 task->Run();
195 task->AfterTaskExecute();
196 EXPECT_EQ(taskListener1->stage_, 1);
197 EXPECT_EQ(taskListener2->stage_, 1);
198 GTEST_LOG_(INFO) << name << " end";
199 }
200
201 /**
202 * @tc.number: AppExecFwk_Task_BeforeTaskExecute_001
203 * @tc.name: BeforeTaskExecute
204 * @tc.desc: Test task before task execute
205 */
206 HWTEST(TaskTest, AppExecFwk_Task_BeforeTaskExecute_001, TestSize.Level0)
207 {
208 auto name = std::string("AppExecFwk_Task_BeforeTaskExecute_001");
209 GTEST_LOG_(INFO) << name << " start";
210 std::string taskRun = "Task_Run: BeforeTaskExecute";
211 std::shared_ptr<Task> task = CreateTask(taskRun, TaskPriority::DEFAULT);
212 std::shared_ptr<MyTaskListener> taskListener = std::make_shared<MyTaskListener>();
213 task->AddTaskListener(taskListener);
214 task->BeforeTaskExecute();
215 EXPECT_EQ(taskListener->stage_, TaskStage::BEFORE_EXECUTE);
216 GTEST_LOG_(INFO) << name << " end";
217 }
218
219 /**
220 * @tc.number: AppExecFwk_Task_AfterTaskExecute_001
221 * @tc.name: AfterTaskExecute
222 * @tc.desc: Test after task execute
223 */
224 HWTEST(TaskTest, AppExecFwk_Task_AfterTaskExecute_001, TestSize.Level0)
225 {
226 auto name = std::string("AppExecFwk_Task_AfterTaskExecute_001");
227 GTEST_LOG_(INFO) << name << " start";
228 std::string taskRun = "Task_Run: AfterTaskExecute";
229 std::shared_ptr<Task> task = CreateTask(taskRun, TaskPriority::DEFAULT);
230 std::shared_ptr<MyTaskListener> taskListener = std::make_shared<MyTaskListener>();
231 task->AddTaskListener(taskListener);
232 task->AfterTaskExecute();
233 EXPECT_EQ(taskListener->stage_, 0);
234 task->Run();
235 task->AfterTaskExecute();
236 EXPECT_EQ(taskListener->stage_, 1);
237 GTEST_LOG_(INFO) << name << " end";
238 }
239
240 /**
241 * @tc.number: AppExecFwk_Task_OnTaskCanceled_001
242 * @tc.name: OnTaskCanceled
243 * @tc.desc: Test task canceled
244 */
245 HWTEST(TaskTest, AppExecFwk_Task_OnTaskCanceled_001, TestSize.Level0)
246 {
247 auto name = std::string("AppExecFwk_Task_OnTaskCanceled_001");
248 GTEST_LOG_(INFO) << name << " start";
249 std::string taskRun = "Task_Run: OnTaskCanceled";
250 std::shared_ptr<Task> task = CreateTask(taskRun, TaskPriority::DEFAULT);
251 std::shared_ptr<MyTaskListener> taskListener = std::make_shared<MyTaskListener>();
252 task->AddTaskListener(taskListener);
253 task->OnTaskCanceled();
254 EXPECT_EQ(taskListener->stage_, 2);
255 GTEST_LOG_(INFO) << name << " end";
256 }
257 } // namespace AppExecFwk
258 } // namespace OHOS