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