1/*
2 * Copyright (C) 2023-2024 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 "cdma_sms_transport_message.h"
20#include "core_manager_inner.h"
21#include "core_service_client.h"
22#include "gtest/gtest.h"
23#include "i_sms_service_interface.h"
24#include "if_system_ability_manager.h"
25#include "iservice_registry.h"
26#include "mms_address.h"
27#include "mms_apn_info.h"
28#include "mms_attachment.h"
29#include "mms_base64.h"
30#include "mms_body.h"
31#include "mms_body_part.h"
32#include "mms_body_part_header.h"
33#include "mms_charset.h"
34#include "mms_codec_type.h"
35#include "mms_decode_buffer.h"
36#include "mms_header.h"
37#include "mms_msg.h"
38#include "mms_persist_helper.h"
39#include "mms_quoted_printable.h"
40#include "pdp_profile_data.h"
41#include "radio_event.h"
42#include "sms_broadcast_subscriber_gtest.h"
43#include "sms_mms_gtest.h"
44#include "sms_mms_test_helper.h"
45#include "sms_service.h"
46#include "sms_service_manager_client.h"
47#include "string_utils.h"
48#include "telephony_log_wrapper.h"
49#include "telephony_types.h"
50#include "uri.h"
51
52namespace OHOS {
53namespace Telephony {
54namespace {
55sptr<ISmsServiceInterface> g_telephonyService = nullptr;
56} // namespace
57using namespace testing::ext;
58
59class MmsGtest : public testing::Test {
60public:
61    static void SetUpTestCase();
62    static void TearDownTestCase();
63    void SetUp();
64    void TearDown();
65    static sptr<ISmsServiceInterface> GetProxy();
66    static bool HasSimCard(int32_t slotId)
67    {
68        bool hasSimCard = false;
69        if (CoreServiceClient::GetInstance().GetProxy() == nullptr) {
70            return hasSimCard;
71        }
72        CoreServiceClient::GetInstance().HasSimCard(slotId, hasSimCard);
73        return hasSimCard;
74    }
75};
76
77void MmsGtest::TearDownTestCase() {}
78
79void MmsGtest::SetUp() {}
80
81void MmsGtest::TearDown() {}
82
83const int32_t DEFAULT_SIM_SLOT_ID_1 = 1;
84const uint16_t MESSAGE_TYPE = 4;
85const uint16_t WAPPUSH_PDU_LEN = 164;
86const uint32_t MAX_MMS_ATTACHMENT_LEN = 10 * 1024 * 1024;
87const char PDU_TEST_DATA = 35;
88const char MIN_SHORT_OCTET = 30;
89const char QUOTE_CHAR_LEN = 0X7F - 1;
90const char VALUE_CHAR = 8;
91const char PDU_COUNT = 10;
92const char PDU_CUSITION = 5;
93const char PDU_LENGTH = 4;
94const char *ENCODE_CHARSET = "01010101";
95const uint32_t ENCODE_CHARSET1 = 0x0100;
96const uint32_t ENCODE_CHARSET2 = 0x0001;
97const uint32_t MMS_PDU_MAX_SIZE = 300 * 1024;
98static constexpr const char *PDU = "pdu";
99static constexpr uint32_t MAX_PDU_PAGES = 4;
100static constexpr uint8_t HEX_VALUE_0F = 0x0F;
101static constexpr uint8_t HEX_VALUE_F0 = 0xF0;
102static constexpr uint32_t SPLIT_PDU_LENGTH = 195 * 1024;
103static constexpr const char *PDU_CONTENT = "pdu_content";
104const std::string PDP_PROFILE_NET_URI = "datashare:///com.ohos.pdpprofileability/net/pdp_profile?simId=";
105const std::string MMS_APN_TYPE = "mms";
106const std::string ALL_APN_TYPE = "*";
107const std::string MMS_FILE_ADDRESS = "/data/app/test.mms";
108const std::string SMS_PROFILE_MMS_PDU_URI = "datashare:///com.ohos.smsmmsability/sms_mms/mms_pdu";
109
110void MmsGtest::SetUpTestCase()
111{
112    TELEPHONY_LOGI("SetUpTestCase slotId%{public}d", DEFAULT_SIM_SLOT_ID_1);
113    g_telephonyService = GetProxy();
114    if (g_telephonyService == nullptr) {
115        return;
116    }
117    Singleton<SmsServiceManagerClient>::GetInstance().ResetSmsServiceProxy();
118    Singleton<SmsServiceManagerClient>::GetInstance().InitSmsServiceProxy();
119}
120
121sptr<ISmsServiceInterface> MmsGtest::GetProxy()
122{
123    auto systemAbilityMgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
124    if (systemAbilityMgr == nullptr) {
125        return nullptr;
126    }
127    sptr<IRemoteObject> remote = systemAbilityMgr->CheckSystemAbility(TELEPHONY_SMS_MMS_SYS_ABILITY_ID);
128    if (remote) {
129        sptr<ISmsServiceInterface> smsService = iface_cast<ISmsServiceInterface>(remote);
130        return smsService;
131    }
132    return nullptr;
133}
134
135#ifndef TEL_TEST_UNSUPPORT
136void ReceiveWapPushTestFunc(SmsMmsTestHelper &helper)
137{
138    AccessMmsToken token;
139    auto smsReceiveHandler = std::make_shared<GsmSmsReceiveHandler>(helper.slotId);
140    auto message = std::make_shared<SmsMessageInfo>();
141    message->indicationType = MESSAGE_TYPE;
142    message->size = WAPPUSH_PDU_LEN;
143    message->pdu = StringUtils::HexToByteVector(
144        "0891683110205005F0640BA10156455102F1000432109261715023880605040B8423F04C06246170706C69636174696F6E2F766E642E77"
145        "61702E6D6D732D6D65737361676500B487AF848C829850765030303031365A645430008D9089178031363630373532313930382F545950"
146        "453D504C4D4E008A808E040001298D"
147        "8805810303F47B83687474703A2F2F31302E3132332E31382E38303A3138302F76564F455F3000");
148
149    AppExecFwk::InnerEvent::Pointer event = AppExecFwk::InnerEvent::Get(RadioEvent::RADIO_GSM_SMS, message);
150    smsReceiveHandler->ProcessEvent(event);
151}
152
153void GetSendReqDataTest(MmsMsg &encodeMsg, std::string number)
154{
155    if (!encodeMsg.SetMmsMessageType(MMS_MSGTYPE_SEND_REQ)) {
156        TELEPHONY_LOGE("SetMmsMessageType fail");
157    }
158    if (!encodeMsg.SetMmsTransactionId("2077.1427358451410")) {
159        TELEPHONY_LOGE("SetMmsTransactionId fail");
160    }
161    if (!encodeMsg.SetMmsVersion(static_cast<uint16_t>(MmsVersionType::MMS_VERSION_1_2))) {
162        TELEPHONY_LOGE("SetMmsVersion fail");
163    }
164    MmsAddress address;
165    address.SetMmsAddressString(number);
166    if (!encodeMsg.SetMmsFrom(address)) {
167        TELEPHONY_LOGE("SetMmsFrom fail");
168    }
169    if (!encodeMsg.SetHeaderContentType("application/vnd.wap.multipart.related")) {
170        TELEPHONY_LOGE("SetHeaderContentType fail");
171    }
172    if (!encodeMsg.SetMmsSubject("mms")) {
173        TELEPHONY_LOGE("SetMmsSubject fail");
174    }
175    if (!encodeMsg.SetHeaderOctetValue(MMS_CONTENT_CLASS, static_cast<uint8_t>(MmsContentClass::MMS_TEXT))) {
176        TELEPHONY_LOGE("SetHeaderOctetValue MMS_CONTENT_CLASS fail");
177    }
178}
179
180bool MmsAddAttachment(MmsMsg &msg, std::string pathName, std::string contentId, std::string contenType, bool isSmil)
181{
182    MmsAttachment imageAttachment;
183    std::size_t pos = pathName.find_last_of('/');
184    std::string fileName(pathName.substr(pos + 1));
185    if (!imageAttachment.SetAttachmentFilePath(pathName, isSmil)) {
186        TELEPHONY_LOGE("MmsAddAttachment SetAttachmentFilePath fail");
187        return false;
188    }
189    if (!imageAttachment.SetFileName(fileName)) {
190        TELEPHONY_LOGE("MmsAddAttachment SetFileName fail");
191        return false;
192    }
193    if (!imageAttachment.SetContentId(contentId)) {
194        TELEPHONY_LOGE("MmsAddAttachment SetContentId fail");
195        return false;
196    }
197    if (!imageAttachment.SetContentLocation(fileName)) {
198        TELEPHONY_LOGE("MmsAddAttachment SetContentLocation fail");
199        return false;
200    }
201    if (!imageAttachment.SetContentType(contenType)) {
202        TELEPHONY_LOGE("MmsAddAttachment SetContentType fail");
203        return false;
204    }
205    imageAttachment.SetContentDisposition("attachment");
206    if (!msg.AddAttachment(imageAttachment)) {
207        TELEPHONY_LOGE("MmsAddAttachment AddAttachment fail");
208        return false;
209    }
210    return true;
211}
212
213bool WriteBufferToFile(const std::unique_ptr<char[]> &buff, uint32_t len, const std::string &strPathName)
214{
215    FILE *pFile = nullptr;
216    pFile = fopen(strPathName.c_str(), "wb");
217    if (!pFile || buff == nullptr) {
218        return false;
219    }
220    uint32_t fileLen = fwrite(buff.get(), len, 1, pFile);
221    if (fileLen > 0) {
222        TELEPHONY_LOGD("write mms buffer to file success");
223    } else {
224        TELEPHONY_LOGE("write mms buffer to file error");
225    }
226    (void)fclose(pFile);
227    return true;
228}
229
230bool GetMmsPduFromFile(const std::string &fileName, std::string &mmsPdu)
231{
232    char realPath[PATH_MAX] = { 0 };
233    if (fileName.empty() || realpath(fileName.c_str(), realPath) == nullptr) {
234        TELEPHONY_LOGE("path or realPath is nullptr");
235        return false;
236    }
237    FILE *pFile = fopen(realPath, "rb");
238    if (pFile == nullptr) {
239        TELEPHONY_LOGE("openFile Error");
240        return false;
241    }
242    (void)fseek(pFile, 0, SEEK_END);
243    long fileLen = ftell(pFile);
244    if (fileLen <= 0 || fileLen > static_cast<long>(MMS_PDU_MAX_SIZE)) {
245        (void)fclose(pFile);
246        TELEPHONY_LOGE("fileLen Over Max Error");
247        return false;
248    }
249    std::unique_ptr<char[]> pduBuffer = std::make_unique<char[]>(fileLen);
250    if (!pduBuffer) {
251        (void)fclose(pFile);
252        TELEPHONY_LOGE("make unique pduBuffer nullptr Error");
253        return false;
254    }
255    (void)fseek(pFile, 0, SEEK_SET);
256    int32_t totolLength = static_cast<int32_t>(fread(pduBuffer.get(), 1, MMS_PDU_MAX_SIZE, pFile));
257    TELEPHONY_LOGI("fread totolLength%{public}d", totolLength);
258    long i = 0;
259    while (i < fileLen) {
260        mmsPdu += pduBuffer[i];
261        i++;
262    }
263    (void)fclose(pFile);
264    return true;
265}
266
267std::vector<std::string> SplitPdu(const std::string &mmsPdu)
268{
269    std::vector<std::string> mmsPdus;
270    if (mmsPdu.compare(PDU) == 0) {
271        for (uint32_t locate = 0; locate < MAX_PDU_PAGES; locate++) {
272            mmsPdus.push_back(PDU);
273        }
274        return mmsPdus;
275    }
276    std::string targetMmsPdu;
277    for (size_t i = 0; i < mmsPdu.size(); i++) {
278        targetMmsPdu += static_cast<char>((mmsPdu[i] & HEX_VALUE_0F) | HEX_VALUE_F0);
279        targetMmsPdu += static_cast<char>((mmsPdu[i] & HEX_VALUE_F0) | HEX_VALUE_0F);
280    }
281    std::string mmsPduData;
282    for (uint32_t locate = 0; locate * SPLIT_PDU_LENGTH < targetMmsPdu.size(); locate++) {
283        if ((locate + 1) * SPLIT_PDU_LENGTH < targetMmsPdu.size()) {
284            mmsPduData = targetMmsPdu.substr(locate * SPLIT_PDU_LENGTH, SPLIT_PDU_LENGTH);
285            mmsPdus.push_back(mmsPduData);
286        } else {
287            mmsPduData = targetMmsPdu.substr(locate * SPLIT_PDU_LENGTH);
288            mmsPdus.push_back(mmsPduData);
289            break;
290        }
291    }
292    TELEPHONY_LOGI("pduLen:%{public}zu,targetPduLen:%{public}zu", mmsPdu.size(), targetMmsPdu.size());
293    return mmsPdus;
294}
295
296void GetPduToFile(int32_t slotId)
297{
298    SmsMmsTestHelper smsMmsTestHelper;
299    smsMmsTestHelper.slotId = slotId;
300    std::string dest = "10086";
301    std::u16string simcardNumber;
302    if (!CoreServiceClient::GetInstance().GetSimTelephoneNumber(smsMmsTestHelper.slotId, simcardNumber) &&
303        !simcardNumber.empty()) {
304        dest = StringUtils::ToUtf8(simcardNumber);
305    }
306    MmsMsg encodeMsg;
307    std::vector<MmsAddress> vecAddrs;
308    std::string toAddr = dest + "/TYPE=PLMN";
309    MmsAddress toAddrs(toAddr);
310    GetSendReqDataTest(encodeMsg, toAddr);
311    vecAddrs.push_back(toAddrs);
312    if (!encodeMsg.SetMmsTo(vecAddrs)) {
313        TELEPHONY_LOGE("SetMmsTo fail");
314    }
315    const std::string filePathNameText = "/data/app/mms.text";
316    const char *source = "mms";
317    size_t sourceLen = std::strlen(source);
318    std::unique_ptr<char[]> text = std::make_unique<char[]>(sourceLen + 1);
319    if (snprintf_s(text.get(), sourceLen + 1, sourceLen + 1, "%s", source) < 0) {
320        TELEPHONY_LOGE("snprintf_s failed");
321        return;
322    }
323    if (!WriteBufferToFile(std::move(text), std::strlen(source) + 1, filePathNameText)) {
324        TELEPHONY_LOGE("file error.");
325    }
326    if (!MmsAddAttachment(encodeMsg, filePathNameText, "<content.text>", "text/plain", false)) {
327        TELEPHONY_LOGE("MmsAddAttachment text fail");
328    }
329    uint32_t len = 0;
330    std::unique_ptr<char[]> results = encodeMsg.EncodeMsg(len);
331    if (results == nullptr) {
332        TELEPHONY_LOGE("encode fail result nullptr !!!!");
333    }
334    if (!WriteBufferToFile(std::move(results), len, MMS_FILE_ADDRESS)) {
335        TELEPHONY_LOGE("Encode write to file error.");
336    }
337}
338
339std::string GetFileToDb()
340{
341    std::string mmsPdu;
342    GetMmsPduFromFile(MMS_FILE_ADDRESS, mmsPdu);
343    Uri uri(SMS_PROFILE_MMS_PDU_URI);
344    std::shared_ptr<MmsPersistHelper> mmsPersistHelper = std::make_shared<MmsPersistHelper>();
345    if (mmsPersistHelper == nullptr) {
346        return "";
347    }
348    std::shared_ptr<DataShare::DataShareHelper> helper = mmsPersistHelper->CreateSmsHelper();
349    if (helper == nullptr) {
350        return "";
351    }
352    std::vector<std::string> mmsPdus = SplitPdu(mmsPdu);
353    std::string dbUrl;
354    for (std::string mmsPdu : mmsPdus) {
355        DataShare::DataShareValuesBucket bucket;
356        bucket.Put(PDU_CONTENT, mmsPdu);
357        int32_t result = helper->Insert(uri, bucket);
358        if (result < 0) {
359            TELEPHONY_LOGE("mms pdu insert fail");
360        }
361        dbUrl += std::to_string(result) + ',';
362    }
363    helper->Release();
364    return dbUrl;
365}
366
367std::string GetMmsc(int32_t slotId)
368{
369    int32_t simId = CoreManagerInner::GetInstance().GetSimId(slotId);
370    Uri pdpUri(PDP_PROFILE_NET_URI + std::to_string(simId));
371    std::vector<std::string> colume;
372    DataShare::DataSharePredicates predicates;
373    std::u16string operatorNumeric;
374    CoreServiceClient::GetInstance().GetSimOperatorNumeric(slotId, operatorNumeric);
375    std::string mccmnc = StringUtils::ToUtf8(operatorNumeric);
376    predicates.EqualTo(PdpProfileData::MCCMNC, mccmnc);
377    std::shared_ptr<MmsApnInfo> mmsApnInfo = std::make_shared<MmsApnInfo>(slotId);
378    auto pdpHelper = mmsApnInfo->CreatePdpProfileHelper();
379    if (pdpHelper == nullptr) {
380        return "";
381    }
382    auto resultSet = pdpHelper->Query(pdpUri, predicates, colume);
383    if (resultSet == nullptr) {
384        pdpHelper->Release();
385        return "";
386    }
387    int count;
388    resultSet->GetRowCount(count);
389    if (count <= 0) {
390        resultSet->Close();
391        pdpHelper->Release();
392        return "";
393    }
394    std::string homeUrlVal;
395    std::string mmsIPAddressVal;
396    if (!mmsApnInfo->GetMmsApnValue(resultSet, count, homeUrlVal, mmsIPAddressVal)) {
397        TELEPHONY_LOGI("homeUrlVal and mmsIPAddressVal not matched");
398        resultSet->Close();
399        pdpHelper->Release();
400        return "";
401    }
402    resultSet->Close();
403    pdpHelper->Release();
404    return homeUrlVal;
405}
406
407/**
408 * @tc.number   Telephony_SmsMmsGtest_Receive_Wap_Push_0001
409 * @tc.name     Receive a Wap Push
410 * @tc.desc     Function test
411 */
412HWTEST_F(MmsGtest, Receive_Wap_Push_0001, Function | MediumTest | Level2)
413{
414    TELEPHONY_LOGI("TelSMSMMSTest::Receive_Wap_Push_0001 -->");
415    int32_t slotId = DEFAULT_SIM_SLOT_ID;
416    if (!(MmsGtest::HasSimCard(slotId))) {
417        TELEPHONY_LOGI("TelephonyTestService has no sim card");
418        ASSERT_FALSE(MmsGtest::HasSimCard(slotId));
419        return;
420    }
421    SmsMmsTestHelper helper;
422    helper.slotId = slotId;
423
424    EventFwk::MatchingSkills matchingSkills;
425    matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_SMS_WAPPUSH_RECEIVE_COMPLETED);
426    EventFwk::CommonEventSubscribeInfo subscriberInfo(matchingSkills);
427    std::shared_ptr<SmsBroadcastSubscriberGtest> subscriberTest =
428        std::make_shared<SmsBroadcastSubscriberGtest>(subscriberInfo, helper);
429    ASSERT_NE(subscriberTest, nullptr);
430    bool subscribeResult = EventFwk::CommonEventManager::SubscribeCommonEvent(subscriberTest);
431    TELEPHONY_LOGI("subscribeResult is : %{public}d", subscribeResult);
432
433    if (!helper.Run(ReceiveWapPushTestFunc, helper)) {
434        TELEPHONY_LOGI("ReceiveWapPushTestFunc out of time");
435        ASSERT_TRUE(helper.Run(ReceiveWapPushTestFunc, helper));
436        return;
437    }
438    TELEPHONY_LOGI("TelSMSMMSTest::Receive_Wap_Push_0001 -->finished");
439    EXPECT_TRUE(helper.GetBoolResult());
440}
441
442/**
443 * @tc.number   Telephony_SmsMmsGtest_Receive_Wap_Push_0002
444 * @tc.name     Receive a Wap Push
445 * @tc.desc     Function test
446 */
447HWTEST_F(MmsGtest, Receive_Wap_Push_0002, Function | MediumTest | Level2)
448{
449    TELEPHONY_LOGI("TelSMSMMSTest::Receive_Wap_Push_0002 -->");
450    int32_t slotId = DEFAULT_SIM_SLOT_ID_1;
451    if (!(MmsGtest::HasSimCard(slotId))) {
452        TELEPHONY_LOGI("TelephonyTestService has no sim card");
453        ASSERT_FALSE(MmsGtest::HasSimCard(slotId));
454        return;
455    }
456    SmsMmsTestHelper helper;
457    helper.slotId = slotId;
458
459    EventFwk::MatchingSkills matchingSkills;
460    matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_SMS_WAPPUSH_RECEIVE_COMPLETED);
461    EventFwk::CommonEventSubscribeInfo subscriberInfo(matchingSkills);
462    std::shared_ptr<SmsBroadcastSubscriberGtest> subscriberTest =
463        std::make_shared<SmsBroadcastSubscriberGtest>(subscriberInfo, helper);
464    ASSERT_NE(subscriberTest, nullptr);
465    bool subscribeResult = EventFwk::CommonEventManager::SubscribeCommonEvent(subscriberTest);
466    TELEPHONY_LOGI("subscribeResult is : %{public}d", subscribeResult);
467
468    if (!helper.Run(ReceiveWapPushTestFunc, helper)) {
469        TELEPHONY_LOGI("ReceiveWapPushTestFunc out of time");
470        ASSERT_FALSE(helper.Run(ReceiveWapPushTestFunc, helper));
471        return;
472    }
473    TELEPHONY_LOGI("TelSMSMMSTest::Receive_Wap_Push_0002 -->finished");
474    EXPECT_TRUE(helper.GetBoolResult());
475}
476
477/**
478 * @tc.number   Telephony_SmsMmsGtest_MmsAddress_0001
479 * @tc.name     Test MmsAddress
480 * @tc.desc     Function test
481 */
482HWTEST_F(MmsGtest, MmsAddress_0001, Function | MediumTest | Level1)
483{
484    TELEPHONY_LOGI("TelSMSMMSTest::MmsAddress_0001 -->");
485    MmsAddress address;
486    address.SetMmsAddressString("12345678/TYPE=PLMN");
487    address.SetMmsAddressString("12345678/TYPE=IPv4");
488    address.SetMmsAddressString("12345678/TYPE=IPv6");
489    address.SetMmsAddressString("12345678/TYPE=UNKNOWN");
490    address.SetMmsAddressString("12345678/TYPE=EMAIL");
491    std::string ret = address.GetAddressString();
492    EXPECT_STREQ(ret.c_str(), "12345678/TYPE=EMAIL");
493    MmsAddress::MmsAddressType type = address.GetAddressType();
494    EXPECT_EQ(type, MmsAddress::MmsAddressType::ADDRESS_TYPE_PLMN);
495    MmsCharSets charset = address.GetAddressCharset();
496    EXPECT_EQ(charset, MmsCharSets::UTF_8);
497}
498
499/**
500 * @tc.number   Telephony_SmsMmsGtest_MmsAttachment_0001
501 * @tc.name     Test MmsAttachment
502 * @tc.desc     Function test
503 */
504HWTEST_F(MmsGtest, MmsAttachment_0001, Function | MediumTest | Level1)
505{
506    TELEPHONY_LOGI("TelSMSMMSTest::MmsAttachment_0001 -->");
507    const std::string pathName = "/data/app/enSrc/618C0A89.smil";
508    std::size_t pos = pathName.find_last_of('/');
509    std::string fileName(pathName.substr(pos + 1));
510    MmsAttachment attachment;
511    bool retBool;
512    std::string retStr;
513    retBool = attachment.SetAttachmentFilePath("", false);
514    EXPECT_EQ(false, retBool);
515    retBool = attachment.SetAttachmentFilePath(pathName, true);
516    EXPECT_EQ(true, retBool);
517    retStr = attachment.GetAttachmentFilePath();
518    EXPECT_STREQ(retStr.c_str(), pathName.c_str());
519    retBool = attachment.SetContentId("");
520    EXPECT_EQ(false, retBool);
521    retBool = attachment.SetContentId("0000");
522    EXPECT_EQ(true, retBool);
523    retBool = attachment.SetContentId("<0000>");
524    EXPECT_EQ(true, retBool);
525    retStr = attachment.GetContentId();
526    EXPECT_STREQ(retStr.c_str(), "<0000>");
527    retBool = attachment.SetContentLocation("");
528    EXPECT_EQ(false, retBool);
529    retBool = attachment.SetContentLocation("SetContentLocation");
530    EXPECT_EQ(true, retBool);
531    retStr = attachment.GetContentLocation();
532    EXPECT_STREQ(retStr.c_str(), "SetContentLocation");
533    retBool = attachment.SetContentDisposition("");
534    EXPECT_EQ(false, retBool);
535    retBool = attachment.SetContentDisposition("attachment");
536    EXPECT_EQ(true, retBool);
537    retStr = attachment.GetContentDisposition();
538    EXPECT_STREQ(retStr.c_str(), "attachment");
539    retBool = attachment.SetContentTransferEncoding("");
540    EXPECT_EQ(false, retBool);
541    retBool = attachment.SetFileName(fileName);
542    EXPECT_EQ(true, retBool);
543    retStr = attachment.GetFileName();
544    EXPECT_STREQ(retStr.c_str(), fileName.c_str());
545    attachment.strFileName_ = "";
546    retStr = attachment.GetFileName();
547    EXPECT_STRNE(retStr.c_str(), fileName.c_str());
548}
549
550/**
551 * @tc.number   Telephony_SmsMmsGtest_MmsAttachment_0002
552 * @tc.name     Test MmsAttachment
553 * @tc.desc     Function test
554 */
555HWTEST_F(MmsGtest, MmsAttachment_0002, Function | MediumTest | Level1)
556{
557    TELEPHONY_LOGI("TelSMSMMSTest::MmsAttachment_0002 -->");
558    MmsAttachment attachment;
559    bool retBool;
560    std::string retStr;
561    uint32_t retU32t;
562    uint32_t len = 10 * 1024 * 1024;
563    uint32_t charset = 0;
564    retBool = attachment.SetContentTransferEncoding("SetContentTransferEncoding");
565    EXPECT_EQ(true, retBool);
566    retStr = attachment.GetContentTransferEncoding();
567    EXPECT_STREQ(retStr.c_str(), "SetContentTransferEncoding");
568    retBool = attachment.SetContentType("");
569    EXPECT_EQ(false, retBool);
570    attachment.SetIsSmilFile(true);
571    retBool = attachment.IsSmilFile();
572    EXPECT_EQ(true, retBool);
573    attachment.SetCharSet(charset);
574    retU32t = attachment.GetCharSet();
575    EXPECT_EQ(charset, retU32t);
576    retBool = attachment.SetDataBuffer(nullptr, 0);
577    retBool = attachment.SetDataBuffer(nullptr, MAX_MMS_ATTACHMENT_LEN + 1);
578    EXPECT_EQ(false, retBool);
579    retBool = attachment.SetDataBuffer(std::make_unique<char[]>(len + 1), len + 1);
580    EXPECT_EQ(false, retBool);
581    retBool = attachment.SetDataBuffer(std::make_unique<char[]>(len - 1), len - 1);
582    EXPECT_EQ(true, retBool);
583    retBool = attachment.SetDataBuffer(std::make_unique<char[]>(len - 1), len + 1);
584    EXPECT_EQ(false, retBool);
585    EXPECT_FALSE(attachment.GetDataBuffer(len) == nullptr);
586    attachment.dataLength_ = MAX_MMS_ATTACHMENT_LEN + 1;
587    EXPECT_TRUE(attachment.GetDataBuffer(len) == nullptr);
588    MmsAttachment attachment1(attachment);
589    attachment1.SetContentType("application/smil");
590    retStr = attachment1.GetContentType();
591    EXPECT_STREQ(retStr.c_str(), "application/smil");
592}
593
594/**
595 * @tc.number   Telephony_SmsMmsGtest_MmsBodyPartHeader_0001
596 * @tc.name     Test MmsBodyPartHeader
597 * @tc.desc     Function test
598 */
599HWTEST_F(MmsGtest, MmsBodyPartHeader_0001, Function | MediumTest | Level1)
600{
601    TELEPHONY_LOGI("TelSMSMMSTest::MmsBodyPartHeader_0001 -->");
602    MmsBodyPartHeader mmsBodyPartHeader;
603    MmsDecodeBuffer decodeBuffer;
604    std::string testStr;
605    uint32_t len = 0;
606    uint32_t lenErr = -1;
607    uint32_t lenMax = 300 * 1024;
608    mmsBodyPartHeader.DumpBodyPartHeader();
609    mmsBodyPartHeader.DecodeContentLocation(decodeBuffer, len);
610    mmsBodyPartHeader.DecodeContentId(decodeBuffer, len);
611    mmsBodyPartHeader.DecodeContentDisposition(decodeBuffer, len);
612    mmsBodyPartHeader.DecodeDispositionParameter(decodeBuffer, lenMax, len);
613    mmsBodyPartHeader.DecodeDispositionParameter(decodeBuffer, lenErr, len);
614    mmsBodyPartHeader.DecodeWellKnownHeader(decodeBuffer, len);
615    mmsBodyPartHeader.DecodeApplicationHeader(decodeBuffer, len);
616    mmsBodyPartHeader.SetContentId("contentId");
617    mmsBodyPartHeader.GetContentId(testStr);
618    EXPECT_STREQ(testStr.c_str(), "contentId");
619    mmsBodyPartHeader.SetContentTransferEncoding("contentTransferEncoding");
620    mmsBodyPartHeader.GetContentTransferEncoding(testStr);
621    EXPECT_STREQ(testStr.c_str(), "contentTransferEncoding");
622    mmsBodyPartHeader.SetContentLocation("contentLocation");
623    mmsBodyPartHeader.GetContentLocation(testStr);
624    EXPECT_STREQ(testStr.c_str(), "contentLocation");
625    MmsEncodeBuffer encodeBuffer;
626    mmsBodyPartHeader.EncodeContentLocation(encodeBuffer);
627    mmsBodyPartHeader.EncodeContentId(encodeBuffer);
628    mmsBodyPartHeader.EncodeContentDisposition(encodeBuffer);
629    mmsBodyPartHeader.EncodeContentTransferEncoding(encodeBuffer);
630    mmsBodyPartHeader.EncodeMmsBodyPartHeader(encodeBuffer);
631    MmsBodyPartHeader mmsBodyPartHeader2;
632    MmsBodyPartHeader mmsBodyPartHeader3 = MmsBodyPartHeader(mmsBodyPartHeader);
633    mmsBodyPartHeader2 = mmsBodyPartHeader;
634    mmsBodyPartHeader2.SetContentDisposition("contentDisposition");
635    mmsBodyPartHeader2.GetContentDisposition(testStr);
636    EXPECT_STREQ(testStr.c_str(), "contentDisposition");
637}
638
639/**
640 * @tc.number   Telephony_SmsMmsGtest_MmsBuffer_0001
641 * @tc.name     Test MmsBuffer
642 * @tc.desc     Function test
643 */
644HWTEST_F(MmsGtest, MmsBuffer_0001, Function | MediumTest | Level1)
645{
646    TELEPHONY_LOGI("TelSMSMMSTest::MmsBuffer_0001 -->");
647    MmsBuffer mmsBuffer;
648    uint32_t len = 10;
649    bool retBool;
650    std::string strPathName = "/data/app/enSrc/618C0A89.smil";
651    mmsBuffer.ReadDataBuffer(len);
652    mmsBuffer.ReadDataBuffer(len, len);
653    retBool = mmsBuffer.WriteDataBuffer(std::make_unique<char[]>(len), 0);
654    EXPECT_EQ(false, retBool);
655    retBool = mmsBuffer.WriteDataBuffer(std::make_unique<char[]>(len), len);
656    EXPECT_EQ(true, retBool);
657    mmsBuffer.WriteBufferFromFile(strPathName);
658    mmsBuffer.GetCurPosition();
659    uint32_t ret = mmsBuffer.GetSize();
660    EXPECT_GE(ret, 0);
661}
662
663/**
664 * @tc.number   Telephony_SmsMmsGtest_MmsContentParam_0001
665 * @tc.name     Test MmsContentParam
666 * @tc.desc     Function test
667 */
668HWTEST_F(MmsGtest, MmsContentParam_0001, Function | MediumTest | Level1)
669{
670    TELEPHONY_LOGI("TelSMSMMSTest::MmsContentParam_0001 -->");
671    MmsContentParam mmsContentParam;
672    MmsContentParam mmsContentParam2;
673    uint8_t field = 1;
674    uint32_t charset = 10;
675    std::string testStr;
676    uint32_t retU32t;
677    mmsContentParam.DumpContentParam();
678    mmsContentParam.SetCharSet(charset);
679    retU32t = mmsContentParam.GetCharSet();
680    EXPECT_EQ(charset, retU32t);
681    mmsContentParam.SetType("type");
682    testStr = mmsContentParam.GetType();
683    EXPECT_STREQ(testStr.c_str(), "type");
684    mmsContentParam.SetFileName("");
685    mmsContentParam.SetStart("");
686    mmsContentParam.SetStart("start");
687    mmsContentParam.GetStart(testStr);
688    EXPECT_STREQ(testStr.c_str(), "start");
689    mmsContentParam.AddNormalField(field, "value");
690    mmsContentParam.GetNormalField(field, testStr);
691    EXPECT_STREQ(testStr.c_str(), "value");
692    mmsContentParam.GetParamMap();
693    mmsContentParam2 = mmsContentParam;
694    mmsContentParam2.SetFileName("fileName");
695    mmsContentParam2.GetFileName(testStr);
696    EXPECT_STREQ(testStr.c_str(), "fileName");
697
698    mmsContentParam.textMap_.clear();
699    mmsContentParam.AddNormalField(field, "value");
700    mmsContentParam.textMap_.clear();
701    mmsContentParam.GetNormalField(field, testStr);
702    mmsContentParam.GetStart(testStr);
703    mmsContentParam2.GetFileName(testStr);
704    mmsContentParam.DumpContentParam();
705    EXPECT_STREQ(testStr.c_str(), "fileName");
706}
707
708/**
709 * @tc.number   Telephony_SmsMmsGtest_MmsContentType_0001
710 * @tc.name     Test MmsContentType
711 * @tc.desc     Function test
712 */
713HWTEST_F(MmsGtest, MmsContentType_0001, Function | MediumTest | Level1)
714{
715    TELEPHONY_LOGI("TelSMSMMSTest::MmsContentType_0001 -->");
716    MmsContentType mmsContentType;
717    MmsDecodeBuffer decodeBuffer;
718    MmsContentParam contentParam;
719    int32_t len = 10;
720    uint8_t type = 10;
721    std::string testStr;
722    uint8_t count = 10;
723    uint8_t index = 0;
724    while (index < count) {
725        decodeBuffer.pduBuffer_[index] = '1';
726        index++;
727    }
728    mmsContentType.DumpMmsContentType();
729
730    decodeBuffer.curPosition_ = 0;
731    decodeBuffer.pduBuffer_[decodeBuffer.curPosition_++] = PDU_TEST_DATA;
732    decodeBuffer.pduBuffer_[decodeBuffer.curPosition_++] = PDU_TEST_DATA;
733    decodeBuffer.pduBuffer_[decodeBuffer.curPosition_] = PDU_TEST_DATA;
734    mmsContentType.DecodeMmsContentType(decodeBuffer, len);
735
736    decodeBuffer.curPosition_ = 0;
737    mmsContentType.DecodeMmsCTGeneralForm(decodeBuffer, len);
738    mmsContentType.GetContentTypeFromInt(type);
739    mmsContentType.GetContentTypeFromString("");
740
741    decodeBuffer.curPosition_ = 0;
742    mmsContentType.DecodeParameter(decodeBuffer, len);
743    mmsContentType.SetContentParam(contentParam);
744    mmsContentType.DecodeTextField(decodeBuffer, type, len);
745
746    decodeBuffer.curPosition_ = 0;
747    mmsContentType.DecodeCharsetField(decodeBuffer, len);
748    mmsContentType.DecodeTypeField(decodeBuffer, len);
749
750    MmsEncodeBuffer encodeBuffer;
751    mmsContentType.EncodeTextField(encodeBuffer);
752    mmsContentType.EncodeCharsetField(encodeBuffer);
753    mmsContentType.EncodeTypeField(encodeBuffer);
754    mmsContentType.EncodeMmsBodyPartContentParam(encodeBuffer);
755    mmsContentType.EncodeMmsBodyPartContentType(encodeBuffer);
756    mmsContentType.GetContentParam();
757    MmsContentType mmsContentType2(mmsContentType);
758    mmsContentType2 = mmsContentType;
759    mmsContentType2.SetContentType("contentType");
760    mmsContentType2.GetContentType(testStr);
761    EXPECT_STREQ(testStr.c_str(), "contentType");
762}
763
764/**
765 * @tc.number   Telephony_SmsMmsGtest_MmsDecodeBuffer_0001
766 * @tc.name     Test MmsDecodeBuffer
767 * @tc.desc     Function test
768 */
769HWTEST_F(MmsGtest, MmsDecodeBuffer_0001, Function | MediumTest | Level1)
770{
771    TELEPHONY_LOGI("TelSMSMMSTest::MmsDecodeBuffer_0001 -->");
772    uint8_t byteVar = 1;
773    uint32_t intVar = PDU_COUNT;
774    std::string testStr;
775    MmsDecodeBuffer mmsDecodeBuffer;
776    uint8_t count = PDU_COUNT;
777    uint8_t index = 0;
778    while (index < count) {
779        mmsDecodeBuffer.pduBuffer_[index] = '1';
780        index++;
781    }
782
783    mmsDecodeBuffer.PeekOneByte(byteVar);
784    mmsDecodeBuffer.GetOneByte(byteVar);
785    mmsDecodeBuffer.IncreasePointer(intVar);
786    mmsDecodeBuffer.DecreasePointer(intVar);
787    mmsDecodeBuffer.curPosition_ = PDU_CUSITION;
788    mmsDecodeBuffer.totolLength_ = PDU_LENGTH;
789    mmsDecodeBuffer.PeekOneByte(byteVar);
790    mmsDecodeBuffer.GetOneByte(byteVar);
791    mmsDecodeBuffer.IncreasePointer(intVar);
792    mmsDecodeBuffer.DecreasePointer(intVar);
793
794    mmsDecodeBuffer.curPosition_ = 0;
795    mmsDecodeBuffer.DecodeUintvar(intVar, intVar);
796    mmsDecodeBuffer.DecodeShortLength(byteVar);
797
798    char testChar = MIN_SHORT_OCTET + 1;
799    mmsDecodeBuffer.pduBuffer_[mmsDecodeBuffer.curPosition_] = testChar;
800    mmsDecodeBuffer.DecodeShortLength(byteVar);
801    mmsDecodeBuffer.curPosition_ = 0;
802    mmsDecodeBuffer.pduBuffer_[mmsDecodeBuffer.curPosition_] = MIN_SHORT_OCTET;
803    mmsDecodeBuffer.DecodeValueLengthReturnLen(intVar, intVar);
804    mmsDecodeBuffer.pduBuffer_[mmsDecodeBuffer.curPosition_] = testChar;
805    mmsDecodeBuffer.DecodeValueLengthReturnLen(intVar, intVar);
806    mmsDecodeBuffer.pduBuffer_[mmsDecodeBuffer.curPosition_] = testChar + 1;
807    mmsDecodeBuffer.DecodeValueLengthReturnLen(intVar, intVar);
808
809    uint8_t errVar = -1;
810    bool ret = mmsDecodeBuffer.CharIsToken(errVar);
811    EXPECT_EQ(false, ret);
812}
813
814/**
815 * @tc.number   Telephony_SmsMmsGtest_MmsDecodeBuffer_0002
816 * @tc.name     Test MmsDecodeBuffer
817 * @tc.desc     Function test
818 */
819HWTEST_F(MmsGtest, MmsDecodeBuffer_0002, Function | MediumTest | Level1)
820{
821    TELEPHONY_LOGI("TelSMSMMSTest::MmsDecodeBuffer_0002 -->");
822    uint32_t intVar = 10;
823    std::string testStr;
824    MmsDecodeBuffer mmsDecodeBuffer;
825    uint8_t count = 10;
826    uint8_t index = 0;
827    while (index < count) {
828        mmsDecodeBuffer.pduBuffer_[index] = '1';
829        index++;
830    }
831    mmsDecodeBuffer.curPosition_ = 0;
832    char testChar = MIN_SHORT_OCTET + 1;
833    mmsDecodeBuffer.pduBuffer_[mmsDecodeBuffer.curPosition_] = MIN_SHORT_OCTET;
834    mmsDecodeBuffer.DecodeValueLength(intVar);
835    mmsDecodeBuffer.pduBuffer_[mmsDecodeBuffer.curPosition_] = testChar;
836    mmsDecodeBuffer.DecodeValueLength(intVar);
837    mmsDecodeBuffer.pduBuffer_[mmsDecodeBuffer.curPosition_] = testChar + 1;
838    mmsDecodeBuffer.DecodeValueLength(intVar);
839
840    mmsDecodeBuffer.curPosition_ = 0;
841    testChar += 1;
842    mmsDecodeBuffer.pduBuffer_[mmsDecodeBuffer.curPosition_] = testChar;
843    mmsDecodeBuffer.DecodeTokenText(testStr, intVar);
844    mmsDecodeBuffer.pduBuffer_[mmsDecodeBuffer.curPosition_] = testChar + 1;
845    mmsDecodeBuffer.DecodeTokenText(testStr, intVar);
846    mmsDecodeBuffer.pduBuffer_[mmsDecodeBuffer.curPosition_] = QUOTE_CHAR_LEN;
847    mmsDecodeBuffer.DecodeTokenText(testStr, intVar);
848
849    mmsDecodeBuffer.curPosition_ = 0;
850    mmsDecodeBuffer.pduBuffer_[mmsDecodeBuffer.curPosition_] = QUOTE_CHAR_LEN - 1;
851    mmsDecodeBuffer.DecodeText(testStr, intVar);
852    mmsDecodeBuffer.pduBuffer_[mmsDecodeBuffer.curPosition_] = QUOTE_CHAR_LEN;
853    mmsDecodeBuffer.DecodeText(testStr, intVar);
854
855    mmsDecodeBuffer.curPosition_ = 0;
856    testChar += 1;
857    mmsDecodeBuffer.pduBuffer_[mmsDecodeBuffer.curPosition_] = testChar;
858    mmsDecodeBuffer.DecodeQuotedText(testStr, intVar);
859    mmsDecodeBuffer.pduBuffer_[mmsDecodeBuffer.curPosition_] = testChar + 1;
860    mmsDecodeBuffer.DecodeQuotedText(testStr, intVar);
861
862    uint8_t errVar = -1;
863    bool ret = mmsDecodeBuffer.CharIsToken(errVar);
864    EXPECT_EQ(false, ret);
865}
866
867/**
868 * @tc.number   Telephony_SmsMmsGtest_MmsDecodeBuffer_0003
869 * @tc.name     Test MmsDecodeBuffer
870 * @tc.desc     Function test
871 */
872HWTEST_F(MmsGtest, MmsDecodeBuffer_0003, Function | MediumTest | Level1)
873{
874    TELEPHONY_LOGI("TelSMSMMSTest::MmsDecodeBuffer_0003 -->");
875    uint8_t byteVar = 1;
876    uint64_t longVar = 10;
877    std::string testStr;
878    MmsDecodeBuffer mmsDecodeBuffer;
879    uint8_t count = 10;
880    uint8_t index = 0;
881    while (index < count) {
882        mmsDecodeBuffer.pduBuffer_[index] = '1';
883        index++;
884    }
885
886    mmsDecodeBuffer.curPosition_ = 0;
887    char testChar = QUOTE_CHAR_LEN + 1;
888    mmsDecodeBuffer.pduBuffer_[mmsDecodeBuffer.curPosition_] = testChar;
889    mmsDecodeBuffer.DecodeShortInteger(byteVar);
890    mmsDecodeBuffer.pduBuffer_[mmsDecodeBuffer.curPosition_] = testChar + 1;
891    mmsDecodeBuffer.DecodeShortInteger(byteVar);
892
893    mmsDecodeBuffer.curPosition_ = 0;
894    mmsDecodeBuffer.pduBuffer_[mmsDecodeBuffer.curPosition_] = VALUE_CHAR;
895    mmsDecodeBuffer.DecodeLongInteger(longVar);
896    mmsDecodeBuffer.pduBuffer_[mmsDecodeBuffer.curPosition_] = VALUE_CHAR + 1;
897    mmsDecodeBuffer.DecodeLongInteger(longVar);
898
899    mmsDecodeBuffer.curPosition_ = 0;
900    mmsDecodeBuffer.DecodeInteger(longVar);
901    mmsDecodeBuffer.curPosition_ = 0;
902    mmsDecodeBuffer.pduBuffer_[mmsDecodeBuffer.curPosition_] = testChar;
903    mmsDecodeBuffer.DecodeIsShortInt();
904    mmsDecodeBuffer.pduBuffer_[mmsDecodeBuffer.curPosition_] = testChar + 1;
905    mmsDecodeBuffer.DecodeIsShortInt();
906
907    mmsDecodeBuffer.curPosition_ = 0;
908    char srcChar = MIN_SHORT_OCTET + 1;
909    mmsDecodeBuffer.pduBuffer_[mmsDecodeBuffer.curPosition_] = srcChar;
910    mmsDecodeBuffer.DecodeIsString();
911    mmsDecodeBuffer.pduBuffer_[mmsDecodeBuffer.curPosition_] = srcChar + 1;
912    mmsDecodeBuffer.DecodeIsString();
913    mmsDecodeBuffer.pduBuffer_[mmsDecodeBuffer.curPosition_] = testChar + 1;
914    mmsDecodeBuffer.DecodeIsString();
915
916    mmsDecodeBuffer.curPosition_ = 0;
917    mmsDecodeBuffer.pduBuffer_[mmsDecodeBuffer.curPosition_] = srcChar;
918    mmsDecodeBuffer.DecodeIsValueLength();
919    mmsDecodeBuffer.pduBuffer_[mmsDecodeBuffer.curPosition_] = srcChar + 1;
920    mmsDecodeBuffer.DecodeIsValueLength();
921
922    mmsDecodeBuffer.MarkPosition();
923    mmsDecodeBuffer.UnMarkPosition();
924    uint8_t errVar = -1;
925    bool ret = mmsDecodeBuffer.CharIsToken(errVar);
926    EXPECT_EQ(false, ret);
927}
928
929/**
930 * @tc.number   Telephony_SmsMmsGtest_MmsEncodeString_0001
931 * @tc.name     Test MmsEncodeString
932 * @tc.desc     Function test
933 */
934HWTEST_F(MmsGtest, MmsEncodeString_0001, Function | MediumTest | Level1)
935{
936    TELEPHONY_LOGI("TelSMSMMSTest::MmsEncodeString_0001 -->");
937    MmsEncodeString mmsEncodeString;
938    MmsDecodeBuffer decodeBuffer;
939    MmsEncodeBuffer encodeBuffer;
940    std::string testStr;
941    uint32_t charset = PDU_COUNT;
942    MmsAddress addrsss;
943    uint32_t len = PDU_COUNT;
944    std::unique_ptr<char[]> inBuff = std::make_unique<char[]>(len);
945    for (uint32_t i = 0; i < len; i++) {
946        inBuff[i] = 1;
947    }
948    decodeBuffer.WriteDataBuffer(std::move(inBuff), len);
949    mmsEncodeString.DecodeEncodeString(decodeBuffer);
950    decodeBuffer.curPosition_ = MAX_MMS_ATTACHMENT_LEN + 1;
951    mmsEncodeString.DecodeEncodeString(decodeBuffer);
952    mmsEncodeString.charset_ = ENCODE_CHARSET1;
953    mmsEncodeString.EncodeEncodeString(encodeBuffer);
954    mmsEncodeString.charset_ = ENCODE_CHARSET2;
955    mmsEncodeString.EncodeEncodeString(encodeBuffer);
956    mmsEncodeString.GetEncodeString(testStr);
957    EXPECT_GE(testStr.size(), 0);
958    mmsEncodeString.SetAddressString(addrsss);
959    mmsEncodeString.GetStrEncodeString();
960    MmsEncodeString mmsEncodeString1(mmsEncodeString);
961    charset = 0;
962    bool ret = mmsEncodeString1.SetEncodeString(charset, testStr);
963    EXPECT_EQ(true, ret);
964    ret = mmsEncodeString1.SetEncodeString(charset, testStr);
965    EXPECT_EQ(true, ret);
966}
967
968/**
969 * @tc.number   Telephony_SmsMmsGtest_MmsHeaderCateg_0001
970 * @tc.name     Test MmsHeaderCateg
971 * @tc.desc     Function test
972 */
973HWTEST_F(MmsGtest, MmsHeaderCateg_0001, Function | MediumTest | Level1)
974{
975    TELEPHONY_LOGI("TelSMSMMSTest::MmsHeaderCateg_0001 -->");
976    MmsHeaderCateg mmsHeaderCateg;
977    uint8_t fieldId = 0;
978    mmsHeaderCateg.FindSendReqOptType(fieldId);
979    mmsHeaderCateg.FindSendConfOptType(fieldId);
980    mmsHeaderCateg.FindFieldDes(fieldId);
981    mmsHeaderCateg.CheckIsValueLen(fieldId);
982    bool ret = mmsHeaderCateg.CheckIsValueLen(fieldId);
983    EXPECT_EQ(false, ret);
984}
985
986/**
987 * @tc.number   Telephony_SmsMmsGtest_MmsBase64_0001
988 * @tc.name     Test MmsBase64
989 * @tc.desc     Function test
990 */
991HWTEST_F(MmsGtest, MmsBase64_0001, Function | MediumTest | Level1)
992{
993    TELEPHONY_LOGI("TelSMSMMSTest::MmsBase64_0001 -->");
994    MmsBase64 mmsBase64;
995    std::string valueStr = "valueStr";
996    mmsBase64.Encode(valueStr);
997    std::string ret = mmsBase64.Decode(valueStr);
998    EXPECT_STRNE(ret.c_str(), "test");
999}
1000
1001/**
1002 * @tc.number   Telephony_SmsMmsGtest_MmsCharSet_0001
1003 * @tc.name     Test MmsCharSet
1004 * @tc.desc     Function test
1005 */
1006HWTEST_F(MmsGtest, MmsCharSet_0001, Function | MediumTest | Level1)
1007{
1008    TELEPHONY_LOGI("TelSMSMMSTest::MmsCharSet_0001 -->");
1009    MmsCharSet mmsCharSet;
1010    uint32_t charSet = 10;
1011    std::string strCharSet = "US-ASCII";
1012    mmsCharSet.GetCharSetStrFromInt(strCharSet, charSet);
1013    bool ret = mmsCharSet.GetCharSetIntFromString(charSet, strCharSet);
1014    EXPECT_EQ(true, ret);
1015}
1016
1017/**
1018 * @tc.number   Telephony_SmsMmsGtest_MmsQuotedPrintable_0001
1019 * @tc.name     Test MmsQuotedPrintable
1020 * @tc.desc     Function test
1021 */
1022HWTEST_F(MmsGtest, MmsQuotedPrintable_0001, Function | MediumTest | Level1)
1023{
1024    TELEPHONY_LOGI("TelSMSMMSTest::MmsQuotedPrintable_0001 -->");
1025    MmsQuotedPrintable mmsQuotedPrintable;
1026    std::string valueStr = "123";
1027    mmsQuotedPrintable.Encode(valueStr);
1028    std::string destStr = "";
1029    mmsQuotedPrintable.Decode(valueStr, destStr);
1030    bool ret = mmsQuotedPrintable.Decode("", valueStr);
1031    EXPECT_EQ(false, ret);
1032}
1033
1034/**
1035 * @tc.number   Telephony_SmsServiceTest_0001
1036 * @tc.name     Test MmsQuotedPrintable
1037 * @tc.desc     Function test
1038 */
1039HWTEST_F(MmsGtest, SmsServiceTest_0001, Function | MediumTest | Level1)
1040{
1041    AccessMmsToken token;
1042    int32_t slotId = 0;
1043    int64_t timeStamp = 0;
1044    std::string homeUrlVal;
1045    std::string dbUrl;
1046    GetPduToFile(slotId);
1047    dbUrl = GetFileToDb();
1048    homeUrlVal = GetMmsc(slotId);
1049    std::u16string mmsc = StringUtils::ToUtf16(homeUrlVal);
1050    std::u16string data = StringUtils::ToUtf16(dbUrl);
1051    std::u16string ua = u"";
1052    std::u16string uaprof = u"";
1053    Singleton<SmsServiceManagerClient>::GetInstance().SendMms(slotId, mmsc, data, ua, uaprof, timeStamp);
1054    Singleton<SmsServiceManagerClient>::GetInstance().DownloadMms(slotId, mmsc, data, ua, uaprof);
1055    EXPECT_GE(dbUrl.length(), 0);
1056    EXPECT_GE(homeUrlVal.length(), 0);
1057}
1058#endif // TEL_TEST_UNSUPPORT
1059} // namespace Telephony
1060} // namespace OHOS