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