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_transport_message.h"
21 #include "core_service_client.h"
22 #include "gtest/gtest.h"
23 #include "i_sms_service_interface.h"
24 #include "if_system_ability_manager.h"
25 #include "iservice_registry.h"
26 #include "radio_event.h"
27 #include "sms_mms_gtest.h"
28 #include "sms_mms_test_helper.h"
29 #include "sms_service.h"
30 #include "sms_service_manager_client.h"
31 #include "string_utils.h"
32 #include "telephony_log_wrapper.h"
33 
34 namespace OHOS {
35 namespace Telephony {
36 namespace {
37 sptr<ISmsServiceInterface> g_telephonyService = nullptr;
38 } // namespace
39 using namespace testing::ext;
40 
41 class CdmaSmsGtest : public testing::Test {
42 public:
43     static void SetUpTestCase();
44     static void TearDownTestCase();
45     void SetUp();
46     void TearDown();
47     static sptr<ISmsServiceInterface> GetProxy();
HasSimCard(int32_t slotId)48     static bool HasSimCard(int32_t slotId)
49     {
50         bool hasSimCard = false;
51         if (CoreServiceClient::GetInstance().GetProxy() == nullptr) {
52             return hasSimCard;
53         }
54         CoreServiceClient::GetInstance().HasSimCard(slotId, hasSimCard);
55         return hasSimCard;
56     }
57 };
58 
TearDownTestCase()59 void CdmaSmsGtest::TearDownTestCase() {}
60 
SetUp()61 void CdmaSmsGtest::SetUp() {}
62 
TearDown()63 void CdmaSmsGtest::TearDown() {}
64 
65 const int32_t DEFAULT_SIM_SLOT_ID_1 = 1;
66 const uint8_t HEX_CHAR_LEN = 2;
67 const uint8_t UNICODE_CHAR_LEN = 2;
68 const uint8_t VALUE_INDEX = 2;
69 const char *CDMA_PDU = "01010101";
70 const char *OTHER_CDMA_PDU = "111111";
71 
SetUpTestCase()72 void CdmaSmsGtest::SetUpTestCase()
73 {
74     TELEPHONY_LOGI("SetUpTestCase slotId%{public}d", DEFAULT_SIM_SLOT_ID_1);
75     g_telephonyService = GetProxy();
76     if (g_telephonyService == nullptr) {
77         return;
78     }
79     DelayedSingleton<SmsServiceManagerClient>::GetInstance()->ResetSmsServiceProxy();
80     DelayedSingleton<SmsServiceManagerClient>::GetInstance()->InitSmsServiceProxy();
81 }
82 
GetProxy()83 sptr<ISmsServiceInterface> CdmaSmsGtest::GetProxy()
84 {
85     auto systemAbilityMgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
86     if (systemAbilityMgr == nullptr) {
87         return nullptr;
88     }
89     sptr<IRemoteObject> remote = systemAbilityMgr->CheckSystemAbility(TELEPHONY_SMS_MMS_SYS_ABILITY_ID);
90     if (remote) {
91         sptr<ISmsServiceInterface> smsService = iface_cast<ISmsServiceInterface>(remote);
92         return smsService;
93     }
94     return nullptr;
95 }
96 
97 #ifndef TEL_TEST_UNSUPPORT
98 /**
99  * @tc.number   Telephony_SmsMmsGtest_CdmaSmsMessage_0001
100  * @tc.name     Test CdmaSmsMessage
101  * @tc.desc     Function test
102  */
103 HWTEST_F(CdmaSmsGtest, CdmaSmsMessage_0001, Function | MediumTest | Level1)
104 {
105     TELEPHONY_LOGI("TelSMSMMSTest::CdmaSmsMessage_0001 -->");
106     CdmaSmsMessage cdmaSmsMessage;
107     std::string dest = "dest";
108     std::string sc = "sc";
109     std::string text = "text";
110     int32_t port = 10;
111     uint8_t *data;
112     uint32_t dataLen = 10;
113     std::string pdu = "01000B818176251308F4000007E8B0BCFD76E701";
114     bool bStatusReport = false;
115     DataCodingScheme codingScheme = DATA_CODING_7BIT;
116     cdmaSmsMessage.CreateSubmitTransMsg(dest, sc, text, bStatusReport, codingScheme);
117     cdmaSmsMessage.CreateSubmitTransMsg(dest, sc, port, data, dataLen, bStatusReport);
118     cdmaSmsMessage.GreateTransMsg();
119     cdmaSmsMessage.CovertEncodingType(codingScheme);
120     cdmaSmsMessage.CreateMessage(pdu);
121     cdmaSmsMessage.PduAnalysis(pdu);
122     CdmaP2PMsg p2pMsg;
123     cdmaSmsMessage.AnalysisP2pMsg(p2pMsg);
124     cdmaSmsMessage.AnalsisDeliverMwi(p2pMsg);
125     bool ret = cdmaSmsMessage.PduAnalysis("");
126     EXPECT_EQ(false, ret);
127 }
128 
129 /**
130  * @tc.number   Telephony_SmsMmsGtest_CdmaSmsReceiveHandler_0001
131  * @tc.name     Test CdmaSmsReceiveHandler
132  * @tc.desc     Function test
133  */
134 HWTEST_F(CdmaSmsGtest, CdmaSmsReceiveHandler_0001, Function | MediumTest | Level1)
135 {
136     TELEPHONY_LOGI("TelSMSMMSTest::CdmaSmsReceiveHandler_0001 -->");
137     auto smsReceiveManager = std::make_shared<SmsReceiveManager>(DEFAULT_SIM_SLOT_ID);
138     EXPECT_TRUE(smsReceiveManager != nullptr);
139     smsReceiveManager->Init();
140     EXPECT_TRUE(smsReceiveManager->cdmaSmsReceiveHandler_ != nullptr);
141     int32_t retInt = smsReceiveManager->cdmaSmsReceiveHandler_->HandleSmsByType(nullptr);
142     EXPECT_EQ(AckIncomeCause::SMS_ACK_UNKNOWN_ERROR, retInt);
143 }
144 
145 /**
146  * @tc.number   Telephony_SmsMmsGtest_CdmaSmsReceiveHandler_0002
147  * @tc.name     Test CdmaSmsReceiveHandler
148  * @tc.desc     Function test
149  */
150 HWTEST_F(CdmaSmsGtest, CdmaSmsReceiveHandler_0002, Function | MediumTest | Level1)
151 {
152     TELEPHONY_LOGI("TelSMSMMSTest::CdmaSmsReceiveHandler_0002 -->");
153     auto smsReceiveManager = std::make_shared<SmsReceiveManager>(DEFAULT_SIM_SLOT_ID);
154     EXPECT_TRUE(smsReceiveManager != nullptr);
155     smsReceiveManager->Init();
156     EXPECT_TRUE(smsReceiveManager->cdmaSmsReceiveHandler_ != nullptr);
157     auto retMsg = std::make_shared<CdmaSmsMessage>();
158     retMsg = CdmaSmsMessage::CreateMessage(CDMA_PDU);
159     EXPECT_EQ(retMsg, nullptr);
160     auto cdmaMsg = std::make_shared<CdmaSmsMessage>();
161     cdmaMsg->transMsg_ = std::make_unique<struct CdmaTransportMsg>();
162     cdmaMsg->transMsg_->type = CdmaTransportMsgType::BROADCAST;
163     int32_t retInt = smsReceiveManager->cdmaSmsReceiveHandler_->HandleSmsByType(cdmaMsg);
164     EXPECT_EQ(AckIncomeCause::SMS_ACK_RESULT_OK, retInt);
165     cdmaMsg->transMsg_->type = CdmaTransportMsgType::P2P;
166     retInt = smsReceiveManager->cdmaSmsReceiveHandler_->HandleSmsByType(cdmaMsg);
167     EXPECT_EQ(AckIncomeCause::SMS_ACK_RESULT_OK, retInt);
168     cdmaMsg->transMsg_->type = CdmaTransportMsgType::ACK;
169     retInt = smsReceiveManager->cdmaSmsReceiveHandler_->HandleSmsByType(cdmaMsg);
170     EXPECT_EQ(AckIncomeCause::SMS_ACK_RESULT_OK, retInt);
171     cdmaMsg->transMsg_->type = CdmaTransportMsgType::RESERVED;
172     retInt = smsReceiveManager->cdmaSmsReceiveHandler_->HandleSmsByType(cdmaMsg);
173     EXPECT_EQ(AckIncomeCause::SMS_ACK_RESULT_OK, retInt);
174 }
175 
176 /**
177  * @tc.number   Telephony_SmsMmsGtest_CdmaSmsReceiveHandler_0003
178  * @tc.name     Test CdmaSmsReceiveHandler
179  * @tc.desc     Function test
180  */
181 HWTEST_F(CdmaSmsGtest, CdmaSmsReceiveHandler_0003, Function | MediumTest | Level1)
182 {
183     TELEPHONY_LOGI("TelSMSMMSTest::CdmaSmsReceiveHandler_0003 -->");
184     auto smsReceiveManager = std::make_shared<SmsReceiveManager>(DEFAULT_SIM_SLOT_ID);
185     EXPECT_TRUE(smsReceiveManager != nullptr);
186     smsReceiveManager->Init();
187     EXPECT_TRUE(smsReceiveManager->cdmaSmsReceiveHandler_ != nullptr);
188     int32_t retInt = smsReceiveManager->cdmaSmsReceiveHandler_->HandleSmsOtherSvcid(nullptr);
189     EXPECT_NE(AckIncomeCause::SMS_ACK_RESULT_OK, retInt);
190     auto retMsg = CdmaSmsMessage::CreateMessage(OTHER_CDMA_PDU);
191     EXPECT_EQ(retMsg, nullptr);
192 
193     auto cdmaMsg = std::make_shared<CdmaSmsMessage>();
194     smsReceiveManager->cdmaSmsReceiveHandler_->ReplySmsToSmsc(1);
195     retInt = smsReceiveManager->cdmaSmsReceiveHandler_->HandleSmsOtherSvcid(cdmaMsg);
196     EXPECT_NE(AckIncomeCause::SMS_ACK_RESULT_OK, retInt);
197     cdmaMsg->smsConcat_ = std::make_shared<SmsConcat>();
198     cdmaMsg->smsConcat_->is8Bits = true;
199     cdmaMsg->smsConcat_->msgRef = 1;
200     cdmaMsg->smsConcat_->seqNum = 1;
201     cdmaMsg->smsConcat_->totalSeg = 1;
202     retInt = smsReceiveManager->cdmaSmsReceiveHandler_->HandleSmsOtherSvcid(cdmaMsg);
203     EXPECT_NE(AckIncomeCause::SMS_ACK_RESULT_OK, retInt);
204 }
205 
206 /**
207  * @tc.number   Telephony_SmsMmsGtest_CdmaSmsReceiveHandler_0004
208  * @tc.name     Test CdmaSmsReceiveHandler
209  * @tc.desc     Function test
210  */
211 HWTEST_F(CdmaSmsGtest, CdmaSmsReceiveHandler_0004, Function | MediumTest | Level1)
212 {
213     TELEPHONY_LOGI("TelSMSMMSTest::CdmaSmsReceiveHandler_0004 -->");
214     auto smsReceiveManager = std::make_shared<SmsReceiveManager>(DEFAULT_SIM_SLOT_ID);
215     EXPECT_TRUE(smsReceiveManager != nullptr);
216     smsReceiveManager->Init();
217     EXPECT_TRUE(smsReceiveManager->cdmaSmsReceiveHandler_ != nullptr);
218     std::function<void(std::shared_ptr<SmsSendIndexer>)> fun = nullptr;
219     auto smsSender = std::make_shared<CdmaSmsSender>(DEFAULT_SIM_SLOT_ID, fun);
220     smsReceiveManager->cdmaSmsReceiveHandler_->SetCdmaSender(smsSender);
221     auto info = std::make_shared<SmsMessageInfo>();
222     auto ret = smsReceiveManager->cdmaSmsReceiveHandler_->TransformMessageInfo(info);
223     EXPECT_EQ(ret, nullptr);
224     smsReceiveManager->cdmaSmsReceiveHandler_->SendCBBroadcast(nullptr);
225     auto cdmaMsg = std::make_shared<CdmaSmsMessage>();
226     EXPECT_EQ(smsReceiveManager->cdmaSmsReceiveHandler_->SendCBBroadcast(cdmaMsg), true);
227 }
228 
229 /**
230  * @tc.number   Telephony_CdmaSmsGtest_SmsPduBuffer_0001
231  * @tc.name     Test SmsPduBuffer
232  * @tc.desc     Function test
233  */
234 HWTEST_F(CdmaSmsGtest, SmsPduBuffer_0001, Function | MediumTest | Level1)
235 {
236     auto buffer = std::make_shared<SmsPduBuffer>();
237     EXPECT_TRUE(buffer->IsEmpty());
238     EXPECT_EQ(buffer->GetIndex(), 0);
239     EXPECT_FALSE(buffer->SetIndex(1));
240     EXPECT_EQ(buffer->MoveForward(), 0);
241     EXPECT_EQ(buffer->SkipBits(), 0);
242 
243     std::string pduHex = "00000210020000021002";
244     std::string pdu = StringUtils::HexToString(pduHex);
245     auto rBuffer = std::make_shared<SmsReadBuffer>(pdu);
246     EXPECT_FALSE(rBuffer->IsEmpty());
247     rBuffer->SetIndex(0);
248     uint8_t v = 0;
249     uint16_t v2 = 0;
250     EXPECT_TRUE(rBuffer->ReadByte(v));
251     EXPECT_TRUE(rBuffer->ReadWord(v2));
252     EXPECT_TRUE(rBuffer->ReadBits(v));
253 
254     auto wBuffer = std::make_shared<SmsWriteBuffer>();
255     EXPECT_FALSE(wBuffer->IsEmpty());
256     wBuffer->SetIndex(0);
257     v = 1;
258     v2 = 0x1234;
259     EXPECT_TRUE(wBuffer->WriteByte(v));
260     EXPECT_TRUE(wBuffer->WriteWord(v2));
261     EXPECT_TRUE(wBuffer->InsertByte(v, 1));
262     EXPECT_TRUE(wBuffer->WriteBits(v));
263 }
264 
265 /**
266  * @tc.number   Telephony_CdmaSmsGtest_CdmaSmsTransportMessage_0001
267  * @tc.name     Test CdmaSmsTransportMessage
268  * @tc.desc     Function test
269  */
270 HWTEST_F(CdmaSmsGtest, CdmaSmsTransportMessage_0001, Function | MediumTest | Level1)
271 {
272     TELEPHONY_LOGI("TelSMSMMSTest::CdmaSmsTransportMessage_0001 -->");
273     CdmaSmsMessage cdmaSmsMessage;
274     std::string dest = "dest";
275     std::string sc = "sc";
276     std::string text = "text";
277     bool bStatusReport = false;
278     DataCodingScheme codingScheme = DATA_CODING_7BIT;
279     std::unique_ptr<CdmaTransportMsg> transMsg =
280         cdmaSmsMessage.CreateSubmitTransMsg(dest, sc, text, bStatusReport, codingScheme);
281 
282     std::unique_ptr<CdmaSmsTransportMessage> transportMessage =
283         CdmaSmsTransportMessage::CreateTransportMessage(*transMsg.get());
284     SmsWriteBuffer pduBuffer;
285     EXPECT_NE(transportMessage, nullptr);
286     EXPECT_NE(transportMessage->IsEmpty(), true);
287     EXPECT_EQ(transportMessage->Encode(pduBuffer), true);
288     std::unique_ptr<std::vector<uint8_t>> pdu = pduBuffer.GetPduBuffer();
289     EXPECT_NE(pdu, nullptr);
290     EXPECT_GT(pdu->size(), static_cast<uint32_t>(0));
291 }
292 
293 /**
294  * @tc.number   Telephony_CdmaSmsGtest_CdmaSmsTransportMessage_0002
295  * @tc.name     Test CdmaSmsTransportMessage
296  * @tc.desc     Function test
297  */
298 HWTEST_F(CdmaSmsGtest, CdmaSmsTransportMessage_0002, Function | MediumTest | Level1)
299 {
300     TELEPHONY_LOGI("TelSMSMMSTest::CdmaSmsTransportMessage_0002 -->");
301     std::string pduHex = "0000021002040702C48D159E268406010408260003200640011910D61C58F265CD9F469D5AF66DDDBF871E5CFA75E"
302                          "DDFC79F400801000A0140";
303     std::string pdu = StringUtils::HexToString(pduHex);
304     SmsReadBuffer pduBuffer(pdu);
305     CdmaTransportMsg msg;
306     memset_s(&msg, sizeof(msg), 0, sizeof(msg));
307     std::unique_ptr<CdmaSmsTransportMessage> transportMessage =
308         CdmaSmsTransportMessage::CreateTransportMessage(msg, pduBuffer);
309     EXPECT_NE(transportMessage, nullptr);
310     EXPECT_NE(transportMessage->IsEmpty(), true);
311     EXPECT_EQ(transportMessage->Decode(pduBuffer), true);
312 }
313 
314 /**
315  * @tc.number   Telephony_CdmaSmsGtest_CdmaSmsTransportMessage_0003
316  * @tc.name     Test CdmaSmsTransportMessage
317  * @tc.desc     Function test
318  */
319 HWTEST_F(CdmaSmsGtest, CdmaSmsTransportMessage_0003, Function | MediumTest | Level1)
320 {
321     // BROADCAST DELIVER CMASDATA
322     uint8_t cmasTestBearerData[] = { 0x00, 0x03, 0x1C, 0x78, 0x00, 0x01, 0x59, 0x02, 0xB8, 0x00, 0x02, 0x10, 0xAA,
323         0x68, 0xD3, 0xCD, 0x06, 0x9E, 0x68, 0x30, 0xA0, 0xE9, 0x97, 0x9F, 0x44, 0x1B, 0xF3, 0x20, 0xE9, 0xA3, 0x2A,
324         0x08, 0x7B, 0xF6, 0xED, 0xCB, 0xCB, 0x1E, 0x9C, 0x3B, 0x10, 0x4D, 0xDF, 0x8B, 0x4E, 0xCC, 0xA8, 0x20, 0xEC,
325         0xCB, 0xCB, 0xA2, 0x0A, 0x7E, 0x79, 0xF4, 0xCB, 0xB5, 0x72, 0x0A, 0x9A, 0x34, 0xF3, 0x41, 0xA7, 0x9A, 0x0D,
326         0xFB, 0xB6, 0x79, 0x41, 0x85, 0x07, 0x4C, 0xBC, 0xFA, 0x2E, 0x00, 0x08, 0x20, 0x58, 0x38, 0x88, 0x80, 0x10,
327         0x54, 0x06, 0x38, 0x20, 0x60, 0x30, 0xA8, 0x81, 0x90, 0x20, 0x08 };
328 
329     std::stringstream ss;
330     ss.clear();
331     ss << static_cast<uint8_t>(CdmaTransportMsgType::BROADCAST);
332     ss << static_cast<uint8_t>(CdmaSmsParameterRecord::SERVICE_CATEGORY);
333     ss << static_cast<uint8_t>(0x02);
334     ss << static_cast<uint8_t>(static_cast<uint16_t>(SmsServiceCtg::CMAS_TEST) >> 8);
335     ss << static_cast<uint8_t>(static_cast<uint16_t>(SmsServiceCtg::CMAS_TEST) & 0xff);
336     ss << static_cast<uint8_t>(CdmaSmsParameterRecord::BEARER_DATA);
337     ss << static_cast<uint8_t>(sizeof(cmasTestBearerData));
338     for (uint8_t i = 0; i < sizeof(cmasTestBearerData); i++) {
339         ss << cmasTestBearerData[i];
340     }
341     SmsReadBuffer rBuffer(ss.str());
342     CdmaTransportMsg msg;
343     memset_s(&msg, sizeof(msg), 0, sizeof(msg));
344     std::unique_ptr<CdmaSmsTransportMessage> message = CdmaSmsTransportMessage::CreateTransportMessage(msg, rBuffer);
345     EXPECT_TRUE(message->Decode(rBuffer));
346     EXPECT_EQ(msg.data.broadcast.telesvcMsg.data.deliver.msgId.msgId, 0xc780);
347     EXPECT_EQ(msg.data.broadcast.serviceCtg, static_cast<uint16_t>(SmsServiceCtg::CMAS_TEST));
348     EXPECT_EQ(msg.data.broadcast.telesvcMsg.data.deliver.cmasData.dataLen, 74);
349     EXPECT_EQ(msg.data.broadcast.telesvcMsg.data.deliver.cmasData.urgency, SmsCmaeUrgency::EXPECTED);
350 }
351 
352 /**
353  * @tc.number   Telephony_CdmaSmsGtest_CdmaSmsTransportMessage_0004
354  * @tc.name     Test CdmaSmsTransportMessage
355  * @tc.desc     Function test
356  */
357 HWTEST_F(CdmaSmsGtest, CdmaSmsTransportMessage_0004, Function | MediumTest | Level1)
358 {
359     // BROADCAST DELIVER USERDATA(BCCBB)
360     std::string pduHex = "0101020004081300031008d00106102c2870e1420801c00c01c0";
361     std::string pdu = StringUtils::HexToString(pduHex);
362     SmsReadBuffer pduBuffer(pdu);
363     CdmaTransportMsg msg;
364     memset_s(&msg, sizeof(msg), 0, sizeof(msg));
365     std::unique_ptr<CdmaSmsTransportMessage> transportMessage =
366         CdmaSmsTransportMessage::CreateTransportMessage(msg, pduBuffer);
367     EXPECT_NE(transportMessage, nullptr);
368     EXPECT_FALSE(transportMessage->IsEmpty());
369     EXPECT_TRUE(transportMessage->Decode(pduBuffer));
370 }
371 
GetUserDataString(SmsTeleSvcUserData userData)372 string GetUserDataString(SmsTeleSvcUserData userData)
373 {
374     std::stringstream ssUserData;
375     if (userData.encodeType == SmsEncodingType::UNICODE) {
376         char unicodeChar[UNICODE_CHAR_LEN + 1];
377         unicodeChar[UNICODE_CHAR_LEN] = '\0';
378         for (uint8_t i = 0; i < userData.userData.length; i += UNICODE_CHAR_LEN) {
379             ssUserData << "\\u";
380             snprintf_s(unicodeChar, sizeof(unicodeChar), sizeof(unicodeChar) - 1, "%02x",
381                 static_cast<uint8_t>(userData.userData.data[i]));
382             ssUserData << unicodeChar;
383             snprintf_s(unicodeChar, sizeof(unicodeChar), sizeof(unicodeChar) - 1, "%02x",
384                 static_cast<uint8_t>(userData.userData.data[i + 1]));
385             ssUserData << unicodeChar;
386         }
387     } else {
388         for (uint8_t i = 0; i < userData.userData.length; i++) {
389             ssUserData << static_cast<uint8_t>(userData.userData.data[i]);
390         }
391     }
392     return ssUserData.str();
393 }
394 
CheckDeliverUserData(string pdu,string userData)395 void CheckDeliverUserData(string pdu, string userData)
396 {
397     std::stringstream ss;
398     ss << static_cast<uint8_t>(CdmaSmsParameterRecord::BEARER_DATA);
399     ss << static_cast<uint8_t>(pdu.size() / HEX_CHAR_LEN);
400     ss << StringUtils::HexToString(pdu);
401 
402     CdmaTeleserviceMsg v;
403     memset_s(&v, sizeof(CdmaTeleserviceMsg), 0x00, sizeof(CdmaTeleserviceMsg));
404     SmsReadBuffer rBuffer(ss.str());
405     rBuffer.SetIndex(VALUE_INDEX);
406     auto message = std::make_shared<CdmaSmsBearerData>(v, rBuffer);
407     rBuffer.SetIndex(0);
408     EXPECT_TRUE(message->Decode(rBuffer));
409     EXPECT_STREQ(GetUserDataString(v.data.deliver.userData).c_str(), userData.c_str());
410 }
411 
CheckSubmitUserData(string pdu,string userData)412 void CheckSubmitUserData(string pdu, string userData)
413 {
414     std::stringstream ss;
415     ss << static_cast<uint8_t>(CdmaSmsParameterRecord::BEARER_DATA);
416     ss << static_cast<uint8_t>(pdu.size() / HEX_CHAR_LEN);
417     ss << StringUtils::HexToString(pdu);
418 
419     CdmaTeleserviceMsg v;
420     memset_s(&v, sizeof(CdmaTeleserviceMsg), 0x00, sizeof(CdmaTeleserviceMsg));
421     SmsReadBuffer rBuffer(ss.str());
422     rBuffer.SetIndex(VALUE_INDEX);
423     auto message = std::make_shared<CdmaSmsBearerData>(v, rBuffer);
424     rBuffer.SetIndex(0);
425     EXPECT_TRUE(message->Decode(rBuffer));
426     EXPECT_STREQ(GetUserDataString(v.data.submit.userData).c_str(), userData.c_str());
427 
428     auto message1 = std::make_shared<CdmaSmsBearerData>(v);
429     SmsWriteBuffer wBuffer;
430     EXPECT_TRUE(message1->Encode(wBuffer));
431     auto buffer = wBuffer.GetPduBuffer();
432     EXPECT_GT(buffer->size(), 0);
433     std::stringstream ssEncode;
434     for (uint16_t i = 0; i < buffer->size(); i++) {
435         ssEncode << (*buffer)[i];
436     }
437 
438     CdmaTeleserviceMsg v2;
439     memset_s(&v2, sizeof(CdmaTeleserviceMsg), 0x00, sizeof(CdmaTeleserviceMsg));
440     SmsReadBuffer rBuffer2(ssEncode.str());
441     rBuffer2.SetIndex(VALUE_INDEX);
442     auto message2 = std::make_shared<CdmaSmsBearerData>(v2, rBuffer2);
443     rBuffer2.SetIndex(0);
444     EXPECT_TRUE(message2->Decode(rBuffer2));
445     EXPECT_STREQ(GetUserDataString(v2.data.submit.userData).c_str(), userData.c_str());
446 }
447 
448 /**
449  * @tc.number   Telephony_CdmaSmsGtest_CdmaSmsBearerData_0001
450  * @tc.name     Test CdmaSmsBearerData
451  * @tc.desc     Function test
452  */
453 HWTEST_F(CdmaSmsGtest, CdmaSmsBearerData_0001, Function | MediumTest | Level1)
454 {
455     // gsm 7bit
456     CheckDeliverUserData("00031040900112488ea794e074d69e1b7392c270326cde9e98", "Test standard SMS");
457     // ascii 7bit
458     CheckDeliverUserData("0003100160010610262d5ab500", "bjjj");
459     // ia5
460     CheckDeliverUserData("00031002100109184539b4d052ebb3d0", "SMS Rulz");
461     // unicode
462     CheckDeliverUserData("000310021001062012716B2C380801000A0140", "\\u4e2d\\u6587");
463 
464     // gsm 7bit
465     CheckSubmitUserData("00032006400112488ea794e074d69e1b7392c270326cde9e98", "Test standard SMS");
466     // ascii 7bit
467     CheckSubmitUserData("0003200640010610262d5ab500", "bjjj");
468     // ia5
469     CheckSubmitUserData("00032006400109184539b4d052ebb3d0", "SMS Rulz");
470     // unicode
471     CheckSubmitUserData("000320064001062012716B2C380801000A0140", "\\u4e2d\\u6587");
472 }
473 
474 /**
475  * @tc.number   Telephony_CdmaSmsGtest_CdmaSmsBearerData_0002
476  * @tc.name     Test CdmaSmsBearerData
477  * @tc.desc     Function test
478  */
479 HWTEST_F(CdmaSmsGtest, CdmaSmsBearerData_0002, Function | MediumTest | Level1)
480 {
481     std::string dataStr = "0003200010010410168d20020105030608120111015905019206069706180000000801c00901800a01e00b"
482                           "01030c01c00d01070e05039acc13880f018011020566";
483     std::stringstream ss;
484     ss.clear();
485     ss << static_cast<uint8_t>(CdmaSmsParameterRecord::BEARER_DATA);
486     ss << static_cast<uint8_t>(dataStr.size() / HEX_CHAR_LEN);
487     ss << StringUtils::HexToString(dataStr);
488 
489     CdmaTeleserviceMsg v;
490     memset_s(&v, sizeof(CdmaTeleserviceMsg), 0x00, sizeof(CdmaTeleserviceMsg));
491     SmsReadBuffer rBuffer(ss.str());
492     rBuffer.SetIndex(VALUE_INDEX);
493     auto message = std::make_shared<CdmaSmsBearerData>(v, rBuffer);
494     rBuffer.SetIndex(0);
495     EXPECT_TRUE(message->Decode(rBuffer));
496     EXPECT_EQ(v.type, TeleserviceMsgType::SUBMIT);
497     EXPECT_EQ(v.data.submit.msgId.msgId, 1);
498     EXPECT_EQ(v.data.submit.priority, SmsPriorityIndicator::EMERGENCY);
499     EXPECT_EQ(v.data.submit.privacy, SmsPrivacyIndicator::CONFIDENTIAL);
500     EXPECT_EQ(v.data.submit.callbackNumber.addrLen, 7);
501     char number[] = "3598271";
502     for (uint8_t i = 0; i < sizeof(number); i++) {
503         EXPECT_EQ(v.data.submit.callbackNumber.szData[i], number[i]);
504     }
505     EXPECT_EQ(v.data.submit.depositId, 1382);
506     EXPECT_EQ(v.data.submit.language, SmsLanguageType::HEBREW);
507     EXPECT_EQ(v.data.submit.alertPriority, SmsAlertPriority::HIGH);
508     EXPECT_EQ(v.data.submit.deferValPeriod.time.absTime.year, 97);
509     EXPECT_EQ(v.data.submit.deferValPeriod.time.absTime.month, 6);
510     EXPECT_EQ(v.data.submit.deferValPeriod.time.absTime.day, 18);
511 }
512 #endif // TEL_TEST_UNSUPPORT
513 } // namespace Telephony
514 } // namespace OHOS