1 /*
2 * Copyright (c) 2021-2025 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 "ability_schedule_stub_mock.h"
18
19 using namespace testing::ext;
20
21 namespace OHOS {
22 namespace AAFwk {
23 class AbilitySchedulerStubTest : public testing::Test {
24 public:
25 static void SetUpTestCase(void);
26 static void TearDownTestCase(void);
27 void SetUp();
28 void TearDown();
29 void WriteInterfaceToken(MessageParcel& data);
30 sptr<AbilitySchedulerStubMock> stub_{ nullptr };
31 };
32
SetUpTestCase(void)33 void AbilitySchedulerStubTest::SetUpTestCase(void)
34 {}
TearDownTestCase(void)35 void AbilitySchedulerStubTest::TearDownTestCase(void)
36 {}
TearDown(void)37 void AbilitySchedulerStubTest::TearDown(void)
38 {}
39
SetUp(void)40 void AbilitySchedulerStubTest::SetUp(void)
41 {
42 stub_ = new AbilitySchedulerStubMock();
43 }
WriteInterfaceToken(MessageParcel & data)44 void AbilitySchedulerStubTest::WriteInterfaceToken(MessageParcel& data)
45 {
46 data.WriteInterfaceToken(AbilitySchedulerStub::GetDescriptor());
47 }
48
49 /*
50 * Feature: AbilitySchedulerStub
51 * Function: OnRemoteRequest
52 * SubFunction: NA
53 * FunctionPoints: AbilitySchedulerStub OnRemoteRequest
54 * EnvConditions: code is SCHEDULE_ABILITY_TRANSACTION
55 * CaseDescription: Verify the normal process of onremoterequest
56 */
57 HWTEST_F(AbilitySchedulerStubTest, AbilitySchedulerStub_001, TestSize.Level1)
58 {
59 MessageParcel data;
60 MessageParcel reply;
61 MessageOption option;
62
63 Want want;
64 LifeCycleStateInfo stateInfo;
65 WriteInterfaceToken(data);
66 data.WriteParcelable(&want);
67 data.WriteParcelable(&stateInfo);
68 auto res = stub_->OnRemoteRequest(IAbilityScheduler::SCHEDULE_ABILITY_TRANSACTION, data, reply, option);
69 EXPECT_EQ(res, NO_ERROR);
70 }
71
72 /*
73 * Feature: AbilitySchedulerStub
74 * Function: OnRemoteRequest
75 * SubFunction: NA
76 * FunctionPoints: AbilitySchedulerStub OnRemoteRequest
77 * EnvConditions: code is SCHEDULE_ABILITY_TRANSACTION
78 * CaseDescription: Verifying stateinfo is nullptr causes onremoterequest to fail
79 */
80 HWTEST_F(AbilitySchedulerStubTest, AbilitySchedulerStub_002, TestSize.Level1)
81 {
82 MessageParcel data;
83 MessageParcel reply;
84 MessageOption option;
85
86 Want want;
87 WriteInterfaceToken(data);
88 data.WriteParcelable(&want);
89 data.WriteParcelable(nullptr);
90 auto res = stub_->OnRemoteRequest(IAbilityScheduler::SCHEDULE_ABILITY_TRANSACTION, data, reply, option);
91 EXPECT_NE(res, NO_ERROR);
92 }
93
94 /*
95 * Feature: AbilitySchedulerStub
96 * Function: OnRemoteRequest
97 * SubFunction: NA
98 * FunctionPoints: AbilitySchedulerStub OnRemoteRequest
99 * EnvConditions: code is SEND_RESULT
100 * CaseDescription: Verify the normal process of onremoterequest
101 */
102 HWTEST_F(AbilitySchedulerStubTest, AbilitySchedulerStub_003, TestSize.Level1)
103 {
104 MessageParcel data;
105 MessageParcel reply;
106 MessageOption option;
107
108 Want want;
109 WriteInterfaceToken(data);
110 data.WriteInt32(1);
111 data.WriteInt32(1);
112 data.WriteParcelable(&want);
113
114 auto res = stub_->OnRemoteRequest(IAbilityScheduler::SEND_RESULT, data, reply, option);
115 EXPECT_EQ(res, NO_ERROR);
116 }
117
118 /*
119 * Feature: AbilitySchedulerStub
120 * Function: OnRemoteRequest
121 * SubFunction: NA
122 * FunctionPoints: AbilitySchedulerStub OnRemoteRequest
123 * EnvConditions: code is SEND_RESULT
124 * CaseDescription: Verifying want is nullptr causes onremoterequest to fail
125 */
126 HWTEST_F(AbilitySchedulerStubTest, AbilitySchedulerStub_004, TestSize.Level1)
127 {
128 MessageParcel data;
129 MessageParcel reply;
130 MessageOption option;
131 WriteInterfaceToken(data);
132 data.WriteInt32(1);
133 data.WriteParcelable(nullptr);
134
135 auto res = stub_->OnRemoteRequest(IAbilityScheduler::SEND_RESULT, data, reply, option);
136 EXPECT_NE(res, NO_ERROR);
137 }
138
139 /*
140 * Feature: AbilitySchedulerStub
141 * Function: OnRemoteRequest
142 * SubFunction: NA
143 * FunctionPoints: AbilitySchedulerStub OnRemoteRequest
144 * EnvConditions: code is SCHEDULE_ABILITY_CONNECT
145 * CaseDescription: Verify the normal and failed conditions of onremoterequest
146 */
147 HWTEST_F(AbilitySchedulerStubTest, AbilitySchedulerStub_005, TestSize.Level1)
148 {
149 MessageParcel data;
150 MessageParcel reply;
151 MessageOption option;
152
153 WriteInterfaceToken(data);
154 data.WriteParcelable(nullptr);
155
156 auto res = stub_->OnRemoteRequest(IAbilityScheduler::SCHEDULE_ABILITY_CONNECT, data, reply, option);
157 EXPECT_NE(res, NO_ERROR);
158
159 Want want;
160 WriteInterfaceToken(data);
161 data.WriteParcelable(&want);
162 auto res1 = stub_->OnRemoteRequest(IAbilityScheduler::SCHEDULE_ABILITY_CONNECT, data, reply, option);
163 EXPECT_EQ(res1, NO_ERROR);
164 }
165
166 /*
167 * Feature: AbilitySchedulerStub
168 * Function: OnRemoteRequest
169 * SubFunction: NA
170 * FunctionPoints: AbilitySchedulerStub OnRemoteRequest
171 * EnvConditions: code is SCHEDULE_ABILITY_DISCONNECT
172 * CaseDescription: Verify the normal conditions of onremoterequest
173 */
174 HWTEST_F(AbilitySchedulerStubTest, AbilitySchedulerStub_006, TestSize.Level1)
175 {
176 MessageParcel data;
177 MessageParcel reply;
178 MessageOption option;
179 WriteInterfaceToken(data);
180 auto res = stub_->OnRemoteRequest(IAbilityScheduler::SCHEDULE_ABILITY_DISCONNECT, data, reply, option);
181 EXPECT_EQ(res, ERR_INVALID_VALUE);
182 }
183
184 /*
185 * Feature: AbilitySchedulerStub
186 * Function: OnRemoteRequest
187 * SubFunction: NA
188 * FunctionPoints: AbilitySchedulerStub OnRemoteRequest
189 * EnvConditions: code is SCHEDULE_SAVE_ABILITY_STATE
190 * CaseDescription: Verify the failed conditions of onremoterequest
191 */
192 HWTEST_F(AbilitySchedulerStubTest, AbilitySchedulerStub_007, TestSize.Level1)
193 {
194 MessageParcel data;
195 MessageParcel reply;
196 MessageOption option;
197 WriteInterfaceToken(data);
198 auto res = stub_->OnRemoteRequest(IAbilityScheduler::SCHEDULE_SAVE_ABILITY_STATE, data, reply, option);
199 EXPECT_EQ(res, NO_ERROR);
200 }
201
202 /*
203 * Feature: AbilitySchedulerStub
204 * Function: OnRemoteRequest
205 * SubFunction: NA
206 * FunctionPoints: AbilitySchedulerStub OnRemoteRequest
207 * EnvConditions: code is default
208 * CaseDescription: Verify the normal conditions of onremoterequest
209 */
210 HWTEST_F(AbilitySchedulerStubTest, AbilitySchedulerStub_008, TestSize.Level1)
211 {
212 MessageParcel data;
213 MessageParcel reply;
214 MessageOption option;
215 WriteInterfaceToken(data);
216 auto res = stub_->OnRemoteRequest(INT_MAX, data, reply, option);
217 EXPECT_NE(res, NO_ERROR);
218 }
219
220 /**
221 * @tc.name: AbilitySchedulerStub_009
222 * @tc.desc: test NotifyContinuationResult
223 * @tc.type: FUNC
224 * @tc.require: AR000GI8IJ
225 */
226 HWTEST_F(AbilitySchedulerStubTest, AbilitySchedulerStub_009, TestSize.Level2)
227 {
228 MessageParcel data;
229 MessageParcel reply;
230 MessageOption option;
231 WriteInterfaceToken(data);
232 int32_t result = 0;
233 data.WriteInt32(result);
234 auto res = stub_->OnRemoteRequest(IAbilityScheduler::NOTIFY_CONTINUATION_RESULT, data, reply, option);
235 EXPECT_EQ(res, NO_ERROR);
236 }
237
238 /**
239 * @tc.name: AbilitySchedulerStub_0010
240 * @tc.desc: test NotifyContinuationResult
241 * @tc.type: FUNC
242 * @tc.require:
243 */
244 HWTEST_F(AbilitySchedulerStubTest, AbilitySchedulerStub_0010, TestSize.Level2)
245 {
246 MessageParcel data;
247 MessageParcel reply;
248 MessageOption option;
249 WriteInterfaceToken(data);
250 int32_t result = 0;
251 data.WriteInt32(result);
252 auto res = stub_->OnRemoteRequest(IAbilityScheduler::REQUEST_CALL_REMOTE, data, reply, option);
253 EXPECT_EQ(res, NO_ERROR);
254 }
255
256 /**
257 * @tc.name: AbilitySchedulerStub_011
258 * @tc.desc: test DumpAbilityInfo
259 * @tc.type: FUNC
260 * @tc.require: SR000GH1GO
261 */
262 HWTEST_F(AbilitySchedulerStubTest, AbilitySchedulerStub_011, TestSize.Level1)
263 {
264 MessageParcel data;
265 MessageParcel reply;
266 MessageOption option;
267 WriteInterfaceToken(data);
268 int32_t result = 0;
269 data.WriteInt32(result);
270 auto res = stub_->OnRemoteRequest(IAbilityScheduler::DUMP_ABILITY_RUNNER_INNER, data, reply, option);
271 EXPECT_EQ(res, NO_ERROR);
272 }
273
274 /**
275 * @tc.name: ScheduleAbilityRequestFailureInner_001
276 * @tc.desc: test ScheduleAbilityRequestFailureInner
277 * @tc.type: FUNC
278 * @tc.require: SR000GH1GO
279 */
280 HWTEST_F(AbilitySchedulerStubTest, ScheduleAbilityRequestFailureInner_001, TestSize.Level1)
281 {
282 MessageParcel data;
283 MessageParcel reply;
284 MessageOption option;
285 WriteInterfaceToken(data);
286 std::string requestId = "1234567890";
287 data.WriteString(requestId);
288 AppExecFwk::ElementName element("", "com.example.com", "MainAbility");
289 data.WriteParcelable(&element);
290 std::string message = "failure";
291 data.WriteString(message);
292 auto res = stub_->OnRemoteRequest(IAbilityScheduler::SCHEDULE_ABILITY_REQUEST_FAILURE, data, reply, option);
293 EXPECT_EQ(res, NO_ERROR);
294 }
295
296 /**
297 * @tc.name: ScheduleAbilityRequestSuccessInner_001
298 * @tc.desc: test ScheduleAbilityRequestSuccessInner
299 * @tc.type: FUNC
300 * @tc.require: SR000GH1GO
301 */
302 HWTEST_F(AbilitySchedulerStubTest, ScheduleAbilityRequestSuccessInner_001, TestSize.Level1)
303 {
304 MessageParcel data;
305 MessageParcel reply;
306 MessageOption option;
307 WriteInterfaceToken(data);
308 std::string requestId = "1234567890";
309 data.WriteString(requestId);
310 AppExecFwk::ElementName element("", "com.example.com", "MainAbility");
311 data.WriteParcelable(&element);
312 auto res = stub_->OnRemoteRequest(IAbilityScheduler::SCHEDULE_ABILITY_REQUEST_SUCCESS, data, reply, option);
313 EXPECT_EQ(res, NO_ERROR);
314 }
315
316 /**
317 * @tc.name: ScheduleAbilitiesRequestDoneInner_001
318 * @tc.desc: test ScheduleAbilitiesRequestDoneInner
319 * @tc.type: FUNC
320 * @tc.require: SR000GH1GO
321 */
322 HWTEST_F(AbilitySchedulerStubTest, ScheduleAbilitiesRequestDoneInner_001, TestSize.Level1)
323 {
324 MessageParcel data;
325 MessageParcel reply;
326 MessageOption option;
327 WriteInterfaceToken(data);
328 std::string requestKey = "12345";
329 data.WriteString(requestKey);
330 int32_t resultCode = 1;
331 data.WriteInt32(resultCode);
332 auto res = stub_->OnRemoteRequest(IAbilityScheduler::SCHEDULE_ABILITIES_REQUEST_DONE, data, reply, option);
333 EXPECT_EQ(res, NO_ERROR);
334 }
335 } // namespace AAFwk
336 } // namespace OHOS
337