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