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