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 "hril_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 std::string PHONE_NUMBER = "0000000"; 38 const int32_t DEFAULT_INDEX = 1; 39 40 /** 41 * @tc.number cellular_call_ImsCallCallbackProxy_0001 42 * @tc.name Test for ImsCallCallbackProxy 43 * @tc.desc Function test 44 */ 45 HWTEST_F(ImsTest, cellular_call_ImsCallCallbackProxy_0001, Function | MediumTest | Level3) 46 { 47 const sptr<ImsCallCallbackInterface> imsCallCallback_ = (std::make_unique<ImsCallCallbackStub>()).release(); 48 auto callCallbackProxy = 49 (std::make_unique<ImsCallCallbackProxy>(imsCallCallback_->AsObject().GetRefPtr())).release(); 50 ASSERT_TRUE(callCallbackProxy != nullptr); 51 for (int32_t slotId = 0; slotId < SIM_SLOT_COUNT; slotId++) { 52 if (!HasSimCard(slotId)) { 53 continue; 54 } 55 EventFwk::MatchingSkills matchingSkills; 56 matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_OPERATOR_CONFIG_CHANGED); 57 EventFwk::CommonEventSubscribeInfo subscriberInfo(matchingSkills); 58 auto handler = std::make_shared<CellularCallHandler>(subscriberInfo); 59 handler->SetSlotId(slotId); 60 handler->RegisterImsCallCallbackHandler(); 61 HRilRadioResponseInfo rilRadioResponse; 62 rilRadioResponse.error = HRilErrType::HRIL_ERR_GENERIC_FAILURE; 63 ASSERT_EQ(callCallbackProxy->DialResponse(slotId, rilRadioResponse), TELEPHONY_SUCCESS); 64 ASSERT_EQ(callCallbackProxy->HangUpResponse(slotId, rilRadioResponse), TELEPHONY_SUCCESS); 65 ASSERT_EQ(callCallbackProxy->RejectWithReasonResponse(slotId, rilRadioResponse), TELEPHONY_SUCCESS); 66 ASSERT_EQ(callCallbackProxy->AnswerResponse(slotId, rilRadioResponse), TELEPHONY_SUCCESS); 67 ASSERT_EQ(callCallbackProxy->HoldCallResponse(slotId, rilRadioResponse), TELEPHONY_SUCCESS); 68 ASSERT_EQ(callCallbackProxy->UnHoldCallResponse(slotId, rilRadioResponse), TELEPHONY_SUCCESS); 69 ASSERT_EQ(callCallbackProxy->SwitchCallResponse(slotId, rilRadioResponse), TELEPHONY_SUCCESS); 70 ASSERT_EQ(callCallbackProxy->StartDtmfResponse(slotId, rilRadioResponse), TELEPHONY_SUCCESS); 71 ASSERT_GE(callCallbackProxy->SendDtmfResponse(slotId, rilRadioResponse, DEFAULT_INDEX), TELEPHONY_SUCCESS); 72 ASSERT_EQ(callCallbackProxy->StopDtmfResponse(slotId, rilRadioResponse), TELEPHONY_SUCCESS); 73 ASSERT_EQ(callCallbackProxy->SetImsSwitchResponse(slotId, rilRadioResponse), TELEPHONY_SUCCESS); 74 ASSERT_EQ(callCallbackProxy->GetImsSwitchResponse(slotId, rilRadioResponse), TELEPHONY_SUCCESS); 75 ASSERT_EQ(callCallbackProxy->GetImsCallsDataResponse(slotId, rilRadioResponse), TELEPHONY_SUCCESS); 76 ASSERT_EQ(callCallbackProxy->CallStateChangeReport(slotId), TELEPHONY_SUCCESS); 77 ImsCurrentCallList imsCallList; 78 imsCallList.callSize = 0; 79 ASSERT_EQ(callCallbackProxy->GetImsCallsDataResponse(slotId, imsCallList), TELEPHONY_SUCCESS); 80 DisconnectedDetails details; 81 ASSERT_EQ(callCallbackProxy->LastCallFailReasonResponse(slotId, details), TELEPHONY_SUCCESS); 82 RingbackVoice ringback; 83 ASSERT_EQ(callCallbackProxy->CallRingBackReport(slotId, ringback), TELEPHONY_SUCCESS); 84 int32_t active = 0; 85 ASSERT_EQ(callCallbackProxy->GetImsSwitchResponse(slotId, active), TELEPHONY_SUCCESS); 86 MuteControlResponse muteResponse; 87 ASSERT_EQ(callCallbackProxy->SetMuteResponse(slotId, muteResponse), TELEPHONY_SUCCESS); 88 ASSERT_EQ(callCallbackProxy->CombineConferenceResponse(slotId, rilRadioResponse), TELEPHONY_SUCCESS); 89 ASSERT_EQ(callCallbackProxy->InviteToConferenceResponse(slotId, rilRadioResponse), TELEPHONY_SUCCESS); 90 } 91 } 92 93 /** 94 * @tc.number cellular_call_ImsCallCallbackProxy_0002 95 * @tc.name Test for ImsCallCallbackProxy 96 * @tc.desc Function test 97 */ 98 HWTEST_F(ImsTest, cellular_call_ImsCallCallbackProxy_0002, Function | MediumTest | Level3) 99 { 100 const sptr<ImsCallCallbackInterface> imsCallCallback_ = (std::make_unique<ImsCallCallbackStub>()).release(); 101 auto callCallbackProxy = 102 (std::make_unique<ImsCallCallbackProxy>(imsCallCallback_->AsObject().GetRefPtr())).release(); 103 ASSERT_TRUE(callCallbackProxy != nullptr); 104 for (int32_t slotId = 0; slotId < SIM_SLOT_COUNT; slotId++) { 105 if (!HasSimCard(slotId)) { 106 continue; 107 } 108 EventFwk::MatchingSkills matchingSkills; 109 matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_OPERATOR_CONFIG_CHANGED); 110 EventFwk::CommonEventSubscribeInfo subscriberInfo(matchingSkills); 111 auto handler = std::make_shared<CellularCallHandler>(subscriberInfo); 112 handler->SetSlotId(slotId); 113 handler->RegisterImsCallCallbackHandler(); 114 GetClipResult clipResult; 115 clipResult.result.index = INVALID_INDEX; 116 ASSERT_EQ(callCallbackProxy->GetClipResponse(slotId, clipResult), TELEPHONY_SUCCESS); 117 GetClirResult clirResult; 118 clirResult.result.index = INVALID_INDEX; 119 ASSERT_EQ(callCallbackProxy->GetClirResponse(slotId, clirResult), TELEPHONY_SUCCESS); 120 SsBaseResult normalResult; 121 normalResult.index = DEFAULT_INDEX; 122 ASSERT_EQ(callCallbackProxy->SetClipResponse(slotId, normalResult), TELEPHONY_SUCCESS); 123 ASSERT_EQ(callCallbackProxy->SetClirResponse(slotId, normalResult), TELEPHONY_SUCCESS); 124 ASSERT_EQ(callCallbackProxy->SetCallTransferResponse(slotId, normalResult), TELEPHONY_SUCCESS); 125 ASSERT_EQ(callCallbackProxy->SetCallRestrictionResponse(slotId, normalResult), TELEPHONY_SUCCESS); 126 ASSERT_EQ(callCallbackProxy->SetCallWaitingResponse(slotId, normalResult), TELEPHONY_SUCCESS); 127 ASSERT_EQ(callCallbackProxy->SetColrResponse(slotId, normalResult), TELEPHONY_SUCCESS); 128 ASSERT_EQ(callCallbackProxy->SetColpResponse(slotId, normalResult), TELEPHONY_SUCCESS); 129 CallForwardQueryInfoList callList; 130 callList.result.index = INVALID_INDEX; 131 ASSERT_EQ(callCallbackProxy->GetCallTransferResponse(slotId, callList), TELEPHONY_SUCCESS); 132 CallRestrictionResult crResult; 133 crResult.result.index = INVALID_INDEX; 134 ASSERT_EQ(callCallbackProxy->GetCallRestrictionResponse(slotId, crResult), TELEPHONY_SUCCESS); 135 CallWaitResult cwResult; 136 cwResult.result.index = INVALID_INDEX; 137 ASSERT_EQ(callCallbackProxy->GetCallWaitingResponse(slotId, cwResult), TELEPHONY_SUCCESS); 138 GetColrResult colrResult; 139 colrResult.result.index = INVALID_INDEX; 140 ASSERT_EQ(callCallbackProxy->GetColrResponse(slotId, colrResult), TELEPHONY_SUCCESS); 141 GetColpResult colpResult; 142 colpResult.result.index = INVALID_INDEX; 143 ASSERT_EQ(callCallbackProxy->GetColpResponse(slotId, colpResult), TELEPHONY_SUCCESS); 144 } 145 } 146 147 /** 148 * @tc.number cellular_call_ImsCallCallbackProxy_0003 149 * @tc.name Test for ImsCallCallbackProxy 150 * @tc.desc Function test 151 */ 152 HWTEST_F(ImsTest, cellular_call_ImsCallCallbackProxy_0003, Function | MediumTest | Level3) 153 { 154 const sptr<ImsCallCallbackInterface> imsCallCallback_ = (std::make_unique<ImsCallCallbackStub>()).release(); 155 auto callCallbackProxy = 156 (std::make_unique<ImsCallCallbackProxy>(imsCallCallback_->AsObject().GetRefPtr())).release(); 157 ASSERT_TRUE(callCallbackProxy != nullptr); 158 for (int32_t slotId = 0; slotId < SIM_SLOT_COUNT; slotId++) { 159 if (!HasSimCard(slotId)) { 160 continue; 161 } 162 EventFwk::MatchingSkills matchingSkills; 163 matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_OPERATOR_CONFIG_CHANGED); 164 EventFwk::CommonEventSubscribeInfo subscriberInfo(matchingSkills); 165 auto handler = std::make_shared<CellularCallHandler>(subscriberInfo); 166 handler->SetSlotId(slotId); 167 handler->RegisterImsCallCallbackHandler(); 168 ImsCallModeReceiveInfo callModeReceiveInfo; 169 callModeReceiveInfo.callIndex = DEFAULT_INDEX; 170 ASSERT_EQ( 171 callCallbackProxy->ReceiveUpdateCallMediaModeResponse(slotId, callModeReceiveInfo), TELEPHONY_SUCCESS); 172 ASSERT_EQ( 173 callCallbackProxy->ReceiveUpdateCallMediaModeRequest(slotId, callModeReceiveInfo), TELEPHONY_SUCCESS); 174 ImsCallSessionEventInfo callSessionEventInfo; 175 callSessionEventInfo.callIndex = DEFAULT_INDEX; 176 ASSERT_EQ(callCallbackProxy->CallSessionEventChanged(slotId, callSessionEventInfo), TELEPHONY_SUCCESS); 177 ImsCallPeerDimensionsInfo callPeerDimensionsInfo; 178 callPeerDimensionsInfo.callIndex = DEFAULT_INDEX; 179 ASSERT_EQ(callCallbackProxy->PeerDimensionsChanged(slotId, callPeerDimensionsInfo), TELEPHONY_SUCCESS); 180 ImsCallDataUsageInfo callDataUsageInfo; 181 callDataUsageInfo.callIndex = DEFAULT_INDEX; 182 ASSERT_EQ(callCallbackProxy->CallDataUsageChanged(slotId, callDataUsageInfo), TELEPHONY_SUCCESS); 183 CameraCapabilitiesInfo cameraCapabilitiesInfo; 184 cameraCapabilitiesInfo.callIndex = DEFAULT_INDEX; 185 ASSERT_EQ(callCallbackProxy->CameraCapabilitiesChanged(slotId, cameraCapabilitiesInfo), TELEPHONY_SUCCESS); 186 } 187 } 188 189 /** 190 * @tc.number cellular_call_ImsCallCallbackStub_0001 191 * @tc.name Test for ImsCallCallbackStub 192 * @tc.desc Function test 193 */ 194 HWTEST_F(ImsTest, cellular_call_ImsCallCallbackStub_0001, Function | MediumTest | Level3) 195 { 196 sptr<ImsCallCallbackStub> stub = (std::make_unique<ImsCallCallbackStub>()).release(); 197 ASSERT_TRUE(stub != nullptr); 198 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) { 199 return; 200 } 201 for (int32_t slotId = 0; slotId < SIM_SLOT_COUNT; slotId++) { 202 if (!HasSimCard(slotId)) { 203 continue; 204 } 205 HRilRadioResponseInfo rilRadioResponse; 206 rilRadioResponse.error = HRilErrType::HRIL_ERR_GENERIC_FAILURE; 207 MessageParcel answerData; 208 MessageParcel answerReply; 209 ASSERT_TRUE(answerData.WriteInt32(slotId)); 210 ASSERT_TRUE(answerData.WriteRawData((const void *)&rilRadioResponse, sizeof(HRilRadioResponseInfo))); 211 ASSERT_EQ(stub->OnAnswerResponseInner(answerData, answerReply), TELEPHONY_SUCCESS); 212 213 MessageParcel dialData; 214 MessageParcel dialReply; 215 ASSERT_TRUE(dialData.WriteInt32(slotId)); 216 ASSERT_TRUE(dialData.WriteRawData((const void *)&rilRadioResponse, sizeof(HRilRadioResponseInfo))); 217 ASSERT_EQ(stub->OnDialResponseInner(dialData, dialReply), TELEPHONY_SUCCESS); 218 219 MessageParcel imsCallsData; 220 MessageParcel imsCallsReply; 221 ASSERT_TRUE(imsCallsData.WriteInt32(slotId)); 222 ASSERT_TRUE(imsCallsData.WriteRawData((const void *)&rilRadioResponse, sizeof(HRilRadioResponseInfo))); 223 ASSERT_EQ(stub->OnGetImsCallsDataResponseInner(imsCallsData, imsCallsReply), TELEPHONY_SUCCESS); 224 225 MessageParcel hangupData; 226 MessageParcel hangupReply; 227 ASSERT_TRUE(hangupData.WriteInt32(slotId)); 228 ASSERT_TRUE(hangupData.WriteRawData((const void *)&rilRadioResponse, sizeof(HRilRadioResponseInfo))); 229 ASSERT_EQ(stub->OnHangUpResponseInner(hangupData, hangupReply), TELEPHONY_SUCCESS); 230 231 MessageParcel holdCallData; 232 MessageParcel holdCallReply; 233 ASSERT_TRUE(holdCallData.WriteInt32(slotId)); 234 ASSERT_TRUE(holdCallData.WriteRawData((const void *)&rilRadioResponse, sizeof(HRilRadioResponseInfo))); 235 ASSERT_EQ(stub->OnHoldCallResponseInner(holdCallData, holdCallReply), TELEPHONY_SUCCESS); 236 237 MessageParcel rejectData; 238 MessageParcel rejectReply; 239 ASSERT_TRUE(rejectData.WriteInt32(slotId)); 240 ASSERT_TRUE(rejectData.WriteRawData((const void *)&rilRadioResponse, sizeof(HRilRadioResponseInfo))); 241 ASSERT_EQ(stub->OnRejectResponseInner(rejectData, rejectReply), TELEPHONY_SUCCESS); 242 } 243 } 244 245 /** 246 * @tc.number cellular_call_ImsCallCallbackStub_0002 247 * @tc.name Test for ImsCallCallbackStub 248 * @tc.desc Function test 249 */ 250 HWTEST_F(ImsTest, cellular_call_ImsCallCallbackStub_0002, Function | MediumTest | Level3) 251 { 252 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) { 253 return; 254 } 255 sptr<ImsCallCallbackStub> stubTestTwo = (std::make_unique<ImsCallCallbackStub>()).release(); 256 ASSERT_TRUE(stubTestTwo != nullptr); 257 for (int32_t slotId = 0; slotId < SIM_SLOT_COUNT; slotId++) { 258 if (!HasSimCard(slotId)) { 259 continue; 260 } 261 HRilRadioResponseInfo rilRadioResponse; 262 rilRadioResponse.error = HRilErrType::HRIL_ERR_GENERIC_FAILURE; 263 MessageParcel sendDtmfData; 264 MessageParcel sendDtmfReply; 265 ASSERT_TRUE(sendDtmfData.WriteInt32(slotId)); 266 ASSERT_TRUE(sendDtmfData.WriteRawData((const void *)&rilRadioResponse, sizeof(HRilRadioResponseInfo))); 267 ASSERT_GE(stubTestTwo->OnSendDtmfResponseInner(sendDtmfData, sendDtmfReply), TELEPHONY_SUCCESS); 268 269 MessageParcel setImsSwitchData; 270 MessageParcel setImsSwitchReply; 271 ASSERT_TRUE(setImsSwitchData.WriteInt32(slotId)); 272 ASSERT_TRUE(setImsSwitchData.WriteRawData((const void *)&rilRadioResponse, sizeof(HRilRadioResponseInfo))); 273 ASSERT_EQ(stubTestTwo->OnSetImsSwitchResponseInner(setImsSwitchData, setImsSwitchReply), TELEPHONY_SUCCESS); 274 275 MessageParcel startDtmfData; 276 MessageParcel startDtmfReply; 277 ASSERT_TRUE(startDtmfData.WriteInt32(slotId)); 278 ASSERT_TRUE(startDtmfData.WriteRawData((const void *)&rilRadioResponse, sizeof(HRilRadioResponseInfo))); 279 ASSERT_EQ(stubTestTwo->OnStartDtmfResponseInner(startDtmfData, startDtmfReply), TELEPHONY_SUCCESS); 280 281 MessageParcel stopDtmfData; 282 MessageParcel stopDtmfReply; 283 ASSERT_TRUE(stopDtmfData.WriteInt32(slotId)); 284 ASSERT_TRUE(stopDtmfData.WriteRawData((const void *)&rilRadioResponse, sizeof(HRilRadioResponseInfo))); 285 ASSERT_EQ(stubTestTwo->OnStopDtmfResponseInner(stopDtmfData, stopDtmfReply), TELEPHONY_SUCCESS); 286 287 MessageParcel switchCallData; 288 MessageParcel switchCallReply; 289 ASSERT_TRUE(switchCallData.WriteInt32(slotId)); 290 ASSERT_TRUE(switchCallData.WriteRawData((const void *)&rilRadioResponse, sizeof(HRilRadioResponseInfo))); 291 ASSERT_EQ(stubTestTwo->OnSwitchCallResponseInner(switchCallData, switchCallReply), TELEPHONY_SUCCESS); 292 293 MessageParcel unholdData; 294 MessageParcel unholdReply; 295 ASSERT_TRUE(unholdData.WriteInt32(slotId)); 296 ASSERT_TRUE(unholdData.WriteRawData((const void *)&rilRadioResponse, sizeof(HRilRadioResponseInfo))); 297 ASSERT_EQ(stubTestTwo->OnUnHoldCallResponseInner(unholdData, unholdReply), TELEPHONY_SUCCESS); 298 299 MessageParcel getImsSwitchData; 300 MessageParcel getImsSwitchReply; 301 ASSERT_TRUE(getImsSwitchData.WriteInt32(slotId)); 302 ASSERT_TRUE(getImsSwitchData.WriteRawData((const void *)&rilRadioResponse, sizeof(HRilRadioResponseInfo))); 303 ASSERT_EQ(stubTestTwo->OnGetImsSwitchResponseInner(getImsSwitchData, getImsSwitchReply), TELEPHONY_SUCCESS); 304 } 305 } 306 307 /** 308 * @tc.number cellular_call_ImsCallCallbackStub_0003 309 * @tc.name Test for ImsCallCallbackStub 310 * @tc.desc Function test 311 */ 312 HWTEST_F(ImsTest, cellular_call_ImsCallCallbackStub_0003, Function | MediumTest | Level3) 313 { 314 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) { 315 return; 316 } 317 318 sptr<ImsCallCallbackStub> stubTestThree = (std::make_unique<ImsCallCallbackStub>()).release(); 319 ASSERT_TRUE(stubTestThree != nullptr); 320 for (int32_t slotId = 0; slotId < SIM_SLOT_COUNT; slotId++) { 321 if (!HasSimCard(slotId)) { 322 continue; 323 } 324 MessageParcel data; 325 MessageParcel reply; 326 ASSERT_TRUE(data.WriteInt32(slotId)); 327 ASSERT_NE(stubTestThree->OnAnswerResponseInner(data, reply), TELEPHONY_SUCCESS); 328 ASSERT_NE(stubTestThree->OnCallRingBackReportInner(data, reply), TELEPHONY_SUCCESS); 329 ASSERT_NE(stubTestThree->OnDialResponseInner(data, reply), TELEPHONY_SUCCESS); 330 ASSERT_NE(stubTestThree->OnHangUpResponseInner(data, reply), TELEPHONY_SUCCESS); 331 ASSERT_NE(stubTestThree->OnHoldCallResponseInner(data, reply), TELEPHONY_SUCCESS); 332 ASSERT_NE(stubTestThree->OnRejectResponseInner(data, reply), TELEPHONY_SUCCESS); 333 ASSERT_NE(stubTestThree->OnSendDtmfResponseInner(data, reply), TELEPHONY_SUCCESS); 334 ASSERT_NE(stubTestThree->OnSetImsSwitchResponseInner(data, reply), TELEPHONY_SUCCESS); 335 ASSERT_NE(stubTestThree->OnStartDtmfResponseInner(data, reply), TELEPHONY_SUCCESS); 336 ASSERT_NE(stubTestThree->OnStopDtmfResponseInner(data, reply), TELEPHONY_SUCCESS); 337 ASSERT_NE(stubTestThree->OnSwitchCallResponseInner(data, reply), TELEPHONY_SUCCESS); 338 ASSERT_NE(stubTestThree->OnUnHoldCallResponseInner(data, reply), TELEPHONY_SUCCESS); 339 ASSERT_NE(stubTestThree->OnSetMuteResponseInner(data, reply), TELEPHONY_SUCCESS); 340 ASSERT_NE(stubTestThree->OnCombineConferenceResponseInner(data, reply), TELEPHONY_SUCCESS); 341 ASSERT_NE(stubTestThree->OnInviteToConferenceResponseInner(data, reply), TELEPHONY_SUCCESS); 342 ASSERT_NE(stubTestThree->OnReceiveUpdateCallMediaModeRequestInner(data, reply), TELEPHONY_SUCCESS); 343 ASSERT_NE(stubTestThree->OnReceiveUpdateCallMediaModeResponseInner(data, reply), TELEPHONY_SUCCESS); 344 ASSERT_NE(stubTestThree->OnCallSessionEventChangedInner(data, reply), TELEPHONY_SUCCESS); 345 ASSERT_NE(stubTestThree->OnPeerDimensionsChangedInner(data, reply), TELEPHONY_SUCCESS); 346 ASSERT_NE(stubTestThree->OnCallDataUsageChangedInner(data, reply), TELEPHONY_SUCCESS); 347 ASSERT_NE(stubTestThree->OnCameraCapabilitiesChangedInner(data, reply), TELEPHONY_SUCCESS); 348 } 349 } 350 351 /** 352 * @tc.number cellular_call_ImsCallCallbackStub_0004 353 * @tc.name Test for ImsCallCallbackStub 354 * @tc.desc Function test 355 */ 356 HWTEST_F(ImsTest, cellular_call_ImsCallCallbackStub_0004, Function | MediumTest | Level3) 357 { 358 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) { 359 return; 360 } 361 sptr<ImsCallCallbackStub> stubTestFour = (std::make_unique<ImsCallCallbackStub>()).release(); 362 ASSERT_TRUE(stubTestFour != 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 = DEFAULT_INDEX; 369 MessageParcel crData; 370 MessageParcel crReply; 371 ASSERT_TRUE(crData.WriteInt32(slotId)); 372 ASSERT_EQ(WriteSsBaseResult(crData, normalResult), TELEPHONY_SUCCESS); 373 ASSERT_EQ(stubTestFour->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(stubTestFour->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(stubTestFour->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(stubTestFour->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(stubTestFour->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(stubTestFour->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(stubTestFour->OnSetColrResponseInner(colrData, colrReply), TELEPHONY_SUCCESS); 404 } 405 } 406 407 /** 408 * @tc.number cellular_call_ImsCallCallbackStub_0005 409 * @tc.name Test for ImsCallCallbackStub 410 * @tc.desc Function test 411 */ 412 HWTEST_F(ImsTest, cellular_call_ImsCallCallbackStub_0005, Function | MediumTest | Level3) 413 { 414 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) { 415 return; 416 } 417 sptr<ImsCallCallbackStub> stubTestFive = (std::make_unique<ImsCallCallbackStub>()).release(); 418 ASSERT_TRUE(stubTestFive != nullptr); 419 for (int32_t slotId = 0; slotId < SIM_SLOT_COUNT; slotId++) { 420 if (!HasSimCard(slotId)) { 421 continue; 422 } 423 SsBaseResult normalResult; 424 normalResult.index = INVALID_INDEX; 425 MessageParcel crData; 426 MessageParcel crReply; 427 ASSERT_TRUE(crData.WriteInt32(slotId)); 428 ASSERT_EQ(WriteSsBaseResult(crData, normalResult), TELEPHONY_SUCCESS); 429 ASSERT_EQ(stubTestFive->OnSetCallRestrictionResponseInner(crData, crReply), TELEPHONY_SUCCESS); 430 MessageParcel ctData; 431 MessageParcel ctReply; 432 ASSERT_TRUE(ctData.WriteInt32(slotId)); 433 ASSERT_EQ(WriteSsBaseResult(ctData, normalResult), TELEPHONY_SUCCESS); 434 ASSERT_EQ(stubTestFive->OnSetCallTransferResponseInner(ctData, ctReply), TELEPHONY_SUCCESS); 435 MessageParcel cwData; 436 MessageParcel cwReply; 437 ASSERT_TRUE(cwData.WriteInt32(slotId)); 438 ASSERT_EQ(WriteSsBaseResult(cwData, normalResult), TELEPHONY_SUCCESS); 439 ASSERT_EQ(stubTestFive->OnSetCallWaitingResponseInner(cwData, cwReply), TELEPHONY_SUCCESS); 440 MessageParcel clipData; 441 MessageParcel clipReply; 442 ASSERT_TRUE(clipData.WriteInt32(slotId)); 443 ASSERT_EQ(WriteSsBaseResult(clipData, normalResult), TELEPHONY_SUCCESS); 444 ASSERT_EQ(stubTestFive->OnSetClipResponseInner(clipData, clipReply), TELEPHONY_SUCCESS); 445 MessageParcel clirData; 446 MessageParcel clirReply; 447 ASSERT_TRUE(clirData.WriteInt32(slotId)); 448 ASSERT_EQ(WriteSsBaseResult(clirData, normalResult), TELEPHONY_SUCCESS); 449 ASSERT_EQ(stubTestFive->OnSetClirResponseInner(clirData, clirReply), TELEPHONY_SUCCESS); 450 MessageParcel colpData; 451 MessageParcel colpReply; 452 ASSERT_TRUE(colpData.WriteInt32(slotId)); 453 ASSERT_EQ(WriteSsBaseResult(colpData, normalResult), TELEPHONY_SUCCESS); 454 ASSERT_EQ(stubTestFive->OnSetColpResponseInner(colpData, colpReply), TELEPHONY_SUCCESS); 455 MessageParcel colrData; 456 MessageParcel colrReply; 457 ASSERT_TRUE(colrData.WriteInt32(slotId)); 458 ASSERT_EQ(WriteSsBaseResult(colrData, normalResult), TELEPHONY_SUCCESS); 459 ASSERT_EQ(stubTestFive->OnSetColrResponseInner(colrData, colrReply), TELEPHONY_SUCCESS); 460 } 461 } 462 463 /** 464 * @tc.number cellular_call_ImsCallCallbackStub_0006 465 * @tc.name Test for ImsCallCallbackStub 466 * @tc.desc Function test 467 */ 468 HWTEST_F(ImsTest, cellular_call_ImsCallCallbackStub_0006, Function | MediumTest | Level3) 469 { 470 sptr<ImsCallCallbackStub> stubTestSix = (std::make_unique<ImsCallCallbackStub>()).release(); 471 ASSERT_TRUE(stubTestSix != nullptr); 472 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) { 473 return; 474 } 475 for (int32_t slotId = 0; slotId < SIM_SLOT_COUNT; slotId++) { 476 if (!HasSimCard(slotId)) { 477 continue; 478 } 479 SsBaseResult ssBaseResult; 480 ssBaseResult.index = DEFAULT_INDEX; 481 ssBaseResult.result = IMS_ERROR_UT_CS_FALLBACK; 482 ASSERT_NE(stubTestSix->SetCallRestrictionResponse(slotId, ssBaseResult), TELEPHONY_SUCCESS); 483 ASSERT_NE(stubTestSix->SetCallTransferResponse(slotId, ssBaseResult), TELEPHONY_SUCCESS); 484 ASSERT_NE(stubTestSix->SetCallWaitingResponse(slotId, ssBaseResult), TELEPHONY_SUCCESS); 485 ASSERT_NE(stubTestSix->SetClirResponse(slotId, ssBaseResult), TELEPHONY_SUCCESS); 486 MessageParcel muteData; 487 MessageParcel muteReply; 488 MuteControlResponse muteResponse; 489 ASSERT_TRUE(muteData.WriteInt32(slotId)); 490 ASSERT_TRUE(muteData.WriteRawData((const void *)&muteResponse, sizeof(MuteControlResponse))); 491 ASSERT_EQ(stubTestSix->OnSetMuteResponseInner(muteData, muteReply), TELEPHONY_SUCCESS); 492 MessageParcel ringData; 493 MessageParcel ringReply; 494 RingbackVoice ringback; 495 ASSERT_TRUE(ringData.WriteInt32(slotId)); 496 ASSERT_TRUE(ringData.WriteRawData((const void *)&ringback, sizeof(RingbackVoice))); 497 ASSERT_EQ(stubTestSix->OnCallRingBackReportInner(ringData, ringReply), TELEPHONY_SUCCESS); 498 MessageParcel failData; 499 MessageParcel failReply; 500 DisconnectedDetails details; 501 ASSERT_TRUE(failData.WriteInt32(slotId)); 502 ASSERT_TRUE(failData.WriteInt32(static_cast<int32_t>(details.reason))); 503 ASSERT_TRUE(failData.WriteString(details.message)); 504 ASSERT_EQ(stubTestSix->OnLastCallFailReasonResponseInner(failData, failReply), TELEPHONY_SUCCESS); 505 } 506 } 507 508 /** 509 * @tc.number cellular_call_ImsCallCallbackStub_0007 510 * @tc.name Test for ImsCallCallbackStub 511 * @tc.desc Function test 512 */ 513 HWTEST_F(ImsTest, cellular_call_ImsCallCallbackStub_0007, Function | MediumTest | Level3) 514 { 515 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) { 516 return; 517 } 518 sptr<ImsCallCallbackStub> stubTestSeven = (std::make_unique<ImsCallCallbackStub>()).release(); 519 ASSERT_TRUE(stubTestSeven != nullptr); 520 for (int32_t slotId = 0; slotId < SIM_SLOT_COUNT; slotId++) { 521 if (!HasSimCard(slotId)) { 522 continue; 523 } 524 CallRestrictionResult crResult; 525 crResult.result.index = INVALID_INDEX; 526 MessageParcel crErrorData; 527 MessageParcel crErrorReply; 528 ASSERT_TRUE(crErrorData.WriteInt32(slotId)); 529 ASSERT_EQ(WriteSsResult(crErrorData, crResult.result, crResult.status, crResult.classCw), TELEPHONY_SUCCESS); 530 ASSERT_EQ(stubTestSeven->OnGetCallRestrictionResponseInner(crErrorData, crErrorReply), TELEPHONY_SUCCESS); 531 532 crResult.result.index = DEFAULT_INDEX; 533 MessageParcel crData; 534 MessageParcel crReply; 535 ASSERT_TRUE(crData.WriteInt32(slotId)); 536 ASSERT_EQ(WriteSsResult(crData, crResult.result, crResult.status, crResult.classCw), TELEPHONY_SUCCESS); 537 ASSERT_EQ(stubTestSeven->OnGetCallRestrictionResponseInner(crData, crReply), TELEPHONY_SUCCESS); 538 crResult.result.result = IMS_ERROR_UT_CS_FALLBACK; 539 ASSERT_NE(stubTestSeven->GetCallRestrictionResponse(slotId, crResult), TELEPHONY_SUCCESS); 540 541 CallForwardQueryInfoList callList; 542 callList.result.index = INVALID_INDEX; 543 MessageParcel ctErrorData; 544 MessageParcel ctErrorReply; 545 ASSERT_TRUE(ctErrorData.WriteInt32(slotId)); 546 ASSERT_EQ(WriteCallForwardResult(ctErrorData, callList), TELEPHONY_SUCCESS); 547 ASSERT_EQ(stubTestSeven->OnGetCallTransferResponseInner(ctErrorData, ctErrorReply), TELEPHONY_SUCCESS); 548 549 callList.result.index = DEFAULT_INDEX; 550 MessageParcel ctData; 551 MessageParcel ctReply; 552 ASSERT_TRUE(ctData.WriteInt32(slotId)); 553 ASSERT_EQ(WriteCallForwardResult(ctData, callList), TELEPHONY_SUCCESS); 554 ASSERT_EQ(stubTestSeven->OnGetCallTransferResponseInner(ctData, ctReply), TELEPHONY_SUCCESS); 555 callList.result.result = IMS_ERROR_UT_CS_FALLBACK; 556 ASSERT_NE(stubTestSeven->GetCallTransferResponse(slotId, callList), TELEPHONY_SUCCESS); 557 } 558 } 559 560 /** 561 * @tc.number cellular_call_ImsCallCallbackStub_0008 562 * @tc.name Test for ImsCallCallbackStub 563 * @tc.desc Function test 564 */ 565 HWTEST_F(ImsTest, cellular_call_ImsCallCallbackStub_0008, Function | MediumTest | Level3) 566 { 567 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) { 568 return; 569 } 570 sptr<ImsCallCallbackStub> stubTestEigth = (std::make_unique<ImsCallCallbackStub>()).release(); 571 ASSERT_TRUE(stubTestEigth != nullptr); 572 for (int32_t slotId = 0; slotId < SIM_SLOT_COUNT; slotId++) { 573 if (!HasSimCard(slotId)) { 574 continue; 575 } 576 CallWaitResult cwResult; 577 cwResult.result.index = INVALID_INDEX; 578 MessageParcel cwErrorData; 579 MessageParcel cwErrorReply; 580 ASSERT_TRUE(cwErrorData.WriteInt32(slotId)); 581 ASSERT_EQ(WriteSsResult(cwErrorData, cwResult.result, cwResult.status, cwResult.classCw), TELEPHONY_SUCCESS); 582 ASSERT_EQ(stubTestEigth->OnGetCallWaitingResponseInner(cwErrorData, cwErrorReply), TELEPHONY_SUCCESS); 583 584 cwResult.result.index = DEFAULT_INDEX; 585 MessageParcel cwData; 586 MessageParcel cwReply; 587 ASSERT_TRUE(cwData.WriteInt32(slotId)); 588 ASSERT_EQ(WriteSsResult(cwData, cwResult.result, cwResult.status, cwResult.classCw), TELEPHONY_SUCCESS); 589 ASSERT_EQ(stubTestEigth->OnGetCallWaitingResponseInner(cwData, cwReply), TELEPHONY_SUCCESS); 590 cwResult.result.result = IMS_ERROR_UT_CS_FALLBACK; 591 ASSERT_NE(stubTestEigth->GetCallWaitingResponse(slotId, cwResult), TELEPHONY_SUCCESS); 592 593 GetClipResult clipResult; 594 clipResult.result.index = INVALID_INDEX; 595 MessageParcel clipErrorData; 596 MessageParcel clipErrorReply; 597 ASSERT_TRUE(clipErrorData.WriteInt32(slotId)); 598 ASSERT_EQ( 599 WriteSsResult(clipErrorData, clipResult.result, clipResult.action, clipResult.clipStat), TELEPHONY_SUCCESS); 600 ASSERT_EQ(stubTestEigth->OnGetClipResponseInner(clipErrorData, clipErrorReply), TELEPHONY_SUCCESS); 601 602 clipResult.result.index = DEFAULT_INDEX; 603 MessageParcel clipData; 604 MessageParcel clipReply; 605 ASSERT_TRUE(clipData.WriteInt32(slotId)); 606 ASSERT_EQ( 607 WriteSsResult(clipData, clipResult.result, clipResult.action, clipResult.clipStat), TELEPHONY_SUCCESS); 608 ASSERT_EQ(stubTestEigth->OnGetClipResponseInner(clipData, clipReply), TELEPHONY_SUCCESS); 609 clipResult.result.result = IMS_ERROR_UT_CS_FALLBACK; 610 ASSERT_NE(stubTestEigth->GetClipResponse(slotId, clipResult), TELEPHONY_SUCCESS); 611 } 612 } 613 614 /** 615 * @tc.number cellular_call_ImsCallCallbackStub_0009 616 * @tc.name Test for ImsCallCallbackStub 617 * @tc.desc Function test 618 */ 619 HWTEST_F(ImsTest, cellular_call_ImsCallCallbackStub_0009, Function | MediumTest | Level3) 620 { 621 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) { 622 return; 623 } 624 sptr<ImsCallCallbackStub> stubTestNight = (std::make_unique<ImsCallCallbackStub>()).release(); 625 ASSERT_TRUE(stubTestNight != nullptr); 626 for (int32_t slotId = 0; slotId < SIM_SLOT_COUNT; slotId++) { 627 if (!HasSimCard(slotId)) { 628 continue; 629 } 630 GetClirResult clirResult; 631 clirResult.result.index = INVALID_INDEX; 632 MessageParcel clirErrorData; 633 MessageParcel clirErrorReply; 634 ASSERT_TRUE(clirErrorData.WriteInt32(slotId)); 635 ASSERT_EQ( 636 WriteSsResult(clirErrorData, clirResult.result, clirResult.action, clirResult.clirStat), TELEPHONY_SUCCESS); 637 ASSERT_EQ(stubTestNight->OnGetClirResponseInner(clirErrorData, clirErrorReply), TELEPHONY_SUCCESS); 638 639 clirResult.result.index = DEFAULT_INDEX; 640 MessageParcel clirData; 641 MessageParcel clirReply; 642 ASSERT_TRUE(clirData.WriteInt32(slotId)); 643 ASSERT_EQ( 644 WriteSsResult(clirData, clirResult.result, clirResult.action, clirResult.clirStat), TELEPHONY_SUCCESS); 645 ASSERT_EQ(stubTestNight->OnGetClirResponseInner(clirData, clirReply), TELEPHONY_SUCCESS); 646 clirResult.result.result = IMS_ERROR_UT_CS_FALLBACK; 647 ASSERT_NE(stubTestNight->GetClirResponse(slotId, clirResult), TELEPHONY_SUCCESS); 648 649 GetColpResult colpResult; 650 colpResult.result.index = INVALID_INDEX; 651 MessageParcel colpErrorData; 652 MessageParcel colpErrorReply; 653 ASSERT_TRUE(colpErrorData.WriteInt32(slotId)); 654 ASSERT_EQ( 655 WriteSsResult(colpErrorData, colpResult.result, colpResult.action, colpResult.colpStat), TELEPHONY_SUCCESS); 656 ASSERT_EQ(stubTestNight->OnGetColpResponseInner(colpErrorData, colpErrorReply), TELEPHONY_SUCCESS); 657 658 colpResult.result.index = DEFAULT_INDEX; 659 MessageParcel colpData; 660 MessageParcel colpReply; 661 ASSERT_TRUE(colpData.WriteInt32(slotId)); 662 ASSERT_EQ( 663 WriteSsResult(colpData, colpResult.result, colpResult.action, colpResult.colpStat), TELEPHONY_SUCCESS); 664 ASSERT_EQ(stubTestNight->OnGetColpResponseInner(colpData, colpReply), TELEPHONY_SUCCESS); 665 } 666 } 667 668 /** 669 * @tc.number cellular_call_ImsCallCallbackStub_0010 670 * @tc.name Test for ImsCallCallbackStub 671 * @tc.desc Function test 672 */ 673 HWTEST_F(ImsTest, cellular_call_ImsCallCallbackStub_0010, Function | MediumTest | Level3) 674 { 675 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) { 676 return; 677 } 678 679 sptr<ImsCallCallbackStub> stubTestTen = (std::make_unique<ImsCallCallbackStub>()).release(); 680 ASSERT_TRUE(stubTestTen != nullptr); 681 for (int32_t slotId = 0; slotId < SIM_SLOT_COUNT; slotId++) { 682 if (!HasSimCard(slotId)) { 683 continue; 684 } 685 GetColrResult colrResult; 686 colrResult.result.index = INVALID_INDEX; 687 MessageParcel colrErrorData; 688 MessageParcel colrErrorReply; 689 ASSERT_TRUE(colrErrorData.WriteInt32(slotId)); 690 ASSERT_EQ( 691 WriteSsResult(colrErrorData, colrResult.result, colrResult.action, colrResult.colrStat), TELEPHONY_SUCCESS); 692 ASSERT_EQ(stubTestTen->OnGetColrResponseInner(colrErrorData, colrErrorReply), TELEPHONY_SUCCESS); 693 694 colrResult.result.index = DEFAULT_INDEX; 695 MessageParcel colrData; 696 MessageParcel colrReply; 697 ASSERT_TRUE(colrData.WriteInt32(slotId)); 698 ASSERT_EQ( 699 WriteSsResult(colrData, colrResult.result, colrResult.action, colrResult.colrStat), TELEPHONY_SUCCESS); 700 ASSERT_EQ(stubTestTen->OnGetColrResponseInner(colrData, colrReply), TELEPHONY_SUCCESS); 701 702 SsBaseResult normalResult; 703 normalResult.index = DEFAULT_INDEX; 704 MessageParcel ctErrorData; 705 MessageParcel ctReply; 706 ASSERT_TRUE(ctErrorData.WriteInt32(slotId)); 707 ASSERT_EQ(WriteSsBaseResult(ctErrorData, normalResult), TELEPHONY_SUCCESS); 708 ASSERT_TRUE(ctErrorData.WriteInt32(INVALID_INDEX)); 709 ASSERT_TRUE(ctErrorData.WriteInt32(INVALID_INDEX)); 710 ASSERT_TRUE(ctErrorData.WriteInt32(INVALID_INDEX)); 711 ASSERT_NE(stubTestTen->OnGetCallTransferResponseInner(ctErrorData, ctReply), TELEPHONY_SUCCESS); 712 713 MessageParcel icErrorData; 714 MessageParcel icReply; 715 ASSERT_TRUE(icErrorData.WriteInt32(slotId)); 716 ASSERT_TRUE(icErrorData.WriteInt32(INVALID_INDEX)); 717 ASSERT_TRUE(icErrorData.WriteInt32(INVALID_INDEX)); 718 ASSERT_TRUE(icErrorData.WriteInt32(INVALID_INDEX)); 719 ASSERT_TRUE(icErrorData.WriteInt32(INVALID_INDEX)); 720 ASSERT_NE(stubTestTen->OnGetImsCallsDataResponseInner(icErrorData, icReply), TELEPHONY_SUCCESS); 721 } 722 } 723 724 /** 725 * @tc.number cellular_call_ImsCallCallbackStub_0011 726 * @tc.name Test for ImsCallCallbackStub 727 * @tc.desc Function test 728 */ 729 HWTEST_F(ImsTest, cellular_call_ImsCallCallbackStub_0011, Function | MediumTest | Level3) 730 { 731 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) { 732 return; 733 } 734 sptr<ImsCallCallbackStub> stubTestEleven = (std::make_unique<ImsCallCallbackStub>()).release(); 735 ASSERT_TRUE(stubTestEleven != nullptr); 736 for (int32_t slotId = 0; slotId < SIM_SLOT_COUNT; slotId++) { 737 if (!HasSimCard(slotId)) { 738 continue; 739 } 740 MessageParcel callModeReceiveRequestData; 741 MessageParcel callModeReceiveRequestReply; 742 ImsCallModeReceiveInfo callModeReceiveRequesInfo; 743 callModeReceiveRequesInfo.callIndex = DEFAULT_INDEX; 744 ASSERT_TRUE(callModeReceiveRequestData.WriteInt32(slotId)); 745 ASSERT_TRUE(callModeReceiveRequestData.WriteRawData( 746 (const void *)&callModeReceiveRequesInfo, sizeof(ImsCallModeReceiveInfo))); 747 ASSERT_EQ(stubTestEleven->OnReceiveUpdateCallMediaModeRequestInner( 748 callModeReceiveRequestData, callModeReceiveRequestReply), TELEPHONY_SUCCESS); 749 MessageParcel callModeReceiveResponseData; 750 MessageParcel callModeReceiveResponseReply; 751 ImsCallModeReceiveInfo callModeReceiveResponseInfo; 752 callModeReceiveResponseInfo.callIndex = DEFAULT_INDEX; 753 ASSERT_TRUE(callModeReceiveResponseData.WriteInt32(slotId)); 754 ASSERT_TRUE(callModeReceiveResponseData.WriteRawData( 755 (const void *)&callModeReceiveResponseInfo, sizeof(ImsCallModeReceiveInfo))); 756 ASSERT_EQ(stubTestEleven->OnReceiveUpdateCallMediaModeResponseInner( 757 callModeReceiveResponseData, callModeReceiveResponseReply), TELEPHONY_SUCCESS); 758 MessageParcel callSessionEventInfoData; 759 MessageParcel callSessionEventInfoReply; 760 ImsCallSessionEventInfo callSessionEventInfo; 761 callSessionEventInfo.callIndex = DEFAULT_INDEX; 762 ASSERT_TRUE(callSessionEventInfoData.WriteInt32(slotId)); 763 ASSERT_TRUE(callSessionEventInfoData.WriteRawData( 764 (const void *)&callSessionEventInfo, sizeof(ImsCallSessionEventInfo))); 765 ASSERT_EQ(stubTestEleven->OnCallSessionEventChangedInner( 766 callSessionEventInfoData, callSessionEventInfoReply), TELEPHONY_SUCCESS); 767 } 768 } 769 770 /** 771 * @tc.number cellular_call_ImsCallCallbackStub_0012 772 * @tc.name Test for ImsCallCallbackStub 773 * @tc.desc Function test 774 */ 775 HWTEST_F(ImsTest, cellular_call_ImsCallCallbackStub_0012, Function | MediumTest | Level3) 776 { 777 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) { 778 return; 779 } 780 sptr<ImsCallCallbackStub> stubTestEleven = (std::make_unique<ImsCallCallbackStub>()).release(); 781 ASSERT_TRUE(stubTestEleven != nullptr); 782 for (int32_t slotId = 0; slotId < SIM_SLOT_COUNT; slotId++) { 783 if (!HasSimCard(slotId)) { 784 continue; 785 } 786 MessageParcel callPeerDimensionsInfoData; 787 MessageParcel callPeerDimensionsInfoReply; 788 ImsCallPeerDimensionsInfo callPeerDimensionsInfo; 789 callPeerDimensionsInfo.callIndex = DEFAULT_INDEX; 790 ASSERT_TRUE(callPeerDimensionsInfoData.WriteInt32(slotId)); 791 ASSERT_TRUE(callPeerDimensionsInfoData.WriteRawData( 792 (const void *)&callPeerDimensionsInfo, sizeof(ImsCallPeerDimensionsInfo))); 793 ASSERT_EQ(stubTestEleven->OnPeerDimensionsChangedInner( 794 callPeerDimensionsInfoData, callPeerDimensionsInfoReply), TELEPHONY_SUCCESS); 795 MessageParcel callDataUsageInfoData; 796 MessageParcel callDataUsageInfoReply; 797 ImsCallDataUsageInfo callDataUsageInfo; 798 callDataUsageInfo.callIndex = DEFAULT_INDEX; 799 ASSERT_TRUE(callDataUsageInfoData.WriteInt32(slotId)); 800 ASSERT_TRUE(callDataUsageInfoData.WriteRawData( 801 (const void *)&callDataUsageInfo, sizeof(ImsCallDataUsageInfo))); 802 ASSERT_EQ(stubTestEleven->OnCallDataUsageChangedInner( 803 callDataUsageInfoData, callDataUsageInfoReply), TELEPHONY_SUCCESS); 804 MessageParcel cameraCapabilitiesInfoData; 805 MessageParcel cameraCapabilitiesInfoReply; 806 CameraCapabilitiesInfo cameraCapabilitiesInfo; 807 cameraCapabilitiesInfo.callIndex = DEFAULT_INDEX; 808 ASSERT_TRUE(cameraCapabilitiesInfoData.WriteInt32(slotId)); 809 ASSERT_TRUE(cameraCapabilitiesInfoData.WriteRawData( 810 (const void *)&cameraCapabilitiesInfo, sizeof(CameraCapabilitiesInfo))); 811 ASSERT_EQ(stubTestEleven->OnCameraCapabilitiesChangedInner( 812 cameraCapabilitiesInfoData, cameraCapabilitiesInfoReply), TELEPHONY_SUCCESS); 813 } 814 } 815 } // namespace Telephony 816 } // namespace OHOS 817