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