1/*
2 * Copyright (C) 2022 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 "data_request.h"
21#include "mms_apn_info.h"
22#include "mms_receive.h"
23#include "mms_receive_manager.h"
24#include "mms_sender.h"
25#include "mms_send_manager.h"
26#include "mms_network_client.h"
27
28namespace OHOS {
29namespace Telephony {
30using namespace testing::ext;
31class MmsReceiveGtest : public testing::Test {
32public:
33    static void SetUpTestCase();
34    static void TearDownTestCase();
35    void SetUp();
36    void TearDown();
37};
38void MmsReceiveGtest::SetUpTestCase() {}
39
40void MmsReceiveGtest::TearDownTestCase() {}
41
42void MmsReceiveGtest::SetUp() {}
43
44void MmsReceiveGtest::TearDown() {}
45/**
46 * @tc.number   Telephony_MmsReceiveManagerTest_0001
47 * @tc.name     Test MmsReceiveManager
48 * @tc.desc     Function test
49 */
50HWTEST_F(MmsReceiveGtest, MmsReceiveManagerTest_0001, Function | MediumTest | Level1)
51{
52    int32_t slotId = 0;
53    auto mmsReceiverManager = std::make_shared<MmsReceiveManager>(slotId);
54    ASSERT_NE(mmsReceiverManager, nullptr);
55    std::u16string mmsc = u"";
56    std::u16string data = u"";
57    std::u16string ua = u"";
58    std::u16string uaprof = u"";
59    int32_t stata = mmsReceiverManager->DownloadMms(mmsc, data, ua, uaprof);
60    EXPECT_EQ(stata, TELEPHONY_ERR_LOCAL_PTR_NULL);
61
62    mmsReceiverManager->Init();
63    stata = mmsReceiverManager->DownloadMms(mmsc, data, ua, uaprof);
64    EXPECT_EQ(stata, TELEPHONY_ERR_MMS_FAIL_DATA_NETWORK_ERROR);
65}
66
67/**
68 * @tc.number   Telephony_MmsSendManagerTest_0001
69 * @tc.name     Test MmsSendManager
70 * @tc.desc     Function test
71 */
72HWTEST_F(MmsReceiveGtest, MmsSendManagerTest_0001, Function | MediumTest | Level1)
73{
74    int32_t slotId = 0;
75    auto mmsSendManager = std::make_shared<MmsSendManager>(slotId);
76    ASSERT_NE(nullptr, mmsSendManager);
77    mmsSendManager->Init();
78    std::u16string mmsc = u"";
79    std::u16string data = u"";
80    std::u16string ua = u"";
81    std::u16string uaprof = u"";
82    int32_t stata = mmsSendManager->SendMms(mmsc, data, ua, uaprof);
83    EXPECT_EQ(stata, TELEPHONY_ERR_MMS_FAIL_DATA_NETWORK_ERROR);
84}
85
86/**
87 * @tc.number   Telephony_DataRequestTest_0001
88 * @tc.name     Test DataRequest
89 * @tc.desc     Function test
90 */
91HWTEST_F(MmsReceiveGtest, DataRequestTest_0001, Function | MediumTest | Level1)
92{
93    int32_t slotId = 0;
94    auto dataRequest = std::make_shared<DataRequest>(slotId);
95    ASSERT_NE(nullptr, dataRequest);
96    std::string method;
97    auto netMgr = std::make_shared<MmsNetworkManager>();
98    ASSERT_NE(nullptr, netMgr);
99    std::string contentUrl;
100    std::string pduDir;
101    int32_t stata = dataRequest->HttpRequest(slotId, method, netMgr, contentUrl, pduDir, "ua", "uaprof");
102    EXPECT_NE(stata, TELEPHONY_ERR_MMS_FAIL_DATA_NETWORK_ERROR);
103}
104
105/**
106 * @tc.number   Telephony_MmsApnInfoTest_0001
107 * @tc.name     Test MmsApnInfo
108 * @tc.desc     Function test
109 */
110HWTEST_F(MmsReceiveGtest, MmsApnInfoTest_0001, Function | MediumTest | Level1)
111{
112    int32_t slotId = 0;
113    auto mmsApnInfo = std::make_shared<MmsApnInfo>(slotId);
114    ASSERT_NE(nullptr, mmsApnInfo);
115    std::string apn = "mms,mms,mms,mms";
116    EXPECT_TRUE(mmsApnInfo->SplitAndMatchApnTypes(apn));
117    apn = "";
118    EXPECT_FALSE(mmsApnInfo->SplitAndMatchApnTypes(apn));
119}
120
121/**
122 * @tc.number   Telephony_MmsNetworkClientTest_0002
123 * @tc.name     Test MmsNetworkClient
124 * @tc.desc     Function test
125 */
126HWTEST_F(MmsReceiveGtest, MmsNetworkClientTest_0001, Function | MediumTest | Level1)
127{
128    int32_t slotId = 0;
129    auto mmsNetworkClient = std::make_shared<MmsNetworkClient>(slotId);
130    ASSERT_NE(nullptr, mmsNetworkClient);
131    std::string str;
132    mmsNetworkClient->GetCoverUrl(str);
133    EXPECT_EQ(str, "");
134    str = "str";
135    mmsNetworkClient->GetCoverUrl(str);
136    EXPECT_EQ(str, "str");
137}
138
139/**
140 * @tc.number   Telephony_MmsReceiveTest_0001
141 * @tc.name     Test MmsReceive
142 * @tc.desc     Function test
143 */
144HWTEST_F(MmsReceiveGtest, MmsMmsReceiveTest_0001, Function | MediumTest | Level1)
145{
146    int32_t slotId = 0;
147    auto mmsReceive = std::make_shared<MmsReceive>(slotId);
148    ASSERT_NE(nullptr, mmsReceive);
149    std::string method;
150    std::string url;
151    std::string data;
152    std::string uaprof;
153    int32_t ret = mmsReceive->ExecuteDownloadMms(method, url, data, uaprof);
154    EXPECT_EQ(ret, TELEPHONY_ERR_MMS_FAIL_DATA_NETWORK_ERROR);
155}
156
157/**
158 * @tc.number   Telephony_MmsSenderTest_0001
159 * @tc.name     Test MmsSender
160 * @tc.desc     Function test
161 */
162HWTEST_F(MmsReceiveGtest, MmsSenderTest_0001, Function | MediumTest | Level1)
163{
164    int32_t slotId = 0;
165    auto mmsSender = std::make_shared<MmsSender>(slotId);
166    ASSERT_NE(nullptr, mmsSender);
167    std::string method;
168    std::string url;
169    std::string data;
170    std::string uaprof;
171    int32_t ret = mmsSender->ExecuteSendMms(method, url, data, uaprof);
172    EXPECT_EQ(ret, TELEPHONY_ERR_MMS_FAIL_DATA_NETWORK_ERROR);
173}
174} // namespace Telephony
175} // namespace OHOS
176