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 
16 #include <thread>
17 #include <chrono>
18 #include "gtest/gtest.h"
19 #include "test/mock/interfaces/mock_uicontent.h"
20 #include "ui_content.h"
21 
22 #define private public
23 #include "interfaces/inner_api/form_render/include/form_renderer.h"
24 #include "interfaces/inner_api/form_render/include/form_renderer_delegate_impl.h"
25 #include "interfaces/inner_api/form_render/include/form_renderer_group.h"
26 #include "interfaces/inner_api/ace/serialized_gesture.h"
27 #include "test/mock/core/pipeline/mock_pipeline_context.h"
28 
29 using namespace testing;
30 using namespace testing::ext;
31 
32 namespace OHOS::Ace {
33 namespace {
34 constexpr char FORM_RENDERER_ALLOW_UPDATE[] = "allowUpdate";
35 constexpr char FORM_RENDERER_COMP_ID[] = "ohos.extra.param.key.form_comp_id";
36 constexpr char FORM_WIDTH_KEY[] = "ohos.extra.param.key.form_width";
37 constexpr char FORM_HEIGHT_KEY[] = "ohos.extra.param.key.form_height";
38 constexpr char FORM_RENDERER_PROCESS_ON_ADD_SURFACE[] = "ohos.extra.param.key.process_on_add_surface";
39 constexpr char FORM_RENDER_STATE[] = "ohos.extra.param.key.form_render_state";
40 constexpr const char* FORM_STATUS_DATA = "form_status_data";
41 const std::string FORM_COMPONENT_ID_1 = "111111";
42 const std::string FORM_COMPONENT_ID_2 = "222222";
43 const std::string FORM_COMPONENT_ID_3 = "333333";
44 const std::string CHECK_KEY = "CHECK_KEY";
45 constexpr double FORM_WIDTH = 100.0f;
46 constexpr double FORM_HEIGHT = 100.0f;
47 constexpr double FORM_WIDTH_2 = 200.0f;
48 constexpr double FORM_HEIGHT_2 = 200.0f;
49 } // namespace
50 class FormRenderTest : public testing::Test {
51 public:
SetUpTestCase()52     static void SetUpTestCase()
53     {
54         NG::MockPipelineContext::SetUp();
55     }
56 
TearDownTestCase()57     static void TearDownTestCase()
58     {
59         NG::MockPipelineContext::TearDown();
60     }
61 };
62 
63 /**
64  * @tc.name: FormRenderTest001
65  * @tc.desc: test AddForm -> UpdateForm -> ReloadForm -> DeleteForm(comp_id) -> DeleteForm
66  * @tc.type: FUNC
67  */
68 HWTEST_F(FormRenderTest, FormRenderTest001, TestSize.Level1)
69 {
70     /**
71      * @tc.steps: step1. create formRenderGroup and prepare want
72      * @tc.expected: step1. formRenderGroup is created successfully
73      */
74     std::weak_ptr<OHOS::AppExecFwk::EventHandler> emptyHandler;
75     auto formRendererGroup = FormRendererGroup::Create(nullptr, nullptr, emptyHandler);
76     EXPECT_TRUE(formRendererGroup);
77     bool isEmpty = formRendererGroup->IsFormRequestsEmpty();
78     EXPECT_TRUE(isEmpty);
79     OHOS::AAFwk::Want want;
80     want.SetParam(FORM_WIDTH_KEY, FORM_WIDTH);
81     want.SetParam(FORM_HEIGHT_KEY, FORM_HEIGHT);
82     want.SetParam(FORM_RENDERER_COMP_ID, FORM_COMPONENT_ID_1);
83     want.SetParam(FORM_RENDERER_ALLOW_UPDATE, true);
84     want.SetParam(FORM_RENDER_STATE, true);
85     OHOS::AppExecFwk::FormJsInfo formJsInfo;
86 
87     /**
88      * @tc.steps: step2. call AddForm
89      * @tc.expected: step2. formRenderer is created successfully and added to the formRendererGroup
90      */
91     // formRenderer->uiContent_ is null, so formRenderer->AddForm will not be called
92     formRendererGroup->AddForm(want, formJsInfo);
93     EXPECT_TRUE(formRendererGroup->formRenderer_ != nullptr);
94     isEmpty = formRendererGroup->IsFormRequestsEmpty();
95     formRendererGroup->UpdateConfiguration(nullptr);
96     EXPECT_FALSE(isEmpty);
97 
98 
99     /**
100      * @tc.steps: step3. call formRenderer's AddForm
101      * @tc.expected: step3. uiContent's relevant methods are called & formRenderer's property are set
102      */
103     auto formRenderer = formRendererGroup->formRenderer_;
104     EXPECT_TRUE(formRenderer);
105     formRenderer->uiContent_ = UIContent::Create(nullptr, nullptr);
106     EXPECT_TRUE(formRenderer->uiContent_);
107     EXPECT_CALL(*((MockUIContent*)(formRenderer->uiContent_.get())), SetFormWidth(FORM_WIDTH)).WillOnce(Return());
108     EXPECT_CALL(*((MockUIContent*)(formRenderer->uiContent_.get())), SetFormHeight(FORM_HEIGHT)).WillOnce(Return());
109     EXPECT_CALL(*((MockUIContent*)(formRenderer->uiContent_.get())), UpdateFormSharedImage(_)).WillOnce(Return());
110     EXPECT_CALL(*((MockUIContent*)(formRenderer->uiContent_.get())), UpdateFormData(_)).WillOnce(Return());
111 
112     EXPECT_CALL(*((MockUIContent *)(formRenderer->uiContent_.get())),
113         PreInitializeForm(An<OHOS::Rosen::Window *>(), "", _)).WillOnce(Return());
114     EXPECT_CALL(*((MockUIContent *)(formRenderer->uiContent_.get())), RunFormPage()).Times(Exactly(1));
115 
116     EXPECT_CALL(*((MockUIContent*)(formRenderer->uiContent_.get())), SetActionEventHandler(_)).WillOnce(Return());
117     EXPECT_CALL(*((MockUIContent*)(formRenderer->uiContent_.get())), SetErrorEventHandler(_)).WillOnce(Return());
118     EXPECT_CALL(*((MockUIContent*)(formRenderer->uiContent_.get())), GetFormRootNode()).Times(Exactly(2));
119     // call AddForm manually
120     formRenderer->AddForm(want, formJsInfo);
121     EXPECT_EQ(formRenderer->allowUpdate_, true);
122     EXPECT_EQ(formRenderer->width_, FORM_WIDTH);
123     EXPECT_EQ(formRenderer->height_, FORM_HEIGHT);
124 
125     /**
126      * @tc.steps: step4. add another formRenderer
127      * @tc.expected: step4. the formRenderer is created successfully and added to the formRendererGroup
128      */
129     OHOS::AAFwk::Want want2;
130     want2.SetParam(FORM_WIDTH_KEY, FORM_WIDTH);
131     want2.SetParam(FORM_HEIGHT_KEY, FORM_HEIGHT);
132     want2.SetParam(FORM_RENDERER_COMP_ID, FORM_COMPONENT_ID_2);
133     want2.SetParam(FORM_RENDERER_ALLOW_UPDATE, true);
134     want2.SetParam(FORM_RENDER_STATE, true);
135     formRendererGroup->AddForm(want2, formJsInfo);
136     auto formRenderer2 = formRendererGroup->formRenderer_;
137     formRenderer2->OnActionEvent("");
138     formRenderer2->OnError("", "");
139     formRenderer2->OnSurfaceChange(0.0f, 0.0f);
140 
141     /**
142      * @tc.steps: step5. call formRenderer's UpdateForm
143      * @tc.expected: step5. uiContent's relevant methods are called
144      */
145     EXPECT_CALL(*((MockUIContent*)(formRenderer->uiContent_.get())), UpdateFormSharedImage(_)).WillOnce(Return());
146     EXPECT_CALL(*((MockUIContent*)(formRenderer->uiContent_.get())), UpdateFormData(_)).WillOnce(Return());
147     formRendererGroup->UpdateForm(formJsInfo);
148 
149     /**
150      * @tc.steps: step6. call formRenderer's ReloadForm
151      * @tc.expected: step6. uiContent's relevant methods are called
152      */
153     EXPECT_CALL(*((MockUIContent*)(formRenderer->uiContent_.get())), ReloadForm(_)).WillOnce(Return());
154     formRendererGroup->ReloadForm(formJsInfo);
155 
156     /**
157      * @tc.steps: step7. delete formRenderer whose compId not exists
158      * @tc.expected: step7. delete fail
159      */
160     formRendererGroup->DeleteForm(FORM_COMPONENT_ID_3);
161 
162     /**
163      * @tc.steps: step8. delete formRenderer whose compId exists
164      * @tc.expected: step8. delete successfully
165      */
166     EXPECT_CALL(*((MockUIContent*)(formRenderer->uiContent_.get())), Destroy()).WillOnce(Return());
167     // delete formRenderer that compId exists
168     formRendererGroup->DeleteForm(FORM_COMPONENT_ID_1);
169 
170     /**
171      * @tc.steps: step9. delete all formRenderers
172      * @tc.expected: step9. delete successfully
173      */
174     formRendererGroup->DeleteForm();
175 }
176 
177 /**
178  * @tc.name: FormRenderTest002
179  * @tc.desc: delegate & dispatcher is not null
180  * @tc.type: FUNC
181  */
182 HWTEST_F(FormRenderTest, FormRenderTest002, TestSize.Level1)
183 {
184     /**
185      * @tc.steps: step1. create formRenderGroup and add new formRenderer with delegate & dispatcher
186      * @tc.expected: step1. formRenderGroup is created successfully and the formRenderer is added to the
187      * formRendererGroup
188      */
189     auto eventRunner = OHOS::AppExecFwk::EventRunner::Create("formRenderTest002");
190     ASSERT_TRUE(eventRunner);
191     auto eventHandler = std::make_shared<OHOS::AppExecFwk::EventHandler>(eventRunner);
192     auto formRendererGroup = FormRendererGroup::Create(nullptr, nullptr, eventHandler);
193     EXPECT_TRUE(formRendererGroup);
194     OHOS::AAFwk::Want want;
195     want.SetParam(FORM_RENDERER_COMP_ID, FORM_COMPONENT_ID_1);
196     want.SetParam(FORM_RENDERER_ALLOW_UPDATE, false);
197     want.SetParam(FORM_RENDER_STATE, true);
198     sptr<FormRendererDelegateImpl> renderDelegate = new FormRendererDelegateImpl();
199     want.SetParam(FORM_RENDERER_PROCESS_ON_ADD_SURFACE, renderDelegate->AsObject());
200     OHOS::AppExecFwk::FormJsInfo formJsInfo;
201     formRendererGroup->AddForm(want, formJsInfo);
202     auto formRenderer = formRendererGroup->formRenderer_;;
203     EXPECT_TRUE(formRenderer);
204     formRenderer->uiContent_ = UIContent::Create(nullptr, nullptr);
205     EXPECT_TRUE(formRenderer->uiContent_);
206 
207     /**
208      * @tc.steps: step2. register callback for rendererDelegate
209      */
210     std::string onSurfaceCreateKey;
211     auto onSurfaceCreate = [&onSurfaceCreateKey](const std::shared_ptr<Rosen::RSSurfaceNode>& /* surfaceNode */,
212                                const OHOS::AppExecFwk::FormJsInfo& /* info */,
__anonbf2bd1f30202(const std::shared_ptr<Rosen::RSSurfaceNode>& , const OHOS::AppExecFwk::FormJsInfo& , const AAFwk::Want& ) 213                                const AAFwk::Want& /* want */) { onSurfaceCreateKey = CHECK_KEY; };
214     renderDelegate->SetSurfaceCreateEventHandler(std::move(onSurfaceCreate));
215 
216     std::string onActionEventKey;
__anonbf2bd1f30302(const std::string& ) 217     auto onAction = [&onActionEventKey](const std::string& /* action */) { onActionEventKey = CHECK_KEY; };
218     renderDelegate->SetActionEventHandler(std::move(onAction));
219 
220     std::string onErrorEventKey;
221     auto onError = [&onErrorEventKey](
__anonbf2bd1f30402( const std::string& , const std::string& ) 222                        const std::string& /* code */, const std::string& /* msg */) { onErrorEventKey = CHECK_KEY; };
223     renderDelegate->SetErrorEventHandler(std::move(onError));
224 
225     std::string onSurfaceChangeEventKey;
226     auto onSurfaceChange = [&onSurfaceChangeEventKey](float /* width */,
__anonbf2bd1f30502(float , float , float ) 227                         float /* height */, float /* borderWidth */) { onSurfaceChangeEventKey = CHECK_KEY; };
228     renderDelegate->SetSurfaceChangeEventHandler(std::move(onSurfaceChange));
229 
230     /**
231      * @tc.steps: step3. call formRenderer's AddForm
232      * @tc.expected: step3. onSurfaceCreate has been called
233      */
234     EXPECT_CALL(*((MockUIContent*)(formRenderer->uiContent_.get())), SetFormWidth(_)).WillOnce(Return());
235     EXPECT_CALL(*((MockUIContent*)(formRenderer->uiContent_.get())), SetFormHeight(_)).WillOnce(Return());
236     EXPECT_CALL(*((MockUIContent*)(formRenderer->uiContent_.get())), UpdateFormSharedImage(_)).WillOnce(Return());
237     EXPECT_CALL(*((MockUIContent*)(formRenderer->uiContent_.get())), UpdateFormData(_)).WillOnce(Return());
238 
239     EXPECT_CALL(*((MockUIContent *)(formRenderer->uiContent_.get())),
240         PreInitializeForm(An<OHOS::Rosen::Window *>(), "", _)).WillOnce(Return());
241     EXPECT_CALL(*((MockUIContent *)(formRenderer->uiContent_.get())), RunFormPage()).Times(Exactly(1));
242 
243     EXPECT_CALL(*((MockUIContent*)(formRenderer->uiContent_.get())), SetActionEventHandler(_)).WillOnce(Return());
244     EXPECT_CALL(*((MockUIContent*)(formRenderer->uiContent_.get())), SetErrorEventHandler(_)).WillOnce(Return());
245     std::string surfaceNodeName = "ArkTSCardNode";
246     struct Rosen::RSSurfaceNodeConfig surfaceNodeConfig = { .SurfaceNodeName = surfaceNodeName };
247     std::shared_ptr<Rosen::RSSurfaceNode> rsNode = OHOS::Rosen::RSSurfaceNode::Create(surfaceNodeConfig, true);
248     EXPECT_CALL(*((MockUIContent*)(formRenderer->uiContent_.get())), GetFormRootNode())
249         .WillOnce(Return(rsNode))
250         .WillOnce(Return(rsNode))
251         .WillOnce(Return(rsNode));
252     EXPECT_CALL(*((MockUIContent*)(formRenderer->uiContent_.get())), Foreground()).WillOnce(Return());
253     formRenderer->AddForm(want, formJsInfo);
254     EXPECT_EQ(onSurfaceCreateKey, CHECK_KEY);
255 
256     /**
257      * @tc.steps: step4. call formRenderer's OnActionEvent & OnErrorEvent
258      * @tc.expected: step4. onAction & onError have been called
259      */
260     formRenderer->OnActionEvent("");
261     EXPECT_EQ(onActionEventKey, CHECK_KEY);
262     formRenderer->OnError("", "");
263     EXPECT_EQ(onErrorEventKey, CHECK_KEY);
264 
265     /**
266      * @tc.steps: step5. Test surface change
267      * @tc.expected: step5. onSurfaceChange & uiContent.OnFormSurfaceChange has been called
268      */
269     auto formRendererDispatcher = formRenderer->formRendererDispatcherImpl_;
270     EXPECT_TRUE(formRendererDispatcher);
271     EXPECT_CALL(*((MockUIContent*)(formRenderer->uiContent_.get())), SetFormWidth(FORM_WIDTH_2)).WillOnce(Return());
272     EXPECT_CALL(*((MockUIContent*)(formRenderer->uiContent_.get())), SetFormHeight(FORM_HEIGHT_2)).WillOnce(Return());
273     EXPECT_CALL(*((MockUIContent*)(formRenderer->uiContent_.get())), OnFormSurfaceChange(FORM_WIDTH_2, FORM_HEIGHT_2,
274         _, _)).WillOnce(Return());
275     formRendererDispatcher->DispatchSurfaceChangeEvent(FORM_WIDTH_2, FORM_HEIGHT_2);
276     std::this_thread::sleep_for(std::chrono::seconds(1));
277     EXPECT_EQ(onSurfaceChangeEventKey, CHECK_KEY);
278     // formRenderer is null
279     formRendererDispatcher->formRenderer_.reset();
280     EXPECT_CALL(*((MockUIContent*)(formRenderer->uiContent_.get())), SetFormWidth(FORM_WIDTH_2)).WillOnce(Return());
281     EXPECT_CALL(*((MockUIContent*)(formRenderer->uiContent_.get())), SetFormHeight(FORM_HEIGHT_2)).WillOnce(Return());
282     EXPECT_CALL(*((MockUIContent*)(formRenderer->uiContent_.get())), OnFormSurfaceChange(FORM_WIDTH_2, FORM_HEIGHT_2,
283         _, _)).WillOnce(Return());
284     onSurfaceChangeEventKey = "";
285     formRendererDispatcher->DispatchSurfaceChangeEvent(FORM_WIDTH_2, FORM_HEIGHT_2);
286     std::this_thread::sleep_for(std::chrono::seconds(1));
287     EXPECT_NE(onSurfaceChangeEventKey, CHECK_KEY);
288 
289     /**
290      * @tc.steps: step6. Test pointer event
291      * @tc.expected: step4. uiContent.ProcessPointerEvent has been called
292      */
293     std::shared_ptr<OHOS::MMI::PointerEvent> event;
294     EXPECT_CALL(*((MockUIContent*)(formRenderer->uiContent_.get())), ProcessPointerEvent(event))
295         .WillOnce(Return(true));
296     SerializedGesture serializedGesture;
297     formRendererDispatcher->DispatchPointerEvent(event, serializedGesture);
298     std::this_thread::sleep_for(std::chrono::seconds(1));
299 }
300 
301 /**
302  * @tc.name: FormRenderTest003
303  * @tc.type: FUNC
304  * Function: OnActionEvent,SetActionEventHandler
305  **@tc.desc: 1. system running normally
306  *           2. test FormRendererDelegateImpl
307  */
308 HWTEST_F(FormRenderTest, FormRenderTest003, TestSize.Level1)
309 {
310     std::string action = "action";
__anonbf2bd1f30602(const std::string&) 311     auto fun = [](const std::string&) {};
312     sptr<FormRendererDelegateImpl> renderDelegate = new FormRendererDelegateImpl();
313     renderDelegate->SetActionEventHandler(nullptr);
314     EXPECT_EQ(renderDelegate->OnActionEvent(action), ERR_INVALID_DATA);
315     renderDelegate->SetActionEventHandler(fun);
316     EXPECT_EQ(renderDelegate->OnActionEvent(action), ERR_OK);
317 }
318 
319 /**
320  * @tc.name: FormRenderTest004
321  * @tc.type: FUNC
322  * Function: OnError,SetErrorEventHandler
323  **@tc.desc: 1. system running normally
324  *           2. test FormRendererDelegateImpl
325  */
326 HWTEST_F(FormRenderTest, FormRenderTest004, TestSize.Level1)
327 {
328     std::string code = "code";
329     std::string msg = "msg";
__anonbf2bd1f30702(const std::string&, const std::string&) 330     auto fun = [](const std::string&, const std::string&) {};
331     sptr<FormRendererDelegateImpl> renderDelegate = new FormRendererDelegateImpl();
332     renderDelegate->SetErrorEventHandler(nullptr);
333     EXPECT_EQ(renderDelegate->OnError(code, msg), ERR_INVALID_DATA);
334     renderDelegate->SetErrorEventHandler(fun);
335     EXPECT_EQ(renderDelegate->OnError(code, msg), ERR_OK);
336 }
337 
338 /**
339  * @tc.name: FormRenderTest005
340  * @tc.type: FUNC
341  * Function: OnSurfaceChange,SetSurfaceChangeEventHandler
342  **@tc.desc: 1. system running normally
343  *           2. test FormRendererDelegateImpl
344  */
345 HWTEST_F(FormRenderTest, FormRenderTest005, TestSize.Level1)
346 {
347     float width = 1.1;
348     float height = 2.2;
__anonbf2bd1f30802(float, float, float) 349     auto fun = [](float, float, float) {};
350     sptr<FormRendererDelegateImpl> renderDelegate = new FormRendererDelegateImpl();
351     renderDelegate->SetSurfaceChangeEventHandler(nullptr);
352     EXPECT_EQ(renderDelegate->OnSurfaceChange(width, height), ERR_INVALID_DATA);
353     renderDelegate->SetSurfaceChangeEventHandler(fun);
354     EXPECT_EQ(renderDelegate->OnSurfaceChange(width, height), ERR_OK);
355 }
356 
357 /**
358  * @tc.name: FormRenderTest006
359  * @tc.type: FUNC
360  * Function: OnSurfaceDetach,SetSurfaceDetachEventHandler
361  **@tc.desc: 1. system running normally
362  *           2. test FormRendererDelegateImpl
363  */
364 HWTEST_F(FormRenderTest, FormRenderTest006, TestSize.Level1)
365 {
366     uint64_t surfaceId = 1;
__anonbf2bd1f30902() 367     auto fun = []() {};
368     sptr<FormRendererDelegateImpl> renderDelegate = new FormRendererDelegateImpl();
369     renderDelegate->SetSurfaceDetachEventHandler(nullptr);
370     EXPECT_EQ(renderDelegate->OnSurfaceDetach(surfaceId), ERR_INVALID_DATA);
371     renderDelegate->SetSurfaceDetachEventHandler(fun);
372     EXPECT_EQ(renderDelegate->OnSurfaceDetach(surfaceId), ERR_OK);
373 }
374 
375 /**
376  * @tc.name: FormRenderTest007
377  * @tc.type: FUNC
378  * Function: OnFormLinkInfoUpdate,SetFormLinkInfoUpdateHandler
379  **@tc.desc: 1. system running normally
380  *           2. test FormRendererDelegateImpl
381  */
382 HWTEST_F(FormRenderTest, FormRenderTest007, TestSize.Level1)
383 {
384     std::vector<std::string> formLinkInfos;
__anonbf2bd1f30a02(const std::vector<std::string>&) 385     auto fun = [](const std::vector<std::string>&) {};
386     sptr<FormRendererDelegateImpl> renderDelegate = new FormRendererDelegateImpl();
387     renderDelegate->SetFormLinkInfoUpdateHandler(nullptr);
388     EXPECT_EQ(renderDelegate->OnFormLinkInfoUpdate(formLinkInfos), ERR_INVALID_DATA);
389     renderDelegate->SetFormLinkInfoUpdateHandler(fun);
390     EXPECT_EQ(renderDelegate->OnFormLinkInfoUpdate(formLinkInfos), ERR_OK);
391 }
392 
393 /**
394  * @tc.name: FormRenderTest008
395  * @tc.type: FUNC
396  * Function: OnGetRectRelativeToWindow,SetGetRectRelativeToWindowHandler
397  **@tc.desc: 1. system running normally
398  *           2. test FormRendererDelegateImpl
399  */
400 HWTEST_F(FormRenderTest, FormRenderTest008, TestSize.Level1)
401 {
402     int32_t top = 50;
403     int32_t left = 50;
__anonbf2bd1f30b02(int32_t&, int32_t&) 404     auto fun = [](int32_t&, int32_t&) {};
405     sptr<FormRendererDelegateImpl> renderDelegate = new FormRendererDelegateImpl();
406     renderDelegate->SetGetRectRelativeToWindowHandler(nullptr);
407     EXPECT_EQ(renderDelegate->OnGetRectRelativeToWindow(top, left), ERR_INVALID_DATA);
408     renderDelegate->SetGetRectRelativeToWindowHandler(fun);
409     EXPECT_EQ(renderDelegate->OnGetRectRelativeToWindow(top, left), ERR_OK);
410 }
411 
412 /**
413  * @tc.name: FormRenderTest010
414  * @tc.desc: test RunFormPage
415  * @tc.type: FUNC
416  */
417 HWTEST_F(FormRenderTest, FormRenderTest010, TestSize.Level1)
418 {
419     auto eventRunner = OHOS::AppExecFwk::EventRunner::Create("formRenderTest010");
420     ASSERT_TRUE(eventRunner);
421     auto eventHandler = std::make_shared<OHOS::AppExecFwk::EventHandler>(eventRunner);
422     auto formRendererGroup = FormRendererGroup::Create(nullptr, nullptr, eventHandler);
423     EXPECT_TRUE(formRendererGroup);
424     OHOS::AAFwk::Want want;
425     want.SetParam(FORM_RENDERER_COMP_ID, FORM_COMPONENT_ID_1);
426     want.SetParam(FORM_RENDERER_ALLOW_UPDATE, false);
427     want.SetParam(FORM_RENDER_STATE, true);
428     sptr<FormRendererDelegateImpl> renderDelegate = new FormRendererDelegateImpl();
429     want.SetParam(FORM_RENDERER_PROCESS_ON_ADD_SURFACE, renderDelegate->AsObject());
430     OHOS::AppExecFwk::FormJsInfo formJsInfo;
431     formRendererGroup->AddForm(want, formJsInfo);
432     auto formRenderer = formRendererGroup->formRenderer_;;
433     EXPECT_TRUE(formRenderer);
434     formRenderer->RunFormPage(want, formJsInfo);
435     formRenderer->uiContent_ = UIContent::Create(nullptr, nullptr);
436     EXPECT_TRUE(formRenderer->uiContent_);
437     formRenderer->RunFormPage(want, formJsInfo);
438     want.SetParam(FORM_STATUS_DATA, true);
439     formRenderer->RunFormPage(want, formJsInfo);
440 }
441 
442 /**
443  * @tc.name: FormRenderTest011
444  * @tc.desc: test OnFormLinkInfoUpdate
445  * @tc.type: FUNC
446  */
447 HWTEST_F(FormRenderTest, FormRenderTest011, TestSize.Level1)
448 {
449     auto eventRunner = OHOS::AppExecFwk::EventRunner::Create("formRenderTest011");
450     ASSERT_TRUE(eventRunner);
451     auto eventHandler = std::make_shared<OHOS::AppExecFwk::EventHandler>(eventRunner);
452     auto formRendererGroup = FormRendererGroup::Create(nullptr, nullptr, eventHandler);
453     EXPECT_TRUE(formRendererGroup);
454     OHOS::AAFwk::Want want;
455     want.SetParam(FORM_RENDERER_COMP_ID, FORM_COMPONENT_ID_1);
456     want.SetParam(FORM_RENDERER_ALLOW_UPDATE, false);
457     want.SetParam(FORM_RENDER_STATE, true);
458     sptr<FormRendererDelegateImpl> renderDelegate = new FormRendererDelegateImpl();
459     want.SetParam(FORM_RENDERER_PROCESS_ON_ADD_SURFACE, renderDelegate->AsObject());
460     OHOS::AppExecFwk::FormJsInfo formJsInfo;
461     formRendererGroup->AddForm(want, formJsInfo);
462     auto formRenderer = formRendererGroup->formRenderer_;
463     EXPECT_TRUE(formRenderer);
464     formRenderer->uiContent_ = UIContent::Create(nullptr, nullptr);
465     EXPECT_TRUE(formRenderer->uiContent_);
466     std::vector<std::string> cachedInfos = formRenderer->cachedInfos_;
467     formRenderer->OnFormLinkInfoUpdate(cachedInfos);
468     formRenderer->formRendererDelegate_ = renderDelegate;
469     EXPECT_TRUE(formRenderer->formRendererDelegate_);
470     formRenderer->OnFormLinkInfoUpdate(cachedInfos);
471 }
472 
473 /**
474  * @tc.name: FormRenderTest012
475  * @tc.desc: test ResetRenderDelegate
476  * @tc.type: FUNC
477  */
478 HWTEST_F(FormRenderTest, FormRenderTest012, TestSize.Level1)
479 {
480     auto eventRunner = OHOS::AppExecFwk::EventRunner::Create("formRenderTest012");
481     ASSERT_TRUE(eventRunner);
482     auto eventHandler = std::make_shared<OHOS::AppExecFwk::EventHandler>(eventRunner);
483     auto formRendererGroup = FormRendererGroup::Create(nullptr, nullptr, eventHandler);
484     EXPECT_TRUE(formRendererGroup);
485     OHOS::AAFwk::Want want;
486     want.SetParam(FORM_RENDERER_COMP_ID, FORM_COMPONENT_ID_1);
487     want.SetParam(FORM_RENDERER_ALLOW_UPDATE, false);
488     want.SetParam(FORM_RENDER_STATE, true);
489     sptr<FormRendererDelegateImpl> renderDelegate = new FormRendererDelegateImpl();
490     want.SetParam(FORM_RENDERER_PROCESS_ON_ADD_SURFACE, renderDelegate->AsObject());
491     OHOS::AppExecFwk::FormJsInfo formJsInfo;
492     formRendererGroup->AddForm(want, formJsInfo);
493     auto formRenderer = formRendererGroup->formRenderer_;
494     EXPECT_TRUE(formRenderer);
495     formRenderer->uiContent_ = UIContent::Create(nullptr, nullptr);
496     EXPECT_TRUE(formRenderer->uiContent_);
497     formRenderer->ResetRenderDelegate();
498 }
499 
500 /**
501  * @tc.name: FormRenderTest013
502  * @tc.desc: test UpdateConfiguration
503  * @tc.type: FUNC
504  */
505 HWTEST_F(FormRenderTest, FormRenderTest013, TestSize.Level1)
506 {
507     auto eventRunner = OHOS::AppExecFwk::EventRunner::Create("formRenderTest013");
508     ASSERT_TRUE(eventRunner);
509     auto eventHandler = std::make_shared<OHOS::AppExecFwk::EventHandler>(eventRunner);
510     auto formRendererGroup = FormRendererGroup::Create(nullptr, nullptr, eventHandler);
511     EXPECT_TRUE(formRendererGroup);
512     OHOS::AAFwk::Want want;
513     want.SetParam(FORM_RENDERER_COMP_ID, FORM_COMPONENT_ID_1);
514     want.SetParam(FORM_RENDERER_ALLOW_UPDATE, false);
515     want.SetParam(FORM_RENDER_STATE, true);
516     sptr<FormRendererDelegateImpl> renderDelegate = new FormRendererDelegateImpl();
517     want.SetParam(FORM_RENDERER_PROCESS_ON_ADD_SURFACE, renderDelegate->AsObject());
518     OHOS::AppExecFwk::FormJsInfo formJsInfo;
519     formRendererGroup->AddForm(want, formJsInfo);
520     auto formRenderer = formRendererGroup->formRenderer_;
521     EXPECT_TRUE(formRenderer);
522     formRenderer->uiContent_ = UIContent::Create(nullptr, nullptr);
523     EXPECT_TRUE(formRenderer->uiContent_);
524     formRenderer->UpdateConfiguration(nullptr);
525 }
526 
527 /**
528  * @tc.name: FormRenderTest014
529  * @tc.desc: test OnRemoteDied
530  * @tc.type: FUNC
531  */
532 HWTEST_F(FormRenderTest, FormRenderTest014, TestSize.Level1)
533 {
534     auto eventRunner = OHOS::AppExecFwk::EventRunner::Create("formRenderTest014");
535     ASSERT_TRUE(eventRunner);
536     auto eventHandler = std::make_shared<OHOS::AppExecFwk::EventHandler>(eventRunner);
537     auto formRendererGroup = FormRendererGroup::Create(nullptr, nullptr, eventHandler);
538     EXPECT_TRUE(formRendererGroup);
539     OHOS::AAFwk::Want want;
540     want.SetParam(FORM_RENDERER_COMP_ID, FORM_COMPONENT_ID_1);
541     want.SetParam(FORM_RENDERER_ALLOW_UPDATE, false);
542     want.SetParam(FORM_RENDER_STATE, true);
543     sptr<FormRendererDelegateImpl> renderDelegate = new FormRendererDelegateImpl();
544     want.SetParam(FORM_RENDERER_PROCESS_ON_ADD_SURFACE, renderDelegate->AsObject());
545     OHOS::AppExecFwk::FormJsInfo formJsInfo;
546     formRendererGroup->AddForm(want, formJsInfo);
547     auto formRenderer = formRendererGroup->formRenderer_;
548     EXPECT_TRUE(formRenderer);
549     formRenderer->uiContent_ = UIContent::Create(nullptr, nullptr);
550     EXPECT_TRUE(formRenderer->uiContent_);
__anonbf2bd1f30c02()551     FormRenderDelegateRecipient::RemoteDiedHandler handler = [](){};
552     auto formRenderDelegateRecipient = new FormRenderDelegateRecipient(handler);
553     formRenderDelegateRecipient->OnRemoteDied(nullptr);
554     formRenderDelegateRecipient->OnRemoteDied(renderDelegate->AsObject());
555 }
556 
557 /**
558  * @tc.name: FormRenderTest015
559  * @tc.desc: test GetRectRelativeToWindow
560  * @tc.type: FUNC
561  */
562 HWTEST_F(FormRenderTest, FormRenderTest015, TestSize.Level1)
563 {
564     auto eventRunner = OHOS::AppExecFwk::EventRunner::Create("formRenderTest015");
565     ASSERT_TRUE(eventRunner);
566     auto eventHandler = std::make_shared<OHOS::AppExecFwk::EventHandler>(eventRunner);
567     auto formRendererGroup = FormRendererGroup::Create(nullptr, nullptr, eventHandler);
568     EXPECT_TRUE(formRendererGroup);
569     OHOS::AAFwk::Want want;
570     want.SetParam(FORM_RENDERER_COMP_ID, FORM_COMPONENT_ID_1);
571     want.SetParam(FORM_RENDERER_ALLOW_UPDATE, false);
572     want.SetParam(FORM_RENDER_STATE, true);
573     sptr<FormRendererDelegateImpl> renderDelegate = new FormRendererDelegateImpl();
574     want.SetParam(FORM_RENDERER_PROCESS_ON_ADD_SURFACE, renderDelegate->AsObject());
575     OHOS::AppExecFwk::FormJsInfo formJsInfo;
576     formRendererGroup->AddForm(want, formJsInfo);
577     auto formRenderer = formRendererGroup->formRenderer_;
578     EXPECT_TRUE(formRenderer);
579     formRenderer->uiContent_ = UIContent::Create(nullptr, nullptr);
580     EXPECT_TRUE(formRenderer->uiContent_);
581     int32_t top = 0;
582     int32_t left = 0;
583     formRenderer->GetRectRelativeToWindow(top, left);
584     formRenderer->formRendererDelegate_ = renderDelegate;
585     EXPECT_TRUE(formRenderer->formRendererDelegate_);
586     formRenderer->GetRectRelativeToWindow(top, left);
587 }
588 
589 /**
590  * @tc.name: FormRenderTest016
591  * @tc.desc: test RecycleForm
592  * @tc.type: FUNC
593  */
594 HWTEST_F(FormRenderTest, FormRenderTest016, TestSize.Level1)
595 {
596     auto eventRunner = OHOS::AppExecFwk::EventRunner::Create("formRenderTest016");
597     ASSERT_TRUE(eventRunner);
598     auto eventHandler = std::make_shared<OHOS::AppExecFwk::EventHandler>(eventRunner);
599     auto formRendererGroup = FormRendererGroup::Create(nullptr, nullptr, eventHandler);
600     EXPECT_TRUE(formRendererGroup);
601     OHOS::AAFwk::Want want;
602     want.SetParam(FORM_RENDERER_COMP_ID, FORM_COMPONENT_ID_1);
603     want.SetParam(FORM_RENDERER_ALLOW_UPDATE, false);
604     want.SetParam(FORM_RENDER_STATE, true);
605     sptr<FormRendererDelegateImpl> renderDelegate = new FormRendererDelegateImpl();
606     want.SetParam(FORM_RENDERER_PROCESS_ON_ADD_SURFACE, renderDelegate->AsObject());
607     OHOS::AppExecFwk::FormJsInfo formJsInfo;
608     formRendererGroup->AddForm(want, formJsInfo);
609     auto formRenderer = formRendererGroup->formRenderer_;
610     EXPECT_TRUE(formRenderer);
611     std::string statusData;
612     formRenderer->RecycleForm(statusData);
613     formRenderer->uiContent_ = UIContent::Create(nullptr, nullptr);
614     EXPECT_TRUE(formRenderer->uiContent_);
615     formRenderer->RecycleForm(statusData);
616 }
617 
618 /**
619  * @tc.name: FormRenderTest017
620  * @tc.desc: test RecoverForm
621  * @tc.type: FUNC
622  */
623 HWTEST_F(FormRenderTest, FormRenderTest017, TestSize.Level1)
624 {
625     auto eventRunner = OHOS::AppExecFwk::EventRunner::Create("formRenderTest017");
626     ASSERT_TRUE(eventRunner);
627     auto eventHandler = std::make_shared<OHOS::AppExecFwk::EventHandler>(eventRunner);
628     auto formRendererGroup = FormRendererGroup::Create(nullptr, nullptr, eventHandler);
629     EXPECT_TRUE(formRendererGroup);
630     OHOS::AAFwk::Want want;
631     want.SetParam(FORM_RENDERER_COMP_ID, FORM_COMPONENT_ID_1);
632     want.SetParam(FORM_RENDERER_ALLOW_UPDATE, false);
633     want.SetParam(FORM_RENDER_STATE, true);
634     sptr<FormRendererDelegateImpl> renderDelegate = new FormRendererDelegateImpl();
635     want.SetParam(FORM_RENDERER_PROCESS_ON_ADD_SURFACE, renderDelegate->AsObject());
636     OHOS::AppExecFwk::FormJsInfo formJsInfo;
637     formRendererGroup->AddForm(want, formJsInfo);
638     auto formRenderer = formRendererGroup->formRenderer_;
639     EXPECT_TRUE(formRenderer);
640     const std::string statusData = "";
641     formRenderer->RecoverForm(statusData);
642     formRenderer->uiContent_ = UIContent::Create(nullptr, nullptr);
643     EXPECT_TRUE(formRenderer->uiContent_);
644     formRenderer->RecoverForm(statusData);
645 }
646 
647 /**
648  * @tc.name: FormRenderTest018
649  * @tc.desc: test PreInitAddForm
650  * @tc.type: FUNC
651  */
652 HWTEST_F(FormRenderTest, FormRenderTest018, TestSize.Level1)
653 {
654     auto eventRunner = OHOS::AppExecFwk::EventRunner::Create("formRenderTest018");
655     ASSERT_TRUE(eventRunner);
656     auto eventHandler = std::make_shared<OHOS::AppExecFwk::EventHandler>(eventRunner);
657     auto formRendererGroup = FormRendererGroup::Create(nullptr, nullptr, eventHandler);
658     EXPECT_TRUE(formRendererGroup);
659     OHOS::AAFwk::Want want;
660     want.SetParam(FORM_RENDERER_COMP_ID, FORM_COMPONENT_ID_1);
661     want.SetParam(FORM_RENDERER_ALLOW_UPDATE, false);
662     want.SetParam(FORM_RENDER_STATE, true);
663     sptr<FormRendererDelegateImpl> renderDelegate = new FormRendererDelegateImpl();
664     want.SetParam(FORM_RENDERER_PROCESS_ON_ADD_SURFACE, renderDelegate->AsObject());
665     OHOS::AppExecFwk::FormJsInfo formJsInfo;
666     formRendererGroup->AddForm(want, formJsInfo);
667     auto formRenderer = formRendererGroup->formRenderer_;
668     EXPECT_TRUE(formRenderer);
669     formRenderer->PreInitAddForm(want, formJsInfo);
670     std::string url = "";
671     formRenderer->ReloadForm(url);
672     formRenderer->UpdateForm(formJsInfo);
673     formRenderer->uiContent_ = UIContent::Create(nullptr, nullptr);
674     EXPECT_TRUE(formRenderer->uiContent_);
675     formRenderer->PreInitAddForm(want, formJsInfo);
676 }
677 
678 /**
679  * @tc.name: FormRenderTest019
680  * @tc.desc: test AttachForm
681  * @tc.type: FUNC
682  */
683 HWTEST_F(FormRenderTest, FormRenderTest019, TestSize.Level1)
684 {
685     auto eventRunner = OHOS::AppExecFwk::EventRunner::Create("formRenderTest019");
686     ASSERT_TRUE(eventRunner);
687     auto eventHandler = std::make_shared<OHOS::AppExecFwk::EventHandler>(eventRunner);
688     auto formRendererGroup = FormRendererGroup::Create(nullptr, nullptr, eventHandler);
689     EXPECT_TRUE(formRendererGroup);
690     OHOS::AAFwk::Want want;
691     want.SetParam(FORM_RENDERER_COMP_ID, FORM_COMPONENT_ID_1);
692     want.SetParam(FORM_RENDERER_ALLOW_UPDATE, false);
693     want.SetParam(FORM_RENDER_STATE, true);
694     sptr<FormRendererDelegateImpl> renderDelegate = new FormRendererDelegateImpl();
695     want.SetParam(FORM_RENDERER_PROCESS_ON_ADD_SURFACE, renderDelegate->AsObject());
696     OHOS::AppExecFwk::FormJsInfo formJsInfo;
697     formRendererGroup->AddForm(want, formJsInfo);
698     auto formRenderer = formRendererGroup->formRenderer_;
699     EXPECT_TRUE(formRenderer);
700     formRenderer->AttachForm(want, formJsInfo);
701     formRenderer->uiContent_ = UIContent::Create(nullptr, nullptr);
702     EXPECT_TRUE(formRenderer->uiContent_);
703     formRenderer->AttachForm(want, formJsInfo);
704 }
705 
706 /**
707  * @tc.name: FormRenderTest020
708  * @tc.desc: test AttachUIContent
709  * @tc.type: FUNC
710  */
711 HWTEST_F(FormRenderTest, FormRenderTest020, TestSize.Level1)
712 {
713     auto eventRunner = OHOS::AppExecFwk::EventRunner::Create("formRenderTest020");
714     ASSERT_TRUE(eventRunner);
715     auto eventHandler = std::make_shared<OHOS::AppExecFwk::EventHandler>(eventRunner);
716     auto formRendererGroup = FormRendererGroup::Create(nullptr, nullptr, eventHandler);
717     EXPECT_TRUE(formRendererGroup);
718     OHOS::AAFwk::Want want;
719     want.SetParam(FORM_RENDERER_COMP_ID, FORM_COMPONENT_ID_1);
720     want.SetParam(FORM_RENDERER_ALLOW_UPDATE, false);
721     want.SetParam(FORM_RENDER_STATE, true);
722     sptr<FormRendererDelegateImpl> renderDelegate = new FormRendererDelegateImpl();
723     want.SetParam(FORM_RENDERER_PROCESS_ON_ADD_SURFACE, renderDelegate->AsObject());
724     OHOS::AppExecFwk::FormJsInfo formJsInfo;
725     formRendererGroup->AddForm(want, formJsInfo);
726     auto formRenderer = formRendererGroup->formRenderer_;
727     EXPECT_TRUE(formRenderer);
728     formRenderer->uiContent_ = UIContent::Create(nullptr, nullptr);
729     EXPECT_TRUE(formRenderer->uiContent_);
730     std::string surfaceNodeName = "ArkTSCardNode";
731     struct Rosen::RSSurfaceNodeConfig surfaceNodeConfig = { .SurfaceNodeName = surfaceNodeName };
732     std::shared_ptr<Rosen::RSSurfaceNode> rsNode = OHOS::Rosen::RSSurfaceNode::Create(surfaceNodeConfig, true);
733     EXPECT_CALL(*((MockUIContent*)(formRenderer->uiContent_.get())), GetFormRootNode()).WillOnce(Return(rsNode));
734     formRenderer->AttachUIContent(want, formJsInfo);
735 }
736 
737 /**
738  * @tc.name: FormRenderTest021
739  * @tc.desc: test OnSurfaceReuse
740  * @tc.type: FUNC
741  */
742 HWTEST_F(FormRenderTest, FormRenderTest021, TestSize.Level1)
743 {
744     auto eventRunner = OHOS::AppExecFwk::EventRunner::Create("formRenderTest021");
745     ASSERT_TRUE(eventRunner);
746     auto eventHandler = std::make_shared<OHOS::AppExecFwk::EventHandler>(eventRunner);
747     auto formRendererGroup = FormRendererGroup::Create(nullptr, nullptr, eventHandler);
748     EXPECT_TRUE(formRendererGroup);
749     OHOS::AAFwk::Want want;
750     want.SetParam(FORM_RENDERER_COMP_ID, FORM_COMPONENT_ID_1);
751     want.SetParam(FORM_RENDERER_ALLOW_UPDATE, false);
752     want.SetParam(FORM_RENDER_STATE, true);
753     sptr<FormRendererDelegateImpl> renderDelegate = new FormRendererDelegateImpl();
754     want.SetParam(FORM_RENDERER_PROCESS_ON_ADD_SURFACE, renderDelegate->AsObject());
755     OHOS::AppExecFwk::FormJsInfo formJsInfo;
756     formRendererGroup->AddForm(want, formJsInfo);
757     auto formRenderer = formRendererGroup->formRenderer_;
758     EXPECT_TRUE(formRenderer);
759     formRenderer->uiContent_ = UIContent::Create(nullptr, nullptr);
760     EXPECT_TRUE(formRenderer->uiContent_);
761     formRenderer->formRendererDispatcherImpl_ =
762         new FormRendererDispatcherImpl(formRenderer->uiContent_, nullptr, eventHandler);
763     formRenderer->formRendererDelegate_ = renderDelegate;
764     formRenderer->OnSurfaceReuse(formJsInfo);
765     std::string surfaceNodeName = "ArkTSCardNode";
766     struct Rosen::RSSurfaceNodeConfig surfaceNodeConfig = { .SurfaceNodeName = surfaceNodeName };
767     std::shared_ptr<Rosen::RSSurfaceNode> rsNode = OHOS::Rosen::RSSurfaceNode::Create(surfaceNodeConfig, true);
768     EXPECT_CALL(*((MockUIContent*)(formRenderer->uiContent_.get())), GetFormRootNode()).Times(Exactly(2))
769         .WillOnce(Return(rsNode));
770     formRenderer->OnSurfaceReuse(formJsInfo);
771 }
772 
773 /**
774  * @tc.name: FormRenderTest022
775  * @tc.desc: test OnSurfaceDetach
776  * @tc.type: FUNC
777  */
778 HWTEST_F(FormRenderTest, FormRenderTest022, TestSize.Level1)
779 {
780     auto eventRunner = OHOS::AppExecFwk::EventRunner::Create("formRenderTest022");
781     ASSERT_TRUE(eventRunner);
782     auto eventHandler = std::make_shared<OHOS::AppExecFwk::EventHandler>(eventRunner);
783     auto formRendererGroup = FormRendererGroup::Create(nullptr, nullptr, eventHandler);
784     EXPECT_TRUE(formRendererGroup);
785     OHOS::AAFwk::Want want;
786     want.SetParam(FORM_RENDERER_COMP_ID, FORM_COMPONENT_ID_1);
787     want.SetParam(FORM_RENDERER_ALLOW_UPDATE, false);
788     want.SetParam(FORM_RENDER_STATE, true);
789     sptr<FormRendererDelegateImpl> renderDelegate = new FormRendererDelegateImpl();
790     want.SetParam(FORM_RENDERER_PROCESS_ON_ADD_SURFACE, renderDelegate->AsObject());
791     OHOS::AppExecFwk::FormJsInfo formJsInfo;
792     formRendererGroup->AddForm(want, formJsInfo);
793     auto formRenderer = formRendererGroup->formRenderer_;
794     EXPECT_TRUE(formRenderer);
795     formRenderer->uiContent_ = UIContent::Create(nullptr, nullptr);
796     EXPECT_TRUE(formRenderer->uiContent_);
797     formRenderer->formRendererDelegate_ = renderDelegate;
798     formRenderer->OnSurfaceDetach();
799     std::string surfaceNodeName = "ArkTSCardNode";
800     struct Rosen::RSSurfaceNodeConfig surfaceNodeConfig = { .SurfaceNodeName = surfaceNodeName };
801     std::shared_ptr<Rosen::RSSurfaceNode> rsNode = OHOS::Rosen::RSSurfaceNode::Create(surfaceNodeConfig, true);
802     EXPECT_CALL(*((MockUIContent*)(formRenderer->uiContent_.get())), GetFormRootNode()).Times(Exactly(2)).
803         WillOnce(Return(rsNode));
804     formRenderer->OnSurfaceDetach();
805 }
806 
807 /**
808 * @tc.name: FormRenderTest023
809 * @tc.desc: test SetVisibleChange
810 * @tc.type: FUNC
811 */
812 HWTEST_F(FormRenderTest, FormRenderTest023, TestSize.Level1)
813 {
814     auto eventRunner = OHOS::AppExecFwk::EventRunner::Create("formRenderTest023");
815     ASSERT_TRUE(eventRunner);
816     auto eventHandler = std::make_shared<OHOS::AppExecFwk::EventHandler>(eventRunner);
817     auto formRendererGroup = FormRendererGroup::Create(nullptr, nullptr, eventHandler);
818     EXPECT_TRUE(formRendererGroup);
819     OHOS::AAFwk::Want want;
820     want.SetParam(FORM_RENDERER_COMP_ID, FORM_COMPONENT_ID_1);
821     want.SetParam(FORM_RENDERER_ALLOW_UPDATE, false);
822     want.SetParam(FORM_RENDER_STATE, true);
823     sptr<FormRendererDelegateImpl> renderDelegate = new FormRendererDelegateImpl();
824     want.SetParam(FORM_RENDERER_PROCESS_ON_ADD_SURFACE, renderDelegate->AsObject());
825     OHOS::AppExecFwk::FormJsInfo formJsInfo;
826     formRendererGroup->AddForm(want, formJsInfo);
827     auto formRenderer = formRendererGroup->formRenderer_;
828     EXPECT_TRUE(formRenderer);
829     formRenderer->SetVisibleChange(true);
830     formRenderer->uiContent_ = UIContent::Create(nullptr, nullptr);
831     EXPECT_TRUE(formRenderer->uiContent_);
832     formRenderer->SetVisibleChange(true);
833 }
834 
835 } // namespace OHOS::Ace
836