1 /*
2 * Copyright (C) 2023-2024 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
52 constexpr uint32_t EVENT_RELEASE_DATA_SHARE_HELPER = 10000;
TearDownTestCase()53 void BranchCbTest::TearDownTestCase()
54 {
55 DelayedSingleton<SmsPersistHelper>::GetInstance()->RemoveEvent(EVENT_RELEASE_DATA_SHARE_HELPER);
56 }
57
SetUp()58 void BranchCbTest::SetUp() {}
59
TearDown()60 void BranchCbTest::TearDown() {}
61
62 /**
63 * @tc.number Telephony_SmsMmsGtest_GsmCbCodec_0001
64 * @tc.name Test GsmCbCodec
65 * @tc.desc Function test
66 */
67 HWTEST_F(BranchCbTest, GsmCbCodec_0001, Function | MediumTest | Level1)
68 {
69 std::vector<unsigned char> pdu;
70 unsigned char data = 1;
71 pdu.push_back(data);
72 auto cbCodec = std::make_shared<GsmCbCodec>();
73 cbCodec->PduAnalysis(pdu);
74 int8_t format = 1;
75 EXPECT_TRUE(cbCodec->GetFormat(format));
76 EXPECT_TRUE(cbCodec->GetPriority(format));
77 EXPECT_NE(cbCodec->GsmCbCodec::ToString(), "");
78 uint8_t gs = 1;
79 EXPECT_TRUE(cbCodec->GetGeoScope(gs));
80 uint16_t serial = 1;
81 EXPECT_TRUE(cbCodec->GetSerialNum(serial));
82 bool isUserAlert = false;
83 EXPECT_TRUE(cbCodec->IsEtwsEmergencyUserAlert(isUserAlert));
84 EXPECT_TRUE(cbCodec->IsEtwsPopupAlert(isUserAlert));
85 EXPECT_TRUE(cbCodec->GetServiceCategory(serial));
86 uint8_t cmasType;
87 EXPECT_TRUE(cbCodec->GetCmasResponseType(cmasType));
88 uint8_t cmasClass;
89 EXPECT_TRUE(cbCodec->GetCmasMessageClass(cmasClass));
90 EXPECT_TRUE(cbCodec->GetWarningType(serial));
91 EXPECT_TRUE(cbCodec->GetMsgType(gs));
92 EXPECT_TRUE(cbCodec->GetLangType(gs));
93 EXPECT_TRUE(cbCodec->GetDcs(gs));
94 int64_t recvTime = 0;
95 EXPECT_TRUE(cbCodec->GetReceiveTime(recvTime));
96 }
97
98 /**
99 * @tc.number Telephony_SmsMmsGtest_GsmCbCodec_0002
100 * @tc.name Test GsmCbCodec
101 * @tc.desc Function test
102 */
103 HWTEST_F(BranchCbTest, GsmCbCodec_0002, Function | MediumTest | Level1)
104 {
105 std::vector<unsigned char> pdu;
106 unsigned char data = 1;
107 pdu.push_back(data);
108 auto cbCodec = std::make_shared<GsmCbCodec>();
109 cbCodec->PduAnalysis(pdu);
110 uint8_t cmasType;
111 cbCodec->GetCmasCategory(cmasType);
112 std::string raw = "qwe";
113 std::string message = "asd";
114 cbCodec->ConvertToUTF8(raw, message);
115 cbCodec->cbHeader_ = std::make_shared<GsmCbCodec::GsmCbMessageHeader>();
116 cbCodec->cbHeader_->dcs.codingScheme = DATA_CODING_7BIT;
117 cbCodec->ConvertToUTF8(raw, message);
118 cbCodec->cbHeader_->dcs.codingScheme = DATA_CODING_UCS2;
119 cbCodec->ConvertToUTF8(raw, message);
120 cbCodec->cbHeader_->dcs.codingScheme = DATA_CODING_AUTO;
121 cbCodec->ConvertToUTF8(raw, message);
122 cbCodec->cbHeader_->bEtwsMessage = true;
123 cbCodec->cbHeader_->cbEtwsType = GsmCbCodec::ETWS_PRIMARY;
124 cbCodec->ConvertToUTF8(raw, message);
125 cbCodec->GetCbMessageRaw();
126 int8_t format = 1;
127 EXPECT_TRUE(cbCodec->GetPriority(format));
128 cbCodec->cbHeader_->msgId = PWS_FIRST_ID;
129 EXPECT_TRUE(cbCodec->GetPriority(format));
130 EXPECT_FALSE(cbCodec->IsSinglePageMsg());
131 std::string pdus = "123";
132 EXPECT_TRUE(cbCodec->CreateCbMessage(pdu) == nullptr);
133 EXPECT_FALSE(cbCodec->CreateCbMessage(pdus));
134 EXPECT_TRUE(cbCodec->GetCbHeader() != nullptr);
135 }
136
137 /**
138 * @tc.number Telephony_SmsMmsGtest_GsmCbCodec_0003
139 * @tc.name Test GsmCbCodec
140 * @tc.desc Function test
141 */
142 HWTEST_F(BranchCbTest, GsmCbCodec_0003, Function | MediumTest | Level1)
143 {
144 auto smsCbMessage = std::make_shared<GsmCbCodec>();
145 uint8_t severity = 1;
146 smsCbMessage->cbHeader_ = std::make_shared<GsmCbCodec::GsmCbMessageHeader>();
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::EXTREME_OBSERVED_SPANISH;
151 EXPECT_TRUE(smsCbMessage->GetCmasSeverity(severity));
152 EXPECT_TRUE(smsCbMessage->GetCmasUrgency(severity));
153 smsCbMessage->cbHeader_->msgId = GsmCbCodec::CmasMsgType::EXTREME_LIKELY;
154 EXPECT_TRUE(smsCbMessage->GetCmasSeverity(severity));
155 EXPECT_TRUE(smsCbMessage->GetCmasUrgency(severity));
156 smsCbMessage->cbHeader_->msgId = GsmCbCodec::CmasMsgType::EXTREME_LIKELY_SPANISH;
157 EXPECT_TRUE(smsCbMessage->GetCmasSeverity(severity));
158 EXPECT_TRUE(smsCbMessage->GetCmasUrgency(severity));
159 smsCbMessage->cbHeader_->msgId = GsmCbCodec::CmasMsgType::EXTREME_OBSERVED;
160 EXPECT_TRUE(smsCbMessage->GetCmasSeverity(severity));
161 EXPECT_TRUE(smsCbMessage->GetCmasUrgency(severity));
162 smsCbMessage->cbHeader_->msgId = GsmCbCodec::CmasMsgType::SEVERE_OBSERVED_SPANISH;
163 EXPECT_TRUE(smsCbMessage->GetCmasSeverity(severity));
164 EXPECT_TRUE(smsCbMessage->GetCmasUrgency(severity));
165 smsCbMessage->cbHeader_->msgId = GsmCbCodec::CmasMsgType::SEVERE_LIKELY;
166 EXPECT_TRUE(smsCbMessage->GetCmasSeverity(severity));
167 EXPECT_TRUE(smsCbMessage->GetCmasUrgency(severity));
168 smsCbMessage->cbHeader_->msgId = GsmCbCodec::CmasMsgType::SEVERE_LIKELY_SPANISH;
169 EXPECT_TRUE(smsCbMessage->GetCmasSeverity(severity));
170 EXPECT_TRUE(smsCbMessage->GetCmasUrgency(severity));
171 smsCbMessage->cbHeader_->msgId = GsmCbCodec::CmasMsgType::ALERT_OBSERVED_DEFUALT;
172 EXPECT_TRUE(smsCbMessage->GetCmasSeverity(severity));
173 EXPECT_TRUE(smsCbMessage->GetCmasUrgency(severity));
174 smsCbMessage->cbHeader_->msgId = GsmCbCodec::CmasMsgType::ALERT_OBSERVED_SPANISH;
175 EXPECT_TRUE(smsCbMessage->GetCmasSeverity(severity));
176 EXPECT_TRUE(smsCbMessage->GetCmasUrgency(severity));
177 smsCbMessage->cbHeader_->msgId = GsmCbCodec::CmasMsgType::ALERT_LIKELY;
178 EXPECT_TRUE(smsCbMessage->GetCmasSeverity(severity));
179 EXPECT_TRUE(smsCbMessage->GetCmasUrgency(severity));
180 smsCbMessage->cbHeader_->msgId = GsmCbCodec::CmasMsgType::ALERT_LIKELY_SPANISH;
181 EXPECT_TRUE(smsCbMessage->GetCmasSeverity(severity));
182 EXPECT_TRUE(smsCbMessage->GetCmasUrgency(severity));
183 smsCbMessage->cbHeader_->msgId = GsmCbCodec::CmasMsgType::EXPECTED_OBSERVED;
184 EXPECT_TRUE(smsCbMessage->GetCmasSeverity(severity));
185 EXPECT_TRUE(smsCbMessage->GetCmasUrgency(severity));
186 smsCbMessage->cbHeader_->msgId = GsmCbCodec::CmasMsgType::EXPECTED_OBSERVED_SPANISH;
187 EXPECT_TRUE(smsCbMessage->GetCmasSeverity(severity));
188 EXPECT_TRUE(smsCbMessage->GetCmasUrgency(severity));
189 smsCbMessage->cbHeader_->msgId = GsmCbCodec::CmasMsgType::EXPECTED_LIKELY;
190 EXPECT_TRUE(smsCbMessage->GetCmasSeverity(severity));
191 EXPECT_TRUE(smsCbMessage->GetCmasUrgency(severity));
192 }
193
194 /**
195 * @tc.number Telephony_SmsMmsGtest_GsmCbCodec_0004
196 * @tc.name Test GsmCbCodec
197 * @tc.desc Function test
198 */
199 HWTEST_F(BranchCbTest, GsmCbCodec_0004, Function | MediumTest | Level1)
200 {
201 auto smsCbMessage = std::make_shared<GsmCbCodec>();
202 uint8_t severity = 1;
203 smsCbMessage->cbHeader_ = std::make_shared<GsmCbCodec::GsmCbMessageHeader>();
204 smsCbMessage->cbHeader_->msgId = GsmCbCodec::CmasMsgType::EXPECTED_LIKELY_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::OPERATOR_ALERT_SPANISH;
209 EXPECT_TRUE(smsCbMessage->GetCmasSeverity(severity));
210 EXPECT_TRUE(smsCbMessage->GetCmasUrgency(severity));
211 EXPECT_TRUE(smsCbMessage->GetCmasCertainty(severity));
212 smsCbMessage->cbHeader_->msgId = GsmCbCodec::CmasMsgType::EXTREME_OBSERVED;
213 EXPECT_TRUE(smsCbMessage->GetCmasCertainty(severity));
214 smsCbMessage->cbHeader_->msgId = GsmCbCodec::CmasMsgType::EXTREME_OBSERVED_SPANISH;
215 EXPECT_TRUE(smsCbMessage->GetCmasCertainty(severity));
216 smsCbMessage->cbHeader_->msgId = GsmCbCodec::CmasMsgType::SEVERE_OBSERVED;
217 EXPECT_TRUE(smsCbMessage->GetCmasCertainty(severity));
218 smsCbMessage->cbHeader_->msgId = GsmCbCodec::CmasMsgType::SEVERE_OBSERVED_SPANISH;
219 EXPECT_TRUE(smsCbMessage->GetCmasCertainty(severity));
220 smsCbMessage->cbHeader_->msgId = GsmCbCodec::CmasMsgType::ALERT_OBSERVED_DEFUALT;
221 EXPECT_TRUE(smsCbMessage->GetCmasCertainty(severity));
222 smsCbMessage->cbHeader_->msgId = GsmCbCodec::CmasMsgType::ALERT_OBSERVED_SPANISH;
223 EXPECT_TRUE(smsCbMessage->GetCmasCertainty(severity));
224 smsCbMessage->cbHeader_->msgId = GsmCbCodec::CmasMsgType::EXPECTED_OBSERVED;
225 EXPECT_TRUE(smsCbMessage->GetCmasCertainty(severity));
226 smsCbMessage->cbHeader_->msgId = GsmCbCodec::CmasMsgType::EXPECTED_OBSERVED_SPANISH;
227 EXPECT_TRUE(smsCbMessage->GetCmasCertainty(severity));
228 smsCbMessage->cbHeader_->msgId = GsmCbCodec::CmasMsgType::EXTREME_LIKELY;
229 EXPECT_TRUE(smsCbMessage->GetCmasCertainty(severity));
230 smsCbMessage->cbHeader_->msgId = GsmCbCodec::CmasMsgType::EXTREME_LIKELY_SPANISH;
231 EXPECT_TRUE(smsCbMessage->GetCmasCertainty(severity));
232 smsCbMessage->cbHeader_->msgId = GsmCbCodec::CmasMsgType::SEVERE_LIKELY;
233 EXPECT_TRUE(smsCbMessage->GetCmasCertainty(severity));
234 smsCbMessage->cbHeader_->msgId = GsmCbCodec::CmasMsgType::SEVERE_LIKELY_SPANISH;
235 EXPECT_TRUE(smsCbMessage->GetCmasCertainty(severity));
236 smsCbMessage->cbHeader_->msgId = GsmCbCodec::CmasMsgType::ALERT_LIKELY;
237 EXPECT_TRUE(smsCbMessage->GetCmasCertainty(severity));
238 smsCbMessage->cbHeader_->msgId = GsmCbCodec::CmasMsgType::ALERT_LIKELY_SPANISH;
239 EXPECT_TRUE(smsCbMessage->GetCmasCertainty(severity));
240 smsCbMessage->cbHeader_->msgId = GsmCbCodec::CmasMsgType::EXPECTED_LIKELY;
241 EXPECT_TRUE(smsCbMessage->GetCmasCertainty(severity));
242 }
243
244 /**
245 * @tc.number Telephony_SmsMmsGtest_GsmCbCodec_0005
246 * @tc.name Test GsmCbCodec
247 * @tc.desc Function test
248 */
249 HWTEST_F(BranchCbTest, GsmCbCodec_0005, Function | MediumTest | Level1)
250 {
251 auto cbMsg = std::make_shared<GsmCbCodec>();
252 auto gsmMsg = std::make_shared<GsmCbGsmCodec>(cbMsg->cbHeader_, cbMsg->cbPduBuffer_, cbMsg);
253 auto umtsMsg = std::make_shared<GsmCbUmtsCodec>(cbMsg->cbHeader_, cbMsg->cbPduBuffer_, cbMsg);
254 ASSERT_NE(cbMsg, nullptr);
255 ASSERT_NE(gsmMsg, nullptr);
256 ASSERT_NE(umtsMsg, nullptr);
257 EXPECT_FALSE(gsmMsg->Decode2gHeader());
258 unsigned char data = 1;
259 std::vector<unsigned char> pdu;
260 pdu.push_back(data);
261 cbMsg->PduAnalysis(pdu);
262 gsmMsg->Decode2gCbMsg();
263 umtsMsg->Decode3gCbMsg();
264 cbMsg->cbHeader_ = std::make_shared<GsmCbCodec::GsmCbMessageHeader>();
265 cbMsg->cbHeader_->dcs.codingScheme = DataCodingScheme::DATA_CODING_7BIT;
266 gsmMsg->Decode2gCbMsg();
267 umtsMsg->Decode3gCbMsg();
268 cbMsg->cbHeader_->dcs.codingScheme = DataCodingScheme::DATA_CODING_8BIT;
269 gsmMsg->Decode2gCbMsg();
270 umtsMsg->Decode3gCbMsg();
271 cbMsg->cbHeader_->dcs.codingScheme = DataCodingScheme::DATA_CODING_UCS2;
272 gsmMsg->Decode2gCbMsg();
273 umtsMsg->Decode3gCbMsg();
274 cbMsg->cbHeader_->dcs.codingScheme = DataCodingScheme::DATA_CODING_ASCII7BIT;
275 gsmMsg->Decode2gCbMsg();
276 umtsMsg->Decode3gCbMsg();
277 cbMsg->cbHeader_->totalPages = 1;
278 umtsMsg->Decode3g7Bit();
279 umtsMsg->Decode3gUCS2();
280 EXPECT_EQ(cbMsg->CMASClass(GsmCbCodec::PRESIDENTIAL), GsmCbCodec::GSMCbMsgSubType::CMAS_PRESIDENTIAL);
281 EXPECT_EQ(cbMsg->CMASClass(GsmCbCodec::PRESIDENTIAL_SPANISH), GsmCbCodec::GSMCbMsgSubType::CMAS_PRESIDENTIAL);
282 EXPECT_EQ(cbMsg->CMASClass(GsmCbCodec::EXTREME_OBSERVED), GsmCbCodec::GSMCbMsgSubType::CMAS_EXTREME);
283 EXPECT_EQ(cbMsg->CMASClass(GsmCbCodec::EXTREME_OBSERVED_SPANISH), GsmCbCodec::GSMCbMsgSubType::CMAS_EXTREME);
284 EXPECT_EQ(cbMsg->CMASClass(GsmCbCodec::EXTREME_LIKELY), GsmCbCodec::GSMCbMsgSubType::CMAS_EXTREME);
285 EXPECT_EQ(cbMsg->CMASClass(GsmCbCodec::EXTREME_LIKELY_SPANISH), GsmCbCodec::GSMCbMsgSubType::CMAS_EXTREME);
286 EXPECT_EQ(cbMsg->CMASClass(GsmCbCodec::SEVERE_OBSERVED), GsmCbCodec::GSMCbMsgSubType::CMAS_SEVERE);
287 EXPECT_EQ(cbMsg->CMASClass(GsmCbCodec::SEVERE_OBSERVED_SPANISH), GsmCbCodec::GSMCbMsgSubType::CMAS_SEVERE);
288 EXPECT_EQ(cbMsg->CMASClass(GsmCbCodec::SEVERE_LIKELY), GsmCbCodec::GSMCbMsgSubType::CMAS_SEVERE);
289 EXPECT_EQ(cbMsg->CMASClass(GsmCbCodec::SEVERE_LIKELY_SPANISH), GsmCbCodec::GSMCbMsgSubType::CMAS_SEVERE);
290 EXPECT_EQ(cbMsg->CMASClass(GsmCbCodec::ALERT_OBSERVED_DEFUALT), GsmCbCodec::GSMCbMsgSubType::CMAS_SEVERE);
291 EXPECT_EQ(cbMsg->CMASClass(GsmCbCodec::ALERT_OBSERVED_SPANISH), GsmCbCodec::GSMCbMsgSubType::CMAS_SEVERE);
292 }
293
294 /**
295 * @tc.number Telephony_SmsMmsGtest_GsmCbCodec_0006
296 * @tc.name Test GsmCbCodec
297 * @tc.desc Function test
298 */
299 HWTEST_F(BranchCbTest, GsmCbCodec_0006, Function | MediumTest | Level1)
300 {
301 auto smsCbMessage = std::make_shared<GsmCbCodec>();
302 EXPECT_EQ(smsCbMessage->CMASClass(GsmCbCodec::ALERT_LIKELY), GsmCbCodec::GSMCbMsgSubType::CMAS_SEVERE);
303 EXPECT_EQ(smsCbMessage->CMASClass(GsmCbCodec::ALERT_LIKELY_SPANISH), GsmCbCodec::GSMCbMsgSubType::CMAS_SEVERE);
304 EXPECT_EQ(smsCbMessage->CMASClass(GsmCbCodec::EXPECTED_OBSERVED), GsmCbCodec::GSMCbMsgSubType::CMAS_SEVERE);
305 EXPECT_EQ(smsCbMessage->CMASClass(GsmCbCodec::EXPECTED_OBSERVED_SPANISH), GsmCbCodec::GSMCbMsgSubType::CMAS_SEVERE);
306 EXPECT_EQ(smsCbMessage->CMASClass(GsmCbCodec::EXPECTED_LIKELY_SPANISH), GsmCbCodec::GSMCbMsgSubType::CMAS_SEVERE);
307 EXPECT_EQ(smsCbMessage->CMASClass(GsmCbCodec::EXPECTED_LIKELY_SPANISH), GsmCbCodec::GSMCbMsgSubType::CMAS_SEVERE);
308 EXPECT_EQ(smsCbMessage->CMASClass(GsmCbCodec::AMBER_ALERT), GsmCbCodec::GSMCbMsgSubType::CMAS_AMBER);
309 EXPECT_EQ(smsCbMessage->CMASClass(GsmCbCodec::AMBER_ALERT_SPANISH), GsmCbCodec::GSMCbMsgSubType::CMAS_AMBER);
310 EXPECT_EQ(smsCbMessage->CMASClass(GsmCbCodec::MONTHLY_ALERT), GsmCbCodec::GSMCbMsgSubType::CMAS_TEST);
311 EXPECT_EQ(smsCbMessage->CMASClass(GsmCbCodec::MONTHLY_ALERT_SPANISH), GsmCbCodec::GSMCbMsgSubType::CMAS_TEST);
312 EXPECT_EQ(smsCbMessage->CMASClass(GsmCbCodec::EXERCISE_ALERT), GsmCbCodec::GSMCbMsgSubType::CMAS_EXERCISE);
313 EXPECT_EQ(smsCbMessage->CMASClass(GsmCbCodec::EXERCISE_ALERT_SPANISH), GsmCbCodec::GSMCbMsgSubType::CMAS_EXERCISE);
314 EXPECT_EQ(smsCbMessage->CMASClass(GsmCbCodec::OPERATOR_ALERT), GsmCbCodec::GSMCbMsgSubType::CMAS_OPERATOR_DEFINED);
315 EXPECT_EQ(smsCbMessage->CMASClass(GsmCbCodec::OPERATOR_ALERT_SPANISH),
316 GsmCbCodec::GSMCbMsgSubType::CMAS_OPERATOR_DEFINED);
317 }
318
319 /**
320 * @tc.number Telephony_SmsMmsGtest_GsmCbGsmCodec_0001
321 * @tc.name Test GsmCbGsmCodec
322 * @tc.desc Function test
323 */
324 HWTEST_F(BranchCbTest, GsmCbGsmCodec_0001, Function | MediumTest | Level1)
325 {
326 auto cbMsg = std::make_shared<GsmCbCodec>();
327 ASSERT_NE(cbMsg, nullptr);
328 cbMsg->CreateCbMessage(ETWS_PDU);
329 std::vector<unsigned char> pdu = StringUtils::HexToByteVector(ETWS_PDU);
330 cbMsg->cbPduBuffer_ = std::make_shared<GsmCbPduDecodeBuffer>(pdu.size());
331 cbMsg->cbHeader_ = std::make_shared<GsmCbCodec::GsmCbMessageHeader>();
332 for (size_t index = 0; index < pdu.size() && index < cbMsg->cbPduBuffer_->GetSize(); index++) {
333 cbMsg->cbPduBuffer_->pduBuffer_[index] = static_cast<char>(pdu[index]);
334 }
335 auto gsmMsg = std::make_shared<GsmCbGsmCodec>(cbMsg->cbHeader_, cbMsg->cbPduBuffer_, cbMsg);
336 auto umtsMsg = std::make_shared<GsmCbUmtsCodec>(cbMsg->cbHeader_, cbMsg->cbPduBuffer_, cbMsg);
337 gsmMsg->cbPduBuffer_ = cbMsg->cbPduBuffer_;
338 umtsMsg->cbPduBuffer_ = cbMsg->cbPduBuffer_;
339 gsmMsg->Decode2gHeader();
340 gsmMsg->Decode2gHeaderEtws();
341 EXPECT_TRUE(gsmMsg->Decode2gCbMsg());
342
343 gsmMsg->Decode2gHeaderCommonCb();
344 uint16_t dataLen = gsmMsg->cbPduBuffer_->GetSize() - gsmMsg->cbPduBuffer_->GetCurPosition();
345 gsmMsg->Decode2gCbMsg7bit(dataLen);
346 EXPECT_TRUE(gsmMsg->DecodeEtwsMsg());
347
348 umtsMsg->Decode3gHeader();
349 umtsMsg->Decode3gHeaderPartData(0);
350 umtsMsg->Decode3gCbMsg();
351 umtsMsg->Decode3g7Bit();
352 EXPECT_FALSE(umtsMsg->Decode3gUCS2());
353 cbMsg->cbHeader_ = std::make_shared<GsmCbCodec::GsmCbMessageHeader>();
354 cbMsg->cbHeader_->dcs.codingScheme = DataCodingScheme::DATA_CODING_7BIT;
355 gsmMsg->Decode2gCbMsg();
356 EXPECT_FALSE(umtsMsg->Decode3gCbMsg());
357
358 cbMsg->cbHeader_->dcs.codingScheme = DataCodingScheme::DATA_CODING_8BIT;
359 gsmMsg->Decode2gCbMsg();
360 EXPECT_FALSE(umtsMsg->Decode3gCbMsg());
361 cbMsg->cbHeader_->dcs.codingScheme = DataCodingScheme::DATA_CODING_UCS2;
362 gsmMsg->Decode2gCbMsg();
363 EXPECT_FALSE(umtsMsg->Decode3gCbMsg());
364
365 cbMsg->cbHeader_->dcs.codingScheme = DataCodingScheme::DATA_CODING_ASCII7BIT;
366 gsmMsg->Decode2gCbMsg();
367 EXPECT_FALSE(umtsMsg->Decode3gCbMsg());
368 cbMsg->cbHeader_->totalPages = 1;
369 umtsMsg->Decode3g7Bit();
370 EXPECT_FALSE(umtsMsg->Decode3gUCS2());
371 }
372
373 /**
374 * @tc.number Telephony_SmsMmsGtest_GsmCbGsmCodec_0002
375 * @tc.name Test GsmCbGsmCodec
376 * @tc.desc Function test
377 */
378 HWTEST_F(BranchCbTest, GsmCbGsmCodec_0002, Function | MediumTest | Level1)
379 {
380 auto cbMsg = std::make_shared<GsmCbCodec>();
381 ASSERT_NE(cbMsg, nullptr);
382 cbMsg->CreateCbMessage(CMAS_PDU);
383 std::vector<unsigned char> pdu = StringUtils::HexToByteVector(CMAS_PDU);
384 cbMsg->cbPduBuffer_ = std::make_shared<GsmCbPduDecodeBuffer>(pdu.size());
385 cbMsg->cbHeader_ = std::make_shared<GsmCbCodec::GsmCbMessageHeader>();
386 for (size_t index = 0; index < pdu.size() && index < cbMsg->cbPduBuffer_->GetSize(); index++) {
387 cbMsg->cbPduBuffer_->pduBuffer_[index] = static_cast<char>(pdu[index]);
388 }
389 auto gsmMsg = std::make_shared<GsmCbGsmCodec>(cbMsg->cbHeader_, cbMsg->cbPduBuffer_, cbMsg);
390 auto umtsMsg = std::make_shared<GsmCbUmtsCodec>(cbMsg->cbHeader_, cbMsg->cbPduBuffer_, cbMsg);
391 gsmMsg->cbPduBuffer_ = cbMsg->cbPduBuffer_;
392 umtsMsg->cbPduBuffer_ = cbMsg->cbPduBuffer_;
393 gsmMsg->Decode2gHeader();
394 gsmMsg->Decode2gHeaderEtws();
395 EXPECT_TRUE(gsmMsg->Decode2gCbMsg());
396
397 gsmMsg->Decode2gHeaderCommonCb();
398 uint16_t dataLen = gsmMsg->cbPduBuffer_->GetSize() - gsmMsg->cbPduBuffer_->GetCurPosition();
399 gsmMsg->Decode2gCbMsg7bit(dataLen);
400 EXPECT_TRUE(gsmMsg->DecodeEtwsMsg());
401
402 umtsMsg->Decode3gHeader();
403 umtsMsg->Decode3gHeaderPartData(0);
404 umtsMsg->Decode3gCbMsg();
405 umtsMsg->Decode3g7Bit();
406 EXPECT_FALSE(umtsMsg->Decode3gUCS2());
407 cbMsg->cbHeader_ = std::make_shared<GsmCbCodec::GsmCbMessageHeader>();
408 cbMsg->cbHeader_->dcs.codingScheme = DataCodingScheme::DATA_CODING_7BIT;
409 gsmMsg->Decode2gCbMsg();
410 EXPECT_FALSE(umtsMsg->Decode3gCbMsg());
411
412 cbMsg->cbHeader_->dcs.codingScheme = DataCodingScheme::DATA_CODING_8BIT;
413 gsmMsg->Decode2gCbMsg();
414 EXPECT_FALSE(umtsMsg->Decode3gCbMsg());
415 cbMsg->cbHeader_->dcs.codingScheme = DataCodingScheme::DATA_CODING_UCS2;
416 gsmMsg->Decode2gCbMsg();
417 EXPECT_FALSE(umtsMsg->Decode3gCbMsg());
418
419 cbMsg->cbHeader_->dcs.codingScheme = DataCodingScheme::DATA_CODING_ASCII7BIT;
420 gsmMsg->Decode2gCbMsg();
421 EXPECT_FALSE(umtsMsg->Decode3gCbMsg());
422 cbMsg->cbHeader_->totalPages = 1;
423 umtsMsg->Decode3g7Bit();
424 EXPECT_FALSE(umtsMsg->Decode3gUCS2());
425 }
426
427 /**
428 * @tc.number Telephony_SmsMmsGtest_GsmCbGsmCodec_0003
429 * @tc.name Test GsmCbGsmCodec
430 * @tc.desc Function test
431 */
432 HWTEST_F(BranchCbTest, GsmCbGsmCodec_0003, Function | MediumTest | Level1)
433 {
434 auto cbMsg = std::make_shared<GsmCbCodec>();
435 ASSERT_NE(cbMsg, nullptr);
436 cbMsg->CreateCbMessage(CBS_PDU);
437 std::vector<unsigned char> pdu = StringUtils::HexToByteVector(CBS_PDU);
438 cbMsg->cbPduBuffer_ = std::make_shared<GsmCbPduDecodeBuffer>(pdu.size());
439 cbMsg->cbHeader_ = std::make_shared<GsmCbCodec::GsmCbMessageHeader>();
440 for (size_t index = 0; index < pdu.size() && index < cbMsg->cbPduBuffer_->GetSize(); index++) {
441 cbMsg->cbPduBuffer_->pduBuffer_[index] = static_cast<char>(pdu[index]);
442 }
443 auto gsmMsg = std::make_shared<GsmCbGsmCodec>(cbMsg->cbHeader_, cbMsg->cbPduBuffer_, cbMsg);
444 auto umtsMsg = std::make_shared<GsmCbUmtsCodec>(cbMsg->cbHeader_, cbMsg->cbPduBuffer_, cbMsg);
445 gsmMsg->cbPduBuffer_ = cbMsg->cbPduBuffer_;
446 umtsMsg->cbPduBuffer_ = cbMsg->cbPduBuffer_;
447 gsmMsg->Decode2gHeader();
448 gsmMsg->Decode2gHeaderEtws();
449 EXPECT_TRUE(gsmMsg->Decode2gCbMsg());
450
451 gsmMsg->Decode2gHeaderCommonCb();
452 uint16_t dataLen = gsmMsg->cbPduBuffer_->GetSize() - gsmMsg->cbPduBuffer_->GetCurPosition();
453 gsmMsg->Decode2gCbMsg7bit(dataLen);
454 EXPECT_TRUE(gsmMsg->DecodeEtwsMsg());
455
456 umtsMsg->Decode3gHeader();
457 umtsMsg->Decode3gHeaderPartData(0);
458 umtsMsg->Decode3gCbMsg();
459 umtsMsg->Decode3g7Bit();
460 EXPECT_FALSE(umtsMsg->Decode3gUCS2());
461 cbMsg->cbHeader_ = std::make_shared<GsmCbCodec::GsmCbMessageHeader>();
462 cbMsg->cbHeader_->dcs.codingScheme = DataCodingScheme::DATA_CODING_7BIT;
463 gsmMsg->Decode2gCbMsg();
464 EXPECT_FALSE(umtsMsg->Decode3gCbMsg());
465
466 cbMsg->cbHeader_->dcs.codingScheme = DataCodingScheme::DATA_CODING_8BIT;
467 gsmMsg->Decode2gCbMsg();
468 EXPECT_FALSE(umtsMsg->Decode3gCbMsg());
469 cbMsg->cbHeader_->dcs.codingScheme = DataCodingScheme::DATA_CODING_UCS2;
470 gsmMsg->Decode2gCbMsg();
471 EXPECT_FALSE(umtsMsg->Decode3gCbMsg());
472
473 cbMsg->cbHeader_->dcs.codingScheme = DataCodingScheme::DATA_CODING_ASCII7BIT;
474 gsmMsg->Decode2gCbMsg();
475 EXPECT_FALSE(umtsMsg->Decode3gCbMsg());
476 cbMsg->cbHeader_->totalPages = 1;
477 umtsMsg->Decode3g7Bit();
478 EXPECT_FALSE(umtsMsg->Decode3gUCS2());
479 }
480
481 /**
482 * @tc.number Telephony_SmsMmsGtest_GsmCbGsmCodec_0004
483 * @tc.name Test GsmCbGsmCodec
484 * @tc.desc Function test
485 */
486 HWTEST_F(BranchCbTest, GsmCbGsmCodec_0004, Function | MediumTest | Level1)
487 {
488 auto cbMsg = std::make_shared<GsmCbCodec>();
489 ASSERT_NE(cbMsg, nullptr);
490 cbMsg->CreateCbMessage(CMAS_JP_PDU);
491 std::vector<unsigned char> pdu = StringUtils::HexToByteVector(CMAS_JP_PDU);
492 cbMsg->cbPduBuffer_ = std::make_shared<GsmCbPduDecodeBuffer>(pdu.size());
493 cbMsg->cbHeader_ = std::make_shared<GsmCbCodec::GsmCbMessageHeader>();
494 for (size_t index = 0; index < pdu.size() && index < cbMsg->cbPduBuffer_->GetSize(); index++) {
495 cbMsg->cbPduBuffer_->pduBuffer_[index] = static_cast<char>(pdu[index]);
496 }
497 auto gsmMsg = std::make_shared<GsmCbGsmCodec>(cbMsg->cbHeader_, cbMsg->cbPduBuffer_, cbMsg);
498 auto umtsMsg = std::make_shared<GsmCbUmtsCodec>(cbMsg->cbHeader_, cbMsg->cbPduBuffer_, cbMsg);
499 gsmMsg->cbPduBuffer_ = cbMsg->cbPduBuffer_;
500 umtsMsg->cbPduBuffer_ = cbMsg->cbPduBuffer_;
501 gsmMsg->Decode2gHeader();
502 gsmMsg->Decode2gHeaderEtws();
503 EXPECT_TRUE(gsmMsg->Decode2gCbMsg());
504
505 gsmMsg->Decode2gHeaderCommonCb();
506 uint16_t dataLen = gsmMsg->cbPduBuffer_->GetSize() - gsmMsg->cbPduBuffer_->GetCurPosition();
507 gsmMsg->Decode2gCbMsg7bit(dataLen);
508 EXPECT_FALSE(gsmMsg->DecodeEtwsMsg());
509
510 umtsMsg->Decode3gHeader();
511 umtsMsg->Decode3gHeaderPartData(0);
512 umtsMsg->Decode3gCbMsg();
513 umtsMsg->Decode3g7Bit();
514 EXPECT_TRUE(umtsMsg->Decode3gUCS2());
515 cbMsg->cbHeader_ = std::make_shared<GsmCbCodec::GsmCbMessageHeader>();
516 cbMsg->cbHeader_->dcs.codingScheme = DataCodingScheme::DATA_CODING_7BIT;
517 gsmMsg->Decode2gCbMsg();
518 EXPECT_TRUE(umtsMsg->Decode3gCbMsg());
519
520 cbMsg->cbHeader_->dcs.codingScheme = DataCodingScheme::DATA_CODING_8BIT;
521 gsmMsg->Decode2gCbMsg();
522 EXPECT_TRUE(umtsMsg->Decode3gCbMsg());
523 cbMsg->cbHeader_->dcs.codingScheme = DataCodingScheme::DATA_CODING_UCS2;
524 gsmMsg->Decode2gCbMsg();
525 EXPECT_TRUE(umtsMsg->Decode3gCbMsg());
526
527 cbMsg->cbHeader_->dcs.codingScheme = DataCodingScheme::DATA_CODING_ASCII7BIT;
528 gsmMsg->Decode2gCbMsg();
529 EXPECT_TRUE(umtsMsg->Decode3gCbMsg());
530 cbMsg->cbHeader_->totalPages = 1;
531 umtsMsg->Decode3g7Bit();
532 EXPECT_TRUE(umtsMsg->Decode3gUCS2());
533 }
534
535 /**
536 * @tc.number Telephony_SmsMmsGtest_GsmCbGsmCodec_0005
537 * @tc.name Test GsmCbGsmCodec
538 * @tc.desc Function test
539 */
540 HWTEST_F(BranchCbTest, GsmCbGsmCodec_0005, Function | MediumTest | Level1)
541 {
542 auto cbMsg = std::make_shared<GsmCbCodec>();
543 ASSERT_NE(cbMsg, nullptr);
544 unsigned char data = 1;
545 std::vector<unsigned char> pdu;
546 pdu.push_back(data);
547 cbMsg->PduAnalysis(pdu);
548 auto gsmMsg = std::make_shared<GsmCbGsmCodec>(cbMsg->cbHeader_, cbMsg->cbPduBuffer_, cbMsg);
549 auto umtsMsg = std::make_shared<GsmCbUmtsCodec>(cbMsg->cbHeader_, cbMsg->cbPduBuffer_, cbMsg);
550 ASSERT_NE(gsmMsg, nullptr);
551 ASSERT_NE(umtsMsg, nullptr);
552 gsmMsg->Decode2gCbMsg();
553 EXPECT_FALSE(umtsMsg->Decode3gCbMsg());
554 cbMsg->cbHeader_ = std::make_shared<GsmCbCodec::GsmCbMessageHeader>();
555 cbMsg->cbHeader_->dcs.codingScheme = DataCodingScheme::DATA_CODING_7BIT;
556 gsmMsg->Decode2gCbMsg();
557 EXPECT_FALSE(umtsMsg->Decode3gCbMsg());
558 cbMsg->cbHeader_->dcs.codingScheme = DataCodingScheme::DATA_CODING_8BIT;
559 gsmMsg->Decode2gCbMsg();
560 EXPECT_FALSE(umtsMsg->Decode3gCbMsg());
561 cbMsg->cbHeader_->dcs.codingScheme = DataCodingScheme::DATA_CODING_UCS2;
562 gsmMsg->Decode2gCbMsg();
563 EXPECT_FALSE(umtsMsg->Decode3gCbMsg());
564 cbMsg->cbHeader_->dcs.codingScheme = DataCodingScheme::DATA_CODING_ASCII7BIT;
565 gsmMsg->Decode2gCbMsg();
566 umtsMsg->Decode3gCbMsg();
567 cbMsg->cbHeader_->totalPages = 1;
568 umtsMsg->Decode3g7Bit();
569 EXPECT_FALSE(umtsMsg->Decode3gUCS2());
570 }
571
572 /**
573 * @tc.number Telephony_SmsMmsGtest_GsmSmsCbHandler_0001
574 * @tc.name Test GsmSmsCbHandler
575 * @tc.desc Function test
576 */
577 HWTEST_F(BranchCbTest, GsmSmsCbHandler_0001, Function | MediumTest | Level1)
578 {
579 auto gsmSmsCbHandler = std::make_shared<GsmSmsCbHandler>(INVALID_SLOTID);
580 auto cbMessage = std::make_shared<GsmCbCodec>();
581 auto message = std::make_shared<CBConfigReportInfo>();
582 AppExecFwk::InnerEvent::Pointer event = AppExecFwk::InnerEvent::Get(RadioEvent::RADIO_CELL_BROADCAST, 1);
583 gsmSmsCbHandler->ProcessEvent(event);
584 event = AppExecFwk::InnerEvent::Get(RadioEvent::RADIO_GET_STATUS, 1);
585 gsmSmsCbHandler->ProcessEvent(event);
586 gsmSmsCbHandler->HandleCbMessage(message);
587 EXPECT_EQ(gsmSmsCbHandler->CheckCbMessage(cbMessage), 0);
588 EXPECT_TRUE(gsmSmsCbHandler->FindCbMessage(cbMessage) == nullptr);
589 EXPECT_FALSE(gsmSmsCbHandler->AddCbMessageToList(cbMessage));
590 EXPECT_FALSE(gsmSmsCbHandler->SendCbMessageBroadcast(cbMessage));
591 EXPECT_TRUE(gsmSmsCbHandler->CheckCbActive(cbMessage));
592 cbMessage->cbHeader_ = std::make_shared<GsmCbCodec::GsmCbMessageHeader>();
593 EXPECT_EQ(gsmSmsCbHandler->CheckCbMessage(cbMessage), 1);
594 cbMessage->cbHeader_->totalPages = 1;
595 EXPECT_EQ(gsmSmsCbHandler->CheckCbMessage(cbMessage), 0x01);
596 EXPECT_FALSE(gsmSmsCbHandler->AddCbMessageToList(cbMessage));
597 CbInfo cbInfo;
598 gsmSmsCbHandler->cbMsgList_.push_back(cbInfo);
599 EXPECT_EQ(gsmSmsCbHandler->CheckCbMessage(cbMessage), 0x01);
600 cbMessage = nullptr;
601 message = nullptr;
602 event = nullptr;
603 gsmSmsCbHandler->ProcessEvent(event);
604 SmsCbData::CbData sendData;
605 gsmSmsCbHandler->GetCbData(cbMessage, sendData);
606 EventFwk::Want want;
607 gsmSmsCbHandler->PackageWantData(sendData, want);
608 gsmSmsCbHandler->HandleCbMessage(message);
609 gsmSmsCbHandler->SetWantData(want, cbMessage);
610 EXPECT_FALSE(gsmSmsCbHandler->CheckCbActive(cbMessage));
611 EXPECT_FALSE(gsmSmsCbHandler->AddCbMessageToList(cbMessage));
612 EXPECT_FALSE(gsmSmsCbHandler->SendCbMessageBroadcast(cbMessage));
613 EXPECT_TRUE(gsmSmsCbHandler->FindCbMessage(cbMessage) == nullptr);
614 EXPECT_EQ(gsmSmsCbHandler->CheckCbMessage(cbMessage), 0);
615 gsmSmsCbHandler->cbMsgList_.clear();
616 gsmSmsCbHandler->ClearExpiredMessage();
617 }
618
619 /**
620 * @tc.number Telephony_SmsMmsGtest_GsmCbCodecOperator_0001
621 * @tc.name Test GsmCbCodec::operator==
622 * @tc.desc Function test
623 */
624 HWTEST_F(BranchCbTest, GsmCbCodecOperator_0001, Function | MediumTest | Level1)
625 {
626 GsmCbCodec gsmCbCodec1;
627 GsmCbCodec gsmCbCodec2;
628 const std::vector<unsigned char> pdu = {0x01, 0x02};
629 EXPECT_FALSE(gsmCbCodec1 == gsmCbCodec2);
630
631 bool ret = gsmCbCodec2.ParamsCheck(pdu);
632 EXPECT_FALSE(gsmCbCodec1 == gsmCbCodec2);
633
634 gsmCbCodec2.cbHeader_ = nullptr;
635 ret = gsmCbCodec1.ParamsCheck(pdu);
636 EXPECT_FALSE(gsmCbCodec1 == gsmCbCodec2);
637
638 ret = gsmCbCodec2.ParamsCheck(pdu);
639 EXPECT_TRUE(gsmCbCodec1 == gsmCbCodec2);
640 }
641
642 /**
643 * @tc.number Telephony_SmsMmsGtest_PickOneByte_0001
644 * @tc.name Test PickOneByte
645 * @tc.desc Function test
646 */
647 HWTEST_F(BranchCbTest, PickOneByte_0001, Function | MediumTest | Level1)
648 {
649 auto cbMsg = std::make_shared<GsmCbCodec>();
650 ASSERT_NE(cbMsg, nullptr);
651 std::vector<unsigned char> pdu(GsmSmsCbHandler::MAX_CB_MSG_LEN + 1, 0x01);
652 bool ret = cbMsg->PduAnalysis(pdu);
653 EXPECT_FALSE(ret);
654 }
655
656 /**
657 * @tc.number Telephony_SmsMmsGtest_GetPduData_0001
658 * @tc.name Test GetPduData
659 * @tc.desc Function test
660 */
661 HWTEST_F(BranchCbTest, GetPduData_0001, Function | MediumTest | Level1)
662 {
663 auto cbMsg = std::make_shared<GsmCbCodec>();
664 ASSERT_NE(cbMsg, nullptr);
665 std::vector<unsigned char> dataPdu = {0x01};
666 cbMsg->GetPduData(dataPdu);
667 EXPECT_TRUE(cbMsg->cbPduBuffer_ == nullptr);
668 }
669
670 /**
671 * @tc.number Telephony_SmsMmsGtest_ConvertToUTF8_0001
672 * @tc.name Test ConvertToUTF8
673 * @tc.desc Function test
674 */
675 HWTEST_F(BranchCbTest, ConvertToUTF8_0001, Function | MediumTest | Level1)
676 {
677 auto cbMsg = std::make_shared<GsmCbCodec>();
678 ASSERT_NE(cbMsg, nullptr);
679 const std::string raw = "raw";
680 std::string message = "message";
681 cbMsg->ConvertToUTF8(raw, message);
682 EXPECT_TRUE(cbMsg->cbHeader_ == nullptr);
683 }
684
685 /**
686 * @tc.number Telephony_SmsMmsGtest_DecodeGeneralDcs_0001
687 * @tc.name Test DecodeGeneralDcs
688 * @tc.desc Function test
689 */
690 HWTEST_F(BranchCbTest, DecodeGeneralDcs_0001, Function | MediumTest | Level1)
691 {
692 auto cbMsg = std::make_shared<GsmCbCodec>();
693 ASSERT_NE(cbMsg, nullptr);
694 const uint8_t dcsData = 0x04;
695 GsmCbCodec::GsmCbMsgDcs dcs = {};
696 uint8_t tmpScheme = (dcsData & 0x0C) >> 0x02;
697 EXPECT_EQ(tmpScheme, 0x01);
698 cbMsg->DecodeGeneralDcs(dcsData, dcs);
699 EXPECT_EQ(dcs.codingScheme, DATA_CODING_8BIT);
700 }
701
702 /**
703 * @tc.number Telephony_SmsMmsGtest_DecodeCbMsgDCS_0001
704 * @tc.name Test DecodeCbMsgDCS
705 * @tc.desc Function test
706 */
707 HWTEST_F(BranchCbTest, DecodeCbMsgDCS_0001, Function | MediumTest | Level1)
708 {
709 auto cbMsg = std::make_shared<GsmCbCodec>();
710 ASSERT_NE(cbMsg, nullptr);
711 const uint8_t dcsData = 0xE0;
712 const unsigned short iosData = 1;
713 GsmCbCodec::GsmCbMsgDcs dcs = {};
714 cbMsg->DecodeCbMsgDCS(dcsData, iosData, dcs);
715 EXPECT_EQ(dcs.codingGroup, GsmCbCodec::SMS_CBMSG_CODGRP_WAP);
716
717 const uint8_t dcsData1 = 0xF0;
718 cbMsg->DecodeCbMsgDCS(dcsData1, iosData, dcs);
719 EXPECT_EQ(dcs.codingGroup, GsmCbCodec::SMS_CBMSG_CODGRP_CLASS_CODING);
720
721 const uint8_t dcsData2 = 0xD0;
722 cbMsg->DecodeCbMsgDCS(dcsData2, iosData, dcs);
723 EXPECT_EQ(dcs.codingGroup, GsmCbCodec::SMS_CBMSG_CODGRP_GENERAL_DCS);
724 }
725
726 /**
727 * @tc.number Telephony_SmsMmsGtest_GsmCbCodecToString_0001
728 * @tc.name Test GsmCbCodecToString
729 * @tc.desc Function test
730 */
731 HWTEST_F(BranchCbTest, GsmCbCodecToString_0001, Function | MediumTest | Level1)
732 {
733 auto cbMsg = std::make_shared<GsmCbCodec>();
734 ASSERT_NE(cbMsg, nullptr);
735 std::string ret = cbMsg->ToString();
736 EXPECT_EQ(ret, "GsmCbCodec Header nullptr");
737 }
738
739 /**
740 * @tc.number Telephony_SmsMmsGtest_GsmCbCodecGetBranch_0001
741 * @tc.name Test GsmCbCodecGetBranch
742 * @tc.desc Function test
743 */
744 HWTEST_F(BranchCbTest, GsmCbCodecGetBranch_0001, Function | MediumTest | Level1)
745 {
746 auto cbMsg = std::make_shared<GsmCbCodec>();
747 ASSERT_NE(cbMsg, nullptr);
748 int8_t cbPriority = 1;
749 bool ret = cbMsg->GetPriority(cbPriority);
750 EXPECT_FALSE(ret);
751
752 uint8_t geoScope = 1;
753 ret = cbMsg->GetGeoScope(geoScope);
754 EXPECT_FALSE(ret);
755
756 uint16_t cbSerial = 1;
757 ret = cbMsg->GetSerialNum(cbSerial);
758 EXPECT_FALSE(ret);
759
760 uint16_t cbCategoty = 1;
761 ret = cbMsg->GetServiceCategory(cbCategoty);
762 EXPECT_FALSE(ret);
763
764 bool primary = true;
765 ret = cbMsg->IsEtwsPrimary(primary);
766 EXPECT_FALSE(ret);
767
768 ret = cbMsg->IsEtwsMessage(primary);
769 EXPECT_FALSE(ret);
770
771 ret = cbMsg->IsCmasMessage(primary);
772 EXPECT_FALSE(ret);
773 }
774
775 /**
776 * @tc.number Telephony_SmsMmsGtest_GetWarningType_0001
777 * @tc.name Test GetWarningType
778 * @tc.desc Function test
779 */
780 HWTEST_F(BranchCbTest, GetWarningType_0001, Function | MediumTest | Level1)
781 {
782 auto cbMsg = std::make_shared<GsmCbCodec>();
783 ASSERT_NE(cbMsg, nullptr);
784 uint16_t type = 1;
785 bool ret = cbMsg->GetWarningType(type);
786 EXPECT_FALSE(ret);
787
788 std::vector<unsigned char> pdu = {0x01};
789 ret = cbMsg->ParamsCheck(pdu);
790 ret = cbMsg->GetWarningType(type);
791 EXPECT_TRUE(ret);
792
793 type = -2; // OTHER_TYPE = -2
794 ret = cbMsg->GetWarningType(type);
795 EXPECT_TRUE(ret);
796 }
797
798 /**
799 * @tc.number Telephony_SmsMmsGtest_GsmCbCodecIsEtws_0001
800 * @tc.name Test GsmCbCodecIsEtws
801 * @tc.desc Function test
802 */
803 HWTEST_F(BranchCbTest, GsmCbCodecIsEtws_0001, Function | MediumTest | Level1)
804 {
805 auto cbMsg = std::make_shared<GsmCbCodec>();
806 ASSERT_NE(cbMsg, nullptr);
807 bool alert = true;
808 bool ret = cbMsg->IsEtwsEmergencyUserAlert(alert);
809 EXPECT_FALSE(ret);
810
811 ret = cbMsg->IsEtwsPopupAlert(alert);
812 EXPECT_FALSE(ret);
813 }
814
815 /**
816 * @tc.number Telephony_SmsMmsGtest_GsmCbCodecGetCmas_0001
817 * @tc.name Test GsmCbCodecGetCmas
818 * @tc.desc Function test
819 */
820 HWTEST_F(BranchCbTest, GsmCbCodecGetCmas_0001, Function | MediumTest | Level1)
821 {
822 auto cbMsg = std::make_shared<GsmCbCodec>();
823 ASSERT_NE(cbMsg, nullptr);
824 uint8_t severity = 1;
825 bool ret = cbMsg->GetCmasSeverity(severity);
826 EXPECT_FALSE(ret);
827
828 uint8_t urgency = 1;
829 ret = cbMsg->GetCmasUrgency(urgency);
830 EXPECT_FALSE(ret);
831
832 uint8_t certainty = 1;
833 ret = cbMsg->GetCmasCertainty(certainty);
834 EXPECT_FALSE(ret);
835
836 uint8_t cmasClass = 1;
837 ret = cbMsg->GetCmasMessageClass(cmasClass);
838 EXPECT_FALSE(ret);
839 }
840
841 /**
842 * @tc.number Telephony_SmsMmsGtest_GsmCbCodecGetBranch_0002
843 * @tc.name Test GsmCbCodecGetBranch
844 * @tc.desc Function test
845 */
846 HWTEST_F(BranchCbTest, GsmCbCodecGetBranch_0002, Function | MediumTest | Level1)
847 {
848 auto cbMsg = std::make_shared<GsmCbCodec>();
849 ASSERT_NE(cbMsg, nullptr);
850 uint16_t msgId = 1;
851 bool ret = cbMsg->GetMessageId(msgId);
852 EXPECT_FALSE(ret);
853
854 uint8_t msgType = 1;
855 ret = cbMsg->GetMsgType(msgType);
856 EXPECT_FALSE(ret);
857
858 ret = cbMsg->GetLangType(msgType);
859 EXPECT_FALSE(ret);
860
861 ret = cbMsg->GetDcs(msgType);
862 EXPECT_FALSE(ret);
863
864 int64_t receiveTime = 1;
865 ret = cbMsg->GetReceiveTime(receiveTime);
866 EXPECT_FALSE(ret);
867 }
868
869 /**
870 * @tc.number Telephony_SmsMmsGtest_Decode2gHeaderBranch_0001
871 * @tc.name Test Decode2gHeaderBranch
872 * @tc.desc Function test
873 */
874 HWTEST_F(BranchCbTest, Decode2gHeaderBranch_0001, Function | MediumTest | Level1)
875 {
876 auto cbMsg = std::make_shared<GsmCbCodec>();
877 ASSERT_NE(cbMsg, nullptr);
878 cbMsg->CreateCbMessage(ETWS_PDU);
879 std::vector<unsigned char> pdu = StringUtils::HexToByteVector(ETWS_PDU);
880 cbMsg->cbPduBuffer_ = std::make_shared<GsmCbPduDecodeBuffer>(pdu.size());
881 cbMsg->cbHeader_ = std::make_shared<GsmCbCodec::GsmCbMessageHeader>();
882 for (size_t index = 0; index < pdu.size() && index < cbMsg->cbPduBuffer_->GetSize(); index++)
883 {
884 cbMsg->cbPduBuffer_->pduBuffer_[index] = static_cast<char>(pdu[index]);
885 }
886 auto gsmMsg = std::make_shared<GsmCbGsmCodec>(cbMsg->cbHeader_, cbMsg->cbPduBuffer_, cbMsg);
887 gsmMsg->cbPduBuffer_ = cbMsg->cbPduBuffer_;
888 gsmMsg->cbPduBuffer_->curPosition_ = gsmMsg->cbPduBuffer_->totolLength_;
889 bool ret = gsmMsg->Decode2gHeader();
890 EXPECT_FALSE(ret);
891 ret = gsmMsg->Decode2gHeaderEtws();
892 EXPECT_FALSE(ret);
893 ret = gsmMsg->Decode2gHeaderCommonCb();
894 EXPECT_FALSE(ret);
895
896 gsmMsg->cbPduBuffer_->curPosition_ = gsmMsg->cbPduBuffer_->totolLength_ - 1;
897 EXPECT_FALSE(gsmMsg->cbHeader_->msgId >= PWS_FIRST_ID);
898 ret = gsmMsg->Decode2gHeaderEtws();
899 EXPECT_FALSE(ret);
900 gsmMsg->cbPduBuffer_->curPosition_ = gsmMsg->cbPduBuffer_->totolLength_ - 1;
901 ret = gsmMsg->Decode2gHeaderCommonCb();
902 EXPECT_FALSE(ret);
903
904 gsmMsg->cbPduBuffer_->curPosition_ = gsmMsg->cbPduBuffer_->totolLength_ - 2;
905 ret = gsmMsg->Decode2gHeader();
906 EXPECT_FALSE(ret);
907 gsmMsg->cbPduBuffer_->curPosition_ = gsmMsg->cbPduBuffer_->totolLength_ - 2;
908 ret = gsmMsg->Decode2gHeaderCommonCb();
909 EXPECT_FALSE(ret);
910
911 gsmMsg->cbPduBuffer_->curPosition_ = gsmMsg->cbPduBuffer_->totolLength_ - 3;
912 ret = gsmMsg->Decode2gHeader();
913 EXPECT_FALSE(ret);
914 gsmMsg->cbPduBuffer_->curPosition_ = gsmMsg->cbPduBuffer_->totolLength_ - 3;
915 ret = gsmMsg->Decode2gHeaderCommonCb();
916 EXPECT_FALSE(ret);
917 }
918
919 /**
920 * @tc.number Telephony_SmsMmsGtest_Decode2gHeaderCommonCb_0001
921 * @tc.name Test Decode2gHeaderCommonCb
922 * @tc.desc Function test
923 */
924 HWTEST_F(BranchCbTest, Decode2gHeaderCommonCb_0001, Function | MediumTest | Level1)
925 {
926 auto cbMsg = std::make_shared<GsmCbCodec>();
927 ASSERT_NE(cbMsg, nullptr);
928 cbMsg->CreateCbMessage(ETWS_PDU);
929 std::vector<unsigned char> pdu = StringUtils::HexToByteVector(ETWS_PDU);
930 cbMsg->cbPduBuffer_ = std::make_shared<GsmCbPduDecodeBuffer>(pdu.size());
931 cbMsg->cbHeader_ = std::make_shared<GsmCbCodec::GsmCbMessageHeader>();
932 for (size_t index = 0; index < pdu.size() && index < cbMsg->cbPduBuffer_->GetSize(); index++)
933 {
934 cbMsg->cbPduBuffer_->pduBuffer_[index] = static_cast<char>(pdu[index]);
935 }
936 auto gsmMsg = std::make_shared<GsmCbGsmCodec>(cbMsg->cbHeader_, cbMsg->cbPduBuffer_, cbMsg);
937 ASSERT_NE(gsmMsg, nullptr);
938 gsmMsg->cbPduBuffer_ = nullptr;
939 bool ret = gsmMsg->Decode2gHeaderCommonCb();
940 EXPECT_FALSE(ret);
941
942 gsmMsg->cbPduBuffer_ = cbMsg->cbPduBuffer_;
943 gsmMsg->cbHeader_->totalPages = 18; // MAX_PAGE_NUM
944 ret = gsmMsg->Decode2gHeaderCommonCb();
945 EXPECT_TRUE(ret);
946 }
947
948 /**
949 * @tc.number Telephony_SmsMmsGtest_Decode2gCbMsg_0001
950 * @tc.name Test Decode2gCbMsg
951 * @tc.desc Function test
952 */
953 HWTEST_F(BranchCbTest, Decode2gCbMsg_0001, Function | MediumTest | Level1)
954 {
955 auto cbMsg = std::make_shared<GsmCbCodec>();
956 ASSERT_NE(cbMsg, nullptr);
957 cbMsg->CreateCbMessage(ETWS_PDU);
958 std::vector<unsigned char> pdu = StringUtils::HexToByteVector(ETWS_PDU);
959 cbMsg->cbPduBuffer_ = std::make_shared<GsmCbPduDecodeBuffer>(pdu.size());
960 cbMsg->cbHeader_ = std::make_shared<GsmCbCodec::GsmCbMessageHeader>();
961 for (size_t index = 0; index < pdu.size() && index < cbMsg->cbPduBuffer_->GetSize(); index++)
962 {
963 cbMsg->cbPduBuffer_->pduBuffer_[index] = static_cast<char>(pdu[index]);
964 }
965 auto gsmMsg = std::make_shared<GsmCbGsmCodec>(cbMsg->cbHeader_, cbMsg->cbPduBuffer_, cbMsg);
966 gsmMsg->cbHeader_->dcs.codingScheme = DATA_CODING_8BIT;
967 gsmMsg->cbPduBuffer_->curPosition_ = gsmMsg->cbPduBuffer_->totolLength_ - 1;
968 bool ret = gsmMsg->Decode2gCbMsg();
969 EXPECT_FALSE(ret);
970
971 gsmMsg->cbPduBuffer_->curPosition_ = 0;
972 ret = gsmMsg->Decode2gCbMsg();
973 EXPECT_TRUE(ret);
974
975 gsmMsg->cbHeader_->dcs.iso639Lang[0] = 0;
976 ret = gsmMsg->Decode2gCbMsg();
977 EXPECT_TRUE(ret);
978
979 gsmMsg->cbHeader_->dcs.iso639Lang[0] = 1;
980 ret = gsmMsg->Decode2gCbMsg();
981 EXPECT_TRUE(ret);
982
983 ret = gsmMsg->Decode2gCbMsg();
984 EXPECT_TRUE(ret);
985
986 gsmMsg->cbPduBuffer_->pduBuffer_ = nullptr;
987 ret = gsmMsg->Decode2gCbMsg();
988 EXPECT_FALSE(ret);
989
990 gsmMsg->cbHeader_->dcs.codingScheme = DATA_CODING_AUTO;
991 ret = gsmMsg->Decode2gCbMsg();
992 EXPECT_TRUE(ret);
993 }
994
995 /**
996 * @tc.number Telephony_SmsMmsGtest_Decode2gCbMsg7bit_0001
997 * @tc.name Test Decode2gCbMsg7bit
998 * @tc.desc Function test
999 */
1000 HWTEST_F(BranchCbTest, Decode2gCbMsg7bit_0001, Function | MediumTest | Level1)
1001 {
1002 auto cbMsg = std::make_shared<GsmCbCodec>();
1003 ASSERT_NE(cbMsg, nullptr);
1004 cbMsg->cbPduBuffer_ = std::make_shared<GsmCbPduDecodeBuffer>(0);
1005 cbMsg->cbHeader_ = std::make_shared<GsmCbCodec::GsmCbMessageHeader>();
1006 auto gsmMsg = std::make_shared<GsmCbGsmCodec>(cbMsg->cbHeader_, cbMsg->cbPduBuffer_, cbMsg);
1007 ASSERT_NE(gsmMsg, nullptr);
1008 uint16_t dataLen = 5;
1009 bool ret = gsmMsg->Decode2gCbMsg7bit(dataLen);
1010 EXPECT_FALSE(ret);
1011 }
1012
1013 /**
1014 * @tc.number Telephony_SmsMmsGtest_Decode2gCbMsg7bit_0002
1015 * @tc.name Test Decode2gCbMsg7bit
1016 * @tc.desc Function test
1017 */
1018 HWTEST_F(BranchCbTest, Decode2gCbMsg7bit_0002, Function | MediumTest | Level1)
1019 {
1020 auto cbMsg = std::make_shared<GsmCbCodec>();
1021 ASSERT_NE(cbMsg, nullptr);
1022 cbMsg->CreateCbMessage(CMAS_JP_PDU);
1023 std::vector<unsigned char> pdu = StringUtils::HexToByteVector(CMAS_JP_PDU);
1024 cbMsg->cbPduBuffer_ = std::make_shared<GsmCbPduDecodeBuffer>(pdu.size());
1025 cbMsg->cbHeader_ = std::make_shared<GsmCbCodec::GsmCbMessageHeader>();
1026 for (size_t index = 0; index < pdu.size() && index < cbMsg->cbPduBuffer_->GetSize(); index++)
1027 {
1028 cbMsg->cbPduBuffer_->pduBuffer_[index] = static_cast<char>(pdu[index]);
1029 }
1030 auto gsmMsg = std::make_shared<GsmCbGsmCodec>(cbMsg->cbHeader_, cbMsg->cbPduBuffer_, cbMsg);
1031 ASSERT_NE(gsmMsg, nullptr);
1032 gsmMsg->cbPduBuffer_ = cbMsg->cbPduBuffer_;
1033 gsmMsg->cbHeader_->dcs.iso639Lang[0] = 1;
1034 uint16_t dataLen = 5;
1035 bool ret = gsmMsg->Decode2gCbMsg7bit(dataLen);
1036 EXPECT_TRUE(ret);
1037 }
1038
1039 /**
1040 * @tc.number Telephony_SmsMmsGtest_misc_manager_CloseCBRange_0001
1041 * @tc.name Test CloseCBRange
1042 * @tc.desc Function test
1043 */
1044 HWTEST_F(BranchCbTest, misc_manager_CloseCBRange_0001, Function | MediumTest | Level1)
1045 {
1046 auto smsMiscManager = std::make_shared<SmsMiscManager>(INVALID_SLOTID);
1047 ASSERT_NE(smsMiscManager, nullptr);
1048 uint32_t fromMsgId = 2;
1049 uint32_t toMsgId = 2;
1050 SmsMiscManager::gsmCBRangeInfo rangeInfo(2, 2);
1051 smsMiscManager->rangeList_ = {rangeInfo};
1052 bool ret = smsMiscManager->CloseCBRange(fromMsgId, toMsgId);
1053 EXPECT_TRUE(ret);
1054
1055 smsMiscManager->rangeList_ = {rangeInfo};
1056 toMsgId = 3;
1057 ret = smsMiscManager->CloseCBRange(fromMsgId, toMsgId);
1058 EXPECT_TRUE(ret);
1059
1060 smsMiscManager->rangeList_ = {rangeInfo};
1061 toMsgId = 1;
1062 ret = smsMiscManager->CloseCBRange(fromMsgId, toMsgId);
1063 EXPECT_TRUE(ret);
1064
1065 smsMiscManager->rangeList_ = {rangeInfo};
1066 fromMsgId = 1;
1067 toMsgId = 2;
1068 ret = smsMiscManager->CloseCBRange(fromMsgId, toMsgId);
1069 EXPECT_TRUE(ret);
1070
1071 smsMiscManager->rangeList_ = {rangeInfo};
1072 toMsgId = 3;
1073 ret = smsMiscManager->CloseCBRange(fromMsgId, toMsgId);
1074 EXPECT_TRUE(ret);
1075
1076 smsMiscManager->rangeList_ = {rangeInfo};
1077 fromMsgId = 3;
1078 toMsgId = 2;
1079 ret = smsMiscManager->CloseCBRange(fromMsgId, toMsgId);
1080 EXPECT_TRUE(ret);
1081
1082 smsMiscManager->rangeList_ = {rangeInfo};
1083 toMsgId = 1;
1084 ret = smsMiscManager->CloseCBRange(fromMsgId, toMsgId);
1085 EXPECT_TRUE(ret);
1086
1087 SmsMiscManager::gsmCBRangeInfo rangeInfo1(2, 3);
1088 smsMiscManager->rangeList_ = {rangeInfo1};
1089 toMsgId = 3;
1090 ret = smsMiscManager->CloseCBRange(fromMsgId, toMsgId);
1091 EXPECT_TRUE(ret);
1092
1093 SmsMiscManager::gsmCBRangeInfo rangeInfo2(2, 1);
1094 smsMiscManager->rangeList_ = {rangeInfo2};
1095 fromMsgId = 1;
1096 toMsgId = 1;
1097 ret = smsMiscManager->CloseCBRange(fromMsgId, toMsgId);
1098 EXPECT_TRUE(ret);
1099 }
1100
1101 /**
1102 * @tc.number Telephony_SmsMmsGtest_misc_manager_SplitMidValue_0001
1103 * @tc.name Test SplitMidValue
1104 * @tc.desc Function test
1105 */
1106 HWTEST_F(BranchCbTest, misc_manager_SplitMidValue_0001, Function | MediumTest | Level1)
1107 {
1108 auto smsMiscManager = std::make_shared<SmsMiscManager>(INVALID_SLOTID);
1109 ASSERT_NE(smsMiscManager, nullptr);
1110 std::string value = "";
1111 std::string start = "";
1112 std::string end = "";
1113 const std::string delimiter = ":";
1114 bool ret = smsMiscManager->SplitMidValue(value, start, end, delimiter);
1115 EXPECT_FALSE(ret);
1116
1117 value = ":value";
1118 ret = smsMiscManager->SplitMidValue(value, start, end, delimiter);
1119 EXPECT_FALSE(ret);
1120
1121 value = "value:";
1122 ret = smsMiscManager->SplitMidValue(value, start, end, delimiter);
1123 EXPECT_FALSE(ret);
1124
1125 value = "value";
1126 ret = smsMiscManager->SplitMidValue(value, start, end, delimiter);
1127 EXPECT_TRUE(ret);
1128
1129 value = "smsMisc:value";
1130 ret = smsMiscManager->SplitMidValue(value, start, end, delimiter);
1131 EXPECT_TRUE(ret);
1132 }
1133
1134 /**
1135 * @tc.number Telephony_SmsMmsGtest_misc_DelSimMessage_0001
1136 * @tc.name Test DelSimMessage
1137 * @tc.desc Function test
1138 */
1139 HWTEST_F(BranchCbTest, misc_manager_DelSimMessage_0001, Function | MediumTest | Level1)
1140 {
1141 auto smsMiscManager = std::make_shared<SmsMiscManager>(INVALID_SLOTID);
1142 ASSERT_NE(smsMiscManager, nullptr);
1143 uint32_t msgIndex = 1;
1144 int32_t ret = smsMiscManager->DelSimMessage(msgIndex);
1145 EXPECT_EQ(ret, TELEPHONY_ERR_SLOTID_INVALID);
1146 }
1147
1148 /**
1149 * @tc.number Telephony_SmsMmsGtest_misc_SetSmscAddr_0001
1150 * @tc.name Test SetSmscAddr
1151 * @tc.desc Function test
1152 */
1153 HWTEST_F(BranchCbTest, misc_manager_SetSmscAddr_0001, Function | MediumTest | Level1)
1154 {
1155 auto smsMiscManager = std::make_shared<SmsMiscManager>(INVALID_SLOTID);
1156 ASSERT_NE(smsMiscManager, nullptr);
1157 const std::string scAddr = "";
1158 int32_t ret = smsMiscManager->SetSmscAddr(scAddr);
1159 EXPECT_EQ(ret, TELEPHONY_ERR_RIL_CMD_FAIL);
1160 std::u16string smscAddress = u"";
1161 ret = smsMiscManager->GetSmscAddr(smscAddress);
1162 EXPECT_EQ(ret, TELEPHONY_ERR_SUCCESS);
1163 }
1164
1165 /**
1166 * @tc.number Telephony_SmsMmsGtest_GetSmsStateEventIntValue_0001
1167 * @tc.name Test GetSmsStateEventIntValue
1168 * @tc.desc Function test
1169 */
1170 HWTEST_F(BranchCbTest, misc_GetSmsStateEventIntValue_0001, Function | MediumTest | Level1)
1171 {
1172 std::shared_ptr<CommonEventSubscribeInfo> subscribeInfo = std::make_shared<CommonEventSubscribeInfo>();
1173 std::shared_ptr<SmsStateEventSubscriber> smsStateEventSubscriber =
1174 std::make_shared<SmsStateEventSubscriber>(*subscribeInfo);
1175 std::string event = "event";
1176 smsStateEventSubscriber->smsStateEvenMapIntValues_[event] = COMMON_EVENT_SMS_CB_RECEIVE_COMPLETED;
1177 auto ret = smsStateEventSubscriber->GetSmsStateEventIntValue(event);
1178 EXPECT_EQ(ret, COMMON_EVENT_SMS_CB_RECEIVE_COMPLETED);
1179 }
1180
1181 /**
1182 * @tc.number Telephony_Sms_OnAddSystemAbility_0001
1183 * @tc.name Test OnAddSystemAbility
1184 * @tc.desc Function test
1185 */
1186 HWTEST_F(BranchCbTest, Sms_OnAddSystemAbility_0001, Function | MediumTest | Level1)
1187 {
1188 std::shared_ptr<SmsStateEventSubscriber> smsStateEventSubscriber = nullptr;
1189 std::shared_ptr<SmsStateObserver::SystemAbilityStatusChangeListener> sysAbilityStatus =
1190 std::make_shared<SmsStateObserver::SystemAbilityStatusChangeListener>(smsStateEventSubscriber);
1191 int32_t systemAbilityId = 1;
1192 const std::string deviceId = "123";
1193 sysAbilityStatus->OnAddSystemAbility(systemAbilityId, deviceId);
1194 EXPECT_TRUE(systemAbilityId != COMMON_EVENT_SERVICE_ID);
1195
1196 systemAbilityId = COMMON_EVENT_SERVICE_ID;
1197 sysAbilityStatus->OnAddSystemAbility(systemAbilityId, deviceId);
1198 EXPECT_TRUE(sysAbilityStatus->sub_ == nullptr);
1199 }
1200
1201 /**
1202 * @tc.number Telephony_Sms_OnRemoveSystemAbility_0001
1203 * @tc.name Test OnRemoveSystemAbility
1204 * @tc.desc Function test
1205 */
1206 HWTEST_F(BranchCbTest, Sms_OnRemoveSystemAbility_0001, Function | MediumTest | Level1)
1207 {
1208 std::shared_ptr<CommonEventSubscribeInfo> subscribeInfo = std::make_shared<CommonEventSubscribeInfo>();
1209 std::shared_ptr<SmsStateEventSubscriber> smsStateEventSubscriber = nullptr;
1210 std::shared_ptr<SmsStateObserver::SystemAbilityStatusChangeListener> sysAbilityStatus =
1211 std::make_shared<SmsStateObserver::SystemAbilityStatusChangeListener>(smsStateEventSubscriber);
1212 int32_t systemAbilityId = 1;
1213 const std::string deviceId = "123";
1214 sysAbilityStatus->OnRemoveSystemAbility(systemAbilityId, deviceId);
1215 EXPECT_TRUE(systemAbilityId != COMMON_EVENT_SERVICE_ID);
1216
1217 systemAbilityId = COMMON_EVENT_SERVICE_ID;
1218 sysAbilityStatus->OnRemoveSystemAbility(systemAbilityId, deviceId);
1219 EXPECT_TRUE(systemAbilityId == COMMON_EVENT_SERVICE_ID);
1220
1221 sysAbilityStatus->OnRemoveSystemAbility(systemAbilityId, deviceId);
1222 EXPECT_TRUE(sysAbilityStatus->sub_ == nullptr);
1223
1224 smsStateEventSubscriber = std::make_shared<SmsStateEventSubscriber>(*subscribeInfo);
1225 sysAbilityStatus =
1226 std::make_shared<SmsStateObserver::SystemAbilityStatusChangeListener>(smsStateEventSubscriber);
1227 sysAbilityStatus->OnRemoveSystemAbility(systemAbilityId, deviceId);
1228 EXPECT_TRUE(sysAbilityStatus->sub_ != nullptr);
1229 }
1230
1231 /**
1232 * @tc.number Telephony_Sms_GetSmsUserDataMultipage_0001
1233 * @tc.name Test GetSmsUserDataMultipage
1234 * @tc.desc Function test
1235 */
1236 HWTEST_F(BranchCbTest, Sms_GetSmsUserDataMultipage_0001, Function | MediumTest | Level1)
1237 {
1238 auto reliabilityHandler = std::make_shared<SmsReceiveReliabilityHandler>(INVALID_SLOTID);
1239 int32_t smsPagesCount = 1;
1240 SmsReceiveIndexer smsReceiveIndexer;
1241 smsReceiveIndexer.msgSeqId_ = 0;
1242 smsReceiveIndexer.msgRefId_ = 1;
1243 std::vector<SmsReceiveIndexer> dbIndexers = {smsReceiveIndexer, smsReceiveIndexer};
1244 int32_t position = -1;
1245 std::vector<std::string> initialData = {"User1", "User2"};
1246 std::shared_ptr<std::vector<std::string>> userDataRaws = std::make_shared<std::vector<std::string>>(initialData);
1247 reliabilityHandler->GetSmsUserDataMultipage(smsPagesCount, MAX_SEGMENT_NUM, dbIndexers, position, userDataRaws);
1248 EXPECT_TRUE(position < 0);
1249
1250 position = 2;
1251 reliabilityHandler->GetSmsUserDataMultipage(smsPagesCount, MAX_SEGMENT_NUM, dbIndexers, position, userDataRaws);
1252 EXPECT_TRUE(position >= static_cast<int32_t>(dbIndexers.size()));
1253
1254 position = 0;
1255 reliabilityHandler->GetSmsUserDataMultipage(smsPagesCount, dbIndexers[position].GetMsgCount(), dbIndexers,
1256 position, userDataRaws);
1257 EXPECT_TRUE(dbIndexers[position].GetMsgSeqId() < 1);
1258
1259 dbIndexers[position].msgSeqId_ = MAX_SEGMENT_NUM + 1;
1260 reliabilityHandler->HiSysEventCBResult(true);
1261 reliabilityHandler->GetSmsUserDataMultipage(smsPagesCount, dbIndexers[position].GetMsgCount(), dbIndexers,
1262 position, userDataRaws);
1263 EXPECT_TRUE(dbIndexers[position].GetMsgSeqId() > MAX_SEGMENT_NUM);
1264
1265 dbIndexers[position].msgSeqId_ = 1;
1266 dbIndexers[position + 1].msgSeqId_ = 0;
1267 reliabilityHandler->GetSmsUserDataMultipage(smsPagesCount, dbIndexers[position].GetMsgCount(), dbIndexers,
1268 position, userDataRaws);
1269 EXPECT_TRUE(dbIndexers[position + 1].GetMsgSeqId() < 1);
1270
1271 dbIndexers.push_back(smsReceiveIndexer);
1272 dbIndexers[position + 1].msgSeqId_ = MAX_SEGMENT_NUM + 1;
1273 reliabilityHandler->GetSmsUserDataMultipage(smsPagesCount, dbIndexers[position].GetMsgCount(), dbIndexers,
1274 position, userDataRaws);
1275 EXPECT_TRUE(dbIndexers[position + 1].GetMsgSeqId() > MAX_SEGMENT_NUM);
1276
1277 dbIndexers.push_back(smsReceiveIndexer);
1278 dbIndexers[position + 1].msgSeqId_ = 1;
1279 reliabilityHandler->GetSmsUserDataMultipage(smsPagesCount, dbIndexers[position].GetMsgCount(), dbIndexers,
1280 position, userDataRaws);
1281 EXPECT_EQ(smsPagesCount, 2);
1282 }
1283
1284 /**
1285 * @tc.number Telephony_Sms_SendCacheMapLimitCheck_0001
1286 * @tc.name Test SendCacheMapLimitCheck
1287 * @tc.desc Function test
1288 */
1289 HWTEST_F(BranchCbTest, Sms_SendCacheMapLimitCheck_0001, Function | MediumTest | Level1)
1290 {
1291 std::function<void(std::shared_ptr<SmsSendIndexer>)> fun = nullptr;
1292 std::shared_ptr<SmsSender> smsSender = std::make_shared<CdmaSmsSender>(INVALID_SLOTID, fun);
1293 const sptr<ISendShortMessageCallback> sendCallback = nullptr;
1294 bool ret = smsSender->SendCacheMapLimitCheck(sendCallback);
1295 EXPECT_FALSE(ret);
1296 for (size_t i = 0; i < 30; i++)
1297 {
1298 smsSender->sendCacheMap_[i] = nullptr;
1299 }
1300 ret = smsSender->SendCacheMapLimitCheck(sendCallback);
1301 EXPECT_TRUE(ret);
1302 }
1303 } // namespace Telephony
1304 } // namespace OHOS
1305