1 /*
2 * Copyright (c) 2023-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 "test.h"
17
18 #include <unistd.h>
19
20 #include "async_runner.h"
21 #include "async_runner_manager.h"
22 #include "helper/napi_helper.h"
23 #include "queue.h"
24 #include "sequence_runner_manager.h"
25 #include "task.h"
26 #include "taskpool.h"
27 #include "task_group_manager.h"
28 #include "task_manager.h"
29 #include "task_runner.h"
30 #include "thread.h"
31 #include "tools/log.h"
32 #include "uv.h"
33 #include "worker.h"
34
35 using namespace Commonlibrary::Concurrent::TaskPoolModule;
GetSendableFunction(napi_env env,const char * str,napi_value & result)36 void GetSendableFunction(napi_env env, const char* str, napi_value& result)
37 {
38 napi_value instance = SendableUtils::CreateSendableInstance(env);
39 napi_value name = nullptr;
40 napi_create_string_utf8(env, str, NAPI_AUTO_LENGTH, &name);
41 napi_get_property(env, instance, name, &result);
42 }
43
GeneratorTask(napi_env env,napi_value thisVar)44 napi_value GeneratorTask(napi_env env, napi_value thisVar)
45 {
46 napi_value func = nullptr;
47 GetSendableFunction(env, "foo", func);
48 napi_value argv[] = { func };
49 std::string funcName = "TaskConstructor";
50 napi_value cb = nullptr;
51 napi_value task = nullptr;
52 napi_create_function(env, funcName.c_str(), funcName.size(), Task::TaskConstructor, nullptr, &cb);
53 napi_call_function(env, thisVar, cb, 1, argv, &task);
54 return task;
55 }
56
GeneratorTaskGroup(napi_env env,napi_value thisVar)57 napi_value GeneratorTaskGroup(napi_env env, napi_value thisVar)
58 {
59 std::string funcName = "TaskGroupConstructor";
60 napi_value argv[] = {};
61 napi_value cb = nullptr;
62 napi_value group = nullptr;
63 napi_create_function(env, funcName.c_str(), funcName.size(), TaskGroup::TaskGroupConstructor, nullptr, &cb);
64 napi_call_function(env, thisVar, cb, 0, argv, &group);
65 return group;
66 }
67
GeneratorTaskGroupWithName(napi_env env,napi_value thisVar,const char * name)68 napi_value GeneratorTaskGroupWithName(napi_env env, napi_value thisVar, const char* name)
69 {
70 std::string funcName = "TaskGroupConstructor";
71 napi_value str = nullptr;
72 napi_create_string_utf8(env, name, NAPI_AUTO_LENGTH, &str);
73 napi_value argv[] = { str };
74 napi_value cb = nullptr;
75 napi_value group = nullptr;
76 napi_create_function(env, funcName.c_str(), funcName.size(), TaskGroup::TaskGroupConstructor, nullptr, &cb);
77 napi_call_function(env, thisVar, cb, 1, argv, &group);
78 return group;
79 }
80
CreateTaskObject(napi_env env,TaskType taskType=TaskType::TASK,ExecuteState state=ExecuteState::NOT_FOUND,bool needStoreTask=false)81 napi_value CreateTaskObject(napi_env env, TaskType taskType = TaskType::TASK,
82 ExecuteState state = ExecuteState::NOT_FOUND, bool needStoreTask = false)
83 {
84 napi_value thisValue = NapiHelper::CreateObject(env);
85 size_t argc = 0;
86 napi_value func = nullptr;
87 napi_create_string_utf8(env, "testFunc", NAPI_AUTO_LENGTH, &func);
88 napi_value* args = new napi_value[1];
89 ObjectScope<napi_value> objScope(args, true);
90 napi_value taskName = NapiHelper::CreateEmptyString(env);
91 Task* task = Task::GenerateTask(env, thisValue, func, taskName, args, argc);
92 task->UpdateTaskType(taskType);
93 if (state != ExecuteState::NOT_FOUND) {
94 task->taskState_ = state;
95 }
96 if (!needStoreTask) {
97 TaskManager::GetInstance().RemoveTask(task->taskId_);
98 }
99 if (napi_wrap(
100 env, thisValue, task,
101 [](napi_env environment, void* data, void* hint) {
102 auto obj = reinterpret_cast<Task*>(data);
103 if (obj != nullptr) {
104 delete obj;
105 }
106 }, nullptr, nullptr) != napi_ok) {
107 delete task;
108 task = nullptr;
109 return nullptr;
110 }
111 return thisValue;
112 }
113
CreateNullTaskObject(napi_env env)114 napi_value CreateNullTaskObject(napi_env env)
115 {
116 napi_value thisValue = NapiHelper::CreateObject(env);
117 Task* task = nullptr;
118 napi_wrap(
119 env, thisValue, task,
120 [](napi_env environment, void* data, void* hint) {
121 auto obj = reinterpret_cast<Task*>(data);
122 if (obj != nullptr) {
123 delete obj;
124 }
125 }, nullptr, nullptr);
126 return thisValue;
127 }
128
GetNapiString(napi_env env,const char * str)129 napi_value GetNapiString(napi_env env, const char* str)
130 {
131 napi_value name = nullptr;
132 napi_create_string_utf8(env, str, NAPI_AUTO_LENGTH, &name);
133 return name;
134 }
135
136 HWTEST_F(NativeEngineTest, TaskpoolTest001, testing::ext::TestSize.Level0)
137 {
138 TaskManager &taskManager = TaskManager::GetInstance();
139 uint32_t result = taskManager.GetThreadNum();
140 ASSERT_TRUE(result == 0);
141 }
142
143 HWTEST_F(NativeEngineTest, TaskpoolTest002, testing::ext::TestSize.Level0)
144 {
145 napi_env env = reinterpret_cast<napi_env>(engine_);
146 Worker* worker = reinterpret_cast<Worker*>(NativeEngineTest::WorkerConstructor(env));
147 ASSERT_NE(worker, nullptr);
148 }
149
150 HWTEST_F(NativeEngineTest, TaskpoolTest003, testing::ext::TestSize.Level0)
151 {
152 napi_env env = reinterpret_cast<napi_env>(engine_);
153 napi_value taskClass = nullptr;
154 napi_value result = TaskPool::InitTaskPool(env, taskClass);
155 usleep(50000);
156 ASSERT_TRUE(result == nullptr);
157 }
158
159 HWTEST_F(NativeEngineTest, TaskpoolTest004, testing::ext::TestSize.Level0)
160 {
161 napi_env env = reinterpret_cast<napi_env>(engine_);
162 Worker* worker = reinterpret_cast<Worker*>(NativeEngineTest::WorkerConstructor(env));
163 ASSERT_NE(worker, nullptr);
164 uint32_t workers = TaskManager::GetInstance().GetRunningWorkers();
165 ASSERT_TRUE(workers == 0);
166 }
167
168 HWTEST_F(NativeEngineTest, TaskpoolTest005, testing::ext::TestSize.Level0)
169 {
170 uint32_t taskId = 10;
171 TaskManager &taskManager = TaskManager::GetInstance();
172 Task* task = taskManager.GetTask(taskId);
173 ASSERT_TRUE(task == nullptr);
174 }
175
176 HWTEST_F(NativeEngineTest, TaskpoolTest006, testing::ext::TestSize.Level0)
177 {
178 TaskManager &taskManager = TaskManager::GetInstance();
179 std::pair<uint32_t, Priority> result = taskManager.DequeueTaskId();
180 ASSERT_TRUE(result.first == 0);
181 ASSERT_TRUE(result.second == Priority::LOW);
182 }
183
184 HWTEST_F(NativeEngineTest, TaskpoolTest007, testing::ext::TestSize.Level0)
185 {
186 TaskManager &taskManager = TaskManager::GetInstance();
187 uint32_t result = taskManager.GetTaskNum();
188 ASSERT_TRUE(result == 0);
189 }
190
191 HWTEST_F(NativeEngineTest, TaskpoolTest008, testing::ext::TestSize.Level0)
192 {
193 ExecuteQueue executeQueue;
194 uint32_t result = executeQueue.DequeueTaskId();
195 ASSERT_TRUE(result == 0);
196 }
197
198 HWTEST_F(NativeEngineTest, TaskpoolTest009, testing::ext::TestSize.Level0)
199 {
200 ExecuteQueue executeQueue;
201 bool result = executeQueue.IsEmpty();
202 ASSERT_TRUE(result);
203 }
204
205 HWTEST_F(NativeEngineTest, TaskpoolTest010, testing::ext::TestSize.Level0)
206 {
207 ExecuteQueue executeQueue;
208 uint32_t result = executeQueue.GetTaskNum();
209 ASSERT_TRUE(result == 0);
210 }
211
212 HWTEST_F(NativeEngineTest, TaskpoolTest011, testing::ext::TestSize.Level0)
213 {
214 napi_env env = (napi_env)engine_;
215 ExceptionScope scope(env);
216 napi_value argv[] = {nullptr};
217 std::string funcName = "TaskGroupConstructor";
218 napi_value cb = nullptr;
219 napi_value result = nullptr;
220 napi_create_function(env, funcName.c_str(), funcName.size(), TaskGroup::TaskGroupConstructor, nullptr, &cb);
221 napi_call_function(env, nullptr, cb, 0, argv, &result);
222 ASSERT_TRUE(result != nullptr);
223 }
224
225 HWTEST_F(NativeEngineTest, TaskpoolTest012, testing::ext::TestSize.Level0)
226 {
227 napi_env env = (napi_env)engine_;
228 ExceptionScope scope(env);
229 napi_value argv[] = {nullptr};
230 std::string funcName = "TaskGroupConstructor";
231 napi_value cb = nullptr;
232 napi_value result = nullptr;
233 napi_create_function(env, funcName.c_str(), funcName.size(), TaskGroup::TaskGroupConstructor, nullptr, &cb);
234 napi_call_function(env, nullptr, cb, 0, argv, &result);
235 ASSERT_TRUE(result != nullptr);
236 napi_value exception;
237 napi_get_and_clear_last_exception(env, &exception);
238
239 size_t argc1 = 0;
240 napi_value argv1[] = {nullptr};
241 funcName = "AddTask";
242 cb = nullptr;
243 napi_value result1 = nullptr;
244 napi_create_function(env, funcName.c_str(), funcName.size(), TaskGroup::AddTask, nullptr, &cb);
245 napi_call_function(env, nullptr, cb, argc1, argv1, &result1);
246 ASSERT_TRUE(result1 == nullptr);
247 }
248
249 HWTEST_F(NativeEngineTest, TaskpoolTest013, testing::ext::TestSize.Level0)
250 {
251 uint32_t number = 10;
252 napi_env env = reinterpret_cast<napi_env>(engine_);
253 napi_value value = NapiHelper::CreateUint32(env, number);
254 napi_value result = TaskPool::InitTaskPool(env, value);
255 usleep(50000);
256 ASSERT_TRUE(result != nullptr);
257 }
258
TestFunction(napi_env env)259 napi_value TestFunction(napi_env env)
260 {
261 napi_value result = nullptr;
262 const char* message = "test taskpool";
263 size_t length = strlen(message);
264 napi_create_string_utf8(env, message, length, &result);
265 return result;
266 }
267
268 HWTEST_F(NativeEngineTest, TaskpoolTest014, testing::ext::TestSize.Level0)
269 {
270 napi_env env = reinterpret_cast<napi_env>(engine_);
271 TaskManager& taskManager = TaskManager::GetInstance();
272 taskManager.InitTaskManager(env);
273 usleep(50000);
274 uint32_t taskNum = taskManager.GetTaskNum();
275 ASSERT_TRUE(taskNum == 0);
276 uint32_t threadNum = taskManager.GetThreadNum();
277 ASSERT_TRUE(threadNum != 0);
278 uint32_t idleWorkers = taskManager.GetIdleWorkers();
279 ASSERT_TRUE(idleWorkers != 0);
280 uint32_t runningWorkers = taskManager.GetRunningWorkers();
281 ASSERT_TRUE(runningWorkers == 0);
282 uint32_t timeoutWorkers = taskManager.GetTimeoutWorkers();
283 ASSERT_TRUE(timeoutWorkers == 0);
284 }
285
286 HWTEST_F(NativeEngineTest, TaskpoolTest015, testing::ext::TestSize.Level0)
287 {
288 napi_env env = reinterpret_cast<napi_env>(engine_);
289 TaskManager& taskManager = TaskManager::GetInstance();
290 std::pair<uint32_t, Priority> result = taskManager.DequeueTaskId();
291 ASSERT_TRUE(result.first == 0);
292 ASSERT_TRUE(result.second == Priority::LOW);
293 }
294
295 HWTEST_F(NativeEngineTest, TaskpoolTest016, testing::ext::TestSize.Level0)
296 {
297 napi_env env = reinterpret_cast<napi_env>(engine_);
298 ExceptionScope scope(env);
299 TaskManager& taskManager = TaskManager::GetInstance();
300 Task* task = new Task();
301 uint32_t taskId = TaskManager::GetInstance().CalculateTaskId(reinterpret_cast<uint64_t>(task));
302 taskManager.CancelTask(env, taskId);
303 ASSERT_TRUE(taskId != 0);
304 delete task;
305 }
306
307 HWTEST_F(NativeEngineTest, TaskpoolTest017, testing::ext::TestSize.Level0)
308 {
309 napi_env env = reinterpret_cast<napi_env>(engine_);
310 TaskManager& taskManager = TaskManager::GetInstance();
311 Task* task = new Task();
312 uint32_t taskId = TaskManager::GetInstance().CalculateTaskId(reinterpret_cast<uint64_t>(task));
313 taskManager.TryTriggerExpand();
314 ASSERT_TRUE(taskId != 0);
315 delete task;
316 }
317
318 HWTEST_F(NativeEngineTest, TaskpoolTest018, testing::ext::TestSize.Level0)
319 {
320 napi_env env = reinterpret_cast<napi_env>(engine_);
321 TaskManager& taskManager = TaskManager::GetInstance();
322 Task* task = new Task();
323 uint32_t taskId = TaskManager::GetInstance().CalculateTaskId(reinterpret_cast<uint64_t>(task));
324 uint64_t duration = 10;
325 taskManager.UpdateExecutedInfo(duration);
326 ASSERT_TRUE(taskId != 0);
327 delete task;
328 }
329
330 HWTEST_F(NativeEngineTest, TaskpoolTest019, testing::ext::TestSize.Level0)
331 {
332 napi_env env = (napi_env)engine_;
333 ExceptionScope scope(env);
334 napi_value argv[] = {nullptr};
335 std::string funcName = "TaskConstructor";
336 napi_value cb = nullptr;
337 napi_value result = nullptr;
338 napi_create_function(env, funcName.c_str(), funcName.size(), Task::TaskConstructor, nullptr, &cb);
339 napi_call_function(env, nullptr, cb, 0, argv, &result);
340 ASSERT_TRUE(result == nullptr);
341 }
342
343 HWTEST_F(NativeEngineTest, TaskpoolTest020, testing::ext::TestSize.Level0)
344 {
345 napi_env env = (napi_env)engine_;
346 ExceptionScope scope(env);
347 napi_value argv[] = {nullptr};
348 std::string funcName = "TaskConstructor";
349 napi_value cb = nullptr;
350 napi_value result = nullptr;
351 napi_create_function(env, funcName.c_str(), funcName.size(), Task::TaskConstructor, nullptr, &cb);
352 napi_call_function(env, nullptr, cb, 0, argv, &result);
353 ASSERT_TRUE(result == nullptr);
354 napi_value exception = nullptr;
355 napi_get_and_clear_last_exception(env, &exception);
356
357 cb = nullptr;
358 napi_value result1 = nullptr;
359 funcName = "SetTransferList";
360 napi_create_function(env, funcName.c_str(), funcName.size(), Task::SetTransferList, nullptr, &cb);
361 napi_call_function(env, nullptr, cb, 0, argv, &result1);
362 ASSERT_TRUE(result1 != nullptr);
363 }
364
365 HWTEST_F(NativeEngineTest, TaskpoolTest021, testing::ext::TestSize.Level0)
366 {
367 napi_env env = (napi_env)engine_;
368 ExceptionScope scope(env);
369 size_t argc = 10;
370 napi_value argv[] = {nullptr};
371 std::string funcName = "TaskConstructor";
372 napi_value cb = nullptr;
373 napi_value result = nullptr;
374 napi_create_function(env, funcName.c_str(), funcName.size(), Task::TaskConstructor, nullptr, &cb);
375 napi_call_function(env, nullptr, cb, 0, argv, &result);
376 ASSERT_TRUE(result == nullptr);
377
378 napi_value func = TestFunction(env);
379 uint32_t number = 10;
380 napi_value value = NapiHelper::CreateUint32(env, number);
381 napi_value* args = new napi_value[argc];
382 ObjectScope<napi_value> objScope(args, true);
383 napi_value taskName = NapiHelper::CreateEmptyString(env);
384 Task::GenerateTask(env, value, func, taskName, args, argc);
385 ASSERT_TRUE(args != nullptr);
386 }
387
388 HWTEST_F(NativeEngineTest, TaskpoolTest022, testing::ext::TestSize.Level0)
389 {
390 napi_env env = reinterpret_cast<napi_env>(engine_);
391 ExceptionScope scope(env);
392 TaskGroupManager &taskGroupManager = TaskGroupManager::GetInstance();
393 TaskGroup* group = new TaskGroup();
394 uint64_t groupId = reinterpret_cast<uint64_t>(group);
395 Task* task = new Task();
396 uint32_t taskId = TaskManager::GetInstance().CalculateTaskId(reinterpret_cast<uint64_t>(task));
397 napi_value value = NapiHelper::CreateUint64(env, groupId);
398 napi_ref reference = NapiHelper::CreateReference(env, value, 0);
399 taskGroupManager.AddTask(groupId, reference, taskId);
400 ASSERT_NE(reference, nullptr);
401 delete task;
402 delete group;
403 }
404
405 HWTEST_F(NativeEngineTest, TaskpoolTest023, testing::ext::TestSize.Level0)
406 {
407 TaskGroupManager &taskGroupManager = TaskGroupManager::GetInstance();
408 TaskGroup* group = new TaskGroup();
409 uint64_t groupId = reinterpret_cast<uint64_t>(group);
410 TaskGroup* taskGroup = taskGroupManager.GetTaskGroup(groupId);
411 ASSERT_TRUE(taskGroup == nullptr);
412 }
413
414 HWTEST_F(NativeEngineTest, TaskpoolTest024, testing::ext::TestSize.Level0)
415 {
416 MessageQueue<int*> mesQueue;
417 int testData = 42;
418 mesQueue.EnQueue(&testData);
419
420 auto result = mesQueue.DeQueue();
421 ASSERT_EQ(testData, *result);
422 }
423
424 HWTEST_F(NativeEngineTest, TaskpoolTest025, testing::ext::TestSize.Level0)
425 {
426 MessageQueue<std::string> mesQueue;
427 ASSERT_EQ(mesQueue.IsEmpty(), true);
428
429 std::string testStr = "hello";
430 mesQueue.EnQueue(testStr);
431 ASSERT_EQ(mesQueue.IsEmpty(), false);
432 }
433
434 HWTEST_F(NativeEngineTest, TaskpoolTest026, testing::ext::TestSize.Level0)
435 {
436 napi_env env = (napi_env)engine_;
437 ExceptionScope scope(env);
438 napi_value argv[] = {nullptr};
439 std::string funcName = "SeqRunnerConstructor";
440 napi_value cb = nullptr;
441 napi_value result = nullptr;
442 napi_create_function(env, funcName.c_str(), funcName.size(), SequenceRunner::SeqRunnerConstructor, nullptr, &cb);
443 napi_call_function(env, nullptr, cb, 0, argv, &result);
444 ASSERT_NE(result, nullptr);
445 }
446
447 HWTEST_F(NativeEngineTest, TaskpoolTest027, testing::ext::TestSize.Level0)
448 {
449 napi_env env = (napi_env)engine_;
450 ExceptionScope scope(env);
451 napi_value argv[] = {nullptr};
452 std::string func = "SeqRunnerConstructor";
453 napi_value callback = nullptr;
454 napi_value result = nullptr;
455 napi_create_function(env, func.c_str(), func.size(), SequenceRunner::SeqRunnerConstructor, nullptr, &callback);
456 napi_call_function(env, nullptr, callback, 0, argv, &result);
457 ASSERT_NE(result, nullptr);
458
459 size_t argc1 = 0;
460 napi_value argv1[] = {nullptr};
461 func = "Execute";
462 callback = nullptr;
463 napi_value result1 = nullptr;
464 napi_create_function(env, func.c_str(), func.size(), SequenceRunner::Execute, nullptr, &callback);
465 napi_call_function(env, nullptr, callback, argc1, argv1, &result1);
466 ASSERT_TRUE(result1 == nullptr);
467 }
468
469 HWTEST_F(NativeEngineTest, TaskpoolTest028, testing::ext::TestSize.Level0)
470 {
471 TaskGroup taskGroup;
472 uint32_t taskId = 10;
473 uint32_t index = taskGroup.GetTaskIndex(taskId);
474 ASSERT_EQ(index, 0);
475 }
476
477 HWTEST_F(NativeEngineTest, TaskpoolTest029, testing::ext::TestSize.Level0)
478 {
479 napi_env env = (napi_env)engine_;
480 TaskGroup taskGroup;
481 taskGroup.NotifyGroupTask(env);
482 TaskManager &taskManager = TaskManager::GetInstance();
483 uint32_t taskId = 11;
484 ASSERT_EQ(taskId, 11);
485 }
486
487 HWTEST_F(NativeEngineTest, TaskpoolTest030, testing::ext::TestSize.Level0)
488 {
489 napi_env env = (napi_env)engine_;
490 TaskGroup taskGroup;
491 taskGroup.CancelPendingGroup(env);
492 TaskManager &taskManager = TaskManager::GetInstance();
493 uint32_t taskId = 12;
494 ASSERT_EQ(taskId, 12);
495 }
496
497 HWTEST_F(NativeEngineTest, TaskpoolTest031, testing::ext::TestSize.Level0)
498 {
499 napi_env env = reinterpret_cast<napi_env>(engine_);
500 TaskManager& taskManager = TaskManager::GetInstance();
501 Task* task = new Task();
502 taskManager.StoreTask(task);
503 Task* res = taskManager.GetTask(task->taskId_);
504 ASSERT_EQ(task, res);
505 }
506
507 HWTEST_F(NativeEngineTest, TaskpoolTest032, testing::ext::TestSize.Level0)
508 {
509 napi_env env = reinterpret_cast<napi_env>(engine_);
510 TaskManager& taskManager = TaskManager::GetInstance();
511 uint32_t taskId = 14;
512 taskManager.RemoveTask(taskId);
513 ASSERT_EQ(taskId, 14);
514 }
515
516 HWTEST_F(NativeEngineTest, TaskpoolTest033, testing::ext::TestSize.Level0)
517 {
518 napi_env env = reinterpret_cast<napi_env>(engine_);
519 TaskManager& taskManager = TaskManager::GetInstance();
520 usleep(50000);
521 ResetTaskManager();
522 // the task will freed in the taskManager's Destuctor and will not cause memory leak
523 Task* task = new Task();
524 auto taskId = TaskManager::GetInstance().CalculateTaskId(reinterpret_cast<uint64_t>(task));
525 taskManager.EnqueueTaskId(taskId, Priority::HIGH);
526 std::pair<uint32_t, Priority> result = taskManager.DequeueTaskId();
527 ASSERT_TRUE(result.first == taskId);
528 ASSERT_TRUE(result.second == Priority::HIGH);
529 }
530
531 HWTEST_F(NativeEngineTest, TaskpoolTest034, testing::ext::TestSize.Level0)
532 {
533 napi_env env = reinterpret_cast<napi_env>(engine_);
534 Worker* worker = reinterpret_cast<Worker*>(NativeEngineTest::WorkerConstructor(env));
535 TaskManager& taskManager = TaskManager::GetInstance();
536 taskManager.NotifyWorkerIdle(worker);
537 ASSERT_NE(worker, nullptr);
538 taskManager.NotifyWorkerCreated(worker);
539 ASSERT_NE(worker, nullptr);
540 taskManager.NotifyWorkerRunning(worker);
541 ASSERT_NE(worker, nullptr);
542 taskManager.RestoreWorker(worker);
543 ASSERT_NE(worker, nullptr);
544 taskManager.RemoveWorker(worker);
545 ASSERT_NE(worker, nullptr);
546 }
547
548 HWTEST_F(NativeEngineTest, TaskpoolTest035, testing::ext::TestSize.Level0)
549 {
550 napi_env env = reinterpret_cast<napi_env>(engine_);
551 TaskManager& taskManager = TaskManager::GetInstance();
552 uint32_t step = 8;
553 taskManager.GetIdleWorkersList(step);
554 ASSERT_EQ(step, 8);
555 }
556
557 HWTEST_F(NativeEngineTest, TaskpoolTest036, testing::ext::TestSize.Level0)
558 {
559 napi_env env = reinterpret_cast<napi_env>(engine_);
560 TaskManager& taskManager = TaskManager::GetInstance();
561 napi_value res = taskManager.GetThreadInfos(env);
562 ASSERT_NE(res, nullptr);
563 }
564
565 HWTEST_F(NativeEngineTest, TaskpoolTest037, testing::ext::TestSize.Level0)
566 {
567 napi_env env = reinterpret_cast<napi_env>(engine_);
568 TaskManager& taskManager = TaskManager::GetInstance();
569 uint32_t taskId = 16;
570 std::shared_ptr<CallbackInfo> res = taskManager.GetCallbackInfo(taskId);
571 ASSERT_EQ(res, nullptr);
572 }
573
574 HWTEST_F(NativeEngineTest, TaskpoolTest038, testing::ext::TestSize.Level0)
575 {
576 napi_env env = reinterpret_cast<napi_env>(engine_);
577 TaskManager& taskManager = TaskManager::GetInstance();
578 uint32_t taskId = 16;
579 taskManager.RegisterCallback(env, taskId, nullptr);
580 ASSERT_EQ(taskId, 16);
581 }
582
583 HWTEST_F(NativeEngineTest, TaskpoolTest039, testing::ext::TestSize.Level0)
584 {
585 napi_env env = reinterpret_cast<napi_env>(engine_);
586 TaskManager& taskManager = TaskManager::GetInstance();
587 uint32_t taskId = 17;
588 taskManager.IncreaseRefCount(taskId);
589 ASSERT_EQ(taskId, 17);
590 }
591
592 HWTEST_F(NativeEngineTest, TaskpoolTest040, testing::ext::TestSize.Level0)
593 {
594 napi_env env = reinterpret_cast<napi_env>(engine_);
595 TaskManager& taskManager = TaskManager::GetInstance();
596 uint32_t taskId = 18;
597 taskManager.DecreaseRefCount(env, taskId);
598 ASSERT_EQ(taskId, 18);
599 }
600
601 HWTEST_F(NativeEngineTest, TaskpoolTest041, testing::ext::TestSize.Level0)
602 {
603 napi_env env = reinterpret_cast<napi_env>(engine_);
604 TaskManager& taskManager = TaskManager::GetInstance();
605 uint32_t taskId = 19;
606 bool res = taskManager.IsDependendByTaskId(taskId);
607 ASSERT_EQ(res, false);
608 }
609
610 HWTEST_F(NativeEngineTest, TaskpoolTest042, testing::ext::TestSize.Level0)
611 {
612 napi_env env = reinterpret_cast<napi_env>(engine_);
613 TaskManager& taskManager = TaskManager::GetInstance();
614 uint32_t taskId = 20;
615 taskManager.NotifyDependencyTaskInfo(taskId);
616 ASSERT_EQ(taskId, 20);
617 }
618
619 HWTEST_F(NativeEngineTest, TaskpoolTest043, testing::ext::TestSize.Level0)
620 {
621 napi_env env = reinterpret_cast<napi_env>(engine_);
622 TaskManager& taskManager = TaskManager::GetInstance();
623 uint32_t taskId = 21;
624 std::set<uint32_t> taskSet;
625 taskSet.emplace(1);
626 taskSet.emplace(2);
627 bool res = taskManager.StoreTaskDependency(taskId, taskSet);
628 ASSERT_EQ(res, true);
629 }
630
631 HWTEST_F(NativeEngineTest, TaskpoolTest044, testing::ext::TestSize.Level0)
632 {
633 napi_env env = reinterpret_cast<napi_env>(engine_);
634 TaskManager& taskManager = TaskManager::GetInstance();
635 uint32_t taskId = 22;
636 uint32_t dependentId = 0;
637 bool res = taskManager.RemoveTaskDependency(taskId, dependentId);
638 ASSERT_EQ(res, false);
639 }
640
641 HWTEST_F(NativeEngineTest, TaskpoolTest045, testing::ext::TestSize.Level0)
642 {
643 napi_env env = reinterpret_cast<napi_env>(engine_);
644 TaskManager& taskManager = TaskManager::GetInstance();
645 uint32_t taskId = 23;
646 std::set<uint32_t> dependentIdSet;
647 dependentIdSet.emplace(1);
648 std::set<uint32_t> idSet;
649 idSet.emplace(2);
650 bool res = taskManager.CheckCircularDependency(dependentIdSet, idSet, taskId);
651 ASSERT_EQ(res, true);
652 }
653
654 HWTEST_F(NativeEngineTest, TaskpoolTest046, testing::ext::TestSize.Level0)
655 {
656 napi_env env = reinterpret_cast<napi_env>(engine_);
657 TaskManager& taskManager = TaskManager::GetInstance();
658 uint32_t taskId = 24;
659 taskManager.EnqueuePendingTaskInfo(taskId, Priority::NUMBER);
660 std::pair<uint32_t, Priority> res = taskManager.DequeuePendingTaskInfo(taskId);
661 ASSERT_EQ(res.first, 24);
662 ASSERT_EQ(res.second, Priority::NUMBER);
663 }
664
665 HWTEST_F(NativeEngineTest, TaskpoolTest047, testing::ext::TestSize.Level0)
666 {
667 napi_env env = reinterpret_cast<napi_env>(engine_);
668 TaskManager& taskManager = TaskManager::GetInstance();
669 uint32_t taskId = 24;
670 taskManager.RemovePendingTaskInfo(taskId);
671 ASSERT_EQ(taskId, 24);
672 }
673
674 HWTEST_F(NativeEngineTest, TaskpoolTest048, testing::ext::TestSize.Level0)
675 {
676 napi_env env = reinterpret_cast<napi_env>(engine_);
677 TaskManager& taskManager = TaskManager::GetInstance();
678 uint32_t taskId = 25;
679 std::set<uint32_t> dependTaskIdSet;
680 taskManager.StoreDependentTaskInfo(dependTaskIdSet, taskId);
681 ASSERT_EQ(taskId, 25);
682 }
683
684 HWTEST_F(NativeEngineTest, TaskpoolTest049, testing::ext::TestSize.Level0)
685 {
686 napi_env env = reinterpret_cast<napi_env>(engine_);
687 TaskManager& taskManager = TaskManager::GetInstance();
688 uint32_t taskId = 26;
689 uint32_t dependentTaskId = 26;
690 taskManager.RemoveDependentTaskInfo(dependentTaskId, taskId);
691 ASSERT_EQ(taskId, 26);
692 ASSERT_EQ(dependentTaskId, 26);
693 }
694
695 HWTEST_F(NativeEngineTest, TaskpoolTest050, testing::ext::TestSize.Level0)
696 {
697 napi_env env = reinterpret_cast<napi_env>(engine_);
698 TaskManager& taskManager = TaskManager::GetInstance();
699 uint32_t taskId = 27;
700 uint64_t totalDuration = 25;
701 uint64_t cpuDuration = 8;
702 taskManager.StoreTaskDuration(taskId, totalDuration, cpuDuration);
703 ASSERT_EQ(taskId, 27);
704 ASSERT_EQ(totalDuration, 25);
705 ASSERT_EQ(cpuDuration, 8);
706 }
707
708 HWTEST_F(NativeEngineTest, TaskpoolTest051, testing::ext::TestSize.Level0)
709 {
710 napi_env env = reinterpret_cast<napi_env>(engine_);
711 TaskManager& taskManager = TaskManager::GetInstance();
712 uint32_t taskId = 28;
713 std::string str = "testTaskpool";
714 taskManager.GetTaskDuration(taskId, str);
715 ASSERT_EQ(taskId, 28);
716 }
717
718 HWTEST_F(NativeEngineTest, TaskpoolTest052, testing::ext::TestSize.Level0)
719 {
720 napi_env env = reinterpret_cast<napi_env>(engine_);
721 TaskManager& taskManager = TaskManager::GetInstance();
722 uint32_t taskId = 29;
723 taskManager.RemoveTaskDuration(taskId);
724 ASSERT_EQ(taskId, 29);
725 }
726
727 HWTEST_F(NativeEngineTest, TaskpoolTest053, testing::ext::TestSize.Level0)
728 {
729 TaskGroupManager& taskGroupManager = TaskGroupManager::GetInstance();
730 uint64_t groupId = 30;
731 TaskGroup* group = taskGroupManager.GetTaskGroup(groupId);
732 taskGroupManager.StoreTaskGroup(groupId, group);
733 ASSERT_EQ(groupId, 30);
734 }
735
736 HWTEST_F(NativeEngineTest, TaskpoolTest054, testing::ext::TestSize.Level0)
737 {
738 TaskGroupManager& taskGroupManager = TaskGroupManager::GetInstance();
739 uint64_t groupId = 31;
740 taskGroupManager.RemoveTaskGroup(groupId);
741 ASSERT_EQ(groupId, 31);
742 }
743
744 HWTEST_F(NativeEngineTest, TaskpoolTest055, testing::ext::TestSize.Level0)
745 {
746 napi_env env = reinterpret_cast<napi_env>(engine_);
747 TaskGroupManager& taskGroupManager = TaskGroupManager::GetInstance();
748 uint64_t groupId = 32;
749 taskGroupManager.CancelGroup(env, groupId);
750 ASSERT_EQ(groupId, 32);
751 }
752
753 HWTEST_F(NativeEngineTest, TaskpoolTest056, testing::ext::TestSize.Level0)
754 {
755 napi_env env = reinterpret_cast<napi_env>(engine_);
756 TaskGroupManager& taskGroupManager = TaskGroupManager::GetInstance();
757 uint32_t taskId = 33;
758 TaskGroup* group = taskGroupManager.GetTaskGroup(taskId);
759 taskGroupManager.CancelGroupTask(env, taskId, group);
760 ASSERT_EQ(taskId, 33);
761 }
762
763 HWTEST_F(NativeEngineTest, TaskpoolTest057, testing::ext::TestSize.Level0)
764 {
765 TaskGroupManager& taskGroupManager = TaskGroupManager::GetInstance();
766 uint64_t groupId = 34;
767 taskGroupManager.UpdateGroupState(groupId);
768 ASSERT_EQ(groupId, 34);
769 }
770
771 HWTEST_F(NativeEngineTest, TaskpoolTest058, testing::ext::TestSize.Level0)
772 {
773 napi_env env = reinterpret_cast<napi_env>(engine_);
774 TaskGroupManager& taskGroupManager = TaskGroupManager::GetInstance();
775 SequenceRunnerManager& sequenceRunnerManager = SequenceRunnerManager::GetInstance();
776 uint64_t seqRunnerId = 35;
777 Task* task = new Task();
778 ASSERT_NE(task, nullptr);
779 sequenceRunnerManager.AddTaskToSeqRunner(seqRunnerId, task);
780 sequenceRunnerManager.TriggerSeqRunner(env, task);
781 SequenceRunner sequenceRunner;
782 sequenceRunnerManager.StoreSequenceRunner(seqRunnerId, &sequenceRunner);
783 NativeEngineTest::RemoveSequenceRunner(seqRunnerId);
784 ASSERT_EQ(seqRunnerId, 35);
785 SequenceRunner* res = sequenceRunnerManager.GetSeqRunner(seqRunnerId);
786 ASSERT_EQ(res, nullptr);
787 }
788
789 HWTEST_F(NativeEngineTest, TaskpoolTest059, testing::ext::TestSize.Level0)
790 {
791 napi_env env = reinterpret_cast<napi_env>(engine_);
792 TaskManager& taskManager = TaskManager::GetInstance();
793 taskManager.InitTaskManager(env);
794 taskManager.TryTriggerExpand();
795 usleep(50000);
796 NativeEngineTest::TriggerShrink(env);
797 napi_value exception = nullptr;
798 napi_get_and_clear_last_exception(env, &exception);
799 ASSERT_TRUE(exception == nullptr);
800 }
801
802 HWTEST_F(NativeEngineTest, TaskpoolTest060, testing::ext::TestSize.Level0)
803 {
804 napi_env env = reinterpret_cast<napi_env>(engine_);
805 TaskManager& taskManager = TaskManager::GetInstance();
806 ResetTaskManager();
807 uint32_t taskId = 36;
808 taskManager.EnqueueTaskId(taskId, Priority::LOW);
809 ASSERT_EQ(taskId, 36);
810
811 std::pair<uint32_t, Priority> result = taskManager.DequeueTaskId();
812 ASSERT_TRUE(result.first == 36);
813 ASSERT_TRUE(result.second == Priority::LOW);
814
815 taskId = 37;
816 taskManager.EnqueueTaskId(taskId, Priority::IDLE);
817 ASSERT_EQ(taskId, 37);
818
819 result = taskManager.DequeueTaskId();
820 ASSERT_TRUE(result.first == 37);
821 ASSERT_TRUE(result.second == Priority::IDLE);
822 result = taskManager.DequeueTaskId();
823 ASSERT_TRUE(result.first == 0);
824 ASSERT_TRUE(result.second == Priority::LOW);
825 }
826
827 HWTEST_F(NativeEngineTest, TaskpoolTest061, testing::ext::TestSize.Level0)
828 {
829 napi_env env = (napi_env)engine_;
830 ExceptionScope scope(env);
831 napi_value argv[] = {nullptr, nullptr};
832 std::string funcName = "TaskGroupConstructor";
833 napi_value cb = nullptr;
834 napi_value result = nullptr;
835 napi_create_function(env, funcName.c_str(), funcName.size(), TaskGroup::TaskGroupConstructor, nullptr, &cb);
836
837 napi_call_function(env, nullptr, cb, 2, argv, &result);
838 ASSERT_TRUE(result == nullptr);
839 }
840
841 HWTEST_F(NativeEngineTest, TaskpoolTest062, testing::ext::TestSize.Level0)
842 {
843 napi_env env = (napi_env)engine_;
844 ExceptionScope scope(env);
845 napi_value argv[] = {nullptr};
846 std::string funcName = "TaskGroupConstructor";
847 napi_value cb = nullptr;
848 napi_value result = nullptr;
849 napi_create_function(env, funcName.c_str(), funcName.size(), TaskGroup::TaskGroupConstructor, nullptr, &cb);
850
851 napi_call_function(env, nullptr, cb, 1, argv, &result);
852 ASSERT_TRUE(result == nullptr);
853 }
854
855 HWTEST_F(NativeEngineTest, TaskpoolTest063, testing::ext::TestSize.Level0)
856 {
857 napi_env env = (napi_env)engine_;
858 TaskGroup taskGroup;
859 uint32_t taskId = 10;
860 taskGroup.taskIds_.push_back(taskId);
861 uint32_t index = taskGroup.GetTaskIndex(taskId);
862 ASSERT_EQ(index, 0);
863 }
864
865 HWTEST_F(NativeEngineTest, TaskpoolTest064, testing::ext::TestSize.Level0)
866 {
867 napi_env env = (napi_env)engine_;
868 TaskGroup taskGroup;
869 uint32_t taskId = 11;
870 taskGroup.taskIds_.push_back(taskId);
871 uint32_t index = taskGroup.GetTaskIndex(1);
872 ASSERT_EQ(index, 1);
873 }
874
875 HWTEST_F(NativeEngineTest, TaskpoolTest065, testing::ext::TestSize.Level0)
876 {
877 napi_env env = (napi_env)engine_;
878 TaskGroup taskGroup;
879 GroupInfo* groupInfo = new GroupInfo();
880 taskGroup.pendingGroupInfos_.push_back(groupInfo);
881 taskGroup.NotifyGroupTask(env);
882 delete groupInfo;
883 groupInfo = nullptr;
884 ASSERT_TRUE(taskGroup.pendingGroupInfos_.empty());
885 }
886
887 HWTEST_F(NativeEngineTest, TaskpoolTest066, testing::ext::TestSize.Level0)
888 {
889 napi_env env = (napi_env)engine_;
890 TaskGroupManager& taskGroupManager = TaskGroupManager::GetInstance();
891 TaskGroup* taskGroup = new TaskGroup();
892 uint64_t groupId = reinterpret_cast<uint64_t>(taskGroup);
893 taskGroup->groupId_ = groupId;
894 taskGroupManager.StoreTaskGroup(groupId, taskGroup);
895
896 GroupInfo* groupInfo = new GroupInfo();
897 groupInfo->priority = Priority::DEFAULT;
898 taskGroup->pendingGroupInfos_.push_back(groupInfo);
899 taskGroup->NotifyGroupTask(env);
900 ASSERT_TRUE(taskGroup->pendingGroupInfos_.empty());
901 }
902
903 HWTEST_F(NativeEngineTest, TaskpoolTest067, testing::ext::TestSize.Level0)
904 {
905 napi_env env = (napi_env)engine_;
906 TaskGroupManager& taskGroupManager = TaskGroupManager::GetInstance();
907 TaskGroup* taskGroup = new TaskGroup();
908 uint64_t groupId = reinterpret_cast<uint64_t>(taskGroup);
909 taskGroup->groupId_ = groupId;
910 taskGroupManager.StoreTaskGroup(groupId, taskGroup);
911
912 Task* task = new Task();
913 task->taskType_ = TaskType::COMMON_TASK;
914 task->groupId_ = groupId;
915 task->taskId_ = TaskManager::GetInstance().CalculateTaskId(reinterpret_cast<uint64_t>(task));
916 napi_reference_ref(env, task->taskRef_, nullptr);
917 napi_value thisValue = NapiHelper::CreateObject(env);
918 napi_wrap(
919 env, thisValue, task,
__anon57f9c37c0302(napi_env environment, void* data, void* hint) 920 [](napi_env environment, void* data, void* hint) {
921 auto obj = reinterpret_cast<Task*>(data);
922 if (obj != nullptr) {
923 delete obj;
924 }
925 }, nullptr, nullptr);
926 napi_ref ref = NapiHelper::CreateReference(env, thisValue, 1);
927 taskGroupManager.AddTask(groupId, ref, task->taskId_);
928
929 GroupInfo* groupInfo = new GroupInfo();
930 groupInfo->priority = Priority::DEFAULT;
931 taskGroup->pendingGroupInfos_.push_back(groupInfo);
932 taskGroup->NotifyGroupTask(env);
933 ASSERT_TRUE(taskGroup->pendingGroupInfos_.empty());
934 }
935
936 HWTEST_F(NativeEngineTest, TaskpoolTest068, testing::ext::TestSize.Level0)
937 {
938 napi_env env = (napi_env)engine_;
939 TaskGroupManager& taskGroupManager = TaskGroupManager::GetInstance();
940 TaskGroup taskGroup;
941
942 GroupInfo* groupInfo = new GroupInfo();
943 groupInfo->priority = Priority::DEFAULT;
944 taskGroup.pendingGroupInfos_.push_back(groupInfo);
945 uint32_t taskId = 68;
946 taskGroup.taskIds_.push_back(taskId);
947 taskGroup.CancelPendingGroup(env);
948
949 ASSERT_TRUE(taskGroup.pendingGroupInfos_.empty());
950 }
951
952 HWTEST_F(NativeEngineTest, TaskpoolTest069, testing::ext::TestSize.Level0)
953 {
954 napi_env env = (napi_env)engine_;
955 TaskManager& taskManager = TaskManager::GetInstance();
956 Task* pointer = new Task();
957 auto task = TaskManager::GetInstance().CalculateTaskId(reinterpret_cast<uint64_t>(pointer));
958 auto worker = reinterpret_cast<Worker*>(NativeEngineTest::WorkerConstructor(env));
959 taskManager.StoreLongTaskInfo(task, worker);
960 auto res = taskManager.GetLongTaskInfo(task);
961 ASSERT_TRUE(worker == res);
962 taskManager.TerminateTask(task);
963 res = taskManager.GetLongTaskInfo(task);
964 ASSERT_TRUE(res == nullptr);
965 }
966
967 HWTEST_F(NativeEngineTest, TaskpoolTest070, testing::ext::TestSize.Level0)
968 {
969 napi_env env = (napi_env)engine_;
970 TaskManager& taskManager = TaskManager::GetInstance();
971 ResetTaskManager();
972 auto worker = Worker::WorkerConstructor(env);
973 usleep(50000);
974 taskManager.NotifyWorkerCreated(worker);
975 Task* task = new Task();
976 task->isLongTask_ = true;
977 taskManager.StoreTask(task);
978 uint32_t id = task->taskId_;
979 taskManager.EnqueueTaskId(id);
980 usleep(50000);
981 auto res = taskManager.GetLongTaskInfo(id);
982 ASSERT_NE(res, nullptr);
983 ResetTaskManager();
984 }
985
986 HWTEST_F(NativeEngineTest, TaskpoolTest071, testing::ext::TestSize.Level0)
987 {
988 napi_env env = (napi_env)engine_;
989 TaskManager& taskManager = TaskManager::GetInstance();
990 char buf[4096]; // 4096: buffer length for thread state
991 auto worker = reinterpret_cast<Worker*>(NativeEngineTest::WorkerConstructor(env));
992 uv_timer_t* handle = new uv_timer_t;
993 handle->data = worker;
994 auto tid = NativeEngineTest::GetWorkerTid(handle);
995 bool res = taskManager.ReadThreadInfo(tid, buf, sizeof(buf));
996 ASSERT_TRUE(res == true);
997 }
998
999 HWTEST_F(NativeEngineTest, TaskpoolTest072, testing::ext::TestSize.Level0)
1000 {
1001 napi_env env = (napi_env)engine_;
1002 TaskManager& taskManager = TaskManager::GetInstance();
1003 Task* task = new Task();
1004 auto id = TaskManager::GetInstance().CalculateTaskId(reinterpret_cast<uint64_t>(task));
1005 bool res = taskManager.IsDependendByTaskId(id);
1006 ASSERT_NE(res, true);
1007 }
1008
1009 HWTEST_F(NativeEngineTest, TaskpoolTest073, testing::ext::TestSize.Level0)
1010 {
1011 napi_env env = (napi_env)engine_;
1012 TaskManager& taskManager = TaskManager::GetInstance();
1013 Task* task = new Task();
1014 taskManager.StoreTask(task);
1015 bool res = taskManager.CheckTask(task->taskId_);
1016 ASSERT_TRUE(res == true);
1017 }
1018
1019 HWTEST_F(NativeEngineTest, TaskpoolTest074, testing::ext::TestSize.Level0)
1020 {
1021 napi_env env = (napi_env)engine_;
1022 TaskManager& taskManager = TaskManager::GetInstance();
1023 auto res = taskManager.GetThreadInfos(env);
1024 ASSERT_TRUE(res != nullptr);
1025 }
1026
1027 HWTEST_F(NativeEngineTest, TaskpoolTest075, testing::ext::TestSize.Level0)
1028 {
1029 napi_env env = (napi_env)engine_;
1030 TaskManager& taskManager = TaskManager::GetInstance();
1031 auto res = taskManager.GetTaskInfos(env);
1032 ASSERT_TRUE(res != nullptr);
1033 }
1034
1035 HWTEST_F(NativeEngineTest, TaskpoolTest076, testing::ext::TestSize.Level0)
1036 {
1037 napi_env env = (napi_env)engine_;
1038 TaskManager& taskManager = TaskManager::GetInstance();
1039 Task* task = new Task();
1040 auto id = TaskManager::GetInstance().CalculateTaskId(reinterpret_cast<uint64_t>(task));
1041 taskManager.StoreTaskDuration(id, 0, 0);
1042 auto totalTime = taskManager.GetTaskDuration(id, TASK_TOTAL_TIME);
1043 auto cpuTime = taskManager.GetTaskDuration(id, TASK_CPU_TIME);
1044 ASSERT_TRUE(totalTime == 0);
1045 ASSERT_TRUE(cpuTime == 0);
1046 taskManager.StoreTaskDuration(id, 100, 100); // 100: 100 seconds
1047 totalTime = taskManager.GetTaskDuration(id, TASK_TOTAL_TIME);
1048 cpuTime = taskManager.GetTaskDuration(id, TASK_CPU_TIME);
1049 ASSERT_TRUE(totalTime == 100);
1050 ASSERT_TRUE(cpuTime == 100);
1051 }
1052
1053 HWTEST_F(NativeEngineTest, TaskpoolTest077, testing::ext::TestSize.Level0)
1054 {
1055 napi_env env = (napi_env)engine_;
1056 TaskManager& taskManager = TaskManager::GetInstance();
1057 Task* task = new Task(env, TaskType::COMMON_TASK, "test");
1058 taskManager.StoreTask(task);
1059 auto res = task->name_;
1060 ASSERT_TRUE(strcmp(res.c_str(), "test") == 0);
1061 }
1062
1063 HWTEST_F(NativeEngineTest, TaskpoolTest078, testing::ext::TestSize.Level0)
1064 {
1065 napi_env env = (napi_env)engine_;
1066 ExceptionScope scope(env);
1067 napi_value argv[] = {};
1068 napi_value result = NativeEngineTest::IsConcurrent(env, argv, 0);
1069 ASSERT_TRUE(result == nullptr);
1070 }
1071
1072 HWTEST_F(NativeEngineTest, TaskpoolTest079, testing::ext::TestSize.Level0)
1073 {
1074 napi_env env = (napi_env)engine_;
1075 ExceptionScope scope(env);
1076 napi_value argv[] = { nullptr };
1077 napi_value result = NativeEngineTest::IsConcurrent(env, argv, 1);
1078 ASSERT_TRUE(result == nullptr);
1079 }
1080
1081 HWTEST_F(NativeEngineTest, TaskpoolTest080, testing::ext::TestSize.Level0)
1082 {
1083 napi_env env = (napi_env)engine_;
1084 ExceptionScope scope(env);
1085 napi_value argv[] = { nullptr, nullptr };
1086 napi_value result = NativeEngineTest::IsConcurrent(env, argv, 2);
1087 ASSERT_TRUE(result == nullptr);
1088 }
1089
1090 HWTEST_F(NativeEngineTest, TaskpoolTest081, testing::ext::TestSize.Level0)
1091 {
1092 napi_env env = (napi_env)engine_;
1093 ExceptionScope scope(env);
1094 napi_value func = nullptr;
1095 GetSendableFunction(env, "foo", func);
1096 napi_value argv[] = { func };
1097 napi_value result = NativeEngineTest::IsConcurrent(env, argv, 1);
1098 bool res = true;
1099 napi_get_value_bool(env, result, &res);
1100 ASSERT_TRUE(res == false);
1101 }
1102
1103 HWTEST_F(NativeEngineTest, TaskpoolTest082, testing::ext::TestSize.Level0)
1104 {
1105 napi_env env = (napi_env)engine_;
1106 ExceptionScope scope(env);
1107 napi_value argv[] = { nullptr };
1108 napi_value result = NativeEngineTest::GetTaskPoolInfo(env, argv, 1);
1109 ASSERT_TRUE(result != nullptr);
1110 }
1111
1112 HWTEST_F(NativeEngineTest, TaskpoolTest083, testing::ext::TestSize.Level0)
1113 {
1114 napi_env env = (napi_env)engine_;
1115 ExceptionScope scope(env);
1116 napi_value argv[] = { nullptr };
1117 napi_value result = NativeEngineTest::TerminateTask(env, argv, 1);
1118 ASSERT_TRUE(result == nullptr);
1119 }
1120
1121 HWTEST_F(NativeEngineTest, TaskpoolTest084, testing::ext::TestSize.Level0)
1122 {
1123 napi_env env = (napi_env)engine_;
1124 ExceptionScope scope(env);
1125 napi_value func = nullptr;
1126 GetSendableFunction(env, "foo", func);
1127 napi_value argv[] = { func };
1128 napi_value result = NativeEngineTest::Execute(env, argv, 1);
1129 ASSERT_TRUE(result != nullptr);
1130 }
1131
1132 HWTEST_F(NativeEngineTest, TaskpoolTest085, testing::ext::TestSize.Level0)
1133 {
1134 napi_env env = (napi_env)engine_;
1135 ExceptionScope scope(env);
1136 napi_value func = nullptr;
1137 GetSendableFunction(env, "foo", func);
1138
1139 size_t delay = 1000;
1140 napi_value result = nullptr;
1141 napi_create_uint32(env, delay, &result);
1142
1143 napi_value argv[] = { result, func };
1144 std::string funcName = "ExecuteDelayed";
1145 result = NativeEngineTest::ExecuteDelayed(env, argv, 2);
1146 ASSERT_TRUE(result == nullptr);
1147 }
1148
1149 HWTEST_F(NativeEngineTest, TaskpoolTest086, testing::ext::TestSize.Level0)
1150 {
1151 napi_env env = (napi_env)engine_;
1152 ExceptionScope scope(env);
1153 std::string func = "SeqRunnerConstructor";
1154 napi_value callback = nullptr;
1155 napi_value result = nullptr;
1156 napi_create_function(env, func.c_str(), func.size(), SequenceRunner::SeqRunnerConstructor, nullptr, &callback);
1157
1158 napi_value argv1[] = {nullptr};
1159 napi_create_uint32(env, 1, &argv1[0]);
1160 napi_call_function(env, nullptr, callback, 1, argv1, &result);
1161 ASSERT_NE(result, nullptr);
1162
1163 napi_value argv2[2] = {nullptr};
1164 napi_create_uint32(env, 1, &argv2[0]);
1165 napi_create_string_utf8(env, "seq01", NAPI_AUTO_LENGTH, &argv2[1]);
1166 result = nullptr;
1167 napi_call_function(env, nullptr, callback, 2, argv2, &result);
1168 ASSERT_EQ(result, nullptr);
1169 napi_value exception = nullptr;
1170 napi_get_and_clear_last_exception(env, &exception);
1171
1172 napi_value argv3[2] = {nullptr};
1173 napi_create_string_utf8(env, "seq02", NAPI_AUTO_LENGTH, &argv3[0]);
1174 napi_create_uint32(env, 1, &argv3[1]);
1175 result = nullptr;
1176 napi_call_function(env, nullptr, callback, 2, argv3, &result);
1177 ASSERT_NE(result, nullptr);
1178 }
1179
1180 HWTEST_F(NativeEngineTest, TaskpoolTest087, testing::ext::TestSize.Level0)
1181 {
1182 napi_env env = (napi_env)engine_;
1183 ExceptionScope scope(env);
1184 std::string func = "SeqRunnerConstructor";
1185 napi_value callback = nullptr;
1186 napi_create_function(env, func.c_str(), func.size(), SequenceRunner::SeqRunnerConstructor, nullptr, &callback);
1187
1188 napi_value argv[2] = {nullptr};
1189 napi_create_string_utf8(env, "seq03", NAPI_AUTO_LENGTH, &argv[0]);
1190 napi_create_uint32(env, 1, &argv[1]);
1191 napi_value result = nullptr;
1192 napi_call_function(env, nullptr, callback, 2, argv, &result);
1193 ASSERT_NE(result, nullptr);
1194
1195 func = "Execute";
1196 napi_value cb = nullptr;
1197 napi_value res = nullptr;
1198 napi_create_function(env, func.c_str(), func.size(), SequenceRunner::Execute, nullptr, &cb);
1199
1200 napi_value argv1[] = {nullptr};
1201 napi_create_uint32(env, 1, &argv1[0]);
1202 napi_call_function(env, nullptr, cb, 1, argv1, &res);
1203 ASSERT_EQ(res, nullptr);
1204 napi_value exception = nullptr;
1205 napi_get_and_clear_last_exception(env, &exception);
1206
1207 napi_value thisValue = CreateTaskObject(env);
1208 napi_value argv2[] = {thisValue};
1209 res = nullptr;
1210 napi_call_function(env, nullptr, cb, 1, argv2, &res);
1211 ASSERT_NE(res, nullptr);
1212 exception = nullptr;
1213 napi_get_and_clear_last_exception(env, &exception);
1214
1215 napi_value napiSeqRunnerId = NapiHelper::GetNameProperty(env, result, "seqRunnerId");
1216 uint64_t seqId = NapiHelper::GetUint64Value(env, napiSeqRunnerId);
1217 SequenceRunner seq;
1218 SequenceRunnerManager::GetInstance().StoreSequenceRunner(seqId, &seq);
1219
1220 res = nullptr;
1221 napi_call_function(env, nullptr, cb, 1, argv2, &res);
1222 ASSERT_NE(res, nullptr);
1223 }
1224
1225 HWTEST_F(NativeEngineTest, TaskpoolTest088, testing::ext::TestSize.Level0)
1226 {
1227 napi_env env = (napi_env)engine_;
1228 ExceptionScope scope(env);
1229 napi_value argv[] = {nullptr};
1230 std::string func = "TaskGroupConstructor";
1231 napi_value callback = nullptr;
1232 napi_value taskGroupResult = nullptr;
1233 napi_create_function(env, func.c_str(), func.size(), TaskGroup::TaskGroupConstructor, nullptr, &callback);
1234 napi_call_function(env, nullptr, callback, 0, argv, &taskGroupResult);
1235
1236 func = "AddTask";
1237 napi_value cb = nullptr;
1238 napi_value result = nullptr;
1239 napi_create_function(env, func.c_str(), func.size(), TaskGroup::AddTask, nullptr, &cb);
1240
1241 napi_value napiGroupId = NapiHelper::GetNameProperty(env, taskGroupResult, "groupId");
1242 uint64_t groupId = NapiHelper::GetUint64Value(env, napiGroupId);
1243
1244 TaskGroupManager& taskGroupManager = TaskGroupManager::GetInstance();
1245 TaskGroup* group = new TaskGroup();
1246 group->groupId_ = groupId;
1247 taskGroupManager.StoreTaskGroup(groupId, group);
1248
1249 napi_value thisValue = CreateTaskObject(env);
1250 napi_value argv1[] = {thisValue};
1251 napi_call_function(env, nullptr, cb, 1, argv1, &result);
1252 ASSERT_NE(result, nullptr);
1253
1254 napi_value thisValue2 = CreateTaskObject(env, TaskType::SEQRUNNER_TASK);
1255 napi_value argv2[] = {thisValue2};
1256 result = nullptr;
1257 napi_call_function(env, nullptr, cb, 1, argv2, &result);
1258 ASSERT_EQ(result, nullptr);
1259 }
1260
1261 HWTEST_F(NativeEngineTest, TaskpoolTest089, testing::ext::TestSize.Level0)
1262 {
1263 napi_env env = (napi_env)engine_;
1264 ExceptionScope scope(env);
1265 napi_value argv[] = {nullptr};
1266 std::string func = "TaskGroupConstructor";
1267 napi_value callback = nullptr;
1268 napi_value taskGroupResult = nullptr;
1269 napi_create_function(env, func.c_str(), func.size(), TaskGroup::TaskGroupConstructor, nullptr, &callback);
1270 napi_call_function(env, nullptr, callback, 0, argv, &taskGroupResult);
1271
1272 napi_value thisValue = NapiHelper::CreateObject(env);
1273 napi_value argv1[] = {thisValue};
1274 func = "AddTask";
1275 napi_value cb = nullptr;
1276 napi_value result = nullptr;
1277 napi_create_function(env, func.c_str(), func.size(), TaskGroup::AddTask, nullptr, &cb);
1278 napi_call_function(env, nullptr, cb, 1, argv1, &result);
1279 ASSERT_EQ(result, nullptr);
1280 }
1281
1282 HWTEST_F(NativeEngineTest, TaskpoolTest090, testing::ext::TestSize.Level0)
1283 {
1284 napi_env env = (napi_env)engine_;
1285 ExceptionScope scope(env);
1286 napi_value argv[] = {nullptr};
1287 std::string funcName = "TaskGroupConstructor";
1288 napi_value callback = nullptr;
1289 napi_value taskGroupResult = nullptr;
1290 napi_create_function(env, funcName.c_str(), funcName.size(), TaskGroup::TaskGroupConstructor, nullptr, &callback);
1291 napi_call_function(env, nullptr, callback, 0, argv, &taskGroupResult);
1292
__anon57f9c37c0402(napi_env environment, napi_callback_info info) 1293 auto func = [](napi_env environment, napi_callback_info info) -> napi_value {
1294 return nullptr;
1295 };
1296 napi_value thisValue = nullptr;
1297 napi_create_function(env, "testFunc", NAPI_AUTO_LENGTH, func, nullptr, &thisValue);
1298 napi_value argv1[] = {thisValue};
1299 funcName = "AddTask";
1300 napi_value cb = nullptr;
1301 napi_value result = nullptr;
1302 napi_create_function(env, funcName.c_str(), funcName.size(), TaskGroup::AddTask, nullptr, &cb);
1303 napi_call_function(env, nullptr, cb, 1, argv1, &result);
1304 ASSERT_EQ(result, nullptr);
1305 }
1306
1307 HWTEST_F(NativeEngineTest, TaskpoolTest091, testing::ext::TestSize.Level0)
1308 {
1309 napi_env env = (napi_env)engine_;
1310 ExceptionScope scope(env);
1311 napi_value argv[] = {nullptr};
1312 std::string funcName = "TaskGroupConstructor";
1313 napi_value callback = nullptr;
1314 napi_value taskGroupResult = nullptr;
1315 napi_create_function(env, funcName.c_str(), funcName.size(), TaskGroup::TaskGroupConstructor, nullptr, &callback);
1316 napi_call_function(env, nullptr, callback, 0, argv, &taskGroupResult);
1317
1318 napi_value argv1[] = {};
1319 napi_create_uint32(env, 1, &argv1[0]);
1320 funcName = "AddTask";
1321 napi_value cb = nullptr;
1322 napi_value result = nullptr;
1323 napi_create_function(env, funcName.c_str(), funcName.size(), TaskGroup::AddTask, nullptr, &cb);
1324 napi_call_function(env, nullptr, cb, 1, argv1, &result);
1325 ASSERT_EQ(result, nullptr);
1326 }
1327
1328 HWTEST_F(NativeEngineTest, TaskpoolTest092, testing::ext::TestSize.Level0)
1329 {
1330 napi_env env = (napi_env)engine_;
1331 napi_value global = NapiHelper::CreateObject(env);
1332 napi_value argv[2] = {};
1333 std::string funcName = "OnReceiveData";
1334 napi_value cb = nullptr;
1335 napi_value result = nullptr;
1336 napi_create_function(env, funcName.c_str(), funcName.size(), Task::OnReceiveData, nullptr, &cb);
1337 napi_call_function(env, global, cb, 0, argv, &result);
1338 napi_value exception = nullptr;
1339 napi_get_and_clear_last_exception(env, &exception);
1340 ExceptionScope scope(env);
1341 argv[0] = nullptr;
1342 argv[1] = nullptr;
1343 result = nullptr;
1344 napi_create_function(env, funcName.c_str(), funcName.size(), Task::OnReceiveData, nullptr, &cb);
1345 napi_call_function(env, global, cb, 2, argv, &result);
1346 ASSERT_TRUE(result == nullptr);
1347 }
1348
1349 HWTEST_F(NativeEngineTest, TaskpoolTest093, testing::ext::TestSize.Level0)
1350 {
1351 napi_env env = (napi_env)engine_;
1352 napi_value global = NapiHelper::CreateObject(env);
1353 ExceptionScope scope(env);
1354 napi_value func = nullptr;
1355 GetSendableFunction(env, "foo", func);
1356 napi_value argv[] = { func };
1357 std::string funcName = "TaskConstructor";
1358 napi_value cb = nullptr;
1359 napi_value task = nullptr;
1360 napi_create_function(env, funcName.c_str(), funcName.size(), Task::TaskConstructor, nullptr, &cb);
1361 napi_call_function(env, global, cb, 1, argv, &task);
1362 auto& taskManager = TaskManager::GetInstance();
1363 Task* pointer = nullptr;
1364 napi_unwrap(env, task, reinterpret_cast<void**>(&pointer));
1365
1366 funcName = "OnReceiveData";
1367 cb = nullptr;
1368 napi_value result = nullptr;
1369 napi_create_function(env, funcName.c_str(), funcName.size(), Task::OnReceiveData, nullptr, &cb);
1370 napi_call_function(env, global, cb, 1, argv, &result);
1371 auto res = taskManager.GetCallbackInfo(pointer->taskId_);
1372 ASSERT_TRUE(res != nullptr);
1373 }
1374
1375 HWTEST_F(NativeEngineTest, TaskpoolTest094, testing::ext::TestSize.Level0)
1376 {
1377 napi_env env = (napi_env)engine_;
1378 ExceptionScope scope(env);
1379 napi_value argv[] = { nullptr, nullptr };
1380 std::string funcName = "TaskConstructor";
1381 napi_value cb = nullptr;
1382 napi_value result = nullptr;
1383 napi_create_function(env, funcName.c_str(), funcName.size(), Task::TaskConstructor, nullptr, &cb);
1384 napi_call_function(env, nullptr, cb, 2, argv, &result);
1385 ASSERT_TRUE(result == nullptr);
1386 }
1387
1388 HWTEST_F(NativeEngineTest, TaskpoolTest095, testing::ext::TestSize.Level0)
1389 {
1390 napi_env env = (napi_env)engine_;
1391 ExceptionScope scope(env);
1392 const char* str = "Task";
1393 napi_value name = nullptr;
1394 napi_create_string_utf8(env, str, NAPI_AUTO_LENGTH, &name);
1395 napi_value argv[] = { name, nullptr };
1396 std::string funcName = "TaskConstructor";
1397 napi_value cb = nullptr;
1398 napi_value result = nullptr;
1399 napi_create_function(env, funcName.c_str(), funcName.size(), Task::TaskConstructor, nullptr, &cb);
1400 napi_call_function(env, nullptr, cb, 2, argv, &result);
1401 ASSERT_TRUE(result == nullptr);
1402 }
1403
1404 HWTEST_F(NativeEngineTest, TaskpoolTest096, testing::ext::TestSize.Level0)
1405 {
1406 napi_env env = (napi_env)engine_;
1407 napi_value global = NapiHelper::CreateObject(env);
1408 ExceptionScope scope(env);
1409 napi_value func = nullptr;
1410 GetSendableFunction(env, "foo", func);
1411 napi_value argv[] = { func };
1412 std::string funcName = "TaskConstructor";
1413 napi_value cb = nullptr;
1414 napi_value result = nullptr;
1415 napi_create_function(env, funcName.c_str(), funcName.size(), Task::TaskConstructor, nullptr, &cb);
1416 napi_call_function(env, global, cb, 1, argv, &result);
1417 ASSERT_TRUE(result != nullptr);
1418 }
1419
1420 HWTEST_F(NativeEngineTest, TaskpoolTest097, testing::ext::TestSize.Level0)
1421 {
1422 napi_env env = (napi_env)engine_;
1423 napi_value global = NapiHelper::CreateObject(env);
1424 ExceptionScope scope(env);
1425 napi_value func = nullptr;
1426 GetSendableFunction(env, "bar", func);
1427 napi_value argv[] = { func };
1428 std::string funcName = "LongTaskConstructor";
1429 napi_value cb = nullptr;
1430 napi_value result = nullptr;
1431 napi_create_function(env, funcName.c_str(), funcName.size(), Task::LongTaskConstructor, nullptr, &cb);
1432 napi_call_function(env, global, cb, 1, argv, &result);
1433 ASSERT_TRUE(result != nullptr);
1434 }
1435
1436 HWTEST_F(NativeEngineTest, TaskpoolTest098, testing::ext::TestSize.Level0)
1437 {
1438 napi_env env = (napi_env)engine_;
1439 ExceptionScope scope(env);
1440 napi_value argv[] = { nullptr };
1441 std::string funcName = "SendData";
1442 napi_value cb = nullptr;
1443 napi_value result = nullptr;
1444 napi_create_function(env, funcName.c_str(), funcName.size(), Task::SendData, nullptr, &cb);
1445 napi_call_function(env, nullptr, cb, 1, argv, &result);
1446 ASSERT_TRUE(result == nullptr);
1447 }
1448
1449 HWTEST_F(NativeEngineTest, TaskpoolTest099, testing::ext::TestSize.Level0)
1450 {
1451 napi_env env = (napi_env)engine_;
1452 napi_value argv[] = {};
1453 std::string funcName = "AddDependency";
1454 napi_value cb = nullptr;
1455 napi_value result = nullptr;
1456 napi_create_function(env, funcName.c_str(), funcName.size(), Task::AddDependency, nullptr, &cb);
1457 napi_call_function(env, nullptr, cb, 0, argv, &result);
1458 napi_value exception = nullptr;
1459 napi_get_and_clear_last_exception(env, &exception);
1460 ASSERT_TRUE(exception != nullptr);
1461 }
1462
1463 HWTEST_F(NativeEngineTest, TaskpoolTest100, testing::ext::TestSize.Level0)
1464 {
1465 napi_env env = (napi_env)engine_;
1466 napi_value global = NapiHelper::CreateObject(env);
1467 auto task = GeneratorTask(env, global);
1468 Task* pointer = nullptr;
1469 napi_unwrap(env, task, reinterpret_cast<void**>(&pointer));
1470 pointer->isPeriodicTask_ = true;
1471
1472 napi_value argv[] = { nullptr };
1473 std::string funcName = "AddDependency";
1474 napi_value cb = nullptr;
1475 napi_value result = nullptr;
1476 napi_create_function(env, funcName.c_str(), funcName.size(), Task::AddDependency, nullptr, &cb);
1477 napi_call_function(env, task, cb, 1, argv, &result);
1478 napi_value exception = nullptr;
1479 napi_get_and_clear_last_exception(env, &exception);
1480 ASSERT_TRUE(exception != nullptr);
1481 }
1482
1483 HWTEST_F(NativeEngineTest, TaskpoolTest101, testing::ext::TestSize.Level0)
1484 {
1485 napi_env env = (napi_env)engine_;
1486 napi_value global = NapiHelper::CreateObject(env);
1487 auto task = GeneratorTask(env, global);
1488 Task* pointer = nullptr;
1489 napi_unwrap(env, task, reinterpret_cast<void**>(&pointer));
1490 pointer->taskType_ = TaskType::COMMON_TASK;
1491
1492 napi_value argv[] = { nullptr };
1493 std::string funcName = "AddDependency";
1494 napi_value cb = nullptr;
1495 napi_value result = nullptr;
1496 napi_create_function(env, funcName.c_str(), funcName.size(), Task::AddDependency, nullptr, &cb);
1497 napi_call_function(env, task, cb, 1, argv, &result);
1498 napi_value exception = nullptr;
1499 napi_get_and_clear_last_exception(env, &exception);
1500 ASSERT_TRUE(exception != nullptr);
1501 }
1502
1503 HWTEST_F(NativeEngineTest, TaskpoolTest102, testing::ext::TestSize.Level0)
1504 {
1505 napi_env env = (napi_env)engine_;
1506 napi_value global = NapiHelper::CreateObject(env);
1507 auto task = GeneratorTask(env, global);
1508 auto dependentTask = GeneratorTask(env, global);
1509
1510 napi_value argv[] = { task };
1511 std::string funcName = "AddDependency";
1512 napi_value cb = nullptr;
1513 napi_value result = nullptr;
1514 napi_create_function(env, funcName.c_str(), funcName.size(), Task::AddDependency, nullptr, &cb);
1515 napi_call_function(env, task, cb, 1, argv, &result);
1516 napi_value exception = nullptr;
1517 napi_get_and_clear_last_exception(env, &exception);
1518 ASSERT_TRUE(exception != nullptr);
1519 }
1520
1521 HWTEST_F(NativeEngineTest, TaskpoolTest103, testing::ext::TestSize.Level0)
1522 {
1523 napi_env env = (napi_env)engine_;
1524 napi_value global = NapiHelper::CreateObject(env);
1525 auto task = GeneratorTask(env, global);
1526 napi_value obj;
1527 napi_create_object(env, &obj);
1528 auto dependentTask = GeneratorTask(env, obj);
1529
1530 napi_value argv[] = { dependentTask };
1531 std::string funcName = "AddDependency";
1532 napi_value cb = nullptr;
1533 napi_value result = nullptr;
1534 napi_create_function(env, funcName.c_str(), funcName.size(), Task::AddDependency, nullptr, &cb);
1535 napi_call_function(env, task, cb, 1, argv, &result);
1536 napi_value exception = nullptr;
1537 napi_get_and_clear_last_exception(env, &exception);
1538 ASSERT_TRUE(exception == nullptr);
1539 }
1540
1541 HWTEST_F(NativeEngineTest, TaskpoolTest104, testing::ext::TestSize.Level0)
1542 {
1543 napi_env env = (napi_env)engine_;
1544 ExceptionScope scope(env);
1545 napi_value obj;
1546 napi_create_object(env, &obj);
1547 auto task = GeneratorTask(env, obj);
1548 napi_value argv[] = { task };
1549 NativeEngineTest::Execute(env, argv, 1);
1550 napi_value exception = nullptr;
1551 napi_get_and_clear_last_exception(env, &exception);
1552 ASSERT_TRUE(exception == nullptr);
1553 }
1554
1555 HWTEST_F(NativeEngineTest, TaskpoolTest105, testing::ext::TestSize.Level0)
1556 {
1557 napi_env env = (napi_env)engine_;
1558 ExceptionScope scope(env);
1559 napi_value obj;
1560 napi_create_object(env, &obj);
1561 auto task = GeneratorTask(env, obj);
1562 napi_value argv[] = { task };
1563 NativeEngineTest::TerminateTask(env, argv, 1);
1564 napi_value exception = nullptr;
1565 napi_get_and_clear_last_exception(env, &exception);
1566 ASSERT_TRUE(exception != nullptr);
1567 }
1568
1569 HWTEST_F(NativeEngineTest, TaskpoolTest106, testing::ext::TestSize.Level0)
1570 {
1571 napi_env env = (napi_env)engine_;
1572 ExceptionScope scope(env);
1573 napi_value argv[] = {};
1574 NativeEngineTest::TerminateTask(env, argv, 0);
1575 napi_value exception = nullptr;
1576 napi_get_and_clear_last_exception(env, &exception);
1577 ASSERT_TRUE(exception != nullptr);
1578 }
1579
1580 HWTEST_F(NativeEngineTest, TaskpoolTest107, testing::ext::TestSize.Level0)
1581 {
1582 napi_env env = (napi_env)engine_;
1583 ExceptionScope scope(env);
1584 napi_value obj;
1585 napi_create_object(env, &obj);
1586 auto task = GeneratorTask(env, obj);
1587 Task* pointer = nullptr;
1588 napi_unwrap(env, task, reinterpret_cast<void**>(&pointer));
1589 ASSERT_TRUE(pointer != nullptr);
1590 pointer->isLongTask_ = true;
1591 napi_value argv[] = { task };
1592 NativeEngineTest::TerminateTask(env, argv, 1);
1593 napi_value exception = nullptr;
1594 napi_get_and_clear_last_exception(env, &exception);
1595 ASSERT_TRUE(exception == nullptr);
1596 }
1597
1598 HWTEST_F(NativeEngineTest, TaskpoolTest108, testing::ext::TestSize.Level0)
1599 {
1600 napi_env env = (napi_env)engine_;
1601 ExceptionScope scope(env);
1602 napi_value argv[] = {};
1603 NativeEngineTest::Execute(env, argv, 0);
1604 napi_value exception = nullptr;
1605 napi_get_and_clear_last_exception(env, &exception);
1606 ASSERT_TRUE(exception != nullptr);
1607 }
1608
1609 HWTEST_F(NativeEngineTest, TaskpoolTest109, testing::ext::TestSize.Level0)
1610 {
1611 napi_env env = (napi_env)engine_;
1612 ExceptionScope scope(env);
1613 napi_value obj;
1614 napi_create_object(env, &obj);
1615 auto task = GeneratorTask(env, obj);
1616 napi_value priority = nullptr;
1617 napi_create_uint32(env, 2, &priority); // 2: LOW priority
1618 napi_value argv[] = { task, priority };
1619 NativeEngineTest::Execute(env, argv, 2);
1620 napi_value exception = nullptr;
1621 napi_get_and_clear_last_exception(env, &exception);
1622 ASSERT_TRUE(exception == nullptr);
1623 }
1624
1625 HWTEST_F(NativeEngineTest, TaskpoolTest110, testing::ext::TestSize.Level0)
1626 {
1627 napi_env env = (napi_env)engine_;
1628 ExceptionScope scope(env);
1629 napi_value obj;
1630 napi_create_object(env, &obj);
1631 auto task = GeneratorTask(env, obj);
1632 napi_value priority = nullptr;
1633 napi_create_uint32(env, 10, &priority); // 10: invalid priority
1634 napi_value argv[] = { task, priority };
1635 NativeEngineTest::Execute(env, argv, 2);
1636 napi_value exception = nullptr;
1637 napi_get_and_clear_last_exception(env, &exception);
1638 ASSERT_TRUE(exception != nullptr);
1639 }
1640
1641 HWTEST_F(NativeEngineTest, TaskpoolTest111, testing::ext::TestSize.Level0)
1642 {
1643 napi_env env = (napi_env)engine_;
1644 ExceptionScope scope(env);
1645 napi_value obj;
1646 napi_create_object(env, &obj);
1647 auto group = GeneratorTaskGroup(env, obj);
1648 napi_value taskObj;
1649 napi_create_object(env, &taskObj);
1650 auto task = GeneratorTask(env, taskObj);
1651 napi_value argv[] = { task };
1652 std::string funcName = "AddTask";
1653 napi_value cb = nullptr;
1654 napi_value result = nullptr;
1655 napi_create_function(env, funcName.c_str(), funcName.size(), TaskGroup::AddTask, nullptr, &cb);
1656 napi_call_function(env, group, cb, 1, argv, &result);
1657 napi_value exception = nullptr;
1658 napi_get_and_clear_last_exception(env, &exception);
1659 ASSERT_TRUE(exception == nullptr);
1660 }
1661
1662 HWTEST_F(NativeEngineTest, TaskpoolTest112, testing::ext::TestSize.Level0)
1663 {
1664 napi_env env = (napi_env)engine_;
1665 ExceptionScope scope(env);
1666 napi_value obj;
1667 napi_create_object(env, &obj);
1668 auto group = GeneratorTaskGroup(env, obj);
1669 napi_value func = nullptr;
1670 GetSendableFunction(env, "foo", func);
1671 napi_value argv[] = { func };
1672 std::string funcName = "AddTask";
1673 napi_value cb = nullptr;
1674 napi_value result = nullptr;
1675 napi_create_function(env, funcName.c_str(), funcName.size(), TaskGroup::AddTask, nullptr, &cb);
1676 napi_call_function(env, group, cb, 1, argv, &result);
1677 napi_value exception = nullptr;
1678 napi_get_and_clear_last_exception(env, &exception);
1679 ASSERT_TRUE(exception == nullptr);
1680 }
1681
1682 HWTEST_F(NativeEngineTest, TaskpoolTest113, testing::ext::TestSize.Level0)
1683 {
1684 napi_env env = (napi_env)engine_;
1685 ExceptionScope scope(env);
1686 napi_value argv[] = {};
1687 NativeEngineTest::Cancel(env, argv, 0);
1688 napi_value exception = nullptr;
1689 napi_get_and_clear_last_exception(env, &exception);
1690 ASSERT_TRUE(exception != nullptr);
1691 }
1692
1693 HWTEST_F(NativeEngineTest, TaskpoolTest114, testing::ext::TestSize.Level0)
1694 {
1695 napi_env env = (napi_env)engine_;
1696 ExceptionScope scope(env);
1697 napi_value argv[] = { nullptr };
1698 NativeEngineTest::Cancel(env, argv, 1);
1699 napi_value exception = nullptr;
1700 napi_get_and_clear_last_exception(env, &exception);
1701 ASSERT_TRUE(exception != nullptr);
1702 }
1703
1704 HWTEST_F(NativeEngineTest, TaskpoolTest115, testing::ext::TestSize.Level0)
1705 {
1706 napi_env env = (napi_env)engine_;
1707 ExceptionScope scope(env);
1708 napi_value obj = nullptr;
1709 napi_create_object(env, &obj);
1710 auto task = GeneratorTask(env, obj);
1711 napi_value argv[] = { task };
1712 NativeEngineTest::Cancel(env, argv, 1);
1713 napi_value exception = nullptr;
1714 napi_get_and_clear_last_exception(env, &exception);
1715 ASSERT_TRUE(exception != nullptr);
1716 }
1717
1718 HWTEST_F(NativeEngineTest, TaskpoolTest116, testing::ext::TestSize.Level0)
1719 {
1720 napi_env env = (napi_env)engine_;
1721 ExceptionScope scope(env);
1722 napi_value obj = nullptr;
1723 napi_create_object(env, &obj);
1724 auto task = GeneratorTask(env, obj);
1725 napi_value argv[] = { task };
1726 NativeEngineTest::Execute(env, argv, 1);
1727 NativeEngineTest::Cancel(env, argv, 1);
1728 napi_value exception = nullptr;
1729 napi_get_and_clear_last_exception(env, &exception);
1730 ASSERT_TRUE(exception == nullptr);
1731 }
1732
1733
1734 HWTEST_F(NativeEngineTest, TaskpoolTest117, testing::ext::TestSize.Level0)
1735 {
1736 napi_env env = (napi_env)engine_;
1737 napi_value obj;
1738 napi_create_object(env, &obj);
1739 auto task = GeneratorTask(env, obj);
1740 napi_value argv[] = { nullptr, nullptr };
1741 std::string funcName = "SetTransferList";
1742 napi_value cb = nullptr;
1743 napi_value result = nullptr;
1744 napi_create_function(env, funcName.c_str(), funcName.size(), Task::SetTransferList, nullptr, &cb);
1745 napi_call_function(env, task, cb, 2, argv, &result);
1746 napi_value exception = nullptr;
1747 napi_get_and_clear_last_exception(env, &exception);
1748 ASSERT_TRUE(exception != nullptr);
1749 }
1750
1751 HWTEST_F(NativeEngineTest, TaskpoolTest118, testing::ext::TestSize.Level0)
1752 {
1753 napi_env env = (napi_env)engine_;
1754 napi_value obj;
1755 napi_create_object(env, &obj);
1756 auto task = GeneratorTask(env, obj);
1757 napi_value array;
1758 napi_create_array_with_length(env, 1, &array);
1759
1760 napi_value argv[] = { array };
1761 std::string funcName = "SetTransferList";
1762 napi_value cb = nullptr;
1763 napi_value result = nullptr;
1764 napi_create_function(env, funcName.c_str(), funcName.size(), Task::SetTransferList, nullptr, &cb);
1765 napi_call_function(env, task, cb, 1, argv, &result);
1766 napi_value exception = nullptr;
1767 napi_get_and_clear_last_exception(env, &exception);
1768 ASSERT_TRUE(exception != nullptr);
1769 }
1770
1771 HWTEST_F(NativeEngineTest, TaskpoolTest119, testing::ext::TestSize.Level0)
1772 {
1773 napi_env env = (napi_env)engine_;
1774 napi_value obj;
1775 napi_create_object(env, &obj);
1776 auto task = GeneratorTask(env, obj);
1777 napi_value argv[] = { nullptr, nullptr };
1778 std::string funcName = "SetCloneList";
1779 napi_value cb = nullptr;
1780 napi_value result = nullptr;
1781 napi_create_function(env, funcName.c_str(), funcName.size(), Task::SetCloneList, nullptr, &cb);
1782 napi_call_function(env, task, cb, 2, argv, &result);
1783 napi_value exception = nullptr;
1784 napi_get_and_clear_last_exception(env, &exception);
1785 ASSERT_TRUE(exception != nullptr);
1786 }
1787
1788 HWTEST_F(NativeEngineTest, TaskpoolTest120, testing::ext::TestSize.Level0)
1789 {
1790 napi_env env = (napi_env)engine_;
1791 napi_value obj;
1792 napi_create_object(env, &obj);
1793 auto task = GeneratorTask(env, obj);
1794 napi_value argv[] = { nullptr };
1795 std::string funcName = "SetCloneList";
1796 napi_value cb = nullptr;
1797 napi_value result = nullptr;
1798 napi_create_function(env, funcName.c_str(), funcName.size(), Task::SetCloneList, nullptr, &cb);
1799 napi_call_function(env, task, cb, 1, argv, &result);
1800 napi_value exception = nullptr;
1801 napi_get_and_clear_last_exception(env, &exception);
1802 ASSERT_TRUE(exception != nullptr);
1803 }
1804
1805 HWTEST_F(NativeEngineTest, TaskpoolTest121, testing::ext::TestSize.Level0)
1806 {
1807 napi_env env = (napi_env)engine_;
1808 napi_value obj;
1809 napi_create_object(env, &obj);
1810 auto task = GeneratorTask(env, obj);
1811 napi_value array;
1812 napi_create_array_with_length(env, 1, &array);
1813 napi_value argv[] = { array };
1814 std::string funcName = "SetCloneList";
1815 napi_value cb = nullptr;
1816 napi_value result = nullptr;
1817 napi_create_function(env, funcName.c_str(), funcName.size(), Task::SetCloneList, nullptr, &cb);
1818 napi_call_function(env, task, cb, 1, argv, &result);
1819 napi_value exception = nullptr;
1820 napi_get_and_clear_last_exception(env, &exception);
1821 ASSERT_TRUE(exception == nullptr);
1822 }
1823
1824 HWTEST_F(NativeEngineTest, TaskpoolTest122, testing::ext::TestSize.Level0)
1825 {
1826 napi_env env = (napi_env)engine_;
1827 napi_value argv[] = {};
1828 std::string funcName = "IsCanceled";
1829 napi_value cb = nullptr;
1830 napi_value result = nullptr;
1831 napi_create_function(env, funcName.c_str(), funcName.size(), Task::IsCanceled, nullptr, &cb);
1832 napi_call_function(env, nullptr, cb, 0, argv, &result);
1833 bool value = true;
1834 napi_get_value_bool(env, result, &value);
1835 ASSERT_TRUE(value == false);
1836 }
1837
1838 HWTEST_F(NativeEngineTest, TaskpoolTest123, testing::ext::TestSize.Level0)
1839 {
1840 auto task = std::make_unique<Task>();
1841 task->taskId_ = TaskManager::GetInstance().CalculateTaskId(reinterpret_cast<uint64_t>(task.get()));
1842 task->ioTime_ = 100;
1843 task->startTime_ = 0;
1844 task->StoreTaskDuration();
1845 auto& taskManager = TaskManager::GetInstance();
1846 auto res = taskManager.GetTaskDuration(task->taskId_, "totalDuration");
1847 ASSERT_TRUE(res != 0);
1848 res = taskManager.GetTaskDuration(task->taskId_, "cpuDuration");
1849 ASSERT_TRUE(res != 0);
1850 res = taskManager.GetTaskDuration(task->taskId_, "ioDuration");
1851 ASSERT_TRUE(res == 0);
1852 }
1853
1854 HWTEST_F(NativeEngineTest, TaskpoolTest124, testing::ext::TestSize.Level0)
1855 {
1856 napi_env env = (napi_env)engine_;
1857 ExceptionScope scope(env);
1858 auto task = std::make_unique<Task>();
1859 task->taskId_ = TaskManager::GetInstance().CalculateTaskId(reinterpret_cast<uint64_t>(task.get()));
1860 task->SetHasDependency(true);
1861 auto res = task->CanForSequenceRunner(env);
1862 ASSERT_TRUE(res == false);
1863 task->TryClearHasDependency();
1864 res = task->CanForSequenceRunner(env);
1865 ASSERT_TRUE(res == true);
1866 task->taskType_ = TaskType::SEQRUNNER_TASK;
1867 res = task->CanForSequenceRunner(env);
1868 ASSERT_TRUE(res == false);
1869 task->taskType_ = TaskType::GROUP_COMMON_TASK;
1870 res = task->CanForSequenceRunner(env);
1871 ASSERT_TRUE(res == false);
1872 task->UpdatePeriodicTask();
1873 res = task->CanForSequenceRunner(env);
1874 ASSERT_TRUE(res == false);
1875 }
1876
1877 HWTEST_F(NativeEngineTest, TaskpoolTest125, testing::ext::TestSize.Level0)
1878 {
1879 napi_env env = (napi_env)engine_;
1880 ExceptionScope scope(env);
1881 auto task = std::make_unique<Task>();
1882 task->ThrowNoDependencyError(env);
1883 napi_value exception = nullptr;
1884 napi_get_and_clear_last_exception(env, &exception);
1885 ASSERT_TRUE(exception!= nullptr);
1886 auto res = task->CanExecutePeriodically(env);
1887 ASSERT_TRUE(res == true);
1888 task->UpdatePeriodicTask();
1889 res = task->CanExecutePeriodically(env);
1890 ASSERT_TRUE(res == false);
1891 }
1892
1893 HWTEST_F(NativeEngineTest, TaskpoolTest126, testing::ext::TestSize.Level0)
1894 {
1895 napi_env env = (napi_env)engine_;
1896 ExceptionScope scope(env);
1897 auto task = std::make_unique<Task>();
1898 auto res = task->CanForTaskGroup(env);
1899 ASSERT_TRUE(res == true);
1900 task->taskId_ = TaskManager::GetInstance().CalculateTaskId(reinterpret_cast<uint64_t>(task.get()));
1901 task->SetHasDependency(true);
1902 res = task->CanForTaskGroup(env);
1903 ASSERT_TRUE(res == false);
1904 task->taskType_ = TaskType::SEQRUNNER_TASK;
1905 res = task->CanForTaskGroup(env);
1906 ASSERT_TRUE(res == false);
1907 task->taskType_ = TaskType::GROUP_COMMON_TASK;
1908 res = task->CanForTaskGroup(env);
1909 ASSERT_TRUE(res == false);
1910 task->isLongTask_ = true;
1911 res = task->CanForTaskGroup(env);
1912 ASSERT_TRUE(res == false);
1913 task->UpdatePeriodicTask();
1914 res = task->CanForTaskGroup(env);
1915 ASSERT_TRUE(res == false);
1916 }
1917
1918 HWTEST_F(NativeEngineTest, TaskpoolTest127, testing::ext::TestSize.Level0)
1919 {
1920 napi_env env = (napi_env)engine_;
1921 ExceptionScope scope(env);
1922 auto task = std::make_unique<Task>();
1923 auto res = task->CanExecute(env);
1924 task->taskType_ = TaskType::GROUP_COMMON_TASK;
1925 res = task->CanExecute(env);
1926 ASSERT_TRUE(res == false);
1927 task->taskType_ = TaskType::SEQRUNNER_TASK;
1928 res = task->CanExecute(env);
1929 ASSERT_TRUE(res == false);
1930 task->taskType_ = TaskType::COMMON_TASK;
1931 res = task->CanExecute(env);
1932 ASSERT_TRUE(res == true);
1933 task->SetHasDependency(true);
1934 res = task->CanExecute(env);
1935 ASSERT_TRUE(res == false);
1936 task->TryClearHasDependency();
1937 task->isLongTask_ = true;
1938 res = task->CanExecute(env);
1939 ASSERT_TRUE(res == false);
1940 task->UpdatePeriodicTask();
1941 res = task->CanExecute(env);
1942 ASSERT_TRUE(res == false);
1943 }
1944
1945 HWTEST_F(NativeEngineTest, TaskpoolTest128, testing::ext::TestSize.Level0)
1946 {
1947 napi_env env = (napi_env)engine_;
1948 ExceptionScope scope(env);
1949 auto task = std::make_unique<Task>();
1950 auto res = task->CanExecuteDelayed(env);
1951 task->taskType_ = TaskType::GROUP_COMMON_TASK;
1952 res = task->CanExecuteDelayed(env);
1953 ASSERT_TRUE(res == false);
1954 task->taskType_ = TaskType::SEQRUNNER_TASK;
1955 res = task->CanExecuteDelayed(env);
1956 ASSERT_TRUE(res == false);
1957 task->taskType_ = TaskType::COMMON_TASK;
1958 res = task->CanExecuteDelayed(env);
1959 ASSERT_TRUE(res == true);
1960 task->isLongTask_ = true;
1961 res = task->CanExecute(env);
1962 ASSERT_TRUE(res == false);
1963 task->UpdatePeriodicTask();
1964 res = task->CanExecute(env);
1965 ASSERT_TRUE(res == false);
1966 }
1967
1968 HWTEST_F(NativeEngineTest, TaskpoolTest129, testing::ext::TestSize.Level0)
1969 {
1970 napi_env env = (napi_env)engine_;
1971 ExceptionScope scope(env);
1972 SequenceRunner* seqRunner = new SequenceRunner();
1973 seqRunner->seqRunnerId_ = reinterpret_cast<uint64_t>(seqRunner);
1974 seqRunner->seqName_ = "seq01";
1975 void* data = static_cast<void*>(seqRunner);
1976 NativeEngineTest::SequenceRunnerDestructor(env, data);
1977
1978 SequenceRunner* seqRunner2 = new SequenceRunner();
1979 seqRunner2->seqRunnerId_ = reinterpret_cast<uint64_t>(seqRunner2);
1980 seqRunner2->seqName_ = "seq02";
1981 seqRunner2->isGlobalRunner_ = true;
1982 void* data2 = static_cast<void*>(seqRunner2);
1983 NativeEngineTest::SequenceRunnerDestructor(env, data2);
1984
1985 ASSERT_TRUE(true);
1986 }
1987
1988 HWTEST_F(NativeEngineTest, TaskpoolTest130, testing::ext::TestSize.Level0)
1989 {
1990 napi_env env = (napi_env)engine_;
1991 ExceptionScope scope(env);
1992 TaskGroup* taskGroup = new TaskGroup();
1993 Task* task = new Task(env, TaskType::COMMON_TASK, "groupTask");
1994 TaskManager &taskManager = TaskManager::GetInstance();
1995 taskManager.StoreTask(task);
1996 uint32_t taskId = task->taskId_;
1997 taskGroup->taskIds_.push_back(taskId);
1998 napi_reference_ref(env, task->taskRef_, nullptr);
1999
2000 taskGroup->taskIds_.push_back(2);
2001
2002 GroupInfo* groupInfo = new GroupInfo();
2003 taskGroup->currentGroupInfo_ = groupInfo;
2004
2005 void* data = static_cast<void*>(taskGroup);
2006 NativeEngineTest::TaskGroupDestructor(env, data);
2007 ASSERT_TRUE(true);
2008 }
2009
2010 HWTEST_F(NativeEngineTest, TaskpoolTest131, testing::ext::TestSize.Level0)
2011 {
2012 napi_env env = (napi_env)engine_;
2013 ExceptionScope scope(env);
2014 Task* task = new Task();
2015 uint32_t taskId = TaskManager::GetInstance().CalculateTaskId(reinterpret_cast<uint64_t>(task));
2016 task->taskId_ = taskId;
2017 napi_value thisValue = NapiHelper::CreateObject(env);
2018 napi_ref ref = NapiHelper::CreateReference(env, thisValue, 0);
2019
2020 CallbackInfo* cbInfo = new CallbackInfo(env, 1, ref, task);
2021 uv_async_t* req = new uv_async_t;
2022 req->data = cbInfo;
2023
2024 TaskPool::ExecuteCallback(req);
2025 ASSERT_TRUE(true);
2026
2027 Worker* worker = reinterpret_cast<Worker*>(NativeEngineTest::WorkerConstructor(env));
2028 void* args = nullptr;
2029 TaskResultInfo* resultInfo = new TaskResultInfo(env, env, taskId, args);
2030 worker->Enqueue(env, resultInfo);
2031 TaskResultInfo* resultInfo2 = nullptr;
2032 worker->Enqueue(env, resultInfo2);
2033
2034 TaskManager &taskManager = TaskManager::GetInstance();
2035 taskManager.RegisterCallback(env, taskId, nullptr);
2036 cbInfo->worker = worker;
2037 TaskPool::ExecuteCallback(req);
2038 ASSERT_TRUE(true);
2039 }
2040
2041 HWTEST_F(NativeEngineTest, TaskpoolTest132, testing::ext::TestSize.Level0)
2042 {
2043 napi_env env = (napi_env)engine_;
2044 ExceptionScope scope(env);
2045 Task* task = new Task();
2046 uint32_t taskId = TaskManager::GetInstance().CalculateTaskId(reinterpret_cast<uint64_t>(task));
2047 task->taskId_ = taskId;
2048 napi_value thisValue = NapiHelper::CreateObject(env);
2049 napi_ref ref = NapiHelper::CreateReference(env, thisValue, 0);
2050
2051 CallbackInfo* cbInfo = new CallbackInfo(env, 1, ref, task);
2052 uv_async_t* req = new uv_async_t;
2053 req->data = cbInfo;
2054
2055 Worker* worker = reinterpret_cast<Worker*>(NativeEngineTest::WorkerConstructor(env));
2056 void* args = nullptr;
2057 TaskResultInfo* resultInfo = new TaskResultInfo(env, env, taskId, args);
2058 worker->Enqueue(env, resultInfo);
2059
2060 TaskManager &taskManager = TaskManager::GetInstance();
__anon57f9c37c0502(napi_env environment, napi_callback_info info) 2061 auto func = [](napi_env environment, napi_callback_info info) -> napi_value {
2062 return nullptr;
2063 };
2064 napi_value funValue = nullptr;
2065 napi_create_function(env, "testFunc", NAPI_AUTO_LENGTH, func, nullptr, &funValue);
2066 napi_value argv[] = {funValue};
2067 napi_ref callbackRef = NapiHelper::CreateReference(env, argv[0], 1);
2068 std::shared_ptr<CallbackInfo> callbackInfo = std::make_shared<CallbackInfo>(env, 1, callbackRef, task);
2069 taskManager.RegisterCallback(env, taskId, callbackInfo);
2070 cbInfo->worker = worker;
2071 TaskPool::ExecuteCallback(req);
2072 ASSERT_TRUE(true);
2073 }
2074
2075 HWTEST_F(NativeEngineTest, TaskpoolTest133, testing::ext::TestSize.Level0)
2076 {
2077 napi_env env = (napi_env)engine_;
2078 ExceptionScope scope(env);
2079 Task* task = new Task();
2080 uint32_t taskId = TaskManager::GetInstance().CalculateTaskId(reinterpret_cast<uint64_t>(task));
2081 task->taskId_ = taskId;
2082 napi_value thisValue = NapiHelper::CreateObject(env);
2083 napi_ref ref = NapiHelper::CreateReference(env, thisValue, 0);
2084
2085 CallbackInfo* cbInfo = new CallbackInfo(env, 1, ref, task);
2086 uv_async_t* req = new uv_async_t;
2087 req->data = cbInfo;
2088
2089 Worker* worker = reinterpret_cast<Worker*>(NativeEngineTest::WorkerConstructor(env));
2090 size_t argc = 1;
2091 napi_value argv[] = {nullptr};
2092 napi_create_uint32(env, 1, &argv[0]);
2093 napi_value argsArray;
2094 napi_create_array_with_length(env, argc, &argsArray);
2095 for (size_t i = 0; i < argc; i++) {
2096 napi_set_element(env, argsArray, i, argv[i]);
2097 }
2098 napi_value undefined = NapiHelper::GetUndefinedValue(env);
2099 void* serializationArgs = nullptr;
2100 napi_serialize_inner(env, argsArray, undefined, undefined, true, false, &serializationArgs);
2101 TaskResultInfo* resultInfo = new TaskResultInfo(env, env, taskId, serializationArgs);
2102 worker->Enqueue(env, resultInfo);
2103
2104 TaskManager &taskManager = TaskManager::GetInstance();
__anon57f9c37c0602(napi_env environment, napi_callback_info info) 2105 auto func = [](napi_env environment, napi_callback_info info) -> napi_value {
2106 return nullptr;
2107 };
2108 napi_value funValue = nullptr;
2109 napi_create_function(env, "testFunc", NAPI_AUTO_LENGTH, func, nullptr, &funValue);
2110 napi_value argv1[] = {funValue};
2111 napi_ref callbackRef = NapiHelper::CreateReference(env, argv1[0], 1);
2112 std::shared_ptr<CallbackInfo> callbackInfo = std::make_shared<CallbackInfo>(env, 1, callbackRef, task);
2113 taskManager.RegisterCallback(env, taskId, callbackInfo);
2114 cbInfo->worker = worker;
2115 TaskPool::ExecuteCallback(req);
2116 ASSERT_TRUE(true);
2117 }
2118
2119 HWTEST_F(NativeEngineTest, TaskpoolTest134, testing::ext::TestSize.Level0)
2120 {
2121 napi_env env = (napi_env)engine_;
2122 ExceptionScope scope(env);
2123 Task* task = new Task();
2124 uint32_t taskId = TaskManager::GetInstance().CalculateTaskId(reinterpret_cast<uint64_t>(task));
2125 task->taskId_ = taskId;
2126 napi_value thisValue = NapiHelper::CreateObject(env);
2127 napi_ref ref = NapiHelper::CreateReference(env, thisValue, 0);
2128
2129 CallbackInfo* cbInfo = new CallbackInfo(env, 1, ref, task);
2130 TaskPool::ExecuteCallbackTask(cbInfo);
2131 ASSERT_TRUE(true);
2132
2133 Worker* worker = reinterpret_cast<Worker*>(NativeEngineTest::WorkerConstructor(env));
2134 void* args = nullptr;
2135 TaskResultInfo* resultInfo = new TaskResultInfo(env, env, taskId, args);
2136 worker->Enqueue(env, resultInfo);
2137 cbInfo->worker = worker;
2138 TaskPool::ExecuteCallbackTask(cbInfo);
2139 ASSERT_TRUE(true);
2140 }
2141
2142 HWTEST_F(NativeEngineTest, TaskpoolTest135, testing::ext::TestSize.Level0)
2143 {
2144 napi_env env = (napi_env)engine_;
2145 ExceptionScope scope(env);
2146 napi_value argv[] = {};
2147 napi_value result = NativeEngineTest::TerminateTask(env, argv, 0);
2148 ASSERT_TRUE(result == nullptr);
2149 napi_value exception = nullptr;
2150 napi_get_and_clear_last_exception(env, &exception);
2151
2152 napi_value thisValue = NapiHelper::CreateObject(env);
2153 napi_value argv1[] = {thisValue};
2154 result = NativeEngineTest::TerminateTask(env, argv1, 1);
2155 ASSERT_TRUE(result == nullptr);
2156 exception = nullptr;
2157 napi_get_and_clear_last_exception(env, &exception);
2158
2159 napi_value napiTask = CreateTaskObject(env, TaskType::TASK, ExecuteState::NOT_FOUND, true);
2160 Task* task = nullptr;
2161 napi_unwrap(env, napiTask, reinterpret_cast<void**>(&task));
2162 task->isLongTask_ = true;
2163 napi_value argv2[] = {napiTask};
2164 result = NativeEngineTest::TerminateTask(env, argv2, 1);
2165 ASSERT_TRUE(result != nullptr);
2166 }
2167
2168 HWTEST_F(NativeEngineTest, TaskpoolTest136, testing::ext::TestSize.Level0)
2169 {
2170 napi_env env = (napi_env)engine_;
2171 ExceptionScope scope(env);
2172 napi_value argv[] = {};
2173 napi_value result = NativeEngineTest::Execute(env, argv, 0);
2174 ASSERT_TRUE(result == nullptr);
2175 napi_value exception = nullptr;
2176 napi_get_and_clear_last_exception(env, &exception);
2177
2178 napi_value thisValue = NapiHelper::CreateObject(env);
2179 napi_value argv1[] = {thisValue};
2180 result = NativeEngineTest::Execute(env, argv1, 1);
2181 ASSERT_TRUE(result == nullptr);
2182 exception = nullptr;
2183 napi_get_and_clear_last_exception(env, &exception);
2184
2185 thisValue = CreateTaskObject(env);
2186 napi_value argv2[] = {thisValue};
2187 result = NativeEngineTest::Execute(env, argv2, 1);
2188 ASSERT_TRUE(result != nullptr);
2189 exception = nullptr;
2190 napi_get_and_clear_last_exception(env, &exception);
2191
2192 napi_create_string_utf8(env, "test", NAPI_AUTO_LENGTH, &argv2[0]);
2193 result = NativeEngineTest::Execute(env, argv2, 1);
2194 ASSERT_TRUE(result == nullptr);
2195 exception = nullptr;
2196 napi_get_and_clear_last_exception(env, &exception);
2197
2198 thisValue = CreateTaskObject(env);
2199 napi_value argv3[2] = {};
2200 argv3[0] = thisValue;
2201 napi_create_string_utf8(env, "test", NAPI_AUTO_LENGTH, &argv[1]);
2202 result = NativeEngineTest::Execute(env, argv3, 2);
2203 ASSERT_TRUE(result == nullptr);
2204 }
2205
2206 HWTEST_F(NativeEngineTest, TaskpoolTest137, testing::ext::TestSize.Level0)
2207 {
2208 napi_env env = (napi_env)engine_;
2209 ExceptionScope scope(env);
2210 napi_value thisValue = CreateTaskObject(env);
2211 napi_value argv[2] = {};
2212 argv[0] = thisValue;
2213 napi_create_uint32(env, 1, &argv[1]);
2214 napi_value result = NativeEngineTest::Execute(env, argv, 2);
2215 ASSERT_TRUE(result != nullptr);
2216
2217 thisValue = CreateTaskObject(env, TaskType::SEQRUNNER_TASK);
2218 napi_value argv1[2] = {};
2219 argv1[0] = thisValue;
2220 napi_create_uint32(env, 1, &argv[1]);
2221 result = NativeEngineTest::Execute(env, argv1, 2);
2222 ASSERT_TRUE(result == nullptr);
2223 napi_value exception = nullptr;
2224 napi_get_and_clear_last_exception(env, &exception);
2225
2226 napi_value func = nullptr;
2227 GetSendableFunction(env, "foo", func);
2228 napi_value argv2[] = {func};
2229 result = NativeEngineTest::Execute(env, argv2, 1);
2230 ASSERT_TRUE(result != nullptr);
2231
2232 thisValue = CreateTaskObject(env);
2233 napi_value argv3[2] = {};
2234 argv3[0] = thisValue;
2235 napi_create_uint32(env, 5, &argv3[1]);
2236 result = NativeEngineTest::Execute(env, argv3, 2);
2237 ASSERT_TRUE(result == nullptr);
2238 }
2239
2240 HWTEST_F(NativeEngineTest, TaskpoolTest138, testing::ext::TestSize.Level0)
2241 {
2242 napi_env env = (napi_env)engine_;
2243 ExceptionScope scope(env);
2244 size_t delayTime = 1000;
2245
2246 napi_value argv[] = {nullptr};
2247 napi_value result = NativeEngineTest::ExecuteDelayed(env, argv, 1);
2248 ASSERT_TRUE(result == nullptr);
2249 napi_value exception = nullptr;
2250 napi_get_and_clear_last_exception(env, &exception);
2251
2252 napi_value func = nullptr;
2253 GetSendableFunction(env, "foo", func);
2254 napi_value num = nullptr;
2255 napi_create_uint32(env, delayTime, &num);
2256 napi_value argv1[] = { func, num };
2257 result = NativeEngineTest::ExecuteDelayed(env, argv1, 2);
2258 ASSERT_TRUE(result == nullptr);
2259 exception = nullptr;
2260 napi_get_and_clear_last_exception(env, &exception);
2261
2262 napi_value obj = NapiHelper::CreateObject(env);
2263 num = nullptr;
2264 napi_create_uint32(env, -100, &num);
2265 napi_value argv2[] = { num, obj };
2266 result = NativeEngineTest::ExecuteDelayed(env, argv2, 2);
2267 ASSERT_TRUE(result == nullptr);
2268 exception = nullptr;
2269 napi_get_and_clear_last_exception(env, &exception);
2270
2271 num = nullptr;
2272 napi_create_uint32(env, delayTime, &num);
2273 napi_value argv3[] = { num, obj, obj };
2274 result = NativeEngineTest::ExecuteDelayed(env, argv3, 3);
2275 ASSERT_TRUE(result == nullptr);
2276 exception = nullptr;
2277 napi_get_and_clear_last_exception(env, &exception);
2278
2279 napi_value argv4[] = { num, func};
2280 result = NativeEngineTest::ExecuteDelayed(env, argv4, 2);
2281 ASSERT_TRUE(result == nullptr);
2282 }
2283
2284 HWTEST_F(NativeEngineTest, TaskpoolTest139, testing::ext::TestSize.Level0)
2285 {
2286 napi_env env = (napi_env)engine_;
2287 ExceptionScope scope(env);
2288 size_t delayTime = 1000;
2289 napi_value result = nullptr;
2290 napi_value num = nullptr;
2291 napi_value priority = nullptr;
2292 napi_value exception = nullptr;
2293
2294 napi_value obj = NapiHelper::CreateObject(env);
2295 napi_create_uint32(env, delayTime, &num);
2296 napi_create_uint32(env, 5, &priority);
2297 napi_value argv[] = { num, obj, priority };
2298 result = NativeEngineTest::ExecuteDelayed(env, argv, 3);
2299 ASSERT_TRUE(result == nullptr);
2300 exception = nullptr;
2301 napi_get_and_clear_last_exception(env, &exception);
2302
2303 obj = CreateNullTaskObject(env);
2304 napi_create_uint32(env, 1, &priority);
2305 napi_value argv2[] = { num, obj, priority };
2306 result = NativeEngineTest::ExecuteDelayed(env, argv2, 3);
2307 ASSERT_TRUE(result == nullptr);
2308 exception = nullptr;
2309 napi_get_and_clear_last_exception(env, &exception);
2310
2311 obj = CreateTaskObject(env, TaskType::GROUP_COMMON_TASK);
2312 napi_value argv3[] = { num, obj, priority };
2313 result = NativeEngineTest::ExecuteDelayed(env, argv3, 3);
2314 exception = nullptr;
2315 napi_get_and_clear_last_exception(env, &exception);
2316 ASSERT_TRUE(result == nullptr);
2317
2318 obj = CreateTaskObject(env, TaskType::COMMON_TASK, ExecuteState::CANCELED);
2319 napi_value argv4[] = { num, obj, priority };
2320 result = NativeEngineTest::ExecuteDelayed(env, argv4, 3);
2321 ASSERT_TRUE(result != nullptr);
2322 }
2323
2324 HWTEST_F(NativeEngineTest, TaskpoolTest140, testing::ext::TestSize.Level0)
2325 {
2326 napi_env env = (napi_env)engine_;
2327 ExceptionScope scope(env);
2328 TaskManager &taskManager = TaskManager::GetInstance();
2329 napi_value exception = nullptr;
2330 uv_loop_t* loop = NapiHelper::GetLibUV(env);
2331 uv_update_time(loop);
2332 uv_timer_t* handle = new uv_timer_t;
2333 uv_timer_init(loop, handle);
2334 TaskMessage* taskMessage = new TaskMessage();
__anon57f9c37c0702(napi_env environment, napi_callback_info info) 2335 auto func = [](napi_env environment, napi_callback_info info) -> napi_value {
2336 return nullptr;
2337 };
2338 size_t argc = 1;
2339 napi_value funcValue = nullptr;
2340 napi_create_function(env, "testFunc", NAPI_AUTO_LENGTH, func, nullptr, &funcValue);
2341 napi_value* args = new napi_value[argc];
2342 ObjectScope<napi_value> objScope(args, true);
2343 napi_value taskName = NapiHelper::CreateEmptyString(env);
2344 napi_value obj = NapiHelper::CreateObject(env);
2345 Task* task = Task::GenerateTask(env, obj, funcValue, taskName, args, argc);
2346
2347 taskMessage->taskId = task->taskId_;
2348 handle->data = taskMessage;
2349 NativeEngineTest::DelayTask(handle);
2350 ASSERT_TRUE(true);
2351 }
2352
2353 HWTEST_F(NativeEngineTest, TaskpoolTest141, testing::ext::TestSize.Level0)
2354 {
2355 napi_env env = (napi_env)engine_;
2356 ExceptionScope scope(env);
2357 napi_value exception = nullptr;
2358 napi_value thisVar = NapiHelper::CreateObject(env);
2359 napi_value taskGroupResult = GeneratorTaskGroup(env, thisVar);
2360 napi_value napiGroupId = NapiHelper::GetNameProperty(env, taskGroupResult, "groupId");
2361 uint64_t groupId = NapiHelper::GetUint64Value(env, napiGroupId);
2362
2363 TaskGroupManager& taskGroupManager = TaskGroupManager::GetInstance();
2364 TaskGroup* group = new TaskGroup();
2365 group->groupId_ = groupId;
2366 taskGroupManager.StoreTaskGroup(groupId, group);
2367 napi_value value = NapiHelper::CreateUint64(env, groupId);
2368 napi_ref reference = NapiHelper::CreateReference(env, value, 0);
2369 taskGroupManager.AddTask(groupId, reference, 1);
2370 napi_value result = NativeEngineTest::ExecuteGroup(env, taskGroupResult);
2371 ASSERT_TRUE(result == nullptr);
2372 }
2373
2374 HWTEST_F(NativeEngineTest, TaskpoolTest142, testing::ext::TestSize.Level0)
2375 {
2376 napi_env env = (napi_env)engine_;
2377 ExceptionScope scope(env);
2378 napi_value exception = nullptr;
2379 napi_value thisVar = NapiHelper::CreateObject(env);
2380 napi_value taskGroupResult = GeneratorTaskGroup(env, thisVar);
2381 napi_value napiGroupId = NapiHelper::GetNameProperty(env, taskGroupResult, "groupId");
2382 uint64_t groupId = NapiHelper::GetUint64Value(env, napiGroupId);
2383
2384 TaskGroupManager& taskGroupManager = TaskGroupManager::GetInstance();
2385 TaskGroup* group = new TaskGroup();
2386 group->groupId_ = groupId;
2387 taskGroupManager.StoreTaskGroup(groupId, group);
2388 Task* task = new Task();
2389 task->taskType_ = TaskType::GROUP_COMMON_TASK;
2390 task->groupId_ = groupId;
2391 task->taskId_ = TaskManager::GetInstance().CalculateTaskId(reinterpret_cast<uint64_t>(task));
2392 napi_reference_ref(env, task->taskRef_, nullptr);
2393 napi_value thisValue = NapiHelper::CreateObject(env);
2394 napi_wrap(
2395 env, thisValue, task,
__anon57f9c37c0802(napi_env environment, void* data, void* hint) 2396 [](napi_env environment, void* data, void* hint) {
2397 auto obj = reinterpret_cast<Task*>(data);
2398 if (obj != nullptr) {
2399 delete obj;
2400 }
2401 }, nullptr, nullptr);
2402 napi_ref ref = NapiHelper::CreateReference(env, thisValue, 1);
2403 taskGroupManager.AddTask(groupId, ref, task->taskId_);
2404 napi_value result = NativeEngineTest::ExecuteGroup(env, taskGroupResult);
2405 ASSERT_TRUE(result != nullptr);
2406 }
2407
2408 HWTEST_F(NativeEngineTest, TaskpoolTest143, testing::ext::TestSize.Level0)
2409 {
2410 napi_env env = (napi_env)engine_;
2411 ExceptionScope scope(env);
2412 napi_value exception = nullptr;
2413 napi_value thisVar = NapiHelper::CreateObject(env);
2414 napi_value taskGroupResult = GeneratorTaskGroup(env, thisVar);
2415 napi_value napiGroupId = NapiHelper::GetNameProperty(env, taskGroupResult, "groupId");
2416 uint64_t groupId = NapiHelper::GetUint64Value(env, napiGroupId);
2417
2418 TaskGroupManager& taskGroupManager = TaskGroupManager::GetInstance();
2419 TaskGroup* group = taskGroupManager.GetTaskGroup(groupId);
2420 GroupInfo* groupInfo = new GroupInfo();
2421 groupInfo->priority = Priority::DEFAULT;
2422 group->currentGroupInfo_ = groupInfo;
2423 taskGroupManager.StoreTaskGroup(groupId, group);
2424 napi_value result = NativeEngineTest::ExecuteGroup(env, taskGroupResult);
2425 ASSERT_TRUE(result != nullptr);
2426 }
2427
2428 HWTEST_F(NativeEngineTest, TaskpoolTest144, testing::ext::TestSize.Level0)
2429 {
2430 napi_env env = (napi_env)engine_;
2431 ExceptionScope scope(env);
2432 size_t delayTime = 1000;
2433
2434 napi_value argv[] = {nullptr};
2435 napi_value result = NativeEngineTest::ExecutePeriodically(env, argv, 1);
2436 ASSERT_TRUE(result == nullptr);
2437 napi_value exception = nullptr;
2438 napi_get_and_clear_last_exception(env, &exception);
2439
2440 napi_value func = nullptr;
2441 GetSendableFunction(env, "foo", func);
2442 napi_value num = nullptr;
2443 napi_create_uint32(env, delayTime, &num);
2444 napi_value argv1[] = { func, num };
2445 result = NativeEngineTest::ExecutePeriodically(env, argv1, 2);
2446 ASSERT_TRUE(result == nullptr);
2447 exception = nullptr;
2448 napi_get_and_clear_last_exception(env, &exception);
2449
2450 napi_value obj = NapiHelper::CreateObject(env);
2451 num = nullptr;
2452 napi_create_uint32(env, -100, &num);
2453 napi_value argv2[] = { num, obj };
2454 result = NativeEngineTest::ExecutePeriodically(env, argv2, 2);
2455 ASSERT_TRUE(result == nullptr);
2456 exception = nullptr;
2457 napi_get_and_clear_last_exception(env, &exception);
2458
2459 num = nullptr;
2460 napi_create_uint32(env, delayTime, &num);
2461 napi_value argv3[] = { num, obj, obj };
2462 result = NativeEngineTest::ExecutePeriodically(env, argv3, 3);
2463 ASSERT_TRUE(result == nullptr);
2464 exception = nullptr;
2465 napi_get_and_clear_last_exception(env, &exception);
2466
2467 napi_value argv4[] = { num, num };
2468 result = NativeEngineTest::ExecutePeriodically(env, argv4, 2);
2469 ASSERT_TRUE(result == nullptr);
2470 }
2471
2472 HWTEST_F(NativeEngineTest, TaskpoolTest145, testing::ext::TestSize.Level0)
2473 {
2474 napi_env env = (napi_env)engine_;
2475 ExceptionScope scope(env);
2476 size_t delayTime = 1000;
2477 napi_value result = nullptr;
2478 napi_value num = nullptr;
2479 napi_value priority = nullptr;
2480 napi_value exception = nullptr;
2481
2482 napi_value obj = NapiHelper::CreateObject(env);
2483 napi_create_uint32(env, delayTime, &num);
2484 napi_create_uint32(env, 5, &priority);
2485 napi_value argv[] = { num, obj, priority };
2486 result = NativeEngineTest::ExecutePeriodically(env, argv, 3);
2487 ASSERT_TRUE(result == nullptr);
2488 exception = nullptr;
2489 napi_get_and_clear_last_exception(env, &exception);
2490
2491 obj = CreateNullTaskObject(env);
2492 napi_create_uint32(env, 1, &priority);
2493 napi_value argv2[] = { num, obj, priority };
2494 result = NativeEngineTest::ExecutePeriodically(env, argv2, 3);
2495 ASSERT_TRUE(result == nullptr);
2496 exception = nullptr;
2497 napi_get_and_clear_last_exception(env, &exception);
2498
2499 obj = CreateTaskObject(env, TaskType::GROUP_COMMON_TASK);
2500 napi_value argv3[] = { num, obj, priority };
2501 result = NativeEngineTest::ExecutePeriodically(env, argv3, 3);
2502 exception = nullptr;
2503 napi_get_and_clear_last_exception(env, &exception);
2504 ASSERT_TRUE(result == nullptr);
2505
2506 obj = CreateTaskObject(env, TaskType::TASK);
2507 napi_value argv4[] = { num, obj, priority };
2508 result = NativeEngineTest::ExecutePeriodically(env, argv4, 3);
2509 ASSERT_TRUE(result == nullptr);
2510 }
2511
2512 HWTEST_F(NativeEngineTest, TaskpoolTest146, testing::ext::TestSize.Level0)
2513 {
2514 napi_env env = (napi_env)engine_;
2515 ExceptionScope scope(env);
2516 napi_value global = NapiHelper::CreateObject(env);
2517 auto task = GeneratorTask(env, global);
2518 size_t delayTime = 1000;
2519 napi_value result = nullptr;
2520 napi_value num = nullptr;
2521 napi_value priority = nullptr;
2522 napi_create_uint32(env, delayTime, &num);
2523 napi_create_uint32(env, 1, &priority);
2524 napi_value argv[] = { num, global, priority };
2525 result = NativeEngineTest::ExecutePeriodically(env, argv, 3);
2526 ASSERT_TRUE(result != nullptr);
2527 }
2528
2529 HWTEST_F(NativeEngineTest, TaskpoolTest147, testing::ext::TestSize.Level0)
2530 {
2531 napi_env env = (napi_env)engine_;
2532 uv_timer_t* handle = new uv_timer_t;
2533
2534 handle->data = nullptr;
2535 NativeEngineTest::PeriodicTaskCallback(handle);
2536 ASSERT_TRUE(true);
2537 Task* task = new Task();
2538 handle->data = task;
2539 NativeEngineTest::PeriodicTaskCallback(handle);
2540 ASSERT_TRUE(true);
2541
2542 task->isPeriodicTask_ = true;
2543 handle->data = task;
2544 NativeEngineTest::PeriodicTaskCallback(handle);
2545 ASSERT_TRUE(true);
2546
2547 task->taskState_ = ExecuteState::CANCELED;
2548 task->env_ = env;
2549 napi_value obj = NapiHelper::CreateObject(env);
2550 task->taskRef_ = NapiHelper::CreateReference(env, obj, 1);
2551 uv_loop_t* loop = NapiHelper::GetLibUV(env);
2552 task->timer_ = new uv_timer_t;
2553 uv_timer_init(loop, task->timer_);
2554 handle->data = task;
2555 NativeEngineTest::PeriodicTaskCallback(handle);
2556 ASSERT_TRUE(true);
2557 }
2558
2559 HWTEST_F(NativeEngineTest, TaskpoolTest148, testing::ext::TestSize.Level0)
2560 {
2561 napi_env env = (napi_env)engine_;
2562 uv_timer_t* handle = new uv_timer_t;
2563
2564 Task* task = new Task();
2565 uint32_t taskId = TaskManager::GetInstance().CalculateTaskId(reinterpret_cast<uint64_t>(task));
2566 task->taskId_ = taskId;
2567 task->taskType_ = TaskType::GROUP_COMMON_TASK;
2568 napi_value num = nullptr;
2569 napi_create_uint32(env, 1, &num);
2570 napi_ref callbackRef = Helper::NapiHelper::CreateReference(env, num, 1);
2571 task->onExecutionFailedCallBackInfo_ = new ListenerCallBackInfo(env, callbackRef, nullptr);
2572 handle->data = task;
2573 napi_value res = nullptr;
2574 NativeEngineTest::UpdateGroupInfoByResult(env, handle, res, true);
2575 ASSERT_TRUE(true);
2576
2577 TaskGroupManager& taskGroupManager = TaskGroupManager::GetInstance();
2578 TaskGroup* group = new TaskGroup();
2579 uint64_t groupId = reinterpret_cast<uint64_t>(group);
2580 group->groupId_ = groupId;
2581 task->groupId_ = groupId;
2582 taskGroupManager.StoreTaskGroup(groupId, group);
2583 NativeEngineTest::UpdateGroupInfoByResult(env, handle, res, true);
2584 ASSERT_TRUE(true);
2585
2586 group->taskIds_.push_back(taskId);
2587 GroupInfo* groupInfo = new GroupInfo();
2588 napi_value resArr;
2589 napi_create_array_with_length(env, group->taskIds_.size(), &resArr);
2590 napi_ref arrRef = NapiHelper::CreateReference(env, resArr, 1);
2591 groupInfo->resArr = arrRef;
2592 NapiHelper::CreatePromise(env, &groupInfo->deferred);
2593 group->currentGroupInfo_ = groupInfo;
2594 taskGroupManager.StoreTaskGroup(groupId, group);
2595 NativeEngineTest::UpdateGroupInfoByResult(env, handle, res, false);
2596 ASSERT_TRUE(true);
2597 }
2598
2599 HWTEST_F(NativeEngineTest, TaskpoolTest149, testing::ext::TestSize.Level0)
2600 {
2601 napi_env env = (napi_env)engine_;
2602 uv_timer_t* handle = new uv_timer_t;
2603 TaskGroupManager& taskGroupManager = TaskGroupManager::GetInstance();
2604 TaskManager& taskManager = TaskManager::GetInstance();
2605
2606 TaskGroup* group = new TaskGroup();
2607 uint64_t groupId = reinterpret_cast<uint64_t>(group);
2608 group->groupId_ = groupId;
2609 Task* task = new Task();
2610 taskManager.StoreTask(task);
2611 uint32_t taskId = task->taskId_;
2612 task->groupId_ = groupId;
2613 napi_value num = nullptr;
2614 napi_create_uint32(env, 1, &num);
2615 napi_ref callbackRef = Helper::NapiHelper::CreateReference(env, num, 1);
2616 task->onExecutionSucceededCallBackInfo_ = new ListenerCallBackInfo(env, callbackRef, nullptr);
2617 group->taskIds_.push_back(taskId);
2618 handle->data = task;
2619
2620 GroupInfo* groupInfo = new GroupInfo();
2621 groupInfo->priority = Priority::DEFAULT;
2622 napi_value resArr;
2623 napi_create_array_with_length(env, group->taskIds_.size(), &resArr);
2624 napi_ref arrRef = NapiHelper::CreateReference(env, resArr, 1);
2625 groupInfo->resArr = arrRef;
2626 NapiHelper::CreatePromise(env, &groupInfo->deferred);
2627 group->currentGroupInfo_ = groupInfo;
2628
2629 taskGroupManager.StoreTaskGroup(groupId, group);
2630 napi_value value = NapiHelper::CreateUint64(env, groupId);
2631 napi_ref reference = NapiHelper::CreateReference(env, value, 0);
2632 taskGroupManager.AddTask(groupId, reference, taskId);
2633
2634 napi_value res = nullptr;
2635 napi_create_uint32(env, 1, &res);
2636 NativeEngineTest::UpdateGroupInfoByResult(env, handle, res, true);
2637 ASSERT_TRUE(true);
2638 }
2639
2640 HWTEST_F(NativeEngineTest, TaskpoolTest150, testing::ext::TestSize.Level0)
2641 {
2642 napi_env env = (napi_env)engine_;
2643 NativeEngineTest::TryTriggerExpand();
2644 napi_value exception = nullptr;
2645 napi_get_and_clear_last_exception(env, &exception);
2646 ASSERT_TRUE(exception == nullptr);
2647 }
2648
2649 HWTEST_F(NativeEngineTest, TaskpoolTest150_1, testing::ext::TestSize.Level0)
2650 {
2651 napi_env env = (napi_env)engine_;
2652 NativeEngineTest::CheckForBlockedWorkers(env);
2653 napi_value exception = nullptr;
2654 napi_get_and_clear_last_exception(env, &exception);
2655 ASSERT_TRUE(exception == nullptr);
2656 }
2657
2658 HWTEST_F(NativeEngineTest, TaskpoolTest150_2, testing::ext::TestSize.Level0)
2659 {
2660 napi_env env = (napi_env)engine_;
2661 NativeEngineTest::NotifyShrink(env);
2662 napi_value exception = nullptr;
2663 napi_get_and_clear_last_exception(env, &exception);
2664 ASSERT_TRUE(exception == nullptr);
2665 }
2666
2667 HWTEST_F(NativeEngineTest, TaskpoolTest150_3, testing::ext::TestSize.Level0)
2668 {
2669 napi_env env = (napi_env)engine_;
2670 NativeEngineTest::TryExpand(env);
2671 napi_value exception = nullptr;
2672 napi_get_and_clear_last_exception(env, &exception);
2673 ASSERT_TRUE(exception == nullptr);
2674 }
2675
2676 HWTEST_F(NativeEngineTest, TaskpoolTest150_4, testing::ext::TestSize.Level0)
2677 {
2678 napi_env env = (napi_env)engine_;
2679 NativeEngineTest::CancelTask(env);
2680 napi_value exception = nullptr;
2681 napi_get_and_clear_last_exception(env, &exception);
2682 ASSERT_TRUE(exception != nullptr);
2683 }
2684
2685 HWTEST_F(NativeEngineTest, TaskpoolTest150_5, testing::ext::TestSize.Level0)
2686 {
2687 napi_env env = (napi_env)engine_;
2688 NativeEngineTest::NotifyWorkerIdle(env);
2689 napi_value exception = nullptr;
2690 napi_get_and_clear_last_exception(env, &exception);
2691 ASSERT_TRUE(exception == nullptr);
2692 }
2693
2694 HWTEST_F(NativeEngineTest, TaskpoolTest150_6, testing::ext::TestSize.Level0)
2695 {
2696 napi_env env = (napi_env)engine_;
2697 NativeEngineTest::EnqueueTaskId(env);
2698 napi_value exception = nullptr;
2699 napi_get_and_clear_last_exception(env, &exception);
2700 ASSERT_TRUE(exception == nullptr);
2701 }
2702
2703 HWTEST_F(NativeEngineTest, TaskpoolTest150_7, testing::ext::TestSize.Level0)
2704 {
2705 napi_env env = (napi_env)engine_;
2706 NativeEngineTest::GetTaskByPriority(env);
2707 napi_value exception = nullptr;
2708 napi_get_and_clear_last_exception(env, &exception);
2709 ASSERT_TRUE(exception == nullptr);
2710 }
2711
2712 HWTEST_F(NativeEngineTest, TaskpoolTest150_8, testing::ext::TestSize.Level0)
2713 {
2714 napi_env env = (napi_env)engine_;
2715 NativeEngineTest::RestoreWorker(env);
2716 napi_value exception = nullptr;
2717 napi_get_and_clear_last_exception(env, &exception);
2718 ASSERT_TRUE(exception == nullptr);
2719 }
2720
2721 HWTEST_F(NativeEngineTest, TaskpoolTest151, testing::ext::TestSize.Level0)
2722 {
2723 napi_env env = (napi_env)engine_;
2724 ExceptionScope scope(env);
2725 napi_value argv[] = {nullptr};
2726 std::string func = "TaskGroupConstructor";
2727 napi_value callback = nullptr;
2728 napi_value taskGroupResult = nullptr;
2729 napi_create_function(env, func.c_str(), func.size(), TaskGroup::TaskGroupConstructor, nullptr, &callback);
2730 napi_call_function(env, nullptr, callback, 0, argv, &taskGroupResult);
2731
2732 func = "AddTask";
2733 napi_value cb = nullptr;
2734 napi_value result = nullptr;
2735
2736 napi_create_function(env, func.c_str(), func.size(), TaskGroup::AddTask, nullptr, &cb);
2737 napi_value napiGroupId = NapiHelper::GetNameProperty(env, taskGroupResult, "groupId");
2738 uint64_t groupId = NapiHelper::GetUint64Value(env, napiGroupId);
2739 TaskGroupManager& taskGroupManager = TaskGroupManager::GetInstance();
2740 TaskGroup* group = new TaskGroup();
2741 group->groupId_ = groupId;
2742 group->groupState_ = ExecuteState::RUNNING;
2743 taskGroupManager.StoreTaskGroup(groupId, group);
2744 napi_value argv1[] = {taskGroupResult};
2745 napi_call_function(env, nullptr, cb, 1, argv1, &result);
2746 ASSERT_TRUE(result == nullptr);
2747 }
2748
2749 HWTEST_F(NativeEngineTest, TaskpoolTest152, testing::ext::TestSize.Level0)
2750 {
2751 napi_env env = (napi_env)engine_;
2752 TaskGroupManager& taskGroupManager = TaskGroupManager::GetInstance();
2753 TaskGroup* taskGroup = new TaskGroup();
2754 uint64_t groupId = reinterpret_cast<uint64_t>(taskGroup);
2755 taskGroup->groupId_ = groupId;
2756 taskGroupManager.StoreTaskGroup(groupId, taskGroup);
2757
2758 Task* task = new Task();
2759 task->taskType_ = TaskType::COMMON_TASK;
2760 task->groupId_ = groupId;
2761 task->taskId_ = TaskManager::GetInstance().CalculateTaskId(reinterpret_cast<uint64_t>(task));
2762 napi_reference_ref(env, task->taskRef_, nullptr);
2763 napi_value thisValue = NapiHelper::CreateObject(env);
2764 napi_wrap(
2765 env, thisValue, task,
__anon57f9c37c0902(napi_env environment, void* data, void* hint) 2766 [](napi_env environment, void* data, void* hint) {
2767 auto obj = reinterpret_cast<Task*>(data);
2768 if (obj != nullptr) {
2769 delete obj;
2770 }
2771 }, nullptr, nullptr);
2772 napi_ref ref = NapiHelper::CreateReference(env, thisValue, 1);
2773 taskGroupManager.AddTask(groupId, nullptr, task->taskId_);
2774
2775 GroupInfo* groupInfo = new GroupInfo();
2776 groupInfo->priority = Priority::DEFAULT;
2777 taskGroup->pendingGroupInfos_.push_back(groupInfo);
2778 taskGroup->NotifyGroupTask(env);
2779 ASSERT_TRUE(taskGroup->pendingGroupInfos_.empty());
2780 }
2781
2782 HWTEST_F(NativeEngineTest, TaskpoolTest153, testing::ext::TestSize.Level0)
2783 {
2784 napi_env env = (napi_env)engine_;
2785 TaskGroupManager& taskGroupManager = TaskGroupManager::GetInstance();
2786 TaskGroup* taskGroup = new TaskGroup();
2787 uint64_t groupId = reinterpret_cast<uint64_t>(taskGroup);
2788 taskGroup->groupId_ = groupId;
2789 taskGroupManager.StoreTaskGroup(groupId, taskGroup);
2790
2791 Task* task = new Task();
2792 task->taskType_ = TaskType::GROUP_COMMON_TASK;
2793 task->groupId_ = groupId;
2794 task->taskId_ = TaskManager::GetInstance().CalculateTaskId(reinterpret_cast<uint64_t>(task));
2795 napi_reference_ref(env, task->taskRef_, nullptr);
2796 napi_value thisValue = NapiHelper::CreateObject(env);
2797 napi_wrap(
2798 env, thisValue, task,
__anon57f9c37c0a02(napi_env environment, void* data, void* hint) 2799 [](napi_env environment, void* data, void* hint) {
2800 auto obj = reinterpret_cast<Task*>(data);
2801 if (obj != nullptr) {
2802 delete obj;
2803 }
2804 }, nullptr, nullptr);
2805 napi_ref ref = NapiHelper::CreateReference(env, thisValue, 1);
2806 taskGroupManager.AddTask(groupId, ref, task->taskId_);
2807
2808 GroupInfo* groupInfo = new GroupInfo();
2809 groupInfo->priority = Priority::DEFAULT;
2810 taskGroup->pendingGroupInfos_.push_back(groupInfo);
2811 taskGroup->NotifyGroupTask(env);
2812 ASSERT_TRUE(taskGroup->pendingGroupInfos_.empty());
2813 }
2814
2815 HWTEST_F(NativeEngineTest, TaskpoolTest154, testing::ext::TestSize.Level0)
2816 {
2817 napi_env env = (napi_env)engine_;
2818 Task* task = new Task();
2819 task->taskType_ = TaskType::GROUP_COMMON_TASK;
2820 task->taskId_ = TaskManager::GetInstance().CalculateTaskId(reinterpret_cast<uint64_t>(task));
2821 napi_value args[2] = {nullptr};
2822 napi_create_string_utf8(env, "generate", NAPI_AUTO_LENGTH, &args[0]);
2823 napi_value obj;
2824 napi_create_object(env, &obj);
2825 args[1] = obj;
2826 task = task->GenerateFunctionTask(env, nullptr, args, 2, TaskType::GROUP_FUNCTION_TASK);
2827 napi_value exception = nullptr;
2828 napi_get_and_clear_last_exception(env, &exception);
2829 ASSERT_TRUE(exception != nullptr);
2830 }
2831
2832 HWTEST_F(NativeEngineTest, TaskpoolTest155, testing::ext::TestSize.Level0)
2833 {
2834 napi_env env = (napi_env)engine_;
2835 Task* task = new Task();
2836 napi_value result = CreateTaskObject(env);
2837 std::string func = "func";
2838 std::string name = "Task";
2839 napi_value funcValue = nullptr;
2840 napi_value nameValue = nullptr;
2841 napi_create_string_utf8(env, name.c_str(), name.length(), &nameValue);
2842 napi_create_string_utf8(env, func.c_str(), func.length(), &funcValue);
2843 napi_value undefined = nullptr;
2844 napi_get_undefined(env, &undefined);
2845 napi_set_named_property(env, result, ARGUMENTS_STR, nameValue);
2846
2847 napi_set_named_property(env, result, FUNCTION_STR, funcValue);
2848 napi_set_named_property(env, result, NAME, nameValue);
2849 napi_value trueVal = NapiHelper::CreateBooleanValue(env, true);
2850 napi_set_named_property(env, result, DEFAULT_TRANSFER_STR, trueVal);
2851 napi_set_named_property(env, result, DEFAULT_CLONE_SENDABLE_STR, trueVal);
2852
2853 napi_set_named_property(env, result, TRANSFERLIST_STR, nameValue);
2854 napi_set_named_property(env, result, TRANSFERLIST_STR, nameValue);
2855 TaskInfo* info = task->GetTaskInfo(env, result, Priority::DEFAULT);
2856 ASSERT_TRUE(info == nullptr);
2857 delete task;
2858 }
2859
2860 HWTEST_F(NativeEngineTest, TaskpoolTest156, testing::ext::TestSize.Level0)
2861 {
2862 napi_env env = (napi_env)engine_;
2863 napi_value global = NapiHelper::GetGlobalObject(env);
2864 napi_value thisValue = CreateTaskObject(env);
2865 Task* task = nullptr;
2866 napi_unwrap(env, thisValue, reinterpret_cast<void**>(&task));
2867 napi_value undefined = NapiHelper::GetUndefinedValue(env);
2868 napi_status status = napi_set_named_property(env, thisValue, CLONE_LIST_STR, undefined);
2869 napi_value array;
2870 napi_create_array_with_length(env, 1, &array);
2871
2872 napi_value argv[] = { array };
2873 std::string funcName = "SetTransferList";
2874 napi_value cb = nullptr;
2875 napi_value result = nullptr;
2876 napi_create_function(env, funcName.c_str(), funcName.size(), Task::SetTransferList, nullptr, &cb);
2877 napi_call_function(env, thisValue, cb, 1, argv, &result);
2878 napi_value exception = nullptr;
2879 napi_get_and_clear_last_exception(env, &exception);
2880 ASSERT_TRUE(exception != nullptr);
2881 }
2882
2883 HWTEST_F(NativeEngineTest, TaskpoolTest157, testing::ext::TestSize.Level0)
2884 {
2885 napi_env env = (napi_env)engine_;
2886 napi_value global = NapiHelper::GetGlobalObject(env);
2887 napi_value thisValue = CreateTaskObject(env);
2888 Task* task = nullptr;
2889 napi_unwrap(env, thisValue, reinterpret_cast<void**>(&task));
2890
2891 napi_value array;
2892 napi_create_array_with_length(env, 1, &array);
2893
2894 std::string funcName = "SetTransferList";
2895 napi_value cb = nullptr;
2896 napi_value result = nullptr;
2897 napi_create_function(env, funcName.c_str(), funcName.size(), Task::SetTransferList, nullptr, &cb);
2898 napi_call_function(env, thisValue, cb, 0, nullptr, &result);
2899 napi_value exception = nullptr;
2900 napi_get_and_clear_last_exception(env, &exception);
2901 ASSERT_TRUE(exception == nullptr);
2902 }
2903
2904 HWTEST_F(NativeEngineTest, TaskpoolTest158, testing::ext::TestSize.Level0)
2905 {
2906 napi_env env = (napi_env)engine_;
2907 napi_value global = NapiHelper::GetGlobalObject(env);
2908 napi_value thisValue = CreateTaskObject(env);
2909 Task* task = nullptr;
2910 napi_unwrap(env, thisValue, reinterpret_cast<void**>(&task));
2911
2912 napi_value argv[1] = { nullptr };
2913 std::string funcName = "SetTransferList";
2914 napi_create_string_utf8(env, funcName.c_str(), funcName.size(), &argv[0]);
2915 napi_value cb = nullptr;
2916 napi_value result = nullptr;
2917 napi_create_function(env, funcName.c_str(), funcName.size(), Task::SetTransferList, nullptr, &cb);
2918 napi_call_function(env, thisValue, cb, 1, argv, &result);
2919 napi_value exception = nullptr;
2920 napi_get_and_clear_last_exception(env, &exception);
2921 ASSERT_TRUE(exception != nullptr);
2922 }
2923
2924 HWTEST_F(NativeEngineTest, TaskpoolTest159, testing::ext::TestSize.Level0)
2925 {
2926 napi_env env = (napi_env)engine_;
2927 napi_value global = NapiHelper::GetGlobalObject(env);
2928 napi_value thisValue = CreateTaskObject(env);
2929 Task* task = nullptr;
2930 napi_unwrap(env, thisValue, reinterpret_cast<void**>(&task));
2931 napi_value array;
2932 napi_create_array_with_length(env, 0, &array);
2933
2934 napi_value argv[] = { array };
2935 std::string funcName = "SetTransferList";
2936 napi_value cb = nullptr;
2937 napi_value result = nullptr;
2938 napi_create_function(env, funcName.c_str(), funcName.size(), Task::SetTransferList, nullptr, &cb);
2939 napi_call_function(env, thisValue, cb, 1, argv, &result);
2940 napi_value exception = nullptr;
2941 napi_get_and_clear_last_exception(env, &exception);
2942 ASSERT_TRUE(exception == nullptr);
2943 }
2944
2945 HWTEST_F(NativeEngineTest, TaskpoolTest160, testing::ext::TestSize.Level0)
2946 {
2947 napi_env env = (napi_env)engine_;
2948 napi_value global = NapiHelper::GetGlobalObject(env);
2949 napi_value thisValue = CreateTaskObject(env);
2950 Task* task = nullptr;
2951 napi_unwrap(env, thisValue, reinterpret_cast<void**>(&task));
2952 napi_value undefined = NapiHelper::GetUndefinedValue(env);
2953 napi_status status = napi_set_named_property(env, thisValue, TRANSFERLIST_STR, undefined);
2954 ASSERT_TRUE(status == napi_ok);
2955 napi_value argv[] = { nullptr, nullptr };
2956 std::string funcName = "SetCloneList";
2957 napi_value cb = nullptr;
2958 napi_value result = nullptr;
2959 napi_create_function(env, funcName.c_str(), funcName.size(), Task::SetCloneList, nullptr, &cb);
2960 napi_call_function(env, nullptr, cb, 2, argv, &result);
2961 napi_value exception = nullptr;
2962 napi_get_and_clear_last_exception(env, &exception);
2963 ASSERT_TRUE(exception != nullptr);
2964 }
2965
2966 HWTEST_F(NativeEngineTest, TaskpoolTest161, testing::ext::TestSize.Level0)
2967 {
2968 napi_env env = (napi_env)engine_;
2969 napi_value global = NapiHelper::GetGlobalObject(env);
2970 napi_value thisValue = CreateTaskObject(env);
2971 Task* task = nullptr;
2972 napi_unwrap(env, thisValue, reinterpret_cast<void**>(&task));
2973
2974 napi_value array;
2975 napi_create_array_with_length(env, 0, &array);
2976 napi_value argv[] = { array };
2977 std::string funcName = "SetCloneList";
2978 napi_value cb = nullptr;
2979 napi_value result = nullptr;
2980 napi_create_function(env, funcName.c_str(), funcName.size(), Task::SetCloneList, nullptr, &cb);
2981 napi_call_function(env, nullptr, cb, 1, argv, &result);
2982 napi_value exception = nullptr;
2983 napi_get_and_clear_last_exception(env, &exception);
2984 ASSERT_TRUE(exception == nullptr);
2985 }
2986
2987 HWTEST_F(NativeEngineTest, TaskpoolTest162, testing::ext::TestSize.Level0)
2988 {
2989 napi_env env = (napi_env)engine_;
2990 napi_value global = NapiHelper::GetGlobalObject(env);
2991 napi_value thisValue = CreateTaskObject(env);
2992 Task* task = nullptr;
2993 napi_unwrap(env, thisValue, reinterpret_cast<void**>(&task));
2994
2995 napi_value array;
2996 napi_create_array_with_length(env, 0, &array);
2997 napi_value argv[] = { array };
2998 std::string funcName = "SetCloneList";
2999 napi_value cb = nullptr;
3000 napi_value result = nullptr;
3001 napi_create_function(env, funcName.c_str(), funcName.size(), Task::SetCloneList, nullptr, &cb);
3002 napi_call_function(env, thisValue, cb, 1, argv, &result);
3003 napi_value exception = nullptr;
3004 napi_get_and_clear_last_exception(env, &exception);
3005 ASSERT_TRUE(exception == nullptr);
3006 }
3007
3008 HWTEST_F(NativeEngineTest, TaskpoolTest163, testing::ext::TestSize.Level0)
3009 {
3010 napi_env env = (napi_env)engine_;
3011 napi_value global = NapiHelper::GetGlobalObject(env);
3012 napi_value thisValue = CreateTaskObject(env);
3013 Task* task = nullptr;
3014 napi_unwrap(env, thisValue, reinterpret_cast<void**>(&task));
3015
3016 napi_value array;
3017 napi_create_array_with_length(env, 0, &array);
3018 napi_value argv[] = { array };
3019 std::string funcName = "SetCloneList";
3020 napi_value cb = nullptr;
3021 napi_value result = nullptr;
3022 napi_create_function(env, funcName.c_str(), funcName.size(), Task::SetCloneList, nullptr, &cb);
3023 napi_call_function(env, thisValue, cb, 1, argv, &result);
3024 napi_value exception = nullptr;
3025 napi_get_and_clear_last_exception(env, &exception);
3026 ASSERT_TRUE(exception == nullptr);
3027 }
3028
3029 HWTEST_F(NativeEngineTest, TaskpoolTest164, testing::ext::TestSize.Level0)
3030 {
3031 napi_env env = (napi_env)engine_;
3032 napi_env taskEnv = nullptr;
3033 napi_create_runtime(env, &taskEnv);
3034 NativeEngine* taskEngine = reinterpret_cast<NativeEngine*>(taskEnv);
3035 taskEngine->MarkTaskPoolThread();
3036 napi_value global = NapiHelper::GetGlobalObject(env);
3037 napi_value thisValue = CreateTaskObject(taskEnv);
3038
3039 std::string funcName = "IsCanceled";
3040 napi_value cb = nullptr;
3041 napi_value result = nullptr;
3042 napi_create_function(taskEnv, funcName.c_str(), funcName.size(), Task::IsCanceled, nullptr, &cb);
3043 napi_call_function(taskEnv, thisValue, cb, 0, nullptr, &result);
3044 napi_value exception = nullptr;
3045 napi_get_and_clear_last_exception(taskEnv, &exception);
3046 ASSERT_TRUE(exception == nullptr);
3047 }
3048
3049 HWTEST_F(NativeEngineTest, TaskpoolTest165, testing::ext::TestSize.Level0)
3050 {
3051 napi_env env = (napi_env)engine_;
3052 napi_env taskEnv = nullptr;
3053 napi_create_runtime(env, &taskEnv);
3054 NativeEngine* taskEngine = reinterpret_cast<NativeEngine*>(taskEnv);
3055 taskEngine->MarkTaskPoolThread();
3056 napi_value global = NapiHelper::GetGlobalObject(env);
3057 napi_value thisValue = CreateTaskObject(taskEnv);
3058 std::string funcName = "IsCanceled";
3059 napi_value cb = nullptr;
3060 napi_value result = nullptr;
3061 napi_create_function(taskEnv, funcName.c_str(), funcName.size(), Task::IsCanceled, nullptr, &cb);
3062 napi_call_function(taskEnv, thisValue, cb, 0, nullptr, &result);
3063 napi_value exception = nullptr;
3064 napi_get_and_clear_last_exception(taskEnv, &exception);
3065 ASSERT_TRUE(exception == nullptr);
3066 }
3067
3068 HWTEST_F(NativeEngineTest, TaskpoolTest166, testing::ext::TestSize.Level0)
3069 {
3070 napi_env env = (napi_env)engine_;
3071 napi_value global = NapiHelper::GetGlobalObject(env);
3072 napi_value argv[1] = { nullptr };
3073 napi_value undefined = NapiHelper::GetUndefinedValue(env);
3074 argv[0] = undefined;
3075 std::string funcName = "OnReceiveData";
3076 napi_value cb = nullptr;
3077 napi_value result = nullptr;
3078
3079 napi_create_function(env, funcName.c_str(), funcName.size(), Task::OnReceiveData, nullptr, &cb);
3080 napi_call_function(env, global, cb, 1, argv, &result);
3081
3082 napi_value exception = nullptr;
3083 napi_get_and_clear_last_exception(env, &exception);
3084 ASSERT_TRUE(exception != nullptr);
3085 }
3086
3087 HWTEST_F(NativeEngineTest, TaskpoolTest167, testing::ext::TestSize.Level0)
3088 {
3089 napi_env env = (napi_env)engine_;
3090 ExceptionScope scope(env);
3091 napi_env taskEnv = nullptr;
3092 napi_create_runtime(env, &taskEnv);
3093 NativeEngine* taskEngine = reinterpret_cast<NativeEngine*>(taskEnv);
3094 taskEngine->MarkTaskPoolThread();
3095 napi_value global = NapiHelper::GetGlobalObject(env);
3096
3097 napi_value argv[] = { nullptr };
3098 std::string funcName = "SendData";
3099 napi_value cb = nullptr;
3100 napi_value result = nullptr;
3101 napi_create_function(taskEnv, funcName.c_str(), funcName.size(), Task::SendData, nullptr, &cb);
3102 napi_call_function(taskEnv, global, cb, 1, argv, &result);
3103 napi_value exception = nullptr;
3104 napi_get_and_clear_last_exception(env, &exception);
3105 ASSERT_TRUE(exception == nullptr);
3106 }
3107
3108 HWTEST_F(NativeEngineTest, TaskpoolTest168, testing::ext::TestSize.Level0)
3109 {
3110 napi_env env = (napi_env)engine_;
3111 ExceptionScope scope(env);
3112 napi_env taskEnv = nullptr;
3113 napi_create_runtime(env, &taskEnv);
3114 NativeEngine* taskEngine = reinterpret_cast<NativeEngine*>(taskEnv);
3115 taskEngine->MarkTaskPoolThread();
3116 napi_value global = NapiHelper::GetGlobalObject(env);
3117 napi_value argv[] = { nullptr };
3118 std::string funcName = "SendData";
3119 napi_value cb = nullptr;
3120 napi_value result = nullptr;
3121 napi_create_function(taskEnv, funcName.c_str(), funcName.size(), Task::SendData, nullptr, &cb);
3122 napi_call_function(taskEnv, global, cb, 1, argv, &result);
3123 napi_value exception = nullptr;
3124 napi_get_and_clear_last_exception(env, &exception);
3125 ASSERT_TRUE(exception == nullptr);
3126 }
3127
3128 HWTEST_F(NativeEngineTest, TaskpoolTest169, testing::ext::TestSize.Level0)
3129 {
3130 napi_env env = (napi_env)engine_;
3131 napi_value global = NapiHelper::CreateObject(env);
3132 napi_value thisValue = CreateTaskObject(env);
3133
3134 napi_value dependentTask = CreateTaskObject(env);
3135 napi_value argv[] = { dependentTask };
3136 std::string funcName = "AddDependency";
3137 napi_value cb = nullptr;
3138 napi_value result = nullptr;
3139 napi_create_function(env, funcName.c_str(), funcName.size(), Task::AddDependency, nullptr, &cb);
3140 napi_call_function(env, nullptr, cb, 1, argv, &result);
3141 napi_value exception = nullptr;
3142 napi_get_and_clear_last_exception(env, &exception);
3143 ASSERT_TRUE(exception == nullptr);
3144 }
3145
3146 HWTEST_F(NativeEngineTest, TaskpoolTest170, testing::ext::TestSize.Level0)
3147 {
3148 napi_env env = (napi_env)engine_;
3149 napi_value global = NapiHelper::CreateObject(env);
3150 napi_value thisValue = CreateTaskObject(env);
3151 Task* task = nullptr;
3152 napi_unwrap(env, thisValue, reinterpret_cast<void**>(&task));
3153 ASSERT_TRUE(task != nullptr);
3154
3155 napi_value dependentTask = CreateTaskObject(env);
3156 napi_value argv[] = { dependentTask };
3157 std::string funcName = "AddDependency";
3158 napi_value cb = nullptr;
3159 napi_value result = nullptr;
3160 napi_create_function(env, funcName.c_str(), funcName.size(), Task::AddDependency, nullptr, &cb);
3161 task->isPeriodicTask_ = false;
3162 task->taskType_ = TaskType::GROUP_COMMON_TASK;
3163 napi_call_function(env, thisValue, cb, 1, argv, &result);
3164 napi_value exception = nullptr;
3165 napi_get_and_clear_last_exception(env, &exception);
3166 ASSERT_TRUE(exception != nullptr);
3167 }
3168
3169 HWTEST_F(NativeEngineTest, TaskpoolTest171, testing::ext::TestSize.Level0)
3170 {
3171 napi_env env = (napi_env)engine_;
3172 napi_value global = NapiHelper::CreateObject(env);
3173 napi_value thisValue = CreateTaskObject(env);
3174 Task* task = nullptr;
3175 napi_unwrap(env, thisValue, reinterpret_cast<void**>(&task));
3176
3177 napi_value dependentTask = CreateTaskObject(env);
3178 napi_value argv[] = { dependentTask };
3179 std::string funcName = "AddDependency";
3180 napi_value cb = nullptr;
3181 napi_value result = nullptr;
3182 napi_create_function(env, funcName.c_str(), funcName.size(), Task::AddDependency, nullptr, &cb);
3183 task->taskType_ = TaskType::TASK;
3184 task->isPeriodicTask_ = false;
3185 napi_call_function(env, thisValue, cb, 1, argv, &result);
3186 napi_value exception = nullptr;
3187 napi_get_and_clear_last_exception(env, &exception);
3188 ASSERT_TRUE(exception == nullptr);
3189 }
3190
3191 HWTEST_F(NativeEngineTest, TaskpoolTest172, testing::ext::TestSize.Level0)
3192 {
3193 napi_env env = (napi_env)engine_;
3194 napi_value global = NapiHelper::CreateObject(env);
3195 napi_value thisValue = CreateTaskObject(env);
3196 Task* task = nullptr;
3197 napi_unwrap(env, thisValue, reinterpret_cast<void**>(&task));
3198
3199 napi_value argv[] = { nullptr };
3200 std::string funcName = "AddDependency";
3201 napi_value cb = nullptr;
3202 napi_value result = nullptr;
3203 napi_create_function(env, funcName.c_str(), funcName.size(), Task::AddDependency, nullptr, &cb);
3204 task->taskType_ = TaskType::TASK;
3205 task->isPeriodicTask_ = false;
3206 napi_call_function(env, thisValue, cb, 1, argv, &result);
3207 napi_value exception = nullptr;
3208 napi_get_and_clear_last_exception(env, &exception);
3209 ASSERT_TRUE(exception != nullptr);
3210 }
3211
3212 HWTEST_F(NativeEngineTest, TaskpoolTest173, testing::ext::TestSize.Level0)
3213 {
3214 napi_env env = (napi_env)engine_;
3215 napi_value global = NapiHelper::CreateObject(env);
3216 napi_value thisValue = CreateTaskObject(env);
3217 Task* task = nullptr;
3218 napi_unwrap(env, thisValue, reinterpret_cast<void**>(&task));
3219
3220 napi_value dependentTask = CreateTaskObject(env);
3221 Task* task1 = nullptr;
3222 napi_unwrap(env, dependentTask, reinterpret_cast<void**>(&task1));
3223 task1->isPeriodicTask_ = true;
3224 napi_value argv[] = { dependentTask };
3225 std::string funcName = "AddDependency";
3226 napi_value cb = nullptr;
3227 napi_value result = nullptr;
3228 napi_create_function(env, funcName.c_str(), funcName.size(), Task::AddDependency, nullptr, &cb);
3229 task->taskType_ = TaskType::TASK;
3230 task->isPeriodicTask_ = false;
3231 napi_call_function(env, thisValue, cb, 1, argv, &result);
3232 napi_value exception = nullptr;
3233 napi_get_and_clear_last_exception(env, &exception);
3234 ASSERT_TRUE(exception != nullptr);
3235 }
3236
3237 HWTEST_F(NativeEngineTest, TaskpoolTest174, testing::ext::TestSize.Level0)
3238 {
3239 napi_env env = (napi_env)engine_;
3240 napi_value global = NapiHelper::CreateObject(env);
3241 napi_value thisValue = CreateTaskObject(env);
3242 Task* task = nullptr;
3243 napi_unwrap(env, thisValue, reinterpret_cast<void**>(&task));
3244
3245 napi_value dependentTask = CreateTaskObject(env);
3246 Task* task1 = nullptr;
3247 napi_unwrap(env, dependentTask, reinterpret_cast<void**>(&task1));
3248 task1->taskType_ = TaskType::COMMON_TASK;
3249 napi_value argv[] = { dependentTask };
3250 std::string funcName = "AddDependency";
3251 napi_value cb = nullptr;
3252 napi_value result = nullptr;
3253 napi_create_function(env, funcName.c_str(), funcName.size(), Task::AddDependency, nullptr, &cb);
3254 task->taskType_ = TaskType::TASK;
3255 task1->taskType_ = TaskType::COMMON_TASK;
3256 task->isPeriodicTask_ = false;
3257 task1->isPeriodicTask_ = false;
3258 napi_call_function(env, thisValue, cb, 1, argv, &result);
3259 napi_value exception = nullptr;
3260 napi_get_and_clear_last_exception(env, &exception);
3261 ASSERT_TRUE(exception != nullptr);
3262
3263 task1->taskType_ = TaskType::SEQRUNNER_TASK;
3264 napi_call_function(env, thisValue, cb, 1, argv, &result);
3265 napi_get_and_clear_last_exception(env, &exception);
3266 ASSERT_TRUE(exception != nullptr);
3267
3268 task1->taskType_ = TaskType::GROUP_COMMON_TASK;
3269 napi_call_function(env, thisValue, cb, 1, argv, &result);
3270 napi_get_and_clear_last_exception(env, &exception);
3271 ASSERT_TRUE(exception != nullptr);
3272
3273 task1->taskType_ = TaskType::ASYNCRUNNER_TASK;
3274 napi_call_function(env, thisValue, cb, 1, argv, &result);
3275 napi_get_and_clear_last_exception(env, &exception);
3276 ASSERT_TRUE(exception != nullptr);
3277 }
3278
3279 HWTEST_F(NativeEngineTest, TaskpoolTest175, testing::ext::TestSize.Level0)
3280 {
3281 napi_env env = (napi_env)engine_;
3282 napi_value global = NapiHelper::CreateObject(env);
3283 napi_value thisValue = CreateTaskObject(env);
3284 Task* task = nullptr;
3285 napi_unwrap(env, thisValue, reinterpret_cast<void**>(&task));
3286
3287 napi_value dependentTask = CreateTaskObject(env);
3288 napi_value argv[] = { dependentTask };
3289 std::string funcName = "AddDependency";
3290 napi_value cb = nullptr;
3291 napi_value result = nullptr;
3292 napi_create_function(env, funcName.c_str(), funcName.size(), Task::AddDependency, nullptr, &cb);
3293 task->isPeriodicTask_ = false;
3294 task->taskType_ = TaskType::SEQRUNNER_TASK;
3295 napi_call_function(env, thisValue, cb, 1, argv, &result);
3296 napi_value exception = nullptr;
3297 napi_get_and_clear_last_exception(env, &exception);
3298 ASSERT_TRUE(exception != nullptr);
3299
3300 task->taskType_ = TaskType::COMMON_TASK;
3301 napi_call_function(env, thisValue, cb, 1, argv, &result);
3302 exception = nullptr;
3303 napi_get_and_clear_last_exception(env, &exception);
3304 ASSERT_TRUE(exception != nullptr);
3305
3306 task->taskType_ = TaskType::ASYNCRUNNER_TASK;
3307 napi_call_function(env, thisValue, cb, 1, argv, &result);
3308 exception = nullptr;
3309 napi_get_and_clear_last_exception(env, &exception);
3310 ASSERT_TRUE(exception != nullptr);
3311 }
3312
3313 HWTEST_F(NativeEngineTest, TaskpoolTest176, testing::ext::TestSize.Level0)
3314 {
3315 napi_env env = (napi_env)engine_;
3316 std::string funcName = "RemoveDependency";
3317 napi_value cb = nullptr;
3318 napi_value result = nullptr;
3319 napi_create_function(env, funcName.c_str(), funcName.size(), Task::RemoveDependency, nullptr, &cb);
3320
3321 napi_call_function(env, nullptr, cb, 0, nullptr, &result);
3322 napi_value exception = nullptr;
3323 napi_get_and_clear_last_exception(env, &exception);
3324 ASSERT_TRUE(exception != nullptr);
3325 }
3326
3327 HWTEST_F(NativeEngineTest, TaskpoolTest177, testing::ext::TestSize.Level0)
3328 {
3329 napi_env env = (napi_env)engine_;
3330 napi_value thisValue = CreateTaskObject(env);
3331 Task* task = nullptr;
3332 napi_unwrap(env, thisValue, reinterpret_cast<void**>(&task));
3333
3334 napi_value dependentTask = CreateTaskObject(env);
3335 napi_value argv[] = { dependentTask };
3336 std::string funcName = "RemoveDependency";
3337 napi_value cb = nullptr;
3338 napi_value result = nullptr;
3339 napi_create_function(env, funcName.c_str(), funcName.size(), Task::RemoveDependency, nullptr, &cb);
3340 napi_call_function(env, nullptr, cb, 1, argv, &result);
3341 napi_value exception = nullptr;
3342 napi_get_and_clear_last_exception(env, &exception);
3343 ASSERT_TRUE(exception != nullptr);
3344 }
3345
3346 HWTEST_F(NativeEngineTest, TaskpoolTest178, testing::ext::TestSize.Level0)
3347 {
3348 napi_env env = (napi_env)engine_;
3349 napi_value thisValue = CreateTaskObject(env);
3350 Task* task = nullptr;
3351 napi_unwrap(env, thisValue, reinterpret_cast<void**>(&task));
3352
3353 napi_value undefined = NapiHelper::GetUndefinedValue(env);
3354 napi_value dependentTask = CreateTaskObject(env);
3355 napi_set_named_property(env, dependentTask, TASKID_STR, undefined);
3356 napi_value argv[] = { dependentTask };
3357 std::string funcName = "RemoveDependency";
3358 napi_value cb = nullptr;
3359 napi_value result = nullptr;
3360 napi_create_function(env, funcName.c_str(), funcName.size(), Task::RemoveDependency, nullptr, &cb);
3361 task->hasDependency_ = false;
3362 napi_call_function(env, thisValue, cb, 1, argv, &result);
3363 napi_value exception = nullptr;
3364 napi_get_and_clear_last_exception(env, &exception);
3365 ASSERT_TRUE(exception != nullptr);
3366
3367 task->hasDependency_ = true;
3368 task->isPeriodicTask_ = true;
3369 napi_call_function(env, thisValue, cb, 1, argv, &result);
3370 napi_get_and_clear_last_exception(env, &exception);
3371 ASSERT_TRUE(exception != nullptr);
3372
3373 task->isPeriodicTask_ = false;
3374 task->taskType_ = TaskType::COMMON_TASK;
3375 napi_call_function(env, thisValue, cb, 1, argv, &result);
3376 napi_get_and_clear_last_exception(env, &exception);
3377 ASSERT_TRUE(exception != nullptr);
3378
3379 task->taskType_ = TaskType::TASK;
3380 napi_call_function(env, thisValue, cb, 1, argv, &result);
3381 napi_get_and_clear_last_exception(env, &exception);
3382 ASSERT_TRUE(exception != nullptr);
3383 }
3384
3385 HWTEST_F(NativeEngineTest, TaskpoolTest179, testing::ext::TestSize.Level0)
3386 {
3387 napi_env env = (napi_env)engine_;
3388 napi_value thisValue = CreateTaskObject(env);
3389 Task* task = nullptr;
3390 napi_unwrap(env, thisValue, reinterpret_cast<void**>(&task));
3391
3392 napi_value dependentTask = CreateTaskObject(env);
3393 Task* task1 = nullptr;
3394 napi_unwrap(env, dependentTask, reinterpret_cast<void**>(&task1));
3395 napi_value argv[] = { dependentTask };
3396 std::string funcName = "RemoveDependency";
3397 napi_value cb = nullptr;
3398 napi_value result = nullptr;
3399 napi_create_function(env, funcName.c_str(), funcName.size(), Task::RemoveDependency, nullptr, &cb);
3400 task->hasDependency_ = true;
3401 task->isPeriodicTask_ = false;
3402 task->taskType_ = TaskType::TASK;
3403 task1->hasDependency_ = false;
3404 napi_call_function(env, thisValue, cb, 1, argv, &result);
3405 napi_value exception = nullptr;
3406 napi_get_and_clear_last_exception(env, &exception);
3407 ASSERT_TRUE(exception != nullptr);
3408
3409 task1->hasDependency_ = true;
3410 task1->isPeriodicTask_ = true;
3411 napi_call_function(env, thisValue, cb, 1, argv, &result);
3412 napi_get_and_clear_last_exception(env, &exception);
3413 ASSERT_TRUE(exception != nullptr);
3414
3415 task1->isPeriodicTask_ = false;
3416 task1->taskType_ = TaskType::COMMON_TASK;
3417 napi_call_function(env, thisValue, cb, 1, argv, &result);
3418 napi_get_and_clear_last_exception(env, &exception);
3419 ASSERT_TRUE(exception != nullptr);
3420
3421 task1->taskType_ = TaskType::TASK;
3422 napi_call_function(env, thisValue, cb, 1, argv, &result);
3423 napi_get_and_clear_last_exception(env, &exception);
3424 ASSERT_TRUE(exception != nullptr);
3425
3426 task->taskType_ = TaskType::ASYNCRUNNER_TASK;
3427 napi_call_function(env, thisValue, cb, 1, argv, &result);
3428 napi_get_and_clear_last_exception(env, &exception);
3429 ASSERT_TRUE(exception != nullptr);
3430 }
3431
3432 HWTEST_F(NativeEngineTest, TaskpoolTest180, testing::ext::TestSize.Level0)
3433 {
3434 napi_env env = (napi_env)engine_;
3435 napi_value thisValue = CreateTaskObject(env);
3436 Task* task = nullptr;
3437 napi_unwrap(env, thisValue, reinterpret_cast<void**>(&task));
3438
3439 napi_value dependentTask = CreateTaskObject(env);
3440 Task* task1 = nullptr;
3441 napi_unwrap(env, dependentTask, reinterpret_cast<void**>(&task1));
3442 napi_value argv[] = { dependentTask };
3443 std::string funcName = "RemoveDependency";
3444 napi_value cb = nullptr;
3445 napi_value result = nullptr;
3446 napi_create_function(env, funcName.c_str(), funcName.size(), Task::RemoveDependency, nullptr, &cb);
3447 task->hasDependency_ = true;
3448 task->isPeriodicTask_ = false;
3449 task->taskType_ = TaskType::TASK;
3450 task1->hasDependency_ = true;
3451 task1->isPeriodicTask_ = false;
3452 task1->taskType_ = TaskType::TASK;
3453 task1->hasDependency_ = false;
3454 NativeEngineTest::StoreDependentId(task->taskId_, task1->taskId_);
3455 napi_call_function(env, thisValue, cb, 1, argv, &result);
3456 napi_value exception = nullptr;
3457 napi_get_and_clear_last_exception(env, &exception);
3458 ASSERT_TRUE(exception != nullptr);
3459 }
3460
3461 HWTEST_F(NativeEngineTest, TaskpoolTest181, testing::ext::TestSize.Level0)
3462 {
3463 napi_env env = (napi_env)engine_;
3464 napi_value func = nullptr;
3465 GetSendableFunction(env, "foo", func);
3466 napi_ref callbackRef = Helper::NapiHelper::CreateReference(env, func, 1);
3467 ListenerCallBackInfo* cbInfo = new ListenerCallBackInfo(env, callbackRef, nullptr);
3468
3469 uv_async_t* req = new uv_async_t;
3470 req->data = cbInfo;
3471 Task::StartExecutionCallback(req);
3472 napi_value exception = nullptr;
3473 napi_get_and_clear_last_exception(env, &exception);
3474 ASSERT_TRUE(exception == nullptr);
3475 }
3476
3477 HWTEST_F(NativeEngineTest, TaskpoolTest182, testing::ext::TestSize.Level0)
3478 {
3479 napi_env env = (napi_env)engine_;
3480 ListenerCallBackInfo* cbInfo = new ListenerCallBackInfo(env, nullptr, nullptr);
3481
3482 uv_async_t* req = new uv_async_t;
3483 req->data = cbInfo;
3484 Task::StartExecutionCallback(req);
3485 napi_value exception = nullptr;
3486 napi_get_and_clear_last_exception(env, &exception);
3487 ASSERT_TRUE(exception == nullptr);
3488 }
3489
3490 HWTEST_F(NativeEngineTest, TaskpoolTest183, testing::ext::TestSize.Level0)
3491 {
3492 napi_env env = (napi_env)engine_;
3493 ListenerCallBackInfo* cbInfo = new ListenerCallBackInfo(env, nullptr, nullptr);
3494
3495 Task::ExecuteListenerCallback(cbInfo);
3496 napi_value exception = nullptr;
3497 napi_get_and_clear_last_exception(env, &exception);
3498 ASSERT_TRUE(exception == nullptr);
3499
3500 napi_value func = nullptr;
3501 GetSendableFunction(env, "foo", func);
3502 napi_ref callbackRef = Helper::NapiHelper::CreateReference(env, func, 1);
3503 cbInfo = new ListenerCallBackInfo(env, callbackRef, nullptr);
3504 Task::ExecuteListenerCallback(cbInfo);
3505 napi_get_and_clear_last_exception(env, &exception);
3506 ASSERT_TRUE(exception == nullptr);
3507
3508 napi_value error = NapiHelper::CreateObject(env);
3509 cbInfo = new ListenerCallBackInfo(env, callbackRef, error);
3510 Task::ExecuteListenerCallback(cbInfo);
3511 napi_get_and_clear_last_exception(env, &exception);
3512 ASSERT_TRUE(exception == nullptr);
3513 }
3514
3515 HWTEST_F(NativeEngineTest, TaskpoolTest184, testing::ext::TestSize.Level0)
3516 {
3517 napi_env env = (napi_env)engine_;
3518 napi_value thisValue = CreateTaskObject(env);
3519 Task* task = nullptr;
3520 napi_unwrap(env, thisValue, reinterpret_cast<void**>(&task));
3521
3522 std::string funcName = "OnEnqueued";
3523 napi_value cb = nullptr;
3524 napi_value result = nullptr;
3525 napi_create_function(env, funcName.c_str(), funcName.size(), Task::OnEnqueued, nullptr, &cb);
3526 napi_call_function(env, thisValue, cb, 0, nullptr, &result);
3527 napi_value exception = nullptr;
3528 napi_get_and_clear_last_exception(env, &exception);
3529 ASSERT_TRUE(exception == nullptr);
3530 }
3531
3532 HWTEST_F(NativeEngineTest, TaskpoolTest185, testing::ext::TestSize.Level0)
3533 {
3534 napi_env env = (napi_env)engine_;
3535 napi_value thisValue = CreateTaskObject(env);
3536 Task* task = nullptr;
3537 napi_unwrap(env, thisValue, reinterpret_cast<void**>(&task));
3538
3539 napi_value object = NapiHelper::CreateObject(env);
3540 napi_value argv[1] = { object };
3541 std::string funcName = "OnEnqueued";
3542 napi_value cb = nullptr;
3543 napi_value result = nullptr;
3544 napi_create_function(env, funcName.c_str(), funcName.size(), Task::OnEnqueued, nullptr, &cb);
3545 napi_call_function(env, thisValue, cb, 1, argv, &result);
3546 napi_value exception = nullptr;
3547 napi_get_and_clear_last_exception(env, &exception);
3548 ASSERT_TRUE(exception != nullptr);
3549 }
3550
3551 HWTEST_F(NativeEngineTest, TaskpoolTest186, testing::ext::TestSize.Level0)
3552 {
3553 napi_env env = (napi_env)engine_;
3554 napi_value thisValue = CreateTaskObject(env);
3555 Task* task = nullptr;
3556 napi_unwrap(env, thisValue, reinterpret_cast<void**>(&task));
3557
3558 napi_value func = nullptr;
3559 GetSendableFunction(env, "foo", func);
3560 napi_value argv[1] = { func };
3561 std::string funcName = "OnEnqueued";
3562 napi_value cb = nullptr;
3563 napi_value result = nullptr;
3564 napi_create_function(env, funcName.c_str(), funcName.size(), Task::OnEnqueued, nullptr, &cb);
3565 napi_call_function(env, nullptr, cb, 1, argv, &result);
3566 napi_value exception = nullptr;
3567 napi_get_and_clear_last_exception(env, &exception);
3568 ASSERT_TRUE(exception == nullptr);
3569 }
3570
3571 HWTEST_F(NativeEngineTest, TaskpoolTest187, testing::ext::TestSize.Level0)
3572 {
3573 napi_env env = (napi_env)engine_;
3574 napi_value thisValue = CreateTaskObject(env);
3575 Task* task = nullptr;
3576 napi_unwrap(env, thisValue, reinterpret_cast<void**>(&task));
3577
3578 napi_value func = nullptr;
3579 GetSendableFunction(env, "foo", func);
3580 napi_value argv[1] = { func };
3581 std::string funcName = "OnEnqueued";
3582 napi_value cb = nullptr;
3583 napi_value result = nullptr;
3584 napi_create_function(env, funcName.c_str(), funcName.size(), Task::OnEnqueued, nullptr, &cb);
3585 task->taskState_ = ExecuteState::WAITING;
3586 napi_call_function(env, thisValue, cb, 1, argv, &result);
3587 napi_value exception = nullptr;
3588 napi_get_and_clear_last_exception(env, &exception);
3589 ASSERT_TRUE(exception != nullptr);
3590
3591 task->taskState_ = ExecuteState::NOT_FOUND;
3592 napi_call_function(env, thisValue, cb, 1, argv, &result);
3593 napi_get_and_clear_last_exception(env, &exception);
3594 ASSERT_TRUE(exception != nullptr);
3595 }
3596
3597 HWTEST_F(NativeEngineTest, TaskpoolTest188, testing::ext::TestSize.Level0)
3598 {
3599 napi_env env = (napi_env)engine_;
3600 napi_value thisValue = CreateTaskObject(env);
3601 Task* task = nullptr;
3602 napi_unwrap(env, thisValue, reinterpret_cast<void**>(&task));
3603
3604 std::string funcName = "OnStartExecution";
3605 napi_value cb = nullptr;
3606 napi_value result = nullptr;
3607 napi_create_function(env, funcName.c_str(), funcName.size(), Task::OnStartExecution, nullptr, &cb);
3608 napi_call_function(env, thisValue, cb, 0, nullptr, &result);
3609 napi_value exception = nullptr;
3610 napi_get_and_clear_last_exception(env, &exception);
3611 ASSERT_TRUE(exception == nullptr);
3612 }
3613
3614 HWTEST_F(NativeEngineTest, TaskpoolTest189, testing::ext::TestSize.Level0)
3615 {
3616 napi_env env = (napi_env)engine_;
3617 napi_value thisValue = CreateTaskObject(env);
3618 Task* task = nullptr;
3619 napi_unwrap(env, thisValue, reinterpret_cast<void**>(&task));
3620
3621 napi_value object = NapiHelper::CreateObject(env);
3622 napi_value argv[1] = { object };
3623 std::string funcName = "OnStartExecution";
3624 napi_value cb = nullptr;
3625 napi_value result = nullptr;
3626 napi_create_function(env, funcName.c_str(), funcName.size(), Task::OnStartExecution, nullptr, &cb);
3627 napi_call_function(env, thisValue, cb, 1, argv, &result);
3628 napi_value exception = nullptr;
3629 napi_get_and_clear_last_exception(env, &exception);
3630 ASSERT_TRUE(exception != nullptr);
3631 }
3632
3633 HWTEST_F(NativeEngineTest, TaskpoolTest190, testing::ext::TestSize.Level0)
3634 {
3635 napi_env env = (napi_env)engine_;
3636 napi_value thisValue = CreateTaskObject(env);
3637 Task* task = nullptr;
3638 napi_unwrap(env, thisValue, reinterpret_cast<void**>(&task));
3639
3640 napi_value func = nullptr;
3641 GetSendableFunction(env, "foo", func);
3642 napi_value argv[1] = { func };
3643 std::string funcName = "OnStartExecution";
3644 napi_value cb = nullptr;
3645 napi_value result = nullptr;
3646 napi_create_function(env, funcName.c_str(), funcName.size(), Task::OnStartExecution, nullptr, &cb);
3647 napi_call_function(env, thisValue, cb, 1, argv, &result);
3648 napi_value exception = nullptr;
3649 napi_get_and_clear_last_exception(env, &exception);
3650 ASSERT_TRUE(exception == nullptr);
3651 }
3652
3653 HWTEST_F(NativeEngineTest, TaskpoolTest191, testing::ext::TestSize.Level0)
3654 {
3655 napi_env env = (napi_env)engine_;
3656 napi_value thisValue = CreateTaskObject(env);
3657 Task* task = nullptr;
3658 napi_unwrap(env, thisValue, reinterpret_cast<void**>(&task));
3659
3660 napi_value func = nullptr;
3661 GetSendableFunction(env, "foo", func);
3662 napi_value argv[1] = { func };
3663 std::string funcName = "OnStartExecution";
3664 napi_value cb = nullptr;
3665 napi_value result = nullptr;
3666 napi_create_function(env, funcName.c_str(), funcName.size(), Task::OnStartExecution, nullptr, &cb);
3667 task->taskState_ = ExecuteState::WAITING;
3668 napi_call_function(env, thisValue, cb, 1, argv, &result);
3669 napi_value exception = nullptr;
3670 napi_get_and_clear_last_exception(env, &exception);
3671 ASSERT_TRUE(exception != nullptr);
3672
3673 task->taskState_ = ExecuteState::NOT_FOUND;
3674 task->isMainThreadTask_ = false;
3675 napi_call_function(env, thisValue, cb, 1, argv, &result);
3676 napi_get_and_clear_last_exception(env, &exception);
3677 ASSERT_TRUE(exception != nullptr);
3678
3679 task->isMainThreadTask_ = true;
3680 napi_call_function(env, thisValue, cb, 1, argv, &result);
3681 napi_get_and_clear_last_exception(env, &exception);
3682 ASSERT_TRUE(exception != nullptr);
3683 }
3684
3685 HWTEST_F(NativeEngineTest, TaskpoolTest192, testing::ext::TestSize.Level0)
3686 {
3687 napi_env env = (napi_env)engine_;
3688 napi_value thisValue = CreateTaskObject(env);
3689 Task* task = nullptr;
3690 napi_unwrap(env, thisValue, reinterpret_cast<void**>(&task));
3691
3692 std::string funcName = "OnExecutionFailed";
3693 napi_value cb = nullptr;
3694 napi_value result = nullptr;
3695 napi_create_function(env, funcName.c_str(), funcName.size(), Task::OnExecutionFailed, nullptr, &cb);
3696 napi_call_function(env, thisValue, cb, 0, nullptr, &result);
3697 napi_value exception = nullptr;
3698 napi_get_and_clear_last_exception(env, &exception);
3699 ASSERT_TRUE(exception == nullptr);
3700 }
3701
3702 HWTEST_F(NativeEngineTest, TaskpoolTest193, testing::ext::TestSize.Level0)
3703 {
3704 napi_env env = (napi_env)engine_;
3705 napi_value thisValue = CreateTaskObject(env);
3706 Task* task = nullptr;
3707 napi_unwrap(env, thisValue, reinterpret_cast<void**>(&task));
3708
3709 napi_value object = NapiHelper::CreateObject(env);
3710 napi_value argv[1] = { object };
3711 std::string funcName = "OnExecutionFailed";
3712 napi_value cb = nullptr;
3713 napi_value result = nullptr;
3714 napi_create_function(env, funcName.c_str(), funcName.size(), Task::OnExecutionFailed, nullptr, &cb);
3715 napi_call_function(env, thisValue, cb, 1, argv, &result);
3716 napi_value exception = nullptr;
3717 napi_get_and_clear_last_exception(env, &exception);
3718 ASSERT_TRUE(exception != nullptr);
3719 }
3720
3721 HWTEST_F(NativeEngineTest, TaskpoolTest194, testing::ext::TestSize.Level0)
3722 {
3723 napi_env env = (napi_env)engine_;
3724 napi_value thisValue = CreateTaskObject(env);
3725 Task* task = nullptr;
3726 napi_unwrap(env, thisValue, reinterpret_cast<void**>(&task));
3727
3728 napi_value func = nullptr;
3729 GetSendableFunction(env, "foo", func);
3730 napi_value argv[1] = { func };
3731 std::string funcName = "OnExecutionFailed";
3732 napi_value cb = nullptr;
3733 napi_value result = nullptr;
3734 napi_create_function(env, funcName.c_str(), funcName.size(), Task::OnExecutionFailed, nullptr, &cb);
3735 napi_call_function(env, nullptr, cb, 1, argv, &result);
3736 napi_value exception = nullptr;
3737 napi_get_and_clear_last_exception(env, &exception);
3738 ASSERT_TRUE(exception == nullptr);
3739 }
3740
3741 HWTEST_F(NativeEngineTest, TaskpoolTest195, testing::ext::TestSize.Level0)
3742 {
3743 napi_env env = (napi_env)engine_;
3744 napi_value thisValue = CreateTaskObject(env);
3745 Task* task = nullptr;
3746 napi_unwrap(env, thisValue, reinterpret_cast<void**>(&task));
3747
3748 napi_value func = nullptr;
3749 GetSendableFunction(env, "foo", func);
3750 napi_value argv[1] = { func };
3751 std::string funcName = "OnExecutionFailed";
3752 napi_value cb = nullptr;
3753 napi_value result = nullptr;
3754 napi_create_function(env, funcName.c_str(), funcName.size(), Task::OnExecutionFailed, nullptr, &cb);
3755 task->taskState_ = ExecuteState::WAITING;
3756 napi_call_function(env, thisValue, cb, 1, argv, &result);
3757 napi_value exception = nullptr;
3758 napi_get_and_clear_last_exception(env, &exception);
3759 ASSERT_TRUE(exception != nullptr);
3760
3761 task->taskState_ = ExecuteState::NOT_FOUND;
3762 napi_call_function(env, thisValue, cb, 1, argv, &result);
3763 napi_get_and_clear_last_exception(env, &exception);
3764 ASSERT_TRUE(exception != nullptr);
3765 }
3766
3767 HWTEST_F(NativeEngineTest, TaskpoolTest196, testing::ext::TestSize.Level0)
3768 {
3769 napi_env env = (napi_env)engine_;
3770 napi_value thisValue = CreateTaskObject(env);
3771 Task* task = nullptr;
3772 napi_unwrap(env, thisValue, reinterpret_cast<void**>(&task));
3773
3774 std::string funcName = "OnExecutionSucceeded";
3775 napi_value cb = nullptr;
3776 napi_value result = nullptr;
3777 napi_create_function(env, funcName.c_str(), funcName.size(), Task::OnExecutionSucceeded, nullptr, &cb);
3778 napi_call_function(env, thisValue, cb, 0, nullptr, &result);
3779 napi_value exception = nullptr;
3780 napi_get_and_clear_last_exception(env, &exception);
3781 ASSERT_TRUE(exception == nullptr);
3782 }
3783
3784 HWTEST_F(NativeEngineTest, TaskpoolTest197, testing::ext::TestSize.Level0)
3785 {
3786 napi_env env = (napi_env)engine_;
3787 napi_value thisValue = CreateTaskObject(env);
3788 Task* task = nullptr;
3789 napi_unwrap(env, thisValue, reinterpret_cast<void**>(&task));
3790
3791 napi_value object = NapiHelper::CreateObject(env);
3792 napi_value argv[1] = { object };
3793 std::string funcName = "OnExecutionSucceeded";
3794 napi_value cb = nullptr;
3795 napi_value result = nullptr;
3796 napi_create_function(env, funcName.c_str(), funcName.size(), Task::OnExecutionSucceeded, nullptr, &cb);
3797 napi_call_function(env, thisValue, cb, 1, argv, &result);
3798 napi_value exception = nullptr;
3799 napi_get_and_clear_last_exception(env, &exception);
3800 ASSERT_TRUE(exception != nullptr);
3801 }
3802
3803 HWTEST_F(NativeEngineTest, TaskpoolTest198, testing::ext::TestSize.Level0)
3804 {
3805 napi_env env = (napi_env)engine_;
3806 napi_value thisValue = CreateTaskObject(env);
3807 Task* task = nullptr;
3808 napi_unwrap(env, thisValue, reinterpret_cast<void**>(&task));
3809
3810 napi_value func = nullptr;
3811 GetSendableFunction(env, "foo", func);
3812 napi_value argv[1] = { func };
3813 std::string funcName = "OnExecutionSucceeded";
3814 napi_value cb = nullptr;
3815 napi_value result = nullptr;
3816 napi_create_function(env, funcName.c_str(), funcName.size(), Task::OnExecutionSucceeded, nullptr, &cb);
3817 napi_call_function(env, nullptr, cb, 1, argv, &result);
3818 napi_value exception = nullptr;
3819 napi_get_and_clear_last_exception(env, &exception);
3820 ASSERT_TRUE(exception == nullptr);
3821 }
3822
3823 HWTEST_F(NativeEngineTest, TaskpoolTest199, testing::ext::TestSize.Level0)
3824 {
3825 napi_env env = (napi_env)engine_;
3826 napi_value thisValue = CreateTaskObject(env);
3827 Task* task = nullptr;
3828 napi_unwrap(env, thisValue, reinterpret_cast<void**>(&task));
3829
3830 napi_value func = nullptr;
3831 GetSendableFunction(env, "foo", func);
3832 napi_value argv[1] = { func };
3833 std::string funcName = "OnExecutionSucceeded";
3834 napi_value cb = nullptr;
3835 napi_value result = nullptr;
3836 napi_create_function(env, funcName.c_str(), funcName.size(), Task::OnExecutionSucceeded, nullptr, &cb);
3837 task->taskState_ = ExecuteState::WAITING;
3838 napi_call_function(env, thisValue, cb, 1, argv, &result);
3839 napi_value exception = nullptr;
3840 napi_get_and_clear_last_exception(env, &exception);
3841 ASSERT_TRUE(exception != nullptr);
3842
3843 task->taskState_ = ExecuteState::NOT_FOUND;
3844 napi_call_function(env, thisValue, cb, 1, argv, &result);
3845 napi_get_and_clear_last_exception(env, &exception);
3846 ASSERT_TRUE(exception != nullptr);
3847 }
3848
3849 HWTEST_F(NativeEngineTest, TaskpoolTest200, testing::ext::TestSize.Level0)
3850 {
3851 napi_env env = (napi_env)engine_;
3852 napi_value thisValue = CreateTaskObject(env);
3853 Task* task = nullptr;
3854 napi_unwrap(env, thisValue, reinterpret_cast<void**>(&task));
3855
3856 std::string funcName = "IsDone";
3857 napi_value cb = nullptr;
3858 napi_value result = nullptr;
3859 napi_create_function(env, funcName.c_str(), funcName.size(), Task::IsDone, nullptr, &cb);
3860 napi_call_function(env, nullptr, cb, 0, nullptr, &result);
3861 napi_value exception = nullptr;
3862 napi_get_and_clear_last_exception(env, &exception);
3863 ASSERT_TRUE(exception == nullptr);
3864 }
3865
3866 HWTEST_F(NativeEngineTest, TaskpoolTest201, testing::ext::TestSize.Level0)
3867 {
3868 napi_env env = (napi_env)engine_;
3869 napi_value thisValue = CreateTaskObject(env);
3870 Task* task = nullptr;
3871 napi_unwrap(env, thisValue, reinterpret_cast<void**>(&task));
3872
3873 std::string funcName = "IsDone";
3874 napi_value cb = nullptr;
3875 napi_value result = nullptr;
3876 napi_create_function(env, funcName.c_str(), funcName.size(), Task::IsDone, nullptr, &cb);
3877 task->taskState_ = ExecuteState::WAITING;
3878 napi_call_function(env, thisValue, cb, 0, nullptr, &result);
3879 napi_value exception = nullptr;
3880 napi_get_and_clear_last_exception(env, &exception);
3881 ASSERT_TRUE(exception == nullptr);
3882
3883 task->taskState_ = ExecuteState::FINISHED;
3884 napi_call_function(env, thisValue, cb, 0, nullptr, &result);
3885 napi_get_and_clear_last_exception(env, &exception);
3886 ASSERT_TRUE(exception == nullptr);
3887
3888 task->taskState_ = ExecuteState::ENDING;
3889 napi_call_function(env, thisValue, cb, 0, nullptr, &result);
3890 napi_get_and_clear_last_exception(env, &exception);
3891 ASSERT_TRUE(exception == nullptr);
3892 }
3893
3894 HWTEST_F(NativeEngineTest, TaskpoolTest202, testing::ext::TestSize.Level0)
3895 {
3896 napi_env env = (napi_env)engine_;
3897 napi_value thisValue = CreateTaskObject(env);
3898 Task* task = nullptr;
3899 napi_unwrap(env, thisValue, reinterpret_cast<void**>(&task));
3900 NativeEngineTest::StoreTaskDuration(task->taskId_);
3901 std::string funcName = "GetTotalDuration";
3902 napi_value cb = nullptr;
3903 napi_value result = nullptr;
3904 napi_create_function(env, funcName.c_str(), funcName.size(), Task::GetTotalDuration, nullptr, &cb);
3905 napi_call_function(env, thisValue, cb, 0, nullptr, &result);
3906 napi_value exception = nullptr;
3907 napi_get_and_clear_last_exception(env, &exception);
3908 ASSERT_TRUE(exception == nullptr);
3909
3910 funcName = "GetCPUDuration";
3911 cb = nullptr;
3912 napi_create_function(env, funcName.c_str(), funcName.size(), Task::GetCPUDuration, nullptr, &cb);
3913 napi_call_function(env, thisValue, cb, 0, nullptr, &result);
3914 napi_get_and_clear_last_exception(env, &exception);
3915 ASSERT_TRUE(exception == nullptr);
3916
3917 funcName = "GetIODuration";
3918 cb = nullptr;
3919 napi_create_function(env, funcName.c_str(), funcName.size(), Task::GetIODuration, nullptr, &cb);
3920 napi_call_function(env, thisValue, cb, 0, nullptr, &result);
3921 napi_get_and_clear_last_exception(env, &exception);
3922 ASSERT_TRUE(exception == nullptr);
3923 }
3924
3925 HWTEST_F(NativeEngineTest, TaskpoolTest203, testing::ext::TestSize.Level0)
3926 {
3927 Task* task = new Task();
3928 task->IncreaseRefCount();
3929 task->DecreaseRefCount();
3930 task->taskType_ = TaskType::COMMON_TASK;
3931 ASSERT_TRUE(task->IsRepeatableTask());
3932 task->taskType_ = TaskType::GROUP_COMMON_TASK;
3933 ASSERT_TRUE(task->IsRepeatableTask());
3934 task->taskType_ = TaskType::GROUP_FUNCTION_TASK;
3935 ASSERT_TRUE(task->IsRepeatableTask());
3936 task->taskType_ = TaskType::TASK;
3937 ASSERT_TRUE(!task->IsRepeatableTask());
3938 delete task;
3939 }
3940
3941 HWTEST_F(NativeEngineTest, TaskpoolTest204, testing::ext::TestSize.Level0)
3942 {
3943 napi_env env = (napi_env)engine_;
3944 Task* task = new Task();
3945 task->taskId_ = TaskManager::GetInstance().CalculateTaskId(reinterpret_cast<uint64_t>(task));
3946 napi_value thisValue = NapiHelper::CreateObject(env);
3947 napi_ref ref = NapiHelper::CreateReference(env, thisValue, 0);
3948 task->taskRef_ = ref;
3949 TaskInfo* taskInfo = new TaskInfo();
3950 task->pendingTaskInfos_.push_back(taskInfo);
3951 task->NotifyPendingTask();
3952 napi_value exception = nullptr;
3953 napi_get_and_clear_last_exception(env, &exception);
3954 ASSERT_TRUE(exception == nullptr);
3955 delete task;
3956 }
3957
3958 HWTEST_F(NativeEngineTest, TaskpoolTest205, testing::ext::TestSize.Level0)
3959 {
3960 napi_env env = (napi_env)engine_;
3961 Task* task = new Task();
3962 task->taskId_ = TaskManager::GetInstance().CalculateTaskId(reinterpret_cast<uint64_t>(task));
3963 napi_value thisValue = NapiHelper::CreateObject(env);
3964 napi_ref ref = NapiHelper::CreateReference(env, thisValue, 0);
3965 task->taskRef_ = ref;
3966 TaskInfo* taskInfo = new TaskInfo();
3967 napi_value promise = NapiHelper::CreatePromise(env, &taskInfo->deferred);
3968 task->pendingTaskInfos_.push_back(taskInfo);
3969 task->isPeriodicTask_ = false;
3970 task->CancelPendingTask(env);
3971 napi_value exception = nullptr;
3972 napi_get_and_clear_last_exception(env, &exception);
3973 ASSERT_TRUE(exception == nullptr);
3974
3975 TaskInfo* taskInfo1 = new TaskInfo();
3976 napi_value promise1 = NapiHelper::CreatePromise(env, &taskInfo1->deferred);
3977 task->pendingTaskInfos_.push_back(taskInfo1);
3978 task->isPeriodicTask_ = true;
3979 task->CancelPendingTask(env);
3980 napi_get_and_clear_last_exception(env, &exception);
3981 ASSERT_TRUE(exception == nullptr);
3982 delete task;
3983 }
3984
3985 HWTEST_F(NativeEngineTest, TaskpoolTest206, testing::ext::TestSize.Level0)
3986 {
3987 napi_env env = (napi_env)engine_;
3988 Task* task = new Task();
3989 task->taskId_ = TaskManager::GetInstance().CalculateTaskId(reinterpret_cast<uint64_t>(task));
3990 napi_value thisValue = NapiHelper::CreateObject(env);
3991 napi_ref ref = NapiHelper::CreateReference(env, thisValue, 0);
3992 task->taskRef_ = ref;
3993 TaskInfo* taskInfo = new TaskInfo();
3994 task->taskType_ = TaskType::GROUP_FUNCTION_TASK;
3995 task->currentTaskInfo_ = taskInfo;
3996 task->taskRefCount_ = 1;
3997 Worker* worker = reinterpret_cast<Worker*>(NativeEngineTest::WorkerConstructor(env));
3998 task->worker_ = worker;
3999
4000 napi_value func = nullptr;
4001 napi_value args = nullptr;
4002 task->DeserializeValue(env, &func, &args);
4003 napi_value exception = nullptr;
4004 napi_get_and_clear_last_exception(env, &exception);
4005 ASSERT_TRUE(exception == nullptr);
4006
4007 task->startTime_ = task->taskId_;
4008 task->ioTime_ = task->taskId_;
4009 task->StoreTaskDuration();
4010 napi_get_and_clear_last_exception(env, &exception);
4011 ASSERT_TRUE(exception == nullptr);
4012 delete task;
4013 }
4014
4015 HWTEST_F(NativeEngineTest, TaskpoolTest207, testing::ext::TestSize.Level0)
4016 {
4017 napi_env env = (napi_env)engine_;
4018 Task* task = new Task();
4019 task->taskId_ = TaskManager::GetInstance().CalculateTaskId(reinterpret_cast<uint64_t>(task));
4020 task->taskType_ = TaskType::SEQRUNNER_TASK;
4021 task->hasDependency_ = false;
4022 task->isPeriodicTask_ = false;
4023 task->CanForSequenceRunner(env);
4024 napi_value exception = nullptr;
4025 napi_get_and_clear_last_exception(env, &exception);
4026 ASSERT_TRUE(exception != nullptr);
4027
4028 task->taskType_ = TaskType::COMMON_TASK;
4029 task->CanForSequenceRunner(env);
4030 napi_get_and_clear_last_exception(env, &exception);
4031 ASSERT_TRUE(exception != nullptr);
4032 delete task;
4033 }
4034
4035 HWTEST_F(NativeEngineTest, TaskpoolTest208, testing::ext::TestSize.Level0)
4036 {
4037 napi_env env = (napi_env)engine_;
4038 Task* task = new Task();
4039 task->taskId_ = TaskManager::GetInstance().CalculateTaskId(reinterpret_cast<uint64_t>(task));
4040 task->hasDependency_ = false;
4041 task->isPeriodicTask_ = true;
4042 task->CanForTaskGroup(env);
4043 napi_value exception = nullptr;
4044 napi_get_and_clear_last_exception(env, &exception);
4045 ASSERT_TRUE(exception != nullptr);
4046
4047 task->isPeriodicTask_ = false;
4048 task->taskType_ = TaskType::COMMON_TASK;
4049 task->CanForTaskGroup(env);
4050 napi_get_and_clear_last_exception(env, &exception);
4051 ASSERT_TRUE(exception != nullptr);
4052
4053 task->taskType_ = TaskType::SEQRUNNER_TASK;
4054 task->CanForTaskGroup(env);
4055 napi_get_and_clear_last_exception(env, &exception);
4056 ASSERT_TRUE(exception != nullptr);
4057
4058 task->taskType_ = TaskType::GROUP_COMMON_TASK;
4059 task->CanForTaskGroup(env);
4060 napi_get_and_clear_last_exception(env, &exception);
4061 ASSERT_TRUE(exception != nullptr);
4062
4063 task->taskType_ = TaskType::TASK;
4064 task->isLongTask_ = true;
4065 task->CanForTaskGroup(env);
4066 napi_get_and_clear_last_exception(env, &exception);
4067 ASSERT_TRUE(exception != nullptr);
4068 delete task;
4069 }
4070
4071 HWTEST_F(NativeEngineTest, TaskpoolTest209, testing::ext::TestSize.Level0)
4072 {
4073 napi_env env = (napi_env)engine_;
4074 Task* task = new Task();
4075 task->taskId_ = TaskManager::GetInstance().CalculateTaskId(reinterpret_cast<uint64_t>(task));
4076 task->taskType_ = TaskType::TASK;
4077 task->hasDependency_ = false;
4078 task->isLongTask_ = false;
4079 task->isPeriodicTask_ = true;
4080 task->CanExecute(env);
4081 napi_value exception = nullptr;
4082 napi_get_and_clear_last_exception(env, &exception);
4083 ASSERT_TRUE(exception != nullptr);
4084 delete task;
4085 }
4086
4087 HWTEST_F(NativeEngineTest, TaskpoolTest210, testing::ext::TestSize.Level0)
4088 {
4089 napi_env env = (napi_env)engine_;
4090 Task* task = new Task();
4091 task->taskId_ = TaskManager::GetInstance().CalculateTaskId(reinterpret_cast<uint64_t>(task));
4092 task->taskType_ = TaskType::COMMON_TASK;
4093 task->hasDependency_ = true;
4094 task->CanExecuteDelayed(env);
4095 napi_value exception = nullptr;
4096 napi_get_and_clear_last_exception(env, &exception);
4097 ASSERT_TRUE(exception != nullptr);
4098
4099 task->taskType_ = TaskType::FUNCTION_TASK;
4100 task->isLongTask_ = true;
4101 task->hasDependency_ = false;
4102 task->CanExecuteDelayed(env);
4103 napi_get_and_clear_last_exception(env, &exception);
4104 ASSERT_TRUE(exception != nullptr);
4105
4106 task->taskType_ = TaskType::TASK;
4107 task->isPeriodicTask_ = true;
4108 task->CanExecuteDelayed(env);
4109 napi_get_and_clear_last_exception(env, &exception);
4110 ASSERT_TRUE(exception != nullptr);
4111 delete task;
4112 }
4113
4114 HWTEST_F(NativeEngineTest, TaskpoolTest211, testing::ext::TestSize.Level0)
4115 {
4116 napi_env env = (napi_env)engine_;
4117 Task* task = new Task();
4118 task->taskId_ = TaskManager::GetInstance().CalculateTaskId(reinterpret_cast<uint64_t>(task));
4119 task->taskType_ = TaskType::COMMON_TASK;
4120 task->isPeriodicTask_ = false;
4121 task->CanExecutePeriodically(env);
4122 napi_value exception = nullptr;
4123 napi_get_and_clear_last_exception(env, &exception);
4124 ASSERT_TRUE(exception != nullptr);
4125
4126 task->taskType_ = TaskType::COMMON_TASK;
4127 task->isPeriodicTask_ = true;
4128 task->CanExecutePeriodically(env);
4129 napi_get_and_clear_last_exception(env, &exception);
4130 ASSERT_TRUE(exception != nullptr);
4131
4132 task->taskType_ = TaskType::TASK;
4133 task->isPeriodicTask_ = true;
4134 task->CanExecutePeriodically(env);
4135 napi_get_and_clear_last_exception(env, &exception);
4136 ASSERT_TRUE(exception != nullptr);
4137
4138 task->taskType_ = TaskType::TASK;
4139 task->isPeriodicTask_ = false;
4140 task->hasDependency_ = true;
4141 task->CanExecutePeriodically(env);
4142 napi_get_and_clear_last_exception(env, &exception);
4143 ASSERT_TRUE(exception != nullptr);
4144 delete task;
4145 }
4146
4147 HWTEST_F(NativeEngineTest, TaskpoolTest212, testing::ext::TestSize.Level0)
4148 {
4149 napi_env env = (napi_env)engine_;
4150 Task* task = new Task();
4151 task->taskId_ = TaskManager::GetInstance().CalculateTaskId(reinterpret_cast<uint64_t>(task));
4152 uv_loop_t* loop = NapiHelper::GetLibUV(env);
4153 uv_update_time(loop);
4154 uv_timer_t* timer = new uv_timer_t;
4155 uv_timer_init(loop, timer);
4156 TaskMessage* taskMessage = new TaskMessage();
4157 taskMessage->priority = Priority::DEFAULT;
4158 taskMessage->taskId = task->taskId_;
4159 napi_value promise = NapiHelper::CreatePromise(env, &taskMessage->deferred);
4160 timer->data = taskMessage;
4161 task->delayedTimers_.insert(nullptr);
4162 task->delayedTimers_.insert(timer);
4163 task->ClearDelayedTimers();
4164 napi_value exception = nullptr;
4165 napi_get_and_clear_last_exception(env, &exception);
4166 ASSERT_TRUE(exception == nullptr);
4167 delete task;
4168 }
4169
4170 HWTEST_F(NativeEngineTest, TaskpoolTest213, testing::ext::TestSize.Level0)
4171 {
4172 napi_env env = (napi_env)engine_;
4173 Task* task = new Task();
4174 task->taskId_ = TaskManager::GetInstance().CalculateTaskId(reinterpret_cast<uint64_t>(task));
4175 task->TryClearHasDependency();
4176 napi_value exception = nullptr;
4177 napi_get_and_clear_last_exception(env, &exception);
4178 ASSERT_TRUE(exception == nullptr);
4179
4180 NativeEngineTest::StoreDependentId(task->taskId_, task->taskId_);
4181 task->TryClearHasDependency();
4182 napi_get_and_clear_last_exception(env, &exception);
4183 ASSERT_TRUE(exception == nullptr);
4184
4185 Task* task1 = new Task();
4186 task1->taskId_ = TaskManager::GetInstance().CalculateTaskId(reinterpret_cast<uint64_t>(task1));
4187 NativeEngineTest::StoreDependentTaskId(task1->taskId_, task1->taskId_);
4188 task1->TryClearHasDependency();
4189 napi_get_and_clear_last_exception(env, &exception);
4190 ASSERT_TRUE(exception == nullptr);
4191
4192 NativeEngineTest::StoreDependentId(task1->taskId_, task1->taskId_);
4193 task1->TryClearHasDependency();
4194 napi_get_and_clear_last_exception(env, &exception);
4195 ASSERT_TRUE(exception == nullptr);
4196 delete task;
4197 }
4198
4199 HWTEST_F(NativeEngineTest, TaskpoolTest214, testing::ext::TestSize.Level0)
4200 {
4201 napi_env env = (napi_env)engine_;
4202 NativeEngineTest::InitTaskManager(env);
4203 NativeEngineTest::NotifyDependencyTaskInfo(env);
4204 NativeEngineTest::StoreTaskDependency(env);
4205 NativeEngineTest::RemoveTaskDependency(env);
4206 NativeEngineTest::ReleaseTaskData(env);
4207 NativeEngineTest::CheckTask(env);
4208 NativeEngineTest::CancelGroupTask(env);
4209 NativeEngineTest::TriggerSeqRunner(env);
4210 NativeEngineTest::UpdateGroupState(env);
4211 napi_value exception = nullptr;
4212 napi_get_and_clear_last_exception(env, &exception);
4213 ASSERT_TRUE(exception != nullptr);
4214 }
4215
4216 HWTEST_F(NativeEngineTest, TaskpoolTest215, testing::ext::TestSize.Level0)
4217 {
4218 napi_env env = (napi_env)engine_;
4219 ExceptionScope scope(env);
4220 std::string func = "SeqRunnerConstructor";
4221 napi_value callback = nullptr;
4222 napi_value result = nullptr;
4223 napi_create_function(env, func.c_str(), func.size(), SequenceRunner::SeqRunnerConstructor, nullptr, &callback);
4224 napi_value argv[2] = {nullptr};
4225 napi_create_string_utf8(env, "seq04", NAPI_AUTO_LENGTH, &argv[0]);
4226 napi_create_uint32(env, 5, &argv[1]);
4227 result = nullptr;
4228 napi_call_function(env, nullptr, callback, 2, argv, &result);
4229 ASSERT_EQ(result, nullptr);
4230 napi_value exception = nullptr;
4231 napi_get_and_clear_last_exception(env, &exception);
4232
4233 napi_value argv1[1] = {nullptr};
4234 napi_create_string_utf8(env, "seq05", NAPI_AUTO_LENGTH, &argv1[0]);
4235
4236 result = nullptr;
4237 napi_call_function(env, nullptr, callback, 1, argv1, &result);
4238 ASSERT_NE(result, nullptr);
4239 exception = nullptr;
4240 napi_get_and_clear_last_exception(env, &exception);
4241
4242 napi_value argv2[1] = {nullptr};
4243 napi_create_uint32(env, 5, &argv2[0]);
4244 result = nullptr;
4245 napi_call_function(env, nullptr, callback, 1, argv2, &result);
4246 ASSERT_EQ(result, nullptr);
4247 exception = nullptr;
4248 napi_get_and_clear_last_exception(env, &exception);
4249
4250 napi_value argv3[1] = {nullptr};
4251 result = nullptr;
4252 napi_call_function(env, nullptr, callback, 1, argv3, &result);
4253 ASSERT_EQ(result, nullptr);
4254 exception = nullptr;
4255 napi_get_and_clear_last_exception(env, &exception);
4256
4257 napi_value argv4[1] = {nullptr};
4258 napi_create_string_utf8(env, "seq05", NAPI_AUTO_LENGTH, &argv4[0]);
4259 result = nullptr;
4260 napi_call_function(env, nullptr, callback, 1, argv4, &result);
4261 ASSERT_NE(result, nullptr);
4262 }
4263
4264 HWTEST_F(NativeEngineTest, TaskpoolTest216, testing::ext::TestSize.Level0)
4265 {
4266 napi_env env = (napi_env)engine_;
4267 ExceptionScope scope(env);
4268 std::string func = "SeqRunnerConstructor";
4269 napi_value SeqCallback = nullptr;
4270 napi_value SeqResult = nullptr;
4271 napi_create_function(env, func.c_str(), func.size(), SequenceRunner::SeqRunnerConstructor, nullptr, &SeqCallback);
4272 napi_value SeqArgv[1] = {nullptr};
4273 napi_create_string_utf8(env, "seq06", NAPI_AUTO_LENGTH, &SeqArgv[0]);
4274 napi_call_function(env, nullptr, SeqCallback, 1, SeqArgv, &SeqResult);
4275
4276 std::string funcName = "Execute";
4277 napi_value callback = nullptr;
4278 napi_value result = nullptr;
4279 napi_create_function(env, funcName.c_str(), funcName.size(), SequenceRunner::Execute, nullptr, &callback);
4280
4281 napi_value napiSeqRunnerId = NapiHelper::GetNameProperty(env, SeqResult, "seqRunnerId");
4282 uint64_t seqId = NapiHelper::GetUint64Value(env, napiSeqRunnerId);
4283 SequenceRunner seq;
4284 SequenceRunnerManager::GetInstance().StoreSequenceRunner(seqId, &seq);
4285
4286 napi_value thisValue = NapiHelper::CreateObject(env);
4287 napi_value num = nullptr;
4288 napi_create_uint32(env, 1, &num);
4289 napi_set_named_property(env, thisValue, "taskId", num);
4290 napi_value argv[] = {thisValue};
4291 napi_call_function(env, nullptr, callback, 1, argv, &result);
4292 ASSERT_EQ(result, nullptr);
4293 napi_value exception = nullptr;
4294 napi_get_and_clear_last_exception(env, &exception);
4295
4296 thisValue = CreateTaskObject(env, TaskType::COMMON_TASK);
4297 napi_value argv1[] = {thisValue};
4298 napi_call_function(env, nullptr, callback, 1, argv1, &result);
4299 ASSERT_EQ(result, nullptr);
4300 exception = nullptr;
4301 napi_get_and_clear_last_exception(env, &exception);
4302
4303 SequenceRunner seq1;
4304 seq1.currentTaskId_ = 1;
4305 NativeEngineTest::RemoveSequenceRunner(seqId);
4306 SequenceRunnerManager::GetInstance().StoreSequenceRunner(seqId, &seq1);
4307 thisValue = CreateTaskObject(env);
4308 napi_value argv2[] = {thisValue};
4309 napi_call_function(env, nullptr, callback, 1, argv2, &result);
4310 ASSERT_NE(result, nullptr);
4311 }
4312
4313 HWTEST_F(NativeEngineTest, TaskpoolTest217, testing::ext::TestSize.Level0)
4314 {
4315 napi_env env = (napi_env)engine_;
4316 NativeEngineTest::NotifyHandleTaskResult(env);
4317 napi_value exception = nullptr;
4318 napi_get_and_clear_last_exception(env, &exception);
4319 ASSERT_TRUE(exception == nullptr);
4320 }
4321
4322 HWTEST_F(NativeEngineTest, TaskpoolTest217_1, testing::ext::TestSize.Level0)
4323 {
4324 napi_env env = (napi_env)engine_;
4325 NativeEngineTest::TaskResultCallback(env);
4326 napi_value exception = nullptr;
4327 napi_get_and_clear_last_exception(env, &exception);
4328 ASSERT_TRUE(exception == nullptr);
4329 }
4330
4331 HWTEST_F(NativeEngineTest, TaskpoolTest217_2, testing::ext::TestSize.Level0)
4332 {
4333 napi_env env = (napi_env)engine_;
4334 NativeEngineTest::HandleFunctionException(env);
4335 napi_value exception = nullptr;
4336 napi_get_and_clear_last_exception(env, &exception);
4337 ASSERT_TRUE(exception == nullptr);
4338 }
4339
4340 HWTEST_F(NativeEngineTest, TaskpoolTest217_3, testing::ext::TestSize.Level0)
4341 {
4342 napi_env env = (napi_env)engine_;
4343 NativeEngineTest::DebuggerOnPostTask(env);
4344 napi_value exception = nullptr;
4345 napi_get_and_clear_last_exception(env, &exception);
4346 ASSERT_TRUE(exception == nullptr);
4347 }
4348
4349 HWTEST_F(NativeEngineTest, TaskpoolTest217_4, testing::ext::TestSize.Level0)
4350 {
4351 napi_env env = (napi_env)engine_;
4352 NativeEngineTest::ReleaseWorkerHandles(env);
4353 napi_value exception = nullptr;
4354 napi_get_and_clear_last_exception(env, &exception);
4355 ASSERT_TRUE(exception == nullptr);
4356 }
4357
4358 HWTEST_F(NativeEngineTest, TaskpoolTest218, testing::ext::TestSize.Level0)
4359 {
4360 napi_env env = (napi_env)engine_;
4361 ExceptionScope scope(env);
4362 napi_value exception = nullptr;
4363 napi_value thisVar = NapiHelper::CreateObject(env);
4364 napi_value taskGroupResult = GeneratorTaskGroup(env, thisVar);
4365 napi_value napiGroupId = NapiHelper::GetNameProperty(env, taskGroupResult, "groupId");
4366 uint64_t groupId = NapiHelper::GetUint64Value(env, napiGroupId);
4367
4368 TaskGroupManager& taskGroupManager = TaskGroupManager::GetInstance();
4369 TaskGroup* group = taskGroupManager.GetTaskGroup(groupId);
4370 GroupInfo* groupInfo = new GroupInfo();
4371 groupInfo->priority = Priority::DEFAULT;
4372 group->currentGroupInfo_ = groupInfo;
4373 group->groupState_ = ExecuteState::FINISHED;
4374 taskGroupManager.StoreTaskGroup(groupId, group);
4375 napi_value result = NativeEngineTest::ExecuteGroup(env, taskGroupResult);
4376 ASSERT_TRUE(result != nullptr);
4377 }
4378
4379 HWTEST_F(NativeEngineTest, TaskpoolTest219, testing::ext::TestSize.Level0)
4380 {
4381 napi_env env = (napi_env)engine_;
4382 ExceptionScope scope(env);
4383 napi_value exception = nullptr;
4384 napi_value thisVar = NapiHelper::CreateObject(env);
4385 napi_value taskGroupResult = GeneratorTaskGroup(env, thisVar);
4386 napi_value napiGroupId = NapiHelper::GetNameProperty(env, taskGroupResult, "groupId");
4387 uint64_t groupId = NapiHelper::GetUint64Value(env, napiGroupId);
4388
4389 TaskGroupManager& taskGroupManager = TaskGroupManager::GetInstance();
4390 TaskGroup* group = taskGroupManager.GetTaskGroup(groupId);
4391 GroupInfo* groupInfo = new GroupInfo();
4392 groupInfo->priority = Priority::DEFAULT;
4393 group->currentGroupInfo_ = groupInfo;
4394 group->groupState_ = ExecuteState::CANCELED;
4395 taskGroupManager.StoreTaskGroup(groupId, group);
4396 napi_value result = NativeEngineTest::ExecuteGroup(env, taskGroupResult);
4397 ASSERT_TRUE(result != nullptr);
4398 }
4399
4400 HWTEST_F(NativeEngineTest, TaskpoolTest220, testing::ext::TestSize.Level0)
4401 {
4402 napi_env env = (napi_env)engine_;
4403 ExceptionScope scope(env);
4404 size_t delayTime = 1000;
4405 napi_value result = nullptr;
4406 napi_value num = nullptr;
4407 napi_value priority = nullptr;
4408 napi_value exception = nullptr;
4409 napi_create_uint32(env, delayTime, &num);
4410 napi_create_uint32(env, 1, &priority);
4411
4412 napi_value obj = CreateTaskObject(env, TaskType::TASK, ExecuteState::FINISHED);
4413 napi_value argv[] = { num, obj, priority };
4414 result = NativeEngineTest::ExecuteDelayed(env, argv, 3);
4415 ASSERT_TRUE(result != nullptr);
4416
4417 obj = CreateTaskObject(env);
4418 napi_value argv1[] = { num, obj, priority };
4419 result = NativeEngineTest::ExecuteDelayed(env, argv1, 3);
4420 ASSERT_TRUE(result != nullptr);
4421 }
4422
4423 HWTEST_F(NativeEngineTest, TaskpoolTest221, testing::ext::TestSize.Level0)
4424 {
4425 napi_env env = (napi_env)engine_;
4426 ExceptionScope scope(env);
4427 size_t delayTime = 1000;
4428 napi_value result = nullptr;
4429 napi_value num = nullptr;
4430 napi_value priority = nullptr;
4431 napi_value exception = nullptr;
4432 napi_create_uint32(env, delayTime, &num);
4433 napi_create_uint32(env, 1, &priority);
4434
4435 napi_value obj = CreateTaskObject(env, TaskType::COMMON_TASK, ExecuteState::FINISHED);
4436 napi_value argv[] = { num, obj, priority };
4437 result = NativeEngineTest::ExecuteDelayed(env, argv, 3);
4438 ASSERT_TRUE(result != nullptr);
4439
4440 obj = CreateTaskObject(env);
4441 napi_value argv1[] = { num, obj, priority };
4442 result = NativeEngineTest::ExecuteDelayed(env, argv1, 3);
4443 ASSERT_TRUE(result != nullptr);
4444 }
4445
4446 HWTEST_F(NativeEngineTest, TaskpoolTest222, testing::ext::TestSize.Level0)
4447 {
4448 napi_env env = (napi_env)engine_;
4449 ExceptionScope scope(env);
4450
4451 napi_value thisValue = CreateTaskObject(env, TaskType::SEQRUNNER_TASK);
4452 napi_value argv[] = {thisValue};
4453 napi_value result = NativeEngineTest::Execute(env, argv, 1);
4454 ASSERT_TRUE(result == nullptr);
4455 napi_value exception = nullptr;
4456 napi_get_and_clear_last_exception(env, &exception);
4457
4458 napi_value obj = NapiHelper::CreateObject(env);
4459 auto group = GeneratorTaskGroup(env, obj);
4460 napi_value argv1[] = {group};
4461 result = NativeEngineTest::Execute(env, argv1, 1);
4462 ASSERT_TRUE(result != nullptr);
4463
4464 napi_value value = nullptr;
__anon57f9c37c0b02(napi_env env, napi_callback_info info) 4465 auto func = [](napi_env env, napi_callback_info info) -> napi_value {
4466 return nullptr;
4467 };
4468 napi_create_function(env, "testFunc", NAPI_AUTO_LENGTH, func, nullptr, &value);
4469 napi_value argv2[] = {value};
4470 result = NativeEngineTest::Execute(env, argv2, 1);
4471 ASSERT_TRUE(result == nullptr);
4472 }
4473
4474 HWTEST_F(NativeEngineTest, TaskpoolTest223, testing::ext::TestSize.Level0)
4475 {
4476 napi_env env = (napi_env)engine_;
4477 ExceptionScope scope(env);
4478 TaskManager &taskManager = TaskManager::GetInstance();
4479 napi_value exception = nullptr;
4480 uv_loop_t* loop = NapiHelper::GetLibUV(env);
4481 uv_update_time(loop);
4482 uv_timer_t* handle = new uv_timer_t;
4483 uv_timer_init(loop, handle);
4484 TaskMessage* taskMessage = new TaskMessage();
4485
4486 napi_value global = NapiHelper::CreateObject(env);
4487 auto napiTask = GeneratorTask(env, global);
4488 Task* task = nullptr;
4489 napi_unwrap(env, napiTask, reinterpret_cast<void**>(&task));
4490 task->taskState_ = ExecuteState::CANCELED;
4491
4492 taskMessage->taskId = task->taskId_;
4493 handle->data = taskMessage;
4494 NativeEngineTest::DelayTask(handle);
4495 ASSERT_TRUE(true);
4496 }
4497
4498 HWTEST_F(NativeEngineTest, TaskpoolTest224, testing::ext::TestSize.Level0)
4499 {
4500 napi_env env = (napi_env)engine_;
4501 ExceptionScope scope(env);
4502 TaskManager &taskManager = TaskManager::GetInstance();
4503 napi_value exception = nullptr;
4504 uv_loop_t* loop = NapiHelper::GetLibUV(env);
4505 uv_update_time(loop);
4506 uv_timer_t* handle = new uv_timer_t;
4507 uv_timer_init(loop, handle);
4508 TaskMessage* taskMessage = new TaskMessage();
4509
4510 napi_value global = NapiHelper::CreateObject(env);
4511 auto napiTask = GeneratorTask(env, global);
4512 Task* task = nullptr;
4513 napi_unwrap(env, napiTask, reinterpret_cast<void**>(&task));
4514 task->taskState_ = ExecuteState::DELAYED;
4515 taskMessage->taskId = task->taskId_;
4516 handle->data = taskMessage;
4517 NativeEngineTest::DelayTask(handle);
4518 ASSERT_TRUE(true);
4519 }
4520
4521 HWTEST_F(NativeEngineTest, TaskpoolTest225, testing::ext::TestSize.Level0)
4522 {
4523 napi_env env = (napi_env)engine_;
4524 ExceptionScope scope(env);
4525 TaskManager &taskManager = TaskManager::GetInstance();
4526 napi_value exception = nullptr;
4527 uv_loop_t* loop = NapiHelper::GetLibUV(env);
4528 uv_update_time(loop);
4529 uv_timer_t* handle = new uv_timer_t;
4530 uv_timer_init(loop, handle);
4531 TaskMessage* taskMessage = new TaskMessage();
4532
4533 napi_value global = NapiHelper::CreateObject(env);
4534 auto napiTask = GeneratorTask(env, global);
4535 Task* task = nullptr;
4536 napi_unwrap(env, napiTask, reinterpret_cast<void**>(&task));
4537 task->taskState_ = ExecuteState::FINISHED;
4538 taskMessage->taskId = task->taskId_;
4539 handle->data = taskMessage;
4540 NativeEngineTest::DelayTask(handle);
4541 ASSERT_TRUE(true);
4542 }
4543
4544 HWTEST_F(NativeEngineTest, TaskpoolTest226, testing::ext::TestSize.Level0)
4545 {
4546 napi_env env = (napi_env)engine_;
4547 ExceptionScope scope(env);
4548 napi_value global = NapiHelper::CreateObject(env);
4549 auto napiTask = GeneratorTask(env, global);
4550 Task* task = nullptr;
4551 napi_unwrap(env, napiTask, reinterpret_cast<void**>(&task));
4552 task->taskType_ = TaskType::GROUP_COMMON_TASK;
4553 TaskPool::HandleTaskResultCallback(task);
4554 ASSERT_TRUE(true);
4555 }
4556
4557 HWTEST_F(NativeEngineTest, TaskpoolTest227, testing::ext::TestSize.Level0)
4558 {
4559 napi_env env = (napi_env)engine_;
4560 ExceptionScope scope(env);
4561
4562 napi_value thisValue = CreateTaskObject(env, TaskType::SEQRUNNER_TASK, ExecuteState::CANCELED);
4563 Task* task = nullptr;
4564 napi_unwrap(env, thisValue, reinterpret_cast<void**>(&task));
4565 TaskInfo* taskInfo = new TaskInfo();
4566 task->currentTaskInfo_ = taskInfo;
4567 task->seqRunnerId_ = 1;
4568 napi_value num = nullptr;
4569 napi_create_uint32(env, 1, &num);
4570 napi_ref callbackRef = Helper::NapiHelper::CreateReference(env, num, 1);
4571 task->onExecutionFailedCallBackInfo_ = new ListenerCallBackInfo(env, callbackRef, nullptr);
4572 TaskPool::HandleTaskResultCallback(task);
4573 ASSERT_TRUE(true);
4574 }
4575
4576 HWTEST_F(NativeEngineTest, TaskpoolTest228, testing::ext::TestSize.Level0)
4577 {
4578 napi_env env = (napi_env)engine_;
4579 ExceptionScope scope(env);
4580
4581 napi_value thisValue = CreateTaskObject(env);
4582 Task* task = nullptr;
4583 napi_unwrap(env, thisValue, reinterpret_cast<void**>(&task));
4584 TaskInfo* taskInfo = new TaskInfo();
4585 task->currentTaskInfo_ = taskInfo;
4586 task->success_ = true;
4587 napi_value num = nullptr;
4588 napi_create_uint32(env, 1, &num);
4589 napi_ref callbackRef = Helper::NapiHelper::CreateReference(env, num, 1);
4590 task->onExecutionSucceededCallBackInfo_ = new ListenerCallBackInfo(env, callbackRef, nullptr);
4591 void* resultData = nullptr;
4592 napi_value undefined = NapiHelper::GetUndefinedValue(env);
4593 napi_status status = napi_serialize_inner(env, num, undefined, undefined,
4594 true, false, &resultData);
4595 task->result_ = resultData;
4596 TaskPool::HandleTaskResultCallback(task);
4597 ASSERT_TRUE(true);
4598 }
4599
4600 HWTEST_F(NativeEngineTest, TaskpoolTest229, testing::ext::TestSize.Level0)
4601 {
4602 napi_env env = (napi_env)engine_;
4603 ExceptionScope scope(env);
4604 Task* task = new Task();
4605 uint32_t taskId = TaskManager::GetInstance().CalculateTaskId(reinterpret_cast<uint64_t>(task));
4606 task->taskId_ = taskId;
4607 napi_value thisValue = NapiHelper::CreateObject(env);
4608 napi_ref ref = NapiHelper::CreateReference(env, thisValue, 0);
4609
4610 CallbackInfo* cbInfo = new CallbackInfo(env, 1, ref, task);
4611
4612 Worker* worker = reinterpret_cast<Worker*>(NativeEngineTest::WorkerConstructor(env));
4613 void* args = nullptr;
4614 TaskResultInfo* resultInfo = new TaskResultInfo(nullptr, env, taskId, args);
4615 worker->Enqueue(env, resultInfo);
4616 cbInfo->worker = worker;
4617 TaskPool::ExecuteCallbackTask(cbInfo);
4618 ASSERT_TRUE(true);
4619 }
4620
4621 HWTEST_F(NativeEngineTest, TaskpoolTest230, testing::ext::TestSize.Level0)
4622 {
4623 napi_env env = (napi_env)engine_;
4624 uv_timer_t* handle = new uv_timer_t;
4625 TaskGroupManager& taskGroupManager = TaskGroupManager::GetInstance();
4626
4627 TaskGroup* group = new TaskGroup();
4628 uint64_t groupId = reinterpret_cast<uint64_t>(group);
4629 group->groupId_ = groupId;
4630 Task* task = new Task();
4631 uint32_t taskId = TaskManager::GetInstance().CalculateTaskId(reinterpret_cast<uint64_t>(task));
4632 task->taskId_ = taskId;
4633 task->groupId_ = groupId;
4634
4635 group->taskIds_.push_back(taskId);
4636 handle->data = task;
4637
4638 GroupInfo* groupInfo = new GroupInfo();
4639 groupInfo->priority = Priority::DEFAULT;
4640 napi_value resArr;
4641 napi_create_array_with_length(env, group->taskIds_.size(), &resArr);
4642 napi_ref arrRef = NapiHelper::CreateReference(env, resArr, 1);
4643 groupInfo->resArr = arrRef;
4644 NapiHelper::CreatePromise(env, &groupInfo->deferred);
4645 group->currentGroupInfo_ = groupInfo;
4646 group->taskNum_ = 2;
4647 taskGroupManager.StoreTaskGroup(groupId, group);
4648 napi_value value = NapiHelper::CreateUint64(env, groupId);
4649 napi_ref reference = NapiHelper::CreateReference(env, value, 0);
4650 taskGroupManager.AddTask(groupId, reference, taskId);
4651
4652 napi_value res = nullptr;
4653 napi_create_uint32(env, 1, &res);
4654 NativeEngineTest::UpdateGroupInfoByResult(env, handle, res, true);
4655 ASSERT_TRUE(true);
4656 }
4657
4658 HWTEST_F(NativeEngineTest, TaskpoolTest231, testing::ext::TestSize.Level0)
4659 {
4660 napi_env env = (napi_env)engine_;
4661 ExceptionScope scope(env);
4662 napi_value undefined = NapiHelper::GetUndefinedValue(env);
4663 napi_value thisVar = NapiHelper::CreateObject(env);
4664 napi_value taskGroup = GeneratorTaskGroup(env, thisVar);
4665 napi_value argv[] = {taskGroup};
4666 NativeEngineTest::Cancel(env, argv, 1);
4667 ASSERT_TRUE(true);
4668 }
4669
4670 HWTEST_F(NativeEngineTest, TaskpoolTest232, testing::ext::TestSize.Level0)
4671 {
4672 napi_env env = (napi_env)engine_;
4673 NativeEngineTest::PerformTask(env);
4674 napi_value exception = nullptr;
4675 napi_get_and_clear_last_exception(env, &exception);
4676 ASSERT_TRUE(exception == nullptr);
4677 }
4678
4679 HWTEST_F(NativeEngineTest, TaskpoolTest233, testing::ext::TestSize.Level0)
4680 {
4681 napi_env env = (napi_env)engine_;
4682 Task* task = new Task();
4683 task->SetValid(false);
4684 bool res = task->ShouldDeleteTask();
4685 ASSERT_TRUE(res);
4686 task->SetValid(true);
4687 task->refCount_ = 1;
4688 res = task->ShouldDeleteTask();
4689 ASSERT_TRUE(res == false);
4690 ASSERT_TRUE(task->refCount_ == 0);
4691 }
4692
4693 HWTEST_F(NativeEngineTest, TaskpoolTest234, testing::ext::TestSize.Level0)
4694 {
4695 napi_env env = (napi_env)engine_;
4696 std::string funcName = "GetName";
4697 napi_value cb = nullptr;
4698 napi_value result = nullptr;
4699 napi_create_function(env, funcName.c_str(), funcName.size(), Task::GetName, nullptr, &cb);
4700 napi_call_function(env, nullptr, cb, 0, nullptr, &result);
4701 std::string taskName = NapiHelper::GetString(env, result);
4702 ASSERT_STREQ(taskName.c_str(), "");
4703 napi_value exception = nullptr;
4704 napi_get_and_clear_last_exception(env, &exception);
4705 ASSERT_TRUE(exception == nullptr);
4706 }
4707
4708 HWTEST_F(NativeEngineTest, TaskpoolTest235, testing::ext::TestSize.Level0)
4709 {
4710 napi_env env = (napi_env)engine_;
4711 std::string funcName = "GetTotalDuration";
4712 napi_value cb = nullptr;
4713 napi_value result = nullptr;
4714 napi_create_function(env, funcName.c_str(), funcName.size(), Task::GetTotalDuration, nullptr, &cb);
4715 napi_call_function(env, nullptr, cb, 0, nullptr, &result);
4716 napi_value exception = nullptr;
4717 napi_get_and_clear_last_exception(env, &exception);
4718 ASSERT_TRUE(exception == nullptr);
4719 }
4720
4721 HWTEST_F(NativeEngineTest, TaskpoolTest236, testing::ext::TestSize.Level0)
4722 {
4723 napi_env env = (napi_env)engine_;
4724 napi_value global = NapiHelper::CreateObject(env);
4725 napi_value thisValue = CreateTaskObject(env);
4726
4727 std::string funcName = "GetName";
4728 napi_value cb = nullptr;
4729 napi_value result = nullptr;
4730 napi_create_function(env, funcName.c_str(), funcName.size(), Task::GetName, nullptr, &cb);
4731 napi_call_function(env, thisValue, cb, 0, nullptr, &result);
4732 std::string taskName = NapiHelper::GetString(env, result);
4733 ASSERT_STREQ(taskName.c_str(), "");
4734 napi_value exception = nullptr;
4735 napi_get_and_clear_last_exception(env, &exception);
4736 ASSERT_TRUE(exception == nullptr);
4737 }
4738
4739 HWTEST_F(NativeEngineTest, TaskpoolTest237, testing::ext::TestSize.Level0)
4740 {
4741 napi_env env = (napi_env)engine_;
4742 NativeEngineTest::WorkerPostTask(env);
4743 napi_value exception = nullptr;
4744 napi_get_and_clear_last_exception(env, &exception);
4745 ASSERT_TRUE(exception == nullptr);
4746 }
4747
4748 HWTEST_F(NativeEngineTest, TaskpoolTest238, testing::ext::TestSize.Level0)
4749 {
4750 napi_env env = (napi_env)engine_;
4751 Task* task = new Task();
4752 uint32_t taskId = TaskManager::GetInstance().CalculateTaskId(reinterpret_cast<uint64_t>(task));
4753 task->taskId_ = taskId;
4754 task->isMainThreadTask_ = true;
4755 task->taskType_ = TaskType::FUNCTION_TASK;
4756 napi_value obj = NapiHelper::CreateObject(env);
4757 task->taskRef_ = NapiHelper::CreateReference(env, obj, 1);
4758 Task::TaskDestructor(env, task, nullptr);
4759 napi_value exception = nullptr;
4760 napi_get_and_clear_last_exception(env, &exception);
4761 ASSERT_TRUE(exception == nullptr);
4762 }
4763
4764 HWTEST_F(NativeEngineTest, TaskpoolTest239, testing::ext::TestSize.Level0)
4765 {
4766 napi_env env = (napi_env)engine_;
4767 Task* task = new Task();
4768 uint32_t taskId = TaskManager::GetInstance().CalculateTaskId(reinterpret_cast<uint64_t>(task));
4769 task->taskId_ = taskId;
4770 task->isMainThreadTask_ = false;
4771 task->taskType_ = TaskType::FUNCTION_TASK;
4772 napi_value obj = NapiHelper::CreateObject(env);
4773 task->taskRef_ = NapiHelper::CreateReference(env, obj, 1);
4774 task->refCount_.fetch_add(1);
4775 napi_add_env_cleanup_hook(env, Task::CleanupHookFunc, task);
4776 Task::TaskDestructor(env, task, nullptr);
4777 napi_value exception = nullptr;
4778 napi_get_and_clear_last_exception(env, &exception);
4779 ASSERT_TRUE(exception == nullptr);
4780 }
4781
4782 HWTEST_F(NativeEngineTest, TaskpoolTest240, testing::ext::TestSize.Level0)
4783 {
4784 napi_env env = (napi_env)engine_;
4785 Task::CleanupHookFunc(nullptr);
4786 Task* task = new Task();
4787 uint32_t taskId = TaskManager::GetInstance().CalculateTaskId(reinterpret_cast<uint64_t>(task));
4788 task->taskId_ = taskId;
4789 task->onResultSignal_ = nullptr;
4790 auto loop = NapiHelper::GetLibUV(env);
4791 ConcurrentHelper::UvHandleInit(loop, task->onStartExecutionSignal_, NativeEngineTest::foo, task);
4792 task->taskType_ = TaskType::FUNCTION_TASK;
4793 Task::CleanupHookFunc(task);
4794 napi_value exception = nullptr;
4795 napi_get_and_clear_last_exception(env, &exception);
4796 ASSERT_TRUE(exception == nullptr);
4797 }
4798
4799 HWTEST_F(NativeEngineTest, TaskpoolTest241, testing::ext::TestSize.Level0)
4800 {
4801 napi_env env = (napi_env)engine_;
4802 Task* task = new Task();
4803 uint32_t taskId = TaskManager::GetInstance().CalculateTaskId(reinterpret_cast<uint64_t>(task));
4804 task->taskId_ = taskId;
4805 napi_value obj = NapiHelper::CreateObject(env);
4806 task->GetTaskInfoPromise(env, obj, TaskType::FUNCTION_TASK, Priority::DEFAULT);
4807 napi_value exception = nullptr;
4808 napi_get_and_clear_last_exception(env, &exception);
4809 ASSERT_TRUE(exception == nullptr);
4810 }
4811
4812 HWTEST_F(NativeEngineTest, TaskpoolTest242, testing::ext::TestSize.Level0)
4813 {
4814 napi_env env = (napi_env)engine_;
4815 napi_value func = nullptr;
4816 GetSendableFunction(env, "foo", func);
4817 napi_value argv[1] = { func };
4818 std::string funcName = "OnStartExecution";
4819 napi_value cb = nullptr;
4820 napi_value result = nullptr;
4821 napi_create_function(env, funcName.c_str(), funcName.size(), Task::OnStartExecution, nullptr, &cb);
4822 napi_call_function(env, nullptr, cb, 1, argv, &result);
4823 napi_value exception = nullptr;
4824 napi_get_and_clear_last_exception(env, &exception);
4825 ASSERT_TRUE(exception == nullptr);
4826 }
4827
4828 HWTEST_F(NativeEngineTest, TaskpoolTest243, testing::ext::TestSize.Level0)
4829 {
4830 napi_env env = (napi_env)engine_;
4831 Task* task = new Task();
4832 uint32_t taskId = TaskManager::GetInstance().CalculateTaskId(reinterpret_cast<uint64_t>(task));
4833 task->taskId_ = taskId;
4834 task->taskState_ = ExecuteState::CANCELED;
4835 task->UpdateTask(0, nullptr);
4836 task->isMainThreadTask_ = false;
4837 task->SetValid(false);
4838 task->VerifyAndPostResult(Priority::DEFAULT);
4839 task->SetValid(true);
4840 task->VerifyAndPostResult(Priority::DEFAULT);
4841 task->onResultSignal_ = nullptr;
4842 napi_value exception = nullptr;
4843 napi_get_and_clear_last_exception(env, &exception);
4844 ASSERT_TRUE(exception == nullptr);
4845 }
4846
4847 HWTEST_F(NativeEngineTest, TaskpoolTest244, testing::ext::TestSize.Level0)
4848 {
4849 napi_env env = (napi_env)engine_;
4850 Task* task = new Task();
4851 uint32_t taskId = TaskManager::GetInstance().CalculateTaskId(reinterpret_cast<uint64_t>(task));
4852 task->taskId_ = taskId;
4853 task->isMainThreadTask_ = true;
4854 task->VerifyAndPostResult(Priority::DEFAULT);
4855 napi_value exception = nullptr;
4856 napi_get_and_clear_last_exception(env, &exception);
4857 ASSERT_TRUE(exception == nullptr);
4858 }
4859
4860 HWTEST_F(NativeEngineTest, TaskpoolTest245, testing::ext::TestSize.Level0)
4861 {
4862 napi_env env = (napi_env)engine_;
4863 Task* task = new Task();
4864 uint32_t taskId = TaskManager::GetInstance().CalculateTaskId(reinterpret_cast<uint64_t>(task));
4865 task->taskId_ = taskId;
4866 task->env_ = env;
4867 task->isMainThreadTask_ = false;
4868 task->onStartExecutionSignal_ = nullptr;
4869 task->CheckStartExecution(Priority::DEFAULT);
4870 auto loop = NapiHelper::GetLibUV(env);
4871 ConcurrentHelper::UvHandleInit(loop, task->onStartExecutionSignal_, NativeEngineTest::foo, task);
4872 task->SetValid(false);
4873 task->CheckStartExecution(Priority::DEFAULT);
4874 task->SetValid(true);
4875 task->CheckStartExecution(Priority::DEFAULT);
4876 napi_value exception = nullptr;
4877 napi_get_and_clear_last_exception(env, &exception);
4878 ASSERT_TRUE(exception == nullptr);
4879 }
4880
4881 HWTEST_F(NativeEngineTest, TaskpoolTest246, testing::ext::TestSize.Level0)
4882 {
4883 napi_env env = (napi_env)engine_;
4884 Task* task = new Task();
4885 uint32_t taskId = TaskManager::GetInstance().CalculateTaskId(reinterpret_cast<uint64_t>(task));
4886 task->taskId_ = taskId;
4887 task->env_ = env;
4888 task->isMainThreadTask_ = true;
4889 task->onStartExecutionCallBackInfo_ = nullptr;
4890 task->CheckStartExecution(Priority::DEFAULT);
4891 napi_value exception = nullptr;
4892 napi_get_and_clear_last_exception(env, &exception);
4893 ASSERT_TRUE(exception == nullptr);
4894 }
4895
4896 HWTEST_F(NativeEngineTest, TaskpoolTest247, testing::ext::TestSize.Level0)
4897 {
4898 napi_env env = (napi_env)engine_;
4899 Task* task = new Task();
4900 uint32_t taskId = TaskManager::GetInstance().CalculateTaskId(reinterpret_cast<uint64_t>(task));
4901 task->taskId_ = taskId;
4902 task->env_ = env;
4903 task->isMainThreadTask_ = false;
4904 auto loop = NapiHelper::GetLibUV(env);
4905 ConcurrentHelper::UvHandleInit(loop, task->onStartExecutionSignal_, NativeEngineTest::foo, task);
4906 TaskManager::GetInstance().ReleaseCallBackInfo(task);
4907 napi_value exception = nullptr;
4908 napi_get_and_clear_last_exception(env, &exception);
4909 ASSERT_TRUE(exception == nullptr);
4910 }
4911
4912 HWTEST_F(NativeEngineTest, TaskpoolTest248, testing::ext::TestSize.Level0)
4913 {
4914 napi_env env = (napi_env)engine_;
4915 ExceptionScope scope(env);
4916 std::string func = "SeqRunnerConstructor";
4917 napi_value thisValue = NapiHelper::CreateObject(env);
4918 napi_value SeqCallback = nullptr;
4919 napi_value SeqResult = nullptr;
4920 napi_create_function(env, func.c_str(), func.size(), SequenceRunner::SeqRunnerConstructor, nullptr, &SeqCallback);
4921 napi_value SeqArgv[1] = {nullptr};
4922 napi_create_string_utf8(env, "seq248", NAPI_AUTO_LENGTH, &SeqArgv[0]);
4923 napi_call_function(env, thisValue, SeqCallback, 1, SeqArgv, &SeqResult);
4924
4925 std::string funcName = "Execute";
4926 napi_value callback = nullptr;
4927 napi_value result = nullptr;
4928 napi_create_function(env, funcName.c_str(), funcName.size(), SequenceRunner::Execute, nullptr, &callback);
4929
4930 napi_value task = CreateTaskObject(env);
4931 napi_value argv[] = {task};
4932 napi_call_function(env, thisValue, callback, 1, argv, &result);
4933 ASSERT_NE(result, nullptr);
4934 }
4935
4936 HWTEST_F(NativeEngineTest, TaskpoolTest249, testing::ext::TestSize.Level0)
4937 {
4938 napi_env env = (napi_env)engine_;
4939 ExceptionScope scope(env);
4940 std::string func = "SeqRunnerConstructor";
4941 napi_value thisValue = NapiHelper::CreateObject(env);
4942 napi_value SeqCallback = nullptr;
4943 napi_value SeqResult = nullptr;
4944 napi_create_function(env, func.c_str(), func.size(), SequenceRunner::SeqRunnerConstructor, nullptr, &SeqCallback);
4945 napi_value SeqArgv[1] = {nullptr};
4946 napi_create_string_utf8(env, "seq249", NAPI_AUTO_LENGTH, &SeqArgv[0]);
4947 napi_call_function(env, thisValue, SeqCallback, 1, SeqArgv, &SeqResult);
4948
4949 std::string funcName = "Execute";
4950 napi_value callback = nullptr;
4951 napi_value result = nullptr;
4952 napi_create_function(env, funcName.c_str(), funcName.size(), SequenceRunner::Execute, nullptr, &callback);
4953
4954 napi_value task = CreateTaskObject(env);
4955 napi_value argv[] = {task};
4956 napi_call_function(env, thisValue, callback, 1, argv, &result);
4957 ASSERT_NE(result, nullptr);
4958 }
4959
4960 HWTEST_F(NativeEngineTest, TaskpoolTest250, testing::ext::TestSize.Level0)
4961 {
4962 napi_env env = (napi_env)engine_;
4963 ExceptionScope scope(env);
4964 std::string funcName = "AsyncRunnerConstructor250";
4965 napi_value cb = nullptr;
4966 napi_value result = nullptr;
4967 napi_create_function(env, funcName.c_str(), funcName.size(), AsyncRunner::AsyncRunnerConstructor, nullptr, &cb);
4968 napi_value nameNumber = NapiHelper::CreateUint32(env, 5);
4969 napi_value runningCapacity = NapiHelper::CreateUint32(env, 5);
4970 napi_value waitingCapacity = nullptr;
4971 napi_create_int32(env, -1, &waitingCapacity);
4972 napi_value argv[] = {nameNumber, runningCapacity, waitingCapacity};
4973 napi_call_function(env, nullptr, cb, 3, argv, &result);
4974 ASSERT_EQ(result, nullptr);
4975 napi_value exception = nullptr;
4976 napi_get_and_clear_last_exception(env, &exception);
4977
4978 napi_value argv2[] = {runningCapacity, waitingCapacity};
4979 napi_call_function(env, nullptr, cb, 2, argv2, &result);
4980 ASSERT_EQ(result, nullptr);
4981 }
4982
4983 HWTEST_F(NativeEngineTest, TaskpoolTest251, testing::ext::TestSize.Level0)
4984 {
4985 napi_env env = (napi_env)engine_;
4986 ExceptionScope scope(env);
4987 std::string funcName = "AsyncRunnerConstructor251";
4988 napi_value cb = nullptr;
4989 napi_value result = nullptr;
4990 napi_create_function(env, funcName.c_str(), funcName.size(), AsyncRunner::AsyncRunnerConstructor, nullptr, &cb);
4991 napi_value runningCapacity = NapiHelper::CreateUint32(env, 5);
4992 napi_value argv[] = {nullptr, runningCapacity};
4993 napi_call_function(env, nullptr, cb, 2, argv, &result);
4994 ASSERT_EQ(result, nullptr);
4995 }
4996
4997 HWTEST_F(NativeEngineTest, TaskpoolTest252, testing::ext::TestSize.Level0)
4998 {
4999 napi_env env = (napi_env)engine_;
5000 ExceptionScope scope(env);
5001 std::string funcName = "AsyncRunnerConstructor252";
5002 napi_value cb = nullptr;
5003 napi_value result = nullptr;
5004 napi_create_function(env, funcName.c_str(), funcName.size(), AsyncRunner::AsyncRunnerConstructor, nullptr, &cb);
5005 napi_value name = GetNapiString(env, "async252");
5006 napi_value argv[] = {name, name};
5007 napi_call_function(env, nullptr, cb, 2, argv, &result);
5008 ASSERT_EQ(result, nullptr);
5009 }
5010
5011 HWTEST_F(NativeEngineTest, TaskpoolTest253, testing::ext::TestSize.Level0)
5012 {
5013 napi_env env = (napi_env)engine_;
5014 ExceptionScope scope(env);
5015 std::string funcName = "AsyncRunnerConstructor253";
5016 napi_value cb = nullptr;
5017 napi_value result = nullptr;
5018 napi_create_function(env, funcName.c_str(), funcName.size(), AsyncRunner::AsyncRunnerConstructor, nullptr, &cb);
5019 napi_value runningCapacity = NapiHelper::CreateUint32(env, 0);
5020 napi_value argv[] = {runningCapacity};
5021 napi_call_function(env, nullptr, cb, 1, argv, &result);
5022 ASSERT_EQ(result, nullptr);
5023 }
5024
5025 HWTEST_F(NativeEngineTest, TaskpoolTest254, testing::ext::TestSize.Level0)
5026 {
5027 napi_env env = (napi_env)engine_;
5028 ExceptionScope scope(env);
5029 std::string funcName = "AsyncRunnerConstructor254";
5030 napi_value cb = nullptr;
5031 napi_value result = nullptr;
5032 napi_create_function(env, funcName.c_str(), funcName.size(), AsyncRunner::AsyncRunnerConstructor, nullptr, &cb);
5033 napi_value runningCapacity = NapiHelper::CreateUint32(env, 5);
5034 napi_value name = GetNapiString(env, "async254");
5035 napi_value argv[] = {runningCapacity, name};
5036 napi_call_function(env, nullptr, cb, 2, argv, &result);
5037 ASSERT_EQ(result, nullptr);
5038 }
5039
5040 HWTEST_F(NativeEngineTest, TaskpoolTest255, testing::ext::TestSize.Level0)
5041 {
5042 napi_env env = (napi_env)engine_;
5043 ExceptionScope scope(env);
5044 std::string funcName = "AsyncRunnerConstructor255";
5045 napi_value cb = nullptr;
5046 napi_value result = nullptr;
5047 napi_create_function(env, funcName.c_str(), funcName.size(), AsyncRunner::AsyncRunnerConstructor, nullptr, &cb);
5048 napi_value runningCapacity = NapiHelper::CreateUint32(env, 5);
5049 napi_value argv[] = {runningCapacity};
5050 napi_value obj = NapiHelper::CreateObject(env);
5051 napi_call_function(env, obj, cb, 1, argv, &result);
5052 ASSERT_NE(result, nullptr);
5053 }
5054
5055 HWTEST_F(NativeEngineTest, TaskpoolTest256, testing::ext::TestSize.Level0)
5056 {
5057 napi_env env = (napi_env)engine_;
5058 ExceptionScope scope(env);
5059 NativeEngineTest::CheckAndCreateAsyncRunner(env, nullptr, nullptr, nullptr);
5060 napi_value exception = nullptr;
5061 napi_get_and_clear_last_exception(env, &exception);
5062 ASSERT_NE(exception, nullptr);
5063 }
5064
5065 HWTEST_F(NativeEngineTest, TaskpoolTest257, testing::ext::TestSize.Level0)
5066 {
5067 napi_env env = (napi_env)engine_;
5068 ExceptionScope scope(env);
5069
5070 std::string asyncName = "async257";
5071 AsyncRunnerManager &asyncRunnerManager = AsyncRunnerManager::GetInstance();
5072 napi_value global = NapiHelper::GetGlobalObject(env);
5073 uint32_t capacity = 5;
5074 asyncRunnerManager.CreateOrGetGlobalRunner(env, global, asyncName, capacity, capacity);
5075
5076 std::string funcName = "AsyncRunnerConstructor257";
5077 napi_value cb = nullptr;
5078 napi_value result = nullptr;
5079 napi_create_function(env, funcName.c_str(), funcName.size(), AsyncRunner::AsyncRunnerConstructor, nullptr, &cb);
5080 napi_value runningCapacity = NapiHelper::CreateUint32(env, 3);
5081 napi_value name = GetNapiString(env, asyncName.c_str());
5082 napi_value argv1[] = {name, runningCapacity};
5083 napi_call_function(env, nullptr, cb, 2, argv1, &result);
5084 ASSERT_EQ(result, nullptr);
5085 napi_value exception = nullptr;
5086 napi_get_and_clear_last_exception(env, &exception);
5087
5088 result = nullptr;
5089 napi_value runningCapacity2 = NapiHelper::CreateUint32(env, 5);
5090 napi_value argv2[] = {name, runningCapacity2};
5091 napi_call_function(env, nullptr, cb, 2, argv2, &result);
5092 ASSERT_EQ(result, nullptr);
5093 exception = nullptr;
5094 napi_get_and_clear_last_exception(env, &exception);
5095
5096 asyncRunnerManager.CreateOrGetGlobalRunner(env, global, asyncName, capacity, capacity);
5097 exception = nullptr;
5098 napi_get_and_clear_last_exception(env, &exception);
5099 ASSERT_EQ(exception, nullptr);
5100 }
5101
5102 HWTEST_F(NativeEngineTest, TaskpoolTest258, testing::ext::TestSize.Level0)
5103 {
5104 napi_env env = (napi_env)engine_;
5105 ExceptionScope scope(env);
5106 std::string funcName = "Execute258";
5107 napi_value cb = nullptr;
5108 napi_value result = nullptr;
5109 napi_create_function(env, funcName.c_str(), funcName.size(), AsyncRunner::Execute, nullptr, &cb);
5110
5111 napi_value obj = NapiHelper::CreateObject(env);
5112 napi_value priority = NapiHelper::CreateUint32(env, 1);
5113 napi_value argv[] = {obj, priority};
5114 napi_call_function(env, nullptr, cb, 2, argv, &result);
5115 ASSERT_EQ(result, nullptr);
5116 }
5117
5118 HWTEST_F(NativeEngineTest, TaskpoolTest259, testing::ext::TestSize.Level0)
5119 {
5120 napi_env env = (napi_env)engine_;
5121 ExceptionScope scope(env);
5122 std::string funcName = "Execute259";
5123 napi_value cb = nullptr;
5124 napi_value result = nullptr;
5125 napi_create_function(env, funcName.c_str(), funcName.size(), AsyncRunner::Execute, nullptr, &cb);
5126
5127 napi_value argv1[] = {nullptr};
5128 napi_call_function(env, nullptr, cb, 0, argv1, &result);
5129 ASSERT_EQ(result, nullptr);
5130 napi_value exception = nullptr;
5131 napi_get_and_clear_last_exception(env, &exception);
5132
5133 napi_value priority = NapiHelper::CreateUint32(env, 1);
5134 napi_value argv2[] = {priority, priority, priority};
5135 result = nullptr;
5136 napi_call_function(env, nullptr, cb, 3, argv2, &result);
5137 ASSERT_EQ(result, nullptr);
5138 }
5139
5140 HWTEST_F(NativeEngineTest, TaskpoolTest260, testing::ext::TestSize.Level0)
5141 {
5142 napi_env env = (napi_env)engine_;
5143 ExceptionScope scope(env);
5144 std::string funcName = "Execute260";
5145 napi_value cb = nullptr;
5146 napi_value result = nullptr;
5147 napi_create_function(env, funcName.c_str(), funcName.size(), AsyncRunner::Execute, nullptr, &cb);
5148
5149 napi_value priority = NapiHelper::CreateUint32(env, 4);
5150 napi_value argv[] = {priority, priority};
5151 napi_call_function(env, nullptr, cb, 2, argv, &result);
5152 ASSERT_EQ(result, nullptr);
5153 }
5154
5155 HWTEST_F(NativeEngineTest, TaskpoolTest261, testing::ext::TestSize.Level0)
5156 {
5157 napi_env env = (napi_env)engine_;
5158 ExceptionScope scope(env);
5159 std::string funcName = "Execute261";
5160 napi_value cb = nullptr;
5161 napi_value result = nullptr;
5162 napi_create_function(env, funcName.c_str(), funcName.size(), AsyncRunner::Execute, nullptr, &cb);
5163
5164 napi_value obj = NapiHelper::CreateObject(env);
5165 napi_value task = GeneratorTask(env, obj);
5166 napi_value argv1[] = {task, task};
5167 napi_call_function(env, nullptr, cb, 2, argv1, &result);
5168 ASSERT_EQ(result, nullptr);
5169 napi_value exception = nullptr;
5170 napi_get_and_clear_last_exception(env, &exception);
5171
5172 napi_value priority = NapiHelper::CreateUint32(env, 4);
5173 napi_value argv2[] = {task, priority};
5174 result = nullptr;
5175 napi_call_function(env, nullptr, cb, 2, argv2, &result);
5176 ASSERT_EQ(result, nullptr);
5177 }
5178
5179 HWTEST_F(NativeEngineTest, TaskpoolTest262, testing::ext::TestSize.Level0)
5180 {
5181 napi_env env = (napi_env)engine_;
5182 ExceptionScope scope(env);
5183 std::string funcName = "Execute262";
5184 napi_value cb = nullptr;
5185 napi_value result = nullptr;
5186 napi_create_function(env, funcName.c_str(), funcName.size(), AsyncRunner::Execute, nullptr, &cb);
5187
5188 napi_value obj = NapiHelper::CreateObject(env);
5189 napi_value task = GeneratorTask(env, obj);
5190 napi_value priority = NapiHelper::CreateUint32(env, 1);
5191 napi_value argv[] = {task, priority};
5192 napi_call_function(env, nullptr, cb, 2, argv, &result);
5193 ASSERT_NE(result, nullptr);
5194 }
5195
5196 HWTEST_F(NativeEngineTest, TaskpoolTest263, testing::ext::TestSize.Level0)
5197 {
5198 napi_env env = (napi_env)engine_;
5199 ExceptionScope scope(env);
5200 napi_value asyncGlobal = NapiHelper::CreateObject(env);
5201 std::string conName = "AsyncRunnerConstructor263";
5202 napi_value callback = nullptr;
5203 napi_value asyncResult = nullptr;
5204 napi_create_function(env, conName.c_str(), conName.size(), AsyncRunner::AsyncRunnerConstructor, nullptr, &callback);
5205 napi_value runningCapacity = NapiHelper::CreateUint32(env, 3);
5206 napi_value asyncArgv[] = {runningCapacity, runningCapacity};
5207 napi_call_function(env, asyncGlobal, callback, 2, asyncArgv, &asyncResult);
5208
5209 std::string funcName = "Execute263";
5210 napi_value cb = nullptr;
5211 napi_value result = nullptr;
5212 napi_create_function(env, funcName.c_str(), funcName.size(), AsyncRunner::Execute, nullptr, &cb);
5213 napi_value obj = NapiHelper::CreateObject(env);
5214 napi_value task = GeneratorTask(env, obj);
5215 napi_value priority = NapiHelper::CreateUint32(env, 1);
5216 napi_value argv[] = {task, priority};
5217 napi_call_function(env, asyncGlobal, cb, 2, argv, &result);
5218 ASSERT_NE(result, nullptr);
5219 napi_value exception = nullptr;
5220 napi_get_and_clear_last_exception(env, &exception);
5221
5222 napi_value task2 = CreateTaskObject(env, TaskType::ASYNCRUNNER_TASK);
5223 napi_value argv2[] = {task2, priority};
5224 result = nullptr;
5225 napi_call_function(env, asyncGlobal, cb, 2, argv2, &result);
5226 ASSERT_EQ(result, nullptr);
5227 }
5228
5229 HWTEST_F(NativeEngineTest, TaskpoolTest264, testing::ext::TestSize.Level0)
5230 {
5231 napi_env env = (napi_env)engine_;
5232 ExceptionScope scope(env);
5233 napi_value asyncGlobal = NapiHelper::CreateObject(env);
5234 std::string conName = "AsyncRunnerConstructor264";
5235 napi_value callback = nullptr;
5236 napi_value asyncResult = nullptr;
5237 napi_create_function(env, conName.c_str(), conName.size(), AsyncRunner::AsyncRunnerConstructor, nullptr, &callback);
5238 napi_value runningCapacity = NapiHelper::CreateUint32(env, 1);
5239 napi_value asyncArgv[] = {runningCapacity, runningCapacity};
5240 napi_call_function(env, asyncGlobal, callback, 2, asyncArgv, &asyncResult);
5241
5242 std::string funcName = "Execute264";
5243 napi_value cb = nullptr;
5244 napi_value result = nullptr;
5245 napi_create_function(env, funcName.c_str(), funcName.size(), AsyncRunner::Execute, nullptr, &cb);
5246 napi_value task1 = CreateTaskObject(env);
5247 napi_value priority = NapiHelper::CreateUint32(env, 1);
5248 napi_value argv1[] = {task1, priority};
5249 napi_call_function(env, asyncGlobal, cb, 2, argv1, &result);
5250 ASSERT_NE(result, nullptr);
5251
5252 napi_value task2 = CreateTaskObject(env);
5253 napi_value argv2[] = {task2, priority};
5254 result = nullptr;
5255 napi_call_function(env, asyncGlobal, cb, 2, argv2, &result);
5256 ASSERT_NE(result, nullptr);
5257
5258 napi_value task3 = CreateTaskObject(env);
5259 napi_value argv3[] = {task3, priority};
5260 result = nullptr;
5261 napi_call_function(env, asyncGlobal, cb, 2, argv3, &result);
5262 ASSERT_NE(result, nullptr);
5263 }
5264
5265 HWTEST_F(NativeEngineTest, TaskpoolTest265, testing::ext::TestSize.Level0)
5266 {
5267 napi_env env = (napi_env)engine_;
5268 ExceptionScope scope(env);
5269 void* data = nullptr;
5270 NativeEngineTest::AsyncRunnerDestructor(nullptr, data);
5271 NativeEngineTest::AsyncRunnerDestructor(env, data);
5272 AsyncRunner* asyncRunner = new AsyncRunner();
5273 asyncRunner->asyncRunnerId_ = 265;
5274 void* data2 = static_cast<void*>(asyncRunner);
5275 NativeEngineTest::AsyncRunnerDestructor(env, data2);
5276 ASSERT_TRUE(true);
5277 }
5278
5279 HWTEST_F(NativeEngineTest, TaskpoolTest266, testing::ext::TestSize.Level0)
5280 {
5281 napi_env env = (napi_env)engine_;
5282 ExceptionScope scope(env);
5283 AsyncRunnerManager &asyncRunnerManager = AsyncRunnerManager::GetInstance();
5284 Task* task = new Task();
5285 task->taskType_ = TaskType::ASYNCRUNNER_TASK;
5286 asyncRunnerManager.TriggerAsyncRunner(env, task);
5287
5288 AsyncRunner* asyncRunner = new AsyncRunner();
5289 asyncRunner->runningCapacity_ = 1;
5290 asyncRunner->waitingCapacity_ = 1;
5291 asyncRunner->runningCount_ = 1;
5292 asyncRunner->asyncRunnerId_ = reinterpret_cast<uint64_t>(asyncRunner);
5293 task->asyncRunnerId_ = asyncRunner->asyncRunnerId_;
5294 asyncRunnerManager.StoreAsyncRunner(asyncRunner->asyncRunnerId_, asyncRunner);
5295
5296 Task* task2 = new Task();
5297 task2->asyncRunnerId_ = asyncRunner->asyncRunnerId_;
5298 TaskInfo* taskInfo = new TaskInfo();
5299 task2->currentTaskInfo_ = taskInfo;
5300 void* data2 = reinterpret_cast<void*>(task2);
5301 void* async = reinterpret_cast<void*>(asyncRunner);
5302 NativeEngineTest::AddTasksToAsyncRunner(async, data2);
5303 asyncRunnerManager.TriggerAsyncRunner(env, task);
5304 delete task;
5305 ASSERT_TRUE(true);
5306 }
5307
5308 HWTEST_F(NativeEngineTest, TaskpoolTest267, testing::ext::TestSize.Level0)
5309 {
5310 napi_env env = (napi_env)engine_;
5311 ExceptionScope scope(env);
5312 AsyncRunnerManager &asyncRunnerManager = AsyncRunnerManager::GetInstance();
5313 Task* task = new Task();
5314 task->taskState_ = ExecuteState::FINISHED;
5315 asyncRunnerManager.CancelAsyncRunnerTask(env, task);
5316 napi_value exception = nullptr;
5317 napi_get_and_clear_last_exception(env, &exception);
5318 ASSERT_NE(exception, nullptr);
5319
5320 task->taskState_ = ExecuteState::ENDING;
5321 asyncRunnerManager.CancelAsyncRunnerTask(env, task);
5322 exception = nullptr;
5323 napi_get_and_clear_last_exception(env, &exception);
5324 ASSERT_NE(exception, nullptr);
5325
5326 task->taskState_ = ExecuteState::RUNNING;
5327 asyncRunnerManager.CancelAsyncRunnerTask(env, task);
5328
5329 task->taskState_ = ExecuteState::WAITING;
5330 TaskInfo* taskInfo = new TaskInfo();
5331 task->currentTaskInfo_ = taskInfo;
5332 task->taskId_ = TaskManager::GetInstance().CalculateTaskId(reinterpret_cast<uint64_t>(task));
5333 asyncRunnerManager.CancelAsyncRunnerTask(env, task);
5334 delete task;
5335 ASSERT_TRUE(true);
5336 }
5337
5338 HWTEST_F(NativeEngineTest, TaskpoolTest268, testing::ext::TestSize.Level0)
5339 {
5340 napi_env env = (napi_env)engine_;
5341 ExceptionScope scope(env);
5342 AsyncRunnerManager &asyncRunnerManager = AsyncRunnerManager::GetInstance();
5343 Task* task = new Task();
5344
5345 AsyncRunner* asyncRunner = new AsyncRunner();
5346 asyncRunner->runningCapacity_ = 1;
5347 asyncRunner->waitingCapacity_ = 1;
5348 asyncRunner->runningCount_ = 1;
5349 asyncRunner->asyncRunnerId_ = reinterpret_cast<uint64_t>(asyncRunner);
5350 asyncRunner->IncreaseAsyncCount();
5351 task->asyncRunnerId_ = asyncRunner->asyncRunnerId_;
5352 asyncRunnerManager.StoreAsyncRunner(asyncRunner->asyncRunnerId_, asyncRunner);
5353 bool flag = asyncRunnerManager.TriggerAsyncRunner(env, task);
5354 ASSERT_TRUE(flag);
5355 delete task;
5356 }
5357
5358 HWTEST_F(NativeEngineTest, TaskpoolTest269, testing::ext::TestSize.Level0)
5359 {
5360 napi_env env = (napi_env)engine_;
5361 ExceptionScope scope(env);
5362 AsyncRunnerManager &asyncRunnerManager = AsyncRunnerManager::GetInstance();
5363
5364 std::string asyncName = "async269";
5365 napi_value obj = NapiHelper::CreateObject(env);
5366 AsyncRunner* asyncRunner = asyncRunnerManager.CreateOrGetGlobalRunner(env, obj, asyncName, 5, 0);
5367 asyncRunner->asyncRunnerId_ = reinterpret_cast<uint64_t>(asyncRunner);
5368 asyncRunner->isGlobalRunner_ = true;
5369 asyncRunnerManager.StoreAsyncRunner(asyncRunner->asyncRunnerId_, asyncRunner);
5370
5371 Task* task = new Task();
5372 task->asyncRunnerId_ = asyncRunner->asyncRunnerId_;
5373
5374 Task* task2 = new Task();
5375 task2->asyncRunnerId_ = asyncRunner->asyncRunnerId_;
5376 task2->taskState_ = ExecuteState::CANCELED;
5377 TaskInfo* taskInfo = new TaskInfo();
5378 task2->currentTaskInfo_ = taskInfo;
5379 void* data2 = reinterpret_cast<void*>(task2);
5380 void* async = reinterpret_cast<void*>(asyncRunner);
5381 NativeEngineTest::AddTasksToAsyncRunner(async, data2);
5382 asyncRunner->IncreaseAsyncCount();
5383
5384 Task* task3 = new Task();
5385 task3->asyncRunnerId_ = asyncRunner->asyncRunnerId_;
5386 task3->taskId_ = TaskManager::GetInstance().CalculateTaskId(reinterpret_cast<uint64_t>(task3));
5387 void* data3 = reinterpret_cast<void*>(task3);
5388 NativeEngineTest::AddTasksToAsyncRunner(async, data3);
5389 asyncRunner->IncreaseAsyncCount();
5390 bool flag = asyncRunnerManager.TriggerAsyncRunner(env, task);
5391 ASSERT_TRUE(flag);
5392
5393 delete task;
5394 delete task2;
5395 delete task3;
5396 }
5397
5398 HWTEST_F(NativeEngineTest, TaskpoolTest270, testing::ext::TestSize.Level0)
5399 {
5400 napi_env env = (napi_env)engine_;
5401 ExceptionScope scope(env);
5402
5403 napi_value asyncGlobal = NapiHelper::CreateObject(env);
5404 std::string conName = "AsyncRunnerConstructor270";
5405 napi_value callback = nullptr;
5406 napi_value asyncResult = nullptr;
5407 napi_create_function(env, conName.c_str(), conName.size(), AsyncRunner::AsyncRunnerConstructor, nullptr, &callback);
5408 std::string asyncName = "async270";
5409 napi_value name = GetNapiString(env, asyncName.c_str());
5410 napi_value runningCapacity = NapiHelper::CreateUint32(env, 1);
5411 napi_value asyncArgv[] = {name, runningCapacity, runningCapacity};
5412 napi_call_function(env, asyncGlobal, callback, 3, asyncArgv, &asyncResult);
5413
5414 std::string funcName = "Execute270";
5415 napi_value cb = nullptr;
5416 napi_value result = nullptr;
5417 napi_create_function(env, funcName.c_str(), funcName.size(), AsyncRunner::Execute, nullptr, &cb);
5418 napi_value task = CreateTaskObject(env);
5419 napi_value priority = NapiHelper::CreateUint32(env, 1);
5420 napi_value argv[] = {task, priority};
5421 napi_call_function(env, asyncGlobal, cb, 2, argv, &result);
5422 ASSERT_NE(result, nullptr);
5423
5424 std::string funcName2 = "Execute270-1";
5425 napi_value cb2 = nullptr;
5426 napi_value result2 = nullptr;
5427 napi_create_function(env, funcName2.c_str(), funcName2.size(), AsyncRunner::Execute, nullptr, &cb2);
5428 napi_value task2 = CreateTaskObject(env);
5429 napi_value argv2[] = {task2, priority};
5430 napi_call_function(env, asyncGlobal, cb2, 2, argv2, &result2);
5431 napi_value exception = nullptr;
5432 napi_get_and_clear_last_exception(env, &exception);
5433 ASSERT_EQ(exception, nullptr);
5434 }
5435
5436 HWTEST_F(NativeEngineTest, TaskpoolTest271, testing::ext::TestSize.Level0)
5437 {
5438 napi_env env = (napi_env)engine_;
5439 ExceptionScope scope(env);
5440 Task* task = new Task();
5441 task->taskType_ = TaskType::ASYNCRUNNER_TASK;
5442 bool flag = task->CanForSequenceRunner(env);
5443 ASSERT_FALSE(flag);
5444 napi_value exception = nullptr;
5445 napi_get_and_clear_last_exception(env, &exception);
5446
5447 flag = task->CanForTaskGroup(env);
5448 ASSERT_FALSE(flag);
5449 exception = nullptr;
5450 napi_get_and_clear_last_exception(env, &exception);
5451
5452 flag = task->CanExecute(env);
5453 ASSERT_FALSE(flag);
5454 exception = nullptr;
5455 napi_get_and_clear_last_exception(env, &exception);
5456
5457 flag = task->CanExecuteDelayed(env);
5458 ASSERT_FALSE(flag);
5459 exception = nullptr;
5460 napi_get_and_clear_last_exception(env, &exception);
5461
5462 flag = task->CanExecutePeriodically(env);
5463 ASSERT_FALSE(flag);
5464 delete task;
5465 }
5466
5467 HWTEST_F(NativeEngineTest, TaskpoolTest272, testing::ext::TestSize.Level0)
5468 {
5469 napi_env env = (napi_env)engine_;
5470 ExceptionScope scope(env);
5471 Task* task = new Task();
5472 task->hasDependency_ = true;
5473 bool flag = task->CanForAsyncRunner(env);
5474 ASSERT_FALSE(flag);
5475 napi_value exception = nullptr;
5476 napi_get_and_clear_last_exception(env, &exception);
5477
5478 task->hasDependency_ = false;
5479 task->isPeriodicTask_ = true;
5480 flag = task->CanForAsyncRunner(env);
5481 ASSERT_FALSE(flag);
5482 exception = nullptr;
5483 napi_get_and_clear_last_exception(env, &exception);
5484
5485 task->isPeriodicTask_ = false;
5486 task->taskType_ = TaskType::COMMON_TASK;
5487 flag = task->CanForAsyncRunner(env);
5488 ASSERT_FALSE(flag);
5489 exception = nullptr;
5490 napi_get_and_clear_last_exception(env, &exception);
5491
5492 task->taskType_ = TaskType::SEQRUNNER_TASK;
5493 flag = task->CanForAsyncRunner(env);
5494 ASSERT_FALSE(flag);
5495 exception = nullptr;
5496 napi_get_and_clear_last_exception(env, &exception);
5497
5498 task->taskType_ = TaskType::GROUP_COMMON_TASK;
5499 flag = task->CanForAsyncRunner(env);
5500 ASSERT_FALSE(flag);
5501 delete task;
5502 }
5503
5504 HWTEST_F(NativeEngineTest, TaskpoolTest273, testing::ext::TestSize.Level0)
5505 {
5506 napi_env env = (napi_env)engine_;
5507 ExceptionScope scope(env);
5508 napi_value thisValue = CreateTaskObject(env, TaskType::ASYNCRUNNER_TASK, ExecuteState::CANCELED);
5509 Task* task = nullptr;
5510 napi_unwrap(env, thisValue, reinterpret_cast<void**>(&task));
5511 TaskInfo* taskInfo = new TaskInfo();
5512 task->currentTaskInfo_ = taskInfo;
5513 task->asyncRunnerId_ = 1;
5514 napi_value num = nullptr;
5515 napi_create_int32(env, 1, &num);
5516 napi_ref callbackRef = NapiHelper::CreateReference(env, num, 1);
5517 task->onExecutionFailedCallBackInfo_ = new ListenerCallBackInfo(env, callbackRef, nullptr);
5518 TaskPool::HandleTaskResultCallback(task);
5519 ASSERT_TRUE(true);
5520 }
5521
5522 HWTEST_F(NativeEngineTest, TaskpoolTest274, testing::ext::TestSize.Level0)
5523 {
5524 napi_env env = (napi_env)engine_;
5525 ExceptionScope scope(env);
5526 TaskManager& taskManager = TaskManager::GetInstance();
5527 Task* task = new Task();
5528 task->taskType_ = TaskType::ASYNCRUNNER_TASK;
5529 taskManager.StoreTask(task);
5530 uint32_t taskId = task->taskId_;
5531 taskManager.CancelTask(env, taskId);
5532 napi_value exception = nullptr;
5533 napi_get_and_clear_last_exception(env, &exception);
5534 ASSERT_EQ(exception, nullptr);
5535 taskManager.RemoveTask(taskId);
5536 delete task;
5537 }
5538
5539 HWTEST_F(NativeEngineTest, TaskpoolTest275, testing::ext::TestSize.Level0)
5540 {
5541 napi_env env = (napi_env)engine_;
5542 ExceptionScope scope(env);
5543 TaskManager& taskManager = TaskManager::GetInstance();
5544 AsyncRunnerManager& asyncRunnerManager = AsyncRunnerManager::GetInstance();
5545
5546 std::string asyncName = "async275";
5547 napi_value obj = NapiHelper::CreateObject(env);
5548 AsyncRunner* asyncRunner = asyncRunnerManager.CreateOrGetGlobalRunner(env, obj, asyncName, 5, 0);
5549 asyncRunner->asyncRunnerId_ = reinterpret_cast<uint64_t>(asyncRunner);
5550 asyncRunnerManager.StoreAsyncRunner(asyncRunner->asyncRunnerId_, asyncRunner);
5551
5552 Task* task = new Task();
5553 task->asyncRunnerId_ = asyncRunner->asyncRunnerId_;
5554 TaskInfo* taskInfo = new TaskInfo();
5555 task->currentTaskInfo_ = taskInfo;
5556 task->taskType_ = TaskType::ASYNCRUNNER_TASK;
5557 task->taskState_ = ExecuteState::WAITING;
5558 taskManager.StoreTask(task);
5559 taskManager.CancelTask(env, task->taskId_);
5560 napi_value exception = nullptr;
5561 napi_get_and_clear_last_exception(env, &exception);
5562 ASSERT_EQ(exception, nullptr);
5563 asyncRunner->waitingTasks_.push_back(task);
5564
5565 Task* task2 = new Task();
5566 task2->env_ = env;
5567 task2->asyncRunnerId_ = asyncRunner->asyncRunnerId_;
5568 TaskInfo* taskInfo2 = new TaskInfo();
5569 task2->currentTaskInfo_ = taskInfo2;
5570 task2->taskType_ = TaskType::ASYNCRUNNER_TASK;
5571 task2->SetValid(false);
5572 asyncRunner->waitingTasks_.push_back(task2);
5573 taskManager.StoreTask(task2);
5574 taskManager.CancelTask(env, task2->taskId_);
5575 exception = nullptr;
5576 napi_get_and_clear_last_exception(env, &exception);
5577 ASSERT_EQ(exception, nullptr);
5578 }
5579
5580 HWTEST_F(NativeEngineTest, TaskpoolTest276, testing::ext::TestSize.Level0)
5581 {
5582 napi_env env = (napi_env)engine_;
5583 ExceptionScope scope(env);
5584 TaskManager& taskManager = TaskManager::GetInstance();
5585 AsyncRunner* asyncRunner = new AsyncRunner();
5586 asyncRunner->TriggerRejectErrorTimer(nullptr, 0);
5587 napi_value exception = nullptr;
5588 napi_get_and_clear_last_exception(env, &exception);
5589 ASSERT_EQ(exception, nullptr);
5590 delete asyncRunner;
5591
5592 Task* task = new Task();
5593 taskManager.StoreTask(task);
5594 DiscardTaskMessage* message = new DiscardTaskMessage(task->env_, task->taskId_, 0, true);
5595 task->DiscardAsyncRunnerTask(message);
5596 exception = nullptr;
5597 napi_get_and_clear_last_exception(env, &exception);
5598 ASSERT_EQ(exception, nullptr);
5599
5600 DiscardTaskMessage* message2 = new DiscardTaskMessage(task->env_, task->taskId_, 0, true);
5601 task->SetValid(false);
5602 task->taskType_ = TaskType::ASYNCRUNNER_TASK;
5603 task->DiscardAsyncRunnerTask(message2);
5604 exception = nullptr;
5605 napi_get_and_clear_last_exception(env, &exception);
5606 ASSERT_EQ(exception, nullptr);
5607
5608 task->SetValid(true);
5609 task->DiscardAsyncRunnerTask(nullptr);
5610 exception = nullptr;
5611 napi_get_and_clear_last_exception(env, &exception);
5612 ASSERT_EQ(exception, nullptr);
5613
5614 taskManager.RemoveTask(task->taskId_);
5615 delete task;
5616 }
5617
5618 HWTEST_F(NativeEngineTest, TaskpoolTest277, testing::ext::TestSize.Level0)
5619 {
5620 napi_env env = (napi_env)engine_;
5621 ExceptionScope scope(env);
5622 TaskManager& taskManager = TaskManager::GetInstance();
5623
5624 Task* task = new Task();
5625 TaskInfo* taskInfo = new TaskInfo();
5626 task->currentTaskInfo_ = taskInfo;
5627 task->taskType_ = TaskType::ASYNCRUNNER_TASK;
5628 task->isMainThreadTask_ = true;
5629 taskManager.StoreTask(task);
5630 DiscardTaskMessage* message = new DiscardTaskMessage(task->env_, 1, 0, true);
5631 task->DiscardAsyncRunnerTask(message);
5632 napi_value exception = nullptr;
5633 napi_get_and_clear_last_exception(env, &exception);
5634 ASSERT_EQ(exception, nullptr);
5635
5636 Task* task2 = new Task();
5637 TaskInfo* taskInfo2 = new TaskInfo();
5638 task2->currentTaskInfo_ = taskInfo2;
5639 task2->taskType_ = TaskType::ASYNCRUNNER_TASK;
5640 taskManager.StoreTask(task2);
5641 task2->DiscardInner(nullptr);
5642 exception = nullptr;
5643 napi_get_and_clear_last_exception(env, &exception);
5644 ASSERT_EQ(exception, nullptr);
5645
5646 task2->env_ = env;
5647 DiscardTaskMessage* message2 = new DiscardTaskMessage(nullptr, task2->taskId_, 0, true);
5648 task2->DiscardInner(message2);
5649 exception = nullptr;
5650 napi_get_and_clear_last_exception(env, &exception);
5651 ASSERT_EQ(exception, nullptr);
5652
5653 task2->SetValid(false);
5654 DiscardTaskMessage* message3 = new DiscardTaskMessage(task2->env_, task2->taskId_, 0, true);
5655 task2->DiscardInner(message3);
5656 exception = nullptr;
5657 napi_get_and_clear_last_exception(env, &exception);
5658 ASSERT_EQ(exception, nullptr);
5659 taskManager.RemoveTask(task->taskId_);
5660 taskManager.RemoveTask(task2->taskId_);
5661 delete task;
5662 delete task2;
5663 }
5664
5665 HWTEST_F(NativeEngineTest, TaskpoolTest278, testing::ext::TestSize.Level0)
5666 {
5667 napi_env env = (napi_env)engine_;
5668 ExceptionScope scope(env);
5669 TaskManager& taskManager = TaskManager::GetInstance();
5670 AsyncRunnerManager& asyncRunnerManager = AsyncRunnerManager::GetInstance();
5671
5672 napi_value obj = NapiHelper::CreateObject(env);
5673 AsyncRunner* asyncRunner = asyncRunnerManager.CreateOrGetGlobalRunner(env, obj, "", 5, 0);
5674 asyncRunner->asyncRunnerId_ = reinterpret_cast<uint64_t>(asyncRunner);
5675 asyncRunnerManager.StoreAsyncRunner(asyncRunner->asyncRunnerId_, asyncRunner);
5676
5677 Task* task = new Task();
5678 task->asyncRunnerId_ = asyncRunner->asyncRunnerId_;
5679 task->taskType_ = TaskType::ASYNCRUNNER_TASK;
5680 taskManager.StoreTask(task);
5681 asyncRunner->waitingTasks_.push_back(task);
5682 taskManager.CancelTask(env, task->taskId_);
5683 napi_value exception = nullptr;
5684 napi_get_and_clear_last_exception(env, &exception);
5685 ASSERT_EQ(exception, nullptr);
5686 taskManager.RemoveTask(task->taskId_);
5687 delete task;
5688 }
5689
5690 HWTEST_F(NativeEngineTest, TaskpoolTest279, testing::ext::TestSize.Level0)
5691 {
5692 napi_env env = (napi_env)engine_;
5693 ExceptionScope scope(env);
5694 napi_value argv[] = {nullptr};
5695 std::string funcName = "AsyncRunnerConstructor279";
5696 napi_value cb = nullptr;
5697 napi_value result = nullptr;
5698 napi_create_function(env, funcName.c_str(), funcName.size(), AsyncRunner::AsyncRunnerConstructor, nullptr, &cb);
5699 napi_call_function(env, nullptr, cb, 0, argv, &result);
5700 ASSERT_EQ(result, nullptr);
5701 }
5702
5703 HWTEST_F(NativeEngineTest, TaskpoolTest280, testing::ext::TestSize.Level0)
5704 {
5705 napi_env env = (napi_env)engine_;
5706 ExceptionScope scope(env);
5707 std::string funcName = "AsyncRunnerConstructor280";
5708 napi_value cb = nullptr;
5709 napi_value result = nullptr;
5710 napi_create_function(env, funcName.c_str(), funcName.size(), AsyncRunner::AsyncRunnerConstructor, nullptr, &cb);
5711 napi_value name = GetNapiString(env, "async280");
5712 napi_value runningCapacity = NapiHelper::CreateUint32(env, 5);
5713 napi_value argv[] = {name, runningCapacity};
5714 napi_call_function(env, nullptr, cb, 2, argv, &result);
5715 ASSERT_NE(result, nullptr);
5716 }
5717
5718 HWTEST_F(NativeEngineTest, TaskpoolTest281, testing::ext::TestSize.Level0)
5719 {
5720 napi_env env = (napi_env)engine_;
5721 napi_value thisValue = CreateTaskObject(env);
5722 Task* task = nullptr;
5723 napi_unwrap(env, thisValue, reinterpret_cast<void**>(&task));
5724
5725 napi_value dependentTask = CreateTaskObject(env);
5726 Task* task1 = nullptr;
5727 napi_unwrap(env, dependentTask, reinterpret_cast<void**>(&task1));
5728 napi_value argv[] = { dependentTask };
5729 std::string funcName = "RemoveDependency";
5730 napi_value cb = nullptr;
5731 napi_value result = nullptr;
5732 napi_create_function(env, funcName.c_str(), funcName.size(), Task::RemoveDependency, nullptr, &cb);
5733 task->hasDependency_ = true;
5734 task->isPeriodicTask_ = false;
5735 task->taskType_ = TaskType::TASK;
5736 task1->hasDependency_ = true;
5737 task1->isPeriodicTask_ = false;
5738 task1->taskType_ = TaskType::ASYNCRUNNER_TASK;
5739 NativeEngineTest::StoreDependentId(task->taskId_, task1->taskId_);
5740 napi_call_function(env, thisValue, cb, 1, argv, &result);
5741 napi_value exception = nullptr;
5742 napi_get_and_clear_last_exception(env, &exception);
5743 ASSERT_TRUE(exception != nullptr);
5744 }
5745
5746 HWTEST_F(NativeEngineTest, TaskpoolTest282, testing::ext::TestSize.Level0)
5747 {
5748 napi_env env = (napi_env)engine_;
5749 ExceptionScope scope(env);
5750 TaskManager& taskManager = TaskManager::GetInstance();
5751 AsyncRunnerManager& asyncRunnerManager = AsyncRunnerManager::GetInstance();
5752
5753 Task* task = new Task();
5754 task->env_ = env;
5755 TaskInfo* taskInfo = new TaskInfo();
5756 task->currentTaskInfo_ = taskInfo;
5757 task->taskType_ = TaskType::ASYNCRUNNER_TASK;
5758 taskManager.StoreTask(task);
5759
5760 std::string asyncName = "";
5761 napi_value obj = NapiHelper::CreateObject(env);
5762 AsyncRunner* asyncRunner = asyncRunnerManager.CreateOrGetGlobalRunner(env, obj, asyncName, 5, 0);
5763 asyncRunner->asyncRunnerId_ = reinterpret_cast<uint64_t>(asyncRunner);
5764 asyncRunnerManager.StoreAsyncRunner(asyncRunner->asyncRunnerId_, asyncRunner);
5765 task->asyncRunnerId_ = asyncRunner->asyncRunnerId_;
5766 napi_value obj2 = NapiHelper::CreateObject(env);
5767 task->taskRef_ = NapiHelper::CreateReference(env, obj2, 1);
5768 DiscardTaskMessage* message = new DiscardTaskMessage(task->env_, task->taskId_, 0, false);
5769 task->DiscardInner(message);
5770 napi_value exception = nullptr;
5771 napi_get_and_clear_last_exception(env, &exception);
5772 ASSERT_EQ(exception, nullptr);
5773 taskManager.RemoveTask(task->taskId_);
5774 delete task;
5775 }
5776
5777 HWTEST_F(NativeEngineTest, TaskpoolTest283, testing::ext::TestSize.Level0)
5778 {
5779 napi_env env = (napi_env)engine_;
5780 ExceptionScope scope(env);
5781 TaskManager& taskManager = TaskManager::GetInstance();
5782 AsyncRunnerManager& asyncRunnerManager = AsyncRunnerManager::GetInstance();
5783
5784 uv_async_t* req = new uv_async_t;
5785 req->data = nullptr;
5786 Task::DiscardTask(req);
5787 napi_value exception = nullptr;
5788 napi_get_and_clear_last_exception(env, &exception);
5789 ASSERT_EQ(exception, nullptr);
5790
5791 Task* task = new Task();
5792 TaskInfo* taskInfo = new TaskInfo();
5793 task->currentTaskInfo_ = taskInfo;
5794 task->taskType_ = TaskType::ASYNCRUNNER_TASK;
5795 taskManager.StoreTask(task);
5796 DiscardTaskMessage* message = new DiscardTaskMessage(env, task->taskId_, 0, false);
5797 req->data = message;
5798 Task::DiscardTask(req);
5799 exception = nullptr;
5800 napi_get_and_clear_last_exception(env, &exception);
5801 ASSERT_EQ(exception, nullptr);
5802
5803 DiscardTaskMessage* message2 = new DiscardTaskMessage(nullptr, 283, 0, false);
5804 req->data = message2;
5805 Task::DiscardTask(req);
5806 exception = nullptr;
5807 napi_get_and_clear_last_exception(env, &exception);
5808 ASSERT_EQ(exception, nullptr);
5809
5810 task->env_ = env;
5811 task->SetValid(false);
5812 DiscardTaskMessage* message3 = new DiscardTaskMessage(env, task->taskId_, 0, false);
5813 req->data = message3;
5814 Task::DiscardTask(req);
5815 exception = nullptr;
5816 napi_get_and_clear_last_exception(env, &exception);
5817 ASSERT_EQ(exception, nullptr);
5818 taskManager.RemoveTask(task->taskId_);
5819 delete task;
5820 }
5821
5822 HWTEST_F(NativeEngineTest, TaskpoolTest284, testing::ext::TestSize.Level0)
5823 {
5824 napi_env env = (napi_env)engine_;
5825 ExceptionScope scope(env);
5826 AsyncRunnerManager &asyncRunnerManager = AsyncRunnerManager::GetInstance();
5827 Task* task = new Task();
5828 task->taskType_ = TaskType::ASYNCRUNNER_TASK;
5829 asyncRunnerManager.TriggerAsyncRunner(env, task);
5830
5831 AsyncRunner* asyncRunner = new AsyncRunner();
5832 asyncRunner->runningCapacity_ = 1;
5833 asyncRunner->waitingCapacity_ = 1;
5834 asyncRunner->runningCount_ = 1;
5835 asyncRunner->asyncRunnerId_ = reinterpret_cast<uint64_t>(asyncRunner);
5836 task->asyncRunnerId_ = asyncRunner->asyncRunnerId_;
5837 asyncRunnerManager.StoreAsyncRunner(asyncRunner->asyncRunnerId_, asyncRunner);
5838
5839 Task* task2 = new Task();
5840 task2->asyncRunnerId_ = asyncRunner->asyncRunnerId_;
5841 TaskInfo* taskInfo = new TaskInfo();
5842 task2->currentTaskInfo_ = taskInfo;
5843 task2->SetValid(false);
5844 void* data2 = reinterpret_cast<void*>(task2);
5845 void* async = reinterpret_cast<void*>(asyncRunner);
5846 NativeEngineTest::AddTasksToAsyncRunner(async, data2);
5847 asyncRunnerManager.TriggerAsyncRunner(env, task);
5848 delete task;
5849 delete task2;
5850 ASSERT_TRUE(true);
5851 }
5852
5853 HWTEST_F(NativeEngineTest, TaskpoolTest285, testing::ext::TestSize.Level0)
5854 {
5855 napi_env env = (napi_env)engine_;
5856 TaskGroup::HostEnvCleanupHook(nullptr);
5857 TaskGroup* group = new TaskGroup();
5858 TaskGroup::HostEnvCleanupHook(group);
5859 napi_value exception = nullptr;
5860 napi_get_and_clear_last_exception(env, &exception);
5861 ASSERT_EQ(exception, nullptr);
5862 delete group;
5863 }
5864
5865 HWTEST_F(NativeEngineTest, TaskpoolTest286, testing::ext::TestSize.Level0)
5866 {
5867 napi_env env = (napi_env)engine_;
5868 uv_async_t* req = new uv_async_t;
5869 req->data = nullptr;
5870 TaskGroup::StartRejectResult(req);
5871 TaskGroup* group = new TaskGroup(env);
5872 req->data = group;
5873 TaskGroup::StartRejectResult(req);
5874 napi_value exception = nullptr;
5875 napi_get_and_clear_last_exception(env, &exception);
5876 ASSERT_EQ(exception, nullptr);
5877 delete group;
5878 delete req;
5879 }
5880
5881 HWTEST_F(NativeEngineTest, TaskpoolTest287, testing::ext::TestSize.Level0)
5882 {
5883 napi_env env = (napi_env)engine_;
5884 TaskGroup* group = new TaskGroup(env);
5885 group->CancelGroupTask(env, 0);
5886 napi_env runtimeEnv = nullptr;
5887 napi_create_runtime(env, &runtimeEnv);
5888 group->CancelGroupTask(runtimeEnv, 0);
5889 napi_value exception = nullptr;
5890 napi_get_and_clear_last_exception(env, &exception);
5891 ASSERT_EQ(exception, nullptr);
5892 delete group;
5893 }
5894
5895 HWTEST_F(NativeEngineTest, TaskpoolTest288, testing::ext::TestSize.Level0)
5896 {
5897 napi_env env = (napi_env)engine_;
5898 TaskGroup* group = new TaskGroup(env);
5899 uint64_t groupId = reinterpret_cast<uint64_t>(group);
5900 group->groupId_ = groupId;
5901
5902 Task* task = new Task();
5903 uint32_t taskId = TaskManager::GetInstance().CalculateTaskId(reinterpret_cast<uint64_t>(task));
5904 task->taskId_ = taskId;
5905 task->groupId_ = groupId;
5906 group->taskIds_.push_back(taskId);
5907 GroupInfo* groupInfo = new GroupInfo();
5908 groupInfo->priority = Priority::DEFAULT;
5909 napi_value resArr;
5910 napi_create_array_with_length(env, group->taskIds_.size(), &resArr);
5911 napi_ref arrRef = NapiHelper::CreateReference(env, resArr, 1);
5912 groupInfo->resArr = arrRef;
5913 NapiHelper::CreatePromise(env, &groupInfo->deferred);
5914 group->currentGroupInfo_ = groupInfo;
5915 group->taskNum_ = 0;
5916 groupInfo->finishedTaskNum = 1;
5917 group->RejectResult(env);
5918
5919 group->taskNum_ = 1;
5920 napi_value obj = NapiHelper::CreateObject(env);
5921 napi_ref ref = NapiHelper::CreateReference(env, obj, 1);
5922 group->groupRef_ = ref;
5923 group->RejectResult(env);
5924 napi_value exception = nullptr;
5925 napi_get_and_clear_last_exception(env, &exception);
5926 ASSERT_EQ(exception, nullptr);
5927 delete group;
5928 delete task;
5929 }
5930
5931 HWTEST_F(NativeEngineTest, TaskpoolTest289, testing::ext::TestSize.Level0)
5932 {
5933 napi_env env = (napi_env)engine_;
5934 TaskGroup* group = new TaskGroup(env);
5935 uv_loop_t* loop = NapiHelper::GetLibUV(env);
5936 ConcurrentHelper::UvHandleInit(loop, group->onRejectResultSignal_, NativeEngineTest::foo);
5937 group->TriggerRejectResult();
5938 napi_value exception = nullptr;
5939 napi_get_and_clear_last_exception(env, &exception);
5940 ASSERT_EQ(exception, nullptr);
5941 delete group;
5942 }
5943
5944 HWTEST_F(NativeEngineTest, TaskpoolTest290, testing::ext::TestSize.Level0)
5945 {
5946 napi_env env = (napi_env)engine_;
5947 uint32_t id = 1;
5948 napi_value taskId = NapiHelper::CreateUint32(env, id);
5949 napi_value argv[] = { taskId };
5950 NativeEngineTest::Cancel(env, argv, 1);
5951 napi_value exception = nullptr;
5952 napi_get_and_clear_last_exception(env, &exception);
5953 ASSERT_TRUE(exception != nullptr);
5954 }
5955
5956 HWTEST_F(NativeEngineTest, TaskpoolTest291, testing::ext::TestSize.Level0)
5957 {
5958 napi_env env = (napi_env)engine_;
5959 TaskManager& taskManager = TaskManager::GetInstance();
5960 Task* task = new Task();
5961 taskManager.StoreTask(task);
5962 task->taskType_ = TaskType::GROUP_COMMON_TASK;
5963 taskManager.CancelTask(env, task->taskId_);
5964 napi_value exception = nullptr;
5965 napi_get_and_clear_last_exception(env, &exception);
5966 ASSERT_TRUE(exception != nullptr);
5967
5968 TaskInfo* taskInfo = new TaskInfo();
5969 task->currentTaskInfo_ = taskInfo;
5970 taskManager.CancelTask(env, task->taskId_);
5971 exception = nullptr;
5972 napi_get_and_clear_last_exception(env, &exception);
5973 ASSERT_TRUE(exception != nullptr);
5974 task->taskState_ = ExecuteState::FINISHED;
5975 taskManager.CancelTask(env, task->taskId_);
5976 exception = nullptr;
5977 napi_get_and_clear_last_exception(env, &exception);
5978 ASSERT_TRUE(exception != nullptr);
5979
5980 task->taskState_ = ExecuteState::ENDING;
5981 taskManager.CancelTask(env, task->taskId_);
5982 exception = nullptr;
5983 napi_get_and_clear_last_exception(env, &exception);
5984 ASSERT_TRUE(exception != nullptr);
5985
5986 task->taskState_ = ExecuteState::RUNNING;
5987 task->groupId_ = 1;
5988 taskManager.CancelTask(env, task->taskId_);
5989 TaskGroup* group = new TaskGroup(env);
5990 group->groupId_ = reinterpret_cast<uint64_t>(group);
5991 TaskGroupManager::GetInstance().StoreTaskGroup(group->groupId_, group);
5992 task->groupId_ = group->groupId_;
5993 taskManager.CancelTask(env, task->taskId_);
5994 exception = nullptr;
5995 napi_get_and_clear_last_exception(env, &exception);
5996 ASSERT_TRUE(exception == nullptr);
5997 TaskManager::GetInstance().RemoveTask(task->taskId_);
5998 TaskGroupManager::GetInstance().RemoveTaskGroup(group->groupId_);
5999 delete taskInfo;
6000 delete task;
6001 delete group;
6002 }
6003
6004 HWTEST_F(NativeEngineTest, TaskpoolTest292, testing::ext::TestSize.Level0)
6005 {
6006 napi_env env = (napi_env)engine_;
6007 Task* task = new Task();
6008 TaskManager::GetInstance().StoreTask(task);
6009 task->env_ = env;
6010 task->taskType_ = TaskType::COMMON_TASK;
6011 task->taskState_ = ExecuteState::RUNNING;
6012 task->isMainThreadTask_ = false;
6013 napi_env runtimeEnv = nullptr;
6014 napi_create_runtime(env, &runtimeEnv);
6015 TaskManager::GetInstance().CancelTask(runtimeEnv, task->taskId_);
6016 napi_value exception = nullptr;
6017 napi_get_and_clear_last_exception(env, &exception);
6018 ASSERT_TRUE(exception == nullptr);
6019 TaskManager::GetInstance().RemoveTask(task->taskId_);
6020 delete task;
6021 }
6022
6023 HWTEST_F(NativeEngineTest, TaskpoolTest293, testing::ext::TestSize.Level0)
6024 {
6025 napi_env env = (napi_env)engine_;
6026 Task* task = new Task();
6027 task->env_ = env;
6028 TaskManager::GetInstance().StoreTask(task);
6029 task->isMainThreadTask_ = true;
6030 CancelTaskMessage* message = new CancelTaskMessage(ExecuteState::RUNNING, task->taskId_);
6031 task->TriggerCancel(message);
6032 usleep(100000); // 100000: is sleep 100ms
6033
6034 task->isMainThreadTask_ = false;
6035 CancelTaskMessage* message2 = new CancelTaskMessage(ExecuteState::RUNNING, task->taskId_);
6036 task->SetValid(false);
6037 task->TriggerCancel(message2);
6038 CancelTaskMessage* message3 = new CancelTaskMessage(ExecuteState::RUNNING, task->taskId_);
6039 task->SetValid(true);
6040 task->TriggerCancel(message3);
6041 uv_loop_t* loop = NapiHelper::GetLibUV(env);
6042 ConcurrentHelper::UvHandleInit(loop, task->onStartCancelSignal_, NativeEngineTest::foo);
6043 CancelTaskMessage* message4 = new CancelTaskMessage(ExecuteState::RUNNING, task->taskId_);
6044 task->TriggerCancel(message4);
6045 napi_value exception = nullptr;
6046 napi_get_and_clear_last_exception(env, &exception);
6047 ASSERT_TRUE(exception == nullptr);
6048 task->ReleaseData();
6049 }
6050
6051 HWTEST_F(NativeEngineTest, TaskpoolTest294, testing::ext::TestSize.Level0)
6052 {
6053 napi_env env = (napi_env)engine_;
6054 Task* task = new Task();
6055 task->env_ = env;
6056 task->CancelInner(ExecuteState::RUNNING);
6057 task->CancelInner(ExecuteState::WAITING);
6058 napi_value exception = nullptr;
6059 napi_get_and_clear_last_exception(env, &exception);
6060 ASSERT_TRUE(exception == nullptr);
6061 delete task;
6062 }
6063
6064 HWTEST_F(NativeEngineTest, TaskpoolTest295, testing::ext::TestSize.Level0)
6065 {
6066 napi_env env = (napi_env)engine_;
6067 Task* task = new Task();
6068 task->env_ = env;
6069 task->CancelInner(ExecuteState::RUNNING);
6070 task->CancelInner(ExecuteState::WAITING);
6071 napi_value exception = nullptr;
6072 napi_get_and_clear_last_exception(env, &exception);
6073 ASSERT_TRUE(exception == nullptr);
6074 delete task;
6075 }
6076
6077 HWTEST_F(NativeEngineTest, TaskpoolTest296, testing::ext::TestSize.Level0)
6078 {
6079 napi_env env = (napi_env)engine_;
6080 Task* task = new Task();
6081 task->env_ = env;
6082 uv_async_t* req = new uv_async_t;
6083 req->data = nullptr;
6084 Task::Cancel(req);
6085 task->taskId_ = 1000; // 1000: test number
6086 CancelTaskMessage* message = new CancelTaskMessage(ExecuteState::RUNNING, task->taskId_);
6087 req->data = message;
6088 Task::Cancel(req);
6089 TaskManager::GetInstance().StoreTask(task);
6090 CancelTaskMessage* message2 = new CancelTaskMessage(ExecuteState::RUNNING, task->taskId_);
6091 req->data = message2;
6092 Task::Cancel(req);
6093 napi_value exception = nullptr;
6094 napi_get_and_clear_last_exception(env, &exception);
6095 ASSERT_TRUE(exception == nullptr);
6096 delete req;
6097 }
6098
6099 HWTEST_F(NativeEngineTest, TaskpoolTest297, testing::ext::TestSize.Level0)
6100 {
6101 napi_env env = (napi_env)engine_;
6102 ExceptionScope scope(env);
6103
6104 AsyncRunner* asyncRunner = new AsyncRunner();
6105 asyncRunner->DecreaseAsyncCount();
6106 uint64_t refCount = asyncRunner->DecreaseAsyncCount();
6107 ASSERT_TRUE(refCount == 0);
6108 delete asyncRunner;
6109 }
6110
6111 HWTEST_F(NativeEngineTest, TaskpoolTest298, testing::ext::TestSize.Level0)
6112 {
6113 napi_env env = (napi_env)engine_;
6114 ExceptionScope scope(env);
6115
6116 Task* task = new Task();
6117 task->SetValid(false);
6118 task->taskType_ = TaskType::ASYNCRUNNER_TASK;
6119 bool res = task->ShouldDeleteTask();
6120 ASSERT_TRUE(res);
6121
6122 AsyncRunner* asyncRunner = new AsyncRunner();
6123 asyncRunner->asyncRunnerId_ = reinterpret_cast<uint64_t>(asyncRunner);
6124 AsyncRunnerManager::GetInstance().StoreAsyncRunner(asyncRunner->asyncRunnerId_, asyncRunner);
6125 task->asyncRunnerId_ = asyncRunner->asyncRunnerId_;
6126 res = task->ShouldDeleteTask();
6127 ASSERT_TRUE(res);
6128 delete task;
6129 }
6130
6131 HWTEST_F(NativeEngineTest, TaskpoolTest299, testing::ext::TestSize.Level0)
6132 {
6133 napi_env env = (napi_env)engine_;
6134 ExceptionScope scope(env);
6135 SequenceRunnerManager& sequenceRunnerManager = SequenceRunnerManager::GetInstance();
6136 SequenceRunner* seqRunner = new SequenceRunner();
6137 seqRunner->seqRunnerId_ = reinterpret_cast<uint64_t>(seqRunner);
6138 sequenceRunnerManager.StoreSequenceRunner(seqRunner->seqRunnerId_, seqRunner);
6139 Task* task = new Task();
6140 uint32_t taskId = TaskManager::GetInstance().CalculateTaskId(reinterpret_cast<uint64_t>(task));
6141 task->seqRunnerId_ = seqRunner->seqRunnerId_;
6142 task->taskId_ = taskId;
6143 task->taskType_ = TaskType::SEQRUNNER_TASK;
6144 sequenceRunnerManager.AddTaskToSeqRunner(seqRunner->seqRunnerId_, task);
6145 sequenceRunnerManager.RemoveWaitingTask(task);
6146 napi_value exception = nullptr;
6147 napi_get_and_clear_last_exception(env, &exception);
6148 ASSERT_TRUE(exception == nullptr);
6149 delete task;
6150 }
6151
6152 HWTEST_F(NativeEngineTest, TaskpoolTest300, testing::ext::TestSize.Level0)
6153 {
6154 napi_env env = (napi_env)engine_;
6155 ExceptionScope scope(env);
6156 SequenceRunnerManager& sequenceRunnerManager = SequenceRunnerManager::GetInstance();
6157 Task* task = new Task();
6158 task->seqRunnerId_ = 1;
6159 sequenceRunnerManager.RemoveWaitingTask(task);
6160 napi_value exception = nullptr;
6161 napi_get_and_clear_last_exception(env, &exception);
6162 ASSERT_TRUE(exception == nullptr);
6163 delete task;
6164 }
6165
6166 HWTEST_F(NativeEngineTest, TaskpoolTest301, testing::ext::TestSize.Level0)
6167 {
6168 napi_env env = (napi_env)engine_;
6169 ExceptionScope scope(env);
6170 SequenceRunner* seqRunner = new SequenceRunner();
6171 seqRunner->seqRunnerId_ = reinterpret_cast<uint64_t>(seqRunner);
6172 Task* task = new Task();
6173 seqRunner->RemoveWaitingTask(task);
6174 napi_value exception = nullptr;
6175 napi_get_and_clear_last_exception(env, &exception);
6176 ASSERT_TRUE(exception == nullptr);
6177 Task* task2 = new Task();
6178 seqRunner->AddTask(task2);
6179 seqRunner->RemoveWaitingTask(task);
6180 napi_get_and_clear_last_exception(env, &exception);
6181 ASSERT_TRUE(exception == nullptr);
6182 delete task;
6183 delete task2;
6184 }
6185
6186 HWTEST_F(NativeEngineTest, TaskpoolTest302, testing::ext::TestSize.Level0)
6187 {
6188 napi_env env = (napi_env)engine_;
6189 ExceptionScope scope(env);
6190 bool isFalse = SequenceRunnerManager::GetInstance().FindRunnerAndRef(302);
6191 ASSERT_FALSE(isFalse);
6192 SequenceRunner* seqRunner = new SequenceRunner();
6193 seqRunner->DecreaseSeqCount();
6194 isFalse = seqRunner->DecreaseSeqCount();
6195 ASSERT_FALSE(isFalse);
6196 }
6197
6198 HWTEST_F(NativeEngineTest, TaskpoolTest303, testing::ext::TestSize.Level0)
6199 {
6200 napi_env env = (napi_env)engine_;
6201 ExceptionScope scope(env);
6202 SequenceRunner* seqRunner = new SequenceRunner();
6203 seqRunner->seqRunnerId_ = reinterpret_cast<uint64_t>(seqRunner);
6204 SequenceRunnerManager::GetInstance().StoreSequenceRunner(seqRunner->seqRunnerId_, seqRunner);
6205 Task* task = new Task();
6206 task->seqRunnerId_ = seqRunner->seqRunnerId_;
6207 bool isFalse = SequenceRunnerManager::GetInstance().TriggerSeqRunner(env, task);
6208 ASSERT_FALSE(isFalse);
6209 delete task;
6210 }
6211
6212 HWTEST_F(NativeEngineTest, TaskpoolTest304, testing::ext::TestSize.Level0)
6213 {
6214 napi_env env = (napi_env)engine_;
6215 ExceptionScope scope(env);
6216 Task* task = new Task();
6217 task->seqRunnerId_ = 304;
6218 task->taskType_ = TaskType::SEQRUNNER_TASK;
6219 Task::CleanupHookFunc(task);
6220 napi_value exception = nullptr;
6221 napi_get_and_clear_last_exception(env, &exception);
6222 ASSERT_TRUE(exception == nullptr);
6223 delete task;
6224 }
6225
6226 HWTEST_F(NativeEngineTest, TaskpoolTest305, testing::ext::TestSize.Level0)
6227 {
6228 napi_env env = (napi_env)engine_;
6229 ExceptionScope scope(env);
6230 Task* task = new Task();
6231 task->seqRunnerId_ = 305;
6232 task->env_ = env;
6233 task->taskType_ = TaskType::SEQRUNNER_TASK;
6234 napi_value obj = NapiHelper::CreateObject(env);
6235 task->taskRef_ = NapiHelper::CreateReference(env, obj, 1);
6236 task->CancelInner(ExecuteState::CANCELED);
6237 napi_value exception = nullptr;
6238 napi_get_and_clear_last_exception(env, &exception);
6239 ASSERT_TRUE(exception == nullptr);
6240 delete task;
6241 }
6242
6243 HWTEST_F(NativeEngineTest, TaskpoolTest306, testing::ext::TestSize.Level0)
6244 {
6245 napi_env env = (napi_env)engine_;
6246 ExceptionScope scope(env);
6247 Task* task = new Task();
6248 task->taskId_ = 306;
6249 task->SetHasDependency(true);
6250 task->env_ = env;
6251 task->CancelInner(ExecuteState::DELAYED);
6252 napi_value exception = nullptr;
6253 napi_get_and_clear_last_exception(env, &exception);
6254 ASSERT_TRUE(exception == nullptr);
6255 delete task;
6256 }
6257
6258 HWTEST_F(NativeEngineTest, TaskpoolTest307, testing::ext::TestSize.Level0)
6259 {
6260 napi_env env = (napi_env)engine_;
6261 ExceptionScope scope(env);
6262 uint32_t taskId = 307;
6263 std::set<uint32_t> taskIds{1};
6264 TaskManager::GetInstance().StoreTaskDependency(taskId, taskIds);
6265 TaskManager::GetInstance().ClearDependentTask(taskId);
6266 napi_value exception = nullptr;
6267 napi_get_and_clear_last_exception(env, &exception);
6268 ASSERT_TRUE(exception == nullptr);
6269 }
6270
6271 HWTEST_F(NativeEngineTest, TaskpoolTest308, testing::ext::TestSize.Level0)
6272 {
6273 napi_env env = (napi_env)engine_;
6274 ExceptionScope scope(env);
6275 uint32_t taskId = 308;
6276 uint32_t taskId2 = 1308;
6277 std::set<uint32_t> taskIds{taskId2};
6278 TaskManager::GetInstance().StoreDependentTaskInfo(taskIds, taskId);
6279 TaskManager::GetInstance().ClearDependentTask(taskId2);
6280 napi_value exception = nullptr;
6281 napi_get_and_clear_last_exception(env, &exception);
6282 ASSERT_TRUE(exception == nullptr);
6283 }
6284
6285 HWTEST_F(NativeEngineTest, TaskpoolTest309, testing::ext::TestSize.Level0)
6286 {
6287 napi_env env = (napi_env)engine_;
6288 ExceptionScope scope(env);
6289 uint32_t taskId = 309;
6290 Task* task = new Task();
6291 task->env_ = env;
6292 napi_value obj = NapiHelper::CreateObject(env);
6293 task->taskRef_ = NapiHelper::CreateReference(env, obj, 1);
6294 TaskManager::GetInstance().StoreTask(task);
6295 std::set<uint32_t> taskIds{taskId};
6296 TaskManager::GetInstance().StoreDependentTaskInfo(taskIds, task->taskId_);
6297 TaskManager::GetInstance().ClearDependentTask(taskId);
6298 napi_value exception = nullptr;
6299 napi_get_and_clear_last_exception(env, &exception);
6300 ASSERT_TRUE(exception == nullptr);
6301 }
6302
6303 HWTEST_F(NativeEngineTest, TaskpoolTest310, testing::ext::TestSize.Level0)
6304 {
6305 napi_env env = (napi_env)engine_;
6306 ExceptionScope scope(env);
6307 uint32_t taskId = 310;
6308 Task* task = new Task();
6309 task->env_ = env;
6310 napi_value obj = NapiHelper::CreateObject(env);
6311 task->taskRef_ = NapiHelper::CreateReference(env, obj, 1);
6312 task->currentTaskInfo_ = new TaskInfo();
6313 TaskManager::GetInstance().StoreTask(task);
6314 std::set<uint32_t> taskIds{taskId};
6315 TaskManager::GetInstance().StoreDependentTaskInfo(taskIds, task->taskId_);
6316 TaskManager::GetInstance().ClearDependentTask(taskId);
6317 napi_value exception = nullptr;
6318 napi_get_and_clear_last_exception(env, &exception);
6319 ASSERT_TRUE(exception == nullptr);
6320 }
6321
6322 HWTEST_F(NativeEngineTest, TaskpoolTest311, testing::ext::TestSize.Level0)
6323 {
6324 napi_env env = (napi_env)engine_;
6325 ExceptionScope scope(env);
6326 uint32_t taskId = 311;
6327 uint32_t taskId2 = 1311;
6328 std::set<uint32_t> taskIds{taskId2};
6329 TaskManager::GetInstance().StoreDependentTaskInfo(taskIds, taskId);
6330 TaskManager::GetInstance().RemoveDependentTaskInfo(taskId2, taskId);
6331 TaskManager::GetInstance().ClearDependentTask(taskId2);
6332 napi_value exception = nullptr;
6333 napi_get_and_clear_last_exception(env, &exception);
6334 ASSERT_TRUE(exception == nullptr);
6335 }
6336
6337 HWTEST_F(NativeEngineTest, TaskpoolTest312, testing::ext::TestSize.Level0)
6338 {
6339 napi_env env = (napi_env)engine_;
6340 ExceptionScope scope(env);
6341 napi_value napiTask = CreateTaskObject(env, TaskType::TASK, ExecuteState::FINISHED, true);
6342 napi_value argv[] = {napiTask};
6343 napi_value result = NativeEngineTest::Execute(env, argv, 1);
6344 ASSERT_TRUE(result != nullptr);
6345 Task* task = nullptr;
6346 napi_unwrap(env, napiTask, reinterpret_cast<void**>(&task));
6347 TaskManager::GetInstance().RemoveTask(task->taskId_);
6348 napi_value exception = nullptr;
6349 napi_get_and_clear_last_exception(env, &exception);
6350 ASSERT_TRUE(exception == nullptr);
6351
6352 napi_value napiTask2 = CreateTaskObject(env, TaskType::TASK, ExecuteState::CANCELED, true);
6353 Task* task2 = nullptr;
6354 napi_unwrap(env, napiTask2, reinterpret_cast<void**>(&task2));
6355 task2->isCancelToFinish_ = true;
6356 napi_value argv2[] = {napiTask2};
6357 result = NativeEngineTest::Execute(env, argv2, 1);
6358 ASSERT_TRUE(result != nullptr);
6359 TaskManager::GetInstance().RemoveTask(task2->taskId_);
6360 }