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