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 #include "core_service_client.h"
17 #include "gtest/gtest.h"
18 #include "i_sms_service_interface.h"
19 #include "if_system_ability_manager.h"
20 #include "iservice_registry.h"
21 #include "radio_event.h"
22 #include "sms_broadcast_subscriber_gtest.h"
23 #include "sms_mms_gtest.h"
24 #include "sms_mms_test_helper.h"
25 #include "sms_service.h"
26 #include "sms_service_manager_client.h"
27 #include "telephony_log_wrapper.h"
28 #include "telephony_types.h"
29
30 namespace OHOS {
31 namespace Telephony {
32 namespace {
33 sptr<ISmsServiceInterface> g_telephonyService = nullptr;
34 } // namespace
35 using namespace testing::ext;
36
37 class CbGtest : public testing::Test {
38 public:
39 static void SetUpTestCase();
40 static void TearDownTestCase();
41 void SetUp();
42 void TearDown();
43 static sptr<ISmsServiceInterface> GetProxy();
HasSimCard(int32_t slotId)44 static bool HasSimCard(int32_t slotId)
45 {
46 bool hasSimCard = false;
47 if (CoreServiceClient::GetInstance().GetProxy() == nullptr) {
48 return hasSimCard;
49 }
50 CoreServiceClient::GetInstance().HasSimCard(slotId, hasSimCard);
51 return hasSimCard;
52 }
53 };
54
TearDownTestCase()55 void CbGtest::TearDownTestCase() {}
56
SetUp()57 void CbGtest::SetUp() {}
58
TearDown()59 void CbGtest::TearDown() {}
60
61 const int32_t DEFAULT_SIM_SLOT_ID_1 = 1;
62 const uint16_t MESSAGE_TYPE = 4;
63 const uint16_t CB_PDU_LEN = 100;
64
SetUpTestCase()65 void CbGtest::SetUpTestCase()
66 {
67 TELEPHONY_LOGI("SetUpTestCase slotId%{public}d", DEFAULT_SIM_SLOT_ID_1);
68 g_telephonyService = GetProxy();
69 if (g_telephonyService == nullptr) {
70 return;
71 }
72 Singleton<SmsServiceManagerClient>::GetInstance().ResetSmsServiceProxy();
73 Singleton<SmsServiceManagerClient>::GetInstance().InitSmsServiceProxy();
74 }
75
GetProxy()76 sptr<ISmsServiceInterface> CbGtest::GetProxy()
77 {
78 auto systemAbilityMgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
79 if (systemAbilityMgr == nullptr) {
80 return nullptr;
81 }
82 sptr<IRemoteObject> remote = systemAbilityMgr->CheckSystemAbility(TELEPHONY_SMS_MMS_SYS_ABILITY_ID);
83 if (remote) {
84 sptr<ISmsServiceInterface> smsService = iface_cast<ISmsServiceInterface>(remote);
85 return smsService;
86 }
87 return nullptr;
88 }
89
90 #ifndef TEL_TEST_UNSUPPORT
OpenCellBroadcastTestFuc(SmsMmsTestHelper &helper)91 void OpenCellBroadcastTestFuc(SmsMmsTestHelper &helper)
92 {
93 AccessMmsToken token;
94 bool enable = true;
95 uint32_t fromMsgId = 0;
96 uint32_t toMsgId = 10;
97 uint8_t netType = 1;
98 int32_t result = Singleton<SmsServiceManagerClient>::GetInstance().SetCBConfig(
99 helper.slotId, enable, fromMsgId, toMsgId, netType);
100 helper.SetIntResult(result);
101 helper.NotifyAll();
102 }
103
104 /**
105 * @tc.number Telephony_SmsMmsGtest_OpenCellBroadcast_0001
106 * @tc.name Open cellBroadcast slotId is -1
107 * @tc.desc Function test
108 */
HWTEST_F(CbGtest, OpenCellBroadcast_0001, Function | MediumTest | Level3)109 HWTEST_F(CbGtest, OpenCellBroadcast_0001, Function | MediumTest | Level3)
110 {
111 TELEPHONY_LOGI("TelSMSMMSTest::OpenCellBroadcast_0001 -->");
112 if (!(CbGtest::HasSimCard(DEFAULT_SIM_SLOT_ID))) {
113 TELEPHONY_LOGI("TelephonyTestService has no sim card");
114 ASSERT_FALSE(CbGtest::HasSimCard(DEFAULT_SIM_SLOT_ID));
115 return;
116 }
117 SmsMmsTestHelper helper;
118 helper.slotId = DEFAULT_SIM_SLOT_ID_REMOVE;
119 if (!helper.Run(OpenCellBroadcastTestFuc, std::ref(helper))) {
120 TELEPHONY_LOGI("OpenCellBroadcastTestFuc out of time");
121 ASSERT_TRUE(helper.Run(OpenCellBroadcastTestFuc, std::ref(helper)));
122 }
123 TELEPHONY_LOGI("TelSMSMMSTest::OpenCellBroadcast_0001 -->finished");
124 EXPECT_NE(helper.GetIntResult(), 0);
125 }
126
OpenCellBroadcastTestFuc2(SmsMmsTestHelper &helper)127 void OpenCellBroadcastTestFuc2(SmsMmsTestHelper &helper)
128 {
129 AccessMmsToken token;
130 bool enable = true;
131 uint32_t fromMsgId = 20;
132 uint32_t toMsgId = 10;
133 uint8_t netType = 1;
134 int32_t result = Singleton<SmsServiceManagerClient>::GetInstance().SetCBConfig(
135 helper.slotId, enable, fromMsgId, toMsgId, netType);
136 helper.SetIntResult(result);
137 helper.NotifyAll();
138 }
139
OpenCellBroadcastTestFuc3(SmsMmsTestHelper &helper)140 void OpenCellBroadcastTestFuc3(SmsMmsTestHelper &helper)
141 {
142 AccessMmsToken token;
143 bool enable = true;
144 uint32_t fromMsgId = 0;
145 uint32_t toMsgId = 10;
146 uint8_t netType = 3;
147 int32_t result = Singleton<SmsServiceManagerClient>::GetInstance().SetCBConfig(
148 helper.slotId, enable, fromMsgId, toMsgId, netType);
149 helper.SetIntResult(result);
150 helper.NotifyAll();
151 }
152
153 /**
154 * @tc.number Telephony_SmsMmsGtest_OpenCellBroadcast_0003
155 * @tc.name Open cellBroadcast netType is unknown.
156 * @tc.desc Function test
157 */
HWTEST_F(CbGtest, OpenCellBroadcast_0003, Function | MediumTest | Level3)158 HWTEST_F(CbGtest, OpenCellBroadcast_0003, Function | MediumTest | Level3)
159 {
160 TELEPHONY_LOGI("TelSMSMMSTest::OpenCellBroadcast_0003 -->");
161 if (!(CbGtest::HasSimCard(DEFAULT_SIM_SLOT_ID))) {
162 TELEPHONY_LOGI("TelephonyTestService has no sim card");
163 ASSERT_FALSE(CbGtest::HasSimCard(DEFAULT_SIM_SLOT_ID));
164 return;
165 }
166 SmsMmsTestHelper helper;
167 helper.slotId = DEFAULT_SIM_SLOT_ID;
168 if (!helper.Run(OpenCellBroadcastTestFuc3, std::ref(helper))) {
169 TELEPHONY_LOGI("OpenCellBroadcastTestFuc3 out of time");
170 ASSERT_TRUE(helper.Run(OpenCellBroadcastTestFuc3, std::ref(helper)));
171 }
172 TELEPHONY_LOGI("TelSMSMMSTest::OpenCellBroadcast_0003 -->finished");
173 EXPECT_NE(helper.GetIntResult(), 0);
174 }
175
OpenCellBroadcastTestFuc4(SmsMmsTestHelper &helper)176 void OpenCellBroadcastTestFuc4(SmsMmsTestHelper &helper)
177 {
178 AccessMmsToken token;
179 bool enable = true;
180 uint32_t fromMsgId = 0;
181 uint32_t toMsgId = 10;
182 uint8_t netType = 1;
183 int32_t result = Singleton<SmsServiceManagerClient>::GetInstance().SetCBConfig(
184 helper.slotId, enable, fromMsgId, toMsgId, netType);
185 helper.SetIntResult(result);
186 helper.NotifyAll();
187 }
188
189 /**
190 * @tc.number Telephony_SmsMmsGtest_OpenCellBroadcast_0004
191 * @tc.name Open cellBroadcast parameter is valid.
192 * @tc.desc Function test
193 */
HWTEST_F(CbGtest, OpenCellBroadcast_0004, Function | MediumTest | Level3)194 HWTEST_F(CbGtest, OpenCellBroadcast_0004, Function | MediumTest | Level3)
195 {
196 TELEPHONY_LOGI("TelSMSMMSTest::OpenCellBroadcast_0004 -->");
197 if (!(CbGtest::HasSimCard(DEFAULT_SIM_SLOT_ID))) {
198 TELEPHONY_LOGI("TelephonyTestService has no sim card");
199 ASSERT_FALSE(CbGtest::HasSimCard(DEFAULT_SIM_SLOT_ID));
200 return;
201 }
202 SmsMmsTestHelper helper;
203 helper.slotId = DEFAULT_SIM_SLOT_ID;
204 if (!helper.Run(OpenCellBroadcastTestFuc4, std::ref(helper))) {
205 TELEPHONY_LOGI("OpenCellBroadcastTestFuc4 out of time");
206 ASSERT_TRUE(helper.Run(OpenCellBroadcastTestFuc4, std::ref(helper)));
207 }
208 TELEPHONY_LOGI("TelSMSMMSTest::OpenCellBroadcast_0004 -->finished");
209 ASSERT_GE(helper.GetIntResult(), 0);
210 }
211
OpenCellBroadcastTestFuc5(SmsMmsTestHelper &helper)212 void OpenCellBroadcastTestFuc5(SmsMmsTestHelper &helper)
213 {
214 AccessMmsToken token;
215 bool enable = true;
216 uint32_t fromMsgId = 0;
217 uint32_t toMsgId = 1000;
218 uint8_t netType = 1;
219 int32_t result = Singleton<SmsServiceManagerClient>::GetInstance().SetCBConfig(
220 helper.slotId, enable, fromMsgId, toMsgId, netType);
221 helper.SetIntResult(result);
222 helper.NotifyAll();
223 }
224
225 /**
226 * @tc.number Telephony_SmsMmsGtest_OpenCellBroadcast_0005
227 * @tc.name Open cellBroadcast parameter is valid
228 * @tc.desc Function test
229 */
HWTEST_F(CbGtest, OpenCellBroadcast_0005, Function | MediumTest | Level3)230 HWTEST_F(CbGtest, OpenCellBroadcast_0005, Function | MediumTest | Level3)
231 {
232 TELEPHONY_LOGI("TelSMSMMSTest::OpenCellBroadcast_0005 -->");
233 if (!(CbGtest::HasSimCard(DEFAULT_SIM_SLOT_ID))) {
234 TELEPHONY_LOGI("TelephonyTestService has no sim card");
235 ASSERT_FALSE(CbGtest::HasSimCard(DEFAULT_SIM_SLOT_ID));
236 return;
237 }
238 SmsMmsTestHelper helper;
239 helper.slotId = DEFAULT_SIM_SLOT_ID;
240 if (!helper.Run(OpenCellBroadcastTestFuc5, std::ref(helper))) {
241 TELEPHONY_LOGI("OpenCellBroadcastTestFuc5 out of time");
242 ASSERT_TRUE(helper.Run(OpenCellBroadcastTestFuc5, std::ref(helper)));
243 }
244 TELEPHONY_LOGI("TelSMSMMSTest::OpenCellBroadcast_0005 -->finished");
245 ASSERT_GE(helper.GetIntResult(), 0);
246 }
247
OpenCellBroadcastTestFuc6(SmsMmsTestHelper &helper)248 void OpenCellBroadcastTestFuc6(SmsMmsTestHelper &helper)
249 {
250 bool enable = true;
251 uint32_t fromMsgId = 0;
252 uint32_t toMsgId = 0;
253 uint8_t netType = 1;
254 int32_t result = Singleton<SmsServiceManagerClient>::GetInstance().SetCBConfig(
255 helper.slotId, enable, fromMsgId, toMsgId, netType);
256 helper.SetIntResult(result);
257 helper.NotifyAll();
258 }
259
OpenCellBroadcastTestFuc6WithToken(SmsMmsTestHelper &helper)260 void OpenCellBroadcastTestFuc6WithToken(SmsMmsTestHelper &helper)
261 {
262 AccessMmsToken token;
263 OpenCellBroadcastTestFuc6(helper);
264 }
265
266 /**
267 * @tc.number Telephony_SmsMmsGtest_OpenCellBroadcast_0006
268 * @tc.name Open cellBroadcast parameter is valid
269 * @tc.desc Function test
270 */
HWTEST_F(CbGtest, OpenCellBroadcast_0006, Function | MediumTest | Level3)271 HWTEST_F(CbGtest, OpenCellBroadcast_0006, Function | MediumTest | Level3)
272 {
273 TELEPHONY_LOGI("TelSMSMMSTest::OpenCellBroadcast_0006 -->");
274 if (!(CbGtest::HasSimCard(DEFAULT_SIM_SLOT_ID))) {
275 TELEPHONY_LOGI("TelephonyTestService has no sim card");
276 ASSERT_FALSE(CbGtest::HasSimCard(DEFAULT_SIM_SLOT_ID));
277 return;
278 }
279 SmsMmsTestHelper helper;
280 helper.slotId = DEFAULT_SIM_SLOT_ID;
281 if (!helper.Run(OpenCellBroadcastTestFuc6WithToken, std::ref(helper))) {
282 TELEPHONY_LOGI("OpenCellBroadcastTestFuc6WithToken out of time");
283 ASSERT_TRUE(helper.Run(OpenCellBroadcastTestFuc6WithToken, std::ref(helper)));
284 }
285 TELEPHONY_LOGI("TelSMSMMSTest::OpenCellBroadcast_0006 -->finished");
286 ASSERT_GE(helper.GetIntResult(), 0);
287 }
288
289 /**
290 * @tc.number Telephony_SmsMmsGtest_OpenCellBroadcast_0007
291 * @tc.name Open cellBroadcast fromMsgId less than toMsgId
292 * @tc.desc Function test
293 */
HWTEST_F(CbGtest, OpenCellBroadcast_0007, Function | MediumTest | Level3)294 HWTEST_F(CbGtest, OpenCellBroadcast_0007, Function | MediumTest | Level3)
295 {
296 TELEPHONY_LOGI("TelSMSMMSTest::OpenCellBroadcast_0007 -->");
297 if (!(CbGtest::HasSimCard(DEFAULT_SIM_SLOT_ID_1))) {
298 TELEPHONY_LOGI("TelephonyTestService has no sim card");
299 ASSERT_FALSE(CbGtest::HasSimCard(DEFAULT_SIM_SLOT_ID_1));
300 return;
301 }
302 SmsMmsTestHelper helper;
303 helper.slotId = DEFAULT_SIM_SLOT_ID_1;
304 if (!helper.Run(OpenCellBroadcastTestFuc2, std::ref(helper))) {
305 TELEPHONY_LOGI("OpenCellBroadcastTestFuc2 out of time");
306 ASSERT_TRUE(helper.Run(OpenCellBroadcastTestFuc2, std::ref(helper)));
307 }
308 TELEPHONY_LOGI("TelSMSMMSTest::OpenCellBroadcast_0007 -->finished");
309 EXPECT_NE(helper.GetIntResult(), 0);
310 }
311
312 /**
313 * @tc.number Telephony_SmsMmsGtest_OpenCellBroadcast_0008
314 * @tc.name Open cellBroadcast netType is unknown.
315 * @tc.desc Function test
316 */
HWTEST_F(CbGtest, OpenCellBroadcast_0008, Function | MediumTest | Level3)317 HWTEST_F(CbGtest, OpenCellBroadcast_0008, Function | MediumTest | Level3)
318 {
319 TELEPHONY_LOGI("TelSMSMMSTest::OpenCellBroadcast_0008 -->");
320 if (!(CbGtest::HasSimCard(DEFAULT_SIM_SLOT_ID_1))) {
321 TELEPHONY_LOGI("TelephonyTestService has no sim card");
322 ASSERT_FALSE(CbGtest::HasSimCard(DEFAULT_SIM_SLOT_ID_1));
323 return;
324 }
325 SmsMmsTestHelper helper;
326 helper.slotId = DEFAULT_SIM_SLOT_ID_1;
327 if (!helper.Run(OpenCellBroadcastTestFuc3, std::ref(helper))) {
328 TELEPHONY_LOGI("OpenCellBroadcastTestFuc3 out of time");
329 ASSERT_TRUE(helper.Run(OpenCellBroadcastTestFuc3, std::ref(helper)));
330 }
331 TELEPHONY_LOGI("TelSMSMMSTest::OpenCellBroadcast_0008 -->finished");
332 EXPECT_NE(helper.GetIntResult(), 0);
333 }
334
335 /**
336 * @tc.number Telephony_SmsMmsGtest_OpenCellBroadcast_0009
337 * @tc.name Open cellBroadcast parameter is valid.
338 * @tc.desc Function test
339 */
HWTEST_F(CbGtest, OpenCellBroadcast_0009, Function | MediumTest | Level3)340 HWTEST_F(CbGtest, OpenCellBroadcast_0009, Function | MediumTest | Level3)
341 {
342 TELEPHONY_LOGI("TelSMSMMSTest::OpenCellBroadcast_0009 -->");
343 if (!(CbGtest::HasSimCard(DEFAULT_SIM_SLOT_ID_1))) {
344 TELEPHONY_LOGI("TelephonyTestService has no sim card");
345 ASSERT_FALSE(CbGtest::HasSimCard(DEFAULT_SIM_SLOT_ID_1));
346 return;
347 }
348 SmsMmsTestHelper helper;
349 helper.slotId = DEFAULT_SIM_SLOT_ID_1;
350 if (!helper.Run(OpenCellBroadcastTestFuc4, std::ref(helper))) {
351 TELEPHONY_LOGI("OpenCellBroadcastTestFuc4 out of time");
352 ASSERT_TRUE(helper.Run(OpenCellBroadcastTestFuc4, std::ref(helper)));
353 }
354 TELEPHONY_LOGI("TelSMSMMSTest::OpenCellBroadcast_0009 -->finished");
355 ASSERT_EQ(helper.GetIntResult(), 0);
356 }
357
358 /**
359 * @tc.number Telephony_SmsMmsGtest_OpenCellBroadcast_0010
360 * @tc.name Open cellBroadcast parameter is valid
361 * @tc.desc Function test
362 */
HWTEST_F(CbGtest, OpenCellBroadcast_00010, Function | MediumTest | Level3)363 HWTEST_F(CbGtest, OpenCellBroadcast_00010, Function | MediumTest | Level3)
364 {
365 TELEPHONY_LOGI("TelSMSMMSTest::OpenCellBroadcast_0010 -->");
366 if (!(CbGtest::HasSimCard(DEFAULT_SIM_SLOT_ID_1))) {
367 TELEPHONY_LOGI("TelephonyTestService has no sim card");
368 ASSERT_FALSE(CbGtest::HasSimCard(DEFAULT_SIM_SLOT_ID_1));
369 return;
370 }
371 SmsMmsTestHelper helper;
372 helper.slotId = DEFAULT_SIM_SLOT_ID_1;
373 if (!helper.Run(OpenCellBroadcastTestFuc5, std::ref(helper))) {
374 TELEPHONY_LOGI("OpenCellBroadcastTestFuc5 out of time");
375 ASSERT_TRUE(helper.Run(OpenCellBroadcastTestFuc5, std::ref(helper)));
376 }
377 TELEPHONY_LOGI("TelSMSMMSTest::OpenCellBroadcast_0010 -->finished");
378 ASSERT_EQ(helper.GetIntResult(), 0);
379 }
380
381 /**
382 * @tc.number Telephony_SmsMmsGtest_OpenCellBroadcast_0011
383 * @tc.name Open cellBroadcast parameter is valid
384 * @tc.desc Function test
385 */
HWTEST_F(CbGtest, OpenCellBroadcast_0011, Function | MediumTest | Level3)386 HWTEST_F(CbGtest, OpenCellBroadcast_0011, Function | MediumTest | Level3)
387 {
388 TELEPHONY_LOGI("TelSMSMMSTest::OpenCellBroadcast_0011 -->");
389 if (!(CbGtest::HasSimCard(DEFAULT_SIM_SLOT_ID_1))) {
390 TELEPHONY_LOGI("TelephonyTestService has no sim card");
391 ASSERT_FALSE(CbGtest::HasSimCard(DEFAULT_SIM_SLOT_ID_1));
392 return;
393 }
394 SmsMmsTestHelper helper;
395 helper.slotId = DEFAULT_SIM_SLOT_ID_1;
396 if (!helper.Run(OpenCellBroadcastTestFuc6WithToken, std::ref(helper))) {
397 TELEPHONY_LOGI("OpenCellBroadcastTestFuc6WithToken out of time");
398 ASSERT_TRUE(helper.Run(OpenCellBroadcastTestFuc6WithToken, std::ref(helper)));
399 }
400 TELEPHONY_LOGI("TelSMSMMSTest::OpenCellBroadcast_0011 -->finished");
401 ASSERT_EQ(helper.GetIntResult(), 0);
402 }
403
404 /**
405 * @tc.number Telephony_SmsMmsGtest_OpenCellBroadcast_0012
406 * @tc.name Open cellBroadcast parameter is valid
407 * @tc.desc Function test
408 */
HWTEST_F(CbGtest, OpenCellBroadcast_0012, Function | MediumTest | Level3)409 HWTEST_F(CbGtest, OpenCellBroadcast_0012, Function | MediumTest | Level3)
410 {
411 TELEPHONY_LOGI("TelSMSMMSTest::OpenCellBroadcast_0012 -->");
412 if (!(CbGtest::HasSimCard(DEFAULT_SIM_SLOT_ID))) {
413 TELEPHONY_LOGI("TelephonyTestService has no sim card");
414 ASSERT_FALSE(CbGtest::HasSimCard(DEFAULT_SIM_SLOT_ID));
415 return;
416 }
417 SmsMmsTestHelper helper;
418 helper.slotId = DEFAULT_SIM_SLOT_ID;
419 if (!helper.Run(OpenCellBroadcastTestFuc6, std::ref(helper))) {
420 TELEPHONY_LOGI("OpenCellBroadcastTestFuc6 out of time");
421 ASSERT_TRUE(helper.Run(OpenCellBroadcastTestFuc6, std::ref(helper)));
422 }
423 TELEPHONY_LOGI("TelSMSMMSTest::OpenCellBroadcast_0012 -->finished");
424 EXPECT_NE(helper.GetIntResult(), 0);
425 }
426
CloseCellBroadcastTestFuc(SmsMmsTestHelper &helper)427 void CloseCellBroadcastTestFuc(SmsMmsTestHelper &helper)
428 {
429 AccessMmsToken token;
430 bool enable = false;
431 uint32_t fromMsgId = 0;
432 uint32_t toMsgId = 10;
433 uint8_t netType = 1;
434 int32_t result = Singleton<SmsServiceManagerClient>::GetInstance().SetCBConfig(
435 helper.slotId, enable, fromMsgId, toMsgId, netType);
436 helper.SetIntResult(result);
437 helper.NotifyAll();
438 }
439
440 /**
441 * @tc.number Telephony_SmsMmsGtest_CloseCellBroadcast_0001
442 * @tc.name Close cellBroadcast slotId is -1
443 * @tc.desc Function test
444 */
HWTEST_F(CbGtest, CloseCellBroadcast_0001, Function | MediumTest | Level3)445 HWTEST_F(CbGtest, CloseCellBroadcast_0001, Function | MediumTest | Level3)
446 {
447 TELEPHONY_LOGI("TelSMSMMSTest::CloseCellBroadcast_0001 -->");
448 if (!(CbGtest::HasSimCard(DEFAULT_SIM_SLOT_ID))) {
449 TELEPHONY_LOGI("TelephonyTestService has no sim card");
450 ASSERT_FALSE(CbGtest::HasSimCard(DEFAULT_SIM_SLOT_ID));
451 return;
452 }
453 SmsMmsTestHelper helper;
454 helper.slotId = DEFAULT_SIM_SLOT_ID_REMOVE;
455 if (!helper.Run(CloseCellBroadcastTestFuc, std::ref(helper))) {
456 TELEPHONY_LOGI("CloseCellBroadcastTestFuc out of time");
457 ASSERT_TRUE(helper.Run(CloseCellBroadcastTestFuc, std::ref(helper)));
458 }
459 TELEPHONY_LOGI("TelSMSMMSTest::CloseCellBroadcast_0001 -->finished");
460 EXPECT_NE(helper.GetIntResult(), 0);
461 }
462
CloseCellBroadcastTestFuc2(SmsMmsTestHelper &helper)463 void CloseCellBroadcastTestFuc2(SmsMmsTestHelper &helper)
464 {
465 AccessMmsToken token;
466 bool enable = false;
467 uint32_t fromMsgId = 20;
468 uint32_t toMsgId = 10;
469 uint8_t netType = 1;
470 int32_t result = Singleton<SmsServiceManagerClient>::GetInstance().SetCBConfig(
471 helper.slotId, enable, fromMsgId, toMsgId, netType);
472 helper.SetIntResult(result);
473 helper.NotifyAll();
474 }
475
476 /**
477 * @tc.number Telephony_SmsMmsGtest_CloseCellBroadcast_0002
478 * @tc.name Close cellBroadcast fromMsgId less than toMsgId
479 * @tc.desc Function test
480 */
HWTEST_F(CbGtest, CloseCellBroadcast_0002, Function | MediumTest | Level3)481 HWTEST_F(CbGtest, CloseCellBroadcast_0002, Function | MediumTest | Level3)
482 {
483 TELEPHONY_LOGI("TelSMSMMSTest::CloseCellBroadcast_0002 -->");
484 if (!(CbGtest::HasSimCard(DEFAULT_SIM_SLOT_ID))) {
485 TELEPHONY_LOGI("TelephonyTestService has no sim card");
486 ASSERT_FALSE(CbGtest::HasSimCard(DEFAULT_SIM_SLOT_ID));
487 return;
488 }
489 SmsMmsTestHelper helper;
490 helper.slotId = DEFAULT_SIM_SLOT_ID;
491 if (!helper.Run(CloseCellBroadcastTestFuc2, std::ref(helper))) {
492 TELEPHONY_LOGI("CloseCellBroadcastTestFuc2 out of time");
493 ASSERT_TRUE(helper.Run(CloseCellBroadcastTestFuc2, std::ref(helper)));
494 }
495 TELEPHONY_LOGI("TelSMSMMSTest::CloseCellBroadcast_0002 -->finished");
496 EXPECT_NE(helper.GetIntResult(), 0);
497 }
498
CloseCellBroadcastTestFuc3(SmsMmsTestHelper &helper)499 void CloseCellBroadcastTestFuc3(SmsMmsTestHelper &helper)
500 {
501 AccessMmsToken token;
502 bool enable = false;
503 uint32_t fromMsgId = 0;
504 uint32_t toMsgId = 10;
505 uint8_t netType = 3;
506 int32_t result = Singleton<SmsServiceManagerClient>::GetInstance().SetCBConfig(
507 helper.slotId, enable, fromMsgId, toMsgId, netType);
508 helper.SetIntResult(result);
509 helper.NotifyAll();
510 }
511
512 /**
513 * @tc.number Telephony_SmsMmsGtest_CloseCellBroadcast_0003
514 * @tc.name Close cellBroadcast netType is unknown
515 * @tc.desc Function test
516 */
HWTEST_F(CbGtest, CloseCellBroadcast_0003, Function | MediumTest | Level3)517 HWTEST_F(CbGtest, CloseCellBroadcast_0003, Function | MediumTest | Level3)
518 {
519 TELEPHONY_LOGI("TelSMSMMSTest::CloseCellBroadcast_0003 -->");
520 if (!(CbGtest::HasSimCard(DEFAULT_SIM_SLOT_ID))) {
521 TELEPHONY_LOGI("TelephonyTestService has no sim card");
522 ASSERT_FALSE(CbGtest::HasSimCard(DEFAULT_SIM_SLOT_ID));
523 return;
524 }
525 SmsMmsTestHelper helper;
526 helper.slotId = DEFAULT_SIM_SLOT_ID;
527 if (!helper.Run(CloseCellBroadcastTestFuc3, std::ref(helper))) {
528 TELEPHONY_LOGI("CloseCellBroadcastTestFuc3 out of time");
529 ASSERT_TRUE(helper.Run(CloseCellBroadcastTestFuc3, std::ref(helper)));
530 }
531 TELEPHONY_LOGI("TelSMSMMSTest::CloseCellBroadcast_0003-->finished");
532 EXPECT_NE(helper.GetIntResult(), 0);
533 }
534
CloseCellBroadcastTestFuc4(SmsMmsTestHelper &helper)535 void CloseCellBroadcastTestFuc4(SmsMmsTestHelper &helper)
536 {
537 AccessMmsToken token;
538 bool enable = false;
539 uint32_t fromMsgId = 0;
540 uint32_t toMsgId = 10;
541 uint8_t netType = 1;
542 int32_t result = Singleton<SmsServiceManagerClient>::GetInstance().SetCBConfig(
543 helper.slotId, enable, fromMsgId, toMsgId, netType);
544 helper.SetIntResult(result);
545 helper.NotifyAll();
546 }
547
548 /**
549 * @tc.number Telephony_SmsMmsGtest_CloseCellBroadcast_0004
550 * @tc.name Close cellBroadcast parameter is valid
551 * @tc.desc Function test
552 */
HWTEST_F(CbGtest, CloseCellBroadcast_0004, Function | MediumTest | Level3)553 HWTEST_F(CbGtest, CloseCellBroadcast_0004, Function | MediumTest | Level3)
554 {
555 TELEPHONY_LOGI("TelSMSMMSTest::CloseCellBroadcast_0004 -->");
556 if (!(CbGtest::HasSimCard(DEFAULT_SIM_SLOT_ID))) {
557 TELEPHONY_LOGI("TelephonyTestService has no sim card");
558 ASSERT_FALSE(CbGtest::HasSimCard(DEFAULT_SIM_SLOT_ID));
559 return;
560 }
561 SmsMmsTestHelper helper;
562 helper.slotId = DEFAULT_SIM_SLOT_ID;
563 if (!helper.Run(CloseCellBroadcastTestFuc4, std::ref(helper))) {
564 TELEPHONY_LOGI("CloseCellBroadcastTestFuc4 out of time");
565 ASSERT_TRUE(helper.Run(CloseCellBroadcastTestFuc4, std::ref(helper)));
566 }
567 TELEPHONY_LOGI("TelSMSMMSTest::CloseCellBroadcast_0004 -->finished");
568 ASSERT_GE(helper.GetIntResult(), 0);
569 }
570
CloseCellBroadcastTestFuc5(SmsMmsTestHelper &helper)571 void CloseCellBroadcastTestFuc5(SmsMmsTestHelper &helper)
572 {
573 AccessMmsToken token;
574 bool enable = false;
575 uint32_t fromMsgId = 0;
576 uint32_t toMsgId = 1000;
577 uint8_t netType = 1;
578 int32_t result = Singleton<SmsServiceManagerClient>::GetInstance().SetCBConfig(
579 helper.slotId, enable, fromMsgId, toMsgId, netType);
580 helper.SetIntResult(result);
581 helper.NotifyAll();
582 }
583
584 /**
585 * @tc.number Telephony_SmsMmsGtest_CloseCellBroadcast_0005
586 * @tc.name Close cellBroadcast parameter is valid
587 * @tc.desc Function test
588 */
HWTEST_F(CbGtest, CloseCellBroadcast_0005, Function | MediumTest | Level3)589 HWTEST_F(CbGtest, CloseCellBroadcast_0005, Function | MediumTest | Level3)
590 {
591 TELEPHONY_LOGI("TelSMSMMSTest::CloseCellBroadcast_0005 -->");
592 if (!(CbGtest::HasSimCard(DEFAULT_SIM_SLOT_ID))) {
593 TELEPHONY_LOGI("TelephonyTestService has no sim card");
594 ASSERT_FALSE(CbGtest::HasSimCard(DEFAULT_SIM_SLOT_ID));
595 return;
596 }
597 SmsMmsTestHelper helper;
598 helper.slotId = DEFAULT_SIM_SLOT_ID;
599 if (!helper.Run(CloseCellBroadcastTestFuc5, std::ref(helper))) {
600 TELEPHONY_LOGI("CloseCellBroadcastTestFuc5 out of time");
601 ASSERT_TRUE(helper.Run(CloseCellBroadcastTestFuc5, std::ref(helper)));
602 }
603 TELEPHONY_LOGI("TelSMSMMSTest::CloseCellBroadcast_0005 -->finished");
604 ASSERT_GE(helper.GetIntResult(), 0);
605 }
606
CloseCellBroadcastTestFuc6(SmsMmsTestHelper &helper)607 void CloseCellBroadcastTestFuc6(SmsMmsTestHelper &helper)
608 {
609 bool enable = false;
610 uint32_t fromMsgId = 0;
611 uint32_t toMsgId = 0;
612 uint8_t netType = 1;
613 int32_t result = Singleton<SmsServiceManagerClient>::GetInstance().SetCBConfig(
614 helper.slotId, enable, fromMsgId, toMsgId, netType);
615 helper.SetIntResult(result);
616 helper.NotifyAll();
617 }
618
CloseCellBroadcastTestFuc6WithToken(SmsMmsTestHelper &helper)619 void CloseCellBroadcastTestFuc6WithToken(SmsMmsTestHelper &helper)
620 {
621 AccessMmsToken token;
622 CloseCellBroadcastTestFuc6(helper);
623 }
624
625 /**
626 * @tc.number Telephony_SmsMmsGtest_CloseCellBroadcast_0006
627 * @tc.name Close cellBroadcast parameter is valid
628 * @tc.desc Function test
629 */
HWTEST_F(CbGtest, CloseCellBroadcast_0006, Function | MediumTest | Level3)630 HWTEST_F(CbGtest, CloseCellBroadcast_0006, Function | MediumTest | Level3)
631 {
632 TELEPHONY_LOGI("TelSMSMMSTest::CloseCellBroadcast_0006 -->");
633 if (!(CbGtest::HasSimCard(DEFAULT_SIM_SLOT_ID))) {
634 TELEPHONY_LOGI("TelephonyTestService has no sim card");
635 ASSERT_FALSE(CbGtest::HasSimCard(DEFAULT_SIM_SLOT_ID));
636 return;
637 }
638 SmsMmsTestHelper helper;
639 helper.slotId = DEFAULT_SIM_SLOT_ID;
640 if (!helper.Run(CloseCellBroadcastTestFuc6WithToken, std::ref(helper))) {
641 TELEPHONY_LOGI("CloseCellBroadcastTestFuc6WithToken out of time");
642 ASSERT_TRUE(helper.Run(CloseCellBroadcastTestFuc6WithToken, std::ref(helper)));
643 }
644 TELEPHONY_LOGI("TelSMSMMSTest::CloseCellBroadcast_0006 -->finished");
645 ASSERT_GE(helper.GetIntResult(), 0);
646 }
647
648 /**
649 * @tc.number Telephony_SmsMmsGtest_CloseCellBroadcast_0007
650 * @tc.name Close cellBroadcast fromMsgId less than toMsgId
651 * @tc.desc Function test
652 */
HWTEST_F(CbGtest, CloseCellBroadcast_0007, Function | MediumTest | Level3)653 HWTEST_F(CbGtest, CloseCellBroadcast_0007, Function | MediumTest | Level3)
654 {
655 TELEPHONY_LOGI("TelSMSMMSTest::CloseCellBroadcast_0007 -->");
656 if (!(CbGtest::HasSimCard(DEFAULT_SIM_SLOT_ID_1))) {
657 TELEPHONY_LOGI("TelephonyTestService has no sim card");
658 ASSERT_FALSE(CbGtest::HasSimCard(DEFAULT_SIM_SLOT_ID_1));
659 return;
660 }
661 SmsMmsTestHelper helper;
662 helper.slotId = DEFAULT_SIM_SLOT_ID_1;
663 if (!helper.Run(CloseCellBroadcastTestFuc2, std::ref(helper))) {
664 TELEPHONY_LOGI("CloseCellBroadcastTestFuc7 out of time");
665 ASSERT_TRUE(helper.Run(CloseCellBroadcastTestFuc2, std::ref(helper)));
666 }
667 TELEPHONY_LOGI("TelSMSMMSTest::CloseCellBroadcast_0007 -->finished");
668 EXPECT_NE(helper.GetIntResult(), 0);
669 }
670
671 /**
672 * @tc.number Telephony_SmsMmsGtest_CloseCellBroadcast_0008
673 * @tc.name Close cellBroadcast netType is unknown
674 * @tc.desc Function test
675 */
HWTEST_F(CbGtest, CloseCellBroadcast_0008, Function | MediumTest | Level3)676 HWTEST_F(CbGtest, CloseCellBroadcast_0008, Function | MediumTest | Level3)
677 {
678 TELEPHONY_LOGI("TelSMSMMSTest::CloseCellBroadcast_0008 -->");
679 if (!(CbGtest::HasSimCard(DEFAULT_SIM_SLOT_ID_1))) {
680 TELEPHONY_LOGI("TelephonyTestService has no sim card");
681 ASSERT_FALSE(CbGtest::HasSimCard(DEFAULT_SIM_SLOT_ID_1));
682 return;
683 }
684 SmsMmsTestHelper helper;
685 helper.slotId = DEFAULT_SIM_SLOT_ID_1;
686 if (!helper.Run(CloseCellBroadcastTestFuc3, std::ref(helper))) {
687 TELEPHONY_LOGI("CloseCellBroadcastTestFuc8 out of time");
688 ASSERT_TRUE(helper.Run(CloseCellBroadcastTestFuc3, std::ref(helper)));
689 }
690 TELEPHONY_LOGI("TelSMSMMSTest::CloseCellBroadcast_0008-->finished");
691 EXPECT_NE(helper.GetIntResult(), 0);
692 }
693
694 /**
695 * @tc.number Telephony_SmsMmsGtest_CloseCellBroadcast_0009
696 * @tc.name Close cellBroadcast parameter is valid
697 * @tc.desc Function test
698 */
HWTEST_F(CbGtest, CloseCellBroadcast_0009, Function | MediumTest | Level3)699 HWTEST_F(CbGtest, CloseCellBroadcast_0009, Function | MediumTest | Level3)
700 {
701 TELEPHONY_LOGI("TelSMSMMSTest::CloseCellBroadcast_0009 -->");
702 if (!(CbGtest::HasSimCard(DEFAULT_SIM_SLOT_ID_1))) {
703 TELEPHONY_LOGI("TelephonyTestService has no sim card");
704 ASSERT_FALSE(CbGtest::HasSimCard(DEFAULT_SIM_SLOT_ID_1));
705 return;
706 }
707 SmsMmsTestHelper helper;
708 helper.slotId = DEFAULT_SIM_SLOT_ID_1;
709 if (!helper.Run(CloseCellBroadcastTestFuc4, std::ref(helper))) {
710 TELEPHONY_LOGI("CloseCellBroadcastTestFuc9 out of time");
711 ASSERT_TRUE(helper.Run(CloseCellBroadcastTestFuc4, std::ref(helper)));
712 }
713 TELEPHONY_LOGI("TelSMSMMSTest::CloseCellBroadcast_0009 -->finished");
714 ASSERT_GE(helper.GetIntResult(), 0);
715 }
716
717 /**
718 * @tc.number Telephony_SmsMmsGtest_CloseCellBroadcast_0010
719 * @tc.name Close cellBroadcast parameter is valid
720 * @tc.desc Function test
721 */
HWTEST_F(CbGtest, CloseCellBroadcast_0010, Function | MediumTest | Level3)722 HWTEST_F(CbGtest, CloseCellBroadcast_0010, Function | MediumTest | Level3)
723 {
724 TELEPHONY_LOGI("TelSMSMMSTest::CloseCellBroadcast_0010 -->");
725 if (!(CbGtest::HasSimCard(DEFAULT_SIM_SLOT_ID_1))) {
726 TELEPHONY_LOGI("TelephonyTestService has no sim card");
727 ASSERT_FALSE(CbGtest::HasSimCard(DEFAULT_SIM_SLOT_ID_1));
728 return;
729 }
730 SmsMmsTestHelper helper;
731 helper.slotId = DEFAULT_SIM_SLOT_ID_1;
732 if (!helper.Run(CloseCellBroadcastTestFuc5, std::ref(helper))) {
733 TELEPHONY_LOGI("CloseCellBroadcastTestFuc10 out of time");
734 ASSERT_TRUE(helper.Run(CloseCellBroadcastTestFuc5, std::ref(helper)));
735 }
736 TELEPHONY_LOGI("TelSMSMMSTest::CloseCellBroadcast_0010 -->finished");
737 ASSERT_GE(helper.GetIntResult(), 0);
738 }
739
740 /**
741 * @tc.number Telephony_SmsMmsGtest_CloseCellBroadcast_0011
742 * @tc.name Close cellBroadcast parameter is valid
743 * @tc.desc Function test
744 */
HWTEST_F(CbGtest, CloseCellBroadcast_00011, Function | MediumTest | Level3)745 HWTEST_F(CbGtest, CloseCellBroadcast_00011, Function | MediumTest | Level3)
746 {
747 TELEPHONY_LOGI("TelSMSMMSTest::CloseCellBroadcast_0011 -->");
748 if (!(CbGtest::HasSimCard(DEFAULT_SIM_SLOT_ID_1))) {
749 TELEPHONY_LOGI("TelephonyTestService has no sim card");
750 ASSERT_FALSE(CbGtest::HasSimCard(DEFAULT_SIM_SLOT_ID_1));
751 return;
752 }
753 SmsMmsTestHelper helper;
754 helper.slotId = DEFAULT_SIM_SLOT_ID_1;
755 if (!helper.Run(CloseCellBroadcastTestFuc6WithToken, std::ref(helper))) {
756 TELEPHONY_LOGI("CloseCellBroadcastTestFuc6WithToken out of time");
757 ASSERT_TRUE(helper.Run(CloseCellBroadcastTestFuc6WithToken, std::ref(helper)));
758 }
759 TELEPHONY_LOGI("TelSMSMMSTest::CloseCellBroadcast_0011 -->finished");
760 ASSERT_GE(helper.GetIntResult(), 0);
761 }
762
763 /**
764 * @tc.number Telephony_SmsMmsGtest_CloseCellBroadcast_0012
765 * @tc.name Close cellBroadcast parameter is valid
766 * @tc.desc Function test
767 */
HWTEST_F(CbGtest, CloseCellBroadcast_0012, Function | MediumTest | Level3)768 HWTEST_F(CbGtest, CloseCellBroadcast_0012, Function | MediumTest | Level3)
769 {
770 TELEPHONY_LOGI("TelSMSMMSTest::CloseCellBroadcast_0012 -->");
771 if (!(CbGtest::HasSimCard(DEFAULT_SIM_SLOT_ID))) {
772 TELEPHONY_LOGI("TelephonyTestService has no sim card");
773 ASSERT_FALSE(CbGtest::HasSimCard(DEFAULT_SIM_SLOT_ID_1));
774 return;
775 }
776 SmsMmsTestHelper helper;
777 helper.slotId = DEFAULT_SIM_SLOT_ID;
778 if (!helper.Run(CloseCellBroadcastTestFuc6, std::ref(helper))) {
779 TELEPHONY_LOGI("CloseCellBroadcastTestFuc6 out of time");
780 ASSERT_TRUE(helper.Run(CloseCellBroadcastTestFuc6, std::ref(helper)));
781 }
782 TELEPHONY_LOGI("TelSMSMMSTest::CloseCellBroadcast_0012 -->finished");
783 EXPECT_NE(helper.GetIntResult(), 0);
784 }
785
ReceiveCellBroadCastTestFunc(SmsMmsTestHelper &helper)786 void ReceiveCellBroadCastTestFunc(SmsMmsTestHelper &helper)
787 {
788 AccessMmsToken token;
789 auto gsmSmsCbHandler = std::make_shared<GsmSmsCbHandler>(helper.slotId);
790 auto message = std::make_shared<CBConfigReportInfo>();
791 message->indicationType = MESSAGE_TYPE;
792 message->sn = 0;
793 message->mid = 0;
794 message->page = 0;
795 message->pages = 0;
796 message->dcs = "";
797 message->data = "";
798 message->length = CB_PDU_LEN;
799 message->pdu = "01a41f51101102ea3030a830ea30a230e130fc30eb914d4fe130c630b930c8000d000a3053308c306f8a669a137528306e3"
800 "0e130c330bb30fc30b8306730593002000d000aff080032003000310033002f00310031002f003252ea3000370020003100"
801 "35003a00340034ff09000d000aff0830a830ea30a25e02ff090000000000000000000000000000000000000000000000000"
802 "0000000000000000000000000000000000000000000000022";
803 AppExecFwk::InnerEvent::Pointer event = AppExecFwk::InnerEvent::Get(RadioEvent::RADIO_CELL_BROADCAST, message);
804 gsmSmsCbHandler->ProcessEvent(event);
805 }
806
ReceiveCellBroadCastTestFunc2(SmsMmsTestHelper &helper)807 void ReceiveCellBroadCastTestFunc2(SmsMmsTestHelper &helper)
808 {
809 AccessMmsToken token;
810 auto gsmSmsCbHandler = std::make_shared<GsmSmsCbHandler>(helper.slotId);
811 auto message = std::make_shared<CBConfigReportInfo>();
812 message->indicationType = MESSAGE_TYPE;
813 message->sn = 0;
814 message->mid = 0;
815 message->page = 0;
816 message->pages = 0;
817 message->dcs = "";
818 message->data = "";
819 message->length = CB_PDU_LEN;
820 message->pdu = "C0000032401174747A0E4ACF41E8B0BCFD76E741EF39685C66B34162F93B4C1E87E77410BD3CA7836EC2341D440ED3C321";
821 AppExecFwk::InnerEvent::Pointer event = AppExecFwk::InnerEvent::Get(RadioEvent::RADIO_CELL_BROADCAST, message);
822 gsmSmsCbHandler->ProcessEvent(event);
823 }
824
825 /**
826 * @tc.number Telephony_SmsMmsGtest_Receive_Cell_BroadCast_0001
827 * @tc.name Receive a 3g Cell Broadcast
828 * @tc.desc Function test
829 */
HWTEST_F(CbGtest, Receive_Cell_BroadCast_0001, Function | MediumTest | Level2)830 HWTEST_F(CbGtest, Receive_Cell_BroadCast_0001, Function | MediumTest | Level2)
831 {
832 TELEPHONY_LOGI("TelSMSMMSTest::Receive_Cell_BroadCast_0001 -->");
833 int32_t slotId = DEFAULT_SIM_SLOT_ID;
834 if (!(CbGtest::HasSimCard(slotId))) {
835 TELEPHONY_LOGI("TelephonyTestService has no sim card");
836 ASSERT_FALSE(CbGtest::HasSimCard(slotId));
837 return;
838 }
839 SmsMmsTestHelper helper;
840 helper.slotId = slotId;
841
842 EventFwk::MatchingSkills matchingSkills;
843 matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_SMS_EMERGENCY_CB_RECEIVE_COMPLETED);
844 matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_SMS_CB_RECEIVE_COMPLETED);
845 EventFwk::CommonEventSubscribeInfo subscriberInfo(matchingSkills);
846 std::shared_ptr<SmsBroadcastSubscriberGtest> subscriberTest =
847 std::make_shared<SmsBroadcastSubscriberGtest>(subscriberInfo, helper);
848 ASSERT_NE(subscriberTest, nullptr);
849 bool subscribeResult = EventFwk::CommonEventManager::SubscribeCommonEvent(subscriberTest);
850 TELEPHONY_LOGI("subscribeResult is : %{public}d", subscribeResult);
851
852 if (!helper.Run(ReceiveCellBroadCastTestFunc, helper)) {
853 TELEPHONY_LOGI("ReceiveCellBroadCastTestFunc out of time");
854 ASSERT_TRUE(helper.Run(ReceiveCellBroadCastTestFunc, helper));
855 return;
856 }
857 TELEPHONY_LOGI("TelSMSMMSTest::Receive_Cell_BroadCast_0001 -->finished");
858 EXPECT_TRUE(helper.GetBoolResult());
859 }
860
861 /**
862 * @tc.number Telephony_SmsMmsGtest_Receive_Cell_BroadCast_0002
863 * @tc.name Receive a 2g Cell Broadcast
864 * @tc.desc Function test
865 */
HWTEST_F(CbGtest, Receive_Cell_BroadCast_0002, Function | MediumTest | Level2)866 HWTEST_F(CbGtest, Receive_Cell_BroadCast_0002, Function | MediumTest | Level2)
867 {
868 TELEPHONY_LOGI("TelSMSMMSTest::Receive_Cell_BroadCast_0002 -->");
869 int32_t slotId = DEFAULT_SIM_SLOT_ID;
870 if (!(CbGtest::HasSimCard(slotId))) {
871 TELEPHONY_LOGI("TelephonyTestService has no sim card");
872 ASSERT_FALSE(CbGtest::HasSimCard(slotId));
873 return;
874 }
875 SmsMmsTestHelper helper;
876 helper.slotId = slotId;
877
878 EventFwk::MatchingSkills matchingSkills;
879 matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_SMS_EMERGENCY_CB_RECEIVE_COMPLETED);
880 matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_SMS_CB_RECEIVE_COMPLETED);
881 EventFwk::CommonEventSubscribeInfo subscriberInfo(matchingSkills);
882 std::shared_ptr<SmsBroadcastSubscriberGtest> subscriberTest =
883 std::make_shared<SmsBroadcastSubscriberGtest>(subscriberInfo, helper);
884 ASSERT_NE(subscriberTest, nullptr);
885 bool subscribeResult = EventFwk::CommonEventManager::SubscribeCommonEvent(subscriberTest);
886 TELEPHONY_LOGI("subscribeResult is : %{public}d", subscribeResult);
887
888 if (!helper.Run(ReceiveCellBroadCastTestFunc2, helper)) {
889 TELEPHONY_LOGI("ReceiveCellBroadCastTestFunc2 out of time");
890 ASSERT_TRUE(helper.Run(ReceiveCellBroadCastTestFunc2, helper));
891 return;
892 }
893 TELEPHONY_LOGI("TelSMSMMSTest::Receive_Cell_BroadCast_0002 -->finished");
894 EXPECT_TRUE(helper.GetBoolResult());
895 }
896
897 /**
898 * @tc.number Telephony_SmsMmsGtest_Receive_Cell_BroadCast_0003
899 * @tc.name Receive a 3g Cell Broadcast
900 * @tc.desc Function test
901 */
HWTEST_F(CbGtest, Receive_Cell_BroadCast_0003, Function | MediumTest | Level2)902 HWTEST_F(CbGtest, Receive_Cell_BroadCast_0003, Function | MediumTest | Level2)
903 {
904 TELEPHONY_LOGI("TelSMSMMSTest::Receive_Cell_BroadCast_0003 -->");
905 int32_t slotId = DEFAULT_SIM_SLOT_ID_1;
906 if (!(CbGtest::HasSimCard(slotId))) {
907 TELEPHONY_LOGI("TelephonyTestService has no sim card");
908 ASSERT_FALSE(CbGtest::HasSimCard(slotId));
909 return;
910 }
911 SmsMmsTestHelper helper;
912 helper.slotId = slotId;
913
914 EventFwk::MatchingSkills matchingSkills;
915 matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_SMS_EMERGENCY_CB_RECEIVE_COMPLETED);
916 matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_SMS_CB_RECEIVE_COMPLETED);
917 EventFwk::CommonEventSubscribeInfo subscriberInfo(matchingSkills);
918 std::shared_ptr<SmsBroadcastSubscriberGtest> subscriberTest =
919 std::make_shared<SmsBroadcastSubscriberGtest>(subscriberInfo, helper);
920 ASSERT_NE(subscriberTest, nullptr);
921 bool subscribeResult = EventFwk::CommonEventManager::SubscribeCommonEvent(subscriberTest);
922 TELEPHONY_LOGI("subscribeResult is : %{public}d", subscribeResult);
923
924 if (!helper.Run(ReceiveCellBroadCastTestFunc, helper)) {
925 TELEPHONY_LOGI("ReceiveCellBroadCastTestFunc out of time");
926 ASSERT_TRUE(helper.Run(ReceiveCellBroadCastTestFunc, helper));
927 return;
928 }
929 TELEPHONY_LOGI("TelSMSMMSTest::Receive_Cell_BroadCast_0003 -->finished");
930 EXPECT_TRUE(helper.GetBoolResult());
931 }
932
933 /**
934 * @tc.number Telephony_SmsMmsGtest_Receive_Cell_BroadCast_0004
935 * @tc.name Receive a 2g Cell Broadcast
936 * @tc.desc Function test
937 */
HWTEST_F(CbGtest, Receive_Cell_BroadCast_0004, Function | MediumTest | Level2)938 HWTEST_F(CbGtest, Receive_Cell_BroadCast_0004, Function | MediumTest | Level2)
939 {
940 TELEPHONY_LOGI("TelSMSMMSTest::Receive_Cell_BroadCast_0004 -->");
941 int32_t slotId = DEFAULT_SIM_SLOT_ID_1;
942 if (!(CbGtest::HasSimCard(slotId))) {
943 TELEPHONY_LOGI("TelephonyTestService has no sim card");
944 ASSERT_FALSE(CbGtest::HasSimCard(slotId));
945 return;
946 }
947 SmsMmsTestHelper helper;
948 helper.slotId = slotId;
949
950 EventFwk::MatchingSkills matchingSkills;
951 matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_SMS_EMERGENCY_CB_RECEIVE_COMPLETED);
952 matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_SMS_CB_RECEIVE_COMPLETED);
953 EventFwk::CommonEventSubscribeInfo subscriberInfo(matchingSkills);
954 std::shared_ptr<SmsBroadcastSubscriberGtest> subscriberTest =
955 std::make_shared<SmsBroadcastSubscriberGtest>(subscriberInfo, helper);
956 ASSERT_NE(subscriberTest, nullptr);
957 bool subscribeResult = EventFwk::CommonEventManager::SubscribeCommonEvent(subscriberTest);
958 TELEPHONY_LOGI("subscribeResult is : %{public}d", subscribeResult);
959
960 if (!helper.Run(ReceiveCellBroadCastTestFunc2, helper)) {
961 TELEPHONY_LOGI("ReceiveCellBroadCastTestFunc2 out of time");
962 ASSERT_TRUE(helper.Run(ReceiveCellBroadCastTestFunc2, helper));
963 return;
964 }
965 TELEPHONY_LOGI("TelSMSMMSTest::Receive_Cell_BroadCast_0004 -->finished");
966 EXPECT_TRUE(helper.GetBoolResult());
967 }
968 #endif // TEL_TEST_UNSUPPORT
969 } // namespace Telephony
970 } // namespace OHOS