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 "task_queue_unit_test.h"
17
18 #include <chrono>
19
20 using namespace OHOS;
21 using namespace OHOS::Media;
22 using namespace std;
23 using namespace testing::ext;
24
25
26 namespace OHOS {
27 namespace Media {
28 namespace Test {
29
30 namespace {
31 static constexpr uint64_t WAIT_TIME = 1e6; // 1s
32 static constexpr uint32_t UINT32_TASK_RESULT = 10;
33 }
34
SetUpTestCase(void)35 void TaskQueueUnitTest::SetUpTestCase(void) {}
36
TearDownTestCase(void)37 void TaskQueueUnitTest::TearDownTestCase(void) {}
38
SetUp(void)39 void TaskQueueUnitTest::SetUp(void)
40 {
41 taskQueue_ = std::make_shared<TaskQueue>("test_name");
42 }
43
TearDown(void)44 void TaskQueueUnitTest::TearDown(void)
45 {
46 taskQueue_ = nullptr;
47 }
48
49 HWTEST_F(TaskQueueUnitTest, Stop_000, TestSize.Level0) {
50 taskQueue_->isExit_ = true;
51 int32_t result = -1;
__anon5749459d0202() 52 taskQueue_->thread_ = std::make_unique<std::thread>([&]() {
53 result = taskQueue_->Stop();
54 });
55 if (taskQueue_->thread_->joinable()) {
56 taskQueue_->thread_->join();
57 }
58 ASSERT_EQ(result, MSERR_OK);
59 }
60
61 HWTEST_F(TaskQueueUnitTest, Stop_001, TestSize.Level0) {
62 taskQueue_->isExit_ = false;
63 int32_t result = -1;
__anon5749459d0302() 64 taskQueue_->thread_ = std::make_unique<std::thread>([&]() {
65 result = taskQueue_->Stop();
66 });
67 if (taskQueue_->thread_->joinable()) {
68 taskQueue_->thread_->join();
69 }
70 ASSERT_EQ(result, MSERR_INVALID_OPERATION);
71 }
72
73 HWTEST_F(TaskQueueUnitTest, CancelNotExecutedTaskLocked_001, TestSize.Level0) {
74 taskQueue_->isExit_ = false;
75 TaskQueue::TaskHandlerItem taskItem;
76 taskItem.task_ = nullptr;
77 taskQueue_->taskList_.push_back(taskItem);
__anon5749459d0402() 78 taskQueue_->thread_ = std::make_unique<std::thread>([&]() {
79 taskQueue_->CancelNotExecutedTaskLocked();
80 });
81 if (taskQueue_->thread_->joinable()) {
82 taskQueue_->thread_->join();
83 }
84 ASSERT_TRUE(taskQueue_->taskList_.empty());
85 }
86
87 HWTEST_F(TaskQueueUnitTest, CancelNotExecutedTaskLocked_002, TestSize.Level0) {
88 taskQueue_->isExit_ = false;
89 uint32_t count = 0;
90
91 auto task1 = make_shared<TaskHandler<uint32_t>>(
__anon5749459d0502() 92 [&] () -> uint32_t {
93 count++;
94 return count;
95 }
96 );
97 ASSERT_EQ(taskQueue_->EnqueueTask(task1), 0);
98
99 auto task2 = make_shared<TaskHandler<void>>(
__anon5749459d0602() 100 [&] () -> void {
101 count++;
102 return;
103 }
104 );
105 ASSERT_EQ(taskQueue_->EnqueueTask(task2), 0);
106
__anon5749459d0702() 107 taskQueue_->thread_ = std::make_unique<std::thread>([&]() {
108 taskQueue_->CancelNotExecutedTaskLocked();
109 });
110 if (taskQueue_->thread_->joinable()) {
111 taskQueue_->thread_->join();
112 }
113
114 auto result1 = task1->GetResult();
115 auto result2 = task2->GetResult();
116
117 ASSERT_TRUE(taskQueue_->taskList_.empty());
118 ASSERT_EQ(count, 0);
119 ASSERT_TRUE(task1->IsCanceled());
120 ASSERT_TRUE(task2->IsCanceled());
121 ASSERT_FALSE(result1.HasResult());
122 ASSERT_FALSE(result2.HasResult());
123 }
124
125 HWTEST_F(TaskQueueUnitTest, TaskProcessor_001, TestSize.Level0) {
126 taskQueue_->Start();
127
128 TaskQueue::TaskHandlerItem taskItem;
129 taskItem.task_ = nullptr;
130 taskQueue_->taskList_.push_back(taskItem);
131
132 auto task = make_shared<TaskHandler<uint32_t>>(
__anon5749459d0802() 133 [] () -> uint32_t {
134 return UINT32_TASK_RESULT;
135 }
136 );
137 ASSERT_EQ(taskQueue_->EnqueueTask(task, false, WAIT_TIME), 0);
138
139 auto result = task->GetResult();
140 ASSERT_TRUE(taskQueue_->taskList_.empty());
141 ASSERT_TRUE(result.HasResult());
142 ASSERT_EQ(result.Value(), UINT32_TASK_RESULT);
143 }
144
145 HWTEST_F(TaskQueueUnitTest, TaskProcessor_002, TestSize.Level0) {
146 taskQueue_->Start();
147
148 TaskQueue::TaskHandlerItem taskItem;
149 taskItem.task_ = nullptr;
150 taskQueue_->taskList_.push_back(taskItem);
151 std::this_thread::sleep_for(std::chrono::seconds(1));
152 ASSERT_TRUE(taskQueue_->taskList_.empty());
153 }
154
155 HWTEST_F(TaskQueueUnitTest, TaskProcessor_003, TestSize.Level0) {
156 taskQueue_->Start();
157
158 auto task = make_shared<TaskHandler<uint32_t>>(
__anon5749459d0902() 159 [] () -> uint32_t {
160 return UINT32_TASK_RESULT;
161 }
162 );
163 ASSERT_EQ(taskQueue_->EnqueueTask(task, false, WAIT_TIME), 0);
164 task->Cancel();
165
166 std::this_thread::sleep_for(std::chrono::seconds(5));
167 ASSERT_TRUE(task->IsCanceled());
168 ASSERT_TRUE(taskQueue_->taskList_.empty());
169 auto result = task->GetResult();
170 ASSERT_FALSE(result.HasResult());
171 }
172
173 HWTEST_F(TaskQueueUnitTest, IsTaskExecuting_001, TestSize.Level0) {
174 taskQueue_->isTaskExecuting_ = true;
175 bool ret;
176 ret = taskQueue_->IsTaskExecuting();
177 ASSERT_TRUE(ret);
178 }
179
180 HWTEST_F(TaskQueueUnitTest, IsTaskExecuting_002, TestSize.Level0) {
181 taskQueue_->isTaskExecuting_ = false;
182 bool ret;
183 ret = taskQueue_->IsTaskExecuting();
184 ASSERT_FALSE(ret);
185 }
186
187 HWTEST_F(TaskQueueUnitTest, FullProgress_001, TestSize.Level0) {
188 taskQueue_->SetQos(OHOS::QOS::QosLevel::QOS_USER_INTERACTIVE);
189 taskQueue_->ResetQos();
190 ASSERT_EQ(taskQueue_->tid_, -1);
191
192 taskQueue_->Start();
193
194 auto task1 = make_shared<TaskHandler<uint32_t>>(
__anon5749459d0a02() 195 [] () -> uint32_t {
196 return UINT32_TASK_RESULT;
197 }
198 );
199 ASSERT_EQ(taskQueue_->EnqueueTask(task1, false, WAIT_TIME), 0);
200 task1->Cancel();
201
202 auto task2 = make_shared<TaskHandler<uint32_t>>(
__anon5749459d0b02() 203 [] () -> uint32_t {
204 return UINT32_TASK_RESULT;
205 }
206 );
207 ASSERT_EQ(taskQueue_->EnqueueTask(task2), 0);
208
209 auto task3 = make_shared<TaskHandler<uint32_t>>(
__anon5749459d0c02() 210 [] () -> uint32_t {
211 return UINT32_TASK_RESULT;
212 }
213 );
214 ASSERT_EQ(taskQueue_->EnqueueTask(task3, false, WAIT_TIME), 0);
215
216 ASSERT_TRUE(task1->IsCanceled());
217 auto result2 = task2->GetResult();
218 ASSERT_TRUE(result2.HasResult());
219 ASSERT_EQ(result2.Value(), UINT32_TASK_RESULT);
220 auto result3 = task3->GetResult();
221 ASSERT_TRUE(result3.HasResult());
222 ASSERT_EQ(result3.Value(), UINT32_TASK_RESULT);
223
224 ASSERT_TRUE(taskQueue_->taskList_.empty());
225 }
226
227 } // namespace Test
228 } // namespace Media
229 } // namespace OHOS
230