* Copyright (C) 2023 Huawei Device Co., Ltd.
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#define private public
#define protected public
#include "cdma_sms_message.h"
#include "cdma_sms_parameter_record.h"
#include "cdma_sms_receive_handler.h"
#include "cdma_sms_transport_message.h"
#include "gtest/gtest.h"
namespace OHOS {
namespace Telephony {
using namespace testing::ext;
namespace {
const uint16_t PDU_BUFFER_MAX_SIZE = 0xFF;
const size_t DATA_LENGTH = 162;
const int32_t HEADER_LENGTH = 7;
}
class BranchCdmaSmsTest : public testing::Test {
public:
static void SetUpTestCase();
static void TearDownTestCase();
void SetUp();
void TearDown();
};
void BranchCdmaSmsTest::SetUpTestCase() {}
constexpr uint32_t EVENT_RELEASE_DATA_SHARE_HELPER = 10000;
void BranchCdmaSmsTest::TearDownTestCase()
{
DelayedSingleton<SmsPersistHelper>::GetInstance()->RemoveEvent(EVENT_RELEASE_DATA_SHARE_HELPER);
}
void BranchCdmaSmsTest::SetUp() {}
void BranchCdmaSmsTest::TearDown() {}
* @tc.number Telephony_BranchCdmaSmsTest_CdmaSmsMessage_0001
* @tc.name Test CdmaSmsMessage
* @tc.desc Function test
*/
HWTEST_F(BranchCdmaSmsTest, CdmaSmsMessage_0001, Function | MediumTest | Level1)
{
std::shared_ptr<CdmaSmsMessage> cdmaSmsMessage = std::make_shared<CdmaSmsMessage>();
string pduHex = "";
DataCodingScheme codingType;
CdmaP2PMsg p2pMsg;
p2pMsg.telesvcMsg.type = TeleserviceMsgType::DELIVER;
cdmaSmsMessage->AnalysisP2pMsg(p2pMsg);
p2pMsg.telesvcMsg.type = TeleserviceMsgType::DELIVERY_ACK;
cdmaSmsMessage->AnalysisP2pMsg(p2pMsg);
p2pMsg.telesvcMsg.type = TeleserviceMsgType::USER_ACK;
cdmaSmsMessage->AnalysisP2pMsg(p2pMsg);
p2pMsg.telesvcMsg.type = TeleserviceMsgType::READ_ACK;
cdmaSmsMessage->AnalysisP2pMsg(p2pMsg);
p2pMsg.telesvcMsg.type = TeleserviceMsgType::SUBMIT_REPORT;
cdmaSmsMessage->AnalysisP2pMsg(p2pMsg);
p2pMsg.telesvcMsg.type = TeleserviceMsgType::SUBMIT;
cdmaSmsMessage->AnalysisP2pMsg(p2pMsg);
p2pMsg.telesvcMsg.type = TeleserviceMsgType::MAX_VALUE;
cdmaSmsMessage->AnalysisP2pMsg(p2pMsg);
p2pMsg.teleserviceId = static_cast<uint16_t>(SmsTransTelsvcId::RESERVED);
cdmaSmsMessage->AnalysisP2pMsg(p2pMsg);
EXPECT_FALSE(cdmaSmsMessage->IsWapPushMsg());
EXPECT_EQ(cdmaSmsMessage->GetTransMsgType(), CdmaTransportMsgType::RESERVED);
EXPECT_EQ(cdmaSmsMessage->GetTransTeleService(), static_cast<uint16_t>(SmsTransTelsvcId::RESERVED));
EXPECT_FALSE(cdmaSmsMessage->PduAnalysis(pduHex));
cdmaSmsMessage->transMsg_ = std::make_unique<struct CdmaTransportMsg>();
cdmaSmsMessage->transMsg_->type = CdmaTransportMsgType::BROADCAST;
EXPECT_EQ(cdmaSmsMessage->GetTransTeleService(), static_cast<uint16_t>(SmsTransTelsvcId::RESERVED));
cdmaSmsMessage->transMsg_->type = CdmaTransportMsgType::P2P;
cdmaSmsMessage->transMsg_->data.p2p.teleserviceId = static_cast<uint16_t>(SmsTransTelsvcId::WAP);
EXPECT_TRUE(cdmaSmsMessage->IsWapPushMsg());
codingType = DataCodingScheme::DATA_CODING_7BIT;
EXPECT_EQ(cdmaSmsMessage->CovertEncodingType(codingType), SmsEncodingType::GSM7BIT);
codingType = DataCodingScheme::DATA_CODING_ASCII7BIT;
EXPECT_EQ(cdmaSmsMessage->CovertEncodingType(codingType), SmsEncodingType::ASCII_7BIT);
codingType = DataCodingScheme::DATA_CODING_8BIT;
EXPECT_EQ(cdmaSmsMessage->CovertEncodingType(codingType), SmsEncodingType::OCTET);
codingType = DataCodingScheme::DATA_CODING_UCS2;
EXPECT_EQ(cdmaSmsMessage->CovertEncodingType(codingType), SmsEncodingType::UNICODE);
codingType = DataCodingScheme::DATA_CODING_EUCKR;
EXPECT_EQ(cdmaSmsMessage->CovertEncodingType(codingType), SmsEncodingType::UNICODE);
EXPECT_FALSE(cdmaSmsMessage->PduAnalysis(pduHex));
pduHex = "12";
EXPECT_FALSE(cdmaSmsMessage->PduAnalysis(pduHex));
}
* @tc.number Telephony_BranchCdmaSmsTest_CdmaSmsMessage_0002
* @tc.name Test CdmaSmsMessage
* @tc.desc Function test
*/
HWTEST_F(BranchCdmaSmsTest, CdmaSmsMessage_0002, Function | MediumTest | Level1)
{
std::shared_ptr<CdmaSmsMessage> cdmaSmsMessage = std::make_shared<CdmaSmsMessage>();
CdmaP2PMsg p2pMsg;
TeleserviceDeliver deliver;
SmsTeleSvcUserData userData;
CdmaBroadCastMsg cbMsg;
SmsUDH header;
p2pMsg.teleserviceId = static_cast<uint16_t>(SmsTransTelsvcId::VMN_95);
p2pMsg.telesvcMsg.data.deliver.vmn.faxIncluded = true;
p2pMsg.telesvcMsg.data.deliver.userData.userData.length = 0;
deliver.displayMode = SmsDisplayMode::IMMEDIATE;
cdmaSmsMessage->AnalsisDeliverMwi(p2pMsg);
cdmaSmsMessage->AnalsisDeliverMsg(deliver);
userData.encodeType = SmsEncodingType::GSM7BIT;
cdmaSmsMessage->AnalsisUserData(userData);
userData.encodeType = SmsEncodingType::KOREAN;
cdmaSmsMessage->AnalsisUserData(userData);
userData.encodeType = SmsEncodingType::EUCKR;
cdmaSmsMessage->AnalsisUserData(userData);
userData.encodeType = SmsEncodingType::IA5;
cdmaSmsMessage->AnalsisUserData(userData);
userData.encodeType = SmsEncodingType::ASCII_7BIT;
cdmaSmsMessage->AnalsisUserData(userData);
userData.encodeType = SmsEncodingType::LATIN_HEBREW;
cdmaSmsMessage->AnalsisUserData(userData);
userData.encodeType = SmsEncodingType::LATIN;
cdmaSmsMessage->AnalsisUserData(userData);
userData.encodeType = SmsEncodingType::OCTET;
cdmaSmsMessage->AnalsisUserData(userData);
userData.encodeType = SmsEncodingType::SHIFT_JIS;
cdmaSmsMessage->AnalsisUserData(userData);
userData.encodeType = SmsEncodingType::RESERVED;
cdmaSmsMessage->AnalsisUserData(userData);
deliver.cmasData.dataLen = DATA_LENGTH;
cdmaSmsMessage->AnalsisCMASMsg(deliver);
cbMsg.telesvcMsg.type = TeleserviceMsgType::RESERVED;
cdmaSmsMessage->AnalysisCbMsg(cbMsg);
cbMsg.telesvcMsg.type = TeleserviceMsgType::DELIVER;
cdmaSmsMessage->AnalysisCbMsg(cbMsg);
cbMsg.serviceCtg = static_cast<uint16_t>(SmsServiceCtg::CMAS_AMBER);
cdmaSmsMessage->AnalysisCbMsg(cbMsg);
userData.userData.headerCnt = HEADER_LENGTH;
cdmaSmsMessage->bHeaderInd_ = true;
cdmaSmsMessage->AnalsisHeader(userData);
EXPECT_FALSE(cdmaSmsMessage->AddUserDataHeader(header));
}
* @tc.number Telephony_SmsMmsGtest_SmsPduBuffer_0001
* @tc.name Test SmsPduBuffer
* @tc.desc Function test
*/
HWTEST_F(BranchCdmaSmsTest, SmsPduBuffer_0001, Function | MediumTest | Level1)
{
auto buffer = std::make_shared<SmsPduBuffer>();
EXPECT_TRUE(buffer->IsEmpty());
EXPECT_EQ(buffer->GetIndex(), 0);
EXPECT_FALSE(buffer->SetIndex(1));
EXPECT_EQ(buffer->GetIndex(), 0);
EXPECT_TRUE(buffer->SetIndex(0));
EXPECT_EQ(buffer->GetIndex(), 0);
EXPECT_EQ(buffer->MoveForward(), 0);
EXPECT_EQ(buffer->MoveForward(1), 0);
EXPECT_EQ(buffer->MoveBack(), 0);
EXPECT_EQ(buffer->MoveBack(1), 0);
EXPECT_EQ(buffer->MoveBack(2), 0);
EXPECT_EQ(buffer->MoveForward(0), 0);
EXPECT_EQ(buffer->SkipBits(), 0);
}
* @tc.number Telephony_SmsMmsGtest_SmsReadBuffer_0001
* @tc.name Test SmsReadBuffer
* @tc.desc Function test
*/
HWTEST_F(BranchCdmaSmsTest, SmsReadBuffer_0001, Function | MediumTest | Level1)
{
std::string pduHex = "0000021002";
std::string pdu = StringUtils::HexToString(pduHex);
uint16_t pduLen = pdu.length();
auto buffer = std::make_shared<SmsReadBuffer>(pdu);
EXPECT_FALSE(buffer->IsEmpty());
EXPECT_EQ(buffer->GetIndex(), 0);
EXPECT_TRUE(buffer->SetIndex(1));
EXPECT_EQ(buffer->GetIndex(), 1);
EXPECT_TRUE(buffer->SetIndex(0));
EXPECT_EQ(buffer->GetIndex(), 0);
EXPECT_TRUE(buffer->SetIndex(pduLen));
EXPECT_EQ(buffer->GetIndex(), pduLen);
EXPECT_FALSE(buffer->SetIndex(pduLen + 1));
EXPECT_EQ(buffer->GetIndex(), pduLen);
EXPECT_TRUE(buffer->SetIndex(0));
EXPECT_EQ(buffer->GetIndex(), 0);
EXPECT_EQ(buffer->MoveForward(), 0);
EXPECT_EQ(buffer->MoveForward(1), 1);
EXPECT_EQ(buffer->MoveBack(1), 2);
EXPECT_EQ(buffer->MoveForward(0), 1);
EXPECT_EQ(buffer->MoveBack(2), 1);
EXPECT_EQ(buffer->MoveBack(1), 1);
EXPECT_EQ(buffer->GetIndex(), 0);
EXPECT_TRUE(buffer->SetIndex(pduLen));
EXPECT_EQ(buffer->GetIndex(), pduLen);
EXPECT_EQ(buffer->MoveForward(), pduLen);
EXPECT_EQ(buffer->MoveForward(), pduLen);
EXPECT_EQ(buffer->MoveBack(1), pduLen);
EXPECT_EQ(buffer->GetIndex(), pduLen - 1);
uint16_t index = buffer->GetIndex();
EXPECT_EQ(buffer->SkipBits(), index);
}
* @tc.number Telephony_SmsMmsGtest_SmsReadBuffer_0002
* @tc.name Test SmsReadBuffer
* @tc.desc Function test
*/
HWTEST_F(BranchCdmaSmsTest, SmsReadBuffer_0002, Function | MediumTest | Level1)
{
std::string pduHex = "00000210020000021002";
std::string pdu = StringUtils::HexToString(pduHex);
uint16_t pduLen = pdu.length();
auto buffer = std::make_shared<SmsReadBuffer>(pdu);
EXPECT_FALSE(buffer->IsEmpty());
buffer->SetIndex(0);
uint8_t v = 0;
for (uint16_t i = 0; i < pduLen; i++) {
EXPECT_TRUE(buffer->ReadByte(v));
}
EXPECT_FALSE(buffer->ReadByte(v));
buffer->SetIndex(0);
uint16_t v2 = 0;
uint16_t index = buffer->GetIndex();
do {
EXPECT_TRUE(buffer->ReadWord(v2));
index += 2;
EXPECT_EQ(buffer->GetIndex(), index);
} while (index < pduLen);
index = buffer->GetIndex();
EXPECT_FALSE(buffer->ReadWord(v2));
EXPECT_EQ(buffer->GetIndex(), index);
}
* @tc.number Telephony_SmsMmsGtest_SmsReadBuffer_0003
* @tc.name Test SmsReadBuffer
* @tc.desc Function test
*/
HWTEST_F(BranchCdmaSmsTest, SmsReadBuffer_0003, Function | MediumTest | Level1)
{
std::string pduHex = "00000210020000021002";
std::string pdu = StringUtils::HexToString(pduHex);
uint16_t pduLen = pdu.length();
auto buffer = std::make_shared<SmsReadBuffer>(pdu);
EXPECT_FALSE(buffer->IsEmpty());
buffer->SetIndex(0);
uint32_t bitLen = pduLen * BIT8;
uint8_t v = 0;
for (uint32_t i = 0; i < bitLen; i++) {
EXPECT_TRUE(buffer->ReadBits(v));
}
EXPECT_FALSE(buffer->ReadBits(v));
uint16_t index = buffer->GetIndex();
EXPECT_EQ(buffer->SkipBits(), index);
buffer->SetIndex(0);
uint8_t bits = BIT0;
uint32_t bitIndex = 0;
do {
bits++;
if (bits > BIT8) {
EXPECT_FALSE(buffer->ReadBits(v, bits));
if (bits == 10) {
bits = BIT0;
}
} else {
if (bitIndex + bits <= bitLen) {
bitIndex += bits;
EXPECT_TRUE(buffer->ReadBits(v, bits));
} else {
EXPECT_FALSE(buffer->ReadBits(v, bits));
}
}
} while (bitIndex < bitLen);
buffer->SetIndex(0);
index = buffer->GetIndex();
EXPECT_EQ(buffer->SkipBits(), index);
EXPECT_TRUE(buffer->ReadBits(v));
EXPECT_FALSE(buffer->SetIndex(0));
EXPECT_EQ(buffer->SkipBits(), index + 1);
EXPECT_TRUE(buffer->SetIndex(0));
}
* @tc.number Telephony_SmsMmsGtest_SmsReadBuffer_0004
* @tc.name Test SmsReadBuffer
* @tc.desc Function test
*/
HWTEST_F(BranchCdmaSmsTest, SmsReadBuffer_0004, Function | MediumTest | Level1)
{
auto buffer = std::make_shared<SmsReadBuffer>(StringUtils::HexToString("00"));
EXPECT_TRUE(buffer->IsEmpty());
buffer = std::make_shared<SmsReadBuffer>(StringUtils::HexToString("0000"));
EXPECT_FALSE(buffer->IsEmpty());
buffer = std::make_shared<SmsReadBuffer>(StringUtils::HexToString("000002"));
EXPECT_FALSE(buffer->IsEmpty());
buffer = std::make_shared<SmsReadBuffer>(StringUtils::HexToString("0000021002"));
EXPECT_FALSE(buffer->IsEmpty());
std::string s1(PDU_BUFFER_MAX_SIZE * 2, '0');
buffer = std::make_shared<SmsReadBuffer>(StringUtils::HexToString(s1));
EXPECT_FALSE(buffer->IsEmpty());
std::string s2((PDU_BUFFER_MAX_SIZE + 1) * 2, '0');
buffer = std::make_shared<SmsReadBuffer>(StringUtils::HexToString(s2));
EXPECT_FALSE(buffer->IsEmpty());
std::string s3((PDU_BUFFER_MAX_SIZE + 2) * 2, '0');
buffer = std::make_shared<SmsReadBuffer>(StringUtils::HexToString(s3));
EXPECT_TRUE(buffer->IsEmpty());
}
* @tc.number Telephony_SmsMmsGtest_SmsWriteBuffer_0001
* @tc.name Test SmsWriteBuffer
* @tc.desc Function test
*/
HWTEST_F(BranchCdmaSmsTest, SmsWriteBuffer_0001, Function | MediumTest | Level1)
{
uint16_t pduLen = PDU_BUFFER_MAX_SIZE + 1;
auto buffer = std::make_shared<SmsWriteBuffer>();
EXPECT_FALSE(buffer->IsEmpty());
EXPECT_EQ(buffer->GetIndex(), 0);
EXPECT_TRUE(buffer->SetIndex(1));
EXPECT_EQ(buffer->GetIndex(), 1);
EXPECT_TRUE(buffer->SetIndex(0));
EXPECT_EQ(buffer->GetIndex(), 0);
EXPECT_TRUE(buffer->SetIndex(pduLen));
EXPECT_EQ(buffer->GetIndex(), pduLen);
EXPECT_FALSE(buffer->SetIndex(pduLen + 1));
EXPECT_EQ(buffer->GetIndex(), pduLen);
EXPECT_TRUE(buffer->SetIndex(0));
EXPECT_EQ(buffer->GetIndex(), 0);
EXPECT_EQ(buffer->MoveForward(), 0);
EXPECT_EQ(buffer->MoveForward(1), 1);
EXPECT_EQ(buffer->MoveBack(1), 2);
EXPECT_EQ(buffer->MoveForward(0), 1);
EXPECT_EQ(buffer->MoveBack(2), 1);
EXPECT_EQ(buffer->MoveBack(1), 1);
EXPECT_EQ(buffer->GetIndex(), 0);
EXPECT_TRUE(buffer->SetIndex(pduLen));
EXPECT_EQ(buffer->GetIndex(), pduLen);
EXPECT_EQ(buffer->MoveForward(), pduLen);
EXPECT_EQ(buffer->MoveForward(), pduLen);
EXPECT_EQ(buffer->MoveBack(1), pduLen);
EXPECT_EQ(buffer->GetIndex(), pduLen - 1);
uint16_t index = buffer->GetIndex();
EXPECT_EQ(buffer->SkipBits(), index);
}
* @tc.number Telephony_SmsMmsGtest_SmsWriteBuffer_0002
* @tc.name Test SmsWriteBuffer
* @tc.desc Function test
*/
HWTEST_F(BranchCdmaSmsTest, SmsWriteBuffer_0002, Function | MediumTest | Level1)
{
uint16_t pduLen = PDU_BUFFER_MAX_SIZE + 1;
auto buffer = std::make_shared<SmsWriteBuffer>();
EXPECT_FALSE(buffer->IsEmpty());
EXPECT_EQ(buffer->GetPduBuffer(), nullptr);
buffer->SetIndex(0);
uint8_t v = 0;
for (uint16_t i = 0; i < pduLen; i++) {
v++;
if (v == 0xff) {
v = 0;
}
EXPECT_TRUE(buffer->InsertByte(v, i));
}
EXPECT_FALSE(buffer->InsertByte(v, pduLen));
buffer->SetIndex(0);
for (uint16_t i = 0; i < pduLen; i++) {
v++;
if (v == 0xff) {
v = 0;
}
EXPECT_TRUE(buffer->WriteByte(v));
EXPECT_EQ(buffer->GetIndex(), i + 1);
}
uint16_t index = buffer->GetIndex();
EXPECT_FALSE(buffer->WriteByte(v));
EXPECT_EQ(buffer->GetIndex(), index);
buffer->SetIndex(1);
std::unique_ptr<std::vector<uint8_t>> data = buffer->GetPduBuffer();
EXPECT_NE(data, nullptr);
EXPECT_EQ(data->size(), 1);
buffer->SetIndex(0);
uint16_t v2 = 0;
index = buffer->GetIndex();
do {
v2++;
if (v2 == 0xffff) {
v = 0;
}
EXPECT_TRUE(buffer->WriteWord(v2));
index += 2;
EXPECT_EQ(buffer->GetIndex(), index);
} while (index < pduLen);
index = buffer->GetIndex();
EXPECT_FALSE(buffer->WriteByte(v));
EXPECT_EQ(buffer->GetIndex(), index);
}
* @tc.number Telephony_SmsMmsGtest_SmsWriteBuffer_0003
* @tc.name Test SmsWriteBuffer
* @tc.desc Function test
*/
HWTEST_F(BranchCdmaSmsTest, SmsWriteBuffer_0003, Function | MediumTest | Level1)
{
uint16_t pduLen = PDU_BUFFER_MAX_SIZE + 1;
auto buffer = std::make_shared<SmsWriteBuffer>();
EXPECT_FALSE(buffer->IsEmpty());
buffer->SetIndex(0);
uint32_t bitLen = pduLen * BIT8;
uint8_t v = 0;
for (uint32_t i = 0; i < bitLen; i++) {
EXPECT_TRUE(buffer->WriteBits(v));
}
EXPECT_FALSE(buffer->WriteBits(v));
uint16_t index = buffer->GetIndex();
EXPECT_EQ(buffer->SkipBits(), index);
buffer->SetIndex(0);
uint8_t bits = BIT0;
uint32_t bitIndex = 0;
do {
bits++;
if (bits > BIT8) {
EXPECT_FALSE(buffer->WriteBits(v, bits));
if (bits == 10) {
bits = BIT0;
}
} else {
if (bitIndex + bits <= bitLen) {
bitIndex += bits;
EXPECT_TRUE(buffer->WriteBits(v, bits));
} else {
EXPECT_FALSE(buffer->WriteBits(v, bits));
}
}
} while (bitIndex < bitLen);
buffer->SetIndex(0);
index = buffer->GetIndex();
EXPECT_EQ(buffer->SkipBits(), index);
EXPECT_TRUE(buffer->WriteBits(v));
EXPECT_FALSE(buffer->SetIndex(0));
EXPECT_EQ(buffer->SkipBits(), index + 1);
EXPECT_TRUE(buffer->SetIndex(0));
buffer->SetIndex(0);
EXPECT_EQ(buffer->GetPduBuffer(), nullptr);
buffer->SetIndex(1);
index = buffer->GetIndex();
EXPECT_EQ(buffer->GetPduBuffer()->size(), index);
EXPECT_TRUE(buffer->WriteBits(v));
EXPECT_EQ(buffer->GetPduBuffer(), nullptr);
EXPECT_EQ(buffer->SkipBits(), index + 1);
EXPECT_EQ(buffer->GetPduBuffer()->size(), static_cast<unsigned long>(index + 1));
}
* @tc.number Telephony_SmsMmsGtest_CdmaSmsTransportMessage_0001
* @tc.name Test CdmaSmsTransportMessage
* @tc.desc Function test
*/
HWTEST_F(BranchCdmaSmsTest, CdmaSmsTransportMessage_0001, Function | MediumTest | Level1)
{
auto message = std::make_shared<CdmaSmsTransportMessage>();
EXPECT_TRUE(message->IsEmpty());
auto buffer1 = std::make_shared<SmsWriteBuffer>();
EXPECT_FALSE(buffer1->IsEmpty());
EXPECT_FALSE(message->Encode(*buffer1));
std::stringstream ss;
ss.clear();
ss << static_cast<uint8_t>(CdmaTransportMsgType::P2P);
auto buffer2 = std::make_shared<SmsReadBuffer>(ss.str());
EXPECT_TRUE(buffer2->IsEmpty());
EXPECT_FALSE(message->Decode(*buffer2));
ss << CdmaSmsParameterRecord::TELESERVICE_ID;
auto buffer3 = std::make_shared<SmsReadBuffer>(ss.str());
EXPECT_FALSE(buffer3->IsEmpty());
EXPECT_FALSE(message->Decode(*buffer3));
}
* @tc.number Telephony_SmsMmsGtest_CdmaSmsTransportMessage_0002
* @tc.name Test CdmaSmsTransportMessage
* @tc.desc Function test
*/
HWTEST_F(BranchCdmaSmsTest, CdmaSmsTransportMessage_0002, Function | MediumTest | Level1)
{
do {
CdmaTransportMsg msg;
msg.type = CdmaTransportMsgType::RESERVED;
auto message = CdmaSmsTransportMessage::CreateTransportMessage(msg);
EXPECT_EQ(message, nullptr);
} while (0);
uint8_t type = 0;
for (type = 0; type < static_cast<uint8_t>(CdmaTransportMsgType::RESERVED); type++) {
CdmaTransportMsg msg;
msg.type = CdmaTransportMsgType(type);
auto message = CdmaSmsTransportMessage::CreateTransportMessage(msg);
EXPECT_NE(message, nullptr);
auto buffer = std::make_shared<SmsWriteBuffer>();
EXPECT_FALSE(buffer->IsEmpty());
message->Encode(*buffer);
SmsReadBuffer rBuffer(StringUtils::HexToString("000000"));
EXPECT_FALSE(message->Decode(rBuffer));
}
CdmaTransportMsg msg;
std::vector<std::string> pduHex;
pduHex.clear();
pduHex.push_back("00");
pduHex.push_back("0300");
for (uint8_t i = 0; i < pduHex.size(); i++) {
SmsReadBuffer buffer(StringUtils::HexToString(pduHex[i]));
auto message = CdmaSmsTransportMessage::CreateTransportMessage(msg, buffer);
EXPECT_EQ(message, nullptr);
}
pduHex.clear();
pduHex.push_back("0000");
pduHex.push_back("0100");
pduHex.push_back("0200");
for (uint8_t i = 0; i < pduHex.size(); i++) {
SmsReadBuffer buffer(StringUtils::HexToString(pduHex[i]));
auto message = CdmaSmsTransportMessage::CreateTransportMessage(msg, buffer);
EXPECT_NE(message, nullptr);
EXPECT_FALSE(message->Decode(buffer));
}
pduHex.clear();
pduHex.push_back("0000021002");
pduHex.push_back("0101020000");
pduHex.push_back("0207020000");
for (uint8_t i = 0; i < pduHex.size(); i++) {
SmsReadBuffer buffer(StringUtils::HexToString(pduHex[i]));
auto message = CdmaSmsTransportMessage::CreateTransportMessage(msg, buffer);
EXPECT_NE(message, nullptr);
EXPECT_TRUE(message->Decode(buffer));
}
}
* @tc.number Telephony_SmsMmsGtest_CdmaSmsTransportMessage_0003
* @tc.name Test CdmaSmsTransportMessage
* @tc.desc Function test
*/
HWTEST_F(BranchCdmaSmsTest, CdmaSmsTransportMessage_0003, Function | MediumTest | Level1)
{
auto message = std::make_shared<CdmaSmsTransportMessage>();
EXPECT_TRUE(message->IsEmpty());
auto buffer1 = std::make_shared<SmsWriteBuffer>();
EXPECT_FALSE(buffer1->IsEmpty());
EXPECT_FALSE(message->Encode(*buffer1));
std::stringstream ss;
ss.clear();
ss << static_cast<uint8_t>(CdmaTransportMsgType::P2P);
ss << CdmaSmsParameterRecord::TELESERVICE_ID;
auto buffer2 = std::make_shared<SmsReadBuffer>(ss.str());
EXPECT_FALSE(buffer2->IsEmpty());
EXPECT_FALSE(message->Decode(*buffer2));
CdmaTransportMsg msg;
msg.type = CdmaTransportMsgType::P2P;
auto message2 = CdmaSmsTransportMessage::CreateTransportMessage(msg);
EXPECT_NE(message2, nullptr);
auto message3 = CdmaSmsTransportMessage::CreateTransportMessage(msg, *buffer2);
EXPECT_NE(message3, nullptr);
auto message4 = std::make_shared<CdmaSmsP2pMessage>(msg.data.p2p);
EXPECT_NE(message4, nullptr);
auto message5 = std::make_shared<CdmaSmsP2pMessage>(msg.data.p2p, *buffer2);
EXPECT_NE(message5, nullptr);
auto message6 = std::make_shared<CdmaSmsBroadcastMessage>(msg.data.broadcast);
EXPECT_NE(message6, nullptr);
auto message7 = std::make_shared<CdmaSmsBroadcastMessage>(msg.data.broadcast, *buffer2);
EXPECT_NE(message7, nullptr);
auto message8 = std::make_shared<CdmaSmsAckMessage>(msg.data.ack);
EXPECT_NE(message8, nullptr);
auto message9 = std::make_shared<CdmaSmsAckMessage>(msg.data.ack, *buffer2);
EXPECT_NE(message9, nullptr);
}
* @tc.number Telephony_SmsMmsGtest_CdmaSmsTeleserviceMessage_0001
* @tc.name Test CdmaSmsTeleserviceMessage
* @tc.desc Function test
*/
HWTEST_F(BranchCdmaSmsTest, CdmaSmsTeleserviceMessage_0001, Function | MediumTest | Level1)
{
SmsWriteBuffer wBuffer;
SmsReadBuffer rBuffer(StringUtils::HexToString("0003200640"));
auto message = std::make_shared<CdmaSmsTeleserviceMessage>();
EXPECT_NE(message, nullptr);
wBuffer.SetIndex(PDU_BUFFER_MAX_SIZE);
EXPECT_FALSE(message->Encode(wBuffer));
EXPECT_FALSE(message->Decode(rBuffer));
EXPECT_EQ(CdmaSmsTeleserviceMessage::GetMessageType(rBuffer), CdmaSmsTeleserviceMessage::SUBMIT);
wBuffer.SetIndex(PDU_BUFFER_MAX_SIZE);
CdmaTransportMsg msg;
auto message1 = std::make_shared<CdmaSmsSubmitMessage>(msg.data.p2p.telesvcMsg.data.submit);
EXPECT_NE(message1, nullptr);
EXPECT_FALSE(message1->Encode(wBuffer));
EXPECT_FALSE(message1->Decode(rBuffer));
auto message2 = std::make_shared<CdmaSmsSubmitMessage>(msg.data.p2p.telesvcMsg.data.submit, rBuffer);
EXPECT_NE(message2, nullptr);
EXPECT_FALSE(message2->Encode(wBuffer));
EXPECT_FALSE(message2->Decode(rBuffer));
auto message3 = std::make_shared<CdmaSmsCancelMessage>(msg.data.p2p.telesvcMsg.data.cancel);
EXPECT_NE(message3, nullptr);
EXPECT_FALSE(message3->Encode(wBuffer));
EXPECT_FALSE(message3->Decode(rBuffer));
auto message4 = std::make_shared<CdmaSmsDeliverReport>(msg.data.p2p.telesvcMsg.data.report);
EXPECT_NE(message4, nullptr);
EXPECT_FALSE(message4->Encode(wBuffer));
EXPECT_FALSE(message4->Decode(rBuffer));
auto message5 = std::make_shared<CdmaSmsDeliverMessage>(msg.data.p2p.telesvcMsg.data.deliver, rBuffer);
EXPECT_NE(message5, nullptr);
EXPECT_FALSE(message5->Encode(wBuffer));
EXPECT_FALSE(message5->Decode(rBuffer));
auto message6 = std::make_shared<CdmaSmsDeliveryAck>(msg.data.p2p.telesvcMsg.data.deliveryAck, rBuffer);
EXPECT_NE(message6, nullptr);
EXPECT_FALSE(message6->Encode(wBuffer));
EXPECT_FALSE(message6->Decode(rBuffer));
auto message7 = std::make_shared<CdmaSmsUserAck>(msg.data.p2p.telesvcMsg.data.userAck, rBuffer);
EXPECT_NE(message7, nullptr);
EXPECT_FALSE(message7->Encode(wBuffer));
EXPECT_FALSE(message7->Decode(rBuffer));
auto message8 = std::make_shared<CdmaSmsReadAck>(msg.data.p2p.telesvcMsg.data.readAck, rBuffer);
EXPECT_NE(message8, nullptr);
EXPECT_FALSE(message8->Encode(wBuffer));
EXPECT_FALSE(message8->Decode(rBuffer));
}
* @tc.number Telephony_SmsMmsGtest_CdmaSmsParameterRecord_0001
* @tc.name Test CdmaSmsParameterRecord
* @tc.desc Function test
*/
HWTEST_F(BranchCdmaSmsTest, CdmaSmsParameterRecord_0001, Function | MediumTest | Level1)
{
auto initValue = static_cast<uint16_t>(SmsTransTelsvcId::RESERVED);
auto testValue = static_cast<uint16_t>(SmsTransTelsvcId::CMT_95);
uint16_t v1 = testValue;
uint16_t v2 = initValue;
auto message1 = std::make_shared<CdmaSmsTeleserviceId>(v1);
SmsWriteBuffer wBuffer;
EXPECT_TRUE(message1->Encode(wBuffer));
auto buffer = wBuffer.GetPduBuffer();
EXPECT_GT(buffer->size(), static_cast<uint32_t>(0));
std::stringstream ss;
ss.clear();
for (uint16_t i = 0; i < buffer->size(); i++) {
ss << (*buffer)[i];
}
SmsReadBuffer rBuffer(ss.str());
auto message2 = std::make_shared<CdmaSmsTeleserviceId>(v2);
EXPECT_TRUE(message2->Decode(rBuffer));
EXPECT_EQ(v2, testValue);
wBuffer.SetIndex(PDU_BUFFER_MAX_SIZE);
EXPECT_FALSE(message1->Encode(wBuffer));
rBuffer.SetIndex(1);
EXPECT_FALSE(message1->Decode(rBuffer));
}
* @tc.number Telephony_SmsMmsGtest_CdmaSmsParameterRecord_0002
* @tc.name Test CdmaSmsParameterRecord
* @tc.desc Function test
*/
HWTEST_F(BranchCdmaSmsTest, CdmaSmsParameterRecord_0002, Function | MediumTest | Level1)
{
auto initValue = static_cast<uint16_t>(SmsServiceCtg::RESERVED);
auto testValue = static_cast<uint16_t>(SmsServiceCtg::CMAS_TEST);
uint16_t v1 = testValue;
uint16_t v2 = initValue;
auto message1 = std::make_shared<CdmaSmsServiceCategory>(v1);
SmsWriteBuffer wBuffer;
EXPECT_TRUE(message1->Encode(wBuffer));
auto buffer = wBuffer.GetPduBuffer();
EXPECT_GT(buffer->size(), 0);
std::stringstream ss;
ss.clear();
for (uint16_t i = 0; i < buffer->size(); i++) {
ss << (*buffer)[i];
}
SmsReadBuffer rBuffer(ss.str());
auto message2 = std::make_shared<CdmaSmsServiceCategory>(v2);
EXPECT_TRUE(message2->Decode(rBuffer));
EXPECT_EQ(v2, testValue);
wBuffer.SetIndex(PDU_BUFFER_MAX_SIZE);
EXPECT_FALSE(message1->Encode(wBuffer));
rBuffer.SetIndex(1);
EXPECT_FALSE(message1->Decode(rBuffer));
}
* @tc.number Telephony_SmsMmsGtest_CdmaSmsParameterRecord_0003
* @tc.name Test CdmaSmsParameterRecord
* @tc.desc Function test
*/
HWTEST_F(BranchCdmaSmsTest, CdmaSmsParameterRecord_0003, Function | MediumTest | Level1)
{
auto initValue = static_cast<uint32_t>(0);
auto testValue = static_cast<uint32_t>(5);
TransportAddr v1;
memset_s(&v1, sizeof(TransportAddr), 0x00, sizeof(TransportAddr));
v1.addrLen = testValue;
TransportAddr v2;
v2.addrLen = initValue;
auto message1 = std::make_shared<CdmaSmsAddressParameter>(v1, CdmaSmsParameterRecord::DEST_ADDRESS);
SmsWriteBuffer wBuffer;
EXPECT_TRUE(message1->Encode(wBuffer));
auto buffer = wBuffer.GetPduBuffer();
EXPECT_GT(buffer->size(), 0);
std::stringstream ss;
ss.clear();
for (uint16_t i = 0; i < buffer->size(); i++) {
ss << (*buffer)[i];
}
SmsReadBuffer rBuffer(ss.str());
auto message2 = std::make_shared<CdmaSmsAddressParameter>(v2, CdmaSmsParameterRecord::DEST_ADDRESS);
EXPECT_TRUE(message2->Decode(rBuffer));
EXPECT_EQ(v2.addrLen, testValue);
wBuffer.SetIndex(PDU_BUFFER_MAX_SIZE);
EXPECT_FALSE(message1->Encode(wBuffer));
rBuffer.SetIndex(1);
EXPECT_FALSE(message1->Decode(rBuffer));
}
* @tc.number Telephony_SmsMmsGtest_CdmaSmsParameterRecord_0004
* @tc.name Test CdmaSmsParameterRecord
* @tc.desc Function test
*/
HWTEST_F(BranchCdmaSmsTest, CdmaSmsParameterRecord_0004, Function | MediumTest | Level1)
{
auto initValue = static_cast<uint32_t>(0);
auto testValue = static_cast<uint32_t>(5);
TransportSubAddr v1;
memset_s(&v1, sizeof(TransportSubAddr), 0x00, sizeof(TransportSubAddr));
v1.addrLen = testValue;
TransportSubAddr v2;
v2.addrLen = initValue;
auto message1 = std::make_shared<CdmaSmsSubaddress>(v1, CdmaSmsParameterRecord::DEST_SUB_ADDRESS);
SmsWriteBuffer wBuffer;
EXPECT_TRUE(message1->Encode(wBuffer));
auto buffer = wBuffer.GetPduBuffer();
EXPECT_GT(buffer->size(), 0);
std::stringstream ss;
ss.clear();
for (uint16_t i = 0; i < buffer->size(); i++) {
ss << (*buffer)[i];
}
SmsReadBuffer rBuffer(ss.str());
auto message2 = std::make_shared<CdmaSmsSubaddress>(v2, CdmaSmsParameterRecord::DEST_SUB_ADDRESS);
EXPECT_TRUE(message2->Decode(rBuffer));
EXPECT_EQ(v2.addrLen, testValue);
wBuffer.SetIndex(PDU_BUFFER_MAX_SIZE);
EXPECT_FALSE(message1->Encode(wBuffer));
rBuffer.SetIndex(1);
EXPECT_FALSE(message1->Decode(rBuffer));
}
* @tc.number Telephony_SmsMmsGtest_CdmaSmsParameterRecord_0005
* @tc.name Test CdmaSmsParameterRecord
* @tc.desc Function test
*/
HWTEST_F(BranchCdmaSmsTest, CdmaSmsParameterRecord_0005, Function | MediumTest | Level1)
{
auto initValue = static_cast<uint8_t>(0);
auto testValue = static_cast<uint8_t>(5);
uint8_t v1 = testValue;
uint8_t v2 = initValue;
auto message1 = std::make_shared<CdmaSmsBearerReply>(v1);
SmsWriteBuffer wBuffer;
EXPECT_TRUE(message1->Encode(wBuffer));
auto buffer = wBuffer.GetPduBuffer();
EXPECT_GT(buffer->size(), 0);
std::stringstream ss;
ss.clear();
for (uint16_t i = 0; i < buffer->size(); i++) {
ss << (*buffer)[i];
}
SmsReadBuffer rBuffer(ss.str());
auto message2 = std::make_shared<CdmaSmsBearerReply>(v2);
EXPECT_TRUE(message2->Decode(rBuffer));
EXPECT_EQ(v2, testValue);
wBuffer.SetIndex(PDU_BUFFER_MAX_SIZE);
EXPECT_FALSE(message1->Encode(wBuffer));
rBuffer.SetIndex(1);
EXPECT_FALSE(message1->Decode(rBuffer));
}
* @tc.number Telephony_SmsMmsGtest_CdmaSmsParameterRecord_0006
* @tc.name Test CdmaSmsParameterRecord
* @tc.desc Function test
*/
HWTEST_F(BranchCdmaSmsTest, CdmaSmsParameterRecord_0006, Function | MediumTest | Level1)
{
auto initValue = TeleserviceMsgType::RESERVED;
auto testValue = TeleserviceMsgType::SUBMIT;
CdmaTeleserviceMsg v1;
memset_s(&v1, sizeof(CdmaTeleserviceMsg), 0x00, sizeof(CdmaTeleserviceMsg));
v1.type = testValue;
CdmaTeleserviceMsg v2;
v2.type = initValue;
auto message1 = std::make_shared<CdmaSmsBearerData>(v1);
SmsWriteBuffer wBuffer;
EXPECT_TRUE(message1->Encode(wBuffer));
auto buffer = wBuffer.GetPduBuffer();
EXPECT_GT(buffer->size(), 0);
std::stringstream ss;
ss.clear();
for (uint16_t i = 0; i < buffer->size(); i++) {
ss << (*buffer)[i];
}
SmsReadBuffer rBuffer(ss.str());
rBuffer.SetIndex(2);
auto message2 = std::make_shared<CdmaSmsBearerData>(v2, rBuffer);
rBuffer.SetIndex(0);
EXPECT_TRUE(message2->Decode(rBuffer));
EXPECT_EQ(v2.type, testValue);
wBuffer.SetIndex(PDU_BUFFER_MAX_SIZE);
EXPECT_FALSE(message1->Encode(wBuffer));
rBuffer.SetIndex(1);
EXPECT_FALSE(message1->Decode(rBuffer));
}
* @tc.number Telephony_SmsMmsGtest_CdmaSmsParameterRecord_0007
* @tc.name Test CdmaSmsParameterRecord
* @tc.desc Function test
*/
HWTEST_F(BranchCdmaSmsTest, CdmaSmsParameterRecord_0007, Function | MediumTest | Level1)
{
auto initValue = TransportErrClass::NONE;
auto testValue = TransportErrClass::TEMPORARY;
TransportCauseCode v1;
memset_s(&v1, sizeof(TransportCauseCode), 0x00, sizeof(TransportCauseCode));
v1.errorClass = testValue;
TransportCauseCode v2;
v2.errorClass = initValue;
auto message1 = std::make_shared<CdmaSmsCauseCodes>(v1);
SmsWriteBuffer wBuffer;
EXPECT_TRUE(message1->Encode(wBuffer));
auto buffer = wBuffer.GetPduBuffer();
EXPECT_GT(buffer->size(), 0);
std::stringstream ss;
ss.clear();
for (uint16_t i = 0; i < buffer->size(); i++) {
ss << (*buffer)[i];
}
SmsReadBuffer rBuffer(ss.str());
auto message2 = std::make_shared<CdmaSmsCauseCodes>(v2);
EXPECT_TRUE(message2->Decode(rBuffer));
EXPECT_EQ(v2.errorClass, testValue);
wBuffer.SetIndex(PDU_BUFFER_MAX_SIZE);
EXPECT_FALSE(message1->Encode(wBuffer));
rBuffer.SetIndex(1);
EXPECT_FALSE(message1->Decode(rBuffer));
}
* @tc.number Telephony_SmsMmsGtest_CdmaSmsSubParameter_0001
* @tc.name Test CdmaSmsSubParameter
* @tc.desc Function test
*/
HWTEST_F(BranchCdmaSmsTest, CdmaSmsSubParameter_0001, Function | MediumTest | Level1)
{
auto initValue = static_cast<uint8_t>(0);
auto testValue = static_cast<uint8_t>(5);
uint8_t v1 = testValue;
uint8_t v2 = initValue;
auto message1 = std::make_shared<CdmaSmsBaseParameter>(CdmaSmsSubParameter::USER_RESPONSE_CODE, v1);
SmsWriteBuffer wBuffer;
EXPECT_TRUE(message1->Encode(wBuffer));
auto buffer = wBuffer.GetPduBuffer();
EXPECT_GT(buffer->size(), 0);
std::stringstream ss;
ss.clear();
for (uint16_t i = 0; i < buffer->size(); i++) {
ss << (*buffer)[i];
}
SmsReadBuffer rBuffer(ss.str());
auto message2 = std::make_shared<CdmaSmsBaseParameter>(CdmaSmsSubParameter::USER_RESPONSE_CODE, v2);
EXPECT_TRUE(message2->Decode(rBuffer));
EXPECT_EQ(v2, testValue);
wBuffer.SetIndex(PDU_BUFFER_MAX_SIZE);
EXPECT_FALSE(message1->Encode(wBuffer));
rBuffer.SetIndex(1);
EXPECT_FALSE(message1->Decode(rBuffer));
}
* @tc.number Telephony_SmsMmsGtest_CdmaSmsSubParameter_0002
* @tc.name Test CdmaSmsSubParameter
* @tc.desc Function test
*/
HWTEST_F(BranchCdmaSmsTest, CdmaSmsSubParameter_0002, Function | MediumTest | Level1)
{
auto message1 = std::make_shared<CdmaSmsReservedParameter>(CdmaSmsSubParameter::USER_RESPONSE_CODE);
SmsWriteBuffer wBuffer;
EXPECT_TRUE(message1->Encode(wBuffer));
std::stringstream ss;
ss.clear();
ss << static_cast<uint8_t>(CdmaSmsSubParameter::USER_RESPONSE_CODE);
ss << static_cast<uint8_t>(0x01);
ss << static_cast<uint8_t>(0x00);
SmsReadBuffer rBuffer(ss.str());
auto message2 = std::make_shared<CdmaSmsReservedParameter>(CdmaSmsSubParameter::USER_RESPONSE_CODE);
EXPECT_TRUE(message2->Decode(rBuffer));
wBuffer.SetIndex(PDU_BUFFER_MAX_SIZE);
EXPECT_TRUE(message1->Encode(wBuffer));
rBuffer.SetIndex(1);
EXPECT_FALSE(message1->Decode(rBuffer));
}
* @tc.number Telephony_SmsMmsGtest_CdmaSmsSubParameter_0003
* @tc.name Test CdmaSmsSubParameter
* @tc.desc Function test
*/
HWTEST_F(BranchCdmaSmsTest, CdmaSmsSubParameter_0003, Function | MediumTest | Level1)
{
auto initValue = static_cast<uint16_t>(0x0);
auto testValue = static_cast<uint16_t>(0x10);
SmsTeleSvcMsgId v1;
memset_s(&v1, sizeof(SmsTeleSvcMsgId), 0x00, sizeof(SmsTeleSvcMsgId));
v1.msgId = testValue;
SmsTeleSvcMsgId v2;
v2.msgId = initValue;
uint8_t type = static_cast<uint8_t>(TeleserviceMsgType::SUBMIT);
auto message1 = std::make_shared<CdmaSmsMessageId>(v1, type);
SmsWriteBuffer wBuffer;
EXPECT_TRUE(message1->Encode(wBuffer));
auto buffer = wBuffer.GetPduBuffer();
EXPECT_GT(buffer->size(), 0);
std::stringstream ss;
ss.clear();
for (uint16_t i = 0; i < buffer->size(); i++) {
ss << (*buffer)[i];
}
SmsReadBuffer rBuffer(ss.str());
auto message2 = std::make_shared<CdmaSmsMessageId>(v2, type);
EXPECT_TRUE(message2->Decode(rBuffer));
EXPECT_EQ(message2->GetMessageType(), type);
EXPECT_EQ(v2.msgId, testValue);
wBuffer.SetIndex(PDU_BUFFER_MAX_SIZE);
EXPECT_FALSE(message1->Encode(wBuffer));
rBuffer.SetIndex(1);
EXPECT_FALSE(message1->Decode(rBuffer));
}
* @tc.number Telephony_SmsMmsGtest_CdmaSmsSubParameter_0004
* @tc.name Test CdmaSmsSubParameter
* @tc.desc Function test
*/
HWTEST_F(BranchCdmaSmsTest, CdmaSmsSubParameter_0004, Function | MediumTest | Level1)
{
auto initValue = SmsEncodingType::RESERVED;
auto testValue = SmsEncodingType::ASCII_7BIT;
SmsTeleSvcUserData v1;
memset_s(&v1, sizeof(SmsTeleSvcUserData), 0x00, sizeof(SmsTeleSvcUserData));
v1.encodeType = testValue;
SmsTeleSvcUserData v2;
v2.encodeType = initValue;
bool headerInd = false;
auto message1 = std::make_shared<CdmaSmsUserData>(v1, headerInd);
SmsWriteBuffer wBuffer;
EXPECT_TRUE(message1->Encode(wBuffer));
auto buffer = wBuffer.GetPduBuffer();
EXPECT_GT(buffer->size(), 0);
std::stringstream ss;
ss.clear();
for (uint16_t i = 0; i < buffer->size(); i++) {
ss << (*buffer)[i];
}
SmsReadBuffer rBuffer(ss.str());
auto message2 = std::make_shared<CdmaSmsUserData>(v2, headerInd);
EXPECT_TRUE(message2->Decode(rBuffer));
EXPECT_EQ(v2.encodeType, testValue);
wBuffer.SetIndex(0);
EXPECT_TRUE(message1->EncodeHeader7Bit(wBuffer));
EXPECT_TRUE(message1->EncodeAscii7Bit(wBuffer));
EXPECT_TRUE(message1->EncodeGsm7Bit(wBuffer));
EXPECT_TRUE(message1->EncodeUnicode(wBuffer));
rBuffer.SetIndex(0);
EXPECT_EQ(message2->DecodeHeader7Bit(rBuffer), 0);
EXPECT_TRUE(message2->DecodeAscii7Bit(rBuffer, 0, 0));
EXPECT_TRUE(message2->DecodeGsm7Bit(rBuffer, 0, 0));
wBuffer.SetIndex(PDU_BUFFER_MAX_SIZE);
EXPECT_FALSE(message1->Encode(wBuffer));
rBuffer.SetIndex(1);
EXPECT_FALSE(message1->Decode(rBuffer));
}
* @tc.number Telephony_SmsMmsGtest_CdmaSmsSubParameter_0005
* @tc.name Test CdmaSmsSubParameter
* @tc.desc Function test
*/
HWTEST_F(BranchCdmaSmsTest, CdmaSmsSubParameter_0005, Function | MediumTest | Level1)
{
SmsTeleSvcCmasData v1;
memset_s(&v1, sizeof(SmsTeleSvcCmasData), 0x00, sizeof(SmsTeleSvcCmasData));
SmsTeleSvcCmasData v2;
auto message1 = std::make_shared<CdmaSmsCmasData>(v1);
SmsWriteBuffer wBuffer;
EXPECT_FALSE(message1->Encode(wBuffer));
std::stringstream ss;
ss.clear();
ss << static_cast<uint8_t>(CdmaSmsSubParameter::USER_DATA);
uint8_t len = 100;
ss << static_cast<uint8_t>(len);
for (uint8_t i = 0; i < len; i++) {
ss << static_cast<uint8_t>(0x00);
}
SmsReadBuffer rBuffer(ss.str());
auto message2 = std::make_shared<CdmaSmsCmasData>(v2);
EXPECT_TRUE(message2->Decode(rBuffer));
rBuffer.SetIndex(0);
EXPECT_TRUE(message2->DecodeType0Data(rBuffer));
EXPECT_TRUE(message2->DecodeType1Data(rBuffer));
EXPECT_TRUE(message2->DecodeType2Data(rBuffer));
EXPECT_TRUE(message2->DecodeAbsTime(rBuffer));
wBuffer.SetIndex(PDU_BUFFER_MAX_SIZE);
EXPECT_FALSE(message1->Encode(wBuffer));
rBuffer.SetIndex(1);
EXPECT_FALSE(message1->Decode(rBuffer));
}
* @tc.number Telephony_SmsMmsGtest_CdmaSmsSubParameter_0006
* @tc.name Test CdmaSmsSubParameter
* @tc.desc Function test
*/
HWTEST_F(BranchCdmaSmsTest, CdmaSmsSubParameter_0006, Function | MediumTest | Level1)
{
auto initValue = static_cast<unsigned char>(0);
auto testValue = static_cast<unsigned char>(5);
SmsTimeAbs v1;
memset_s(&v1, sizeof(SmsTimeAbs), 0x00, sizeof(SmsTimeAbs));
v1.month = testValue;
SmsTimeAbs v2;
v2.month = initValue;
auto message1 = std::make_shared<CdmaSmsAbsoluteTime>(CdmaSmsSubParameter::VALIDITY_PERIOD_ABSOLUTE, v1);
SmsWriteBuffer wBuffer;
EXPECT_TRUE(message1->Encode(wBuffer));
auto buffer = wBuffer.GetPduBuffer();
EXPECT_GT(buffer->size(), 0);
std::stringstream ss;
ss.clear();
for (uint16_t i = 0; i < buffer->size(); i++) {
ss << (*buffer)[i];
}
SmsReadBuffer rBuffer(ss.str());
auto message2 = std::make_shared<CdmaSmsAbsoluteTime>(CdmaSmsSubParameter::VALIDITY_PERIOD_ABSOLUTE, v2);
EXPECT_TRUE(message2->Decode(rBuffer));
EXPECT_EQ(v2.month, testValue);
wBuffer.SetIndex(PDU_BUFFER_MAX_SIZE);
EXPECT_FALSE(message1->Encode(wBuffer));
rBuffer.SetIndex(1);
EXPECT_FALSE(message1->Decode(rBuffer));
}
* @tc.number Telephony_SmsMmsGtest_CdmaSmsSubParameter_0007
* @tc.name Test CdmaSmsSubParameter
* @tc.desc Function test
*/
HWTEST_F(BranchCdmaSmsTest, CdmaSmsSubParameter_0007, Function | MediumTest | Level1)
{
auto initValue = SmsPriorityIndicator::RESERVED;
auto testValue = SmsPriorityIndicator::NORMAL;
SmsPriorityIndicator v1 = testValue;
SmsPriorityIndicator v2 = initValue;
auto message1 = std::make_shared<CdmaSmsPriorityInd>(v1);
SmsWriteBuffer wBuffer;
EXPECT_TRUE(message1->Encode(wBuffer));
auto buffer = wBuffer.GetPduBuffer();
EXPECT_GT(buffer->size(), 0);
std::stringstream ss;
ss.clear();
for (uint16_t i = 0; i < buffer->size(); i++) {
ss << (*buffer)[i];
}
SmsReadBuffer rBuffer(ss.str());
auto message2 = std::make_shared<CdmaSmsPriorityInd>(v2);
EXPECT_TRUE(message2->Decode(rBuffer));
EXPECT_EQ(v2, testValue);
wBuffer.SetIndex(PDU_BUFFER_MAX_SIZE);
EXPECT_FALSE(message1->Encode(wBuffer));
rBuffer.SetIndex(1);
EXPECT_FALSE(message1->Decode(rBuffer));
}
* @tc.number Telephony_SmsMmsGtest_CdmaSmsSubParameter_0008
* @tc.name Test CdmaSmsSubParameter
* @tc.desc Function test
*/
HWTEST_F(BranchCdmaSmsTest, CdmaSmsSubParameter_0008, Function | MediumTest | Level1)
{
auto initValue = SmsPrivacyIndicator::NOT_RESTRICTED;
auto testValue = SmsPrivacyIndicator::RESTRICTED;
SmsPrivacyIndicator v1 = testValue;
SmsPrivacyIndicator v2 = initValue;
auto message1 = std::make_shared<CdmaSmsPrivacyInd>(v1);
SmsWriteBuffer wBuffer;
EXPECT_TRUE(message1->Encode(wBuffer));
auto buffer = wBuffer.GetPduBuffer();
EXPECT_GT(buffer->size(), 0);
std::stringstream ss;
ss.clear();
for (uint16_t i = 0; i < buffer->size(); i++) {
ss << (*buffer)[i];
}
SmsReadBuffer rBuffer(ss.str());
auto message2 = std::make_shared<CdmaSmsPrivacyInd>(v2);
EXPECT_TRUE(message2->Decode(rBuffer));
EXPECT_EQ(v2, testValue);
wBuffer.SetIndex(PDU_BUFFER_MAX_SIZE);
EXPECT_FALSE(message1->Encode(wBuffer));
rBuffer.SetIndex(1);
EXPECT_FALSE(message1->Decode(rBuffer));
}
* @tc.number Telephony_SmsMmsGtest_CdmaSmsSubParameter_0009
* @tc.name Test CdmaSmsSubParameter
* @tc.desc Function test
*/
HWTEST_F(BranchCdmaSmsTest, CdmaSmsSubParameter_0009, Function | MediumTest | Level1)
{
auto initValue = false;
auto testValue = true;
SmsReplyOption v1;
memset_s(&v1, sizeof(SmsReplyOption), 0x00, sizeof(SmsReplyOption));
v1.dak = testValue;
SmsReplyOption v2;
v2.dak = initValue;
auto message1 = std::make_shared<CdmaSmsReplyOption>(v1);
SmsWriteBuffer wBuffer;
EXPECT_TRUE(message1->Encode(wBuffer));
auto buffer = wBuffer.GetPduBuffer();
EXPECT_GT(buffer->size(), 0);
std::stringstream ss;
ss.clear();
for (uint16_t i = 0; i < buffer->size(); i++) {
ss << (*buffer)[i];
}
SmsReadBuffer rBuffer(ss.str());
auto message2 = std::make_shared<CdmaSmsReplyOption>(v2);
EXPECT_TRUE(message2->Decode(rBuffer));
EXPECT_EQ(v2.dak, testValue);
wBuffer.SetIndex(PDU_BUFFER_MAX_SIZE);
EXPECT_FALSE(message1->Encode(wBuffer));
rBuffer.SetIndex(1);
EXPECT_FALSE(message1->Decode(rBuffer));
}
* @tc.number Telephony_SmsMmsGtest_CdmaSmsSubParameter_0010
* @tc.name Test CdmaSmsSubParameter
* @tc.desc Function test
*/
HWTEST_F(BranchCdmaSmsTest, CdmaSmsSubParameter_0010, Function | MediumTest | Level1)
{
auto initValue = SmsAlertPriority::DEFAULT;
auto testValue = SmsAlertPriority::HIGH;
SmsAlertPriority v1 = testValue;
SmsAlertPriority v2 = initValue;
auto message1 = std::make_shared<CdmaSmsAlertPriority>(v1);
SmsWriteBuffer wBuffer;
EXPECT_TRUE(message1->Encode(wBuffer));
auto buffer = wBuffer.GetPduBuffer();
EXPECT_GT(buffer->size(), 0);
std::stringstream ss;
ss.clear();
for (uint16_t i = 0; i < buffer->size(); i++) {
ss << (*buffer)[i];
}
SmsReadBuffer rBuffer(ss.str());
auto message2 = std::make_shared<CdmaSmsAlertPriority>(v2);
EXPECT_TRUE(message2->Decode(rBuffer));
EXPECT_EQ(v2, testValue);
wBuffer.SetIndex(PDU_BUFFER_MAX_SIZE);
EXPECT_FALSE(message1->Encode(wBuffer));
rBuffer.SetIndex(1);
EXPECT_FALSE(message1->Decode(rBuffer));
}
* @tc.number Telephony_SmsMmsGtest_CdmaSmsSubParameter_0011
* @tc.name Test CdmaSmsSubParameter
* @tc.desc Function test
*/
HWTEST_F(BranchCdmaSmsTest, CdmaSmsSubParameter_0011, Function | MediumTest | Level1)
{
auto initValue = SmsLanguageType::UNKNOWN;
auto testValue = SmsLanguageType::CHINESE;
SmsLanguageType v1 = testValue;
SmsLanguageType v2 = initValue;
auto message1 = std::make_shared<CdmaSmsLanguageInd>(v1);
SmsWriteBuffer wBuffer;
EXPECT_TRUE(message1->Encode(wBuffer));
auto buffer = wBuffer.GetPduBuffer();
EXPECT_GT(buffer->size(), 0);
std::stringstream ss;
ss.clear();
for (uint16_t i = 0; i < buffer->size(); i++) {
ss << (*buffer)[i];
}
SmsReadBuffer rBuffer(ss.str());
auto message2 = std::make_shared<CdmaSmsLanguageInd>(v2);
EXPECT_TRUE(message2->Decode(rBuffer));
EXPECT_EQ(v2, testValue);
wBuffer.SetIndex(PDU_BUFFER_MAX_SIZE);
EXPECT_FALSE(message1->Encode(wBuffer));
rBuffer.SetIndex(1);
EXPECT_FALSE(message1->Decode(rBuffer));
}
* @tc.number Telephony_SmsMmsGtest_CdmaSmsSubParameter_0012
* @tc.name Test CdmaSmsSubParameter
* @tc.desc Function test
*/
HWTEST_F(BranchCdmaSmsTest, CdmaSmsSubParameter_0012, Function | MediumTest | Level1)
{
auto initValue = static_cast<uint32_t>(0);
auto testValue = static_cast<uint32_t>(5);
SmsTeleSvcAddr v1;
memset_s(&v1, sizeof(SmsTeleSvcAddr), 0x00, sizeof(SmsTeleSvcAddr));
v1.addrLen = testValue;
SmsTeleSvcAddr v2;
v2.addrLen = initValue;
auto message1 = std::make_shared<CdmaSmsCallbackNumber>(v1);
SmsWriteBuffer wBuffer;
EXPECT_TRUE(message1->Encode(wBuffer));
auto buffer = wBuffer.GetPduBuffer();
EXPECT_GT(buffer->size(), 0);
std::stringstream ss;
ss.clear();
for (uint16_t i = 0; i < buffer->size(); i++) {
ss << (*buffer)[i];
}
SmsReadBuffer rBuffer(ss.str());
auto message2 = std::make_shared<CdmaSmsCallbackNumber>(v2);
EXPECT_TRUE(message2->Decode(rBuffer));
EXPECT_EQ(v2.addrLen, testValue);
wBuffer.SetIndex(PDU_BUFFER_MAX_SIZE);
EXPECT_FALSE(message1->Encode(wBuffer));
rBuffer.SetIndex(1);
EXPECT_FALSE(message1->Decode(rBuffer));
}
* @tc.number Telephony_SmsMmsGtest_CdmaSmsSubParameter_0013
* @tc.name Test CdmaSmsSubParameter
* @tc.desc Function test
*/
HWTEST_F(BranchCdmaSmsTest, CdmaSmsSubParameter_0013, Function | MediumTest | Level1)
{
uint16_t initValue = 0;
uint16_t testValue = 5;
uint16_t v1 = testValue;
uint16_t v2 = initValue;
auto message1 = std::make_shared<CdmaSmsDepositIndex>(v1);
SmsWriteBuffer wBuffer;
EXPECT_TRUE(message1->Encode(wBuffer));
auto buffer = wBuffer.GetPduBuffer();
EXPECT_GT(buffer->size(), 0);
std::stringstream ss;
ss.clear();
for (uint16_t i = 0; i < buffer->size(); i++) {
ss << (*buffer)[i];
}
SmsReadBuffer rBuffer(ss.str());
auto message2 = std::make_shared<CdmaSmsDepositIndex>(v2);
EXPECT_TRUE(message2->Decode(rBuffer));
EXPECT_EQ(v2, testValue);
wBuffer.SetIndex(PDU_BUFFER_MAX_SIZE);
EXPECT_FALSE(message1->Encode(wBuffer));
rBuffer.SetIndex(1);
EXPECT_FALSE(message1->Decode(rBuffer));
}
* @tc.number Telephony_SmsMmsGtest_CdmaSmsSubParameter_0014
* @tc.name Test CdmaSmsSubParameter
* @tc.desc Function test
*/
HWTEST_F(BranchCdmaSmsTest, CdmaSmsSubParameter_0014, Function | MediumTest | Level1)
{
auto initValue = SmsDisplayMode::RESERVED;
auto testValue = SmsDisplayMode::DEFAULT_SETTING;
SmsDisplayMode v1 = testValue;
SmsDisplayMode v2 = initValue;
auto message1 = std::make_shared<CdmaSmsDisplayMode>(v1);
SmsWriteBuffer wBuffer;
EXPECT_TRUE(message1->Encode(wBuffer));
auto buffer = wBuffer.GetPduBuffer();
EXPECT_GT(buffer->size(), 0);
std::stringstream ss;
ss.clear();
for (uint16_t i = 0; i < buffer->size(); i++) {
ss << (*buffer)[i];
}
SmsReadBuffer rBuffer(ss.str());
auto message2 = std::make_shared<CdmaSmsDisplayMode>(v2);
EXPECT_TRUE(message2->Decode(rBuffer));
EXPECT_EQ(v2, testValue);
wBuffer.SetIndex(PDU_BUFFER_MAX_SIZE);
EXPECT_FALSE(message1->Encode(wBuffer));
rBuffer.SetIndex(1);
EXPECT_FALSE(message1->Decode(rBuffer));
}
* @tc.number Telephony_SmsMmsGtest_CdmaSmsSubParameter_0015
* @tc.name Test CdmaSmsSubParameter
* @tc.desc Function test
*/
HWTEST_F(BranchCdmaSmsTest, CdmaSmsSubParameter_0015, Function | MediumTest | Level1)
{
SmsEnhancedVmn v1;
SmsEnhancedVmn v2;
auto message1 = std::make_shared<CdmaSmsEnhancedVmn>(v1);
SmsWriteBuffer wBuffer;
EXPECT_FALSE(message1->Encode(wBuffer));
std::stringstream ss;
ss.clear();
ss << static_cast<uint8_t>(CdmaSmsSubParameter::ENHANCED_VMN);
uint8_t len = 20;
ss << static_cast<uint8_t>(len);
for (uint8_t i = 0; i < len; i++) {
ss << static_cast<uint8_t>(0x00);
}
SmsReadBuffer rBuffer(ss.str());
auto message2 = std::make_shared<CdmaSmsEnhancedVmn>(v2);
EXPECT_TRUE(message2->Decode(rBuffer));
rBuffer.SetIndex(0);
EXPECT_TRUE(message2->DecodeHeader(rBuffer));
EXPECT_TRUE(message2->DecodeAccessNumber(rBuffer));
EXPECT_TRUE(message2->DecodeCallingPartyNumber(rBuffer));
wBuffer.SetIndex(PDU_BUFFER_MAX_SIZE);
EXPECT_FALSE(message1->Encode(wBuffer));
rBuffer.SetIndex(1);
EXPECT_FALSE(message1->Decode(rBuffer));
}
* @tc.number Telephony_SmsMmsGtest_CdmaSmsSubParameter_0016
* @tc.name Test CdmaSmsSubParameter
* @tc.desc Function test
*/
HWTEST_F(BranchCdmaSmsTest, CdmaSmsSubParameter_0016, Function | MediumTest | Level1)
{
SmsEnhancedVmnAck v1;
SmsEnhancedVmnAck v2;
auto message1 = std::make_shared<CdmaSmsEnhancedVmnAck>(v1);
SmsWriteBuffer wBuffer;
EXPECT_FALSE(message1->Encode(wBuffer));
std::stringstream ss;
ss.clear();
ss << static_cast<uint8_t>(CdmaSmsSubParameter::ENHANCED_VMN_ACK);
ss << static_cast<uint8_t>(0x05);
ss << static_cast<uint8_t>(0x00);
ss << static_cast<uint8_t>(0x00);
ss << static_cast<uint8_t>(0x00);
ss << static_cast<uint8_t>(0x00);
ss << static_cast<uint8_t>(0x00);
SmsReadBuffer rBuffer(ss.str());
auto message2 = std::make_shared<CdmaSmsEnhancedVmnAck>(v2);
EXPECT_TRUE(message2->Decode(rBuffer));
wBuffer.SetIndex(PDU_BUFFER_MAX_SIZE);
EXPECT_FALSE(message1->Encode(wBuffer));
rBuffer.SetIndex(1);
EXPECT_FALSE(message1->Decode(rBuffer));
}
* @tc.number Telephony_SmsMmsGtest_CdmaSmsSubParameter_0017
* @tc.name Test CdmaSmsSubParameter
* @tc.desc Function test
*/
HWTEST_F(BranchCdmaSmsTest, CdmaSmsSubParameter_0017, Function | MediumTest | Level1)
{
SmsStatusCode v1;
SmsStatusCode v2;
auto message1 = std::make_shared<CdmaSmsMessageStatus>(v1);
SmsWriteBuffer wBuffer;
EXPECT_FALSE(message1->Encode(wBuffer));
std::stringstream ss;
ss.clear();
ss << static_cast<uint8_t>(CdmaSmsSubParameter::MESSAGE_STATUS);
ss << static_cast<uint8_t>(0x01);
ss << static_cast<uint8_t>(0x00);
SmsReadBuffer rBuffer(ss.str());
auto message2 = std::make_shared<CdmaSmsMessageStatus>(v2);
EXPECT_TRUE(message2->Decode(rBuffer));
wBuffer.SetIndex(PDU_BUFFER_MAX_SIZE);
EXPECT_FALSE(message1->Encode(wBuffer));
rBuffer.SetIndex(1);
EXPECT_FALSE(message1->Decode(rBuffer));
}
* @tc.number Telephony_SmsMmsGtest_CdmaSmsSubParameter_0018
* @tc.name Test CdmaSmsSubParameter
* @tc.desc Function test
*/
HWTEST_F(BranchCdmaSmsTest, CdmaSmsSubParameter_0018, Function | MediumTest | Level1)
{
uint32_t v1;
uint32_t v2;
auto message1 = std::make_shared<CdmaSmsNumberMessages>(v1);
SmsWriteBuffer wBuffer;
EXPECT_FALSE(message1->Encode(wBuffer));
std::stringstream ss;
ss.clear();
ss << static_cast<uint8_t>(CdmaSmsSubParameter::NUMBER_OF_MESSAGES);
ss << static_cast<uint8_t>(0x01);
ss << static_cast<uint8_t>(0x00);
SmsReadBuffer rBuffer(ss.str());
auto message2 = std::make_shared<CdmaSmsNumberMessages>(v2);
EXPECT_TRUE(message2->Decode(rBuffer));
wBuffer.SetIndex(PDU_BUFFER_MAX_SIZE);
EXPECT_FALSE(message1->Encode(wBuffer));
rBuffer.SetIndex(1);
EXPECT_FALSE(message1->Decode(rBuffer));
}
* @tc.number Telephony_SmsMmsGtest_CdmaSmsSubParameter_0019
* @tc.name Test CdmaSmsSubParameter
* @tc.desc Function test
*/
HWTEST_F(BranchCdmaSmsTest, CdmaSmsSubParameter_0019, Function | MediumTest | Level1)
{
auto testValue = static_cast<uint8_t>(5);
uint8_t v1 = testValue;
auto message1 = std::make_shared<CdmaSmsBaseParameter>(CdmaSmsSubParameter::USER_RESPONSE_CODE, v1);
SmsWriteBuffer wBuffer;
wBuffer.data_ = nullptr;
EXPECT_FALSE(message1->Encode(wBuffer));
auto message2 = std::make_shared<CdmaSmsReservedParameter>(CdmaSmsSubParameter::USER_RESPONSE_CODE);
EXPECT_FALSE(message2->Encode(wBuffer));
SmsTeleSvcMsgId v3;
uint8_t type = static_cast<uint8_t>(TeleserviceMsgType::SUBMIT);
auto message3 = std::make_shared<CdmaSmsMessageId>(v3, type);
EXPECT_FALSE(message3->Encode(wBuffer));
SmsTimeAbs v4;
auto message4 = std::make_shared<CdmaSmsAbsoluteTime>(CdmaSmsSubParameter::VALIDITY_PERIOD_ABSOLUTE, v4);
EXPECT_FALSE(message4->Encode(wBuffer));
SmsPriorityIndicator v5 = SmsPriorityIndicator::NORMAL;;
auto message5 = std::make_shared<CdmaSmsPriorityInd>(v5);
EXPECT_FALSE(message5->Encode(wBuffer));
SmsPrivacyIndicator v6 = SmsPrivacyIndicator::RESTRICTED;
auto message6 = std::make_shared<CdmaSmsPrivacyInd>(v6);
EXPECT_FALSE(message6->Encode(wBuffer));
SmsReplyOption v7;
auto message7 = std::make_shared<CdmaSmsReplyOption>(v7);
EXPECT_FALSE(message7->Encode(wBuffer));
SmsTeleSvcUserData userData;
memset_s(&userData, sizeof(SmsTeleSvcUserData), 0x00, sizeof(SmsTeleSvcUserData));
userData.encodeType = SmsEncodingType::ASCII_7BIT;
bool headerInd = false;
auto message8 = std::make_shared<CdmaSmsUserData>(userData, headerInd);
EXPECT_FALSE(message8->Encode(wBuffer));
}
* @tc.number Telephony_SmsMmsGtest_CdmaSmsSubParameter_0020
* @tc.name Test CdmaSmsSubParameter
* @tc.desc Function test
*/
HWTEST_F(BranchCdmaSmsTest, CdmaSmsSubParameter_0020, Function | MediumTest | Level1)
{
SmsAlertPriority v1 = SmsAlertPriority::HIGH;
auto message1 = std::make_shared<CdmaSmsAlertPriority>(v1);
SmsWriteBuffer wBuffer;
wBuffer.data_ = nullptr;
EXPECT_FALSE(message1->Encode(wBuffer));
SmsLanguageType v2 = SmsLanguageType::CHINESE;
auto message2 = std::make_shared<CdmaSmsLanguageInd>(v2);
EXPECT_FALSE(message2->Encode(wBuffer));
SmsTeleSvcAddr v3;
auto message3 = std::make_shared<CdmaSmsCallbackNumber>(v3);
EXPECT_FALSE(message3->Encode(wBuffer));
uint16_t v4 = 1;
auto message4 = std::make_shared<CdmaSmsDepositIndex>(v4);
EXPECT_FALSE(message4->Encode(wBuffer));
SmsDisplayMode v5 = SmsDisplayMode::DEFAULT_SETTING;
auto message5 = std::make_shared<CdmaSmsDisplayMode>(v5);
EXPECT_FALSE(message5->Encode(wBuffer));
}
* @tc.number Telephony_SmsMmsGtest_CdmaSmsParameterRecord_0008
* @tc.name Test CdmaSmsParameterRecord
* @tc.desc Function test
*/
HWTEST_F(BranchCdmaSmsTest, CdmaSmsParameterRecord_0008, Function | MediumTest | Level1)
{
SmsWriteBuffer wBuf;
wBuf.data_ = nullptr;
SmsReadBuffer rBuf("");
rBuf.data_ = nullptr;
uint16_t cat = 0;
CdmaSmsTeleserviceId teleserviceId(cat);
EXPECT_FALSE(teleserviceId.Encode(wBuf));
CdmaSmsServiceCategory category(cat);
EXPECT_FALSE(category.Encode(wBuf));
uint8_t seq = 0;
CdmaSmsBearerReply reply(seq);
EXPECT_FALSE(reply.Encode(wBuf));
TransportCauseCode code;
CdmaSmsCauseCodes codes(code);
EXPECT_FALSE(codes.Encode(wBuf));
TransportAddr addr;
CdmaSmsAddressParameter parameter(addr, 0);
EXPECT_FALSE(parameter.Encode(wBuf));
EXPECT_FALSE(parameter.Decode(rBuf));
parameter.isInvalid_ = false;
EXPECT_FALSE(parameter.Encode(wBuf));
EXPECT_FALSE(parameter.Decode(rBuf));
EXPECT_FALSE(parameter.EncodeAddress(wBuf));
EXPECT_FALSE(parameter.DecodeAddress(rBuf));
TransportSubAddr subAddr;
CdmaSmsSubaddress address(subAddr, 0);
EXPECT_FALSE(address.Encode(wBuf));
EXPECT_FALSE(address.Decode(rBuf));
address.isInvalid_ = false;
EXPECT_FALSE(address.Encode(wBuf));
EXPECT_FALSE(address.Decode(rBuf));
CdmaTeleserviceMsg msg;
CdmaSmsBearerData data(msg);
EXPECT_FALSE(data.Encode(wBuf));
data.teleserviceMessage_ = nullptr;
EXPECT_FALSE(data.Decode(rBuf));
}
}
}
