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 "gsm_cb_codec.h" 20#include "gsm_cb_gsm_codec.h" 21#include "gsm_cb_umts_codec.h" 22#include "gtest/gtest.h" 23#include "radio_event.h" 24#include "sms_service.h" 25 26namespace OHOS { 27namespace Telephony { 28using namespace testing::ext; 29 30namespace { 31const int32_t INVALID_SLOTID = 2; 32const uint16_t PWS_FIRST_ID = 0x1100; 33const std::string ETWS_PDU = "000B1100011165FA7D4E9BD564"; 34const std::string CMAS_PDU = "000D11120111E376784E9BDD60"; 35const std::string CBS_PDU = "00031112011163F19C36BBC11A"; 36const std::string CMAS_JP_PDU = 37 "01A41F51101102EA3030A830EA30A230E130FC30EB914D4FE130C630B930C8000D000A3053308C306F8A669A137528306E30E130C330BB30FC" 38 "30B8306730593002000D000AFF080032003000310033002F00310031002F003252EA300037002000310035003A00340034FF09000D000AFF08" 39 "30A830EA30A25E02FF090000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" 40 "0022"; 41} // namespace 42 43class BranchCbTest : public testing::Test { 44public: 45 static void SetUpTestCase(); 46 static void TearDownTestCase(); 47 void SetUp(); 48 void TearDown(); 49}; 50void BranchCbTest::SetUpTestCase() {} 51 52void BranchCbTest::TearDownTestCase() {} 53 54void BranchCbTest::SetUp() {} 55 56void BranchCbTest::TearDown() {} 57 58/** 59 * @tc.number Telephony_SmsMmsGtest_GsmCbCodec_0001 60 * @tc.name Test GsmCbCodec 61 * @tc.desc Function test 62 */ 63HWTEST_F(BranchCbTest, GsmCbCodec_0001, Function | MediumTest | Level1) 64{ 65 std::vector<unsigned char> pdu; 66 unsigned char data = 1; 67 pdu.push_back(data); 68 auto cbCodec = std::make_shared<GsmCbCodec>(); 69 cbCodec->PduAnalysis(pdu); 70 int8_t format = 1; 71 EXPECT_TRUE(cbCodec->GetFormat(format)); 72 EXPECT_TRUE(cbCodec->GetPriority(format)); 73 EXPECT_NE(cbCodec->GsmCbCodec::ToString(), ""); 74 uint8_t gs = 1; 75 EXPECT_TRUE(cbCodec->GetGeoScope(gs)); 76 uint16_t serial = 1; 77 EXPECT_TRUE(cbCodec->GetSerialNum(serial)); 78 bool isUserAlert = false; 79 EXPECT_TRUE(cbCodec->IsEtwsEmergencyUserAlert(isUserAlert)); 80 EXPECT_TRUE(cbCodec->IsEtwsPopupAlert(isUserAlert)); 81 EXPECT_TRUE(cbCodec->GetServiceCategory(serial)); 82 uint8_t cmasType; 83 EXPECT_TRUE(cbCodec->GetCmasResponseType(cmasType)); 84 uint8_t cmasClass; 85 EXPECT_TRUE(cbCodec->GetCmasMessageClass(cmasClass)); 86 EXPECT_TRUE(cbCodec->GetWarningType(serial)); 87 EXPECT_TRUE(cbCodec->GetMsgType(gs)); 88 EXPECT_TRUE(cbCodec->GetLangType(gs)); 89 EXPECT_TRUE(cbCodec->GetDcs(gs)); 90 int64_t recvTime = 0; 91 EXPECT_TRUE(cbCodec->GetReceiveTime(recvTime)); 92} 93 94/** 95 * @tc.number Telephony_SmsMmsGtest_GsmCbCodec_0002 96 * @tc.name Test GsmCbCodec 97 * @tc.desc Function test 98 */ 99HWTEST_F(BranchCbTest, GsmCbCodec_0002, Function | MediumTest | Level1) 100{ 101 std::vector<unsigned char> pdu; 102 unsigned char data = 1; 103 pdu.push_back(data); 104 auto cbCodec = std::make_shared<GsmCbCodec>(); 105 cbCodec->PduAnalysis(pdu); 106 uint8_t cmasType; 107 cbCodec->GetCmasCategory(cmasType); 108 std::string raw = "qwe"; 109 std::string message = "asd"; 110 cbCodec->ConvertToUTF8(raw, message); 111 cbCodec->cbHeader_ = std::make_shared<GsmCbCodec::GsmCbMessageHeader>(); 112 cbCodec->cbHeader_->dcs.codingScheme = DATA_CODING_7BIT; 113 cbCodec->ConvertToUTF8(raw, message); 114 cbCodec->cbHeader_->dcs.codingScheme = DATA_CODING_UCS2; 115 cbCodec->ConvertToUTF8(raw, message); 116 cbCodec->cbHeader_->dcs.codingScheme = DATA_CODING_AUTO; 117 cbCodec->ConvertToUTF8(raw, message); 118 cbCodec->cbHeader_->bEtwsMessage = true; 119 cbCodec->cbHeader_->cbEtwsType = GsmCbCodec::ETWS_PRIMARY; 120 cbCodec->ConvertToUTF8(raw, message); 121 cbCodec->GetCbMessageRaw(); 122 int8_t format = 1; 123 EXPECT_TRUE(cbCodec->GetPriority(format)); 124 cbCodec->cbHeader_->msgId = PWS_FIRST_ID; 125 EXPECT_TRUE(cbCodec->GetPriority(format)); 126 EXPECT_FALSE(cbCodec->IsSinglePageMsg()); 127 std::string pdus = "123"; 128 EXPECT_TRUE(cbCodec->CreateCbMessage(pdu) == nullptr); 129 EXPECT_FALSE(cbCodec->CreateCbMessage(pdus)); 130 EXPECT_TRUE(cbCodec->GetCbHeader() != nullptr); 131} 132 133/** 134 * @tc.number Telephony_SmsMmsGtest_GsmCbCodec_0003 135 * @tc.name Test GsmCbCodec 136 * @tc.desc Function test 137 */ 138HWTEST_F(BranchCbTest, GsmCbCodec_0003, Function | MediumTest | Level1) 139{ 140 auto smsCbMessage = std::make_shared<GsmCbCodec>(); 141 uint8_t severity = 1; 142 smsCbMessage->cbHeader_ = std::make_shared<GsmCbCodec::GsmCbMessageHeader>(); 143 smsCbMessage->cbHeader_->msgId = GsmCbCodec::CmasMsgType::EXTREME_OBSERVED; 144 EXPECT_TRUE(smsCbMessage->GetCmasSeverity(severity)); 145 EXPECT_TRUE(smsCbMessage->GetCmasUrgency(severity)); 146 smsCbMessage->cbHeader_->msgId = GsmCbCodec::CmasMsgType::EXTREME_OBSERVED_SPANISH; 147 EXPECT_TRUE(smsCbMessage->GetCmasSeverity(severity)); 148 EXPECT_TRUE(smsCbMessage->GetCmasUrgency(severity)); 149 smsCbMessage->cbHeader_->msgId = GsmCbCodec::CmasMsgType::EXTREME_LIKELY; 150 EXPECT_TRUE(smsCbMessage->GetCmasSeverity(severity)); 151 EXPECT_TRUE(smsCbMessage->GetCmasUrgency(severity)); 152 smsCbMessage->cbHeader_->msgId = GsmCbCodec::CmasMsgType::EXTREME_LIKELY_SPANISH; 153 EXPECT_TRUE(smsCbMessage->GetCmasSeverity(severity)); 154 EXPECT_TRUE(smsCbMessage->GetCmasUrgency(severity)); 155 smsCbMessage->cbHeader_->msgId = GsmCbCodec::CmasMsgType::EXTREME_OBSERVED; 156 EXPECT_TRUE(smsCbMessage->GetCmasSeverity(severity)); 157 EXPECT_TRUE(smsCbMessage->GetCmasUrgency(severity)); 158 smsCbMessage->cbHeader_->msgId = GsmCbCodec::CmasMsgType::SEVERE_OBSERVED_SPANISH; 159 EXPECT_TRUE(smsCbMessage->GetCmasSeverity(severity)); 160 EXPECT_TRUE(smsCbMessage->GetCmasUrgency(severity)); 161 smsCbMessage->cbHeader_->msgId = GsmCbCodec::CmasMsgType::SEVERE_LIKELY; 162 EXPECT_TRUE(smsCbMessage->GetCmasSeverity(severity)); 163 EXPECT_TRUE(smsCbMessage->GetCmasUrgency(severity)); 164 smsCbMessage->cbHeader_->msgId = GsmCbCodec::CmasMsgType::SEVERE_LIKELY_SPANISH; 165 EXPECT_TRUE(smsCbMessage->GetCmasSeverity(severity)); 166 EXPECT_TRUE(smsCbMessage->GetCmasUrgency(severity)); 167 smsCbMessage->cbHeader_->msgId = GsmCbCodec::CmasMsgType::ALERT_OBSERVED_DEFUALT; 168 EXPECT_TRUE(smsCbMessage->GetCmasSeverity(severity)); 169 EXPECT_TRUE(smsCbMessage->GetCmasUrgency(severity)); 170 smsCbMessage->cbHeader_->msgId = GsmCbCodec::CmasMsgType::ALERT_OBSERVED_SPANISH; 171 EXPECT_TRUE(smsCbMessage->GetCmasSeverity(severity)); 172 EXPECT_TRUE(smsCbMessage->GetCmasUrgency(severity)); 173 smsCbMessage->cbHeader_->msgId = GsmCbCodec::CmasMsgType::ALERT_LIKELY; 174 EXPECT_TRUE(smsCbMessage->GetCmasSeverity(severity)); 175 EXPECT_TRUE(smsCbMessage->GetCmasUrgency(severity)); 176 smsCbMessage->cbHeader_->msgId = GsmCbCodec::CmasMsgType::ALERT_LIKELY_SPANISH; 177 EXPECT_TRUE(smsCbMessage->GetCmasSeverity(severity)); 178 EXPECT_TRUE(smsCbMessage->GetCmasUrgency(severity)); 179 smsCbMessage->cbHeader_->msgId = GsmCbCodec::CmasMsgType::EXPECTED_OBSERVED; 180 EXPECT_TRUE(smsCbMessage->GetCmasSeverity(severity)); 181 EXPECT_TRUE(smsCbMessage->GetCmasUrgency(severity)); 182 smsCbMessage->cbHeader_->msgId = GsmCbCodec::CmasMsgType::EXPECTED_OBSERVED_SPANISH; 183 EXPECT_TRUE(smsCbMessage->GetCmasSeverity(severity)); 184 EXPECT_TRUE(smsCbMessage->GetCmasUrgency(severity)); 185 smsCbMessage->cbHeader_->msgId = GsmCbCodec::CmasMsgType::EXPECTED_LIKELY; 186 EXPECT_TRUE(smsCbMessage->GetCmasSeverity(severity)); 187 EXPECT_TRUE(smsCbMessage->GetCmasUrgency(severity)); 188} 189 190/** 191 * @tc.number Telephony_SmsMmsGtest_GsmCbCodec_0004 192 * @tc.name Test GsmCbCodec 193 * @tc.desc Function test 194 */ 195HWTEST_F(BranchCbTest, GsmCbCodec_0004, Function | MediumTest | Level1) 196{ 197 auto smsCbMessage = std::make_shared<GsmCbCodec>(); 198 uint8_t severity = 1; 199 smsCbMessage->cbHeader_ = std::make_shared<GsmCbCodec::GsmCbMessageHeader>(); 200 smsCbMessage->cbHeader_->msgId = GsmCbCodec::CmasMsgType::EXPECTED_LIKELY_SPANISH; 201 EXPECT_TRUE(smsCbMessage->GetCmasSeverity(severity)); 202 EXPECT_TRUE(smsCbMessage->GetCmasUrgency(severity)); 203 EXPECT_TRUE(smsCbMessage->GetCmasCertainty(severity)); 204 smsCbMessage->cbHeader_->msgId = GsmCbCodec::CmasMsgType::OPERATOR_ALERT_SPANISH; 205 EXPECT_TRUE(smsCbMessage->GetCmasSeverity(severity)); 206 EXPECT_TRUE(smsCbMessage->GetCmasUrgency(severity)); 207 EXPECT_TRUE(smsCbMessage->GetCmasCertainty(severity)); 208 smsCbMessage->cbHeader_->msgId = GsmCbCodec::CmasMsgType::EXTREME_OBSERVED; 209 EXPECT_TRUE(smsCbMessage->GetCmasCertainty(severity)); 210 smsCbMessage->cbHeader_->msgId = GsmCbCodec::CmasMsgType::EXTREME_OBSERVED_SPANISH; 211 EXPECT_TRUE(smsCbMessage->GetCmasCertainty(severity)); 212 smsCbMessage->cbHeader_->msgId = GsmCbCodec::CmasMsgType::SEVERE_OBSERVED; 213 EXPECT_TRUE(smsCbMessage->GetCmasCertainty(severity)); 214 smsCbMessage->cbHeader_->msgId = GsmCbCodec::CmasMsgType::SEVERE_OBSERVED_SPANISH; 215 EXPECT_TRUE(smsCbMessage->GetCmasCertainty(severity)); 216 smsCbMessage->cbHeader_->msgId = GsmCbCodec::CmasMsgType::ALERT_OBSERVED_DEFUALT; 217 EXPECT_TRUE(smsCbMessage->GetCmasCertainty(severity)); 218 smsCbMessage->cbHeader_->msgId = GsmCbCodec::CmasMsgType::ALERT_OBSERVED_SPANISH; 219 EXPECT_TRUE(smsCbMessage->GetCmasCertainty(severity)); 220 smsCbMessage->cbHeader_->msgId = GsmCbCodec::CmasMsgType::EXPECTED_OBSERVED; 221 EXPECT_TRUE(smsCbMessage->GetCmasCertainty(severity)); 222 smsCbMessage->cbHeader_->msgId = GsmCbCodec::CmasMsgType::EXPECTED_OBSERVED_SPANISH; 223 EXPECT_TRUE(smsCbMessage->GetCmasCertainty(severity)); 224 smsCbMessage->cbHeader_->msgId = GsmCbCodec::CmasMsgType::EXTREME_LIKELY; 225 EXPECT_TRUE(smsCbMessage->GetCmasCertainty(severity)); 226 smsCbMessage->cbHeader_->msgId = GsmCbCodec::CmasMsgType::EXTREME_LIKELY_SPANISH; 227 EXPECT_TRUE(smsCbMessage->GetCmasCertainty(severity)); 228 smsCbMessage->cbHeader_->msgId = GsmCbCodec::CmasMsgType::SEVERE_LIKELY; 229 EXPECT_TRUE(smsCbMessage->GetCmasCertainty(severity)); 230 smsCbMessage->cbHeader_->msgId = GsmCbCodec::CmasMsgType::SEVERE_LIKELY_SPANISH; 231 EXPECT_TRUE(smsCbMessage->GetCmasCertainty(severity)); 232 smsCbMessage->cbHeader_->msgId = GsmCbCodec::CmasMsgType::ALERT_LIKELY; 233 EXPECT_TRUE(smsCbMessage->GetCmasCertainty(severity)); 234 smsCbMessage->cbHeader_->msgId = GsmCbCodec::CmasMsgType::ALERT_LIKELY_SPANISH; 235 EXPECT_TRUE(smsCbMessage->GetCmasCertainty(severity)); 236 smsCbMessage->cbHeader_->msgId = GsmCbCodec::CmasMsgType::EXPECTED_LIKELY; 237 EXPECT_TRUE(smsCbMessage->GetCmasCertainty(severity)); 238} 239 240/** 241 * @tc.number Telephony_SmsMmsGtest_GsmCbCodec_0005 242 * @tc.name Test GsmCbCodec 243 * @tc.desc Function test 244 */ 245HWTEST_F(BranchCbTest, GsmCbCodec_0005, Function | MediumTest | Level1) 246{ 247 auto cbMsg = std::make_shared<GsmCbCodec>(); 248 auto gsmMsg = std::make_shared<GsmCbGsmCodec>(cbMsg->cbHeader_, cbMsg->cbPduBuffer_, cbMsg); 249 auto umtsMsg = std::make_shared<GsmCbUmtsCodec>(cbMsg->cbHeader_, cbMsg->cbPduBuffer_, cbMsg); 250 ASSERT_NE(cbMsg, nullptr); 251 ASSERT_NE(gsmMsg, nullptr); 252 ASSERT_NE(umtsMsg, nullptr); 253 EXPECT_FALSE(gsmMsg->Decode2gHeader()); 254 unsigned char data = 1; 255 std::vector<unsigned char> pdu; 256 pdu.push_back(data); 257 cbMsg->PduAnalysis(pdu); 258 gsmMsg->Decode2gCbMsg(); 259 umtsMsg->Decode3gCbMsg(); 260 cbMsg->cbHeader_ = std::make_shared<GsmCbCodec::GsmCbMessageHeader>(); 261 cbMsg->cbHeader_->dcs.codingScheme = DataCodingScheme::DATA_CODING_7BIT; 262 gsmMsg->Decode2gCbMsg(); 263 umtsMsg->Decode3gCbMsg(); 264 cbMsg->cbHeader_->dcs.codingScheme = DataCodingScheme::DATA_CODING_8BIT; 265 gsmMsg->Decode2gCbMsg(); 266 umtsMsg->Decode3gCbMsg(); 267 cbMsg->cbHeader_->dcs.codingScheme = DataCodingScheme::DATA_CODING_UCS2; 268 gsmMsg->Decode2gCbMsg(); 269 umtsMsg->Decode3gCbMsg(); 270 cbMsg->cbHeader_->dcs.codingScheme = DataCodingScheme::DATA_CODING_ASCII7BIT; 271 gsmMsg->Decode2gCbMsg(); 272 umtsMsg->Decode3gCbMsg(); 273 cbMsg->cbHeader_->totalPages = 1; 274 umtsMsg->Decode3g7Bit(); 275 umtsMsg->Decode3gUCS2(); 276 EXPECT_EQ(cbMsg->CMASClass(GsmCbCodec::PRESIDENTIAL), GsmCbCodec::GSMCbMsgSubType::CMAS_PRESIDENTIAL); 277 EXPECT_EQ(cbMsg->CMASClass(GsmCbCodec::PRESIDENTIAL_SPANISH), GsmCbCodec::GSMCbMsgSubType::CMAS_PRESIDENTIAL); 278 EXPECT_EQ(cbMsg->CMASClass(GsmCbCodec::EXTREME_OBSERVED), GsmCbCodec::GSMCbMsgSubType::CMAS_EXTREME); 279 EXPECT_EQ(cbMsg->CMASClass(GsmCbCodec::EXTREME_OBSERVED_SPANISH), GsmCbCodec::GSMCbMsgSubType::CMAS_EXTREME); 280 EXPECT_EQ(cbMsg->CMASClass(GsmCbCodec::EXTREME_LIKELY), GsmCbCodec::GSMCbMsgSubType::CMAS_EXTREME); 281 EXPECT_EQ(cbMsg->CMASClass(GsmCbCodec::EXTREME_LIKELY_SPANISH), GsmCbCodec::GSMCbMsgSubType::CMAS_EXTREME); 282 EXPECT_EQ(cbMsg->CMASClass(GsmCbCodec::SEVERE_OBSERVED), GsmCbCodec::GSMCbMsgSubType::CMAS_SEVERE); 283 EXPECT_EQ(cbMsg->CMASClass(GsmCbCodec::SEVERE_OBSERVED_SPANISH), GsmCbCodec::GSMCbMsgSubType::CMAS_SEVERE); 284 EXPECT_EQ(cbMsg->CMASClass(GsmCbCodec::SEVERE_LIKELY), GsmCbCodec::GSMCbMsgSubType::CMAS_SEVERE); 285 EXPECT_EQ(cbMsg->CMASClass(GsmCbCodec::SEVERE_LIKELY_SPANISH), GsmCbCodec::GSMCbMsgSubType::CMAS_SEVERE); 286 EXPECT_EQ(cbMsg->CMASClass(GsmCbCodec::ALERT_OBSERVED_DEFUALT), GsmCbCodec::GSMCbMsgSubType::CMAS_SEVERE); 287 EXPECT_EQ(cbMsg->CMASClass(GsmCbCodec::ALERT_OBSERVED_SPANISH), GsmCbCodec::GSMCbMsgSubType::CMAS_SEVERE); 288} 289 290/** 291 * @tc.number Telephony_SmsMmsGtest_GsmCbCodec_0006 292 * @tc.name Test GsmCbCodec 293 * @tc.desc Function test 294 */ 295HWTEST_F(BranchCbTest, GsmCbCodec_0006, Function | MediumTest | Level1) 296{ 297 auto smsCbMessage = std::make_shared<GsmCbCodec>(); 298 EXPECT_EQ(smsCbMessage->CMASClass(GsmCbCodec::ALERT_LIKELY), GsmCbCodec::GSMCbMsgSubType::CMAS_SEVERE); 299 EXPECT_EQ(smsCbMessage->CMASClass(GsmCbCodec::ALERT_LIKELY_SPANISH), GsmCbCodec::GSMCbMsgSubType::CMAS_SEVERE); 300 EXPECT_EQ(smsCbMessage->CMASClass(GsmCbCodec::EXPECTED_OBSERVED), GsmCbCodec::GSMCbMsgSubType::CMAS_SEVERE); 301 EXPECT_EQ(smsCbMessage->CMASClass(GsmCbCodec::EXPECTED_OBSERVED_SPANISH), GsmCbCodec::GSMCbMsgSubType::CMAS_SEVERE); 302 EXPECT_EQ(smsCbMessage->CMASClass(GsmCbCodec::EXPECTED_LIKELY_SPANISH), GsmCbCodec::GSMCbMsgSubType::CMAS_SEVERE); 303 EXPECT_EQ(smsCbMessage->CMASClass(GsmCbCodec::EXPECTED_LIKELY_SPANISH), GsmCbCodec::GSMCbMsgSubType::CMAS_SEVERE); 304 EXPECT_EQ(smsCbMessage->CMASClass(GsmCbCodec::AMBER_ALERT), GsmCbCodec::GSMCbMsgSubType::CMAS_AMBER); 305 EXPECT_EQ(smsCbMessage->CMASClass(GsmCbCodec::AMBER_ALERT_SPANISH), GsmCbCodec::GSMCbMsgSubType::CMAS_AMBER); 306 EXPECT_EQ(smsCbMessage->CMASClass(GsmCbCodec::MONTHLY_ALERT), GsmCbCodec::GSMCbMsgSubType::CMAS_TEST); 307 EXPECT_EQ(smsCbMessage->CMASClass(GsmCbCodec::MONTHLY_ALERT_SPANISH), GsmCbCodec::GSMCbMsgSubType::CMAS_TEST); 308 EXPECT_EQ(smsCbMessage->CMASClass(GsmCbCodec::EXERCISE_ALERT), GsmCbCodec::GSMCbMsgSubType::CMAS_EXERCISE); 309 EXPECT_EQ(smsCbMessage->CMASClass(GsmCbCodec::EXERCISE_ALERT_SPANISH), GsmCbCodec::GSMCbMsgSubType::CMAS_EXERCISE); 310 EXPECT_EQ(smsCbMessage->CMASClass(GsmCbCodec::OPERATOR_ALERT), GsmCbCodec::GSMCbMsgSubType::CMAS_OPERATOR_DEFINED); 311 EXPECT_EQ(smsCbMessage->CMASClass(GsmCbCodec::OPERATOR_ALERT_SPANISH), 312 GsmCbCodec::GSMCbMsgSubType::CMAS_OPERATOR_DEFINED); 313} 314 315/** 316 * @tc.number Telephony_SmsMmsGtest_GsmCbGsmCodec_0001 317 * @tc.name Test GsmCbGsmCodec 318 * @tc.desc Function test 319 */ 320HWTEST_F(BranchCbTest, GsmCbGsmCodec_0001, Function | MediumTest | Level1) 321{ 322 auto cbMsg = std::make_shared<GsmCbCodec>(); 323 ASSERT_NE(cbMsg, nullptr); 324 cbMsg->CreateCbMessage(ETWS_PDU); 325 std::vector<unsigned char> pdu = StringUtils::HexToByteVector(ETWS_PDU); 326 cbMsg->cbPduBuffer_ = std::make_shared<GsmCbPduDecodeBuffer>(pdu.size()); 327 cbMsg->cbHeader_ = std::make_shared<GsmCbCodec::GsmCbMessageHeader>(); 328 for (size_t index = 0; index < pdu.size() && index < cbMsg->cbPduBuffer_->GetSize(); index++) { 329 cbMsg->cbPduBuffer_->pduBuffer_[index] = static_cast<char>(pdu[index]); 330 } 331 auto gsmMsg = std::make_shared<GsmCbGsmCodec>(cbMsg->cbHeader_, cbMsg->cbPduBuffer_, cbMsg); 332 auto umtsMsg = std::make_shared<GsmCbUmtsCodec>(cbMsg->cbHeader_, cbMsg->cbPduBuffer_, cbMsg); 333 gsmMsg->cbPduBuffer_ = cbMsg->cbPduBuffer_; 334 umtsMsg->cbPduBuffer_ = cbMsg->cbPduBuffer_; 335 gsmMsg->Decode2gHeader(); 336 gsmMsg->Decode2gHeaderEtws(); 337 EXPECT_TRUE(gsmMsg->Decode2gCbMsg()); 338 339 gsmMsg->Decode2gHeaderCommonCb(); 340 uint16_t dataLen = gsmMsg->cbPduBuffer_->GetSize() - gsmMsg->cbPduBuffer_->GetCurPosition(); 341 gsmMsg->Decode2gCbMsg7bit(dataLen); 342 EXPECT_TRUE(gsmMsg->DecodeEtwsMsg()); 343 344 umtsMsg->Decode3gHeader(); 345 umtsMsg->Decode3gHeaderPartData(0); 346 umtsMsg->Decode3gCbMsg(); 347 umtsMsg->Decode3g7Bit(); 348 EXPECT_FALSE(umtsMsg->Decode3gUCS2()); 349 cbMsg->cbHeader_ = std::make_shared<GsmCbCodec::GsmCbMessageHeader>(); 350 cbMsg->cbHeader_->dcs.codingScheme = DataCodingScheme::DATA_CODING_7BIT; 351 gsmMsg->Decode2gCbMsg(); 352 EXPECT_FALSE(umtsMsg->Decode3gCbMsg()); 353 354 cbMsg->cbHeader_->dcs.codingScheme = DataCodingScheme::DATA_CODING_8BIT; 355 gsmMsg->Decode2gCbMsg(); 356 EXPECT_FALSE(umtsMsg->Decode3gCbMsg()); 357 cbMsg->cbHeader_->dcs.codingScheme = DataCodingScheme::DATA_CODING_UCS2; 358 gsmMsg->Decode2gCbMsg(); 359 EXPECT_FALSE(umtsMsg->Decode3gCbMsg()); 360 361 cbMsg->cbHeader_->dcs.codingScheme = DataCodingScheme::DATA_CODING_ASCII7BIT; 362 gsmMsg->Decode2gCbMsg(); 363 EXPECT_FALSE(umtsMsg->Decode3gCbMsg()); 364 cbMsg->cbHeader_->totalPages = 1; 365 umtsMsg->Decode3g7Bit(); 366 EXPECT_FALSE(umtsMsg->Decode3gUCS2()); 367} 368 369/** 370 * @tc.number Telephony_SmsMmsGtest_GsmCbGsmCodec_0002 371 * @tc.name Test GsmCbGsmCodec 372 * @tc.desc Function test 373 */ 374HWTEST_F(BranchCbTest, GsmCbGsmCodec_0002, Function | MediumTest | Level1) 375{ 376 auto cbMsg = std::make_shared<GsmCbCodec>(); 377 ASSERT_NE(cbMsg, nullptr); 378 cbMsg->CreateCbMessage(CMAS_PDU); 379 std::vector<unsigned char> pdu = StringUtils::HexToByteVector(CMAS_PDU); 380 cbMsg->cbPduBuffer_ = std::make_shared<GsmCbPduDecodeBuffer>(pdu.size()); 381 cbMsg->cbHeader_ = std::make_shared<GsmCbCodec::GsmCbMessageHeader>(); 382 for (size_t index = 0; index < pdu.size() && index < cbMsg->cbPduBuffer_->GetSize(); index++) { 383 cbMsg->cbPduBuffer_->pduBuffer_[index] = static_cast<char>(pdu[index]); 384 } 385 auto gsmMsg = std::make_shared<GsmCbGsmCodec>(cbMsg->cbHeader_, cbMsg->cbPduBuffer_, cbMsg); 386 auto umtsMsg = std::make_shared<GsmCbUmtsCodec>(cbMsg->cbHeader_, cbMsg->cbPduBuffer_, cbMsg); 387 gsmMsg->cbPduBuffer_ = cbMsg->cbPduBuffer_; 388 umtsMsg->cbPduBuffer_ = cbMsg->cbPduBuffer_; 389 gsmMsg->Decode2gHeader(); 390 gsmMsg->Decode2gHeaderEtws(); 391 EXPECT_TRUE(gsmMsg->Decode2gCbMsg()); 392 393 gsmMsg->Decode2gHeaderCommonCb(); 394 uint16_t dataLen = gsmMsg->cbPduBuffer_->GetSize() - gsmMsg->cbPduBuffer_->GetCurPosition(); 395 gsmMsg->Decode2gCbMsg7bit(dataLen); 396 EXPECT_TRUE(gsmMsg->DecodeEtwsMsg()); 397 398 umtsMsg->Decode3gHeader(); 399 umtsMsg->Decode3gHeaderPartData(0); 400 umtsMsg->Decode3gCbMsg(); 401 umtsMsg->Decode3g7Bit(); 402 EXPECT_FALSE(umtsMsg->Decode3gUCS2()); 403 cbMsg->cbHeader_ = std::make_shared<GsmCbCodec::GsmCbMessageHeader>(); 404 cbMsg->cbHeader_->dcs.codingScheme = DataCodingScheme::DATA_CODING_7BIT; 405 gsmMsg->Decode2gCbMsg(); 406 EXPECT_FALSE(umtsMsg->Decode3gCbMsg()); 407 408 cbMsg->cbHeader_->dcs.codingScheme = DataCodingScheme::DATA_CODING_8BIT; 409 gsmMsg->Decode2gCbMsg(); 410 EXPECT_FALSE(umtsMsg->Decode3gCbMsg()); 411 cbMsg->cbHeader_->dcs.codingScheme = DataCodingScheme::DATA_CODING_UCS2; 412 gsmMsg->Decode2gCbMsg(); 413 EXPECT_FALSE(umtsMsg->Decode3gCbMsg()); 414 415 cbMsg->cbHeader_->dcs.codingScheme = DataCodingScheme::DATA_CODING_ASCII7BIT; 416 gsmMsg->Decode2gCbMsg(); 417 EXPECT_FALSE(umtsMsg->Decode3gCbMsg()); 418 cbMsg->cbHeader_->totalPages = 1; 419 umtsMsg->Decode3g7Bit(); 420 EXPECT_FALSE(umtsMsg->Decode3gUCS2()); 421} 422 423/** 424 * @tc.number Telephony_SmsMmsGtest_GsmCbGsmCodec_0003 425 * @tc.name Test GsmCbGsmCodec 426 * @tc.desc Function test 427 */ 428HWTEST_F(BranchCbTest, GsmCbGsmCodec_0003, Function | MediumTest | Level1) 429{ 430 auto cbMsg = std::make_shared<GsmCbCodec>(); 431 ASSERT_NE(cbMsg, nullptr); 432 cbMsg->CreateCbMessage(CBS_PDU); 433 std::vector<unsigned char> pdu = StringUtils::HexToByteVector(CBS_PDU); 434 cbMsg->cbPduBuffer_ = std::make_shared<GsmCbPduDecodeBuffer>(pdu.size()); 435 cbMsg->cbHeader_ = std::make_shared<GsmCbCodec::GsmCbMessageHeader>(); 436 for (size_t index = 0; index < pdu.size() && index < cbMsg->cbPduBuffer_->GetSize(); index++) { 437 cbMsg->cbPduBuffer_->pduBuffer_[index] = static_cast<char>(pdu[index]); 438 } 439 auto gsmMsg = std::make_shared<GsmCbGsmCodec>(cbMsg->cbHeader_, cbMsg->cbPduBuffer_, cbMsg); 440 auto umtsMsg = std::make_shared<GsmCbUmtsCodec>(cbMsg->cbHeader_, cbMsg->cbPduBuffer_, cbMsg); 441 gsmMsg->cbPduBuffer_ = cbMsg->cbPduBuffer_; 442 umtsMsg->cbPduBuffer_ = cbMsg->cbPduBuffer_; 443 gsmMsg->Decode2gHeader(); 444 gsmMsg->Decode2gHeaderEtws(); 445 EXPECT_TRUE(gsmMsg->Decode2gCbMsg()); 446 447 gsmMsg->Decode2gHeaderCommonCb(); 448 uint16_t dataLen = gsmMsg->cbPduBuffer_->GetSize() - gsmMsg->cbPduBuffer_->GetCurPosition(); 449 gsmMsg->Decode2gCbMsg7bit(dataLen); 450 EXPECT_TRUE(gsmMsg->DecodeEtwsMsg()); 451 452 umtsMsg->Decode3gHeader(); 453 umtsMsg->Decode3gHeaderPartData(0); 454 umtsMsg->Decode3gCbMsg(); 455 umtsMsg->Decode3g7Bit(); 456 EXPECT_FALSE(umtsMsg->Decode3gUCS2()); 457 cbMsg->cbHeader_ = std::make_shared<GsmCbCodec::GsmCbMessageHeader>(); 458 cbMsg->cbHeader_->dcs.codingScheme = DataCodingScheme::DATA_CODING_7BIT; 459 gsmMsg->Decode2gCbMsg(); 460 EXPECT_FALSE(umtsMsg->Decode3gCbMsg()); 461 462 cbMsg->cbHeader_->dcs.codingScheme = DataCodingScheme::DATA_CODING_8BIT; 463 gsmMsg->Decode2gCbMsg(); 464 EXPECT_FALSE(umtsMsg->Decode3gCbMsg()); 465 cbMsg->cbHeader_->dcs.codingScheme = DataCodingScheme::DATA_CODING_UCS2; 466 gsmMsg->Decode2gCbMsg(); 467 EXPECT_FALSE(umtsMsg->Decode3gCbMsg()); 468 469 cbMsg->cbHeader_->dcs.codingScheme = DataCodingScheme::DATA_CODING_ASCII7BIT; 470 gsmMsg->Decode2gCbMsg(); 471 EXPECT_FALSE(umtsMsg->Decode3gCbMsg()); 472 cbMsg->cbHeader_->totalPages = 1; 473 umtsMsg->Decode3g7Bit(); 474 EXPECT_FALSE(umtsMsg->Decode3gUCS2()); 475} 476 477/** 478 * @tc.number Telephony_SmsMmsGtest_GsmCbGsmCodec_0004 479 * @tc.name Test GsmCbGsmCodec 480 * @tc.desc Function test 481 */ 482HWTEST_F(BranchCbTest, GsmCbGsmCodec_0004, Function | MediumTest | Level1) 483{ 484 auto cbMsg = std::make_shared<GsmCbCodec>(); 485 ASSERT_NE(cbMsg, nullptr); 486 cbMsg->CreateCbMessage(CMAS_JP_PDU); 487 std::vector<unsigned char> pdu = StringUtils::HexToByteVector(CMAS_JP_PDU); 488 cbMsg->cbPduBuffer_ = std::make_shared<GsmCbPduDecodeBuffer>(pdu.size()); 489 cbMsg->cbHeader_ = std::make_shared<GsmCbCodec::GsmCbMessageHeader>(); 490 for (size_t index = 0; index < pdu.size() && index < cbMsg->cbPduBuffer_->GetSize(); index++) { 491 cbMsg->cbPduBuffer_->pduBuffer_[index] = static_cast<char>(pdu[index]); 492 } 493 auto gsmMsg = std::make_shared<GsmCbGsmCodec>(cbMsg->cbHeader_, cbMsg->cbPduBuffer_, cbMsg); 494 auto umtsMsg = std::make_shared<GsmCbUmtsCodec>(cbMsg->cbHeader_, cbMsg->cbPduBuffer_, cbMsg); 495 gsmMsg->cbPduBuffer_ = cbMsg->cbPduBuffer_; 496 umtsMsg->cbPduBuffer_ = cbMsg->cbPduBuffer_; 497 gsmMsg->Decode2gHeader(); 498 gsmMsg->Decode2gHeaderEtws(); 499 EXPECT_TRUE(gsmMsg->Decode2gCbMsg()); 500 501 gsmMsg->Decode2gHeaderCommonCb(); 502 uint16_t dataLen = gsmMsg->cbPduBuffer_->GetSize() - gsmMsg->cbPduBuffer_->GetCurPosition(); 503 gsmMsg->Decode2gCbMsg7bit(dataLen); 504 EXPECT_FALSE(gsmMsg->DecodeEtwsMsg()); 505 506 umtsMsg->Decode3gHeader(); 507 umtsMsg->Decode3gHeaderPartData(0); 508 umtsMsg->Decode3gCbMsg(); 509 umtsMsg->Decode3g7Bit(); 510 EXPECT_TRUE(umtsMsg->Decode3gUCS2()); 511 cbMsg->cbHeader_ = std::make_shared<GsmCbCodec::GsmCbMessageHeader>(); 512 cbMsg->cbHeader_->dcs.codingScheme = DataCodingScheme::DATA_CODING_7BIT; 513 gsmMsg->Decode2gCbMsg(); 514 EXPECT_TRUE(umtsMsg->Decode3gCbMsg()); 515 516 cbMsg->cbHeader_->dcs.codingScheme = DataCodingScheme::DATA_CODING_8BIT; 517 gsmMsg->Decode2gCbMsg(); 518 EXPECT_TRUE(umtsMsg->Decode3gCbMsg()); 519 cbMsg->cbHeader_->dcs.codingScheme = DataCodingScheme::DATA_CODING_UCS2; 520 gsmMsg->Decode2gCbMsg(); 521 EXPECT_TRUE(umtsMsg->Decode3gCbMsg()); 522 523 cbMsg->cbHeader_->dcs.codingScheme = DataCodingScheme::DATA_CODING_ASCII7BIT; 524 gsmMsg->Decode2gCbMsg(); 525 EXPECT_TRUE(umtsMsg->Decode3gCbMsg()); 526 cbMsg->cbHeader_->totalPages = 1; 527 umtsMsg->Decode3g7Bit(); 528 EXPECT_TRUE(umtsMsg->Decode3gUCS2()); 529} 530 531/** 532 * @tc.number Telephony_SmsMmsGtest_GsmCbGsmCodec_0005 533 * @tc.name Test GsmCbGsmCodec 534 * @tc.desc Function test 535 */ 536HWTEST_F(BranchCbTest, GsmCbGsmCodec_0005, Function | MediumTest | Level1) 537{ 538 auto cbMsg = std::make_shared<GsmCbCodec>(); 539 ASSERT_NE(cbMsg, nullptr); 540 unsigned char data = 1; 541 std::vector<unsigned char> pdu; 542 pdu.push_back(data); 543 cbMsg->PduAnalysis(pdu); 544 auto gsmMsg = std::make_shared<GsmCbGsmCodec>(cbMsg->cbHeader_, cbMsg->cbPduBuffer_, cbMsg); 545 auto umtsMsg = std::make_shared<GsmCbUmtsCodec>(cbMsg->cbHeader_, cbMsg->cbPduBuffer_, cbMsg); 546 ASSERT_NE(gsmMsg, nullptr); 547 ASSERT_NE(umtsMsg, nullptr); 548 gsmMsg->Decode2gCbMsg(); 549 EXPECT_FALSE(umtsMsg->Decode3gCbMsg()); 550 cbMsg->cbHeader_ = std::make_shared<GsmCbCodec::GsmCbMessageHeader>(); 551 cbMsg->cbHeader_->dcs.codingScheme = DataCodingScheme::DATA_CODING_7BIT; 552 gsmMsg->Decode2gCbMsg(); 553 EXPECT_FALSE(umtsMsg->Decode3gCbMsg()); 554 cbMsg->cbHeader_->dcs.codingScheme = DataCodingScheme::DATA_CODING_8BIT; 555 gsmMsg->Decode2gCbMsg(); 556 EXPECT_FALSE(umtsMsg->Decode3gCbMsg()); 557 cbMsg->cbHeader_->dcs.codingScheme = DataCodingScheme::DATA_CODING_UCS2; 558 gsmMsg->Decode2gCbMsg(); 559 EXPECT_FALSE(umtsMsg->Decode3gCbMsg()); 560 cbMsg->cbHeader_->dcs.codingScheme = DataCodingScheme::DATA_CODING_ASCII7BIT; 561 gsmMsg->Decode2gCbMsg(); 562 umtsMsg->Decode3gCbMsg(); 563 cbMsg->cbHeader_->totalPages = 1; 564 umtsMsg->Decode3g7Bit(); 565 EXPECT_FALSE(umtsMsg->Decode3gUCS2()); 566} 567 568/** 569 * @tc.number Telephony_SmsMmsGtest_GsmSmsCbHandler_0001 570 * @tc.name Test GsmSmsCbHandler 571 * @tc.desc Function test 572 */ 573HWTEST_F(BranchCbTest, GsmSmsCbHandler_0001, Function | MediumTest | Level1) 574{ 575 auto gsmSmsCbHandler = std::make_shared<GsmSmsCbHandler>(INVALID_SLOTID); 576 auto cbMessage = std::make_shared<GsmCbCodec>(); 577 auto message = std::make_shared<CBConfigReportInfo>(); 578 AppExecFwk::InnerEvent::Pointer event = AppExecFwk::InnerEvent::Get(RadioEvent::RADIO_CELL_BROADCAST, 1); 579 gsmSmsCbHandler->ProcessEvent(event); 580 event = AppExecFwk::InnerEvent::Get(RadioEvent::RADIO_GET_STATUS, 1); 581 gsmSmsCbHandler->ProcessEvent(event); 582 gsmSmsCbHandler->HandleCbMessage(message); 583 EXPECT_EQ(gsmSmsCbHandler->CheckCbMessage(cbMessage), 0); 584 EXPECT_TRUE(gsmSmsCbHandler->FindCbMessage(cbMessage) == nullptr); 585 EXPECT_FALSE(gsmSmsCbHandler->AddCbMessageToList(cbMessage)); 586 EXPECT_FALSE(gsmSmsCbHandler->SendCbMessageBroadcast(cbMessage)); 587 cbMessage->cbHeader_ = std::make_shared<GsmCbCodec::GsmCbMessageHeader>(); 588 EXPECT_EQ(gsmSmsCbHandler->CheckCbMessage(cbMessage), 1); 589 cbMessage->cbHeader_->totalPages = 1; 590 EXPECT_EQ(gsmSmsCbHandler->CheckCbMessage(cbMessage), 0x01); 591 EXPECT_FALSE(gsmSmsCbHandler->AddCbMessageToList(cbMessage)); 592 CbInfo cbInfo; 593 gsmSmsCbHandler->cbMsgList_.push_back(cbInfo); 594 EXPECT_EQ(gsmSmsCbHandler->CheckCbMessage(cbMessage), 0x01); 595 cbMessage = nullptr; 596 message = nullptr; 597 event = nullptr; 598 gsmSmsCbHandler->ProcessEvent(event); 599 SmsCbData::CbData sendData; 600 gsmSmsCbHandler->GetCbData(cbMessage, sendData); 601 EventFwk::Want want; 602 gsmSmsCbHandler->PackageWantData(sendData, want); 603 gsmSmsCbHandler->HandleCbMessage(message); 604 EXPECT_FALSE(gsmSmsCbHandler->CheckCbActive(cbMessage)); 605 EXPECT_FALSE(gsmSmsCbHandler->AddCbMessageToList(cbMessage)); 606 EXPECT_FALSE(gsmSmsCbHandler->SendCbMessageBroadcast(cbMessage)); 607 EXPECT_TRUE(gsmSmsCbHandler->FindCbMessage(cbMessage) == nullptr); 608 EXPECT_EQ(gsmSmsCbHandler->CheckCbMessage(cbMessage), 0); 609} 610 611/** 612 * @tc.number Telephony_SmsMmsGtest_GsmCbCodecOperator_0001 613 * @tc.name Test GsmCbCodec::operator== 614 * @tc.desc Function test 615 */ 616HWTEST_F(BranchCbTest, GsmCbCodecOperator_0001, Function | MediumTest | Level1) 617{ 618 GsmCbCodec gsmCbCodec1; 619 GsmCbCodec gsmCbCodec2; 620 const std::vector<unsigned char> pdu = {0x01, 0x02}; 621 EXPECT_FALSE(gsmCbCodec1 == gsmCbCodec2); 622 623 bool ret = gsmCbCodec2.ParamsCheck(pdu); 624 EXPECT_FALSE(gsmCbCodec1 == gsmCbCodec2); 625 626 gsmCbCodec2.cbHeader_ = nullptr; 627 ret = gsmCbCodec1.ParamsCheck(pdu); 628 EXPECT_FALSE(gsmCbCodec1 == gsmCbCodec2); 629 630 ret = gsmCbCodec2.ParamsCheck(pdu); 631 EXPECT_TRUE(gsmCbCodec1 == gsmCbCodec2); 632} 633 634/** 635 * @tc.number Telephony_SmsMmsGtest_PickOneByte_0001 636 * @tc.name Test PickOneByte 637 * @tc.desc Function test 638 */ 639HWTEST_F(BranchCbTest, PickOneByte_0001, Function | MediumTest | Level1) 640{ 641 auto cbMsg = std::make_shared<GsmCbCodec>(); 642 ASSERT_NE(cbMsg, nullptr); 643 std::vector<unsigned char> pdu(GsmSmsCbHandler::MAX_CB_MSG_LEN + 1, 0x01); 644 bool ret = cbMsg->PduAnalysis(pdu); 645 EXPECT_FALSE(ret); 646} 647 648/** 649 * @tc.number Telephony_SmsMmsGtest_GetPduData_0001 650 * @tc.name Test GetPduData 651 * @tc.desc Function test 652 */ 653HWTEST_F(BranchCbTest, GetPduData_0001, Function | MediumTest | Level1) 654{ 655 auto cbMsg = std::make_shared<GsmCbCodec>(); 656 ASSERT_NE(cbMsg, nullptr); 657 std::vector<unsigned char> dataPdu = {0x01}; 658 cbMsg->GetPduData(dataPdu); 659 EXPECT_TRUE(cbMsg->cbPduBuffer_ == nullptr); 660} 661 662/** 663 * @tc.number Telephony_SmsMmsGtest_ConvertToUTF8_0001 664 * @tc.name Test ConvertToUTF8 665 * @tc.desc Function test 666 */ 667HWTEST_F(BranchCbTest, ConvertToUTF8_0001, Function | MediumTest | Level1) 668{ 669 auto cbMsg = std::make_shared<GsmCbCodec>(); 670 ASSERT_NE(cbMsg, nullptr); 671 const std::string raw = "raw"; 672 std::string message = "message"; 673 cbMsg->ConvertToUTF8(raw, message); 674 EXPECT_TRUE(cbMsg->cbHeader_ == nullptr); 675} 676 677/** 678 * @tc.number Telephony_SmsMmsGtest_DecodeGeneralDcs_0001 679 * @tc.name Test DecodeGeneralDcs 680 * @tc.desc Function test 681 */ 682HWTEST_F(BranchCbTest, DecodeGeneralDcs_0001, Function | MediumTest | Level1) 683{ 684 auto cbMsg = std::make_shared<GsmCbCodec>(); 685 ASSERT_NE(cbMsg, nullptr); 686 const uint8_t dcsData = 0x04; 687 GsmCbCodec::GsmCbMsgDcs dcs = {}; 688 uint8_t tmpScheme = (dcsData & 0x0C) >> 0x02; 689 EXPECT_EQ(tmpScheme, 0x01); 690 cbMsg->DecodeGeneralDcs(dcsData, dcs); 691 EXPECT_EQ(dcs.codingScheme, DATA_CODING_8BIT); 692} 693 694/** 695 * @tc.number Telephony_SmsMmsGtest_DecodeCbMsgDCS_0001 696 * @tc.name Test DecodeCbMsgDCS 697 * @tc.desc Function test 698 */ 699HWTEST_F(BranchCbTest, DecodeCbMsgDCS_0001, Function | MediumTest | Level1) 700{ 701 auto cbMsg = std::make_shared<GsmCbCodec>(); 702 ASSERT_NE(cbMsg, nullptr); 703 const uint8_t dcsData = 0xE0; 704 const unsigned short iosData = 1; 705 GsmCbCodec::GsmCbMsgDcs dcs = {}; 706 cbMsg->DecodeCbMsgDCS(dcsData, iosData, dcs); 707 EXPECT_EQ(dcs.codingGroup, GsmCbCodec::SMS_CBMSG_CODGRP_WAP); 708 709 const uint8_t dcsData1 = 0xF0; 710 cbMsg->DecodeCbMsgDCS(dcsData1, iosData, dcs); 711 EXPECT_EQ(dcs.codingGroup, GsmCbCodec::SMS_CBMSG_CODGRP_CLASS_CODING); 712 713 const uint8_t dcsData2 = 0xD0; 714 cbMsg->DecodeCbMsgDCS(dcsData2, iosData, dcs); 715 EXPECT_EQ(dcs.codingGroup, GsmCbCodec::SMS_CBMSG_CODGRP_GENERAL_DCS); 716} 717 718/** 719 * @tc.number Telephony_SmsMmsGtest_GsmCbCodecToString_0001 720 * @tc.name Test GsmCbCodecToString 721 * @tc.desc Function test 722 */ 723HWTEST_F(BranchCbTest, GsmCbCodecToString_0001, Function | MediumTest | Level1) 724{ 725 auto cbMsg = std::make_shared<GsmCbCodec>(); 726 ASSERT_NE(cbMsg, nullptr); 727 std::string ret = cbMsg->ToString(); 728 EXPECT_EQ(ret, "GsmCbCodec Header nullptr"); 729} 730 731/** 732 * @tc.number Telephony_SmsMmsGtest_GsmCbCodecGetBranch_0001 733 * @tc.name Test GsmCbCodecGetBranch 734 * @tc.desc Function test 735 */ 736HWTEST_F(BranchCbTest, GsmCbCodecGetBranch_0001, Function | MediumTest | Level1) 737{ 738 auto cbMsg = std::make_shared<GsmCbCodec>(); 739 ASSERT_NE(cbMsg, nullptr); 740 int8_t cbPriority = 1; 741 bool ret = cbMsg->GetPriority(cbPriority); 742 EXPECT_FALSE(ret); 743 744 uint8_t geoScope = 1; 745 ret = cbMsg->GetGeoScope(geoScope); 746 EXPECT_FALSE(ret); 747 748 uint16_t cbSerial = 1; 749 ret = cbMsg->GetSerialNum(cbSerial); 750 EXPECT_FALSE(ret); 751 752 uint16_t cbCategoty = 1; 753 ret = cbMsg->GetServiceCategory(cbCategoty); 754 EXPECT_FALSE(ret); 755 756 bool primary = true; 757 ret = cbMsg->IsEtwsPrimary(primary); 758 EXPECT_FALSE(ret); 759 760 ret = cbMsg->IsEtwsMessage(primary); 761 EXPECT_FALSE(ret); 762 763 ret = cbMsg->IsCmasMessage(primary); 764 EXPECT_FALSE(ret); 765} 766 767/** 768 * @tc.number Telephony_SmsMmsGtest_GetWarningType_0001 769 * @tc.name Test GetWarningType 770 * @tc.desc Function test 771 */ 772HWTEST_F(BranchCbTest, GetWarningType_0001, Function | MediumTest | Level1) 773{ 774 auto cbMsg = std::make_shared<GsmCbCodec>(); 775 ASSERT_NE(cbMsg, nullptr); 776 uint16_t type = 1; 777 bool ret = cbMsg->GetWarningType(type); 778 EXPECT_FALSE(ret); 779 780 std::vector<unsigned char> pdu = {0x01}; 781 ret = cbMsg->ParamsCheck(pdu); 782 ret = cbMsg->GetWarningType(type); 783 EXPECT_TRUE(ret); 784 785 type = -2; // OTHER_TYPE = -2 786 ret = cbMsg->GetWarningType(type); 787 EXPECT_TRUE(ret); 788} 789 790/** 791 * @tc.number Telephony_SmsMmsGtest_GsmCbCodecIsEtws_0001 792 * @tc.name Test GsmCbCodecIsEtws 793 * @tc.desc Function test 794 */ 795HWTEST_F(BranchCbTest, GsmCbCodecIsEtws_0001, Function | MediumTest | Level1) 796{ 797 auto cbMsg = std::make_shared<GsmCbCodec>(); 798 ASSERT_NE(cbMsg, nullptr); 799 bool alert = true; 800 bool ret = cbMsg->IsEtwsEmergencyUserAlert(alert); 801 EXPECT_FALSE(ret); 802 803 ret = cbMsg->IsEtwsPopupAlert(alert); 804 EXPECT_FALSE(ret); 805} 806 807/** 808 * @tc.number Telephony_SmsMmsGtest_GsmCbCodecGetCmas_0001 809 * @tc.name Test GsmCbCodecGetCmas 810 * @tc.desc Function test 811 */ 812HWTEST_F(BranchCbTest, GsmCbCodecGetCmas_0001, Function | MediumTest | Level1) 813{ 814 auto cbMsg = std::make_shared<GsmCbCodec>(); 815 ASSERT_NE(cbMsg, nullptr); 816 uint8_t severity = 1; 817 bool ret = cbMsg->GetCmasSeverity(severity); 818 EXPECT_FALSE(ret); 819 820 uint8_t urgency = 1; 821 ret = cbMsg->GetCmasUrgency(urgency); 822 EXPECT_FALSE(ret); 823 824 uint8_t certainty = 1; 825 ret = cbMsg->GetCmasCertainty(certainty); 826 EXPECT_FALSE(ret); 827 828 uint8_t cmasClass = 1; 829 ret = cbMsg->GetCmasMessageClass(cmasClass); 830 EXPECT_FALSE(ret); 831} 832 833/** 834 * @tc.number Telephony_SmsMmsGtest_GsmCbCodecGetBranch_0002 835 * @tc.name Test GsmCbCodecGetBranch 836 * @tc.desc Function test 837 */ 838HWTEST_F(BranchCbTest, GsmCbCodecGetBranch_0002, Function | MediumTest | Level1) 839{ 840 auto cbMsg = std::make_shared<GsmCbCodec>(); 841 ASSERT_NE(cbMsg, nullptr); 842 uint16_t msgId = 1; 843 bool ret = cbMsg->GetMessageId(msgId); 844 EXPECT_FALSE(ret); 845 846 uint8_t msgType = 1; 847 ret = cbMsg->GetMsgType(msgType); 848 EXPECT_FALSE(ret); 849 850 ret = cbMsg->GetLangType(msgType); 851 EXPECT_FALSE(ret); 852 853 ret = cbMsg->GetDcs(msgType); 854 EXPECT_FALSE(ret); 855 856 int64_t receiveTime = 1; 857 ret = cbMsg->GetReceiveTime(receiveTime); 858 EXPECT_FALSE(ret); 859} 860 861/** 862 * @tc.number Telephony_SmsMmsGtest_Decode2gHeaderBranch_0001 863 * @tc.name Test Decode2gHeaderBranch 864 * @tc.desc Function test 865 */ 866HWTEST_F(BranchCbTest, Decode2gHeaderBranch_0001, Function | MediumTest | Level1) 867{ 868 auto cbMsg = std::make_shared<GsmCbCodec>(); 869 ASSERT_NE(cbMsg, nullptr); 870 cbMsg->CreateCbMessage(ETWS_PDU); 871 std::vector<unsigned char> pdu = StringUtils::HexToByteVector(ETWS_PDU); 872 cbMsg->cbPduBuffer_ = std::make_shared<GsmCbPduDecodeBuffer>(pdu.size()); 873 cbMsg->cbHeader_ = std::make_shared<GsmCbCodec::GsmCbMessageHeader>(); 874 for (size_t index = 0; index < pdu.size() && index < cbMsg->cbPduBuffer_->GetSize(); index++) 875 { 876 cbMsg->cbPduBuffer_->pduBuffer_[index] = static_cast<char>(pdu[index]); 877 } 878 auto gsmMsg = std::make_shared<GsmCbGsmCodec>(cbMsg->cbHeader_, cbMsg->cbPduBuffer_, cbMsg); 879 gsmMsg->cbPduBuffer_ = cbMsg->cbPduBuffer_; 880 gsmMsg->cbPduBuffer_->curPosition_ = gsmMsg->cbPduBuffer_->totolLength_; 881 bool ret = gsmMsg->Decode2gHeader(); 882 EXPECT_FALSE(ret); 883 ret = gsmMsg->Decode2gHeaderEtws(); 884 EXPECT_FALSE(ret); 885 ret = gsmMsg->Decode2gHeaderCommonCb(); 886 EXPECT_FALSE(ret); 887 888 gsmMsg->cbPduBuffer_->curPosition_ = gsmMsg->cbPduBuffer_->totolLength_ - 1; 889 EXPECT_FALSE(gsmMsg->cbHeader_->msgId >= PWS_FIRST_ID); 890 ret = gsmMsg->Decode2gHeaderEtws(); 891 EXPECT_FALSE(ret); 892 gsmMsg->cbPduBuffer_->curPosition_ = gsmMsg->cbPduBuffer_->totolLength_ - 1; 893 ret = gsmMsg->Decode2gHeaderCommonCb(); 894 EXPECT_FALSE(ret); 895 896 gsmMsg->cbPduBuffer_->curPosition_ = gsmMsg->cbPduBuffer_->totolLength_ - 2; 897 ret = gsmMsg->Decode2gHeader(); 898 EXPECT_FALSE(ret); 899 gsmMsg->cbPduBuffer_->curPosition_ = gsmMsg->cbPduBuffer_->totolLength_ - 2; 900 ret = gsmMsg->Decode2gHeaderCommonCb(); 901 EXPECT_FALSE(ret); 902 903 gsmMsg->cbPduBuffer_->curPosition_ = gsmMsg->cbPduBuffer_->totolLength_ - 3; 904 ret = gsmMsg->Decode2gHeader(); 905 EXPECT_FALSE(ret); 906 gsmMsg->cbPduBuffer_->curPosition_ = gsmMsg->cbPduBuffer_->totolLength_ - 3; 907 ret = gsmMsg->Decode2gHeaderCommonCb(); 908 EXPECT_FALSE(ret); 909} 910 911/** 912 * @tc.number Telephony_SmsMmsGtest_Decode2gHeaderCommonCb_0001 913 * @tc.name Test Decode2gHeaderCommonCb 914 * @tc.desc Function test 915 */ 916HWTEST_F(BranchCbTest, Decode2gHeaderCommonCb_0001, Function | MediumTest | Level1) 917{ 918 auto cbMsg = std::make_shared<GsmCbCodec>(); 919 ASSERT_NE(cbMsg, nullptr); 920 cbMsg->CreateCbMessage(ETWS_PDU); 921 std::vector<unsigned char> pdu = StringUtils::HexToByteVector(ETWS_PDU); 922 cbMsg->cbPduBuffer_ = std::make_shared<GsmCbPduDecodeBuffer>(pdu.size()); 923 cbMsg->cbHeader_ = std::make_shared<GsmCbCodec::GsmCbMessageHeader>(); 924 for (size_t index = 0; index < pdu.size() && index < cbMsg->cbPduBuffer_->GetSize(); index++) 925 { 926 cbMsg->cbPduBuffer_->pduBuffer_[index] = static_cast<char>(pdu[index]); 927 } 928 auto gsmMsg = std::make_shared<GsmCbGsmCodec>(cbMsg->cbHeader_, cbMsg->cbPduBuffer_, cbMsg); 929 ASSERT_NE(gsmMsg, nullptr); 930 gsmMsg->cbPduBuffer_ = nullptr; 931 bool ret = gsmMsg->Decode2gHeaderCommonCb(); 932 EXPECT_FALSE(ret); 933 934 gsmMsg->cbPduBuffer_ = cbMsg->cbPduBuffer_; 935 gsmMsg->cbHeader_->totalPages = 18; // MAX_PAGE_NUM 936 ret = gsmMsg->Decode2gHeaderCommonCb(); 937 EXPECT_TRUE(ret); 938} 939 940/** 941 * @tc.number Telephony_SmsMmsGtest_Decode2gCbMsg_0001 942 * @tc.name Test Decode2gCbMsg 943 * @tc.desc Function test 944 */ 945HWTEST_F(BranchCbTest, Decode2gCbMsg_0001, Function | MediumTest | Level1) 946{ 947 auto cbMsg = std::make_shared<GsmCbCodec>(); 948 ASSERT_NE(cbMsg, nullptr); 949 cbMsg->CreateCbMessage(ETWS_PDU); 950 std::vector<unsigned char> pdu = StringUtils::HexToByteVector(ETWS_PDU); 951 cbMsg->cbPduBuffer_ = std::make_shared<GsmCbPduDecodeBuffer>(pdu.size()); 952 cbMsg->cbHeader_ = std::make_shared<GsmCbCodec::GsmCbMessageHeader>(); 953 for (size_t index = 0; index < pdu.size() && index < cbMsg->cbPduBuffer_->GetSize(); index++) 954 { 955 cbMsg->cbPduBuffer_->pduBuffer_[index] = static_cast<char>(pdu[index]); 956 } 957 auto gsmMsg = std::make_shared<GsmCbGsmCodec>(cbMsg->cbHeader_, cbMsg->cbPduBuffer_, cbMsg); 958 gsmMsg->cbHeader_->dcs.codingScheme = DATA_CODING_8BIT; 959 gsmMsg->cbPduBuffer_->curPosition_ = gsmMsg->cbPduBuffer_->totolLength_ - 1; 960 bool ret = gsmMsg->Decode2gCbMsg(); 961 EXPECT_FALSE(ret); 962 963 gsmMsg->cbPduBuffer_->curPosition_ = 0; 964 ret = gsmMsg->Decode2gCbMsg(); 965 EXPECT_TRUE(ret); 966 967 gsmMsg->cbHeader_->dcs.iso639Lang[0] = 0; 968 ret = gsmMsg->Decode2gCbMsg(); 969 EXPECT_TRUE(ret); 970 971 gsmMsg->cbHeader_->dcs.iso639Lang[0] = 1; 972 ret = gsmMsg->Decode2gCbMsg(); 973 EXPECT_TRUE(ret); 974 975 ret = gsmMsg->Decode2gCbMsg(); 976 EXPECT_TRUE(ret); 977 978 gsmMsg->cbPduBuffer_->pduBuffer_ = nullptr; 979 ret = gsmMsg->Decode2gCbMsg(); 980 EXPECT_FALSE(ret); 981 982 gsmMsg->cbHeader_->dcs.codingScheme = DATA_CODING_AUTO; 983 ret = gsmMsg->Decode2gCbMsg(); 984 EXPECT_TRUE(ret); 985} 986 987/** 988 * @tc.number Telephony_SmsMmsGtest_Decode2gCbMsg7bit_0001 989 * @tc.name Test Decode2gCbMsg7bit 990 * @tc.desc Function test 991 */ 992HWTEST_F(BranchCbTest, Decode2gCbMsg7bit_0001, Function | MediumTest | Level1) 993{ 994 auto cbMsg = std::make_shared<GsmCbCodec>(); 995 ASSERT_NE(cbMsg, nullptr); 996 cbMsg->cbPduBuffer_ = std::make_shared<GsmCbPduDecodeBuffer>(0); 997 cbMsg->cbHeader_ = std::make_shared<GsmCbCodec::GsmCbMessageHeader>(); 998 auto gsmMsg = std::make_shared<GsmCbGsmCodec>(cbMsg->cbHeader_, cbMsg->cbPduBuffer_, cbMsg); 999 ASSERT_NE(gsmMsg, nullptr); 1000 uint16_t dataLen = 5; 1001 bool ret = gsmMsg->Decode2gCbMsg7bit(dataLen); 1002 EXPECT_FALSE(ret); 1003} 1004 1005/** 1006 * @tc.number Telephony_SmsMmsGtest_Decode2gCbMsg7bit_0002 1007 * @tc.name Test Decode2gCbMsg7bit 1008 * @tc.desc Function test 1009 */ 1010HWTEST_F(BranchCbTest, Decode2gCbMsg7bit_0002, Function | MediumTest | Level1) 1011{ 1012 auto cbMsg = std::make_shared<GsmCbCodec>(); 1013 ASSERT_NE(cbMsg, nullptr); 1014 cbMsg->CreateCbMessage(CMAS_JP_PDU); 1015 std::vector<unsigned char> pdu = StringUtils::HexToByteVector(CMAS_JP_PDU); 1016 cbMsg->cbPduBuffer_ = std::make_shared<GsmCbPduDecodeBuffer>(pdu.size()); 1017 cbMsg->cbHeader_ = std::make_shared<GsmCbCodec::GsmCbMessageHeader>(); 1018 for (size_t index = 0; index < pdu.size() && index < cbMsg->cbPduBuffer_->GetSize(); index++) 1019 { 1020 cbMsg->cbPduBuffer_->pduBuffer_[index] = static_cast<char>(pdu[index]); 1021 } 1022 auto gsmMsg = std::make_shared<GsmCbGsmCodec>(cbMsg->cbHeader_, cbMsg->cbPduBuffer_, cbMsg); 1023 ASSERT_NE(gsmMsg, nullptr); 1024 gsmMsg->cbPduBuffer_ = cbMsg->cbPduBuffer_; 1025 gsmMsg->cbHeader_->dcs.iso639Lang[0] = 1; 1026 uint16_t dataLen = 5; 1027 bool ret = gsmMsg->Decode2gCbMsg7bit(dataLen); 1028 EXPECT_TRUE(ret); 1029} 1030 1031/** 1032 * @tc.number Telephony_SmsMmsGtest_misc_manager_CloseCBRange_0001 1033 * @tc.name Test CloseCBRange 1034 * @tc.desc Function test 1035 */ 1036HWTEST_F(BranchCbTest, misc_manager_CloseCBRange_0001, Function | MediumTest | Level1) 1037{ 1038 auto smsMiscManager = std::make_shared<SmsMiscManager>(INVALID_SLOTID); 1039 ASSERT_NE(smsMiscManager, nullptr); 1040 uint32_t fromMsgId = 2; 1041 uint32_t toMsgId = 2; 1042 SmsMiscManager::gsmCBRangeInfo rangeInfo(2, 2); 1043 smsMiscManager->rangeList_ = {rangeInfo}; 1044 bool ret = smsMiscManager->CloseCBRange(fromMsgId, toMsgId); 1045 EXPECT_TRUE(ret); 1046 1047 smsMiscManager->rangeList_ = {rangeInfo}; 1048 toMsgId = 3; 1049 ret = smsMiscManager->CloseCBRange(fromMsgId, toMsgId); 1050 EXPECT_TRUE(ret); 1051 1052 smsMiscManager->rangeList_ = {rangeInfo}; 1053 toMsgId = 1; 1054 ret = smsMiscManager->CloseCBRange(fromMsgId, toMsgId); 1055 EXPECT_TRUE(ret); 1056 1057 smsMiscManager->rangeList_ = {rangeInfo}; 1058 fromMsgId = 1; 1059 toMsgId = 2; 1060 ret = smsMiscManager->CloseCBRange(fromMsgId, toMsgId); 1061 EXPECT_TRUE(ret); 1062 1063 smsMiscManager->rangeList_ = {rangeInfo}; 1064 toMsgId = 3; 1065 ret = smsMiscManager->CloseCBRange(fromMsgId, toMsgId); 1066 EXPECT_TRUE(ret); 1067 1068 smsMiscManager->rangeList_ = {rangeInfo}; 1069 fromMsgId = 3; 1070 toMsgId = 2; 1071 ret = smsMiscManager->CloseCBRange(fromMsgId, toMsgId); 1072 EXPECT_TRUE(ret); 1073 1074 smsMiscManager->rangeList_ = {rangeInfo}; 1075 toMsgId = 1; 1076 ret = smsMiscManager->CloseCBRange(fromMsgId, toMsgId); 1077 EXPECT_TRUE(ret); 1078 1079 SmsMiscManager::gsmCBRangeInfo rangeInfo1(2, 3); 1080 smsMiscManager->rangeList_ = {rangeInfo1}; 1081 toMsgId = 3; 1082 ret = smsMiscManager->CloseCBRange(fromMsgId, toMsgId); 1083 EXPECT_TRUE(ret); 1084 1085 SmsMiscManager::gsmCBRangeInfo rangeInfo2(2, 1); 1086 smsMiscManager->rangeList_ = {rangeInfo2}; 1087 fromMsgId = 1; 1088 toMsgId = 1; 1089 ret = smsMiscManager->CloseCBRange(fromMsgId, toMsgId); 1090 EXPECT_TRUE(ret); 1091} 1092 1093/** 1094 * @tc.number Telephony_SmsMmsGtest_misc_manager_SplitMidValue_0001 1095 * @tc.name Test SplitMidValue 1096 * @tc.desc Function test 1097 */ 1098HWTEST_F(BranchCbTest, misc_manager_SplitMidValue_0001, Function | MediumTest | Level1) 1099{ 1100 auto smsMiscManager = std::make_shared<SmsMiscManager>(INVALID_SLOTID); 1101 ASSERT_NE(smsMiscManager, nullptr); 1102 std::string value = ""; 1103 std::string start = ""; 1104 std::string end = ""; 1105 const std::string delimiter = ":"; 1106 bool ret = smsMiscManager->SplitMidValue(value, start, end, delimiter); 1107 EXPECT_FALSE(ret); 1108 1109 value = ":value"; 1110 ret = smsMiscManager->SplitMidValue(value, start, end, delimiter); 1111 EXPECT_FALSE(ret); 1112 1113 value = "value:"; 1114 ret = smsMiscManager->SplitMidValue(value, start, end, delimiter); 1115 EXPECT_FALSE(ret); 1116 1117 value = "value"; 1118 ret = smsMiscManager->SplitMidValue(value, start, end, delimiter); 1119 EXPECT_TRUE(ret); 1120 1121 value = "smsMisc:value"; 1122 ret = smsMiscManager->SplitMidValue(value, start, end, delimiter); 1123 EXPECT_TRUE(ret); 1124} 1125 1126/** 1127 * @tc.number Telephony_SmsMmsGtest_misc_DelSimMessage_0001 1128 * @tc.name Test DelSimMessage 1129 * @tc.desc Function test 1130 */ 1131HWTEST_F(BranchCbTest, misc_manager_DelSimMessage_0001, Function | MediumTest | Level1) 1132{ 1133 auto smsMiscManager = std::make_shared<SmsMiscManager>(INVALID_SLOTID); 1134 ASSERT_NE(smsMiscManager, nullptr); 1135 uint32_t msgIndex = 1; 1136 int32_t ret = smsMiscManager->DelSimMessage(msgIndex); 1137 EXPECT_EQ(ret, TELEPHONY_ERR_SLOTID_INVALID); 1138} 1139 1140/** 1141 * @tc.number Telephony_SmsMmsGtest_misc_SetSmscAddr_0001 1142 * @tc.name Test SetSmscAddr 1143 * @tc.desc Function test 1144 */ 1145HWTEST_F(BranchCbTest, misc_manager_SetSmscAddr_0001, Function | MediumTest | Level1) 1146{ 1147 auto smsMiscManager = std::make_shared<SmsMiscManager>(INVALID_SLOTID); 1148 ASSERT_NE(smsMiscManager, nullptr); 1149 const std::string scAddr = ""; 1150 int32_t ret = smsMiscManager->SetSmscAddr(scAddr); 1151 EXPECT_EQ(ret, TELEPHONY_ERR_RIL_CMD_FAIL); 1152 std::u16string smscAddress = u""; 1153 ret = smsMiscManager->GetSmscAddr(smscAddress); 1154 EXPECT_EQ(ret, TELEPHONY_ERR_SUCCESS); 1155} 1156 1157/** 1158 * @tc.number Telephony_SmsMmsGtest_GetSmsStateEventIntValue_0001 1159 * @tc.name Test GetSmsStateEventIntValue 1160 * @tc.desc Function test 1161 */ 1162HWTEST_F(BranchCbTest, misc_GetSmsStateEventIntValue_0001, Function | MediumTest | Level1) 1163{ 1164 std::shared_ptr<CommonEventSubscribeInfo> subscribeInfo = std::make_shared<CommonEventSubscribeInfo>(); 1165 std::shared_ptr<SmsStateEventSubscriber> smsStateEventSubscriber = 1166 std::make_shared<SmsStateEventSubscriber>(*subscribeInfo); 1167 std::string event = "event"; 1168 smsStateEventSubscriber->smsStateEvenMapIntValues_[event] = COMMON_EVENT_SMS_CB_RECEIVE_COMPLETED; 1169 auto ret = smsStateEventSubscriber->GetSmsStateEventIntValue(event); 1170 EXPECT_EQ(ret, COMMON_EVENT_SMS_CB_RECEIVE_COMPLETED); 1171} 1172 1173/** 1174 * @tc.number Telephony_Sms_OnAddSystemAbility_0001 1175 * @tc.name Test OnAddSystemAbility 1176 * @tc.desc Function test 1177 */ 1178HWTEST_F(BranchCbTest, Sms_OnAddSystemAbility_0001, Function | MediumTest | Level1) 1179{ 1180 std::shared_ptr<SmsStateEventSubscriber> smsStateEventSubscriber = nullptr; 1181 std::shared_ptr<SmsStateObserver::SystemAbilityStatusChangeListener> sysAbilityStatus = 1182 std::make_shared<SmsStateObserver::SystemAbilityStatusChangeListener>(smsStateEventSubscriber); 1183 int32_t systemAbilityId = 1; 1184 const std::string deviceId = "123"; 1185 sysAbilityStatus->OnAddSystemAbility(systemAbilityId, deviceId); 1186 EXPECT_TRUE(systemAbilityId != COMMON_EVENT_SERVICE_ID); 1187 1188 systemAbilityId = COMMON_EVENT_SERVICE_ID; 1189 sysAbilityStatus->OnAddSystemAbility(systemAbilityId, deviceId); 1190 EXPECT_TRUE(sysAbilityStatus->sub_ == nullptr); 1191} 1192 1193/** 1194 * @tc.number Telephony_Sms_OnRemoveSystemAbility_0001 1195 * @tc.name Test OnRemoveSystemAbility 1196 * @tc.desc Function test 1197 */ 1198HWTEST_F(BranchCbTest, Sms_OnRemoveSystemAbility_0001, Function | MediumTest | Level1) 1199{ 1200 std::shared_ptr<CommonEventSubscribeInfo> subscribeInfo = std::make_shared<CommonEventSubscribeInfo>(); 1201 std::shared_ptr<SmsStateEventSubscriber> smsStateEventSubscriber = nullptr; 1202 std::shared_ptr<SmsStateObserver::SystemAbilityStatusChangeListener> sysAbilityStatus = 1203 std::make_shared<SmsStateObserver::SystemAbilityStatusChangeListener>(smsStateEventSubscriber); 1204 int32_t systemAbilityId = 1; 1205 const std::string deviceId = "123"; 1206 sysAbilityStatus->OnRemoveSystemAbility(systemAbilityId, deviceId); 1207 EXPECT_TRUE(systemAbilityId != COMMON_EVENT_SERVICE_ID); 1208 1209 systemAbilityId = COMMON_EVENT_SERVICE_ID; 1210 sysAbilityStatus->OnRemoveSystemAbility(systemAbilityId, deviceId); 1211 EXPECT_TRUE(systemAbilityId == COMMON_EVENT_SERVICE_ID); 1212 1213 sysAbilityStatus->OnRemoveSystemAbility(systemAbilityId, deviceId); 1214 EXPECT_TRUE(sysAbilityStatus->sub_ == nullptr); 1215 1216 smsStateEventSubscriber = std::make_shared<SmsStateEventSubscriber>(*subscribeInfo); 1217 sysAbilityStatus = 1218 std::make_shared<SmsStateObserver::SystemAbilityStatusChangeListener>(smsStateEventSubscriber); 1219 sysAbilityStatus->OnRemoveSystemAbility(systemAbilityId, deviceId); 1220 EXPECT_TRUE(sysAbilityStatus->sub_ != nullptr); 1221} 1222 1223/** 1224 * @tc.number Telephony_Sms_GetSmsUserDataMultipage_0001 1225 * @tc.name Test GetSmsUserDataMultipage 1226 * @tc.desc Function test 1227 */ 1228HWTEST_F(BranchCbTest, Sms_GetSmsUserDataMultipage_0001, Function | MediumTest | Level1) 1229{ 1230 auto reliabilityHandler = std::make_shared<SmsReceiveReliabilityHandler>(INVALID_SLOTID); 1231 int32_t smsPagesCount = 1; 1232 SmsReceiveIndexer smsReceiveIndexer; 1233 smsReceiveIndexer.msgSeqId_ = 0; 1234 smsReceiveIndexer.msgRefId_ = 1; 1235 std::vector<SmsReceiveIndexer> dbIndexers = {smsReceiveIndexer, smsReceiveIndexer}; 1236 int32_t position = -1; 1237 std::vector<std::string> initialData = {"User1", "User2"}; 1238 std::shared_ptr<std::vector<std::string>> userDataRaws = std::make_shared<std::vector<std::string>>(initialData); 1239 reliabilityHandler->GetSmsUserDataMultipage(smsPagesCount, dbIndexers, position, userDataRaws); 1240 EXPECT_TRUE(position < 0); 1241 1242 position = 2; 1243 reliabilityHandler->GetSmsUserDataMultipage(smsPagesCount, dbIndexers, position, userDataRaws); 1244 EXPECT_TRUE(position >= static_cast<int32_t>(dbIndexers.size())); 1245 1246 position = 0; 1247 reliabilityHandler->GetSmsUserDataMultipage(smsPagesCount, dbIndexers, position, userDataRaws); 1248 EXPECT_TRUE(dbIndexers[position].GetMsgSeqId() < 1); 1249 1250 dbIndexers[position].msgSeqId_ = MAX_SEGMENT_NUM + 1; 1251 reliabilityHandler->HiSysEventCBResult(true); 1252 reliabilityHandler->GetSmsUserDataMultipage(smsPagesCount, dbIndexers, position, userDataRaws); 1253 EXPECT_TRUE(dbIndexers[position].GetMsgSeqId() > MAX_SEGMENT_NUM); 1254 1255 dbIndexers[position].msgSeqId_ = 1; 1256 dbIndexers[position + 1].msgSeqId_ = 0; 1257 reliabilityHandler->GetSmsUserDataMultipage(smsPagesCount, dbIndexers, position, userDataRaws); 1258 EXPECT_TRUE(dbIndexers[position + 1].GetMsgSeqId() < 1); 1259 1260 dbIndexers.push_back(smsReceiveIndexer); 1261 dbIndexers[position + 1].msgSeqId_ = MAX_SEGMENT_NUM + 1; 1262 reliabilityHandler->GetSmsUserDataMultipage(smsPagesCount, dbIndexers, position, userDataRaws); 1263 EXPECT_TRUE(dbIndexers[position + 1].GetMsgSeqId() > MAX_SEGMENT_NUM); 1264 1265 dbIndexers.push_back(smsReceiveIndexer); 1266 dbIndexers[position + 1].msgSeqId_ = 1; 1267 reliabilityHandler->GetSmsUserDataMultipage(smsPagesCount, dbIndexers, position, userDataRaws); 1268 EXPECT_EQ(smsPagesCount, 2); 1269} 1270 1271/** 1272 * @tc.number Telephony_Sms_SendCacheMapLimitCheck_0001 1273 * @tc.name Test SendCacheMapLimitCheck 1274 * @tc.desc Function test 1275 */ 1276HWTEST_F(BranchCbTest, Sms_SendCacheMapLimitCheck_0001, Function | MediumTest | Level1) 1277{ 1278 std::function<void(std::shared_ptr<SmsSendIndexer>)> fun = nullptr; 1279 std::shared_ptr<SmsSender> smsSender = std::make_shared<CdmaSmsSender>(INVALID_SLOTID, fun); 1280 const sptr<ISendShortMessageCallback> sendCallback = nullptr; 1281 bool ret = smsSender->SendCacheMapLimitCheck(sendCallback); 1282 EXPECT_FALSE(ret); 1283 for (size_t i = 0; i < 30; i++) 1284 { 1285 smsSender->sendCacheMap_[i] = nullptr; 1286 } 1287 ret = smsSender->SendCacheMapLimitCheck(sendCallback); 1288 EXPECT_TRUE(ret); 1289} 1290} // namespace Telephony 1291} // namespace OHOS 1292