1 /* 2 * Copyright (c) 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 "screenlock/screen_lock.h" 17 18 #include <gtest/gtest.h> 19 namespace { 20 using namespace OHOS::DistributedData; 21 using namespace testing::ext; 22 class ScreenLockObserver : public ScreenManager::Observer { 23 public: OnScreenUnlocked(int32_t user)24 void OnScreenUnlocked(int32_t user) override 25 { 26 } 27 GetName()28 std::string GetName() override 29 { 30 return name_; 31 } 32 SetName(const std::string & name)33 void SetName(const std::string &name) 34 { 35 name_ = name; 36 } 37 38 private: 39 std::string name_ = "screenTestObserver"; 40 }; 41 42 class ScreenLockTest : public testing::Test { 43 public: SetUpTestCase(void)44 static void SetUpTestCase(void) 45 { 46 } TearDownTestCase(void)47 static void TearDownTestCase(void) 48 { 49 } SetUp()50 void SetUp() 51 { 52 } TearDown()53 void TearDown() 54 { 55 } 56 protected: 57 static constexpr int32_t MAX_RETRY_TIME = 300; 58 }; 59 60 /** 61 * @tc.name: Subscribe001 62 * @tc.desc: invalid param 63 * @tc.type: FUNC 64 * @tc.require: 65 * @tc.author: 66 */ 67 HWTEST_F(ScreenLockTest, Subscribe001, TestSize.Level0) 68 { 69 auto screenLock = std::make_shared<ScreenLock>(); 70 screenLock->Subscribe(nullptr); 71 EXPECT_TRUE(screenLock->observerMap_.Empty()); 72 auto observer = std::make_shared<ScreenLockObserver>(); 73 observer->SetName(""); 74 screenLock->Subscribe(observer); 75 EXPECT_TRUE(screenLock->observerMap_.Empty()); 76 } 77 78 /** 79 * @tc.name: Subscribe002 80 * @tc.desc: valid param 81 * @tc.type: FUNC 82 * @tc.require: 83 * @tc.author: 84 */ 85 HWTEST_F(ScreenLockTest, Subscribe002, TestSize.Level0) 86 { 87 auto screenLock = std::make_shared<ScreenLock>(); 88 auto observer = std::make_shared<ScreenLockObserver>(); 89 screenLock->Subscribe(observer); 90 EXPECT_TRUE(screenLock->observerMap_.Contains(observer->GetName())); 91 screenLock->Subscribe(observer); 92 EXPECT_EQ(screenLock->observerMap_.Size(), 1); 93 } 94 95 /** 96 * @tc.name: Unsubscribe001 97 * @tc.desc: test normal unsubscribe 98 * @tc.type: FUNC 99 * @tc.require: 100 * @tc.author: 101 */ 102 HWTEST_F(ScreenLockTest, Unsubscribe001, TestSize.Level0) 103 { 104 auto screenLock = std::make_shared<ScreenLock>(); 105 auto observer = std::make_shared<ScreenLockObserver>(); 106 screenLock->Subscribe(observer); 107 EXPECT_EQ(screenLock->observerMap_.Size(), 1); 108 screenLock->Unsubscribe(observer); 109 EXPECT_TRUE(screenLock->observerMap_.Empty()); 110 } 111 112 /** 113 * @tc.name: SubscribeScreenEvent001 114 * @tc.desc: subscribe ScreenEvent 115 * @tc.type: FUNC 116 * @tc.author: 117 */ 118 HWTEST_F(ScreenLockTest, SubscribeScreenEvent001, TestSize.Level0) 119 { 120 auto executor = std::make_shared<OHOS::ExecutorPool>(12, 5); 121 auto screenLock = std::make_shared<ScreenLock>(); 122 screenLock->BindExecutor(executor); 123 ASSERT_NE(screenLock->executors_, nullptr); 124 EXPECT_EQ(screenLock->eventSubscriber_, nullptr); 125 screenLock->SubscribeScreenEvent(); 126 EXPECT_NE(screenLock->eventSubscriber_, nullptr); 127 screenLock->UnsubscribeScreenEvent(); 128 screenLock->executors_ = nullptr; 129 } 130 131 /** 132 * @tc.name: SubscribeScreenEvent002 133 * @tc.desc: subscribe ScreenEvent 134 * @tc.type: FUNC 135 * @tc.author: 136 */ 137 HWTEST_F(ScreenLockTest, SubscribeScreenEvent002, TestSize.Level0) 138 { 139 auto screenLock = std::make_shared<ScreenLock>(); 140 EXPECT_EQ(screenLock->executors_, nullptr); 141 EXPECT_EQ(screenLock->eventSubscriber_, nullptr); 142 screenLock->SubscribeScreenEvent(); 143 EXPECT_NE(screenLock->eventSubscriber_, nullptr); 144 screenLock->UnsubscribeScreenEvent(); 145 } 146 147 /** 148 * @tc.name: GetTask001 149 * @tc.desc: subscribe ScreenEvent 150 * @tc.type: FUNC 151 * @tc.author: 152 */ 153 HWTEST_F(ScreenLockTest, GetTask001, TestSize.Level0) 154 { 155 auto screenLock = std::make_shared<ScreenLock>(); 156 EXPECT_EQ(screenLock->executors_, nullptr); 157 EXPECT_EQ(screenLock->eventSubscriber_, nullptr); 158 auto Task = screenLock->GetTask(0); 159 Task(); 160 auto executor = std::make_shared<OHOS::ExecutorPool>(12, 5); 161 screenLock->BindExecutor(executor); 162 ASSERT_NE(screenLock->executors_, nullptr); 163 Task = screenLock->GetTask(MAX_RETRY_TIME - 1); 164 Task(); 165 } 166 167 /** 168 * @tc.name: GetTask002 169 * @tc.desc: subscribe ScreenEvent 170 * @tc.type: FUNC 171 * @tc.author: 172 */ 173 HWTEST_F(ScreenLockTest, GetTask002, TestSize.Level0) 174 { 175 auto screenLock = std::make_shared<ScreenLock>(); 176 EXPECT_EQ(screenLock->executors_, nullptr); 177 EXPECT_EQ(screenLock->eventSubscriber_, nullptr); 178 screenLock->SubscribeScreenEvent(); 179 EXPECT_NE(screenLock->eventSubscriber_, nullptr); 180 auto Task = screenLock->GetTask(0); 181 Task(); 182 } 183 } // namespace