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 "delivery_short_message_callback_stub.h"
20 #include "gtest/gtest.h"
21 #include "gsm_sms_param_decode.h"
22 #include "gsm_sms_tpdu_encode.h"
23 #include "send_short_message_callback_stub.h"
24 #include "sms_misc_manager.h"
25 #include "sms_mms_gtest.h"
26 #include "sms_service.h"
27 #include "system_ability_definition.h"
28 
29 namespace OHOS {
30 namespace Telephony {
31 using namespace testing::ext;
32 
33 namespace {
34 const std::string TEST_SOURCE_DATA = "srcData";
35 const std::string SMS_ADDR_ONE = "";
36 const std::string SMS_ADDR_TWO = " ";
37 const std::string SMS_ADDR_THREE = " 123 ";
38 const std::string SMS_ADDR_FOUR = "1 23";
39 const std::string SMS_ADDR_FIVE = " a 123 ";
40 const std::string SEND_MMS_FILE_URL = "1,2,";
41 const std::string VNET_MMSC = "http://mmsc.vnet.mobi";
42 static constexpr uint8_t MAX_GSM_7BIT_DATA_LEN = 160;
43 static constexpr uint8_t MAX_SMSC_LEN = 20;
44 } // namespace
45 
46 class BranchSmsPartTest : public testing::Test {
47 public:
48     static void SetUpTestCase();
49     static void TearDownTestCase();
50     void SetUp();
51     void TearDown();
52 };
SetUpTestCase()53 void BranchSmsPartTest::SetUpTestCase() {}
54 
TearDownTestCase()55 void BranchSmsPartTest::TearDownTestCase() {}
56 
SetUp()57 void BranchSmsPartTest::SetUp() {}
58 
TearDown()59 void BranchSmsPartTest::TearDown() {}
60 
61 /**
62  * @tc.number   Telephony_SmsMmsGtest_SmsInterfaceStub_0001
63  * @tc.name     Test SmsInterfaceStub
64  * @tc.desc     Function test
65  */
HWTEST_F(BranchSmsPartTest, SmsInterfaceStub_0001, Function | MediumTest | Level1)66 HWTEST_F(BranchSmsPartTest, SmsInterfaceStub_0001, Function | MediumTest | Level1)
67 {
68     AccessMmsToken token;
69     int32_t slotId = 0;
70     MessageParcel dataParcel;
71     dataParcel.WriteInt32(slotId);
72     dataParcel.WriteBuffer(TEST_SOURCE_DATA.c_str(), TEST_SOURCE_DATA.size());
73     dataParcel.RewindRead(0);
74     MessageParcel replyParcel;
75     uint32_t code = 0;
76     MessageOption option(MessageOption::TF_SYNC);
77     DelayedSingleton<SmsService>::GetInstance()->OnRemoteRequest(code, dataParcel, replyParcel, option);
78     DelayedSingleton<SmsService>::GetInstance()->OnSendSmsTextRequest(dataParcel, replyParcel, option);
79     DelayedSingleton<SmsService>::GetInstance()->OnSendSmsTextWithoutSaveRequest(dataParcel, replyParcel, option);
80     DelayedSingleton<SmsService>::GetInstance()->OnSendSmsDataRequest(dataParcel, replyParcel, option);
81     DelayedSingleton<SmsService>::GetInstance()->OnGetSmscAddr(dataParcel, replyParcel, option);
82     DelayedSingleton<SmsService>::GetInstance()->OnAddSimMessage(dataParcel, replyParcel, option);
83     DelayedSingleton<SmsService>::GetInstance()->OnUpdateSimMessage(dataParcel, replyParcel, option);
84     DelayedSingleton<SmsService>::GetInstance()->OnGetAllSimMessages(dataParcel, replyParcel, option);
85     DelayedSingleton<SmsService>::GetInstance()->OnSplitMessage(dataParcel, replyParcel, option);
86     DelayedSingleton<SmsService>::GetInstance()->OnCreateMessage(dataParcel, replyParcel, option);
87     DelayedSingleton<SmsService>::GetInstance()->OnGetBase64Encode(dataParcel, replyParcel, option);
88     DelayedSingleton<SmsService>::GetInstance()->OnGetBase64Decode(dataParcel, replyParcel, option);
89     DelayedSingleton<SmsService>::GetInstance()->OnGetEncodeStringFunc(dataParcel, replyParcel, option);
90     DelayedSingleton<SmsService>::GetInstance()->OnGetSmsSegmentsInfo(dataParcel, replyParcel, option);
91 
92     MessageParcel sendTextParcel;
93     sendTextParcel.WriteInt32(0);
94     sendTextParcel.WriteString16(Str8ToStr16(TEST_SOURCE_DATA));
95     sendTextParcel.WriteString16(Str8ToStr16(TEST_SOURCE_DATA));
96     sendTextParcel.WriteString16(Str8ToStr16(TEST_SOURCE_DATA));
97     sendTextParcel.WriteString(TEST_SOURCE_DATA);
98     DelayedSingleton<SmsService>::GetInstance()->OnSendSmsTextRequest(sendTextParcel, replyParcel, option);
99     sendTextParcel.WriteInt32(-1);
100     DelayedSingleton<SmsService>::GetInstance()->OnSendSmsTextRequest(sendTextParcel, replyParcel, option);
101     int32_t result = replyParcel.ReadInt32();
102     EXPECT_GE(result, 0);
103 
104     MessageParcel sendDataParcel;
105     dataParcel.WriteInt32(0);
106     dataParcel.WriteString16(Str8ToStr16(TEST_SOURCE_DATA));
107     dataParcel.WriteString16(Str8ToStr16(TEST_SOURCE_DATA));
108     dataParcel.WriteInt16(0);
109     dataParcel.WriteInt16(TEST_SOURCE_DATA.size());
110     dataParcel.WriteRawData(TEST_SOURCE_DATA.c_str(), TEST_SOURCE_DATA.size());
111     DelayedSingleton<SmsService>::GetInstance()->OnSendSmsDataRequest(dataParcel, replyParcel, option);
112     sendTextParcel.WriteInt32(-1);
113     DelayedSingleton<SmsService>::GetInstance()->OnSendSmsDataRequest(dataParcel, replyParcel, option);
114     result = replyParcel.ReadInt32();
115     EXPECT_GE(result, -1);
116 }
117 
118 /**
119  * @tc.number   Telephony_SmsMmsGtest_SmsInterfaceStub_0002
120  * @tc.name     Test SmsInterfaceStub
121  * @tc.desc     Function test
122  */
HWTEST_F(BranchSmsPartTest, SmsInterfaceStub_0002, Function | MediumTest | Level1)123 HWTEST_F(BranchSmsPartTest, SmsInterfaceStub_0002, Function | MediumTest | Level1)
124 {
125     std::u16string desAddr = Str8ToStr16(SMS_ADDR_ONE);
126     DelayedSingleton<SmsService>::GetInstance()->RemoveSpacesInDesAddr(desAddr);
127     EXPECT_GE(desAddr.size(), 0);
128     desAddr = Str8ToStr16(SMS_ADDR_TWO);
129     DelayedSingleton<SmsService>::GetInstance()->RemoveSpacesInDesAddr(desAddr);
130     EXPECT_GE(desAddr.size(), 0);
131     desAddr = Str8ToStr16(SMS_ADDR_THREE);
132     DelayedSingleton<SmsService>::GetInstance()->RemoveSpacesInDesAddr(desAddr);
133     EXPECT_GE(desAddr.size(), 0);
134     desAddr = Str8ToStr16(SMS_ADDR_FOUR);
135     DelayedSingleton<SmsService>::GetInstance()->RemoveSpacesInDesAddr(desAddr);
136     EXPECT_GE(desAddr.size(), 0);
137     desAddr = Str8ToStr16(SMS_ADDR_FIVE);
138     DelayedSingleton<SmsService>::GetInstance()->RemoveSpacesInDesAddr(desAddr);
139     EXPECT_GE(desAddr.size(), 0);
140 
141     MessageParcel setSmscParcel;
142     MessageParcel replyParcel;
143     MessageOption option(MessageOption::TF_SYNC);
144     setSmscParcel.WriteInt32(0);
145     setSmscParcel.WriteString16(Str8ToStr16(TEST_SOURCE_DATA));
146     DelayedSingleton<SmsService>::GetInstance()->OnSetSmscAddr(setSmscParcel, replyParcel, option);
147     MessageParcel getSmscParcel;
148     getSmscParcel.WriteInt32(0);
149     DelayedSingleton<SmsService>::GetInstance()->OnGetSmscAddr(getSmscParcel, replyParcel, option);
150     DelayedSingleton<SmsService>::GetInstance()->OnGetAllSimMessages(getSmscParcel, replyParcel, option);
151     DelayedSingleton<SmsService>::GetInstance()->OnSetDefaultSmsSlotId(getSmscParcel, replyParcel, option);
152     DelayedSingleton<SmsService>::GetInstance()->OnGetDefaultSmsSlotId(getSmscParcel, replyParcel, option);
153     int32_t result = replyParcel.ReadInt32();
154     EXPECT_GE(result, 0);
155 
156     MessageParcel addSimMsgParcel;
157     addSimMsgParcel.WriteInt32(0);
158     addSimMsgParcel.WriteString16(Str8ToStr16(TEST_SOURCE_DATA));
159     addSimMsgParcel.WriteString16(Str8ToStr16(TEST_SOURCE_DATA));
160     addSimMsgParcel.WriteUint32(0);
161     DelayedSingleton<SmsService>::GetInstance()->OnAddSimMessage(addSimMsgParcel, replyParcel, option);
162     result = replyParcel.ReadInt32();
163     EXPECT_GE(result, 0);
164 
165     MessageParcel delSimMsgParcel;
166     delSimMsgParcel.WriteInt32(0);
167     delSimMsgParcel.WriteUint32(0);
168     DelayedSingleton<SmsService>::GetInstance()->OnDelSimMessage(delSimMsgParcel, replyParcel, option);
169     result = replyParcel.ReadInt32();
170     EXPECT_GE(result, 0);
171 }
172 
173 /**
174  * @tc.number   Telephony_SmsMmsGtest_SmsInterfaceStub_0003
175  * @tc.name     Test SmsInterfaceStub
176  * @tc.desc     Function test
177  */
HWTEST_F(BranchSmsPartTest, SmsInterfaceStub_0003, Function | MediumTest | Level1)178 HWTEST_F(BranchSmsPartTest, SmsInterfaceStub_0003, Function | MediumTest | Level1)
179 {
180     MessageParcel simMsgParcel;
181     MessageParcel replyParcel;
182     MessageOption option(MessageOption::TF_SYNC);
183     simMsgParcel.WriteInt32(0);
184     simMsgParcel.WriteUint32(0);
185     simMsgParcel.WriteUint32(0);
186     simMsgParcel.WriteString16(Str8ToStr16(TEST_SOURCE_DATA));
187     simMsgParcel.WriteString16(Str8ToStr16(TEST_SOURCE_DATA));
188     DelayedSingleton<SmsService>::GetInstance()->OnUpdateSimMessage(simMsgParcel, replyParcel, option);
189     int32_t result = replyParcel.ReadInt32();
190     EXPECT_GE(result, 0);
191 
192     MessageParcel SetImsSmsParcel;
193     SetImsSmsParcel.WriteInt32(0);
194     SetImsSmsParcel.WriteInt32(false);
195     DelayedSingleton<SmsService>::GetInstance()->OnSetImsSmsConfig(SetImsSmsParcel, replyParcel, option);
196     result = replyParcel.ReadInt32();
197     EXPECT_GE(result, 0);
198 
199     MessageParcel splitMsgParcel;
200     splitMsgParcel.WriteString16(Str8ToStr16(TEST_SOURCE_DATA));
201     DelayedSingleton<SmsService>::GetInstance()->OnSplitMessage(splitMsgParcel, replyParcel, option);
202     DelayedSingleton<SmsService>::GetInstance()->OnGetBase64Encode(splitMsgParcel, replyParcel, option);
203     DelayedSingleton<SmsService>::GetInstance()->OnGetBase64Decode(splitMsgParcel, replyParcel, option);
204     result = replyParcel.ReadInt32();
205     EXPECT_GE(result, 0);
206 
207     MessageParcel createMsgParcel;
208     createMsgParcel.WriteString(TEST_SOURCE_DATA);
209     createMsgParcel.WriteString(TEST_SOURCE_DATA);
210     DelayedSingleton<SmsService>::GetInstance()->OnCreateMessage(createMsgParcel, replyParcel, option);
211     result = replyParcel.ReadInt32();
212     EXPECT_GE(result, 0);
213 
214     MessageParcel segmentParcel;
215     segmentParcel.WriteInt32(0);
216     segmentParcel.WriteString16(Str8ToStr16(TEST_SOURCE_DATA));
217     segmentParcel.WriteBool(false);
218     DelayedSingleton<SmsService>::GetInstance()->OnGetSmsSegmentsInfo(segmentParcel, replyParcel, option);
219     result = replyParcel.ReadInt32();
220     EXPECT_GE(result, 0);
221 
222     MessageParcel formatParcel;
223     DelayedSingleton<SmsService>::GetInstance()->OnGetImsShortMessageFormat(formatParcel, replyParcel, option);
224     result = replyParcel.ReadInt32();
225     DelayedSingleton<SmsService>::GetInstance()->OnGetDefaultSmsSimId(formatParcel, replyParcel, option);
226     result = replyParcel.ReadInt32();
227     EXPECT_GE(result, 0);
228 }
229 
230 /**
231  * @tc.number   Telephony_SmsMmsGtest_SmsInterfaceManager_0001
232  * @tc.name     Test SmsInterfaceManager
233  * @tc.desc     Function test
234  */
HWTEST_F(BranchSmsPartTest, SmsInterfaceManager_0001, Function | MediumTest | Level1)235 HWTEST_F(BranchSmsPartTest, SmsInterfaceManager_0001, Function | MediumTest | Level1)
236 {
237     auto interfaceManager = std::make_shared<SmsInterfaceManager>(0);
238     ASSERT_NE(interfaceManager, nullptr);
239     interfaceManager->HasSmsCapability();
240     std::string dataStr = TEST_SOURCE_DATA;
241     auto callStub = iface_cast<ISendShortMessageCallback>(new SendShortMessageCallbackStub());
242     auto deliveryStub = iface_cast<IDeliveryShortMessageCallback>(new DeliveryShortMessageCallbackStub());
243     std::string emptyStr = "";
244     uint16_t dataBaseId = 0;
245     interfaceManager->TextBasedSmsDelivery(dataStr, dataStr, dataStr, callStub, deliveryStub, dataBaseId);
246     interfaceManager->TextBasedSmsDelivery(dataStr, emptyStr, dataStr, callStub, deliveryStub, dataBaseId);
247     interfaceManager->TextBasedSmsDelivery(dataStr, dataStr, emptyStr, callStub, deliveryStub, dataBaseId);
248     int32_t result = interfaceManager->TextBasedSmsDelivery(dataStr, emptyStr, emptyStr,
249         callStub, deliveryStub, dataBaseId);
250     EXPECT_GE(result, 0);
251 
252     const uint8_t *data = reinterpret_cast<const uint8_t *>(dataStr.c_str());
253     interfaceManager->DataBasedSmsDelivery(dataStr, dataStr, 0, data, dataStr.size(), callStub, deliveryStub);
254     interfaceManager->DataBasedSmsDelivery(dataStr, emptyStr, 0, data, dataStr.size(), callStub, deliveryStub);
255     interfaceManager->DataBasedSmsDelivery(dataStr, dataStr, 0, nullptr, 0, callStub, deliveryStub);
256     interfaceManager->smsSendManager_ = nullptr;
257     interfaceManager->TextBasedSmsDelivery(dataStr, dataStr, dataStr, callStub, deliveryStub, dataBaseId);
258     result = interfaceManager->DataBasedSmsDelivery(dataStr, dataStr, 0, data, dataStr.size(), callStub, deliveryStub);
259     EXPECT_GE(result, 0);
260 
261     interfaceManager->AddSimMessage(dataStr, dataStr, ISmsServiceInterface::SIM_MESSAGE_STATUS_UNREAD);
262     interfaceManager->UpdateSimMessage(0, ISmsServiceInterface::SIM_MESSAGE_STATUS_UNREAD, dataStr, dataStr);
263     std::vector<ShortMessage> message;
264     interfaceManager->GetAllSimMessages(message);
265     result = interfaceManager->SetSmscAddr(dataStr);
266     EXPECT_GE(result, 0);
267 
268     std::u16string smsc;
269     interfaceManager->GetSmscAddr(smsc);
270     interfaceManager->SetCBConfig(false, 0, 1, 0);
271     result = interfaceManager->SetImsSmsConfig(0, false);
272     EXPECT_GE(result, 0);
273 
274     interfaceManager->SetDefaultSmsSlotId(0);
275     interfaceManager->GetDefaultSmsSlotId();
276     int32_t simId;
277     interfaceManager->GetDefaultSmsSimId(simId);
278     std::vector<std::u16string> splitMessage;
279     result = interfaceManager->SplitMessage(dataStr, splitMessage);
280     EXPECT_GE(result, 0);
281 }
282 
283 /**
284  * @tc.number   Telephony_SmsMmsGtest_SmsInterfaceManager_0002
285  * @tc.name     Test SmsInterfaceManager
286  * @tc.desc     Function test
287  */
HWTEST_F(BranchSmsPartTest, SmsInterfaceManager_0002, Function | MediumTest | Level1)288 HWTEST_F(BranchSmsPartTest, SmsInterfaceManager_0002, Function | MediumTest | Level1)
289 {
290     auto interfaceManager = std::make_shared<SmsInterfaceManager>(0);
291     ASSERT_NE(interfaceManager, nullptr);
292     LengthInfo outInfo;
293     std::string dataStr = TEST_SOURCE_DATA;
294     interfaceManager->GetSmsSegmentsInfo(dataStr, false, outInfo);
295     bool isSupported = false;
296     interfaceManager->IsImsSmsSupported(0, isSupported);
297     std::u16string format;
298     interfaceManager->GetImsShortMessageFormat(format);
299     int32_t result = interfaceManager->HasSmsCapability();
300     EXPECT_GE(result, 0);
301 
302     std::u16string mmsc = u"";
303     std::u16string data = u"";
304     std::u16string ua = u"";
305     std::u16string uaprof = u"";
306     interfaceManager->SendMms(mmsc, data, ua, uaprof);
307     result = interfaceManager->DownloadMms(mmsc, data, ua, uaprof);
308     EXPECT_GE(result, 0);
309 
310     interfaceManager->smsMiscManager_ = nullptr;
311     interfaceManager->AddSimMessage(dataStr, dataStr, ISmsServiceInterface::SIM_MESSAGE_STATUS_UNREAD);
312     interfaceManager->UpdateSimMessage(0, ISmsServiceInterface::SIM_MESSAGE_STATUS_UNREAD, dataStr, dataStr);
313     std::vector<ShortMessage> message;
314     interfaceManager->GetAllSimMessages(message);
315     interfaceManager->SetSmscAddr(dataStr);
316     std::u16string smsc;
317     result = interfaceManager->GetSmscAddr(mmsc);
318     EXPECT_GE(result, 0);
319 
320     interfaceManager->SetCBConfig(false, 0, 1, 0);
321     interfaceManager->SetImsSmsConfig(0, false);
322     interfaceManager->SetDefaultSmsSlotId(0);
323     interfaceManager->GetDefaultSmsSlotId();
324     int32_t simId;
325     result = interfaceManager->GetDefaultSmsSimId(simId);
326     EXPECT_GE(result, 0);
327 
328     std::vector<std::u16string> splitMessage;
329     interfaceManager->SplitMessage(dataStr, splitMessage);
330     interfaceManager->GetSmsSegmentsInfo(dataStr, false, outInfo);
331     result = interfaceManager->IsImsSmsSupported(0, isSupported);
332     EXPECT_GE(result, 0);
333 
334     interfaceManager->GetImsShortMessageFormat(format);
335     interfaceManager->mmsSendManager_ = nullptr;
336     interfaceManager->SendMms(mmsc, data, ua, uaprof);
337     interfaceManager->mmsReceiverManager_ = nullptr;
338     result = interfaceManager->DownloadMms(mmsc, data, ua, uaprof);
339     EXPECT_GE(result, 0);
340 }
341 
342 /**
343  * @tc.number   Telephony_SmsMmsGtest_SmsInterfaceManager_0003
344  * @tc.name     Test SmsInterfaceManager
345  * @tc.desc     Function test
346  */
HWTEST_F(BranchSmsPartTest, SmsInterfaceManager_0003, Function | MediumTest | Level1)347 HWTEST_F(BranchSmsPartTest, SmsInterfaceManager_0003, Function | MediumTest | Level1)
348 {
349     int32_t slotId = 0;
350     std::shared_ptr<SmsInterfaceManager> interfaceManager = std::make_shared<SmsInterfaceManager>(slotId);
351     interfaceManager->mmsSendManager_ = nullptr;
352     std::u16string mmsc(StringUtils::ToUtf16(VNET_MMSC));
353     std::u16string data(StringUtils::ToUtf16(SEND_MMS_FILE_URL));
354     std::u16string ua = u"112233";
355     std::u16string uaprof = u"112233";
356     int32_t sendMmsRet = interfaceManager->SendMms(mmsc, data, ua, uaprof);
357     interfaceManager->mmsReceiverManager_ = nullptr;
358     int32_t downloadMmsRet = interfaceManager->DownloadMms(mmsc, data, ua, uaprof);
359     EXPECT_GE(sendMmsRet, 0);
360     EXPECT_GE(downloadMmsRet, 0);
361 }
362 
363 /**
364  * @tc.number   Telephony_SmsMmsGtest_SmsStateObserver_0001
365  * @tc.name     Test SmsStateObserver_0001
366  * @tc.desc     Function test
367  */
HWTEST_F(BranchSmsPartTest, SmsStateObserver_0001, Function | MediumTest | Level1)368 HWTEST_F(BranchSmsPartTest, SmsStateObserver_0001, Function | MediumTest | Level1)
369 {
370     std::shared_ptr<SmsStateObserver> smsStateObserver = std::make_shared<SmsStateObserver>();
371     smsStateObserver->smsSubscriber_ = nullptr;
372     smsStateObserver->StopEventSubscriber();
373     std::shared_ptr<CommonEventSubscribeInfo> subscribeInfo = std::make_shared<CommonEventSubscribeInfo>();
374     std::shared_ptr<SmsStateEventSubscriber> smsStateEventSubscriber =
375         std::make_shared<SmsStateEventSubscriber>(*subscribeInfo);
376     EventFwk::CommonEventData eventData = EventFwk::CommonEventData();
377     AAFwk::Want want = AAFwk::Want();
378     want.SetAction(EventFwk::CommonEventSupport::COMMON_EVENT_SMS_EMERGENCY_CB_RECEIVE_COMPLETED);
379     eventData.SetWant(want);
380     smsStateEventSubscriber->OnReceiveEvent(eventData);
381     want.SetAction(EventFwk::CommonEventSupport::COMMON_EVENT_SMS_RECEIVE_COMPLETED);
382     eventData.SetWant(want);
383     smsStateEventSubscriber->OnReceiveEvent(eventData);
384     want.SetAction(EventFwk::CommonEventSupport::COMMON_EVENT_SMS_WAPPUSH_RECEIVE_COMPLETED);
385     eventData.SetWant(want);
386     smsStateEventSubscriber->OnReceiveEvent(eventData);
387     want.SetAction(EventFwk::CommonEventSupport::COMMON_EVENT_BATTERY_LOW);
388     eventData.SetWant(want);
389     smsStateEventSubscriber->OnReceiveEvent(eventData);
390     EXPECT_TRUE(smsStateObserver != nullptr);
391     EXPECT_TRUE(subscribeInfo != nullptr);
392     EXPECT_TRUE(smsStateEventSubscriber != nullptr);
393 }
394 
395 /**
396  * @tc.number   Telephony_SmsMmsGtest_GsmSmsParamCodec_0014
397  * @tc.name     Test GsmSmsParamCodec DecodeSmscPdu
398  * @tc.desc     Function test
399  */
HWTEST_F(BranchSmsPartTest, GsmSmsParamCodec_0014, Function | MediumTest | Level1)400 HWTEST_F(BranchSmsPartTest, GsmSmsParamCodec_0014, Function | MediumTest | Level1) {
401     /**
402     * test supporting smsAddress.ton is unknown
403     */
404     auto gsmSmsParamCodec = std::make_shared<GsmSmsParamCodec>();
405     EXPECT_NE(gsmSmsParamCodec, nullptr);
406     AddressNumber smsAddress;
407 
408     unsigned char encodeData[] = { 0x2, 0x81, 0x2A, 0xB1 };
409     unsigned char *pSMSC = encodeData;
410     EXPECT_GE(gsmSmsParamCodec->DecodeSmscPdu(pSMSC, 5, smsAddress), 0);
411     std::string address(smsAddress.address);
412     EXPECT_EQ(address, "*21#");
413 }
414 
415 /**
416  * @tc.number   Telephony_SmsMmsGtest_GsmSmsParamCodec_0015
417  * @tc.name     Test GsmSmsParamCodec DecodeDcsPdu
418  * @tc.desc     Function test
419  */
HWTEST_F(BranchSmsPartTest, GsmSmsParamCodec_0015, Function | MediumTest | Level1)420 HWTEST_F(BranchSmsPartTest, GsmSmsParamCodec_0015, Function | MediumTest | Level1) {
421     /**
422     * test DecodeDcsPdu
423     */
424     auto gsmSmsParamCodec = std::make_shared<GsmSmsParamCodec>();
425     EXPECT_NE(gsmSmsParamCodec, nullptr);
426 
427     auto decodeBuffer = std::make_shared<SmsReadBuffer>("0011000D91685150800576F70001C404D4F29C0E");
428     SmsDcs *smsDcs = new SmsDcs();
429     smsDcs->codingGroup = OHOS::Telephony::PduSchemeGroup::CODING_GENERAL_GROUP;
430     smsDcs->bCompressed = false;
431     smsDcs->codingScheme = OHOS::Telephony::DataCodingScheme::DATA_CODING_UCS2;
432     smsDcs->msgClass = OHOS::Telephony::SmsMessageClass::SMS_INSTANT_MESSAGE;
433 
434     EXPECT_EQ(gsmSmsParamCodec->DecodeDcsPdu(*decodeBuffer, smsDcs), 1);
435     auto decodeBuffer1 = std::make_shared<SmsReadBuffer>("16D131D98C56B3DD7039584C36A3D56C375C0E169301");
436     EXPECT_EQ(gsmSmsParamCodec->DecodeDcsPdu(*decodeBuffer1, smsDcs), 1);
437     auto decodeBuffer2 = std::make_shared<SmsReadBuffer>("4011000D91685150800576F70001C404D4F29C0E");
438     EXPECT_EQ(gsmSmsParamCodec->DecodeDcsPdu(*decodeBuffer2, smsDcs), 1);
439     auto decodeBuffer3 = std::make_shared<SmsReadBuffer>("C011000D91685150800576F70001C404D4F29C0E");
440     EXPECT_EQ(gsmSmsParamCodec->DecodeDcsPdu(*decodeBuffer3, smsDcs), 1);
441     auto decodeBuffer4 = std::make_shared<SmsReadBuffer>("D011000D91685150800576F70001C404D4F29C0E");
442     EXPECT_EQ(gsmSmsParamCodec->DecodeDcsPdu(*decodeBuffer4, smsDcs), 1);
443     auto decodeBuffer5 = std::make_shared<SmsReadBuffer>("B011000D91685150800576F70001C404D4F29C0E");
444     EXPECT_EQ(gsmSmsParamCodec->DecodeDcsPdu(*decodeBuffer5, smsDcs), 1);
445 }
446 
447 /**
448  * @tc.number   Telephony_SmsMmsGtest_GsmSmsParamDecode_0003
449  * @tc.name     Test GsmSmsParamDecode DecodeDcsGeneralGroupPdu
450  * @tc.desc     Function test
451  */
HWTEST_F(BranchSmsPartTest, GsmSmsParamDecode_0003, Function | MediumTest | Level1)452 HWTEST_F(BranchSmsPartTest, GsmSmsParamDecode_0003, Function | MediumTest | Level1)
453 {
454     auto gsmSmsParamDecode = std::make_shared<GsmSmsParamDecode>();
455     EXPECT_NE(gsmSmsParamDecode, nullptr);
456     uint8_t dcs = 0x08;
457     SmsDcs *smsDcs = nullptr;
458     gsmSmsParamDecode->DecodeDcsGeneralGroupPdu(dcs, smsDcs);
459     EXPECT_EQ(smsDcs, nullptr);
460     SmsDcs *smsDcs1 = new SmsDcs();
461     gsmSmsParamDecode->DecodeDcsGeneralGroupPdu(dcs, smsDcs1);
462     EXPECT_EQ(smsDcs1->msgClass, OHOS::Telephony::SMS_CLASS_UNKNOWN);
463     dcs = 0x15;
464     gsmSmsParamDecode->DecodeDcsGeneralGroupPdu(dcs, smsDcs1);
465     EXPECT_NE(smsDcs1->msgClass, OHOS::Telephony::SMS_CLASS_UNKNOWN);
466 }
467 
468 /**
469  * @tc.number   Telephony_SmsMmsGtest_GsmSmsParamDecode_0004
470  * @tc.name     Test GsmSmsParamDecode DecodeDcsClassGroupPdu
471  * @tc.desc     Function test
472  */
HWTEST_F(BranchSmsPartTest, GsmSmsParamDecode_0004, Function | MediumTest | Level1)473 HWTEST_F(BranchSmsPartTest, GsmSmsParamDecode_0004, Function | MediumTest | Level1)
474 {
475     auto gsmSmsParamDecode = std::make_shared<GsmSmsParamDecode>();
476     EXPECT_NE(gsmSmsParamDecode, nullptr);
477     uint8_t dcs = 0x08;
478     SmsDcs *smsDcs = nullptr;
479     gsmSmsParamDecode->DecodeDcsClassGroupPdu(dcs, smsDcs);
480     EXPECT_EQ(smsDcs, nullptr);
481     SmsDcs *smsDcs1 = new SmsDcs();
482     gsmSmsParamDecode->DecodeDcsClassGroupPdu(dcs, smsDcs1);
483     EXPECT_EQ(smsDcs1->codingGroup, OHOS::Telephony::SMS_CLASS_GROUP);
484 }
485 
486 /**
487  * @tc.number   Telephony_SmsMmsGtest_GsmSmsParamDecode_0005
488  * @tc.name     Test GsmSmsParamDecode DecodeDcsDeleteGroupPdu
489  * @tc.desc     Function test
490  */
HWTEST_F(BranchSmsPartTest, GsmSmsParamDecode_0005, Function | MediumTest | Level1)491 HWTEST_F(BranchSmsPartTest, GsmSmsParamDecode_0005, Function | MediumTest | Level1)
492 {
493     auto gsmSmsParamDecode = std::make_shared<GsmSmsParamDecode>();
494     EXPECT_NE(gsmSmsParamDecode, nullptr);
495     uint8_t dcs = 0x08;
496     SmsDcs *smsDcs = nullptr;
497     gsmSmsParamDecode->DecodeDcsDeleteGroupPdu(dcs, smsDcs);
498     EXPECT_EQ(smsDcs, nullptr);
499     SmsDcs *smsDcs1 = new SmsDcs();
500     gsmSmsParamDecode->DecodeDcsDeleteGroupPdu(dcs, smsDcs1);
501     EXPECT_EQ(smsDcs1->codingGroup, OHOS::Telephony::CODING_DELETION_GROUP);
502 }
503 
504 /**
505  * @tc.number   Telephony_SmsMmsGtest_GsmSmsParamDecode_0006
506  * @tc.name     Test GsmSmsParamDecode DecodeDcsDiscardGroupPdu
507  * @tc.desc     Function test
508  */
HWTEST_F(BranchSmsPartTest, GsmSmsParamDecode_0006, Function | MediumTest | Level1)509 HWTEST_F(BranchSmsPartTest, GsmSmsParamDecode_0006, Function | MediumTest | Level1)
510 {
511     auto gsmSmsParamDecode = std::make_shared<GsmSmsParamDecode>();
512     EXPECT_NE(gsmSmsParamDecode, nullptr);
513     uint8_t dcs = 0x08;
514     SmsDcs *smsDcs = nullptr;
515     gsmSmsParamDecode->DecodeDcsDiscardGroupPdu(dcs, smsDcs);
516     EXPECT_EQ(smsDcs, nullptr);
517     SmsDcs *smsDcs1 = new SmsDcs();
518     gsmSmsParamDecode->DecodeDcsDiscardGroupPdu(dcs, smsDcs1);
519     EXPECT_EQ(smsDcs1->codingGroup, OHOS::Telephony::CODING_DISCARD_GROUP);
520 }
521 
522 /**
523  * @tc.number   Telephony_SmsMmsGtest_GsmSmsParamDecode_0007
524  * @tc.name     Test GsmSmsParamDecode DecodeDcsStoreGsmGroupPdu
525  * @tc.desc     Function test
526  */
HWTEST_F(BranchSmsPartTest, GsmSmsParamDecode_0007, Function | MediumTest | Level1)527 HWTEST_F(BranchSmsPartTest, GsmSmsParamDecode_0007, Function | MediumTest | Level1)
528 {
529     auto gsmSmsParamDecode = std::make_shared<GsmSmsParamDecode>();
530     EXPECT_NE(gsmSmsParamDecode, nullptr);
531     uint8_t dcs = 0x08;
532     SmsDcs *smsDcs = nullptr;
533     gsmSmsParamDecode->DecodeDcsStoreGsmGroupPdu(dcs, smsDcs);
534     EXPECT_EQ(smsDcs, nullptr);
535     SmsDcs *smsDcs1 = new SmsDcs();
536     gsmSmsParamDecode->DecodeDcsStoreGsmGroupPdu(dcs, smsDcs1);
537     EXPECT_EQ(smsDcs1->codingGroup, OHOS::Telephony::CODING_STORE_GROUP);
538     EXPECT_EQ(smsDcs1->codingScheme, OHOS::Telephony::DATA_CODING_7BIT);
539 }
540 
541 /**
542  * @tc.number   Telephony_SmsMmsGtest_GsmSmsParamDecode_0008
543  * @tc.name     Test GsmSmsParamDecode DecodeDcsStoreUCS2GroupPdu
544  * @tc.desc     Function test
545  */
HWTEST_F(BranchSmsPartTest, GsmSmsParamDecode_0008, Function | MediumTest | Level1)546 HWTEST_F(BranchSmsPartTest, GsmSmsParamDecode_0008, Function | MediumTest | Level1)
547 {
548     auto gsmSmsParamDecode = std::make_shared<GsmSmsParamDecode>();
549     EXPECT_NE(gsmSmsParamDecode, nullptr);
550     uint8_t dcs = 0x08;
551     SmsDcs *smsDcs = nullptr;
552     gsmSmsParamDecode->DecodeDcsStoreUCS2GroupPdu(dcs, smsDcs);
553     EXPECT_EQ(smsDcs, nullptr);
554     SmsDcs *smsDcs1 = new SmsDcs();
555     gsmSmsParamDecode->DecodeDcsStoreUCS2GroupPdu(dcs, smsDcs1);
556     EXPECT_EQ(smsDcs1->codingGroup, OHOS::Telephony::CODING_STORE_GROUP);
557     EXPECT_EQ(smsDcs1->codingScheme, OHOS::Telephony::DATA_CODING_UCS2);
558 }
559 
560 /**
561  * @tc.number   Telephony_SmsMmsGtest_GsmSmsParamDecode_0009
562  * @tc.name     Test GsmSmsParamDecode DecodeDcsUnknownGroupPdu
563  * @tc.desc     Function test
564  */
HWTEST_F(BranchSmsPartTest, GsmSmsParamDecode_0009, Function | MediumTest | Level1)565 HWTEST_F(BranchSmsPartTest, GsmSmsParamDecode_0009, Function | MediumTest | Level1)
566 {
567     auto gsmSmsParamDecode = std::make_shared<GsmSmsParamDecode>();
568     EXPECT_NE(gsmSmsParamDecode, nullptr);
569     uint8_t dcs = 0x08;
570     SmsDcs *smsDcs = nullptr;
571     gsmSmsParamDecode->DecodeDcsUnknownGroupPdu(dcs, smsDcs);
572     EXPECT_EQ(smsDcs, nullptr);
573     SmsDcs *smsDcs1 = new SmsDcs();
574     gsmSmsParamDecode->DecodeDcsUnknownGroupPdu(dcs, smsDcs1);
575     EXPECT_EQ(smsDcs1->codingGroup, OHOS::Telephony::CODING_UNKNOWN_GROUP);
576     EXPECT_EQ(smsDcs1->msgClass, OHOS::Telephony::SMS_CLASS_UNKNOWN);
577 }
578 
579 
580 /**
581  * @tc.number   Telephony_SmsMmsGtest_GsmSmsParamDecode_0010
582  * @tc.name     Test GsmSmsParamDecode DecodeTimePduPartData
583  * @tc.desc     Function test
584  */
HWTEST_F(BranchSmsPartTest, GsmSmsParamDecode_0010, Function | MediumTest | Level1)585 HWTEST_F(BranchSmsPartTest, GsmSmsParamDecode_0010, Function | MediumTest | Level1)
586 {
587     auto gsmSmsParamDecode = std::make_shared<GsmSmsParamDecode>();
588     EXPECT_NE(gsmSmsParamDecode, nullptr);
589     auto decodeBuffer = std::make_shared<SmsReadBuffer>("");
590     EXPECT_NE(decodeBuffer, nullptr);
591     EXPECT_TRUE(decodeBuffer->IsEmpty());
592     SmsTimeStamp *pTimeStamp = new SmsTimeStamp();
593     pTimeStamp->format = SmsTimeFormat::SMS_TIME_ABSOLUTE;
594     pTimeStamp->time.absolute.timeZone = -1;
595     EXPECT_EQ(gsmSmsParamDecode->DecodeTimePduPartData(*decodeBuffer, pTimeStamp), false); // first branch PickOneByte
596 
597     auto decodeBuffer1 = std::make_shared<SmsReadBuffer>("00");
598     EXPECT_NE(decodeBuffer1, nullptr);
599     EXPECT_FALSE(decodeBuffer1->IsEmpty());
600     decodeBuffer1->bitIndex_ = 1;
601     EXPECT_EQ(gsmSmsParamDecode->DecodeTimePduPartData(*decodeBuffer1, pTimeStamp), false); // fifth branch ReadByte
602     EXPECT_EQ(gsmSmsParamDecode->DecodeTimePduPartData(*decodeBuffer1, pTimeStamp), false); // third branch ReadByte
603 }
604 
605 /**
606  * @tc.number   Telephony_SmsMmsGtest_GsmSmsParamDecode_0011
607  * @tc.name     Test GsmSmsParamDecode DecodeTimePduData
608  * @tc.desc     Function test
609  */
HWTEST_F(BranchSmsPartTest, GsmSmsParamDecode_0011, Function | MediumTest | Level1)610 HWTEST_F(BranchSmsPartTest, GsmSmsParamDecode_0011, Function | MediumTest | Level1)
611 {
612     auto gsmSmsParamDecode = std::make_shared<GsmSmsParamDecode>();
613     EXPECT_NE(gsmSmsParamDecode, nullptr);
614     auto decodeBuffer = std::make_shared<SmsReadBuffer>("");
615     EXPECT_NE(decodeBuffer, nullptr);
616     EXPECT_FALSE(gsmSmsParamDecode->DecodeTimePduData(*decodeBuffer, nullptr)); // first branch nullptr
617 
618     SmsTimeStamp *pTimeStamp = new SmsTimeStamp();
619     pTimeStamp->format = SmsTimeFormat::SMS_TIME_ABSOLUTE;
620     pTimeStamp->time.absolute.timeZone = -1;
621     EXPECT_FALSE(gsmSmsParamDecode->DecodeTimePduData(*decodeBuffer, pTimeStamp)); // second branch PickOneByte
622 
623     auto decodeBuffer1 = std::make_shared<SmsReadBuffer>("00");
624     EXPECT_NE(decodeBuffer1, nullptr);
625     EXPECT_TRUE(gsmSmsParamDecode->DecodeTimePduData(*decodeBuffer1, pTimeStamp));
626     EXPECT_FALSE(gsmSmsParamDecode->DecodeTimePduData(*decodeBuffer1, pTimeStamp)); // second branch PickOneByte
627 
628     auto decodeBuffer2 = std::make_shared<SmsReadBuffer>("16D131D98C56B3DD7039584C36A3D56C375C0E169301");
629     EXPECT_NE(decodeBuffer2, nullptr);
630     EXPECT_TRUE(gsmSmsParamDecode->DecodeTimePduData(*decodeBuffer2, pTimeStamp));
631 }
632 
633 /**
634  * @tc.number   Telephony_SmsMmsGtest_DecodeAddressAlphaNum_0001
635  * @tc.name     Test GsmSmsParamDecode DecodeAddressAlphaNum
636  * @tc.desc     Function test
637  */
HWTEST_F(BranchSmsPartTest, DecodeAddressAlphaNum_0001, Function | MediumTest | Level1)638 HWTEST_F(BranchSmsPartTest, DecodeAddressAlphaNum_0001, Function | MediumTest | Level1)
639 {
640     auto gsmSmsParamDecode = std::make_shared<GsmSmsParamDecode>();
641     EXPECT_NE(gsmSmsParamDecode, nullptr);
642     auto buffer = std::make_shared<SmsReadBuffer>("00");
643     AddressNumber *pAddress = new AddressNumber();
644     uint8_t bcdLen = 1;
645     uint8_t addrLen = 1;
646     EXPECT_FALSE(gsmSmsParamDecode->DecodeAddressAlphaNum(*buffer, pAddress, bcdLen, addrLen)); // third branch
647 
648     std::string pdu = StringUtils::HexToString("");
649     auto decodeBuffer1 = std::make_shared<SmsReadBuffer>(pdu);
650     printf("decodeBuffer1 index_ = %d, length_ = %d\n", decodeBuffer1->index_, decodeBuffer1->length_);
651     EXPECT_FALSE(gsmSmsParamDecode->DecodeAddressAlphaNum(*buffer, pAddress, bcdLen, addrLen)); // first branch
652 }
653 
654 /**
655  * @tc.number   Telephony_SmsMmsGtest_GsmSmsMessage_0004
656  * @tc.name     Test GsmSmsMessage
657  * @tc.desc     Function test
658  */
HWTEST_F(BranchSmsPartTest, GsmSmsMessage_0004, Function | MediumTest | Level1)659 HWTEST_F(BranchSmsPartTest, GsmSmsMessage_0004, Function | MediumTest | Level1)
660 {
661     auto gsmSmsMessage = std::make_shared<GsmSmsMessage>();
662     EXPECT_TRUE(gsmSmsMessage != nullptr);
663     unsigned char langId = 0;
664     gsmSmsMessage->smsTpdu_ = std::make_shared<struct SmsTpdu>();
665     gsmSmsMessage->smsTpdu_->tpduType = OHOS::Telephony::SmsTpduType::SMS_TPDU_STATUS_REP;
666     EXPECT_EQ(gsmSmsMessage->SetHeaderLang(1, DataCodingScheme::DATA_CODING_UCS2, langId), 0);
667 }
668 
669 /**
670  * @tc.number   Telephony_SmsMmsGtest_GsmSmsMessage_0005
671  * @tc.name     Test GsmSmsMessage
672  * @tc.desc     Function test
673  */
HWTEST_F(BranchSmsPartTest, GsmSmsMessage_0005, Function | MediumTest | Level1)674 HWTEST_F(BranchSmsPartTest, GsmSmsMessage_0005, Function | MediumTest | Level1)
675 {
676     auto gsmSmsMessage = std::make_shared<GsmSmsMessage>();
677     EXPECT_TRUE(gsmSmsMessage != nullptr);
678     SmsConcat concat;
679     gsmSmsMessage->smsTpdu_ = std::make_shared<struct SmsTpdu>();
680     gsmSmsMessage->smsTpdu_->tpduType = OHOS::Telephony::SmsTpduType::SMS_TPDU_STATUS_REP;
681     EXPECT_EQ(gsmSmsMessage->SetHeaderConcat(1, concat), 0);
682 }
683 
684 /**
685  * @tc.number   Telephony_SmsMmsGtest_GsmSmsMessage_0006
686  * @tc.name     Test GsmSmsMessage
687  * @tc.desc     Function test
688  */
HWTEST_F(BranchSmsPartTest, GsmSmsMessage_0006, Function | MediumTest | Level1)689 HWTEST_F(BranchSmsPartTest, GsmSmsMessage_0006, Function | MediumTest | Level1)
690 {
691     auto gsmSmsMessage = std::make_shared<GsmSmsMessage>();
692     EXPECT_TRUE(gsmSmsMessage != nullptr);
693     gsmSmsMessage->smsTpdu_ = nullptr;
694     EXPECT_EQ(gsmSmsMessage->SetHeaderReply(1), 0);
695 
696     gsmSmsMessage->smsTpdu_ = std::make_shared<struct SmsTpdu>();
697     gsmSmsMessage->replyAddress_ = "+13588421254";
698     gsmSmsMessage->smsTpdu_->tpduType = OHOS::Telephony::SmsTpduType::SMS_TPDU_STATUS_REP;
699     EXPECT_EQ(gsmSmsMessage->SetHeaderReply(1), 0);
700 }
701 
702 /**
703  * @tc.number   Telephony_SmsMmsGtest_GsmSmsMessage_0007
704  * @tc.name     Test GsmSmsMessage CreateDefaultSubmit
705  * @tc.desc     Function test
706  */
HWTEST_F(BranchSmsPartTest, GsmSmsMessage_0007, Function | MediumTest | Level1)707 HWTEST_F(BranchSmsPartTest, GsmSmsMessage_0007, Function | MediumTest | Level1)
708 {
709     auto gsmSmsMessage = std::make_shared<GsmSmsMessage>();
710     EXPECT_TRUE(gsmSmsMessage != nullptr);
711     gsmSmsMessage->CreateDefaultSubmit(false, DataCodingScheme::DATA_CODING_7BIT);
712     EXPECT_EQ(gsmSmsMessage->smsTpdu_->tpduType, OHOS::Telephony::SmsTpduType::SMS_TPDU_SUBMIT);
713 }
714 
715 /**
716  * @tc.number   Telephony_SmsMmsGtest_GsmSmsMessage_0008
717  * @tc.name     Test GsmSmsMessage PduAnalysisMsg
718  * @tc.desc     Function test
719  */
HWTEST_F(BranchSmsPartTest, GsmSmsMessage_0008, Function | MediumTest | Level1)720 HWTEST_F(BranchSmsPartTest, GsmSmsMessage_0008, Function | MediumTest | Level1)
721 {
722     auto gsmSmsMessage = std::make_shared<GsmSmsMessage>();
723     EXPECT_TRUE(gsmSmsMessage != nullptr);
724     gsmSmsMessage->smsTpdu_ = std::make_shared<struct SmsTpdu>();
725     gsmSmsMessage->smsTpdu_->tpduType = OHOS::Telephony::SmsTpduType::SMS_TPDU_STATUS_REP;
726     // also test AnalysisMsgDeliver
727     EXPECT_TRUE(gsmSmsMessage->PduAnalysisMsg());
728     gsmSmsMessage->smsTpdu_->tpduType = OHOS::Telephony::SmsTpduType::SMS_TPDU_SUBMIT;
729     // alse test AnalysisMsgSubmit
730     EXPECT_TRUE(gsmSmsMessage->PduAnalysisMsg());
731     gsmSmsMessage->smsTpdu_->tpduType = OHOS::Telephony::SmsTpduType::SMS_TPDU_DELIVER_REP;
732     EXPECT_FALSE(gsmSmsMessage->PduAnalysisMsg());
733 }
734 
735 /**
736  * @tc.number   Telephony_SmsMmsGtest_GsmSmsMessage_0009
737  * @tc.name     Test GsmSmsMessage ConvertUserData and ConvertUserPartData
738  * @tc.desc     Function test
739  */
HWTEST_F(BranchSmsPartTest, GsmSmsMessage_0009, Function | MediumTest | Level1)740 HWTEST_F(BranchSmsPartTest, GsmSmsMessage_0009, Function | MediumTest | Level1)
741 {
742     auto gsmSmsMessage = std::make_shared<GsmSmsMessage>();
743     EXPECT_TRUE(gsmSmsMessage != nullptr);
744 
745     gsmSmsMessage->smsTpdu_ = std::make_shared<struct SmsTpdu>();
746     gsmSmsMessage->smsTpdu_->tpduType = OHOS::Telephony::SmsTpduType::SMS_TPDU_DELIVER;
747     gsmSmsMessage->codingScheme_ = OHOS::Telephony::DataCodingScheme::DATA_CODING_7BIT;
748     size_t  oldSize = gsmSmsMessage->visibleMessageBody_.size();
749     gsmSmsMessage->smsUserData_.header[0].udh.singleShift.langId = 1;
750     std::string text = "1234566";
751     gsmSmsMessage->SetFullText(text);
752     gsmSmsMessage->ConvertUserData();
753     size_t  newSize = gsmSmsMessage->visibleMessageBody_.size();
754     EXPECT_EQ(newSize, oldSize);
755 
756     gsmSmsMessage->codingScheme_ = OHOS::Telephony::DataCodingScheme::DATA_CODING_UCS2;
757     oldSize = gsmSmsMessage->visibleMessageBody_.size();
758     gsmSmsMessage->ConvertUserData();
759     newSize = gsmSmsMessage->visibleMessageBody_.size();
760     EXPECT_EQ(newSize, oldSize);
761 }
762 
763 /**
764  * @tc.number   Telephony_SmsMmsGtest_GsmSmsMessage_0010
765  * @tc.name     Test GsmSmsMessage IsSpecialMessage
766  * @tc.desc     Function test
767  */
HWTEST_F(BranchSmsPartTest, GsmSmsMessage_0010, Function | MediumTest | Level1)768 HWTEST_F(BranchSmsPartTest, GsmSmsMessage_0010, Function | MediumTest | Level1)
769 {
770     auto gsmSmsMessage = std::make_shared<GsmSmsMessage>();
771     EXPECT_TRUE(gsmSmsMessage != nullptr);
772     gsmSmsMessage->protocolId_ = 0x40;
773     EXPECT_TRUE(gsmSmsMessage->IsSpecialMessage());
774 
775     gsmSmsMessage->msgClass_ = OHOS::Telephony::SmsMessageClass::SMS_SIM_MESSAGE;
776     gsmSmsMessage->protocolId_ = 0x7f;
777     EXPECT_TRUE(gsmSmsMessage->IsSpecialMessage());
778 
779     gsmSmsMessage->protocolId_ = 0x7c;
780     EXPECT_TRUE(gsmSmsMessage->IsSpecialMessage());
781 
782     gsmSmsMessage->protocolId_ = 0x41;
783     gsmSmsMessage->bMwiSet_ = true;
784     EXPECT_TRUE(gsmSmsMessage->IsSpecialMessage());
785 
786     gsmSmsMessage->bMwiClear_ = true;
787     EXPECT_TRUE(gsmSmsMessage->IsSpecialMessage());
788 }
789 
790 /**
791  * @tc.number   Telephony_SmsMmsGtest_GsmSmsMessage_0011
792  * @tc.name     Test GsmSmsMessage DecodeMessage
793  * @tc.desc     Function test
794  */
HWTEST_F(BranchSmsPartTest, GsmSmsMessage_0011, Function | MediumTest | Level1)795 HWTEST_F(BranchSmsPartTest, GsmSmsMessage_0011, Function | MediumTest | Level1)
796 {
797     auto gsmSmsMessage = std::make_shared<GsmSmsMessage>();
798     EXPECT_TRUE(gsmSmsMessage != nullptr);
799 
800     std::string msgText("");
801     // init destination array of pdu data
802     uint8_t decodeData[(MAX_GSM_7BIT_DATA_LEN * OHOS::Telephony::MAX_SEGMENT_NUM) + 1];
803     EXPECT_EQ(memset_s(decodeData, sizeof(decodeData), 0x00, sizeof(decodeData)), EOK);
804 
805     int encodeLen = 0;
806     bool bAbnormal = false;
807     unsigned char langId = OHOS::Telephony::MsgLanguageId::MSG_ID_RESERVED_LANG;
808     OHOS::Telephony::DataCodingScheme codingType = OHOS::Telephony::DataCodingScheme::DATA_CODING_7BIT;
809 
810     encodeLen = gsmSmsMessage->DecodeMessage(decodeData, sizeof(decodeData), codingType, msgText, bAbnormal, langId);
811     EXPECT_EQ(encodeLen, 0);
812 
813     msgText = "123456";
814     encodeLen = gsmSmsMessage->DecodeMessage(decodeData, sizeof(decodeData), codingType, msgText, bAbnormal, langId);
815     EXPECT_GT(encodeLen, 0);
816 
817     codingType = OHOS::Telephony::DataCodingScheme::DATA_CODING_8BIT;
818     encodeLen = gsmSmsMessage->DecodeMessage(decodeData, sizeof(decodeData), codingType, msgText, bAbnormal, langId);
819     EXPECT_GT(encodeLen, 0);
820 
821     msgText.append(sizeof(decodeData), '1');
822     encodeLen = gsmSmsMessage->DecodeMessage(decodeData, sizeof(decodeData), codingType, msgText, bAbnormal, langId);
823     EXPECT_EQ(encodeLen, 0);
824 
825     msgText = "123456";
826     codingType = OHOS::Telephony::DataCodingScheme::DATA_CODING_UCS2;
827     encodeLen = gsmSmsMessage->DecodeMessage(decodeData, sizeof(decodeData), codingType, msgText, bAbnormal, langId);
828     EXPECT_GT(encodeLen, 0);
829 
830     codingType = OHOS::Telephony::DataCodingScheme::DATA_CODING_AUTO;
831     encodeLen = gsmSmsMessage->DecodeMessage(decodeData, sizeof(decodeData), codingType, msgText, bAbnormal, langId);
832     EXPECT_GT(encodeLen, 0);
833 
834     codingType = OHOS::Telephony::DataCodingScheme::DATA_CODING_EUCKR;
835     encodeLen = gsmSmsMessage->DecodeMessage(decodeData, sizeof(decodeData), codingType, msgText, bAbnormal, langId);
836     EXPECT_GT(encodeLen, 0);
837 }
838 
839 /**
840  * @tc.number   Telephony_SmsMmsGtest_GsmSmsParamCodec_0016
841  * @tc.name     Test GsmSmsParamCodec EncodeAddressPdu
842  * @tc.desc     Function test
843  */
HWTEST_F(BranchSmsPartTest, GsmSmsParamCodec_0016, Function | MediumTest | Level1)844 HWTEST_F(BranchSmsPartTest, GsmSmsParamCodec_0016, Function | MediumTest | Level1)
845 {
846     auto gsmSmsParamCodec = std::make_shared<GsmSmsParamCodec>();
847     AddressNumber *pAddress = new AddressNumber();
848     std::string paramStr;
849 
850     std::string smsc = "**21*1300555002012345";
851     memcpy_s(&pAddress->address, sizeof(pAddress->address), smsc.data(), smsc.length());
852     pAddress->address[smsc.length()] = '\0';
853     pAddress->ton = TYPE_INTERNATIONAL;
854     pAddress->npi = SMS_NPI_ISDN;
855     EXPECT_FALSE(gsmSmsParamCodec->EncodeAddressPdu(pAddress, paramStr)); // second branch
856 }
857 
858 /**
859  * @tc.number   Telephony_SmsMmsGtest_GsmSmsParamCodec_0017
860  * @tc.name     Test GsmSmsParamCodec EncodeSmscPdu
861  * @tc.desc     Function test
862  */
HWTEST_F(BranchSmsPartTest, GsmSmsParamCodec_0017, Function | MediumTest | Level1)863 HWTEST_F(BranchSmsPartTest, GsmSmsParamCodec_0017, Function | MediumTest | Level1)
864 {
865     /*
866      *   test third branch
867      */
868     auto gsmSmsParamCodec = std::make_shared<GsmSmsParamCodec>();
869     EXPECT_NE(gsmSmsParamCodec, nullptr);
870     const std::string smsc = "+17005550020";
871     AddressNumber *pAddress = new AddressNumber();
872     uint8_t encodeSmscAddr[MAX_SMSC_LEN];
873     memset_s(encodeSmscAddr, sizeof(encodeSmscAddr), 0x00, sizeof(encodeSmscAddr));
874     std::string decodeAddr;
875     memcpy_s(&pAddress->address, sizeof(pAddress->address), smsc.data(), smsc.length());
876     pAddress->address[smsc.length()] = '\0';
877     pAddress->ton = TYPE_INTERNATIONAL;
878     pAddress->npi = SMS_NPI_ISDN;
879     uint8_t encodeSmscLen = 0;
880     encodeSmscLen = gsmSmsParamCodec->EncodeSmscPdu(pAddress, encodeSmscAddr, sizeof(encodeSmscAddr));
881     EXPECT_GT(encodeSmscLen, 0);
882 }
883 
884 /**
885  * @tc.number   Telephony_SmsMmsGtest_GsmSmsTpduCodec_0005
886  * @tc.name     Test GsmSmsTpduCodec EncodeSubmitPdu
887  * @tc.desc     Function test
888  */
HWTEST_F(BranchSmsPartTest, GsmSmsTpduCodec_0005, Function | MediumTest | Level1)889 HWTEST_F(BranchSmsPartTest, GsmSmsTpduCodec_0005, Function | MediumTest | Level1)
890 {
891     auto tpduCodec = std::make_shared<GsmSmsTpduCodec>();
892     auto encodeBuffer = std::make_shared<SmsWriteBuffer>();
893     encodeBuffer->data_[0] = 1;
894     SmsSubmit *pSubmit = new SmsSubmit();
895     /*
896      * parameter check
897      */
898     auto encode = std::make_shared<GsmSmsTpduEncode>(nullptr, tpduCodec->paramCodec_, tpduCodec);
899     EXPECT_FALSE(encode->EncodeSubmitPdu(*encodeBuffer, pSubmit));
900     auto encode1 = std::make_shared<GsmSmsTpduEncode>(tpduCodec->uDataCodec_, nullptr, tpduCodec);
901     EXPECT_FALSE(encode1->EncodeSubmitPdu(*encodeBuffer, pSubmit));
902 
903     auto encode2 = std::make_shared<GsmSmsTpduEncode>(tpduCodec->uDataCodec_, tpduCodec->paramCodec_, tpduCodec);
904     EXPECT_TRUE(encode2->EncodeSubmitPdu(*encodeBuffer, pSubmit));
905     /*
906      * third branch
907      */
908     const std::string smsc = "+17005550020324556627";
909     memcpy_s(&pSubmit->destAddress.address, sizeof(pSubmit->destAddress.address), smsc.data(), smsc.length());
910     pSubmit->destAddress.address[smsc.length()] = '\0';
911     EXPECT_FALSE(encode2->EncodeSubmitPdu(*encodeBuffer, pSubmit));
912 
913     delete pSubmit;
914     pSubmit = nullptr;
915 }
916 
917 /**
918  * @tc.number   Telephony_SmsMmsGtest_GsmSmsTpduCodec_0006
919  * @tc.name     Test GsmSmsTpduCodec EncodeSubmitPduPartData
920  * @tc.desc     Function test
921  */
HWTEST_F(BranchSmsPartTest, GsmSmsTpduCodec_0006, Function | MediumTest | Level1)922 HWTEST_F(BranchSmsPartTest, GsmSmsTpduCodec_0006, Function | MediumTest | Level1)
923 {
924     auto tpduCodec = std::make_shared<GsmSmsTpduCodec>();
925     auto encodeBuffer = std::make_shared<SmsWriteBuffer>();
926     SmsSubmit *pSubmit = new SmsSubmit();
927     auto encode = std::make_shared<GsmSmsTpduEncode>(tpduCodec->uDataCodec_, tpduCodec->paramCodec_, tpduCodec);
928     EXPECT_NE(encode, nullptr);
929     /*
930      * parameter check
931      */
932     encodeBuffer->data_ = nullptr;
933     EXPECT_FALSE(encode->EncodeSubmitPduPartData(*encodeBuffer, pSubmit));
934     /*
935      * third branch
936      */
937     encodeBuffer->index_ = 0;
938     pSubmit->vpf = OHOS::Telephony::SmsVpf::SMS_VPF_ENHANCED;
939     EXPECT_FALSE(encode->EncodeSubmitPdu(*encodeBuffer, pSubmit));
940 
941     encodeBuffer->data_ = nullptr;
942     EXPECT_FALSE(encode->EncodeSubmitPdu(*encodeBuffer, pSubmit));
943 
944     delete pSubmit;
945     pSubmit = nullptr;
946 }
947 
948 /**
949  * @tc.number   Telephony_SmsMmsGtest_GsmSmsTpduCodec_0007
950  * @tc.name     Test GsmSmsTpduCodec EncodeSubmitTpduType
951  * @tc.desc     Function test
952  */
HWTEST_F(BranchSmsPartTest, GsmSmsTpduCodec_0007, Function | MediumTest | Level1)953 HWTEST_F(BranchSmsPartTest, GsmSmsTpduCodec_0007, Function | MediumTest | Level1)
954 {
955     auto tpduCodec = std::make_shared<GsmSmsTpduCodec>();
956     auto encodeBuffer = std::make_shared<SmsWriteBuffer>();
957     SmsSubmit pSubmit;
958     auto encode = std::make_shared<GsmSmsTpduEncode>(tpduCodec->uDataCodec_, tpduCodec->paramCodec_, tpduCodec);
959     EXPECT_NE(encode, nullptr);
960 
961     /*
962      * parameter check
963      */
964     pSubmit.bRejectDup = false;
965     encodeBuffer->data_ = nullptr;
966     uint16_t count = encodeBuffer->GetSize();
967     encode->EncodeSubmitTpduType(*encodeBuffer, pSubmit);
968     EXPECT_EQ(encodeBuffer->GetSize(), count);
969     /*
970      * third branch
971      */
972     auto encodeBuffer2 = std::make_shared<SmsWriteBuffer>();
973     encodeBuffer2->data_[0] = 1;
974     encodeBuffer2->bitIndex_ = 1;
975     uint16_t count2 = encodeBuffer2->GetSize();
976     encode->EncodeSubmitTpduType(*encodeBuffer2, pSubmit);
977     EXPECT_EQ(encodeBuffer2->GetSize(), count2);
978 }
979 
980 /**
981  * @tc.number   Telephony_SmsMmsGtest_GsmSmsTpduCodec_0008
982  * @tc.name     Test GsmSmsTpduCodec EncodeSubmitTypePartData
983  * @tc.desc     Function test
984  */
HWTEST_F(BranchSmsPartTest, GsmSmsTpduCodec_0008, Function | MediumTest | Level1)985 HWTEST_F(BranchSmsPartTest, GsmSmsTpduCodec_0008, Function | MediumTest | Level1)
986 {
987     auto tpduCodec = std::make_shared<GsmSmsTpduCodec>();
988     auto encodeBuffer = std::make_shared<SmsWriteBuffer>();
989     SmsSubmit pSubmit;
990     auto encode = std::make_shared<GsmSmsTpduEncode>(tpduCodec->uDataCodec_, tpduCodec->paramCodec_, tpduCodec);
991     EXPECT_NE(encode, nullptr);
992     pSubmit.bStatusReport = false;
993     pSubmit.bHeaderInd = false;
994     pSubmit.bReplyPath = false;
995     /*
996      * SMS_VPF_ENHANCED
997      */
998     pSubmit.vpf = OHOS::Telephony::SmsVpf::SMS_VPF_ENHANCED;
999     encodeBuffer->data_ = nullptr;
1000     uint16_t count1 = encodeBuffer->GetSize();
1001     encode->EncodeSubmitTypePartData(*encodeBuffer, pSubmit);
1002     EXPECT_EQ(encodeBuffer->GetSize(), count1);
1003 
1004     auto encodeBuffer2 = std::make_shared<SmsWriteBuffer>();
1005     encodeBuffer2->data_[0] = 1;
1006     encodeBuffer2->index_ = 1;
1007     uint16_t count2 = encodeBuffer2->GetSize();
1008     encode->EncodeSubmitTypePartData(*encodeBuffer2, pSubmit);
1009     EXPECT_EQ(encodeBuffer2->GetSize(), count2);
1010     /*
1011      * SMS_VPF_RELATIVE
1012      */
1013     pSubmit.vpf = OHOS::Telephony::SmsVpf::SMS_VPF_ENHANCED;
1014     auto encodeBuffer3 = std::make_shared<SmsWriteBuffer>();
1015     encodeBuffer3->data_ = nullptr;
1016     uint16_t count3 = encodeBuffer3->GetSize();
1017     encode->EncodeSubmitTypePartData(*encodeBuffer3, pSubmit);
1018     EXPECT_EQ(encodeBuffer3->GetSize(), count3);
1019 
1020     auto encodeBuffer4 = std::make_shared<SmsWriteBuffer>();
1021     encodeBuffer4->data_[0] = 1;
1022     encodeBuffer4->index_ = 1;
1023     uint16_t count4 = encodeBuffer4->GetSize();
1024     encode->EncodeSubmitTypePartData(*encodeBuffer4, pSubmit);
1025     EXPECT_EQ(encodeBuffer4->GetSize(), count4);
1026     /*
1027      * SMS_VPF_RELATIVE
1028      */
1029     pSubmit.vpf = OHOS::Telephony::SmsVpf::SMS_VPF_RELATIVE;
1030     auto encodeBuffer5 = std::make_shared<SmsWriteBuffer>();
1031     encodeBuffer5->data_ = nullptr;
1032     uint16_t count5 = encodeBuffer5->GetSize();
1033     encode->EncodeSubmitTypePartData(*encodeBuffer5, pSubmit);
1034     EXPECT_EQ(encodeBuffer5->GetSize(), count5);
1035 
1036     auto encodeBuffer6 = std::make_shared<SmsWriteBuffer>();
1037     encodeBuffer6->data_[0] = 1;
1038     encodeBuffer6->index_ = 1;
1039     uint16_t count6 = encodeBuffer6->GetSize();
1040     encode->EncodeSubmitTypePartData(*encodeBuffer6, pSubmit);
1041     EXPECT_EQ(encodeBuffer6->GetSize(), count6);
1042 }
1043 
1044 /**
1045  * @tc.number   Telephony_SmsMmsGtest_GsmSmsTpduCodec_0009
1046  * @tc.name     Test GsmSmsTpduCodec EncodeSubmitTypePartData
1047  * @tc.desc     Function test
1048  */
HWTEST_F(BranchSmsPartTest, GsmSmsTpduCodec_0009, Function | MediumTest | Level1)1049 HWTEST_F(BranchSmsPartTest, GsmSmsTpduCodec_0009, Function | MediumTest | Level1)
1050 {
1051     auto tpduCodec = std::make_shared<GsmSmsTpduCodec>();
1052     auto encodeBuffer = std::make_shared<SmsWriteBuffer>();
1053     SmsSubmit pSubmit;
1054     auto encode = std::make_shared<GsmSmsTpduEncode>(tpduCodec->uDataCodec_, tpduCodec->paramCodec_, tpduCodec);
1055     EXPECT_NE(encode, nullptr);
1056     pSubmit.bStatusReport = false;
1057     pSubmit.bHeaderInd = false;
1058     pSubmit.bReplyPath = false;
1059     /*
1060      * SMS_VPF_ABSOLUTE
1061      */
1062     pSubmit.vpf = OHOS::Telephony::SmsVpf::SMS_VPF_ABSOLUTE;
1063     auto encodeBuffer7 = std::make_shared<SmsWriteBuffer>();
1064     encodeBuffer7->data_ = nullptr;
1065     uint16_t count7 = encodeBuffer7->GetSize();
1066     encode->EncodeSubmitTypePartData(*encodeBuffer7, pSubmit);
1067     EXPECT_EQ(encodeBuffer7->GetSize(), count7);
1068 
1069     auto encodeBuffer8 = std::make_shared<SmsWriteBuffer>();
1070     encodeBuffer8->data_[0] = 1;
1071     encodeBuffer8->index_ = 1;
1072     uint16_t count8 = encodeBuffer8->GetSize();
1073     encode->EncodeSubmitTypePartData(*encodeBuffer8, pSubmit);
1074     EXPECT_EQ(encodeBuffer8->GetSize(), count8);
1075     /*
1076      * SMS_VPF_NOT_PRESENT
1077      */
1078     pSubmit.vpf = OHOS::Telephony::SmsVpf::SMS_VPF_NOT_PRESENT;
1079     auto encodeBuffer9 = std::make_shared<SmsWriteBuffer>();
1080     encodeBuffer9->data_ = nullptr;
1081     uint16_t count9 = encodeBuffer9->GetSize();
1082     encode->EncodeSubmitTypePartData(*encodeBuffer9, pSubmit);
1083     EXPECT_EQ(encodeBuffer9->GetSize(), count9);
1084 }
1085 
1086 /**
1087  * @tc.number   Telephony_SmsMmsGtest_GsmSmsTpduCodec_0010
1088  * @tc.name     Test GsmSmsTpduCodec EncodeSubmitTypeData
1089  * @tc.desc     Function test
1090  */
HWTEST_F(BranchSmsPartTest, GsmSmsTpduCodec_0010, Function | MediumTest | Level1)1091 HWTEST_F(BranchSmsPartTest, GsmSmsTpduCodec_0010, Function | MediumTest | Level1)
1092 {
1093     auto tpduCodec = std::make_shared<GsmSmsTpduCodec>();
1094     auto encodeBuffer = std::make_shared<SmsWriteBuffer>();
1095     SmsSubmit pSubmit;
1096     auto encode = std::make_shared<GsmSmsTpduEncode>(tpduCodec->uDataCodec_, tpduCodec->paramCodec_, tpduCodec);
1097     EXPECT_NE(encode, nullptr);
1098     /*
1099      * pSubmit->bStatusReport is true
1100      */
1101     pSubmit.bStatusReport = true;
1102     encode->EncodeSubmitTypePartData(*encodeBuffer, pSubmit);
1103     auto encodeBuffer1 = std::make_shared<SmsWriteBuffer>();
1104     encodeBuffer1->data_[0] = 1;
1105     encodeBuffer1->index_ = 1;
1106     uint16_t count1 = encodeBuffer1->GetSize();
1107     encode->EncodeSubmitTypePartData(*encodeBuffer1, pSubmit);
1108     EXPECT_EQ(encodeBuffer1->GetSize(), count1);
1109     /*
1110      * pSubmit.bHeaderInd is true
1111      */
1112     auto encodeBuffer2 = std::make_shared<SmsWriteBuffer>();
1113     pSubmit.bStatusReport = false;
1114     pSubmit.bHeaderInd = true;
1115     const std::string smsc = "17005550020";
1116     memcpy_s(&pSubmit.destAddress.address, sizeof(pSubmit.destAddress.address), smsc.data(), smsc.length());
1117     pSubmit.destAddress.address[smsc.length()] = '\0';
1118     encodeBuffer2->data_ = nullptr;
1119     uint16_t count2 = encodeBuffer2->GetSize();
1120     encode->EncodeSubmitTypePartData(*encodeBuffer2, pSubmit);
1121     EXPECT_EQ(encodeBuffer2->GetSize(), count2);
1122 
1123     auto encodeBuffer3 = std::make_shared<SmsWriteBuffer>();
1124     encodeBuffer3->data_[0] = 1;
1125     encodeBuffer3->index_ = 1;
1126     uint16_t count3 = encodeBuffer3->GetSize();
1127     encode->EncodeSubmitTypePartData(*encodeBuffer3, pSubmit);
1128     EXPECT_EQ(encodeBuffer3->GetSize(), count3);
1129     /*
1130      * pSubmit.bReplyPath is true
1131      */
1132     pSubmit.bStatusReport = false;
1133     pSubmit.bHeaderInd = false;
1134     pSubmit.bReplyPath = true;
1135     auto encodeBuffer4 = std::make_shared<SmsWriteBuffer>();
1136     encodeBuffer4->data_ = nullptr;
1137     uint16_t count4 = encodeBuffer4->GetSize();
1138     encode->EncodeSubmitTypePartData(*encodeBuffer4, pSubmit);
1139     EXPECT_EQ(encodeBuffer4->GetSize(), count4);
1140 
1141     auto encodeBuffer5 = std::make_shared<SmsWriteBuffer>();
1142     encodeBuffer5->data_[0] = 1;
1143     encodeBuffer5->index_ = 1;
1144     uint16_t count5 = encodeBuffer5->GetSize();
1145     encode->EncodeSubmitTypePartData(*encodeBuffer5, pSubmit);
1146     EXPECT_EQ(encodeBuffer5->GetSize(), count5);
1147 }
1148 
1149 /**
1150  * @tc.number   Telephony_SmsMmsGtest_GsmSmsTpduCodec_0011
1151  * @tc.name     Test GsmSmsTpduCodec EncodeDeliverPdu
1152  * @tc.desc     Function test
1153  */
HWTEST_F(BranchSmsPartTest, GsmSmsTpduCodec_0011, Function | MediumTest | Level1)1154 HWTEST_F(BranchSmsPartTest, GsmSmsTpduCodec_0011, Function | MediumTest | Level1)
1155 {
1156     auto tpduCodec = std::make_shared<GsmSmsTpduCodec>();
1157     auto encodeBuffer = std::make_shared<SmsWriteBuffer>();
1158     SmsDeliver *pDeliver = new SmsDeliver();
1159     auto encode = std::make_shared<GsmSmsTpduEncode>(tpduCodec->uDataCodec_, tpduCodec->paramCodec_, tpduCodec);
1160     EXPECT_NE(encode, nullptr);
1161     /*
1162      * second branch
1163      */
1164     encodeBuffer->data_ = nullptr;
1165     EXPECT_FALSE(encode->EncodeDeliverPdu(*encodeBuffer, pDeliver));
1166     /*
1167      * third branch pDeliver->bMoreMsg is false
1168      */
1169     auto encodeBuffer1 = std::make_shared<SmsWriteBuffer>();
1170     pDeliver->bMoreMsg = false;
1171     EXPECT_FALSE(encode->EncodeDeliverPdu(*encodeBuffer1, pDeliver));
1172 
1173     auto encodeBuffer2 = std::make_shared<SmsWriteBuffer>();
1174     encodeBuffer2->data_[0] = 1;
1175     encodeBuffer2->index_ = 1;
1176     EXPECT_FALSE(encode->EncodeDeliverPdu(*encodeBuffer2, pDeliver));
1177     /*
1178      * fourth branch pDeliver->bStatusReport is true
1179      */
1180     pDeliver->bMoreMsg = true;
1181     pDeliver->bStatusReport = true;
1182     auto encodeBuffer3 = std::make_shared<SmsWriteBuffer>();
1183     EXPECT_FALSE(encode->EncodeDeliverPdu(*encodeBuffer3, pDeliver));
1184 
1185     auto encodeBuffer4 = std::make_shared<SmsWriteBuffer>();
1186     encodeBuffer4->data_[0] = 1;
1187     encodeBuffer4->index_ = 1;
1188     EXPECT_FALSE(encode->EncodeDeliverPdu(*encodeBuffer4, pDeliver));
1189     /*
1190      * fifth branch pDeliver->bHeaderInd is true
1191      */
1192     auto encodeBuffer5 = std::make_shared<SmsWriteBuffer>();
1193     pDeliver->bStatusReport = false;
1194     pDeliver->bHeaderInd = true;
1195     EXPECT_FALSE(encode->EncodeDeliverPdu(*encodeBuffer5, pDeliver));
1196 
1197     auto encodeBuffer6 = std::make_shared<SmsWriteBuffer>();
1198     encodeBuffer6->data_[0] = 1;
1199     encodeBuffer6->index_ = 1;
1200     EXPECT_FALSE(encode->EncodeDeliverPdu(*encodeBuffer6, pDeliver));
1201 
1202     delete pDeliver;
1203     pDeliver = nullptr;
1204 }
1205 
1206 /**
1207  * @tc.number   Telephony_SmsMmsGtest_GsmSmsTpduCodec_0012
1208  * @tc.name     Test GsmSmsTpduCodec EncodeDeliverPartData
1209  * @tc.desc     Function test
1210  */
HWTEST_F(BranchSmsPartTest, GsmSmsTpduCodec_0012, Function | MediumTest | Level1)1211 HWTEST_F(BranchSmsPartTest, GsmSmsTpduCodec_0012, Function | MediumTest | Level1)
1212 {
1213     auto tpduCodec = std::make_shared<GsmSmsTpduCodec>();
1214     auto encodeBuffer = std::make_shared<SmsWriteBuffer>();
1215     SmsDeliver *pDeliver = new SmsDeliver();
1216     /*
1217      * parameter check
1218      */
1219     auto encode0 = std::make_shared<GsmSmsTpduEncode>(tpduCodec->uDataCodec_, nullptr, tpduCodec);
1220     EXPECT_NE(encode0, nullptr);
1221     EXPECT_FALSE(encode0->EncodeDeliverPartData(*encodeBuffer, pDeliver));
1222 
1223     auto encode = std::make_shared<GsmSmsTpduEncode>(tpduCodec->uDataCodec_, tpduCodec->paramCodec_, tpduCodec);
1224     EXPECT_NE(encode, nullptr);
1225     /*
1226      * pDeliver->bReplyPath is true
1227      */
1228     pDeliver->bReplyPath = true;
1229     encodeBuffer->data_ = nullptr;
1230     EXPECT_FALSE(encode->EncodeDeliverPartData(*encodeBuffer, pDeliver));
1231 
1232     auto encodeBuffer1 = std::make_shared<SmsWriteBuffer>();
1233     encodeBuffer1->data_[0] = 1;
1234     encodeBuffer1->index_ = 1;
1235     EXPECT_FALSE(encode->EncodeDeliverPartData(*encodeBuffer, pDeliver));
1236     /*
1237      * third branch
1238      */
1239     auto encodeBuffer2 = std::make_shared<SmsWriteBuffer>();
1240     pDeliver->bReplyPath = false;
1241     const std::string smsc = "17005550020111111111";
1242     memcpy_s(&pDeliver->originAddress.address, sizeof(pDeliver->originAddress.address), smsc.data(), smsc.length());
1243     pDeliver->originAddress.address[smsc.length()] = '\0';
1244     EXPECT_FALSE(encode->EncodeDeliverPartData(*encodeBuffer2, pDeliver));
1245     /*
1246      * fourth branch
1247      */
1248     auto encodeBuffer3 = std::make_shared<SmsWriteBuffer>();
1249     encodeBuffer3->data_[0] = 1;
1250     EXPECT_FALSE(encode->EncodeDeliverPartData(*encodeBuffer3, pDeliver));
1251 
1252     delete pDeliver;
1253     pDeliver = nullptr;
1254 }
1255 
1256 /**
1257  * @tc.number   Telephony_SmsMmsGtest_GsmSmsTpduCodec_0013
1258  * @tc.name     Test GsmSmsTpduCodec EncodeDeliverData
1259  * @tc.desc     Function test
1260  */
HWTEST_F(BranchSmsPartTest, GsmSmsTpduCodec_0013, Function | MediumTest | Level1)1261 HWTEST_F(BranchSmsPartTest, GsmSmsTpduCodec_0013, Function | MediumTest | Level1)
1262 {
1263     auto tpduCodec = std::make_shared<GsmSmsTpduCodec>();
1264     auto encodeBuffer = std::make_shared<SmsWriteBuffer>();
1265     SmsDeliver *pDeliver = new SmsDeliver();
1266     /*
1267      * parameter check
1268      */
1269     auto encode0 = std::make_shared<GsmSmsTpduEncode>(nullptr, tpduCodec->paramCodec_, tpduCodec);
1270     EXPECT_NE(encode0, nullptr);
1271     EXPECT_FALSE(encode0->EncodeDeliverData(*encodeBuffer, pDeliver));
1272     /*
1273      * second branch
1274      */
1275     auto encode = std::make_shared<GsmSmsTpduEncode>(tpduCodec->uDataCodec_, tpduCodec->paramCodec_, tpduCodec);
1276     EXPECT_NE(encode, nullptr);
1277     encodeBuffer->data_ = nullptr;
1278     EXPECT_FALSE(encode->EncodeDeliverData(*encodeBuffer, pDeliver));
1279 
1280     auto encodeBuffer1 = std::make_shared<SmsWriteBuffer>();
1281     encodeBuffer->index_ = 1;
1282     EXPECT_FALSE(encode->EncodeDeliverPartData(*encodeBuffer1, pDeliver));
1283     /*
1284      * main branch
1285      */
1286     auto encodeBuffer2 = std::make_shared<SmsWriteBuffer>();
1287     encodeBuffer2->data_[0] = 1;
1288     encodeBuffer2->index_ = 1;
1289     EXPECT_FALSE(encode->EncodeDeliverPartData(*encodeBuffer2, pDeliver));
1290 
1291     delete pDeliver;
1292     pDeliver = nullptr;
1293 }
1294 } // namespace Telephony
1295 } // namespace OHOS
1296