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, TestSize.Level1) 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, TestSize.Level1) 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, TestSize.Level1) 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; __anon87d717cc0202() 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, TestSize.Level1) 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; __anon87d717cc0302() 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 HWTEST_F(TaskSchedulerTest, AddExportTask2, TestSize.Level1) 103 { 104 std::string threadName = "threadName"; 105 std::string funcName = "funcName"; 106 std::shared_ptr<TaskScheduler> taskScheduler = std::make_shared<TaskScheduler>(threadName); 107 pid_t taskTid = 0; __anon87d717cc0402() 108 auto taskFunc = [&taskTid]() { 109 GTEST_LOG_(INFO) << "START_TASK"; 110 taskTid = gettid(); 111 }; 112 ASSERT_NE(taskScheduler, nullptr); 113 ASSERT_EQ(taskScheduler->exportFuncMap_.size(), 0); __anon87d717cc0502null114 auto testTask = [taskScheduler, funcName, taskFunc] { 115 taskScheduler->AddExportTask(funcName, taskFunc); 116 return 0; 117 }; 118 taskScheduler->PostSyncTask(testTask); 119 ASSERT_EQ(taskTid, 0); 120 ASSERT_NE(taskScheduler->exportFuncMap_.size(), 0); 121 } 122 123 HWTEST_F(TaskSchedulerTest, SetExportHandler, TestSize.Level1) 124 { 125 std::string exportThreadName = "exportThread"; 126 auto eventRunner = AppExecFwk::EventRunner::Create(exportThreadName); 127 auto eventHandler = std::make_shared<AppExecFwk::EventHandler>(eventRunner); 128 std::string threadName = "threadName"; 129 std::shared_ptr<TaskScheduler> taskScheduler = std::make_shared<TaskScheduler>(threadName); 130 taskScheduler->SetExportHandler(eventHandler); 131 ASSERT_EQ(eventHandler.get(), taskScheduler->exportHandler_.get()); 132 } 133 134 HWTEST_F(TaskSchedulerTest, ExecuteExportTask, TestSize.Level1) 135 { 136 std::string threadName = "threadName"; 137 std::shared_ptr<TaskScheduler> taskScheduler = std::make_shared<TaskScheduler>(threadName); 138 bool executed = false; 139 std::string funcName = "funcName"; __anon87d717cc0602() 140 auto taskFunc = [&executed]() { 141 GTEST_LOG_(INFO) << "START_TASK"; 142 executed = true; 143 }; 144 ASSERT_EQ(taskScheduler->exportFuncMap_.size(), 0); 145 taskScheduler->ExecuteExportTask(); 146 ASSERT_EQ(taskScheduler->exportFuncMap_.size(), 0); 147 ASSERT_EQ(executed, false); 148 taskScheduler->exportFuncMap_["taskFunc"] = taskFunc; 149 ASSERT_EQ(taskScheduler->exportFuncMap_.size(), 1); 150 taskScheduler->ExecuteExportTask(); 151 152 std::string exportThreadName = "exportThread"; 153 auto eventRunner = AppExecFwk::EventRunner::Create(exportThreadName); 154 auto eventHandler = std::make_shared<AppExecFwk::EventHandler>(eventRunner); 155 taskScheduler->SetExportHandler(eventHandler); 156 taskScheduler->ExecuteExportTask(); 157 ASSERT_EQ(taskScheduler->exportFuncMap_.size(), 0); 158 } 159 } // namespace 160 } // namespace Rosen 161 } // namespace OHOS 162