1 /* 2 * Copyright (C) 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 #include "gtest/gtest.h" 17 #define private public 18 #define protected public 19 #include "cb_start_ability.h" 20 #include "delivery_short_message_callback_stub.h" 21 #include "gsm_sms_param_codec.h" 22 #include "gsm_pdu_hex_value.h" 23 #include "gsm_sms_common_utils.h" 24 #include "gsm_sms_message.h" 25 #include "gsm_sms_receive_handler.h" 26 #include "gsm_sms_sender.h" 27 #include "gsm_sms_tpdu_decode.h" 28 #include "gsm_user_data_decode.h" 29 #include "gsm_user_data_encode.h" 30 #include "short_message.h" 31 32 namespace OHOS { 33 namespace Telephony { 34 using namespace testing::ext; 35 36 static constexpr uint8_t MAX_GSM_7BIT_DATA_LEN = 160; 37 constexpr uint32_t EVENT_RELEASE_DATA_SHARE_HELPER = 10000; 38 class SmsGsmTest : public testing::Test { 39 public: SetUpTestCase()40 static void SetUpTestCase() 41 {} TearDownTestCase()42 static void TearDownTestCase() 43 { 44 DelayedSingleton<SmsPersistHelper>::GetInstance()->RemoveEvent(EVENT_RELEASE_DATA_SHARE_HELPER); 45 } SetUp()46 void SetUp() 47 {} TearDown()48 void TearDown() 49 {} 50 }; 51 52 /** 53 * @tc.number Telephony_SmsMmsGtest_SmsGsmTest_001 54 * @tc.name SmsGsmTest_001 55 * @tc.desc Function test 56 */ 57 HWTEST_F(SmsGsmTest, SmsGsmTest_001, Function | MediumTest | Level1) 58 { 59 std::shared_ptr<GsmSmsParamCodec> codec = std::make_shared<GsmSmsParamCodec>(); 60 61 string strBuff; 62 int32_t setType = 0; 63 int32_t indType = 0; 64 strBuff += HEX_VALUE_0D; 65 SmsReadBuffer smsReadBuff(strBuff); 66 EXPECT_FALSE(codec->CheckVoicemail(smsReadBuff, &setType, &indType)); 67 } 68 69 /** 70 * @tc.number Telephony_SmsMmsGtest_SmsGsmTest_002 71 * @tc.name SmsGsmTest_002 72 * @tc.desc Function test 73 */ 74 HWTEST_F(SmsGsmTest, SmsGsmTest_002, Function | MediumTest | Level1) 75 { 76 std::shared_ptr<GsmSmsParamCodec> codec = std::make_shared<GsmSmsParamCodec>(); 77 78 string strBuff; 79 int32_t setType = 0; 80 int32_t indType = 0; 81 strBuff += HEX_VALUE_04; 82 SmsReadBuffer smsReadBuff(strBuff); 83 EXPECT_FALSE(codec->CheckVoicemail(smsReadBuff, &setType, &indType)); 84 } 85 86 /** 87 * @tc.number Telephony_SmsMmsGtest_SmsGsmTest_003 88 * @tc.name SmsGsmTest_003 89 * @tc.desc Function test 90 */ 91 HWTEST_F(SmsGsmTest, SmsGsmTest_003, Function | MediumTest | Level1) 92 { 93 std::shared_ptr<GsmSmsParamCodec> codec = std::make_shared<GsmSmsParamCodec>(); 94 95 string strBuff; 96 int32_t setType = 0; 97 int32_t indType = 0; 98 strBuff += HEX_VALUE_04; 99 strBuff += HEX_VALUE_04; 100 SmsReadBuffer smsReadBuff(strBuff); 101 EXPECT_FALSE(codec->CheckVoicemail(smsReadBuff, &setType, &indType)); 102 } 103 104 /** 105 * @tc.number Telephony_SmsMmsGtest_SmsGsmTest_004 106 * @tc.name SmsGsmTest_004 107 * @tc.desc Function test 108 */ 109 HWTEST_F(SmsGsmTest, SmsGsmTest_004, Function | MediumTest | Level1) 110 { 111 std::shared_ptr<GsmSmsParamCodec> codec = std::make_shared<GsmSmsParamCodec>(); 112 113 string strBuff; 114 int32_t setType = 0; 115 int32_t indType = 0; 116 strBuff += HEX_VALUE_04; 117 strBuff += HEX_VALUE_D0; 118 SmsReadBuffer smsReadBuff(strBuff); 119 EXPECT_FALSE(codec->CheckVoicemail(smsReadBuff, &setType, &indType)); 120 } 121 122 123 /** 124 * @tc.number Telephony_SmsMmsGtest_SmsGsmTest_005 125 * @tc.name SmsGsmTest_005 126 * @tc.desc Function test 127 */ 128 HWTEST_F(SmsGsmTest, SmsGsmTest_005, Function | MediumTest | Level1) 129 { 130 std::shared_ptr<GsmSmsParamCodec> codec = std::make_shared<GsmSmsParamCodec>(); 131 string strBuff; 132 int32_t setType = 0; 133 int32_t indType = 0; 134 strBuff += HEX_VALUE_04; 135 strBuff += HEX_VALUE_D0; 136 strBuff += HEX_VALUE_D0; 137 SmsReadBuffer smsReadBuff(strBuff); 138 EXPECT_FALSE(codec->CheckVoicemail(smsReadBuff, &setType, &indType)); 139 } 140 141 /** 142 * @tc.number Telephony_SmsMmsGtest_SmsGsmTest_006 143 * @tc.name SmsGsmTest_006 144 * @tc.desc Function test 145 */ 146 HWTEST_F(SmsGsmTest, SmsGsmTest_006, Function | MediumTest | Level1) 147 { 148 std::shared_ptr<GsmSmsParamCodec> codec = std::make_shared<GsmSmsParamCodec>(); 149 150 string strBuff; 151 int32_t setType = 0; 152 int32_t indType = 0; 153 strBuff += HEX_VALUE_04; 154 strBuff += HEX_VALUE_D0; 155 strBuff += HEX_VALUE_11; 156 SmsReadBuffer smsReadBuff(strBuff); 157 EXPECT_FALSE(codec->CheckVoicemail(smsReadBuff, &setType, &indType)); 158 } 159 160 /** 161 * @tc.number Telephony_SmsMmsGtest_SmsGsmTest_007 162 * @tc.name SmsGsmTest_007 163 * @tc.desc Function test 164 */ 165 HWTEST_F(SmsGsmTest, SmsGsmTest_007, Function | MediumTest | Level1) 166 { 167 std::shared_ptr<GsmSmsParamCodec> codec = std::make_shared<GsmSmsParamCodec>(); 168 169 string strBuff; 170 int32_t setType = 0; 171 int32_t indType = 0; 172 strBuff += HEX_VALUE_04; 173 strBuff += HEX_VALUE_D0; 174 strBuff += HEX_VALUE_10; 175 strBuff += HEX_VALUE_10; 176 SmsReadBuffer smsReadBuff(strBuff); 177 EXPECT_TRUE(codec->CheckVoicemail(smsReadBuff, &setType, &indType)); 178 } 179 180 /** 181 * @tc.number Telephony_SmsMmsGtest_SmsGsmTest_008 182 * @tc.name SmsGsmTest_008 183 * @tc.desc Function test 184 */ 185 HWTEST_F(SmsGsmTest, SmsGsmTest_008, Function | MediumTest | Level1) 186 { 187 std::shared_ptr<GsmSmsCommonUtils> utils = std::make_shared<GsmSmsCommonUtils>(); 188 SmsWriteBuffer buffer; 189 EXPECT_FALSE(utils->Pack7bitChar(buffer, nullptr, 0, 0)); 190 } 191 192 /** 193 * @tc.number Telephony_SmsMmsGtest_SmsGsmTest_009 194 * @tc.name SmsGsmTest_009 195 * @tc.desc Function test 196 */ 197 HWTEST_F(SmsGsmTest, SmsGsmTest_009, Function | MediumTest | Level1) 198 { 199 std::shared_ptr<GsmSmsCommonUtils> utils = std::make_shared<GsmSmsCommonUtils>(); 200 std::vector<uint8_t> vectData; 201 uint8_t fillBits = 1; 202 203 SmsWriteBuffer buffer; 204 EXPECT_FALSE(utils->Pack7bitChar(buffer, static_cast<const uint8_t*>(&vectData[0]), 0, fillBits)); 205 } 206 207 /** 208 * @tc.number Telephony_SmsMmsGtest_SmsGsmTest_010 209 * @tc.name SmsGsmTest_010 210 * @tc.desc Function test 211 */ 212 HWTEST_F(SmsGsmTest, SmsGsmTest_010, Function | MediumTest | Level1) 213 { 214 std::shared_ptr<GsmSmsCommonUtils> utils = std::make_shared<GsmSmsCommonUtils>(); 215 std::vector<uint8_t> vectData; 216 uint8_t fillBits = 1; 217 vectData.push_back(1); 218 vectData.push_back(2); 219 vectData.push_back(3); 220 vectData.push_back(4); 221 SmsWriteBuffer buffer; 222 EXPECT_TRUE(utils->Pack7bitChar(buffer, static_cast<const uint8_t*>(&vectData[0]), vectData.size(), fillBits)); 223 224 vectData.clear(); 225 vectData.assign(MAX_GSM_7BIT_DATA_LEN + 1, 1); // first branch 226 EXPECT_FALSE(utils->Pack7bitChar(buffer, static_cast<const uint8_t*>(&vectData[0]), vectData.size(), fillBits)); 227 vectData.clear(); 228 EXPECT_TRUE(utils->Pack7bitChar(buffer, static_cast<const uint8_t*>(&vectData[0]), vectData.size(), fillBits)); 229 } 230 231 /** 232 * @tc.number Telephony_SmsMmsGtest_SmsGsmTest_011 233 * @tc.name SmsGsmTest_011 234 * @tc.desc Function test 235 */ 236 HWTEST_F(SmsGsmTest, SmsGsmTest_011, Function | MediumTest | Level1) 237 { 238 std::shared_ptr<GsmSmsCommonUtils> utils = std::make_shared<GsmSmsCommonUtils>(); 239 std::string strBuffer; 240 uint8_t fillBits = 0; 241 uint8_t dstIdx = 0; 242 243 SmsReadBuffer buffer(strBuffer); 244 EXPECT_FALSE(utils->Unpack7bitChar(buffer, strBuffer.size(), fillBits, nullptr, 0, dstIdx)); 245 fillBits = 8; 246 EXPECT_FALSE(utils->Unpack7bitChar(buffer, strBuffer.size(), fillBits, nullptr, 0, dstIdx)); 247 } 248 249 /** 250 * @tc.number Telephony_SmsMmsGtest_SmsGsmTest_012 251 * @tc.name SmsGsmTest_012 252 * @tc.desc Function test 253 */ 254 HWTEST_F(SmsGsmTest, SmsGsmTest_012, Function | MediumTest | Level1) 255 { 256 std::shared_ptr<GsmSmsCommonUtils> utils = std::make_shared<GsmSmsCommonUtils>(); 257 std::string strBuffer; 258 std::vector<uint8_t> vectData; 259 uint8_t fillBits = 1; 260 uint8_t dstIdx = 0; 261 262 SmsReadBuffer buffer(strBuffer); 263 EXPECT_FALSE(utils->Unpack7bitChar(buffer, strBuffer.size(), fillBits, 264 static_cast<uint8_t*>(&vectData[0]), vectData.size(), dstIdx)); 265 } 266 267 /** 268 * @tc.number Telephony_SmsMmsGtest_SmsGsmTest_013 269 * @tc.name SmsGsmTest_013 270 * @tc.desc Function test Unpack7bitCharForMiddlePart 271 */ 272 HWTEST_F(SmsGsmTest, SmsGsmTest_013, Function | MediumTest | Level1) 273 { 274 std::shared_ptr<GsmSmsCommonUtils> utils = std::make_shared<GsmSmsCommonUtils>(); 275 std::string dataStr("1141515"); 276 std::vector<uint8_t> vectData; 277 278 const uint8_t *buffer = reinterpret_cast<const uint8_t *>(dataStr.c_str()); 279 EXPECT_FALSE(utils->Unpack7bitCharForMiddlePart(nullptr, 0, static_cast<uint8_t*>(&vectData[0]))); 280 EXPECT_FALSE(utils->Unpack7bitCharForMiddlePart(buffer, dataStr.size(), nullptr)); 281 EXPECT_FALSE(utils->Unpack7bitCharForMiddlePart(buffer, 0, static_cast<uint8_t*>(&vectData[0]))); 282 } 283 284 /** 285 * @tc.number Telephony_SmsMmsGtest_GsmSmsTpduCodec_001 286 * @tc.name GsmSmsTpduCodec_001 287 * @tc.desc Function test decode 288 */ 289 HWTEST_F(SmsGsmTest, GsmSmsTpduCodec_001, Function | MediumTest | Level1) 290 { 291 auto tpduCodec = std::make_shared<GsmSmsTpduCodec>(); 292 GsmSmsTpduDecode decode(tpduCodec->uDataCodec_, tpduCodec->paramCodec_, tpduCodec); 293 SmsReadBuffer buffer(""); 294 SmsSubmit submit; 295 EXPECT_FALSE(decode.DecodeSubmitPartData(buffer, &submit)); 296 SmsReadBuffer buffer0(std::string(2, 0x80)); 297 EXPECT_FALSE(decode.DecodeSubmitPartData(buffer0, &submit)); 298 SmsDeliver deliver; 299 SmsReadBuffer buffer1(std::string(2, 0x80)); 300 decode.DecodeDeliver(buffer1, &deliver); 301 EXPECT_TRUE(deliver.bReplyPath); 302 SmsStatusReport statusRep; 303 SmsReadBuffer buffer2("0000000"); 304 EXPECT_FALSE(decode.DecodeStatusReportPartData(buffer, &statusRep)); 305 EXPECT_FALSE(decode.DecodeStatusReportPartData(buffer2, &statusRep)); 306 SmsReadBuffer buffer3("00000000"); 307 EXPECT_TRUE(decode.DecodeStatusReportPartData(buffer3, &statusRep)); 308 } 309 310 /** 311 * @tc.number Telephony_SmsMmsGtest_GsmUserDataDecode_001 312 * @tc.name GsmUserDataDecode_001 313 * @tc.desc Function test decode 314 */ 315 HWTEST_F(SmsGsmTest, GsmUserDataDecode_001, Function | MediumTest | Level1) 316 { 317 GsmUserDataDecode decode(nullptr); 318 GsmUserDataDecode decode2(std::make_shared<GsmUserDataPdu>()); 319 SmsReadBuffer buffer(""); 320 SmsUDPackage userData; 321 SmsTpud tpud; 322 uint8_t udl = 1; 323 uint8_t fillBits = 0; 324 EXPECT_FALSE(decode.DecodeGsmHeadPdu(buffer, false, nullptr, &tpud, udl, fillBits)); 325 EXPECT_FALSE(decode.DecodeGsmHeadPdu(buffer, false, &userData, &tpud, udl, fillBits)); 326 SmsReadBuffer buffer1(std::string(2, 161)); 327 EXPECT_FALSE(decode.DecodeGsmHeadPdu(buffer1, false, &userData, &tpud, udl, fillBits)); 328 329 EXPECT_FALSE(decode.DecodeGsmHeadPduPartData(buffer, false, &userData, udl, fillBits)); 330 EXPECT_FALSE(decode2.DecodeGsmHeadPduPartData(buffer, true, &userData, udl, fillBits)); 331 332 EXPECT_FALSE(decode.DecodeGsmBodyPdu(buffer, false, nullptr, &tpud, udl, fillBits)); 333 334 EXPECT_FALSE(decode2.Decode8bitPduPartData(buffer, true, &userData, &tpud, udl, fillBits)); 335 336 EXPECT_FALSE(decode.Decode8bitPdu(buffer, false, nullptr, &tpud)); 337 EXPECT_FALSE(decode.Decode8bitPdu(buffer, false, &userData, &tpud)); 338 SmsReadBuffer buffer2(std::string(2, 141)); 339 EXPECT_FALSE(decode.Decode8bitPdu(buffer2, false, &userData, &tpud)); 340 341 EXPECT_FALSE(decode.DecodeUcs2Pdu(buffer, false, nullptr, &tpud)); 342 SmsReadBuffer buffer3(std::string(2, 141)); 343 EXPECT_FALSE(decode.DecodeUcs2Pdu(buffer3, false, &userData, &tpud)); 344 345 EXPECT_FALSE(decode.DecodeUcs2PduPartData(buffer, false, &userData, udl, fillBits)); 346 EXPECT_FALSE(decode2.DecodeUcs2PduPartData(buffer, true, &userData, udl, fillBits)); 347 userData.length = 0; 348 EXPECT_TRUE(decode2.DecodeUcs2PduPartData(buffer, false, &userData, udl, fillBits)); 349 EXPECT_TRUE(decode2.Decode8bitPduPartData(buffer, false, &userData, &tpud, udl, fillBits)); 350 } 351 352 /** 353 * @tc.number Telephony_SmsMmsGtest_GsmUserDataEncode_001 354 * @tc.name GsmUserDataEncode_001 355 * @tc.desc Function test encode 356 */ 357 HWTEST_F(SmsGsmTest, GsmUserDataEncode_001, Function | MediumTest | Level1) 358 { 359 GsmUserDataEncode encode(nullptr); 360 SmsWriteBuffer buffer; 361 SmsUDPackage userData; 362 uint8_t fillBits = 0; 363 EXPECT_FALSE(encode.EncodeGsmHeadPdu(buffer, &userData, fillBits)); 364 EXPECT_FALSE(encode.EncodeGsmHeadPdu(buffer, nullptr, fillBits)); 365 EXPECT_FALSE(encode.EncodeGsmBodyPdu(buffer, nullptr, fillBits)); 366 std::string destAddr = ""; 367 EXPECT_FALSE(encode.Encode8bitHeadPdu(buffer, &userData, destAddr)); 368 EXPECT_FALSE(encode.Encode8bitHeadPdu(buffer, nullptr, destAddr)); 369 buffer.data_ = nullptr; 370 EXPECT_FALSE(encode.Encode8bitBodyPdu(buffer, &userData)); 371 EXPECT_FALSE(encode.Encode8bitBodyPdu(buffer, nullptr)); 372 EXPECT_FALSE(encode.EncodeUcs2HeadPdu(buffer, &userData)); 373 EXPECT_FALSE(encode.EncodeUcs2HeadPdu(buffer, nullptr)); 374 EXPECT_FALSE(encode.EncodeUcs2BodyPdu(buffer, nullptr)); 375 } 376 377 /** 378 * @tc.number Telephony_SmsMmsGtest_GsmSmsSender_001 379 * @tc.name GsmSmsSender_001 380 * @tc.desc Function test GsmSmsSender 381 */ 382 HWTEST_F(SmsGsmTest, GsmSmsSender_001, Function | MediumTest | Level1) 383 { __anon0b72b4ff0102(std::shared_ptr<SmsSendIndexer> indexer) 384 std::function<void(std::shared_ptr<SmsSendIndexer>)> fun = [](std::shared_ptr<SmsSendIndexer> indexer) {}; 385 std::shared_ptr<GsmSmsSender> smsSender = std::make_shared<GsmSmsSender>(DEFAULT_SIM_SLOT_ID, fun); 386 std::shared_ptr<SmsMessageInfo> statusInfo = std::make_shared<SmsMessageInfo>(); 387 AppExecFwk::InnerEvent::Pointer event = AppExecFwk::InnerEvent::Get(0, statusInfo); 388 smsSender->StatusReportAnalysis(event); 389 std::vector<uint8_t> pdu = { 8, 145, 104, 49, 8, 32, 1, 5, 240, 68, 13, 145, 104, 145, 39, 32, 49, 100, 240, 390 0, 0, 82, 64, 80, 34, 145, 17, 35, 160, 5, 0, 3, 1, 2, 1, 98, 177, 88, 44, 22, 139, 197, 98, 177, 88, 44, 391 22, 139, 197, 98, 177, 152, 44, 54, 171, 209, 108, 55, 25, 142, 54, 163, 213, 108, 180, 90, 12, 55, 187, 392 213, 104, 177, 88, 44, 22, 139, 197, 98, 177, 88, 44, 22, 139, 197, 98, 177, 88, 76, 22, 155, 213, 104, 393 182, 155, 12, 71, 155, 209, 106, 54, 90, 45, 134, 155, 221, 106, 180, 88, 44, 22, 139, 197, 98, 177, 88, 394 44, 22, 139, 197, 98, 177, 88, 44, 38, 139, 205, 106, 52, 219, 77, 134, 163, 205, 104, 53, 27, 173, 22, 395 195, 205, 110, 53, 90, 44, 22, 139, 197, 98, 177, 88, 44, 22, 139, 197, 98, 177, 88, 44, 22, 147, 197, 102, 396 53, 154, 237, 38, 195, 209, 102 }; 397 statusInfo->pdu = pdu; 398 event = AppExecFwk::InnerEvent::Get(0, statusInfo); 399 std::shared_ptr<SmsSendIndexer> indexer = std::make_shared<SmsSendIndexer>("des", "src", "text", nullptr, nullptr); 400 auto message = GsmSmsMessage::CreateMessage(StringUtils::StringToHex(pdu)); 401 ASSERT_NE(message, nullptr); 402 indexer->SetMsgRefId(message->GetMsgRef() + 1); 403 smsSender->reportList_.push_back(indexer); 404 smsSender->StatusReportAnalysis(event); 405 indexer->SetMsgRefId(message->GetMsgRef()); 406 sptr<DeliveryShortMessageCallbackStub> callback = new DeliveryShortMessageCallbackStub(); 407 indexer->SetDeliveryCallback(callback); 408 smsSender->StatusReportAnalysis(event); 409 smsSender->StatusReportSetImsSms(event); 410 std::shared_ptr<RadioResponseInfo> imsResponseInfo = std::make_shared<RadioResponseInfo>(); 411 imsResponseInfo->error = ErrType::NONE; 412 event = AppExecFwk::InnerEvent::Get(0, imsResponseInfo); 413 smsSender->StatusReportSetImsSms(event); 414 imsResponseInfo->error = ErrType::ERR_GENERIC_FAILURE; 415 event = AppExecFwk::InnerEvent::Get(0, imsResponseInfo); 416 smsSender->imsSmsCfg_ = GsmSmsSender::IMS_SMS_ENABLE; 417 smsSender->StatusReportSetImsSms(event); 418 EXPECT_EQ(smsSender->imsSmsCfg_, GsmSmsSender::IMS_SMS_DISABLE); 419 std::shared_ptr<int32_t> imsSmsInfo = std::make_shared<int32_t>(GsmSmsSender::IMS_SMS_ENABLE); 420 event = AppExecFwk::InnerEvent::Get(0, imsSmsInfo); 421 smsSender->StatusReportGetImsSms(event); 422 EXPECT_EQ(smsSender->imsSmsCfg_, GsmSmsSender::IMS_SMS_ENABLE); 423 } 424 425 /** 426 * @tc.number Telephony_SmsMmsGtest_GsmSmsSender_002 427 * @tc.name GsmSmsSender_002 428 * @tc.desc Function test GsmSmsSender 429 */ 430 HWTEST_F(SmsGsmTest, GsmSmsSender_002, Function | MediumTest | Level1) 431 { __anon0b72b4ff0202(std::shared_ptr<SmsSendIndexer> indexer) 432 std::function<void(std::shared_ptr<SmsSendIndexer>)> fun = [](std::shared_ptr<SmsSendIndexer> indexer) {}; 433 std::shared_ptr<GsmSmsSender> smsSender = std::make_shared<GsmSmsSender>(DEFAULT_SIM_SLOT_ID, fun); 434 GsmSimMessageParam smsData; 435 std::shared_ptr<SmsSendIndexer> indexer = std::make_shared<SmsSendIndexer>("des", "src", "text", nullptr, nullptr); 436 indexer->hasMore_ = true; 437 smsSender->SendSatelliteSms(indexer, smsData); 438 indexer->csResendCount_ = 1; 439 smsSender->SendSatelliteSms(indexer, smsData); 440 smsSender->ResendDataDelivery(indexer); 441 EXPECT_NE(indexer, nullptr); 442 } 443 444 /** 445 * @tc.number Telephony_SmsMmsGtest_ShortMessage_001 446 * @tc.name ShortMessage_001 447 * @tc.desc Function test ShortMessage 448 */ 449 HWTEST_F(SmsGsmTest, ShortMessage_001, Function | MediumTest | Level1) 450 { 451 auto shortMessage = std::make_shared<ShortMessage>(); 452 Parcel parcel; 453 EXPECT_TRUE(shortMessage->Marshalling(parcel)); 454 EXPECT_TRUE(shortMessage->ReadFromParcel(parcel)); 455 } 456 } 457 }