1 /*
2 * Copyright (C) 2023 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 "delivery_short_message_callback_stub.h"
20 #include "gtest/gtest.h"
21 #include "send_short_message_callback_stub.h"
22 #include "sms_misc_manager.h"
23 #include "sms_mms_gtest.h"
24 #include "sms_service.h"
25 #include "system_ability_definition.h"
26
27 namespace OHOS {
28 namespace Telephony {
29 using namespace testing::ext;
30
31 namespace {
32 const std::string TEST_SOURCE_DATA = "srcData";
33 const std::string SMS_ADDR_ONE = "";
34 const std::string SMS_ADDR_TWO = " ";
35 const std::string SMS_ADDR_THREE = " 123 ";
36 const std::string SMS_ADDR_FOUR = "1 23";
37 const std::string SMS_ADDR_FIVE = " a 123 ";
38 const std::string SEND_MMS_FILE_URL = "1,2,";
39 const std::string VNET_MMSC = "http://mmsc.vnet.mobi";
40 } // namespace
41
42 class BranchSmsPartTest : public testing::Test {
43 public:
44 static void SetUpTestCase();
45 static void TearDownTestCase();
46 void SetUp();
47 void TearDown();
48 };
SetUpTestCase()49 void BranchSmsPartTest::SetUpTestCase() {}
50
TearDownTestCase()51 void BranchSmsPartTest::TearDownTestCase() {}
52
SetUp()53 void BranchSmsPartTest::SetUp() {}
54
TearDown()55 void BranchSmsPartTest::TearDown() {}
56
57 /**
58 * @tc.number Telephony_SmsMmsGtest_SmsInterfaceStub_0001
59 * @tc.name Test SmsInterfaceStub
60 * @tc.desc Function test
61 */
62 HWTEST_F(BranchSmsPartTest, SmsInterfaceStub_0001, Function | MediumTest | Level1)
63 {
64 AccessMmsToken token;
65 int32_t slotId = 0;
66 MessageParcel dataParcel;
67 dataParcel.WriteInt32(slotId);
68 dataParcel.WriteBuffer(TEST_SOURCE_DATA.c_str(), TEST_SOURCE_DATA.size());
69 dataParcel.RewindRead(0);
70 MessageParcel replyParcel;
71 uint32_t code = 0;
72 MessageOption option(MessageOption::TF_SYNC);
73 DelayedSingleton<SmsService>::GetInstance()->OnRemoteRequest(code, dataParcel, replyParcel, option);
74 DelayedSingleton<SmsService>::GetInstance()->OnSendSmsTextRequest(dataParcel, replyParcel, option);
75 DelayedSingleton<SmsService>::GetInstance()->OnSendSmsDataRequest(dataParcel, replyParcel, option);
76 DelayedSingleton<SmsService>::GetInstance()->OnGetSmscAddr(dataParcel, replyParcel, option);
77 DelayedSingleton<SmsService>::GetInstance()->OnAddSimMessage(dataParcel, replyParcel, option);
78 DelayedSingleton<SmsService>::GetInstance()->OnUpdateSimMessage(dataParcel, replyParcel, option);
79 DelayedSingleton<SmsService>::GetInstance()->OnGetAllSimMessages(dataParcel, replyParcel, option);
80 DelayedSingleton<SmsService>::GetInstance()->OnSplitMessage(dataParcel, replyParcel, option);
81 DelayedSingleton<SmsService>::GetInstance()->OnCreateMessage(dataParcel, replyParcel, option);
82 DelayedSingleton<SmsService>::GetInstance()->OnGetBase64Encode(dataParcel, replyParcel, option);
83 DelayedSingleton<SmsService>::GetInstance()->OnGetBase64Decode(dataParcel, replyParcel, option);
84 DelayedSingleton<SmsService>::GetInstance()->OnGetEncodeStringFunc(dataParcel, replyParcel, option);
85 DelayedSingleton<SmsService>::GetInstance()->OnGetSmsSegmentsInfo(dataParcel, replyParcel, option);
86
87 MessageParcel sendTextParcel;
88 sendTextParcel.WriteInt32(0);
89 sendTextParcel.WriteString16(Str8ToStr16(TEST_SOURCE_DATA));
90 sendTextParcel.WriteString16(Str8ToStr16(TEST_SOURCE_DATA));
91 sendTextParcel.WriteString16(Str8ToStr16(TEST_SOURCE_DATA));
92 sendTextParcel.WriteString(TEST_SOURCE_DATA);
93 DelayedSingleton<SmsService>::GetInstance()->OnSendSmsTextRequest(sendTextParcel, replyParcel, option);
94 sendTextParcel.WriteInt32(-1);
95 DelayedSingleton<SmsService>::GetInstance()->OnSendSmsTextRequest(sendTextParcel, replyParcel, option);
96 int32_t result = replyParcel.ReadInt32();
97 EXPECT_GE(result, 0);
98
99 MessageParcel sendDataParcel;
100 dataParcel.WriteInt32(0);
101 dataParcel.WriteString16(Str8ToStr16(TEST_SOURCE_DATA));
102 dataParcel.WriteString16(Str8ToStr16(TEST_SOURCE_DATA));
103 dataParcel.WriteInt16(0);
104 dataParcel.WriteInt16(TEST_SOURCE_DATA.size());
105 dataParcel.WriteRawData(TEST_SOURCE_DATA.c_str(), TEST_SOURCE_DATA.size());
106 DelayedSingleton<SmsService>::GetInstance()->OnSendSmsDataRequest(dataParcel, replyParcel, option);
107 sendTextParcel.WriteInt32(-1);
108 DelayedSingleton<SmsService>::GetInstance()->OnSendSmsDataRequest(dataParcel, replyParcel, option);
109 result = replyParcel.ReadInt32();
110 EXPECT_GE(result, 0);
111 }
112
113 /**
114 * @tc.number Telephony_SmsMmsGtest_SmsInterfaceStub_0002
115 * @tc.name Test SmsInterfaceStub
116 * @tc.desc Function test
117 */
118 HWTEST_F(BranchSmsPartTest, SmsInterfaceStub_0002, Function | MediumTest | Level1)
119 {
120 std::u16string desAddr = Str8ToStr16(SMS_ADDR_ONE);
121 DelayedSingleton<SmsService>::GetInstance()->RemoveSpacesInDesAddr(desAddr);
122 EXPECT_GE(desAddr.size(), 0);
123 desAddr = Str8ToStr16(SMS_ADDR_TWO);
124 DelayedSingleton<SmsService>::GetInstance()->RemoveSpacesInDesAddr(desAddr);
125 EXPECT_GE(desAddr.size(), 0);
126 desAddr = Str8ToStr16(SMS_ADDR_THREE);
127 DelayedSingleton<SmsService>::GetInstance()->RemoveSpacesInDesAddr(desAddr);
128 EXPECT_GE(desAddr.size(), 0);
129 desAddr = Str8ToStr16(SMS_ADDR_FOUR);
130 DelayedSingleton<SmsService>::GetInstance()->RemoveSpacesInDesAddr(desAddr);
131 EXPECT_GE(desAddr.size(), 0);
132 desAddr = Str8ToStr16(SMS_ADDR_FIVE);
133 DelayedSingleton<SmsService>::GetInstance()->RemoveSpacesInDesAddr(desAddr);
134 EXPECT_GE(desAddr.size(), 0);
135
136 MessageParcel setSmscParcel;
137 MessageParcel replyParcel;
138 MessageOption option(MessageOption::TF_SYNC);
139 setSmscParcel.WriteInt32(0);
140 setSmscParcel.WriteString16(Str8ToStr16(TEST_SOURCE_DATA));
141 DelayedSingleton<SmsService>::GetInstance()->OnSetSmscAddr(setSmscParcel, replyParcel, option);
142 MessageParcel getSmscParcel;
143 getSmscParcel.WriteInt32(0);
144 DelayedSingleton<SmsService>::GetInstance()->OnGetSmscAddr(getSmscParcel, replyParcel, option);
145 DelayedSingleton<SmsService>::GetInstance()->OnGetAllSimMessages(getSmscParcel, replyParcel, option);
146 DelayedSingleton<SmsService>::GetInstance()->OnSetDefaultSmsSlotId(getSmscParcel, replyParcel, option);
147 DelayedSingleton<SmsService>::GetInstance()->OnGetDefaultSmsSlotId(getSmscParcel, replyParcel, option);
148 int32_t result = replyParcel.ReadInt32();
149 EXPECT_GE(result, 0);
150
151 MessageParcel addSimMsgParcel;
152 addSimMsgParcel.WriteInt32(0);
153 addSimMsgParcel.WriteString16(Str8ToStr16(TEST_SOURCE_DATA));
154 addSimMsgParcel.WriteString16(Str8ToStr16(TEST_SOURCE_DATA));
155 addSimMsgParcel.WriteUint32(0);
156 DelayedSingleton<SmsService>::GetInstance()->OnAddSimMessage(addSimMsgParcel, replyParcel, option);
157 result = replyParcel.ReadInt32();
158 EXPECT_GE(result, 0);
159
160 MessageParcel delSimMsgParcel;
161 delSimMsgParcel.WriteInt32(0);
162 delSimMsgParcel.WriteUint32(0);
163 DelayedSingleton<SmsService>::GetInstance()->OnDelSimMessage(delSimMsgParcel, replyParcel, option);
164 result = replyParcel.ReadInt32();
165 EXPECT_GE(result, 0);
166 }
167
168 /**
169 * @tc.number Telephony_SmsMmsGtest_SmsInterfaceStub_0003
170 * @tc.name Test SmsInterfaceStub
171 * @tc.desc Function test
172 */
173 HWTEST_F(BranchSmsPartTest, SmsInterfaceStub_0003, Function | MediumTest | Level1)
174 {
175 MessageParcel simMsgParcel;
176 MessageParcel replyParcel;
177 MessageOption option(MessageOption::TF_SYNC);
178 simMsgParcel.WriteInt32(0);
179 simMsgParcel.WriteUint32(0);
180 simMsgParcel.WriteUint32(0);
181 simMsgParcel.WriteString16(Str8ToStr16(TEST_SOURCE_DATA));
182 simMsgParcel.WriteString16(Str8ToStr16(TEST_SOURCE_DATA));
183 DelayedSingleton<SmsService>::GetInstance()->OnUpdateSimMessage(simMsgParcel, replyParcel, option);
184 int32_t result = replyParcel.ReadInt32();
185 EXPECT_GE(result, 0);
186
187 MessageParcel SetImsSmsParcel;
188 SetImsSmsParcel.WriteInt32(0);
189 SetImsSmsParcel.WriteInt32(false);
190 DelayedSingleton<SmsService>::GetInstance()->OnSetImsSmsConfig(SetImsSmsParcel, replyParcel, option);
191 result = replyParcel.ReadInt32();
192 EXPECT_GE(result, 0);
193
194 MessageParcel splitMsgParcel;
195 splitMsgParcel.WriteString16(Str8ToStr16(TEST_SOURCE_DATA));
196 DelayedSingleton<SmsService>::GetInstance()->OnSplitMessage(splitMsgParcel, replyParcel, option);
197 DelayedSingleton<SmsService>::GetInstance()->OnGetBase64Encode(splitMsgParcel, replyParcel, option);
198 DelayedSingleton<SmsService>::GetInstance()->OnGetBase64Decode(splitMsgParcel, replyParcel, option);
199 result = replyParcel.ReadInt32();
200 EXPECT_GE(result, 0);
201
202 MessageParcel createMsgParcel;
203 createMsgParcel.WriteString(TEST_SOURCE_DATA);
204 createMsgParcel.WriteString(TEST_SOURCE_DATA);
205 DelayedSingleton<SmsService>::GetInstance()->OnCreateMessage(createMsgParcel, replyParcel, option);
206 result = replyParcel.ReadInt32();
207 EXPECT_GE(result, 0);
208
209 MessageParcel segmentParcel;
210 segmentParcel.WriteInt32(0);
211 segmentParcel.WriteString16(Str8ToStr16(TEST_SOURCE_DATA));
212 segmentParcel.WriteBool(false);
213 DelayedSingleton<SmsService>::GetInstance()->OnGetSmsSegmentsInfo(segmentParcel, replyParcel, option);
214 result = replyParcel.ReadInt32();
215 EXPECT_GE(result, 0);
216
217 MessageParcel formatParcel;
218 DelayedSingleton<SmsService>::GetInstance()->OnGetImsShortMessageFormat(formatParcel, replyParcel, option);
219 result = replyParcel.ReadInt32();
220 DelayedSingleton<SmsService>::GetInstance()->OnGetDefaultSmsSimId(formatParcel, replyParcel, option);
221 result = replyParcel.ReadInt32();
222 EXPECT_GE(result, 0);
223 }
224
225 /**
226 * @tc.number Telephony_SmsMmsGtest_SmsInterfaceManager_0001
227 * @tc.name Test SmsInterfaceManager
228 * @tc.desc Function test
229 */
230 HWTEST_F(BranchSmsPartTest, SmsInterfaceManager_0001, Function | MediumTest | Level1)
231 {
232 auto interfaceManager = std::make_shared<SmsInterfaceManager>(0);
233 if (interfaceManager == nullptr) {
234 return;
235 }
236 interfaceManager->HasSmsCapability();
237 std::string dataStr = TEST_SOURCE_DATA;
238 auto callStub = iface_cast<ISendShortMessageCallback>(new SendShortMessageCallbackStub());
239 auto deliveryStub = iface_cast<IDeliveryShortMessageCallback>(new DeliveryShortMessageCallbackStub());
240 std::string emptyStr = "";
241
242 interfaceManager->TextBasedSmsDelivery(dataStr, dataStr, dataStr, callStub, deliveryStub);
243 interfaceManager->TextBasedSmsDelivery(dataStr, emptyStr, dataStr, callStub, deliveryStub);
244 interfaceManager->TextBasedSmsDelivery(dataStr, dataStr, emptyStr, callStub, deliveryStub);
245 int32_t result = interfaceManager->TextBasedSmsDelivery(dataStr, emptyStr, emptyStr, callStub, deliveryStub);
246 EXPECT_GE(result, 0);
247
248 const uint8_t *data = reinterpret_cast<const uint8_t *>(dataStr.c_str());
249 interfaceManager->DataBasedSmsDelivery(dataStr, dataStr, 0, data, dataStr.size(), callStub, deliveryStub);
250 interfaceManager->DataBasedSmsDelivery(dataStr, emptyStr, 0, data, dataStr.size(), callStub, deliveryStub);
251 interfaceManager->DataBasedSmsDelivery(dataStr, dataStr, 0, nullptr, 0, callStub, deliveryStub);
252 interfaceManager->smsSendManager_ = nullptr;
253 interfaceManager->TextBasedSmsDelivery(dataStr, dataStr, dataStr, callStub, deliveryStub);
254 result = interfaceManager->DataBasedSmsDelivery(dataStr, dataStr, 0, data, dataStr.size(), callStub, deliveryStub);
255 EXPECT_GE(result, 0);
256
257 interfaceManager->AddSimMessage(dataStr, dataStr, ISmsServiceInterface::SIM_MESSAGE_STATUS_UNREAD);
258 interfaceManager->UpdateSimMessage(0, ISmsServiceInterface::SIM_MESSAGE_STATUS_UNREAD, dataStr, dataStr);
259 std::vector<ShortMessage> message;
260 interfaceManager->GetAllSimMessages(message);
261 result = interfaceManager->SetSmscAddr(dataStr);
262 EXPECT_GE(result, 0);
263
264 std::u16string smsc;
265 interfaceManager->GetSmscAddr(smsc);
266 interfaceManager->SetCBConfig(false, 0, 1, 0);
267 result = interfaceManager->SetImsSmsConfig(0, false);
268 EXPECT_GE(result, 0);
269
270 interfaceManager->SetDefaultSmsSlotId(0);
271 interfaceManager->GetDefaultSmsSlotId();
272 int32_t simId;
273 interfaceManager->GetDefaultSmsSimId(simId);
274 std::vector<std::u16string> splitMessage;
275 result = interfaceManager->SplitMessage(dataStr, splitMessage);
276 EXPECT_GE(result, 0);
277 }
278
279 /**
280 * @tc.number Telephony_SmsMmsGtest_SmsInterfaceManager_0002
281 * @tc.name Test SmsInterfaceManager
282 * @tc.desc Function test
283 */
284 HWTEST_F(BranchSmsPartTest, SmsInterfaceManager_0002, Function | MediumTest | Level1)
285 {
286 auto interfaceManager = std::make_shared<SmsInterfaceManager>(0);
287 if (interfaceManager == nullptr) {
288 return;
289 }
290 LengthInfo outInfo;
291 std::string dataStr = TEST_SOURCE_DATA;
292 interfaceManager->GetSmsSegmentsInfo(dataStr, false, outInfo);
293 bool isSupported = false;
294 interfaceManager->IsImsSmsSupported(0, isSupported);
295 std::u16string format;
296 interfaceManager->GetImsShortMessageFormat(format);
297 int32_t result = interfaceManager->HasSmsCapability();
298 EXPECT_GE(result, 0);
299
300 std::u16string mmsc = u"";
301 std::u16string data = u"";
302 std::u16string ua = u"";
303 std::u16string uaprof = u"";
304 interfaceManager->SendMms(mmsc, data, ua, uaprof);
305 result = interfaceManager->DownloadMms(mmsc, data, ua, uaprof);
306 EXPECT_GE(result, 0);
307
308 interfaceManager->smsMiscManager_ = nullptr;
309 interfaceManager->AddSimMessage(dataStr, dataStr, ISmsServiceInterface::SIM_MESSAGE_STATUS_UNREAD);
310 interfaceManager->UpdateSimMessage(0, ISmsServiceInterface::SIM_MESSAGE_STATUS_UNREAD, dataStr, dataStr);
311 std::vector<ShortMessage> message;
312 interfaceManager->GetAllSimMessages(message);
313 interfaceManager->SetSmscAddr(dataStr);
314 std::u16string smsc;
315 result = interfaceManager->GetSmscAddr(mmsc);
316 EXPECT_GE(result, 0);
317
318 interfaceManager->SetCBConfig(false, 0, 1, 0);
319 interfaceManager->SetImsSmsConfig(0, false);
320 interfaceManager->SetDefaultSmsSlotId(0);
321 interfaceManager->GetDefaultSmsSlotId();
322 int32_t simId;
323 result = interfaceManager->GetDefaultSmsSimId(simId);
324 EXPECT_GE(result, 0);
325
326 std::vector<std::u16string> splitMessage;
327 interfaceManager->SplitMessage(dataStr, splitMessage);
328 interfaceManager->GetSmsSegmentsInfo(dataStr, false, outInfo);
329 result = interfaceManager->IsImsSmsSupported(0, isSupported);
330 EXPECT_GE(result, 0);
331
332 interfaceManager->GetImsShortMessageFormat(format);
333 interfaceManager->mmsSendManager_ = nullptr;
334 interfaceManager->SendMms(mmsc, data, ua, uaprof);
335 interfaceManager->mmsReceiverManager_ = nullptr;
336 result = interfaceManager->DownloadMms(mmsc, data, ua, uaprof);
337 EXPECT_GE(result, 0);
338 }
339
340 /**
341 * @tc.number Telephony_SmsMmsGtest_SmsInterfaceManager_0003
342 * @tc.name Test SmsInterfaceManager
343 * @tc.desc Function test
344 */
345 HWTEST_F(BranchSmsPartTest, SmsInterfaceManager_0003, Function | MediumTest | Level1)
346 {
347 int32_t slotId = 0;
348 std::shared_ptr<SmsInterfaceManager> interfaceManager = std::make_shared<SmsInterfaceManager>(slotId);
349 interfaceManager->mmsSendManager_ = nullptr;
350 std::u16string mmsc(StringUtils::ToUtf16(VNET_MMSC));
351 std::u16string data(StringUtils::ToUtf16(SEND_MMS_FILE_URL));
352 std::u16string ua = u"112233";
353 std::u16string uaprof = u"112233";
354 int32_t sendMmsRet = interfaceManager->SendMms(mmsc, data, ua, uaprof);
355 interfaceManager->mmsReceiverManager_ = nullptr;
356 int32_t downloadMmsRet = interfaceManager->DownloadMms(mmsc, data, ua, uaprof);
357 EXPECT_GE(sendMmsRet, 0);
358 EXPECT_GE(downloadMmsRet, 0);
359 }
360
361 /**
362 * @tc.number Telephony_SmsMmsGtest_SmsStateObserver_0001
363 * @tc.name Test SmsStateObserver_0001
364 * @tc.desc Function test
365 */
366 HWTEST_F(BranchSmsPartTest, SmsStateObserver_0001, Function | MediumTest | Level1)
367 {
368 std::shared_ptr<SmsStateObserver> smsStateObserver = std::make_shared<SmsStateObserver>();
369 smsStateObserver->smsSubscriber_ = nullptr;
370 smsStateObserver->StopEventSubscriber();
371 std::shared_ptr<CommonEventSubscribeInfo> subscribeInfo = std::make_shared<CommonEventSubscribeInfo>();
372 std::shared_ptr<SmsStateEventSubscriber> smsStateEventSubscriber =
373 std::make_shared<SmsStateEventSubscriber>(*subscribeInfo);
374 EventFwk::CommonEventData eventData = EventFwk::CommonEventData();
375 AAFwk::Want want = AAFwk::Want();
376 want.SetAction(EventFwk::CommonEventSupport::COMMON_EVENT_SMS_EMERGENCY_CB_RECEIVE_COMPLETED);
377 eventData.SetWant(want);
378 smsStateEventSubscriber->OnReceiveEvent(eventData);
379 want.SetAction(EventFwk::CommonEventSupport::COMMON_EVENT_SMS_RECEIVE_COMPLETED);
380 eventData.SetWant(want);
381 smsStateEventSubscriber->OnReceiveEvent(eventData);
382 want.SetAction(EventFwk::CommonEventSupport::COMMON_EVENT_SMS_WAPPUSH_RECEIVE_COMPLETED);
383 eventData.SetWant(want);
384 smsStateEventSubscriber->OnReceiveEvent(eventData);
385 want.SetAction(EventFwk::CommonEventSupport::COMMON_EVENT_BATTERY_LOW);
386 eventData.SetWant(want);
387 smsStateEventSubscriber->OnReceiveEvent(eventData);
388 EXPECT_TRUE(smsStateObserver != nullptr);
389 EXPECT_TRUE(subscribeInfo != nullptr);
390 EXPECT_TRUE(smsStateEventSubscriber != nullptr);
391 }
392 } // namespace Telephony
393 } // namespace OHOS
394