1/* 2 * Copyright (C) 2023-2024 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 19#include <regex> 20 21#include "cdma_sms_message.h" 22#include "delivery_short_message_callback_stub.h" 23#include "gsm_pdu_hex_value.h" 24#include "gsm_sms_common_utils.h" 25#include "gsm_sms_message.h" 26#include "gsm_sms_param_decode.h" 27#include "gsm_sms_receive_handler.h" 28#include "gsm_sms_tpdu_decode.h" 29#include "gsm_sms_tpdu_encode.h" 30#include "gsm_user_data_decode.h" 31#include "gsm_user_data_encode.h" 32#include "gtest/gtest.h" 33#include "radio_event.h" 34#include "satellite_sms_client.h" 35#include "send_short_message_callback_stub.h" 36#include "short_message.h" 37#include "sms_common_utils.h" 38#include "sms_misc_manager.h" 39#include "sms_mms_gtest.h" 40#include "sms_pdu_buffer.h" 41#include "sms_receive_handler.h" 42#include "sms_receive_reliability_handler.h" 43#include "sms_send_manager.h" 44#include "sms_sender.h" 45#include "sms_service.h" 46#include "sms_service_manager_client.h" 47#include "sms_state_handler.h" 48#include "telephony_errors.h" 49 50namespace OHOS { 51namespace Telephony { 52using namespace testing::ext; 53 54namespace { 55const std::string TEXT_SMS_CONTENT = "hello world"; 56const std::u16string INTERFACE_TOKEN = u"ohos.telephony.ISatelliteSmsCallback"; 57const std::string BLOCK_NUMBER = "123"; 58const int8_t TEXT_PORT_NUM = -1; 59const int16_t WAP_PUSH_PORT = 2948; 60const uint16_t BUF_SIZE = 2401; 61const uint8_t BUFFER_SIZE = 255; 62const int DIGIT_LEN = 3; 63const int START_BIT = 4; 64const int32_t INVALID_SLOTID = 2; 65const int32_t VALUE_LENGTH = 2; 66const int32_t HEADER_LENGTH = 7; 67const uint32_t CODE_BUFFER_MAX_SIZE = 300 * 1024; 68const unsigned int SMS_REF_ID = 10; 69static constexpr uint16_t MAX_TPDU_DATA_LEN = 255; 70const std::string CB_RANGE_MIDS = "0-1,2-3"; 71const std::string CB_RANGE_DCSS = "0-255"; 72const std::string CB_RANGE_DELI = ","; 73const std::string CB_RANGE_MID = "0-1"; 74const std::string CB_RANGE_DELIM = "-"; 75static constexpr const char *SLOT_ID = "slot_id"; 76const std::string TABLE_URL = "datashare:///com.ohos.smsmmsability/sms_mms/sms_subsection"; 77const std::string SMS_READ_PDU = "123456"; 78const size_t DECODE_SIZE = 10; 79const int EIGHT_BIT = 8; 80const int FOUR_BIT = 4; 81const int FIVE_BIT = 5; 82const int SIX_BIT = 6; 83const int TWO_BIT = 2; 84const std::string CBN_NUM = "+86192********"; 85const int NUM_LENGTH = 11; 86const std::string PREFIX = "+86"; 87const std::vector<uint8_t> PDU = { 0 }; 88static constexpr uint8_t MAX_SMSC_LEN = 20; 89} // namespace 90 91class BranchSmsTest : public testing::Test { 92public: 93 static void SetUpTestCase(); 94 static void TearDownTestCase(); 95 void SetUp(); 96 void TearDown(); 97}; 98void BranchSmsTest::SetUpTestCase() {} 99 100void BranchSmsTest::TearDownTestCase() {} 101 102void BranchSmsTest::SetUp() {} 103 104void BranchSmsTest::TearDown() {} 105 106/** 107 * @tc.number Telephony_SmsMmsGtest_SmsReceiveHandler_0001 108 * @tc.name Test SmsReceiveHandler 109 * @tc.desc Function test 110 */ 111HWTEST_F(BranchSmsTest, SmsReceiveHandler_0001, Function | MediumTest | Level1) 112{ 113 AppExecFwk::InnerEvent::Pointer event = AppExecFwk::InnerEvent::Get(RadioEvent::RADIO_GSM_SMS, 1); 114 std::shared_ptr<SmsReceiveHandler> smsReceiveHandler = std::make_shared<CdmaSmsReceiveHandler>(INVALID_SLOTID); 115 smsReceiveHandler->ProcessEvent(event); 116 event = AppExecFwk::InnerEvent::Get(RadioEvent::RADIO_CDMA_SMS, 1); 117 smsReceiveHandler->ProcessEvent(event); 118 event = AppExecFwk::InnerEvent::Get(RadioEvent::RADIO_CONNECTED, 1); 119 smsReceiveHandler->ProcessEvent(event); 120 event = nullptr; 121 smsReceiveHandler->ProcessEvent(event); 122 std::shared_ptr<SmsReceiveIndexer> indexer = nullptr; 123 std::shared_ptr<SmsBaseMessage> smsBaseMessage = nullptr; 124 std::shared_ptr<vector<string>> pdus = nullptr; 125 auto reliabilityHandler = std::make_shared<SmsReceiveReliabilityHandler>(INVALID_SLOTID); 126 reliabilityHandler->DeleteMessageFormDb(SMS_REF_ID); 127 smsReceiveHandler->CombineMessagePart(indexer); 128 129 reliabilityHandler->CheckBlockedPhoneNumber(BLOCK_NUMBER); 130 reliabilityHandler->DeleteAutoSmsFromDB(reliabilityHandler, 0, 0); 131 reliabilityHandler->SendBroadcast(indexer, pdus); 132 smsReceiveHandler->HandleReceivedSms(smsBaseMessage); 133 indexer = std::make_shared<SmsReceiveIndexer>(); 134 smsReceiveHandler->CombineMessagePart(indexer); 135 indexer->msgCount_ = 1; 136 indexer->destPort_ = WAP_PUSH_PORT; 137 smsReceiveHandler->CombineMessagePart(indexer); 138 reliabilityHandler->SendBroadcast(indexer, pdus); 139 pdus = std::make_shared<vector<string>>(); 140 string pud = "qwe"; 141 pdus->push_back(pud); 142 reliabilityHandler->SendBroadcast(indexer, pdus); 143 smsReceiveHandler->CombineMultiPageMessage(indexer, pdus, reliabilityHandler); 144 smsReceiveHandler->UpdateMultiPageMessage(indexer, pdus); 145 indexer->destPort_ = TEXT_PORT_NUM; 146 reliabilityHandler->SendBroadcast(indexer, pdus); 147 smsReceiveHandler->AddMsgToDB(indexer); 148 smsReceiveHandler->IsRepeatedMessagePart(indexer); 149 indexer = nullptr; 150 EXPECT_FALSE(smsReceiveHandler->AddMsgToDB(indexer)); 151} 152 153/** 154 * @tc.number Telephony_SmsMmsGtest_SmsReceiveReliabilityHandler_0001 155 * @tc.name Test SmsReceiveReliabilityHandler 156 * @tc.desc Function test 157 */ 158HWTEST_F(BranchSmsTest, SmsReceiveReliabilityHandler_0001, Function | MediumTest | Level1) 159{ 160 auto reliabilityHandler = std::make_shared<SmsReceiveReliabilityHandler>(INVALID_SLOTID); 161 reliabilityHandler->DeleteMessageFormDb(SMS_REF_ID); 162 163 std::vector<SmsReceiveIndexer> dbIndexers; 164 std::string strData = "qwe"; 165 auto indexer = SmsReceiveIndexer(StringUtils::HexToByteVector(strData), strData.size(), strData.size(), false, 166 strData, strData, strData.size(), strData.size(), strData.size(), false, strData); 167 168 dbIndexers.push_back(indexer); 169 indexer = SmsReceiveIndexer( 170 StringUtils::HexToByteVector(strData), strData.size(), strData.size(), false, false, strData, strData, strData); 171 dbIndexers.push_back(indexer); 172 reliabilityHandler->CheckUnReceiveWapPush(dbIndexers); 173 174 std::shared_ptr<std::vector<std::string>> userDataRaws = std::make_shared<std::vector<std::string>>(); 175 userDataRaws->push_back(strData); 176 177 int32_t pages = 0; 178 reliabilityHandler->GetWapPushUserDataSinglePage(indexer, userDataRaws); 179 int32_t count; 180 reliabilityHandler->GetWapPushUserDataMultipage(count, dbIndexers, 0, userDataRaws); 181 reliabilityHandler->GetWapPushUserDataMultipage(count, dbIndexers, VALUE_LENGTH, userDataRaws); 182 reliabilityHandler->GetWapPushUserDataMultipage(count, dbIndexers, VALUE_LENGTH + 1, userDataRaws); 183 reliabilityHandler->ReadyDecodeWapPushUserData(indexer, userDataRaws); 184 reliabilityHandler->GetSmsUserDataMultipage(pages, dbIndexers, 0, userDataRaws); 185 reliabilityHandler->ReadySendSmsBroadcast(indexer, userDataRaws); 186 reliabilityHandler->DeleteMessageFormDb(strData.size(), strData.size()); 187 reliabilityHandler->RemoveBlockedSms(dbIndexers); 188 189 std::shared_ptr<SmsReceiveIndexer> indexerPtr = 190 std::make_shared<SmsReceiveIndexer>(StringUtils::HexToByteVector(strData), strData.size(), strData.size(), 191 false, strData, strData, strData.size(), strData.size(), strData.size(), false, strData); 192 if (indexerPtr == nullptr) { 193 return; 194 } 195 reliabilityHandler->SendBroadcast(indexerPtr, userDataRaws); 196 EXPECT_TRUE(reliabilityHandler->CheckSmsCapable()); 197 EXPECT_FALSE(reliabilityHandler->CheckBlockedPhoneNumber(BLOCK_NUMBER)); 198} 199 200/** 201 * @tc.number Telephony_SmsMmsGtest_SmsStateHandler_0001 202 * @tc.name Test SmsStateHandler 203 * @tc.desc Function test 204 */ 205HWTEST_F(BranchSmsTest, SmsStateHandler_0001, Function | MediumTest | Level1) 206{ 207 SmsStateHandler handler; 208 handler.Init(); 209 handler.UnInit(); 210 EXPECT_TRUE(handler.RegisterHandler()); 211 EXPECT_TRUE(handler.UnRegisterHandler()); 212} 213 214/** 215 * @tc.number Telephony_SmsMmsGtest_CdmaSmsSender_0001 216 * @tc.name Test CdmaSmsSender 217 * @tc.desc Function test 218 */ 219HWTEST_F(BranchSmsTest, CdmaSmsSender_0001, Function | MediumTest | Level1) 220{ 221 std::function<void(std::shared_ptr<SmsSendIndexer>)> fun = nullptr; 222 auto cdmaSmsSender = std::make_shared<CdmaSmsSender>(INVALID_SLOTID, fun); 223 cdmaSmsSender->isImsCdmaHandlerRegistered = true; 224 cdmaSmsSender->RegisterImsHandler(); 225 const sptr<ISendShortMessageCallback> sendCallback = 226 iface_cast<ISendShortMessageCallback>(new SendShortMessageCallbackStub()); 227 ASSERT_NE(sendCallback, nullptr); 228 const sptr<IDeliveryShortMessageCallback> deliveryCallback = 229 iface_cast<IDeliveryShortMessageCallback>(new DeliveryShortMessageCallbackStub()); 230 ASSERT_NE(deliveryCallback, nullptr); 231 const std::string text = "123"; 232 const std::string desAddr = "qwe"; 233 const std::string scAddr = "123"; 234 cdmaSmsSender->isImsNetDomain_ = true; 235 uint16_t dataBaseId = 0; 236 cdmaSmsSender->TextBasedSmsDelivery(desAddr, scAddr, text, sendCallback, deliveryCallback, dataBaseId); 237 std::vector<struct SplitInfo> splits; 238 std::unique_ptr<CdmaTransportMsg> transMsg; 239 uint8_t msgRef8bit = 0; 240 uint16_t msgId = 0; 241 long timeStamp = 0; 242 cdmaSmsSender->TextBasedSmsSplitDelivery( 243 desAddr, scAddr, splits, std::move(transMsg), msgRef8bit, msgId, timeStamp, sendCallback, deliveryCallback, 244 dataBaseId); 245 cdmaSmsSender->TextBasedSmsDeliveryViaIms(desAddr, scAddr, text, sendCallback, deliveryCallback, dataBaseId); 246 std::shared_ptr<SmsSendIndexer> smsIndexer = nullptr; 247 cdmaSmsSender->SendSmsToRil(smsIndexer); 248 cdmaSmsSender->ResendTextDelivery(smsIndexer); 249 cdmaSmsSender->ResendDataDelivery(smsIndexer); 250 smsIndexer = std::make_shared<SmsSendIndexer>(desAddr, scAddr, text, sendCallback, deliveryCallback); 251 cdmaSmsSender->SendSmsToRil(smsIndexer); 252 cdmaSmsSender->ResendTextDelivery(smsIndexer); 253 cdmaSmsSender->ResendDataDelivery(smsIndexer); 254 AppExecFwk::InnerEvent::Pointer event = AppExecFwk::InnerEvent::Get(0, 1); 255 cdmaSmsSender->StatusReportGetImsSms(event); 256 cdmaSmsSender->StatusReportAnalysis(event); 257 event = nullptr; 258 cdmaSmsSender->StatusReportSetImsSms(event); 259 cdmaSmsSender->StatusReportGetImsSms(event); 260 cdmaSmsSender->StatusReportAnalysis(event); 261} 262 263/** 264 * @tc.number Telephony_SmsMmsGtest_ShortMessage_0001 265 * @tc.name Test ShortMessage 266 * @tc.desc Function test 267 */ 268HWTEST_F(BranchSmsTest, ShortMessage_0001, Function | MediumTest | Level1) 269{ 270 auto shortMessage = std::make_shared<ShortMessage>(); 271 std::vector<unsigned char> pdu; 272 std::string str = "3gpp"; 273 Parcel parcel; 274 std::u16string specification = u" "; 275 ShortMessage ShortMessageObj; 276 EXPECT_TRUE(shortMessage->CreateMessage(pdu, specification, ShortMessageObj) != TELEPHONY_ERR_SUCCESS); 277 pdu.push_back(ShortMessage::SmsSimMessageStatus::SMS_SIM_MESSAGE_STATUS_READ); 278 EXPECT_GE(shortMessage->CreateIccMessage(pdu, str, 1).indexOnSim_, 0); 279 pdu.push_back(ShortMessage::SmsSimMessageStatus::SMS_SIM_MESSAGE_STATUS_FREE); 280 EXPECT_GE(shortMessage->CreateIccMessage(pdu, str, 1).indexOnSim_, 0); 281 pdu.clear(); 282 pdu.push_back(ShortMessage::SmsSimMessageStatus::SMS_SIM_MESSAGE_STATUS_UNREAD); 283 pdu.push_back(ShortMessage::SmsSimMessageStatus::SMS_SIM_MESSAGE_STATUS_FREE); 284 EXPECT_GE(shortMessage->CreateIccMessage(pdu, str, 1).indexOnSim_, 0); 285 pdu.clear(); 286 pdu.push_back(ShortMessage::SmsSimMessageStatus::SMS_SIM_MESSAGE_STATUS_SENT); 287 pdu.push_back(ShortMessage::SmsSimMessageStatus::SMS_SIM_MESSAGE_STATUS_FREE); 288 EXPECT_GE(shortMessage->CreateIccMessage(pdu, str, 1).indexOnSim_, 0); 289 pdu.clear(); 290 pdu.push_back(ShortMessage::SmsSimMessageStatus::SMS_SIM_MESSAGE_STATUS_UNSENT); 291 pdu.push_back(ShortMessage::SmsSimMessageStatus::SMS_SIM_MESSAGE_STATUS_FREE); 292 EXPECT_GE(shortMessage->CreateIccMessage(pdu, str, 1).indexOnSim_, 0); 293 pdu.clear(); 294 pdu.push_back(ShortMessage::SmsSimMessageStatus::SMS_SIM_MESSAGE_STATUS_FREE); 295 pdu.push_back(ShortMessage::SmsSimMessageStatus::SMS_SIM_MESSAGE_STATUS_UNSENT); 296 EXPECT_EQ(shortMessage->CreateIccMessage(pdu, str, 1).simMessageStatus_, 297 ShortMessage::SmsSimMessageStatus::SMS_SIM_MESSAGE_STATUS_FREE); 298 EXPECT_FALSE(shortMessage->ReadFromParcel(parcel)); 299} 300 301/** 302 * @tc.number Telephony_SmsMmsGtest_ShortMessage_0002 303 * @tc.name Test ShortMessage 304 * @tc.desc Function test 305 */ 306HWTEST_F(BranchSmsTest, ShortMessage_0002, Function | MediumTest | Level1) 307{ 308 auto shortMessage = DelayedSingleton<ShortMessage>::GetInstance(); 309 MessageParcel reply; 310 int32_t result = 0; 311 reply.WriteInt32(result); 312 shortMessage->UnMarshalling(reply); 313 shortMessage->GetVisibleMessageBody(); 314 shortMessage->GetVisibleRawAddress(); 315 shortMessage->GetMessageClass(); 316 std::u16string smscAddress = u"13677884499"; 317 shortMessage->GetScAddress(smscAddress); 318 shortMessage->GetScTimestamp(); 319 shortMessage->IsReplaceMessage(); 320 shortMessage->GetStatus(); 321 shortMessage->IsSmsStatusReportMessage(); 322 shortMessage->HasReplyPath(); 323 shortMessage->GetIccMessageStatus(); 324 shortMessage->GetProtocolId(); 325 shortMessage->GetPdu(); 326 std::vector<unsigned char> pdus; 327 unsigned char data = 255; 328 pdus.push_back(data); 329 std::u16string specification = u""; 330 ShortMessage messageObj; 331 shortMessage->CreateMessage(pdus, specification, messageObj); 332 shortMessage->GetIndexOnSim(); 333 EXPECT_TRUE(shortMessage != nullptr); 334} 335 336/** 337 * @tc.number Telephony_SmsMmsGtest_GsmSmsMessage_0001 338 * @tc.name Test GsmSmsMessage 339 * @tc.desc Function test 340 */ 341HWTEST_F(BranchSmsTest, GsmSmsMessage_0001, Function | MediumTest | Level1) 342{ 343 auto gsmSmsMessage = std::make_shared<GsmSmsMessage>(); 344 std::string dest = ""; 345 std::string str = ""; 346 std::string text = ""; 347 std::string msgText = ""; 348 unsigned char langId = 0; 349 std::string desAddr = ""; 350 SmsTimeStamp times; 351 SmsConcat concat; 352 std::shared_ptr<struct SmsTpdu> tPdu = std::make_shared<struct SmsTpdu>(); 353 gsmSmsMessage->ConvertMsgTimeStamp(times); 354 times.format = SmsTimeFormat::SMS_TIME_ABSOLUTE; 355 gsmSmsMessage->ConvertMsgTimeStamp(times); 356 EXPECT_EQ(gsmSmsMessage->SetHeaderLang(1, DataCodingScheme::DATA_CODING_UCS2, langId), 0); 357 EXPECT_EQ(gsmSmsMessage->SetHeaderConcat(1, concat), 0); 358 EXPECT_EQ(gsmSmsMessage->SetHeaderReply(1), 0); 359 EXPECT_TRUE(gsmSmsMessage->CreateDefaultSubmitSmsTpdu(dest, str, text, true, DataCodingScheme::DATA_CODING_7BIT) != 360 nullptr); 361 EXPECT_NE(gsmSmsMessage->GetDestPort(), -1); 362 msgText = "123"; 363 desAddr = "+SetSmsTpduDestAddress"; 364 EXPECT_EQ(gsmSmsMessage->SetSmsTpduDestAddress(tPdu, desAddr), 22); 365 desAddr = "SetSmsTpduDestAddress"; 366 EXPECT_EQ(gsmSmsMessage->SetSmsTpduDestAddress(tPdu, desAddr), 21); 367 tPdu = nullptr; 368 EXPECT_EQ(gsmSmsMessage->SetSmsTpduDestAddress(tPdu, desAddr), 0); 369 langId = 1; 370 EXPECT_EQ(gsmSmsMessage->SetHeaderLang(1, DataCodingScheme::DATA_CODING_7BIT, langId), 1); 371 EXPECT_EQ(gsmSmsMessage->SetHeaderConcat(1, concat), 1); 372 concat.is8Bits = true; 373 EXPECT_EQ(gsmSmsMessage->SetHeaderConcat(1, concat), 1); 374 gsmSmsMessage->replyAddress_ = "++SetSmsTpduDestAddress"; 375 EXPECT_EQ(gsmSmsMessage->SetHeaderReply(1), 0); 376 EXPECT_TRUE(gsmSmsMessage->GetSubmitEncodeInfo(msgText, true) != nullptr); 377 msgText = "++"; 378 EXPECT_TRUE(gsmSmsMessage->GetSubmitEncodeInfo(msgText, true) != nullptr); 379} 380 381/** 382 * @tc.number Telephony_SmsMmsGtest_GsmSmsMessage_0002 383 * @tc.name Test GsmSmsMessage 384 * @tc.desc Function test 385 */ 386HWTEST_F(BranchSmsTest, GsmSmsMessage_0002, Function | MediumTest | Level1) 387{ 388 auto gsmSmsMessage = std::make_shared<GsmSmsMessage>(); 389 string pdu = ""; 390 gsmSmsMessage->ConvertMessageDcs(); 391 gsmSmsMessage->ConvertUserData(); 392 EXPECT_TRUE(gsmSmsMessage->CreateMessage(pdu) == nullptr); 393 EXPECT_FALSE(gsmSmsMessage->PduAnalysis(pdu)); 394 EXPECT_FALSE(gsmSmsMessage->PduAnalysis(pdu)); 395 pdu = "123"; 396 EXPECT_FALSE(gsmSmsMessage->PduAnalysis(pdu)); 397 pdu = "123456"; 398 EXPECT_FALSE(gsmSmsMessage->PduAnalysis(pdu)); 399 EXPECT_TRUE(gsmSmsMessage->CreateDeliverReportSmsTpdu() != nullptr); 400 EXPECT_FALSE(gsmSmsMessage->PduAnalysis(pdu)); 401 gsmSmsMessage->smsTpdu_ = nullptr; 402 gsmSmsMessage->smsTpdu_ = std::make_shared<struct SmsTpdu>(); 403 gsmSmsMessage->ConvertMessageDcs(); 404 gsmSmsMessage->smsTpdu_->tpduType = SmsTpduType::SMS_TPDU_DELIVER; 405 gsmSmsMessage->ConvertUserData(); 406 gsmSmsMessage->ConvertMessageDcs(); 407 gsmSmsMessage->smsTpdu_->tpduType = SmsTpduType::SMS_TPDU_SUBMIT; 408 gsmSmsMessage->ConvertUserData(); 409 gsmSmsMessage->ConvertMessageDcs(); 410 gsmSmsMessage->smsTpdu_->tpduType = SmsTpduType::SMS_TPDU_STATUS_REP; 411 gsmSmsMessage->ConvertUserData(); 412 gsmSmsMessage->ConvertMessageDcs(); 413 gsmSmsMessage->smsTpdu_->tpduType = SmsTpduType::SMS_TPDU_DELIVER_REP; 414 gsmSmsMessage->ConvertMessageDcs(); 415 gsmSmsMessage->ConvertUserData(); 416 EXPECT_TRUE(gsmSmsMessage->CreateDeliverSmsTpdu() != nullptr); 417 EXPECT_FALSE(gsmSmsMessage->PduAnalysis(pdu)); 418} 419 420/** 421 * @tc.number Telephony_SmsMmsGtest_SmsSender_0001 422 * @tc.name Test SmsSender 423 * @tc.desc Function test 424 */ 425HWTEST_F(BranchSmsTest, SmsSender_0001, Function | MediumTest | Level1) 426{ 427 std::function<void(std::shared_ptr<SmsSendIndexer>)> fun = nullptr; 428 AppExecFwk::InnerEvent::Pointer event = AppExecFwk::InnerEvent::Get(RadioEvent::RADIO_SEND_SMS, 1); 429 std::shared_ptr<SmsSender> smsSender = std::make_shared<CdmaSmsSender>(INVALID_SLOTID, fun); 430 const sptr<ISendShortMessageCallback> sendCallback = 431 iface_cast<ISendShortMessageCallback>(new SendShortMessageCallbackStub()); 432 const sptr<IDeliveryShortMessageCallback> deliveryCallback = 433 iface_cast<IDeliveryShortMessageCallback>(new DeliveryShortMessageCallbackStub()); 434 const std::string desAddr = "qwe"; 435 const std::string scAddr = "123"; 436 const std::string text = "123"; 437 auto smsIndexer = std::make_shared<SmsSendIndexer>(desAddr, scAddr, text, sendCallback, deliveryCallback); 438 smsSender->HandleMessageResponse(smsIndexer); 439 smsIndexer->isFailure_ = true; 440 smsSender->HandleMessageResponse(smsIndexer); 441 smsSender->SyncSwitchISmsResponse(); 442 smsSender->ProcessEvent(event); 443 event = AppExecFwk::InnerEvent::Get(RadioEvent::RADIO_SEND_CDMA_SMS, 1); 444 smsSender->ProcessEvent(event); 445 event = AppExecFwk::InnerEvent::Get(RadioEvent::RADIO_SEND_IMS_GSM_SMS, 1); 446 smsSender->ProcessEvent(event); 447 event = AppExecFwk::InnerEvent::Get(RadioEvent::RADIO_SEND_SMS_EXPECT_MORE, 1); 448 smsSender->ProcessEvent(event); 449 event = AppExecFwk::InnerEvent::Get(MSG_SMS_RETRY_DELIVERY, 1); 450 smsSender->ProcessEvent(event); 451 event = AppExecFwk::InnerEvent::Get(RadioEvent::RADIO_SMS_STATUS, 1); 452 smsSender->ProcessEvent(event); 453 event = AppExecFwk::InnerEvent::Get(RadioEvent::RADIO_GET_IMS_SMS, 1); 454 smsSender->ProcessEvent(event); 455 event = AppExecFwk::InnerEvent::Get(RadioEvent::RADIO_DIAL, 1); 456 smsSender->ProcessEvent(event); 457 event->GetSharedObject<RadioResponseInfo>() = std::make_shared<RadioResponseInfo>(); 458 smsSender->HandleResend(smsIndexer); 459 smsIndexer->errorCode_ = static_cast<int32_t>(ErrType::ERR_CMD_SEND_FAILURE); 460 smsSender->HandleResend(smsIndexer); 461 smsIndexer->errorCode_ = static_cast<int32_t>(ErrType::ERR_GENERIC_FAILURE); 462 smsSender->HandleResend(smsIndexer); 463 smsSender->lastSmsDomain_ = 1; 464 smsSender->HandleResend(smsIndexer); 465 EXPECT_NE(smsSender->SendCacheMapAddItem(1, smsIndexer), false); 466 event = nullptr; 467 smsIndexer = nullptr; 468 smsSender->HandleResend(smsIndexer); 469 smsSender->ProcessEvent(event); 470 smsSender->HandleMessageResponse(smsIndexer); 471 smsSender->SetNetworkState(true, 1); 472 EXPECT_TRUE(smsSender->FindCacheMapAndTransform(event) == nullptr); 473} 474 475/** 476 * @tc.number Telephony_SmsMmsGtest_SmsSender_0002 477 * @tc.name Test SmsSender 478 * @tc.desc Function test 479 */ 480HWTEST_F(BranchSmsTest, SmsSender_0002, Function | MediumTest | Level1) 481{ 482 std::function<void(std::shared_ptr<SmsSendIndexer>)> fun = nullptr; 483 std::shared_ptr<SmsSender> smsSender = std::make_shared<CdmaSmsSender>(INVALID_SLOTID, fun); 484 const sptr<ISendShortMessageCallback> sendCallback = 485 iface_cast<ISendShortMessageCallback>(new SendShortMessageCallbackStub()); 486 const sptr<IDeliveryShortMessageCallback> deliveryCallback = 487 iface_cast<IDeliveryShortMessageCallback>(new DeliveryShortMessageCallbackStub()); 488 const std::string desAddr = "qwe"; 489 const std::string scAddr = "123"; 490 const std::string text = "123"; 491 auto smsIndexer = std::make_shared<SmsSendIndexer>(desAddr, scAddr, text, sendCallback, deliveryCallback); 492 smsIndexer->unSentCellCount_ = 1; 493 smsSender->SendMessageSucceed(smsIndexer); 494 smsIndexer->unSentCellCount_ = 1; 495 smsIndexer->hasCellFailed_ = std::make_shared<bool>(true); 496 smsSender->SendMessageSucceed(smsIndexer); 497 smsIndexer->unSentCellCount_ = 1; 498 smsSender->SendMessageFailed(smsIndexer); 499 smsIndexer->unSentCellCount_ = 0; 500 smsSender->SendMessageFailed(smsIndexer); 501 smsSender->SendResultCallBack(smsIndexer, ISendShortMessageCallback::SEND_SMS_FAILURE_UNKNOWN); 502 smsSender->SendResultCallBack(sendCallback, ISendShortMessageCallback::SEND_SMS_FAILURE_UNKNOWN); 503 smsIndexer = nullptr; 504 smsSender->SendMessageSucceed(smsIndexer); 505 smsSender->SendMessageFailed(smsIndexer); 506 EXPECT_FALSE(smsSender->SendCacheMapAddItem(1, smsIndexer)); 507} 508 509/** 510 * @tc.number Telephony_SmsMmsGtest_SmsSender_0003 511 * @tc.name Test SmsSender 512 * @tc.desc Function test 513 */ 514HWTEST_F(BranchSmsTest, SmsSender_0003, Function | MediumTest | Level1) 515{ 516 std::function<void(std::shared_ptr<SmsSendIndexer>)> fun = nullptr; 517 std::shared_ptr<SmsSender> smsSender = std::make_shared<CdmaSmsSender>(INVALID_SLOTID, fun); 518 const sptr<ISendShortMessageCallback> sendCallback = 519 iface_cast<ISendShortMessageCallback>(new SendShortMessageCallbackStub()); 520 const sptr<IDeliveryShortMessageCallback> deliveryCallback = 521 iface_cast<IDeliveryShortMessageCallback>(new DeliveryShortMessageCallbackStub()); 522 const std::string desAddr = "qwe"; 523 const std::string scAddr = "123"; 524 const std::string text = "123"; 525 auto smsIndexer = std::make_shared<SmsSendIndexer>(desAddr, scAddr, text, sendCallback, deliveryCallback); 526 EXPECT_FALSE(smsSender->SendCacheMapAddItem(1, smsIndexer)); 527 smsIndexer->isFailure_ = true; 528 smsSender->OnRilAdapterHostDied(); 529 smsIndexer->isFailure_ = false; 530 smsIndexer->msgRefId64Bit_ = 0; 531 smsSender->OnRilAdapterHostDied(); 532 EXPECT_GE(smsIndexer->msgRefId64Bit_, 0); 533} 534 535/** 536 * @tc.number Telephony_SmsMmsGtest_SmsSendManager_0001 537 * @tc.name Test SmsSendManager 538 * @tc.desc Function test 539 */ 540HWTEST_F(BranchSmsTest, SmsSendManager_0001, Function | MediumTest | Level1) 541{ 542 auto smsSendManager = std::make_shared<SmsSendManager>(INVALID_SLOTID); 543 auto smsNetworkPolicyManager = std::make_shared<SmsNetworkPolicyManager>(INVALID_SLOTID); 544 std::function<void(std::shared_ptr<SmsSendIndexer>)> fun = nullptr; 545 auto cdmaSmsSender = std::make_shared<CdmaSmsSender>(INVALID_SLOTID, fun); 546 auto gsmSmsSender = std::make_shared<GsmSmsSender>(INVALID_SLOTID, fun); 547 std::string desAddr = ""; 548 std::string scAddr = "123"; 549 std::string text = ""; 550 uint16_t dataBaseId = 0; 551 std::u16string format = u""; 552 uint8_t *data = nullptr; 553 const sptr<ISendShortMessageCallback> sendCallback = 554 iface_cast<ISendShortMessageCallback>(new SendShortMessageCallbackStub()); 555 const sptr<IDeliveryShortMessageCallback> deliveryCallback = 556 iface_cast<IDeliveryShortMessageCallback>(new DeliveryShortMessageCallbackStub()); 557 auto smsIndexer = std::make_shared<SmsSendIndexer>(desAddr, scAddr, text, sendCallback, deliveryCallback); 558 smsSendManager->TextBasedSmsDelivery(desAddr, scAddr, text, sendCallback, deliveryCallback, dataBaseId); 559 smsSendManager->DataBasedSmsDelivery(desAddr, scAddr, 1, data, 1, sendCallback, deliveryCallback); 560 desAddr = "qwe"; 561 smsSendManager->DataBasedSmsDelivery(desAddr, scAddr, 1, data, 1, sendCallback, deliveryCallback); 562 smsSendManager->TextBasedSmsDelivery(desAddr, scAddr, text, sendCallback, deliveryCallback, dataBaseId); 563 text = "123"; 564 data = new uint8_t(1); 565 smsSendManager->DataBasedSmsDelivery(desAddr, scAddr, 1, data, 1, sendCallback, deliveryCallback); 566 smsSendManager->TextBasedSmsDelivery(desAddr, scAddr, text, sendCallback, deliveryCallback, dataBaseId); 567 smsSendManager->networkManager_ = smsNetworkPolicyManager; 568 smsSendManager->DataBasedSmsDelivery(desAddr, scAddr, 1, data, 1, sendCallback, deliveryCallback); 569 smsSendManager->TextBasedSmsDelivery(desAddr, scAddr, text, sendCallback, deliveryCallback, dataBaseId); 570 smsSendManager->RetriedSmsDelivery(smsIndexer); 571 smsSendManager->gsmSmsSender_ = gsmSmsSender; 572 smsSendManager->DataBasedSmsDelivery(desAddr, scAddr, 1, data, 1, sendCallback, deliveryCallback); 573 smsSendManager->TextBasedSmsDelivery(desAddr, scAddr, text, sendCallback, deliveryCallback, dataBaseId); 574 smsSendManager->RetriedSmsDelivery(smsIndexer); 575 smsSendManager->cdmaSmsSender_ = cdmaSmsSender; 576 smsSendManager->networkManager_->netWorkType_ = NetWorkType::NET_TYPE_GSM; 577 smsSendManager->DataBasedSmsDelivery(desAddr, scAddr, 1, data, 1, sendCallback, deliveryCallback); 578 smsSendManager->TextBasedSmsDelivery(desAddr, scAddr, text, sendCallback, deliveryCallback, dataBaseId); 579 EXPECT_EQ(smsSendManager->GetImsShortMessageFormat(format), TELEPHONY_ERR_SUCCESS); 580 smsSendManager->networkManager_->netWorkType_ = NetWorkType::NET_TYPE_CDMA; 581 smsSendManager->DataBasedSmsDelivery(desAddr, scAddr, 1, data, 1, sendCallback, deliveryCallback); 582 smsSendManager->TextBasedSmsDelivery(desAddr, scAddr, text, sendCallback, deliveryCallback, dataBaseId); 583 EXPECT_EQ(smsSendManager->GetImsShortMessageFormat(format), TELEPHONY_ERR_SUCCESS); 584 smsSendManager->networkManager_->netWorkType_ = NetWorkType::NET_TYPE_UNKNOWN; 585 smsSendManager->DataBasedSmsDelivery(desAddr, scAddr, 1, data, 1, sendCallback, deliveryCallback); 586 smsSendManager->TextBasedSmsDelivery(desAddr, scAddr, text, sendCallback, deliveryCallback, dataBaseId); 587 smsIndexer = nullptr; 588 smsSendManager->RetriedSmsDelivery(smsIndexer); 589 EXPECT_EQ(smsSendManager->GetImsShortMessageFormat(format), TELEPHONY_ERR_SUCCESS); 590} 591 592/** 593 * @tc.number Telephony_SmsMmsGtest_SmsSendManager_0002 594 * @tc.name Test SmsSendManager 595 * @tc.desc Function test 596 */ 597HWTEST_F(BranchSmsTest, SmsSendManager_0002, Function | MediumTest | Level1) 598{ 599 auto smsSendManager = std::make_shared<SmsSendManager>(INVALID_SLOTID); 600 std::function<void(std::shared_ptr<SmsSendIndexer>)> fun = nullptr; 601 std::string scAddr = "123"; 602 bool isSupported = true; 603 std::vector<std::u16string> splitMessage; 604 LengthInfo lenInfo; 605 const sptr<ISendShortMessageCallback> sendCallback = 606 iface_cast<ISendShortMessageCallback>(new SendShortMessageCallbackStub()); 607 const sptr<IDeliveryShortMessageCallback> deliveryCallback = 608 iface_cast<IDeliveryShortMessageCallback>(new DeliveryShortMessageCallbackStub()); 609 auto smsIndexer = std::make_shared<SmsSendIndexer>("", scAddr, "", sendCallback, deliveryCallback); 610 EXPECT_GT(smsSendManager->SplitMessage(scAddr, splitMessage), TELEPHONY_ERR_SUCCESS); 611 EXPECT_GT(smsSendManager->GetSmsSegmentsInfo(scAddr, true, lenInfo), TELEPHONY_ERR_SUCCESS); 612 EXPECT_GT(smsSendManager->IsImsSmsSupported(INVALID_SLOTID, isSupported), TELEPHONY_ERR_SUCCESS); 613 EXPECT_FALSE(smsSendManager->SetImsSmsConfig(INVALID_SLOTID, 1)); 614 smsSendManager->networkManager_ = std::make_shared<SmsNetworkPolicyManager>(INVALID_SLOTID); 615 EXPECT_FALSE(smsSendManager->SetImsSmsConfig(INVALID_SLOTID, 1)); 616 EXPECT_GT(smsSendManager->IsImsSmsSupported(INVALID_SLOTID, isSupported), TELEPHONY_ERR_SUCCESS); 617 smsSendManager->gsmSmsSender_ = std::make_shared<CdmaSmsSender>(INVALID_SLOTID, fun); 618 EXPECT_FALSE(smsSendManager->SetImsSmsConfig(INVALID_SLOTID, 1)); 619 EXPECT_GT(smsSendManager->IsImsSmsSupported(INVALID_SLOTID, isSupported), TELEPHONY_ERR_SUCCESS); 620 smsSendManager->cdmaSmsSender_ = std::make_shared<GsmSmsSender>(INVALID_SLOTID, fun); 621 smsSendManager->RetriedSmsDelivery(smsIndexer); 622 smsIndexer->netWorkType_ = NetWorkType::NET_TYPE_CDMA; 623 smsSendManager->networkManager_->netWorkType_ = NetWorkType::NET_TYPE_UNKNOWN; 624 smsSendManager->RetriedSmsDelivery(smsIndexer); 625 smsIndexer->netWorkType_ = NetWorkType::NET_TYPE_UNKNOWN; 626 EXPECT_FALSE(smsSendManager->SetImsSmsConfig(INVALID_SLOTID, 1)); 627 EXPECT_GT(smsSendManager->IsImsSmsSupported(INVALID_SLOTID, isSupported), TELEPHONY_ERR_SUCCESS); 628 EXPECT_GT(smsSendManager->GetSmsSegmentsInfo(scAddr, true, lenInfo), TELEPHONY_ERR_SUCCESS); 629 EXPECT_EQ(smsSendManager->SplitMessage(scAddr, splitMessage), TELEPHONY_ERR_SUCCESS); 630 smsSendManager->RetriedSmsDelivery(smsIndexer); 631 smsSendManager->networkManager_->netWorkType_ = NetWorkType::NET_TYPE_GSM; 632 smsIndexer->netWorkType_ = NetWorkType::NET_TYPE_GSM; 633 EXPECT_TRUE(smsSendManager->SetImsSmsConfig(INVALID_SLOTID, 1)); 634 EXPECT_EQ(smsSendManager->IsImsSmsSupported(INVALID_SLOTID, isSupported), TELEPHONY_ERR_SUCCESS); 635 EXPECT_EQ(smsSendManager->SplitMessage(scAddr, splitMessage), TELEPHONY_ERR_SUCCESS); 636 EXPECT_EQ(smsSendManager->GetSmsSegmentsInfo(scAddr, true, lenInfo), TELEPHONY_ERR_SUCCESS); 637 smsSendManager->RetriedSmsDelivery(smsIndexer); 638 smsSendManager->networkManager_->netWorkType_ = NetWorkType::NET_TYPE_CDMA; 639 smsIndexer->netWorkType_ = NetWorkType::NET_TYPE_CDMA; 640 smsSendManager->RetriedSmsDelivery(smsIndexer); 641 EXPECT_TRUE(smsSendManager->SetImsSmsConfig(INVALID_SLOTID, 1)); 642 EXPECT_EQ(smsSendManager->IsImsSmsSupported(INVALID_SLOTID, isSupported), TELEPHONY_ERR_SUCCESS); 643 EXPECT_EQ(smsSendManager->SplitMessage(scAddr, splitMessage), TELEPHONY_ERR_SUCCESS); 644 EXPECT_EQ(smsSendManager->GetSmsSegmentsInfo(scAddr, true, lenInfo), TELEPHONY_ERR_SUCCESS); 645} 646 647/** 648 * @tc.number Telephony_SmsMmsGtest_SmsInterfaceManager_0001 649 * @tc.name Test SmsInterfaceManager 650 * @tc.desc Function test 651 */ 652HWTEST_F(BranchSmsTest, SmsInterfaceManager_0001, Function | MediumTest | Level1) 653{ 654 auto smsSendManager = std::make_shared<SmsSendManager>(INVALID_SLOTID); 655 std::function<void(std::shared_ptr<SmsSendIndexer>)> fun = nullptr; 656 std::string scAddr = "123"; 657 const sptr<ISendShortMessageCallback> sendCallback = 658 iface_cast<ISendShortMessageCallback>(new SendShortMessageCallbackStub()); 659 const sptr<IDeliveryShortMessageCallback> deliveryCallback = 660 iface_cast<IDeliveryShortMessageCallback>(new DeliveryShortMessageCallbackStub()); 661 auto smsIndexer = std::make_shared<SmsSendIndexer>("", scAddr, "", sendCallback, deliveryCallback); 662 663 auto smsInterfaceManager = std::make_shared<SmsInterfaceManager>(INVALID_SLOTID); 664 EXPECT_EQ(smsInterfaceManager->OnRilAdapterHostDied(), TELEPHONY_ERR_LOCAL_PTR_NULL); 665 666 smsSendManager->gsmSmsSender_ = std::make_shared<GsmSmsSender>(INVALID_SLOTID, fun); 667 smsSendManager->cdmaSmsSender_ = std::make_shared<CdmaSmsSender>(INVALID_SLOTID, fun); 668 smsInterfaceManager->InitInterfaceManager(); 669 EXPECT_EQ(smsInterfaceManager->OnRilAdapterHostDied(), TELEPHONY_ERR_SUCCESS); 670} 671 672/** 673 * @tc.number Telephony_SmsMmsGtest_GsmSmsParamCodec_0001 674 * @tc.name Test GsmSmsParamCodec 675 * @tc.desc Function test 676 */ 677HWTEST_F(BranchSmsTest, GsmSmsParamCodec_0001, Function | MediumTest | Level1) 678{ 679 auto gsmSmsParamCodec = std::make_shared<GsmSmsParamCodec>(); 680 AddressNumber *pAddress = new AddressNumber(); 681 SmsTimeStamp *pTimeStamp = new SmsTimeStamp(); 682 pTimeStamp->format = SmsTimeFormat::SMS_TIME_ABSOLUTE; 683 pTimeStamp->time.absolute.timeZone = -1; 684 std::string paramStr; 685 EXPECT_GT(gsmSmsParamCodec->EncodeAddressPdu(pAddress, paramStr), 0); 686 pAddress->address[0] = '+'; 687 paramStr.clear(); 688 EXPECT_GT(gsmSmsParamCodec->EncodeAddressPdu(pAddress, paramStr), 0); 689 paramStr.clear(); 690 EXPECT_EQ(gsmSmsParamCodec->EncodeAddressPdu(nullptr, paramStr), 0); 691 692 paramStr.clear(); 693 gsmSmsParamCodec->EncodeTimePdu(nullptr, paramStr); 694 uint8_t value = 0; 695 EXPECT_GE(paramStr.size(), value); 696 paramStr.clear(); 697 gsmSmsParamCodec->EncodeTimePdu(pTimeStamp, paramStr); 698 EXPECT_GT(paramStr.size(), value); 699 pTimeStamp->format = SmsTimeFormat::SMS_TIME_RELATIVE; 700 paramStr.clear(); 701 uint8_t result = 1; 702 gsmSmsParamCodec->EncodeTimePdu(pTimeStamp, paramStr); 703 EXPECT_GE(paramStr.size(), result); 704 705 SmsDcs *pDCS = new SmsDcs(); 706 paramStr.clear(); 707 gsmSmsParamCodec->EncodeDCS(nullptr, paramStr); 708 EXPECT_EQ(paramStr.size(), value); 709 pDCS->codingGroup = PduSchemeGroup::CODING_DELETION_GROUP; 710 paramStr.clear(); 711 gsmSmsParamCodec->EncodeDCS(pDCS, paramStr); 712 EXPECT_GE(paramStr.size(), value); 713 714 pDCS->codingGroup = PduSchemeGroup::CODING_DISCARD_GROUP; 715 paramStr.clear(); 716 gsmSmsParamCodec->EncodeDCS(pDCS, paramStr); 717 EXPECT_GE(paramStr.size(), value); 718 719 pDCS->codingGroup = PduSchemeGroup::CODING_STORE_GROUP; 720 paramStr.clear(); 721 gsmSmsParamCodec->EncodeDCS(pDCS, paramStr); 722 EXPECT_GE(paramStr.size(), value); 723} 724 725/** 726 * @tc.number Telephony_SmsMmsGtest_GsmSmsParamCodec_0002 727 * @tc.name Test GsmSmsParamCodec 728 * @tc.desc Function test 729 */ 730HWTEST_F(BranchSmsTest, GsmSmsParamCodec_0002, Function | MediumTest | Level1) 731{ 732 auto gsmSmsParamCodec = std::make_shared<GsmSmsParamCodec>(); 733 std::string paramStr; 734 SmsDcs *pDCS = new SmsDcs(); 735 pDCS->codingGroup = PduSchemeGroup::CODING_GENERAL_GROUP; 736 pDCS->msgClass = SmsMessageClass::SMS_FORWARD_MESSAGE; 737 pDCS->bCompressed = true; 738 gsmSmsParamCodec->EncodeDCS(pDCS, paramStr); 739 uint8_t result = 0; 740 EXPECT_GE(paramStr.size(), result); 741 742 pDCS->codingGroup = PduSchemeGroup::SMS_CLASS_GROUP; 743 paramStr.clear(); 744 gsmSmsParamCodec->EncodeDCS(pDCS, paramStr); 745 EXPECT_GE(paramStr.size(), result); 746 747 pDCS->codingScheme = DataCodingScheme::DATA_CODING_7BIT; 748 paramStr.clear(); 749 gsmSmsParamCodec->EncodeDCS(pDCS, paramStr); 750 EXPECT_GE(paramStr.size(), result); 751 752 pDCS->codingScheme = DataCodingScheme::DATA_CODING_UCS2; 753 paramStr.clear(); 754 gsmSmsParamCodec->EncodeDCS(pDCS, paramStr); 755 EXPECT_GE(paramStr.size(), result); 756 757 pDCS->codingScheme = DataCodingScheme::DATA_CODING_8BIT; 758 paramStr.clear(); 759 gsmSmsParamCodec->EncodeDCS(pDCS, paramStr); 760 EXPECT_GE(paramStr.size(), result); 761 762 pDCS->codingScheme = DataCodingScheme::DATA_CODING_EUCKR; 763 paramStr.clear(); 764 gsmSmsParamCodec->EncodeDCS(pDCS, paramStr); 765 766 EXPECT_GE(paramStr.size(), result); 767 paramStr.clear(); 768 pDCS->codingGroup = PduSchemeGroup::CODING_UNKNOWN_GROUP; 769 gsmSmsParamCodec->EncodeDCS(pDCS, paramStr); 770 uint8_t value = 0; 771 EXPECT_EQ(paramStr.size(), value); 772 773 unsigned char encodeData[BUF_SIZE]; 774 char addressData[BUF_SIZE]; 775 char *address = addressData; 776 unsigned char *pEncodeAddr = encodeData; 777 EXPECT_EQ(gsmSmsParamCodec->EncodeSmscPdu(nullptr, nullptr), 0); 778 EXPECT_EQ(gsmSmsParamCodec->EncodeSmscPdu(address, nullptr), 0); 779 EXPECT_EQ(gsmSmsParamCodec->EncodeSmscPdu(address, pEncodeAddr), 0); 780} 781 782/** 783 * @tc.number Telephony_SmsMmsGtest_GsmSmsParamCodec_0003 784 * @tc.name Test GsmSmsParamCodec 785 * @tc.desc Function test 786 */ 787HWTEST_F(BranchSmsTest, GsmSmsParamCodec_0003, Function | MediumTest | Level1) 788{ 789 auto gsmSmsParamCodec = std::make_shared<GsmSmsParamCodec>(); 790 AddressNumber *pAddress = new AddressNumber(); 791 SmsDcs *pDCS = new SmsDcs(); 792 unsigned char encodeData[BUF_SIZE] = { 0 }; 793 unsigned char *pSMSC = encodeData; 794 std::string decodeAddr; 795 gsmSmsParamCodec->DecodeSmscPdu(pSMSC, 0, TypeOfNum::TYPE_UNKNOWN, decodeAddr); 796 gsmSmsParamCodec->DecodeSmscPdu(nullptr, 1, TypeOfNum::TYPE_UNKNOWN, decodeAddr); 797 gsmSmsParamCodec->DecodeSmscPdu(pSMSC, 1, TypeOfNum::TYPE_UNKNOWN, decodeAddr); 798 gsmSmsParamCodec->DecodeSmscPdu(pSMSC, 1, TypeOfNum::TYPE_INTERNATIONAL, decodeAddr); 799 gsmSmsParamCodec->DecodeSmscPdu(pSMSC, 1, TypeOfNum::TYPE_INTERNATIONAL, decodeAddr); 800 801 auto decodeBuffer = std::make_shared<SmsReadBuffer>("00"); 802 EXPECT_EQ(gsmSmsParamCodec->EncodeSmscPdu(nullptr, pSMSC, 0), 0); 803 EXPECT_EQ(gsmSmsParamCodec->EncodeSmscPdu(pAddress, nullptr, 0), 0); 804 EXPECT_EQ(gsmSmsParamCodec->EncodeSmscPdu(pAddress, pSMSC, 0), 0); 805 EXPECT_EQ(gsmSmsParamCodec->DecodeAddressPdu(*decodeBuffer, nullptr), 0); 806 EXPECT_EQ(gsmSmsParamCodec->DecodeAddressPdu(*decodeBuffer, pAddress), 0); 807 EXPECT_EQ(gsmSmsParamCodec->DecodeTimePdu(*decodeBuffer, nullptr), 0); 808 EXPECT_EQ(gsmSmsParamCodec->DecodeDcsPdu(*decodeBuffer, pDCS), 1); 809 EXPECT_EQ(gsmSmsParamCodec->DecodeDcsPdu(*decodeBuffer, nullptr), 0); 810 AddressNumber smsAddress; 811 EXPECT_EQ(gsmSmsParamCodec->DecodeSmscPdu(nullptr, 1, smsAddress), 0); 812 EXPECT_GE(gsmSmsParamCodec->DecodeSmscPdu(pSMSC, 1, smsAddress), 0); 813 EXPECT_EQ(gsmSmsParamCodec->CheckVoicemail(*decodeBuffer, nullptr, nullptr), 0); 814} 815 816/** 817 * @tc.number Telephony_SmsMmsGtest_GsmSmsParamCodec_0004 818 * @tc.name Test GsmSmsParamCodec 819 * @tc.desc Function test 820 */ 821HWTEST_F(BranchSmsTest, GsmSmsParamCodec_0004, Function | MediumTest | Level1) { 822 auto gsmSmsParamCodec = std::make_shared<GsmSmsParamCodec>(); 823 AddressNumber *pAddress = new AddressNumber(); 824 std::string pdu = StringUtils::HexToString("16D131D98C56B3DD7039584C36A3D56C375C0E169301"); // D1, ton = 5 825 auto decodeBuffer = std::make_shared<SmsReadBuffer>(pdu); 826 EXPECT_TRUE(gsmSmsParamCodec->DecodeAddressPdu(*decodeBuffer, pAddress)); 827} 828 829/** 830 * @tc.number Telephony_SmsMmsGtest_GsmSmsParamCodec_0005 831 * @tc.name Test GsmSmsParamCodec 832 * @tc.desc Function test 833 */ 834HWTEST_F(BranchSmsTest, GsmSmsParamCodec_0005, Function | MediumTest | Level1) { 835 auto gsmSmsParamCodec = std::make_shared<GsmSmsParamCodec>(); 836 AddressNumber *pAddress = new AddressNumber(); 837 std::string pdu = StringUtils::HexToString("16D131D98C56B3DD7039584A01"); // D1, ton = 5 838 auto decodeBuffer = std::make_shared<SmsReadBuffer>(pdu); 839 EXPECT_TRUE(gsmSmsParamCodec->DecodeAddressPdu(*decodeBuffer, pAddress)); 840} 841 842/** 843 * @tc.number Telephony_SmsMmsGtest_GsmSmsParamCodec_0006 844 * @tc.name Test GsmSmsParamCodec 845 * @tc.desc Function test 846 */ 847HWTEST_F(BranchSmsTest, GsmSmsParamCodec_0006, Function | MediumTest | Level1) { 848 auto gsmSmsParamCodec = std::make_shared<GsmSmsParamCodec>(); 849 AddressNumber *pAddress = new AddressNumber(); 850 std::string pdu = StringUtils::HexToString("0ED0A3F19CDD7A52A1"); // D0, ton = 5 851 auto decodeBuffer = std::make_shared<SmsReadBuffer>(pdu); 852 EXPECT_TRUE(gsmSmsParamCodec->DecodeAddressPdu(*decodeBuffer, pAddress)); 853} 854 855/** 856 * @tc.number Telephony_SmsMmsGtest_GsmSmsParamCodec_0007 857 * @tc.name Test GsmSmsParamCodec DecodeSmscPdu 858 * @tc.desc Function test 859 */ 860HWTEST_F(BranchSmsTest, GsmSmsParamCodec_0007, Function | MediumTest | Level1) { 861 /** 862 * test supporting number and + 863 */ 864 auto gsmSmsParamCodec = std::make_shared<GsmSmsParamCodec>(); 865 EXPECT_NE(gsmSmsParamCodec, nullptr); 866 AddressNumber smsAddress; 867 868 unsigned char encodeData[] = { 0x6, 0x90, 0x31, 0x00, 0x55, 0x05, 0x20, 0xF0 }; 869 unsigned char *pSMSC = encodeData; 870 EXPECT_GE(gsmSmsParamCodec->DecodeSmscPdu(pSMSC, 9, smsAddress), 0); 871 std::string address(smsAddress.address); 872 EXPECT_EQ(address, "+13005550020"); 873} 874 875/** 876 * @tc.number Telephony_SmsMmsGtest_GsmSmsParamCodec_0008 877 * @tc.name Test GsmSmsParamCodec DecodeSmscPdu 878 * @tc.desc Function test 879 */ 880HWTEST_F(BranchSmsTest, GsmSmsParamCodec_0008, Function | MediumTest | Level1) { 881 /** 882 * test supporting number * + and # 883 */ 884 auto gsmSmsParamCodec = std::make_shared<GsmSmsParamCodec>(); 885 EXPECT_NE(gsmSmsParamCodec, nullptr); 886 AddressNumber smsAddress; 887 888 unsigned char encodeData1[] = { 0x6, 0x91, 0x31, 0x00, 0x55, 0x05, 0x20, 0xB0 }; 889 unsigned char *pSMSC1 = encodeData1; 890 EXPECT_GE(gsmSmsParamCodec->DecodeSmscPdu(pSMSC1, 9, smsAddress), 0); 891 std::string address1(smsAddress.address); 892 EXPECT_EQ(address1, "+13005550020#"); 893 894 unsigned char encodeData2[] = { 0x2, 0x91, 0x2A, 0xB1 }; 895 unsigned char *pSMSC2 = encodeData2; 896 EXPECT_GE(gsmSmsParamCodec->DecodeSmscPdu(pSMSC2, 5, smsAddress), 0); 897 std::string address2(smsAddress.address); 898 EXPECT_EQ(address2, "*21#+"); 899 900 unsigned char encodeData3[] = { 0x3, 0x91, 0xAA, 0x12, 0xFB }; 901 unsigned char *pSMSC3 = encodeData3; 902 EXPECT_GE(gsmSmsParamCodec->DecodeSmscPdu(pSMSC3, 6, smsAddress), 0); 903 std::string address3(smsAddress.address); 904 EXPECT_EQ(address3, "**21#+"); 905} 906 907/** 908 * @tc.number Telephony_SmsMmsGtest_GsmSmsParamCodec_0009 909 * @tc.name Test GsmSmsParamCodec DecodeSmscPdu 910 * @tc.desc Function test 911 */ 912HWTEST_F(BranchSmsTest, GsmSmsParamCodec_0009, Function | MediumTest | Level1) { 913 /** 914 * test supporting number + * and # 915 */ 916 auto gsmSmsParamCodec = std::make_shared<GsmSmsParamCodec>(); 917 EXPECT_NE(gsmSmsParamCodec, nullptr); 918 AddressNumber smsAddress; 919 920 unsigned char encodeData1[] = { 0x8, 0x91, 0x9A, 0xA9, 0x31, 0x00, 0x55, 0x05, 0x20, 0xB0 }; 921 unsigned char *pSMSC1 = encodeData1; 922 EXPECT_GE(gsmSmsParamCodec->DecodeSmscPdu(pSMSC1, 11, smsAddress), 0); 923 std::string address1(smsAddress.address); 924 EXPECT_EQ(address1, "*99*+13005550020#"); 925 926 unsigned char encodeData5[] = { 0x9, 0x91, 0xAA, 0x12, 0x1A, 0x03, 0x50, 0x55, 0x00, 0x02, 0xFB }; 927 unsigned char *pSMSC2 = encodeData5; 928 EXPECT_GE(gsmSmsParamCodec->DecodeSmscPdu(pSMSC2, 12, smsAddress), 0); 929 std::string address2(smsAddress.address); 930 EXPECT_EQ(address2, "**21*+13005550020#"); 931 932 unsigned char encodeData6[] = { 0x9, 0x91, 0x2A, 0xB1, 0x31, 0x00, 0x55, 0x05, 0x20, 0xF0 }; 933 unsigned char *pSMSC3 = encodeData6; 934 EXPECT_GE(gsmSmsParamCodec->DecodeSmscPdu(pSMSC3, 12, smsAddress), 0); 935 std::string address3(smsAddress.address); 936 EXPECT_EQ(address3, "*21#+13005550020"); 937} 938 939/** 940 * @tc.number Telephony_SmsMmsGtest_GsmSmsParamCodec_0010 941 * @tc.name Test GsmSmsParamCodec EncodeSmscPdu and DecodeSmscPdu 942 * @tc.desc Function test 943 */ 944HWTEST_F(BranchSmsTest, GsmSmsParamCodec_0010, Function | MediumTest | Level1) { 945 /** 946 * test supporting number 947 */ 948 auto gsmSmsParamCodec = std::make_shared<GsmSmsParamCodec>(); 949 EXPECT_NE(gsmSmsParamCodec, nullptr); 950 const std::string smsc = "17005550020"; 951 AddressNumber *pAddress = new AddressNumber(); 952 uint8_t encodeSmscAddr[MAX_SMSC_LEN]; 953 memset_s(encodeSmscAddr, sizeof(encodeSmscAddr), 0x00, sizeof(encodeSmscAddr)); 954 std::string decodeAddr; 955 memcpy_s(&pAddress->address, sizeof(pAddress->address), smsc.data(), smsc.length()); 956 pAddress->address[smsc.length()] = '\0'; 957 pAddress->ton = TYPE_INTERNATIONAL; 958 pAddress->npi = SMS_NPI_ISDN; 959 uint8_t encodeSmscLen = 0; 960 encodeSmscLen = gsmSmsParamCodec->EncodeSmscPdu(pAddress, encodeSmscAddr, sizeof(encodeSmscAddr)); 961 EXPECT_GE(encodeSmscLen, 0); 962 963 AddressNumber smsAddress; 964 unsigned char *pSMSC = encodeSmscAddr; 965 EXPECT_GE(gsmSmsParamCodec->DecodeSmscPdu(pSMSC, sizeof(encodeSmscAddr), smsAddress), 0); 966 std::string address2(smsAddress.address); 967 EXPECT_EQ(address2, "+" + smsc); 968} 969 970/** 971 * @tc.number Telephony_SmsMmsGtest_GsmSmsParamCodec_0011 972 * @tc.name Test GsmSmsParamCodec EncodeSmscPdu and DecodeSmscPdu 973 * @tc.desc Function test 974 */ 975HWTEST_F(BranchSmsTest, GsmSmsParamCodec_0011, Function | MediumTest | Level1) { 976 /** 977 * test supporting number 978 */ 979 auto gsmSmsParamCodec = std::make_shared<GsmSmsParamCodec>(); 980 EXPECT_NE(gsmSmsParamCodec, nullptr); 981 const std::string smsc = "**21#"; 982 AddressNumber *pAddress = new AddressNumber(); 983 uint8_t encodeSmscAddr[MAX_SMSC_LEN]; 984 memset_s(encodeSmscAddr, sizeof(encodeSmscAddr), 0x00, sizeof(encodeSmscAddr)); 985 std::string decodeAddr; 986 memcpy_s(&pAddress->address, sizeof(pAddress->address), smsc.data(), smsc.length()); 987 pAddress->address[smsc.length()] = '\0'; 988 pAddress->ton = TYPE_INTERNATIONAL; 989 pAddress->npi = SMS_NPI_ISDN; 990 uint8_t encodeSmscLen = 0; 991 encodeSmscLen = gsmSmsParamCodec->EncodeSmscPdu(pAddress, encodeSmscAddr, sizeof(encodeSmscAddr)); 992 EXPECT_GE(encodeSmscLen, 0); 993 994 AddressNumber smsAddress; 995 unsigned char *pSMSC = encodeSmscAddr; 996 EXPECT_GE(gsmSmsParamCodec->DecodeSmscPdu(pSMSC, sizeof(encodeSmscAddr), smsAddress), 0); 997 std::string address2(smsAddress.address); 998 EXPECT_EQ(address2, smsc + "+"); 999} 1000 1001/** 1002 * @tc.number Telephony_SmsMmsGtest_GsmSmsParamCodec_0012 1003 * @tc.name Test GsmSmsParamCodec EncodeSmscPdu and DecodeSmscPdu 1004 * @tc.desc Function test 1005 */ 1006HWTEST_F(BranchSmsTest, GsmSmsParamCodec_0012, Function | MediumTest | Level1) { 1007 /** 1008 * test supporting number 1009 */ 1010 auto gsmSmsParamCodec = std::make_shared<GsmSmsParamCodec>(); 1011 EXPECT_NE(gsmSmsParamCodec, nullptr); 1012 const std::string smsc = "**21*13005550020#"; 1013 AddressNumber *pAddress = new AddressNumber(); 1014 uint8_t encodeSmscAddr[MAX_SMSC_LEN]; 1015 memset_s(encodeSmscAddr, sizeof(encodeSmscAddr), 0x00, sizeof(encodeSmscAddr)); 1016 std::string decodeAddr; 1017 memcpy_s(&pAddress->address, sizeof(pAddress->address), smsc.data(), smsc.length()); 1018 pAddress->address[smsc.length()] = '\0'; 1019 pAddress->ton = TYPE_INTERNATIONAL; 1020 pAddress->npi = SMS_NPI_ISDN; 1021 uint8_t encodeSmscLen = 0; 1022 encodeSmscLen = gsmSmsParamCodec->EncodeSmscPdu(pAddress, encodeSmscAddr, sizeof(encodeSmscAddr)); 1023 EXPECT_GE(encodeSmscLen, 0); 1024 1025 AddressNumber smsAddress; 1026 unsigned char *pSMSC = encodeSmscAddr; 1027 EXPECT_GE(gsmSmsParamCodec->DecodeSmscPdu(pSMSC, sizeof(encodeSmscAddr), smsAddress), 0); 1028 std::string address2(smsAddress.address); 1029 EXPECT_EQ(address2, "**21*+13005550020#"); 1030} 1031 1032/** 1033 * @tc.number Telephony_SmsMmsGtest_GsmSmsParamCodec_0013 1034 * @tc.name Test GsmSmsParamCodec DecodeAddressPdu 1035 * @tc.desc Function test 1036 */ 1037HWTEST_F(BranchSmsTest, GsmSmsParamCodec_0013, Function | MediumTest | Level1) { 1038 /** 1039 * test DecodeAddressPdu when ton is TYPE_INTERNATIONAL 1040 */ 1041 auto gsmSmsParamCodec = std::make_shared<GsmSmsParamCodec>(); 1042 EXPECT_NE(gsmSmsParamCodec, nullptr); 1043 AddressNumber *pAddress = new AddressNumber(); 1044 std::string hexStr = "0891683108501705F0040D91683177474733F20008429011015535230E90FD4E0D559C6B227684597D50CF"; 1045 std::string pdu = StringUtils::HexToString(hexStr); 1046 auto decodeBuffer = std::make_shared<SmsReadBuffer>(pdu); 1047 EXPECT_TRUE(gsmSmsParamCodec->DecodeAddressPdu(*decodeBuffer, pAddress)); 1048 EXPECT_NE(pAddress, nullptr); 1049 std::string address = pAddress->address; 1050 EXPECT_TRUE(address.find('+') != std::string::npos); 1051} 1052 1053/** 1054 * @tc.number Telephony_SmsMmsGtest_CreateMessage_0001 1055 * @tc.name Test CreateMessage 1056 * @tc.desc Function test 1057 */ 1058HWTEST_F(BranchSmsTest, CreateMessage_0001, Function | MediumTest | Level1) { 1059 /* 1060 step1: The pdu whose mti is 0 1061 */ 1062 std::string pduHex = "07914151551512f2040B916105551511f100006060605130308A04D4F29C0E"; 1063 /* 1064 step2: Decoding pdu packets 1065 */ 1066 GsmSmsMessage message; 1067 auto result = message.CreateMessage(pduHex); 1068 EXPECT_TRUE(result != nullptr); 1069 EXPECT_TRUE(result->GetSmscAddr()== "+14155551212"); 1070 EXPECT_TRUE(result->GetOriginatingAddress() == "+16505551111"); 1071} 1072 1073/** 1074 * @tc.number Telephony_SmsMmsGtest_CreateMessage_0002 1075 * @tc.name Test CreateMessage 1076 * @tc.desc Function test 1077 */ 1078HWTEST_F(BranchSmsTest, CreateMessage_0002, Function | MediumTest | Level1) { 1079 /* 1080 step1: The pdu whose mti is 1 1081 */ 1082 std::string pduHex = "07914151551512f2050B916105551511f100006060605130308A04D4F29C0E"; 1083 /* 1084 step2: Decoding pdu packets 1085 */ 1086 GsmSmsMessage message; 1087 auto result = message.CreateMessage(pduHex); 1088 EXPECT_EQ(result, nullptr); 1089} 1090 1091/** 1092 * @tc.number Telephony_SmsMmsGtest_CreateMessage_0003 1093 * @tc.name Test CreateMessage 1094 * @tc.desc Function test 1095 */ 1096HWTEST_F(BranchSmsTest, CreateMessage_0003, Function | MediumTest | Level1) { 1097 /* 1098 step1: The pdu whose mti is 2 1099 */ 1100 std::string pduHex = "07914151551512f2060B916105551511f100006060605130308A04D4F29C0E"; 1101 /* 1102 step2: Decoding pdu packets 1103 */ 1104 GsmSmsMessage message; 1105 auto result = message.CreateMessage(pduHex); 1106 EXPECT_EQ(result, nullptr); 1107} 1108 1109/** 1110 * @tc.number Telephony_SmsMmsGtest_CreateMessage_0004 1111 * @tc.name Test CreateMessage 1112 * @tc.desc Function test 1113 */ 1114HWTEST_F(BranchSmsTest, CreateMessage_0004, Function | MediumTest | Level1) { 1115 /* 1116 step1: The pdu whose mti is 3 1117 */ 1118 std::string pduHex = "07914151551512f2070B916105551511f100006060605130308A04D4F29C0E"; 1119 /* 1120 step2: Decoding pdu packets 1121 */ 1122 GsmSmsMessage message; 1123 auto result = message.CreateMessage(pduHex); 1124 EXPECT_TRUE(result != nullptr); 1125 EXPECT_TRUE(result->GetSmscAddr() == "+14155551212"); 1126 EXPECT_TRUE(result->GetOriginatingAddress() == "+16505551111"); 1127} 1128 1129/** 1130 * @tc.number Telephony_SmsMmsGtest_CreateMessage_0005 1131 * @tc.name Test CreateMessage 1132 * @tc.desc Function test 1133 */ 1134HWTEST_F(BranchSmsTest, CreateMessage_0005, Function | MediumTest | Level1) { 1135 /* 1136 step1: The pdu whose ton is TYPE_ALPHA_NUMERIC 1137 */ 1138 const std::string pduHex = 1139 "07915892208800F0040ED0A3F19CDD7A52A10008424011119582235C4F60768400630073006C00200041007000" 1140 "704E006B2160275BC678BC70BA0034003800370033003200373002598267097591554FFF0C8ACB806F7D61006300" 1141 "73006C670D52D971B17DDA003200350031003200330031003200333002"; 1142 /* 1143 step2: Decoding pdu packets 1144 */ 1145 GsmSmsMessage message; 1146 auto result = message.CreateMessage(pduHex); 1147 EXPECT_TRUE(result != nullptr); 1148 EXPECT_TRUE(result->GetSmscAddr() == "+85290288000"); 1149 EXPECT_TRUE(result->GetOriginatingAddress() == "#csl-OTP"); 1150} 1151 1152/** 1153 * @tc.number Telephony_SmsMmsGtest_CreateMessage_0006 1154 * @tc.name Test CreateMessage 1155 * @tc.desc Function test 1156 */ 1157HWTEST_F(BranchSmsTest, CreateMessage_0006, Function | MediumTest | Level1) { 1158 /* 1159 step1: The pdu whose ton is TYPE_ALPHA_NUMERIC 1160 */ 1161 const std::string pduHex = 1162 "07915892208800F0040ED0B4F19CDD8B61A10108424011119582235C4F60768400630073006C0020004100700" 1163 "0704E006B2160275BC678BC70BA0034003800370033003200373002598267097591554FFF0C8ACB806F7D610063" 1164 "0073006C670D52D971B17DDA003200350031003200330031003200333002"; 1165 /* 1166 step2: Decoding pdu packets 1167 */ 1168 GsmSmsMessage message; 1169 auto result = message.CreateMessage(pduHex); 1170 EXPECT_TRUE(result != nullptr); 1171 EXPECT_TRUE(result->GetSmscAddr() == "+85290288000"); 1172 EXPECT_TRUE(result->GetOriginatingAddress() == "4csl=1XP"); 1173} 1174 1175/** 1176 * @tc.number Telephony_SmsMmsGtest_GsmSmsUDataCodec_0001 1177 * @tc.name Test GsmUserDataPdu 1178 * @tc.desc Function test 1179 */ 1180HWTEST_F(BranchSmsTest, GsmSmsUDataCodec_0001, Function | MediumTest | Level1) 1181{ 1182 auto udPdu = std::make_shared<GsmUserDataPdu>(); 1183 SmsUDPackage smsUserData; 1184 SmsTpud *pTPUD = new SmsTpud(); 1185 const struct SmsUDPackage *pUserData = &(smsUserData); 1186 auto encodeBuffer = std::make_shared<SmsWriteBuffer>(); 1187 auto decodeBuffer = std::make_shared<SmsReadBuffer>("00"); 1188 std::string str; 1189 EXPECT_GT(udPdu->EncodeUserDataPdu(*encodeBuffer, pUserData, DataCodingScheme::DATA_CODING_7BIT, str), 0); 1190 EXPECT_GT(udPdu->EncodeUserDataPdu(*encodeBuffer, pUserData, DataCodingScheme::DATA_CODING_8BIT, str), 0); 1191 EXPECT_GT(udPdu->EncodeUserDataPdu(*encodeBuffer, pUserData, DataCodingScheme::DATA_CODING_UCS2, str), 0); 1192 EXPECT_EQ(udPdu->EncodeUserDataPdu(*encodeBuffer, pUserData, DataCodingScheme::DATA_CODING_ASCII7BIT, str), 0); 1193 SmsUDPackage *userData = new SmsUDPackage(); 1194 EXPECT_GE(udPdu->DecodeUserDataPdu(*decodeBuffer, true, DataCodingScheme::DATA_CODING_7BIT, userData, pTPUD), 0); 1195 EXPECT_GE(udPdu->DecodeUserDataPdu(*decodeBuffer, true, DataCodingScheme::DATA_CODING_8BIT, userData, pTPUD), 0); 1196 EXPECT_GE(udPdu->DecodeUserDataPdu(*decodeBuffer, true, DataCodingScheme::DATA_CODING_UCS2, userData, pTPUD), 0); 1197 EXPECT_EQ( 1198 udPdu->DecodeUserDataPdu(*decodeBuffer, true, DataCodingScheme::DATA_CODING_ASCII7BIT, userData, pTPUD), 0); 1199 EXPECT_GE(udPdu->DecodeUserDataPdu(*decodeBuffer, true, DataCodingScheme::DATA_CODING_7BIT, userData), 0); 1200 EXPECT_GE(udPdu->DecodeUserDataPdu(*decodeBuffer, true, DataCodingScheme::DATA_CODING_8BIT, userData), 0); 1201 EXPECT_GE(udPdu->DecodeUserDataPdu(*decodeBuffer, true, DataCodingScheme::DATA_CODING_UCS2, userData), 0); 1202 EXPECT_EQ(udPdu->DecodeUserDataPdu(*decodeBuffer, true, DataCodingScheme::DATA_CODING_ASCII7BIT, userData), 0); 1203 1204 auto encode = std::make_shared<GsmUserDataEncode>(udPdu); 1205 auto decode = std::make_shared<GsmUserDataDecode>(udPdu); 1206 EXPECT_TRUE(encode->Encode8bitPdu(*encodeBuffer, userData, str)); 1207 EXPECT_TRUE(encode->EncodeUcs2Pdu(*encodeBuffer, userData)); 1208 userData->headerCnt = 1; 1209 userData->length = BUFFER_SIZE; 1210 EXPECT_EQ(encode->Encode8bitPdu(*encodeBuffer, userData, str), 0); 1211 EXPECT_EQ(encode->EncodeUcs2Pdu(*encodeBuffer, userData), 0); 1212 EXPECT_EQ(decode->DecodeGsmPdu(*decodeBuffer, true, userData, pTPUD), 0); 1213 EXPECT_FALSE(decode->DecodeGsmPdu(*decodeBuffer, false, userData, pTPUD)); 1214 EXPECT_FALSE(decode->Decode8bitPdu(*decodeBuffer, true, userData, pTPUD)); 1215 EXPECT_FALSE(decode->DecodeGsmPdu(*decodeBuffer, false, userData, pTPUD)); 1216 EXPECT_FALSE(decode->DecodeUcs2Pdu(*decodeBuffer, true, userData, pTPUD)); 1217 EXPECT_FALSE(decode->DecodeGsmPdu(*decodeBuffer, false, userData, pTPUD)); 1218 decode->userData_ = nullptr; 1219 EXPECT_FALSE(decode->Decode8bitPduPartData(*decodeBuffer, false, userData, pTPUD, 0, 0)); 1220 EXPECT_FALSE(decode->Decode8bitPduPartData(*decodeBuffer, false, userData, pTPUD, 1, 1)); 1221} 1222 1223/** 1224 * @tc.number Telephony_SmsMmsGtest_GsmSmsUDataCodec_0002 1225 * @tc.name Test GsmUserDataPdu 1226 * @tc.desc Function test 1227 */ 1228HWTEST_F(BranchSmsTest, GsmSmsUDataCodec_0002, Function | MediumTest | Level1) 1229{ 1230 auto gsmUserDataPdu = std::make_shared<GsmUserDataPdu>(); 1231 SmsUDH header; 1232 header.udhType = UDH_CONCAT_8BIT; 1233 auto encodeBuffer = std::make_shared<SmsWriteBuffer>(); 1234 encodeBuffer->data_[0] = 1; 1235 gsmUserDataPdu->EncodeHeaderConcat(*encodeBuffer, header); 1236 gsmUserDataPdu->EncodeHeader(*encodeBuffer, header); 1237 header.udhType = UDH_CONCAT_16BIT; 1238 gsmUserDataPdu->EncodeHeaderConcat(*encodeBuffer, header); 1239 gsmUserDataPdu->EncodeHeader(*encodeBuffer, header); 1240 header.udhType = UDH_APP_PORT_8BIT; 1241 gsmUserDataPdu->EncodeHeader(*encodeBuffer, header); 1242 header.udhType = UDH_APP_PORT_16BIT; 1243 gsmUserDataPdu->EncodeHeader(*encodeBuffer, header); 1244 header.udhType = UDH_ALTERNATE_REPLY_ADDRESS; 1245 gsmUserDataPdu->EncodeHeader(*encodeBuffer, header); 1246 header.udhType = UDH_SINGLE_SHIFT; 1247 gsmUserDataPdu->EncodeHeader(*encodeBuffer, header); 1248 header.udhType = UDH_LOCKING_SHIFT; 1249 gsmUserDataPdu->EncodeHeader(*encodeBuffer, header); 1250 header.udhType = UDH_NONE; 1251 gsmUserDataPdu->EncodeHeaderConcat(*encodeBuffer, header); 1252 gsmUserDataPdu->EncodeHeader(*encodeBuffer, header); 1253 header.udhType = UDH_EMS_LAST; 1254 gsmUserDataPdu->EncodeHeaderConcat(*encodeBuffer, header); 1255 gsmUserDataPdu->EncodeHeader(*encodeBuffer, header); 1256 SmsUDH *pHeader = new SmsUDH(); 1257 1258 pHeader->udhType = UserDataHeadType::UDH_CONCAT_8BIT; 1259 uint16_t headerLen = 0; 1260 auto decodeBuffer = std::make_shared<SmsReadBuffer>("00"); 1261 decodeBuffer->data_[0] = 1; 1262 EXPECT_EQ(gsmUserDataPdu->DecodeHeader(*decodeBuffer, *pHeader, headerLen), 0); 1263 pHeader->udhType = UserDataHeadType::UDH_CONCAT_16BIT; 1264 EXPECT_EQ(gsmUserDataPdu->DecodeHeader(*decodeBuffer, *pHeader, headerLen), 0); 1265 pHeader->udhType = UserDataHeadType::UDH_APP_PORT_8BIT; 1266 EXPECT_EQ(gsmUserDataPdu->DecodeHeader(*decodeBuffer, *pHeader, headerLen), 0); 1267 pHeader->udhType = UserDataHeadType::UDH_APP_PORT_16BIT; 1268 EXPECT_EQ(gsmUserDataPdu->DecodeHeader(*decodeBuffer, *pHeader, headerLen), 0); 1269 pHeader->udhType = UserDataHeadType::UDH_SPECIAL_SMS; 1270 EXPECT_EQ(gsmUserDataPdu->DecodeHeader(*decodeBuffer, *pHeader, headerLen), 0); 1271 pHeader->udhType = UserDataHeadType::UDH_ALTERNATE_REPLY_ADDRESS; 1272 EXPECT_EQ(gsmUserDataPdu->DecodeHeader(*decodeBuffer, *pHeader, headerLen), 0); 1273 pHeader->udhType = UserDataHeadType::UDH_SINGLE_SHIFT; 1274 EXPECT_EQ(gsmUserDataPdu->DecodeHeader(*decodeBuffer, *pHeader, headerLen), 0); 1275} 1276 1277/** 1278 * @tc.number Telephony_SmsMmsGtest_GsmSmsUDataCodec_0003 1279 * @tc.name Test GsmUserDataPdu 1280 * @tc.desc Function test 1281 */ 1282HWTEST_F(BranchSmsTest, GsmSmsUDataCodec_0003, Function | MediumTest | Level1) 1283{ 1284 auto gsmUserDataPdu = std::make_shared<GsmUserDataPdu>(); 1285 SmsUDH *pHeader = new SmsUDH(); 1286 pHeader->udhType = UDH_CONCAT_8BIT; 1287 gsmUserDataPdu->DebugDecodeHeader(*pHeader); 1288 pHeader->udhType = UDH_CONCAT_16BIT; 1289 gsmUserDataPdu->DebugDecodeHeader(*pHeader); 1290 pHeader->udhType = UDH_APP_PORT_8BIT; 1291 gsmUserDataPdu->DebugDecodeHeader(*pHeader); 1292 pHeader->udhType = UDH_APP_PORT_16BIT; 1293 gsmUserDataPdu->DebugDecodeHeader(*pHeader); 1294 pHeader->udhType = UDH_SPECIAL_SMS; 1295 gsmUserDataPdu->DebugDecodeHeader(*pHeader); 1296 pHeader->udhType = UDH_ALTERNATE_REPLY_ADDRESS; 1297 gsmUserDataPdu->DebugDecodeHeader(*pHeader); 1298 pHeader->udhType = UDH_SINGLE_SHIFT; 1299 gsmUserDataPdu->DebugDecodeHeader(*pHeader); 1300 pHeader->udhType = UDH_LOCKING_SHIFT; 1301 gsmUserDataPdu->DebugDecodeHeader(*pHeader); 1302 pHeader->udhType = UDH_NONE; 1303 gsmUserDataPdu->DebugDecodeHeader(*pHeader); 1304 pHeader->udhType = UserDataHeadType::UDH_LOCKING_SHIFT; 1305 1306 auto decodeBuffer = std::make_shared<SmsReadBuffer>("00"); 1307 decodeBuffer->data_[0] = 1; 1308 uint16_t headerLen; 1309 EXPECT_EQ(gsmUserDataPdu->DecodeHeader(*decodeBuffer, *pHeader, headerLen), 0); 1310 pHeader->udhType = UserDataHeadType::UDH_NONE; 1311 EXPECT_EQ(gsmUserDataPdu->DecodeHeader(*decodeBuffer, *pHeader, headerLen), 0); 1312} 1313 1314/** 1315 * @tc.number Telephony_SmsMmsGtest_GsmSmsTpduCodec_0001 1316 * @tc.name Test GsmSmsTpduCodec 1317 * @tc.desc Function test 1318 */ 1319HWTEST_F(BranchSmsTest, GsmSmsTpduCodec_0001, Function | MediumTest | Level1) 1320{ 1321 unsigned char encodeData[BUF_SIZE]; 1322 unsigned char *pSMSC = encodeData; 1323 char addressData[BUF_SIZE]; 1324 char *pDecodeAddr = addressData; 1325 auto smsTpdu = std::make_shared<SmsTpdu>(); 1326 smsTpdu->tpduType = SmsTpduType::SMS_TPDU_SUBMIT; 1327 1328 uint16_t bufLen; 1329 auto tpduCodec = std::make_shared<GsmSmsTpduCodec>(); 1330 EXPECT_GE(tpduCodec->EncodeSmsPdu(smsTpdu, pDecodeAddr, 1, bufLen), 0); 1331 smsTpdu->tpduType = SmsTpduType::SMS_TPDU_DELIVER; 1332 EXPECT_GE(tpduCodec->EncodeSmsPdu(smsTpdu, pDecodeAddr, 1, bufLen), 0); 1333 smsTpdu->tpduType = SmsTpduType::SMS_TPDU_DELIVER_REP; 1334 EXPECT_GE(tpduCodec->EncodeSmsPdu(smsTpdu, pDecodeAddr, 1, bufLen), 0); 1335 smsTpdu->tpduType = SmsTpduType::SMS_TPDU_STATUS_REP; 1336 EXPECT_GE(tpduCodec->EncodeSmsPdu(smsTpdu, pDecodeAddr, 1, bufLen), 0); 1337 1338 SmsTpdu *pSmsTpdu = new SmsTpdu(); 1339 EXPECT_EQ(tpduCodec->DecodeSmsPdu(nullptr, 1, pSmsTpdu), 0); 1340 EXPECT_EQ(tpduCodec->DecodeSmsPdu(pSMSC, 1, nullptr), 0); 1341 EXPECT_GE(tpduCodec->DecodeSmsPdu(pSMSC, 1, pSmsTpdu), 0); 1342 pSMSC[0] = 1; 1343 EXPECT_GE(tpduCodec->DecodeSmsPdu(pSMSC, 1, pSmsTpdu), 0); 1344 pSMSC[0] = VALUE_LENGTH; 1345 EXPECT_GE(tpduCodec->DecodeSmsPdu(pSMSC, 1, pSmsTpdu), 0); 1346 pSMSC[0] = HEADER_LENGTH; 1347 EXPECT_EQ(tpduCodec->DecodeSmsPdu(pSMSC, 1, pSmsTpdu), 0); 1348} 1349 1350/** 1351 * @tc.number Telephony_SmsMmsGtest_GsmSmsTpduCodec_0002 1352 * @tc.name Test GsmSmsTpduCodec 1353 * @tc.desc Function test 1354 */ 1355HWTEST_F(BranchSmsTest, GsmSmsTpduCodec_0002, Function | MediumTest | Level1) 1356{ 1357 auto tpduCodec = std::make_shared<GsmSmsTpduCodec>(); 1358 auto encode = std::make_shared<GsmSmsTpduEncode>(tpduCodec->uDataCodec_, tpduCodec->paramCodec_, tpduCodec); 1359 auto encodeBuffer = std::make_shared<SmsWriteBuffer>(); 1360 encodeBuffer->data_[0] = 1; 1361 SmsSubmit *pSubmit = new SmsSubmit(); 1362 SmsDeliver *pDeliver = new SmsDeliver(); 1363 SmsDeliverReport *pDeliverRep = new SmsDeliverReport(); 1364 EXPECT_EQ(encode->EncodeSubmitPdu(*encodeBuffer, nullptr), 0); 1365 EXPECT_EQ(encode->EncodeSubmitPdu(*encodeBuffer, pSubmit), 1); 1366 EXPECT_EQ(encode->EncodeDeliverPdu(*encodeBuffer, nullptr), 0); 1367 EXPECT_EQ(encode->EncodeDeliverPdu(*encodeBuffer, pDeliver), 0); 1368 pDeliver->bMoreMsg = false; 1369 pDeliver->bStatusReport = true; 1370 pDeliver->bHeaderInd = true; 1371 pDeliver->bReplyPath = true; 1372 EXPECT_GE(encode->EncodeDeliverPdu(*encodeBuffer, pDeliver), 0); 1373 EXPECT_EQ(encode->EncodeDeliverReportPdu(*encodeBuffer, nullptr), 0); 1374 EXPECT_EQ(encode->EncodeDeliverReportPdu(*encodeBuffer, pDeliverRep), 0); 1375 pDeliverRep->bHeaderInd = true; 1376 pDeliverRep->reportType = _SMS_REPORT_TYPE_E::SMS_REPORT_NEGATIVE; 1377 pDeliverRep->paramInd = 1; 1378 EXPECT_GE(encode->EncodeDeliverReportPdu(*encodeBuffer, pDeliverRep), 0); 1379 pDeliverRep->paramInd = VALUE_LENGTH; 1380 EXPECT_GE(encode->EncodeDeliverReportPdu(*encodeBuffer, pDeliverRep), 0); 1381 pDeliverRep->paramInd = START_BIT; 1382 EXPECT_GE(encode->EncodeDeliverReportPdu(*encodeBuffer, pDeliverRep), 0); 1383} 1384 1385/** 1386 * @tc.number Telephony_SmsMmsGtest_GsmSmsTpduCodec_0003 1387 * @tc.name Test GsmSmsTpduCodec 1388 * @tc.desc Function test 1389 */ 1390HWTEST_F(BranchSmsTest, GsmSmsTpduCodec_0003, Function | MediumTest | Level1) 1391{ 1392 auto tpduCodec = std::make_shared<GsmSmsTpduCodec>(); 1393 SmsStatusReport *pStatusRep = new SmsStatusReport(); 1394 SmsSubmit *pSmsSub = new SmsSubmit(); 1395 1396 auto encode = std::make_shared<GsmSmsTpduEncode>(tpduCodec->uDataCodec_, tpduCodec->paramCodec_, tpduCodec); 1397 auto encodeBuffer = std::make_shared<SmsWriteBuffer>(); 1398 encodeBuffer->data_[0] = 1; 1399 EXPECT_EQ(encode->EncodeStatusReportPdu(*encodeBuffer, nullptr), 0); 1400 EXPECT_EQ(encode->EncodeStatusReportPdu(*encodeBuffer, pStatusRep), 0); 1401 pStatusRep->bMoreMsg = true; 1402 pStatusRep->bStatusReport = true; 1403 pStatusRep->bHeaderInd = true; 1404 pStatusRep->paramInd = 1; 1405 EXPECT_GE(encode->EncodeStatusReportPdu(*encodeBuffer, pStatusRep), 0); 1406 pStatusRep->paramInd = VALUE_LENGTH; 1407 EXPECT_GE(encode->EncodeStatusReportPdu(*encodeBuffer, pStatusRep), 0); 1408 pStatusRep->paramInd = START_BIT; 1409 EXPECT_GE(encode->EncodeStatusReportPdu(*encodeBuffer, pStatusRep), 0); 1410 1411 auto decode = std::make_shared<GsmSmsTpduDecode>(tpduCodec->uDataCodec_, tpduCodec->paramCodec_, tpduCodec); 1412 auto decodeBuffer = std::make_shared<SmsReadBuffer>("00"); 1413 decodeBuffer->data_[0] = 1; 1414 EXPECT_EQ(decode->DecodeSubmit(*decodeBuffer, pSmsSub), 0); 1415 EXPECT_EQ(decode->DecodeSubmit(*decodeBuffer, nullptr), 0); 1416 SmsDeliver *pDeliver = new SmsDeliver(); 1417 EXPECT_EQ(decode->DecodeDeliver(*decodeBuffer, pDeliver), 0); 1418 EXPECT_EQ(decode->DecodeDeliver(*decodeBuffer, nullptr), 0); 1419 EXPECT_EQ(decode->DecodeStatusReport(*decodeBuffer, pStatusRep), 0); 1420 EXPECT_EQ(decode->DecodeStatusReport(*decodeBuffer, nullptr), 0); 1421} 1422 1423/** 1424 * @tc.number Telephony_SmsMmsGtest_GsmSmsTpduCodec_0004 1425 * @tc.name Test GsmSmsTpduCodec 1426 * @tc.desc Function test 1427 */ 1428HWTEST_F(BranchSmsTest, GsmSmsTpduCodec_0004, Function | MediumTest | Level1) 1429{ 1430 auto tpduCodec = std::make_shared<GsmSmsTpduCodec>(); 1431 auto smsTpdu_ = std::make_shared<SmsTpdu>(); 1432 char tpduBuf[MAX_TPDU_DATA_LEN] = { 0 }; 1433 uint16_t bufLen; 1434 bool ret = tpduCodec->EncodeSmsPdu(smsTpdu_, tpduBuf, sizeof(tpduBuf), bufLen); 1435 SmsSubmit pSubmit; 1436 pSubmit.bRejectDup = true; 1437 pSubmit.bStatusReport = true; 1438 pSubmit.bHeaderInd = true; 1439 pSubmit.bReplyPath = true; 1440 auto decodeBuffer = std::make_shared<SmsReadBuffer>("00"); 1441 decodeBuffer->data_[0] = 1; 1442 tpduCodec->DebugTpdu(*decodeBuffer, SmsParseType::PARSE_SUBMIT_TYPE); 1443 1444 auto encodeBuffer = std::make_shared<SmsWriteBuffer>(); 1445 encodeBuffer->data_[0] = 1; 1446 auto encode = std::make_shared<GsmSmsTpduEncode>(tpduCodec->uDataCodec_, tpduCodec->paramCodec_, tpduCodec); 1447 encode->EncodeSubmitTpduType(*encodeBuffer, pSubmit); 1448 pSubmit.vpf = SmsVpf::SMS_VPF_NOT_PRESENT; 1449 encode->EncodeSubmitTpduType(*encodeBuffer, pSubmit); 1450 pSubmit.vpf = SmsVpf::SMS_VPF_ENHANCED; 1451 encode->EncodeSubmitTpduType(*encodeBuffer, pSubmit); 1452 pSubmit.vpf = SmsVpf::SMS_VPF_RELATIVE; 1453 encode->EncodeSubmitTpduType(*encodeBuffer, pSubmit); 1454 pSubmit.vpf = SmsVpf::SMS_VPF_ABSOLUTE; 1455 encode->EncodeSubmitTpduType(*encodeBuffer, pSubmit); 1456 EXPECT_TRUE(ret); 1457} 1458 1459/** 1460 * @tc.number Telephony_SmsMmsGtest_SmsBaseMessage_0001 1461 * @tc.name Test SmsBaseMessage 1462 * @tc.desc Function test 1463 */ 1464HWTEST_F(BranchSmsTest, SmsBaseMessage_0001, Function | MediumTest | Level1) 1465{ 1466 auto smsBaseMessage = std::make_shared<GsmSmsMessage>(); 1467 smsBaseMessage->ConvertMessageClass(SmsMessageClass::SMS_SIM_MESSAGE); 1468 smsBaseMessage->ConvertMessageClass(SmsMessageClass::SMS_INSTANT_MESSAGE); 1469 smsBaseMessage->ConvertMessageClass(SmsMessageClass::SMS_OPTIONAL_MESSAGE); 1470 smsBaseMessage->ConvertMessageClass(SmsMessageClass::SMS_FORWARD_MESSAGE); 1471 smsBaseMessage->ConvertMessageClass(SmsMessageClass::SMS_CLASS_UNKNOWN); 1472 SplitInfo split; 1473 DataCodingScheme codingType = DataCodingScheme::DATA_CODING_7BIT; 1474 smsBaseMessage->ConvertSpiltToUtf8(split, codingType); 1475 split.encodeData.push_back(1); 1476 codingType = DataCodingScheme::DATA_CODING_UCS2; 1477 smsBaseMessage->ConvertSpiltToUtf8(split, codingType); 1478 codingType = DataCodingScheme::DATA_CODING_AUTO; 1479 smsBaseMessage->ConvertSpiltToUtf8(split, codingType); 1480 smsBaseMessage->smsUserData_.headerCnt = 1; 1481 smsBaseMessage->smsUserData_.header[0].udhType = UserDataHeadType::UDH_CONCAT_8BIT; 1482 EXPECT_FALSE(smsBaseMessage->GetConcatMsg() == nullptr); 1483 smsBaseMessage->smsUserData_.header[0].udhType = UserDataHeadType::UDH_CONCAT_16BIT; 1484 EXPECT_FALSE(smsBaseMessage->GetConcatMsg() == nullptr); 1485 smsBaseMessage->smsUserData_.header[0].udhType = UserDataHeadType::UDH_APP_PORT_8BIT; 1486 EXPECT_FALSE(smsBaseMessage->GetPortAddress() == nullptr); 1487 smsBaseMessage->smsUserData_.header[0].udhType = UserDataHeadType::UDH_APP_PORT_16BIT; 1488 EXPECT_FALSE(smsBaseMessage->GetPortAddress() == nullptr); 1489 smsBaseMessage->smsUserData_.header[0].udhType = UserDataHeadType::UDH_SPECIAL_SMS; 1490 EXPECT_FALSE(smsBaseMessage->GetSpecialSmsInd() == nullptr); 1491 smsBaseMessage->smsUserData_.header[0].udhType = UserDataHeadType::UDH_APP_PORT_8BIT; 1492 EXPECT_FALSE(smsBaseMessage->IsWapPushMsg()); 1493 MSG_LANGUAGE_ID_T langId = 1; 1494 codingType = DataCodingScheme::DATA_CODING_7BIT; 1495 EXPECT_GT(smsBaseMessage->GetMaxSegmentSize(codingType, 1, true, langId, 1), 0); 1496 EXPECT_GT(smsBaseMessage->GetSegmentSize(codingType, 1, true, langId), 0); 1497 codingType = DataCodingScheme::DATA_CODING_ASCII7BIT; 1498 EXPECT_GT(smsBaseMessage->GetMaxSegmentSize(codingType, 1, true, langId, 1), 0); 1499 EXPECT_GT(smsBaseMessage->GetSegmentSize(codingType, 1, true, langId), 0); 1500 codingType = DataCodingScheme::DATA_CODING_8BIT; 1501 EXPECT_GT(smsBaseMessage->GetMaxSegmentSize(codingType, 1, true, langId, 1), 0); 1502 EXPECT_GT(smsBaseMessage->GetSegmentSize(codingType, 1, true, langId), 0); 1503 codingType = DataCodingScheme::DATA_CODING_UCS2; 1504 EXPECT_GT(smsBaseMessage->GetMaxSegmentSize(codingType, 1, true, langId, 1), 0); 1505 EXPECT_GT(smsBaseMessage->GetSegmentSize(codingType, 1, true, langId), 0); 1506 std::string message = ""; 1507 LengthInfo lenInfo; 1508 EXPECT_GE(smsBaseMessage->GetSmsSegmentsInfo(message, true, lenInfo), 0); 1509 message = "123"; 1510 EXPECT_EQ(smsBaseMessage->GetSmsSegmentsInfo(message, true, lenInfo), TELEPHONY_ERR_SUCCESS); 1511 EXPECT_EQ(smsBaseMessage->GetSmsSegmentsInfo(message, false, lenInfo), TELEPHONY_ERR_SUCCESS); 1512} 1513 1514/** 1515 * @tc.number Telephony_SmsMmsGtest_SmsBaseMessage_0002 1516 * @tc.name Test SmsBaseMessage 1517 * @tc.desc Function test 1518 */ 1519HWTEST_F(BranchSmsTest, SmsBaseMessage_0002, Function | MediumTest | Level1) 1520{ 1521 auto gsmSmsMessage = std::make_shared<GsmSmsMessage>(); 1522 std::vector<struct SplitInfo> splitResult; 1523 DataCodingScheme codingType = DATA_CODING_AUTO; 1524 std::string text = {0xe4, 0xbd, 0xa0, 0xe4, 0xbd, 0xa0, 0xe4, 0xbd, 0xa0, 0xf0, 0x9f, 0xa5, 0xb3, 0xf0, 0x9f, 0xa5, 1525 0xb3, 0xf0, 0x9f, 0xa5, 0xb3, 0xf0, 0x9f, 0xa5, 0xb3, 0xf0, 0x9f, 0xa5, 0xb3, 0xf0, 0x9f, 0xa5, 0xb3, 1526 0xf0, 0x9f, 0xa5, 0xb3, 0xf0, 0x9f, 0xa5, 0xb3, 0xf0, 0x9f, 0xa5, 0xb3, 0xf0, 0x9f, 0xa5, 0xb3, 1527 0xf0, 0x9f, 0xa5, 0xb3, 0xf0, 0x9f, 0xa5, 0xb3, 0xf0, 0x9f, 0xa5, 0xb3, 0xf0, 0x9f, 0xa5, 0xb3, 1528 0xf0, 0x9f, 0xa5, 0xb3, 0xf0, 0x9f, 0xa5, 0xb3, 0xf0, 0x9f, 0xa5, 0xb3, 0xf0, 0x9f, 0xa5, 0xb3, 1529 0xf0, 0x9f, 0xa5, 0xb3, 0xf0, 0x9f, 0xa5, 0xb3, 0xf0, 0x9f, 0xa5, 0xb3, 0xf0, 0x9f, 0xa5, 0xb3, 1530 0xf0, 0x9f, 0xa5, 0xb3, 0xf0, 0x9f, 0xa5, 0xb3, 0xf0, 0x9f, 0xa5, 0xb3, 0xf0, 0x9f, 0xa5, 0xb3, 1531 0xf0, 0x9f, 0xa5, 0xb3, 0xf0, 0x9f, 0xa5, 0xb3, 0xf0, 0x9f, 0xa5, 0xb3, 0xf0, 0x9f, 0xa5, 0xb3, 1532 0xf0, 0x9f, 0xa5, 0xb3, 0xf0, 0x9f, 0xa5, 0xb3, 0xf0, 0x9f, 0xa5, 0xb3}; 1533 std::string desAddr = ""; 1534 gsmSmsMessage->SplitMessage(splitResult, text, false, codingType, false, desAddr); 1535 std::vector<unsigned char> expect1 = {0x4f, 0x60, 0x4f, 0x60, 0x4f, 0x60, 0xd8, 0x3e, 0xdd, 0x73, 1536 0xd8, 0x3e, 0xdd, 0x73, 0xd8, 0x3e, 0xdd, 0x73, 0xd8, 0x3e, 0xdd, 0x73, 0xd8, 0x3e, 0xdd, 0x73, 0xd8, 0x3e, 1537 0xdd, 0x73, 0xd8, 0x3e, 0xdd, 0x73, 0xd8, 0x3e, 0xdd, 0x73, 0xd8, 0x3e, 0xdd, 0x73, 0xd8, 0x3e, 0xdd, 0x73, 1538 0xd8, 0x3e, 0xdd, 0x73, 0xd8, 0x3e, 0xdd, 0x73, 0xd8, 0x3e, 0xdd, 0x73, 0xd8, 0x3e, 0xdd, 0x73, 1539 0xd8, 0x3e, 0xdd, 0x73, 0xd8, 0x3e, 0xdd, 0x73, 0xd8, 0x3e, 0xdd, 0x73, 0xd8, 0x3e, 0xdd, 0x73, 1540 0xd8, 0x3e, 0xdd, 0x73, 0xd8, 0x3e, 0xdd, 0x73, 0xd8, 0x3e, 0xdd, 0x73, 0xd8, 0x3e, 0xdd, 0x73, 1541 0xd8, 0x3e, 0xdd, 0x73, 0xd8, 0x3e, 0xdd, 0x73, 0xd8, 0x3e, 0xdd, 0x73, 0xd8, 0x3e, 0xdd, 0x73, 1542 0xd8, 0x3e, 0xdd, 0x73, 0xd8, 0x3e, 0xdd, 0x73}; 1543 std::vector<unsigned char> expect2 = {0xd8, 0x3e, 0xdd, 0x73, 0xd8, 0x3e, 0xdd, 0x73, 0xd8, 0x3e, 0xdd, 0x73, 1544 0xd8, 0x3e, 0xdd, 0x73, 0xd8, 0x3e, 0xdd, 0x73}; 1545 EXPECT_FALSE(splitResult[0].encodeData == expect1); 1546 EXPECT_FALSE(splitResult[1].encodeData == expect2); 1547} 1548 1549/** 1550 * @tc.number Telephony_SmsMmsGtest_GsmSmsReceiveHandler_0001 1551 * @tc.name Test GsmSmsReceiveHandler 1552 * @tc.desc Function test 1553 */ 1554HWTEST_F(BranchSmsTest, GsmSmsReceiveHandler_0001, Function | MediumTest | Level1) 1555{ 1556 auto smsReceiveManager = std::make_shared<SmsReceiveManager>(1); 1557 EXPECT_TRUE(smsReceiveManager != nullptr); 1558 smsReceiveManager->Init(); 1559 EXPECT_TRUE(smsReceiveManager->gsmSmsReceiveHandler_ != nullptr); 1560 smsReceiveManager->gsmSmsReceiveHandler_->UnRegisterHandler(); 1561 EXPECT_NE(smsReceiveManager->gsmSmsReceiveHandler_->HandleSmsByType(nullptr), TELEPHONY_ERR_SUCCESS); 1562 EXPECT_EQ(smsReceiveManager->gsmSmsReceiveHandler_->TransformMessageInfo(nullptr), nullptr); 1563} 1564 1565/** 1566 * @tc.number Telephony_SmsMmsGtest_GsmSmsSender_0001 1567 * @tc.name Test GsmSmsSender 1568 * @tc.desc Function test 1569 */ 1570HWTEST_F(BranchSmsTest, GsmSmsSender_0001, Function | MediumTest | Level1) 1571{ 1572 std::function<void(std::shared_ptr<SmsSendIndexer>)> sendRetryFun = nullptr; 1573 auto gsmSmsSender = std::make_shared<GsmSmsSender>(INVALID_SLOTID, sendRetryFun); 1574 uint8_t *data = (uint8_t *)malloc(VALUE_LENGTH * sizeof(uint8_t)); 1575 std::string dataStr = "123"; 1576 gsmSmsSender->CharArrayToString(data, 1, dataStr); 1577 std::shared_ptr<SmsSendIndexer> smsIndexer = nullptr; 1578 const sptr<ISendShortMessageCallback> sendCallback = 1579 iface_cast<ISendShortMessageCallback>(new SendShortMessageCallbackStub()); 1580 const sptr<IDeliveryShortMessageCallback> deliveryCallback = 1581 iface_cast<IDeliveryShortMessageCallback>(new DeliveryShortMessageCallbackStub()); 1582 const std::string desAddr = "qwe"; 1583 const std::string scAddr = "123"; 1584 const std::string text = "123"; 1585 std::shared_ptr<struct EncodeInfo> encodeInfo = nullptr; 1586 gsmSmsSender->SendSmsToRil(smsIndexer); 1587 gsmSmsSender->ResendTextDelivery(smsIndexer); 1588 gsmSmsSender->ResendDataDelivery(smsIndexer); 1589 gsmSmsSender->SetSendIndexerInfo(smsIndexer, encodeInfo, 1); 1590 smsIndexer = std::make_shared<SmsSendIndexer>(desAddr, scAddr, text, sendCallback, deliveryCallback); 1591 gsmSmsSender->ResendTextDelivery(smsIndexer); 1592 gsmSmsSender->voiceServiceState_ = static_cast<int32_t>(RegServiceState::REG_STATE_IN_SERVICE); 1593 gsmSmsSender->imsSmsCfg_ = 0; 1594 gsmSmsSender->SendSmsToRil(smsIndexer); 1595 smsIndexer->psResendCount_ = DIGIT_LEN; 1596 gsmSmsSender->SendSmsToRil(smsIndexer); 1597 AppExecFwk::InnerEvent::Pointer event = AppExecFwk::InnerEvent::Get(0, 1); 1598 gsmSmsSender->StatusReportAnalysis(event); 1599 gsmSmsSender->StatusReportGetImsSms(event); 1600 event = nullptr; 1601 gsmSmsSender->StatusReportSetImsSms(event); 1602 gsmSmsSender->StatusReportAnalysis(event); 1603 gsmSmsSender->StatusReportGetImsSms(event); 1604 gsmSmsSender->isImsGsmHandlerRegistered = true; 1605 gsmSmsSender->RegisterImsHandler(); 1606 gsmSmsSender->SetSendIndexerInfo(smsIndexer, encodeInfo, 1); 1607 GsmSimMessageParam smsData; 1608 smsIndexer->hasMore_ = true; 1609 gsmSmsSender->SendCsSms(smsIndexer, smsData); 1610 smsIndexer->csResendCount_ = 1; 1611 gsmSmsSender->SendCsSms(smsIndexer, smsData); 1612 GsmSmsMessage gsmSmsMessage; 1613 bool isMore = true; 1614 smsIndexer->isConcat_ = true; 1615 EXPECT_FALSE(gsmSmsSender->SetPduInfo(nullptr, gsmSmsMessage, isMore)); 1616 EXPECT_TRUE(gsmSmsSender->SetPduInfo(smsIndexer, gsmSmsMessage, isMore)); 1617 smsIndexer->smsConcat_.totalSeg = VALUE_LENGTH; 1618 EXPECT_TRUE(gsmSmsSender->SetPduInfo(smsIndexer, gsmSmsMessage, isMore)); 1619} 1620 1621/** 1622 * @tc.number Telephony_SmsMmsGtest_SatelliteSmsCallback_0001 1623 * @tc.name Test SatelliteSms Callback 1624 * @tc.desc Function test 1625 */ 1626HWTEST_F(BranchSmsTest, SatelliteSmsCallback_0001, Function | MediumTest | Level1) 1627{ 1628 std::function<void(std::shared_ptr<SmsSendIndexer>)> fun = nullptr; 1629 auto gsmSmsSender = std::make_shared<GsmSmsSender>(INVALID_SLOTID, fun); 1630 SatelliteSmsCallback callback(gsmSmsSender); 1631 MessageParcel data; 1632 MessageParcel reply; 1633 MessageOption option; 1634 data.WriteInterfaceToken(u""); 1635 data.WriteInt32(0); 1636 EXPECT_EQ(callback.OnRemoteRequest(0, data, reply, option), TELEPHONY_ERR_DESCRIPTOR_MISMATCH); 1637} 1638 1639/** 1640 * @tc.number Telephony_SmsMmsGtest_SatelliteSmsCallback_0002 1641 * @tc.name Test SatelliteSms Callback 1642 * @tc.desc Function test 1643 */ 1644HWTEST_F(BranchSmsTest, SatelliteSmsCallback_0002, Function | MediumTest | Level1) 1645{ 1646 std::function<void(std::shared_ptr<SmsSendIndexer>)> fun = nullptr; 1647 auto gsmSmsSender = std::make_shared<GsmSmsSender>(INVALID_SLOTID, fun); 1648 SatelliteSmsCallback callback(gsmSmsSender); 1649 MessageParcel reply; 1650 MessageOption option; 1651 1652 MessageParcel hrilData; 1653 hrilData.WriteInterfaceToken(INTERFACE_TOKEN); 1654 hrilData.WriteInt32(0); 1655 hrilData.WriteInt32(static_cast<int32_t>(SatelliteSmsResultType::HRIL_RADIO_RESPONSE)); 1656 hrilData.WriteInt32(0); 1657 hrilData.WriteInt32(0); 1658 hrilData.WriteInt32(0); 1659 hrilData.WriteInt32(0); 1660 EXPECT_EQ(callback.OnRemoteRequest(0, hrilData, reply, option), TELEPHONY_SUCCESS); 1661 1662 MessageParcel data; 1663 data.WriteInterfaceToken(INTERFACE_TOKEN); 1664 data.WriteInt32(0); 1665 data.WriteInt32(static_cast<int32_t>(SatelliteSmsResultType::SEND_SMS_RESULT)); 1666 data.WriteInt32(0); 1667 data.WriteString(""); 1668 data.WriteInt32(0); 1669 data.WriteInt64(0); 1670 EXPECT_EQ(callback.OnRemoteRequest(0, data, reply, option), TELEPHONY_SUCCESS); 1671} 1672 1673/** 1674 * @tc.number Telephony_SmsMmsGtest_SatelliteSmsCallback_0003 1675 * @tc.name Test SatelliteSms Callback 1676 * @tc.desc Function test 1677 */ 1678HWTEST_F(BranchSmsTest, SatelliteSmsCallback_0003, Function | MediumTest | Level1) 1679{ 1680 std::function<void(std::shared_ptr<SmsSendIndexer>)> fun = nullptr; 1681 auto gsmSmsSender = std::make_shared<GsmSmsSender>(INVALID_SLOTID, fun); 1682 SatelliteSmsCallback callback(gsmSmsSender); 1683 MessageParcel reply; 1684 MessageOption option; 1685 1686 MessageParcel errData; 1687 errData.WriteInterfaceToken(INTERFACE_TOKEN); 1688 errData.WriteInt32(0); 1689 EXPECT_EQ(callback.OnRemoteRequest(1, errData, reply, option), TELEPHONY_ERR_READ_DATA_FAIL); 1690 1691 MessageParcel data; 1692 data.WriteInterfaceToken(INTERFACE_TOKEN); 1693 data.WriteInt32(0); 1694 data.WriteInt32(0); 1695 data.WriteInt32(0); 1696 std::vector<uint8_t> pdu {}; 1697 data.WriteUInt8Vector(pdu); 1698 EXPECT_NE(callback.OnRemoteRequest(1, data, reply, option), TELEPHONY_SUCCESS); 1699} 1700 1701/** 1702 * @tc.number Telephony_SmsMmsGtest_SatelliteSmsCallback_0004 1703 * @tc.name Test SatelliteSms Callback 1704 * @tc.desc Function test 1705 */ 1706HWTEST_F(BranchSmsTest, SatelliteSmsCallback_0004, Function | MediumTest | Level1) 1707{ 1708 std::function<void(std::shared_ptr<SmsSendIndexer>)> fun = nullptr; 1709 auto gsmSmsSender = std::make_shared<GsmSmsSender>(INVALID_SLOTID, fun); 1710 SatelliteSmsCallback callback(gsmSmsSender); 1711 MessageParcel reply; 1712 MessageOption option; 1713 1714 MessageParcel errData; 1715 errData.WriteInterfaceToken(INTERFACE_TOKEN); 1716 errData.WriteInt32(0); 1717 EXPECT_EQ(callback.OnRemoteRequest(2, errData, reply, option), TELEPHONY_ERR_READ_DATA_FAIL); 1718 1719 MessageParcel data; 1720 data.WriteInterfaceToken(INTERFACE_TOKEN); 1721 data.WriteInt32(0); 1722 data.WriteInt32(0); 1723 data.WriteInt32(0); 1724 std::vector<uint8_t> pdu {}; 1725 data.WriteUInt8Vector(pdu); 1726 EXPECT_EQ(callback.OnRemoteRequest(2, data, reply, option), TELEPHONY_SUCCESS); 1727} 1728 1729/** 1730 * @tc.number Telephony_SmsMmsGtest_SatelliteSmsClient_0001 1731 * @tc.name Test Satellite Service Client 1732 * @tc.desc Function test 1733 */ 1734HWTEST_F(BranchSmsTest, SatelliteSmsClient_0001, Function | MediumTest | Level1) 1735{ 1736 TELEPHONY_LOGI("SatelliteSmsClient_0001=========="); 1737 std::function<void(std::shared_ptr<SmsSendIndexer>)> fun = nullptr; 1738 auto gsmSmsSender = std::make_shared<GsmSmsSender>(INVALID_SLOTID, fun); 1739 auto smsReceiveManager = std::make_shared<SmsReceiveManager>(INVALID_SLOTID); 1740 EXPECT_TRUE(smsReceiveManager != nullptr); 1741 smsReceiveManager->Init(); 1742 EXPECT_TRUE(smsReceiveManager->gsmSmsReceiveHandler_ != nullptr); 1743 auto &satelliteSmsClient = SatelliteSmsClient::GetInstance(); 1744 satelliteSmsClient.AddSendHandler(INVALID_SLOTID, std::static_pointer_cast<TelEventHandler>(gsmSmsSender)); 1745 satelliteSmsClient.AddReceiveHandler(INVALID_SLOTID, std::static_pointer_cast<TelEventHandler> 1746 (smsReceiveManager->gsmSmsReceiveHandler_)); 1747 satelliteSmsClient.statusChangeListener_->OnAddSystemAbility(INVALID_SLOTID, ""); 1748 satelliteSmsClient.statusChangeListener_->OnRemoveSystemAbility(INVALID_SLOTID, ""); 1749 EXPECT_GE(satelliteSmsClient.GetSatelliteSupported(), 0); 1750 EXPECT_GE(satelliteSmsClient.IsSatelliteEnabled(), 0); 1751 EXPECT_GE(satelliteSmsClient.GetSatelliteCapability(), 0); 1752 SatelliteMessage message; 1753 EXPECT_EQ(satelliteSmsClient.SendSms(INVALID_SLOTID, RadioEvent::RADIO_SEND_SMS, message), 1754 TELEPHONY_ERR_IPC_CONNECT_STUB_FAIL); 1755 EXPECT_EQ(satelliteSmsClient.SendSmsMoreMode(INVALID_SLOTID, RadioEvent::RADIO_SEND_SMS_EXPECT_MORE, message), 1756 TELEPHONY_ERR_IPC_CONNECT_STUB_FAIL); 1757 EXPECT_EQ( 1758 satelliteSmsClient.SendSmsAck(INVALID_SLOTID, SMS_EVENT_NEW_SMS_REPLY, true, AckIncomeCause::SMS_ACK_RESULT_OK), 1759 TELEPHONY_ERR_IPC_CONNECT_STUB_FAIL); 1760} 1761 1762/** 1763 * @tc.number Telephony_SmsMmsGtest_SmsMiscManager_0001 1764 * @tc.name Test SmsMiscManager 1765 * @tc.desc Function test 1766 */ 1767HWTEST_F(BranchSmsTest, SmsMiscManager_0001, Function | MediumTest | Level1) 1768{ 1769 auto smsMiscManager = std::make_shared<SmsMiscManager>(INVALID_SLOTID); 1770 AppExecFwk::InnerEvent::Pointer event = AppExecFwk::InnerEvent::Get(SmsMiscManager::SET_CB_CONFIG_FINISH, 1); 1771 smsMiscManager->ProcessEvent(event); 1772 event = AppExecFwk::InnerEvent::Get(SmsMiscManager::SET_SMSC_ADDR_FINISH, 1); 1773 smsMiscManager->ProcessEvent(event); 1774 event = AppExecFwk::InnerEvent::Get(TELEPHONY_ERR_STRCPY_FAIL, 1); 1775 smsMiscManager->ProcessEvent(event); 1776 event = nullptr; 1777 smsMiscManager->ProcessEvent(event); 1778 smsMiscManager->NotifyHasResponse(); 1779 smsMiscManager->fairList_.push_back(1); 1780 smsMiscManager->NotifyHasResponse(); 1781 EXPECT_EQ(smsMiscManager->SetCBConfig(true, CODE_BUFFER_MAX_SIZE, 1, 1), TELEPHONY_ERR_ARGUMENT_INVALID); 1782 EXPECT_EQ(smsMiscManager->SetCBConfig(true, 1, 0, 1), TELEPHONY_ERR_ARGUMENT_INVALID); 1783 EXPECT_EQ(smsMiscManager->SetCBConfig(true, 1, 1, 0), TELEPHONY_ERR_ARGUMENT_INVALID); 1784 EXPECT_EQ(smsMiscManager->SetCBConfig(true, 1, 0, 0), TELEPHONY_ERR_ARGUMENT_INVALID); 1785 EXPECT_EQ(smsMiscManager->SetCBConfig(false, 1, 1, 1), TELEPHONY_ERR_SUCCESS); 1786 EXPECT_GE(smsMiscManager->SetCBConfig(true, 1, 1, 1), TELEPHONY_ERR_SUCCESS); 1787 EXPECT_TRUE(smsMiscManager->OpenCBRange(1, 1)); 1788 smsMiscManager->rangeList_.clear(); 1789 smsMiscManager->rangeList_.emplace_back(VALUE_LENGTH, 1); 1790 EXPECT_EQ(smsMiscManager->SetCBConfig(true, 1, 1, 1), TELEPHONY_ERR_RIL_CMD_FAIL); 1791 SmsMiscManager::infoData data(1, 1); 1792 std::string smsc = ""; 1793 std::string pdu = ""; 1794 std::vector<ShortMessage> message; 1795 EXPECT_GE( 1796 smsMiscManager->AddSimMessage(smsc, pdu, ISmsServiceInterface::SimMessageStatus::SIM_MESSAGE_STATUS_UNREAD), 0); 1797 EXPECT_GE(smsMiscManager->UpdateSimMessage( 1798 1, ISmsServiceInterface::SimMessageStatus::SIM_MESSAGE_STATUS_UNREAD, pdu, smsc), 1799 0); 1800 EXPECT_GT(smsMiscManager->GetAllSimMessages(message), TELEPHONY_ERR_SUCCESS); 1801 std::list<SmsMiscManager::gsmCBRangeInfo> rangeList; 1802 EXPECT_TRUE(smsMiscManager->SendDataToRil(true, rangeList)); 1803 SmsMiscManager::gsmCBRangeInfo rangeInfo(1, 1); 1804 SmsMiscManager::gsmCBRangeInfo rangeInfoTwo(1, 0); 1805 rangeList.push_back(rangeInfo); 1806 rangeList.push_back(rangeInfoTwo); 1807 EXPECT_NE(smsMiscManager->RangeListToString(rangeList), ""); 1808 EXPECT_FALSE(smsMiscManager->SendDataToRil(true, rangeList)); 1809 EXPECT_FALSE(smsMiscManager->CloseCBRange(0, 0)); 1810} 1811 1812/** 1813 * @tc.number Telephony_SmsMmsGtest_SmsMiscManager_0003 1814 * @tc.name Test SmsMiscManager 1815 * @tc.desc Function test 1816 */ 1817HWTEST_F(BranchSmsTest, SmsMiscManager_0003, Function | MediumTest | Level1) 1818{ 1819 auto smsMiscManager = std::make_shared<SmsMiscManager>(0); 1820 AppExecFwk::InnerEvent::Pointer event = AppExecFwk::InnerEvent::Get(SmsMiscManager::GET_CB_CONFIG_FINISH, 1); 1821 smsMiscManager->ProcessEvent(event); 1822 std::shared_ptr<CBConfigInfo> res = std::make_shared<CBConfigInfo>(); 1823 res->mids = CB_RANGE_MIDS; 1824 res->dcss = CB_RANGE_DCSS; 1825 smsMiscManager->UpdateCbRangList(res); 1826 smsMiscManager->rangeList_.emplace_back(1, 1); 1827 smsMiscManager->rangeList_.emplace_back(0, 1); 1828 smsMiscManager->rangeList_.emplace_back(0, 0); 1829 smsMiscManager->CombineCBRange(); 1830 EXPECT_FALSE(smsMiscManager->SendDataToRil(true, smsMiscManager->rangeList_)); 1831 std::string src = CB_RANGE_MIDS; 1832 std::vector<std::string> dest; 1833 std::string delimiter = CB_RANGE_DELI; 1834 smsMiscManager->SplitMids(src, dest, delimiter); 1835 std::string value = CB_RANGE_MID; 1836 std::string start; 1837 std::string end; 1838 std::string dlm = CB_RANGE_DELIM; 1839 smsMiscManager->SplitMidValue(value, start, end, dlm); 1840 smsMiscManager->hasGotCbRange_ = true; 1841 smsMiscManager->GetModemCBRange(); 1842 smsMiscManager->hasGotCbRange_ = false; 1843 smsMiscManager->GetModemCBRange(); 1844 EXPECT_FALSE(smsMiscManager->SendDataToRil(true, smsMiscManager->rangeList_)); 1845} 1846 1847/** 1848 * @tc.number Telephony_SmsMmsGtest_SmsService_0001 1849 * @tc.name Test SmsService 1850 * @tc.desc Function test 1851 */ 1852HWTEST_F(BranchSmsTest, SmsService_0001, Function | MediumTest | Level1) 1853{ 1854 auto smsService = DelayedSingleton<SmsService>::GetInstance(); 1855 smsService->state_ = ServiceRunningState::STATE_RUNNING; 1856 smsService->OnStart(); 1857 std::u16string desAddr = u""; 1858 uint8_t *data = nullptr; 1859 sptr<ISendShortMessageCallback> sendCallback = nullptr; 1860 sptr<IDeliveryShortMessageCallback> deliveryCallback = nullptr; 1861 EXPECT_GT(smsService->SendMessage(0, desAddr, desAddr, desAddr, sendCallback, 1862 deliveryCallback, true), TELEPHONY_ERR_SUCCESS); 1863 EXPECT_GT(smsService->SendMessage(0, desAddr, desAddr, desAddr, sendCallback, 1864 deliveryCallback, false), TELEPHONY_ERR_SUCCESS); 1865 EXPECT_GT(smsService->SendMessage(0, desAddr, desAddr, 1, data, 1, sendCallback, deliveryCallback), 1866 TELEPHONY_ERR_SUCCESS); 1867 bool isSupported = true; 1868 std::string sca = ""; 1869 smsService->TrimSmscAddr(sca); 1870 sca = " 123"; 1871 smsService->TrimSmscAddr(sca); 1872 EXPECT_GT(smsService->IsImsSmsSupported(INVALID_SLOTID, isSupported), TELEPHONY_ERR_SUCCESS); 1873 EXPECT_GT(smsService->GetImsShortMessageFormat(desAddr), TELEPHONY_ERR_SUCCESS); 1874 EXPECT_GT(smsService->SetSmscAddr(INVALID_SLOTID, desAddr), TELEPHONY_ERR_SUCCESS); 1875 EXPECT_GT(smsService->GetSmscAddr(INVALID_SLOTID, desAddr), TELEPHONY_ERR_SUCCESS); 1876 EXPECT_GT(smsService->AddSimMessage( 1877 INVALID_SLOTID, desAddr, desAddr, ISmsServiceInterface::SimMessageStatus::SIM_MESSAGE_STATUS_UNREAD), 1878 TELEPHONY_ERR_SUCCESS); 1879 EXPECT_GT(smsService->DelSimMessage(INVALID_SLOTID, 1), TELEPHONY_ERR_SUCCESS); 1880 EXPECT_GT(smsService->UpdateSimMessage(INVALID_SLOTID, 1, 1881 ISmsServiceInterface::SimMessageStatus::SIM_MESSAGE_STATUS_UNREAD, desAddr, desAddr), 1882 TELEPHONY_ERR_SUCCESS); 1883 std::vector<ShortMessage> message; 1884 EXPECT_GT(smsService->SetCBConfig(INVALID_SLOTID, true, 1, 1, 1), TELEPHONY_ERR_SUCCESS); 1885 EXPECT_GE(smsService->SetImsSmsConfig(INVALID_SLOTID, 1), TELEPHONY_ERR_SUCCESS); 1886 EXPECT_GT(smsService->SetDefaultSmsSlotId(INVALID_SLOTID), TELEPHONY_ERR_SUCCESS); 1887 std::vector<std::u16string> splitMessage; 1888 EXPECT_GT(smsService->SplitMessage(desAddr, splitMessage), TELEPHONY_ERR_SUCCESS); 1889} 1890 1891/** 1892 * @tc.number Telephony_SmsMmsGtest_SmsService_0002 1893 * @tc.name Test SmsService 1894 * @tc.desc Function test 1895 */ 1896HWTEST_F(BranchSmsTest, SmsService_0002, Function | MediumTest | Level1) 1897{ 1898 auto smsService = DelayedSingleton<SmsService>::GetInstance(); 1899 std::u16string message = u""; 1900 ISmsServiceInterface::SmsSegmentsInfo info; 1901 EXPECT_GT(smsService->GetSmsSegmentsInfo(INVALID_SLOTID, message, true, info), TELEPHONY_ERR_SUCCESS); 1902 message = u"123"; 1903 EXPECT_GT(smsService->GetSmsSegmentsInfo(INVALID_SLOTID, message, true, info), TELEPHONY_ERR_SUCCESS); 1904 std::string scAddr = ""; 1905 std::string specification = ""; 1906 ShortMessage messages; 1907 EXPECT_GT(smsService->CreateMessage(scAddr, specification, messages), TELEPHONY_ERR_SUCCESS); 1908 specification = "3gpp"; 1909 EXPECT_GE(smsService->CreateMessage(scAddr, specification, messages), TELEPHONY_ERR_SUCCESS); 1910 specification = "3gpp2"; 1911 EXPECT_GE(smsService->CreateMessage(scAddr, specification, messages), TELEPHONY_ERR_SUCCESS); 1912} 1913 1914/** 1915 * @tc.number Telephony_SmsMmsGtest_SmsService_0003 1916 * @tc.name Test SmsService 1917 * @tc.desc Function test 1918 */ 1919HWTEST_F(BranchSmsTest, SmsService_0003, Function | MediumTest | Level1) 1920{ 1921 auto smsNwPolicyManager = std::make_shared<SmsNetworkPolicyManager>(INVALID_SLOTID); 1922 AppExecFwk::InnerEvent::Pointer event = AppExecFwk::InnerEvent::Get(RadioEvent::RADIO_ON); 1923 smsNwPolicyManager->ProcessEvent(event); 1924 event = AppExecFwk::InnerEvent::Get(RadioEvent::RADIO_RIL_ADAPTER_HOST_DIED); 1925 smsNwPolicyManager->ProcessEvent(event); 1926 smsNwPolicyManager->HandleFactoryReset(); 1927 1928 auto smsService = DelayedSingleton<SmsService>::GetInstance(); 1929 EXPECT_EQ(smsService->OnRilAdapterHostDied(INVALID_SLOTID), TELEPHONY_ERR_LOCAL_PTR_NULL); 1930 smsService->slotSmsInterfaceManagerMap_[INVALID_SLOTID] = std::make_shared<SmsInterfaceManager>(INVALID_SLOTID); 1931 EXPECT_EQ(smsService->OnRilAdapterHostDied(INVALID_SLOTID), TELEPHONY_ERR_SUCCESS); 1932} 1933 1934/** 1935 * @tc.number Telephony_SmsMmsGtest_SmsPersistHelper_0001 1936 * @tc.name Test SmsService 1937 * @tc.desc Function test 1938 */ 1939HWTEST_F(BranchSmsTest, SmsPersistHelper_0001, Function | MediumTest | Level1) 1940{ 1941 AccessMmsToken token; 1942 auto smsPersistHelper = DelayedSingleton<SmsPersistHelper>::GetInstance(); 1943 DataShare::DataSharePredicates predicates; 1944 uint16_t maxGroupId = 0; 1945 smsPersistHelper->QueryMaxGroupId(predicates, maxGroupId); 1946 EXPECT_GE(maxGroupId, 0); 1947 1948 std::string num = ""; 1949 std::string countryCode = "123"; 1950 i18n::phonenumbers::PhoneNumberUtil::PhoneNumberFormat formatInfo = 1951 i18n::phonenumbers::PhoneNumberUtil::PhoneNumberFormat::NATIONAL; 1952 std::string formatNum = ""; 1953 smsPersistHelper->FormatSmsNumber(num, countryCode, formatInfo, formatNum); 1954 num = "123"; 1955 smsPersistHelper->FormatSmsNumber(num, countryCode, formatInfo, formatNum); 1956 formatNum = "123"; 1957 int32_t value = smsPersistHelper->FormatSmsNumber(num, countryCode, formatInfo, formatNum); 1958 EXPECT_GE(value, 0); 1959 1960 DataShare::DataShareValuesBucket bucket; 1961 std::string id = "1"; 1962 bucket.Put(SLOT_ID, id); 1963 uint16_t dataBaseId = 0; 1964 smsPersistHelper->QuerySmsMmsForId(predicates, dataBaseId); 1965 EXPECT_GE(dataBaseId, 0); 1966 smsPersistHelper->Insert(bucket, dataBaseId); 1967 smsPersistHelper->Insert(TABLE_URL, bucket); 1968 uint16_t sessionId = 0; 1969 uint16_t messageCount = 0; 1970 smsPersistHelper->QuerySession(predicates, sessionId, messageCount); 1971 EXPECT_GE(sessionId, 0); 1972 smsPersistHelper->QuerySmsMmsForId(predicates, dataBaseId); 1973 EXPECT_GE(dataBaseId, 0); 1974 1975 smsPersistHelper->Update(predicates, bucket); 1976 std::vector<SmsReceiveIndexer> indexers; 1977 smsPersistHelper->Query(predicates, indexers); 1978 smsPersistHelper->Delete(predicates); 1979 std::string phoneNum = ""; 1980 smsPersistHelper->QueryBlockPhoneNumber(phoneNum); 1981 smsPersistHelper->UpdateContact(phoneNum); 1982 EXPECT_GE(phoneNum.size(), 0); 1983 1984 phoneNum = "13866666666"; 1985 smsPersistHelper->QueryBlockPhoneNumber(phoneNum); 1986 smsPersistHelper->UpdateContact(phoneNum); 1987 int32_t rawCountId = 1; 1988 int32_t contactedCount = 1; 1989 smsPersistHelper->QueryContactedCount(phoneNum, rawCountId, contactedCount); 1990 EXPECT_TRUE(smsPersistHelper != nullptr); 1991} 1992 1993/** 1994 * @tc.number Telephony_SmsMmsGtest_SmsServiceManagerClient_0001 1995 * @tc.name Test SmsServiceManagerClient 1996 * @tc.desc Function test 1997 */ 1998HWTEST_F(BranchSmsTest, SmsServiceManagerClient_0001, Function | MediumTest | Level1) 1999{ 2000 int32_t slotId = 0; 2001 std::u16string desAddr = u""; 2002 sptr<ISendShortMessageCallback> sendCallback; 2003 sptr<IDeliveryShortMessageCallback> deliveryCallback; 2004 int32_t ret = 0; 2005 ret = Singleton<SmsServiceManagerClient>::GetInstance().SetDefaultSmsSlotId(slotId); 2006 EXPECT_GE(ret, 0); 2007 Singleton<SmsServiceManagerClient>::GetInstance().GetDefaultSmsSlotId(); 2008 Singleton<SmsServiceManagerClient>::GetInstance().GetDefaultSmsSimId(slotId); 2009 Singleton<SmsServiceManagerClient>::GetInstance().SendMessage 2010 (slotId, desAddr, desAddr, desAddr, sendCallback, deliveryCallback); 2011 uint16_t port = 1; 2012 uint8_t *data = nullptr; 2013 Singleton<SmsServiceManagerClient>::GetInstance().SendMessage 2014 (slotId, desAddr, desAddr, port, data, port, sendCallback, deliveryCallback); 2015 std::u16string scAddr = u"1234"; 2016 Singleton<SmsServiceManagerClient>::GetInstance().SetScAddress(slotId, scAddr); 2017 Singleton<SmsServiceManagerClient>::GetInstance().GetScAddress(slotId, scAddr); 2018 std::u16string smsc = u"test"; 2019 Singleton<SmsServiceManagerClient>::GetInstance().AddSimMessage( 2020 slotId, smsc, smsc, ISmsServiceInterface::SimMessageStatus::SIM_MESSAGE_STATUS_UNREAD); 2021 uint32_t msgIndex = 1; 2022 Singleton<SmsServiceManagerClient>::GetInstance().DelSimMessage(slotId, msgIndex); 2023 Singleton<SmsServiceManagerClient>::GetInstance().UpdateSimMessage( 2024 slotId, msgIndex, ISmsServiceInterface::SimMessageStatus::SIM_MESSAGE_STATUS_UNREAD, smsc, smsc); 2025 std::vector<ShortMessage> messages; 2026 Singleton<SmsServiceManagerClient>::GetInstance().GetAllSimMessages(slotId, messages); 2027 bool enable = true; 2028 uint8_t ranType = 1; 2029 Singleton<SmsServiceManagerClient>::GetInstance().SetCBConfig(slotId, enable, msgIndex, msgIndex, ranType); 2030 Singleton<SmsServiceManagerClient>::GetInstance().SetImsSmsConfig(slotId, enable); 2031 std::vector<std::u16string> splitMessage; 2032 Singleton<SmsServiceManagerClient>::GetInstance().SplitMessage(desAddr, splitMessage); 2033 ISmsServiceInterface::SmsSegmentsInfo segInfo; 2034 Singleton<SmsServiceManagerClient>::GetInstance().GetSmsSegmentsInfo(slotId, desAddr, enable, segInfo); 2035 Singleton<SmsServiceManagerClient>::GetInstance().IsImsSmsSupported(slotId, enable); 2036 Singleton<SmsServiceManagerClient>::GetInstance().GetImsShortMessageFormat(desAddr); 2037 Singleton<SmsServiceManagerClient>::GetInstance().HasSmsCapability(); 2038 std::string pdu = ""; 2039 ShortMessage message; 2040 Singleton<SmsServiceManagerClient>::GetInstance().CreateMessage(pdu, pdu, message); 2041 Singleton<SmsServiceManagerClient>::GetInstance().GetBase64Encode(pdu, pdu); 2042 Singleton<SmsServiceManagerClient>::GetInstance().GetBase64Decode(pdu, pdu); 2043 uint32_t charset = 1; 2044 Singleton<SmsServiceManagerClient>::GetInstance().GetEncodeStringFunc(pdu, charset, charset, pdu); 2045} 2046 2047/** 2048 * @tc.number Telephony_SmsMmsGtest_GsmUserDataPdu_0001 2049 * @tc.name Test GsmUserDataPdu 2050 * @tc.desc Function test 2051 */ 2052HWTEST_F(BranchSmsTest, GsmUserDataPdu_0001, Function | MediumTest | Level1) 2053{ 2054 const struct SmsUDPackage *userData = nullptr; 2055 struct SmsUDPackage *pUserData = nullptr; 2056 auto encodeBuffer = std::make_shared<SmsWriteBuffer>(); 2057 auto gsmUserDataPdu = DelayedSingleton<GsmUserDataPdu>::GetInstance(); 2058 std::string str; 2059 gsmUserDataPdu->EncodeUserDataPdu(*encodeBuffer, userData, DataCodingScheme::DATA_CODING_7BIT, str); 2060 auto deBuffer = std::make_shared<SmsReadBuffer>(SMS_READ_PDU); 2061 gsmUserDataPdu->DecodeUserDataPdu(*deBuffer, true, DataCodingScheme::DATA_CODING_7BIT, pUserData); 2062 SmsTpud *pTPUD = new SmsTpud(); 2063 gsmUserDataPdu->DecodeUserDataPdu(*deBuffer, true, DataCodingScheme::DATA_CODING_7BIT, pUserData, pTPUD); 2064 delete pTPUD; 2065 pTPUD = nullptr; 2066 pUserData = new SmsUDPackage(); 2067 gsmUserDataPdu->ResetUserData(*pUserData); 2068 auto smsReadBuffer = std::make_shared<SmsReadBuffer>(SMS_READ_PDU); 2069 uint8_t udhl = 0; 2070 uint16_t i = 0; 2071 gsmUserDataPdu->GetHeaderCnt(*smsReadBuffer, pUserData, udhl, i); 2072 delete pUserData; 2073 pUserData = nullptr; 2074 SmsWriteBuffer buffer; 2075 uint8_t v = 1; 2076 buffer.WriteByte(v); 2077 SmsUDH header; 2078 header.udhType = UDH_CONCAT_16BIT; 2079 SmsUDH *pHeader = new SmsUDH(); 2080 uint16_t headerLen = 0; 2081 auto decodeBuffer = std::make_shared<SmsReadBuffer>(SMS_READ_PDU); 2082 decodeBuffer->data_.reset(new uint8_t[DECODE_SIZE]()); 2083 decodeBuffer->data_[0] = 0; 2084 decodeBuffer->data_[1] = EIGHT_BIT; 2085 decodeBuffer->data_[TWO_BIT] = FOUR_BIT; 2086 decodeBuffer->data_[DIGIT_LEN] = FIVE_BIT; 2087 decodeBuffer->data_[FOUR_BIT] = SIX_BIT; 2088 decodeBuffer->index_ = 0; 2089 gsmUserDataPdu->DecodeHeader(*decodeBuffer, *pHeader, headerLen); 2090 decodeBuffer->index_ = 1; 2091 gsmUserDataPdu->DecodeHeader(*decodeBuffer, *pHeader, headerLen); 2092 decodeBuffer->index_ = TWO_BIT; 2093 gsmUserDataPdu->DecodeHeader(*decodeBuffer, *pHeader, headerLen); 2094 decodeBuffer->index_ = DIGIT_LEN; 2095 gsmUserDataPdu->DecodeHeader(*decodeBuffer, *pHeader, headerLen); 2096 decodeBuffer->index_ = FOUR_BIT; 2097 gsmUserDataPdu->DecodeHeader(*decodeBuffer, *pHeader, headerLen); 2098 delete pHeader; 2099 pHeader = nullptr; 2100 EXPECT_TRUE(decodeBuffer != nullptr); 2101 EXPECT_TRUE(gsmUserDataPdu != nullptr); 2102} 2103 2104/** 2105 * @tc.number Telephony_SmsMmsGtest_GsmUserDataPdu_0002 2106 * @tc.name Test GsmUserDataPdu 2107 * @tc.desc Function test 2108 */ 2109HWTEST_F(BranchSmsTest, GsmUserDataPdu_0002, Function | MediumTest | Level1) 2110{ 2111 SmsUDH *pHeader = new SmsUDH(); 2112 auto decodeBuffer = std::make_shared<SmsReadBuffer>(SMS_READ_PDU); 2113 auto gsmUserDataPdu = DelayedSingleton<GsmUserDataPdu>::GetInstance(); 2114 uint8_t oneByte = UDH_ALTERNATE_REPLY_ADDRESS; 2115 gsmUserDataPdu->DecodeHeaderPartData(*decodeBuffer, *pHeader, oneByte); 2116 oneByte = UDH_SINGLE_SHIFT; 2117 gsmUserDataPdu->DecodeHeaderPartData(*decodeBuffer, *pHeader, oneByte); 2118 oneByte = UDH_LOCKING_SHIFT; 2119 gsmUserDataPdu->DecodeHeaderPartData(*decodeBuffer, *pHeader, oneByte); 2120 gsmUserDataPdu->DecodeHeaderConcat8Bit(*decodeBuffer, *pHeader); 2121 decodeBuffer->data_[0] = 0; 2122 gsmUserDataPdu->DecodeHeaderConcat8Bit(*decodeBuffer, *pHeader); 2123 decodeBuffer->index_ = 0; 2124 gsmUserDataPdu->DecodeHeaderConcat8Bit(*decodeBuffer, *pHeader); 2125 decodeBuffer->data_[1] = 1; 2126 decodeBuffer->index_ = 1; 2127 gsmUserDataPdu->DecodeHeaderConcat8Bit(*decodeBuffer, *pHeader); 2128 auto sixteenDecodeBuffer = std::make_shared<SmsReadBuffer>(SMS_READ_PDU); 2129 gsmUserDataPdu->DecodeHeaderConcat16Bit(*sixteenDecodeBuffer, *pHeader); 2130 gsmUserDataPdu->DecodeHeaderAppPort8Bit(*sixteenDecodeBuffer, *pHeader); 2131 sixteenDecodeBuffer->data_[0] = 0; 2132 gsmUserDataPdu->DecodeHeaderAppPort8Bit(*sixteenDecodeBuffer, *pHeader); 2133 sixteenDecodeBuffer->index_ = 0; 2134 gsmUserDataPdu->DecodeHeaderAppPort8Bit(*sixteenDecodeBuffer, *pHeader); 2135 decodeBuffer->data_[1] = 1; 2136 decodeBuffer->index_ = 1; 2137 EXPECT_TRUE(decodeBuffer != nullptr); 2138 gsmUserDataPdu->DecodeHeaderAppPort8Bit(*sixteenDecodeBuffer, *pHeader); 2139 auto appPortDecodeBuffer = std::make_shared<SmsReadBuffer>(SMS_READ_PDU); 2140 gsmUserDataPdu->DecodeHeaderAppPort16Bit(*appPortDecodeBuffer, *pHeader); 2141 gsmUserDataPdu->DecodeHeaderReplyAddress(*appPortDecodeBuffer, *pHeader); 2142 appPortDecodeBuffer->data_[0] = 0; 2143 gsmUserDataPdu->DecodeHeaderReplyAddress(*appPortDecodeBuffer, *pHeader); 2144 appPortDecodeBuffer->index_ = 0; 2145 gsmUserDataPdu->DecodeHeaderReplyAddress(*appPortDecodeBuffer, *pHeader); 2146 appPortDecodeBuffer->data_[1] = 1; 2147 appPortDecodeBuffer->index_ = 1; 2148 EXPECT_TRUE(appPortDecodeBuffer != nullptr); 2149 gsmUserDataPdu->DecodeHeaderReplyAddress(*appPortDecodeBuffer, *pHeader); 2150 auto singleShiftDecodeBuffer = std::make_shared<SmsReadBuffer>(SMS_READ_PDU); 2151 gsmUserDataPdu->DecodeHeaderSingleShift(*singleShiftDecodeBuffer, *pHeader); 2152 gsmUserDataPdu->DecodeHeaderLockingShift(*singleShiftDecodeBuffer, *pHeader); 2153 gsmUserDataPdu->DecodeHeaderDefaultCase(*singleShiftDecodeBuffer, *pHeader); 2154 delete pHeader; 2155 pHeader = nullptr; 2156 EXPECT_TRUE(gsmUserDataPdu != nullptr); 2157} 2158 2159/** 2160 * @tc.number Telephony_SmsMmsGtest_GsmSmsSender_0002 2161 * @tc.name Test GsmSmsSender 2162 * @tc.desc Function test 2163 */ 2164HWTEST_F(BranchSmsTest, GsmSmsSender_0002, Function | MediumTest | Level1) 2165{ 2166 std::function<void(std::shared_ptr<SmsSendIndexer>)> sendRetryFun = nullptr; 2167 auto gsmSmsSender = std::make_shared<GsmSmsSender>(INVALID_SLOTID, sendRetryFun); 2168 GsmSimMessageParam smsData; 2169 smsData.refId = 1; 2170 smsData.smscPdu = SMS_READ_PDU; 2171 smsData.pdu = SMS_READ_PDU; 2172 const std::shared_ptr<SmsSendIndexer> indexer = nullptr; 2173 gsmSmsSender->SendImsSms(indexer, smsData); 2174 EXPECT_TRUE(gsmSmsSender != nullptr); 2175} 2176 2177/** 2178 * @tc.number Telephony_SmsMmsGtest_GsmSmsMessage_0003 2179 * @tc.name Test GsmSmsMessage 2180 * @tc.desc Function test 2181 */ 2182HWTEST_F(BranchSmsTest, GsmSmsMessage_0003, Function | MediumTest | Level1) 2183{ 2184 auto gsmSmsMessage = std::make_shared<GsmSmsMessage>(); 2185 const std::string replyAddress = ""; 2186 gsmSmsMessage->CalcReplyEncodeAddress(replyAddress); 2187 gsmSmsMessage->CalcReplyEncodeAddress(SMS_READ_PDU); 2188 gsmSmsMessage->CreateStatusReportSmsTpdu(); 2189 gsmSmsMessage->IsSpecialMessage(); 2190 gsmSmsMessage->GetIsSIMDataTypeDownload(); 2191 gsmSmsMessage->GetIsTypeZeroInd(); 2192 EXPECT_TRUE(gsmSmsMessage->GetGsm()); 2193 gsmSmsMessage->GetIsSmsText(); 2194 gsmSmsMessage->GetDestAddress(); 2195 gsmSmsMessage->GetFullText(); 2196 gsmSmsMessage->SetDestPort(INVALID_SLOTID); 2197 EXPECT_TRUE(gsmSmsMessage != nullptr); 2198} 2199 2200/** 2201 * @tc.number Telephony_SmsMmsGtest_GsmSmsParamDecode_0001 2202 * @tc.name Test GsmSmsParamDecode 2203 * @tc.desc Function test 2204 */ 2205HWTEST_F(BranchSmsTest, GsmSmsParamDecode_0001, Function | MediumTest | Level1) 2206{ 2207 auto gsmSmsParamDecode = std::make_shared<GsmSmsParamDecode>(); 2208 auto buffer = std::make_shared<SmsReadBuffer>(SMS_READ_PDU); 2209 AddressNumber *pAddress = new AddressNumber(); 2210 uint8_t bcdLen = 1; 2211 uint8_t addrLen = 1; 2212 gsmSmsParamDecode->DecodeAddressAlphaNum(*buffer, pAddress, bcdLen, addrLen); 2213 SmsDcs *smsDcs = nullptr; 2214 gsmSmsParamDecode->DecodeDcsClassGroupPdu(bcdLen, smsDcs); 2215 gsmSmsParamDecode->DecodeDcsDiscardGroupPdu(bcdLen, smsDcs); 2216 gsmSmsParamDecode->DecodeDcsStoreGsmGroupPdu(bcdLen, smsDcs); 2217 gsmSmsParamDecode->DecodeDcsStoreUCS2GroupPdu(bcdLen, smsDcs); 2218 gsmSmsParamDecode->DecodeDcsUnknownGroupPdu(bcdLen, smsDcs); 2219 enum SmsIndicatorType ret = gsmSmsParamDecode->GetMsgIndicatorType(bcdLen); 2220 EXPECT_GE(ret, 0); 2221 SmsDcs *mwiTypeSmsDcs = new SmsDcs(); 2222 gsmSmsParamDecode->GetMwiType(bcdLen, *mwiTypeSmsDcs); 2223 EXPECT_TRUE(gsmSmsParamDecode != nullptr); 2224 int32_t slotId = 0; 2225 auto gsmSmsCbHandler = std::make_shared<GsmSmsCbHandler>(slotId); 2226 std::shared_ptr<GsmCbCodec> cbMessage = nullptr; 2227 gsmSmsCbHandler->RemoveCbMessageFromList(cbMessage); 2228 delete pAddress; 2229 pAddress = nullptr; 2230 delete mwiTypeSmsDcs; 2231 mwiTypeSmsDcs = nullptr; 2232 EXPECT_TRUE(gsmSmsCbHandler != nullptr); 2233 auto smsReceiveManager = std::make_shared<SmsReceiveManager>(slotId); 2234 EXPECT_TRUE(smsReceiveManager != nullptr); 2235 smsReceiveManager->Init(); 2236 EXPECT_TRUE(smsReceiveManager->gsmSmsReceiveHandler_ != nullptr); 2237 smsReceiveManager->gsmSmsReceiveHandler_->CheckSmsSupport(); 2238 std::shared_ptr<SmsBaseMessage> smsBaseMessage = nullptr; 2239 smsReceiveManager->gsmSmsReceiveHandler_->HandleNormalSmsByType(smsBaseMessage); 2240 EXPECT_TRUE(smsReceiveManager->gsmSmsReceiveHandler_ != nullptr); 2241} 2242/** 2243 * @tc.number Telephony_SmsMmsGtest_GsmSmsParamDecode_0002 2244 * @tc.name Test GsmSmsParamDecode regProcessSmscAddrs 2245 * @tc.desc Function test 2246 */ 2247HWTEST_F(BranchSmsTest, GsmSmsParamDecode_0002, Function | MediumTest | Level1) 2248{ 2249 auto gsmSmsParamDecode = std::make_shared<GsmSmsParamDecode>(); 2250 EXPECT_NE(gsmSmsParamDecode, nullptr); 2251 std::string smscAddrs = "**21888#"; 2252 std::string ret = gsmSmsParamDecode->regProcessSmsAddrs(smscAddrs); 2253 EXPECT_EQ(ret, "**21888#+"); 2254 2255 smscAddrs = "**21*+888#"; 2256 ret = gsmSmsParamDecode->regProcessSmsAddrs(smscAddrs); 2257 EXPECT_EQ(ret, "**21*++888#"); 2258 2259 smscAddrs = "#21#1188881"; 2260 ret = gsmSmsParamDecode->regProcessSmsAddrs(smscAddrs); 2261 EXPECT_EQ(ret, "#21#+1188881"); 2262 2263 smscAddrs = "1811111"; 2264 ret = gsmSmsParamDecode->regProcessSmsAddrs(smscAddrs); 2265 EXPECT_EQ(ret, "+1811111"); 2266} 2267 2268/** 2269 * @tc.number Telephony_SmsMmsGtest_SmsService_0004 2270 * @tc.name Test SmsService 2271 * @tc.desc Function test 2272 */ 2273HWTEST_F(BranchSmsTest, SmsService_0004, Function | MediumTest | Level1) 2274{ 2275 int32_t slotId = 0; 2276 std::u16string desAddr = u""; 2277 sptr<ISendShortMessageCallback> sendCallback; 2278 sptr<IDeliveryShortMessageCallback> deliveryCallback; 2279 auto smsService = DelayedSingleton<SmsService>::GetInstance(); 2280 AccessMmsToken token; 2281 smsService->SendMessage(slotId, desAddr, desAddr, desAddr, sendCallback, deliveryCallback, true); 2282 smsService->SendMessage(slotId, desAddr, desAddr, desAddr, sendCallback, deliveryCallback, false); 2283 uint16_t port = 1; 2284 uint8_t *data = nullptr; 2285 smsService->SendMessage(slotId, desAddr, desAddr, port, data, port, sendCallback, deliveryCallback); 2286 slotId = -1; 2287 desAddr = u"test"; 2288 smsService->SendMessage(slotId, desAddr, desAddr, desAddr, sendCallback, deliveryCallback, true); 2289 smsService->SendMessage(slotId, desAddr, desAddr, desAddr, sendCallback, deliveryCallback, false); 2290 smsService->SendMessage(slotId, desAddr, desAddr, port, data, port, sendCallback, deliveryCallback); 2291 slotId = 0; 2292 std::string telephone = "13888888888"; 2293 uint16_t dataBaseId = 0; 2294 smsService->InsertSessionAndDetail(slotId, telephone, telephone, dataBaseId); 2295 bool isSupported = false; 2296 slotId = -1; 2297 smsService->IsImsSmsSupported(slotId, isSupported); 2298 std::u16string format = u""; 2299 smsService->GetImsShortMessageFormat(format); 2300 smsService->HasSmsCapability(); 2301 int32_t setSmscRes = 0; 2302 setSmscRes = smsService->SetSmscAddr(slotId, desAddr); 2303 desAddr = u" test"; 2304 string sca = StringUtils::ToUtf8(desAddr); 2305 smsService->TrimSmscAddr(sca); 2306 desAddr = u"test "; 2307 sca = StringUtils::ToUtf8(desAddr); 2308 smsService->TrimSmscAddr(sca); 2309 int32_t smscRes = 0; 2310 smscRes = smsService->GetSmscAddr(slotId, desAddr); 2311 EXPECT_GE(setSmscRes, TELEPHONY_ERR_SLOTID_INVALID); 2312 EXPECT_GE(smscRes, TELEPHONY_ERR_ARGUMENT_INVALID); 2313 EXPECT_TRUE(smsService != nullptr); 2314} 2315 2316/** 2317 * @tc.number Telephony_SmsMmsGtest_SmsService_0005 2318 * @tc.name Test SmsService 2319 * @tc.desc Function test 2320 */ 2321HWTEST_F(BranchSmsTest, SmsService_0005, Function | MediumTest | Level1) 2322{ 2323 int32_t slotId = 0; 2324 std::u16string desAddr = u""; 2325 sptr<ISendShortMessageCallback> sendCallback; 2326 sptr<IDeliveryShortMessageCallback> deliveryCallback; 2327 auto smsService = DelayedSingleton<SmsService>::GetInstance(); 2328 AccessMmsToken token; 2329 smsService->AddSimMessage( 2330 slotId, desAddr, desAddr, ISmsServiceInterface::SimMessageStatus::SIM_MESSAGE_STATUS_UNREAD); 2331 uint32_t msgIndex = 1; 2332 smsService->DelSimMessage(slotId, msgIndex); 2333 smsService->UpdateSimMessage( 2334 slotId, msgIndex, ISmsServiceInterface::SimMessageStatus::SIM_MESSAGE_STATUS_UNREAD, desAddr, desAddr); 2335 smsService->CheckSimMessageIndexValid(slotId, msgIndex); 2336 uint32_t fromMsgId = 1; 2337 uint32_t toMsgId = 1; 2338 uint8_t netType = 1; 2339 smsService->SetCBConfig(slotId, true, fromMsgId, toMsgId, netType); 2340 int32_t enable = 1; 2341 smsService->SetImsSmsConfig(slotId, enable); 2342 smsService->SetDefaultSmsSlotId(slotId); 2343 smsService->GetDefaultSmsSlotId(); 2344 smsService->GetDefaultSmsSimId(slotId); 2345 std::u16string message = u""; 2346 ISmsServiceInterface::SmsSegmentsInfo info; 2347 std::vector<std::u16string> splitMessage; 2348 bool text = true; 2349 int32_t splitRes = 0; 2350 int32_t smsRes = 0; 2351 splitRes = smsService->SplitMessage(message, splitMessage); 2352 smsRes = smsService->GetSmsSegmentsInfo(slotId, message, text, info); 2353 message = u"text"; 2354 splitRes = smsService->SplitMessage(message, splitMessage); 2355 smsRes = smsService->GetSmsSegmentsInfo(slotId, message, text, info); 2356 smsService->GetServiceRunningState(); 2357 smsService->GetEndTime(); 2358 smsService->GetSpendTime(); 2359 EXPECT_GE(splitRes, TELEPHONY_ERR_ARGUMENT_INVALID); 2360 EXPECT_GE(smsRes, TELEPHONY_ERR_ARGUMENT_INVALID); 2361 EXPECT_TRUE(smsService != nullptr); 2362} 2363 2364/** 2365 * @tc.number Telephony_SmsMmsGtest_SmsPersistHelper_0002 2366 * @tc.name Test SmsPersistHelper 2367 * @tc.desc Function test 2368 */ 2369HWTEST_F(BranchSmsTest, SmsPersistHelper_0002, Function | MediumTest | Level1) 2370{ 2371 std::string formatNum = ""; 2372 auto smsPersistHelper = DelayedSingleton<SmsPersistHelper>::GetInstance(); 2373 std::string num = ""; 2374 std::string cbnNumTemp = ""; 2375 cbnNumTemp.assign(CBN_NUM); 2376 num = cbnNumTemp.substr(DIGIT_LEN, NUM_LENGTH); 2377 smsPersistHelper->CbnFormat(num, i18n::phonenumbers::PhoneNumberUtil::PhoneNumberFormat::NATIONAL, formatNum); 2378 EXPECT_TRUE(formatNum == num); 2379 smsPersistHelper->CbnFormat(num, i18n::phonenumbers::PhoneNumberUtil::PhoneNumberFormat::INTERNATIONAL, formatNum); 2380 EXPECT_TRUE(formatNum == cbnNumTemp); 2381 smsPersistHelper->CbnFormat( 2382 cbnNumTemp, i18n::phonenumbers::PhoneNumberUtil::PhoneNumberFormat::INTERNATIONAL, formatNum); 2383 EXPECT_TRUE(formatNum == cbnNumTemp); 2384 smsPersistHelper->CbnFormat( 2385 cbnNumTemp, i18n::phonenumbers::PhoneNumberUtil::PhoneNumberFormat::NATIONAL, formatNum); 2386 EXPECT_TRUE(formatNum == num); 2387} 2388 2389/** 2390 * @tc.number Telephony_SmsMmsGtest_SmsNetworkPolicyManager_0001 2391 * @tc.name Test SmsNetworkPolicyManager 2392 * @tc.desc Function test 2393 */ 2394HWTEST_F(BranchSmsTest, SmsNetworkPolicyManager_0001, Function | MediumTest | Level1) 2395{ 2396 auto smsNetworkPolicyManager = std::make_shared<SmsNetworkPolicyManager>(INVALID_SLOTID); 2397 smsNetworkPolicyManager->IsImsNetDomain(); 2398 smsNetworkPolicyManager->GetVoiceServiceState(); 2399 smsNetworkPolicyManager->NetworkRegister(nullptr); 2400 auto smsBaseMessage = std::make_shared<GsmSmsMessage>(); 2401 smsBaseMessage->GetSmscAddr(); 2402 smsBaseMessage->GetRawUserData(); 2403 smsBaseMessage->GetRawWapPushUserData(); 2404 smsBaseMessage->IsReplaceMessage(); 2405 smsBaseMessage->IsCphsMwi(); 2406 smsBaseMessage->IsMwiNotStore(); 2407 smsBaseMessage->GetStatus(); 2408 smsBaseMessage->IsSmsStatusReportMessage(); 2409 smsBaseMessage->HasReplyPath(); 2410 smsBaseMessage->GetMsgRef(); 2411 smsBaseMessage->SetIndexOnSim(0); 2412 smsBaseMessage->GetIndexOnSim(); 2413 auto smsInterfaceManager = std::make_shared<SmsInterfaceManager>(INVALID_SLOTID); 2414 smsInterfaceManager->DelSimMessage(0); 2415 auto smsWapPushBuffer = std::make_shared<SmsWapPushBuffer>(); 2416 smsWapPushBuffer->DecodeExtensionMedia(); 2417 smsWapPushBuffer->DecodeConstrainedEncoding(); 2418 smsWapPushBuffer->MarkPosition(); 2419 smsWapPushBuffer->UnMarkPosition(); 2420 std::shared_ptr<CdmaSmsMessage> cdmaSmsMessage = std::make_shared<CdmaSmsMessage>(); 2421 cdmaSmsMessage->GetCbInfo(); 2422 cdmaSmsMessage->GetCMASResponseType(); 2423 cdmaSmsMessage->GetSpecialSmsInd(); 2424 cdmaSmsMessage->GetProtocolId(); 2425 cdmaSmsMessage->IsReplaceMessage(); 2426 cdmaSmsMessage->IsCphsMwi(); 2427 EXPECT_TRUE(smsNetworkPolicyManager != nullptr); 2428 EXPECT_TRUE(smsBaseMessage != nullptr); 2429 EXPECT_TRUE(smsInterfaceManager != nullptr); 2430 EXPECT_TRUE(cdmaSmsMessage != nullptr); 2431} 2432 2433/** 2434 * @tc.number Telephony_SmsMmsGtest_SmsNetworkPolicyManager_0004 2435 * @tc.name Test SmsNetworkPolicyManager 2436 * @tc.desc Function test 2437 */ 2438HWTEST_F(BranchSmsTest, SmsNetworkPolicyManager_0004, Function | MediumTest | Level1) 2439{ 2440 auto smsMiscManager = std::make_shared<SmsMiscManager>(INVALID_SLOTID); 2441 smsMiscManager->GetRangeInfo(); 2442 smsMiscManager->IsEmpty(); 2443 std::shared_ptr<SmsReceiveIndexer> indexer = std::make_shared<SmsReceiveIndexer>(); 2444 indexer->SetVisibleAddress(CBN_NUM); 2445 indexer->SetMsgCount(0); 2446 indexer->SetMsgSeqId(0); 2447 indexer->SetOriginatingAddress(CBN_NUM); 2448 indexer->SetIsCdmaWapPdu(false); 2449 indexer->GetIsCdmaWapPdu(); 2450 indexer->SetIsCdma(false); 2451 indexer->SetDestPort(0); 2452 indexer->SetTimestamp(0); 2453 indexer->SetPdu(PDU); 2454 indexer->SetRawWapPushUserData(CBN_NUM); 2455 const sptr<ISendShortMessageCallback> sendCallback = 2456 iface_cast<ISendShortMessageCallback>(new SendShortMessageCallbackStub()); 2457 const sptr<IDeliveryShortMessageCallback> deliveryCallback = 2458 iface_cast<IDeliveryShortMessageCallback>(new DeliveryShortMessageCallbackStub()); 2459 std::shared_ptr<SmsSendIndexer> smsIndexer = 2460 std::make_shared<SmsSendIndexer>(CBN_NUM, CBN_NUM, CBN_NUM, sendCallback, deliveryCallback); 2461 smsIndexer->SetEncodeSmca(PDU); 2462 smsIndexer->SetText(CBN_NUM); 2463 smsIndexer->SetDeliveryCallback(deliveryCallback); 2464 smsIndexer->SetSendCallback(sendCallback); 2465 smsIndexer->SetDestPort(0); 2466 smsIndexer->SetDestAddr(CBN_NUM); 2467 smsIndexer->SetSmcaAddr(CBN_NUM); 2468 smsIndexer->GetIsText(); 2469 smsIndexer->GetErrorCode(); 2470 smsIndexer->SetData(PDU); 2471 smsIndexer->SetAckPdu(PDU); 2472 smsIndexer->GetAckPdu(); 2473 smsIndexer->SetMsgRefId64Bit(0); 2474 smsIndexer->SetIsConcat(true); 2475 EXPECT_TRUE(smsMiscManager != nullptr); 2476 EXPECT_TRUE(indexer != nullptr); 2477 EXPECT_TRUE(sendCallback != nullptr); 2478 EXPECT_TRUE(deliveryCallback != nullptr); 2479 EXPECT_TRUE(smsIndexer != nullptr); 2480} 2481} // namespace Telephony 2482} // namespace OHOS 2483