1 /*
2 * Copyright (c) 2022-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 <gtest/gtest.h>
16 #include <memory>
17 #include "form_caller_mgr.h"
18 #define private public
19 #define protected public
20 #include "form_mgr.h"
21 #include "form_errors.h"
22 #include "iservice_registry.h"
23 #undef private
24 #undef protected
25 #include "form_mgr_errors.h"
26 #include "mock_form_provider_client.h"
27 #include "gmock/gmock.h"
28 #include "mock_form_mgr_proxy.h"
29 #include "mock_form_token.h"
30 #include "if_system_ability_manager.h"
31 #include "mock_system_ability_manager.h"
32 #include "mock_i_remote_object.h"
33 #include "fms_log_wrapper.h"
34
35 using namespace testing::ext;
36 using namespace OHOS;
37 using namespace OHOS::AppExecFwk;
38
39 using ::testing::Return;
40 using ::testing::SetArgReferee;
41 using ::testing::ContainerEq;
42 using ::testing::_;
43 using ::testing::DoAll;
44
45 // overload operator for ContainerEq
46 namespace OHOS::AppExecFwk {
operator ==(const FormInfo & lhs,const FormInfo & rhs)47 bool operator==(const FormInfo& lhs, const FormInfo& rhs)
48 {
49 if (lhs.bundleName != rhs.bundleName) {
50 return false;
51 }
52 if (lhs.moduleName != rhs.moduleName) {
53 return false;
54 }
55 if (lhs.name != rhs.name) {
56 return false;
57 }
58 // to be continued...
59 return true;
60 }
61 }
62
63 namespace {
64 const std::int32_t ERROR_NUM = 2293778;
65 const std::int32_t ERROR_NUMS = 8388610;
66 const std::int32_t NEGATIVE_NUM = -1;
67 const std::int32_t POSITIVE_NUM = 1;
68 const std::int32_t ERR_FAILED = -1;
69 const std::int64_t FORM_ID = 10;
70 class FormMgrTest : public testing::Test {
71 public:
72 static void SetUpTestCase();
73 static void TearDownTestCase();
74 void SetUp();
75 void TearDown();
76
77 static sptr<MockFormMgrProxy> mockProxy;
78 };
79 // initialize static variable.
80 sptr<MockFormMgrProxy> FormMgrTest::mockProxy = nullptr;
81
SetUpTestCase(void)82 void FormMgrTest::SetUpTestCase(void)
83 {}
84
TearDownTestCase(void)85 void FormMgrTest::TearDownTestCase(void)
86 {}
87
SetUp(void)88 void FormMgrTest::SetUp(void)
89 {
90 if (mockProxy == nullptr) {
91 GTEST_LOG_(INFO) << "SetUpTestCase";
92 sptr<IRemoteObject> impl = nullptr;
93 mockProxy = new (std::nothrow) MockFormMgrProxy(impl);
94 FormMgr::GetInstance().SetFormMgrService(mockProxy);
95 }
96 }
97
TearDown(void)98 void FormMgrTest::TearDown(void)
99 {
100 GTEST_LOG_(INFO) << "FormMgrTest_TearDown start";
101 FormMgr::GetInstance().SetFormMgrService(nullptr);
102 mockProxy = nullptr;
103 GTEST_LOG_(INFO) << "FormMgrTest_TearDown end";
104 }
105
106 /**
107 * @tc.name: FormMgrTest_0001
108 * @tc.desc: Verify GetFormsInfo
109 * @tc.type: FUNC
110 * @tc.require: #I59O23
111 */
112 HWTEST_F(FormMgrTest, FormMgrTest_0001, TestSize.Level1) {
113 GTEST_LOG_(INFO) << "FormMgrTest_0001 starts";
114 // initialize input parameters.
115 FormInfoFilter filter;
116 filter.moduleName = "";
117 std::vector<FormInfo> formInfos;
118 // setup expectations.
119 std::vector<FormInfo> expectFormInfos;
120 FormInfo formInfo = {};
121 formInfo.bundleName = "ohos.samples.FormApplication";
122 expectFormInfos.push_back(formInfo);
123 EXPECT_CALL(*mockProxy, GetFormsInfo(_, _))
124 .Times(1)
125 .WillOnce(DoAll(SetArgReferee<1>(expectFormInfos), Return(ERR_OK)));
126 // test.
127 FormMgr::GetInstance().GetFormsInfo(filter, formInfos);
128 // expect result.
129 EXPECT_THAT(formInfos, ContainerEq(expectFormInfos));
130 // FormMgr is a singleton, therefore, deleteing it will cause segfault for other invocations.
131 testing::Mock::AllowLeak(mockProxy);
132 GTEST_LOG_(INFO) << "FormMgrTest_0001 test ends";
133 }
134
135 /**
136 * @tc.name: FormMgrTest_0002
137 * @tc.desc: Verify GetFormsInfo
138 * @tc.type: FUNC
139 * @tc.require: #I59O23
140 */
141 HWTEST_F(FormMgrTest, FormMgrTest_0002, TestSize.Level1) {
142 GTEST_LOG_(INFO) << "FormMgrTest_0002 starts";
143 // initialize input parameters.
144 FormInfoFilter filter;
145 filter.moduleName = "empty";
146 std::vector<FormInfo> formInfos;
147 // setup expectations.
148 std::vector<FormInfo> expectFormInfos;
149 FormInfo formInfo = {};
150 formInfo.bundleName = "ohos.samples.FormApplication";
151 formInfo.moduleName = "entry";
152 expectFormInfos.push_back(formInfo);
153 EXPECT_CALL(*mockProxy, GetFormsInfo(_, _))
154 .Times(1)
155 .WillOnce(Return(ERR_OK));
156 // test.
157 FormMgr::GetInstance().GetFormsInfo(filter, formInfos);
158 // expect result.
159 EXPECT_EQ(formInfos.size(), 0);
160 testing::Mock::AllowLeak(mockProxy);
161 GTEST_LOG_(INFO) << "FormMgrTest_0002 test ends";
162 }
163
164 /**
165 * @tc.name: FormMgrTest_0003
166 * @tc.desc: Verify IsRequestPublishFormSupported
167 * @tc.type: FUNC
168 * @tc.require: #I58Y0A
169 */
170 HWTEST_F(FormMgrTest, FormMgrTest_0003, TestSize.Level1) {
171 GTEST_LOG_(INFO) << "FormMgrTest_0003 starts";
172 EXPECT_CALL(*mockProxy, IsRequestPublishFormSupported())
173 .Times(1)
174 .WillOnce(Return(false));
175 bool result = FormMgr::GetInstance().IsRequestPublishFormSupported();
176 EXPECT_EQ(result, false);
177 GTEST_LOG_(INFO) << "FormMgrTest_0003 test ends";
178 }
179
180 /**
181 * @tc.name: FormMgrTest_0004
182 * @tc.desc: Verify StartAbility
183 * @tc.type: FUNC
184 * @tc.require: #I5EFDX
185 */
186 HWTEST_F(FormMgrTest, FormMgrTest_0004, TestSize.Level1) {
187 GTEST_LOG_(INFO) << "FormMgrTest_0004 starts";
188 EXPECT_CALL(*mockProxy, StartAbility(_, _))
189 .Times(1)
190 .WillOnce(Return(0));
191 Want want;
192 want = want.SetElementName("", "com.example.FormAbility", "MainAbility");
193 sptr<MockFormToken> token = new (std::nothrow) MockFormToken();
194 int32_t result = FormMgr::GetInstance().StartAbility(want, token);
195 EXPECT_EQ(result, 0);
196 GTEST_LOG_(INFO) << "FormMgrTest_0004 test ends";
197 }
198
199 /**
200 * @tc.name: FormMgrTest_0005
201 * @tc.desc: Verify UpdateForm
202 * @tc.type: FUNC
203 * @tc.require: issueI5PFT9
204 */
205 HWTEST_F(FormMgrTest, FormMgrTest_0005, TestSize.Level1) {
206 GTEST_LOG_(INFO) << "FormMgrTest_0005 starts";
207 EXPECT_CALL(*mockProxy, UpdateForm(_, _))
208 .Times(1)
209 .WillOnce(Return(0));
210 FormJsInfo formJsInfo;
211 formJsInfo.formId = 1;
212 sptr<MockFormToken> token = new (std::nothrow) MockFormToken();
213 sptr<IRemoteObject> providerToken = new (std::nothrow) MockFormProviderClient();
214 FormCallerMgr::GetInstance().AddFormHostCaller(formJsInfo, providerToken);
215 FormProviderData formProviderData = FormProviderData(std::string("{\"city\": \"beijing001\"}"));
216 int32_t result = FormMgr::GetInstance().UpdateForm(formJsInfo.formId, formProviderData);
217 EXPECT_EQ(result, 0);
218 GTEST_LOG_(INFO) << "FormMgrTest_0005 test ends";
219 }
220
221 /**
222 * @tc.name: FormMgrTest_0006
223 * @tc.desc: Verify RequestForm
224 * @tc.type: FUNC
225 * @tc.require: issueI5Q8IU
226 */
227 HWTEST_F(FormMgrTest, FormMgrTest_0006, TestSize.Level1) {
228 GTEST_LOG_(INFO) << "FormMgrTest_0006 starts";
229
230 Want want;
231 want = want.SetElementName("", "com.example.FormAbility", "MainAbility");
232 sptr<MockFormToken> token = new (std::nothrow) MockFormToken();
233 FormJsInfo formJsInfo;
234 formJsInfo.formId = 1;
235 sptr<IRemoteObject> providerToken = new (std::nothrow) MockFormProviderClient();
236 FormCallerMgr::GetInstance().AddFormHostCaller(formJsInfo, providerToken);
237 int32_t result = FormMgr::GetInstance().RequestForm(formJsInfo.formId, token, want);
238 EXPECT_EQ(result, 0);
239 GTEST_LOG_(INFO) << "FormMgrTest_0006 test ends";
240 }
241
242 /**
243 * @tc.name: FormMgrTest_0007
244 * @tc.desc: Verify MessageEvent
245 * @tc.type: FUNC
246 * @tc.require: issueI5QGMS
247 */
248 HWTEST_F(FormMgrTest, FormMgrTest_0007, TestSize.Level1) {
249 GTEST_LOG_(INFO) << "FormMgrTest_0007 starts";
250
251 Want want;
252 want = want.SetElementName("", "com.example.FormAbility", "MainAbility");
253 sptr<MockFormToken> token = new (std::nothrow) MockFormToken();
254 FormJsInfo formJsInfo;
255 sptr<IRemoteObject> providerToken = new (std::nothrow) MockFormProviderClient();
256 FormCallerMgr::GetInstance().AddFormHostCaller(formJsInfo, providerToken);
257 int32_t result = FormMgr::GetInstance().MessageEvent(formJsInfo.formId, want, token);
258 EXPECT_EQ(result, 0);
259 GTEST_LOG_(INFO) << "FormMgrTest_0007 test ends";
260 }
261
262 /**
263 * @tc.name: FormMgrTest_0005
264 * @tc.desc: Verify NotifyFormsPrivacyProtected
265 * @tc.type: FUNC
266 * @tc.require: I5ST27
267 */
268 HWTEST_F(FormMgrTest, FormMgrTest_0008, TestSize.Level1) {
269 GTEST_LOG_(INFO) << "FormMgrTest_0008 starts";
270 EXPECT_CALL(*mockProxy, NotifyFormsPrivacyProtected(_, _, _))
271 .Times(1)
272 .WillOnce(Return(0));
273 // initialize input parameters.
274 int64_t formId = 1;
275 std::vector<int64_t> formIds;
276 formIds.push_back(formId);
277 bool isProtected = false;
278 sptr<MockFormToken> token = new (std::nothrow) MockFormToken();
279 int32_t result = FormMgr::GetInstance().NotifyFormsPrivacyProtected(formIds, isProtected, token);
280 // expect result.
281 EXPECT_EQ(result, 0);
282 GTEST_LOG_(INFO) << "FormMgrTest_0008 test ends";
283 }
284
285 /**
286 * @tc.name: FormMgrTest_0006
287 * @tc.desc: Verify NotifyFormsPrivacyProtected
288 * @tc.type: FUNC
289 * @tc.require: I5ST27
290 */
291 HWTEST_F(FormMgrTest, FormMgrTest_0009, TestSize.Level1) {
292 GTEST_LOG_(INFO) << "FormMgrTest_0009 starts";
293 EXPECT_CALL(*mockProxy, NotifyFormsPrivacyProtected(_, _, _))
294 .Times(1)
295 .WillOnce(Return(0));
296 // initialize input parameters.
297 int64_t formId = 2;
298 std::vector<int64_t> formIds;
299 formIds.push_back(formId);
300 bool isProtected = true;
301 sptr<MockFormToken> token = new (std::nothrow) MockFormToken();
302 int32_t result = FormMgr::GetInstance().NotifyFormsPrivacyProtected(formIds, isProtected, token);
303 // expect result.
304 EXPECT_EQ(result, 0);
305 GTEST_LOG_(INFO) << "FormMgrTest_0009 test ends";
306 }
307
308 /**
309 * @tc.name: FormMgrTest_0007
310 * @tc.desc: Verify NotifyFormsPrivacyProtected
311 * @tc.type: FUNC
312 * @tc.require: I5ST27
313 */
314 HWTEST_F(FormMgrTest, FormMgrTest_0010, TestSize.Level1) {
315 GTEST_LOG_(INFO) << "FormMgrTest_0010 starts";
316 EXPECT_CALL(*mockProxy, NotifyFormsPrivacyProtected(_, _, _))
317 .Times(1)
318 .WillOnce(Return(0));
319 // initialize input parameters.
320 int64_t formId1 = 3;
321 int64_t formId2 = 4;
322 std::vector<int64_t> formIds;
323 formIds.push_back(formId1);
324 formIds.push_back(formId2);
325 bool isProtected = false;
326 sptr<MockFormToken> token = new (std::nothrow) MockFormToken();
327 int32_t result = FormMgr::GetInstance().NotifyFormsPrivacyProtected(formIds, isProtected, token);
328 // expect result.
329 EXPECT_EQ(result, 0);
330 GTEST_LOG_(INFO) << "FormMgrTest_0010 test ends";
331 }
332
333 /**
334 * @tc.name: FormMgrTest_0011
335 * @tc.desc: Verify NotifyFormsPrivacyProtected
336 * @tc.type: FUNC
337 * @tc.require: I5ST27
338 */
339 HWTEST_F(FormMgrTest, FormMgrTest_0011, TestSize.Level1) {
340 GTEST_LOG_(INFO) << "FormMgrTest_0008 starts";
341 EXPECT_CALL(*mockProxy, NotifyFormsPrivacyProtected(_, _, _))
342 .Times(1)
343 .WillOnce(Return(0));
344 // initialize input parameters.
345 int64_t formId1 = 5;
346 int64_t formId2 = 6;
347 std::vector<int64_t> formIds;
348 formIds.push_back(formId1);
349 formIds.push_back(formId2);
350 bool isProtected = true;
351 sptr<MockFormToken> token = new (std::nothrow) MockFormToken();
352 int32_t result = FormMgr::GetInstance().NotifyFormsPrivacyProtected(formIds, isProtected, token);
353 // expect result.
354 EXPECT_EQ(result, 0);
355 GTEST_LOG_(INFO) << "FormMgrTest_0011 test ends";
356 }
357
358 /**
359 * @tc.name: FormMgrTest_0012
360 * @tc.desc: Verify GetErrorMsg
361 * @tc.type: FUNC
362 */
363 HWTEST_F(FormMgrTest, FormMgrTest_0012, TestSize.Level1) {
364 GTEST_LOG_(INFO) << "FormMgrTest_0012 starts";
365 int errorCode = 0;
366 auto result = FormMgr::GetInstance().GetErrorMsg(errorCode);
367
368 EXPECT_EQ(result, "unknown error");
369 GTEST_LOG_(INFO) << "FormMgrTest_0012 test ends";
370 }
371
372 /**
373 * @tc.name: FormMgrTest_0013
374 * @tc.desc: Verify DumpStorageFormInfos
375 * @tc.type: FUNC
376 */
377 HWTEST_F(FormMgrTest, FormMgrTest_0013, TestSize.Level1) {
378 GTEST_LOG_(INFO) << "FormMgrTest_0013 starts";
379 EXPECT_CALL(*mockProxy, DumpStorageFormInfos(_))
380 .Times(1)
381 .WillOnce(Return(0));
382 std::string formInfos = "a";
383 auto result = FormMgr::GetInstance().DumpStorageFormInfos(formInfos);
384
385 EXPECT_EQ(result, 0);
386 GTEST_LOG_(INFO) << "FormMgrTest_0013 test ends";
387 }
388
389 /**
390 * @tc.name: FormMgrTest_0014
391 * @tc.desc: Verify DumpFormInfoByFormId
392 * @tc.type: FUNC
393 */
394 HWTEST_F(FormMgrTest, FormMgrTest_0014, TestSize.Level1) {
395 GTEST_LOG_(INFO) << "FormMgrTest_0014 starts";
396 EXPECT_CALL(*mockProxy, DumpFormInfoByFormId(_, _))
397 .Times(1)
398 .WillOnce(Return(0));
399 std::string formInfos = "a";
400 std::int64_t formId = 3;
401 auto result = FormMgr::GetInstance().DumpFormInfoByFormId(formId, formInfos);
402
403 EXPECT_EQ(result, 0);
404 GTEST_LOG_(INFO) << "FormMgrTest_0014 test ends";
405 }
406
407 /**
408 * @tc.name: FormMgrTest_0015
409 * @tc.desc: Verify DumpFormTimerByFormId
410 * @tc.type: FUNC
411 */
412 HWTEST_F(FormMgrTest, FormMgrTest_0015, TestSize.Level1) {
413 GTEST_LOG_(INFO) << "FormMgrTest_0015 starts";
414 EXPECT_CALL(*mockProxy, DumpFormTimerByFormId(_, _))
415 .Times(1)
416 .WillOnce(Return(0));
417 std::string isTimingService = "b";
418 std::int64_t formId = 3;
419 auto result = FormMgr::GetInstance().DumpFormTimerByFormId(formId, isTimingService);
420
421 EXPECT_EQ(result, 0);
422 GTEST_LOG_(INFO) << "FormMgrTest_0015 test ends";
423 }
424
425 /**
426 * @tc.name: FormMgrTest_0016
427 * @tc.desc: Verify RouterEvent
428 * @tc.type: FUNC
429 */
430 HWTEST_F(FormMgrTest, FormMgrTest_0016, TestSize.Level1) {
431 GTEST_LOG_(INFO) << "FormMgrTest_0016 starts";
432 EXPECT_CALL(*mockProxy, RouterEvent(_, _, _))
433 .Times(1)
434 .WillOnce(Return(0));
435 Want want;
436 want = want.SetElementName("", "com.example.FormAbility", "MainAbility");
437 sptr<MockFormToken> token = new (std::nothrow) MockFormToken();
438 FormJsInfo formJsInfo;
439 sptr<IRemoteObject> providerToken = new (std::nothrow) MockFormProviderClient();
440 FormCallerMgr::GetInstance().AddFormHostCaller(formJsInfo, providerToken);
441 int32_t result = FormMgr::GetInstance().RouterEvent(formJsInfo.formId, want, token);
442
443 EXPECT_EQ(result, 0);
444 GTEST_LOG_(INFO) << "FormMgrTest_0016 test ends";
445 }
446
447 /**
448 * @tc.name: FormMgrTest_0017
449 * @tc.desc: Verify SetNextRefreshTime
450 * @tc.type: FUNC
451 */
452 HWTEST_F(FormMgrTest, FormMgrTest_0017, TestSize.Level1) {
453 GTEST_LOG_(INFO) << "FormMgrTest_0017 starts";
454 int64_t formId = 1;
455 int64_t nextTime = 2;
456 auto result = FormMgr::GetInstance().SetNextRefreshTime(formId, nextTime);
457
458 EXPECT_EQ(result, 0);
459 GTEST_LOG_(INFO) << "FormMgrTest_0017 test ends";
460 }
461
462 /**
463 * @tc.name: FormMgrTest_0018
464 * @tc.desc: Verify GetErrorMessage
465 * @tc.type: FUNC
466 */
467 HWTEST_F(FormMgrTest, FormMgrTest_0018, TestSize.Level1) {
468 GTEST_LOG_(INFO) << "FormMgrTest_0018 starts";
469 FormErrors::GetInstance().InitErrorMessageMap();
470 int errCode = ERR_APPEXECFWK_FORM_PERMISSION_DENY;
471 auto result = FormMgr::GetInstance().GetErrorMessage(errCode);
472
473 EXPECT_EQ(result, "check permission deny, need to request ohos.permission.REQUIRE_FORM "
474 "or ohos.permission.INTERACT_ACROSS_LOCAL_ACCOUNTS.");
475 GTEST_LOG_(INFO) << "FormMgrTest_0018 test ends";
476 }
477
478 /**
479 * @tc.name: FormMgrTest_0019
480 * @tc.desc: Verify DeleteInvalidForms
481 * @tc.type: FUNC
482 */
483 HWTEST_F(FormMgrTest, FormMgrTest_0019, TestSize.Level1) {
484 GTEST_LOG_(INFO) << "FormMgrTest_0019 starts";
485 EXPECT_CALL(*mockProxy, DeleteInvalidForms(_, _, _))
486 .Times(1)
487 .WillOnce(Return(0));
488 std::vector<int64_t> formInfos;
489 formInfos.push_back(1);
490 formInfos.push_back(2);
491 FormJsInfo formJsInfo;
492 sptr<MockFormToken> token = new (std::nothrow) MockFormToken();
493 int32_t numFormsDeleted = 2;
494 auto result = FormMgr::GetInstance().DeleteInvalidForms(formInfos, token, numFormsDeleted);
495
496 EXPECT_EQ(result, 0);
497 GTEST_LOG_(INFO) << "FormMgrTest_0019 test ends";
498 }
499
500 /**
501 * @tc.name: FormMgrTest_0020
502 * @tc.desc: Verify DumpStorageFormInfos
503 * @tc.type: FUNC
504 */
505 HWTEST_F(FormMgrTest, FormMgrTest_0020, TestSize.Level1) {
506 GTEST_LOG_(INFO) << "FormMgrTest_0020 starts";
507 EXPECT_CALL(*mockProxy, NotifyFormsVisible(_, _, _))
508 .Times(1)
509 .WillOnce(Return(0));
510 int64_t formId1 = 5;
511 int64_t formId2 = 6;
512 std::vector<int64_t> formIds;
513 formIds.push_back(formId1);
514 formIds.push_back(formId2);
515 bool isProtected = true;
516 sptr<MockFormToken> token = new (std::nothrow) MockFormToken();
517 int32_t result = FormMgr::GetInstance().NotifyFormsVisible(formIds, isProtected, token);
518
519 EXPECT_EQ(result, 0);
520 GTEST_LOG_(INFO) << "FormMgrTest_0020 test ends";
521 }
522
523 /**
524 * @tc.name: FormMgrTest_0021
525 * @tc.desc: Verify NotifyFormsEnableUpdate
526 * @tc.type: FUNC
527 */
528 HWTEST_F(FormMgrTest, FormMgrTest_0021, TestSize.Level1) {
529 GTEST_LOG_(INFO) << "FormMgrTest_0021 starts";
530 EXPECT_CALL(*mockProxy, NotifyFormsEnableUpdate(_, _, _))
531 .Times(1)
532 .WillOnce(Return(0));
533 int64_t formId1 = 3;
534 int64_t formId2 = 4;
535 std::vector<int64_t> formIds;
536 formIds.push_back(formId1);
537 formIds.push_back(formId2);
538 bool isProtected = true;
539 sptr<MockFormToken> token = new (std::nothrow) MockFormToken();
540 int32_t result = FormMgr::GetInstance().NotifyFormsEnableUpdate(formIds, isProtected, token);
541
542 EXPECT_EQ(result, 0);
543 GTEST_LOG_(INFO) << "FormMgrTest_0021 test ends";
544 }
545
546 /**
547 * @tc.name: FormMgrTest_0022
548 * @tc.desc: Verify GetAllFormsInfo
549 * @tc.type: FUNC
550 */
551 HWTEST_F(FormMgrTest, FormMgrTest_0022, TestSize.Level1) {
552 GTEST_LOG_(INFO) << "FormMgrTest_0022 starts";
553 EXPECT_CALL(*mockProxy, GetAllFormsInfo(_))
554 .Times(1)
555 .WillOnce(Return(0));
556 std::vector<FormInfo> formInfos;
557 std::vector<FormInfo> expectFormInfos;
558 FormInfo formInfo = {};
559 formInfo.bundleName = "ohos.samples.FormApplication";
560 formInfo.moduleName = "entry";
561 expectFormInfos.push_back(formInfo);
562 auto result = FormMgr::GetInstance().GetAllFormsInfo(formInfos);
563
564 EXPECT_EQ(result, 0);
565 GTEST_LOG_(INFO) << "FormMgrTest_0022 test ends";
566 }
567
568 /**
569 * @tc.name: FormMgrTest_0023
570 * @tc.desc: Verify GetFormsInfoByApp
571 * @tc.type: FUNC
572 */
573 HWTEST_F(FormMgrTest, FormMgrTest_0023, TestSize.Level1) {
574 GTEST_LOG_(INFO) << "FormMgrTest_0023 starts";
575 EXPECT_CALL(*mockProxy, GetFormsInfoByApp(_, _))
576 .Times(1)
577 .WillOnce(Return(0));
578 std::vector<FormInfo> formInfos;
579 std::vector<FormInfo> expectFormInfos;
580 FormInfo formInfo = {};
581 formInfo.bundleName = "ohos.samples.FormApplication";
582 formInfo.moduleName = "entry";
583 expectFormInfos.push_back(formInfo);
584 std::string bundleName = "a";
585 auto result = FormMgr::GetInstance().GetFormsInfoByApp(bundleName, formInfos);
586
587 EXPECT_EQ(result, 0);
588 GTEST_LOG_(INFO) << "FormMgrTest_0023 test ends";
589 }
590
591 /**
592 * @tc.name: FormMgrTest_0024
593 * @tc.desc: Verify GetFormsInfoByModule
594 * @tc.type: FUNC
595 */
596 HWTEST_F(FormMgrTest, FormMgrTest_0024, TestSize.Level1) {
597 GTEST_LOG_(INFO) << "FormMgrTest_0024 starts";
598 EXPECT_CALL(*mockProxy, GetFormsInfoByModule(_, _, _))
599 .Times(1)
600 .WillOnce(Return(0));
601 std::vector<FormInfo> formInfos;
602 std::vector<FormInfo> expectFormInfos;
603 FormInfo formInfo = {};
604 formInfo.bundleName = "ohos.samples.FormApplication";
605 formInfo.moduleName = "entry";
606 expectFormInfos.push_back(formInfo);
607 std::string bundleName = "a";
608 std::string moduleName = "A";
609 auto result = FormMgr::GetInstance().GetFormsInfoByModule(bundleName, moduleName, formInfos);
610
611 EXPECT_EQ(result, 0);
612 GTEST_LOG_(INFO) << "FormMgrTest_0024 test ends";
613 }
614
615 /**
616 * @tc.name: FormMgrTest_0025
617 * @tc.desc: Verify CheckFMSReady
618 * @tc.type: FUNC
619 */
620 HWTEST_F(FormMgrTest, FormMgrTest_0025, TestSize.Level1) {
621 GTEST_LOG_(INFO) << "FormMgrTest_0025 starts";
622 EXPECT_CALL(*mockProxy, CheckFMSReady())
623 .Times(1)
624 .WillOnce(Return(true));
625
626 auto result = FormMgr::GetInstance().CheckFMSReady();
627 EXPECT_TRUE(result);
628 GTEST_LOG_(INFO) << "FormMgrTest_0025 test ends";
629 }
630
631 /**
632 * @tc.name: FormMgrTest_0026
633 * @tc.desc: Verify DumpFormInfoByBundleName
634 * @tc.type: FUNC
635 */
636 HWTEST_F(FormMgrTest, FormMgrTest_0026, TestSize.Level1) {
637 GTEST_LOG_(INFO) << "FormMgrTest_0026 starts";
638 EXPECT_CALL(*mockProxy, DumpFormInfoByBundleName(_, _))
639 .Times(1)
640 .WillOnce(Return(0));
641 std::string bundleName = "b";
642 std::string formInfos = "a";
643 auto result = FormMgr::GetInstance().DumpFormInfoByBundleName(bundleName, formInfos);
644
645 EXPECT_EQ(result, 0);
646 GTEST_LOG_(INFO) << "FormMgrTest_0026 test ends";
647 }
648
649 /**
650 * @tc.name: FormMgrTest_0027
651 * @tc.desc: Verify AcquireFormState
652 * @tc.type: FUNC
653 */
654 HWTEST_F(FormMgrTest, FormMgrTest_0027, TestSize.Level1) {
655 GTEST_LOG_(INFO) << "FormMgrTest_0027 starts";
656 EXPECT_CALL(*mockProxy, AcquireFormState(_, _, _))
657 .Times(1)
658 .WillOnce(Return(0));
659 Want want;
660 want = want.SetElementName("", "com.example.FormAbility", "MainAbility");
661 sptr<MockFormToken> token = new (std::nothrow) MockFormToken();
662 FormStateInfo stateInfo;
663 auto result = FormMgr::GetInstance().AcquireFormState(want, token, stateInfo);
664
665 EXPECT_EQ(result, 0);
666 GTEST_LOG_(INFO) << "FormMgrTest_0027 test ends";
667 }
668
669 /**
670 * @tc.name: FormMgrTest_0028
671 * @tc.desc: Verify DeleteForm
672 * @tc.type: FUNC
673 * @tc.require: issueI63OQL
674 */
675 HWTEST_F(FormMgrTest, FormMgrTest_0028, TestSize.Level1) {
676 GTEST_LOG_(INFO) << "FormMgrTest_0028 starts";
677 int64_t formId = 1;
678 sptr<MockFormToken> token = new (std::nothrow) MockFormToken();
679 FormMgr::GetInstance().SetRecoverStatus(Constants::IN_RECOVERING);
680 int result = FormMgr::GetInstance().DeleteForm(formId, token);
681
682 EXPECT_EQ(result, ERR_APPEXECFWK_FORM_SERVER_STATUS_ERR);
683 GTEST_LOG_(INFO) << "FormMgrTest_0028 test ends";
684 }
685
686 /**
687 * @tc.name: FormMgrTest_0029
688 * @tc.desc: Verify ReleaseForm
689 * @tc.type: FUNC
690 * @tc.require: issueI63OQL
691 */
692 HWTEST_F(FormMgrTest, FormMgrTest_0029, TestSize.Level1) {
693 GTEST_LOG_(INFO) << "FormMgrTest_0029 starts";
694 int64_t formId = 1;
695 sptr<MockFormToken> token = new (std::nothrow) MockFormToken();
696 bool delCache = true;
697 FormMgr::GetInstance().SetRecoverStatus(Constants::IN_RECOVERING);
698 int result = FormMgr::GetInstance().ReleaseForm(formId, token, delCache);
699
700 EXPECT_EQ(result, ERR_APPEXECFWK_FORM_SERVER_STATUS_ERR);
701 GTEST_LOG_(INFO) << "FormMgrTest_0029 test ends";
702 }
703
704 /**
705 * @tc.name: FormMgrTest_0030
706 * @tc.desc: Verify ReleaseForm
707 * @tc.type: FUNC
708 * @tc.require: issueI63OQL
709 */
710 HWTEST_F(FormMgrTest, FormMgrTest_0030, TestSize.Level1) {
711 GTEST_LOG_(INFO) << "FormMgrTest_0030 starts";
712 int64_t formId = -1;
713 sptr<MockFormToken> token = new (std::nothrow) MockFormToken();
714 bool delCache = true;
715 FormMgr::GetInstance().SetRecoverStatus(Constants::NOT_IN_RECOVERY);
716 int result = FormMgr::GetInstance().ReleaseForm(formId, token, delCache);
717
718 EXPECT_EQ(result, ERR_APPEXECFWK_FORM_INVALID_FORM_ID);
719 GTEST_LOG_(INFO) << "FormMgrTest_0030 test ends";
720 }
721
722 /**
723 * @tc.name: FormMgrTest_0031
724 * @tc.desc: Verify UpdateForm
725 * @tc.type: FUNC
726 * @tc.require: issueI63OQL
727 */
728 HWTEST_F(FormMgrTest, FormMgrTest_0031, TestSize.Level1) {
729 GTEST_LOG_(INFO) << "FormMgrTest_0031 starts";
730 int64_t formId = 1;
731 FormProviderData formBindingData;
732 FormMgr::GetInstance().SetRecoverStatus(Constants::IN_RECOVERING);
733 int result = FormMgr::GetInstance().UpdateForm(formId, formBindingData);
734
735 EXPECT_EQ(result, ERR_APPEXECFWK_FORM_SERVER_STATUS_ERR);
736 GTEST_LOG_(INFO) << "FormMgrTest_0031 test ends";
737 }
738
739 /**
740 * @tc.name: FormMgrTest_0032
741 * @tc.desc: Verify UpdateForm
742 * @tc.type: FUNC
743 * @tc.require: issueI63OQL
744 */
745 HWTEST_F(FormMgrTest, FormMgrTest_0032, TestSize.Level1) {
746 GTEST_LOG_(INFO) << "FormMgrTest_0032 starts";
747 int64_t formId = -1;
748 FormProviderData formBindingData;
749 FormMgr::GetInstance().SetRecoverStatus(Constants::NOT_IN_RECOVERY);
750 int result = FormMgr::GetInstance().UpdateForm(formId, formBindingData);
751
752 EXPECT_EQ(result, ERR_APPEXECFWK_FORM_INVALID_FORM_ID);
753 GTEST_LOG_(INFO) << "FormMgrTest_0032 test ends";
754 }
755
756 /**
757 * @tc.name: FormMgrTest_0033
758 * @tc.desc: Verify UpdateForm
759 * @tc.type: FUNC
760 * @tc.require: issueI63OQL
761 */
762 HWTEST_F(FormMgrTest, FormMgrTest_0033, TestSize.Level1) {
763 GTEST_LOG_(INFO) << "FormMgrTest_0033 starts";
764 int64_t formId = 1;
765 FormProviderData formBindingData;
766 FormMgr::GetInstance().SetRecoverStatus(Constants::NOT_IN_RECOVERY);
767 int result = FormMgr::GetInstance().UpdateForm(formId, formBindingData);
768
769 EXPECT_EQ(result, ERR_APPEXECFWK_FORM_PROVIDER_DATA_EMPTY);
770 GTEST_LOG_(INFO) << "FormMgrTest_0033 test ends";
771 }
772
773 /**
774 * @tc.name: FormMgrTest_0034
775 * @tc.desc: Verify RequestForm
776 * @tc.type: FUNC
777 * @tc.require: issueI63OQL
778 */
779 HWTEST_F(FormMgrTest, FormMgrTest_0034, TestSize.Level1) {
780 GTEST_LOG_(INFO) << "FormMgrTest_0034 starts";
781 int64_t formId = 1;
782 Want want;
783 want = want.SetElementName("", "com.example.FormAbility", "MainAbility");
784 sptr<MockFormToken> token = new (std::nothrow) MockFormToken();
785 FormMgr::GetInstance().SetRecoverStatus(Constants::IN_RECOVERING);
786 int result = FormMgr::GetInstance().RequestForm(formId, token, want);
787
788 EXPECT_EQ(result, ERR_APPEXECFWK_FORM_SERVER_STATUS_ERR);
789 GTEST_LOG_(INFO) << "FormMgrTest_0034 test ends";
790 }
791
792 /**
793 * @tc.name: FormMgrTest_0035
794 * @tc.desc: Verify RequestForm
795 * @tc.type: FUNC
796 * @tc.require: issueI63OQL
797 */
798 HWTEST_F(FormMgrTest, FormMgrTest_0035, TestSize.Level1) {
799 GTEST_LOG_(INFO) << "FormMgrTest_0035 starts";
800 int64_t formId = -1;
801 Want want;
802 want = want.SetElementName("", "com.example.FormAbility", "MainAbility");
803 sptr<MockFormToken> token = new (std::nothrow) MockFormToken();
804 FormMgr::GetInstance().SetRecoverStatus(Constants::NOT_IN_RECOVERY);
805 int result = FormMgr::GetInstance().RequestForm(formId, token, want);
806
807 EXPECT_EQ(result, ERR_APPEXECFWK_FORM_INVALID_FORM_ID);
808 GTEST_LOG_(INFO) << "FormMgrTest_0035 test ends";
809 }
810
811 /**
812 * @tc.name: FormMgrTest_0036
813 * @tc.desc: Verify NotifyWhetherVisibleForms
814 * @tc.type: FUNC
815 * @tc.require: issueI63OQL
816 */
817 HWTEST_F(FormMgrTest, FormMgrTest_0036, TestSize.Level1) {
818 GTEST_LOG_(INFO) << "FormMgrTest_0036 starts";
819 std::vector<int64_t> formIds;
820 sptr<MockFormToken> token = new (std::nothrow) MockFormToken();
821 int32_t formVisibleType = 1;
822 FormMgr::GetInstance().SetRecoverStatus(Constants::NOT_IN_RECOVERY);
823 int result = FormMgr::GetInstance().NotifyWhetherVisibleForms(formIds, token, formVisibleType);
824
825 EXPECT_EQ(result, ERR_APPEXECFWK_FORM_INVALID_FORM_ID);
826 GTEST_LOG_(INFO) << "FormMgrTest_0036 test ends";
827 }
828
829 /**
830 * @tc.name: FormMgrTest_0037
831 * @tc.desc: Verify NotifyWhetherVisibleForms
832 * @tc.type: FUNC
833 * @tc.require: issueI63OQL
834 */
835 HWTEST_F(FormMgrTest, FormMgrTest_0037, TestSize.Level1) {
836 GTEST_LOG_(INFO) << "FormMgrTest_0037 starts";
837 std::vector<int64_t> formIds;
838 int64_t formId = 1;
839 formIds.emplace_back(formId);
840 sptr<MockFormToken> token = new (std::nothrow) MockFormToken();
841 int32_t formVisibleType = 1;
842 FormMgr::GetInstance().SetRecoverStatus(Constants::IN_RECOVERING);
843 int result = FormMgr::GetInstance().NotifyWhetherVisibleForms(formIds, token, formVisibleType);
844
845 EXPECT_EQ(result, ERR_APPEXECFWK_FORM_SERVER_STATUS_ERR);
846 GTEST_LOG_(INFO) << "FormMgrTest_0037 test ends";
847 }
848
849 /**
850 * @tc.name: FormMgrTest_0038
851 * @tc.desc: Verify SetNextRefreshTime
852 * @tc.type: FUNC
853 * @tc.require: issueI63OQL
854 */
855 HWTEST_F(FormMgrTest, FormMgrTest_0038, TestSize.Level1) {
856 GTEST_LOG_(INFO) << "FormMgrTest_0038 starts";
857 int64_t formId = 10;
858 int64_t nextTime = 50;
859 FormMgr::GetInstance().SetRecoverStatus(Constants::IN_RECOVERING);
860 int result = FormMgr::GetInstance().SetNextRefreshTime(formId, nextTime);
861
862 EXPECT_EQ(result, ERR_APPEXECFWK_FORM_SERVER_STATUS_ERR);
863 GTEST_LOG_(INFO) << "FormMgrTest_0038 test ends";
864 }
865
866 /**
867 * @tc.name: FormMgrTest_0039
868 * @tc.desc: Verify LifecycleUpdate
869 * @tc.type: FUNC
870 * @tc.require: issueI63OQL
871 */
872 HWTEST_F(FormMgrTest, FormMgrTest_0039, TestSize.Level1) {
873 GTEST_LOG_(INFO) << "FormMgrTest_0039 starts";
874 std::vector<int64_t> formIds;
875 int64_t formId = 1;
876 formIds.emplace_back(formId);
877 sptr<MockFormToken> token = new (std::nothrow) MockFormToken();
878 bool updateType = true;
879 FormMgr::GetInstance().SetRecoverStatus(Constants::IN_RECOVERING);
880 int result = FormMgr::GetInstance().LifecycleUpdate(formIds, token, updateType);
881
882 EXPECT_EQ(result, ERR_APPEXECFWK_FORM_SERVER_STATUS_ERR);
883 GTEST_LOG_(INFO) << "FormMgrTest_0039 test ends";
884 }
885
886 /**
887 * @tc.name: FormMgrTest_0040
888 * @tc.desc: Verify RegisterDeathCallback
889 * @tc.type: FUNC
890 * @tc.require: issueI63OQL
891 */
892 HWTEST_F(FormMgrTest, FormMgrTest_0040, TestSize.Level1) {
893 GTEST_LOG_(INFO) << "FormMgrTest_0040 starts";
894 std::shared_ptr<FormMgr> formMgr = std::make_shared<FormMgr>();
895 ASSERT_NE(nullptr, formMgr);
896 formMgr->RegisterDeathCallback(nullptr);
897 formMgr->UnRegisterDeathCallback(nullptr);
898 formMgr->SetRecoverStatus(Constants::IN_RECOVERING);
899 GTEST_LOG_(INFO) << "FormMgrTest_0040 test ends";
900 }
901
902 /**
903 * @tc.name: FormMgrTest_0041
904 * @tc.desc: Verify DeleteInvalidForms
905 * @tc.type: FUNC
906 * @tc.require: issueI63OQL
907 */
908 HWTEST_F(FormMgrTest, FormMgrTest_0041, TestSize.Level1) {
909 GTEST_LOG_(INFO) << "FormMgrTest_0041 starts";
910 std::vector<int64_t> formIds;
911 int64_t formId = 1;
912 formIds.emplace_back(formId);
913 sptr<MockFormToken> token = new (std::nothrow) MockFormToken();
914 int32_t numFormsDeleted = 2;
915 FormMgr::GetInstance().SetRecoverStatus(Constants::IN_RECOVERING);
916 int result = FormMgr::GetInstance().DeleteInvalidForms(formIds, token, numFormsDeleted);
917
918 EXPECT_EQ(result, ERR_APPEXECFWK_FORM_SERVER_STATUS_ERR);
919 GTEST_LOG_(INFO) << "FormMgrTest_0041 test ends";
920 }
921
922 /**
923 * @tc.name: FormMgrTest_0042
924 * @tc.desc: Verify AcquireFormState
925 * @tc.type: FUNC
926 * @tc.require: issueI63OQL
927 */
928 HWTEST_F(FormMgrTest, FormMgrTest_0042, TestSize.Level1) {
929 GTEST_LOG_(INFO) << "FormMgrTest_0042 starts";
930 Want want;
931 want = want.SetElementName("", "com.example.FormAbility", "MainAbility");
932 sptr<MockFormToken> token = new (std::nothrow) MockFormToken();
933 FormStateInfo stateInfo;
934 FormMgr::GetInstance().SetRecoverStatus(Constants::IN_RECOVERING);
935 int result = FormMgr::GetInstance().AcquireFormState(want, token, stateInfo);
936
937 EXPECT_EQ(result, ERR_APPEXECFWK_FORM_SERVER_STATUS_ERR);
938 GTEST_LOG_(INFO) << "FormMgrTest_0042 test ends";
939 }
940
941 /**
942 * @tc.name: FormMgrTest_0043
943 * @tc.desc: Verify NotifyFormsVisible
944 * @tc.type: FUNC
945 * @tc.require: issueI63OQL
946 */
947 HWTEST_F(FormMgrTest, FormMgrTest_0043, TestSize.Level1) {
948 GTEST_LOG_(INFO) << "FormMgrTest_0043 starts";
949 std::vector<int64_t> formIds;
950 int64_t formId = 1;
951 formIds.emplace_back(formId);
952 bool isVisible = true;
953 sptr<MockFormToken> token = new (std::nothrow) MockFormToken();
954 FormMgr::GetInstance().SetRecoverStatus(Constants::IN_RECOVERING);
955 int result = FormMgr::GetInstance().NotifyFormsVisible(formIds, isVisible, token);
956
957 EXPECT_EQ(result, ERR_APPEXECFWK_FORM_SERVER_STATUS_ERR);
958 GTEST_LOG_(INFO) << "FormMgrTest_0043 test ends";
959 }
960
961 /**
962 * @tc.name: FormMgrTest_0044
963 * @tc.desc: Verify NotifyFormsPrivacyProtected
964 * @tc.type: FUNC
965 * @tc.require: issueI63OQL
966 */
967 HWTEST_F(FormMgrTest, FormMgrTest_0044, TestSize.Level1) {
968 GTEST_LOG_(INFO) << "FormMgrTest_0044 starts";
969 std::vector<int64_t> formIds;
970 int64_t formId = 1;
971 formIds.emplace_back(formId);
972 bool isProtected = true;
973 sptr<MockFormToken> token = new (std::nothrow) MockFormToken();
974 FormMgr::GetInstance().SetRecoverStatus(Constants::IN_RECOVERING);
975 int result = FormMgr::GetInstance().NotifyFormsPrivacyProtected(formIds, isProtected, token);
976
977 EXPECT_EQ(result, ERR_APPEXECFWK_FORM_SERVER_STATUS_ERR);
978 GTEST_LOG_(INFO) << "FormMgrTest_0044 test ends";
979 }
980
981 /**
982 * @tc.name: FormMgrTest_0045
983 * @tc.desc: Verify NotifyFormsEnableUpdate
984 * @tc.type: FUNC
985 * @tc.require: issueI63OQL
986 */
987 HWTEST_F(FormMgrTest, FormMgrTest_0045, TestSize.Level1) {
988 GTEST_LOG_(INFO) << "FormMgrTest_0045 starts";
989 std::vector<int64_t> formIds;
990 int64_t formId = 1;
991 formIds.emplace_back(formId);
992 bool isEnableUpdate = true;
993 sptr<MockFormToken> token = new (std::nothrow) MockFormToken();
994 FormMgr::GetInstance().SetRecoverStatus(Constants::IN_RECOVERING);
995 int result = FormMgr::GetInstance().NotifyFormsEnableUpdate(formIds, isEnableUpdate, token);
996
997 EXPECT_EQ(result, ERR_APPEXECFWK_FORM_SERVER_STATUS_ERR);
998 GTEST_LOG_(INFO) << "FormMgrTest_0045 test ends";
999 }
1000
1001 /**
1002 * @tc.name: FormMgrTest_0046
1003 * @tc.desc: Verify GetAllFormsInfo
1004 * @tc.type: FUNC
1005 * @tc.require: issueI63OQL
1006 */
1007 HWTEST_F(FormMgrTest, FormMgrTest_0046, TestSize.Level1) {
1008 GTEST_LOG_(INFO) << "FormMgrTest_0046 starts";
1009 std::vector<FormInfo> formInfos;
1010 FormMgr::GetInstance().SetRecoverStatus(Constants::IN_RECOVERING);
1011 int result = FormMgr::GetInstance().GetAllFormsInfo(formInfos);
1012
1013 EXPECT_EQ(result, ERR_APPEXECFWK_FORM_SERVER_STATUS_ERR);
1014 GTEST_LOG_(INFO) << "FormMgrTest_0046 test ends";
1015 }
1016
1017 /**
1018 * @tc.name: FormMgrTest_0047
1019 * @tc.desc: Verify GetFormsInfoByApp
1020 * @tc.type: FUNC
1021 * @tc.require: issueI63OQL
1022 */
1023 HWTEST_F(FormMgrTest, FormMgrTest_0047, TestSize.Level1) {
1024 GTEST_LOG_(INFO) << "FormMgrTest_0047 starts";
1025 std::string bundleName = "this is bundleName";
1026 std::vector<FormInfo> formInfos;
1027 FormMgr::GetInstance().SetRecoverStatus(Constants::IN_RECOVERING);
1028 int result = FormMgr::GetInstance().GetFormsInfoByApp(bundleName, formInfos);
1029
1030 EXPECT_EQ(result, ERR_APPEXECFWK_FORM_SERVER_STATUS_ERR);
1031 GTEST_LOG_(INFO) << "FormMgrTest_0047 test ends";
1032 }
1033
1034 /**
1035 * @tc.name: FormMgrTest_0048
1036 * @tc.desc: Verify GetFormsInfoByApp
1037 * @tc.type: FUNC
1038 * @tc.require: issueI63OQL
1039 */
1040 HWTEST_F(FormMgrTest, FormMgrTest_0048, TestSize.Level1) {
1041 GTEST_LOG_(INFO) << "FormMgrTest_0048 starts";
1042 std::string bundleName = "";
1043 std::vector<FormInfo> formInfos;
1044 FormMgr::GetInstance().SetRecoverStatus(Constants::NOT_IN_RECOVERY);
1045 int result = FormMgr::GetInstance().GetFormsInfoByApp(bundleName, formInfos);
1046
1047 EXPECT_EQ(result, ERR_APPEXECFWK_FORM_INVALID_BUNDLENAME);
1048 GTEST_LOG_(INFO) << "FormMgrTest_0048 test ends";
1049 }
1050
1051 /**
1052 * @tc.name: FormMgrTest_0050
1053 * @tc.desc: Verify GetFormsInfoByModule
1054 * @tc.type: FUNC
1055 * @tc.require: issueI63OQL
1056 */
1057 HWTEST_F(FormMgrTest, FormMgrTest_0050, TestSize.Level1) {
1058 GTEST_LOG_(INFO) << "FormMgrTest_0050 starts";
1059 std::string bundleName = "";
1060 std::string moduleName = "this is moduleName";
1061 std::vector<FormInfo> formInfos;
1062 FormMgr::GetInstance().SetRecoverStatus(Constants::NOT_IN_RECOVERY);
1063 int result = FormMgr::GetInstance().GetFormsInfoByModule(bundleName, moduleName, formInfos);
1064
1065 EXPECT_EQ(result, ERR_APPEXECFWK_FORM_INVALID_BUNDLENAME);
1066 GTEST_LOG_(INFO) << "FormMgrTest_0050 test ends";
1067 }
1068
1069 /**
1070 * @tc.name: FormMgrTest_0051
1071 * @tc.desc: Verify GetFormsInfoByModule
1072 * @tc.type: FUNC
1073 * @tc.require: issueI63OQL
1074 */
1075 HWTEST_F(FormMgrTest, FormMgrTest_0051, TestSize.Level1) {
1076 GTEST_LOG_(INFO) << "FormMgrTest_0051 starts";
1077 std::string bundleName = "this is bundleName";
1078 std::string moduleName = "";
1079 std::vector<FormInfo> formInfos;
1080 FormMgr::GetInstance().SetRecoverStatus(Constants::NOT_IN_RECOVERY);
1081 int result = FormMgr::GetInstance().GetFormsInfoByModule(bundleName, moduleName, formInfos);
1082
1083 EXPECT_EQ(result, ERR_APPEXECFWK_FORM_INVALID_MODULENAME);
1084 GTEST_LOG_(INFO) << "FormMgrTest_0051 test ends";
1085 }
1086
1087 /**
1088 * @tc.name: FormMgrTest_0052
1089 * @tc.desc: Verify GetFormsInfoByModule
1090 * @tc.type: FUNC
1091 * @tc.require: issueI63OQL
1092 */
1093 HWTEST_F(FormMgrTest, FormMgrTest_0052, TestSize.Level1) {
1094 GTEST_LOG_(INFO) << "FormMgrTest_0052 starts";
1095 std::string bundleName = "this is bundleName";
1096 std::string moduleName = "this is moduleName";
1097 std::vector<FormInfo> formInfos;
1098 FormMgr::GetInstance().SetRecoverStatus(Constants::IN_RECOVERING);
1099 int result = FormMgr::GetInstance().GetFormsInfoByModule(bundleName, moduleName, formInfos);
1100
1101 EXPECT_EQ(result, ERR_APPEXECFWK_FORM_SERVER_STATUS_ERR);
1102 GTEST_LOG_(INFO) << "FormMgrTest_0052 test ends";
1103 }
1104
1105 /**
1106 * @tc.name: FormMgrTest_0053
1107 * @tc.desc: Verify GetErrorMessage
1108 * @tc.type: FUNC
1109 * @tc.require: issueI63Y7Y
1110 */
1111 HWTEST_F(FormMgrTest, FormMgrTest_0053, TestSize.Level1) {
1112 GTEST_LOG_(INFO) << "FormMgrTest_0053 starts";
1113 FormErrors::GetInstance().InitErrorMessageMap();
1114 int errCode = ERR_APPEXECFWK_FORM_COMMON_CODE;
1115 auto result = FormMgr::GetInstance().GetErrorMessage(errCode);
1116
1117 EXPECT_EQ(result, "some internal server error occurs.");
1118 GTEST_LOG_(INFO) << "FormMgrTest_0053 test ends";
1119 }
1120
1121 /**
1122 * @tc.name: FormMgrTest_0054
1123 * @tc.desc: Verify AddForm
1124 * @tc.type: FUNC
1125 * @tc.require: issueI63Y7Y
1126 */
1127 HWTEST_F(FormMgrTest, FormMgrTest_0054, TestSize.Level1)
1128 {
1129 GTEST_LOG_(INFO) << "FormMgrTest_0054 starts";
1130 int64_t formId = 10;
1131 Want want;
1132 FormJsInfo formInfo;
1133 sptr<MockFormToken> token = new (std::nothrow) MockFormToken();
1134 auto data = FormMgr::GetInstance().AddForm(formId, want, token, formInfo);
1135 EXPECT_EQ(data, ERROR_NUMS);
1136 GTEST_LOG_(INFO) << "FormMgrTest_0054 test ends";
1137 }
1138
1139 /**
1140 * @tc.name: FormMgrTest_0055
1141 * @tc.desc: Verify DeleteForm (ID <= 0)
1142 * @tc.type: FUNC
1143 * @tc.require: issueI63Y7Y
1144 */
1145 HWTEST_F(FormMgrTest, FormMgrTest_0055, TestSize.Level1)
1146 {
1147 GTEST_LOG_(INFO) << "FormMgrTest_0055 starts";
1148 int64_t formId = -1;
1149 sptr<MockFormToken> token = new (std::nothrow) MockFormToken();
1150 FormMgr::GetInstance().SetRecoverStatus(Constants::NOT_IN_RECOVERY);
1151 int result = FormMgr::GetInstance().DeleteForm(formId, token);
1152 EXPECT_EQ(result, ERR_APPEXECFWK_FORM_INVALID_FORM_ID);
1153 GTEST_LOG_(INFO) << "FormMgrTest_0055 test ends";
1154 }
1155
1156 /**
1157 * @tc.name: FormMgrTest_0056
1158 * @tc.desc: Verify DeleteForm (Parameters are normal.)
1159 * @tc.type: FUNC
1160 * @tc.require: issueI63Y7Y
1161 */
1162 HWTEST_F(FormMgrTest, FormMgrTest_0056, TestSize.Level1)
1163 {
1164 GTEST_LOG_(INFO) << "FormMgrTest_0056 starts";
1165 EXPECT_CALL(*mockProxy, DeleteForm(_, _))
1166 .Times(1)
1167 .WillOnce(Return(OHOS::ERR_OK));
1168 int64_t formId = 1;
1169 sptr<MockFormToken> token = new (std::nothrow) MockFormToken();
1170 FormMgr::GetInstance().SetRecoverStatus(Constants::NOT_IN_RECOVERY);
1171 int result = FormMgr::GetInstance().DeleteForm(formId, token);
1172 EXPECT_EQ(result, OHOS::ERR_OK);
1173 GTEST_LOG_(INFO) << "FormMgrTest_0056 test ends";
1174 }
1175
1176 /**
1177 * @tc.name: FormMgrTest_0057
1178 * @tc.desc: Verify ReleaseForm (Parameters are normal.)
1179 * @tc.type: FUNC
1180 * @tc.require: issueI63Y7Y
1181 */
1182 HWTEST_F(FormMgrTest, FormMgrTest_0057, TestSize.Level1)
1183 {
1184 GTEST_LOG_(INFO) << "FormMgrTest_0057 starts";
1185 EXPECT_CALL(*mockProxy, ReleaseForm(_, _, _))
1186 .Times(1)
1187 .WillOnce(Return(OHOS::ERR_OK));
1188 int64_t formId = 1;
1189 sptr<MockFormToken> token = new (std::nothrow) MockFormToken();
1190 bool delCache = true;
1191 FormMgr::GetInstance().SetRecoverStatus(Constants::NOT_IN_RECOVERY);
1192 int result = FormMgr::GetInstance().ReleaseForm(formId, token, delCache);
1193 EXPECT_EQ(result, OHOS::ERR_OK);
1194 GTEST_LOG_(INFO) << "FormMgrTest_0057 test ends";
1195 }
1196
1197 /**
1198 * @tc.name: FormMgrTest_0058
1199 * @tc.desc: Verify UpdateForm (Parameter formId exception)
1200 * @tc.type: FUNC
1201 * @tc.require: issueI63Y7Y
1202 */
1203 HWTEST_F(FormMgrTest, FormMgrTest_0058, TestSize.Level1) {
1204 GTEST_LOG_(INFO) << "FormMgrTest_0058 starts";
1205 EXPECT_CALL(*mockProxy, UpdateForm(_, _))
1206 .Times(1)
1207 .WillOnce(Return(NEGATIVE_NUM));
1208 FormJsInfo formJsInfo;
1209 formJsInfo.formId = 0x00000008fffffffL;
1210 FormProviderData formProviderData = FormProviderData(std::string("{\"city\": \"beijing001\"}"));
1211 int32_t result = FormMgr::GetInstance().UpdateForm(formJsInfo.formId, formProviderData);
1212 EXPECT_EQ(result, NEGATIVE_NUM);
1213 GTEST_LOG_(INFO) << "FormMgrTest_0058 test ends";
1214 }
1215
1216 /**
1217 * @tc.name: FormMgrTest_0059
1218 * @tc.desc: Verify RequestForm (Parameter formId exception)
1219 * @tc.type: FUNC
1220 * @tc.require: issueI63Y7Y
1221 */
1222 HWTEST_F(FormMgrTest, FormMgrTest_0059, TestSize.Level1) {
1223 GTEST_LOG_(INFO) << "FormMgrTest_0059 starts";
1224 EXPECT_CALL(*mockProxy, RequestForm(_, _, _))
1225 .Times(1)
1226 .WillOnce(Return(NEGATIVE_NUM));
1227 Want want;
1228 want = want.SetElementName("", "com.example.FormAbility", "MainAbility");
1229 sptr<MockFormToken> token = new (std::nothrow) MockFormToken();
1230 FormJsInfo formJsInfo;
1231 formJsInfo.formId = 0x00000008fffffffL;
1232 int32_t result = FormMgr::GetInstance().RequestForm(formJsInfo.formId, token, want);
1233 EXPECT_EQ(result, NEGATIVE_NUM);
1234 GTEST_LOG_(INFO) << "FormMgrTest_0059 test ends";
1235 }
1236
1237 /**
1238 * @tc.name: FormMgrTest_0060
1239 * @tc.desc: Verify NotifyWhetherVisibleForms (Parameters are normal, the return value of mock function is 0)
1240 * @tc.type: FUNC
1241 * @tc.require: issueI63Y7Y
1242 */
1243 HWTEST_F(FormMgrTest, FormMgrTest_0060, TestSize.Level1) {
1244 GTEST_LOG_(INFO) << "FormMgrTest_0060 starts";
1245 EXPECT_CALL(*mockProxy, NotifyWhetherVisibleForms(_, _, _))
1246 .Times(1)
1247 .WillOnce(Return(OHOS::ERR_OK));
1248 std::vector<int64_t> formIds;
1249 int64_t formId = 1;
1250 formIds.emplace_back(formId);
1251 sptr<MockFormToken> token = new (std::nothrow) MockFormToken();
1252 int32_t formVisibleType = 1;
1253 FormMgr::GetInstance().SetRecoverStatus(Constants::NOT_IN_RECOVERY);
1254 int result = FormMgr::GetInstance().NotifyWhetherVisibleForms(formIds, token, formVisibleType);
1255 EXPECT_EQ(result, OHOS::ERR_OK);
1256 GTEST_LOG_(INFO) << "FormMgrTest_0060 test ends";
1257 }
1258
1259 /**
1260 * @tc.name: FormMgrTest_0061
1261 * @tc.desc: Verify NotifyWhetherVisibleForms (Parameters are normal, the return value of mock function is not 0)
1262 * @tc.type: FUNC
1263 * @tc.require: issueI63Y7Y
1264 */
1265 HWTEST_F(FormMgrTest, FormMgrTest_0061, TestSize.Level1) {
1266 GTEST_LOG_(INFO) << "FormMgrTest_0061 starts";
1267 EXPECT_CALL(*mockProxy, NotifyWhetherVisibleForms(_, _, _))
1268 .Times(1)
1269 .WillOnce(Return(POSITIVE_NUM));
1270 std::vector<int64_t> formIds;
1271 int64_t formId = 1;
1272 formIds.emplace_back(formId);
1273 sptr<MockFormToken> token = new (std::nothrow) MockFormToken();
1274 int32_t formVisibleType = 1;
1275 FormMgr::GetInstance().SetRecoverStatus(Constants::NOT_IN_RECOVERY);
1276 int result = FormMgr::GetInstance().NotifyWhetherVisibleForms(formIds, token, formVisibleType);
1277 EXPECT_EQ(result, POSITIVE_NUM);
1278 GTEST_LOG_(INFO) << "FormMgrTest_0061 test ends";
1279 }
1280
1281 /**
1282 * @tc.name: FormMgrTest_0062
1283 * @tc.desc: Verify CastTempForm (Parameters are normal, the return value of mock function is 0)
1284 * @tc.type: FUNC
1285 * @tc.require: issueI63Y7Y
1286 */
1287 HWTEST_F(FormMgrTest, FormMgrTest_0062, TestSize.Level1) {
1288 GTEST_LOG_(INFO) << "FormMgrTest_0062 starts";
1289 EXPECT_CALL(*mockProxy, CastTempForm(_, _))
1290 .Times(1)
1291 .WillOnce(Return(OHOS::ERR_OK));
1292 int64_t formId = 1;
1293 sptr<MockFormToken> token = new (std::nothrow) MockFormToken();
1294 int result = FormMgr::GetInstance().CastTempForm(formId, token);
1295 EXPECT_EQ(result, OHOS::ERR_OK);
1296 GTEST_LOG_(INFO) << "FormMgrTest_0062 test ends";
1297 }
1298
1299 /**
1300 * @tc.name: FormMgrTest_0063
1301 * @tc.desc: Verify CastTempForm (Parameters are normal, the return value of mock function is not 0)
1302 * @tc.type: FUNC
1303 * @tc.require: issueI63Y7Y
1304 */
1305 HWTEST_F(FormMgrTest, FormMgrTest_0063, TestSize.Level1) {
1306 GTEST_LOG_(INFO) << "FormMgrTest_0063 starts";
1307 EXPECT_CALL(*mockProxy, CastTempForm(_, _))
1308 .Times(1)
1309 .WillOnce(Return(POSITIVE_NUM));
1310 int64_t formId = 1;
1311 sptr<MockFormToken> token = new (std::nothrow) MockFormToken();
1312 int result = FormMgr::GetInstance().CastTempForm(formId, token);
1313 EXPECT_EQ(result, POSITIVE_NUM);
1314 GTEST_LOG_(INFO) << "FormMgrTest_0063 test ends";
1315 }
1316
1317 /**
1318 * @tc.name: FormMgrTest_0064
1319 * @tc.desc: Verify CastTempForm (formId <= 0)
1320 * @tc.type: FUNC
1321 * @tc.require: issueI63Y7Y
1322 */
1323 HWTEST_F(FormMgrTest, FormMgrTest_0064, TestSize.Level1) {
1324 GTEST_LOG_(INFO) << "FormMgrTest_0064 starts";
1325
1326 int64_t formId = -1;
1327 sptr<MockFormToken> token = new (std::nothrow) MockFormToken();
1328 int result = FormMgr::GetInstance().CastTempForm(formId, token);
1329 EXPECT_EQ(result, ERR_APPEXECFWK_FORM_INVALID_FORM_ID);
1330 GTEST_LOG_(INFO) << "FormMgrTest_0064 test ends";
1331 }
1332
1333 /**
1334 * @tc.name: FormMgrTest_0065
1335 * @tc.desc: Verify RegisterDeathCallback (Parameter is not nullptr)
1336 * @tc.type: FUNC
1337 * @tc.require: issueI63Y7Y
1338 */
1339 HWTEST_F(FormMgrTest, FormMgrTest_0065, TestSize.Level1) {
1340 GTEST_LOG_(INFO) << "FormMgrTest_0065 starts";
1341 std::shared_ptr<FormMgr> formMgr = std::make_shared<FormMgr>();
1342 ASSERT_NE(nullptr, formMgr);
1343 std::shared_ptr<FormInterfaceCallbackTest> callback = std::make_shared<FormInterfaceCallbackTest>();
1344 std::shared_ptr<FormInterfaceCallbackTest> callback_first = std::make_shared<FormInterfaceCallbackTest>();
1345 formMgr->formDeathCallbacks_.emplace_back(callback);
1346 formMgr->formDeathCallbacks_.emplace_back(callback_first);
1347 formMgr->RegisterDeathCallback(callback);
1348 GTEST_LOG_(INFO) << "FormMgrTest_0065 test ends";
1349 }
1350
1351 /**
1352 * @tc.name: FormMgrTest_0066
1353 * @tc.desc: Verify UnRegisterDeathCallback (Parameter is not nullptr)
1354 * @tc.type: FUNC
1355 * @tc.require: issueI63Y7Y
1356 */
1357 HWTEST_F(FormMgrTest, FormMgrTest_0066, TestSize.Level1) {
1358 GTEST_LOG_(INFO) << "FormMgrTest_0066 starts";
1359 std::shared_ptr<FormMgr> formMgr = std::make_shared<FormMgr>();
1360 ASSERT_NE(nullptr, formMgr);
1361 std::shared_ptr<FormInterfaceCallbackTest> callback = std::make_shared<FormInterfaceCallbackTest>();
1362 std::shared_ptr<FormInterfaceCallbackTest> callback_first = std::make_shared<FormInterfaceCallbackTest>();
1363 formMgr->formDeathCallbacks_.emplace_back(callback);
1364 formMgr->formDeathCallbacks_.emplace_back(callback_first);
1365 formMgr->UnRegisterDeathCallback(callback);
1366 GTEST_LOG_(INFO) << "FormMgrTest_0066 test ends";
1367 }
1368
1369 /**
1370 * @tc.name: FormMgrTest_0067
1371 * @tc.desc: Verify GetDeathRecipient
1372 * @tc.type: FUNC
1373 * @tc.require: issueI63Y7Y
1374 */
1375 HWTEST_F(FormMgrTest, FormMgrTest_0067, TestSize.Level1)
1376 {
1377 GTEST_LOG_(INFO) << "FormMgrTest_0067 starts";
1378 auto data = FormMgr::GetInstance().GetDeathRecipient();
1379 EXPECT_TRUE(data == FormMgr::GetInstance().deathRecipient_);
1380 GTEST_LOG_(INFO) << "FormMgrTest_0067 test ends";
1381 }
1382
1383 /**
1384 * @tc.name: FormMgrTest_0068
1385 * @tc.desc: Verify CheckIsDeathCallbackRegistered (Parameter is nullptr)
1386 * @tc.type: FUNC
1387 * @tc.require: issueI63Y7Y
1388 */
1389 HWTEST_F(FormMgrTest, FormMgrTest_0068, TestSize.Level1) {
1390 GTEST_LOG_(INFO) << "FormMgrTest_0068 starts";
1391 bool data = FormMgr::GetInstance().CheckIsDeathCallbackRegistered(nullptr);
1392 EXPECT_TRUE(data == false);
1393 GTEST_LOG_(INFO) << "FormMgrTest_0068 test ends";
1394 }
1395
1396 /**
1397 * @tc.name: FormMgrTest_0069
1398 * @tc.desc: Verify CheckIsDeathCallbackRegistered (Parameter is not nullptr)
1399 * @tc.type: FUNC
1400 * @tc.require: issueI63Y7Y
1401 */
1402 HWTEST_F(FormMgrTest, FormMgrTest_0069, TestSize.Level1) {
1403 GTEST_LOG_(INFO) << "FormMgrTest_0069 starts";
1404 std::shared_ptr<FormInterfaceCallbackTest> callback = std::make_shared<FormInterfaceCallbackTest>();
1405 std::shared_ptr<FormInterfaceCallbackTest> callback_first = std::make_shared<FormInterfaceCallbackTest>();
1406 std::shared_ptr<FormInterfaceCallbackTest> callback_second = std::make_shared<FormInterfaceCallbackTest>();
1407 bool result = FormMgr::GetInstance().CheckIsDeathCallbackRegistered(callback_first);
1408 EXPECT_TRUE(result == false);
1409 FormMgr::GetInstance().formDeathCallbacks_.emplace_back(callback_first);
1410 FormMgr::GetInstance().formDeathCallbacks_.emplace_back(callback_second);
1411 bool data = FormMgr::GetInstance().CheckIsDeathCallbackRegistered(callback_first);
1412 EXPECT_TRUE(data);
1413 GTEST_LOG_(INFO) << "FormMgrTest_0069 test ends";
1414 }
1415
1416 /**
1417 * @tc.name: FormMgrTest_0070
1418 * @tc.desc: Verify CheckIsDeathCallbackRegistered (Parameter exception)
1419 * @tc.type: FUNC
1420 * @tc.require: issueI63Y7Y
1421 */
1422 HWTEST_F(FormMgrTest, FormMgrTest_0070, TestSize.Level1) {
1423 GTEST_LOG_(INFO) << "FormMgrTest_0070 starts";
1424 std::shared_ptr<FormInterfaceCallbackTest> callback = std::make_shared<FormInterfaceCallbackTest>();
1425 std::shared_ptr<FormInterfaceCallbackTest> callback_first = std::make_shared<FormInterfaceCallbackTest>();
1426 std::shared_ptr<FormInterfaceCallbackTest> callback_second = std::make_shared<FormInterfaceCallbackTest>();
1427 FormMgr::GetInstance().formDeathCallbacks_.emplace_back(callback_first);
1428 FormMgr::GetInstance().formDeathCallbacks_.emplace_back(callback_second);
1429 bool data = FormMgr::GetInstance().CheckIsDeathCallbackRegistered(callback);
1430 EXPECT_TRUE(data == false);
1431 GTEST_LOG_(INFO) << "FormMgrTest_0070 test ends";
1432 }
1433
1434 /**
1435 * @tc.name: FormMgrTest_0071
1436 * @tc.desc: Verify OnRemoteDied
1437 * @tc.type: FUNC
1438 * @tc.require: issueI63Y7Y
1439 */
1440 HWTEST_F(FormMgrTest, FormMgrTest_0071, TestSize.Level1) {
1441 GTEST_LOG_(INFO) << "FormMgrTest_0071 starts";
1442 sptr<IRemoteObject> mockFormProviderClient = new (std::nothrow) MockFormProviderClient();
1443 sptr<FormMgr::FormMgrDeathRecipient> formMgrDeath = new (std::nothrow) FormMgr::FormMgrDeathRecipient();
1444 FormMgr::GetInstance().SetRecoverStatus(Constants::IN_RECOVERING);
1445 formMgrDeath->OnRemoteDied(mockFormProviderClient);
1446 EXPECT_TRUE(FormMgr::GetInstance().GetRecoverStatus() == Constants::IN_RECOVERING);
1447 GTEST_LOG_(INFO) << "FormMgrTest_0071 test ends";
1448 }
1449
1450 /**
1451 * @tc.name: FormMgrTest_0072
1452 * @tc.desc: Verify OnRemoteDied (Parameter is nullptr)
1453 * @tc.type: FUNC
1454 * @tc.require: issueI63Y7Y
1455 */
1456 HWTEST_F(FormMgrTest, FormMgrTest_0072, TestSize.Level1) {
1457 GTEST_LOG_(INFO) << "FormMgrTest_0072 starts";
1458 sptr<FormMgr::FormMgrDeathRecipient> formMgrDeath = new (std::nothrow) FormMgr::FormMgrDeathRecipient();
1459 formMgrDeath->OnRemoteDied(nullptr);
1460 GTEST_LOG_(INFO) << "FormMgrTest_0072 test ends";
1461 }
1462
1463 /**
1464 * @tc.name: FormMgrTest_0073
1465 * @tc.desc: Verify Reconnect
1466 * @tc.type: FUNC
1467 * @tc.require: issueI63Y7Y
1468 */
1469 HWTEST_F(FormMgrTest, FormMgrTest_0073, TestSize.Level1) {
1470 GTEST_LOG_(INFO) << "FormMgrTest_0073 starts";
1471 bool data = FormMgr::GetInstance().Reconnect();
1472 EXPECT_EQ(data, true);
1473 GTEST_LOG_(INFO) << "FormMgrTest_0073 test ends";
1474 }
1475
1476 /**
1477 * @tc.name: FormMgrTest_0074
1478 * @tc.desc: Verify ResetProxy (Parameter is nullptr)
1479 * @tc.type: FUNC
1480 * @tc.require: issueI63Y7Y
1481 */
1482 HWTEST_F(FormMgrTest, FormMgrTest_0074, TestSize.Level1) {
1483 GTEST_LOG_(INFO) << "FormMgrTest_0074 starts";
1484 std::shared_ptr<FormMgr> formMgr = std::make_shared<FormMgr>();
1485 ASSERT_NE(nullptr, formMgr);
1486 formMgr->ResetProxy(nullptr);
1487 formMgr->SetFormMgrService(mockProxy);
1488 GTEST_LOG_(INFO) << "FormMgrTest_0074 test ends";
1489 }
1490
1491 /**
1492 * @tc.name: FormMgrTest_0075
1493 * @tc.desc: Verify ResetProxy
1494 * @tc.type: FUNC
1495 * @tc.require: issueI63Y7Y
1496 */
1497 HWTEST_F(FormMgrTest, FormMgrTest_0075, TestSize.Level1) {
1498 GTEST_LOG_(INFO) << "FormMgrTest_0075 starts";
1499 sptr<IRemoteObject> remote = new (std::nothrow) MockFormProviderClient();
1500 FormMgr::GetInstance().ResetProxy(remote);
1501 EXPECT_TRUE(FormMgr::GetInstance().GetRecoverStatus() == Constants::IN_RECOVERING);
1502 FormMgr::GetInstance().SetFormMgrService(mockProxy);
1503 GTEST_LOG_(INFO) << "FormMgrTest_0075 test ends";
1504 }
1505
1506 /**
1507 * @tc.name: FormMgrTest_0076
1508 * @tc.desc: Verify DeleteInvalidForms (The return value of mock function is not 0)
1509 * @tc.type: FUNC
1510 * @tc.require: issueI63Y7Y
1511 */
1512 HWTEST_F(FormMgrTest, FormMgrTest_0076, TestSize.Level1) {
1513 GTEST_LOG_(INFO) << "FormMgrTest_0076 starts";
1514
1515 std::vector<int64_t> formInfos;
1516 formInfos.push_back(1);
1517 formInfos.push_back(2);
1518 FormJsInfo formJsInfo;
1519 sptr<MockFormToken> token = new (std::nothrow) MockFormToken();
1520 int32_t numFormsDeleted = 2;
1521 auto result = FormMgr::GetInstance().DeleteInvalidForms(formInfos, token, numFormsDeleted);
1522 EXPECT_EQ(result, ERROR_NUM);
1523 GTEST_LOG_(INFO) << "FormMgrTest_0076 test ends";
1524 }
1525
1526 /**
1527 * @tc.name: FormMgrTest_0077
1528 * @tc.desc: Verify AcquireFormState (The return value of mock function is not 0)
1529 * @tc.type: FUNC
1530 * @tc.require: issueI63Y7Y
1531 */
1532 HWTEST_F(FormMgrTest, FormMgrTest_0077, TestSize.Level1) {
1533 GTEST_LOG_(INFO) << "FormMgrTest_0077 starts";
1534
1535 Want want;
1536 want = want.SetElementName("", "com.example.FormAbility", "MainAbility");
1537 sptr<MockFormToken> token = new (std::nothrow) MockFormToken();
1538 FormStateInfo stateInfo;
1539 auto result = FormMgr::GetInstance().AcquireFormState(want, token, stateInfo);
1540 EXPECT_EQ(result, ERROR_NUM);
1541 GTEST_LOG_(INFO) << "FormMgrTest_0077 test ends";
1542 }
1543
1544 /**
1545 * @tc.name: FormMgrTest_0078
1546 * @tc.desc: Verify NotifyFormsVisible (The return value of mock function is not 0)
1547 * @tc.type: FUNC
1548 * @tc.require: issueI63Y7Y
1549 */
1550 HWTEST_F(FormMgrTest, FormMgrTest_0078, TestSize.Level1) {
1551 GTEST_LOG_(INFO) << "FormMgrTest_0078 starts";
1552
1553 int64_t formId1 = 5;
1554 int64_t formId2 = 6;
1555 std::vector<int64_t> formIds;
1556 formIds.push_back(formId1);
1557 formIds.push_back(formId2);
1558 bool isProtected = true;
1559 sptr<MockFormToken> token = new (std::nothrow) MockFormToken();
1560 int32_t result = FormMgr::GetInstance().NotifyFormsVisible(formIds, isProtected, token);
1561 EXPECT_EQ(result, ERROR_NUM);
1562 GTEST_LOG_(INFO) << "FormMgrTest_0078 test ends";
1563 }
1564
1565 /**
1566 * @tc.name: FormMgrTest_0079
1567 * @tc.desc: Verify NotifyFormsPrivacyProtected (The return value of mock function is not 0)
1568 * @tc.type: FUNC
1569 * @tc.require: issueI63Y7Y
1570 */
1571 HWTEST_F(FormMgrTest, FormMgrTest_0079, TestSize.Level1) {
1572 GTEST_LOG_(INFO) << "FormMgrTest_0079 starts";
1573
1574 int64_t formId = 1;
1575 std::vector<int64_t> formIds;
1576 formIds.push_back(formId);
1577 bool isProtected = false;
1578 sptr<MockFormToken> token = new (std::nothrow) MockFormToken();
1579 int32_t result = FormMgr::GetInstance().NotifyFormsPrivacyProtected(formIds, isProtected, token);
1580 EXPECT_EQ(result, ERROR_NUM);
1581 GTEST_LOG_(INFO) << "FormMgrTest_0079 test ends";
1582 }
1583
1584 /**
1585 * @tc.name: FormMgrTest_0080
1586 * @tc.desc: Verify NotifyFormsEnableUpdate (The return value of mock function is not 0)
1587 * @tc.type: FUNC
1588 * @tc.require: issueI63Y7Y
1589 */
1590 HWTEST_F(FormMgrTest, FormMgrTest_0080, TestSize.Level1) {
1591 GTEST_LOG_(INFO) << "FormMgrTest_0080 starts";
1592
1593 int64_t formId1 = 3;
1594 int64_t formId2 = 4;
1595 std::vector<int64_t> formIds;
1596 formIds.push_back(formId1);
1597 formIds.push_back(formId2);
1598 bool isProtected = true;
1599 sptr<MockFormToken> token = new (std::nothrow) MockFormToken();
1600 int32_t result = FormMgr::GetInstance().NotifyFormsEnableUpdate(formIds, isProtected, token);
1601 EXPECT_EQ(result, ERROR_NUM);
1602 GTEST_LOG_(INFO) << "FormMgrTest_0080 test ends";
1603 }
1604
1605 /**
1606 * @tc.name: FormMgrTest_0081
1607 * @tc.desc: Verify GetAllFormsInfo (The return value of mock function is not 0)
1608 * @tc.type: FUNC
1609 * @tc.require: issueI63Y7Y
1610 */
1611 HWTEST_F(FormMgrTest, FormMgrTest_0081, TestSize.Level1) {
1612 GTEST_LOG_(INFO) << "FormMgrTest_0081 starts";
1613
1614 std::vector<FormInfo> formInfos;
1615 std::vector<FormInfo> expectFormInfos;
1616 FormInfo formInfo = {};
1617 formInfo.bundleName = "ohos.samples.FormApplication";
1618 formInfo.moduleName = "entry";
1619 expectFormInfos.push_back(formInfo);
1620 auto result = FormMgr::GetInstance().GetAllFormsInfo(formInfos);
1621 EXPECT_EQ(result, ERROR_NUM);
1622 GTEST_LOG_(INFO) << "FormMgrTest_0081 test ends";
1623 }
1624
1625 /**
1626 * @tc.name: FormMgrTest_0082
1627 * @tc.desc: Verify GetFormsInfoByApp (The return value of mock function is not 0)
1628 * @tc.type: FUNC
1629 * @tc.require: issueI63Y7Y
1630 */
1631 HWTEST_F(FormMgrTest, FormMgrTest_0082, TestSize.Level1) {
1632 GTEST_LOG_(INFO) << "FormMgrTest_0082 starts";
1633
1634 std::vector<FormInfo> formInfos;
1635 std::vector<FormInfo> expectFormInfos;
1636 FormInfo formInfo = {};
1637 formInfo.bundleName = "ohos.samples.FormApplication";
1638 formInfo.moduleName = "entry";
1639 expectFormInfos.push_back(formInfo);
1640 std::string bundleName = "a";
1641 auto result = FormMgr::GetInstance().GetFormsInfoByApp(bundleName, formInfos);
1642 EXPECT_EQ(result, ERROR_NUM);
1643 GTEST_LOG_(INFO) << "FormMgrTest_0082 test ends";
1644 }
1645
1646 /**
1647 * @tc.name: FormMgrTest_0083
1648 * @tc.desc: Verify GetFormsInfoByModule (The return value of mock function is not 0)
1649 * @tc.type: FUNC
1650 * @tc.require: issueI63Y7Y
1651 */
1652 HWTEST_F(FormMgrTest, FormMgrTest_0083, TestSize.Level1) {
1653 GTEST_LOG_(INFO) << "FormMgrTest_0083 starts";
1654
1655 std::vector<FormInfo> formInfos;
1656 std::vector<FormInfo> expectFormInfos;
1657 FormInfo formInfo = {};
1658 formInfo.bundleName = "ohos.samples.FormApplication";
1659 formInfo.moduleName = "entry";
1660 expectFormInfos.push_back(formInfo);
1661 std::string bundleName = "a";
1662 std::string moduleName = "A";
1663 auto result = FormMgr::GetInstance().GetFormsInfoByModule(bundleName, moduleName, formInfos);
1664 EXPECT_EQ(result, ERROR_NUM);
1665 GTEST_LOG_(INFO) << "FormMgrTest_0083 test ends";
1666 }
1667
1668 /**
1669 * @tc.name: FormMgrTest_0084
1670 * @tc.desc: Verify CheckFMSReady (mock function returns nullptr)
1671 * @tc.type: FUNC
1672 * @tc.require: issueI63Y7Y
1673 */
1674 HWTEST_F(FormMgrTest, FormMgrTest_0084, TestSize.Level1) {
1675 GTEST_LOG_(INFO) << "FormMgrTest_0084 starts";
1676 sptr<MockSystemAbilityManager> mockSamgr = new (std::nothrow) MockSystemAbilityManager();
1677 sptr<ISystemAbilityManager> backupSamgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
1678 SystemAbilityManagerClient::GetInstance().systemAbilityManager_ = mockSamgr;
1679 std::shared_ptr<bool> dummyVal = std::make_shared<bool>(true);
1680 mockSamgr->weakGetSystemAbility_ = dummyVal;
1681 auto result = FormMgr::GetInstance().CheckFMSReady();
1682 EXPECT_TRUE(result == false);
1683 GTEST_LOG_(INFO) << "FormMgrTest_0084 test ends";
1684 }
1685
1686 /**
1687 * @tc.name: FormMgrTest_0085
1688 * @tc.desc: Verify ShareForm (The return value of mock function is 0)
1689 * @tc.type: FUNC
1690 * @tc.require: issueI63Y7Y
1691 */
1692 HWTEST_F(FormMgrTest, FormMgrTest_0085, TestSize.Level1) {
1693 GTEST_LOG_(INFO) << "FormMgrTest_0085 starts";
1694 EXPECT_CALL(*mockProxy, ShareForm(_, _, _, _))
1695 .Times(1)
1696 .WillOnce(Return(OHOS::ERR_OK));
1697 int64_t formId = 0;
1698 std::string deviceId = "aa";
1699 int64_t requestCode = 1;
1700 sptr<IRemoteObject> Token = new (std::nothrow) MockFormProviderClient();
1701 auto result = FormMgr::GetInstance().ShareForm(formId, deviceId, Token, requestCode);
1702 EXPECT_EQ(result, OHOS::ERR_OK);
1703 GTEST_LOG_(INFO) << "FormMgrTest_0085 test ends";
1704 }
1705
1706 /**
1707 * @tc.name: FormMgrTest_0086
1708 * @tc.desc: Verify GetFormsCount
1709 * @tc.type: FUNC
1710 * @tc.require: issueI63OQL
1711 */
1712 HWTEST_F(FormMgrTest, FormMgrTest_0086, TestSize.Level1) {
1713 GTEST_LOG_(INFO) << "FormMgrTest_0086 starts";
1714 bool isTempFormFlag = true;
1715 int32_t formCount = 0;
1716 FormMgr::GetInstance().SetRecoverStatus(Constants::IN_RECOVERING);
1717 int result = FormMgr::GetInstance().GetFormsCount(isTempFormFlag, formCount);
1718
1719 EXPECT_EQ(result, ERR_APPEXECFWK_FORM_SERVER_STATUS_ERR);
1720 GTEST_LOG_(INFO) << "FormMgrTest_0086 test ends";
1721 }
1722
1723 /**
1724 * @tc.name: FormMgrTest_0087
1725 * @tc.desc: Verify GetFormsCount
1726 * @tc.type: FUNC
1727 * @tc.require: issueI63OQL
1728 */
1729 HWTEST_F(FormMgrTest, FormMgrTest_0087, TestSize.Level1) {
1730 GTEST_LOG_(INFO) << "FormMgrTest_0087 starts";
1731 bool isTempFormFlag = true;
1732 int32_t formCount = 0;
1733 FormMgr::GetInstance().SetRecoverStatus(Constants::NOT_IN_RECOVERY);
1734 int result = FormMgr::GetInstance().GetFormsCount(isTempFormFlag, formCount);
1735
1736 EXPECT_EQ(result, 0);
1737 GTEST_LOG_(INFO) << "FormMgrTest_0087 test ends";
1738 }
1739
1740 /**
1741 * @tc.name: FormMgrTest_0088
1742 * @tc.desc: Verify GetHostFormsCount
1743 * @tc.type: FUNC
1744 * @tc.require: issueI63OQL
1745 */
1746 HWTEST_F(FormMgrTest, FormMgrTest_0088, TestSize.Level1) {
1747 GTEST_LOG_(INFO) << "FormMgrTest_0088 starts";
1748 std::string bundleName = "this is bundleName";
1749 int32_t formCount = 0;
1750 FormMgr::GetInstance().SetRecoverStatus(Constants::IN_RECOVERING);
1751 int result = FormMgr::GetInstance().GetHostFormsCount(bundleName, formCount);
1752
1753 EXPECT_EQ(result, ERR_APPEXECFWK_FORM_SERVER_STATUS_ERR);
1754 GTEST_LOG_(INFO) << "FormMgrTest_0088 test ends";
1755 }
1756
1757 /**
1758 * @tc.name: FormMgrTest_0089
1759 * @tc.desc: Verify GetHostFormsCount
1760 * @tc.type: FUNC
1761 * @tc.require: issueI63OQL
1762 */
1763 HWTEST_F(FormMgrTest, FormMgrTest_0089, TestSize.Level1) {
1764 GTEST_LOG_(INFO) << "FormMgrTest_0089 starts";
1765 std::string bundleName = "";
1766 int32_t formCount = 0;
1767 FormMgr::GetInstance().SetRecoverStatus(Constants::NOT_IN_RECOVERY);
1768 int result = FormMgr::GetInstance().GetHostFormsCount(bundleName, formCount);
1769
1770 EXPECT_EQ(result, ERR_APPEXECFWK_FORM_INVALID_BUNDLENAME);
1771 GTEST_LOG_(INFO) << "FormMgrTest_0089 test ends";
1772 }
1773
1774 /**
1775 * @tc.name: FormMgrTest_0090
1776 * @tc.desc: Verify GetHostFormsCount
1777 * @tc.type: FUNC
1778 * @tc.require: issueI63OQL
1779 */
1780 HWTEST_F(FormMgrTest, FormMgrTest_0090, TestSize.Level1) {
1781 GTEST_LOG_(INFO) << "FormMgrTest_0090 starts";
1782 std::string bundleName = "this is bundleName";
1783 int32_t formCount = 0;
1784 FormMgr::GetInstance().SetRecoverStatus(Constants::NOT_IN_RECOVERY);
1785 int result = FormMgr::GetInstance().GetHostFormsCount(bundleName, formCount);
1786
1787 EXPECT_EQ(result, 0);
1788 GTEST_LOG_(INFO) << "FormMgrTest_0090 test ends";
1789 }
1790
1791 /**
1792 * @tc.name: FormMgrTest_0091
1793 * @tc.desc: Verify AcquireFormData (The return value of mock function is 0)
1794 * @tc.type: FUNC
1795 * @tc.require: issueI63Y7Y
1796 */
1797 HWTEST_F(FormMgrTest, FormMgrTest_0091, TestSize.Level1) {
1798 GTEST_LOG_(INFO) << "FormMgrTest_0091 starts";
1799 EXPECT_CALL(*mockProxy, AcquireFormData(_, _, _, _))
1800 .Times(1)
1801 .WillOnce(Return(OHOS::ERR_OK));
1802 int64_t formId = 0;
1803 int64_t requestCode = 1;
1804 AAFwk::WantParams formData;
1805 sptr<IRemoteObject> Token = new (std::nothrow) MockFormProviderClient();
1806 auto result = FormMgr::GetInstance().AcquireFormData(formId, requestCode, Token, formData);
1807 EXPECT_EQ(result, OHOS::ERR_OK);
1808 GTEST_LOG_(INFO) << "FormMgrTest_0091 test ends";
1809 }
1810
1811 /**
1812 * @tc.name: FormMgrTest_0092
1813 * @tc.desc: Verify GetRunningFormInfos
1814 * @tc.type: FUNC
1815 * @tc.require: issueI63OQL
1816 */
1817 HWTEST_F(FormMgrTest, FormMgrTest_0092, TestSize.Level1) {
1818 GTEST_LOG_(INFO) << "FormMgrTest_0092 starts";
1819 EXPECT_CALL(*mockProxy, GetRunningFormInfos(_, _))
1820 .Times(1)
1821 .WillOnce(Return(OHOS::ERR_OK));
1822 FormMgr::GetInstance().SetRecoverStatus(Constants::NOT_IN_RECOVERY);
1823
1824 std::vector<RunningFormInfo> runningFormInfos;
1825 bool isUnusedInclude = false;
1826 int result = FormMgr::GetInstance().GetRunningFormInfos(isUnusedInclude, runningFormInfos);
1827
1828 EXPECT_EQ(result, 0);
1829 GTEST_LOG_(INFO) << "FormMgrTest_0092 test ends";
1830 }
1831
1832 /**
1833 * @tc.name: FormMgrTest_0093
1834 * @tc.desc: Verify GetRunningFormInfos
1835 * @tc.type: FUNC
1836 * @tc.require: issueI63OQL
1837 */
1838 HWTEST_F(FormMgrTest, FormMgrTest_0093, TestSize.Level1) {
1839 GTEST_LOG_(INFO) << "FormMgrTest_0093 starts";
1840
1841 FormMgr::GetInstance().SetRecoverStatus(Constants::IN_RECOVERING);
1842
1843 std::vector<RunningFormInfo> runningFormInfos;
1844 bool isUnusedInclude = false;
1845 int result = FormMgr::GetInstance().GetRunningFormInfos(isUnusedInclude, runningFormInfos);
1846
1847 EXPECT_EQ(result, ERR_APPEXECFWK_FORM_SERVER_STATUS_ERR);
1848 GTEST_LOG_(INFO) << "FormMgrTest_0093 test ends";
1849 }
1850
1851 /**
1852 * @tc.name: FormMgrTest_0094
1853 * @tc.desc: Verify GetRunningFormInfos
1854 * @tc.type: FUNC
1855 * @tc.require: issueI63OQL
1856 */
1857 HWTEST_F(FormMgrTest, FormMgrTest_0094, TestSize.Level1) {
1858 GTEST_LOG_(INFO) << "FormMgrTest_0094 starts";
1859 FormMgr::GetInstance().SetRecoverStatus(Constants::NOT_IN_RECOVERY);
1860 EXPECT_CALL(*mockProxy, GetRunningFormInfos(_, _))
1861 .Times(1)
1862 .WillOnce(Return(ERROR_NUM));
1863 std::vector<RunningFormInfo> runningFormInfos;
1864 bool isUnusedInclude = false;
1865 int result = FormMgr::GetInstance().GetRunningFormInfos(isUnusedInclude, runningFormInfos);
1866
1867 EXPECT_EQ(result, ERROR_NUM);
1868 GTEST_LOG_(INFO) << "FormMgrTest_0094 test ends";
1869 }
1870
1871 /**
1872 * @tc.name: FormMgrTest_0095
1873 * @tc.desc: Verify GetRunningFormInfos
1874 * @tc.type: FUNC
1875 * @tc.require: issueI63OQL
1876 */
1877 HWTEST_F(FormMgrTest, FormMgrTest_0095, TestSize.Level1) {
1878 GTEST_LOG_(INFO) << "FormMgrTest_0095 starts";
1879 FormMgr::GetInstance().SetRecoverStatus(Constants::NOT_IN_RECOVERY);
1880 EXPECT_CALL(*mockProxy, GetRunningFormInfos(_, _))
1881 .Times(1)
1882 .WillOnce(Return(NEGATIVE_NUM));
1883 std::vector<RunningFormInfo> runningFormInfos;
1884 bool isUnusedInclude = false;
1885 int result = FormMgr::GetInstance().GetRunningFormInfos(isUnusedInclude, runningFormInfos);
1886
1887 EXPECT_EQ(result, NEGATIVE_NUM);
1888 GTEST_LOG_(INFO) << "FormMgrTest_0095 test ends";
1889 }
1890
1891 /**
1892 * @tc.name: FormMgrTest_0096
1893 * @tc.desc: Verify GetRunningFormInfos
1894 * @tc.type: FUNC
1895 * @tc.require: issueI63OQL
1896 */
1897 HWTEST_F(FormMgrTest, FormMgrTest_0096, TestSize.Level1) {
1898 GTEST_LOG_(INFO) << "FormMgrTest_0096 starts";
1899 EXPECT_CALL(*mockProxy, GetRunningFormInfosByBundleName(_, _, _))
1900 .Times(1)
1901 .WillOnce(Return(OHOS::ERR_OK));
1902 FormMgr::GetInstance().SetRecoverStatus(Constants::NOT_IN_RECOVERY);
1903
1904 std::string bundleName = "a";
1905 bool isUnusedInclude = false;
1906 std::vector<RunningFormInfo> runningFormInfos;
1907 int result = FormMgr::GetInstance().GetRunningFormInfosByBundleName(bundleName, isUnusedInclude, runningFormInfos);
1908
1909 EXPECT_EQ(result, 0);
1910 GTEST_LOG_(INFO) << "FormMgrTest_0096 test ends";
1911 }
1912
1913 /**
1914 * @tc.name: FormMgrTest_0097
1915 * @tc.desc: Verify GetRunningFormInfosByBundleName
1916 * @tc.type: FUNC
1917 * @tc.require: issueI63OQL
1918 */
1919 HWTEST_F(FormMgrTest, FormMgrTest_0097, TestSize.Level1) {
1920 GTEST_LOG_(INFO) << "FormMgrTest_0097 starts";
1921 EXPECT_CALL(*mockProxy, GetRunningFormInfosByBundleName(_, _, _))
1922 .Times(1)
1923 .WillOnce(Return(OHOS::ERR_OK));
1924 FormMgr::GetInstance().SetRecoverStatus(Constants::NOT_IN_RECOVERY);
1925 std::string bundleName = "a";
1926 bool isUnusedInclude = false;
1927 std::vector<RunningFormInfo> runningFormInfos;
1928 int result = FormMgr::GetInstance().GetRunningFormInfosByBundleName(bundleName, isUnusedInclude, runningFormInfos);
1929
1930 EXPECT_EQ(result, 0);
1931 GTEST_LOG_(INFO) << "FormMgrTest_0097 test ends";
1932 }
1933
1934 /**
1935 * @tc.name: FormMgrTest_0098
1936 * @tc.desc: Verify GetRunningFormInfosByBundleName
1937 * @tc.type: FUNC
1938 * @tc.require: issueI63OQL
1939 */
1940 HWTEST_F(FormMgrTest, FormMgrTest_0098, TestSize.Level1) {
1941 GTEST_LOG_(INFO) << "FormMgrTest_0098 starts";
1942
1943 FormMgr::GetInstance().SetRecoverStatus(Constants::IN_RECOVERING);
1944 std::string bundleName = "a";
1945 bool isUnusedInclude = false;
1946 std::vector<RunningFormInfo> runningFormInfos;
1947 int result = FormMgr::GetInstance().GetRunningFormInfosByBundleName(bundleName, isUnusedInclude, runningFormInfos);
1948
1949 EXPECT_EQ(result, ERR_APPEXECFWK_FORM_SERVER_STATUS_ERR);
1950 GTEST_LOG_(INFO) << "FormMgrTest_0098 test ends";
1951 }
1952
1953 /**
1954 * @tc.name: FormMgrTest_0099
1955 * @tc.desc: Verify GetRunningFormInfosByBundleName
1956 * @tc.type: FUNC
1957 * @tc.require: issueI63OQL
1958 */
1959 HWTEST_F(FormMgrTest, FormMgrTest_0099, TestSize.Level1) {
1960 GTEST_LOG_(INFO) << "FormMgrTest_0099 starts";
1961 FormMgr::GetInstance().SetRecoverStatus(Constants::NOT_IN_RECOVERY);
1962 EXPECT_CALL(*mockProxy, GetRunningFormInfosByBundleName(_, _, _))
1963 .Times(1)
1964 .WillOnce(Return(ERROR_NUM));
1965 std::string bundleName = "a";
1966 bool isUnusedInclude = false;
1967 std::vector<RunningFormInfo> runningFormInfos;
1968 int result = FormMgr::GetInstance().GetRunningFormInfosByBundleName(bundleName, isUnusedInclude, runningFormInfos);
1969
1970 EXPECT_EQ(result, ERROR_NUM);
1971 GTEST_LOG_(INFO) << "FormMgrTest_0099 test ends";
1972 }
1973
1974 /**
1975 * @tc.name: FormMgrTest_0100
1976 * @tc.desc: Verify RegisterFormAddObserverByBundle
1977 * @tc.type: FUNC
1978 * @tc.require: issueI63OQL
1979 */
1980 HWTEST_F(FormMgrTest, FormMgrTest_0100, TestSize.Level1) {
1981 GTEST_LOG_(INFO) << "FormMgrTest_0100 starts";
1982 EXPECT_CALL(*mockProxy, RegisterFormAddObserverByBundle(_, _))
1983 .Times(1)
1984 .WillOnce(Return(OHOS::ERR_OK));
1985 FormMgr::GetInstance().SetRecoverStatus(Constants::NOT_IN_RECOVERY);
1986 std::string bundleName = "a";
1987 sptr<IRemoteObject> callerToken = new (std::nothrow) MockFormProviderClient();
1988 int result = FormMgr::GetInstance().RegisterFormAddObserverByBundle(bundleName, callerToken);
1989
1990 EXPECT_EQ(result, 0);
1991 GTEST_LOG_(INFO) << "FormMgrTest_0100 test ends";
1992 }
1993
1994 /**
1995 * @tc.name: FormMgrTest_0101
1996 * @tc.desc: Verify RegisterFormAddObserverByBundle
1997 * @tc.type: FUNC
1998 * @tc.require: issueI63OQL
1999 */
2000 HWTEST_F(FormMgrTest, FormMgrTest_0101, TestSize.Level1) {
2001 GTEST_LOG_(INFO) << "FormMgrTest_0101 starts";
2002
2003 FormMgr::GetInstance().SetRecoverStatus(Constants::IN_RECOVERING);
2004 std::string bundleName = "a";
2005 sptr<IRemoteObject> callerToken = new (std::nothrow) MockFormProviderClient();
2006 int result = FormMgr::GetInstance().RegisterFormAddObserverByBundle(bundleName, callerToken);
2007
2008 EXPECT_EQ(result, ERR_APPEXECFWK_FORM_SERVER_STATUS_ERR);
2009 GTEST_LOG_(INFO) << "FormMgrTest_0101 test ends";
2010 }
2011
2012 /**
2013 * @tc.name: FormMgrTest_0102
2014 * @tc.desc: Verify RegisterFormAddObserverByBundle
2015 * @tc.type: FUNC
2016 * @tc.require: issueI63OQL
2017 */
2018 HWTEST_F(FormMgrTest, FormMgrTest_0102, TestSize.Level1) {
2019 GTEST_LOG_(INFO) << "FormMgrTest_0102 starts";
2020 EXPECT_CALL(*mockProxy, RegisterFormAddObserverByBundle(_, _))
2021 .Times(1)
2022 .WillOnce(Return(ERROR_NUM));
2023 FormMgr::GetInstance().SetRecoverStatus(Constants::NOT_IN_RECOVERY);
2024 std::string bundleName = "a";
2025 sptr<IRemoteObject> callerToken = new (std::nothrow) MockFormProviderClient();
2026 int result = FormMgr::GetInstance().RegisterFormAddObserverByBundle(bundleName, callerToken);
2027
2028 EXPECT_EQ(result, ERROR_NUM);
2029 GTEST_LOG_(INFO) << "FormMgrTest_0102 test ends";
2030 }
2031
2032 /**
2033 * @tc.name: FormMgrTest_0103
2034 * @tc.desc: Verify RegisterFormRemoveObserverByBundle
2035 * @tc.type: FUNC
2036 * @tc.require: issueI63OQL
2037 */
2038 HWTEST_F(FormMgrTest, FormMgrTest_0103, TestSize.Level1) {
2039 GTEST_LOG_(INFO) << "FormMgrTest_0103 starts";
2040 EXPECT_CALL(*mockProxy, RegisterFormRemoveObserverByBundle(_, _))
2041 .Times(1)
2042 .WillOnce(Return(OHOS::ERR_OK));
2043 FormMgr::GetInstance().SetRecoverStatus(Constants::NOT_IN_RECOVERY);
2044 std::string bundleName = "a";
2045 sptr<IRemoteObject> callerToken = new (std::nothrow) MockFormProviderClient();
2046 int result = FormMgr::GetInstance().RegisterFormRemoveObserverByBundle(bundleName, callerToken);
2047
2048 EXPECT_EQ(result, 0);
2049 GTEST_LOG_(INFO) << "FormMgrTest_0103 test ends";
2050 }
2051
2052 /**
2053 * @tc.name: FormMgrTest_0104
2054 * @tc.desc: Verify RegisterFormRemoveObserverByBundle
2055 * @tc.type: FUNC
2056 * @tc.require: issueI63OQL
2057 */
2058 HWTEST_F(FormMgrTest, FormMgrTest_0104, TestSize.Level1) {
2059 GTEST_LOG_(INFO) << "FormMgrTest_0104 starts";
2060
2061 FormMgr::GetInstance().SetRecoverStatus(Constants::IN_RECOVERING);
2062 std::string bundleName = "a";
2063 sptr<IRemoteObject> callerToken = new (std::nothrow) MockFormProviderClient();
2064 int result = FormMgr::GetInstance().RegisterFormRemoveObserverByBundle(bundleName, callerToken);
2065
2066 EXPECT_EQ(result, ERR_APPEXECFWK_FORM_SERVER_STATUS_ERR);
2067 GTEST_LOG_(INFO) << "FormMgrTest_0104 test ends";
2068 }
2069
2070 /**
2071 * @tc.name: FormMgrTest_0105
2072 * @tc.desc: Verify RegisterFormRemoveObserverByBundle
2073 * @tc.type: FUNC
2074 * @tc.require: issueI63OQL
2075 */
2076 HWTEST_F(FormMgrTest, FormMgrTest_0105, TestSize.Level1) {
2077 GTEST_LOG_(INFO) << "FormMgrTest_0105 starts";
2078 EXPECT_CALL(*mockProxy, RegisterFormRemoveObserverByBundle(_, _))
2079 .Times(1)
2080 .WillOnce(Return(ERROR_NUM));
2081 FormMgr::GetInstance().SetRecoverStatus(Constants::NOT_IN_RECOVERY);
2082 std::string bundleName = "a";
2083 sptr<IRemoteObject> callerToken = new (std::nothrow) MockFormProviderClient();
2084 int result = FormMgr::GetInstance().RegisterFormRemoveObserverByBundle(bundleName, callerToken);
2085
2086 EXPECT_EQ(result, ERROR_NUM);
2087 GTEST_LOG_(INFO) << "FormMgrTest_0105 test ends";
2088 }
2089
2090 /**
2091 * @tc.name: FormMgrTest_0106
2092 * @tc.desc: Verify UpdateForm (include data proxies)
2093 * @tc.type: FUNC
2094 * @tc.require: issueI7CGTP
2095 */
2096 HWTEST_F(FormMgrTest, FormMgrTest_0106, TestSize.Level1) {
2097 GTEST_LOG_(INFO) << "FormMgrTest_0106 starts";
2098 EXPECT_CALL(*mockProxy, UpdateProxyForm(_, _, _))
2099 .Times(1)
2100 .WillOnce(Return(NEGATIVE_NUM));
2101 FormJsInfo formJsInfo;
2102 formJsInfo.formId = 0x00000008fffffffL;
2103 FormProviderData formProviderData = FormProviderData(std::string("{\"city\": \"beijing001\"}"));
2104 std::vector<FormDataProxy> formDataProxies;
2105 FormDataProxy formDataProxy("city", "");
2106 formDataProxies.push_back(formDataProxy);
2107 int32_t result = FormMgr::GetInstance().UpdateForm(formJsInfo.formId, formProviderData, formDataProxies);
2108 EXPECT_EQ(result, NEGATIVE_NUM);
2109 GTEST_LOG_(INFO) << "FormMgrTest_0106 test ends";
2110 }
2111
2112 /**
2113 * @tc.name: FormMgrTest_0107
2114 * @tc.desc: Verify RequestPublishForm (include data proxies)
2115 * @tc.type: FUNC
2116 * @tc.require: issueI7CGTP
2117 */
2118 HWTEST_F(FormMgrTest, FormMgrTest_0107, TestSize.Level1) {
2119 GTEST_LOG_(INFO) << "FormMgrTest_0107 starts";
2120 EXPECT_CALL(*mockProxy, RequestPublishProxyForm(_, _, _, _, _))
2121 .Times(1)
2122 .WillOnce(Return(NEGATIVE_NUM));
2123 Want want;
2124 int64_t formId = 0x00000008fffffffL;
2125 std::unique_ptr<FormProviderData> formProviderData;
2126 std::vector<FormDataProxy> formDataProxies;
2127 FormDataProxy formDataProxy("city", "");
2128 formDataProxies.push_back(formDataProxy);
2129 int32_t result = FormMgr::GetInstance().RequestPublishForm(want, true, formProviderData, formId, formDataProxies);
2130 EXPECT_EQ(result, NEGATIVE_NUM);
2131 GTEST_LOG_(INFO) << "FormMgrTest_0107 test ends";
2132 }
2133
2134 /**
2135 * @tc.name: FormMgrTest_0108
2136 * @tc.desc: Verify StopRenderingForm
2137 * @tc.type: FUNC
2138 * @tc.require: issueI7HGZ2
2139 */
2140 HWTEST_F(FormMgrTest, FormMgrTest_0108, TestSize.Level1) {
2141 GTEST_LOG_(INFO) << "FormMgrTest_0108 starts";
2142 int64_t formId = 0;
2143 std::string compId = "this is compId";
2144 int result = FormMgr::GetInstance().StopRenderingForm(formId, compId);
2145 EXPECT_EQ(result, ERR_APPEXECFWK_FORM_INVALID_FORM_ID);
2146 GTEST_LOG_(INFO) << "FormMgrTest_0108 test ends";
2147 }
2148
2149 /**
2150 * @tc.name: FormMgrTest_0109
2151 * @tc.desc: Verify ReleaseRenderer
2152 * @tc.type: FUNC
2153 * @tc.require: issueI7HGZ2
2154 */
2155 HWTEST_F(FormMgrTest, FormMgrTest_0109, TestSize.Level1) {
2156 GTEST_LOG_(INFO) << "FormMgrTest_0109 starts";
2157 int64_t formId = 0;
2158 std::string compId = "this is compId";
2159 int result = FormMgr::GetInstance().ReleaseRenderer(formId, compId);
2160 EXPECT_EQ(result, ERR_APPEXECFWK_FORM_INVALID_FORM_ID);
2161 GTEST_LOG_(INFO) << "FormMgrTest_0109 test ends";
2162 }
2163
2164 /**
2165 * @tc.name: FormMgrTest_0111
2166 * @tc.desc: Verify GetErrorMsgByExternalErrorCode
2167 * @tc.type: FUNC
2168 * @tc.require: issueI7HGZ2
2169 */
2170 HWTEST_F(FormMgrTest, FormMgrTest_0111, TestSize.Level1) {
2171 GTEST_LOG_(INFO) << "FormMgrTest_0111 starts";
2172 int32_t innerErrorCode = 0;
2173 int32_t externalErrorCode = 0;
2174 std::string errorMsg = "this is errorMsg";
2175 FormMgr::GetInstance().GetExternalError(innerErrorCode, externalErrorCode, errorMsg);
2176
2177 std::string result = FormMgr::GetInstance().GetErrorMsgByExternalErrorCode(externalErrorCode);
2178 EXPECT_EQ(result, "success");
2179 GTEST_LOG_(INFO) << "FormMgrTest_0111 test ends";
2180 }
2181
2182 /**
2183 * @tc.name: FormMgrTest_0112
2184 * @tc.desc: Verify GetFormInstancesByFilter
2185 * @tc.type: FUNC
2186 * @tc.require: issueI7HGZ2
2187 */
2188 HWTEST_F(FormMgrTest, FormMgrTest_0112, TestSize.Level1) {
2189 GTEST_LOG_(INFO) << "FormMgrTest_0112 starts";
2190 FormInstancesFilter filter;
2191 std::vector<FormInstance> formInstances;
2192 ErrCode result = FormMgr::GetInstance().GetFormInstancesByFilter(filter, formInstances);
2193 int code = 8388610;
2194 EXPECT_EQ(result, code);
2195
2196 int64_t formId = 1;
2197 FormInstance formInstance;
2198 ErrCode result1 = FormMgr::GetInstance().GetFormInstanceById(formId, formInstance);
2199 EXPECT_EQ(result1, code);
2200 GTEST_LOG_(INFO) << "FormMgrTest_0112 test ends";
2201 }
2202
2203 /**
2204 * @tc.name: FormMgrTest_0113
2205 * @tc.desc: Verify BackgroundEvent
2206 * @tc.type: FUNC
2207 * @tc.require: IssueI7X4L4
2208 */
2209 HWTEST_F(FormMgrTest, FormMgrTest_0113, TestSize.Level1) {
2210 GTEST_LOG_(INFO) << "FormMgrTest_0113 starts";
2211 EXPECT_CALL(*mockProxy, BackgroundEvent(_, _, _))
2212 .Times(1)
2213 .WillOnce(Return(ERROR_NUM));
2214 FormMgr::GetInstance().SetRecoverStatus(Constants::IN_RECOVERING);
2215 Want want;
2216 int64_t formId = 1;
2217 std::string bundleName = "a";
2218 sptr<IRemoteObject> callerToken = new (std::nothrow) MockFormProviderClient();
2219 int result = FormMgr::GetInstance().BackgroundEvent(formId, want, callerToken);
2220
2221 EXPECT_EQ(result, ERROR_NUM);
2222 GTEST_LOG_(INFO) << "FormMgrTest_0113 test ends";
2223 }
2224
2225 /**
2226 * @tc.name: FormMgrTest_0114
2227 * @tc.desc: Verify RegisterPublishFormInterceptor
2228 * @tc.type: FUNC
2229 * @tc.require: IssueI7X4L4
2230 */
2231 HWTEST_F(FormMgrTest, FormMgrTest_0114, TestSize.Level1) {
2232 GTEST_LOG_(INFO) << "FormMgrTest_0114 starts";
2233 EXPECT_CALL(*mockProxy, RegisterPublishFormInterceptor(_))
2234 .Times(1)
2235 .WillOnce(Return(ERR_OK));
2236 FormMgr::GetInstance().SetRecoverStatus(Constants::IN_RECOVERING);
2237 sptr<IRemoteObject> interceptorCallback;
2238
2239 int32_t result = FormMgr::GetInstance().RegisterPublishFormInterceptor(interceptorCallback);
2240
2241 EXPECT_EQ(result, 0);
2242 GTEST_LOG_(INFO) << "FormMgrTest_0114 test ends";
2243 }
2244
2245 /**
2246 * @tc.name: FormMgrTest_0115
2247 * @tc.desc: Verify UnregisterPublishFormInterceptor
2248 * @tc.type: FUNC
2249 * @tc.require: IssueI7X4L4
2250 */
2251 HWTEST_F(FormMgrTest, FormMgrTest_0115, TestSize.Level1) {
2252 GTEST_LOG_(INFO) << "FormMgrTest_0115 starts";
2253 FormMgr::GetInstance().SetRecoverStatus(Constants::NOT_IN_RECOVERY);
2254 EXPECT_CALL(*mockProxy, UnregisterPublishFormInterceptor(_))
2255 .Times(1)
2256 .WillOnce(Return(ERROR_NUMS));
2257 sptr<IRemoteObject> interceptorCallback;
2258
2259 int32_t result = FormMgr::GetInstance().UnregisterPublishFormInterceptor(interceptorCallback);
2260 EXPECT_EQ(result, 8388610);
2261 GTEST_LOG_(INFO) << "FormMgrTest_0115 test ends";
2262 }
2263
2264 /**
2265 * @tc.name: FormMgrTest_0117
2266 * @tc.desc: Verify RegisterAddObserver
2267 * @tc.type: FUNC
2268 * @tc.require: IssueI7X4L4
2269 */
2270 HWTEST_F(FormMgrTest, FormMgrTest_0117, TestSize.Level1) {
2271 GTEST_LOG_(INFO) << "FormMgrTest_0117 starts";
2272
2273 FormMgr::GetInstance().SetRecoverStatus(Constants::IN_RECOVERING);
2274 std::string bundleName = "this is a bundleName";
2275 sptr<IRemoteObject> callerToken = new (std::nothrow) MockFormProviderClient();
2276
2277 ErrCode result = FormMgr::GetInstance().RegisterAddObserver(bundleName, callerToken);
2278 EXPECT_EQ(result, ERROR_NUM);
2279 GTEST_LOG_(INFO) << "FormMgrTest_0117 test ends";
2280 }
2281
2282 /**
2283 * @tc.name: FormMgrTest_0118
2284 * @tc.desc: Verify RegisterRemoveObserver
2285 * @tc.type: FUNC
2286 * @tc.require: IssueI7X4L4
2287 */
2288 HWTEST_F(FormMgrTest, FormMgrTest_0118, TestSize.Level1) {
2289 GTEST_LOG_(INFO) << "FormMgrTest_0118 starts";
2290
2291 FormMgr::GetInstance().SetRecoverStatus(Constants::IN_RECOVERING);
2292 std::string bundleName = "a";
2293 sptr<IRemoteObject> callerToken = new (std::nothrow) MockFormProviderClient();
2294
2295 ErrCode result = FormMgr::GetInstance().RegisterRemoveObserver(bundleName, callerToken);
2296 EXPECT_EQ(result, ERROR_NUM);
2297 GTEST_LOG_(INFO) << "FormMgrTest_0118 test ends";
2298 }
2299
2300 /**
2301 * @tc.name: FormMgrTest_0119
2302 * @tc.desc: Verify RegisterFormRouterProxy
2303 * @tc.type: FUNC
2304 * @tc.require: IssueI8H9R5
2305 */
2306 HWTEST_F(FormMgrTest, FormMgrTest_0119, TestSize.Level1) {
2307 GTEST_LOG_(INFO) << "FormMgrTest_0119 starts";
2308
2309 FormMgr::GetInstance().SetRecoverStatus(Constants::IN_RECOVERING);
2310 std::vector<int64_t> formIds;
2311 formIds.push_back(0);
2312 sptr<IRemoteObject> callerToken = new (std::nothrow) MockFormProviderClient();
2313
2314 ErrCode result = FormMgr::GetInstance().RegisterFormRouterProxy(formIds, callerToken);
2315 EXPECT_EQ(result, ERROR_NUM);
2316 GTEST_LOG_(INFO) << "FormMgrTest_0119 test ends";
2317 }
2318
2319 /**
2320 * @tc.name: FormMgrTest_0120
2321 * @tc.desc: Verify UnregisterFormRouterProxy
2322 * @tc.type: FUNC
2323 * @tc.require: IssueI8H9R5
2324 */
2325 HWTEST_F(FormMgrTest, FormMgrTest_0120, TestSize.Level1) {
2326 GTEST_LOG_(INFO) << "FormMgrTest_0120 starts";
2327
2328 FormMgr::GetInstance().SetRecoverStatus(Constants::IN_RECOVERING);
2329 std::vector<int64_t> formIds;
2330 formIds.push_back(0);
2331
2332 ErrCode result = FormMgr::GetInstance().UnregisterFormRouterProxy(formIds);
2333 EXPECT_EQ(result, ERROR_NUM);
2334 GTEST_LOG_(INFO) << "FormMgrTest_0120 test ends";
2335 }
2336
2337 /**
2338 * @tc.name: FormMgrTest_0121
2339 * @tc.desc: Verify HasFormVisible
2340 * @tc.type: FUNC
2341 */
2342 HWTEST_F(FormMgrTest, FormMgrTest_0121, TestSize.Level1) {
2343 GTEST_LOG_(INFO) << "FormMgrTest_0121 starts";
2344 EXPECT_CALL(*mockProxy, HasFormVisible(_))
2345 .Times(1)
2346 .WillOnce(Return(true));
2347 uint32_t tokenId = 0;
2348 bool result = FormMgr::GetInstance().HasFormVisible(tokenId);
2349 EXPECT_EQ(result, true);
2350 GTEST_LOG_(INFO) << "FormMgrTest_0121 test ends";
2351 }
2352
2353 /**
2354 * @tc.name: FormMgrTest_0122
2355 * @tc.desc: Verify GetFormsInfoByFilter
2356 * @tc.type: FUNC
2357 * @tc.require:
2358 */
2359 HWTEST_F(FormMgrTest, FormMgrTest_0122, TestSize.Level1) {
2360 GTEST_LOG_(INFO) << "FormMgrTest_0122 starts";
2361 FormInfoFilter filter;
2362 std::vector<FormInfo> formInfos;
2363 std::vector<FormInfo> expectFormInfos;
2364 FormInfo formInfo = {};
2365 formInfo.bundleName = "ohos.samples.FormApplication";
2366 expectFormInfos.push_back(formInfo);
2367 EXPECT_CALL(*mockProxy, GetFormsInfoByFilter(_, _))
2368 .Times(1)
2369 .WillOnce(DoAll(SetArgReferee<1>(expectFormInfos), Return(ERR_OK)));
2370 FormMgr::GetInstance().GetFormsInfoByFilter(filter, formInfos);
2371 EXPECT_THAT(formInfos, ContainerEq(expectFormInfos));
2372 testing::Mock::AllowLeak(mockProxy);
2373 GTEST_LOG_(INFO) << "FormMgrTest_0122 test ends";
2374 }
2375
2376 /**
2377 * @tc.name: FormMgrTest_0123
2378 * @tc.desc: Verify UpdateFormLocation (The return value of mock function is not 0)
2379 * @tc.type: FUNC
2380 */
2381 HWTEST_F(FormMgrTest, FormMgrTest_0123, TestSize.Level1) {
2382 GTEST_LOG_(INFO) << "FormMgrTest_0123 starts";
2383
2384 sptr<MockFormToken> token = new (std::nothrow) MockFormToken();
2385 FormMgr::GetInstance().SetRecoverStatus(Constants::IN_RECOVERING);
2386 int64_t formId = 0;
2387 int32_t formLocation = 1;
2388 EXPECT_EQ(FormMgr::GetInstance().UpdateFormLocation(formId, formLocation), ERROR_NUM);
2389 GTEST_LOG_(INFO) << "FormMgrTest_0123 test ends";
2390 }
2391
2392 /**
2393 * @tc.name: FormMgrTest_0124
2394 * @tc.desc: Verify CreateForm
2395 * @tc.type: FUNC
2396 */
2397 HWTEST_F(FormMgrTest, FormMgrTest_0124, TestSize.Level1)
2398 {
2399 GTEST_LOG_(INFO) << "FormMgrTest_0124 starts";
2400 EXPECT_CALL(*mockProxy, CreateForm(_, _))
2401 .Times(1)
2402 .WillOnce(Return(0));
2403 Want want;
2404 RunningFormInfo runningFormInfo;
2405 int result = FormMgr::GetInstance().CreateForm(want, runningFormInfo);
2406 EXPECT_EQ(result, 0);
2407 GTEST_LOG_(INFO) << "FormMgrTest_0124 test ends";
2408 }
2409
2410 /**
2411 * @tc.name: FormMgrTest_0125
2412 * @tc.desc: Verify RegisterClickEventObserver
2413 * @tc.type: FUNC
2414 */
2415 HWTEST_F(FormMgrTest, FormMgrTest_0125, TestSize.Level0)
2416 {
2417 GTEST_LOG_(INFO) << "FormMgrTest_0125 begin";
2418 std::string bundleName = "";
2419 std::string formEventType = "formAdd";
2420 sptr<IRemoteObject> observer = nullptr;
2421 int result = FormMgr::GetInstance().RegisterClickEventObserver(bundleName, formEventType, observer);
2422 EXPECT_EQ(result, ERR_APPEXECFWK_FORM_INVALID_PARAM);
2423 GTEST_LOG_(INFO) << "FormMgrTest_0125 end";
2424 }
2425
2426 /**
2427 * @tc.name: FormMgrTest_0126
2428 * @tc.desc: Verify RegisterClickEventObserver
2429 * @tc.type: FUNC
2430 */
2431 HWTEST_F(FormMgrTest, FormMgrTest_0126, TestSize.Level0)
2432 {
2433 GTEST_LOG_(INFO) << "FormMgrTest_0126 begin";
2434 std::string bundleName = "";
2435 std::string formEventType = "formAdd";
2436 sptr<MockIRemoteObject> iremoteObject = new (std::nothrow) MockIRemoteObject();
2437 ASSERT_NE(nullptr, iremoteObject);
2438 FormMgr::GetInstance().SetRecoverStatus(Constants::IN_RECOVERING);
2439 int result = FormMgr::GetInstance().RegisterClickEventObserver(bundleName, formEventType, iremoteObject);
2440 EXPECT_EQ(result, ERR_APPEXECFWK_FORM_SERVER_STATUS_ERR);
2441 GTEST_LOG_(INFO) << "FormMgrTest_0126 end";
2442 }
2443
2444 /**
2445 * @tc.name: FormMgrTest_0127
2446 * @tc.desc: Verify RegisterClickEventObserver
2447 * @tc.type: FUNC
2448 */
2449 HWTEST_F(FormMgrTest, FormMgrTest_0127, TestSize.Level0)
2450 {
2451 GTEST_LOG_(INFO) << "FormMgrTest_0127 begin";
2452 std::string bundleName = "";
2453 std::string formEventType = "formAdd";
2454
2455 sptr<MockIRemoteObject> iremoteObject = new (std::nothrow) MockIRemoteObject();
2456 ASSERT_NE(nullptr, iremoteObject);
2457
2458 FormMgr::GetInstance().SetRecoverStatus(Constants::NOT_IN_RECOVERY);
2459 EXPECT_CALL(*mockProxy, RegisterClickEventObserver(_, _, _))
2460 .Times(1)
2461 .WillOnce(Return(OHOS::ERR_OK));
2462 int result = FormMgr::GetInstance().RegisterClickEventObserver(bundleName, formEventType, iremoteObject);
2463 EXPECT_EQ(result, ERR_OK);
2464 GTEST_LOG_(INFO) << "FormMgrTest_0127 end";
2465 }
2466
2467 /**
2468 * @tc.name: FormMgrTest_0128
2469 * @tc.desc: Verify RegisterClickEventObserver
2470 * @tc.type: FUNC
2471 */
2472 HWTEST_F(FormMgrTest, FormMgrTest_0128, TestSize.Level0)
2473 {
2474 GTEST_LOG_(INFO) << "FormMgrTest_0128 begin";
2475 std::string bundleName = "";
2476 std::string formEventType = "formAdd";
2477 FormMgr::GetInstance().resetFlag_ = true;
2478 sptr<MockIRemoteObject> iremoteObject = new (std::nothrow) MockIRemoteObject();
2479 ASSERT_NE(nullptr, iremoteObject);
2480 FormMgr::GetInstance().SetRecoverStatus(Constants::NOT_IN_RECOVERY);
2481 int result = FormMgr::GetInstance().RegisterClickEventObserver(bundleName, formEventType, iremoteObject);
2482 EXPECT_EQ(result, ERR_APPEXECFWK_FORM_COMMON_CODE);
2483 FormMgr::GetInstance().resetFlag_ = false;
2484 FormMgr::GetInstance().SetFormMgrService(mockProxy);
2485 GTEST_LOG_(INFO) << "FormMgrTest_0128 end";
2486 }
2487
2488 /**
2489 * @tc.name: FormMgrTest_0129
2490 * @tc.desc: Verify UnregisterClickEventObserver
2491 * @tc.type: FUNC
2492 */
2493 HWTEST_F(FormMgrTest, FormMgrTest_0129, TestSize.Level0)
2494 {
2495 GTEST_LOG_(INFO) << "FormMgrTest_0129 begin";
2496 std::string bundleName = "";
2497 std::string formEventType = "formAdd";
2498 sptr<IRemoteObject> observer = nullptr;
2499 int result = FormMgr::GetInstance().UnregisterClickEventObserver(bundleName, formEventType, observer);
2500 EXPECT_EQ(result, ERR_APPEXECFWK_FORM_INVALID_PARAM);
2501 GTEST_LOG_(INFO) << "FormMgrTest_0129 end";
2502 }
2503
2504 /**
2505 * @tc.name: FormMgrTest_0130
2506 * @tc.desc: Verify UnregisterClickEventObserver
2507 * @tc.type: FUNC
2508 */
2509 HWTEST_F(FormMgrTest, FormMgrTest_0130, TestSize.Level0)
2510 {
2511 GTEST_LOG_(INFO) << "FormMgrTest_0130 begin";
2512 std::string bundleName = "";
2513 std::string formEventType = "formAdd";
2514 sptr<MockIRemoteObject> iremoteObject = new (std::nothrow) MockIRemoteObject();
2515 ASSERT_NE(nullptr, iremoteObject);
2516 FormMgr::GetInstance().SetRecoverStatus(Constants::IN_RECOVERING);
2517 int result = FormMgr::GetInstance().UnregisterClickEventObserver(bundleName, formEventType, iremoteObject);
2518 EXPECT_EQ(result, ERR_APPEXECFWK_FORM_SERVER_STATUS_ERR);
2519 GTEST_LOG_(INFO) << "FormMgrTest_0130 end";
2520 }
2521
2522 /**
2523 * @tc.name: FormMgrTest_0131
2524 * @tc.desc: Verify UnregisterClickEventObserver
2525 * @tc.type: FUNC
2526 */
2527 HWTEST_F(FormMgrTest, FormMgrTest_0131, TestSize.Level0)
2528 {
2529 GTEST_LOG_(INFO) << "FormMgrTest_0131 begin";
2530 std::string bundleName = "";
2531 std::string formEventType = "formAdd";
2532
2533 sptr<MockIRemoteObject> iremoteObject = new (std::nothrow) MockIRemoteObject();
2534 ASSERT_NE(nullptr, iremoteObject);
2535
2536 FormMgr::GetInstance().SetRecoverStatus(Constants::NOT_IN_RECOVERY);
2537 EXPECT_CALL(*mockProxy, UnregisterClickEventObserver(_, _, _))
2538 .Times(1)
2539 .WillOnce(Return(OHOS::ERR_OK));
2540 int result = FormMgr::GetInstance().UnregisterClickEventObserver(bundleName, formEventType, iremoteObject);
2541 EXPECT_EQ(result, ERR_OK);
2542 GTEST_LOG_(INFO) << "FormMgrTest_0131 end";
2543 }
2544
2545 /**
2546 * @tc.name: FormMgrTest_0132
2547 * @tc.desc: Verify UnregisterClickEventObserver
2548 * @tc.type: FUNC
2549 */
2550 HWTEST_F(FormMgrTest, FormMgrTest_0132, TestSize.Level0)
2551 {
2552 GTEST_LOG_(INFO) << "FormMgrTest_0132 begin";
2553 std::string bundleName = "";
2554 std::string formEventType = "formAdd";
2555 FormMgr::GetInstance().resetFlag_ = true;
2556 sptr<MockIRemoteObject> iremoteObject = new (std::nothrow) MockIRemoteObject();
2557 ASSERT_NE(nullptr, iremoteObject);
2558 FormMgr::GetInstance().SetRecoverStatus(Constants::NOT_IN_RECOVERY);
2559 int result = FormMgr::GetInstance().UnregisterClickEventObserver(bundleName, formEventType, iremoteObject);
2560 EXPECT_EQ(result, ERR_APPEXECFWK_FORM_COMMON_CODE);
2561 FormMgr::GetInstance().resetFlag_ = false;
2562 FormMgr::GetInstance().SetFormMgrService(mockProxy);
2563 GTEST_LOG_(INFO) << "FormMgrTest_0132 end";
2564 }
2565
2566 /**
2567 * @tc.name: FormMgrTest_0133
2568 * @tc.desc: Verify SetFormsRecyclable
2569 * @tc.type: FUNC
2570 */
2571 HWTEST_F(FormMgrTest, FormMgrTest_0133, TestSize.Level0) {
2572 GTEST_LOG_(INFO) << "FormMgrTest_0133 test begin";
2573 std::vector<int64_t> formIds;
2574 FormMgr::GetInstance().SetRecoverStatus(Constants::IN_RECOVERING);
2575 int32_t result = FormMgr::GetInstance().SetFormsRecyclable(formIds);
2576 EXPECT_EQ(result, ERR_APPEXECFWK_FORM_SERVER_STATUS_ERR);
2577 GTEST_LOG_(INFO) << "FormMgrTest_0133 test ends";
2578 }
2579
2580 /**
2581 * @tc.name: FormMgrTest_0134
2582 * @tc.desc: Verify SetFormsRecyclable
2583 * @tc.type: FUNC
2584 */
2585 HWTEST_F(FormMgrTest, FormMgrTest_0134, TestSize.Level0) {
2586 GTEST_LOG_(INFO) << "FormMgrTest_0134 test begin";
2587 std::vector<int64_t> formIds;
2588 FormMgr::GetInstance().SetRecoverStatus(Constants::NOT_IN_RECOVERY);
2589 int32_t result = FormMgr::GetInstance().SetFormsRecyclable(formIds);
2590 EXPECT_EQ(result, ERR_APPEXECFWK_FORM_INVALID_FORM_ID);
2591 GTEST_LOG_(INFO) << "FormMgrTest_0134 test ends";
2592 }
2593
2594 /**
2595 * @tc.name: FormMgrTest_0135
2596 * @tc.desc: Verify SetFormsRecyclable
2597 * @tc.type: FUNC
2598 */
2599 HWTEST_F(FormMgrTest, FormMgrTest_0135, TestSize.Level0) {
2600 GTEST_LOG_(INFO) << "FormMgrTest_0135 test begin";
2601 std::vector<int64_t> formIds;
2602 int64_t formId1 = 1;
2603 int64_t formId2 = 2;
2604 formIds.push_back(formId1);
2605 formIds.push_back(formId2);
2606 FormMgr::GetInstance().SetRecoverStatus(Constants::NOT_IN_RECOVERY);
2607 EXPECT_CALL(*mockProxy, SetFormsRecyclable(_))
2608 .Times(1)
2609 .WillOnce(Return(OHOS::ERR_OK));
2610 int32_t result = FormMgr::GetInstance().SetFormsRecyclable(formIds);
2611 EXPECT_EQ(result, ERR_OK);
2612 GTEST_LOG_(INFO) << "FormMgrTest_0135 test ends";
2613 }
2614
2615 /**
2616 * @tc.name: FormMgrTest_0136
2617 * @tc.desc: Verify RecoverForms
2618 * @tc.type: FUNC
2619 */
2620 HWTEST_F(FormMgrTest, FormMgrTest_0136, TestSize.Level0) {
2621 GTEST_LOG_(INFO) << "FormMgrTest_0136 begin";
2622 std::vector<int64_t> formIds;
2623 Want want;
2624 FormMgr::GetInstance().SetRecoverStatus(Constants::IN_RECOVERING);
2625 int32_t result = FormMgr::GetInstance().RecycleForms(formIds, want);
2626 EXPECT_EQ(result, ERR_APPEXECFWK_FORM_SERVER_STATUS_ERR);
2627 GTEST_LOG_(INFO) << "FormMgrTest_0136 test ends";
2628 }
2629
2630 /**
2631 * @tc.name: FormMgrTest_0137
2632 * @tc.desc: Verify RecoverForms
2633 * @tc.type: FUNC
2634 */
2635 HWTEST_F(FormMgrTest, FormMgrTest_0137, TestSize.Level0) {
2636 GTEST_LOG_(INFO) << "FormMgrTest_0137 begin";
2637 std::vector<int64_t> formIds;
2638 Want want;
2639 FormMgr::GetInstance().SetRecoverStatus(Constants::NOT_IN_RECOVERY);
2640 int32_t result = FormMgr::GetInstance().RecycleForms(formIds, want);
2641 EXPECT_EQ(result, ERR_APPEXECFWK_FORM_INVALID_FORM_ID);
2642 GTEST_LOG_(INFO) << "FormMgrTest_0137 test ends";
2643 }
2644
2645 /**
2646 * @tc.name: FormMgrTest_0138
2647 * @tc.desc: Verify RecoverForms
2648 * @tc.type: FUNC
2649 */
2650 HWTEST_F(FormMgrTest, FormMgrTest_0138, TestSize.Level0) {
2651 GTEST_LOG_(INFO) << "FormMgrTest_0138 begin";
2652 std::vector<int64_t> formIds;
2653 int64_t formId1 = 1;
2654 formIds.push_back(formId1);
2655 Want want;
2656 FormMgr::GetInstance().SetRecoverStatus(Constants::NOT_IN_RECOVERY);
2657
2658 int32_t result = FormMgr::GetInstance().RecycleForms(formIds, want);
2659 EXPECT_EQ(result, ERR_OK);
2660 GTEST_LOG_(INFO) << "FormMgrTest_0138 test ends";
2661 }
2662
2663 /**
2664 * @tc.name: FormMgrTest_0139
2665 * @tc.desc: Verify RecoverForms
2666 * @tc.type: FUNC
2667 */
2668 HWTEST_F(FormMgrTest, FormMgrTest_0139, TestSize.Level0) {
2669 GTEST_LOG_(INFO) << "FormMgrTest_0139 begin";
2670 std::vector<int64_t> formIds;
2671 Want want;
2672 FormMgr::GetInstance().SetRecoverStatus(Constants::IN_RECOVERING);
2673 int32_t result = FormMgr::GetInstance().RecoverForms(formIds, want);
2674 EXPECT_EQ(result, ERR_APPEXECFWK_FORM_SERVER_STATUS_ERR);
2675 GTEST_LOG_(INFO) << "FormMgrTest_0139 test ends";
2676 }
2677
2678 /**
2679 * @tc.name: FormMgrTest_0140
2680 * @tc.desc: Verify RecoverForms
2681 * @tc.type: FUNC
2682 */
2683 HWTEST_F(FormMgrTest, FormMgrTest_0140, TestSize.Level0) {
2684 GTEST_LOG_(INFO) << "FormMgrTest_0140 begin";
2685 std::vector<int64_t> formIds;
2686 Want want;
2687 FormMgr::GetInstance().SetRecoverStatus(Constants::NOT_IN_RECOVERY);
2688 int32_t result = FormMgr::GetInstance().RecoverForms(formIds, want);
2689 EXPECT_EQ(result, ERR_APPEXECFWK_FORM_INVALID_FORM_ID);
2690 GTEST_LOG_(INFO) << "FormMgrTest_0140 test ends";
2691 }
2692
2693 /**
2694 * @tc.name: FormMgrTest_0141
2695 * @tc.desc: Verify RecoverForms
2696 * @tc.type: FUNC
2697 */
2698 HWTEST_F(FormMgrTest, FormMgrTest_0141, TestSize.Level0) {
2699 GTEST_LOG_(INFO) << "FormMgrTest_0141 begin";
2700 std::vector<int64_t> formIds;
2701 int64_t formId1 = 1;
2702 formIds.push_back(formId1);
2703 Want want;
2704 FormMgr::GetInstance().SetRecoverStatus(Constants::NOT_IN_RECOVERY);
2705 EXPECT_CALL(*mockProxy, RecoverForms(_, _))
2706 .Times(1)
2707 .WillOnce(Return(OHOS::ERR_OK));
2708 int32_t result = FormMgr::GetInstance().RecoverForms(formIds, want);
2709 EXPECT_EQ(result, ERR_OK);
2710 GTEST_LOG_(INFO) << "FormMgrTest_0141 test ends";
2711 }
2712
2713 /**
2714 * @tc.name: FormMgrTest_0142
2715 * @tc.desc: Verify SetPublishFormResult (The return value of mock function is not 0)
2716 * @tc.type: FUNC
2717 */
2718 HWTEST_F(FormMgrTest, FormMgrTest_0142, TestSize.Level1) {
2719 GTEST_LOG_(INFO) << "FormMgrTest_0142 starts";
2720
2721 sptr<MockFormToken> token = new (std::nothrow) MockFormToken();
2722 FormMgr::GetInstance().SetRecoverStatus(Constants::IN_RECOVERING);
2723 int64_t formId = 0;
2724 Constants::PublishFormResult result {Constants::PublishFormErrorCode::SUCCESS, ""};
2725 EXPECT_EQ(FormMgr::GetInstance().SetPublishFormResult(formId, result), ERR_APPEXECFWK_FORM_INVALID_FORM_ID);
2726 GTEST_LOG_(INFO) << "FormMgrTest_0142 test ends";
2727 }
2728
2729 /**
2730 * @tc.name: FormMgrTest_0143
2731 * @tc.desc: Verify AcquireAddFormResult (The return value of mock function is not 0)
2732 * @tc.type: FUNC
2733 */
2734 HWTEST_F(FormMgrTest, FormMgrTest_0143, TestSize.Level1) {
2735 GTEST_LOG_(INFO) << "FormMgrTest_0143 starts";
2736
2737 sptr<MockFormToken> token = new (std::nothrow) MockFormToken();
2738 FormMgr::GetInstance().SetRecoverStatus(Constants::IN_RECOVERING);
2739 int64_t formId = 0;
2740 EXPECT_EQ(FormMgr::GetInstance().AcquireAddFormResult(formId), ERR_APPEXECFWK_FORM_INVALID_FORM_ID);
2741 GTEST_LOG_(INFO) << "FormMgrTest_0143 test ends";
2742 }
2743
2744 /**
2745 * @tc.name: FormMgrTest_0144
2746 * @tc.desc: Verify BatchRefreshForms (The return value of mock function is not 0)
2747 * @tc.type: FUNC
2748 */
2749 HWTEST_F(FormMgrTest, FormMgrTest_0144, TestSize.Level1) {
2750 GTEST_LOG_(INFO) << "FormMgrTest_0144 starts";
2751 FormMgr::GetInstance().SetRecoverStatus(Constants::IN_RECOVERING);
2752 int32_t formRefreshType = Constants::REFRESH_ALL_FORM;
2753 EXPECT_EQ(FormMgr::GetInstance().BatchRefreshForms(formRefreshType), ERR_APPEXECFWK_FORM_SERVER_STATUS_ERR);
2754 GTEST_LOG_(INFO) << "FormMgrTest_0144 test ends";
2755 }
2756
2757 /**
2758 * @tc.name: FormMgrTest_0145
2759 * @tc.desc: Verify BatchRefreshForms (The return value of mock function is not 0)
2760 * @tc.type: FUNC
2761 */
2762 HWTEST_F(FormMgrTest, FormMgrTest_0145, TestSize.Level1) {
2763 GTEST_LOG_(INFO) << "FormMgrTest_0145 starts";
2764 FormMgr::GetInstance().SetRecoverStatus(Constants::NOT_IN_RECOVERY);
2765 int32_t formRefreshType = Constants::REFRESH_ALL_FORM - 1;
2766 EXPECT_EQ(FormMgr::GetInstance().BatchRefreshForms(formRefreshType), ERR_APPEXECFWK_FORM_INVALID_PARAM);
2767 formRefreshType = Constants::REFRESH_ATOMIC_FORM + 1;
2768 EXPECT_EQ(FormMgr::GetInstance().BatchRefreshForms(formRefreshType), ERR_APPEXECFWK_FORM_INVALID_PARAM);
2769 GTEST_LOG_(INFO) << "FormMgrTest_0145 test ends";
2770 }
2771
2772 /**
2773 * @tc.name: FormMgrTest_0146
2774 * @tc.desc: Verify BatchRefreshForms (The return value of mock function is not 0)
2775 * @tc.type: FUNC
2776 */
2777 HWTEST_F(FormMgrTest, FormMgrTest_0146, TestSize.Level1) {
2778 GTEST_LOG_(INFO) << "FormMgrTest_0146 starts";
2779 EXPECT_CALL(*mockProxy, BatchRefreshForms(_))
2780 .Times(1)
2781 .WillOnce(Return(OHOS::ERR_OK));
2782 sptr<MockFormToken> token = new (std::nothrow) MockFormToken();
2783 FormMgr::GetInstance().SetRecoverStatus(Constants::NOT_IN_RECOVERY);
2784 int32_t formRefreshType = Constants::REFRESH_ALL_FORM;
2785 EXPECT_EQ(FormMgr::GetInstance().BatchRefreshForms(formRefreshType), ERR_OK);
2786 GTEST_LOG_(INFO) << "FormMgrTest_0146 test ends";
2787 }
2788
2789 /**
2790 * @tc.name: FormMgrTest_0147
2791 * @tc.desc: Verify EnableForms
2792 * @tc.type: FUNC
2793 */
2794 HWTEST_F(FormMgrTest, FormMgrTest_0147, TestSize.Level0) {
2795 GTEST_LOG_(INFO) << "FormMgrTest_0147 begin";
2796 std::string bundleName = "ohos.samples.FormApplication";
2797 FormMgr::GetInstance().SetRecoverStatus(Constants::IN_RECOVERING);
2798 int32_t result = FormMgr::GetInstance().EnableForms(bundleName, true);
2799 EXPECT_EQ(result, ERR_APPEXECFWK_FORM_SERVER_STATUS_ERR);
2800 GTEST_LOG_(INFO) << "FormMgrTest_0147 test ends";
2801 }
2802
2803 /**
2804 * @tc.name: FormMgrTest_0148
2805 * @tc.desc: Verify EnableForms
2806 * @tc.type: FUNC
2807 */
2808 HWTEST_F(FormMgrTest, FormMgrTest_0148, TestSize.Level0) {
2809 GTEST_LOG_(INFO) << "FormMgrTest_0148 begin";
2810 std::string bundleName = "ohos.samples.FormApplication";
2811 FormMgr::GetInstance().SetRecoverStatus(Constants::NOT_IN_RECOVERY);
2812 EXPECT_CALL(*mockProxy, EnableForms(_, _))
2813 .Times(1)
2814 .WillOnce(Return(OHOS::ERR_OK));
2815 int32_t result = FormMgr::GetInstance().EnableForms(bundleName, true);
2816 EXPECT_EQ(result, ERR_OK);
2817 GTEST_LOG_(INFO) << "FormMgrTest_0148 test ends";
2818 }
2819
2820 /**
2821 * @tc.name: FormMgrTest_0149
2822 * @tc.desc: Verify EnableForms
2823 * @tc.type: FUNC
2824 */
2825 HWTEST_F(FormMgrTest, FormMgrTest_0149, TestSize.Level0)
2826 {
2827 GTEST_LOG_(INFO) << "FormMgrTest_0149 begin";
2828 std::string bundleName;
2829 FormMgr::GetInstance().SetRecoverStatus(Constants::NOT_IN_RECOVERY);
2830 int32_t result = FormMgr::GetInstance().EnableForms(bundleName, true);
2831 EXPECT_EQ(result, ERR_APPEXECFWK_FORM_INVALID_PARAM);
2832 GTEST_LOG_(INFO) << "FormMgrTest_0149 test ends";
2833 }
2834
2835 /**
2836 * @tc.name: FormMgrTest_0150
2837 * @tc.desc: Verify IsFormBundleForbidden
2838 * @tc.type: FUNC
2839 */
2840 HWTEST_F(FormMgrTest, FormMgrTest_0150, TestSize.Level0) {
2841 GTEST_LOG_(INFO) << "FormMgrTest_0150 begin";
2842 std::string bundleName = "ohos.samples.FormApplication";
2843 bool result = FormMgr::GetInstance().IsFormBundleForbidden(bundleName);
2844 EXPECT_EQ(result, false);
2845 GTEST_LOG_(INFO) << "FormMgrTest_0150 test ends";
2846 }
2847
2848 /**
2849 * @tc.name: FormMgrTest_0151
2850 * @tc.desc: Verify IsFormBundleForbidden
2851 * @tc.type: FUNC
2852 */
2853 HWTEST_F(FormMgrTest, FormMgrTest_0151, TestSize.Level0)
2854 {
2855 GTEST_LOG_(INFO) << "FormMgrTest_0151 begin";
2856 EXPECT_CALL(*mockProxy, IsFormBundleForbidden(_))
2857 .Times(1)
2858 .WillOnce(Return(true));
2859 std::string bundleName = "ohos.samples.FormApplication";
2860 bool result = FormMgr::GetInstance().IsFormBundleForbidden(bundleName);
2861 EXPECT_EQ(result, true);
2862 GTEST_LOG_(INFO) << "FormMgrTest_0151 test ends";
2863 }
2864
2865 /**
2866 * @tc.name: FormMgrTest_0152
2867 * @tc.desc: Verify RequestPublishFormWithSnapshot (include data proxies)
2868 * @tc.type: FUNC
2869 * @tc.require: issueIA6CAJ
2870 */
2871 HWTEST_F(FormMgrTest, FormMgrTest_0152, TestSize.Level1) {
2872 GTEST_LOG_(INFO) << "FormMgrTest_0152 starts";
2873 EXPECT_CALL(*mockProxy, RequestPublishFormWithSnapshot(_, _, _, _))
2874 .Times(1)
2875 .WillOnce(Return(ERR_OK));
2876 Want want;
2877 int64_t formId = 0x00000008fffffffL;
2878 std::unique_ptr<FormProviderData> formProviderData;
2879 FormDataProxy formDataProxy("city", "");
2880 ErrCode result = FormMgr::GetInstance().RequestPublishFormWithSnapshot(want, true, formProviderData, formId);
2881 EXPECT_EQ(result, ERR_OK);
2882 AppExecFwk::ApplicationInfo appInfo;
2883 appInfo.isSystemApp = false;
2884 FormMgr::GetInstance().resetFlag_ = true;
2885 result = FormMgr::GetInstance().RequestPublishFormWithSnapshot(want, true, formProviderData, formId);
2886 EXPECT_NE(result, ERR_OK);
2887 GTEST_LOG_(INFO) << "FormMgrTest_0152 test ends";
2888 }
2889
2890 /**
2891 * @tc.name: FormMgrTest_0153
2892 * @tc.desc: Verify StopRenderingForm
2893 * @tc.type: FUNC
2894 */
2895 HWTEST_F(FormMgrTest, FormMgrTest_0153, TestSize.Level1)
2896 {
2897 GTEST_LOG_(INFO) << "FormMgrTest_0153 starts";
2898 int64_t formId = FORM_ID;
2899 std::string compId = "this is compId";
2900 FormMgr::GetInstance().SetRecoverStatus(Constants::IN_RECOVERING);
2901 int result = FormMgr::GetInstance().StopRenderingForm(formId, compId);
2902 EXPECT_EQ(result, ERR_APPEXECFWK_FORM_SERVER_STATUS_ERR);
2903 GTEST_LOG_(INFO) << "FormMgrTest_0153 test ends";
2904 }
2905
2906 /**
2907 * @tc.name: FormMgrTest_0154
2908 * @tc.desc: Verify ReleaseRenderer
2909 * @tc.type: FUNC
2910 */
2911 HWTEST_F(FormMgrTest, FormMgrTest_0154, TestSize.Level1)
2912 {
2913 GTEST_LOG_(INFO) << "FormMgrTest_0154 starts";
2914 EXPECT_CALL(*mockProxy, ReleaseRenderer(_, _))
2915 .Times(1)
2916 .WillOnce(Return(ERR_OK));
2917 SetUpTestCase();
2918 int64_t formId = FORM_ID;
2919 std::string compId = "this is compId";
2920 FormMgr::GetInstance().resetFlag_ = false;
2921 FormMgr::GetInstance().SetFormMgrService(mockProxy);
2922 FormMgr::GetInstance().SetRecoverStatus(Constants::NOT_IN_RECOVERY);
2923 int result = FormMgr::GetInstance().ReleaseRenderer(formId, compId);
2924 EXPECT_EQ(result, ERR_OK);
2925 GTEST_LOG_(INFO) << "FormMgrTest_0154 test ends";
2926 }
2927
2928 /**
2929 * @tc.name: FormMgrTest_0155
2930 * @tc.desc: Verify ReleaseRenderer
2931 * @tc.type: FUNC
2932 */
2933 HWTEST_F(FormMgrTest, FormMgrTest_0155, TestSize.Level1)
2934 {
2935 GTEST_LOG_(INFO) << "FormMgrTest_0155 starts";
2936 int64_t formId = FORM_ID;
2937 std::string compId = "this is compId";
2938 FormMgr::GetInstance().SetRecoverStatus(Constants::IN_RECOVERING);
2939 int result = FormMgr::GetInstance().ReleaseRenderer(formId, compId);
2940 EXPECT_EQ(result, ERR_APPEXECFWK_FORM_SERVER_STATUS_ERR);
2941 GTEST_LOG_(INFO) << "FormMgrTest_0155 test ends";
2942 }
2943
2944 /**
2945 * @tc.name: FormMgrTest_0156
2946 * @tc.desc: Verify SetNextRefreshTime
2947 * @tc.type: FUNC
2948 */
2949 HWTEST_F(FormMgrTest, FormMgrTest_0156, TestSize.Level1)
2950 {
2951 GTEST_LOG_(INFO) << "FormMgrTest_0156 starts";
2952 EXPECT_CALL(*mockProxy, SetNextRefreshTime(_, _))
2953 .Times(1)
2954 .WillOnce(Return(0));
2955 int64_t formId = FORM_ID;
2956 int64_t nextTime = 50;
2957 FormMgr::GetInstance().SetRecoverStatus(Constants::NOT_IN_RECOVERY);
2958 auto result = FormMgr::GetInstance().SetNextRefreshTime(formId, nextTime);
2959 EXPECT_EQ(result, 0);
2960 GTEST_LOG_(INFO) << "FormMgrTest_0156 test ends";
2961 }
2962
2963 /**
2964 * @tc.name: FormMgrTest_0157
2965 * @tc.desc: Verify RequestPublishForm
2966 * @tc.type: FUNC
2967 */
2968 HWTEST_F(FormMgrTest, FormMgrTest_0157, TestSize.Level1)
2969 {
2970 GTEST_LOG_(INFO) << "FormMgrTest_0157 starts";
2971 EXPECT_CALL(*mockProxy, RequestPublishForm(_, _, _, _))
2972 .Times(1)
2973 .WillOnce(Return(NEGATIVE_NUM));
2974 Want want;
2975 int64_t formId = FORM_ID;
2976 std::unique_ptr<FormProviderData> formProviderData;
2977 std::vector<FormDataProxy> formDataProxies;
2978 int32_t result = FormMgr::GetInstance().RequestPublishForm(want, true, formProviderData, formId, formDataProxies);
2979 EXPECT_EQ(result, NEGATIVE_NUM);
2980 GTEST_LOG_(INFO) << "FormMgrTest_0157 test ends";
2981 }
2982
2983 /**
2984 * @tc.name: FormMgrTest_0158
2985 * @tc.desc: Verify SetPublishFormResult
2986 * @tc.type: FUNC
2987 */
2988 HWTEST_F(FormMgrTest, FormMgrTest_0158, TestSize.Level1)
2989 {
2990 GTEST_LOG_(INFO) << "FormMgrTest_0158 starts";
2991 EXPECT_CALL(*mockProxy, SetPublishFormResult(_, _))
2992 .Times(1)
2993 .WillOnce(Return(OHOS::ERR_OK));
2994 Constants::PublishFormResult errorCodeInfo{Constants::PublishFormErrorCode::SUCCESS, ""};
2995 int64_t formId = FORM_ID;
2996 ErrCode result = FormMgr::GetInstance().SetPublishFormResult(formId, errorCodeInfo);
2997 EXPECT_EQ(result, OHOS::ERR_OK);
2998 GTEST_LOG_(INFO) << "FormMgrTest_0158 test ends";
2999 }
3000
3001 /**
3002 * @tc.name: FormMgrTest_0159
3003 * @tc.desc: Verify AcquireAddFormResult
3004 * @tc.type: FUNC
3005 */
3006 HWTEST_F(FormMgrTest, FormMgrTest_0159, TestSize.Level1)
3007 {
3008 GTEST_LOG_(INFO) << "FormMgrTest_0159 starts";
3009 EXPECT_CALL(*mockProxy, AcquireAddFormResult(_))
3010 .Times(1)
3011 .WillOnce(Return(OHOS::ERR_OK));
3012 int64_t formId = FORM_ID;
3013 EXPECT_EQ(FormMgr::GetInstance().AcquireAddFormResult(formId), OHOS::ERR_OK);
3014 GTEST_LOG_(INFO) << "FormMgrTest_0159 test ends";
3015 }
3016
3017 /**
3018 * @tc.name: FormMgrTest_0160
3019 * @tc.desc: Verify LifecycleUpdate
3020 * @tc.type: FUNC
3021 */
3022 HWTEST_F(FormMgrTest, FormMgrTest_0160, TestSize.Level1)
3023 {
3024 GTEST_LOG_(INFO) << "FormMgrTest_0160 starts";
3025 EXPECT_CALL(*mockProxy, LifecycleUpdate(_, _, _))
3026 .Times(1)
3027 .WillOnce(Return(0));
3028 std::vector<int64_t> formIds;
3029 int64_t formId = FORM_ID;
3030 formIds.emplace_back(formId);
3031 sptr<MockFormToken> token = new (std::nothrow) MockFormToken();
3032 int result = FormMgr::GetInstance().LifecycleUpdate(formIds, token, true);
3033 EXPECT_EQ(result, 0);
3034 GTEST_LOG_(INFO) << "FormMgrTest_0160 test ends";
3035 }
3036
3037 /**
3038 * @tc.name: FormMgrTest_0161
3039 * @tc.desc: Verify GetRecoverStatus
3040 * @tc.type: FUNC
3041 */
3042 HWTEST_F(FormMgrTest, FormMgrTest_0161, TestSize.Level1)
3043 {
3044 GTEST_LOG_(INFO) << "FormMgrTest_0161 starts";
3045 FormMgr::GetInstance().SetRecoverStatus(Constants::IN_RECOVERING);
3046 EXPECT_TRUE(FormMgr::GetInstance().GetRecoverStatus() == Constants::IN_RECOVERING);
3047 GTEST_LOG_(INFO) << "FormMgrTest_0161 test ends";
3048 }
3049
3050 /**
3051 * @tc.name: FormMgrTest_0162
3052 * @tc.desc: Verify GetFormInstancesByFilter
3053 * @tc.type: FUNC
3054 */
3055 HWTEST_F(FormMgrTest, FormMgrTest_0162, TestSize.Level1)
3056 {
3057 GTEST_LOG_(INFO) << "FormMgrTest_0162 starts";
3058 EXPECT_CALL(*mockProxy, GetFormInstanceById(_, _, _))
3059 .Times(1)
3060 .WillOnce(Return(OHOS::ERR_OK));
3061 int64_t formId = FORM_ID;
3062 FormInstance formInstance;
3063 auto result = FormMgr::GetInstance().GetFormInstanceById(formId, true, formInstance);
3064 EXPECT_EQ(result, OHOS::ERR_OK);
3065 GTEST_LOG_(INFO) << "FormMgrTest_0162 test ends";
3066 }
3067
3068 /**
3069 * @tc.name: FormMgrTest_0163
3070 * @tc.desc: Verify IsSystemAppForm
3071 * @tc.type: FUNC
3072 */
3073 HWTEST_F(FormMgrTest, FormMgrTest_0163, TestSize.Level1)
3074 {
3075 GTEST_LOG_(INFO) << "FormMgrTest_0163 starts";
3076 EXPECT_CALL(*mockProxy, IsSystemAppForm(_))
3077 .Times(1)
3078 .WillOnce(Return(true));
3079 std::string bundle = "bundle";
3080 bool result = FormMgr::GetInstance().IsSystemAppForm(bundle);
3081 EXPECT_EQ(result, true);
3082 GTEST_LOG_(INFO) << "FormMgrTest_0163 test ends";
3083 }
3084
3085 /**
3086 * @tc.name: FormMgrTest_0164
3087 * @tc.desc: Verify GetRunningFormInfosByBundleName
3088 * @tc.type: FUNC
3089 */
3090 HWTEST_F(FormMgrTest, FormMgrTest_0164, TestSize.Level1)
3091 {
3092 GTEST_LOG_(INFO) << "FormMgrTest_0164 starts";
3093 std::string bundleName;
3094 bool isUnusedInclude = false;
3095 std::vector<RunningFormInfo> runningFormInfos;
3096 int result = FormMgr::GetInstance().GetRunningFormInfosByBundleName(bundleName, isUnusedInclude, runningFormInfos);
3097 EXPECT_EQ(result, ERR_APPEXECFWK_FORM_INVALID_BUNDLENAME);
3098 GTEST_LOG_(INFO) << "FormMgrTest_0164 test ends";
3099 }
3100
3101 /**
3102 * @tc.name: FormMgrTest_0165
3103 * @tc.desc: Verify GetFormsCount
3104 * @tc.type: FUNC
3105 */
3106 HWTEST_F(FormMgrTest, FormMgrTest_0165, TestSize.Level1)
3107 {
3108 GTEST_LOG_(INFO) << "FormMgrTest_0165 starts";
3109 EXPECT_CALL(*mockProxy, GetFormsCount(_, _))
3110 .Times(1)
3111 .WillOnce(Return(ERR_FAILED));
3112 bool isTempFormFlag = true;
3113 int32_t formCount = 0;
3114 FormMgr::GetInstance().SetRecoverStatus(Constants::NOT_IN_RECOVERY);
3115 int result = FormMgr::GetInstance().GetFormsCount(isTempFormFlag, formCount);
3116 EXPECT_EQ(result, ERR_FAILED);
3117 GTEST_LOG_(INFO) << "FormMgrTest_0165 test ends";
3118 }
3119
3120 /**
3121 * @tc.name: FormMgrTest_0166
3122 * @tc.desc: Verify GetHostFormsCount
3123 * @tc.type: FUNC
3124 */
3125 HWTEST_F(FormMgrTest, FormMgrTest_0166, TestSize.Level1)
3126 {
3127 GTEST_LOG_(INFO) << "FormMgrTest_0166 starts";
3128 EXPECT_CALL(*mockProxy, GetHostFormsCount(_, _))
3129 .Times(1)
3130 .WillOnce(Return(ERR_FAILED));
3131 std::string bundleName = "this is bundleName";
3132 int32_t formCount = 0;
3133 FormMgr::GetInstance().SetRecoverStatus(Constants::NOT_IN_RECOVERY);
3134 int result = FormMgr::GetInstance().GetHostFormsCount(bundleName, formCount);
3135 EXPECT_EQ(result, ERR_FAILED);
3136 GTEST_LOG_(INFO) << "FormMgrTest_0166 test ends";
3137 }
3138
3139 /**
3140 * @tc.name: FormMgrTest_0167
3141 * @tc.desc: Verify RegisterAddObserver
3142 * @tc.type: FUNC
3143 */
3144 HWTEST_F(FormMgrTest, FormMgrTest_0167, TestSize.Level1)
3145 {
3146 GTEST_LOG_(INFO) << "FormMgrTest_0167 starts";
3147 EXPECT_CALL(*mockProxy, RegisterAddObserver(_, _))
3148 .Times(1)
3149 .WillOnce(Return(0));
3150 FormMgr::GetInstance().SetRecoverStatus(Constants::NOT_IN_RECOVERY);
3151 std::string bundleName = "this is a bundleName";
3152 sptr<IRemoteObject> callerToken = new (std::nothrow) MockFormProviderClient();
3153 ErrCode result = FormMgr::GetInstance().RegisterAddObserver(bundleName, callerToken);
3154 EXPECT_EQ(result, 0);
3155 GTEST_LOG_(INFO) << "FormMgrTest_0167 test ends";
3156 }
3157
3158 /**
3159 * @tc.name: FormMgrTest_0168
3160 * @tc.desc: Verify RegisterRemoveObserver
3161 * @tc.type: FUNC
3162 */
3163 HWTEST_F(FormMgrTest, FormMgrTest_0168, TestSize.Level1)
3164 {
3165 GTEST_LOG_(INFO) << "FormMgrTest_0168 starts";
3166 EXPECT_CALL(*mockProxy, RegisterRemoveObserver(_, _))
3167 .Times(1)
3168 .WillOnce(Return(OHOS::ERR_OK));
3169 FormMgr::GetInstance().SetRecoverStatus(Constants::NOT_IN_RECOVERY);
3170 std::string bundleName = "a";
3171 sptr<IRemoteObject> callerToken = new (std::nothrow) MockFormProviderClient();
3172 ErrCode result = FormMgr::GetInstance().RegisterRemoveObserver(bundleName, callerToken);
3173 EXPECT_EQ(result, OHOS::ERR_OK);
3174 GTEST_LOG_(INFO) << "FormMgrTest_0168 test ends";
3175 }
3176
3177 /**
3178 * @tc.name: FormMgrTest_0169
3179 * @tc.desc: Verify RegisterFormRouterProxy
3180 * @tc.type: FUNC
3181 */
3182 HWTEST_F(FormMgrTest, FormMgrTest_0169, TestSize.Level1)
3183 {
3184 GTEST_LOG_(INFO) << "FormMgrTest_0169 starts";
3185 EXPECT_CALL(*mockProxy, RegisterFormRouterProxy(_, _))
3186 .Times(1)
3187 .WillOnce(Return(OHOS::ERR_OK));
3188 FormMgr::GetInstance().SetRecoverStatus(Constants::NOT_IN_RECOVERY);
3189 std::vector<int64_t> formIds;
3190 formIds.push_back(0);
3191 sptr<IRemoteObject> callerToken = new (std::nothrow) MockFormProviderClient();
3192 ErrCode result = FormMgr::GetInstance().RegisterFormRouterProxy(formIds, callerToken);
3193 EXPECT_EQ(result, OHOS::ERR_OK);
3194 GTEST_LOG_(INFO) << "FormMgrTest_0169 test ends";
3195 }
3196
3197 /**
3198 * @tc.name: FormMgrTest_0170
3199 * @tc.desc: Verify UnregisterFormRouterProxy
3200 * @tc.type: FUNC
3201 */
3202 HWTEST_F(FormMgrTest, FormMgrTest_0170, TestSize.Level1)
3203 {
3204 GTEST_LOG_(INFO) << "FormMgrTest_0170 starts";
3205 EXPECT_CALL(*mockProxy, UnregisterFormRouterProxy(_))
3206 .Times(1)
3207 .WillOnce(Return(OHOS::ERR_OK));
3208 FormMgr::GetInstance().SetRecoverStatus(Constants::NOT_IN_RECOVERY);
3209 std::vector<int64_t> formIds;
3210 formIds.push_back(0);
3211 ErrCode result = FormMgr::GetInstance().UnregisterFormRouterProxy(formIds);
3212 EXPECT_EQ(result, OHOS::ERR_OK);
3213 GTEST_LOG_(INFO) << "FormMgrTest_0170 test ends";
3214 }
3215
3216 /**
3217 * @tc.name: FormMgrTest_0171
3218 * @tc.desc: Verify UpdateFormLocation
3219 * @tc.type: FUNC
3220 */
3221 HWTEST_F(FormMgrTest, FormMgrTest_0171, TestSize.Level1)
3222 {
3223 GTEST_LOG_(INFO) << "FormMgrTest_0171 starts";
3224 EXPECT_CALL(*mockProxy, UpdateFormLocation(_, _))
3225 .Times(1)
3226 .WillOnce(Return(OHOS::ERR_OK));
3227 sptr<MockFormToken> token = new (std::nothrow) MockFormToken();
3228 FormMgr::GetInstance().SetRecoverStatus(Constants::NOT_IN_RECOVERY);
3229 int64_t formId = FORM_ID;
3230 int32_t formLocation = 1;
3231 EXPECT_EQ(FormMgr::GetInstance().UpdateFormLocation(formId, formLocation), OHOS::ERR_OK);
3232 GTEST_LOG_(INFO) << "FormMgrTest_0171 test ends";
3233 }
3234
3235 /**
3236 * @tc.name: FormMgrTest_0172
3237 * @tc.desc: Verify AddForm
3238 * @tc.type: FUNC
3239 */
3240 HWTEST_F(FormMgrTest, FormMgrTest_0172, TestSize.Level1)
3241 {
3242 GTEST_LOG_(INFO) << "FormMgrTest_0172 starts";
3243 int64_t formId = FORM_ID;
3244 Want want;
3245 FormJsInfo formInfo;
3246 FormMgr::GetInstance().resetFlag_ = true;
3247 sptr<MockFormToken> token = new (std::nothrow) MockFormToken();
3248 auto data = FormMgr::GetInstance().AddForm(formId, want, token, formInfo);
3249 EXPECT_EQ(data, ERR_APPEXECFWK_FORM_COMMON_CODE);
3250 FormMgr::GetInstance().resetFlag_ = false;
3251 GTEST_LOG_(INFO) << "FormMgrTest_0172 test ends";
3252 }
3253
3254 /**
3255 * @tc.name: FormMgrTest_0173
3256 * @tc.desc: Verify CreateForm
3257 * @tc.type: FUNC
3258 */
3259 HWTEST_F(FormMgrTest, FormMgrTest_0173, TestSize.Level1)
3260 {
3261 GTEST_LOG_(INFO) << "FormMgrTest_0173 starts";
3262 Want want;
3263 FormMgr::GetInstance().resetFlag_ = true;
3264 RunningFormInfo runningFormInfo;
3265 int result = FormMgr::GetInstance().CreateForm(want, runningFormInfo);
3266 EXPECT_EQ(result, ERR_APPEXECFWK_FORM_COMMON_CODE);
3267 FormMgr::GetInstance().resetFlag_ = false;
3268 GTEST_LOG_(INFO) << "FormMgrTest_0173 test ends";
3269 }
3270
3271 /**
3272 * @tc.name: FormMgrTest_0174
3273 * @tc.desc: Verify DeleteForm
3274 * @tc.type: FUNC
3275 */
3276 HWTEST_F(FormMgrTest, FormMgrTest_0174, TestSize.Level1)
3277 {
3278 GTEST_LOG_(INFO) << "FormMgrTest_0174 starts";
3279 int64_t formId = FORM_ID;
3280 FormMgr::GetInstance().resetFlag_ = true;
3281 sptr<MockFormToken> token = new (std::nothrow) MockFormToken();
3282 FormMgr::GetInstance().SetRecoverStatus(Constants::NOT_IN_RECOVERY);
3283 int result = FormMgr::GetInstance().DeleteForm(formId, token);
3284 EXPECT_EQ(result, ERR_APPEXECFWK_FORM_COMMON_CODE);
3285 FormMgr::GetInstance().resetFlag_ = false;
3286 GTEST_LOG_(INFO) << "FormMgrTest_0174 test ends";
3287 }
3288
3289 /**
3290 * @tc.name: FormMgrTest_0175
3291 * @tc.desc: Verify StopRenderingForm
3292 * @tc.type: FUNC
3293 */
3294 HWTEST_F(FormMgrTest, FormMgrTest_0175, TestSize.Level1)
3295 {
3296 GTEST_LOG_(INFO) << "FormMgrTest_0175 starts";
3297 int64_t formId = FORM_ID;
3298 std::string compId = "this is compId";
3299 FormMgr::GetInstance().resetFlag_ = true;
3300 int result = FormMgr::GetInstance().StopRenderingForm(formId, compId);
3301 EXPECT_EQ(result, ERR_APPEXECFWK_FORM_COMMON_CODE);
3302 FormMgr::GetInstance().resetFlag_ = false;
3303 GTEST_LOG_(INFO) << "FormMgrTest_0175 test ends";
3304 }
3305
3306 /**
3307 * @tc.name: FormMgrTest_0176
3308 * @tc.desc: Verify StopRenderingForm
3309 * @tc.type: FUNC
3310 */
3311 HWTEST_F(FormMgrTest, FormMgrTest_0176, TestSize.Level1)
3312 {
3313 GTEST_LOG_(INFO) << "FormMgrTest_0176 starts";
3314 EXPECT_CALL(*mockProxy, StopRenderingForm(_, _))
3315 .Times(1)
3316 .WillOnce(Return(OHOS::ERR_OK));
3317 int64_t formId = FORM_ID;
3318 std::string compId = "this is compId";
3319 FormMgr::GetInstance().SetFormMgrService(mockProxy);
3320 int result = FormMgr::GetInstance().StopRenderingForm(formId, compId);
3321 EXPECT_EQ(result, OHOS::ERR_OK);
3322 GTEST_LOG_(INFO) << "FormMgrTest_0176 test ends";
3323 }
3324
3325 /**
3326 * @tc.name: FormMgrTest_0177
3327 * @tc.desc: Verify ReleaseRenderer
3328 * @tc.type: FUNC
3329 */
3330 HWTEST_F(FormMgrTest, FormMgrTest_0177, TestSize.Level1)
3331 {
3332 GTEST_LOG_(INFO) << "FormMgrTest_0177 starts";
3333 int64_t formId = FORM_ID;
3334 std::string compId = "this is compId";
3335 FormMgr::GetInstance().resetFlag_ = true;
3336 int result = FormMgr::GetInstance().ReleaseRenderer(formId, compId);
3337 EXPECT_EQ(result, ERR_APPEXECFWK_FORM_COMMON_CODE);
3338 FormMgr::GetInstance().resetFlag_ = false;
3339 GTEST_LOG_(INFO) << "FormMgrTest_0177 test ends";
3340 }
3341
3342 /**
3343 * @tc.name: FormMgrTest_0178
3344 * @tc.desc: Verify RequestForm
3345 * @tc.type: FUNC
3346 */
3347 HWTEST_F(FormMgrTest, FormMgrTest_0178, TestSize.Level1)
3348 {
3349 GTEST_LOG_(INFO) << "FormMgrTest_0178 starts";
3350 Want want;
3351 want = want.SetElementName("", "com.example.FormAbility", "MainAbility");
3352 sptr<MockFormToken> token = new (std::nothrow) MockFormToken();
3353 FormJsInfo formJsInfo;
3354 formJsInfo.formId = 0x00000008fffffffL;
3355 FormMgr::GetInstance().resetFlag_ = true;
3356 FormMgr::GetInstance().SetRecoverStatus(Constants::NOT_IN_RECOVERY);
3357 int32_t result = FormMgr::GetInstance().RequestForm(formJsInfo.formId, token, want);
3358 EXPECT_EQ(result, ERR_APPEXECFWK_FORM_COMMON_CODE);
3359 FormMgr::GetInstance().resetFlag_ = false;
3360 GTEST_LOG_(INFO) << "FormMgrTest_0178 test ends";
3361 }
3362
3363 /**
3364 * @tc.name: FormMgrTest_0179
3365 * @tc.desc: Verify NotifyWhetherVisibleForms
3366 * @tc.type: FUNC
3367 */
3368 HWTEST_F(FormMgrTest, FormMgrTest_0179, TestSize.Level1)
3369 {
3370 GTEST_LOG_(INFO) << "FormMgrTest_0179 starts";
3371 std::vector<int64_t> formIds;
3372 int64_t formId = FORM_ID;
3373 formIds.emplace_back(formId);
3374 sptr<MockFormToken> token = new (std::nothrow) MockFormToken();
3375 int32_t formVisibleType = 1;
3376 FormMgr::GetInstance().resetFlag_ = true;
3377 FormMgr::GetInstance().SetRecoverStatus(Constants::NOT_IN_RECOVERY);
3378 int result = FormMgr::GetInstance().NotifyWhetherVisibleForms(formIds, token, formVisibleType);
3379 EXPECT_EQ(result, ERR_APPEXECFWK_FORM_COMMON_CODE);
3380 FormMgr::GetInstance().resetFlag_ = false;
3381 GTEST_LOG_(INFO) << "FormMgrTest_0179 test ends";
3382 }
3383
3384 /**
3385 * @tc.name: FormMgrTest_0180
3386 * @tc.desc: Verify HasFormVisible
3387 * @tc.type: FUNC
3388 */
3389 HWTEST_F(FormMgrTest, FormMgrTest_0180, TestSize.Level1)
3390 {
3391 GTEST_LOG_(INFO) << "FormMgrTest_0180 starts";
3392 FormMgr::GetInstance().resetFlag_ = true;
3393 uint32_t tokenId = 0;
3394 bool result = FormMgr::GetInstance().HasFormVisible(tokenId);
3395 EXPECT_EQ(result, false);
3396 FormMgr::GetInstance().resetFlag_ = false;
3397 GTEST_LOG_(INFO) << "FormMgrTest_0180 test ends";
3398 }
3399
3400 /**
3401 * @tc.name: FormMgrTest_0181
3402 * @tc.desc: Verify ReleaseForm (Parameters are normal.)
3403 * @tc.type: FUNC
3404 */
3405 HWTEST_F(FormMgrTest, FormMgrTest_0181, TestSize.Level1)
3406 {
3407 GTEST_LOG_(INFO) << "FormMgrTest_0181 starts";
3408 int64_t formId = FORM_ID;
3409 sptr<MockFormToken> token = new (std::nothrow) MockFormToken();
3410 bool delCache = true;
3411 FormMgr::GetInstance().resetFlag_ = true;
3412 FormMgr::GetInstance().SetRecoverStatus(Constants::NOT_IN_RECOVERY);
3413 int result = FormMgr::GetInstance().ReleaseForm(formId, token, delCache);
3414 EXPECT_EQ(result, ERR_APPEXECFWK_FORM_COMMON_CODE);
3415 FormMgr::GetInstance().resetFlag_ = false;
3416 GTEST_LOG_(INFO) << "FormMgrTest_0181 test ends";
3417 }
3418
3419 /**
3420 * @tc.name: FormMgrTest_0182
3421 * @tc.desc: Verify CastTempForm
3422 * @tc.type: FUNC
3423 */
3424 HWTEST_F(FormMgrTest, FormMgrTest_0182, TestSize.Level1)
3425 {
3426 GTEST_LOG_(INFO) << "FormMgrTest_0182 starts";
3427 FormMgr::GetInstance().resetFlag_ = true;
3428 int64_t formId = FORM_ID;
3429 sptr<MockFormToken> token = new (std::nothrow) MockFormToken();
3430 int result = FormMgr::GetInstance().CastTempForm(formId, token);
3431 EXPECT_EQ(result, ERR_APPEXECFWK_FORM_COMMON_CODE);
3432 FormMgr::GetInstance().resetFlag_ = false;
3433 GTEST_LOG_(INFO) << "FormMgrTest_0182 test ends";
3434 }
3435
3436 /**
3437 * @tc.name: FormMgrTest_0183
3438 * @tc.desc: Verify DumpStorageFormInfos
3439 * @tc.type: FUNC
3440 */
3441 HWTEST_F(FormMgrTest, FormMgrTest_0183, TestSize.Level1)
3442 {
3443 GTEST_LOG_(INFO) << "FormMgrTest_0183 starts";
3444 FormMgr::GetInstance().resetFlag_ = true;
3445 std::string formInfos = "a";
3446 auto result = FormMgr::GetInstance().DumpStorageFormInfos(formInfos);
3447 EXPECT_EQ(result, ERR_APPEXECFWK_FORM_COMMON_CODE);
3448 FormMgr::GetInstance().resetFlag_ = false;
3449 GTEST_LOG_(INFO) << "FormMgrTest_0183 test ends";
3450 }
3451
3452 /**
3453 * @tc.name: FormMgrTest_0184
3454 * @tc.desc: Verify DumpFormInfoByBundleName
3455 * @tc.type: FUNC
3456 */
3457 HWTEST_F(FormMgrTest, FormMgrTest_0184, TestSize.Level1)
3458 {
3459 GTEST_LOG_(INFO) << "FormMgrTest_0184 starts";
3460 FormMgr::GetInstance().resetFlag_ = true;
3461 std::string bundleName = "b";
3462 std::string formInfos = "a";
3463 auto result = FormMgr::GetInstance().DumpFormInfoByBundleName(bundleName, formInfos);
3464 FormMgr::GetInstance().resetFlag_ = false;
3465 EXPECT_EQ(result, ERR_APPEXECFWK_FORM_COMMON_CODE);
3466 GTEST_LOG_(INFO) << "FormMgrTest_0184 test ends";
3467 }
3468
3469 /**
3470 * @tc.name: FormMgrTest_0185
3471 * @tc.desc: Verify DumpFormInfoByFormId
3472 * @tc.type: FUNC
3473 */
3474 HWTEST_F(FormMgrTest, FormMgrTest_0185, TestSize.Level1)
3475 {
3476 GTEST_LOG_(INFO) << "FormMgrTest_0185 starts";
3477 std::string formInfos = "a";
3478 FormMgr::GetInstance().resetFlag_ = true;
3479 auto result = FormMgr::GetInstance().DumpFormInfoByFormId(FORM_ID, formInfos);
3480 EXPECT_EQ(result, ERR_APPEXECFWK_FORM_COMMON_CODE);
3481 FormMgr::GetInstance().resetFlag_ = false;
3482 GTEST_LOG_(INFO) << "FormMgrTest_0185 test ends";
3483 }
3484
3485 /**
3486 * @tc.name: FormMgrTest_0186
3487 * @tc.desc: Verify DumpFormTimerByFormId
3488 * @tc.type: FUNC
3489 */
3490 HWTEST_F(FormMgrTest, FormMgrTest_0186, TestSize.Level1)
3491 {
3492 GTEST_LOG_(INFO) << "FormMgrTest_0186 starts";
3493 std::string isTimingService = "b";
3494 FormMgr::GetInstance().resetFlag_ = true;
3495 auto result = FormMgr::GetInstance().DumpFormTimerByFormId(FORM_ID, isTimingService);
3496 EXPECT_EQ(result, ERR_APPEXECFWK_FORM_COMMON_CODE);
3497 FormMgr::GetInstance().resetFlag_ = false;
3498 GTEST_LOG_(INFO) << "FormMgrTest_0186 test ends";
3499 }
3500
3501 /**
3502 * @tc.name: FormMgrTest_0187
3503 * @tc.desc: Verify MessageEvent
3504 * @tc.type: FUNC
3505 */
3506 HWTEST_F(FormMgrTest, FormMgrTest_0187, TestSize.Level1)
3507 {
3508 GTEST_LOG_(INFO) << "FormMgrTest_0187 starts";
3509 FormMgr::GetInstance().resetFlag_ = true;
3510 Want want;
3511 want = want.SetElementName("", "com.example.FormAbility", "MainAbility");
3512 sptr<MockFormToken> token = new (std::nothrow) MockFormToken();
3513 FormJsInfo formJsInfo;
3514 sptr<IRemoteObject> providerToken = new (std::nothrow) MockFormProviderClient();
3515 FormCallerMgr::GetInstance().AddFormHostCaller(formJsInfo, providerToken);
3516 int32_t result = FormMgr::GetInstance().MessageEvent(formJsInfo.formId, want, token);
3517 EXPECT_EQ(result, ERR_APPEXECFWK_FORM_COMMON_CODE);
3518 FormMgr::GetInstance().resetFlag_ = false;
3519 GTEST_LOG_(INFO) << "FormMgrTest_0187 test ends";
3520 }
3521
3522 /**
3523 * @tc.name: FormMgrTest_0188
3524 * @tc.desc: Verify RouterEvent
3525 * @tc.type: FUNC
3526 */
3527 HWTEST_F(FormMgrTest, FormMgrTest_0188, TestSize.Level1)
3528 {
3529 GTEST_LOG_(INFO) << "FormMgrTest_0188 starts";
3530 FormMgr::GetInstance().resetFlag_ = true;
3531 Want want;
3532 want = want.SetElementName("", "com.example.FormAbility", "MainAbility");
3533 sptr<MockFormToken> token = new (std::nothrow) MockFormToken();
3534 FormJsInfo formJsInfo;
3535 sptr<IRemoteObject> providerToken = new (std::nothrow) MockFormProviderClient();
3536 FormCallerMgr::GetInstance().AddFormHostCaller(formJsInfo, providerToken);
3537 int32_t result = FormMgr::GetInstance().RouterEvent(formJsInfo.formId, want, token);
3538 FormMgr::GetInstance().resetFlag_ = false;
3539 EXPECT_EQ(result, ERR_APPEXECFWK_FORM_COMMON_CODE);
3540 GTEST_LOG_(INFO) << "FormMgrTest_0188 test ends";
3541 }
3542
3543 /**
3544 * @tc.name: FormMgrTest_0189
3545 * @tc.desc: Verify BackgroundEvent
3546 * @tc.type: FUNC
3547 */
3548 HWTEST_F(FormMgrTest, FormMgrTest_0189, TestSize.Level1)
3549 {
3550 GTEST_LOG_(INFO) << "FormMgrTest_0189 starts";
3551 FormMgr::GetInstance().SetRecoverStatus(Constants::IN_RECOVERING);
3552 Want want;
3553 std::string bundleName = "a";
3554 FormMgr::GetInstance().resetFlag_ = true;
3555 sptr<IRemoteObject> callerToken = new (std::nothrow) MockFormProviderClient();
3556 int result = FormMgr::GetInstance().BackgroundEvent(FORM_ID, want, callerToken);
3557 EXPECT_EQ(result, ERR_APPEXECFWK_FORM_COMMON_CODE);
3558 FormMgr::GetInstance().resetFlag_ = false;
3559 GTEST_LOG_(INFO) << "FormMgrTest_0189 test ends";
3560 }
3561
3562 /**
3563 * @tc.name: FormMgrTest_0190
3564 * @tc.desc: Verify SetNextRefreshTime
3565 * @tc.type: FUNC
3566 */
3567 HWTEST_F(FormMgrTest, FormMgrTest_0190, TestSize.Level1)
3568 {
3569 GTEST_LOG_(INFO) << "FormMgrTest_0190 starts";
3570 FormMgr::GetInstance().resetFlag_ = true;
3571 int64_t nextTime = 50;
3572 FormMgr::GetInstance().SetRecoverStatus(Constants::NOT_IN_RECOVERY);
3573 auto result = FormMgr::GetInstance().SetNextRefreshTime(FORM_ID, nextTime);
3574 EXPECT_EQ(result, ERR_APPEXECFWK_FORM_COMMON_CODE);
3575 FormMgr::GetInstance().resetFlag_ = false;
3576 GTEST_LOG_(INFO) << "FormMgrTest_0190 test ends";
3577 }
3578
3579 /**
3580 * @tc.name: FormMgrTest_0191
3581 * @tc.desc: Verify SetPublishFormResult
3582 * @tc.type: FUNC
3583 */
3584 HWTEST_F(FormMgrTest, FormMgrTest_0191, TestSize.Level1)
3585 {
3586 GTEST_LOG_(INFO) << "FormMgrTest_0191 starts";
3587 FormMgr::GetInstance().resetFlag_ = true;
3588 Constants::PublishFormResult errorCodeInfo{Constants::PublishFormErrorCode::SUCCESS, ""};
3589 ErrCode result = FormMgr::GetInstance().SetPublishFormResult(FORM_ID, errorCodeInfo);
3590 EXPECT_EQ(result, ERR_APPEXECFWK_FORM_COMMON_CODE);
3591 FormMgr::GetInstance().resetFlag_ = false;
3592 GTEST_LOG_(INFO) << "FormMgrTest_0191 test ends";
3593 }
3594
3595 /**
3596 * @tc.name: FormMgrTest_0192
3597 * @tc.desc: Verify AcquireAddFormResult
3598 * @tc.type: FUNC
3599 */
3600 HWTEST_F(FormMgrTest, FormMgrTest_0192, TestSize.Level1)
3601 {
3602 GTEST_LOG_(INFO) << "FormMgrTest_0192 starts";
3603 FormMgr::GetInstance().resetFlag_ = true;
3604 EXPECT_EQ(FormMgr::GetInstance().AcquireAddFormResult(FORM_ID), ERR_APPEXECFWK_FORM_COMMON_CODE);
3605 FormMgr::GetInstance().resetFlag_ = false;
3606 GTEST_LOG_(INFO) << "FormMgrTest_0192 test ends";
3607 }
3608
3609 /**
3610 * @tc.name: FormMgrTest_0193
3611 * @tc.desc: Verify LifecycleUpdate
3612 * @tc.type: FUNC
3613 */
3614 HWTEST_F(FormMgrTest, FormMgrTest_0193, TestSize.Level1)
3615 {
3616 GTEST_LOG_(INFO) << "FormMgrTest_0193 starts";
3617 FormMgr::GetInstance().resetFlag_ = true;
3618 std::vector<int64_t> formIds;
3619 formIds.emplace_back(FORM_ID);
3620 sptr<MockFormToken> token = new (std::nothrow) MockFormToken();
3621 bool updateType = true;
3622 int result = FormMgr::GetInstance().LifecycleUpdate(formIds, token, updateType);
3623 EXPECT_EQ(result, ERR_APPEXECFWK_FORM_COMMON_CODE);
3624 FormMgr::GetInstance().resetFlag_ = false;
3625 GTEST_LOG_(INFO) << "FormMgrTest_0193 test ends";
3626 }
3627
3628 /**
3629 * @tc.name: FormMgrTest_0194
3630 * @tc.desc: Verify OnRemoteDied
3631 * @tc.type: FUNC
3632 */
3633 HWTEST_F(FormMgrTest, FormMgrTest_0194, TestSize.Level1)
3634 {
3635 GTEST_LOG_(INFO) << "FormMgrTest_0194 starts";
3636 sptr<IRemoteObject> mockFormProviderClient = new (std::nothrow) MockFormProviderClient();
3637 sptr<FormMgr::FormMgrDeathRecipient> formMgrDeath = new (std::nothrow) FormMgr::FormMgrDeathRecipient();
3638 FormMgr::GetInstance().resetFlag_ = true;
3639 FormMgr::GetInstance().SetRecoverStatus(Constants::NOT_IN_RECOVERY);
3640 formMgrDeath->OnRemoteDied(mockFormProviderClient);
3641 EXPECT_TRUE(FormMgr::GetInstance().GetRecoverStatus() == Constants::RECOVER_FAIL);
3642 FormMgr::GetInstance().resetFlag_ = false;
3643 GTEST_LOG_(INFO) << "FormMgrTest_0194 test ends";
3644 }
3645
3646 /**
3647 * @tc.name: FormMgrTest_0195
3648 * @tc.desc: Verify NotifyFormsPrivacyProtected
3649 * @tc.type: FUNC
3650 */
3651 HWTEST_F(FormMgrTest, FormMgrTest_0195, TestSize.Level1)
3652 {
3653 GTEST_LOG_(INFO) << "FormMgrTest_0195 starts";
3654 std::vector<int64_t> formIds;
3655 formIds.push_back(FORM_ID);
3656 bool isProtected = false;
3657 FormMgr::GetInstance().resetFlag_ = true;
3658 sptr<MockFormToken> token = new (std::nothrow) MockFormToken();
3659 int32_t result = FormMgr::GetInstance().NotifyFormsPrivacyProtected(formIds, isProtected, token);
3660 EXPECT_EQ(result, ERR_APPEXECFWK_FORM_COMMON_CODE);
3661 FormMgr::GetInstance().resetFlag_ = false;
3662 GTEST_LOG_(INFO) << "FormMgrTest_0195 test ends";
3663 }
3664
3665 /**
3666 * @tc.name: FormMgrTest_0196
3667 * @tc.desc: Verify DeleteInvalidForms
3668 * @tc.type: FUNC
3669 */
3670 HWTEST_F(FormMgrTest, FormMgrTest_0196, TestSize.Level1)
3671 {
3672 GTEST_LOG_(INFO) << "FormMgrTest_0196 starts";
3673 EXPECT_CALL(*mockProxy, DeleteInvalidForms(_, _, _))
3674 .Times(1)
3675 .WillOnce(Return(ERR_FAILED));
3676 std::vector<int64_t> formInfos;
3677 formInfos.push_back(FORM_ID);
3678 FormJsInfo formJsInfo;
3679 FormMgr::GetInstance().SetFormMgrService(mockProxy);
3680 FormMgr::GetInstance().resetFlag_ = false;
3681 sptr<MockFormToken> token = new (std::nothrow) MockFormToken();
3682 int32_t numFormsDeleted = 2;
3683 auto result = FormMgr::GetInstance().DeleteInvalidForms(formInfos, token, numFormsDeleted);
3684 EXPECT_EQ(result, ERR_FAILED);
3685 GTEST_LOG_(INFO) << "FormMgrTest_0196 test ends";
3686 }
3687
3688 /**
3689 * @tc.name: FormMgrTest_0197
3690 * @tc.desc: Verify AcquireFormState
3691 * @tc.type: FUNC
3692 */
3693 HWTEST_F(FormMgrTest, FormMgrTest_0197, TestSize.Level1)
3694 {
3695 GTEST_LOG_(INFO) << "FormMgrTest_0197 starts";
3696 EXPECT_CALL(*mockProxy, AcquireFormState(_, _, _))
3697 .Times(1)
3698 .WillOnce(Return(ERR_FAILED));
3699 Want want;
3700 want = want.SetElementName("", "com.example.FormAbility", "MainAbility");
3701 sptr<MockFormToken> token = new (std::nothrow) MockFormToken();
3702 FormStateInfo stateInfo;
3703 auto result = FormMgr::GetInstance().AcquireFormState(want, token, stateInfo);
3704 EXPECT_EQ(result, ERR_FAILED);
3705 GTEST_LOG_(INFO) << "FormMgrTest_0197 test ends";
3706 }
3707
3708 /**
3709 * @tc.name: FormMgrTest_0198
3710 * @tc.desc: Verify DumpStorageFormInfos
3711 * @tc.type: FUNC
3712 */
3713 HWTEST_F(FormMgrTest, FormMgrTest_0198, TestSize.Level1)
3714 {
3715 GTEST_LOG_(INFO) << "FormMgrTest_0198 starts";
3716 EXPECT_CALL(*mockProxy, NotifyFormsVisible(_, _, _))
3717 .Times(1)
3718 .WillOnce(Return(ERR_FAILED));
3719 std::vector<int64_t> formIds;
3720 formIds.push_back(FORM_ID);
3721 bool isProtected = true;
3722 sptr<MockFormToken> token = new (std::nothrow) MockFormToken();
3723 int32_t result = FormMgr::GetInstance().NotifyFormsVisible(formIds, isProtected, token);
3724 EXPECT_EQ(result, ERR_FAILED);
3725 GTEST_LOG_(INFO) << "FormMgrTest_0198 test ends";
3726 }
3727
3728 /**
3729 * @tc.name: FormMgrTest_0199
3730 * @tc.desc: Verify NotifyFormsPrivacyProtected
3731 * @tc.type: FUNC
3732 */
3733 HWTEST_F(FormMgrTest, FormMgrTest_0199, TestSize.Level1)
3734 {
3735 GTEST_LOG_(INFO) << "FormMgrTest_0199 starts";
3736 EXPECT_CALL(*mockProxy, NotifyFormsPrivacyProtected(_, _, _))
3737 .Times(1)
3738 .WillOnce(Return(ERR_FAILED));
3739 std::vector<int64_t> formIds;
3740 formIds.push_back(FORM_ID);
3741 bool isProtected = false;
3742 sptr<MockFormToken> token = new (std::nothrow) MockFormToken();
3743 int32_t result = FormMgr::GetInstance().NotifyFormsPrivacyProtected(formIds, isProtected, token);
3744 EXPECT_EQ(result, ERR_FAILED);
3745 GTEST_LOG_(INFO) << "FormMgrTest_0199 test ends";
3746 }
3747
3748 /**
3749 * @tc.name: FormMgrTest_0200
3750 * @tc.desc: Verify NotifyFormsEnableUpdate
3751 * @tc.type: FUNC
3752 */
3753 HWTEST_F(FormMgrTest, FormMgrTest_0200, TestSize.Level1)
3754 {
3755 GTEST_LOG_(INFO) << "FormMgrTest_0200 starts";
3756 EXPECT_CALL(*mockProxy, NotifyFormsEnableUpdate(_, _, _))
3757 .Times(1)
3758 .WillOnce(Return(ERR_FAILED));
3759 std::vector<int64_t> formIds;
3760 formIds.push_back(FORM_ID);
3761 bool isProtected = true;
3762 sptr<MockFormToken> token = new (std::nothrow) MockFormToken();
3763 int32_t result = FormMgr::GetInstance().NotifyFormsEnableUpdate(formIds, isProtected, token);
3764 EXPECT_EQ(result, ERR_FAILED);
3765 GTEST_LOG_(INFO) << "FormMgrTest_0200 test ends";
3766 }
3767
3768 /**
3769 * @tc.name: FormMgrTest_0201
3770 * @tc.desc: Verify GetAllFormsInfo
3771 * @tc.type: FUNC
3772 */
3773 HWTEST_F(FormMgrTest, FormMgrTest_0201, TestSize.Level1)
3774 {
3775 GTEST_LOG_(INFO) << "FormMgrTest_0201 starts";
3776 EXPECT_CALL(*mockProxy, GetAllFormsInfo(_))
3777 .Times(1)
3778 .WillOnce(Return(ERR_FAILED));
3779 std::vector<FormInfo> formInfos;
3780 std::vector<FormInfo> expectFormInfos;
3781 FormInfo formInfo = {};
3782 formInfo.bundleName = "ohos.samples.FormApplication";
3783 formInfo.moduleName = "entry";
3784 expectFormInfos.push_back(formInfo);
3785 auto result = FormMgr::GetInstance().GetAllFormsInfo(formInfos);
3786 EXPECT_EQ(result, ERR_FAILED);
3787 GTEST_LOG_(INFO) << "FormMgrTest_0201 test ends";
3788 }
3789
3790 /**
3791 * @tc.name: FormMgrTest_0202
3792 * @tc.desc: Verify GetFormsInfoByApp
3793 * @tc.type: FUNC
3794 */
3795 HWTEST_F(FormMgrTest, FormMgrTest_0202, TestSize.Level1)
3796 {
3797 GTEST_LOG_(INFO) << "FormMgrTest_0202 starts";
3798 EXPECT_CALL(*mockProxy, GetFormsInfoByApp(_, _))
3799 .Times(1)
3800 .WillOnce(Return(ERR_FAILED));
3801 std::vector<FormInfo> formInfos;
3802 std::vector<FormInfo> expectFormInfos;
3803 FormInfo formInfo = {};
3804 formInfo.bundleName = "ohos.samples.FormApplication";
3805 formInfo.moduleName = "entry";
3806 expectFormInfos.push_back(formInfo);
3807 std::string bundleName = "a";
3808 auto result = FormMgr::GetInstance().GetFormsInfoByApp(bundleName, formInfos);
3809 EXPECT_EQ(result, ERR_FAILED);
3810 GTEST_LOG_(INFO) << "FormMgrTest_0202 test ends";
3811 }
3812
3813 /**
3814 * @tc.name: FormMgrTest_0203
3815 * @tc.desc: Verify GetFormsInfoByApp
3816 * @tc.type: FUNC
3817 */
3818 HWTEST_F(FormMgrTest, FormMgrTest_0203, TestSize.Level1)
3819 {
3820 GTEST_LOG_(INFO) << "FormMgrTest_0203 starts";
3821 std::vector<FormInfo> formInfos;
3822 std::vector<FormInfo> expectFormInfos;
3823 FormInfo formInfo = {};
3824 formInfo.bundleName = "ohos.samples.FormApplication";
3825 formInfo.moduleName = "entry";
3826 FormMgr::GetInstance().resetFlag_ = true;
3827 expectFormInfos.push_back(formInfo);
3828 std::string bundleName = "a";
3829 auto result = FormMgr::GetInstance().GetFormsInfoByApp(bundleName, formInfos);
3830 EXPECT_EQ(result, ERR_APPEXECFWK_FORM_COMMON_CODE);
3831 FormMgr::GetInstance().resetFlag_ = false;
3832 GTEST_LOG_(INFO) << "FormMgrTest_0203 test ends";
3833 }
3834
3835 /**
3836 * @tc.name: FormMgrTest_0204
3837 * @tc.desc: Verify GetAllFormsInfo
3838 * @tc.type: FUNC
3839 */
3840 HWTEST_F(FormMgrTest, FormMgrTest_0204, TestSize.Level1)
3841 {
3842 GTEST_LOG_(INFO) << "FormMgrTest_0204 starts";
3843 std::vector<FormInfo> formInfos;
3844 std::vector<FormInfo> expectFormInfos;
3845 FormInfo formInfo = {};
3846 FormMgr::GetInstance().resetFlag_ = true;
3847 formInfo.bundleName = "ohos.samples.FormApplication";
3848 formInfo.moduleName = "entry";
3849 expectFormInfos.push_back(formInfo);
3850 auto result = FormMgr::GetInstance().GetAllFormsInfo(formInfos);
3851 EXPECT_EQ(result, ERR_APPEXECFWK_FORM_COMMON_CODE);
3852 FormMgr::GetInstance().resetFlag_ = false;
3853 GTEST_LOG_(INFO) << "FormMgrTest_0204 test ends";
3854 }
3855
3856 /**
3857 * @tc.name: FormMgrTest_0205
3858 * @tc.desc: Verify NotifyFormsEnableUpdate
3859 * @tc.type: FUNC
3860 */
3861 HWTEST_F(FormMgrTest, FormMgrTest_0205, TestSize.Level1)
3862 {
3863 GTEST_LOG_(INFO) << "FormMgrTest_0205 starts";
3864 std::vector<int64_t> formIds;
3865 formIds.push_back(FORM_ID);
3866 bool isProtected = true;
3867 FormMgr::GetInstance().resetFlag_ = true;
3868 sptr<MockFormToken> token = new (std::nothrow) MockFormToken();
3869 int32_t result = FormMgr::GetInstance().NotifyFormsEnableUpdate(formIds, isProtected, token);
3870 EXPECT_EQ(result, ERR_APPEXECFWK_FORM_COMMON_CODE);
3871 FormMgr::GetInstance().resetFlag_ = false;
3872 GTEST_LOG_(INFO) << "FormMgrTest_0205 test ends";
3873 }
3874
3875 /**
3876 * @tc.name: FormMgrTest_0206
3877 * @tc.desc: Verify NotifyFormsPrivacyProtected
3878 * @tc.type: FUNC
3879 */
3880 HWTEST_F(FormMgrTest, FormMgrTest_0206, TestSize.Level1)
3881 {
3882 GTEST_LOG_(INFO) << "FormMgrTest_0206 starts";
3883 std::vector<int64_t> formIds;
3884 formIds.push_back(FORM_ID);
3885 bool isProtected = false;
3886 FormMgr::GetInstance().resetFlag_ = true;
3887 sptr<MockFormToken> token = new (std::nothrow) MockFormToken();
3888 int32_t result = FormMgr::GetInstance().NotifyFormsPrivacyProtected(formIds, isProtected, token);
3889 EXPECT_EQ(result, ERR_APPEXECFWK_FORM_COMMON_CODE);
3890 FormMgr::GetInstance().resetFlag_ = false;
3891 GTEST_LOG_(INFO) << "FormMgrTest_0206 test ends";
3892 }
3893
3894 /**
3895 * @tc.name: FormMgrTest_0207
3896 * @tc.desc: Verify DumpStorageFormInfos
3897 * @tc.type: FUNC
3898 */
3899 HWTEST_F(FormMgrTest, FormMgrTest_0207, TestSize.Level1)
3900 {
3901 GTEST_LOG_(INFO) << "FormMgrTest_0207 starts";
3902 std::vector<int64_t> formIds;
3903 formIds.push_back(FORM_ID);
3904 FormMgr::GetInstance().resetFlag_ = true;
3905 bool isProtected = true;
3906 sptr<MockFormToken> token = new (std::nothrow) MockFormToken();
3907 int32_t result = FormMgr::GetInstance().NotifyFormsVisible(formIds, isProtected, token);
3908 EXPECT_EQ(result, ERR_APPEXECFWK_FORM_COMMON_CODE);
3909 FormMgr::GetInstance().resetFlag_ = false;
3910 GTEST_LOG_(INFO) << "FormMgrTest_0207 test ends";
3911 }
3912
3913 /**
3914 * @tc.name: FormMgrTest_0208
3915 * @tc.desc: Verify AcquireFormState
3916 * @tc.type: FUNC
3917 */
3918 HWTEST_F(FormMgrTest, FormMgrTest_0208, TestSize.Level1)
3919 {
3920 GTEST_LOG_(INFO) << "FormMgrTest_0208 starts";
3921 FormMgr::GetInstance().resetFlag_ = true;
3922 Want want;
3923 want = want.SetElementName("", "com.example.FormAbility", "MainAbility");
3924 sptr<MockFormToken> token = new (std::nothrow) MockFormToken();
3925 FormStateInfo stateInfo;
3926 auto result = FormMgr::GetInstance().AcquireFormState(want, token, stateInfo);
3927 EXPECT_EQ(result, ERR_APPEXECFWK_FORM_COMMON_CODE);
3928 FormMgr::GetInstance().resetFlag_ = false;
3929 GTEST_LOG_(INFO) << "FormMgrTest_0208 test ends";
3930 }
3931
3932 /**
3933 * @tc.name: FormMgrTest_0209
3934 * @tc.desc: Verify GetFormsInfoByModule
3935 * @tc.type: FUNC
3936 */
3937 HWTEST_F(FormMgrTest, FormMgrTest_0209, TestSize.Level1)
3938 {
3939 std::vector<FormInfo> formInfos;
3940 std::vector<FormInfo> expectFormInfos;
3941 FormMgr::GetInstance().resetFlag_ = true;
3942 FormInfo formInfo = {};
3943 formInfo.bundleName = "ohos.samples.FormApplication";
3944 formInfo.moduleName = "entry";
3945 expectFormInfos.push_back(formInfo);
3946 std::string bundleName = "a";
3947 std::string moduleName = "A";
3948 auto result = FormMgr::GetInstance().GetFormsInfoByModule(bundleName, moduleName, formInfos);
3949 EXPECT_EQ(result, ERR_APPEXECFWK_FORM_COMMON_CODE);
3950 FormMgr::GetInstance().resetFlag_ = false;
3951 GTEST_LOG_(INFO) << "FormMgrTest_0209 test ends";
3952 }
3953
3954 /**
3955 * @tc.name: FormMgrTest_0210
3956 * @tc.desc: Verify GetFormsInfoByModule
3957 * @tc.type: FUNC
3958 */
3959 HWTEST_F(FormMgrTest, FormMgrTest_0210, TestSize.Level1)
3960 {
3961 GTEST_LOG_(INFO) << "FormMgrTest_0210 starts";
3962 EXPECT_CALL(*mockProxy, GetFormsInfoByModule(_, _, _))
3963 .Times(1)
3964 .WillOnce(Return(ERR_FAILED));
3965 std::vector<FormInfo> formInfos;
3966 std::vector<FormInfo> expectFormInfos;
3967 FormInfo formInfo = {};
3968 FormMgr::GetInstance().resetFlag_ = false;
3969 FormMgr::GetInstance().SetFormMgrService(mockProxy);
3970 formInfo.bundleName = "ohos.samples.FormApplication";
3971 formInfo.moduleName = "entry";
3972 expectFormInfos.push_back(formInfo);
3973 std::string bundleName = "a";
3974 std::string moduleName = "A";
3975 auto result = FormMgr::GetInstance().GetFormsInfoByModule(bundleName, moduleName, formInfos);
3976 EXPECT_EQ(result, ERR_FAILED);
3977 GTEST_LOG_(INFO) << "FormMgrTest_0210 test ends";
3978 }
3979
3980 /**
3981 * @tc.name: FormMgrTest_0211
3982 * @tc.desc: Verify GetFormsInfoByFilter
3983 * @tc.type: FUNC
3984 */
3985 HWTEST_F(FormMgrTest, FormMgrTest_0211, TestSize.Level1)
3986 {
3987 GTEST_LOG_(INFO) << "FormMgrTest_0211 starts";
3988 FormInfoFilter filter;
3989 std::vector<FormInfo> formInfos;
3990 FormMgr::GetInstance().resetFlag_ = true;
3991 auto result = FormMgr::GetInstance().GetFormsInfoByFilter(filter, formInfos);
3992 EXPECT_EQ(result, ERR_APPEXECFWK_FORM_COMMON_CODE);
3993 FormMgr::GetInstance().resetFlag_ = false;
3994 GTEST_LOG_(INFO) << "FormMgrTest_0211 test ends";
3995 }
3996
3997 /**
3998 * @tc.name: FormMgrTest_0212
3999 * @tc.desc: Verify GetFormsInfoByFilter
4000 * @tc.type: FUNC
4001 */
4002 HWTEST_F(FormMgrTest, FormMgrTest_0212, TestSize.Level1)
4003 {
4004 GTEST_LOG_(INFO) << "FormMgrTest_0212 starts";
4005 EXPECT_CALL(*mockProxy, GetFormsInfoByFilter(_, _))
4006 .Times(1)
4007 .WillOnce(Return(ERR_FAILED));
4008 FormInfoFilter filter;
4009 std::vector<FormInfo> formInfos;
4010 FormMgr::GetInstance().resetFlag_ = false;
4011 FormMgr::GetInstance().SetFormMgrService(mockProxy);
4012 auto result = FormMgr::GetInstance().GetFormsInfoByFilter(filter, formInfos);
4013 EXPECT_EQ(result, ERR_FAILED);
4014 GTEST_LOG_(INFO) << "FormMgrTest_0212 test ends";
4015 }
4016
4017 /**
4018 * @tc.name: FormMgrTest_0213
4019 * @tc.desc: Verify GetFormsInfo
4020 * @tc.type: FUNC
4021 * @tc.require: #I59O23
4022 */
4023 HWTEST_F(FormMgrTest, FormMgrTest_0213, TestSize.Level1)
4024 {
4025 GTEST_LOG_(INFO) << "FormMgrTest_0213 starts";
4026 FormInfoFilter filter;
4027 FormMgr::GetInstance().resetFlag_ = true;
4028 std::vector<FormInfo> formInfos;
4029 auto result = FormMgr::GetInstance().GetFormsInfo(filter, formInfos);
4030 EXPECT_EQ(result, ERR_APPEXECFWK_FORM_COMMON_CODE);
4031 FormMgr::GetInstance().resetFlag_ = false;
4032 GTEST_LOG_(INFO) << "FormMgrTest_0213 test ends";
4033 }
4034
4035 /**
4036 * @tc.name: FormMgrTest_0214
4037 * @tc.desc: Verify IsRequestPublishFormSupported
4038 * @tc.type: FUNC
4039 */
4040 HWTEST_F(FormMgrTest, FormMgrTest_0214, TestSize.Level1)
4041 {
4042 GTEST_LOG_(INFO) << "FormMgrTest_0214 starts";
4043 FormMgr::GetInstance().resetFlag_ = true;
4044 bool result = FormMgr::GetInstance().IsRequestPublishFormSupported();
4045 EXPECT_EQ(result, false);
4046 FormMgr::GetInstance().resetFlag_ = false;
4047 GTEST_LOG_(INFO) << "FormMgrTest_0214 test ends";
4048 }
4049
4050 /**
4051 * @tc.name: FormMgrTest_0215
4052 * @tc.desc: Verify ShareForm
4053 * @tc.type: FUNC
4054 */
4055 HWTEST_F(FormMgrTest, FormMgrTest_0215, TestSize.Level1)
4056 {
4057 GTEST_LOG_(INFO) << "FormMgrTest_0215 starts";
4058 FormMgr::GetInstance().resetFlag_ = true;
4059 std::string deviceId = "aa";
4060 int64_t requestCode = 1;
4061 sptr<IRemoteObject> Token = new (std::nothrow) MockFormProviderClient();
4062 auto result = FormMgr::GetInstance().ShareForm(FORM_ID, deviceId, Token, requestCode);
4063 EXPECT_EQ(result, OHOS::ERR_APPEXECFWK_FORM_COMMON_CODE);
4064 FormMgr::GetInstance().resetFlag_ = false;
4065 GTEST_LOG_(INFO) << "FormMgrTest_0215 test ends";
4066 }
4067
4068 /**
4069 * @tc.name: FormMgrTest_0216
4070 * @tc.desc: Verify AcquireFormData
4071 * @tc.type: FUNC
4072 */
4073 HWTEST_F(FormMgrTest, FormMgrTest_0216, TestSize.Level1)
4074 {
4075 GTEST_LOG_(INFO) << "FormMgrTest_0216 starts";
4076 FormMgr::GetInstance().resetFlag_ = true;
4077 int64_t requestCode = 1;
4078 AAFwk::WantParams formData;
4079 sptr<IRemoteObject> Token = new (std::nothrow) MockFormProviderClient();
4080 auto result = FormMgr::GetInstance().AcquireFormData(FORM_ID, requestCode, Token, formData);
4081 EXPECT_EQ(result, ERR_APPEXECFWK_FORM_COMMON_CODE);
4082 FormMgr::GetInstance().resetFlag_ = false;
4083 GTEST_LOG_(INFO) << "FormMgrTest_0216 test ends";
4084 }
4085
4086 /**
4087 * @tc.name: FormMgrTest_0217
4088 * @tc.desc: Verify StartAbility
4089 * @tc.type: FUNC
4090 */
4091 HWTEST_F(FormMgrTest, FormMgrTest_0217, TestSize.Level1)
4092 {
4093 GTEST_LOG_(INFO) << "FormMgrTest_0217 starts";
4094 Want want;
4095 want = want.SetElementName("", "com.example.FormAbility", "MainAbility");
4096 sptr<MockFormToken> token = new (std::nothrow) MockFormToken();
4097 FormMgr::GetInstance().resetFlag_ = true;
4098 int32_t result = FormMgr::GetInstance().StartAbility(want, token);
4099 EXPECT_EQ(result, ERR_APPEXECFWK_FORM_COMMON_CODE);
4100 FormMgr::GetInstance().resetFlag_ = false;
4101 GTEST_LOG_(INFO) << "FormMgrTest_0217 test ends";
4102 }
4103
4104 /**
4105 * @tc.name: FormMgrTest_0218
4106 * @tc.desc: Verify CheckFMSReady
4107 * @tc.type: FUNC
4108 */
4109 HWTEST_F(FormMgrTest, FormMgrTest_0218, TestSize.Level1)
4110 {
4111 GTEST_LOG_(INFO) << "FormMgrTest_0218 starts";
4112 FormMgr::GetInstance().resetFlag_ = true;
4113 auto result = FormMgr::GetInstance().CheckFMSReady();
4114 EXPECT_EQ(result, false);
4115 FormMgr::GetInstance().resetFlag_ = false;
4116 GTEST_LOG_(INFO) << "FormMgrTest_0218 test ends";
4117 }
4118
4119 /**
4120 * @tc.name: FormMgrTest_0219
4121 * @tc.desc: Verify IsSystemAppForm
4122 * @tc.type: FUNC
4123 */
4124 HWTEST_F(FormMgrTest, FormMgrTest_0219, TestSize.Level1)
4125 {
4126 GTEST_LOG_(INFO) << "FormMgrTest_0219 starts";
4127 FormMgr::GetInstance().resetFlag_ = true;
4128 std::string bundle = "bundle";
4129 bool result = FormMgr::GetInstance().IsSystemAppForm(bundle);
4130 EXPECT_EQ(result, false);
4131 FormMgr::GetInstance().resetFlag_ = false;
4132 GTEST_LOG_(INFO) << "FormMgrTest_0219 test ends";
4133 }
4134
4135 /**
4136 * @tc.name: FormMgrTest_0220
4137 * @tc.desc: Verify UnregisterPublishFormInterceptor
4138 * @tc.type: FUNC
4139 */
4140 HWTEST_F(FormMgrTest, FormMgrTest_0220, TestSize.Level1)
4141 {
4142 GTEST_LOG_(INFO) << "FormMgrTest_0220 starts";
4143 FormMgr::GetInstance().resetFlag_ = true;
4144 sptr<IRemoteObject> interceptorCallback;
4145 int32_t result = FormMgr::GetInstance().UnregisterPublishFormInterceptor(interceptorCallback);
4146 EXPECT_EQ(result, ERR_APPEXECFWK_FORM_COMMON_CODE);
4147 FormMgr::GetInstance().resetFlag_ = false;
4148 GTEST_LOG_(INFO) << "FormMgrTest_0220 test ends";
4149 }
4150
4151 /**
4152 * @tc.name: FormMgrTest_0221
4153 * @tc.desc: Verify GetRunningFormInfos
4154 * @tc.type: FUNC
4155 */
4156 HWTEST_F(FormMgrTest, FormMgrTest_0221, TestSize.Level1)
4157 {
4158 GTEST_LOG_(INFO) << "FormMgrTest_0221 starts";
4159 FormMgr::GetInstance().SetRecoverStatus(Constants::NOT_IN_RECOVERY);
4160 FormMgr::GetInstance().resetFlag_ = true;
4161 std::vector<RunningFormInfo> runningFormInfos;
4162 bool isUnusedInclude = false;
4163 int result = FormMgr::GetInstance().GetRunningFormInfos(isUnusedInclude, runningFormInfos);
4164 EXPECT_EQ(result, ERR_APPEXECFWK_FORM_COMMON_CODE);
4165 FormMgr::GetInstance().resetFlag_ = false;
4166 GTEST_LOG_(INFO) << "FormMgrTest_0221 test ends";
4167 }
4168
4169 /**
4170 * @tc.name: FormMgrTest_0222
4171 * @tc.desc: Verify GetRunningFormInfos
4172 * @tc.type: FUNC
4173 */
4174 HWTEST_F(FormMgrTest, FormMgrTest_0222, TestSize.Level1)
4175 {
4176 GTEST_LOG_(INFO) << "FormMgrTest_0222 starts";
4177 FormMgr::GetInstance().resetFlag_ = true;
4178 FormMgr::GetInstance().SetRecoverStatus(Constants::NOT_IN_RECOVERY);
4179 std::string bundleName = "a";
4180 bool isUnusedInclude = false;
4181 std::vector<RunningFormInfo> runningFormInfos;
4182 int result = FormMgr::GetInstance().GetRunningFormInfosByBundleName(bundleName, isUnusedInclude, runningFormInfos);
4183 EXPECT_EQ(result, ERR_APPEXECFWK_FORM_COMMON_CODE);
4184 FormMgr::GetInstance().resetFlag_ = false;
4185 GTEST_LOG_(INFO) << "FormMgrTest_0222 test ends";
4186 }
4187
4188 /**
4189 * @tc.name: FormMgrTest_0223
4190 * @tc.desc: Verify RegisterFormAddObserverByBundle
4191 * @tc.type: FUNC
4192 */
4193 HWTEST_F(FormMgrTest, FormMgrTest_0223, TestSize.Level1)
4194 {
4195 GTEST_LOG_(INFO) << "FormMgrTest_0223 starts";
4196 FormMgr::GetInstance().resetFlag_ = true;
4197 FormMgr::GetInstance().SetRecoverStatus(Constants::NOT_IN_RECOVERY);
4198 std::string bundleName = "a";
4199 sptr<IRemoteObject> callerToken = new (std::nothrow) MockFormProviderClient();
4200 int result = FormMgr::GetInstance().RegisterFormAddObserverByBundle(bundleName, callerToken);
4201 EXPECT_EQ(result, ERR_APPEXECFWK_FORM_COMMON_CODE);
4202 FormMgr::GetInstance().resetFlag_ = false;
4203 GTEST_LOG_(INFO) << "FormMgrTest_0223 test ends";
4204 }
4205
4206 /**
4207 * @tc.name: FormMgrTest_0224
4208 * @tc.desc: Verify RegisterFormRemoveObserverByBundle
4209 * @tc.type: FUNC
4210 */
4211 HWTEST_F(FormMgrTest, FormMgrTest_0224, TestSize.Level1)
4212 {
4213 GTEST_LOG_(INFO) << "FormMgrTest_0224 starts";
4214 FormMgr::GetInstance().resetFlag_ = true;
4215 FormMgr::GetInstance().SetRecoverStatus(Constants::NOT_IN_RECOVERY);
4216 std::string bundleName = "a";
4217 sptr<IRemoteObject> callerToken = new (std::nothrow) MockFormProviderClient();
4218 int result = FormMgr::GetInstance().RegisterFormRemoveObserverByBundle(bundleName, callerToken);
4219 FormMgr::GetInstance().resetFlag_ = false;
4220 EXPECT_EQ(result, ERR_APPEXECFWK_FORM_COMMON_CODE);
4221 GTEST_LOG_(INFO) << "FormMgrTest_0224 test ends";
4222 }
4223
4224 /**
4225 * @tc.name: FormMgrTest_0225
4226 * @tc.desc: Verify GetFormsCount
4227 * @tc.type: FUNC
4228 */
4229 HWTEST_F(FormMgrTest, FormMgrTest_0225, TestSize.Level1)
4230 {
4231 GTEST_LOG_(INFO) << "FormMgrTest_0225 starts";
4232 bool isTempFormFlag = true;
4233 int32_t formCount = 0;
4234 FormMgr::GetInstance().resetFlag_ = true;
4235 FormMgr::GetInstance().SetRecoverStatus(Constants::NOT_IN_RECOVERY);
4236 int result = FormMgr::GetInstance().GetFormsCount(isTempFormFlag, formCount);
4237 FormMgr::GetInstance().resetFlag_ = false;
4238 EXPECT_EQ(result, ERR_APPEXECFWK_FORM_COMMON_CODE);
4239 GTEST_LOG_(INFO) << "FormMgrTest_0225 test ends";
4240 }
4241
4242 /**
4243 * @tc.name: FormMgrTest_0226
4244 * @tc.desc: Verify GetHostFormsCount
4245 * @tc.type: FUNC
4246 */
4247 HWTEST_F(FormMgrTest, FormMgrTest_0226, TestSize.Level1)
4248 {
4249 GTEST_LOG_(INFO) << "FormMgrTest_0226 starts";
4250 std::string bundleName = "this is bundleName";
4251 int32_t formCount = 0;
4252 FormMgr::GetInstance().resetFlag_ = true;
4253 FormMgr::GetInstance().SetRecoverStatus(Constants::NOT_IN_RECOVERY);
4254 int result = FormMgr::GetInstance().GetHostFormsCount(bundleName, formCount);
4255 FormMgr::GetInstance().resetFlag_ = false;
4256 EXPECT_EQ(result, ERR_APPEXECFWK_FORM_COMMON_CODE);
4257 GTEST_LOG_(INFO) << "FormMgrTest_0226 test ends";
4258 }
4259
4260 /**
4261 * @tc.name: FormMgrTest_0227
4262 * @tc.desc: Verify GetFormInstancesByFilter
4263 * @tc.type: FUNC
4264 */
4265 HWTEST_F(FormMgrTest, FormMgrTest_0227, TestSize.Level1)
4266 {
4267 GTEST_LOG_(INFO) << "FormMgrTest_0227 starts";
4268 FormInstancesFilter filter;
4269 std::vector<FormInstance> formInstances;
4270 FormMgr::GetInstance().resetFlag_ = true;
4271 ErrCode result = FormMgr::GetInstance().GetFormInstancesByFilter(filter, formInstances);
4272 EXPECT_EQ(result, ERR_APPEXECFWK_FORM_COMMON_CODE);
4273 FormMgr::GetInstance().resetFlag_ = false;
4274 GTEST_LOG_(INFO) << "FormMgrTest_0227 test ends";
4275 }
4276
4277 /**
4278 * @tc.name: FormMgrTest_0228
4279 * @tc.desc: Verify GetFormInstancesByFilter
4280 * @tc.type: FUNC
4281 */
4282 HWTEST_F(FormMgrTest, FormMgrTest_0228, TestSize.Level1)
4283 {
4284 GTEST_LOG_(INFO) << "FormMgrTest_0228 starts";
4285 FormMgr::GetInstance().resetFlag_ = true;
4286 FormInstance formInstance;
4287 ErrCode result1 = FormMgr::GetInstance().GetFormInstanceById(FORM_ID, formInstance);
4288 EXPECT_EQ(result1, ERR_APPEXECFWK_FORM_COMMON_CODE);
4289 FormMgr::GetInstance().resetFlag_ = false;
4290 GTEST_LOG_(INFO) << "FormMgrTest_0228 test ends";
4291 }
4292
4293 /**
4294 * @tc.name: FormMgrTest_0229
4295 * @tc.desc: Verify GetFormInstancesByFilter
4296 * @tc.type: FUNC
4297 */
4298 HWTEST_F(FormMgrTest, FormMgrTest_0229, TestSize.Level1)
4299 {
4300 GTEST_LOG_(INFO) << "FormMgrTest_0229 starts";
4301 FormMgr::GetInstance().resetFlag_ = true;
4302 FormInstance formInstance;
4303 auto result = FormMgr::GetInstance().GetFormInstanceById(FORM_ID, true, formInstance);
4304 EXPECT_EQ(result, ERR_APPEXECFWK_FORM_COMMON_CODE);
4305 FormMgr::GetInstance().resetFlag_ = false;
4306 GTEST_LOG_(INFO) << "FormMgrTest_0229 test ends";
4307 }
4308
4309 /**
4310 * @tc.name: FormMgrTest_0230
4311 * @tc.desc: Verify RegisterAddObserver
4312 * @tc.type: FUNC
4313 */
4314 HWTEST_F(FormMgrTest, FormMgrTest_0230, TestSize.Level1)
4315 {
4316 GTEST_LOG_(INFO) << "FormMgrTest_0230 starts";
4317 FormMgr::GetInstance().resetFlag_ = true;
4318 FormMgr::GetInstance().SetRecoverStatus(Constants::NOT_IN_RECOVERY);
4319 std::string bundleName = "this is a bundleName";
4320 sptr<IRemoteObject> callerToken = new (std::nothrow) MockFormProviderClient();
4321 ErrCode result = FormMgr::GetInstance().RegisterAddObserver(bundleName, callerToken);
4322 EXPECT_EQ(result, ERR_APPEXECFWK_FORM_COMMON_CODE);
4323 FormMgr::GetInstance().resetFlag_ = false;
4324 GTEST_LOG_(INFO) << "FormMgrTest_0230 test ends";
4325 }
4326
4327 /**
4328 * @tc.name: FormMgrTest_0231
4329 * @tc.desc: Verify RegisterRemoveObserver
4330 * @tc.type: FUNC
4331 */
4332 HWTEST_F(FormMgrTest, FormMgrTest_0231, TestSize.Level1)
4333 {
4334 GTEST_LOG_(INFO) << "FormMgrTest_0231 starts";
4335 FormMgr::GetInstance().resetFlag_ = true;
4336 FormMgr::GetInstance().SetRecoverStatus(Constants::NOT_IN_RECOVERY);
4337 std::string bundleName = "a";
4338 sptr<IRemoteObject> callerToken = new (std::nothrow) MockFormProviderClient();
4339 ErrCode result = FormMgr::GetInstance().RegisterRemoveObserver(bundleName, callerToken);
4340 EXPECT_EQ(result, ERR_APPEXECFWK_FORM_COMMON_CODE);
4341 FormMgr::GetInstance().resetFlag_ = false;
4342 GTEST_LOG_(INFO) << "FormMgrTest_0231 test ends";
4343 }
4344
4345 /**
4346 * @tc.name: FormMgrTest_0232
4347 * @tc.desc: Verify RegisterFormRouterProxy
4348 * @tc.type: FUNC
4349 */
4350 HWTEST_F(FormMgrTest, FormMgrTest_0232, TestSize.Level1)
4351 {
4352 GTEST_LOG_(INFO) << "FormMgrTest_0232 starts";
4353 FormMgr::GetInstance().resetFlag_ = true;
4354 FormMgr::GetInstance().SetRecoverStatus(Constants::NOT_IN_RECOVERY);
4355 std::vector<int64_t> formIds;
4356 formIds.push_back(FORM_ID);
4357 sptr<IRemoteObject> callerToken = new (std::nothrow) MockFormProviderClient();
4358 ErrCode result = FormMgr::GetInstance().RegisterFormRouterProxy(formIds, callerToken);
4359 EXPECT_EQ(result, ERR_APPEXECFWK_FORM_COMMON_CODE);
4360 FormMgr::GetInstance().resetFlag_ = false;
4361 GTEST_LOG_(INFO) << "FormMgrTest_0232 test ends";
4362 }
4363
4364 /**
4365 * @tc.name: FormMgrTest_0233
4366 * @tc.desc: Verify UnregisterFormRouterProxy
4367 * @tc.type: FUNC
4368 */
4369 HWTEST_F(FormMgrTest, FormMgrTest_0233, TestSize.Level1)
4370 {
4371 GTEST_LOG_(INFO) << "FormMgrTest_0233 starts";
4372 FormMgr::GetInstance().resetFlag_ = true;
4373 FormMgr::GetInstance().SetRecoverStatus(Constants::NOT_IN_RECOVERY);
4374 std::vector<int64_t> formIds;
4375 formIds.push_back(FORM_ID);
4376 ErrCode result = FormMgr::GetInstance().UnregisterFormRouterProxy(formIds);
4377 EXPECT_EQ(result, ERR_APPEXECFWK_FORM_COMMON_CODE);
4378 FormMgr::GetInstance().resetFlag_ = false;
4379 GTEST_LOG_(INFO) << "FormMgrTest_0233 test ends";
4380 }
4381
4382 /**
4383 * @tc.name: FormMgrTest_0234
4384 * @tc.desc: Verify UpdateFormLocation
4385 * @tc.type: FUNC
4386 */
4387 HWTEST_F(FormMgrTest, FormMgrTest_0234, TestSize.Level1)
4388 {
4389 GTEST_LOG_(INFO) << "FormMgrTest_0234 starts";
4390 FormMgr::GetInstance().resetFlag_ = true;
4391 FormMgr::GetInstance().SetRecoverStatus(Constants::NOT_IN_RECOVERY);
4392 int32_t formLocation = 1;
4393 auto result = FormMgr::GetInstance().UpdateFormLocation(FORM_ID, formLocation);
4394 EXPECT_EQ(result, ERR_APPEXECFWK_FORM_COMMON_CODE);
4395 FormMgr::GetInstance().resetFlag_ = false;
4396 GTEST_LOG_(INFO) << "FormMgrTest_0234 test ends";
4397 }
4398
4399 /**
4400 * @tc.name: FormMgrTest_0235
4401 * @tc.desc: Verify UpdateFormLocation
4402 * @tc.type: FUNC
4403 */
4404 HWTEST_F(FormMgrTest, FormMgrTest_0235, TestSize.Level1)
4405 {
4406 GTEST_LOG_(INFO) << "FormMgrTest_0235 starts";
4407 EXPECT_CALL(*mockProxy, UpdateFormLocation(_, _))
4408 .Times(1)
4409 .WillOnce(Return(ERR_FAILED));
4410 FormMgr::GetInstance().SetFormMgrService(mockProxy);
4411 FormMgr::GetInstance().SetRecoverStatus(Constants::NOT_IN_RECOVERY);
4412 int32_t formLocation = 1;
4413 EXPECT_EQ(FormMgr::GetInstance().UpdateFormLocation(FORM_ID, formLocation), ERR_FAILED);
4414 GTEST_LOG_(INFO) << "FormMgrTest_0235 test ends";
4415 }
4416
4417 /**
4418 * @tc.name: FormMgrTest_0236
4419 * @tc.desc: Verify BatchRefreshForms
4420 * @tc.type: FUNC
4421 */
4422 HWTEST_F(FormMgrTest, FormMgrTest_0236, TestSize.Level1)
4423 {
4424 GTEST_LOG_(INFO) << "FormMgrTest_0236 starts";
4425 FormMgr::GetInstance().resetFlag_ = true;
4426 FormMgr::GetInstance().SetRecoverStatus(Constants::NOT_IN_RECOVERY);
4427 int32_t formRefreshType = Constants::REFRESH_ALL_FORM;
4428 EXPECT_EQ(FormMgr::GetInstance().BatchRefreshForms(formRefreshType), ERR_APPEXECFWK_FORM_COMMON_CODE);
4429 FormMgr::GetInstance().resetFlag_ = false;
4430 GTEST_LOG_(INFO) << "FormMgrTest_0236 test ends";
4431 }
4432
4433 /**
4434 * @tc.name: FormMgrTest_0237
4435 * @tc.desc: Verify CreateForm
4436 * @tc.type: FUNC
4437 */
4438 HWTEST_F(FormMgrTest, FormMgrTest_0237, TestSize.Level1)
4439 {
4440 GTEST_LOG_(INFO) << "FormMgrTest_0237 starts";
4441 EXPECT_CALL(*mockProxy, CreateForm(_, _))
4442 .Times(1)
4443 .WillOnce(Return(ERR_FAILED));
4444 Want want;
4445 RunningFormInfo runningFormInfo;
4446 FormMgr::GetInstance().SetFormMgrService(mockProxy);
4447 int result = FormMgr::GetInstance().CreateForm(want, runningFormInfo);
4448 EXPECT_EQ(result, ERR_FAILED);
4449 FormMgr::GetInstance().resetFlag_ = false;
4450 GTEST_LOG_(INFO) << "FormMgrTest_0237 test ends";
4451 }
4452
4453 /**
4454 * @tc.name: FormMgrTest_0238
4455 * @tc.desc: Verify RequestPublishForm (include data proxies)
4456 * @tc.type: FUNC
4457 */
4458 HWTEST_F(FormMgrTest, FormMgrTest_0238, TestSize.Level1)
4459 {
4460 GTEST_LOG_(INFO) << "FormMgrTest_0238 starts";
4461 FormMgr::GetInstance().resetFlag_ = true;
4462 Want want;
4463 int64_t formId = 0x00000008fffffffL;
4464 std::unique_ptr<FormProviderData> formProviderData;
4465 std::vector<FormDataProxy> formDataProxies;
4466 FormDataProxy formDataProxy("city", "");
4467 formDataProxies.push_back(formDataProxy);
4468 int32_t result = FormMgr::GetInstance().RequestPublishForm(want, true, formProviderData, formId, formDataProxies);
4469 EXPECT_EQ(result, ERR_APPEXECFWK_FORM_COMMON_CODE);
4470 FormMgr::GetInstance().resetFlag_ = false;
4471 FormMgr::GetInstance().SetFormMgrService(mockProxy);
4472 GTEST_LOG_(INFO) << "FormMgrTest_0238 test ends";
4473 }
4474
4475 /**
4476 * @tc.name: FormMgrTest_0239
4477 * @tc.desc: Verify SetFormsRecyclable
4478 * @tc.type: FUNC
4479 */
4480 HWTEST_F(FormMgrTest, FormMgrTest_0239, TestSize.Level1)
4481 {
4482 GTEST_LOG_(INFO) << "FormMgrTest_0239 test begin";
4483 FormMgr::GetInstance().resetFlag_ = true;
4484 std::vector<int64_t> formIds;
4485 formIds.push_back(FORM_ID);
4486 FormMgr::GetInstance().SetRecoverStatus(Constants::NOT_IN_RECOVERY);
4487 int32_t result = FormMgr::GetInstance().SetFormsRecyclable(formIds);
4488 EXPECT_EQ(result, ERR_APPEXECFWK_FORM_COMMON_CODE);
4489 FormMgr::GetInstance().resetFlag_ = false;
4490 FormMgr::GetInstance().SetFormMgrService(mockProxy);
4491 GTEST_LOG_(INFO) << "FormMgrTest_0239 test ends";
4492 }
4493
4494 /**
4495 * @tc.name: FormMgrTest_0240
4496 * @tc.desc: Verify RecycleForms
4497 * @tc.type: FUNC
4498 */
4499 HWTEST_F(FormMgrTest, FormMgrTest_0240, TestSize.Level1)
4500 {
4501 GTEST_LOG_(INFO) << "FormMgrTest_0240 begin";
4502 std::vector<int64_t> formIds;
4503 FormMgr::GetInstance().resetFlag_ = true;
4504 formIds.push_back(FORM_ID);
4505 Want want;
4506 FormMgr::GetInstance().SetRecoverStatus(Constants::NOT_IN_RECOVERY);
4507 int32_t result = FormMgr::GetInstance().RecycleForms(formIds, want);
4508 EXPECT_EQ(result, ERR_APPEXECFWK_FORM_COMMON_CODE);
4509 FormMgr::GetInstance().resetFlag_ = false;
4510 FormMgr::GetInstance().SetFormMgrService(mockProxy);
4511 GTEST_LOG_(INFO) << "FormMgrTest_0240 test ends";
4512 }
4513
4514 /**
4515 * @tc.name: FormMgrTest_0241
4516 * @tc.desc: Verify RecoverForms
4517 * @tc.type: FUNC
4518 */
4519 HWTEST_F(FormMgrTest, FormMgrTest_0241, TestSize.Level1)
4520 {
4521 GTEST_LOG_(INFO) << "FormMgrTest_0241 begin";
4522 FormMgr::GetInstance().resetFlag_ = true;
4523 std::vector<int64_t> formIds;
4524 formIds.push_back(FORM_ID);
4525 Want want;
4526 FormMgr::GetInstance().SetRecoverStatus(Constants::NOT_IN_RECOVERY);
4527 int32_t result = FormMgr::GetInstance().RecoverForms(formIds, want);
4528 EXPECT_EQ(result, ERR_APPEXECFWK_FORM_COMMON_CODE);
4529 FormMgr::GetInstance().resetFlag_ = false;
4530 FormMgr::GetInstance().SetFormMgrService(mockProxy);
4531 GTEST_LOG_(INFO) << "FormMgrTest_0241 test ends";
4532 }
4533
4534 /**
4535 * @tc.name: FormMgrTest_0242
4536 * @tc.desc: Verify EnableForms
4537 * @tc.type: FUNC
4538 */
4539 HWTEST_F(FormMgrTest, FormMgrTest_0242, TestSize.Level1)
4540 {
4541 GTEST_LOG_(INFO) << "FormMgrTest_0242 begin";
4542 std::string bundleName = "ohos.samples.FormApplication";
4543 FormMgr::GetInstance().SetRecoverStatus(Constants::NOT_IN_RECOVERY);
4544 EXPECT_CALL(*mockProxy, EnableForms(_, _))
4545 .Times(1)
4546 .WillOnce(Return(ERR_FAILED));
4547 int32_t result = FormMgr::GetInstance().EnableForms(bundleName, true);
4548 EXPECT_EQ(result, ERR_FAILED);
4549 GTEST_LOG_(INFO) << "FormMgrTest_0242 test ends";
4550 }
4551
4552 /**
4553 * @tc.name: FormMgrTest_0243
4554 * @tc.desc: Verify EnableForms
4555 * @tc.type: FUNC
4556 */
4557 HWTEST_F(FormMgrTest, FormMgrTest_0243, TestSize.Level1)
4558 {
4559 GTEST_LOG_(INFO) << "FormMgrTest_0243 begin";
4560 FormMgr::GetInstance().resetFlag_ = true;
4561 std::string bundleName = "ohos.samples.FormApplication";
4562 FormMgr::GetInstance().SetRecoverStatus(Constants::NOT_IN_RECOVERY);
4563 int32_t result = FormMgr::GetInstance().EnableForms(bundleName, true);
4564 EXPECT_EQ(result, ERR_APPEXECFWK_FORM_COMMON_CODE);
4565 FormMgr::GetInstance().resetFlag_ = false;
4566 FormMgr::GetInstance().SetFormMgrService(mockProxy);
4567 GTEST_LOG_(INFO) << "FormMgrTest_0243 test ends";
4568 }
4569
4570 /**
4571 * @tc.name: FormMgrTest_0244
4572 * @tc.desc: Verify IsFormBundleForbidden
4573 * @tc.type: FUNC
4574 */
4575 HWTEST_F(FormMgrTest, FormMgrTest_0244, TestSize.Level1)
4576 {
4577 GTEST_LOG_(INFO) << "FormMgrTest_0244 begin";
4578 FormMgr::GetInstance().resetFlag_ = true;
4579 std::string bundleName = "ohos.samples.FormApplication";
4580 bool result = FormMgr::GetInstance().IsFormBundleForbidden(bundleName);
4581 EXPECT_EQ(result, false);
4582 FormMgr::GetInstance().resetFlag_ = false;
4583 FormMgr::GetInstance().SetFormMgrService(mockProxy);
4584 GTEST_LOG_(INFO) << "FormMgrTest_0244 test ends";
4585 }
4586
4587 /**
4588 * @tc.name: FormMgrTest_0245
4589 * @tc.desc: Verify IsFormBundleProtected
4590 * @tc.type: FUNC
4591 */
4592 HWTEST_F(FormMgrTest, FormMgrTest_0245, TestSize.Level1)
4593 {
4594 GTEST_LOG_(INFO) << "FormMgrTest_0245 begin";
4595 std::string bundleName = "ohos.samples.FormApplication";
4596 int64_t formId = 1;
4597 bool result = FormMgr::GetInstance().IsFormBundleProtected(bundleName, formId);
4598 EXPECT_EQ(result, false);
4599 GTEST_LOG_(INFO) << "FormMgrTest_0245 test ends";
4600 }
4601
4602 /**
4603 * @tc.name: FormMgrTest_0246
4604 * @tc.desc: Verify UpdateFormSize
4605 * @tc.type: FUNC
4606 */
4607 HWTEST_F(FormMgrTest, FormMgrTest_0246, TestSize.Level1)
4608 {
4609 GTEST_LOG_(INFO) << "FormMgrTest_0246 begin";
4610 int64_t formId = 1;
4611 float width = 100;
4612 float height = 50;
4613 float borderWidth = 10;
4614 bool result = FormMgr::GetInstance().UpdateFormSize(formId, width, height, borderWidth);
4615 EXPECT_EQ(result, true);
4616 GTEST_LOG_(INFO) << "FormMgrTest_0246 test ends";
4617 }
4618
4619 /**
4620 * @tc.name: FormMgrTest_0247
4621 * @tc.desc: Verify NotifyFormLocked
4622 * @tc.type: FUNC
4623 */
4624 HWTEST_F(FormMgrTest, FormMgrTest_0247, TestSize.Level1)
4625 {
4626 GTEST_LOG_(INFO) << "FormMgrTest_0247 begin";
4627 int64_t formId = 1;
4628 bool isLocked = true;
4629 int32_t error = FormMgr::GetInstance().NotifyFormLocked(formId, isLocked);
4630 EXPECT_EQ(error, ERR_APPEXECFWK_FORM_SEND_FMS_MSG);
4631 GTEST_LOG_(INFO) << "FormMgrTest_0247 test ends";
4632 }
4633
4634 /**
4635 * @tc.name: FormMgrTest_0248
4636 * @tc.desc: Verify IsFormBundleExempt
4637 * @tc.type: FUNC
4638 */
4639 HWTEST_F(FormMgrTest, FormMgrTest_0248, TestSize.Level1)
4640 {
4641 GTEST_LOG_(INFO) << "FormMgrTest_0248 begin";
4642 int64_t formId = 1;
4643 bool result = FormMgr::GetInstance().IsFormBundleExempt(formId);
4644 EXPECT_EQ(result, false);
4645 GTEST_LOG_(INFO) << "FormMgrTest_0248 begin";
4646 }
4647
4648 /**
4649 * @tc.name: FormMgrTest_0249
4650 * @tc.desc: Verify GetPublishedFormInfoById
4651 * @tc.type: FUNC
4652 */
4653 HWTEST_F(FormMgrTest, FormMgrTest_0249, TestSize.Level1)
4654 {
4655 GTEST_LOG_(INFO) << "FormMgrTest_0249 begin";
4656 int64_t formId = 1;
4657 RunningFormInfo runningFormInfo;
4658 int32_t result = FormMgr::GetInstance().GetPublishedFormInfoById(formId, runningFormInfo);
4659 HILOG_INFO("FormMgrTest_0249,result: %{public}d", result);
4660 EXPECT_EQ(result, ERROR_NUMS);
4661 GTEST_LOG_(INFO) << "FormMgrTest_0249 end";
4662 }
4663
4664 /**
4665 * @tc.name: FormMgrTest_0250
4666 * @tc.desc: Verify GetPublishedFormInfoById
4667 * @tc.type: FUNC
4668 */
4669 HWTEST_F(FormMgrTest, FormMgrTest_0250, TestSize.Level1)
4670 {
4671 GTEST_LOG_(INFO) << "FormMgrTest_0250 begin";
4672 int64_t formId = 2;
4673 RunningFormInfo runningFormInfo;
4674 FormMgr::GetInstance().remoteProxy_ = nullptr;
4675 int32_t result = FormMgr::GetInstance().GetPublishedFormInfoById(formId, runningFormInfo);
4676 HILOG_INFO("FormMgrTest_0250,result: %{public}d", result);
4677 EXPECT_EQ(result, ERR_APPEXECFWK_FORM_COMMON_CODE);
4678 GTEST_LOG_(INFO) << "FormMgrTest_0250 end";
4679 }
4680
4681 /**
4682 * @tc.name: FormMgrTest_0251
4683 * @tc.desc: Verify GetPublishedFormInfos
4684 * @tc.type: FUNC
4685 */
4686 HWTEST_F(FormMgrTest, FormMgrTest_0251, TestSize.Level1)
4687 {
4688 GTEST_LOG_(INFO) << "FormMgrTest_0251 begin";
4689 std::vector<RunningFormInfo> runningFormInfos;
4690 int32_t result = FormMgr::GetInstance().GetPublishedFormInfos(runningFormInfos);
4691 HILOG_INFO("FormMgrTest_0251,result: %{public}d", result);
4692 EXPECT_EQ(result, ERROR_NUMS);
4693 GTEST_LOG_(INFO) << "FormMgrTest_0251 end";
4694 }
4695
4696 /**
4697 * @tc.name: FormMgrTest_0252
4698 * @tc.desc: Verify GetPublishedFormInfos
4699 * @tc.type: FUNC
4700 */
4701 HWTEST_F(FormMgrTest, FormMgrTest_0252, TestSize.Level1)
4702 {
4703 GTEST_LOG_(INFO) << "FormMgrTest_0252 begin";
4704 std::vector<RunningFormInfo> runningFormInfos;
4705 FormMgr::GetInstance().remoteProxy_ = nullptr;
4706 int32_t result = FormMgr::GetInstance().GetPublishedFormInfos(runningFormInfos);
4707 HILOG_INFO("FormMgrTest_0252,result: %{public}d", result);
4708 EXPECT_EQ(result, ERR_APPEXECFWK_FORM_COMMON_CODE);
4709 GTEST_LOG_(INFO) << "FormMgrTest_0252 end";
4710 }
4711
4712 /**
4713 * @tc.name: FormMgrTest_0253
4714 * @tc.desc: Verify OpenFormEditAbility
4715 * @tc.type: FUNC
4716 */
4717 HWTEST_F(FormMgrTest, FormMgrTest_0253, TestSize.Level1)
4718 {
4719 GTEST_LOG_(INFO) << "FormMgrTest_0253 begin";
4720 std::string abilityName = "";
4721 int64_t formId = 1;
4722 bool isMainPage = true;
4723 ErrCode result = FormMgr::GetInstance().OpenFormEditAbility(abilityName, formId, isMainPage);
4724 HILOG_INFO("FormMgrTest_0253,result: %{public}d", result);
4725 EXPECT_EQ(result, ERROR_NUMS);
4726 GTEST_LOG_(INFO) << "FormMgrTest_0253 end";
4727 }
4728
4729 /**
4730 * @tc.name: FormMgrTest_0254
4731 * @tc.desc: Verify OpenFormEditAbility
4732 * @tc.type: FUNC
4733 */
4734 HWTEST_F(FormMgrTest, FormMgrTest_0254, TestSize.Level1)
4735 {
4736 GTEST_LOG_(INFO) << "FormMgrTest_0254 begin";
4737 std::string abilityName = "123";
4738 int64_t formId = 2;
4739 bool isMainPage = true;
4740 FormMgr::GetInstance().remoteProxy_ = nullptr;
4741 ErrCode result = FormMgr::GetInstance().OpenFormEditAbility(abilityName, formId, isMainPage);
4742 HILOG_INFO("FormMgrTest_0254,result: %{public}d", result);
4743 EXPECT_EQ(result, ERR_APPEXECFWK_FORM_COMMON_CODE);
4744 GTEST_LOG_(INFO) << "FormMgrTest_0254 end";
4745 }
4746
4747 /**
4748 * @tc.name: FormMgrTest_0255
4749 * @tc.desc: Verify OpenFormEditAbility
4750 * @tc.type: FUNC
4751 */
4752 HWTEST_F(FormMgrTest, FormMgrTest_0255, TestSize.Level1)
4753 {
4754 GTEST_LOG_(INFO) << "FormMgrTest_0255 begin";
4755 std::string abilityName = "456";
4756 int64_t formId = 2;
4757 bool isMainPage = false;
4758 FormMgr::GetInstance().remoteProxy_ = nullptr;
4759 ErrCode result = FormMgr::GetInstance().OpenFormEditAbility(abilityName, formId, isMainPage);
4760 HILOG_INFO("FormMgrTest_0255,result: %{public}d", result);
4761 EXPECT_EQ(result, ERR_APPEXECFWK_FORM_COMMON_CODE);
4762 GTEST_LOG_(INFO) << "FormMgrTest_0255 end";
4763 }
4764 } // namespace
4765