1 /*
2 * Copyright (c) 2023-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 <gtest/gtest.h>
17
18 #include "ffrt_task_utils_wrap.h"
19 #include "queue_task_handler_wrap.h"
20 #include "task_handler_wrap.h"
21 #include "task_utils_wrap.h"
22
23 using namespace testing;
24 using namespace testing::ext;
25
26 namespace OHOS {
27 namespace AAFwk {
28 constexpr int32_t LONG_TIME_TASK_TIME = 2 * 500000 + 100000; // us
29 constexpr int32_t SCHEDULE_TIMEOUT = 500; // ms
30 class TaskHandlerWrapTest : public testing::Test {
31 public:
32 static void SetUpTestCase(void);
33 static void TearDownTestCase(void);
34 void SetUp() override;
35 void TearDown() override;
36
37 std::shared_ptr<TaskHandlerWrap> queueHandler_;
38 std::shared_ptr<TaskHandlerWrap> ffrtHandler_;
39 };
40
SetUpTestCase(void)41 void TaskHandlerWrapTest::SetUpTestCase(void)
42 {}
TearDownTestCase(void)43 void TaskHandlerWrapTest::TearDownTestCase(void)
44 {}
SetUp()45 void TaskHandlerWrapTest::SetUp()
46 {
47 queueHandler_ = TaskHandlerWrap::CreateQueueHandler("TaskHandlerWrapTest");
48 ffrtHandler_ = TaskHandlerWrap::GetFfrtHandler();
49 }
TearDown()50 void TaskHandlerWrapTest::TearDown()
51 {
52 queueHandler_.reset();
53 ffrtHandler_.reset();
54 }
55
56 /**
57 * @tc.name: QueueTest_0010
58 * @tc.desc: SubmitTask Test
59 * @tc.type: FUNC
60 */
61 HWTEST_F(TaskHandlerWrapTest, QueueTest_0010, TestSize.Level0)
62 {
63 int input = 0;
__anonf373569a0102() 64 auto taskHandle = queueHandler_->SubmitTask([&input]() {
65 input = 1;
66 });
67 EXPECT_TRUE(taskHandle);
68 taskHandle.Sync();
69 EXPECT_TRUE(input == 1);
70 }
71
72 /**
73 * @tc.name: QueueTest_0020
74 * @tc.desc: SubmitTask with delay Test
75 * @tc.type: FUNC
76 */
77 HWTEST_F(TaskHandlerWrapTest, QueueTest_0020, TestSize.Level0)
78 {
79 int input = 0;
__anonf373569a0202() 80 auto taskHandle = queueHandler_->SubmitTask([&input]() {
81 input = 1;
82 }, 100);
83 EXPECT_TRUE(taskHandle);
84 taskHandle.Sync();
85 EXPECT_TRUE(input == 1);
86 }
87
88 /**
89 * @tc.name: QueueTest_0030
90 * @tc.desc: SubmitTask Test
91 * @tc.type: FUNC
92 */
93 HWTEST_F(TaskHandlerWrapTest, QueueTest_0030, TestSize.Level0)
94 {
__anonf373569a0302() 95 auto taskHandle = queueHandler_->SubmitTask([]() {});
96 EXPECT_TRUE(taskHandle);
97 auto result = taskHandle.Cancel();
98 EXPECT_FALSE(result);
99 }
100
101 /**
102 * @tc.name: QueueTest_0040
103 * @tc.desc: SubmitTask with delay Test
104 * @tc.type: FUNC
105 */
106 HWTEST_F(TaskHandlerWrapTest, QueueTest_0040, TestSize.Level0)
107 {
__anonf373569a0402() 108 auto taskHandle = queueHandler_->SubmitTask([]() {}, 100);
109 EXPECT_TRUE(taskHandle);
110 auto result = taskHandle.Cancel();
111 EXPECT_TRUE(result);
112 }
113
114 /**
115 * @tc.name: QueueTest_0050
116 * @tc.desc: SubmitTask time task test
117 * @tc.type: FUNC
118 */
119 HWTEST_F(TaskHandlerWrapTest, QueueTest_0050, TestSize.Level0)
120 {
121 int input = 0;
__anonf373569a0502() 122 auto taskHandle = queueHandler_->SubmitTask([&input]() {
123 usleep(LONG_TIME_TASK_TIME);
124 input = 1;
125 }, 100);
126 EXPECT_TRUE(taskHandle);
127 taskHandle.Sync();
128 EXPECT_TRUE(input == 1);
129 }
130
131 /**
132 * @tc.name: QueueTest_0060
133 * @tc.desc: Insert task test
134 * @tc.type: FUNC
135 */
136 HWTEST_F(TaskHandlerWrapTest, QueueTest_0060, TestSize.Level0)
137 {
138 queueHandler_->SetPrintTaskLog(true);
139 int input = 0;
__anonf373569a0602() 140 auto task1 = [&input]() {
141 usleep(LONG_TIME_TASK_TIME);
142 input = 1;
143 };
144 auto handle1 = queueHandler_->SubmitTask(task1, "task1");
145
146 // this task will trigger scheduling timeout
__anonf373569a0702()147 auto handle2 = queueHandler_->SubmitTask([](){}, TaskAttribute{
148 .taskName_ = "task2",
149 .timeoutMillis_ = SCHEDULE_TIMEOUT
150 });
151
152 int result3 = 0;
153 int result4 = 0;
__anonf373569a0902() 154 auto handle3 = queueHandler_->SubmitTask([&input, &result3]() {
155 result3 = ++input;
156 }, "task3");
__anonf373569a0a02() 157 auto handle4 = queueHandler_->SubmitTask([&input, &result4]() {
158 result4 = ++input;
159 }, TaskAttribute{
160 .taskName_ = "task4",
161 .insertHead_ = true
162 });
163 handle1.Sync();
164 handle2.Sync();
165 handle3.Sync();
166 handle4.Sync();
167 EXPECT_TRUE(result3 == result4 + 1);
168 }
169
170 /**
171 * @tc.name: FfrtTest_0010
172 * @tc.desc: SubmitTask Test
173 * @tc.type: FUNC
174 */
175 HWTEST_F(TaskHandlerWrapTest, FfrtTest_0010, TestSize.Level0)
176 {
177 int input = 0;
__anonf373569a0c02() 178 auto taskHandle = ffrtHandler_->SubmitTask([&input]() {
179 input = 1;
180 });
181 EXPECT_TRUE(taskHandle);
182 taskHandle.Sync();
183 EXPECT_TRUE(input == 1);
184 }
185
186 /**
187 * @tc.name: FfrtTest_0020
188 * @tc.desc: SubmitTask with delay Test
189 * @tc.type: FUNC
190 */
191 HWTEST_F(TaskHandlerWrapTest, FfrtTest_0020, TestSize.Level0)
192 {
193 int input = 0;
__anonf373569a0d02() 194 auto taskHandle = ffrtHandler_->SubmitTask([&input]() {
195 input = 1;
196 }, 100);
197 EXPECT_TRUE(taskHandle);
198 taskHandle.Sync();
199 EXPECT_TRUE(input == 1);
200 }
201
202 /**
203 * @tc.name: FfrtTest_0030
204 * @tc.desc: SubmitTask Test
205 * @tc.type: FUNC
206 */
207 HWTEST_F(TaskHandlerWrapTest, FfrtTest_0030, TestSize.Level0)
208 {
__anonf373569a0e02() 209 auto taskHandle = ffrtHandler_->SubmitTask([]() {});
210 EXPECT_TRUE(taskHandle);
211 auto result = taskHandle.Cancel();
212 EXPECT_TRUE(result);
213 }
214
215 /**
216 * @tc.name: FfrtTest_0040
217 * @tc.desc: SubmitTask with delay Test
218 * @tc.type: FUNC
219 */
220 HWTEST_F(TaskHandlerWrapTest, FfrtTest_0040, TestSize.Level0)
221 {
__anonf373569a0f02() 222 auto taskHandle = ffrtHandler_->SubmitTask([]() {}, 100);
223 EXPECT_TRUE(taskHandle);
224 auto result = taskHandle.Cancel();
225 EXPECT_TRUE(result);
226 }
227
228 /**
229 * @tc.name: RemoveTask_0050
230 * @tc.desc: Test removing a task from the task handler after submission.
231 * @tc.type: FUNC
232 */
233 HWTEST_F(TaskHandlerWrapTest, RemoveTask_0050, TestSize.Level0)
234 {
235 GTEST_LOG_(INFO) << "RemoveTask_0050 start";
236
237 EXPECT_NE(ffrtHandler_, nullptr);
238
239 const std::string name = "test";
240 TaskHandle taskHandle;
241 EXPECT_FALSE(ffrtHandler_->RemoveTask(name, taskHandle));
242
__anonf373569a1002() 243 std::function<void()> taskWrap = []() {};
244 TaskAttribute taskAttr;
245 std::shared_ptr<InnerTaskHandle> innerTaskHandle = ffrtHandler_->SubmitTaskInner(std::move(taskWrap), taskAttr);
246 EXPECT_NE(innerTaskHandle, nullptr);
247 TaskHandle taskHandleTest(nullptr, innerTaskHandle);
248 ffrtHandler_->tasks_.emplace(name, taskHandleTest);
249 EXPECT_FALSE(ffrtHandler_->RemoveTask(name, taskHandle));
250
251 EXPECT_EQ(ffrtHandler_->tasks_.size(), 1);
252 EXPECT_TRUE(ffrtHandler_->RemoveTask(name, taskHandleTest));
253 EXPECT_EQ(ffrtHandler_->tasks_.size(), 0);
254
255 GTEST_LOG_(INFO) << "RemoveTask_0050 end";
256 }
257
258 /**
259 * @tc.name: Convert2FfrtQosAndConvert2FfrtPriority_0060
260 * @tc.desc: Verify the conversion of task QoS and priority to ffrt equivalents.
261 * @tc.type: FUNC
262 */
263 HWTEST_F(TaskHandlerWrapTest, Convert2FfrtQosAndConvert2FfrtPriority_0060, TestSize.Level0)
264 {
265 GTEST_LOG_(INFO) << "Convert2FfrtQosAndConvert2FfrtPriority_0060 start";
266
267 EXPECT_EQ(Convert2FfrtQos(TaskQoS::INHERENT), ffrt::qos_inherit);
268 EXPECT_EQ(Convert2FfrtQos(TaskQoS::BACKGROUND), ffrt::qos_background);
269 EXPECT_EQ(Convert2FfrtQos(TaskQoS::UTILITY), ffrt::qos_utility);
270 EXPECT_EQ(Convert2FfrtQos(TaskQoS::DEFAULT), ffrt::qos_default);
271 EXPECT_EQ(Convert2FfrtQos(TaskQoS::USER_INITIATED), ffrt::qos_user_initiated);
272 EXPECT_EQ(Convert2FfrtQos(TaskQoS::DEADLINE_REQUEST), ffrt::qos_deadline_request);
273 EXPECT_EQ(Convert2FfrtQos(TaskQoS::USER_INTERACTIVE), ffrt::qos_user_interactive);
274 EXPECT_EQ(Convert2FfrtPriority(TaskQueuePriority::IMMEDIATE), ffrt_queue_priority_t::ffrt_queue_priority_immediate);
275 EXPECT_EQ(Convert2FfrtPriority(TaskQueuePriority::HIGH), ffrt_queue_priority_t::ffrt_queue_priority_high);
276 EXPECT_EQ(Convert2FfrtPriority(TaskQueuePriority::LOW), ffrt_queue_priority_t::ffrt_queue_priority_low);
277 EXPECT_EQ(Convert2FfrtPriority(TaskQueuePriority::IDLE), ffrt_queue_priority_t::ffrt_queue_priority_idle);
278
279 GTEST_LOG_(INFO) << "Convert2FfrtQosAndConvert2FfrtPriority_0060 end";
280 }
281
282 /**
283 * @tc.name: BuildFfrtTaskAttr_0070
284 * @tc.desc: Test building task attributes and ensure task execution occurs after delay.
285 * @tc.type: FUNC
286 */
287 HWTEST_F(TaskHandlerWrapTest, BuildFfrtTaskAttr_0070, TestSize.Level0)
288 {
289 GTEST_LOG_(INFO) << "BuildFfrtTaskAttr_0070 start";
290
291 EXPECT_NE(ffrtHandler_, nullptr);
292 std::shared_ptr<QueueTaskHandlerWrap> queueTaskHandlerWrap =
293 std::static_pointer_cast<QueueTaskHandlerWrap>(ffrtHandler_);
294 EXPECT_NE(queueTaskHandlerWrap, nullptr);
295 int ret = 0;
__anonf373569a1102() 296 std::function<void()> task = [&ret]() { ret++; };
297 TaskAttribute taskAttr;
298 taskAttr.delayMillis_ = 1;
299 taskAttr.taskName_ = "test";
300 taskAttr.taskQos_ = TaskQoS::INHERENT;
301 taskAttr.taskPriority_ = TaskQueuePriority::IMMEDIATE;
302 taskAttr.timeoutMillis_ = 1;
303 auto innerTaskHandle = queueTaskHandlerWrap->SubmitTaskInner(std::move(task), taskAttr);
304 EXPECT_NE(innerTaskHandle, nullptr);
305 EXPECT_NE(ret, 1);
306
307 GTEST_LOG_(INFO) << "BuildFfrtTaskAttr_0070 end";
308 }
309 } // namespace AAFwk
310 } // namespace OHOS
311