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