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 CdmaSmsReceiveHandler cdmaSmsReceiveHandler(DEFAULT_SIM_SLOT_ID);
138 int32_t retInt = cdmaSmsReceiveHandler.HandleSmsByType(nullptr);
139 EXPECT_EQ(AckIncomeCause::SMS_ACK_UNKNOWN_ERROR, retInt);
140 }
141
142 /**
143 * @tc.number Telephony_SmsMmsGtest_CdmaSmsReceiveHandler_0002
144 * @tc.name Test CdmaSmsReceiveHandler
145 * @tc.desc Function test
146 */
147 HWTEST_F(CdmaSmsGtest, CdmaSmsReceiveHandler_0002, Function | MediumTest | Level1)
148 {
149 TELEPHONY_LOGI("TelSMSMMSTest::CdmaSmsReceiveHandler_0002 -->");
150 auto cdmaSmsReceiveHandler = std::make_shared<CdmaSmsReceiveHandler>(DEFAULT_SIM_SLOT_ID);
151 cdmaSmsReceiveHandler->Init();
152 auto retMsg = std::make_shared<CdmaSmsMessage>();
153 retMsg = CdmaSmsMessage::CreateMessage(CDMA_PDU);
154 EXPECT_EQ(retMsg, nullptr);
155 auto cdmaMsg = std::make_shared<CdmaSmsMessage>();
156 cdmaMsg->transMsg_ = std::make_unique<struct CdmaTransportMsg>();
157 cdmaMsg->transMsg_->type = CdmaTransportMsgType::BROADCAST;
158 int32_t retInt = cdmaSmsReceiveHandler->HandleSmsByType(cdmaMsg);
159 EXPECT_EQ(AckIncomeCause::SMS_ACK_RESULT_OK, retInt);
160 cdmaMsg->transMsg_->type = CdmaTransportMsgType::P2P;
161 retInt = cdmaSmsReceiveHandler->HandleSmsByType(cdmaMsg);
162 EXPECT_EQ(AckIncomeCause::SMS_ACK_RESULT_OK, retInt);
163 cdmaMsg->transMsg_->type = CdmaTransportMsgType::ACK;
164 retInt = cdmaSmsReceiveHandler->HandleSmsByType(cdmaMsg);
165 EXPECT_EQ(AckIncomeCause::SMS_ACK_RESULT_OK, retInt);
166 cdmaMsg->transMsg_->type = CdmaTransportMsgType::RESERVED;
167 retInt = cdmaSmsReceiveHandler->HandleSmsByType(cdmaMsg);
168 EXPECT_EQ(AckIncomeCause::SMS_ACK_RESULT_OK, retInt);
169 }
170
171 /**
172 * @tc.number Telephony_SmsMmsGtest_CdmaSmsReceiveHandler_0003
173 * @tc.name Test CdmaSmsReceiveHandler
174 * @tc.desc Function test
175 */
176 HWTEST_F(CdmaSmsGtest, CdmaSmsReceiveHandler_0003, Function | MediumTest | Level1)
177 {
178 TELEPHONY_LOGI("TelSMSMMSTest::CdmaSmsReceiveHandler_0003 -->");
179 auto cdmaSmsReceiveHandler = std::make_shared<CdmaSmsReceiveHandler>(DEFAULT_SIM_SLOT_ID);
180 int32_t retInt = cdmaSmsReceiveHandler->HandleSmsOtherSvcid(nullptr);
181 EXPECT_NE(AckIncomeCause::SMS_ACK_RESULT_OK, retInt);
182 auto retMsg = CdmaSmsMessage::CreateMessage(OTHER_CDMA_PDU);
183 EXPECT_EQ(retMsg, nullptr);
184
185 auto cdmaMsg = std::make_shared<CdmaSmsMessage>();
186 cdmaSmsReceiveHandler->ReplySmsToSmsc(1, cdmaMsg);
187 retInt = cdmaSmsReceiveHandler->HandleSmsOtherSvcid(cdmaMsg);
188 EXPECT_NE(AckIncomeCause::SMS_ACK_RESULT_OK, retInt);
189 cdmaMsg->smsConcat_ = std::make_shared<SmsConcat>();
190 cdmaMsg->smsConcat_->is8Bits = true;
191 cdmaMsg->smsConcat_->msgRef = 1;
192 cdmaMsg->smsConcat_->seqNum = 1;
193 cdmaMsg->smsConcat_->totalSeg = 1;
194 retInt = cdmaSmsReceiveHandler->HandleSmsOtherSvcid(cdmaMsg);
195 EXPECT_NE(AckIncomeCause::SMS_ACK_RESULT_OK, retInt);
196 }
197
198 /**
199 * @tc.number Telephony_SmsMmsGtest_CdmaSmsReceiveHandler_0004
200 * @tc.name Test CdmaSmsReceiveHandler
201 * @tc.desc Function test
202 */
203 HWTEST_F(CdmaSmsGtest, CdmaSmsReceiveHandler_0004, Function | MediumTest | Level1)
204 {
205 TELEPHONY_LOGI("TelSMSMMSTest::CdmaSmsReceiveHandler_0004 -->");
206 CdmaSmsReceiveHandler cdmaSmsReceiveHandler(DEFAULT_SIM_SLOT_ID);
207 std::function<void(std::shared_ptr<SmsSendIndexer>)> fun = nullptr;
208 auto smsSender = std::make_shared<CdmaSmsSender>(DEFAULT_SIM_SLOT_ID, fun);
209 cdmaSmsReceiveHandler.SetCdmaSender(smsSender);
210 auto info = std::make_shared<SmsMessageInfo>();
211 auto ret = cdmaSmsReceiveHandler.TransformMessageInfo(info);
212 EXPECT_EQ(ret, nullptr);
213 cdmaSmsReceiveHandler.SendCBBroadcast(nullptr);
214 auto cdmaMsg = std::make_shared<CdmaSmsMessage>();
215 EXPECT_EQ(cdmaSmsReceiveHandler.SendCBBroadcast(cdmaMsg), true);
216 }
217
218 /**
219 * @tc.number Telephony_CdmaSmsGtest_SmsPduBuffer_0001
220 * @tc.name Test SmsPduBuffer
221 * @tc.desc Function test
222 */
223 HWTEST_F(CdmaSmsGtest, SmsPduBuffer_0001, Function | MediumTest | Level1)
224 {
225 auto buffer = std::make_shared<SmsPduBuffer>();
226 EXPECT_TRUE(buffer->IsEmpty());
227 EXPECT_EQ(buffer->GetIndex(), 0);
228 EXPECT_FALSE(buffer->SetIndex(1));
229 EXPECT_EQ(buffer->MoveForward(), 0);
230 EXPECT_EQ(buffer->SkipBits(), 0);
231
232 std::string pduHex = "00000210020000021002";
233 std::string pdu = StringUtils::HexToString(pduHex);
234 auto rBuffer = std::make_shared<SmsReadBuffer>(pdu);
235 EXPECT_FALSE(rBuffer->IsEmpty());
236 rBuffer->SetIndex(0);
237 uint8_t v = 0;
238 uint16_t v2 = 0;
239 EXPECT_TRUE(rBuffer->ReadByte(v));
240 EXPECT_TRUE(rBuffer->ReadWord(v2));
241 EXPECT_TRUE(rBuffer->ReadBits(v));
242
243 auto wBuffer = std::make_shared<SmsWriteBuffer>();
244 EXPECT_FALSE(wBuffer->IsEmpty());
245 wBuffer->SetIndex(0);
246 v = 1;
247 v2 = 0x1234;
248 EXPECT_TRUE(wBuffer->WriteByte(v));
249 EXPECT_TRUE(wBuffer->WriteWord(v2));
250 EXPECT_TRUE(wBuffer->InsertByte(v, 1));
251 EXPECT_TRUE(wBuffer->WriteBits(v));
252 }
253
254 /**
255 * @tc.number Telephony_CdmaSmsGtest_CdmaSmsTransportMessage_0001
256 * @tc.name Test CdmaSmsTransportMessage
257 * @tc.desc Function test
258 */
259 HWTEST_F(CdmaSmsGtest, CdmaSmsTransportMessage_0001, Function | MediumTest | Level1)
260 {
261 TELEPHONY_LOGI("TelSMSMMSTest::CdmaSmsTransportMessage_0001 -->");
262 CdmaSmsMessage cdmaSmsMessage;
263 std::string dest = "dest";
264 std::string sc = "sc";
265 std::string text = "text";
266 bool bStatusReport = false;
267 DataCodingScheme codingScheme = DATA_CODING_7BIT;
268 std::unique_ptr<CdmaTransportMsg> transMsg =
269 cdmaSmsMessage.CreateSubmitTransMsg(dest, sc, text, bStatusReport, codingScheme);
270
271 std::unique_ptr<CdmaSmsTransportMessage> transportMessage =
272 CdmaSmsTransportMessage::CreateTransportMessage(*transMsg.get());
273 SmsWriteBuffer pduBuffer;
274 EXPECT_NE(transportMessage, nullptr);
275 EXPECT_NE(transportMessage->IsEmpty(), true);
276 EXPECT_EQ(transportMessage->Encode(pduBuffer), true);
277 std::unique_ptr<std::vector<uint8_t>> pdu = pduBuffer.GetPduBuffer();
278 EXPECT_NE(pdu, nullptr);
279 EXPECT_GT(pdu->size(), static_cast<uint32_t>(0));
280 }
281
282 /**
283 * @tc.number Telephony_CdmaSmsGtest_CdmaSmsTransportMessage_0002
284 * @tc.name Test CdmaSmsTransportMessage
285 * @tc.desc Function test
286 */
287 HWTEST_F(CdmaSmsGtest, CdmaSmsTransportMessage_0002, Function | MediumTest | Level1)
288 {
289 TELEPHONY_LOGI("TelSMSMMSTest::CdmaSmsTransportMessage_0002 -->");
290 std::string pduHex = "0000021002040702C48D159E268406010408260003200640011910D61C58F265CD9F469D5AF66DDDBF871E5CFA75E"
291 "DDFC79F400801000A0140";
292 std::string pdu = StringUtils::HexToString(pduHex);
293 SmsReadBuffer pduBuffer(pdu);
294 CdmaTransportMsg msg;
295 memset_s(&msg, sizeof(msg), 0, sizeof(msg));
296 std::unique_ptr<CdmaSmsTransportMessage> transportMessage =
297 CdmaSmsTransportMessage::CreateTransportMessage(msg, pduBuffer);
298 EXPECT_NE(transportMessage, nullptr);
299 EXPECT_NE(transportMessage->IsEmpty(), true);
300 EXPECT_EQ(transportMessage->Decode(pduBuffer), true);
301 }
302
303 /**
304 * @tc.number Telephony_CdmaSmsGtest_CdmaSmsTransportMessage_0003
305 * @tc.name Test CdmaSmsTransportMessage
306 * @tc.desc Function test
307 */
308 HWTEST_F(CdmaSmsGtest, CdmaSmsTransportMessage_0003, Function | MediumTest | Level1)
309 {
310 // BROADCAST DELIVER CMASDATA
311 uint8_t CMAS_TEST_BEARER_DATA[] = { 0x00, 0x03, 0x1C, 0x78, 0x00, 0x01, 0x59, 0x02, 0xB8, 0x00, 0x02, 0x10, 0xAA,
312 0x68, 0xD3, 0xCD, 0x06, 0x9E, 0x68, 0x30, 0xA0, 0xE9, 0x97, 0x9F, 0x44, 0x1B, 0xF3, 0x20, 0xE9, 0xA3, 0x2A,
313 0x08, 0x7B, 0xF6, 0xED, 0xCB, 0xCB, 0x1E, 0x9C, 0x3B, 0x10, 0x4D, 0xDF, 0x8B, 0x4E, 0xCC, 0xA8, 0x20, 0xEC,
314 0xCB, 0xCB, 0xA2, 0x0A, 0x7E, 0x79, 0xF4, 0xCB, 0xB5, 0x72, 0x0A, 0x9A, 0x34, 0xF3, 0x41, 0xA7, 0x9A, 0x0D,
315 0xFB, 0xB6, 0x79, 0x41, 0x85, 0x07, 0x4C, 0xBC, 0xFA, 0x2E, 0x00, 0x08, 0x20, 0x58, 0x38, 0x88, 0x80, 0x10,
316 0x54, 0x06, 0x38, 0x20, 0x60, 0x30, 0xA8, 0x81, 0x90, 0x20, 0x08 };
317
318 std::stringstream ss;
319 ss.clear();
320 ss << static_cast<uint8_t>(CdmaTransportMsgType::BROADCAST);
321 ss << static_cast<uint8_t>(CdmaSmsParameterRecord::SERVICE_CATEGORY);
322 ss << static_cast<uint8_t>(0x02);
323 ss << static_cast<uint8_t>(static_cast<uint16_t>(SmsServiceCtg::CMAS_TEST) >> 8);
324 ss << static_cast<uint8_t>(static_cast<uint16_t>(SmsServiceCtg::CMAS_TEST) & 0xff);
325 ss << static_cast<uint8_t>(CdmaSmsParameterRecord::BEARER_DATA);
326 ss << static_cast<uint8_t>(sizeof(CMAS_TEST_BEARER_DATA));
327 for (uint8_t i = 0; i < sizeof(CMAS_TEST_BEARER_DATA); i++) {
328 ss << CMAS_TEST_BEARER_DATA[i];
329 }
330 SmsReadBuffer rBuffer(ss.str());
331 CdmaTransportMsg msg;
332 memset_s(&msg, sizeof(msg), 0, sizeof(msg));
333 std::unique_ptr<CdmaSmsTransportMessage> message = CdmaSmsTransportMessage::CreateTransportMessage(msg, rBuffer);
334 EXPECT_TRUE(message->Decode(rBuffer));
335 EXPECT_EQ(msg.data.broadcast.telesvcMsg.data.deliver.msgId.msgId, 0xc780);
336 EXPECT_EQ(msg.data.broadcast.serviceCtg, static_cast<uint16_t>(SmsServiceCtg::CMAS_TEST));
337 EXPECT_EQ(msg.data.broadcast.telesvcMsg.data.deliver.cmasData.dataLen, 74);
338 EXPECT_EQ(msg.data.broadcast.telesvcMsg.data.deliver.cmasData.urgency, SmsCmaeUrgency::EXPECTED);
339 }
340
341 /**
342 * @tc.number Telephony_CdmaSmsGtest_CdmaSmsTransportMessage_0004
343 * @tc.name Test CdmaSmsTransportMessage
344 * @tc.desc Function test
345 */
346 HWTEST_F(CdmaSmsGtest, CdmaSmsTransportMessage_0004, Function | MediumTest | Level1)
347 {
348 // BROADCAST DELIVER USERDATA(BCCBB)
349 std::string pduHex = "0101020004081300031008d00106102c2870e1420801c00c01c0";
350 std::string pdu = StringUtils::HexToString(pduHex);
351 SmsReadBuffer pduBuffer(pdu);
352 CdmaTransportMsg msg;
353 memset_s(&msg, sizeof(msg), 0, sizeof(msg));
354 std::unique_ptr<CdmaSmsTransportMessage> transportMessage =
355 CdmaSmsTransportMessage::CreateTransportMessage(msg, pduBuffer);
356 EXPECT_NE(transportMessage, nullptr);
357 EXPECT_FALSE(transportMessage->IsEmpty());
358 EXPECT_TRUE(transportMessage->Decode(pduBuffer));
359 }
360
GetUserDataString(SmsTeleSvcUserData userData)361 string GetUserDataString(SmsTeleSvcUserData userData)
362 {
363 std::stringstream ssUserData;
364 if (userData.encodeType == SmsEncodingType::UNICODE) {
365 char unicodeChar[UNICODE_CHAR_LEN + 1];
366 unicodeChar[UNICODE_CHAR_LEN] = '\0';
367 for (uint8_t i = 0; i < userData.userData.length; i += UNICODE_CHAR_LEN) {
368 ssUserData << "\\u";
369 snprintf_s(unicodeChar, sizeof(unicodeChar), sizeof(unicodeChar) - 1, "%02x",
370 static_cast<uint8_t>(userData.userData.data[i]));
371 ssUserData << unicodeChar;
372 snprintf_s(unicodeChar, sizeof(unicodeChar), sizeof(unicodeChar) - 1, "%02x",
373 static_cast<uint8_t>(userData.userData.data[i + 1]));
374 ssUserData << unicodeChar;
375 }
376 } else {
377 for (uint8_t i = 0; i < userData.userData.length; i++) {
378 ssUserData << static_cast<uint8_t>(userData.userData.data[i]);
379 }
380 }
381 return ssUserData.str();
382 }
383
CheckDeliverUserData(string pdu,string userData)384 void CheckDeliverUserData(string pdu, string userData)
385 {
386 std::stringstream ss;
387 ss << static_cast<uint8_t>(CdmaSmsParameterRecord::BEARER_DATA);
388 ss << static_cast<uint8_t>(pdu.size() / HEX_CHAR_LEN);
389 ss << StringUtils::HexToString(pdu);
390
391 CdmaTeleserviceMsg v;
392 memset_s(&v, sizeof(CdmaTeleserviceMsg), 0x00, sizeof(CdmaTeleserviceMsg));
393 SmsReadBuffer rBuffer(ss.str());
394 rBuffer.SetIndex(VALUE_INDEX);
395 auto message = std::make_shared<CdmaSmsBearerData>(v, rBuffer);
396 rBuffer.SetIndex(0);
397 EXPECT_TRUE(message->Decode(rBuffer));
398 EXPECT_STREQ(GetUserDataString(v.data.deliver.userData).c_str(), userData.c_str());
399 }
400
CheckSubmitUserData(string pdu,string userData)401 void CheckSubmitUserData(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.submit.userData).c_str(), userData.c_str());
416
417 auto message1 = std::make_shared<CdmaSmsBearerData>(v);
418 SmsWriteBuffer wBuffer;
419 EXPECT_TRUE(message1->Encode(wBuffer));
420 auto buffer = wBuffer.GetPduBuffer();
421 EXPECT_GT(buffer->size(), 0);
422 std::stringstream ssEncode;
423 for (uint16_t i = 0; i < buffer->size(); i++) {
424 ssEncode << (*buffer)[i];
425 }
426
427 CdmaTeleserviceMsg v2;
428 memset_s(&v2, sizeof(CdmaTeleserviceMsg), 0x00, sizeof(CdmaTeleserviceMsg));
429 SmsReadBuffer rBuffer2(ssEncode.str());
430 rBuffer2.SetIndex(VALUE_INDEX);
431 auto message2 = std::make_shared<CdmaSmsBearerData>(v2, rBuffer2);
432 rBuffer2.SetIndex(0);
433 EXPECT_TRUE(message2->Decode(rBuffer2));
434 EXPECT_STREQ(GetUserDataString(v2.data.submit.userData).c_str(), userData.c_str());
435 }
436
437 /**
438 * @tc.number Telephony_CdmaSmsGtest_CdmaSmsBearerData_0001
439 * @tc.name Test CdmaSmsBearerData
440 * @tc.desc Function test
441 */
442 HWTEST_F(CdmaSmsGtest, CdmaSmsBearerData_0001, Function | MediumTest | Level1)
443 {
444 // gsm 7bit
445 CheckDeliverUserData("00031040900112488ea794e074d69e1b7392c270326cde9e98", "Test standard SMS");
446 // ascii 7bit
447 CheckDeliverUserData("0003100160010610262d5ab500", "bjjj");
448 // ia5
449 CheckDeliverUserData("00031002100109184539b4d052ebb3d0", "SMS Rulz");
450 // unicode
451 CheckDeliverUserData("000310021001062012716B2C380801000A0140", "\\u4e2d\\u6587");
452
453 // gsm 7bit
454 CheckSubmitUserData("00032006400112488ea794e074d69e1b7392c270326cde9e98", "Test standard SMS");
455 // ascii 7bit
456 CheckSubmitUserData("0003200640010610262d5ab500", "bjjj");
457 // ia5
458 CheckSubmitUserData("00032006400109184539b4d052ebb3d0", "SMS Rulz");
459 // unicode
460 CheckSubmitUserData("000320064001062012716B2C380801000A0140", "\\u4e2d\\u6587");
461 }
462
463 /**
464 * @tc.number Telephony_CdmaSmsGtest_CdmaSmsBearerData_0002
465 * @tc.name Test CdmaSmsBearerData
466 * @tc.desc Function test
467 */
468 HWTEST_F(CdmaSmsGtest, CdmaSmsBearerData_0002, Function | MediumTest | Level1)
469 {
470 std::string dataStr = "0003200010010410168d20020105030608120111015905019206069706180000000801c00901800a01e00b"
471 "01030c01c00d01070e05039acc13880f018011020566";
472 std::stringstream ss;
473 ss.clear();
474 ss << static_cast<uint8_t>(CdmaSmsParameterRecord::BEARER_DATA);
475 ss << static_cast<uint8_t>(dataStr.size() / HEX_CHAR_LEN);
476 ss << StringUtils::HexToString(dataStr);
477
478 CdmaTeleserviceMsg v;
479 memset_s(&v, sizeof(CdmaTeleserviceMsg), 0x00, sizeof(CdmaTeleserviceMsg));
480 SmsReadBuffer rBuffer(ss.str());
481 rBuffer.SetIndex(VALUE_INDEX);
482 auto message = std::make_shared<CdmaSmsBearerData>(v, rBuffer);
483 rBuffer.SetIndex(0);
484 EXPECT_TRUE(message->Decode(rBuffer));
485 EXPECT_EQ(v.type, TeleserviceMsgType::SUBMIT);
486 EXPECT_EQ(v.data.submit.msgId.msgId, 1);
487 EXPECT_EQ(v.data.submit.priority, SmsPriorityIndicator::EMERGENCY);
488 EXPECT_EQ(v.data.submit.privacy, SmsPrivacyIndicator::CONFIDENTIAL);
489 EXPECT_EQ(v.data.submit.callbackNumber.addrLen, 7);
490 char number[] = "3598271";
491 for (uint8_t i = 0; i < sizeof(number); i++) {
492 EXPECT_EQ(v.data.submit.callbackNumber.szData[i], number[i]);
493 }
494 EXPECT_EQ(v.data.submit.depositId, 1382);
495 EXPECT_EQ(v.data.submit.language, SmsLanguageType::HEBREW);
496 EXPECT_EQ(v.data.submit.alertPriority, SmsAlertPriority::HIGH);
497 EXPECT_EQ(v.data.submit.deferValPeriod.time.absTime.year, 97);
498 EXPECT_EQ(v.data.submit.deferValPeriod.time.absTime.month, 6);
499 EXPECT_EQ(v.data.submit.deferValPeriod.time.absTime.day, 18);
500 }
501 #endif // TEL_TEST_UNSUPPORT
502 } // namespace Telephony
503 } // namespace OHOS