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