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