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 <gmock/gmock.h>
20 #include <random>
21 #include "cdma_sms_message.h"
22 #include "delivery_short_message_callback_stub.h"
23 #include "gtest/gtest.h"
24 #include "gsm_sms_tpdu_decode.h"
25 #include "gsm_sms_param_decode.h"
26 #include "gsm_sms_tpdu_encode.h"
27 #include "gsm_user_data_pdu.h"
28 #include "mock/mock_data_share_helper.h"
29 #include "mock/mock_data_share_result_set.h"
30 #include "radio_event.h"
31 #include "send_short_message_callback_stub.h"
32 #include "sms_broadcast_subscriber_receiver.h"
33 #include "sms_hisysevent.h"
34 #include "sms_misc_manager.h"
35 #include "sms_mms_gtest.h"
36 #include "sms_network_policy_manager.h"
37 #include "sms_service.h"
38 #include "sms_persist_helper.h"
39 #include "system_ability_definition.h"
40
41 namespace OHOS {
42 namespace Telephony {
43 using namespace testing::ext;
44 using ::testing::Invoke;
45 using ::testing::Return;
46 using ::testing::_;
47
48 namespace {
49 const std::string TEST_SOURCE_DATA = "srcData";
50 const std::string SMS_ADDR_ONE = "";
51 const std::string SMS_ADDR_TWO = " ";
52 const std::string SMS_ADDR_THREE = " 123 ";
53 const std::string SMS_ADDR_FOUR = "1 23";
54 const std::string SMS_ADDR_FIVE = " a 123 ";
55 const std::string SEND_MMS_FILE_URL = "1,2,";
56 const std::string VNET_MMSC = "http://mmsc.vnet.mobi";
57 static constexpr uint8_t MAX_GSM_7BIT_DATA_LEN = 160;
58 static constexpr uint8_t MAX_SMSC_LEN = 20;
59 } // namespace
60
61 class BranchSmsPartTest : public testing::Test {
62 public:
63 static void SetUpTestCase();
64 static void TearDownTestCase();
65 void SetUp();
66 void TearDown();
67 };
SetUpTestCase()68 void BranchSmsPartTest::SetUpTestCase() {}
69
70 constexpr uint32_t EVENT_RELEASE_DATA_SHARE_HELPER = 10000;
TearDownTestCase()71 void BranchSmsPartTest::TearDownTestCase()
72 {
73 DelayedSingleton<SmsPersistHelper>::GetInstance()->RemoveEvent(EVENT_RELEASE_DATA_SHARE_HELPER);
74 }
75
SetUp()76 void BranchSmsPartTest::SetUp() {}
77
TearDown()78 void BranchSmsPartTest::TearDown() {}
79
80 /**
81 * @tc.number Telephony_SmsMmsGtest_SmsInterfaceStub_0001
82 * @tc.name Test SmsInterfaceStub
83 * @tc.desc Function test
84 */
85 HWTEST_F(BranchSmsPartTest, SmsInterfaceStub_0001, Function | MediumTest | Level1)
86 {
87 AccessMmsToken token;
88 int32_t slotId = 0;
89 MessageParcel dataParcel;
90 dataParcel.WriteInt32(slotId);
91 dataParcel.WriteBuffer(TEST_SOURCE_DATA.c_str(), TEST_SOURCE_DATA.size());
92 dataParcel.RewindRead(0);
93 MessageParcel replyParcel;
94 uint32_t code = 0;
95 MessageOption option(MessageOption::TF_SYNC);
96 DelayedSingleton<SmsService>::GetInstance()->OnRemoteRequest(code, dataParcel, replyParcel, option);
97 DelayedSingleton<SmsService>::GetInstance()->OnSendSmsTextRequest(dataParcel, replyParcel, option);
98 DelayedSingleton<SmsService>::GetInstance()->OnSendSmsTextWithoutSaveRequest(dataParcel, replyParcel, option);
99 DelayedSingleton<SmsService>::GetInstance()->OnSendSmsDataRequest(dataParcel, replyParcel, option);
100 DelayedSingleton<SmsService>::GetInstance()->OnGetSmscAddr(dataParcel, replyParcel, option);
101 DelayedSingleton<SmsService>::GetInstance()->OnAddSimMessage(dataParcel, replyParcel, option);
102 DelayedSingleton<SmsService>::GetInstance()->OnUpdateSimMessage(dataParcel, replyParcel, option);
103 DelayedSingleton<SmsService>::GetInstance()->OnGetAllSimMessages(dataParcel, replyParcel, option);
104 DelayedSingleton<SmsService>::GetInstance()->OnSplitMessage(dataParcel, replyParcel, option);
105 DelayedSingleton<SmsService>::GetInstance()->OnCreateMessage(dataParcel, replyParcel, option);
106 DelayedSingleton<SmsService>::GetInstance()->OnGetBase64Encode(dataParcel, replyParcel, option);
107 DelayedSingleton<SmsService>::GetInstance()->OnGetBase64Decode(dataParcel, replyParcel, option);
108 DelayedSingleton<SmsService>::GetInstance()->OnGetEncodeStringFunc(dataParcel, replyParcel, option);
109 DelayedSingleton<SmsService>::GetInstance()->OnGetSmsSegmentsInfo(dataParcel, replyParcel, option);
110
111 MessageParcel sendTextParcel;
112 sendTextParcel.WriteInt32(0);
113 sendTextParcel.WriteString16(Str8ToStr16(TEST_SOURCE_DATA));
114 sendTextParcel.WriteString16(Str8ToStr16(TEST_SOURCE_DATA));
115 sendTextParcel.WriteString16(Str8ToStr16(TEST_SOURCE_DATA));
116 sendTextParcel.WriteString(TEST_SOURCE_DATA);
117 DelayedSingleton<SmsService>::GetInstance()->OnSendSmsTextRequest(sendTextParcel, replyParcel, option);
118 sendTextParcel.WriteInt32(-1);
119 DelayedSingleton<SmsService>::GetInstance()->OnSendSmsTextRequest(sendTextParcel, replyParcel, option);
120 int32_t result = replyParcel.ReadInt32();
121 EXPECT_GE(result, 0);
122
123 MessageParcel sendDataParcel;
124 dataParcel.WriteInt32(0);
125 dataParcel.WriteString16(Str8ToStr16(TEST_SOURCE_DATA));
126 dataParcel.WriteString16(Str8ToStr16(TEST_SOURCE_DATA));
127 dataParcel.WriteInt16(0);
128 dataParcel.WriteInt16(TEST_SOURCE_DATA.size());
129 dataParcel.WriteRawData(TEST_SOURCE_DATA.c_str(), TEST_SOURCE_DATA.size());
130 DelayedSingleton<SmsService>::GetInstance()->OnSendSmsDataRequest(dataParcel, replyParcel, option);
131 sendTextParcel.WriteInt32(-1);
132 DelayedSingleton<SmsService>::GetInstance()->OnSendSmsDataRequest(dataParcel, replyParcel, option);
133 result = replyParcel.ReadInt32();
134 EXPECT_GE(result, -1);
135 }
136
137 /**
138 * @tc.number Telephony_SmsMmsGtest_SmsInterfaceStub_0002
139 * @tc.name Test SmsInterfaceStub
140 * @tc.desc Function test
141 */
142 HWTEST_F(BranchSmsPartTest, SmsInterfaceStub_0002, Function | MediumTest | Level1)
143 {
144 std::u16string desAddr = Str8ToStr16(SMS_ADDR_ONE);
145 DelayedSingleton<SmsService>::GetInstance()->RemoveSpacesInDesAddr(desAddr);
146 EXPECT_GE(desAddr.size(), 0);
147 desAddr = Str8ToStr16(SMS_ADDR_TWO);
148 DelayedSingleton<SmsService>::GetInstance()->RemoveSpacesInDesAddr(desAddr);
149 EXPECT_GE(desAddr.size(), 0);
150 desAddr = Str8ToStr16(SMS_ADDR_THREE);
151 DelayedSingleton<SmsService>::GetInstance()->RemoveSpacesInDesAddr(desAddr);
152 EXPECT_GE(desAddr.size(), 0);
153 desAddr = Str8ToStr16(SMS_ADDR_FOUR);
154 DelayedSingleton<SmsService>::GetInstance()->RemoveSpacesInDesAddr(desAddr);
155 EXPECT_GE(desAddr.size(), 0);
156 desAddr = Str8ToStr16(SMS_ADDR_FIVE);
157 DelayedSingleton<SmsService>::GetInstance()->RemoveSpacesInDesAddr(desAddr);
158 EXPECT_GE(desAddr.size(), 0);
159
160 MessageParcel setSmscParcel;
161 MessageParcel replyParcel;
162 MessageOption option(MessageOption::TF_SYNC);
163 setSmscParcel.WriteInt32(0);
164 setSmscParcel.WriteString16(Str8ToStr16(TEST_SOURCE_DATA));
165 DelayedSingleton<SmsService>::GetInstance()->OnSetSmscAddr(setSmscParcel, replyParcel, option);
166 MessageParcel getSmscParcel;
167 getSmscParcel.WriteInt32(0);
168 DelayedSingleton<SmsService>::GetInstance()->OnGetSmscAddr(getSmscParcel, replyParcel, option);
169 DelayedSingleton<SmsService>::GetInstance()->OnGetAllSimMessages(getSmscParcel, replyParcel, option);
170 DelayedSingleton<SmsService>::GetInstance()->OnSetDefaultSmsSlotId(getSmscParcel, replyParcel, option);
171 DelayedSingleton<SmsService>::GetInstance()->OnGetDefaultSmsSlotId(getSmscParcel, replyParcel, option);
172 int32_t result = replyParcel.ReadInt32();
173 EXPECT_GE(result, 0);
174
175 MessageParcel addSimMsgParcel;
176 addSimMsgParcel.WriteInt32(0);
177 addSimMsgParcel.WriteString16(Str8ToStr16(TEST_SOURCE_DATA));
178 addSimMsgParcel.WriteString16(Str8ToStr16(TEST_SOURCE_DATA));
179 addSimMsgParcel.WriteUint32(0);
180 DelayedSingleton<SmsService>::GetInstance()->OnAddSimMessage(addSimMsgParcel, replyParcel, option);
181 result = replyParcel.ReadInt32();
182 EXPECT_GE(result, 0);
183
184 MessageParcel delSimMsgParcel;
185 delSimMsgParcel.WriteInt32(0);
186 delSimMsgParcel.WriteUint32(0);
187 DelayedSingleton<SmsService>::GetInstance()->OnDelSimMessage(delSimMsgParcel, replyParcel, option);
188 result = replyParcel.ReadInt32();
189 EXPECT_GE(result, 0);
190 }
191
192 /**
193 * @tc.number Telephony_SmsMmsGtest_SmsInterfaceStub_0003
194 * @tc.name Test SmsInterfaceStub
195 * @tc.desc Function test
196 */
197 HWTEST_F(BranchSmsPartTest, SmsInterfaceStub_0003, Function | MediumTest | Level1)
198 {
199 MessageParcel simMsgParcel;
200 MessageParcel replyParcel;
201 MessageOption option(MessageOption::TF_SYNC);
202 simMsgParcel.WriteInt32(0);
203 simMsgParcel.WriteUint32(0);
204 simMsgParcel.WriteUint32(0);
205 simMsgParcel.WriteString16(Str8ToStr16(TEST_SOURCE_DATA));
206 simMsgParcel.WriteString16(Str8ToStr16(TEST_SOURCE_DATA));
207 DelayedSingleton<SmsService>::GetInstance()->OnUpdateSimMessage(simMsgParcel, replyParcel, option);
208 int32_t result = replyParcel.ReadInt32();
209 EXPECT_GE(result, 0);
210
211 MessageParcel SetImsSmsParcel;
212 SetImsSmsParcel.WriteInt32(0);
213 SetImsSmsParcel.WriteInt32(false);
214 DelayedSingleton<SmsService>::GetInstance()->OnSetImsSmsConfig(SetImsSmsParcel, replyParcel, option);
215 result = replyParcel.ReadInt32();
216 EXPECT_GE(result, 0);
217
218 MessageParcel splitMsgParcel;
219 splitMsgParcel.WriteString16(Str8ToStr16(TEST_SOURCE_DATA));
220 DelayedSingleton<SmsService>::GetInstance()->OnSplitMessage(splitMsgParcel, replyParcel, option);
221 DelayedSingleton<SmsService>::GetInstance()->OnGetBase64Encode(splitMsgParcel, replyParcel, option);
222 DelayedSingleton<SmsService>::GetInstance()->OnGetBase64Decode(splitMsgParcel, replyParcel, option);
223 result = replyParcel.ReadInt32();
224 EXPECT_GE(result, 0);
225
226 MessageParcel createMsgParcel;
227 createMsgParcel.WriteString(TEST_SOURCE_DATA);
228 createMsgParcel.WriteString(TEST_SOURCE_DATA);
229 DelayedSingleton<SmsService>::GetInstance()->OnCreateMessage(createMsgParcel, replyParcel, option);
230 result = replyParcel.ReadInt32();
231 EXPECT_GE(result, 0);
232
233 MessageParcel segmentParcel;
234 segmentParcel.WriteInt32(0);
235 segmentParcel.WriteString16(Str8ToStr16(TEST_SOURCE_DATA));
236 segmentParcel.WriteBool(false);
237 DelayedSingleton<SmsService>::GetInstance()->OnGetSmsSegmentsInfo(segmentParcel, replyParcel, option);
238 result = replyParcel.ReadInt32();
239 EXPECT_GE(result, 0);
240
241 MessageParcel formatParcel;
242 DelayedSingleton<SmsService>::GetInstance()->OnGetImsShortMessageFormat(formatParcel, replyParcel, option);
243 result = replyParcel.ReadInt32();
244 DelayedSingleton<SmsService>::GetInstance()->OnGetDefaultSmsSimId(formatParcel, replyParcel, option);
245 result = replyParcel.ReadInt32();
246 EXPECT_GE(result, 0);
247 }
248
249 /**
250 * @tc.number Telephony_SmsMmsGtest_SmsInterfaceStub_0004
251 * @tc.name Test SmsInterfaceStub
252 * @tc.desc Function test
253 */
254 HWTEST_F(BranchSmsPartTest, SmsInterfaceStub_0004, Function | MediumTest | Level1)
255 {
256 MessageParcel replyParcel;
257 MessageOption option(MessageOption::TF_SYNC);
258 MessageParcel cbConfigListMessage;
259 cbConfigListMessage.WriteInt32(1);
260 cbConfigListMessage.WriteInt32(257);
261 replyParcel.WriteInt32(111);
262 DelayedSingleton<SmsService>::GetInstance()->OnSetCBConfigList(cbConfigListMessage, replyParcel, option);
263 EXPECT_GE(replyParcel.ReadInt32(), 111);
264 }
265 /**
266 * @tc.number Telephony_SmsMmsGtest_SmsInterfaceManager_0001
267 * @tc.name Test SmsInterfaceManager
268 * @tc.desc Function test
269 */
270 HWTEST_F(BranchSmsPartTest, SmsInterfaceManager_0001, Function | MediumTest | Level1)
271 {
272 auto interfaceManager = std::make_shared<SmsInterfaceManager>(0);
273 ASSERT_NE(interfaceManager, nullptr);
274 interfaceManager->HasSmsCapability();
275 std::string dataStr = TEST_SOURCE_DATA;
276 auto callStub = iface_cast<ISendShortMessageCallback>(new SendShortMessageCallbackStub());
277 auto deliveryStub = iface_cast<IDeliveryShortMessageCallback>(new DeliveryShortMessageCallbackStub());
278 std::string emptyStr = "";
279 uint16_t dataBaseId = 0;
280 interfaceManager->TextBasedSmsDelivery(dataStr, dataStr, dataStr, callStub, deliveryStub, dataBaseId);
281 interfaceManager->TextBasedSmsDelivery(dataStr, emptyStr, dataStr, callStub, deliveryStub, dataBaseId);
282 interfaceManager->TextBasedSmsDelivery(dataStr, dataStr, emptyStr, callStub, deliveryStub, dataBaseId);
283 int32_t result = interfaceManager->TextBasedSmsDelivery(dataStr, emptyStr, emptyStr,
284 callStub, deliveryStub, dataBaseId);
285 EXPECT_GE(result, 0);
286
287 const uint8_t *data = reinterpret_cast<const uint8_t *>(dataStr.c_str());
288 interfaceManager->DataBasedSmsDelivery(dataStr, dataStr, 0, data, dataStr.size(), callStub, deliveryStub);
289 interfaceManager->DataBasedSmsDelivery(dataStr, emptyStr, 0, data, dataStr.size(), callStub, deliveryStub);
290 interfaceManager->DataBasedSmsDelivery(dataStr, dataStr, 0, nullptr, 0, callStub, deliveryStub);
291 interfaceManager->smsSendManager_ = nullptr;
292 interfaceManager->TextBasedSmsDelivery(dataStr, dataStr, dataStr, callStub, deliveryStub, dataBaseId);
293 result = interfaceManager->DataBasedSmsDelivery(dataStr, dataStr, 0, data, dataStr.size(), callStub, deliveryStub);
294 EXPECT_GE(result, 0);
295
296 interfaceManager->AddSimMessage(dataStr, dataStr, ISmsServiceInterface::SIM_MESSAGE_STATUS_UNREAD);
297 interfaceManager->UpdateSimMessage(0, ISmsServiceInterface::SIM_MESSAGE_STATUS_UNREAD, dataStr, dataStr);
298 std::vector<ShortMessage> message;
299 interfaceManager->GetAllSimMessages(message);
300 result = interfaceManager->SetSmscAddr(dataStr);
301 EXPECT_GE(result, 0);
302
303 std::u16string smsc;
304 interfaceManager->GetSmscAddr(smsc);
305 interfaceManager->SetCBConfig(false, 0, 1, 0);
306 std::vector<int32_t> messageIds1 = {4352, 4355, 4388, 4390};
307 interfaceManager->SetCBConfigList(messageIds1, 1);
308 std::vector<int32_t> messageIds2 = {4352, 4388, 4390};
309 interfaceManager->SetCBConfigList(messageIds2, 1);
310 result = interfaceManager->SetImsSmsConfig(0, false);
311 EXPECT_GE(result, 0);
312
313 interfaceManager->SetDefaultSmsSlotId(0);
314 interfaceManager->GetDefaultSmsSlotId();
315 int32_t simId;
316 interfaceManager->GetDefaultSmsSimId(simId);
317 std::vector<std::u16string> splitMessage;
318 result = interfaceManager->SplitMessage(dataStr, splitMessage);
319 EXPECT_GE(result, 0);
320 }
321
322 /**
323 * @tc.number Telephony_SmsMmsGtest_SmsInterfaceManager_0002
324 * @tc.name Test SmsInterfaceManager
325 * @tc.desc Function test
326 */
327 HWTEST_F(BranchSmsPartTest, SmsInterfaceManager_0002, Function | MediumTest | Level1)
328 {
329 auto interfaceManager = std::make_shared<SmsInterfaceManager>(0);
330 ASSERT_NE(interfaceManager, nullptr);
331 LengthInfo outInfo;
332 std::string dataStr = TEST_SOURCE_DATA;
333 interfaceManager->GetSmsSegmentsInfo(dataStr, false, outInfo);
334 bool isSupported = false;
335 interfaceManager->IsImsSmsSupported(0, isSupported);
336 std::u16string format;
337 interfaceManager->GetImsShortMessageFormat(format);
338 int32_t result = interfaceManager->HasSmsCapability();
339 EXPECT_GE(result, 0);
340
341 std::u16string mmsc = u"";
342 std::u16string data = u"";
343 std::u16string ua = u"";
344 std::u16string uaprof = u"";
345 interfaceManager->SendMms(mmsc, data, ua, uaprof);
346 result = interfaceManager->DownloadMms(mmsc, data, ua, uaprof);
347 EXPECT_GE(result, 0);
348
349 interfaceManager->smsMiscManager_ = nullptr;
350 interfaceManager->AddSimMessage(dataStr, dataStr, ISmsServiceInterface::SIM_MESSAGE_STATUS_UNREAD);
351 interfaceManager->UpdateSimMessage(0, ISmsServiceInterface::SIM_MESSAGE_STATUS_UNREAD, dataStr, dataStr);
352 std::vector<ShortMessage> message;
353 interfaceManager->GetAllSimMessages(message);
354 interfaceManager->SetSmscAddr(dataStr);
355 std::u16string smsc;
356 result = interfaceManager->GetSmscAddr(mmsc);
357 EXPECT_GE(result, 0);
358
359 interfaceManager->SetCBConfig(false, 0, 1, 0);
360 std::vector<int32_t> messageIds1 = {4352, 4355, 4388, 4390};
361 interfaceManager->SetCBConfigList(messageIds1, 1);
362 interfaceManager->SetImsSmsConfig(0, false);
363 interfaceManager->SetDefaultSmsSlotId(0);
364 interfaceManager->GetDefaultSmsSlotId();
365 int32_t simId;
366 result = interfaceManager->GetDefaultSmsSimId(simId);
367 EXPECT_GE(result, 0);
368
369 std::vector<std::u16string> splitMessage;
370 interfaceManager->SplitMessage(dataStr, splitMessage);
371 interfaceManager->GetSmsSegmentsInfo(dataStr, false, outInfo);
372 result = interfaceManager->IsImsSmsSupported(0, isSupported);
373 EXPECT_GE(result, 0);
374
375 interfaceManager->GetImsShortMessageFormat(format);
376 interfaceManager->mmsSendManager_ = nullptr;
377 interfaceManager->SendMms(mmsc, data, ua, uaprof);
378 interfaceManager->mmsReceiverManager_ = nullptr;
379 result = interfaceManager->DownloadMms(mmsc, data, ua, uaprof);
380 EXPECT_GE(result, 0);
381 }
382
383 /**
384 * @tc.number Telephony_SmsMmsGtest_SmsInterfaceManager_0003
385 * @tc.name Test SmsInterfaceManager
386 * @tc.desc Function test
387 */
388 HWTEST_F(BranchSmsPartTest, SmsInterfaceManager_0003, Function | MediumTest | Level1)
389 {
390 int32_t slotId = 0;
391 std::shared_ptr<SmsInterfaceManager> interfaceManager = std::make_shared<SmsInterfaceManager>(slotId);
392 interfaceManager->mmsSendManager_ = nullptr;
393 std::u16string mmsc(StringUtils::ToUtf16(VNET_MMSC));
394 std::u16string data(StringUtils::ToUtf16(SEND_MMS_FILE_URL));
395 std::u16string ua = u"112233";
396 std::u16string uaprof = u"112233";
397 int32_t sendMmsRet = interfaceManager->SendMms(mmsc, data, ua, uaprof);
398 interfaceManager->mmsReceiverManager_ = nullptr;
399 int32_t downloadMmsRet = interfaceManager->DownloadMms(mmsc, data, ua, uaprof);
400 EXPECT_GE(sendMmsRet, 0);
401 EXPECT_GE(downloadMmsRet, 0);
402
403 if (interfaceManager->smsSendManager_ == nullptr) {
404 interfaceManager->smsSendManager_ = std::make_unique<SmsSendManager>(0);
405 }
406 interfaceManager->smsSendManager_->Init();
407 interfaceManager->smsSendManager_->networkManager_->netWorkType_ = NetWorkType::NET_TYPE_GSM;
408 std::string specialText =
409 "ฏ็็็็็็็็็็็็็็็็็็็็็็็็็็็็็็็็็็็็็็็็็็็็็็็็็็็็็็็็็็็็็็็็็็็็็็็็็็็็็็็็็็็็";
410 std::vector<std::u16string> splitMessage;
411 interfaceManager->SplitMessage(specialText, splitMessage);
412 size_t segCount = 2;
413 size_t maxSegLen = 67;
414 ASSERT_EQ(splitMessage.size(), segCount);
415 EXPECT_EQ(splitMessage[0].size(), maxSegLen);
416
417 std::string normalText =
418 "这是一个普通的长短信，由数字0123456789、小写字母abcdefghijklmnopqrstuvwxyz、大写字母ABCDEFGHIJKLMNOPQRSTUVWXYZ和汉字组成";
419 splitMessage.clear();
420 interfaceManager->SplitMessage(normalText, splitMessage);
421 ASSERT_EQ(splitMessage.size(), segCount);
422 EXPECT_EQ(splitMessage[0].size(), maxSegLen);
423
424 std::string randomText;
425 size_t randomLength = 500;
426 randomText.reserve(randomLength);
427 std::random_device rd;
428 std::mt19937 gen(rd());
429 std::uniform_int_distribution<> dis(1, 0xFF);
430 for (size_t i = 0; i < randomLength; i++) {
431 randomText += static_cast<char>(dis(gen));
432 }
433 splitMessage.clear();
434 interfaceManager->SplitMessage(randomText, splitMessage);
435 EXPECT_GE(splitMessage.size(), 1);
436 }
437
438 /**
439 * @tc.number Telephony_SmsMmsGtest_SmsEmailMessage_0001
440 * @tc.name Test SmsEmailMessage
441 * @tc.desc Function test
442 */
443 HWTEST_F(BranchSmsPartTest, SmsEmailMessage_0001, Function | MediumTest | Level1)
444 {
445 auto gsmSmsMessage = std::make_shared<GsmSmsMessage>();
446 string pdu = ("07963258974152f204038105f300008022110232438a28e6a71b40c587eb7"
447 "076d9357eb7412f7d793a07ddeb6278794d07bde8d5391b246e93d3");
448 EXPECT_TRUE(gsmSmsMessage->CreateMessage(pdu) != nullptr);
449 auto message = gsmSmsMessage->CreateMessage(pdu);
450 EXPECT_EQ(message->GetEmailMessageBody(), "zeSs wubpekt /tUsl bmdi");
451 EXPECT_EQ(message->GetVisibleMessageBody(), "zeSs wubpekt /tUsl bmdi");
452 EXPECT_EQ(message->GetEmailAddress(), "fOn@Txauple.com");
453 EXPECT_EQ(message->GetVisibleOriginatingAddress(), "fOn@Txauple.com");
454 EXPECT_TRUE(message->IsEmail());
455
456 pdu = ("07913244457812f204038105f400007120103215358a29d6e71b503667db7076d935"
457 "7eb741af0d0a442fcfe8c13639bfe16d289bdee6b5f1813629");
458 EXPECT_TRUE(gsmSmsMessage->CreateMessage(pdu) != nullptr);
459 message = gsmSmsMessage->CreateMessage(pdu);
460 EXPECT_EQ(message->GetEmailMessageBody(), "{ te3tAmdy[^~\\] }");
461 EXPECT_EQ(message->GetVisibleMessageBody(), "{ te3tAmdy[^~\\] }");
462 EXPECT_EQ(message->GetEmailAddress(), "VOo@efYmple.com");
463 EXPECT_EQ(message->GetVisibleOriginatingAddress(), "VOo@efYmple.com");
464 EXPECT_TRUE(message->IsEmail());
465 }
466
467 /**
468 * @tc.number Telephony_SmsMmsGtest_SmsEmailMessage_0002
469 * @tc.name Test SmsEmailMessage
470 * @tc.desc Function test
471 */
472 HWTEST_F(BranchSmsPartTest, SmsEmailMessage_0002, Function | MediumTest | Level1)
473 {
474 auto gsmSmsMessage = std::make_shared<GsmSmsMessage>();
475 string pdu = ("07963258974152f204038105f300008022110232438a28e6a71b40c587eb"
476 "7076d9357eb7412f7d793a07ddeb6278794d07bde8d5391b246e93d3");
477 EXPECT_TRUE(gsmSmsMessage->CreateMessage(pdu) != nullptr);
478 auto message = gsmSmsMessage->CreateMessage(pdu);
479 EXPECT_TRUE(message != nullptr);
480
481 EXPECT_TRUE(message->IsEmailAddress("\"DAS\" <NAME@sadds.com>"));
482 EXPECT_TRUE(message->IsEmailAddress("DAS <NAME@sadds.com>"));
483 EXPECT_FALSE(message->IsEmailAddress(""));
484 EXPECT_FALSE(message->IsEmailAddress("\"DAS\" 45654654564"));
485 EXPECT_FALSE(message->IsEmailAddress("DAS 13254654654"));
486 EXPECT_TRUE(message->IsEmailAddress("阿松大@163.com"));
487 EXPECT_TRUE(message->IsEmailAddress("aaa@aa.bb.163.com"));
488 }
489
490 /**
491 * @tc.number Telephony_SmsMmsGtest_SmsEmailMessage_0003
492 * @tc.name Test SmsEmailMessage
493 * @tc.desc Function test
494 */
495 HWTEST_F(BranchSmsPartTest, SmsEmailMessage_0003, Function | MediumTest | Level1)
496 {
497 auto gsmSmsMessage = std::make_shared<GsmSmsMessage>();
498 string pdu = ("07963258974152f2040D91687103920059F100008022110232438a28e6a71b40c587e"
499 "b7076d9357eb7412f7d793a07ddeb6278794d07bde8d5391b246e93d3");
500 EXPECT_TRUE(gsmSmsMessage->CreateMessage(pdu) != nullptr);
501 auto message = gsmSmsMessage->CreateMessage(pdu);
502 EXPECT_FALSE(message->IsEmail());
503
504 pdu = ("07963258974152f204038105f300008022110232438a10e6a71b40c587eb7076d9357eb743");
505 EXPECT_TRUE(gsmSmsMessage->CreateMessage(pdu) != nullptr);
506 message = gsmSmsMessage->CreateMessage(pdu);
507 EXPECT_FALSE(message->IsEmail());
508 }
509
510 /**
511 * @tc.number Telephony_SmsMmsGtest_SmsStateObserver_0001
512 * @tc.name Test SmsStateObserver_0001
513 * @tc.desc Function test
514 */
515 HWTEST_F(BranchSmsPartTest, SmsStateObserver_0001, Function | MediumTest | Level1)
516 {
517 std::shared_ptr<SmsStateObserver> smsStateObserver = std::make_shared<SmsStateObserver>();
518 smsStateObserver->smsSubscriber_ = nullptr;
519 smsStateObserver->StopEventSubscriber();
520 std::shared_ptr<CommonEventSubscribeInfo> subscribeInfo = std::make_shared<CommonEventSubscribeInfo>();
521 std::shared_ptr<SmsStateEventSubscriber> smsStateEventSubscriber =
522 std::make_shared<SmsStateEventSubscriber>(*subscribeInfo);
523 EventFwk::CommonEventData eventData = EventFwk::CommonEventData();
524 AAFwk::Want want = AAFwk::Want();
525 want.SetAction(EventFwk::CommonEventSupport::COMMON_EVENT_SMS_EMERGENCY_CB_RECEIVE_COMPLETED);
526 eventData.SetWant(want);
527 smsStateEventSubscriber->OnReceiveEvent(eventData);
528 want.SetAction(EventFwk::CommonEventSupport::COMMON_EVENT_SMS_RECEIVE_COMPLETED);
529 eventData.SetWant(want);
530 smsStateEventSubscriber->OnReceiveEvent(eventData);
531 want.SetAction(EventFwk::CommonEventSupport::COMMON_EVENT_SMS_WAPPUSH_RECEIVE_COMPLETED);
532 eventData.SetWant(want);
533 smsStateEventSubscriber->OnReceiveEvent(eventData);
534 want.SetAction(EventFwk::CommonEventSupport::COMMON_EVENT_BATTERY_LOW);
535 eventData.SetWant(want);
536 smsStateEventSubscriber->OnReceiveEvent(eventData);
537 EXPECT_TRUE(smsStateObserver != nullptr);
538 EXPECT_TRUE(subscribeInfo != nullptr);
539 EXPECT_TRUE(smsStateEventSubscriber != nullptr);
540 }
541
542 /**
543 * @tc.number Telephony_SmsMmsGtest_GsmSmsParamCodec_0014
544 * @tc.name Test GsmSmsParamCodec DecodeSmscPdu
545 * @tc.desc Function test
546 */
547 HWTEST_F(BranchSmsPartTest, GsmSmsParamCodec_0014, Function | MediumTest | Level1) {
548 /**
549 * test supporting smsAddress.ton is unknown
550 */
551 auto gsmSmsParamCodec = std::make_shared<GsmSmsParamCodec>();
552 EXPECT_NE(gsmSmsParamCodec, nullptr);
553 AddressNumber smsAddress;
554
555 unsigned char encodeData[] = { 0x2, 0x81, 0x2A, 0xB1 };
556 unsigned char *pSMSC = encodeData;
557 EXPECT_GE(gsmSmsParamCodec->DecodeSmscPdu(pSMSC, 5, smsAddress), 0);
558 std::string address(smsAddress.address);
559 EXPECT_EQ(address, "*21#");
560 }
561
562 /**
563 * @tc.number Telephony_SmsMmsGtest_GsmSmsParamCodec_0015
564 * @tc.name Test GsmSmsParamCodec DecodeDcsPdu
565 * @tc.desc Function test
566 */
567 HWTEST_F(BranchSmsPartTest, GsmSmsParamCodec_0015, Function | MediumTest | Level1) {
568 /**
569 * test DecodeDcsPdu
570 */
571 auto gsmSmsParamCodec = std::make_shared<GsmSmsParamCodec>();
572 EXPECT_NE(gsmSmsParamCodec, nullptr);
573
574 auto decodeBuffer = std::make_shared<SmsReadBuffer>("0011000D91685150800576F70001C404D4F29C0E");
575 SmsDcs *smsDcs = new SmsDcs();
576 smsDcs->codingGroup = OHOS::Telephony::PduSchemeGroup::CODING_GENERAL_GROUP;
577 smsDcs->bCompressed = false;
578 smsDcs->codingScheme = OHOS::Telephony::DataCodingScheme::DATA_CODING_UCS2;
579 smsDcs->msgClass = OHOS::Telephony::SmsMessageClass::SMS_INSTANT_MESSAGE;
580
581 EXPECT_EQ(gsmSmsParamCodec->DecodeDcsPdu(*decodeBuffer, smsDcs), 1);
582 auto decodeBuffer1 = std::make_shared<SmsReadBuffer>("16D131D98C56B3DD7039584C36A3D56C375C0E169301");
583 EXPECT_EQ(gsmSmsParamCodec->DecodeDcsPdu(*decodeBuffer1, smsDcs), 1);
584 auto decodeBuffer2 = std::make_shared<SmsReadBuffer>("4011000D91685150800576F70001C404D4F29C0E");
585 EXPECT_EQ(gsmSmsParamCodec->DecodeDcsPdu(*decodeBuffer2, smsDcs), 1);
586 auto decodeBuffer3 = std::make_shared<SmsReadBuffer>("C011000D91685150800576F70001C404D4F29C0E");
587 EXPECT_EQ(gsmSmsParamCodec->DecodeDcsPdu(*decodeBuffer3, smsDcs), 1);
588 auto decodeBuffer4 = std::make_shared<SmsReadBuffer>("D011000D91685150800576F70001C404D4F29C0E");
589 EXPECT_EQ(gsmSmsParamCodec->DecodeDcsPdu(*decodeBuffer4, smsDcs), 1);
590 auto decodeBuffer5 = std::make_shared<SmsReadBuffer>("B011000D91685150800576F70001C404D4F29C0E");
591 EXPECT_EQ(gsmSmsParamCodec->DecodeDcsPdu(*decodeBuffer5, smsDcs), 1);
592 }
593
594 /**
595 * @tc.number Telephony_SmsMmsGtest_GsmSmsParamDecode_0003
596 * @tc.name Test GsmSmsParamDecode DecodeDcsGeneralGroupPdu
597 * @tc.desc Function test
598 */
599 HWTEST_F(BranchSmsPartTest, GsmSmsParamDecode_0003, Function | MediumTest | Level1)
600 {
601 auto gsmSmsParamDecode = std::make_shared<GsmSmsParamDecode>();
602 EXPECT_NE(gsmSmsParamDecode, nullptr);
603 uint8_t dcs = 0x08;
604 SmsDcs *smsDcs = nullptr;
605 gsmSmsParamDecode->DecodeDcsGeneralGroupPdu(dcs, smsDcs);
606 EXPECT_EQ(smsDcs, nullptr);
607 SmsDcs *smsDcs1 = new SmsDcs();
608 gsmSmsParamDecode->DecodeDcsGeneralGroupPdu(dcs, smsDcs1);
609 EXPECT_EQ(smsDcs1->msgClass, OHOS::Telephony::SMS_CLASS_UNKNOWN);
610 dcs = 0x15;
611 gsmSmsParamDecode->DecodeDcsGeneralGroupPdu(dcs, smsDcs1);
612 EXPECT_NE(smsDcs1->msgClass, OHOS::Telephony::SMS_CLASS_UNKNOWN);
613 }
614
615 /**
616 * @tc.number Telephony_SmsMmsGtest_GsmSmsParamDecode_0004
617 * @tc.name Test GsmSmsParamDecode DecodeDcsClassGroupPdu
618 * @tc.desc Function test
619 */
620 HWTEST_F(BranchSmsPartTest, GsmSmsParamDecode_0004, Function | MediumTest | Level1)
621 {
622 auto gsmSmsParamDecode = std::make_shared<GsmSmsParamDecode>();
623 EXPECT_NE(gsmSmsParamDecode, nullptr);
624 uint8_t dcs = 0x08;
625 SmsDcs *smsDcs = nullptr;
626 gsmSmsParamDecode->DecodeDcsClassGroupPdu(dcs, smsDcs);
627 EXPECT_EQ(smsDcs, nullptr);
628 SmsDcs *smsDcs1 = new SmsDcs();
629 gsmSmsParamDecode->DecodeDcsClassGroupPdu(dcs, smsDcs1);
630 EXPECT_EQ(smsDcs1->codingGroup, OHOS::Telephony::SMS_CLASS_GROUP);
631 }
632
633 /**
634 * @tc.number Telephony_SmsMmsGtest_GsmSmsParamDecode_0005
635 * @tc.name Test GsmSmsParamDecode DecodeDcsDeleteGroupPdu
636 * @tc.desc Function test
637 */
638 HWTEST_F(BranchSmsPartTest, GsmSmsParamDecode_0005, Function | MediumTest | Level1)
639 {
640 auto gsmSmsParamDecode = std::make_shared<GsmSmsParamDecode>();
641 EXPECT_NE(gsmSmsParamDecode, nullptr);
642 uint8_t dcs = 0x08;
643 SmsDcs *smsDcs = nullptr;
644 gsmSmsParamDecode->DecodeDcsDeleteGroupPdu(dcs, smsDcs);
645 EXPECT_EQ(smsDcs, nullptr);
646 SmsDcs *smsDcs1 = new SmsDcs();
647 gsmSmsParamDecode->DecodeDcsDeleteGroupPdu(dcs, smsDcs1);
648 EXPECT_EQ(smsDcs1->codingGroup, OHOS::Telephony::CODING_DELETION_GROUP);
649 }
650
651 /**
652 * @tc.number Telephony_SmsMmsGtest_GsmSmsParamDecode_0006
653 * @tc.name Test GsmSmsParamDecode DecodeDcsDiscardGroupPdu
654 * @tc.desc Function test
655 */
656 HWTEST_F(BranchSmsPartTest, GsmSmsParamDecode_0006, Function | MediumTest | Level1)
657 {
658 auto gsmSmsParamDecode = std::make_shared<GsmSmsParamDecode>();
659 EXPECT_NE(gsmSmsParamDecode, nullptr);
660 uint8_t dcs = 0x08;
661 SmsDcs *smsDcs = nullptr;
662 gsmSmsParamDecode->DecodeDcsDiscardGroupPdu(dcs, smsDcs);
663 EXPECT_EQ(smsDcs, nullptr);
664 SmsDcs *smsDcs1 = new SmsDcs();
665 gsmSmsParamDecode->DecodeDcsDiscardGroupPdu(dcs, smsDcs1);
666 EXPECT_EQ(smsDcs1->codingGroup, OHOS::Telephony::CODING_DISCARD_GROUP);
667 }
668
669 /**
670 * @tc.number Telephony_SmsMmsGtest_GsmSmsParamDecode_0007
671 * @tc.name Test GsmSmsParamDecode DecodeDcsStoreGsmGroupPdu
672 * @tc.desc Function test
673 */
674 HWTEST_F(BranchSmsPartTest, GsmSmsParamDecode_0007, Function | MediumTest | Level1)
675 {
676 auto gsmSmsParamDecode = std::make_shared<GsmSmsParamDecode>();
677 EXPECT_NE(gsmSmsParamDecode, nullptr);
678 uint8_t dcs = 0x08;
679 SmsDcs *smsDcs = nullptr;
680 gsmSmsParamDecode->DecodeDcsStoreGsmGroupPdu(dcs, smsDcs);
681 EXPECT_EQ(smsDcs, nullptr);
682 SmsDcs *smsDcs1 = new SmsDcs();
683 gsmSmsParamDecode->DecodeDcsStoreGsmGroupPdu(dcs, smsDcs1);
684 EXPECT_EQ(smsDcs1->codingGroup, OHOS::Telephony::CODING_STORE_GROUP);
685 EXPECT_EQ(smsDcs1->codingScheme, OHOS::Telephony::DATA_CODING_7BIT);
686 }
687
688 /**
689 * @tc.number Telephony_SmsMmsGtest_GsmSmsParamDecode_0008
690 * @tc.name Test GsmSmsParamDecode DecodeDcsStoreUCS2GroupPdu
691 * @tc.desc Function test
692 */
693 HWTEST_F(BranchSmsPartTest, GsmSmsParamDecode_0008, Function | MediumTest | Level1)
694 {
695 auto gsmSmsParamDecode = std::make_shared<GsmSmsParamDecode>();
696 EXPECT_NE(gsmSmsParamDecode, nullptr);
697 uint8_t dcs = 0x08;
698 SmsDcs *smsDcs = nullptr;
699 gsmSmsParamDecode->DecodeDcsStoreUCS2GroupPdu(dcs, smsDcs);
700 EXPECT_EQ(smsDcs, nullptr);
701 SmsDcs *smsDcs1 = new SmsDcs();
702 gsmSmsParamDecode->DecodeDcsStoreUCS2GroupPdu(dcs, smsDcs1);
703 EXPECT_EQ(smsDcs1->codingGroup, OHOS::Telephony::CODING_STORE_GROUP);
704 EXPECT_EQ(smsDcs1->codingScheme, OHOS::Telephony::DATA_CODING_UCS2);
705 }
706
707 /**
708 * @tc.number Telephony_SmsMmsGtest_GsmSmsParamDecode_0009
709 * @tc.name Test GsmSmsParamDecode DecodeDcsUnknownGroupPdu
710 * @tc.desc Function test
711 */
712 HWTEST_F(BranchSmsPartTest, GsmSmsParamDecode_0009, Function | MediumTest | Level1)
713 {
714 auto gsmSmsParamDecode = std::make_shared<GsmSmsParamDecode>();
715 EXPECT_NE(gsmSmsParamDecode, nullptr);
716 uint8_t dcs = 0x08;
717 SmsDcs *smsDcs = nullptr;
718 gsmSmsParamDecode->DecodeDcsUnknownGroupPdu(dcs, smsDcs);
719 EXPECT_EQ(smsDcs, nullptr);
720 SmsDcs *smsDcs1 = new SmsDcs();
721 gsmSmsParamDecode->DecodeDcsUnknownGroupPdu(dcs, smsDcs1);
722 EXPECT_EQ(smsDcs1->codingGroup, OHOS::Telephony::CODING_UNKNOWN_GROUP);
723 EXPECT_EQ(smsDcs1->msgClass, OHOS::Telephony::SMS_CLASS_UNKNOWN);
724 }
725
726
727 /**
728 * @tc.number Telephony_SmsMmsGtest_GsmSmsParamDecode_0010
729 * @tc.name Test GsmSmsParamDecode DecodeTimePduPartData
730 * @tc.desc Function test
731 */
732 HWTEST_F(BranchSmsPartTest, GsmSmsParamDecode_0010, Function | MediumTest | Level1)
733 {
734 auto gsmSmsParamDecode = std::make_shared<GsmSmsParamDecode>();
735 EXPECT_NE(gsmSmsParamDecode, nullptr);
736 auto decodeBuffer = std::make_shared<SmsReadBuffer>("");
737 EXPECT_NE(decodeBuffer, nullptr);
738 EXPECT_TRUE(decodeBuffer->IsEmpty());
739 SmsTimeStamp *pTimeStamp = new SmsTimeStamp();
740 pTimeStamp->format = SmsTimeFormat::SMS_TIME_ABSOLUTE;
741 pTimeStamp->time.absolute.timeZone = -1;
742 EXPECT_EQ(gsmSmsParamDecode->DecodeTimePduPartData(*decodeBuffer, pTimeStamp), false); // first branch PickOneByte
743
744 auto decodeBuffer1 = std::make_shared<SmsReadBuffer>("00");
745 EXPECT_NE(decodeBuffer1, nullptr);
746 EXPECT_FALSE(decodeBuffer1->IsEmpty());
747 decodeBuffer1->bitIndex_ = 1;
748 EXPECT_EQ(gsmSmsParamDecode->DecodeTimePduPartData(*decodeBuffer1, pTimeStamp), false); // fifth branch ReadByte
749 EXPECT_EQ(gsmSmsParamDecode->DecodeTimePduPartData(*decodeBuffer1, pTimeStamp), false); // third branch ReadByte
750 }
751
752 /**
753 * @tc.number Telephony_SmsMmsGtest_GsmSmsParamDecode_0011
754 * @tc.name Test GsmSmsParamDecode DecodeTimePduData
755 * @tc.desc Function test
756 */
757 HWTEST_F(BranchSmsPartTest, GsmSmsParamDecode_0011, Function | MediumTest | Level1)
758 {
759 auto gsmSmsParamDecode = std::make_shared<GsmSmsParamDecode>();
760 EXPECT_NE(gsmSmsParamDecode, nullptr);
761 auto decodeBuffer = std::make_shared<SmsReadBuffer>("");
762 EXPECT_NE(decodeBuffer, nullptr);
763 EXPECT_FALSE(gsmSmsParamDecode->DecodeTimePduData(*decodeBuffer, nullptr)); // first branch nullptr
764
765 SmsTimeStamp *pTimeStamp = new SmsTimeStamp();
766 pTimeStamp->format = SmsTimeFormat::SMS_TIME_ABSOLUTE;
767 pTimeStamp->time.absolute.timeZone = -1;
768 EXPECT_FALSE(gsmSmsParamDecode->DecodeTimePduData(*decodeBuffer, pTimeStamp)); // second branch PickOneByte
769
770 auto decodeBuffer1 = std::make_shared<SmsReadBuffer>("00");
771 EXPECT_NE(decodeBuffer1, nullptr);
772 EXPECT_TRUE(gsmSmsParamDecode->DecodeTimePduData(*decodeBuffer1, pTimeStamp));
773 EXPECT_FALSE(gsmSmsParamDecode->DecodeTimePduData(*decodeBuffer1, pTimeStamp)); // second branch PickOneByte
774
775 auto decodeBuffer2 = std::make_shared<SmsReadBuffer>("16D131D98C56B3DD7039584C36A3D56C375C0E169301");
776 EXPECT_NE(decodeBuffer2, nullptr);
777 EXPECT_TRUE(gsmSmsParamDecode->DecodeTimePduData(*decodeBuffer2, pTimeStamp));
778 }
779
780 /**
781 * @tc.number Telephony_SmsMmsGtest_DecodeAddressAlphaNum_0001
782 * @tc.name Test GsmSmsParamDecode DecodeAddressAlphaNum
783 * @tc.desc Function test
784 */
785 HWTEST_F(BranchSmsPartTest, DecodeAddressAlphaNum_0001, Function | MediumTest | Level1)
786 {
787 auto gsmSmsParamDecode = std::make_shared<GsmSmsParamDecode>();
788 EXPECT_NE(gsmSmsParamDecode, nullptr);
789 auto buffer = std::make_shared<SmsReadBuffer>("00");
790 AddressNumber *pAddress = new AddressNumber();
791 uint8_t bcdLen = 1;
792 uint8_t addrLen = 1;
793 EXPECT_FALSE(gsmSmsParamDecode->DecodeAddressAlphaNum(*buffer, pAddress, bcdLen, addrLen)); // third branch
794
795 std::string pdu = StringUtils::HexToString("");
796 auto decodeBuffer1 = std::make_shared<SmsReadBuffer>(pdu);
797 printf("decodeBuffer1 index_ = %d, length_ = %d\n", decodeBuffer1->index_, decodeBuffer1->length_);
798 EXPECT_FALSE(gsmSmsParamDecode->DecodeAddressAlphaNum(*buffer, pAddress, bcdLen, addrLen)); // first branch
799 }
800
801 /**
802 * @tc.number Telephony_SmsMmsGtest_GsmSmsMessage_0004
803 * @tc.name Test GsmSmsMessage
804 * @tc.desc Function test
805 */
806 HWTEST_F(BranchSmsPartTest, GsmSmsMessage_0004, Function | MediumTest | Level1)
807 {
808 auto gsmSmsMessage = std::make_shared<GsmSmsMessage>();
809 EXPECT_TRUE(gsmSmsMessage != nullptr);
810 unsigned char langId = 0;
811 gsmSmsMessage->smsTpdu_ = std::make_shared<struct SmsTpdu>();
812 gsmSmsMessage->smsTpdu_->tpduType = OHOS::Telephony::SmsTpduType::SMS_TPDU_STATUS_REP;
813 EXPECT_EQ(gsmSmsMessage->SetHeaderLang(1, DataCodingScheme::DATA_CODING_UCS2, langId), 0);
814 }
815
816 /**
817 * @tc.number Telephony_SmsMmsGtest_GsmSmsMessage_0005
818 * @tc.name Test GsmSmsMessage
819 * @tc.desc Function test
820 */
821 HWTEST_F(BranchSmsPartTest, GsmSmsMessage_0005, Function | MediumTest | Level1)
822 {
823 auto gsmSmsMessage = std::make_shared<GsmSmsMessage>();
824 EXPECT_TRUE(gsmSmsMessage != nullptr);
825 SmsConcat concat;
826 gsmSmsMessage->smsTpdu_ = std::make_shared<struct SmsTpdu>();
827 gsmSmsMessage->smsTpdu_->tpduType = OHOS::Telephony::SmsTpduType::SMS_TPDU_STATUS_REP;
828 EXPECT_EQ(gsmSmsMessage->SetHeaderConcat(1, concat), 0);
829 }
830
831 /**
832 * @tc.number Telephony_SmsMmsGtest_GsmSmsMessage_0006
833 * @tc.name Test GsmSmsMessage
834 * @tc.desc Function test
835 */
836 HWTEST_F(BranchSmsPartTest, GsmSmsMessage_0006, Function | MediumTest | Level1)
837 {
838 auto gsmSmsMessage = std::make_shared<GsmSmsMessage>();
839 EXPECT_TRUE(gsmSmsMessage != nullptr);
840 gsmSmsMessage->smsTpdu_ = nullptr;
841 EXPECT_EQ(gsmSmsMessage->SetHeaderReply(1), 0);
842
843 gsmSmsMessage->smsTpdu_ = std::make_shared<struct SmsTpdu>();
844 gsmSmsMessage->replyAddress_ = "+13588421254";
845 gsmSmsMessage->smsTpdu_->tpduType = OHOS::Telephony::SmsTpduType::SMS_TPDU_STATUS_REP;
846 EXPECT_EQ(gsmSmsMessage->SetHeaderReply(1), 0);
847 }
848
849 /**
850 * @tc.number Telephony_SmsMmsGtest_GsmSmsMessage_0007
851 * @tc.name Test GsmSmsMessage CreateDefaultSubmit
852 * @tc.desc Function test
853 */
854 HWTEST_F(BranchSmsPartTest, GsmSmsMessage_0007, Function | MediumTest | Level1)
855 {
856 auto gsmSmsMessage = std::make_shared<GsmSmsMessage>();
857 EXPECT_TRUE(gsmSmsMessage != nullptr);
858 gsmSmsMessage->CreateDefaultSubmit(false, DataCodingScheme::DATA_CODING_7BIT);
859 EXPECT_EQ(gsmSmsMessage->smsTpdu_->tpduType, OHOS::Telephony::SmsTpduType::SMS_TPDU_SUBMIT);
860 }
861
862 /**
863 * @tc.number Telephony_SmsMmsGtest_GsmSmsMessage_0008
864 * @tc.name Test GsmSmsMessage PduAnalysisMsg
865 * @tc.desc Function test
866 */
867 HWTEST_F(BranchSmsPartTest, GsmSmsMessage_0008, Function | MediumTest | Level1)
868 {
869 auto gsmSmsMessage = std::make_shared<GsmSmsMessage>();
870 EXPECT_TRUE(gsmSmsMessage != nullptr);
871 gsmSmsMessage->smsTpdu_ = std::make_shared<struct SmsTpdu>();
872 gsmSmsMessage->smsTpdu_->tpduType = OHOS::Telephony::SmsTpduType::SMS_TPDU_STATUS_REP;
873 // also test AnalysisMsgDeliver
874 EXPECT_TRUE(gsmSmsMessage->PduAnalysisMsg());
875 gsmSmsMessage->smsTpdu_->tpduType = OHOS::Telephony::SmsTpduType::SMS_TPDU_SUBMIT;
876 // alse test AnalysisMsgSubmit
877 EXPECT_TRUE(gsmSmsMessage->PduAnalysisMsg());
878 gsmSmsMessage->smsTpdu_->tpduType = OHOS::Telephony::SmsTpduType::SMS_TPDU_DELIVER_REP;
879 EXPECT_FALSE(gsmSmsMessage->PduAnalysisMsg());
880 }
881
882 /**
883 * @tc.number Telephony_SmsMmsGtest_GsmSmsMessage_0009
884 * @tc.name Test GsmSmsMessage ConvertUserData and ConvertUserPartData
885 * @tc.desc Function test
886 */
887 HWTEST_F(BranchSmsPartTest, GsmSmsMessage_0009, Function | MediumTest | Level1)
888 {
889 auto gsmSmsMessage = std::make_shared<GsmSmsMessage>();
890 EXPECT_TRUE(gsmSmsMessage != nullptr);
891
892 gsmSmsMessage->smsTpdu_ = std::make_shared<struct SmsTpdu>();
893 gsmSmsMessage->smsTpdu_->tpduType = OHOS::Telephony::SmsTpduType::SMS_TPDU_DELIVER;
894 gsmSmsMessage->codingScheme_ = OHOS::Telephony::DataCodingScheme::DATA_CODING_7BIT;
895 size_t oldSize = gsmSmsMessage->visibleMessageBody_.size();
896 gsmSmsMessage->smsUserData_.header[0].udh.singleShift.langId = 1;
897 std::string text = "1234566";
898 gsmSmsMessage->SetFullText(text);
899 gsmSmsMessage->ConvertUserData();
900 size_t newSize = gsmSmsMessage->visibleMessageBody_.size();
901 EXPECT_EQ(newSize, oldSize);
902
903 gsmSmsMessage->codingScheme_ = OHOS::Telephony::DataCodingScheme::DATA_CODING_UCS2;
904 oldSize = gsmSmsMessage->visibleMessageBody_.size();
905 gsmSmsMessage->ConvertUserData();
906 newSize = gsmSmsMessage->visibleMessageBody_.size();
907 EXPECT_EQ(newSize, oldSize);
908 }
909
910 /**
911 * @tc.number Telephony_SmsMmsGtest_GsmSmsMessage_0010
912 * @tc.name Test GsmSmsMessage IsSpecialMessage
913 * @tc.desc Function test
914 */
915 HWTEST_F(BranchSmsPartTest, GsmSmsMessage_0010, Function | MediumTest | Level1)
916 {
917 auto gsmSmsMessage = std::make_shared<GsmSmsMessage>();
918 EXPECT_TRUE(gsmSmsMessage != nullptr);
919 gsmSmsMessage->protocolId_ = 0x40;
920 EXPECT_TRUE(gsmSmsMessage->IsSpecialMessage());
921
922 gsmSmsMessage->msgClass_ = OHOS::Telephony::SmsMessageClass::SMS_SIM_MESSAGE;
923 gsmSmsMessage->protocolId_ = 0x7f;
924 EXPECT_TRUE(gsmSmsMessage->IsSpecialMessage());
925
926 gsmSmsMessage->protocolId_ = 0x7c;
927 EXPECT_TRUE(gsmSmsMessage->IsSpecialMessage());
928
929 gsmSmsMessage->protocolId_ = 0x41;
930 gsmSmsMessage->bMwiSet_ = true;
931 EXPECT_TRUE(gsmSmsMessage->IsSpecialMessage());
932
933 gsmSmsMessage->bMwiClear_ = true;
934 EXPECT_TRUE(gsmSmsMessage->IsSpecialMessage());
935 }
936
937 /**
938 * @tc.number Telephony_SmsMmsGtest_GsmSmsMessage_0011
939 * @tc.name Test GsmSmsMessage DecodeMessage
940 * @tc.desc Function test
941 */
942 HWTEST_F(BranchSmsPartTest, GsmSmsMessage_0011, Function | MediumTest | Level1)
943 {
944 auto gsmSmsMessage = std::make_shared<GsmSmsMessage>();
945 EXPECT_TRUE(gsmSmsMessage != nullptr);
946
947 std::string msgText("");
948 // init destination array of pdu data
949 uint8_t decodeData[(MAX_GSM_7BIT_DATA_LEN * OHOS::Telephony::MAX_SEGMENT_NUM) + 1];
950 EXPECT_EQ(memset_s(decodeData, sizeof(decodeData), 0x00, sizeof(decodeData)), EOK);
951
952 int encodeLen = 0;
953 bool bAbnormal = false;
954 unsigned char langId = OHOS::Telephony::MsgLanguageId::MSG_ID_RESERVED_LANG;
955 OHOS::Telephony::DataCodingScheme codingType = OHOS::Telephony::DataCodingScheme::DATA_CODING_7BIT;
956
957 encodeLen = gsmSmsMessage->DecodeMessage(decodeData, sizeof(decodeData), codingType, msgText, bAbnormal, langId);
958 EXPECT_EQ(encodeLen, 0);
959
960 msgText = "123456";
961 encodeLen = gsmSmsMessage->DecodeMessage(decodeData, sizeof(decodeData), codingType, msgText, bAbnormal, langId);
962 EXPECT_GT(encodeLen, 0);
963
964 codingType = OHOS::Telephony::DataCodingScheme::DATA_CODING_8BIT;
965 encodeLen = gsmSmsMessage->DecodeMessage(decodeData, sizeof(decodeData), codingType, msgText, bAbnormal, langId);
966 EXPECT_GT(encodeLen, 0);
967
968 msgText.append(sizeof(decodeData), '1');
969 encodeLen = gsmSmsMessage->DecodeMessage(decodeData, sizeof(decodeData), codingType, msgText, bAbnormal, langId);
970 EXPECT_EQ(encodeLen, 0);
971
972 msgText = "123456";
973 codingType = OHOS::Telephony::DataCodingScheme::DATA_CODING_UCS2;
974 encodeLen = gsmSmsMessage->DecodeMessage(decodeData, sizeof(decodeData), codingType, msgText, bAbnormal, langId);
975 EXPECT_GT(encodeLen, 0);
976
977 codingType = OHOS::Telephony::DataCodingScheme::DATA_CODING_AUTO;
978 encodeLen = gsmSmsMessage->DecodeMessage(decodeData, sizeof(decodeData), codingType, msgText, bAbnormal, langId);
979 EXPECT_GT(encodeLen, 0);
980
981 codingType = OHOS::Telephony::DataCodingScheme::DATA_CODING_EUCKR;
982 encodeLen = gsmSmsMessage->DecodeMessage(decodeData, sizeof(decodeData), codingType, msgText, bAbnormal, langId);
983 EXPECT_GT(encodeLen, 0);
984 }
985
986 /**
987 * @tc.number Telephony_SmsMmsGtest_GsmSmsParamCodec_0016
988 * @tc.name Test GsmSmsParamCodec EncodeAddressPdu
989 * @tc.desc Function test
990 */
991 HWTEST_F(BranchSmsPartTest, GsmSmsParamCodec_0016, Function | MediumTest | Level1)
992 {
993 auto gsmSmsParamCodec = std::make_shared<GsmSmsParamCodec>();
994 AddressNumber *pAddress = new AddressNumber();
995 std::string paramStr;
996
997 std::string smsc = "**21*1300555002012345";
998 memcpy_s(&pAddress->address, sizeof(pAddress->address), smsc.data(), smsc.length());
999 pAddress->address[smsc.length()] = '\0';
1000 pAddress->ton = TYPE_INTERNATIONAL;
1001 pAddress->npi = SMS_NPI_ISDN;
1002 EXPECT_FALSE(gsmSmsParamCodec->EncodeAddressPdu(pAddress, paramStr)); // second branch
1003 }
1004
1005 /**
1006 * @tc.number Telephony_SmsMmsGtest_GsmSmsParamCodec_0017
1007 * @tc.name Test GsmSmsParamCodec EncodeSmscPdu
1008 * @tc.desc Function test
1009 */
1010 HWTEST_F(BranchSmsPartTest, GsmSmsParamCodec_0017, Function | MediumTest | Level1)
1011 {
1012 /*
1013 * test third branch
1014 */
1015 auto gsmSmsParamCodec = std::make_shared<GsmSmsParamCodec>();
1016 EXPECT_NE(gsmSmsParamCodec, nullptr);
1017 const std::string smsc = "+17005550020";
1018 AddressNumber *pAddress = new AddressNumber();
1019 uint8_t encodeSmscAddr[MAX_SMSC_LEN];
1020 memset_s(encodeSmscAddr, sizeof(encodeSmscAddr), 0x00, sizeof(encodeSmscAddr));
1021 std::string decodeAddr;
1022 memcpy_s(&pAddress->address, sizeof(pAddress->address), smsc.data(), smsc.length());
1023 pAddress->address[smsc.length()] = '\0';
1024 pAddress->ton = TYPE_INTERNATIONAL;
1025 pAddress->npi = SMS_NPI_ISDN;
1026 uint8_t encodeSmscLen = 0;
1027 encodeSmscLen = gsmSmsParamCodec->EncodeSmscPdu(pAddress, encodeSmscAddr, sizeof(encodeSmscAddr));
1028 EXPECT_GT(encodeSmscLen, 0);
1029 }
1030
1031 /**
1032 * @tc.number Telephony_SmsMmsGtest_GsmSmsTpduCodec_0005
1033 * @tc.name Test GsmSmsTpduCodec EncodeSubmitPdu
1034 * @tc.desc Function test
1035 */
1036 HWTEST_F(BranchSmsPartTest, GsmSmsTpduCodec_0005, Function | MediumTest | Level1)
1037 {
1038 auto tpduCodec = std::make_shared<GsmSmsTpduCodec>();
1039 auto encodeBuffer = std::make_shared<SmsWriteBuffer>();
1040 encodeBuffer->data_[0] = 1;
1041 SmsSubmit *pSubmit = new SmsSubmit();
1042 /*
1043 * parameter check
1044 */
1045 auto encode = std::make_shared<GsmSmsTpduEncode>(nullptr, tpduCodec->paramCodec_, tpduCodec);
1046 EXPECT_FALSE(encode->EncodeSubmitPdu(*encodeBuffer, pSubmit));
1047 auto encode1 = std::make_shared<GsmSmsTpduEncode>(tpduCodec->uDataCodec_, nullptr, tpduCodec);
1048 EXPECT_FALSE(encode1->EncodeSubmitPdu(*encodeBuffer, pSubmit));
1049
1050 auto encode2 = std::make_shared<GsmSmsTpduEncode>(tpduCodec->uDataCodec_, tpduCodec->paramCodec_, tpduCodec);
1051 EXPECT_TRUE(encode2->EncodeSubmitPdu(*encodeBuffer, pSubmit));
1052 /*
1053 * third branch
1054 */
1055 const std::string smsc = "+17005550020324556627";
1056 memcpy_s(&pSubmit->destAddress.address, sizeof(pSubmit->destAddress.address), smsc.data(), smsc.length());
1057 pSubmit->destAddress.address[smsc.length()] = '\0';
1058 EXPECT_FALSE(encode2->EncodeSubmitPdu(*encodeBuffer, pSubmit));
1059
1060 delete pSubmit;
1061 pSubmit = nullptr;
1062 }
1063
1064 /**
1065 * @tc.number Telephony_SmsMmsGtest_GsmSmsTpduCodec_0006
1066 * @tc.name Test GsmSmsTpduCodec EncodeSubmitPduPartData
1067 * @tc.desc Function test
1068 */
1069 HWTEST_F(BranchSmsPartTest, GsmSmsTpduCodec_0006, Function | MediumTest | Level1)
1070 {
1071 auto tpduCodec = std::make_shared<GsmSmsTpduCodec>();
1072 auto encodeBuffer = std::make_shared<SmsWriteBuffer>();
1073 SmsSubmit *pSubmit = new SmsSubmit();
1074 auto encode = std::make_shared<GsmSmsTpduEncode>(tpduCodec->uDataCodec_, tpduCodec->paramCodec_, tpduCodec);
1075 EXPECT_NE(encode, nullptr);
1076 /*
1077 * parameter check
1078 */
1079 encodeBuffer->data_ = nullptr;
1080 EXPECT_FALSE(encode->EncodeSubmitPduPartData(*encodeBuffer, pSubmit));
1081 /*
1082 * third branch
1083 */
1084 encodeBuffer->index_ = 0;
1085 pSubmit->vpf = OHOS::Telephony::SmsVpf::SMS_VPF_ENHANCED;
1086 EXPECT_FALSE(encode->EncodeSubmitPdu(*encodeBuffer, pSubmit));
1087
1088 encodeBuffer->data_ = nullptr;
1089 EXPECT_FALSE(encode->EncodeSubmitPdu(*encodeBuffer, pSubmit));
1090
1091 delete pSubmit;
1092 pSubmit = nullptr;
1093 }
1094
1095 /**
1096 * @tc.number Telephony_SmsMmsGtest_GsmSmsTpduCodec_0007
1097 * @tc.name Test GsmSmsTpduCodec EncodeSubmitTpduType
1098 * @tc.desc Function test
1099 */
1100 HWTEST_F(BranchSmsPartTest, GsmSmsTpduCodec_0007, Function | MediumTest | Level1)
1101 {
1102 auto tpduCodec = std::make_shared<GsmSmsTpduCodec>();
1103 auto encodeBuffer = std::make_shared<SmsWriteBuffer>();
1104 SmsSubmit pSubmit;
1105 auto encode = std::make_shared<GsmSmsTpduEncode>(tpduCodec->uDataCodec_, tpduCodec->paramCodec_, tpduCodec);
1106 EXPECT_NE(encode, nullptr);
1107
1108 /*
1109 * parameter check
1110 */
1111 pSubmit.bRejectDup = false;
1112 encodeBuffer->data_ = nullptr;
1113 uint16_t count = encodeBuffer->GetSize();
1114 encode->EncodeSubmitTpduType(*encodeBuffer, pSubmit);
1115 EXPECT_EQ(encodeBuffer->GetSize(), count);
1116 /*
1117 * third branch
1118 */
1119 auto encodeBuffer2 = std::make_shared<SmsWriteBuffer>();
1120 encodeBuffer2->data_[0] = 1;
1121 encodeBuffer2->bitIndex_ = 1;
1122 uint16_t count2 = encodeBuffer2->GetSize();
1123 encode->EncodeSubmitTpduType(*encodeBuffer2, pSubmit);
1124 EXPECT_EQ(encodeBuffer2->GetSize(), count2);
1125 }
1126
1127 /**
1128 * @tc.number Telephony_SmsMmsGtest_GsmSmsTpduCodec_0008
1129 * @tc.name Test GsmSmsTpduCodec EncodeSubmitTypePartData
1130 * @tc.desc Function test
1131 */
1132 HWTEST_F(BranchSmsPartTest, GsmSmsTpduCodec_0008, Function | MediumTest | Level1)
1133 {
1134 auto tpduCodec = std::make_shared<GsmSmsTpduCodec>();
1135 auto encodeBuffer = std::make_shared<SmsWriteBuffer>();
1136 SmsSubmit pSubmit;
1137 auto encode = std::make_shared<GsmSmsTpduEncode>(tpduCodec->uDataCodec_, tpduCodec->paramCodec_, tpduCodec);
1138 EXPECT_NE(encode, nullptr);
1139 pSubmit.bStatusReport = false;
1140 pSubmit.bHeaderInd = false;
1141 pSubmit.bReplyPath = false;
1142 /*
1143 * SMS_VPF_ENHANCED
1144 */
1145 pSubmit.vpf = OHOS::Telephony::SmsVpf::SMS_VPF_ENHANCED;
1146 encodeBuffer->data_ = nullptr;
1147 uint16_t count1 = encodeBuffer->GetSize();
1148 encode->EncodeSubmitTypePartData(*encodeBuffer, pSubmit);
1149 EXPECT_EQ(encodeBuffer->GetSize(), count1);
1150
1151 auto encodeBuffer2 = std::make_shared<SmsWriteBuffer>();
1152 encodeBuffer2->data_[0] = 1;
1153 encodeBuffer2->index_ = 1;
1154 uint16_t count2 = encodeBuffer2->GetSize();
1155 encode->EncodeSubmitTypePartData(*encodeBuffer2, pSubmit);
1156 EXPECT_EQ(encodeBuffer2->GetSize(), count2);
1157 /*
1158 * SMS_VPF_RELATIVE
1159 */
1160 pSubmit.vpf = OHOS::Telephony::SmsVpf::SMS_VPF_ENHANCED;
1161 auto encodeBuffer3 = std::make_shared<SmsWriteBuffer>();
1162 encodeBuffer3->data_ = nullptr;
1163 uint16_t count3 = encodeBuffer3->GetSize();
1164 encode->EncodeSubmitTypePartData(*encodeBuffer3, pSubmit);
1165 EXPECT_EQ(encodeBuffer3->GetSize(), count3);
1166
1167 auto encodeBuffer4 = std::make_shared<SmsWriteBuffer>();
1168 encodeBuffer4->data_[0] = 1;
1169 encodeBuffer4->index_ = 1;
1170 uint16_t count4 = encodeBuffer4->GetSize();
1171 encode->EncodeSubmitTypePartData(*encodeBuffer4, pSubmit);
1172 EXPECT_EQ(encodeBuffer4->GetSize(), count4);
1173 /*
1174 * SMS_VPF_RELATIVE
1175 */
1176 pSubmit.vpf = OHOS::Telephony::SmsVpf::SMS_VPF_RELATIVE;
1177 auto encodeBuffer5 = std::make_shared<SmsWriteBuffer>();
1178 encodeBuffer5->data_ = nullptr;
1179 uint16_t count5 = encodeBuffer5->GetSize();
1180 encode->EncodeSubmitTypePartData(*encodeBuffer5, pSubmit);
1181 EXPECT_EQ(encodeBuffer5->GetSize(), count5);
1182
1183 auto encodeBuffer6 = std::make_shared<SmsWriteBuffer>();
1184 encodeBuffer6->data_[0] = 1;
1185 encodeBuffer6->index_ = 1;
1186 uint16_t count6 = encodeBuffer6->GetSize();
1187 encode->EncodeSubmitTypePartData(*encodeBuffer6, pSubmit);
1188 EXPECT_EQ(encodeBuffer6->GetSize(), count6);
1189 }
1190
1191 /**
1192 * @tc.number Telephony_SmsMmsGtest_GsmSmsTpduCodec_0009
1193 * @tc.name Test GsmSmsTpduCodec EncodeSubmitTypePartData
1194 * @tc.desc Function test
1195 */
1196 HWTEST_F(BranchSmsPartTest, GsmSmsTpduCodec_0009, Function | MediumTest | Level1)
1197 {
1198 auto tpduCodec = std::make_shared<GsmSmsTpduCodec>();
1199 auto encodeBuffer = std::make_shared<SmsWriteBuffer>();
1200 SmsSubmit pSubmit;
1201 auto encode = std::make_shared<GsmSmsTpduEncode>(tpduCodec->uDataCodec_, tpduCodec->paramCodec_, tpduCodec);
1202 EXPECT_NE(encode, nullptr);
1203 pSubmit.bStatusReport = false;
1204 pSubmit.bHeaderInd = false;
1205 pSubmit.bReplyPath = false;
1206 /*
1207 * SMS_VPF_ABSOLUTE
1208 */
1209 pSubmit.vpf = OHOS::Telephony::SmsVpf::SMS_VPF_ABSOLUTE;
1210 auto encodeBuffer7 = std::make_shared<SmsWriteBuffer>();
1211 encodeBuffer7->data_ = nullptr;
1212 uint16_t count7 = encodeBuffer7->GetSize();
1213 encode->EncodeSubmitTypePartData(*encodeBuffer7, pSubmit);
1214 EXPECT_EQ(encodeBuffer7->GetSize(), count7);
1215
1216 auto encodeBuffer8 = std::make_shared<SmsWriteBuffer>();
1217 encodeBuffer8->data_[0] = 1;
1218 encodeBuffer8->index_ = 1;
1219 uint16_t count8 = encodeBuffer8->GetSize();
1220 encode->EncodeSubmitTypePartData(*encodeBuffer8, pSubmit);
1221 EXPECT_EQ(encodeBuffer8->GetSize(), count8);
1222 /*
1223 * SMS_VPF_NOT_PRESENT
1224 */
1225 pSubmit.vpf = OHOS::Telephony::SmsVpf::SMS_VPF_NOT_PRESENT;
1226 auto encodeBuffer9 = std::make_shared<SmsWriteBuffer>();
1227 encodeBuffer9->data_ = nullptr;
1228 uint16_t count9 = encodeBuffer9->GetSize();
1229 encode->EncodeSubmitTypePartData(*encodeBuffer9, pSubmit);
1230 EXPECT_EQ(encodeBuffer9->GetSize(), count9);
1231 }
1232
1233 /**
1234 * @tc.number Telephony_SmsMmsGtest_GsmSmsTpduCodec_0010
1235 * @tc.name Test GsmSmsTpduCodec EncodeSubmitTypeData
1236 * @tc.desc Function test
1237 */
1238 HWTEST_F(BranchSmsPartTest, GsmSmsTpduCodec_0010, Function | MediumTest | Level1)
1239 {
1240 auto tpduCodec = std::make_shared<GsmSmsTpduCodec>();
1241 auto encodeBuffer = std::make_shared<SmsWriteBuffer>();
1242 SmsSubmit pSubmit;
1243 auto encode = std::make_shared<GsmSmsTpduEncode>(tpduCodec->uDataCodec_, tpduCodec->paramCodec_, tpduCodec);
1244 EXPECT_NE(encode, nullptr);
1245 /*
1246 * pSubmit->bStatusReport is true
1247 */
1248 pSubmit.bStatusReport = true;
1249 encode->EncodeSubmitTypePartData(*encodeBuffer, pSubmit);
1250 auto encodeBuffer1 = std::make_shared<SmsWriteBuffer>();
1251 encodeBuffer1->data_[0] = 1;
1252 encodeBuffer1->index_ = 1;
1253 uint16_t count1 = encodeBuffer1->GetSize();
1254 encode->EncodeSubmitTypePartData(*encodeBuffer1, pSubmit);
1255 EXPECT_EQ(encodeBuffer1->GetSize(), count1);
1256 /*
1257 * pSubmit.bHeaderInd is true
1258 */
1259 auto encodeBuffer2 = std::make_shared<SmsWriteBuffer>();
1260 pSubmit.bStatusReport = false;
1261 pSubmit.bHeaderInd = true;
1262 const std::string smsc = "17005550020";
1263 memcpy_s(&pSubmit.destAddress.address, sizeof(pSubmit.destAddress.address), smsc.data(), smsc.length());
1264 pSubmit.destAddress.address[smsc.length()] = '\0';
1265 encodeBuffer2->data_ = nullptr;
1266 uint16_t count2 = encodeBuffer2->GetSize();
1267 encode->EncodeSubmitTypePartData(*encodeBuffer2, pSubmit);
1268 EXPECT_EQ(encodeBuffer2->GetSize(), count2);
1269
1270 auto encodeBuffer3 = std::make_shared<SmsWriteBuffer>();
1271 encodeBuffer3->data_[0] = 1;
1272 encodeBuffer3->index_ = 1;
1273 uint16_t count3 = encodeBuffer3->GetSize();
1274 encode->EncodeSubmitTypePartData(*encodeBuffer3, pSubmit);
1275 EXPECT_EQ(encodeBuffer3->GetSize(), count3);
1276 /*
1277 * pSubmit.bReplyPath is true
1278 */
1279 pSubmit.bStatusReport = false;
1280 pSubmit.bHeaderInd = false;
1281 pSubmit.bReplyPath = true;
1282 auto encodeBuffer4 = std::make_shared<SmsWriteBuffer>();
1283 encodeBuffer4->data_ = nullptr;
1284 uint16_t count4 = encodeBuffer4->GetSize();
1285 encode->EncodeSubmitTypePartData(*encodeBuffer4, pSubmit);
1286 EXPECT_EQ(encodeBuffer4->GetSize(), count4);
1287
1288 auto encodeBuffer5 = std::make_shared<SmsWriteBuffer>();
1289 encodeBuffer5->data_[0] = 1;
1290 encodeBuffer5->index_ = 1;
1291 uint16_t count5 = encodeBuffer5->GetSize();
1292 encode->EncodeSubmitTypePartData(*encodeBuffer5, pSubmit);
1293 EXPECT_EQ(encodeBuffer5->GetSize(), count5);
1294 }
1295
1296 /**
1297 * @tc.number Telephony_SmsMmsGtest_GsmSmsTpduCodec_0011
1298 * @tc.name Test GsmSmsTpduCodec EncodeDeliverPdu
1299 * @tc.desc Function test
1300 */
1301 HWTEST_F(BranchSmsPartTest, GsmSmsTpduCodec_0011, Function | MediumTest | Level1)
1302 {
1303 auto tpduCodec = std::make_shared<GsmSmsTpduCodec>();
1304 auto encodeBuffer = std::make_shared<SmsWriteBuffer>();
1305 SmsDeliver *pDeliver = new SmsDeliver();
1306 auto encode = std::make_shared<GsmSmsTpduEncode>(tpduCodec->uDataCodec_, tpduCodec->paramCodec_, tpduCodec);
1307 EXPECT_NE(encode, nullptr);
1308 /*
1309 * second branch
1310 */
1311 encodeBuffer->data_ = nullptr;
1312 EXPECT_FALSE(encode->EncodeDeliverPdu(*encodeBuffer, pDeliver));
1313 /*
1314 * third branch pDeliver->bMoreMsg is false
1315 */
1316 auto encodeBuffer1 = std::make_shared<SmsWriteBuffer>();
1317 pDeliver->bMoreMsg = false;
1318 EXPECT_FALSE(encode->EncodeDeliverPdu(*encodeBuffer1, pDeliver));
1319
1320 auto encodeBuffer2 = std::make_shared<SmsWriteBuffer>();
1321 encodeBuffer2->data_[0] = 1;
1322 encodeBuffer2->index_ = 1;
1323 EXPECT_FALSE(encode->EncodeDeliverPdu(*encodeBuffer2, pDeliver));
1324 /*
1325 * fourth branch pDeliver->bStatusReport is true
1326 */
1327 pDeliver->bMoreMsg = true;
1328 pDeliver->bStatusReport = true;
1329 auto encodeBuffer3 = std::make_shared<SmsWriteBuffer>();
1330 EXPECT_FALSE(encode->EncodeDeliverPdu(*encodeBuffer3, pDeliver));
1331
1332 auto encodeBuffer4 = std::make_shared<SmsWriteBuffer>();
1333 encodeBuffer4->data_[0] = 1;
1334 encodeBuffer4->index_ = 1;
1335 EXPECT_FALSE(encode->EncodeDeliverPdu(*encodeBuffer4, pDeliver));
1336 /*
1337 * fifth branch pDeliver->bHeaderInd is true
1338 */
1339 auto encodeBuffer5 = std::make_shared<SmsWriteBuffer>();
1340 pDeliver->bStatusReport = false;
1341 pDeliver->bHeaderInd = true;
1342 EXPECT_FALSE(encode->EncodeDeliverPdu(*encodeBuffer5, pDeliver));
1343
1344 auto encodeBuffer6 = std::make_shared<SmsWriteBuffer>();
1345 encodeBuffer6->data_[0] = 1;
1346 encodeBuffer6->index_ = 1;
1347 EXPECT_FALSE(encode->EncodeDeliverPdu(*encodeBuffer6, pDeliver));
1348
1349 delete pDeliver;
1350 pDeliver = nullptr;
1351 }
1352
1353 /**
1354 * @tc.number Telephony_SmsMmsGtest_GsmSmsTpduCodec_0012
1355 * @tc.name Test GsmSmsTpduCodec EncodeDeliverPartData
1356 * @tc.desc Function test
1357 */
1358 HWTEST_F(BranchSmsPartTest, GsmSmsTpduCodec_0012, Function | MediumTest | Level1)
1359 {
1360 auto tpduCodec = std::make_shared<GsmSmsTpduCodec>();
1361 auto encodeBuffer = std::make_shared<SmsWriteBuffer>();
1362 SmsDeliver *pDeliver = new SmsDeliver();
1363 /*
1364 * parameter check
1365 */
1366 auto encode0 = std::make_shared<GsmSmsTpduEncode>(tpduCodec->uDataCodec_, nullptr, tpduCodec);
1367 EXPECT_NE(encode0, nullptr);
1368 EXPECT_FALSE(encode0->EncodeDeliverPartData(*encodeBuffer, pDeliver));
1369
1370 auto encode = std::make_shared<GsmSmsTpduEncode>(tpduCodec->uDataCodec_, tpduCodec->paramCodec_, tpduCodec);
1371 EXPECT_NE(encode, nullptr);
1372 /*
1373 * pDeliver->bReplyPath is true
1374 */
1375 pDeliver->bReplyPath = true;
1376 encodeBuffer->data_ = nullptr;
1377 EXPECT_FALSE(encode->EncodeDeliverPartData(*encodeBuffer, pDeliver));
1378
1379 auto encodeBuffer1 = std::make_shared<SmsWriteBuffer>();
1380 encodeBuffer1->data_[0] = 1;
1381 encodeBuffer1->index_ = 1;
1382 EXPECT_FALSE(encode->EncodeDeliverPartData(*encodeBuffer, pDeliver));
1383 /*
1384 * third branch
1385 */
1386 auto encodeBuffer2 = std::make_shared<SmsWriteBuffer>();
1387 pDeliver->bReplyPath = false;
1388 const std::string smsc = "17005550020111111111";
1389 memcpy_s(&pDeliver->originAddress.address, sizeof(pDeliver->originAddress.address), smsc.data(), smsc.length());
1390 pDeliver->originAddress.address[smsc.length()] = '\0';
1391 EXPECT_FALSE(encode->EncodeDeliverPartData(*encodeBuffer2, pDeliver));
1392 /*
1393 * fourth branch
1394 */
1395 auto encodeBuffer3 = std::make_shared<SmsWriteBuffer>();
1396 encodeBuffer3->data_[0] = 1;
1397 EXPECT_FALSE(encode->EncodeDeliverPartData(*encodeBuffer3, pDeliver));
1398
1399 delete pDeliver;
1400 pDeliver = nullptr;
1401 }
1402
1403 /**
1404 * @tc.number Telephony_SmsMmsGtest_GsmSmsTpduCodec_0013
1405 * @tc.name Test GsmSmsTpduCodec EncodeDeliverData
1406 * @tc.desc Function test
1407 */
1408 HWTEST_F(BranchSmsPartTest, GsmSmsTpduCodec_0013, Function | MediumTest | Level1)
1409 {
1410 auto tpduCodec = std::make_shared<GsmSmsTpduCodec>();
1411 auto encodeBuffer = std::make_shared<SmsWriteBuffer>();
1412 SmsDeliver *pDeliver = new SmsDeliver();
1413 /*
1414 * parameter check
1415 */
1416 auto encode0 = std::make_shared<GsmSmsTpduEncode>(nullptr, tpduCodec->paramCodec_, tpduCodec);
1417 EXPECT_NE(encode0, nullptr);
1418 EXPECT_FALSE(encode0->EncodeDeliverData(*encodeBuffer, pDeliver));
1419 /*
1420 * second branch
1421 */
1422 auto encode = std::make_shared<GsmSmsTpduEncode>(tpduCodec->uDataCodec_, tpduCodec->paramCodec_, tpduCodec);
1423 EXPECT_NE(encode, nullptr);
1424 encodeBuffer->data_ = nullptr;
1425 EXPECT_FALSE(encode->EncodeDeliverData(*encodeBuffer, pDeliver));
1426
1427 auto encodeBuffer1 = std::make_shared<SmsWriteBuffer>();
1428 encodeBuffer->index_ = 1;
1429 EXPECT_FALSE(encode->EncodeDeliverPartData(*encodeBuffer1, pDeliver));
1430 /*
1431 * main branch
1432 */
1433 auto encodeBuffer2 = std::make_shared<SmsWriteBuffer>();
1434 encodeBuffer2->data_[0] = 1;
1435 encodeBuffer2->index_ = 1;
1436 EXPECT_FALSE(encode->EncodeDeliverPartData(*encodeBuffer2, pDeliver));
1437
1438 delete pDeliver;
1439 pDeliver = nullptr;
1440 }
1441
1442 /**
1443 * @tc.number Telephony_SmsMmsGtest_SmsBaseMessage_0001
1444 * @tc.name Test SmsBaseMessage
1445 * @tc.desc Function test
1446 */
1447 HWTEST_F(BranchSmsPartTest, SmsBaseMessage_0001, Function | MediumTest | Level1)
1448 {
1449 auto smsBaseMessage = std::make_shared<GsmSmsMessage>();
1450 smsBaseMessage->ConvertMessageClass(SmsMessageClass::SMS_SIM_MESSAGE);
1451 smsBaseMessage->ConvertMessageClass(SmsMessageClass::SMS_INSTANT_MESSAGE);
1452 smsBaseMessage->ConvertMessageClass(SmsMessageClass::SMS_OPTIONAL_MESSAGE);
1453 smsBaseMessage->ConvertMessageClass(SmsMessageClass::SMS_FORWARD_MESSAGE);
1454 smsBaseMessage->ConvertMessageClass(SmsMessageClass::SMS_CLASS_UNKNOWN);
1455 SplitInfo split;
1456 DataCodingScheme codingType = DataCodingScheme::DATA_CODING_7BIT;
1457 smsBaseMessage->ConvertSpiltToUtf8(split, codingType);
1458 split.encodeData.push_back(1);
1459 codingType = DataCodingScheme::DATA_CODING_UCS2;
1460 smsBaseMessage->ConvertSpiltToUtf8(split, codingType);
1461 codingType = DataCodingScheme::DATA_CODING_AUTO;
1462 smsBaseMessage->ConvertSpiltToUtf8(split, codingType);
1463 smsBaseMessage->smsUserData_.headerCnt = 1;
1464 smsBaseMessage->smsUserData_.header[0].udhType = UserDataHeadType::UDH_CONCAT_8BIT;
1465 EXPECT_FALSE(smsBaseMessage->GetConcatMsg() == nullptr);
1466 smsBaseMessage->smsUserData_.header[0].udhType = UserDataHeadType::UDH_CONCAT_16BIT;
1467 EXPECT_FALSE(smsBaseMessage->GetConcatMsg() == nullptr);
1468 smsBaseMessage->smsUserData_.header[0].udhType = UserDataHeadType::UDH_APP_PORT_8BIT;
1469 EXPECT_FALSE(smsBaseMessage->GetPortAddress() == nullptr);
1470 smsBaseMessage->smsUserData_.header[0].udhType = UserDataHeadType::UDH_APP_PORT_16BIT;
1471 EXPECT_FALSE(smsBaseMessage->GetPortAddress() == nullptr);
1472 smsBaseMessage->smsUserData_.header[0].udhType = UserDataHeadType::UDH_SPECIAL_SMS;
1473 EXPECT_FALSE(smsBaseMessage->GetSpecialSmsInd() == nullptr);
1474 smsBaseMessage->smsUserData_.header[0].udhType = UserDataHeadType::UDH_APP_PORT_8BIT;
1475 EXPECT_FALSE(smsBaseMessage->IsWapPushMsg());
1476 MSG_LANGUAGE_ID_T langId = 1;
1477 codingType = DataCodingScheme::DATA_CODING_7BIT;
1478 EXPECT_GT(smsBaseMessage->GetMaxSegmentSize(codingType, 1, true, langId, 1), 0);
1479 EXPECT_GT(smsBaseMessage->GetSegmentSize(codingType, 1, true, langId), 0);
1480 codingType = DataCodingScheme::DATA_CODING_ASCII7BIT;
1481 EXPECT_GT(smsBaseMessage->GetMaxSegmentSize(codingType, 1, true, langId, 1), 0);
1482 EXPECT_GT(smsBaseMessage->GetSegmentSize(codingType, 1, true, langId), 0);
1483 codingType = DataCodingScheme::DATA_CODING_8BIT;
1484 EXPECT_GT(smsBaseMessage->GetMaxSegmentSize(codingType, 1, true, langId, 1), 0);
1485 EXPECT_GT(smsBaseMessage->GetSegmentSize(codingType, 1, true, langId), 0);
1486 codingType = DataCodingScheme::DATA_CODING_UCS2;
1487 EXPECT_GT(smsBaseMessage->GetMaxSegmentSize(codingType, 1, true, langId, 1), 0);
1488 EXPECT_GT(smsBaseMessage->GetSegmentSize(codingType, 1, true, langId), 0);
1489 std::string message = "";
1490 LengthInfo lenInfo;
1491 EXPECT_GE(smsBaseMessage->GetSmsSegmentsInfo(message, true, lenInfo), 0);
1492 message = "123";
1493 EXPECT_EQ(smsBaseMessage->GetSmsSegmentsInfo(message, true, lenInfo), TELEPHONY_ERR_SUCCESS);
1494 EXPECT_EQ(smsBaseMessage->GetSmsSegmentsInfo(message, false, lenInfo), TELEPHONY_ERR_SUCCESS);
1495 }
1496
1497 /**
1498 * @tc.number Telephony_SmsMmsGtest_SmsBaseMessage_0002
1499 * @tc.name Test SmsBaseMessage
1500 * @tc.desc Function test
1501 */
1502 HWTEST_F(BranchSmsPartTest, SmsBaseMessage_0002, Function | MediumTest | Level1)
1503 {
1504 auto gsmSmsMessage = std::make_shared<GsmSmsMessage>();
1505 std::vector<struct SplitInfo> splitResult;
1506 DataCodingScheme codingType = DATA_CODING_AUTO;
1507 std::string text = {0xe4, 0xbd, 0xa0, 0xe4, 0xbd, 0xa0, 0xe4, 0xbd, 0xa0, 0xf0, 0x9f, 0xa5, 0xb3, 0xf0, 0x9f, 0xa5,
1508 0xb3, 0xf0, 0x9f, 0xa5, 0xb3, 0xf0, 0x9f, 0xa5, 0xb3, 0xf0, 0x9f, 0xa5, 0xb3, 0xf0, 0x9f, 0xa5, 0xb3,
1509 0xf0, 0x9f, 0xa5, 0xb3, 0xf0, 0x9f, 0xa5, 0xb3, 0xf0, 0x9f, 0xa5, 0xb3, 0xf0, 0x9f, 0xa5, 0xb3,
1510 0xf0, 0x9f, 0xa5, 0xb3, 0xf0, 0x9f, 0xa5, 0xb3, 0xf0, 0x9f, 0xa5, 0xb3, 0xf0, 0x9f, 0xa5, 0xb3,
1511 0xf0, 0x9f, 0xa5, 0xb3, 0xf0, 0x9f, 0xa5, 0xb3, 0xf0, 0x9f, 0xa5, 0xb3, 0xf0, 0x9f, 0xa5, 0xb3,
1512 0xf0, 0x9f, 0xa5, 0xb3, 0xf0, 0x9f, 0xa5, 0xb3, 0xf0, 0x9f, 0xa5, 0xb3, 0xf0, 0x9f, 0xa5, 0xb3,
1513 0xf0, 0x9f, 0xa5, 0xb3, 0xf0, 0x9f, 0xa5, 0xb3, 0xf0, 0x9f, 0xa5, 0xb3, 0xf0, 0x9f, 0xa5, 0xb3,
1514 0xf0, 0x9f, 0xa5, 0xb3, 0xf0, 0x9f, 0xa5, 0xb3, 0xf0, 0x9f, 0xa5, 0xb3, 0xf0, 0x9f, 0xa5, 0xb3,
1515 0xf0, 0x9f, 0xa5, 0xb3, 0xf0, 0x9f, 0xa5, 0xb3, 0xf0, 0x9f, 0xa5, 0xb3, 0xf0, 0x9f, 0xa5, 0xb3,
1516 0xf0, 0x9f, 0xa5, 0xb3, 0xf0, 0x9f, 0xa5, 0xb3, 0xf0, 0x9f, 0xa5, 0xb3};
1517 std::string desAddr = "";
1518 gsmSmsMessage->SplitMessage(splitResult, text, false, codingType, false, desAddr);
1519 std::vector<unsigned char> expect1 = {0x4f, 0x60, 0x4f, 0x60, 0x4f, 0x60, 0xd8, 0x3e, 0xdd, 0x73,
1520 0xd8, 0x3e, 0xdd, 0x73, 0xd8, 0x3e, 0xdd, 0x73, 0xd8, 0x3e, 0xdd, 0x73, 0xd8, 0x3e, 0xdd, 0x73,
1521 0xd8, 0x3e, 0xdd, 0x73, 0xd8, 0x3e, 0xdd, 0x73, 0xd8, 0x3e, 0xdd, 0x73, 0xd8, 0x3e, 0xdd, 0x73,
1522 0xd8, 0x3e, 0xdd, 0x73, 0xd8, 0x3e, 0xdd, 0x73, 0xd8, 0x3e, 0xdd, 0x73, 0xd8, 0x3e, 0xdd, 0x73,
1523 0xd8, 0x3e, 0xdd, 0x73, 0xd8, 0x3e, 0xdd, 0x73, 0xd8, 0x3e, 0xdd, 0x73, 0xd8, 0x3e, 0xdd, 0x73,
1524 0xd8, 0x3e, 0xdd, 0x73, 0xd8, 0x3e, 0xdd, 0x73, 0xd8, 0x3e, 0xdd, 0x73, 0xd8, 0x3e, 0xdd, 0x73,
1525 0xd8, 0x3e, 0xdd, 0x73, 0xd8, 0x3e, 0xdd, 0x73, 0xd8, 0x3e, 0xdd, 0x73, 0xd8, 0x3e, 0xdd, 0x73,
1526 0xd8, 0x3e, 0xdd, 0x73, 0xd8, 0x3e, 0xdd, 0x73, 0xd8, 0x3e, 0xdd, 0x73, 0xd8, 0x3e, 0xdd, 0x73,
1527 0xd8, 0x3e, 0xdd, 0x73, 0xd8, 0x3e, 0xdd, 0x73, 0xd8, 0x3e, 0xdd, 0x73};
1528 std::vector<unsigned char> expect2 = {0xd8, 0x3e, 0xdd, 0x73, 0xd8, 0x3e, 0xdd, 0x73, 0xd8, 0x3e, 0xdd, 0x73,
1529 0xd8, 0x3e, 0xdd, 0x73, 0xd8, 0x3e, 0xdd, 0x73};
1530 EXPECT_TRUE(splitResult[0].encodeData == expect1);
1531 EXPECT_TRUE(splitResult[1].encodeData == expect2);
1532 }
1533
1534 /**
1535 * @tc.number Telephony_SmsMmsGtest_SmsPersistHelper_0002
1536 * @tc.name Test SmsPersistHelper
1537 * @tc.desc Function test
1538 */
1539 HWTEST_F(BranchSmsPartTest, SmsPersistHelper_0002, Function | MediumTest | Level1)
1540 {
1541 auto smsPersistHelper = DelayedSingleton<SmsPersistHelper>::GetInstance();
1542 smsPersistHelper->CreateSmsHelper();
1543 AppExecFwk::InnerEvent::Pointer event = AppExecFwk::InnerEvent::Get(0, 0);
1544 smsPersistHelper->ProcessEvent(event);
1545 uint32_t releaseDataShareHelperEventId = 10000;
1546 event = AppExecFwk::InnerEvent::Get(releaseDataShareHelperEventId, 0);
1547 smsPersistHelper->ProcessEvent(event);
1548 EXPECT_TRUE(smsPersistHelper->smsDataShareHelper_ == nullptr);
1549 smsPersistHelper->RemoveEvent(releaseDataShareHelperEventId);
1550 }
1551
1552 /**
1553 * @tc.number Telephony_SmsMmsGtest_SmsPersistHelper_0003
1554 * @tc.name Test SmsPersistHelper
1555 * @tc.desc Function test
1556 */
1557 HWTEST_F(BranchSmsPartTest, SmsPersistHelper_0003, Function | MediumTest | Level1)
1558 {
1559 auto dataShareHelperMock = std::make_shared<DataShareHelperMock>();
1560 DelayedSingleton<SmsPersistHelper>::GetInstance()->smsDataShareHelper_ = dataShareHelperMock;
1561 EXPECT_CALL(*dataShareHelperMock, Query(_, _, _, _))
1562 .WillRepeatedly(Return(nullptr));
1563 EXPECT_CALL(*dataShareHelperMock, Release())
1564 .WillRepeatedly(Return(true));
1565 DataShare::DataShareValuesBucket values;
1566 uint16_t dataBaseId;
1567 DataShare::DataSharePredicates predicates;
1568 EXPECT_FALSE(DelayedSingleton<SmsPersistHelper>::GetInstance()->QuerySession(predicates, dataBaseId, dataBaseId));
1569 EXPECT_FALSE(DelayedSingleton<SmsPersistHelper>::GetInstance()->QuerySmsMmsForId(predicates, dataBaseId));
1570 std::vector<SmsReceiveIndexer> indexers;
1571 EXPECT_FALSE(DelayedSingleton<SmsPersistHelper>::GetInstance()->Query(predicates, indexers));
1572 EXPECT_FALSE(DelayedSingleton<SmsPersistHelper>::GetInstance()->QueryMaxGroupId(predicates, dataBaseId));
1573 DelayedSingleton<SmsPersistHelper>::GetInstance()->ReleaseDataShareHelper();
1574 }
1575
1576 /**
1577 * @tc.number Telephony_SmsMmsGtest_SmsReceiveHandler_0001
1578 * @tc.name Test SmsReceiveHandler
1579 * @tc.desc Function test
1580 */
1581 HWTEST_F(BranchSmsPartTest, SmsReceiveHandler_0001, Function | MediumTest | Level1)
1582 {
1583 auto dataShareHelperMock = std::make_shared<DataShareHelperMock>();
1584 DelayedSingleton<SmsPersistHelper>::GetInstance()->smsDataShareHelper_ = dataShareHelperMock;
1585 auto resultSet = std::make_shared<DataShareResultSetMock>();
1586 std::shared_ptr<SmsReceiveHandler> smsReceiveHandler = std::make_shared<GsmSmsReceiveHandler>(0);
1587 auto reliabilityHandler = std::make_shared<SmsReceiveReliabilityHandler>(0);
1588 auto indexer = std::make_shared<SmsReceiveIndexer>();
1589 indexer->msgCount_ = 1;
1590 auto pdus = std::make_shared<vector<string>>();
1591 EXPECT_CALL(*dataShareHelperMock, Query(_, _, _, _))
1592 .WillRepeatedly(Return(resultSet));
1593 EXPECT_CALL(*resultSet, GoToFirstRow())
1594 .WillRepeatedly(Return(0));
1595 EXPECT_CALL(*resultSet, GoToNextRow())
1596 .WillOnce(Return(0))
1597 .WillRepeatedly(Return(-1));
1598 EXPECT_CALL(*resultSet, GetColumnIndex(_, _))
__anon521935340202(const std::string &columnName, int &columnIndex) 1599 .WillRepeatedly(Invoke([](const std::string &columnName, int &columnIndex) -> int {
1600 if (columnName == SmsSubsection::SIZE) {
1601 columnIndex = 1;
1602 } else if (columnName == SmsSubsection::SUBSECTION_INDEX) {
1603 columnIndex = 2;
1604 }
1605 return 0;
1606 }));
1607 EXPECT_CALL(*resultSet, GetInt(_, _))
__anon521935340302(int columnIndex, int &value) 1608 .WillRepeatedly(Invoke([](int columnIndex, int &value) -> int {
1609 if (columnIndex == 1) {
1610 value = 1;
1611 } else if (columnIndex == 2) {
1612 value = 2;
1613 }
1614 return 0;
1615 }));
1616 EXPECT_CALL(*resultSet, GetString(_, _))
1617 .WillRepeatedly(Return(0));
1618 EXPECT_CALL(*resultSet, Close())
1619 .WillRepeatedly(Return(0));
1620 EXPECT_CALL(*dataShareHelperMock, Release())
1621 .WillRepeatedly(Return(0));
1622 EXPECT_FALSE(smsReceiveHandler->CombineMultiPageMessage(indexer, pdus, reliabilityHandler));
1623 DelayedSingleton<SmsPersistHelper>::GetInstance()->ReleaseDataShareHelper();
1624 }
1625
1626 /**
1627 * @tc.number Telephony_SmsMmsGtest_SmsReceiveHandler_0002
1628 * @tc.name Test SmsReceiveHandler
1629 * @tc.desc Function test
1630 */
1631 HWTEST_F(BranchSmsPartTest, SmsReceiveHandler_0002, Function | MediumTest | Level1)
1632 {
1633 auto dataShareHelperMock = std::make_shared<DataShareHelperMock>();
1634 DelayedSingleton<SmsPersistHelper>::GetInstance()->smsDataShareHelper_ = dataShareHelperMock;
1635 auto resultSet = std::make_shared<DataShareResultSetMock>();
1636 std::shared_ptr<SmsReceiveHandler> smsReceiveHandler = std::make_shared<GsmSmsReceiveHandler>(0);
1637 auto reliabilityHandler = std::make_shared<SmsReceiveReliabilityHandler>(0);
1638 auto indexer = std::make_shared<SmsReceiveIndexer>();
1639 indexer->msgCount_ = 4;
1640 auto pdus = std::make_shared<vector<string>>();
1641 EXPECT_CALL(*dataShareHelperMock, Query(_, _, _, _))
1642 .WillRepeatedly(Return(resultSet));
1643 EXPECT_CALL(*resultSet, GoToFirstRow())
1644 .WillRepeatedly(Return(0));
1645 EXPECT_CALL(*resultSet, GoToNextRow())
1646 .WillOnce(Return(0))
1647 .WillRepeatedly(Return(-1));
1648 EXPECT_CALL(*resultSet, GetColumnIndex(_, _))
1649 .WillRepeatedly(Return(0));
1650 EXPECT_CALL(*resultSet, GetInt(_, _))
1651 .WillRepeatedly(Return(-1));
1652 EXPECT_CALL(*resultSet, GetString(_, _))
1653 .WillRepeatedly(Return(-1));
1654 EXPECT_CALL(*resultSet, Close())
1655 .WillRepeatedly(Return(0));
1656 EXPECT_CALL(*dataShareHelperMock, Release())
1657 .WillRepeatedly(Return(0));
1658 EXPECT_FALSE(smsReceiveHandler->CombineMultiPageMessage(indexer, pdus, reliabilityHandler));
1659 DelayedSingleton<SmsPersistHelper>::GetInstance()->ReleaseDataShareHelper();
1660 }
1661
1662 /**
1663 * @tc.number Telephony_SmsMmsGtest_SmsReceiveHandler_0003
1664 * @tc.name Test SmsReceiveHandler
1665 * @tc.desc Function test
1666 */
1667 HWTEST_F(BranchSmsPartTest, SmsReceiveHandler_0003, Function | MediumTest | Level1)
1668 {
1669 auto dataShareHelperMock = std::make_shared<DataShareHelperMock>();
1670 DelayedSingleton<SmsPersistHelper>::GetInstance()->smsDataShareHelper_ = dataShareHelperMock;
1671 auto resultSet = std::make_shared<DataShareResultSetMock>();
1672 std::shared_ptr<SmsReceiveHandler> smsReceiveHandler = std::make_shared<GsmSmsReceiveHandler>(0);
1673 auto reliabilityHandler = std::make_shared<SmsReceiveReliabilityHandler>(0);
1674 auto indexer = std::make_shared<SmsReceiveIndexer>();
1675 indexer->msgCount_ = 1;
1676 auto pdus = std::make_shared<vector<string>>();
1677 EXPECT_CALL(*dataShareHelperMock, Query(_, _, _, _))
1678 .WillRepeatedly(Return(resultSet));
1679 EXPECT_CALL(*resultSet, GoToFirstRow())
1680 .WillRepeatedly(Return(0));
1681 EXPECT_CALL(*resultSet, GoToNextRow())
1682 .WillOnce(Return(0))
1683 .WillRepeatedly(Return(-1));
1684 EXPECT_CALL(*resultSet, GetColumnIndex(_, _))
1685 .WillRepeatedly(Return(0));
1686 EXPECT_CALL(*resultSet, GetInt(_, _))
__anon521935340402(int columnIndex, int &value) 1687 .WillRepeatedly(Invoke([](int columnIndex, int &value) -> int {
1688 value = 1;
1689 return 0;
1690 }));
1691 EXPECT_CALL(*resultSet, GetString(_, _))
1692 .WillRepeatedly(Return(0));
1693 EXPECT_CALL(*resultSet, Close())
1694 .WillRepeatedly(Return(0));
1695 EXPECT_CALL(*dataShareHelperMock, Release())
1696 .WillRepeatedly(Return(0));
1697 EXPECT_FALSE(smsReceiveHandler->CombineMultiPageMessage(indexer, pdus, reliabilityHandler));
1698 DelayedSingleton<SmsPersistHelper>::GetInstance()->ReleaseDataShareHelper();
1699 }
1700
1701 /**
1702 * @tc.number Telephony_SmsMmsGtest_SmsReceiveHandler_0004
1703 * @tc.name Test SmsReceiveHandler
1704 * @tc.desc Function test
1705 */
1706 HWTEST_F(BranchSmsPartTest, SmsReceiveHandler_0004, Function | MediumTest | Level1)
1707 {
1708 std::shared_ptr<SmsReceiveHandler> smsReceiveHandler = std::make_shared<GsmSmsReceiveHandler>(0);
1709 EXPECT_TRUE(smsReceiveHandler != nullptr);
1710 smsReceiveHandler->smsLockSerialNum_ = 0;
1711 smsReceiveHandler->smsRunningLockCount_ = 0;
1712 #ifdef ABILITY_POWER_SUPPORT
1713 smsReceiveHandler->smsRunningLock_ = nullptr;
1714 #endif
1715 AppExecFwk::InnerEvent::Pointer event =
1716 AppExecFwk::InnerEvent::Get(SmsReceiveHandler::RUNNING_LOCK_TIMEOUT_EVENT_ID, -1);
1717 smsReceiveHandler->ProcessEvent(event);
1718 event = AppExecFwk::InnerEvent::Get(SmsReceiveHandler::RUNNING_LOCK_TIMEOUT_EVENT_ID, 0);
1719 smsReceiveHandler->ProcessEvent(event);
1720 event = AppExecFwk::InnerEvent::Get(SmsReceiveHandler::DELAY_RELEASE_RUNNING_LOCK_EVENT_ID, 0);
1721 smsReceiveHandler->ProcessEvent(event);
1722 event = AppExecFwk::InnerEvent::Get(SmsReceiveHandler::RETRY_CONNECT_DATASHARE_EVENT_ID, 0);
1723 smsReceiveHandler->ProcessEvent(event);
1724 smsReceiveHandler->ReduceRunningLock();
1725 smsReceiveHandler->ReleaseRunningLock();
1726 smsReceiveHandler->ApplyRunningLock();
1727 #ifdef ABILITY_POWER_SUPPORT
1728 EXPECT_EQ(smsReceiveHandler->smsRunningLockCount_, 1);
1729 smsReceiveHandler->ApplyRunningLock();
1730 EXPECT_EQ(smsReceiveHandler->smsRunningLockCount_, 2);
1731 smsReceiveHandler->ReduceRunningLock();
1732 EXPECT_EQ(smsReceiveHandler->smsRunningLockCount_, 1);
1733 smsReceiveHandler->ReduceRunningLock();
1734 EXPECT_EQ(smsReceiveHandler->smsRunningLockCount_, 0);
1735 #endif
1736 }
1737
1738 /**
1739 * @tc.number Telephony_SmsMmsGtest_SmsReceiveHandler_0005
1740 * @tc.name Test SmsReceiveHandler
1741 * @tc.desc Function test
1742 */
1743 HWTEST_F(BranchSmsPartTest, SmsReceiveHandler_0005, Function | MediumTest | Level1)
1744 {
1745 std::shared_ptr<SmsReceiveIndexer> indexer = nullptr;
1746 std::shared_ptr<SmsReceiveHandler> smsReceiveHandler = std::make_shared<GsmSmsReceiveHandler>(0);
1747 smsReceiveHandler->UpdateMultiPageMessage(indexer, nullptr);
1748 EXPECT_FALSE(smsReceiveHandler->IsRepeatedMessagePart(indexer));
1749 indexer = std::make_shared<SmsReceiveIndexer>();
1750 smsReceiveHandler->UpdateMultiPageMessage(indexer, nullptr);
1751 indexer->msgCount_ = 2;
1752 smsReceiveHandler->CombineMessagePart(indexer);
1753 auto dataShareHelperMock = std::make_shared<DataShareHelperMock>();
1754 DelayedSingleton<SmsPersistHelper>::GetInstance()->smsDataShareHelper_ = dataShareHelperMock;
1755 auto resultSet = std::make_shared<DataShareResultSetMock>();
1756 auto reliabilityHandler = std::make_shared<SmsReceiveReliabilityHandler>(0);
1757 auto pdus = std::make_shared<vector<string>>();
1758 smsReceiveHandler->UpdateMultiPageMessage(indexer, pdus);
1759 EXPECT_CALL(*dataShareHelperMock, Query(_, _, _, _))
1760 .WillRepeatedly(Return(resultSet));
1761 EXPECT_CALL(*resultSet, GoToFirstRow())
1762 .WillRepeatedly(Return(0));
1763 EXPECT_CALL(*resultSet, GoToNextRow())
1764 .WillOnce(Return(0))
1765 .WillRepeatedly(Return(-1));
1766 EXPECT_CALL(*resultSet, GetColumnIndex(_, _))
1767 .WillRepeatedly(Return(0));
1768 EXPECT_CALL(*resultSet, GetInt(_, _))
__anon521935340502(int columnIndex, int &value) 1769 .WillRepeatedly(Invoke([](int columnIndex, int &value) -> int {
1770 value = 1;
1771 return 0;
1772 }));
1773 EXPECT_CALL(*resultSet, GetString(_, _))
__anon521935340602(int columnIndex, std::string &value) 1774 .WillRepeatedly(Invoke([](int columnIndex, std::string &value) -> int {
1775 value = "test";
1776 return 0;
1777 }));
1778 EXPECT_CALL(*resultSet, Close())
1779 .WillRepeatedly(Return(0));
1780 EXPECT_CALL(*dataShareHelperMock, Release())
1781 .WillRepeatedly(Return(true));
1782 EXPECT_TRUE(smsReceiveHandler->CombineMultiPageMessage(indexer, pdus, reliabilityHandler));
1783 EXPECT_FALSE(smsReceiveHandler->IsRepeatedMessagePart(indexer));
1784 std::shared_ptr<GsmSmsMessage> message = std::make_shared<GsmSmsMessage>();
1785 smsReceiveHandler->HandleReceivedSmsWithoutDataShare(message);
1786 indexer->msgSeqId_ = 1;
1787 EXPECT_TRUE(smsReceiveHandler->IsRepeatedMessagePart(indexer));
1788 std::make_shared<SmsReceiveReliabilityHandler>(0)->SmsReceiveReliabilityProcessing();
1789 DelayedSingleton<SmsPersistHelper>::GetInstance()->ReleaseDataShareHelper();
1790 }
1791
1792 /**
1793 * @tc.number Telephony_SmsMmsGtest_SmsReceiveReliabilityHandler_0001
1794 * @tc.name Test SmsReceiveReliabilityHandler
1795 * @tc.desc Function test
1796 */
1797 HWTEST_F(BranchSmsPartTest, SmsReceiveReliabilityHandler_0001, Function | MediumTest | Level1)
1798 {
1799 auto reliabilityHandler = std::make_shared<SmsReceiveReliabilityHandler>(0);
1800 auto indexer = std::make_shared<SmsReceiveIndexer>();
1801 auto pdus = std::make_shared<vector<string>>();
1802 indexer->originatingAddress_ = "10659401";
1803 reliabilityHandler->SendBroadcast(indexer, pdus);
1804 indexer->originatingAddress_ = "8610659401";
1805 reliabilityHandler->SendBroadcast(indexer, pdus);
1806 indexer->originatingAddress_ = "+8610659401";
1807 reliabilityHandler->SendBroadcast(indexer, pdus);
1808 indexer->originatingAddress_ = "+86106594011";
1809 reliabilityHandler->SendBroadcast(indexer, pdus);
1810 reliabilityHandler->HiSysEventCBResult(false);
1811 DelayedSingleton<SmsHiSysEvent>::GetInstance()->smsBroadcastStartTime_ = 0;
1812 reliabilityHandler->HiSysEventCBResult(true);
1813 EXPECT_NE(DelayedSingleton<SmsHiSysEvent>::GetInstance()->smsBroadcastStartTime_, 0);
1814 }
1815
1816 /**
1817 * @tc.number Telephony_SmsMmsGtest_SmsReceiveReliabilityHandler_0002
1818 * @tc.name Test SmsReceiveReliabilityHandler
1819 * @tc.desc Function test
1820 */
1821 HWTEST_F(BranchSmsPartTest, SmsReceiveReliabilityHandler_0002, Function | MediumTest | Level1)
1822 {
1823 auto reliabilityHandler = std::make_shared<SmsReceiveReliabilityHandler>(0);
1824 int32_t smsPagesCount = 0;
1825 std::vector<SmsReceiveIndexer> dbIndexers;
1826 SmsReceiveIndexer indexer;
1827 indexer.msgRefId_ = 1;
1828 indexer.msgSeqId_ = 1;
1829 std::vector<uint8_t> pdu = { 8, 145, 104, 49, 8, 32, 1, 5, 240, 68, 13, 145, 104, 145, 39, 32, 49, 100, 240,
1830 0, 0, 82, 64, 80, 34, 145, 17, 35, 160, 5, 0, 3, 1, 2, 1, 98, 177, 88, 44, 22, 139, 197, 98, 177, 88, 44,
1831 22, 139, 197, 98, 177, 152, 44, 54, 171, 209, 108, 55, 25, 142, 54, 163, 213, 108, 180, 90, 12, 55, 187,
1832 213, 104, 177, 88, 44, 22, 139, 197, 98, 177, 88, 44, 22, 139, 197, 98, 177, 88, 76, 22, 155, 213, 104,
1833 182, 155, 12, 71, 155, 209, 106, 54, 90, 45, 134, 155, 221, 106, 180, 88, 44, 22, 139, 197, 98, 177, 88,
1834 44, 22, 139, 197, 98, 177, 88, 44, 38, 139, 205, 106, 52, 219, 77, 134, 163, 205, 104, 53, 27, 173, 22,
1835 195, 205, 110, 53, 90, 44, 22, 139, 197, 98, 177, 88, 44, 22, 139, 197, 98, 177, 88, 44, 22, 147, 197, 102,
1836 53, 154, 237, 38, 195, 209, 102 };
1837 indexer.pdu_ = pdu;
1838 dbIndexers.push_back(indexer);
1839 indexer.msgSeqId_ = -1;
1840 dbIndexers.push_back(indexer);
1841 indexer.msgSeqId_ = MAX_SEGMENT_NUM + 1;
1842 dbIndexers.push_back(indexer);
1843 indexer.msgRefId_ = 2;
1844 dbIndexers.push_back(indexer);
1845 indexer.msgRefId_ = 1;
1846 indexer.pdu_ = {};
1847 dbIndexers.push_back(indexer);
1848 std::shared_ptr<std::vector<std::string>> userDataRaws = std::make_shared<std::vector<std::string>>();
1849 userDataRaws->assign(MAX_SEGMENT_NUM, "");
1850 reliabilityHandler->GetWapPushUserDataMultipage(smsPagesCount, dbIndexers, -1, userDataRaws);
1851 reliabilityHandler->GetWapPushUserDataMultipage(smsPagesCount, dbIndexers, 100, userDataRaws);
1852 reliabilityHandler->GetWapPushUserDataMultipage(smsPagesCount, dbIndexers, 1, userDataRaws);
1853 reliabilityHandler->GetWapPushUserDataMultipage(smsPagesCount, dbIndexers, 2, userDataRaws);
1854 reliabilityHandler->GetWapPushUserDataMultipage(smsPagesCount, dbIndexers, 0, userDataRaws);
1855 EXPECT_EQ(smsPagesCount, 1);
1856 reliabilityHandler->GetWapPushUserDataMultipage(smsPagesCount, dbIndexers, 0, userDataRaws);
1857 reliabilityHandler->GetWapPushUserDataMultipage(smsPagesCount, dbIndexers, 0, userDataRaws);
1858 EXPECT_EQ(smsPagesCount, 2);
1859 reliabilityHandler->DeleteMessageFormDb(0, 1);
1860 }
1861
1862 /**
1863 * @tc.number Telephony_SmsMmsGtest_SmsReceiveReliabilityHandler_0003
1864 * @tc.name Test SmsReceiveReliabilityHandler
1865 * @tc.desc Function test
1866 */
1867 HWTEST_F(BranchSmsPartTest, SmsReceiveReliabilityHandler_0003, Function | MediumTest | Level1)
1868 {
1869 auto reliabilityHandler = std::make_shared<SmsReceiveReliabilityHandler>(0);
1870 std::vector<SmsReceiveIndexer> dbIndexers;
1871 SmsReceiveIndexer indexer;
1872 indexer.destPort_ = 2948;
1873 indexer.msgCount_ = 1;
1874 std::vector<uint8_t> pdu = { 8, 145, 104, 49, 8, 32, 1, 5, 240, 68, 13, 145, 104, 145, 39, 32, 49, 100, 240,
1875 0, 0, 82, 64, 80, 34, 145, 17, 35, 160, 5, 0, 3, 1, 2, 1, 98, 177, 88, 44, 22, 139, 197, 98, 177, 88, 44,
1876 22, 139, 197, 98, 177, 152, 44, 54, 171, 209, 108, 55, 25, 142, 54, 163, 213, 108, 180, 90, 12, 55, 187,
1877 213, 104, 177, 88, 44, 22, 139, 197, 98, 177, 88, 44, 22, 139, 197, 98, 177, 88, 76, 22, 155, 213, 104,
1878 182, 155, 12, 71, 155, 209, 106, 54, 90, 45, 134, 155, 221, 106, 180, 88, 44, 22, 139, 197, 98, 177, 88,
1879 44, 22, 139, 197, 98, 177, 88, 44, 38, 139, 205, 106, 52, 219, 77, 134, 163, 205, 104, 53, 27, 173, 22,
1880 195, 205, 110, 53, 90, 44, 22, 139, 197, 98, 177, 88, 44, 22, 139, 197, 98, 177, 88, 44, 22, 147, 197, 102,
1881 53, 154, 237, 38, 195, 209, 102 };
1882 indexer.pdu_ = pdu;
1883 dbIndexers.push_back(indexer);
1884 indexer.msgCount_ = 2;
1885 dbIndexers.push_back(indexer);
1886 reliabilityHandler->CheckUnReceiveWapPush(dbIndexers);
1887 EXPECT_EQ(dbIndexers.size(), 0);
1888 }
1889
1890 /**
1891 * @tc.number Telephony_SmsMmsGtest_SmsNetworkPolicyManager_0001
1892 * @tc.name Test SmsNetworkPolicyManager
1893 * @tc.desc Function test
1894 */
1895 HWTEST_F(BranchSmsPartTest, SmsNetworkPolicyManager_0001, Function | MediumTest | Level1)
1896 {
1897 SmsNetworkPolicyManager manager(0);
1898 AppExecFwk::InnerEvent::Pointer event = AppExecFwk::InnerEvent::Get(1234567);
1899 manager.ProcessEvent(event);
1900 auto dataShareHelperMock = std::make_shared<DataShareHelperMock>();
1901 DelayedSingleton<SmsPersistHelper>::GetInstance()->smsDataShareHelper_ = dataShareHelperMock;
1902 EXPECT_CALL(*dataShareHelperMock, Delete(_, _))
1903 .WillRepeatedly(Return(0));
1904 EXPECT_CALL(*dataShareHelperMock, Release())
1905 .WillRepeatedly(Return(true));
1906 event = AppExecFwk::InnerEvent::Get(RadioEvent::RADIO_FACTORY_RESET);
1907 manager.ProcessEvent(event);
1908 DelayedSingleton<SmsPersistHelper>::GetInstance()->ReleaseDataShareHelper();
1909 event = nullptr;
1910 manager.ProcessEvent(event);
1911 std::function<void(bool isImsNetDomain, int32_t voiceServiceState)> callback = nullptr;
1912 EXPECT_EQ(manager.NetworkRegister(callback), std::nullopt);
1913 manager.NetworkUnregister(0);
1914 }
1915
1916 /**
1917 * @tc.number Telephony_SmsMmsGtest_GsmSmsReceiveHandler_0001
1918 * @tc.name Test GsmSmsReceiveHandler
1919 * @tc.desc Function test
1920 */
1921 HWTEST_F(BranchSmsPartTest, GsmSmsReceiveHandler_0001, Function | MediumTest | Level1)
1922 {
1923 std::vector<uint8_t> pdu = { 8, 145, 104, 49, 8, 32, 1, 5, 240, 68, 13, 145, 104, 145, 39, 32, 49, 100, 240,
1924 0, 0, 82, 64, 80, 34, 145, 17, 35, 160, 5, 0, 3, 1, 2, 1, 98, 177, 88, 44, 22, 139, 197, 98, 177, 88, 44,
1925 22, 139, 197, 98, 177, 152, 44, 54, 171, 209, 108, 55, 25, 142, 54, 163, 213, 108, 180, 90, 12, 55, 187,
1926 213, 104, 177, 88, 44, 22, 139, 197, 98, 177, 88, 44, 22, 139, 197, 98, 177, 88, 76, 22, 155, 213, 104,
1927 182, 155, 12, 71, 155, 209, 106, 54, 90, 45, 134, 155, 221, 106, 180, 88, 44, 22, 139, 197, 98, 177, 88,
1928 44, 22, 139, 197, 98, 177, 88, 44, 38, 139, 205, 106, 52, 219, 77, 134, 163, 205, 104, 53, 27, 173, 22,
1929 195, 205, 110, 53, 90, 44, 22, 139, 197, 98, 177, 88, 44, 22, 139, 197, 98, 177, 88, 44, 22, 147, 197, 102,
1930 53, 154, 237, 38, 195, 209, 102 };
1931 std::shared_ptr<SmsBaseMessage> baseMessage = GsmSmsMessage::CreateMessage(StringUtils::StringToHex(pdu));
1932 EXPECT_NE(baseMessage, nullptr);
1933 std::shared_ptr<GsmSmsReceiveHandler> smsReceiveHandler = std::make_shared<GsmSmsReceiveHandler>(0);
1934 smsReceiveHandler->HandleReceivedSmsWithoutDataShare(baseMessage);
1935 smsReceiveHandler->HandleRemainDataShare(baseMessage);
1936 smsReceiveHandler->HandleSmsByType(baseMessage);
1937 smsReceiveHandler->HandleRemainDataShare(nullptr);
1938 EXPECT_NE(smsReceiveHandler->HandleAck(baseMessage), AckIncomeCause::SMS_ACK_UNKNOWN_ERROR);
1939 EXPECT_EQ(smsReceiveHandler->HandleAck(nullptr), AckIncomeCause::SMS_ACK_UNKNOWN_ERROR);
1940 std::shared_ptr<CdmaSmsMessage> message = std::make_shared<CdmaSmsMessage>();
1941 EXPECT_NE(message, nullptr);
1942 message->transMsg_ = std::make_unique<struct CdmaTransportMsg>();
1943 EXPECT_NE(message->transMsg_, nullptr);
1944 (void)memset_s(message->transMsg_.get(), sizeof(struct CdmaTransportMsg), 0x00, sizeof(struct CdmaTransportMsg));
1945 std::make_shared<CdmaSmsReceiveHandler>(0)->HandleRemainDataShare(message);
1946 EXPECT_NE(std::make_shared<CdmaSmsReceiveHandler>(0)->HandleAck(message), AckIncomeCause::SMS_ACK_UNKNOWN_ERROR);
1947 pdu = { 1, 1, 2, 0, 4, 8, 19, 0, 3, 16, 8, 208, 1, 6, 16, 44, 40, 112, 225, 66, 8, 1, 192, 12, 1, 192 };
1948 message = CdmaSmsMessage::CreateMessage(StringUtils::StringToHex(pdu));
1949 EXPECT_NE(message, nullptr);
1950 auto dataShareHelperMock = std::make_shared<DataShareHelperMock>();
1951 DelayedSingleton<SmsPersistHelper>::GetInstance()->smsDataShareHelper_ = dataShareHelperMock;
1952 EXPECT_CALL(*dataShareHelperMock, Insert(_, _))
1953 .WillRepeatedly(Return(0));
1954 EXPECT_CALL(*dataShareHelperMock, Delete(_, _))
1955 .WillOnce(Return(-1))
1956 .WillRepeatedly(Return(0));
1957 std::make_shared<CdmaSmsReceiveHandler>(0)->HandleRemainDataShare(message);
1958 std::make_shared<CdmaSmsReceiveHandler>(0)->HandleRemainDataShare(message);
1959 EXPECT_NE(std::make_shared<CdmaSmsReceiveHandler>(0)->HandleAck(message), AckIncomeCause::SMS_ACK_UNKNOWN_ERROR);
1960 DelayedSingleton<SmsPersistHelper>::GetInstance()->smsDataShareHelper_ = nullptr;
1961 }
1962
1963 /**
1964 * @tc.number Telephony_SmsMmsGtest_GsmSmsTpduCodec_0014
1965 * @tc.name Test GsmSmsTpduCodec
1966 * @tc.desc Function test
1967 */
1968 HWTEST_F(BranchSmsPartTest, GsmSmsTpduCodec_0014, Function | MediumTest | Level1)
1969 {
1970 auto tpduCodec = std::make_shared<GsmSmsTpduCodec>();
1971 SmsStatusReport pStatusRep;
1972 SmsSubmit pSmsSub;
1973
1974 auto encode = std::make_shared<GsmSmsTpduEncode>(tpduCodec->uDataCodec_, tpduCodec->paramCodec_, tpduCodec);
1975 auto encodeBuffer = std::make_shared<SmsWriteBuffer>();
1976 encodeBuffer->data_[0] = 1;
1977 EXPECT_FALSE(encode->EncodeStatusReportPdu(*encodeBuffer, nullptr));
1978 EXPECT_FALSE(encode->EncodeStatusReportPdu(*encodeBuffer, &pStatusRep));
1979 pStatusRep.bMoreMsg = true;
1980 pStatusRep.bStatusReport = true;
1981 pStatusRep.bHeaderInd = true;
1982 pStatusRep.paramInd = 1;
1983 EXPECT_FALSE(encode->EncodeStatusReportPdu(*encodeBuffer, &pStatusRep));
1984 pStatusRep.paramInd = 2;
1985 EXPECT_FALSE(encode->EncodeStatusReportPdu(*encodeBuffer, &pStatusRep));
1986 pStatusRep.paramInd = 4;
1987 EXPECT_FALSE(encode->EncodeStatusReportPdu(*encodeBuffer, &pStatusRep));
1988 encode->paramCodec_ = nullptr;
1989 EXPECT_FALSE(encode->EncodeDeliverReportPartData(*encodeBuffer, nullptr));
1990 EXPECT_FALSE(encode->EncodeStatusReportPartData(*encodeBuffer, &pStatusRep));
1991 encode->uDataCodec_ = nullptr;
1992 EXPECT_FALSE(encode->EncodeDeliverReportPartData(*encodeBuffer, nullptr));
1993 EXPECT_FALSE(encode->EncodeStatusReportData(*encodeBuffer, &pStatusRep, 0));
1994
1995 auto decode = std::make_shared<GsmSmsTpduDecode>(tpduCodec->uDataCodec_, tpduCodec->paramCodec_, tpduCodec);
1996 auto decodeBuffer = std::make_shared<SmsReadBuffer>("00");
1997 decodeBuffer->data_[0] = 1;
1998 EXPECT_FALSE(decode->DecodeSubmit(*decodeBuffer, &pSmsSub));
1999 EXPECT_FALSE(decode->DecodeSubmit(*decodeBuffer, nullptr));
2000 SmsDeliver pDeliver;
2001 EXPECT_FALSE(decode->DecodeDeliver(*decodeBuffer, &pDeliver));
2002 EXPECT_FALSE(decode->DecodeDeliver(*decodeBuffer, nullptr));
2003 EXPECT_FALSE(decode->DecodeStatusReport(*decodeBuffer, &pStatusRep));
2004 EXPECT_FALSE(decode->DecodeStatusReport(*decodeBuffer, nullptr));
2005 encode->EncodeStatusReportData(*encodeBuffer, &pStatusRep, 0);
2006 decode->DecodeStatusReportData(*decodeBuffer, &pStatusRep);
2007 decode->tpdu_ = nullptr;
2008 EXPECT_FALSE(decode->DecodeStatusReportData(*decodeBuffer, &pStatusRep));
2009 EXPECT_FALSE(decode->DecodeDeliver(*decodeBuffer, &pDeliver));
2010 EXPECT_FALSE(decode->DecodeSubmit(*decodeBuffer, &pSmsSub));
2011 decode->paramCodec_ = nullptr;
2012 EXPECT_FALSE(decode->DecodeSubmitPartData(*decodeBuffer, &pSmsSub));
2013 EXPECT_FALSE(decode->DecodeDeliver(*decodeBuffer, &pDeliver));
2014 EXPECT_FALSE(decode->DecodeStatusReport(*decodeBuffer, &pStatusRep));
2015 decode->uDataCodec_ = nullptr;
2016 EXPECT_FALSE(decode->DecodeSubmitPartData(*decodeBuffer, &pSmsSub));
2017 EXPECT_FALSE(decode->DecodeDeliverPartData(*decodeBuffer, nullptr));
2018 EXPECT_FALSE(decode->DecodeStatusReportData(*decodeBuffer, &pStatusRep));
2019 }
2020
2021 /**
2022 * @tc.number Telephony_SmsMmsGtest_GsmUserDataPdu_0001
2023 * @tc.name Test GsmUserDataPdu
2024 * @tc.desc Function test
2025 */
2026 HWTEST_F(BranchSmsPartTest, GsmUserDataPdu_0001, Function | MediumTest | Level1)
2027 {
2028 SmsWriteBuffer wBuf;
2029 wBuf.data_ = nullptr;
2030 SmsReadBuffer rBuf("");
2031 rBuf.data_ = nullptr;
2032 GsmUserDataPdu gsmUserDataPdu;
2033 uint8_t udhl = 0;
2034 EXPECT_FALSE(gsmUserDataPdu.GetHeaderCnt(rBuf, nullptr, udhl, MAX_UD_HEADER_NUM));
2035 SmsUDH header;
2036 header.udhType = UDH_SINGLE_SHIFT;
2037 gsmUserDataPdu.EncodeHeader(wBuf, header);
2038 EXPECT_FALSE(gsmUserDataPdu.DecodeHeaderPartData(rBuf, header, 0));
2039 header.udhType = UDH_LOCKING_SHIFT;
2040 gsmUserDataPdu.EncodeHeader(wBuf, header);
2041 EXPECT_FALSE(gsmUserDataPdu.DecodeHeaderPartData(rBuf, header, 0));
2042 header.udhType = UDH_NONE;
2043 gsmUserDataPdu.EncodeHeaderAppPort8bit(wBuf, header);
2044 EXPECT_FALSE(gsmUserDataPdu.DecodeHeaderPartData(rBuf, header, 0));
2045 header.udhType = UDH_CONCAT_8BIT;
2046 gsmUserDataPdu.EncodeHeaderAppPort16bit(wBuf, header);
2047 uint16_t len = 0;
2048 EXPECT_FALSE(gsmUserDataPdu.DecodeHeader(rBuf, header, len));
2049 header.udhType = UDH_APP_PORT_8BIT;
2050 gsmUserDataPdu.EncodeHeaderReplyAddress(wBuf, header);
2051 EXPECT_FALSE(gsmUserDataPdu.DecodeHeader(rBuf, header, len));
2052 gsmUserDataPdu.EncodeHeaderConcat8Bit(wBuf, header);
2053 gsmUserDataPdu.EncodeHeaderConcat16Bit(wBuf, header);
2054 EXPECT_FALSE(gsmUserDataPdu.DecodeHeaderConcat8Bit(rBuf, header));
2055 EXPECT_FALSE(gsmUserDataPdu.DecodeHeaderConcat16Bit(rBuf, header));
2056 EXPECT_FALSE(gsmUserDataPdu.DecodeHeaderAppPort16Bit(rBuf, header));
2057 EXPECT_FALSE(gsmUserDataPdu.DecodeHeaderSpecialSms(rBuf, header));
2058 EXPECT_FALSE(gsmUserDataPdu.DecodeHeaderSingleShift(rBuf, header));
2059 EXPECT_FALSE(gsmUserDataPdu.DecodeHeaderLockingShift(rBuf, header));
2060 EXPECT_FALSE(gsmUserDataPdu.DecodeHeaderDefaultCase(rBuf, header));
2061 }
2062
2063 /**
2064 * @tc.number Telephony_SmsMmsGtest_SmsBroadcastSubscriberReceiver_0001
2065 * @tc.name Test SmsBroadcastSubscriberReceiver
2066 * @tc.desc Function test
2067 */
2068 HWTEST_F(BranchSmsPartTest, SmsBroadcastSubscriberReceiver_0001, Function | MediumTest | Level1)
2069 {
2070 using namespace EventFwk;
2071 auto dataShareHelperMock = std::make_shared<DataShareHelperMock>();
2072 DelayedSingleton<SmsPersistHelper>::GetInstance()->smsDataShareHelper_ = dataShareHelperMock;
2073 EXPECT_CALL(*dataShareHelperMock, Delete(_, _))
2074 .WillRepeatedly(Return(0));
2075 MatchingSkills smsSkills;
2076 smsSkills.AddEvent(CommonEventSupport::COMMON_EVENT_SMS_RECEIVE_COMPLETED);
2077 CommonEventSubscribeInfo smsSubscriberInfo(smsSkills);
2078 smsSubscriberInfo.SetThreadMode(EventFwk::CommonEventSubscribeInfo::COMMON);
2079 auto receiver = std::make_shared<SmsBroadcastSubscriberReceiver>(smsSubscriberInfo);
2080 Want want;
2081 CommonEventData data;
2082 std::string addr = "";
2083 want.SetAction(CommonEventSupport::COMMON_EVENT_SMS_RECEIVE_COMPLETED);
2084 want.SetParam(SmsBroadcastSubscriberReceiver::SMS_BROADCAST_ADDRESS_KEY, addr);
2085 want.SetParam(SmsBroadcastSubscriberReceiver::SMS_BROADCAST_DATABASE_ID_KEY, 1);
2086 data.SetWant(want);
2087 receiver->OnReceiveEvent(data);
2088
2089 addr = "addr";
2090 want.SetParam(SmsBroadcastSubscriberReceiver::SMS_BROADCAST_ADDRESS_KEY, addr);
2091 data.SetWant(want);
2092 receiver->OnReceiveEvent(data);
2093
2094 want.SetAction(CommonEventSupport::COMMON_EVENT_SMS_WAPPUSH_RECEIVE_COMPLETED);
2095 data.SetWant(want);
2096 receiver->OnReceiveEvent(data);
2097
2098 want.SetAction("invalid action");
2099 data.SetWant(want);
2100 receiver->OnReceiveEvent(data);
2101 DelayedSingleton<SmsPersistHelper>::GetInstance()->smsDataShareHelper_ = nullptr;
2102
2103 SmsWapPushHandler wapPushHandler(0);
2104 EXPECT_FALSE(wapPushHandler.SendWapPushMessageBroadcast(nullptr));
2105 }
2106 } // namespace Telephony
2107 } // namespace OHOS
2108