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 <unistd.h>
17 #include <gtest/gtest.h>
18
19 #include "app_mgr_proxy.h"
20 #include "app_record_id.h"
21 #include "app_scheduler_proxy.h"
22 #include "application_state_observer_stub.h"
23 #include "errors.h"
24 #include "hilog_tag_wrapper.h"
25 #include "ipc_types.h"
26 #include "mock_application.h"
27 #include "mock_app_mgr_service.h"
28 #include "mock_kia_interceptor.h"
29
30 using namespace testing::ext;
31
32 using OHOS::iface_cast;
33 using OHOS::sptr;
34 using testing::_;
35 using testing::Invoke;
36 using testing::InvokeWithoutArgs;
37 using testing::Return;
38
39 namespace OHOS {
40 namespace AppExecFwk {
41 class AmsIpcAppMgrInterfaceTest : public testing::Test {
42 public:
43 static void SetUpTestCase();
44 static void TearDownTestCase();
45 void SetUp();
46 void TearDown();
47 };
48
SetUpTestCase()49 void AmsIpcAppMgrInterfaceTest::SetUpTestCase()
50 {}
51
TearDownTestCase()52 void AmsIpcAppMgrInterfaceTest::TearDownTestCase()
53 {}
54
SetUp()55 void AmsIpcAppMgrInterfaceTest::SetUp()
56 {}
57
TearDown()58 void AmsIpcAppMgrInterfaceTest::TearDown()
59 {}
60
61 /*
62 * Feature: AMS
63 * Function: IPC
64 * SubFunction: appmgr interface
65 * FunctionPoints: interface
66 * CaseDescription: test interface of AttachApplication
67 */
68 HWTEST_F(AmsIpcAppMgrInterfaceTest, Interface_001, TestSize.Level1)
69 {
70 TAG_LOGD(AAFwkTag::TEST, "AppMgrIpcInterfaceTest_AppMgr_001 start");
71 sptr<MockAppMgrService> mockAppMgr(new MockAppMgrService());
72 sptr<IAppMgr> appMgrClient = iface_cast<IAppMgr>(mockAppMgr);
73 sptr<MockApplication> app(new MockApplication());
74
75 EXPECT_CALL(*mockAppMgr, AttachApplication(_))
76 .WillOnce(InvokeWithoutArgs(mockAppMgr.GetRefPtr(), &MockAppMgrService::Post));
77 appMgrClient->AttachApplication(app);
78 mockAppMgr->Wait();
79 TAG_LOGD(AAFwkTag::TEST, "AppMgrIpcInterfaceTest_AppMgr_001 end");
80 }
81
82 /*
83 * Feature: AMS
84 * Function: IPC
85 * SubFunction: appmgr interface
86 * FunctionPoints: interface
87 * CaseDescription: test interface of ApplicationForegrounded
88 */
89 HWTEST_F(AmsIpcAppMgrInterfaceTest, Interface_002, TestSize.Level1)
90 {
91 TAG_LOGD(AAFwkTag::TEST, "AppMgrIpcInterfaceTest_AppMgr_002 start");
92 sptr<MockAppMgrService> mockAppMgr(new MockAppMgrService());
93 sptr<IAppMgr> appMgrClient = iface_cast<IAppMgr>(mockAppMgr);
94
95 EXPECT_CALL(*mockAppMgr, ApplicationForegrounded(_))
96 .WillOnce(InvokeWithoutArgs(mockAppMgr.GetRefPtr(), &MockAppMgrService::Post));
97 auto recordId = AppRecordId::Create();
98 appMgrClient->ApplicationForegrounded(recordId);
99 mockAppMgr->Wait();
100 TAG_LOGD(AAFwkTag::TEST, "AppMgrIpcInterfaceTest_AppMgr_002 end");
101 }
102
103 /*
104 * Feature: AMS
105 * Function: IPC
106 * SubFunction: appmgr interface
107 * FunctionPoints: interface
108 * CaseDescription: test interface of ApplicationBackgrounded
109 */
110 HWTEST_F(AmsIpcAppMgrInterfaceTest, Interface_003, TestSize.Level1)
111 {
112 TAG_LOGD(AAFwkTag::TEST, "AppMgrIpcInterfaceTest_AppMgr_003 start");
113 sptr<MockAppMgrService> mockAppMgr(new MockAppMgrService());
114 sptr<IAppMgr> appMgrClient = iface_cast<IAppMgr>(mockAppMgr);
115
116 EXPECT_CALL(*mockAppMgr, ApplicationBackgrounded(_))
117 .WillOnce(InvokeWithoutArgs(mockAppMgr.GetRefPtr(), &MockAppMgrService::Post));
118 auto recordId = AppRecordId::Create();
119 appMgrClient->ApplicationBackgrounded(recordId);
120 mockAppMgr->Wait();
121 TAG_LOGD(AAFwkTag::TEST, "AppMgrIpcInterfaceTest_AppMgr_003 end");
122 }
123
124 /*
125 * Feature: AMS
126 * Function: IPC
127 * SubFunction: appmgr interface
128 * FunctionPoints: interface
129 * CaseDescription: test interface of ApplicationTerminated
130 */
131 HWTEST_F(AmsIpcAppMgrInterfaceTest, Interface_004, TestSize.Level1)
132 {
133 TAG_LOGD(AAFwkTag::TEST, "AppMgrIpcInterfaceTest_AppMgr_004 start");
134 sptr<MockAppMgrService> mockAppMgr(new MockAppMgrService());
135 sptr<IAppMgr> appMgrClient = iface_cast<IAppMgr>(mockAppMgr);
136
137 EXPECT_CALL(*mockAppMgr, ApplicationTerminated(_))
138 .WillOnce(InvokeWithoutArgs(mockAppMgr.GetRefPtr(), &MockAppMgrService::Post));
139 auto recordId = AppRecordId::Create();
140 appMgrClient->ApplicationTerminated(recordId);
141 mockAppMgr->Wait();
142 TAG_LOGD(AAFwkTag::TEST, "AppMgrIpcInterfaceTest_AppMgr_004 end");
143 }
144
145 /*
146 * Feature: AMS
147 * Function: IPC
148 * SubFunction: appmgr interface
149 * FunctionPoints: KillApplication interface
150 * CaseDescription: test IPC can transact data
151 */
152 HWTEST_F(AmsIpcAppMgrInterfaceTest, ClearUpApplicationData_008, TestSize.Level1)
153 {
154 TAG_LOGD(AAFwkTag::TEST, "ClearUpApplicationData_008 start");
155
156 sptr<MockAppMgrService> mockAppMgr(new MockAppMgrService());
157 sptr<IAppMgr> appMgrClient = iface_cast<IAppMgr>(mockAppMgr);
158
159 EXPECT_CALL(*mockAppMgr, ClearUpApplicationData(_, _, _)).Times(1);
160
161 appMgrClient->ClearUpApplicationData("PROCESS", 0);
162
163 TAG_LOGD(AAFwkTag::TEST, "ClearUpApplicationData_008 end");
164 }
165
166 /*
167 * Feature: AMS
168 * Function: IPC
169 * SubFunction: appmgr interface
170 * FunctionPoints: KillApplication interface
171 * CaseDescription: test IPC can transact data
172 */
173 HWTEST_F(AmsIpcAppMgrInterfaceTest, GetAllRunningProcesses_010, TestSize.Level1)
174 {
175 TAG_LOGD(AAFwkTag::TEST, "GetAllRunningProcesses_009 start");
176
177 sptr<MockAppMgrService> mockAppMgr(new MockAppMgrService());
178 sptr<IAppMgr> appMgrClient = iface_cast<IAppMgr>(mockAppMgr);
179
180 EXPECT_CALL(*mockAppMgr, GetAllRunningProcesses(_)).Times(1).WillOnce(Return(OHOS::ERR_NULL_OBJECT));
181
182 std::vector<RunningProcessInfo> runningProcessInfo;
183 int32_t ret = appMgrClient->GetAllRunningProcesses(runningProcessInfo);
184 EXPECT_EQ(ret, OHOS::ERR_NULL_OBJECT);
185
186 EXPECT_CALL(*mockAppMgr, GetAllRunningProcesses(_)).Times(1).WillOnce(Return(OHOS::ERR_NONE));
187 ret = appMgrClient->GetAllRunningProcesses(runningProcessInfo);
188 EXPECT_EQ(ret, OHOS::ERR_NONE);
189
190 TAG_LOGD(AAFwkTag::TEST, "GetAllRunningProcesses_009 end");
191 }
192
193 /*
194 * @tc.name: RegisterApplicationStateObserver_001
195 * @tc.desc: Register application state observer test.
196 * @tc.type: FUNC
197 * @tc.require: issueI5822Q
198 */
199 HWTEST_F(AmsIpcAppMgrInterfaceTest, RegisterApplicationStateObserver_001, TestSize.Level0)
200 {
201 TAG_LOGD(AAFwkTag::TEST, "RegisterApplicationStateObserver_001 start");
202
203 sptr<IApplicationStateObserver> observer = new ApplicationStateObserverStub();
204 std::vector<std::string> bundleNameList;
205 sptr<MockAppMgrService> mockAppMgr(new MockAppMgrService());
206 sptr<IAppMgr> appMgrClient = iface_cast<IAppMgr>(mockAppMgr);
207
208 EXPECT_CALL(*mockAppMgr, RegisterApplicationStateObserver(_, _)).Times(1).WillOnce(Return(OHOS::NO_ERROR));
209
210 int32_t err = appMgrClient->RegisterApplicationStateObserver(observer, bundleNameList);
211
212 EXPECT_EQ(OHOS::NO_ERROR, err);
213
214 TAG_LOGD(AAFwkTag::TEST, "RegisterApplicationStateObserver_001 end");
215 }
216
217 /*
218 * Feature: AMS
219 * Function: IPC
220 * SubFunction: appmgr interface
221 * FunctionPoints: KillApplication interface
222 * CaseDescription: test IPC can transact data
223 */
224 HWTEST_F(AmsIpcAppMgrInterfaceTest, UnregisterApplicationStateObserver_001, TestSize.Level0)
225 {
226 TAG_LOGD(AAFwkTag::TEST, "UnregisterApplicationStateObserver_001 start");
227
228 sptr<IApplicationStateObserver> observer = new ApplicationStateObserverStub();
229 sptr<MockAppMgrService> mockAppMgr(new MockAppMgrService());
230 sptr<IAppMgr> appMgrClient = iface_cast<IAppMgr>(mockAppMgr);
231
232 EXPECT_CALL(*mockAppMgr, UnregisterApplicationStateObserver(_)).Times(1).WillOnce(Return(OHOS::NO_ERROR));
233
234 int32_t err = appMgrClient->UnregisterApplicationStateObserver(observer);
235
236 EXPECT_EQ(OHOS::NO_ERROR, err);
237
238 TAG_LOGD(AAFwkTag::TEST, "UnregisterApplicationStateObserver_001 end");
239 }
240
241 /*
242 * @tc.name: RegisterKiaInterceptor_001
243 * @tc.desc: Register kia interceptor test.
244 * @tc.type: FUNC
245 */
246 HWTEST_F(AmsIpcAppMgrInterfaceTest, RegisterKiaInterceptor_001, TestSize.Level0)
247 {
248 TAG_LOGD(AAFwkTag::TEST, "RegisterKiaInterceptor_001 start");
249
250 sptr<MockAppMgrService> mockAppMgr(new MockAppMgrService());
251 sptr<IAppMgr> appMgrClient = iface_cast<IAppMgr>(mockAppMgr);
252
253 EXPECT_CALL(*mockAppMgr, RegisterKiaInterceptor(_)).Times(1).WillOnce(Return(ERR_OK));
254
255 sptr<IKiaInterceptor> interceptor = new MockKiaInterceptor();
256 int32_t err = appMgrClient->RegisterKiaInterceptor(interceptor);
257 EXPECT_EQ(ERR_OK, err);
258
259 TAG_LOGD(AAFwkTag::TEST, "RegisterKiaInterceptor_001 end");
260 }
261
262 /*
263 * @tc.name: RegisterKiaInterceptor_002
264 * @tc.desc: Register kia interceptor test.
265 * @tc.type: FUNC
266 */
267 HWTEST_F(AmsIpcAppMgrInterfaceTest, RegisterKiaInterceptor_002, TestSize.Level0)
268 {
269 TAG_LOGD(AAFwkTag::TEST, "RegisterKiaInterceptor_002 start");
270
271 sptr<MockAppMgrService> mockAppMgr(new MockAppMgrService());
272 sptr<IAppMgr> appMgrClient = iface_cast<IAppMgr>(mockAppMgr);
273
274 EXPECT_CALL(*mockAppMgr, RegisterKiaInterceptor(_)).Times(1).WillOnce(Return(ERR_INVALID_VALUE));
275
276 sptr<IKiaInterceptor> interceptor = new MockKiaInterceptor();
277 int32_t err = appMgrClient->RegisterKiaInterceptor(interceptor);
278 EXPECT_EQ(ERR_INVALID_VALUE, err);
279
280 TAG_LOGD(AAFwkTag::TEST, "RegisterKiaInterceptor_002 end");
281 }
282
283 /*
284 * @tc.name: CheckIsKiaProcess_001
285 * @tc.desc: Check if a process is kia protected.
286 * @tc.type: FUNC
287 */
288 HWTEST_F(AmsIpcAppMgrInterfaceTest, CheckIsKiaProcess_001, TestSize.Level0)
289 {
290 TAG_LOGD(AAFwkTag::TEST, "CheckIsKiaProcess_001 start");
291
292 sptr<MockAppMgrService> mockAppMgr(new MockAppMgrService());
293 sptr<IAppMgr> appMgrClient = iface_cast<IAppMgr>(mockAppMgr);
294
295 EXPECT_CALL(*mockAppMgr, CheckIsKiaProcess(_, _)).Times(1).WillOnce(Return(ERR_OK));
296
297 pid_t pid = 1234;
298 bool isKia = false;
299 int32_t err = appMgrClient->CheckIsKiaProcess(pid, isKia);
300 EXPECT_EQ(ERR_OK, err);
301
302 TAG_LOGD(AAFwkTag::TEST, "CheckIsKiaProcess_001 end");
303 }
304
305 /*
306 * @tc.name: CheckIsKiaProcess_002
307 * @tc.desc: Check if a process is kia protected.
308 * @tc.type: FUNC
309 */
310 HWTEST_F(AmsIpcAppMgrInterfaceTest, CheckIsKiaProcess_002, TestSize.Level0)
311 {
312 TAG_LOGD(AAFwkTag::TEST, "CheckIsKiaProcess_002 start");
313
314 sptr<MockAppMgrService> mockAppMgr(new MockAppMgrService());
315 sptr<IAppMgr> appMgrClient = iface_cast<IAppMgr>(mockAppMgr);
316
317 EXPECT_CALL(*mockAppMgr, CheckIsKiaProcess(_, _)).Times(1).WillOnce(Return(ERR_INVALID_VALUE));
318
319 pid_t pid = 1234;
320 bool isKia = false;
321 int32_t err = appMgrClient->CheckIsKiaProcess(pid, isKia);
322 EXPECT_EQ(ERR_INVALID_VALUE, err);
323
324 TAG_LOGD(AAFwkTag::TEST, "CheckIsKiaProcess_002 end");
325 }
326 } // namespace AppExecFwk
327 } // namespace OHOS
328