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     Singleton<SmsServiceManagerClient>::GetInstance().ResetSmsServiceProxy();
88     Singleton<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  */
HWTEST_F(SmsGtest, GetProxy_0001, Function | MediumTest | Level0)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 = Singleton<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  */
HWTEST_F(SmsGtest, SetDefaultSmsSlotId_0001, Function | MediumTest | Level2)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_FALSE(SmsGtest::HasSimCard(DEFAULT_SIM_SLOT_ID));
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(helper.Run(SetDefaultSmsSlotIdTestFucWithToken, std::ref(helper)));
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  */
HWTEST_F(SmsGtest, SetDefaultSmsSlotId_0002, Function | MediumTest | Level2)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_FALSE(SmsGtest::HasSimCard(DEFAULT_SIM_SLOT_ID_1));
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(helper.Run(SetDefaultSmsSlotIdTestFucWithToken, std::ref(helper)));
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  */
HWTEST_F(SmsGtest, SetDefaultSmsSlotId_0003, Function | MediumTest | Level2)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_FALSE(SmsGtest::HasSimCard(DEFAULT_SIM_SLOT_ID));
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(helper.Run(SetDefaultSmsSlotIdTestFuc, std::ref(helper)));
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 = Singleton<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  */
HWTEST_F(SmsGtest, GetDefaultSmsSlotId_0001, Function | MediumTest | Level2)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_FALSE(SmsGtest::HasSimCard(DEFAULT_SIM_SLOT_ID));
219         return;
220     }
221     SmsMmsTestHelper helper;
222     if (!helper.Run(GetDefaultSmsSlotIdTestFuc, std::ref(helper))) {
223         TELEPHONY_LOGI("GetDefaultSmsSlotIdTestFuc out of time");
224         ASSERT_FALSE(helper.Run(GetDefaultSmsSlotIdTestFuc, std::ref(helper)));
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     Singleton<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  */
HWTEST_F(SmsGtest, GetDefaultSmsSimId_0001, Function | MediumTest | Level2)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_FALSE(SmsGtest::HasSimCard(DEFAULT_SIM_SLOT_ID));
249         return;
250     }
251     SmsMmsTestHelper helper;
252     if (!helper.Run(GetDefaultSmsSimIdTestFuc, std::ref(helper))) {
253         TELEPHONY_LOGI("GetDefaultSmsSimIdTestFuc out of time");
254         ASSERT_FALSE(helper.Run(GetDefaultSmsSimIdTestFuc, std::ref(helper)));
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  */
HWTEST_F(SmsGtest, GetDefaultSmsSimId_0002, Function | MediumTest | Level2)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_FALSE(SmsGtest::HasSimCard(DEFAULT_SIM_SLOT_ID));
271         return;
272     }
273     SmsMmsTestHelper helper;
274     if (!helper.Run(GetDefaultSmsSimIdTestFuc, std::ref(helper))) {
275         TELEPHONY_LOGI("GetDefaultSmsSimIdTestFuc out of time");
276         ASSERT_FALSE(helper.Run(GetDefaultSmsSimIdTestFuc, std::ref(helper)));
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 = Singleton<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  */
HWTEST_F(SmsGtest, SetSmscAddr_0001, Function | MediumTest | Level2)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_FALSE(SmsGtest::HasSimCard(DEFAULT_SIM_SLOT_ID));
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(helper.Run(SetSmscAddrTestFucWithToken, std::ref(helper)));
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  */
HWTEST_F(SmsGtest, SetSmscAddr_0002, Function | MediumTest | Level2)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_FALSE(SmsGtest::HasSimCard(DEFAULT_SIM_SLOT_ID_1));
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(helper.Run(SetSmscAddrTestFuc, std::ref(helper)));
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     Singleton<SmsServiceManagerClient>::GetInstance().GetAllSimMessages(helper.slotId, message);
351     for (auto msg : message) {
352         TELEPHONY_LOGI("DelAllSimMessagesTestFuc,index:%{public}d", msg.GetIndexOnSim());
353         Singleton<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  */
HWTEST_F(SmsGtest, DelAllSimMessages_0001, Function | MediumTest | Level3)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_FALSE(SmsGtest::HasSimCard(DEFAULT_SIM_SLOT_ID));
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(helper.Run(DelAllSimMessagesTestFuc, std::ref(helper), WAIT_TIME_LONG_SECOND));
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  */
HWTEST_F(SmsGtest, DelAllSimMessages_0002, Function | MediumTest | Level3)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_FALSE(SmsGtest::HasSimCard(DEFAULT_SIM_SLOT_ID_1));
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(helper.Run(DelAllSimMessagesTestFuc, std::ref(helper), WAIT_TIME_LONG_SECOND));
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 = Singleton<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  */
HWTEST_F(SmsGtest, AddSimMessage_0001, Function | MediumTest | Level3)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_FALSE(SmsGtest::HasSimCard(DEFAULT_SIM_SLOT_ID));
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(helper.Run(AddSimMessageTestFucWithToken, std::ref(helper)));
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  */
HWTEST_F(SmsGtest, AddSimMessage_0002, Function | MediumTest | Level3)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_FALSE(SmsGtest::HasSimCard(DEFAULT_SIM_SLOT_ID_1));
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(helper.Run(AddSimMessageTestFucWithToken, std::ref(helper)));
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  */
HWTEST_F(SmsGtest, AddSimMessage_0003, Function | MediumTest | Level3)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_FALSE(SmsGtest::HasSimCard(DEFAULT_SIM_SLOT_ID));
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(helper.Run(AddSimMessageTestFuc, std::ref(helper)));
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     Singleton<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  */
HWTEST_F(SmsGtest, GetAllSimMessages_0001, Function | MediumTest | Level3)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_FALSE(SmsGtest::HasSimCard(DEFAULT_SIM_SLOT_ID));
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(helper.Run(GetAllSimMessagesTestFucWithToken, std::ref(helper)));
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  */
HWTEST_F(SmsGtest, GetAllSimMessages_0002, Function | MediumTest | Level3)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_FALSE(SmsGtest::HasSimCard(DEFAULT_SIM_SLOT_ID_1));
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(helper.Run(GetAllSimMessagesTestFucWithToken, std::ref(helper)));
550     }
551     TELEPHONY_LOGI("TelSMSMMSTest::GetAllSimMessages_0002 -->finished");
552     EXPECT_GE(helper.GetBoolResult(), 0);
553 }
554 
UpdateSimMessageTestFuc(SmsMmsTestHelper &helper)555 void UpdateSimMessageTestFuc(SmsMmsTestHelper &helper)
556 {
557     uint32_t msgIndex = 0;
558     std::u16string smscData(u"");
559     std::u16string pduData(u"01000B818176251308F4000007E8B0BCFD76E701");
560     uint32_t status = 3;
561 
562     int32_t result = Singleton<SmsServiceManagerClient>::GetInstance().UpdateSimMessage(
563         helper.slotId, msgIndex, static_cast<ISmsServiceInterface::SimMessageStatus>(status), pduData, smscData);
564     helper.SetIntResult(result);
565     helper.NotifyAll();
566 }
567 
UpdateSimMessageTestFucWithToken(SmsMmsTestHelper &helper)568 void UpdateSimMessageTestFucWithToken(SmsMmsTestHelper &helper)
569 {
570     AccessMmsToken token;
571     UpdateSimMessageTestFuc(helper);
572 }
573 
574 /**
575  * @tc.number   Telephony_SmsMmsGtest_UpdateSimMessage_0001
576  * @tc.name     Update Sim Message
577  * @tc.desc     Function test
578  */
HWTEST_F(SmsGtest, UpdateSimMessage_0001, Function | MediumTest | Level3)579 HWTEST_F(SmsGtest, UpdateSimMessage_0001, Function | MediumTest | Level3)
580 {
581     TELEPHONY_LOGI("TelSMSMMSTest::UpdateSimMessage_0001 -->");
582     if (!(SmsGtest::HasSimCard(DEFAULT_SIM_SLOT_ID))) {
583         TELEPHONY_LOGI("TelephonyTestService has no sim card");
584         ASSERT_FALSE(SmsGtest::HasSimCard(DEFAULT_SIM_SLOT_ID));
585         return;
586     }
587     SmsMmsTestHelper helper;
588     helper.slotId = DEFAULT_SIM_SLOT_ID;
589     if (!helper.Run(UpdateSimMessageTestFucWithToken, std::ref(helper))) {
590         TELEPHONY_LOGI("UpdateSimMessageTestFucWithToken out of time");
591         ASSERT_TRUE(helper.Run(UpdateSimMessageTestFucWithToken, std::ref(helper)));
592     }
593     TELEPHONY_LOGI("TelSMSMMSTest::UpdateSimMessage_0001 -->finished");
594     ASSERT_GE(helper.GetIntResult(), 0);
595 }
596 
597 /**
598  * @tc.number   Telephony_SmsMmsGtest_UpdateSimMessage_0002
599  * @tc.name     Update Sim Message
600  * @tc.desc     Function test
601  * @tc.require: issueI5K12U
602  */
HWTEST_F(SmsGtest, UpdateSimMessage_0002, Function | MediumTest | Level3)603 HWTEST_F(SmsGtest, UpdateSimMessage_0002, Function | MediumTest | Level3)
604 {
605     TELEPHONY_LOGI("TelSMSMMSTest::UpdateSimMessage_0002 -->");
606     if (!(SmsGtest::HasSimCard(DEFAULT_SIM_SLOT_ID_1))) {
607         TELEPHONY_LOGI("TelephonyTestService has no sim card");
608         ASSERT_FALSE(SmsGtest::HasSimCard(DEFAULT_SIM_SLOT_ID_1));
609         return;
610     }
611     SmsMmsTestHelper helper;
612     helper.slotId = DEFAULT_SIM_SLOT_ID_1;
613     if (!helper.Run(UpdateSimMessageTestFucWithToken, std::ref(helper))) {
614         TELEPHONY_LOGI("UpdateSimMessageTestFucWithToken out of time");
615         ASSERT_TRUE(helper.Run(UpdateSimMessageTestFucWithToken, std::ref(helper)));
616     }
617     TELEPHONY_LOGI("TelSMSMMSTest::UpdateSimMessage_0002 -->finished");
618     ASSERT_GE(helper.GetIntResult(), 0);
619 }
620 
621 /**
622  * @tc.number   Telephony_SmsMmsGtest_UpdateSimMessage_0003
623  * @tc.name     Update Sim Message
624  * @tc.desc     Function test
625  */
HWTEST_F(SmsGtest, UpdateSimMessage_0003, Function | MediumTest | Level3)626 HWTEST_F(SmsGtest, UpdateSimMessage_0003, Function | MediumTest | Level3)
627 {
628     TELEPHONY_LOGI("TelSMSMMSTest::UpdateSimMessage_0003 -->");
629     if (!(SmsGtest::HasSimCard(DEFAULT_SIM_SLOT_ID))) {
630         TELEPHONY_LOGI("TelephonyTestService has no sim card");
631         ASSERT_FALSE(SmsGtest::HasSimCard(DEFAULT_SIM_SLOT_ID));
632         return;
633     }
634     SmsMmsTestHelper helper;
635     helper.slotId = DEFAULT_SIM_SLOT_ID;
636     if (!helper.Run(UpdateSimMessageTestFuc, std::ref(helper))) {
637         TELEPHONY_LOGI("UpdateSimMessageTestFuc out of time");
638         ASSERT_TRUE(helper.Run(UpdateSimMessageTestFuc, std::ref(helper)));
639     }
640     TELEPHONY_LOGI("TelSMSMMSTest::UpdateSimMessage_0003 -->finished");
641     EXPECT_NE(helper.GetIntResult(), 0);
642 }
643 
DelSimMessageTestFuc(SmsMmsTestHelper &helper)644 void DelSimMessageTestFuc(SmsMmsTestHelper &helper)
645 {
646     uint32_t msgIndex = 1;
647     int32_t result = Singleton<SmsServiceManagerClient>::GetInstance().DelSimMessage(helper.slotId, msgIndex);
648     helper.SetIntResult(result);
649     helper.NotifyAll();
650 }
651 
DelSimMessageTestFucWithToken(SmsMmsTestHelper &helper)652 void DelSimMessageTestFucWithToken(SmsMmsTestHelper &helper)
653 {
654     AccessMmsToken token;
655     DelSimMessageTestFuc(helper);
656 }
657 
658 /**
659  * @tc.number   Telephony_SmsMmsGtest_DelSimMessage_0001
660  * @tc.name     Del Sim Message
661  * @tc.desc     Function test
662  */
HWTEST_F(SmsGtest, DelSimMessage_0001, Function | MediumTest | Level3)663 HWTEST_F(SmsGtest, DelSimMessage_0001, Function | MediumTest | Level3)
664 {
665     TELEPHONY_LOGI("TelSMSMMSTest::DelSimMessage_0001 -->");
666     if (!(SmsGtest::HasSimCard(DEFAULT_SIM_SLOT_ID))) {
667         TELEPHONY_LOGI("TelephonyTestService has no sim card");
668         ASSERT_FALSE(SmsGtest::HasSimCard(DEFAULT_SIM_SLOT_ID));
669         return;
670     }
671     SmsMmsTestHelper helper;
672     helper.slotId = DEFAULT_SIM_SLOT_ID;
673     if (!helper.Run(DelSimMessageTestFucWithToken, std::ref(helper))) {
674         TELEPHONY_LOGI("DelSimMessageTestFucWithToken out of time");
675         ASSERT_TRUE(helper.Run(DelSimMessageTestFucWithToken, std::ref(helper)));
676     }
677     TELEPHONY_LOGI("TelSMSMMSTest::DelSimMessage_0001 -->finished");
678     ASSERT_GE(helper.GetIntResult(), 0);
679 }
680 
681 /**
682  * @tc.number   Telephony_SmsMmsGtest_DelSimMessage_0002
683  * @tc.name     Del Sim Message
684  * @tc.desc     Function test
685  */
HWTEST_F(SmsGtest, DelSimMessage_0002, Function | MediumTest | Level3)686 HWTEST_F(SmsGtest, DelSimMessage_0002, Function | MediumTest | Level3)
687 {
688     TELEPHONY_LOGI("TelSMSMMSTest::DelSimMessage_0002 -->");
689     if (!(SmsGtest::HasSimCard(DEFAULT_SIM_SLOT_ID_1))) {
690         TELEPHONY_LOGI("TelephonyTestService has no sim card");
691         ASSERT_FALSE(SmsGtest::HasSimCard(DEFAULT_SIM_SLOT_ID_1));
692         return;
693     }
694     SmsMmsTestHelper helper;
695     helper.slotId = DEFAULT_SIM_SLOT_ID_1;
696     if (!helper.Run(DelSimMessageTestFucWithToken, std::ref(helper))) {
697         TELEPHONY_LOGI("DelSimMessageTestFucWithToken out of time");
698         ASSERT_TRUE(helper.Run(DelSimMessageTestFucWithToken, std::ref(helper)));
699     }
700     TELEPHONY_LOGI("TelSMSMMSTest::DelSimMessage_0002 -->finished");
701     ASSERT_GE(helper.GetIntResult(), 0);
702 }
703 
704 /**
705  * @tc.number   Telephony_SmsMmsGtest_DelSimMessage_0003
706  * @tc.name     Del Sim Message
707  * @tc.desc     Function test
708  */
HWTEST_F(SmsGtest, DelSimMessage_0003, Function | MediumTest | Level3)709 HWTEST_F(SmsGtest, DelSimMessage_0003, Function | MediumTest | Level3)
710 {
711     TELEPHONY_LOGI("TelSMSMMSTest::DelSimMessage_0003 -->");
712     if (!(SmsGtest::HasSimCard(DEFAULT_SIM_SLOT_ID))) {
713         TELEPHONY_LOGI("TelephonyTestService has no sim card");
714         ASSERT_FALSE(SmsGtest::HasSimCard(DEFAULT_SIM_SLOT_ID));
715         return;
716     }
717     SmsMmsTestHelper helper;
718     helper.slotId = DEFAULT_SIM_SLOT_ID;
719     if (!helper.Run(DelSimMessageTestFuc, std::ref(helper))) {
720         TELEPHONY_LOGI("DelSimMessageTestFuc out of time");
721         ASSERT_TRUE(helper.Run(DelSimMessageTestFuc, std::ref(helper)));
722     }
723     TELEPHONY_LOGI("TelSMSMMSTest::DelSimMessage_0003 -->finished");
724     EXPECT_NE(helper.GetIntResult(), 0);
725 }
726 
SetImsSmsConfigTestFuc(SmsMmsTestHelper &helper)727 void SetImsSmsConfigTestFuc(SmsMmsTestHelper &helper)
728 {
729     Singleton<SmsServiceManagerClient>::GetInstance().SetImsSmsConfig(helper.slotId, 1);
730     bool isSupported = false;
731     Singleton<SmsServiceManagerClient>::GetInstance().IsImsSmsSupported(helper.slotId, isSupported);
732     helper.SetBoolResult(isSupported);
733     helper.NotifyAll();
734 }
735 
SetImsSmsConfigTestFucWithToken(SmsMmsTestHelper &helper)736 void SetImsSmsConfigTestFucWithToken(SmsMmsTestHelper &helper)
737 {
738     AccessMmsToken token;
739     SetImsSmsConfigTestFuc(helper);
740 }
741 
742 /**
743  * @tc.number   Telephony_SmsMmsGtest_SetImsSmsConfig_0001
744  * @tc.name     Enable IMS SMS
745  * @tc.desc     Function test
746  * @tc.require: issueI5K12U
747  */
HWTEST_F(SmsGtest, SetImsSmsConfig_0001, Function | MediumTest | Level2)748 HWTEST_F(SmsGtest, SetImsSmsConfig_0001, Function | MediumTest | Level2)
749 {
750     TELEPHONY_LOGI("TelSMSMMSTest::SetImsSmsConfig_0001 -->");
751     if (!(SmsGtest::HasSimCard(DEFAULT_SIM_SLOT_ID))) {
752         TELEPHONY_LOGI("TelephonyTestService has no sim card");
753         ASSERT_FALSE(SmsGtest::HasSimCard(DEFAULT_SIM_SLOT_ID));
754         return;
755     }
756     SmsMmsTestHelper helper;
757     helper.slotId = DEFAULT_SIM_SLOT_ID;
758     if (!helper.Run(SetImsSmsConfigTestFucWithToken, std::ref(helper))) {
759         TELEPHONY_LOGI("SetImsSmsConfigTestFucWithToken out of time");
760         ASSERT_TRUE(helper.Run(SetImsSmsConfigTestFucWithToken, std::ref(helper)));
761     }
762     TELEPHONY_LOGI("TelSMSMMSTest::SetImsSmsConfig_0001 -->finished");
763     ASSERT_TRUE(helper.GetBoolResult());
764 }
765 
SetImsSmsConfigTestFuc2(SmsMmsTestHelper &helper)766 void SetImsSmsConfigTestFuc2(SmsMmsTestHelper &helper)
767 {
768     AccessMmsToken token;
769     bool isSupported = false;
770     Singleton<SmsServiceManagerClient>::GetInstance().SetImsSmsConfig(helper.slotId, 0);
771     Singleton<SmsServiceManagerClient>::GetInstance().IsImsSmsSupported(helper.slotId, isSupported);
772     helper.SetBoolResult(isSupported);
773     helper.NotifyAll();
774 }
775 
776 /**
777  * @tc.number   Telephony_SmsMmsGtest_SetImsSmsConfig_0002
778  * @tc.name     Disable Ims Sms
779  * @tc.desc     Function test
780  * @tc.require: issueI5K12U
781  */
HWTEST_F(SmsGtest, SetImsSmsConfig_0002, Function | MediumTest | Level2)782 HWTEST_F(SmsGtest, SetImsSmsConfig_0002, Function | MediumTest | Level2)
783 {
784     TELEPHONY_LOGI("TelSMSMMSTest::SetImsSmsConfig_0002 -->");
785     if (!(SmsGtest::HasSimCard(DEFAULT_SIM_SLOT_ID))) {
786         TELEPHONY_LOGI("TelephonyTestService has no sim card");
787         ASSERT_FALSE(SmsGtest::HasSimCard(DEFAULT_SIM_SLOT_ID));
788         return;
789     }
790     SmsMmsTestHelper helper;
791     helper.slotId = DEFAULT_SIM_SLOT_ID;
792     if (!helper.Run(SetImsSmsConfigTestFuc2, std::ref(helper))) {
793         TELEPHONY_LOGI("SetImsSmsConfigTestFuc2 out of time");
794         ASSERT_TRUE(helper.Run(SetImsSmsConfigTestFuc2, std::ref(helper)));
795     }
796     TELEPHONY_LOGI("TelSMSMMSTest::SetImsSmsConfig_0002 -->finished");
797     EXPECT_GE(helper.GetBoolResult(), 0);
798 }
799 
800 /**
801  * @tc.number   Telephony_SmsMmsGtest_SetImsSmsConfig_0003
802  * @tc.name     Enable IMS SMS
803  * @tc.desc     Function test
804  * @tc.require: issueI5K12U
805  */
HWTEST_F(SmsGtest, SetImsSmsConfig_0003, Function | MediumTest | Level2)806 HWTEST_F(SmsGtest, SetImsSmsConfig_0003, Function | MediumTest | Level2)
807 {
808     TELEPHONY_LOGI("TelSMSMMSTest::SetImsSmsConfig_0003 -->");
809     if (!(SmsGtest::HasSimCard(DEFAULT_SIM_SLOT_ID_1))) {
810         TELEPHONY_LOGI("TelephonyTestService has no sim card");
811         ASSERT_FALSE(SmsGtest::HasSimCard(DEFAULT_SIM_SLOT_ID_1));
812         return;
813     }
814     SmsMmsTestHelper helper;
815     helper.slotId = DEFAULT_SIM_SLOT_ID_1;
816     if (!helper.Run(SetImsSmsConfigTestFucWithToken, std::ref(helper))) {
817         TELEPHONY_LOGI("SetImsSmsConfigTestFucWithToken out of time");
818         ASSERT_TRUE(helper.Run(SetImsSmsConfigTestFucWithToken, std::ref(helper)));
819     }
820     TELEPHONY_LOGI("TelSMSMMSTest::SetImsSmsConfig_0003 -->finished");
821     ASSERT_TRUE(helper.GetBoolResult());
822 }
823 
824 /**
825  * @tc.number   Telephony_SmsMmsGtest_SetImsSmsConfig_0004
826  * @tc.name     Disable Ims Sms
827  * @tc.desc     Function test
828  */
HWTEST_F(SmsGtest, SetImsSmsConfig_0004, Function | MediumTest | Level2)829 HWTEST_F(SmsGtest, SetImsSmsConfig_0004, Function | MediumTest | Level2)
830 {
831     TELEPHONY_LOGI("TelSMSMMSTest::SetImsSmsConfig_0004 -->");
832     if (!(SmsGtest::HasSimCard(DEFAULT_SIM_SLOT_ID_1))) {
833         TELEPHONY_LOGI("TelephonyTestService has no sim card");
834         ASSERT_FALSE(SmsGtest::HasSimCard(DEFAULT_SIM_SLOT_ID_1));
835         return;
836     }
837     SmsMmsTestHelper helper;
838     helper.slotId = DEFAULT_SIM_SLOT_ID_1;
839     if (!helper.Run(SetImsSmsConfigTestFuc2, std::ref(helper))) {
840         TELEPHONY_LOGI("SetImsSmsConfigTestFuc4 out of time");
841         ASSERT_TRUE(helper.Run(SetImsSmsConfigTestFuc2, std::ref(helper)));
842     }
843     TELEPHONY_LOGI("TelSMSMMSTest::SetImsSmsConfig_0004 -->finished");
844     EXPECT_FALSE(helper.GetBoolResult());
845 }
846 
847 /**
848  * @tc.number   Telephony_SmsMmsGtest_SetImsSmsConfig_0005
849  * @tc.name     Enable IMS SMS
850  * @tc.desc     Function test
851  * @tc.require: issueI5K12U
852  */
HWTEST_F(SmsGtest, SetImsSmsConfig_0005, Function | MediumTest | Level2)853 HWTEST_F(SmsGtest, SetImsSmsConfig_0005, Function | MediumTest | Level2)
854 {
855     TELEPHONY_LOGI("TelSMSMMSTest::SetImsSmsConfig_0005 -->");
856     if (!(SmsGtest::HasSimCard(DEFAULT_SIM_SLOT_ID))) {
857         TELEPHONY_LOGI("TelephonyTestService has no sim card");
858         ASSERT_FALSE(SmsGtest::HasSimCard(DEFAULT_SIM_SLOT_ID));
859         return;
860     }
861     SmsMmsTestHelper helper;
862     helper.slotId = DEFAULT_SIM_SLOT_ID;
863     if (!helper.Run(SetImsSmsConfigTestFuc, std::ref(helper))) {
864         TELEPHONY_LOGI("SetImsSmsConfigTestFuc out of time");
865         ASSERT_TRUE(helper.Run(SetImsSmsConfigTestFuc, std::ref(helper)));
866     }
867     TELEPHONY_LOGI("TelSMSMMSTest::SetImsSmsConfig_0005 -->finished");
868     EXPECT_GE(helper.GetBoolResult(), 0);
869 }
870 
SendDataMessageTestFuc(SmsMmsTestHelper &helper)871 void SendDataMessageTestFuc(SmsMmsTestHelper &helper)
872 {
873     AccessMmsToken token;
874     std::string dest = DES_ADDR;
875     std::u16string simcardNumber;
876     if (!CoreServiceClient::GetInstance().GetSimTelephoneNumber(helper.slotId, simcardNumber) &&
877         !simcardNumber.empty()) {
878         dest = StringUtils::ToUtf8(simcardNumber);
879     }
880 
881     std::string sca("");
882     OHOS::sptr<SmsSendCallbackGTest> sendCallBackPtr(new SmsSendCallbackGTest(helper));
883     OHOS::sptr<SmsDeliveryCallbackGTest> deliveryCallBackPtr(new SmsDeliveryCallbackGTest(helper));
884     uint16_t port = SMS_PORT;
885     if (sendCallBackPtr == nullptr) {
886         TELEPHONY_LOGI("sendCallBackPtr is nullptr");
887         helper.NotifyAll();
888     }
889 
890     if (deliveryCallBackPtr == nullptr) {
891         TELEPHONY_LOGI("deliveryCallBackPtr is nullptr");
892         helper.NotifyAll();
893     }
894     sendCallBackPtr->HasDeliveryCallBack(true);
895     Singleton<SmsServiceManagerClient>::GetInstance().SendMessage(helper.slotId, StringUtils::ToUtf16(dest),
896         StringUtils::ToUtf16(sca), port, DATA_SMS, (sizeof(DATA_SMS) / sizeof(DATA_SMS[0]) - 1), sendCallBackPtr,
897         deliveryCallBackPtr);
898 }
899 
SendDataMessageTestFuc2(SmsMmsTestHelper &helper)900 void SendDataMessageTestFuc2(SmsMmsTestHelper &helper)
901 {
902     std::u16string simcardNumber;
903     std::string dest = DES_ADDR;
904     if (!CoreServiceClient::GetInstance().GetSimTelephoneNumber(helper.slotId, simcardNumber) &&
905         !simcardNumber.empty()) {
906         dest = StringUtils::ToUtf8(simcardNumber);
907     }
908 
909     std::string sca("");
910     OHOS::sptr<SmsSendCallbackGTest> sendCallBackPtr(new SmsSendCallbackGTest(helper));
911     OHOS::sptr<SmsDeliveryCallbackGTest> deliveryCallBackPtr(new SmsDeliveryCallbackGTest(helper));
912     uint16_t port = SMS_PORT;
913     if (sendCallBackPtr == nullptr) {
914         TELEPHONY_LOGI("sendCallBackPtr is nullptr");
915         helper.NotifyAll();
916     }
917 
918     if (deliveryCallBackPtr == nullptr) {
919         TELEPHONY_LOGI("deliveryCallBackPtr is nullptr");
920         helper.NotifyAll();
921     }
922     sendCallBackPtr->HasDeliveryCallBack(false);
923     Singleton<SmsServiceManagerClient>::GetInstance().SendMessage(helper.slotId, StringUtils::ToUtf16(dest),
924         StringUtils::ToUtf16(sca), port, DATA_SMS, (sizeof(DATA_SMS) / sizeof(DATA_SMS[0]) - 1), sendCallBackPtr,
925         deliveryCallBackPtr);
926 }
927 
928 /**
929  * @tc.number   Telephony_SmsMmsGtest_SendDataMessage_0001
930  * @tc.name     Send Data Sms
931  * @tc.desc     Function test
932  */
HWTEST_F(SmsGtest, SendDataMessage_0001, Function | MediumTest | Level2)933 HWTEST_F(SmsGtest, SendDataMessage_0001, Function | MediumTest | Level2)
934 {
935     TELEPHONY_LOGI("TelSMSMMSTest::SendDataMessage_0001 -->");
936     int32_t slotId = DEFAULT_SIM_SLOT_ID;
937     if (!(SmsGtest::HasSimCard(slotId))) {
938         TELEPHONY_LOGI("TelephonyTestService has no sim card");
939         ASSERT_FALSE(SmsGtest::HasSimCard(DEFAULT_SIM_SLOT_ID));
940         return;
941     }
942     SmsMmsTestHelper helper;
943     helper.slotId = slotId;
944     if (!helper.Run(SendDataMessageTestFuc, helper, WAIT_TIME_SHORT_SECOND)) {
945         TELEPHONY_LOGI("SendDataMessageTestFuc out of time");
946     }
947     TELEPHONY_LOGI("TelSMSMMSTest::SendDataMessage_0001 -->finished");
948     ASSERT_TRUE(helper.GetSendSmsIntResult() == 0 || helper.GetDeliverySmsIntResult() == 0);
949 }
950 
951 /**
952  * @tc.number   Telephony_SmsMmsGtest_SendDataMessage_0002
953  * @tc.name     Send Data Sms
954  * @tc.desc     Function test
955  */
HWTEST_F(SmsGtest, SendDataMessage_0002, Function | MediumTest | Level2)956 HWTEST_F(SmsGtest, SendDataMessage_0002, Function | MediumTest | Level2)
957 {
958     TELEPHONY_LOGI("TelSMSMMSTest::SendDataMessage_0002 -->");
959     int32_t slotId = DEFAULT_SIM_SLOT_ID_1;
960     if (!(SmsGtest::HasSimCard(slotId))) {
961         TELEPHONY_LOGI("TelephonyTestService has no sim card");
962         ASSERT_FALSE(SmsGtest::HasSimCard(DEFAULT_SIM_SLOT_ID));
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_0002 -->finished");
971     ASSERT_TRUE(helper.GetSendSmsIntResult() == 0 || helper.GetDeliverySmsIntResult() == 0);
972 }
973 
974 /**
975  * @tc.number   Telephony_SmsMmsGtest_SendDataMessage_0003
976  * @tc.name     Send Data Sms
977  * @tc.desc     Function test
978  */
HWTEST_F(SmsGtest, SendDataMessage_0003, Function | MediumTest | Level2)979 HWTEST_F(SmsGtest, SendDataMessage_0003, Function | MediumTest | Level2)
980 {
981     TELEPHONY_LOGI("TelSMSMMSTest::SendDataMessage_0003 -->");
982     int32_t slotId = DEFAULT_SIM_SLOT_ID;
983     if (!(SmsGtest::HasSimCard(slotId))) {
984         TELEPHONY_LOGI("TelephonyTestService has no sim card");
985         ASSERT_FALSE(SmsGtest::HasSimCard(DEFAULT_SIM_SLOT_ID));
986         return;
987     }
988     SmsMmsTestHelper helper;
989     helper.slotId = slotId;
990     if (!helper.Run(SendDataMessageTestFuc2, helper)) {
991         TELEPHONY_LOGI("SendDataMessageTestFuc out of time");
992         ASSERT_TRUE(helper.Run(SendDataMessageTestFuc2, helper));
993         return;
994     }
995     TELEPHONY_LOGI("TelSMSMMSTest::SendDataMessage_0003 -->finished");
996     EXPECT_NE(helper.GetSendSmsIntResult(), 0);
997 }
998 
SendTextMessageTestFuc(SmsMmsTestHelper &helper)999 void SendTextMessageTestFuc(SmsMmsTestHelper &helper)
1000 {
1001     AccessMmsToken token;
1002     std::string dest = DES_ADDR;
1003     std::u16string simcardNumber;
1004     if (!CoreServiceClient::GetInstance().GetSimTelephoneNumber(helper.slotId, simcardNumber) &&
1005         !simcardNumber.empty()) {
1006         dest = StringUtils::ToUtf8(simcardNumber);
1007     }
1008 
1009     std::string sca("");
1010     OHOS::sptr<SmsDeliveryCallbackGTest> deliveryCallBackPtr(new SmsDeliveryCallbackGTest(helper));
1011     OHOS::sptr<SmsSendCallbackGTest> sendCallBackPtr(new SmsSendCallbackGTest(helper));
1012     std::string text = TEXT_SMS_CONTENT;
1013     if (sendCallBackPtr == nullptr) {
1014         TELEPHONY_LOGI("sendCallBackPtr is nullptr");
1015         helper.NotifyAll();
1016         return;
1017     }
1018 
1019     if (deliveryCallBackPtr == nullptr) {
1020         TELEPHONY_LOGI("deliveryCallBackPtr is nullptr");
1021         helper.NotifyAll();
1022         return;
1023     }
1024     sendCallBackPtr->HasDeliveryCallBack(true);
1025     Singleton<SmsServiceManagerClient>::GetInstance().SendMessage(helper.slotId, StringUtils::ToUtf16(dest),
1026         StringUtils::ToUtf16(sca), StringUtils::ToUtf16(text), sendCallBackPtr, deliveryCallBackPtr);
1027 }
1028 
SendTextMessageTestFuc2(SmsMmsTestHelper &helper)1029 void SendTextMessageTestFuc2(SmsMmsTestHelper &helper)
1030 {
1031     std::u16string simcardNumber;
1032     std::string dest = DES_ADDR;
1033     if (!CoreServiceClient::GetInstance().GetSimTelephoneNumber(helper.slotId, simcardNumber) &&
1034         !simcardNumber.empty()) {
1035         dest = StringUtils::ToUtf8(simcardNumber);
1036     }
1037 
1038     std::string sca("");
1039     OHOS::sptr<SmsDeliveryCallbackGTest> deliveryCallBackPtr(new SmsDeliveryCallbackGTest(helper));
1040     OHOS::sptr<SmsSendCallbackGTest> sendCallBackPtr(new SmsSendCallbackGTest(helper));
1041     std::string text = TEXT_SMS_CONTENT;
1042     if (sendCallBackPtr == nullptr) {
1043         TELEPHONY_LOGI("sendCallBackPtr is nullptr");
1044         helper.NotifyAll();
1045         return;
1046     }
1047 
1048     if (deliveryCallBackPtr == nullptr) {
1049         TELEPHONY_LOGI("deliveryCallBackPtr is nullptr");
1050         helper.NotifyAll();
1051         return;
1052     }
1053     sendCallBackPtr->HasDeliveryCallBack(false);
1054     Singleton<SmsServiceManagerClient>::GetInstance().SendMessage(helper.slotId, StringUtils::ToUtf16(dest),
1055         StringUtils::ToUtf16(sca), StringUtils::ToUtf16(text), sendCallBackPtr, deliveryCallBackPtr);
1056 }
1057 
1058 /**
1059  * @tc.number   Telephony_SmsMmsGtest_SendTextMessage_0001
1060  * @tc.name     Send Text Sms
1061  * @tc.desc     Function test
1062  */
HWTEST_F(SmsGtest, SendTextMessage_0001, Function | MediumTest | Level2)1063 HWTEST_F(SmsGtest, SendTextMessage_0001, Function | MediumTest | Level2)
1064 {
1065     TELEPHONY_LOGI("TelSMSMMSTest::SendTextMessage_0001 -->");
1066     int32_t slotId = DEFAULT_SIM_SLOT_ID;
1067     if (!(SmsGtest::HasSimCard(slotId))) {
1068         TELEPHONY_LOGI("TelephonyTestService has no sim card");
1069         ASSERT_FALSE(SmsGtest::HasSimCard(slotId));
1070         return;
1071     }
1072     SmsMmsTestHelper helper;
1073     helper.slotId = slotId;
1074     if (!helper.Run(SendTextMessageTestFuc, helper, WAIT_TIME_SHORT_SECOND)) {
1075         TELEPHONY_LOGI("SendTextMessageTestFuc out of time");
1076     }
1077     TELEPHONY_LOGI("TelSMSMMSTest::SendTextMessage_0001 -->finished");
1078     ASSERT_TRUE(helper.GetSendSmsIntResult() == 0 || helper.GetDeliverySmsIntResult() == 0);
1079 }
1080 
1081 /**
1082  * @tc.number   Telephony_SmsMmsGtest_SendTextMessage_0002
1083  * @tc.name     Send Text Sms
1084  * @tc.desc     Function test
1085  */
HWTEST_F(SmsGtest, SendTextMessage_0002, Function | MediumTest | Level2)1086 HWTEST_F(SmsGtest, SendTextMessage_0002, Function | MediumTest | Level2)
1087 {
1088     TELEPHONY_LOGI("TelSMSMMSTest::SendTextMessage_0002 -->");
1089     int32_t slotId = DEFAULT_SIM_SLOT_ID_1;
1090     if (!(SmsGtest::HasSimCard(slotId))) {
1091         TELEPHONY_LOGI("TelephonyTestService has no sim card");
1092         ASSERT_FALSE(SmsGtest::HasSimCard(slotId));
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_0003
1106  * @tc.name     Send Text Sms
1107  * @tc.desc     Function test
1108  */
HWTEST_F(SmsGtest, SendTextMessage_0003, Function | MediumTest | Level2)1109 HWTEST_F(SmsGtest, SendTextMessage_0003, Function | MediumTest | Level2)
1110 {
1111     TELEPHONY_LOGI("TelSMSMMSTest::SendTextMessage_0003 -->");
1112     int32_t slotId = DEFAULT_SIM_SLOT_ID;
1113     if (!(SmsGtest::HasSimCard(slotId))) {
1114         TELEPHONY_LOGI("TelephonyTestService has no sim card");
1115         ASSERT_FALSE(SmsGtest::HasSimCard(slotId));
1116         return;
1117     }
1118     SmsMmsTestHelper helper;
1119     helper.slotId = slotId;
1120     if (!helper.Run(SendTextMessageTestFuc2, helper)) {
1121         TELEPHONY_LOGI("SendTextMessageTestFuc out of time");
1122         ASSERT_TRUE(helper.Run(SendTextMessageTestFuc2, helper));
1123         return;
1124     }
1125     TELEPHONY_LOGI("TelSMSMMSTest::SendTextMessage_0003 -->finished");
1126     EXPECT_NE(helper.GetSendSmsIntResult(), 0);
1127 }
1128 
ReceiveSmsTestFunc(SmsMmsTestHelper &helper)1129 void ReceiveSmsTestFunc(SmsMmsTestHelper &helper)
1130 {
1131     AccessMmsToken token;
1132     auto smsReceiveHandler = std::make_shared<GsmSmsReceiveHandler>(helper.slotId);
1133     auto message = std::make_shared<SmsMessageInfo>();
1134     message->indicationType = MESSAGE_TYPE;
1135     message->size = SMS_PDU_LEN;
1136     message->pdu =
1137         StringUtils::HexToByteVector("0891683110808805F0040D91686106571209F800003210921134922307D3F69C5A9ED301");
1138 
1139     AppExecFwk::InnerEvent::Pointer event = AppExecFwk::InnerEvent::Get(RadioEvent::RADIO_GSM_SMS, message);
1140     smsReceiveHandler->ProcessEvent(event);
1141 }
1142 
1143 /**
1144  * @tc.number   Telephony_SmsMmsGtest_Receive_SMS_0001
1145  * @tc.name     Receive a normal Sms
1146  * @tc.desc     Function test
1147  */
HWTEST_F(SmsGtest, Receive_SMS_0001, Function | MediumTest | Level2)1148 HWTEST_F(SmsGtest, Receive_SMS_0001, Function | MediumTest | Level2)
1149 {
1150     TELEPHONY_LOGI("TelSMSMMSTest::Receive_SMS_0001 -->");
1151     int32_t slotId = DEFAULT_SIM_SLOT_ID;
1152     if (!(SmsGtest::HasSimCard(slotId))) {
1153         TELEPHONY_LOGI("TelephonyTestService has no sim card");
1154         ASSERT_FALSE(SmsGtest::HasSimCard(slotId));
1155         return;
1156     }
1157     SmsMmsTestHelper helper;
1158     helper.slotId = slotId;
1159 
1160     EventFwk::MatchingSkills matchingSkills;
1161     matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_SMS_RECEIVE_COMPLETED);
1162     EventFwk::CommonEventSubscribeInfo subscriberInfo(matchingSkills);
1163     std::shared_ptr<SmsBroadcastSubscriberGtest> subscriberTest =
1164         std::make_shared<SmsBroadcastSubscriberGtest>(subscriberInfo, helper);
1165     ASSERT_NE(subscriberTest, nullptr);
1166     bool subscribeResult = EventFwk::CommonEventManager::SubscribeCommonEvent(subscriberTest);
1167     TELEPHONY_LOGI("subscribeResult is : %{public}d", subscribeResult);
1168 
1169     if (!helper.Run(ReceiveSmsTestFunc, helper)) {
1170         TELEPHONY_LOGI("ReceiveSmsTestFunc out of time");
1171         ASSERT_FALSE(helper.Run(ReceiveSmsTestFunc, helper));
1172         return;
1173     }
1174     TELEPHONY_LOGI("TelSMSMMSTest::Receive_SMS_0001 -->finished");
1175     EXPECT_TRUE(helper.GetBoolResult());
1176 }
1177 
1178 /**
1179  * @tc.number   Telephony_SmsMmsGtest_Receive_SMS_0002
1180  * @tc.name     Receive a normal Sms
1181  * @tc.desc     Function test
1182  */
HWTEST_F(SmsGtest, Receive_SMS_0002, Function | MediumTest | Level2)1183 HWTEST_F(SmsGtest, Receive_SMS_0002, Function | MediumTest | Level2)
1184 {
1185     TELEPHONY_LOGI("TelSMSMMSTest::Receive_SMS_0002 -->");
1186     int32_t slotId = DEFAULT_SIM_SLOT_ID_1;
1187     if (!(SmsGtest::HasSimCard(slotId))) {
1188         TELEPHONY_LOGI("TelephonyTestService has no sim card");
1189         ASSERT_FALSE(SmsGtest::HasSimCard(slotId));
1190         return;
1191     }
1192     SmsMmsTestHelper helper;
1193     helper.slotId = slotId;
1194 
1195     EventFwk::MatchingSkills matchingSkills;
1196     matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_SMS_RECEIVE_COMPLETED);
1197     EventFwk::CommonEventSubscribeInfo subscriberInfo(matchingSkills);
1198     std::shared_ptr<SmsBroadcastSubscriberGtest> subscriberTest =
1199         std::make_shared<SmsBroadcastSubscriberGtest>(subscriberInfo, helper);
1200     ASSERT_NE(subscriberTest, nullptr);
1201     bool subscribeResult = EventFwk::CommonEventManager::SubscribeCommonEvent(subscriberTest);
1202     TELEPHONY_LOGI("subscribeResult is : %{public}d", subscribeResult);
1203 
1204     if (!helper.Run(ReceiveSmsTestFunc, helper)) {
1205         TELEPHONY_LOGI("ReceiveSmsTestFunc out of time");
1206         ASSERT_FALSE(helper.Run(ReceiveSmsTestFunc, helper));
1207         return;
1208     }
1209     TELEPHONY_LOGI("TelSMSMMSTest::Receive_SMS_0002 -->finished");
1210     EXPECT_TRUE(helper.GetBoolResult());
1211 }
1212 
GetSmsSegmentsInfoTestFuc(SmsMmsTestHelper &helper)1213 void GetSmsSegmentsInfoTestFuc(SmsMmsTestHelper &helper)
1214 {
1215     std::u16string message = u"";
1216     bool force7BitCode = false;
1217     ISmsServiceInterface::SmsSegmentsInfo result;
1218     Singleton<SmsServiceManagerClient>::GetInstance().GetSmsSegmentsInfo(
1219         helper.slotId, message, force7BitCode, result);
1220     bool isSupported = false;
1221     Singleton<SmsServiceManagerClient>::GetInstance().IsImsSmsSupported(helper.slotId, isSupported);
1222     helper.SetBoolResult(isSupported);
1223     helper.NotifyAll();
1224 }
1225 
GetSmsSegmentsInfoTestFuc2(SmsMmsTestHelper &helper)1226 void GetSmsSegmentsInfoTestFuc2(SmsMmsTestHelper &helper)
1227 {
1228     std::u16string message = u"message";
1229     bool force7BitCode = true;
1230     ISmsServiceInterface::SmsSegmentsInfo result;
1231     Singleton<SmsServiceManagerClient>::GetInstance().GetSmsSegmentsInfo(
1232         helper.slotId, message, force7BitCode, result);
1233     bool isSupported = false;
1234     Singleton<SmsServiceManagerClient>::GetInstance().IsImsSmsSupported(helper.slotId, isSupported);
1235     helper.SetBoolResult(isSupported);
1236     helper.NotifyAll();
1237 }
1238 
1239 /**
1240  * @tc.number   Telephony_SmsMmsGtest_GetSmsSegmentsInfo_0001
1241  * @tc.name     Send Text Sms
1242  * @tc.desc     Function test
1243  */
HWTEST_F(SmsGtest, GetSmsSegmentsInfo_0001, Function | MediumTest | Level2)1244 HWTEST_F(SmsGtest, GetSmsSegmentsInfo_0001, Function | MediumTest | Level2)
1245 {
1246     TELEPHONY_LOGI("TelSMSMMSTest::GetSmsSegmentsInfo_0001 -->");
1247     int32_t slotId = DEFAULT_SIM_SLOT_ID;
1248     if (!(SmsGtest::HasSimCard(slotId))) {
1249         TELEPHONY_LOGI("TelephonyTestService has no sim card");
1250         ASSERT_FALSE(SmsGtest::HasSimCard(slotId));
1251         return;
1252     }
1253     SmsMmsTestHelper helper;
1254     helper.slotId = slotId;
1255     if (!helper.Run(GetSmsSegmentsInfoTestFuc, helper)) {
1256         TELEPHONY_LOGI("GetSmsSegmentsInfoTestFuc out of time");
1257         ASSERT_TRUE(helper.Run(GetSmsSegmentsInfoTestFuc, helper));
1258     }
1259     TELEPHONY_LOGI("TelSMSMMSTest::GetSmsSegmentsInfo_0001 -->finished");
1260     EXPECT_GE(helper.GetBoolResult(), 0);
1261 }
1262 
1263 /**
1264  * @tc.number   Telephony_SmsMmsGtest_GetSmsSegmentsInfo_0002
1265  * @tc.name     Send Text Sms
1266  * @tc.desc     Function test
1267  */
HWTEST_F(SmsGtest, GetSmsSegmentsInfo_0002, Function | MediumTest | Level2)1268 HWTEST_F(SmsGtest, GetSmsSegmentsInfo_0002, Function | MediumTest | Level2)
1269 {
1270     TELEPHONY_LOGI("TelSMSMMSTest::GetSmsSegmentsInfo_0002 -->");
1271     int32_t slotId = DEFAULT_SIM_SLOT_ID;
1272     if (!(SmsGtest::HasSimCard(slotId))) {
1273         TELEPHONY_LOGI("TelephonyTestService has no sim card");
1274         ASSERT_FALSE(SmsGtest::HasSimCard(slotId));
1275         return;
1276     }
1277     SmsMmsTestHelper helper;
1278     helper.slotId = slotId;
1279     if (!helper.Run(GetSmsSegmentsInfoTestFuc2, helper)) {
1280         TELEPHONY_LOGI("GetSmsSegmentsInfoTestFuc2 out of time");
1281         ASSERT_TRUE(helper.Run(GetSmsSegmentsInfoTestFuc2, helper));
1282     }
1283     TELEPHONY_LOGI("TelSMSMMSTest::GetSmsSegmentsInfo_0002 -->finished");
1284     EXPECT_GE(helper.GetBoolResult(), 0);
1285 }
1286 
1287 /**
1288  * @tc.number   Telephony_SmsMmsGtest_GetSmsSegmentsInfo_0003
1289  * @tc.name     Send Text Sms
1290  * @tc.desc     Function test
1291  */
HWTEST_F(SmsGtest, GetSmsSegmentsInfo_0003, Function | MediumTest | Level2)1292 HWTEST_F(SmsGtest, GetSmsSegmentsInfo_0003, Function | MediumTest | Level2)
1293 {
1294     TELEPHONY_LOGI("TelSMSMMSTest::GetSmsSegmentsInfo_0003 -->");
1295     int32_t slotId = DEFAULT_SIM_SLOT_ID_1;
1296     if (!(SmsGtest::HasSimCard(slotId))) {
1297         TELEPHONY_LOGI("TelephonyTestService has no sim card");
1298         ASSERT_FALSE(SmsGtest::HasSimCard(slotId));
1299         return;
1300     }
1301     SmsMmsTestHelper helper;
1302     helper.slotId = slotId;
1303     if (!helper.Run(GetSmsSegmentsInfoTestFuc, helper)) {
1304         TELEPHONY_LOGI("GetSmsSegmentsInfoTestFuc3 out of time");
1305         ASSERT_TRUE(helper.Run(GetSmsSegmentsInfoTestFuc, helper));
1306     }
1307     TELEPHONY_LOGI("TelSMSMMSTest::GetSmsSegmentsInfo_0003 -->finished");
1308     EXPECT_FALSE(helper.GetBoolResult());
1309 }
1310 
Create7bitSubmitSmsTestFuc(SmsMmsTestHelper &helper)1311 void Create7bitSubmitSmsTestFuc(SmsMmsTestHelper &helper)
1312 {
1313     AccessMmsToken token;
1314     std::vector<unsigned char> pdu = StringUtils::HexToByteVector("21010B818176251308F4000002C130");
1315     ShortMessage *message = new ShortMessage();
1316     if (message == nullptr) {
1317         helper.SetIntResult(1);
1318         helper.NotifyAll();
1319         return;
1320     }
1321     int result = ShortMessage::CreateMessage(pdu, u"3gpp", *message);
1322     helper.SetIntResult(result);
1323     helper.NotifyAll();
1324 }
1325 
1326 /**
1327  * @tc.number   Telephony_SmsMmsGtest_Create7bitSubmitSms_0001
1328  * @tc.name     Create 7bit Submit Sms
1329  * @tc.desc     Function test
1330  */
HWTEST_F(SmsGtest, Create7bitSubmitSms_0001, Function | MediumTest | Level2)1331 HWTEST_F(SmsGtest, Create7bitSubmitSms_0001, Function | MediumTest | Level2)
1332 {
1333     TELEPHONY_LOGI("TelSMSMMSTest::Create7bitSubmitSms_0001 -->");
1334     if (!(SmsGtest::HasSimCard(DEFAULT_SIM_SLOT_ID))) {
1335         TELEPHONY_LOGI("TelephonyTestService has no sim card");
1336         ASSERT_FALSE(SmsGtest::HasSimCard(DEFAULT_SIM_SLOT_ID));
1337         return;
1338     }
1339     SmsMmsTestHelper helper;
1340     helper.slotId = DEFAULT_SIM_SLOT_ID;
1341     if (!helper.Run(Create7bitSubmitSmsTestFuc, std::ref(helper))) {
1342         TELEPHONY_LOGI("Create7bitSubmitSmsTestFuc out of time");
1343         ASSERT_TRUE(helper.Run(Create7bitSubmitSmsTestFuc, std::ref(helper)));
1344         return;
1345     }
1346     TELEPHONY_LOGI("TelSMSMMSTest::Create7bitSubmitSms_0001 -->finished");
1347     ASSERT_EQ(helper.GetIntResult(), 0);
1348 }
1349 
1350 /**
1351  * @tc.number   Telephony_SmsMmsGtest_Create7bitSubmitSms_0002
1352  * @tc.name     Create 7bit Submit Sms
1353  * @tc.desc     Function test
1354  */
HWTEST_F(SmsGtest, Create7bitSubmitSms_0002, Function | MediumTest | Level2)1355 HWTEST_F(SmsGtest, Create7bitSubmitSms_0002, Function | MediumTest | Level2)
1356 {
1357     TELEPHONY_LOGI("TelSMSMMSTest::Create7bitSubmitSms_0002 -->");
1358     if (!(SmsGtest::HasSimCard(DEFAULT_SIM_SLOT_ID_1))) {
1359         TELEPHONY_LOGI("TelephonyTestService has no sim card");
1360         ASSERT_FALSE(SmsGtest::HasSimCard(DEFAULT_SIM_SLOT_ID_1));
1361         return;
1362     }
1363     SmsMmsTestHelper helper;
1364     helper.slotId = DEFAULT_SIM_SLOT_ID_1;
1365     if (!helper.Run(Create7bitSubmitSmsTestFuc, std::ref(helper))) {
1366         TELEPHONY_LOGI("Create7bitSubmitSmsTestFuc out of time");
1367         ASSERT_TRUE(helper.Run(Create7bitSubmitSmsTestFuc, std::ref(helper)));
1368         return;
1369     }
1370     TELEPHONY_LOGI("TelSMSMMSTest::Create7bitSubmitSms_0002 -->finished");
1371     ASSERT_EQ(helper.GetIntResult(), 0);
1372 }
1373 
CreateUcs2SubmitSmsTestFuc(SmsMmsTestHelper &helper)1374 void CreateUcs2SubmitSmsTestFuc(SmsMmsTestHelper &helper)
1375 {
1376     AccessMmsToken token;
1377     std::vector<unsigned char> pdu = StringUtils::HexToByteVector("21020B818176251308F40008046D4B8BD5");
1378     ShortMessage *message = new ShortMessage();
1379     if (message == nullptr) {
1380         helper.SetIntResult(1);
1381         helper.NotifyAll();
1382         return;
1383     }
1384     int result = ShortMessage::CreateMessage(pdu, u"3gpp", *message);
1385     helper.SetIntResult(result);
1386     helper.NotifyAll();
1387 }
1388 
1389 /**
1390  * @tc.number   Telephony_SmsMmsGtest_CreateUcs2SubmitSms_0001
1391  * @tc.name     Create Ucs2 Submit Sms
1392  * @tc.desc     Function test
1393  */
HWTEST_F(SmsGtest, CreateUcs2SubmitSms_0001, Function | MediumTest | Level2)1394 HWTEST_F(SmsGtest, CreateUcs2SubmitSms_0001, Function | MediumTest | Level2)
1395 {
1396     TELEPHONY_LOGI("TelSMSMMSTest::CreateUcs2SubmitSms_0001 -->");
1397     if (!(SmsGtest::HasSimCard(DEFAULT_SIM_SLOT_ID))) {
1398         TELEPHONY_LOGI("TelephonyTestService has no sim card");
1399         ASSERT_FALSE(SmsGtest::HasSimCard(DEFAULT_SIM_SLOT_ID));
1400         return;
1401     }
1402     SmsMmsTestHelper helper;
1403     helper.slotId = DEFAULT_SIM_SLOT_ID;
1404     if (!helper.Run(CreateUcs2SubmitSmsTestFuc, std::ref(helper))) {
1405         TELEPHONY_LOGI("CreateUcs2SubmitSmsTestFuc out of time");
1406         ASSERT_TRUE(helper.Run(CreateUcs2SubmitSmsTestFuc, std::ref(helper)));
1407         return;
1408     }
1409     TELEPHONY_LOGI("TelSMSMMSTest::CreateUcs2SubmitSms_0001 -->finished");
1410     ASSERT_EQ(helper.GetIntResult(), 0);
1411 }
1412 
1413 /**
1414  * @tc.number   Telephony_SmsMmsGtest_CreateUcs2SubmitSms_0002
1415  * @tc.name     Create Ucs2 Submit Sms
1416  * @tc.desc     Function test
1417  */
HWTEST_F(SmsGtest, CreateUcs2SubmitSms_0002, Function | MediumTest | Level2)1418 HWTEST_F(SmsGtest, CreateUcs2SubmitSms_0002, Function | MediumTest | Level2)
1419 {
1420     TELEPHONY_LOGI("TelSMSMMSTest::CreateUcs2SubmitSms_0002 -->");
1421     if (!(SmsGtest::HasSimCard(DEFAULT_SIM_SLOT_ID_1))) {
1422         TELEPHONY_LOGI("TelephonyTestService has no sim card");
1423         ASSERT_FALSE(SmsGtest::HasSimCard(DEFAULT_SIM_SLOT_ID_1));
1424         return;
1425     }
1426     SmsMmsTestHelper helper;
1427     helper.slotId = DEFAULT_SIM_SLOT_ID_1;
1428     if (!helper.Run(CreateUcs2SubmitSmsTestFuc, std::ref(helper))) {
1429         TELEPHONY_LOGI("CreateUcs2SubmitSmsTestFuc out of time");
1430         ASSERT_TRUE(helper.Run(CreateUcs2SubmitSmsTestFuc, std::ref(helper)));
1431         return;
1432     }
1433     TELEPHONY_LOGI("TelSMSMMSTest::CreateUcs2SubmitSms_0002 -->finished");
1434     ASSERT_EQ(helper.GetIntResult(), 0);
1435 }
1436 
Create7bitDeliverySmsTestFuc(SmsMmsTestHelper &helper)1437 void Create7bitDeliverySmsTestFuc(SmsMmsTestHelper &helper)
1438 {
1439     AccessMmsToken token;
1440     std::vector<unsigned char> pdu =
1441         StringUtils::HexToByteVector("0891683108200075F4240D91688129562983F600001240800102142302C130");
1442     ShortMessage *message = new ShortMessage();
1443     if (message == nullptr) {
1444         helper.SetIntResult(1);
1445         helper.NotifyAll();
1446         return;
1447     }
1448     int result = ShortMessage::CreateMessage(pdu, u"3gpp", *message);
1449     helper.SetIntResult(result);
1450     helper.NotifyAll();
1451 }
1452 
1453 /**
1454  * @tc.number   Telephony_SmsMmsGtest_Create7bitDeliverySms_0001
1455  * @tc.name     Create 7bit Delivery Sms
1456  * @tc.desc     Function test
1457  */
HWTEST_F(SmsGtest, Create7bitDeliverySms_0001, Function | MediumTest | Level2)1458 HWTEST_F(SmsGtest, Create7bitDeliverySms_0001, Function | MediumTest | Level2)
1459 {
1460     TELEPHONY_LOGI("TelSMSMMSTest::Create7bitDeliverySms_0001 -->");
1461     if (!(SmsGtest::HasSimCard(DEFAULT_SIM_SLOT_ID))) {
1462         TELEPHONY_LOGI("TelephonyTestService has no sim card");
1463         ASSERT_FALSE(SmsGtest::HasSimCard(DEFAULT_SIM_SLOT_ID));
1464         return;
1465     }
1466     SmsMmsTestHelper helper;
1467     helper.slotId = DEFAULT_SIM_SLOT_ID;
1468     if (!helper.Run(Create7bitDeliverySmsTestFuc, std::ref(helper))) {
1469         TELEPHONY_LOGI("Create7bitDeliverySmsTestFuc out of time");
1470         ASSERT_TRUE(helper.Run(Create7bitDeliverySmsTestFuc, std::ref(helper)));
1471         return;
1472     }
1473     TELEPHONY_LOGI("TelSMSMMSTest::Create7bitDeliverySms_0001 -->finished");
1474     ASSERT_EQ(helper.GetIntResult(), 0);
1475 }
1476 
1477 /**
1478  * @tc.number   Telephony_SmsMmsGtest_Create7bitDeliverySms_0002
1479  * @tc.name     Create 7bit Delivery Sms
1480  * @tc.desc     Function test
1481  */
HWTEST_F(SmsGtest, Create7bitDeliverySms_0002, Function | MediumTest | Level2)1482 HWTEST_F(SmsGtest, Create7bitDeliverySms_0002, Function | MediumTest | Level2)
1483 {
1484     TELEPHONY_LOGI("TelSMSMMSTest::Create7bitDeliverySms_0002 -->");
1485     if (!(SmsGtest::HasSimCard(DEFAULT_SIM_SLOT_ID_1))) {
1486         TELEPHONY_LOGI("TelephonyTestService has no sim card");
1487         ASSERT_FALSE(SmsGtest::HasSimCard(DEFAULT_SIM_SLOT_ID_1));
1488         return;
1489     }
1490     SmsMmsTestHelper helper;
1491     helper.slotId = DEFAULT_SIM_SLOT_ID_1;
1492     if (!helper.Run(Create7bitDeliverySmsTestFuc, std::ref(helper))) {
1493         TELEPHONY_LOGI("Create7bitDeliverySmsTestFuc out of time");
1494         ASSERT_TRUE(helper.Run(Create7bitDeliverySmsTestFuc, std::ref(helper)));
1495         return;
1496     }
1497     TELEPHONY_LOGI("TelSMSMMSTest::Create7bitDeliverySms_0002 -->finished");
1498     ASSERT_EQ(helper.GetIntResult(), 0);
1499 }
1500 
CreateUcs2DeliverySmsTestFuc(SmsMmsTestHelper &helper)1501 void CreateUcs2DeliverySmsTestFuc(SmsMmsTestHelper &helper)
1502 {
1503     AccessMmsToken token;
1504     std::vector<unsigned char> pdu =
1505         StringUtils::HexToByteVector("0891683110206005F0240DA1688176251308F4000832500381459323044F60597D");
1506     ShortMessage *message = new ShortMessage();
1507     if (message == nullptr) {
1508         helper.SetIntResult(1);
1509         helper.NotifyAll();
1510         return;
1511     }
1512     int result = ShortMessage::CreateMessage(pdu, u"3gpp", *message);
1513     helper.SetIntResult(result);
1514     helper.NotifyAll();
1515 }
1516 
1517 /**
1518  * @tc.number   Telephony_SmsMmsGtest_CreateUcs2DeliverySms_0001
1519  * @tc.name     Create Ucs2 Delivery Sms
1520  * @tc.desc     Function test
1521  */
HWTEST_F(SmsGtest, CreateUcs2DeliverySms_0001, Function | MediumTest | Level2)1522 HWTEST_F(SmsGtest, CreateUcs2DeliverySms_0001, Function | MediumTest | Level2)
1523 {
1524     TELEPHONY_LOGI("TelSMSMMSTest::CreateUcs2DeliverySms_0001 -->");
1525     if (!(SmsGtest::HasSimCard(DEFAULT_SIM_SLOT_ID))) {
1526         TELEPHONY_LOGI("TelephonyTestService has no sim card");
1527         ASSERT_FALSE(SmsGtest::HasSimCard(DEFAULT_SIM_SLOT_ID));
1528         return;
1529     }
1530     SmsMmsTestHelper helper;
1531     helper.slotId = DEFAULT_SIM_SLOT_ID;
1532     if (!helper.Run(CreateUcs2DeliverySmsTestFuc, std::ref(helper))) {
1533         TELEPHONY_LOGI("CreateUcs2DeliverySmsTestFuc out of time");
1534         ASSERT_TRUE(helper.Run(CreateUcs2DeliverySmsTestFuc, std::ref(helper)));
1535         return;
1536     }
1537     TELEPHONY_LOGI("TelSMSMMSTest::CreateUcs2DeliverySms_0001 -->finished");
1538     ASSERT_EQ(helper.GetIntResult(), 0);
1539 }
1540 
1541 /**
1542  * @tc.number   Telephony_SmsMmsGtest_CreateUcs2DeliverySms_0002
1543  * @tc.name     Create Ucs2 Delivery Sms
1544  * @tc.desc     Function test
1545  */
HWTEST_F(SmsGtest, CreateUcs2DeliverySms_0002, Function | MediumTest | Level2)1546 HWTEST_F(SmsGtest, CreateUcs2DeliverySms_0002, Function | MediumTest | Level2)
1547 {
1548     TELEPHONY_LOGI("TelSMSMMSTest::CreateUcs2DeliverySms_0002 -->");
1549     if (!(SmsGtest::HasSimCard(DEFAULT_SIM_SLOT_ID_1))) {
1550         TELEPHONY_LOGI("TelephonyTestService has no sim card");
1551         ASSERT_FALSE(SmsGtest::HasSimCard(DEFAULT_SIM_SLOT_ID_1));
1552         return;
1553     }
1554     SmsMmsTestHelper helper;
1555     helper.slotId = DEFAULT_SIM_SLOT_ID_1;
1556     if (!helper.Run(CreateUcs2DeliverySmsTestFuc, std::ref(helper))) {
1557         TELEPHONY_LOGI("CreateUcs2DeliverySmsTestFuc out of time");
1558         ASSERT_TRUE(helper.Run(CreateUcs2DeliverySmsTestFuc, std::ref(helper)));
1559         return;
1560     }
1561     TELEPHONY_LOGI("TelSMSMMSTest::CreateUcs2DeliverySms_0002 -->finished");
1562     ASSERT_EQ(helper.GetIntResult(), 0);
1563 }
1564 
CreateStatusReportSmsTestFuc(SmsMmsTestHelper &helper)1565 void CreateStatusReportSmsTestFuc(SmsMmsTestHelper &helper)
1566 {
1567     AccessMmsToken token;
1568     std::vector<unsigned char> pdu =
1569         StringUtils::HexToByteVector("0891683110808805F006510B818176251308F4325013113382233250131143802300");
1570     ShortMessage *message = new ShortMessage();
1571     if (message == nullptr) {
1572         helper.SetIntResult(1);
1573         helper.NotifyAll();
1574         return;
1575     }
1576     int result = ShortMessage::CreateMessage(pdu, u"3gpp", *message);
1577     helper.SetIntResult(result);
1578     helper.NotifyAll();
1579 }
1580 
1581 /**
1582  * @tc.number   Telephony_SmsMmsGtest_CreateStatusReportSms_0001
1583  * @tc.name     Create Status Report Sms
1584  * @tc.desc     Function test
1585  */
HWTEST_F(SmsGtest, CreateStatusReportSms_0001, Function | MediumTest | Level2)1586 HWTEST_F(SmsGtest, CreateStatusReportSms_0001, Function | MediumTest | Level2)
1587 {
1588     TELEPHONY_LOGI("TelSMSMMSTest::CreateStatusReportSms_0001 -->");
1589     if (!(SmsGtest::HasSimCard(DEFAULT_SIM_SLOT_ID))) {
1590         TELEPHONY_LOGI("TelephonyTestService has no sim card");
1591         ASSERT_FALSE(SmsGtest::HasSimCard(DEFAULT_SIM_SLOT_ID));
1592         return;
1593     }
1594     SmsMmsTestHelper helper;
1595     helper.slotId = DEFAULT_SIM_SLOT_ID;
1596     if (!helper.Run(CreateStatusReportSmsTestFuc, std::ref(helper))) {
1597         TELEPHONY_LOGI("CreateStatusReportSmsTestFuc out of time");
1598         ASSERT_TRUE(helper.Run(CreateStatusReportSmsTestFuc, std::ref(helper)));
1599         return;
1600     }
1601     TELEPHONY_LOGI("TelSMSMMSTest::CreateStatusReportSms_0001 -->finished");
1602     ASSERT_EQ(helper.GetIntResult(), 0);
1603 }
1604 
1605 /**
1606  * @tc.number   Telephony_SmsMmsGtest_CreateStatusReportSms_0002
1607  * @tc.name     Create Status Report Sms
1608  * @tc.desc     Function test
1609  */
HWTEST_F(SmsGtest, CreateStatusReportSms_0002, Function | MediumTest | Level2)1610 HWTEST_F(SmsGtest, CreateStatusReportSms_0002, Function | MediumTest | Level2)
1611 {
1612     TELEPHONY_LOGI("TelSMSMMSTest::CreateStatusReportSms_0002 -->");
1613     if (!(SmsGtest::HasSimCard(DEFAULT_SIM_SLOT_ID_1))) {
1614         TELEPHONY_LOGI("TelephonyTestService has no sim card");
1615         ASSERT_FALSE(SmsGtest::HasSimCard(DEFAULT_SIM_SLOT_ID_1));
1616         return;
1617     }
1618     SmsMmsTestHelper helper;
1619     helper.slotId = DEFAULT_SIM_SLOT_ID_1;
1620     if (!helper.Run(CreateStatusReportSmsTestFuc, std::ref(helper))) {
1621         TELEPHONY_LOGI("CreateStatusReportSmsTestFuc out of time");
1622         ASSERT_TRUE(helper.Run(CreateStatusReportSmsTestFuc, std::ref(helper)));
1623         return;
1624     }
1625     TELEPHONY_LOGI("TelSMSMMSTest::CreateStatusReportSms_0002 -->finished");
1626     ASSERT_EQ(helper.GetIntResult(), 0);
1627 }
1628 
CreateMultiPageSmsTestFuc(SmsMmsTestHelper &helper)1629 void CreateMultiPageSmsTestFuc(SmsMmsTestHelper &helper)
1630 {
1631     AccessMmsToken token;
1632     std::vector<unsigned char> pdu = StringUtils::HexToByteVector(
1633         "0891683110205005F06005A00110F00008325052214182238C050003D3030200310030002E0063006E002F007100410053004B00380020"
1634         "FF0C4EE5514D6B216708521D6263966476F851738D397528540E5F7154CD60A876846B635E384F7F752830024E2D56FD8054901A004100"
1635         "5000507545723D65B04F539A8CFF0C70B951FB0020002000680074007400700073003A002F002F0075002E00310030003000310030002"
1636         "E");
1637 
1638     ShortMessage *message = new ShortMessage();
1639     if (message == nullptr) {
1640         helper.SetIntResult(1);
1641         helper.NotifyAll();
1642         return;
1643     }
1644     int result = ShortMessage::CreateMessage(pdu, u"3gpp", *message);
1645     helper.SetIntResult(result);
1646     helper.NotifyAll();
1647 }
1648 
1649 /**
1650  * @tc.number   Telephony_SmsMmsGtest_CreateMultiPageSms_0001
1651  * @tc.name     Create MultiPage Sms
1652  * @tc.desc     Function test
1653  */
HWTEST_F(SmsGtest, CreateMultiPageSms_0001, Function | MediumTest | Level2)1654 HWTEST_F(SmsGtest, CreateMultiPageSms_0001, Function | MediumTest | Level2)
1655 {
1656     TELEPHONY_LOGI("TelSMSMMSTest::CreateMultiPageSms_0001 -->");
1657     if (!(SmsGtest::HasSimCard(DEFAULT_SIM_SLOT_ID))) {
1658         TELEPHONY_LOGI("TelephonyTestService has no sim card");
1659         ASSERT_FALSE(SmsGtest::HasSimCard(DEFAULT_SIM_SLOT_ID));
1660         return;
1661     }
1662     SmsMmsTestHelper helper;
1663     helper.slotId = DEFAULT_SIM_SLOT_ID;
1664     if (!helper.Run(CreateMultiPageSmsTestFuc, std::ref(helper))) {
1665         TELEPHONY_LOGI("CreateMultiPageSmsTestFuc out of time");
1666         ASSERT_TRUE(helper.Run(CreateMultiPageSmsTestFuc, std::ref(helper)));
1667         return;
1668     }
1669     TELEPHONY_LOGI("TelSMSMMSTest::CreateMultiPageSms_0001 -->finished");
1670     ASSERT_EQ(helper.GetIntResult(), 0);
1671 }
1672 
1673 /**
1674  * @tc.number   Telephony_SmsMmsGtest_CreateMultiPageSms_0002
1675  * @tc.name     Create MultiPage Sms
1676  * @tc.desc     Function test
1677  */
HWTEST_F(SmsGtest, CreateMultiPageSms_0002, Function | MediumTest | Level2)1678 HWTEST_F(SmsGtest, CreateMultiPageSms_0002, Function | MediumTest | Level2)
1679 {
1680     TELEPHONY_LOGI("TelSMSMMSTest::CreateMultiPageSms_0002 -->");
1681     if (!(SmsGtest::HasSimCard(DEFAULT_SIM_SLOT_ID_1))) {
1682         TELEPHONY_LOGI("TelephonyTestService has no sim card");
1683         ASSERT_FALSE(SmsGtest::HasSimCard(DEFAULT_SIM_SLOT_ID_1));
1684         return;
1685     }
1686     SmsMmsTestHelper helper;
1687     helper.slotId = DEFAULT_SIM_SLOT_ID_1;
1688     if (!helper.Run(CreateMultiPageSmsTestFuc, std::ref(helper))) {
1689         TELEPHONY_LOGI("CreateMultiPageSmsTestFuc out of time");
1690         ASSERT_TRUE(helper.Run(CreateMultiPageSmsTestFuc, std::ref(helper)));
1691         return;
1692     }
1693     TELEPHONY_LOGI("TelSMSMMSTest::CreateMultiPageSms_0002 -->finished");
1694     ASSERT_EQ(helper.GetIntResult(), 0);
1695 }
1696 
CreateWapPushSmsTestFuc(SmsMmsTestHelper &helper)1697 void CreateWapPushSmsTestFuc(SmsMmsTestHelper &helper)
1698 {
1699     AccessMmsToken token;
1700     std::vector<unsigned char> pdu = StringUtils::HexToByteVector("21010B818176251308F4000002C130");
1701     ShortMessage *message = new ShortMessage();
1702     if (message == nullptr) {
1703         helper.SetIntResult(1);
1704         helper.NotifyAll();
1705         return;
1706     }
1707     int result = ShortMessage::CreateMessage(pdu, u"3gpp", *message);
1708     helper.SetIntResult(result);
1709     helper.NotifyAll();
1710 }
1711 
1712 /**
1713  * @tc.number   Telephony_SmsMmsGtest_CreateWapPushSms_0001
1714  * @tc.name     Create WapPush Sms
1715  * @tc.desc     Function test
1716  */
HWTEST_F(SmsGtest, CreateWapPushSms_0001, Function | MediumTest | Level2)1717 HWTEST_F(SmsGtest, CreateWapPushSms_0001, Function | MediumTest | Level2)
1718 {
1719     TELEPHONY_LOGI("TelSMSMMSTest::CreateWapPushSms_0001 -->");
1720     if (!(SmsGtest::HasSimCard(DEFAULT_SIM_SLOT_ID))) {
1721         TELEPHONY_LOGI("TelephonyTestService has no sim card");
1722         ASSERT_FALSE(SmsGtest::HasSimCard(DEFAULT_SIM_SLOT_ID));
1723         return;
1724     }
1725     SmsMmsTestHelper helper;
1726     helper.slotId = DEFAULT_SIM_SLOT_ID;
1727     if (!helper.Run(CreateWapPushSmsTestFuc, std::ref(helper))) {
1728         TELEPHONY_LOGI("CreateWapPushSmsTestFuc out of time");
1729         ASSERT_TRUE(helper.Run(CreateWapPushSmsTestFuc, std::ref(helper)));
1730         return;
1731     }
1732     TELEPHONY_LOGI("TelSMSMMSTest::CreateWapPushSms_0001 -->finished");
1733     ASSERT_EQ(helper.GetIntResult(), 0);
1734 }
1735 
1736 /**
1737  * @tc.number   Telephony_SmsMmsGtest_CreateWapPushSms_0002
1738  * @tc.name     Create WapPush Sms
1739  * @tc.desc     Function test
1740  */
HWTEST_F(SmsGtest, CreateWapPushSms_0002, Function | MediumTest | Level2)1741 HWTEST_F(SmsGtest, CreateWapPushSms_0002, Function | MediumTest | Level2)
1742 {
1743     TELEPHONY_LOGI("TelSMSMMSTest::CreateWapPushSms_0002 -->");
1744     if (!(SmsGtest::HasSimCard(DEFAULT_SIM_SLOT_ID_1))) {
1745         TELEPHONY_LOGI("TelephonyTestService has no sim card");
1746         ASSERT_FALSE(SmsGtest::HasSimCard(DEFAULT_SIM_SLOT_ID_1));
1747         return;
1748     }
1749     SmsMmsTestHelper helper;
1750     helper.slotId = DEFAULT_SIM_SLOT_ID_1;
1751     if (!helper.Run(CreateWapPushSmsTestFuc, std::ref(helper))) {
1752         TELEPHONY_LOGI("CreateWapPushSmsTestFuc out of time");
1753         ASSERT_TRUE(helper.Run(CreateWapPushSmsTestFuc, std::ref(helper)));
1754         return;
1755     }
1756     TELEPHONY_LOGI("TelSMSMMSTest::CreateWapPushSms_0002 -->finished");
1757     ASSERT_EQ(helper.GetIntResult(), 0);
1758 }
1759 
HWTEST_F(SmsGtest, Sms_TestDump_0002, Function | MediumTest | Level3)1760 HWTEST_F(SmsGtest, Sms_TestDump_0002, Function | MediumTest | Level3)
1761 {
1762     std::string originatingAddress = "";
1763     bool result = DelayedSingleton<SmsPersistHelper>::GetInstance()->QueryBlockPhoneNumber(originatingAddress);
1764     ASSERT_FALSE(result);
1765 }
1766 
1767 /**
1768  * @tc.number   Sms_TestDump_0100
1769  * @tc.name    TestDump
1770  * @tc.desc     Function test
1771  */
HWTEST_F(SmsGtest, Sms_TestDump_0001, Function | MediumTest | Level3)1772 HWTEST_F(SmsGtest, Sms_TestDump_0001, Function | MediumTest | Level3)
1773 {
1774     std::vector<std::u16string> emptyArgs = {};
1775     std::vector<std::u16string> args = { u"test", u"test1" };
1776     EXPECT_GE(DelayedSingleton<SmsService>::GetInstance()->Dump(-1, args), 0);
1777     EXPECT_GE(DelayedSingleton<SmsService>::GetInstance()->Dump(0, emptyArgs), 0);
1778     EXPECT_GE(DelayedSingleton<SmsService>::GetInstance()->Dump(0, args), 0);
1779 }
1780 #else // TEL_TEST_UNSUPPORT
1781 #endif // TEL_TEST_UNSUPPORT
1782 } // namespace Telephony
1783 } // namespace OHOS