1 /*
2 * Copyright (c) 2021-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
18 #define private public
19 #define protected public
20 #include "resident_process_manager.h"
21 #undef private
22 #undef protected
23 #include "ability_manager_service.h"
24 #include "user_controller.h"
25
26 using namespace testing;
27 using namespace testing::ext;
28 using namespace OHOS::AppExecFwk;
29
30 namespace OHOS {
31 namespace AAFwk {
32
33 class ResidentProcessManagerTest : public testing::Test {
34 public:
35 static void SetUpTestCase(void);
36 static void TearDownTestCase(void);
37 void SetUp();
38 void TearDown();
39 };
40
SetUpTestCase(void)41 void ResidentProcessManagerTest::SetUpTestCase(void)
42 {}
TearDownTestCase(void)43 void ResidentProcessManagerTest::TearDownTestCase(void)
44 {}
SetUp()45 void ResidentProcessManagerTest::SetUp()
46 {}
TearDown()47 void ResidentProcessManagerTest::TearDown()
48 {}
49
50 /*
51 * Feature: ResidentProcessManager
52 * Function: StartResidentProcessWithMainElement
53 * SubFunction: NA
54 * FunctionPoints:ResidentProcessManager StartResidentProcessWithMainElement
55 * EnvConditions: NA
56 * CaseDescription: Verify StartResidentProcessWithMainElement
57 */
58 HWTEST_F(ResidentProcessManagerTest, StartResidentProcessWithMainElement_001, TestSize.Level1)
59 {
60 auto manager = std::make_shared<ResidentProcessManager>();
61 std::vector<BundleInfo> bundleInfos;
62 BundleInfo bundleInfo1;
63 BundleInfo bundleInfo2;
64 HapModuleInfo hapModuleInfo1;
65 HapModuleInfo hapModuleInfo2;
66 hapModuleInfo1.isModuleJson = false;
67 hapModuleInfo1.mainAbility = "";
68 hapModuleInfo2.isModuleJson = true;
69 hapModuleInfo2.mainElementName = "mainElementName";
70 hapModuleInfo2.process = "process";
71 bundleInfo1.isKeepAlive = true;
72 bundleInfo1.applicationInfo.process = "";
73 bundleInfo2.isKeepAlive = true;
74 bundleInfo2.applicationInfo.process = "process";
75 bundleInfo2.hapModuleInfos.emplace_back(hapModuleInfo1);
76 bundleInfo2.hapModuleInfos.emplace_back(hapModuleInfo2);
77 bundleInfos.emplace_back(bundleInfo1);
78 bundleInfos.emplace_back(bundleInfo2);
79 manager->StartResidentProcessWithMainElement(bundleInfos, 0);
80 }
81
82 /*
83 * Feature: ResidentProcessManager
84 * Function: CheckMainElement
85 * SubFunction: NA
86 * FunctionPoints:ResidentProcessManager CheckMainElement
87 * EnvConditions: NA
88 * CaseDescription: Verify CheckMainElement
89 */
90 HWTEST_F(ResidentProcessManagerTest, CheckMainElement_001, TestSize.Level1)
91 {
92 auto manager = std::make_shared<ResidentProcessManager>();
93 HapModuleInfo hapModuleInfo;
94 std::string processName = "processName";
95 std::string mainElement = "";
96 std::set<uint32_t> needEraseIndexSet;
97 size_t bundleInfoIndex = 0;
98 AbilityInfo abilityInfo;
99 hapModuleInfo.mainAbility = "mainAbility";
100 hapModuleInfo.isModuleJson = false;
101 abilityInfo.process = "process";
102 abilityInfo.name = "mainAbility";
103 hapModuleInfo.abilityInfos.push_back(abilityInfo);
104 bool res = manager->CheckMainElement(hapModuleInfo, processName, mainElement, needEraseIndexSet, bundleInfoIndex);
105 EXPECT_FALSE(res);
106 manager.reset();
107 }
108
109 /*
110 * Feature: ResidentProcessManager
111 * Function: CheckMainElement
112 * SubFunction: NA
113 * FunctionPoints:ResidentProcessManager CheckMainElement
114 * EnvConditions: NA
115 * CaseDescription: Verify CheckMainElement
116 */
117 HWTEST_F(ResidentProcessManagerTest, CheckMainElement_002, TestSize.Level1)
118 {
119 auto manager = std::make_shared<ResidentProcessManager>();
120 HapModuleInfo hapModuleInfo;
121 std::string processName = "processName";
122 std::string mainElement = "";
123 std::set<uint32_t> needEraseIndexSet;
124 size_t bundleInfoIndex = 0;
125 AbilityInfo abilityInfo;
126 hapModuleInfo.mainAbility = "mainAbility";
127 hapModuleInfo.isModuleJson = false;
128 abilityInfo.process = "processName";
129 abilityInfo.name = "";
130 hapModuleInfo.abilityInfos.push_back(abilityInfo);
131 bool res = manager->CheckMainElement(hapModuleInfo, processName, mainElement, needEraseIndexSet, bundleInfoIndex);
132 EXPECT_FALSE(res);
133 manager.reset();
134 }
135
136 /*
137 * Feature: ResidentProcessManager
138 * Function: CheckMainElement
139 * SubFunction: NA
140 * FunctionPoints:ResidentProcessManager CheckMainElement
141 * EnvConditions: NA
142 * CaseDescription: Verify CheckMainElement
143 */
144 HWTEST_F(ResidentProcessManagerTest, CheckMainElement_003, TestSize.Level1)
145 {
146 auto manager = std::make_shared<ResidentProcessManager>();
147 HapModuleInfo hapModuleInfo;
148 std::string processName = "processName";
149 std::string mainElement = "";
150 std::set<uint32_t> needEraseIndexSet;
151 size_t bundleInfoIndex = 0;
152 AbilityInfo abilityInfo;
153 hapModuleInfo.mainAbility = "mainAbility";
154 hapModuleInfo.isModuleJson = false;
155 abilityInfo.process = "processName";
156 abilityInfo.name = "mainAbility";
157 abilityInfo.uri = "//";
158 abilityInfo.type = AbilityType::DATA;
159 hapModuleInfo.abilityInfos.push_back(abilityInfo);
160 bool res = manager->CheckMainElement(hapModuleInfo, processName, mainElement, needEraseIndexSet, bundleInfoIndex);
161 EXPECT_FALSE(res);
162 manager.reset();
163 }
164
165 /*
166 * Feature: ResidentProcessManager
167 * Function: CheckMainElement
168 * SubFunction: NA
169 * FunctionPoints:ResidentProcessManager CheckMainElement
170 * EnvConditions: NA
171 * CaseDescription: Verify CheckMainElement
172 */
173 HWTEST_F(ResidentProcessManagerTest, CheckMainElement_004, TestSize.Level1)
174 {
175 auto manager = std::make_shared<ResidentProcessManager>();
176 HapModuleInfo hapModuleInfo;
177 std::string processName = "processName";
178 std::string mainElement = "";
179 std::set<uint32_t> needEraseIndexSet;
180 size_t bundleInfoIndex = 0;
181 AbilityInfo abilityInfo;
182 hapModuleInfo.mainAbility = "mainAbility";
183 hapModuleInfo.isModuleJson = false;
184 abilityInfo.process = "processName";
185 abilityInfo.name = "mainAbility";
186 abilityInfo.uri = "//";
187 abilityInfo.type = AbilityType::PAGE;
188 hapModuleInfo.abilityInfos.push_back(abilityInfo);
189 bool res = manager->CheckMainElement(hapModuleInfo, processName, mainElement, needEraseIndexSet, bundleInfoIndex);
190 EXPECT_FALSE(res);
191 manager.reset();
192 }
193
194 /*
195 * Feature: ResidentProcessManager
196 * Function: CheckMainElement
197 * SubFunction: NA
198 * FunctionPoints:ResidentProcessManager CheckMainElement
199 * EnvConditions: NA
200 * CaseDescription: Verify CheckMainElement
201 */
202 HWTEST_F(ResidentProcessManagerTest, CheckMainElement_005, TestSize.Level1)
203 {
204 auto manager = std::make_shared<ResidentProcessManager>();
205 HapModuleInfo hapModuleInfo;
206 std::string processName = "processName";
207 std::string mainElement = "";
208 std::set<uint32_t> needEraseIndexSet;
209 size_t bundleInfoIndex = 0;
210 hapModuleInfo.mainAbility = "";
211 hapModuleInfo.isModuleJson = true;
212 bool res = manager->CheckMainElement(hapModuleInfo, processName, mainElement, needEraseIndexSet, bundleInfoIndex);
213 EXPECT_FALSE(res);
214 manager.reset();
215 }
216
217 /*
218 * Feature: ResidentProcessManager
219 * Function: CheckMainElement
220 * SubFunction: NA
221 * FunctionPoints:ResidentProcessManager CheckMainElement
222 * EnvConditions: NA
223 * CaseDescription: Verify CheckMainElement
224 */
225 HWTEST_F(ResidentProcessManagerTest, CheckMainElement_006, TestSize.Level1)
226 {
227 auto manager = std::make_shared<ResidentProcessManager>();
228 HapModuleInfo hapModuleInfo;
229 std::string processName = "processName";
230 std::string mainElement = "";
231 std::set<uint32_t> needEraseIndexSet;
232 size_t bundleInfoIndex = 0;
233 hapModuleInfo.mainAbility = "mainAbility";
234 hapModuleInfo.isModuleJson = true;
235 hapModuleInfo.process = "";
236 bool res = manager->CheckMainElement(hapModuleInfo, processName, mainElement, needEraseIndexSet, bundleInfoIndex);
237 EXPECT_FALSE(res);
238 manager.reset();
239 }
240
241 /*
242 * Feature: ResidentProcessManager
243 * Function: SetResidentProcessEnabled
244 * SubFunction: NA
245 * FunctionPoints:ResidentProcessManager SetResidentProcessEnabled
246 * EnvConditions: NA
247 * CaseDescription: Verify SetResidentProcessEnabled
248 */
249 HWTEST_F(ResidentProcessManagerTest, SetResidentProcessEnable_001, TestSize.Level1)
250 {
251 auto manager = std::make_shared<ResidentProcessManager>();
252 ASSERT_NE(manager, nullptr);
253 std::string bundleName = "com.example.resident.process";
254 std::string callerName;
255 EXPECT_EQ(manager->SetResidentProcessEnabled(bundleName, callerName, false), INVALID_PARAMETERS_ERR);
256 }
257
258 /*
259 * Feature: ResidentProcessManager
260 * Function: ResidentProcessManager
261 * SubFunction: NA
262 * FunctionPoints:ResidentProcessManager ResidentProcessManager
263 * EnvConditions: NA
264 * CaseDescription: Verify ResidentProcessManager
265 */
266 HWTEST_F(ResidentProcessManagerTest, SetResidentProcessEnable_002, TestSize.Level1)
267 {
268 auto manager = std::make_shared<ResidentProcessManager>();
269 ASSERT_NE(manager, nullptr);
270
271 std::string bundleName = "com.example.resident.process";
272 std::string callerName = "resident.process.manager.test";
273 EXPECT_EQ(manager->SetResidentProcessEnabled(bundleName, callerName, false), ERR_NO_RESIDENT_PERMISSION);
274 }
275
276 /*
277 * Feature: ResidentProcessManager
278 * Function: PutResidentAbility
279 * SubFunction: NA
280 * FunctionPoints:ResidentProcessManager PutResidentAbility
281 * EnvConditions: NA
282 * CaseDescription: Verify PutResidentAbility
283 */
284 HWTEST_F(ResidentProcessManagerTest, PutResidentAbility_001, TestSize.Level1)
285 {
286 auto manager = std::make_shared<ResidentProcessManager>();
287 ASSERT_NE(manager, nullptr);
288
289 std::string bundleName = "com.example.resident.process";
290 std::string callerName = "resident.process.manager.test";
291 auto residentId = manager->PutResidentAbility(bundleName, callerName, 0);
292 EXPECT_GE(residentId, 0);
293 EXPECT_TRUE(manager->IsResidentAbility(bundleName, callerName, 0));
294 manager->RemoveResidentAbility(residentId);
295 EXPECT_TRUE(manager->residentAbilityInfos_.empty());
296 }
297 } // namespace AAFwk
298 } // namespace OHOS
299