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  */
HWTEST_F(FormRenderTest, FormRenderTest001, TestSize.Level1)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  */
HWTEST_F(FormRenderTest, FormRenderTest002, TestSize.Level1)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 */,
213                                const AAFwk::Want& /* want */) { onSurfaceCreateKey = CHECK_KEY; };
214     renderDelegate->SetSurfaceCreateEventHandler(std::move(onSurfaceCreate));
215 
216     std::string onActionEventKey;
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](
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 */,
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     OHOS::Rosen::WindowSizeChangeReason type = static_cast<OHOS::Rosen::WindowSizeChangeReason>(0);
272     const std::shared_ptr<Rosen::RSTransaction>& rsTransaction = nullptr;
273     EXPECT_CALL(*((MockUIContent*)(formRenderer->uiContent_.get())), SetFormWidth(FORM_WIDTH_2)).WillOnce(Return());
274     EXPECT_CALL(*((MockUIContent*)(formRenderer->uiContent_.get())), SetFormHeight(FORM_HEIGHT_2)).WillOnce(Return());
275     EXPECT_CALL(*((MockUIContent*)(formRenderer->uiContent_.get())), OnFormSurfaceChange(FORM_WIDTH_2, FORM_HEIGHT_2,
276         type, rsTransaction)).WillOnce(Return());
277     formRendererDispatcher->DispatchSurfaceChangeEvent(FORM_WIDTH_2, FORM_HEIGHT_2);
278     std::this_thread::sleep_for(std::chrono::seconds(1));
279     EXPECT_EQ(onSurfaceChangeEventKey, CHECK_KEY);
280     // formRenderer is null
281     formRendererDispatcher->formRenderer_.reset();
282     EXPECT_CALL(*((MockUIContent*)(formRenderer->uiContent_.get())), SetFormWidth(FORM_WIDTH_2)).WillOnce(Return());
283     EXPECT_CALL(*((MockUIContent*)(formRenderer->uiContent_.get())), SetFormHeight(FORM_HEIGHT_2)).WillOnce(Return());
284     EXPECT_CALL(*((MockUIContent*)(formRenderer->uiContent_.get())), OnFormSurfaceChange(FORM_WIDTH_2, FORM_HEIGHT_2,
285         type, rsTransaction)).WillOnce(Return());
286     onSurfaceChangeEventKey = "";
287     formRendererDispatcher->DispatchSurfaceChangeEvent(FORM_WIDTH_2, FORM_HEIGHT_2);
288     std::this_thread::sleep_for(std::chrono::seconds(1));
289     EXPECT_NE(onSurfaceChangeEventKey, CHECK_KEY);
290 
291     /**
292      * @tc.steps: step6. Test pointer event
293      * @tc.expected: step4. uiContent.ProcessPointerEvent has been called
294      */
295     std::shared_ptr<OHOS::MMI::PointerEvent> event;
296     EXPECT_CALL(*((MockUIContent*)(formRenderer->uiContent_.get())), ProcessPointerEvent(event))
297         .WillOnce(Return(true));
298     SerializedGesture serializedGesture;
299     formRendererDispatcher->DispatchPointerEvent(event, serializedGesture);
300     std::this_thread::sleep_for(std::chrono::seconds(1));
301 }
302 
303 /**
304  * @tc.name: FormRenderTest003
305  * @tc.type: FUNC
306  * Function: OnActionEvent,SetActionEventHandler
307  **@tc.desc: 1. system running normally
308  *           2. test FormRendererDelegateImpl
309  */
HWTEST_F(FormRenderTest, FormRenderTest003, TestSize.Level1)310 HWTEST_F(FormRenderTest, FormRenderTest003, TestSize.Level1)
311 {
312     std::string action = "action";
313     auto fun = [](const std::string&) {};
314     sptr<FormRendererDelegateImpl> renderDelegate = new FormRendererDelegateImpl();
315     renderDelegate->SetActionEventHandler(nullptr);
316     EXPECT_EQ(renderDelegate->OnActionEvent(action), ERR_INVALID_DATA);
317     renderDelegate->SetActionEventHandler(fun);
318     EXPECT_EQ(renderDelegate->OnActionEvent(action), ERR_OK);
319 }
320 
321 /**
322  * @tc.name: FormRenderTest004
323  * @tc.type: FUNC
324  * Function: OnError,SetErrorEventHandler
325  **@tc.desc: 1. system running normally
326  *           2. test FormRendererDelegateImpl
327  */
HWTEST_F(FormRenderTest, FormRenderTest004, TestSize.Level1)328 HWTEST_F(FormRenderTest, FormRenderTest004, TestSize.Level1)
329 {
330     std::string code = "code";
331     std::string msg = "msg";
332     auto fun = [](const std::string&, const std::string&) {};
333     sptr<FormRendererDelegateImpl> renderDelegate = new FormRendererDelegateImpl();
334     renderDelegate->SetErrorEventHandler(nullptr);
335     EXPECT_EQ(renderDelegate->OnError(code, msg), ERR_INVALID_DATA);
336     renderDelegate->SetErrorEventHandler(fun);
337     EXPECT_EQ(renderDelegate->OnError(code, msg), ERR_OK);
338 }
339 
340 /**
341  * @tc.name: FormRenderTest005
342  * @tc.type: FUNC
343  * Function: OnSurfaceChange,SetSurfaceChangeEventHandler
344  **@tc.desc: 1. system running normally
345  *           2. test FormRendererDelegateImpl
346  */
HWTEST_F(FormRenderTest, FormRenderTest005, TestSize.Level1)347 HWTEST_F(FormRenderTest, FormRenderTest005, TestSize.Level1)
348 {
349     float width = 1.1;
350     float height = 2.2;
351     auto fun = [](float, float, float) {};
352     sptr<FormRendererDelegateImpl> renderDelegate = new FormRendererDelegateImpl();
353     renderDelegate->SetSurfaceChangeEventHandler(nullptr);
354     EXPECT_EQ(renderDelegate->OnSurfaceChange(width, height), ERR_INVALID_DATA);
355     renderDelegate->SetSurfaceChangeEventHandler(fun);
356     EXPECT_EQ(renderDelegate->OnSurfaceChange(width, height), ERR_OK);
357 }
358 
359 /**
360  * @tc.name: FormRenderTest006
361  * @tc.type: FUNC
362  * Function: OnSurfaceDetach,SetSurfaceDetachEventHandler
363  **@tc.desc: 1. system running normally
364  *           2. test FormRendererDelegateImpl
365  */
HWTEST_F(FormRenderTest, FormRenderTest006, TestSize.Level1)366 HWTEST_F(FormRenderTest, FormRenderTest006, TestSize.Level1)
367 {
368     uint64_t surfaceId = 1;
369     auto fun = []() {};
370     sptr<FormRendererDelegateImpl> renderDelegate = new FormRendererDelegateImpl();
371     renderDelegate->SetSurfaceDetachEventHandler(nullptr);
372     EXPECT_EQ(renderDelegate->OnSurfaceDetach(surfaceId), ERR_INVALID_DATA);
373     renderDelegate->SetSurfaceDetachEventHandler(fun);
374     EXPECT_EQ(renderDelegate->OnSurfaceDetach(surfaceId), ERR_OK);
375 }
376 
377 /**
378  * @tc.name: FormRenderTest007
379  * @tc.type: FUNC
380  * Function: OnFormLinkInfoUpdate,SetFormLinkInfoUpdateHandler
381  **@tc.desc: 1. system running normally
382  *           2. test FormRendererDelegateImpl
383  */
HWTEST_F(FormRenderTest, FormRenderTest007, TestSize.Level1)384 HWTEST_F(FormRenderTest, FormRenderTest007, TestSize.Level1)
385 {
386     std::vector<std::string> formLinkInfos;
387     auto fun = [](const std::vector<std::string>&) {};
388     sptr<FormRendererDelegateImpl> renderDelegate = new FormRendererDelegateImpl();
389     renderDelegate->SetFormLinkInfoUpdateHandler(nullptr);
390     EXPECT_EQ(renderDelegate->OnFormLinkInfoUpdate(formLinkInfos), ERR_INVALID_DATA);
391     renderDelegate->SetFormLinkInfoUpdateHandler(fun);
392     EXPECT_EQ(renderDelegate->OnFormLinkInfoUpdate(formLinkInfos), ERR_OK);
393 }
394 
395 /**
396  * @tc.name: FormRenderTest008
397  * @tc.type: FUNC
398  * Function: OnGetRectRelativeToWindow,SetGetRectRelativeToWindowHandler
399  **@tc.desc: 1. system running normally
400  *           2. test FormRendererDelegateImpl
401  */
HWTEST_F(FormRenderTest, FormRenderTest008, TestSize.Level1)402 HWTEST_F(FormRenderTest, FormRenderTest008, TestSize.Level1)
403 {
404     int32_t top = 50;
405     int32_t left = 50;
406     auto fun = [](int32_t&, int32_t&) {};
407     sptr<FormRendererDelegateImpl> renderDelegate = new FormRendererDelegateImpl();
408     renderDelegate->SetGetRectRelativeToWindowHandler(nullptr);
409     EXPECT_EQ(renderDelegate->OnGetRectRelativeToWindow(top, left), ERR_INVALID_DATA);
410     renderDelegate->SetGetRectRelativeToWindowHandler(fun);
411     EXPECT_EQ(renderDelegate->OnGetRectRelativeToWindow(top, left), ERR_OK);
412 }
413 
414 /**
415  * @tc.name: FormRenderTest010
416  * @tc.desc: test RunFormPage
417  * @tc.type: FUNC
418  */
HWTEST_F(FormRenderTest, FormRenderTest010, TestSize.Level1)419 HWTEST_F(FormRenderTest, FormRenderTest010, TestSize.Level1)
420 {
421     auto eventRunner = OHOS::AppExecFwk::EventRunner::Create("formRenderTest010");
422     ASSERT_TRUE(eventRunner);
423     auto eventHandler = std::make_shared<OHOS::AppExecFwk::EventHandler>(eventRunner);
424     auto formRendererGroup = FormRendererGroup::Create(nullptr, nullptr, eventHandler);
425     EXPECT_TRUE(formRendererGroup);
426     OHOS::AAFwk::Want want;
427     want.SetParam(FORM_RENDERER_COMP_ID, FORM_COMPONENT_ID_1);
428     want.SetParam(FORM_RENDERER_ALLOW_UPDATE, false);
429     want.SetParam(FORM_RENDER_STATE, true);
430     sptr<FormRendererDelegateImpl> renderDelegate = new FormRendererDelegateImpl();
431     want.SetParam(FORM_RENDERER_PROCESS_ON_ADD_SURFACE, renderDelegate->AsObject());
432     OHOS::AppExecFwk::FormJsInfo formJsInfo;
433     formRendererGroup->AddForm(want, formJsInfo);
434     auto formRenderer = formRendererGroup->formRenderer_;;
435     EXPECT_TRUE(formRenderer);
436     formRenderer->RunFormPage(want, formJsInfo);
437     formRenderer->uiContent_ = UIContent::Create(nullptr, nullptr);
438     EXPECT_TRUE(formRenderer->uiContent_);
439     formRenderer->RunFormPage(want, formJsInfo);
440     want.SetParam(FORM_STATUS_DATA, true);
441     formRenderer->RunFormPage(want, formJsInfo);
442 }
443 
444 /**
445  * @tc.name: FormRenderTest011
446  * @tc.desc: test OnFormLinkInfoUpdate
447  * @tc.type: FUNC
448  */
HWTEST_F(FormRenderTest, FormRenderTest011, TestSize.Level1)449 HWTEST_F(FormRenderTest, FormRenderTest011, TestSize.Level1)
450 {
451     auto eventRunner = OHOS::AppExecFwk::EventRunner::Create("formRenderTest011");
452     ASSERT_TRUE(eventRunner);
453     auto eventHandler = std::make_shared<OHOS::AppExecFwk::EventHandler>(eventRunner);
454     auto formRendererGroup = FormRendererGroup::Create(nullptr, nullptr, eventHandler);
455     EXPECT_TRUE(formRendererGroup);
456     OHOS::AAFwk::Want want;
457     want.SetParam(FORM_RENDERER_COMP_ID, FORM_COMPONENT_ID_1);
458     want.SetParam(FORM_RENDERER_ALLOW_UPDATE, false);
459     want.SetParam(FORM_RENDER_STATE, true);
460     sptr<FormRendererDelegateImpl> renderDelegate = new FormRendererDelegateImpl();
461     want.SetParam(FORM_RENDERER_PROCESS_ON_ADD_SURFACE, renderDelegate->AsObject());
462     OHOS::AppExecFwk::FormJsInfo formJsInfo;
463     formRendererGroup->AddForm(want, formJsInfo);
464     auto formRenderer = formRendererGroup->formRenderer_;
465     EXPECT_TRUE(formRenderer);
466     formRenderer->uiContent_ = UIContent::Create(nullptr, nullptr);
467     EXPECT_TRUE(formRenderer->uiContent_);
468     std::vector<std::string> cachedInfos = formRenderer->cachedInfos_;
469     formRenderer->OnFormLinkInfoUpdate(cachedInfos);
470     formRenderer->formRendererDelegate_ = renderDelegate;
471     EXPECT_TRUE(formRenderer->formRendererDelegate_);
472     formRenderer->OnFormLinkInfoUpdate(cachedInfos);
473 }
474 
475 /**
476  * @tc.name: FormRenderTest012
477  * @tc.desc: test ResetRenderDelegate
478  * @tc.type: FUNC
479  */
HWTEST_F(FormRenderTest, FormRenderTest012, TestSize.Level1)480 HWTEST_F(FormRenderTest, FormRenderTest012, TestSize.Level1)
481 {
482     auto eventRunner = OHOS::AppExecFwk::EventRunner::Create("formRenderTest012");
483     ASSERT_TRUE(eventRunner);
484     auto eventHandler = std::make_shared<OHOS::AppExecFwk::EventHandler>(eventRunner);
485     auto formRendererGroup = FormRendererGroup::Create(nullptr, nullptr, eventHandler);
486     EXPECT_TRUE(formRendererGroup);
487     OHOS::AAFwk::Want want;
488     want.SetParam(FORM_RENDERER_COMP_ID, FORM_COMPONENT_ID_1);
489     want.SetParam(FORM_RENDERER_ALLOW_UPDATE, false);
490     want.SetParam(FORM_RENDER_STATE, true);
491     sptr<FormRendererDelegateImpl> renderDelegate = new FormRendererDelegateImpl();
492     want.SetParam(FORM_RENDERER_PROCESS_ON_ADD_SURFACE, renderDelegate->AsObject());
493     OHOS::AppExecFwk::FormJsInfo formJsInfo;
494     formRendererGroup->AddForm(want, formJsInfo);
495     auto formRenderer = formRendererGroup->formRenderer_;
496     EXPECT_TRUE(formRenderer);
497     formRenderer->uiContent_ = UIContent::Create(nullptr, nullptr);
498     EXPECT_TRUE(formRenderer->uiContent_);
499     formRenderer->ResetRenderDelegate();
500 }
501 
502 /**
503  * @tc.name: FormRenderTest013
504  * @tc.desc: test UpdateConfiguration
505  * @tc.type: FUNC
506  */
HWTEST_F(FormRenderTest, FormRenderTest013, TestSize.Level1)507 HWTEST_F(FormRenderTest, FormRenderTest013, TestSize.Level1)
508 {
509     auto eventRunner = OHOS::AppExecFwk::EventRunner::Create("formRenderTest013");
510     ASSERT_TRUE(eventRunner);
511     auto eventHandler = std::make_shared<OHOS::AppExecFwk::EventHandler>(eventRunner);
512     auto formRendererGroup = FormRendererGroup::Create(nullptr, nullptr, eventHandler);
513     EXPECT_TRUE(formRendererGroup);
514     OHOS::AAFwk::Want want;
515     want.SetParam(FORM_RENDERER_COMP_ID, FORM_COMPONENT_ID_1);
516     want.SetParam(FORM_RENDERER_ALLOW_UPDATE, false);
517     want.SetParam(FORM_RENDER_STATE, true);
518     sptr<FormRendererDelegateImpl> renderDelegate = new FormRendererDelegateImpl();
519     want.SetParam(FORM_RENDERER_PROCESS_ON_ADD_SURFACE, renderDelegate->AsObject());
520     OHOS::AppExecFwk::FormJsInfo formJsInfo;
521     formRendererGroup->AddForm(want, formJsInfo);
522     auto formRenderer = formRendererGroup->formRenderer_;
523     EXPECT_TRUE(formRenderer);
524     formRenderer->uiContent_ = UIContent::Create(nullptr, nullptr);
525     EXPECT_TRUE(formRenderer->uiContent_);
526     formRenderer->UpdateConfiguration(nullptr);
527 }
528 
529 /**
530  * @tc.name: FormRenderTest014
531  * @tc.desc: test OnRemoteDied
532  * @tc.type: FUNC
533  */
HWTEST_F(FormRenderTest, FormRenderTest014, TestSize.Level1)534 HWTEST_F(FormRenderTest, FormRenderTest014, TestSize.Level1)
535 {
536     auto eventRunner = OHOS::AppExecFwk::EventRunner::Create("formRenderTest014");
537     ASSERT_TRUE(eventRunner);
538     auto eventHandler = std::make_shared<OHOS::AppExecFwk::EventHandler>(eventRunner);
539     auto formRendererGroup = FormRendererGroup::Create(nullptr, nullptr, eventHandler);
540     EXPECT_TRUE(formRendererGroup);
541     OHOS::AAFwk::Want want;
542     want.SetParam(FORM_RENDERER_COMP_ID, FORM_COMPONENT_ID_1);
543     want.SetParam(FORM_RENDERER_ALLOW_UPDATE, false);
544     want.SetParam(FORM_RENDER_STATE, true);
545     sptr<FormRendererDelegateImpl> renderDelegate = new FormRendererDelegateImpl();
546     want.SetParam(FORM_RENDERER_PROCESS_ON_ADD_SURFACE, renderDelegate->AsObject());
547     OHOS::AppExecFwk::FormJsInfo formJsInfo;
548     formRendererGroup->AddForm(want, formJsInfo);
549     auto formRenderer = formRendererGroup->formRenderer_;
550     EXPECT_TRUE(formRenderer);
551     formRenderer->uiContent_ = UIContent::Create(nullptr, nullptr);
552     EXPECT_TRUE(formRenderer->uiContent_);
553     FormRenderDelegateRecipient::RemoteDiedHandler handler = [](){};
554     auto formRenderDelegateRecipient = new FormRenderDelegateRecipient(handler);
555     formRenderDelegateRecipient->OnRemoteDied(nullptr);
556     formRenderDelegateRecipient->OnRemoteDied(renderDelegate->AsObject());
557 }
558 
559 /**
560  * @tc.name: FormRenderTest015
561  * @tc.desc: test GetRectRelativeToWindow
562  * @tc.type: FUNC
563  */
HWTEST_F(FormRenderTest, FormRenderTest015, TestSize.Level1)564 HWTEST_F(FormRenderTest, FormRenderTest015, TestSize.Level1)
565 {
566     auto eventRunner = OHOS::AppExecFwk::EventRunner::Create("formRenderTest015");
567     ASSERT_TRUE(eventRunner);
568     auto eventHandler = std::make_shared<OHOS::AppExecFwk::EventHandler>(eventRunner);
569     auto formRendererGroup = FormRendererGroup::Create(nullptr, nullptr, eventHandler);
570     EXPECT_TRUE(formRendererGroup);
571     OHOS::AAFwk::Want want;
572     want.SetParam(FORM_RENDERER_COMP_ID, FORM_COMPONENT_ID_1);
573     want.SetParam(FORM_RENDERER_ALLOW_UPDATE, false);
574     want.SetParam(FORM_RENDER_STATE, true);
575     sptr<FormRendererDelegateImpl> renderDelegate = new FormRendererDelegateImpl();
576     want.SetParam(FORM_RENDERER_PROCESS_ON_ADD_SURFACE, renderDelegate->AsObject());
577     OHOS::AppExecFwk::FormJsInfo formJsInfo;
578     formRendererGroup->AddForm(want, formJsInfo);
579     auto formRenderer = formRendererGroup->formRenderer_;
580     EXPECT_TRUE(formRenderer);
581     formRenderer->uiContent_ = UIContent::Create(nullptr, nullptr);
582     EXPECT_TRUE(formRenderer->uiContent_);
583     int32_t top = 0;
584     int32_t left = 0;
585     formRenderer->GetRectRelativeToWindow(top, left);
586     formRenderer->formRendererDelegate_ = renderDelegate;
587     EXPECT_TRUE(formRenderer->formRendererDelegate_);
588     formRenderer->GetRectRelativeToWindow(top, left);
589 }
590 
591 /**
592  * @tc.name: FormRenderTest016
593  * @tc.desc: test RecycleForm
594  * @tc.type: FUNC
595  */
HWTEST_F(FormRenderTest, FormRenderTest016, TestSize.Level1)596 HWTEST_F(FormRenderTest, FormRenderTest016, TestSize.Level1)
597 {
598     auto eventRunner = OHOS::AppExecFwk::EventRunner::Create("formRenderTest016");
599     ASSERT_TRUE(eventRunner);
600     auto eventHandler = std::make_shared<OHOS::AppExecFwk::EventHandler>(eventRunner);
601     auto formRendererGroup = FormRendererGroup::Create(nullptr, nullptr, eventHandler);
602     EXPECT_TRUE(formRendererGroup);
603     OHOS::AAFwk::Want want;
604     want.SetParam(FORM_RENDERER_COMP_ID, FORM_COMPONENT_ID_1);
605     want.SetParam(FORM_RENDERER_ALLOW_UPDATE, false);
606     want.SetParam(FORM_RENDER_STATE, true);
607     sptr<FormRendererDelegateImpl> renderDelegate = new FormRendererDelegateImpl();
608     want.SetParam(FORM_RENDERER_PROCESS_ON_ADD_SURFACE, renderDelegate->AsObject());
609     OHOS::AppExecFwk::FormJsInfo formJsInfo;
610     formRendererGroup->AddForm(want, formJsInfo);
611     auto formRenderer = formRendererGroup->formRenderer_;
612     EXPECT_TRUE(formRenderer);
613     std::string statusData;
614     formRenderer->RecycleForm(statusData);
615     formRenderer->uiContent_ = UIContent::Create(nullptr, nullptr);
616     EXPECT_TRUE(formRenderer->uiContent_);
617     formRenderer->RecycleForm(statusData);
618 }
619 
620 /**
621  * @tc.name: FormRenderTest017
622  * @tc.desc: test RecoverForm
623  * @tc.type: FUNC
624  */
HWTEST_F(FormRenderTest, FormRenderTest017, TestSize.Level1)625 HWTEST_F(FormRenderTest, FormRenderTest017, TestSize.Level1)
626 {
627     auto eventRunner = OHOS::AppExecFwk::EventRunner::Create("formRenderTest017");
628     ASSERT_TRUE(eventRunner);
629     auto eventHandler = std::make_shared<OHOS::AppExecFwk::EventHandler>(eventRunner);
630     auto formRendererGroup = FormRendererGroup::Create(nullptr, nullptr, eventHandler);
631     EXPECT_TRUE(formRendererGroup);
632     OHOS::AAFwk::Want want;
633     want.SetParam(FORM_RENDERER_COMP_ID, FORM_COMPONENT_ID_1);
634     want.SetParam(FORM_RENDERER_ALLOW_UPDATE, false);
635     want.SetParam(FORM_RENDER_STATE, true);
636     sptr<FormRendererDelegateImpl> renderDelegate = new FormRendererDelegateImpl();
637     want.SetParam(FORM_RENDERER_PROCESS_ON_ADD_SURFACE, renderDelegate->AsObject());
638     OHOS::AppExecFwk::FormJsInfo formJsInfo;
639     formRendererGroup->AddForm(want, formJsInfo);
640     auto formRenderer = formRendererGroup->formRenderer_;
641     EXPECT_TRUE(formRenderer);
642     const std::string statusData = "";
643     formRenderer->RecoverForm(statusData);
644     formRenderer->uiContent_ = UIContent::Create(nullptr, nullptr);
645     EXPECT_TRUE(formRenderer->uiContent_);
646     formRenderer->RecoverForm(statusData);
647 }
648 
649 /**
650  * @tc.name: FormRenderTest018
651  * @tc.desc: test PreInitAddForm
652  * @tc.type: FUNC
653  */
HWTEST_F(FormRenderTest, FormRenderTest018, TestSize.Level1)654 HWTEST_F(FormRenderTest, FormRenderTest018, TestSize.Level1)
655 {
656     auto eventRunner = OHOS::AppExecFwk::EventRunner::Create("formRenderTest018");
657     ASSERT_TRUE(eventRunner);
658     auto eventHandler = std::make_shared<OHOS::AppExecFwk::EventHandler>(eventRunner);
659     auto formRendererGroup = FormRendererGroup::Create(nullptr, nullptr, eventHandler);
660     EXPECT_TRUE(formRendererGroup);
661     OHOS::AAFwk::Want want;
662     want.SetParam(FORM_RENDERER_COMP_ID, FORM_COMPONENT_ID_1);
663     want.SetParam(FORM_RENDERER_ALLOW_UPDATE, false);
664     want.SetParam(FORM_RENDER_STATE, true);
665     sptr<FormRendererDelegateImpl> renderDelegate = new FormRendererDelegateImpl();
666     want.SetParam(FORM_RENDERER_PROCESS_ON_ADD_SURFACE, renderDelegate->AsObject());
667     OHOS::AppExecFwk::FormJsInfo formJsInfo;
668     formRendererGroup->AddForm(want, formJsInfo);
669     auto formRenderer = formRendererGroup->formRenderer_;
670     EXPECT_TRUE(formRenderer);
671     formRenderer->PreInitAddForm(want, formJsInfo);
672     std::string url = "";
673     formRenderer->ReloadForm(url);
674     formRenderer->UpdateForm(formJsInfo);
675     formRenderer->uiContent_ = UIContent::Create(nullptr, nullptr);
676     EXPECT_TRUE(formRenderer->uiContent_);
677     formRenderer->PreInitAddForm(want, formJsInfo);
678 }
679 
680 /**
681  * @tc.name: FormRenderTest019
682  * @tc.desc: test AttachForm
683  * @tc.type: FUNC
684  */
HWTEST_F(FormRenderTest, FormRenderTest019, TestSize.Level1)685 HWTEST_F(FormRenderTest, FormRenderTest019, TestSize.Level1)
686 {
687     auto eventRunner = OHOS::AppExecFwk::EventRunner::Create("formRenderTest019");
688     ASSERT_TRUE(eventRunner);
689     auto eventHandler = std::make_shared<OHOS::AppExecFwk::EventHandler>(eventRunner);
690     auto formRendererGroup = FormRendererGroup::Create(nullptr, nullptr, eventHandler);
691     EXPECT_TRUE(formRendererGroup);
692     OHOS::AAFwk::Want want;
693     want.SetParam(FORM_RENDERER_COMP_ID, FORM_COMPONENT_ID_1);
694     want.SetParam(FORM_RENDERER_ALLOW_UPDATE, false);
695     want.SetParam(FORM_RENDER_STATE, true);
696     sptr<FormRendererDelegateImpl> renderDelegate = new FormRendererDelegateImpl();
697     want.SetParam(FORM_RENDERER_PROCESS_ON_ADD_SURFACE, renderDelegate->AsObject());
698     OHOS::AppExecFwk::FormJsInfo formJsInfo;
699     formRendererGroup->AddForm(want, formJsInfo);
700     auto formRenderer = formRendererGroup->formRenderer_;
701     EXPECT_TRUE(formRenderer);
702     formRenderer->AttachForm(want, formJsInfo);
703     formRenderer->uiContent_ = UIContent::Create(nullptr, nullptr);
704     EXPECT_TRUE(formRenderer->uiContent_);
705     formRenderer->AttachForm(want, formJsInfo);
706 }
707 
708 /**
709  * @tc.name: FormRenderTest020
710  * @tc.desc: test AttachUIContent
711  * @tc.type: FUNC
712  */
HWTEST_F(FormRenderTest, FormRenderTest020, TestSize.Level1)713 HWTEST_F(FormRenderTest, FormRenderTest020, TestSize.Level1)
714 {
715     auto eventRunner = OHOS::AppExecFwk::EventRunner::Create("formRenderTest020");
716     ASSERT_TRUE(eventRunner);
717     auto eventHandler = std::make_shared<OHOS::AppExecFwk::EventHandler>(eventRunner);
718     auto formRendererGroup = FormRendererGroup::Create(nullptr, nullptr, eventHandler);
719     EXPECT_TRUE(formRendererGroup);
720     OHOS::AAFwk::Want want;
721     want.SetParam(FORM_RENDERER_COMP_ID, FORM_COMPONENT_ID_1);
722     want.SetParam(FORM_RENDERER_ALLOW_UPDATE, false);
723     want.SetParam(FORM_RENDER_STATE, true);
724     sptr<FormRendererDelegateImpl> renderDelegate = new FormRendererDelegateImpl();
725     want.SetParam(FORM_RENDERER_PROCESS_ON_ADD_SURFACE, renderDelegate->AsObject());
726     OHOS::AppExecFwk::FormJsInfo formJsInfo;
727     formRendererGroup->AddForm(want, formJsInfo);
728     auto formRenderer = formRendererGroup->formRenderer_;
729     EXPECT_TRUE(formRenderer);
730     formRenderer->uiContent_ = UIContent::Create(nullptr, nullptr);
731     EXPECT_TRUE(formRenderer->uiContent_);
732     std::string surfaceNodeName = "ArkTSCardNode";
733     struct Rosen::RSSurfaceNodeConfig surfaceNodeConfig = { .SurfaceNodeName = surfaceNodeName };
734     std::shared_ptr<Rosen::RSSurfaceNode> rsNode = OHOS::Rosen::RSSurfaceNode::Create(surfaceNodeConfig, true);
735     EXPECT_CALL(*((MockUIContent*)(formRenderer->uiContent_.get())), GetFormRootNode()).WillOnce(Return(rsNode));
736     formRenderer->AttachUIContent(want, formJsInfo);
737 }
738 
739 /**
740  * @tc.name: FormRenderTest021
741  * @tc.desc: test OnSurfaceReuse
742  * @tc.type: FUNC
743  */
HWTEST_F(FormRenderTest, FormRenderTest021, TestSize.Level1)744 HWTEST_F(FormRenderTest, FormRenderTest021, TestSize.Level1)
745 {
746     auto eventRunner = OHOS::AppExecFwk::EventRunner::Create("formRenderTest021");
747     ASSERT_TRUE(eventRunner);
748     auto eventHandler = std::make_shared<OHOS::AppExecFwk::EventHandler>(eventRunner);
749     auto formRendererGroup = FormRendererGroup::Create(nullptr, nullptr, eventHandler);
750     EXPECT_TRUE(formRendererGroup);
751     OHOS::AAFwk::Want want;
752     want.SetParam(FORM_RENDERER_COMP_ID, FORM_COMPONENT_ID_1);
753     want.SetParam(FORM_RENDERER_ALLOW_UPDATE, false);
754     want.SetParam(FORM_RENDER_STATE, true);
755     sptr<FormRendererDelegateImpl> renderDelegate = new FormRendererDelegateImpl();
756     want.SetParam(FORM_RENDERER_PROCESS_ON_ADD_SURFACE, renderDelegate->AsObject());
757     OHOS::AppExecFwk::FormJsInfo formJsInfo;
758     formRendererGroup->AddForm(want, formJsInfo);
759     auto formRenderer = formRendererGroup->formRenderer_;
760     EXPECT_TRUE(formRenderer);
761     formRenderer->uiContent_ = UIContent::Create(nullptr, nullptr);
762     EXPECT_TRUE(formRenderer->uiContent_);
763     formRenderer->formRendererDispatcherImpl_ =
764         new FormRendererDispatcherImpl(formRenderer->uiContent_, nullptr, eventHandler);
765     formRenderer->formRendererDelegate_ = renderDelegate;
766     formRenderer->OnSurfaceReuse(formJsInfo);
767     std::string surfaceNodeName = "ArkTSCardNode";
768     struct Rosen::RSSurfaceNodeConfig surfaceNodeConfig = { .SurfaceNodeName = surfaceNodeName };
769     std::shared_ptr<Rosen::RSSurfaceNode> rsNode = OHOS::Rosen::RSSurfaceNode::Create(surfaceNodeConfig, true);
770     EXPECT_CALL(*((MockUIContent*)(formRenderer->uiContent_.get())), GetFormRootNode()).Times(Exactly(2))
771         .WillOnce(Return(rsNode));
772     formRenderer->OnSurfaceReuse(formJsInfo);
773 }
774 
775 /**
776  * @tc.name: FormRenderTest022
777  * @tc.desc: test OnSurfaceDetach
778  * @tc.type: FUNC
779  */
HWTEST_F(FormRenderTest, FormRenderTest022, TestSize.Level1)780 HWTEST_F(FormRenderTest, FormRenderTest022, TestSize.Level1)
781 {
782     auto eventRunner = OHOS::AppExecFwk::EventRunner::Create("formRenderTest022");
783     ASSERT_TRUE(eventRunner);
784     auto eventHandler = std::make_shared<OHOS::AppExecFwk::EventHandler>(eventRunner);
785     auto formRendererGroup = FormRendererGroup::Create(nullptr, nullptr, eventHandler);
786     EXPECT_TRUE(formRendererGroup);
787     OHOS::AAFwk::Want want;
788     want.SetParam(FORM_RENDERER_COMP_ID, FORM_COMPONENT_ID_1);
789     want.SetParam(FORM_RENDERER_ALLOW_UPDATE, false);
790     want.SetParam(FORM_RENDER_STATE, true);
791     sptr<FormRendererDelegateImpl> renderDelegate = new FormRendererDelegateImpl();
792     want.SetParam(FORM_RENDERER_PROCESS_ON_ADD_SURFACE, renderDelegate->AsObject());
793     OHOS::AppExecFwk::FormJsInfo formJsInfo;
794     formRendererGroup->AddForm(want, formJsInfo);
795     auto formRenderer = formRendererGroup->formRenderer_;
796     EXPECT_TRUE(formRenderer);
797     formRenderer->uiContent_ = UIContent::Create(nullptr, nullptr);
798     EXPECT_TRUE(formRenderer->uiContent_);
799     formRenderer->formRendererDelegate_ = renderDelegate;
800     formRenderer->OnSurfaceDetach();
801     std::string surfaceNodeName = "ArkTSCardNode";
802     struct Rosen::RSSurfaceNodeConfig surfaceNodeConfig = { .SurfaceNodeName = surfaceNodeName };
803     std::shared_ptr<Rosen::RSSurfaceNode> rsNode = OHOS::Rosen::RSSurfaceNode::Create(surfaceNodeConfig, true);
804     EXPECT_CALL(*((MockUIContent*)(formRenderer->uiContent_.get())), GetFormRootNode()).Times(Exactly(2)).
805         WillOnce(Return(rsNode));
806     formRenderer->OnSurfaceDetach();
807 }
808 
809 } // namespace OHOS::Ace
810