1 /* 2 * Copyright (c) 2022-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 <gtest/gtest.h> 17 #include <system_ability_definition.h> 18 19 #include "accesstoken_kit.h" 20 #include "mock_accesstoken_kit.h" 21 #include "permission.h" 22 #include "power_common.h" 23 #include "power_log.h" 24 25 #define private public 26 #define protected public 27 #include "power_vibrator.h" 28 #include "vibrator_source_parser.h" 29 #undef private 30 #undef protected 31 32 #include "setting_observer.h" 33 #include "setting_provider.h" 34 #include "sysparam.h" 35 #include "tokenid_kit.h" 36 37 using namespace OHOS::Security::AccessToken; 38 using namespace OHOS::PowerMgr; 39 using namespace testing::ext; 40 using namespace std; 41 42 namespace OHOS { 43 namespace PowerMgr { 44 class PowerMgrUtilTest : public testing::Test {}; 45 } // namespace PowerMgr 46 } // namespace OHOS 47 48 namespace { 49 const std::string POWER_VIBRATOR_CONFIG_FILE = "etc/power_config/power_vibrator.json"; 50 const std::string VENDOR_POWER_VIBRATOR_CONFIG_FILE = "/vendor/etc/power_config/power_vibrator.json"; 51 const std::string SYSTEM_POWER_VIBRATOR_CONFIG_FILE = "/system/etc/power_config/power_vibrator.json"; 52 const std::string SHUTDOWN_DIAG = "shutdown_diag"; 53 54 /** 55 * @tc.name: PermissionIsSystemNative 56 * @tc.desc: The IsSystem and IsPermissionGranted functions are granted by default as TOKEN_NATIVE or TOKEN_SHELL types 57 * @tc.type: FUNC 58 */ 59 HWTEST_F(PowerMgrUtilTest, PermissionIsSystemNative, TestSize.Level0) 60 { 61 MockAccesstokenKit::MockSetTokenTypeFlag(ATokenTypeEnum::TOKEN_NATIVE); 62 EXPECT_TRUE(Permission::IsSystem()); 63 EXPECT_TRUE(Permission::IsPermissionGranted("REBOOT")); 64 65 MockAccesstokenKit::MockSetTokenTypeFlag(ATokenTypeEnum::TOKEN_SHELL); 66 EXPECT_TRUE(Permission::IsSystem()); 67 EXPECT_TRUE(Permission::IsPermissionGranted("REBOOT")); 68 } 69 70 /** 71 * @tc.name: PermissionIsSystemHap 72 * @tc.desc: The function IsSystem and IsPermissionGranted in the test TOKEN_HAP 73 * @tc.type: FUNC 74 */ 75 HWTEST_F(PowerMgrUtilTest, PermissionIsSystemHap, TestSize.Level0) 76 { 77 MockAccesstokenKit::MockSetTokenTypeFlag(ATokenTypeEnum::TOKEN_HAP); 78 MockAccesstokenKit::MockSetSystemApp(false); 79 EXPECT_FALSE(Permission::IsSystem()); 80 81 MockAccesstokenKit::MockSetSystemApp(true); 82 EXPECT_TRUE(Permission::IsSystem()); 83 MockAccesstokenKit::MockSetPermissionState(PermissionState::PERMISSION_GRANTED); 84 EXPECT_TRUE(Permission::IsPermissionGranted("REBOOT")); 85 } 86 87 /** 88 * @tc.name: PermissionIsSystemInvalid 89 * @tc.desc: The IsSystem and IsPermissionGranted do not have permissions on TOKEN_INVALID or TOKEN_TYPE_BUTT types 90 * @tc.type: FUNC 91 */ 92 HWTEST_F(PowerMgrUtilTest, PermissionIsSystemInvalid, TestSize.Level0) 93 { 94 MockAccesstokenKit::MockSetTokenTypeFlag(ATokenTypeEnum::TOKEN_INVALID); 95 EXPECT_FALSE(Permission::IsSystem()); 96 EXPECT_FALSE(Permission::IsPermissionGranted("REBOOT")); 97 98 MockAccesstokenKit::MockSetTokenTypeFlag(ATokenTypeEnum::TOKEN_TYPE_BUTT); 99 EXPECT_FALSE(Permission::IsSystem()); 100 EXPECT_FALSE(Permission::IsPermissionGranted("REBOOT")); 101 } 102 103 /** 104 * @tc.name: PermissionIsPermissionGrantedHap 105 * @tc.desc: Test Permission function IsPermissionGranted is TOKEN_HAP 106 * @tc.type: FUNC 107 */ 108 HWTEST_F(PowerMgrUtilTest, PermissionIsPermissionGrantedHap, TestSize.Level0) 109 { 110 MockAccesstokenKit::MockSetTokenTypeFlag(ATokenTypeEnum::TOKEN_HAP); 111 MockAccesstokenKit::MockSetPermissionState(PermissionState::PERMISSION_DENIED); 112 EXPECT_FALSE(Permission::IsPermissionGranted("REBOOT")); 113 114 MockAccesstokenKit::MockSetPermissionState(PermissionState::PERMISSION_GRANTED); 115 EXPECT_TRUE(Permission::IsPermissionGranted("REBOOT")); 116 } 117 118 /** 119 * @tc.name: PermissionIsPermissionGrantedNative 120 * @tc.desc: Test function IsPermissionGranted is TOKEN_NATIVE or TOKEN_SHELL with permissions by default 121 * @tc.type: FUNC 122 */ 123 HWTEST_F(PowerMgrUtilTest, PermissionIsPermissionGrantedNative, TestSize.Level0) 124 { 125 MockAccesstokenKit::MockSetTokenTypeFlag(ATokenTypeEnum::TOKEN_NATIVE); 126 EXPECT_TRUE(Permission::IsPermissionGranted("REBOOT")); 127 128 MockAccesstokenKit::MockSetTokenTypeFlag(ATokenTypeEnum::TOKEN_SHELL); 129 EXPECT_TRUE(Permission::IsPermissionGranted("REBOOT")); 130 } 131 132 /** 133 * @tc.name: PermissionIsPermissionGrantedInvalid 134 * @tc.desc: Test Permission function IsSystem is TOKEN_INVALID or TOKEN_TYPE_BUTT without permission 135 * @tc.type: FUNC 136 */ 137 HWTEST_F(PowerMgrUtilTest, PermissionIsPermissionGrantedInvalid, TestSize.Level0) 138 { 139 MockAccesstokenKit::MockSetTokenTypeFlag(ATokenTypeEnum::TOKEN_INVALID); 140 EXPECT_FALSE(Permission::IsPermissionGranted("REBOOT")); 141 MockAccesstokenKit::MockSetTokenTypeFlag(ATokenTypeEnum::TOKEN_TYPE_BUTT); 142 EXPECT_FALSE(Permission::IsPermissionGranted("REBOOT")); 143 } 144 145 /** 146 * @tc.name: SettingObserverTest001 147 * @tc.desc: test SetKey in proxy 148 * @tc.type: FUNC 149 */ 150 HWTEST_F (PowerMgrUtilTest, SettingObserver001, TestSize.Level0) 151 { 152 POWER_HILOGD(LABEL_TEST, "SettingObserver001::fun is start!"); 153 std::shared_ptr<SettingObserver> settingObserver = std::make_shared<SettingObserver>(); 154 settingObserver->OnChange(); __anon9b8764400202(const std::string&) 155 SettingObserver::UpdateFunc updateFunc = [&](const std::string&) {}; 156 settingObserver->SetUpdateFunc(updateFunc); 157 settingObserver->SetKey("settings.power.wakeup_sources"); 158 std::string key = settingObserver->GetKey(); 159 EXPECT_EQ(key, "settings.power.wakeup_sources"); 160 POWER_HILOGD(LABEL_TEST, "SettingObserver001::fun is end!"); 161 } 162 163 /** 164 * @tc.name: SettingProviderTest001 165 * @tc.desc: test CreateObserver in proxy 166 * @tc.type: FUNC 167 */ 168 HWTEST_F (PowerMgrUtilTest, SettingProvider001, TestSize.Level0) 169 { 170 POWER_HILOGD(LABEL_TEST, "SettingProvider001::fun is start!"); 171 auto& settingProvider = SettingProvider::GetInstance(OHOS::POWER_MANAGER_SERVICE_ID); 172 std::string valueStr; 173 settingProvider.GetStringValue("settings.power.wakeup_sources", valueStr); 174 bool valueBool = false; 175 settingProvider.PutBoolValue("settings.power.suspend_sources", valueBool); 176 settingProvider.GetBoolValue("settings.power.suspend_sources", valueBool); __anon9b8764400302(const std::string&) 177 SettingObserver::UpdateFunc updateFunc = [&](const std::string&) {}; 178 auto observer = settingProvider.CreateObserver("settings.power.suspend_sources", updateFunc); 179 EXPECT_TRUE(observer != nullptr); 180 POWER_HILOGD(LABEL_TEST, "SettingProvider001::fun is end!"); 181 } 182 183 /** 184 * @tc.name: SettingProviderTest002 185 * @tc.desc: test RegisterObserver in proxy 186 * @tc.type: FUNC 187 */ 188 HWTEST_F (PowerMgrUtilTest, SettingProvider002, TestSize.Level0) 189 { 190 POWER_HILOGD(LABEL_TEST, "SettingProvider002::fun is start!"); 191 auto& settingProvider = SettingProvider::GetInstance(OHOS::POWER_MANAGER_SERVICE_ID); 192 int32_t putValue = 10; 193 int32_t getValue; 194 settingProvider.PutIntValue("settings.power.suspend_sources", putValue); 195 settingProvider.GetIntValue("settings.power.suspend_sources", getValue); __anon9b8764400402(const std::string&) 196 SettingObserver::UpdateFunc updateFunc = [&](const std::string&) {}; 197 auto observer = settingProvider.CreateObserver("settings.power.suspend_sources", updateFunc); 198 EXPECT_EQ(OHOS::ERR_OK, settingProvider.RegisterObserver(observer)); 199 POWER_HILOGD(LABEL_TEST, "SettingProvider002::fun is end!"); 200 } 201 202 /** 203 * @tc.name: SettingProviderTest003 204 * @tc.desc: test UnregisterObserver in proxy 205 * @tc.type: FUNC 206 */ 207 HWTEST_F (PowerMgrUtilTest, SettingProvider003, TestSize.Level0) 208 { 209 POWER_HILOGD(LABEL_TEST, "SettingProvider003::fun is start!"); 210 auto& settingProvider = SettingProvider::GetInstance(OHOS::POWER_MANAGER_SERVICE_ID); 211 int64_t value; 212 settingProvider.GetLongValue("settings.display.screen_off_timeout", value); 213 settingProvider.IsValidKey("settings.power.suspend_sources"); __anon9b8764400502(const std::string&) 214 SettingObserver::UpdateFunc updateFunc = [&](const std::string&) {}; 215 auto observer = settingProvider.CreateObserver("settings.power.suspend_sources", updateFunc); 216 OHOS::ErrCode ret = settingProvider.RegisterObserver(observer); 217 ret = settingProvider.UnregisterObserver(observer); 218 EXPECT_EQ(OHOS::ERR_OK, ret); 219 POWER_HILOGD(LABEL_TEST, "SettingProvider003::fun is end!"); 220 } 221 222 /** 223 * @tc.name: SettingProviderTest004 224 * @tc.desc: test PutLongValue func 225 * @tc.type: FUNC 226 */ 227 HWTEST_F(PowerMgrUtilTest, SettingProvider004, TestSize.Level0) 228 { 229 POWER_HILOGD(LABEL_TEST, "SettingProvider004::fun is start!"); 230 static constexpr const char* SETTING_DISPLAY_OFF_TIME_KEY {"settings.display.screen_off_timeout"}; 231 auto& settingProvider = SettingProvider::GetInstance(OHOS::POWER_MANAGER_SERVICE_ID); 232 int64_t value = 0; 233 OHOS::ErrCode ret = settingProvider.PutLongValue(SETTING_DISPLAY_OFF_TIME_KEY, value); 234 EXPECT_EQ(OHOS::ERR_OK, ret); 235 POWER_HILOGD(LABEL_TEST, "SettingProvider004::fun is end!"); 236 } 237 238 /** 239 * @tc.name: SysparamTest001 240 * @tc.desc: test GetIntValue in proxy 241 * @tc.type: FUNC 242 */ 243 HWTEST_F (PowerMgrUtilTest, Sysparam001, TestSize.Level0) 244 { 245 POWER_HILOGD(LABEL_TEST, "Sysparam001::fun is start!"); 246 std::shared_ptr<SysParam> sysParam = std::make_shared<SysParam>(); 247 int32_t def = 0; 248 EXPECT_EQ(OHOS::ERR_OK, sysParam->GetIntValue("settings.power.suspend_sources", def)); 249 POWER_HILOGD(LABEL_TEST, "Sysparam001::fun is end!"); 250 } 251 252 /** 253 * @tc.name: PowerVibratorTest001 254 * @tc.desc: test power vibrator 255 * @tc.type: FUNC 256 */ 257 HWTEST_F (PowerMgrUtilTest, PowerVibratorTest001, TestSize.Level0) 258 { 259 POWER_HILOGI(LABEL_TEST, "PowerVibratorTest001 is start!"); 260 std::shared_ptr<PowerVibrator> vibrator = PowerVibrator::GetInstance(); 261 EXPECT_TRUE(vibrator != nullptr); 262 vibrator->LoadConfig(POWER_VIBRATOR_CONFIG_FILE, 263 VENDOR_POWER_VIBRATOR_CONFIG_FILE, SYSTEM_POWER_VIBRATOR_CONFIG_FILE); 264 vibrator->StartVibrator(SHUTDOWN_DIAG); 265 } 266 267 /** 268 * @tc.name: PowerVibratorTest002 269 * @tc.desc: test power vibrator coverage 270 * @tc.type: FUNC 271 */ 272 HWTEST_F (PowerMgrUtilTest, PowerVibratorTest002, TestSize.Level0) 273 { 274 POWER_HILOGI(LABEL_TEST, "PowerVibratorTest002 is start!"); 275 std::shared_ptr<PowerVibrator> vibrator = PowerVibrator::GetInstance(); 276 EXPECT_TRUE(vibrator != nullptr); 277 std::string key = "shutdown_diag"; 278 bool enable = true; 279 std::string type = "wave_form"; 280 VibratorSource vibratorSource = VibratorSource(key, enable, type); 281 vibrator->sourceList_.emplace_back(vibratorSource); 282 vibrator->StartVibrator(SHUTDOWN_DIAG); 283 } 284 } // namespace 285