1 /*
2 * Copyright (C) 2023 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include "cdma_sms_message.h"
17 #include "cdma_sms_receive_handler.h"
18 #include "cdma_sms_transport_message.h"
19 #include "core_service_client.h"
20 #include "delivery_short_message_callback_stub.h"
21 #include "gtest/gtest.h"
22 #include "i_sms_service_interface.h"
23 #include "if_system_ability_manager.h"
24 #include "iservice_registry.h"
25 #include "radio_event.h"
26 #include "send_short_message_callback_stub.h"
27 #include "sms_broadcast_subscriber_gtest.h"
28 #include "sms_delivery_callback_gtest.h"
29 #include "sms_mms_gtest.h"
30 #include "sms_mms_test_helper.h"
31 #include "sms_send_callback_gtest.h"
32 #include "sms_service.h"
33 #include "sms_service_manager_client.h"
34 #include "string_utils.h"
35 #include "telephony_errors.h"
36 #include "telephony_log_wrapper.h"
37 #include "telephony_types.h"
38
39 namespace OHOS {
40 namespace Telephony {
41 namespace {
42 sptr<ISmsServiceInterface> g_telephonyService = nullptr;
43 } // namespace
44 using namespace testing::ext;
45
46 class SmsGtest : public testing::Test {
47 public:
48 static void SetUpTestCase();
49 static void TearDownTestCase();
50 void SetUp();
51 void TearDown();
52 static sptr<ISmsServiceInterface> GetProxy();
HasSimCard(int32_t slotId)53 static bool HasSimCard(int32_t slotId)
54 {
55 bool hasSimCard = false;
56 if (CoreServiceClient::GetInstance().GetProxy() == nullptr) {
57 return hasSimCard;
58 }
59 CoreServiceClient::GetInstance().HasSimCard(slotId, hasSimCard);
60 return hasSimCard;
61 }
62 };
63
TearDownTestCase()64 void SmsGtest::TearDownTestCase() {}
65
SetUp()66 void SmsGtest::SetUp() {}
67
TearDown()68 void SmsGtest::TearDown() {}
69
70 const int32_t DEFAULT_SIM_SLOT_ID_1 = 1;
71 const std::string DES_ADDR = "10086";
72 const std::string TEXT_SMS_CONTENT = "hello world";
73 const uint8_t DATA_SMS[] = "hello world";
74 const uint16_t SMS_PORT = 100;
75 const uint16_t MESSAGE_TYPE = 4;
76 const uint16_t SMS_PDU_LEN = 36;
77 const int32_t WAIT_TIME_LONG_SECOND = 180;
78 const int32_t WAIT_TIME_SHORT_SECOND = 30;
79
SetUpTestCase()80 void SmsGtest::SetUpTestCase()
81 {
82 TELEPHONY_LOGI("SetUpTestCase slotId%{public}d", DEFAULT_SIM_SLOT_ID_1);
83 g_telephonyService = GetProxy();
84 if (g_telephonyService == nullptr) {
85 return;
86 }
87 DelayedSingleton<SmsServiceManagerClient>::GetInstance()->ResetSmsServiceProxy();
88 DelayedSingleton<SmsServiceManagerClient>::GetInstance()->InitSmsServiceProxy();
89 }
90
GetProxy()91 sptr<ISmsServiceInterface> SmsGtest::GetProxy()
92 {
93 auto systemAbilityMgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
94 if (systemAbilityMgr == nullptr) {
95 return nullptr;
96 }
97 sptr<IRemoteObject> remote = systemAbilityMgr->CheckSystemAbility(TELEPHONY_SMS_MMS_SYS_ABILITY_ID);
98 if (remote) {
99 sptr<ISmsServiceInterface> smsService = iface_cast<ISmsServiceInterface>(remote);
100 return smsService;
101 }
102 return nullptr;
103 }
104
105 #ifndef TEL_TEST_UNSUPPORT
106 /**
107 * @tc.number Telephony_SmsMmsGtest_GetProxy_0001
108 * @tc.name Get SmsMms service
109 * @tc.desc Function test
110 */
111 HWTEST_F(SmsGtest, GetProxy_0001, Function | MediumTest | Level0)
112 {
113 TELEPHONY_LOGI("TelSMSMMSTest::GetProxy_0001 -->");
114 g_telephonyService = SmsGtest::GetProxy();
115 TELEPHONY_LOGI("TelSMSMMSTest::GetProxy_0001 -->finished");
116 EXPECT_FALSE(g_telephonyService == nullptr);
117 }
118
SetDefaultSmsSlotIdTestFuc(SmsMmsTestHelper & helper)119 void SetDefaultSmsSlotIdTestFuc(SmsMmsTestHelper &helper)
120 {
121 int32_t result = DelayedSingleton<SmsServiceManagerClient>::GetInstance()->SetDefaultSmsSlotId(helper.slotId);
122 helper.SetIntResult(result);
123 helper.NotifyAll();
124 }
125
126 /**
127 * @tc.number Telephony_SmsMmsGtest_SetDefaultSmsSlotId_0001
128 * @tc.name Set Default Sms SlotId slotId is valid
129 * @tc.desc Function test
130 */
131 HWTEST_F(SmsGtest, SetDefaultSmsSlotId_0001, Function | MediumTest | Level2)
132 {
133 AccessMmsToken token;
134 TELEPHONY_LOGI("TelSMSMMSTest::SetDefaultSmsSlotId_0001 -->");
135 if (!(SmsGtest::HasSimCard(DEFAULT_SIM_SLOT_ID))) {
136 TELEPHONY_LOGI("TelephonyTestService has no sim card");
137 ASSERT_TRUE(true);
138 return;
139 }
140 SmsMmsTestHelper helper;
141 helper.slotId = DEFAULT_SIM_SLOT_ID;
142 if (!helper.Run(SetDefaultSmsSlotIdTestFuc, std::ref(helper))) {
143 TELEPHONY_LOGI("SetDefaultSmsSlotIdTestFuc out of time");
144 ASSERT_TRUE(false);
145 }
146 TELEPHONY_LOGI("TelSMSMMSTest::SetDefaultSmsSlotId_0001 -->finished");
147 ASSERT_EQ(helper.GetIntResult(), 0);
148 }
149
150 /**
151 * @tc.number Telephony_SmsMmsGtest_SetDefaultSmsSlotId_0002
152 * @tc.name Set Default Sms SlotId slotId is valid
153 * @tc.desc Function test
154 */
155 HWTEST_F(SmsGtest, SetDefaultSmsSlotId_0002, Function | MediumTest | Level2)
156 {
157 AccessMmsToken token;
158 TELEPHONY_LOGI("TelSMSMMSTest::SetDefaultSmsSlotId_0002 -->");
159 if (!(SmsGtest::HasSimCard(DEFAULT_SIM_SLOT_ID_1))) {
160 TELEPHONY_LOGI("TelephonyTestService has no sim card");
161 ASSERT_TRUE(true);
162 return;
163 }
164 SmsMmsTestHelper helper;
165 helper.slotId = DEFAULT_SIM_SLOT_ID_1;
166 if (!helper.Run(SetDefaultSmsSlotIdTestFuc, std::ref(helper))) {
167 TELEPHONY_LOGI("SetDefaultSmsSlotIdTestFuc2 out of time");
168 ASSERT_TRUE(false);
169 }
170 TELEPHONY_LOGI("TelSMSMMSTest::SetDefaultSmsSlotId_0002 -->finished");
171 EXPECT_EQ(helper.GetIntResult(), 0);
172 }
173
174 /**
175 * @tc.number Telephony_SmsMmsGtest_SetDefaultSmsSlotId_0003
176 * @tc.name Set Default Sms SlotId slotId is valid
177 * @tc.desc Function test
178 */
179 HWTEST_F(SmsGtest, SetDefaultSmsSlotId_0003, Function | MediumTest | Level2)
180 {
181 TELEPHONY_LOGI("TelSMSMMSTest::SetDefaultSmsSlotId_0003 -->");
182 if (!(SmsGtest::HasSimCard(DEFAULT_SIM_SLOT_ID))) {
183 TELEPHONY_LOGI("TelephonyTestService has no sim card");
184 ASSERT_TRUE(true);
185 return;
186 }
187 SmsMmsTestHelper helper;
188 helper.slotId = DEFAULT_SIM_SLOT_ID;
189 if (!helper.Run(SetDefaultSmsSlotIdTestFuc, std::ref(helper))) {
190 TELEPHONY_LOGI("SetDefaultSmsSlotIdTestFuc out of time");
191 ASSERT_TRUE(false);
192 }
193 TELEPHONY_LOGI("TelSMSMMSTest::SetDefaultSmsSlotId_0003 -->finished");
194 EXPECT_NE(helper.GetIntResult(), 0);
195 }
196
GetDefaultSmsSlotIdTestFuc(SmsMmsTestHelper & helper)197 void GetDefaultSmsSlotIdTestFuc(SmsMmsTestHelper &helper)
198 {
199 int32_t slotId = DelayedSingleton<SmsServiceManagerClient>::GetInstance()->GetDefaultSmsSlotId();
200 helper.SetIntResult(slotId);
201 helper.NotifyAll();
202 }
203
204 /**
205 * @tc.number Telephony_SmsMmsGtest_GetDefaultSmsSlotId_0001
206 * @tc.name Get Default Sms SlotId
207 * @tc.desc Function test
208 */
209 HWTEST_F(SmsGtest, GetDefaultSmsSlotId_0001, Function | MediumTest | Level2)
210 {
211 TELEPHONY_LOGI("TelSMSMMSTest::GetDefaultSmsSlotId_0001 -->");
212 if (!(SmsGtest::HasSimCard(DEFAULT_SIM_SLOT_ID))) {
213 TELEPHONY_LOGI("TelephonyTestService has no sim card");
214 ASSERT_TRUE(true);
215 return;
216 }
217 SmsMmsTestHelper helper;
218 if (!helper.Run(GetDefaultSmsSlotIdTestFuc, std::ref(helper))) {
219 TELEPHONY_LOGI("GetDefaultSmsSlotIdTestFuc out of time");
220 ASSERT_TRUE(false);
221 }
222 TELEPHONY_LOGI("TelSMSMMSTest::GetDefaultSmsSlotId_0001 -->finished");
223 ASSERT_EQ(helper.GetIntResult(), 0);
224 }
225
GetDefaultSmsSimIdTestFuc(SmsMmsTestHelper & helper)226 void GetDefaultSmsSimIdTestFuc(SmsMmsTestHelper &helper)
227 {
228 int32_t simId = DEFAULT_SIM_SLOT_ID_REMOVE;
229 DelayedSingleton<SmsServiceManagerClient>::GetInstance()->GetDefaultSmsSimId(simId);
230 helper.SetIntResult(simId);
231 helper.NotifyAll();
232 }
233
234 /**
235 * @tc.number GetDefaultSmsSimId_0001
236 * @tc.name Get Default Sms SimId
237 * @tc.desc Function test
238 */
239 HWTEST_F(SmsGtest, GetDefaultSmsSimId_0001, Function | MediumTest | Level2)
240 {
241 TELEPHONY_LOGI("TelSMSMMSTest::GetDefaultSmsSimId_0001 -->");
242 if (!(SmsGtest::HasSimCard(DEFAULT_SIM_SLOT_ID))) {
243 TELEPHONY_LOGI("TelephonyTestService has no sim card");
244 ASSERT_TRUE(true);
245 return;
246 }
247 SmsMmsTestHelper helper;
248 if (!helper.Run(GetDefaultSmsSimIdTestFuc, std::ref(helper))) {
249 TELEPHONY_LOGI("GetDefaultSmsSimIdTestFuc out of time");
250 ASSERT_TRUE(true);
251 }
252 TELEPHONY_LOGI("TelSMSMMSTest::GetDefaultSmsSimId_0001 -->finished");
253 ASSERT_GT(helper.GetIntResult(), 0);
254 }
255
256 /**
257 * @tc.number GetDefaultSmsSimId_0002
258 * @tc.name Get Default Sms SimId
259 * @tc.desc Function test
260 */
261 HWTEST_F(SmsGtest, GetDefaultSmsSimId_0002, Function | MediumTest | Level2)
262 {
263 TELEPHONY_LOGI("TelSMSMMSTest::GetDefaultSmsSimId_0002 -->");
264 if (!(SmsGtest::HasSimCard(DEFAULT_SIM_SLOT_ID))) {
265 TELEPHONY_LOGI("TelephonyTestService has no sim card");
266 ASSERT_TRUE(true);
267 return;
268 }
269 SmsMmsTestHelper helper;
270 if (!helper.Run(GetDefaultSmsSimIdTestFuc, std::ref(helper))) {
271 TELEPHONY_LOGI("GetDefaultSmsSimIdTestFuc out of time");
272 ASSERT_TRUE(true);
273 }
274 TELEPHONY_LOGI("TelSMSMMSTest::GetDefaultSmsSimId_0002 -->finished");
275 ASSERT_GT(helper.GetIntResult(), 0);
276 }
277
SetSmscAddrTestFuc(SmsMmsTestHelper & helper)278 void SetSmscAddrTestFuc(SmsMmsTestHelper &helper)
279 {
280 // invalid slotID scenario, a invalid smsc addr is OKAY
281 std::string scAddr("1234");
282 int32_t result = DelayedSingleton<SmsServiceManagerClient>::GetInstance()->SetScAddress(
283 helper.slotId, StringUtils::ToUtf16(scAddr));
284 helper.SetIntResult(result);
285 helper.NotifyAll();
286 }
287
288 /**
289 * @tc.number Telephony_SmsMmsGtest_SetSmscAddr_0001
290 * @tc.name Set smsc addr slotId is invalid
291 * @tc.desc Function test
292 * @tc.require: issueI5JI0H
293 */
294 HWTEST_F(SmsGtest, SetSmscAddr_0001, Function | MediumTest | Level2)
295 {
296 AccessMmsToken token;
297 TELEPHONY_LOGI("TelSMSMMSTest::SetSmscAddr_0001 -->");
298 if (!(SmsGtest::HasSimCard(DEFAULT_SIM_SLOT_ID))) {
299 TELEPHONY_LOGI("TelephonyTestService has no sim card");
300 ASSERT_TRUE(true);
301 return;
302 }
303 SmsMmsTestHelper helper;
304 helper.slotId = DEFAULT_SIM_SLOT_ID_REMOVE;
305 if (!helper.Run(SetSmscAddrTestFuc, std::ref(helper))) {
306 TELEPHONY_LOGI("SetSmscAddrTestFuc out of time");
307 ASSERT_TRUE(false);
308 }
309 TELEPHONY_LOGI("TelSMSMMSTest::SetSmscAddr_0001 -->finished");
310 EXPECT_NE(helper.GetIntResult(), 0);
311 }
312
313 /**
314 * @tc.number Telephony_SmsMmsGtest_SetSmscAddr_0002
315 * @tc.name Set smsc addr slotId is invalid
316 * @tc.desc Function test
317 * @tc.require: issueI5JI0H
318 */
319 HWTEST_F(SmsGtest, SetSmscAddr_0002, Function | MediumTest | Level2)
320 {
321 TELEPHONY_LOGI("TelSMSMMSTest::SetSmscAddr_0002 -->");
322 if (!(SmsGtest::HasSimCard(DEFAULT_SIM_SLOT_ID_1))) {
323 TELEPHONY_LOGI("TelephonyTestService has no sim card");
324 ASSERT_TRUE(true);
325 return;
326 }
327 SmsMmsTestHelper helper;
328 helper.slotId = DEFAULT_SIM_SLOT_ID_REMOVE;
329 if (!helper.Run(SetSmscAddrTestFuc, std::ref(helper))) {
330 TELEPHONY_LOGI("SetSmscAddrTestFuc out of time");
331 ASSERT_TRUE(false);
332 }
333 TELEPHONY_LOGI("TelSMSMMSTest::SetSmscAddr_0002 -->finished");
334 EXPECT_NE(helper.GetIntResult(), 0);
335 }
336
DelAllSimMessagesTestFuc(SmsMmsTestHelper & helper)337 void DelAllSimMessagesTestFuc(SmsMmsTestHelper &helper)
338 {
339 std::vector<ShortMessage> message;
340 DelayedSingleton<SmsServiceManagerClient>::GetInstance()->GetAllSimMessages(helper.slotId, message);
341 for (auto msg : message) {
342 TELEPHONY_LOGI("DelAllSimMessagesTestFuc,index:%{public}d", msg.GetIndexOnSim());
343 DelayedSingleton<SmsServiceManagerClient>::GetInstance()->DelSimMessage(helper.slotId, msg.GetIndexOnSim());
344 }
345 helper.SetBoolResult(message.size() >= 0);
346 helper.NotifyAll();
347 }
348
349 /**
350 * @tc.number Telephony_SmsMmsGtest_DelAllSimMessages_0001
351 * @tc.name Delete All Sim Messages
352 * @tc.desc Function test
353 */
354 HWTEST_F(SmsGtest, DelAllSimMessages_0001, Function | MediumTest | Level3)
355 {
356 AccessMmsToken token;
357 TELEPHONY_LOGI("TelSMSMMSTest::DelAllSimMessages_0001 -->");
358 if (!(SmsGtest::HasSimCard(DEFAULT_SIM_SLOT_ID))) {
359 TELEPHONY_LOGI("TelephonyTestService has no sim card");
360 ASSERT_TRUE(true);
361 return;
362 }
363 SmsMmsTestHelper helper;
364 helper.slotId = DEFAULT_SIM_SLOT_ID;
365 if (!helper.Run(DelAllSimMessagesTestFuc, std::ref(helper), WAIT_TIME_LONG_SECOND)) {
366 TELEPHONY_LOGI("DelAllSimMessagesTestFuc out of time");
367 ASSERT_TRUE(false);
368 }
369 TELEPHONY_LOGI("TelSMSMMSTest::DelAllSimMessages_0001 -->finished");
370 EXPECT_TRUE(helper.GetBoolResult());
371 }
372
373 /**
374 * @tc.number Telephony_SmsMmsGtest_DelAllSimMessages_0002
375 * @tc.name Delete All Sim Messages
376 * @tc.desc Function test
377 */
378 HWTEST_F(SmsGtest, DelAllSimMessages_0002, Function | MediumTest | Level3)
379 {
380 AccessMmsToken token;
381 TELEPHONY_LOGI("TelSMSMMSTest::DelAllSimMessages_0001 -->");
382 if (!(SmsGtest::HasSimCard(DEFAULT_SIM_SLOT_ID_1))) {
383 TELEPHONY_LOGI("TelephonyTestService has no sim card");
384 ASSERT_TRUE(true);
385 return;
386 }
387 SmsMmsTestHelper helper;
388 helper.slotId = DEFAULT_SIM_SLOT_ID_1;
389 if (!helper.Run(DelAllSimMessagesTestFuc, std::ref(helper), WAIT_TIME_LONG_SECOND)) {
390 TELEPHONY_LOGI("DelAllSimMessagesTestFuc out of time");
391 ASSERT_TRUE(false);
392 }
393 TELEPHONY_LOGI("TelSMSMMSTest::DelAllSimMessages_0002 -->finished");
394 EXPECT_TRUE(helper.GetBoolResult());
395 }
396
AddSimMessageTestFuc(SmsMmsTestHelper & helper)397 void AddSimMessageTestFuc(SmsMmsTestHelper &helper)
398 {
399 std::u16string smscData(u"");
400 std::u16string pduData(u"01000B818176251308F4000007E8B0BCFD76E701");
401 uint32_t status = 3;
402 int32_t result = DelayedSingleton<SmsServiceManagerClient>::GetInstance()->AddSimMessage(
403 helper.slotId, smscData, pduData, static_cast<ISmsServiceInterface::SimMessageStatus>(status));
404 helper.SetIntResult(result);
405 helper.NotifyAll();
406 }
407
408 /**
409 * @tc.number Telephony_SmsMmsGtest_AddSimMessage_0001
410 * @tc.name Add Sim Message
411 * @tc.desc Function test
412 */
413 HWTEST_F(SmsGtest, AddSimMessage_0001, Function | MediumTest | Level3)
414 {
415 AccessMmsToken token;
416 TELEPHONY_LOGI("TelSMSMMSTest::AddSimMessage_0001 -->");
417 if (!(SmsGtest::HasSimCard(DEFAULT_SIM_SLOT_ID))) {
418 TELEPHONY_LOGI("TelephonyTestService has no sim card");
419 ASSERT_TRUE(true);
420 return;
421 }
422 SmsMmsTestHelper helper;
423 helper.slotId = DEFAULT_SIM_SLOT_ID;
424
425 if (!helper.Run(AddSimMessageTestFuc, std::ref(helper))) {
426 TELEPHONY_LOGI("AddSimMessageTestFuc out of time");
427 ASSERT_TRUE(false);
428 }
429 TELEPHONY_LOGI("TelSMSMMSTest::AddSimMessage_0001 -->finished");
430 ASSERT_EQ(helper.GetIntResult(), 0);
431 }
432
433 /**
434 * @tc.number Telephony_SmsMmsGtest_AddSimMessage_0002
435 * @tc.name Add Sim Message
436 * @tc.desc Function test
437 */
438 HWTEST_F(SmsGtest, AddSimMessage_0002, Function | MediumTest | Level3)
439 {
440 AccessMmsToken token;
441 TELEPHONY_LOGI("TelSMSMMSTest::AddSimMessage_0002 -->");
442 if (!(SmsGtest::HasSimCard(DEFAULT_SIM_SLOT_ID_1))) {
443 TELEPHONY_LOGI("TelephonyTestService has no sim card");
444 ASSERT_TRUE(true);
445 return;
446 }
447 SmsMmsTestHelper helper;
448 helper.slotId = DEFAULT_SIM_SLOT_ID_1;
449
450 if (!helper.Run(AddSimMessageTestFuc, std::ref(helper))) {
451 TELEPHONY_LOGI("AddSimMessageTestFuc2 out of time");
452 ASSERT_TRUE(false);
453 }
454 TELEPHONY_LOGI("TelSMSMMSTest::AddSimMessage_0002 -->finished");
455 ASSERT_EQ(helper.GetIntResult(), 0);
456 }
457
458 /**
459 * @tc.number Telephony_SmsMmsGtest_AddSimMessage_0003
460 * @tc.name Add Sim Message
461 * @tc.desc Function test
462 */
463 HWTEST_F(SmsGtest, AddSimMessage_0003, Function | MediumTest | Level3)
464 {
465 TELEPHONY_LOGI("TelSMSMMSTest::AddSimMessage_0003 -->");
466 if (!(SmsGtest::HasSimCard(DEFAULT_SIM_SLOT_ID))) {
467 TELEPHONY_LOGI("TelephonyTestService has no sim card");
468 ASSERT_TRUE(true);
469 return;
470 }
471 SmsMmsTestHelper helper;
472 helper.slotId = DEFAULT_SIM_SLOT_ID;
473
474 if (!helper.Run(AddSimMessageTestFuc, std::ref(helper))) {
475 TELEPHONY_LOGI("AddSimMessageTestFuc out of time");
476 ASSERT_TRUE(false);
477 }
478 TELEPHONY_LOGI("TelSMSMMSTest::AddSimMessage_0003 -->finished");
479 EXPECT_NE(helper.GetIntResult(), 0);
480 }
481
GetAllSimMessagesTestFuc(SmsMmsTestHelper & helper)482 void GetAllSimMessagesTestFuc(SmsMmsTestHelper &helper)
483 {
484 std::vector<ShortMessage> message;
485 DelayedSingleton<SmsServiceManagerClient>::GetInstance()->GetAllSimMessages(helper.slotId, message);
486 bool empty = message.empty();
487 helper.SetBoolResult(empty);
488 helper.NotifyAll();
489 }
490
491 /**
492 * @tc.number Telephony_SmsMmsGtest_GetAllSimMessages_0001
493 * @tc.name Get All Sim Messages
494 * @tc.desc Function test
495 */
496 HWTEST_F(SmsGtest, GetAllSimMessages_0001, Function | MediumTest | Level3)
497 {
498 AccessMmsToken token;
499 TELEPHONY_LOGI("TelSMSMMSTest::GetAllSimMessages_0001 -->");
500 if (!(SmsGtest::HasSimCard(DEFAULT_SIM_SLOT_ID))) {
501 TELEPHONY_LOGI("TelephonyTestService has no sim card");
502 ASSERT_TRUE(true);
503 return;
504 }
505 SmsMmsTestHelper helper;
506 helper.slotId = DEFAULT_SIM_SLOT_ID;
507 if (!helper.Run(GetAllSimMessagesTestFuc, std::ref(helper))) {
508 TELEPHONY_LOGI("GetAllSimMessagesTestFuc out of time");
509 ASSERT_TRUE(false);
510 }
511 TELEPHONY_LOGI("TelSMSMMSTest::GetAllSimMessages_0001 -->finished");
512 EXPECT_FALSE(helper.GetBoolResult());
513 }
514
515 /**
516 * @tc.number Telephony_SmsMmsGtest_GetAllSimMessages_0002
517 * @tc.name Get All Sim Messages
518 * @tc.desc Function test
519 */
520 HWTEST_F(SmsGtest, GetAllSimMessages_0002, Function | MediumTest | Level3)
521 {
522 AccessMmsToken token;
523 TELEPHONY_LOGI("TelSMSMMSTest::GetAllSimMessages_0002 -->");
524 if (!(SmsGtest::HasSimCard(DEFAULT_SIM_SLOT_ID_1))) {
525 TELEPHONY_LOGI("TelephonyTestService has no sim card");
526 ASSERT_TRUE(true);
527 return;
528 }
529 SmsMmsTestHelper helper;
530 helper.slotId = DEFAULT_SIM_SLOT_ID_1;
531 if (!helper.Run(GetAllSimMessagesTestFuc, std::ref(helper))) {
532 TELEPHONY_LOGI("GetAllSimMessagesTestFuc2 out of time");
533 ASSERT_TRUE(false);
534 }
535 TELEPHONY_LOGI("TelSMSMMSTest::GetAllSimMessages_0002 -->finished");
536 EXPECT_FALSE(helper.GetBoolResult());
537 }
538
539 /**
540 * @tc.number Telephony_SmsMmsGtest_GetAllSimMessages_0003
541 * @tc.name Get All Sim Messages
542 * @tc.desc Function test
543 */
544 HWTEST_F(SmsGtest, GetAllSimMessages_0003, Function | MediumTest | Level3)
545 {
546 TELEPHONY_LOGI("TelSMSMMSTest::GetAllSimMessages_0003 -->");
547 if (!(SmsGtest::HasSimCard(DEFAULT_SIM_SLOT_ID))) {
548 TELEPHONY_LOGI("TelephonyTestService has no sim card");
549 ASSERT_TRUE(true);
550 return;
551 }
552 SmsMmsTestHelper helper;
553 helper.slotId = DEFAULT_SIM_SLOT_ID;
554 if (!helper.Run(GetAllSimMessagesTestFuc, std::ref(helper))) {
555 TELEPHONY_LOGI("GetAllSimMessagesTestFuc out of time");
556 ASSERT_TRUE(false);
557 }
558 TELEPHONY_LOGI("TelSMSMMSTest::GetAllSimMessages_0003 -->finished");
559 ASSERT_TRUE(helper.GetBoolResult());
560 }
561
UpdateSimMessageTestFuc(SmsMmsTestHelper & helper)562 void UpdateSimMessageTestFuc(SmsMmsTestHelper &helper)
563 {
564 uint32_t msgIndex = 0;
565 std::u16string smscData(u"");
566 std::u16string pduData(u"01000B818176251308F4000007E8B0BCFD76E701");
567 uint32_t status = 3;
568
569 int32_t result = DelayedSingleton<SmsServiceManagerClient>::GetInstance()->UpdateSimMessage(
570 helper.slotId, msgIndex, static_cast<ISmsServiceInterface::SimMessageStatus>(status), pduData, smscData);
571 helper.SetIntResult(result);
572 helper.NotifyAll();
573 }
574
575 /**
576 * @tc.number Telephony_SmsMmsGtest_UpdateSimMessage_0001
577 * @tc.name Update Sim Message
578 * @tc.desc Function test
579 */
580 HWTEST_F(SmsGtest, UpdateSimMessage_0001, Function | MediumTest | Level3)
581 {
582 AccessMmsToken token;
583 TELEPHONY_LOGI("TelSMSMMSTest::UpdateSimMessage_0001 -->");
584 if (!(SmsGtest::HasSimCard(DEFAULT_SIM_SLOT_ID))) {
585 TELEPHONY_LOGI("TelephonyTestService has no sim card");
586 ASSERT_TRUE(true);
587 return;
588 }
589 SmsMmsTestHelper helper;
590 helper.slotId = DEFAULT_SIM_SLOT_ID;
591 if (!helper.Run(UpdateSimMessageTestFuc, std::ref(helper))) {
592 TELEPHONY_LOGI("UpdateSimMessageTestFuc out of time");
593 ASSERT_TRUE(false);
594 }
595 TELEPHONY_LOGI("TelSMSMMSTest::UpdateSimMessage_0001 -->finished");
596 ASSERT_GE(helper.GetIntResult(), 0);
597 }
598
599 /**
600 * @tc.number Telephony_SmsMmsGtest_UpdateSimMessage_0002
601 * @tc.name Update Sim Message
602 * @tc.desc Function test
603 * @tc.require: issueI5K12U
604 */
605 HWTEST_F(SmsGtest, UpdateSimMessage_0002, Function | MediumTest | Level3)
606 {
607 AccessMmsToken token;
608 TELEPHONY_LOGI("TelSMSMMSTest::UpdateSimMessage_0002 -->");
609 if (!(SmsGtest::HasSimCard(DEFAULT_SIM_SLOT_ID_1))) {
610 TELEPHONY_LOGI("TelephonyTestService has no sim card");
611 ASSERT_TRUE(true);
612 return;
613 }
614 SmsMmsTestHelper helper;
615 helper.slotId = DEFAULT_SIM_SLOT_ID_1;
616 if (!helper.Run(UpdateSimMessageTestFuc, std::ref(helper))) {
617 TELEPHONY_LOGI("UpdateSimMessageTestFuc2 out of time");
618 ASSERT_TRUE(false);
619 }
620 TELEPHONY_LOGI("TelSMSMMSTest::UpdateSimMessage_0002 -->finished");
621 ASSERT_GE(helper.GetIntResult(), 0);
622 }
623
624 /**
625 * @tc.number Telephony_SmsMmsGtest_UpdateSimMessage_0003
626 * @tc.name Update Sim Message
627 * @tc.desc Function test
628 */
629 HWTEST_F(SmsGtest, UpdateSimMessage_0003, Function | MediumTest | Level3)
630 {
631 TELEPHONY_LOGI("TelSMSMMSTest::UpdateSimMessage_0003 -->");
632 if (!(SmsGtest::HasSimCard(DEFAULT_SIM_SLOT_ID))) {
633 TELEPHONY_LOGI("TelephonyTestService has no sim card");
634 ASSERT_TRUE(true);
635 return;
636 }
637 SmsMmsTestHelper helper;
638 helper.slotId = DEFAULT_SIM_SLOT_ID;
639 if (!helper.Run(UpdateSimMessageTestFuc, std::ref(helper))) {
640 TELEPHONY_LOGI("UpdateSimMessageTestFuc out of time");
641 ASSERT_TRUE(false);
642 }
643 TELEPHONY_LOGI("TelSMSMMSTest::UpdateSimMessage_0003 -->finished");
644 EXPECT_NE(helper.GetIntResult(), 0);
645 }
646
DelSimMessageTestFuc(SmsMmsTestHelper & helper)647 void DelSimMessageTestFuc(SmsMmsTestHelper &helper)
648 {
649 uint32_t msgIndex = 1;
650 int32_t result = DelayedSingleton<SmsServiceManagerClient>::GetInstance()->DelSimMessage(helper.slotId, msgIndex);
651 helper.SetIntResult(result);
652 helper.NotifyAll();
653 }
654
655 /**
656 * @tc.number Telephony_SmsMmsGtest_DelSimMessage_0001
657 * @tc.name Del Sim Message
658 * @tc.desc Function test
659 */
660 HWTEST_F(SmsGtest, DelSimMessage_0001, Function | MediumTest | Level3)
661 {
662 AccessMmsToken token;
663 TELEPHONY_LOGI("TelSMSMMSTest::DelSimMessage_0001 -->");
664 if (!(SmsGtest::HasSimCard(DEFAULT_SIM_SLOT_ID))) {
665 TELEPHONY_LOGI("TelephonyTestService has no sim card");
666 ASSERT_TRUE(true);
667 return;
668 }
669 SmsMmsTestHelper helper;
670 helper.slotId = DEFAULT_SIM_SLOT_ID;
671 if (!helper.Run(DelSimMessageTestFuc, std::ref(helper))) {
672 TELEPHONY_LOGI("DelSimMessageTestFuc out of time");
673 ASSERT_TRUE(false);
674 }
675 TELEPHONY_LOGI("TelSMSMMSTest::DelSimMessage_0001 -->finished");
676 ASSERT_GE(helper.GetIntResult(), 0);
677 }
678
679 /**
680 * @tc.number Telephony_SmsMmsGtest_DelSimMessage_0002
681 * @tc.name Del Sim Message
682 * @tc.desc Function test
683 */
684 HWTEST_F(SmsGtest, DelSimMessage_0002, Function | MediumTest | Level3)
685 {
686 AccessMmsToken token;
687 TELEPHONY_LOGI("TelSMSMMSTest::DelSimMessage_0002 -->");
688 if (!(SmsGtest::HasSimCard(DEFAULT_SIM_SLOT_ID_1))) {
689 TELEPHONY_LOGI("TelephonyTestService has no sim card");
690 ASSERT_TRUE(true);
691 return;
692 }
693 SmsMmsTestHelper helper;
694 helper.slotId = DEFAULT_SIM_SLOT_ID_1;
695 if (!helper.Run(DelSimMessageTestFuc, std::ref(helper))) {
696 TELEPHONY_LOGI("DelSimMessageTestFuc2 out of time");
697 ASSERT_TRUE(false);
698 }
699 TELEPHONY_LOGI("TelSMSMMSTest::DelSimMessage_0002 -->finished");
700 ASSERT_GE(helper.GetIntResult(), 0);
701 }
702
703 /**
704 * @tc.number Telephony_SmsMmsGtest_DelSimMessage_0003
705 * @tc.name Del Sim Message
706 * @tc.desc Function test
707 */
708 HWTEST_F(SmsGtest, DelSimMessage_0003, Function | MediumTest | Level3)
709 {
710 TELEPHONY_LOGI("TelSMSMMSTest::DelSimMessage_0003 -->");
711 if (!(SmsGtest::HasSimCard(DEFAULT_SIM_SLOT_ID))) {
712 TELEPHONY_LOGI("TelephonyTestService has no sim card");
713 ASSERT_TRUE(true);
714 return;
715 }
716 SmsMmsTestHelper helper;
717 helper.slotId = DEFAULT_SIM_SLOT_ID;
718 if (!helper.Run(DelSimMessageTestFuc, std::ref(helper))) {
719 TELEPHONY_LOGI("DelSimMessageTestFuc out of time");
720 ASSERT_TRUE(false);
721 }
722 TELEPHONY_LOGI("TelSMSMMSTest::DelSimMessage_0003 -->finished");
723 EXPECT_NE(helper.GetIntResult(), 0);
724 }
725
SetImsSmsConfigTestFuc(SmsMmsTestHelper & helper)726 void SetImsSmsConfigTestFuc(SmsMmsTestHelper &helper)
727 {
728 DelayedSingleton<SmsServiceManagerClient>::GetInstance()->SetImsSmsConfig(helper.slotId, 1);
729 bool isSupported = false;
730 DelayedSingleton<SmsServiceManagerClient>::GetInstance()->IsImsSmsSupported(helper.slotId, isSupported);
731 helper.SetBoolResult(isSupported);
732 helper.NotifyAll();
733 }
734
735 /**
736 * @tc.number Telephony_SmsMmsGtest_SetImsSmsConfig_0001
737 * @tc.name Enable IMS SMS
738 * @tc.desc Function test
739 * @tc.require: issueI5K12U
740 */
741 HWTEST_F(SmsGtest, SetImsSmsConfig_0001, Function | MediumTest | Level2)
742 {
743 AccessMmsToken token;
744 TELEPHONY_LOGI("TelSMSMMSTest::SetImsSmsConfig_0001 -->");
745 if (!(SmsGtest::HasSimCard(DEFAULT_SIM_SLOT_ID))) {
746 TELEPHONY_LOGI("TelephonyTestService has no sim card");
747 ASSERT_TRUE(true);
748 return;
749 }
750 SmsMmsTestHelper helper;
751 helper.slotId = DEFAULT_SIM_SLOT_ID;
752 if (!helper.Run(SetImsSmsConfigTestFuc, std::ref(helper))) {
753 TELEPHONY_LOGI("SetImsSmsConfigTestFuc out of time");
754 ASSERT_TRUE(false);
755 }
756 TELEPHONY_LOGI("TelSMSMMSTest::SetImsSmsConfig_0001 -->finished");
757 ASSERT_TRUE(helper.GetBoolResult());
758 }
759
SetImsSmsConfigTestFuc2(SmsMmsTestHelper & helper)760 void SetImsSmsConfigTestFuc2(SmsMmsTestHelper &helper)
761 {
762 bool isSupported = false;
763 DelayedSingleton<SmsServiceManagerClient>::GetInstance()->SetImsSmsConfig(helper.slotId, 0);
764 DelayedSingleton<SmsServiceManagerClient>::GetInstance()->IsImsSmsSupported(helper.slotId, isSupported);
765 helper.SetBoolResult(isSupported);
766 helper.NotifyAll();
767 }
768
769 /**
770 * @tc.number Telephony_SmsMmsGtest_SetImsSmsConfig_0002
771 * @tc.name Disable Ims Sms
772 * @tc.desc Function test
773 * @tc.require: issueI5K12U
774 */
775 HWTEST_F(SmsGtest, SetImsSmsConfig_0002, Function | MediumTest | Level2)
776 {
777 AccessMmsToken token;
778 TELEPHONY_LOGI("TelSMSMMSTest::SetImsSmsConfig_0002 -->");
779 if (!(SmsGtest::HasSimCard(DEFAULT_SIM_SLOT_ID))) {
780 TELEPHONY_LOGI("TelephonyTestService has no sim card");
781 ASSERT_TRUE(true);
782 return;
783 }
784 SmsMmsTestHelper helper;
785 helper.slotId = DEFAULT_SIM_SLOT_ID;
786 if (!helper.Run(SetImsSmsConfigTestFuc2, std::ref(helper))) {
787 TELEPHONY_LOGI("SetImsSmsConfigTestFuc2 out of time");
788 ASSERT_TRUE(false);
789 }
790 TELEPHONY_LOGI("TelSMSMMSTest::SetImsSmsConfig_0002 -->finished");
791 EXPECT_FALSE(helper.GetBoolResult());
792 }
793
794 /**
795 * @tc.number Telephony_SmsMmsGtest_SetImsSmsConfig_0003
796 * @tc.name Enable IMS SMS
797 * @tc.desc Function test
798 * @tc.require: issueI5K12U
799 */
800 HWTEST_F(SmsGtest, SetImsSmsConfig_0003, Function | MediumTest | Level2)
801 {
802 AccessMmsToken token;
803 TELEPHONY_LOGI("TelSMSMMSTest::SetImsSmsConfig_0003 -->");
804 if (!(SmsGtest::HasSimCard(DEFAULT_SIM_SLOT_ID_1))) {
805 TELEPHONY_LOGI("TelephonyTestService has no sim card");
806 ASSERT_TRUE(true);
807 return;
808 }
809 SmsMmsTestHelper helper;
810 helper.slotId = DEFAULT_SIM_SLOT_ID_1;
811 if (!helper.Run(SetImsSmsConfigTestFuc, std::ref(helper))) {
812 TELEPHONY_LOGI("SetImsSmsConfigTestFuc3 out of time");
813 ASSERT_TRUE(false);
814 }
815 TELEPHONY_LOGI("TelSMSMMSTest::SetImsSmsConfig_0003 -->finished");
816 ASSERT_TRUE(helper.GetBoolResult());
817 }
818
819 /**
820 * @tc.number Telephony_SmsMmsGtest_SetImsSmsConfig_0004
821 * @tc.name Disable Ims Sms
822 * @tc.desc Function test
823 */
824 HWTEST_F(SmsGtest, SetImsSmsConfig_0004, Function | MediumTest | Level2)
825 {
826 AccessMmsToken token;
827 TELEPHONY_LOGI("TelSMSMMSTest::SetImsSmsConfig_0004 -->");
828 if (!(SmsGtest::HasSimCard(DEFAULT_SIM_SLOT_ID_1))) {
829 TELEPHONY_LOGI("TelephonyTestService has no sim card");
830 ASSERT_TRUE(true);
831 return;
832 }
833 SmsMmsTestHelper helper;
834 helper.slotId = DEFAULT_SIM_SLOT_ID_1;
835 if (!helper.Run(SetImsSmsConfigTestFuc2, std::ref(helper))) {
836 TELEPHONY_LOGI("SetImsSmsConfigTestFuc4 out of time");
837 ASSERT_TRUE(false);
838 }
839 TELEPHONY_LOGI("TelSMSMMSTest::SetImsSmsConfig_0004 -->finished");
840 EXPECT_FALSE(helper.GetBoolResult());
841 }
842
843 /**
844 * @tc.number Telephony_SmsMmsGtest_SetImsSmsConfig_0005
845 * @tc.name Enable IMS SMS
846 * @tc.desc Function test
847 * @tc.require: issueI5K12U
848 */
849 HWTEST_F(SmsGtest, SetImsSmsConfig_0005, Function | MediumTest | Level2)
850 {
851 TELEPHONY_LOGI("TelSMSMMSTest::SetImsSmsConfig_0005 -->");
852 if (!(SmsGtest::HasSimCard(DEFAULT_SIM_SLOT_ID))) {
853 TELEPHONY_LOGI("TelephonyTestService has no sim card");
854 ASSERT_TRUE(true);
855 return;
856 }
857 SmsMmsTestHelper helper;
858 helper.slotId = DEFAULT_SIM_SLOT_ID;
859 if (!helper.Run(SetImsSmsConfigTestFuc, std::ref(helper))) {
860 TELEPHONY_LOGI("SetImsSmsConfigTestFuc out of time");
861 ASSERT_TRUE(false);
862 }
863 TELEPHONY_LOGI("TelSMSMMSTest::SetImsSmsConfig_0005 -->finished");
864 EXPECT_FALSE(helper.GetBoolResult());
865 }
866
SendDataMessageTestFuc(SmsMmsTestHelper & helper)867 void SendDataMessageTestFuc(SmsMmsTestHelper &helper)
868 {
869 std::string dest = DES_ADDR;
870 std::u16string simcardNumber;
871 if (!CoreServiceClient::GetInstance().GetSimTelephoneNumber(helper.slotId, simcardNumber) &&
872 !simcardNumber.empty()) {
873 dest = StringUtils::ToUtf8(simcardNumber);
874 }
875
876 std::string sca("");
877 OHOS::sptr<SmsSendCallbackGTest> sendCallBackPtr(new SmsSendCallbackGTest(helper));
878 OHOS::sptr<SmsDeliveryCallbackGTest> deliveryCallBackPtr(new SmsDeliveryCallbackGTest(helper));
879 uint16_t port = SMS_PORT;
880 if (sendCallBackPtr == nullptr) {
881 TELEPHONY_LOGI("sendCallBackPtr is nullptr");
882 helper.NotifyAll();
883 }
884
885 if (deliveryCallBackPtr == nullptr) {
886 TELEPHONY_LOGI("deliveryCallBackPtr is nullptr");
887 helper.NotifyAll();
888 }
889 sendCallBackPtr->HasDeliveryCallBack(true);
890 DelayedSingleton<SmsServiceManagerClient>::GetInstance()->SendMessage(helper.slotId, StringUtils::ToUtf16(dest),
891 StringUtils::ToUtf16(sca), port, DATA_SMS, (sizeof(DATA_SMS) / sizeof(DATA_SMS[0]) - 1), sendCallBackPtr,
892 deliveryCallBackPtr);
893 }
894
SendDataMessageTestFuc2(SmsMmsTestHelper & helper)895 void SendDataMessageTestFuc2(SmsMmsTestHelper &helper)
896 {
897 std::string dest = DES_ADDR;
898 std::u16string simcardNumber;
899 if (!CoreServiceClient::GetInstance().GetSimTelephoneNumber(helper.slotId, simcardNumber) &&
900 !simcardNumber.empty()) {
901 dest = StringUtils::ToUtf8(simcardNumber);
902 }
903
904 std::string sca("");
905 OHOS::sptr<SmsSendCallbackGTest> sendCallBackPtr(new SmsSendCallbackGTest(helper));
906 OHOS::sptr<SmsDeliveryCallbackGTest> deliveryCallBackPtr(new SmsDeliveryCallbackGTest(helper));
907 uint16_t port = SMS_PORT;
908 if (sendCallBackPtr == nullptr) {
909 TELEPHONY_LOGI("sendCallBackPtr is nullptr");
910 helper.NotifyAll();
911 }
912
913 if (deliveryCallBackPtr == nullptr) {
914 TELEPHONY_LOGI("deliveryCallBackPtr is nullptr");
915 helper.NotifyAll();
916 }
917 sendCallBackPtr->HasDeliveryCallBack(false);
918 DelayedSingleton<SmsServiceManagerClient>::GetInstance()->SendMessage(helper.slotId, StringUtils::ToUtf16(dest),
919 StringUtils::ToUtf16(sca), port, DATA_SMS, (sizeof(DATA_SMS) / sizeof(DATA_SMS[0]) - 1), sendCallBackPtr,
920 deliveryCallBackPtr);
921 }
922
923 /**
924 * @tc.number Telephony_SmsMmsGtest_SendDataMessage_0001
925 * @tc.name Send Data Sms
926 * @tc.desc Function test
927 */
928 HWTEST_F(SmsGtest, SendDataMessage_0001, Function | MediumTest | Level2)
929 {
930 AccessMmsToken token;
931 TELEPHONY_LOGI("TelSMSMMSTest::SendDataMessage_0001 -->");
932 int32_t slotId = DEFAULT_SIM_SLOT_ID;
933 if (!(SmsGtest::HasSimCard(slotId))) {
934 TELEPHONY_LOGI("TelephonyTestService has no sim card");
935 ASSERT_TRUE(true);
936 return;
937 }
938 SmsMmsTestHelper helper;
939 helper.slotId = slotId;
940 if (!helper.Run(SendDataMessageTestFuc, helper, WAIT_TIME_SHORT_SECOND)) {
941 TELEPHONY_LOGI("SendDataMessageTestFuc out of time");
942 }
943 TELEPHONY_LOGI("TelSMSMMSTest::SendDataMessage_0001 -->finished");
944 ASSERT_TRUE(helper.GetSendSmsIntResult() == 0 || helper.GetDeliverySmsIntResult() == 0);
945 }
946
947 /**
948 * @tc.number Telephony_SmsMmsGtest_SendDataMessage_0002
949 * @tc.name Send Data Sms
950 * @tc.desc Function test
951 */
952 HWTEST_F(SmsGtest, SendDataMessage_0002, Function | MediumTest | Level2)
953 {
954 AccessMmsToken token;
955 TELEPHONY_LOGI("TelSMSMMSTest::SendDataMessage_0002 -->");
956 int32_t slotId = DEFAULT_SIM_SLOT_ID_1;
957 if (!(SmsGtest::HasSimCard(slotId))) {
958 TELEPHONY_LOGI("TelephonyTestService has no sim card");
959 ASSERT_TRUE(true);
960 return;
961 }
962 SmsMmsTestHelper helper;
963 helper.slotId = slotId;
964 if (!helper.Run(SendDataMessageTestFuc, helper, WAIT_TIME_SHORT_SECOND)) {
965 TELEPHONY_LOGI("SendDataMessageTestFuc out of time");
966 }
967 TELEPHONY_LOGI("TelSMSMMSTest::SendDataMessage_0002 -->finished");
968 ASSERT_TRUE(helper.GetSendSmsIntResult() == 0 || helper.GetDeliverySmsIntResult() == 0);
969 }
970
971 /**
972 * @tc.number Telephony_SmsMmsGtest_SendDataMessage_0003
973 * @tc.name Send Data Sms
974 * @tc.desc Function test
975 */
976 HWTEST_F(SmsGtest, SendDataMessage_0003, Function | MediumTest | Level2)
977 {
978 TELEPHONY_LOGI("TelSMSMMSTest::SendDataMessage_0003 -->");
979 int32_t slotId = DEFAULT_SIM_SLOT_ID;
980 if (!(SmsGtest::HasSimCard(slotId))) {
981 TELEPHONY_LOGI("TelephonyTestService has no sim card");
982 ASSERT_TRUE(true);
983 return;
984 }
985 SmsMmsTestHelper helper;
986 helper.slotId = slotId;
987 if (!helper.Run(SendDataMessageTestFuc2, helper)) {
988 TELEPHONY_LOGI("SendDataMessageTestFuc out of time");
989 ASSERT_TRUE(false);
990 return;
991 }
992 TELEPHONY_LOGI("TelSMSMMSTest::SendDataMessage_0003 -->finished");
993 EXPECT_NE(helper.GetSendSmsIntResult(), 0);
994 }
995
SendTextMessageTestFuc(SmsMmsTestHelper & helper)996 void SendTextMessageTestFuc(SmsMmsTestHelper &helper)
997 {
998 std::string dest = DES_ADDR;
999 std::u16string simcardNumber;
1000 if (!CoreServiceClient::GetInstance().GetSimTelephoneNumber(helper.slotId, simcardNumber) &&
1001 !simcardNumber.empty()) {
1002 dest = StringUtils::ToUtf8(simcardNumber);
1003 }
1004
1005 std::string sca("");
1006 OHOS::sptr<SmsSendCallbackGTest> sendCallBackPtr(new SmsSendCallbackGTest(helper));
1007 OHOS::sptr<SmsDeliveryCallbackGTest> deliveryCallBackPtr(new SmsDeliveryCallbackGTest(helper));
1008 std::string text = TEXT_SMS_CONTENT;
1009 if (sendCallBackPtr == nullptr) {
1010 TELEPHONY_LOGI("sendCallBackPtr is nullptr");
1011 helper.NotifyAll();
1012 return;
1013 }
1014
1015 if (deliveryCallBackPtr == nullptr) {
1016 TELEPHONY_LOGI("deliveryCallBackPtr is nullptr");
1017 helper.NotifyAll();
1018 return;
1019 }
1020 sendCallBackPtr->HasDeliveryCallBack(true);
1021 DelayedSingleton<SmsServiceManagerClient>::GetInstance()->SendMessage(helper.slotId, StringUtils::ToUtf16(dest),
1022 StringUtils::ToUtf16(sca), StringUtils::ToUtf16(text), sendCallBackPtr, deliveryCallBackPtr);
1023 }
1024
SendTextMessageTestFuc2(SmsMmsTestHelper & helper)1025 void SendTextMessageTestFuc2(SmsMmsTestHelper &helper)
1026 {
1027 std::string dest = DES_ADDR;
1028 std::u16string simcardNumber;
1029 if (!CoreServiceClient::GetInstance().GetSimTelephoneNumber(helper.slotId, simcardNumber) &&
1030 !simcardNumber.empty()) {
1031 dest = StringUtils::ToUtf8(simcardNumber);
1032 }
1033
1034 std::string sca("");
1035 OHOS::sptr<SmsSendCallbackGTest> sendCallBackPtr(new SmsSendCallbackGTest(helper));
1036 OHOS::sptr<SmsDeliveryCallbackGTest> deliveryCallBackPtr(new SmsDeliveryCallbackGTest(helper));
1037 std::string text = TEXT_SMS_CONTENT;
1038 if (sendCallBackPtr == nullptr) {
1039 TELEPHONY_LOGI("sendCallBackPtr is nullptr");
1040 helper.NotifyAll();
1041 return;
1042 }
1043
1044 if (deliveryCallBackPtr == nullptr) {
1045 TELEPHONY_LOGI("deliveryCallBackPtr is nullptr");
1046 helper.NotifyAll();
1047 return;
1048 }
1049 sendCallBackPtr->HasDeliveryCallBack(false);
1050 DelayedSingleton<SmsServiceManagerClient>::GetInstance()->SendMessage(helper.slotId, StringUtils::ToUtf16(dest),
1051 StringUtils::ToUtf16(sca), StringUtils::ToUtf16(text), sendCallBackPtr, deliveryCallBackPtr);
1052 }
1053
1054 /**
1055 * @tc.number Telephony_SmsMmsGtest_SendTextMessage_0001
1056 * @tc.name Send Text Sms
1057 * @tc.desc Function test
1058 */
1059 HWTEST_F(SmsGtest, SendTextMessage_0001, Function | MediumTest | Level2)
1060 {
1061 AccessMmsToken token;
1062 TELEPHONY_LOGI("TelSMSMMSTest::SendTextMessage_0001 -->");
1063 int32_t slotId = DEFAULT_SIM_SLOT_ID;
1064 if (!(SmsGtest::HasSimCard(slotId))) {
1065 TELEPHONY_LOGI("TelephonyTestService has no sim card");
1066 ASSERT_TRUE(true);
1067 return;
1068 }
1069 SmsMmsTestHelper helper;
1070 helper.slotId = slotId;
1071 if (!helper.Run(SendTextMessageTestFuc, helper, WAIT_TIME_SHORT_SECOND)) {
1072 TELEPHONY_LOGI("SendTextMessageTestFuc out of time");
1073 }
1074 TELEPHONY_LOGI("TelSMSMMSTest::SendTextMessage_0001 -->finished");
1075 ASSERT_TRUE(helper.GetSendSmsIntResult() == 0 || helper.GetDeliverySmsIntResult() == 0);
1076 }
1077
1078 /**
1079 * @tc.number Telephony_SmsMmsGtest_SendTextMessage_0002
1080 * @tc.name Send Text Sms
1081 * @tc.desc Function test
1082 */
1083 HWTEST_F(SmsGtest, SendTextMessage_0002, Function | MediumTest | Level2)
1084 {
1085 AccessMmsToken token;
1086 TELEPHONY_LOGI("TelSMSMMSTest::SendTextMessage_0002 -->");
1087 int32_t slotId = DEFAULT_SIM_SLOT_ID_1;
1088 if (!(SmsGtest::HasSimCard(slotId))) {
1089 TELEPHONY_LOGI("TelephonyTestService has no sim card");
1090 ASSERT_TRUE(true);
1091 return;
1092 }
1093 SmsMmsTestHelper helper;
1094 helper.slotId = slotId;
1095 if (!helper.Run(SendTextMessageTestFuc, helper, WAIT_TIME_SHORT_SECOND)) {
1096 TELEPHONY_LOGI("SendTextMessageTestFuc out of time");
1097 }
1098 TELEPHONY_LOGI("TelSMSMMSTest::SendTextMessage_0001 -->finished");
1099 ASSERT_TRUE(helper.GetSendSmsIntResult() == 0 || helper.GetDeliverySmsIntResult() == 0);
1100 }
1101
1102 /**
1103 * @tc.number Telephony_SmsMmsGtest_SendTextMessage_0003
1104 * @tc.name Send Text Sms
1105 * @tc.desc Function test
1106 */
1107 HWTEST_F(SmsGtest, SendTextMessage_0003, Function | MediumTest | Level2)
1108 {
1109 TELEPHONY_LOGI("TelSMSMMSTest::SendTextMessage_0003 -->");
1110 int32_t slotId = DEFAULT_SIM_SLOT_ID;
1111 if (!(SmsGtest::HasSimCard(slotId))) {
1112 TELEPHONY_LOGI("TelephonyTestService has no sim card");
1113 ASSERT_TRUE(true);
1114 return;
1115 }
1116 SmsMmsTestHelper helper;
1117 helper.slotId = slotId;
1118 if (!helper.Run(SendTextMessageTestFuc2, helper)) {
1119 TELEPHONY_LOGI("SendTextMessageTestFuc out of time");
1120 ASSERT_TRUE(false);
1121 return;
1122 }
1123 TELEPHONY_LOGI("TelSMSMMSTest::SendTextMessage_0003 -->finished");
1124 EXPECT_NE(helper.GetSendSmsIntResult(), 0);
1125 }
1126
ReceiveSmsTestFunc(SmsMmsTestHelper & helper)1127 void ReceiveSmsTestFunc(SmsMmsTestHelper &helper)
1128 {
1129 std::shared_ptr<AppExecFwk::EventRunner> runner = AppExecFwk::EventRunner::Create("test");
1130 auto smsReceiveHandler = std::make_shared<GsmSmsReceiveHandler>(runner, helper.slotId);
1131 auto message = std::make_shared<SmsMessageInfo>();
1132 message->indicationType = MESSAGE_TYPE;
1133 message->size = SMS_PDU_LEN;
1134 message->pdu =
1135 StringUtils::HexToByteVector("0891683110808805F0040D91686106571209F800003210921134922307D3F69C5A9ED301");
1136
1137 AppExecFwk::InnerEvent::Pointer event = AppExecFwk::InnerEvent::Get(RadioEvent::RADIO_GSM_SMS, message);
1138 smsReceiveHandler->ProcessEvent(event);
1139 }
1140
1141 /**
1142 * @tc.number Telephony_SmsMmsGtest_Receive_SMS_0001
1143 * @tc.name Receive a normal Sms
1144 * @tc.desc Function test
1145 */
1146 HWTEST_F(SmsGtest, Receive_SMS_0001, Function | MediumTest | Level2)
1147 {
1148 AccessMmsToken token;
1149 TELEPHONY_LOGI("TelSMSMMSTest::Receive_SMS_0001 -->");
1150 int32_t slotId = DEFAULT_SIM_SLOT_ID;
1151 if (!(SmsGtest::HasSimCard(slotId))) {
1152 TELEPHONY_LOGI("TelephonyTestService has no sim card");
1153 ASSERT_TRUE(true);
1154 return;
1155 }
1156 SmsMmsTestHelper helper;
1157 helper.slotId = slotId;
1158
1159 EventFwk::MatchingSkills matchingSkills;
1160 matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_SMS_RECEIVE_COMPLETED);
1161 EventFwk::CommonEventSubscribeInfo subscriberInfo(matchingSkills);
1162 std::shared_ptr<SmsBroadcastSubscriberGtest> subscriberTest =
1163 std::make_shared<SmsBroadcastSubscriberGtest>(subscriberInfo, helper);
1164 if (subscriberTest == nullptr) {
1165 ASSERT_TRUE(false);
1166 return;
1167 }
1168 bool subscribeResult = EventFwk::CommonEventManager::SubscribeCommonEvent(subscriberTest);
1169 TELEPHONY_LOGI("subscribeResult is : %{public}d", subscribeResult);
1170
1171 if (!helper.Run(ReceiveSmsTestFunc, helper)) {
1172 TELEPHONY_LOGI("ReceiveSmsTestFunc out of time");
1173 ASSERT_TRUE(true);
1174 return;
1175 }
1176 TELEPHONY_LOGI("TelSMSMMSTest::Receive_SMS_0001 -->finished");
1177 EXPECT_TRUE(helper.GetBoolResult());
1178 }
1179
1180 /**
1181 * @tc.number Telephony_SmsMmsGtest_Receive_SMS_0002
1182 * @tc.name Receive a normal Sms
1183 * @tc.desc Function test
1184 */
1185 HWTEST_F(SmsGtest, Receive_SMS_0002, Function | MediumTest | Level2)
1186 {
1187 AccessMmsToken token;
1188 TELEPHONY_LOGI("TelSMSMMSTest::Receive_SMS_0002 -->");
1189 int32_t slotId = DEFAULT_SIM_SLOT_ID_1;
1190 if (!(SmsGtest::HasSimCard(slotId))) {
1191 TELEPHONY_LOGI("TelephonyTestService has no sim card");
1192 ASSERT_TRUE(true);
1193 return;
1194 }
1195 SmsMmsTestHelper helper;
1196 helper.slotId = slotId;
1197
1198 EventFwk::MatchingSkills matchingSkills;
1199 matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_SMS_RECEIVE_COMPLETED);
1200 EventFwk::CommonEventSubscribeInfo subscriberInfo(matchingSkills);
1201 std::shared_ptr<SmsBroadcastSubscriberGtest> subscriberTest =
1202 std::make_shared<SmsBroadcastSubscriberGtest>(subscriberInfo, helper);
1203 if (subscriberTest == nullptr) {
1204 ASSERT_TRUE(false);
1205 return;
1206 }
1207 bool subscribeResult = EventFwk::CommonEventManager::SubscribeCommonEvent(subscriberTest);
1208 TELEPHONY_LOGI("subscribeResult is : %{public}d", subscribeResult);
1209
1210 if (!helper.Run(ReceiveSmsTestFunc, helper)) {
1211 TELEPHONY_LOGI("ReceiveSmsTestFunc out of time");
1212 ASSERT_TRUE(true);
1213 return;
1214 }
1215 TELEPHONY_LOGI("TelSMSMMSTest::Receive_SMS_0002 -->finished");
1216 EXPECT_TRUE(helper.GetBoolResult());
1217 }
1218
GetSmsSegmentsInfoTestFuc(SmsMmsTestHelper & helper)1219 void GetSmsSegmentsInfoTestFuc(SmsMmsTestHelper &helper)
1220 {
1221 std::u16string message = u"";
1222 bool force7BitCode = false;
1223 ISmsServiceInterface::SmsSegmentsInfo result;
1224 DelayedSingleton<SmsServiceManagerClient>::GetInstance()->GetSmsSegmentsInfo(
1225 helper.slotId, message, force7BitCode, result);
1226 bool isSupported = false;
1227 DelayedSingleton<SmsServiceManagerClient>::GetInstance()->IsImsSmsSupported(helper.slotId, isSupported);
1228 helper.SetBoolResult(isSupported);
1229 helper.NotifyAll();
1230 }
1231
GetSmsSegmentsInfoTestFuc2(SmsMmsTestHelper & helper)1232 void GetSmsSegmentsInfoTestFuc2(SmsMmsTestHelper &helper)
1233 {
1234 std::u16string message = u"message";
1235 bool force7BitCode = true;
1236 ISmsServiceInterface::SmsSegmentsInfo result;
1237 DelayedSingleton<SmsServiceManagerClient>::GetInstance()->GetSmsSegmentsInfo(
1238 helper.slotId, message, force7BitCode, result);
1239 bool isSupported = false;
1240 DelayedSingleton<SmsServiceManagerClient>::GetInstance()->IsImsSmsSupported(helper.slotId, isSupported);
1241 helper.SetBoolResult(isSupported);
1242 helper.NotifyAll();
1243 }
1244
1245 /**
1246 * @tc.number Telephony_SmsMmsGtest_GetSmsSegmentsInfo_0001
1247 * @tc.name Send Text Sms
1248 * @tc.desc Function test
1249 */
1250 HWTEST_F(SmsGtest, GetSmsSegmentsInfo_0001, Function | MediumTest | Level2)
1251 {
1252 TELEPHONY_LOGI("TelSMSMMSTest::GetSmsSegmentsInfo_0001 -->");
1253 int32_t slotId = DEFAULT_SIM_SLOT_ID;
1254 if (!(SmsGtest::HasSimCard(slotId))) {
1255 TELEPHONY_LOGI("TelephonyTestService has no sim card");
1256 ASSERT_TRUE(true);
1257 return;
1258 }
1259 SmsMmsTestHelper helper;
1260 helper.slotId = slotId;
1261 if (!helper.Run(GetSmsSegmentsInfoTestFuc, helper)) {
1262 TELEPHONY_LOGI("GetSmsSegmentsInfoTestFuc out of time");
1263 ASSERT_TRUE(false);
1264 }
1265 TELEPHONY_LOGI("TelSMSMMSTest::GetSmsSegmentsInfo_0001 -->finished");
1266 EXPECT_FALSE(helper.GetBoolResult());
1267 }
1268
1269 /**
1270 * @tc.number Telephony_SmsMmsGtest_GetSmsSegmentsInfo_0002
1271 * @tc.name Send Text Sms
1272 * @tc.desc Function test
1273 */
1274 HWTEST_F(SmsGtest, GetSmsSegmentsInfo_0002, Function | MediumTest | Level2)
1275 {
1276 TELEPHONY_LOGI("TelSMSMMSTest::GetSmsSegmentsInfo_0002 -->");
1277 int32_t slotId = DEFAULT_SIM_SLOT_ID;
1278 if (!(SmsGtest::HasSimCard(slotId))) {
1279 TELEPHONY_LOGI("TelephonyTestService has no sim card");
1280 ASSERT_TRUE(true);
1281 return;
1282 }
1283 SmsMmsTestHelper helper;
1284 helper.slotId = slotId;
1285 if (!helper.Run(GetSmsSegmentsInfoTestFuc2, helper)) {
1286 TELEPHONY_LOGI("GetSmsSegmentsInfoTestFuc2 out of time");
1287 ASSERT_TRUE(false);
1288 }
1289 TELEPHONY_LOGI("TelSMSMMSTest::GetSmsSegmentsInfo_0002 -->finished");
1290 EXPECT_FALSE(helper.GetBoolResult());
1291 }
1292
1293 /**
1294 * @tc.number Telephony_SmsMmsGtest_GetSmsSegmentsInfo_0003
1295 * @tc.name Send Text Sms
1296 * @tc.desc Function test
1297 */
1298 HWTEST_F(SmsGtest, GetSmsSegmentsInfo_0003, Function | MediumTest | Level2)
1299 {
1300 TELEPHONY_LOGI("TelSMSMMSTest::GetSmsSegmentsInfo_0003 -->");
1301 int32_t slotId = DEFAULT_SIM_SLOT_ID_1;
1302 if (!(SmsGtest::HasSimCard(slotId))) {
1303 TELEPHONY_LOGI("TelephonyTestService has no sim card");
1304 ASSERT_TRUE(true);
1305 return;
1306 }
1307 SmsMmsTestHelper helper;
1308 helper.slotId = slotId;
1309 if (!helper.Run(GetSmsSegmentsInfoTestFuc, helper)) {
1310 TELEPHONY_LOGI("GetSmsSegmentsInfoTestFuc3 out of time");
1311 ASSERT_TRUE(false);
1312 }
1313 TELEPHONY_LOGI("TelSMSMMSTest::GetSmsSegmentsInfo_0003 -->finished");
1314 EXPECT_FALSE(helper.GetBoolResult());
1315 }
1316
Create7bitSubmitSmsTestFuc(SmsMmsTestHelper & helper)1317 void Create7bitSubmitSmsTestFuc(SmsMmsTestHelper &helper)
1318 {
1319 std::vector<unsigned char> pdu = StringUtils::HexToByteVector("21010B818176251308F4000002C130");
1320 ShortMessage *message = new ShortMessage();
1321 if (message == nullptr) {
1322 helper.SetIntResult(1);
1323 helper.NotifyAll();
1324 return;
1325 }
1326 int result = ShortMessage::CreateMessage(pdu, u"3gpp", *message);
1327 helper.SetIntResult(result);
1328 helper.NotifyAll();
1329 }
1330
1331 /**
1332 * @tc.number Telephony_SmsMmsGtest_Create7bitSubmitSms_0001
1333 * @tc.name Create 7bit Submit Sms
1334 * @tc.desc Function test
1335 */
1336 HWTEST_F(SmsGtest, Create7bitSubmitSms_0001, Function | MediumTest | Level2)
1337 {
1338 AccessMmsToken token;
1339 TELEPHONY_LOGI("TelSMSMMSTest::Create7bitSubmitSms_0001 -->");
1340 if (!(SmsGtest::HasSimCard(DEFAULT_SIM_SLOT_ID))) {
1341 TELEPHONY_LOGI("TelephonyTestService has no sim card");
1342 ASSERT_TRUE(true);
1343 return;
1344 }
1345 SmsMmsTestHelper helper;
1346 helper.slotId = DEFAULT_SIM_SLOT_ID;
1347 if (!helper.Run(Create7bitSubmitSmsTestFuc, std::ref(helper))) {
1348 TELEPHONY_LOGI("Create7bitSubmitSmsTestFuc out of time");
1349 ASSERT_TRUE(false);
1350 return;
1351 }
1352 TELEPHONY_LOGI("TelSMSMMSTest::Create7bitSubmitSms_0001 -->finished");
1353 ASSERT_EQ(helper.GetIntResult(), 0);
1354 }
1355
1356 /**
1357 * @tc.number Telephony_SmsMmsGtest_Create7bitSubmitSms_0002
1358 * @tc.name Create 7bit Submit Sms
1359 * @tc.desc Function test
1360 */
1361 HWTEST_F(SmsGtest, Create7bitSubmitSms_0002, Function | MediumTest | Level2)
1362 {
1363 AccessMmsToken token;
1364 TELEPHONY_LOGI("TelSMSMMSTest::Create7bitSubmitSms_0002 -->");
1365 if (!(SmsGtest::HasSimCard(DEFAULT_SIM_SLOT_ID_1))) {
1366 TELEPHONY_LOGI("TelephonyTestService has no sim card");
1367 ASSERT_TRUE(true);
1368 return;
1369 }
1370 SmsMmsTestHelper helper;
1371 helper.slotId = DEFAULT_SIM_SLOT_ID_1;
1372 if (!helper.Run(Create7bitSubmitSmsTestFuc, std::ref(helper))) {
1373 TELEPHONY_LOGI("Create7bitSubmitSmsTestFuc out of time");
1374 ASSERT_TRUE(false);
1375 return;
1376 }
1377 TELEPHONY_LOGI("TelSMSMMSTest::Create7bitSubmitSms_0002 -->finished");
1378 ASSERT_EQ(helper.GetIntResult(), 0);
1379 }
1380
CreateUcs2SubmitSmsTestFuc(SmsMmsTestHelper & helper)1381 void CreateUcs2SubmitSmsTestFuc(SmsMmsTestHelper &helper)
1382 {
1383 std::vector<unsigned char> pdu = StringUtils::HexToByteVector("21020B818176251308F40008046D4B8BD5");
1384 ShortMessage *message = new ShortMessage();
1385 if (message == nullptr) {
1386 helper.SetIntResult(1);
1387 helper.NotifyAll();
1388 return;
1389 }
1390 int result = ShortMessage::CreateMessage(pdu, u"3gpp", *message);
1391 helper.SetIntResult(result);
1392 helper.NotifyAll();
1393 }
1394
1395 /**
1396 * @tc.number Telephony_SmsMmsGtest_CreateUcs2SubmitSms_0001
1397 * @tc.name Create Ucs2 Submit Sms
1398 * @tc.desc Function test
1399 */
1400 HWTEST_F(SmsGtest, CreateUcs2SubmitSms_0001, Function | MediumTest | Level2)
1401 {
1402 AccessMmsToken token;
1403 TELEPHONY_LOGI("TelSMSMMSTest::CreateUcs2SubmitSms_0001 -->");
1404 if (!(SmsGtest::HasSimCard(DEFAULT_SIM_SLOT_ID))) {
1405 TELEPHONY_LOGI("TelephonyTestService has no sim card");
1406 ASSERT_TRUE(true);
1407 return;
1408 }
1409 SmsMmsTestHelper helper;
1410 helper.slotId = DEFAULT_SIM_SLOT_ID;
1411 if (!helper.Run(CreateUcs2SubmitSmsTestFuc, std::ref(helper))) {
1412 TELEPHONY_LOGI("CreateUcs2SubmitSmsTestFuc out of time");
1413 ASSERT_TRUE(false);
1414 return;
1415 }
1416 TELEPHONY_LOGI("TelSMSMMSTest::CreateUcs2SubmitSms_0001 -->finished");
1417 ASSERT_EQ(helper.GetIntResult(), 0);
1418 }
1419
1420 /**
1421 * @tc.number Telephony_SmsMmsGtest_CreateUcs2SubmitSms_0002
1422 * @tc.name Create Ucs2 Submit Sms
1423 * @tc.desc Function test
1424 */
1425 HWTEST_F(SmsGtest, CreateUcs2SubmitSms_0002, Function | MediumTest | Level2)
1426 {
1427 AccessMmsToken token;
1428 TELEPHONY_LOGI("TelSMSMMSTest::CreateUcs2SubmitSms_0002 -->");
1429 if (!(SmsGtest::HasSimCard(DEFAULT_SIM_SLOT_ID_1))) {
1430 TELEPHONY_LOGI("TelephonyTestService has no sim card");
1431 ASSERT_TRUE(true);
1432 return;
1433 }
1434 SmsMmsTestHelper helper;
1435 helper.slotId = DEFAULT_SIM_SLOT_ID_1;
1436 if (!helper.Run(CreateUcs2SubmitSmsTestFuc, std::ref(helper))) {
1437 TELEPHONY_LOGI("CreateUcs2SubmitSmsTestFuc out of time");
1438 ASSERT_TRUE(false);
1439 return;
1440 }
1441 TELEPHONY_LOGI("TelSMSMMSTest::CreateUcs2SubmitSms_0002 -->finished");
1442 ASSERT_EQ(helper.GetIntResult(), 0);
1443 }
1444
Create7bitDeliverySmsTestFuc(SmsMmsTestHelper & helper)1445 void Create7bitDeliverySmsTestFuc(SmsMmsTestHelper &helper)
1446 {
1447 std::vector<unsigned char> pdu =
1448 StringUtils::HexToByteVector("0891683108200075F4240D91688129562983F600001240800102142302C130");
1449 ShortMessage *message = new ShortMessage();
1450 if (message == nullptr) {
1451 helper.SetIntResult(1);
1452 helper.NotifyAll();
1453 return;
1454 }
1455 int result = ShortMessage::CreateMessage(pdu, u"3gpp", *message);
1456 helper.SetIntResult(result);
1457 helper.NotifyAll();
1458 }
1459
1460 /**
1461 * @tc.number Telephony_SmsMmsGtest_Create7bitDeliverySms_0001
1462 * @tc.name Create 7bit Delivery Sms
1463 * @tc.desc Function test
1464 */
1465 HWTEST_F(SmsGtest, Create7bitDeliverySms_0001, Function | MediumTest | Level2)
1466 {
1467 AccessMmsToken token;
1468 TELEPHONY_LOGI("TelSMSMMSTest::Create7bitDeliverySms_0001 -->");
1469 if (!(SmsGtest::HasSimCard(DEFAULT_SIM_SLOT_ID))) {
1470 TELEPHONY_LOGI("TelephonyTestService has no sim card");
1471 ASSERT_TRUE(true);
1472 return;
1473 }
1474 SmsMmsTestHelper helper;
1475 helper.slotId = DEFAULT_SIM_SLOT_ID;
1476 if (!helper.Run(Create7bitDeliverySmsTestFuc, std::ref(helper))) {
1477 TELEPHONY_LOGI("Create7bitDeliverySmsTestFuc out of time");
1478 ASSERT_TRUE(false);
1479 return;
1480 }
1481 TELEPHONY_LOGI("TelSMSMMSTest::Create7bitDeliverySms_0001 -->finished");
1482 ASSERT_EQ(helper.GetIntResult(), 0);
1483 }
1484
1485 /**
1486 * @tc.number Telephony_SmsMmsGtest_Create7bitDeliverySms_0002
1487 * @tc.name Create 7bit Delivery Sms
1488 * @tc.desc Function test
1489 */
1490 HWTEST_F(SmsGtest, Create7bitDeliverySms_0002, Function | MediumTest | Level2)
1491 {
1492 AccessMmsToken token;
1493 TELEPHONY_LOGI("TelSMSMMSTest::Create7bitDeliverySms_0002 -->");
1494 if (!(SmsGtest::HasSimCard(DEFAULT_SIM_SLOT_ID_1))) {
1495 TELEPHONY_LOGI("TelephonyTestService has no sim card");
1496 ASSERT_TRUE(true);
1497 return;
1498 }
1499 SmsMmsTestHelper helper;
1500 helper.slotId = DEFAULT_SIM_SLOT_ID_1;
1501 if (!helper.Run(Create7bitDeliverySmsTestFuc, std::ref(helper))) {
1502 TELEPHONY_LOGI("Create7bitDeliverySmsTestFuc out of time");
1503 ASSERT_TRUE(false);
1504 return;
1505 }
1506 TELEPHONY_LOGI("TelSMSMMSTest::Create7bitDeliverySms_0002 -->finished");
1507 ASSERT_EQ(helper.GetIntResult(), 0);
1508 }
1509
CreateUcs2DeliverySmsTestFuc(SmsMmsTestHelper & helper)1510 void CreateUcs2DeliverySmsTestFuc(SmsMmsTestHelper &helper)
1511 {
1512 std::vector<unsigned char> pdu =
1513 StringUtils::HexToByteVector("0891683110206005F0240DA1688176251308F4000832500381459323044F60597D");
1514 ShortMessage *message = new ShortMessage();
1515 if (message == nullptr) {
1516 helper.SetIntResult(1);
1517 helper.NotifyAll();
1518 return;
1519 }
1520 int result = ShortMessage::CreateMessage(pdu, u"3gpp", *message);
1521 helper.SetIntResult(result);
1522 helper.NotifyAll();
1523 }
1524
1525 /**
1526 * @tc.number Telephony_SmsMmsGtest_CreateUcs2DeliverySms_0001
1527 * @tc.name Create Ucs2 Delivery Sms
1528 * @tc.desc Function test
1529 */
1530 HWTEST_F(SmsGtest, CreateUcs2DeliverySms_0001, Function | MediumTest | Level2)
1531 {
1532 AccessMmsToken token;
1533 TELEPHONY_LOGI("TelSMSMMSTest::CreateUcs2DeliverySms_0001 -->");
1534 if (!(SmsGtest::HasSimCard(DEFAULT_SIM_SLOT_ID))) {
1535 TELEPHONY_LOGI("TelephonyTestService has no sim card");
1536 ASSERT_TRUE(true);
1537 return;
1538 }
1539 SmsMmsTestHelper helper;
1540 helper.slotId = DEFAULT_SIM_SLOT_ID;
1541 if (!helper.Run(CreateUcs2DeliverySmsTestFuc, std::ref(helper))) {
1542 TELEPHONY_LOGI("CreateUcs2DeliverySmsTestFuc out of time");
1543 ASSERT_TRUE(false);
1544 return;
1545 }
1546 TELEPHONY_LOGI("TelSMSMMSTest::CreateUcs2DeliverySms_0001 -->finished");
1547 ASSERT_EQ(helper.GetIntResult(), 0);
1548 }
1549
1550 /**
1551 * @tc.number Telephony_SmsMmsGtest_CreateUcs2DeliverySms_0002
1552 * @tc.name Create Ucs2 Delivery Sms
1553 * @tc.desc Function test
1554 */
1555 HWTEST_F(SmsGtest, CreateUcs2DeliverySms_0002, Function | MediumTest | Level2)
1556 {
1557 AccessMmsToken token;
1558 TELEPHONY_LOGI("TelSMSMMSTest::CreateUcs2DeliverySms_0002 -->");
1559 if (!(SmsGtest::HasSimCard(DEFAULT_SIM_SLOT_ID_1))) {
1560 TELEPHONY_LOGI("TelephonyTestService has no sim card");
1561 ASSERT_TRUE(true);
1562 return;
1563 }
1564 SmsMmsTestHelper helper;
1565 helper.slotId = DEFAULT_SIM_SLOT_ID_1;
1566 if (!helper.Run(CreateUcs2DeliverySmsTestFuc, std::ref(helper))) {
1567 TELEPHONY_LOGI("CreateUcs2DeliverySmsTestFuc out of time");
1568 ASSERT_TRUE(false);
1569 return;
1570 }
1571 TELEPHONY_LOGI("TelSMSMMSTest::CreateUcs2DeliverySms_0002 -->finished");
1572 ASSERT_EQ(helper.GetIntResult(), 0);
1573 }
1574
CreateStatusReportSmsTestFuc(SmsMmsTestHelper & helper)1575 void CreateStatusReportSmsTestFuc(SmsMmsTestHelper &helper)
1576 {
1577 std::vector<unsigned char> pdu =
1578 StringUtils::HexToByteVector("0891683110808805F006510B818176251308F4325013113382233250131143802300");
1579 ShortMessage *message = new ShortMessage();
1580 if (message == nullptr) {
1581 helper.SetIntResult(1);
1582 helper.NotifyAll();
1583 return;
1584 }
1585 int result = ShortMessage::CreateMessage(pdu, u"3gpp", *message);
1586 helper.SetIntResult(result);
1587 helper.NotifyAll();
1588 }
1589
1590 /**
1591 * @tc.number Telephony_SmsMmsGtest_CreateStatusReportSms_0001
1592 * @tc.name Create Status Report Sms
1593 * @tc.desc Function test
1594 */
1595 HWTEST_F(SmsGtest, CreateStatusReportSms_0001, Function | MediumTest | Level2)
1596 {
1597 AccessMmsToken token;
1598 TELEPHONY_LOGI("TelSMSMMSTest::CreateStatusReportSms_0001 -->");
1599 if (!(SmsGtest::HasSimCard(DEFAULT_SIM_SLOT_ID))) {
1600 TELEPHONY_LOGI("TelephonyTestService has no sim card");
1601 ASSERT_TRUE(true);
1602 return;
1603 }
1604 SmsMmsTestHelper helper;
1605 helper.slotId = DEFAULT_SIM_SLOT_ID;
1606 if (!helper.Run(CreateStatusReportSmsTestFuc, std::ref(helper))) {
1607 TELEPHONY_LOGI("CreateStatusReportSmsTestFuc out of time");
1608 ASSERT_TRUE(false);
1609 return;
1610 }
1611 TELEPHONY_LOGI("TelSMSMMSTest::CreateStatusReportSms_0001 -->finished");
1612 ASSERT_EQ(helper.GetIntResult(), 0);
1613 }
1614
1615 /**
1616 * @tc.number Telephony_SmsMmsGtest_CreateStatusReportSms_0002
1617 * @tc.name Create Status Report Sms
1618 * @tc.desc Function test
1619 */
1620 HWTEST_F(SmsGtest, CreateStatusReportSms_0002, Function | MediumTest | Level2)
1621 {
1622 AccessMmsToken token;
1623 TELEPHONY_LOGI("TelSMSMMSTest::CreateStatusReportSms_0002 -->");
1624 if (!(SmsGtest::HasSimCard(DEFAULT_SIM_SLOT_ID_1))) {
1625 TELEPHONY_LOGI("TelephonyTestService has no sim card");
1626 ASSERT_TRUE(true);
1627 return;
1628 }
1629 SmsMmsTestHelper helper;
1630 helper.slotId = DEFAULT_SIM_SLOT_ID_1;
1631 if (!helper.Run(CreateStatusReportSmsTestFuc, std::ref(helper))) {
1632 TELEPHONY_LOGI("CreateStatusReportSmsTestFuc out of time");
1633 ASSERT_TRUE(false);
1634 return;
1635 }
1636 TELEPHONY_LOGI("TelSMSMMSTest::CreateStatusReportSms_0002 -->finished");
1637 ASSERT_EQ(helper.GetIntResult(), 0);
1638 }
1639
CreateMultiPageSmsTestFuc(SmsMmsTestHelper & helper)1640 void CreateMultiPageSmsTestFuc(SmsMmsTestHelper &helper)
1641 {
1642 std::vector<unsigned char> pdu = StringUtils::HexToByteVector(
1643 "0891683110205005F06005A00110F00008325052214182238C050003D3030200310030002E0063006E002F007100410053004B00380020"
1644 "FF0C4EE5514D6B216708521D6263966476F851738D397528540E5F7154CD60A876846B635E384F7F752830024E2D56FD8054901A004100"
1645 "5000507545723D65B04F539A8CFF0C70B951FB0020002000680074007400700073003A002F002F0075002E00310030003000310030002"
1646 "E");
1647
1648 ShortMessage *message = new ShortMessage();
1649 if (message == nullptr) {
1650 helper.SetIntResult(1);
1651 helper.NotifyAll();
1652 return;
1653 }
1654 int result = ShortMessage::CreateMessage(pdu, u"3gpp", *message);
1655 helper.SetIntResult(result);
1656 helper.NotifyAll();
1657 }
1658
1659 /**
1660 * @tc.number Telephony_SmsMmsGtest_CreateMultiPageSms_0001
1661 * @tc.name Create MultiPage Sms
1662 * @tc.desc Function test
1663 */
1664 HWTEST_F(SmsGtest, CreateMultiPageSms_0001, Function | MediumTest | Level2)
1665 {
1666 AccessMmsToken token;
1667 TELEPHONY_LOGI("TelSMSMMSTest::CreateMultiPageSms_0001 -->");
1668 if (!(SmsGtest::HasSimCard(DEFAULT_SIM_SLOT_ID))) {
1669 TELEPHONY_LOGI("TelephonyTestService has no sim card");
1670 ASSERT_TRUE(true);
1671 return;
1672 }
1673 SmsMmsTestHelper helper;
1674 helper.slotId = DEFAULT_SIM_SLOT_ID;
1675 if (!helper.Run(CreateMultiPageSmsTestFuc, std::ref(helper))) {
1676 TELEPHONY_LOGI("CreateMultiPageSmsTestFuc out of time");
1677 ASSERT_TRUE(false);
1678 return;
1679 }
1680 TELEPHONY_LOGI("TelSMSMMSTest::CreateMultiPageSms_0001 -->finished");
1681 ASSERT_EQ(helper.GetIntResult(), 0);
1682 }
1683
1684 /**
1685 * @tc.number Telephony_SmsMmsGtest_CreateMultiPageSms_0002
1686 * @tc.name Create MultiPage Sms
1687 * @tc.desc Function test
1688 */
1689 HWTEST_F(SmsGtest, CreateMultiPageSms_0002, Function | MediumTest | Level2)
1690 {
1691 AccessMmsToken token;
1692 TELEPHONY_LOGI("TelSMSMMSTest::CreateMultiPageSms_0002 -->");
1693 if (!(SmsGtest::HasSimCard(DEFAULT_SIM_SLOT_ID_1))) {
1694 TELEPHONY_LOGI("TelephonyTestService has no sim card");
1695 ASSERT_TRUE(true);
1696 return;
1697 }
1698 SmsMmsTestHelper helper;
1699 helper.slotId = DEFAULT_SIM_SLOT_ID_1;
1700 if (!helper.Run(CreateMultiPageSmsTestFuc, std::ref(helper))) {
1701 TELEPHONY_LOGI("CreateMultiPageSmsTestFuc out of time");
1702 ASSERT_TRUE(false);
1703 return;
1704 }
1705 TELEPHONY_LOGI("TelSMSMMSTest::CreateMultiPageSms_0002 -->finished");
1706 ASSERT_EQ(helper.GetIntResult(), 0);
1707 }
1708
CreateWapPushSmsTestFuc(SmsMmsTestHelper & helper)1709 void CreateWapPushSmsTestFuc(SmsMmsTestHelper &helper)
1710 {
1711 std::vector<unsigned char> pdu = StringUtils::HexToByteVector("21010B818176251308F4000002C130");
1712 ShortMessage *message = new ShortMessage();
1713 if (message == nullptr) {
1714 helper.SetIntResult(1);
1715 helper.NotifyAll();
1716 return;
1717 }
1718 int result = ShortMessage::CreateMessage(pdu, u"3gpp", *message);
1719 helper.SetIntResult(result);
1720 helper.NotifyAll();
1721 }
1722
1723 /**
1724 * @tc.number Telephony_SmsMmsGtest_CreateWapPushSms_0001
1725 * @tc.name Create WapPush Sms
1726 * @tc.desc Function test
1727 */
1728 HWTEST_F(SmsGtest, CreateWapPushSms_0001, Function | MediumTest | Level2)
1729 {
1730 AccessMmsToken token;
1731 TELEPHONY_LOGI("TelSMSMMSTest::CreateWapPushSms_0001 -->");
1732 if (!(SmsGtest::HasSimCard(DEFAULT_SIM_SLOT_ID))) {
1733 TELEPHONY_LOGI("TelephonyTestService has no sim card");
1734 ASSERT_TRUE(true);
1735 return;
1736 }
1737 SmsMmsTestHelper helper;
1738 helper.slotId = DEFAULT_SIM_SLOT_ID;
1739 if (!helper.Run(CreateWapPushSmsTestFuc, std::ref(helper))) {
1740 TELEPHONY_LOGI("CreateWapPushSmsTestFuc out of time");
1741 ASSERT_TRUE(false);
1742 return;
1743 }
1744 TELEPHONY_LOGI("TelSMSMMSTest::CreateWapPushSms_0001 -->finished");
1745 ASSERT_EQ(helper.GetIntResult(), 0);
1746 }
1747
1748 /**
1749 * @tc.number Telephony_SmsMmsGtest_CreateWapPushSms_0002
1750 * @tc.name Create WapPush Sms
1751 * @tc.desc Function test
1752 */
1753 HWTEST_F(SmsGtest, CreateWapPushSms_0002, Function | MediumTest | Level2)
1754 {
1755 AccessMmsToken token;
1756 TELEPHONY_LOGI("TelSMSMMSTest::CreateWapPushSms_0002 -->");
1757 if (!(SmsGtest::HasSimCard(DEFAULT_SIM_SLOT_ID_1))) {
1758 TELEPHONY_LOGI("TelephonyTestService has no sim card");
1759 ASSERT_TRUE(true);
1760 return;
1761 }
1762 SmsMmsTestHelper helper;
1763 helper.slotId = DEFAULT_SIM_SLOT_ID_1;
1764 if (!helper.Run(CreateWapPushSmsTestFuc, std::ref(helper))) {
1765 TELEPHONY_LOGI("CreateWapPushSmsTestFuc out of time");
1766 ASSERT_TRUE(false);
1767 return;
1768 }
1769 TELEPHONY_LOGI("TelSMSMMSTest::CreateWapPushSms_0002 -->finished");
1770 ASSERT_EQ(helper.GetIntResult(), 0);
1771 }
1772
1773 /**
1774 * @tc.number Sms_TestDump_0100
1775 * @tc.name TestDump
1776 * @tc.desc Function test
1777 */
1778 HWTEST_F(SmsGtest, Sms_TestDump_0001, Function | MediumTest | Level3)
1779 {
1780 std::vector<std::u16string> emptyArgs = {};
1781 std::vector<std::u16string> args = { u"test", u"test1" };
1782 EXPECT_GE(DelayedSingleton<SmsService>::GetInstance()->Dump(-1, args), 0);
1783 EXPECT_GE(DelayedSingleton<SmsService>::GetInstance()->Dump(0, emptyArgs), 0);
1784 EXPECT_GE(DelayedSingleton<SmsService>::GetInstance()->Dump(0, args), 0);
1785 }
1786 #else // TEL_TEST_UNSUPPORT
1787 /**
1788 * @tc.number Telephony_SmsMms_MockTest_0001
1789 * @tc.name Mock test for unsupported platform
1790 * @tc.desc Function test
1791 */
1792 HWTEST_F(SmsGtest, MockTest_0001, Function | MediumTest | Level3)
1793 {
1794 ASSERT_TRUE(true);
1795 }
1796 #endif // TEL_TEST_UNSUPPORT
1797 } // namespace Telephony
1798 } // namespace OHOS