1 /*
2 * Copyright (C) 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 #define private public
17 #define protected public
18
19 #include "cdma_sms_common.h"
20 #include "cdma_sms_sub_parameter.h"
21 #include "data_request.h"
22 #include "gsm_cb_umts_codec.h"
23 #include "gsm_sms_sender.h"
24 #include "gtest/gtest.h"
25 #include "ims_reg_state_callback_stub.h"
26 #include "mms_apn_info.h"
27 #include "radio_event.h"
28 #include "sms_mms_gtest.h"
29 #include "sms_pdu_buffer.h"
30 #include "sms_receive_handler.h"
31 #include "sms_state_handler.h"
32 #include "sms_send_manager.h"
33 #include "sms_sender.h"
34 #include "sms_service.h"
35 #include "sms_service_manager_client.h"
36 #include "sms_state_handler.h"
37 #include "telephony_errors.h"
38
39 namespace OHOS {
40 namespace Telephony {
41 namespace {
42 static constexpr int TEST_MAX_UD_HEADER_NUM = 8;
43 static constexpr int TEST_MAX_USER_DATA_LEN = 170;
44 static constexpr uint8_t TEST_MAX_FIELD_LEN = 170;
45 static constexpr uint8_t MAX_FIELD_LEN = 255;
46 static constexpr int TEST_DATA_LEN = 100;
47 static constexpr int TEST_SEND_CONF_MAX_SIZE = 600;
48 const int32_t INVALID_SLOTID = 2;
49 const unsigned int SMS_REF_ID = 10;
50 const std::string BLOCK_NUMBER = "123";
51 const int16_t WAP_PUSH_PORT = 2948;
52 const int8_t TEXT_PORT_NUM = -1;
53 } // namespace
54 using namespace testing::ext;
55
56 class SmsServicesMmsGtest : public testing::Test {
57 public:
58 static void SetUpTestCase();
59 static void TearDownTestCase();
60 void SetUp();
61 void TearDown();
62 };
63
64 constexpr uint32_t EVENT_RELEASE_DATA_SHARE_HELPER = 10000;
TearDownTestCase()65 void SmsServicesMmsGtest::TearDownTestCase()
66 {
67 DelayedSingleton<SmsPersistHelper>::GetInstance()->RemoveEvent(EVENT_RELEASE_DATA_SHARE_HELPER);
68 }
69
SetUp()70 void SmsServicesMmsGtest::SetUp() {}
71
TearDown()72 void SmsServicesMmsGtest::TearDown() {}
73
SetUpTestCase()74 void SmsServicesMmsGtest::SetUpTestCase() {}
75
76 HWTEST_F(SmsServicesMmsGtest, DataRequest_0001, Function | MediumTest | Level2)
77 {
78 int32_t slotId = 0;
79 auto dataRequest = std::make_shared<DataRequest>(slotId);
80 std::string testStr = "";
81 EXPECT_EQ(dataRequest->HttpRequest(slotId, testStr, nullptr, testStr, testStr, "ua", "uaprof"),
82 TELEPHONY_ERR_LOCAL_PTR_NULL);
83 }
84
85 HWTEST_F(SmsServicesMmsGtest, MmsNetworkClient_0001, Function | MediumTest | Level2)
86 {
87 int32_t slotId = 0;
88 MmsNetworkClient client(0);
89 std::string testStr = "testStr";
90 auto mmsApnInfo = std::make_shared<MmsApnInfo>(slotId);
91 mmsApnInfo->setMmscUrl("");
92 EXPECT_EQ(client.PostUrl(testStr, testStr, "ua", "uaprof"), TELEPHONY_ERR_ARGUMENT_INVALID);
93
94 client.responseData_ = std::string(TEST_SEND_CONF_MAX_SIZE, 'a');
95 EXPECT_TRUE(client.CheckSendConf());
96
97 client.responseData_ = "";
98 EXPECT_TRUE(client.CheckSendConf());
99
100 client.responseData_ = "responseData";
101 EXPECT_TRUE(client.CheckSendConf());
102 }
103
104 HWTEST_F(SmsServicesMmsGtest, MmsConnCallbackStub_0001, Function | MediumTest | Level2)
105 {
106 MmsConnCallbackStub connCallback;
107 sptr<NetManagerStandard::NetHandle> netHandle = new NetManagerStandard::NetHandle;
108 EXPECT_EQ(connCallback.NetAvailable(netHandle), ERR_NONE);
109 }
110
111 HWTEST_F(SmsServicesMmsGtest, CdmaSmsMessageId_0001, Function | MediumTest | Level2)
112 {
113 auto initValue = static_cast<uint16_t>(0x0);
114 auto testValue = static_cast<uint16_t>(0x10);
115 SmsTeleSvcMsgId v1;
116 memset_s(&v1, sizeof(SmsTeleSvcMsgId), 0x00, sizeof(SmsTeleSvcMsgId));
117 v1.msgId = testValue;
118 SmsTeleSvcMsgId v2;
119 v2.msgId = initValue;
120 uint8_t type = static_cast<uint8_t>(TeleserviceMsgType::SUBMIT);
121
122 auto message1 = std::make_shared<CdmaSmsMessageId>(v1, type);
123 SmsWriteBuffer wBuffer;
124 EXPECT_TRUE(message1->Encode(wBuffer));
125 auto buffer = wBuffer.GetPduBuffer();
126 EXPECT_GT(buffer->size(), 0);
127 std::stringstream ss;
128 ss.clear();
129 for (uint16_t i = 0; i < buffer->size(); i++) {
130 ss << (*buffer)[i];
131 }
132 SmsReadBuffer rBuffer(ss.str());
133 auto message2 = std::make_shared<CdmaSmsMessageId>(v2, type);
134
135 rBuffer.bitIndex_ = 0;
136 rBuffer.index_ = 0;
137 rBuffer.length_ = 0;
138 EXPECT_FALSE(message2->Decode(rBuffer));
139 }
140
141 HWTEST_F(SmsServicesMmsGtest, CdmaSmsAbsoluteTime_0001, Function | MediumTest | Level2)
142 {
143 auto initValue = static_cast<unsigned char>(0);
144 auto testValue = static_cast<unsigned char>(5);
145 SmsTimeAbs v1;
146 memset_s(&v1, sizeof(SmsTimeAbs), 0x00, sizeof(SmsTimeAbs));
147 v1.month = testValue;
148 SmsTimeAbs v2;
149 v2.month = initValue;
150
151 auto message1 = std::make_shared<CdmaSmsAbsoluteTime>(CdmaSmsSubParameter::VALIDITY_PERIOD_ABSOLUTE, v1);
152 SmsWriteBuffer wBuffer;
153 EXPECT_TRUE(message1->Encode(wBuffer));
154 auto buffer = wBuffer.GetPduBuffer();
155 EXPECT_GT(buffer->size(), 0);
156 std::stringstream ss;
157 ss.clear();
158 for (uint16_t i = 0; i < buffer->size(); i++) {
159 ss << (*buffer)[i];
160 }
161 SmsReadBuffer rBuffer(ss.str());
162 auto message2 = std::make_shared<CdmaSmsAbsoluteTime>(CdmaSmsSubParameter::VALIDITY_PERIOD_ABSOLUTE, v2);
163
164 rBuffer.bitIndex_ = 0;
165 rBuffer.index_ = 0;
166 rBuffer.length_ = 0;
167 EXPECT_FALSE(message2->Decode(rBuffer));
168 }
169
170 HWTEST_F(SmsServicesMmsGtest, SmsTeleSvcUserData_0001, Function | MediumTest | Level2)
171 {
172 auto initValue = SmsEncodingType::RESERVED;
173 auto testValue = SmsEncodingType::ASCII_7BIT;
174 SmsTeleSvcUserData v1;
175 memset_s(&v1, sizeof(SmsTeleSvcUserData), 0x00, sizeof(SmsTeleSvcUserData));
176 v1.encodeType = testValue;
177 SmsTeleSvcUserData v2;
178 v2.encodeType = initValue;
179 bool headerInd = false;
180
181 auto message1 = std::make_shared<CdmaSmsUserData>(v1, headerInd);
182 SmsWriteBuffer wBuffer;
183 EXPECT_TRUE(message1->Encode(wBuffer));
184 auto buffer = wBuffer.GetPduBuffer();
185 EXPECT_GT(buffer->size(), 0);
186 std::stringstream ss;
187 ss.clear();
188 for (uint16_t i = 0; i < buffer->size(); i++) {
189 ss << (*buffer)[i];
190 }
191 SmsReadBuffer rBuffer(ss.str());
192 auto message2 = std::make_shared<CdmaSmsUserData>(v2, headerInd);
193 EXPECT_TRUE(message2->Decode(rBuffer));
194 EXPECT_EQ(v2.encodeType, testValue);
195
196 message2->data_.userData.headerCnt = TEST_MAX_UD_HEADER_NUM;
197 EXPECT_FALSE(message2->EncodeHeader7Bit(wBuffer));
198 EXPECT_FALSE(message2->EncodeAscii7Bit(wBuffer));
199 EXPECT_FALSE(message2->EncodeGsm7Bit(wBuffer));
200 EXPECT_FALSE(message2->EncodeHeaderUnicode(wBuffer));
201 EXPECT_FALSE(message2->EncodeUnicode(wBuffer));
202 }
203
204 HWTEST_F(SmsServicesMmsGtest, SmsTeleSvcUserData_0002, Function | MediumTest | Level2)
205 {
206 auto initValue = SmsEncodingType::RESERVED;
207 auto testValue = SmsEncodingType::ASCII_7BIT;
208 SmsTeleSvcUserData v1;
209 memset_s(&v1, sizeof(SmsTeleSvcUserData), 0x00, sizeof(SmsTeleSvcUserData));
210 v1.encodeType = testValue;
211 SmsTeleSvcUserData v2;
212 v2.encodeType = initValue;
213 bool headerInd = false;
214
215 auto message1 = std::make_shared<CdmaSmsUserData>(v1, headerInd);
216 SmsWriteBuffer wBuffer;
217 EXPECT_TRUE(message1->Encode(wBuffer));
218 auto buffer = wBuffer.GetPduBuffer();
219 EXPECT_GT(buffer->size(), 0);
220 std::stringstream ss;
221 ss.clear();
222 for (uint16_t i = 0; i < buffer->size(); i++) {
223 ss << (*buffer)[i];
224 }
225 SmsReadBuffer rBuffer(ss.str());
226 auto message2 = std::make_shared<CdmaSmsUserData>(v2, headerInd);
227 EXPECT_TRUE(message2->Decode(rBuffer));
228 EXPECT_EQ(v2.encodeType, testValue);
229
230 message2->data_.userData.length = TEST_MAX_USER_DATA_LEN;
231 EXPECT_FALSE(message2->Encode8BitData(wBuffer));
232
233 rBuffer.bitIndex_ = 0;
234 rBuffer.index_ = 0;
235 rBuffer.length_ = 0;
236 EXPECT_FALSE(message2->Decode(rBuffer));
237
238 message2->headerInd_ = true;
239 EXPECT_EQ(message2->DecodeHeader7Bit(rBuffer), 0);
240 EXPECT_FALSE(message2->DecodeAscii7Bit(rBuffer, 0, BIT7));
241 EXPECT_FALSE(message2->DecodeAscii7Bit(rBuffer, TEST_MAX_FIELD_LEN, 0));
242 EXPECT_FALSE(message2->DecodeAscii7Bit(rBuffer, 1, 0));
243 }
244
245 HWTEST_F(SmsServicesMmsGtest, SmsTeleSvcUserData_0003, Function | MediumTest | Level2)
246 {
247 auto initValue = SmsEncodingType::RESERVED;
248 auto testValue = SmsEncodingType::ASCII_7BIT;
249 SmsTeleSvcUserData v1;
250 memset_s(&v1, sizeof(SmsTeleSvcUserData), 0x00, sizeof(SmsTeleSvcUserData));
251 v1.encodeType = testValue;
252 SmsTeleSvcUserData v2;
253 v2.encodeType = initValue;
254 bool headerInd = false;
255
256 auto message1 = std::make_shared<CdmaSmsUserData>(v1, headerInd);
257 SmsWriteBuffer wBuffer;
258 EXPECT_TRUE(message1->Encode(wBuffer));
259 auto buffer = wBuffer.GetPduBuffer();
260 EXPECT_GT(buffer->size(), 0);
261 std::stringstream ss;
262 ss.clear();
263 for (uint16_t i = 0; i < buffer->size(); i++) {
264 ss << (*buffer)[i];
265 }
266 SmsReadBuffer rBuffer(ss.str());
267 auto message2 = std::make_shared<CdmaSmsUserData>(v2, headerInd);
268 EXPECT_TRUE(message2->Decode(rBuffer));
269 EXPECT_EQ(v2.encodeType, testValue);
270
271 rBuffer.bitIndex_ = 0;
272 rBuffer.index_ = 0;
273 rBuffer.length_ = 0;
274 EXPECT_FALSE(message2->DecodeGsm7Bit(rBuffer, 0, BIT7));
275 EXPECT_FALSE(message2->DecodeGsm7Bit(rBuffer, MAX_FIELD_LEN, 0));
276
277 message2->data_.userData.length = TEST_MAX_USER_DATA_LEN;
278 EXPECT_FALSE(message2->Decode8BitData(rBuffer));
279 }
280
281 HWTEST_F(SmsServicesMmsGtest, CdmaSmsCmasData_0001, Function | MediumTest | Level2)
282 {
283 SmsTeleSvcCmasData v1;
284 std::stringstream ss;
285 ss.clear();
286 ss << static_cast<uint8_t>(CdmaSmsSubParameter::USER_DATA);
287 uint8_t len = TEST_DATA_LEN;
288 ss << static_cast<uint8_t>(len);
289 for (uint8_t i = 0; i < len; i++) {
290 ss << static_cast<uint8_t>(0x00);
291 }
292 SmsReadBuffer rBuffer(ss.str());
293 auto message1 = std::make_shared<CdmaSmsCmasData>(v1);
294 rBuffer.bitIndex_ = 0;
295 rBuffer.index_ = 0;
296 rBuffer.length_ = 0;
297 EXPECT_FALSE(message1->DecodeData(rBuffer));
298 EXPECT_FALSE(message1->DecodeType0Data(rBuffer));
299 EXPECT_FALSE(message1->DecodeType1Data(rBuffer));
300 EXPECT_FALSE(message1->DecodeType2Data(rBuffer));
301 EXPECT_FALSE(message1->DecodeAbsTime(rBuffer));
302 }
303
304 HWTEST_F(SmsServicesMmsGtest, ImsRegStateCallbackStub_0001, Function | MediumTest | Level1)
305 {
306 ImsRegStateCallbackStub stub(nullptr);
307 MessageParcel data;
308 MessageParcel reply;
309 MessageOption option;
310 EXPECT_EQ(stub.OnRemoteRequest(0, data, reply, option), TELEPHONY_ERR_DESCRIPTOR_MISMATCH);
311 data.WriteInterfaceToken(stub.GetDescriptor());
312 data.WriteInt32(0);
313 data.WriteInt32(0);
314 data.WriteInt32(0);
315 EXPECT_EQ(stub.OnRemoteRequest(0, data, reply, option), TELEPHONY_SUCCESS);
316 }
317
318 HWTEST_F(SmsServicesMmsGtest, SmsStateHandler_0001, Function | MediumTest | Level1)
319 {
320 SmsStateHandler handler;
321 handler.smsStateObserver_ = nullptr;
322 EXPECT_FALSE(handler.UnRegisterHandler());
323 handler.UnInit();
324 }
325
326 HWTEST_F(SmsServicesMmsGtest, SmsSender_0001, Function | MediumTest | Level1)
327 {
328 bool hasRetry = false;
__anonadead6e80202(std::shared_ptr<SmsSendIndexer>) 329 GsmSmsSender sender(0, [&hasRetry](std::shared_ptr<SmsSendIndexer>) { hasRetry = true; });
330 AppExecFwk::InnerEvent::Pointer event = AppExecFwk::InnerEvent::Get(MSG_SMS_RETRY_DELIVERY);
331 sender.ProcessEvent(event);
332 EXPECT_TRUE(hasRetry);
333 event = AppExecFwk::InnerEvent::Get(MSG_SMS_RETRY_DELIVERY, std::make_shared<SendSmsResultInfo>());
334 EXPECT_EQ(sender.FindCacheMapAndTransform(event), nullptr);
335 sender.sendCacheMap_[0] = nullptr;
336 EXPECT_EQ(sender.FindCacheMapAndTransform(event), nullptr);
337 event = AppExecFwk::InnerEvent::Get(MSG_SMS_RETRY_DELIVERY, std::make_shared<RadioResponseInfo>());
338 EXPECT_EQ(sender.FindCacheMapAndTransform(event), nullptr);
339 sender.sendCacheMap_.clear();
340 EXPECT_EQ(sender.FindCacheMapAndTransform(event), nullptr);
341 }
342
343 HWTEST_F(SmsServicesMmsGtest, GsmCbUmtsCodec_0001, Function | MediumTest | Level1)
344 {
345 GsmCbUmtsCodec codec(nullptr, nullptr, nullptr);
346 EXPECT_FALSE(codec.Decode3gHeader());
347 std::shared_ptr<GsmCbCodec::GsmCbMessageHeader> header = std::make_shared<GsmCbCodec::GsmCbMessageHeader>();
348 std::shared_ptr<GsmCbPduDecodeBuffer> buffer = std::make_shared<GsmCbPduDecodeBuffer>(0);
349 buffer->totolLength_ = 0;
350 std::shared_ptr<GsmCbCodec> cbCodec = std::make_shared<GsmCbCodec>();
351 codec.cbHeader_ = header;
352 EXPECT_FALSE(codec.Decode3gHeader());
353 codec.cbHeader_ = nullptr;
354 codec.cbPduBuffer_ = buffer;
355 EXPECT_FALSE(codec.Decode3gHeader());
356 codec.cbPduBuffer_ = nullptr;
357 codec.cbCodec_ = cbCodec;
358 EXPECT_FALSE(codec.Decode3gHeader());
359 codec.cbHeader_ = header;
360 EXPECT_FALSE(codec.Decode3gHeader());
361 codec.cbPduBuffer_ = buffer;
362 EXPECT_FALSE(codec.Decode3gHeader());
363 codec.cbCodec_ = nullptr;
364 EXPECT_FALSE(codec.Decode3gHeader());
365 codec.cbCodec_ = cbCodec;
366 codec.cbHeader_ = nullptr;
367 EXPECT_FALSE(codec.Decode3gHeader());
368 }
369
370 HWTEST_F(SmsServicesMmsGtest, SmsReceiveHandlerDisable_0001, Function | MediumTest | Level1)
371 {
372 system::SetParameter("persist.edm.sms_disable", "true");
373 AppExecFwk::InnerEvent::Pointer event = AppExecFwk::InnerEvent::Get(RadioEvent::RADIO_GSM_SMS, 1);
374 std::shared_ptr<SmsReceiveHandler> smsReceiveHandler = std::make_shared<CdmaSmsReceiveHandler>(INVALID_SLOTID);
375 smsReceiveHandler->ProcessEvent(event);
376 event = AppExecFwk::InnerEvent::Get(RadioEvent::RADIO_CDMA_SMS, 1);
377 smsReceiveHandler->ProcessEvent(event);
378 event = AppExecFwk::InnerEvent::Get(RadioEvent::RADIO_CONNECTED, 1);
379 smsReceiveHandler->ProcessEvent(event);
380 event = nullptr;
381 smsReceiveHandler->ProcessEvent(event);
382 std::shared_ptr<SmsReceiveIndexer> indexer = nullptr;
383 std::shared_ptr<SmsBaseMessage> smsBaseMessage = nullptr;
384 std::shared_ptr<vector<string>> pdus = nullptr;
385 auto reliabilityHandler = std::make_shared<SmsReceiveReliabilityHandler>(INVALID_SLOTID);
386 reliabilityHandler->DeleteMessageFormDb(SMS_REF_ID);
387 smsReceiveHandler->CombineMessagePart(indexer);
388
389 reliabilityHandler->CheckBlockedPhoneNumber(BLOCK_NUMBER);
390 reliabilityHandler->DeleteAutoSmsFromDB(reliabilityHandler, 0, 0);
391 reliabilityHandler->SendBroadcast(indexer, pdus);
392 smsReceiveHandler->HandleReceivedSms(smsBaseMessage);
393 indexer = std::make_shared<SmsReceiveIndexer>();
394 smsReceiveHandler->CombineMessagePart(indexer);
395 indexer->msgCount_ = 1;
396 indexer->destPort_ = WAP_PUSH_PORT;
397 smsReceiveHandler->CombineMessagePart(indexer);
398 reliabilityHandler->SendBroadcast(indexer, pdus);
399 pdus = std::make_shared<vector<string>>();
400 string pud = "qwe";
401 pdus->push_back(pud);
402 reliabilityHandler->SendBroadcast(indexer, pdus);
403 smsReceiveHandler->CombineMultiPageMessage(indexer, pdus, reliabilityHandler);
404 smsReceiveHandler->UpdateMultiPageMessage(indexer, pdus);
405 indexer->destPort_ = TEXT_PORT_NUM;
406 reliabilityHandler->SendBroadcast(indexer, pdus);
407 smsReceiveHandler->AddMsgToDB(indexer);
408 smsReceiveHandler->IsRepeatedMessagePart(indexer);
409 indexer = nullptr;
410 EXPECT_FALSE(smsReceiveHandler->AddMsgToDB(indexer));
411 system::SetParameter("persist.edm.sms_disable", "false");
412 }
413
414 HWTEST_F(SmsServicesMmsGtest, SmsServiceSendMessageDisable_0001, Function | MediumTest | Level1)
415 {
416 int32_t slotId = 0;
417 std::u16string desAddr = u"";
418 sptr<ISendShortMessageCallback> sendCallback;
419 sptr<IDeliveryShortMessageCallback> deliveryCallback;
420 auto smsService = DelayedSingleton<SmsService>::GetInstance();
421 AccessMmsToken token;
422 system::SetParameter("persist.edm.sms_disable", "true");
423 int32_t ret = smsService->SendMessage(slotId, desAddr, desAddr, desAddr, sendCallback, deliveryCallback, true);
424 EXPECT_TRUE(ret == TELEPHONY_ERR_POLICY_DISABLED);
425 ret = smsService->SendMessage(slotId, desAddr, desAddr, desAddr, sendCallback, deliveryCallback, false);
426 EXPECT_TRUE(ret == TELEPHONY_ERR_POLICY_DISABLED);
427 uint16_t port = 1;
428 uint8_t *data = nullptr;
429 ret = smsService->SendMessage(slotId, desAddr, desAddr, port, data, port, sendCallback, deliveryCallback);
430 EXPECT_TRUE(ret == TELEPHONY_ERR_POLICY_DISABLED);
431 std::string telephone = "13888888888";
432 uint16_t dataBaseId = 0;
433 smsService->InsertSessionAndDetail(slotId, telephone, telephone, dataBaseId);
434 smsService->InsertSessionAndDetail(slotId, "10000", "text", dataBaseId);
435 smsService->InsertSessionAndDetail(slotId, "10000,10001", "text", dataBaseId);
436 smsService->InsertSessionAndDetail(slotId, "11112123", "text", dataBaseId);
437 smsService->InsertSessionAndDetail(slotId, "invalid_number", "text", dataBaseId);
438
439 bool isSupported = false;
440 slotId = 0;
441 smsService->IsImsSmsSupported(slotId, isSupported);
442 std::u16string format = u"";
443 smsService->GetImsShortMessageFormat(format);
444 smsService->HasSmsCapability();
445 int32_t setSmscRes = 0;
446 setSmscRes = smsService->SetSmscAddr(slotId, desAddr);
447 desAddr = u" test";
448 string sca = StringUtils::ToUtf8(desAddr);
449 smsService->TrimSmscAddr(sca);
450 desAddr = u"test ";
451 sca = StringUtils::ToUtf8(desAddr);
452 smsService->TrimSmscAddr(sca);
453 int32_t smscRes = 0;
454
455 smscRes = smsService->GetSmscAddr(slotId, desAddr);
456 system::SetParameter("persist.edm.sms_disable", "false");
457 EXPECT_GE(setSmscRes, TELEPHONY_ERR_SLOTID_INVALID);
458 EXPECT_GE(smscRes, TELEPHONY_ERR_ARGUMENT_INVALID);
459 EXPECT_TRUE(smsService != nullptr);
460 }
461 } // namespace Telephony
462 } // namespace OHOS