1 /*
2 * Copyright (c) 2021 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 #include <gmock/gmock.h>
18
19 #include "abs_shared_result_set.h"
20 #include "data_ability_predicates.h"
21 #include "values_bucket.h"
22 #include "uri.h"
23 #include "want.h"
24 #include "semaphore_ex.h"
25 #include "session_info.h"
26 #include "ability_scheduler_stub.h"
27 #include "ability_scheduler_proxy.h"
28 #include "mock_ability_scheduler_stub.h"
29
30 namespace {
31 constexpr int COUNT = 1;
32 } // namespace
33
34 using namespace testing::ext;
35 using namespace OHOS;
36 using namespace OHOS::AAFwk;
37 using OHOS::iface_cast;
38 using OHOS::sptr;
39 using testing::_;
40 using testing::Invoke;
41 using testing::InvokeWithoutArgs;
42
43 class IpcAbilitySchedulerModuleTest : public testing::Test {
44 public:
45 static void SetUpTestCase();
46 static void TearDownTestCase();
47 void SetUp();
48 void TearDown();
49 };
50
SetUpTestCase()51 void IpcAbilitySchedulerModuleTest::SetUpTestCase()
52 {}
53
TearDownTestCase()54 void IpcAbilitySchedulerModuleTest::TearDownTestCase()
55 {}
56
SetUp()57 void IpcAbilitySchedulerModuleTest::SetUp()
58 {}
59
TearDown()60 void IpcAbilitySchedulerModuleTest::TearDown()
61 {}
62
63 /*
64 * Feature: AAFwk
65 * Function: AbilityScheduler
66 * SubFunction: IPC of Aafwk and AppExecFwk
67 * FunctionPoints: ScheduleAbilityTransaction
68 * EnvConditions: NA
69 * CaseDescription: verify ScheduleAbilityTransaction IPC between Aafwk and AppExecFwk.
70 */
71 HWTEST_F(IpcAbilitySchedulerModuleTest, ScheduleAbilityTransaction_001, TestSize.Level3)
72 {
73 Semaphore sem(0);
74 struct {
75 Want want;
76 LifeCycleStateInfo lifeCycleStateInfo;
77 } proxyState, stubState;
78
79 proxyState.want.SetAction("test");
80 proxyState.lifeCycleStateInfo.isNewWant = true;
81
82 for (int i = 0; i < COUNT; i++) {
83 sptr<MockAbilitySchedulerStub> stub(new MockAbilitySchedulerStub());
84 sptr<IAbilityScheduler> proxy = iface_cast<IAbilityScheduler>(stub);
85
86 Want::ClearWant(&stubState.want);
87 stubState.lifeCycleStateInfo.isNewWant = false;
88
89 auto stubHandler = [&](const Want& want, const LifeCycleStateInfo& lifeCycleStateInfo,
__anona0aac8190302(const Want& want, const LifeCycleStateInfo& lifeCycleStateInfo, sptr<SessionInfo> sessionInfo) 90 sptr<SessionInfo> sessionInfo) {
91 stubState.want.SetAction(want.GetAction());
92 stubState.lifeCycleStateInfo.isNewWant = lifeCycleStateInfo.isNewWant;
93 sem.Post();
94 };
95
96 EXPECT_CALL(*stub, ScheduleAbilityTransaction(_, _, _)).Times(1)
97 .WillOnce(testing::DoAll(Invoke(stubHandler), testing::Return(true)));
98
99 proxy->ScheduleAbilityTransaction(proxyState.want, proxyState.lifeCycleStateInfo);
100
101 sem.Wait();
102
103 EXPECT_EQ(stubState.want.GetAction(), proxyState.want.GetAction());
104 EXPECT_EQ(stubState.lifeCycleStateInfo.isNewWant, proxyState.lifeCycleStateInfo.isNewWant);
105 }
106 }
107
108 /*
109 * Feature: AAFwk
110 * Function: AbilityScheduler
111 * SubFunction: IPC of Aafwk and AppExecFwk
112 * FunctionPoints: SendResult
113 * EnvConditions: NA
114 * CaseDescription: verify SendResult IPC between Aafwk and AppExecFwk.
115 */
116 HWTEST_F(IpcAbilitySchedulerModuleTest, SendResult_001, TestSize.Level3)
117 {
118 Semaphore sem(0);
119 struct {
120 int requestCode;
121 int resultCode;
122 Want resultWant;
123 } proxyState, stubState;
124
125 proxyState.requestCode = 123;
126 proxyState.resultCode = 456;
127 proxyState.resultWant.SetAction("test");
128
129 for (int i = 0; i < COUNT; i++) {
130 sptr<MockAbilitySchedulerStub> stub(new MockAbilitySchedulerStub());
131 sptr<IAbilityScheduler> proxy = iface_cast<IAbilityScheduler>(stub);
132
133 stubState.requestCode = 0;
134 Want::ClearWant(&stubState.resultWant);
135
__anona0aac8190502(int requestCode, int resultCode, const Want& resultWant) 136 auto stubHandler = [&](int requestCode, int resultCode, const Want& resultWant) {
137 stubState.requestCode = requestCode;
138 stubState.resultCode = resultCode;
139 stubState.resultWant.SetAction(resultWant.GetAction());
140 sem.Post();
141 };
142
143 EXPECT_CALL(*stub, SendResult(_, _, _)).Times(1).WillOnce(Invoke(stubHandler));
144
145 proxy->SendResult(proxyState.requestCode, proxyState.resultCode, proxyState.resultWant);
146
147 sem.Wait();
148
149 EXPECT_EQ(stubState.requestCode, proxyState.requestCode);
150 EXPECT_EQ(stubState.resultCode, proxyState.resultCode);
151 EXPECT_EQ(stubState.resultWant.GetAction(), proxyState.resultWant.GetAction());
152 }
153 }
154
155 /*
156 * Feature: AAFwk
157 * Function: AbilityScheduler
158 * SubFunction: IPC of Aafwk and AppExecFwk
159 * FunctionPoints: ScheduleConnectAbility
160 * EnvConditions: NA
161 * CaseDescription: verify ScheduleConnectAbility IPC between Aafwk and AppExecFwk.
162 */
163 HWTEST_F(IpcAbilitySchedulerModuleTest, ScheduleConnectAbility_001, TestSize.Level3)
164 {
165 Semaphore sem(0);
166 struct {
167 Want want;
168 } proxyState, stubState;
169
170 proxyState.want.SetAction("test");
171
172 for (int i = 0; i < COUNT; i++) {
173 sptr<MockAbilitySchedulerStub> stub(new MockAbilitySchedulerStub());
174 sptr<IAbilityScheduler> proxy = iface_cast<IAbilityScheduler>(stub);
175
176 Want::ClearWant(&stubState.want);
177
__anona0aac8190702(const Want& want) 178 auto stubHandler = [&](const Want& want) {
179 stubState.want.SetAction(want.GetAction());
180 sem.Post();
181 };
182
183 EXPECT_CALL(*stub, ScheduleConnectAbility(_)).Times(1).WillOnce(Invoke(stubHandler));
184
185 proxy->ScheduleConnectAbility(proxyState.want);
186
187 sem.Wait();
188
189 EXPECT_EQ(stubState.want.GetAction(), proxyState.want.GetAction());
190 }
191 }
192
193 /*
194 * Feature: AAFwk
195 * Function: AbilityScheduler
196 * SubFunction: IPC of Aafwk and AppExecFwk
197 * FunctionPoints: ScheduleDisconnectAbility
198 * EnvConditions: NA
199 * CaseDescription: verify ScheduleDisconnectAbility IPC between Aafwk and AppExecFwk.
200 */
201 HWTEST_F(IpcAbilitySchedulerModuleTest, ScheduleDisconnectAbility_001, TestSize.Level3)
202 {
203 Semaphore sem(0);
204 struct {
205 Want want;
206 } proxyState, stubState;
207
208 proxyState.want.SetAction("test");
209
210 for (int i = 0; i < COUNT; i++) {
211 sptr<MockAbilitySchedulerStub> stub(new MockAbilitySchedulerStub());
212 sptr<IAbilityScheduler> proxy = iface_cast<IAbilityScheduler>(stub);
213
214 Want::ClearWant(&stubState.want);
__anona0aac8190902(const Want& want) 215 auto stubHandler = [&](const Want& want) {
216 stubState.want.SetAction(want.GetAction());
217 sem.Post();
218 };
219 EXPECT_CALL(*stub, ScheduleDisconnectAbility(_)).Times(1).WillOnce(Invoke(stubHandler));
220
221 proxy->ScheduleDisconnectAbility(proxyState.want);
222
223 sem.Wait();
224 }
225 }
226
227 /*
228 * Feature: AAFwk
229 * Function: AbilityScheduler
230 * SubFunction: IPC of Aafwk and AppExecFwk
231 * FunctionPoints: ScheduleSaveAbilityState
232 * EnvConditions: NA
233 * CaseDescription: verify ScheduleSaveAbilityState IPC between Aafwk and AppExecFwk.
234 */
235 HWTEST_F(IpcAbilitySchedulerModuleTest, ScheduleSaveAbilityState_001, TestSize.Level3)
236 {
237 Semaphore sem(0);
238
239 for (int i = 0; i < COUNT; i++) {
240 sptr<MockAbilitySchedulerStub> stub(new MockAbilitySchedulerStub());
241 sptr<IAbilityScheduler> proxy = iface_cast<IAbilityScheduler>(stub);
242
243 bool testResult = false;
__anona0aac8190a02() 244 auto mockHandler = [&]() {
245 testResult = true;
246 sem.Post();
247 };
248
249 EXPECT_CALL(*stub, ScheduleSaveAbilityState()).Times(1).WillOnce(Invoke(mockHandler));
250
251 proxy->ScheduleSaveAbilityState();
252
253 sem.Wait();
254
255 EXPECT_TRUE(testResult);
256 }
257 }
258
259 /*
260 * Feature: AAFwk
261 * Function: AbilityScheduler
262 * SubFunction: IPC of Aafwk and AppExecFwk
263 * FunctionPoints: ScheduleRestoreAbilityState
264 * EnvConditions: NA
265 * CaseDescription: verify ScheduleRestoreAbilityState IPC between Aafwk and AppExecFwk.
266 */
267 HWTEST_F(IpcAbilitySchedulerModuleTest, ScheduleRestoreAbilityState_001, TestSize.Level3)
268 {
269 Semaphore sem(0);
270
271 for (int i = 0; i < COUNT; i++) {
272 sptr<MockAbilitySchedulerStub> stub(new MockAbilitySchedulerStub());
273 sptr<IAbilityScheduler> proxy = iface_cast<IAbilityScheduler>(stub);
274
275 bool testResult = false;
__anona0aac8190b02(const PacMap& pacMap) 276 auto mockHandler = [&](const PacMap& pacMap) {
277 testResult = true;
278 sem.Post();
279 };
280
281 EXPECT_CALL(*stub, ScheduleRestoreAbilityState(_)).Times(1).WillOnce(Invoke(mockHandler));
282
283 PacMap pacMap;
284 proxy->ScheduleRestoreAbilityState(pacMap);
285
286 sem.Wait();
287
288 EXPECT_TRUE(testResult);
289 }
290 }
291
292 /*
293 * Feature: AAFwk
294 * Function: AbilityScheduler
295 * SubFunction: IPC of AMS and App
296 * FunctionPoints: GetFileType
297 * EnvConditions: NA
298 * CaseDescription: verify GetFileType IPC between AMS and AppFwk.
299 */
300 HWTEST_F(IpcAbilitySchedulerModuleTest, GetFileType_001, TestSize.Level1)
301 {
302 Semaphore sem(0);
303
304 for (int i = 0; i < COUNT; i++) {
305 sptr<MockAbilitySchedulerStub> stub(new MockAbilitySchedulerStub());
306 sptr<IAbilityScheduler> proxy = iface_cast<IAbilityScheduler>(stub);
307
308 bool testResult = false;
309 std::string testUri("dataability://test/path");
310 std::string testMime("text");
311
__anona0aac8190c02(const Uri& uri, const std::string& mime) 312 auto mockHandler = [&](const Uri& uri, const std::string& mime) {
313 testResult = (mime == testMime);
314 std::vector<std::string> ret;
315 ret.emplace_back("type1");
316 ret.emplace_back("type2");
317 sem.Post();
318 return ret;
319 };
320
321 EXPECT_CALL(*stub, GetFileTypes(_, _)).Times(1).WillOnce(Invoke(mockHandler));
322
323 auto result = proxy->GetFileTypes(Uri(testUri), testMime);
324
325 sem.Wait();
326
327 EXPECT_TRUE(testResult);
328 EXPECT_EQ(result.size(), size_t(2));
329 EXPECT_EQ(result[0], "type1");
330 EXPECT_EQ(result[1], "type2");
331 }
332 }
333
334 /*
335 * Feature: AAFwk
336 * Function: AbilityScheduler
337 * SubFunction: IPC of AMS and App
338 * FunctionPoints: OpenFile
339 * EnvConditions: NA
340 * CaseDescription: verify OpenFile IPC between AMS and AppFwk.
341 */
342 HWTEST_F(IpcAbilitySchedulerModuleTest, OpenFile_001, TestSize.Level1)
343 {
344 Semaphore sem(0);
345
346 for (int i = 0; i < COUNT; i++) {
347 sptr<MockAbilitySchedulerStub> stub(new MockAbilitySchedulerStub());
348 sptr<IAbilityScheduler> proxy = iface_cast<IAbilityScheduler>(stub);
349
350 bool testResult = false;
351 std::string testUri("dataability://test/path");
352 std::string testMode("RW");
353 int testRet = 123;
354
__anona0aac8190d02(const Uri& uri, const std::string& mode) 355 auto mockHandler = [&](const Uri& uri, const std::string& mode) {
356 testResult = (mode == testMode);
357 sem.Post();
358 return testRet;
359 };
360
361 EXPECT_CALL(*stub, OpenFile(_, _)).Times(1).WillOnce(Invoke(mockHandler));
362
363 auto result = proxy->OpenFile(Uri(testUri), testMode);
364
365 sem.Wait();
366
367 EXPECT_TRUE(testResult);
368 EXPECT_EQ(result, testRet);
369 }
370 }
371
372 /*
373 * Feature: AAFwk
374 * Function: AbilityScheduler
375 * SubFunction: IPC of AMS and App
376 * FunctionPoints: Insert
377 * EnvConditions: NA
378 * CaseDescription: verify Insert IPC between AMS and AppFwk.
379 */
380 HWTEST_F(IpcAbilitySchedulerModuleTest, Insert_001, TestSize.Level1)
381 {
382 Semaphore sem(0);
383
384 for (int i = 0; i < COUNT; i++) {
385 sptr<MockAbilitySchedulerStub> stub(new MockAbilitySchedulerStub());
386 sptr<IAbilityScheduler> proxy = iface_cast<IAbilityScheduler>(stub);
387
388 bool testResult = false;
389 std::string testUri("dataability://test/path");
390 NativeRdb::ValuesBucket testValues;
391 int testRet = 123;
392
__anona0aac8190e02(const Uri& uri, const NativeRdb::ValuesBucket& vb) 393 auto mockHandler = [&](const Uri& uri, const NativeRdb::ValuesBucket& vb) {
394 testResult = true;
395 sem.Post();
396 return testRet;
397 };
398
399 EXPECT_CALL(*stub, Insert(_, _)).Times(1).WillOnce(Invoke(mockHandler));
400
401 auto result = proxy->Insert(Uri(testUri), testValues);
402
403 sem.Wait();
404
405 EXPECT_TRUE(testResult);
406 EXPECT_EQ(result, testRet);
407 }
408 }
409
410 /*
411 * Feature: AAFwk
412 * Function: AbilityScheduler
413 * SubFunction: IPC of AMS and App
414 * FunctionPoints: Update
415 * EnvConditions: NA
416 * CaseDescription: verify Update IPC between AMS and AppFwk.
417 */
418 HWTEST_F(IpcAbilitySchedulerModuleTest, Update_001, TestSize.Level1)
419 {
420 Semaphore sem(0);
421
422 for (int i = 0; i < COUNT; i++) {
423 sptr<MockAbilitySchedulerStub> stub(new MockAbilitySchedulerStub());
424 sptr<IAbilityScheduler> proxy = iface_cast<IAbilityScheduler>(stub);
425
426 bool testResult = false;
427 std::string testUri("dataability://test/path");
428 NativeRdb::ValuesBucket testValues;
429 NativeRdb::DataAbilityPredicates testPred;
430 int testRet = 123;
431
432 auto mockHandler = [&](const Uri& uri, const NativeRdb::ValuesBucket& vb,
__anona0aac8190f02(const Uri& uri, const NativeRdb::ValuesBucket& vb, const NativeRdb::DataAbilityPredicates& pred) 433 const NativeRdb::DataAbilityPredicates& pred) {
434 testResult = true;
435 sem.Post();
436 return testRet;
437 };
438
439 EXPECT_CALL(*stub, Update(_, _, _)).Times(1).WillOnce(Invoke(mockHandler));
440
441 auto result = proxy->Update(Uri(testUri), testValues, testPred);
442
443 sem.Wait();
444
445 EXPECT_TRUE(testResult);
446 EXPECT_EQ(result, testRet);
447 }
448 }
449
450 /*
451 * Feature: AAFwk
452 * Function: AbilityScheduler
453 * SubFunction: IPC of AMS and App
454 * FunctionPoints: Delete
455 * EnvConditions: NA
456 * CaseDescription: verify Delete IPC between AMS and AppFwk.
457 */
458 HWTEST_F(IpcAbilitySchedulerModuleTest, Delete_001, TestSize.Level1)
459 {
460 Semaphore sem(0);
461
462 for (int i = 0; i < COUNT; i++) {
463 sptr<MockAbilitySchedulerStub> stub(new MockAbilitySchedulerStub());
464 sptr<IAbilityScheduler> proxy = iface_cast<IAbilityScheduler>(stub);
465
466 bool testResult = false;
467 std::string testUri("dataability://test/path");
468 NativeRdb::DataAbilityPredicates testPred;
469 int testRet = 123;
470
__anona0aac8191002(const Uri& uri, const NativeRdb::DataAbilityPredicates& pred) 471 auto mockHandler = [&](const Uri& uri, const NativeRdb::DataAbilityPredicates& pred) {
472 testResult = true;
473 sem.Post();
474 return testRet;
475 };
476
477 EXPECT_CALL(*stub, Delete(_, _)).Times(1).WillOnce(Invoke(mockHandler));
478
479 auto result = proxy->Delete(Uri(testUri), testPred);
480
481 sem.Wait();
482
483 EXPECT_TRUE(testResult);
484 EXPECT_EQ(result, testRet);
485 }
486 }
487
488 /*
489 * Feature: AAFwk
490 * Function: AbilityScheduler
491 * SubFunction: IPC of AMS and App
492 * FunctionPoints: Query
493 * EnvConditions: NA
494 * CaseDescription: verify Query IPC between AMS and AppFwk.
495 */
496 HWTEST_F(IpcAbilitySchedulerModuleTest, Query_001, TestSize.Level1)
497 {
498 Semaphore sem(0);
499
500 for (int i = 0; i < COUNT; i++) {
501 sptr<MockAbilitySchedulerStub> stub(new MockAbilitySchedulerStub());
502 sptr<IAbilityScheduler> proxy = iface_cast<IAbilityScheduler>(stub);
503
504 bool testResult = false;
505 std::string testUri("dataability://test/path");
506 std::vector<std::string> testColumns;
507 testColumns.emplace_back("col1");
508 testColumns.emplace_back("col2");
509 NativeRdb::DataAbilityPredicates testPred;
510
511 auto mockHandler = [&sem, &testResult, testColumns](const Uri& uri, const std::vector<std::string>& columns,
__anona0aac8191102(const Uri& uri, const std::vector<std::string>& columns, const NativeRdb::DataAbilityPredicates& pred) 512 const NativeRdb::DataAbilityPredicates& pred) {
513 testResult = (columns == testColumns);
514 sem.Post();
515 return std::make_shared<NativeRdb::AbsSharedResultSet>("DataAbilityTest");
516 };
517
518 EXPECT_CALL(*stub, Query(_, _, _)).Times(1).WillOnce(Invoke(mockHandler));
519
520 auto result = proxy->Query(Uri(testUri), testColumns, testPred);
521
522 sem.Wait();
523
524 EXPECT_TRUE(testResult);
525 EXPECT_TRUE(result);
526 }
527 }
528
529 /*
530 * Feature: AAFwk
531 * Function: AbilityScheduler
532 * SubFunction: IPC of Aafwk and AppExecFwk
533 * FunctionPoints: ScheduleCommandAbility
534 * EnvConditions: NA
535 * CaseDescription: verify ScheduleCommandAbility IPC between Aafwk and AppExecFwk.
536 */
537 HWTEST_F(IpcAbilitySchedulerModuleTest, ScheduleCommandAbility_001, TestSize.Level1)
538 {
539 Semaphore sem(0);
540 struct {
541 Want want;
542 } proxyState, stubState;
543
544 proxyState.want.SetAction("test");
545 static int count = 0;
546 for (int i = 0; i < COUNT; i++) {
547 sptr<MockAbilitySchedulerStub> stub(new MockAbilitySchedulerStub());
548 sptr<AbilitySchedulerProxy> proxy(new AbilitySchedulerProxy(stub));
549
550 Want::ClearWant(&stubState.want);
__anona0aac8191302(const Want& want, bool reStart, int startId) 551 auto stubHandler = [&](const Want& want, bool reStart, int startId) {
552 stubState.want.SetAction(want.GetAction());
553 count++;
554 sem.Post();
555 };
556 EXPECT_CALL(*stub, ScheduleCommandAbility(_, _, _)).Times(1).WillOnce(Invoke(stubHandler));
557 proxy->ScheduleCommandAbility(proxyState.want, false, i + 1);
558 sem.Wait();
559 }
560
561 bool testResult = (count == COUNT);
562 EXPECT_TRUE(testResult);
563 }
564