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