1 /* 2 * Copyright (c) 2022-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 <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 #include "setting_provider.h" 30 #undef private 31 #undef protected 32 33 #include "setting_observer.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 constexpr int32_t INVALID_CODE = -1; 54 55 /** 56 * @tc.name: PermissionIsSystemNative 57 * @tc.desc: The IsSystem and IsPermissionGranted functions are granted by default as TOKEN_NATIVE or TOKEN_SHELL types 58 * @tc.type: FUNC 59 */ 60 HWTEST_F(PowerMgrUtilTest, PermissionIsSystemNative, TestSize.Level0) 61 { 62 POWER_HILOGI(LABEL_TEST, "PermissionIsSystemNative start"); 63 MockAccesstokenKit::MockSetTokenTypeFlag(ATokenTypeEnum::TOKEN_NATIVE); 64 EXPECT_TRUE(Permission::IsSystem()); 65 EXPECT_TRUE(Permission::IsPermissionGranted("REBOOT")); 66 67 MockAccesstokenKit::MockSetTokenTypeFlag(ATokenTypeEnum::TOKEN_SHELL); 68 EXPECT_TRUE(Permission::IsSystem()); 69 EXPECT_TRUE(Permission::IsPermissionGranted("REBOOT")); 70 POWER_HILOGI(LABEL_TEST, "PermissionIsSystemNative end"); 71 } 72 73 /** 74 * @tc.name: PermissionIsSystemHap 75 * @tc.desc: The function IsSystem and IsPermissionGranted in the test TOKEN_HAP 76 * @tc.type: FUNC 77 */ 78 HWTEST_F(PowerMgrUtilTest, PermissionIsSystemHap, TestSize.Level0) 79 { 80 POWER_HILOGI(LABEL_TEST, "PermissionIsSystemHap start"); 81 MockAccesstokenKit::MockSetTokenTypeFlag(ATokenTypeEnum::TOKEN_HAP); 82 MockAccesstokenKit::MockSetSystemApp(false); 83 EXPECT_FALSE(Permission::IsSystem()); 84 85 MockAccesstokenKit::MockSetSystemApp(true); 86 EXPECT_TRUE(Permission::IsSystem()); 87 MockAccesstokenKit::MockSetPermissionState(PermissionState::PERMISSION_GRANTED); 88 EXPECT_TRUE(Permission::IsPermissionGranted("REBOOT")); 89 POWER_HILOGI(LABEL_TEST, "PermissionIsSystemHap end"); 90 } 91 92 /** 93 * @tc.name: PermissionIsSystemInvalid 94 * @tc.desc: The IsSystem and IsPermissionGranted do not have permissions on TOKEN_INVALID or TOKEN_TYPE_BUTT types 95 * @tc.type: FUNC 96 */ 97 HWTEST_F(PowerMgrUtilTest, PermissionIsSystemInvalid, TestSize.Level0) 98 { 99 POWER_HILOGI(LABEL_TEST, "PermissionIsSystemInvalid start"); 100 MockAccesstokenKit::MockSetTokenTypeFlag(ATokenTypeEnum::TOKEN_INVALID); 101 EXPECT_FALSE(Permission::IsSystem()); 102 EXPECT_FALSE(Permission::IsPermissionGranted("REBOOT")); 103 104 MockAccesstokenKit::MockSetTokenTypeFlag(ATokenTypeEnum::TOKEN_TYPE_BUTT); 105 EXPECT_FALSE(Permission::IsSystem()); 106 EXPECT_FALSE(Permission::IsPermissionGranted("REBOOT")); 107 POWER_HILOGI(LABEL_TEST, "PermissionIsSystemInvalid end"); 108 } 109 110 /** 111 * @tc.name: PermissionIsPermissionGrantedHap 112 * @tc.desc: Test Permission function IsPermissionGranted is TOKEN_HAP 113 * @tc.type: FUNC 114 */ 115 HWTEST_F(PowerMgrUtilTest, PermissionIsPermissionGrantedHap, TestSize.Level0) 116 { 117 POWER_HILOGI(LABEL_TEST, "PermissionIsPermissionGrantedHap start"); 118 MockAccesstokenKit::MockSetTokenTypeFlag(ATokenTypeEnum::TOKEN_HAP); 119 MockAccesstokenKit::MockSetPermissionState(PermissionState::PERMISSION_DENIED); 120 EXPECT_FALSE(Permission::IsPermissionGranted("REBOOT")); 121 122 MockAccesstokenKit::MockSetPermissionState(PermissionState::PERMISSION_GRANTED); 123 EXPECT_TRUE(Permission::IsPermissionGranted("REBOOT")); 124 POWER_HILOGI(LABEL_TEST, "PermissionIsPermissionGrantedHap end"); 125 } 126 127 /** 128 * @tc.name: PermissionIsPermissionGrantedNative 129 * @tc.desc: Test function IsPermissionGranted is TOKEN_NATIVE or TOKEN_SHELL with permissions by default 130 * @tc.type: FUNC 131 */ 132 HWTEST_F(PowerMgrUtilTest, PermissionIsPermissionGrantedNative, TestSize.Level0) 133 { 134 POWER_HILOGI(LABEL_TEST, "PermissionIsPermissionGrantedNative start"); 135 MockAccesstokenKit::MockSetTokenTypeFlag(ATokenTypeEnum::TOKEN_NATIVE); 136 EXPECT_TRUE(Permission::IsPermissionGranted("REBOOT")); 137 138 MockAccesstokenKit::MockSetTokenTypeFlag(ATokenTypeEnum::TOKEN_SHELL); 139 EXPECT_TRUE(Permission::IsPermissionGranted("REBOOT")); 140 POWER_HILOGI(LABEL_TEST, "PermissionIsPermissionGrantedNative end"); 141 } 142 143 /** 144 * @tc.name: PermissionIsPermissionGrantedInvalid 145 * @tc.desc: Test Permission function IsSystem is TOKEN_INVALID or TOKEN_TYPE_BUTT without permission 146 * @tc.type: FUNC 147 */ 148 HWTEST_F(PowerMgrUtilTest, PermissionIsPermissionGrantedInvalid, TestSize.Level0) 149 { 150 POWER_HILOGI(LABEL_TEST, "PermissionIsPermissionGrantedInvalid start"); 151 MockAccesstokenKit::MockSetTokenTypeFlag(ATokenTypeEnum::TOKEN_INVALID); 152 EXPECT_FALSE(Permission::IsPermissionGranted("REBOOT")); 153 MockAccesstokenKit::MockSetTokenTypeFlag(ATokenTypeEnum::TOKEN_TYPE_BUTT); 154 EXPECT_FALSE(Permission::IsPermissionGranted("REBOOT")); 155 POWER_HILOGI(LABEL_TEST, "PermissionIsPermissionGrantedInvalid end"); 156 } 157 158 /** 159 * @tc.name: IsNativePermissionGrantedHap 160 * @tc.desc: The function IsSystem and IsNativePermissionGranted in the test TOKEN_HAP 161 * @tc.type: FUNC 162 */ 163 HWTEST_F(PowerMgrUtilTest, IsNativePermissionGrantedHap, TestSize.Level0) 164 { 165 POWER_HILOGI(LABEL_TEST, "IsNativePermissionGrantedHap start"); 166 MockAccesstokenKit::MockSetTokenTypeFlag(ATokenTypeEnum::TOKEN_HAP); 167 MockAccesstokenKit::MockSetSystemApp(false); 168 EXPECT_FALSE(Permission::IsSystem()); 169 170 MockAccesstokenKit::MockSetSystemApp(true); 171 EXPECT_TRUE(Permission::IsSystem()); 172 MockAccesstokenKit::MockSetPermissionState(PermissionState::PERMISSION_DENIED); 173 EXPECT_TRUE(Permission::IsNativePermissionGranted("POWER_OPTIMIZATION")); 174 MockAccesstokenKit::MockSetPermissionState(PermissionState::PERMISSION_GRANTED); 175 EXPECT_TRUE(Permission::IsNativePermissionGranted("POWER_OPTIMIZATION")); 176 POWER_HILOGI(LABEL_TEST, "IsNativePermissionGrantedHap end"); 177 } 178 179 /** 180 * @tc.name: IsNativePermissionGrantedNative 181 * @tc.desc: The function IsNativePermissionGranted in the test TOKEN_NATIVE or TOKEN_SHELL 182 * @tc.type: FUNC 183 */ 184 HWTEST_F(PowerMgrUtilTest, IsNativePermissionGrantedNative, TestSize.Level0) 185 { 186 POWER_HILOGI(LABEL_TEST, "IsNativePermissionGrantedNative start"); 187 MockAccesstokenKit::MockSetTokenTypeFlag(ATokenTypeEnum::TOKEN_NATIVE); 188 MockAccesstokenKit::MockSetPermissionState(PermissionState::PERMISSION_DENIED); 189 EXPECT_FALSE(Permission::IsNativePermissionGranted("POWER_OPTIMIZATION")); 190 MockAccesstokenKit::MockSetPermissionState(PermissionState::PERMISSION_GRANTED); 191 EXPECT_TRUE(Permission::IsNativePermissionGranted("POWER_OPTIMIZATION")); 192 193 MockAccesstokenKit::MockSetTokenTypeFlag(ATokenTypeEnum::TOKEN_SHELL); 194 MockAccesstokenKit::MockSetPermissionState(PermissionState::PERMISSION_DENIED); 195 EXPECT_FALSE(Permission::IsNativePermissionGranted("POWER_OPTIMIZATION")); 196 MockAccesstokenKit::MockSetPermissionState(PermissionState::PERMISSION_GRANTED); 197 EXPECT_TRUE(Permission::IsNativePermissionGranted("POWER_OPTIMIZATION")); 198 POWER_HILOGI(LABEL_TEST, "IsNativePermissionGrantedNative end"); 199 } 200 201 /** 202 * @tc.name: IsNativePermissionGrantedInvalid 203 * @tc.desc: The function IsNativePermissionGranted in the test TOKEN_INVALID or TOKEN_TYPE_BUTT 204 * @tc.type: FUNC 205 */ 206 HWTEST_F(PowerMgrUtilTest, IsNativePermissionGrantedInvalid, TestSize.Level0) 207 { 208 POWER_HILOGI(LABEL_TEST, "IsNativePermissionGrantedInvalid start"); 209 MockAccesstokenKit::MockSetTokenTypeFlag(ATokenTypeEnum::TOKEN_INVALID); 210 MockAccesstokenKit::MockSetPermissionState(PermissionState::PERMISSION_DENIED); 211 EXPECT_FALSE(Permission::IsNativePermissionGranted("POWER_OPTIMIZATION")); 212 MockAccesstokenKit::MockSetPermissionState(PermissionState::PERMISSION_GRANTED); 213 EXPECT_FALSE(Permission::IsNativePermissionGranted("POWER_OPTIMIZATION")); 214 215 MockAccesstokenKit::MockSetTokenTypeFlag(ATokenTypeEnum::TOKEN_TYPE_BUTT); 216 MockAccesstokenKit::MockSetPermissionState(PermissionState::PERMISSION_DENIED); 217 EXPECT_FALSE(Permission::IsNativePermissionGranted("POWER_OPTIMIZATION")); 218 MockAccesstokenKit::MockSetPermissionState(PermissionState::PERMISSION_GRANTED); 219 EXPECT_FALSE(Permission::IsNativePermissionGranted("POWER_OPTIMIZATION")); 220 POWER_HILOGI(LABEL_TEST, "IsNativePermissionGrantedInvalid end"); 221 } 222 223 /** 224 * @tc.name: SettingObserver001 225 * @tc.desc: test SetKey in proxy 226 * @tc.type: FUNC 227 */ 228 HWTEST_F (PowerMgrUtilTest, SettingObserver001, TestSize.Level0) 229 { 230 POWER_HILOGI(LABEL_TEST, "SettingObserver001::fun is start!"); 231 std::shared_ptr<SettingObserver> settingObserver = std::make_shared<SettingObserver>(); 232 settingObserver->OnChange(); __anonc1a52dfe0202(const std::string&) 233 SettingObserver::UpdateFunc updateFunc = [&](const std::string&) {}; 234 settingObserver->SetUpdateFunc(updateFunc); 235 settingObserver->SetKey("settings.power.wakeup_sources"); 236 std::string key = settingObserver->GetKey(); 237 EXPECT_EQ(key, "settings.power.wakeup_sources"); 238 POWER_HILOGI(LABEL_TEST, "SettingObserver001::fun is end!"); 239 } 240 241 /** 242 * @tc.name: SettingProvider001 243 * @tc.desc: test CreateObserver in proxy 244 * @tc.type: FUNC 245 */ 246 HWTEST_F (PowerMgrUtilTest, SettingProvider001, TestSize.Level0) 247 { 248 POWER_HILOGI(LABEL_TEST, "SettingProvider001::fun is start!"); 249 auto& settingProvider = SettingProvider::GetInstance(OHOS::POWER_MANAGER_SERVICE_ID); 250 std::string valueStr; 251 settingProvider.GetStringValue("settings.power.wakeup_sources", valueStr); 252 bool valueBool = false; 253 settingProvider.PutBoolValue("settings.power.suspend_sources", valueBool); 254 settingProvider.GetBoolValue("settings.power.suspend_sources", valueBool); __anonc1a52dfe0302(const std::string&) 255 SettingObserver::UpdateFunc updateFunc = [&](const std::string&) {}; 256 auto observer = settingProvider.CreateObserver("settings.power.suspend_sources", updateFunc); 257 EXPECT_TRUE(observer != nullptr); 258 POWER_HILOGI(LABEL_TEST, "SettingProvider001::fun is end!"); 259 } 260 261 /** 262 * @tc.name: SettingProvider002 263 * @tc.desc: test RegisterObserver in proxy 264 * @tc.type: FUNC 265 */ 266 HWTEST_F (PowerMgrUtilTest, SettingProvider002, TestSize.Level0) 267 { 268 POWER_HILOGI(LABEL_TEST, "SettingProvider002::fun is start!"); 269 auto& settingProvider = SettingProvider::GetInstance(OHOS::POWER_MANAGER_SERVICE_ID); 270 int32_t putValue = 10; 271 int32_t getValue; 272 settingProvider.PutIntValue("settings.power.suspend_sources", putValue); 273 settingProvider.GetIntValue("settings.power.suspend_sources", getValue); __anonc1a52dfe0402(const std::string&) 274 SettingObserver::UpdateFunc updateFunc = [&](const std::string&) {}; 275 auto observer = settingProvider.CreateObserver("settings.power.suspend_sources", updateFunc); 276 EXPECT_EQ(OHOS::ERR_OK, settingProvider.RegisterObserver(observer)); 277 POWER_HILOGI(LABEL_TEST, "SettingProvider002::fun is end!"); 278 } 279 280 /** 281 * @tc.name: SettingProvider003 282 * @tc.desc: test UnregisterObserver in proxy 283 * @tc.type: FUNC 284 */ 285 HWTEST_F (PowerMgrUtilTest, SettingProvider003, TestSize.Level0) 286 { 287 POWER_HILOGI(LABEL_TEST, "SettingProvider003::fun is start!"); 288 auto& settingProvider = SettingProvider::GetInstance(OHOS::POWER_MANAGER_SERVICE_ID); 289 int64_t value; 290 settingProvider.GetLongValue("settings.display.screen_off_timeout", value); 291 settingProvider.IsValidKey("settings.power.suspend_sources"); __anonc1a52dfe0502(const std::string&) 292 SettingObserver::UpdateFunc updateFunc = [&](const std::string&) {}; 293 auto observer = settingProvider.CreateObserver("settings.power.suspend_sources", updateFunc); 294 OHOS::ErrCode ret = settingProvider.RegisterObserver(observer); 295 ret = settingProvider.UnregisterObserver(observer); 296 EXPECT_EQ(OHOS::ERR_OK, ret); 297 POWER_HILOGI(LABEL_TEST, "SettingProvider003::fun is end!"); 298 } 299 300 /** 301 * @tc.name: SettingProvider004 302 * @tc.desc: test PutLongValue func 303 * @tc.type: FUNC 304 */ 305 HWTEST_F(PowerMgrUtilTest, SettingProvider004, TestSize.Level0) 306 { 307 POWER_HILOGI(LABEL_TEST, "SettingProvider004::fun is start!"); 308 static constexpr const char* SETTING_DISPLAY_OFF_TIME_KEY {"settings.display.screen_off_timeout"}; 309 auto& settingProvider = SettingProvider::GetInstance(OHOS::POWER_MANAGER_SERVICE_ID); 310 int64_t value = 0; 311 OHOS::ErrCode ret = settingProvider.PutLongValue(SETTING_DISPLAY_OFF_TIME_KEY, value); 312 EXPECT_EQ(OHOS::ERR_OK, ret); 313 POWER_HILOGI(LABEL_TEST, "SettingProvider004::fun is end!"); 314 } 315 316 /** 317 * @tc.name: SettingProvider005 318 * @tc.desc: test UpdateCurrentUserId func 319 * @tc.type: FUNC 320 */ 321 HWTEST_F(PowerMgrUtilTest, SettingProvider005, TestSize.Level0) 322 { 323 POWER_HILOGI(LABEL_TEST, "SettingProvider005::fun is start!"); 324 auto& settingProvider = SettingProvider::GetInstance(OHOS::POWER_MANAGER_SERVICE_ID); 325 settingProvider.UpdateCurrentUserId(); 326 EXPECT_NE(settingProvider.currentUserId_, INVALID_CODE); 327 POWER_HILOGI(LABEL_TEST, "SettingProvider005::fun is end!"); 328 } 329 330 /** 331 * @tc.name: SettingProvider006 332 * @tc.desc: test CopyDataForUpdateScene func 333 * @tc.type: FUNC 334 */ 335 HWTEST_F(PowerMgrUtilTest, SettingProvider006, TestSize.Level0) 336 { 337 POWER_HILOGI(LABEL_TEST, "SettingProvider006::fun is start!"); 338 auto& settingProvider = SettingProvider::GetInstance(OHOS::POWER_MANAGER_SERVICE_ID); 339 settingProvider.CopyDataForUpdateScene(); 340 static constexpr const char* SETTING_POWER_WAKEUP_PICKUP_KEY {"settings.power.wakeup_pick_up"}; 341 bool isValidKeyGlobal = settingProvider.IsValidKeyGlobal(SETTING_POWER_WAKEUP_PICKUP_KEY); 342 bool isValidKeyUser = settingProvider.IsValidKey(SETTING_POWER_WAKEUP_PICKUP_KEY); 343 EXPECT_FALSE(isValidKeyGlobal && !isValidKeyUser); 344 POWER_HILOGI(LABEL_TEST, "SettingProvider006::fun is end!"); 345 } 346 347 /** 348 * @tc.name: Sysparam001 349 * @tc.desc: test GetIntValue in proxy 350 * @tc.type: FUNC 351 */ 352 HWTEST_F (PowerMgrUtilTest, Sysparam001, TestSize.Level0) 353 { 354 POWER_HILOGI(LABEL_TEST, "Sysparam001::fun is start!"); 355 std::shared_ptr<SysParam> sysParam = std::make_shared<SysParam>(); 356 int32_t def = 0; 357 EXPECT_EQ(OHOS::ERR_OK, sysParam->GetIntValue("settings.power.suspend_sources", def)); 358 POWER_HILOGI(LABEL_TEST, "Sysparam001::fun is end!"); 359 } 360 361 /** 362 * @tc.name: PowerVibratorTest001 363 * @tc.desc: test power vibrator 364 * @tc.type: FUNC 365 */ 366 HWTEST_F (PowerMgrUtilTest, PowerVibratorTest001, TestSize.Level0) 367 { 368 POWER_HILOGI(LABEL_TEST, "PowerVibratorTest001 is start!"); 369 std::shared_ptr<PowerVibrator> vibrator = PowerVibrator::GetInstance(); 370 EXPECT_TRUE(vibrator != nullptr); 371 vibrator->LoadConfig(POWER_VIBRATOR_CONFIG_FILE, 372 VENDOR_POWER_VIBRATOR_CONFIG_FILE, SYSTEM_POWER_VIBRATOR_CONFIG_FILE); 373 vibrator->StartVibrator(SHUTDOWN_DIAG); 374 POWER_HILOGI(LABEL_TEST, "PowerVibratorTest001 is end!"); 375 } 376 377 /** 378 * @tc.name: PowerVibratorTest002 379 * @tc.desc: test power vibrator coverage 380 * @tc.type: FUNC 381 */ 382 HWTEST_F (PowerMgrUtilTest, PowerVibratorTest002, TestSize.Level0) 383 { 384 POWER_HILOGI(LABEL_TEST, "PowerVibratorTest002 is start!"); 385 std::shared_ptr<PowerVibrator> vibrator = PowerVibrator::GetInstance(); 386 EXPECT_TRUE(vibrator != nullptr); 387 std::string key = "shutdown_diag"; 388 bool enable = true; 389 std::string type = "wave_form"; 390 VibratorSource vibratorSource = VibratorSource(key, enable, type); 391 vibrator->sourceList_.emplace_back(vibratorSource); 392 vibrator->StartVibrator(SHUTDOWN_DIAG); 393 POWER_HILOGI(LABEL_TEST, "PowerVibratorTest002 is end!"); 394 } 395 } // namespace 396