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 FormMgr::GetInstance().RegisterClickEventObserver(bundleName, formEventType, iremoteObject);
2482 FormMgr::GetInstance().resetFlag_ = false;
2483 FormMgr::GetInstance().SetFormMgrService(mockProxy);
2484 GTEST_LOG_(INFO) << "FormMgrTest_0128 end";
2485 }
2486
2487 /**
2488 * @tc.name: FormMgrTest_0129
2489 * @tc.desc: Verify UnregisterClickEventObserver
2490 * @tc.type: FUNC
2491 */
2492 HWTEST_F(FormMgrTest, FormMgrTest_0129, TestSize.Level0)
2493 {
2494 GTEST_LOG_(INFO) << "FormMgrTest_0129 begin";
2495 std::string bundleName = "";
2496 std::string formEventType = "formAdd";
2497 sptr<IRemoteObject> observer = nullptr;
2498 int result = FormMgr::GetInstance().UnregisterClickEventObserver(bundleName, formEventType, observer);
2499 EXPECT_EQ(result, ERR_APPEXECFWK_FORM_INVALID_PARAM);
2500 GTEST_LOG_(INFO) << "FormMgrTest_0129 end";
2501 }
2502
2503 /**
2504 * @tc.name: FormMgrTest_0130
2505 * @tc.desc: Verify UnregisterClickEventObserver
2506 * @tc.type: FUNC
2507 */
2508 HWTEST_F(FormMgrTest, FormMgrTest_0130, TestSize.Level0)
2509 {
2510 GTEST_LOG_(INFO) << "FormMgrTest_0130 begin";
2511 std::string bundleName = "";
2512 std::string formEventType = "formAdd";
2513 sptr<MockIRemoteObject> iremoteObject = new (std::nothrow) MockIRemoteObject();
2514 ASSERT_NE(nullptr, iremoteObject);
2515 FormMgr::GetInstance().SetRecoverStatus(Constants::IN_RECOVERING);
2516 int result = FormMgr::GetInstance().UnregisterClickEventObserver(bundleName, formEventType, iremoteObject);
2517 EXPECT_EQ(result, ERR_APPEXECFWK_FORM_SERVER_STATUS_ERR);
2518 GTEST_LOG_(INFO) << "FormMgrTest_0130 end";
2519 }
2520
2521 /**
2522 * @tc.name: FormMgrTest_0131
2523 * @tc.desc: Verify UnregisterClickEventObserver
2524 * @tc.type: FUNC
2525 */
2526 HWTEST_F(FormMgrTest, FormMgrTest_0131, TestSize.Level0)
2527 {
2528 GTEST_LOG_(INFO) << "FormMgrTest_0131 begin";
2529 std::string bundleName = "";
2530 std::string formEventType = "formAdd";
2531
2532 sptr<MockIRemoteObject> iremoteObject = new (std::nothrow) MockIRemoteObject();
2533 ASSERT_NE(nullptr, iremoteObject);
2534
2535 FormMgr::GetInstance().SetRecoverStatus(Constants::NOT_IN_RECOVERY);
2536 EXPECT_CALL(*mockProxy, UnregisterClickEventObserver(_, _, _))
2537 .Times(1)
2538 .WillOnce(Return(OHOS::ERR_OK));
2539 int result = FormMgr::GetInstance().UnregisterClickEventObserver(bundleName, formEventType, iremoteObject);
2540 EXPECT_EQ(result, ERR_OK);
2541 GTEST_LOG_(INFO) << "FormMgrTest_0131 end";
2542 }
2543
2544 /**
2545 * @tc.name: FormMgrTest_0132
2546 * @tc.desc: Verify UnregisterClickEventObserver
2547 * @tc.type: FUNC
2548 */
2549 HWTEST_F(FormMgrTest, FormMgrTest_0132, TestSize.Level0)
2550 {
2551 GTEST_LOG_(INFO) << "FormMgrTest_0132 begin";
2552 std::string bundleName = "";
2553 std::string formEventType = "formAdd";
2554 FormMgr::GetInstance().resetFlag_ = true;
2555 sptr<MockIRemoteObject> iremoteObject = new (std::nothrow) MockIRemoteObject();
2556 ASSERT_NE(nullptr, iremoteObject);
2557 FormMgr::GetInstance().SetRecoverStatus(Constants::NOT_IN_RECOVERY);
2558 FormMgr::GetInstance().UnregisterClickEventObserver(bundleName, formEventType, iremoteObject);
2559 FormMgr::GetInstance().resetFlag_ = false;
2560 FormMgr::GetInstance().SetFormMgrService(mockProxy);
2561 GTEST_LOG_(INFO) << "FormMgrTest_0132 end";
2562 }
2563
2564 /**
2565 * @tc.name: FormMgrTest_0133
2566 * @tc.desc: Verify SetFormsRecyclable
2567 * @tc.type: FUNC
2568 */
2569 HWTEST_F(FormMgrTest, FormMgrTest_0133, TestSize.Level0) {
2570 GTEST_LOG_(INFO) << "FormMgrTest_0133 test begin";
2571 std::vector<int64_t> formIds;
2572 FormMgr::GetInstance().SetRecoverStatus(Constants::IN_RECOVERING);
2573 int32_t result = FormMgr::GetInstance().SetFormsRecyclable(formIds);
2574 EXPECT_EQ(result, ERR_APPEXECFWK_FORM_SERVER_STATUS_ERR);
2575 GTEST_LOG_(INFO) << "FormMgrTest_0133 test ends";
2576 }
2577
2578 /**
2579 * @tc.name: FormMgrTest_0134
2580 * @tc.desc: Verify SetFormsRecyclable
2581 * @tc.type: FUNC
2582 */
2583 HWTEST_F(FormMgrTest, FormMgrTest_0134, TestSize.Level0) {
2584 GTEST_LOG_(INFO) << "FormMgrTest_0134 test begin";
2585 std::vector<int64_t> formIds;
2586 FormMgr::GetInstance().SetRecoverStatus(Constants::NOT_IN_RECOVERY);
2587 int32_t result = FormMgr::GetInstance().SetFormsRecyclable(formIds);
2588 EXPECT_EQ(result, ERR_APPEXECFWK_FORM_INVALID_FORM_ID);
2589 GTEST_LOG_(INFO) << "FormMgrTest_0134 test ends";
2590 }
2591
2592 /**
2593 * @tc.name: FormMgrTest_0135
2594 * @tc.desc: Verify SetFormsRecyclable
2595 * @tc.type: FUNC
2596 */
2597 HWTEST_F(FormMgrTest, FormMgrTest_0135, TestSize.Level0) {
2598 GTEST_LOG_(INFO) << "FormMgrTest_0135 test begin";
2599 std::vector<int64_t> formIds;
2600 int64_t formId1 = 1;
2601 int64_t formId2 = 2;
2602 formIds.push_back(formId1);
2603 formIds.push_back(formId2);
2604 FormMgr::GetInstance().SetRecoverStatus(Constants::NOT_IN_RECOVERY);
2605 EXPECT_CALL(*mockProxy, SetFormsRecyclable(_))
2606 .Times(1)
2607 .WillOnce(Return(OHOS::ERR_OK));
2608 int32_t result = FormMgr::GetInstance().SetFormsRecyclable(formIds);
2609 EXPECT_EQ(result, ERR_OK);
2610 GTEST_LOG_(INFO) << "FormMgrTest_0135 test ends";
2611 }
2612
2613 /**
2614 * @tc.name: FormMgrTest_0136
2615 * @tc.desc: Verify RecoverForms
2616 * @tc.type: FUNC
2617 */
2618 HWTEST_F(FormMgrTest, FormMgrTest_0136, TestSize.Level0) {
2619 GTEST_LOG_(INFO) << "FormMgrTest_0136 begin";
2620 std::vector<int64_t> formIds;
2621 Want want;
2622 FormMgr::GetInstance().SetRecoverStatus(Constants::IN_RECOVERING);
2623 int32_t result = FormMgr::GetInstance().RecycleForms(formIds, want);
2624 EXPECT_EQ(result, ERR_APPEXECFWK_FORM_SERVER_STATUS_ERR);
2625 GTEST_LOG_(INFO) << "FormMgrTest_0136 test ends";
2626 }
2627
2628 /**
2629 * @tc.name: FormMgrTest_0137
2630 * @tc.desc: Verify RecoverForms
2631 * @tc.type: FUNC
2632 */
2633 HWTEST_F(FormMgrTest, FormMgrTest_0137, TestSize.Level0) {
2634 GTEST_LOG_(INFO) << "FormMgrTest_0137 begin";
2635 std::vector<int64_t> formIds;
2636 Want want;
2637 FormMgr::GetInstance().SetRecoverStatus(Constants::NOT_IN_RECOVERY);
2638 int32_t result = FormMgr::GetInstance().RecycleForms(formIds, want);
2639 EXPECT_EQ(result, ERR_APPEXECFWK_FORM_INVALID_FORM_ID);
2640 GTEST_LOG_(INFO) << "FormMgrTest_0137 test ends";
2641 }
2642
2643 /**
2644 * @tc.name: FormMgrTest_0138
2645 * @tc.desc: Verify RecoverForms
2646 * @tc.type: FUNC
2647 */
2648 HWTEST_F(FormMgrTest, FormMgrTest_0138, TestSize.Level0) {
2649 GTEST_LOG_(INFO) << "FormMgrTest_0138 begin";
2650 std::vector<int64_t> formIds;
2651 int64_t formId1 = 1;
2652 formIds.push_back(formId1);
2653 Want want;
2654 FormMgr::GetInstance().SetRecoverStatus(Constants::NOT_IN_RECOVERY);
2655
2656 int32_t result = FormMgr::GetInstance().RecycleForms(formIds, want);
2657 EXPECT_EQ(result, ERR_OK);
2658 GTEST_LOG_(INFO) << "FormMgrTest_0138 test ends";
2659 }
2660
2661 /**
2662 * @tc.name: FormMgrTest_0139
2663 * @tc.desc: Verify RecoverForms
2664 * @tc.type: FUNC
2665 */
2666 HWTEST_F(FormMgrTest, FormMgrTest_0139, TestSize.Level0) {
2667 GTEST_LOG_(INFO) << "FormMgrTest_0139 begin";
2668 std::vector<int64_t> formIds;
2669 Want want;
2670 FormMgr::GetInstance().SetRecoverStatus(Constants::IN_RECOVERING);
2671 int32_t result = FormMgr::GetInstance().RecoverForms(formIds, want);
2672 EXPECT_EQ(result, ERR_APPEXECFWK_FORM_SERVER_STATUS_ERR);
2673 GTEST_LOG_(INFO) << "FormMgrTest_0139 test ends";
2674 }
2675
2676 /**
2677 * @tc.name: FormMgrTest_0140
2678 * @tc.desc: Verify RecoverForms
2679 * @tc.type: FUNC
2680 */
2681 HWTEST_F(FormMgrTest, FormMgrTest_0140, TestSize.Level0) {
2682 GTEST_LOG_(INFO) << "FormMgrTest_0140 begin";
2683 std::vector<int64_t> formIds;
2684 Want want;
2685 FormMgr::GetInstance().SetRecoverStatus(Constants::NOT_IN_RECOVERY);
2686 int32_t result = FormMgr::GetInstance().RecoverForms(formIds, want);
2687 EXPECT_EQ(result, ERR_APPEXECFWK_FORM_INVALID_FORM_ID);
2688 GTEST_LOG_(INFO) << "FormMgrTest_0140 test ends";
2689 }
2690
2691 /**
2692 * @tc.name: FormMgrTest_0141
2693 * @tc.desc: Verify RecoverForms
2694 * @tc.type: FUNC
2695 */
2696 HWTEST_F(FormMgrTest, FormMgrTest_0141, TestSize.Level0) {
2697 GTEST_LOG_(INFO) << "FormMgrTest_0141 begin";
2698 std::vector<int64_t> formIds;
2699 int64_t formId1 = 1;
2700 formIds.push_back(formId1);
2701 Want want;
2702 FormMgr::GetInstance().SetRecoverStatus(Constants::NOT_IN_RECOVERY);
2703 EXPECT_CALL(*mockProxy, RecoverForms(_, _))
2704 .Times(1)
2705 .WillOnce(Return(OHOS::ERR_OK));
2706 int32_t result = FormMgr::GetInstance().RecoverForms(formIds, want);
2707 EXPECT_EQ(result, ERR_OK);
2708 GTEST_LOG_(INFO) << "FormMgrTest_0141 test ends";
2709 }
2710
2711 /**
2712 * @tc.name: FormMgrTest_0142
2713 * @tc.desc: Verify SetPublishFormResult (The return value of mock function is not 0)
2714 * @tc.type: FUNC
2715 */
2716 HWTEST_F(FormMgrTest, FormMgrTest_0142, TestSize.Level1) {
2717 GTEST_LOG_(INFO) << "FormMgrTest_0142 starts";
2718
2719 sptr<MockFormToken> token = new (std::nothrow) MockFormToken();
2720 FormMgr::GetInstance().SetRecoverStatus(Constants::IN_RECOVERING);
2721 int64_t formId = 0;
2722 Constants::PublishFormResult result {Constants::PublishFormErrorCode::SUCCESS, ""};
2723 EXPECT_EQ(FormMgr::GetInstance().SetPublishFormResult(formId, result), ERR_APPEXECFWK_FORM_INVALID_FORM_ID);
2724 GTEST_LOG_(INFO) << "FormMgrTest_0142 test ends";
2725 }
2726
2727 /**
2728 * @tc.name: FormMgrTest_0143
2729 * @tc.desc: Verify AcquireAddFormResult (The return value of mock function is not 0)
2730 * @tc.type: FUNC
2731 */
2732 HWTEST_F(FormMgrTest, FormMgrTest_0143, TestSize.Level1) {
2733 GTEST_LOG_(INFO) << "FormMgrTest_0143 starts";
2734
2735 sptr<MockFormToken> token = new (std::nothrow) MockFormToken();
2736 FormMgr::GetInstance().SetRecoverStatus(Constants::IN_RECOVERING);
2737 int64_t formId = 0;
2738 EXPECT_EQ(FormMgr::GetInstance().AcquireAddFormResult(formId), ERR_APPEXECFWK_FORM_INVALID_FORM_ID);
2739 GTEST_LOG_(INFO) << "FormMgrTest_0143 test ends";
2740 }
2741
2742 /**
2743 * @tc.name: FormMgrTest_0144
2744 * @tc.desc: Verify BatchRefreshForms (The return value of mock function is not 0)
2745 * @tc.type: FUNC
2746 */
2747 HWTEST_F(FormMgrTest, FormMgrTest_0144, TestSize.Level1) {
2748 GTEST_LOG_(INFO) << "FormMgrTest_0144 starts";
2749 FormMgr::GetInstance().SetRecoverStatus(Constants::IN_RECOVERING);
2750 int32_t formRefreshType = Constants::REFRESH_ALL_FORM;
2751 EXPECT_EQ(FormMgr::GetInstance().BatchRefreshForms(formRefreshType), ERR_APPEXECFWK_FORM_SERVER_STATUS_ERR);
2752 GTEST_LOG_(INFO) << "FormMgrTest_0144 test ends";
2753 }
2754
2755 /**
2756 * @tc.name: FormMgrTest_0145
2757 * @tc.desc: Verify BatchRefreshForms (The return value of mock function is not 0)
2758 * @tc.type: FUNC
2759 */
2760 HWTEST_F(FormMgrTest, FormMgrTest_0145, TestSize.Level1) {
2761 GTEST_LOG_(INFO) << "FormMgrTest_0145 starts";
2762 FormMgr::GetInstance().SetRecoverStatus(Constants::NOT_IN_RECOVERY);
2763 int32_t formRefreshType = Constants::REFRESH_ALL_FORM - 1;
2764 EXPECT_EQ(FormMgr::GetInstance().BatchRefreshForms(formRefreshType), ERR_APPEXECFWK_FORM_INVALID_PARAM);
2765 formRefreshType = Constants::REFRESH_ATOMIC_FORM + 1;
2766 EXPECT_EQ(FormMgr::GetInstance().BatchRefreshForms(formRefreshType), ERR_APPEXECFWK_FORM_INVALID_PARAM);
2767 GTEST_LOG_(INFO) << "FormMgrTest_0145 test ends";
2768 }
2769
2770 /**
2771 * @tc.name: FormMgrTest_0146
2772 * @tc.desc: Verify BatchRefreshForms (The return value of mock function is not 0)
2773 * @tc.type: FUNC
2774 */
2775 HWTEST_F(FormMgrTest, FormMgrTest_0146, TestSize.Level1) {
2776 GTEST_LOG_(INFO) << "FormMgrTest_0146 starts";
2777 EXPECT_CALL(*mockProxy, BatchRefreshForms(_))
2778 .Times(1)
2779 .WillOnce(Return(OHOS::ERR_OK));
2780 sptr<MockFormToken> token = new (std::nothrow) MockFormToken();
2781 FormMgr::GetInstance().SetRecoverStatus(Constants::NOT_IN_RECOVERY);
2782 int32_t formRefreshType = Constants::REFRESH_ALL_FORM;
2783 EXPECT_EQ(FormMgr::GetInstance().BatchRefreshForms(formRefreshType), ERR_OK);
2784 GTEST_LOG_(INFO) << "FormMgrTest_0146 test ends";
2785 }
2786
2787 /**
2788 * @tc.name: FormMgrTest_0147
2789 * @tc.desc: Verify EnableForms
2790 * @tc.type: FUNC
2791 */
2792 HWTEST_F(FormMgrTest, FormMgrTest_0147, TestSize.Level0) {
2793 GTEST_LOG_(INFO) << "FormMgrTest_0147 begin";
2794 std::string bundleName = "ohos.samples.FormApplication";
2795 FormMgr::GetInstance().SetRecoverStatus(Constants::IN_RECOVERING);
2796 int32_t result = FormMgr::GetInstance().EnableForms(bundleName, true);
2797 EXPECT_EQ(result, ERR_APPEXECFWK_FORM_SERVER_STATUS_ERR);
2798 GTEST_LOG_(INFO) << "FormMgrTest_0147 test ends";
2799 }
2800
2801 /**
2802 * @tc.name: FormMgrTest_0148
2803 * @tc.desc: Verify EnableForms
2804 * @tc.type: FUNC
2805 */
2806 HWTEST_F(FormMgrTest, FormMgrTest_0148, TestSize.Level0) {
2807 GTEST_LOG_(INFO) << "FormMgrTest_0148 begin";
2808 std::string bundleName = "ohos.samples.FormApplication";
2809 FormMgr::GetInstance().SetRecoverStatus(Constants::NOT_IN_RECOVERY);
2810 EXPECT_CALL(*mockProxy, EnableForms(_, _))
2811 .Times(1)
2812 .WillOnce(Return(OHOS::ERR_OK));
2813 int32_t result = FormMgr::GetInstance().EnableForms(bundleName, true);
2814 EXPECT_EQ(result, ERR_OK);
2815 GTEST_LOG_(INFO) << "FormMgrTest_0148 test ends";
2816 }
2817
2818 /**
2819 * @tc.name: FormMgrTest_0149
2820 * @tc.desc: Verify EnableForms
2821 * @tc.type: FUNC
2822 */
2823 HWTEST_F(FormMgrTest, FormMgrTest_0149, TestSize.Level0)
2824 {
2825 GTEST_LOG_(INFO) << "FormMgrTest_0149 begin";
2826 std::string bundleName;
2827 FormMgr::GetInstance().SetRecoverStatus(Constants::NOT_IN_RECOVERY);
2828 int32_t result = FormMgr::GetInstance().EnableForms(bundleName, true);
2829 EXPECT_EQ(result, ERR_APPEXECFWK_FORM_INVALID_PARAM);
2830 GTEST_LOG_(INFO) << "FormMgrTest_0149 test ends";
2831 }
2832
2833 /**
2834 * @tc.name: FormMgrTest_0150
2835 * @tc.desc: Verify IsFormBundleForbidden
2836 * @tc.type: FUNC
2837 */
2838 HWTEST_F(FormMgrTest, FormMgrTest_0150, TestSize.Level0) {
2839 GTEST_LOG_(INFO) << "FormMgrTest_0150 begin";
2840 std::string bundleName = "ohos.samples.FormApplication";
2841 bool result = FormMgr::GetInstance().IsFormBundleForbidden(bundleName);
2842 EXPECT_EQ(result, false);
2843 GTEST_LOG_(INFO) << "FormMgrTest_0150 test ends";
2844 }
2845
2846 /**
2847 * @tc.name: FormMgrTest_0151
2848 * @tc.desc: Verify IsFormBundleForbidden
2849 * @tc.type: FUNC
2850 */
2851 HWTEST_F(FormMgrTest, FormMgrTest_0151, TestSize.Level0)
2852 {
2853 GTEST_LOG_(INFO) << "FormMgrTest_0151 begin";
2854 EXPECT_CALL(*mockProxy, IsFormBundleForbidden(_))
2855 .Times(1)
2856 .WillOnce(Return(true));
2857 std::string bundleName = "ohos.samples.FormApplication";
2858 bool result = FormMgr::GetInstance().IsFormBundleForbidden(bundleName);
2859 EXPECT_EQ(result, true);
2860 GTEST_LOG_(INFO) << "FormMgrTest_0151 test ends";
2861 }
2862
2863 /**
2864 * @tc.name: FormMgrTest_0152
2865 * @tc.desc: Verify RequestPublishFormWithSnapshot (include data proxies)
2866 * @tc.type: FUNC
2867 * @tc.require: issueIA6CAJ
2868 */
2869 HWTEST_F(FormMgrTest, FormMgrTest_0152, TestSize.Level1) {
2870 GTEST_LOG_(INFO) << "FormMgrTest_0152 starts";
2871 EXPECT_CALL(*mockProxy, RequestPublishFormWithSnapshot(_, _, _, _))
2872 .Times(1)
2873 .WillOnce(Return(ERR_OK));
2874 Want want;
2875 int64_t formId = 0x00000008fffffffL;
2876 std::unique_ptr<FormProviderData> formProviderData;
2877 FormDataProxy formDataProxy("city", "");
2878 ErrCode result = FormMgr::GetInstance().RequestPublishFormWithSnapshot(want, true, formProviderData, formId);
2879 EXPECT_EQ(result, ERR_OK);
2880 AppExecFwk::ApplicationInfo appInfo;
2881 appInfo.isSystemApp = false;
2882 FormMgr::GetInstance().resetFlag_ = true;
2883 result = FormMgr::GetInstance().RequestPublishFormWithSnapshot(want, true, formProviderData, formId);
2884 EXPECT_NE(result, ERR_OK);
2885 GTEST_LOG_(INFO) << "FormMgrTest_0152 test ends";
2886 }
2887
2888 /**
2889 * @tc.name: FormMgrTest_0153
2890 * @tc.desc: Verify StopRenderingForm
2891 * @tc.type: FUNC
2892 */
2893 HWTEST_F(FormMgrTest, FormMgrTest_0153, TestSize.Level1)
2894 {
2895 GTEST_LOG_(INFO) << "FormMgrTest_0153 starts";
2896 int64_t formId = FORM_ID;
2897 std::string compId = "this is compId";
2898 FormMgr::GetInstance().SetRecoverStatus(Constants::IN_RECOVERING);
2899 int result = FormMgr::GetInstance().StopRenderingForm(formId, compId);
2900 EXPECT_EQ(result, ERR_APPEXECFWK_FORM_SERVER_STATUS_ERR);
2901 GTEST_LOG_(INFO) << "FormMgrTest_0153 test ends";
2902 }
2903
2904 /**
2905 * @tc.name: FormMgrTest_0154
2906 * @tc.desc: Verify ReleaseRenderer
2907 * @tc.type: FUNC
2908 */
2909 HWTEST_F(FormMgrTest, FormMgrTest_0154, TestSize.Level1)
2910 {
2911 GTEST_LOG_(INFO) << "FormMgrTest_0154 starts";
2912 EXPECT_CALL(*mockProxy, ReleaseRenderer(_, _))
2913 .Times(1)
2914 .WillOnce(Return(ERR_OK));
2915 SetUpTestCase();
2916 int64_t formId = FORM_ID;
2917 std::string compId = "this is compId";
2918 FormMgr::GetInstance().resetFlag_ = false;
2919 FormMgr::GetInstance().SetFormMgrService(mockProxy);
2920 FormMgr::GetInstance().SetRecoverStatus(Constants::NOT_IN_RECOVERY);
2921 int result = FormMgr::GetInstance().ReleaseRenderer(formId, compId);
2922 EXPECT_EQ(result, ERR_OK);
2923 GTEST_LOG_(INFO) << "FormMgrTest_0154 test ends";
2924 }
2925
2926 /**
2927 * @tc.name: FormMgrTest_0155
2928 * @tc.desc: Verify ReleaseRenderer
2929 * @tc.type: FUNC
2930 */
2931 HWTEST_F(FormMgrTest, FormMgrTest_0155, TestSize.Level1)
2932 {
2933 GTEST_LOG_(INFO) << "FormMgrTest_0155 starts";
2934 int64_t formId = FORM_ID;
2935 std::string compId = "this is compId";
2936 FormMgr::GetInstance().SetRecoverStatus(Constants::IN_RECOVERING);
2937 int result = FormMgr::GetInstance().ReleaseRenderer(formId, compId);
2938 EXPECT_EQ(result, ERR_APPEXECFWK_FORM_SERVER_STATUS_ERR);
2939 GTEST_LOG_(INFO) << "FormMgrTest_0155 test ends";
2940 }
2941
2942 /**
2943 * @tc.name: FormMgrTest_0156
2944 * @tc.desc: Verify SetNextRefreshTime
2945 * @tc.type: FUNC
2946 */
2947 HWTEST_F(FormMgrTest, FormMgrTest_0156, TestSize.Level1)
2948 {
2949 GTEST_LOG_(INFO) << "FormMgrTest_0156 starts";
2950 EXPECT_CALL(*mockProxy, SetNextRefreshTime(_, _))
2951 .Times(1)
2952 .WillOnce(Return(0));
2953 int64_t formId = FORM_ID;
2954 int64_t nextTime = 50;
2955 FormMgr::GetInstance().SetRecoverStatus(Constants::NOT_IN_RECOVERY);
2956 auto result = FormMgr::GetInstance().SetNextRefreshTime(formId, nextTime);
2957 EXPECT_EQ(result, 0);
2958 GTEST_LOG_(INFO) << "FormMgrTest_0156 test ends";
2959 }
2960
2961 /**
2962 * @tc.name: FormMgrTest_0157
2963 * @tc.desc: Verify RequestPublishForm
2964 * @tc.type: FUNC
2965 */
2966 HWTEST_F(FormMgrTest, FormMgrTest_0157, TestSize.Level1)
2967 {
2968 GTEST_LOG_(INFO) << "FormMgrTest_0157 starts";
2969 EXPECT_CALL(*mockProxy, RequestPublishForm(_, _, _, _))
2970 .Times(1)
2971 .WillOnce(Return(NEGATIVE_NUM));
2972 Want want;
2973 int64_t formId = FORM_ID;
2974 std::unique_ptr<FormProviderData> formProviderData;
2975 std::vector<FormDataProxy> formDataProxies;
2976 int32_t result = FormMgr::GetInstance().RequestPublishForm(want, true, formProviderData, formId, formDataProxies);
2977 EXPECT_EQ(result, NEGATIVE_NUM);
2978 GTEST_LOG_(INFO) << "FormMgrTest_0157 test ends";
2979 }
2980
2981 /**
2982 * @tc.name: FormMgrTest_0158
2983 * @tc.desc: Verify SetPublishFormResult
2984 * @tc.type: FUNC
2985 */
2986 HWTEST_F(FormMgrTest, FormMgrTest_0158, TestSize.Level1)
2987 {
2988 GTEST_LOG_(INFO) << "FormMgrTest_0158 starts";
2989 EXPECT_CALL(*mockProxy, SetPublishFormResult(_, _))
2990 .Times(1)
2991 .WillOnce(Return(OHOS::ERR_OK));
2992 Constants::PublishFormResult errorCodeInfo{Constants::PublishFormErrorCode::SUCCESS, ""};
2993 int64_t formId = FORM_ID;
2994 ErrCode result = FormMgr::GetInstance().SetPublishFormResult(formId, errorCodeInfo);
2995 EXPECT_EQ(result, OHOS::ERR_OK);
2996 GTEST_LOG_(INFO) << "FormMgrTest_0158 test ends";
2997 }
2998
2999 /**
3000 * @tc.name: FormMgrTest_0159
3001 * @tc.desc: Verify AcquireAddFormResult
3002 * @tc.type: FUNC
3003 */
3004 HWTEST_F(FormMgrTest, FormMgrTest_0159, TestSize.Level1)
3005 {
3006 GTEST_LOG_(INFO) << "FormMgrTest_0159 starts";
3007 EXPECT_CALL(*mockProxy, AcquireAddFormResult(_))
3008 .Times(1)
3009 .WillOnce(Return(OHOS::ERR_OK));
3010 int64_t formId = FORM_ID;
3011 EXPECT_EQ(FormMgr::GetInstance().AcquireAddFormResult(formId), OHOS::ERR_OK);
3012 GTEST_LOG_(INFO) << "FormMgrTest_0159 test ends";
3013 }
3014
3015 /**
3016 * @tc.name: FormMgrTest_0160
3017 * @tc.desc: Verify LifecycleUpdate
3018 * @tc.type: FUNC
3019 */
3020 HWTEST_F(FormMgrTest, FormMgrTest_0160, TestSize.Level1)
3021 {
3022 GTEST_LOG_(INFO) << "FormMgrTest_0160 starts";
3023 EXPECT_CALL(*mockProxy, LifecycleUpdate(_, _, _))
3024 .Times(1)
3025 .WillOnce(Return(0));
3026 std::vector<int64_t> formIds;
3027 int64_t formId = FORM_ID;
3028 formIds.emplace_back(formId);
3029 sptr<MockFormToken> token = new (std::nothrow) MockFormToken();
3030 int result = FormMgr::GetInstance().LifecycleUpdate(formIds, token, true);
3031 EXPECT_EQ(result, 0);
3032 GTEST_LOG_(INFO) << "FormMgrTest_0160 test ends";
3033 }
3034
3035 /**
3036 * @tc.name: FormMgrTest_0161
3037 * @tc.desc: Verify GetRecoverStatus
3038 * @tc.type: FUNC
3039 */
3040 HWTEST_F(FormMgrTest, FormMgrTest_0161, TestSize.Level1)
3041 {
3042 GTEST_LOG_(INFO) << "FormMgrTest_0161 starts";
3043 FormMgr::GetInstance().SetRecoverStatus(Constants::IN_RECOVERING);
3044 EXPECT_TRUE(FormMgr::GetInstance().GetRecoverStatus() == Constants::IN_RECOVERING);
3045 GTEST_LOG_(INFO) << "FormMgrTest_0161 test ends";
3046 }
3047
3048 /**
3049 * @tc.name: FormMgrTest_0162
3050 * @tc.desc: Verify GetFormInstancesByFilter
3051 * @tc.type: FUNC
3052 */
3053 HWTEST_F(FormMgrTest, FormMgrTest_0162, TestSize.Level1)
3054 {
3055 GTEST_LOG_(INFO) << "FormMgrTest_0162 starts";
3056 EXPECT_CALL(*mockProxy, GetFormInstanceById(_, _, _))
3057 .Times(1)
3058 .WillOnce(Return(OHOS::ERR_OK));
3059 int64_t formId = FORM_ID;
3060 FormInstance formInstance;
3061 auto result = FormMgr::GetInstance().GetFormInstanceById(formId, true, formInstance);
3062 EXPECT_EQ(result, OHOS::ERR_OK);
3063 GTEST_LOG_(INFO) << "FormMgrTest_0162 test ends";
3064 }
3065
3066 /**
3067 * @tc.name: FormMgrTest_0163
3068 * @tc.desc: Verify IsSystemAppForm
3069 * @tc.type: FUNC
3070 */
3071 HWTEST_F(FormMgrTest, FormMgrTest_0163, TestSize.Level1)
3072 {
3073 GTEST_LOG_(INFO) << "FormMgrTest_0163 starts";
3074 EXPECT_CALL(*mockProxy, IsSystemAppForm(_))
3075 .Times(1)
3076 .WillOnce(Return(true));
3077 std::string bundle = "bundle";
3078 bool result = FormMgr::GetInstance().IsSystemAppForm(bundle);
3079 EXPECT_EQ(result, true);
3080 GTEST_LOG_(INFO) << "FormMgrTest_0163 test ends";
3081 }
3082
3083 /**
3084 * @tc.name: FormMgrTest_0164
3085 * @tc.desc: Verify GetRunningFormInfosByBundleName
3086 * @tc.type: FUNC
3087 */
3088 HWTEST_F(FormMgrTest, FormMgrTest_0164, TestSize.Level1)
3089 {
3090 GTEST_LOG_(INFO) << "FormMgrTest_0164 starts";
3091 std::string bundleName;
3092 bool isUnusedInclude = false;
3093 std::vector<RunningFormInfo> runningFormInfos;
3094 int result = FormMgr::GetInstance().GetRunningFormInfosByBundleName(bundleName, isUnusedInclude, runningFormInfos);
3095 EXPECT_EQ(result, ERR_APPEXECFWK_FORM_INVALID_BUNDLENAME);
3096 GTEST_LOG_(INFO) << "FormMgrTest_0164 test ends";
3097 }
3098
3099 /**
3100 * @tc.name: FormMgrTest_0165
3101 * @tc.desc: Verify GetFormsCount
3102 * @tc.type: FUNC
3103 */
3104 HWTEST_F(FormMgrTest, FormMgrTest_0165, TestSize.Level1)
3105 {
3106 GTEST_LOG_(INFO) << "FormMgrTest_0165 starts";
3107 EXPECT_CALL(*mockProxy, GetFormsCount(_, _))
3108 .Times(1)
3109 .WillOnce(Return(ERR_FAILED));
3110 bool isTempFormFlag = true;
3111 int32_t formCount = 0;
3112 FormMgr::GetInstance().SetRecoverStatus(Constants::NOT_IN_RECOVERY);
3113 int result = FormMgr::GetInstance().GetFormsCount(isTempFormFlag, formCount);
3114 EXPECT_EQ(result, ERR_FAILED);
3115 GTEST_LOG_(INFO) << "FormMgrTest_0165 test ends";
3116 }
3117
3118 /**
3119 * @tc.name: FormMgrTest_0166
3120 * @tc.desc: Verify GetHostFormsCount
3121 * @tc.type: FUNC
3122 */
3123 HWTEST_F(FormMgrTest, FormMgrTest_0166, TestSize.Level1)
3124 {
3125 GTEST_LOG_(INFO) << "FormMgrTest_0166 starts";
3126 EXPECT_CALL(*mockProxy, GetHostFormsCount(_, _))
3127 .Times(1)
3128 .WillOnce(Return(ERR_FAILED));
3129 std::string bundleName = "this is bundleName";
3130 int32_t formCount = 0;
3131 FormMgr::GetInstance().SetRecoverStatus(Constants::NOT_IN_RECOVERY);
3132 int result = FormMgr::GetInstance().GetHostFormsCount(bundleName, formCount);
3133 EXPECT_EQ(result, ERR_FAILED);
3134 GTEST_LOG_(INFO) << "FormMgrTest_0166 test ends";
3135 }
3136
3137 /**
3138 * @tc.name: FormMgrTest_0167
3139 * @tc.desc: Verify RegisterAddObserver
3140 * @tc.type: FUNC
3141 */
3142 HWTEST_F(FormMgrTest, FormMgrTest_0167, TestSize.Level1)
3143 {
3144 GTEST_LOG_(INFO) << "FormMgrTest_0167 starts";
3145 EXPECT_CALL(*mockProxy, RegisterAddObserver(_, _))
3146 .Times(1)
3147 .WillOnce(Return(0));
3148 FormMgr::GetInstance().SetRecoverStatus(Constants::NOT_IN_RECOVERY);
3149 std::string bundleName = "this is a bundleName";
3150 sptr<IRemoteObject> callerToken = new (std::nothrow) MockFormProviderClient();
3151 ErrCode result = FormMgr::GetInstance().RegisterAddObserver(bundleName, callerToken);
3152 EXPECT_EQ(result, 0);
3153 GTEST_LOG_(INFO) << "FormMgrTest_0167 test ends";
3154 }
3155
3156 /**
3157 * @tc.name: FormMgrTest_0168
3158 * @tc.desc: Verify RegisterRemoveObserver
3159 * @tc.type: FUNC
3160 */
3161 HWTEST_F(FormMgrTest, FormMgrTest_0168, TestSize.Level1)
3162 {
3163 GTEST_LOG_(INFO) << "FormMgrTest_0168 starts";
3164 EXPECT_CALL(*mockProxy, RegisterRemoveObserver(_, _))
3165 .Times(1)
3166 .WillOnce(Return(OHOS::ERR_OK));
3167 FormMgr::GetInstance().SetRecoverStatus(Constants::NOT_IN_RECOVERY);
3168 std::string bundleName = "a";
3169 sptr<IRemoteObject> callerToken = new (std::nothrow) MockFormProviderClient();
3170 ErrCode result = FormMgr::GetInstance().RegisterRemoveObserver(bundleName, callerToken);
3171 EXPECT_EQ(result, OHOS::ERR_OK);
3172 GTEST_LOG_(INFO) << "FormMgrTest_0168 test ends";
3173 }
3174
3175 /**
3176 * @tc.name: FormMgrTest_0169
3177 * @tc.desc: Verify RegisterFormRouterProxy
3178 * @tc.type: FUNC
3179 */
3180 HWTEST_F(FormMgrTest, FormMgrTest_0169, TestSize.Level1)
3181 {
3182 GTEST_LOG_(INFO) << "FormMgrTest_0169 starts";
3183 EXPECT_CALL(*mockProxy, RegisterFormRouterProxy(_, _))
3184 .Times(1)
3185 .WillOnce(Return(OHOS::ERR_OK));
3186 FormMgr::GetInstance().SetRecoverStatus(Constants::NOT_IN_RECOVERY);
3187 std::vector<int64_t> formIds;
3188 formIds.push_back(0);
3189 sptr<IRemoteObject> callerToken = new (std::nothrow) MockFormProviderClient();
3190 ErrCode result = FormMgr::GetInstance().RegisterFormRouterProxy(formIds, callerToken);
3191 EXPECT_EQ(result, OHOS::ERR_OK);
3192 GTEST_LOG_(INFO) << "FormMgrTest_0169 test ends";
3193 }
3194
3195 /**
3196 * @tc.name: FormMgrTest_0170
3197 * @tc.desc: Verify UnregisterFormRouterProxy
3198 * @tc.type: FUNC
3199 */
3200 HWTEST_F(FormMgrTest, FormMgrTest_0170, TestSize.Level1)
3201 {
3202 GTEST_LOG_(INFO) << "FormMgrTest_0170 starts";
3203 EXPECT_CALL(*mockProxy, UnregisterFormRouterProxy(_))
3204 .Times(1)
3205 .WillOnce(Return(OHOS::ERR_OK));
3206 FormMgr::GetInstance().SetRecoverStatus(Constants::NOT_IN_RECOVERY);
3207 std::vector<int64_t> formIds;
3208 formIds.push_back(0);
3209 ErrCode result = FormMgr::GetInstance().UnregisterFormRouterProxy(formIds);
3210 EXPECT_EQ(result, OHOS::ERR_OK);
3211 GTEST_LOG_(INFO) << "FormMgrTest_0170 test ends";
3212 }
3213
3214 /**
3215 * @tc.name: FormMgrTest_0171
3216 * @tc.desc: Verify UpdateFormLocation
3217 * @tc.type: FUNC
3218 */
3219 HWTEST_F(FormMgrTest, FormMgrTest_0171, TestSize.Level1)
3220 {
3221 GTEST_LOG_(INFO) << "FormMgrTest_0171 starts";
3222 EXPECT_CALL(*mockProxy, UpdateFormLocation(_, _))
3223 .Times(1)
3224 .WillOnce(Return(OHOS::ERR_OK));
3225 sptr<MockFormToken> token = new (std::nothrow) MockFormToken();
3226 FormMgr::GetInstance().SetRecoverStatus(Constants::NOT_IN_RECOVERY);
3227 int64_t formId = FORM_ID;
3228 int32_t formLocation = 1;
3229 EXPECT_EQ(FormMgr::GetInstance().UpdateFormLocation(formId, formLocation), OHOS::ERR_OK);
3230 GTEST_LOG_(INFO) << "FormMgrTest_0171 test ends";
3231 }
3232
3233 /**
3234 * @tc.name: FormMgrTest_0172
3235 * @tc.desc: Verify AddForm
3236 * @tc.type: FUNC
3237 */
3238 HWTEST_F(FormMgrTest, FormMgrTest_0172, TestSize.Level1)
3239 {
3240 GTEST_LOG_(INFO) << "FormMgrTest_0172 starts";
3241 int64_t formId = FORM_ID;
3242 Want want;
3243 FormJsInfo formInfo;
3244 FormMgr::GetInstance().resetFlag_ = true;
3245 sptr<MockFormToken> token = new (std::nothrow) MockFormToken();
3246 auto data = FormMgr::GetInstance().AddForm(formId, want, token, formInfo);
3247 EXPECT_EQ(data, ERR_APPEXECFWK_FORM_COMMON_CODE);
3248 FormMgr::GetInstance().resetFlag_ = false;
3249 GTEST_LOG_(INFO) << "FormMgrTest_0172 test ends";
3250 }
3251
3252 /**
3253 * @tc.name: FormMgrTest_0173
3254 * @tc.desc: Verify CreateForm
3255 * @tc.type: FUNC
3256 */
3257 HWTEST_F(FormMgrTest, FormMgrTest_0173, TestSize.Level1)
3258 {
3259 GTEST_LOG_(INFO) << "FormMgrTest_0173 starts";
3260 Want want;
3261 FormMgr::GetInstance().resetFlag_ = true;
3262 RunningFormInfo runningFormInfo;
3263 int result = FormMgr::GetInstance().CreateForm(want, runningFormInfo);
3264 EXPECT_EQ(result, ERR_APPEXECFWK_FORM_COMMON_CODE);
3265 FormMgr::GetInstance().resetFlag_ = false;
3266 GTEST_LOG_(INFO) << "FormMgrTest_0173 test ends";
3267 }
3268
3269 /**
3270 * @tc.name: FormMgrTest_0174
3271 * @tc.desc: Verify DeleteForm
3272 * @tc.type: FUNC
3273 */
3274 HWTEST_F(FormMgrTest, FormMgrTest_0174, TestSize.Level1)
3275 {
3276 GTEST_LOG_(INFO) << "FormMgrTest_0174 starts";
3277 int64_t formId = FORM_ID;
3278 FormMgr::GetInstance().resetFlag_ = true;
3279 sptr<MockFormToken> token = new (std::nothrow) MockFormToken();
3280 FormMgr::GetInstance().SetRecoverStatus(Constants::NOT_IN_RECOVERY);
3281 int result = FormMgr::GetInstance().DeleteForm(formId, token);
3282 EXPECT_EQ(result, ERR_APPEXECFWK_FORM_COMMON_CODE);
3283 FormMgr::GetInstance().resetFlag_ = false;
3284 GTEST_LOG_(INFO) << "FormMgrTest_0174 test ends";
3285 }
3286
3287 /**
3288 * @tc.name: FormMgrTest_0175
3289 * @tc.desc: Verify StopRenderingForm
3290 * @tc.type: FUNC
3291 */
3292 HWTEST_F(FormMgrTest, FormMgrTest_0175, TestSize.Level1)
3293 {
3294 GTEST_LOG_(INFO) << "FormMgrTest_0175 starts";
3295 int64_t formId = FORM_ID;
3296 std::string compId = "this is compId";
3297 FormMgr::GetInstance().resetFlag_ = true;
3298 int result = FormMgr::GetInstance().StopRenderingForm(formId, compId);
3299 EXPECT_EQ(result, ERR_APPEXECFWK_FORM_COMMON_CODE);
3300 FormMgr::GetInstance().resetFlag_ = false;
3301 GTEST_LOG_(INFO) << "FormMgrTest_0175 test ends";
3302 }
3303
3304 /**
3305 * @tc.name: FormMgrTest_0176
3306 * @tc.desc: Verify StopRenderingForm
3307 * @tc.type: FUNC
3308 */
3309 HWTEST_F(FormMgrTest, FormMgrTest_0176, TestSize.Level1)
3310 {
3311 GTEST_LOG_(INFO) << "FormMgrTest_0176 starts";
3312 EXPECT_CALL(*mockProxy, StopRenderingForm(_, _))
3313 .Times(1)
3314 .WillOnce(Return(OHOS::ERR_OK));
3315 int64_t formId = FORM_ID;
3316 std::string compId = "this is compId";
3317 FormMgr::GetInstance().SetFormMgrService(mockProxy);
3318 int result = FormMgr::GetInstance().StopRenderingForm(formId, compId);
3319 EXPECT_EQ(result, OHOS::ERR_OK);
3320 GTEST_LOG_(INFO) << "FormMgrTest_0176 test ends";
3321 }
3322
3323 /**
3324 * @tc.name: FormMgrTest_0177
3325 * @tc.desc: Verify ReleaseRenderer
3326 * @tc.type: FUNC
3327 */
3328 HWTEST_F(FormMgrTest, FormMgrTest_0177, TestSize.Level1)
3329 {
3330 GTEST_LOG_(INFO) << "FormMgrTest_0177 starts";
3331 int64_t formId = FORM_ID;
3332 std::string compId = "this is compId";
3333 FormMgr::GetInstance().resetFlag_ = true;
3334 int result = FormMgr::GetInstance().ReleaseRenderer(formId, compId);
3335 EXPECT_EQ(result, ERR_APPEXECFWK_FORM_COMMON_CODE);
3336 FormMgr::GetInstance().resetFlag_ = false;
3337 GTEST_LOG_(INFO) << "FormMgrTest_0177 test ends";
3338 }
3339
3340 /**
3341 * @tc.name: FormMgrTest_0178
3342 * @tc.desc: Verify RequestForm
3343 * @tc.type: FUNC
3344 */
3345 HWTEST_F(FormMgrTest, FormMgrTest_0178, TestSize.Level1)
3346 {
3347 GTEST_LOG_(INFO) << "FormMgrTest_0178 starts";
3348 Want want;
3349 want = want.SetElementName("", "com.example.FormAbility", "MainAbility");
3350 sptr<MockFormToken> token = new (std::nothrow) MockFormToken();
3351 FormJsInfo formJsInfo;
3352 formJsInfo.formId = 0x00000008fffffffL;
3353 FormMgr::GetInstance().resetFlag_ = true;
3354 FormMgr::GetInstance().SetRecoverStatus(Constants::NOT_IN_RECOVERY);
3355 int32_t result = FormMgr::GetInstance().RequestForm(formJsInfo.formId, token, want);
3356 EXPECT_EQ(result, ERR_APPEXECFWK_FORM_COMMON_CODE);
3357 FormMgr::GetInstance().resetFlag_ = false;
3358 GTEST_LOG_(INFO) << "FormMgrTest_0178 test ends";
3359 }
3360
3361 /**
3362 * @tc.name: FormMgrTest_0179
3363 * @tc.desc: Verify NotifyWhetherVisibleForms
3364 * @tc.type: FUNC
3365 */
3366 HWTEST_F(FormMgrTest, FormMgrTest_0179, TestSize.Level1)
3367 {
3368 GTEST_LOG_(INFO) << "FormMgrTest_0179 starts";
3369 std::vector<int64_t> formIds;
3370 int64_t formId = FORM_ID;
3371 formIds.emplace_back(formId);
3372 sptr<MockFormToken> token = new (std::nothrow) MockFormToken();
3373 int32_t formVisibleType = 1;
3374 FormMgr::GetInstance().resetFlag_ = true;
3375 FormMgr::GetInstance().SetRecoverStatus(Constants::NOT_IN_RECOVERY);
3376 int result = FormMgr::GetInstance().NotifyWhetherVisibleForms(formIds, token, formVisibleType);
3377 EXPECT_EQ(result, ERR_APPEXECFWK_FORM_COMMON_CODE);
3378 FormMgr::GetInstance().resetFlag_ = false;
3379 GTEST_LOG_(INFO) << "FormMgrTest_0179 test ends";
3380 }
3381
3382 /**
3383 * @tc.name: FormMgrTest_0180
3384 * @tc.desc: Verify HasFormVisible
3385 * @tc.type: FUNC
3386 */
3387 HWTEST_F(FormMgrTest, FormMgrTest_0180, TestSize.Level1)
3388 {
3389 GTEST_LOG_(INFO) << "FormMgrTest_0180 starts";
3390 FormMgr::GetInstance().resetFlag_ = true;
3391 uint32_t tokenId = 0;
3392 bool result = FormMgr::GetInstance().HasFormVisible(tokenId);
3393 EXPECT_EQ(result, false);
3394 FormMgr::GetInstance().resetFlag_ = false;
3395 GTEST_LOG_(INFO) << "FormMgrTest_0180 test ends";
3396 }
3397
3398 /**
3399 * @tc.name: FormMgrTest_0181
3400 * @tc.desc: Verify ReleaseForm (Parameters are normal.)
3401 * @tc.type: FUNC
3402 */
3403 HWTEST_F(FormMgrTest, FormMgrTest_0181, TestSize.Level1)
3404 {
3405 GTEST_LOG_(INFO) << "FormMgrTest_0181 starts";
3406 int64_t formId = FORM_ID;
3407 sptr<MockFormToken> token = new (std::nothrow) MockFormToken();
3408 bool delCache = true;
3409 FormMgr::GetInstance().resetFlag_ = true;
3410 FormMgr::GetInstance().SetRecoverStatus(Constants::NOT_IN_RECOVERY);
3411 int result = FormMgr::GetInstance().ReleaseForm(formId, token, delCache);
3412 EXPECT_EQ(result, ERR_APPEXECFWK_FORM_COMMON_CODE);
3413 FormMgr::GetInstance().resetFlag_ = false;
3414 GTEST_LOG_(INFO) << "FormMgrTest_0181 test ends";
3415 }
3416
3417 /**
3418 * @tc.name: FormMgrTest_0182
3419 * @tc.desc: Verify CastTempForm
3420 * @tc.type: FUNC
3421 */
3422 HWTEST_F(FormMgrTest, FormMgrTest_0182, TestSize.Level1)
3423 {
3424 GTEST_LOG_(INFO) << "FormMgrTest_0182 starts";
3425 FormMgr::GetInstance().resetFlag_ = true;
3426 int64_t formId = FORM_ID;
3427 sptr<MockFormToken> token = new (std::nothrow) MockFormToken();
3428 int result = FormMgr::GetInstance().CastTempForm(formId, token);
3429 EXPECT_EQ(result, ERR_APPEXECFWK_FORM_COMMON_CODE);
3430 FormMgr::GetInstance().resetFlag_ = false;
3431 GTEST_LOG_(INFO) << "FormMgrTest_0182 test ends";
3432 }
3433
3434 /**
3435 * @tc.name: FormMgrTest_0183
3436 * @tc.desc: Verify DumpStorageFormInfos
3437 * @tc.type: FUNC
3438 */
3439 HWTEST_F(FormMgrTest, FormMgrTest_0183, TestSize.Level1)
3440 {
3441 GTEST_LOG_(INFO) << "FormMgrTest_0183 starts";
3442 FormMgr::GetInstance().resetFlag_ = true;
3443 std::string formInfos = "a";
3444 auto result = FormMgr::GetInstance().DumpStorageFormInfos(formInfos);
3445 EXPECT_EQ(result, ERR_APPEXECFWK_FORM_COMMON_CODE);
3446 FormMgr::GetInstance().resetFlag_ = false;
3447 GTEST_LOG_(INFO) << "FormMgrTest_0183 test ends";
3448 }
3449
3450 /**
3451 * @tc.name: FormMgrTest_0184
3452 * @tc.desc: Verify DumpFormInfoByBundleName
3453 * @tc.type: FUNC
3454 */
3455 HWTEST_F(FormMgrTest, FormMgrTest_0184, TestSize.Level1)
3456 {
3457 GTEST_LOG_(INFO) << "FormMgrTest_0184 starts";
3458 FormMgr::GetInstance().resetFlag_ = true;
3459 std::string bundleName = "b";
3460 std::string formInfos = "a";
3461 auto result = FormMgr::GetInstance().DumpFormInfoByBundleName(bundleName, formInfos);
3462 FormMgr::GetInstance().resetFlag_ = false;
3463 EXPECT_EQ(result, ERR_APPEXECFWK_FORM_COMMON_CODE);
3464 GTEST_LOG_(INFO) << "FormMgrTest_0184 test ends";
3465 }
3466
3467 /**
3468 * @tc.name: FormMgrTest_0185
3469 * @tc.desc: Verify DumpFormInfoByFormId
3470 * @tc.type: FUNC
3471 */
3472 HWTEST_F(FormMgrTest, FormMgrTest_0185, TestSize.Level1)
3473 {
3474 GTEST_LOG_(INFO) << "FormMgrTest_0185 starts";
3475 std::string formInfos = "a";
3476 FormMgr::GetInstance().resetFlag_ = true;
3477 auto result = FormMgr::GetInstance().DumpFormInfoByFormId(FORM_ID, formInfos);
3478 EXPECT_EQ(result, ERR_APPEXECFWK_FORM_COMMON_CODE);
3479 FormMgr::GetInstance().resetFlag_ = false;
3480 GTEST_LOG_(INFO) << "FormMgrTest_0185 test ends";
3481 }
3482
3483 /**
3484 * @tc.name: FormMgrTest_0186
3485 * @tc.desc: Verify DumpFormTimerByFormId
3486 * @tc.type: FUNC
3487 */
3488 HWTEST_F(FormMgrTest, FormMgrTest_0186, TestSize.Level1)
3489 {
3490 GTEST_LOG_(INFO) << "FormMgrTest_0186 starts";
3491 std::string isTimingService = "b";
3492 FormMgr::GetInstance().resetFlag_ = true;
3493 auto result = FormMgr::GetInstance().DumpFormTimerByFormId(FORM_ID, isTimingService);
3494 EXPECT_EQ(result, ERR_APPEXECFWK_FORM_COMMON_CODE);
3495 FormMgr::GetInstance().resetFlag_ = false;
3496 GTEST_LOG_(INFO) << "FormMgrTest_0186 test ends";
3497 }
3498
3499 /**
3500 * @tc.name: FormMgrTest_0187
3501 * @tc.desc: Verify MessageEvent
3502 * @tc.type: FUNC
3503 */
3504 HWTEST_F(FormMgrTest, FormMgrTest_0187, TestSize.Level1)
3505 {
3506 GTEST_LOG_(INFO) << "FormMgrTest_0187 starts";
3507 FormMgr::GetInstance().resetFlag_ = true;
3508 Want want;
3509 want = want.SetElementName("", "com.example.FormAbility", "MainAbility");
3510 sptr<MockFormToken> token = new (std::nothrow) MockFormToken();
3511 FormJsInfo formJsInfo;
3512 sptr<IRemoteObject> providerToken = new (std::nothrow) MockFormProviderClient();
3513 FormCallerMgr::GetInstance().AddFormHostCaller(formJsInfo, providerToken);
3514 int32_t result = FormMgr::GetInstance().MessageEvent(formJsInfo.formId, want, token);
3515 EXPECT_EQ(result, ERR_APPEXECFWK_FORM_COMMON_CODE);
3516 FormMgr::GetInstance().resetFlag_ = false;
3517 GTEST_LOG_(INFO) << "FormMgrTest_0187 test ends";
3518 }
3519
3520 /**
3521 * @tc.name: FormMgrTest_0188
3522 * @tc.desc: Verify RouterEvent
3523 * @tc.type: FUNC
3524 */
3525 HWTEST_F(FormMgrTest, FormMgrTest_0188, TestSize.Level1)
3526 {
3527 GTEST_LOG_(INFO) << "FormMgrTest_0188 starts";
3528 FormMgr::GetInstance().resetFlag_ = true;
3529 Want want;
3530 want = want.SetElementName("", "com.example.FormAbility", "MainAbility");
3531 sptr<MockFormToken> token = new (std::nothrow) MockFormToken();
3532 FormJsInfo formJsInfo;
3533 sptr<IRemoteObject> providerToken = new (std::nothrow) MockFormProviderClient();
3534 FormCallerMgr::GetInstance().AddFormHostCaller(formJsInfo, providerToken);
3535 int32_t result = FormMgr::GetInstance().RouterEvent(formJsInfo.formId, want, token);
3536 FormMgr::GetInstance().resetFlag_ = false;
3537 EXPECT_EQ(result, ERR_APPEXECFWK_FORM_COMMON_CODE);
3538 GTEST_LOG_(INFO) << "FormMgrTest_0188 test ends";
3539 }
3540
3541 /**
3542 * @tc.name: FormMgrTest_0189
3543 * @tc.desc: Verify BackgroundEvent
3544 * @tc.type: FUNC
3545 */
3546 HWTEST_F(FormMgrTest, FormMgrTest_0189, TestSize.Level1)
3547 {
3548 GTEST_LOG_(INFO) << "FormMgrTest_0189 starts";
3549 FormMgr::GetInstance().SetRecoverStatus(Constants::IN_RECOVERING);
3550 Want want;
3551 std::string bundleName = "a";
3552 FormMgr::GetInstance().resetFlag_ = true;
3553 sptr<IRemoteObject> callerToken = new (std::nothrow) MockFormProviderClient();
3554 int result = FormMgr::GetInstance().BackgroundEvent(FORM_ID, want, callerToken);
3555 EXPECT_EQ(result, ERR_APPEXECFWK_FORM_COMMON_CODE);
3556 FormMgr::GetInstance().resetFlag_ = false;
3557 GTEST_LOG_(INFO) << "FormMgrTest_0189 test ends";
3558 }
3559
3560 /**
3561 * @tc.name: FormMgrTest_0190
3562 * @tc.desc: Verify SetNextRefreshTime
3563 * @tc.type: FUNC
3564 */
3565 HWTEST_F(FormMgrTest, FormMgrTest_0190, TestSize.Level1)
3566 {
3567 GTEST_LOG_(INFO) << "FormMgrTest_0190 starts";
3568 FormMgr::GetInstance().resetFlag_ = true;
3569 int64_t nextTime = 50;
3570 FormMgr::GetInstance().SetRecoverStatus(Constants::NOT_IN_RECOVERY);
3571 auto result = FormMgr::GetInstance().SetNextRefreshTime(FORM_ID, nextTime);
3572 EXPECT_EQ(result, ERR_APPEXECFWK_FORM_COMMON_CODE);
3573 FormMgr::GetInstance().resetFlag_ = false;
3574 GTEST_LOG_(INFO) << "FormMgrTest_0190 test ends";
3575 }
3576
3577 /**
3578 * @tc.name: FormMgrTest_0191
3579 * @tc.desc: Verify SetPublishFormResult
3580 * @tc.type: FUNC
3581 */
3582 HWTEST_F(FormMgrTest, FormMgrTest_0191, TestSize.Level1)
3583 {
3584 GTEST_LOG_(INFO) << "FormMgrTest_0191 starts";
3585 FormMgr::GetInstance().resetFlag_ = true;
3586 Constants::PublishFormResult errorCodeInfo{Constants::PublishFormErrorCode::SUCCESS, ""};
3587 ErrCode result = FormMgr::GetInstance().SetPublishFormResult(FORM_ID, errorCodeInfo);
3588 EXPECT_EQ(result, ERR_APPEXECFWK_FORM_COMMON_CODE);
3589 FormMgr::GetInstance().resetFlag_ = false;
3590 GTEST_LOG_(INFO) << "FormMgrTest_0191 test ends";
3591 }
3592
3593 /**
3594 * @tc.name: FormMgrTest_0192
3595 * @tc.desc: Verify AcquireAddFormResult
3596 * @tc.type: FUNC
3597 */
3598 HWTEST_F(FormMgrTest, FormMgrTest_0192, TestSize.Level1)
3599 {
3600 GTEST_LOG_(INFO) << "FormMgrTest_0192 starts";
3601 FormMgr::GetInstance().resetFlag_ = true;
3602 EXPECT_EQ(FormMgr::GetInstance().AcquireAddFormResult(FORM_ID), ERR_APPEXECFWK_FORM_COMMON_CODE);
3603 FormMgr::GetInstance().resetFlag_ = false;
3604 GTEST_LOG_(INFO) << "FormMgrTest_0192 test ends";
3605 }
3606
3607 /**
3608 * @tc.name: FormMgrTest_0193
3609 * @tc.desc: Verify LifecycleUpdate
3610 * @tc.type: FUNC
3611 */
3612 HWTEST_F(FormMgrTest, FormMgrTest_0193, TestSize.Level1)
3613 {
3614 GTEST_LOG_(INFO) << "FormMgrTest_0193 starts";
3615 FormMgr::GetInstance().resetFlag_ = true;
3616 std::vector<int64_t> formIds;
3617 formIds.emplace_back(FORM_ID);
3618 sptr<MockFormToken> token = new (std::nothrow) MockFormToken();
3619 bool updateType = true;
3620 int result = FormMgr::GetInstance().LifecycleUpdate(formIds, token, updateType);
3621 EXPECT_EQ(result, ERR_APPEXECFWK_FORM_COMMON_CODE);
3622 FormMgr::GetInstance().resetFlag_ = false;
3623 GTEST_LOG_(INFO) << "FormMgrTest_0193 test ends";
3624 }
3625
3626 /**
3627 * @tc.name: FormMgrTest_0194
3628 * @tc.desc: Verify OnRemoteDied
3629 * @tc.type: FUNC
3630 */
3631 HWTEST_F(FormMgrTest, FormMgrTest_0194, TestSize.Level1)
3632 {
3633 GTEST_LOG_(INFO) << "FormMgrTest_0194 starts";
3634 sptr<IRemoteObject> mockFormProviderClient = new (std::nothrow) MockFormProviderClient();
3635 sptr<FormMgr::FormMgrDeathRecipient> formMgrDeath = new (std::nothrow) FormMgr::FormMgrDeathRecipient();
3636 FormMgr::GetInstance().resetFlag_ = true;
3637 FormMgr::GetInstance().SetRecoverStatus(Constants::NOT_IN_RECOVERY);
3638 formMgrDeath->OnRemoteDied(mockFormProviderClient);
3639 EXPECT_TRUE(FormMgr::GetInstance().GetRecoverStatus() == Constants::RECOVER_FAIL);
3640 FormMgr::GetInstance().resetFlag_ = false;
3641 GTEST_LOG_(INFO) << "FormMgrTest_0194 test ends";
3642 }
3643
3644 /**
3645 * @tc.name: FormMgrTest_0195
3646 * @tc.desc: Verify NotifyFormsPrivacyProtected
3647 * @tc.type: FUNC
3648 */
3649 HWTEST_F(FormMgrTest, FormMgrTest_0195, TestSize.Level1)
3650 {
3651 GTEST_LOG_(INFO) << "FormMgrTest_0195 starts";
3652 std::vector<int64_t> formIds;
3653 formIds.push_back(FORM_ID);
3654 bool isProtected = false;
3655 FormMgr::GetInstance().resetFlag_ = true;
3656 sptr<MockFormToken> token = new (std::nothrow) MockFormToken();
3657 int32_t result = FormMgr::GetInstance().NotifyFormsPrivacyProtected(formIds, isProtected, token);
3658 EXPECT_EQ(result, ERR_APPEXECFWK_FORM_COMMON_CODE);
3659 FormMgr::GetInstance().resetFlag_ = false;
3660 GTEST_LOG_(INFO) << "FormMgrTest_0195 test ends";
3661 }
3662
3663 /**
3664 * @tc.name: FormMgrTest_0196
3665 * @tc.desc: Verify DeleteInvalidForms
3666 * @tc.type: FUNC
3667 */
3668 HWTEST_F(FormMgrTest, FormMgrTest_0196, TestSize.Level1)
3669 {
3670 GTEST_LOG_(INFO) << "FormMgrTest_0196 starts";
3671 EXPECT_CALL(*mockProxy, DeleteInvalidForms(_, _, _))
3672 .Times(1)
3673 .WillOnce(Return(ERR_FAILED));
3674 std::vector<int64_t> formInfos;
3675 formInfos.push_back(FORM_ID);
3676 FormJsInfo formJsInfo;
3677 FormMgr::GetInstance().SetFormMgrService(mockProxy);
3678 FormMgr::GetInstance().resetFlag_ = false;
3679 sptr<MockFormToken> token = new (std::nothrow) MockFormToken();
3680 int32_t numFormsDeleted = 2;
3681 auto result = FormMgr::GetInstance().DeleteInvalidForms(formInfos, token, numFormsDeleted);
3682 EXPECT_EQ(result, ERR_FAILED);
3683 GTEST_LOG_(INFO) << "FormMgrTest_0196 test ends";
3684 }
3685
3686 /**
3687 * @tc.name: FormMgrTest_0197
3688 * @tc.desc: Verify AcquireFormState
3689 * @tc.type: FUNC
3690 */
3691 HWTEST_F(FormMgrTest, FormMgrTest_0197, TestSize.Level1)
3692 {
3693 GTEST_LOG_(INFO) << "FormMgrTest_0197 starts";
3694 EXPECT_CALL(*mockProxy, AcquireFormState(_, _, _))
3695 .Times(1)
3696 .WillOnce(Return(ERR_FAILED));
3697 Want want;
3698 want = want.SetElementName("", "com.example.FormAbility", "MainAbility");
3699 sptr<MockFormToken> token = new (std::nothrow) MockFormToken();
3700 FormStateInfo stateInfo;
3701 auto result = FormMgr::GetInstance().AcquireFormState(want, token, stateInfo);
3702 EXPECT_EQ(result, ERR_FAILED);
3703 GTEST_LOG_(INFO) << "FormMgrTest_0197 test ends";
3704 }
3705
3706 /**
3707 * @tc.name: FormMgrTest_0198
3708 * @tc.desc: Verify DumpStorageFormInfos
3709 * @tc.type: FUNC
3710 */
3711 HWTEST_F(FormMgrTest, FormMgrTest_0198, TestSize.Level1)
3712 {
3713 GTEST_LOG_(INFO) << "FormMgrTest_0198 starts";
3714 EXPECT_CALL(*mockProxy, NotifyFormsVisible(_, _, _))
3715 .Times(1)
3716 .WillOnce(Return(ERR_FAILED));
3717 std::vector<int64_t> formIds;
3718 formIds.push_back(FORM_ID);
3719 bool isProtected = true;
3720 sptr<MockFormToken> token = new (std::nothrow) MockFormToken();
3721 int32_t result = FormMgr::GetInstance().NotifyFormsVisible(formIds, isProtected, token);
3722 EXPECT_EQ(result, ERR_FAILED);
3723 GTEST_LOG_(INFO) << "FormMgrTest_0198 test ends";
3724 }
3725
3726 /**
3727 * @tc.name: FormMgrTest_0199
3728 * @tc.desc: Verify NotifyFormsPrivacyProtected
3729 * @tc.type: FUNC
3730 */
3731 HWTEST_F(FormMgrTest, FormMgrTest_0199, TestSize.Level1)
3732 {
3733 GTEST_LOG_(INFO) << "FormMgrTest_0199 starts";
3734 EXPECT_CALL(*mockProxy, NotifyFormsPrivacyProtected(_, _, _))
3735 .Times(1)
3736 .WillOnce(Return(ERR_FAILED));
3737 std::vector<int64_t> formIds;
3738 formIds.push_back(FORM_ID);
3739 bool isProtected = false;
3740 sptr<MockFormToken> token = new (std::nothrow) MockFormToken();
3741 int32_t result = FormMgr::GetInstance().NotifyFormsPrivacyProtected(formIds, isProtected, token);
3742 EXPECT_EQ(result, ERR_FAILED);
3743 GTEST_LOG_(INFO) << "FormMgrTest_0199 test ends";
3744 }
3745
3746 /**
3747 * @tc.name: FormMgrTest_0200
3748 * @tc.desc: Verify NotifyFormsEnableUpdate
3749 * @tc.type: FUNC
3750 */
3751 HWTEST_F(FormMgrTest, FormMgrTest_0200, TestSize.Level1)
3752 {
3753 GTEST_LOG_(INFO) << "FormMgrTest_0200 starts";
3754 EXPECT_CALL(*mockProxy, NotifyFormsEnableUpdate(_, _, _))
3755 .Times(1)
3756 .WillOnce(Return(ERR_FAILED));
3757 std::vector<int64_t> formIds;
3758 formIds.push_back(FORM_ID);
3759 bool isProtected = true;
3760 sptr<MockFormToken> token = new (std::nothrow) MockFormToken();
3761 int32_t result = FormMgr::GetInstance().NotifyFormsEnableUpdate(formIds, isProtected, token);
3762 EXPECT_EQ(result, ERR_FAILED);
3763 GTEST_LOG_(INFO) << "FormMgrTest_0200 test ends";
3764 }
3765
3766 /**
3767 * @tc.name: FormMgrTest_0201
3768 * @tc.desc: Verify GetAllFormsInfo
3769 * @tc.type: FUNC
3770 */
3771 HWTEST_F(FormMgrTest, FormMgrTest_0201, TestSize.Level1)
3772 {
3773 GTEST_LOG_(INFO) << "FormMgrTest_0201 starts";
3774 EXPECT_CALL(*mockProxy, GetAllFormsInfo(_))
3775 .Times(1)
3776 .WillOnce(Return(ERR_FAILED));
3777 std::vector<FormInfo> formInfos;
3778 std::vector<FormInfo> expectFormInfos;
3779 FormInfo formInfo = {};
3780 formInfo.bundleName = "ohos.samples.FormApplication";
3781 formInfo.moduleName = "entry";
3782 expectFormInfos.push_back(formInfo);
3783 auto result = FormMgr::GetInstance().GetAllFormsInfo(formInfos);
3784 EXPECT_EQ(result, ERR_FAILED);
3785 GTEST_LOG_(INFO) << "FormMgrTest_0201 test ends";
3786 }
3787
3788 /**
3789 * @tc.name: FormMgrTest_0202
3790 * @tc.desc: Verify GetFormsInfoByApp
3791 * @tc.type: FUNC
3792 */
3793 HWTEST_F(FormMgrTest, FormMgrTest_0202, TestSize.Level1)
3794 {
3795 GTEST_LOG_(INFO) << "FormMgrTest_0202 starts";
3796 EXPECT_CALL(*mockProxy, GetFormsInfoByApp(_, _))
3797 .Times(1)
3798 .WillOnce(Return(ERR_FAILED));
3799 std::vector<FormInfo> formInfos;
3800 std::vector<FormInfo> expectFormInfos;
3801 FormInfo formInfo = {};
3802 formInfo.bundleName = "ohos.samples.FormApplication";
3803 formInfo.moduleName = "entry";
3804 expectFormInfos.push_back(formInfo);
3805 std::string bundleName = "a";
3806 auto result = FormMgr::GetInstance().GetFormsInfoByApp(bundleName, formInfos);
3807 EXPECT_EQ(result, ERR_FAILED);
3808 GTEST_LOG_(INFO) << "FormMgrTest_0202 test ends";
3809 }
3810
3811 /**
3812 * @tc.name: FormMgrTest_0203
3813 * @tc.desc: Verify GetFormsInfoByApp
3814 * @tc.type: FUNC
3815 */
3816 HWTEST_F(FormMgrTest, FormMgrTest_0203, TestSize.Level1)
3817 {
3818 GTEST_LOG_(INFO) << "FormMgrTest_0203 starts";
3819 std::vector<FormInfo> formInfos;
3820 std::vector<FormInfo> expectFormInfos;
3821 FormInfo formInfo = {};
3822 formInfo.bundleName = "ohos.samples.FormApplication";
3823 formInfo.moduleName = "entry";
3824 FormMgr::GetInstance().resetFlag_ = true;
3825 expectFormInfos.push_back(formInfo);
3826 std::string bundleName = "a";
3827 auto result = FormMgr::GetInstance().GetFormsInfoByApp(bundleName, formInfos);
3828 EXPECT_EQ(result, ERR_APPEXECFWK_FORM_COMMON_CODE);
3829 FormMgr::GetInstance().resetFlag_ = false;
3830 GTEST_LOG_(INFO) << "FormMgrTest_0203 test ends";
3831 }
3832
3833 /**
3834 * @tc.name: FormMgrTest_0204
3835 * @tc.desc: Verify GetAllFormsInfo
3836 * @tc.type: FUNC
3837 */
3838 HWTEST_F(FormMgrTest, FormMgrTest_0204, TestSize.Level1)
3839 {
3840 GTEST_LOG_(INFO) << "FormMgrTest_0204 starts";
3841 std::vector<FormInfo> formInfos;
3842 std::vector<FormInfo> expectFormInfos;
3843 FormInfo formInfo = {};
3844 FormMgr::GetInstance().resetFlag_ = true;
3845 formInfo.bundleName = "ohos.samples.FormApplication";
3846 formInfo.moduleName = "entry";
3847 expectFormInfos.push_back(formInfo);
3848 auto result = FormMgr::GetInstance().GetAllFormsInfo(formInfos);
3849 EXPECT_EQ(result, ERR_APPEXECFWK_FORM_COMMON_CODE);
3850 FormMgr::GetInstance().resetFlag_ = false;
3851 GTEST_LOG_(INFO) << "FormMgrTest_0204 test ends";
3852 }
3853
3854 /**
3855 * @tc.name: FormMgrTest_0205
3856 * @tc.desc: Verify NotifyFormsEnableUpdate
3857 * @tc.type: FUNC
3858 */
3859 HWTEST_F(FormMgrTest, FormMgrTest_0205, TestSize.Level1)
3860 {
3861 GTEST_LOG_(INFO) << "FormMgrTest_0205 starts";
3862 std::vector<int64_t> formIds;
3863 formIds.push_back(FORM_ID);
3864 bool isProtected = true;
3865 FormMgr::GetInstance().resetFlag_ = true;
3866 sptr<MockFormToken> token = new (std::nothrow) MockFormToken();
3867 int32_t result = FormMgr::GetInstance().NotifyFormsEnableUpdate(formIds, isProtected, token);
3868 EXPECT_EQ(result, ERR_APPEXECFWK_FORM_COMMON_CODE);
3869 FormMgr::GetInstance().resetFlag_ = false;
3870 GTEST_LOG_(INFO) << "FormMgrTest_0205 test ends";
3871 }
3872
3873 /**
3874 * @tc.name: FormMgrTest_0206
3875 * @tc.desc: Verify NotifyFormsPrivacyProtected
3876 * @tc.type: FUNC
3877 */
3878 HWTEST_F(FormMgrTest, FormMgrTest_0206, TestSize.Level1)
3879 {
3880 GTEST_LOG_(INFO) << "FormMgrTest_0206 starts";
3881 std::vector<int64_t> formIds;
3882 formIds.push_back(FORM_ID);
3883 bool isProtected = false;
3884 FormMgr::GetInstance().resetFlag_ = true;
3885 sptr<MockFormToken> token = new (std::nothrow) MockFormToken();
3886 int32_t result = FormMgr::GetInstance().NotifyFormsPrivacyProtected(formIds, isProtected, token);
3887 EXPECT_EQ(result, ERR_APPEXECFWK_FORM_COMMON_CODE);
3888 FormMgr::GetInstance().resetFlag_ = false;
3889 GTEST_LOG_(INFO) << "FormMgrTest_0206 test ends";
3890 }
3891
3892 /**
3893 * @tc.name: FormMgrTest_0207
3894 * @tc.desc: Verify DumpStorageFormInfos
3895 * @tc.type: FUNC
3896 */
3897 HWTEST_F(FormMgrTest, FormMgrTest_0207, TestSize.Level1)
3898 {
3899 GTEST_LOG_(INFO) << "FormMgrTest_0207 starts";
3900 std::vector<int64_t> formIds;
3901 formIds.push_back(FORM_ID);
3902 FormMgr::GetInstance().resetFlag_ = true;
3903 bool isProtected = true;
3904 sptr<MockFormToken> token = new (std::nothrow) MockFormToken();
3905 int32_t result = FormMgr::GetInstance().NotifyFormsVisible(formIds, isProtected, token);
3906 EXPECT_EQ(result, ERR_APPEXECFWK_FORM_COMMON_CODE);
3907 FormMgr::GetInstance().resetFlag_ = false;
3908 GTEST_LOG_(INFO) << "FormMgrTest_0207 test ends";
3909 }
3910
3911 /**
3912 * @tc.name: FormMgrTest_0208
3913 * @tc.desc: Verify AcquireFormState
3914 * @tc.type: FUNC
3915 */
3916 HWTEST_F(FormMgrTest, FormMgrTest_0208, TestSize.Level1)
3917 {
3918 GTEST_LOG_(INFO) << "FormMgrTest_0208 starts";
3919 FormMgr::GetInstance().resetFlag_ = true;
3920 Want want;
3921 want = want.SetElementName("", "com.example.FormAbility", "MainAbility");
3922 sptr<MockFormToken> token = new (std::nothrow) MockFormToken();
3923 FormStateInfo stateInfo;
3924 auto result = FormMgr::GetInstance().AcquireFormState(want, token, stateInfo);
3925 EXPECT_EQ(result, ERR_APPEXECFWK_FORM_COMMON_CODE);
3926 FormMgr::GetInstance().resetFlag_ = false;
3927 GTEST_LOG_(INFO) << "FormMgrTest_0208 test ends";
3928 }
3929
3930 /**
3931 * @tc.name: FormMgrTest_0209
3932 * @tc.desc: Verify GetFormsInfoByModule
3933 * @tc.type: FUNC
3934 */
3935 HWTEST_F(FormMgrTest, FormMgrTest_0209, TestSize.Level1)
3936 {
3937 std::vector<FormInfo> formInfos;
3938 std::vector<FormInfo> expectFormInfos;
3939 FormMgr::GetInstance().resetFlag_ = true;
3940 FormInfo formInfo = {};
3941 formInfo.bundleName = "ohos.samples.FormApplication";
3942 formInfo.moduleName = "entry";
3943 expectFormInfos.push_back(formInfo);
3944 std::string bundleName = "a";
3945 std::string moduleName = "A";
3946 auto result = FormMgr::GetInstance().GetFormsInfoByModule(bundleName, moduleName, formInfos);
3947 EXPECT_EQ(result, ERR_APPEXECFWK_FORM_COMMON_CODE);
3948 FormMgr::GetInstance().resetFlag_ = false;
3949 GTEST_LOG_(INFO) << "FormMgrTest_0209 test ends";
3950 }
3951
3952 /**
3953 * @tc.name: FormMgrTest_0210
3954 * @tc.desc: Verify GetFormsInfoByModule
3955 * @tc.type: FUNC
3956 */
3957 HWTEST_F(FormMgrTest, FormMgrTest_0210, TestSize.Level1)
3958 {
3959 GTEST_LOG_(INFO) << "FormMgrTest_0210 starts";
3960 EXPECT_CALL(*mockProxy, GetFormsInfoByModule(_, _, _))
3961 .Times(1)
3962 .WillOnce(Return(ERR_FAILED));
3963 std::vector<FormInfo> formInfos;
3964 std::vector<FormInfo> expectFormInfos;
3965 FormInfo formInfo = {};
3966 FormMgr::GetInstance().resetFlag_ = false;
3967 FormMgr::GetInstance().SetFormMgrService(mockProxy);
3968 formInfo.bundleName = "ohos.samples.FormApplication";
3969 formInfo.moduleName = "entry";
3970 expectFormInfos.push_back(formInfo);
3971 std::string bundleName = "a";
3972 std::string moduleName = "A";
3973 auto result = FormMgr::GetInstance().GetFormsInfoByModule(bundleName, moduleName, formInfos);
3974 EXPECT_EQ(result, ERR_FAILED);
3975 GTEST_LOG_(INFO) << "FormMgrTest_0210 test ends";
3976 }
3977
3978 /**
3979 * @tc.name: FormMgrTest_0211
3980 * @tc.desc: Verify GetFormsInfoByFilter
3981 * @tc.type: FUNC
3982 */
3983 HWTEST_F(FormMgrTest, FormMgrTest_0211, TestSize.Level1)
3984 {
3985 GTEST_LOG_(INFO) << "FormMgrTest_0211 starts";
3986 FormInfoFilter filter;
3987 std::vector<FormInfo> formInfos;
3988 FormMgr::GetInstance().resetFlag_ = true;
3989 auto result = FormMgr::GetInstance().GetFormsInfoByFilter(filter, formInfos);
3990 EXPECT_EQ(result, ERR_APPEXECFWK_FORM_COMMON_CODE);
3991 FormMgr::GetInstance().resetFlag_ = false;
3992 GTEST_LOG_(INFO) << "FormMgrTest_0211 test ends";
3993 }
3994
3995 /**
3996 * @tc.name: FormMgrTest_0212
3997 * @tc.desc: Verify GetFormsInfoByFilter
3998 * @tc.type: FUNC
3999 */
4000 HWTEST_F(FormMgrTest, FormMgrTest_0212, TestSize.Level1)
4001 {
4002 GTEST_LOG_(INFO) << "FormMgrTest_0212 starts";
4003 EXPECT_CALL(*mockProxy, GetFormsInfoByFilter(_, _))
4004 .Times(1)
4005 .WillOnce(Return(ERR_FAILED));
4006 FormInfoFilter filter;
4007 std::vector<FormInfo> formInfos;
4008 FormMgr::GetInstance().resetFlag_ = false;
4009 FormMgr::GetInstance().SetFormMgrService(mockProxy);
4010 auto result = FormMgr::GetInstance().GetFormsInfoByFilter(filter, formInfos);
4011 EXPECT_EQ(result, ERR_FAILED);
4012 GTEST_LOG_(INFO) << "FormMgrTest_0212 test ends";
4013 }
4014
4015 /**
4016 * @tc.name: FormMgrTest_0213
4017 * @tc.desc: Verify GetFormsInfo
4018 * @tc.type: FUNC
4019 * @tc.require: #I59O23
4020 */
4021 HWTEST_F(FormMgrTest, FormMgrTest_0213, TestSize.Level1)
4022 {
4023 GTEST_LOG_(INFO) << "FormMgrTest_0213 starts";
4024 FormInfoFilter filter;
4025 FormMgr::GetInstance().resetFlag_ = true;
4026 std::vector<FormInfo> formInfos;
4027 auto result = FormMgr::GetInstance().GetFormsInfo(filter, formInfos);
4028 EXPECT_EQ(result, ERR_APPEXECFWK_FORM_COMMON_CODE);
4029 FormMgr::GetInstance().resetFlag_ = false;
4030 GTEST_LOG_(INFO) << "FormMgrTest_0213 test ends";
4031 }
4032
4033 /**
4034 * @tc.name: FormMgrTest_0214
4035 * @tc.desc: Verify IsRequestPublishFormSupported
4036 * @tc.type: FUNC
4037 */
4038 HWTEST_F(FormMgrTest, FormMgrTest_0214, TestSize.Level1)
4039 {
4040 GTEST_LOG_(INFO) << "FormMgrTest_0214 starts";
4041 FormMgr::GetInstance().resetFlag_ = true;
4042 bool result = FormMgr::GetInstance().IsRequestPublishFormSupported();
4043 EXPECT_EQ(result, false);
4044 FormMgr::GetInstance().resetFlag_ = false;
4045 GTEST_LOG_(INFO) << "FormMgrTest_0214 test ends";
4046 }
4047
4048 /**
4049 * @tc.name: FormMgrTest_0215
4050 * @tc.desc: Verify ShareForm
4051 * @tc.type: FUNC
4052 */
4053 HWTEST_F(FormMgrTest, FormMgrTest_0215, TestSize.Level1)
4054 {
4055 GTEST_LOG_(INFO) << "FormMgrTest_0215 starts";
4056 FormMgr::GetInstance().resetFlag_ = true;
4057 std::string deviceId = "aa";
4058 int64_t requestCode = 1;
4059 sptr<IRemoteObject> Token = new (std::nothrow) MockFormProviderClient();
4060 auto result = FormMgr::GetInstance().ShareForm(FORM_ID, deviceId, Token, requestCode);
4061 EXPECT_EQ(result, OHOS::ERR_APPEXECFWK_FORM_COMMON_CODE);
4062 FormMgr::GetInstance().resetFlag_ = false;
4063 GTEST_LOG_(INFO) << "FormMgrTest_0215 test ends";
4064 }
4065
4066 /**
4067 * @tc.name: FormMgrTest_0216
4068 * @tc.desc: Verify AcquireFormData
4069 * @tc.type: FUNC
4070 */
4071 HWTEST_F(FormMgrTest, FormMgrTest_0216, TestSize.Level1)
4072 {
4073 GTEST_LOG_(INFO) << "FormMgrTest_0216 starts";
4074 FormMgr::GetInstance().resetFlag_ = true;
4075 int64_t requestCode = 1;
4076 AAFwk::WantParams formData;
4077 sptr<IRemoteObject> Token = new (std::nothrow) MockFormProviderClient();
4078 auto result = FormMgr::GetInstance().AcquireFormData(FORM_ID, requestCode, Token, formData);
4079 EXPECT_EQ(result, ERR_APPEXECFWK_FORM_COMMON_CODE);
4080 FormMgr::GetInstance().resetFlag_ = false;
4081 GTEST_LOG_(INFO) << "FormMgrTest_0216 test ends";
4082 }
4083
4084 /**
4085 * @tc.name: FormMgrTest_0217
4086 * @tc.desc: Verify StartAbility
4087 * @tc.type: FUNC
4088 */
4089 HWTEST_F(FormMgrTest, FormMgrTest_0217, TestSize.Level1)
4090 {
4091 GTEST_LOG_(INFO) << "FormMgrTest_0217 starts";
4092 Want want;
4093 want = want.SetElementName("", "com.example.FormAbility", "MainAbility");
4094 sptr<MockFormToken> token = new (std::nothrow) MockFormToken();
4095 FormMgr::GetInstance().resetFlag_ = true;
4096 int32_t result = FormMgr::GetInstance().StartAbility(want, token);
4097 EXPECT_EQ(result, ERR_APPEXECFWK_FORM_COMMON_CODE);
4098 FormMgr::GetInstance().resetFlag_ = false;
4099 GTEST_LOG_(INFO) << "FormMgrTest_0217 test ends";
4100 }
4101
4102 /**
4103 * @tc.name: FormMgrTest_0218
4104 * @tc.desc: Verify CheckFMSReady
4105 * @tc.type: FUNC
4106 */
4107 HWTEST_F(FormMgrTest, FormMgrTest_0218, TestSize.Level1)
4108 {
4109 GTEST_LOG_(INFO) << "FormMgrTest_0218 starts";
4110 FormMgr::GetInstance().resetFlag_ = true;
4111 auto result = FormMgr::GetInstance().CheckFMSReady();
4112 EXPECT_EQ(result, false);
4113 FormMgr::GetInstance().resetFlag_ = false;
4114 GTEST_LOG_(INFO) << "FormMgrTest_0218 test ends";
4115 }
4116
4117 /**
4118 * @tc.name: FormMgrTest_0219
4119 * @tc.desc: Verify IsSystemAppForm
4120 * @tc.type: FUNC
4121 */
4122 HWTEST_F(FormMgrTest, FormMgrTest_0219, TestSize.Level1)
4123 {
4124 GTEST_LOG_(INFO) << "FormMgrTest_0219 starts";
4125 FormMgr::GetInstance().resetFlag_ = true;
4126 std::string bundle = "bundle";
4127 bool result = FormMgr::GetInstance().IsSystemAppForm(bundle);
4128 EXPECT_EQ(result, false);
4129 FormMgr::GetInstance().resetFlag_ = false;
4130 GTEST_LOG_(INFO) << "FormMgrTest_0219 test ends";
4131 }
4132
4133 /**
4134 * @tc.name: FormMgrTest_0220
4135 * @tc.desc: Verify UnregisterPublishFormInterceptor
4136 * @tc.type: FUNC
4137 */
4138 HWTEST_F(FormMgrTest, FormMgrTest_0220, TestSize.Level1)
4139 {
4140 GTEST_LOG_(INFO) << "FormMgrTest_0220 starts";
4141 FormMgr::GetInstance().resetFlag_ = true;
4142 sptr<IRemoteObject> interceptorCallback;
4143 int32_t result = FormMgr::GetInstance().UnregisterPublishFormInterceptor(interceptorCallback);
4144 EXPECT_EQ(result, ERR_APPEXECFWK_FORM_COMMON_CODE);
4145 FormMgr::GetInstance().resetFlag_ = false;
4146 GTEST_LOG_(INFO) << "FormMgrTest_0220 test ends";
4147 }
4148
4149 /**
4150 * @tc.name: FormMgrTest_0221
4151 * @tc.desc: Verify GetRunningFormInfos
4152 * @tc.type: FUNC
4153 */
4154 HWTEST_F(FormMgrTest, FormMgrTest_0221, TestSize.Level1)
4155 {
4156 GTEST_LOG_(INFO) << "FormMgrTest_0221 starts";
4157 FormMgr::GetInstance().SetRecoverStatus(Constants::NOT_IN_RECOVERY);
4158 FormMgr::GetInstance().resetFlag_ = true;
4159 std::vector<RunningFormInfo> runningFormInfos;
4160 bool isUnusedInclude = false;
4161 int result = FormMgr::GetInstance().GetRunningFormInfos(isUnusedInclude, runningFormInfos);
4162 EXPECT_EQ(result, ERR_APPEXECFWK_FORM_COMMON_CODE);
4163 FormMgr::GetInstance().resetFlag_ = false;
4164 GTEST_LOG_(INFO) << "FormMgrTest_0221 test ends";
4165 }
4166
4167 /**
4168 * @tc.name: FormMgrTest_0222
4169 * @tc.desc: Verify GetRunningFormInfos
4170 * @tc.type: FUNC
4171 */
4172 HWTEST_F(FormMgrTest, FormMgrTest_0222, TestSize.Level1)
4173 {
4174 GTEST_LOG_(INFO) << "FormMgrTest_0222 starts";
4175 FormMgr::GetInstance().resetFlag_ = true;
4176 FormMgr::GetInstance().SetRecoverStatus(Constants::NOT_IN_RECOVERY);
4177 std::string bundleName = "a";
4178 bool isUnusedInclude = false;
4179 std::vector<RunningFormInfo> runningFormInfos;
4180 int result = FormMgr::GetInstance().GetRunningFormInfosByBundleName(bundleName, isUnusedInclude, runningFormInfos);
4181 EXPECT_EQ(result, ERR_APPEXECFWK_FORM_COMMON_CODE);
4182 FormMgr::GetInstance().resetFlag_ = false;
4183 GTEST_LOG_(INFO) << "FormMgrTest_0222 test ends";
4184 }
4185
4186 /**
4187 * @tc.name: FormMgrTest_0223
4188 * @tc.desc: Verify RegisterFormAddObserverByBundle
4189 * @tc.type: FUNC
4190 */
4191 HWTEST_F(FormMgrTest, FormMgrTest_0223, TestSize.Level1)
4192 {
4193 GTEST_LOG_(INFO) << "FormMgrTest_0223 starts";
4194 FormMgr::GetInstance().resetFlag_ = true;
4195 FormMgr::GetInstance().SetRecoverStatus(Constants::NOT_IN_RECOVERY);
4196 std::string bundleName = "a";
4197 sptr<IRemoteObject> callerToken = new (std::nothrow) MockFormProviderClient();
4198 int result = FormMgr::GetInstance().RegisterFormAddObserverByBundle(bundleName, callerToken);
4199 EXPECT_EQ(result, ERR_APPEXECFWK_FORM_COMMON_CODE);
4200 FormMgr::GetInstance().resetFlag_ = false;
4201 GTEST_LOG_(INFO) << "FormMgrTest_0223 test ends";
4202 }
4203
4204 /**
4205 * @tc.name: FormMgrTest_0224
4206 * @tc.desc: Verify RegisterFormRemoveObserverByBundle
4207 * @tc.type: FUNC
4208 */
4209 HWTEST_F(FormMgrTest, FormMgrTest_0224, TestSize.Level1)
4210 {
4211 GTEST_LOG_(INFO) << "FormMgrTest_0224 starts";
4212 FormMgr::GetInstance().resetFlag_ = true;
4213 FormMgr::GetInstance().SetRecoverStatus(Constants::NOT_IN_RECOVERY);
4214 std::string bundleName = "a";
4215 sptr<IRemoteObject> callerToken = new (std::nothrow) MockFormProviderClient();
4216 int result = FormMgr::GetInstance().RegisterFormRemoveObserverByBundle(bundleName, callerToken);
4217 FormMgr::GetInstance().resetFlag_ = false;
4218 EXPECT_EQ(result, ERR_APPEXECFWK_FORM_COMMON_CODE);
4219 GTEST_LOG_(INFO) << "FormMgrTest_0224 test ends";
4220 }
4221
4222 /**
4223 * @tc.name: FormMgrTest_0225
4224 * @tc.desc: Verify GetFormsCount
4225 * @tc.type: FUNC
4226 */
4227 HWTEST_F(FormMgrTest, FormMgrTest_0225, TestSize.Level1)
4228 {
4229 GTEST_LOG_(INFO) << "FormMgrTest_0225 starts";
4230 bool isTempFormFlag = true;
4231 int32_t formCount = 0;
4232 FormMgr::GetInstance().resetFlag_ = true;
4233 FormMgr::GetInstance().SetRecoverStatus(Constants::NOT_IN_RECOVERY);
4234 int result = FormMgr::GetInstance().GetFormsCount(isTempFormFlag, formCount);
4235 FormMgr::GetInstance().resetFlag_ = false;
4236 EXPECT_EQ(result, ERR_APPEXECFWK_FORM_COMMON_CODE);
4237 GTEST_LOG_(INFO) << "FormMgrTest_0225 test ends";
4238 }
4239
4240 /**
4241 * @tc.name: FormMgrTest_0226
4242 * @tc.desc: Verify GetHostFormsCount
4243 * @tc.type: FUNC
4244 */
4245 HWTEST_F(FormMgrTest, FormMgrTest_0226, TestSize.Level1)
4246 {
4247 GTEST_LOG_(INFO) << "FormMgrTest_0226 starts";
4248 std::string bundleName = "this is bundleName";
4249 int32_t formCount = 0;
4250 FormMgr::GetInstance().resetFlag_ = true;
4251 FormMgr::GetInstance().SetRecoverStatus(Constants::NOT_IN_RECOVERY);
4252 int result = FormMgr::GetInstance().GetHostFormsCount(bundleName, formCount);
4253 FormMgr::GetInstance().resetFlag_ = false;
4254 EXPECT_EQ(result, ERR_APPEXECFWK_FORM_COMMON_CODE);
4255 GTEST_LOG_(INFO) << "FormMgrTest_0226 test ends";
4256 }
4257
4258 /**
4259 * @tc.name: FormMgrTest_0227
4260 * @tc.desc: Verify GetFormInstancesByFilter
4261 * @tc.type: FUNC
4262 */
4263 HWTEST_F(FormMgrTest, FormMgrTest_0227, TestSize.Level1)
4264 {
4265 GTEST_LOG_(INFO) << "FormMgrTest_0227 starts";
4266 FormInstancesFilter filter;
4267 std::vector<FormInstance> formInstances;
4268 FormMgr::GetInstance().resetFlag_ = true;
4269 ErrCode result = FormMgr::GetInstance().GetFormInstancesByFilter(filter, formInstances);
4270 EXPECT_EQ(result, ERR_APPEXECFWK_FORM_COMMON_CODE);
4271 FormMgr::GetInstance().resetFlag_ = false;
4272 GTEST_LOG_(INFO) << "FormMgrTest_0227 test ends";
4273 }
4274
4275 /**
4276 * @tc.name: FormMgrTest_0228
4277 * @tc.desc: Verify GetFormInstancesByFilter
4278 * @tc.type: FUNC
4279 */
4280 HWTEST_F(FormMgrTest, FormMgrTest_0228, TestSize.Level1)
4281 {
4282 GTEST_LOG_(INFO) << "FormMgrTest_0228 starts";
4283 FormMgr::GetInstance().resetFlag_ = true;
4284 FormInstance formInstance;
4285 ErrCode result1 = FormMgr::GetInstance().GetFormInstanceById(FORM_ID, formInstance);
4286 EXPECT_EQ(result1, ERR_APPEXECFWK_FORM_COMMON_CODE);
4287 FormMgr::GetInstance().resetFlag_ = false;
4288 GTEST_LOG_(INFO) << "FormMgrTest_0228 test ends";
4289 }
4290
4291 /**
4292 * @tc.name: FormMgrTest_0229
4293 * @tc.desc: Verify GetFormInstancesByFilter
4294 * @tc.type: FUNC
4295 */
4296 HWTEST_F(FormMgrTest, FormMgrTest_0229, TestSize.Level1)
4297 {
4298 GTEST_LOG_(INFO) << "FormMgrTest_0229 starts";
4299 FormMgr::GetInstance().resetFlag_ = true;
4300 FormInstance formInstance;
4301 auto result = FormMgr::GetInstance().GetFormInstanceById(FORM_ID, true, formInstance);
4302 EXPECT_EQ(result, ERR_APPEXECFWK_FORM_COMMON_CODE);
4303 FormMgr::GetInstance().resetFlag_ = false;
4304 GTEST_LOG_(INFO) << "FormMgrTest_0229 test ends";
4305 }
4306
4307 /**
4308 * @tc.name: FormMgrTest_0230
4309 * @tc.desc: Verify RegisterAddObserver
4310 * @tc.type: FUNC
4311 */
4312 HWTEST_F(FormMgrTest, FormMgrTest_0230, TestSize.Level1)
4313 {
4314 GTEST_LOG_(INFO) << "FormMgrTest_0230 starts";
4315 FormMgr::GetInstance().resetFlag_ = true;
4316 FormMgr::GetInstance().SetRecoverStatus(Constants::NOT_IN_RECOVERY);
4317 std::string bundleName = "this is a bundleName";
4318 sptr<IRemoteObject> callerToken = new (std::nothrow) MockFormProviderClient();
4319 ErrCode result = FormMgr::GetInstance().RegisterAddObserver(bundleName, callerToken);
4320 EXPECT_EQ(result, ERR_APPEXECFWK_FORM_COMMON_CODE);
4321 FormMgr::GetInstance().resetFlag_ = false;
4322 GTEST_LOG_(INFO) << "FormMgrTest_0230 test ends";
4323 }
4324
4325 /**
4326 * @tc.name: FormMgrTest_0231
4327 * @tc.desc: Verify RegisterRemoveObserver
4328 * @tc.type: FUNC
4329 */
4330 HWTEST_F(FormMgrTest, FormMgrTest_0231, TestSize.Level1)
4331 {
4332 GTEST_LOG_(INFO) << "FormMgrTest_0231 starts";
4333 FormMgr::GetInstance().resetFlag_ = true;
4334 FormMgr::GetInstance().SetRecoverStatus(Constants::NOT_IN_RECOVERY);
4335 std::string bundleName = "a";
4336 sptr<IRemoteObject> callerToken = new (std::nothrow) MockFormProviderClient();
4337 ErrCode result = FormMgr::GetInstance().RegisterRemoveObserver(bundleName, callerToken);
4338 EXPECT_EQ(result, ERR_APPEXECFWK_FORM_COMMON_CODE);
4339 FormMgr::GetInstance().resetFlag_ = false;
4340 GTEST_LOG_(INFO) << "FormMgrTest_0231 test ends";
4341 }
4342
4343 /**
4344 * @tc.name: FormMgrTest_0232
4345 * @tc.desc: Verify RegisterFormRouterProxy
4346 * @tc.type: FUNC
4347 */
4348 HWTEST_F(FormMgrTest, FormMgrTest_0232, TestSize.Level1)
4349 {
4350 GTEST_LOG_(INFO) << "FormMgrTest_0232 starts";
4351 FormMgr::GetInstance().resetFlag_ = true;
4352 FormMgr::GetInstance().SetRecoverStatus(Constants::NOT_IN_RECOVERY);
4353 std::vector<int64_t> formIds;
4354 formIds.push_back(FORM_ID);
4355 sptr<IRemoteObject> callerToken = new (std::nothrow) MockFormProviderClient();
4356 ErrCode result = FormMgr::GetInstance().RegisterFormRouterProxy(formIds, callerToken);
4357 EXPECT_EQ(result, ERR_APPEXECFWK_FORM_COMMON_CODE);
4358 FormMgr::GetInstance().resetFlag_ = false;
4359 GTEST_LOG_(INFO) << "FormMgrTest_0232 test ends";
4360 }
4361
4362 /**
4363 * @tc.name: FormMgrTest_0233
4364 * @tc.desc: Verify UnregisterFormRouterProxy
4365 * @tc.type: FUNC
4366 */
4367 HWTEST_F(FormMgrTest, FormMgrTest_0233, TestSize.Level1)
4368 {
4369 GTEST_LOG_(INFO) << "FormMgrTest_0233 starts";
4370 FormMgr::GetInstance().resetFlag_ = true;
4371 FormMgr::GetInstance().SetRecoverStatus(Constants::NOT_IN_RECOVERY);
4372 std::vector<int64_t> formIds;
4373 formIds.push_back(FORM_ID);
4374 ErrCode result = FormMgr::GetInstance().UnregisterFormRouterProxy(formIds);
4375 EXPECT_EQ(result, ERR_APPEXECFWK_FORM_COMMON_CODE);
4376 FormMgr::GetInstance().resetFlag_ = false;
4377 GTEST_LOG_(INFO) << "FormMgrTest_0233 test ends";
4378 }
4379
4380 /**
4381 * @tc.name: FormMgrTest_0234
4382 * @tc.desc: Verify UpdateFormLocation
4383 * @tc.type: FUNC
4384 */
4385 HWTEST_F(FormMgrTest, FormMgrTest_0234, TestSize.Level1)
4386 {
4387 GTEST_LOG_(INFO) << "FormMgrTest_0234 starts";
4388 FormMgr::GetInstance().resetFlag_ = true;
4389 FormMgr::GetInstance().SetRecoverStatus(Constants::NOT_IN_RECOVERY);
4390 int32_t formLocation = 1;
4391 auto result = FormMgr::GetInstance().UpdateFormLocation(FORM_ID, formLocation);
4392 EXPECT_EQ(result, ERR_APPEXECFWK_FORM_COMMON_CODE);
4393 FormMgr::GetInstance().resetFlag_ = false;
4394 GTEST_LOG_(INFO) << "FormMgrTest_0234 test ends";
4395 }
4396
4397 /**
4398 * @tc.name: FormMgrTest_0235
4399 * @tc.desc: Verify UpdateFormLocation
4400 * @tc.type: FUNC
4401 */
4402 HWTEST_F(FormMgrTest, FormMgrTest_0235, TestSize.Level1)
4403 {
4404 GTEST_LOG_(INFO) << "FormMgrTest_0235 starts";
4405 EXPECT_CALL(*mockProxy, UpdateFormLocation(_, _))
4406 .Times(1)
4407 .WillOnce(Return(ERR_FAILED));
4408 FormMgr::GetInstance().SetFormMgrService(mockProxy);
4409 FormMgr::GetInstance().SetRecoverStatus(Constants::NOT_IN_RECOVERY);
4410 int32_t formLocation = 1;
4411 EXPECT_EQ(FormMgr::GetInstance().UpdateFormLocation(FORM_ID, formLocation), ERR_FAILED);
4412 GTEST_LOG_(INFO) << "FormMgrTest_0235 test ends";
4413 }
4414
4415 /**
4416 * @tc.name: FormMgrTest_0236
4417 * @tc.desc: Verify BatchRefreshForms
4418 * @tc.type: FUNC
4419 */
4420 HWTEST_F(FormMgrTest, FormMgrTest_0236, TestSize.Level1)
4421 {
4422 GTEST_LOG_(INFO) << "FormMgrTest_0236 starts";
4423 FormMgr::GetInstance().resetFlag_ = true;
4424 FormMgr::GetInstance().SetRecoverStatus(Constants::NOT_IN_RECOVERY);
4425 int32_t formRefreshType = Constants::REFRESH_ALL_FORM;
4426 EXPECT_EQ(FormMgr::GetInstance().BatchRefreshForms(formRefreshType), ERR_APPEXECFWK_FORM_COMMON_CODE);
4427 FormMgr::GetInstance().resetFlag_ = false;
4428 GTEST_LOG_(INFO) << "FormMgrTest_0236 test ends";
4429 }
4430
4431 /**
4432 * @tc.name: FormMgrTest_0237
4433 * @tc.desc: Verify CreateForm
4434 * @tc.type: FUNC
4435 */
4436 HWTEST_F(FormMgrTest, FormMgrTest_0237, TestSize.Level1)
4437 {
4438 GTEST_LOG_(INFO) << "FormMgrTest_0237 starts";
4439 EXPECT_CALL(*mockProxy, CreateForm(_, _))
4440 .Times(1)
4441 .WillOnce(Return(ERR_FAILED));
4442 Want want;
4443 RunningFormInfo runningFormInfo;
4444 FormMgr::GetInstance().SetFormMgrService(mockProxy);
4445 int result = FormMgr::GetInstance().CreateForm(want, runningFormInfo);
4446 EXPECT_EQ(result, ERR_FAILED);
4447 FormMgr::GetInstance().resetFlag_ = false;
4448 GTEST_LOG_(INFO) << "FormMgrTest_0237 test ends";
4449 }
4450
4451 /**
4452 * @tc.name: FormMgrTest_0238
4453 * @tc.desc: Verify RequestPublishForm (include data proxies)
4454 * @tc.type: FUNC
4455 */
4456 HWTEST_F(FormMgrTest, FormMgrTest_0238, TestSize.Level1)
4457 {
4458 GTEST_LOG_(INFO) << "FormMgrTest_0238 starts";
4459 FormMgr::GetInstance().resetFlag_ = true;
4460 Want want;
4461 int64_t formId = 0x00000008fffffffL;
4462 std::unique_ptr<FormProviderData> formProviderData;
4463 std::vector<FormDataProxy> formDataProxies;
4464 FormDataProxy formDataProxy("city", "");
4465 formDataProxies.push_back(formDataProxy);
4466 int32_t result = FormMgr::GetInstance().RequestPublishForm(want, true, formProviderData, formId, formDataProxies);
4467 EXPECT_EQ(result, ERR_APPEXECFWK_FORM_COMMON_CODE);
4468 FormMgr::GetInstance().resetFlag_ = false;
4469 FormMgr::GetInstance().SetFormMgrService(mockProxy);
4470 GTEST_LOG_(INFO) << "FormMgrTest_0238 test ends";
4471 }
4472
4473 /**
4474 * @tc.name: FormMgrTest_0239
4475 * @tc.desc: Verify SetFormsRecyclable
4476 * @tc.type: FUNC
4477 */
4478 HWTEST_F(FormMgrTest, FormMgrTest_0239, TestSize.Level1)
4479 {
4480 GTEST_LOG_(INFO) << "FormMgrTest_0239 test begin";
4481 FormMgr::GetInstance().resetFlag_ = true;
4482 std::vector<int64_t> formIds;
4483 formIds.push_back(FORM_ID);
4484 FormMgr::GetInstance().SetRecoverStatus(Constants::NOT_IN_RECOVERY);
4485 int32_t result = FormMgr::GetInstance().SetFormsRecyclable(formIds);
4486 EXPECT_EQ(result, ERR_APPEXECFWK_FORM_COMMON_CODE);
4487 FormMgr::GetInstance().resetFlag_ = false;
4488 FormMgr::GetInstance().SetFormMgrService(mockProxy);
4489 GTEST_LOG_(INFO) << "FormMgrTest_0239 test ends";
4490 }
4491
4492 /**
4493 * @tc.name: FormMgrTest_0240
4494 * @tc.desc: Verify RecycleForms
4495 * @tc.type: FUNC
4496 */
4497 HWTEST_F(FormMgrTest, FormMgrTest_0240, TestSize.Level1)
4498 {
4499 GTEST_LOG_(INFO) << "FormMgrTest_0240 begin";
4500 std::vector<int64_t> formIds;
4501 FormMgr::GetInstance().resetFlag_ = true;
4502 formIds.push_back(FORM_ID);
4503 Want want;
4504 FormMgr::GetInstance().SetRecoverStatus(Constants::NOT_IN_RECOVERY);
4505 int32_t result = FormMgr::GetInstance().RecycleForms(formIds, want);
4506 EXPECT_EQ(result, ERR_APPEXECFWK_FORM_COMMON_CODE);
4507 FormMgr::GetInstance().resetFlag_ = false;
4508 FormMgr::GetInstance().SetFormMgrService(mockProxy);
4509 GTEST_LOG_(INFO) << "FormMgrTest_0240 test ends";
4510 }
4511
4512 /**
4513 * @tc.name: FormMgrTest_0241
4514 * @tc.desc: Verify RecoverForms
4515 * @tc.type: FUNC
4516 */
4517 HWTEST_F(FormMgrTest, FormMgrTest_0241, TestSize.Level1)
4518 {
4519 GTEST_LOG_(INFO) << "FormMgrTest_0241 begin";
4520 FormMgr::GetInstance().resetFlag_ = true;
4521 std::vector<int64_t> formIds;
4522 formIds.push_back(FORM_ID);
4523 Want want;
4524 FormMgr::GetInstance().SetRecoverStatus(Constants::NOT_IN_RECOVERY);
4525 int32_t result = FormMgr::GetInstance().RecoverForms(formIds, want);
4526 EXPECT_EQ(result, ERR_APPEXECFWK_FORM_COMMON_CODE);
4527 FormMgr::GetInstance().resetFlag_ = false;
4528 FormMgr::GetInstance().SetFormMgrService(mockProxy);
4529 GTEST_LOG_(INFO) << "FormMgrTest_0241 test ends";
4530 }
4531
4532 /**
4533 * @tc.name: FormMgrTest_0242
4534 * @tc.desc: Verify EnableForms
4535 * @tc.type: FUNC
4536 */
4537 HWTEST_F(FormMgrTest, FormMgrTest_0242, TestSize.Level1)
4538 {
4539 GTEST_LOG_(INFO) << "FormMgrTest_0242 begin";
4540 std::string bundleName = "ohos.samples.FormApplication";
4541 FormMgr::GetInstance().SetRecoverStatus(Constants::NOT_IN_RECOVERY);
4542 EXPECT_CALL(*mockProxy, EnableForms(_, _))
4543 .Times(1)
4544 .WillOnce(Return(ERR_FAILED));
4545 int32_t result = FormMgr::GetInstance().EnableForms(bundleName, true);
4546 EXPECT_EQ(result, ERR_FAILED);
4547 GTEST_LOG_(INFO) << "FormMgrTest_0242 test ends";
4548 }
4549
4550 /**
4551 * @tc.name: FormMgrTest_0243
4552 * @tc.desc: Verify EnableForms
4553 * @tc.type: FUNC
4554 */
4555 HWTEST_F(FormMgrTest, FormMgrTest_0243, TestSize.Level1)
4556 {
4557 GTEST_LOG_(INFO) << "FormMgrTest_0243 begin";
4558 FormMgr::GetInstance().resetFlag_ = true;
4559 std::string bundleName = "ohos.samples.FormApplication";
4560 FormMgr::GetInstance().SetRecoverStatus(Constants::NOT_IN_RECOVERY);
4561 int32_t result = FormMgr::GetInstance().EnableForms(bundleName, true);
4562 EXPECT_EQ(result, ERR_APPEXECFWK_FORM_COMMON_CODE);
4563 FormMgr::GetInstance().resetFlag_ = false;
4564 FormMgr::GetInstance().SetFormMgrService(mockProxy);
4565 GTEST_LOG_(INFO) << "FormMgrTest_0243 test ends";
4566 }
4567
4568 /**
4569 * @tc.name: FormMgrTest_0244
4570 * @tc.desc: Verify IsFormBundleForbidden
4571 * @tc.type: FUNC
4572 */
4573 HWTEST_F(FormMgrTest, FormMgrTest_0244, TestSize.Level1)
4574 {
4575 GTEST_LOG_(INFO) << "FormMgrTest_0244 begin";
4576 FormMgr::GetInstance().resetFlag_ = true;
4577 std::string bundleName = "ohos.samples.FormApplication";
4578 bool result = FormMgr::GetInstance().IsFormBundleForbidden(bundleName);
4579 EXPECT_EQ(result, false);
4580 FormMgr::GetInstance().resetFlag_ = false;
4581 FormMgr::GetInstance().SetFormMgrService(mockProxy);
4582 GTEST_LOG_(INFO) << "FormMgrTest_0244 test ends";
4583 }
4584
4585 /**
4586 * @tc.name: FormMgrTest_0245
4587 * @tc.desc: Verify IsFormBundleProtected
4588 * @tc.type: FUNC
4589 */
4590 HWTEST_F(FormMgrTest, FormMgrTest_0245, TestSize.Level1)
4591 {
4592 GTEST_LOG_(INFO) << "FormMgrTest_0245 begin";
4593 std::string bundleName = "ohos.samples.FormApplication";
4594 int64_t formId = 1;
4595 bool result = FormMgr::GetInstance().IsFormBundleProtected(bundleName, formId);
4596 EXPECT_EQ(result, false);
4597 GTEST_LOG_(INFO) << "FormMgrTest_0245 test ends";
4598 }
4599
4600 /**
4601 * @tc.name: FormMgrTest_0246
4602 * @tc.desc: Verify UpdateFormSize
4603 * @tc.type: FUNC
4604 */
4605 HWTEST_F(FormMgrTest, FormMgrTest_0246, TestSize.Level1)
4606 {
4607 GTEST_LOG_(INFO) << "FormMgrTest_0246 begin";
4608 int64_t formId = 1;
4609 float width = 100;
4610 float height = 50;
4611 float borderWidth = 10;
4612 bool result = FormMgr::GetInstance().UpdateFormSize(formId, width, height, borderWidth);
4613 EXPECT_EQ(result, true);
4614 GTEST_LOG_(INFO) << "FormMgrTest_0246 test ends";
4615 }
4616
4617 /**
4618 * @tc.name: FormMgrTest_0247
4619 * @tc.desc: Verify NotifyFormLocked
4620 * @tc.type: FUNC
4621 */
4622 HWTEST_F(FormMgrTest, FormMgrTest_0247, TestSize.Level1)
4623 {
4624 GTEST_LOG_(INFO) << "FormMgrTest_0247 begin";
4625 int64_t formId = 1;
4626 bool isLocked = true;
4627 int32_t error = FormMgr::GetInstance().NotifyFormLocked(formId, isLocked);
4628 EXPECT_EQ(error, ERR_APPEXECFWK_FORM_SEND_FMS_MSG);
4629 GTEST_LOG_(INFO) << "FormMgrTest_0247 test ends";
4630 }
4631
4632 /**
4633 * @tc.name: FormMgrTest_0248
4634 * @tc.desc: Verify IsFormBundleExempt
4635 * @tc.type: FUNC
4636 */
4637 HWTEST_F(FormMgrTest, FormMgrTest_0248, TestSize.Level1)
4638 {
4639 GTEST_LOG_(INFO) << "FormMgrTest_0248 begin";
4640 int64_t formId = 1;
4641 bool result = FormMgr::GetInstance().IsFormBundleExempt(formId);
4642 EXPECT_EQ(result, false);
4643 GTEST_LOG_(INFO) << "FormMgrTest_0248 begin";
4644 }
4645
4646 /**
4647 * @tc.name: FormMgrTest_0249
4648 * @tc.desc: Verify GetPublishedFormInfoById
4649 * @tc.type: FUNC
4650 */
4651 HWTEST_F(FormMgrTest, FormMgrTest_0249, TestSize.Level1)
4652 {
4653 GTEST_LOG_(INFO) << "FormMgrTest_0249 begin";
4654 int64_t formId = 1;
4655 RunningFormInfo runningFormInfo;
4656 int32_t result = FormMgr::GetInstance().GetPublishedFormInfoById(formId, runningFormInfo);
4657 HILOG_INFO("FormMgrTest_0249,result: %{public}d", result);
4658 EXPECT_EQ(result, ERROR_NUMS);
4659 GTEST_LOG_(INFO) << "FormMgrTest_0249 end";
4660 }
4661
4662 /**
4663 * @tc.name: FormMgrTest_0250
4664 * @tc.desc: Verify GetPublishedFormInfoById
4665 * @tc.type: FUNC
4666 */
4667 HWTEST_F(FormMgrTest, FormMgrTest_0250, TestSize.Level1)
4668 {
4669 GTEST_LOG_(INFO) << "FormMgrTest_0250 begin";
4670 int64_t formId = 2;
4671 RunningFormInfo runningFormInfo;
4672 FormMgr::GetInstance().remoteProxy_ = nullptr;
4673 int32_t result = FormMgr::GetInstance().GetPublishedFormInfoById(formId, runningFormInfo);
4674 HILOG_INFO("FormMgrTest_0250,result: %{public}d", result);
4675 EXPECT_EQ(result, ERR_APPEXECFWK_FORM_COMMON_CODE);
4676 GTEST_LOG_(INFO) << "FormMgrTest_0250 end";
4677 }
4678
4679 /**
4680 * @tc.name: FormMgrTest_0251
4681 * @tc.desc: Verify GetPublishedFormInfos
4682 * @tc.type: FUNC
4683 */
4684 HWTEST_F(FormMgrTest, FormMgrTest_0251, TestSize.Level1)
4685 {
4686 GTEST_LOG_(INFO) << "FormMgrTest_0251 begin";
4687 std::vector<RunningFormInfo> runningFormInfos;
4688 int32_t result = FormMgr::GetInstance().GetPublishedFormInfos(runningFormInfos);
4689 HILOG_INFO("FormMgrTest_0251,result: %{public}d", result);
4690 EXPECT_EQ(result, ERROR_NUMS);
4691 GTEST_LOG_(INFO) << "FormMgrTest_0251 end";
4692 }
4693
4694 /**
4695 * @tc.name: FormMgrTest_0252
4696 * @tc.desc: Verify GetPublishedFormInfos
4697 * @tc.type: FUNC
4698 */
4699 HWTEST_F(FormMgrTest, FormMgrTest_0252, TestSize.Level1)
4700 {
4701 GTEST_LOG_(INFO) << "FormMgrTest_0252 begin";
4702 std::vector<RunningFormInfo> runningFormInfos;
4703 FormMgr::GetInstance().remoteProxy_ = nullptr;
4704 int32_t result = FormMgr::GetInstance().GetPublishedFormInfos(runningFormInfos);
4705 HILOG_INFO("FormMgrTest_0252,result: %{public}d", result);
4706 EXPECT_EQ(result, ERR_APPEXECFWK_FORM_COMMON_CODE);
4707 GTEST_LOG_(INFO) << "FormMgrTest_0252 end";
4708 }
4709
4710 /**
4711 * @tc.name: FormMgrTest_0253
4712 * @tc.desc: Verify OpenFormEditAbility
4713 * @tc.type: FUNC
4714 */
4715 HWTEST_F(FormMgrTest, FormMgrTest_0253, TestSize.Level1)
4716 {
4717 GTEST_LOG_(INFO) << "FormMgrTest_0253 begin";
4718 std::string abilityName = "";
4719 int64_t formId = 1;
4720 bool isMainPage = true;
4721 ErrCode result = FormMgr::GetInstance().OpenFormEditAbility(abilityName, formId, isMainPage);
4722 HILOG_INFO("FormMgrTest_0253,result: %{public}d", result);
4723 EXPECT_EQ(result, ERROR_NUMS);
4724 GTEST_LOG_(INFO) << "FormMgrTest_0253 end";
4725 }
4726
4727 /**
4728 * @tc.name: FormMgrTest_0254
4729 * @tc.desc: Verify OpenFormEditAbility
4730 * @tc.type: FUNC
4731 */
4732 HWTEST_F(FormMgrTest, FormMgrTest_0254, TestSize.Level1)
4733 {
4734 GTEST_LOG_(INFO) << "FormMgrTest_0254 begin";
4735 std::string abilityName = "123";
4736 int64_t formId = 2;
4737 bool isMainPage = true;
4738 FormMgr::GetInstance().remoteProxy_ = nullptr;
4739 ErrCode result = FormMgr::GetInstance().OpenFormEditAbility(abilityName, formId, isMainPage);
4740 HILOG_INFO("FormMgrTest_0254,result: %{public}d", result);
4741 EXPECT_EQ(result, ERR_APPEXECFWK_FORM_COMMON_CODE);
4742 GTEST_LOG_(INFO) << "FormMgrTest_0254 end";
4743 }
4744
4745 /**
4746 * @tc.name: FormMgrTest_0255
4747 * @tc.desc: Verify OpenFormEditAbility
4748 * @tc.type: FUNC
4749 */
4750 HWTEST_F(FormMgrTest, FormMgrTest_0255, TestSize.Level1)
4751 {
4752 GTEST_LOG_(INFO) << "FormMgrTest_0255 begin";
4753 std::string abilityName = "456";
4754 int64_t formId = 2;
4755 bool isMainPage = false;
4756 FormMgr::GetInstance().remoteProxy_ = nullptr;
4757 ErrCode result = FormMgr::GetInstance().OpenFormEditAbility(abilityName, formId, isMainPage);
4758 HILOG_INFO("FormMgrTest_0255,result: %{public}d", result);
4759 EXPECT_EQ(result, ERR_APPEXECFWK_FORM_COMMON_CODE);
4760 GTEST_LOG_(INFO) << "FormMgrTest_0255 end";
4761 }
4762
4763 /**
4764 * @tc.name: FormMgrTest_0256
4765 * @tc.desc: Verify requestOverflow
4766 * @tc.type: FUNC
4767 */
4768 HWTEST_F(FormMgrTest, FormMgrTest_0256, TestSize.Level1) {
4769 GTEST_LOG_(INFO) << "FormMgrTest_0256 starts";
4770 EXPECT_CALL(*mockProxy, RequestOverflow(_, _, _))
4771 .Times(1)
4772 .WillOnce(Return(0));
4773 FormJsInfo formJsInfo;
4774 formJsInfo.formId = 1;
4775 OverflowInfo overflowInfo;
4776 overflowInfo.duration = 3500;
4777 overflowInfo.area.left = -30;
4778 overflowInfo.area.top = -30;
4779 overflowInfo.area.width = 300;
4780 overflowInfo.area.height = 300;
4781 bool isOverflow = true;
4782 sptr<MockFormToken> token = new (std::nothrow) MockFormToken();
4783 sptr<IRemoteObject> providerToken = new (std::nothrow) MockFormProviderClient();
4784 FormCallerMgr::GetInstance().AddFormHostCaller(formJsInfo, providerToken);
4785 ErrCode result = FormMgr::GetInstance().RequestOverflow(formJsInfo.formId, overflowInfo, isOverflow);
4786 EXPECT_EQ(result, 0);
4787 GTEST_LOG_(INFO) << "FormMgrTest_0256 test ends";
4788 }
4789
4790 /**
4791 * @tc.name: FormMgrTest_0257
4792 * @tc.desc: Verify requestOverflow
4793 * @tc.type: FUNC
4794 */
4795 HWTEST_F(FormMgrTest, FormMgrTest_0257, TestSize.Level1) {
4796 GTEST_LOG_(INFO) << "FormMgrTest_0257 starts";
4797 int64_t formId = -1;
4798 OverflowInfo overflowInfo;
4799 bool isOverflow = true;
4800 ErrCode result = FormMgr::GetInstance().RequestOverflow(formId, overflowInfo, isOverflow);
4801 EXPECT_EQ(result, ERR_APPEXECFWK_FORM_INVALID_FORM_ID);
4802 GTEST_LOG_(INFO) << "FormMgrTest_0257 test ends";
4803 }
4804
4805 /**
4806 * @tc.name: FormMgrTest_0258
4807 * @tc.desc: Verify requestOverflow
4808 * @tc.type: FUNC
4809 */
4810 HWTEST_F(FormMgrTest, FormMgrTest_0258, TestSize.Level1) {
4811 GTEST_LOG_(INFO) << "FormMgrTest_0258 starts";
4812 int64_t formId = 1;
4813 OverflowInfo overflowInfo;
4814 overflowInfo.duration = -1;
4815 bool isOverflow = true;
4816 ErrCode result = FormMgr::GetInstance().RequestOverflow(formId, overflowInfo, isOverflow);
4817 EXPECT_EQ(result, ERR_APPEXECFWK_FORM_INVALID_PARAM);
4818 GTEST_LOG_(INFO) << "FormMgrTest_0258 test ends";
4819 }
4820
4821 /**
4822 * @tc.name: FormMgrTest_0259
4823 * @tc.desc: Verify requestOverflow
4824 * @tc.type: FUNC
4825 */
4826 HWTEST_F(FormMgrTest, FormMgrTest_0259, TestSize.Level1)
4827 {
4828 GTEST_LOG_(INFO) << "FormMgrTest_0259 begin";
4829 int64_t formId = 1;
4830 OverflowInfo overflowInfo;
4831 overflowInfo.area.left = -30;
4832 overflowInfo.area.top = -30;
4833 overflowInfo.area.width = 200;
4834 overflowInfo.area.height = 200;
4835 overflowInfo.duration = 3500;
4836 bool isOverflow = true;
4837 FormMgr::GetInstance().remoteProxy_ = nullptr;
4838 ErrCode result = FormMgr::GetInstance().RequestOverflow(formId, overflowInfo, isOverflow);
4839 EXPECT_EQ(result, ERR_APPEXECFWK_FORM_COMMON_CODE);
4840 GTEST_LOG_(INFO) << "FormMgrTest_0259 end";
4841 }
4842
4843 /**
4844 * @tc.name: FormMgrTest_0260
4845 * @tc.desc: Verify ChangeSceneAnimationState
4846 * @tc.type: FUNC
4847 */
4848 HWTEST_F(FormMgrTest, FormMgrTest_0260, TestSize.Level1) {
4849 GTEST_LOG_(INFO) << "FormMgrTest_0260 starts";
4850 EXPECT_CALL(*mockProxy, ChangeSceneAnimationState(_, _))
4851 .Times(1)
4852 .WillOnce(Return(0));
4853 FormJsInfo formJsInfo;
4854 formJsInfo.formId = 1;
4855 int32_t state = 1;
4856 sptr<MockFormToken> token = new (std::nothrow) MockFormToken();
4857 sptr<IRemoteObject> providerToken = new (std::nothrow) MockFormProviderClient();
4858 FormCallerMgr::GetInstance().AddFormHostCaller(formJsInfo, providerToken);
4859 ErrCode result = FormMgr::GetInstance().ChangeSceneAnimationState(formJsInfo.formId, state);
4860 EXPECT_EQ(result, 0);
4861 GTEST_LOG_(INFO) << "FormMgrTest_0260 test ends";
4862 }
4863
4864 /**
4865 * @tc.name: FormMgrTest_0261
4866 * @tc.desc: Verify ChangeSceneAnimationState
4867 * @tc.type: FUNC
4868 */
4869 HWTEST_F(FormMgrTest, FormMgrTest_0261, TestSize.Level1) {
4870 GTEST_LOG_(INFO) << "FormMgrTest_0261 starts";
4871 int64_t formId = -1;
4872 int32_t state = 1;
4873 ErrCode result = FormMgr::GetInstance().ChangeSceneAnimationState(formId, state);
4874 EXPECT_EQ(result, ERR_APPEXECFWK_FORM_INVALID_FORM_ID);
4875 GTEST_LOG_(INFO) << "FormMgrTest_0261 test ends";
4876 }
4877
4878 /**
4879 * @tc.name: FormMgrTest_0262
4880 * @tc.desc: Verify ChangeSceneAnimationState
4881 * @tc.type: FUNC
4882 */
4883 HWTEST_F(FormMgrTest, FormMgrTest_0262, TestSize.Level1)
4884 {
4885 GTEST_LOG_(INFO) << "FormMgrTest_0262 begin";
4886 int64_t formId = 1;
4887 int32_t state = 1;
4888 FormMgr::GetInstance().remoteProxy_ = nullptr;
4889 ErrCode result = FormMgr::GetInstance().ChangeSceneAnimationState(formId, state);
4890 EXPECT_EQ(result, ERR_APPEXECFWK_FORM_COMMON_CODE);
4891 GTEST_LOG_(INFO) << "FormMgrTest_0262 end";
4892 }
4893
4894 /**
4895 * @tc.name: FormMgrTest_0263
4896 * @tc.desc: Verify StartAbilityByCrossBundle
4897 * @tc.type: FUNC
4898 */
4899 HWTEST_F(FormMgrTest, FormMgrTest_0263, TestSize.Level1)
4900 {
4901 GTEST_LOG_(INFO) << "FormMgrTest_0263 begin";
4902 Want want;
4903 ErrCode result = FormMgr::GetInstance().StartAbilityByCrossBundle(want);
4904 HILOG_INFO("FormMgrTest_0263,result: %{public}d", result);
4905 EXPECT_EQ(result, ERR_APPEXECFWK_FORM_GET_SYSMGR_FAILED);
4906 GTEST_LOG_(INFO) << "FormMgrTest_0263 end";
4907 }
4908
4909 /**
4910 * @tc.name: FormMgrTest_0272
4911 * @tc.desc: Verify getFormRect
4912 * @tc.type: FUNC
4913 */
4914 HWTEST_F(FormMgrTest, FormMgrTest_0272, TestSize.Level1) {
4915 GTEST_LOG_(INFO) << "FormMgrTest_0272 starts";
4916 EXPECT_CALL(*mockProxy, GetFormRect(_, _))
4917 .Times(1)
4918 .WillOnce(Return(0));
4919 FormJsInfo formJsInfo;
4920 formJsInfo.formId = 1;
4921 Rect rect;
4922 sptr<MockFormToken> token = new (std::nothrow) MockFormToken();
4923 sptr<IRemoteObject> providerToken = new (std::nothrow) MockFormProviderClient();
4924 FormCallerMgr::GetInstance().AddFormHostCaller(formJsInfo, providerToken);
4925 ErrCode result = FormMgr::GetInstance().GetFormRect(formJsInfo.formId, rect);
4926 EXPECT_EQ(result, 0);
4927 GTEST_LOG_(INFO) << "FormMgrTest_0272 test ends";
4928 }
4929
4930 /**
4931 * @tc.name: FormMgrTest_0273
4932 * @tc.desc: Verify getFormRect
4933 * @tc.type: FUNC
4934 */
4935 HWTEST_F(FormMgrTest, FormMgrTest_0273, TestSize.Level1) {
4936 GTEST_LOG_(INFO) << "FormMgrTest_0273 starts";
4937 int64_t formId = -1;
4938 Rect rect;
4939 ErrCode result = FormMgr::GetInstance().GetFormRect(formId, rect);
4940 EXPECT_EQ(result, ERR_APPEXECFWK_FORM_INVALID_FORM_ID);
4941 GTEST_LOG_(INFO) << "FormMgrTest_0273 test ends";
4942 }
4943
4944 /**
4945 * @tc.name: FormMgrTest_0275
4946 * @tc.desc: Verify RegisterGetFormRectProxy
4947 * @tc.type: FUNC
4948 */
4949 HWTEST_F(FormMgrTest, FormMgrTest_0275, TestSize.Level1) {
4950 GTEST_LOG_(INFO) << "FormMgrTest_0275 starts";
4951 EXPECT_CALL(*mockProxy, RegisterGetFormRectProxy(_))
4952 .Times(1)
4953 .WillOnce(Return(true));
4954 sptr<IRemoteObject> callerToken = new (std::nothrow) MockFormProviderClient();
4955 bool result = FormMgr::GetInstance().RegisterGetFormRectProxy(callerToken);
4956 EXPECT_EQ(result, true);
4957 GTEST_LOG_(INFO) << "FormMgrTest_0275 test ends";
4958 }
4959
4960 /**
4961 * @tc.name: FormMgrTest_0276
4962 * @tc.desc: Verify RegisterGetFormRectProxy
4963 * @tc.type: FUNC
4964 */
4965 HWTEST_F(FormMgrTest, FormMgrTest_0276, TestSize.Level1) {
4966 GTEST_LOG_(INFO) << "FormMgrTest_0276 starts";
4967 EXPECT_CALL(*mockProxy, RegisterGetFormRectProxy(_))
4968 .Times(1)
4969 .WillOnce(Return(false));
4970 sptr<IRemoteObject> callerToken = new (std::nothrow) MockFormProviderClient();
4971 bool result = FormMgr::GetInstance().RegisterGetFormRectProxy(callerToken);
4972 EXPECT_EQ(result, false);
4973 GTEST_LOG_(INFO) << "FormMgrTest_0276 test ends";
4974 }
4975
4976 /**
4977 * @tc.name: FormMgrTest_0277
4978 * @tc.desc: Verify UnregisterGetFormRectProxy
4979 * @tc.type: FUNC
4980 */
4981 HWTEST_F(FormMgrTest, FormMgrTest_0277, TestSize.Level1)
4982 {
4983 GTEST_LOG_(INFO) << "FormMgrTest_0277 starts";
4984 EXPECT_CALL(*mockProxy, UnregisterGetFormRectProxy())
4985 .Times(1)
4986 .WillOnce(Return(true));
4987 bool result = FormMgr::GetInstance().UnregisterGetFormRectProxy();
4988 EXPECT_EQ(result, true);
4989 GTEST_LOG_(INFO) << "FormMgrTest_0277 test ends";
4990 }
4991
4992 /**
4993 * @tc.name: FormMgrTest_0278
4994 * @tc.desc: Verify UnregisterGetFormRectProxy
4995 * @tc.type: FUNC
4996 */
4997 HWTEST_F(FormMgrTest, FormMgrTest_0278, TestSize.Level1)
4998 {
4999 GTEST_LOG_(INFO) << "FormMgrTest_0278 starts";
5000 EXPECT_CALL(*mockProxy, UnregisterGetFormRectProxy())
5001 .Times(1)
5002 .WillOnce(Return(false));
5003 bool result = FormMgr::GetInstance().UnregisterGetFormRectProxy();
5004 EXPECT_EQ(result, false);
5005 GTEST_LOG_(INFO) << "FormMgrTest_0278 test ends";
5006 }
5007
5008 /**
5009 * @tc.name: FormMgrTest_0279
5010 * @tc.desc: Verify RegisterGetLiveFormStatusProxy
5011 * @tc.type: FUNC
5012 */
5013 HWTEST_F(FormMgrTest, FormMgrTest_0279, TestSize.Level1) {
5014 GTEST_LOG_(INFO) << "FormMgrTest_0279 starts";
5015 EXPECT_CALL(*mockProxy, RegisterGetLiveFormStatusProxy(_))
5016 .Times(1)
5017 .WillOnce(Return(true));
5018 sptr<IRemoteObject> callerToken = new (std::nothrow) MockFormProviderClient();
5019 bool result = FormMgr::GetInstance().RegisterGetLiveFormStatusProxy(callerToken);
5020 EXPECT_EQ(result, true);
5021 GTEST_LOG_(INFO) << "FormMgrTest_0279 test ends";
5022 }
5023
5024 /**
5025 * @tc.name: FormMgrTest_0280
5026 * @tc.desc: Verify RegisterGetLiveFormStatusProxy
5027 * @tc.type: FUNC
5028 */
5029 HWTEST_F(FormMgrTest, FormMgrTest_0280, TestSize.Level1) {
5030 GTEST_LOG_(INFO) << "FormMgrTest_0280 starts";
5031 EXPECT_CALL(*mockProxy, RegisterGetLiveFormStatusProxy(_))
5032 .Times(1)
5033 .WillOnce(Return(false));
5034 sptr<IRemoteObject> callerToken = new (std::nothrow) MockFormProviderClient();
5035 bool result = FormMgr::GetInstance().RegisterGetLiveFormStatusProxy(callerToken);
5036 EXPECT_EQ(result, false);
5037 GTEST_LOG_(INFO) << "FormMgrTest_0280 test ends";
5038 }
5039
5040 /**
5041 * @tc.name: FormMgrTest_0281
5042 * @tc.desc: Verify UnregisterGetLiveFormStatusProxy
5043 * @tc.type: FUNC
5044 */
5045 HWTEST_F(FormMgrTest, FormMgrTest_0281, TestSize.Level1)
5046 {
5047 GTEST_LOG_(INFO) << "FormMgrTest_0281 starts";
5048 EXPECT_CALL(*mockProxy, UnregisterGetLiveFormStatusProxy())
5049 .Times(1)
5050 .WillOnce(Return(true));
5051 bool result = FormMgr::GetInstance().UnregisterGetLiveFormStatusProxy();
5052 EXPECT_EQ(result, true);
5053 GTEST_LOG_(INFO) << "FormMgrTest_0281 test ends";
5054 }
5055
5056 /**
5057 * @tc.name: FormMgrTest_0282
5058 * @tc.desc: Verify UnregisterGetLiveFormStatusProxy
5059 * @tc.type: FUNC
5060 */
5061 HWTEST_F(FormMgrTest, FormMgrTest_0282, TestSize.Level1)
5062 {
5063 GTEST_LOG_(INFO) << "FormMgrTest_0282 starts";
5064 EXPECT_CALL(*mockProxy, UnregisterGetLiveFormStatusProxy())
5065 .Times(1)
5066 .WillOnce(Return(false));
5067 bool result = FormMgr::GetInstance().UnregisterGetLiveFormStatusProxy();
5068 EXPECT_EQ(result, false);
5069 GTEST_LOG_(INFO) << "FormMgrTest_0282 test ends";
5070 }
5071
5072 /**
5073 * @tc.name: FormMgrTest_0283
5074 * @tc.desc: Verify UpdateFormSize
5075 * @tc.type: FUNC
5076 */
5077 HWTEST_F(FormMgrTest, FormMgrTest_0283, TestSize.Level1) {
5078 GTEST_LOG_(INFO) << "FormMgrTest_0283 starts";
5079 int64_t formId = -1;
5080 int32_t newDimension = 1;
5081 Rect rect;
5082 ErrCode result = FormMgr::GetInstance().UpdateFormSize(formId, newDimension, rect);
5083 EXPECT_EQ(result, ERR_APPEXECFWK_FORM_NOT_EXIST_ID);
5084 GTEST_LOG_(INFO) << "FormMgrTest_0283 test ends";
5085 }
5086
5087 /**
5088 * @tc.name: FormMgrTest_0284
5089 * @tc.desc: Verify UpdateFormSize
5090 * @tc.type: FUNC
5091 */
5092 HWTEST_F(FormMgrTest, FormMgrTest_0284, TestSize.Level1)
5093 {
5094 GTEST_LOG_(INFO) << "FormMgrTest_0284 begin";
5095 int64_t formId = 1;
5096 int32_t newDimension = 1;
5097 Rect rect;
5098 ErrCode result = FormMgr::GetInstance().UpdateFormSize(formId, newDimension, rect);
5099 EXPECT_EQ(result, ERR_APPEXECFWK_FORM_SEND_FMS_MSG);
5100 GTEST_LOG_(INFO) << "FormMgrTest_0284 end";
5101 }
5102 } // namespace
5103