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 "app_process_data.h"
18 #include "lifecycle_deal.h"
19 #include "ability_scheduler_mock.h"
20
21 using namespace testing::ext;
22
23 namespace OHOS {
24 namespace AAFwk {
25 class LifecycleDealTest : public testing::Test {
26 public:
27 static void SetUpTestCase(void);
28 static void TearDownTestCase(void);
29 void SetUp();
30 void TearDown();
31
32 std::shared_ptr<LifecycleDeal> lifecycleDeal_ {nullptr};
33 sptr<AbilitySchedulerMock> abilityScheduler_ {nullptr};
34 };
35
SetUpTestCase(void)36 void LifecycleDealTest::SetUpTestCase(void)
37 {}
TearDownTestCase(void)38 void LifecycleDealTest::TearDownTestCase(void)
39 {}
TearDown()40 void LifecycleDealTest::TearDown()
41 {}
42
SetUp()43 void LifecycleDealTest::SetUp()
44 {
45 lifecycleDeal_ = std::make_shared<LifecycleDeal>();
46 abilityScheduler_ = new AbilitySchedulerMock();
47 }
48
49 /*
50 * Feature: LifecycleDeal
51 * Function: Activate
52 * SubFunction: NA
53 * FunctionPoints: LifecycleDeal Activate
54 * EnvConditions:NA
55 * CaseDescription: Verify activate operation and call mock once
56 */
57 HWTEST_F(LifecycleDealTest, LifecycleDeal_oprator_001, TestSize.Level1)
58 {
59 LifeCycleStateInfo val;
60 EXPECT_CALL(*abilityScheduler_, ScheduleAbilityTransaction(::testing::_, ::testing::_))
61 .Times(1)
62 .WillOnce(testing::SaveArg<1>(&val));
63
64 const Want want;
65 CallerInfo caller;
66 caller.deviceId = "device";
67 caller.bundleName = "bundle";
68 caller.abilityName = "LifecycleDealTest";
69
70 LifeCycleStateInfo info;
71 info.caller = caller;
72 lifecycleDeal_->Activate(want, info);
73 lifecycleDeal_->SetScheduler(abilityScheduler_);
74 lifecycleDeal_->Activate(want, info);
75
76 EXPECT_EQ(val.caller.deviceId, caller.deviceId);
77 EXPECT_EQ(val.caller.bundleName, caller.bundleName);
78 EXPECT_EQ(val.caller.abilityName, caller.abilityName);
79 }
80
81 /*
82 * Feature: LifecycleDeal
83 * Function: Inactivate
84 * SubFunction: NA
85 * FunctionPoints: LifecycleDeal Inactivate
86 * EnvConditions:NA
87 * CaseDescription: Verify Inactivate operation and call mock once
88 */
89 HWTEST_F(LifecycleDealTest, LifecycleDeal_oprator_002, TestSize.Level1)
90 {
91 LifeCycleStateInfo val;
92 EXPECT_CALL(*abilityScheduler_, ScheduleAbilityTransaction(::testing::_, ::testing::_))
93 .Times(1)
94 .WillOnce(testing::SaveArg<1>(&val));
95
96 const Want want;
97 CallerInfo caller;
98 caller.deviceId = "device";
99 caller.bundleName = "bundle";
100 caller.abilityName = "LifecycleDealTest";
101
102 LifeCycleStateInfo info;
103 info.caller = caller;
104 lifecycleDeal_->Inactivate(want, info);
105 lifecycleDeal_->SetScheduler(abilityScheduler_);
106 lifecycleDeal_->Inactivate(want, info);
107
108 EXPECT_EQ(val.caller.deviceId, caller.deviceId);
109 EXPECT_EQ(val.caller.bundleName, caller.bundleName);
110 EXPECT_EQ(val.caller.abilityName, caller.abilityName);
111 }
112
113 /*
114 * Feature: LifecycleDeal
115 * Function: MoveToBackground
116 * SubFunction: NA
117 * FunctionPoints: LifecycleDeal MoveToBackground
118 * EnvConditions:NA
119 * CaseDescription: Verify MoveToBackground operation and call mock once
120 */
121 HWTEST_F(LifecycleDealTest, LifecycleDeal_oprator_003, TestSize.Level1)
122 {
123 LifeCycleStateInfo val;
124 EXPECT_CALL(*abilityScheduler_, ScheduleAbilityTransaction(::testing::_, ::testing::_))
125 .Times(1)
126 .WillOnce(testing::SaveArg<1>(&val));
127
128 const Want want;
129 CallerInfo caller;
130 caller.deviceId = "device";
131 caller.bundleName = "bundle";
132 caller.abilityName = "LifecycleDealTest";
133
134 LifeCycleStateInfo info;
135 info.caller = caller;
136 lifecycleDeal_->MoveToBackground(want, info);
137 lifecycleDeal_->SetScheduler(abilityScheduler_);
138 lifecycleDeal_->MoveToBackground(want, info);
139
140 EXPECT_EQ(val.caller.deviceId, caller.deviceId);
141 EXPECT_EQ(val.caller.bundleName, caller.bundleName);
142 EXPECT_EQ(val.caller.abilityName, caller.abilityName);
143 }
144
145 /*
146 * Feature: LifecycleDeal
147 * Function: ConnectAbility
148 * SubFunction: NA
149 * FunctionPoints: LifecycleDeal ConnectAbility
150 * EnvConditions:NA
151 * CaseDescription: Verify ConnectAbility operation and call mock once
152 */
153 HWTEST_F(LifecycleDealTest, LifecycleDeal_oprator_004, TestSize.Level1)
154 {
155 EXPECT_CALL(*abilityScheduler_, ScheduleConnectAbility(::testing::_)).Times(1);
156 const Want want;
157 lifecycleDeal_->ConnectAbility(want);
158 lifecycleDeal_->SetScheduler(abilityScheduler_);
159 lifecycleDeal_->ConnectAbility(want);
160 }
161
162 /*
163 * Feature: LifecycleDeal
164 * Function: DisconnectAbility
165 * SubFunction: NA
166 * FunctionPoints: LifecycleDeal DisconnectAbility
167 * EnvConditions:NA
168 * CaseDescription: Verify DisconnectAbility operation and call mock once
169 */
170 HWTEST_F(LifecycleDealTest, LifecycleDeal_oprator_005, TestSize.Level1)
171 {
172 EXPECT_CALL(*abilityScheduler_, ScheduleDisconnectAbility(::testing::_)).Times(1);
173
174 const Want want;
175 lifecycleDeal_->DisconnectAbility(want);
176 lifecycleDeal_->SetScheduler(abilityScheduler_);
177 lifecycleDeal_->DisconnectAbility(want);
178 }
179
180 /*
181 * Feature: LifecycleDeal
182 * Function: Terminate
183 * SubFunction: NA
184 * FunctionPoints: LifecycleDeal Terminate
185 * EnvConditions:NA
186 * CaseDescription: Verify Terminate operation and call mock once
187 */
188 HWTEST_F(LifecycleDealTest, LifecycleDeal_oprator_006, TestSize.Level1)
189 {
190 EXPECT_CALL(*abilityScheduler_, ScheduleAbilityTransaction(::testing::_, ::testing::_)).Times(1);
191
192 const Want want;
193 CallerInfo caller;
194 caller.deviceId = "device";
195 caller.bundleName = "bundle";
196 caller.abilityName = "LifecycleDealTest";
197
198 LifeCycleStateInfo info;
199 info.caller = caller;
200 lifecycleDeal_->Activate(want, info);
201 lifecycleDeal_->SetScheduler(abilityScheduler_);
202 lifecycleDeal_->Activate(want, info);
203 }
204
205 /*
206 * Feature: LifecycleDeal
207 * Function: CommandAbility
208 * SubFunction: NA
209 * FunctionPoints: LifecycleDeal CommandAbility
210 * EnvConditions:NA
211 * CaseDescription: Verify CommandAbility operation and call mock once
212 */
213 HWTEST_F(LifecycleDealTest, LifecycleDeal_oprator_007, TestSize.Level1)
214 {
215 EXPECT_CALL(*abilityScheduler_, ScheduleCommandAbility(::testing::_, ::testing::_, ::testing::_)).Times(1);
216 const Want want;
217 LifeCycleStateInfo info;
218 lifecycleDeal_->CommandAbility(want, false, 1);
219 lifecycleDeal_->SetScheduler(abilityScheduler_);
220 lifecycleDeal_->CommandAbility(want, false, 1);
221 }
222 } // namespace AAFwk
223 } // namespace OHOS
224