1 /*
2 * Copyright (C) 2023 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 #define private public
17 #define protected public
18 #include "cellular_call_config.h"
19 #include "cellular_call_handler.h"
20 #include "cellular_call_proxy.h"
21 #include "cellular_call_register.h"
22 #include "cellular_call_service.h"
23 #include "tel_ril_call_parcel.h"
24 #include "ims_call_callback_proxy.h"
25 #include "ims_call_callback_stub.h"
26 #include "ims_call_client.h"
27 #include "ims_control.h"
28 #include "ims_error.h"
29 #include "core_service_client.h"
30 #include "gtest/gtest.h"
31 #include "ims_core_service_client.h"
32 #include "token.h"
33 #include "securec.h"
34
35 namespace OHOS {
36 namespace Telephony {
37 using namespace testing::ext;
38 const int32_t SLOT_COUNT = 2;
39 const std::string PHONE_NUMBER = "0000000";
40 const int32_t DEFAULT_INDEX = 1;
41
42 class ImsCallbackStubTest : public testing::Test {
43 public:
44 static void SetUpTestCase();
45 static void TearDownTestCase();
46 void SetUp();
47 void TearDown();
48
HasSimCard(int32_t slotId)49 bool HasSimCard(int32_t slotId)
50 {
51 bool hasSimCard = false;
52 DelayedRefSingleton<CoreServiceClient>::GetInstance().HasSimCard(slotId, hasSimCard);
53 return hasSimCard;
54 }
55
WriteSsBaseResult(MessageParcel & in,const SsBaseResult & ssResult)56 int32_t WriteSsBaseResult(MessageParcel &in, const SsBaseResult &ssResult)
57 {
58 if (!in.WriteInt32(ssResult.index)) {
59 return TELEPHONY_ERR_WRITE_DATA_FAIL;
60 }
61 if (!in.WriteInt32(ssResult.result)) {
62 return TELEPHONY_ERR_WRITE_DATA_FAIL;
63 }
64 if (!in.WriteInt32(ssResult.reason)) {
65 return TELEPHONY_ERR_WRITE_DATA_FAIL;
66 }
67 if (!in.WriteString(ssResult.message)) {
68 return TELEPHONY_ERR_WRITE_DATA_FAIL;
69 }
70 return TELEPHONY_SUCCESS;
71 };
72
WriteSsResult(MessageParcel & in,const SsBaseResult & ssResult,const int32_t action,const int32_t state)73 int32_t WriteSsResult(MessageParcel &in, const SsBaseResult &ssResult, const int32_t action, const int32_t state)
74 {
75 int32_t ret = WriteSsBaseResult(in, ssResult);
76 if (ret != TELEPHONY_SUCCESS) {
77 return ret;
78 }
79 if (!in.WriteInt32(action)) {
80 return TELEPHONY_ERR_WRITE_DATA_FAIL;
81 }
82 if (!in.WriteInt32(state)) {
83 return TELEPHONY_ERR_WRITE_DATA_FAIL;
84 }
85 return TELEPHONY_SUCCESS;
86 };
87
WriteCallForwardResult(MessageParcel & in,const CallForwardQueryInfoList & cFQueryList)88 int32_t WriteCallForwardResult(MessageParcel &in, const CallForwardQueryInfoList &cFQueryList)
89 {
90 int32_t ret = WriteSsBaseResult(in, cFQueryList.result);
91 if (ret != TELEPHONY_SUCCESS) {
92 return ret;
93 }
94 if (!in.WriteInt32(cFQueryList.callSize) || !in.WriteInt32(cFQueryList.flag)) {
95 return TELEPHONY_ERR_WRITE_DATA_FAIL;
96 }
97 if (!in.WriteInt32(static_cast<int32_t>(cFQueryList.calls.size()))) {
98 return TELEPHONY_ERR_WRITE_DATA_FAIL;
99 }
100 for (auto call : cFQueryList.calls) {
101 if (!in.WriteInt32(call.serial) || !in.WriteInt32(call.result) || !in.WriteInt32(call.status) ||
102 !in.WriteInt32(call.classx) || !in.WriteString(call.number) || !in.WriteInt32(call.type) ||
103 !in.WriteInt32(call.reason) || !in.WriteInt32(call.time) || !in.WriteInt32(call.startHour) ||
104 !in.WriteInt32(call.startMinute) || !in.WriteInt32(call.endHour) || !in.WriteInt32(call.endMinute)) {
105 return TELEPHONY_ERR_WRITE_DATA_FAIL;
106 }
107 }
108 return TELEPHONY_SUCCESS;
109 }
110 };
111
SetUpTestCase(void)112 void ImsCallbackStubTest::SetUpTestCase(void)
113 {
114 // step 3: Set Up Test Case
115 }
116
TearDownTestCase(void)117 void ImsCallbackStubTest::TearDownTestCase(void)
118 {
119 // step 3: Tear Down Test Case
120 }
121
SetUp(void)122 void ImsCallbackStubTest::SetUp(void) {}
123
TearDown(void)124 void ImsCallbackStubTest::TearDown(void)
125 {
126 // step 3: input testcase teardown step
127 }
128
129 /**
130 * @tc.number cellular_call_ImsCallCallbackStub_0001
131 * @tc.name Test for ImsCallCallbackStub
132 * @tc.desc Function test
133 */
134 HWTEST_F(ImsCallbackStubTest, cellular_call_ImsCallCallbackStub_0001, Function | MediumTest | Level3)
135 {
136 sptr<ImsCallCallbackStub> stub = (std::make_unique<ImsCallCallbackStub>()).release();
137 ASSERT_TRUE(stub != nullptr);
138 for (int32_t slotId = 0; slotId < SIM_SLOT_COUNT; slotId++) {
139 if (!HasSimCard(slotId)) {
140 continue;
141 }
142 RadioResponseInfo rilRadioResponse;
143 rilRadioResponse.error = ErrType::ERR_GENERIC_FAILURE;
144 MessageParcel answerData;
145 MessageParcel answerReply;
146 ASSERT_TRUE(answerData.WriteInt32(slotId));
147 ASSERT_TRUE(answerData.WriteRawData((const void *)&rilRadioResponse, sizeof(RadioResponseInfo)));
148 ASSERT_EQ(stub->OnAnswerResponseInner(answerData, answerReply), TELEPHONY_SUCCESS);
149
150 MessageParcel dialData;
151 MessageParcel dialReply;
152 ASSERT_TRUE(dialData.WriteInt32(slotId));
153 ASSERT_TRUE(dialData.WriteRawData((const void *)&rilRadioResponse, sizeof(RadioResponseInfo)));
154 ASSERT_EQ(stub->OnDialResponseInner(dialData, dialReply), TELEPHONY_SUCCESS);
155
156 MessageParcel imsCallsData;
157 MessageParcel imsCallsReply;
158 ASSERT_TRUE(imsCallsData.WriteInt32(slotId));
159 ASSERT_TRUE(imsCallsData.WriteRawData((const void *)&rilRadioResponse, sizeof(RadioResponseInfo)));
160 ASSERT_EQ(stub->OnGetImsCallsDataResponseInner(imsCallsData, imsCallsReply), TELEPHONY_SUCCESS);
161
162 MessageParcel hangupData;
163 MessageParcel hangupReply;
164 ASSERT_TRUE(hangupData.WriteInt32(slotId));
165 ASSERT_TRUE(hangupData.WriteRawData((const void *)&rilRadioResponse, sizeof(RadioResponseInfo)));
166 ASSERT_EQ(stub->OnHangUpResponseInner(hangupData, hangupReply), TELEPHONY_SUCCESS);
167
168 MessageParcel holdCallData;
169 MessageParcel holdCallReply;
170 ASSERT_TRUE(holdCallData.WriteInt32(slotId));
171 ASSERT_TRUE(holdCallData.WriteRawData((const void *)&rilRadioResponse, sizeof(RadioResponseInfo)));
172 ASSERT_EQ(stub->OnHoldCallResponseInner(holdCallData, holdCallReply), TELEPHONY_SUCCESS);
173
174 MessageParcel rejectData;
175 MessageParcel rejectReply;
176 ASSERT_TRUE(rejectData.WriteInt32(slotId));
177 ASSERT_TRUE(rejectData.WriteRawData((const void *)&rilRadioResponse, sizeof(RadioResponseInfo)));
178 ASSERT_EQ(stub->OnRejectResponseInner(rejectData, rejectReply), TELEPHONY_SUCCESS);
179 }
180 }
181
182 /**
183 * @tc.number cellular_call_ImsCallCallbackStub_0002
184 * @tc.name Test for ImsCallCallbackStub
185 * @tc.desc Function test
186 */
187 HWTEST_F(ImsCallbackStubTest, cellular_call_ImsCallCallbackStub_0002, Function | MediumTest | Level3)
188 {
189 sptr<ImsCallCallbackStub> stubTestTwo = (std::make_unique<ImsCallCallbackStub>()).release();
190 ASSERT_TRUE(stubTestTwo != nullptr);
191 for (int32_t slotId = 0; slotId < SIM_SLOT_COUNT; slotId++) {
192 if (!HasSimCard(slotId)) {
193 continue;
194 }
195 RadioResponseInfo rilRadioResponse;
196 rilRadioResponse.error = ErrType::ERR_GENERIC_FAILURE;
197 MessageParcel sendDtmfData;
198 MessageParcel sendDtmfReply;
199 ASSERT_TRUE(sendDtmfData.WriteInt32(slotId));
200 ASSERT_TRUE(sendDtmfData.WriteRawData((const void *)&rilRadioResponse, sizeof(RadioResponseInfo)));
201 ASSERT_GE(stubTestTwo->OnSendDtmfResponseInner(sendDtmfData, sendDtmfReply), TELEPHONY_SUCCESS);
202
203 MessageParcel setImsSwitchData;
204 MessageParcel setImsSwitchReply;
205 ASSERT_TRUE(setImsSwitchData.WriteInt32(slotId));
206 ASSERT_TRUE(setImsSwitchData.WriteRawData((const void *)&rilRadioResponse, sizeof(RadioResponseInfo)));
207 ASSERT_EQ(stubTestTwo->OnSetImsSwitchResponseInner(setImsSwitchData, setImsSwitchReply), TELEPHONY_SUCCESS);
208
209 MessageParcel startDtmfData;
210 MessageParcel startDtmfReply;
211 ASSERT_TRUE(startDtmfData.WriteInt32(slotId));
212 ASSERT_TRUE(startDtmfData.WriteRawData((const void *)&rilRadioResponse, sizeof(RadioResponseInfo)));
213 ASSERT_EQ(stubTestTwo->OnStartDtmfResponseInner(startDtmfData, startDtmfReply), TELEPHONY_SUCCESS);
214
215 MessageParcel stopDtmfData;
216 MessageParcel stopDtmfReply;
217 ASSERT_TRUE(stopDtmfData.WriteInt32(slotId));
218 ASSERT_TRUE(stopDtmfData.WriteRawData((const void *)&rilRadioResponse, sizeof(RadioResponseInfo)));
219 ASSERT_EQ(stubTestTwo->OnStopDtmfResponseInner(stopDtmfData, stopDtmfReply), TELEPHONY_SUCCESS);
220
221 MessageParcel switchCallData;
222 MessageParcel switchCallReply;
223 ASSERT_TRUE(switchCallData.WriteInt32(slotId));
224 ASSERT_TRUE(switchCallData.WriteRawData((const void *)&rilRadioResponse, sizeof(RadioResponseInfo)));
225 ASSERT_EQ(stubTestTwo->OnSwitchCallResponseInner(switchCallData, switchCallReply), TELEPHONY_SUCCESS);
226
227 MessageParcel unholdData;
228 MessageParcel unholdReply;
229 ASSERT_TRUE(unholdData.WriteInt32(slotId));
230 ASSERT_TRUE(unholdData.WriteRawData((const void *)&rilRadioResponse, sizeof(RadioResponseInfo)));
231 ASSERT_EQ(stubTestTwo->OnUnHoldCallResponseInner(unholdData, unholdReply), TELEPHONY_SUCCESS);
232
233 MessageParcel getImsSwitchData;
234 MessageParcel getImsSwitchReply;
235 ASSERT_TRUE(getImsSwitchData.WriteInt32(slotId));
236 ASSERT_TRUE(getImsSwitchData.WriteRawData((const void *)&rilRadioResponse, sizeof(RadioResponseInfo)));
237 ASSERT_EQ(stubTestTwo->OnGetImsSwitchResponseInner(getImsSwitchData, getImsSwitchReply), TELEPHONY_SUCCESS);
238 }
239 }
240
241 /**
242 * @tc.number cellular_call_ImsCallCallbackStub_0003
243 * @tc.name Test for ImsCallCallbackStub
244 * @tc.desc Function test
245 */
246 HWTEST_F(ImsCallbackStubTest, cellular_call_ImsCallCallbackStub_0003, Function | MediumTest | Level3)
247 {
248 sptr<ImsCallCallbackStub> stubTestThree = (std::make_unique<ImsCallCallbackStub>()).release();
249 ASSERT_TRUE(stubTestThree != nullptr);
250 for (int32_t slotId = 0; slotId < SIM_SLOT_COUNT; slotId++) {
251 if (!HasSimCard(slotId)) {
252 continue;
253 }
254 MessageParcel data;
255 MessageParcel reply;
256 ASSERT_TRUE(data.WriteInt32(slotId));
257 ASSERT_NE(stubTestThree->OnAnswerResponseInner(data, reply), TELEPHONY_SUCCESS);
258 ASSERT_NE(stubTestThree->OnCallRingBackReportInner(data, reply), TELEPHONY_SUCCESS);
259 ASSERT_NE(stubTestThree->OnDialResponseInner(data, reply), TELEPHONY_SUCCESS);
260 ASSERT_NE(stubTestThree->OnHangUpResponseInner(data, reply), TELEPHONY_SUCCESS);
261 ASSERT_NE(stubTestThree->OnHoldCallResponseInner(data, reply), TELEPHONY_SUCCESS);
262 ASSERT_NE(stubTestThree->OnRejectResponseInner(data, reply), TELEPHONY_SUCCESS);
263 ASSERT_NE(stubTestThree->OnSendDtmfResponseInner(data, reply), TELEPHONY_SUCCESS);
264 ASSERT_NE(stubTestThree->OnSetImsSwitchResponseInner(data, reply), TELEPHONY_SUCCESS);
265 ASSERT_NE(stubTestThree->OnStartDtmfResponseInner(data, reply), TELEPHONY_SUCCESS);
266 ASSERT_NE(stubTestThree->OnStopDtmfResponseInner(data, reply), TELEPHONY_SUCCESS);
267 ASSERT_NE(stubTestThree->OnSwitchCallResponseInner(data, reply), TELEPHONY_SUCCESS);
268 ASSERT_NE(stubTestThree->OnUnHoldCallResponseInner(data, reply), TELEPHONY_SUCCESS);
269 ASSERT_NE(stubTestThree->OnSetMuteResponseInner(data, reply), TELEPHONY_SUCCESS);
270 ASSERT_NE(stubTestThree->OnCombineConferenceResponseInner(data, reply), TELEPHONY_SUCCESS);
271 ASSERT_NE(stubTestThree->OnInviteToConferenceResponseInner(data, reply), TELEPHONY_SUCCESS);
272 ASSERT_NE(stubTestThree->OnReceiveUpdateCallMediaModeRequestInner(data, reply), TELEPHONY_SUCCESS);
273 ASSERT_NE(stubTestThree->OnReceiveUpdateCallMediaModeResponseInner(data, reply), TELEPHONY_SUCCESS);
274 ASSERT_NE(stubTestThree->OnCallSessionEventChangedInner(data, reply), TELEPHONY_SUCCESS);
275 ASSERT_NE(stubTestThree->OnPeerDimensionsChangedInner(data, reply), TELEPHONY_SUCCESS);
276 ASSERT_NE(stubTestThree->OnCallDataUsageChangedInner(data, reply), TELEPHONY_SUCCESS);
277 ASSERT_NE(stubTestThree->OnCameraCapabilitiesChangedInner(data, reply), TELEPHONY_SUCCESS);
278 ASSERT_EQ(stubTestThree->OnGetImsCapResponseInner(data, reply), TELEPHONY_SUCCESS);
279 }
280 }
281
282 /**
283 * @tc.number cellular_call_ImsCallCallbackStub_0004
284 * @tc.name Test for ImsCallCallbackStub
285 * @tc.desc Function test
286 */
287 HWTEST_F(ImsCallbackStubTest, cellular_call_ImsCallCallbackStub_0004, Function | MediumTest | Level3)
288 {
289 sptr<ImsCallCallbackStub> stubTestFour = (std::make_unique<ImsCallCallbackStub>()).release();
290 ASSERT_TRUE(stubTestFour != nullptr);
291 for (int32_t slotId = 0; slotId < SIM_SLOT_COUNT; slotId++) {
292 if (!HasSimCard(slotId)) {
293 continue;
294 }
295 SsBaseResult normalResult;
296 normalResult.index = DEFAULT_INDEX;
297 MessageParcel crData;
298 MessageParcel crReply;
299 ASSERT_TRUE(crData.WriteInt32(slotId));
300 ASSERT_EQ(WriteSsBaseResult(crData, normalResult), TELEPHONY_SUCCESS);
301 ASSERT_EQ(stubTestFour->OnSetCallRestrictionResponseInner(crData, crReply), TELEPHONY_SUCCESS);
302 MessageParcel ctData;
303 MessageParcel ctReply;
304 ASSERT_TRUE(ctData.WriteInt32(slotId));
305 ASSERT_EQ(WriteSsBaseResult(ctData, normalResult), TELEPHONY_SUCCESS);
306 ASSERT_EQ(stubTestFour->OnSetCallTransferResponseInner(ctData, ctReply), TELEPHONY_SUCCESS);
307 MessageParcel cwData;
308 MessageParcel cwReply;
309 ASSERT_TRUE(cwData.WriteInt32(slotId));
310 ASSERT_EQ(WriteSsBaseResult(cwData, normalResult), TELEPHONY_SUCCESS);
311 ASSERT_EQ(stubTestFour->OnSetCallWaitingResponseInner(cwData, cwReply), TELEPHONY_SUCCESS);
312 MessageParcel clipData;
313 MessageParcel clipReply;
314 ASSERT_TRUE(clipData.WriteInt32(slotId));
315 ASSERT_EQ(WriteSsBaseResult(clipData, normalResult), TELEPHONY_SUCCESS);
316 ASSERT_EQ(stubTestFour->OnSetClipResponseInner(clipData, clipReply), TELEPHONY_SUCCESS);
317 MessageParcel clirData;
318 MessageParcel clirReply;
319 ASSERT_TRUE(clirData.WriteInt32(slotId));
320 ASSERT_EQ(WriteSsBaseResult(clirData, normalResult), TELEPHONY_SUCCESS);
321 ASSERT_EQ(stubTestFour->OnSetClirResponseInner(clirData, clirReply), TELEPHONY_SUCCESS);
322 MessageParcel colpData;
323 MessageParcel colpReply;
324 ASSERT_TRUE(colpData.WriteInt32(slotId));
325 ASSERT_EQ(WriteSsBaseResult(colpData, normalResult), TELEPHONY_SUCCESS);
326 ASSERT_EQ(stubTestFour->OnSetColpResponseInner(colpData, colpReply), TELEPHONY_SUCCESS);
327 MessageParcel colrData;
328 MessageParcel colrReply;
329 ASSERT_TRUE(colrData.WriteInt32(slotId));
330 ASSERT_EQ(WriteSsBaseResult(colrData, normalResult), TELEPHONY_SUCCESS);
331 ASSERT_EQ(stubTestFour->OnSetColrResponseInner(colrData, colrReply), TELEPHONY_SUCCESS);
332 }
333 }
334
335 /**
336 * @tc.number cellular_call_ImsCallCallbackStub_0005
337 * @tc.name Test for ImsCallCallbackStub
338 * @tc.desc Function test
339 */
340 HWTEST_F(ImsCallbackStubTest, cellular_call_ImsCallCallbackStub_0005, Function | MediumTest | Level3)
341 {
342 sptr<ImsCallCallbackStub> stubTestFive = (std::make_unique<ImsCallCallbackStub>()).release();
343 ASSERT_TRUE(stubTestFive != nullptr);
344 for (int32_t slotId = 0; slotId < SIM_SLOT_COUNT; slotId++) {
345 if (!HasSimCard(slotId)) {
346 continue;
347 }
348 SsBaseResult normalResult;
349 normalResult.index = INVALID_INDEX;
350 MessageParcel crData;
351 MessageParcel crReply;
352 ASSERT_TRUE(crData.WriteInt32(slotId));
353 ASSERT_EQ(WriteSsBaseResult(crData, normalResult), TELEPHONY_SUCCESS);
354 ASSERT_EQ(stubTestFive->OnSetCallRestrictionResponseInner(crData, crReply), TELEPHONY_SUCCESS);
355 MessageParcel ctData;
356 MessageParcel ctReply;
357 ASSERT_TRUE(ctData.WriteInt32(slotId));
358 ASSERT_EQ(WriteSsBaseResult(ctData, normalResult), TELEPHONY_SUCCESS);
359 ASSERT_EQ(stubTestFive->OnSetCallTransferResponseInner(ctData, ctReply), TELEPHONY_SUCCESS);
360 MessageParcel cwData;
361 MessageParcel cwReply;
362 ASSERT_TRUE(cwData.WriteInt32(slotId));
363 ASSERT_EQ(WriteSsBaseResult(cwData, normalResult), TELEPHONY_SUCCESS);
364 ASSERT_EQ(stubTestFive->OnSetCallWaitingResponseInner(cwData, cwReply), TELEPHONY_SUCCESS);
365 MessageParcel clipData;
366 MessageParcel clipReply;
367 ASSERT_TRUE(clipData.WriteInt32(slotId));
368 ASSERT_EQ(WriteSsBaseResult(clipData, normalResult), TELEPHONY_SUCCESS);
369 ASSERT_EQ(stubTestFive->OnSetClipResponseInner(clipData, clipReply), TELEPHONY_SUCCESS);
370 MessageParcel clirData;
371 MessageParcel clirReply;
372 ASSERT_TRUE(clirData.WriteInt32(slotId));
373 ASSERT_EQ(WriteSsBaseResult(clirData, normalResult), TELEPHONY_SUCCESS);
374 ASSERT_EQ(stubTestFive->OnSetClirResponseInner(clirData, clirReply), TELEPHONY_SUCCESS);
375 MessageParcel colpData;
376 MessageParcel colpReply;
377 ASSERT_TRUE(colpData.WriteInt32(slotId));
378 ASSERT_EQ(WriteSsBaseResult(colpData, normalResult), TELEPHONY_SUCCESS);
379 ASSERT_EQ(stubTestFive->OnSetColpResponseInner(colpData, colpReply), TELEPHONY_SUCCESS);
380 MessageParcel colrData;
381 MessageParcel colrReply;
382 ASSERT_TRUE(colrData.WriteInt32(slotId));
383 ASSERT_EQ(WriteSsBaseResult(colrData, normalResult), TELEPHONY_SUCCESS);
384 ASSERT_EQ(stubTestFive->OnSetColrResponseInner(colrData, colrReply), TELEPHONY_SUCCESS);
385 }
386 }
387
388 /**
389 * @tc.number cellular_call_ImsCallCallbackStub_0006
390 * @tc.name Test for ImsCallCallbackStub
391 * @tc.desc Function test
392 */
393 HWTEST_F(ImsCallbackStubTest, cellular_call_ImsCallCallbackStub_0006, Function | MediumTest | Level3)
394 {
395 sptr<ImsCallCallbackStub> stubTestSix = (std::make_unique<ImsCallCallbackStub>()).release();
396 ASSERT_TRUE(stubTestSix != nullptr);
397 for (int32_t slotId = 0; slotId < SIM_SLOT_COUNT; slotId++) {
398 if (!HasSimCard(slotId)) {
399 continue;
400 }
401 SsBaseResult ssBaseResult;
402 ssBaseResult.index = DEFAULT_INDEX;
403 ssBaseResult.result = IMS_ERROR_UT_CS_FALLBACK;
404 ASSERT_NE(stubTestSix->SetCallRestrictionResponse(slotId, ssBaseResult), TELEPHONY_SUCCESS);
405 ASSERT_NE(stubTestSix->SetCallTransferResponse(slotId, ssBaseResult), TELEPHONY_SUCCESS);
406 ASSERT_NE(stubTestSix->SetCallWaitingResponse(slotId, ssBaseResult), TELEPHONY_SUCCESS);
407 ASSERT_NE(stubTestSix->SetClirResponse(slotId, ssBaseResult), TELEPHONY_SUCCESS);
408 MessageParcel muteData;
409 MessageParcel muteReply;
410 MuteControlResponse muteResponse;
411 ASSERT_TRUE(muteData.WriteInt32(slotId));
412 ASSERT_TRUE(muteData.WriteRawData((const void *)&muteResponse, sizeof(MuteControlResponse)));
413 ASSERT_EQ(stubTestSix->OnSetMuteResponseInner(muteData, muteReply), TELEPHONY_SUCCESS);
414 MessageParcel ringData;
415 MessageParcel ringReply;
416 RingbackVoice ringback;
417 ASSERT_TRUE(ringData.WriteInt32(slotId));
418 ASSERT_TRUE(ringData.WriteRawData((const void *)&ringback, sizeof(RingbackVoice)));
419 ASSERT_EQ(stubTestSix->OnCallRingBackReportInner(ringData, ringReply), TELEPHONY_SUCCESS);
420 MessageParcel failData;
421 MessageParcel failReply;
422 DisconnectedDetails details;
423 ASSERT_TRUE(failData.WriteInt32(slotId));
424 ASSERT_TRUE(failData.WriteInt32(static_cast<int32_t>(details.reason)));
425 ASSERT_TRUE(failData.WriteString(details.message));
426 ASSERT_EQ(stubTestSix->OnLastCallFailReasonResponseInner(failData, failReply), TELEPHONY_SUCCESS);
427 }
428 }
429
430 /**
431 * @tc.number cellular_call_ImsCallCallbackStub_0007
432 * @tc.name Test for ImsCallCallbackStub
433 * @tc.desc Function test
434 */
435 HWTEST_F(ImsCallbackStubTest, cellular_call_ImsCallCallbackStub_0007, Function | MediumTest | Level3)
436 {
437 sptr<ImsCallCallbackStub> stubTestSeven = (std::make_unique<ImsCallCallbackStub>()).release();
438 ASSERT_TRUE(stubTestSeven != nullptr);
439 for (int32_t slotId = 0; slotId < SIM_SLOT_COUNT; slotId++) {
440 if (!HasSimCard(slotId)) {
441 continue;
442 }
443 CallRestrictionResult crResult;
444 crResult.result.index = INVALID_INDEX;
445 MessageParcel crErrorData;
446 MessageParcel crErrorReply;
447 ASSERT_TRUE(crErrorData.WriteInt32(slotId));
448 ASSERT_EQ(WriteSsResult(crErrorData, crResult.result, crResult.status, crResult.classCw), TELEPHONY_SUCCESS);
449 ASSERT_EQ(stubTestSeven->OnGetCallRestrictionResponseInner(crErrorData, crErrorReply), TELEPHONY_SUCCESS);
450
451 crResult.result.index = DEFAULT_INDEX;
452 MessageParcel crData;
453 MessageParcel crReply;
454 ASSERT_TRUE(crData.WriteInt32(slotId));
455 ASSERT_EQ(WriteSsResult(crData, crResult.result, crResult.status, crResult.classCw), TELEPHONY_SUCCESS);
456 ASSERT_EQ(stubTestSeven->OnGetCallRestrictionResponseInner(crData, crReply), TELEPHONY_SUCCESS);
457 crResult.result.result = IMS_ERROR_UT_CS_FALLBACK;
458 ASSERT_NE(stubTestSeven->GetCallRestrictionResponse(slotId, crResult), TELEPHONY_SUCCESS);
459
460 CallForwardQueryInfoList callList;
461 callList.result.index = INVALID_INDEX;
462 MessageParcel ctErrorData;
463 MessageParcel ctErrorReply;
464 ASSERT_TRUE(ctErrorData.WriteInt32(slotId));
465 ASSERT_EQ(WriteCallForwardResult(ctErrorData, callList), TELEPHONY_SUCCESS);
466 ASSERT_EQ(stubTestSeven->OnGetCallTransferResponseInner(ctErrorData, ctErrorReply), TELEPHONY_SUCCESS);
467
468 callList.result.index = DEFAULT_INDEX;
469 MessageParcel ctData;
470 MessageParcel ctReply;
471 ASSERT_TRUE(ctData.WriteInt32(slotId));
472 ASSERT_EQ(WriteCallForwardResult(ctData, callList), TELEPHONY_SUCCESS);
473 ASSERT_EQ(stubTestSeven->OnGetCallTransferResponseInner(ctData, ctReply), TELEPHONY_SUCCESS);
474 callList.result.result = IMS_ERROR_UT_CS_FALLBACK;
475 ASSERT_NE(stubTestSeven->GetCallTransferResponse(slotId, callList), TELEPHONY_SUCCESS);
476 }
477 }
478
479 /**
480 * @tc.number cellular_call_ImsCallCallbackStub_0008
481 * @tc.name Test for ImsCallCallbackStub
482 * @tc.desc Function test
483 */
484 HWTEST_F(ImsCallbackStubTest, cellular_call_ImsCallCallbackStub_0008, Function | MediumTest | Level3)
485 {
486 sptr<ImsCallCallbackStub> stubTestEigth = (std::make_unique<ImsCallCallbackStub>()).release();
487 ASSERT_TRUE(stubTestEigth != nullptr);
488 for (int32_t slotId = 0; slotId < SIM_SLOT_COUNT; slotId++) {
489 if (!HasSimCard(slotId)) {
490 continue;
491 }
492 CallWaitResult cwResult;
493 cwResult.result.index = INVALID_INDEX;
494 MessageParcel cwErrorData;
495 MessageParcel cwErrorReply;
496 ASSERT_TRUE(cwErrorData.WriteInt32(slotId));
497 ASSERT_EQ(WriteSsResult(cwErrorData, cwResult.result, cwResult.status, cwResult.classCw), TELEPHONY_SUCCESS);
498 ASSERT_EQ(stubTestEigth->OnGetCallWaitingResponseInner(cwErrorData, cwErrorReply), TELEPHONY_SUCCESS);
499
500 cwResult.result.index = DEFAULT_INDEX;
501 MessageParcel cwData;
502 MessageParcel cwReply;
503 ASSERT_TRUE(cwData.WriteInt32(slotId));
504 ASSERT_EQ(WriteSsResult(cwData, cwResult.result, cwResult.status, cwResult.classCw), TELEPHONY_SUCCESS);
505 ASSERT_EQ(stubTestEigth->OnGetCallWaitingResponseInner(cwData, cwReply), TELEPHONY_SUCCESS);
506 cwResult.result.result = IMS_ERROR_UT_CS_FALLBACK;
507 ASSERT_NE(stubTestEigth->GetCallWaitingResponse(slotId, cwResult), TELEPHONY_SUCCESS);
508
509 GetClipResult clipResult;
510 clipResult.result.index = INVALID_INDEX;
511 MessageParcel clipErrorData;
512 MessageParcel clipErrorReply;
513 ASSERT_TRUE(clipErrorData.WriteInt32(slotId));
514 ASSERT_EQ(
515 WriteSsResult(clipErrorData, clipResult.result, clipResult.action, clipResult.clipStat), TELEPHONY_SUCCESS);
516 ASSERT_EQ(stubTestEigth->OnGetClipResponseInner(clipErrorData, clipErrorReply), TELEPHONY_SUCCESS);
517
518 clipResult.result.index = DEFAULT_INDEX;
519 MessageParcel clipData;
520 MessageParcel clipReply;
521 ASSERT_TRUE(clipData.WriteInt32(slotId));
522 ASSERT_EQ(
523 WriteSsResult(clipData, clipResult.result, clipResult.action, clipResult.clipStat), TELEPHONY_SUCCESS);
524 ASSERT_EQ(stubTestEigth->OnGetClipResponseInner(clipData, clipReply), TELEPHONY_SUCCESS);
525 clipResult.result.result = IMS_ERROR_UT_CS_FALLBACK;
526 ASSERT_NE(stubTestEigth->GetClipResponse(slotId, clipResult), TELEPHONY_SUCCESS);
527 }
528 }
529
530 /**
531 * @tc.number cellular_call_ImsCallCallbackStub_0009
532 * @tc.name Test for ImsCallCallbackStub
533 * @tc.desc Function test
534 */
535 HWTEST_F(ImsCallbackStubTest, cellular_call_ImsCallCallbackStub_0009, Function | MediumTest | Level3)
536 {
537 sptr<ImsCallCallbackStub> stubTestNight = (std::make_unique<ImsCallCallbackStub>()).release();
538 ASSERT_TRUE(stubTestNight != nullptr);
539 for (int32_t slotId = 0; slotId < SIM_SLOT_COUNT; slotId++) {
540 if (!HasSimCard(slotId)) {
541 continue;
542 }
543 GetClirResult clirResult;
544 clirResult.result.index = INVALID_INDEX;
545 MessageParcel clirErrorData;
546 MessageParcel clirErrorReply;
547 ASSERT_TRUE(clirErrorData.WriteInt32(slotId));
548 ASSERT_EQ(
549 WriteSsResult(clirErrorData, clirResult.result, clirResult.action, clirResult.clirStat), TELEPHONY_SUCCESS);
550 ASSERT_EQ(stubTestNight->OnGetClirResponseInner(clirErrorData, clirErrorReply), TELEPHONY_SUCCESS);
551
552 clirResult.result.index = DEFAULT_INDEX;
553 MessageParcel clirData;
554 MessageParcel clirReply;
555 ASSERT_TRUE(clirData.WriteInt32(slotId));
556 ASSERT_EQ(
557 WriteSsResult(clirData, clirResult.result, clirResult.action, clirResult.clirStat), TELEPHONY_SUCCESS);
558 ASSERT_EQ(stubTestNight->OnGetClirResponseInner(clirData, clirReply), TELEPHONY_SUCCESS);
559 clirResult.result.result = IMS_ERROR_UT_CS_FALLBACK;
560 ASSERT_NE(stubTestNight->GetClirResponse(slotId, clirResult), TELEPHONY_SUCCESS);
561
562 GetColpResult colpResult;
563 colpResult.result.index = INVALID_INDEX;
564 MessageParcel colpErrorData;
565 MessageParcel colpErrorReply;
566 ASSERT_TRUE(colpErrorData.WriteInt32(slotId));
567 ASSERT_EQ(
568 WriteSsResult(colpErrorData, colpResult.result, colpResult.action, colpResult.colpStat), TELEPHONY_SUCCESS);
569 ASSERT_EQ(stubTestNight->OnGetColpResponseInner(colpErrorData, colpErrorReply), TELEPHONY_SUCCESS);
570
571 colpResult.result.index = DEFAULT_INDEX;
572 MessageParcel colpData;
573 MessageParcel colpReply;
574 ASSERT_TRUE(colpData.WriteInt32(slotId));
575 ASSERT_EQ(
576 WriteSsResult(colpData, colpResult.result, colpResult.action, colpResult.colpStat), TELEPHONY_SUCCESS);
577 ASSERT_EQ(stubTestNight->OnGetColpResponseInner(colpData, colpReply), TELEPHONY_SUCCESS);
578 }
579 }
580
581 /**
582 * @tc.number cellular_call_ImsCallCallbackStub_0010
583 * @tc.name Test for ImsCallCallbackStub
584 * @tc.desc Function test
585 */
586 HWTEST_F(ImsCallbackStubTest, cellular_call_ImsCallCallbackStub_0010, Function | MediumTest | Level3)
587 {
588 sptr<ImsCallCallbackStub> stubTestTen = (std::make_unique<ImsCallCallbackStub>()).release();
589 ASSERT_TRUE(stubTestTen != nullptr);
590 for (int32_t slotId = 0; slotId < SIM_SLOT_COUNT; slotId++) {
591 if (!HasSimCard(slotId)) {
592 continue;
593 }
594 GetColrResult colrResult;
595 colrResult.result.index = INVALID_INDEX;
596 MessageParcel colrErrorData;
597 MessageParcel colrErrorReply;
598 ASSERT_TRUE(colrErrorData.WriteInt32(slotId));
599 ASSERT_EQ(
600 WriteSsResult(colrErrorData, colrResult.result, colrResult.action, colrResult.colrStat), TELEPHONY_SUCCESS);
601 ASSERT_EQ(stubTestTen->OnGetColrResponseInner(colrErrorData, colrErrorReply), TELEPHONY_SUCCESS);
602
603 colrResult.result.index = DEFAULT_INDEX;
604 MessageParcel colrData;
605 MessageParcel colrReply;
606 ASSERT_TRUE(colrData.WriteInt32(slotId));
607 ASSERT_EQ(
608 WriteSsResult(colrData, colrResult.result, colrResult.action, colrResult.colrStat), TELEPHONY_SUCCESS);
609 ASSERT_EQ(stubTestTen->OnGetColrResponseInner(colrData, colrReply), TELEPHONY_SUCCESS);
610
611 SsBaseResult normalResult;
612 normalResult.index = DEFAULT_INDEX;
613 MessageParcel ctErrorData;
614 MessageParcel ctReply;
615 ASSERT_TRUE(ctErrorData.WriteInt32(slotId));
616 ASSERT_EQ(WriteSsBaseResult(ctErrorData, normalResult), TELEPHONY_SUCCESS);
617 ASSERT_TRUE(ctErrorData.WriteInt32(INVALID_INDEX));
618 ASSERT_TRUE(ctErrorData.WriteInt32(INVALID_INDEX));
619 ASSERT_TRUE(ctErrorData.WriteInt32(INVALID_INDEX));
620 ASSERT_NE(stubTestTen->OnGetCallTransferResponseInner(ctErrorData, ctReply), TELEPHONY_SUCCESS);
621
622 MessageParcel icErrorData;
623 MessageParcel icReply;
624 ASSERT_TRUE(icErrorData.WriteInt32(slotId));
625 ASSERT_TRUE(icErrorData.WriteInt32(INVALID_INDEX));
626 ASSERT_TRUE(icErrorData.WriteInt32(INVALID_INDEX));
627 ASSERT_TRUE(icErrorData.WriteInt32(INVALID_INDEX));
628 ASSERT_TRUE(icErrorData.WriteInt32(INVALID_INDEX));
629 ASSERT_NE(stubTestTen->OnGetImsCallsDataResponseInner(icErrorData, icReply), TELEPHONY_SUCCESS);
630 }
631 }
632
633 /**
634 * @tc.number cellular_call_ImsCallCallbackStub_0011
635 * @tc.name Test for ImsCallCallbackStub
636 * @tc.desc Function test
637 */
638 HWTEST_F(ImsCallbackStubTest, cellular_call_ImsCallCallbackStub_0011, Function | MediumTest | Level3)
639 {
640 sptr<ImsCallCallbackStub> stubTestEleven = (std::make_unique<ImsCallCallbackStub>()).release();
641 ASSERT_TRUE(stubTestEleven != nullptr);
642 for (int32_t slotId = 0; slotId < SIM_SLOT_COUNT; slotId++) {
643 if (!HasSimCard(slotId)) {
644 continue;
645 }
646 MessageParcel callModeReceiveRequestData;
647 MessageParcel callModeReceiveRequestReply;
648 ImsCallModeReceiveInfo callModeReceiveRequesInfo;
649 callModeReceiveRequesInfo.callIndex = DEFAULT_INDEX;
650 ASSERT_TRUE(callModeReceiveRequestData.WriteInt32(slotId));
651 ASSERT_TRUE(callModeReceiveRequestData.WriteRawData(
652 (const void *)&callModeReceiveRequesInfo, sizeof(ImsCallModeReceiveInfo)));
653 ASSERT_EQ(stubTestEleven->OnReceiveUpdateCallMediaModeRequestInner(
654 callModeReceiveRequestData, callModeReceiveRequestReply), TELEPHONY_SUCCESS);
655 MessageParcel callModeReceiveResponseData;
656 MessageParcel callModeReceiveResponseReply;
657 ImsCallModeReceiveInfo callModeReceiveResponseInfo;
658 callModeReceiveResponseInfo.callIndex = DEFAULT_INDEX;
659 ASSERT_TRUE(callModeReceiveResponseData.WriteInt32(slotId));
660 ASSERT_TRUE(callModeReceiveResponseData.WriteRawData(
661 (const void *)&callModeReceiveResponseInfo, sizeof(ImsCallModeReceiveInfo)));
662 ASSERT_EQ(stubTestEleven->OnReceiveUpdateCallMediaModeResponseInner(
663 callModeReceiveResponseData, callModeReceiveResponseReply), TELEPHONY_SUCCESS);
664 MessageParcel callSessionEventInfoData;
665 MessageParcel callSessionEventInfoReply;
666 ImsCallSessionEventInfo callSessionEventInfo;
667 callSessionEventInfo.callIndex = DEFAULT_INDEX;
668 ASSERT_TRUE(callSessionEventInfoData.WriteInt32(slotId));
669 ASSERT_TRUE(callSessionEventInfoData.WriteRawData(
670 (const void *)&callSessionEventInfo, sizeof(ImsCallSessionEventInfo)));
671 ASSERT_EQ(stubTestEleven->OnCallSessionEventChangedInner(
672 callSessionEventInfoData, callSessionEventInfoReply), TELEPHONY_SUCCESS);
673 }
674 }
675
676 /**
677 * @tc.number cellular_call_ImsCallCallbackStub_0012
678 * @tc.name Test for ImsCallCallbackStub
679 * @tc.desc Function test
680 */
681 HWTEST_F(ImsCallbackStubTest, cellular_call_ImsCallCallbackStub_0012, Function | MediumTest | Level3)
682 {
683 sptr<ImsCallCallbackStub> stubTestEleven = (std::make_unique<ImsCallCallbackStub>()).release();
684 ASSERT_TRUE(stubTestEleven != nullptr);
685 for (int32_t slotId = 0; slotId < SIM_SLOT_COUNT; slotId++) {
686 if (!HasSimCard(slotId)) {
687 continue;
688 }
689 MessageParcel callPeerDimensionsInfoData;
690 MessageParcel callPeerDimensionsInfoReply;
691 ImsCallPeerDimensionsInfo callPeerDimensionsInfo;
692 callPeerDimensionsInfo.callIndex = DEFAULT_INDEX;
693 ASSERT_TRUE(callPeerDimensionsInfoData.WriteInt32(slotId));
694 ASSERT_TRUE(callPeerDimensionsInfoData.WriteRawData(
695 (const void *)&callPeerDimensionsInfo, sizeof(ImsCallPeerDimensionsInfo)));
696 ASSERT_EQ(stubTestEleven->OnPeerDimensionsChangedInner(
697 callPeerDimensionsInfoData, callPeerDimensionsInfoReply), TELEPHONY_SUCCESS);
698 MessageParcel callDataUsageInfoData;
699 MessageParcel callDataUsageInfoReply;
700 ImsCallDataUsageInfo callDataUsageInfo;
701 callDataUsageInfo.callIndex = DEFAULT_INDEX;
702 ASSERT_TRUE(callDataUsageInfoData.WriteInt32(slotId));
703 ASSERT_TRUE(callDataUsageInfoData.WriteRawData(
704 (const void *)&callDataUsageInfo, sizeof(ImsCallDataUsageInfo)));
705 ASSERT_EQ(stubTestEleven->OnCallDataUsageChangedInner(
706 callDataUsageInfoData, callDataUsageInfoReply), TELEPHONY_SUCCESS);
707 MessageParcel cameraCapabilitiesInfoData;
708 MessageParcel cameraCapabilitiesInfoReply;
709 CameraCapabilitiesInfo cameraCapabilitiesInfo;
710 cameraCapabilitiesInfo.callIndex = DEFAULT_INDEX;
711 ASSERT_TRUE(cameraCapabilitiesInfoData.WriteInt32(slotId));
712 ASSERT_TRUE(cameraCapabilitiesInfoData.WriteRawData(
713 (const void *)&cameraCapabilitiesInfo, sizeof(CameraCapabilitiesInfo)));
714 ASSERT_EQ(stubTestEleven->OnCameraCapabilitiesChangedInner(
715 cameraCapabilitiesInfoData, cameraCapabilitiesInfoReply), TELEPHONY_SUCCESS);
716 }
717 }
718 /**
719 * @tc.number cellular_call_ImsCallCallbackStub_0013
720 * @tc.name Test for ImsCallCallbackStub
721 * @tc.desc Function test
722 */
723 HWTEST_F(ImsCallbackStubTest, cellular_call_ImsCallCallbackStub_0013, Function | MediumTest | Level3)
724 {
725 sptr<ImsCallCallbackStub> stub = (std::make_unique<ImsCallCallbackStub>()).release();
726 ASSERT_TRUE(stub != nullptr);
727 for (int32_t slotId = 0; slotId < SLOT_COUNT; slotId++) {
728 RadioResponseInfo rilRadioResponse;
729 rilRadioResponse.error = ErrType::ERR_GENERIC_FAILURE;
730 MessageParcel answerData;
731 MessageParcel answerReply;
732 ASSERT_TRUE(answerData.WriteInt32(slotId));
733 ASSERT_TRUE(answerData.WriteRawData((const void *)&rilRadioResponse, sizeof(RadioResponseInfo)));
734 ASSERT_EQ(stub->OnAnswerResponseInner(answerData, answerReply), TELEPHONY_SUCCESS);
735
736 MessageParcel dialData;
737 MessageParcel dialReply;
738 ASSERT_TRUE(dialData.WriteInt32(slotId));
739 ASSERT_TRUE(dialData.WriteRawData((const void *)&rilRadioResponse, sizeof(RadioResponseInfo)));
740 ASSERT_EQ(stub->OnDialResponseInner(dialData, dialReply), TELEPHONY_SUCCESS);
741
742 MessageParcel imsCallsData;
743 MessageParcel imsCallsReply;
744 ASSERT_TRUE(imsCallsData.WriteInt32(slotId));
745 ASSERT_TRUE(imsCallsData.WriteRawData((const void *)&rilRadioResponse, sizeof(RadioResponseInfo)));
746 ASSERT_EQ(stub->OnGetImsCallsDataResponseInner(imsCallsData, imsCallsReply), TELEPHONY_SUCCESS);
747
748 MessageParcel hangupData;
749 MessageParcel hangupReply;
750 ASSERT_TRUE(hangupData.WriteInt32(slotId));
751 ASSERT_TRUE(hangupData.WriteRawData((const void *)&rilRadioResponse, sizeof(RadioResponseInfo)));
752 ASSERT_EQ(stub->OnHangUpResponseInner(hangupData, hangupReply), TELEPHONY_SUCCESS);
753
754 MessageParcel holdCallData;
755 MessageParcel holdCallReply;
756 ASSERT_TRUE(holdCallData.WriteInt32(slotId));
757 ASSERT_TRUE(holdCallData.WriteRawData((const void *)&rilRadioResponse, sizeof(RadioResponseInfo)));
758 ASSERT_EQ(stub->OnHoldCallResponseInner(holdCallData, holdCallReply), TELEPHONY_SUCCESS);
759
760 MessageParcel rejectData;
761 MessageParcel rejectReply;
762 ASSERT_TRUE(rejectData.WriteInt32(slotId));
763 ASSERT_TRUE(rejectData.WriteRawData((const void *)&rilRadioResponse, sizeof(RadioResponseInfo)));
764 ASSERT_EQ(stub->OnRejectResponseInner(rejectData, rejectReply), TELEPHONY_SUCCESS);
765 }
766 }
767
768 /**
769 * @tc.number cellular_call_ImsCallCallbackStub_0014
770 * @tc.name Test for ImsCallCallbackStub
771 * @tc.desc Function test
772 */
773 HWTEST_F(ImsCallbackStubTest, cellular_call_ImsCallCallbackStub_0014, Function | MediumTest | Level3)
774 {
775 sptr<ImsCallCallbackStub> stubTestTwo = (std::make_unique<ImsCallCallbackStub>()).release();
776 ASSERT_TRUE(stubTestTwo != nullptr);
777 for (int32_t slotId = 0; slotId < SLOT_COUNT; slotId++) {
778 RadioResponseInfo rilRadioResponse;
779 rilRadioResponse.error = ErrType::ERR_GENERIC_FAILURE;
780 MessageParcel sendDtmfData;
781 MessageParcel sendDtmfReply;
782 ASSERT_TRUE(sendDtmfData.WriteInt32(slotId));
783 ASSERT_TRUE(sendDtmfData.WriteRawData((const void *)&rilRadioResponse, sizeof(RadioResponseInfo)));
784 ASSERT_GE(stubTestTwo->OnSendDtmfResponseInner(sendDtmfData, sendDtmfReply), TELEPHONY_SUCCESS);
785
786 MessageParcel setImsSwitchData;
787 MessageParcel setImsSwitchReply;
788 ASSERT_TRUE(setImsSwitchData.WriteInt32(slotId));
789 ASSERT_TRUE(setImsSwitchData.WriteRawData((const void *)&rilRadioResponse, sizeof(RadioResponseInfo)));
790 ASSERT_EQ(stubTestTwo->OnSetImsSwitchResponseInner(setImsSwitchData, setImsSwitchReply), TELEPHONY_SUCCESS);
791
792 MessageParcel startDtmfData;
793 MessageParcel startDtmfReply;
794 ASSERT_TRUE(startDtmfData.WriteInt32(slotId));
795 ASSERT_TRUE(startDtmfData.WriteRawData((const void *)&rilRadioResponse, sizeof(RadioResponseInfo)));
796 ASSERT_EQ(stubTestTwo->OnStartDtmfResponseInner(startDtmfData, startDtmfReply), TELEPHONY_SUCCESS);
797
798 MessageParcel stopDtmfData;
799 MessageParcel stopDtmfReply;
800 ASSERT_TRUE(stopDtmfData.WriteInt32(slotId));
801 ASSERT_TRUE(stopDtmfData.WriteRawData((const void *)&rilRadioResponse, sizeof(RadioResponseInfo)));
802 ASSERT_EQ(stubTestTwo->OnStopDtmfResponseInner(stopDtmfData, stopDtmfReply), TELEPHONY_SUCCESS);
803
804 MessageParcel switchCallData;
805 MessageParcel switchCallReply;
806 ASSERT_TRUE(switchCallData.WriteInt32(slotId));
807 ASSERT_TRUE(switchCallData.WriteRawData((const void *)&rilRadioResponse, sizeof(RadioResponseInfo)));
808 ASSERT_EQ(stubTestTwo->OnSwitchCallResponseInner(switchCallData, switchCallReply), TELEPHONY_SUCCESS);
809
810 MessageParcel unholdData;
811 MessageParcel unholdReply;
812 ASSERT_TRUE(unholdData.WriteInt32(slotId));
813 ASSERT_TRUE(unholdData.WriteRawData((const void *)&rilRadioResponse, sizeof(RadioResponseInfo)));
814 ASSERT_EQ(stubTestTwo->OnUnHoldCallResponseInner(unholdData, unholdReply), TELEPHONY_SUCCESS);
815
816 MessageParcel getImsSwitchData;
817 MessageParcel getImsSwitchReply;
818 ASSERT_TRUE(getImsSwitchData.WriteInt32(slotId));
819 ASSERT_TRUE(getImsSwitchData.WriteRawData((const void *)&rilRadioResponse, sizeof(RadioResponseInfo)));
820 ASSERT_EQ(stubTestTwo->OnGetImsSwitchResponseInner(getImsSwitchData, getImsSwitchReply), TELEPHONY_SUCCESS);
821 }
822 }
823
824 /**
825 * @tc.number cellular_call_ImsCallCallbackStub_0015
826 * @tc.name Test for ImsCallCallbackStub
827 * @tc.desc Function test
828 */
829 HWTEST_F(ImsCallbackStubTest, cellular_call_ImsCallCallbackStub_0015, Function | MediumTest | Level3)
830 {
831 sptr<ImsCallCallbackStub> stubTestThree = (std::make_unique<ImsCallCallbackStub>()).release();
832 ASSERT_TRUE(stubTestThree != nullptr);
833 for (int32_t slotId = 0; slotId < SLOT_COUNT; slotId++) {
834 MessageParcel data;
835 MessageParcel reply;
836 ASSERT_TRUE(data.WriteInt32(slotId));
837 ASSERT_NE(stubTestThree->OnAnswerResponseInner(data, reply), TELEPHONY_SUCCESS);
838 ASSERT_NE(stubTestThree->OnCallRingBackReportInner(data, reply), TELEPHONY_SUCCESS);
839 ASSERT_NE(stubTestThree->OnDialResponseInner(data, reply), TELEPHONY_SUCCESS);
840 ASSERT_NE(stubTestThree->OnHangUpResponseInner(data, reply), TELEPHONY_SUCCESS);
841 ASSERT_NE(stubTestThree->OnHoldCallResponseInner(data, reply), TELEPHONY_SUCCESS);
842 ASSERT_NE(stubTestThree->OnRejectResponseInner(data, reply), TELEPHONY_SUCCESS);
843 ASSERT_NE(stubTestThree->OnSendDtmfResponseInner(data, reply), TELEPHONY_SUCCESS);
844 ASSERT_NE(stubTestThree->OnSetImsSwitchResponseInner(data, reply), TELEPHONY_SUCCESS);
845 ASSERT_NE(stubTestThree->OnStartDtmfResponseInner(data, reply), TELEPHONY_SUCCESS);
846 ASSERT_NE(stubTestThree->OnStopDtmfResponseInner(data, reply), TELEPHONY_SUCCESS);
847 ASSERT_NE(stubTestThree->OnSwitchCallResponseInner(data, reply), TELEPHONY_SUCCESS);
848 ASSERT_NE(stubTestThree->OnUnHoldCallResponseInner(data, reply), TELEPHONY_SUCCESS);
849 ASSERT_NE(stubTestThree->OnSetMuteResponseInner(data, reply), TELEPHONY_SUCCESS);
850 ASSERT_NE(stubTestThree->OnCombineConferenceResponseInner(data, reply), TELEPHONY_SUCCESS);
851 ASSERT_NE(stubTestThree->OnInviteToConferenceResponseInner(data, reply), TELEPHONY_SUCCESS);
852 ASSERT_NE(stubTestThree->OnReceiveUpdateCallMediaModeRequestInner(data, reply), TELEPHONY_SUCCESS);
853 ASSERT_NE(stubTestThree->OnReceiveUpdateCallMediaModeResponseInner(data, reply), TELEPHONY_SUCCESS);
854 ASSERT_NE(stubTestThree->OnCallSessionEventChangedInner(data, reply), TELEPHONY_SUCCESS);
855 ASSERT_NE(stubTestThree->OnPeerDimensionsChangedInner(data, reply), TELEPHONY_SUCCESS);
856 ASSERT_NE(stubTestThree->OnCallDataUsageChangedInner(data, reply), TELEPHONY_SUCCESS);
857 ASSERT_NE(stubTestThree->OnCameraCapabilitiesChangedInner(data, reply), TELEPHONY_SUCCESS);
858 }
859 }
860
861 /**
862 * @tc.number cellular_call_ImsCallCallbackStub_0016
863 * @tc.name Test for ImsCallCallbackStub
864 * @tc.desc Function test
865 */
866 HWTEST_F(ImsCallbackStubTest, cellular_call_ImsCallCallbackStub_0016, Function | MediumTest | Level3)
867 {
868 sptr<ImsCallCallbackStub> stubTestFour = (std::make_unique<ImsCallCallbackStub>()).release();
869 ASSERT_TRUE(stubTestFour != nullptr);
870 for (int32_t slotId = 0; slotId < SLOT_COUNT; slotId++) {
871 SsBaseResult normalResult;
872 normalResult.index = DEFAULT_INDEX;
873 MessageParcel crData;
874 MessageParcel crReply;
875 ASSERT_TRUE(crData.WriteInt32(slotId));
876 ASSERT_EQ(WriteSsBaseResult(crData, normalResult), TELEPHONY_SUCCESS);
877 ASSERT_EQ(stubTestFour->OnSetCallRestrictionResponseInner(crData, crReply), TELEPHONY_SUCCESS);
878 MessageParcel ctData;
879 MessageParcel ctReply;
880 ASSERT_TRUE(ctData.WriteInt32(slotId));
881 ASSERT_EQ(WriteSsBaseResult(ctData, normalResult), TELEPHONY_SUCCESS);
882 ASSERT_EQ(stubTestFour->OnSetCallTransferResponseInner(ctData, ctReply), TELEPHONY_SUCCESS);
883 MessageParcel cwData;
884 MessageParcel cwReply;
885 ASSERT_TRUE(cwData.WriteInt32(slotId));
886 ASSERT_EQ(WriteSsBaseResult(cwData, normalResult), TELEPHONY_SUCCESS);
887 ASSERT_EQ(stubTestFour->OnSetCallWaitingResponseInner(cwData, cwReply), TELEPHONY_SUCCESS);
888 MessageParcel clipData;
889 MessageParcel clipReply;
890 ASSERT_TRUE(clipData.WriteInt32(slotId));
891 ASSERT_EQ(WriteSsBaseResult(clipData, normalResult), TELEPHONY_SUCCESS);
892 ASSERT_EQ(stubTestFour->OnSetClipResponseInner(clipData, clipReply), TELEPHONY_SUCCESS);
893 MessageParcel clirData;
894 MessageParcel clirReply;
895 ASSERT_TRUE(clirData.WriteInt32(slotId));
896 ASSERT_EQ(WriteSsBaseResult(clirData, normalResult), TELEPHONY_SUCCESS);
897 ASSERT_EQ(stubTestFour->OnSetClirResponseInner(clirData, clirReply), TELEPHONY_SUCCESS);
898 MessageParcel colpData;
899 MessageParcel colpReply;
900 ASSERT_TRUE(colpData.WriteInt32(slotId));
901 ASSERT_EQ(WriteSsBaseResult(colpData, normalResult), TELEPHONY_SUCCESS);
902 ASSERT_EQ(stubTestFour->OnSetColpResponseInner(colpData, colpReply), TELEPHONY_SUCCESS);
903 MessageParcel colrData;
904 MessageParcel colrReply;
905 ASSERT_TRUE(colrData.WriteInt32(slotId));
906 ASSERT_EQ(WriteSsBaseResult(colrData, normalResult), TELEPHONY_SUCCESS);
907 ASSERT_EQ(stubTestFour->OnSetColrResponseInner(colrData, colrReply), TELEPHONY_SUCCESS);
908 }
909 }
910
911 /**
912 * @tc.number cellular_call_ImsCallCallbackStub_0017
913 * @tc.name Test for ImsCallCallbackStub
914 * @tc.desc Function test
915 */
916 HWTEST_F(ImsCallbackStubTest, cellular_call_ImsCallCallbackStub_0017, Function | MediumTest | Level3)
917 {
918 sptr<ImsCallCallbackStub> stubTestFive = (std::make_unique<ImsCallCallbackStub>()).release();
919 ASSERT_TRUE(stubTestFive != nullptr);
920 for (int32_t slotId = 0; slotId < SLOT_COUNT; slotId++) {
921 SsBaseResult normalResult;
922 normalResult.index = INVALID_INDEX;
923 MessageParcel crData;
924 MessageParcel crReply;
925 ASSERT_TRUE(crData.WriteInt32(slotId));
926 ASSERT_EQ(WriteSsBaseResult(crData, normalResult), TELEPHONY_SUCCESS);
927 ASSERT_EQ(stubTestFive->OnSetCallRestrictionResponseInner(crData, crReply), TELEPHONY_SUCCESS);
928 MessageParcel ctData;
929 MessageParcel ctReply;
930 ASSERT_TRUE(ctData.WriteInt32(slotId));
931 ASSERT_EQ(WriteSsBaseResult(ctData, normalResult), TELEPHONY_SUCCESS);
932 ASSERT_EQ(stubTestFive->OnSetCallTransferResponseInner(ctData, ctReply), TELEPHONY_SUCCESS);
933 MessageParcel cwData;
934 MessageParcel cwReply;
935 ASSERT_TRUE(cwData.WriteInt32(slotId));
936 ASSERT_EQ(WriteSsBaseResult(cwData, normalResult), TELEPHONY_SUCCESS);
937 ASSERT_EQ(stubTestFive->OnSetCallWaitingResponseInner(cwData, cwReply), TELEPHONY_SUCCESS);
938 MessageParcel clipData;
939 MessageParcel clipReply;
940 ASSERT_TRUE(clipData.WriteInt32(slotId));
941 ASSERT_EQ(WriteSsBaseResult(clipData, normalResult), TELEPHONY_SUCCESS);
942 ASSERT_EQ(stubTestFive->OnSetClipResponseInner(clipData, clipReply), TELEPHONY_SUCCESS);
943 MessageParcel clirData;
944 MessageParcel clirReply;
945 ASSERT_TRUE(clirData.WriteInt32(slotId));
946 ASSERT_EQ(WriteSsBaseResult(clirData, normalResult), TELEPHONY_SUCCESS);
947 ASSERT_EQ(stubTestFive->OnSetClirResponseInner(clirData, clirReply), TELEPHONY_SUCCESS);
948 MessageParcel colpData;
949 MessageParcel colpReply;
950 ASSERT_TRUE(colpData.WriteInt32(slotId));
951 ASSERT_EQ(WriteSsBaseResult(colpData, normalResult), TELEPHONY_SUCCESS);
952 ASSERT_EQ(stubTestFive->OnSetColpResponseInner(colpData, colpReply), TELEPHONY_SUCCESS);
953 MessageParcel colrData;
954 MessageParcel colrReply;
955 ASSERT_TRUE(colrData.WriteInt32(slotId));
956 ASSERT_EQ(WriteSsBaseResult(colrData, normalResult), TELEPHONY_SUCCESS);
957 ASSERT_EQ(stubTestFive->OnSetColrResponseInner(colrData, colrReply), TELEPHONY_SUCCESS);
958 }
959 }
960
961 /**
962 * @tc.number cellular_call_ImsCallCallbackStub_0018
963 * @tc.name Test for ImsCallCallbackStub
964 * @tc.desc Function test
965 */
966 HWTEST_F(ImsCallbackStubTest, cellular_call_ImsCallCallbackStub_0018, Function | MediumTest | Level3)
967 {
968 sptr<ImsCallCallbackStub> stubTestSix = (std::make_unique<ImsCallCallbackStub>()).release();
969 ASSERT_TRUE(stubTestSix != nullptr);
970 for (int32_t slotId = 0; slotId < SLOT_COUNT; slotId++) {
971 SsBaseResult ssBaseResult;
972 ssBaseResult.index = DEFAULT_INDEX;
973 ssBaseResult.result = IMS_ERROR_UT_CS_FALLBACK;
974 ASSERT_NE(stubTestSix->SetCallRestrictionResponse(slotId, ssBaseResult), TELEPHONY_SUCCESS);
975 ASSERT_NE(stubTestSix->SetCallTransferResponse(slotId, ssBaseResult), TELEPHONY_SUCCESS);
976 ASSERT_NE(stubTestSix->SetCallWaitingResponse(slotId, ssBaseResult), TELEPHONY_SUCCESS);
977 ASSERT_NE(stubTestSix->SetClirResponse(slotId, ssBaseResult), TELEPHONY_SUCCESS);
978 MessageParcel muteData;
979 MessageParcel muteReply;
980 MuteControlResponse muteResponse;
981 ASSERT_TRUE(muteData.WriteInt32(slotId));
982 ASSERT_TRUE(muteData.WriteRawData((const void *)&muteResponse, sizeof(MuteControlResponse)));
983 ASSERT_EQ(stubTestSix->OnSetMuteResponseInner(muteData, muteReply), TELEPHONY_SUCCESS);
984 MessageParcel ringData;
985 MessageParcel ringReply;
986 RingbackVoice ringback;
987 ASSERT_TRUE(ringData.WriteInt32(slotId));
988 ASSERT_TRUE(ringData.WriteRawData((const void *)&ringback, sizeof(RingbackVoice)));
989 ASSERT_EQ(stubTestSix->OnCallRingBackReportInner(ringData, ringReply), TELEPHONY_SUCCESS);
990 MessageParcel failData;
991 MessageParcel failReply;
992 DisconnectedDetails details;
993 ASSERT_TRUE(failData.WriteInt32(slotId));
994 ASSERT_TRUE(failData.WriteInt32(static_cast<int32_t>(details.reason)));
995 ASSERT_TRUE(failData.WriteString(details.message));
996 ASSERT_EQ(stubTestSix->OnLastCallFailReasonResponseInner(failData, failReply), TELEPHONY_SUCCESS);
997 }
998 }
999
1000 /**
1001 * @tc.number cellular_call_ImsCallCallbackStub_0019
1002 * @tc.name Test for ImsCallCallbackStub
1003 * @tc.desc Function test
1004 */
1005 HWTEST_F(ImsCallbackStubTest, cellular_call_ImsCallCallbackStub_0019, Function | MediumTest | Level3)
1006 {
1007 sptr<ImsCallCallbackStub> stubTestSeven = (std::make_unique<ImsCallCallbackStub>()).release();
1008 ASSERT_TRUE(stubTestSeven != nullptr);
1009 for (int32_t slotId = 0; slotId < SLOT_COUNT; slotId++) {
1010 CallRestrictionResult crResult;
1011 crResult.result.index = INVALID_INDEX;
1012 MessageParcel crErrorData;
1013 MessageParcel crErrorReply;
1014 ASSERT_TRUE(crErrorData.WriteInt32(slotId));
1015 ASSERT_EQ(WriteSsResult(crErrorData, crResult.result, crResult.status, crResult.classCw), TELEPHONY_SUCCESS);
1016 ASSERT_EQ(stubTestSeven->OnGetCallRestrictionResponseInner(crErrorData, crErrorReply), TELEPHONY_SUCCESS);
1017
1018 crResult.result.index = DEFAULT_INDEX;
1019 MessageParcel crData;
1020 MessageParcel crReply;
1021 ASSERT_TRUE(crData.WriteInt32(slotId));
1022 ASSERT_EQ(WriteSsResult(crData, crResult.result, crResult.status, crResult.classCw), TELEPHONY_SUCCESS);
1023 ASSERT_EQ(stubTestSeven->OnGetCallRestrictionResponseInner(crData, crReply), TELEPHONY_SUCCESS);
1024 crResult.result.result = IMS_ERROR_UT_CS_FALLBACK;
1025 ASSERT_NE(stubTestSeven->GetCallRestrictionResponse(slotId, crResult), TELEPHONY_SUCCESS);
1026
1027 CallForwardQueryInfoList callList;
1028 callList.result.index = INVALID_INDEX;
1029 MessageParcel ctErrorData;
1030 MessageParcel ctErrorReply;
1031 ASSERT_TRUE(ctErrorData.WriteInt32(slotId));
1032 ASSERT_EQ(WriteCallForwardResult(ctErrorData, callList), TELEPHONY_SUCCESS);
1033 ASSERT_EQ(stubTestSeven->OnGetCallTransferResponseInner(ctErrorData, ctErrorReply), TELEPHONY_SUCCESS);
1034
1035 callList.result.index = DEFAULT_INDEX;
1036 MessageParcel ctData;
1037 MessageParcel ctReply;
1038 ASSERT_TRUE(ctData.WriteInt32(slotId));
1039 ASSERT_EQ(WriteCallForwardResult(ctData, callList), TELEPHONY_SUCCESS);
1040 ASSERT_EQ(stubTestSeven->OnGetCallTransferResponseInner(ctData, ctReply), TELEPHONY_SUCCESS);
1041 callList.result.result = IMS_ERROR_UT_CS_FALLBACK;
1042 ASSERT_NE(stubTestSeven->GetCallTransferResponse(slotId, callList), TELEPHONY_SUCCESS);
1043 }
1044 }
1045
1046 /**
1047 * @tc.number cellular_call_ImsCallCallbackStub_0020
1048 * @tc.name Test for ImsCallCallbackStub
1049 * @tc.desc Function test
1050 */
1051 HWTEST_F(ImsCallbackStubTest, cellular_call_ImsCallCallbackStub_0020, Function | MediumTest | Level3)
1052 {
1053 sptr<ImsCallCallbackStub> stubTestEigth = (std::make_unique<ImsCallCallbackStub>()).release();
1054 ASSERT_TRUE(stubTestEigth != nullptr);
1055 for (int32_t slotId = 0; slotId < SLOT_COUNT; slotId++) {
1056 CallWaitResult cwResult;
1057 cwResult.result.index = INVALID_INDEX;
1058 MessageParcel cwErrorData;
1059 MessageParcel cwErrorReply;
1060 ASSERT_TRUE(cwErrorData.WriteInt32(slotId));
1061 ASSERT_EQ(WriteSsResult(cwErrorData, cwResult.result, cwResult.status, cwResult.classCw), TELEPHONY_SUCCESS);
1062 ASSERT_EQ(stubTestEigth->OnGetCallWaitingResponseInner(cwErrorData, cwErrorReply), TELEPHONY_SUCCESS);
1063
1064 cwResult.result.index = DEFAULT_INDEX;
1065 MessageParcel cwData;
1066 MessageParcel cwReply;
1067 ASSERT_TRUE(cwData.WriteInt32(slotId));
1068 ASSERT_EQ(WriteSsResult(cwData, cwResult.result, cwResult.status, cwResult.classCw), TELEPHONY_SUCCESS);
1069 ASSERT_EQ(stubTestEigth->OnGetCallWaitingResponseInner(cwData, cwReply), TELEPHONY_SUCCESS);
1070 cwResult.result.result = IMS_ERROR_UT_CS_FALLBACK;
1071 ASSERT_NE(stubTestEigth->GetCallWaitingResponse(slotId, cwResult), TELEPHONY_SUCCESS);
1072
1073 GetClipResult clipResult;
1074 clipResult.result.index = INVALID_INDEX;
1075 MessageParcel clipErrorData;
1076 MessageParcel clipErrorReply;
1077 ASSERT_TRUE(clipErrorData.WriteInt32(slotId));
1078 ASSERT_EQ(
1079 WriteSsResult(clipErrorData, clipResult.result, clipResult.action, clipResult.clipStat), TELEPHONY_SUCCESS);
1080 ASSERT_EQ(stubTestEigth->OnGetClipResponseInner(clipErrorData, clipErrorReply), TELEPHONY_SUCCESS);
1081
1082 clipResult.result.index = DEFAULT_INDEX;
1083 MessageParcel clipData;
1084 MessageParcel clipReply;
1085 ASSERT_TRUE(clipData.WriteInt32(slotId));
1086 ASSERT_EQ(
1087 WriteSsResult(clipData, clipResult.result, clipResult.action, clipResult.clipStat), TELEPHONY_SUCCESS);
1088 ASSERT_EQ(stubTestEigth->OnGetClipResponseInner(clipData, clipReply), TELEPHONY_SUCCESS);
1089 clipResult.result.result = IMS_ERROR_UT_CS_FALLBACK;
1090 ASSERT_NE(stubTestEigth->GetClipResponse(slotId, clipResult), TELEPHONY_SUCCESS);
1091 }
1092 }
1093
1094 /**
1095 * @tc.number cellular_call_ImsCallCallbackStub_0021
1096 * @tc.name Test for ImsCallCallbackStub
1097 * @tc.desc Function test
1098 */
1099 HWTEST_F(ImsCallbackStubTest, cellular_call_ImsCallCallbackStub_0021, Function | MediumTest | Level3)
1100 {
1101 sptr<ImsCallCallbackStub> stubTestNight = (std::make_unique<ImsCallCallbackStub>()).release();
1102 ASSERT_TRUE(stubTestNight != nullptr);
1103 for (int32_t slotId = 0; slotId < SLOT_COUNT; slotId++) {
1104 GetClirResult clirResult;
1105 clirResult.result.index = INVALID_INDEX;
1106 MessageParcel clirErrorData;
1107 MessageParcel clirErrorReply;
1108 ASSERT_TRUE(clirErrorData.WriteInt32(slotId));
1109 ASSERT_EQ(
1110 WriteSsResult(clirErrorData, clirResult.result, clirResult.action, clirResult.clirStat), TELEPHONY_SUCCESS);
1111 ASSERT_EQ(stubTestNight->OnGetClirResponseInner(clirErrorData, clirErrorReply), TELEPHONY_SUCCESS);
1112
1113 clirResult.result.index = DEFAULT_INDEX;
1114 MessageParcel clirData;
1115 MessageParcel clirReply;
1116 ASSERT_TRUE(clirData.WriteInt32(slotId));
1117 ASSERT_EQ(
1118 WriteSsResult(clirData, clirResult.result, clirResult.action, clirResult.clirStat), TELEPHONY_SUCCESS);
1119 ASSERT_EQ(stubTestNight->OnGetClirResponseInner(clirData, clirReply), TELEPHONY_SUCCESS);
1120 clirResult.result.result = IMS_ERROR_UT_CS_FALLBACK;
1121 ASSERT_NE(stubTestNight->GetClirResponse(slotId, clirResult), TELEPHONY_SUCCESS);
1122
1123 GetColpResult colpResult;
1124 colpResult.result.index = INVALID_INDEX;
1125 MessageParcel colpErrorData;
1126 MessageParcel colpErrorReply;
1127 ASSERT_TRUE(colpErrorData.WriteInt32(slotId));
1128 ASSERT_EQ(
1129 WriteSsResult(colpErrorData, colpResult.result, colpResult.action, colpResult.colpStat), TELEPHONY_SUCCESS);
1130 ASSERT_EQ(stubTestNight->OnGetColpResponseInner(colpErrorData, colpErrorReply), TELEPHONY_SUCCESS);
1131
1132 colpResult.result.index = DEFAULT_INDEX;
1133 MessageParcel colpData;
1134 MessageParcel colpReply;
1135 ASSERT_TRUE(colpData.WriteInt32(slotId));
1136 ASSERT_EQ(
1137 WriteSsResult(colpData, colpResult.result, colpResult.action, colpResult.colpStat), TELEPHONY_SUCCESS);
1138 ASSERT_EQ(stubTestNight->OnGetColpResponseInner(colpData, colpReply), TELEPHONY_SUCCESS);
1139 }
1140 }
1141
1142 /**
1143 * @tc.number cellular_call_ImsCallCallbackStub_0022
1144 * @tc.name Test for ImsCallCallbackStub
1145 * @tc.desc Function test
1146 */
1147 HWTEST_F(ImsCallbackStubTest, cellular_call_ImsCallCallbackStub_0022, Function | MediumTest | Level3)
1148 {
1149 sptr<ImsCallCallbackStub> stubTestTen = (std::make_unique<ImsCallCallbackStub>()).release();
1150 ASSERT_TRUE(stubTestTen != nullptr);
1151 for (int32_t slotId = 0; slotId < SLOT_COUNT; slotId++) {
1152 GetColrResult colrResult;
1153 colrResult.result.index = INVALID_INDEX;
1154 MessageParcel colrErrorData;
1155 MessageParcel colrErrorReply;
1156 ASSERT_TRUE(colrErrorData.WriteInt32(slotId));
1157 ASSERT_EQ(
1158 WriteSsResult(colrErrorData, colrResult.result, colrResult.action, colrResult.colrStat), TELEPHONY_SUCCESS);
1159 ASSERT_EQ(stubTestTen->OnGetColrResponseInner(colrErrorData, colrErrorReply), TELEPHONY_SUCCESS);
1160
1161 colrResult.result.index = DEFAULT_INDEX;
1162 MessageParcel colrData;
1163 MessageParcel colrReply;
1164 ASSERT_TRUE(colrData.WriteInt32(slotId));
1165 ASSERT_EQ(
1166 WriteSsResult(colrData, colrResult.result, colrResult.action, colrResult.colrStat), TELEPHONY_SUCCESS);
1167 ASSERT_EQ(stubTestTen->OnGetColrResponseInner(colrData, colrReply), TELEPHONY_SUCCESS);
1168
1169 SsBaseResult normalResult;
1170 normalResult.index = DEFAULT_INDEX;
1171 MessageParcel ctErrorData;
1172 MessageParcel ctReply;
1173 ASSERT_TRUE(ctErrorData.WriteInt32(slotId));
1174 ASSERT_EQ(WriteSsBaseResult(ctErrorData, normalResult), TELEPHONY_SUCCESS);
1175 ASSERT_TRUE(ctErrorData.WriteInt32(INVALID_INDEX));
1176 ASSERT_TRUE(ctErrorData.WriteInt32(INVALID_INDEX));
1177 ASSERT_TRUE(ctErrorData.WriteInt32(INVALID_INDEX));
1178 ASSERT_NE(stubTestTen->OnGetCallTransferResponseInner(ctErrorData, ctReply), TELEPHONY_SUCCESS);
1179
1180 MessageParcel icErrorData;
1181 MessageParcel icReply;
1182 ASSERT_TRUE(icErrorData.WriteInt32(slotId));
1183 ASSERT_TRUE(icErrorData.WriteInt32(INVALID_INDEX));
1184 ASSERT_TRUE(icErrorData.WriteInt32(INVALID_INDEX));
1185 ASSERT_TRUE(icErrorData.WriteInt32(INVALID_INDEX));
1186 ASSERT_TRUE(icErrorData.WriteInt32(INVALID_INDEX));
1187 ASSERT_NE(stubTestTen->OnGetImsCallsDataResponseInner(icErrorData, icReply), TELEPHONY_SUCCESS);
1188 }
1189 }
1190
1191 /**
1192 * @tc.number cellular_call_ImsCallCallbackStub_0023
1193 * @tc.name Test for ImsCallCallbackStub
1194 * @tc.desc Function test
1195 */
1196 HWTEST_F(ImsCallbackStubTest, cellular_call_ImsCallCallbackStub_0023, Function | MediumTest | Level3)
1197 {
1198 sptr<ImsCallCallbackStub> stubTestEleven = (std::make_unique<ImsCallCallbackStub>()).release();
1199 ASSERT_TRUE(stubTestEleven != nullptr);
1200 for (int32_t slotId = 0; slotId < SLOT_COUNT; slotId++) {
1201 MessageParcel callModeReceiveRequestData;
1202 MessageParcel callModeReceiveRequestReply;
1203 ImsCallModeReceiveInfo callModeReceiveRequesInfo;
1204 callModeReceiveRequesInfo.callIndex = DEFAULT_INDEX;
1205 ASSERT_TRUE(callModeReceiveRequestData.WriteInt32(slotId));
1206 ASSERT_TRUE(callModeReceiveRequestData.WriteRawData(
1207 (const void *)&callModeReceiveRequesInfo, sizeof(ImsCallModeReceiveInfo)));
1208 ASSERT_EQ(stubTestEleven->OnReceiveUpdateCallMediaModeRequestInner(
1209 callModeReceiveRequestData, callModeReceiveRequestReply), TELEPHONY_SUCCESS);
1210 MessageParcel callModeReceiveResponseData;
1211 MessageParcel callModeReceiveResponseReply;
1212 ImsCallModeReceiveInfo callModeReceiveResponseInfo;
1213 callModeReceiveResponseInfo.callIndex = DEFAULT_INDEX;
1214 ASSERT_TRUE(callModeReceiveResponseData.WriteInt32(slotId));
1215 ASSERT_TRUE(callModeReceiveResponseData.WriteRawData(
1216 (const void *)&callModeReceiveResponseInfo, sizeof(ImsCallModeReceiveInfo)));
1217 ASSERT_EQ(stubTestEleven->OnReceiveUpdateCallMediaModeResponseInner(
1218 callModeReceiveResponseData, callModeReceiveResponseReply), TELEPHONY_SUCCESS);
1219 MessageParcel callSessionEventInfoData;
1220 MessageParcel callSessionEventInfoReply;
1221 ImsCallSessionEventInfo callSessionEventInfo;
1222 callSessionEventInfo.callIndex = DEFAULT_INDEX;
1223 ASSERT_TRUE(callSessionEventInfoData.WriteInt32(slotId));
1224 ASSERT_TRUE(callSessionEventInfoData.WriteRawData(
1225 (const void *)&callSessionEventInfo, sizeof(ImsCallSessionEventInfo)));
1226 ASSERT_EQ(stubTestEleven->OnCallSessionEventChangedInner(
1227 callSessionEventInfoData, callSessionEventInfoReply), TELEPHONY_SUCCESS);
1228 }
1229 }
1230
1231 /**
1232 * @tc.number cellular_call_ImsCallCallbackStub_0024
1233 * @tc.name Test for ImsCallCallbackStub
1234 * @tc.desc Function test
1235 */
1236 HWTEST_F(ImsCallbackStubTest, cellular_call_ImsCallCallbackStub_0024, Function | MediumTest | Level3)
1237 {
1238 sptr<ImsCallCallbackStub> stubTestEleven = (std::make_unique<ImsCallCallbackStub>()).release();
1239 ASSERT_TRUE(stubTestEleven != nullptr);
1240 for (int32_t slotId = 0; slotId < SLOT_COUNT; slotId++) {
1241 MessageParcel callPeerDimensionsInfoData;
1242 MessageParcel callPeerDimensionsInfoReply;
1243 ImsCallPeerDimensionsInfo callPeerDimensionsInfo;
1244 callPeerDimensionsInfo.callIndex = DEFAULT_INDEX;
1245 ASSERT_TRUE(callPeerDimensionsInfoData.WriteInt32(slotId));
1246 ASSERT_TRUE(callPeerDimensionsInfoData.WriteRawData(
1247 (const void *)&callPeerDimensionsInfo, sizeof(ImsCallPeerDimensionsInfo)));
1248 ASSERT_EQ(stubTestEleven->OnPeerDimensionsChangedInner(
1249 callPeerDimensionsInfoData, callPeerDimensionsInfoReply), TELEPHONY_SUCCESS);
1250 MessageParcel callDataUsageInfoData;
1251 MessageParcel callDataUsageInfoReply;
1252 ImsCallDataUsageInfo callDataUsageInfo;
1253 callDataUsageInfo.callIndex = DEFAULT_INDEX;
1254 ASSERT_TRUE(callDataUsageInfoData.WriteInt32(slotId));
1255 ASSERT_TRUE(callDataUsageInfoData.WriteRawData(
1256 (const void *)&callDataUsageInfo, sizeof(ImsCallDataUsageInfo)));
1257 ASSERT_EQ(stubTestEleven->OnCallDataUsageChangedInner(
1258 callDataUsageInfoData, callDataUsageInfoReply), TELEPHONY_SUCCESS);
1259 MessageParcel cameraCapabilitiesInfoData;
1260 MessageParcel cameraCapabilitiesInfoReply;
1261 CameraCapabilitiesInfo cameraCapabilitiesInfo;
1262 cameraCapabilitiesInfo.callIndex = DEFAULT_INDEX;
1263 ASSERT_TRUE(cameraCapabilitiesInfoData.WriteInt32(slotId));
1264 ASSERT_TRUE(cameraCapabilitiesInfoData.WriteRawData(
1265 (const void *)&cameraCapabilitiesInfo, sizeof(CameraCapabilitiesInfo)));
1266 ASSERT_EQ(stubTestEleven->OnCameraCapabilitiesChangedInner(
1267 cameraCapabilitiesInfoData, cameraCapabilitiesInfoReply), TELEPHONY_SUCCESS);
1268 }
1269 }
1270 } // namespace Telephony
1271 } // namespace OHOS
1272