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 "random"
20 #include "delivery_short_message_callback_stub.h"
21 #include "gtest/gtest.h"
22 #include "gsm_sms_param_decode.h"
23 #include "gsm_sms_tpdu_encode.h"
24 #include "send_short_message_callback_stub.h"
25 #include "sms_misc_manager.h"
26 #include "sms_mms_gtest.h"
27 #include "sms_service.h"
28 #include "sms_persist_helper.h"
29 #include "system_ability_definition.h"
30
31 namespace OHOS {
32 namespace Telephony {
33 using namespace testing::ext;
34
35 namespace {
36 const std::string TEST_SOURCE_DATA = "srcData";
37 const std::string SMS_ADDR_ONE = "";
38 const std::string SMS_ADDR_TWO = " ";
39 const std::string SMS_ADDR_THREE = " 123 ";
40 const std::string SMS_ADDR_FOUR = "1 23";
41 const std::string SMS_ADDR_FIVE = " a 123 ";
42 const std::string SEND_MMS_FILE_URL = "1,2,";
43 const std::string VNET_MMSC = "http://mmsc.vnet.mobi";
44 static constexpr uint8_t MAX_GSM_7BIT_DATA_LEN = 160;
45 static constexpr uint8_t MAX_SMSC_LEN = 20;
46 } // namespace
47
48 class BranchSmsPartTest : public testing::Test {
49 public:
50 static void SetUpTestCase();
51 static void TearDownTestCase();
52 void SetUp();
53 void TearDown();
54 };
SetUpTestCase()55 void BranchSmsPartTest::SetUpTestCase() {}
56
TearDownTestCase()57 void BranchSmsPartTest::TearDownTestCase() {}
58
SetUp()59 void BranchSmsPartTest::SetUp() {}
60
TearDown()61 void BranchSmsPartTest::TearDown() {}
62
63 /**
64 * @tc.number Telephony_SmsMmsGtest_SmsInterfaceStub_0001
65 * @tc.name Test SmsInterfaceStub
66 * @tc.desc Function test
67 */
68 HWTEST_F(BranchSmsPartTest, SmsInterfaceStub_0001, Function | MediumTest | Level1)
69 {
70 AccessMmsToken token;
71 int32_t slotId = 0;
72 MessageParcel dataParcel;
73 dataParcel.WriteInt32(slotId);
74 dataParcel.WriteBuffer(TEST_SOURCE_DATA.c_str(), TEST_SOURCE_DATA.size());
75 dataParcel.RewindRead(0);
76 MessageParcel replyParcel;
77 uint32_t code = 0;
78 MessageOption option(MessageOption::TF_SYNC);
79 DelayedSingleton<SmsService>::GetInstance()->OnRemoteRequest(code, dataParcel, replyParcel, option);
80 DelayedSingleton<SmsService>::GetInstance()->OnSendSmsTextRequest(dataParcel, replyParcel, option);
81 DelayedSingleton<SmsService>::GetInstance()->OnSendSmsTextWithoutSaveRequest(dataParcel, replyParcel, option);
82 DelayedSingleton<SmsService>::GetInstance()->OnSendSmsDataRequest(dataParcel, replyParcel, option);
83 DelayedSingleton<SmsService>::GetInstance()->OnGetSmscAddr(dataParcel, replyParcel, option);
84 DelayedSingleton<SmsService>::GetInstance()->OnAddSimMessage(dataParcel, replyParcel, option);
85 DelayedSingleton<SmsService>::GetInstance()->OnUpdateSimMessage(dataParcel, replyParcel, option);
86 DelayedSingleton<SmsService>::GetInstance()->OnGetAllSimMessages(dataParcel, replyParcel, option);
87 DelayedSingleton<SmsService>::GetInstance()->OnSplitMessage(dataParcel, replyParcel, option);
88 DelayedSingleton<SmsService>::GetInstance()->OnCreateMessage(dataParcel, replyParcel, option);
89 DelayedSingleton<SmsService>::GetInstance()->OnGetBase64Encode(dataParcel, replyParcel, option);
90 DelayedSingleton<SmsService>::GetInstance()->OnGetBase64Decode(dataParcel, replyParcel, option);
91 DelayedSingleton<SmsService>::GetInstance()->OnGetEncodeStringFunc(dataParcel, replyParcel, option);
92 DelayedSingleton<SmsService>::GetInstance()->OnGetSmsSegmentsInfo(dataParcel, replyParcel, option);
93
94 MessageParcel sendTextParcel;
95 sendTextParcel.WriteInt32(0);
96 sendTextParcel.WriteString16(Str8ToStr16(TEST_SOURCE_DATA));
97 sendTextParcel.WriteString16(Str8ToStr16(TEST_SOURCE_DATA));
98 sendTextParcel.WriteString16(Str8ToStr16(TEST_SOURCE_DATA));
99 sendTextParcel.WriteString(TEST_SOURCE_DATA);
100 DelayedSingleton<SmsService>::GetInstance()->OnSendSmsTextRequest(sendTextParcel, replyParcel, option);
101 sendTextParcel.WriteInt32(-1);
102 DelayedSingleton<SmsService>::GetInstance()->OnSendSmsTextRequest(sendTextParcel, replyParcel, option);
103 int32_t result = replyParcel.ReadInt32();
104 EXPECT_GE(result, 0);
105
106 MessageParcel sendDataParcel;
107 dataParcel.WriteInt32(0);
108 dataParcel.WriteString16(Str8ToStr16(TEST_SOURCE_DATA));
109 dataParcel.WriteString16(Str8ToStr16(TEST_SOURCE_DATA));
110 dataParcel.WriteInt16(0);
111 dataParcel.WriteInt16(TEST_SOURCE_DATA.size());
112 dataParcel.WriteRawData(TEST_SOURCE_DATA.c_str(), TEST_SOURCE_DATA.size());
113 DelayedSingleton<SmsService>::GetInstance()->OnSendSmsDataRequest(dataParcel, replyParcel, option);
114 sendTextParcel.WriteInt32(-1);
115 DelayedSingleton<SmsService>::GetInstance()->OnSendSmsDataRequest(dataParcel, replyParcel, option);
116 result = replyParcel.ReadInt32();
117 EXPECT_GE(result, -1);
118 }
119
120 /**
121 * @tc.number Telephony_SmsMmsGtest_SmsInterfaceStub_0002
122 * @tc.name Test SmsInterfaceStub
123 * @tc.desc Function test
124 */
125 HWTEST_F(BranchSmsPartTest, SmsInterfaceStub_0002, Function | MediumTest | Level1)
126 {
127 std::u16string desAddr = Str8ToStr16(SMS_ADDR_ONE);
128 DelayedSingleton<SmsService>::GetInstance()->RemoveSpacesInDesAddr(desAddr);
129 EXPECT_GE(desAddr.size(), 0);
130 desAddr = Str8ToStr16(SMS_ADDR_TWO);
131 DelayedSingleton<SmsService>::GetInstance()->RemoveSpacesInDesAddr(desAddr);
132 EXPECT_GE(desAddr.size(), 0);
133 desAddr = Str8ToStr16(SMS_ADDR_THREE);
134 DelayedSingleton<SmsService>::GetInstance()->RemoveSpacesInDesAddr(desAddr);
135 EXPECT_GE(desAddr.size(), 0);
136 desAddr = Str8ToStr16(SMS_ADDR_FOUR);
137 DelayedSingleton<SmsService>::GetInstance()->RemoveSpacesInDesAddr(desAddr);
138 EXPECT_GE(desAddr.size(), 0);
139 desAddr = Str8ToStr16(SMS_ADDR_FIVE);
140 DelayedSingleton<SmsService>::GetInstance()->RemoveSpacesInDesAddr(desAddr);
141 EXPECT_GE(desAddr.size(), 0);
142
143 MessageParcel setSmscParcel;
144 MessageParcel replyParcel;
145 MessageOption option(MessageOption::TF_SYNC);
146 setSmscParcel.WriteInt32(0);
147 setSmscParcel.WriteString16(Str8ToStr16(TEST_SOURCE_DATA));
148 DelayedSingleton<SmsService>::GetInstance()->OnSetSmscAddr(setSmscParcel, replyParcel, option);
149 MessageParcel getSmscParcel;
150 getSmscParcel.WriteInt32(0);
151 DelayedSingleton<SmsService>::GetInstance()->OnGetSmscAddr(getSmscParcel, replyParcel, option);
152 DelayedSingleton<SmsService>::GetInstance()->OnGetAllSimMessages(getSmscParcel, replyParcel, option);
153 DelayedSingleton<SmsService>::GetInstance()->OnSetDefaultSmsSlotId(getSmscParcel, replyParcel, option);
154 DelayedSingleton<SmsService>::GetInstance()->OnGetDefaultSmsSlotId(getSmscParcel, replyParcel, option);
155 int32_t result = replyParcel.ReadInt32();
156 EXPECT_GE(result, 0);
157
158 MessageParcel addSimMsgParcel;
159 addSimMsgParcel.WriteInt32(0);
160 addSimMsgParcel.WriteString16(Str8ToStr16(TEST_SOURCE_DATA));
161 addSimMsgParcel.WriteString16(Str8ToStr16(TEST_SOURCE_DATA));
162 addSimMsgParcel.WriteUint32(0);
163 DelayedSingleton<SmsService>::GetInstance()->OnAddSimMessage(addSimMsgParcel, replyParcel, option);
164 result = replyParcel.ReadInt32();
165 EXPECT_GE(result, 0);
166
167 MessageParcel delSimMsgParcel;
168 delSimMsgParcel.WriteInt32(0);
169 delSimMsgParcel.WriteUint32(0);
170 DelayedSingleton<SmsService>::GetInstance()->OnDelSimMessage(delSimMsgParcel, replyParcel, option);
171 result = replyParcel.ReadInt32();
172 EXPECT_GE(result, 0);
173 }
174
175 /**
176 * @tc.number Telephony_SmsMmsGtest_SmsInterfaceStub_0003
177 * @tc.name Test SmsInterfaceStub
178 * @tc.desc Function test
179 */
180 HWTEST_F(BranchSmsPartTest, SmsInterfaceStub_0003, Function | MediumTest | Level1)
181 {
182 MessageParcel simMsgParcel;
183 MessageParcel replyParcel;
184 MessageOption option(MessageOption::TF_SYNC);
185 simMsgParcel.WriteInt32(0);
186 simMsgParcel.WriteUint32(0);
187 simMsgParcel.WriteUint32(0);
188 simMsgParcel.WriteString16(Str8ToStr16(TEST_SOURCE_DATA));
189 simMsgParcel.WriteString16(Str8ToStr16(TEST_SOURCE_DATA));
190 DelayedSingleton<SmsService>::GetInstance()->OnUpdateSimMessage(simMsgParcel, replyParcel, option);
191 int32_t result = replyParcel.ReadInt32();
192 EXPECT_GE(result, 0);
193
194 MessageParcel SetImsSmsParcel;
195 SetImsSmsParcel.WriteInt32(0);
196 SetImsSmsParcel.WriteInt32(false);
197 DelayedSingleton<SmsService>::GetInstance()->OnSetImsSmsConfig(SetImsSmsParcel, replyParcel, option);
198 result = replyParcel.ReadInt32();
199 EXPECT_GE(result, 0);
200
201 MessageParcel splitMsgParcel;
202 splitMsgParcel.WriteString16(Str8ToStr16(TEST_SOURCE_DATA));
203 DelayedSingleton<SmsService>::GetInstance()->OnSplitMessage(splitMsgParcel, replyParcel, option);
204 DelayedSingleton<SmsService>::GetInstance()->OnGetBase64Encode(splitMsgParcel, replyParcel, option);
205 DelayedSingleton<SmsService>::GetInstance()->OnGetBase64Decode(splitMsgParcel, replyParcel, option);
206 result = replyParcel.ReadInt32();
207 EXPECT_GE(result, 0);
208
209 MessageParcel createMsgParcel;
210 createMsgParcel.WriteString(TEST_SOURCE_DATA);
211 createMsgParcel.WriteString(TEST_SOURCE_DATA);
212 DelayedSingleton<SmsService>::GetInstance()->OnCreateMessage(createMsgParcel, replyParcel, option);
213 result = replyParcel.ReadInt32();
214 EXPECT_GE(result, 0);
215
216 MessageParcel segmentParcel;
217 segmentParcel.WriteInt32(0);
218 segmentParcel.WriteString16(Str8ToStr16(TEST_SOURCE_DATA));
219 segmentParcel.WriteBool(false);
220 DelayedSingleton<SmsService>::GetInstance()->OnGetSmsSegmentsInfo(segmentParcel, replyParcel, option);
221 result = replyParcel.ReadInt32();
222 EXPECT_GE(result, 0);
223
224 MessageParcel formatParcel;
225 DelayedSingleton<SmsService>::GetInstance()->OnGetImsShortMessageFormat(formatParcel, replyParcel, option);
226 result = replyParcel.ReadInt32();
227 DelayedSingleton<SmsService>::GetInstance()->OnGetDefaultSmsSimId(formatParcel, replyParcel, option);
228 result = replyParcel.ReadInt32();
229 EXPECT_GE(result, 0);
230 }
231
232 /**
233 * @tc.number Telephony_SmsMmsGtest_SmsInterfaceManager_0001
234 * @tc.name Test SmsInterfaceManager
235 * @tc.desc Function test
236 */
237 HWTEST_F(BranchSmsPartTest, SmsInterfaceManager_0001, Function | MediumTest | Level1)
238 {
239 auto interfaceManager = std::make_shared<SmsInterfaceManager>(0);
240 ASSERT_NE(interfaceManager, nullptr);
241 interfaceManager->HasSmsCapability();
242 std::string dataStr = TEST_SOURCE_DATA;
243 auto callStub = iface_cast<ISendShortMessageCallback>(new SendShortMessageCallbackStub());
244 auto deliveryStub = iface_cast<IDeliveryShortMessageCallback>(new DeliveryShortMessageCallbackStub());
245 std::string emptyStr = "";
246 uint16_t dataBaseId = 0;
247 interfaceManager->TextBasedSmsDelivery(dataStr, dataStr, dataStr, callStub, deliveryStub, dataBaseId);
248 interfaceManager->TextBasedSmsDelivery(dataStr, emptyStr, dataStr, callStub, deliveryStub, dataBaseId);
249 interfaceManager->TextBasedSmsDelivery(dataStr, dataStr, emptyStr, callStub, deliveryStub, dataBaseId);
250 int32_t result = interfaceManager->TextBasedSmsDelivery(dataStr, emptyStr, emptyStr,
251 callStub, deliveryStub, dataBaseId);
252 EXPECT_GE(result, 0);
253
254 const uint8_t *data = reinterpret_cast<const uint8_t *>(dataStr.c_str());
255 interfaceManager->DataBasedSmsDelivery(dataStr, dataStr, 0, data, dataStr.size(), callStub, deliveryStub);
256 interfaceManager->DataBasedSmsDelivery(dataStr, emptyStr, 0, data, dataStr.size(), callStub, deliveryStub);
257 interfaceManager->DataBasedSmsDelivery(dataStr, dataStr, 0, nullptr, 0, callStub, deliveryStub);
258 interfaceManager->smsSendManager_ = nullptr;
259 interfaceManager->TextBasedSmsDelivery(dataStr, dataStr, dataStr, callStub, deliveryStub, dataBaseId);
260 result = interfaceManager->DataBasedSmsDelivery(dataStr, dataStr, 0, data, dataStr.size(), callStub, deliveryStub);
261 EXPECT_GE(result, 0);
262
263 interfaceManager->AddSimMessage(dataStr, dataStr, ISmsServiceInterface::SIM_MESSAGE_STATUS_UNREAD);
264 interfaceManager->UpdateSimMessage(0, ISmsServiceInterface::SIM_MESSAGE_STATUS_UNREAD, dataStr, dataStr);
265 std::vector<ShortMessage> message;
266 interfaceManager->GetAllSimMessages(message);
267 result = interfaceManager->SetSmscAddr(dataStr);
268 EXPECT_GE(result, 0);
269
270 std::u16string smsc;
271 interfaceManager->GetSmscAddr(smsc);
272 interfaceManager->SetCBConfig(false, 0, 1, 0);
273 result = interfaceManager->SetImsSmsConfig(0, false);
274 EXPECT_GE(result, 0);
275
276 interfaceManager->SetDefaultSmsSlotId(0);
277 interfaceManager->GetDefaultSmsSlotId();
278 int32_t simId;
279 interfaceManager->GetDefaultSmsSimId(simId);
280 std::vector<std::u16string> splitMessage;
281 result = interfaceManager->SplitMessage(dataStr, splitMessage);
282 EXPECT_GE(result, 0);
283 }
284
285 /**
286 * @tc.number Telephony_SmsMmsGtest_SmsInterfaceManager_0002
287 * @tc.name Test SmsInterfaceManager
288 * @tc.desc Function test
289 */
290 HWTEST_F(BranchSmsPartTest, SmsInterfaceManager_0002, Function | MediumTest | Level1)
291 {
292 auto interfaceManager = std::make_shared<SmsInterfaceManager>(0);
293 ASSERT_NE(interfaceManager, nullptr);
294 LengthInfo outInfo;
295 std::string dataStr = TEST_SOURCE_DATA;
296 interfaceManager->GetSmsSegmentsInfo(dataStr, false, outInfo);
297 bool isSupported = false;
298 interfaceManager->IsImsSmsSupported(0, isSupported);
299 std::u16string format;
300 interfaceManager->GetImsShortMessageFormat(format);
301 int32_t result = interfaceManager->HasSmsCapability();
302 EXPECT_GE(result, 0);
303
304 std::u16string mmsc = u"";
305 std::u16string data = u"";
306 std::u16string ua = u"";
307 std::u16string uaprof = u"";
308 interfaceManager->SendMms(mmsc, data, ua, uaprof);
309 result = interfaceManager->DownloadMms(mmsc, data, ua, uaprof);
310 EXPECT_GE(result, 0);
311
312 interfaceManager->smsMiscManager_ = nullptr;
313 interfaceManager->AddSimMessage(dataStr, dataStr, ISmsServiceInterface::SIM_MESSAGE_STATUS_UNREAD);
314 interfaceManager->UpdateSimMessage(0, ISmsServiceInterface::SIM_MESSAGE_STATUS_UNREAD, dataStr, dataStr);
315 std::vector<ShortMessage> message;
316 interfaceManager->GetAllSimMessages(message);
317 interfaceManager->SetSmscAddr(dataStr);
318 std::u16string smsc;
319 result = interfaceManager->GetSmscAddr(mmsc);
320 EXPECT_GE(result, 0);
321
322 interfaceManager->SetCBConfig(false, 0, 1, 0);
323 interfaceManager->SetImsSmsConfig(0, false);
324 interfaceManager->SetDefaultSmsSlotId(0);
325 interfaceManager->GetDefaultSmsSlotId();
326 int32_t simId;
327 result = interfaceManager->GetDefaultSmsSimId(simId);
328 EXPECT_GE(result, 0);
329
330 std::vector<std::u16string> splitMessage;
331 interfaceManager->SplitMessage(dataStr, splitMessage);
332 interfaceManager->GetSmsSegmentsInfo(dataStr, false, outInfo);
333 result = interfaceManager->IsImsSmsSupported(0, isSupported);
334 EXPECT_GE(result, 0);
335
336 interfaceManager->GetImsShortMessageFormat(format);
337 interfaceManager->mmsSendManager_ = nullptr;
338 interfaceManager->SendMms(mmsc, data, ua, uaprof);
339 interfaceManager->mmsReceiverManager_ = nullptr;
340 result = interfaceManager->DownloadMms(mmsc, data, ua, uaprof);
341 EXPECT_GE(result, 0);
342 }
343
344 /**
345 * @tc.number Telephony_SmsMmsGtest_SmsInterfaceManager_0003
346 * @tc.name Test SmsInterfaceManager
347 * @tc.desc Function test
348 */
349 HWTEST_F(BranchSmsPartTest, SmsInterfaceManager_0003, Function | MediumTest | Level1)
350 {
351 int32_t slotId = 0;
352 std::shared_ptr<SmsInterfaceManager> interfaceManager = std::make_shared<SmsInterfaceManager>(slotId);
353 interfaceManager->mmsSendManager_ = nullptr;
354 std::u16string mmsc(StringUtils::ToUtf16(VNET_MMSC));
355 std::u16string data(StringUtils::ToUtf16(SEND_MMS_FILE_URL));
356 std::u16string ua = u"112233";
357 std::u16string uaprof = u"112233";
358 int32_t sendMmsRet = interfaceManager->SendMms(mmsc, data, ua, uaprof);
359 interfaceManager->mmsReceiverManager_ = nullptr;
360 int32_t downloadMmsRet = interfaceManager->DownloadMms(mmsc, data, ua, uaprof);
361 EXPECT_GE(sendMmsRet, 0);
362 EXPECT_GE(downloadMmsRet, 0);
363
364 if (interfaceManager->smsSendManager_ == nullptr) {
365 interfaceManager->smsSendManager_ = std::make_unique<SmsSendManager>(0);
366 }
367 interfaceManager->smsSendManager_->Init();
368 interfaceManager->smsSendManager_->networkManager_->netWorkType_ = NetWorkType::NET_TYPE_GSM;
369 std::string specialText =
370 "ฏ็็็็็็็็็็็็็็็็็็็็็็็็็็็็็็็็็็็็็็็็็็็็็็็็็็็็็็็็็็็็็็็็็็็็็็็็็็็็็็็็็็็็";
371 std::vector<std::u16string> splitMessage;
372 interfaceManager->SplitMessage(specialText, splitMessage);
373 size_t segCount = 2;
374 size_t maxSegLen = 67;
375 ASSERT_EQ(splitMessage.size(), segCount);
376 EXPECT_EQ(splitMessage[0].size(), maxSegLen);
377
378 std::string normalText =
379 "这是一个普通的长短信，由数字0123456789、小写字母abcdefghijklmnopqrstuvwxyz、大写字母ABCDEFGHIJKLMNOPQRSTUVWXYZ和汉字组成";
380 splitMessage.clear();
381 interfaceManager->SplitMessage(normalText, splitMessage);
382 ASSERT_EQ(splitMessage.size(), segCount);
383 EXPECT_EQ(splitMessage[0].size(), maxSegLen);
384
385 std::string randomText;
386 size_t randomLength = 500;
387 randomText.reserve(randomLength);
388 std::random_device rd;
389 std::mt19937 gen(rd());
390 std::uniform_int_distribution<> dis(1, 0xFF);
391 for (size_t i = 0; i < randomLength; i++) {
392 randomText += static_cast<char>(dis(gen));
393 }
394 splitMessage.clear();
395 interfaceManager->SplitMessage(randomText, splitMessage);
396 EXPECT_GE(splitMessage.size(), 1);
397 }
398
399 /**
400 * @tc.number Telephony_SmsMmsGtest_SmsEmailMessage_0001
401 * @tc.name Test SmsEmailMessage
402 * @tc.desc Function test
403 */
404 HWTEST_F(BranchSmsPartTest, SmsEmailMessage_0001, Function | MediumTest | Level1)
405 {
406 auto gsmSmsMessage = std::make_shared<GsmSmsMessage>();
407 string pdu = ("07963258974152f204038105f300008022110232438a28e6a71b40c587eb7"
408 "076d9357eb7412f7d793a07ddeb6278794d07bde8d5391b246e93d3");
409 EXPECT_TRUE(gsmSmsMessage->CreateMessage(pdu) != nullptr);
410 auto message = gsmSmsMessage->CreateMessage(pdu);
411 EXPECT_EQ(message->GetEmailMessageBody(), "zeSs wubpekt /tUsl bmdi");
412 EXPECT_EQ(message->GetVisibleMessageBody(), "zeSs wubpekt /tUsl bmdi");
413 EXPECT_EQ(message->GetEmailAddress(), "fOn@Txauple.com");
414 EXPECT_EQ(message->GetVisibleOriginatingAddress(), "fOn@Txauple.com");
415 EXPECT_TRUE(message->IsEmail());
416
417 pdu = ("07913244457812f204038105f400007120103215358a29d6e71b503667db7076d935"
418 "7eb741af0d0a442fcfe8c13639bfe16d289bdee6b5f1813629");
419 EXPECT_TRUE(gsmSmsMessage->CreateMessage(pdu) != nullptr);
420 message = gsmSmsMessage->CreateMessage(pdu);
421 EXPECT_EQ(message->GetEmailMessageBody(), "{ te3tAmdy[^~\\] }");
422 EXPECT_EQ(message->GetVisibleMessageBody(), "{ te3tAmdy[^~\\] }");
423 EXPECT_EQ(message->GetEmailAddress(), "VOo@efYmple.com");
424 EXPECT_EQ(message->GetVisibleOriginatingAddress(), "VOo@efYmple.com");
425 EXPECT_TRUE(message->IsEmail());
426 }
427
428 /**
429 * @tc.number Telephony_SmsMmsGtest_SmsEmailMessage_0002
430 * @tc.name Test SmsEmailMessage
431 * @tc.desc Function test
432 */
433 HWTEST_F(BranchSmsPartTest, SmsEmailMessage_0002, Function | MediumTest | Level1)
434 {
435 auto gsmSmsMessage = std::make_shared<GsmSmsMessage>();
436 string pdu = ("07963258974152f204038105f300008022110232438a28e6a71b40c587eb"
437 "7076d9357eb7412f7d793a07ddeb6278794d07bde8d5391b246e93d3");
438 EXPECT_TRUE(gsmSmsMessage->CreateMessage(pdu) != nullptr);
439 auto message = gsmSmsMessage->CreateMessage(pdu);
440 EXPECT_TRUE(message != nullptr);
441
442 EXPECT_TRUE(message->IsEmailAddress("\"DAS\" <NAME@sadds.com>"));
443 EXPECT_TRUE(message->IsEmailAddress("DAS <NAME@sadds.com>"));
444 EXPECT_FALSE(message->IsEmailAddress(""));
445 EXPECT_FALSE(message->IsEmailAddress("\"DAS\" 45654654564"));
446 EXPECT_FALSE(message->IsEmailAddress("DAS 13254654654"));
447 EXPECT_TRUE(message->IsEmailAddress("阿松大@163.com"));
448 EXPECT_TRUE(message->IsEmailAddress("aaa@aa.bb.163.com"));
449 }
450
451 /**
452 * @tc.number Telephony_SmsMmsGtest_SmsEmailMessage_0003
453 * @tc.name Test SmsEmailMessage
454 * @tc.desc Function test
455 */
456 HWTEST_F(BranchSmsPartTest, SmsEmailMessage_0003, Function | MediumTest | Level1)
457 {
458 auto gsmSmsMessage = std::make_shared<GsmSmsMessage>();
459 string pdu = ("07963258974152f2040D91687103920059F100008022110232438a28e6a71b40c587e"
460 "b7076d9357eb7412f7d793a07ddeb6278794d07bde8d5391b246e93d3");
461 EXPECT_TRUE(gsmSmsMessage->CreateMessage(pdu) != nullptr);
462 auto message = gsmSmsMessage->CreateMessage(pdu);
463 EXPECT_FALSE(message->IsEmail());
464
465 pdu = ("07963258974152f204038105f300008022110232438a10e6a71b40c587eb7076d9357eb743");
466 EXPECT_TRUE(gsmSmsMessage->CreateMessage(pdu) != nullptr);
467 message = gsmSmsMessage->CreateMessage(pdu);
468 EXPECT_FALSE(message->IsEmail());
469 }
470
471 /**
472 * @tc.number Telephony_SmsMmsGtest_SmsStateObserver_0001
473 * @tc.name Test SmsStateObserver_0001
474 * @tc.desc Function test
475 */
476 HWTEST_F(BranchSmsPartTest, SmsStateObserver_0001, Function | MediumTest | Level1)
477 {
478 std::shared_ptr<SmsStateObserver> smsStateObserver = std::make_shared<SmsStateObserver>();
479 smsStateObserver->smsSubscriber_ = nullptr;
480 smsStateObserver->StopEventSubscriber();
481 std::shared_ptr<CommonEventSubscribeInfo> subscribeInfo = std::make_shared<CommonEventSubscribeInfo>();
482 std::shared_ptr<SmsStateEventSubscriber> smsStateEventSubscriber =
483 std::make_shared<SmsStateEventSubscriber>(*subscribeInfo);
484 EventFwk::CommonEventData eventData = EventFwk::CommonEventData();
485 AAFwk::Want want = AAFwk::Want();
486 want.SetAction(EventFwk::CommonEventSupport::COMMON_EVENT_SMS_EMERGENCY_CB_RECEIVE_COMPLETED);
487 eventData.SetWant(want);
488 smsStateEventSubscriber->OnReceiveEvent(eventData);
489 want.SetAction(EventFwk::CommonEventSupport::COMMON_EVENT_SMS_RECEIVE_COMPLETED);
490 eventData.SetWant(want);
491 smsStateEventSubscriber->OnReceiveEvent(eventData);
492 want.SetAction(EventFwk::CommonEventSupport::COMMON_EVENT_SMS_WAPPUSH_RECEIVE_COMPLETED);
493 eventData.SetWant(want);
494 smsStateEventSubscriber->OnReceiveEvent(eventData);
495 want.SetAction(EventFwk::CommonEventSupport::COMMON_EVENT_BATTERY_LOW);
496 eventData.SetWant(want);
497 smsStateEventSubscriber->OnReceiveEvent(eventData);
498 EXPECT_TRUE(smsStateObserver != nullptr);
499 EXPECT_TRUE(subscribeInfo != nullptr);
500 EXPECT_TRUE(smsStateEventSubscriber != nullptr);
501 }
502
503 /**
504 * @tc.number Telephony_SmsMmsGtest_GsmSmsParamCodec_0014
505 * @tc.name Test GsmSmsParamCodec DecodeSmscPdu
506 * @tc.desc Function test
507 */
508 HWTEST_F(BranchSmsPartTest, GsmSmsParamCodec_0014, Function | MediumTest | Level1) {
509 /**
510 * test supporting smsAddress.ton is unknown
511 */
512 auto gsmSmsParamCodec = std::make_shared<GsmSmsParamCodec>();
513 EXPECT_NE(gsmSmsParamCodec, nullptr);
514 AddressNumber smsAddress;
515
516 unsigned char encodeData[] = { 0x2, 0x81, 0x2A, 0xB1 };
517 unsigned char *pSMSC = encodeData;
518 EXPECT_GE(gsmSmsParamCodec->DecodeSmscPdu(pSMSC, 5, smsAddress), 0);
519 std::string address(smsAddress.address);
520 EXPECT_EQ(address, "*21#");
521 }
522
523 /**
524 * @tc.number Telephony_SmsMmsGtest_GsmSmsParamCodec_0015
525 * @tc.name Test GsmSmsParamCodec DecodeDcsPdu
526 * @tc.desc Function test
527 */
528 HWTEST_F(BranchSmsPartTest, GsmSmsParamCodec_0015, Function | MediumTest | Level1) {
529 /**
530 * test DecodeDcsPdu
531 */
532 auto gsmSmsParamCodec = std::make_shared<GsmSmsParamCodec>();
533 EXPECT_NE(gsmSmsParamCodec, nullptr);
534
535 auto decodeBuffer = std::make_shared<SmsReadBuffer>("0011000D91685150800576F70001C404D4F29C0E");
536 SmsDcs *smsDcs = new SmsDcs();
537 smsDcs->codingGroup = OHOS::Telephony::PduSchemeGroup::CODING_GENERAL_GROUP;
538 smsDcs->bCompressed = false;
539 smsDcs->codingScheme = OHOS::Telephony::DataCodingScheme::DATA_CODING_UCS2;
540 smsDcs->msgClass = OHOS::Telephony::SmsMessageClass::SMS_INSTANT_MESSAGE;
541
542 EXPECT_EQ(gsmSmsParamCodec->DecodeDcsPdu(*decodeBuffer, smsDcs), 1);
543 auto decodeBuffer1 = std::make_shared<SmsReadBuffer>("16D131D98C56B3DD7039584C36A3D56C375C0E169301");
544 EXPECT_EQ(gsmSmsParamCodec->DecodeDcsPdu(*decodeBuffer1, smsDcs), 1);
545 auto decodeBuffer2 = std::make_shared<SmsReadBuffer>("4011000D91685150800576F70001C404D4F29C0E");
546 EXPECT_EQ(gsmSmsParamCodec->DecodeDcsPdu(*decodeBuffer2, smsDcs), 1);
547 auto decodeBuffer3 = std::make_shared<SmsReadBuffer>("C011000D91685150800576F70001C404D4F29C0E");
548 EXPECT_EQ(gsmSmsParamCodec->DecodeDcsPdu(*decodeBuffer3, smsDcs), 1);
549 auto decodeBuffer4 = std::make_shared<SmsReadBuffer>("D011000D91685150800576F70001C404D4F29C0E");
550 EXPECT_EQ(gsmSmsParamCodec->DecodeDcsPdu(*decodeBuffer4, smsDcs), 1);
551 auto decodeBuffer5 = std::make_shared<SmsReadBuffer>("B011000D91685150800576F70001C404D4F29C0E");
552 EXPECT_EQ(gsmSmsParamCodec->DecodeDcsPdu(*decodeBuffer5, smsDcs), 1);
553 }
554
555 /**
556 * @tc.number Telephony_SmsMmsGtest_GsmSmsParamDecode_0003
557 * @tc.name Test GsmSmsParamDecode DecodeDcsGeneralGroupPdu
558 * @tc.desc Function test
559 */
560 HWTEST_F(BranchSmsPartTest, GsmSmsParamDecode_0003, Function | MediumTest | Level1)
561 {
562 auto gsmSmsParamDecode = std::make_shared<GsmSmsParamDecode>();
563 EXPECT_NE(gsmSmsParamDecode, nullptr);
564 uint8_t dcs = 0x08;
565 SmsDcs *smsDcs = nullptr;
566 gsmSmsParamDecode->DecodeDcsGeneralGroupPdu(dcs, smsDcs);
567 EXPECT_EQ(smsDcs, nullptr);
568 SmsDcs *smsDcs1 = new SmsDcs();
569 gsmSmsParamDecode->DecodeDcsGeneralGroupPdu(dcs, smsDcs1);
570 EXPECT_EQ(smsDcs1->msgClass, OHOS::Telephony::SMS_CLASS_UNKNOWN);
571 dcs = 0x15;
572 gsmSmsParamDecode->DecodeDcsGeneralGroupPdu(dcs, smsDcs1);
573 EXPECT_NE(smsDcs1->msgClass, OHOS::Telephony::SMS_CLASS_UNKNOWN);
574 }
575
576 /**
577 * @tc.number Telephony_SmsMmsGtest_GsmSmsParamDecode_0004
578 * @tc.name Test GsmSmsParamDecode DecodeDcsClassGroupPdu
579 * @tc.desc Function test
580 */
581 HWTEST_F(BranchSmsPartTest, GsmSmsParamDecode_0004, Function | MediumTest | Level1)
582 {
583 auto gsmSmsParamDecode = std::make_shared<GsmSmsParamDecode>();
584 EXPECT_NE(gsmSmsParamDecode, nullptr);
585 uint8_t dcs = 0x08;
586 SmsDcs *smsDcs = nullptr;
587 gsmSmsParamDecode->DecodeDcsClassGroupPdu(dcs, smsDcs);
588 EXPECT_EQ(smsDcs, nullptr);
589 SmsDcs *smsDcs1 = new SmsDcs();
590 gsmSmsParamDecode->DecodeDcsClassGroupPdu(dcs, smsDcs1);
591 EXPECT_EQ(smsDcs1->codingGroup, OHOS::Telephony::SMS_CLASS_GROUP);
592 }
593
594 /**
595 * @tc.number Telephony_SmsMmsGtest_GsmSmsParamDecode_0005
596 * @tc.name Test GsmSmsParamDecode DecodeDcsDeleteGroupPdu
597 * @tc.desc Function test
598 */
599 HWTEST_F(BranchSmsPartTest, GsmSmsParamDecode_0005, 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->DecodeDcsDeleteGroupPdu(dcs, smsDcs);
606 EXPECT_EQ(smsDcs, nullptr);
607 SmsDcs *smsDcs1 = new SmsDcs();
608 gsmSmsParamDecode->DecodeDcsDeleteGroupPdu(dcs, smsDcs1);
609 EXPECT_EQ(smsDcs1->codingGroup, OHOS::Telephony::CODING_DELETION_GROUP);
610 }
611
612 /**
613 * @tc.number Telephony_SmsMmsGtest_GsmSmsParamDecode_0006
614 * @tc.name Test GsmSmsParamDecode DecodeDcsDiscardGroupPdu
615 * @tc.desc Function test
616 */
617 HWTEST_F(BranchSmsPartTest, GsmSmsParamDecode_0006, Function | MediumTest | Level1)
618 {
619 auto gsmSmsParamDecode = std::make_shared<GsmSmsParamDecode>();
620 EXPECT_NE(gsmSmsParamDecode, nullptr);
621 uint8_t dcs = 0x08;
622 SmsDcs *smsDcs = nullptr;
623 gsmSmsParamDecode->DecodeDcsDiscardGroupPdu(dcs, smsDcs);
624 EXPECT_EQ(smsDcs, nullptr);
625 SmsDcs *smsDcs1 = new SmsDcs();
626 gsmSmsParamDecode->DecodeDcsDiscardGroupPdu(dcs, smsDcs1);
627 EXPECT_EQ(smsDcs1->codingGroup, OHOS::Telephony::CODING_DISCARD_GROUP);
628 }
629
630 /**
631 * @tc.number Telephony_SmsMmsGtest_GsmSmsParamDecode_0007
632 * @tc.name Test GsmSmsParamDecode DecodeDcsStoreGsmGroupPdu
633 * @tc.desc Function test
634 */
635 HWTEST_F(BranchSmsPartTest, GsmSmsParamDecode_0007, Function | MediumTest | Level1)
636 {
637 auto gsmSmsParamDecode = std::make_shared<GsmSmsParamDecode>();
638 EXPECT_NE(gsmSmsParamDecode, nullptr);
639 uint8_t dcs = 0x08;
640 SmsDcs *smsDcs = nullptr;
641 gsmSmsParamDecode->DecodeDcsStoreGsmGroupPdu(dcs, smsDcs);
642 EXPECT_EQ(smsDcs, nullptr);
643 SmsDcs *smsDcs1 = new SmsDcs();
644 gsmSmsParamDecode->DecodeDcsStoreGsmGroupPdu(dcs, smsDcs1);
645 EXPECT_EQ(smsDcs1->codingGroup, OHOS::Telephony::CODING_STORE_GROUP);
646 EXPECT_EQ(smsDcs1->codingScheme, OHOS::Telephony::DATA_CODING_7BIT);
647 }
648
649 /**
650 * @tc.number Telephony_SmsMmsGtest_GsmSmsParamDecode_0008
651 * @tc.name Test GsmSmsParamDecode DecodeDcsStoreUCS2GroupPdu
652 * @tc.desc Function test
653 */
654 HWTEST_F(BranchSmsPartTest, GsmSmsParamDecode_0008, Function | MediumTest | Level1)
655 {
656 auto gsmSmsParamDecode = std::make_shared<GsmSmsParamDecode>();
657 EXPECT_NE(gsmSmsParamDecode, nullptr);
658 uint8_t dcs = 0x08;
659 SmsDcs *smsDcs = nullptr;
660 gsmSmsParamDecode->DecodeDcsStoreUCS2GroupPdu(dcs, smsDcs);
661 EXPECT_EQ(smsDcs, nullptr);
662 SmsDcs *smsDcs1 = new SmsDcs();
663 gsmSmsParamDecode->DecodeDcsStoreUCS2GroupPdu(dcs, smsDcs1);
664 EXPECT_EQ(smsDcs1->codingGroup, OHOS::Telephony::CODING_STORE_GROUP);
665 EXPECT_EQ(smsDcs1->codingScheme, OHOS::Telephony::DATA_CODING_UCS2);
666 }
667
668 /**
669 * @tc.number Telephony_SmsMmsGtest_GsmSmsParamDecode_0009
670 * @tc.name Test GsmSmsParamDecode DecodeDcsUnknownGroupPdu
671 * @tc.desc Function test
672 */
673 HWTEST_F(BranchSmsPartTest, GsmSmsParamDecode_0009, Function | MediumTest | Level1)
674 {
675 auto gsmSmsParamDecode = std::make_shared<GsmSmsParamDecode>();
676 EXPECT_NE(gsmSmsParamDecode, nullptr);
677 uint8_t dcs = 0x08;
678 SmsDcs *smsDcs = nullptr;
679 gsmSmsParamDecode->DecodeDcsUnknownGroupPdu(dcs, smsDcs);
680 EXPECT_EQ(smsDcs, nullptr);
681 SmsDcs *smsDcs1 = new SmsDcs();
682 gsmSmsParamDecode->DecodeDcsUnknownGroupPdu(dcs, smsDcs1);
683 EXPECT_EQ(smsDcs1->codingGroup, OHOS::Telephony::CODING_UNKNOWN_GROUP);
684 EXPECT_EQ(smsDcs1->msgClass, OHOS::Telephony::SMS_CLASS_UNKNOWN);
685 }
686
687
688 /**
689 * @tc.number Telephony_SmsMmsGtest_GsmSmsParamDecode_0010
690 * @tc.name Test GsmSmsParamDecode DecodeTimePduPartData
691 * @tc.desc Function test
692 */
693 HWTEST_F(BranchSmsPartTest, GsmSmsParamDecode_0010, Function | MediumTest | Level1)
694 {
695 auto gsmSmsParamDecode = std::make_shared<GsmSmsParamDecode>();
696 EXPECT_NE(gsmSmsParamDecode, nullptr);
697 auto decodeBuffer = std::make_shared<SmsReadBuffer>("");
698 EXPECT_NE(decodeBuffer, nullptr);
699 EXPECT_TRUE(decodeBuffer->IsEmpty());
700 SmsTimeStamp *pTimeStamp = new SmsTimeStamp();
701 pTimeStamp->format = SmsTimeFormat::SMS_TIME_ABSOLUTE;
702 pTimeStamp->time.absolute.timeZone = -1;
703 EXPECT_EQ(gsmSmsParamDecode->DecodeTimePduPartData(*decodeBuffer, pTimeStamp), false); // first branch PickOneByte
704
705 auto decodeBuffer1 = std::make_shared<SmsReadBuffer>("00");
706 EXPECT_NE(decodeBuffer1, nullptr);
707 EXPECT_FALSE(decodeBuffer1->IsEmpty());
708 decodeBuffer1->bitIndex_ = 1;
709 EXPECT_EQ(gsmSmsParamDecode->DecodeTimePduPartData(*decodeBuffer1, pTimeStamp), false); // fifth branch ReadByte
710 EXPECT_EQ(gsmSmsParamDecode->DecodeTimePduPartData(*decodeBuffer1, pTimeStamp), false); // third branch ReadByte
711 }
712
713 /**
714 * @tc.number Telephony_SmsMmsGtest_GsmSmsParamDecode_0011
715 * @tc.name Test GsmSmsParamDecode DecodeTimePduData
716 * @tc.desc Function test
717 */
718 HWTEST_F(BranchSmsPartTest, GsmSmsParamDecode_0011, Function | MediumTest | Level1)
719 {
720 auto gsmSmsParamDecode = std::make_shared<GsmSmsParamDecode>();
721 EXPECT_NE(gsmSmsParamDecode, nullptr);
722 auto decodeBuffer = std::make_shared<SmsReadBuffer>("");
723 EXPECT_NE(decodeBuffer, nullptr);
724 EXPECT_FALSE(gsmSmsParamDecode->DecodeTimePduData(*decodeBuffer, nullptr)); // first branch nullptr
725
726 SmsTimeStamp *pTimeStamp = new SmsTimeStamp();
727 pTimeStamp->format = SmsTimeFormat::SMS_TIME_ABSOLUTE;
728 pTimeStamp->time.absolute.timeZone = -1;
729 EXPECT_FALSE(gsmSmsParamDecode->DecodeTimePduData(*decodeBuffer, pTimeStamp)); // second branch PickOneByte
730
731 auto decodeBuffer1 = std::make_shared<SmsReadBuffer>("00");
732 EXPECT_NE(decodeBuffer1, nullptr);
733 EXPECT_TRUE(gsmSmsParamDecode->DecodeTimePduData(*decodeBuffer1, pTimeStamp));
734 EXPECT_FALSE(gsmSmsParamDecode->DecodeTimePduData(*decodeBuffer1, pTimeStamp)); // second branch PickOneByte
735
736 auto decodeBuffer2 = std::make_shared<SmsReadBuffer>("16D131D98C56B3DD7039584C36A3D56C375C0E169301");
737 EXPECT_NE(decodeBuffer2, nullptr);
738 EXPECT_TRUE(gsmSmsParamDecode->DecodeTimePduData(*decodeBuffer2, pTimeStamp));
739 }
740
741 /**
742 * @tc.number Telephony_SmsMmsGtest_DecodeAddressAlphaNum_0001
743 * @tc.name Test GsmSmsParamDecode DecodeAddressAlphaNum
744 * @tc.desc Function test
745 */
746 HWTEST_F(BranchSmsPartTest, DecodeAddressAlphaNum_0001, Function | MediumTest | Level1)
747 {
748 auto gsmSmsParamDecode = std::make_shared<GsmSmsParamDecode>();
749 EXPECT_NE(gsmSmsParamDecode, nullptr);
750 auto buffer = std::make_shared<SmsReadBuffer>("00");
751 AddressNumber *pAddress = new AddressNumber();
752 uint8_t bcdLen = 1;
753 uint8_t addrLen = 1;
754 EXPECT_FALSE(gsmSmsParamDecode->DecodeAddressAlphaNum(*buffer, pAddress, bcdLen, addrLen)); // third branch
755
756 std::string pdu = StringUtils::HexToString("");
757 auto decodeBuffer1 = std::make_shared<SmsReadBuffer>(pdu);
758 printf("decodeBuffer1 index_ = %d, length_ = %d\n", decodeBuffer1->index_, decodeBuffer1->length_);
759 EXPECT_FALSE(gsmSmsParamDecode->DecodeAddressAlphaNum(*buffer, pAddress, bcdLen, addrLen)); // first branch
760 }
761
762 /**
763 * @tc.number Telephony_SmsMmsGtest_GsmSmsMessage_0004
764 * @tc.name Test GsmSmsMessage
765 * @tc.desc Function test
766 */
767 HWTEST_F(BranchSmsPartTest, GsmSmsMessage_0004, Function | MediumTest | Level1)
768 {
769 auto gsmSmsMessage = std::make_shared<GsmSmsMessage>();
770 EXPECT_TRUE(gsmSmsMessage != nullptr);
771 unsigned char langId = 0;
772 gsmSmsMessage->smsTpdu_ = std::make_shared<struct SmsTpdu>();
773 gsmSmsMessage->smsTpdu_->tpduType = OHOS::Telephony::SmsTpduType::SMS_TPDU_STATUS_REP;
774 EXPECT_EQ(gsmSmsMessage->SetHeaderLang(1, DataCodingScheme::DATA_CODING_UCS2, langId), 0);
775 }
776
777 /**
778 * @tc.number Telephony_SmsMmsGtest_GsmSmsMessage_0005
779 * @tc.name Test GsmSmsMessage
780 * @tc.desc Function test
781 */
782 HWTEST_F(BranchSmsPartTest, GsmSmsMessage_0005, Function | MediumTest | Level1)
783 {
784 auto gsmSmsMessage = std::make_shared<GsmSmsMessage>();
785 EXPECT_TRUE(gsmSmsMessage != nullptr);
786 SmsConcat concat;
787 gsmSmsMessage->smsTpdu_ = std::make_shared<struct SmsTpdu>();
788 gsmSmsMessage->smsTpdu_->tpduType = OHOS::Telephony::SmsTpduType::SMS_TPDU_STATUS_REP;
789 EXPECT_EQ(gsmSmsMessage->SetHeaderConcat(1, concat), 0);
790 }
791
792 /**
793 * @tc.number Telephony_SmsMmsGtest_GsmSmsMessage_0006
794 * @tc.name Test GsmSmsMessage
795 * @tc.desc Function test
796 */
797 HWTEST_F(BranchSmsPartTest, GsmSmsMessage_0006, Function | MediumTest | Level1)
798 {
799 auto gsmSmsMessage = std::make_shared<GsmSmsMessage>();
800 EXPECT_TRUE(gsmSmsMessage != nullptr);
801 gsmSmsMessage->smsTpdu_ = nullptr;
802 EXPECT_EQ(gsmSmsMessage->SetHeaderReply(1), 0);
803
804 gsmSmsMessage->smsTpdu_ = std::make_shared<struct SmsTpdu>();
805 gsmSmsMessage->replyAddress_ = "+13588421254";
806 gsmSmsMessage->smsTpdu_->tpduType = OHOS::Telephony::SmsTpduType::SMS_TPDU_STATUS_REP;
807 EXPECT_EQ(gsmSmsMessage->SetHeaderReply(1), 0);
808 }
809
810 /**
811 * @tc.number Telephony_SmsMmsGtest_GsmSmsMessage_0007
812 * @tc.name Test GsmSmsMessage CreateDefaultSubmit
813 * @tc.desc Function test
814 */
815 HWTEST_F(BranchSmsPartTest, GsmSmsMessage_0007, Function | MediumTest | Level1)
816 {
817 auto gsmSmsMessage = std::make_shared<GsmSmsMessage>();
818 EXPECT_TRUE(gsmSmsMessage != nullptr);
819 gsmSmsMessage->CreateDefaultSubmit(false, DataCodingScheme::DATA_CODING_7BIT);
820 EXPECT_EQ(gsmSmsMessage->smsTpdu_->tpduType, OHOS::Telephony::SmsTpduType::SMS_TPDU_SUBMIT);
821 }
822
823 /**
824 * @tc.number Telephony_SmsMmsGtest_GsmSmsMessage_0008
825 * @tc.name Test GsmSmsMessage PduAnalysisMsg
826 * @tc.desc Function test
827 */
828 HWTEST_F(BranchSmsPartTest, GsmSmsMessage_0008, Function | MediumTest | Level1)
829 {
830 auto gsmSmsMessage = std::make_shared<GsmSmsMessage>();
831 EXPECT_TRUE(gsmSmsMessage != nullptr);
832 gsmSmsMessage->smsTpdu_ = std::make_shared<struct SmsTpdu>();
833 gsmSmsMessage->smsTpdu_->tpduType = OHOS::Telephony::SmsTpduType::SMS_TPDU_STATUS_REP;
834 // also test AnalysisMsgDeliver
835 EXPECT_TRUE(gsmSmsMessage->PduAnalysisMsg());
836 gsmSmsMessage->smsTpdu_->tpduType = OHOS::Telephony::SmsTpduType::SMS_TPDU_SUBMIT;
837 // alse test AnalysisMsgSubmit
838 EXPECT_TRUE(gsmSmsMessage->PduAnalysisMsg());
839 gsmSmsMessage->smsTpdu_->tpduType = OHOS::Telephony::SmsTpduType::SMS_TPDU_DELIVER_REP;
840 EXPECT_FALSE(gsmSmsMessage->PduAnalysisMsg());
841 }
842
843 /**
844 * @tc.number Telephony_SmsMmsGtest_GsmSmsMessage_0009
845 * @tc.name Test GsmSmsMessage ConvertUserData and ConvertUserPartData
846 * @tc.desc Function test
847 */
848 HWTEST_F(BranchSmsPartTest, GsmSmsMessage_0009, Function | MediumTest | Level1)
849 {
850 auto gsmSmsMessage = std::make_shared<GsmSmsMessage>();
851 EXPECT_TRUE(gsmSmsMessage != nullptr);
852
853 gsmSmsMessage->smsTpdu_ = std::make_shared<struct SmsTpdu>();
854 gsmSmsMessage->smsTpdu_->tpduType = OHOS::Telephony::SmsTpduType::SMS_TPDU_DELIVER;
855 gsmSmsMessage->codingScheme_ = OHOS::Telephony::DataCodingScheme::DATA_CODING_7BIT;
856 size_t oldSize = gsmSmsMessage->visibleMessageBody_.size();
857 gsmSmsMessage->smsUserData_.header[0].udh.singleShift.langId = 1;
858 std::string text = "1234566";
859 gsmSmsMessage->SetFullText(text);
860 gsmSmsMessage->ConvertUserData();
861 size_t newSize = gsmSmsMessage->visibleMessageBody_.size();
862 EXPECT_EQ(newSize, oldSize);
863
864 gsmSmsMessage->codingScheme_ = OHOS::Telephony::DataCodingScheme::DATA_CODING_UCS2;
865 oldSize = gsmSmsMessage->visibleMessageBody_.size();
866 gsmSmsMessage->ConvertUserData();
867 newSize = gsmSmsMessage->visibleMessageBody_.size();
868 EXPECT_EQ(newSize, oldSize);
869 }
870
871 /**
872 * @tc.number Telephony_SmsMmsGtest_GsmSmsMessage_0010
873 * @tc.name Test GsmSmsMessage IsSpecialMessage
874 * @tc.desc Function test
875 */
876 HWTEST_F(BranchSmsPartTest, GsmSmsMessage_0010, Function | MediumTest | Level1)
877 {
878 auto gsmSmsMessage = std::make_shared<GsmSmsMessage>();
879 EXPECT_TRUE(gsmSmsMessage != nullptr);
880 gsmSmsMessage->protocolId_ = 0x40;
881 EXPECT_TRUE(gsmSmsMessage->IsSpecialMessage());
882
883 gsmSmsMessage->msgClass_ = OHOS::Telephony::SmsMessageClass::SMS_SIM_MESSAGE;
884 gsmSmsMessage->protocolId_ = 0x7f;
885 EXPECT_TRUE(gsmSmsMessage->IsSpecialMessage());
886
887 gsmSmsMessage->protocolId_ = 0x7c;
888 EXPECT_TRUE(gsmSmsMessage->IsSpecialMessage());
889
890 gsmSmsMessage->protocolId_ = 0x41;
891 gsmSmsMessage->bMwiSet_ = true;
892 EXPECT_TRUE(gsmSmsMessage->IsSpecialMessage());
893
894 gsmSmsMessage->bMwiClear_ = true;
895 EXPECT_TRUE(gsmSmsMessage->IsSpecialMessage());
896 }
897
898 /**
899 * @tc.number Telephony_SmsMmsGtest_GsmSmsMessage_0011
900 * @tc.name Test GsmSmsMessage DecodeMessage
901 * @tc.desc Function test
902 */
903 HWTEST_F(BranchSmsPartTest, GsmSmsMessage_0011, Function | MediumTest | Level1)
904 {
905 auto gsmSmsMessage = std::make_shared<GsmSmsMessage>();
906 EXPECT_TRUE(gsmSmsMessage != nullptr);
907
908 std::string msgText("");
909 // init destination array of pdu data
910 uint8_t decodeData[(MAX_GSM_7BIT_DATA_LEN * OHOS::Telephony::MAX_SEGMENT_NUM) + 1];
911 EXPECT_EQ(memset_s(decodeData, sizeof(decodeData), 0x00, sizeof(decodeData)), EOK);
912
913 int encodeLen = 0;
914 bool bAbnormal = false;
915 unsigned char langId = OHOS::Telephony::MsgLanguageId::MSG_ID_RESERVED_LANG;
916 OHOS::Telephony::DataCodingScheme codingType = OHOS::Telephony::DataCodingScheme::DATA_CODING_7BIT;
917
918 encodeLen = gsmSmsMessage->DecodeMessage(decodeData, sizeof(decodeData), codingType, msgText, bAbnormal, langId);
919 EXPECT_EQ(encodeLen, 0);
920
921 msgText = "123456";
922 encodeLen = gsmSmsMessage->DecodeMessage(decodeData, sizeof(decodeData), codingType, msgText, bAbnormal, langId);
923 EXPECT_GT(encodeLen, 0);
924
925 codingType = OHOS::Telephony::DataCodingScheme::DATA_CODING_8BIT;
926 encodeLen = gsmSmsMessage->DecodeMessage(decodeData, sizeof(decodeData), codingType, msgText, bAbnormal, langId);
927 EXPECT_GT(encodeLen, 0);
928
929 msgText.append(sizeof(decodeData), '1');
930 encodeLen = gsmSmsMessage->DecodeMessage(decodeData, sizeof(decodeData), codingType, msgText, bAbnormal, langId);
931 EXPECT_EQ(encodeLen, 0);
932
933 msgText = "123456";
934 codingType = OHOS::Telephony::DataCodingScheme::DATA_CODING_UCS2;
935 encodeLen = gsmSmsMessage->DecodeMessage(decodeData, sizeof(decodeData), codingType, msgText, bAbnormal, langId);
936 EXPECT_GT(encodeLen, 0);
937
938 codingType = OHOS::Telephony::DataCodingScheme::DATA_CODING_AUTO;
939 encodeLen = gsmSmsMessage->DecodeMessage(decodeData, sizeof(decodeData), codingType, msgText, bAbnormal, langId);
940 EXPECT_GT(encodeLen, 0);
941
942 codingType = OHOS::Telephony::DataCodingScheme::DATA_CODING_EUCKR;
943 encodeLen = gsmSmsMessage->DecodeMessage(decodeData, sizeof(decodeData), codingType, msgText, bAbnormal, langId);
944 EXPECT_GT(encodeLen, 0);
945 }
946
947 /**
948 * @tc.number Telephony_SmsMmsGtest_GsmSmsParamCodec_0016
949 * @tc.name Test GsmSmsParamCodec EncodeAddressPdu
950 * @tc.desc Function test
951 */
952 HWTEST_F(BranchSmsPartTest, GsmSmsParamCodec_0016, Function | MediumTest | Level1)
953 {
954 auto gsmSmsParamCodec = std::make_shared<GsmSmsParamCodec>();
955 AddressNumber *pAddress = new AddressNumber();
956 std::string paramStr;
957
958 std::string smsc = "**21*1300555002012345";
959 memcpy_s(&pAddress->address, sizeof(pAddress->address), smsc.data(), smsc.length());
960 pAddress->address[smsc.length()] = '\0';
961 pAddress->ton = TYPE_INTERNATIONAL;
962 pAddress->npi = SMS_NPI_ISDN;
963 EXPECT_FALSE(gsmSmsParamCodec->EncodeAddressPdu(pAddress, paramStr)); // second branch
964 }
965
966 /**
967 * @tc.number Telephony_SmsMmsGtest_GsmSmsParamCodec_0017
968 * @tc.name Test GsmSmsParamCodec EncodeSmscPdu
969 * @tc.desc Function test
970 */
971 HWTEST_F(BranchSmsPartTest, GsmSmsParamCodec_0017, Function | MediumTest | Level1)
972 {
973 /*
974 * test third branch
975 */
976 auto gsmSmsParamCodec = std::make_shared<GsmSmsParamCodec>();
977 EXPECT_NE(gsmSmsParamCodec, nullptr);
978 const std::string smsc = "+17005550020";
979 AddressNumber *pAddress = new AddressNumber();
980 uint8_t encodeSmscAddr[MAX_SMSC_LEN];
981 memset_s(encodeSmscAddr, sizeof(encodeSmscAddr), 0x00, sizeof(encodeSmscAddr));
982 std::string decodeAddr;
983 memcpy_s(&pAddress->address, sizeof(pAddress->address), smsc.data(), smsc.length());
984 pAddress->address[smsc.length()] = '\0';
985 pAddress->ton = TYPE_INTERNATIONAL;
986 pAddress->npi = SMS_NPI_ISDN;
987 uint8_t encodeSmscLen = 0;
988 encodeSmscLen = gsmSmsParamCodec->EncodeSmscPdu(pAddress, encodeSmscAddr, sizeof(encodeSmscAddr));
989 EXPECT_GT(encodeSmscLen, 0);
990 }
991
992 /**
993 * @tc.number Telephony_SmsMmsGtest_GsmSmsTpduCodec_0005
994 * @tc.name Test GsmSmsTpduCodec EncodeSubmitPdu
995 * @tc.desc Function test
996 */
997 HWTEST_F(BranchSmsPartTest, GsmSmsTpduCodec_0005, Function | MediumTest | Level1)
998 {
999 auto tpduCodec = std::make_shared<GsmSmsTpduCodec>();
1000 auto encodeBuffer = std::make_shared<SmsWriteBuffer>();
1001 encodeBuffer->data_[0] = 1;
1002 SmsSubmit *pSubmit = new SmsSubmit();
1003 /*
1004 * parameter check
1005 */
1006 auto encode = std::make_shared<GsmSmsTpduEncode>(nullptr, tpduCodec->paramCodec_, tpduCodec);
1007 EXPECT_FALSE(encode->EncodeSubmitPdu(*encodeBuffer, pSubmit));
1008 auto encode1 = std::make_shared<GsmSmsTpduEncode>(tpduCodec->uDataCodec_, nullptr, tpduCodec);
1009 EXPECT_FALSE(encode1->EncodeSubmitPdu(*encodeBuffer, pSubmit));
1010
1011 auto encode2 = std::make_shared<GsmSmsTpduEncode>(tpduCodec->uDataCodec_, tpduCodec->paramCodec_, tpduCodec);
1012 EXPECT_TRUE(encode2->EncodeSubmitPdu(*encodeBuffer, pSubmit));
1013 /*
1014 * third branch
1015 */
1016 const std::string smsc = "+17005550020324556627";
1017 memcpy_s(&pSubmit->destAddress.address, sizeof(pSubmit->destAddress.address), smsc.data(), smsc.length());
1018 pSubmit->destAddress.address[smsc.length()] = '\0';
1019 EXPECT_FALSE(encode2->EncodeSubmitPdu(*encodeBuffer, pSubmit));
1020
1021 delete pSubmit;
1022 pSubmit = nullptr;
1023 }
1024
1025 /**
1026 * @tc.number Telephony_SmsMmsGtest_GsmSmsTpduCodec_0006
1027 * @tc.name Test GsmSmsTpduCodec EncodeSubmitPduPartData
1028 * @tc.desc Function test
1029 */
1030 HWTEST_F(BranchSmsPartTest, GsmSmsTpduCodec_0006, Function | MediumTest | Level1)
1031 {
1032 auto tpduCodec = std::make_shared<GsmSmsTpduCodec>();
1033 auto encodeBuffer = std::make_shared<SmsWriteBuffer>();
1034 SmsSubmit *pSubmit = new SmsSubmit();
1035 auto encode = std::make_shared<GsmSmsTpduEncode>(tpduCodec->uDataCodec_, tpduCodec->paramCodec_, tpduCodec);
1036 EXPECT_NE(encode, nullptr);
1037 /*
1038 * parameter check
1039 */
1040 encodeBuffer->data_ = nullptr;
1041 EXPECT_FALSE(encode->EncodeSubmitPduPartData(*encodeBuffer, pSubmit));
1042 /*
1043 * third branch
1044 */
1045 encodeBuffer->index_ = 0;
1046 pSubmit->vpf = OHOS::Telephony::SmsVpf::SMS_VPF_ENHANCED;
1047 EXPECT_FALSE(encode->EncodeSubmitPdu(*encodeBuffer, pSubmit));
1048
1049 encodeBuffer->data_ = nullptr;
1050 EXPECT_FALSE(encode->EncodeSubmitPdu(*encodeBuffer, pSubmit));
1051
1052 delete pSubmit;
1053 pSubmit = nullptr;
1054 }
1055
1056 /**
1057 * @tc.number Telephony_SmsMmsGtest_GsmSmsTpduCodec_0007
1058 * @tc.name Test GsmSmsTpduCodec EncodeSubmitTpduType
1059 * @tc.desc Function test
1060 */
1061 HWTEST_F(BranchSmsPartTest, GsmSmsTpduCodec_0007, Function | MediumTest | Level1)
1062 {
1063 auto tpduCodec = std::make_shared<GsmSmsTpduCodec>();
1064 auto encodeBuffer = std::make_shared<SmsWriteBuffer>();
1065 SmsSubmit pSubmit;
1066 auto encode = std::make_shared<GsmSmsTpduEncode>(tpduCodec->uDataCodec_, tpduCodec->paramCodec_, tpduCodec);
1067 EXPECT_NE(encode, nullptr);
1068
1069 /*
1070 * parameter check
1071 */
1072 pSubmit.bRejectDup = false;
1073 encodeBuffer->data_ = nullptr;
1074 uint16_t count = encodeBuffer->GetSize();
1075 encode->EncodeSubmitTpduType(*encodeBuffer, pSubmit);
1076 EXPECT_EQ(encodeBuffer->GetSize(), count);
1077 /*
1078 * third branch
1079 */
1080 auto encodeBuffer2 = std::make_shared<SmsWriteBuffer>();
1081 encodeBuffer2->data_[0] = 1;
1082 encodeBuffer2->bitIndex_ = 1;
1083 uint16_t count2 = encodeBuffer2->GetSize();
1084 encode->EncodeSubmitTpduType(*encodeBuffer2, pSubmit);
1085 EXPECT_EQ(encodeBuffer2->GetSize(), count2);
1086 }
1087
1088 /**
1089 * @tc.number Telephony_SmsMmsGtest_GsmSmsTpduCodec_0008
1090 * @tc.name Test GsmSmsTpduCodec EncodeSubmitTypePartData
1091 * @tc.desc Function test
1092 */
1093 HWTEST_F(BranchSmsPartTest, GsmSmsTpduCodec_0008, Function | MediumTest | Level1)
1094 {
1095 auto tpduCodec = std::make_shared<GsmSmsTpduCodec>();
1096 auto encodeBuffer = std::make_shared<SmsWriteBuffer>();
1097 SmsSubmit pSubmit;
1098 auto encode = std::make_shared<GsmSmsTpduEncode>(tpduCodec->uDataCodec_, tpduCodec->paramCodec_, tpduCodec);
1099 EXPECT_NE(encode, nullptr);
1100 pSubmit.bStatusReport = false;
1101 pSubmit.bHeaderInd = false;
1102 pSubmit.bReplyPath = false;
1103 /*
1104 * SMS_VPF_ENHANCED
1105 */
1106 pSubmit.vpf = OHOS::Telephony::SmsVpf::SMS_VPF_ENHANCED;
1107 encodeBuffer->data_ = nullptr;
1108 uint16_t count1 = encodeBuffer->GetSize();
1109 encode->EncodeSubmitTypePartData(*encodeBuffer, pSubmit);
1110 EXPECT_EQ(encodeBuffer->GetSize(), count1);
1111
1112 auto encodeBuffer2 = std::make_shared<SmsWriteBuffer>();
1113 encodeBuffer2->data_[0] = 1;
1114 encodeBuffer2->index_ = 1;
1115 uint16_t count2 = encodeBuffer2->GetSize();
1116 encode->EncodeSubmitTypePartData(*encodeBuffer2, pSubmit);
1117 EXPECT_EQ(encodeBuffer2->GetSize(), count2);
1118 /*
1119 * SMS_VPF_RELATIVE
1120 */
1121 pSubmit.vpf = OHOS::Telephony::SmsVpf::SMS_VPF_ENHANCED;
1122 auto encodeBuffer3 = std::make_shared<SmsWriteBuffer>();
1123 encodeBuffer3->data_ = nullptr;
1124 uint16_t count3 = encodeBuffer3->GetSize();
1125 encode->EncodeSubmitTypePartData(*encodeBuffer3, pSubmit);
1126 EXPECT_EQ(encodeBuffer3->GetSize(), count3);
1127
1128 auto encodeBuffer4 = std::make_shared<SmsWriteBuffer>();
1129 encodeBuffer4->data_[0] = 1;
1130 encodeBuffer4->index_ = 1;
1131 uint16_t count4 = encodeBuffer4->GetSize();
1132 encode->EncodeSubmitTypePartData(*encodeBuffer4, pSubmit);
1133 EXPECT_EQ(encodeBuffer4->GetSize(), count4);
1134 /*
1135 * SMS_VPF_RELATIVE
1136 */
1137 pSubmit.vpf = OHOS::Telephony::SmsVpf::SMS_VPF_RELATIVE;
1138 auto encodeBuffer5 = std::make_shared<SmsWriteBuffer>();
1139 encodeBuffer5->data_ = nullptr;
1140 uint16_t count5 = encodeBuffer5->GetSize();
1141 encode->EncodeSubmitTypePartData(*encodeBuffer5, pSubmit);
1142 EXPECT_EQ(encodeBuffer5->GetSize(), count5);
1143
1144 auto encodeBuffer6 = std::make_shared<SmsWriteBuffer>();
1145 encodeBuffer6->data_[0] = 1;
1146 encodeBuffer6->index_ = 1;
1147 uint16_t count6 = encodeBuffer6->GetSize();
1148 encode->EncodeSubmitTypePartData(*encodeBuffer6, pSubmit);
1149 EXPECT_EQ(encodeBuffer6->GetSize(), count6);
1150 }
1151
1152 /**
1153 * @tc.number Telephony_SmsMmsGtest_GsmSmsTpduCodec_0009
1154 * @tc.name Test GsmSmsTpduCodec EncodeSubmitTypePartData
1155 * @tc.desc Function test
1156 */
1157 HWTEST_F(BranchSmsPartTest, GsmSmsTpduCodec_0009, Function | MediumTest | Level1)
1158 {
1159 auto tpduCodec = std::make_shared<GsmSmsTpduCodec>();
1160 auto encodeBuffer = std::make_shared<SmsWriteBuffer>();
1161 SmsSubmit pSubmit;
1162 auto encode = std::make_shared<GsmSmsTpduEncode>(tpduCodec->uDataCodec_, tpduCodec->paramCodec_, tpduCodec);
1163 EXPECT_NE(encode, nullptr);
1164 pSubmit.bStatusReport = false;
1165 pSubmit.bHeaderInd = false;
1166 pSubmit.bReplyPath = false;
1167 /*
1168 * SMS_VPF_ABSOLUTE
1169 */
1170 pSubmit.vpf = OHOS::Telephony::SmsVpf::SMS_VPF_ABSOLUTE;
1171 auto encodeBuffer7 = std::make_shared<SmsWriteBuffer>();
1172 encodeBuffer7->data_ = nullptr;
1173 uint16_t count7 = encodeBuffer7->GetSize();
1174 encode->EncodeSubmitTypePartData(*encodeBuffer7, pSubmit);
1175 EXPECT_EQ(encodeBuffer7->GetSize(), count7);
1176
1177 auto encodeBuffer8 = std::make_shared<SmsWriteBuffer>();
1178 encodeBuffer8->data_[0] = 1;
1179 encodeBuffer8->index_ = 1;
1180 uint16_t count8 = encodeBuffer8->GetSize();
1181 encode->EncodeSubmitTypePartData(*encodeBuffer8, pSubmit);
1182 EXPECT_EQ(encodeBuffer8->GetSize(), count8);
1183 /*
1184 * SMS_VPF_NOT_PRESENT
1185 */
1186 pSubmit.vpf = OHOS::Telephony::SmsVpf::SMS_VPF_NOT_PRESENT;
1187 auto encodeBuffer9 = std::make_shared<SmsWriteBuffer>();
1188 encodeBuffer9->data_ = nullptr;
1189 uint16_t count9 = encodeBuffer9->GetSize();
1190 encode->EncodeSubmitTypePartData(*encodeBuffer9, pSubmit);
1191 EXPECT_EQ(encodeBuffer9->GetSize(), count9);
1192 }
1193
1194 /**
1195 * @tc.number Telephony_SmsMmsGtest_GsmSmsTpduCodec_0010
1196 * @tc.name Test GsmSmsTpduCodec EncodeSubmitTypeData
1197 * @tc.desc Function test
1198 */
1199 HWTEST_F(BranchSmsPartTest, GsmSmsTpduCodec_0010, Function | MediumTest | Level1)
1200 {
1201 auto tpduCodec = std::make_shared<GsmSmsTpduCodec>();
1202 auto encodeBuffer = std::make_shared<SmsWriteBuffer>();
1203 SmsSubmit pSubmit;
1204 auto encode = std::make_shared<GsmSmsTpduEncode>(tpduCodec->uDataCodec_, tpduCodec->paramCodec_, tpduCodec);
1205 EXPECT_NE(encode, nullptr);
1206 /*
1207 * pSubmit->bStatusReport is true
1208 */
1209 pSubmit.bStatusReport = true;
1210 encode->EncodeSubmitTypePartData(*encodeBuffer, pSubmit);
1211 auto encodeBuffer1 = std::make_shared<SmsWriteBuffer>();
1212 encodeBuffer1->data_[0] = 1;
1213 encodeBuffer1->index_ = 1;
1214 uint16_t count1 = encodeBuffer1->GetSize();
1215 encode->EncodeSubmitTypePartData(*encodeBuffer1, pSubmit);
1216 EXPECT_EQ(encodeBuffer1->GetSize(), count1);
1217 /*
1218 * pSubmit.bHeaderInd is true
1219 */
1220 auto encodeBuffer2 = std::make_shared<SmsWriteBuffer>();
1221 pSubmit.bStatusReport = false;
1222 pSubmit.bHeaderInd = true;
1223 const std::string smsc = "17005550020";
1224 memcpy_s(&pSubmit.destAddress.address, sizeof(pSubmit.destAddress.address), smsc.data(), smsc.length());
1225 pSubmit.destAddress.address[smsc.length()] = '\0';
1226 encodeBuffer2->data_ = nullptr;
1227 uint16_t count2 = encodeBuffer2->GetSize();
1228 encode->EncodeSubmitTypePartData(*encodeBuffer2, pSubmit);
1229 EXPECT_EQ(encodeBuffer2->GetSize(), count2);
1230
1231 auto encodeBuffer3 = std::make_shared<SmsWriteBuffer>();
1232 encodeBuffer3->data_[0] = 1;
1233 encodeBuffer3->index_ = 1;
1234 uint16_t count3 = encodeBuffer3->GetSize();
1235 encode->EncodeSubmitTypePartData(*encodeBuffer3, pSubmit);
1236 EXPECT_EQ(encodeBuffer3->GetSize(), count3);
1237 /*
1238 * pSubmit.bReplyPath is true
1239 */
1240 pSubmit.bStatusReport = false;
1241 pSubmit.bHeaderInd = false;
1242 pSubmit.bReplyPath = true;
1243 auto encodeBuffer4 = std::make_shared<SmsWriteBuffer>();
1244 encodeBuffer4->data_ = nullptr;
1245 uint16_t count4 = encodeBuffer4->GetSize();
1246 encode->EncodeSubmitTypePartData(*encodeBuffer4, pSubmit);
1247 EXPECT_EQ(encodeBuffer4->GetSize(), count4);
1248
1249 auto encodeBuffer5 = std::make_shared<SmsWriteBuffer>();
1250 encodeBuffer5->data_[0] = 1;
1251 encodeBuffer5->index_ = 1;
1252 uint16_t count5 = encodeBuffer5->GetSize();
1253 encode->EncodeSubmitTypePartData(*encodeBuffer5, pSubmit);
1254 EXPECT_EQ(encodeBuffer5->GetSize(), count5);
1255 }
1256
1257 /**
1258 * @tc.number Telephony_SmsMmsGtest_GsmSmsTpduCodec_0011
1259 * @tc.name Test GsmSmsTpduCodec EncodeDeliverPdu
1260 * @tc.desc Function test
1261 */
1262 HWTEST_F(BranchSmsPartTest, GsmSmsTpduCodec_0011, Function | MediumTest | Level1)
1263 {
1264 auto tpduCodec = std::make_shared<GsmSmsTpduCodec>();
1265 auto encodeBuffer = std::make_shared<SmsWriteBuffer>();
1266 SmsDeliver *pDeliver = new SmsDeliver();
1267 auto encode = std::make_shared<GsmSmsTpduEncode>(tpduCodec->uDataCodec_, tpduCodec->paramCodec_, tpduCodec);
1268 EXPECT_NE(encode, nullptr);
1269 /*
1270 * second branch
1271 */
1272 encodeBuffer->data_ = nullptr;
1273 EXPECT_FALSE(encode->EncodeDeliverPdu(*encodeBuffer, pDeliver));
1274 /*
1275 * third branch pDeliver->bMoreMsg is false
1276 */
1277 auto encodeBuffer1 = std::make_shared<SmsWriteBuffer>();
1278 pDeliver->bMoreMsg = false;
1279 EXPECT_FALSE(encode->EncodeDeliverPdu(*encodeBuffer1, pDeliver));
1280
1281 auto encodeBuffer2 = std::make_shared<SmsWriteBuffer>();
1282 encodeBuffer2->data_[0] = 1;
1283 encodeBuffer2->index_ = 1;
1284 EXPECT_FALSE(encode->EncodeDeliverPdu(*encodeBuffer2, pDeliver));
1285 /*
1286 * fourth branch pDeliver->bStatusReport is true
1287 */
1288 pDeliver->bMoreMsg = true;
1289 pDeliver->bStatusReport = true;
1290 auto encodeBuffer3 = std::make_shared<SmsWriteBuffer>();
1291 EXPECT_FALSE(encode->EncodeDeliverPdu(*encodeBuffer3, pDeliver));
1292
1293 auto encodeBuffer4 = std::make_shared<SmsWriteBuffer>();
1294 encodeBuffer4->data_[0] = 1;
1295 encodeBuffer4->index_ = 1;
1296 EXPECT_FALSE(encode->EncodeDeliverPdu(*encodeBuffer4, pDeliver));
1297 /*
1298 * fifth branch pDeliver->bHeaderInd is true
1299 */
1300 auto encodeBuffer5 = std::make_shared<SmsWriteBuffer>();
1301 pDeliver->bStatusReport = false;
1302 pDeliver->bHeaderInd = true;
1303 EXPECT_FALSE(encode->EncodeDeliverPdu(*encodeBuffer5, pDeliver));
1304
1305 auto encodeBuffer6 = std::make_shared<SmsWriteBuffer>();
1306 encodeBuffer6->data_[0] = 1;
1307 encodeBuffer6->index_ = 1;
1308 EXPECT_FALSE(encode->EncodeDeliverPdu(*encodeBuffer6, pDeliver));
1309
1310 delete pDeliver;
1311 pDeliver = nullptr;
1312 }
1313
1314 /**
1315 * @tc.number Telephony_SmsMmsGtest_GsmSmsTpduCodec_0012
1316 * @tc.name Test GsmSmsTpduCodec EncodeDeliverPartData
1317 * @tc.desc Function test
1318 */
1319 HWTEST_F(BranchSmsPartTest, GsmSmsTpduCodec_0012, Function | MediumTest | Level1)
1320 {
1321 auto tpduCodec = std::make_shared<GsmSmsTpduCodec>();
1322 auto encodeBuffer = std::make_shared<SmsWriteBuffer>();
1323 SmsDeliver *pDeliver = new SmsDeliver();
1324 /*
1325 * parameter check
1326 */
1327 auto encode0 = std::make_shared<GsmSmsTpduEncode>(tpduCodec->uDataCodec_, nullptr, tpduCodec);
1328 EXPECT_NE(encode0, nullptr);
1329 EXPECT_FALSE(encode0->EncodeDeliverPartData(*encodeBuffer, pDeliver));
1330
1331 auto encode = std::make_shared<GsmSmsTpduEncode>(tpduCodec->uDataCodec_, tpduCodec->paramCodec_, tpduCodec);
1332 EXPECT_NE(encode, nullptr);
1333 /*
1334 * pDeliver->bReplyPath is true
1335 */
1336 pDeliver->bReplyPath = true;
1337 encodeBuffer->data_ = nullptr;
1338 EXPECT_FALSE(encode->EncodeDeliverPartData(*encodeBuffer, pDeliver));
1339
1340 auto encodeBuffer1 = std::make_shared<SmsWriteBuffer>();
1341 encodeBuffer1->data_[0] = 1;
1342 encodeBuffer1->index_ = 1;
1343 EXPECT_FALSE(encode->EncodeDeliverPartData(*encodeBuffer, pDeliver));
1344 /*
1345 * third branch
1346 */
1347 auto encodeBuffer2 = std::make_shared<SmsWriteBuffer>();
1348 pDeliver->bReplyPath = false;
1349 const std::string smsc = "17005550020111111111";
1350 memcpy_s(&pDeliver->originAddress.address, sizeof(pDeliver->originAddress.address), smsc.data(), smsc.length());
1351 pDeliver->originAddress.address[smsc.length()] = '\0';
1352 EXPECT_FALSE(encode->EncodeDeliverPartData(*encodeBuffer2, pDeliver));
1353 /*
1354 * fourth branch
1355 */
1356 auto encodeBuffer3 = std::make_shared<SmsWriteBuffer>();
1357 encodeBuffer3->data_[0] = 1;
1358 EXPECT_FALSE(encode->EncodeDeliverPartData(*encodeBuffer3, pDeliver));
1359
1360 delete pDeliver;
1361 pDeliver = nullptr;
1362 }
1363
1364 /**
1365 * @tc.number Telephony_SmsMmsGtest_GsmSmsTpduCodec_0013
1366 * @tc.name Test GsmSmsTpduCodec EncodeDeliverData
1367 * @tc.desc Function test
1368 */
1369 HWTEST_F(BranchSmsPartTest, GsmSmsTpduCodec_0013, Function | MediumTest | Level1)
1370 {
1371 auto tpduCodec = std::make_shared<GsmSmsTpduCodec>();
1372 auto encodeBuffer = std::make_shared<SmsWriteBuffer>();
1373 SmsDeliver *pDeliver = new SmsDeliver();
1374 /*
1375 * parameter check
1376 */
1377 auto encode0 = std::make_shared<GsmSmsTpduEncode>(nullptr, tpduCodec->paramCodec_, tpduCodec);
1378 EXPECT_NE(encode0, nullptr);
1379 EXPECT_FALSE(encode0->EncodeDeliverData(*encodeBuffer, pDeliver));
1380 /*
1381 * second branch
1382 */
1383 auto encode = std::make_shared<GsmSmsTpduEncode>(tpduCodec->uDataCodec_, tpduCodec->paramCodec_, tpduCodec);
1384 EXPECT_NE(encode, nullptr);
1385 encodeBuffer->data_ = nullptr;
1386 EXPECT_FALSE(encode->EncodeDeliverData(*encodeBuffer, pDeliver));
1387
1388 auto encodeBuffer1 = std::make_shared<SmsWriteBuffer>();
1389 encodeBuffer->index_ = 1;
1390 EXPECT_FALSE(encode->EncodeDeliverPartData(*encodeBuffer1, pDeliver));
1391 /*
1392 * main branch
1393 */
1394 auto encodeBuffer2 = std::make_shared<SmsWriteBuffer>();
1395 encodeBuffer2->data_[0] = 1;
1396 encodeBuffer2->index_ = 1;
1397 EXPECT_FALSE(encode->EncodeDeliverPartData(*encodeBuffer2, pDeliver));
1398
1399 delete pDeliver;
1400 pDeliver = nullptr;
1401 }
1402
1403 /**
1404 * @tc.number Telephony_SmsMmsGtest_SmsBaseMessage_0001
1405 * @tc.name Test SmsBaseMessage
1406 * @tc.desc Function test
1407 */
1408 HWTEST_F(BranchSmsPartTest, SmsBaseMessage_0001, Function | MediumTest | Level1)
1409 {
1410 auto smsBaseMessage = std::make_shared<GsmSmsMessage>();
1411 smsBaseMessage->ConvertMessageClass(SmsMessageClass::SMS_SIM_MESSAGE);
1412 smsBaseMessage->ConvertMessageClass(SmsMessageClass::SMS_INSTANT_MESSAGE);
1413 smsBaseMessage->ConvertMessageClass(SmsMessageClass::SMS_OPTIONAL_MESSAGE);
1414 smsBaseMessage->ConvertMessageClass(SmsMessageClass::SMS_FORWARD_MESSAGE);
1415 smsBaseMessage->ConvertMessageClass(SmsMessageClass::SMS_CLASS_UNKNOWN);
1416 SplitInfo split;
1417 DataCodingScheme codingType = DataCodingScheme::DATA_CODING_7BIT;
1418 smsBaseMessage->ConvertSpiltToUtf8(split, codingType);
1419 split.encodeData.push_back(1);
1420 codingType = DataCodingScheme::DATA_CODING_UCS2;
1421 smsBaseMessage->ConvertSpiltToUtf8(split, codingType);
1422 codingType = DataCodingScheme::DATA_CODING_AUTO;
1423 smsBaseMessage->ConvertSpiltToUtf8(split, codingType);
1424 smsBaseMessage->smsUserData_.headerCnt = 1;
1425 smsBaseMessage->smsUserData_.header[0].udhType = UserDataHeadType::UDH_CONCAT_8BIT;
1426 EXPECT_FALSE(smsBaseMessage->GetConcatMsg() == nullptr);
1427 smsBaseMessage->smsUserData_.header[0].udhType = UserDataHeadType::UDH_CONCAT_16BIT;
1428 EXPECT_FALSE(smsBaseMessage->GetConcatMsg() == nullptr);
1429 smsBaseMessage->smsUserData_.header[0].udhType = UserDataHeadType::UDH_APP_PORT_8BIT;
1430 EXPECT_FALSE(smsBaseMessage->GetPortAddress() == nullptr);
1431 smsBaseMessage->smsUserData_.header[0].udhType = UserDataHeadType::UDH_APP_PORT_16BIT;
1432 EXPECT_FALSE(smsBaseMessage->GetPortAddress() == nullptr);
1433 smsBaseMessage->smsUserData_.header[0].udhType = UserDataHeadType::UDH_SPECIAL_SMS;
1434 EXPECT_FALSE(smsBaseMessage->GetSpecialSmsInd() == nullptr);
1435 smsBaseMessage->smsUserData_.header[0].udhType = UserDataHeadType::UDH_APP_PORT_8BIT;
1436 EXPECT_FALSE(smsBaseMessage->IsWapPushMsg());
1437 MSG_LANGUAGE_ID_T langId = 1;
1438 codingType = DataCodingScheme::DATA_CODING_7BIT;
1439 EXPECT_GT(smsBaseMessage->GetMaxSegmentSize(codingType, 1, true, langId, 1), 0);
1440 EXPECT_GT(smsBaseMessage->GetSegmentSize(codingType, 1, true, langId), 0);
1441 codingType = DataCodingScheme::DATA_CODING_ASCII7BIT;
1442 EXPECT_GT(smsBaseMessage->GetMaxSegmentSize(codingType, 1, true, langId, 1), 0);
1443 EXPECT_GT(smsBaseMessage->GetSegmentSize(codingType, 1, true, langId), 0);
1444 codingType = DataCodingScheme::DATA_CODING_8BIT;
1445 EXPECT_GT(smsBaseMessage->GetMaxSegmentSize(codingType, 1, true, langId, 1), 0);
1446 EXPECT_GT(smsBaseMessage->GetSegmentSize(codingType, 1, true, langId), 0);
1447 codingType = DataCodingScheme::DATA_CODING_UCS2;
1448 EXPECT_GT(smsBaseMessage->GetMaxSegmentSize(codingType, 1, true, langId, 1), 0);
1449 EXPECT_GT(smsBaseMessage->GetSegmentSize(codingType, 1, true, langId), 0);
1450 std::string message = "";
1451 LengthInfo lenInfo;
1452 EXPECT_GE(smsBaseMessage->GetSmsSegmentsInfo(message, true, lenInfo), 0);
1453 message = "123";
1454 EXPECT_EQ(smsBaseMessage->GetSmsSegmentsInfo(message, true, lenInfo), TELEPHONY_ERR_SUCCESS);
1455 EXPECT_EQ(smsBaseMessage->GetSmsSegmentsInfo(message, false, lenInfo), TELEPHONY_ERR_SUCCESS);
1456 }
1457
1458 /**
1459 * @tc.number Telephony_SmsMmsGtest_SmsBaseMessage_0002
1460 * @tc.name Test SmsBaseMessage
1461 * @tc.desc Function test
1462 */
1463 HWTEST_F(BranchSmsPartTest, SmsBaseMessage_0002, Function | MediumTest | Level1)
1464 {
1465 auto gsmSmsMessage = std::make_shared<GsmSmsMessage>();
1466 std::vector<struct SplitInfo> splitResult;
1467 DataCodingScheme codingType = DATA_CODING_AUTO;
1468 std::string text = {0xe4, 0xbd, 0xa0, 0xe4, 0xbd, 0xa0, 0xe4, 0xbd, 0xa0, 0xf0, 0x9f, 0xa5, 0xb3, 0xf0, 0x9f, 0xa5,
1469 0xb3, 0xf0, 0x9f, 0xa5, 0xb3, 0xf0, 0x9f, 0xa5, 0xb3, 0xf0, 0x9f, 0xa5, 0xb3, 0xf0, 0x9f, 0xa5, 0xb3,
1470 0xf0, 0x9f, 0xa5, 0xb3, 0xf0, 0x9f, 0xa5, 0xb3, 0xf0, 0x9f, 0xa5, 0xb3, 0xf0, 0x9f, 0xa5, 0xb3,
1471 0xf0, 0x9f, 0xa5, 0xb3, 0xf0, 0x9f, 0xa5, 0xb3, 0xf0, 0x9f, 0xa5, 0xb3, 0xf0, 0x9f, 0xa5, 0xb3,
1472 0xf0, 0x9f, 0xa5, 0xb3, 0xf0, 0x9f, 0xa5, 0xb3, 0xf0, 0x9f, 0xa5, 0xb3, 0xf0, 0x9f, 0xa5, 0xb3,
1473 0xf0, 0x9f, 0xa5, 0xb3, 0xf0, 0x9f, 0xa5, 0xb3, 0xf0, 0x9f, 0xa5, 0xb3, 0xf0, 0x9f, 0xa5, 0xb3,
1474 0xf0, 0x9f, 0xa5, 0xb3, 0xf0, 0x9f, 0xa5, 0xb3, 0xf0, 0x9f, 0xa5, 0xb3, 0xf0, 0x9f, 0xa5, 0xb3,
1475 0xf0, 0x9f, 0xa5, 0xb3, 0xf0, 0x9f, 0xa5, 0xb3, 0xf0, 0x9f, 0xa5, 0xb3, 0xf0, 0x9f, 0xa5, 0xb3,
1476 0xf0, 0x9f, 0xa5, 0xb3, 0xf0, 0x9f, 0xa5, 0xb3, 0xf0, 0x9f, 0xa5, 0xb3, 0xf0, 0x9f, 0xa5, 0xb3,
1477 0xf0, 0x9f, 0xa5, 0xb3, 0xf0, 0x9f, 0xa5, 0xb3, 0xf0, 0x9f, 0xa5, 0xb3};
1478 std::string desAddr = "";
1479 gsmSmsMessage->SplitMessage(splitResult, text, false, codingType, false, desAddr);
1480 std::vector<unsigned char> expect1 = {0x4f, 0x60, 0x4f, 0x60, 0x4f, 0x60, 0xd8, 0x3e, 0xdd, 0x73,
1481 0xd8, 0x3e, 0xdd, 0x73, 0xd8, 0x3e, 0xdd, 0x73, 0xd8, 0x3e, 0xdd, 0x73, 0xd8, 0x3e, 0xdd, 0x73,
1482 0xd8, 0x3e, 0xdd, 0x73, 0xd8, 0x3e, 0xdd, 0x73, 0xd8, 0x3e, 0xdd, 0x73, 0xd8, 0x3e, 0xdd, 0x73,
1483 0xd8, 0x3e, 0xdd, 0x73, 0xd8, 0x3e, 0xdd, 0x73, 0xd8, 0x3e, 0xdd, 0x73, 0xd8, 0x3e, 0xdd, 0x73,
1484 0xd8, 0x3e, 0xdd, 0x73, 0xd8, 0x3e, 0xdd, 0x73, 0xd8, 0x3e, 0xdd, 0x73, 0xd8, 0x3e, 0xdd, 0x73,
1485 0xd8, 0x3e, 0xdd, 0x73, 0xd8, 0x3e, 0xdd, 0x73, 0xd8, 0x3e, 0xdd, 0x73, 0xd8, 0x3e, 0xdd, 0x73,
1486 0xd8, 0x3e, 0xdd, 0x73, 0xd8, 0x3e, 0xdd, 0x73, 0xd8, 0x3e, 0xdd, 0x73, 0xd8, 0x3e, 0xdd, 0x73,
1487 0xd8, 0x3e, 0xdd, 0x73, 0xd8, 0x3e, 0xdd, 0x73, 0xd8, 0x3e, 0xdd, 0x73, 0xd8, 0x3e, 0xdd, 0x73,
1488 0xd8, 0x3e, 0xdd, 0x73, 0xd8, 0x3e, 0xdd, 0x73, 0xd8, 0x3e, 0xdd, 0x73};
1489 std::vector<unsigned char> expect2 = {0xd8, 0x3e, 0xdd, 0x73, 0xd8, 0x3e, 0xdd, 0x73, 0xd8, 0x3e, 0xdd, 0x73,
1490 0xd8, 0x3e, 0xdd, 0x73, 0xd8, 0x3e, 0xdd, 0x73};
1491 EXPECT_TRUE(splitResult[0].encodeData == expect1);
1492 EXPECT_TRUE(splitResult[1].encodeData == expect2);
1493 }
1494
1495 /**
1496 * @tc.number Telephony_SmsMmsGtest_SmsPersistHelper_0002
1497 * @tc.name Test SmsPersistHelper
1498 * @tc.desc Function test
1499 */
1500 HWTEST_F(BranchSmsPartTest, SmsPersistHelper_0002, Function | MediumTest | Level1)
1501 {
1502 auto smsPersistHelper = DelayedSingleton<SmsPersistHelper>::GetInstance();
1503 smsPersistHelper->CreateSmsHelper();
1504 smsPersistHelper->SendEvent(0);
1505 uint32_t releaseDataShareHelperEventId = 10000;
1506 smsPersistHelper->SendEvent(releaseDataShareHelperEventId);
1507 EXPECT_TRUE(smsPersistHelper->smsDataShareHelper_ == nullptr);
1508 smsPersistHelper->RemoveEvent(releaseDataShareHelperEventId);
1509 }
1510 } // namespace Telephony
1511 } // namespace OHOS
1512