1 /*
2  * Copyright (C) 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_common.h"
20 #include "cdma_sms_sub_parameter.h"
21 #include "data_request.h"
22 #include "gtest/gtest.h"
23 #include "mms_apn_info.h"
24 #include "sms_pdu_buffer.h"
25 #include "telephony_errors.h"
26 
27 namespace OHOS {
28 namespace Telephony {
29 namespace {
30 static constexpr int TEST_MAX_UD_HEADER_NUM = 8;
31 static constexpr int TEST_MAX_USER_DATA_LEN = 170;
32 static constexpr uint8_t TEST_MAX_FIELD_LEN = 170;
33 static constexpr uint8_t MAX_FIELD_LEN = 255;
34 static constexpr int TEST_DATA_LEN = 100;
35 static constexpr int TEST_SEND_CONF_MAX_SIZE = 600;
36 } // namespace
37 using namespace testing::ext;
38 
39 class SmsServicesMmsGtest : public testing::Test {
40 public:
41     static void SetUpTestCase();
42     static void TearDownTestCase();
43     void SetUp();
44     void TearDown();
45 };
46 
TearDownTestCase()47 void SmsServicesMmsGtest::TearDownTestCase() {}
48 
SetUp()49 void SmsServicesMmsGtest::SetUp() {}
50 
TearDown()51 void SmsServicesMmsGtest::TearDown() {}
52 
SetUpTestCase()53 void SmsServicesMmsGtest::SetUpTestCase() {}
54 
HWTEST_F(SmsServicesMmsGtest, DataRequest_0001, Function | MediumTest | Level2)55 HWTEST_F(SmsServicesMmsGtest, DataRequest_0001, Function | MediumTest | Level2)
56 {
57     int32_t slotId = 0;
58     auto dataRequest = std::make_shared<DataRequest>(slotId);
59     std::string testStr = "";
60     EXPECT_EQ(dataRequest->HttpRequest(slotId, testStr, nullptr, testStr, testStr, "ua", "uaprof"),
61         TELEPHONY_ERR_LOCAL_PTR_NULL);
62 }
63 
HWTEST_F(SmsServicesMmsGtest, MmsNetworkClient_0001, Function | MediumTest | Level2)64 HWTEST_F(SmsServicesMmsGtest, MmsNetworkClient_0001, Function | MediumTest | Level2)
65 {
66     int32_t slotId = 0;
67     MmsNetworkClient client(0);
68     std::string testStr = "testStr";
69     auto mmsApnInfo = std::make_shared<MmsApnInfo>(slotId);
70     mmsApnInfo->setMmscUrl("");
71     EXPECT_EQ(client.PostUrl(testStr, testStr, "ua", "uaprof"), TELEPHONY_ERR_ARGUMENT_INVALID);
72 
73     client.responseData_ = std::string(TEST_SEND_CONF_MAX_SIZE, 'a');
74     EXPECT_TRUE(client.CheckSendConf());
75 
76     client.responseData_ = "";
77     EXPECT_TRUE(client.CheckSendConf());
78 
79     client.responseData_ = "responseData";
80     EXPECT_TRUE(client.CheckSendConf());
81 }
82 
HWTEST_F(SmsServicesMmsGtest, MmsConnCallbackStub_0001, Function | MediumTest | Level2)83 HWTEST_F(SmsServicesMmsGtest, MmsConnCallbackStub_0001, Function | MediumTest | Level2)
84 {
85     MmsConnCallbackStub connCallback;
86     sptr<NetManagerStandard::NetHandle> netHandle = new NetManagerStandard::NetHandle;
87     EXPECT_EQ(connCallback.NetAvailable(netHandle), ERR_NONE);
88 }
89 
HWTEST_F(SmsServicesMmsGtest, CdmaSmsMessageId_0001, Function | MediumTest | Level2)90 HWTEST_F(SmsServicesMmsGtest, CdmaSmsMessageId_0001, Function | MediumTest | Level2)
91 {
92     auto initValue = static_cast<uint16_t>(0x0);
93     auto testValue = static_cast<uint16_t>(0x10);
94     SmsTeleSvcMsgId v1;
95     memset_s(&v1, sizeof(SmsTeleSvcMsgId), 0x00, sizeof(SmsTeleSvcMsgId));
96     v1.msgId = testValue;
97     SmsTeleSvcMsgId v2;
98     v2.msgId = initValue;
99     uint8_t type = static_cast<uint8_t>(TeleserviceMsgType::SUBMIT);
100 
101     auto message1 = std::make_shared<CdmaSmsMessageId>(v1, type);
102     SmsWriteBuffer wBuffer;
103     EXPECT_TRUE(message1->Encode(wBuffer));
104     auto buffer = wBuffer.GetPduBuffer();
105     EXPECT_GT(buffer->size(), 0);
106     std::stringstream ss;
107     ss.clear();
108     for (uint16_t i = 0; i < buffer->size(); i++) {
109         ss << (*buffer)[i];
110     }
111     SmsReadBuffer rBuffer(ss.str());
112     auto message2 = std::make_shared<CdmaSmsMessageId>(v2, type);
113 
114     rBuffer.bitIndex_ = 0;
115     rBuffer.index_ = 0;
116     rBuffer.length_ = 0;
117     EXPECT_FALSE(message2->Decode(rBuffer));
118 }
119 
HWTEST_F(SmsServicesMmsGtest, CdmaSmsAbsoluteTime_0001, Function | MediumTest | Level2)120 HWTEST_F(SmsServicesMmsGtest, CdmaSmsAbsoluteTime_0001, Function | MediumTest | Level2)
121 {
122     auto initValue = static_cast<unsigned char>(0);
123     auto testValue = static_cast<unsigned char>(5);
124     SmsTimeAbs v1;
125     memset_s(&v1, sizeof(SmsTimeAbs), 0x00, sizeof(SmsTimeAbs));
126     v1.month = testValue;
127     SmsTimeAbs v2;
128     v2.month = initValue;
129 
130     auto message1 = std::make_shared<CdmaSmsAbsoluteTime>(CdmaSmsSubParameter::VALIDITY_PERIOD_ABSOLUTE, v1);
131     SmsWriteBuffer wBuffer;
132     EXPECT_TRUE(message1->Encode(wBuffer));
133     auto buffer = wBuffer.GetPduBuffer();
134     EXPECT_GT(buffer->size(), 0);
135     std::stringstream ss;
136     ss.clear();
137     for (uint16_t i = 0; i < buffer->size(); i++) {
138         ss << (*buffer)[i];
139     }
140     SmsReadBuffer rBuffer(ss.str());
141     auto message2 = std::make_shared<CdmaSmsAbsoluteTime>(CdmaSmsSubParameter::VALIDITY_PERIOD_ABSOLUTE, v2);
142 
143     rBuffer.bitIndex_ = 0;
144     rBuffer.index_ = 0;
145     rBuffer.length_ = 0;
146     EXPECT_FALSE(message2->Decode(rBuffer));
147 }
148 
HWTEST_F(SmsServicesMmsGtest, SmsTeleSvcUserData_0001, Function | MediumTest | Level2)149 HWTEST_F(SmsServicesMmsGtest, SmsTeleSvcUserData_0001, Function | MediumTest | Level2)
150 {
151     auto initValue = SmsEncodingType::RESERVED;
152     auto testValue = SmsEncodingType::ASCII_7BIT;
153     SmsTeleSvcUserData v1;
154     memset_s(&v1, sizeof(SmsTeleSvcUserData), 0x00, sizeof(SmsTeleSvcUserData));
155     v1.encodeType = testValue;
156     SmsTeleSvcUserData v2;
157     v2.encodeType = initValue;
158     bool headerInd = false;
159 
160     auto message1 = std::make_shared<CdmaSmsUserData>(v1, headerInd);
161     SmsWriteBuffer wBuffer;
162     EXPECT_TRUE(message1->Encode(wBuffer));
163     auto buffer = wBuffer.GetPduBuffer();
164     EXPECT_GT(buffer->size(), 0);
165     std::stringstream ss;
166     ss.clear();
167     for (uint16_t i = 0; i < buffer->size(); i++) {
168         ss << (*buffer)[i];
169     }
170     SmsReadBuffer rBuffer(ss.str());
171     auto message2 = std::make_shared<CdmaSmsUserData>(v2, headerInd);
172     EXPECT_TRUE(message2->Decode(rBuffer));
173     EXPECT_EQ(v2.encodeType, testValue);
174 
175     message2->data_.userData.headerCnt = TEST_MAX_UD_HEADER_NUM;
176     EXPECT_FALSE(message2->EncodeHeader7Bit(wBuffer));
177     EXPECT_FALSE(message2->EncodeAscii7Bit(wBuffer));
178     EXPECT_FALSE(message2->EncodeGsm7Bit(wBuffer));
179     EXPECT_FALSE(message2->EncodeHeaderUnicode(wBuffer));
180     EXPECT_FALSE(message2->EncodeUnicode(wBuffer));
181 }
182 
HWTEST_F(SmsServicesMmsGtest, SmsTeleSvcUserData_0002, Function | MediumTest | Level2)183 HWTEST_F(SmsServicesMmsGtest, SmsTeleSvcUserData_0002, Function | MediumTest | Level2)
184 {
185     auto initValue = SmsEncodingType::RESERVED;
186     auto testValue = SmsEncodingType::ASCII_7BIT;
187     SmsTeleSvcUserData v1;
188     memset_s(&v1, sizeof(SmsTeleSvcUserData), 0x00, sizeof(SmsTeleSvcUserData));
189     v1.encodeType = testValue;
190     SmsTeleSvcUserData v2;
191     v2.encodeType = initValue;
192     bool headerInd = false;
193 
194     auto message1 = std::make_shared<CdmaSmsUserData>(v1, headerInd);
195     SmsWriteBuffer wBuffer;
196     EXPECT_TRUE(message1->Encode(wBuffer));
197     auto buffer = wBuffer.GetPduBuffer();
198     EXPECT_GT(buffer->size(), 0);
199     std::stringstream ss;
200     ss.clear();
201     for (uint16_t i = 0; i < buffer->size(); i++) {
202         ss << (*buffer)[i];
203     }
204     SmsReadBuffer rBuffer(ss.str());
205     auto message2 = std::make_shared<CdmaSmsUserData>(v2, headerInd);
206     EXPECT_TRUE(message2->Decode(rBuffer));
207     EXPECT_EQ(v2.encodeType, testValue);
208 
209     message2->data_.userData.length = TEST_MAX_USER_DATA_LEN;
210     EXPECT_FALSE(message2->Encode8BitData(wBuffer));
211 
212     rBuffer.bitIndex_ = 0;
213     rBuffer.index_ = 0;
214     rBuffer.length_ = 0;
215     EXPECT_FALSE(message2->Decode(rBuffer));
216 
217     message2->headerInd_ = true;
218     EXPECT_EQ(message2->DecodeHeader7Bit(rBuffer), 0);
219     EXPECT_FALSE(message2->DecodeAscii7Bit(rBuffer, 0, BIT7));
220     EXPECT_FALSE(message2->DecodeAscii7Bit(rBuffer, TEST_MAX_FIELD_LEN, 0));
221     EXPECT_FALSE(message2->DecodeAscii7Bit(rBuffer, 1, 0));
222 }
223 
HWTEST_F(SmsServicesMmsGtest, SmsTeleSvcUserData_0003, Function | MediumTest | Level2)224 HWTEST_F(SmsServicesMmsGtest, SmsTeleSvcUserData_0003, Function | MediumTest | Level2)
225 {
226     auto initValue = SmsEncodingType::RESERVED;
227     auto testValue = SmsEncodingType::ASCII_7BIT;
228     SmsTeleSvcUserData v1;
229     memset_s(&v1, sizeof(SmsTeleSvcUserData), 0x00, sizeof(SmsTeleSvcUserData));
230     v1.encodeType = testValue;
231     SmsTeleSvcUserData v2;
232     v2.encodeType = initValue;
233     bool headerInd = false;
234 
235     auto message1 = std::make_shared<CdmaSmsUserData>(v1, headerInd);
236     SmsWriteBuffer wBuffer;
237     EXPECT_TRUE(message1->Encode(wBuffer));
238     auto buffer = wBuffer.GetPduBuffer();
239     EXPECT_GT(buffer->size(), 0);
240     std::stringstream ss;
241     ss.clear();
242     for (uint16_t i = 0; i < buffer->size(); i++) {
243         ss << (*buffer)[i];
244     }
245     SmsReadBuffer rBuffer(ss.str());
246     auto message2 = std::make_shared<CdmaSmsUserData>(v2, headerInd);
247     EXPECT_TRUE(message2->Decode(rBuffer));
248     EXPECT_EQ(v2.encodeType, testValue);
249 
250     rBuffer.bitIndex_ = 0;
251     rBuffer.index_ = 0;
252     rBuffer.length_ = 0;
253     EXPECT_FALSE(message2->DecodeGsm7Bit(rBuffer, 0, BIT7));
254     EXPECT_FALSE(message2->DecodeGsm7Bit(rBuffer, MAX_FIELD_LEN, 0));
255 
256     message2->data_.userData.length = TEST_MAX_USER_DATA_LEN;
257     EXPECT_FALSE(message2->Decode8BitData(rBuffer));
258 }
259 
HWTEST_F(SmsServicesMmsGtest, CdmaSmsCmasData_0001, Function | MediumTest | Level2)260 HWTEST_F(SmsServicesMmsGtest, CdmaSmsCmasData_0001, Function | MediumTest | Level2)
261 {
262     SmsTeleSvcCmasData v1;
263     std::stringstream ss;
264     ss.clear();
265     ss << static_cast<uint8_t>(CdmaSmsSubParameter::USER_DATA);
266     uint8_t len = TEST_DATA_LEN;
267     ss << static_cast<uint8_t>(len);
268     for (uint8_t i = 0; i < len; i++) {
269         ss << static_cast<uint8_t>(0x00);
270     }
271     SmsReadBuffer rBuffer(ss.str());
272     auto message1 = std::make_shared<CdmaSmsCmasData>(v1);
273     rBuffer.bitIndex_ = 0;
274     rBuffer.index_ = 0;
275     rBuffer.length_ = 0;
276     EXPECT_FALSE(message1->DecodeData(rBuffer));
277     EXPECT_FALSE(message1->DecodeType0Data(rBuffer));
278     EXPECT_FALSE(message1->DecodeType1Data(rBuffer));
279     EXPECT_FALSE(message1->DecodeType2Data(rBuffer));
280     EXPECT_FALSE(message1->DecodeAbsTime(rBuffer));
281 }
282 } // namespace Telephony
283 } // namespace OHOS