1 /*
2 * Copyright (C) 2023 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 "cdma_sms_message.h"
20 #include "cdma_sms_teleservice_message.h"
21 #include "cdma_sms_transport_message.h"
22 #include "core_service_client.h"
23 #include "delivery_short_message_callback_stub.h"
24 #include "gtest/gtest.h"
25 #include "i_sms_service_interface.h"
26 #include "if_system_ability_manager.h"
27 #include "iservice_registry.h"
28 #include "radio_event.h"
29 #include "sms_mms_gtest.h"
30 #include "sms_mms_test_helper.h"
31 #include "sms_service.h"
32 #include "sms_service_manager_client.h"
33 #include "string_utils.h"
34 #include "telephony_log_wrapper.h"
35
36 namespace OHOS {
37 namespace Telephony {
38 namespace {
39 sptr<ISmsServiceInterface> g_telephonyService = nullptr;
40 } // namespace
41 using namespace testing::ext;
42
43 class CdmaSmsGtest : public testing::Test {
44 public:
45 static void SetUpTestCase();
46 static void TearDownTestCase();
47 void SetUp();
48 void TearDown();
49 static sptr<ISmsServiceInterface> GetProxy();
HasSimCard(int32_t slotId)50 static bool HasSimCard(int32_t slotId)
51 {
52 bool hasSimCard = false;
53 if (CoreServiceClient::GetInstance().GetProxy() == nullptr) {
54 return hasSimCard;
55 }
56 CoreServiceClient::GetInstance().HasSimCard(slotId, hasSimCard);
57 return hasSimCard;
58 }
59 };
60
61 constexpr uint32_t EVENT_RELEASE_DATA_SHARE_HELPER = 10000;
TearDownTestCase()62 void CdmaSmsGtest::TearDownTestCase()
63 {
64 DelayedSingleton<SmsPersistHelper>::GetInstance()->RemoveEvent(EVENT_RELEASE_DATA_SHARE_HELPER);
65 }
66
SetUp()67 void CdmaSmsGtest::SetUp() {}
68
TearDown()69 void CdmaSmsGtest::TearDown() {}
70
71 const int32_t DEFAULT_SIM_SLOT_ID_1 = 1;
72 const uint8_t HEX_CHAR_LEN = 2;
73 const uint8_t UNICODE_CHAR_LEN = 2;
74 const uint8_t VALUE_INDEX = 2;
75 const char *CDMA_PDU = "01010101";
76 const char *OTHER_CDMA_PDU = "111111";
77
SetUpTestCase()78 void CdmaSmsGtest::SetUpTestCase()
79 {
80 TELEPHONY_LOGI("SetUpTestCase slotId%{public}d", DEFAULT_SIM_SLOT_ID_1);
81 g_telephonyService = GetProxy();
82 if (g_telephonyService == nullptr) {
83 return;
84 }
85 Singleton<SmsServiceManagerClient>::GetInstance().ResetSmsServiceProxy();
86 Singleton<SmsServiceManagerClient>::GetInstance().InitSmsServiceProxy();
87 }
88
GetProxy()89 sptr<ISmsServiceInterface> CdmaSmsGtest::GetProxy()
90 {
91 auto systemAbilityMgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
92 if (systemAbilityMgr == nullptr) {
93 return nullptr;
94 }
95 sptr<IRemoteObject> remote = systemAbilityMgr->CheckSystemAbility(TELEPHONY_SMS_MMS_SYS_ABILITY_ID);
96 if (remote) {
97 sptr<ISmsServiceInterface> smsService = iface_cast<ISmsServiceInterface>(remote);
98 return smsService;
99 }
100 return nullptr;
101 }
102
103 #ifndef TEL_TEST_UNSUPPORT
104 /**
105 * @tc.number Telephony_SmsMmsGtest_CdmaSmsMessage_0001
106 * @tc.name Test CdmaSmsMessage
107 * @tc.desc Function test
108 */
109 HWTEST_F(CdmaSmsGtest, CdmaSmsMessage_0001, Function | MediumTest | Level1)
110 {
111 TELEPHONY_LOGI("TelSMSMMSTest::CdmaSmsMessage_0001 -->");
112 CdmaSmsMessage cdmaSmsMessage;
113 std::string dest = "dest";
114 std::string sc = "sc";
115 std::string text = "text";
116 int32_t port = 10;
117 uint8_t *data;
118 uint32_t dataLen = 10;
119 std::string pdu = "01000B818176251308F4000007E8B0BCFD76E701";
120 bool bStatusReport = false;
121 DataCodingScheme codingScheme = DATA_CODING_7BIT;
122 cdmaSmsMessage.CreateSubmitTransMsg(dest, sc, text, bStatusReport, codingScheme);
123 cdmaSmsMessage.CreateSubmitTransMsg(dest, sc, port, data, dataLen, bStatusReport);
124 cdmaSmsMessage.GreateTransMsg();
125 cdmaSmsMessage.CovertEncodingType(codingScheme);
126 cdmaSmsMessage.CreateMessage(pdu);
127 cdmaSmsMessage.PduAnalysis(pdu);
128 CdmaP2PMsg p2pMsg;
129 cdmaSmsMessage.AnalysisP2pMsg(p2pMsg);
130 cdmaSmsMessage.AnalsisDeliverMwi(p2pMsg);
131 bool ret = cdmaSmsMessage.PduAnalysis("");
132 EXPECT_EQ(false, ret);
133 }
134
135 /**
136 * @tc.number Telephony_SmsMmsGtest_CdmaSmsReceiveHandler_0001
137 * @tc.name Test CdmaSmsReceiveHandler
138 * @tc.desc Function test
139 */
140 HWTEST_F(CdmaSmsGtest, CdmaSmsReceiveHandler_0001, Function | MediumTest | Level1)
141 {
142 TELEPHONY_LOGI("TelSMSMMSTest::CdmaSmsReceiveHandler_0001 -->");
143 auto smsReceiveManager = std::make_shared<SmsReceiveManager>(DEFAULT_SIM_SLOT_ID);
144 EXPECT_TRUE(smsReceiveManager != nullptr);
145 smsReceiveManager->Init();
146 EXPECT_TRUE(smsReceiveManager->cdmaSmsReceiveHandler_ != nullptr);
147 int32_t retInt = smsReceiveManager->cdmaSmsReceiveHandler_->HandleSmsByType(nullptr);
148 EXPECT_EQ(AckIncomeCause::SMS_ACK_UNKNOWN_ERROR, retInt);
149 }
150
151 /**
152 * @tc.number Telephony_SmsMmsGtest_CdmaSmsReceiveHandler_0002
153 * @tc.name Test CdmaSmsReceiveHandler
154 * @tc.desc Function test
155 */
156 HWTEST_F(CdmaSmsGtest, CdmaSmsReceiveHandler_0002, Function | MediumTest | Level1)
157 {
158 TELEPHONY_LOGI("TelSMSMMSTest::CdmaSmsReceiveHandler_0002 -->");
159 auto smsReceiveManager = std::make_shared<SmsReceiveManager>(DEFAULT_SIM_SLOT_ID);
160 EXPECT_TRUE(smsReceiveManager != nullptr);
161 smsReceiveManager->Init();
162 EXPECT_TRUE(smsReceiveManager->cdmaSmsReceiveHandler_ != nullptr);
163 auto retMsg = std::make_shared<CdmaSmsMessage>();
164 retMsg = CdmaSmsMessage::CreateMessage(CDMA_PDU);
165 EXPECT_EQ(retMsg, nullptr);
166 auto cdmaMsg = std::make_shared<CdmaSmsMessage>();
167 cdmaMsg->transMsg_ = std::make_unique<struct CdmaTransportMsg>();
168 cdmaMsg->transMsg_->type = CdmaTransportMsgType::BROADCAST;
169 int32_t retInt = smsReceiveManager->cdmaSmsReceiveHandler_->HandleSmsByType(cdmaMsg);
170 EXPECT_EQ(AckIncomeCause::SMS_ACK_RESULT_OK, retInt);
171 cdmaMsg->transMsg_->type = CdmaTransportMsgType::P2P;
172 retInt = smsReceiveManager->cdmaSmsReceiveHandler_->HandleSmsByType(cdmaMsg);
173 EXPECT_EQ(AckIncomeCause::SMS_ACK_RESULT_OK, retInt);
174 cdmaMsg->transMsg_->type = CdmaTransportMsgType::ACK;
175 retInt = smsReceiveManager->cdmaSmsReceiveHandler_->HandleSmsByType(cdmaMsg);
176 EXPECT_EQ(AckIncomeCause::SMS_ACK_RESULT_OK, retInt);
177 cdmaMsg->transMsg_->type = CdmaTransportMsgType::RESERVED;
178 retInt = smsReceiveManager->cdmaSmsReceiveHandler_->HandleSmsByType(cdmaMsg);
179 EXPECT_EQ(AckIncomeCause::SMS_ACK_RESULT_OK, retInt);
180 }
181
182 /**
183 * @tc.number Telephony_SmsMmsGtest_CdmaSmsReceiveHandler_0003
184 * @tc.name Test CdmaSmsReceiveHandler
185 * @tc.desc Function test
186 */
187 HWTEST_F(CdmaSmsGtest, CdmaSmsReceiveHandler_0003, Function | MediumTest | Level1)
188 {
189 TELEPHONY_LOGI("TelSMSMMSTest::CdmaSmsReceiveHandler_0003 -->");
190 auto smsReceiveManager = std::make_shared<SmsReceiveManager>(DEFAULT_SIM_SLOT_ID);
191 EXPECT_TRUE(smsReceiveManager != nullptr);
192 smsReceiveManager->Init();
193 EXPECT_TRUE(smsReceiveManager->cdmaSmsReceiveHandler_ != nullptr);
194 int32_t retInt = smsReceiveManager->cdmaSmsReceiveHandler_->HandleSmsOtherSvcid(nullptr);
195 EXPECT_NE(AckIncomeCause::SMS_ACK_RESULT_OK, retInt);
196 auto retMsg = CdmaSmsMessage::CreateMessage(OTHER_CDMA_PDU);
197 EXPECT_EQ(retMsg, nullptr);
198
199 auto cdmaMsg = std::make_shared<CdmaSmsMessage>();
200 smsReceiveManager->cdmaSmsReceiveHandler_->ReplySmsToSmsc(1);
201 retInt = smsReceiveManager->cdmaSmsReceiveHandler_->HandleSmsOtherSvcid(cdmaMsg);
202 EXPECT_NE(AckIncomeCause::SMS_ACK_RESULT_OK, retInt);
203 cdmaMsg->smsConcat_ = std::make_shared<SmsConcat>();
204 cdmaMsg->smsConcat_->is8Bits = true;
205 cdmaMsg->smsConcat_->msgRef = 1;
206 cdmaMsg->smsConcat_->seqNum = 1;
207 cdmaMsg->smsConcat_->totalSeg = 1;
208 retInt = smsReceiveManager->cdmaSmsReceiveHandler_->HandleSmsOtherSvcid(cdmaMsg);
209 EXPECT_NE(AckIncomeCause::SMS_ACK_RESULT_OK, retInt);
210 }
211
212 /**
213 * @tc.number Telephony_SmsMmsGtest_CdmaSmsReceiveHandler_0004
214 * @tc.name Test CdmaSmsReceiveHandler
215 * @tc.desc Function test
216 */
217 HWTEST_F(CdmaSmsGtest, CdmaSmsReceiveHandler_0004, Function | MediumTest | Level1)
218 {
219 TELEPHONY_LOGI("TelSMSMMSTest::CdmaSmsReceiveHandler_0004 -->");
220 auto smsReceiveManager = std::make_shared<SmsReceiveManager>(DEFAULT_SIM_SLOT_ID);
221 EXPECT_TRUE(smsReceiveManager != nullptr);
222 smsReceiveManager->Init();
223 EXPECT_TRUE(smsReceiveManager->cdmaSmsReceiveHandler_ != nullptr);
224 std::function<void(std::shared_ptr<SmsSendIndexer>)> fun = nullptr;
225 auto smsSender = std::make_shared<CdmaSmsSender>(DEFAULT_SIM_SLOT_ID, fun);
226 smsReceiveManager->cdmaSmsReceiveHandler_->SetCdmaSender(smsSender);
227 auto info = std::make_shared<SmsMessageInfo>();
228 auto ret = smsReceiveManager->cdmaSmsReceiveHandler_->TransformMessageInfo(info);
229 EXPECT_EQ(ret, nullptr);
230 smsReceiveManager->cdmaSmsReceiveHandler_->SendCBBroadcast(nullptr);
231 auto cdmaMsg = std::make_shared<CdmaSmsMessage>();
232 EXPECT_EQ(smsReceiveManager->cdmaSmsReceiveHandler_->SendCBBroadcast(cdmaMsg), true);
233 }
234
235 /**
236 * @tc.number Telephony_CdmaSmsGtest_SmsPduBuffer_0001
237 * @tc.name Test SmsPduBuffer
238 * @tc.desc Function test
239 */
240 HWTEST_F(CdmaSmsGtest, SmsPduBuffer_0001, Function | MediumTest | Level1)
241 {
242 auto buffer = std::make_shared<SmsPduBuffer>();
243 EXPECT_TRUE(buffer->IsEmpty());
244 EXPECT_EQ(buffer->GetIndex(), 0);
245 EXPECT_FALSE(buffer->SetIndex(1));
246 EXPECT_EQ(buffer->MoveForward(), 0);
247 EXPECT_EQ(buffer->SkipBits(), 0);
248
249 std::string pduHex = "00000210020000021002";
250 std::string pdu = StringUtils::HexToString(pduHex);
251 auto rBuffer = std::make_shared<SmsReadBuffer>(pdu);
252 EXPECT_FALSE(rBuffer->IsEmpty());
253 rBuffer->SetIndex(0);
254 uint8_t v = 0;
255 uint16_t v2 = 0;
256 EXPECT_TRUE(rBuffer->ReadByte(v));
257 EXPECT_TRUE(rBuffer->ReadWord(v2));
258 EXPECT_TRUE(rBuffer->ReadBits(v));
259
260 auto wBuffer = std::make_shared<SmsWriteBuffer>();
261 EXPECT_FALSE(wBuffer->IsEmpty());
262 wBuffer->SetIndex(0);
263 v = 1;
264 v2 = 0x1234;
265 EXPECT_TRUE(wBuffer->WriteByte(v));
266 EXPECT_TRUE(wBuffer->WriteWord(v2));
267 EXPECT_TRUE(wBuffer->InsertByte(v, 1));
268 EXPECT_TRUE(wBuffer->WriteBits(v));
269 }
270
271 /**
272 * @tc.number Telephony_CdmaSmsGtest_CdmaSmsTransportMessage_0001
273 * @tc.name Test CdmaSmsTransportMessage
274 * @tc.desc Function test
275 */
276 HWTEST_F(CdmaSmsGtest, CdmaSmsTransportMessage_0001, Function | MediumTest | Level1)
277 {
278 TELEPHONY_LOGI("TelSMSMMSTest::CdmaSmsTransportMessage_0001 -->");
279 CdmaSmsMessage cdmaSmsMessage;
280 std::string dest = "dest";
281 std::string sc = "sc";
282 std::string text = "text";
283 bool bStatusReport = false;
284 DataCodingScheme codingScheme = DATA_CODING_7BIT;
285 std::unique_ptr<CdmaTransportMsg> transMsg =
286 cdmaSmsMessage.CreateSubmitTransMsg(dest, sc, text, bStatusReport, codingScheme);
287
288 std::unique_ptr<CdmaSmsTransportMessage> transportMessage =
289 CdmaSmsTransportMessage::CreateTransportMessage(*transMsg.get());
290 SmsWriteBuffer pduBuffer;
291 EXPECT_NE(transportMessage, nullptr);
292 EXPECT_NE(transportMessage->IsEmpty(), true);
293 EXPECT_EQ(transportMessage->Encode(pduBuffer), true);
294 std::unique_ptr<std::vector<uint8_t>> pdu = pduBuffer.GetPduBuffer();
295 EXPECT_NE(pdu, nullptr);
296 EXPECT_GT(pdu->size(), static_cast<uint32_t>(0));
297 }
298
299 /**
300 * @tc.number Telephony_CdmaSmsGtest_CdmaSmsTransportMessage_0002
301 * @tc.name Test CdmaSmsTransportMessage
302 * @tc.desc Function test
303 */
304 HWTEST_F(CdmaSmsGtest, CdmaSmsTransportMessage_0002, Function | MediumTest | Level1)
305 {
306 TELEPHONY_LOGI("TelSMSMMSTest::CdmaSmsTransportMessage_0002 -->");
307 std::string pduHex = "0000021002040702C48D159E268406010408260003200640011910D61C58F265CD9F469D5AF66DDDBF871E5CFA75E"
308 "DDFC79F400801000A0140";
309 std::string pdu = StringUtils::HexToString(pduHex);
310 SmsReadBuffer pduBuffer(pdu);
311 CdmaTransportMsg msg;
312 memset_s(&msg, sizeof(msg), 0, sizeof(msg));
313 std::unique_ptr<CdmaSmsTransportMessage> transportMessage =
314 CdmaSmsTransportMessage::CreateTransportMessage(msg, pduBuffer);
315 EXPECT_NE(transportMessage, nullptr);
316 EXPECT_NE(transportMessage->IsEmpty(), true);
317 EXPECT_EQ(transportMessage->Decode(pduBuffer), true);
318 }
319
320 /**
321 * @tc.number Telephony_CdmaSmsGtest_CdmaSmsTransportMessage_0003
322 * @tc.name Test CdmaSmsTransportMessage
323 * @tc.desc Function test
324 */
325 HWTEST_F(CdmaSmsGtest, CdmaSmsTransportMessage_0003, Function | MediumTest | Level1)
326 {
327 // BROADCAST DELIVER CMASDATA
328 uint8_t cmasTestBearerData[] = { 0x00, 0x03, 0x1C, 0x78, 0x00, 0x01, 0x59, 0x02, 0xB8, 0x00, 0x02, 0x10, 0xAA,
329 0x68, 0xD3, 0xCD, 0x06, 0x9E, 0x68, 0x30, 0xA0, 0xE9, 0x97, 0x9F, 0x44, 0x1B, 0xF3, 0x20, 0xE9, 0xA3, 0x2A,
330 0x08, 0x7B, 0xF6, 0xED, 0xCB, 0xCB, 0x1E, 0x9C, 0x3B, 0x10, 0x4D, 0xDF, 0x8B, 0x4E, 0xCC, 0xA8, 0x20, 0xEC,
331 0xCB, 0xCB, 0xA2, 0x0A, 0x7E, 0x79, 0xF4, 0xCB, 0xB5, 0x72, 0x0A, 0x9A, 0x34, 0xF3, 0x41, 0xA7, 0x9A, 0x0D,
332 0xFB, 0xB6, 0x79, 0x41, 0x85, 0x07, 0x4C, 0xBC, 0xFA, 0x2E, 0x00, 0x08, 0x20, 0x58, 0x38, 0x88, 0x80, 0x10,
333 0x54, 0x06, 0x38, 0x20, 0x60, 0x30, 0xA8, 0x81, 0x90, 0x20, 0x08 };
334
335 std::stringstream ss;
336 ss.clear();
337 ss << static_cast<uint8_t>(CdmaTransportMsgType::BROADCAST);
338 ss << static_cast<uint8_t>(CdmaSmsParameterRecord::SERVICE_CATEGORY);
339 ss << static_cast<uint8_t>(0x02);
340 ss << static_cast<uint8_t>(static_cast<uint16_t>(SmsServiceCtg::CMAS_TEST) >> 8);
341 ss << static_cast<uint8_t>(static_cast<uint16_t>(SmsServiceCtg::CMAS_TEST) & 0xff);
342 ss << static_cast<uint8_t>(CdmaSmsParameterRecord::BEARER_DATA);
343 ss << static_cast<uint8_t>(sizeof(cmasTestBearerData));
344 for (uint8_t i = 0; i < sizeof(cmasTestBearerData); i++) {
345 ss << cmasTestBearerData[i];
346 }
347 SmsReadBuffer rBuffer(ss.str());
348 CdmaTransportMsg msg;
349 memset_s(&msg, sizeof(msg), 0, sizeof(msg));
350 std::unique_ptr<CdmaSmsTransportMessage> message = CdmaSmsTransportMessage::CreateTransportMessage(msg, rBuffer);
351 EXPECT_TRUE(message->Decode(rBuffer));
352 EXPECT_EQ(msg.data.broadcast.telesvcMsg.data.deliver.msgId.msgId, 0xc780);
353 EXPECT_EQ(msg.data.broadcast.serviceCtg, static_cast<uint16_t>(SmsServiceCtg::CMAS_TEST));
354 EXPECT_EQ(msg.data.broadcast.telesvcMsg.data.deliver.cmasData.dataLen, 74);
355 EXPECT_EQ(msg.data.broadcast.telesvcMsg.data.deliver.cmasData.urgency, SmsCmaeUrgency::EXPECTED);
356 }
357
358 /**
359 * @tc.number Telephony_CdmaSmsGtest_CdmaSmsTransportMessage_0004
360 * @tc.name Test CdmaSmsTransportMessage
361 * @tc.desc Function test
362 */
363 HWTEST_F(CdmaSmsGtest, CdmaSmsTransportMessage_0004, Function | MediumTest | Level1)
364 {
365 // BROADCAST DELIVER USERDATA(BCCBB)
366 std::string pduHex = "0101020004081300031008d00106102c2870e1420801c00c01c0";
367 std::string pdu = StringUtils::HexToString(pduHex);
368 SmsReadBuffer pduBuffer(pdu);
369 CdmaTransportMsg msg;
370 memset_s(&msg, sizeof(msg), 0, sizeof(msg));
371 std::unique_ptr<CdmaSmsTransportMessage> transportMessage =
372 CdmaSmsTransportMessage::CreateTransportMessage(msg, pduBuffer);
373 EXPECT_NE(transportMessage, nullptr);
374 EXPECT_FALSE(transportMessage->IsEmpty());
375 EXPECT_TRUE(transportMessage->Decode(pduBuffer));
376 }
377
GetUserDataString(SmsTeleSvcUserData userData)378 string GetUserDataString(SmsTeleSvcUserData userData)
379 {
380 std::stringstream ssUserData;
381 if (userData.encodeType == SmsEncodingType::UNICODE) {
382 char unicodeChar[UNICODE_CHAR_LEN + 1];
383 unicodeChar[UNICODE_CHAR_LEN] = '\0';
384 for (uint8_t i = 0; i < userData.userData.length; i += UNICODE_CHAR_LEN) {
385 ssUserData << "\\u";
386 snprintf_s(unicodeChar, sizeof(unicodeChar), sizeof(unicodeChar) - 1, "%02x",
387 static_cast<uint8_t>(userData.userData.data[i]));
388 ssUserData << unicodeChar;
389 snprintf_s(unicodeChar, sizeof(unicodeChar), sizeof(unicodeChar) - 1, "%02x",
390 static_cast<uint8_t>(userData.userData.data[i + 1]));
391 ssUserData << unicodeChar;
392 }
393 } else {
394 for (uint8_t i = 0; i < userData.userData.length; i++) {
395 ssUserData << static_cast<uint8_t>(userData.userData.data[i]);
396 }
397 }
398 return ssUserData.str();
399 }
400
CheckDeliverUserData(string pdu,string userData)401 void CheckDeliverUserData(string pdu, string userData)
402 {
403 std::stringstream ss;
404 ss << static_cast<uint8_t>(CdmaSmsParameterRecord::BEARER_DATA);
405 ss << static_cast<uint8_t>(pdu.size() / HEX_CHAR_LEN);
406 ss << StringUtils::HexToString(pdu);
407
408 CdmaTeleserviceMsg v;
409 memset_s(&v, sizeof(CdmaTeleserviceMsg), 0x00, sizeof(CdmaTeleserviceMsg));
410 SmsReadBuffer rBuffer(ss.str());
411 rBuffer.SetIndex(VALUE_INDEX);
412 auto message = std::make_shared<CdmaSmsBearerData>(v, rBuffer);
413 rBuffer.SetIndex(0);
414 EXPECT_TRUE(message->Decode(rBuffer));
415 EXPECT_STREQ(GetUserDataString(v.data.deliver.userData).c_str(), userData.c_str());
416 }
417
CheckSubmitUserData(string pdu,string userData)418 void CheckSubmitUserData(string pdu, string userData)
419 {
420 std::stringstream ss;
421 ss << static_cast<uint8_t>(CdmaSmsParameterRecord::BEARER_DATA);
422 ss << static_cast<uint8_t>(pdu.size() / HEX_CHAR_LEN);
423 ss << StringUtils::HexToString(pdu);
424
425 CdmaTeleserviceMsg v;
426 memset_s(&v, sizeof(CdmaTeleserviceMsg), 0x00, sizeof(CdmaTeleserviceMsg));
427 SmsReadBuffer rBuffer(ss.str());
428 rBuffer.SetIndex(VALUE_INDEX);
429 auto message = std::make_shared<CdmaSmsBearerData>(v, rBuffer);
430 rBuffer.SetIndex(0);
431 EXPECT_TRUE(message->Decode(rBuffer));
432 EXPECT_STREQ(GetUserDataString(v.data.submit.userData).c_str(), userData.c_str());
433
434 auto message1 = std::make_shared<CdmaSmsBearerData>(v);
435 SmsWriteBuffer wBuffer;
436 EXPECT_TRUE(message1->Encode(wBuffer));
437 auto buffer = wBuffer.GetPduBuffer();
438 EXPECT_GT(buffer->size(), 0);
439 std::stringstream ssEncode;
440 for (uint16_t i = 0; i < buffer->size(); i++) {
441 ssEncode << (*buffer)[i];
442 }
443
444 CdmaTeleserviceMsg v2;
445 memset_s(&v2, sizeof(CdmaTeleserviceMsg), 0x00, sizeof(CdmaTeleserviceMsg));
446 SmsReadBuffer rBuffer2(ssEncode.str());
447 rBuffer2.SetIndex(VALUE_INDEX);
448 auto message2 = std::make_shared<CdmaSmsBearerData>(v2, rBuffer2);
449 rBuffer2.SetIndex(0);
450 EXPECT_TRUE(message2->Decode(rBuffer2));
451 EXPECT_STREQ(GetUserDataString(v2.data.submit.userData).c_str(), userData.c_str());
452 }
453
454 /**
455 * @tc.number Telephony_CdmaSmsGtest_CdmaSmsBearerData_0001
456 * @tc.name Test CdmaSmsBearerData
457 * @tc.desc Function test
458 */
459 HWTEST_F(CdmaSmsGtest, CdmaSmsBearerData_0001, Function | MediumTest | Level1)
460 {
461 // gsm 7bit
462 CheckDeliverUserData("00031040900112488ea794e074d69e1b7392c270326cde9e98", "Test standard SMS");
463 // ascii 7bit
464 CheckDeliverUserData("0003100160010610262d5ab500", "bjjj");
465 // ia5
466 CheckDeliverUserData("00031002100109184539b4d052ebb3d0", "SMS Rulz");
467 // unicode
468 CheckDeliverUserData("000310021001062012716B2C380801000A0140", "\\u4e2d\\u6587");
469
470 // gsm 7bit
471 CheckSubmitUserData("00032006400112488ea794e074d69e1b7392c270326cde9e98", "Test standard SMS");
472 // ascii 7bit
473 CheckSubmitUserData("0003200640010610262d5ab500", "bjjj");
474 // ia5
475 CheckSubmitUserData("00032006400109184539b4d052ebb3d0", "SMS Rulz");
476 // unicode
477 CheckSubmitUserData("000320064001062012716B2C380801000A0140", "\\u4e2d\\u6587");
478 }
479
480 /**
481 * @tc.number Telephony_CdmaSmsGtest_CdmaSmsBearerData_0002
482 * @tc.name Test CdmaSmsBearerData
483 * @tc.desc Function test
484 */
485 HWTEST_F(CdmaSmsGtest, CdmaSmsBearerData_0002, Function | MediumTest | Level1)
486 {
487 std::string dataStr = "0003200010010410168d20020105030608120111015905019206069706180000000801c00901800a01e00b"
488 "01030c01c00d01070e05039acc13880f018011020566";
489 std::stringstream ss;
490 ss.clear();
491 ss << static_cast<uint8_t>(CdmaSmsParameterRecord::BEARER_DATA);
492 ss << static_cast<uint8_t>(dataStr.size() / HEX_CHAR_LEN);
493 ss << StringUtils::HexToString(dataStr);
494
495 CdmaTeleserviceMsg v;
496 memset_s(&v, sizeof(CdmaTeleserviceMsg), 0x00, sizeof(CdmaTeleserviceMsg));
497 SmsReadBuffer rBuffer(ss.str());
498 rBuffer.SetIndex(VALUE_INDEX);
499 auto message = std::make_shared<CdmaSmsBearerData>(v, rBuffer);
500 rBuffer.SetIndex(0);
501 EXPECT_TRUE(message->Decode(rBuffer));
502 EXPECT_EQ(v.type, TeleserviceMsgType::SUBMIT);
503 EXPECT_EQ(v.data.submit.msgId.msgId, 1);
504 EXPECT_EQ(v.data.submit.priority, SmsPriorityIndicator::EMERGENCY);
505 EXPECT_EQ(v.data.submit.privacy, SmsPrivacyIndicator::CONFIDENTIAL);
506 EXPECT_EQ(v.data.submit.callbackNumber.addrLen, 7);
507 char number[] = "3598271";
508 for (uint8_t i = 0; i < sizeof(number); i++) {
509 EXPECT_EQ(v.data.submit.callbackNumber.szData[i], number[i]);
510 }
511 EXPECT_EQ(v.data.submit.depositId, 1382);
512 EXPECT_EQ(v.data.submit.language, SmsLanguageType::HEBREW);
513 EXPECT_EQ(v.data.submit.alertPriority, SmsAlertPriority::HIGH);
514 EXPECT_EQ(v.data.submit.deferValPeriod.time.absTime.year, 97);
515 EXPECT_EQ(v.data.submit.deferValPeriod.time.absTime.month, 6);
516 EXPECT_EQ(v.data.submit.deferValPeriod.time.absTime.day, 18);
517 }
518
519 /**
520 * @tc.number Telephony_CdmaSmsGtest_CdmaSmsSender_0001
521 * @tc.name Test CdmaSmsSender
522 * @tc.desc Function test
523 */
524 HWTEST_F(CdmaSmsGtest, CdmaSmsSender_0001, Function | MediumTest | Level1)
525 {
__anon9750b94d0202(std::shared_ptr<SmsSendIndexer> indexer) 526 std::function<void(std::shared_ptr<SmsSendIndexer>)> fun = [](std::shared_ptr<SmsSendIndexer> indexer) {};
527 std::shared_ptr<CdmaSmsSender> smsSender = std::make_shared<CdmaSmsSender>(DEFAULT_SIM_SLOT_ID, fun);
528 int i = 0;
529 std::vector<struct SplitInfo> cellsInfos;
530 SplitInfo info;
531 for (uint8_t j = 0; j < MAX_USER_DATA_LEN + 2; j++) {
532 info.encodeData.push_back(j);
533 }
534 cellsInfos.push_back(info);
535 GsmSmsMessage gsmSmsMessage;
536 std::shared_ptr<struct SmsTpdu> tpdu = std::make_shared<struct SmsTpdu>();
537 std::shared_ptr<uint8_t> unSentCellCount = std::make_shared<uint8_t>(0);
538 std::shared_ptr<bool> hasCellFailed = std::make_shared<bool>(false);
539 smsSender->SendSmsForEveryIndexer(i, cellsInfos, "", "", tpdu, gsmSmsMessage, unSentCellCount,
540 hasCellFailed, DATA_CODING_7BIT, 0, nullptr, nullptr, 0, false);
541
542 info.encodeData.clear();
543 for (uint8_t j = 0; j < MAX_USER_DATA_LEN; j++) {
544 info.encodeData.push_back(j);
545 }
546 cellsInfos.push_back(info);
547 i = 1;
548 smsSender->SendSmsForEveryIndexer(i, cellsInfos, "", "", tpdu, gsmSmsMessage, unSentCellCount,
549 hasCellFailed, DATA_CODING_7BIT, 0, nullptr, nullptr, 0, false);
550
551 cellsInfos.push_back(info);
552 cellsInfos.push_back(info);
553 i = 1;
554 tpdu->data.submit.bStatusReport = true;
555 smsSender->SendSmsForEveryIndexer(i, cellsInfos, "", "", tpdu, gsmSmsMessage, unSentCellCount,
556 hasCellFailed, DATA_CODING_7BIT, 0, nullptr, nullptr, 0, false);
557 EXPECT_FALSE(tpdu->data.submit.bStatusReport);
558 }
559
560 /**
561 * @tc.number Telephony_CdmaSmsGtest_CdmaSmsSender_0002
562 * @tc.name Test CdmaSmsSender
563 * @tc.desc Function test
564 */
565 HWTEST_F(CdmaSmsGtest, CdmaSmsSender_0002, Function | MediumTest | Level1)
566 {
__anon9750b94d0302(std::shared_ptr<SmsSendIndexer> indexer) 567 std::function<void(std::shared_ptr<SmsSendIndexer>)> fun = [](std::shared_ptr<SmsSendIndexer> indexer) {};
568 std::shared_ptr<CdmaSmsSender> smsSender = std::make_shared<CdmaSmsSender>(DEFAULT_SIM_SLOT_ID, fun);
569 std::shared_ptr<SmsSendIndexer> indexer = std::make_shared<SmsSendIndexer>("des", "src", "text", nullptr, nullptr);
570 std::shared_ptr<struct EncodeInfo> encodeInfo = std::make_shared<struct EncodeInfo>();
571 smsSender->SetSendIndexerInfo(indexer, nullptr, 0);
572 smsSender->SetSendIndexerInfo(nullptr, encodeInfo, 0);
573 std::unique_ptr<CdmaTransportMsg> transMsg = std::make_unique<CdmaTransportMsg>();
574 smsSender->SetPduSeqInfo(indexer, 2, transMsg, 0, 0);
575 smsSender->isImsNetDomain_ = true;
576 smsSender->imsSmsCfg_ = true;
577 std::vector<struct SplitInfo> cellsInfos;
578 SplitInfo info;
579 for (uint8_t j = 0; j < MAX_USER_DATA_LEN; j++) {
580 info.encodeData.push_back(j);
581 }
582 smsSender->DataBasedSmsDelivery("des", "src", 0, info.encodeData.data(), info.encodeData.size(), nullptr, nullptr);
583 smsSender->imsSmsCfg_ = false;
584 smsSender->DataBasedSmsDelivery("des", "src", 0, info.encodeData.data(), info.encodeData.size(), nullptr, nullptr);
585 std::unique_ptr<CdmaTransportMsg> transMsg2 = std::make_unique<CdmaTransportMsg>();
586 smsSender->EncodeMsgData(std::move(transMsg2), indexer, 0, nullptr);
587 for (uint8_t j = 0; j < MAX_SEGMENT_NUM + 2; j++) {
588 cellsInfos.push_back(info);
589 }
590 std::shared_ptr<struct SmsTpdu> tpdu = std::make_shared<struct SmsTpdu>();
591 std::shared_ptr<uint8_t> unSentCellCount = std::make_shared<uint8_t>(0);
592 std::shared_ptr<bool> hasCellFailed = std::make_shared<bool>(false);
593 EXPECT_TRUE(smsSender->TpduNullOrSmsPageOverNormalOrSmsEncodeFail(cellsInfos, nullptr, unSentCellCount,
594 hasCellFailed, nullptr));
595 EXPECT_TRUE(smsSender->TpduNullOrSmsPageOverNormalOrSmsEncodeFail(cellsInfos, tpdu, unSentCellCount,
596 hasCellFailed, nullptr));
597 cellsInfos.clear();
598 EXPECT_TRUE(smsSender->TpduNullOrSmsPageOverNormalOrSmsEncodeFail(cellsInfos, tpdu, nullptr,
599 hasCellFailed, nullptr));
600 EXPECT_TRUE(smsSender->TpduNullOrSmsPageOverNormalOrSmsEncodeFail(cellsInfos, tpdu, unSentCellCount,
601 nullptr, nullptr));
602 EXPECT_FALSE(smsSender->TpduNullOrSmsPageOverNormalOrSmsEncodeFail(cellsInfos, tpdu, unSentCellCount,
603 hasCellFailed, nullptr));
604 }
605
606 /**
607 * @tc.number Telephony_CdmaSmsGtest_CdmaSmsSender_0003
608 * @tc.name Test CdmaSmsSender
609 * @tc.desc Function test
610 */
611 HWTEST_F(CdmaSmsGtest, CdmaSmsSender_0003, Function | MediumTest | Level1)
612 {
__anon9750b94d0402(std::shared_ptr<SmsSendIndexer> indexer) 613 std::function<void(std::shared_ptr<SmsSendIndexer>)> fun = [](std::shared_ptr<SmsSendIndexer> indexer) {};
614 std::shared_ptr<CdmaSmsSender> smsSender = std::make_shared<CdmaSmsSender>(DEFAULT_SIM_SLOT_ID, fun);
615 std::shared_ptr<SmsReceiveIndexer> statusInfo = std::make_shared<SmsReceiveIndexer>();
616 AppExecFwk::InnerEvent::Pointer event = AppExecFwk::InnerEvent::Get(0, statusInfo);
617 smsSender->StatusReportAnalysis(event);
618 std::vector<uint8_t> pdu =
619 { 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 };
620 statusInfo->SetPdu(pdu);
621 event = AppExecFwk::InnerEvent::Get(0, statusInfo);
622 std::shared_ptr<SmsSendIndexer> indexer = std::make_shared<SmsSendIndexer>("des", "src", "text", nullptr, nullptr);
623 auto message = CdmaSmsMessage::CreateMessage(StringUtils::StringToHex(pdu));
624 ASSERT_NE(message, nullptr);
625 indexer->SetMsgRefId(message->GetMsgRef() + 1);
626 smsSender->reportList_.push_back(indexer);
627 smsSender->StatusReportAnalysis(event);
628 indexer->SetMsgRefId(message->GetMsgRef());
629 sptr<DeliveryShortMessageCallbackStub> callback = new DeliveryShortMessageCallbackStub();
630 indexer->SetDeliveryCallback(callback);
631 smsSender->StatusReportAnalysis(event);
632 smsSender->StatusReportSetImsSms(event);
633 std::shared_ptr<RadioResponseInfo> imsResponseInfo = std::make_shared<RadioResponseInfo>();
634 imsResponseInfo->error = ErrType::NONE;
635 event = AppExecFwk::InnerEvent::Get(0, imsResponseInfo);
636 smsSender->StatusReportSetImsSms(event);
637 imsResponseInfo->error = ErrType::ERR_GENERIC_FAILURE;
638 event = AppExecFwk::InnerEvent::Get(0, imsResponseInfo);
639 smsSender->imsSmsCfg_ = CdmaSmsSender::IMS_SMS_ENABLE;
640 smsSender->StatusReportSetImsSms(event);
641 EXPECT_EQ(smsSender->imsSmsCfg_, CdmaSmsSender::IMS_SMS_DISABLE);
642 std::shared_ptr<int32_t> imsSmsInfo = std::make_shared<int32_t>(CdmaSmsSender::IMS_SMS_ENABLE);
643 event = AppExecFwk::InnerEvent::Get(0, imsSmsInfo);
644 smsSender->StatusReportGetImsSms(event);
645 EXPECT_EQ(smsSender->imsSmsCfg_, CdmaSmsSender::IMS_SMS_ENABLE);
646 CdmaTransportMsg msg;
647 EXPECT_EQ(smsSender->EncodeMsg(msg), nullptr);
648 indexer->SetIsConcat(true);
649 std::unique_ptr<CdmaTransportMsg> transMsg = std::make_unique<CdmaTransportMsg>();
650 SmsConcat concat;
651 concat.is8Bits = false;
652 indexer->SetSmsConcat(concat);
653 smsSender->SetConcact(indexer, transMsg);
654 concat.is8Bits = true;
655 indexer->SetSmsConcat(concat);
656 smsSender->SetConcact(indexer, transMsg);
657 EXPECT_EQ(transMsg->data.p2p.teleserviceId, static_cast<uint16_t>(SmsTransTelsvcId::WEMT));
658 }
659
660 /**
661 * @tc.number Telephony_CdmaSmsGtest_CdmaSmsTeleserviceMessage_0003
662 * @tc.name Test CdmaSmsTeleserviceMessage
663 * @tc.desc Function test
664 */
665 HWTEST_F(CdmaSmsGtest, CdmaSmsTeleserviceMessage_0003, Function | MediumTest | Level1)
666 {
667 SmsWriteBuffer wPdu;
668 wPdu.data_ = nullptr;
669 SmsReadBuffer rPdu("");
670 rPdu.data_ = nullptr;
671 CdmaSmsTeleserviceMessage msg;
672 EXPECT_FALSE(msg.Encode(wPdu));
673 EXPECT_FALSE(msg.Decode(rPdu));
674 EXPECT_EQ(msg.GetMessageType(rPdu), CdmaSmsTeleserviceMessage::RESERVED);
675 TeleserviceSubmit submit;
676 CdmaSmsSubmitMessage submitMsg(submit, rPdu);
677 TeleserviceDeliver deliver;
678 CdmaSmsDeliverMessage deliverMsg(deliver, rPdu, false);
679 TeleserviceDeliverAck deliverAck;
680 CdmaSmsDeliveryAck ack(deliverAck, rPdu);
681 EXPECT_NE(ack.type_, CdmaSmsTeleserviceMessage::DELIVERY_ACK);
682 TeleserviceUserAck userAck;
683 CdmaSmsUserAck smsUserAck(userAck, rPdu);
684 EXPECT_NE(smsUserAck.type_, CdmaSmsTeleserviceMessage::USER_ACK);
685 TeleserviceReadAck readAck;
686 CdmaSmsReadAck smsReadAck(readAck, rPdu);
687 EXPECT_NE(smsReadAck.type_, CdmaSmsTeleserviceMessage::READ_ACK);
688 SmsReadBuffer rPdu2("001020304050");
689 CdmaSmsDeliveryAck ack2(deliverAck, rPdu2);
690 EXPECT_EQ(ack2.type_, CdmaSmsTeleserviceMessage::DELIVERY_ACK);
691 SmsReadBuffer rPdu3("001020304050");
692 CdmaSmsUserAck smsUserAck2(userAck, rPdu3);
693 EXPECT_EQ(smsUserAck2.type_, CdmaSmsTeleserviceMessage::USER_ACK);
694 SmsReadBuffer rPdu4("001020304050");
695 CdmaSmsReadAck smsReadAck2(readAck, rPdu4);
696 EXPECT_EQ(smsReadAck2.type_, CdmaSmsTeleserviceMessage::READ_ACK);
697 SmsReadBuffer rPdu5("1");
698 EXPECT_EQ(msg.GetMessageType(rPdu5), CdmaSmsTeleserviceMessage::RESERVED);
699 SmsReadBuffer rPdu6("10");
700 EXPECT_EQ(msg.GetMessageType(rPdu6), CdmaSmsTeleserviceMessage::RESERVED);
701 }
702
703 /**
704 * @tc.number Telephony_CdmaSmsGtest_CdmaSmsSubParameter_0001
705 * @tc.name Test CdmaSmsSubParameter
706 * @tc.desc Function test
707 */
708 HWTEST_F(CdmaSmsGtest, CdmaSmsSubParameter_0001, Function | MediumTest | Level1)
709 {
710 uint8_t data;
711 CdmaSmsBaseParameter param(0, data);
712 SmsReadBuffer rPdu("1");
713 EXPECT_FALSE(param.Decode(rPdu));
714 SmsReadBuffer rPdu2("11");
715 EXPECT_FALSE(param.Decode(rPdu2));
716 SmsTimeAbs timeAbs;
717 uint8_t id = static_cast<uint8_t>('0');
718 CdmaSmsAbsoluteTime time(id, timeAbs);
719 SmsReadBuffer rPdu3("00");
720 EXPECT_FALSE(time.Decode(rPdu3));
721 SmsReadBuffer rPdu4("001");
722 EXPECT_FALSE(time.Decode(rPdu4));
723 SmsReadBuffer rPdu5("0011");
724 EXPECT_FALSE(time.Decode(rPdu5));
725 SmsReadBuffer rPdu6("00111");
726 EXPECT_FALSE(time.Decode(rPdu6));
727 SmsReadBuffer rPdu7("001111");
728 EXPECT_FALSE(time.Decode(rPdu7));
729 SmsReadBuffer rPdu8("0011111");
730 EXPECT_FALSE(time.Decode(rPdu8));
731 SmsReadBuffer rPdu9("00111111");
732 EXPECT_TRUE(time.Decode(rPdu9));
733 }
734
735 /**
736 * @tc.number Telephony_CdmaSmsGtest_CdmaSmsSubParameter_0002
737 * @tc.name Test CdmaSmsSubParameter
738 * @tc.desc Function test
739 */
740 HWTEST_F(CdmaSmsGtest, CdmaSmsSubParameter_0002, Function | MediumTest | Level1)
741 {
742 SmsTimeAbs timeAbs;
743 uint8_t id = static_cast<uint8_t>('0');
744 CdmaSmsAbsoluteTime time(id, timeAbs);
745 SmsWriteBuffer wPdu;
746 wPdu.length_ = 0;
747 EXPECT_FALSE(time.Encode(wPdu));
748 wPdu.length_ = 1;
749 EXPECT_FALSE(time.Encode(wPdu));
750 wPdu.index_ = 0;
751 wPdu.length_ = 2;
752 EXPECT_FALSE(time.Encode(wPdu));
753 wPdu.index_ = 0;
754 wPdu.length_ = 3;
755 EXPECT_FALSE(time.Encode(wPdu));
756 wPdu.index_ = 0;
757 wPdu.length_ = 4;
758 EXPECT_FALSE(time.Encode(wPdu));
759 wPdu.index_ = 0;
760 wPdu.length_ = 5;
761 EXPECT_FALSE(time.Encode(wPdu));
762 wPdu.index_ = 0;
763 wPdu.length_ = 6;
764 EXPECT_FALSE(time.Encode(wPdu));
765 wPdu.index_ = 0;
766 wPdu.length_ = 7;
767 EXPECT_FALSE(time.Encode(wPdu));
768 wPdu.index_ = 0;
769 wPdu.length_ = 8;
770 EXPECT_TRUE(time.Encode(wPdu));
771 }
772
773 /**
774 * @tc.number Telephony_CdmaSmsGtest_CdmaSmsSubParameter_0003
775 * @tc.name Test CdmaSmsSubParameter
776 * @tc.desc Function test
777 */
778 HWTEST_F(CdmaSmsGtest, CdmaSmsSubParameter_0003, Function | MediumTest | Level1)
779 {
780 uint8_t id = static_cast<uint8_t>('0');
781 SmsTeleSvcMsgId value;
782 CdmaSmsMessageId message(value, CdmaSmsTeleserviceMessage::DELIVER);
783 message.id_ = id;
784 SmsReadBuffer rPdu("00");
785 EXPECT_FALSE(message.Decode(rPdu));
786 SmsReadBuffer rPdu1("001");
787 EXPECT_FALSE(message.Decode(rPdu1));
788 SmsReadBuffer rPdu2("0011");
789 EXPECT_FALSE(message.Decode(rPdu2));
790 SmsReadBuffer rPdu4("001111");
791 EXPECT_TRUE(message.Decode(rPdu4));
792
793 SmsWriteBuffer wPdu;
794 wPdu.length_ = 0;
795 EXPECT_FALSE(message.Encode(wPdu));
796 wPdu.length_ = 1;
797 EXPECT_FALSE(message.Encode(wPdu));
798 wPdu.index_ = 0;
799 wPdu.length_ = 2;
800 EXPECT_FALSE(message.Encode(wPdu));
801 wPdu.index_ = 0;
802 wPdu.length_ = 3;
803 EXPECT_FALSE(message.Encode(wPdu));
804 wPdu.index_ = 0;
805 wPdu.length_ = 4;
806 EXPECT_FALSE(message.Encode(wPdu));
807 wPdu.index_ = 0;
808 wPdu.length_ = 5;
809 EXPECT_TRUE(message.Encode(wPdu));
810 }
811
812 /**
813 * @tc.number Telephony_CdmaSmsGtest_CdmaSmsSubParameter_0004
814 * @tc.name Test CdmaSmsSubParameter
815 * @tc.desc Function test
816 */
817 HWTEST_F(CdmaSmsGtest, CdmaSmsSubParameter_0004, Function | MediumTest | Level1)
818 {
819 uint8_t id = static_cast<uint8_t>('0');
820 SmsPrivacyIndicator value;
821 CdmaSmsPrivacyInd parameter(value);
822 parameter.id_ = id;
823 SmsReadBuffer rPdu("00");
824 EXPECT_FALSE(parameter.Decode(rPdu));
825 SmsReadBuffer rPdu1("001");
826 EXPECT_TRUE(parameter.Decode(rPdu1));
827
828 SmsWriteBuffer wPdu;
829 wPdu.length_ = 0;
830 EXPECT_FALSE(parameter.Encode(wPdu));
831 wPdu.length_ = 1;
832 EXPECT_FALSE(parameter.Encode(wPdu));
833 wPdu.index_ = 0;
834 wPdu.length_ = 2;
835 EXPECT_FALSE(parameter.Encode(wPdu));
836 wPdu.index_ = 0;
837 wPdu.length_ = 3;
838 EXPECT_TRUE(parameter.Encode(wPdu));
839
840 SmsReplyOption op;
841 CdmaSmsReplyOption option(op);
842 option.id_ = id;
843 SmsReadBuffer rPdu2("00");
844 EXPECT_FALSE(option.Decode(rPdu2));
845
846 wPdu.index_ = 0;
847 wPdu.length_ = 0;
848 EXPECT_FALSE(option.Encode(wPdu));
849 wPdu.length_ = 1;
850 EXPECT_FALSE(option.Encode(wPdu));
851 wPdu.index_ = 0;
852 wPdu.length_ = 2;
853 EXPECT_FALSE(option.Encode(wPdu));
854 wPdu.index_ = 0;
855 wPdu.length_ = 3;
856 EXPECT_TRUE(option.Encode(wPdu));
857 }
858
859 /**
860 * @tc.number Telephony_CdmaSmsGtest_CdmaSmsSubParameter_0005
861 * @tc.name Test CdmaSmsSubParameter
862 * @tc.desc Function test
863 */
864 HWTEST_F(CdmaSmsGtest, CdmaSmsSubParameter_0005, Function | MediumTest | Level1)
865 {
866 uint8_t id = static_cast<uint8_t>('0');
867 SmsTeleSvcUserData value;
868 bool headerInd = false;
869 CdmaSmsUserData parameter(value, headerInd);
870 parameter.id_ = id;
871 SmsReadBuffer rPdu("00");
872 EXPECT_FALSE(parameter.Decode(rPdu));
873 SmsReadBuffer rPdu1("00" + std::string(1, static_cast<char>(static_cast<uint8_t>(SmsEncodingType::EPM) << 3)));
874 EXPECT_FALSE(parameter.Decode(rPdu1));
875 SmsReadBuffer rPdu2("00" +
876 std::string(1, static_cast<char>(static_cast<uint8_t>(SmsEncodingType::GSMDCS) << 3)) + "1");
877 EXPECT_FALSE(parameter.Decode(rPdu2));
878 SmsReadBuffer rPdu3("00" +
879 std::string(1, static_cast<char>(static_cast<uint8_t>(SmsEncodingType::UNICODE) << 3)) + "1");
880 EXPECT_FALSE(parameter.Decode(rPdu3));
881 SmsReadBuffer rPdu4("00" +
882 std::string(1, static_cast<char>(static_cast<uint8_t>(SmsEncodingType::GSMDCS) << 3)) + "11");
883 EXPECT_FALSE(parameter.Decode(rPdu4));
884 SmsReadBuffer rPdu5("00" +
885 std::string(1, static_cast<char>(static_cast<uint8_t>(SmsEncodingType::LATIN) << 3)) + "1");
886 EXPECT_FALSE(parameter.Decode(rPdu5));
887
888 SmsReadBuffer rPdu6("");
889 parameter.headerInd_ = true;
890 EXPECT_EQ(parameter.DecodeHeader7Bit(rPdu6), 0);
891 SmsReadBuffer rPdu7("0");
892 EXPECT_EQ(parameter.DecodeHeader7Bit(rPdu7), 0);
893 SmsReadBuffer rPdu8("01");
894 EXPECT_EQ(parameter.DecodeHeader7Bit(rPdu8), 0);
895 }
896
897 /**
898 * @tc.number Telephony_CdmaSmsGtest_CdmaSmsSubParameter_0006
899 * @tc.name Test CdmaSmsSubParameter
900 * @tc.desc Function test
901 */
902 HWTEST_F(CdmaSmsGtest, CdmaSmsSubParameter_0006, Function | MediumTest | Level1)
903 {
904 SmsTeleSvcCmasData value;
905 CdmaSmsCmasData parameter(value);
906 uint8_t id = static_cast<uint8_t>('0');
907 parameter.id_ = id;
908 SmsReadBuffer rPdu("00");
909 EXPECT_FALSE(parameter.Decode(rPdu));
910 SmsReadBuffer rPdu1("00" +
911 std::string(1, static_cast<char>(static_cast<uint8_t>(SmsEncodingType::EUCKR) << 3)));
912 EXPECT_FALSE(parameter.Decode(rPdu1));
913 SmsReadBuffer rPdu2("00" +
914 std::string(1, static_cast<char>((static_cast<uint8_t>(SmsEncodingType::OCTET) << 3) + 1)));
915 EXPECT_FALSE(parameter.Decode(rPdu2));
916 SmsReadBuffer rPdu3("00" +
917 std::string(1, static_cast<char>((static_cast<uint8_t>(SmsEncodingType::OCTET) << 3) + 1)) + "1");
918 EXPECT_FALSE(parameter.Decode(rPdu3));
919 SmsReadBuffer rPdu4("00" +
920 std::string(1, static_cast<char>((static_cast<uint8_t>(SmsEncodingType::OCTET) << 3) + 1)) + "11");
921 EXPECT_FALSE(parameter.Decode(rPdu4));
922 SmsReadBuffer rPdu5(std::string(1, static_cast<char>(0)) + "1");
923 EXPECT_FALSE(parameter.DecodeData(rPdu5));
924 SmsReadBuffer rPdu6(std::string(1, static_cast<char>(1)) + "1");
925 EXPECT_FALSE(parameter.DecodeData(rPdu6));
926 SmsReadBuffer rPdu7(std::string(1, static_cast<char>(1)) + "11");
927 EXPECT_FALSE(parameter.DecodeData(rPdu7));
928 SmsReadBuffer rPdu8(std::string(1, static_cast<char>(1)) + "111");
929 EXPECT_FALSE(parameter.DecodeData(rPdu8));
930 SmsReadBuffer rPdu9(std::string(1, static_cast<char>(2)) + "1");
931 EXPECT_FALSE(parameter.DecodeData(rPdu9));
932 SmsReadBuffer rPdu10(std::string(1, static_cast<char>(2)) + "11");
933 EXPECT_FALSE(parameter.DecodeData(rPdu10));
934 SmsReadBuffer rPdu11(std::string(1, static_cast<char>(2)) + "111");
935 EXPECT_FALSE(parameter.DecodeData(rPdu11));
936 SmsReadBuffer rPdu12(std::string(1, static_cast<char>(2)) + "1111");
937 EXPECT_FALSE(parameter.DecodeData(rPdu12));
938 SmsReadBuffer rPdu13(std::string(1, static_cast<char>(2)) + "11111");
939 EXPECT_FALSE(parameter.DecodeData(rPdu13));
940 SmsReadBuffer rPdu14(std::string(1, static_cast<char>(2)) + "111111");
941 EXPECT_FALSE(parameter.DecodeData(rPdu14));
942 SmsReadBuffer rPdu15(std::string(1, static_cast<char>(2)) + "1111111");
943 EXPECT_FALSE(parameter.DecodeData(rPdu15));
944 SmsReadBuffer rPdu16(std::string(1, static_cast<char>(2)) + "11111111");
945 EXPECT_FALSE(parameter.DecodeData(rPdu16));
946 }
947
948 /**
949 * @tc.number Telephony_CdmaSmsGtest_CdmaSmsSubParameter_0007
950 * @tc.name Test CdmaSmsSubParameter
951 * @tc.desc Function test
952 */
953 HWTEST_F(CdmaSmsGtest, CdmaSmsSubParameter_0007, Function | MediumTest | Level1)
954 {
955 uint8_t id = static_cast<uint8_t>('0');
956 SmsDisplayMode mode;
957 CdmaSmsDisplayMode parameter(mode);
958 parameter.id_ = id;
959 SmsReadBuffer rPdu("00");
960 EXPECT_FALSE(parameter.Decode(rPdu));
961
962 SmsStatusCode code;
963 CdmaSmsMessageStatus status(code);
964 status.id_ = id;
965 SmsReadBuffer rPdu1("00");
966 EXPECT_FALSE(status.Decode(rPdu1));
967
968 uint32_t value = 0;
969 CdmaSmsNumberMessages messages(value);
970 messages.id_ = id;
971 SmsReadBuffer rPdu2("00");
972 EXPECT_FALSE(messages.Decode(rPdu2));
973
974 SmsAlertPriority p = SmsAlertPriority::HIGH;
975 CdmaSmsAlertPriority priority(p);
976 priority.id_ = id;
977 SmsReadBuffer rPdu3("00");
978 EXPECT_FALSE(priority.Decode(rPdu3));
979
980 SmsLanguageType l = SmsLanguageType::CHINESE;
981 CdmaSmsLanguageInd ind(l);
982 ind.id_ = id;
983 SmsReadBuffer rPdu4("00");
984 EXPECT_FALSE(ind.Decode(rPdu4));
985
986 SmsTeleSvcAddr addr;
987 CdmaSmsCallbackNumber number(addr);
988 number.id_ = id;
989 SmsReadBuffer rPdu5("00");
990 EXPECT_FALSE(number.Decode(rPdu5));
991 SmsReadBuffer rPdu6("00" + std::string(1, static_cast<char>(0b1 << 7)));
992 EXPECT_FALSE(number.Decode(rPdu6));
993 SmsReadBuffer rPdu7("00" + std::string(1, static_cast<char>(0b1 << 7)) + "11");
994 EXPECT_FALSE(number.Decode(rPdu7));
995 SmsReadBuffer rPdu8("0011");
996 EXPECT_FALSE(number.Decode(rPdu8));
997 }
998
999 /**
1000 * @tc.number Telephony_CdmaSmsGtest_CdmaSmsSubParameter_0008
1001 * @tc.name Test CdmaSmsSubParameter
1002 * @tc.desc Function test
1003 */
1004 HWTEST_F(CdmaSmsGtest, CdmaSmsSubParameter_0008, Function | MediumTest | Level1)
1005 {
1006 SmsEnhancedVmn value;
1007 CdmaSmsEnhancedVmn parameter(value);
1008 uint8_t id = static_cast<uint8_t>('0');
1009 parameter.id_ = id;
1010 SmsReadBuffer rPdu("00");
1011 EXPECT_FALSE(parameter.Decode(rPdu));
1012 SmsReadBuffer rPdu1("001");
1013 EXPECT_FALSE(parameter.Decode(rPdu1));
1014 SmsReadBuffer rPdu2("0011");
1015 EXPECT_FALSE(parameter.Decode(rPdu2));
1016 SmsReadBuffer rPdu3("00111");
1017 EXPECT_FALSE(parameter.Decode(rPdu3));
1018 SmsReadBuffer rPdu4("001111");
1019 EXPECT_FALSE(parameter.Decode(rPdu4));
1020 SmsReadBuffer rPdu5("0011111");
1021 EXPECT_FALSE(parameter.Decode(rPdu5));
1022 SmsReadBuffer rPdu6("00111111");
1023 EXPECT_FALSE(parameter.Decode(rPdu6));
1024 SmsReadBuffer rPdu7("001111111");
1025 EXPECT_FALSE(parameter.Decode(rPdu7));
1026 SmsReadBuffer rPdu8("0011111111");
1027 EXPECT_FALSE(parameter.Decode(rPdu8));
1028 SmsReadBuffer rPdu9("00111111111");
1029 EXPECT_FALSE(parameter.Decode(rPdu9));
1030 SmsReadBuffer rPdu10("001111111111");
1031 EXPECT_FALSE(parameter.Decode(rPdu10));
1032 SmsReadBuffer rPdu11("0011111111111");
1033 EXPECT_FALSE(parameter.Decode(rPdu11));
1034 SmsReadBuffer rPdu12("00111111111111");
1035 EXPECT_FALSE(parameter.Decode(rPdu12));
1036 SmsReadBuffer rPdu13("001111111111111");
1037 EXPECT_FALSE(parameter.Decode(rPdu13));
1038 SmsReadBuffer rPdu14("0011111111111111");
1039 EXPECT_FALSE(parameter.Decode(rPdu14));
1040
1041 SmsReadBuffer rPdu15("");
1042 EXPECT_FALSE(parameter.DecodeCallingPartyNumber(rPdu15));
1043 SmsReadBuffer rPdu16("0");
1044 EXPECT_FALSE(parameter.DecodeCallingPartyNumber(rPdu16));
1045 SmsReadBuffer rPdu17("01");
1046 EXPECT_FALSE(parameter.DecodeCallingPartyNumber(rPdu17));
1047 SmsReadBuffer rPdu18("011");
1048 EXPECT_FALSE(parameter.DecodeCallingPartyNumber(rPdu18));
1049 }
1050
1051 /**
1052 * @tc.number Telephony_CdmaSmsGtest_CdmaSmsSubParameter_0009
1053 * @tc.name Test CdmaSmsSubParameter
1054 * @tc.desc Function test
1055 */
1056 HWTEST_F(CdmaSmsGtest, CdmaSmsSubParameter_0009, Function | MediumTest | Level1)
1057 {
1058 SmsEnhancedVmnAck value;
1059 CdmaSmsEnhancedVmnAck parameter(value);
1060 uint8_t id = static_cast<uint8_t>('0');
1061 parameter.id_ = id;
1062 SmsReadBuffer rPdu("00");
1063 EXPECT_FALSE(parameter.Decode(rPdu));
1064 SmsReadBuffer rPdu1("001");
1065 EXPECT_FALSE(parameter.Decode(rPdu1));
1066 SmsReadBuffer rPdu2("0011");
1067 EXPECT_FALSE(parameter.Decode(rPdu2));
1068 SmsReadBuffer rPdu3("00111");
1069 EXPECT_FALSE(parameter.Decode(rPdu3));
1070 SmsReadBuffer rPdu4("001111");
1071 EXPECT_FALSE(parameter.Decode(rPdu4));
1072 SmsReadBuffer rPdu5("0011111");
1073 EXPECT_FALSE(parameter.Decode(rPdu5));
1074 SmsReadBuffer rPdu6("00111111");
1075 EXPECT_FALSE(parameter.Decode(rPdu6));
1076 SmsReadBuffer rPdu7("001111111");
1077 EXPECT_FALSE(parameter.Decode(rPdu7));
1078 SmsReadBuffer rPdu8("0011111111");
1079 EXPECT_FALSE(parameter.Decode(rPdu8));
1080 SmsReadBuffer rPdu9("00111111111");
1081 EXPECT_FALSE(parameter.Decode(rPdu9));
1082 }
1083
1084 /**
1085 * @tc.number Telephony_CdmaSmsGtest_CdmaSmsParameterRecord_0001
1086 * @tc.name Test CdmaSmsParameterRecord
1087 * @tc.desc Function test
1088 */
1089 HWTEST_F(CdmaSmsGtest, CdmaSmsParameterRecord_0001, Function | MediumTest | Level1)
1090 {
1091 uint16_t value = 0;
1092 CdmaSmsTeleserviceId parameter(value);
1093 SmsWriteBuffer wPdu;
1094 wPdu.length_ = 0;
1095 EXPECT_FALSE(parameter.Encode(wPdu));
1096 wPdu.length_ = 1;
1097 EXPECT_FALSE(parameter.Encode(wPdu));
1098 wPdu.index_ = 0;
1099 wPdu.length_ = 2;
1100 EXPECT_FALSE(parameter.Encode(wPdu));
1101 wPdu.index_ = 0;
1102 wPdu.length_ = 3;
1103 EXPECT_FALSE(parameter.Encode(wPdu));
1104 wPdu.index_ = 0;
1105 wPdu.length_ = 4;
1106 EXPECT_TRUE(parameter.Encode(wPdu));
1107
1108 CdmaSmsServiceCategory cat(value);
1109 wPdu.length_ = 0;
1110 EXPECT_FALSE(cat.Encode(wPdu));
1111 wPdu.index_ = 0;
1112 wPdu.length_ = 1;
1113 EXPECT_FALSE(cat.Encode(wPdu));
1114 wPdu.index_ = 0;
1115 wPdu.length_ = 2;
1116 EXPECT_FALSE(cat.Encode(wPdu));
1117 wPdu.index_ = 0;
1118 wPdu.length_ = 3;
1119 EXPECT_FALSE(cat.Encode(wPdu));
1120 wPdu.index_ = 0;
1121 wPdu.length_ = 4;
1122 EXPECT_TRUE(cat.Encode(wPdu));
1123
1124 uint8_t r = 0;
1125 CdmaSmsBearerReply reply(r);
1126 wPdu.length_ = 0;
1127 EXPECT_FALSE(reply.Encode(wPdu));
1128 wPdu.index_ = 0;
1129 wPdu.length_ = 1;
1130 EXPECT_FALSE(reply.Encode(wPdu));
1131 wPdu.index_ = 0;
1132 wPdu.length_ = 2;
1133 EXPECT_FALSE(reply.Encode(wPdu));
1134 wPdu.index_ = 0;
1135 wPdu.length_ = 3;
1136 EXPECT_TRUE(reply.Encode(wPdu));
1137 reply.id_ = static_cast<uint8_t>('0');
1138 SmsReadBuffer rPdu("00");
1139 EXPECT_FALSE(reply.Decode(rPdu));
1140 }
1141
1142 /**
1143 * @tc.number Telephony_CdmaSmsGtest_CdmaSmsParameterRecord_0002
1144 * @tc.name Test CdmaSmsParameterRecord
1145 * @tc.desc Function test
1146 */
1147 HWTEST_F(CdmaSmsGtest, CdmaSmsParameterRecord_0002, Function | MediumTest | Level1)
1148 {
1149 TransportCauseCode value;
1150 CdmaSmsCauseCodes codes(value);
1151 SmsWriteBuffer wPdu;
1152 wPdu.length_ = 0;
1153 EXPECT_FALSE(codes.Encode(wPdu));
1154 uint8_t id = static_cast<uint8_t>('0');
1155 codes.id_ = id;
1156 SmsReadBuffer rPdu("00");
1157 EXPECT_FALSE(codes.Decode(rPdu));
1158 SmsReadBuffer rPdu1("001");
1159 EXPECT_TRUE(codes.Decode(rPdu1));
1160
1161 TransportAddr addr;
1162 CdmaSmsAddressParameter parameter(addr, CdmaSmsParameterRecord::ORG_ADDRESS);
1163 EXPECT_FALSE(parameter.Encode(wPdu));
1164 parameter.id_ = id;
1165 parameter.isInvalid_ = false;
1166 SmsReadBuffer rPdu2("00");
1167 EXPECT_FALSE(parameter.Decode(rPdu2));
1168
1169 TransportSubAddr subAddr;
1170 CdmaSmsSubaddress subAddress(subAddr, CdmaSmsParameterRecord::ORG_SUB_ADDRESS);
1171 EXPECT_FALSE(subAddress.Encode(wPdu));
1172 subAddress.id_ = id;
1173 subAddress.isInvalid_ = false;
1174 SmsReadBuffer rPdu3("00");
1175 EXPECT_FALSE(subAddress.Decode(rPdu3));
1176 SmsReadBuffer rPdu4("001");
1177 EXPECT_FALSE(subAddress.Decode(rPdu4));
1178 }
1179 #endif // TEL_TEST_UNSUPPORT
1180 } // namespace Telephony
1181 } // namespace OHOS