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