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 TaskManager &taskManager = TaskManager::GetInstance();
50 uint32_t taskId = taskManager.GenerateTaskId();
51 ASSERT_TRUE(taskId == 1);
52 }
53
54 HWTEST_F(NativeEngineTest, TaskpoolTest004, testing::ext::TestSize.Level0)
55 {
56 TaskManager &taskManager = TaskManager::GetInstance();
57 uint32_t executeId = taskManager.GenerateExecuteId();
58 ASSERT_TRUE(executeId == 1);
59 }
60
61 HWTEST_F(NativeEngineTest, TaskpoolTest005, testing::ext::TestSize.Level0)
62 {
63 napi_env env = reinterpret_cast<napi_env>(engine_);
64 napi_value taskClass = nullptr;
65 napi_value result = TaskPool::InitTaskPool(env, taskClass);
66 usleep(50000);
67 ASSERT_TRUE(result == nullptr);
68 }
69
70 HWTEST_F(NativeEngineTest, TaskpoolTest006, testing::ext::TestSize.Level0)
71 {
72 napi_env env = reinterpret_cast<napi_env>(engine_);
73 Worker* worker = Worker::WorkerConstructor(env);
74 usleep(50000);
75 ASSERT_NE(worker, nullptr);
76 uint32_t workers = TaskManager::GetInstance().GetRunningWorkers();
77 ASSERT_TRUE(workers == 0);
78 }
79
80 HWTEST_F(NativeEngineTest, TaskpoolTest007, testing::ext::TestSize.Level0)
81 {
82 uint32_t executeId = 10;
83 TaskManager &taskManager = TaskManager::GetInstance();
84 TaskInfo* taskInfo = taskManager.GetTaskInfo(executeId);
85 ASSERT_TRUE(taskInfo == nullptr);
86 }
87
88 HWTEST_F(NativeEngineTest, TaskpoolTest008, testing::ext::TestSize.Level0)
89 {
90 uint32_t executeId = 0;
91 TaskManager &taskManager = TaskManager::GetInstance();
92 TaskInfo *result = taskManager.PopTaskInfo(executeId);
93 ASSERT_TRUE(result == nullptr);
94 }
95
96 HWTEST_F(NativeEngineTest, TaskpoolTest009, testing::ext::TestSize.Level0)
97 {
98 uint32_t executeId = 0;
99 TaskManager &taskManager = TaskManager::GetInstance();
100 bool result = taskManager.UpdateExecuteState(executeId, ExecuteState::NOT_FOUND);
101 ASSERT_TRUE(!result);
102 result = taskManager.UpdateExecuteState(executeId, ExecuteState::RUNNING);
103 ASSERT_TRUE(!result);
104 result = taskManager.UpdateExecuteState(executeId, ExecuteState::WAITING);
105 ASSERT_TRUE(!result);
106 result = taskManager.UpdateExecuteState(executeId, ExecuteState::CANCELED);
107 ASSERT_TRUE(!result);
108 }
109
110 HWTEST_F(NativeEngineTest, TaskpoolTest010, testing::ext::TestSize.Level0)
111 {
112 TaskManager &taskManager = TaskManager::GetInstance();
113 std::pair<uint32_t, Priority> result = taskManager.DequeueExecuteId();
114 ASSERT_TRUE(result.first == 0);
115 ASSERT_TRUE(result.second == Priority::HIGH);
116 }
117
118 HWTEST_F(NativeEngineTest, TaskpoolTest011, testing::ext::TestSize.Level0)
119 {
120 TaskManager &taskManager = TaskManager::GetInstance();
121 uint32_t result = taskManager.GetTaskNum();
122 ASSERT_TRUE(result == 0);
123 }
124
125 HWTEST_F(NativeEngineTest, TaskpoolTest012, testing::ext::TestSize.Level0)
126 {
127 ExecuteQueue executeQueue;
128 uint32_t result = executeQueue.DequeueExecuteId();
129 ASSERT_TRUE(result == 0);
130 }
131
132 HWTEST_F(NativeEngineTest, TaskpoolTest013, testing::ext::TestSize.Level0)
133 {
134 ExecuteQueue executeQueue;
135 bool result = executeQueue.IsEmpty();
136 ASSERT_TRUE(result);
137 }
138
139 HWTEST_F(NativeEngineTest, TaskpoolTest014, testing::ext::TestSize.Level0)
140 {
141 ExecuteQueue executeQueue;
142 uint32_t result = executeQueue.GetTaskNum();
143 ASSERT_TRUE(result == 0);
144 }
145
146 HWTEST_F(NativeEngineTest, TaskpoolTest015, testing::ext::TestSize.Level0)
147 {
148 napi_env env = reinterpret_cast<napi_env>(engine_);
149 TaskManager& taskManger = TaskManager::GetInstance();
150 taskManger.InitTaskManager(env);
151 uint32_t executeId = taskManger.GenerateExecuteId();
152 ExecuteQueue executeQueue;
153 bool result = executeQueue.IsEmpty();
154 ASSERT_TRUE(result);
155 uint32_t taskNum = executeQueue.GetTaskNum();
156 ASSERT_TRUE(taskNum == 0);
157 executeQueue.EnqueueExecuteId(executeId);
158 result = executeQueue.IsEmpty();
159 ASSERT_TRUE(!result);
160 taskNum = executeQueue.GetTaskNum();
161 ASSERT_TRUE(taskNum != 0);
162 uint32_t dequeueExecuteId = executeQueue.DequeueExecuteId();
163 ASSERT_TRUE(dequeueExecuteId == executeId);
164 result = executeQueue.IsEmpty();
165 ASSERT_TRUE(result);
166 executeQueue.EnqueueExecuteId(executeId);
167 executeQueue.EnqueueExecuteId(executeId);
168 taskNum = executeQueue.GetTaskNum();
169 ASSERT_TRUE(taskNum == 2);
170 dequeueExecuteId = executeQueue.DequeueExecuteId();
171 ASSERT_TRUE(dequeueExecuteId == executeId);
172 taskNum = executeQueue.GetTaskNum();
173 ASSERT_TRUE(taskNum == 1);
174 dequeueExecuteId = executeQueue.DequeueExecuteId();
175 ASSERT_TRUE(dequeueExecuteId == executeId);
176 taskNum = executeQueue.GetTaskNum();
177 ASSERT_TRUE(taskNum == 0);
178 }
179
napi_create_cbinfo(napi_env env,size_t * argc,NativeValue ** argv)180 napi_callback_info napi_create_cbinfo(napi_env env,
181 size_t* argc,
182 NativeValue** argv)
183 {
184 NativeCallbackInfo* info = new NativeCallbackInfo;
185
186 if (argv != nullptr && argc != nullptr) {
187 info->argc = *argc;
188 info->argv = argv;
189 return reinterpret_cast<napi_callback_info>(info);
190 }
191 return nullptr;
192 }
193
194 HWTEST_F(NativeEngineTest, TaskpoolTest016, testing::ext::TestSize.Level0)
195 {
196 napi_env env = reinterpret_cast<napi_env>(engine_);
197 size_t argc = 0;
198 NativeValue* argv0[] = {nullptr};
199 napi_callback_info cbinfo = napi_create_cbinfo(env, &argc, argv0);
200 napi_value result = TaskGroup::TaskGroupConstructor(env, cbinfo);
201 ASSERT_TRUE(result == nullptr);
202 }
203
204 HWTEST_F(NativeEngineTest, TaskpoolTest017, testing::ext::TestSize.Level0)
205 {
206 napi_env env = reinterpret_cast<napi_env>(engine_);
207 size_t argc = 0;
208 NativeValue* argv0[] = {nullptr};
209 napi_callback_info cbinfo = napi_create_cbinfo(env, &argc, argv0);
210 napi_value result = TaskGroup::TaskGroupConstructor(env, cbinfo);
211 ASSERT_TRUE(result == nullptr);
212 size_t argc1 = 10;
213 NativeValue* argv1[] = {nullptr};
214 napi_callback_info cbinfo1 = napi_create_cbinfo(env, &argc1, argv1);
215 napi_value result1 = TaskGroup::AddTask(env, cbinfo1);
216 ASSERT_TRUE(result1 == nullptr);
217 }
218
219 HWTEST_F(NativeEngineTest, TaskpoolTest018, testing::ext::TestSize.Level0)
220 {
221 uint32_t number = 10;
222 napi_env env = reinterpret_cast<napi_env>(engine_);
223 napi_value value = NapiHelper::CreateUint32(env, number);
224 napi_value result = TaskPool::InitTaskPool(env, value);
225 usleep(50000);
226 ASSERT_TRUE(result != nullptr);
227 }
228
229 HWTEST_F(NativeEngineTest, TaskpoolTest019, testing::ext::TestSize.Level0)
230 {
231 napi_env env = reinterpret_cast<napi_env>(engine_);
232 TaskManager& taskManger = TaskManager::GetInstance();
233 taskManger.InitTaskManager(env);
234 uint32_t taskId = taskManger.GenerateTaskId();
235 napi_value task = NapiHelper::CreateUint32(env, taskId);
236 uint32_t executeId = taskManger.GenerateExecuteId();
237 ASSERT_TRUE(executeId == 3);
238 TaskInfo* taskInfo = taskManger.GenerateTaskInfoFromTask(env, task, executeId);
239 ASSERT_TRUE(taskInfo == nullptr);
240 }
241
242 HWTEST_F(NativeEngineTest, TaskpoolTest020, testing::ext::TestSize.Level0)
243 {
244 napi_env env = reinterpret_cast<napi_env>(engine_);
245 TaskManager& taskManger = TaskManager::GetInstance();
246 taskManger.InitTaskManager(env);
247 uint32_t taskId = taskManger.GenerateTaskId();
248 uint32_t executeId = taskManger.GenerateExecuteId();
249 uint32_t taskId1 = 10;
250 uint32_t executeId1 = 20;
251 taskManger.StoreRunningInfo(taskId, executeId);
252 taskManger.StoreRunningInfo(taskId1, executeId1);
253 taskManger.PopRunningInfo(taskId, executeId);
254 uint32_t taskNum = taskManger.GetTaskNum();
255 ASSERT_TRUE(taskNum == 0);
256 uint32_t threadNum = taskManger.GetThreadNum();
257 ASSERT_TRUE(threadNum == 0);
258 uint32_t idleWorkers = taskManger.GetIdleWorkers();
259 ASSERT_TRUE(idleWorkers == 0);
260 uint32_t runningWorkers = taskManger.GetRunningWorkers();
261 ASSERT_TRUE(runningWorkers == 0);
262 uint32_t timeoutWorkers = taskManger.GetTimeoutWorkers();
263 ASSERT_TRUE(timeoutWorkers == 0);
264 }
265
TestFunction(napi_env env)266 napi_value TestFunction(napi_env env)
267 {
268 napi_value result = nullptr;
269 const char* message = "test taskpool";
270 size_t length = strlen(message);
271 napi_create_string_utf8(env, message, length, &result);
272 return result;
273 }
274
275 HWTEST_F(NativeEngineTest, TaskpoolTest021, testing::ext::TestSize.Level0)
276 {
277 napi_env env = reinterpret_cast<napi_env>(engine_);
278 TaskManager& taskManger = TaskManager::GetInstance();
279 taskManger.InitTaskManager(env);
280 uint32_t taskId = taskManger.GenerateTaskId();
281 uint32_t executeId = taskManger.GenerateExecuteId();
282 napi_value args = NapiHelper::CreateUint32(env, taskId);
283 napi_value task = nullptr;
284 napi_value function = NapiHelper::GetNameProperty(env, task, FUNCTION_STR);
285 napi_value function1 = TestFunction(env);
286 TaskInfo* taskInfo = taskManger.GenerateTaskInfo(env, function, args, taskId, executeId);
287 ASSERT_TRUE(taskInfo == nullptr);
288 taskInfo = taskManger.GenerateTaskInfo(env, function1, args, taskId, executeId);
289 ASSERT_TRUE(taskInfo == nullptr);
290 TaskInfo* taskInfo1 = taskManger.GetTaskInfo(executeId);
291 ASSERT_TRUE(taskInfo1 == nullptr);
292 TaskInfo* taskInfo2 = taskManger.PopTaskInfo(executeId);
293 ASSERT_TRUE(taskInfo2 == nullptr);
294 uint32_t taskNum = taskManger.GetTaskNum();
295 ASSERT_TRUE(taskNum == 0);
296 uint32_t threadNum = taskManger.GetThreadNum();
297 ASSERT_TRUE(threadNum == 0);
298 uint32_t idleWorkers = taskManger.GetIdleWorkers();
299 ASSERT_TRUE(idleWorkers == 0);
300 uint32_t runningWorkers = taskManger.GetRunningWorkers();
301 ASSERT_TRUE(runningWorkers == 0);
302 uint32_t timeoutWorkers = taskManger.GetTimeoutWorkers();
303 ASSERT_TRUE(timeoutWorkers == 0);
304 }
305
306 HWTEST_F(NativeEngineTest, TaskpoolTest022, testing::ext::TestSize.Level0)
307 {
308 napi_env env = reinterpret_cast<napi_env>(engine_);
309 TaskManager& taskManger = TaskManager::GetInstance();
310 taskManger.InitTaskManager(env);
311 uint32_t executeId = taskManger.GenerateExecuteId();
312 taskManger.AddExecuteState(executeId);
313 bool result = taskManger.UpdateExecuteState(executeId, ExecuteState::RUNNING);
314 ASSERT_TRUE(result);
315 result = taskManger.UpdateExecuteState(executeId, ExecuteState::CANCELED);
316 ASSERT_TRUE(result);
317 result = taskManger.UpdateExecuteState(executeId, ExecuteState::NOT_FOUND);
318 ASSERT_TRUE(result);
319 result = taskManger.UpdateExecuteState(executeId, ExecuteState::WAITING);
320 ASSERT_TRUE(result);
321 taskManger.RemoveExecuteState(executeId);
322 ASSERT_TRUE(executeId == 6);
323 result = taskManger.UpdateExecuteState(executeId, ExecuteState::RUNNING);
324 ASSERT_TRUE(!result);
325 result = taskManger.UpdateExecuteState(executeId, ExecuteState::CANCELED);
326 ASSERT_TRUE(!result);
327 result = taskManger.UpdateExecuteState(executeId, ExecuteState::NOT_FOUND);
328 ASSERT_TRUE(!result);
329 result = taskManger.UpdateExecuteState(executeId, ExecuteState::WAITING);
330 ASSERT_TRUE(!result);
331 }
332
333 HWTEST_F(NativeEngineTest, TaskpoolTest023, testing::ext::TestSize.Level0)
334 {
335 napi_env env = reinterpret_cast<napi_env>(engine_);
336 TaskManager& taskManger = TaskManager::GetInstance();
337 taskManger.InitTaskManager(env);
338 taskManger.PopTaskEnvInfo(env);
339 uint32_t taskId = taskManger.GenerateTaskId();
340 ASSERT_TRUE(taskId == 5);
341 uint32_t executeId = taskManger.GenerateExecuteId();
342 ASSERT_TRUE(executeId == 7);
343 }
344
345 HWTEST_F(NativeEngineTest, TaskpoolTest024, testing::ext::TestSize.Level0)
346 {
347 napi_env env = reinterpret_cast<napi_env>(engine_);
348 TaskManager& taskManger = TaskManager::GetInstance();
349 taskManger.InitTaskManager(env);
350 uint32_t executeId = taskManger.GenerateExecuteId();
351 taskManger.EnqueueExecuteId(executeId);
352 ASSERT_TRUE(executeId == 8);
353 std::pair<uint32_t, Priority> result = taskManger.DequeueExecuteId();
354 ASSERT_TRUE(result.first == 0);
355 ASSERT_TRUE(result.second == 0);
356 }
357
358 HWTEST_F(NativeEngineTest, TaskpoolTest025, testing::ext::TestSize.Level0)
359 {
360 TaskGroupManager &taskGroupManager = TaskGroupManager::GetInstance();
361 uint32_t groupExecuteId = taskGroupManager.GenerateGroupExecuteId();
362 bool result = taskGroupManager.IsRunning(groupExecuteId);
363 ASSERT_TRUE(!result);
364 }
365
366 HWTEST_F(NativeEngineTest, TaskpoolTest026, testing::ext::TestSize.Level0)
367 {
368 napi_env env = reinterpret_cast<napi_env>(engine_);
369 TaskManager& taskManger = TaskManager::GetInstance();
370 taskManger.InitTaskManager(env);
371 uint32_t executeId = taskManger.GenerateExecuteId();
372 taskManger.CancelTask(env, executeId);
373 ASSERT_TRUE(executeId == 9);
374 }
375
376 HWTEST_F(NativeEngineTest, TaskpoolTest027, testing::ext::TestSize.Level0)
377 {
378 napi_env env = reinterpret_cast<napi_env>(engine_);
379 TaskManager& taskManger = TaskManager::GetInstance();
380 taskManger.InitTaskManager(env);
381 uint32_t executeId = taskManger.GenerateExecuteId();
382 taskManger.TryTriggerLoadBalance();
383 ASSERT_TRUE(executeId == 10);
384 }
385
386 HWTEST_F(NativeEngineTest, TaskpoolTest028, testing::ext::TestSize.Level0)
387 {
388 napi_env env = reinterpret_cast<napi_env>(engine_);
389 TaskManager& taskManger = TaskManager::GetInstance();
390 taskManger.InitTaskManager(env);
391 uint32_t executeId = taskManger.GenerateExecuteId();
392 uint64_t duration = 10;
393 taskManger.UpdateExecutedInfo(duration);
394 ASSERT_TRUE(executeId == 11);
395 }
396
397 HWTEST_F(NativeEngineTest, TaskpoolTest029, testing::ext::TestSize.Level0)
398 {
399 napi_env env = reinterpret_cast<napi_env>(engine_);
400 size_t argc = 0;
401 NativeValue* argv[] = {nullptr};
402 napi_callback_info cbinfo = napi_create_cbinfo(env, &argc, argv);
403 napi_value result = Task::TaskConstructor(env, cbinfo);
404 ASSERT_TRUE(result == nullptr);
405 }
406
407 HWTEST_F(NativeEngineTest, TaskpoolTest030, testing::ext::TestSize.Level0)
408 {
409 napi_env env = reinterpret_cast<napi_env>(engine_);
410 size_t argc = 0;
411 NativeValue* argv[] = {nullptr};
412 napi_callback_info cbinfo = napi_create_cbinfo(env, &argc, argv);
413 napi_value result = Task::TaskConstructor(env, cbinfo);
414 ASSERT_TRUE(result == nullptr);
415 napi_value result1 = Task::SetTransferList(env, cbinfo);
416 ASSERT_TRUE(result1 == nullptr);
417 }
418
419 HWTEST_F(NativeEngineTest, TaskpoolTest031, testing::ext::TestSize.Level0)
420 {
421 napi_env env = reinterpret_cast<napi_env>(engine_);
422 size_t argc = 10;
423 NativeValue* argv[] = {nullptr};
424 napi_callback_info cbinfo = napi_create_cbinfo(env, &argc, argv);
425 napi_value result = Task::TaskConstructor(env, cbinfo);
426 ASSERT_TRUE(result == nullptr);
427 napi_value func = TestFunction(env);
428 uint32_t number = 10;
429 napi_value value = NapiHelper::CreateUint32(env, number);
430 napi_value* args = new napi_value[argc];
431 Task::CreateTaskByFunc(env, value, func, args, argc);
432 ASSERT_TRUE(args != nullptr);
433 }
434
435 HWTEST_F(NativeEngineTest, TaskpoolTest032, testing::ext::TestSize.Level0)
436 {
437 TaskGroupManager &taskGroupManager = TaskGroupManager::GetInstance();
438 uint32_t groupId = taskGroupManager.GenerateGroupId();
439 ASSERT_TRUE(groupId == 2);
440 }
441
442 HWTEST_F(NativeEngineTest, TaskpoolTest033, testing::ext::TestSize.Level0)
443 {
444 TaskGroupManager &taskGroupManager = TaskGroupManager::GetInstance();
445 uint32_t groupExecuteId = taskGroupManager.GenerateGroupExecuteId();
446 ASSERT_TRUE(groupExecuteId == 2);
447 }
448
449 HWTEST_F(NativeEngineTest, TaskpoolTest034, testing::ext::TestSize.Level0)
450 {
451 napi_env env = reinterpret_cast<napi_env>(engine_);
452 TaskGroupManager &taskGroupManager = TaskGroupManager::GetInstance();
453 uint32_t groupId = taskGroupManager.GenerateGroupId();
454 uint32_t groupExecuteId = taskGroupManager.GenerateGroupExecuteId();
455 napi_value value = NapiHelper::CreateUint32(env, groupId);
456 napi_ref reference = NapiHelper::CreateReference(env, value, groupExecuteId);
457 taskGroupManager.AddTask(groupId, reference);
458 ASSERT_NE(reference, nullptr);
459 }
460
461 HWTEST_F(NativeEngineTest, TaskpoolTest035, testing::ext::TestSize.Level0)
462 {
463 TaskGroupManager &taskGroupManager = TaskGroupManager::GetInstance();
464 uint32_t groupId = taskGroupManager.GenerateGroupId();
465 const std::list<napi_ref>&tasks = taskGroupManager.GetTasksByGroup(groupId);
466 ASSERT_TRUE(tasks.size() == 0);
467 }
468
469 HWTEST_F(NativeEngineTest, TaskpoolTest036, testing::ext::TestSize.Level0)
470 {
471 napi_env env = reinterpret_cast<napi_env>(engine_);
472 TaskGroupManager &taskGroupManager = TaskGroupManager::GetInstance();
473 uint32_t groupId = taskGroupManager.GenerateGroupId();
474 taskGroupManager.ClearTasks(env, groupId);
475 ASSERT_TRUE(groupId == 5);
476 }
477
478 HWTEST_F(NativeEngineTest, TaskpoolTest037, testing::ext::TestSize.Level0)
479 {
480 napi_env env = reinterpret_cast<napi_env>(engine_);
481 TaskGroupManager &taskGroupManager = TaskGroupManager::GetInstance();
482 uint32_t groupId = taskGroupManager.GenerateGroupId();
483 uint32_t groupExecuteId = taskGroupManager.GenerateGroupExecuteId();
484 uint32_t taskNum = 10;
485 GroupInfo* groupInfo = taskGroupManager.GenerateGroupInfo(env, taskNum, groupId, groupExecuteId);
486 ASSERT_TRUE(groupInfo != nullptr);
487 ASSERT_TRUE(groupInfo->groupId == 6);
488 ASSERT_TRUE(groupInfo->taskNum == 10);
489 ASSERT_TRUE(groupInfo->finishedTask == 0);
490 ASSERT_TRUE(groupInfo->executeIds.size() == 0);
491 ASSERT_TRUE(groupInfo->deferred == nullptr);
492 ASSERT_TRUE(groupInfo->resArr != nullptr);
493 }
494
495 HWTEST_F(NativeEngineTest, TaskpoolTest038, testing::ext::TestSize.Level0)
496 {
497 napi_env env = reinterpret_cast<napi_env>(engine_);
498 TaskGroupManager &taskGroupManager = TaskGroupManager::GetInstance();
499 uint32_t groupId = taskGroupManager.GenerateGroupId();
500 ASSERT_TRUE(groupId == 7);
501 uint32_t groupExecuteId = taskGroupManager.GenerateGroupExecuteId();
502 uint32_t taskNum = 10;
503 GroupInfo* groupInfo = taskGroupManager.GenerateGroupInfo(env, taskNum, groupId, groupExecuteId);
504 taskGroupManager.ClearGroupInfo(env, groupExecuteId, groupInfo);
505 ASSERT_TRUE(groupExecuteId == 5);
506 }
507
508 HWTEST_F(NativeEngineTest, TaskpoolTest039, testing::ext::TestSize.Level0)
509 {
510 TaskGroupManager &taskGroupManager = TaskGroupManager::GetInstance();
511 uint32_t groupExecuteId = taskGroupManager.GenerateGroupExecuteId();
512 GroupInfo* groupInfo = taskGroupManager.GetGroupInfoByExecutionId(groupExecuteId);
513 ASSERT_TRUE(groupInfo == nullptr);
514 }
515
516 HWTEST_F(NativeEngineTest, TaskpoolTest040, testing::ext::TestSize.Level0)
517 {
518 TaskGroupManager &taskGroupManager = TaskGroupManager::GetInstance();
519 uint32_t groupId = taskGroupManager.GenerateGroupId();
520 taskGroupManager.ClearExecuteId(groupId);
521 ASSERT_TRUE(groupId == 8);
522 }