1 /*
2 * Copyright (c) 2023 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 "test.h"
17
18 #include <unistd.h>
19
20 #include "helper/napi_helper.h"
21 #include "queue.h"
22 #include "task.h"
23 #include "taskpool.h"
24 #include "task_manager.h"
25 #include "task_runner.h"
26 #include "thread.h"
27 #include "utils/log.h"
28 #include "worker.h"
29
30 using namespace Commonlibrary::Concurrent::TaskPoolModule;
31
32 HWTEST_F(NativeEngineTest, TaskpoolTest001, testing::ext::TestSize.Level0)
33 {
34 TaskManager &taskManager = TaskManager::GetInstance();
35 uint32_t result = taskManager.GetThreadNum();
36 ASSERT_TRUE(result == 0);
37 }
38
39 HWTEST_F(NativeEngineTest, TaskpoolTest002, testing::ext::TestSize.Level0)
40 {
41 napi_env env = reinterpret_cast<napi_env>(engine_);
42 Worker* worker = Worker::WorkerConstructor(env);
43 usleep(50000);
44 ASSERT_NE(worker, nullptr);
45 }
46
47 HWTEST_F(NativeEngineTest, TaskpoolTest003, testing::ext::TestSize.Level0)
48 {
49 napi_env env = reinterpret_cast<napi_env>(engine_);
50 napi_value taskClass = nullptr;
51 napi_value result = TaskPool::InitTaskPool(env, taskClass);
52 usleep(50000);
53 ASSERT_TRUE(result == nullptr);
54 }
55
56 HWTEST_F(NativeEngineTest, TaskpoolTest004, testing::ext::TestSize.Level0)
57 {
58 napi_env env = reinterpret_cast<napi_env>(engine_);
59 Worker* worker = Worker::WorkerConstructor(env);
60 usleep(50000);
61 ASSERT_NE(worker, nullptr);
62 uint32_t workers = TaskManager::GetInstance().GetRunningWorkers();
63 ASSERT_TRUE(workers == 0);
64 }
65
66 HWTEST_F(NativeEngineTest, TaskpoolTest005, testing::ext::TestSize.Level0)
67 {
68 uint64_t taskId = 10;
69 TaskManager &taskManager = TaskManager::GetInstance();
70 Task* task = taskManager.GetTask(taskId);
71 ASSERT_TRUE(task == nullptr);
72 }
73
74 HWTEST_F(NativeEngineTest, TaskpoolTest006, testing::ext::TestSize.Level0)
75 {
76 TaskManager &taskManager = TaskManager::GetInstance();
77 std::pair<uint64_t, Priority> result = taskManager.DequeueTaskId();
78 ASSERT_TRUE(result.first == 0);
79 ASSERT_TRUE(result.second == Priority::LOW);
80 }
81
82 HWTEST_F(NativeEngineTest, TaskpoolTest007, testing::ext::TestSize.Level0)
83 {
84 TaskManager &taskManager = TaskManager::GetInstance();
85 uint32_t result = taskManager.GetTaskNum();
86 ASSERT_TRUE(result == 0);
87 }
88
89 HWTEST_F(NativeEngineTest, TaskpoolTest008, testing::ext::TestSize.Level0)
90 {
91 ExecuteQueue executeQueue;
92 uint64_t result = executeQueue.DequeueTaskId();
93 ASSERT_TRUE(result == 0);
94 }
95
96 HWTEST_F(NativeEngineTest, TaskpoolTest009, testing::ext::TestSize.Level0)
97 {
98 ExecuteQueue executeQueue;
99 bool result = executeQueue.IsEmpty();
100 ASSERT_TRUE(result);
101 }
102
103 HWTEST_F(NativeEngineTest, TaskpoolTest010, testing::ext::TestSize.Level0)
104 {
105 ExecuteQueue executeQueue;
106 uint32_t result = executeQueue.GetTaskNum();
107 ASSERT_TRUE(result == 0);
108 }
109
110 HWTEST_F(NativeEngineTest, TaskpoolTest011, testing::ext::TestSize.Level0)
111 {
112 napi_env env = (napi_env)engine_;
113 napi_value argv[] = {nullptr};
114 std::string funcName = "TaskGroupConstructor";
115 napi_value cb = nullptr;
116 napi_value result = nullptr;
117 napi_create_function(env, funcName.c_str(), funcName.size(), TaskGroup::TaskGroupConstructor, nullptr, &cb);
118 napi_call_function(env, nullptr, cb, 0, argv, &result);
119 ASSERT_TRUE(result != nullptr);
120 }
121
122 HWTEST_F(NativeEngineTest, TaskpoolTest012, testing::ext::TestSize.Level0)
123 {
124 napi_env env = (napi_env)engine_;
125 napi_value argv[] = {nullptr};
126 std::string funcName = "TaskGroupConstructor";
127 napi_value cb = nullptr;
128 napi_value result = nullptr;
129 napi_create_function(env, funcName.c_str(), funcName.size(), TaskGroup::TaskGroupConstructor, nullptr, &cb);
130 napi_call_function(env, nullptr, cb, 0, argv, &result);
131 ASSERT_TRUE(result != nullptr);
132
133 size_t argc1 = 0;
134 napi_value argv1[] = {nullptr};
135 funcName = "AddTask";
136 cb = nullptr;
137 napi_value result1 = nullptr;
138 napi_create_function(env, funcName.c_str(), funcName.size(), TaskGroup::AddTask, nullptr, &cb);
139 napi_call_function(env, nullptr, cb, argc1, argv1, &result1);
140 ASSERT_TRUE(result1 == nullptr);
141 }
142
143 HWTEST_F(NativeEngineTest, TaskpoolTest013, testing::ext::TestSize.Level0)
144 {
145 uint32_t number = 10;
146 napi_env env = reinterpret_cast<napi_env>(engine_);
147 napi_value value = NapiHelper::CreateUint32(env, number);
148 napi_value result = TaskPool::InitTaskPool(env, value);
149 usleep(50000);
150 ASSERT_TRUE(result != nullptr);
151 }
152
TestFunction(napi_env env)153 napi_value TestFunction(napi_env env)
154 {
155 napi_value result = nullptr;
156 const char* message = "test taskpool";
157 size_t length = strlen(message);
158 napi_create_string_utf8(env, message, length, &result);
159 return result;
160 }
161
162 HWTEST_F(NativeEngineTest, TaskpoolTest014, testing::ext::TestSize.Level0)
163 {
164 napi_env env = reinterpret_cast<napi_env>(engine_);
165 TaskManager& taskManger = TaskManager::GetInstance();
166 taskManger.InitTaskManager(env);
167 uint32_t taskNum = taskManger.GetTaskNum();
168 ASSERT_TRUE(taskNum == 0);
169 uint32_t threadNum = taskManger.GetThreadNum();
170 ASSERT_TRUE(threadNum == 0);
171 uint32_t idleWorkers = taskManger.GetIdleWorkers();
172 ASSERT_TRUE(idleWorkers == 0);
173 uint32_t runningWorkers = taskManger.GetRunningWorkers();
174 ASSERT_TRUE(runningWorkers == 0);
175 uint32_t timeoutWorkers = taskManger.GetTimeoutWorkers();
176 ASSERT_TRUE(timeoutWorkers == 0);
177 }
178
179 HWTEST_F(NativeEngineTest, TaskpoolTest015, testing::ext::TestSize.Level0)
180 {
181 napi_env env = reinterpret_cast<napi_env>(engine_);
182 TaskManager& taskManger = TaskManager::GetInstance();
183 taskManger.InitTaskManager(env);
184 std::pair<uint64_t, Priority> result = taskManger.DequeueTaskId();
185 ASSERT_TRUE(result.first == 0);
186 ASSERT_TRUE(result.second == Priority::LOW);
187 }
188
189 HWTEST_F(NativeEngineTest, TaskpoolTest016, testing::ext::TestSize.Level0)
190 {
191 napi_env env = reinterpret_cast<napi_env>(engine_);
192 TaskManager& taskManger = TaskManager::GetInstance();
193 taskManger.InitTaskManager(env);
194 Task* task = new Task();
195 uint64_t taskId = reinterpret_cast<uint64_t>(task);
196 taskManger.CancelTask(env, taskId);
197 ASSERT_TRUE(taskId != 0);
198 delete task;
199 }
200
201 HWTEST_F(NativeEngineTest, TaskpoolTest017, testing::ext::TestSize.Level0)
202 {
203 napi_env env = reinterpret_cast<napi_env>(engine_);
204 TaskManager& taskManger = TaskManager::GetInstance();
205 taskManger.InitTaskManager(env);
206 Task* task = new Task();
207 uint64_t taskId = reinterpret_cast<uint64_t>(task);
208 taskManger.TryTriggerExpand();
209 ASSERT_TRUE(taskId != 0);
210 delete task;
211 }
212
213 HWTEST_F(NativeEngineTest, TaskpoolTest018, testing::ext::TestSize.Level0)
214 {
215 napi_env env = reinterpret_cast<napi_env>(engine_);
216 TaskManager& taskManger = TaskManager::GetInstance();
217 taskManger.InitTaskManager(env);
218 Task* task = new Task();
219 uint64_t taskId = reinterpret_cast<uint64_t>(task);
220 uint64_t duration = 10;
221 taskManger.UpdateExecutedInfo(duration);
222 ASSERT_TRUE(taskId != 0);
223 delete task;
224 }
225
226 HWTEST_F(NativeEngineTest, TaskpoolTest019, testing::ext::TestSize.Level0)
227 {
228 napi_env env = (napi_env)engine_;
229 napi_value argv[] = {nullptr};
230 std::string funcName = "TaskConstructor";
231 napi_value cb = nullptr;
232 napi_value result = nullptr;
233 napi_create_function(env, funcName.c_str(), funcName.size(), Task::TaskConstructor, nullptr, &cb);
234 napi_call_function(env, nullptr, cb, 0, argv, &result);
235 ASSERT_TRUE(result == nullptr);
236 }
237
238 HWTEST_F(NativeEngineTest, TaskpoolTest020, testing::ext::TestSize.Level0)
239 {
240 napi_env env = (napi_env)engine_;
241 napi_value argv[] = {nullptr};
242 std::string funcName = "TaskConstructor";
243 napi_value cb = nullptr;
244 napi_value result = nullptr;
245 napi_create_function(env, funcName.c_str(), funcName.size(), Task::TaskConstructor, nullptr, &cb);
246 napi_call_function(env, nullptr, cb, 0, argv, &result);
247 ASSERT_TRUE(result == nullptr);
248
249 cb = nullptr;
250 napi_value result1 = nullptr;
251 funcName = "SetTransferList";
252 napi_create_function(env, funcName.c_str(), funcName.size(), Task::SetTransferList, nullptr, &cb);
253 napi_call_function(env, nullptr, cb, 0, argv, &result1);
254 ASSERT_TRUE(result1 == nullptr);
255 }
256
257 HWTEST_F(NativeEngineTest, TaskpoolTest021, testing::ext::TestSize.Level0)
258 {
259 napi_env env = (napi_env)engine_;
260 size_t argc = 10;
261 napi_value argv[] = {nullptr};
262 std::string funcName = "TaskConstructor";
263 napi_value cb = nullptr;
264 napi_value result = nullptr;
265 napi_create_function(env, funcName.c_str(), funcName.size(), Task::TaskConstructor, nullptr, &cb);
266 napi_call_function(env, nullptr, cb, 0, argv, &result);
267 ASSERT_TRUE(result == nullptr);
268
269 napi_value func = TestFunction(env);
270 uint32_t number = 10;
271 napi_value value = NapiHelper::CreateUint32(env, number);
272 napi_value* args = new napi_value[argc];
273 napi_value taskName = NapiHelper::CreateEmptyString(env);
274 Task::GenerateTask(env, value, func, taskName, args, argc);
275 ASSERT_TRUE(args != nullptr);
276 }
277
278 HWTEST_F(NativeEngineTest, TaskpoolTest022, testing::ext::TestSize.Level0)
279 {
280 napi_env env = reinterpret_cast<napi_env>(engine_);
281 TaskGroupManager &taskGroupManager = TaskGroupManager::GetInstance();
282 TaskGroup* group = new TaskGroup();
283 uint64_t groupId = reinterpret_cast<uint64_t>(group);
284 Task* task = new Task();
285 uint64_t taskId = reinterpret_cast<uint64_t>(task);
286 napi_value value = NapiHelper::CreateUint64(env, groupId);
287 napi_ref reference = NapiHelper::CreateReference(env, value, 0);
288 taskGroupManager.AddTask(groupId, reference, taskId);
289 ASSERT_NE(reference, nullptr);
290 delete task;
291 delete group;
292 }
293
294 HWTEST_F(NativeEngineTest, TaskpoolTest023, testing::ext::TestSize.Level0)
295 {
296 TaskGroupManager &taskGroupManager = TaskGroupManager::GetInstance();
297 TaskGroup* group = new TaskGroup();
298 uint64_t groupId = reinterpret_cast<uint64_t>(group);
299 TaskGroup* taskGroup = taskGroupManager.GetTaskGroup(groupId);
300 ASSERT_TRUE(taskGroup == nullptr);
301 }
302