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  */
HWTEST_F(BranchMmsTest, MmsHeader_0001, Function | MediumTest | Level1)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  */
HWTEST_F(BranchMmsTest, MmsHeader_0002, Function | MediumTest | Level1)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  */
HWTEST_F(BranchMmsTest, MmsHeader_0003, Function | MediumTest | Level1)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  */
HWTEST_F(BranchMmsTest, MmsHeader_0004, Function | MediumTest | Level1)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  */
HWTEST_F(BranchMmsTest, MmsHeader_0005, Function | MediumTest | Level1)314 HWTEST_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  */
HWTEST_F(BranchMmsTest, SmsWapPushBuffer_0001, Function | MediumTest | Level1)365 HWTEST_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  */
HWTEST_F(BranchMmsTest, SmsWapPushBuffer_0002, Function | MediumTest | Level1)421 HWTEST_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  */
HWTEST_F(BranchMmsTest, SmsWapPushHandler_0001, Function | MediumTest | Level1)464 HWTEST_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  */
HWTEST_F(BranchMmsTest, SmsWapPushHandler_0002, Function | MediumTest | Level1)494 HWTEST_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  */
HWTEST_F(BranchMmsTest, SmsWapPushContentType_0001, Function | MediumTest | Level1)543 HWTEST_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  */
HWTEST_F(BranchMmsTest, SmsWapPushContentType_0002, Function | MediumTest | Level1)574 HWTEST_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  */
HWTEST_F(BranchMmsTest, SmsWapPushContentType_0003, Function | MediumTest | Level1)614 HWTEST_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  */
HWTEST_F(BranchMmsTest, MmsBodyPart_0001, Function | MediumTest | Level3)656 HWTEST_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  */
HWTEST_F(BranchMmsTest, MmsBodyPart_0002, Function | MediumTest | Level3)712 HWTEST_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  */
HWTEST_F(BranchMmsTest, MmsContentType_0001, Function | MediumTest | Level3)750 HWTEST_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  */
HWTEST_F(BranchMmsTest, MmsContentType_0002, Function | MediumTest | Level3)787 HWTEST_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  */
HWTEST_F(BranchMmsTest, MmsContentType_0003, Function | MediumTest | Level3)836 HWTEST_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  */
HWTEST_F(BranchMmsTest, MmsContentType_0004, Function | MediumTest | Level3)879 HWTEST_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  */
HWTEST_F(BranchMmsTest, SmsMmsGtest_MmsBody_0001, Function | MediumTest | Level1)918 HWTEST_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  */
HWTEST_F(BranchMmsTest, SmsMmsGtest_MmsBody_0002, Function | MediumTest | Level1)968 HWTEST_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  */
HWTEST_F(BranchMmsTest, SmsMmsGtest_MmsMsg_0001, Function | MediumTest | Level1)1006 HWTEST_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  */
HWTEST_F(BranchMmsTest, SmsMmsGtest_MmsMsg_0002, Function | MediumTest | Level1)1033 HWTEST_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  */
HWTEST_F(BranchMmsTest, MmsBodyPartHeader_0001, Function | MediumTest | Level1)1078 HWTEST_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  */
HWTEST_F(BranchMmsTest, MmsBuffer_0002, Function | MediumTest | Level1)1131 HWTEST_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  */
HWTEST_F(BranchMmsTest, MmsConnCallback_0001, Function | MediumTest | Level1)1153 HWTEST_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  */
HWTEST_F(BranchMmsTest, MmsNetworkManager_0001, Function | MediumTest | Level1)1174 HWTEST_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  */
HWTEST_F(BranchMmsTest, MmsNetworkClient_0001, Function | MediumTest | Level1)1188 HWTEST_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  */
HWTEST_F(BranchMmsTest, MmsPersistHelper_0001, Function | MediumTest | Level1)1220 HWTEST_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  */
HWTEST_F(BranchMmsTest, MmsPersistHelper_0002, Function | MediumTest | Level1)1246 HWTEST_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  */
HWTEST_F(BranchMmsTest, MmsPersistHelper_0003, Function | MediumTest | Level1)1264 HWTEST_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  */
HWTEST_F(BranchMmsTest, MmsEncodeBuffer_0001, Function | MediumTest | Level1)1281 HWTEST_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  */
HWTEST_F(BranchMmsTest, MmsEncodeBuffer_0002, Function | MediumTest | Level1)1321 HWTEST_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  */
HWTEST_F(BranchMmsTest, SendMms_0001, Function | MediumTest | Level1)1361 HWTEST_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  */
HWTEST_F(BranchMmsTest, DownloadMms_0001, Function | MediumTest | Level1)1385 HWTEST_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  */
HWTEST_F(BranchMmsTest, ServiceAfterSendMmsComplete_0001, Function | MediumTest | Level1)1413 HWTEST_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