1 /* 2 * Copyright (c) 2023 Huawei Device Co., Ltd. 3 * Licensed under the Apache License, Version 2.0 (the "License"); 4 * you may not use this file except in compliance with the License. 5 * You may obtain a copy of the License at 6 * 7 * http://www.apache.org/licenses/LICENSE-2.0 8 * 9 * Unless required by applicable law or agreed to in writing, software 10 * distributed under the License is distributed on an "AS IS" BASIS, 11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 * See the License for the specific language governing permissions and 13 * limitations under the License. 14 */ 15 16 #include "common/include/task_scheduler.h" 17 #include <gtest/gtest.h> 18 19 using namespace testing; 20 using namespace testing::ext; 21 namespace OHOS { 22 namespace Rosen { 23 class TaskSchedulerTest : public testing::Test { 24 public: TaskSchedulerTest()25 TaskSchedulerTest() {} ~TaskSchedulerTest()26 ~TaskSchedulerTest() {} 27 }; 28 29 namespace { 30 /** 31 * @tc.name: task_scheduler_test001 32 * @tc.desc: normal function 33 * @tc.type: FUNC 34 */ 35 HWTEST_F(TaskSchedulerTest, task_scheduler_test001, Function | SmallTest | Level2) 36 { 37 GTEST_LOG_(INFO) << "TaskSchedulerTest: task_scheduler_test001 start"; 38 std::string threadName = "threadName"; 39 std::string name = "name"; 40 TaskScheduler* taskScheduler = new(std::nothrow) TaskScheduler(threadName); 41 int res = 0; 42 taskScheduler->RemoveTask(name); 43 ASSERT_EQ(res, 0); 44 delete taskScheduler; 45 GTEST_LOG_(INFO) << "TaskSchedulerTest: task_scheduler_test001 end"; 46 } 47 48 /** 49 * @tc.name: GetEventHandler 50 * @tc.desc: GetEventHandler function 51 * @tc.type: FUNC 52 */ 53 HWTEST_F(TaskSchedulerTest, GetEventHandler, Function | SmallTest | Level2) 54 { 55 std::string threadName = "threadName"; 56 std::shared_ptr<TaskScheduler> taskScheduler = std::make_shared<TaskScheduler>(threadName); 57 ASSERT_NE(taskScheduler, nullptr); 58 EXPECT_NE(taskScheduler->GetEventHandler(), nullptr); 59 } 60 61 /** 62 * @tc.name: PostTask 63 * @tc.desc: PostTask function 64 * @tc.type: FUNC 65 */ 66 HWTEST_F(TaskSchedulerTest, PostTask, Function | SmallTest | Level2) 67 { 68 std::string threadName = "threadName"; 69 std::shared_ptr<TaskScheduler> taskScheduler = std::make_shared<TaskScheduler>(threadName); 70 ASSERT_NE(taskScheduler, nullptr); 71 int resultValue = 0; __anon3375362a0202() 72 auto taskFunc = [&resultValue]() { 73 GTEST_LOG_(INFO) << "START_TASK"; 74 resultValue = 1; 75 }; 76 taskScheduler->PostAsyncTask(taskFunc, "ssmTask"); 77 EXPECT_NE(taskScheduler->handler_, nullptr); 78 EXPECT_EQ(resultValue, 0); 79 80 int64_t delayTime = 1; 81 taskScheduler->PostAsyncTask(taskFunc, "ssmTask", delayTime); 82 EXPECT_EQ(resultValue, 0); 83 } 84 85 HWTEST_F(TaskSchedulerTest, AddExportTask1, Function | SmallTest | Level2) 86 { 87 std::string threadName = "threadName"; 88 std::string funcName = "funcName"; 89 std::shared_ptr<TaskScheduler> taskScheduler = std::make_shared<TaskScheduler>(threadName); 90 pid_t taskTid = 0; __anon3375362a0302() 91 auto taskFunc = [&taskTid]() { 92 GTEST_LOG_(INFO) << "START_TASK"; 93 taskTid = gettid(); 94 }; 95 ASSERT_NE(taskScheduler, nullptr); 96 ASSERT_EQ(taskScheduler->exportFuncMap_.size(), 0); 97 taskScheduler->AddExportTask(funcName, taskFunc); 98 ASSERT_EQ(taskTid, gettid()); 99 ASSERT_EQ(taskScheduler->exportFuncMap_.size(), 0); 100 } 101 102 103 HWTEST_F(TaskSchedulerTest, AddExportTask2, Function | SmallTest | Level2) 104 { 105 std::string threadName = "threadName"; 106 std::string funcName = "funcName"; 107 std::shared_ptr<TaskScheduler> taskScheduler = std::make_shared<TaskScheduler>(threadName); 108 pid_t taskTid = 0; __anon3375362a0402() 109 auto taskFunc = [&taskTid]() { 110 GTEST_LOG_(INFO) << "START_TASK"; 111 taskTid = gettid(); 112 }; 113 ASSERT_NE(taskScheduler, nullptr); 114 ASSERT_EQ(taskScheduler->exportFuncMap_.size(), 0); __anon3375362a0502null115 auto testTask = [taskScheduler, funcName, taskFunc] { 116 taskScheduler->AddExportTask(funcName, taskFunc); 117 return 0; 118 }; 119 taskScheduler->PostSyncTask(testTask); 120 ASSERT_EQ(taskTid, 0); 121 ASSERT_NE(taskScheduler->exportFuncMap_.size(), 0); 122 } 123 124 HWTEST_F(TaskSchedulerTest, SetExportHandler, Function | SmallTest | Level2) 125 { 126 std::string exportThreadName = "exportThread"; 127 auto eventRunner = AppExecFwk::EventRunner::Create(exportThreadName); 128 auto eventHandler = std::make_shared<AppExecFwk::EventHandler>(eventRunner); 129 std::string threadName = "threadName"; 130 std::shared_ptr<TaskScheduler> taskScheduler = std::make_shared<TaskScheduler>(threadName); 131 taskScheduler->SetExportHandler(eventHandler); 132 ASSERT_EQ(eventHandler.get(), taskScheduler->exportHandler_.get()); 133 } 134 135 HWTEST_F(TaskSchedulerTest, ExecuteExportTask, Function | SmallTest | Level2) 136 { 137 std::string threadName = "threadName"; 138 std::shared_ptr<TaskScheduler> taskScheduler = std::make_shared<TaskScheduler>(threadName); 139 bool executed = false; 140 std::string funcName = "funcName"; __anon3375362a0602() 141 auto taskFunc = [&executed]() { 142 GTEST_LOG_(INFO) << "START_TASK"; 143 executed = true; 144 }; 145 ASSERT_EQ(taskScheduler->exportFuncMap_.size(), 0); 146 taskScheduler->ExecuteExportTask(); 147 ASSERT_EQ(taskScheduler->exportFuncMap_.size(), 0); 148 ASSERT_EQ(executed, false); 149 taskScheduler->exportFuncMap_["taskFunc"] = taskFunc; 150 ASSERT_EQ(taskScheduler->exportFuncMap_.size(), 1); 151 taskScheduler->ExecuteExportTask(); 152 153 std::string exportThreadName = "exportThread"; 154 auto eventRunner = AppExecFwk::EventRunner::Create(exportThreadName); 155 auto eventHandler = std::make_shared<AppExecFwk::EventHandler>(eventRunner); 156 taskScheduler->SetExportHandler(eventHandler); 157 taskScheduler->ExecuteExportTask(); 158 ASSERT_EQ(taskScheduler->exportFuncMap_.size(), 0); 159 } 160 } // namespace 161 } // namespace Rosen 162 } // namespace OHOS 163