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 function 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 function 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 function 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 function 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 function 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 function 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 function 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 function 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 function 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 function 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 function 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 function 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 function 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 function 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 function 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 function 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 function 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 function 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 function start!"); 231 std::shared_ptr<SettingObserver> settingObserver = std::make_shared<SettingObserver>(); 232 settingObserver->OnChange(); __anona24343e00202(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 function 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 function 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); __anona24343e00302(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 function 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 function 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); __anona24343e00402(const std::string&) 274 SettingObserver::UpdateFunc updateFunc = [&](const std::string&) {}; 275 auto observer = settingProvider.CreateObserver("settings.power.suspend_sources", updateFunc); 276 OHOS::ErrCode ret = settingProvider.RegisterObserver(observer); 277 EXPECT_EQ(OHOS::ERR_OK, ret); 278 ret = settingProvider.RegisterObserver(nullptr); 279 EXPECT_EQ(OHOS::ERR_INVALID_VALUE, ret); 280 POWER_HILOGI(LABEL_TEST, "SettingProvider002 function end!"); 281 } 282 283 /** 284 * @tc.name: SettingProvider003 285 * @tc.desc: test UnregisterObserver in proxy 286 * @tc.type: FUNC 287 */ 288 HWTEST_F (PowerMgrUtilTest, SettingProvider003, TestSize.Level0) 289 { 290 POWER_HILOGI(LABEL_TEST, "SettingProvider003 function start!"); 291 auto& settingProvider = SettingProvider::GetInstance(OHOS::POWER_MANAGER_SERVICE_ID); 292 int64_t value; 293 settingProvider.GetLongValue("settings.display.screen_off_timeout", value); 294 settingProvider.IsValidKey("settings.power.suspend_sources"); __anona24343e00502(const std::string&) 295 SettingObserver::UpdateFunc updateFunc = [&](const std::string&) {}; 296 auto observer = settingProvider.CreateObserver("settings.power.suspend_sources", updateFunc); 297 OHOS::ErrCode ret = settingProvider.RegisterObserver(observer); 298 ret = settingProvider.UnregisterObserver(observer); 299 EXPECT_EQ(OHOS::ERR_OK, ret); 300 ret = settingProvider.UnregisterObserver(nullptr); 301 EXPECT_EQ(OHOS::ERR_INVALID_VALUE, ret); 302 POWER_HILOGI(LABEL_TEST, "SettingProvider003 function end!"); 303 } 304 305 /** 306 * @tc.name: SettingProvider004 307 * @tc.desc: test PutLongValue func 308 * @tc.type: FUNC 309 */ 310 HWTEST_F(PowerMgrUtilTest, SettingProvider004, TestSize.Level0) 311 { 312 POWER_HILOGI(LABEL_TEST, "SettingProvider004 function start!"); 313 static constexpr const char* SETTING_DISPLAY_OFF_TIME_KEY {"settings.display.screen_off_timeout"}; 314 auto& settingProvider = SettingProvider::GetInstance(OHOS::POWER_MANAGER_SERVICE_ID); 315 int64_t value = 0; 316 OHOS::ErrCode ret = settingProvider.PutLongValue(SETTING_DISPLAY_OFF_TIME_KEY, value); 317 EXPECT_EQ(OHOS::ERR_OK, ret); 318 POWER_HILOGI(LABEL_TEST, "SettingProvider004 function end!"); 319 } 320 321 /** 322 * @tc.name: SettingProvider005 323 * @tc.desc: test UpdateCurrentUserId func 324 * @tc.type: FUNC 325 */ 326 HWTEST_F(PowerMgrUtilTest, SettingProvider005, TestSize.Level0) 327 { 328 POWER_HILOGI(LABEL_TEST, "SettingProvider005 function start!"); 329 auto& settingProvider = SettingProvider::GetInstance(OHOS::POWER_MANAGER_SERVICE_ID); 330 settingProvider.UpdateCurrentUserId(); 331 EXPECT_NE(settingProvider.currentUserId_, INVALID_CODE); 332 POWER_HILOGI(LABEL_TEST, "SettingProvider005 function end!"); 333 } 334 335 /** 336 * @tc.name: SettingProvider006 337 * @tc.desc: test CopyDataForUpdateScene func 338 * @tc.type: FUNC 339 */ 340 HWTEST_F(PowerMgrUtilTest, SettingProvider006, TestSize.Level0) 341 { 342 POWER_HILOGI(LABEL_TEST, "SettingProvider006 function start!"); 343 auto& settingProvider = SettingProvider::GetInstance(OHOS::POWER_MANAGER_SERVICE_ID); 344 settingProvider.CopyDataForUpdateScene(); 345 static constexpr const char* SETTING_POWER_WAKEUP_PICKUP_KEY {"settings.power.wakeup_pick_up"}; 346 bool isValidKeyGlobal = settingProvider.IsValidKeyGlobal(SETTING_POWER_WAKEUP_PICKUP_KEY); 347 bool isValidKeyUser = settingProvider.IsValidKey(SETTING_POWER_WAKEUP_PICKUP_KEY); 348 EXPECT_FALSE(isValidKeyGlobal && !isValidKeyUser); 349 POWER_HILOGI(LABEL_TEST, "SettingProvider006 function end!"); 350 } 351 352 /** 353 * @tc.name: Sysparam001 354 * @tc.desc: test GetIntValue in proxy 355 * @tc.type: FUNC 356 */ 357 HWTEST_F (PowerMgrUtilTest, Sysparam001, TestSize.Level0) 358 { 359 POWER_HILOGI(LABEL_TEST, "Sysparam001 function start!"); 360 std::shared_ptr<SysParam> sysParam = std::make_shared<SysParam>(); 361 int32_t def = 0; 362 EXPECT_EQ(OHOS::ERR_OK, sysParam->GetIntValue("settings.power.suspend_sources", def)); 363 POWER_HILOGI(LABEL_TEST, "Sysparam001 function end!"); 364 } 365 366 /** 367 * @tc.name: PowerVibratorTest001 368 * @tc.desc: test power vibrator 369 * @tc.type: FUNC 370 */ 371 HWTEST_F (PowerMgrUtilTest, PowerVibratorTest001, TestSize.Level0) 372 { 373 POWER_HILOGI(LABEL_TEST, "PowerVibratorTest001 function start!"); 374 std::shared_ptr<PowerVibrator> vibrator = PowerVibrator::GetInstance(); 375 EXPECT_TRUE(vibrator != nullptr); 376 vibrator->LoadConfig(POWER_VIBRATOR_CONFIG_FILE, 377 VENDOR_POWER_VIBRATOR_CONFIG_FILE, SYSTEM_POWER_VIBRATOR_CONFIG_FILE); 378 vibrator->StartVibrator(SHUTDOWN_DIAG); 379 POWER_HILOGI(LABEL_TEST, "PowerVibratorTest001 function end!"); 380 } 381 382 /** 383 * @tc.name: PowerVibratorTest002 384 * @tc.desc: test power vibrator coverage 385 * @tc.type: FUNC 386 */ 387 HWTEST_F (PowerMgrUtilTest, PowerVibratorTest002, TestSize.Level0) 388 { 389 POWER_HILOGI(LABEL_TEST, "PowerVibratorTest002 function start!"); 390 std::shared_ptr<PowerVibrator> vibrator = PowerVibrator::GetInstance(); 391 EXPECT_TRUE(vibrator != nullptr); 392 std::string key = "shutdown_diag"; 393 bool enable = true; 394 std::string type = "wave_form"; 395 VibratorSource vibratorSource = VibratorSource(key, enable, type); 396 vibrator->sourceList_.emplace_back(vibratorSource); 397 vibrator->StartVibrator(SHUTDOWN_DIAG); 398 POWER_HILOGI(LABEL_TEST, "PowerVibratorTest002 function end!"); 399 } 400 } // namespace 401