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