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_parameter_record.h"
21 #include "cdma_sms_receive_handler.h"
22 #include "cdma_sms_transport_message.h"
23 #include "gtest/gtest.h"
24
25 namespace OHOS {
26 namespace Telephony {
27 using namespace testing::ext;
28
29 namespace {
30 const uint16_t PDU_BUFFER_MAX_SIZE = 0xFF;
31 const size_t DATA_LENGTH = 162;
32 const int32_t HEADER_LENGTH = 7;
33 } // namespace
34
35 class BranchCdmaSmsTest : public testing::Test {
36 public:
37 static void SetUpTestCase();
38 static void TearDownTestCase();
39 void SetUp();
40 void TearDown();
41 };
SetUpTestCase()42 void BranchCdmaSmsTest::SetUpTestCase() {}
43
44 constexpr uint32_t EVENT_RELEASE_DATA_SHARE_HELPER = 10000;
TearDownTestCase()45 void BranchCdmaSmsTest::TearDownTestCase()
46 {
47 DelayedSingleton<SmsPersistHelper>::GetInstance()->RemoveEvent(EVENT_RELEASE_DATA_SHARE_HELPER);
48 }
49
SetUp()50 void BranchCdmaSmsTest::SetUp() {}
51
TearDown()52 void BranchCdmaSmsTest::TearDown() {}
53
54 /**
55 * @tc.number Telephony_BranchCdmaSmsTest_CdmaSmsMessage_0001
56 * @tc.name Test CdmaSmsMessage
57 * @tc.desc Function test
58 */
59 HWTEST_F(BranchCdmaSmsTest, CdmaSmsMessage_0001, Function | MediumTest | Level1)
60 {
61 std::shared_ptr<CdmaSmsMessage> cdmaSmsMessage = std::make_shared<CdmaSmsMessage>();
62 string pduHex = "";
63 DataCodingScheme codingType;
64 CdmaP2PMsg p2pMsg;
65 p2pMsg.telesvcMsg.type = TeleserviceMsgType::DELIVER;
66 cdmaSmsMessage->AnalysisP2pMsg(p2pMsg);
67 p2pMsg.telesvcMsg.type = TeleserviceMsgType::DELIVERY_ACK;
68 cdmaSmsMessage->AnalysisP2pMsg(p2pMsg);
69 p2pMsg.telesvcMsg.type = TeleserviceMsgType::USER_ACK;
70 cdmaSmsMessage->AnalysisP2pMsg(p2pMsg);
71 p2pMsg.telesvcMsg.type = TeleserviceMsgType::READ_ACK;
72 cdmaSmsMessage->AnalysisP2pMsg(p2pMsg);
73 p2pMsg.telesvcMsg.type = TeleserviceMsgType::SUBMIT_REPORT;
74 cdmaSmsMessage->AnalysisP2pMsg(p2pMsg);
75 p2pMsg.telesvcMsg.type = TeleserviceMsgType::SUBMIT;
76 cdmaSmsMessage->AnalysisP2pMsg(p2pMsg);
77 p2pMsg.telesvcMsg.type = TeleserviceMsgType::MAX_VALUE;
78 cdmaSmsMessage->AnalysisP2pMsg(p2pMsg);
79 p2pMsg.teleserviceId = static_cast<uint16_t>(SmsTransTelsvcId::RESERVED);
80 cdmaSmsMessage->AnalysisP2pMsg(p2pMsg);
81 EXPECT_FALSE(cdmaSmsMessage->IsWapPushMsg());
82 EXPECT_EQ(cdmaSmsMessage->GetTransMsgType(), CdmaTransportMsgType::RESERVED);
83 EXPECT_EQ(cdmaSmsMessage->GetTransTeleService(), static_cast<uint16_t>(SmsTransTelsvcId::RESERVED));
84 EXPECT_FALSE(cdmaSmsMessage->PduAnalysis(pduHex));
85 cdmaSmsMessage->transMsg_ = std::make_unique<struct CdmaTransportMsg>();
86 cdmaSmsMessage->transMsg_->type = CdmaTransportMsgType::BROADCAST;
87 EXPECT_EQ(cdmaSmsMessage->GetTransTeleService(), static_cast<uint16_t>(SmsTransTelsvcId::RESERVED));
88 cdmaSmsMessage->transMsg_->type = CdmaTransportMsgType::P2P;
89 cdmaSmsMessage->transMsg_->data.p2p.teleserviceId = static_cast<uint16_t>(SmsTransTelsvcId::WAP);
90 EXPECT_TRUE(cdmaSmsMessage->IsWapPushMsg());
91 codingType = DataCodingScheme::DATA_CODING_7BIT;
92 EXPECT_EQ(cdmaSmsMessage->CovertEncodingType(codingType), SmsEncodingType::GSM7BIT);
93 codingType = DataCodingScheme::DATA_CODING_ASCII7BIT;
94 EXPECT_EQ(cdmaSmsMessage->CovertEncodingType(codingType), SmsEncodingType::ASCII_7BIT);
95 codingType = DataCodingScheme::DATA_CODING_8BIT;
96 EXPECT_EQ(cdmaSmsMessage->CovertEncodingType(codingType), SmsEncodingType::OCTET);
97 codingType = DataCodingScheme::DATA_CODING_UCS2;
98 EXPECT_EQ(cdmaSmsMessage->CovertEncodingType(codingType), SmsEncodingType::UNICODE);
99 codingType = DataCodingScheme::DATA_CODING_EUCKR;
100 EXPECT_EQ(cdmaSmsMessage->CovertEncodingType(codingType), SmsEncodingType::UNICODE);
101 EXPECT_FALSE(cdmaSmsMessage->PduAnalysis(pduHex));
102 pduHex = "12";
103 EXPECT_FALSE(cdmaSmsMessage->PduAnalysis(pduHex));
104 }
105
106 /**
107 * @tc.number Telephony_BranchCdmaSmsTest_CdmaSmsMessage_0002
108 * @tc.name Test CdmaSmsMessage
109 * @tc.desc Function test
110 */
111 HWTEST_F(BranchCdmaSmsTest, CdmaSmsMessage_0002, Function | MediumTest | Level1)
112 {
113 std::shared_ptr<CdmaSmsMessage> cdmaSmsMessage = std::make_shared<CdmaSmsMessage>();
114 CdmaP2PMsg p2pMsg;
115 TeleserviceDeliver deliver;
116 SmsTeleSvcUserData userData;
117 CdmaBroadCastMsg cbMsg;
118 SmsUDH header;
119 p2pMsg.teleserviceId = static_cast<uint16_t>(SmsTransTelsvcId::VMN_95);
120 p2pMsg.telesvcMsg.data.deliver.vmn.faxIncluded = true;
121 p2pMsg.telesvcMsg.data.deliver.userData.userData.length = 0;
122 deliver.displayMode = SmsDisplayMode::IMMEDIATE;
123 cdmaSmsMessage->AnalsisDeliverMwi(p2pMsg);
124 cdmaSmsMessage->AnalsisDeliverMsg(deliver);
125 userData.encodeType = SmsEncodingType::GSM7BIT;
126 cdmaSmsMessage->AnalsisUserData(userData);
127 userData.encodeType = SmsEncodingType::KOREAN;
128 cdmaSmsMessage->AnalsisUserData(userData);
129 userData.encodeType = SmsEncodingType::EUCKR;
130 cdmaSmsMessage->AnalsisUserData(userData);
131 userData.encodeType = SmsEncodingType::IA5;
132 cdmaSmsMessage->AnalsisUserData(userData);
133 userData.encodeType = SmsEncodingType::ASCII_7BIT;
134 cdmaSmsMessage->AnalsisUserData(userData);
135 userData.encodeType = SmsEncodingType::LATIN_HEBREW;
136 cdmaSmsMessage->AnalsisUserData(userData);
137 userData.encodeType = SmsEncodingType::LATIN;
138 cdmaSmsMessage->AnalsisUserData(userData);
139 userData.encodeType = SmsEncodingType::OCTET;
140 cdmaSmsMessage->AnalsisUserData(userData);
141 userData.encodeType = SmsEncodingType::SHIFT_JIS;
142 cdmaSmsMessage->AnalsisUserData(userData);
143 userData.encodeType = SmsEncodingType::RESERVED;
144 cdmaSmsMessage->AnalsisUserData(userData);
145 deliver.cmasData.dataLen = DATA_LENGTH;
146 cdmaSmsMessage->AnalsisCMASMsg(deliver);
147 cbMsg.telesvcMsg.type = TeleserviceMsgType::RESERVED;
148 cdmaSmsMessage->AnalysisCbMsg(cbMsg);
149 cbMsg.telesvcMsg.type = TeleserviceMsgType::DELIVER;
150 cdmaSmsMessage->AnalysisCbMsg(cbMsg);
151 cbMsg.serviceCtg = static_cast<uint16_t>(SmsServiceCtg::CMAS_AMBER);
152 cdmaSmsMessage->AnalysisCbMsg(cbMsg);
153 userData.userData.headerCnt = HEADER_LENGTH;
154 cdmaSmsMessage->bHeaderInd_ = true;
155 cdmaSmsMessage->AnalsisHeader(userData);
156 EXPECT_FALSE(cdmaSmsMessage->AddUserDataHeader(header));
157 }
158
159 /**
160 * @tc.number Telephony_SmsMmsGtest_SmsPduBuffer_0001
161 * @tc.name Test SmsPduBuffer
162 * @tc.desc Function test
163 */
164 HWTEST_F(BranchCdmaSmsTest, SmsPduBuffer_0001, Function | MediumTest | Level1)
165 {
166 auto buffer = std::make_shared<SmsPduBuffer>();
167 EXPECT_TRUE(buffer->IsEmpty());
168 EXPECT_EQ(buffer->GetIndex(), 0);
169 EXPECT_FALSE(buffer->SetIndex(1));
170 EXPECT_EQ(buffer->GetIndex(), 0);
171 EXPECT_TRUE(buffer->SetIndex(0));
172 EXPECT_EQ(buffer->GetIndex(), 0);
173 EXPECT_EQ(buffer->MoveForward(), 0);
174 EXPECT_EQ(buffer->MoveForward(1), 0);
175 EXPECT_EQ(buffer->MoveBack(), 0);
176 EXPECT_EQ(buffer->MoveBack(1), 0);
177 EXPECT_EQ(buffer->MoveBack(2), 0);
178 EXPECT_EQ(buffer->MoveForward(0), 0);
179 EXPECT_EQ(buffer->SkipBits(), 0);
180 }
181
182 /**
183 * @tc.number Telephony_SmsMmsGtest_SmsReadBuffer_0001
184 * @tc.name Test SmsReadBuffer
185 * @tc.desc Function test
186 */
187 HWTEST_F(BranchCdmaSmsTest, SmsReadBuffer_0001, Function | MediumTest | Level1)
188 {
189 std::string pduHex = "0000021002";
190 std::string pdu = StringUtils::HexToString(pduHex);
191 uint16_t pduLen = pdu.length();
192
193 auto buffer = std::make_shared<SmsReadBuffer>(pdu);
194 EXPECT_FALSE(buffer->IsEmpty());
195 EXPECT_EQ(buffer->GetIndex(), 0);
196 EXPECT_TRUE(buffer->SetIndex(1));
197 EXPECT_EQ(buffer->GetIndex(), 1);
198 EXPECT_TRUE(buffer->SetIndex(0));
199 EXPECT_EQ(buffer->GetIndex(), 0);
200 EXPECT_TRUE(buffer->SetIndex(pduLen));
201 EXPECT_EQ(buffer->GetIndex(), pduLen);
202 EXPECT_FALSE(buffer->SetIndex(pduLen + 1));
203 EXPECT_EQ(buffer->GetIndex(), pduLen);
204
205 EXPECT_TRUE(buffer->SetIndex(0));
206 EXPECT_EQ(buffer->GetIndex(), 0);
207 EXPECT_EQ(buffer->MoveForward(), 0);
208 EXPECT_EQ(buffer->MoveForward(1), 1);
209 EXPECT_EQ(buffer->MoveBack(1), 2);
210 EXPECT_EQ(buffer->MoveForward(0), 1);
211 EXPECT_EQ(buffer->MoveBack(2), 1);
212 EXPECT_EQ(buffer->MoveBack(1), 1);
213 EXPECT_EQ(buffer->GetIndex(), 0);
214
215 EXPECT_TRUE(buffer->SetIndex(pduLen));
216 EXPECT_EQ(buffer->GetIndex(), pduLen);
217 EXPECT_EQ(buffer->MoveForward(), pduLen);
218 EXPECT_EQ(buffer->MoveForward(), pduLen);
219 EXPECT_EQ(buffer->MoveBack(1), pduLen);
220 EXPECT_EQ(buffer->GetIndex(), pduLen - 1);
221
222 uint16_t index = buffer->GetIndex();
223 EXPECT_EQ(buffer->SkipBits(), index);
224 }
225
226 /**
227 * @tc.number Telephony_SmsMmsGtest_SmsReadBuffer_0002
228 * @tc.name Test SmsReadBuffer
229 * @tc.desc Function test
230 */
231 HWTEST_F(BranchCdmaSmsTest, SmsReadBuffer_0002, Function | MediumTest | Level1)
232 {
233 std::string pduHex = "00000210020000021002";
234 std::string pdu = StringUtils::HexToString(pduHex);
235 uint16_t pduLen = pdu.length();
236
237 auto buffer = std::make_shared<SmsReadBuffer>(pdu);
238 EXPECT_FALSE(buffer->IsEmpty());
239
240 buffer->SetIndex(0);
241 uint8_t v = 0;
242 for (uint16_t i = 0; i < pduLen; i++) {
243 EXPECT_TRUE(buffer->ReadByte(v));
244 }
245 EXPECT_FALSE(buffer->ReadByte(v));
246
247 buffer->SetIndex(0);
248 uint16_t v2 = 0;
249 uint16_t index = buffer->GetIndex();
250 do {
251 EXPECT_TRUE(buffer->ReadWord(v2));
252 index += 2;
253 EXPECT_EQ(buffer->GetIndex(), index);
254 } while (index < pduLen);
255 index = buffer->GetIndex();
256 EXPECT_FALSE(buffer->ReadWord(v2));
257 EXPECT_EQ(buffer->GetIndex(), index);
258 }
259
260 /**
261 * @tc.number Telephony_SmsMmsGtest_SmsReadBuffer_0003
262 * @tc.name Test SmsReadBuffer
263 * @tc.desc Function test
264 */
265 HWTEST_F(BranchCdmaSmsTest, SmsReadBuffer_0003, Function | MediumTest | Level1)
266 {
267 std::string pduHex = "00000210020000021002";
268 std::string pdu = StringUtils::HexToString(pduHex);
269 uint16_t pduLen = pdu.length();
270
271 auto buffer = std::make_shared<SmsReadBuffer>(pdu);
272 EXPECT_FALSE(buffer->IsEmpty());
273
274 buffer->SetIndex(0);
275 uint32_t bitLen = pduLen * BIT8;
276 uint8_t v = 0;
277 for (uint32_t i = 0; i < bitLen; i++) {
278 EXPECT_TRUE(buffer->ReadBits(v));
279 }
280 EXPECT_FALSE(buffer->ReadBits(v));
281 uint16_t index = buffer->GetIndex();
282 EXPECT_EQ(buffer->SkipBits(), index);
283
284 buffer->SetIndex(0);
285 uint8_t bits = BIT0;
286 uint32_t bitIndex = 0;
287 do {
288 bits++;
289 if (bits > BIT8) {
290 EXPECT_FALSE(buffer->ReadBits(v, bits));
291 if (bits == 10) {
292 bits = BIT0;
293 }
294 } else {
295 if (bitIndex + bits <= bitLen) {
296 bitIndex += bits;
297 EXPECT_TRUE(buffer->ReadBits(v, bits));
298 } else {
299 EXPECT_FALSE(buffer->ReadBits(v, bits));
300 }
301 }
302 } while (bitIndex < bitLen);
303
304 buffer->SetIndex(0);
305 index = buffer->GetIndex();
306 EXPECT_EQ(buffer->SkipBits(), index);
307 EXPECT_TRUE(buffer->ReadBits(v));
308 EXPECT_FALSE(buffer->SetIndex(0));
309 EXPECT_EQ(buffer->SkipBits(), index + 1);
310 EXPECT_TRUE(buffer->SetIndex(0));
311 }
312
313 /**
314 * @tc.number Telephony_SmsMmsGtest_SmsReadBuffer_0004
315 * @tc.name Test SmsReadBuffer
316 * @tc.desc Function test
317 */
318 HWTEST_F(BranchCdmaSmsTest, SmsReadBuffer_0004, Function | MediumTest | Level1)
319 {
320 auto buffer = std::make_shared<SmsReadBuffer>(StringUtils::HexToString("00"));
321 EXPECT_TRUE(buffer->IsEmpty());
322 buffer = std::make_shared<SmsReadBuffer>(StringUtils::HexToString("0000"));
323 EXPECT_FALSE(buffer->IsEmpty());
324 buffer = std::make_shared<SmsReadBuffer>(StringUtils::HexToString("000002"));
325 EXPECT_FALSE(buffer->IsEmpty());
326 buffer = std::make_shared<SmsReadBuffer>(StringUtils::HexToString("0000021002"));
327 EXPECT_FALSE(buffer->IsEmpty());
328 std::string s1(PDU_BUFFER_MAX_SIZE * 2, '0');
329 buffer = std::make_shared<SmsReadBuffer>(StringUtils::HexToString(s1));
330 EXPECT_FALSE(buffer->IsEmpty());
331 std::string s2((PDU_BUFFER_MAX_SIZE + 1) * 2, '0');
332 buffer = std::make_shared<SmsReadBuffer>(StringUtils::HexToString(s2));
333 EXPECT_FALSE(buffer->IsEmpty());
334 std::string s3((PDU_BUFFER_MAX_SIZE + 2) * 2, '0');
335 buffer = std::make_shared<SmsReadBuffer>(StringUtils::HexToString(s3));
336 EXPECT_TRUE(buffer->IsEmpty());
337 }
338
339 /**
340 * @tc.number Telephony_SmsMmsGtest_SmsWriteBuffer_0001
341 * @tc.name Test SmsWriteBuffer
342 * @tc.desc Function test
343 */
344 HWTEST_F(BranchCdmaSmsTest, SmsWriteBuffer_0001, Function | MediumTest | Level1)
345 {
346 uint16_t pduLen = PDU_BUFFER_MAX_SIZE + 1;
347 auto buffer = std::make_shared<SmsWriteBuffer>();
348 EXPECT_FALSE(buffer->IsEmpty());
349 EXPECT_EQ(buffer->GetIndex(), 0);
350 EXPECT_TRUE(buffer->SetIndex(1));
351 EXPECT_EQ(buffer->GetIndex(), 1);
352 EXPECT_TRUE(buffer->SetIndex(0));
353 EXPECT_EQ(buffer->GetIndex(), 0);
354 EXPECT_TRUE(buffer->SetIndex(pduLen));
355 EXPECT_EQ(buffer->GetIndex(), pduLen);
356 EXPECT_FALSE(buffer->SetIndex(pduLen + 1));
357 EXPECT_EQ(buffer->GetIndex(), pduLen);
358
359 EXPECT_TRUE(buffer->SetIndex(0));
360 EXPECT_EQ(buffer->GetIndex(), 0);
361 EXPECT_EQ(buffer->MoveForward(), 0);
362 EXPECT_EQ(buffer->MoveForward(1), 1);
363 EXPECT_EQ(buffer->MoveBack(1), 2);
364 EXPECT_EQ(buffer->MoveForward(0), 1);
365 EXPECT_EQ(buffer->MoveBack(2), 1);
366 EXPECT_EQ(buffer->MoveBack(1), 1);
367 EXPECT_EQ(buffer->GetIndex(), 0);
368
369 EXPECT_TRUE(buffer->SetIndex(pduLen));
370 EXPECT_EQ(buffer->GetIndex(), pduLen);
371 EXPECT_EQ(buffer->MoveForward(), pduLen);
372 EXPECT_EQ(buffer->MoveForward(), pduLen);
373 EXPECT_EQ(buffer->MoveBack(1), pduLen);
374 EXPECT_EQ(buffer->GetIndex(), pduLen - 1);
375
376 uint16_t index = buffer->GetIndex();
377 EXPECT_EQ(buffer->SkipBits(), index);
378 }
379
380 /**
381 * @tc.number Telephony_SmsMmsGtest_SmsWriteBuffer_0002
382 * @tc.name Test SmsWriteBuffer
383 * @tc.desc Function test
384 */
385 HWTEST_F(BranchCdmaSmsTest, SmsWriteBuffer_0002, Function | MediumTest | Level1)
386 {
387 uint16_t pduLen = PDU_BUFFER_MAX_SIZE + 1;
388 auto buffer = std::make_shared<SmsWriteBuffer>();
389 EXPECT_FALSE(buffer->IsEmpty());
390
391 EXPECT_EQ(buffer->GetPduBuffer(), nullptr);
392
393 buffer->SetIndex(0);
394 uint8_t v = 0;
395 for (uint16_t i = 0; i < pduLen; i++) {
396 v++;
397 if (v == 0xff) {
398 v = 0;
399 }
400 EXPECT_TRUE(buffer->InsertByte(v, i));
401 }
402 EXPECT_FALSE(buffer->InsertByte(v, pduLen));
403
404 buffer->SetIndex(0);
405 for (uint16_t i = 0; i < pduLen; i++) {
406 v++;
407 if (v == 0xff) {
408 v = 0;
409 }
410 EXPECT_TRUE(buffer->WriteByte(v));
411 EXPECT_EQ(buffer->GetIndex(), i + 1);
412 }
413 uint16_t index = buffer->GetIndex();
414 EXPECT_FALSE(buffer->WriteByte(v));
415 EXPECT_EQ(buffer->GetIndex(), index);
416
417 buffer->SetIndex(1);
418 std::unique_ptr<std::vector<uint8_t>> data = buffer->GetPduBuffer();
419 EXPECT_NE(data, nullptr);
420 EXPECT_EQ(data->size(), 1);
421
422 buffer->SetIndex(0);
423 uint16_t v2 = 0;
424 index = buffer->GetIndex();
425 do {
426 v2++;
427 if (v2 == 0xffff) {
428 v = 0;
429 }
430 EXPECT_TRUE(buffer->WriteWord(v2));
431 index += 2;
432 EXPECT_EQ(buffer->GetIndex(), index);
433 } while (index < pduLen);
434 index = buffer->GetIndex();
435 EXPECT_FALSE(buffer->WriteByte(v));
436 EXPECT_EQ(buffer->GetIndex(), index);
437 }
438
439 /**
440 * @tc.number Telephony_SmsMmsGtest_SmsWriteBuffer_0003
441 * @tc.name Test SmsWriteBuffer
442 * @tc.desc Function test
443 */
444 HWTEST_F(BranchCdmaSmsTest, SmsWriteBuffer_0003, Function | MediumTest | Level1)
445 {
446 uint16_t pduLen = PDU_BUFFER_MAX_SIZE + 1;
447 auto buffer = std::make_shared<SmsWriteBuffer>();
448 EXPECT_FALSE(buffer->IsEmpty());
449
450 buffer->SetIndex(0);
451 uint32_t bitLen = pduLen * BIT8;
452 uint8_t v = 0;
453 for (uint32_t i = 0; i < bitLen; i++) {
454 EXPECT_TRUE(buffer->WriteBits(v));
455 }
456 EXPECT_FALSE(buffer->WriteBits(v));
457 uint16_t index = buffer->GetIndex();
458 EXPECT_EQ(buffer->SkipBits(), index);
459
460 buffer->SetIndex(0);
461 uint8_t bits = BIT0;
462 uint32_t bitIndex = 0;
463 do {
464 bits++;
465 if (bits > BIT8) {
466 EXPECT_FALSE(buffer->WriteBits(v, bits));
467 if (bits == 10) {
468 bits = BIT0;
469 }
470 } else {
471 if (bitIndex + bits <= bitLen) {
472 bitIndex += bits;
473 EXPECT_TRUE(buffer->WriteBits(v, bits));
474 } else {
475 EXPECT_FALSE(buffer->WriteBits(v, bits));
476 }
477 }
478 } while (bitIndex < bitLen);
479
480 buffer->SetIndex(0);
481 index = buffer->GetIndex();
482 EXPECT_EQ(buffer->SkipBits(), index);
483 EXPECT_TRUE(buffer->WriteBits(v));
484 EXPECT_FALSE(buffer->SetIndex(0));
485 EXPECT_EQ(buffer->SkipBits(), index + 1);
486 EXPECT_TRUE(buffer->SetIndex(0));
487
488 buffer->SetIndex(0);
489 EXPECT_EQ(buffer->GetPduBuffer(), nullptr);
490 buffer->SetIndex(1);
491 index = buffer->GetIndex();
492 EXPECT_EQ(buffer->GetPduBuffer()->size(), index);
493 EXPECT_TRUE(buffer->WriteBits(v));
494 EXPECT_EQ(buffer->GetPduBuffer(), nullptr);
495 EXPECT_EQ(buffer->SkipBits(), index + 1);
496 EXPECT_EQ(buffer->GetPduBuffer()->size(), static_cast<unsigned long>(index + 1));
497 }
498
499 /**
500 * @tc.number Telephony_SmsMmsGtest_CdmaSmsTransportMessage_0001
501 * @tc.name Test CdmaSmsTransportMessage
502 * @tc.desc Function test
503 */
504 HWTEST_F(BranchCdmaSmsTest, CdmaSmsTransportMessage_0001, Function | MediumTest | Level1)
505 {
506 auto message = std::make_shared<CdmaSmsTransportMessage>();
507 EXPECT_TRUE(message->IsEmpty());
508
509 auto buffer1 = std::make_shared<SmsWriteBuffer>();
510 EXPECT_FALSE(buffer1->IsEmpty());
511 EXPECT_FALSE(message->Encode(*buffer1));
512
513 std::stringstream ss;
514 ss.clear();
515 ss << static_cast<uint8_t>(CdmaTransportMsgType::P2P);
516 auto buffer2 = std::make_shared<SmsReadBuffer>(ss.str());
517 EXPECT_TRUE(buffer2->IsEmpty());
518 EXPECT_FALSE(message->Decode(*buffer2));
519
520 ss << CdmaSmsParameterRecord::TELESERVICE_ID;
521 auto buffer3 = std::make_shared<SmsReadBuffer>(ss.str());
522 EXPECT_FALSE(buffer3->IsEmpty());
523 EXPECT_FALSE(message->Decode(*buffer3));
524 }
525
526 /**
527 * @tc.number Telephony_SmsMmsGtest_CdmaSmsTransportMessage_0002
528 * @tc.name Test CdmaSmsTransportMessage
529 * @tc.desc Function test
530 */
531 HWTEST_F(BranchCdmaSmsTest, CdmaSmsTransportMessage_0002, Function | MediumTest | Level1)
532 {
533 do {
534 CdmaTransportMsg msg;
535 msg.type = CdmaTransportMsgType::RESERVED;
536 auto message = CdmaSmsTransportMessage::CreateTransportMessage(msg);
537 EXPECT_EQ(message, nullptr);
538 } while (0);
539
540 uint8_t type = 0;
541 for (type = 0; type < static_cast<uint8_t>(CdmaTransportMsgType::RESERVED); type++) {
542 CdmaTransportMsg msg;
543 msg.type = CdmaTransportMsgType(type);
544 auto message = CdmaSmsTransportMessage::CreateTransportMessage(msg);
545 EXPECT_NE(message, nullptr);
546 auto buffer = std::make_shared<SmsWriteBuffer>();
547 EXPECT_FALSE(buffer->IsEmpty());
548 message->Encode(*buffer);
549 SmsReadBuffer rBuffer(StringUtils::HexToString("000000"));
550 EXPECT_FALSE(message->Decode(rBuffer));
551 }
552
553 CdmaTransportMsg msg;
554 std::vector<std::string> pduHex;
555 pduHex.clear();
556 pduHex.push_back("00");
557 pduHex.push_back("0300");
558 for (uint8_t i = 0; i < pduHex.size(); i++) {
559 SmsReadBuffer buffer(StringUtils::HexToString(pduHex[i]));
560 auto message = CdmaSmsTransportMessage::CreateTransportMessage(msg, buffer);
561 EXPECT_EQ(message, nullptr);
562 }
563
564 pduHex.clear();
565 pduHex.push_back("0000");
566 pduHex.push_back("0100");
567 pduHex.push_back("0200");
568 for (uint8_t i = 0; i < pduHex.size(); i++) {
569 SmsReadBuffer buffer(StringUtils::HexToString(pduHex[i]));
570 auto message = CdmaSmsTransportMessage::CreateTransportMessage(msg, buffer);
571 EXPECT_NE(message, nullptr);
572 EXPECT_FALSE(message->Decode(buffer));
573 }
574
575 pduHex.clear();
576 pduHex.push_back("0000021002");
577 pduHex.push_back("0101020000");
578 pduHex.push_back("0207020000");
579 for (uint8_t i = 0; i < pduHex.size(); i++) {
580 SmsReadBuffer buffer(StringUtils::HexToString(pduHex[i]));
581 auto message = CdmaSmsTransportMessage::CreateTransportMessage(msg, buffer);
582 EXPECT_NE(message, nullptr);
583 EXPECT_TRUE(message->Decode(buffer));
584 }
585 }
586
587 /**
588 * @tc.number Telephony_SmsMmsGtest_CdmaSmsTransportMessage_0003
589 * @tc.name Test CdmaSmsTransportMessage
590 * @tc.desc Function test
591 */
592 HWTEST_F(BranchCdmaSmsTest, CdmaSmsTransportMessage_0003, Function | MediumTest | Level1)
593 {
594 auto message = std::make_shared<CdmaSmsTransportMessage>();
595 EXPECT_TRUE(message->IsEmpty());
596
597 auto buffer1 = std::make_shared<SmsWriteBuffer>();
598 EXPECT_FALSE(buffer1->IsEmpty());
599 EXPECT_FALSE(message->Encode(*buffer1));
600
601 std::stringstream ss;
602 ss.clear();
603 ss << static_cast<uint8_t>(CdmaTransportMsgType::P2P);
604 ss << CdmaSmsParameterRecord::TELESERVICE_ID;
605 auto buffer2 = std::make_shared<SmsReadBuffer>(ss.str());
606 EXPECT_FALSE(buffer2->IsEmpty());
607 EXPECT_FALSE(message->Decode(*buffer2));
608
609 CdmaTransportMsg msg;
610 msg.type = CdmaTransportMsgType::P2P;
611 auto message2 = CdmaSmsTransportMessage::CreateTransportMessage(msg);
612 EXPECT_NE(message2, nullptr);
613 auto message3 = CdmaSmsTransportMessage::CreateTransportMessage(msg, *buffer2);
614 EXPECT_NE(message3, nullptr);
615 auto message4 = std::make_shared<CdmaSmsP2pMessage>(msg.data.p2p);
616 EXPECT_NE(message4, nullptr);
617 auto message5 = std::make_shared<CdmaSmsP2pMessage>(msg.data.p2p, *buffer2);
618 EXPECT_NE(message5, nullptr);
619 auto message6 = std::make_shared<CdmaSmsBroadcastMessage>(msg.data.broadcast);
620 EXPECT_NE(message6, nullptr);
621 auto message7 = std::make_shared<CdmaSmsBroadcastMessage>(msg.data.broadcast, *buffer2);
622 EXPECT_NE(message7, nullptr);
623 auto message8 = std::make_shared<CdmaSmsAckMessage>(msg.data.ack);
624 EXPECT_NE(message8, nullptr);
625 auto message9 = std::make_shared<CdmaSmsAckMessage>(msg.data.ack, *buffer2);
626 EXPECT_NE(message9, nullptr);
627 }
628
629 /**
630 * @tc.number Telephony_SmsMmsGtest_CdmaSmsTeleserviceMessage_0001
631 * @tc.name Test CdmaSmsTeleserviceMessage
632 * @tc.desc Function test
633 */
634 HWTEST_F(BranchCdmaSmsTest, CdmaSmsTeleserviceMessage_0001, Function | MediumTest | Level1)
635 {
636 SmsWriteBuffer wBuffer;
637 SmsReadBuffer rBuffer(StringUtils::HexToString("0003200640"));
638 auto message = std::make_shared<CdmaSmsTeleserviceMessage>();
639 EXPECT_NE(message, nullptr);
640 wBuffer.SetIndex(PDU_BUFFER_MAX_SIZE);
641 EXPECT_FALSE(message->Encode(wBuffer));
642 EXPECT_FALSE(message->Decode(rBuffer));
643 EXPECT_EQ(CdmaSmsTeleserviceMessage::GetMessageType(rBuffer), CdmaSmsTeleserviceMessage::SUBMIT);
644
645 wBuffer.SetIndex(PDU_BUFFER_MAX_SIZE);
646 CdmaTransportMsg msg;
647 auto message1 = std::make_shared<CdmaSmsSubmitMessage>(msg.data.p2p.telesvcMsg.data.submit);
648 EXPECT_NE(message1, nullptr);
649 EXPECT_FALSE(message1->Encode(wBuffer));
650 EXPECT_FALSE(message1->Decode(rBuffer));
651 auto message2 = std::make_shared<CdmaSmsSubmitMessage>(msg.data.p2p.telesvcMsg.data.submit, rBuffer);
652 EXPECT_NE(message2, nullptr);
653 EXPECT_FALSE(message2->Encode(wBuffer));
654 EXPECT_FALSE(message2->Decode(rBuffer));
655 auto message3 = std::make_shared<CdmaSmsCancelMessage>(msg.data.p2p.telesvcMsg.data.cancel);
656 EXPECT_NE(message3, nullptr);
657 EXPECT_FALSE(message3->Encode(wBuffer));
658 EXPECT_FALSE(message3->Decode(rBuffer));
659 auto message4 = std::make_shared<CdmaSmsDeliverReport>(msg.data.p2p.telesvcMsg.data.report);
660 EXPECT_NE(message4, nullptr);
661 EXPECT_FALSE(message4->Encode(wBuffer));
662 EXPECT_FALSE(message4->Decode(rBuffer));
663 auto message5 = std::make_shared<CdmaSmsDeliverMessage>(msg.data.p2p.telesvcMsg.data.deliver, rBuffer);
664 EXPECT_NE(message5, nullptr);
665 EXPECT_FALSE(message5->Encode(wBuffer));
666 EXPECT_FALSE(message5->Decode(rBuffer));
667 auto message6 = std::make_shared<CdmaSmsDeliveryAck>(msg.data.p2p.telesvcMsg.data.deliveryAck, rBuffer);
668 EXPECT_NE(message6, nullptr);
669 EXPECT_FALSE(message6->Encode(wBuffer));
670 EXPECT_FALSE(message6->Decode(rBuffer));
671 auto message7 = std::make_shared<CdmaSmsUserAck>(msg.data.p2p.telesvcMsg.data.userAck, rBuffer);
672 EXPECT_NE(message7, nullptr);
673 EXPECT_FALSE(message7->Encode(wBuffer));
674 EXPECT_FALSE(message7->Decode(rBuffer));
675 auto message8 = std::make_shared<CdmaSmsReadAck>(msg.data.p2p.telesvcMsg.data.readAck, rBuffer);
676 EXPECT_NE(message8, nullptr);
677 EXPECT_FALSE(message8->Encode(wBuffer));
678 EXPECT_FALSE(message8->Decode(rBuffer));
679 }
680
681 /**
682 * @tc.number Telephony_SmsMmsGtest_CdmaSmsParameterRecord_0001
683 * @tc.name Test CdmaSmsParameterRecord
684 * @tc.desc Function test
685 */
686 HWTEST_F(BranchCdmaSmsTest, CdmaSmsParameterRecord_0001, Function | MediumTest | Level1)
687 {
688 auto initValue = static_cast<uint16_t>(SmsTransTelsvcId::RESERVED);
689 auto testValue = static_cast<uint16_t>(SmsTransTelsvcId::CMT_95);
690 uint16_t v1 = testValue;
691 uint16_t v2 = initValue;
692
693 auto message1 = std::make_shared<CdmaSmsTeleserviceId>(v1);
694 SmsWriteBuffer wBuffer;
695 EXPECT_TRUE(message1->Encode(wBuffer));
696 auto buffer = wBuffer.GetPduBuffer();
697 EXPECT_GT(buffer->size(), static_cast<uint32_t>(0));
698 std::stringstream ss;
699 ss.clear();
700 for (uint16_t i = 0; i < buffer->size(); i++) {
701 ss << (*buffer)[i];
702 }
703 SmsReadBuffer rBuffer(ss.str());
704 auto message2 = std::make_shared<CdmaSmsTeleserviceId>(v2);
705 EXPECT_TRUE(message2->Decode(rBuffer));
706 EXPECT_EQ(v2, testValue);
707
708 wBuffer.SetIndex(PDU_BUFFER_MAX_SIZE);
709 EXPECT_FALSE(message1->Encode(wBuffer));
710 rBuffer.SetIndex(1);
711 EXPECT_FALSE(message1->Decode(rBuffer));
712 }
713
714 /**
715 * @tc.number Telephony_SmsMmsGtest_CdmaSmsParameterRecord_0002
716 * @tc.name Test CdmaSmsParameterRecord
717 * @tc.desc Function test
718 */
719 HWTEST_F(BranchCdmaSmsTest, CdmaSmsParameterRecord_0002, Function | MediumTest | Level1)
720 {
721 auto initValue = static_cast<uint16_t>(SmsServiceCtg::RESERVED);
722 auto testValue = static_cast<uint16_t>(SmsServiceCtg::CMAS_TEST);
723 uint16_t v1 = testValue;
724 uint16_t v2 = initValue;
725
726 auto message1 = std::make_shared<CdmaSmsServiceCategory>(v1);
727 SmsWriteBuffer wBuffer;
728 EXPECT_TRUE(message1->Encode(wBuffer));
729 auto buffer = wBuffer.GetPduBuffer();
730 EXPECT_GT(buffer->size(), 0);
731 std::stringstream ss;
732 ss.clear();
733 for (uint16_t i = 0; i < buffer->size(); i++) {
734 ss << (*buffer)[i];
735 }
736 SmsReadBuffer rBuffer(ss.str());
737 auto message2 = std::make_shared<CdmaSmsServiceCategory>(v2);
738 EXPECT_TRUE(message2->Decode(rBuffer));
739 EXPECT_EQ(v2, testValue);
740
741 wBuffer.SetIndex(PDU_BUFFER_MAX_SIZE);
742 EXPECT_FALSE(message1->Encode(wBuffer));
743 rBuffer.SetIndex(1);
744 EXPECT_FALSE(message1->Decode(rBuffer));
745 }
746
747 /**
748 * @tc.number Telephony_SmsMmsGtest_CdmaSmsParameterRecord_0003
749 * @tc.name Test CdmaSmsParameterRecord
750 * @tc.desc Function test
751 */
752 HWTEST_F(BranchCdmaSmsTest, CdmaSmsParameterRecord_0003, Function | MediumTest | Level1)
753 {
754 auto initValue = static_cast<uint32_t>(0);
755 auto testValue = static_cast<uint32_t>(5);
756 TransportAddr v1;
757 memset_s(&v1, sizeof(TransportAddr), 0x00, sizeof(TransportAddr));
758 v1.addrLen = testValue;
759 TransportAddr v2;
760 v2.addrLen = initValue;
761
762 auto message1 = std::make_shared<CdmaSmsAddressParameter>(v1, CdmaSmsParameterRecord::DEST_ADDRESS);
763 SmsWriteBuffer wBuffer;
764 EXPECT_TRUE(message1->Encode(wBuffer));
765 auto buffer = wBuffer.GetPduBuffer();
766 EXPECT_GT(buffer->size(), 0);
767 std::stringstream ss;
768 ss.clear();
769 for (uint16_t i = 0; i < buffer->size(); i++) {
770 ss << (*buffer)[i];
771 }
772 SmsReadBuffer rBuffer(ss.str());
773 auto message2 = std::make_shared<CdmaSmsAddressParameter>(v2, CdmaSmsParameterRecord::DEST_ADDRESS);
774 EXPECT_TRUE(message2->Decode(rBuffer));
775 EXPECT_EQ(v2.addrLen, testValue);
776
777 wBuffer.SetIndex(PDU_BUFFER_MAX_SIZE);
778 EXPECT_FALSE(message1->Encode(wBuffer));
779 rBuffer.SetIndex(1);
780 EXPECT_FALSE(message1->Decode(rBuffer));
781 }
782
783 /**
784 * @tc.number Telephony_SmsMmsGtest_CdmaSmsParameterRecord_0004
785 * @tc.name Test CdmaSmsParameterRecord
786 * @tc.desc Function test
787 */
788 HWTEST_F(BranchCdmaSmsTest, CdmaSmsParameterRecord_0004, Function | MediumTest | Level1)
789 {
790 auto initValue = static_cast<uint32_t>(0);
791 auto testValue = static_cast<uint32_t>(5);
792 TransportSubAddr v1;
793 memset_s(&v1, sizeof(TransportSubAddr), 0x00, sizeof(TransportSubAddr));
794 v1.addrLen = testValue;
795 TransportSubAddr v2;
796 v2.addrLen = initValue;
797
798 auto message1 = std::make_shared<CdmaSmsSubaddress>(v1, CdmaSmsParameterRecord::DEST_SUB_ADDRESS);
799 SmsWriteBuffer wBuffer;
800 EXPECT_TRUE(message1->Encode(wBuffer));
801 auto buffer = wBuffer.GetPduBuffer();
802 EXPECT_GT(buffer->size(), 0);
803 std::stringstream ss;
804 ss.clear();
805 for (uint16_t i = 0; i < buffer->size(); i++) {
806 ss << (*buffer)[i];
807 }
808 SmsReadBuffer rBuffer(ss.str());
809 auto message2 = std::make_shared<CdmaSmsSubaddress>(v2, CdmaSmsParameterRecord::DEST_SUB_ADDRESS);
810 EXPECT_TRUE(message2->Decode(rBuffer));
811 EXPECT_EQ(v2.addrLen, testValue);
812
813 wBuffer.SetIndex(PDU_BUFFER_MAX_SIZE);
814 EXPECT_FALSE(message1->Encode(wBuffer));
815 rBuffer.SetIndex(1);
816 EXPECT_FALSE(message1->Decode(rBuffer));
817 }
818
819 /**
820 * @tc.number Telephony_SmsMmsGtest_CdmaSmsParameterRecord_0005
821 * @tc.name Test CdmaSmsParameterRecord
822 * @tc.desc Function test
823 */
824 HWTEST_F(BranchCdmaSmsTest, CdmaSmsParameterRecord_0005, Function | MediumTest | Level1)
825 {
826 auto initValue = static_cast<uint8_t>(0);
827 auto testValue = static_cast<uint8_t>(5);
828 uint8_t v1 = testValue;
829 uint8_t v2 = initValue;
830
831 auto message1 = std::make_shared<CdmaSmsBearerReply>(v1);
832 SmsWriteBuffer wBuffer;
833 EXPECT_TRUE(message1->Encode(wBuffer));
834 auto buffer = wBuffer.GetPduBuffer();
835 EXPECT_GT(buffer->size(), 0);
836 std::stringstream ss;
837 ss.clear();
838 for (uint16_t i = 0; i < buffer->size(); i++) {
839 ss << (*buffer)[i];
840 }
841 SmsReadBuffer rBuffer(ss.str());
842 auto message2 = std::make_shared<CdmaSmsBearerReply>(v2);
843 EXPECT_TRUE(message2->Decode(rBuffer));
844 EXPECT_EQ(v2, testValue);
845
846 wBuffer.SetIndex(PDU_BUFFER_MAX_SIZE);
847 EXPECT_FALSE(message1->Encode(wBuffer));
848 rBuffer.SetIndex(1);
849 EXPECT_FALSE(message1->Decode(rBuffer));
850 }
851
852 /**
853 * @tc.number Telephony_SmsMmsGtest_CdmaSmsParameterRecord_0006
854 * @tc.name Test CdmaSmsParameterRecord
855 * @tc.desc Function test
856 */
857 HWTEST_F(BranchCdmaSmsTest, CdmaSmsParameterRecord_0006, Function | MediumTest | Level1)
858 {
859 auto initValue = TeleserviceMsgType::RESERVED;
860 auto testValue = TeleserviceMsgType::SUBMIT;
861 CdmaTeleserviceMsg v1;
862 memset_s(&v1, sizeof(CdmaTeleserviceMsg), 0x00, sizeof(CdmaTeleserviceMsg));
863 v1.type = testValue;
864 CdmaTeleserviceMsg v2;
865 v2.type = initValue;
866
867 auto message1 = std::make_shared<CdmaSmsBearerData>(v1);
868 SmsWriteBuffer wBuffer;
869 EXPECT_TRUE(message1->Encode(wBuffer));
870 auto buffer = wBuffer.GetPduBuffer();
871 EXPECT_GT(buffer->size(), 0);
872 std::stringstream ss;
873 ss.clear();
874 for (uint16_t i = 0; i < buffer->size(); i++) {
875 ss << (*buffer)[i];
876 }
877 SmsReadBuffer rBuffer(ss.str());
878 rBuffer.SetIndex(2);
879 auto message2 = std::make_shared<CdmaSmsBearerData>(v2, rBuffer);
880 rBuffer.SetIndex(0);
881 EXPECT_TRUE(message2->Decode(rBuffer));
882 EXPECT_EQ(v2.type, testValue);
883
884 wBuffer.SetIndex(PDU_BUFFER_MAX_SIZE);
885 EXPECT_FALSE(message1->Encode(wBuffer));
886 rBuffer.SetIndex(1);
887 EXPECT_FALSE(message1->Decode(rBuffer));
888 }
889
890 /**
891 * @tc.number Telephony_SmsMmsGtest_CdmaSmsParameterRecord_0007
892 * @tc.name Test CdmaSmsParameterRecord
893 * @tc.desc Function test
894 */
895 HWTEST_F(BranchCdmaSmsTest, CdmaSmsParameterRecord_0007, Function | MediumTest | Level1)
896 {
897 auto initValue = TransportErrClass::NONE;
898 auto testValue = TransportErrClass::TEMPORARY;
899 TransportCauseCode v1;
900 memset_s(&v1, sizeof(TransportCauseCode), 0x00, sizeof(TransportCauseCode));
901 v1.errorClass = testValue;
902 TransportCauseCode v2;
903 v2.errorClass = initValue;
904
905 auto message1 = std::make_shared<CdmaSmsCauseCodes>(v1);
906 SmsWriteBuffer wBuffer;
907 EXPECT_TRUE(message1->Encode(wBuffer));
908 auto buffer = wBuffer.GetPduBuffer();
909 EXPECT_GT(buffer->size(), 0);
910 std::stringstream ss;
911 ss.clear();
912 for (uint16_t i = 0; i < buffer->size(); i++) {
913 ss << (*buffer)[i];
914 }
915 SmsReadBuffer rBuffer(ss.str());
916 auto message2 = std::make_shared<CdmaSmsCauseCodes>(v2);
917 EXPECT_TRUE(message2->Decode(rBuffer));
918 EXPECT_EQ(v2.errorClass, testValue);
919
920 wBuffer.SetIndex(PDU_BUFFER_MAX_SIZE);
921 EXPECT_FALSE(message1->Encode(wBuffer));
922 rBuffer.SetIndex(1);
923 EXPECT_FALSE(message1->Decode(rBuffer));
924 }
925
926 /**
927 * @tc.number Telephony_SmsMmsGtest_CdmaSmsSubParameter_0001
928 * @tc.name Test CdmaSmsSubParameter
929 * @tc.desc Function test
930 */
931 HWTEST_F(BranchCdmaSmsTest, CdmaSmsSubParameter_0001, Function | MediumTest | Level1)
932 {
933 auto initValue = static_cast<uint8_t>(0);
934 auto testValue = static_cast<uint8_t>(5);
935 uint8_t v1 = testValue;
936 uint8_t v2 = initValue;
937
938 auto message1 = std::make_shared<CdmaSmsBaseParameter>(CdmaSmsSubParameter::USER_RESPONSE_CODE, v1);
939 SmsWriteBuffer wBuffer;
940 EXPECT_TRUE(message1->Encode(wBuffer));
941 auto buffer = wBuffer.GetPduBuffer();
942 EXPECT_GT(buffer->size(), 0);
943 std::stringstream ss;
944 ss.clear();
945 for (uint16_t i = 0; i < buffer->size(); i++) {
946 ss << (*buffer)[i];
947 }
948 SmsReadBuffer rBuffer(ss.str());
949 auto message2 = std::make_shared<CdmaSmsBaseParameter>(CdmaSmsSubParameter::USER_RESPONSE_CODE, v2);
950 EXPECT_TRUE(message2->Decode(rBuffer));
951 EXPECT_EQ(v2, testValue);
952
953 wBuffer.SetIndex(PDU_BUFFER_MAX_SIZE);
954 EXPECT_FALSE(message1->Encode(wBuffer));
955 rBuffer.SetIndex(1);
956 EXPECT_FALSE(message1->Decode(rBuffer));
957 }
958
959 /**
960 * @tc.number Telephony_SmsMmsGtest_CdmaSmsSubParameter_0002
961 * @tc.name Test CdmaSmsSubParameter
962 * @tc.desc Function test
963 */
964 HWTEST_F(BranchCdmaSmsTest, CdmaSmsSubParameter_0002, Function | MediumTest | Level1)
965 {
966 auto message1 = std::make_shared<CdmaSmsReservedParameter>(CdmaSmsSubParameter::USER_RESPONSE_CODE);
967 SmsWriteBuffer wBuffer;
968 EXPECT_TRUE(message1->Encode(wBuffer));
969 std::stringstream ss;
970 ss.clear();
971 ss << static_cast<uint8_t>(CdmaSmsSubParameter::USER_RESPONSE_CODE);
972 ss << static_cast<uint8_t>(0x01);
973 ss << static_cast<uint8_t>(0x00);
974 SmsReadBuffer rBuffer(ss.str());
975 auto message2 = std::make_shared<CdmaSmsReservedParameter>(CdmaSmsSubParameter::USER_RESPONSE_CODE);
976 EXPECT_TRUE(message2->Decode(rBuffer));
977
978 wBuffer.SetIndex(PDU_BUFFER_MAX_SIZE);
979 EXPECT_TRUE(message1->Encode(wBuffer));
980 rBuffer.SetIndex(1);
981 EXPECT_FALSE(message1->Decode(rBuffer));
982 }
983
984 /**
985 * @tc.number Telephony_SmsMmsGtest_CdmaSmsSubParameter_0003
986 * @tc.name Test CdmaSmsSubParameter
987 * @tc.desc Function test
988 */
989 HWTEST_F(BranchCdmaSmsTest, CdmaSmsSubParameter_0003, Function | MediumTest | Level1)
990 {
991 auto initValue = static_cast<uint16_t>(0x0);
992 auto testValue = static_cast<uint16_t>(0x10);
993 SmsTeleSvcMsgId v1;
994 memset_s(&v1, sizeof(SmsTeleSvcMsgId), 0x00, sizeof(SmsTeleSvcMsgId));
995 v1.msgId = testValue;
996 SmsTeleSvcMsgId v2;
997 v2.msgId = initValue;
998 uint8_t type = static_cast<uint8_t>(TeleserviceMsgType::SUBMIT);
999
1000 auto message1 = std::make_shared<CdmaSmsMessageId>(v1, type);
1001 SmsWriteBuffer wBuffer;
1002 EXPECT_TRUE(message1->Encode(wBuffer));
1003 auto buffer = wBuffer.GetPduBuffer();
1004 EXPECT_GT(buffer->size(), 0);
1005 std::stringstream ss;
1006 ss.clear();
1007 for (uint16_t i = 0; i < buffer->size(); i++) {
1008 ss << (*buffer)[i];
1009 }
1010 SmsReadBuffer rBuffer(ss.str());
1011 auto message2 = std::make_shared<CdmaSmsMessageId>(v2, type);
1012 EXPECT_TRUE(message2->Decode(rBuffer));
1013 EXPECT_EQ(message2->GetMessageType(), type);
1014 EXPECT_EQ(v2.msgId, testValue);
1015
1016 wBuffer.SetIndex(PDU_BUFFER_MAX_SIZE);
1017 EXPECT_FALSE(message1->Encode(wBuffer));
1018 rBuffer.SetIndex(1);
1019 EXPECT_FALSE(message1->Decode(rBuffer));
1020 }
1021
1022 /**
1023 * @tc.number Telephony_SmsMmsGtest_CdmaSmsSubParameter_0004
1024 * @tc.name Test CdmaSmsSubParameter
1025 * @tc.desc Function test
1026 */
1027 HWTEST_F(BranchCdmaSmsTest, CdmaSmsSubParameter_0004, Function | MediumTest | Level1)
1028 {
1029 auto initValue = SmsEncodingType::RESERVED;
1030 auto testValue = SmsEncodingType::ASCII_7BIT;
1031 SmsTeleSvcUserData v1;
1032 memset_s(&v1, sizeof(SmsTeleSvcUserData), 0x00, sizeof(SmsTeleSvcUserData));
1033 v1.encodeType = testValue;
1034 SmsTeleSvcUserData v2;
1035 v2.encodeType = initValue;
1036 bool headerInd = false;
1037
1038 auto message1 = std::make_shared<CdmaSmsUserData>(v1, headerInd);
1039 SmsWriteBuffer wBuffer;
1040 EXPECT_TRUE(message1->Encode(wBuffer));
1041 auto buffer = wBuffer.GetPduBuffer();
1042 EXPECT_GT(buffer->size(), 0);
1043 std::stringstream ss;
1044 ss.clear();
1045 for (uint16_t i = 0; i < buffer->size(); i++) {
1046 ss << (*buffer)[i];
1047 }
1048 SmsReadBuffer rBuffer(ss.str());
1049 auto message2 = std::make_shared<CdmaSmsUserData>(v2, headerInd);
1050 EXPECT_TRUE(message2->Decode(rBuffer));
1051
1052 EXPECT_EQ(v2.encodeType, testValue);
1053
1054 wBuffer.SetIndex(0);
1055 EXPECT_TRUE(message1->EncodeHeader7Bit(wBuffer));
1056 EXPECT_TRUE(message1->EncodeAscii7Bit(wBuffer));
1057 EXPECT_TRUE(message1->EncodeGsm7Bit(wBuffer));
1058 EXPECT_TRUE(message1->EncodeUnicode(wBuffer));
1059
1060 rBuffer.SetIndex(0);
1061 EXPECT_EQ(message2->DecodeHeader7Bit(rBuffer), 0);
1062 EXPECT_TRUE(message2->DecodeAscii7Bit(rBuffer, 0, 0));
1063 EXPECT_TRUE(message2->DecodeGsm7Bit(rBuffer, 0, 0));
1064
1065 wBuffer.SetIndex(PDU_BUFFER_MAX_SIZE);
1066 EXPECT_FALSE(message1->Encode(wBuffer));
1067 rBuffer.SetIndex(1);
1068 EXPECT_FALSE(message1->Decode(rBuffer));
1069 }
1070
1071 /**
1072 * @tc.number Telephony_SmsMmsGtest_CdmaSmsSubParameter_0005
1073 * @tc.name Test CdmaSmsSubParameter
1074 * @tc.desc Function test
1075 */
1076 HWTEST_F(BranchCdmaSmsTest, CdmaSmsSubParameter_0005, Function | MediumTest | Level1)
1077 {
1078 SmsTeleSvcCmasData v1;
1079 memset_s(&v1, sizeof(SmsTeleSvcCmasData), 0x00, sizeof(SmsTeleSvcCmasData));
1080 SmsTeleSvcCmasData v2;
1081
1082 auto message1 = std::make_shared<CdmaSmsCmasData>(v1);
1083 SmsWriteBuffer wBuffer;
1084 EXPECT_FALSE(message1->Encode(wBuffer));
1085
1086 std::stringstream ss;
1087 ss.clear();
1088 ss << static_cast<uint8_t>(CdmaSmsSubParameter::USER_DATA);
1089 uint8_t len = 100;
1090 ss << static_cast<uint8_t>(len);
1091 for (uint8_t i = 0; i < len; i++) {
1092 ss << static_cast<uint8_t>(0x00);
1093 }
1094 SmsReadBuffer rBuffer(ss.str());
1095 auto message2 = std::make_shared<CdmaSmsCmasData>(v2);
1096 EXPECT_TRUE(message2->Decode(rBuffer));
1097
1098 rBuffer.SetIndex(0);
1099 EXPECT_TRUE(message2->DecodeType0Data(rBuffer));
1100 EXPECT_TRUE(message2->DecodeType1Data(rBuffer));
1101 EXPECT_TRUE(message2->DecodeType2Data(rBuffer));
1102 EXPECT_TRUE(message2->DecodeAbsTime(rBuffer));
1103
1104 wBuffer.SetIndex(PDU_BUFFER_MAX_SIZE);
1105 EXPECT_FALSE(message1->Encode(wBuffer));
1106 rBuffer.SetIndex(1);
1107 EXPECT_FALSE(message1->Decode(rBuffer));
1108 }
1109
1110 /**
1111 * @tc.number Telephony_SmsMmsGtest_CdmaSmsSubParameter_0006
1112 * @tc.name Test CdmaSmsSubParameter
1113 * @tc.desc Function test
1114 */
1115 HWTEST_F(BranchCdmaSmsTest, CdmaSmsSubParameter_0006, Function | MediumTest | Level1)
1116 {
1117 auto initValue = static_cast<unsigned char>(0);
1118 auto testValue = static_cast<unsigned char>(5);
1119 SmsTimeAbs v1;
1120 memset_s(&v1, sizeof(SmsTimeAbs), 0x00, sizeof(SmsTimeAbs));
1121 v1.month = testValue;
1122 SmsTimeAbs v2;
1123 v2.month = initValue;
1124
1125 auto message1 = std::make_shared<CdmaSmsAbsoluteTime>(CdmaSmsSubParameter::VALIDITY_PERIOD_ABSOLUTE, v1);
1126 SmsWriteBuffer wBuffer;
1127 EXPECT_TRUE(message1->Encode(wBuffer));
1128 auto buffer = wBuffer.GetPduBuffer();
1129 EXPECT_GT(buffer->size(), 0);
1130 std::stringstream ss;
1131 ss.clear();
1132 for (uint16_t i = 0; i < buffer->size(); i++) {
1133 ss << (*buffer)[i];
1134 }
1135 SmsReadBuffer rBuffer(ss.str());
1136 auto message2 = std::make_shared<CdmaSmsAbsoluteTime>(CdmaSmsSubParameter::VALIDITY_PERIOD_ABSOLUTE, v2);
1137 EXPECT_TRUE(message2->Decode(rBuffer));
1138 EXPECT_EQ(v2.month, testValue);
1139
1140 wBuffer.SetIndex(PDU_BUFFER_MAX_SIZE);
1141 EXPECT_FALSE(message1->Encode(wBuffer));
1142 rBuffer.SetIndex(1);
1143 EXPECT_FALSE(message1->Decode(rBuffer));
1144 }
1145
1146 /**
1147 * @tc.number Telephony_SmsMmsGtest_CdmaSmsSubParameter_0007
1148 * @tc.name Test CdmaSmsSubParameter
1149 * @tc.desc Function test
1150 */
1151 HWTEST_F(BranchCdmaSmsTest, CdmaSmsSubParameter_0007, Function | MediumTest | Level1)
1152 {
1153 auto initValue = SmsPriorityIndicator::RESERVED;
1154 auto testValue = SmsPriorityIndicator::NORMAL;
1155 SmsPriorityIndicator v1 = testValue;
1156 SmsPriorityIndicator v2 = initValue;
1157
1158 auto message1 = std::make_shared<CdmaSmsPriorityInd>(v1);
1159 SmsWriteBuffer wBuffer;
1160 EXPECT_TRUE(message1->Encode(wBuffer));
1161 auto buffer = wBuffer.GetPduBuffer();
1162 EXPECT_GT(buffer->size(), 0);
1163 std::stringstream ss;
1164 ss.clear();
1165 for (uint16_t i = 0; i < buffer->size(); i++) {
1166 ss << (*buffer)[i];
1167 }
1168 SmsReadBuffer rBuffer(ss.str());
1169 auto message2 = std::make_shared<CdmaSmsPriorityInd>(v2);
1170 EXPECT_TRUE(message2->Decode(rBuffer));
1171 EXPECT_EQ(v2, testValue);
1172
1173 wBuffer.SetIndex(PDU_BUFFER_MAX_SIZE);
1174 EXPECT_FALSE(message1->Encode(wBuffer));
1175 rBuffer.SetIndex(1);
1176 EXPECT_FALSE(message1->Decode(rBuffer));
1177 }
1178
1179 /**
1180 * @tc.number Telephony_SmsMmsGtest_CdmaSmsSubParameter_0008
1181 * @tc.name Test CdmaSmsSubParameter
1182 * @tc.desc Function test
1183 */
1184 HWTEST_F(BranchCdmaSmsTest, CdmaSmsSubParameter_0008, Function | MediumTest | Level1)
1185 {
1186 auto initValue = SmsPrivacyIndicator::NOT_RESTRICTED;
1187 auto testValue = SmsPrivacyIndicator::RESTRICTED;
1188 SmsPrivacyIndicator v1 = testValue;
1189 SmsPrivacyIndicator v2 = initValue;
1190
1191 auto message1 = std::make_shared<CdmaSmsPrivacyInd>(v1);
1192 SmsWriteBuffer wBuffer;
1193 EXPECT_TRUE(message1->Encode(wBuffer));
1194 auto buffer = wBuffer.GetPduBuffer();
1195 EXPECT_GT(buffer->size(), 0);
1196 std::stringstream ss;
1197 ss.clear();
1198 for (uint16_t i = 0; i < buffer->size(); i++) {
1199 ss << (*buffer)[i];
1200 }
1201 SmsReadBuffer rBuffer(ss.str());
1202 auto message2 = std::make_shared<CdmaSmsPrivacyInd>(v2);
1203 EXPECT_TRUE(message2->Decode(rBuffer));
1204 EXPECT_EQ(v2, testValue);
1205
1206 wBuffer.SetIndex(PDU_BUFFER_MAX_SIZE);
1207 EXPECT_FALSE(message1->Encode(wBuffer));
1208 rBuffer.SetIndex(1);
1209 EXPECT_FALSE(message1->Decode(rBuffer));
1210 }
1211
1212 /**
1213 * @tc.number Telephony_SmsMmsGtest_CdmaSmsSubParameter_0009
1214 * @tc.name Test CdmaSmsSubParameter
1215 * @tc.desc Function test
1216 */
1217 HWTEST_F(BranchCdmaSmsTest, CdmaSmsSubParameter_0009, Function | MediumTest | Level1)
1218 {
1219 auto initValue = false;
1220 auto testValue = true;
1221 SmsReplyOption v1;
1222 memset_s(&v1, sizeof(SmsReplyOption), 0x00, sizeof(SmsReplyOption));
1223 v1.dak = testValue;
1224 SmsReplyOption v2;
1225 v2.dak = initValue;
1226
1227 auto message1 = std::make_shared<CdmaSmsReplyOption>(v1);
1228 SmsWriteBuffer wBuffer;
1229 EXPECT_TRUE(message1->Encode(wBuffer));
1230 auto buffer = wBuffer.GetPduBuffer();
1231 EXPECT_GT(buffer->size(), 0);
1232 std::stringstream ss;
1233 ss.clear();
1234 for (uint16_t i = 0; i < buffer->size(); i++) {
1235 ss << (*buffer)[i];
1236 }
1237 SmsReadBuffer rBuffer(ss.str());
1238 auto message2 = std::make_shared<CdmaSmsReplyOption>(v2);
1239 EXPECT_TRUE(message2->Decode(rBuffer));
1240 EXPECT_EQ(v2.dak, testValue);
1241
1242 wBuffer.SetIndex(PDU_BUFFER_MAX_SIZE);
1243 EXPECT_FALSE(message1->Encode(wBuffer));
1244 rBuffer.SetIndex(1);
1245 EXPECT_FALSE(message1->Decode(rBuffer));
1246 }
1247
1248 /**
1249 * @tc.number Telephony_SmsMmsGtest_CdmaSmsSubParameter_0010
1250 * @tc.name Test CdmaSmsSubParameter
1251 * @tc.desc Function test
1252 */
1253 HWTEST_F(BranchCdmaSmsTest, CdmaSmsSubParameter_0010, Function | MediumTest | Level1)
1254 {
1255 auto initValue = SmsAlertPriority::DEFAULT;
1256 auto testValue = SmsAlertPriority::HIGH;
1257 SmsAlertPriority v1 = testValue;
1258 SmsAlertPriority v2 = initValue;
1259
1260 auto message1 = std::make_shared<CdmaSmsAlertPriority>(v1);
1261 SmsWriteBuffer wBuffer;
1262 EXPECT_TRUE(message1->Encode(wBuffer));
1263 auto buffer = wBuffer.GetPduBuffer();
1264 EXPECT_GT(buffer->size(), 0);
1265 std::stringstream ss;
1266 ss.clear();
1267 for (uint16_t i = 0; i < buffer->size(); i++) {
1268 ss << (*buffer)[i];
1269 }
1270 SmsReadBuffer rBuffer(ss.str());
1271 auto message2 = std::make_shared<CdmaSmsAlertPriority>(v2);
1272 EXPECT_TRUE(message2->Decode(rBuffer));
1273 EXPECT_EQ(v2, testValue);
1274
1275 wBuffer.SetIndex(PDU_BUFFER_MAX_SIZE);
1276 EXPECT_FALSE(message1->Encode(wBuffer));
1277 rBuffer.SetIndex(1);
1278 EXPECT_FALSE(message1->Decode(rBuffer));
1279 }
1280
1281 /**
1282 * @tc.number Telephony_SmsMmsGtest_CdmaSmsSubParameter_0011
1283 * @tc.name Test CdmaSmsSubParameter
1284 * @tc.desc Function test
1285 */
1286 HWTEST_F(BranchCdmaSmsTest, CdmaSmsSubParameter_0011, Function | MediumTest | Level1)
1287 {
1288 auto initValue = SmsLanguageType::UNKNOWN;
1289 auto testValue = SmsLanguageType::CHINESE;
1290 SmsLanguageType v1 = testValue;
1291 SmsLanguageType v2 = initValue;
1292
1293 auto message1 = std::make_shared<CdmaSmsLanguageInd>(v1);
1294 SmsWriteBuffer wBuffer;
1295 EXPECT_TRUE(message1->Encode(wBuffer));
1296 auto buffer = wBuffer.GetPduBuffer();
1297 EXPECT_GT(buffer->size(), 0);
1298 std::stringstream ss;
1299 ss.clear();
1300 for (uint16_t i = 0; i < buffer->size(); i++) {
1301 ss << (*buffer)[i];
1302 }
1303 SmsReadBuffer rBuffer(ss.str());
1304 auto message2 = std::make_shared<CdmaSmsLanguageInd>(v2);
1305 EXPECT_TRUE(message2->Decode(rBuffer));
1306 EXPECT_EQ(v2, testValue);
1307
1308 wBuffer.SetIndex(PDU_BUFFER_MAX_SIZE);
1309 EXPECT_FALSE(message1->Encode(wBuffer));
1310 rBuffer.SetIndex(1);
1311 EXPECT_FALSE(message1->Decode(rBuffer));
1312 }
1313
1314 /**
1315 * @tc.number Telephony_SmsMmsGtest_CdmaSmsSubParameter_0012
1316 * @tc.name Test CdmaSmsSubParameter
1317 * @tc.desc Function test
1318 */
1319 HWTEST_F(BranchCdmaSmsTest, CdmaSmsSubParameter_0012, Function | MediumTest | Level1)
1320 {
1321 auto initValue = static_cast<uint32_t>(0);
1322 auto testValue = static_cast<uint32_t>(5);
1323 SmsTeleSvcAddr v1;
1324 memset_s(&v1, sizeof(SmsTeleSvcAddr), 0x00, sizeof(SmsTeleSvcAddr));
1325 v1.addrLen = testValue;
1326 SmsTeleSvcAddr v2;
1327 v2.addrLen = initValue;
1328
1329 auto message1 = std::make_shared<CdmaSmsCallbackNumber>(v1);
1330 SmsWriteBuffer wBuffer;
1331 EXPECT_TRUE(message1->Encode(wBuffer));
1332 auto buffer = wBuffer.GetPduBuffer();
1333 EXPECT_GT(buffer->size(), 0);
1334 std::stringstream ss;
1335 ss.clear();
1336 for (uint16_t i = 0; i < buffer->size(); i++) {
1337 ss << (*buffer)[i];
1338 }
1339 SmsReadBuffer rBuffer(ss.str());
1340 auto message2 = std::make_shared<CdmaSmsCallbackNumber>(v2);
1341 EXPECT_TRUE(message2->Decode(rBuffer));
1342 EXPECT_EQ(v2.addrLen, testValue);
1343
1344 wBuffer.SetIndex(PDU_BUFFER_MAX_SIZE);
1345 EXPECT_FALSE(message1->Encode(wBuffer));
1346 rBuffer.SetIndex(1);
1347 EXPECT_FALSE(message1->Decode(rBuffer));
1348 }
1349
1350 /**
1351 * @tc.number Telephony_SmsMmsGtest_CdmaSmsSubParameter_0013
1352 * @tc.name Test CdmaSmsSubParameter
1353 * @tc.desc Function test
1354 */
1355 HWTEST_F(BranchCdmaSmsTest, CdmaSmsSubParameter_0013, Function | MediumTest | Level1)
1356 {
1357 uint16_t initValue = 0;
1358 uint16_t testValue = 5;
1359 uint16_t v1 = testValue;
1360 uint16_t v2 = initValue;
1361
1362 auto message1 = std::make_shared<CdmaSmsDepositIndex>(v1);
1363 SmsWriteBuffer wBuffer;
1364 EXPECT_TRUE(message1->Encode(wBuffer));
1365 auto buffer = wBuffer.GetPduBuffer();
1366 EXPECT_GT(buffer->size(), 0);
1367 std::stringstream ss;
1368 ss.clear();
1369 for (uint16_t i = 0; i < buffer->size(); i++) {
1370 ss << (*buffer)[i];
1371 }
1372 SmsReadBuffer rBuffer(ss.str());
1373 auto message2 = std::make_shared<CdmaSmsDepositIndex>(v2);
1374 EXPECT_TRUE(message2->Decode(rBuffer));
1375 EXPECT_EQ(v2, testValue);
1376
1377 wBuffer.SetIndex(PDU_BUFFER_MAX_SIZE);
1378 EXPECT_FALSE(message1->Encode(wBuffer));
1379 rBuffer.SetIndex(1);
1380 EXPECT_FALSE(message1->Decode(rBuffer));
1381 }
1382
1383 /**
1384 * @tc.number Telephony_SmsMmsGtest_CdmaSmsSubParameter_0014
1385 * @tc.name Test CdmaSmsSubParameter
1386 * @tc.desc Function test
1387 */
1388 HWTEST_F(BranchCdmaSmsTest, CdmaSmsSubParameter_0014, Function | MediumTest | Level1)
1389 {
1390 auto initValue = SmsDisplayMode::RESERVED;
1391 auto testValue = SmsDisplayMode::DEFAULT_SETTING;
1392 SmsDisplayMode v1 = testValue;
1393 SmsDisplayMode v2 = initValue;
1394
1395 auto message1 = std::make_shared<CdmaSmsDisplayMode>(v1);
1396 SmsWriteBuffer wBuffer;
1397 EXPECT_TRUE(message1->Encode(wBuffer));
1398 auto buffer = wBuffer.GetPduBuffer();
1399 EXPECT_GT(buffer->size(), 0);
1400 std::stringstream ss;
1401 ss.clear();
1402 for (uint16_t i = 0; i < buffer->size(); i++) {
1403 ss << (*buffer)[i];
1404 }
1405 SmsReadBuffer rBuffer(ss.str());
1406 auto message2 = std::make_shared<CdmaSmsDisplayMode>(v2);
1407 EXPECT_TRUE(message2->Decode(rBuffer));
1408 EXPECT_EQ(v2, testValue);
1409
1410 wBuffer.SetIndex(PDU_BUFFER_MAX_SIZE);
1411 EXPECT_FALSE(message1->Encode(wBuffer));
1412 rBuffer.SetIndex(1);
1413 EXPECT_FALSE(message1->Decode(rBuffer));
1414 }
1415
1416 /**
1417 * @tc.number Telephony_SmsMmsGtest_CdmaSmsSubParameter_0015
1418 * @tc.name Test CdmaSmsSubParameter
1419 * @tc.desc Function test
1420 */
1421 HWTEST_F(BranchCdmaSmsTest, CdmaSmsSubParameter_0015, Function | MediumTest | Level1)
1422 {
1423 SmsEnhancedVmn v1;
1424 SmsEnhancedVmn v2;
1425
1426 auto message1 = std::make_shared<CdmaSmsEnhancedVmn>(v1);
1427 SmsWriteBuffer wBuffer;
1428 EXPECT_FALSE(message1->Encode(wBuffer));
1429 std::stringstream ss;
1430 ss.clear();
1431 ss << static_cast<uint8_t>(CdmaSmsSubParameter::ENHANCED_VMN);
1432 uint8_t len = 20;
1433 ss << static_cast<uint8_t>(len);
1434 for (uint8_t i = 0; i < len; i++) {
1435 ss << static_cast<uint8_t>(0x00);
1436 }
1437 SmsReadBuffer rBuffer(ss.str());
1438 auto message2 = std::make_shared<CdmaSmsEnhancedVmn>(v2);
1439 EXPECT_TRUE(message2->Decode(rBuffer));
1440
1441 rBuffer.SetIndex(0);
1442 EXPECT_TRUE(message2->DecodeHeader(rBuffer));
1443 EXPECT_TRUE(message2->DecodeAccessNumber(rBuffer));
1444 EXPECT_TRUE(message2->DecodeCallingPartyNumber(rBuffer));
1445
1446 wBuffer.SetIndex(PDU_BUFFER_MAX_SIZE);
1447 EXPECT_FALSE(message1->Encode(wBuffer));
1448 rBuffer.SetIndex(1);
1449 EXPECT_FALSE(message1->Decode(rBuffer));
1450 }
1451
1452 /**
1453 * @tc.number Telephony_SmsMmsGtest_CdmaSmsSubParameter_0016
1454 * @tc.name Test CdmaSmsSubParameter
1455 * @tc.desc Function test
1456 */
1457 HWTEST_F(BranchCdmaSmsTest, CdmaSmsSubParameter_0016, Function | MediumTest | Level1)
1458 {
1459 SmsEnhancedVmnAck v1;
1460 SmsEnhancedVmnAck v2;
1461
1462 auto message1 = std::make_shared<CdmaSmsEnhancedVmnAck>(v1);
1463 SmsWriteBuffer wBuffer;
1464 EXPECT_FALSE(message1->Encode(wBuffer));
1465 std::stringstream ss;
1466 ss.clear();
1467 ss << static_cast<uint8_t>(CdmaSmsSubParameter::ENHANCED_VMN_ACK);
1468 ss << static_cast<uint8_t>(0x05);
1469 ss << static_cast<uint8_t>(0x00);
1470 ss << static_cast<uint8_t>(0x00);
1471 ss << static_cast<uint8_t>(0x00);
1472 ss << static_cast<uint8_t>(0x00);
1473 ss << static_cast<uint8_t>(0x00);
1474 SmsReadBuffer rBuffer(ss.str());
1475 auto message2 = std::make_shared<CdmaSmsEnhancedVmnAck>(v2);
1476 EXPECT_TRUE(message2->Decode(rBuffer));
1477
1478 wBuffer.SetIndex(PDU_BUFFER_MAX_SIZE);
1479 EXPECT_FALSE(message1->Encode(wBuffer));
1480 rBuffer.SetIndex(1);
1481 EXPECT_FALSE(message1->Decode(rBuffer));
1482 }
1483
1484 /**
1485 * @tc.number Telephony_SmsMmsGtest_CdmaSmsSubParameter_0017
1486 * @tc.name Test CdmaSmsSubParameter
1487 * @tc.desc Function test
1488 */
1489 HWTEST_F(BranchCdmaSmsTest, CdmaSmsSubParameter_0017, Function | MediumTest | Level1)
1490 {
1491 SmsStatusCode v1;
1492 SmsStatusCode v2;
1493
1494 auto message1 = std::make_shared<CdmaSmsMessageStatus>(v1);
1495 SmsWriteBuffer wBuffer;
1496 EXPECT_FALSE(message1->Encode(wBuffer));
1497 std::stringstream ss;
1498 ss.clear();
1499 ss << static_cast<uint8_t>(CdmaSmsSubParameter::MESSAGE_STATUS);
1500 ss << static_cast<uint8_t>(0x01);
1501 ss << static_cast<uint8_t>(0x00);
1502 SmsReadBuffer rBuffer(ss.str());
1503 auto message2 = std::make_shared<CdmaSmsMessageStatus>(v2);
1504 EXPECT_TRUE(message2->Decode(rBuffer));
1505
1506 wBuffer.SetIndex(PDU_BUFFER_MAX_SIZE);
1507 EXPECT_FALSE(message1->Encode(wBuffer));
1508 rBuffer.SetIndex(1);
1509 EXPECT_FALSE(message1->Decode(rBuffer));
1510 }
1511
1512 /**
1513 * @tc.number Telephony_SmsMmsGtest_CdmaSmsSubParameter_0018
1514 * @tc.name Test CdmaSmsSubParameter
1515 * @tc.desc Function test
1516 */
1517 HWTEST_F(BranchCdmaSmsTest, CdmaSmsSubParameter_0018, Function | MediumTest | Level1)
1518 {
1519 uint32_t v1;
1520 uint32_t v2;
1521
1522 auto message1 = std::make_shared<CdmaSmsNumberMessages>(v1);
1523 SmsWriteBuffer wBuffer;
1524 EXPECT_FALSE(message1->Encode(wBuffer));
1525 std::stringstream ss;
1526 ss.clear();
1527 ss << static_cast<uint8_t>(CdmaSmsSubParameter::NUMBER_OF_MESSAGES);
1528 ss << static_cast<uint8_t>(0x01);
1529 ss << static_cast<uint8_t>(0x00);
1530 SmsReadBuffer rBuffer(ss.str());
1531 auto message2 = std::make_shared<CdmaSmsNumberMessages>(v2);
1532 EXPECT_TRUE(message2->Decode(rBuffer));
1533
1534 wBuffer.SetIndex(PDU_BUFFER_MAX_SIZE);
1535 EXPECT_FALSE(message1->Encode(wBuffer));
1536 rBuffer.SetIndex(1);
1537 EXPECT_FALSE(message1->Decode(rBuffer));
1538 }
1539
1540 /**
1541 * @tc.number Telephony_SmsMmsGtest_CdmaSmsSubParameter_0019
1542 * @tc.name Test CdmaSmsSubParameter
1543 * @tc.desc Function test
1544 */
1545 HWTEST_F(BranchCdmaSmsTest, CdmaSmsSubParameter_0019, Function | MediumTest | Level1)
1546 {
1547 auto testValue = static_cast<uint8_t>(5);
1548 uint8_t v1 = testValue;
1549 auto message1 = std::make_shared<CdmaSmsBaseParameter>(CdmaSmsSubParameter::USER_RESPONSE_CODE, v1);
1550 SmsWriteBuffer wBuffer;
1551 wBuffer.data_ = nullptr;
1552 EXPECT_FALSE(message1->Encode(wBuffer));
1553
1554 auto message2 = std::make_shared<CdmaSmsReservedParameter>(CdmaSmsSubParameter::USER_RESPONSE_CODE);
1555 EXPECT_FALSE(message2->Encode(wBuffer));
1556
1557 SmsTeleSvcMsgId v3;
1558 uint8_t type = static_cast<uint8_t>(TeleserviceMsgType::SUBMIT);
1559 auto message3 = std::make_shared<CdmaSmsMessageId>(v3, type);
1560 EXPECT_FALSE(message3->Encode(wBuffer));
1561
1562 SmsTimeAbs v4;
1563 auto message4 = std::make_shared<CdmaSmsAbsoluteTime>(CdmaSmsSubParameter::VALIDITY_PERIOD_ABSOLUTE, v4);
1564 EXPECT_FALSE(message4->Encode(wBuffer));
1565
1566 SmsPriorityIndicator v5 = SmsPriorityIndicator::NORMAL;;
1567 auto message5 = std::make_shared<CdmaSmsPriorityInd>(v5);
1568 EXPECT_FALSE(message5->Encode(wBuffer));
1569
1570 SmsPrivacyIndicator v6 = SmsPrivacyIndicator::RESTRICTED;
1571 auto message6 = std::make_shared<CdmaSmsPrivacyInd>(v6);
1572 EXPECT_FALSE(message6->Encode(wBuffer));
1573
1574 SmsReplyOption v7;
1575 auto message7 = std::make_shared<CdmaSmsReplyOption>(v7);
1576 EXPECT_FALSE(message7->Encode(wBuffer));
1577
1578 SmsTeleSvcUserData userData;
1579 memset_s(&userData, sizeof(SmsTeleSvcUserData), 0x00, sizeof(SmsTeleSvcUserData));
1580 userData.encodeType = SmsEncodingType::ASCII_7BIT;
1581 bool headerInd = false;
1582 auto message8 = std::make_shared<CdmaSmsUserData>(userData, headerInd);
1583 EXPECT_FALSE(message8->Encode(wBuffer));
1584 }
1585
1586 /**
1587 * @tc.number Telephony_SmsMmsGtest_CdmaSmsSubParameter_0020
1588 * @tc.name Test CdmaSmsSubParameter
1589 * @tc.desc Function test
1590 */
1591 HWTEST_F(BranchCdmaSmsTest, CdmaSmsSubParameter_0020, Function | MediumTest | Level1)
1592 {
1593 SmsAlertPriority v1 = SmsAlertPriority::HIGH;
1594
1595 auto message1 = std::make_shared<CdmaSmsAlertPriority>(v1);
1596 SmsWriteBuffer wBuffer;
1597 wBuffer.data_ = nullptr;
1598 EXPECT_FALSE(message1->Encode(wBuffer));
1599
1600 SmsLanguageType v2 = SmsLanguageType::CHINESE;
1601 auto message2 = std::make_shared<CdmaSmsLanguageInd>(v2);
1602 EXPECT_FALSE(message2->Encode(wBuffer));
1603
1604 SmsTeleSvcAddr v3;
1605 auto message3 = std::make_shared<CdmaSmsCallbackNumber>(v3);
1606 EXPECT_FALSE(message3->Encode(wBuffer));
1607
1608 uint16_t v4 = 1;
1609 auto message4 = std::make_shared<CdmaSmsDepositIndex>(v4);
1610 EXPECT_FALSE(message4->Encode(wBuffer));
1611
1612 SmsDisplayMode v5 = SmsDisplayMode::DEFAULT_SETTING;
1613 auto message5 = std::make_shared<CdmaSmsDisplayMode>(v5);
1614 EXPECT_FALSE(message5->Encode(wBuffer));
1615 }
1616
1617 /**
1618 * @tc.number Telephony_SmsMmsGtest_CdmaSmsParameterRecord_0008
1619 * @tc.name Test CdmaSmsParameterRecord
1620 * @tc.desc Function test
1621 */
1622 HWTEST_F(BranchCdmaSmsTest, CdmaSmsParameterRecord_0008, Function | MediumTest | Level1)
1623 {
1624 SmsWriteBuffer wBuf;
1625 wBuf.data_ = nullptr;
1626 SmsReadBuffer rBuf("");
1627 rBuf.data_ = nullptr;
1628 uint16_t cat = 0;
1629 CdmaSmsTeleserviceId teleserviceId(cat);
1630 EXPECT_FALSE(teleserviceId.Encode(wBuf));
1631 CdmaSmsServiceCategory category(cat);
1632 EXPECT_FALSE(category.Encode(wBuf));
1633 uint8_t seq = 0;
1634 CdmaSmsBearerReply reply(seq);
1635 EXPECT_FALSE(reply.Encode(wBuf));
1636 TransportCauseCode code;
1637 CdmaSmsCauseCodes codes(code);
1638 EXPECT_FALSE(codes.Encode(wBuf));
1639 TransportAddr addr;
1640 CdmaSmsAddressParameter parameter(addr, 0);
1641 EXPECT_FALSE(parameter.Encode(wBuf));
1642 EXPECT_FALSE(parameter.Decode(rBuf));
1643 parameter.isInvalid_ = false;
1644 EXPECT_FALSE(parameter.Encode(wBuf));
1645 EXPECT_FALSE(parameter.Decode(rBuf));
1646 EXPECT_FALSE(parameter.EncodeAddress(wBuf));
1647 EXPECT_FALSE(parameter.DecodeAddress(rBuf));
1648 TransportSubAddr subAddr;
1649 CdmaSmsSubaddress address(subAddr, 0);
1650 EXPECT_FALSE(address.Encode(wBuf));
1651 EXPECT_FALSE(address.Decode(rBuf));
1652 address.isInvalid_ = false;
1653 EXPECT_FALSE(address.Encode(wBuf));
1654 EXPECT_FALSE(address.Decode(rBuf));
1655 CdmaTeleserviceMsg msg;
1656 CdmaSmsBearerData data(msg);
1657 EXPECT_FALSE(data.Encode(wBuf));
1658 data.teleserviceMessage_ = nullptr;
1659 EXPECT_FALSE(data.Decode(rBuf));
1660 }
1661 } // namespace Telephony
1662 } // namespace OHOS
1663