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 <gtest/gtest.h>
17 #define private public
18 #define protected public
19 #include "ability_manager_service.h"
20 #undef private
21 #undef protected
22 #include "mock_app_mgr_client.h"
23
24 using namespace testing;
25 using namespace testing::ext;
26 using namespace OHOS::AppExecFwk;
27
28 namespace OHOS {
29 namespace AAFwk {
30 namespace {
31 const int32_t USER_ID = 100;
32 const size_t SIZE_ZERO = 0;
33 const std::string STRING_PROCESS_NAME = "process_name";
34 } // namespace
35
36 class AbilityManagerServiceDumpTest : public testing::Test {
37 public:
38 static void SetUpTestCase();
39 static void TearDownTestCase();
40 void SetUp();
41 void TearDown();
42
43 public:
44 std::shared_ptr<AbilityManagerService> abilityMs_;
45 std::unique_ptr<MockAppMgrClient> mockAppMgrClient_;
46 };
47
SetUpTestCase()48 void AbilityManagerServiceDumpTest::SetUpTestCase()
49 {}
50
TearDownTestCase()51 void AbilityManagerServiceDumpTest::TearDownTestCase()
52 {}
53
SetUp()54 void AbilityManagerServiceDumpTest::SetUp()
55 {
56 abilityMs_ = OHOS::DelayedSingleton<AbilityManagerService>::GetInstance();
57 EXPECT_NE(abilityMs_, nullptr);
58
59 mockAppMgrClient_ = std::make_unique<MockAppMgrClient>();
60 EXPECT_NE(mockAppMgrClient_, nullptr);
61
62 OHOS::DelayedSingleton<AppScheduler>::GetInstance()->appMgrClient_ = std::move(mockAppMgrClient_);
63 }
64
TearDown()65 void AbilityManagerServiceDumpTest::TearDown()
66 {
67 OHOS::DelayedSingleton<AbilityManagerService>::DestroyInstance();
68 }
69
70 /**
71 * @tc.name: AbilityManagerService_GetProcessRunningInfosByUserId_0100
72 * @tc.desc: GetProcessRunningInfosByUserId
73 * @tc.type: FUNC
74 * @tc.require: SR000GH1GO
75 */
76 HWTEST_F(AbilityManagerServiceDumpTest, AbilityManagerService_GetProcessRunningInfosByUserId_0100, TestSize.Level1)
77 {
78 std::vector<RunningProcessInfo> info;
79 auto result = abilityMs_->GetProcessRunningInfosByUserId(info, USER_ID);
80 EXPECT_EQ(result, AppMgrResultCode::RESULT_OK);
81 }
82
83 /**
84 * @tc.name: AbilityManagerService_DumpSysFuncInit_0100
85 * @tc.desc: DumpSysFuncInit
86 * @tc.type: FUNC
87 * @tc.require: SR000GH1GO
88 */
89 HWTEST_F(AbilityManagerServiceDumpTest, AbilityManagerService_DumpSysFuncInit_0100, TestSize.Level1)
90 {
91 abilityMs_->DumpSysFuncInit();
92 EXPECT_GT(abilityMs_->dumpsysFuncMap_.size(), SIZE_ZERO);
93 }
94
95 /**
96 * @tc.name: AbilityManagerService_DumpSysInner_0100
97 * @tc.desc: DumpSysInner
98 * @tc.type: FUNC
99 * @tc.require: SR000GH1GO
100 */
101 HWTEST_F(AbilityManagerServiceDumpTest, AbilityManagerService_DumpSysInner_0100, TestSize.Level1)
102 {
103 std::string args = "-a";
104 std::vector<std::string> info;
105 bool isClient = false;
106 bool isUserID = true;
107 abilityMs_->DumpSysInner(args, info, isClient, isUserID, USER_ID);
108 EXPECT_GT(info.size(), SIZE_ZERO);
109 }
110
111 /**
112 * @tc.name: AbilityManagerService_DumpSysMissionListInner_0100
113 * @tc.desc: DumpSysMissionListInner
114 * @tc.type: FUNC
115 * @tc.require: SR000GH1GO
116 */
117 HWTEST_F(AbilityManagerServiceDumpTest, AbilityManagerService_DumpSysMissionListInner_0100, TestSize.Level1)
118 {
119 std::string args = "-a";
120 std::vector<std::string> info;
121 bool isClient = false;
122 bool isUserID = true;
123 abilityMs_->DumpSysMissionListInner(args, info, isClient, isUserID, USER_ID);
124 EXPECT_GT(info.size(), SIZE_ZERO);
125 }
126
127 /**
128 * @tc.name: AbilityManagerService_DumpSysAbilityInner_0100
129 * @tc.desc: DumpSysAbilityInner
130 * @tc.type: FUNC
131 * @tc.require: SR000GH1GO
132 */
133 HWTEST_F(AbilityManagerServiceDumpTest, AbilityManagerService_DumpSysAbilityInner_0100, TestSize.Level1)
134 {
135 std::string args = "-a";
136 std::vector<std::string> info;
137 bool isClient = false;
138 bool isUserID = true;
139 abilityMs_->DumpSysAbilityInner(args, info, isClient, isUserID, USER_ID);
140 EXPECT_GT(info.size(), SIZE_ZERO);
141 }
142
143 /**
144 * @tc.name: AbilityManagerService_DumpSysStateInner_0100
145 * @tc.desc: DumpSysStateInner
146 * @tc.type: FUNC
147 * @tc.require: SR000GH1GO
148 */
149 HWTEST_F(AbilityManagerServiceDumpTest, AbilityManagerService_DumpSysStateInner_0100, TestSize.Level1)
150 {
151 std::string args = "-a";
152 std::vector<std::string> info;
153 bool isClient = false;
154 bool isUserID = true;
155 abilityMs_->DumpSysStateInner(args, info, isClient, isUserID, USER_ID);
156 EXPECT_GT(info.size(), SIZE_ZERO);
157 }
158
159 /**
160 * @tc.name: AbilityManagerService_DumpSysPendingInner_0100
161 * @tc.desc: DumpSysPendingInner
162 * @tc.type: FUNC
163 * @tc.require: SR000GH1GO
164 */
165 HWTEST_F(AbilityManagerServiceDumpTest, AbilityManagerService_DumpSysPendingInner_0100, TestSize.Level1)
166 {
167 std::string args = "-a";
168 std::vector<std::string> info;
169 bool isClient = false;
170 bool isUserID = true;
171 abilityMs_->DumpSysPendingInner(args, info, isClient, isUserID, USER_ID);
172 EXPECT_GT(info.size(), SIZE_ZERO);
173 }
174
175 /**
176 * @tc.name: AbilityManagerService_DumpSysProcess_0100
177 * @tc.desc: DumpSysProcess
178 * @tc.type: FUNC
179 * @tc.require: SR000GH1GO
180 */
181 HWTEST_F(AbilityManagerServiceDumpTest, AbilityManagerService_DumpSysProcess_0100, TestSize.Level1)
182 {
183 std::string args = "-a";
184 std::vector<std::string> info;
185 bool isClient = false;
186 bool isUserID = true;
187 abilityMs_->DumpSysProcess(args, info, isClient, isUserID, USER_ID);
188 EXPECT_GT(info.size(), SIZE_ZERO);
189 }
190
191 /**
192 * @tc.name: AbilityManagerService_DataDumpSysStateInner_0100
193 * @tc.desc: DataDumpSysStateInner
194 * @tc.type: FUNC
195 * @tc.require: SR000GH1GO
196 */
197 HWTEST_F(AbilityManagerServiceDumpTest, AbilityManagerService_DataDumpSysStateInner_0100, TestSize.Level1)
198 {
199 std::string args = "-a";
200 std::vector<std::string> info;
201 bool isClient = false;
202 bool isUserID = true;
203 abilityMs_->DataDumpSysStateInner(args, info, isClient, isUserID, USER_ID);
204 EXPECT_GT(info.size(), SIZE_ZERO);
205 }
206
207 /**
208 * @tc.name: AbilityManagerService_OnAppStateChanged_0100
209 * @tc.desc: OnAppStateChanged
210 * @tc.type: FUNC
211 * @tc.require: SR000GH1GO
212 */
213 HWTEST_F(AbilityManagerServiceDumpTest, AbilityManagerService_OnAppStateChanged_0100, TestSize.Level1)
214 {
215 abilityMs_->connectManager_ = std::make_shared<AbilityConnectManager>(0);
216 EXPECT_NE(abilityMs_->connectManager_, nullptr);
217
218 Want want;
219 OHOS::AppExecFwk::AbilityInfo abilityInfo;
220 abilityInfo.process = STRING_PROCESS_NAME;
221 OHOS::AppExecFwk::ApplicationInfo applicationInfo;
222 auto abilityRecord = std::make_shared<AbilityRecord>(want, abilityInfo, applicationInfo);
223 EXPECT_NE(abilityRecord, nullptr);
224
225 abilityMs_->currentMissionListManager_ = std::make_shared<MissionListManager>(USER_ID);
226 EXPECT_NE(abilityMs_->currentMissionListManager_, nullptr);
227 abilityMs_->currentMissionListManager_->terminateAbilityList_.push_back(abilityRecord);
228
229 abilityMs_->dataAbilityManager_ = std::make_shared<DataAbilityManager>();
230 EXPECT_NE(abilityMs_->dataAbilityManager_, nullptr);
231
232 AppInfo info;
233 info.processName = STRING_PROCESS_NAME;
234 info.state = AppState::TERMINATED;
235 abilityMs_->OnAppStateChanged(info);
236
237 abilityRecord = abilityMs_->currentMissionListManager_->terminateAbilityList_.front();
238 EXPECT_NE(abilityRecord, nullptr);
239 EXPECT_EQ(abilityRecord->GetAppState(), AppState::TERMINATED);
240 }
241 } // namespace AAFwk
242 } // namespace OHOS
243