1 /*
2  * Copyright (C) 2021 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 <memory>
17 #include <vector>
18 
19 #include "cdma_sms_test.h"
20 #include "common_event_support.h"
21 #include "gsm_sms_sender_test.h"
22 #include "if_system_ability_manager.h"
23 #include "ipc_skeleton.h"
24 #include "iservice_registry.h"
25 #include "mms_msg_test.h"
26 #include "short_message_test.h"
27 #include "sms_broadcast_subscriber.h"
28 #include "sms_cb_message_test.h"
29 #include "sms_gsm_message_test.h"
30 
31 using namespace OHOS;
32 using namespace OHOS::Telephony;
33 using namespace OHOS::EventFwk;
34 
35 using TestStruct = struct FunStruct {
36     std::string funName;
37     std::function<void(void)> fun = nullptr;
FunStruct(const std::string &name, const std::function<void(void)> &function)38     FunStruct(const std::string &name, const std::function<void(void)> &function) : funName(name), fun(function) {}
39 };
40 
41 using TestParam = struct Param {
42     GsmSmsSenderTest gsmSmsSenderTest;
43     ShortMessageTest shortMessageTest;
44     SmsCbMessageTest smsCbMessageTest;
45     MmsMsgTest mmsMsgTest;
46     CdmaSmsTest cdmaSmsTest;
47     SmsGsmMessageTest smsGsmMessageTest;
48 };
49 
50 namespace OHOS {
51 namespace Telephony {
52 class SmsMmsTest {
53 public:
54     SmsMmsTest() = default;
55     ~SmsMmsTest() = default;
56 
57     void TestRecev()
58     {
59         EventFwk::MatchingSkills matchingSkills;
60         matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_SMS_RECEIVE_COMPLETED);
61         matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_SMS_EMERGENCY_CB_RECEIVE_COMPLETED);
62         matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_SMS_CB_RECEIVE_COMPLETED);
63         matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_SMS_WAPPUSH_RECEIVE_COMPLETED);
64         // make subcriber info
65         EventFwk::CommonEventSubscribeInfo subscriberInfo(matchingSkills);
66         // make a subcriber object
67         std::shared_ptr<SmsBroadcastSubscriber> subscriberTest =
68             std::make_shared<SmsBroadcastSubscriber>(subscriberInfo);
69         if (subscriberTest == nullptr) {
70             return;
71         }
72         // subscribe a common event
73         bool subscribeResult = EventFwk::CommonEventManager::SubscribeCommonEvent(subscriberTest);
74         std::cout << "subscribeResult is " << (subscribeResult ? "true" : "false") << std::endl;
75     }
76 
77     void InitGsmFun(const std::unique_ptr<std::vector<TestStruct>> &funArray, const TestParam &param,
78         const sptr<ISmsServiceInterface> &smsService)
79     {
80         funArray->emplace_back(
81             "TestSendShortText", std::bind(&GsmSmsSenderTest::TestSendShortText, param.gsmSmsSenderTest, smsService));
82         funArray->emplace_back("TestGsmSendShortData",
83             std::bind(&GsmSmsSenderTest::TestGsmSendShortData, param.gsmSmsSenderTest, smsService));
84         funArray->emplace_back(
85             "TestSendLongText", std::bind(&GsmSmsSenderTest::TestSendLongText, param.gsmSmsSenderTest, smsService));
86         funArray->emplace_back("TestGsmSendLongData",
87             std::bind(&GsmSmsSenderTest::TestGsmSendLongData, param.gsmSmsSenderTest, smsService));
88         funArray->emplace_back(
89             "TestSendMms", std::bind(&GsmSmsSenderTest::TestSendMms, param.gsmSmsSenderTest, smsService));
90         funArray->emplace_back(
91             "TestSetSmscAddr", std::bind(&GsmSmsSenderTest::TestSetSmscAddr, param.gsmSmsSenderTest, smsService));
92         funArray->emplace_back(
93             "TestGetSmscAddr", std::bind(&GsmSmsSenderTest::TestGetSmscAddr, param.gsmSmsSenderTest, smsService));
94         funArray->emplace_back("TestCbMessage", std::bind(&SmsCbMessageTest::ProcessTest, param.smsCbMessageTest));
95         funArray->emplace_back("TestEnableCBRangeConfig",
96             std::bind(&GsmSmsSenderTest::TestEnableCBRangeConfig, param.gsmSmsSenderTest, smsService));
97         funArray->emplace_back("TestDisableCBRangeConfig",
98             std::bind(&GsmSmsSenderTest::TestDisableCBRangeConfig, param.gsmSmsSenderTest, smsService));
99         funArray->emplace_back(
100             "TestEnableCBConfig", std::bind(&GsmSmsSenderTest::TestEnableCBConfig, param.gsmSmsSenderTest, smsService));
101         funArray->emplace_back("TestDisableCBConfig",
102             std::bind(&GsmSmsSenderTest::TestDisableCBConfig, param.gsmSmsSenderTest, smsService));
103         funArray->emplace_back("TestSetDefaultSmsSlotId",
104             std::bind(&GsmSmsSenderTest::TestSetDefaultSmsSlotId, param.gsmSmsSenderTest, smsService));
105         funArray->emplace_back("TestGetDefaultSmsSlotId",
106             std::bind(&GsmSmsSenderTest::TestGetDefaultSmsSlotId, param.gsmSmsSenderTest, smsService));
107         funArray->emplace_back(
108             "TestSplitMessage", std::bind(&GsmSmsSenderTest::TestSplitMessage, param.gsmSmsSenderTest, smsService));
109         funArray->emplace_back("TestGetSmsSegmentsInfo",
110             std::bind(&GsmSmsSenderTest::TestGetSmsSegmentsInfo, param.gsmSmsSenderTest, smsService));
111         funArray->emplace_back("TestIsImsSmsSupported",
112             std::bind(&GsmSmsSenderTest::TestIsImsSmsSupported, param.gsmSmsSenderTest, smsService));
113         funArray->emplace_back("TestSetImsSmsConfig",
114             std::bind(&GsmSmsSenderTest::TestSetImsSmsConfig, param.gsmSmsSenderTest, smsService));
115         funArray->emplace_back("TestGetImsShortMessageFormat",
116             std::bind(&GsmSmsSenderTest::TestGetImsShortMessageFormat, param.gsmSmsSenderTest, smsService));
117         funArray->emplace_back(
118             "TestAddBlockPhone", std::bind(&GsmSmsSenderTest::TestAddBlockPhone, param.gsmSmsSenderTest));
119         funArray->emplace_back(
120             "TestRemoveBlockPhone", std::bind(&GsmSmsSenderTest::TestRemoveBlockPhone, param.gsmSmsSenderTest));
121         funArray->emplace_back("TestHasSmsCapability",
122             std::bind(&GsmSmsSenderTest::TestHasSmsCapability, param.gsmSmsSenderTest, smsService));
123     }
124 
125     void InitSimMessageFun(const std::unique_ptr<std::vector<TestStruct>> &funArray, const TestParam &param,
126         const sptr<ISmsServiceInterface> &smsService)
127     {
128         funArray->emplace_back(
129             "TestAddSimMessage", std::bind(&GsmSmsSenderTest::TestAddSimMessage, param.gsmSmsSenderTest, smsService));
130         funArray->emplace_back(
131             "TestDelSimMessage", std::bind(&GsmSmsSenderTest::TestDelSimMessage, param.gsmSmsSenderTest, smsService));
132         funArray->emplace_back("TestUpdateSimMessage",
133             std::bind(&GsmSmsSenderTest::TestUpdateSimMessage, param.gsmSmsSenderTest, smsService));
134         funArray->emplace_back("TestGetAllSimMessages",
135             std::bind(&GsmSmsSenderTest::TestGetAllSimMessages, param.gsmSmsSenderTest, smsService));
136     }
137 
138     void InitShortMessageFun(const std::unique_ptr<std::vector<TestStruct>> &funArray, const TestParam &param,
139         const sptr<ISmsServiceInterface> &smsService)
140     {
141         funArray->emplace_back(
142             "TestCreateMessage", std::bind(&ShortMessageTest::TestCreateMessage, param.shortMessageTest));
143         funArray->emplace_back("TestGetVisibleMessageBody",
144             std::bind(&ShortMessageTest::TestGetVisibleMessageBody, param.shortMessageTest));
145         funArray->emplace_back(
146             "TestShowShortMessage", std::bind(&ShortMessageTest::TestShowShortMessage, param.shortMessageTest));
147         funArray->emplace_back(
148             "TestCreate3Gpp2Message", std::bind(&ShortMessageTest::Test3Gpp2CreateMessage, param.shortMessageTest));
149     }
150 
151     void InitMmsFun(const std::unique_ptr<std::vector<TestStruct>> &funArray, const TestParam &param,
152         const sptr<ISmsServiceInterface> &smsService)
153     {
154         funArray->emplace_back("TestMmsMsgFunction", std::bind(&MmsMsgTest::ProcessTest, param.mmsMsgTest));
155     }
156 
157     void InitCdmaFun(const std::unique_ptr<std::vector<TestStruct>> &funArray, const TestParam &param,
158         const sptr<ISmsServiceInterface> &smsService)
159     {
160         funArray->emplace_back("TestCdmaSmsFunction", std::bind(&CdmaSmsTest::ProcessTest, param.cdmaSmsTest));
161     }
162 
163     void InitGsmMessageFun(const std::unique_ptr<std::vector<TestStruct>> &funArray, const TestParam &param,
164         const sptr<ISmsServiceInterface> &smsService)
165     {
166         funArray->emplace_back("TestSmsMessage", std::bind(&SmsGsmMessageTest::ProcessTest, param.smsGsmMessageTest));
167     }
168 
169     void InitFunArray(const std::unique_ptr<std::vector<TestStruct>> &funArray, const TestParam &param,
170         const sptr<ISmsServiceInterface> &smsService)
171     {
172         InitGsmFun(funArray, param, smsService);
173         InitSimMessageFun(funArray, param, smsService);
174         InitShortMessageFun(funArray, param, smsService);
175         InitMmsFun(funArray, param, smsService);
176         InitCdmaFun(funArray, param, smsService);
177         InitGsmMessageFun(funArray, param, smsService);
178     }
179 
180     std::unique_ptr<std::vector<TestStruct>> GetFunArray(const sptr<ISmsServiceInterface> &smsService)
181     {
182         static TestParam param;
183         param.shortMessageTest.TestCreateMessage();
184         std::unique_ptr<std::vector<TestStruct>> funArray = std::make_unique<std::vector<TestStruct>>();
185         if (smsService == nullptr || funArray == nullptr) {
186             return funArray;
187         }
188         InitFunArray(funArray, param, smsService);
189         return funArray;
190     }
191 };
192 } // namespace Telephony
193 } // namespace OHOS
194 
195 int main()
196 {
197     OHOS::Telephony::SmsMmsTest smsMmsTest;
198     smsMmsTest.TestRecev();
199     sptr<ISystemAbilityManager> systemAbilityMgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
200     sptr<IRemoteObject> remote = nullptr;
201     sptr<ISmsServiceInterface> smsService = nullptr;
202     if ((systemAbilityMgr == nullptr) ||
203         ((remote = systemAbilityMgr->CheckSystemAbility(TELEPHONY_SMS_MMS_SYS_ABILITY_ID)) == nullptr) ||
204         ((smsService = iface_cast<ISmsServiceInterface>(remote)) == nullptr)) {
205         std::cout << "connect to sms service failed." << std::endl;
206         return 0;
207     }
208     std::unique_ptr<std::vector<TestStruct>> testFunArray = smsMmsTest.GetFunArray(smsService);
209     int8_t caseCount = 0;
210     if (testFunArray == nullptr || ((caseCount = testFunArray->size()) <= 0)) {
211         std::cout << "Failed to get testFunArray data!\n";
212         return 0;
213     }
214     std::string hint = "[-1]:Exit\n";
215     for (int index = 0; index < caseCount; ++index) {
216         hint += "[" + std::to_string(index) + "]:" + (*testFunArray)[index].funName + "\n";
217     }
218     while (smsService != nullptr) {
219         std::cout << hint;
220         std::cout << "Please input test case number!" << std::endl;
221         std::string input;
222         int caseNumber = 0;
223         std::cin >> input;
224         caseNumber = std::atoi(input.c_str());
225         std::cin.clear();
226         std::cin.ignore();
227         std::cin.sync();
228         if (caseNumber < -1 || caseNumber >= caseCount) {
229             std::cout << "test case is not exist!" << std::endl;
230             continue;
231         }
232         if (caseNumber == -1) {
233             break;
234         }
235         std::cout << "Enter the " << (*testFunArray)[caseNumber].funName << " case!" << std::endl;
236         if ((*testFunArray)[caseNumber].fun != nullptr) {
237             (*testFunArray)[caseNumber].fun();
238         }
239     }
240     return 0;
241 }