1/* 2 * Copyright (C) 2023 Huawei Device Co., Ltd. 3 * Licensed under the Apache License, Version 2.0 (the "License"); 4 * you may not use this file except in compliance with the License. 5 * You may obtain a copy of the License at 6 * 7 * http://www.apache.org/licenses/LICENSE-2.0 8 * 9 * Unless required by applicable law or agreed to in writing, software 10 * distributed under the License is distributed on an "AS IS" BASIS, 11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 * See the License for the specific language governing permissions and 13 * limitations under the License. 14 */ 15 16#define private public 17#define protected public 18 19#include "cdma_sms_message.h" 20#include "cdma_sms_transport_message.h" 21#include "core_service_client.h" 22#include "gtest/gtest.h" 23#include "i_sms_service_interface.h" 24#include "if_system_ability_manager.h" 25#include "iservice_registry.h" 26#include "radio_event.h" 27#include "sms_mms_gtest.h" 28#include "sms_mms_test_helper.h" 29#include "sms_service.h" 30#include "sms_service_manager_client.h" 31#include "string_utils.h" 32#include "telephony_log_wrapper.h" 33 34namespace OHOS { 35namespace Telephony { 36namespace { 37sptr<ISmsServiceInterface> g_telephonyService = nullptr; 38} // namespace 39using namespace testing::ext; 40 41class CdmaSmsGtest : public testing::Test { 42public: 43 static void SetUpTestCase(); 44 static void TearDownTestCase(); 45 void SetUp(); 46 void TearDown(); 47 static sptr<ISmsServiceInterface> GetProxy(); 48 static bool HasSimCard(int32_t slotId) 49 { 50 bool hasSimCard = false; 51 if (CoreServiceClient::GetInstance().GetProxy() == nullptr) { 52 return hasSimCard; 53 } 54 CoreServiceClient::GetInstance().HasSimCard(slotId, hasSimCard); 55 return hasSimCard; 56 } 57}; 58 59void CdmaSmsGtest::TearDownTestCase() {} 60 61void CdmaSmsGtest::SetUp() {} 62 63void CdmaSmsGtest::TearDown() {} 64 65const int32_t DEFAULT_SIM_SLOT_ID_1 = 1; 66const uint8_t HEX_CHAR_LEN = 2; 67const uint8_t UNICODE_CHAR_LEN = 2; 68const uint8_t VALUE_INDEX = 2; 69const char *CDMA_PDU = "01010101"; 70const char *OTHER_CDMA_PDU = "111111"; 71 72void CdmaSmsGtest::SetUpTestCase() 73{ 74 TELEPHONY_LOGI("SetUpTestCase slotId%{public}d", DEFAULT_SIM_SLOT_ID_1); 75 g_telephonyService = GetProxy(); 76 if (g_telephonyService == nullptr) { 77 return; 78 } 79 Singleton<SmsServiceManagerClient>::GetInstance().ResetSmsServiceProxy(); 80 Singleton<SmsServiceManagerClient>::GetInstance().InitSmsServiceProxy(); 81} 82 83sptr<ISmsServiceInterface> CdmaSmsGtest::GetProxy() 84{ 85 auto systemAbilityMgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager(); 86 if (systemAbilityMgr == nullptr) { 87 return nullptr; 88 } 89 sptr<IRemoteObject> remote = systemAbilityMgr->CheckSystemAbility(TELEPHONY_SMS_MMS_SYS_ABILITY_ID); 90 if (remote) { 91 sptr<ISmsServiceInterface> smsService = iface_cast<ISmsServiceInterface>(remote); 92 return smsService; 93 } 94 return nullptr; 95} 96 97#ifndef TEL_TEST_UNSUPPORT 98/** 99 * @tc.number Telephony_SmsMmsGtest_CdmaSmsMessage_0001 100 * @tc.name Test CdmaSmsMessage 101 * @tc.desc Function test 102 */ 103HWTEST_F(CdmaSmsGtest, CdmaSmsMessage_0001, Function | MediumTest | Level1) 104{ 105 TELEPHONY_LOGI("TelSMSMMSTest::CdmaSmsMessage_0001 -->"); 106 CdmaSmsMessage cdmaSmsMessage; 107 std::string dest = "dest"; 108 std::string sc = "sc"; 109 std::string text = "text"; 110 int32_t port = 10; 111 uint8_t *data; 112 uint32_t dataLen = 10; 113 std::string pdu = "01000B818176251308F4000007E8B0BCFD76E701"; 114 bool bStatusReport = false; 115 DataCodingScheme codingScheme = DATA_CODING_7BIT; 116 cdmaSmsMessage.CreateSubmitTransMsg(dest, sc, text, bStatusReport, codingScheme); 117 cdmaSmsMessage.CreateSubmitTransMsg(dest, sc, port, data, dataLen, bStatusReport); 118 cdmaSmsMessage.GreateTransMsg(); 119 cdmaSmsMessage.CovertEncodingType(codingScheme); 120 cdmaSmsMessage.CreateMessage(pdu); 121 cdmaSmsMessage.PduAnalysis(pdu); 122 CdmaP2PMsg p2pMsg; 123 cdmaSmsMessage.AnalysisP2pMsg(p2pMsg); 124 cdmaSmsMessage.AnalsisDeliverMwi(p2pMsg); 125 bool ret = cdmaSmsMessage.PduAnalysis(""); 126 EXPECT_EQ(false, ret); 127} 128 129/** 130 * @tc.number Telephony_SmsMmsGtest_CdmaSmsReceiveHandler_0001 131 * @tc.name Test CdmaSmsReceiveHandler 132 * @tc.desc Function test 133 */ 134HWTEST_F(CdmaSmsGtest, CdmaSmsReceiveHandler_0001, Function | MediumTest | Level1) 135{ 136 TELEPHONY_LOGI("TelSMSMMSTest::CdmaSmsReceiveHandler_0001 -->"); 137 auto smsReceiveManager = std::make_shared<SmsReceiveManager>(DEFAULT_SIM_SLOT_ID); 138 EXPECT_TRUE(smsReceiveManager != nullptr); 139 smsReceiveManager->Init(); 140 EXPECT_TRUE(smsReceiveManager->cdmaSmsReceiveHandler_ != nullptr); 141 int32_t retInt = smsReceiveManager->cdmaSmsReceiveHandler_->HandleSmsByType(nullptr); 142 EXPECT_EQ(AckIncomeCause::SMS_ACK_UNKNOWN_ERROR, retInt); 143} 144 145/** 146 * @tc.number Telephony_SmsMmsGtest_CdmaSmsReceiveHandler_0002 147 * @tc.name Test CdmaSmsReceiveHandler 148 * @tc.desc Function test 149 */ 150HWTEST_F(CdmaSmsGtest, CdmaSmsReceiveHandler_0002, Function | MediumTest | Level1) 151{ 152 TELEPHONY_LOGI("TelSMSMMSTest::CdmaSmsReceiveHandler_0002 -->"); 153 auto smsReceiveManager = std::make_shared<SmsReceiveManager>(DEFAULT_SIM_SLOT_ID); 154 EXPECT_TRUE(smsReceiveManager != nullptr); 155 smsReceiveManager->Init(); 156 EXPECT_TRUE(smsReceiveManager->cdmaSmsReceiveHandler_ != nullptr); 157 auto retMsg = std::make_shared<CdmaSmsMessage>(); 158 retMsg = CdmaSmsMessage::CreateMessage(CDMA_PDU); 159 EXPECT_EQ(retMsg, nullptr); 160 auto cdmaMsg = std::make_shared<CdmaSmsMessage>(); 161 cdmaMsg->transMsg_ = std::make_unique<struct CdmaTransportMsg>(); 162 cdmaMsg->transMsg_->type = CdmaTransportMsgType::BROADCAST; 163 int32_t retInt = smsReceiveManager->cdmaSmsReceiveHandler_->HandleSmsByType(cdmaMsg); 164 EXPECT_EQ(AckIncomeCause::SMS_ACK_RESULT_OK, retInt); 165 cdmaMsg->transMsg_->type = CdmaTransportMsgType::P2P; 166 retInt = smsReceiveManager->cdmaSmsReceiveHandler_->HandleSmsByType(cdmaMsg); 167 EXPECT_EQ(AckIncomeCause::SMS_ACK_RESULT_OK, retInt); 168 cdmaMsg->transMsg_->type = CdmaTransportMsgType::ACK; 169 retInt = smsReceiveManager->cdmaSmsReceiveHandler_->HandleSmsByType(cdmaMsg); 170 EXPECT_EQ(AckIncomeCause::SMS_ACK_RESULT_OK, retInt); 171 cdmaMsg->transMsg_->type = CdmaTransportMsgType::RESERVED; 172 retInt = smsReceiveManager->cdmaSmsReceiveHandler_->HandleSmsByType(cdmaMsg); 173 EXPECT_EQ(AckIncomeCause::SMS_ACK_RESULT_OK, retInt); 174} 175 176/** 177 * @tc.number Telephony_SmsMmsGtest_CdmaSmsReceiveHandler_0003 178 * @tc.name Test CdmaSmsReceiveHandler 179 * @tc.desc Function test 180 */ 181HWTEST_F(CdmaSmsGtest, CdmaSmsReceiveHandler_0003, Function | MediumTest | Level1) 182{ 183 TELEPHONY_LOGI("TelSMSMMSTest::CdmaSmsReceiveHandler_0003 -->"); 184 auto smsReceiveManager = std::make_shared<SmsReceiveManager>(DEFAULT_SIM_SLOT_ID); 185 EXPECT_TRUE(smsReceiveManager != nullptr); 186 smsReceiveManager->Init(); 187 EXPECT_TRUE(smsReceiveManager->cdmaSmsReceiveHandler_ != nullptr); 188 int32_t retInt = smsReceiveManager->cdmaSmsReceiveHandler_->HandleSmsOtherSvcid(nullptr); 189 EXPECT_NE(AckIncomeCause::SMS_ACK_RESULT_OK, retInt); 190 auto retMsg = CdmaSmsMessage::CreateMessage(OTHER_CDMA_PDU); 191 EXPECT_EQ(retMsg, nullptr); 192 193 auto cdmaMsg = std::make_shared<CdmaSmsMessage>(); 194 smsReceiveManager->cdmaSmsReceiveHandler_->ReplySmsToSmsc(1); 195 retInt = smsReceiveManager->cdmaSmsReceiveHandler_->HandleSmsOtherSvcid(cdmaMsg); 196 EXPECT_NE(AckIncomeCause::SMS_ACK_RESULT_OK, retInt); 197 cdmaMsg->smsConcat_ = std::make_shared<SmsConcat>(); 198 cdmaMsg->smsConcat_->is8Bits = true; 199 cdmaMsg->smsConcat_->msgRef = 1; 200 cdmaMsg->smsConcat_->seqNum = 1; 201 cdmaMsg->smsConcat_->totalSeg = 1; 202 retInt = smsReceiveManager->cdmaSmsReceiveHandler_->HandleSmsOtherSvcid(cdmaMsg); 203 EXPECT_NE(AckIncomeCause::SMS_ACK_RESULT_OK, retInt); 204} 205 206/** 207 * @tc.number Telephony_SmsMmsGtest_CdmaSmsReceiveHandler_0004 208 * @tc.name Test CdmaSmsReceiveHandler 209 * @tc.desc Function test 210 */ 211HWTEST_F(CdmaSmsGtest, CdmaSmsReceiveHandler_0004, Function | MediumTest | Level1) 212{ 213 TELEPHONY_LOGI("TelSMSMMSTest::CdmaSmsReceiveHandler_0004 -->"); 214 auto smsReceiveManager = std::make_shared<SmsReceiveManager>(DEFAULT_SIM_SLOT_ID); 215 EXPECT_TRUE(smsReceiveManager != nullptr); 216 smsReceiveManager->Init(); 217 EXPECT_TRUE(smsReceiveManager->cdmaSmsReceiveHandler_ != nullptr); 218 std::function<void(std::shared_ptr<SmsSendIndexer>)> fun = nullptr; 219 auto smsSender = std::make_shared<CdmaSmsSender>(DEFAULT_SIM_SLOT_ID, fun); 220 smsReceiveManager->cdmaSmsReceiveHandler_->SetCdmaSender(smsSender); 221 auto info = std::make_shared<SmsMessageInfo>(); 222 auto ret = smsReceiveManager->cdmaSmsReceiveHandler_->TransformMessageInfo(info); 223 EXPECT_EQ(ret, nullptr); 224 smsReceiveManager->cdmaSmsReceiveHandler_->SendCBBroadcast(nullptr); 225 auto cdmaMsg = std::make_shared<CdmaSmsMessage>(); 226 EXPECT_EQ(smsReceiveManager->cdmaSmsReceiveHandler_->SendCBBroadcast(cdmaMsg), true); 227} 228 229/** 230 * @tc.number Telephony_CdmaSmsGtest_SmsPduBuffer_0001 231 * @tc.name Test SmsPduBuffer 232 * @tc.desc Function test 233 */ 234HWTEST_F(CdmaSmsGtest, SmsPduBuffer_0001, Function | MediumTest | Level1) 235{ 236 auto buffer = std::make_shared<SmsPduBuffer>(); 237 EXPECT_TRUE(buffer->IsEmpty()); 238 EXPECT_EQ(buffer->GetIndex(), 0); 239 EXPECT_FALSE(buffer->SetIndex(1)); 240 EXPECT_EQ(buffer->MoveForward(), 0); 241 EXPECT_EQ(buffer->SkipBits(), 0); 242 243 std::string pduHex = "00000210020000021002"; 244 std::string pdu = StringUtils::HexToString(pduHex); 245 auto rBuffer = std::make_shared<SmsReadBuffer>(pdu); 246 EXPECT_FALSE(rBuffer->IsEmpty()); 247 rBuffer->SetIndex(0); 248 uint8_t v = 0; 249 uint16_t v2 = 0; 250 EXPECT_TRUE(rBuffer->ReadByte(v)); 251 EXPECT_TRUE(rBuffer->ReadWord(v2)); 252 EXPECT_TRUE(rBuffer->ReadBits(v)); 253 254 auto wBuffer = std::make_shared<SmsWriteBuffer>(); 255 EXPECT_FALSE(wBuffer->IsEmpty()); 256 wBuffer->SetIndex(0); 257 v = 1; 258 v2 = 0x1234; 259 EXPECT_TRUE(wBuffer->WriteByte(v)); 260 EXPECT_TRUE(wBuffer->WriteWord(v2)); 261 EXPECT_TRUE(wBuffer->InsertByte(v, 1)); 262 EXPECT_TRUE(wBuffer->WriteBits(v)); 263} 264 265/** 266 * @tc.number Telephony_CdmaSmsGtest_CdmaSmsTransportMessage_0001 267 * @tc.name Test CdmaSmsTransportMessage 268 * @tc.desc Function test 269 */ 270HWTEST_F(CdmaSmsGtest, CdmaSmsTransportMessage_0001, Function | MediumTest | Level1) 271{ 272 TELEPHONY_LOGI("TelSMSMMSTest::CdmaSmsTransportMessage_0001 -->"); 273 CdmaSmsMessage cdmaSmsMessage; 274 std::string dest = "dest"; 275 std::string sc = "sc"; 276 std::string text = "text"; 277 bool bStatusReport = false; 278 DataCodingScheme codingScheme = DATA_CODING_7BIT; 279 std::unique_ptr<CdmaTransportMsg> transMsg = 280 cdmaSmsMessage.CreateSubmitTransMsg(dest, sc, text, bStatusReport, codingScheme); 281 282 std::unique_ptr<CdmaSmsTransportMessage> transportMessage = 283 CdmaSmsTransportMessage::CreateTransportMessage(*transMsg.get()); 284 SmsWriteBuffer pduBuffer; 285 EXPECT_NE(transportMessage, nullptr); 286 EXPECT_NE(transportMessage->IsEmpty(), true); 287 EXPECT_EQ(transportMessage->Encode(pduBuffer), true); 288 std::unique_ptr<std::vector<uint8_t>> pdu = pduBuffer.GetPduBuffer(); 289 EXPECT_NE(pdu, nullptr); 290 EXPECT_GT(pdu->size(), static_cast<uint32_t>(0)); 291} 292 293/** 294 * @tc.number Telephony_CdmaSmsGtest_CdmaSmsTransportMessage_0002 295 * @tc.name Test CdmaSmsTransportMessage 296 * @tc.desc Function test 297 */ 298HWTEST_F(CdmaSmsGtest, CdmaSmsTransportMessage_0002, Function | MediumTest | Level1) 299{ 300 TELEPHONY_LOGI("TelSMSMMSTest::CdmaSmsTransportMessage_0002 -->"); 301 std::string pduHex = "0000021002040702C48D159E268406010408260003200640011910D61C58F265CD9F469D5AF66DDDBF871E5CFA75E" 302 "DDFC79F400801000A0140"; 303 std::string pdu = StringUtils::HexToString(pduHex); 304 SmsReadBuffer pduBuffer(pdu); 305 CdmaTransportMsg msg; 306 memset_s(&msg, sizeof(msg), 0, sizeof(msg)); 307 std::unique_ptr<CdmaSmsTransportMessage> transportMessage = 308 CdmaSmsTransportMessage::CreateTransportMessage(msg, pduBuffer); 309 EXPECT_NE(transportMessage, nullptr); 310 EXPECT_NE(transportMessage->IsEmpty(), true); 311 EXPECT_EQ(transportMessage->Decode(pduBuffer), true); 312} 313 314/** 315 * @tc.number Telephony_CdmaSmsGtest_CdmaSmsTransportMessage_0003 316 * @tc.name Test CdmaSmsTransportMessage 317 * @tc.desc Function test 318 */ 319HWTEST_F(CdmaSmsGtest, CdmaSmsTransportMessage_0003, Function | MediumTest | Level1) 320{ 321 // BROADCAST DELIVER CMASDATA 322 uint8_t cmasTestBearerData[] = { 0x00, 0x03, 0x1C, 0x78, 0x00, 0x01, 0x59, 0x02, 0xB8, 0x00, 0x02, 0x10, 0xAA, 323 0x68, 0xD3, 0xCD, 0x06, 0x9E, 0x68, 0x30, 0xA0, 0xE9, 0x97, 0x9F, 0x44, 0x1B, 0xF3, 0x20, 0xE9, 0xA3, 0x2A, 324 0x08, 0x7B, 0xF6, 0xED, 0xCB, 0xCB, 0x1E, 0x9C, 0x3B, 0x10, 0x4D, 0xDF, 0x8B, 0x4E, 0xCC, 0xA8, 0x20, 0xEC, 325 0xCB, 0xCB, 0xA2, 0x0A, 0x7E, 0x79, 0xF4, 0xCB, 0xB5, 0x72, 0x0A, 0x9A, 0x34, 0xF3, 0x41, 0xA7, 0x9A, 0x0D, 326 0xFB, 0xB6, 0x79, 0x41, 0x85, 0x07, 0x4C, 0xBC, 0xFA, 0x2E, 0x00, 0x08, 0x20, 0x58, 0x38, 0x88, 0x80, 0x10, 327 0x54, 0x06, 0x38, 0x20, 0x60, 0x30, 0xA8, 0x81, 0x90, 0x20, 0x08 }; 328 329 std::stringstream ss; 330 ss.clear(); 331 ss << static_cast<uint8_t>(CdmaTransportMsgType::BROADCAST); 332 ss << static_cast<uint8_t>(CdmaSmsParameterRecord::SERVICE_CATEGORY); 333 ss << static_cast<uint8_t>(0x02); 334 ss << static_cast<uint8_t>(static_cast<uint16_t>(SmsServiceCtg::CMAS_TEST) >> 8); 335 ss << static_cast<uint8_t>(static_cast<uint16_t>(SmsServiceCtg::CMAS_TEST) & 0xff); 336 ss << static_cast<uint8_t>(CdmaSmsParameterRecord::BEARER_DATA); 337 ss << static_cast<uint8_t>(sizeof(cmasTestBearerData)); 338 for (uint8_t i = 0; i < sizeof(cmasTestBearerData); i++) { 339 ss << cmasTestBearerData[i]; 340 } 341 SmsReadBuffer rBuffer(ss.str()); 342 CdmaTransportMsg msg; 343 memset_s(&msg, sizeof(msg), 0, sizeof(msg)); 344 std::unique_ptr<CdmaSmsTransportMessage> message = CdmaSmsTransportMessage::CreateTransportMessage(msg, rBuffer); 345 EXPECT_TRUE(message->Decode(rBuffer)); 346 EXPECT_EQ(msg.data.broadcast.telesvcMsg.data.deliver.msgId.msgId, 0xc780); 347 EXPECT_EQ(msg.data.broadcast.serviceCtg, static_cast<uint16_t>(SmsServiceCtg::CMAS_TEST)); 348 EXPECT_EQ(msg.data.broadcast.telesvcMsg.data.deliver.cmasData.dataLen, 74); 349 EXPECT_EQ(msg.data.broadcast.telesvcMsg.data.deliver.cmasData.urgency, SmsCmaeUrgency::EXPECTED); 350} 351 352/** 353 * @tc.number Telephony_CdmaSmsGtest_CdmaSmsTransportMessage_0004 354 * @tc.name Test CdmaSmsTransportMessage 355 * @tc.desc Function test 356 */ 357HWTEST_F(CdmaSmsGtest, CdmaSmsTransportMessage_0004, Function | MediumTest | Level1) 358{ 359 // BROADCAST DELIVER USERDATA(BCCBB) 360 std::string pduHex = "0101020004081300031008d00106102c2870e1420801c00c01c0"; 361 std::string pdu = StringUtils::HexToString(pduHex); 362 SmsReadBuffer pduBuffer(pdu); 363 CdmaTransportMsg msg; 364 memset_s(&msg, sizeof(msg), 0, sizeof(msg)); 365 std::unique_ptr<CdmaSmsTransportMessage> transportMessage = 366 CdmaSmsTransportMessage::CreateTransportMessage(msg, pduBuffer); 367 EXPECT_NE(transportMessage, nullptr); 368 EXPECT_FALSE(transportMessage->IsEmpty()); 369 EXPECT_TRUE(transportMessage->Decode(pduBuffer)); 370} 371 372string GetUserDataString(SmsTeleSvcUserData userData) 373{ 374 std::stringstream ssUserData; 375 if (userData.encodeType == SmsEncodingType::UNICODE) { 376 char unicodeChar[UNICODE_CHAR_LEN + 1]; 377 unicodeChar[UNICODE_CHAR_LEN] = '\0'; 378 for (uint8_t i = 0; i < userData.userData.length; i += UNICODE_CHAR_LEN) { 379 ssUserData << "\\u"; 380 snprintf_s(unicodeChar, sizeof(unicodeChar), sizeof(unicodeChar) - 1, "%02x", 381 static_cast<uint8_t>(userData.userData.data[i])); 382 ssUserData << unicodeChar; 383 snprintf_s(unicodeChar, sizeof(unicodeChar), sizeof(unicodeChar) - 1, "%02x", 384 static_cast<uint8_t>(userData.userData.data[i + 1])); 385 ssUserData << unicodeChar; 386 } 387 } else { 388 for (uint8_t i = 0; i < userData.userData.length; i++) { 389 ssUserData << static_cast<uint8_t>(userData.userData.data[i]); 390 } 391 } 392 return ssUserData.str(); 393} 394 395void CheckDeliverUserData(string pdu, string userData) 396{ 397 std::stringstream ss; 398 ss << static_cast<uint8_t>(CdmaSmsParameterRecord::BEARER_DATA); 399 ss << static_cast<uint8_t>(pdu.size() / HEX_CHAR_LEN); 400 ss << StringUtils::HexToString(pdu); 401 402 CdmaTeleserviceMsg v; 403 memset_s(&v, sizeof(CdmaTeleserviceMsg), 0x00, sizeof(CdmaTeleserviceMsg)); 404 SmsReadBuffer rBuffer(ss.str()); 405 rBuffer.SetIndex(VALUE_INDEX); 406 auto message = std::make_shared<CdmaSmsBearerData>(v, rBuffer); 407 rBuffer.SetIndex(0); 408 EXPECT_TRUE(message->Decode(rBuffer)); 409 EXPECT_STREQ(GetUserDataString(v.data.deliver.userData).c_str(), userData.c_str()); 410} 411 412void CheckSubmitUserData(string pdu, string userData) 413{ 414 std::stringstream ss; 415 ss << static_cast<uint8_t>(CdmaSmsParameterRecord::BEARER_DATA); 416 ss << static_cast<uint8_t>(pdu.size() / HEX_CHAR_LEN); 417 ss << StringUtils::HexToString(pdu); 418 419 CdmaTeleserviceMsg v; 420 memset_s(&v, sizeof(CdmaTeleserviceMsg), 0x00, sizeof(CdmaTeleserviceMsg)); 421 SmsReadBuffer rBuffer(ss.str()); 422 rBuffer.SetIndex(VALUE_INDEX); 423 auto message = std::make_shared<CdmaSmsBearerData>(v, rBuffer); 424 rBuffer.SetIndex(0); 425 EXPECT_TRUE(message->Decode(rBuffer)); 426 EXPECT_STREQ(GetUserDataString(v.data.submit.userData).c_str(), userData.c_str()); 427 428 auto message1 = std::make_shared<CdmaSmsBearerData>(v); 429 SmsWriteBuffer wBuffer; 430 EXPECT_TRUE(message1->Encode(wBuffer)); 431 auto buffer = wBuffer.GetPduBuffer(); 432 EXPECT_GT(buffer->size(), 0); 433 std::stringstream ssEncode; 434 for (uint16_t i = 0; i < buffer->size(); i++) { 435 ssEncode << (*buffer)[i]; 436 } 437 438 CdmaTeleserviceMsg v2; 439 memset_s(&v2, sizeof(CdmaTeleserviceMsg), 0x00, sizeof(CdmaTeleserviceMsg)); 440 SmsReadBuffer rBuffer2(ssEncode.str()); 441 rBuffer2.SetIndex(VALUE_INDEX); 442 auto message2 = std::make_shared<CdmaSmsBearerData>(v2, rBuffer2); 443 rBuffer2.SetIndex(0); 444 EXPECT_TRUE(message2->Decode(rBuffer2)); 445 EXPECT_STREQ(GetUserDataString(v2.data.submit.userData).c_str(), userData.c_str()); 446} 447 448/** 449 * @tc.number Telephony_CdmaSmsGtest_CdmaSmsBearerData_0001 450 * @tc.name Test CdmaSmsBearerData 451 * @tc.desc Function test 452 */ 453HWTEST_F(CdmaSmsGtest, CdmaSmsBearerData_0001, Function | MediumTest | Level1) 454{ 455 // gsm 7bit 456 CheckDeliverUserData("00031040900112488ea794e074d69e1b7392c270326cde9e98", "Test standard SMS"); 457 // ascii 7bit 458 CheckDeliverUserData("0003100160010610262d5ab500", "bjjj"); 459 // ia5 460 CheckDeliverUserData("00031002100109184539b4d052ebb3d0", "SMS Rulz"); 461 // unicode 462 CheckDeliverUserData("000310021001062012716B2C380801000A0140", "\\u4e2d\\u6587"); 463 464 // gsm 7bit 465 CheckSubmitUserData("00032006400112488ea794e074d69e1b7392c270326cde9e98", "Test standard SMS"); 466 // ascii 7bit 467 CheckSubmitUserData("0003200640010610262d5ab500", "bjjj"); 468 // ia5 469 CheckSubmitUserData("00032006400109184539b4d052ebb3d0", "SMS Rulz"); 470 // unicode 471 CheckSubmitUserData("000320064001062012716B2C380801000A0140", "\\u4e2d\\u6587"); 472} 473 474/** 475 * @tc.number Telephony_CdmaSmsGtest_CdmaSmsBearerData_0002 476 * @tc.name Test CdmaSmsBearerData 477 * @tc.desc Function test 478 */ 479HWTEST_F(CdmaSmsGtest, CdmaSmsBearerData_0002, Function | MediumTest | Level1) 480{ 481 std::string dataStr = "0003200010010410168d20020105030608120111015905019206069706180000000801c00901800a01e00b" 482 "01030c01c00d01070e05039acc13880f018011020566"; 483 std::stringstream ss; 484 ss.clear(); 485 ss << static_cast<uint8_t>(CdmaSmsParameterRecord::BEARER_DATA); 486 ss << static_cast<uint8_t>(dataStr.size() / HEX_CHAR_LEN); 487 ss << StringUtils::HexToString(dataStr); 488 489 CdmaTeleserviceMsg v; 490 memset_s(&v, sizeof(CdmaTeleserviceMsg), 0x00, sizeof(CdmaTeleserviceMsg)); 491 SmsReadBuffer rBuffer(ss.str()); 492 rBuffer.SetIndex(VALUE_INDEX); 493 auto message = std::make_shared<CdmaSmsBearerData>(v, rBuffer); 494 rBuffer.SetIndex(0); 495 EXPECT_TRUE(message->Decode(rBuffer)); 496 EXPECT_EQ(v.type, TeleserviceMsgType::SUBMIT); 497 EXPECT_EQ(v.data.submit.msgId.msgId, 1); 498 EXPECT_EQ(v.data.submit.priority, SmsPriorityIndicator::EMERGENCY); 499 EXPECT_EQ(v.data.submit.privacy, SmsPrivacyIndicator::CONFIDENTIAL); 500 EXPECT_EQ(v.data.submit.callbackNumber.addrLen, 7); 501 char number[] = "3598271"; 502 for (uint8_t i = 0; i < sizeof(number); i++) { 503 EXPECT_EQ(v.data.submit.callbackNumber.szData[i], number[i]); 504 } 505 EXPECT_EQ(v.data.submit.depositId, 1382); 506 EXPECT_EQ(v.data.submit.language, SmsLanguageType::HEBREW); 507 EXPECT_EQ(v.data.submit.alertPriority, SmsAlertPriority::HIGH); 508 EXPECT_EQ(v.data.submit.deferValPeriod.time.absTime.year, 97); 509 EXPECT_EQ(v.data.submit.deferValPeriod.time.absTime.month, 6); 510 EXPECT_EQ(v.data.submit.deferValPeriod.time.absTime.day, 18); 511} 512#endif // TEL_TEST_UNSUPPORT 513} // namespace Telephony 514} // namespace OHOS