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