• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2  * Copyright (c) 2023 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 #include "gtest/gtest.h"
16 #include "ui_content.h"
17 #define private public
18 #include "interfaces/inner_api/form_render/include/form_renderer.h"
19 #undef private
20 
21 using namespace testing;
22 using namespace testing::ext;
23 
24 namespace OHOS::Ace {
25 class FormRenderDispatcherImplTest : public testing::Test {
26 public:
SetUpTestCase()27     static void SetUpTestCase() {};
28 
TearDownTestCase()29     static void TearDownTestCase() {};
30 
GetFormRendererDispatcherImpl()31     sptr<FormRendererDispatcherImpl> GetFormRendererDispatcherImpl()
32     {
33         std::shared_ptr<UIContent> uiContent = nullptr;
34         std::shared_ptr<FormRenderer> formRenderer = nullptr;
35         std::weak_ptr<OHOS::AppExecFwk::EventHandler> eventHandler;
36         sptr<FormRendererDispatcherImpl> renderDispatcher =
37             new FormRendererDispatcherImpl(uiContent, formRenderer, eventHandler);
38         return renderDispatcher;
39     }
40 };
41 
42 /**
43  * @tc.name: FormRenderDispatcherImplTest002
44  * @tc.type: FUNC
45  * Function: DispatchPointerEvent
46  **@tc.desc: 1. system running normally
47  *           2. test FormRendererDispatcherImpl
48  */
49 HWTEST_F(FormRenderDispatcherImplTest, FormRenderDispatcherImplTest002, TestSize.Level1)
50 {
51     sptr<FormRendererDispatcherImpl> renderDispatcher = GetFormRendererDispatcherImpl();
52     bool flag = false;
53     if (renderDispatcher != nullptr) {
54         std::shared_ptr<OHOS::MMI::PointerEvent> pointerEvent = OHOS::MMI::PointerEvent::Create();
55         pointerEvent->pointerAction_ = OHOS::MMI::PointerEvent::POINTER_ACTION_DOWN;
56         SerializedGesture serializedGesture;
57         renderDispatcher->DispatchPointerEvent(pointerEvent, serializedGesture);
58         flag = true;
59     }
60     EXPECT_TRUE(flag);
61 }
62 
63 /**
64  * @tc.name: FormRenderDispatcherImplTest003
65  * @tc.type: FUNC
66  * Function: DispatchPointerEvent
67  **@tc.desc: 1. system running normally
68  *           2. test FormRendererDispatcherImpl
69  */
70 HWTEST_F(FormRenderDispatcherImplTest, FormRenderDispatcherImplTest003, TestSize.Level1)
71 {
72     sptr<FormRendererDispatcherImpl> renderDispatcher = GetFormRendererDispatcherImpl();
73     bool flag = false;
74     if (renderDispatcher != nullptr) {
75         std::shared_ptr<OHOS::MMI::PointerEvent> pointerEvent = OHOS::MMI::PointerEvent::Create();
76         pointerEvent->pointerAction_ = OHOS::MMI::PointerEvent::POINTER_ACTION_UP;
77         SerializedGesture serializedGesture;
78         renderDispatcher->DispatchPointerEvent(pointerEvent, serializedGesture);
79         flag = true;
80     }
81     EXPECT_TRUE(flag);
82 }
83 
84 /**
85  * @tc.name: FormRenderDispatcherImplTest004
86  * @tc.type: FUNC
87  * Function: DispatchPointerEvent
88  **@tc.desc: 1. system running normally
89  *           2. test FormRendererDispatcherImpl
90  */
91 HWTEST_F(FormRenderDispatcherImplTest, FormRenderDispatcherImplTest004, TestSize.Level1)
92 {
93     sptr<FormRendererDispatcherImpl> renderDispatcher = GetFormRendererDispatcherImpl();
94     bool flag = false;
95     if (renderDispatcher != nullptr) {
96         std::shared_ptr<OHOS::MMI::PointerEvent> pointerEvent = OHOS::MMI::PointerEvent::Create();
97         pointerEvent->pointerAction_ = OHOS::MMI::PointerEvent::POINTER_ACTION_UP;
98         SerializedGesture serializedGesture;
99         renderDispatcher->DispatchPointerEvent(pointerEvent, serializedGesture);
100         flag = true;
101     }
102     EXPECT_TRUE(flag);
103 }
104 
105 /**
106  * @tc.name: FormRenderDispatcherImplTest005
107  * @tc.type: FUNC
108  * Function: SetObscured
109  **@tc.desc: 1. system running normally
110  *           2. test FormRendererDispatcherImpl
111  */
112 HWTEST_F(FormRenderDispatcherImplTest, FormRenderDispatcherImplTest005, TestSize.Level1)
113 {
114     sptr<FormRendererDispatcherImpl> renderDispatcher = GetFormRendererDispatcherImpl();
115     bool flag = false;
116     if (renderDispatcher != nullptr) {
117         renderDispatcher->SetObscured(true);
118         flag = true;
119     }
120     EXPECT_TRUE(flag);
121 }
122 
123 /**
124  * @tc.name: FormRenderDispatcherImplTest006
125  * @tc.type: FUNC
126  * Function: OnAccessibilityChildTreeRegister
127  **@tc.desc: 1. system running normally
128  *           2. test FormRendererDispatcherImpl
129  */
130 HWTEST_F(FormRenderDispatcherImplTest, FormRenderDispatcherImplTest006, TestSize.Level1)
131 {
132     sptr<FormRendererDispatcherImpl> renderDispatcher = GetFormRendererDispatcherImpl();
133     bool flag = false;
134     uint32_t windowId = 1;
135     int32_t treeId = 11;
136     int64_t accessibilityId = 111;
137     if (renderDispatcher != nullptr) {
138         renderDispatcher->OnAccessibilityChildTreeRegister(windowId, treeId, accessibilityId);
139         flag = true;
140     }
141     EXPECT_TRUE(flag);
142 }
143 
144 /**
145  * @tc.name: FormRenderDispatcherImplTest007
146  * @tc.type: FUNC
147  * Function: OnAccessibilityChildTreeDeregister
148  **@tc.desc: 1. system running normally
149  *           2. test FormRendererDispatcherImpl
150  */
151 HWTEST_F(FormRenderDispatcherImplTest, FormRenderDispatcherImplTest007, TestSize.Level1)
152 {
153     sptr<FormRendererDispatcherImpl> renderDispatcher = GetFormRendererDispatcherImpl();
154     bool flag = false;
155     if (renderDispatcher != nullptr) {
156         renderDispatcher->OnAccessibilityChildTreeDeregister();
157         flag = true;
158     }
159     EXPECT_TRUE(flag);
160 }
161 
162 /**
163  * @tc.name: FormRenderDispatcherImplTest008
164  * @tc.type: FUNC
165  * Function: OnAccessibilityDumpChildInfo
166  **@tc.desc: 1. system running normally
167  *           2. test FormRendererDispatcherImpl
168  */
169 HWTEST_F(FormRenderDispatcherImplTest, FormRenderDispatcherImplTest008, TestSize.Level1)
170 {
171     sptr<FormRendererDispatcherImpl> renderDispatcher = GetFormRendererDispatcherImpl();
172     bool flag = false;
173     std::vector<std::string> params;
174     std::vector<std::string> info;
175     if (renderDispatcher != nullptr) {
176         renderDispatcher->OnAccessibilityDumpChildInfo(params, info);
177         flag = true;
178     }
179     EXPECT_TRUE(flag);
180 }
181 
182 /**
183  * @tc.name: FormRenderDispatcherImplTest009
184  * @tc.type: FUNC
185  * Function: OnAccessibilityDumpChildInfo
186  **@tc.desc: 1. system running normally
187  *           2. test FormRendererDispatcherImpl
188  */
189 HWTEST_F(FormRenderDispatcherImplTest, FormRenderDispatcherImplTest009, TestSize.Level1)
190 {
191     sptr<FormRendererDispatcherImpl> renderDispatcher = GetFormRendererDispatcherImpl();
192     bool flag = false;
193     std::vector<std::string> params;
194     std::vector<std::string> info;
195     if (renderDispatcher != nullptr) {
196         renderDispatcher->OnAccessibilityDumpChildInfo(params, info);
197         flag = true;
198     }
199     EXPECT_TRUE(flag);
200 }
201 
202 /**
203  * @tc.name: FormRenderDispatcherImplTest010
204  * @tc.type: FUNC
205  * Function: OnAccessibilityTransferHoverEvent
206  **@tc.desc: 1. system running normally
207  *           2. test FormRendererDispatcherImpl
208  */
209 HWTEST_F(FormRenderDispatcherImplTest, FormRenderDispatcherImplTest010, TestSize.Level1)
210 {
211     sptr<FormRendererDispatcherImpl> renderDispatcher = GetFormRendererDispatcherImpl();
212     bool flag = false;
213     float pointX = 1.1;
214     float pointY = 2.2;
215     int32_t sourceType = 1;
216     int32_t eventType = 2;
217     int64_t timeMs = 1000;
218     if (renderDispatcher != nullptr) {
219         renderDispatcher->OnAccessibilityTransferHoverEvent(pointX, pointY, sourceType, eventType, timeMs);
220         flag = true;
221     }
222     EXPECT_TRUE(flag);
223 }
224 
225 /**
226  * @tc.name: FormRenderDispatcherImplTest011
227  * @tc.type: FUNC
228  * Function: DispatchSurfaceChangeEvent
229  **@tc.desc: 1. system running normally
230  *           2. test FormRendererDispatcherImpl
231  */
232 HWTEST_F(FormRenderDispatcherImplTest, FormRenderDispatcherImplTest011, TestSize.Level1)
233 {
234     sptr<FormRendererDispatcherImpl> renderDispatcher = GetFormRendererDispatcherImpl();
235     bool flag = false;
236     float width = 11;
237     float height = 22;
238     if (renderDispatcher != nullptr) {
239         renderDispatcher->DispatchSurfaceChangeEvent(width, height);
240         flag = true;
241     }
242     EXPECT_TRUE(flag);
243 }
244 
245 /**
246  * @tc.name: FormRenderDispatcherImplTest012
247  * @tc.type: FUNC
248  * Function: DispatchSurfaceChangeEvent
249  **@tc.desc: 1. system running normally
250  *           2. test FormRendererDispatcherImpl
251  */
252 HWTEST_F(FormRenderDispatcherImplTest, FormRenderDispatcherImplTest012, TestSize.Level1)
253 {
254     sptr<FormRendererDispatcherImpl> renderDispatcher = GetFormRendererDispatcherImpl();
255     bool flag = false;
256     float width = 11;
257     float height = 22;
258     if (renderDispatcher != nullptr) {
259         renderDispatcher->DispatchSurfaceChangeEvent(width, height);
260         flag = true;
261     }
262     EXPECT_TRUE(flag);
263 }
264 
265 /**
266  * @tc.name: FormRenderDispatcherImplTest013
267  * @tc.desc: test FormRendererDispatcherImpl OnRemoteRequest event
268  * @tc.type: FUNC
269  */
270 HWTEST_F(FormRenderDispatcherImplTest, FormRenderDispatcherImplTest013, TestSize.Level1)
271 {
272     sptr<FormRendererDispatcherImpl> renderDispatcher = GetFormRendererDispatcherImpl();
273     constexpr uint32_t code = static_cast<uint32_t>(IFormRendererDispatcher::Message::DISPATCH_POINTER_EVENT);
274     MessageParcel data;
275     data.WriteInterfaceToken(FormRendererDispatcherImpl::GetDescriptor());
276     std::shared_ptr<OHOS::MMI::PointerEvent> pointerEvent = OHOS::MMI::PointerEvent::Create();
277     pointerEvent->WriteToParcel(data);
278     MessageParcel reply;
279     MessageOption option;
280     if (renderDispatcher != nullptr) {
281         auto ans = renderDispatcher->OnRemoteRequest(code, data, reply, option);
282         EXPECT_EQ(ans, ERR_OK);
283     }
284 }
285 
286 /**
287  * @tc.name: FormRenderDispatcherImplTest014
288  * @tc.desc: test FormRendererDispatcherImpl OnRemoteRequest event
289  * @tc.type: FUNC
290  */
291 HWTEST_F(FormRenderDispatcherImplTest, FormRenderDispatcherImplTest014, TestSize.Level1)
292 {
293     sptr<FormRendererDispatcherImpl> renderDispatcher = GetFormRendererDispatcherImpl();
294     constexpr uint32_t code = static_cast<uint32_t>(IFormRendererDispatcher::Message::DISPATCH_POINTER_EVENT);
295     MessageParcel data;
296     data.WriteInterfaceToken(FormRendererDispatcherImpl::GetDescriptor());
297     MessageParcel reply;
298     MessageOption option;
299     if (renderDispatcher != nullptr) {
300         auto ans = renderDispatcher->OnRemoteRequest(code, data, reply, option);
301         EXPECT_EQ(ans, ERR_INVALID_VALUE);
302     }
303 }
304 
305 /**
306  * @tc.name: FormRenderDispatcherImplTest015
307  * @tc.desc: test FormRendererDispatcherImpl OnRemoteRequest event
308  * @tc.type: FUNC
309  */
310 HWTEST_F(FormRenderDispatcherImplTest, FormRenderDispatcherImplTest015, TestSize.Level1)
311 {
312     sptr<FormRendererDispatcherImpl> renderDispatcher = GetFormRendererDispatcherImpl();
313     constexpr uint32_t code = static_cast<uint32_t>(IFormRendererDispatcher::Message::SET_ALLOW_UPDATE);
314     MessageParcel data;
315     data.WriteInterfaceToken(FormRendererDispatcherImpl::GetDescriptor());
316     data.WriteBool(true);
317     MessageParcel reply;
318     MessageOption option;
319     if (renderDispatcher != nullptr) {
320         auto ans = renderDispatcher->OnRemoteRequest(code, data, reply, option);
321         EXPECT_EQ(ans, ERR_OK);
322     }
323 }
324 
325 /**
326  * @tc.name: FormRenderDispatcherImplTest016
327  * @tc.desc: test FormRendererDispatcherImpl OnRemoteRequest event
328  * @tc.type: FUNC
329  */
330 HWTEST_F(FormRenderDispatcherImplTest, FormRenderDispatcherImplTest016, TestSize.Level1)
331 {
332     sptr<FormRendererDispatcherImpl> renderDispatcher = GetFormRendererDispatcherImpl();
333     constexpr uint32_t code = static_cast<uint32_t>(IFormRendererDispatcher::Message::DISPATCH_SURFACE_CHANGE_EVENT);
334     MessageParcel data;
335     data.WriteInterfaceToken(FormRendererDispatcherImpl::GetDescriptor());
336     float width = 1.0;
337     float height = 1.0;
338     float borderWidth = 1.0;
339     data.WriteBool(width);
340     data.WriteBool(height);
341     data.WriteBool(borderWidth);
342     MessageParcel reply;
343     MessageOption option;
344     if (renderDispatcher != nullptr) {
345         auto ans = renderDispatcher->OnRemoteRequest(code, data, reply, option);
346         EXPECT_EQ(ans, ERR_OK);
347     }
348 }
349 
350 /**
351  * @tc.name: FormRenderDispatcherImplTest017
352  * @tc.desc: test FormRendererDispatcherImpl OnRemoteRequest event
353  * @tc.type: FUNC
354  */
355 HWTEST_F(FormRenderDispatcherImplTest, FormRenderDispatcherImplTest017, TestSize.Level1)
356 {
357     sptr<FormRendererDispatcherImpl> renderDispatcher = GetFormRendererDispatcherImpl();
358     constexpr uint32_t code = static_cast<uint32_t>(IFormRendererDispatcher::Message::SET_OBSCURED);
359     MessageParcel data;
360     data.WriteInterfaceToken(FormRendererDispatcherImpl::GetDescriptor());
361     data.WriteBool(true);
362     MessageParcel reply;
363     MessageOption option;
364     if (renderDispatcher != nullptr) {
365         auto ans = renderDispatcher->OnRemoteRequest(code, data, reply, option);
366         EXPECT_EQ(ans, ERR_OK);
367     }
368 }
369 
370 /**
371  * @tc.name: FormRenderDispatcherImplTest018
372  * @tc.desc: test FormRendererDispatcherImpl OnRemoteRequest event
373  * @tc.type: FUNC
374  */
375 HWTEST_F(FormRenderDispatcherImplTest, FormRenderDispatcherImplTest018, TestSize.Level1)
376 {
377     sptr<FormRendererDispatcherImpl> renderDispatcher = GetFormRendererDispatcherImpl();
378     constexpr uint32_t code =
379         static_cast<uint32_t>(IFormRendererDispatcher::Message::ACCESSIBILITY_CHILD_TREE_REGISTER);
380     MessageParcel data;
381     data.WriteInterfaceToken(FormRendererDispatcherImpl::GetDescriptor());
382     uint32_t windowId = 1;
383     int32_t treeId = 2;
384     int64_t accessibilityId = 3;
385     data.WriteUint32(windowId);
386     data.WriteUint32(treeId);
387     data.WriteUint64(accessibilityId);
388     MessageParcel reply;
389     MessageOption option(MessageOption::TF_ASYNC);
390     if (renderDispatcher != nullptr) {
391         auto ans = renderDispatcher->OnRemoteRequest(code, data, reply, option);
392         EXPECT_EQ(ans, ERR_OK);
393     }
394 }
395 
396 /**
397  * @tc.name: FormRenderDispatcherImplTest019
398  * @tc.desc: test FormRendererDispatcherImpl OnRemoteRequest event
399  * @tc.type: FUNC
400  */
401 HWTEST_F(FormRenderDispatcherImplTest, FormRenderDispatcherImplTest019, TestSize.Level1)
402 {
403     sptr<FormRendererDispatcherImpl> renderDispatcher = GetFormRendererDispatcherImpl();
404     constexpr uint32_t code =
405         static_cast<uint32_t>(IFormRendererDispatcher::Message::ACCESSIBILITY_CHILD_TREE_DEREGISTER);
406     MessageParcel data;
407     data.WriteInterfaceToken(FormRendererDispatcherImpl::GetDescriptor());
408     MessageParcel reply;
409     MessageOption option(MessageOption::TF_ASYNC);
410     if (renderDispatcher != nullptr) {
411         auto ans = renderDispatcher->OnRemoteRequest(code, data, reply, option);
412         EXPECT_EQ(ans, ERR_OK);
413     }
414 }
415 
416 /**
417  * @tc.name: FormRenderDispatcherImplTest020
418  * @tc.desc: test FormRendererDispatcherImpl OnRemoteRequest event
419  * @tc.type: FUNC
420  */
421 HWTEST_F(FormRenderDispatcherImplTest, FormRenderDispatcherImplTest020, TestSize.Level1)
422 {
423     sptr<FormRendererDispatcherImpl> renderDispatcher = GetFormRendererDispatcherImpl();
424     constexpr uint32_t code = static_cast<uint32_t>(IFormRendererDispatcher::Message::ACCESSIBILITY_DUMP_CHILD_INFO);
425     MessageParcel data;
426     data.WriteInterfaceToken(FormRendererDispatcherImpl::GetDescriptor());
427     const std::vector<std::string> params { "hello", "world" };
428     data.WriteStringVector(params);
429     MessageParcel reply;
430     MessageOption option;
431     if (renderDispatcher != nullptr) {
432         auto ans = renderDispatcher->OnRemoteRequest(code, data, reply, option);
433         EXPECT_EQ(ans, ERR_OK);
434     }
435 }
436 
437 /**
438  * @tc.name: FormRenderDispatcherImplTest021
439  * @tc.desc: test FormRendererDispatcherImpl OnRemoteRequest event
440  * @tc.type: FUNC
441  */
442 HWTEST_F(FormRenderDispatcherImplTest, FormRenderDispatcherImplTest021, TestSize.Level1)
443 {
444     sptr<FormRendererDispatcherImpl> renderDispatcher = GetFormRendererDispatcherImpl();
445     constexpr uint32_t code = static_cast<uint32_t>(IFormRendererDispatcher::Message::ACCESSIBILITY_DUMP_CHILD_INFO);
446     MessageParcel data;
447     data.WriteInterfaceToken(FormRendererDispatcherImpl::GetDescriptor());
448     data.WriteBool(true);
449     MessageParcel reply;
450     MessageOption option;
451     if (renderDispatcher != nullptr) {
452         auto ans = renderDispatcher->OnRemoteRequest(code, data, reply, option);
453         EXPECT_EQ(ans, ERR_INVALID_VALUE);
454     }
455 }
456 
457 /**
458  * @tc.name: FormRenderDispatcherImplTest022
459  * @tc.desc: test FormRendererDispatcherImpl OnRemoteRequest event
460  * @tc.type: FUNC
461  */
462 HWTEST_F(FormRenderDispatcherImplTest, FormRenderDispatcherImplTest022, TestSize.Level1)
463 {
464     sptr<FormRendererDispatcherImpl> renderDispatcher = GetFormRendererDispatcherImpl();
465     constexpr uint32_t code =
466         static_cast<uint32_t>(IFormRendererDispatcher::Message::ACCESSIBILITY_TRANSFER_HOVER_EVENT);
467     MessageParcel data;
468     data.WriteInterfaceToken(FormRendererDispatcherImpl::GetDescriptor());
469     float pointX = 0;
470     float pointY = 0;
471     int32_t sourceType = 0;
472     int32_t eventType = 0;
473     int64_t timeMs = 1;
474     data.WriteFloat(pointX);
475     data.WriteFloat(pointY);
476     data.WriteInt32(sourceType);
477     data.WriteInt32(eventType);
478     data.WriteInt64(timeMs);
479     MessageParcel reply;
480     MessageOption option(MessageOption::TF_ASYNC);
481     if (renderDispatcher != nullptr) {
482         auto ans = renderDispatcher->OnRemoteRequest(code, data, reply, option);
483         EXPECT_EQ(ans, ERR_OK);
484     }
485 }
486 
487 /**
488  * @tc.name: FormRenderDispatcherImplTest023
489  * @tc.desc: test FormRendererDispatcherImpl OnRemoteRequest event
490  * @tc.type: FUNC
491  */
492 HWTEST_F(FormRenderDispatcherImplTest, FormRenderDispatcherImplTest023, TestSize.Level1)
493 {
494     sptr<FormRendererDispatcherImpl> renderDispatcher = GetFormRendererDispatcherImpl();
495     constexpr uint32_t code =
496         static_cast<uint32_t>(IFormRendererDispatcher::Message::ACCESSIBILITY_TRANSFER_HOVER_EVENT);
497     MessageParcel data;
498     data.WriteInterfaceToken(FormRendererDispatcherImpl::GetDescriptor());
499     MessageParcel reply;
500     MessageOption option(MessageOption::TF_ASYNC);
501     if (renderDispatcher != nullptr) {
502         auto ans = renderDispatcher->OnRemoteRequest(code, data, reply, option);
503         EXPECT_EQ(ans, ERR_INVALID_VALUE);
504     }
505 }
506 
507 /**
508  * @tc.name: FormRenderDispatcherImplTest024
509  * @tc.type: FUNC
510  * Function: OnNotifyDumpInfo
511  **@tc.desc: FUNC
512  */
513 HWTEST_F(FormRenderDispatcherImplTest, FormRenderDispatcherImplTest024, TestSize.Level1)
514 {
515     std::vector<std::string> params;
516     std::vector<std::string> info;
517     bool flag = false;
518     sptr<FormRendererDispatcherImpl> renderDispatcher = GetFormRendererDispatcherImpl();
519     if (renderDispatcher != nullptr) {
520         renderDispatcher->OnNotifyDumpInfo(params, info);
521         flag = true;
522     }
523     EXPECT_TRUE(flag);
524 }
525 
526 } // namespace OHOS::Ace
527