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