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