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