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 <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_power_state_callback_service.h"
23 #include "bundle_active_service_stub.h"
24 #include "bundle_active_core.h"
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 #include "bundle_active_report_controller.h"
36 #include "bundle_active_test_util.h"
37 #include "bundle_active_event_reporter.h"
38 #include "file_ex.h"
39
40 using namespace testing::ext;
41
42 namespace OHOS {
43 namespace DeviceUsageStats {
44
45 class BundleActiveTotalTest : public testing::Test {
46 public:
47 static void SetUpTestCase(void);
48 static void TearDownTestCase(void);
49 void SetUp();
50 void TearDown();
51 };
52
SetUpTestCase(void)53 void BundleActiveTotalTest::SetUpTestCase(void)
54 {
55 BundleActiveTestUtil::TestInit();
56 }
57
TearDownTestCase(void)58 void BundleActiveTotalTest::TearDownTestCase(void)
59 {
60 BundleActiveTestUtil::TestDeInit();
61 }
62
SetUp(void)63 void BundleActiveTotalTest::SetUp(void)
64 {
65 }
66
TearDown(void)67 void BundleActiveTotalTest::TearDown(void)
68 {
69 }
70
71 /*
72 * @tc.name: BundleActiveAccountHelperTest_001
73 * @tc.desc: test the interface of bundle_active_account_helper
74 * @tc.type: FUNC
75 * @tc.require: DTS2023121404861
76 */
77 HWTEST_F(BundleActiveTotalTest, BundleActiveAccountHelperTest_001, Function | MediumTest | TestSize.Level0)
78 {
79 std::vector<int32_t> activatedOsAccountIds;
80
81 BundleActiveAccountHelper::GetActiveUserId(activatedOsAccountIds);
82
83 EXPECT_NE(activatedOsAccountIds.size(), 0);
84 }
85
86 /*
87 * @tc.name: BundleActiveContinuousTaskObserverTest_001
88 * @tc.desc: test the interface of bundle_active_continuous_task_observer
89 * @tc.type: FUNC
90 * @tc.require: DTS2023121404861
91 */
92 HWTEST_F(BundleActiveTotalTest, BundleActiveContinuousTaskObserverTest_001, Function | MediumTest | TestSize.Level0)
93 {
94 #ifdef BGTASKMGR_ENABLE
95 #ifdef OS_ACCOUNT_PART_ENABLED
96 BundleActiveReportController::GetInstance().Init();
97 BundleActiveContinuousTaskObserver test;
98
99 std::shared_ptr<OHOS::BackgroundTaskMgr::ContinuousTaskCallbackInfo> continuousTaskCallbackInfo;
100 test.OnContinuousTaskStart(continuousTaskCallbackInfo);
101
102 test.ReportContinuousTaskEvent(continuousTaskCallbackInfo, true);
103 test.ReportContinuousTaskEvent(continuousTaskCallbackInfo, false);
104 SUCCEED();
105
106 test.GetBundleMgr();
107 test.bundleMgr_ = nullptr;
108 EXPECT_TRUE(test.GetBundleMgr());
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 | TestSize.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 | TestSize.Level0)
147 {
148 AppExecFwk::ApplicationFlag flag = AppExecFwk::GET_BASIC_APPLICATION_INFO;
149 std::vector<BundleActiveApplication> 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 | TestSize.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 | TestSize.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 | TestSize.Level0)
197 {
198 std::shared_ptr<BundleActiveCore> bundleActiveCore = std::make_shared<BundleActiveCore>();
199 BundleActiveReportController::GetInstance().Init(bundleActiveCore);
200 AbilityStateData abilityStateData;
201 abilityStateData.abilityType = 1;
202 BundleActiveAppStateObserver test;
203 test.OnAbilityStateChanged(abilityStateData);
204
205 abilityStateData.abilityState = static_cast<int32_t>(AppExecFwk::AbilityState::ABILITY_STATE_FOREGROUND);
206 test.OnAbilityStateChanged(abilityStateData);
207 EXPECT_TRUE(BundleActiveReportController::GetInstance().GetBundleReportHandler() != 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 | TestSize.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 | TestSize.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 | TestSize.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 | TestSize.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 | TestSize.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 | TestSize.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 | TestSize.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 | TestSize.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 }