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 "gsm_cb_codec.h"
20 #include "gsm_cb_gsm_codec.h"
21 #include "gsm_cb_umts_codec.h"
22 #include "gtest/gtest.h"
23 #include "radio_event.h"
24 #include "sms_service.h"
25 
26 namespace OHOS {
27 namespace Telephony {
28 using namespace testing::ext;
29 
30 namespace {
31 const int32_t INVALID_SLOTID = 2;
32 const uint16_t PWS_FIRST_ID = 0x1100;
33 const std::string ETWS_PDU = "000B1100011165FA7D4E9BD564";
34 const std::string CMAS_PDU = "000D11120111E376784E9BDD60";
35 const std::string CBS_PDU = "00031112011163F19C36BBC11A";
36 const std::string CMAS_JP_PDU =
37     "01A41F51101102EA3030A830EA30A230E130FC30EB914D4FE130C630B930C8000D000A3053308C306F8A669A137528306E30E130C330BB30FC"
38     "30B8306730593002000D000AFF080032003000310033002F00310031002F003252EA300037002000310035003A00340034FF09000D000AFF08"
39     "30A830EA30A25E02FF090000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
40     "0022";
41 } // namespace
42 
43 class BranchCbTest : public testing::Test {
44 public:
45     static void SetUpTestCase();
46     static void TearDownTestCase();
47     void SetUp();
48     void TearDown();
49 };
SetUpTestCase()50 void BranchCbTest::SetUpTestCase() {}
51 
TearDownTestCase()52 void BranchCbTest::TearDownTestCase() {}
53 
SetUp()54 void BranchCbTest::SetUp() {}
55 
TearDown()56 void BranchCbTest::TearDown() {}
57 
58 /**
59  * @tc.number   Telephony_SmsMmsGtest_GsmCbCodec_0001
60  * @tc.name     Test GsmCbCodec
61  * @tc.desc     Function test
62  */
63 HWTEST_F(BranchCbTest, GsmCbCodec_0001, Function | MediumTest | Level1)
64 {
65     std::vector<unsigned char> pdu;
66     unsigned char data = 1;
67     pdu.push_back(data);
68     auto cbCodec = std::make_shared<GsmCbCodec>();
69     cbCodec->PduAnalysis(pdu);
70     int8_t format = 1;
71     EXPECT_TRUE(cbCodec->GetFormat(format));
72     EXPECT_TRUE(cbCodec->GetPriority(format));
73     EXPECT_NE(cbCodec->GsmCbCodec::ToString(), "");
74     uint8_t gs = 1;
75     EXPECT_TRUE(cbCodec->GetGeoScope(gs));
76     uint16_t serial = 1;
77     EXPECT_TRUE(cbCodec->GetSerialNum(serial));
78     bool isUserAlert = false;
79     EXPECT_TRUE(cbCodec->IsEtwsEmergencyUserAlert(isUserAlert));
80     EXPECT_TRUE(cbCodec->IsEtwsPopupAlert(isUserAlert));
81     EXPECT_TRUE(cbCodec->GetServiceCategory(serial));
82     uint8_t cmasType;
83     EXPECT_TRUE(cbCodec->GetCmasResponseType(cmasType));
84     uint8_t cmasClass;
85     EXPECT_TRUE(cbCodec->GetCmasMessageClass(cmasClass));
86     EXPECT_TRUE(cbCodec->GetWarningType(serial));
87     EXPECT_TRUE(cbCodec->GetMsgType(gs));
88     EXPECT_TRUE(cbCodec->GetLangType(gs));
89     EXPECT_TRUE(cbCodec->GetDcs(gs));
90     int64_t recvTime = 0;
91     EXPECT_TRUE(cbCodec->GetReceiveTime(recvTime));
92 }
93 
94 /**
95  * @tc.number   Telephony_SmsMmsGtest_GsmCbCodec_0002
96  * @tc.name     Test GsmCbCodec
97  * @tc.desc     Function test
98  */
99 HWTEST_F(BranchCbTest, GsmCbCodec_0002, Function | MediumTest | Level1)
100 {
101     std::vector<unsigned char> pdu;
102     unsigned char data = 1;
103     pdu.push_back(data);
104     auto cbCodec = std::make_shared<GsmCbCodec>();
105     cbCodec->PduAnalysis(pdu);
106     uint8_t cmasType;
107     cbCodec->GetCmasCategory(cmasType);
108     std::string raw = "qwe";
109     std::string message = "asd";
110     cbCodec->ConvertToUTF8(raw, message);
111     cbCodec->cbHeader_ = std::make_shared<GsmCbCodec::GsmCbMessageHeader>();
112     cbCodec->cbHeader_->dcs.codingScheme = DATA_CODING_7BIT;
113     cbCodec->ConvertToUTF8(raw, message);
114     cbCodec->cbHeader_->dcs.codingScheme = DATA_CODING_UCS2;
115     cbCodec->ConvertToUTF8(raw, message);
116     cbCodec->cbHeader_->dcs.codingScheme = DATA_CODING_AUTO;
117     cbCodec->ConvertToUTF8(raw, message);
118     cbCodec->cbHeader_->bEtwsMessage = true;
119     cbCodec->cbHeader_->cbEtwsType = GsmCbCodec::ETWS_PRIMARY;
120     cbCodec->ConvertToUTF8(raw, message);
121     cbCodec->GetCbMessageRaw();
122     int8_t format = 1;
123     EXPECT_TRUE(cbCodec->GetPriority(format));
124     cbCodec->cbHeader_->msgId = PWS_FIRST_ID;
125     EXPECT_TRUE(cbCodec->GetPriority(format));
126     EXPECT_FALSE(cbCodec->IsSinglePageMsg());
127     std::string pdus = "123";
128     EXPECT_TRUE(cbCodec->CreateCbMessage(pdu) == nullptr);
129     EXPECT_FALSE(cbCodec->CreateCbMessage(pdus));
130     EXPECT_TRUE(cbCodec->GetCbHeader() != nullptr);
131 }
132 
133 /**
134  * @tc.number   Telephony_SmsMmsGtest_GsmCbCodec_0003
135  * @tc.name     Test GsmCbCodec
136  * @tc.desc     Function test
137  */
138 HWTEST_F(BranchCbTest, GsmCbCodec_0003, Function | MediumTest | Level1)
139 {
140     auto smsCbMessage = std::make_shared<GsmCbCodec>();
141     uint8_t severity = 1;
142     smsCbMessage->cbHeader_ = std::make_shared<GsmCbCodec::GsmCbMessageHeader>();
143     smsCbMessage->cbHeader_->msgId = GsmCbCodec::CmasMsgType::EXTREME_OBSERVED;
144     EXPECT_TRUE(smsCbMessage->GetCmasSeverity(severity));
145     EXPECT_TRUE(smsCbMessage->GetCmasUrgency(severity));
146     smsCbMessage->cbHeader_->msgId = GsmCbCodec::CmasMsgType::EXTREME_OBSERVED_SPANISH;
147     EXPECT_TRUE(smsCbMessage->GetCmasSeverity(severity));
148     EXPECT_TRUE(smsCbMessage->GetCmasUrgency(severity));
149     smsCbMessage->cbHeader_->msgId = GsmCbCodec::CmasMsgType::EXTREME_LIKELY;
150     EXPECT_TRUE(smsCbMessage->GetCmasSeverity(severity));
151     EXPECT_TRUE(smsCbMessage->GetCmasUrgency(severity));
152     smsCbMessage->cbHeader_->msgId = GsmCbCodec::CmasMsgType::EXTREME_LIKELY_SPANISH;
153     EXPECT_TRUE(smsCbMessage->GetCmasSeverity(severity));
154     EXPECT_TRUE(smsCbMessage->GetCmasUrgency(severity));
155     smsCbMessage->cbHeader_->msgId = GsmCbCodec::CmasMsgType::EXTREME_OBSERVED;
156     EXPECT_TRUE(smsCbMessage->GetCmasSeverity(severity));
157     EXPECT_TRUE(smsCbMessage->GetCmasUrgency(severity));
158     smsCbMessage->cbHeader_->msgId = GsmCbCodec::CmasMsgType::SEVERE_OBSERVED_SPANISH;
159     EXPECT_TRUE(smsCbMessage->GetCmasSeverity(severity));
160     EXPECT_TRUE(smsCbMessage->GetCmasUrgency(severity));
161     smsCbMessage->cbHeader_->msgId = GsmCbCodec::CmasMsgType::SEVERE_LIKELY;
162     EXPECT_TRUE(smsCbMessage->GetCmasSeverity(severity));
163     EXPECT_TRUE(smsCbMessage->GetCmasUrgency(severity));
164     smsCbMessage->cbHeader_->msgId = GsmCbCodec::CmasMsgType::SEVERE_LIKELY_SPANISH;
165     EXPECT_TRUE(smsCbMessage->GetCmasSeverity(severity));
166     EXPECT_TRUE(smsCbMessage->GetCmasUrgency(severity));
167     smsCbMessage->cbHeader_->msgId = GsmCbCodec::CmasMsgType::ALERT_OBSERVED_DEFUALT;
168     EXPECT_TRUE(smsCbMessage->GetCmasSeverity(severity));
169     EXPECT_TRUE(smsCbMessage->GetCmasUrgency(severity));
170     smsCbMessage->cbHeader_->msgId = GsmCbCodec::CmasMsgType::ALERT_OBSERVED_SPANISH;
171     EXPECT_TRUE(smsCbMessage->GetCmasSeverity(severity));
172     EXPECT_TRUE(smsCbMessage->GetCmasUrgency(severity));
173     smsCbMessage->cbHeader_->msgId = GsmCbCodec::CmasMsgType::ALERT_LIKELY;
174     EXPECT_TRUE(smsCbMessage->GetCmasSeverity(severity));
175     EXPECT_TRUE(smsCbMessage->GetCmasUrgency(severity));
176     smsCbMessage->cbHeader_->msgId = GsmCbCodec::CmasMsgType::ALERT_LIKELY_SPANISH;
177     EXPECT_TRUE(smsCbMessage->GetCmasSeverity(severity));
178     EXPECT_TRUE(smsCbMessage->GetCmasUrgency(severity));
179     smsCbMessage->cbHeader_->msgId = GsmCbCodec::CmasMsgType::EXPECTED_OBSERVED;
180     EXPECT_TRUE(smsCbMessage->GetCmasSeverity(severity));
181     EXPECT_TRUE(smsCbMessage->GetCmasUrgency(severity));
182     smsCbMessage->cbHeader_->msgId = GsmCbCodec::CmasMsgType::EXPECTED_OBSERVED_SPANISH;
183     EXPECT_TRUE(smsCbMessage->GetCmasSeverity(severity));
184     EXPECT_TRUE(smsCbMessage->GetCmasUrgency(severity));
185     smsCbMessage->cbHeader_->msgId = GsmCbCodec::CmasMsgType::EXPECTED_LIKELY;
186     EXPECT_TRUE(smsCbMessage->GetCmasSeverity(severity));
187     EXPECT_TRUE(smsCbMessage->GetCmasUrgency(severity));
188 }
189 
190 /**
191  * @tc.number   Telephony_SmsMmsGtest_GsmCbCodec_0004
192  * @tc.name     Test GsmCbCodec
193  * @tc.desc     Function test
194  */
195 HWTEST_F(BranchCbTest, GsmCbCodec_0004, Function | MediumTest | Level1)
196 {
197     auto smsCbMessage = std::make_shared<GsmCbCodec>();
198     uint8_t severity = 1;
199     smsCbMessage->cbHeader_ = std::make_shared<GsmCbCodec::GsmCbMessageHeader>();
200     smsCbMessage->cbHeader_->msgId = GsmCbCodec::CmasMsgType::EXPECTED_LIKELY_SPANISH;
201     EXPECT_TRUE(smsCbMessage->GetCmasSeverity(severity));
202     EXPECT_TRUE(smsCbMessage->GetCmasUrgency(severity));
203     EXPECT_TRUE(smsCbMessage->GetCmasCertainty(severity));
204     smsCbMessage->cbHeader_->msgId = GsmCbCodec::CmasMsgType::OPERATOR_ALERT_SPANISH;
205     EXPECT_TRUE(smsCbMessage->GetCmasSeverity(severity));
206     EXPECT_TRUE(smsCbMessage->GetCmasUrgency(severity));
207     EXPECT_TRUE(smsCbMessage->GetCmasCertainty(severity));
208     smsCbMessage->cbHeader_->msgId = GsmCbCodec::CmasMsgType::EXTREME_OBSERVED;
209     EXPECT_TRUE(smsCbMessage->GetCmasCertainty(severity));
210     smsCbMessage->cbHeader_->msgId = GsmCbCodec::CmasMsgType::EXTREME_OBSERVED_SPANISH;
211     EXPECT_TRUE(smsCbMessage->GetCmasCertainty(severity));
212     smsCbMessage->cbHeader_->msgId = GsmCbCodec::CmasMsgType::SEVERE_OBSERVED;
213     EXPECT_TRUE(smsCbMessage->GetCmasCertainty(severity));
214     smsCbMessage->cbHeader_->msgId = GsmCbCodec::CmasMsgType::SEVERE_OBSERVED_SPANISH;
215     EXPECT_TRUE(smsCbMessage->GetCmasCertainty(severity));
216     smsCbMessage->cbHeader_->msgId = GsmCbCodec::CmasMsgType::ALERT_OBSERVED_DEFUALT;
217     EXPECT_TRUE(smsCbMessage->GetCmasCertainty(severity));
218     smsCbMessage->cbHeader_->msgId = GsmCbCodec::CmasMsgType::ALERT_OBSERVED_SPANISH;
219     EXPECT_TRUE(smsCbMessage->GetCmasCertainty(severity));
220     smsCbMessage->cbHeader_->msgId = GsmCbCodec::CmasMsgType::EXPECTED_OBSERVED;
221     EXPECT_TRUE(smsCbMessage->GetCmasCertainty(severity));
222     smsCbMessage->cbHeader_->msgId = GsmCbCodec::CmasMsgType::EXPECTED_OBSERVED_SPANISH;
223     EXPECT_TRUE(smsCbMessage->GetCmasCertainty(severity));
224     smsCbMessage->cbHeader_->msgId = GsmCbCodec::CmasMsgType::EXTREME_LIKELY;
225     EXPECT_TRUE(smsCbMessage->GetCmasCertainty(severity));
226     smsCbMessage->cbHeader_->msgId = GsmCbCodec::CmasMsgType::EXTREME_LIKELY_SPANISH;
227     EXPECT_TRUE(smsCbMessage->GetCmasCertainty(severity));
228     smsCbMessage->cbHeader_->msgId = GsmCbCodec::CmasMsgType::SEVERE_LIKELY;
229     EXPECT_TRUE(smsCbMessage->GetCmasCertainty(severity));
230     smsCbMessage->cbHeader_->msgId = GsmCbCodec::CmasMsgType::SEVERE_LIKELY_SPANISH;
231     EXPECT_TRUE(smsCbMessage->GetCmasCertainty(severity));
232     smsCbMessage->cbHeader_->msgId = GsmCbCodec::CmasMsgType::ALERT_LIKELY;
233     EXPECT_TRUE(smsCbMessage->GetCmasCertainty(severity));
234     smsCbMessage->cbHeader_->msgId = GsmCbCodec::CmasMsgType::ALERT_LIKELY_SPANISH;
235     EXPECT_TRUE(smsCbMessage->GetCmasCertainty(severity));
236     smsCbMessage->cbHeader_->msgId = GsmCbCodec::CmasMsgType::EXPECTED_LIKELY;
237     EXPECT_TRUE(smsCbMessage->GetCmasCertainty(severity));
238 }
239 
240 /**
241  * @tc.number   Telephony_SmsMmsGtest_GsmCbCodec_0005
242  * @tc.name     Test GsmCbCodec
243  * @tc.desc     Function test
244  */
245 HWTEST_F(BranchCbTest, GsmCbCodec_0005, Function | MediumTest | Level1)
246 {
247     auto cbMsg = std::make_shared<GsmCbCodec>();
248     auto gsmMsg = std::make_shared<GsmCbGsmCodec>(cbMsg->cbHeader_, cbMsg->cbPduBuffer_, cbMsg);
249     auto umtsMsg = std::make_shared<GsmCbUmtsCodec>(cbMsg->cbHeader_, cbMsg->cbPduBuffer_, cbMsg);
250     if (cbMsg == nullptr || gsmMsg == nullptr || umtsMsg == nullptr) {
251         EXPECT_TRUE(false);
252         return;
253     }
254     EXPECT_FALSE(gsmMsg->Decode2gHeader());
255     unsigned char data = 1;
256     std::vector<unsigned char> pdu;
257     pdu.push_back(data);
258     cbMsg->PduAnalysis(pdu);
259     gsmMsg->Decode2gCbMsg();
260     umtsMsg->Decode3gCbMsg();
261     cbMsg->cbHeader_ = std::make_shared<GsmCbCodec::GsmCbMessageHeader>();
262     cbMsg->cbHeader_->dcs.codingScheme = DataCodingScheme::DATA_CODING_7BIT;
263     gsmMsg->Decode2gCbMsg();
264     umtsMsg->Decode3gCbMsg();
265     cbMsg->cbHeader_->dcs.codingScheme = DataCodingScheme::DATA_CODING_8BIT;
266     gsmMsg->Decode2gCbMsg();
267     umtsMsg->Decode3gCbMsg();
268     cbMsg->cbHeader_->dcs.codingScheme = DataCodingScheme::DATA_CODING_UCS2;
269     gsmMsg->Decode2gCbMsg();
270     umtsMsg->Decode3gCbMsg();
271     cbMsg->cbHeader_->dcs.codingScheme = DataCodingScheme::DATA_CODING_ASCII7BIT;
272     gsmMsg->Decode2gCbMsg();
273     umtsMsg->Decode3gCbMsg();
274     cbMsg->cbHeader_->totalPages = 1;
275     umtsMsg->Decode3g7Bit();
276     umtsMsg->Decode3gUCS2();
277     EXPECT_EQ(cbMsg->CMASClass(GsmCbCodec::PRESIDENTIAL), GsmCbCodec::GSMCbMsgSubType::CMAS_PRESIDENTIAL);
278     EXPECT_EQ(cbMsg->CMASClass(GsmCbCodec::PRESIDENTIAL_SPANISH), GsmCbCodec::GSMCbMsgSubType::CMAS_PRESIDENTIAL);
279     EXPECT_EQ(cbMsg->CMASClass(GsmCbCodec::EXTREME_OBSERVED), GsmCbCodec::GSMCbMsgSubType::CMAS_EXTREME);
280     EXPECT_EQ(cbMsg->CMASClass(GsmCbCodec::EXTREME_OBSERVED_SPANISH), GsmCbCodec::GSMCbMsgSubType::CMAS_EXTREME);
281     EXPECT_EQ(cbMsg->CMASClass(GsmCbCodec::EXTREME_LIKELY), GsmCbCodec::GSMCbMsgSubType::CMAS_EXTREME);
282     EXPECT_EQ(cbMsg->CMASClass(GsmCbCodec::EXTREME_LIKELY_SPANISH), GsmCbCodec::GSMCbMsgSubType::CMAS_EXTREME);
283     EXPECT_EQ(cbMsg->CMASClass(GsmCbCodec::SEVERE_OBSERVED), GsmCbCodec::GSMCbMsgSubType::CMAS_SEVERE);
284     EXPECT_EQ(cbMsg->CMASClass(GsmCbCodec::SEVERE_OBSERVED_SPANISH), GsmCbCodec::GSMCbMsgSubType::CMAS_SEVERE);
285     EXPECT_EQ(cbMsg->CMASClass(GsmCbCodec::SEVERE_LIKELY), GsmCbCodec::GSMCbMsgSubType::CMAS_SEVERE);
286     EXPECT_EQ(cbMsg->CMASClass(GsmCbCodec::SEVERE_LIKELY_SPANISH), GsmCbCodec::GSMCbMsgSubType::CMAS_SEVERE);
287     EXPECT_EQ(cbMsg->CMASClass(GsmCbCodec::ALERT_OBSERVED_DEFUALT), GsmCbCodec::GSMCbMsgSubType::CMAS_SEVERE);
288     EXPECT_EQ(cbMsg->CMASClass(GsmCbCodec::ALERT_OBSERVED_SPANISH), GsmCbCodec::GSMCbMsgSubType::CMAS_SEVERE);
289 }
290 
291 /**
292  * @tc.number   Telephony_SmsMmsGtest_GsmCbCodec_0006
293  * @tc.name     Test GsmCbCodec
294  * @tc.desc     Function test
295  */
296 HWTEST_F(BranchCbTest, GsmCbCodec_0006, Function | MediumTest | Level1)
297 {
298     auto smsCbMessage = std::make_shared<GsmCbCodec>();
299     EXPECT_EQ(smsCbMessage->CMASClass(GsmCbCodec::ALERT_LIKELY), GsmCbCodec::GSMCbMsgSubType::CMAS_SEVERE);
300     EXPECT_EQ(smsCbMessage->CMASClass(GsmCbCodec::ALERT_LIKELY_SPANISH), GsmCbCodec::GSMCbMsgSubType::CMAS_SEVERE);
301     EXPECT_EQ(smsCbMessage->CMASClass(GsmCbCodec::EXPECTED_OBSERVED), GsmCbCodec::GSMCbMsgSubType::CMAS_SEVERE);
302     EXPECT_EQ(smsCbMessage->CMASClass(GsmCbCodec::EXPECTED_OBSERVED_SPANISH), GsmCbCodec::GSMCbMsgSubType::CMAS_SEVERE);
303     EXPECT_EQ(smsCbMessage->CMASClass(GsmCbCodec::EXPECTED_LIKELY_SPANISH), GsmCbCodec::GSMCbMsgSubType::CMAS_SEVERE);
304     EXPECT_EQ(smsCbMessage->CMASClass(GsmCbCodec::EXPECTED_LIKELY_SPANISH), GsmCbCodec::GSMCbMsgSubType::CMAS_SEVERE);
305     EXPECT_EQ(smsCbMessage->CMASClass(GsmCbCodec::AMBER_ALERT), GsmCbCodec::GSMCbMsgSubType::CMAS_AMBER);
306     EXPECT_EQ(smsCbMessage->CMASClass(GsmCbCodec::AMBER_ALERT_SPANISH), GsmCbCodec::GSMCbMsgSubType::CMAS_AMBER);
307     EXPECT_EQ(smsCbMessage->CMASClass(GsmCbCodec::MONTHLY_ALERT), GsmCbCodec::GSMCbMsgSubType::CMAS_TEST);
308     EXPECT_EQ(smsCbMessage->CMASClass(GsmCbCodec::MONTHLY_ALERT_SPANISH), GsmCbCodec::GSMCbMsgSubType::CMAS_TEST);
309     EXPECT_EQ(smsCbMessage->CMASClass(GsmCbCodec::EXERCISE_ALERT), GsmCbCodec::GSMCbMsgSubType::CMAS_EXERCISE);
310     EXPECT_EQ(smsCbMessage->CMASClass(GsmCbCodec::EXERCISE_ALERT_SPANISH), GsmCbCodec::GSMCbMsgSubType::CMAS_EXERCISE);
311     EXPECT_EQ(smsCbMessage->CMASClass(GsmCbCodec::OPERATOR_ALERT), GsmCbCodec::GSMCbMsgSubType::CMAS_OPERATOR_DEFINED);
312     EXPECT_EQ(smsCbMessage->CMASClass(GsmCbCodec::OPERATOR_ALERT_SPANISH),
313         GsmCbCodec::GSMCbMsgSubType::CMAS_OPERATOR_DEFINED);
314 }
315 
316 /**
317  * @tc.number   Telephony_SmsMmsGtest_GsmCbGsmCodec_0001
318  * @tc.name     Test GsmCbGsmCodec
319  * @tc.desc     Function test
320  */
321 HWTEST_F(BranchCbTest, GsmCbGsmCodec_0001, Function | MediumTest | Level1)
322 {
323     auto cbMsg = std::make_shared<GsmCbCodec>();
324     if (cbMsg == nullptr) {
325         TELEPHONY_LOGI("cbMsg nullptr");
326         EXPECT_TRUE(false);
327         return;
328     }
329     cbMsg->CreateCbMessage(ETWS_PDU);
330     std::vector<unsigned char> pdu = StringUtils::HexToByteVector(ETWS_PDU);
331     cbMsg->cbPduBuffer_ = std::make_shared<GsmCbPduDecodeBuffer>(pdu.size());
332     cbMsg->cbHeader_ = std::make_shared<GsmCbCodec::GsmCbMessageHeader>();
333     for (size_t index = 0; index < pdu.size() && index < cbMsg->cbPduBuffer_->GetSize(); index++) {
334         cbMsg->cbPduBuffer_->pduBuffer_[index] = static_cast<char>(pdu[index]);
335     }
336     auto gsmMsg = std::make_shared<GsmCbGsmCodec>(cbMsg->cbHeader_, cbMsg->cbPduBuffer_, cbMsg);
337     auto umtsMsg = std::make_shared<GsmCbUmtsCodec>(cbMsg->cbHeader_, cbMsg->cbPduBuffer_, cbMsg);
338     gsmMsg->cbPduBuffer_ = cbMsg->cbPduBuffer_;
339     umtsMsg->cbPduBuffer_ = cbMsg->cbPduBuffer_;
340     gsmMsg->Decode2gHeader();
341     gsmMsg->Decode2gHeaderEtws();
342     EXPECT_TRUE(gsmMsg->Decode2gCbMsg());
343 
344     gsmMsg->Decode2gHeaderCommonCb();
345     uint16_t dataLen = gsmMsg->cbPduBuffer_->GetSize() - gsmMsg->cbPduBuffer_->GetCurPosition();
346     gsmMsg->Decode2gCbMsg7bit(dataLen);
347     EXPECT_TRUE(gsmMsg->DecodeEtwsMsg());
348 
349     umtsMsg->Decode3gHeader();
350     umtsMsg->Decode3gHeaderPartData(0);
351     umtsMsg->Decode3gCbMsg();
352     umtsMsg->Decode3g7Bit();
353     EXPECT_FALSE(umtsMsg->Decode3gUCS2());
354     cbMsg->cbHeader_ = std::make_shared<GsmCbCodec::GsmCbMessageHeader>();
355     cbMsg->cbHeader_->dcs.codingScheme = DataCodingScheme::DATA_CODING_7BIT;
356     gsmMsg->Decode2gCbMsg();
357     EXPECT_FALSE(umtsMsg->Decode3gCbMsg());
358 
359     cbMsg->cbHeader_->dcs.codingScheme = DataCodingScheme::DATA_CODING_8BIT;
360     gsmMsg->Decode2gCbMsg();
361     EXPECT_FALSE(umtsMsg->Decode3gCbMsg());
362     cbMsg->cbHeader_->dcs.codingScheme = DataCodingScheme::DATA_CODING_UCS2;
363     gsmMsg->Decode2gCbMsg();
364     EXPECT_FALSE(umtsMsg->Decode3gCbMsg());
365 
366     cbMsg->cbHeader_->dcs.codingScheme = DataCodingScheme::DATA_CODING_ASCII7BIT;
367     gsmMsg->Decode2gCbMsg();
368     EXPECT_FALSE(umtsMsg->Decode3gCbMsg());
369     cbMsg->cbHeader_->totalPages = 1;
370     umtsMsg->Decode3g7Bit();
371     EXPECT_FALSE(umtsMsg->Decode3gUCS2());
372 }
373 
374 /**
375  * @tc.number   Telephony_SmsMmsGtest_GsmCbGsmCodec_0002
376  * @tc.name     Test GsmCbGsmCodec
377  * @tc.desc     Function test
378  */
379 HWTEST_F(BranchCbTest, GsmCbGsmCodec_0002, Function | MediumTest | Level1)
380 {
381     auto cbMsg = std::make_shared<GsmCbCodec>();
382     if (cbMsg == nullptr) {
383         TELEPHONY_LOGI("cbMsg nullptr");
384         EXPECT_TRUE(false);
385         return;
386     }
387     cbMsg->CreateCbMessage(CMAS_PDU);
388     std::vector<unsigned char> pdu = StringUtils::HexToByteVector(CMAS_PDU);
389     cbMsg->cbPduBuffer_ = std::make_shared<GsmCbPduDecodeBuffer>(pdu.size());
390     cbMsg->cbHeader_ = std::make_shared<GsmCbCodec::GsmCbMessageHeader>();
391     for (size_t index = 0; index < pdu.size() && index < cbMsg->cbPduBuffer_->GetSize(); index++) {
392         cbMsg->cbPduBuffer_->pduBuffer_[index] = static_cast<char>(pdu[index]);
393     }
394     auto gsmMsg = std::make_shared<GsmCbGsmCodec>(cbMsg->cbHeader_, cbMsg->cbPduBuffer_, cbMsg);
395     auto umtsMsg = std::make_shared<GsmCbUmtsCodec>(cbMsg->cbHeader_, cbMsg->cbPduBuffer_, cbMsg);
396     gsmMsg->cbPduBuffer_ = cbMsg->cbPduBuffer_;
397     umtsMsg->cbPduBuffer_ = cbMsg->cbPduBuffer_;
398     gsmMsg->Decode2gHeader();
399     gsmMsg->Decode2gHeaderEtws();
400     EXPECT_TRUE(gsmMsg->Decode2gCbMsg());
401 
402     gsmMsg->Decode2gHeaderCommonCb();
403     uint16_t dataLen = gsmMsg->cbPduBuffer_->GetSize() - gsmMsg->cbPduBuffer_->GetCurPosition();
404     gsmMsg->Decode2gCbMsg7bit(dataLen);
405     EXPECT_TRUE(gsmMsg->DecodeEtwsMsg());
406 
407     umtsMsg->Decode3gHeader();
408     umtsMsg->Decode3gHeaderPartData(0);
409     umtsMsg->Decode3gCbMsg();
410     umtsMsg->Decode3g7Bit();
411     EXPECT_FALSE(umtsMsg->Decode3gUCS2());
412     cbMsg->cbHeader_ = std::make_shared<GsmCbCodec::GsmCbMessageHeader>();
413     cbMsg->cbHeader_->dcs.codingScheme = DataCodingScheme::DATA_CODING_7BIT;
414     gsmMsg->Decode2gCbMsg();
415     EXPECT_FALSE(umtsMsg->Decode3gCbMsg());
416 
417     cbMsg->cbHeader_->dcs.codingScheme = DataCodingScheme::DATA_CODING_8BIT;
418     gsmMsg->Decode2gCbMsg();
419     EXPECT_FALSE(umtsMsg->Decode3gCbMsg());
420     cbMsg->cbHeader_->dcs.codingScheme = DataCodingScheme::DATA_CODING_UCS2;
421     gsmMsg->Decode2gCbMsg();
422     EXPECT_FALSE(umtsMsg->Decode3gCbMsg());
423 
424     cbMsg->cbHeader_->dcs.codingScheme = DataCodingScheme::DATA_CODING_ASCII7BIT;
425     gsmMsg->Decode2gCbMsg();
426     EXPECT_FALSE(umtsMsg->Decode3gCbMsg());
427     cbMsg->cbHeader_->totalPages = 1;
428     umtsMsg->Decode3g7Bit();
429     EXPECT_FALSE(umtsMsg->Decode3gUCS2());
430 }
431 
432 /**
433  * @tc.number   Telephony_SmsMmsGtest_GsmCbGsmCodec_0003
434  * @tc.name     Test GsmCbGsmCodec
435  * @tc.desc     Function test
436  */
437 HWTEST_F(BranchCbTest, GsmCbGsmCodec_0003, Function | MediumTest | Level1)
438 {
439     auto cbMsg = std::make_shared<GsmCbCodec>();
440     if (cbMsg == nullptr) {
441         TELEPHONY_LOGI("cbMsg nullptr");
442         EXPECT_TRUE(false);
443         return;
444     }
445     cbMsg->CreateCbMessage(CBS_PDU);
446     std::vector<unsigned char> pdu = StringUtils::HexToByteVector(CBS_PDU);
447     cbMsg->cbPduBuffer_ = std::make_shared<GsmCbPduDecodeBuffer>(pdu.size());
448     cbMsg->cbHeader_ = std::make_shared<GsmCbCodec::GsmCbMessageHeader>();
449     for (size_t index = 0; index < pdu.size() && index < cbMsg->cbPduBuffer_->GetSize(); index++) {
450         cbMsg->cbPduBuffer_->pduBuffer_[index] = static_cast<char>(pdu[index]);
451     }
452     auto gsmMsg = std::make_shared<GsmCbGsmCodec>(cbMsg->cbHeader_, cbMsg->cbPduBuffer_, cbMsg);
453     auto umtsMsg = std::make_shared<GsmCbUmtsCodec>(cbMsg->cbHeader_, cbMsg->cbPduBuffer_, cbMsg);
454     gsmMsg->cbPduBuffer_ = cbMsg->cbPduBuffer_;
455     umtsMsg->cbPduBuffer_ = cbMsg->cbPduBuffer_;
456     gsmMsg->Decode2gHeader();
457     gsmMsg->Decode2gHeaderEtws();
458     EXPECT_TRUE(gsmMsg->Decode2gCbMsg());
459 
460     gsmMsg->Decode2gHeaderCommonCb();
461     uint16_t dataLen = gsmMsg->cbPduBuffer_->GetSize() - gsmMsg->cbPduBuffer_->GetCurPosition();
462     gsmMsg->Decode2gCbMsg7bit(dataLen);
463     EXPECT_TRUE(gsmMsg->DecodeEtwsMsg());
464 
465     umtsMsg->Decode3gHeader();
466     umtsMsg->Decode3gHeaderPartData(0);
467     umtsMsg->Decode3gCbMsg();
468     umtsMsg->Decode3g7Bit();
469     EXPECT_FALSE(umtsMsg->Decode3gUCS2());
470     cbMsg->cbHeader_ = std::make_shared<GsmCbCodec::GsmCbMessageHeader>();
471     cbMsg->cbHeader_->dcs.codingScheme = DataCodingScheme::DATA_CODING_7BIT;
472     gsmMsg->Decode2gCbMsg();
473     EXPECT_FALSE(umtsMsg->Decode3gCbMsg());
474 
475     cbMsg->cbHeader_->dcs.codingScheme = DataCodingScheme::DATA_CODING_8BIT;
476     gsmMsg->Decode2gCbMsg();
477     EXPECT_FALSE(umtsMsg->Decode3gCbMsg());
478     cbMsg->cbHeader_->dcs.codingScheme = DataCodingScheme::DATA_CODING_UCS2;
479     gsmMsg->Decode2gCbMsg();
480     EXPECT_FALSE(umtsMsg->Decode3gCbMsg());
481 
482     cbMsg->cbHeader_->dcs.codingScheme = DataCodingScheme::DATA_CODING_ASCII7BIT;
483     gsmMsg->Decode2gCbMsg();
484     EXPECT_FALSE(umtsMsg->Decode3gCbMsg());
485     cbMsg->cbHeader_->totalPages = 1;
486     umtsMsg->Decode3g7Bit();
487     EXPECT_FALSE(umtsMsg->Decode3gUCS2());
488 }
489 
490 /**
491  * @tc.number   Telephony_SmsMmsGtest_GsmCbGsmCodec_0004
492  * @tc.name     Test GsmCbGsmCodec
493  * @tc.desc     Function test
494  */
495 HWTEST_F(BranchCbTest, GsmCbGsmCodec_0004, Function | MediumTest | Level1)
496 {
497     auto cbMsg = std::make_shared<GsmCbCodec>();
498     if (cbMsg == nullptr) {
499         TELEPHONY_LOGI("cbMsg nullptr");
500         EXPECT_TRUE(false);
501         return;
502     }
503     cbMsg->CreateCbMessage(CMAS_JP_PDU);
504     std::vector<unsigned char> pdu = StringUtils::HexToByteVector(CMAS_JP_PDU);
505     cbMsg->cbPduBuffer_ = std::make_shared<GsmCbPduDecodeBuffer>(pdu.size());
506     cbMsg->cbHeader_ = std::make_shared<GsmCbCodec::GsmCbMessageHeader>();
507     for (size_t index = 0; index < pdu.size() && index < cbMsg->cbPduBuffer_->GetSize(); index++) {
508         cbMsg->cbPduBuffer_->pduBuffer_[index] = static_cast<char>(pdu[index]);
509     }
510     auto gsmMsg = std::make_shared<GsmCbGsmCodec>(cbMsg->cbHeader_, cbMsg->cbPduBuffer_, cbMsg);
511     auto umtsMsg = std::make_shared<GsmCbUmtsCodec>(cbMsg->cbHeader_, cbMsg->cbPduBuffer_, cbMsg);
512     gsmMsg->cbPduBuffer_ = cbMsg->cbPduBuffer_;
513     umtsMsg->cbPduBuffer_ = cbMsg->cbPduBuffer_;
514     gsmMsg->Decode2gHeader();
515     gsmMsg->Decode2gHeaderEtws();
516     EXPECT_TRUE(gsmMsg->Decode2gCbMsg());
517 
518     gsmMsg->Decode2gHeaderCommonCb();
519     uint16_t dataLen = gsmMsg->cbPduBuffer_->GetSize() - gsmMsg->cbPduBuffer_->GetCurPosition();
520     gsmMsg->Decode2gCbMsg7bit(dataLen);
521     EXPECT_FALSE(gsmMsg->DecodeEtwsMsg());
522 
523     umtsMsg->Decode3gHeader();
524     umtsMsg->Decode3gHeaderPartData(0);
525     umtsMsg->Decode3gCbMsg();
526     umtsMsg->Decode3g7Bit();
527     EXPECT_TRUE(umtsMsg->Decode3gUCS2());
528     cbMsg->cbHeader_ = std::make_shared<GsmCbCodec::GsmCbMessageHeader>();
529     cbMsg->cbHeader_->dcs.codingScheme = DataCodingScheme::DATA_CODING_7BIT;
530     gsmMsg->Decode2gCbMsg();
531     EXPECT_TRUE(umtsMsg->Decode3gCbMsg());
532 
533     cbMsg->cbHeader_->dcs.codingScheme = DataCodingScheme::DATA_CODING_8BIT;
534     gsmMsg->Decode2gCbMsg();
535     EXPECT_TRUE(umtsMsg->Decode3gCbMsg());
536     cbMsg->cbHeader_->dcs.codingScheme = DataCodingScheme::DATA_CODING_UCS2;
537     gsmMsg->Decode2gCbMsg();
538     EXPECT_TRUE(umtsMsg->Decode3gCbMsg());
539 
540     cbMsg->cbHeader_->dcs.codingScheme = DataCodingScheme::DATA_CODING_ASCII7BIT;
541     gsmMsg->Decode2gCbMsg();
542     EXPECT_TRUE(umtsMsg->Decode3gCbMsg());
543     cbMsg->cbHeader_->totalPages = 1;
544     umtsMsg->Decode3g7Bit();
545     EXPECT_TRUE(umtsMsg->Decode3gUCS2());
546 }
547 
548 /**
549  * @tc.number   Telephony_SmsMmsGtest_GsmCbGsmCodec_0005
550  * @tc.name     Test GsmCbGsmCodec
551  * @tc.desc     Function test
552  */
553 HWTEST_F(BranchCbTest, GsmCbGsmCodec_0005, Function | MediumTest | Level1)
554 {
555     auto cbMsg = std::make_shared<GsmCbCodec>();
556     unsigned char data = 1;
557     std::vector<unsigned char> pdu;
558     pdu.push_back(data);
559     cbMsg->PduAnalysis(pdu);
560     auto gsmMsg = std::make_shared<GsmCbGsmCodec>(cbMsg->cbHeader_, cbMsg->cbPduBuffer_, cbMsg);
561     auto umtsMsg = std::make_shared<GsmCbUmtsCodec>(cbMsg->cbHeader_, cbMsg->cbPduBuffer_, cbMsg);
562     if (cbMsg == nullptr || gsmMsg == nullptr || umtsMsg == nullptr) {
563         EXPECT_TRUE(false);
564         return;
565     }
566 
567     gsmMsg->Decode2gCbMsg();
568     EXPECT_FALSE(umtsMsg->Decode3gCbMsg());
569     cbMsg->cbHeader_ = std::make_shared<GsmCbCodec::GsmCbMessageHeader>();
570     cbMsg->cbHeader_->dcs.codingScheme = DataCodingScheme::DATA_CODING_7BIT;
571     gsmMsg->Decode2gCbMsg();
572     EXPECT_FALSE(umtsMsg->Decode3gCbMsg());
573     cbMsg->cbHeader_->dcs.codingScheme = DataCodingScheme::DATA_CODING_8BIT;
574     gsmMsg->Decode2gCbMsg();
575     EXPECT_FALSE(umtsMsg->Decode3gCbMsg());
576     cbMsg->cbHeader_->dcs.codingScheme = DataCodingScheme::DATA_CODING_UCS2;
577     gsmMsg->Decode2gCbMsg();
578     EXPECT_FALSE(umtsMsg->Decode3gCbMsg());
579     cbMsg->cbHeader_->dcs.codingScheme = DataCodingScheme::DATA_CODING_ASCII7BIT;
580     gsmMsg->Decode2gCbMsg();
581     umtsMsg->Decode3gCbMsg();
582     cbMsg->cbHeader_->totalPages = 1;
583     umtsMsg->Decode3g7Bit();
584     EXPECT_FALSE(umtsMsg->Decode3gUCS2());
585 }
586 
587 /**
588  * @tc.number   Telephony_SmsMmsGtest_GsmSmsCbHandler_0001
589  * @tc.name     Test GsmSmsCbHandler
590  * @tc.desc     Function test
591  */
592 HWTEST_F(BranchCbTest, GsmSmsCbHandler_0001, Function | MediumTest | Level1)
593 {
594     auto gsmSmsCbHandler = std::make_shared<GsmSmsCbHandler>(INVALID_SLOTID);
595     auto cbMessage = std::make_shared<GsmCbCodec>();
596     auto message = std::make_shared<CBConfigReportInfo>();
597     AppExecFwk::InnerEvent::Pointer event = AppExecFwk::InnerEvent::Get(RadioEvent::RADIO_CELL_BROADCAST, 1);
598     gsmSmsCbHandler->ProcessEvent(event);
599     event = AppExecFwk::InnerEvent::Get(RadioEvent::RADIO_GET_STATUS, 1);
600     gsmSmsCbHandler->ProcessEvent(event);
601     gsmSmsCbHandler->HandleCbMessage(message);
602     EXPECT_EQ(gsmSmsCbHandler->CheckCbMessage(cbMessage), 0);
603     EXPECT_TRUE(gsmSmsCbHandler->FindCbMessage(cbMessage) == nullptr);
604     EXPECT_FALSE(gsmSmsCbHandler->AddCbMessageToList(cbMessage));
605     EXPECT_FALSE(gsmSmsCbHandler->SendCbMessageBroadcast(cbMessage));
606     cbMessage->cbHeader_ = std::make_shared<GsmCbCodec::GsmCbMessageHeader>();
607     EXPECT_EQ(gsmSmsCbHandler->CheckCbMessage(cbMessage), 1);
608     cbMessage->cbHeader_->totalPages = 1;
609     EXPECT_EQ(gsmSmsCbHandler->CheckCbMessage(cbMessage), 0x01);
610     EXPECT_FALSE(gsmSmsCbHandler->AddCbMessageToList(cbMessage));
611     CbInfo cbInfo;
612     gsmSmsCbHandler->cbMsgList_.push_back(cbInfo);
613     EXPECT_EQ(gsmSmsCbHandler->CheckCbMessage(cbMessage), 0x01);
614     cbMessage = nullptr;
615     message = nullptr;
616     event = nullptr;
617     gsmSmsCbHandler->ProcessEvent(event);
618     SmsCbData::CbData sendData;
619     gsmSmsCbHandler->GetCbData(cbMessage, sendData);
620     EventFwk::Want want;
621     gsmSmsCbHandler->PackageWantData(sendData, want);
622     gsmSmsCbHandler->HandleCbMessage(message);
623     EXPECT_FALSE(gsmSmsCbHandler->CheckCbActive(cbMessage));
624     EXPECT_FALSE(gsmSmsCbHandler->AddCbMessageToList(cbMessage));
625     EXPECT_FALSE(gsmSmsCbHandler->SendCbMessageBroadcast(cbMessage));
626     EXPECT_TRUE(gsmSmsCbHandler->FindCbMessage(cbMessage) == nullptr);
627     EXPECT_EQ(gsmSmsCbHandler->CheckCbMessage(cbMessage), 0);
628 }
629 } // namespace Telephony
630 } // namespace OHOS
631