1 /*
2 * Copyright (c) 2022 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 <string>
17
18 #include <gtest/gtest.h>
19 #include "system_ability_definition.h"
20
21 #include "bundle_active_power_state_callback_service.h"
22 #include "bundle_active_service_stub.h"
23 #include "bundle_active_core.h"
24
25 #include "bundle_active_continuous_task_observer.h"
26 #include "bundle_active_bundle_mgr_helper.h"
27 #include "bundle_active_app_state_observer.h"
28 #include "bundle_active_usage_database.h"
29 #include "bundle_active_account_helper.h"
30 #include "bundle_active_power_state_callback_service.h"
31 #include "bundle_active_open_callback.h"
32 #include "bundle_active_shutdown_callback_service.h"
33 #include "bundle_active_binary_search.h"
34 #include "bundle_active_debug_mode.h"
35
36 using namespace testing::ext;
37
38 namespace OHOS {
39 namespace DeviceUsageStats {
40
41 class BundleActiveTotalTest : public testing::Test {
42 public:
43 static void SetUpTestCase(void);
44 static void TearDownTestCase(void);
45 void SetUp();
46 void TearDown();
47 };
48
SetUpTestCase(void)49 void BundleActiveTotalTest::SetUpTestCase(void)
50 {
51 }
52
TearDownTestCase(void)53 void BundleActiveTotalTest::TearDownTestCase(void)
54 {
55 }
56
SetUp(void)57 void BundleActiveTotalTest::SetUp(void)
58 {
59 }
60
TearDown(void)61 void BundleActiveTotalTest::TearDown(void)
62 {
63 }
64
65 /*
66 * @tc.name: BundleActiveAccountHelperTest_001
67 * @tc.desc: test the interface of bundle_active_account_helper
68 * @tc.type: FUNC
69 * @tc.require: DTS2023121404861
70 */
71 HWTEST_F(BundleActiveTotalTest, BundleActiveAccountHelperTest_001, Function | MediumTest | Level0)
72 {
73 std::vector<int32_t> activatedOsAccountIds;
74
75 BundleActiveAccountHelper::GetActiveUserId(activatedOsAccountIds);
76
77 EXPECT_NE(activatedOsAccountIds.size(), 0);
78 }
79
80 /*
81 * @tc.name: BundleActiveContinuousTaskObserverTest_001
82 * @tc.desc: test the interface of bundle_active_continuous_task_observer
83 * @tc.type: FUNC
84 * @tc.require: DTS2023121404861
85 */
86 HWTEST_F(BundleActiveTotalTest, BundleActiveContinuousTaskObserverTest_001, Function | MediumTest | Level0)
87 {
88 #ifdef BGTASKMGR_ENABLE
89 #ifdef OS_ACCOUNT_PART_ENABLED
90 std::shared_ptr<AppExecFwk::EventRunner> runner;
91 auto reportHandler = std::make_shared<BundleActiveReportHandler>(runner);
92 auto reportHandler1 = std::make_shared<BundleActiveReportHandler>(runner);
93 BundleActiveContinuousTaskObserver test;
94 test.Init(reportHandler);
95 test.Init(reportHandler1);
96 EXPECT_TRUE(test.reportHandler_ != nullptr);
97
98 std::shared_ptr<OHOS::BackgroundTaskMgr::ContinuousTaskCallbackInfo> continuousTaskCallbackInfo;
99 test.OnContinuousTaskStart(continuousTaskCallbackInfo);
100
101 test.ReportContinuousTaskEvent(continuousTaskCallbackInfo, true);
102 test.ReportContinuousTaskEvent(continuousTaskCallbackInfo, false);
103 SUCCEED();
104
105 test.GetBundleMgr();
106 test.bundleMgr_ = nullptr;
107 test.GetBundleMgr();
108 SUCCEED();
109 #endif
110 #endif
111 }
112
113 /*
114 * @tc.name: BundleActiveBundleMgrHelperTest_001
115 * @tc.desc: test the interface of bundle_active_bundle_mgr_helper
116 * @tc.type: FUNC
117 * @tc.require: DTS2023121404861
118 */
119 HWTEST_F(BundleActiveTotalTest, BundleActiveBundleMgrHelperTest_001, Function | MediumTest | Level0)
120 {
121 AppExecFwk::ApplicationFlag flag = AppExecFwk::GET_BASIC_APPLICATION_INFO;
122 AppExecFwk::ApplicationInfo appInfo;
123 AppExecFwk::BundleInfo bundleInfo;
124 BundleActiveBundleMgrHelper test;
125
126 std::string string = "test";
127 test.GetNameForUid(0, string);
128 test.GetApplicationInfo(string, flag, 0, appInfo);
129 test.GetBundleInfo(string, AppExecFwk::BundleFlag::GET_BUNDLE_WITH_EXTENSION_INFO, bundleInfo, 0);
130 SUCCEED();
131
132 test.bundleMgr_ = nullptr;
133 test.GetNameForUid(0, string);
134 bool result = test.GetApplicationInfo(string, flag, 0, appInfo);
135 EXPECT_FALSE(result);
136 test.GetBundleInfo(string, AppExecFwk::BundleFlag::GET_BUNDLE_WITH_EXTENSION_INFO, bundleInfo, 0);
137 SUCCEED();
138 }
139
140 /*
141 * @tc.name: BundleActiveBundleMgrHelperTest_002
142 * @tc.desc: test GetApplicationInfos
143 * @tc.type: FUNC
144 * @tc.require: issuesI9SQ6G
145 */
146 HWTEST_F(BundleActiveTotalTest, BundleActiveBundleMgrHelperTest_002, Function | MediumTest | Level0)
147 {
148 AppExecFwk::ApplicationFlag flag = AppExecFwk::GET_BASIC_APPLICATION_INFO;
149 std::vector<AppExecFwk::ApplicationInfo> appInfos;
150 bool result = BundleActiveBundleMgrHelper::GetInstance()->GetApplicationInfos(flag, 0, appInfos);
151 EXPECT_TRUE(result);
152 }
153
154 /*
155 * @tc.name: BundleActiveBundleMgrHelperTest_003
156 * @tc.desc: test is launcherApp
157 * @tc.type: FUNC
158 * @tc.require: issuesI9SQ6G
159 */
160 HWTEST_F(BundleActiveTotalTest, BundleActiveBundleMgrHelperTest_003, Function | MediumTest | Level0)
161 {
162 BundleActiveBundleMgrHelper::GetInstance()->InitLauncherAppMap();
163 BundleActiveBundleMgrHelper::GetInstance()->IsLauncherApp("test", 0);
164 BundleActiveBundleMgrHelper::GetInstance()->launcherAppMap_["test"] = false;
165 BundleActiveBundleMgrHelper::GetInstance()->IsLauncherApp("test", 0);
166 EXPECT_TRUE(BundleActiveBundleMgrHelper::GetInstance()->isInitLauncherAppMap_);
167 }
168
169 /*
170 * @tc.name: BundleActiveBundleMgrHelperTest_004
171 * @tc.desc: test is packageContainUidMap
172 * @tc.type: FUNC
173 * @tc.require: issuesI9SQ6G
174 */
175 HWTEST_F(BundleActiveTotalTest, BundleActiveBundleMgrHelperTest_004, Function | MediumTest | Level0)
176 {
177 BundleActiveBundleMgrHelper::GetInstance()->packageContainUidMap_.clear();
178 BundleActiveBundleMgrHelper::GetInstance()->InsertPackageUid("test", 0);
179 EXPECT_NE(BundleActiveBundleMgrHelper::GetInstance()->packageContainUidMap_.size(), 0);
180 BundleActiveBundleMgrHelper::GetInstance()->DeletePackageUid("test", 0);
181 EXPECT_EQ(BundleActiveBundleMgrHelper::GetInstance()->packageContainUidMap_.size(), 0);
182 BundleActiveBundleMgrHelper::GetInstance()->InsertPackageUid("test", 0);
183 auto uidSet = BundleActiveBundleMgrHelper::GetInstance()->GetPackageUidSet("test");
184 EXPECT_NE(uidSet.size(), 0);
185 BundleActiveBundleMgrHelper::GetInstance()->DeleteMemPackage("test");
186 uidSet = BundleActiveBundleMgrHelper::GetInstance()->GetPackageUidSet("test");
187 EXPECT_EQ(uidSet.size(), 0);
188 }
189
190 /*
191 * @tc.name: BundleActiveAppStateObserverTest_001
192 * @tc.desc: test the interface of bundle_active_app_state_observer
193 * @tc.type: FUNC
194 * @tc.require: DTS2023121404861
195 */
196 HWTEST_F(BundleActiveTotalTest, BundleActiveAppStateObserverTest_001, Function | MediumTest | Level0)
197 {
198 AbilityStateData abilityStateData;
199 auto reportHandler = std::make_shared<BundleActiveReportHandler>();
200 BundleActiveAppStateObserver test;
201 test.Init(reportHandler);
202 test.OnAbilityStateChanged(abilityStateData);
203
204 test.Init(reportHandler);
205 abilityStateData.abilityState = static_cast<int32_t>(AppExecFwk::AbilityState::ABILITY_STATE_FOREGROUND);
206 test.OnAbilityStateChanged(abilityStateData);
207 EXPECT_TRUE(test.reportHandler_ != nullptr);
208
209 abilityStateData.abilityState = static_cast<int32_t>(AppExecFwk::AbilityState::ABILITY_STATE_BACKGROUND);
210 test.OnAbilityStateChanged(abilityStateData);
211 SUCCEED();
212
213 abilityStateData.abilityState = static_cast<int32_t>(AppExecFwk::AbilityState::ABILITY_STATE_TERMINATED);
214 test.OnAbilityStateChanged(abilityStateData);
215 SUCCEED();
216 }
217
218 /*
219 * @tc.name: BundleActiveUsageDatabaseTest_001
220 * @tc.desc: test the interface of bundle_active_usage_database
221 * @tc.type: FUNC
222 * @tc.require: DTS2023121404861
223 */
224 HWTEST_F(BundleActiveTotalTest, BundleActiveUsageDatabaseTest_001, Function | MediumTest | Level0)
225 {
226 BundleActiveUsageDatabase test;
227 test.InitDatabaseTableInfo(test.ParseStartTime(test.eventTableName_)-1);
228 EXPECT_FALSE(test.debugDatabase_);
229 }
230
231 /*
232 * @tc.name: BundleActiveUsageDatabaseTest_002
233 * @tc.desc: test the interface of bundle_active_usage_database
234 * @tc.type: FUNC
235 * @tc.require: DTS2023121404861
236 */
237 HWTEST_F(BundleActiveTotalTest, BundleActiveUsageDatabaseTest_002, Function | MediumTest | Level0)
238 {
239 BundleActiveUsageDatabase test;
240 EXPECT_FALSE(test.debugDatabase_);
241 test.debugDatabase_ = true;
242 test.DeleteExcessiveTableData(100);
243 test.DeleteExcessiveTableData(0);
244 SUCCEED();
245 }
246
247 /*
248 * @tc.name: BundleActiveUsageDatabaseTest_003
249 * @tc.desc: test the interface of bundle_active_usage_database
250 * @tc.type: FUNC
251 * @tc.require: DTS2023121404861
252 */
253 HWTEST_F(BundleActiveTotalTest, BundleActiveUsageDatabaseTest_003, Function | MediumTest | Level0)
254 {
255 BundleActiveUsageDatabase test;
256 auto result = test.GetOverdueTableCreateTime(100, 0);
257 EXPECT_EQ(result, nullptr);
258 }
259
260 /*
261 * @tc.name: BundleActiveUsageDatabaseTest_005
262 * @tc.desc: test the interface of bundle_active_usage_database
263 * @tc.type: FUNC
264 * @tc.require: DTS2023121404861
265 */
266 HWTEST_F(BundleActiveTotalTest, BundleActiveUsageDatabaseTest_005, Function | MediumTest | Level0)
267 {
268 BundleActiveUsageDatabase test;
269 test.bundleHistoryTableName_ = "unknownTableName";
270 std::shared_ptr<map<string, std::shared_ptr<BundleActivePackageHistory>>> userHistory;
271 test.PutBundleHistoryData(0, userHistory);
272 test.GetTableIndexSql(0, 0, true, 0);
273 test.GetTableIndexSql(5, 0, true, 0);
274 test.GetTableIndexSql(5, 0, false, 0);
275 test.GetTableIndexSql(5, 0, false, 1);
276 test.GetTableIndexSql(5, 0, false, 2);
277 std::string result = test.GetTableIndexSql(0, 0, false, 0);
278 EXPECT_TRUE(result != "");
279 }
280
281 /*
282 * @tc.name: BundleActiveUsageDatabaseTest_006
283 * @tc.desc: test the interface of bundle_active_usage_database
284 * @tc.type: FUNC
285 * @tc.require: DTS2023121404861
286 */
287 HWTEST_F(BundleActiveTotalTest, BundleActiveUsageDatabaseTest_006, Function | MediumTest | Level0)
288 {
289 BundleActiveUsageDatabase test;
290 std::shared_ptr<NativeRdb::RdbStore> rdbStore;
291 int32_t result = test.SetNewIndexWhenTimeChanged(5, 0, 0, rdbStore);
292 EXPECT_EQ(result, -1);
293 test.RenameTableName(0, 0, 0);
294 test.ExecuteRenameTableName("test", 0, 0, rdbStore);
295 SUCCEED();
296 }
297
298 /*
299 * @tc.name: BundleActiveUsageDatabaseTest_007
300 * @tc.desc: test the interface of bundle_active_usage_database
301 * @tc.type: FUNC
302 * @tc.require: DTS2023121404861
303 */
304 HWTEST_F(BundleActiveTotalTest, BundleActiveUsageDatabaseTest_007, Function | MediumTest | Level0)
305 {
306 BundleActiveUsageDatabase test;
307 std::vector<NativeRdb::ValuesBucket> formValueBuckets;
308 std::shared_ptr<NativeRdb::RdbStore> rdbStore;
309 BundleActiveFormRecord formRecord;
310 test.UpdateFormData(0, "test", "test", formRecord, rdbStore, formValueBuckets);
311 std::string result = test.GetSystemEventName(0);
312 EXPECT_EQ(result, "");
313 test.JudgeQueryCondition(0, 0, 1);
314 SUCCEED();
315 }
316
317 /*
318 * @tc.name: BundleActivePowerStateCallbackServiceTest_001
319 * @tc.desc: test the interface of bundle_active_usage_database
320 * @tc.type: FUNC
321 * @tc.require: DTS2023121404861
322 */
323 HWTEST_F(BundleActiveTotalTest, BundleActivePowerStateCallbackServiceTest_001, Function | MediumTest | Level0)
324 {
325 #ifdef DEVICE_USAGES_STATISTICS_POWERMANGER_ENABLE
326 BundleActivePowerStateCallbackService test1(nullptr);
327
328 std::shared_ptr<BundleActiveCore> bundleActiveCore = std::make_shared<BundleActiveCore>();
329 BundleActivePowerStateCallbackService test2(bundleActiveCore);
330
331 test2.OnPowerStateChanged(PowerState::AWAKE);
332 SUCCEED();
333 test2.OnPowerStateChanged(PowerState::SLEEP);
334 EXPECT_TRUE(test2.bundleActiveCore_ != nullptr);
335 #endif
336 }
337
338 /*
339 * @tc.name: BundleActiveBinarySearchTest_001
340 * @tc.desc: test the interface of bundle_active_binary_search
341 * @tc.type: FUNC
342 * @tc.require: DTS2023121404861
343 */
344 HWTEST_F(BundleActiveTotalTest, BundleActiveBinarySearchTest_001, Function | MediumTest | Level0)
345 {
346 std::vector<int64_t> tableNameArray;
347 BundleActiveBinarySearch test;
348 int32_t result = test.BinarySearch(tableNameArray, 0);
349 EXPECT_EQ(result, -1);
350 result = test.BinarySearch(tableNameArray, -100);
351 EXPECT_EQ(result, -1);
352 tableNameArray.push_back(-1);
353 tableNameArray.push_back(0);
354 tableNameArray.push_back(1);
355 result = test.BinarySearch(tableNameArray, 0);
356 EXPECT_EQ(result, 1);
357 }
358 }
359 }