1 /* 2 * Copyright (c) 2021 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 #include <atomic> 16 #include <chrono> 17 #include <hwext/gtest-ext.h> 18 #include <hwext/gtest-tag.h> 19 #include <sys/time.h> 20 #include <thread> 21 22 #include "schedule_task_manager.h" 23 24 using namespace testing::ext; 25 26 namespace { 27 class ScheduleTaskManagerTest : public testing::Test { 28 protected: SetUpTestCase()29 static void SetUpTestCase() {} TearDownTestCase()30 static void TearDownTestCase() 31 { 32 ScheduleTaskManager::GetInstance().Shutdown(); 33 } 34 }; 35 36 /** 37 * @tc.name: base 38 * @tc.desc: Get Instance. 39 * @tc.type: FUNC 40 */ 41 HWTEST_F(ScheduleTaskManagerTest, GetInstance, TestSize.Level1) 42 { 43 ScheduleTaskManager::GetInstance(); 44 } 45 46 /** 47 * @tc.name: base 48 * @tc.desc: Single task processing. 49 * @tc.type: FUNC 50 */ 51 HWTEST_F(ScheduleTaskManagerTest, ScheduleTaskOneshot, TestSize.Level1) 52 { 53 std::atomic<int> count = 0; 54 ScheduleTaskManager::ms initalDelay{10}; 55 56 ScheduleTaskManager scheduleTaskManager; 57 EXPECT_TRUE(scheduleTaskManager.ScheduleTask( __anon0a7c5e3a0302() 58 "task-1", [&]() { count++; }, ScheduleTaskManager::ms{0}, initalDelay)); 59 60 std::this_thread::sleep_for(initalDelay + initalDelay); 61 EXPECT_EQ(count.load(), 1); 62 63 scheduleTaskManager.Shutdown(); 64 } 65 66 /** 67 * @tc.name: base 68 * @tc.desc: Repetitive task processing. 69 * @tc.type: FUNC 70 */ 71 HWTEST_F(ScheduleTaskManagerTest, ScheduleTaskRepeated, TestSize.Level1) 72 { 73 std::atomic<int> count = 0; 74 constexpr int cnt = 5; 75 76 ScheduleTaskManager::ms repeatInterval{100}; 77 ScheduleTaskManager::ms initalDelay{10}; 78 79 ScheduleTaskManager scheduleTaskManager; 80 EXPECT_TRUE(scheduleTaskManager.ScheduleTask( 81 "task-2", __anon0a7c5e3a0402() 82 [&]() { 83 count++; 84 struct timeval tv; 85 gettimeofday(&tv, nullptr); 86 }, 87 repeatInterval, initalDelay)); 88 89 int expected = 0; 90 std::this_thread::sleep_for(initalDelay + initalDelay); 91 for (int i = 0; i < cnt; i++) { 92 expected++; 93 struct timeval tv = { 0, 0 }; 94 gettimeofday(&tv, nullptr); 95 EXPECT_EQ(count.load(), expected); 96 std::this_thread::sleep_for(repeatInterval); 97 } 98 99 scheduleTaskManager.Shutdown(); 100 } 101 102 /** 103 * @tc.name: base 104 * @tc.desc: Unschedule Task. 105 * @tc.type: FUNC 106 */ 107 HWTEST_F(ScheduleTaskManagerTest, UnscheduleTask, TestSize.Level1) 108 { 109 std::atomic<int> count = 0; 110 constexpr int cnt = 5; 111 112 std::string taskName = "task-3"; 113 ScheduleTaskManager::ms repeatInterval{100}; 114 ScheduleTaskManager::ms initalDelay{10}; 115 116 ScheduleTaskManager scheduleTaskManager; 117 EXPECT_TRUE(scheduleTaskManager.ScheduleTask( 118 taskName, __anon0a7c5e3a0502() 119 [&]() { 120 count++; 121 struct timeval tv; 122 gettimeofday(&tv, nullptr); 123 }, 124 repeatInterval)); 125 126 int expected = 0; 127 std::this_thread::sleep_for(initalDelay); 128 for (int i = 0; i < cnt; i++) { 129 std::this_thread::sleep_for(repeatInterval); 130 expected++; 131 struct timeval tv = { 0, 0 }; 132 gettimeofday(&tv, nullptr); 133 EXPECT_EQ(count.load(), expected); 134 } 135 136 EXPECT_TRUE(scheduleTaskManager.UnscheduleTask(taskName)); 137 scheduleTaskManager.Shutdown(); 138 } 139 } // namespace