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 <gtest/gtest.h>
17 #include "accessible_ability_channel_proxy.h"
18 #include "mock_accessible_ability_channel_stub.h"
19 #include "accessible_ability_client_proxy.h"
20 #include "mock_accessible_ability_client_stub.h"
21
22 using namespace testing;
23 using namespace testing::ext;
24 using namespace std;
25
26 namespace OHOS {
27 namespace Accessibility {
28 class AccessibleAbilityClientProxyUnitTest : public ::testing::Test {
29 public:
AccessibleAbilityClientProxyUnitTest()30 AccessibleAbilityClientProxyUnitTest() {}
~AccessibleAbilityClientProxyUnitTest()31 ~AccessibleAbilityClientProxyUnitTest() {}
32
33 static void SetUpTestCase();
34 static void TearDownTestCase();
35 void SetUp() override;
36 void TearDown() override;
37
38 std::shared_ptr<AccessibleAbilityClientProxy> proxy_ = nullptr;
39 sptr<AccessibleAbilityClientStubMock> mock_ = nullptr;
40 };
41
SetUpTestCase()42 void AccessibleAbilityClientProxyUnitTest::SetUpTestCase()
43 {
44 GTEST_LOG_(INFO) << "###################### AccessibleAbilityClientProxyUnitTest Start ######################";
45 }
46
TearDownTestCase()47 void AccessibleAbilityClientProxyUnitTest::TearDownTestCase()
48 {
49 GTEST_LOG_(INFO) << "###################### AccessibleAbilityClientProxyUnitTest End ######################";
50 }
51
SetUp()52 void AccessibleAbilityClientProxyUnitTest::SetUp()
53 {
54 GTEST_LOG_(INFO) << "SetUp";
55 mock_ = new AccessibleAbilityClientStubMock();
56 proxy_ = std::make_shared<AccessibleAbilityClientProxy>(mock_);
57 }
58
TearDown()59 void AccessibleAbilityClientProxyUnitTest::TearDown()
60 {
61 GTEST_LOG_(INFO) << "TearDown";
62 mock_ = nullptr;
63 proxy_ = nullptr;
64 }
65
66 /**
67 * @tc.number: AccessibleAbilityClientProxyUnitTest_Unittest_Init_001
68 * @tc.name: Init
69 * @tc.desc: Test function Init
70 */
71 HWTEST_F(AccessibleAbilityClientProxyUnitTest, AccessibleAbilityClientProxyUnitTest_Unittest_Init_001, TestSize.Level1)
72 {
73 GTEST_LOG_(INFO) << "AccessibleAbilityClientProxyUnitTest_Unittest_Init_001 start";
74
75 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
76 .Times(1)
77 .WillOnce(Invoke(mock_.GetRefPtr(), &AccessibleAbilityClientStubMock::InvokeSendRequest));
78
79 sptr<AccessibleAbilityChannelStubMock> stub = new AccessibleAbilityChannelStubMock();
80 sptr<IAccessibleAbilityChannel> channel = new AccessibleAbilityChannelProxy(stub->AsObject());
81 int channelId = 0;
82 proxy_->Init(channel, channelId);
83
84 EXPECT_EQ((int)IAccessibleAbilityClient::Message::INIT, mock_->code_);
85
86 stub = nullptr;
87 channel = nullptr;
88
89 GTEST_LOG_(INFO) << "AccessibleAbilityClientProxyUnitTest_Unittest_Init_001 end";
90 }
91
92 /**
93 * @tc.number: AccessibleAbilityClientProxyUnitTest_Unittest_Init_002
94 * @tc.name: Init
95 * @tc.desc: Test function Init
96 */
97 HWTEST_F(AccessibleAbilityClientProxyUnitTest, AccessibleAbilityClientProxyUnitTest_Unittest_Init_002, TestSize.Level1)
98 {
99 GTEST_LOG_(INFO) << "AccessibleAbilityClientProxyUnitTest_Unittest_Init_002 start";
100
101 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
102 .Times(1)
103 .WillOnce(Invoke(mock_.GetRefPtr(), &AccessibleAbilityClientStubMock::InvokeErrorSendRequest));
104
105 sptr<AccessibleAbilityChannelStubMock> stub = new AccessibleAbilityChannelStubMock();
106 sptr<IAccessibleAbilityChannel> channel = new AccessibleAbilityChannelProxy(stub->AsObject());
107 int channelId = 0;
108 proxy_->Init(channel, channelId);
109
110 EXPECT_EQ((int)IAccessibleAbilityClient::Message::INIT, mock_->code_);
111
112 stub = nullptr;
113 channel = nullptr;
114
115 GTEST_LOG_(INFO) << "AccessibleAbilityClientProxyUnitTest_Unittest_Init_002 end";
116 }
117
118 /**
119 * @tc.number: AccessibleAbilityClientProxyUnitTest_Unittest_Disconnect_001
120 * @tc.name: Disconnect
121 * @tc.desc: Test function Disconnect
122 */
123 HWTEST_F(AccessibleAbilityClientProxyUnitTest,
124 AccessibleAbilityClientProxyUnitTest_Unittest_Disconnect_001, TestSize.Level1)
125 {
126 GTEST_LOG_(INFO) << "AccessibleAbilityClientProxyUnitTest_Unittest_Disconnect_001 start";
127
128 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
129 .Times(1)
130 .WillOnce(Invoke(mock_.GetRefPtr(), &AccessibleAbilityClientStubMock::InvokeSendRequest));
131
132 int channelId = 0;
133 proxy_->Disconnect(channelId);
134
135 EXPECT_EQ((int)IAccessibleAbilityClient::Message::DISCONNECT, mock_->code_);
136
137 GTEST_LOG_(INFO) << "AccessibleAbilityClientProxyUnitTest_Unittest_Disconnect_001 end";
138 }
139
140 /**
141 * @tc.number: AccessibleAbilityClientProxyUnitTest_Unittest_Disconnect_002
142 * @tc.name: Disconnect
143 * @tc.desc: Test function Disconnect
144 */
145 HWTEST_F(AccessibleAbilityClientProxyUnitTest,
146 AccessibleAbilityClientProxyUnitTest_Unittest_Disconnect_002, TestSize.Level1)
147 {
148 GTEST_LOG_(INFO) << "AccessibleAbilityClientProxyUnitTest_Unittest_Disconnect_002 start";
149
150 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
151 .Times(1)
152 .WillOnce(Invoke(mock_.GetRefPtr(), &AccessibleAbilityClientStubMock::InvokeErrorSendRequest));
153
154 int channelId = 0;
155 proxy_->Disconnect(channelId);
156
157 EXPECT_EQ((int)IAccessibleAbilityClient::Message::DISCONNECT, mock_->code_);
158
159 GTEST_LOG_(INFO) << "AccessibleAbilityClientProxyUnitTest_Unittest_Disconnect_002 end";
160 }
161
162 /**
163 * @tc.number: AccessibleAbilityClientProxyUnitTest_Unittest_OnAccessibilityEvent_001
164 * @tc.name: OnAccessibilityEvent
165 * @tc.desc: Test function OnAccessibilityEvent
166 */
167 HWTEST_F(AccessibleAbilityClientProxyUnitTest,
168 AccessibleAbilityClientProxyUnitTest_Unittest_OnAccessibilityEvent_001, TestSize.Level1)
169 {
170 GTEST_LOG_(INFO) << "AccessibleAbilityClientProxyUnitTest_Unittest_OnAccessibilityEvent_001 start";
171
172 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
173 .Times(1)
174 .WillOnce(Invoke(mock_.GetRefPtr(), &AccessibleAbilityClientStubMock::InvokeSendRequest));
175
176 AccessibilityEventInfo eventInfo;
177 proxy_->OnAccessibilityEvent(eventInfo);
178
179 EXPECT_EQ((int)IAccessibleAbilityClient::Message::ON_ACCESSIBILITY_EVENT, mock_->code_);
180
181 GTEST_LOG_(INFO) << "AccessibleAbilityClientProxyUnitTest_Unittest_OnAccessibilityEvent_001 end";
182 }
183
184 /**
185 * @tc.number: AccessibleAbilityClientProxyUnitTest_Unittest_OnAccessibilityEvent_002
186 * @tc.name: OnAccessibilityEvent
187 * @tc.desc: Test function OnAccessibilityEvent
188 */
189 HWTEST_F(AccessibleAbilityClientProxyUnitTest,
190 AccessibleAbilityClientProxyUnitTest_Unittest_OnAccessibilityEvent_002, TestSize.Level1)
191 {
192 GTEST_LOG_(INFO) << "AccessibleAbilityClientProxyUnitTest_Unittest_OnAccessibilityEvent_002 start";
193
194 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
195 .Times(1)
196 .WillOnce(Invoke(mock_.GetRefPtr(), &AccessibleAbilityClientStubMock::InvokeErrorSendRequest));
197
198 AccessibilityEventInfo eventInfo;
199 proxy_->OnAccessibilityEvent(eventInfo);
200
201 EXPECT_EQ((int)IAccessibleAbilityClient::Message::ON_ACCESSIBILITY_EVENT, mock_->code_);
202
203 GTEST_LOG_(INFO) << "AccessibleAbilityClientProxyUnitTest_Unittest_OnAccessibilityEvent_002 end";
204 }
205
206 /**
207 * @tc.number: AccessibleAbilityClientProxyUnitTest_Unittest_OnKeyPressEvent_001
208 * @tc.name: OnKeyPressEvent
209 * @tc.desc: Test function OnKeyPressEvent
210 */
211 HWTEST_F(AccessibleAbilityClientProxyUnitTest,
212 AccessibleAbilityClientProxyUnitTest_Unittest_OnKeyPressEvent_001, TestSize.Level1)
213 {
214 GTEST_LOG_(INFO) << "AccessibleAbilityClientProxyUnitTest_Unittest_OnKeyPressEvent_001 start";
215
216 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
217 .Times(1)
218 .WillOnce(Invoke(mock_.GetRefPtr(), &AccessibleAbilityClientStubMock::InvokeSendRequest));
219
220 std::shared_ptr<MMI::KeyEvent> keyEvent = MMI::KeyEvent::Create();
221 int sequence = 0;
222 proxy_->OnKeyPressEvent(*keyEvent, sequence);
223
224 EXPECT_EQ((int)IAccessibleAbilityClient::Message::ON_KEY_PRESS_EVENT, mock_->code_);
225
226 GTEST_LOG_(INFO) << "AccessibleAbilityClientProxyUnitTest_Unittest_OnKeyPressEvent_001 end";
227 }
228
229 /**
230 * @tc.number: AccessibleAbilityClientProxyUnitTest_Unittest_OnKeyPressEvent_002
231 * @tc.name: OnKeyPressEvent
232 * @tc.desc: Test function OnKeyPressEvent
233 */
234 HWTEST_F(AccessibleAbilityClientProxyUnitTest,
235 AccessibleAbilityClientProxyUnitTest_Unittest_OnKeyPressEvent_002, TestSize.Level1)
236 {
237 GTEST_LOG_(INFO) << "AccessibleAbilityClientProxyUnitTest_Unittest_OnKeyPressEvent_002 start";
238
239 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
240 .Times(1)
241 .WillOnce(Invoke(mock_.GetRefPtr(), &AccessibleAbilityClientStubMock::InvokeErrorSendRequest));
242
243 std::shared_ptr<MMI::KeyEvent> keyEvent = MMI::KeyEvent::Create();
244 int sequence = 0;
245 proxy_->OnKeyPressEvent(*keyEvent, sequence);
246
247 EXPECT_EQ((int)IAccessibleAbilityClient::Message::ON_KEY_PRESS_EVENT, mock_->code_);
248
249 GTEST_LOG_(INFO) << "AccessibleAbilityClientProxyUnitTest_Unittest_OnKeyPressEvent_002 end";
250 }
251
252 /**
253 * @tc.number: AccessibleAbilityClientProxyUnitTest_Unittest_OnDisplayResized_001
254 * @tc.name: OnDisplayResized
255 * @tc.desc: Test function OnDisplayResized
256 */
257 HWTEST_F(AccessibleAbilityClientProxyUnitTest,
258 AccessibleAbilityClientProxyUnitTest_Unittest_OnDisplayResized_001, TestSize.Level1)
259 {
260 GTEST_LOG_(INFO) << "AccessibleAbilityClientProxyUnitTest_Unittest_OnDisplayResized_001 start";
261
262 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
263 .Times(1)
264 .WillOnce(Invoke(mock_.GetRefPtr(), &AccessibleAbilityClientStubMock::InvokeSendRequest));
265
266 int displayId = 0;
267 Rect rect {};
268 float scale = 1;
269 float centerX = 0;
270 float centerY = 0;
271 proxy_->OnDisplayResized(displayId, rect, scale, centerX, centerY);
272
273 EXPECT_EQ((int)IAccessibleAbilityClient::Message::ON_DISPALYRESIZE_CHANGED, mock_->code_);
274
275 GTEST_LOG_(INFO) << "AccessibleAbilityClientProxyUnitTest_Unittest_OnDisplayResized_001 end";
276 }
277
278 /**
279 * @tc.number: AccessibleAbilityClientProxyUnitTest_Unittest_OnDisplayResized_002
280 * @tc.name: OnDisplayResized
281 * @tc.desc: Test function OnDisplayResized
282 */
283 HWTEST_F(AccessibleAbilityClientProxyUnitTest,
284 AccessibleAbilityClientProxyUnitTest_Unittest_OnDisplayResized_002, TestSize.Level1)
285 {
286 GTEST_LOG_(INFO) << "AccessibleAbilityClientProxyUnitTest_Unittest_OnDisplayResized_002 start";
287
288 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
289 .Times(1)
290 .WillOnce(Invoke(mock_.GetRefPtr(), &AccessibleAbilityClientStubMock::InvokeErrorSendRequest));
291
292 int displayId = 0;
293 Rect rect {};
294 float scale = 1;
295 float centerX = 0;
296 float centerY = 0;
297 proxy_->OnDisplayResized(displayId, rect, scale, centerX, centerY);
298
299 EXPECT_EQ((int)IAccessibleAbilityClient::Message::ON_DISPALYRESIZE_CHANGED, mock_->code_);
300
301 GTEST_LOG_(INFO) << "AccessibleAbilityClientProxyUnitTest_Unittest_OnDisplayResized_002 end";
302 }
303
304 /**
305 * @tc.number: AccessibleAbilityClientProxyUnitTest_Unittest_OnGestureSimulateResult_001
306 * @tc.name: OnGestureSimulateResult
307 * @tc.desc: Test function OnGestureSimulateResult
308 */
309 HWTEST_F(AccessibleAbilityClientProxyUnitTest,
310 AccessibleAbilityClientProxyUnitTest_Unittest_OnGestureSimulateResult_001, TestSize.Level1)
311 {
312 GTEST_LOG_(INFO) << "AccessibleAbilityClientProxyUnitTest_Unittest_OnGestureSimulateResult_001 start";
313
314 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
315 .Times(1)
316 .WillOnce(Invoke(mock_.GetRefPtr(), &AccessibleAbilityClientStubMock::InvokeSendRequest));
317
318 int sequence = 0;
319 bool completedSuccessfully = true;
320 proxy_->OnGestureSimulateResult(sequence, completedSuccessfully);
321
322 EXPECT_EQ((int)IAccessibleAbilityClient::Message::ON_GESTURE_SIMULATE_RESULT, mock_->code_);
323
324 GTEST_LOG_(INFO) << "AccessibleAbilityClientProxyUnitTest_Unittest_OnGestureSimulateResult_001 end";
325 }
326
327 /**
328 * @tc.number: AccessibleAbilityClientProxyUnitTest_Unittest_OnGestureSimulateResult_002
329 * @tc.name: OnGestureSimulateResult
330 * @tc.desc: Test function OnGestureSimulateResult
331 */
332 HWTEST_F(AccessibleAbilityClientProxyUnitTest,
333 AccessibleAbilityClientProxyUnitTest_Unittest_OnGestureSimulateResult_002, TestSize.Level1)
334 {
335 GTEST_LOG_(INFO) << "AccessibleAbilityClientProxyUnitTest_Unittest_OnGestureSimulateResult_002 start";
336
337 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
338 .Times(1)
339 .WillOnce(Invoke(mock_.GetRefPtr(), &AccessibleAbilityClientStubMock::InvokeErrorSendRequest));
340
341 int sequence = 0;
342 bool completedSuccessfully = true;
343 proxy_->OnGestureSimulateResult(sequence, completedSuccessfully);
344
345 EXPECT_EQ((int)IAccessibleAbilityClient::Message::ON_GESTURE_SIMULATE_RESULT, mock_->code_);
346
347 GTEST_LOG_(INFO) << "AccessibleAbilityClientProxyUnitTest_Unittest_OnGestureSimulateResult_002 end";
348 }
349 } // namespace Accessibility
350 } // namespace OHOS