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
31using namespace OHOS;
32using namespace OHOS::Telephony;
33using namespace OHOS::EventFwk;
34
35using TestStruct = struct FunStruct {
36    std::string funName;
37    std::function<void(void)> fun = nullptr;
38    FunStruct(const std::string &name, const std::function<void(void)> &function) : funName(name), fun(function) {}
39};
40
41using TestParam = struct Param {
42    GsmSmsSenderTest gsmSmsSenderTest;
43    ShortMessageTest shortMessageTest;
44    SmsCbMessageTest smsCbMessageTest;
45    MmsMsgTest mmsMsgTest;
46    CdmaSmsTest cdmaSmsTest;
47    SmsGsmMessageTest smsGsmMessageTest;
48};
49
50namespace OHOS {
51namespace Telephony {
52class SmsMmsTest {
53public:
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
195int 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}