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