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 "sms_service.h"
27 #include "sms_wap_push_buffer.h"
28 #include "sms_wap_push_content_type.h"
29
30 namespace OHOS {
31 namespace Telephony {
32 using namespace testing::ext;
33
34 namespace {
35 const uint32_t TRANSACTION_ID_LENGTH = 3;
36 const uint32_t PDU_BUFFE_LENGTH = 126;
37 const uint32_t PDU_BUFFE_LENGTH_ONE = 128;
38 const uint32_t PDU_BUFFE_LENGTH_TWO = 127;
39 const uint32_t PDU_BUFFE_LENGTH_THREE = 31;
40 const uint32_t PDU_BUFFE_LENGTH_FOUR = 129;
41 const uint32_t PDU_BUFFE_LENGTH_FIVE = 139;
42 const uint32_t PDU_BUFFE_LENGTH_SIX = 134;
43 const uint32_t PDU_BUFFE_LENGTH_SEVEN = 152;
44 const uint32_t PDU_BUFFE_LENGTH_EIGHT = 153;
45 const uint32_t PDU_BUFFE_LENGTH_NINE = 138;
46 const uint32_t PDU_BUFFE_LENGTH_TEN = 133;
47 const uint32_t PDU_BUFFE_LENGTH_ELEVEN = 151;
48 const uint32_t PDU_BUFFE_LENGTH_TWELVE = 154;
49 const uint32_t PDU_BUFFE_LENGTH_THIRTEEN = 131;
50 const uint32_t PDU_BUFFE_LENGTH_FOURTEEN = 137;
51 const uint8_t MIN_TOKEN = 30;
52 const uint8_t MAX_TOKEN = 127;
53 const uint8_t FIELD_ID = 2;
54 const int32_t INVALID_SLOTID = 2;
55 const int32_t VALUE_LENGTH = 2;
56 static constexpr uint32_t MAX_MMS_MSG_PART_LEN = 300 * 1024;
57 const uint32_t CODE_BUFFER_MAX_SIZE = 300 * 1024;
58 } // namespace
59
60 class BranchMmsTest : public testing::Test {
61 public:
62 static void SetUpTestCase();
63 static void TearDownTestCase();
64 void SetUp();
65 void TearDown();
66 };
SetUpTestCase()67 void BranchMmsTest::SetUpTestCase() {}
68
TearDownTestCase()69 void BranchMmsTest::TearDownTestCase() {}
70
SetUp()71 void BranchMmsTest::SetUp() {}
72
TearDown()73 void BranchMmsTest::TearDown() {}
74
75 /**
76 * @tc.number Telephony_SmsMmsGtest_MmsHeader_0001
77 * @tc.name Test MmsHeader
78 * @tc.desc Function test
79 */
80 HWTEST_F(BranchMmsTest, MmsHeader_0001, Function | MediumTest | Level1)
81 {
82 auto mmsHeader = std::make_shared<MmsHeader>();
83 MmsEncodeString encodeString;
84 MmsDecodeBuffer decodeBuffer;
85 MmsEncodeBuffer encodeBuffer;
86 std::string encodeAddress = "123";
87 uint8_t value = 0;
88 MmsAddress address(encodeAddress);
89 std::vector<MmsAddress> addressValue;
90 addressValue.push_back(address);
91 mmsHeader->octetValueMap_.insert(pair<uint8_t, uint8_t>(1, 1));
92 mmsHeader->longValueMap_.insert(pair<uint8_t, int64_t>(1, 1));
93 mmsHeader->textValueMap_.insert(pair<uint8_t, std::string>(1, "1"));
94 mmsHeader->encodeStringsMap_.insert(pair<uint8_t, MmsEncodeString>(1, encodeString));
95 mmsHeader->addressMap_.insert(pair<uint8_t, std::vector<MmsAddress>>(1, addressValue));
96 mmsHeader->DumpMmsHeader();
97 EXPECT_TRUE(mmsHeader->DecodeMmsHeader(decodeBuffer));
98 EXPECT_FALSE(mmsHeader->EncodeMmsHeader(encodeBuffer));
99 EXPECT_TRUE(mmsHeader->GetOctetValue(1, value));
100 EXPECT_FALSE(mmsHeader->SetOctetValue(1, 0));
101 mmsHeader->mmsHaderCateg_.mmsFieldDesMap_.insert(
102 pair<uint8_t, MmsFieldValueType>(MMS_MESSAGE_TYPE, MmsFieldValueType::MMS_FIELD_OCTET_TYPE));
103 mmsHeader->mmsHaderCateg_.mmsFieldDesMap_.insert(
104 pair<uint8_t, MmsFieldValueType>(MMS_PRIORITY, MmsFieldValueType::MMS_FIELD_OCTET_TYPE));
105 mmsHeader->mmsHaderCateg_.mmsFieldDesMap_.insert(
106 pair<uint8_t, MmsFieldValueType>(MMS_RESPONSE_STATUS, MmsFieldValueType::MMS_FIELD_OCTET_TYPE));
107 mmsHeader->mmsHaderCateg_.mmsFieldDesMap_.insert(
108 pair<uint8_t, MmsFieldValueType>(MMS_SENDER_VISIBILITY, MmsFieldValueType::MMS_FIELD_OCTET_TYPE));
109 mmsHeader->mmsHaderCateg_.mmsFieldDesMap_.insert(
110 pair<uint8_t, MmsFieldValueType>(MMS_STATUS, MmsFieldValueType::MMS_FIELD_OCTET_TYPE));
111 mmsHeader->mmsHaderCateg_.mmsFieldDesMap_.insert(
112 pair<uint8_t, MmsFieldValueType>(MMS_RETRIEVE_STATUS, MmsFieldValueType::MMS_FIELD_OCTET_TYPE));
113 mmsHeader->mmsHaderCateg_.mmsFieldDesMap_.insert(
114 pair<uint8_t, MmsFieldValueType>(MMS_READ_STATUS, MmsFieldValueType::MMS_FIELD_OCTET_TYPE));
115 mmsHeader->mmsHaderCateg_.mmsFieldDesMap_.insert(
116 pair<uint8_t, MmsFieldValueType>(MMS_REPLY_CHARGING, MmsFieldValueType::MMS_FIELD_OCTET_TYPE));
117 EXPECT_FALSE(mmsHeader->SetOctetValue(MMS_MESSAGE_TYPE, MMS_MESSAGE_TYPE));
118 EXPECT_FALSE(mmsHeader->SetOctetValue(MMS_PRIORITY, MMS_PRIORITY));
119 EXPECT_FALSE(mmsHeader->SetOctetValue(MMS_RESPONSE_STATUS, MMS_RESPONSE_STATUS));
120 EXPECT_FALSE(mmsHeader->SetOctetValue(MMS_SENDER_VISIBILITY, MMS_SENDER_VISIBILITY));
121 EXPECT_FALSE(mmsHeader->SetOctetValue(MMS_STATUS, MMS_STATUS));
122 EXPECT_FALSE(mmsHeader->SetOctetValue(MMS_RETRIEVE_STATUS, MMS_RETRIEVE_STATUS));
123 EXPECT_FALSE(mmsHeader->SetOctetValue(MMS_READ_STATUS, MMS_READ_STATUS));
124 EXPECT_FALSE(mmsHeader->SetOctetValue(MMS_REPLY_CHARGING, MMS_REPLY_CHARGING));
125 EXPECT_FALSE(mmsHeader->SetOctetValue(MMS_MM_STATE, MMS_MM_STATE));
126 EXPECT_TRUE(mmsHeader->GetHeaderAllAddressValue(1, addressValue));
127 }
128
129 /**
130 * @tc.number Telephony_SmsMmsGtest_MmsHeader_0002
131 * @tc.name Test MmsHeader
132 * @tc.desc Function test
133 */
134 HWTEST_F(BranchMmsTest, MmsHeader_0002, Function | MediumTest | Level1)
135 {
136 auto mmsHeader = std::make_shared<MmsHeader>();
137 int64_t value = 0;
138 std::string valueStr = "";
139 std::string encodeAddress = "123";
140 MmsAddress address(encodeAddress);
141 std::vector<MmsAddress> addressValue;
142 addressValue.push_back(address);
143 MmsEncodeString encodeString;
144 mmsHeader->longValueMap_.insert(pair<uint8_t, int64_t>(1, 1));
145 mmsHeader->textValueMap_.insert(pair<uint8_t, std::string>(1, "1"));
146 mmsHeader->encodeStringsMap_.insert(pair<uint8_t, MmsEncodeString>(1, encodeString));
147 mmsHeader->mmsHaderCateg_.mmsFieldDesMap_.insert(
148 pair<uint8_t, MmsFieldValueType>(MMS_STORE_STATUS, MmsFieldValueType::MMS_FIELD_OCTET_TYPE));
149 mmsHeader->mmsHaderCateg_.mmsFieldDesMap_.insert(
150 pair<uint8_t, MmsFieldValueType>(MMS_CONTENT_CLASS, MmsFieldValueType::MMS_FIELD_OCTET_TYPE));
151 mmsHeader->mmsHaderCateg_.mmsFieldDesMap_.insert(
152 pair<uint8_t, MmsFieldValueType>(MMS_MESSAGE_CLASS, MmsFieldValueType::MMS_FIELD_OCTET_TYPE));
153 mmsHeader->mmsHaderCateg_.mmsFieldDesMap_.insert(
154 pair<uint8_t, MmsFieldValueType>(MMS_CANCEL_STATUS, MmsFieldValueType::MMS_FIELD_OCTET_TYPE));
155 mmsHeader->mmsHaderCateg_.mmsFieldDesMap_.insert(
156 pair<uint8_t, MmsFieldValueType>(MMS_ADAPTATION_ALLOWED, MmsFieldValueType::MMS_FIELD_OCTET_TYPE));
157 EXPECT_TRUE(mmsHeader->SetOctetValue(MMS_ADAPTATION_ALLOWED, MMS_BCC));
158 EXPECT_TRUE(mmsHeader->GetLongValue(1, value));
159 EXPECT_TRUE(mmsHeader->GetTextValue(1, valueStr));
160 EXPECT_TRUE(mmsHeader->GetEncodeStringValue(1, encodeString));
161 EXPECT_FALSE(mmsHeader->SetTextValue(MMS_CANCEL_STATUS, ""));
162 EXPECT_FALSE(mmsHeader->SetTextValue(MMS_CANCEL_STATUS, "123"));
163 EXPECT_FALSE(mmsHeader->SetOctetValue(MMS_MM_FLAGS, MMS_MM_FLAGS));
164 EXPECT_FALSE(mmsHeader->SetOctetValue(MMS_CONTENT_CLASS, MMS_CONTENT_CLASS));
165 EXPECT_FALSE(mmsHeader->SetOctetValue(MMS_MESSAGE_CLASS, MMS_MESSAGE_CLASS));
166 EXPECT_FALSE(mmsHeader->SetOctetValue(MMS_CANCEL_STATUS, MMS_CANCEL_STATUS));
167 EXPECT_FALSE(mmsHeader->SetLongValue(MMS_MESSAGE_CLASS, 0));
168 EXPECT_FALSE(mmsHeader->SetEncodeStringValue(1, 1, valueStr));
169 EXPECT_FALSE(mmsHeader->SetEncodeStringValue(MMS_STORE_STATUS, 1, encodeAddress));
170 EXPECT_FALSE(mmsHeader->AddHeaderAddressValue(1, address));
171 EXPECT_TRUE(mmsHeader->GetStringValue(1, encodeAddress));
172 EXPECT_FALSE(mmsHeader->GetStringValue(FIELD_ID, encodeAddress));
173 EXPECT_TRUE(mmsHeader->GetSmilFileName(valueStr));
174 EXPECT_FALSE(mmsHeader->IsHaveBody());
175 }
176
177 /**
178 * @tc.number Telephony_SmsMmsGtest_MmsHeader_0003
179 * @tc.name Test MmsHeader
180 * @tc.desc Function test
181 */
182 HWTEST_F(BranchMmsTest, MmsHeader_0003, Function | MediumTest | Level1)
183 {
184 auto mmsHeader = std::make_shared<MmsHeader>();
185 MmsDecodeBuffer decodeBuffer;
186 MmsEncodeBuffer buff;
187 std::string encodeAddress = "123";
188 MmsAddress address(encodeAddress);
189 std::vector<MmsAddress> addressValue;
190 addressValue.push_back(address);
191 int32_t data = 0;
192 mmsHeader->addressMap_.insert(pair<uint8_t, std::vector<MmsAddress>>(MMS_BCC, addressValue));
193 mmsHeader->addressMap_.insert(pair<uint8_t, std::vector<MmsAddress>>(MMS_FROM, addressValue));
194 EXPECT_NE(mmsHeader->MakeTransactionId(TRANSACTION_ID_LENGTH), "");
195 EXPECT_FALSE(mmsHeader->DecodeMmsMsgType(1, decodeBuffer, data));
196 EXPECT_FALSE(mmsHeader->DecodeMmsMsgType(MMS_BCC, decodeBuffer, data));
197 EXPECT_FALSE(mmsHeader->DecodeFieldAddressModelValue(1, decodeBuffer, data));
198 EXPECT_TRUE(mmsHeader->DecodeFieldAddressModelValue(MMS_BCC, decodeBuffer, data));
199 EXPECT_FALSE(mmsHeader->DecodeFieldOctetValue(1, decodeBuffer, data));
200 EXPECT_FALSE(mmsHeader->DecodeFieldLongValue(1, decodeBuffer, data));
201 EXPECT_FALSE(mmsHeader->DecodeFieldIntegerValue(1, decodeBuffer, data));
202 EXPECT_FALSE(mmsHeader->DecodeFieldTextStringValue(1, decodeBuffer, data));
203 EXPECT_FALSE(mmsHeader->DecodeFieldTextStringValue(MMS_BCC, decodeBuffer, data));
204 EXPECT_FALSE(mmsHeader->DecodeFieldEncodedStringValue(1, decodeBuffer, data));
205 EXPECT_FALSE(mmsHeader->DecodeFieldEncodedStringValue(MMS_BCC, decodeBuffer, data));
206 EXPECT_FALSE(mmsHeader->DecodeFromValue(1, decodeBuffer, data));
207 EXPECT_FALSE(mmsHeader->DecodeMmsMsgUnKnownField(decodeBuffer));
208 EXPECT_FALSE(mmsHeader->DecodeMmsContentType(1, decodeBuffer, data));
209 EXPECT_FALSE(mmsHeader->DecodeFieldDate(1, decodeBuffer, data));
210 EXPECT_FALSE(mmsHeader->DecodeFieldDate(MMS_BCC, decodeBuffer, data));
211 EXPECT_FALSE(mmsHeader->DecodeFieldPreviouslySentDate(1, decodeBuffer, data));
212 EXPECT_FALSE(mmsHeader->DecodeFieldPreviouslySentDate(MMS_BCC, decodeBuffer, data));
213 EXPECT_FALSE(mmsHeader->DecodeFieldMBox(1, decodeBuffer, data));
214 EXPECT_FALSE(mmsHeader->DecodeFieldMBox(MMS_BCC, decodeBuffer, data));
215 EXPECT_FALSE(mmsHeader->DecodeFieldMMFlag(1, decodeBuffer, data));
216 EXPECT_FALSE(mmsHeader->DecodeFieldMMFlag(MMS_BCC, decodeBuffer, data));
217 EXPECT_TRUE(mmsHeader->EncodeFieldFromValue(buff, addressValue));
218 mmsHeader->textValueMap_.insert(pair<uint8_t, std::string>(MMS_MESSAGE_CLASS, "personal"));
219 EXPECT_TRUE(mmsHeader->EcondeFieldMessageClassValue(buff));
220 mmsHeader->textValueMap_.insert(pair<uint8_t, std::string>(MMS_MESSAGE_CLASS, "advertisement"));
221 EXPECT_TRUE(mmsHeader->EcondeFieldMessageClassValue(buff));
222 mmsHeader->textValueMap_.insert(pair<uint8_t, std::string>(MMS_MESSAGE_CLASS, "informational"));
223 EXPECT_TRUE(mmsHeader->EcondeFieldMessageClassValue(buff));
224 mmsHeader->textValueMap_.insert(pair<uint8_t, std::string>(MMS_MESSAGE_CLASS, "auto"));
225 EXPECT_TRUE(mmsHeader->EcondeFieldMessageClassValue(buff));
226 mmsHeader->octetValueMap_.insert(pair<uint8_t, uint8_t>(MMS_MESSAGE_CLASS, 1));
227 EXPECT_TRUE(mmsHeader->EcondeFieldMessageClassValue(buff));
228 }
229
230 /**
231 * @tc.number Telephony_SmsMmsGtest_MmsHeader_0004
232 * @tc.name Test MmsHeader
233 * @tc.desc Function test
234 */
235 HWTEST_F(BranchMmsTest, MmsHeader_0004, Function | MediumTest | Level1)
236 {
237 auto mmsHeader = std::make_shared<MmsHeader>();
238 MmsEncodeBuffer buff;
239 std::string encodeAddress = "123";
240 MmsAddress address(encodeAddress);
241 std::vector<MmsAddress> addrs;
242 mmsHeader->longValueMap_.insert(pair<uint8_t, int64_t>(MMS_EXPIRY, 1));
243 mmsHeader->textValueMap_.insert(pair<uint8_t, std::string>(MMS_TRANSACTION_ID, "auto"));
244 EXPECT_TRUE(mmsHeader->EncodeCommontFieldValue(buff));
245 EXPECT_FALSE(mmsHeader->EncodeMultipleAddressValue(buff, 1, addrs));
246 addrs.push_back(address);
247 EXPECT_TRUE(mmsHeader->EncodeMultipleAddressValue(buff, 1, addrs));
248 EXPECT_TRUE(mmsHeader->EncodeMmsSendReq(buff));
249 EXPECT_FALSE(mmsHeader->EncodeMmsSendConf(buff));
250 EXPECT_FALSE(mmsHeader->EncodeMmsNotificationInd(buff));
251 mmsHeader->textValueMap_.insert(pair<uint8_t, std::string>(MMS_CONTENT_LOCATION, "auto"));
252 EXPECT_FALSE(mmsHeader->EncodeMmsNotificationInd(buff));
253 EXPECT_FALSE(mmsHeader->EnocdeMmsNotifyRespInd(buff));
254 EXPECT_FALSE(mmsHeader->EnocdeMmsRetrieveConf(buff));
255 mmsHeader->longValueMap_.insert(pair<uint8_t, int64_t>(MMS_DATE, 1));
256 mmsHeader->addressMap_.insert(pair<uint8_t, std::vector<MmsAddress>>(MMS_CC, addrs));
257 EXPECT_TRUE(mmsHeader->EnocdeMmsRetrieveConf(buff));
258 EXPECT_FALSE(mmsHeader->EnocdeMmsDeliveryInd(buff));
259 mmsHeader->addressMap_.insert(pair<uint8_t, std::vector<MmsAddress>>(MMS_TO, addrs));
260 EXPECT_TRUE(mmsHeader->EnocdeMmsRetrieveConf(buff));
261 mmsHeader->addressMap_.insert(pair<uint8_t, std::vector<MmsAddress>>(MMS_FROM, addrs));
262 EXPECT_TRUE(mmsHeader->EnocdeMmsRetrieveConf(buff));
263 EXPECT_FALSE(mmsHeader->EnocdeMmsDeliveryInd(buff));
264 EXPECT_FALSE(mmsHeader->EncodeMmsReadRecInd(buff));
265 mmsHeader->textValueMap_.insert(pair<uint8_t, std::string>(MMS_MESSAGE_ID, "auto"));
266 EXPECT_FALSE(mmsHeader->EnocdeMmsDeliveryInd(buff));
267 mmsHeader->longValueMap_.clear();
268 EXPECT_FALSE(mmsHeader->EnocdeMmsDeliveryInd(buff));
269 mmsHeader->addressMap_.clear();
270 mmsHeader->textValueMap_.clear();
271 EXPECT_FALSE(mmsHeader->EncodeMmsReadRecInd(buff));
272 EXPECT_FALSE(mmsHeader->EncodeMmsReadOrigInd(buff));
273 mmsHeader->textValueMap_.insert(pair<uint8_t, std::string>(MMS_MESSAGE_ID, "auto"));
274 EXPECT_FALSE(mmsHeader->EncodeMmsReadOrigInd(buff));
275 mmsHeader->addressMap_.insert(pair<uint8_t, std::vector<MmsAddress>>(MMS_TO, addrs));
276 EXPECT_FALSE(mmsHeader->EncodeMmsReadOrigInd(buff));
277 mmsHeader->octetValueMap_.insert(pair<uint8_t, uint8_t>(MMS_READ_STATUS, 1));
278 EXPECT_FALSE(mmsHeader->EncodeMmsReadOrigInd(buff));
279 EXPECT_FALSE(mmsHeader->CheckBooleanValue(MMS_DRM_CONTENT, 0));
280 EXPECT_FALSE(mmsHeader->CheckBooleanValue(MMS_BCC, 1));
281 }
282
283 /**
284 * @tc.number Telephony_SmsMmsGtest_MmsHeader_0005
285 * @tc.name Test MmsHeader
286 * @tc.desc Function test
287 */
288 HWTEST_F(BranchMmsTest, MmsHeader_0005, Function | MediumTest | Level1)
289 {
290 auto mmsHeader = std::make_shared<MmsHeader>();
291 MmsEncodeBuffer buff;
292 MmsEncodeString value;
293 std::string str = "q";
294 mmsHeader->TrimString(str);
295 str = "qwer";
296 mmsHeader->TrimString(str);
297 str = "<wer";
298 mmsHeader->TrimString(str);
299 EXPECT_FALSE(mmsHeader->EncodeTextStringValue(buff, 1, ""));
300 EXPECT_FALSE(mmsHeader->EncodeEncodeStringValue(buff, 1, value));
301 EXPECT_TRUE(mmsHeader->IsHaveTransactionId(MMS_MSGTYPE_SEND_REQ));
302 EXPECT_TRUE(mmsHeader->IsHaveTransactionId(MMS_MSGTYPE_SEND_CONF));
303 EXPECT_TRUE(mmsHeader->IsHaveTransactionId(MMS_MSGTYPE_NOTIFICATION_IND));
304 EXPECT_TRUE(mmsHeader->IsHaveTransactionId(MMS_MSGTYPE_NOTIFYRESP_IND));
305 EXPECT_TRUE(mmsHeader->IsHaveTransactionId(MMS_MSGTYPE_RETRIEVE_CONF));
306 EXPECT_TRUE(mmsHeader->IsHaveTransactionId(MMS_MSGTYPE_ACKNOWLEDGE_IND));
307 EXPECT_TRUE(mmsHeader->CheckResponseStatus(static_cast<uint8_t>(MmsResponseStatus::MMS_OK)));
308 EXPECT_TRUE(mmsHeader->CheckResponseStatus(static_cast<uint8_t>(MmsResponseStatus::MMS_ERROR_UNSUPPORTED_MESSAGE)));
309 EXPECT_TRUE(mmsHeader->CheckResponseStatus(static_cast<uint8_t>(MmsResponseStatus::MMS_ERROR_PERMANENT_FAILURE)));
310 EXPECT_TRUE(
311 mmsHeader->CheckResponseStatus(static_cast<uint8_t>(MmsResponseStatus::MMS_ERROR_PERMANENT_LACK_OF_PREPAID)));
312 EXPECT_TRUE(mmsHeader->CheckRetrieveStatus(static_cast<uint8_t>(MmsRetrieveStatus::MMS_RETRIEVE_STATUS_OK)));
313 EXPECT_TRUE(mmsHeader->CheckRetrieveStatus(
314 static_cast<uint8_t>(MmsRetrieveStatus::MMS_RETRIEVE_STATUS_ERROR_PERMANENT_FAILURE)));
315 EXPECT_TRUE(mmsHeader->CheckRetrieveStatus(
316 static_cast<uint8_t>(MmsRetrieveStatus::MMS_RETRIEVE_STATUS_ERROR_PERMANENT_CONTENT_UNSUPPORTED)));
317 EXPECT_TRUE(mmsHeader->CheckRetrieveStatus(
318 static_cast<uint8_t>(MmsRetrieveStatus::MMS_RETRIEVE_STATUS_ERROR_TRANSIENT_FAILURE)));
319 EXPECT_TRUE(mmsHeader->CheckRetrieveStatus(
320 static_cast<uint8_t>(MmsRetrieveStatus::MMS_RETRIEVE_STATUS_ERROR_TRANSIENT_NETWORK_PROBLEM)));
321 EXPECT_TRUE(mmsHeader->CheckStoreStatus(static_cast<uint8_t>(MmsStoreStatus::MMS_STORE_STATUS_SUCCESS)));
322 EXPECT_TRUE(
323 mmsHeader->CheckStoreStatus(static_cast<uint8_t>(MmsStoreStatus::MMS_STORE_STATUS_ERROR_TRANSIENT_FAILURE)));
324 EXPECT_TRUE(mmsHeader->CheckStoreStatus(
325 static_cast<uint8_t>(MmsStoreStatus::MMS_STORE_STATUS_ERROR_TRANSIENT_NETWORK_PROBLEM)));
326 EXPECT_TRUE(
327 mmsHeader->CheckStoreStatus(static_cast<uint8_t>(MmsStoreStatus::MMS_STORE_STATUS_ERROR_PERMANENT_FAILURE)));
328 EXPECT_TRUE(
329 mmsHeader->CheckStoreStatus(static_cast<uint8_t>(MmsStoreStatus::MMS_STORE_STATUS_ERROR_PERMANENT_MMBOX_FULL)));
330 EXPECT_TRUE(mmsHeader->CheckBooleanValue(MMS_DELIVERY_REPORT, static_cast<uint8_t>(MmsBoolType::MMS_YES)));
331 EXPECT_FALSE(mmsHeader->CheckBooleanValue(MMS_READ_REPORT, 0));
332 EXPECT_FALSE(mmsHeader->CheckBooleanValue(MMS_REPORT_ALLOWED, 0));
333 EXPECT_FALSE(mmsHeader->CheckBooleanValue(MMS_STORE, 0));
334 EXPECT_FALSE(mmsHeader->CheckBooleanValue(MMS_STORED, 0));
335 EXPECT_FALSE(mmsHeader->CheckBooleanValue(MMS_TOTALS, 0));
336 EXPECT_FALSE(mmsHeader->CheckBooleanValue(MMS_QUOTAS, 0));
337 EXPECT_FALSE(mmsHeader->CheckBooleanValue(MMS_DISTRIBUTION_INDICATOR, 0));
338 }
339
340 /**
341 * @tc.number Telephony_SmsMmsGtest_SmsWapPushBuffer_0001
342 * @tc.name Test SmsWapPushBuffer
343 * @tc.desc Function test
344 */
345 HWTEST_F(BranchMmsTest, SmsWapPushBuffer_0001, Function | MediumTest | Level1)
346 {
347 auto smsWapPushBuffer = std::make_shared<SmsWapPushBuffer>();
348 uint8_t oneByte = 0;
349 uint8_t sValueLength = 0;
350 uint32_t valueLength = 0;
351 uint32_t length = 1;
352 std::string str = "qwe";
353 EXPECT_FALSE(smsWapPushBuffer->GetOneByte(oneByte));
354 EXPECT_FALSE(smsWapPushBuffer->IncreasePointer(1));
355 EXPECT_FALSE(smsWapPushBuffer->DecreasePointer(1));
356 EXPECT_FALSE(smsWapPushBuffer->DecodeShortLength(sValueLength));
357 EXPECT_FALSE(smsWapPushBuffer->DecodeValueLengthReturnLen(valueLength, length));
358 EXPECT_FALSE(smsWapPushBuffer->DecodeUintvar(valueLength, length));
359 EXPECT_FALSE(smsWapPushBuffer->DecodeValueLength(valueLength));
360 EXPECT_FALSE(smsWapPushBuffer->DecodeText(str, length));
361 EXPECT_FALSE(smsWapPushBuffer->DecodeShortInteger(oneByte));
362 smsWapPushBuffer->totolLength_ = 1;
363 smsWapPushBuffer->curPosition_ = 1;
364 EXPECT_FALSE(smsWapPushBuffer->IncreasePointer(1));
365 smsWapPushBuffer->curPosition_ = 0;
366 smsWapPushBuffer->pduBuffer_ = std::make_unique<char[]>(1);
367 smsWapPushBuffer->pduBuffer_[0] = 0;
368 EXPECT_TRUE(smsWapPushBuffer->DecodeShortLength(sValueLength));
369 smsWapPushBuffer->curPosition_ = 0;
370 smsWapPushBuffer->pduBuffer_[0] = 0;
371 EXPECT_TRUE(smsWapPushBuffer->DecodeValueLengthReturnLen(valueLength, length));
372 smsWapPushBuffer->curPosition_ = 0;
373 smsWapPushBuffer->pduBuffer_[0] = PDU_BUFFE_LENGTH_TWO;
374 EXPECT_TRUE(smsWapPushBuffer->DecodeIsString());
375 smsWapPushBuffer->pduBuffer_[0] = PDU_BUFFE_LENGTH_ONE;
376 EXPECT_FALSE(smsWapPushBuffer->DecodeUintvar(valueLength, length));
377 smsWapPushBuffer->curPosition_ = 0;
378 EXPECT_TRUE(smsWapPushBuffer->DecodeShortInteger(oneByte));
379 smsWapPushBuffer->curPosition_ = 0;
380 EXPECT_FALSE(smsWapPushBuffer->DecodeValueLength(valueLength));
381 smsWapPushBuffer->curPosition_ = 0;
382 smsWapPushBuffer->pduBuffer_[0] = PDU_BUFFE_LENGTH_THREE;
383 EXPECT_TRUE(smsWapPushBuffer->DecodeIsValueLength());
384 EXPECT_FALSE(smsWapPushBuffer->DecodeValueLength(valueLength));
385 smsWapPushBuffer->curPosition_ = 0;
386 EXPECT_FALSE(smsWapPushBuffer->DecodeTokenText(str, length));
387 smsWapPushBuffer->pduBuffer_[0] = PDU_BUFFE_LENGTH_TWO;
388 EXPECT_TRUE(smsWapPushBuffer->DecodeText(str, length));
389 EXPECT_FALSE(smsWapPushBuffer->CharIsToken(MIN_TOKEN));
390 EXPECT_FALSE(smsWapPushBuffer->CharIsToken(MAX_TOKEN));
391 smsWapPushBuffer->curPosition_ = 0;
392 smsWapPushBuffer->pduBuffer_[0] = PDU_BUFFE_LENGTH;
393 EXPECT_TRUE(smsWapPushBuffer->DecodeTokenText(str, length));
394 }
395
396 /**
397 * @tc.number Telephony_SmsMmsGtest_SmsWapPushBuffer_0002
398 * @tc.name Test SmsWapPushBuffer
399 * @tc.desc Function test
400 */
401 HWTEST_F(BranchMmsTest, SmsWapPushBuffer_0002, Function | MediumTest | Level1)
402 {
403 auto smsWapPushBuffer = std::make_shared<SmsWapPushBuffer>();
404 uint64_t iInteger = 0;
405 std::string str = "qwe";
406 bool isNoValue = true;
407 uint32_t len = 1;
408 smsWapPushBuffer->pduBuffer_ = std::make_unique<char[]>(1);
409 EXPECT_FALSE(smsWapPushBuffer->DecodeLongInteger(iInteger));
410 EXPECT_FALSE(smsWapPushBuffer->DecodeTextValue(str, isNoValue));
411 EXPECT_FALSE(smsWapPushBuffer->DecodeNoValue(isNoValue));
412 EXPECT_TRUE(smsWapPushBuffer->ReadDataBuffer(1, 1) == nullptr);
413 smsWapPushBuffer->totolLength_ = 1;
414 smsWapPushBuffer->pduBuffer_[0] = 1;
415 EXPECT_FALSE(smsWapPushBuffer->DecodeLongInteger(iInteger));
416 smsWapPushBuffer->curPosition_ = 0;
417 smsWapPushBuffer->pduBuffer_[0] = PDU_BUFFE_LENGTH_THREE;
418 EXPECT_FALSE(smsWapPushBuffer->DecodeLongInteger(iInteger));
419 smsWapPushBuffer->curPosition_ = 0;
420 smsWapPushBuffer->pduBuffer_[0] = 1;
421 EXPECT_FALSE(smsWapPushBuffer->DecodeTextValue(str, isNoValue));
422 EXPECT_TRUE(smsWapPushBuffer->ReadDataBuffer(1, 1) == nullptr);
423 EXPECT_FALSE(smsWapPushBuffer->WriteRawStringBuffer(str));
424 EXPECT_FALSE(smsWapPushBuffer->WriteDataBuffer(nullptr, 1));
425 smsWapPushBuffer->curPosition_ = 0;
426 smsWapPushBuffer->pduBuffer_[0] = 0;
427 EXPECT_FALSE(smsWapPushBuffer->DecodeQuotedText(str, len));
428 smsWapPushBuffer->curPosition_ = 0;
429 smsWapPushBuffer->pduBuffer_[0] = PDU_BUFFE_LENGTH_TWO;
430 EXPECT_TRUE(smsWapPushBuffer->DecodeQuotedText(str, len));
431 smsWapPushBuffer->curPosition_ = 0;
432 smsWapPushBuffer->pduBuffer_[0] = PDU_BUFFE_LENGTH_ONE;
433 EXPECT_TRUE(smsWapPushBuffer->DecodeInteger(iInteger));
434 smsWapPushBuffer->curPosition_ = 0;
435 smsWapPushBuffer->pduBuffer_[0] = PDU_BUFFE_LENGTH_TWO;
436 EXPECT_FALSE(smsWapPushBuffer->DecodeInteger(iInteger));
437 }
438
439 /**
440 * @tc.number Telephony_SmsMmsGtest_SmsWapPushHandler_0001
441 * @tc.name Test SmsWapPushHandler
442 * @tc.desc Function test
443 */
444 HWTEST_F(BranchMmsTest, SmsWapPushHandler_0001, Function | MediumTest | Level1)
445 {
446 auto smsWapPushHandler = std::make_shared<SmsWapPushHandler>(INVALID_SLOTID);
447 SmsWapPushBuffer decodeBuffer;
448 std::string wapPdu = "";
449 EXPECT_FALSE(smsWapPushHandler->DecodeWapPushPduData(decodeBuffer, 1, 1));
450 auto indexer = std::make_shared<SmsReceiveIndexer>();
451 EXPECT_FALSE(smsWapPushHandler->DecodeWapPushPdu(indexer, wapPdu));
452 EXPECT_FALSE(smsWapPushHandler->DeocdeCheckIsBlock(wapPdu));
453 wapPdu = "qwer";
454 EXPECT_FALSE(smsWapPushHandler->DecodeWapPushPdu(indexer, wapPdu));
455 EXPECT_FALSE(smsWapPushHandler->DecodePushType(decodeBuffer));
456 EXPECT_FALSE(smsWapPushHandler->DeocdeCheckIsBlock(wapPdu));
457 EXPECT_FALSE(smsWapPushHandler->DecodeXWapApplication(decodeBuffer, 1));
458 EXPECT_FALSE(smsWapPushHandler->DecodeXWapAbandonHeaderValue(decodeBuffer));
459 decodeBuffer.totolLength_ = 1;
460 EXPECT_FALSE(smsWapPushHandler->DecodeXWapApplication(decodeBuffer, 1));
461 EXPECT_TRUE(smsWapPushHandler->SendWapPushMessageBroadcast(indexer));
462 }
463
464 /**
465 * @tc.number Telephony_SmsMmsGtest_SmsWapPushContentType_0001
466 * @tc.name Test SmsWapPushContentType
467 * @tc.desc Function test
468 */
469 HWTEST_F(BranchMmsTest, SmsWapPushContentType_0001, Function | MediumTest | Level1)
470 {
471 auto smsWapPushContentType = std::make_shared<SmsWapPushContentType>();
472 SmsWapPushBuffer decodeBuffer;
473 int32_t contentLength = 1;
474 decodeBuffer.totolLength_ = 1;
475 decodeBuffer.pduBuffer_ = std::make_unique<char[]>(1);
476 decodeBuffer.pduBuffer_[0] = PDU_BUFFE_LENGTH_ONE;
477 EXPECT_FALSE(smsWapPushContentType->DecodeCTGeneralForm(decodeBuffer, contentLength));
478 EXPECT_TRUE(smsWapPushContentType->DecodeContentType(decodeBuffer, contentLength));
479 decodeBuffer.curPosition_ = 0;
480 decodeBuffer.pduBuffer_[0] = PDU_BUFFE_LENGTH_TWO;
481 EXPECT_TRUE(smsWapPushContentType->DecodeContentType(decodeBuffer, contentLength));
482 decodeBuffer.curPosition_ = 0;
483 decodeBuffer.pduBuffer_[0] = 0;
484 EXPECT_FALSE(smsWapPushContentType->DecodeContentType(decodeBuffer, contentLength));
485 EXPECT_FALSE(smsWapPushContentType->DecodeCTGeneralForm(decodeBuffer, contentLength));
486 decodeBuffer.pduBuffer_[0] = PDU_BUFFE_LENGTH_THREE;
487 decodeBuffer.curPosition_ = 1;
488 EXPECT_FALSE(smsWapPushContentType->DecodeParameter(decodeBuffer, 1));
489 EXPECT_FALSE(smsWapPushContentType->DecodeCTGeneralForm(decodeBuffer, contentLength));
490 decodeBuffer.curPosition_ = 0;
491 decodeBuffer.pduBuffer_[0] = PDU_BUFFE_LENGTH_THREE;
492 EXPECT_FALSE(smsWapPushContentType->DecodeCTGeneralForm(decodeBuffer, contentLength));
493 }
494
495 /**
496 * @tc.number Telephony_SmsMmsGtest_SmsWapPushContentType_0002
497 * @tc.name Test SmsWapPushContentType
498 * @tc.desc Function test
499 */
500 HWTEST_F(BranchMmsTest, SmsWapPushContentType_0002, Function | MediumTest | Level1)
501 {
502 auto smsWapPushContentType = std::make_shared<SmsWapPushContentType>();
503 SmsWapPushBuffer decodeBuffer;
504 decodeBuffer.totolLength_ = 1;
505 decodeBuffer.pduBuffer_ = std::make_unique<char[]>(1);
506 decodeBuffer.curPosition_ = 0;
507 decodeBuffer.pduBuffer_[0] = PDU_BUFFE_LENGTH_FOUR;
508 EXPECT_FALSE(smsWapPushContentType->DecodeParameter(decodeBuffer, 1));
509 decodeBuffer.curPosition_ = 0;
510 decodeBuffer.pduBuffer_[0] = PDU_BUFFE_LENGTH_FIVE;
511 EXPECT_FALSE(smsWapPushContentType->DecodeParameter(decodeBuffer, 1));
512 decodeBuffer.curPosition_ = 0;
513 decodeBuffer.pduBuffer_[0] = PDU_BUFFE_LENGTH_SIX;
514 EXPECT_FALSE(smsWapPushContentType->DecodeParameter(decodeBuffer, 1));
515 decodeBuffer.curPosition_ = 0;
516 decodeBuffer.pduBuffer_[0] = PDU_BUFFE_LENGTH_SEVEN;
517 EXPECT_FALSE(smsWapPushContentType->DecodeParameter(decodeBuffer, 1));
518 decodeBuffer.curPosition_ = 0;
519 decodeBuffer.pduBuffer_[0] = PDU_BUFFE_LENGTH_EIGHT;
520 EXPECT_FALSE(smsWapPushContentType->DecodeParameter(decodeBuffer, 1));
521 decodeBuffer.curPosition_ = 0;
522 decodeBuffer.pduBuffer_[0] = PDU_BUFFE_LENGTH_NINE;
523 EXPECT_FALSE(smsWapPushContentType->DecodeParameter(decodeBuffer, 1));
524 decodeBuffer.curPosition_ = 0;
525 decodeBuffer.pduBuffer_[0] = PDU_BUFFE_LENGTH_TEN;
526 EXPECT_FALSE(smsWapPushContentType->DecodeParameter(decodeBuffer, 1));
527 decodeBuffer.curPosition_ = 0;
528 decodeBuffer.pduBuffer_[0] = PDU_BUFFE_LENGTH_ELEVEN;
529 EXPECT_FALSE(smsWapPushContentType->DecodeParameter(decodeBuffer, 1));
530 decodeBuffer.curPosition_ = 0;
531 decodeBuffer.pduBuffer_[0] = PDU_BUFFE_LENGTH_TWELVE;
532 EXPECT_FALSE(smsWapPushContentType->DecodeParameter(decodeBuffer, 1));
533 }
534
535 /**
536 * @tc.number Telephony_SmsMmsGtest_SmsWapPushContentType_0003
537 * @tc.name Test SmsWapPushContentType
538 * @tc.desc Function test
539 */
540 HWTEST_F(BranchMmsTest, SmsWapPushContentType_0003, Function | MediumTest | Level1)
541 {
542 auto smsWapPushContentType = std::make_shared<SmsWapPushContentType>();
543 SmsWapPushBuffer decodeBuffer;
544 int32_t valueLength = 1;
545 string strCharSet = "US-ASCII";
546 string result = "*/*";
547 uint32_t charSet = 1;
548 decodeBuffer.totolLength_ = 1;
549 decodeBuffer.pduBuffer_ = std::make_unique<char[]>(1);
550 decodeBuffer.pduBuffer_[0] = PDU_BUFFE_LENGTH_THIRTEEN;
551 EXPECT_FALSE(smsWapPushContentType->DecodeParameter(decodeBuffer, 1));
552 decodeBuffer.curPosition_ = 0;
553 decodeBuffer.pduBuffer_[0] = PDU_BUFFE_LENGTH_FOURTEEN;
554 EXPECT_FALSE(smsWapPushContentType->DecodeParameter(decodeBuffer, 1));
555 decodeBuffer.curPosition_ = 0;
556 decodeBuffer.pduBuffer_[0] = 1;
557 EXPECT_FALSE(smsWapPushContentType->DecodeParameter(decodeBuffer, VALUE_LENGTH));
558 decodeBuffer.curPosition_ = 0;
559 decodeBuffer.pduBuffer_[0] = PDU_BUFFE_LENGTH;
560 EXPECT_FALSE(smsWapPushContentType->DecodeCharsetField(decodeBuffer, valueLength));
561 decodeBuffer.curPosition_ = 0;
562 decodeBuffer.pduBuffer_[0] = 0;
563 EXPECT_FALSE(smsWapPushContentType->DecodeCharsetField(decodeBuffer, valueLength));
564 decodeBuffer.curPosition_ = 0;
565 decodeBuffer.pduBuffer_[0] = PDU_BUFFE_LENGTH_TWO;
566 EXPECT_FALSE(smsWapPushContentType->DecodeCharsetField(decodeBuffer, valueLength));
567 decodeBuffer.curPosition_ = 0;
568 decodeBuffer.pduBuffer_[0] = PDU_BUFFE_LENGTH_TWO;
569 EXPECT_TRUE(smsWapPushContentType->DecodeTypeField(decodeBuffer, valueLength));
570 decodeBuffer.curPosition_ = 0;
571 decodeBuffer.pduBuffer_[0] = PDU_BUFFE_LENGTH_ONE;
572 EXPECT_TRUE(smsWapPushContentType->DecodeTypeField(decodeBuffer, valueLength));
573 EXPECT_TRUE(smsWapPushContentType->GetCharSetIntFromString(charSet, strCharSet));
574 EXPECT_EQ(smsWapPushContentType->GetContentTypeFromInt(0), result);
575 }
576
577 /**
578 * @tc.number Telephony_SmsMmsGtest_MmsBodyPart_0001
579 * @tc.name Test MmsBodyPart
580 * @tc.desc Function test
581 */
582 HWTEST_F(BranchMmsTest, MmsBodyPart_0001, Function | MediumTest | Level3)
583 {
584 MmsBodyPart mmsBodyPart;
585 MmsBodyPart testBodyPart;
586 mmsBodyPart = testBodyPart;
587 mmsBodyPart.AssignBodyPart(testBodyPart);
588 MmsDecodeBuffer decoderBuffer;
589 decoderBuffer.curPosition_ = 0;
590 decoderBuffer.totolLength_ = 0;
591 ASSERT_FALSE(mmsBodyPart.DecodePart(decoderBuffer));
592 decoderBuffer.pduBuffer_[0] = 0;
593 decoderBuffer.curPosition_ = 0;
594 decoderBuffer.totolLength_ = 1;
595 ASSERT_FALSE(mmsBodyPart.DecodePart(decoderBuffer));
596 decoderBuffer.pduBuffer_[0] = 0;
597 decoderBuffer.pduBuffer_[1] = 0;
598 decoderBuffer.curPosition_ = 0;
599 decoderBuffer.totolLength_ = 2;
600 ASSERT_FALSE(mmsBodyPart.DecodePart(decoderBuffer));
601 decoderBuffer.pduBuffer_[0] = 0;
602 decoderBuffer.pduBuffer_[1] = 0;
603 decoderBuffer.pduBuffer_[2] = 0x70;
604 decoderBuffer.curPosition_ = 0;
605 decoderBuffer.totolLength_ = 3;
606 ASSERT_FALSE(mmsBodyPart.DecodePart(decoderBuffer));
607 decoderBuffer.pduBuffer_[0] = 0x7F;
608 decoderBuffer.pduBuffer_[1] = 0;
609 decoderBuffer.pduBuffer_[2] = 0x70;
610 decoderBuffer.curPosition_ = 0;
611 decoderBuffer.totolLength_ = 10;
612 ASSERT_FALSE(mmsBodyPart.DecodePart(decoderBuffer));
613 ASSERT_TRUE(mmsBodyPart.DecodePartHeader(decoderBuffer, 0));
614 decoderBuffer.curPosition_ = 0;
615 decoderBuffer.totolLength_ = 0;
616 int32_t testLen = 3;
617 ASSERT_FALSE(mmsBodyPart.DecodePartHeader(decoderBuffer, testLen));
618 decoderBuffer.curPosition_ = 0;
619 decoderBuffer.totolLength_ = 1;
620 decoderBuffer.pduBuffer_[0] = 0x80;
621 ASSERT_FALSE(mmsBodyPart.DecodePartHeader(decoderBuffer, testLen));
622 decoderBuffer.curPosition_ = 0;
623 decoderBuffer.totolLength_ = 1;
624 decoderBuffer.pduBuffer_[0] = 0x20;
625 ASSERT_FALSE(mmsBodyPart.DecodePartHeader(decoderBuffer, testLen));
626 decoderBuffer.curPosition_ = 0;
627 decoderBuffer.totolLength_ = 1;
628 decoderBuffer.pduBuffer_[0] = 0x5;
629 ASSERT_FALSE(mmsBodyPart.DecodePartHeader(decoderBuffer, testLen));
630 }
631
632 /**
633 * @tc.number Telephony_SmsMmsGtest_MmsBodyPart_0002
634 * @tc.name Test MmsBodyPart
635 * @tc.desc Function test
636 */
637 HWTEST_F(BranchMmsTest, MmsBodyPart_0002, Function | MediumTest | Level3)
638 {
639 MmsBodyPart mmsBodyPart;
640
641 MmsDecodeBuffer decoderBuffer;
642 decoderBuffer.curPosition_ = 0;
643 decoderBuffer.totolLength_ = 0;
644 ASSERT_FALSE(mmsBodyPart.DecodePartBody(decoderBuffer, 3));
645 decoderBuffer.curPosition_ = 0;
646 int32_t offset = 2;
647 decoderBuffer.totolLength_ = MAX_MMS_MSG_PART_LEN + offset;
648 offset = 1;
649 ASSERT_FALSE(mmsBodyPart.DecodePartBody(decoderBuffer, MAX_MMS_MSG_PART_LEN + offset));
650 MmsAttachment mmsAttachment;
651 ASSERT_FALSE(mmsBodyPart.SetAttachment(mmsAttachment));
652 MmsEncodeBuffer encodeBuffer;
653 ASSERT_FALSE(mmsBodyPart.EncodeMmsBodyPart(encodeBuffer));
654 mmsBodyPart.DecodeSetFileName();
655 ASSERT_FALSE(mmsBodyPart.WriteBodyFromFile(""));
656 ASSERT_FALSE(mmsBodyPart.WriteBodyFromAttachmentBuffer(mmsAttachment));
657 mmsAttachment.strFileName_ = "test";
658 ASSERT_FALSE(mmsBodyPart.WriteBodyFromAttachmentBuffer(mmsAttachment));
659 uint32_t len = 0;
660 ASSERT_TRUE(mmsBodyPart.ReadBodyPartBuffer(len) == nullptr);
661 }
662
663 /**
664 * @tc.number Telephony_SmsMmsGtest_MmsContentType_0001
665 * @tc.name Test MmsContentType
666 * @tc.desc Function test
667 */
668 HWTEST_F(BranchMmsTest, MmsContentType_0001, Function | MediumTest | Level3)
669 {
670 MmsContentType mmsContentType;
671 MmsContentType mmsTContentType;
672 mmsTContentType.contentType_ = "lll";
673 mmsContentType = mmsTContentType;
674 MmsDecodeBuffer decoderBuffer;
675 int32_t testPduBuffer = 0x8f;
676 decoderBuffer.pduBuffer_[0] = testPduBuffer;
677 decoderBuffer.curPosition_ = 0;
678 decoderBuffer.totolLength_ = 1;
679 int32_t length;
680 ASSERT_TRUE(mmsContentType.DecodeMmsContentType(decoderBuffer, length));
681 decoderBuffer.curPosition_ = 0;
682 decoderBuffer.totolLength_ = 1;
683 testPduBuffer = 0x2f;
684 decoderBuffer.pduBuffer_[0] = testPduBuffer;
685 ASSERT_FALSE(mmsContentType.DecodeMmsCTGeneralForm(decoderBuffer, length));
686 decoderBuffer.curPosition_ = 0;
687 decoderBuffer.totolLength_ = 0;
688 ASSERT_FALSE(mmsContentType.DecodeMmsCTGeneralForm(decoderBuffer, length));
689 decoderBuffer.curPosition_ = 0;
690 decoderBuffer.totolLength_ = 1;
691 testPduBuffer = 0x8f;
692 decoderBuffer.pduBuffer_[0] = testPduBuffer;
693 ASSERT_FALSE(mmsContentType.DecodeMmsCTGeneralForm(decoderBuffer, length));
694 decoderBuffer.curPosition_ = 0;
695 decoderBuffer.totolLength_ = 1;
696 decoderBuffer.pduBuffer_[0] = 0;
697 ASSERT_FALSE(mmsContentType.DecodeMmsCTGeneralForm(decoderBuffer, length));
698 }
699
700 /**
701 * @tc.number Telephony_SmsMmsGtest_MmsContentType_0002
702 * @tc.name Test MmsContentType
703 * @tc.desc Function test
704 */
705 HWTEST_F(BranchMmsTest, MmsContentType_0002, Function | MediumTest | Level3)
706 {
707 MmsContentType mmsContentType;
708 MmsDecodeBuffer decoderBuffer;
709 ASSERT_TRUE(mmsContentType.DecodeParameter(decoderBuffer, 0));
710 decoderBuffer.curPosition_ = 0;
711 decoderBuffer.totolLength_ = 0;
712 ASSERT_FALSE(mmsContentType.DecodeParameter(decoderBuffer, 1));
713 int32_t testPduBuffer = 129;
714 decoderBuffer.pduBuffer_[0] = testPduBuffer;
715 decoderBuffer.curPosition_ = 0;
716 decoderBuffer.totolLength_ = 1;
717 ASSERT_FALSE(mmsContentType.DecodeParameter(decoderBuffer, 1));
718 testPduBuffer = 154;
719 decoderBuffer.pduBuffer_[0] = testPduBuffer;
720 decoderBuffer.curPosition_ = 0;
721 decoderBuffer.totolLength_ = 1;
722 ASSERT_FALSE(mmsContentType.DecodeParameter(decoderBuffer, 1));
723 testPduBuffer = 137;
724 decoderBuffer.pduBuffer_[0] = testPduBuffer;
725 decoderBuffer.curPosition_ = 0;
726 decoderBuffer.totolLength_ = 1;
727 ASSERT_FALSE(mmsContentType.DecodeParameter(decoderBuffer, 1));
728 decoderBuffer.pduBuffer_[0] = 0;
729 decoderBuffer.curPosition_ = 0;
730 decoderBuffer.totolLength_ = 1;
731 ASSERT_FALSE(mmsContentType.DecodeParameter(decoderBuffer, 4));
732 decoderBuffer.curPosition_ = 0;
733 decoderBuffer.totolLength_ = 0;
734 int32_t len;
735 ASSERT_FALSE(mmsContentType.DecodeTextField(decoderBuffer, 0, len));
736 ASSERT_FALSE(mmsContentType.DecodeCharsetField(decoderBuffer, len));
737 testPduBuffer = 100;
738 decoderBuffer.pduBuffer_[0] = testPduBuffer;
739 decoderBuffer.curPosition_ = 0;
740 decoderBuffer.totolLength_ = 1;
741 ASSERT_FALSE(mmsContentType.DecodeCharsetField(decoderBuffer, len));
742 testPduBuffer = 30;
743 decoderBuffer.pduBuffer_[0] = testPduBuffer;
744 decoderBuffer.curPosition_ = 0;
745 decoderBuffer.totolLength_ = 1;
746 ASSERT_FALSE(mmsContentType.DecodeCharsetField(decoderBuffer, len));
747 }
748
749 /**
750 * @tc.number Telephony_SmsMmsGtest_MmsContentType_0003
751 * @tc.name Test MmsContentType
752 * @tc.desc Function test
753 */
754 HWTEST_F(BranchMmsTest, MmsContentType_0003, Function | MediumTest | Level3)
755 {
756 MmsEncodeBuffer mmsEncodeBuffer;
757 MmsContentType mmsContentType;
758 MmsDecodeBuffer decoderBuffer;
759 decoderBuffer.curPosition_ = 0;
760 decoderBuffer.totolLength_ = 0;
761 int32_t valueLen = 0;
762 ASSERT_FALSE(mmsContentType.DecodeTypeField(decoderBuffer, valueLen));
763 decoderBuffer.pduBuffer_[0] = 0x8f;
764 decoderBuffer.curPosition_ = 0;
765 decoderBuffer.totolLength_ = 1;
766 ASSERT_TRUE(mmsContentType.DecodeTypeField(decoderBuffer, valueLen));
767 decoderBuffer.pduBuffer_[0] = 0;
768 decoderBuffer.curPosition_ = 0;
769 decoderBuffer.totolLength_ = 1;
770 ASSERT_FALSE(mmsContentType.DecodeTypeField(decoderBuffer, valueLen));
771 mmsContentType.msgContentParm_.textMap_[152] = "";
772 int32_t offset = 1;
773 mmsEncodeBuffer.curPosition_ = CODE_BUFFER_MAX_SIZE + offset;
774 mmsContentType.EncodeTextField(mmsEncodeBuffer);
775 mmsContentType.msgContentParm_.textMap_[152] = "";
776 mmsEncodeBuffer.curPosition_ = 0;
777 ASSERT_TRUE(mmsContentType.EncodeTextField(mmsEncodeBuffer));
778 ASSERT_TRUE(mmsContentType.EncodeCharsetField(mmsEncodeBuffer));
779 mmsContentType.msgContentParm_.charset_ = offset;
780 ASSERT_TRUE(mmsContentType.EncodeCharsetField(mmsEncodeBuffer));
781 mmsContentType.msgContentParm_.charset_ = offset;
782 mmsEncodeBuffer.curPosition_ = CODE_BUFFER_MAX_SIZE + offset;
783 mmsContentType.EncodeCharsetField(mmsEncodeBuffer);
784 mmsContentType.msgContentParm_.charset_ = offset;
785 mmsEncodeBuffer.curPosition_ = CODE_BUFFER_MAX_SIZE - offset;
786 mmsContentType.EncodeCharsetField(mmsEncodeBuffer);
787 mmsContentType.msgContentParm_.charset_ = offset;
788 mmsEncodeBuffer.curPosition_ = 0;
789 ASSERT_TRUE(mmsContentType.EncodeCharsetField(mmsEncodeBuffer));
790 }
791
792 /**
793 * @tc.number Telephony_SmsMmsGtest_MmsContentType_0004
794 * @tc.name Test MmsContentType
795 * @tc.desc Function test
796 */
797 HWTEST_F(BranchMmsTest, MmsContentType_0004, Function | MediumTest | Level3)
798 {
799 MmsContentType mmsContentType;
800 MmsEncodeBuffer mmsEncodeBuffer;
801 ASSERT_TRUE(mmsContentType.EncodeTypeField(mmsEncodeBuffer));
802 mmsContentType.msgContentParm_.type_ = "1";
803 int32_t offset = 1;
804 mmsEncodeBuffer.curPosition_ = CODE_BUFFER_MAX_SIZE + offset;
805 ASSERT_FALSE(mmsContentType.EncodeTypeField(mmsEncodeBuffer));
806 mmsContentType.msgContentParm_.type_ = "1";
807 mmsEncodeBuffer.curPosition_ = CODE_BUFFER_MAX_SIZE - offset;
808 ASSERT_FALSE(mmsContentType.EncodeTypeField(mmsEncodeBuffer));
809 mmsContentType.msgContentParm_.type_ = "1";
810 mmsEncodeBuffer.curPosition_ = CODE_BUFFER_MAX_SIZE - offset;
811 ASSERT_FALSE(mmsContentType.EncodeTypeField(mmsEncodeBuffer));
812 mmsContentType.msgContentParm_.textMap_[152] = "";
813 mmsEncodeBuffer.curPosition_ = CODE_BUFFER_MAX_SIZE + offset;
814 ASSERT_FALSE(mmsContentType.EncodeMmsBodyPartContentParam(mmsEncodeBuffer));
815 mmsContentType.msgContentParm_.textMap_[152] = "";
816 mmsEncodeBuffer.curPosition_ = CODE_BUFFER_MAX_SIZE - offset;
817 ASSERT_FALSE(mmsContentType.EncodeMmsBodyPartContentParam(mmsEncodeBuffer));
818 mmsContentType.msgContentParm_.textMap_[152] = "";
819 offset = 2;
820 mmsEncodeBuffer.curPosition_ = CODE_BUFFER_MAX_SIZE - offset;
821 ASSERT_FALSE(mmsContentType.EncodeMmsBodyPartContentParam(mmsEncodeBuffer));
822 mmsContentType.contentType_ = "";
823 ASSERT_FALSE(mmsContentType.EncodeMmsBodyPartContentType(mmsEncodeBuffer));
824 mmsContentType.contentType_ = "*/*";
825 ASSERT_FALSE(mmsContentType.EncodeMmsBodyPartContentType(mmsEncodeBuffer));
826 mmsEncodeBuffer.curPosition_ = CODE_BUFFER_MAX_SIZE + offset;
827 ASSERT_FALSE(mmsContentType.EncodeMmsBodyPartContentType(mmsEncodeBuffer));
828 }
829
830 /**
831
832 * @tc.number Telephony_SmsMmsGtest_MmsBody_0001
833 * @tc.name Test MmsBody
834 * @tc.desc Function test
835 */
836 HWTEST_F(BranchMmsTest, SmsMmsGtest_MmsBody_0001, Function | MediumTest | Level1)
837 {
838 MmsBody mmsBody;
839 MmsDecodeBuffer mmsDecodeBuffer;
840 MmsHeader mmsHeader;
841 MmsEncodeBuffer mmsEncodeBuffer;
842 MmsBodyPart mmsBodyPart;
843 mmsDecodeBuffer.curPosition_ = 1;
844 mmsDecodeBuffer.totolLength_ = 0;
845 EXPECT_FALSE(mmsBody.DecodeMultipart(mmsDecodeBuffer));
846 EXPECT_FALSE(mmsBody.DecodeMmsBody(mmsDecodeBuffer, mmsHeader));
847 EXPECT_TRUE(mmsBody.EncodeMmsBody(mmsEncodeBuffer));
848 EXPECT_FALSE(mmsBody.EncodeMmsHeaderContentType(mmsHeader, mmsEncodeBuffer));
849 EXPECT_FALSE(mmsBody.IsContentLocationPartExist(""));
850 EXPECT_FALSE(mmsBody.IsContentIdPartExist(""));
851 EXPECT_FALSE(mmsBody.IsBodyPartExist(mmsBodyPart));
852 EXPECT_TRUE(mmsBody.AddMmsBodyPart(mmsBodyPart));
853 mmsBodyPart.isSmilFile_ = true;
854 EXPECT_TRUE(mmsBody.AddMmsBodyPart(mmsBodyPart));
855 mmsBody.bHaveSmilPart_ = true;
856 EXPECT_FALSE(mmsBody.AddMmsBodyPart(mmsBodyPart));
857 }
858
859 /**
860 * @tc.number Telephony_SmsMmsGtest_MmsMsg_0001
861 * @tc.name Test MmsMsg
862 * @tc.desc Function test
863 */
864 HWTEST_F(BranchMmsTest, SmsMmsGtest_MmsMsg_0001, Function | MediumTest | Level1)
865 {
866 MmsMsg mmsMsg;
867 uint32_t outLen;
868 std::vector<MmsAddress> toAddrs = {};
869 MmsAttachment mmsAttachment;
870 std::vector<MmsAttachment> attachments = {};
871 EXPECT_FALSE(mmsMsg.DecodeMsg(""));
872 EXPECT_FALSE(mmsMsg.DecodeMsg(nullptr, 0));
873 mmsMsg.EncodeMsg(outLen);
874 mmsMsg.GetMmsFrom();
875 EXPECT_FALSE(mmsMsg.SetMmsTo(toAddrs));
876 mmsMsg.GetHeaderStringValue(0);
877 mmsMsg.GetHeaderContentTypeStart();
878 EXPECT_FALSE(mmsMsg.AddAttachment(mmsAttachment));
879 EXPECT_FALSE(mmsMsg.GetAllAttachment(attachments));
880 }
881
882 /**
883 * @tc.number Telephony_SmsMmsGtest_MmsBodyPartHeader_0001
884 * @tc.name Test SmsMiscManager
885 * @tc.desc Function test
886 */
887 HWTEST_F(BranchMmsTest, MmsBodyPartHeader_0001, Function | MediumTest | Level1)
888 {
889 auto mmsBodyPartHeader = std::make_shared<MmsBodyPartHeader>();
890 MmsDecodeBuffer decodeBuffer;
891 uint32_t len = 1;
892 decodeBuffer.curPosition_ = 0;
893 decodeBuffer.totolLength_ = 0;
894 EXPECT_FALSE(mmsBodyPartHeader->DecodeContentDisposition(decodeBuffer, len));
895 MmsEncodeBuffer encodeBuffer;
896 mmsBodyPartHeader->strContentTransferEncoding_ = "";
897 EXPECT_TRUE(mmsBodyPartHeader->EncodeContentTransferEncoding(encodeBuffer));
898 EXPECT_TRUE(mmsBodyPartHeader->EncodeContentLocation(encodeBuffer));
899 EXPECT_TRUE(mmsBodyPartHeader->EncodeContentId(encodeBuffer));
900 encodeBuffer.curPosition_ = CODE_BUFFER_MAX_SIZE;
901 mmsBodyPartHeader->strContentLocation_ = "123";
902 EXPECT_FALSE(mmsBodyPartHeader->EncodeMmsBodyPartHeader(encodeBuffer));
903 mmsBodyPartHeader->strContentID_ = "123";
904 encodeBuffer.curPosition_ = CODE_BUFFER_MAX_SIZE;
905 EXPECT_FALSE(mmsBodyPartHeader->EncodeContentLocation(encodeBuffer));
906 EXPECT_FALSE(mmsBodyPartHeader->EncodeContentId(encodeBuffer));
907 EXPECT_FALSE(mmsBodyPartHeader->EncodeMmsBodyPartHeader(encodeBuffer));
908 }
909 } // namespace Telephony
910 } // namespace OHOS
911