1 /*
2 * Copyright (C) 2022 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 <gtest/gtest.h>
18 #include "accessibility_extension.h"
19 #include "accessibility_extension_context.h"
20 #include "accessible_ability_client_stub_impl.h"
21 #include "accessible_ability_channel_proxy.h"
22 #include "mock_accessible_ability_channel_stub.h"
23
24 using namespace testing;
25 using namespace testing::ext;
26 using namespace std;
27
28 namespace OHOS {
29 namespace Accessibility {
30 class UnitTestAccessibleAbilityListener : public AccessibilityExtension {
31 public:
UnitTestAccessibleAbilityListener()32 UnitTestAccessibleAbilityListener()
33 {
34 GTEST_LOG_(INFO) << "mock aa listener's constructor";
35 std::shared_ptr<AppExecFwk::AbilityLocalRecord> record = nullptr;
36 std::shared_ptr<AppExecFwk::OHOSApplication> application = nullptr;
37 std::shared_ptr<AppExecFwk::AbilityHandler> handler = nullptr;
38 sptr<IRemoteObject> token = nullptr;
39 Init(record, application, handler, token);
40 }
~UnitTestAccessibleAbilityListener()41 virtual ~UnitTestAccessibleAbilityListener() {}
42
Init(const std::shared_ptr<AppExecFwk::AbilityLocalRecord> & record,const std::shared_ptr<AppExecFwk::OHOSApplication> & application,std::shared_ptr<AppExecFwk::AbilityHandler> & handler,const sptr<IRemoteObject> & token)43 void Init(const std::shared_ptr<AppExecFwk::AbilityLocalRecord> &record,
44 const std::shared_ptr<AppExecFwk::OHOSApplication> &application,
45 std::shared_ptr<AppExecFwk::AbilityHandler> &handler,
46 const sptr<IRemoteObject> &token) override
47 {
48 GTEST_LOG_(INFO) << "UnitTestAccessibleAbilityListener Init";
49 AccessibilityExtension::Init(record, application, handler, token);
50 }
51
OnAbilityConnected()52 void OnAbilityConnected() override
53 {
54 GTEST_LOG_(INFO) << "UnitTestAccessibleAbilityListener OnAbilityConnected";
55 }
56
OnAccessibilityEvent(const AccessibilityEventInfo & eventInfo)57 void OnAccessibilityEvent(const AccessibilityEventInfo& eventInfo) override
58 {
59 GTEST_LOG_(INFO) << "UnitTestAccessibleAbilityListener OnAccessibilityEvent";
60 }
61
OnKeyPressEvent(const MMI::KeyEvent & keyEvent)62 bool OnKeyPressEvent(const MMI::KeyEvent& keyEvent) override
63 {
64 GTEST_LOG_(INFO) << "UnitTestAccessibleAbilityListener OnKeyPressEvent";
65 return true;
66 }
67 };
68
69 class AccessibleAbilityClientStubImplUnitTest : public ::testing::Test {
70 public:
AccessibleAbilityClientStubImplUnitTest()71 AccessibleAbilityClientStubImplUnitTest() {}
~AccessibleAbilityClientStubImplUnitTest()72 ~AccessibleAbilityClientStubImplUnitTest() {}
73
74 static void SetUpTestCase();
75 static void TearDownTestCase();
76 void SetUp() override;
77 void TearDown() override;
78
79 void InitToSetChannelId();
80
81 sptr<AccessibleAbilityClientStubImpl> stub_ = nullptr;
82 };
83
SetUpTestCase()84 void AccessibleAbilityClientStubImplUnitTest::SetUpTestCase()
85 {
86 GTEST_LOG_(INFO) << "###################### AccessibleAbilityClientStubImplUnitTest Start ######################";
87 }
88
TearDownTestCase()89 void AccessibleAbilityClientStubImplUnitTest::TearDownTestCase()
90 {
91 GTEST_LOG_(INFO) << "###################### AccessibleAbilityClientStubImplUnitTest End ######################";
92 }
93
SetUp()94 void AccessibleAbilityClientStubImplUnitTest::SetUp()
95 {
96 GTEST_LOG_(INFO) << "SetUp";
97 std::shared_ptr<AbilityRuntime::ContextImpl> contextImpl = std::make_shared<AbilityRuntime::ContextImpl>();
98 contextImpl->InitAppContext();
99 stub_ = new AccessibleAbilityClientStubImpl();
100 }
101
TearDown()102 void AccessibleAbilityClientStubImplUnitTest::TearDown()
103 {
104 GTEST_LOG_(INFO) << "TearDown";
105 stub_ = nullptr;
106 }
107
InitToSetChannelId()108 void AccessibleAbilityClientStubImplUnitTest::InitToSetChannelId()
109 {
110 GTEST_LOG_(INFO) << "AccessibleAbilityClientStubImplUnitTest InitToSetChannelId";
111 shared_ptr<AccessibilityExtension> listener = make_shared<UnitTestAccessibleAbilityListener>();
112 sptr<AccessibleAbilityChannelStubMock> stub = new AccessibleAbilityChannelStubMock();
113 sptr<IAccessibleAbilityChannel> channel = new AccessibleAbilityChannelProxy(stub->AsObject());
114 int channelId = 0;
115
116 stub_->RegisterListenerImpl(listener);
117 stub_->Init(channel, channelId);
118 sleep(1); // sleep for task completed.
119
120 stub = nullptr;
121 channel = nullptr;
122 }
123
124 /**
125 * @tc.number: AccessibleAbilityClientStubImpl_Unittest_RegisterListenerImpl_001
126 * @tc.name: RegisterListenerImpl
127 * @tc.desc: Test function RegisterListenerImpl
128 * Register a listener which is already exist.
129 */
130 HWTEST_F(AccessibleAbilityClientStubImplUnitTest,
131 AccessibleAbilityClientStubImpl_Unittest_RegisterListenerImpl_001, TestSize.Level1)
132 {
133 GTEST_LOG_(INFO) << "AccessibleAbilityClientStubImpl_Unittest_RegisterListenerImpl_001 start";
134
135 shared_ptr<AccessibilityExtension> listener = make_shared<UnitTestAccessibleAbilityListener>();
136 stub_->RegisterListenerImpl(listener);
137 stub_->RegisterListenerImpl(listener);
138
139 GTEST_LOG_(INFO) << "AccessibleAbilityClientStubImpl_Unittest_RegisterListenerImpl_001 end";
140 }
141
142 /**
143 * @tc.number: AccessibleAbilityClientStubImpl_Unittest_Init_001
144 * @tc.name: Init
145 * @tc.desc: Test function Init
146 * Init without listener.
147 */
148 HWTEST_F(AccessibleAbilityClientStubImplUnitTest, AccessibleAbilityClientStubImpl_Unittest_Init_001, TestSize.Level1)
149 {
150 GTEST_LOG_(INFO) << "AccessibleAbilityClientStubImpl_Unittest_Init_001 start";
151
152 sptr<AccessibleAbilityChannelStubMock> stub = new AccessibleAbilityChannelStubMock();
153 sptr<IAccessibleAbilityChannel> channel = new AccessibleAbilityChannelProxy(stub->AsObject());
154 int channelId = 0;
155
156 stub_->Init(channel, channelId);
157 sleep(1); // sleep for task completed.
158
159 stub = nullptr;
160 channel = nullptr;
161
162 GTEST_LOG_(INFO) << "AccessibleAbilityClientStubImpl_Unittest_Init_001 end";
163 }
164
165 /**
166 * @tc.number: AccessibleAbilityClientStubImpl_Unittest_Init_002
167 * @tc.name: Init
168 * @tc.desc: Test function Init
169 * Init with listener.
170 */
171 HWTEST_F(AccessibleAbilityClientStubImplUnitTest, AccessibleAbilityClientStubImpl_Unittest_Init_002, TestSize.Level1)
172 {
173 GTEST_LOG_(INFO) << "AccessibleAbilityClientStubImpl_Unittest_Init_002 start";
174
175 shared_ptr<AccessibilityExtension> listener = make_shared<UnitTestAccessibleAbilityListener>();
176 sptr<AccessibleAbilityChannelStubMock> stub = new AccessibleAbilityChannelStubMock();
177 sptr<IAccessibleAbilityChannel> channel = new AccessibleAbilityChannelProxy(stub->AsObject());
178 int channelId = 0;
179
180 stub_->RegisterListenerImpl(listener);
181 stub_->Init(channel, channelId);
182 sleep(1); // sleep for task completed.
183
184 stub = nullptr;
185 channel = nullptr;
186
187 GTEST_LOG_(INFO) << "AccessibleAbilityClientStubImpl_Unittest_Init_002 end";
188 }
189
190 /**
191 * @tc.number: AccessibleAbilityClientStubImpl_Unittest_Disconnect_001
192 * @tc.name: Disconnect
193 * @tc.desc: Test function Disconnect
194 */
195 HWTEST_F(AccessibleAbilityClientStubImplUnitTest,
196 AccessibleAbilityClientStubImpl_Unittest_Disconnect_001, TestSize.Level1)
197 {
198 GTEST_LOG_(INFO) << "AccessibleAbilityClientStubImpl_Unittest_Disconnect_001 start";
199
200 int channelId = 0;
201 InitToSetChannelId();
202 stub_->Disconnect(channelId);
203 sleep(1); // sleep for task Disconnect completed.
204
205 GTEST_LOG_(INFO) << "AccessibleAbilityClientStubImpl_Unittest_Disconnect_001 end";
206 }
207
208 /**
209 * @tc.number: AccessibleAbilityClientStubImpl_Unittest_OnAccessibilityEvent_001
210 * @tc.name: OnAccessibilityEvent
211 * @tc.desc: Test function OnAccessibilityEvent
212 */
213 HWTEST_F(AccessibleAbilityClientStubImplUnitTest,
214 AccessibleAbilityClientStubImpl_Unittest_OnAccessibilityEvent_001, TestSize.Level1)
215 {
216 GTEST_LOG_(INFO) << "AccessibleAbilityClientStubImpl_Unittest_OnAccessibilityEvent_001 start";
217
218 AccessibilityEventInfo eventInfo {};
219
220 InitToSetChannelId();
221 stub_->OnAccessibilityEvent(eventInfo);
222 sleep(1); // sleep for task completed.
223
224 GTEST_LOG_(INFO) << "AccessibleAbilityClientStubImpl_Unittest_OnAccessibilityEvent_001 end";
225 }
226
227 /**
228 * @tc.number: AccessibleAbilityClientStubImpl_Unittest_OnKeyPressEvent_001
229 * @tc.name: OnKeyPressEvent
230 * @tc.desc: Test function OnKeyPressEvent
231 */
232 HWTEST_F(AccessibleAbilityClientStubImplUnitTest,
233 AccessibleAbilityClientStubImpl_Unittest_OnKeyPressEvent_001, TestSize.Level1)
234 {
235 GTEST_LOG_(INFO) << "AccessibleAbilityClientStubImpl_Unittest_OnKeyPressEvent_001 start";
236
237 std::shared_ptr<MMI::KeyEvent> keyEvent = MMI::KeyEvent::Create();
238 int sequence = 0;
239
240 InitToSetChannelId();
241 stub_->OnKeyPressEvent(*keyEvent, sequence);
242 sleep(1); // sleep for task completed.
243
244 GTEST_LOG_(INFO) << "AccessibleAbilityClientStubImpl_Unittest_OnKeyPressEvent_001 end";
245 }
246
247 /**
248 * @tc.number: AccessibleAbilityClientStubImpl_Unittest_OnDisplayResized_001
249 * @tc.name: OnDisplayResized
250 * @tc.desc: Test function OnDisplayResized
251 */
252 HWTEST_F(AccessibleAbilityClientStubImplUnitTest,
253 AccessibleAbilityClientStubImpl_Unittest_OnDisplayResized_001, TestSize.Level1)
254 {
255 GTEST_LOG_(INFO) << "AccessibleAbilityClientStubImpl_Unittest_OnDisplayResized_001 start";
256
257 int displayId = 0;
258 Rect rect {};
259 float scale = 1;
260 float centerX = 0;
261 float centerY = 0;
262
263 InitToSetChannelId();
264 stub_->OnDisplayResized(displayId, rect, scale, centerX, centerY);
265 sleep(1); // sleep for task completed.
266
267 GTEST_LOG_(INFO) << "AccessibleAbilityClientStubImpl_Unittest_OnDisplayResized_001 end";
268 }
269
270 /**
271 * @tc.number: AccessibleAbilityClientStubImpl_Unittest_OnGestureSimulateResult_001
272 * @tc.name: OnGestureSimulateResult
273 * @tc.desc: Test function OnGestureSimulateResult
274 */
275 HWTEST_F(AccessibleAbilityClientStubImplUnitTest,
276 AccessibleAbilityClientStubImpl_Unittest_OnGestureSimulateResult_001, TestSize.Level1)
277 {
278 GTEST_LOG_(INFO) << "AccessibleAbilityClientStubImpl_Unittest_OnGestureSimulateResult_001 start";
279
280 int sequence = 0;
281 bool completedSuccessfully = true;
282
283 InitToSetChannelId();
284 stub_->OnGestureSimulateResult(sequence, completedSuccessfully);
285 sleep(1); // sleep for task completed.
286
287 GTEST_LOG_(INFO) << "AccessibleAbilityClientStubImpl_Unittest_OnGestureSimulateResult_001 end";
288 }
289 } // namespace Accessibility
290 } // namespace OHOS