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 #include "gtest/gtest.h"
17 #define private public
18 #define protected public
19 #include "ims_sms_client.h"
20 #include "ims_sms_proxy.h"
21 #include "ims_sms_callback_stub.h"
22 #include "mock/mock_ims_core_service_interface.h"
23 #include "mock/mock_ims_sms_callback_interface.h"
24 #include "mock/mock_ims_sms_interface.h"
25 #include "mock/mock_remote_object.h"
26 #include "sms_persist_helper.h"
27
28 namespace OHOS {
29 namespace Telephony {
30 using namespace testing::ext;
31
32 class SmsImsServiceInteractionTest : public testing::Test {
33 public:
34 static void SetUpTestCase();
35 static void TearDownTestCase();
36 void SetUp();
37 void TearDown();
38 };
SetUpTestCase()39 void SmsImsServiceInteractionTest::SetUpTestCase() {}
40
41 constexpr uint32_t EVENT_RELEASE_DATA_SHARE_HELPER = 10000;
TearDownTestCase()42 void SmsImsServiceInteractionTest::TearDownTestCase()
43 {
44 DelayedSingleton<SmsPersistHelper>::GetInstance()->RemoveEvent(EVENT_RELEASE_DATA_SHARE_HELPER);
45 }
SetUp()46 void SmsImsServiceInteractionTest::SetUp() {}
TearDown()47 void SmsImsServiceInteractionTest::TearDown() {}
48
49 /**
50 * @tc.number Telephony_SmsImsServiceInteractionTest_smsImsServiceInteractionTest_001
51 * @tc.name smsServiceProxyTest_001
52 * @tc.desc Function test
53 */
54 HWTEST_F(SmsImsServiceInteractionTest, smsImsServiceInteractionTest_001, Function | MediumTest | Level1)
55 {
56 sptr<ImsSmsInterface> pImsSms = new MockImsSms();
57 DelayedSingleton<ImsSmsClient>::GetInstance()->imsSmsProxy_ = pImsSms;
58 DelayedSingleton<ImsSmsClient>::GetInstance()->Init();
59 DelayedSingleton<ImsSmsClient>::GetInstance()->GetImsSmsProxy();
60 EXPECT_EQ(DelayedSingleton<ImsSmsClient>::GetInstance()->IsConnect(), true);
61 DelayedSingleton<ImsSmsClient>::DestroyInstance();
62 }
63
64 /**
65 * @tc.number Telephony_SmsImsServiceInteractionTest_smsImsServiceInteractionTest_002
66 * @tc.name smsServiceProxyTest_001
67 * @tc.desc Function test
68 */
69 HWTEST_F(SmsImsServiceInteractionTest, smsImsServiceInteractionTest_002, Function | MediumTest | Level1)
70 {
71 EXPECT_EQ(DelayedSingleton<ImsSmsClient>::GetInstance()->RegisterImsSmsCallback(), TELEPHONY_ERR_LOCAL_PTR_NULL);
72 DelayedSingleton<ImsSmsClient>::DestroyInstance();
73 }
74
75 /**
76 * @tc.number Telephony_SmsImsServiceInteractionTest_smsImsServiceInteractionTest_003
77 * @tc.name smsServiceProxyTest_001
78 * @tc.desc Function test
79 */
80 HWTEST_F(SmsImsServiceInteractionTest, smsImsServiceInteractionTest_003, Function | MediumTest | Level1)
81 {
82 sptr<MockImsSms> pImsSms = new MockImsSms();
83 pImsSms->retRegisterImsSmsCallback = 1;
84 DelayedSingleton<ImsSmsClient>::GetInstance()->imsSmsProxy_ = pImsSms;
85 EXPECT_EQ(DelayedSingleton<ImsSmsClient>::GetInstance()->RegisterImsSmsCallback(), TELEPHONY_ERR_FAIL);
86 DelayedSingleton<ImsSmsClient>::DestroyInstance();
87 }
88
89 /**
90 * @tc.number Telephony_SmsImsServiceInteractionTest_smsImsServiceInteractionTest_004
91 * @tc.name smsServiceProxyTest_001
92 * @tc.desc Function test
93 */
94 HWTEST_F(SmsImsServiceInteractionTest, smsImsServiceInteractionTest_004, Function | MediumTest | Level1)
95 {
96 sptr<MockImsSms> pImsSms = new MockImsSms();
97 pImsSms->retImsSendMessage = 1;
98 DelayedSingleton<ImsSmsClient>::GetInstance()->imsSmsProxy_ = pImsSms;
99 int32_t slotId = 0;
100 ImsMessageInfo imsMessageInfo;
101 EXPECT_EQ(DelayedSingleton<ImsSmsClient>::GetInstance()->ImsSendMessage(slotId, imsMessageInfo),
102 pImsSms->retImsSendMessage);
103 DelayedSingleton<ImsSmsClient>::DestroyInstance();
104 }
105
106 /**
107 * @tc.number Telephony_SmsImsServiceInteractionTest_smsImsServiceInteractionTest_005
108 * @tc.name smsServiceProxyTest_001
109 * @tc.desc Function test
110 */
111 HWTEST_F(SmsImsServiceInteractionTest, smsImsServiceInteractionTest_005, Function | MediumTest | Level1)
112 {
113 sptr<MockImsSms> pImsSms = new MockImsSms();
114 pImsSms->retImsSetSmsConfig = 1;
115 DelayedSingleton<ImsSmsClient>::GetInstance()->imsSmsProxy_ = pImsSms;
116 int32_t slotId = 0, imsSmsConfig = 0;
117 EXPECT_EQ(DelayedSingleton<ImsSmsClient>::GetInstance()->ImsSetSmsConfig(slotId, imsSmsConfig),
118 pImsSms->retImsSetSmsConfig);
119 DelayedSingleton<ImsSmsClient>::DestroyInstance();
120 }
121
122 /**
123 * @tc.number Telephony_SmsImsServiceInteractionTest_smsImsServiceInteractionTest_006
124 * @tc.name smsServiceProxyTest_001
125 * @tc.desc Function test
126 */
127 HWTEST_F(SmsImsServiceInteractionTest, smsImsServiceInteractionTest_006, Function | MediumTest | Level1)
128 {
129 sptr<MockImsSms> pImsSms = new MockImsSms();
130 pImsSms->retImsGetSmsConfig = 1;
131 DelayedSingleton<ImsSmsClient>::GetInstance()->imsSmsProxy_ = pImsSms;
132 int32_t slotId = 0;
133 EXPECT_EQ(DelayedSingleton<ImsSmsClient>::GetInstance()->ImsGetSmsConfig(slotId), pImsSms->retImsGetSmsConfig);
134 DelayedSingleton<ImsSmsClient>::DestroyInstance();
135 }
136
137 /**
138 * @tc.number Telephony_SmsImsServiceInteractionTest_smsImsServiceInteractionTest_007
139 * @tc.name smsServiceProxyTest_001
140 * @tc.desc Function test
141 */
142 HWTEST_F(SmsImsServiceInteractionTest, smsImsServiceInteractionTest_007, Function | MediumTest | Level1)
143 {
144 int32_t slotId = 0;
145 std::shared_ptr<AppExecFwk::EventHandler> handler = nullptr;
146 EXPECT_EQ(DelayedSingleton<ImsSmsClient>::GetInstance()->RegisterImsSmsCallbackHandler(slotId, handler),
147 TELEPHONY_ERR_LOCAL_PTR_NULL);
148 EXPECT_EQ(DelayedSingleton<ImsSmsClient>::GetInstance()->GetHandler(slotId), handler);
149 DelayedSingleton<ImsSmsClient>::DestroyInstance();
150 }
151
152 /**
153 * @tc.number Telephony_SmsImsServiceInteractionTest_smsImsServiceInteractionTest_008
154 * @tc.name smsServiceProxyTest_001
155 * @tc.desc Function test
156 */
157 HWTEST_F(SmsImsServiceInteractionTest, smsImsServiceInteractionTest_008, Function | MediumTest | Level1)
158 {
159 int32_t slotId = 0;
160 std::shared_ptr<AppExecFwk::EventHandler> handler = std::make_shared<AppExecFwk::EventHandler>();
161 EXPECT_EQ(DelayedSingleton<ImsSmsClient>::GetInstance()->RegisterImsSmsCallbackHandler(slotId, handler),
162 TELEPHONY_SUCCESS);
163 EXPECT_EQ(DelayedSingleton<ImsSmsClient>::GetInstance()->GetHandler(slotId), handler);
164 DelayedSingleton<ImsSmsClient>::DestroyInstance();
165 }
166
167 /**
168 * @tc.number Telephony_SmsImsServiceInteractionTest_smsImsServiceInteractionTest_009
169 * @tc.name smsServiceProxyTest_001
170 * @tc.desc Function test
171 */
172 HWTEST_F(SmsImsServiceInteractionTest, smsImsServiceInteractionTest_009, Function | MediumTest | Level1)
173 {
174 sptr<MockImsSms> pImsSms = new MockImsSms();
175 sptr<MockImsCoreService> pImsCoreService = new MockImsCoreService();
176 sptr<MockImsSmsCallback> pImsSmsCallback = new MockImsSmsCallback();
177 DelayedSingleton<ImsSmsClient>::GetInstance()->imsSmsProxy_ = pImsSms;
178 DelayedSingleton<ImsSmsClient>::GetInstance()->imsSmsCallback_ = pImsSmsCallback;
179 DelayedSingleton<ImsSmsClient>::GetInstance()->imsCoreServiceProxy_ = pImsCoreService;
180
181 DelayedSingleton<ImsSmsClient>::GetInstance()->Clean();
182 EXPECT_EQ(DelayedSingleton<ImsSmsClient>::GetInstance()->imsSmsProxy_, nullptr);
183 EXPECT_EQ(DelayedSingleton<ImsSmsClient>::GetInstance()->imsSmsCallback_, nullptr);
184 EXPECT_EQ(DelayedSingleton<ImsSmsClient>::GetInstance()->imsCoreServiceProxy_, nullptr);
185 DelayedSingleton<ImsSmsClient>::DestroyInstance();
186 }
187
188 /**
189 * @tc.number Telephony_SmsImsServiceInteractionTest_smsImsServiceInteractionTest_010
190 * @tc.name smsServiceProxyTest_001
191 * @tc.desc Function test
192 */
193 HWTEST_F(SmsImsServiceInteractionTest, smsImsServiceInteractionTest_010, Function | MediumTest | Level1)
194 {
195 ImsSmsClient::SystemAbilityListener listerner;
196 int32_t systemAbilityId = 0;
197 std::string deviceId = "";
198 EXPECT_EQ(DelayedSingleton<ImsSmsClient>::GetInstance()->IsConnect(), false);
199 listerner.OnRemoveSystemAbility(systemAbilityId, deviceId);
200 EXPECT_EQ(DelayedSingleton<ImsSmsClient>::GetInstance()->IsConnect(), false);
201
202 sptr<MockImsSms> pImsSms = new MockImsSms();
203 sptr<MockImsCoreService> pImsCoreService = new MockImsCoreService();
204 sptr<MockImsSmsCallback> pImsSmsCallback = new MockImsSmsCallback();
205 DelayedSingleton<ImsSmsClient>::GetInstance()->imsSmsProxy_ = pImsSms;
206 DelayedSingleton<ImsSmsClient>::GetInstance()->imsSmsCallback_ = pImsSmsCallback;
207 DelayedSingleton<ImsSmsClient>::GetInstance()->imsCoreServiceProxy_ = pImsCoreService;
208
209 EXPECT_EQ(DelayedSingleton<ImsSmsClient>::GetInstance()->IsConnect(), true);
210 listerner.OnRemoveSystemAbility(systemAbilityId, deviceId);
211 EXPECT_EQ(DelayedSingleton<ImsSmsClient>::GetInstance()->IsConnect(), false);
212 EXPECT_EQ(DelayedSingleton<ImsSmsClient>::GetInstance()->imsSmsProxy_, nullptr);
213 EXPECT_EQ(DelayedSingleton<ImsSmsClient>::GetInstance()->imsSmsCallback_, nullptr);
214 EXPECT_EQ(DelayedSingleton<ImsSmsClient>::GetInstance()->imsCoreServiceProxy_, nullptr);
215 DelayedSingleton<ImsSmsClient>::DestroyInstance();
216 }
217
218 /**
219 * @tc.number Telephony_SmsImsServiceInteractionTest_smsImsServiceInteractionTest_011
220 * @tc.name smsServiceProxyTest_001
221 * @tc.desc Function test
222 */
223 HWTEST_F(SmsImsServiceInteractionTest, smsImsServiceInteractionTest_011, Function | MediumTest | Level1)
224 {
225 std::unique_ptr<ImsSmsCallbackStub> imsSmsCallbackStub = std::make_unique<ImsSmsCallbackStub>();
226
227 MessageParcel data;
228 MessageParcel reply;
229 MessageOption option;
230 uint32_t code = static_cast<uint32_t>(ImsSmsCallbackInterfaceCode::IMS_SEND_MESSAGE);
231 EXPECT_EQ(imsSmsCallbackStub->OnRemoteRequest(code, data, reply, option), TELEPHONY_ERR_DESCRIPTOR_MISMATCH);
232 }
233
234 /**
235 * @tc.number Telephony_SmsImsServiceInteractionTest_smsImsServiceInteractionTest_012
236 * @tc.name smsServiceProxyTest_001
237 * @tc.desc Function test
238 */
239 HWTEST_F(SmsImsServiceInteractionTest, smsImsServiceInteractionTest_012, Function | MediumTest | Level1)
240 {
241 std::unique_ptr<ImsSmsCallbackStub> imsSmsCallbackStub = std::make_unique<ImsSmsCallbackStub>();
242
243 MessageParcel data;
244 MessageParcel reply;
245 MessageOption option;
246 uint32_t code = static_cast<uint32_t>(1<<31);
247 data.WriteInterfaceToken(ImsSmsCallbackStub::GetDescriptor());
248 EXPECT_EQ(imsSmsCallbackStub->OnRemoteRequest(code, data, reply, option), IPC_STUB_UNKNOW_TRANS_ERR);
249 }
250
251 /**
252 * @tc.number Telephony_SmsImsServiceInteractionTest_smsImsServiceInteractionTest_013
253 * @tc.name smsServiceProxyTest_001
254 * @tc.desc Function test
255 */
256 HWTEST_F(SmsImsServiceInteractionTest, smsImsServiceInteractionTest_013, Function | MediumTest | Level1)
257 {
258 MessageParcel data;
259 MessageParcel reply;
260 MessageOption option;
261 int32_t slotId = 0;
262 int32_t imsSmsConfig = 0;
263 std::unique_ptr<ImsSmsCallbackStub> imsSmsCallbackStub = std::make_unique<ImsSmsCallbackStub>();
264 uint32_t code = static_cast<uint32_t>(ImsSmsCallbackInterfaceCode::IMS_GET_SMS_CONFIG);
265 data.WriteInterfaceToken(ImsSmsCallbackStub::GetDescriptor());
266 data.WriteInt32(slotId);
267 data.WriteInt32(imsSmsConfig);
268 EXPECT_EQ(imsSmsCallbackStub->OnRemoteRequest(code, data, reply, option), TELEPHONY_SUCCESS);
269 }
270
271 /**
272 * @tc.number Telephony_SmsImsServiceInteractionTest_smsImsServiceInteractionTest_014
273 * @tc.name smsServiceProxyTest_001
274 * @tc.desc Function test
275 */
276 HWTEST_F(SmsImsServiceInteractionTest, smsImsServiceInteractionTest_014, Function | MediumTest | Level1)
277 {
278 std::unique_ptr<ImsSmsCallbackStub> imsSmsCallbackStub = std::make_unique<ImsSmsCallbackStub>();
279
280 RadioResponseInfo radioResponseInfo;
281 MessageParcel data;
282 MessageParcel reply;
283 MessageOption option;
284 int32_t slotId = 0;
285 uint32_t code = static_cast<uint32_t>(ImsSmsCallbackInterfaceCode::IMS_SEND_MESSAGE);
286 data.WriteInterfaceToken(ImsSmsCallbackStub::GetDescriptor());
287 data.WriteInt32(slotId);
288 data.WriteRawData(&radioResponseInfo, sizeof(RadioResponseInfo));
289 EXPECT_EQ(imsSmsCallbackStub->OnRemoteRequest(code, data, reply, option), TELEPHONY_SUCCESS);
290 DelayedSingleton<ImsSmsClient>::DestroyInstance();
291 }
292
293 /**
294 * @tc.number Telephony_SmsImsServiceInteractionTest_smsImsServiceInteractionTest_015
295 * @tc.name smsServiceProxyTest_001
296 * @tc.desc Function test
297 */
298 HWTEST_F(SmsImsServiceInteractionTest, smsImsServiceInteractionTest_015, Function | MediumTest | Level1)
299 {
300 std::unique_ptr<ImsSmsCallbackStub> imsSmsCallbackStub = std::make_unique<ImsSmsCallbackStub>();
301
302 SendSmsResultInfo sendSmsResultInfo;
303 MessageParcel data;
304 MessageParcel reply;
305 MessageOption option;
306 int32_t slotId = 0;
307 uint32_t code = static_cast<uint32_t>(ImsSmsCallbackInterfaceCode::IMS_SEND_MESSAGE);
308 data.WriteInterfaceToken(ImsSmsCallbackStub::GetDescriptor());
309 data.WriteInt32(slotId);
310 data.WriteRawData(&sendSmsResultInfo, sizeof(SendSmsResultInfo));
311 EXPECT_GE(imsSmsCallbackStub->OnRemoteRequest(code, data, reply, option), TELEPHONY_SUCCESS);
312 DelayedSingleton<ImsSmsClient>::DestroyInstance();
313 }
314
315 /**
316 * @tc.number Telephony_SmsImsServiceInteractionTest_smsImsServiceInteractionTest_016
317 * @tc.name smsServiceProxyTest_001
318 * @tc.desc Function test
319 */
320 HWTEST_F(SmsImsServiceInteractionTest, smsImsServiceInteractionTest_016, Function | MediumTest | Level1)
321 {
322 std::unique_ptr<ImsSmsCallbackStub> imsSmsCallbackStub = std::make_unique<ImsSmsCallbackStub>();
323
324 RadioResponseInfo radioResponseInfo;
325 MessageParcel data;
326 MessageParcel reply;
327 MessageOption option;
328 int32_t slotId = 0;
329 uint32_t code = static_cast<uint32_t>(ImsSmsCallbackInterfaceCode::IMS_SET_SMS_CONFIG);
330 data.WriteInterfaceToken(ImsSmsCallbackStub::GetDescriptor());
331 data.WriteInt32(slotId);
332 data.WriteRawData(&radioResponseInfo, sizeof(RadioResponseInfo));
333 EXPECT_EQ(imsSmsCallbackStub->OnRemoteRequest(code, data, reply, option), TELEPHONY_SUCCESS);
334 DelayedSingleton<ImsSmsClient>::DestroyInstance();
335 }
336
337 /**
338 * @tc.number Telephony_SmsImsServiceInteractionTest_smsImsServiceInteractionTest_017
339 * @tc.name smsServiceProxyTest_001
340 * @tc.desc Function test
341 */
342 HWTEST_F(SmsImsServiceInteractionTest, smsImsServiceInteractionTest_017, Function | MediumTest | Level1)
343 {
344 sptr<MockRemoteObject> sptrRemoteObject = nullptr;
345 std::unique_ptr<MockImsSmsProxy> imsSmsProxy = std::make_unique<MockImsSmsProxy>(sptrRemoteObject);
346
347 int32_t slotId = 0;
348 ImsMessageInfo imsMessageInfo;
349 EXPECT_EQ(imsSmsProxy->ImsSendMessage(slotId, imsMessageInfo), TELEPHONY_ERR_IPC_CONNECT_STUB_FAIL);
350 }
351
352 /**
353 * @tc.number Telephony_SmsImsServiceInteractionTest_smsImsServiceInteractionTest_018
354 * @tc.name smsServiceProxyTest_001
355 * @tc.desc Function test
356 */
357 HWTEST_F(SmsImsServiceInteractionTest, smsImsServiceInteractionTest_018, Function | MediumTest | Level1)
358 {
359 sptr<MockRemoteObject> sptrRemoteObject = new MockRemoteObject();
360 sptrRemoteObject->retSendRequest = 0;
361 std::unique_ptr<MockImsSmsProxy> imsSmsProxy = std::make_unique<MockImsSmsProxy>(sptrRemoteObject);
362
363 int32_t slotId = 0;
364 ImsMessageInfo imsMessageInfo;
365 EXPECT_EQ(imsSmsProxy->ImsSendMessage(slotId, imsMessageInfo), 0);
366 }
367
368 /**
369 * @tc.number Telephony_SmsImsServiceInteractionTest_smsImsServiceInteractionTest_019
370 * @tc.name smsServiceProxyTest_001
371 * @tc.desc Function test
372 */
373 HWTEST_F(SmsImsServiceInteractionTest, smsImsServiceInteractionTest_019, Function | MediumTest | Level1)
374 {
375 sptr<MockRemoteObject> sptrRemoteObject = new MockRemoteObject();
376 sptrRemoteObject->retSendRequest = -1;
377 std::unique_ptr<MockImsSmsProxy> imsSmsProxy = std::make_unique<MockImsSmsProxy>(sptrRemoteObject);
378
379 int32_t slotId = 0;
380 ImsMessageInfo imsMessageInfo;
381 EXPECT_EQ(imsSmsProxy->ImsSendMessage(slotId, imsMessageInfo), TELEPHONY_ERR_IPC_CONNECT_STUB_FAIL);
382 }
383
384 /**
385 * @tc.number Telephony_SmsImsServiceInteractionTest_smsImsServiceInteractionTest_020
386 * @tc.name smsServiceProxyTest_001
387 * @tc.desc Function test
388 */
389 HWTEST_F(SmsImsServiceInteractionTest, smsImsServiceInteractionTest_020, Function | MediumTest | Level1)
390 {
391 sptr<MockRemoteObject> sptrRemoteObject = new MockRemoteObject();
392 sptrRemoteObject->retSendRequest = 0;
393 std::unique_ptr<MockImsSmsProxy> imsSmsProxy = std::make_unique<MockImsSmsProxy>(sptrRemoteObject);
394
395 int32_t slotId = 0;
396 int32_t imsSmsConfig = 0;
397 EXPECT_EQ(imsSmsProxy->ImsSetSmsConfig(slotId, imsSmsConfig), 0);
398 }
399
400 /**
401 * @tc.number Telephony_SmsImsServiceInteractionTest_smsImsServiceInteractionTest_021
402 * @tc.name smsServiceProxyTest_001
403 * @tc.desc Function test
404 */
405 HWTEST_F(SmsImsServiceInteractionTest, smsImsServiceInteractionTest_021, Function | MediumTest | Level1)
406 {
407 sptr<MockRemoteObject> sptrRemoteObject = new MockRemoteObject();
408 sptrRemoteObject->retSendRequest = 0;
409 std::unique_ptr<MockImsSmsProxy> imsSmsProxy = std::make_unique<MockImsSmsProxy>(sptrRemoteObject);
410
411 int32_t slotId = 0;
412 EXPECT_EQ(imsSmsProxy->ImsGetSmsConfig(slotId), 0);
413 }
414
415 /**
416 * @tc.number Telephony_SmsImsServiceInteractionTest_smsImsServiceInteractionTest_022
417 * @tc.name smsServiceProxyTest_001
418 * @tc.desc Function test
419 */
420 HWTEST_F(SmsImsServiceInteractionTest, smsImsServiceInteractionTest_022, Function | MediumTest | Level1)
421 {
422 sptr<MockRemoteObject> sptrRemoteObject = nullptr;
423 std::unique_ptr<MockImsSmsProxy> imsSmsProxy = std::make_unique<MockImsSmsProxy>(sptrRemoteObject);
424 EXPECT_EQ(imsSmsProxy->RegisterImsSmsCallback(nullptr), TELEPHONY_ERR_ARGUMENT_INVALID);
425 }
426
427 /**
428 * @tc.number Telephony_SmsImsServiceInteractionTest_smsImsServiceInteractionTest_023
429 * @tc.name smsServiceProxyTest_001
430 * @tc.desc Function test
431 */
432 HWTEST_F(SmsImsServiceInteractionTest, smsImsServiceInteractionTest_023, Function | MediumTest | Level1)
433 {
434 sptr<MockRemoteObject> sptrRemoteObject = nullptr;
435 std::unique_ptr<MockImsSmsProxy> imsSmsProxy = std::make_unique<MockImsSmsProxy>(sptrRemoteObject);
436 sptr<MockImsSmsCallback> pImsSmsCallback = new MockImsSmsCallback();
437 EXPECT_EQ(imsSmsProxy->RegisterImsSmsCallback(pImsSmsCallback), TELEPHONY_ERR_WRITE_DATA_FAIL);
438 }
439
440 /**
441 * @tc.number Telephony_SmsImsServiceInteractionTest_smsImsServiceInteractionTest_024
442 * @tc.name smsServiceProxyTest_001
443 * @tc.desc Function test
444 */
445 HWTEST_F(SmsImsServiceInteractionTest, smsImsServiceInteractionTest_024, Function | MediumTest | Level1)
446 {
447 sptr<MockRemoteObject> sptrRemoteObject = new MockRemoteObject();
448 std::unique_ptr<MockImsSmsProxy> imsSmsProxy = std::make_unique<MockImsSmsProxy>(nullptr);
449 sptr<MockImsSmsCallback> pImsSmsCallback = new MockImsSmsCallback();
450 pImsSmsCallback->retRemoteObject = sptrRemoteObject;
451 EXPECT_EQ(imsSmsProxy->RegisterImsSmsCallback(pImsSmsCallback), TELEPHONY_ERR_IPC_CONNECT_STUB_FAIL);
452 }
453
454 /**
455 * @tc.number Telephony_SmsImsServiceInteractionTest_smsImsServiceInteractionTest_025
456 * @tc.name smsServiceProxyTest_001
457 * @tc.desc Function test
458 */
459 HWTEST_F(SmsImsServiceInteractionTest, smsImsServiceInteractionTest_025, Function | MediumTest | Level1)
460 {
461 sptr<MockRemoteObject> sptrRemoteObject = new MockRemoteObject();
462 sptrRemoteObject->retSendRequest = 0;
463 std::unique_ptr<MockImsSmsProxy> imsSmsProxy = std::make_unique<MockImsSmsProxy>(sptrRemoteObject);
464
465 sptr<MockImsSmsCallback> pImsSmsCallback = new MockImsSmsCallback();
466 pImsSmsCallback->retRemoteObject = sptrRemoteObject;
467 EXPECT_EQ(imsSmsProxy->RegisterImsSmsCallback(pImsSmsCallback), 0);
468 }
469
470 /**
471 * @tc.number Telephony_SmsImsServiceInteractionTest_smsImsServiceInteractionTest_026
472 * @tc.name smsServiceProxyTest_001
473 * @tc.desc Function test
474 */
475 HWTEST_F(SmsImsServiceInteractionTest, smsImsServiceInteractionTest_026, Function | MediumTest | Level1)
476 {
477 sptr<MockRemoteObject> sptrRemoteObject = new MockRemoteObject();
478 sptrRemoteObject->retSendRequest = -1;
479 std::unique_ptr<MockImsSmsProxy> imsSmsProxy = std::make_unique<MockImsSmsProxy>(sptrRemoteObject);
480
481 sptr<MockImsSmsCallback> pImsSmsCallback = new MockImsSmsCallback();
482 pImsSmsCallback->retRemoteObject = sptrRemoteObject;
483 EXPECT_EQ(imsSmsProxy->RegisterImsSmsCallback(pImsSmsCallback), TELEPHONY_ERR_IPC_CONNECT_STUB_FAIL);
484 }
485 }
486 }