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 "gtest/gtest.h" 20#include "mms_body.h" 21#include "mms_body_part.h" 22#include "mms_content_type.h" 23#include "mms_encode_buffer.h" 24#include "mms_header.h" 25#include "mms_msg.h" 26#include "mms_network_manager.h" 27#include "mms_persist_helper.h" 28#include "sms_mms_gtest.h" 29#include "sms_service.h" 30#include "sms_wap_push_buffer.h" 31#include "sms_wap_push_content_type.h" 32 33namespace OHOS { 34namespace Telephony { 35using namespace testing::ext; 36 37namespace { 38const uint32_t TRANSACTION_ID_LENGTH = 3; 39const uint32_t PDU_BUFFE_LENGTH = 126; 40const uint32_t PDU_BUFFE_LENGTH_ONE = 128; 41const uint32_t PDU_BUFFE_LENGTH_TWO = 127; 42const uint32_t PDU_BUFFE_LENGTH_THREE = 31; 43const uint32_t PDU_BUFFE_LENGTH_FOUR = 129; 44const uint32_t PDU_BUFFE_LENGTH_FIVE = 139; 45const uint32_t PDU_BUFFE_LENGTH_SIX = 134; 46const uint32_t PDU_BUFFE_LENGTH_SEVEN = 152; 47const uint32_t PDU_BUFFE_LENGTH_EIGHT = 153; 48const uint32_t PDU_BUFFE_LENGTH_NINE = 138; 49const uint32_t PDU_BUFFE_LENGTH_TEN = 133; 50const uint32_t PDU_BUFFE_LENGTH_ELEVEN = 151; 51const uint32_t PDU_BUFFE_LENGTH_TWELVE = 154; 52const uint32_t PDU_BUFFE_LENGTH_THIRTEEN = 131; 53const uint32_t PDU_BUFFE_LENGTH_FOURTEEN = 137; 54const uint8_t MIN_TOKEN = 30; 55const uint8_t MAX_TOKEN = 127; 56const uint8_t FIELD_ID = 2; 57const int32_t INVALID_SLOTID = 2; 58const int32_t VALUE_LENGTH = 2; 59static constexpr uint32_t MAX_MMS_MSG_PART_LEN = 10 * 1024 * 1024; 60const uint32_t CODE_BUFFER_MAX_SIZE = 10 * 1024 * 1024; 61const std::string METHOD_POST = "POST"; 62const std::string METHOD_GET = "GET"; 63const std::string TEST_DATA = "test data test data"; 64const std::string TEST_PATH = "testPath"; 65const std::string TEST_URLS = "url1, url2, url3,"; 66const size_t URL_COUNT = 3; 67constexpr uint32_t SPLIT_PDU_LENGTH = 195 * 1024; 68const size_t SPLIT_PDU_COUNT = 3; 69const size_t BUF_LEN = 10; 70const int VALUE_4 = 4; 71const int VALUE_9 = 9; 72const int VALUE_16 = 0x10; 73const int VALUE_31 = 31; 74const int VALUE_32 = 32; 75const int VALUE_AF = 0xAF; 76constexpr const char *TEST_STR = "str"; 77constexpr const char *INPUT_STR = "00"; 78constexpr const char *SRC_STR = "123"; 79constexpr const char *BEGIN_STR = "01"; 80constexpr const char *END_STR = "FF"; 81const char PDU_COUNT = 10; 82const char INPUT_INTEGER = 128; 83const std::string VNET_MMSC = "http://mmsc.vnet.mobi"; 84} // namespace 85 86class BranchMmsTest : public testing::Test { 87public: 88 static void SetUpTestCase(); 89 static void TearDownTestCase(); 90 void SetUp(); 91 void TearDown(); 92}; 93void BranchMmsTest::SetUpTestCase() {} 94 95void BranchMmsTest::TearDownTestCase() {} 96 97void BranchMmsTest::SetUp() {} 98 99void BranchMmsTest::TearDown() {} 100 101/** 102 * @tc.number Telephony_SmsMmsGtest_MmsHeader_0001 103 * @tc.name Test MmsHeader 104 * @tc.desc Function test 105 */ 106HWTEST_F(BranchMmsTest, MmsHeader_0001, Function | MediumTest | Level1) 107{ 108 auto mmsHeader = std::make_shared<MmsHeader>(); 109 MmsEncodeString encodeString; 110 MmsDecodeBuffer decodeBuffer; 111 MmsEncodeBuffer encodeBuffer; 112 std::string encodeAddress = SRC_STR; 113 uint8_t value = 0; 114 MmsAddress address(encodeAddress); 115 std::vector<MmsAddress> addressValue; 116 addressValue.push_back(address); 117 mmsHeader->octetValueMap_.insert(pair<uint8_t, uint8_t>(1, 1)); 118 mmsHeader->longValueMap_.insert(pair<uint8_t, int64_t>(1, 1)); 119 mmsHeader->textValueMap_.insert(pair<uint8_t, std::string>(1, "1")); 120 mmsHeader->encodeStringsMap_.insert(pair<uint8_t, MmsEncodeString>(1, encodeString)); 121 mmsHeader->addressMap_.insert(pair<uint8_t, std::vector<MmsAddress>>(1, addressValue)); 122 mmsHeader->DumpMmsHeader(); 123 EXPECT_TRUE(mmsHeader->DecodeMmsHeader(decodeBuffer)); 124 EXPECT_FALSE(mmsHeader->EncodeMmsHeader(encodeBuffer)); 125 EXPECT_TRUE(mmsHeader->GetOctetValue(1, value)); 126 EXPECT_FALSE(mmsHeader->SetOctetValue(1, 0)); 127 mmsHeader->mmsHaderCateg_.mmsFieldDesMap_.insert( 128 pair<uint8_t, MmsFieldValueType>(MMS_MESSAGE_TYPE, MmsFieldValueType::MMS_FIELD_OCTET_TYPE)); 129 mmsHeader->mmsHaderCateg_.mmsFieldDesMap_.insert( 130 pair<uint8_t, MmsFieldValueType>(MMS_PRIORITY, MmsFieldValueType::MMS_FIELD_OCTET_TYPE)); 131 mmsHeader->mmsHaderCateg_.mmsFieldDesMap_.insert( 132 pair<uint8_t, MmsFieldValueType>(MMS_RESPONSE_STATUS, MmsFieldValueType::MMS_FIELD_OCTET_TYPE)); 133 mmsHeader->mmsHaderCateg_.mmsFieldDesMap_.insert( 134 pair<uint8_t, MmsFieldValueType>(MMS_SENDER_VISIBILITY, MmsFieldValueType::MMS_FIELD_OCTET_TYPE)); 135 mmsHeader->mmsHaderCateg_.mmsFieldDesMap_.insert( 136 pair<uint8_t, MmsFieldValueType>(MMS_STATUS, MmsFieldValueType::MMS_FIELD_OCTET_TYPE)); 137 mmsHeader->mmsHaderCateg_.mmsFieldDesMap_.insert( 138 pair<uint8_t, MmsFieldValueType>(MMS_RETRIEVE_STATUS, MmsFieldValueType::MMS_FIELD_OCTET_TYPE)); 139 mmsHeader->mmsHaderCateg_.mmsFieldDesMap_.insert( 140 pair<uint8_t, MmsFieldValueType>(MMS_READ_STATUS, MmsFieldValueType::MMS_FIELD_OCTET_TYPE)); 141 mmsHeader->mmsHaderCateg_.mmsFieldDesMap_.insert( 142 pair<uint8_t, MmsFieldValueType>(MMS_REPLY_CHARGING, MmsFieldValueType::MMS_FIELD_OCTET_TYPE)); 143 EXPECT_FALSE(mmsHeader->SetOctetValue(MMS_MESSAGE_TYPE, MMS_MESSAGE_TYPE)); 144 EXPECT_FALSE(mmsHeader->SetOctetValue(MMS_PRIORITY, MMS_PRIORITY)); 145 EXPECT_FALSE(mmsHeader->SetOctetValue(MMS_RESPONSE_STATUS, MMS_RESPONSE_STATUS)); 146 EXPECT_FALSE(mmsHeader->SetOctetValue(MMS_SENDER_VISIBILITY, MMS_SENDER_VISIBILITY)); 147 EXPECT_FALSE(mmsHeader->SetOctetValue(MMS_STATUS, MMS_STATUS)); 148 EXPECT_FALSE(mmsHeader->SetOctetValue(MMS_RETRIEVE_STATUS, MMS_RETRIEVE_STATUS)); 149 EXPECT_FALSE(mmsHeader->SetOctetValue(MMS_READ_STATUS, MMS_READ_STATUS)); 150 EXPECT_FALSE(mmsHeader->SetOctetValue(MMS_REPLY_CHARGING, MMS_REPLY_CHARGING)); 151 EXPECT_FALSE(mmsHeader->SetOctetValue(MMS_MM_STATE, MMS_MM_STATE)); 152 EXPECT_TRUE(mmsHeader->GetHeaderAllAddressValue(1, addressValue)); 153} 154 155/** 156 * @tc.number Telephony_SmsMmsGtest_MmsHeader_0002 157 * @tc.name Test MmsHeader 158 * @tc.desc Function test 159 */ 160HWTEST_F(BranchMmsTest, MmsHeader_0002, Function | MediumTest | Level1) 161{ 162 auto mmsHeader = std::make_shared<MmsHeader>(); 163 int64_t value = 0; 164 std::string valueStr = ""; 165 std::string encodeAddress = SRC_STR; 166 MmsAddress address(encodeAddress); 167 std::vector<MmsAddress> addressValue; 168 addressValue.push_back(address); 169 MmsEncodeString encodeString; 170 mmsHeader->longValueMap_.insert(pair<uint8_t, int64_t>(1, 1)); 171 mmsHeader->textValueMap_.insert(pair<uint8_t, std::string>(1, "1")); 172 mmsHeader->encodeStringsMap_.insert(pair<uint8_t, MmsEncodeString>(1, encodeString)); 173 mmsHeader->mmsHaderCateg_.mmsFieldDesMap_.insert( 174 pair<uint8_t, MmsFieldValueType>(MMS_STORE_STATUS, MmsFieldValueType::MMS_FIELD_OCTET_TYPE)); 175 mmsHeader->mmsHaderCateg_.mmsFieldDesMap_.insert( 176 pair<uint8_t, MmsFieldValueType>(MMS_CONTENT_CLASS, MmsFieldValueType::MMS_FIELD_OCTET_TYPE)); 177 mmsHeader->mmsHaderCateg_.mmsFieldDesMap_.insert( 178 pair<uint8_t, MmsFieldValueType>(MMS_MESSAGE_CLASS, MmsFieldValueType::MMS_FIELD_OCTET_TYPE)); 179 mmsHeader->mmsHaderCateg_.mmsFieldDesMap_.insert( 180 pair<uint8_t, MmsFieldValueType>(MMS_CANCEL_STATUS, MmsFieldValueType::MMS_FIELD_OCTET_TYPE)); 181 mmsHeader->mmsHaderCateg_.mmsFieldDesMap_.insert( 182 pair<uint8_t, MmsFieldValueType>(MMS_ADAPTATION_ALLOWED, MmsFieldValueType::MMS_FIELD_OCTET_TYPE)); 183 EXPECT_TRUE(mmsHeader->SetOctetValue(MMS_ADAPTATION_ALLOWED, MMS_BCC)); 184 EXPECT_TRUE(mmsHeader->GetLongValue(1, value)); 185 EXPECT_TRUE(mmsHeader->GetTextValue(1, valueStr)); 186 EXPECT_TRUE(mmsHeader->GetEncodeStringValue(1, encodeString)); 187 EXPECT_FALSE(mmsHeader->SetTextValue(MMS_CANCEL_STATUS, "")); 188 EXPECT_FALSE(mmsHeader->SetTextValue(MMS_CANCEL_STATUS, SRC_STR)); 189 EXPECT_FALSE(mmsHeader->SetOctetValue(MMS_MM_FLAGS, MMS_MM_FLAGS)); 190 EXPECT_FALSE(mmsHeader->SetOctetValue(MMS_CONTENT_CLASS, MMS_CONTENT_CLASS)); 191 EXPECT_FALSE(mmsHeader->SetOctetValue(MMS_MESSAGE_CLASS, MMS_MESSAGE_CLASS)); 192 EXPECT_FALSE(mmsHeader->SetOctetValue(MMS_CANCEL_STATUS, MMS_CANCEL_STATUS)); 193 EXPECT_FALSE(mmsHeader->SetLongValue(MMS_MESSAGE_CLASS, 0)); 194 EXPECT_FALSE(mmsHeader->SetEncodeStringValue(1, 1, valueStr)); 195 EXPECT_FALSE(mmsHeader->SetEncodeStringValue(MMS_STORE_STATUS, 1, encodeAddress)); 196 EXPECT_FALSE(mmsHeader->AddHeaderAddressValue(1, address)); 197 EXPECT_TRUE(mmsHeader->GetStringValue(1, encodeAddress)); 198 EXPECT_FALSE(mmsHeader->GetStringValue(FIELD_ID, encodeAddress)); 199 EXPECT_TRUE(mmsHeader->GetSmilFileName(valueStr)); 200 EXPECT_FALSE(mmsHeader->IsHaveBody()); 201} 202 203/** 204 * @tc.number Telephony_SmsMmsGtest_MmsHeader_0003 205 * @tc.name Test MmsHeader 206 * @tc.desc Function test 207 */ 208HWTEST_F(BranchMmsTest, MmsHeader_0003, Function | MediumTest | Level1) 209{ 210 auto mmsHeader = std::make_shared<MmsHeader>(); 211 MmsDecodeBuffer decodeBuffer; 212 MmsEncodeBuffer buff; 213 std::string encodeAddress = SRC_STR; 214 MmsAddress address(encodeAddress); 215 std::vector<MmsAddress> addressValue; 216 addressValue.push_back(address); 217 int32_t data = 0; 218 mmsHeader->addressMap_.insert(pair<uint8_t, std::vector<MmsAddress>>(MMS_BCC, addressValue)); 219 mmsHeader->addressMap_.insert(pair<uint8_t, std::vector<MmsAddress>>(MMS_FROM, addressValue)); 220 EXPECT_NE(mmsHeader->MakeTransactionId(TRANSACTION_ID_LENGTH), ""); 221 EXPECT_FALSE(mmsHeader->DecodeMmsMsgType(1, decodeBuffer, data)); 222 EXPECT_FALSE(mmsHeader->DecodeMmsMsgType(MMS_BCC, decodeBuffer, data)); 223 EXPECT_FALSE(mmsHeader->DecodeFieldAddressModelValue(1, decodeBuffer, data)); 224 EXPECT_TRUE(mmsHeader->DecodeFieldAddressModelValue(MMS_BCC, decodeBuffer, data)); 225 EXPECT_FALSE(mmsHeader->DecodeFieldOctetValue(1, decodeBuffer, data)); 226 EXPECT_FALSE(mmsHeader->DecodeFieldLongValue(1, decodeBuffer, data)); 227 EXPECT_FALSE(mmsHeader->DecodeFieldIntegerValue(1, decodeBuffer, data)); 228 EXPECT_FALSE(mmsHeader->DecodeFieldTextStringValue(1, decodeBuffer, data)); 229 EXPECT_FALSE(mmsHeader->DecodeFieldTextStringValue(MMS_BCC, decodeBuffer, data)); 230 EXPECT_FALSE(mmsHeader->DecodeFieldEncodedStringValue(1, decodeBuffer, data)); 231 EXPECT_FALSE(mmsHeader->DecodeFieldEncodedStringValue(MMS_BCC, decodeBuffer, data)); 232 EXPECT_FALSE(mmsHeader->DecodeFromValue(1, decodeBuffer, data)); 233 EXPECT_FALSE(mmsHeader->DecodeMmsMsgUnKnownField(decodeBuffer)); 234 EXPECT_FALSE(mmsHeader->DecodeMmsContentType(1, decodeBuffer, data)); 235 EXPECT_FALSE(mmsHeader->DecodeFieldDate(1, decodeBuffer, data)); 236 EXPECT_FALSE(mmsHeader->DecodeFieldDate(MMS_BCC, decodeBuffer, data)); 237 EXPECT_FALSE(mmsHeader->DecodeFieldPreviouslySentDate(1, decodeBuffer, data)); 238 EXPECT_FALSE(mmsHeader->DecodeFieldPreviouslySentDate(MMS_BCC, decodeBuffer, data)); 239 EXPECT_FALSE(mmsHeader->DecodeFieldMBox(1, decodeBuffer, data)); 240 EXPECT_FALSE(mmsHeader->DecodeFieldMBox(MMS_BCC, decodeBuffer, data)); 241 EXPECT_FALSE(mmsHeader->DecodeFieldMMFlag(1, decodeBuffer, data)); 242 EXPECT_FALSE(mmsHeader->DecodeFieldMMFlag(MMS_BCC, decodeBuffer, data)); 243 EXPECT_TRUE(mmsHeader->EncodeFieldFromValue(buff, addressValue)); 244 mmsHeader->textValueMap_.insert(pair<uint8_t, std::string>(MMS_MESSAGE_CLASS, "personal")); 245 EXPECT_TRUE(mmsHeader->EcondeFieldMessageClassValue(buff)); 246 mmsHeader->textValueMap_.insert(pair<uint8_t, std::string>(MMS_MESSAGE_CLASS, "advertisement")); 247 EXPECT_TRUE(mmsHeader->EcondeFieldMessageClassValue(buff)); 248 mmsHeader->textValueMap_.insert(pair<uint8_t, std::string>(MMS_MESSAGE_CLASS, "informational")); 249 EXPECT_TRUE(mmsHeader->EcondeFieldMessageClassValue(buff)); 250 mmsHeader->textValueMap_.insert(pair<uint8_t, std::string>(MMS_MESSAGE_CLASS, "auto")); 251 EXPECT_TRUE(mmsHeader->EcondeFieldMessageClassValue(buff)); 252 mmsHeader->octetValueMap_.insert(pair<uint8_t, uint8_t>(MMS_MESSAGE_CLASS, 1)); 253 EXPECT_TRUE(mmsHeader->EcondeFieldMessageClassValue(buff)); 254} 255 256/** 257 * @tc.number Telephony_SmsMmsGtest_MmsHeader_0004 258 * @tc.name Test MmsHeader 259 * @tc.desc Function test 260 */ 261HWTEST_F(BranchMmsTest, MmsHeader_0004, Function | MediumTest | Level1) 262{ 263 auto mmsHeader = std::make_shared<MmsHeader>(); 264 MmsEncodeBuffer buff; 265 std::string encodeAddress = SRC_STR; 266 MmsAddress address(encodeAddress); 267 std::vector<MmsAddress> addrs; 268 mmsHeader->longValueMap_.insert(pair<uint8_t, int64_t>(MMS_EXPIRY, 1)); 269 mmsHeader->textValueMap_.insert(pair<uint8_t, std::string>(MMS_TRANSACTION_ID, "auto")); 270 EXPECT_TRUE(mmsHeader->EncodeCommontFieldValue(buff)); 271 EXPECT_FALSE(mmsHeader->EncodeMultipleAddressValue(buff, 1, addrs)); 272 addrs.push_back(address); 273 EXPECT_TRUE(mmsHeader->EncodeMultipleAddressValue(buff, 1, addrs)); 274 EXPECT_TRUE(mmsHeader->EncodeMmsSendReq(buff)); 275 EXPECT_FALSE(mmsHeader->EncodeMmsSendConf(buff)); 276 EXPECT_FALSE(mmsHeader->EncodeMmsNotificationInd(buff)); 277 mmsHeader->textValueMap_.insert(pair<uint8_t, std::string>(MMS_CONTENT_LOCATION, "auto")); 278 EXPECT_FALSE(mmsHeader->EncodeMmsNotificationInd(buff)); 279 EXPECT_FALSE(mmsHeader->EnocdeMmsNotifyRespInd(buff)); 280 EXPECT_FALSE(mmsHeader->EnocdeMmsRetrieveConf(buff)); 281 mmsHeader->longValueMap_.insert(pair<uint8_t, int64_t>(MMS_DATE, 1)); 282 mmsHeader->addressMap_.insert(pair<uint8_t, std::vector<MmsAddress>>(MMS_CC, addrs)); 283 EXPECT_TRUE(mmsHeader->EnocdeMmsRetrieveConf(buff)); 284 EXPECT_FALSE(mmsHeader->EnocdeMmsDeliveryInd(buff)); 285 mmsHeader->addressMap_.insert(pair<uint8_t, std::vector<MmsAddress>>(MMS_TO, addrs)); 286 EXPECT_TRUE(mmsHeader->EnocdeMmsRetrieveConf(buff)); 287 mmsHeader->addressMap_.insert(pair<uint8_t, std::vector<MmsAddress>>(MMS_FROM, addrs)); 288 EXPECT_TRUE(mmsHeader->EnocdeMmsRetrieveConf(buff)); 289 EXPECT_FALSE(mmsHeader->EnocdeMmsDeliveryInd(buff)); 290 EXPECT_FALSE(mmsHeader->EncodeMmsReadRecInd(buff)); 291 mmsHeader->textValueMap_.insert(pair<uint8_t, std::string>(MMS_MESSAGE_ID, "auto")); 292 EXPECT_FALSE(mmsHeader->EnocdeMmsDeliveryInd(buff)); 293 mmsHeader->longValueMap_.clear(); 294 EXPECT_FALSE(mmsHeader->EnocdeMmsDeliveryInd(buff)); 295 mmsHeader->addressMap_.clear(); 296 mmsHeader->textValueMap_.clear(); 297 EXPECT_FALSE(mmsHeader->EncodeMmsReadRecInd(buff)); 298 EXPECT_FALSE(mmsHeader->EncodeMmsReadOrigInd(buff)); 299 mmsHeader->textValueMap_.insert(pair<uint8_t, std::string>(MMS_MESSAGE_ID, "auto")); 300 EXPECT_FALSE(mmsHeader->EncodeMmsReadOrigInd(buff)); 301 mmsHeader->addressMap_.insert(pair<uint8_t, std::vector<MmsAddress>>(MMS_TO, addrs)); 302 EXPECT_FALSE(mmsHeader->EncodeMmsReadOrigInd(buff)); 303 mmsHeader->octetValueMap_.insert(pair<uint8_t, uint8_t>(MMS_READ_STATUS, 1)); 304 EXPECT_FALSE(mmsHeader->EncodeMmsReadOrigInd(buff)); 305 EXPECT_FALSE(mmsHeader->CheckBooleanValue(MMS_DRM_CONTENT, 0)); 306 EXPECT_FALSE(mmsHeader->CheckBooleanValue(MMS_BCC, 1)); 307} 308 309/** 310 * @tc.number Telephony_SmsMmsGtest_MmsHeader_0005 311 * @tc.name Test MmsHeader 312 * @tc.desc Function test 313 */ 314HWTEST_F(BranchMmsTest, MmsHeader_0005, Function | MediumTest | Level1) 315{ 316 auto mmsHeader = std::make_shared<MmsHeader>(); 317 MmsEncodeBuffer buff; 318 MmsEncodeString value; 319 EXPECT_FALSE(mmsHeader->EncodeTextStringValue(buff, 1, "")); 320 EXPECT_FALSE(mmsHeader->EncodeEncodeStringValue(buff, 1, value)); 321 EXPECT_TRUE(mmsHeader->IsHaveTransactionId(MMS_MSGTYPE_SEND_REQ)); 322 EXPECT_TRUE(mmsHeader->IsHaveTransactionId(MMS_MSGTYPE_SEND_CONF)); 323 EXPECT_TRUE(mmsHeader->IsHaveTransactionId(MMS_MSGTYPE_NOTIFICATION_IND)); 324 EXPECT_TRUE(mmsHeader->IsHaveTransactionId(MMS_MSGTYPE_NOTIFYRESP_IND)); 325 EXPECT_TRUE(mmsHeader->IsHaveTransactionId(MMS_MSGTYPE_RETRIEVE_CONF)); 326 EXPECT_TRUE(mmsHeader->IsHaveTransactionId(MMS_MSGTYPE_ACKNOWLEDGE_IND)); 327 EXPECT_TRUE(mmsHeader->CheckResponseStatus(static_cast<uint8_t>(MmsResponseStatus::MMS_OK))); 328 EXPECT_TRUE(mmsHeader->CheckResponseStatus(static_cast<uint8_t>(MmsResponseStatus::MMS_ERROR_UNSUPPORTED_MESSAGE))); 329 EXPECT_TRUE(mmsHeader->CheckResponseStatus(static_cast<uint8_t>(MmsResponseStatus::MMS_ERROR_PERMANENT_FAILURE))); 330 EXPECT_TRUE( 331 mmsHeader->CheckResponseStatus(static_cast<uint8_t>(MmsResponseStatus::MMS_ERROR_PERMANENT_LACK_OF_PREPAID))); 332 EXPECT_TRUE(mmsHeader->CheckRetrieveStatus(static_cast<uint8_t>(MmsRetrieveStatus::MMS_RETRIEVE_STATUS_OK))); 333 EXPECT_TRUE(mmsHeader->CheckRetrieveStatus( 334 static_cast<uint8_t>(MmsRetrieveStatus::MMS_RETRIEVE_STATUS_ERROR_PERMANENT_FAILURE))); 335 EXPECT_TRUE(mmsHeader->CheckRetrieveStatus( 336 static_cast<uint8_t>(MmsRetrieveStatus::MMS_RETRIEVE_STATUS_ERROR_PERMANENT_CONTENT_UNSUPPORTED))); 337 EXPECT_TRUE(mmsHeader->CheckRetrieveStatus( 338 static_cast<uint8_t>(MmsRetrieveStatus::MMS_RETRIEVE_STATUS_ERROR_TRANSIENT_FAILURE))); 339 EXPECT_TRUE(mmsHeader->CheckRetrieveStatus( 340 static_cast<uint8_t>(MmsRetrieveStatus::MMS_RETRIEVE_STATUS_ERROR_TRANSIENT_NETWORK_PROBLEM))); 341 EXPECT_TRUE(mmsHeader->CheckStoreStatus(static_cast<uint8_t>(MmsStoreStatus::MMS_STORE_STATUS_SUCCESS))); 342 EXPECT_TRUE( 343 mmsHeader->CheckStoreStatus(static_cast<uint8_t>(MmsStoreStatus::MMS_STORE_STATUS_ERROR_TRANSIENT_FAILURE))); 344 EXPECT_TRUE(mmsHeader->CheckStoreStatus( 345 static_cast<uint8_t>(MmsStoreStatus::MMS_STORE_STATUS_ERROR_TRANSIENT_NETWORK_PROBLEM))); 346 EXPECT_TRUE( 347 mmsHeader->CheckStoreStatus(static_cast<uint8_t>(MmsStoreStatus::MMS_STORE_STATUS_ERROR_PERMANENT_FAILURE))); 348 EXPECT_TRUE( 349 mmsHeader->CheckStoreStatus(static_cast<uint8_t>(MmsStoreStatus::MMS_STORE_STATUS_ERROR_PERMANENT_MMBOX_FULL))); 350 EXPECT_TRUE(mmsHeader->CheckBooleanValue(MMS_DELIVERY_REPORT, static_cast<uint8_t>(MmsBoolType::MMS_YES))); 351 EXPECT_FALSE(mmsHeader->CheckBooleanValue(MMS_READ_REPORT, 0)); 352 EXPECT_FALSE(mmsHeader->CheckBooleanValue(MMS_REPORT_ALLOWED, 0)); 353 EXPECT_FALSE(mmsHeader->CheckBooleanValue(MMS_STORE, 0)); 354 EXPECT_FALSE(mmsHeader->CheckBooleanValue(MMS_STORED, 0)); 355 EXPECT_FALSE(mmsHeader->CheckBooleanValue(MMS_TOTALS, 0)); 356 EXPECT_FALSE(mmsHeader->CheckBooleanValue(MMS_QUOTAS, 0)); 357 EXPECT_FALSE(mmsHeader->CheckBooleanValue(MMS_DISTRIBUTION_INDICATOR, 0)); 358} 359 360/** 361 * @tc.number Telephony_SmsMmsGtest_SmsWapPushBuffer_0001 362 * @tc.name Test SmsWapPushBuffer 363 * @tc.desc Function test 364 */ 365HWTEST_F(BranchMmsTest, SmsWapPushBuffer_0001, Function | MediumTest | Level1) 366{ 367 auto smsWapPushBuffer = std::make_shared<SmsWapPushBuffer>(); 368 uint8_t oneByte = 0; 369 uint8_t sValueLength = 0; 370 uint32_t valueLength = 0; 371 uint32_t length = 1; 372 std::string str = "qwe"; 373 EXPECT_FALSE(smsWapPushBuffer->GetOneByte(oneByte)); 374 EXPECT_FALSE(smsWapPushBuffer->IncreasePointer(1)); 375 EXPECT_FALSE(smsWapPushBuffer->DecreasePointer(1)); 376 EXPECT_FALSE(smsWapPushBuffer->DecodeShortLength(sValueLength)); 377 EXPECT_FALSE(smsWapPushBuffer->DecodeValueLengthReturnLen(valueLength, length)); 378 EXPECT_FALSE(smsWapPushBuffer->DecodeUintvar(valueLength, length)); 379 EXPECT_FALSE(smsWapPushBuffer->DecodeValueLength(valueLength)); 380 EXPECT_FALSE(smsWapPushBuffer->DecodeText(str, length)); 381 EXPECT_FALSE(smsWapPushBuffer->DecodeShortInteger(oneByte)); 382 smsWapPushBuffer->totolLength_ = 1; 383 smsWapPushBuffer->curPosition_ = 1; 384 EXPECT_FALSE(smsWapPushBuffer->IncreasePointer(1)); 385 smsWapPushBuffer->curPosition_ = 0; 386 smsWapPushBuffer->pduBuffer_ = std::make_unique<char[]>(1); 387 smsWapPushBuffer->pduBuffer_[0] = 0; 388 EXPECT_TRUE(smsWapPushBuffer->DecodeShortLength(sValueLength)); 389 smsWapPushBuffer->curPosition_ = 0; 390 smsWapPushBuffer->pduBuffer_[0] = 0; 391 EXPECT_TRUE(smsWapPushBuffer->DecodeValueLengthReturnLen(valueLength, length)); 392 smsWapPushBuffer->curPosition_ = 0; 393 smsWapPushBuffer->pduBuffer_[0] = PDU_BUFFE_LENGTH_TWO; 394 EXPECT_TRUE(smsWapPushBuffer->DecodeIsString()); 395 smsWapPushBuffer->pduBuffer_[0] = PDU_BUFFE_LENGTH_ONE; 396 EXPECT_FALSE(smsWapPushBuffer->DecodeUintvar(valueLength, length)); 397 smsWapPushBuffer->curPosition_ = 0; 398 EXPECT_TRUE(smsWapPushBuffer->DecodeShortInteger(oneByte)); 399 smsWapPushBuffer->curPosition_ = 0; 400 EXPECT_FALSE(smsWapPushBuffer->DecodeValueLength(valueLength)); 401 smsWapPushBuffer->curPosition_ = 0; 402 smsWapPushBuffer->pduBuffer_[0] = PDU_BUFFE_LENGTH_THREE; 403 EXPECT_TRUE(smsWapPushBuffer->DecodeIsValueLength()); 404 EXPECT_FALSE(smsWapPushBuffer->DecodeValueLength(valueLength)); 405 smsWapPushBuffer->curPosition_ = 0; 406 EXPECT_FALSE(smsWapPushBuffer->DecodeTokenText(str, length)); 407 smsWapPushBuffer->pduBuffer_[0] = PDU_BUFFE_LENGTH_TWO; 408 EXPECT_TRUE(smsWapPushBuffer->DecodeText(str, length)); 409 EXPECT_FALSE(smsWapPushBuffer->CharIsToken(MIN_TOKEN)); 410 EXPECT_FALSE(smsWapPushBuffer->CharIsToken(MAX_TOKEN)); 411 smsWapPushBuffer->curPosition_ = 0; 412 smsWapPushBuffer->pduBuffer_[0] = PDU_BUFFE_LENGTH; 413 EXPECT_TRUE(smsWapPushBuffer->DecodeTokenText(str, length)); 414} 415 416/** 417 * @tc.number Telephony_SmsMmsGtest_SmsWapPushBuffer_0002 418 * @tc.name Test SmsWapPushBuffer 419 * @tc.desc Function test 420 */ 421HWTEST_F(BranchMmsTest, SmsWapPushBuffer_0002, Function | MediumTest | Level1) 422{ 423 auto smsWapPushBuffer = std::make_shared<SmsWapPushBuffer>(); 424 uint64_t iInteger = 0; 425 std::string str = "qwe"; 426 bool isNoValue = true; 427 uint32_t len = 1; 428 smsWapPushBuffer->pduBuffer_ = std::make_unique<char[]>(1); 429 EXPECT_FALSE(smsWapPushBuffer->DecodeLongInteger(iInteger)); 430 EXPECT_FALSE(smsWapPushBuffer->DecodeTextValue(str, isNoValue)); 431 EXPECT_FALSE(smsWapPushBuffer->DecodeNoValue(isNoValue)); 432 EXPECT_TRUE(smsWapPushBuffer->ReadDataBuffer(1, 1) == nullptr); 433 smsWapPushBuffer->totolLength_ = 1; 434 smsWapPushBuffer->pduBuffer_[0] = 1; 435 EXPECT_FALSE(smsWapPushBuffer->DecodeLongInteger(iInteger)); 436 smsWapPushBuffer->curPosition_ = 0; 437 smsWapPushBuffer->pduBuffer_[0] = PDU_BUFFE_LENGTH_THREE; 438 EXPECT_FALSE(smsWapPushBuffer->DecodeLongInteger(iInteger)); 439 smsWapPushBuffer->curPosition_ = 0; 440 smsWapPushBuffer->pduBuffer_[0] = 1; 441 EXPECT_FALSE(smsWapPushBuffer->DecodeTextValue(str, isNoValue)); 442 EXPECT_TRUE(smsWapPushBuffer->ReadDataBuffer(1, 1) == nullptr); 443 EXPECT_FALSE(smsWapPushBuffer->WriteRawStringBuffer(str)); 444 EXPECT_FALSE(smsWapPushBuffer->WriteDataBuffer(nullptr, 1)); 445 smsWapPushBuffer->curPosition_ = 0; 446 smsWapPushBuffer->pduBuffer_[0] = 0; 447 EXPECT_FALSE(smsWapPushBuffer->DecodeQuotedText(str, len)); 448 smsWapPushBuffer->curPosition_ = 0; 449 smsWapPushBuffer->pduBuffer_[0] = PDU_BUFFE_LENGTH_TWO; 450 EXPECT_TRUE(smsWapPushBuffer->DecodeQuotedText(str, len)); 451 smsWapPushBuffer->curPosition_ = 0; 452 smsWapPushBuffer->pduBuffer_[0] = PDU_BUFFE_LENGTH_ONE; 453 EXPECT_TRUE(smsWapPushBuffer->DecodeInteger(iInteger)); 454 smsWapPushBuffer->curPosition_ = 0; 455 smsWapPushBuffer->pduBuffer_[0] = PDU_BUFFE_LENGTH_TWO; 456 EXPECT_FALSE(smsWapPushBuffer->DecodeInteger(iInteger)); 457} 458 459/** 460 * @tc.number Telephony_SmsMmsGtest_SmsWapPushHandler_0001 461 * @tc.name Test SmsWapPushHandler 462 * @tc.desc Function test 463 */ 464HWTEST_F(BranchMmsTest, SmsWapPushHandler_0001, Function | MediumTest | Level1) 465{ 466 auto smsWapPushHandler = std::make_shared<SmsWapPushHandler>(INVALID_SLOTID); 467 SmsWapPushBuffer decodeBuffer; 468 std::string wapPdu = ""; 469 EXPECT_FALSE(smsWapPushHandler->DecodeWapPushPduData(decodeBuffer, 1, 1)); 470 auto indexer = std::make_shared<SmsReceiveIndexer>(); 471 EXPECT_FALSE(smsWapPushHandler->DecodeWapPushPdu(indexer, wapPdu)); 472 EXPECT_FALSE(smsWapPushHandler->DeocdeCheckIsBlock(wapPdu)); 473 wapPdu = "qwer"; 474 EXPECT_FALSE(smsWapPushHandler->DecodeWapPushPdu(indexer, wapPdu)); 475 EXPECT_FALSE(smsWapPushHandler->DecodePushType(decodeBuffer)); 476 EXPECT_FALSE(smsWapPushHandler->DeocdeCheckIsBlock(wapPdu)); 477 EXPECT_FALSE(smsWapPushHandler->DecodeXWapApplication(decodeBuffer, 1)); 478 smsWapPushHandler->DeleteWapPush(indexer); 479 EXPECT_FALSE(smsWapPushHandler->DecodeXWapAbandonHeaderValue(decodeBuffer)); 480 auto dataBuf = std::make_unique<char[]>(BUF_LEN); 481 decodeBuffer.WriteDataBuffer(std::move(dataBuf), BUF_LEN); 482 decodeBuffer.totolLength_ = 1; 483 EXPECT_FALSE(smsWapPushHandler->DecodeXWapApplication(decodeBuffer, 1)); 484 decodeBuffer.totolLength_ = 0; 485 EXPECT_FALSE(smsWapPushHandler->DecodeXWapApplication(decodeBuffer, 0)); 486 EXPECT_TRUE(smsWapPushHandler->SendWapPushMessageBroadcast(indexer)); 487} 488 489/** 490 * @tc.number Telephony_SmsMmsGtest_SmsWapPushHandler_0002 491 * @tc.name Test SmsWapPushHandler 492 * @tc.desc Function test 493 */ 494HWTEST_F(BranchMmsTest, SmsWapPushHandler_0002, Function | MediumTest | Level1) 495{ 496 TELEPHONY_LOGI("TelSMSMMSTest::SmsWapPushHandler_0002 -->"); 497 auto smsWapPushHandler = std::make_shared<SmsWapPushHandler>(INVALID_SLOTID); 498 SmsWapPushBuffer decodeBuffer; 499 auto dataBuf = std::make_unique<char[]>(BUF_LEN); 500 decodeBuffer.WriteDataBuffer(std::move(dataBuf), BUF_LEN); 501 EXPECT_FALSE(smsWapPushHandler->DecodeXWapApplication(decodeBuffer, 1)); 502 503 std::string appId = TEST_PATH; 504 decodeBuffer.curPosition_ = 0; 505 decodeBuffer.pduBuffer_[0] = VALUE_9; 506 EXPECT_FALSE(smsWapPushHandler->DecodeXWapApplicationField(decodeBuffer, appId)); 507 appId = TEST_PATH; 508 decodeBuffer.curPosition_ = 0; 509 decodeBuffer.pduBuffer_[0] = VALUE_AF; 510 EXPECT_TRUE(smsWapPushHandler->DecodeXWapApplicationField(decodeBuffer, appId)); 511 512 appId = TEST_PATH; 513 decodeBuffer.curPosition_ = 0; 514 decodeBuffer.pduBuffer_[0] = VALUE_AF; 515 EXPECT_TRUE(smsWapPushHandler->DecodeXWapApplicationValue(decodeBuffer, appId)); 516 appId = TEST_PATH; 517 decodeBuffer.curPosition_ = 0; 518 decodeBuffer.pduBuffer_[0] = VALUE_9; 519 EXPECT_FALSE(smsWapPushHandler->DecodeXWapApplicationValue(decodeBuffer, appId)); 520 521 decodeBuffer.curPosition_ = 0; 522 decodeBuffer.pduBuffer_[0] = VALUE_4; 523 EXPECT_TRUE(smsWapPushHandler->DecodeXWapAbandonHeaderValue(decodeBuffer)); 524 decodeBuffer.curPosition_ = 0; 525 decodeBuffer.pduBuffer_[0] = VALUE_16; 526 EXPECT_FALSE(smsWapPushHandler->DecodeXWapAbandonHeaderValue(decodeBuffer)); 527 decodeBuffer.curPosition_ = 0; 528 decodeBuffer.pduBuffer_[0] = VALUE_31; 529 EXPECT_TRUE(smsWapPushHandler->DecodeXWapAbandonHeaderValue(decodeBuffer)); 530 decodeBuffer.curPosition_ = VALUE_9; 531 decodeBuffer.pduBuffer_[VALUE_9] = VALUE_31; 532 EXPECT_FALSE(smsWapPushHandler->DecodeXWapAbandonHeaderValue(decodeBuffer)); 533 decodeBuffer.curPosition_ = 0; 534 decodeBuffer.pduBuffer_[0] = VALUE_32; 535 EXPECT_FALSE(smsWapPushHandler->DecodeXWapAbandonHeaderValue(decodeBuffer)); 536} 537 538/** 539 * @tc.number Telephony_SmsMmsGtest_SmsWapPushContentType_0001 540 * @tc.name Test SmsWapPushContentType 541 * @tc.desc Function test 542 */ 543HWTEST_F(BranchMmsTest, SmsWapPushContentType_0001, Function | MediumTest | Level1) 544{ 545 auto smsWapPushContentType = std::make_shared<SmsWapPushContentType>(); 546 SmsWapPushBuffer decodeBuffer; 547 int32_t contentLength = 1; 548 decodeBuffer.totolLength_ = 1; 549 decodeBuffer.pduBuffer_ = std::make_unique<char[]>(1); 550 decodeBuffer.pduBuffer_[0] = PDU_BUFFE_LENGTH_ONE; 551 EXPECT_FALSE(smsWapPushContentType->DecodeCTGeneralForm(decodeBuffer, contentLength)); 552 EXPECT_TRUE(smsWapPushContentType->DecodeContentType(decodeBuffer, contentLength)); 553 decodeBuffer.curPosition_ = 0; 554 decodeBuffer.pduBuffer_[0] = PDU_BUFFE_LENGTH_TWO; 555 EXPECT_TRUE(smsWapPushContentType->DecodeContentType(decodeBuffer, contentLength)); 556 decodeBuffer.curPosition_ = 0; 557 decodeBuffer.pduBuffer_[0] = 0; 558 EXPECT_FALSE(smsWapPushContentType->DecodeContentType(decodeBuffer, contentLength)); 559 EXPECT_FALSE(smsWapPushContentType->DecodeCTGeneralForm(decodeBuffer, contentLength)); 560 decodeBuffer.pduBuffer_[0] = PDU_BUFFE_LENGTH_THREE; 561 decodeBuffer.curPosition_ = 1; 562 EXPECT_FALSE(smsWapPushContentType->DecodeParameter(decodeBuffer, 1)); 563 EXPECT_FALSE(smsWapPushContentType->DecodeCTGeneralForm(decodeBuffer, contentLength)); 564 decodeBuffer.curPosition_ = 0; 565 decodeBuffer.pduBuffer_[0] = PDU_BUFFE_LENGTH_THREE; 566 EXPECT_FALSE(smsWapPushContentType->DecodeCTGeneralForm(decodeBuffer, contentLength)); 567} 568 569/** 570 * @tc.number Telephony_SmsMmsGtest_SmsWapPushContentType_0002 571 * @tc.name Test SmsWapPushContentType 572 * @tc.desc Function test 573 */ 574HWTEST_F(BranchMmsTest, SmsWapPushContentType_0002, Function | MediumTest | Level1) 575{ 576 auto smsWapPushContentType = std::make_shared<SmsWapPushContentType>(); 577 SmsWapPushBuffer decodeBuffer; 578 decodeBuffer.totolLength_ = 1; 579 decodeBuffer.pduBuffer_ = std::make_unique<char[]>(1); 580 decodeBuffer.curPosition_ = 0; 581 decodeBuffer.pduBuffer_[0] = PDU_BUFFE_LENGTH_FOUR; 582 EXPECT_FALSE(smsWapPushContentType->DecodeParameter(decodeBuffer, 1)); 583 decodeBuffer.curPosition_ = 0; 584 decodeBuffer.pduBuffer_[0] = PDU_BUFFE_LENGTH_FIVE; 585 EXPECT_FALSE(smsWapPushContentType->DecodeParameter(decodeBuffer, 1)); 586 decodeBuffer.curPosition_ = 0; 587 decodeBuffer.pduBuffer_[0] = PDU_BUFFE_LENGTH_SIX; 588 EXPECT_FALSE(smsWapPushContentType->DecodeParameter(decodeBuffer, 1)); 589 decodeBuffer.curPosition_ = 0; 590 decodeBuffer.pduBuffer_[0] = PDU_BUFFE_LENGTH_SEVEN; 591 EXPECT_FALSE(smsWapPushContentType->DecodeParameter(decodeBuffer, 1)); 592 decodeBuffer.curPosition_ = 0; 593 decodeBuffer.pduBuffer_[0] = PDU_BUFFE_LENGTH_EIGHT; 594 EXPECT_FALSE(smsWapPushContentType->DecodeParameter(decodeBuffer, 1)); 595 decodeBuffer.curPosition_ = 0; 596 decodeBuffer.pduBuffer_[0] = PDU_BUFFE_LENGTH_NINE; 597 EXPECT_FALSE(smsWapPushContentType->DecodeParameter(decodeBuffer, 1)); 598 decodeBuffer.curPosition_ = 0; 599 decodeBuffer.pduBuffer_[0] = PDU_BUFFE_LENGTH_TEN; 600 EXPECT_FALSE(smsWapPushContentType->DecodeParameter(decodeBuffer, 1)); 601 decodeBuffer.curPosition_ = 0; 602 decodeBuffer.pduBuffer_[0] = PDU_BUFFE_LENGTH_ELEVEN; 603 EXPECT_FALSE(smsWapPushContentType->DecodeParameter(decodeBuffer, 1)); 604 decodeBuffer.curPosition_ = 0; 605 decodeBuffer.pduBuffer_[0] = PDU_BUFFE_LENGTH_TWELVE; 606 EXPECT_FALSE(smsWapPushContentType->DecodeParameter(decodeBuffer, 1)); 607} 608 609/** 610 * @tc.number Telephony_SmsMmsGtest_SmsWapPushContentType_0003 611 * @tc.name Test SmsWapPushContentType 612 * @tc.desc Function test 613 */ 614HWTEST_F(BranchMmsTest, SmsWapPushContentType_0003, Function | MediumTest | Level1) 615{ 616 auto smsWapPushContentType = std::make_shared<SmsWapPushContentType>(); 617 SmsWapPushBuffer decodeBuffer; 618 int32_t valueLength = 1; 619 string strCharSet = "US-ASCII"; 620 string result = "*/*"; 621 uint32_t charSet = 1; 622 decodeBuffer.totolLength_ = 1; 623 decodeBuffer.pduBuffer_ = std::make_unique<char[]>(1); 624 decodeBuffer.pduBuffer_[0] = PDU_BUFFE_LENGTH_THIRTEEN; 625 EXPECT_FALSE(smsWapPushContentType->DecodeParameter(decodeBuffer, 1)); 626 decodeBuffer.curPosition_ = 0; 627 decodeBuffer.pduBuffer_[0] = PDU_BUFFE_LENGTH_FOURTEEN; 628 EXPECT_FALSE(smsWapPushContentType->DecodeParameter(decodeBuffer, 1)); 629 decodeBuffer.curPosition_ = 0; 630 decodeBuffer.pduBuffer_[0] = 1; 631 EXPECT_FALSE(smsWapPushContentType->DecodeParameter(decodeBuffer, VALUE_LENGTH)); 632 decodeBuffer.curPosition_ = 0; 633 decodeBuffer.pduBuffer_[0] = PDU_BUFFE_LENGTH; 634 EXPECT_FALSE(smsWapPushContentType->DecodeCharsetField(decodeBuffer, valueLength)); 635 decodeBuffer.curPosition_ = 0; 636 decodeBuffer.pduBuffer_[0] = 0; 637 EXPECT_FALSE(smsWapPushContentType->DecodeCharsetField(decodeBuffer, valueLength)); 638 decodeBuffer.curPosition_ = 0; 639 decodeBuffer.pduBuffer_[0] = PDU_BUFFE_LENGTH_TWO; 640 EXPECT_FALSE(smsWapPushContentType->DecodeCharsetField(decodeBuffer, valueLength)); 641 decodeBuffer.curPosition_ = 0; 642 decodeBuffer.pduBuffer_[0] = PDU_BUFFE_LENGTH_TWO; 643 EXPECT_TRUE(smsWapPushContentType->DecodeTypeField(decodeBuffer, valueLength)); 644 decodeBuffer.curPosition_ = 0; 645 decodeBuffer.pduBuffer_[0] = PDU_BUFFE_LENGTH_ONE; 646 EXPECT_TRUE(smsWapPushContentType->DecodeTypeField(decodeBuffer, valueLength)); 647 EXPECT_TRUE(smsWapPushContentType->GetCharSetIntFromString(charSet, strCharSet)); 648 EXPECT_EQ(smsWapPushContentType->GetContentTypeFromInt(0), result); 649} 650 651/** 652 * @tc.number Telephony_SmsMmsGtest_MmsBodyPart_0001 653 * @tc.name Test MmsBodyPart 654 * @tc.desc Function test 655 */ 656HWTEST_F(BranchMmsTest, MmsBodyPart_0001, Function | MediumTest | Level3) 657{ 658 MmsBodyPart mmsBodyPart; 659 MmsBodyPart testBodyPart; 660 mmsBodyPart = testBodyPart; 661 mmsBodyPart.AssignBodyPart(testBodyPart); 662 MmsDecodeBuffer decoderBuffer; 663 decoderBuffer.curPosition_ = 0; 664 decoderBuffer.totolLength_ = 0; 665 ASSERT_FALSE(mmsBodyPart.DecodePart(decoderBuffer)); 666 decoderBuffer.pduBuffer_[0] = 0; 667 decoderBuffer.curPosition_ = 0; 668 decoderBuffer.totolLength_ = 1; 669 ASSERT_FALSE(mmsBodyPart.DecodePart(decoderBuffer)); 670 decoderBuffer.pduBuffer_[0] = 0; 671 decoderBuffer.pduBuffer_[1] = 0; 672 decoderBuffer.curPosition_ = 0; 673 decoderBuffer.totolLength_ = 2; 674 ASSERT_FALSE(mmsBodyPart.DecodePart(decoderBuffer)); 675 decoderBuffer.pduBuffer_[0] = 0; 676 decoderBuffer.pduBuffer_[1] = 0; 677 decoderBuffer.pduBuffer_[2] = 0x70; 678 decoderBuffer.curPosition_ = 0; 679 decoderBuffer.totolLength_ = 3; 680 ASSERT_FALSE(mmsBodyPart.DecodePart(decoderBuffer)); 681 decoderBuffer.pduBuffer_[0] = 0x7F; 682 decoderBuffer.pduBuffer_[1] = 0; 683 decoderBuffer.pduBuffer_[2] = 0x70; 684 decoderBuffer.curPosition_ = 0; 685 decoderBuffer.totolLength_ = 10; 686 ASSERT_FALSE(mmsBodyPart.DecodePart(decoderBuffer)); 687 ASSERT_TRUE(mmsBodyPart.DecodePartHeader(decoderBuffer, 0)); 688 decoderBuffer.curPosition_ = 0; 689 decoderBuffer.totolLength_ = 0; 690 int32_t testLen = 3; 691 ASSERT_FALSE(mmsBodyPart.DecodePartHeader(decoderBuffer, testLen)); 692 decoderBuffer.curPosition_ = 0; 693 decoderBuffer.totolLength_ = 1; 694 decoderBuffer.pduBuffer_[0] = 0x80; 695 ASSERT_FALSE(mmsBodyPart.DecodePartHeader(decoderBuffer, testLen)); 696 decoderBuffer.curPosition_ = 0; 697 decoderBuffer.totolLength_ = 1; 698 decoderBuffer.pduBuffer_[0] = 0x20; 699 ASSERT_FALSE(mmsBodyPart.DecodePartHeader(decoderBuffer, testLen)); 700 decoderBuffer.curPosition_ = 0; 701 decoderBuffer.totolLength_ = 1; 702 decoderBuffer.pduBuffer_[0] = 0x5; 703 mmsBodyPart.DumpMmsBodyPart(); 704 ASSERT_FALSE(mmsBodyPart.DecodePartHeader(decoderBuffer, testLen)); 705} 706 707/** 708 * @tc.number Telephony_SmsMmsGtest_MmsBodyPart_0002 709 * @tc.name Test MmsBodyPart 710 * @tc.desc Function test 711 */ 712HWTEST_F(BranchMmsTest, MmsBodyPart_0002, Function | MediumTest | Level3) 713{ 714 MmsBodyPart mmsBodyPart; 715 716 MmsDecodeBuffer decoderBuffer; 717 decoderBuffer.curPosition_ = 0; 718 decoderBuffer.totolLength_ = 0; 719 ASSERT_FALSE(mmsBodyPart.DecodePartBody(decoderBuffer, 3)); 720 decoderBuffer.curPosition_ = 0; 721 int32_t offset = 2; 722 decoderBuffer.totolLength_ = MAX_MMS_MSG_PART_LEN + offset; 723 offset = 1; 724 ASSERT_FALSE(mmsBodyPart.DecodePartBody(decoderBuffer, MAX_MMS_MSG_PART_LEN + offset)); 725 MmsAttachment mmsAttachment; 726 ASSERT_FALSE(mmsBodyPart.SetAttachment(mmsAttachment)); 727 MmsEncodeBuffer encodeBuffer; 728 ASSERT_FALSE(mmsBodyPart.EncodeMmsBodyPart(encodeBuffer)); 729 mmsBodyPart.DecodeSetFileName(); 730 ASSERT_FALSE(mmsBodyPart.WriteBodyFromFile("")); 731 ASSERT_FALSE(mmsBodyPart.WriteBodyFromAttachmentBuffer(mmsAttachment)); 732 mmsAttachment.strFileName_ = "test"; 733 ASSERT_FALSE(mmsBodyPart.WriteBodyFromAttachmentBuffer(mmsAttachment)); 734 MmsBodyPart bodyPart; 735 mmsBodyPart.bodyLen_ = 1; 736 bodyPart = mmsBodyPart; 737 uint32_t len = 0; 738 ASSERT_TRUE(bodyPart.ReadBodyPartBuffer(len) == nullptr); 739 mmsBodyPart.bodyLen_ = MAX_MMS_MSG_PART_LEN + 1; 740 bodyPart = mmsBodyPart; 741 len = 0; 742 ASSERT_TRUE(bodyPart.ReadBodyPartBuffer(len) == nullptr); 743} 744 745/** 746 * @tc.number Telephony_SmsMmsGtest_MmsContentType_0001 747 * @tc.name Test MmsContentType 748 * @tc.desc Function test 749 */ 750HWTEST_F(BranchMmsTest, MmsContentType_0001, Function | MediumTest | Level3) 751{ 752 MmsContentType mmsContentType; 753 MmsContentType mmsTContentType; 754 mmsTContentType.contentType_ = "lll"; 755 mmsContentType = mmsTContentType; 756 MmsDecodeBuffer decoderBuffer; 757 int32_t testPduBuffer = 0x8f; 758 decoderBuffer.pduBuffer_[0] = testPduBuffer; 759 decoderBuffer.curPosition_ = 0; 760 decoderBuffer.totolLength_ = 1; 761 int32_t length; 762 ASSERT_TRUE(mmsContentType.DecodeMmsContentType(decoderBuffer, length)); 763 decoderBuffer.curPosition_ = 0; 764 decoderBuffer.totolLength_ = 1; 765 testPduBuffer = 0x2f; 766 decoderBuffer.pduBuffer_[0] = testPduBuffer; 767 ASSERT_FALSE(mmsContentType.DecodeMmsCTGeneralForm(decoderBuffer, length)); 768 decoderBuffer.curPosition_ = 0; 769 decoderBuffer.totolLength_ = 0; 770 ASSERT_FALSE(mmsContentType.DecodeMmsCTGeneralForm(decoderBuffer, length)); 771 decoderBuffer.curPosition_ = 0; 772 decoderBuffer.totolLength_ = 1; 773 testPduBuffer = 0x8f; 774 decoderBuffer.pduBuffer_[0] = testPduBuffer; 775 ASSERT_FALSE(mmsContentType.DecodeMmsCTGeneralForm(decoderBuffer, length)); 776 decoderBuffer.curPosition_ = 0; 777 decoderBuffer.totolLength_ = 1; 778 decoderBuffer.pduBuffer_[0] = 0; 779 ASSERT_FALSE(mmsContentType.DecodeMmsCTGeneralForm(decoderBuffer, length)); 780} 781 782/** 783 * @tc.number Telephony_SmsMmsGtest_MmsContentType_0002 784 * @tc.name Test MmsContentType 785 * @tc.desc Function test 786 */ 787HWTEST_F(BranchMmsTest, MmsContentType_0002, Function | MediumTest | Level3) 788{ 789 MmsContentType mmsContentType; 790 MmsDecodeBuffer decoderBuffer; 791 ASSERT_TRUE(mmsContentType.DecodeParameter(decoderBuffer, 0)); 792 decoderBuffer.curPosition_ = 0; 793 decoderBuffer.totolLength_ = 0; 794 ASSERT_FALSE(mmsContentType.DecodeParameter(decoderBuffer, 1)); 795 int32_t testPduBuffer = 129; 796 decoderBuffer.pduBuffer_[0] = testPduBuffer; 797 decoderBuffer.curPosition_ = 0; 798 decoderBuffer.totolLength_ = 1; 799 ASSERT_FALSE(mmsContentType.DecodeParameter(decoderBuffer, 1)); 800 testPduBuffer = 154; 801 decoderBuffer.pduBuffer_[0] = testPduBuffer; 802 decoderBuffer.curPosition_ = 0; 803 decoderBuffer.totolLength_ = 1; 804 ASSERT_FALSE(mmsContentType.DecodeParameter(decoderBuffer, 1)); 805 testPduBuffer = 137; 806 decoderBuffer.pduBuffer_[0] = testPduBuffer; 807 decoderBuffer.curPosition_ = 0; 808 decoderBuffer.totolLength_ = 1; 809 ASSERT_FALSE(mmsContentType.DecodeParameter(decoderBuffer, 1)); 810 decoderBuffer.pduBuffer_[0] = 0; 811 decoderBuffer.curPosition_ = 0; 812 decoderBuffer.totolLength_ = 1; 813 ASSERT_FALSE(mmsContentType.DecodeParameter(decoderBuffer, 4)); 814 decoderBuffer.curPosition_ = 0; 815 decoderBuffer.totolLength_ = 0; 816 int32_t len; 817 ASSERT_FALSE(mmsContentType.DecodeTextField(decoderBuffer, 0, len)); 818 ASSERT_FALSE(mmsContentType.DecodeCharsetField(decoderBuffer, len)); 819 testPduBuffer = 100; 820 decoderBuffer.pduBuffer_[0] = testPduBuffer; 821 decoderBuffer.curPosition_ = 0; 822 decoderBuffer.totolLength_ = 1; 823 ASSERT_FALSE(mmsContentType.DecodeCharsetField(decoderBuffer, len)); 824 testPduBuffer = 30; 825 decoderBuffer.pduBuffer_[0] = testPduBuffer; 826 decoderBuffer.curPosition_ = 0; 827 decoderBuffer.totolLength_ = 1; 828 ASSERT_FALSE(mmsContentType.DecodeCharsetField(decoderBuffer, len)); 829} 830 831/** 832 * @tc.number Telephony_SmsMmsGtest_MmsContentType_0003 833 * @tc.name Test MmsContentType 834 * @tc.desc Function test 835 */ 836HWTEST_F(BranchMmsTest, MmsContentType_0003, Function | MediumTest | Level3) 837{ 838 MmsEncodeBuffer mmsEncodeBuffer; 839 MmsContentType mmsContentType; 840 MmsDecodeBuffer decoderBuffer; 841 decoderBuffer.curPosition_ = 0; 842 decoderBuffer.totolLength_ = 0; 843 int32_t valueLen = 0; 844 ASSERT_FALSE(mmsContentType.DecodeTypeField(decoderBuffer, valueLen)); 845 decoderBuffer.pduBuffer_[0] = 0x8f; 846 decoderBuffer.curPosition_ = 0; 847 decoderBuffer.totolLength_ = 1; 848 ASSERT_TRUE(mmsContentType.DecodeTypeField(decoderBuffer, valueLen)); 849 decoderBuffer.pduBuffer_[0] = 0; 850 decoderBuffer.curPosition_ = 0; 851 decoderBuffer.totolLength_ = 1; 852 ASSERT_FALSE(mmsContentType.DecodeTypeField(decoderBuffer, valueLen)); 853 mmsContentType.msgContentParm_.textMap_[152] = ""; 854 int32_t offset = 1; 855 mmsEncodeBuffer.curPosition_ = CODE_BUFFER_MAX_SIZE + offset; 856 mmsContentType.EncodeTextField(mmsEncodeBuffer); 857 mmsContentType.msgContentParm_.textMap_[152] = ""; 858 mmsEncodeBuffer.curPosition_ = 0; 859 ASSERT_TRUE(mmsContentType.EncodeTextField(mmsEncodeBuffer)); 860 ASSERT_TRUE(mmsContentType.EncodeCharsetField(mmsEncodeBuffer)); 861 mmsContentType.msgContentParm_.charset_ = offset; 862 ASSERT_TRUE(mmsContentType.EncodeCharsetField(mmsEncodeBuffer)); 863 mmsContentType.msgContentParm_.charset_ = offset; 864 mmsEncodeBuffer.curPosition_ = CODE_BUFFER_MAX_SIZE + offset; 865 mmsContentType.EncodeCharsetField(mmsEncodeBuffer); 866 mmsContentType.msgContentParm_.charset_ = offset; 867 mmsEncodeBuffer.curPosition_ = CODE_BUFFER_MAX_SIZE - offset; 868 mmsContentType.EncodeCharsetField(mmsEncodeBuffer); 869 mmsContentType.msgContentParm_.charset_ = offset; 870 mmsEncodeBuffer.curPosition_ = 0; 871 ASSERT_TRUE(mmsContentType.EncodeCharsetField(mmsEncodeBuffer)); 872} 873 874/** 875 * @tc.number Telephony_SmsMmsGtest_MmsContentType_0004 876 * @tc.name Test MmsContentType 877 * @tc.desc Function test 878 */ 879HWTEST_F(BranchMmsTest, MmsContentType_0004, Function | MediumTest | Level3) 880{ 881 MmsContentType mmsContentType; 882 MmsEncodeBuffer mmsEncodeBuffer; 883 ASSERT_TRUE(mmsContentType.EncodeTypeField(mmsEncodeBuffer)); 884 mmsContentType.msgContentParm_.type_ = "1"; 885 int32_t offset = 1; 886 mmsEncodeBuffer.curPosition_ = CODE_BUFFER_MAX_SIZE + offset; 887 ASSERT_FALSE(mmsContentType.EncodeTypeField(mmsEncodeBuffer)); 888 mmsContentType.msgContentParm_.type_ = "1"; 889 mmsEncodeBuffer.curPosition_ = CODE_BUFFER_MAX_SIZE - offset; 890 ASSERT_FALSE(mmsContentType.EncodeTypeField(mmsEncodeBuffer)); 891 mmsContentType.msgContentParm_.type_ = "1"; 892 mmsEncodeBuffer.curPosition_ = CODE_BUFFER_MAX_SIZE - offset; 893 ASSERT_FALSE(mmsContentType.EncodeTypeField(mmsEncodeBuffer)); 894 mmsContentType.msgContentParm_.textMap_[152] = ""; 895 mmsEncodeBuffer.curPosition_ = CODE_BUFFER_MAX_SIZE + offset; 896 ASSERT_FALSE(mmsContentType.EncodeMmsBodyPartContentParam(mmsEncodeBuffer)); 897 mmsContentType.msgContentParm_.textMap_[152] = ""; 898 mmsEncodeBuffer.curPosition_ = CODE_BUFFER_MAX_SIZE - offset; 899 ASSERT_FALSE(mmsContentType.EncodeMmsBodyPartContentParam(mmsEncodeBuffer)); 900 mmsContentType.msgContentParm_.textMap_[152] = ""; 901 offset = 2; 902 mmsEncodeBuffer.curPosition_ = CODE_BUFFER_MAX_SIZE - offset; 903 ASSERT_FALSE(mmsContentType.EncodeMmsBodyPartContentParam(mmsEncodeBuffer)); 904 mmsContentType.contentType_ = ""; 905 ASSERT_FALSE(mmsContentType.EncodeMmsBodyPartContentType(mmsEncodeBuffer)); 906 mmsContentType.contentType_ = "*/*"; 907 ASSERT_FALSE(mmsContentType.EncodeMmsBodyPartContentType(mmsEncodeBuffer)); 908 mmsEncodeBuffer.curPosition_ = CODE_BUFFER_MAX_SIZE + offset; 909 ASSERT_FALSE(mmsContentType.EncodeMmsBodyPartContentType(mmsEncodeBuffer)); 910} 911 912/** 913 914 * @tc.number Telephony_SmsMmsGtest_MmsBody_0001 915 * @tc.name Test MmsBody 916 * @tc.desc Function test 917 */ 918HWTEST_F(BranchMmsTest, SmsMmsGtest_MmsBody_0001, Function | MediumTest | Level1) 919{ 920 MmsBody mmsBody; 921 MmsDecodeBuffer mmsDecodeBuffer; 922 MmsHeader mmsHeader; 923 MmsEncodeBuffer mmsEncodeBuffer; 924 MmsBodyPart mmsBodyPart; 925 mmsDecodeBuffer.curPosition_ = 0; 926 mmsDecodeBuffer.totolLength_ = PDU_COUNT; 927 MmsBodyPart part; 928 mmsBody.mmsBodyParts_.push_back(part); 929 EXPECT_TRUE(mmsBody.DecodeMultipart(mmsDecodeBuffer)); 930 EXPECT_FALSE(mmsBody.DecodeMmsBody(mmsDecodeBuffer, mmsHeader)); 931 EXPECT_FALSE(mmsBody.EncodeMmsBody(mmsEncodeBuffer)); 932 EXPECT_FALSE(mmsBody.EncodeMmsHeaderContentType(mmsHeader, mmsEncodeBuffer)); 933 EXPECT_TRUE(mmsBody.IsContentLocationPartExist("")); 934 EXPECT_TRUE(mmsBody.IsContentIdPartExist("")); 935 mmsBody.DumpMmsBody(); 936 mmsBody.GetBodyPartCount(); 937 std::vector<MmsBodyPart> parts; 938 mmsBody.GetMmsBodyPart(parts); 939 940 mmsDecodeBuffer.curPosition_ = PDU_COUNT; 941 mmsDecodeBuffer.totolLength_ = 0; 942 EXPECT_FALSE(mmsBody.DecodeMultipart(mmsDecodeBuffer)); 943 EXPECT_FALSE(mmsBody.DecodeMmsBody(mmsDecodeBuffer, mmsHeader)); 944 EXPECT_FALSE(mmsBody.EncodeMmsBody(mmsEncodeBuffer)); 945 EXPECT_FALSE(mmsBody.EncodeMmsHeaderContentType(mmsHeader, mmsEncodeBuffer)); 946 EXPECT_TRUE(mmsBody.IsContentLocationPartExist("")); 947 EXPECT_TRUE(mmsBody.IsContentIdPartExist("")); 948 949 EXPECT_TRUE(mmsBody.IsBodyPartExist(mmsBodyPart)); 950 EXPECT_TRUE(mmsBody.AddMmsBodyPart(mmsBodyPart)); 951 mmsBodyPart.isSmilFile_ = true; 952 EXPECT_TRUE(mmsBody.AddMmsBodyPart(mmsBodyPart)); 953 mmsBodyPart.isSmilFile_ = false; 954 mmsBody.bHaveSmilPart_ = true; 955 EXPECT_TRUE(mmsBody.AddMmsBodyPart(mmsBodyPart)); 956 mmsBodyPart.isSmilFile_ = true; 957 mmsBodyPart.SetSmilFile(false); 958 mmsBodyPart.IsSmilFile(); 959 EXPECT_TRUE(mmsBody.AddMmsBodyPart(mmsBodyPart)); 960} 961 962/** 963 964 * @tc.number Telephony_SmsMmsGtest_MmsBody_0002 965 * @tc.name Test MmsBody 966 * @tc.desc Function test 967 */ 968HWTEST_F(BranchMmsTest, SmsMmsGtest_MmsBody_0002, Function | MediumTest | Level1) 969{ 970 MmsBody mmsBody; 971 MmsDecodeBuffer mmsDecodeBuffer; 972 MmsHeader mmsHeader; 973 MmsEncodeBuffer mmsEncodeBuffer; 974 MmsBodyPart mmsBodyPart; 975 mmsDecodeBuffer.curPosition_ = 0; 976 mmsDecodeBuffer.totolLength_ = PDU_COUNT; 977 MmsBodyPart part; 978 std::string strCt = INPUT_STR; 979 std::string getCt; 980 part.SetContentType(strCt); 981 part.GetContentType(getCt); 982 EXPECT_STREQ(strCt.c_str(), getCt.c_str()); 983 part.SetContentId(strCt); 984 part.GetContentId(getCt); 985 EXPECT_STREQ(strCt.c_str(), getCt.c_str()); 986 part.SetContentLocation(strCt); 987 part.GetContentLocation(getCt); 988 EXPECT_STREQ(strCt.c_str(), getCt.c_str()); 989 part.SetContentDisposition(strCt); 990 part.GetContentDisposition(getCt); 991 EXPECT_STREQ(strCt.c_str(), getCt.c_str()); 992 part.SetFileName(strCt); 993 EXPECT_STREQ(strCt.c_str(), part.GetPartFileName().c_str()); 994 part.GetContentType(); 995 part.GetPartHeader(); 996 EXPECT_STREQ(strCt.c_str(), getCt.c_str()); 997 mmsBody.mmsBodyParts_.push_back(part); 998 EXPECT_TRUE(mmsBody.AddMmsBodyPart(mmsBodyPart)); 999} 1000 1001/** 1002 * @tc.number Telephony_SmsMmsGtest_MmsMsg_0001 1003 * @tc.name Test MmsMsg 1004 * @tc.desc Function test 1005 */ 1006HWTEST_F(BranchMmsTest, SmsMmsGtest_MmsMsg_0001, Function | MediumTest | Level1) 1007{ 1008 MmsMsg mmsMsg; 1009 uint32_t outLen; 1010 std::vector<MmsAddress> toAddrs = {}; 1011 MmsAttachment mmsAttachment; 1012 std::vector<MmsAttachment> attachments = {}; 1013 EXPECT_FALSE(mmsMsg.DecodeMsg("")); 1014 EXPECT_FALSE(mmsMsg.DecodeMsg(nullptr, 0)); 1015 mmsMsg.EncodeMsg(outLen); 1016 MmsAddress address(INPUT_STR); 1017 mmsMsg.SetMmsFrom(address); 1018 mmsMsg.GetMmsFrom(); 1019 EXPECT_FALSE(mmsMsg.SetMmsTo(toAddrs)); 1020 std::string value = INPUT_STR; 1021 mmsMsg.SetHeaderStringValue(0, value); 1022 mmsMsg.GetHeaderStringValue(0); 1023 mmsMsg.GetHeaderContentTypeStart(); 1024 EXPECT_FALSE(mmsMsg.AddAttachment(mmsAttachment)); 1025 EXPECT_FALSE(mmsMsg.GetAllAttachment(attachments)); 1026} 1027 1028/** 1029 * @tc.number Telephony_SmsMmsGtest_MmsMsg_0002 1030 * @tc.name Test MmsMsg 1031 * @tc.desc Function test 1032 */ 1033HWTEST_F(BranchMmsTest, SmsMmsGtest_MmsMsg_0002, Function | MediumTest | Level1) 1034{ 1035 MmsMsg mmsMsg; 1036 std::vector<MmsAddress> toAddrs = {}; 1037 MmsAttachment mmsAttachment; 1038 std::vector<MmsAttachment> attachments = {}; 1039 std::unique_ptr<char[]> inBuff = std::make_unique<char[]>(2); 1040 inBuff[0] = 1; 1041 inBuff[1] = 1; 1042 EXPECT_FALSE(mmsMsg.DecodeMsg(std::move(inBuff), 2)); 1043 1044 mmsMsg.SetMmsVersion(1); 1045 mmsMsg.GetMmsVersion(); 1046 mmsMsg.SetMmsMessageType(1); 1047 mmsMsg.GetMmsMessageType(); 1048 mmsMsg.SetMmsTransactionId("1"); 1049 mmsMsg.GetMmsTransactionId(); 1050 mmsMsg.SetMmsDate(1); 1051 mmsMsg.GetMmsDate(); 1052 EXPECT_FALSE(mmsMsg.SetMmsTo(toAddrs)); 1053 mmsMsg.GetMmsTo(toAddrs); 1054 mmsMsg.SetHeaderOctetValue(0, 0); 1055 mmsMsg.GetHeaderOctetValue(0); 1056 mmsMsg.SetHeaderIntegerValue(0, 0); 1057 mmsMsg.GetHeaderIntegerValue(0); 1058 mmsMsg.SetHeaderLongValue(0, 0); 1059 mmsMsg.GetHeaderLongValue(0); 1060 1061 mmsMsg.SetHeaderEncodedStringValue(0, INPUT_STR, 0); 1062 MmsAddress address(INPUT_STR); 1063 mmsMsg.AddHeaderAddressValue(0, address); 1064 std::vector<MmsAddress> addressValue; 1065 mmsMsg.GetHeaderAllAddressValue(0, addressValue); 1066 mmsMsg.SetHeaderContentType(INPUT_STR); 1067 mmsMsg.GetHeaderContentType(); 1068 mmsMsg.GetHeaderContentTypeStart(); 1069 EXPECT_FALSE(mmsMsg.AddAttachment(mmsAttachment)); 1070 EXPECT_FALSE(mmsMsg.GetAllAttachment(attachments)); 1071} 1072 1073/** 1074 * @tc.number Telephony_SmsMmsGtest_MmsBodyPartHeader_0001 1075 * @tc.name Test MmsBodyPartHeader 1076 * @tc.desc Function test 1077 */ 1078HWTEST_F(BranchMmsTest, MmsBodyPartHeader_0001, Function | MediumTest | Level1) 1079{ 1080 auto mmsBodyPartHeader = std::make_shared<MmsBodyPartHeader>(); 1081 MmsDecodeBuffer decodeBuffer; 1082 uint32_t len = 1; 1083 decodeBuffer.curPosition_ = 0; 1084 decodeBuffer.totolLength_ = 0; 1085 EXPECT_FALSE(mmsBodyPartHeader->DecodeContentDisposition(decodeBuffer, len)); 1086 EXPECT_FALSE(mmsBodyPartHeader->DecodeContentLocation(decodeBuffer, len)); 1087 EXPECT_FALSE(mmsBodyPartHeader->DecodeContentId(decodeBuffer, len)); 1088 1089 uint32_t dispLen = 1; 1090 uint32_t beginPos = 1; 1091 EXPECT_TRUE(mmsBodyPartHeader->DecodeDispositionParameter(decodeBuffer, dispLen, beginPos)); 1092 EXPECT_FALSE(mmsBodyPartHeader->DecodeWellKnownHeader(decodeBuffer, len)); 1093 EXPECT_FALSE(mmsBodyPartHeader->DecodeApplicationHeader(decodeBuffer, len)); 1094 1095 std::string str = TEST_STR; 1096 mmsBodyPartHeader->SetContentId(str); 1097 EXPECT_TRUE(mmsBodyPartHeader->GetContentId(str)); 1098 mmsBodyPartHeader->SetContentTransferEncoding(str); 1099 EXPECT_TRUE(mmsBodyPartHeader->GetContentTransferEncoding(str)); 1100 mmsBodyPartHeader->SetContentLocation(str); 1101 EXPECT_TRUE(mmsBodyPartHeader->GetContentDisposition(str)); 1102 1103 MmsEncodeBuffer encodeBuffer; 1104 mmsBodyPartHeader->strContentTransferEncoding_ = ""; 1105 EXPECT_TRUE(mmsBodyPartHeader->EncodeContentTransferEncoding(encodeBuffer)); 1106 EXPECT_TRUE(mmsBodyPartHeader->EncodeContentLocation(encodeBuffer)); 1107 1108 mmsBodyPartHeader->strContentTransferEncoding_ = str; 1109 EXPECT_TRUE(mmsBodyPartHeader->EncodeContentLocation(encodeBuffer)); 1110 EXPECT_TRUE(mmsBodyPartHeader->EncodeContentId(encodeBuffer)); 1111 EXPECT_TRUE(mmsBodyPartHeader->EncodeContentDisposition(encodeBuffer)); 1112 1113 encodeBuffer.curPosition_ = CODE_BUFFER_MAX_SIZE; 1114 mmsBodyPartHeader->strContentLocation_ = SRC_STR; 1115 EXPECT_FALSE(mmsBodyPartHeader->EncodeMmsBodyPartHeader(encodeBuffer)); 1116 mmsBodyPartHeader->strContentID_ = SRC_STR; 1117 encodeBuffer.curPosition_ = CODE_BUFFER_MAX_SIZE; 1118 auto otherBodyPartHeader = std::make_shared<MmsBodyPartHeader>(); 1119 *otherBodyPartHeader = *mmsBodyPartHeader; 1120 otherBodyPartHeader->DumpBodyPartHeader(); 1121 EXPECT_FALSE(mmsBodyPartHeader->EncodeContentLocation(encodeBuffer)); 1122 EXPECT_FALSE(mmsBodyPartHeader->EncodeContentId(encodeBuffer)); 1123 EXPECT_FALSE(mmsBodyPartHeader->EncodeMmsBodyPartHeader(encodeBuffer)); 1124} 1125 1126/** 1127 * @tc.number Telephony_SmsMmsGtest_MmsBuffer_0002 1128 * @tc.name Test MmsBuffer 1129 * @tc.desc Function test 1130 */ 1131HWTEST_F(BranchMmsTest, MmsBuffer_0002, Function | MediumTest | Level1) 1132{ 1133 TELEPHONY_LOGI("TelSMSMMSTest::MmsBuffer_0002 -->"); 1134 MmsBuffer mmsBuffer; 1135 uint32_t len = 1; 1136 bool retBool; 1137 mmsBuffer.ReadDataBuffer(len); 1138 mmsBuffer.ReadDataBuffer(len, MAX_MMS_MSG_PART_LEN + 1); 1139 mmsBuffer.ReadDataBuffer(MAX_MMS_MSG_PART_LEN, len); 1140 retBool = mmsBuffer.WriteDataBuffer(nullptr, 0); 1141 retBool = mmsBuffer.WriteDataBuffer(std::make_unique<char[]>(len), MAX_MMS_MSG_PART_LEN + 1); 1142 retBool = mmsBuffer.WriteDataBuffer(std::make_unique<char[]>(len), 0); 1143 EXPECT_FALSE(retBool); 1144 retBool = mmsBuffer.WriteDataBuffer(std::make_unique<char[]>(len), len); 1145 EXPECT_TRUE(retBool); 1146} 1147 1148/** 1149 * @tc.number Telephony_SmsMmsGtest_MmsConnCallback_0001 1150 * @tc.name Test MmsConnCallback 1151 * @tc.desc Function test 1152 */ 1153HWTEST_F(BranchMmsTest, MmsConnCallback_0001, Function | MediumTest | Level1) 1154{ 1155 TELEPHONY_LOGI("TelSMSMMSTest::MmsConnCallback_0001 -->"); 1156 MmsConnCallbackStub connCallback; 1157 sptr<NetManagerStandard::NetHandle> nullHandle; 1158 sptr<NetManagerStandard::NetAllCapabilities> nullCap; 1159 sptr<NetManagerStandard::NetLinkInfo> nullInfo; 1160 connCallback.SyncNetworkResponse(true); 1161 EXPECT_EQ(connCallback.NetAvailable(nullHandle), TELEPHONY_ERR_FAIL); 1162 EXPECT_EQ(connCallback.NetCapabilitiesChange(nullHandle, nullCap), ERR_NONE); 1163 EXPECT_EQ(connCallback.NetConnectionPropertiesChange(nullHandle, nullInfo), ERR_NONE); 1164 EXPECT_EQ(connCallback.NetLost(nullHandle), ERR_NONE); 1165 EXPECT_EQ(connCallback.NetUnavailable(), ERR_NONE); 1166 EXPECT_EQ(connCallback.NetBlockStatusChange(nullHandle, false), ERR_NONE); 1167} 1168 1169/** 1170 * @tc.number Telephony_SmsMmsGtest_MmsNetworkManager_0001 1171 * @tc.name Test MmsNetworkManager 1172 * @tc.desc Function test 1173 */ 1174HWTEST_F(BranchMmsTest, MmsNetworkManager_0001, Function | MediumTest | Level1) 1175{ 1176 TELEPHONY_LOGI("TelSMSMMSTest::MmsNetworkManager_0001 -->"); 1177 MmsNetworkManager mmsNetworkMgr; 1178 EXPECT_GE(mmsNetworkMgr.AcquireNetwork(0, 0), 0); 1179 mmsNetworkMgr.ReleaseNetwork(0, 0); 1180 EXPECT_NE(mmsNetworkMgr.GetOrCreateHttpClient(0), nullptr); 1181} 1182 1183/** 1184 * @tc.number Telephony_SmsMmsGtest_MmsNetworkClient_0001 1185 * @tc.name Test MmsNetworkClient 1186 * @tc.desc Function test 1187 */ 1188HWTEST_F(BranchMmsTest, MmsNetworkClient_0001, Function | MediumTest | Level1) 1189{ 1190 TELEPHONY_LOGI("TelSMSMMSTest::MmsNetworkClient_0001 -->"); 1191 AccessMmsToken token; 1192 MmsNetworkClient client(0); 1193 client.GetIfaceName(); 1194 std::string storeDirName; 1195 client.Execute(METHOD_POST, "", storeDirName, "ua", "uaprof"); 1196 client.Execute(METHOD_GET, "", storeDirName, "ua", "uaprof"); 1197 client.HttpRequest(METHOD_POST, "", TEST_DATA, "ua", "uaprof"); 1198 client.DeleteMmsPdu(""); 1199 1200 MmsNetworkClient clientSlot1(1); 1201 clientSlot1.Execute(METHOD_POST, "", storeDirName, "ua", "uaprof"); 1202 clientSlot1.HttpRequest(METHOD_POST, "", storeDirName, "ua", "uaprof"); 1203 client.responseData_ = ""; 1204 1205 std::string strBuf = TEST_DATA; 1206 EXPECT_EQ(client.GetMmsPduFromFile(storeDirName, strBuf), false); 1207 EXPECT_EQ(client.GetMmsPduFromFile(TEST_PATH, strBuf), false); 1208 1209 std::unique_ptr<char[]> bufp = std::make_unique<char[]>(BUF_LEN); 1210 EXPECT_EQ(client.WriteBufferToFile(nullptr, BUF_LEN, storeDirName), false); 1211 EXPECT_EQ(client.WriteBufferToFile(bufp, BUF_LEN, storeDirName), false); 1212 EXPECT_EQ(client.WriteBufferToFile(bufp, BUF_LEN, storeDirName), false); 1213} 1214 1215/** 1216 * @tc.number Telephony_SmsMmsGtest_MmsPersistHelper_0001 1217 * @tc.name Test MmsPersistHelper 1218 * @tc.desc Function test 1219 */ 1220HWTEST_F(BranchMmsTest, MmsPersistHelper_0001, Function | MediumTest | Level1) 1221{ 1222 TELEPHONY_LOGI("TelSMSMMSTest::PersistHelper_0001 -->"); 1223 MmsPersistHelper persistHelper; 1224 1225 std::string urlStr = TEST_URLS; 1226 std::vector<std::string> urls = persistHelper.SplitUrl(urlStr); 1227 EXPECT_EQ(urls.size(), URL_COUNT); 1228 1229 std::string *pduData = new (std::nothrow) std::string(SPLIT_PDU_COUNT * SPLIT_PDU_LENGTH, 'a'); 1230 std::vector<std::string> pdus = persistHelper.SplitPdu(*pduData); 1231 EXPECT_EQ(pdus.size(), SPLIT_PDU_COUNT * 2); 1232 delete pduData; 1233 1234 persistHelper.SetMmsPdu(TEST_DATA); 1235 persistHelper.GetMmsPdu(TEST_PATH); 1236 persistHelper.DeleteMmsPdu(TEST_PATH); 1237 std::string dbUrl; 1238 EXPECT_FALSE(persistHelper.InsertMmsPdu(TEST_DATA, dbUrl)); 1239} 1240 1241/** 1242 * @tc.number Telephony_SmsMmsGtest_MmsPersistHelper_0002 1243 * @tc.name Test MmsPersistHelper 1244 * @tc.desc Function test 1245 */ 1246HWTEST_F(BranchMmsTest, MmsPersistHelper_0002, Function | MediumTest | Level1) 1247{ 1248 TELEPHONY_LOGI("TelSMSMMSTest::PersistHelper_0002 -->"); 1249 AccessMmsToken token; 1250 MmsPersistHelper persistHelper; 1251 1252 persistHelper.SetMmsPdu(TEST_DATA); 1253 persistHelper.GetMmsPdu(TEST_PATH); 1254 persistHelper.DeleteMmsPdu(TEST_PATH); 1255 std::string dbUrl; 1256 EXPECT_FALSE(persistHelper.InsertMmsPdu(TEST_DATA, dbUrl)); 1257} 1258 1259/** 1260 * @tc.number Telephony_SmsMmsGtest_MmsPersistHelper_0003 1261 * @tc.name Test MmsPersistHelper 1262 * @tc.desc Function test 1263 */ 1264HWTEST_F(BranchMmsTest, MmsPersistHelper_0003, Function | MediumTest | Level1) 1265{ 1266 AccessMmsToken token; 1267 auto mmsPersistHelper = DelayedSingleton<MmsPersistHelper>::GetInstance(); 1268 std::string dbUrl = "1,"; 1269 mmsPersistHelper->DeleteMmsPdu(dbUrl); 1270 std::string mmsPdu = "text"; 1271 mmsPersistHelper->InsertMmsPdu(mmsPdu, dbUrl); 1272 mmsPersistHelper->GetMmsPdu(dbUrl); 1273 EXPECT_TRUE(mmsPersistHelper != nullptr); 1274} 1275 1276/** 1277 * @tc.number Telephony_SmsMmsGtest_MmsEncodeBuffer_0001 1278 * @tc.name Test MmsEncodeBuffer 1279 * @tc.desc Function test 1280 */ 1281HWTEST_F(BranchMmsTest, MmsEncodeBuffer_0001, Function | MediumTest | Level1) 1282{ 1283 TELEPHONY_LOGI("TelSMSMMSTest::MmsEncodeBuffer_0001 -->"); 1284 MmsEncodeBuffer mmsEncodeBuffer; 1285 bool retBool; 1286 retBool = mmsEncodeBuffer.EncodeShortLength(1); 1287 EXPECT_TRUE(retBool); 1288 retBool = mmsEncodeBuffer.EncodeShortLength(31); 1289 EXPECT_FALSE(retBool); 1290 1291 retBool = mmsEncodeBuffer.EncodeShortInteger(1); 1292 EXPECT_TRUE(retBool); 1293 retBool = mmsEncodeBuffer.EncodeShortLength(31); 1294 EXPECT_FALSE(retBool); 1295 mmsEncodeBuffer.curPosition_ = MAX_MMS_MSG_PART_LEN + 1; 1296 retBool = mmsEncodeBuffer.EncodeShortLength(1); 1297 EXPECT_FALSE(retBool); 1298 1299 mmsEncodeBuffer.curPosition_ = 0; 1300 retBool = mmsEncodeBuffer.EncodeOctet(1); 1301 EXPECT_TRUE(retBool); 1302 mmsEncodeBuffer.curPosition_ = MAX_MMS_MSG_PART_LEN + 1; 1303 retBool = mmsEncodeBuffer.EncodeShortLength(1); 1304 EXPECT_FALSE(retBool); 1305 1306 mmsEncodeBuffer.curPosition_ = 0; 1307 retBool = mmsEncodeBuffer.EncodeValueLength(1); 1308 EXPECT_TRUE(retBool); 1309 retBool = mmsEncodeBuffer.EncodeValueLength(31); 1310 EXPECT_TRUE(retBool); 1311 retBool = mmsEncodeBuffer.EncodeValueLength(31); 1312 mmsEncodeBuffer.curPosition_ = MAX_MMS_MSG_PART_LEN + 1; 1313 EXPECT_TRUE(retBool); 1314} 1315 1316/** 1317 * @tc.number Telephony_SmsMmsGtest_MmsEncodeBuffer_0002 1318 * @tc.name Test MmsEncodeBuffer 1319 * @tc.desc Function test 1320 */ 1321HWTEST_F(BranchMmsTest, MmsEncodeBuffer_0002, Function | MediumTest | Level1) 1322{ 1323 TELEPHONY_LOGI("TelSMSMMSTest::MmsEncodeBuffer_0002 -->"); 1324 MmsEncodeBuffer mmsEncodeBuffer; 1325 bool retBool; 1326 mmsEncodeBuffer.curPosition_ = 0; 1327 retBool = mmsEncodeBuffer.EncodeInteger(1); 1328 EXPECT_TRUE(retBool); 1329 retBool = mmsEncodeBuffer.EncodeInteger(INPUT_INTEGER); 1330 EXPECT_TRUE(retBool); 1331 1332 retBool = mmsEncodeBuffer.EncodeLongInteger(0); 1333 EXPECT_TRUE(retBool); 1334 retBool = mmsEncodeBuffer.EncodeLongInteger(1); 1335 EXPECT_TRUE(retBool); 1336 1337 retBool = mmsEncodeBuffer.EncodeQuotedText(""); 1338 EXPECT_TRUE(retBool); 1339 mmsEncodeBuffer.curPosition_ = MAX_MMS_MSG_PART_LEN + 1; 1340 retBool = mmsEncodeBuffer.EncodeQuotedText(BEGIN_STR); 1341 EXPECT_FALSE(retBool); 1342 mmsEncodeBuffer.curPosition_ = 0; 1343 retBool = mmsEncodeBuffer.EncodeQuotedText(END_STR); 1344 EXPECT_TRUE(retBool); 1345 1346 retBool = mmsEncodeBuffer.EncodeTokenText(""); 1347 EXPECT_TRUE(retBool); 1348 mmsEncodeBuffer.curPosition_ = MAX_MMS_MSG_PART_LEN + 1; 1349 retBool = mmsEncodeBuffer.EncodeTokenText(BEGIN_STR); 1350 EXPECT_FALSE(retBool); 1351 mmsEncodeBuffer.curPosition_ = 0; 1352 retBool = mmsEncodeBuffer.EncodeTokenText(END_STR); 1353 EXPECT_TRUE(retBool); 1354} 1355 1356/** 1357 * @tc.number Telephony_SmsMmsGtest_SendMms_0001 1358 * @tc.name Test SendMms_0001 1359 * @tc.desc Function test 1360 */ 1361HWTEST_F(BranchMmsTest, SendMms_0001, Function | MediumTest | Level1) 1362{ 1363 std::shared_ptr<SmsService> smsService = std::make_shared<SmsService>(); 1364 int32_t slotId = 0; 1365 std::u16string mmsc = u""; 1366 std::u16string data = u""; 1367 std::u16string ua = u""; 1368 std::u16string uaprof = u""; 1369 int64_t time = 0; 1370 int32_t notAccess = smsService->SendMms(slotId, mmsc, data, ua, uaprof, time); 1371 AccessMmsToken token; 1372 int32_t noMmsc = smsService->SendMms(slotId, mmsc, data, ua, uaprof, time); 1373 mmsc = StringUtils::ToUtf16(VNET_MMSC); 1374 int32_t noData = smsService->SendMms(slotId, mmsc, data, ua, uaprof, time); 1375 EXPECT_GE(notAccess, 0); 1376 EXPECT_GE(noMmsc, 0); 1377 EXPECT_GE(noData, 0); 1378} 1379 1380/** 1381 * @tc.number Telephony_SmsMmsGtest_DownloadMms_0001 1382 * @tc.name Test DownloadMms_0001 1383 * @tc.desc Function test 1384 */ 1385HWTEST_F(BranchMmsTest, DownloadMms_0001, Function | MediumTest | Level1) 1386{ 1387 std::shared_ptr<SmsService> smsService = std::make_shared<SmsService>(); 1388 int32_t slotId = 0; 1389 std::u16string mmsc = u""; 1390 std::u16string data = u""; 1391 std::u16string ua = u""; 1392 std::u16string uaprof = u""; 1393 int64_t time = 0; 1394 int32_t notAccess = smsService->DownloadMms(slotId, mmsc, data, ua, uaprof); 1395 AccessMmsToken token; 1396 int32_t noMmsc = smsService->DownloadMms(slotId, mmsc, data, ua, uaprof); 1397 mmsc = StringUtils::ToUtf16(VNET_MMSC); 1398 int32_t noData = smsService->DownloadMms(slotId, mmsc, data, ua, uaprof); 1399 notAccess = smsService->SendMms(slotId, mmsc, data, ua, uaprof, time, true); 1400 noMmsc = smsService->SendMms(slotId, mmsc, data, ua, uaprof, time, true); 1401 mmsc = StringUtils::ToUtf16(VNET_MMSC); 1402 noData = smsService->SendMms(slotId, mmsc, data, ua, uaprof, time, true); 1403 EXPECT_GE(notAccess, 0); 1404 EXPECT_GE(noMmsc, 0); 1405 EXPECT_GE(noData, 0); 1406} 1407 1408/** 1409 * @tc.number Telephony_SmsMmsGtest_ServiceAfterSendMmsComplete_0001 1410 * @tc.name Test ServiceAfterSendMmsComplete_0001 1411 * @tc.desc Function test 1412 */ 1413HWTEST_F(BranchMmsTest, ServiceAfterSendMmsComplete_0001, Function | MediumTest | Level1) 1414{ 1415 std::shared_ptr<SmsService> smsService = std::make_shared<SmsService>(); 1416 int32_t slotId = 0; 1417 int64_t time = 0; 1418 DataShare::DataShareValuesBucket sessionBucket; 1419 uint16_t dataBaseId = 0; 1420 std::string sendStatus = ""; 1421 smsService->ServiceAfterSendMmsComplete(slotId, time, dataBaseId, sessionBucket, sendStatus); 1422 dataBaseId = 1; 1423 smsService->ServiceAfterSendMmsComplete(slotId, time, dataBaseId, sessionBucket, sendStatus); 1424} 1425} // namespace Telephony 1426} // namespace OHOS 1427