1 /*
2 * Copyright (C) 2023 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_message.h"
20 #include "delivery_short_message_callback_stub.h"
21 #include "gsm_sms_message.h"
22 #include "gsm_sms_param_decode.h"
23 #include "gsm_sms_receive_handler.h"
24 #include "gsm_sms_tpdu_decode.h"
25 #include "gsm_sms_tpdu_encode.h"
26 #include "gsm_user_data_decode.h"
27 #include "gsm_user_data_encode.h"
28 #include "gtest/gtest.h"
29 #include "radio_event.h"
30 #include "satellite_sms_client.h"
31 #include "send_short_message_callback_stub.h"
32 #include "short_message.h"
33 #include "sms_common_utils.h"
34 #include "sms_misc_manager.h"
35 #include "sms_mms_gtest.h"
36 #include "sms_pdu_buffer.h"
37 #include "sms_receive_handler.h"
38 #include "sms_receive_reliability_handler.h"
39 #include "sms_send_manager.h"
40 #include "sms_sender.h"
41 #include "sms_service.h"
42 #include "sms_service_manager_client.h"
43 #include "sms_state_handler.h"
44 #include "telephony_errors.h"
45
46 namespace OHOS {
47 namespace Telephony {
48 using namespace testing::ext;
49
50 namespace {
51 const std::string TEXT_SMS_CONTENT = "hello world";
52 const std::u16string INTERFACE_TOKEN = u"ohos.telephony.ISatelliteSmsCallback";
53 const std::string BLOCK_NUMBER = "123";
54 const int8_t TEXT_PORT_NUM = -1;
55 const int16_t WAP_PUSH_PORT = 2948;
56 const uint16_t BUF_SIZE = 2401;
57 const uint8_t BUFFER_SIZE = 255;
58 const int DIGIT_LEN = 3;
59 const int START_BIT = 4;
60 const int32_t INVALID_SLOTID = 2;
61 const int32_t VALUE_LENGTH = 2;
62 const int32_t HEADER_LENGTH = 7;
63 const uint32_t CODE_BUFFER_MAX_SIZE = 300 * 1024;
64 const unsigned int SMS_REF_ID = 10;
65 static constexpr uint16_t MAX_TPDU_DATA_LEN = 255;
66 const std::string CB_RANGE_MIDS = "0-1,2-3";
67 const std::string CB_RANGE_DCSS = "0-255";
68 const std::string CB_RANGE_DELI = ",";
69 const std::string CB_RANGE_MID = "0-1";
70 const std::string CB_RANGE_DELIM = "-";
71 static constexpr const char *SLOT_ID = "slot_id";
72 const std::string TABLE_URL = "datashare:///com.ohos.smsmmsability/sms_mms/sms_subsection";
73 const std::string SMS_READ_PDU = "123456";
74 const size_t DECODE_SIZE = 10;
75 const int EIGHT_BIT = 8;
76 const int FOUR_BIT = 4;
77 const int FIVE_BIT = 5;
78 const int SIX_BIT = 6;
79 const int TWO_BIT = 2;
80 const std::string CBN_NUM = "+86192********";
81 const int NUM_LENGTH = 11;
82 const std::string PREFIX = "+86";
83 const std::vector<uint8_t> PDU = { 0 };
84 } // namespace
85
86 class BranchSmsTest : public testing::Test {
87 public:
88 static void SetUpTestCase();
89 static void TearDownTestCase();
90 void SetUp();
91 void TearDown();
92 };
SetUpTestCase()93 void BranchSmsTest::SetUpTestCase() {}
94
TearDownTestCase()95 void BranchSmsTest::TearDownTestCase() {}
96
SetUp()97 void BranchSmsTest::SetUp() {}
98
TearDown()99 void BranchSmsTest::TearDown() {}
100
101 /**
102 * @tc.number Telephony_SmsMmsGtest_SmsReceiveHandler_0001
103 * @tc.name Test SmsReceiveHandler
104 * @tc.desc Function test
105 */
106 HWTEST_F(BranchSmsTest, SmsReceiveHandler_0001, Function | MediumTest | Level1)
107 {
108 AppExecFwk::InnerEvent::Pointer event = AppExecFwk::InnerEvent::Get(RadioEvent::RADIO_GSM_SMS, 1);
109 std::shared_ptr<SmsReceiveHandler> smsReceiveHandler = std::make_shared<CdmaSmsReceiveHandler>(INVALID_SLOTID);
110 smsReceiveHandler->ProcessEvent(event);
111 event = AppExecFwk::InnerEvent::Get(RadioEvent::RADIO_CDMA_SMS, 1);
112 smsReceiveHandler->ProcessEvent(event);
113 event = AppExecFwk::InnerEvent::Get(RadioEvent::RADIO_CONNECTED, 1);
114 smsReceiveHandler->ProcessEvent(event);
115 event = nullptr;
116 smsReceiveHandler->ProcessEvent(event);
117 std::shared_ptr<SmsReceiveIndexer> indexer = nullptr;
118 std::shared_ptr<SmsBaseMessage> smsBaseMessage = nullptr;
119 std::shared_ptr<vector<string>> pdus = nullptr;
120 auto reliabilityHandler = std::make_shared<SmsReceiveReliabilityHandler>(INVALID_SLOTID);
121 reliabilityHandler->DeleteMessageFormDb(SMS_REF_ID);
122 smsReceiveHandler->CombineMessagePart(indexer);
123
124 reliabilityHandler->CheckBlockedPhoneNumber(BLOCK_NUMBER);
125 reliabilityHandler->DeleteAutoSmsFromDB(reliabilityHandler, 0, 0);
126 reliabilityHandler->SendBroadcast(indexer, pdus);
127 smsReceiveHandler->HandleReceivedSms(smsBaseMessage);
128 indexer = std::make_shared<SmsReceiveIndexer>();
129 smsReceiveHandler->CombineMessagePart(indexer);
130 indexer->msgCount_ = 1;
131 indexer->destPort_ = WAP_PUSH_PORT;
132 smsReceiveHandler->CombineMessagePart(indexer);
133 reliabilityHandler->SendBroadcast(indexer, pdus);
134 pdus = std::make_shared<vector<string>>();
135 string pud = "qwe";
136 pdus->push_back(pud);
137 reliabilityHandler->SendBroadcast(indexer, pdus);
138 smsReceiveHandler->CombineMultiPageMessage(indexer, pdus, reliabilityHandler);
139 smsReceiveHandler->UpdateMultiPageMessage(indexer, pdus);
140 indexer->destPort_ = TEXT_PORT_NUM;
141 reliabilityHandler->SendBroadcast(indexer, pdus);
142 smsReceiveHandler->AddMsgToDB(indexer);
143 smsReceiveHandler->IsRepeatedMessagePart(indexer);
144 indexer = nullptr;
145 EXPECT_FALSE(smsReceiveHandler->AddMsgToDB(indexer));
146 }
147
148 /**
149 * @tc.number Telephony_SmsMmsGtest_SmsReceiveReliabilityHandler_0001
150 * @tc.name Test SmsReceiveReliabilityHandler
151 * @tc.desc Function test
152 */
153 HWTEST_F(BranchSmsTest, SmsReceiveReliabilityHandler_0001, Function | MediumTest | Level1)
154 {
155 auto reliabilityHandler = std::make_shared<SmsReceiveReliabilityHandler>(INVALID_SLOTID);
156 reliabilityHandler->DeleteMessageFormDb(SMS_REF_ID);
157
158 std::vector<SmsReceiveIndexer> dbIndexers;
159 std::string strData = "qwe";
160 auto indexer = SmsReceiveIndexer(StringUtils::HexToByteVector(strData), strData.size(), strData.size(), false,
161 strData, strData, strData.size(), strData.size(), strData.size(), false, strData);
162
163 dbIndexers.push_back(indexer);
164 indexer = SmsReceiveIndexer(
165 StringUtils::HexToByteVector(strData), strData.size(), strData.size(), false, false, strData, strData, strData);
166 dbIndexers.push_back(indexer);
167 reliabilityHandler->CheckUnReceiveWapPush(dbIndexers);
168
169 std::shared_ptr<std::vector<std::string>> userDataRaws = std::make_shared<std::vector<std::string>>();
170 userDataRaws->push_back(strData);
171
172 int32_t pages = 0;
173 reliabilityHandler->GetWapPushUserDataSinglePage(indexer, userDataRaws);
174 int32_t count;
175 reliabilityHandler->GetWapPushUserDataMultipage(count, dbIndexers, 0, userDataRaws);
176 reliabilityHandler->GetWapPushUserDataMultipage(count, dbIndexers, VALUE_LENGTH, userDataRaws);
177 reliabilityHandler->GetWapPushUserDataMultipage(count, dbIndexers, VALUE_LENGTH + 1, userDataRaws);
178 reliabilityHandler->ReadyDecodeWapPushUserData(indexer, userDataRaws);
179 reliabilityHandler->GetSmsUserDataMultipage(pages, dbIndexers, 0, userDataRaws);
180 reliabilityHandler->ReadySendSmsBroadcast(indexer, userDataRaws);
181 reliabilityHandler->DeleteMessageFormDb(strData.size(), strData.size());
182 reliabilityHandler->RemoveBlockedSms(dbIndexers);
183
184 std::shared_ptr<SmsReceiveIndexer> indexerPtr =
185 std::make_shared<SmsReceiveIndexer>(StringUtils::HexToByteVector(strData), strData.size(), strData.size(),
186 false, strData, strData, strData.size(), strData.size(), strData.size(), false, strData);
187 if (indexerPtr == nullptr) {
188 return;
189 }
190 reliabilityHandler->SendBroadcast(indexerPtr, userDataRaws);
191 EXPECT_TRUE(reliabilityHandler->CheckSmsCapable());
192 EXPECT_FALSE(reliabilityHandler->CheckBlockedPhoneNumber(BLOCK_NUMBER));
193 }
194
195 /**
196 * @tc.number Telephony_SmsMmsGtest_SmsStateHandler_0001
197 * @tc.name Test SmsStateHandler
198 * @tc.desc Function test
199 */
200 HWTEST_F(BranchSmsTest, SmsStateHandler_0001, Function | MediumTest | Level1)
201 {
202 SmsStateHandler handler;
203 handler.Init();
204 handler.UnInit();
205 EXPECT_TRUE(handler.RegisterHandler());
206 EXPECT_TRUE(handler.UnRegisterHandler());
207 }
208
209 /**
210 * @tc.number Telephony_SmsMmsGtest_CdmaSmsSender_0001
211 * @tc.name Test CdmaSmsSender
212 * @tc.desc Function test
213 */
214 HWTEST_F(BranchSmsTest, CdmaSmsSender_0001, Function | MediumTest | Level1)
215 {
216 std::function<void(std::shared_ptr<SmsSendIndexer>)> fun = nullptr;
217 auto cdmaSmsSender = std::make_shared<CdmaSmsSender>(INVALID_SLOTID, fun);
218 cdmaSmsSender->isImsCdmaHandlerRegistered = true;
219 cdmaSmsSender->RegisterImsHandler();
220 const sptr<ISendShortMessageCallback> sendCallback =
221 iface_cast<ISendShortMessageCallback>(new SendShortMessageCallbackStub());
222 if (sendCallback == nullptr) {
223 return;
224 }
225 const sptr<IDeliveryShortMessageCallback> deliveryCallback =
226 iface_cast<IDeliveryShortMessageCallback>(new DeliveryShortMessageCallbackStub());
227 if (deliveryCallback == nullptr) {
228 return;
229 }
230 const std::string text = "123";
231 const std::string desAddr = "qwe";
232 const std::string scAddr = "123";
233 cdmaSmsSender->isImsNetDomain_ = true;
234 cdmaSmsSender->TextBasedSmsDelivery(desAddr, scAddr, text, sendCallback, deliveryCallback);
235 std::vector<struct SplitInfo> splits;
236 std::unique_ptr<CdmaTransportMsg> transMsg;
237 uint8_t msgRef8bit = 0;
238 uint16_t msgId = 0;
239 long timeStamp = 0;
240 cdmaSmsSender->TextBasedSmsSplitDelivery(
241 desAddr, scAddr, splits, std::move(transMsg), msgRef8bit, msgId, timeStamp, sendCallback, deliveryCallback);
242 cdmaSmsSender->TextBasedSmsDeliveryViaIms(desAddr, scAddr, text, sendCallback, deliveryCallback);
243 std::shared_ptr<SmsSendIndexer> smsIndexer = nullptr;
244 cdmaSmsSender->SendSmsToRil(smsIndexer);
245 cdmaSmsSender->ResendTextDelivery(smsIndexer);
246 cdmaSmsSender->ResendDataDelivery(smsIndexer);
247 smsIndexer = std::make_shared<SmsSendIndexer>(desAddr, scAddr, text, sendCallback, deliveryCallback);
248 cdmaSmsSender->SendSmsToRil(smsIndexer);
249 cdmaSmsSender->ResendTextDelivery(smsIndexer);
250 cdmaSmsSender->ResendDataDelivery(smsIndexer);
251 AppExecFwk::InnerEvent::Pointer event = AppExecFwk::InnerEvent::Get(0, 1);
252 cdmaSmsSender->StatusReportGetImsSms(event);
253 cdmaSmsSender->StatusReportAnalysis(event);
254 event = nullptr;
255 cdmaSmsSender->StatusReportSetImsSms(event);
256 cdmaSmsSender->StatusReportGetImsSms(event);
257 cdmaSmsSender->StatusReportAnalysis(event);
258 }
259
260 /**
261 * @tc.number Telephony_SmsMmsGtest_ShortMessage_0001
262 * @tc.name Test ShortMessage
263 * @tc.desc Function test
264 */
265 HWTEST_F(BranchSmsTest, ShortMessage_0001, Function | MediumTest | Level1)
266 {
267 auto shortMessage = std::make_shared<ShortMessage>();
268 std::vector<unsigned char> pdu;
269 std::string str = "3gpp";
270 Parcel parcel;
271 std::u16string specification = u" ";
272 ShortMessage ShortMessageObj;
273 EXPECT_TRUE(shortMessage->CreateMessage(pdu, specification, ShortMessageObj) != TELEPHONY_ERR_SUCCESS);
274 pdu.push_back(ShortMessage::SmsSimMessageStatus::SMS_SIM_MESSAGE_STATUS_READ);
275 EXPECT_GE(shortMessage->CreateIccMessage(pdu, str, 1).indexOnSim_, 0);
276 pdu.push_back(ShortMessage::SmsSimMessageStatus::SMS_SIM_MESSAGE_STATUS_FREE);
277 EXPECT_GE(shortMessage->CreateIccMessage(pdu, str, 1).indexOnSim_, 0);
278 pdu.clear();
279 pdu.push_back(ShortMessage::SmsSimMessageStatus::SMS_SIM_MESSAGE_STATUS_UNREAD);
280 pdu.push_back(ShortMessage::SmsSimMessageStatus::SMS_SIM_MESSAGE_STATUS_FREE);
281 EXPECT_GE(shortMessage->CreateIccMessage(pdu, str, 1).indexOnSim_, 0);
282 pdu.clear();
283 pdu.push_back(ShortMessage::SmsSimMessageStatus::SMS_SIM_MESSAGE_STATUS_SENT);
284 pdu.push_back(ShortMessage::SmsSimMessageStatus::SMS_SIM_MESSAGE_STATUS_FREE);
285 EXPECT_GE(shortMessage->CreateIccMessage(pdu, str, 1).indexOnSim_, 0);
286 pdu.clear();
287 pdu.push_back(ShortMessage::SmsSimMessageStatus::SMS_SIM_MESSAGE_STATUS_UNSENT);
288 pdu.push_back(ShortMessage::SmsSimMessageStatus::SMS_SIM_MESSAGE_STATUS_FREE);
289 EXPECT_GE(shortMessage->CreateIccMessage(pdu, str, 1).indexOnSim_, 0);
290 pdu.clear();
291 pdu.push_back(ShortMessage::SmsSimMessageStatus::SMS_SIM_MESSAGE_STATUS_FREE);
292 pdu.push_back(ShortMessage::SmsSimMessageStatus::SMS_SIM_MESSAGE_STATUS_UNSENT);
293 EXPECT_EQ(shortMessage->CreateIccMessage(pdu, str, 1).simMessageStatus_,
294 ShortMessage::SmsSimMessageStatus::SMS_SIM_MESSAGE_STATUS_FREE);
295 EXPECT_FALSE(shortMessage->ReadFromParcel(parcel));
296 }
297
298 /**
299 * @tc.number Telephony_SmsMmsGtest_ShortMessage_0002
300 * @tc.name Test ShortMessage
301 * @tc.desc Function test
302 */
303 HWTEST_F(BranchSmsTest, ShortMessage_0002, Function | MediumTest | Level1)
304 {
305 auto shortMessage = DelayedSingleton<ShortMessage>::GetInstance();
306 MessageParcel reply;
307 int32_t result = 0;
308 reply.WriteInt32(result);
309 shortMessage->UnMarshalling(reply);
310 shortMessage->GetVisibleMessageBody();
311 shortMessage->GetVisibleRawAddress();
312 shortMessage->GetMessageClass();
313 std::u16string smscAddress = u"13677884499";
314 shortMessage->GetScAddress(smscAddress);
315 shortMessage->GetScTimestamp();
316 shortMessage->IsReplaceMessage();
317 shortMessage->GetStatus();
318 shortMessage->IsSmsStatusReportMessage();
319 shortMessage->HasReplyPath();
320 shortMessage->GetIccMessageStatus();
321 shortMessage->GetProtocolId();
322 shortMessage->GetPdu();
323 std::vector<unsigned char> pdus;
324 unsigned char data = 255;
325 pdus.push_back(data);
326 std::u16string specification = u"";
327 ShortMessage messageObj;
328 shortMessage->CreateMessage(pdus, specification, messageObj);
329 shortMessage->GetIndexOnSim();
330 EXPECT_TRUE(shortMessage != nullptr);
331 }
332
333 /**
334 * @tc.number Telephony_SmsMmsGtest_GsmSmsMessage_0001
335 * @tc.name Test GsmSmsMessage
336 * @tc.desc Function test
337 */
338 HWTEST_F(BranchSmsTest, GsmSmsMessage_0001, Function | MediumTest | Level1)
339 {
340 auto gsmSmsMessage = std::make_shared<GsmSmsMessage>();
341 std::string dest = "";
342 std::string str = "";
343 std::string text = "";
344 std::string msgText = "";
345 unsigned char langId = 0;
346 std::string desAddr = "";
347 SmsTimeStamp times;
348 SmsConcat concat;
349 std::shared_ptr<struct SmsTpdu> tPdu = std::make_shared<struct SmsTpdu>();
350 gsmSmsMessage->ConvertMsgTimeStamp(times);
351 times.format = SmsTimeFormat::SMS_TIME_ABSOLUTE;
352 gsmSmsMessage->ConvertMsgTimeStamp(times);
353 EXPECT_EQ(gsmSmsMessage->SetHeaderLang(1, DataCodingScheme::DATA_CODING_UCS2, langId), 0);
354 EXPECT_EQ(gsmSmsMessage->SetHeaderConcat(1, concat), 0);
355 EXPECT_EQ(gsmSmsMessage->SetHeaderReply(1), 0);
356 EXPECT_TRUE(gsmSmsMessage->CreateDefaultSubmitSmsTpdu(dest, str, text, true, DataCodingScheme::DATA_CODING_7BIT) !=
357 nullptr);
358 EXPECT_NE(gsmSmsMessage->GetDestPort(), -1);
359 msgText = "123";
360 desAddr = "+SetSmsTpduDestAddress";
361 EXPECT_EQ(gsmSmsMessage->SetSmsTpduDestAddress(tPdu, desAddr), 22);
362 desAddr = "SetSmsTpduDestAddress";
363 EXPECT_EQ(gsmSmsMessage->SetSmsTpduDestAddress(tPdu, desAddr), 21);
364 tPdu = nullptr;
365 EXPECT_EQ(gsmSmsMessage->SetSmsTpduDestAddress(tPdu, desAddr), 0);
366 langId = 1;
367 EXPECT_EQ(gsmSmsMessage->SetHeaderLang(1, DataCodingScheme::DATA_CODING_7BIT, langId), 1);
368 EXPECT_EQ(gsmSmsMessage->SetHeaderConcat(1, concat), 1);
369 concat.is8Bits = true;
370 EXPECT_EQ(gsmSmsMessage->SetHeaderConcat(1, concat), 1);
371 gsmSmsMessage->replyAddress_ = "++SetSmsTpduDestAddress";
372 EXPECT_EQ(gsmSmsMessage->SetHeaderReply(1), 0);
373 EXPECT_TRUE(gsmSmsMessage->GetSubmitEncodeInfo(msgText, true) != nullptr);
374 msgText = "++";
375 EXPECT_TRUE(gsmSmsMessage->GetSubmitEncodeInfo(msgText, true) != nullptr);
376 }
377
378 /**
379 * @tc.number Telephony_SmsMmsGtest_GsmSmsMessage_0002
380 * @tc.name Test GsmSmsMessage
381 * @tc.desc Function test
382 */
383 HWTEST_F(BranchSmsTest, GsmSmsMessage_0002, Function | MediumTest | Level1)
384 {
385 auto gsmSmsMessage = std::make_shared<GsmSmsMessage>();
386 string pdu = "";
387 gsmSmsMessage->ConvertMessageDcs();
388 gsmSmsMessage->ConvertUserData();
389 EXPECT_TRUE(gsmSmsMessage->CreateMessage(pdu) == nullptr);
390 EXPECT_FALSE(gsmSmsMessage->PduAnalysis(pdu));
391 EXPECT_FALSE(gsmSmsMessage->PduAnalysis(pdu));
392 pdu = "123";
393 EXPECT_FALSE(gsmSmsMessage->PduAnalysis(pdu));
394 pdu = "123456";
395 EXPECT_FALSE(gsmSmsMessage->PduAnalysis(pdu));
396 EXPECT_TRUE(gsmSmsMessage->CreateDeliverReportSmsTpdu() != nullptr);
397 EXPECT_FALSE(gsmSmsMessage->PduAnalysis(pdu));
398 gsmSmsMessage->smsTpdu_ = nullptr;
399 gsmSmsMessage->smsTpdu_ = std::make_shared<struct SmsTpdu>();
400 gsmSmsMessage->ConvertMessageDcs();
401 gsmSmsMessage->smsTpdu_->tpduType = SmsTpduType::SMS_TPDU_DELIVER;
402 gsmSmsMessage->ConvertUserData();
403 gsmSmsMessage->ConvertMessageDcs();
404 gsmSmsMessage->smsTpdu_->tpduType = SmsTpduType::SMS_TPDU_SUBMIT;
405 gsmSmsMessage->ConvertUserData();
406 gsmSmsMessage->ConvertMessageDcs();
407 gsmSmsMessage->smsTpdu_->tpduType = SmsTpduType::SMS_TPDU_STATUS_REP;
408 gsmSmsMessage->ConvertUserData();
409 gsmSmsMessage->ConvertMessageDcs();
410 gsmSmsMessage->smsTpdu_->tpduType = SmsTpduType::SMS_TPDU_DELIVER_REP;
411 gsmSmsMessage->ConvertMessageDcs();
412 gsmSmsMessage->ConvertUserData();
413 EXPECT_TRUE(gsmSmsMessage->CreateDeliverSmsTpdu() != nullptr);
414 EXPECT_FALSE(gsmSmsMessage->PduAnalysis(pdu));
415 }
416
417 /**
418 * @tc.number Telephony_SmsMmsGtest_SmsSender_0001
419 * @tc.name Test SmsSender
420 * @tc.desc Function test
421 */
422 HWTEST_F(BranchSmsTest, SmsSender_0001, Function | MediumTest | Level1)
423 {
424 std::function<void(std::shared_ptr<SmsSendIndexer>)> fun = nullptr;
425 AppExecFwk::InnerEvent::Pointer event = AppExecFwk::InnerEvent::Get(RadioEvent::RADIO_SEND_SMS, 1);
426 std::shared_ptr<SmsSender> smsSender = std::make_shared<CdmaSmsSender>(INVALID_SLOTID, fun);
427 const sptr<ISendShortMessageCallback> sendCallback =
428 iface_cast<ISendShortMessageCallback>(new SendShortMessageCallbackStub());
429 const sptr<IDeliveryShortMessageCallback> deliveryCallback =
430 iface_cast<IDeliveryShortMessageCallback>(new DeliveryShortMessageCallbackStub());
431 const std::string desAddr = "qwe";
432 const std::string scAddr = "123";
433 const std::string text = "123";
434 auto smsIndexer = std::make_shared<SmsSendIndexer>(desAddr, scAddr, text, sendCallback, deliveryCallback);
435 smsSender->HandleMessageResponse(smsIndexer);
436 smsIndexer->isFailure_ = true;
437 smsSender->HandleMessageResponse(smsIndexer);
438 smsSender->SyncSwitchISmsResponse();
439 smsSender->ProcessEvent(event);
440 event = AppExecFwk::InnerEvent::Get(RadioEvent::RADIO_SEND_CDMA_SMS, 1);
441 smsSender->ProcessEvent(event);
442 event = AppExecFwk::InnerEvent::Get(RadioEvent::RADIO_SEND_IMS_GSM_SMS, 1);
443 smsSender->ProcessEvent(event);
444 event = AppExecFwk::InnerEvent::Get(RadioEvent::RADIO_SEND_SMS_EXPECT_MORE, 1);
445 smsSender->ProcessEvent(event);
446 event = AppExecFwk::InnerEvent::Get(MSG_SMS_RETRY_DELIVERY, 1);
447 smsSender->ProcessEvent(event);
448 event = AppExecFwk::InnerEvent::Get(RadioEvent::RADIO_SMS_STATUS, 1);
449 smsSender->ProcessEvent(event);
450 event = AppExecFwk::InnerEvent::Get(RadioEvent::RADIO_GET_IMS_SMS, 1);
451 smsSender->ProcessEvent(event);
452 event = AppExecFwk::InnerEvent::Get(RadioEvent::RADIO_DIAL, 1);
453 smsSender->ProcessEvent(event);
454 event->GetSharedObject<RadioResponseInfo>() = std::make_shared<RadioResponseInfo>();
455 smsSender->HandleResend(smsIndexer);
456 smsIndexer->errorCode_ = static_cast<int32_t>(ErrType::ERR_CMD_SEND_FAILURE);
457 smsSender->HandleResend(smsIndexer);
458 smsIndexer->errorCode_ = static_cast<int32_t>(ErrType::ERR_GENERIC_FAILURE);
459 smsSender->HandleResend(smsIndexer);
460 smsSender->lastSmsDomain_ = 1;
461 smsSender->HandleResend(smsIndexer);
462 EXPECT_FALSE(smsSender->SendCacheMapAddItem(1, smsIndexer));
463 event = nullptr;
464 smsIndexer = nullptr;
465 smsSender->HandleResend(smsIndexer);
466 smsSender->ProcessEvent(event);
467 smsSender->HandleMessageResponse(smsIndexer);
468 smsSender->SetNetworkState(true, 1);
469 EXPECT_TRUE(smsSender->FindCacheMapAndTransform(event) == nullptr);
470 }
471
472 /**
473 * @tc.number Telephony_SmsMmsGtest_SmsSender_0002
474 * @tc.name Test SmsSender
475 * @tc.desc Function test
476 */
477 HWTEST_F(BranchSmsTest, SmsSender_0002, Function | MediumTest | Level1)
478 {
479 std::function<void(std::shared_ptr<SmsSendIndexer>)> fun = nullptr;
480 std::shared_ptr<SmsSender> smsSender = std::make_shared<CdmaSmsSender>(INVALID_SLOTID, fun);
481 const sptr<ISendShortMessageCallback> sendCallback =
482 iface_cast<ISendShortMessageCallback>(new SendShortMessageCallbackStub());
483 const sptr<IDeliveryShortMessageCallback> deliveryCallback =
484 iface_cast<IDeliveryShortMessageCallback>(new DeliveryShortMessageCallbackStub());
485 const std::string desAddr = "qwe";
486 const std::string scAddr = "123";
487 const std::string text = "123";
488 auto smsIndexer = std::make_shared<SmsSendIndexer>(desAddr, scAddr, text, sendCallback, deliveryCallback);
489 smsIndexer->unSentCellCount_ = 1;
490 smsSender->SendMessageSucceed(smsIndexer);
491 smsIndexer->unSentCellCount_ = 1;
492 smsIndexer->hasCellFailed_ = std::make_shared<bool>(true);
493 smsSender->SendMessageSucceed(smsIndexer);
494 smsIndexer->unSentCellCount_ = 1;
495 smsSender->SendMessageFailed(smsIndexer);
496 smsIndexer->unSentCellCount_ = 0;
497 smsSender->SendMessageFailed(smsIndexer);
498 smsSender->SendResultCallBack(smsIndexer, ISendShortMessageCallback::SEND_SMS_FAILURE_UNKNOWN);
499 smsSender->SendResultCallBack(sendCallback, ISendShortMessageCallback::SEND_SMS_FAILURE_UNKNOWN);
500 smsIndexer = nullptr;
501 smsSender->SendMessageSucceed(smsIndexer);
502 smsSender->SendMessageFailed(smsIndexer);
503 EXPECT_FALSE(smsSender->SendCacheMapAddItem(1, smsIndexer));
504 }
505
506 /**
507 * @tc.number Telephony_SmsMmsGtest_SmsSender_0003
508 * @tc.name Test SmsSender
509 * @tc.desc Function test
510 */
511 HWTEST_F(BranchSmsTest, SmsSender_0003, Function | MediumTest | Level1)
512 {
513 std::function<void(std::shared_ptr<SmsSendIndexer>)> fun = nullptr;
514 std::shared_ptr<SmsSender> smsSender = std::make_shared<CdmaSmsSender>(INVALID_SLOTID, fun);
515 const sptr<ISendShortMessageCallback> sendCallback =
516 iface_cast<ISendShortMessageCallback>(new SendShortMessageCallbackStub());
517 const sptr<IDeliveryShortMessageCallback> deliveryCallback =
518 iface_cast<IDeliveryShortMessageCallback>(new DeliveryShortMessageCallbackStub());
519 const std::string desAddr = "qwe";
520 const std::string scAddr = "123";
521 const std::string text = "123";
522 auto smsIndexer = std::make_shared<SmsSendIndexer>(desAddr, scAddr, text, sendCallback, deliveryCallback);
523 EXPECT_FALSE(smsSender->SendCacheMapAddItem(1, smsIndexer));
524 smsIndexer->isFailure_ = true;
525 smsSender->OnRilAdapterHostDied();
526 smsIndexer->isFailure_ = false;
527 smsIndexer->msgRefId64Bit_ = 0;
528 smsSender->OnRilAdapterHostDied();
529 EXPECT_GE(smsIndexer->msgRefId64Bit_, 0);
530 }
531
532 /**
533 * @tc.number Telephony_SmsMmsGtest_SmsSendManager_0001
534 * @tc.name Test SmsSendManager
535 * @tc.desc Function test
536 */
537 HWTEST_F(BranchSmsTest, SmsSendManager_0001, Function | MediumTest | Level1)
538 {
539 auto smsSendManager = std::make_shared<SmsSendManager>(INVALID_SLOTID);
540 auto smsNetworkPolicyManager = std::make_shared<SmsNetworkPolicyManager>(INVALID_SLOTID);
541 std::function<void(std::shared_ptr<SmsSendIndexer>)> fun = nullptr;
542 auto cdmaSmsSender = std::make_shared<CdmaSmsSender>(INVALID_SLOTID, fun);
543 auto gsmSmsSender = std::make_shared<GsmSmsSender>(INVALID_SLOTID, fun);
544 std::string desAddr = "";
545 std::string scAddr = "123";
546 std::string text = "";
547 std::u16string format = u"";
548 uint8_t *data = nullptr;
549 const sptr<ISendShortMessageCallback> sendCallback =
550 iface_cast<ISendShortMessageCallback>(new SendShortMessageCallbackStub());
551 const sptr<IDeliveryShortMessageCallback> deliveryCallback =
552 iface_cast<IDeliveryShortMessageCallback>(new DeliveryShortMessageCallbackStub());
553 auto smsIndexer = std::make_shared<SmsSendIndexer>(desAddr, scAddr, text, sendCallback, deliveryCallback);
554 smsSendManager->TextBasedSmsDelivery(desAddr, scAddr, text, sendCallback, deliveryCallback);
555 smsSendManager->DataBasedSmsDelivery(desAddr, scAddr, 1, data, 1, sendCallback, deliveryCallback);
556 desAddr = "qwe";
557 smsSendManager->DataBasedSmsDelivery(desAddr, scAddr, 1, data, 1, sendCallback, deliveryCallback);
558 smsSendManager->TextBasedSmsDelivery(desAddr, scAddr, text, sendCallback, deliveryCallback);
559 text = "123";
560 data = new uint8_t(1);
561 smsSendManager->DataBasedSmsDelivery(desAddr, scAddr, 1, data, 1, sendCallback, deliveryCallback);
562 smsSendManager->TextBasedSmsDelivery(desAddr, scAddr, text, sendCallback, deliveryCallback);
563 smsSendManager->networkManager_ = smsNetworkPolicyManager;
564 smsSendManager->DataBasedSmsDelivery(desAddr, scAddr, 1, data, 1, sendCallback, deliveryCallback);
565 smsSendManager->TextBasedSmsDelivery(desAddr, scAddr, text, sendCallback, deliveryCallback);
566 smsSendManager->RetriedSmsDelivery(smsIndexer);
567 smsSendManager->gsmSmsSender_ = gsmSmsSender;
568 smsSendManager->DataBasedSmsDelivery(desAddr, scAddr, 1, data, 1, sendCallback, deliveryCallback);
569 smsSendManager->TextBasedSmsDelivery(desAddr, scAddr, text, sendCallback, deliveryCallback);
570 smsSendManager->RetriedSmsDelivery(smsIndexer);
571 smsSendManager->cdmaSmsSender_ = cdmaSmsSender;
572 smsSendManager->networkManager_->netWorkType_ = NetWorkType::NET_TYPE_GSM;
573 smsSendManager->DataBasedSmsDelivery(desAddr, scAddr, 1, data, 1, sendCallback, deliveryCallback);
574 smsSendManager->TextBasedSmsDelivery(desAddr, scAddr, text, sendCallback, deliveryCallback);
575 EXPECT_EQ(smsSendManager->GetImsShortMessageFormat(format), TELEPHONY_ERR_SUCCESS);
576 smsSendManager->networkManager_->netWorkType_ = NetWorkType::NET_TYPE_CDMA;
577 smsSendManager->DataBasedSmsDelivery(desAddr, scAddr, 1, data, 1, sendCallback, deliveryCallback);
578 smsSendManager->TextBasedSmsDelivery(desAddr, scAddr, text, sendCallback, deliveryCallback);
579 EXPECT_EQ(smsSendManager->GetImsShortMessageFormat(format), TELEPHONY_ERR_SUCCESS);
580 smsSendManager->networkManager_->netWorkType_ = NetWorkType::NET_TYPE_UNKNOWN;
581 smsSendManager->DataBasedSmsDelivery(desAddr, scAddr, 1, data, 1, sendCallback, deliveryCallback);
582 smsSendManager->TextBasedSmsDelivery(desAddr, scAddr, text, sendCallback, deliveryCallback);
583 smsIndexer = nullptr;
584 smsSendManager->RetriedSmsDelivery(smsIndexer);
585 EXPECT_EQ(smsSendManager->GetImsShortMessageFormat(format), TELEPHONY_ERR_SUCCESS);
586 }
587
588 /**
589 * @tc.number Telephony_SmsMmsGtest_SmsSendManager_0002
590 * @tc.name Test SmsSendManager
591 * @tc.desc Function test
592 */
593 HWTEST_F(BranchSmsTest, SmsSendManager_0002, Function | MediumTest | Level1)
594 {
595 auto smsSendManager = std::make_shared<SmsSendManager>(INVALID_SLOTID);
596 std::function<void(std::shared_ptr<SmsSendIndexer>)> fun = nullptr;
597 std::string scAddr = "123";
598 bool isSupported = true;
599 std::vector<std::u16string> splitMessage;
600 LengthInfo lenInfo;
601 const sptr<ISendShortMessageCallback> sendCallback =
602 iface_cast<ISendShortMessageCallback>(new SendShortMessageCallbackStub());
603 const sptr<IDeliveryShortMessageCallback> deliveryCallback =
604 iface_cast<IDeliveryShortMessageCallback>(new DeliveryShortMessageCallbackStub());
605 auto smsIndexer = std::make_shared<SmsSendIndexer>("", scAddr, "", sendCallback, deliveryCallback);
606 EXPECT_GT(smsSendManager->SplitMessage(scAddr, splitMessage), TELEPHONY_ERR_SUCCESS);
607 EXPECT_GT(smsSendManager->GetSmsSegmentsInfo(scAddr, true, lenInfo), TELEPHONY_ERR_SUCCESS);
608 EXPECT_GT(smsSendManager->IsImsSmsSupported(INVALID_SLOTID, isSupported), TELEPHONY_ERR_SUCCESS);
609 EXPECT_FALSE(smsSendManager->SetImsSmsConfig(INVALID_SLOTID, 1));
610 smsSendManager->networkManager_ = std::make_shared<SmsNetworkPolicyManager>(INVALID_SLOTID);
611 EXPECT_FALSE(smsSendManager->SetImsSmsConfig(INVALID_SLOTID, 1));
612 EXPECT_GT(smsSendManager->IsImsSmsSupported(INVALID_SLOTID, isSupported), TELEPHONY_ERR_SUCCESS);
613 smsSendManager->gsmSmsSender_ = std::make_shared<CdmaSmsSender>(INVALID_SLOTID, fun);
614 EXPECT_FALSE(smsSendManager->SetImsSmsConfig(INVALID_SLOTID, 1));
615 EXPECT_GT(smsSendManager->IsImsSmsSupported(INVALID_SLOTID, isSupported), TELEPHONY_ERR_SUCCESS);
616 smsSendManager->cdmaSmsSender_ = std::make_shared<GsmSmsSender>(INVALID_SLOTID, fun);
617 smsSendManager->RetriedSmsDelivery(smsIndexer);
618 smsIndexer->netWorkType_ = NetWorkType::NET_TYPE_CDMA;
619 smsSendManager->networkManager_->netWorkType_ = NetWorkType::NET_TYPE_UNKNOWN;
620 smsSendManager->RetriedSmsDelivery(smsIndexer);
621 smsIndexer->netWorkType_ = NetWorkType::NET_TYPE_UNKNOWN;
622 EXPECT_FALSE(smsSendManager->SetImsSmsConfig(INVALID_SLOTID, 1));
623 EXPECT_GT(smsSendManager->IsImsSmsSupported(INVALID_SLOTID, isSupported), TELEPHONY_ERR_SUCCESS);
624 EXPECT_GT(smsSendManager->GetSmsSegmentsInfo(scAddr, true, lenInfo), TELEPHONY_ERR_SUCCESS);
625 EXPECT_EQ(smsSendManager->SplitMessage(scAddr, splitMessage), TELEPHONY_ERR_SUCCESS);
626 smsSendManager->RetriedSmsDelivery(smsIndexer);
627 smsSendManager->networkManager_->netWorkType_ = NetWorkType::NET_TYPE_GSM;
628 smsIndexer->netWorkType_ = NetWorkType::NET_TYPE_GSM;
629 EXPECT_TRUE(smsSendManager->SetImsSmsConfig(INVALID_SLOTID, 1));
630 EXPECT_EQ(smsSendManager->IsImsSmsSupported(INVALID_SLOTID, isSupported), TELEPHONY_ERR_SUCCESS);
631 EXPECT_EQ(smsSendManager->SplitMessage(scAddr, splitMessage), TELEPHONY_ERR_SUCCESS);
632 EXPECT_EQ(smsSendManager->GetSmsSegmentsInfo(scAddr, true, lenInfo), TELEPHONY_ERR_SUCCESS);
633 smsSendManager->RetriedSmsDelivery(smsIndexer);
634 smsSendManager->networkManager_->netWorkType_ = NetWorkType::NET_TYPE_CDMA;
635 smsIndexer->netWorkType_ = NetWorkType::NET_TYPE_CDMA;
636 smsSendManager->RetriedSmsDelivery(smsIndexer);
637 EXPECT_TRUE(smsSendManager->SetImsSmsConfig(INVALID_SLOTID, 1));
638 EXPECT_EQ(smsSendManager->IsImsSmsSupported(INVALID_SLOTID, isSupported), TELEPHONY_ERR_SUCCESS);
639 EXPECT_EQ(smsSendManager->SplitMessage(scAddr, splitMessage), TELEPHONY_ERR_SUCCESS);
640 EXPECT_EQ(smsSendManager->GetSmsSegmentsInfo(scAddr, true, lenInfo), TELEPHONY_ERR_SUCCESS);
641 }
642
643 /**
644 * @tc.number Telephony_SmsMmsGtest_SmsInterfaceManager_0001
645 * @tc.name Test SmsInterfaceManager
646 * @tc.desc Function test
647 */
648 HWTEST_F(BranchSmsTest, SmsInterfaceManager_0001, Function | MediumTest | Level1)
649 {
650 auto smsSendManager = std::make_shared<SmsSendManager>(INVALID_SLOTID);
651 std::function<void(std::shared_ptr<SmsSendIndexer>)> fun = nullptr;
652 std::string scAddr = "123";
653 const sptr<ISendShortMessageCallback> sendCallback =
654 iface_cast<ISendShortMessageCallback>(new SendShortMessageCallbackStub());
655 const sptr<IDeliveryShortMessageCallback> deliveryCallback =
656 iface_cast<IDeliveryShortMessageCallback>(new DeliveryShortMessageCallbackStub());
657 auto smsIndexer = std::make_shared<SmsSendIndexer>("", scAddr, "", sendCallback, deliveryCallback);
658
659 auto smsInterfaceManager = std::make_shared<SmsInterfaceManager>(INVALID_SLOTID);
660 EXPECT_EQ(smsInterfaceManager->OnRilAdapterHostDied(), TELEPHONY_ERR_LOCAL_PTR_NULL);
661
662 smsSendManager->gsmSmsSender_ = std::make_shared<GsmSmsSender>(INVALID_SLOTID, fun);
663 smsSendManager->cdmaSmsSender_ = std::make_shared<CdmaSmsSender>(INVALID_SLOTID, fun);
664 smsInterfaceManager->InitInterfaceManager();
665 EXPECT_EQ(smsInterfaceManager->OnRilAdapterHostDied(), TELEPHONY_ERR_SUCCESS);
666 }
667
668 /**
669 * @tc.number Telephony_SmsMmsGtest_GsmSmsParamCodec_0001
670 * @tc.name Test GsmSmsParamCodec
671 * @tc.desc Function test
672 */
673 HWTEST_F(BranchSmsTest, GsmSmsParamCodec_0001, Function | MediumTest | Level1)
674 {
675 auto gsmSmsParamCodec = std::make_shared<GsmSmsParamCodec>();
676 AddressNumber *pAddress = new AddressNumber();
677 SmsTimeStamp *pTimeStamp = new SmsTimeStamp();
678 pTimeStamp->format = SmsTimeFormat::SMS_TIME_ABSOLUTE;
679 pTimeStamp->time.absolute.timeZone = -1;
680 std::string paramStr;
681 EXPECT_GT(gsmSmsParamCodec->EncodeAddressPdu(pAddress, paramStr), 0);
682 pAddress->address[0] = '+';
683 paramStr.clear();
684 EXPECT_GT(gsmSmsParamCodec->EncodeAddressPdu(pAddress, paramStr), 0);
685 paramStr.clear();
686 EXPECT_EQ(gsmSmsParamCodec->EncodeAddressPdu(nullptr, paramStr), 0);
687
688 paramStr.clear();
689 gsmSmsParamCodec->EncodeTimePdu(nullptr, paramStr);
690 uint8_t value = 0;
691 EXPECT_GE(paramStr.size(), value);
692 paramStr.clear();
693 gsmSmsParamCodec->EncodeTimePdu(pTimeStamp, paramStr);
694 EXPECT_GT(paramStr.size(), value);
695 pTimeStamp->format = SmsTimeFormat::SMS_TIME_RELATIVE;
696 paramStr.clear();
697 uint8_t result = 1;
698 gsmSmsParamCodec->EncodeTimePdu(pTimeStamp, paramStr);
699 EXPECT_GE(paramStr.size(), result);
700
701 SmsDcs *pDCS = new SmsDcs();
702 paramStr.clear();
703 gsmSmsParamCodec->EncodeDCS(nullptr, paramStr);
704 EXPECT_EQ(paramStr.size(), value);
705 pDCS->codingGroup = PduSchemeGroup::CODING_DELETION_GROUP;
706 paramStr.clear();
707 gsmSmsParamCodec->EncodeDCS(pDCS, paramStr);
708 EXPECT_GE(paramStr.size(), value);
709
710 pDCS->codingGroup = PduSchemeGroup::CODING_DISCARD_GROUP;
711 paramStr.clear();
712 gsmSmsParamCodec->EncodeDCS(pDCS, paramStr);
713 EXPECT_GE(paramStr.size(), value);
714
715 pDCS->codingGroup = PduSchemeGroup::CODING_STORE_GROUP;
716 paramStr.clear();
717 gsmSmsParamCodec->EncodeDCS(pDCS, paramStr);
718 EXPECT_GE(paramStr.size(), value);
719 }
720
721 /**
722 * @tc.number Telephony_SmsMmsGtest_GsmSmsParamCodec_0002
723 * @tc.name Test GsmSmsParamCodec
724 * @tc.desc Function test
725 */
726 HWTEST_F(BranchSmsTest, GsmSmsParamCodec_0002, Function | MediumTest | Level1)
727 {
728 auto gsmSmsParamCodec = std::make_shared<GsmSmsParamCodec>();
729 std::string paramStr;
730 SmsDcs *pDCS = new SmsDcs();
731 pDCS->codingGroup = PduSchemeGroup::CODING_GENERAL_GROUP;
732 pDCS->msgClass = SmsMessageClass::SMS_FORWARD_MESSAGE;
733 pDCS->bCompressed = true;
734 gsmSmsParamCodec->EncodeDCS(pDCS, paramStr);
735 uint8_t result = 0;
736 EXPECT_GE(paramStr.size(), result);
737
738 pDCS->codingGroup = PduSchemeGroup::SMS_CLASS_GROUP;
739 paramStr.clear();
740 gsmSmsParamCodec->EncodeDCS(pDCS, paramStr);
741 EXPECT_GE(paramStr.size(), result);
742
743 pDCS->codingScheme = DataCodingScheme::DATA_CODING_7BIT;
744 paramStr.clear();
745 gsmSmsParamCodec->EncodeDCS(pDCS, paramStr);
746 EXPECT_GE(paramStr.size(), result);
747
748 pDCS->codingScheme = DataCodingScheme::DATA_CODING_UCS2;
749 paramStr.clear();
750 gsmSmsParamCodec->EncodeDCS(pDCS, paramStr);
751 EXPECT_GE(paramStr.size(), result);
752
753 pDCS->codingScheme = DataCodingScheme::DATA_CODING_8BIT;
754 paramStr.clear();
755 gsmSmsParamCodec->EncodeDCS(pDCS, paramStr);
756 EXPECT_GE(paramStr.size(), result);
757
758 pDCS->codingScheme = DataCodingScheme::DATA_CODING_EUCKR;
759 paramStr.clear();
760 gsmSmsParamCodec->EncodeDCS(pDCS, paramStr);
761
762 EXPECT_GE(paramStr.size(), result);
763 paramStr.clear();
764 pDCS->codingGroup = PduSchemeGroup::CODING_UNKNOWN_GROUP;
765 gsmSmsParamCodec->EncodeDCS(pDCS, paramStr);
766 uint8_t value = 0;
767 EXPECT_EQ(paramStr.size(), value);
768
769 unsigned char encodeData[BUF_SIZE];
770 char addressData[BUF_SIZE];
771 char *address = addressData;
772 unsigned char *pEncodeAddr = encodeData;
773 EXPECT_EQ(gsmSmsParamCodec->EncodeSmscPdu(nullptr, nullptr), 0);
774 EXPECT_EQ(gsmSmsParamCodec->EncodeSmscPdu(address, nullptr), 0);
775 EXPECT_EQ(gsmSmsParamCodec->EncodeSmscPdu(address, pEncodeAddr), 0);
776 }
777
778 /**
779 * @tc.number Telephony_SmsMmsGtest_GsmSmsParamCodec_0003
780 * @tc.name Test GsmSmsParamCodec
781 * @tc.desc Function test
782 */
783 HWTEST_F(BranchSmsTest, GsmSmsParamCodec_0003, Function | MediumTest | Level1)
784 {
785 auto gsmSmsParamCodec = std::make_shared<GsmSmsParamCodec>();
786 AddressNumber *pAddress = new AddressNumber();
787 SmsDcs *pDCS = new SmsDcs();
788 unsigned char encodeData[BUF_SIZE] = { 0 };
789 unsigned char *pSMSC = encodeData;
790 std::string decodeAddr;
791 gsmSmsParamCodec->DecodeSmscPdu(pSMSC, 0, TypeOfNum::TYPE_UNKNOWN, decodeAddr);
792 gsmSmsParamCodec->DecodeSmscPdu(nullptr, 1, TypeOfNum::TYPE_UNKNOWN, decodeAddr);
793 gsmSmsParamCodec->DecodeSmscPdu(pSMSC, 1, TypeOfNum::TYPE_UNKNOWN, decodeAddr);
794 gsmSmsParamCodec->DecodeSmscPdu(pSMSC, 1, TypeOfNum::TYPE_INTERNATIONAL, decodeAddr);
795 gsmSmsParamCodec->DecodeSmscPdu(pSMSC, 1, TypeOfNum::TYPE_INTERNATIONAL, decodeAddr);
796
797 auto decodeBuffer = std::make_shared<SmsReadBuffer>("00");
798 EXPECT_EQ(gsmSmsParamCodec->EncodeSmscPdu(nullptr, pSMSC, 0), 0);
799 EXPECT_EQ(gsmSmsParamCodec->EncodeSmscPdu(pAddress, nullptr, 0), 0);
800 EXPECT_EQ(gsmSmsParamCodec->EncodeSmscPdu(pAddress, pSMSC, 0), 0);
801 EXPECT_EQ(gsmSmsParamCodec->DecodeAddressPdu(*decodeBuffer, nullptr), 0);
802 EXPECT_EQ(gsmSmsParamCodec->DecodeAddressPdu(*decodeBuffer, pAddress), 0);
803 EXPECT_EQ(gsmSmsParamCodec->DecodeTimePdu(*decodeBuffer, nullptr), 0);
804 EXPECT_EQ(gsmSmsParamCodec->DecodeDcsPdu(*decodeBuffer, pDCS), 1);
805 EXPECT_EQ(gsmSmsParamCodec->DecodeDcsPdu(*decodeBuffer, nullptr), 0);
806 AddressNumber smsAddress;
807 EXPECT_EQ(gsmSmsParamCodec->DecodeSmscPdu(nullptr, 1, smsAddress), 0);
808 EXPECT_GE(gsmSmsParamCodec->DecodeSmscPdu(pSMSC, 1, smsAddress), 0);
809 EXPECT_EQ(gsmSmsParamCodec->CheckVoicemail(*decodeBuffer, nullptr, nullptr), 0);
810 }
811
812 /**
813 * @tc.number Telephony_SmsMmsGtest_GsmSmsParamCodec_0004
814 * @tc.name Test GsmSmsParamCodec
815 * @tc.desc Function test
816 */
817 HWTEST_F(BranchSmsTest, GsmSmsParamCodec_0004, Function | MediumTest | Level1) {
818 auto gsmSmsParamCodec = std::make_shared<GsmSmsParamCodec>();
819 AddressNumber *pAddress = new AddressNumber();
820 std::string pdu = StringUtils::HexToString("16D131D98C56B3DD7039584C36A3D56C375C0E169301"); // D1, ton = 5
821 auto decodeBuffer = std::make_shared<SmsReadBuffer>(pdu);
822 EXPECT_TRUE(gsmSmsParamCodec->DecodeAddressPdu(*decodeBuffer, pAddress));
823 }
824
825 /**
826 * @tc.number Telephony_SmsMmsGtest_GsmSmsParamCodec_0005
827 * @tc.name Test GsmSmsParamCodec
828 * @tc.desc Function test
829 */
830 HWTEST_F(BranchSmsTest, GsmSmsParamCodec_0005, Function | MediumTest | Level1) {
831 auto gsmSmsParamCodec = std::make_shared<GsmSmsParamCodec>();
832 AddressNumber *pAddress = new AddressNumber();
833 std::string pdu = StringUtils::HexToString("16D131D98C56B3DD7039584A01"); // D1, ton = 5
834 auto decodeBuffer = std::make_shared<SmsReadBuffer>(pdu);
835 EXPECT_TRUE(gsmSmsParamCodec->DecodeAddressPdu(*decodeBuffer, pAddress));
836 }
837
838 /**
839 * @tc.number Telephony_SmsMmsGtest_GsmSmsParamCodec_0006
840 * @tc.name Test GsmSmsParamCodec
841 * @tc.desc Function test
842 */
843 HWTEST_F(BranchSmsTest, GsmSmsParamCodec_0006, Function | MediumTest | Level1) {
844 auto gsmSmsParamCodec = std::make_shared<GsmSmsParamCodec>();
845 AddressNumber *pAddress = new AddressNumber();
846 std::string pdu = StringUtils::HexToString("0ED0A3F19CDD7A52A1"); // D0, ton = 5
847 auto decodeBuffer = std::make_shared<SmsReadBuffer>(pdu);
848 EXPECT_TRUE(gsmSmsParamCodec->DecodeAddressPdu(*decodeBuffer, pAddress));
849 }
850
851 /**
852 * @tc.number Telephony_SmsMmsGtest_GsmSmsUDataCodec_0001
853 * @tc.name Test GsmUserDataPdu
854 * @tc.desc Function test
855 */
856 HWTEST_F(BranchSmsTest, GsmSmsUDataCodec_0001, Function | MediumTest | Level1)
857 {
858 auto udPdu = std::make_shared<GsmUserDataPdu>();
859 SmsUDPackage smsUserData;
860 SmsTpud *pTPUD = new SmsTpud();
861 const struct SmsUDPackage *pUserData = &(smsUserData);
862 auto encodeBuffer = std::make_shared<SmsWriteBuffer>();
863 auto decodeBuffer = std::make_shared<SmsReadBuffer>("00");
864 std::string str;
865 EXPECT_GT(udPdu->EncodeUserDataPdu(*encodeBuffer, pUserData, DataCodingScheme::DATA_CODING_7BIT, str), 0);
866 EXPECT_GT(udPdu->EncodeUserDataPdu(*encodeBuffer, pUserData, DataCodingScheme::DATA_CODING_8BIT, str), 0);
867 EXPECT_GT(udPdu->EncodeUserDataPdu(*encodeBuffer, pUserData, DataCodingScheme::DATA_CODING_UCS2, str), 0);
868 EXPECT_EQ(udPdu->EncodeUserDataPdu(*encodeBuffer, pUserData, DataCodingScheme::DATA_CODING_ASCII7BIT, str), 0);
869 SmsUDPackage *userData = new SmsUDPackage();
870 EXPECT_GE(udPdu->DecodeUserDataPdu(*decodeBuffer, true, DataCodingScheme::DATA_CODING_7BIT, userData, pTPUD), 0);
871 EXPECT_GE(udPdu->DecodeUserDataPdu(*decodeBuffer, true, DataCodingScheme::DATA_CODING_8BIT, userData, pTPUD), 0);
872 EXPECT_GE(udPdu->DecodeUserDataPdu(*decodeBuffer, true, DataCodingScheme::DATA_CODING_UCS2, userData, pTPUD), 0);
873 EXPECT_EQ(
874 udPdu->DecodeUserDataPdu(*decodeBuffer, true, DataCodingScheme::DATA_CODING_ASCII7BIT, userData, pTPUD), 0);
875 EXPECT_GE(udPdu->DecodeUserDataPdu(*decodeBuffer, true, DataCodingScheme::DATA_CODING_7BIT, userData), 0);
876 EXPECT_GE(udPdu->DecodeUserDataPdu(*decodeBuffer, true, DataCodingScheme::DATA_CODING_8BIT, userData), 0);
877 EXPECT_GE(udPdu->DecodeUserDataPdu(*decodeBuffer, true, DataCodingScheme::DATA_CODING_UCS2, userData), 0);
878 EXPECT_EQ(udPdu->DecodeUserDataPdu(*decodeBuffer, true, DataCodingScheme::DATA_CODING_ASCII7BIT, userData), 0);
879
880 auto encode = std::make_shared<GsmUserDataEncode>(udPdu);
881 auto decode = std::make_shared<GsmUserDataDecode>(udPdu);
882 EXPECT_TRUE(encode->Encode8bitPdu(*encodeBuffer, userData, str));
883 EXPECT_TRUE(encode->EncodeUcs2Pdu(*encodeBuffer, userData));
884 userData->headerCnt = 1;
885 userData->length = BUFFER_SIZE;
886 EXPECT_EQ(encode->Encode8bitPdu(*encodeBuffer, userData, str), 0);
887 EXPECT_EQ(encode->EncodeUcs2Pdu(*encodeBuffer, userData), 0);
888 EXPECT_EQ(decode->DecodeGsmPdu(*decodeBuffer, true, userData, pTPUD), 0);
889 EXPECT_FALSE(decode->DecodeGsmPdu(*decodeBuffer, false, userData, pTPUD));
890 EXPECT_FALSE(decode->Decode8bitPdu(*decodeBuffer, true, userData, pTPUD));
891 EXPECT_FALSE(decode->DecodeGsmPdu(*decodeBuffer, false, userData, pTPUD));
892 EXPECT_FALSE(decode->DecodeUcs2Pdu(*decodeBuffer, true, userData, pTPUD));
893 EXPECT_FALSE(decode->DecodeGsmPdu(*decodeBuffer, false, userData, pTPUD));
894 decode->userData_ = nullptr;
895 EXPECT_FALSE(decode->Decode8bitPduPartData(*decodeBuffer, false, userData, pTPUD, 0, 0));
896 EXPECT_FALSE(decode->Decode8bitPduPartData(*decodeBuffer, false, userData, pTPUD, 1, 1));
897 }
898
899 /**
900 * @tc.number Telephony_SmsMmsGtest_GsmSmsUDataCodec_0002
901 * @tc.name Test GsmUserDataPdu
902 * @tc.desc Function test
903 */
904 HWTEST_F(BranchSmsTest, GsmSmsUDataCodec_0002, Function | MediumTest | Level1)
905 {
906 auto gsmUserDataPdu = std::make_shared<GsmUserDataPdu>();
907 SmsUDH header;
908 header.udhType = UDH_CONCAT_8BIT;
909 auto encodeBuffer = std::make_shared<SmsWriteBuffer>();
910 encodeBuffer->data_[0] = 1;
911 gsmUserDataPdu->EncodeHeaderConcat(*encodeBuffer, header);
912 gsmUserDataPdu->EncodeHeader(*encodeBuffer, header);
913 header.udhType = UDH_CONCAT_16BIT;
914 gsmUserDataPdu->EncodeHeaderConcat(*encodeBuffer, header);
915 gsmUserDataPdu->EncodeHeader(*encodeBuffer, header);
916 header.udhType = UDH_APP_PORT_8BIT;
917 gsmUserDataPdu->EncodeHeader(*encodeBuffer, header);
918 header.udhType = UDH_APP_PORT_16BIT;
919 gsmUserDataPdu->EncodeHeader(*encodeBuffer, header);
920 header.udhType = UDH_ALTERNATE_REPLY_ADDRESS;
921 gsmUserDataPdu->EncodeHeader(*encodeBuffer, header);
922 header.udhType = UDH_SINGLE_SHIFT;
923 gsmUserDataPdu->EncodeHeader(*encodeBuffer, header);
924 header.udhType = UDH_LOCKING_SHIFT;
925 gsmUserDataPdu->EncodeHeader(*encodeBuffer, header);
926 header.udhType = UDH_NONE;
927 gsmUserDataPdu->EncodeHeaderConcat(*encodeBuffer, header);
928 gsmUserDataPdu->EncodeHeader(*encodeBuffer, header);
929 header.udhType = UDH_EMS_LAST;
930 gsmUserDataPdu->EncodeHeaderConcat(*encodeBuffer, header);
931 gsmUserDataPdu->EncodeHeader(*encodeBuffer, header);
932 SmsUDH *pHeader = new SmsUDH();
933
934 pHeader->udhType = UserDataHeadType::UDH_CONCAT_8BIT;
935 uint16_t headerLen = 0;
936 auto decodeBuffer = std::make_shared<SmsReadBuffer>("00");
937 decodeBuffer->data_[0] = 1;
938 EXPECT_EQ(gsmUserDataPdu->DecodeHeader(*decodeBuffer, *pHeader, headerLen), 0);
939 pHeader->udhType = UserDataHeadType::UDH_CONCAT_16BIT;
940 EXPECT_EQ(gsmUserDataPdu->DecodeHeader(*decodeBuffer, *pHeader, headerLen), 0);
941 pHeader->udhType = UserDataHeadType::UDH_APP_PORT_8BIT;
942 EXPECT_EQ(gsmUserDataPdu->DecodeHeader(*decodeBuffer, *pHeader, headerLen), 0);
943 pHeader->udhType = UserDataHeadType::UDH_APP_PORT_16BIT;
944 EXPECT_EQ(gsmUserDataPdu->DecodeHeader(*decodeBuffer, *pHeader, headerLen), 0);
945 pHeader->udhType = UserDataHeadType::UDH_SPECIAL_SMS;
946 EXPECT_EQ(gsmUserDataPdu->DecodeHeader(*decodeBuffer, *pHeader, headerLen), 0);
947 pHeader->udhType = UserDataHeadType::UDH_ALTERNATE_REPLY_ADDRESS;
948 EXPECT_EQ(gsmUserDataPdu->DecodeHeader(*decodeBuffer, *pHeader, headerLen), 0);
949 pHeader->udhType = UserDataHeadType::UDH_SINGLE_SHIFT;
950 EXPECT_EQ(gsmUserDataPdu->DecodeHeader(*decodeBuffer, *pHeader, headerLen), 0);
951 }
952
953 /**
954 * @tc.number Telephony_SmsMmsGtest_GsmSmsUDataCodec_0003
955 * @tc.name Test GsmUserDataPdu
956 * @tc.desc Function test
957 */
958 HWTEST_F(BranchSmsTest, GsmSmsUDataCodec_0003, Function | MediumTest | Level1)
959 {
960 auto gsmUserDataPdu = std::make_shared<GsmUserDataPdu>();
961 SmsUDH *pHeader = new SmsUDH();
962 pHeader->udhType = UDH_CONCAT_8BIT;
963 gsmUserDataPdu->DebugDecodeHeader(*pHeader);
964 pHeader->udhType = UDH_CONCAT_16BIT;
965 gsmUserDataPdu->DebugDecodeHeader(*pHeader);
966 pHeader->udhType = UDH_APP_PORT_8BIT;
967 gsmUserDataPdu->DebugDecodeHeader(*pHeader);
968 pHeader->udhType = UDH_APP_PORT_16BIT;
969 gsmUserDataPdu->DebugDecodeHeader(*pHeader);
970 pHeader->udhType = UDH_SPECIAL_SMS;
971 gsmUserDataPdu->DebugDecodeHeader(*pHeader);
972 pHeader->udhType = UDH_ALTERNATE_REPLY_ADDRESS;
973 gsmUserDataPdu->DebugDecodeHeader(*pHeader);
974 pHeader->udhType = UDH_SINGLE_SHIFT;
975 gsmUserDataPdu->DebugDecodeHeader(*pHeader);
976 pHeader->udhType = UDH_LOCKING_SHIFT;
977 gsmUserDataPdu->DebugDecodeHeader(*pHeader);
978 pHeader->udhType = UDH_NONE;
979 gsmUserDataPdu->DebugDecodeHeader(*pHeader);
980 pHeader->udhType = UserDataHeadType::UDH_LOCKING_SHIFT;
981
982 auto decodeBuffer = std::make_shared<SmsReadBuffer>("00");
983 decodeBuffer->data_[0] = 1;
984 uint16_t headerLen;
985 EXPECT_EQ(gsmUserDataPdu->DecodeHeader(*decodeBuffer, *pHeader, headerLen), 0);
986 pHeader->udhType = UserDataHeadType::UDH_NONE;
987 EXPECT_EQ(gsmUserDataPdu->DecodeHeader(*decodeBuffer, *pHeader, headerLen), 0);
988 }
989
990 /**
991 * @tc.number Telephony_SmsMmsGtest_GsmSmsTpduCodec_0001
992 * @tc.name Test GsmSmsTpduCodec
993 * @tc.desc Function test
994 */
995 HWTEST_F(BranchSmsTest, GsmSmsTpduCodec_0001, Function | MediumTest | Level1)
996 {
997 unsigned char encodeData[BUF_SIZE];
998 unsigned char *pSMSC = encodeData;
999 char addressData[BUF_SIZE];
1000 char *pDecodeAddr = addressData;
1001 auto smsTpdu = std::make_shared<SmsTpdu>();
1002 smsTpdu->tpduType = SmsTpduType::SMS_TPDU_SUBMIT;
1003
1004 uint16_t bufLen;
1005 auto tpduCodec = std::make_shared<GsmSmsTpduCodec>();
1006 EXPECT_GE(tpduCodec->EncodeSmsPdu(smsTpdu, pDecodeAddr, 1, bufLen), 0);
1007 smsTpdu->tpduType = SmsTpduType::SMS_TPDU_DELIVER;
1008 EXPECT_GE(tpduCodec->EncodeSmsPdu(smsTpdu, pDecodeAddr, 1, bufLen), 0);
1009 smsTpdu->tpduType = SmsTpduType::SMS_TPDU_DELIVER_REP;
1010 EXPECT_GE(tpduCodec->EncodeSmsPdu(smsTpdu, pDecodeAddr, 1, bufLen), 0);
1011 smsTpdu->tpduType = SmsTpduType::SMS_TPDU_STATUS_REP;
1012 EXPECT_GE(tpduCodec->EncodeSmsPdu(smsTpdu, pDecodeAddr, 1, bufLen), 0);
1013
1014 SmsTpdu *pSmsTpdu = new SmsTpdu();
1015 EXPECT_EQ(tpduCodec->DecodeSmsPdu(nullptr, 1, pSmsTpdu), 0);
1016 EXPECT_EQ(tpduCodec->DecodeSmsPdu(pSMSC, 1, nullptr), 0);
1017 EXPECT_GE(tpduCodec->DecodeSmsPdu(pSMSC, 1, pSmsTpdu), 0);
1018 pSMSC[0] = 1;
1019 EXPECT_GE(tpduCodec->DecodeSmsPdu(pSMSC, 1, pSmsTpdu), 0);
1020 pSMSC[0] = VALUE_LENGTH;
1021 EXPECT_GE(tpduCodec->DecodeSmsPdu(pSMSC, 1, pSmsTpdu), 0);
1022 pSMSC[0] = HEADER_LENGTH;
1023 EXPECT_EQ(tpduCodec->DecodeSmsPdu(pSMSC, 1, pSmsTpdu), 0);
1024 }
1025
1026 /**
1027 * @tc.number Telephony_SmsMmsGtest_GsmSmsTpduCodec_0002
1028 * @tc.name Test GsmSmsTpduCodec
1029 * @tc.desc Function test
1030 */
1031 HWTEST_F(BranchSmsTest, GsmSmsTpduCodec_0002, Function | MediumTest | Level1)
1032 {
1033 auto tpduCodec = std::make_shared<GsmSmsTpduCodec>();
1034 auto encode = std::make_shared<GsmSmsTpduEncode>(tpduCodec->uDataCodec_, tpduCodec->paramCodec_, tpduCodec);
1035 auto encodeBuffer = std::make_shared<SmsWriteBuffer>();
1036 encodeBuffer->data_[0] = 1;
1037 SmsSubmit *pSubmit = new SmsSubmit();
1038 SmsDeliver *pDeliver = new SmsDeliver();
1039 SmsDeliverReport *pDeliverRep = new SmsDeliverReport();
1040 EXPECT_EQ(encode->EncodeSubmitPdu(*encodeBuffer, nullptr), 0);
1041 EXPECT_EQ(encode->EncodeSubmitPdu(*encodeBuffer, pSubmit), 1);
1042 EXPECT_EQ(encode->EncodeDeliverPdu(*encodeBuffer, nullptr), 0);
1043 EXPECT_EQ(encode->EncodeDeliverPdu(*encodeBuffer, pDeliver), 0);
1044 pDeliver->bMoreMsg = false;
1045 pDeliver->bStatusReport = true;
1046 pDeliver->bHeaderInd = true;
1047 pDeliver->bReplyPath = true;
1048 EXPECT_GE(encode->EncodeDeliverPdu(*encodeBuffer, pDeliver), 0);
1049 EXPECT_EQ(encode->EncodeDeliverReportPdu(*encodeBuffer, nullptr), 0);
1050 EXPECT_EQ(encode->EncodeDeliverReportPdu(*encodeBuffer, pDeliverRep), 0);
1051 pDeliverRep->bHeaderInd = true;
1052 pDeliverRep->reportType = _SMS_REPORT_TYPE_E::SMS_REPORT_NEGATIVE;
1053 pDeliverRep->paramInd = 1;
1054 EXPECT_GE(encode->EncodeDeliverReportPdu(*encodeBuffer, pDeliverRep), 0);
1055 pDeliverRep->paramInd = VALUE_LENGTH;
1056 EXPECT_GE(encode->EncodeDeliverReportPdu(*encodeBuffer, pDeliverRep), 0);
1057 pDeliverRep->paramInd = START_BIT;
1058 EXPECT_GE(encode->EncodeDeliverReportPdu(*encodeBuffer, pDeliverRep), 0);
1059 }
1060
1061 /**
1062 * @tc.number Telephony_SmsMmsGtest_GsmSmsTpduCodec_0003
1063 * @tc.name Test GsmSmsTpduCodec
1064 * @tc.desc Function test
1065 */
1066 HWTEST_F(BranchSmsTest, GsmSmsTpduCodec_0003, Function | MediumTest | Level1)
1067 {
1068 auto tpduCodec = std::make_shared<GsmSmsTpduCodec>();
1069 SmsStatusReport *pStatusRep = new SmsStatusReport();
1070 SmsSubmit *pSmsSub = new SmsSubmit();
1071
1072 auto encode = std::make_shared<GsmSmsTpduEncode>(tpduCodec->uDataCodec_, tpduCodec->paramCodec_, tpduCodec);
1073 auto encodeBuffer = std::make_shared<SmsWriteBuffer>();
1074 encodeBuffer->data_[0] = 1;
1075 EXPECT_EQ(encode->EncodeStatusReportPdu(*encodeBuffer, nullptr), 0);
1076 EXPECT_EQ(encode->EncodeStatusReportPdu(*encodeBuffer, pStatusRep), 0);
1077 pStatusRep->bMoreMsg = true;
1078 pStatusRep->bStatusReport = true;
1079 pStatusRep->bHeaderInd = true;
1080 pStatusRep->paramInd = 1;
1081 EXPECT_GE(encode->EncodeStatusReportPdu(*encodeBuffer, pStatusRep), 0);
1082 pStatusRep->paramInd = VALUE_LENGTH;
1083 EXPECT_GE(encode->EncodeStatusReportPdu(*encodeBuffer, pStatusRep), 0);
1084 pStatusRep->paramInd = START_BIT;
1085 EXPECT_GE(encode->EncodeStatusReportPdu(*encodeBuffer, pStatusRep), 0);
1086
1087 auto decode = std::make_shared<GsmSmsTpduDecode>(tpduCodec->uDataCodec_, tpduCodec->paramCodec_, tpduCodec);
1088 auto decodeBuffer = std::make_shared<SmsReadBuffer>("00");
1089 decodeBuffer->data_[0] = 1;
1090 EXPECT_EQ(decode->DecodeSubmit(*decodeBuffer, pSmsSub), 0);
1091 EXPECT_EQ(decode->DecodeSubmit(*decodeBuffer, nullptr), 0);
1092 SmsDeliver *pDeliver = new SmsDeliver();
1093 EXPECT_EQ(decode->DecodeDeliver(*decodeBuffer, pDeliver), 0);
1094 EXPECT_EQ(decode->DecodeDeliver(*decodeBuffer, nullptr), 0);
1095 EXPECT_EQ(decode->DecodeStatusReport(*decodeBuffer, pStatusRep), 0);
1096 EXPECT_EQ(decode->DecodeStatusReport(*decodeBuffer, nullptr), 0);
1097 }
1098
1099 /**
1100 * @tc.number Telephony_SmsMmsGtest_GsmSmsTpduCodec_0004
1101 * @tc.name Test GsmSmsTpduCodec
1102 * @tc.desc Function test
1103 */
1104 HWTEST_F(BranchSmsTest, GsmSmsTpduCodec_0004, Function | MediumTest | Level1)
1105 {
1106 auto tpduCodec = std::make_shared<GsmSmsTpduCodec>();
1107 auto smsTpdu_ = std::make_shared<SmsTpdu>();
1108 char tpduBuf[MAX_TPDU_DATA_LEN] = { 0 };
1109 uint16_t bufLen;
1110 bool ret = tpduCodec->EncodeSmsPdu(smsTpdu_, tpduBuf, sizeof(tpduBuf), bufLen);
1111 SmsSubmit pSubmit;
1112 pSubmit.bRejectDup = true;
1113 pSubmit.bStatusReport = true;
1114 pSubmit.bHeaderInd = true;
1115 pSubmit.bReplyPath = true;
1116 auto decodeBuffer = std::make_shared<SmsReadBuffer>("00");
1117 decodeBuffer->data_[0] = 1;
1118 tpduCodec->DebugTpdu(*decodeBuffer, SmsParseType::PARSE_SUBMIT_TYPE);
1119
1120 auto encodeBuffer = std::make_shared<SmsWriteBuffer>();
1121 encodeBuffer->data_[0] = 1;
1122 auto encode = std::make_shared<GsmSmsTpduEncode>(tpduCodec->uDataCodec_, tpduCodec->paramCodec_, tpduCodec);
1123 encode->EncodeSubmitTpduType(*encodeBuffer, pSubmit);
1124 pSubmit.vpf = SmsVpf::SMS_VPF_NOT_PRESENT;
1125 encode->EncodeSubmitTpduType(*encodeBuffer, pSubmit);
1126 pSubmit.vpf = SmsVpf::SMS_VPF_ENHANCED;
1127 encode->EncodeSubmitTpduType(*encodeBuffer, pSubmit);
1128 pSubmit.vpf = SmsVpf::SMS_VPF_RELATIVE;
1129 encode->EncodeSubmitTpduType(*encodeBuffer, pSubmit);
1130 pSubmit.vpf = SmsVpf::SMS_VPF_ABSOLUTE;
1131 encode->EncodeSubmitTpduType(*encodeBuffer, pSubmit);
1132 EXPECT_TRUE(ret);
1133 }
1134
1135 /**
1136 * @tc.number Telephony_SmsMmsGtest_SmsBaseMessage_0001
1137 * @tc.name Test SmsBaseMessage
1138 * @tc.desc Function test
1139 */
1140 HWTEST_F(BranchSmsTest, SmsBaseMessage_0001, Function | MediumTest | Level1)
1141 {
1142 auto smsBaseMessage = std::make_shared<GsmSmsMessage>();
1143 smsBaseMessage->ConvertMessageClass(SmsMessageClass::SMS_SIM_MESSAGE);
1144 smsBaseMessage->ConvertMessageClass(SmsMessageClass::SMS_INSTANT_MESSAGE);
1145 smsBaseMessage->ConvertMessageClass(SmsMessageClass::SMS_OPTIONAL_MESSAGE);
1146 smsBaseMessage->ConvertMessageClass(SmsMessageClass::SMS_FORWARD_MESSAGE);
1147 smsBaseMessage->ConvertMessageClass(SmsMessageClass::SMS_CLASS_UNKNOWN);
1148 SplitInfo split;
1149 DataCodingScheme codingType = DataCodingScheme::DATA_CODING_7BIT;
1150 smsBaseMessage->ConvertSpiltToUtf8(split, codingType);
1151 split.encodeData.push_back(1);
1152 codingType = DataCodingScheme::DATA_CODING_UCS2;
1153 smsBaseMessage->ConvertSpiltToUtf8(split, codingType);
1154 codingType = DataCodingScheme::DATA_CODING_AUTO;
1155 smsBaseMessage->ConvertSpiltToUtf8(split, codingType);
1156 smsBaseMessage->smsUserData_.headerCnt = 1;
1157 smsBaseMessage->smsUserData_.header[0].udhType = UserDataHeadType::UDH_CONCAT_8BIT;
1158 EXPECT_FALSE(smsBaseMessage->GetConcatMsg() == nullptr);
1159 smsBaseMessage->smsUserData_.header[0].udhType = UserDataHeadType::UDH_CONCAT_16BIT;
1160 EXPECT_FALSE(smsBaseMessage->GetConcatMsg() == nullptr);
1161 smsBaseMessage->smsUserData_.header[0].udhType = UserDataHeadType::UDH_APP_PORT_8BIT;
1162 EXPECT_FALSE(smsBaseMessage->GetPortAddress() == nullptr);
1163 smsBaseMessage->smsUserData_.header[0].udhType = UserDataHeadType::UDH_APP_PORT_16BIT;
1164 EXPECT_FALSE(smsBaseMessage->GetPortAddress() == nullptr);
1165 smsBaseMessage->smsUserData_.header[0].udhType = UserDataHeadType::UDH_SPECIAL_SMS;
1166 EXPECT_FALSE(smsBaseMessage->GetSpecialSmsInd() == nullptr);
1167 smsBaseMessage->smsUserData_.header[0].udhType = UserDataHeadType::UDH_APP_PORT_8BIT;
1168 EXPECT_FALSE(smsBaseMessage->IsWapPushMsg());
1169 MSG_LANGUAGE_ID_T langId = 1;
1170 codingType = DataCodingScheme::DATA_CODING_7BIT;
1171 EXPECT_GT(smsBaseMessage->GetMaxSegmentSize(codingType, 1, true, langId, 1), 0);
1172 EXPECT_GT(smsBaseMessage->GetSegmentSize(codingType, 1, true, langId), 0);
1173 codingType = DataCodingScheme::DATA_CODING_ASCII7BIT;
1174 EXPECT_GT(smsBaseMessage->GetMaxSegmentSize(codingType, 1, true, langId, 1), 0);
1175 EXPECT_GT(smsBaseMessage->GetSegmentSize(codingType, 1, true, langId), 0);
1176 codingType = DataCodingScheme::DATA_CODING_8BIT;
1177 EXPECT_GT(smsBaseMessage->GetMaxSegmentSize(codingType, 1, true, langId, 1), 0);
1178 EXPECT_GT(smsBaseMessage->GetSegmentSize(codingType, 1, true, langId), 0);
1179 codingType = DataCodingScheme::DATA_CODING_UCS2;
1180 EXPECT_GT(smsBaseMessage->GetMaxSegmentSize(codingType, 1, true, langId, 1), 0);
1181 EXPECT_GT(smsBaseMessage->GetSegmentSize(codingType, 1, true, langId), 0);
1182 std::string message = "";
1183 LengthInfo lenInfo;
1184 EXPECT_GE(smsBaseMessage->GetSmsSegmentsInfo(message, true, lenInfo), 0);
1185 message = "123";
1186 EXPECT_EQ(smsBaseMessage->GetSmsSegmentsInfo(message, true, lenInfo), TELEPHONY_ERR_SUCCESS);
1187 EXPECT_EQ(smsBaseMessage->GetSmsSegmentsInfo(message, false, lenInfo), TELEPHONY_ERR_SUCCESS);
1188 }
1189
1190 /**
1191 * @tc.number Telephony_SmsMmsGtest_SmsBaseMessage_0002
1192 * @tc.name Test SmsBaseMessage
1193 * @tc.desc Function test
1194 */
1195 HWTEST_F(BranchSmsTest, SmsBaseMessage_0002, Function | MediumTest | Level1)
1196 {
1197 auto gsmSmsMessage = std::make_shared<GsmSmsMessage>();
1198 std::vector<struct SplitInfo> splitResult;
1199 DataCodingScheme codingType = DATA_CODING_AUTO;
1200 std::string text = {0xe4, 0xbd, 0xa0, 0xe4, 0xbd, 0xa0, 0xe4, 0xbd, 0xa0, 0xf0, 0x9f, 0xa5, 0xb3, 0xf0, 0x9f, 0xa5,
1201 0xb3, 0xf0, 0x9f, 0xa5, 0xb3, 0xf0, 0x9f, 0xa5, 0xb3, 0xf0, 0x9f, 0xa5, 0xb3, 0xf0, 0x9f, 0xa5, 0xb3,
1202 0xf0, 0x9f, 0xa5, 0xb3, 0xf0, 0x9f, 0xa5, 0xb3, 0xf0, 0x9f, 0xa5, 0xb3, 0xf0, 0x9f, 0xa5, 0xb3,
1203 0xf0, 0x9f, 0xa5, 0xb3, 0xf0, 0x9f, 0xa5, 0xb3, 0xf0, 0x9f, 0xa5, 0xb3, 0xf0, 0x9f, 0xa5, 0xb3,
1204 0xf0, 0x9f, 0xa5, 0xb3, 0xf0, 0x9f, 0xa5, 0xb3, 0xf0, 0x9f, 0xa5, 0xb3, 0xf0, 0x9f, 0xa5, 0xb3,
1205 0xf0, 0x9f, 0xa5, 0xb3, 0xf0, 0x9f, 0xa5, 0xb3, 0xf0, 0x9f, 0xa5, 0xb3, 0xf0, 0x9f, 0xa5, 0xb3,
1206 0xf0, 0x9f, 0xa5, 0xb3, 0xf0, 0x9f, 0xa5, 0xb3, 0xf0, 0x9f, 0xa5, 0xb3, 0xf0, 0x9f, 0xa5, 0xb3,
1207 0xf0, 0x9f, 0xa5, 0xb3, 0xf0, 0x9f, 0xa5, 0xb3, 0xf0, 0x9f, 0xa5, 0xb3, 0xf0, 0x9f, 0xa5, 0xb3,
1208 0xf0, 0x9f, 0xa5, 0xb3, 0xf0, 0x9f, 0xa5, 0xb3, 0xf0, 0x9f, 0xa5, 0xb3};
1209 std::string desAddr = "";
1210 gsmSmsMessage->SplitMessage(splitResult, text, false, codingType, false, desAddr);
1211 std::vector<unsigned char> expect1 = {0x4f, 0x60, 0x4f, 0x60, 0x4f, 0x60, 0xd8, 0x3e, 0xdd, 0x73,
1212 0xd8, 0x3e, 0xdd, 0x73, 0xd8, 0x3e, 0xdd, 0x73, 0xd8, 0x3e, 0xdd, 0x73, 0xd8, 0x3e, 0xdd, 0x73, 0xd8, 0x3e,
1213 0xdd, 0x73, 0xd8, 0x3e, 0xdd, 0x73, 0xd8, 0x3e, 0xdd, 0x73, 0xd8, 0x3e, 0xdd, 0x73, 0xd8, 0x3e, 0xdd, 0x73,
1214 0xd8, 0x3e, 0xdd, 0x73, 0xd8, 0x3e, 0xdd, 0x73, 0xd8, 0x3e, 0xdd, 0x73, 0xd8, 0x3e, 0xdd, 0x73,
1215 0xd8, 0x3e, 0xdd, 0x73, 0xd8, 0x3e, 0xdd, 0x73, 0xd8, 0x3e, 0xdd, 0x73, 0xd8, 0x3e, 0xdd, 0x73,
1216 0xd8, 0x3e, 0xdd, 0x73, 0xd8, 0x3e, 0xdd, 0x73, 0xd8, 0x3e, 0xdd, 0x73, 0xd8, 0x3e, 0xdd, 0x73,
1217 0xd8, 0x3e, 0xdd, 0x73, 0xd8, 0x3e, 0xdd, 0x73, 0xd8, 0x3e, 0xdd, 0x73, 0xd8, 0x3e, 0xdd, 0x73,
1218 0xd8, 0x3e, 0xdd, 0x73, 0xd8, 0x3e, 0xdd, 0x73};
1219 std::vector<unsigned char> expect2 = {0xd8, 0x3e, 0xdd, 0x73, 0xd8, 0x3e, 0xdd, 0x73, 0xd8, 0x3e, 0xdd, 0x73,
1220 0xd8, 0x3e, 0xdd, 0x73, 0xd8, 0x3e, 0xdd, 0x73};
1221 EXPECT_FALSE(splitResult[0].encodeData == expect1);
1222 EXPECT_FALSE(splitResult[1].encodeData == expect2);
1223 }
1224
1225 /**
1226 * @tc.number Telephony_SmsMmsGtest_GsmSmsReceiveHandler_0001
1227 * @tc.name Test GsmSmsReceiveHandler
1228 * @tc.desc Function test
1229 */
1230 HWTEST_F(BranchSmsTest, GsmSmsReceiveHandler_0001, Function | MediumTest | Level1)
1231 {
1232 auto smsReceiveManager = std::make_shared<SmsReceiveManager>(1);
1233 EXPECT_TRUE(smsReceiveManager != nullptr);
1234 smsReceiveManager->Init();
1235 EXPECT_TRUE(smsReceiveManager->gsmSmsReceiveHandler_ != nullptr);
1236 smsReceiveManager->gsmSmsReceiveHandler_->UnRegisterHandler();
1237 EXPECT_NE(smsReceiveManager->gsmSmsReceiveHandler_->HandleSmsByType(nullptr), TELEPHONY_ERR_SUCCESS);
1238 EXPECT_EQ(smsReceiveManager->gsmSmsReceiveHandler_->TransformMessageInfo(nullptr), nullptr);
1239 }
1240
1241 /**
1242 * @tc.number Telephony_SmsMmsGtest_GsmSmsSender_0001
1243 * @tc.name Test GsmSmsSender
1244 * @tc.desc Function test
1245 */
1246 HWTEST_F(BranchSmsTest, GsmSmsSender_0001, Function | MediumTest | Level1)
1247 {
1248 std::function<void(std::shared_ptr<SmsSendIndexer>)> sendRetryFun = nullptr;
1249 auto gsmSmsSender = std::make_shared<GsmSmsSender>(INVALID_SLOTID, sendRetryFun);
1250 uint8_t *data = (uint8_t *)malloc(VALUE_LENGTH * sizeof(uint8_t));
1251 std::string dataStr = "123";
1252 gsmSmsSender->CharArrayToString(data, 1, dataStr);
1253 std::shared_ptr<SmsSendIndexer> smsIndexer = nullptr;
1254 const sptr<ISendShortMessageCallback> sendCallback =
1255 iface_cast<ISendShortMessageCallback>(new SendShortMessageCallbackStub());
1256 const sptr<IDeliveryShortMessageCallback> deliveryCallback =
1257 iface_cast<IDeliveryShortMessageCallback>(new DeliveryShortMessageCallbackStub());
1258 const std::string desAddr = "qwe";
1259 const std::string scAddr = "123";
1260 const std::string text = "123";
1261 std::shared_ptr<struct EncodeInfo> encodeInfo = nullptr;
1262 gsmSmsSender->SendSmsToRil(smsIndexer);
1263 gsmSmsSender->ResendTextDelivery(smsIndexer);
1264 gsmSmsSender->ResendDataDelivery(smsIndexer);
1265 gsmSmsSender->SetSendIndexerInfo(smsIndexer, encodeInfo, 1);
1266 smsIndexer = std::make_shared<SmsSendIndexer>(desAddr, scAddr, text, sendCallback, deliveryCallback);
1267 gsmSmsSender->ResendTextDelivery(smsIndexer);
1268 gsmSmsSender->voiceServiceState_ = static_cast<int32_t>(RegServiceState::REG_STATE_IN_SERVICE);
1269 gsmSmsSender->imsSmsCfg_ = 0;
1270 gsmSmsSender->SendSmsToRil(smsIndexer);
1271 smsIndexer->psResendCount_ = DIGIT_LEN;
1272 gsmSmsSender->SendSmsToRil(smsIndexer);
1273 AppExecFwk::InnerEvent::Pointer event = AppExecFwk::InnerEvent::Get(0, 1);
1274 gsmSmsSender->StatusReportAnalysis(event);
1275 gsmSmsSender->StatusReportGetImsSms(event);
1276 event = nullptr;
1277 gsmSmsSender->StatusReportSetImsSms(event);
1278 gsmSmsSender->StatusReportAnalysis(event);
1279 gsmSmsSender->StatusReportGetImsSms(event);
1280 gsmSmsSender->isImsGsmHandlerRegistered = true;
1281 gsmSmsSender->RegisterImsHandler();
1282 gsmSmsSender->SetSendIndexerInfo(smsIndexer, encodeInfo, 1);
1283 GsmSimMessageParam smsData;
1284 smsIndexer->hasMore_ = true;
1285 gsmSmsSender->SendCsSms(smsIndexer, smsData);
1286 smsIndexer->csResendCount_ = 1;
1287 gsmSmsSender->SendCsSms(smsIndexer, smsData);
1288 GsmSmsMessage gsmSmsMessage;
1289 bool isMore = true;
1290 smsIndexer->isConcat_ = true;
1291 EXPECT_FALSE(gsmSmsSender->SetPduInfo(nullptr, gsmSmsMessage, isMore));
1292 EXPECT_TRUE(gsmSmsSender->SetPduInfo(smsIndexer, gsmSmsMessage, isMore));
1293 smsIndexer->smsConcat_.totalSeg = VALUE_LENGTH;
1294 EXPECT_TRUE(gsmSmsSender->SetPduInfo(smsIndexer, gsmSmsMessage, isMore));
1295 }
1296
1297 /**
1298 * @tc.number Telephony_SmsMmsGtest_SatelliteSmsCallback_0001
1299 * @tc.name Test SatelliteSms Callback
1300 * @tc.desc Function test
1301 */
1302 HWTEST_F(BranchSmsTest, SatelliteSmsCallback_0001, Function | MediumTest | Level1)
1303 {
1304 std::function<void(std::shared_ptr<SmsSendIndexer>)> fun = nullptr;
1305 auto gsmSmsSender = std::make_shared<GsmSmsSender>(INVALID_SLOTID, fun);
1306 SatelliteSmsCallback callback(gsmSmsSender);
1307 MessageParcel data;
1308 MessageParcel reply;
1309 MessageOption option;
1310 data.WriteInterfaceToken(u"");
1311 data.WriteInt32(0);
1312 EXPECT_EQ(callback.OnRemoteRequest(0, data, reply, option), TELEPHONY_ERR_DESCRIPTOR_MISMATCH);
1313 }
1314
1315 /**
1316 * @tc.number Telephony_SmsMmsGtest_SatelliteSmsCallback_0002
1317 * @tc.name Test SatelliteSms Callback
1318 * @tc.desc Function test
1319 */
1320 HWTEST_F(BranchSmsTest, SatelliteSmsCallback_0002, Function | MediumTest | Level1)
1321 {
1322 std::function<void(std::shared_ptr<SmsSendIndexer>)> fun = nullptr;
1323 auto gsmSmsSender = std::make_shared<GsmSmsSender>(INVALID_SLOTID, fun);
1324 SatelliteSmsCallback callback(gsmSmsSender);
1325 MessageParcel reply;
1326 MessageOption option;
1327
1328 MessageParcel hrilData;
1329 hrilData.WriteInterfaceToken(INTERFACE_TOKEN);
1330 hrilData.WriteInt32(0);
1331 hrilData.WriteInt32(static_cast<int32_t>(SatelliteSmsResultType::HRIL_RADIO_RESPONSE));
1332 hrilData.WriteInt32(0);
1333 hrilData.WriteInt32(0);
1334 hrilData.WriteInt32(0);
1335 hrilData.WriteInt32(0);
1336 EXPECT_EQ(callback.OnRemoteRequest(0, hrilData, reply, option), TELEPHONY_SUCCESS);
1337
1338 MessageParcel data;
1339 data.WriteInterfaceToken(INTERFACE_TOKEN);
1340 data.WriteInt32(0);
1341 data.WriteInt32(static_cast<int32_t>(SatelliteSmsResultType::SEND_SMS_RESULT));
1342 data.WriteInt32(0);
1343 data.WriteString("");
1344 data.WriteInt32(0);
1345 data.WriteInt64(0);
1346 EXPECT_EQ(callback.OnRemoteRequest(0, data, reply, option), TELEPHONY_SUCCESS);
1347 }
1348
1349 /**
1350 * @tc.number Telephony_SmsMmsGtest_SatelliteSmsCallback_0003
1351 * @tc.name Test SatelliteSms Callback
1352 * @tc.desc Function test
1353 */
1354 HWTEST_F(BranchSmsTest, SatelliteSmsCallback_0003, Function | MediumTest | Level1)
1355 {
1356 std::function<void(std::shared_ptr<SmsSendIndexer>)> fun = nullptr;
1357 auto gsmSmsSender = std::make_shared<GsmSmsSender>(INVALID_SLOTID, fun);
1358 SatelliteSmsCallback callback(gsmSmsSender);
1359 MessageParcel reply;
1360 MessageOption option;
1361
1362 MessageParcel errData;
1363 errData.WriteInterfaceToken(INTERFACE_TOKEN);
1364 errData.WriteInt32(0);
1365 EXPECT_EQ(callback.OnRemoteRequest(1, errData, reply, option), TELEPHONY_ERR_READ_DATA_FAIL);
1366
1367 MessageParcel data;
1368 data.WriteInterfaceToken(INTERFACE_TOKEN);
1369 data.WriteInt32(0);
1370 data.WriteInt32(0);
1371 data.WriteInt32(0);
1372 std::vector<uint8_t> pdu {};
1373 data.WriteUInt8Vector(pdu);
1374 EXPECT_NE(callback.OnRemoteRequest(1, data, reply, option), TELEPHONY_SUCCESS);
1375 }
1376
1377 /**
1378 * @tc.number Telephony_SmsMmsGtest_SatelliteSmsCallback_0004
1379 * @tc.name Test SatelliteSms Callback
1380 * @tc.desc Function test
1381 */
1382 HWTEST_F(BranchSmsTest, SatelliteSmsCallback_0004, Function | MediumTest | Level1)
1383 {
1384 std::function<void(std::shared_ptr<SmsSendIndexer>)> fun = nullptr;
1385 auto gsmSmsSender = std::make_shared<GsmSmsSender>(INVALID_SLOTID, fun);
1386 SatelliteSmsCallback callback(gsmSmsSender);
1387 MessageParcel reply;
1388 MessageOption option;
1389
1390 MessageParcel errData;
1391 errData.WriteInterfaceToken(INTERFACE_TOKEN);
1392 errData.WriteInt32(0);
1393 EXPECT_EQ(callback.OnRemoteRequest(2, errData, reply, option), TELEPHONY_ERR_READ_DATA_FAIL);
1394
1395 MessageParcel data;
1396 data.WriteInterfaceToken(INTERFACE_TOKEN);
1397 data.WriteInt32(0);
1398 data.WriteInt32(0);
1399 data.WriteInt32(0);
1400 std::vector<uint8_t> pdu {};
1401 data.WriteUInt8Vector(pdu);
1402 EXPECT_EQ(callback.OnRemoteRequest(2, data, reply, option), TELEPHONY_SUCCESS);
1403 }
1404
1405 /**
1406 * @tc.number Telephony_SmsMmsGtest_SatelliteSmsClient_0001
1407 * @tc.name Test Satellite Service Client
1408 * @tc.desc Function test
1409 */
1410 HWTEST_F(BranchSmsTest, SatelliteSmsClient_0001, Function | MediumTest | Level1)
1411 {
1412 TELEPHONY_LOGI("SatelliteSmsClient_0001==========");
1413 std::function<void(std::shared_ptr<SmsSendIndexer>)> fun = nullptr;
1414 auto gsmSmsSender = std::make_shared<GsmSmsSender>(INVALID_SLOTID, fun);
1415 auto smsReceiveManager = std::make_shared<SmsReceiveManager>(INVALID_SLOTID);
1416 EXPECT_TRUE(smsReceiveManager != nullptr);
1417 smsReceiveManager->Init();
1418 EXPECT_TRUE(smsReceiveManager->gsmSmsReceiveHandler_ != nullptr);
1419 auto &satelliteSmsClient = SatelliteSmsClient::GetInstance();
1420 satelliteSmsClient.AddSendHandler(INVALID_SLOTID, std::static_pointer_cast<TelEventHandler>(gsmSmsSender));
1421 satelliteSmsClient.AddReceiveHandler(INVALID_SLOTID, std::static_pointer_cast<TelEventHandler>
1422 (smsReceiveManager->gsmSmsReceiveHandler_));
1423 satelliteSmsClient.statusChangeListener_->OnAddSystemAbility(INVALID_SLOTID, "");
1424 satelliteSmsClient.statusChangeListener_->OnRemoveSystemAbility(INVALID_SLOTID, "");
1425 EXPECT_GE(satelliteSmsClient.GetSatelliteSupported(), 0);
1426 EXPECT_GE(satelliteSmsClient.IsSatelliteEnabled(), 0);
1427 EXPECT_GE(satelliteSmsClient.GetSatelliteCapability(), 0);
1428 SatelliteMessage message;
1429 EXPECT_EQ(satelliteSmsClient.SendSms(INVALID_SLOTID, RadioEvent::RADIO_SEND_SMS, message),
1430 TELEPHONY_ERR_IPC_CONNECT_STUB_FAIL);
1431 EXPECT_EQ(satelliteSmsClient.SendSmsMoreMode(INVALID_SLOTID, RadioEvent::RADIO_SEND_SMS_EXPECT_MORE, message),
1432 TELEPHONY_ERR_IPC_CONNECT_STUB_FAIL);
1433 EXPECT_EQ(
1434 satelliteSmsClient.SendSmsAck(INVALID_SLOTID, SMS_EVENT_NEW_SMS_REPLY, true, AckIncomeCause::SMS_ACK_RESULT_OK),
1435 TELEPHONY_ERR_IPC_CONNECT_STUB_FAIL);
1436 }
1437
1438 /**
1439 * @tc.number Telephony_SmsMmsGtest_SmsMiscManager_0001
1440 * @tc.name Test SmsMiscManager
1441 * @tc.desc Function test
1442 */
1443 HWTEST_F(BranchSmsTest, SmsMiscManager_0001, Function | MediumTest | Level1)
1444 {
1445 auto smsMiscManager = std::make_shared<SmsMiscManager>(INVALID_SLOTID);
1446 AppExecFwk::InnerEvent::Pointer event = AppExecFwk::InnerEvent::Get(SmsMiscManager::SET_CB_CONFIG_FINISH, 1);
1447 smsMiscManager->ProcessEvent(event);
1448 event = AppExecFwk::InnerEvent::Get(SmsMiscManager::SET_SMSC_ADDR_FINISH, 1);
1449 smsMiscManager->ProcessEvent(event);
1450 event = AppExecFwk::InnerEvent::Get(TELEPHONY_ERR_STRCPY_FAIL, 1);
1451 smsMiscManager->ProcessEvent(event);
1452 event = nullptr;
1453 smsMiscManager->ProcessEvent(event);
1454 smsMiscManager->NotifyHasResponse();
1455 smsMiscManager->fairList_.push_back(1);
1456 smsMiscManager->NotifyHasResponse();
1457 EXPECT_EQ(smsMiscManager->SetCBConfig(true, CODE_BUFFER_MAX_SIZE, 1, 1), TELEPHONY_ERR_ARGUMENT_INVALID);
1458 EXPECT_EQ(smsMiscManager->SetCBConfig(true, 1, 0, 1), TELEPHONY_ERR_ARGUMENT_INVALID);
1459 EXPECT_EQ(smsMiscManager->SetCBConfig(true, 1, 1, 0), TELEPHONY_ERR_ARGUMENT_INVALID);
1460 EXPECT_EQ(smsMiscManager->SetCBConfig(true, 1, 0, 0), TELEPHONY_ERR_ARGUMENT_INVALID);
1461 EXPECT_EQ(smsMiscManager->SetCBConfig(false, 1, 1, 1), TELEPHONY_ERR_SUCCESS);
1462 EXPECT_GE(smsMiscManager->SetCBConfig(true, 1, 1, 1), TELEPHONY_ERR_SUCCESS);
1463 EXPECT_TRUE(smsMiscManager->OpenCBRange(1, 1));
1464 smsMiscManager->rangeList_.clear();
1465 smsMiscManager->rangeList_.emplace_back(VALUE_LENGTH, 1);
1466 EXPECT_EQ(smsMiscManager->SetCBConfig(true, 1, 1, 1), TELEPHONY_ERR_RIL_CMD_FAIL);
1467 SmsMiscManager::infoData data(1, 1);
1468 std::string smsc = "";
1469 std::string pdu = "";
1470 std::vector<ShortMessage> message;
1471 EXPECT_GE(
1472 smsMiscManager->AddSimMessage(smsc, pdu, ISmsServiceInterface::SimMessageStatus::SIM_MESSAGE_STATUS_UNREAD), 0);
1473 EXPECT_GE(smsMiscManager->UpdateSimMessage(
1474 1, ISmsServiceInterface::SimMessageStatus::SIM_MESSAGE_STATUS_UNREAD, pdu, smsc),
1475 0);
1476 EXPECT_GT(smsMiscManager->GetAllSimMessages(message), TELEPHONY_ERR_SUCCESS);
1477 std::list<SmsMiscManager::gsmCBRangeInfo> rangeList;
1478 EXPECT_TRUE(smsMiscManager->SendDataToRil(true, rangeList));
1479 SmsMiscManager::gsmCBRangeInfo rangeInfo(1, 1);
1480 SmsMiscManager::gsmCBRangeInfo rangeInfoTwo(1, 0);
1481 rangeList.push_back(rangeInfo);
1482 rangeList.push_back(rangeInfoTwo);
1483 EXPECT_NE(smsMiscManager->RangeListToString(rangeList), "");
1484 EXPECT_FALSE(smsMiscManager->SendDataToRil(true, rangeList));
1485 EXPECT_FALSE(smsMiscManager->CloseCBRange(0, 0));
1486 }
1487
1488 /**
1489 * @tc.number Telephony_SmsMmsGtest_SmsMiscManager_0003
1490 * @tc.name Test SmsMiscManager
1491 * @tc.desc Function test
1492 */
1493 HWTEST_F(BranchSmsTest, SmsMiscManager_0003, Function | MediumTest | Level1)
1494 {
1495 auto smsMiscManager = std::make_shared<SmsMiscManager>(0);
1496 AppExecFwk::InnerEvent::Pointer event = AppExecFwk::InnerEvent::Get(SmsMiscManager::GET_CB_CONFIG_FINISH, 1);
1497 smsMiscManager->ProcessEvent(event);
1498 std::shared_ptr<CBConfigInfo> res = std::make_shared<CBConfigInfo>();
1499 res->mids = CB_RANGE_MIDS;
1500 res->dcss = CB_RANGE_DCSS;
1501 smsMiscManager->UpdateCbRangList(res);
1502 smsMiscManager->rangeList_.emplace_back(1, 1);
1503 smsMiscManager->rangeList_.emplace_back(0, 1);
1504 smsMiscManager->rangeList_.emplace_back(0, 0);
1505 smsMiscManager->CombineCBRange();
1506 EXPECT_FALSE(smsMiscManager->SendDataToRil(true, smsMiscManager->rangeList_));
1507 std::string src = CB_RANGE_MIDS;
1508 std::vector<std::string> dest;
1509 std::string delimiter = CB_RANGE_DELI;
1510 smsMiscManager->SplitMids(src, dest, delimiter);
1511 std::string value = CB_RANGE_MID;
1512 std::string start;
1513 std::string end;
1514 std::string dlm = CB_RANGE_DELIM;
1515 smsMiscManager->SplitMidValue(value, start, end, dlm);
1516 smsMiscManager->hasGotCbRange_ = true;
1517 smsMiscManager->GetModemCBRange();
1518 smsMiscManager->hasGotCbRange_ = false;
1519 smsMiscManager->GetModemCBRange();
1520 EXPECT_FALSE(smsMiscManager->SendDataToRil(true, smsMiscManager->rangeList_));
1521 }
1522
1523 /**
1524 * @tc.number Telephony_SmsMmsGtest_SmsService_0001
1525 * @tc.name Test SmsService
1526 * @tc.desc Function test
1527 */
1528 HWTEST_F(BranchSmsTest, SmsService_0001, Function | MediumTest | Level1)
1529 {
1530 auto smsService = DelayedSingleton<SmsService>::GetInstance();
1531 smsService->state_ = ServiceRunningState::STATE_RUNNING;
1532 smsService->OnStart();
1533 std::u16string desAddr = u"";
1534 uint8_t *data = nullptr;
1535 sptr<ISendShortMessageCallback> sendCallback = nullptr;
1536 sptr<IDeliveryShortMessageCallback> deliveryCallback = nullptr;
1537 EXPECT_GT(
1538 smsService->SendMessage(0, desAddr, desAddr, desAddr, sendCallback, deliveryCallback), TELEPHONY_ERR_SUCCESS);
1539 EXPECT_GT(smsService->SendMessage(0, desAddr, desAddr, 1, data, 1, sendCallback, deliveryCallback),
1540 TELEPHONY_ERR_SUCCESS);
1541 bool isSupported = true;
1542 std::string sca = "";
1543 smsService->TrimSmscAddr(sca);
1544 sca = " 123";
1545 smsService->TrimSmscAddr(sca);
1546 EXPECT_GT(smsService->IsImsSmsSupported(INVALID_SLOTID, isSupported), TELEPHONY_ERR_SUCCESS);
1547 EXPECT_GT(smsService->GetImsShortMessageFormat(desAddr), TELEPHONY_ERR_SUCCESS);
1548 EXPECT_GT(smsService->SetSmscAddr(INVALID_SLOTID, desAddr), TELEPHONY_ERR_SUCCESS);
1549 EXPECT_GT(smsService->GetSmscAddr(INVALID_SLOTID, desAddr), TELEPHONY_ERR_SUCCESS);
1550 EXPECT_GT(smsService->AddSimMessage(
1551 INVALID_SLOTID, desAddr, desAddr, ISmsServiceInterface::SimMessageStatus::SIM_MESSAGE_STATUS_UNREAD),
1552 TELEPHONY_ERR_SUCCESS);
1553 EXPECT_GT(smsService->DelSimMessage(INVALID_SLOTID, 1), TELEPHONY_ERR_SUCCESS);
1554 EXPECT_GT(smsService->UpdateSimMessage(INVALID_SLOTID, 1,
1555 ISmsServiceInterface::SimMessageStatus::SIM_MESSAGE_STATUS_UNREAD, desAddr, desAddr),
1556 TELEPHONY_ERR_SUCCESS);
1557 std::vector<ShortMessage> message;
1558 EXPECT_GT(smsService->SetCBConfig(INVALID_SLOTID, true, 1, 1, 1), TELEPHONY_ERR_SUCCESS);
1559 EXPECT_GE(smsService->SetImsSmsConfig(INVALID_SLOTID, 1), TELEPHONY_ERR_SUCCESS);
1560 EXPECT_GT(smsService->SetDefaultSmsSlotId(INVALID_SLOTID), TELEPHONY_ERR_SUCCESS);
1561 std::vector<std::u16string> splitMessage;
1562 EXPECT_GT(smsService->SplitMessage(desAddr, splitMessage), TELEPHONY_ERR_SUCCESS);
1563 }
1564
1565 /**
1566 * @tc.number Telephony_SmsMmsGtest_SmsService_0002
1567 * @tc.name Test SmsService
1568 * @tc.desc Function test
1569 */
1570 HWTEST_F(BranchSmsTest, SmsService_0002, Function | MediumTest | Level1)
1571 {
1572 auto smsService = DelayedSingleton<SmsService>::GetInstance();
1573 std::u16string message = u"";
1574 ISmsServiceInterface::SmsSegmentsInfo info;
1575 EXPECT_GT(smsService->GetSmsSegmentsInfo(INVALID_SLOTID, message, true, info), TELEPHONY_ERR_SUCCESS);
1576 message = u"123";
1577 EXPECT_GT(smsService->GetSmsSegmentsInfo(INVALID_SLOTID, message, true, info), TELEPHONY_ERR_SUCCESS);
1578 std::string scAddr = "";
1579 std::string specification = "";
1580 ShortMessage messages;
1581 EXPECT_GT(smsService->CreateMessage(scAddr, specification, messages), TELEPHONY_ERR_SUCCESS);
1582 specification = "3gpp";
1583 EXPECT_GE(smsService->CreateMessage(scAddr, specification, messages), TELEPHONY_ERR_SUCCESS);
1584 specification = "3gpp2";
1585 EXPECT_GE(smsService->CreateMessage(scAddr, specification, messages), TELEPHONY_ERR_SUCCESS);
1586 }
1587
1588 /**
1589 * @tc.number Telephony_SmsMmsGtest_SmsService_0003
1590 * @tc.name Test SmsService
1591 * @tc.desc Function test
1592 */
1593 HWTEST_F(BranchSmsTest, SmsService_0003, Function | MediumTest | Level1)
1594 {
1595 auto smsNwPolicyManager = std::make_shared<SmsNetworkPolicyManager>(INVALID_SLOTID);
1596 AppExecFwk::InnerEvent::Pointer event = AppExecFwk::InnerEvent::Get(RadioEvent::RADIO_ON);
1597 smsNwPolicyManager->ProcessEvent(event);
1598 event = AppExecFwk::InnerEvent::Get(RadioEvent::RADIO_RIL_ADAPTER_HOST_DIED);
1599 smsNwPolicyManager->ProcessEvent(event);
1600 smsNwPolicyManager->HandleFactoryReset();
1601
1602 auto smsService = DelayedSingleton<SmsService>::GetInstance();
1603 EXPECT_EQ(smsService->OnRilAdapterHostDied(INVALID_SLOTID), TELEPHONY_ERR_LOCAL_PTR_NULL);
1604 smsService->slotSmsInterfaceManagerMap_[INVALID_SLOTID] = std::make_shared<SmsInterfaceManager>(INVALID_SLOTID);
1605 EXPECT_EQ(smsService->OnRilAdapterHostDied(INVALID_SLOTID), TELEPHONY_ERR_SUCCESS);
1606 }
1607
1608 /**
1609 * @tc.number Telephony_SmsMmsGtest_SmsPersistHelper_0001
1610 * @tc.name Test SmsService
1611 * @tc.desc Function test
1612 */
1613 HWTEST_F(BranchSmsTest, SmsPersistHelper_0001, Function | MediumTest | Level1)
1614 {
1615 AccessMmsToken token;
1616 auto smsPersistHelper = DelayedSingleton<SmsPersistHelper>::GetInstance();
1617 DataShare::DataSharePredicates predicates;
1618 uint16_t maxGroupId = 0;
1619 smsPersistHelper->QueryMaxGroupId(predicates, maxGroupId);
1620 EXPECT_GE(maxGroupId, 0);
1621
1622 std::string num = "";
1623 std::string countryCode = "123";
1624 i18n::phonenumbers::PhoneNumberUtil::PhoneNumberFormat formatInfo =
1625 i18n::phonenumbers::PhoneNumberUtil::PhoneNumberFormat::NATIONAL;
1626 std::string formatNum = "";
1627 smsPersistHelper->FormatSmsNumber(num, countryCode, formatInfo, formatNum);
1628 num = "123";
1629 smsPersistHelper->FormatSmsNumber(num, countryCode, formatInfo, formatNum);
1630 formatNum = "123";
1631 int32_t value = smsPersistHelper->FormatSmsNumber(num, countryCode, formatInfo, formatNum);
1632 EXPECT_GE(value, 0);
1633
1634 DataShare::DataShareValuesBucket bucket;
1635 std::string id = "1";
1636 bucket.Put(SLOT_ID, id);
1637 uint16_t dataBaseId = 0;
1638 smsPersistHelper->Insert(bucket, dataBaseId);
1639 smsPersistHelper->Insert(TABLE_URL, bucket);
1640 uint16_t sessionId = 0;
1641 uint16_t messageCount = 0;
1642 smsPersistHelper->QuerySession(predicates, sessionId, messageCount);
1643 EXPECT_GE(sessionId, 0);
1644
1645 smsPersistHelper->Update(predicates, bucket);
1646 std::vector<SmsReceiveIndexer> indexers;
1647 smsPersistHelper->Query(predicates, indexers);
1648 smsPersistHelper->Delete(predicates);
1649 std::string phoneNum = "";
1650 smsPersistHelper->QueryBlockPhoneNumber(phoneNum);
1651 smsPersistHelper->UpdateContact(phoneNum);
1652 EXPECT_GE(phoneNum.size(), 0);
1653
1654 phoneNum = "13866666666";
1655 smsPersistHelper->QueryBlockPhoneNumber(phoneNum);
1656 smsPersistHelper->UpdateContact(phoneNum);
1657 int32_t rawCountId = 1;
1658 int32_t contactedCount = 1;
1659 smsPersistHelper->QueryContactedCount(phoneNum, rawCountId, contactedCount);
1660 EXPECT_TRUE(smsPersistHelper != nullptr);
1661 }
1662
1663 /**
1664 * @tc.number Telephony_SmsMmsGtest_SmsServiceManagerClient_0001
1665 * @tc.name Test SmsServiceManagerClient
1666 * @tc.desc Function test
1667 */
1668 HWTEST_F(BranchSmsTest, SmsServiceManagerClient_0001, Function | MediumTest | Level1)
1669 {
1670 int32_t slotId = 0;
1671 std::u16string desAddr = u"";
1672 sptr<ISendShortMessageCallback> sendCallback;
1673 sptr<IDeliveryShortMessageCallback> deliveryCallback;
1674 auto smsServiceManagerClient = DelayedSingleton<SmsServiceManagerClient>::GetInstance();
1675 int32_t ret = 0;
1676 ret = smsServiceManagerClient->SetDefaultSmsSlotId(slotId);
1677 EXPECT_GE(ret, 0);
1678 smsServiceManagerClient->GetDefaultSmsSlotId();
1679 smsServiceManagerClient->GetDefaultSmsSimId(slotId);
1680 smsServiceManagerClient->SendMessage(slotId, desAddr, desAddr, desAddr, sendCallback, deliveryCallback);
1681 uint16_t port = 1;
1682 uint8_t *data = nullptr;
1683 smsServiceManagerClient->SendMessage(slotId, desAddr, desAddr, port, data, port, sendCallback, deliveryCallback);
1684 std::u16string scAddr = u"1234";
1685 smsServiceManagerClient->SetScAddress(slotId, scAddr);
1686 smsServiceManagerClient->GetScAddress(slotId, scAddr);
1687 std::u16string smsc = u"test";
1688 smsServiceManagerClient->AddSimMessage(
1689 slotId, smsc, smsc, ISmsServiceInterface::SimMessageStatus::SIM_MESSAGE_STATUS_UNREAD);
1690 uint32_t msgIndex = 1;
1691 smsServiceManagerClient->DelSimMessage(slotId, msgIndex);
1692 smsServiceManagerClient->UpdateSimMessage(
1693 slotId, msgIndex, ISmsServiceInterface::SimMessageStatus::SIM_MESSAGE_STATUS_UNREAD, smsc, smsc);
1694 std::vector<ShortMessage> messages;
1695 smsServiceManagerClient->GetAllSimMessages(slotId, messages);
1696 bool enable = true;
1697 uint8_t ranType = 1;
1698 smsServiceManagerClient->SetCBConfig(slotId, enable, msgIndex, msgIndex, ranType);
1699 smsServiceManagerClient->SetImsSmsConfig(slotId, enable);
1700 std::vector<std::u16string> splitMessage;
1701 smsServiceManagerClient->SplitMessage(desAddr, splitMessage);
1702 ISmsServiceInterface::SmsSegmentsInfo segInfo;
1703 smsServiceManagerClient->GetSmsSegmentsInfo(slotId, desAddr, enable, segInfo);
1704 smsServiceManagerClient->IsImsSmsSupported(slotId, enable);
1705 smsServiceManagerClient->GetImsShortMessageFormat(desAddr);
1706 smsServiceManagerClient->HasSmsCapability();
1707 std::string pdu = "";
1708 ShortMessage message;
1709 smsServiceManagerClient->CreateMessage(pdu, pdu, message);
1710 smsServiceManagerClient->GetBase64Encode(pdu, pdu);
1711 smsServiceManagerClient->GetBase64Decode(pdu, pdu);
1712 uint32_t charset = 1;
1713 smsServiceManagerClient->GetEncodeStringFunc(pdu, charset, charset, pdu);
1714 EXPECT_TRUE(smsServiceManagerClient != nullptr);
1715 }
1716
1717 /**
1718 * @tc.number Telephony_SmsMmsGtest_GsmUserDataPdu_0001
1719 * @tc.name Test GsmUserDataPdu
1720 * @tc.desc Function test
1721 */
1722 HWTEST_F(BranchSmsTest, GsmUserDataPdu_0001, Function | MediumTest | Level1)
1723 {
1724 const struct SmsUDPackage *userData = nullptr;
1725 struct SmsUDPackage *pUserData = nullptr;
1726 auto encodeBuffer = std::make_shared<SmsWriteBuffer>();
1727 auto gsmUserDataPdu = DelayedSingleton<GsmUserDataPdu>::GetInstance();
1728 std::string str;
1729 gsmUserDataPdu->EncodeUserDataPdu(*encodeBuffer, userData, DataCodingScheme::DATA_CODING_7BIT, str);
1730 auto deBuffer = std::make_shared<SmsReadBuffer>(SMS_READ_PDU);
1731 gsmUserDataPdu->DecodeUserDataPdu(*deBuffer, true, DataCodingScheme::DATA_CODING_7BIT, pUserData);
1732 SmsTpud *pTPUD = new SmsTpud();
1733 gsmUserDataPdu->DecodeUserDataPdu(*deBuffer, true, DataCodingScheme::DATA_CODING_7BIT, pUserData, pTPUD);
1734 delete pTPUD;
1735 pTPUD = nullptr;
1736 pUserData = new SmsUDPackage();
1737 gsmUserDataPdu->ResetUserData(*pUserData);
1738 auto smsReadBuffer = std::make_shared<SmsReadBuffer>(SMS_READ_PDU);
1739 uint8_t udhl = 0;
1740 uint16_t i = 0;
1741 gsmUserDataPdu->GetHeaderCnt(*smsReadBuffer, pUserData, udhl, i);
1742 delete pUserData;
1743 pUserData = nullptr;
1744 SmsWriteBuffer buffer;
1745 uint8_t v = 1;
1746 buffer.WriteByte(v);
1747 SmsUDH header;
1748 header.udhType = UDH_CONCAT_16BIT;
1749 SmsUDH *pHeader = new SmsUDH();
1750 uint16_t headerLen = 0;
1751 auto decodeBuffer = std::make_shared<SmsReadBuffer>(SMS_READ_PDU);
1752 decodeBuffer->data_.reset(new uint8_t[DECODE_SIZE]());
1753 decodeBuffer->data_[0] = 0;
1754 decodeBuffer->data_[1] = EIGHT_BIT;
1755 decodeBuffer->data_[TWO_BIT] = FOUR_BIT;
1756 decodeBuffer->data_[DIGIT_LEN] = FIVE_BIT;
1757 decodeBuffer->data_[FOUR_BIT] = SIX_BIT;
1758 decodeBuffer->index_ = 0;
1759 gsmUserDataPdu->DecodeHeader(*decodeBuffer, *pHeader, headerLen);
1760 decodeBuffer->index_ = 1;
1761 gsmUserDataPdu->DecodeHeader(*decodeBuffer, *pHeader, headerLen);
1762 decodeBuffer->index_ = TWO_BIT;
1763 gsmUserDataPdu->DecodeHeader(*decodeBuffer, *pHeader, headerLen);
1764 decodeBuffer->index_ = DIGIT_LEN;
1765 gsmUserDataPdu->DecodeHeader(*decodeBuffer, *pHeader, headerLen);
1766 decodeBuffer->index_ = FOUR_BIT;
1767 gsmUserDataPdu->DecodeHeader(*decodeBuffer, *pHeader, headerLen);
1768 delete pHeader;
1769 pHeader = nullptr;
1770 EXPECT_TRUE(decodeBuffer != nullptr);
1771 EXPECT_TRUE(gsmUserDataPdu != nullptr);
1772 }
1773
1774 /**
1775 * @tc.number Telephony_SmsMmsGtest_GsmUserDataPdu_0002
1776 * @tc.name Test GsmUserDataPdu
1777 * @tc.desc Function test
1778 */
1779 HWTEST_F(BranchSmsTest, GsmUserDataPdu_0002, Function | MediumTest | Level1)
1780 {
1781 SmsUDH *pHeader = new SmsUDH();
1782 auto decodeBuffer = std::make_shared<SmsReadBuffer>(SMS_READ_PDU);
1783 auto gsmUserDataPdu = DelayedSingleton<GsmUserDataPdu>::GetInstance();
1784 uint8_t oneByte = UDH_ALTERNATE_REPLY_ADDRESS;
1785 gsmUserDataPdu->DecodeHeaderPartData(*decodeBuffer, *pHeader, oneByte);
1786 oneByte = UDH_SINGLE_SHIFT;
1787 gsmUserDataPdu->DecodeHeaderPartData(*decodeBuffer, *pHeader, oneByte);
1788 oneByte = UDH_LOCKING_SHIFT;
1789 gsmUserDataPdu->DecodeHeaderPartData(*decodeBuffer, *pHeader, oneByte);
1790 gsmUserDataPdu->DecodeHeaderConcat8Bit(*decodeBuffer, *pHeader);
1791 decodeBuffer->data_[0] = 0;
1792 gsmUserDataPdu->DecodeHeaderConcat8Bit(*decodeBuffer, *pHeader);
1793 decodeBuffer->index_ = 0;
1794 gsmUserDataPdu->DecodeHeaderConcat8Bit(*decodeBuffer, *pHeader);
1795 decodeBuffer->data_[1] = 1;
1796 decodeBuffer->index_ = 1;
1797 gsmUserDataPdu->DecodeHeaderConcat8Bit(*decodeBuffer, *pHeader);
1798 auto sixteenDecodeBuffer = std::make_shared<SmsReadBuffer>(SMS_READ_PDU);
1799 gsmUserDataPdu->DecodeHeaderConcat16Bit(*sixteenDecodeBuffer, *pHeader);
1800 gsmUserDataPdu->DecodeHeaderAppPort8Bit(*sixteenDecodeBuffer, *pHeader);
1801 sixteenDecodeBuffer->data_[0] = 0;
1802 gsmUserDataPdu->DecodeHeaderAppPort8Bit(*sixteenDecodeBuffer, *pHeader);
1803 sixteenDecodeBuffer->index_ = 0;
1804 gsmUserDataPdu->DecodeHeaderAppPort8Bit(*sixteenDecodeBuffer, *pHeader);
1805 decodeBuffer->data_[1] = 1;
1806 decodeBuffer->index_ = 1;
1807 EXPECT_TRUE(decodeBuffer != nullptr);
1808 gsmUserDataPdu->DecodeHeaderAppPort8Bit(*sixteenDecodeBuffer, *pHeader);
1809 auto appPortDecodeBuffer = std::make_shared<SmsReadBuffer>(SMS_READ_PDU);
1810 gsmUserDataPdu->DecodeHeaderAppPort16Bit(*appPortDecodeBuffer, *pHeader);
1811 gsmUserDataPdu->DecodeHeaderReplyAddress(*appPortDecodeBuffer, *pHeader);
1812 appPortDecodeBuffer->data_[0] = 0;
1813 gsmUserDataPdu->DecodeHeaderReplyAddress(*appPortDecodeBuffer, *pHeader);
1814 appPortDecodeBuffer->index_ = 0;
1815 gsmUserDataPdu->DecodeHeaderReplyAddress(*appPortDecodeBuffer, *pHeader);
1816 appPortDecodeBuffer->data_[1] = 1;
1817 appPortDecodeBuffer->index_ = 1;
1818 EXPECT_TRUE(appPortDecodeBuffer != nullptr);
1819 gsmUserDataPdu->DecodeHeaderReplyAddress(*appPortDecodeBuffer, *pHeader);
1820 auto singleShiftDecodeBuffer = std::make_shared<SmsReadBuffer>(SMS_READ_PDU);
1821 gsmUserDataPdu->DecodeHeaderSingleShift(*singleShiftDecodeBuffer, *pHeader);
1822 gsmUserDataPdu->DecodeHeaderLockingShift(*singleShiftDecodeBuffer, *pHeader);
1823 gsmUserDataPdu->DecodeHeaderDefaultCase(*singleShiftDecodeBuffer, *pHeader);
1824 delete pHeader;
1825 pHeader = nullptr;
1826 EXPECT_TRUE(gsmUserDataPdu != nullptr);
1827 }
1828
1829 /**
1830 * @tc.number Telephony_SmsMmsGtest_GsmSmsSender_0002
1831 * @tc.name Test GsmSmsSender
1832 * @tc.desc Function test
1833 */
1834 HWTEST_F(BranchSmsTest, GsmSmsSender_0002, Function | MediumTest | Level1)
1835 {
1836 std::function<void(std::shared_ptr<SmsSendIndexer>)> sendRetryFun = nullptr;
1837 auto gsmSmsSender = std::make_shared<GsmSmsSender>(INVALID_SLOTID, sendRetryFun);
1838 GsmSimMessageParam smsData;
1839 smsData.refId = 1;
1840 smsData.smscPdu = SMS_READ_PDU;
1841 smsData.pdu = SMS_READ_PDU;
1842 const std::shared_ptr<SmsSendIndexer> indexer = nullptr;
1843 gsmSmsSender->SendImsSms(indexer, smsData);
1844 EXPECT_TRUE(gsmSmsSender != nullptr);
1845 }
1846
1847 /**
1848 * @tc.number Telephony_SmsMmsGtest_GsmSmsMessage_0003
1849 * @tc.name Test GsmSmsMessage
1850 * @tc.desc Function test
1851 */
1852 HWTEST_F(BranchSmsTest, GsmSmsMessage_0003, Function | MediumTest | Level1)
1853 {
1854 auto gsmSmsMessage = std::make_shared<GsmSmsMessage>();
1855 const std::string replyAddress = "";
1856 gsmSmsMessage->CalcReplyEncodeAddress(replyAddress);
1857 gsmSmsMessage->CalcReplyEncodeAddress(SMS_READ_PDU);
1858 gsmSmsMessage->CreateStatusReportSmsTpdu();
1859 gsmSmsMessage->IsSpecialMessage();
1860 gsmSmsMessage->GetIsSIMDataTypeDownload();
1861 gsmSmsMessage->GetIsTypeZeroInd();
1862 EXPECT_TRUE(gsmSmsMessage->GetGsm());
1863 gsmSmsMessage->GetIsSmsText();
1864 gsmSmsMessage->GetDestAddress();
1865 gsmSmsMessage->GetFullText();
1866 gsmSmsMessage->SetDestPort(INVALID_SLOTID);
1867 EXPECT_TRUE(gsmSmsMessage != nullptr);
1868 }
1869
1870 /**
1871 * @tc.number Telephony_SmsMmsGtest_GsmSmsParamDecode_0001
1872 * @tc.name Test GsmSmsParamDecode
1873 * @tc.desc Function test
1874 */
1875 HWTEST_F(BranchSmsTest, GsmSmsParamDecode_0001, Function | MediumTest | Level1)
1876 {
1877 auto gsmSmsParamDecode = std::make_shared<GsmSmsParamDecode>();
1878 auto buffer = std::make_shared<SmsReadBuffer>(SMS_READ_PDU);
1879 AddressNumber *pAddress = new AddressNumber();
1880 uint8_t bcdLen = 1;
1881 uint8_t addrLen = 1;
1882 gsmSmsParamDecode->DecodeAddressAlphaNum(*buffer, pAddress, bcdLen, addrLen);
1883 SmsDcs *smsDcs = nullptr;
1884 gsmSmsParamDecode->DecodeDcsClassGroupPdu(bcdLen, smsDcs);
1885 gsmSmsParamDecode->DecodeDcsDiscardGroupPdu(bcdLen, smsDcs);
1886 gsmSmsParamDecode->DecodeDcsStoreGsmGroupPdu(bcdLen, smsDcs);
1887 gsmSmsParamDecode->DecodeDcsStoreUCS2GroupPdu(bcdLen, smsDcs);
1888 gsmSmsParamDecode->DecodeDcsUnknownGroupPdu(bcdLen, smsDcs);
1889 enum SmsIndicatorType ret = gsmSmsParamDecode->GetMsgIndicatorType(bcdLen);
1890 EXPECT_GE(ret, 0);
1891 SmsDcs *mwiTypeSmsDcs = new SmsDcs();
1892 gsmSmsParamDecode->GetMwiType(bcdLen, *mwiTypeSmsDcs);
1893 EXPECT_TRUE(gsmSmsParamDecode != nullptr);
1894 int32_t slotId = 0;
1895 auto gsmSmsCbHandler = std::make_shared<GsmSmsCbHandler>(slotId);
1896 std::shared_ptr<GsmCbCodec> cbMessage = nullptr;
1897 gsmSmsCbHandler->RemoveCbMessageFromList(cbMessage);
1898 delete pAddress;
1899 pAddress = nullptr;
1900 delete mwiTypeSmsDcs;
1901 mwiTypeSmsDcs = nullptr;
1902 EXPECT_TRUE(gsmSmsCbHandler != nullptr);
1903 auto smsReceiveManager = std::make_shared<SmsReceiveManager>(slotId);
1904 EXPECT_TRUE(smsReceiveManager != nullptr);
1905 smsReceiveManager->Init();
1906 EXPECT_TRUE(smsReceiveManager->gsmSmsReceiveHandler_ != nullptr);
1907 smsReceiveManager->gsmSmsReceiveHandler_->CheckSmsSupport();
1908 std::shared_ptr<SmsBaseMessage> smsBaseMessage = nullptr;
1909 smsReceiveManager->gsmSmsReceiveHandler_->HandleNormalSmsByType(smsBaseMessage);
1910 EXPECT_TRUE(smsReceiveManager->gsmSmsReceiveHandler_ != nullptr);
1911 }
1912
1913 /**
1914 * @tc.number Telephony_SmsMmsGtest_SmsService_0004
1915 * @tc.name Test SmsService
1916 * @tc.desc Function test
1917 */
1918 HWTEST_F(BranchSmsTest, SmsService_0004, Function | MediumTest | Level1)
1919 {
1920 int32_t slotId = 0;
1921 std::u16string desAddr = u"";
1922 sptr<ISendShortMessageCallback> sendCallback;
1923 sptr<IDeliveryShortMessageCallback> deliveryCallback;
1924 auto smsService = DelayedSingleton<SmsService>::GetInstance();
1925 AccessMmsToken token;
1926 smsService->SendMessage(slotId, desAddr, desAddr, desAddr, sendCallback, deliveryCallback);
1927 uint16_t port = 1;
1928 uint8_t *data = nullptr;
1929 smsService->SendMessage(slotId, desAddr, desAddr, port, data, port, sendCallback, deliveryCallback);
1930 slotId = -1;
1931 desAddr = u"test";
1932 smsService->SendMessage(slotId, desAddr, desAddr, desAddr, sendCallback, deliveryCallback);
1933 smsService->SendMessage(slotId, desAddr, desAddr, port, data, port, sendCallback, deliveryCallback);
1934 slotId = 0;
1935 std::string telephone = "13888888888";
1936 smsService->InsertSessionAndDetail(slotId, telephone, telephone);
1937 bool isSupported = false;
1938 slotId = -1;
1939 smsService->IsImsSmsSupported(slotId, isSupported);
1940 std::u16string format = u"";
1941 smsService->GetImsShortMessageFormat(format);
1942 smsService->HasSmsCapability();
1943 int32_t setSmscRes = 0;
1944 setSmscRes = smsService->SetSmscAddr(slotId, desAddr);
1945 desAddr = u" test";
1946 string sca = StringUtils::ToUtf8(desAddr);
1947 smsService->TrimSmscAddr(sca);
1948 desAddr = u"test ";
1949 sca = StringUtils::ToUtf8(desAddr);
1950 smsService->TrimSmscAddr(sca);
1951 int32_t smscRes = 0;
1952 smscRes = smsService->GetSmscAddr(slotId, desAddr);
1953 EXPECT_GE(setSmscRes, TELEPHONY_ERR_SLOTID_INVALID);
1954 EXPECT_GE(smscRes, TELEPHONY_ERR_ARGUMENT_INVALID);
1955 EXPECT_TRUE(smsService != nullptr);
1956 }
1957
1958 /**
1959 * @tc.number Telephony_SmsMmsGtest_SmsService_0005
1960 * @tc.name Test SmsService
1961 * @tc.desc Function test
1962 */
1963 HWTEST_F(BranchSmsTest, SmsService_0005, Function | MediumTest | Level1)
1964 {
1965 int32_t slotId = 0;
1966 std::u16string desAddr = u"";
1967 sptr<ISendShortMessageCallback> sendCallback;
1968 sptr<IDeliveryShortMessageCallback> deliveryCallback;
1969 auto smsService = DelayedSingleton<SmsService>::GetInstance();
1970 AccessMmsToken token;
1971 smsService->AddSimMessage(
1972 slotId, desAddr, desAddr, ISmsServiceInterface::SimMessageStatus::SIM_MESSAGE_STATUS_UNREAD);
1973 uint32_t msgIndex = 1;
1974 smsService->DelSimMessage(slotId, msgIndex);
1975 smsService->UpdateSimMessage(
1976 slotId, msgIndex, ISmsServiceInterface::SimMessageStatus::SIM_MESSAGE_STATUS_UNREAD, desAddr, desAddr);
1977 smsService->CheckSimMessageIndexValid(slotId, msgIndex);
1978 uint32_t fromMsgId = 1;
1979 uint32_t toMsgId = 1;
1980 uint8_t netType = 1;
1981 smsService->SetCBConfig(slotId, true, fromMsgId, toMsgId, netType);
1982 int32_t enable = 1;
1983 smsService->SetImsSmsConfig(slotId, enable);
1984 smsService->SetDefaultSmsSlotId(slotId);
1985 smsService->GetDefaultSmsSlotId();
1986 smsService->GetDefaultSmsSimId(slotId);
1987 std::u16string message = u"";
1988 ISmsServiceInterface::SmsSegmentsInfo info;
1989 std::vector<std::u16string> splitMessage;
1990 bool text = true;
1991 int32_t splitRes = 0;
1992 int32_t smsRes = 0;
1993 splitRes = smsService->SplitMessage(message, splitMessage);
1994 smsRes = smsService->GetSmsSegmentsInfo(slotId, message, text, info);
1995 message = u"text";
1996 splitRes = smsService->SplitMessage(message, splitMessage);
1997 smsRes = smsService->GetSmsSegmentsInfo(slotId, message, text, info);
1998 smsService->GetServiceRunningState();
1999 smsService->GetEndTime();
2000 smsService->GetSpendTime();
2001 EXPECT_GE(splitRes, TELEPHONY_ERR_ARGUMENT_INVALID);
2002 EXPECT_GE(smsRes, TELEPHONY_ERR_ARGUMENT_INVALID);
2003 EXPECT_TRUE(smsService != nullptr);
2004 }
2005
2006 /**
2007 * @tc.number Telephony_SmsMmsGtest_SmsPersistHelper_0002
2008 * @tc.name Test SmsPersistHelper
2009 * @tc.desc Function test
2010 */
2011 HWTEST_F(BranchSmsTest, SmsPersistHelper_0002, Function | MediumTest | Level1)
2012 {
2013 std::string formatNum = "";
2014 auto smsPersistHelper = DelayedSingleton<SmsPersistHelper>::GetInstance();
2015 std::string num = "";
2016 std::string cbnNumTemp = "";
2017 cbnNumTemp.assign(CBN_NUM);
2018 num = cbnNumTemp.substr(DIGIT_LEN, NUM_LENGTH);
2019 smsPersistHelper->CbnFormat(num, i18n::phonenumbers::PhoneNumberUtil::PhoneNumberFormat::NATIONAL, formatNum);
2020 EXPECT_TRUE(formatNum == num);
2021 smsPersistHelper->CbnFormat(num, i18n::phonenumbers::PhoneNumberUtil::PhoneNumberFormat::INTERNATIONAL, formatNum);
2022 EXPECT_TRUE(formatNum == cbnNumTemp);
2023 smsPersistHelper->CbnFormat(
2024 cbnNumTemp, i18n::phonenumbers::PhoneNumberUtil::PhoneNumberFormat::INTERNATIONAL, formatNum);
2025 EXPECT_TRUE(formatNum == cbnNumTemp);
2026 smsPersistHelper->CbnFormat(
2027 cbnNumTemp, i18n::phonenumbers::PhoneNumberUtil::PhoneNumberFormat::NATIONAL, formatNum);
2028 EXPECT_TRUE(formatNum == num);
2029 }
2030
2031 /**
2032 * @tc.number Telephony_SmsMmsGtest_SmsNetworkPolicyManager_0001
2033 * @tc.name Test SmsNetworkPolicyManager
2034 * @tc.desc Function test
2035 */
2036 HWTEST_F(BranchSmsTest, SmsNetworkPolicyManager_0001, Function | MediumTest | Level1)
2037 {
2038 auto smsNetworkPolicyManager = std::make_shared<SmsNetworkPolicyManager>(INVALID_SLOTID);
2039 smsNetworkPolicyManager->IsImsNetDomain();
2040 smsNetworkPolicyManager->GetVoiceServiceState();
2041 smsNetworkPolicyManager->NetworkRegister(nullptr);
2042 auto smsBaseMessage = std::make_shared<GsmSmsMessage>();
2043 smsBaseMessage->GetSmscAddr();
2044 smsBaseMessage->GetRawUserData();
2045 smsBaseMessage->GetRawWapPushUserData();
2046 smsBaseMessage->IsReplaceMessage();
2047 smsBaseMessage->IsCphsMwi();
2048 smsBaseMessage->IsMwiNotStore();
2049 smsBaseMessage->GetStatus();
2050 smsBaseMessage->IsSmsStatusReportMessage();
2051 smsBaseMessage->HasReplyPath();
2052 smsBaseMessage->GetMsgRef();
2053 smsBaseMessage->SetIndexOnSim(0);
2054 smsBaseMessage->GetIndexOnSim();
2055 auto smsInterfaceManager = std::make_shared<SmsInterfaceManager>(INVALID_SLOTID);
2056 smsInterfaceManager->DelSimMessage(0);
2057 auto smsWapPushBuffer = std::make_shared<SmsWapPushBuffer>();
2058 smsWapPushBuffer->DecodeExtensionMedia();
2059 smsWapPushBuffer->DecodeConstrainedEncoding();
2060 smsWapPushBuffer->MarkPosition();
2061 smsWapPushBuffer->UnMarkPosition();
2062 std::shared_ptr<CdmaSmsMessage> cdmaSmsMessage = std::make_shared<CdmaSmsMessage>();
2063 cdmaSmsMessage->GetCbInfo();
2064 cdmaSmsMessage->GetCMASResponseType();
2065 cdmaSmsMessage->GetSpecialSmsInd();
2066 cdmaSmsMessage->GetProtocolId();
2067 cdmaSmsMessage->IsReplaceMessage();
2068 cdmaSmsMessage->IsCphsMwi();
2069 EXPECT_TRUE(smsNetworkPolicyManager != nullptr);
2070 EXPECT_TRUE(smsBaseMessage != nullptr);
2071 EXPECT_TRUE(smsInterfaceManager != nullptr);
2072 EXPECT_TRUE(cdmaSmsMessage != nullptr);
2073 }
2074
2075 /**
2076 * @tc.number Telephony_SmsMmsGtest_SmsNetworkPolicyManager_0004
2077 * @tc.name Test SmsNetworkPolicyManager
2078 * @tc.desc Function test
2079 */
2080 HWTEST_F(BranchSmsTest, SmsNetworkPolicyManager_0004, Function | MediumTest | Level1)
2081 {
2082 auto smsMiscManager = std::make_shared<SmsMiscManager>(INVALID_SLOTID);
2083 smsMiscManager->GetRangeInfo();
2084 smsMiscManager->IsEmpty();
2085 std::shared_ptr<SmsReceiveIndexer> indexer = std::make_shared<SmsReceiveIndexer>();
2086 indexer->SetVisibleAddress(CBN_NUM);
2087 indexer->SetMsgCount(0);
2088 indexer->SetMsgSeqId(0);
2089 indexer->SetOriginatingAddress(CBN_NUM);
2090 indexer->SetIsCdmaWapPdu(false);
2091 indexer->GetIsCdmaWapPdu();
2092 indexer->SetIsCdma(false);
2093 indexer->SetDestPort(0);
2094 indexer->SetTimestamp(0);
2095 indexer->SetPdu(PDU);
2096 indexer->SetRawWapPushUserData(CBN_NUM);
2097 const sptr<ISendShortMessageCallback> sendCallback =
2098 iface_cast<ISendShortMessageCallback>(new SendShortMessageCallbackStub());
2099 const sptr<IDeliveryShortMessageCallback> deliveryCallback =
2100 iface_cast<IDeliveryShortMessageCallback>(new DeliveryShortMessageCallbackStub());
2101 std::shared_ptr<SmsSendIndexer> smsIndexer =
2102 std::make_shared<SmsSendIndexer>(CBN_NUM, CBN_NUM, CBN_NUM, sendCallback, deliveryCallback);
2103 smsIndexer->SetEncodeSmca(PDU);
2104 smsIndexer->SetText(CBN_NUM);
2105 smsIndexer->SetDeliveryCallback(deliveryCallback);
2106 smsIndexer->SetSendCallback(sendCallback);
2107 smsIndexer->SetDestPort(0);
2108 smsIndexer->SetDestAddr(CBN_NUM);
2109 smsIndexer->SetSmcaAddr(CBN_NUM);
2110 smsIndexer->GetIsText();
2111 smsIndexer->GetErrorCode();
2112 smsIndexer->SetData(PDU);
2113 smsIndexer->SetAckPdu(PDU);
2114 smsIndexer->GetAckPdu();
2115 smsIndexer->SetMsgRefId64Bit(0);
2116 smsIndexer->SetIsConcat(true);
2117 EXPECT_TRUE(smsMiscManager != nullptr);
2118 EXPECT_TRUE(indexer != nullptr);
2119 EXPECT_TRUE(sendCallback != nullptr);
2120 EXPECT_TRUE(deliveryCallback != nullptr);
2121 EXPECT_TRUE(smsIndexer != nullptr);
2122 }
2123 } // namespace Telephony
2124 } // namespace OHOS
2125