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 } // namespace
34
35 class BranchCbTest : public testing::Test {
36 public:
37 static void SetUpTestCase();
38 static void TearDownTestCase();
39 void SetUp();
40 void TearDown();
41 };
SetUpTestCase()42 void BranchCbTest::SetUpTestCase() {}
43
TearDownTestCase()44 void BranchCbTest::TearDownTestCase() {}
45
SetUp()46 void BranchCbTest::SetUp() {}
47
TearDown()48 void BranchCbTest::TearDown() {}
49
50 /**
51 * @tc.number Telephony_SmsMmsGtest_GsmCbCodec_0001
52 * @tc.name Test GsmCbCodec
53 * @tc.desc Function test
54 */
55 HWTEST_F(BranchCbTest, GsmCbCodec_0001, Function | MediumTest | Level1)
56 {
57 std::vector<unsigned char> pdu;
58 unsigned char data = 1;
59 pdu.push_back(data);
60 auto cbCodec = std::make_shared<GsmCbCodec>();
61 cbCodec->PduAnalysis(pdu);
62 int8_t format = 1;
63 EXPECT_TRUE(cbCodec->GetFormat(format));
64 EXPECT_TRUE(cbCodec->GetPriority(format));
65 EXPECT_NE(cbCodec->GsmCbCodec::ToString(), "");
66 uint8_t gs = 1;
67 EXPECT_TRUE(cbCodec->GetGeoScope(gs));
68 uint16_t serial = 1;
69 EXPECT_TRUE(cbCodec->GetSerialNum(serial));
70 bool isUserAlert = false;
71 EXPECT_TRUE(cbCodec->IsEtwsEmergencyUserAlert(isUserAlert));
72 EXPECT_TRUE(cbCodec->IsEtwsPopupAlert(isUserAlert));
73 EXPECT_TRUE(cbCodec->GetServiceCategory(serial));
74 uint8_t cmasType;
75 EXPECT_TRUE(cbCodec->GetCmasResponseType(cmasType));
76 uint8_t cmasClass;
77 EXPECT_TRUE(cbCodec->GetCmasMessageClass(cmasClass));
78 EXPECT_TRUE(cbCodec->GetWarningType(serial));
79 EXPECT_TRUE(cbCodec->GetMsgType(gs));
80 EXPECT_TRUE(cbCodec->GetLangType(gs));
81 EXPECT_TRUE(cbCodec->GetDcs(gs));
82 int64_t recvTime = 1;
83 EXPECT_TRUE(cbCodec->GetReceiveTime(recvTime));
84 }
85
86 /**
87 * @tc.number Telephony_SmsMmsGtest_GsmCbCodec_0002
88 * @tc.name Test GsmCbCodec
89 * @tc.desc Function test
90 */
91 HWTEST_F(BranchCbTest, GsmCbCodec_0002, Function | MediumTest | Level1)
92 {
93 std::vector<unsigned char> pdu;
94 unsigned char data = 1;
95 pdu.push_back(data);
96 auto cbCodec = std::make_shared<GsmCbCodec>();
97 cbCodec->PduAnalysis(pdu);
98 uint8_t cmasType;
99 cbCodec->GetCmasCategory(cmasType);
100 std::string raw = "qwe";
101 std::string message = "asd";
102 cbCodec->ConvertToUTF8(raw, message);
103 cbCodec->cbHeader_ = std::make_shared<GsmCbCodec::GsmCbMessageHeader>();
104 cbCodec->cbHeader_->dcs.codingScheme = DATA_CODING_7BIT;
105 cbCodec->ConvertToUTF8(raw, message);
106 cbCodec->cbHeader_->dcs.codingScheme = DATA_CODING_UCS2;
107 cbCodec->ConvertToUTF8(raw, message);
108 cbCodec->cbHeader_->dcs.codingScheme = DATA_CODING_AUTO;
109 cbCodec->ConvertToUTF8(raw, message);
110 cbCodec->cbHeader_->bEtwsMessage = true;
111 cbCodec->cbHeader_->cbEtwsType = GsmCbCodec::ETWS_PRIMARY;
112 cbCodec->ConvertToUTF8(raw, message);
113 cbCodec->GetCbMessageRaw();
114 int8_t format = 1;
115 EXPECT_TRUE(cbCodec->GetPriority(format));
116 cbCodec->cbHeader_->msgId = PWS_FIRST_ID;
117 EXPECT_TRUE(cbCodec->GetPriority(format));
118 EXPECT_FALSE(cbCodec->IsSinglePageMsg());
119 std::string pdus = "123";
120 EXPECT_TRUE(cbCodec->CreateCbMessage(pdu) == nullptr);
121 EXPECT_FALSE(cbCodec->CreateCbMessage(pdus));
122 EXPECT_TRUE(cbCodec->GetCbHeader() != nullptr);
123 }
124
125 /**
126 * @tc.number Telephony_SmsMmsGtest_GsmCbCodec_0003
127 * @tc.name Test GsmCbCodec
128 * @tc.desc Function test
129 */
130 HWTEST_F(BranchCbTest, GsmCbCodec_0003, Function | MediumTest | Level1)
131 {
132 auto smsCbMessage = std::make_shared<GsmCbCodec>();
133 uint8_t severity = 1;
134 smsCbMessage->cbHeader_ = std::make_shared<GsmCbCodec::GsmCbMessageHeader>();
135 smsCbMessage->cbHeader_->msgId = GsmCbCodec::CmasMsgType::EXTREME_OBSERVED;
136 EXPECT_TRUE(smsCbMessage->GetCmasSeverity(severity));
137 EXPECT_TRUE(smsCbMessage->GetCmasUrgency(severity));
138 smsCbMessage->cbHeader_->msgId = GsmCbCodec::CmasMsgType::EXTREME_OBSERVED_SPANISH;
139 EXPECT_TRUE(smsCbMessage->GetCmasSeverity(severity));
140 EXPECT_TRUE(smsCbMessage->GetCmasUrgency(severity));
141 smsCbMessage->cbHeader_->msgId = GsmCbCodec::CmasMsgType::EXTREME_LIKELY;
142 EXPECT_TRUE(smsCbMessage->GetCmasSeverity(severity));
143 EXPECT_TRUE(smsCbMessage->GetCmasUrgency(severity));
144 smsCbMessage->cbHeader_->msgId = GsmCbCodec::CmasMsgType::EXTREME_LIKELY_SPANISH;
145 EXPECT_TRUE(smsCbMessage->GetCmasSeverity(severity));
146 EXPECT_TRUE(smsCbMessage->GetCmasUrgency(severity));
147 smsCbMessage->cbHeader_->msgId = GsmCbCodec::CmasMsgType::EXTREME_OBSERVED;
148 EXPECT_TRUE(smsCbMessage->GetCmasSeverity(severity));
149 EXPECT_TRUE(smsCbMessage->GetCmasUrgency(severity));
150 smsCbMessage->cbHeader_->msgId = GsmCbCodec::CmasMsgType::SEVERE_OBSERVED_SPANISH;
151 EXPECT_TRUE(smsCbMessage->GetCmasSeverity(severity));
152 EXPECT_TRUE(smsCbMessage->GetCmasUrgency(severity));
153 smsCbMessage->cbHeader_->msgId = GsmCbCodec::CmasMsgType::SEVERE_LIKELY;
154 EXPECT_TRUE(smsCbMessage->GetCmasSeverity(severity));
155 EXPECT_TRUE(smsCbMessage->GetCmasUrgency(severity));
156 smsCbMessage->cbHeader_->msgId = GsmCbCodec::CmasMsgType::SEVERE_LIKELY_SPANISH;
157 EXPECT_TRUE(smsCbMessage->GetCmasSeverity(severity));
158 EXPECT_TRUE(smsCbMessage->GetCmasUrgency(severity));
159 smsCbMessage->cbHeader_->msgId = GsmCbCodec::CmasMsgType::ALERT_OBSERVED_DEFUALT;
160 EXPECT_TRUE(smsCbMessage->GetCmasSeverity(severity));
161 EXPECT_TRUE(smsCbMessage->GetCmasUrgency(severity));
162 smsCbMessage->cbHeader_->msgId = GsmCbCodec::CmasMsgType::ALERT_OBSERVED_SPANISH;
163 EXPECT_TRUE(smsCbMessage->GetCmasSeverity(severity));
164 EXPECT_TRUE(smsCbMessage->GetCmasUrgency(severity));
165 smsCbMessage->cbHeader_->msgId = GsmCbCodec::CmasMsgType::ALERT_LIKELY;
166 EXPECT_TRUE(smsCbMessage->GetCmasSeverity(severity));
167 EXPECT_TRUE(smsCbMessage->GetCmasUrgency(severity));
168 smsCbMessage->cbHeader_->msgId = GsmCbCodec::CmasMsgType::ALERT_LIKELY_SPANISH;
169 EXPECT_TRUE(smsCbMessage->GetCmasSeverity(severity));
170 EXPECT_TRUE(smsCbMessage->GetCmasUrgency(severity));
171 smsCbMessage->cbHeader_->msgId = GsmCbCodec::CmasMsgType::EXPECTED_OBSERVED;
172 EXPECT_TRUE(smsCbMessage->GetCmasSeverity(severity));
173 EXPECT_TRUE(smsCbMessage->GetCmasUrgency(severity));
174 smsCbMessage->cbHeader_->msgId = GsmCbCodec::CmasMsgType::EXPECTED_OBSERVED_SPANISH;
175 EXPECT_TRUE(smsCbMessage->GetCmasSeverity(severity));
176 EXPECT_TRUE(smsCbMessage->GetCmasUrgency(severity));
177 smsCbMessage->cbHeader_->msgId = GsmCbCodec::CmasMsgType::EXPECTED_LIKELY;
178 EXPECT_TRUE(smsCbMessage->GetCmasSeverity(severity));
179 EXPECT_TRUE(smsCbMessage->GetCmasUrgency(severity));
180 }
181
182 /**
183 * @tc.number Telephony_SmsMmsGtest_GsmCbCodec_0004
184 * @tc.name Test GsmCbCodec
185 * @tc.desc Function test
186 */
187 HWTEST_F(BranchCbTest, GsmCbCodec_0004, Function | MediumTest | Level1)
188 {
189 auto smsCbMessage = std::make_shared<GsmCbCodec>();
190 uint8_t severity = 1;
191 smsCbMessage->cbHeader_ = std::make_shared<GsmCbCodec::GsmCbMessageHeader>();
192 smsCbMessage->cbHeader_->msgId = GsmCbCodec::CmasMsgType::EXPECTED_LIKELY_SPANISH;
193 EXPECT_TRUE(smsCbMessage->GetCmasSeverity(severity));
194 EXPECT_TRUE(smsCbMessage->GetCmasUrgency(severity));
195 EXPECT_TRUE(smsCbMessage->GetCmasCertainty(severity));
196 smsCbMessage->cbHeader_->msgId = GsmCbCodec::CmasMsgType::OPERATOR_ALERT_SPANISH;
197 EXPECT_TRUE(smsCbMessage->GetCmasSeverity(severity));
198 EXPECT_TRUE(smsCbMessage->GetCmasUrgency(severity));
199 EXPECT_TRUE(smsCbMessage->GetCmasCertainty(severity));
200 smsCbMessage->cbHeader_->msgId = GsmCbCodec::CmasMsgType::EXTREME_OBSERVED;
201 EXPECT_TRUE(smsCbMessage->GetCmasCertainty(severity));
202 smsCbMessage->cbHeader_->msgId = GsmCbCodec::CmasMsgType::EXTREME_OBSERVED_SPANISH;
203 EXPECT_TRUE(smsCbMessage->GetCmasCertainty(severity));
204 smsCbMessage->cbHeader_->msgId = GsmCbCodec::CmasMsgType::SEVERE_OBSERVED;
205 EXPECT_TRUE(smsCbMessage->GetCmasCertainty(severity));
206 smsCbMessage->cbHeader_->msgId = GsmCbCodec::CmasMsgType::SEVERE_OBSERVED_SPANISH;
207 EXPECT_TRUE(smsCbMessage->GetCmasCertainty(severity));
208 smsCbMessage->cbHeader_->msgId = GsmCbCodec::CmasMsgType::ALERT_OBSERVED_DEFUALT;
209 EXPECT_TRUE(smsCbMessage->GetCmasCertainty(severity));
210 smsCbMessage->cbHeader_->msgId = GsmCbCodec::CmasMsgType::ALERT_OBSERVED_SPANISH;
211 EXPECT_TRUE(smsCbMessage->GetCmasCertainty(severity));
212 smsCbMessage->cbHeader_->msgId = GsmCbCodec::CmasMsgType::EXPECTED_OBSERVED;
213 EXPECT_TRUE(smsCbMessage->GetCmasCertainty(severity));
214 smsCbMessage->cbHeader_->msgId = GsmCbCodec::CmasMsgType::EXPECTED_OBSERVED_SPANISH;
215 EXPECT_TRUE(smsCbMessage->GetCmasCertainty(severity));
216 smsCbMessage->cbHeader_->msgId = GsmCbCodec::CmasMsgType::EXTREME_LIKELY;
217 EXPECT_TRUE(smsCbMessage->GetCmasCertainty(severity));
218 smsCbMessage->cbHeader_->msgId = GsmCbCodec::CmasMsgType::EXTREME_LIKELY_SPANISH;
219 EXPECT_TRUE(smsCbMessage->GetCmasCertainty(severity));
220 smsCbMessage->cbHeader_->msgId = GsmCbCodec::CmasMsgType::SEVERE_LIKELY;
221 EXPECT_TRUE(smsCbMessage->GetCmasCertainty(severity));
222 smsCbMessage->cbHeader_->msgId = GsmCbCodec::CmasMsgType::SEVERE_LIKELY_SPANISH;
223 EXPECT_TRUE(smsCbMessage->GetCmasCertainty(severity));
224 smsCbMessage->cbHeader_->msgId = GsmCbCodec::CmasMsgType::ALERT_LIKELY;
225 EXPECT_TRUE(smsCbMessage->GetCmasCertainty(severity));
226 smsCbMessage->cbHeader_->msgId = GsmCbCodec::CmasMsgType::ALERT_LIKELY_SPANISH;
227 EXPECT_TRUE(smsCbMessage->GetCmasCertainty(severity));
228 smsCbMessage->cbHeader_->msgId = GsmCbCodec::CmasMsgType::EXPECTED_LIKELY;
229 EXPECT_TRUE(smsCbMessage->GetCmasCertainty(severity));
230 }
231
232 /**
233 * @tc.number Telephony_SmsMmsGtest_GsmCbCodec_0005
234 * @tc.name Test GsmCbCodec
235 * @tc.desc Function test
236 */
237 HWTEST_F(BranchCbTest, GsmCbCodec_0005, Function | MediumTest | Level1)
238 {
239 auto cbMsg = std::make_shared<GsmCbCodec>();
240 auto gsmMsg = std::make_shared<GsmCbGsmCodec>(cbMsg->cbHeader_, cbMsg->cbPduBuffer_, cbMsg);
241 auto umtsMsg = std::make_shared<GsmCbUmtsCodec>(cbMsg->cbHeader_, cbMsg->cbPduBuffer_, cbMsg);
242 if (cbMsg == nullptr || gsmMsg == nullptr || umtsMsg == nullptr) {
243 EXPECT_TRUE(false);
244 return;
245 }
246
247 unsigned char data = 1;
248 std::vector<unsigned char> pdu;
249 pdu.push_back(data);
250 cbMsg->PduAnalysis(pdu);
251 gsmMsg->Decode2gCbMsg();
252 umtsMsg->Decode3gCbMsg();
253 cbMsg->cbHeader_ = std::make_shared<GsmCbCodec::GsmCbMessageHeader>();
254 cbMsg->cbHeader_->dcs.codingScheme = DataCodingScheme::DATA_CODING_7BIT;
255 gsmMsg->Decode2gCbMsg();
256 umtsMsg->Decode3gCbMsg();
257 cbMsg->cbHeader_->dcs.codingScheme = DataCodingScheme::DATA_CODING_8BIT;
258 gsmMsg->Decode2gCbMsg();
259 umtsMsg->Decode3gCbMsg();
260 cbMsg->cbHeader_->dcs.codingScheme = DataCodingScheme::DATA_CODING_UCS2;
261 gsmMsg->Decode2gCbMsg();
262 umtsMsg->Decode3gCbMsg();
263 cbMsg->cbHeader_->dcs.codingScheme = DataCodingScheme::DATA_CODING_ASCII7BIT;
264 gsmMsg->Decode2gCbMsg();
265 umtsMsg->Decode3gCbMsg();
266 cbMsg->cbHeader_->totalPages = 1;
267 umtsMsg->Decode3g7Bit();
268 umtsMsg->Decode3gUCS2();
269 EXPECT_EQ(cbMsg->CMASClass(GsmCbCodec::PRESIDENTIAL), GsmCbCodec::GSMCbMsgSubType::CMAS_PRESIDENTIAL);
270 EXPECT_EQ(cbMsg->CMASClass(GsmCbCodec::PRESIDENTIAL_SPANISH), GsmCbCodec::GSMCbMsgSubType::CMAS_PRESIDENTIAL);
271 EXPECT_EQ(cbMsg->CMASClass(GsmCbCodec::EXTREME_OBSERVED), GsmCbCodec::GSMCbMsgSubType::CMAS_EXTREME);
272 EXPECT_EQ(cbMsg->CMASClass(GsmCbCodec::EXTREME_OBSERVED_SPANISH), GsmCbCodec::GSMCbMsgSubType::CMAS_EXTREME);
273 EXPECT_EQ(cbMsg->CMASClass(GsmCbCodec::EXTREME_LIKELY), GsmCbCodec::GSMCbMsgSubType::CMAS_EXTREME);
274 EXPECT_EQ(cbMsg->CMASClass(GsmCbCodec::EXTREME_LIKELY_SPANISH), GsmCbCodec::GSMCbMsgSubType::CMAS_EXTREME);
275 EXPECT_EQ(cbMsg->CMASClass(GsmCbCodec::SEVERE_OBSERVED), GsmCbCodec::GSMCbMsgSubType::CMAS_SEVERE);
276 EXPECT_EQ(cbMsg->CMASClass(GsmCbCodec::SEVERE_OBSERVED_SPANISH), GsmCbCodec::GSMCbMsgSubType::CMAS_SEVERE);
277 EXPECT_EQ(cbMsg->CMASClass(GsmCbCodec::SEVERE_LIKELY), GsmCbCodec::GSMCbMsgSubType::CMAS_SEVERE);
278 EXPECT_EQ(cbMsg->CMASClass(GsmCbCodec::SEVERE_LIKELY_SPANISH), GsmCbCodec::GSMCbMsgSubType::CMAS_SEVERE);
279 EXPECT_EQ(cbMsg->CMASClass(GsmCbCodec::ALERT_OBSERVED_DEFUALT), GsmCbCodec::GSMCbMsgSubType::CMAS_SEVERE);
280 EXPECT_EQ(cbMsg->CMASClass(GsmCbCodec::ALERT_OBSERVED_SPANISH), GsmCbCodec::GSMCbMsgSubType::CMAS_SEVERE);
281 }
282
283 /**
284 * @tc.number Telephony_SmsMmsGtest_GsmCbCodec_0006
285 * @tc.name Test GsmCbCodec
286 * @tc.desc Function test
287 */
288 HWTEST_F(BranchCbTest, GsmCbCodec_0006, Function | MediumTest | Level1)
289 {
290 auto smsCbMessage = std::make_shared<GsmCbCodec>();
291 EXPECT_EQ(smsCbMessage->CMASClass(GsmCbCodec::ALERT_LIKELY), GsmCbCodec::GSMCbMsgSubType::CMAS_SEVERE);
292 EXPECT_EQ(smsCbMessage->CMASClass(GsmCbCodec::ALERT_LIKELY_SPANISH), GsmCbCodec::GSMCbMsgSubType::CMAS_SEVERE);
293 EXPECT_EQ(smsCbMessage->CMASClass(GsmCbCodec::EXPECTED_OBSERVED), GsmCbCodec::GSMCbMsgSubType::CMAS_SEVERE);
294 EXPECT_EQ(smsCbMessage->CMASClass(GsmCbCodec::EXPECTED_OBSERVED_SPANISH), GsmCbCodec::GSMCbMsgSubType::CMAS_SEVERE);
295 EXPECT_EQ(smsCbMessage->CMASClass(GsmCbCodec::EXPECTED_LIKELY_SPANISH), GsmCbCodec::GSMCbMsgSubType::CMAS_SEVERE);
296 EXPECT_EQ(smsCbMessage->CMASClass(GsmCbCodec::EXPECTED_LIKELY_SPANISH), GsmCbCodec::GSMCbMsgSubType::CMAS_SEVERE);
297 EXPECT_EQ(smsCbMessage->CMASClass(GsmCbCodec::AMBER_ALERT), GsmCbCodec::GSMCbMsgSubType::CMAS_AMBER);
298 EXPECT_EQ(smsCbMessage->CMASClass(GsmCbCodec::AMBER_ALERT_SPANISH), GsmCbCodec::GSMCbMsgSubType::CMAS_AMBER);
299 EXPECT_EQ(smsCbMessage->CMASClass(GsmCbCodec::MONTHLY_ALERT), GsmCbCodec::GSMCbMsgSubType::CMAS_TEST);
300 EXPECT_EQ(smsCbMessage->CMASClass(GsmCbCodec::MONTHLY_ALERT_SPANISH), GsmCbCodec::GSMCbMsgSubType::CMAS_TEST);
301 EXPECT_EQ(smsCbMessage->CMASClass(GsmCbCodec::EXERCISE_ALERT), GsmCbCodec::GSMCbMsgSubType::CMAS_EXERCISE);
302 EXPECT_EQ(smsCbMessage->CMASClass(GsmCbCodec::EXERCISE_ALERT_SPANISH), GsmCbCodec::GSMCbMsgSubType::CMAS_EXERCISE);
303 EXPECT_EQ(smsCbMessage->CMASClass(GsmCbCodec::OPERATOR_ALERT), GsmCbCodec::GSMCbMsgSubType::CMAS_OPERATOR_DEFINED);
304 EXPECT_EQ(smsCbMessage->CMASClass(GsmCbCodec::OPERATOR_ALERT_SPANISH),
305 GsmCbCodec::GSMCbMsgSubType::CMAS_OPERATOR_DEFINED);
306 }
307
308 /**
309 * @tc.number Telephony_SmsMmsGtest_GsmSmsCbHandler_0001
310 * @tc.name Test GsmSmsCbHandler
311 * @tc.desc Function test
312 */
313 HWTEST_F(BranchCbTest, GsmSmsCbHandler_0001, Function | MediumTest | Level1)
314 {
315 std::shared_ptr<AppExecFwk::EventRunner> runner = AppExecFwk::EventRunner::Create("test");
316 auto gsmSmsCbHandler = std::make_shared<GsmSmsCbHandler>(runner, INVALID_SLOTID);
317 auto cbMessage = std::make_shared<GsmCbCodec>();
318 auto message = std::make_shared<CBConfigReportInfo>();
319 AppExecFwk::InnerEvent::Pointer event = AppExecFwk::InnerEvent::Get(RadioEvent::RADIO_CELL_BROADCAST, 1);
320 gsmSmsCbHandler->ProcessEvent(event);
321 event = AppExecFwk::InnerEvent::Get(RadioEvent::RADIO_GET_STATUS, 1);
322 gsmSmsCbHandler->ProcessEvent(event);
323 gsmSmsCbHandler->HandleCbMessage(message);
324 EXPECT_EQ(gsmSmsCbHandler->CheckCbMessage(cbMessage), 0);
325 EXPECT_TRUE(gsmSmsCbHandler->FindCbMessage(cbMessage) == nullptr);
326 EXPECT_FALSE(gsmSmsCbHandler->AddCbMessageToList(cbMessage));
327 EXPECT_FALSE(gsmSmsCbHandler->SendCbMessageBroadcast(cbMessage));
328 cbMessage->cbHeader_ = std::make_shared<GsmCbCodec::GsmCbMessageHeader>();
329 EXPECT_EQ(gsmSmsCbHandler->CheckCbMessage(cbMessage), 0);
330 cbMessage->cbHeader_->totalPages = 1;
331 EXPECT_EQ(gsmSmsCbHandler->CheckCbMessage(cbMessage), 0x01);
332 EXPECT_FALSE(gsmSmsCbHandler->AddCbMessageToList(cbMessage));
333 CbInfo cbInfo;
334 gsmSmsCbHandler->cbMsgList_.push_back(cbInfo);
335 EXPECT_EQ(gsmSmsCbHandler->CheckCbMessage(cbMessage), 0x01);
336 cbMessage = nullptr;
337 message = nullptr;
338 event = nullptr;
339 gsmSmsCbHandler->ProcessEvent(event);
340 SmsCbData::CbData sendData;
341 gsmSmsCbHandler->GetCbData(cbMessage, sendData);
342 gsmSmsCbHandler->HandleCbMessage(message);
343 EXPECT_FALSE(gsmSmsCbHandler->CheckCbActive(cbMessage));
344 EXPECT_FALSE(gsmSmsCbHandler->AddCbMessageToList(cbMessage));
345 EXPECT_FALSE(gsmSmsCbHandler->SendCbMessageBroadcast(cbMessage));
346 EXPECT_TRUE(gsmSmsCbHandler->FindCbMessage(cbMessage) == nullptr);
347 EXPECT_EQ(gsmSmsCbHandler->CheckCbMessage(cbMessage), 0);
348 }
349 } // namespace Telephony
350 } // namespace OHOS
351