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 <memory>
18 #include <vector>
19
20 #include "gesture_simulation.h"
21 #include "parcel.h"
22
23 using namespace testing;
24 using namespace testing::ext;
25 using namespace std;
26
27 namespace OHOS {
28 namespace Accessibility {
29 const int64_t MAX_STROKE_DURATION = 60 * 1000;
30 const uint32_t MAX_STROKES = 10;
31
32 class UnitTestGestureResultListener : public GestureResultListener {
33 public:
UnitTestGestureResultListener()34 UnitTestGestureResultListener() {}
~UnitTestGestureResultListener()35 virtual ~UnitTestGestureResultListener() {}
36
OnGestureInjectResult(uint32_t sequence,bool result)37 void OnGestureInjectResult(uint32_t sequence, bool result) override
38 {
39 GTEST_LOG_(INFO) << "UnitTestGestureResultListener OnGestureInjectResult";
40 }
41 };
42
43 class GestureSimulationUnitTest : public ::testing::Test {
44 public:
GestureSimulationUnitTest()45 GestureSimulationUnitTest() {}
~GestureSimulationUnitTest()46 ~GestureSimulationUnitTest() {}
47
48 static void SetUpTestCase();
49 static void TearDownTestCase();
50 void SetUp() override;
51 void TearDown() override;
52 };
53
SetUpTestCase()54 void GestureSimulationUnitTest::SetUpTestCase()
55 {
56 GTEST_LOG_(INFO) << "###################### GestureSimulationUnitTest Start ######################";
57 }
58
TearDownTestCase()59 void GestureSimulationUnitTest::TearDownTestCase()
60 {
61 GTEST_LOG_(INFO) << "###################### GestureSimulationUnitTest End ######################";
62 }
63
SetUp()64 void GestureSimulationUnitTest::SetUp()
65 {}
66
TearDown()67 void GestureSimulationUnitTest::TearDown()
68 {}
69
70 /**
71 * @tc.number: GestureSimulation_Unittest_GesturePathPositionDefine_GetPositionX_001
72 * @tc.name: GesturePathPositionDefine_GetPositionX
73 * @tc.desc: Test function GetPositionX in class GesturePathPositionDefine
74 */
75 HWTEST_F(GestureSimulationUnitTest,
76 GestureSimulation_Unittest_GesturePathPositionDefine_GetPositionX_001, TestSize.Level1)
77 {
78 GTEST_LOG_(INFO) << "GestureSimulation_Unittest_GesturePathPositionDefine_GetPositionX_001 start";
79
80 GesturePathPositionDefine position {};
81 float positionX = 1.1;
82
83 position.SetPositionX(positionX);
84 EXPECT_EQ(position.GetPositionX(), positionX);
85
86 GTEST_LOG_(INFO) << "GestureSimulation_Unittest_GesturePathPositionDefine_GetPositionX_001 end";
87 }
88
89 /**
90 * @tc.number: GestureSimulation_Unittest_GesturePathPositionDefine_GetPositionY_001
91 * @tc.name: GesturePathPositionDefine_GetPositionY
92 * @tc.desc: Test function GetPositionY in class GesturePathPositionDefine
93 */
94 HWTEST_F(GestureSimulationUnitTest,
95 GestureSimulation_Unittest_GesturePathPositionDefine_GetPositionY_001, TestSize.Level1)
96 {
97 GTEST_LOG_(INFO) << "GestureSimulation_Unittest_GesturePathPositionDefine_GetPositionY_001 start";
98
99 GesturePathPositionDefine position {};
100 float positionY = 1.1;
101
102 position.SetPositionY(positionY);
103 EXPECT_EQ(position.GetPositionY(), positionY);
104
105 GTEST_LOG_(INFO) << "GestureSimulation_Unittest_GesturePathPositionDefine_GetPositionY_001 end";
106 }
107
108 /**
109 * @tc.number: GestureSimulation_Unittest_GesturePathPositionDefine_SetPositionX_001
110 * @tc.name: GesturePathPositionDefine_SetPositionX
111 * @tc.desc: Test function SetPositionX in class GesturePathPositionDefine
112 */
113 HWTEST_F(GestureSimulationUnitTest,
114 GestureSimulation_Unittest_GesturePathPositionDefine_SetPositionX_001, TestSize.Level1)
115 {
116 GTEST_LOG_(INFO) << "GestureSimulation_Unittest_GesturePathPositionDefine_SetPositionX_001 start";
117
118 GesturePathPositionDefine position {};
119 float positionX = 1.1;
120 position.SetPositionX(positionX);
121
122 GTEST_LOG_(INFO) << "GestureSimulation_Unittest_GesturePathPositionDefine_SetPositionX_001 end";
123 }
124
125 /**
126 * @tc.number: GestureSimulation_Unittest_GesturePathPositionDefine_SetPositionY_001
127 * @tc.name: GesturePathPositionDefine_SetPositionY
128 * @tc.desc: Test function SetPositionY in class GesturePathPositionDefine
129 */
130 HWTEST_F(GestureSimulationUnitTest,
131 GestureSimulation_Unittest_GesturePathPositionDefine_SetPositionY_001, TestSize.Level1)
132 {
133 GTEST_LOG_(INFO) << "GestureSimulation_Unittest_GesturePathPositionDefine_SetPositionY_001 start";
134
135 GesturePathPositionDefine position {};
136 float positionY = 1.1;
137 position.SetPositionY(positionY);
138
139 GTEST_LOG_(INFO) << "GestureSimulation_Unittest_GesturePathPositionDefine_SetPositionY_001 end";
140 }
141
142 /**
143 * @tc.number: GestureSimulation_Unittest_GesturePathPositionDefine_ReadFromParcel_001
144 * @tc.name: GesturePathPositionDefine_ReadFromParcel
145 * @tc.desc: Test function ReadFromParcel in class GesturePathPositionDefine
146 */
147 HWTEST_F(GestureSimulationUnitTest,
148 GestureSimulation_Unittest_GesturePathPositionDefine_ReadFromParcel_001, TestSize.Level1)
149 {
150 GTEST_LOG_(INFO) << "GestureSimulation_Unittest_GesturePathPositionDefine_ReadFromParcel_001 start";
151
152 GesturePathPositionDefine position {};
153 Parcel parcel;
154
155 position.Marshalling(parcel);
156 EXPECT_TRUE(position.ReadFromParcel(parcel));
157
158 GTEST_LOG_(INFO) << "GestureSimulation_Unittest_GesturePathPositionDefine_ReadFromParcel_001 end";
159 }
160
161 /**
162 * @tc.number: GestureSimulation_Unittest_GesturePathPositionDefine_Marshalling_001
163 * @tc.name: GesturePathPositionDefine_Marshalling
164 * @tc.desc: Test function Marshalling in class GesturePathPositionDefine
165 */
166 HWTEST_F(GestureSimulationUnitTest,
167 GestureSimulation_Unittest_GesturePathPositionDefine_Marshalling_001, TestSize.Level1)
168 {
169 GTEST_LOG_(INFO) << "GestureSimulation_Unittest_GesturePathPositionDefine_Marshalling_001 start";
170
171 GesturePathPositionDefine position {};
172 Parcel parcel;
173 EXPECT_TRUE(position.Marshalling(parcel));
174
175 GTEST_LOG_(INFO) << "GestureSimulation_Unittest_GesturePathPositionDefine_Marshalling_001 end";
176 }
177
178 /**
179 * @tc.number: GestureSimulation_Unittest_GesturePathPositionDefine_Unmarshalling_001
180 * @tc.name: GesturePathPositionDefine_Unmarshalling
181 * @tc.desc: Test function Unmarshalling in class GesturePathPositionDefine
182 */
183 HWTEST_F(GestureSimulationUnitTest,
184 GestureSimulation_Unittest_GesturePathPositionDefine_Unmarshalling_001, TestSize.Level1)
185 {
186 GTEST_LOG_(INFO) << "GestureSimulation_Unittest_GesturePathPositionDefine_Unmarshalling_001 start";
187
188 GesturePathPositionDefine position {};
189 position.SetPositionX(1.0);
190 position.SetPositionY(1.0);
191
192 Parcel parcel;
193 position.Marshalling(parcel);
194 GesturePathPositionDefine *obj = position.Unmarshalling(parcel);
195 ASSERT_TRUE(obj);
196 EXPECT_EQ(obj->GetPositionX(), position.GetPositionX());
197 EXPECT_EQ(obj->GetPositionY(), position.GetPositionY());
198
199 GTEST_LOG_(INFO) << "GestureSimulation_Unittest_GesturePathPositionDefine_Unmarshalling_001 end";
200 }
201
202 /**
203 * @tc.number: GestureSimulation_Unittest_GesturePathDefine_001
204 * @tc.name: GesturePathDefine
205 * @tc.desc: Test function GesturePathDefine in class GesturePathDefine
206 */
207 HWTEST_F(GestureSimulationUnitTest, GestureSimulation_Unittest_GesturePathDefine_001, TestSize.Level1)
208 {
209 GTEST_LOG_(INFO) << "GestureSimulation_Unittest_GesturePathDefine_001 start";
210
211 GesturePathPositionDefine startPosition {};
212 GesturePathPositionDefine endPosition {};
213 int64_t durationTime = 1;
214 startPosition.SetPositionX(-1);
215 shared_ptr<GesturePathDefine> path = make_shared<GesturePathDefine>(startPosition, endPosition, durationTime);
216 EXPECT_NE(path->GetStartPosition().GetPositionX(), -1);
217
218 GTEST_LOG_(INFO) << "GestureSimulation_Unittest_GesturePathDefine_001 end";
219 }
220
221 /**
222 * @tc.number: GestureSimulation_Unittest_GesturePathDefine_002
223 * @tc.name: GesturePathDefine
224 * @tc.desc: Test function GesturePathDefine in class GesturePathDefine
225 */
226 HWTEST_F(GestureSimulationUnitTest, GestureSimulation_Unittest_GesturePathDefine_002, TestSize.Level1)
227 {
228 GTEST_LOG_(INFO) << "GestureSimulation_Unittest_GesturePathDefine_002 start";
229
230 GesturePathPositionDefine startPosition {};
231 GesturePathPositionDefine endPosition {};
232 int64_t durationTime = 1;
233 endPosition.SetPositionX(-1);
234 shared_ptr<GesturePathDefine> path = make_shared<GesturePathDefine>(startPosition, endPosition, durationTime);
235 EXPECT_NE(path->GetEndPosition().GetPositionX(), -1);
236
237 GTEST_LOG_(INFO) << "GestureSimulation_Unittest_GesturePathDefine_002 end";
238 }
239
240 /**
241 * @tc.number: GestureSimulation_Unittest_GesturePathDefine_GetMaxStrokeDuration_001
242 * @tc.name: GesturePathDefine_GetMaxStrokeDuration
243 * @tc.desc: Test function GetMaxStrokeDuration in class GesturePathDefine
244 */
245 HWTEST_F(GestureSimulationUnitTest,
246 GestureSimulation_Unittest_GesturePathDefine_GetMaxStrokeDuration_001, TestSize.Level1)
247 {
248 GTEST_LOG_(INFO) << "GestureSimulation_Unittest_GesturePathDefine_GetMaxStrokeDuration_001 start";
249
250 GesturePathDefine path {};
251 EXPECT_EQ(path.GetMaxStrokeDuration(), MAX_STROKE_DURATION);
252
253 GTEST_LOG_(INFO) << "GestureSimulation_Unittest_GesturePathDefine_GetMaxStrokeDuration_001 end";
254 }
255
256 /**
257 * @tc.number: GestureSimulation_Unittest_GesturePathDefine_GetMaxStrokes_001
258 * @tc.name: GesturePathDefine_GetMaxStrokes
259 * @tc.desc: Test function GetMaxStrokes in class GesturePathDefine
260 */
261 HWTEST_F(GestureSimulationUnitTest, GestureSimulation_Unittest_GesturePathDefine_GetMaxStrokes_001, TestSize.Level1)
262 {
263 GTEST_LOG_(INFO) << "GestureSimulation_Unittest_GesturePathDefine_GetMaxStrokes_001 start";
264
265 GesturePathDefine path {};
266 EXPECT_EQ(path.GetMaxStrokes(), MAX_STROKES);
267
268 GTEST_LOG_(INFO) << "GestureSimulation_Unittest_GesturePathDefine_GetMaxStrokes_001 end";
269 }
270
271 /**
272 * @tc.number: GestureSimulation_Unittest_GesturePathDefine_GetDurationTime_001
273 * @tc.name: GesturePathDefine_GetDurationTime
274 * @tc.desc: Test function GetDurationTime in class GesturePathDefine
275 */
276 HWTEST_F(GestureSimulationUnitTest, GestureSimulation_Unittest_GesturePathDefine_GetDurationTime_001, TestSize.Level1)
277 {
278 GTEST_LOG_(INFO) << "GestureSimulation_Unittest_GesturePathDefine_GetDurationTime_001 start";
279
280 GesturePathDefine path {};
281 int64_t durationTime = 1;
282
283 path.SetDurationTime(durationTime);
284 EXPECT_EQ(path.GetDurationTime(), durationTime);
285
286 GTEST_LOG_(INFO) << "GestureSimulation_Unittest_GesturePathDefine_GetDurationTime_001 end";
287 }
288
289 /**
290 * @tc.number: GestureSimulation_Unittest_GesturePathDefine_GetEndPosition_001
291 * @tc.name: GesturePathDefine_GetEndPosition
292 * @tc.desc: Test function GetEndPosition in class GesturePathDefine
293 */
294 HWTEST_F(GestureSimulationUnitTest, GestureSimulation_Unittest_GesturePathDefine_GetEndPosition_001, TestSize.Level1)
295 {
296 GTEST_LOG_(INFO) << "GestureSimulation_Unittest_GesturePathDefine_GetEndPosition_001 start";
297
298 GesturePathPositionDefine endposition {};
299 endposition.SetPositionX(1.0);
300 endposition.SetPositionY(1.0);
301
302 GesturePathDefine path {};
303 path.SetEndPosition(endposition);
304
305 EXPECT_EQ(path.GetEndPosition().GetPositionX(), endposition.GetPositionX());
306 EXPECT_EQ(path.GetEndPosition().GetPositionY(), endposition.GetPositionY());
307
308 GTEST_LOG_(INFO) << "GestureSimulation_Unittest_GesturePathDefine_GetEndPosition_001 end";
309 }
310
311 /**
312 * @tc.number: GestureSimulation_Unittest_GesturePathDefine_GetStartPosition_001
313 * @tc.name: GesturePathDefine_GetStartPosition
314 * @tc.desc: Test function GetStartPosition in class GesturePathDefine
315 */
316 HWTEST_F(GestureSimulationUnitTest,
317 GestureSimulation_Unittest_GesturePathDefine_GetStartPosition_001, TestSize.Level1)
318 {
319 GTEST_LOG_(INFO) << "GestureSimulation_Unittest_GesturePathDefine_GetStartPosition_001 start";
320
321 GesturePathPositionDefine startposition {};
322 startposition.SetPositionX(1.0);
323 startposition.SetPositionY(1.0);
324
325 GesturePathDefine path {};
326 path.SetStartPosition(startposition);
327
328 EXPECT_EQ(path.GetStartPosition().GetPositionX(), startposition.GetPositionX());
329 EXPECT_EQ(path.GetStartPosition().GetPositionY(), startposition.GetPositionY());
330
331 GTEST_LOG_(INFO) << "GestureSimulation_Unittest_GesturePathDefine_GetStartPosition_001 end";
332 }
333
334 /**
335 * @tc.number: GestureSimulation_Unittest_GesturePathDefine_SetDurationTime_001
336 * @tc.name: GesturePathDefine_SetDurationTime
337 * @tc.desc: Test function SetDurationTime in class GesturePathDefine
338 */
339 HWTEST_F(GestureSimulationUnitTest,
340 GestureSimulation_Unittest_GesturePathDefine_SetDurationTime_001, TestSize.Level1)
341 {
342 GTEST_LOG_(INFO) << "GestureSimulation_Unittest_GesturePathDefine_SetDurationTime_001 start";
343
344 GesturePathDefine path {};
345 int64_t durationTime = 1;
346
347 path.SetDurationTime(durationTime);
348
349 GTEST_LOG_(INFO) << "GestureSimulation_Unittest_GesturePathDefine_SetDurationTime_001 end";
350 }
351
352 /**
353 * @tc.number: GestureSimulation_Unittest_GesturePathDefine_SetEndPosition_001
354 * @tc.name: GesturePathDefine_SetEndPosition
355 * @tc.desc: Test function SetEndPosition in class GesturePathDefine
356 */
357 HWTEST_F(GestureSimulationUnitTest,
358 GestureSimulation_Unittest_GesturePathDefine_SetEndPosition_001, TestSize.Level1)
359 {
360 GTEST_LOG_(INFO) << "GestureSimulation_Unittest_GesturePathDefine_SetEndPosition_001 start";
361
362 GesturePathPositionDefine endposition {};
363 GesturePathDefine path {};
364 path.SetEndPosition(endposition);
365
366 GTEST_LOG_(INFO) << "GestureSimulation_Unittest_GesturePathDefine_SetEndPosition_001 end";
367 }
368
369 /**
370 * @tc.number: GestureSimulation_Unittest_GesturePathDefine_SetStartPosition_001
371 * @tc.name: GesturePathDefine_SetStartPosition
372 * @tc.desc: Test function SetStartPosition in class GesturePathDefine
373 */
374 HWTEST_F(GestureSimulationUnitTest,
375 GestureSimulation_Unittest_GesturePathDefine_SetStartPosition_001, TestSize.Level1)
376 {
377 GTEST_LOG_(INFO) << "GestureSimulation_Unittest_GesturePathDefine_SetStartPosition_001 start";
378
379 GesturePathPositionDefine startposition {};
380 GesturePathDefine path {};
381 path.SetStartPosition(startposition);
382
383 GTEST_LOG_(INFO) << "GestureSimulation_Unittest_GesturePathDefine_SetStartPosition_001 end";
384 }
385
386 /**
387 * @tc.number: GestureSimulation_Unittest_GesturePathDefine_ReadFromParcel_001
388 * @tc.name: GesturePathDefine_ReadFromParcel
389 * @tc.desc: Test function ReadFromParcel in class GesturePathDefine
390 */
391 HWTEST_F(GestureSimulationUnitTest,
392 GestureSimulation_Unittest_GesturePathDefine_ReadFromParcel_001, TestSize.Level1)
393 {
394 GTEST_LOG_(INFO) << "GestureSimulation_Unittest_GesturePathDefine_ReadFromParcel_001 start";
395
396 GesturePathDefine path {};
397 Parcel parcel;
398
399 path.Marshalling(parcel);
400 EXPECT_TRUE(path.ReadFromParcel(parcel));
401
402 GTEST_LOG_(INFO) << "GestureSimulation_Unittest_GesturePathDefine_ReadFromParcel_001 end";
403 }
404
405 /**
406 * @tc.number: GestureSimulation_Unittest_GesturePathDefine_Marshalling_001
407 * @tc.name: GesturePathDefine_Marshalling
408 * @tc.desc: Test function Marshalling in class GesturePathDefine
409 */
410 HWTEST_F(GestureSimulationUnitTest,
411 GestureSimulation_Unittest_GesturePathDefine_Marshalling_001, TestSize.Level1)
412 {
413 GTEST_LOG_(INFO) << "GestureSimulation_Unittest_GesturePathDefine_Marshalling_001 start";
414
415 GesturePathDefine path {};
416 Parcel parcel;
417 EXPECT_TRUE(path.Marshalling(parcel));
418
419 GTEST_LOG_(INFO) << "GestureSimulation_Unittest_GesturePathDefine_Marshalling_001 end";
420 }
421
422 /**
423 * @tc.number: GestureSimulation_Unittest_GesturePathDefine_Unmarshalling_001
424 * @tc.name: GesturePathDefine_Unmarshalling
425 * @tc.desc: Test function Unmarshalling in class GesturePathDefine
426 */
427 HWTEST_F(GestureSimulationUnitTest,
428 GestureSimulation_Unittest_GesturePathDefine_Unmarshalling_001, TestSize.Level1)
429 {
430 GTEST_LOG_(INFO) << "GestureSimulation_Unittest_GesturePathDefine_Unmarshalling_001 start";
431
432 GesturePathPositionDefine startposition {};
433 GesturePathPositionDefine endposition {};
434 startposition.SetPositionX(1.0);
435 startposition.SetPositionY(1.0);
436 endposition.SetPositionX(2.0);
437 endposition.SetPositionY(2.0);
438 int64_t durationTime = 1;
439
440 GesturePathDefine path {};
441 path.SetDurationTime(durationTime);
442 path.SetStartPosition(startposition);
443 path.SetEndPosition(endposition);
444
445 Parcel parcel;
446 path.Marshalling(parcel);
447 GesturePathDefine *obj = path.Unmarshalling(parcel);
448 ASSERT_TRUE(obj);
449 EXPECT_EQ(obj->GetDurationTime(), durationTime);
450 EXPECT_EQ(obj->GetStartPosition().GetPositionX(), startposition.GetPositionX());
451 EXPECT_EQ(obj->GetStartPosition().GetPositionY(), startposition.GetPositionY());
452 EXPECT_EQ(obj->GetEndPosition().GetPositionX(), endposition.GetPositionX());
453 EXPECT_EQ(obj->GetEndPosition().GetPositionY(), endposition.GetPositionY());
454
455 GTEST_LOG_(INFO) << "GestureSimulation_Unittest_GesturePathDefine_Unmarshalling_001 end";
456 }
457 } // namespace Accessibility
458 } // namespace OHOS