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