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