• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2  * Copyright (c) 2023-2025 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 <thread>
16 #include <chrono>
17 #include "test/mock/interfaces/mock_uicontent.h"
18 #include "ui_content.h"
19 #include "interfaces/inner_api/form_render/include/form_renderer.h"
20 #include "interfaces/inner_api/form_render/include/form_renderer_delegate_impl.h"
21 #define private public
22 #include "interfaces/inner_api/form_render/include/form_renderer_group.h"
23 #undef private
24 #include "test/mock/core/pipeline/mock_pipeline_context.h"
25 #include "configuration.h"
26 
27 using namespace testing;
28 using namespace testing::ext;
29 namespace OHOS::Ace {
30 namespace {
31 constexpr char FORM_RENDER_STATE[] = "ohos.extra.param.key.form_render_state";
32 constexpr char FORM_RENDERER_COMP_ID[] = "ohos.extra.param.key.form_comp_id";
33 } // namespace
34 class FormRenderGroupTest : public testing::Test {
35 public:
SetUpTestCase()36     static void SetUpTestCase() {};
TearDownTestCase()37     static void TearDownTestCase() {};
38 };
39 /**
40  * @tc.name: FormRenderGroupTest_001
41  * @tc.desc: Test AddForm() funtion.
42  * @tc.type: FUNC
43  */
44 HWTEST_F(FormRenderGroupTest, FormRenderGroupTest_001, TestSize.Level1)
45 {
46     GTEST_LOG_(INFO) << "FormRenderGroupTest_001 start";
47     auto eventRunner = OHOS::AppExecFwk::EventRunner::Create("FormRenderGroupTest_001");
48     ASSERT_TRUE(eventRunner);
49     auto eventHandler = std::make_shared<OHOS::AppExecFwk::EventHandler>(eventRunner);
50     auto group = FormRendererGroup::Create(nullptr, nullptr, eventHandler);
51     EXPECT_TRUE(group);
52     OHOS::AAFwk::Want want;
53     OHOS::AppExecFwk::FormJsInfo formJsInfo;
54     formJsInfo.bundleName = "bundleName";
55     formJsInfo.moduleName = "moduleName";
56     formJsInfo.formId = 1;
57     EXPECT_EQ(formJsInfo.formId, 1);
58     group->AddForm(want, formJsInfo);
59     want.SetParam(FORM_RENDER_STATE, true);
60     group->AddForm(want, formJsInfo);
61     GTEST_LOG_(INFO) << "FormRenderGroupTest_001 end";
62 }
63 /**
64  * @tc.name: FormRenderGroupTest_002
65  * @tc.desc: Test OnUnlock() function.
66  * @tc.type: FUNC
67  */
68 HWTEST_F(FormRenderGroupTest, FormRenderGroupTest_002, TestSize.Level1)
69 {
70     GTEST_LOG_(INFO) << "FormRenderGroupTest_002 start";
71     auto eventRunner = OHOS::AppExecFwk::EventRunner::Create("FormRenderGroupTest_002");
72     ASSERT_TRUE(eventRunner);
73     auto eventHandler = std::make_shared<OHOS::AppExecFwk::EventHandler>(eventRunner);
74     auto group = FormRendererGroup::Create(nullptr, nullptr, eventHandler);
75     EXPECT_TRUE(group);
76     group->OnUnlock();
77     GTEST_LOG_(INFO) << "FormRenderGroupTest_002 end";
78 }
79 /**
80  * @tc.name: FormRenderGroupTest_003
81  * @tc.desc: Test UpdateForm() function.
82  * @tc.type: FUNC
83  */
84 HWTEST_F(FormRenderGroupTest, FormRenderGroupTest_003, TestSize.Level1)
85 {
86     GTEST_LOG_(INFO) << "FormRenderGroupTest_003 start";
87     auto eventRunner = OHOS::AppExecFwk::EventRunner::Create("FormRenderGroupTest_003");
88     ASSERT_TRUE(eventRunner);
89     auto eventHandler = std::make_shared<OHOS::AppExecFwk::EventHandler>(eventRunner);
90     auto group = FormRendererGroup::Create(nullptr, nullptr, eventHandler);
91     EXPECT_TRUE(group);
92     OHOS::AppExecFwk::FormJsInfo formJsInfo;
93     formJsInfo.bundleName = "bundleName";
94     formJsInfo.moduleName = "moduleName";
95     group->UpdateForm(formJsInfo);
96     group->formRenderer_ = std::make_shared<FormRenderer>(nullptr, nullptr, eventHandler);
97     group->UpdateForm(formJsInfo);
98     GTEST_LOG_(INFO) << "FormRenderGroupTest_003 end";
99 }
100 /**
101  * @tc.name: FormRenderGroupTest_004
102  * @tc.desc: Test DeleteForm() function.
103  * @tc.type: FUNC
104  */
105 HWTEST_F(FormRenderGroupTest, FormRenderGroupTest_004, TestSize.Level1)
106 {
107     GTEST_LOG_(INFO) << "FormRenderGroupTest_004 start";
108     auto eventRunner = OHOS::AppExecFwk::EventRunner::Create("FormRenderGroupTest_004");
109     ASSERT_TRUE(eventRunner);
110     auto eventHandler = std::make_shared<OHOS::AppExecFwk::EventHandler>(eventRunner);
111     auto group = FormRendererGroup::Create(nullptr, nullptr, eventHandler);
112     EXPECT_TRUE(group);
113     std::string id = "123456";
114     group->DeleteForm(id);
115     GTEST_LOG_(INFO) << "FormRenderGroupTest_004 end";
116 }
117 /**
118  * @tc.name: FormRenderGroupTest_005
119  * @tc.desc: Test DeleteForm() function.
120  * @tc.type: FUNC
121  */
122 HWTEST_F(FormRenderGroupTest, FormRenderGroupTest_005, TestSize.Level1)
123 {
124     GTEST_LOG_(INFO) << "FormRenderGroupTest_005 start";
125     auto eventRunner = OHOS::AppExecFwk::EventRunner::Create("FormRenderGroupTest_005");
126     ASSERT_TRUE(eventRunner);
127     auto eventHandler = std::make_shared<OHOS::AppExecFwk::EventHandler>(eventRunner);
128     auto group = FormRendererGroup::Create(nullptr, nullptr, eventHandler);
129     EXPECT_TRUE(group);
130     OHOS::AAFwk::Want want;
131     OHOS::AppExecFwk::FormJsInfo formJsInfo;
132     formJsInfo.bundleName = "bundleName";
133     formJsInfo.moduleName = "moduleName";
134     group->AddForm(want, formJsInfo);
135     group->DeleteForm();
136     GTEST_LOG_(INFO) << "FormRenderGroupTest_005 end";
137 }
138 /**
139  * @tc.name: FormRenderGroupTest_006
140  * @tc.desc: Test ReloadForm() function.
141  * @tc.type: FUNC
142  */
143 HWTEST_F(FormRenderGroupTest, FormRenderGroupTest_006, TestSize.Level1)
144 {
145     GTEST_LOG_(INFO) << "FormRenderGroupTest_006 start";
146     auto eventRunner = OHOS::AppExecFwk::EventRunner::Create("FormRenderGroupTest_006");
147     ASSERT_TRUE(eventRunner);
148     auto eventHandler = std::make_shared<OHOS::AppExecFwk::EventHandler>(eventRunner);
149     auto group = FormRendererGroup::Create(nullptr, nullptr, eventHandler);
150     EXPECT_TRUE(group);
151     OHOS::AppExecFwk::FormJsInfo formJsInfo;
152     formJsInfo.bundleName = "bundleName";
153     formJsInfo.moduleName = "moduleName";
154     formJsInfo.formId = 2;
155     EXPECT_EQ(formJsInfo.formId, 2);
156     group->ReloadForm(formJsInfo);
157     GTEST_LOG_(INFO) << "FormRenderGroupTest_006 end";
158 }
159 /**
160  * @tc.name: FormRenderGroupTest_007
161  * @tc.desc: Test UpdateConfiguration() function.
162  * @tc.type: FUNC
163  */
164 HWTEST_F(FormRenderGroupTest, FormRenderGroupTest_007, TestSize.Level1)
165 {
166     GTEST_LOG_(INFO) << "FormRenderGroupTest_007 start";
167     auto eventRunner = OHOS::AppExecFwk::EventRunner::Create("FormRenderGroupTest_007");
168     ASSERT_TRUE(eventRunner);
169     auto eventHandler = std::make_shared<OHOS::AppExecFwk::EventHandler>(eventRunner);
170     auto group = FormRendererGroup::Create(nullptr, nullptr, eventHandler);
171     EXPECT_TRUE(group);
172     std::shared_ptr<OHOS::AppExecFwk::Configuration> config;
173     group->UpdateConfiguration(config);
174     GTEST_LOG_(INFO) << "FormRenderGroupTest_007 end";
175 }
176 /**
177  * @tc.name: FormRenderGroupTest_008
178  * @tc.desc: Test IsFormRequestsEmpty() function.
179  * @tc.type: FUNC
180  */
181 HWTEST_F(FormRenderGroupTest, FormRenderGroupTest_008, TestSize.Level1)
182 {
183     GTEST_LOG_(INFO) << "FormRenderGroupTest_008 start";
184     auto eventRunner = OHOS::AppExecFwk::EventRunner::Create("FormRenderGroupTest_008");
185     ASSERT_TRUE(eventRunner);
186     auto eventHandler = std::make_shared<OHOS::AppExecFwk::EventHandler>(eventRunner);
187     auto group = FormRendererGroup::Create(nullptr, nullptr, eventHandler);
188     EXPECT_TRUE(group);
189     EXPECT_EQ(true, group->IsFormRequestsEmpty());
190     GTEST_LOG_(INFO) << "FormRenderGroupTest_008 end";
191 }
192 /**
193  * @tc.name: FormRenderGroupTest_009
194  * @tc.desc: Test GetAllRendererFormRequests() function.
195  * @tc.type: FUNC
196  */
197 HWTEST_F(FormRenderGroupTest, FormRenderGroupTest_009, TestSize.Level1)
198 {
199     GTEST_LOG_(INFO) << "FormRenderGroupTest_009 start";
200     auto eventRunner = OHOS::AppExecFwk::EventRunner::Create("FormRenderGroupTest_009");
201     ASSERT_TRUE(eventRunner);
202     auto eventHandler = std::make_shared<OHOS::AppExecFwk::EventHandler>(eventRunner);
203     auto group = FormRendererGroup::Create(nullptr, nullptr, eventHandler);
204     EXPECT_TRUE(group);
205     std::vector<FormRequest> from_ = group->GetAllRendererFormRequests();
206     GTEST_LOG_(INFO) << "FormRenderGroupTest_009 end";
207 }
208 /**
209  * @tc.name: FormRenderGroupTest_010
210  * @tc.desc: Test RecycleForm() function.
211  * @tc.type: FUNC
212  */
213 HWTEST_F(FormRenderGroupTest, FormRenderGroupTest_010, TestSize.Level1)
214 {
215     GTEST_LOG_(INFO) << "FormRenderGroupTest_010 start";
216     auto eventRunner = OHOS::AppExecFwk::EventRunner::Create("FormRenderGroupTest_010");
217     ASSERT_TRUE(eventRunner);
218     auto eventHandler = std::make_shared<OHOS::AppExecFwk::EventHandler>(eventRunner);
219     auto group = FormRendererGroup::Create(nullptr, nullptr, eventHandler);
220     EXPECT_TRUE(group);
221     std::string data = "123";
222     group->RecycleForm(data);
223     GTEST_LOG_(INFO) << "FormRenderGroupTest_010 end";
224 }
225 /**
226  * @tc.name: FormRenderGroupTest_011
227  * @tc.desc: Test FormRendererGroup() function.
228  * @tc.type: FUNC
229  */
230 HWTEST_F(FormRenderGroupTest, FormRenderGroupTest_011, TestSize.Level1)
231 {
232     GTEST_LOG_(INFO) << "FormRenderGroupTest_011 start";
233     auto eventRunner = OHOS::AppExecFwk::EventRunner::Create("FormRenderGroupTest_011");
234     ASSERT_TRUE(eventRunner);
235     auto eventHandler = std::make_shared<OHOS::AppExecFwk::EventHandler>(eventRunner);
236     FormRendererGroup group(nullptr, nullptr, eventHandler);
237     GTEST_LOG_(INFO) << "FormRenderGroupTest_011 end";
238 }
239 
240 /**
241 * @tc.name: FormRenderGroupTest_012
242 * @tc.desc: Test SetVisibleChange() function.
243 * @tc.type: FUNC
244 */
245 HWTEST_F(FormRenderGroupTest, FormRenderGroupTest_012, TestSize.Level1)
246 {
247     GTEST_LOG_(INFO) << "FormRenderGroupTest_012 start";
248     auto eventRunner = OHOS::AppExecFwk::EventRunner::Create("FormRenderGroupTest_012");
249     ASSERT_TRUE(eventRunner);
250     auto eventHandler = std::make_shared<OHOS::AppExecFwk::EventHandler>(eventRunner);
251     auto group = FormRendererGroup::Create(nullptr, nullptr, eventHandler);
252     EXPECT_TRUE(group);
253     group->SetVisibleChange(true);
254     GTEST_LOG_(INFO) << "FormRenderGroupTest_012 end";
255 }
256 
257 /**
258  * @tc.name: FormRenderGroupTest_014
259  * @tc.desc: Test OnUnlock() function.
260  * @tc.type: FUNC
261  */
262 HWTEST_F(FormRenderGroupTest, FormRenderGroupTest_014, TestSize.Level1)
263 {
264     GTEST_LOG_(INFO) << "FormRenderGroupTest_0014 start";
265     auto eventRunner = OHOS::AppExecFwk::EventRunner::Create("FormRenderGroupTest_014");
266     ASSERT_TRUE(eventRunner);
267     auto eventHandler = std::make_shared<OHOS::AppExecFwk::EventHandler>(eventRunner);
268     auto group = FormRendererGroup::Create(nullptr, nullptr, eventHandler);
269     FormRequest formRequest;
270     formRequest.compId = "unlock";
271     bool flag = false;
272     if (group != nullptr) {
273         group->formRequests_.push_back(formRequest);
274         group->currentCompId_ = "unlock";
275         group->OnUnlock();
276         flag = true;
277     }
278     EXPECT_TRUE(flag);
279     GTEST_LOG_(INFO) << "FormRenderGroupTest_014 end";
280 }
281 
282 /**
283  * @tc.name: FormRenderGroupTest_015
284  * @tc.desc: Test DeleteForm() function.
285  * @tc.type: FUNC
286  */
287 HWTEST_F(FormRenderGroupTest, FormRenderGroupTest_015, TestSize.Level1)
288 {
289     GTEST_LOG_(INFO) << "FormRenderGroupTest_015 start";
290     auto eventRunner = OHOS::AppExecFwk::EventRunner::Create("FormRenderGroupTest_015");
291     ASSERT_TRUE(eventRunner);
292     auto eventHandler = std::make_shared<OHOS::AppExecFwk::EventHandler>(eventRunner);
293     auto group = FormRendererGroup::Create(nullptr, nullptr, eventHandler);
294     std::string compId = "deleteform";
295     bool flag = false;
296     if (group != nullptr) {
297         group->currentCompId_ = "deleteform";
298         group->DeleteForm(compId);
299         flag = true;
300     }
301     EXPECT_TRUE(flag);
302     GTEST_LOG_(INFO) << "FormRenderGroupTest_015 end";
303 }
304 
305 /**
306  * @tc.name: FormRenderGroupTest_016
307  * @tc.desc: Test DeleteForm() function.
308  * @tc.type: FUNC
309  */
310 HWTEST_F(FormRenderGroupTest, FormRenderGroupTest_016, TestSize.Level1)
311 {
312     GTEST_LOG_(INFO) << "FormRenderGroupTest_016 start";
313     auto eventRunner = OHOS::AppExecFwk::EventRunner::Create("FormRenderGroupTest_016");
314     ASSERT_TRUE(eventRunner);
315     auto eventHandler = std::make_shared<OHOS::AppExecFwk::EventHandler>(eventRunner);
316     auto group = FormRendererGroup::Create(nullptr, nullptr, eventHandler);
317     group->formRenderer_ = nullptr;
318     std::string compId = "deleteform";
319     FormRequest formRequest;
320     formRequest.compId = "requestdeleteform";
321     bool flag = false;
322     if (group != nullptr) {
323         group->formRequests_.push_back(formRequest);
324         group->currentCompId_ = "deleteform";
325         group->DeleteForm(compId);
326         flag = true;
327     }
328     EXPECT_TRUE(flag);
329     GTEST_LOG_(INFO) << "FormRenderGroupTest_016 end";
330 }
331 
332 /**
333  * @tc.name: FormRenderGroupTest_017
334  * @tc.desc: Test DeleteForm() function.
335  * @tc.type: FUNC
336  */
337 HWTEST_F(FormRenderGroupTest, FormRenderGroupTest_017, TestSize.Level1)
338 {
339     GTEST_LOG_(INFO) << "FormRenderGroupTest_017 start";
340     auto eventRunner = OHOS::AppExecFwk::EventRunner::Create("FormRenderGroupTest_017");
341     ASSERT_TRUE(eventRunner);
342     auto eventHandler = std::make_shared<OHOS::AppExecFwk::EventHandler>(eventRunner);
343     auto group = FormRendererGroup::Create(nullptr, nullptr, eventHandler);
344     group->formRenderer_ = std::make_shared<FormRenderer>(nullptr, nullptr, eventHandler);
345     std::string compId = "deleteform";
346     FormRequest formRequest;
347     formRequest.compId = "requestdeleteform";
348     bool flag = false;
349     if (group != nullptr) {
350         group->formRequests_.push_back(formRequest);
351         group->currentCompId_ = "deleteform";
352         group->DeleteForm(compId);
353         flag = true;
354     }
355     EXPECT_TRUE(flag);
356     GTEST_LOG_(INFO) << "FormRenderGroupTest_017 end";
357 }
358 
359 /**
360  * @tc.name: FormRenderGroupTest_018
361  * @tc.desc: Test UpdateConfiguration() function.
362  * @tc.type: FUNC
363  */
364 HWTEST_F(FormRenderGroupTest, FormRenderGroupTest_018, TestSize.Level1)
365 {
366     GTEST_LOG_(INFO) << "FormRenderGroupTest_018 start";
367     auto eventRunner = OHOS::AppExecFwk::EventRunner::Create("FormRenderGroupTest_018");
368     ASSERT_TRUE(eventRunner);
369     auto eventHandler = std::make_shared<OHOS::AppExecFwk::EventHandler>(eventRunner);
370     auto group = FormRendererGroup::Create(nullptr, nullptr, eventHandler);
371     bool flag = false;
372     if (group != nullptr) {
373         group->UpdateConfiguration(nullptr);
374         flag = true;
375     }
376     EXPECT_TRUE(flag);
377     std::shared_ptr<OHOS::AppExecFwk::Configuration> config = std::make_shared<OHOS::AppExecFwk::Configuration>();
378     group->formRenderer_ = nullptr;
379     flag = false;
380     if (group != nullptr) {
381         group->UpdateConfiguration(config);
382         flag = true;
383     }
384     EXPECT_TRUE(flag);
385     group->formRenderer_ = std::make_shared<FormRenderer>(nullptr, nullptr, eventHandler);
386     flag = false;
387     if (group != nullptr) {
388         group->UpdateConfiguration(config);
389         flag = true;
390     }
391     EXPECT_TRUE(flag);
392     GTEST_LOG_(INFO) << "FormRenderGroupTest_018 end";
393 }
394 
395 /**
396  * @tc.name: FormRenderGroupTest_019
397  * @tc.desc: Test RecycleForm() function.
398  * @tc.type: FUNC
399  */
400 HWTEST_F(FormRenderGroupTest, FormRenderGroupTest_019, TestSize.Level1)
401 {
402     GTEST_LOG_(INFO) << "FormRenderGroupTest_019 start";
403     auto eventRunner = OHOS::AppExecFwk::EventRunner::Create("FormRenderGroupTest_019");
404     ASSERT_TRUE(eventRunner);
405     auto eventHandler = std::make_shared<OHOS::AppExecFwk::EventHandler>(eventRunner);
406     auto group = FormRendererGroup::Create(nullptr, nullptr, eventHandler);
407     std::string statusData = "statusData";
408     group->formRenderer_ = nullptr;
409     bool flag = false;
410     if (group != nullptr) {
411         group->RecycleForm(statusData);
412         flag = true;
413     }
414     EXPECT_TRUE(flag);
415     group->formRenderer_ = std::make_shared<FormRenderer>(nullptr, nullptr, eventHandler);
416     flag = false;
417     if (group != nullptr) {
418         group->RecycleForm(statusData);
419         flag = true;
420     }
421     EXPECT_TRUE(flag);
422     GTEST_LOG_(INFO) << "FormRenderGroupTest_019 end";
423 }
424 
425 /**
426  * @tc.name: FormRenderGroupTest_020
427  * @tc.desc: Test PreInitAddForm() function.
428  * @tc.type: FUNC
429  */
430 HWTEST_F(FormRenderGroupTest, FormRenderGroupTest_020, TestSize.Level1)
431 {
432     GTEST_LOG_(INFO) << "FormRenderGroupTest_020 start";
433     auto eventRunner = OHOS::AppExecFwk::EventRunner::Create("FormRenderGroupTest_020");
434     ASSERT_TRUE(eventRunner);
435     auto eventHandler = std::make_shared<OHOS::AppExecFwk::EventHandler>(eventRunner);
436     auto group = FormRendererGroup::Create(nullptr, nullptr, eventHandler);
437     FormRequest formRequest;
438     formRequest.compId = "PreInitAddForm";
439     bool flag = false;
440     if (group != nullptr) {
441         group->initState_ = FormRendererGroup::FormRendererInitState::PRE_INITIALIZED;
442         group->PreInitAddForm(formRequest);
443         flag = true;
444     }
445     EXPECT_TRUE(flag);
446     flag = false;
447     if (group != nullptr) {
448         group->initState_ = FormRendererGroup::FormRendererInitState::UNINITIALIZED;
449         group->formRenderer_ = std::make_shared<FormRenderer>(nullptr, nullptr, eventHandler);
450         group->PreInitAddForm(formRequest);
451         flag = true;
452     }
453     EXPECT_TRUE(flag);
454     flag = false;
455     if (group != nullptr) {
456         group->initState_ = FormRendererGroup::FormRendererInitState::UNINITIALIZED;
457         group->formRenderer_ = nullptr;
458         group->PreInitAddForm(formRequest);
459         flag = true;
460     }
461     EXPECT_TRUE(flag);
462     GTEST_LOG_(INFO) << "FormRenderGroupTest_020 end";
463 }
464 
465 /**
466  * @tc.name: FormRenderGroupTest_021
467  * @tc.desc: Test InnerAddForm() function.
468  * @tc.type: FUNC
469  */
470 HWTEST_F(FormRenderGroupTest, FormRenderGroupTest_021, TestSize.Level1)
471 {
472     GTEST_LOG_(INFO) << "FormRenderGroupTest_021 start";
473     auto eventRunner = OHOS::AppExecFwk::EventRunner::Create("FormRenderGroupTest_021");
474     ASSERT_TRUE(eventRunner);
475     auto eventHandler = std::make_shared<OHOS::AppExecFwk::EventHandler>(eventRunner);
476     auto group = FormRendererGroup::Create(nullptr, nullptr, eventHandler);
477     FormRequest formRequest;
478     formRequest.compId = "InnerAddForm";
479     bool flag = false;
480     if (group != nullptr) {
481         group->initState_ = FormRendererGroup::FormRendererInitState::PRE_INITIALIZED;
482         group->formRenderer_ = nullptr;
483         group->InnerAddForm(formRequest);
484         flag = true;
485     }
486     EXPECT_TRUE(flag);
487     flag = false;
488     if (group != nullptr) {
489         group->initState_ = FormRendererGroup::FormRendererInitState::UNINITIALIZED;
490         group->formRenderer_ = std::make_shared<FormRenderer>(nullptr, nullptr, eventHandler);
491         group->InnerAddForm(formRequest);
492         flag = true;
493     }
494     EXPECT_TRUE(flag);
495     flag = false;
496     if (group != nullptr) {
497         group->initState_ = FormRendererGroup::FormRendererInitState::PRE_INITIALIZED;
498         group->formRenderer_ = std::make_shared<FormRenderer>(nullptr, nullptr, eventHandler);
499         group->InnerAddForm(formRequest);
500         flag = true;
501     }
502     EXPECT_TRUE(flag);
503     flag = false;
504     if (group != nullptr) {
505         group->initState_ = FormRendererGroup::FormRendererInitState::INITIALIZED;
506         group->formRenderer_ =  std::make_shared<FormRenderer>(nullptr, nullptr, eventHandler);
507         group->InnerAddForm(formRequest);
508         flag = true;
509     }
510     EXPECT_TRUE(flag);
511     GTEST_LOG_(INFO) << "FormRenderGroupTest_021 end";
512 }
513 
514 /**
515  * @tc.name: FormRenderGroupTest_022
516  * @tc.desc: Test GetOrderedAndCurrentCompIds() function.
517  * @tc.type: FUNC
518  */
519 HWTEST_F(FormRenderGroupTest, FormRenderGroupTest_022, TestSize.Level1)
520 {
521     GTEST_LOG_(INFO) << "FormRenderGroupTest_022 start";
522     auto eventRunner = OHOS::AppExecFwk::EventRunner::Create("FormRenderGroupTest_022");
523     ASSERT_TRUE(eventRunner);
524     auto eventHandler = std::make_shared<OHOS::AppExecFwk::EventHandler>(eventRunner);
525     auto group = FormRendererGroup::Create(nullptr, nullptr, eventHandler);
526     EXPECT_TRUE(group);
527     std::pair<std::vector<std::string>, std::string> compIdPair = group->GetOrderedAndCurrentCompIds();
528     EXPECT_EQ(true, compIdPair.first.empty());
529     EXPECT_EQ(true, compIdPair.second.empty());
530     OHOS::AAFwk::Want want;
531     OHOS::AppExecFwk::FormJsInfo formJsInfo;
532     formJsInfo.formId = 1;
533     std::string compId1 = "comp1";
534     want.SetParam(FORM_RENDERER_COMP_ID, compId1);
535     group->AddForm(want, formJsInfo);
536     formJsInfo.formId = 2;
537     std::string compId2 = "comp2";
538     want.SetParam(FORM_RENDERER_COMP_ID, compId2);
539     group->AddForm(want, formJsInfo);
540     compIdPair = group->GetOrderedAndCurrentCompIds();
541     EXPECT_EQ(2, compIdPair.first.size());
542     EXPECT_EQ(compId1, compIdPair.first[0]);
543     EXPECT_EQ(compId2, compIdPair.first[1]);
544     EXPECT_EQ(compId2, compIdPair.second);
545     group->DeleteForm(compId2);
546     compIdPair = group->GetOrderedAndCurrentCompIds();
547     EXPECT_EQ(1, compIdPair.first.size());
548     EXPECT_EQ(compId1, compIdPair.second);
549     GTEST_LOG_(INFO) << "FormRenderGroupTest_022 end";
550 }
551 
552 /**
553  * @tc.name: FormRenderGroupTest_023
554  * @tc.desc: Test RecoverRenderer() function.
555  * @tc.type: FUNC
556  */
557 HWTEST_F(FormRenderGroupTest, FormRenderGroupTest_023, TestSize.Level1)
558 {
559     GTEST_LOG_(INFO) << "FormRenderGroupTest_023 start";
560     auto eventRunner = OHOS::AppExecFwk::EventRunner::Create("FormRenderGroupTest_023");
561     ASSERT_TRUE(eventRunner);
562     auto eventHandler = std::make_shared<OHOS::AppExecFwk::EventHandler>(eventRunner);
563     auto group = FormRendererGroup::Create(nullptr, nullptr, eventHandler);
564     EXPECT_TRUE(group);
565     OHOS::AAFwk::Want want;
566     OHOS::AppExecFwk::FormJsInfo formJsInfo;
567     formJsInfo.formId = 1;
568     std::string compId1 = "comp1";
569     want.SetParam(FORM_RENDERER_COMP_ID, compId1);
570     group->AddForm(want, formJsInfo);
571     formJsInfo.formId = 2;
572     std::string compId2 = "comp2";
573     want.SetParam(FORM_RENDERER_COMP_ID, compId2);
574     group->AddForm(want, formJsInfo);
575     std::pair<std::vector<std::string>, std::string> compIdPair = group->GetOrderedAndCurrentCompIds();
576     group->DeleteForm();
577     EXPECT_EQ(true, group->GetAllRendererFormRequests().empty());
578     std::vector<FormRequest> requests;
579     group->RecoverRenderer(requests, 0);
580     EXPECT_EQ(true, group->GetAllRendererFormRequests().empty());
581     for (auto compId: compIdPair.first) {
582         FormRequest formRequest;
583         formRequest.compId = compId;
584         requests.emplace_back(formRequest);
585     }
586     group->RecoverRenderer(requests, requests.size());
587     EXPECT_EQ(true, group->GetAllRendererFormRequests().empty());
588     group->RecoverRenderer(requests, requests.size() - 1);
589     EXPECT_EQ(2, group->GetAllRendererFormRequests().size());
590     compIdPair = group->GetOrderedAndCurrentCompIds();
591     EXPECT_EQ(compId2, compIdPair.second);
592     GTEST_LOG_(INFO) << "FormRenderGroupTest_023 end";
593 }
594 
595 HWTEST_F(FormRenderGroupTest, FormRenderGroupTest_024, TestSize.Level1)
596 {
597     GTEST_LOG_(INFO) << "FormRenderGroupTest_024 start";
598     auto eventRunner = OHOS::AppExecFwk::EventRunner::Create("FormRenderGroupTest_024");
599     ASSERT_TRUE(eventRunner);
600     auto eventHandler = std::make_shared<OHOS::AppExecFwk::EventHandler>(eventRunner);
601     auto group = FormRendererGroup::Create(nullptr, nullptr, eventHandler);
602     EXPECT_TRUE(group);
603     OHOS::AAFwk::Want want;
604     OHOS::AppExecFwk::FormJsInfo formJsInfo;
605     formJsInfo.formId = 1;
606     std::string compId = "comp1";
607     want.SetParam(FORM_RENDERER_COMP_ID, compId);
608     want.SetParam(OHOS::AppExecFwk::Constants::PARAM_FORM_WIDTH_KEY, 1.0);
609     want.SetParam(OHOS::AppExecFwk::Constants::PARAM_FORM_HEIGHT_KEY, 1.0);
610     want.SetParam(OHOS::AppExecFwk::Constants::PARAM_FORM_BORDER_WIDTH_KEY, 1.0f);
611     group->AddForm(want, formJsInfo);
612     auto requestWant = group->GetAllRendererFormRequests().begin()->want;
613     EXPECT_EQ(1.0, requestWant.GetDoubleParam(OHOS::AppExecFwk::Constants::PARAM_FORM_WIDTH_KEY, 0.0f));
614     EXPECT_EQ(1.0, requestWant.GetDoubleParam(OHOS::AppExecFwk::Constants::PARAM_FORM_HEIGHT_KEY, 0.0f));
615     EXPECT_EQ(1.0, requestWant.GetFloatParam(OHOS::AppExecFwk::Constants::PARAM_FORM_BORDER_WIDTH_KEY, 0.0f));
616     group->UpdateFormSizeOfFormRequests(2.0, 2.0, 2.0f);
617     auto requestWant2 = group->GetAllRendererFormRequests().begin()->want;
618     EXPECT_EQ(2.0, requestWant2.GetDoubleParam(OHOS::AppExecFwk::Constants::PARAM_FORM_WIDTH_KEY, 0.0f));
619     EXPECT_EQ(2.0, requestWant2.GetDoubleParam(OHOS::AppExecFwk::Constants::PARAM_FORM_HEIGHT_KEY, 0.0f));
620     EXPECT_EQ(2.0, requestWant2.GetFloatParam(OHOS::AppExecFwk::Constants::PARAM_FORM_BORDER_WIDTH_KEY, 0.0f));
621     GTEST_LOG_(INFO) << "FormRenderGroupTest_024 end";
622 }
623 
624 HWTEST_F(FormRenderGroupTest, FormRenderGroupTest_025, TestSize.Level1)
625 {
626     GTEST_LOG_(INFO) << "FormRenderGroupTest_025 start";
627     auto eventRunner = OHOS::AppExecFwk::EventRunner::Create("FormRenderGroupTest_025");
628     ASSERT_TRUE(eventRunner);
629     auto eventHandler = std::make_shared<OHOS::AppExecFwk::EventHandler>(eventRunner);
630     auto group = FormRendererGroup::Create(nullptr, nullptr, eventHandler);
631     EXPECT_TRUE(group);
632     OHOS::AAFwk::Want want;
633     std::string compId = "comp1";
634     want.SetParam(FORM_RENDERER_COMP_ID, compId);
635     EXPECT_TRUE(group->IsManagerDelegateValid(want));
636     GTEST_LOG_(INFO) << "FormRenderGroupTest_025 end";
637 }
638 }