1 /*
2 * Copyright (c) 2022 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 <fstream>
16 #include <future>
17 #include <vector>
18
19 #include <gtest/gtest.h>
20
21 #include "ability_info.h"
22 #include "app_log_wrapper.h"
23 #include "bundle_constants.h"
24 #include "bundle_installer_interface.h"
25 #include "bundle_mgr_client.h"
26 #include "bundle_mgr_interface.h"
27 #include "common_event_manager.h"
28 #include "common_event_support.h"
29 #include "common_tool.h"
30 #include "extension_ability_info.h"
31 #include "hap_module_info.h"
32 #include "iservice_registry.h"
33 #include "status_receiver_host.h"
34 #include "system_ability_definition.h"
35
36 using namespace testing::ext;
37
38 namespace OHOS {
39 namespace AppExecFwk {
40 namespace {
41 const std::string RESOURCE_PATH =
42 "/data/app/el1/bundle/public/com.example.ohosproject.hmservice/entry_phone/resources.index";
43 const std::string THIRD_PATH = "/data/test/bms_bundle/";
44 const std::string BUNDLE_NAME = "com.example.ohosproject.hmservice";
45 const std::string MSG_SUCCESS = "[SUCCESS]";
46 const std::string OPERATION_FAILURE = "Failure";
47 const std::string OPERATION_SUCCESS = "Success";
48 const int TIMEOUT = 10;
49 const int DEFAULT_USERID = 100;
50 } // namespace
51
52 class StatusReceiverImpl : public StatusReceiverHost {
53 public:
54 StatusReceiverImpl();
55 virtual ~StatusReceiverImpl() override;
56 virtual void OnStatusNotify(const int progress) override;
57 virtual void OnFinished(const int32_t resultCode, const std::string &resultMsg) override;
58 std::string GetResultMsg() const;
59
60 private:
61 mutable std::promise<std::string> resultMsgSignal_;
62 int iProgress_ = 0;
63
64 DISALLOW_COPY_AND_MOVE(StatusReceiverImpl);
65 };
66
StatusReceiverImpl()67 StatusReceiverImpl::StatusReceiverImpl()
68 {
69 APP_LOGI("create status receiver instance");
70 }
71
~StatusReceiverImpl()72 StatusReceiverImpl::~StatusReceiverImpl()
73 {
74 APP_LOGI("destroy status receiver instance");
75 }
76
OnStatusNotify(const int progress)77 void StatusReceiverImpl::OnStatusNotify(const int progress)
78 {
79 EXPECT_GT(progress, iProgress_);
80 iProgress_ = progress;
81 APP_LOGI("OnStatusNotify progress:%{public}d", progress);
82 }
83
OnFinished(const int32_t resultCode,const std::string & resultMsg)84 void StatusReceiverImpl::OnFinished(const int32_t resultCode, const std::string &resultMsg)
85 {
86 APP_LOGD("on finished result is %{public}d, %{public}s", resultCode, resultMsg.c_str());
87 resultMsgSignal_.set_value(resultMsg);
88 }
89
GetResultMsg() const90 std::string StatusReceiverImpl::GetResultMsg() const
91 {
92 auto future = resultMsgSignal_.get_future();
93 std::chrono::seconds timeout(TIMEOUT);
94 if (future.wait_for(timeout) == std::future_status::timeout) {
95 return OPERATION_FAILURE + " timeout";
96 }
97 std::string resultMsg = future.get();
98 if (resultMsg == MSG_SUCCESS) {
99 return OPERATION_SUCCESS;
100 }
101 return OPERATION_FAILURE + resultMsg;
102 }
103
104 class BundleMgrClientSystemTest : public testing::Test {
105 public:
106 static void SetUpTestCase();
107 static void TearDownTestCase();
108 void SetUp();
109 void TearDown();
110 static void InstallBundle(
111 const std::string &bundleFilePath, const InstallFlag installFlag, std::string &installMsg, const int userId);
112 static void UninstallBundle(const std::string &bundleName, std::string &uninstallMsg, const int userId);
113 static sptr<IBundleMgr> GetBundleMgrProxy();
114 static sptr<IBundleInstaller> GetInstallerProxy();
115 };
116
SetUpTestCase()117 void BundleMgrClientSystemTest::SetUpTestCase()
118 {}
119
TearDownTestCase()120 void BundleMgrClientSystemTest::TearDownTestCase()
121 {}
122
SetUp()123 void BundleMgrClientSystemTest::SetUp()
124 {}
125
TearDown()126 void BundleMgrClientSystemTest::TearDown()
127 {}
128
GetBundleMgrProxy()129 sptr<IBundleMgr> BundleMgrClientSystemTest::GetBundleMgrProxy()
130 {
131 sptr<ISystemAbilityManager> systemAbilityManager =
132 SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
133 if (!systemAbilityManager) {
134 APP_LOGE("fail to get system ability mgr.");
135 return nullptr;
136 }
137
138 sptr<IRemoteObject> remoteObject = systemAbilityManager->GetSystemAbility(BUNDLE_MGR_SERVICE_SYS_ABILITY_ID);
139 if (!remoteObject) {
140 APP_LOGE("fail to get bundle manager proxy.");
141 return nullptr;
142 }
143
144 APP_LOGI("get bundle manager proxy success.");
145 return iface_cast<IBundleMgr>(remoteObject);
146 }
147
GetInstallerProxy()148 sptr<IBundleInstaller> BundleMgrClientSystemTest::GetInstallerProxy()
149 {
150 sptr<IBundleMgr> bundleMgrProxy = GetBundleMgrProxy();
151 if (!bundleMgrProxy) {
152 APP_LOGE("bundle mgr proxy is nullptr.");
153 return nullptr;
154 }
155
156 sptr<IBundleInstaller> installerProxy = bundleMgrProxy->GetBundleInstaller();
157 if (!installerProxy) {
158 APP_LOGE("fail to get bundle installer proxy");
159 return nullptr;
160 }
161
162 APP_LOGI("get bundle installer proxy success.");
163 return installerProxy;
164 }
165
InstallBundle(const std::string & bundleFilePath,const InstallFlag installFlag,std::string & installMsg,const int userId=Constants::ALL_USERID)166 void BundleMgrClientSystemTest::InstallBundle(
167 const std::string &bundleFilePath, const InstallFlag installFlag, std::string &installMsg,
168 const int userId = Constants::ALL_USERID)
169 {
170 sptr<IBundleInstaller> installerProxy = GetInstallerProxy();
171 if (!installerProxy) {
172 APP_LOGE("get bundle installer Failure.");
173 installMsg = "Failure";
174 return;
175 }
176
177 InstallParam installParam;
178 installParam.installFlag = installFlag;
179 if (userId != 0) {
180 installParam.userId = userId;
181 }
182 sptr<StatusReceiverImpl> statusReceiver(new (std::nothrow) StatusReceiverImpl());
183 EXPECT_NE(statusReceiver, nullptr);
184 bool installResult = installerProxy->Install(bundleFilePath, installParam, statusReceiver);
185 EXPECT_TRUE(installResult);
186 installMsg = statusReceiver->GetResultMsg();
187 }
188
UninstallBundle(const std::string & bundleName,std::string & uninstallMsg,const int userId=Constants::ALL_USERID)189 void BundleMgrClientSystemTest::UninstallBundle(
190 const std::string &bundleName, std::string &uninstallMsg, const int userId = Constants::ALL_USERID)
191 {
192 sptr<IBundleInstaller> installerProxy = GetInstallerProxy();
193 if (!installerProxy) {
194 APP_LOGE("get bundle installer Failure.");
195 uninstallMsg = "Failure";
196 return;
197 }
198
199 sptr<StatusReceiverImpl> statusReceiver(new (std::nothrow) StatusReceiverImpl());
200 EXPECT_NE(statusReceiver, nullptr);
201 InstallParam installParam;
202 if (userId != 0) {
203 installParam.userId = userId;
204 }
205 bool uninstallResult = installerProxy->Uninstall(bundleName, installParam, statusReceiver);
206 EXPECT_TRUE(uninstallResult);
207 uninstallMsg = statusReceiver->GetResultMsg();
208 }
209
210 /**
211 * @tc.number: GetResourceConfigFile_001
212 * @tc.name: GetResConfigFile
213 * @tc.desc: Test the interface of GetResConfigFile
214 * 1. extensionAbilityInfo is invalid, resourcePath is empty
215 * @tc.require: AR000GNT9D
216 */
217 HWTEST_F(BundleMgrClientSystemTest, GetResourceConfigFile_001, TestSize.Level1)
218 {
219 auto name = std::string("GetResourceConfigFile_001");
220 GTEST_LOG_(INFO) << name << " start";
221 ExtensionAbilityInfo info;
222 std::vector<Metadata> &metadata = info.metadata;
223 Metadata data;
224 data.name = "ohos.extension.forms";
225 data.resource = "@profile:form_config";
226 metadata.emplace_back(data);
227 info.resourcePath = "";
228 BundleMgrClient bundleMgrClient;
229 std::string metadataName = "ohos.extension.forms";
230 std::vector<std::string> profileInfo;
231 auto ret = bundleMgrClient.GetResConfigFile(info, metadataName, profileInfo);
232 EXPECT_FALSE(ret);
233 GTEST_LOG_(INFO) << name << " end";
234 }
235
236 /**
237 * @tc.number: GetResourceConfigFile_002
238 * @tc.name: GetResConfigFile
239 * @tc.desc: Test the interface of GetResConfigFile
240 * 1. extensionAbilityInfo is invalid, resourcePath is not existed
241 * @tc.require: AR000GNT9D
242 */
243 HWTEST_F(BundleMgrClientSystemTest, GetResourceConfigFile_002, TestSize.Level1)
244 {
245 auto name = std::string("GetResourceConfigFile_002");
246 GTEST_LOG_(INFO) << name << " start";
247 ExtensionAbilityInfo info;
248 std::vector<Metadata> &metadata = info.metadata;
249 Metadata data;
250 data.name = "ohos.extension.forms";
251 data.resource = "@profile:form_config";
252 metadata.emplace_back(data);
253 info.resourcePath = "resourcePath";
254 BundleMgrClient bundleMgrClient;
255 std::string metadataName = "ohos.extension.forms";
256 std::vector<std::string> profileInfo;
257 auto ret = bundleMgrClient.GetResConfigFile(info, metadataName, profileInfo);
258 EXPECT_FALSE(ret);
259 GTEST_LOG_(INFO) << name << " end";
260 }
261
262 /**
263 * @tc.number: GetResourceConfigFile_003
264 * @tc.name: GetResConfigFile
265 * @tc.desc: Test the interface of GetResConfigFile
266 * 1. extensionAbilityInfo is invalid, metadata is not existed
267 * @tc.require: AR000GNT9D
268 */
269 HWTEST_F(BundleMgrClientSystemTest, GetResourceConfigFile_003, TestSize.Level1)
270 {
271 auto name = std::string("GetResourceConfigFile_003");
272 GTEST_LOG_(INFO) << name << " start";
273 ExtensionAbilityInfo info;
274 std::vector<Metadata> &metadata = info.metadata;
275 Metadata data;
276 data.name = "extensionName";
277 data.resource = "@profile:form_config";
278 metadata.emplace_back(data);
279 info.resourcePath = RESOURCE_PATH;
280 BundleMgrClient bundleMgrClient;
281 std::string metadataName = "ohos.extension.forms";
282 std::vector<std::string> profileInfo;
283 auto ret = bundleMgrClient.GetResConfigFile(info, metadataName, profileInfo);
284 EXPECT_FALSE(ret);
285 GTEST_LOG_(INFO) << name << " end";
286 }
287
288 /**
289 * @tc.number: GetResourceConfigFile_004
290 * @tc.name: GetResConfigFile
291 * @tc.desc: Test the interface of GetResConfigFile
292 * 1. extensionAbilityInfo is valid
293 * 2. metadataName is not empty
294 * 3. extensionAbilityInfo does not have metadata
295 * @tc.require: AR000GNT9D
296 */
297 HWTEST_F(BundleMgrClientSystemTest, GetResourceConfigFile_004, TestSize.Level1)
298 {
299 auto name = std::string("GetResourceConfigFile_004");
300 GTEST_LOG_(INFO) << name << " start";
301 ExtensionAbilityInfo info;
302 info.resourcePath = RESOURCE_PATH;
303 BundleMgrClient bundleMgrClient;
304 std::string metadataName = "ohos.extension.forms";
305 std::vector<std::string> profileInfo;
306 auto ret = bundleMgrClient.GetResConfigFile(info, metadataName, profileInfo);
307 EXPECT_FALSE(ret);
308 GTEST_LOG_(INFO) << name << " end";
309 }
310
311 /**
312 * @tc.number: GetResourceConfigFile_005
313 * @tc.name: GetResConfigFile
314 * @tc.desc: Test the interface of GetResConfigFile
315 * 1. extensionAbilityInfo is valid
316 * 2. metadataName is not empty
317 * 3. metadataName cannot be found
318 * @tc.require: AR000GNT9D
319 */
320 HWTEST_F(BundleMgrClientSystemTest, GetResourceConfigFile_005, TestSize.Level1)
321 {
322 auto name = std::string("GetResourceConfigFile_005");
323 GTEST_LOG_(INFO) << name << " start";
324 ExtensionAbilityInfo info;
325 std::vector<Metadata> &metadata = info.metadata;
326 Metadata data;
327 data.name = "ohos.extension.forms";
328 data.resource = "@profile:form_config";
329 metadata.emplace_back(data);
330 info.resourcePath = RESOURCE_PATH;
331 BundleMgrClient bundleMgrClient;
332 std::string metadataName = "ohos.extension.forms1";
333 std::vector<std::string> profileInfo;
334 auto ret = bundleMgrClient.GetResConfigFile(info, metadataName, profileInfo);
335 EXPECT_FALSE(ret);
336 GTEST_LOG_(INFO) << name << " end";
337 }
338
339 /**
340 * @tc.number: GetResourceConfigFile_006
341 * @tc.name: GetResConfigFile
342 * @tc.desc: Test the interface of GetResConfigFile
343 * 1. extensionAbilityInfo is valid and has only one metadata
344 * 2. metadataName is not empty
345 * 3. metadataName can be found
346 * @tc.require: AR000GNT9D
347 */
348 HWTEST_F(BundleMgrClientSystemTest, GetResourceConfigFile_006, TestSize.Level1)
349 {
350 auto name = std::string("GetResourceConfigFile_006");
351 GTEST_LOG_(INFO) << name << " start";
352 std::string bundleFilePath = THIRD_PATH + "bundleClient1.hap";
353 std::string installMsg;
354 InstallBundle(bundleFilePath, InstallFlag::NORMAL, installMsg);
355 EXPECT_EQ(installMsg, "Success") << "install fail!" << bundleFilePath;
356
357 ExtensionAbilityInfo info;
358 std::vector<Metadata> &metadata = info.metadata;
359 Metadata data;
360 data.name = "ohos.extension.forms";
361 data.resource = "@profile:form_config";
362 metadata.emplace_back(data);
363 info.resourcePath = RESOURCE_PATH;
364 BundleMgrClient bundleMgrClient;
365 std::string metadataName = "ohos.extension.forms";
366 std::vector<std::string> profileInfo;
367 auto ret = bundleMgrClient.GetResConfigFile(info, metadataName, profileInfo);
368 EXPECT_TRUE(ret);
369 std::cout << profileInfo[0] << std::endl;
370
371 std::string uninstallMsg;
372 UninstallBundle(BUNDLE_NAME, uninstallMsg);
373 EXPECT_EQ(uninstallMsg, "Success") << "uninstall fail!" << bundleFilePath;
374 std::cout << "END GetResourceConfigFile_006" << std::endl;
375 GTEST_LOG_(INFO) << name << " end";
376 }
377
378 /**
379 * @tc.number: GetResourceConfigFile_007
380 * @tc.name: GetResConfigFile
381 * @tc.desc: Test the interface of GetResConfigFile
382 * 1. extensionAbilityInfo is valid and has multiple metadata
383 * 2. metadataName is not empty
384 * 3. metadataName can be found
385 * @tc.require: AR000GNT9D
386 */
387 HWTEST_F(BundleMgrClientSystemTest, GetResourceConfigFile_007, TestSize.Level1)
388 {
389 auto name = std::string("GetResourceConfigFile_007");
390 GTEST_LOG_(INFO) << name << " start";
391 std::string bundleFilePath = THIRD_PATH + "bundleClient1.hap";
392 std::string installMsg;
393 InstallBundle(bundleFilePath, InstallFlag::NORMAL, installMsg);
394 EXPECT_EQ(installMsg, "Success") << "install fail!" << bundleFilePath;
395
396 ExtensionAbilityInfo info;
397 std::vector<Metadata> &metadata = info.metadata;
398 Metadata data;
399 data.name = "ohos.extension.forms";
400 data.resource = "@profile:form_config";
401
402 Metadata data1;
403 data1.name = "ohos.extension.forms1";
404 data1.resource = "@profile:shortcuts_config";
405
406 metadata.emplace_back(data);
407 metadata.emplace_back(data1);
408 info.resourcePath = RESOURCE_PATH;
409 BundleMgrClient bundleMgrClient;
410 std::string metadataName = "ohos.extension.forms";
411 std::vector<std::string> profileInfo;
412 auto ret = bundleMgrClient.GetResConfigFile(info, metadataName, profileInfo);
413 EXPECT_TRUE(ret);
414 std::cout << profileInfo[0] << std::endl;
415
416 std::string uninstallMsg;
417 UninstallBundle(BUNDLE_NAME, uninstallMsg);
418 EXPECT_EQ(uninstallMsg, "Success") << "uninstall fail!" << bundleFilePath;
419 std::cout << "END GetResourceConfigFile_007" << std::endl;
420 GTEST_LOG_(INFO) << name << " end";
421 }
422
423 /**
424 * @tc.number: GetResourceConfigFile_008
425 * @tc.name: GetResConfigFile
426 * @tc.desc: Test the interface of GetResConfigFile
427 * 1. extensionAbilityInfo is valid and has multiple metadata
428 * 2. metadataName is not empty
429 * 3. metadataName can be found
430 * @tc.require: AR000GNT9D
431 */
432 HWTEST_F(BundleMgrClientSystemTest, GetResourceConfigFile_008, TestSize.Level1)
433 {
434 auto name = std::string("GetResourceConfigFile_008");
435 GTEST_LOG_(INFO) << name << " start";
436 std::string bundleFilePath = THIRD_PATH + "bundleClient1.hap";
437 std::string installMsg;
438 InstallBundle(bundleFilePath, InstallFlag::NORMAL, installMsg);
439 EXPECT_EQ(installMsg, "Success") << "install fail!" << bundleFilePath;
440
441 ExtensionAbilityInfo info;
442 std::vector<Metadata> &metadata = info.metadata;
443 Metadata data;
444 data.name = "ohos.extension.forms";
445 data.resource = "@profile:form_config";
446
447 Metadata data1;
448 data1.name = "ohos.extension.forms";
449 data1.resource = "@profile:shortcuts_config";
450
451 metadata.emplace_back(data);
452 metadata.emplace_back(data1);
453 info.resourcePath = RESOURCE_PATH;
454 BundleMgrClient bundleMgrClient;
455 std::string metadataName = "ohos.extension.forms";
456 std::vector<std::string> profileInfo;
457 auto ret = bundleMgrClient.GetResConfigFile(info, metadataName, profileInfo);
458 EXPECT_TRUE(ret);
459 EXPECT_EQ(profileInfo.size(), 2);
460 std::cout << profileInfo[0] << std::endl;
461 std::cout << profileInfo[1] << std::endl;
462
463 std::string uninstallMsg;
464 UninstallBundle(BUNDLE_NAME, uninstallMsg);
465 EXPECT_EQ(uninstallMsg, "Success") << "uninstall fail!" << bundleFilePath;
466 std::cout << "END GetResourceConfigFile_008" << std::endl;
467 GTEST_LOG_(INFO) << name << " end";
468 }
469
470 /**
471 * @tc.number: GetResourceConfigFile_009
472 * @tc.name: GetResConfigFile
473 * @tc.desc: Test the interface of GetResConfigFile
474 * 1. metadataName is empty
475 * 2. extensionAbilityInfo has only one metadata
476 * @tc.require: AR000GNT9D
477 */
478 HWTEST_F(BundleMgrClientSystemTest, GetResourceConfigFile_009, TestSize.Level1)
479 {
480 auto name = std::string("GetResourceConfigFile_009");
481 GTEST_LOG_(INFO) << name << " start";
482 std::string bundleFilePath = THIRD_PATH + "bundleClient1.hap";
483 std::string installMsg;
484 InstallBundle(bundleFilePath, InstallFlag::NORMAL, installMsg);
485 EXPECT_EQ(installMsg, "Success") << "install fail!" << bundleFilePath;
486
487 ExtensionAbilityInfo info;
488 std::vector<Metadata> &metadata = info.metadata;
489 Metadata data;
490 data.name = "ohos.extension.forms";
491 data.resource = "@profile:form_config";
492 metadata.emplace_back(data);
493 info.resourcePath = RESOURCE_PATH;
494 BundleMgrClient bundleMgrClient;
495 std::string metadataName;
496 std::vector<std::string> profileInfo;
497 auto ret = bundleMgrClient.GetResConfigFile(info, metadataName, profileInfo);
498 EXPECT_TRUE(ret);
499 std::cout << profileInfo[0] << std::endl;
500
501 std::string uninstallMsg;
502 UninstallBundle(BUNDLE_NAME, uninstallMsg);
503 EXPECT_EQ(uninstallMsg, "Success") << "uninstall fail!" << bundleFilePath;
504 std::cout << "END GetResourceConfigFile_009" << std::endl;
505 GTEST_LOG_(INFO) << name << " end";
506 }
507
508 /**
509 * @tc.number: GetResourceConfigFile_010
510 * @tc.name: GetResConfigFile
511 * @tc.desc: Test the interface of GetResConfigFile
512 * 1. metadataName is empty
513 * 2. extensionAbilityInfo has only multiple metadata
514 * @tc.require: AR000GNT9D
515 */
516 HWTEST_F(BundleMgrClientSystemTest, GetResourceConfigFile_010, TestSize.Level1)
517 {
518 auto name = std::string("GetResourceConfigFile_010");
519 GTEST_LOG_(INFO) << name << " start";
520 std::string bundleFilePath = THIRD_PATH + "bundleClient1.hap";
521 std::string installMsg;
522 InstallBundle(bundleFilePath, InstallFlag::NORMAL, installMsg);
523 EXPECT_EQ(installMsg, "Success") << "install fail!" << bundleFilePath;
524
525 ExtensionAbilityInfo info;
526 std::vector<Metadata> &metadata = info.metadata;
527 Metadata data;
528 data.name = "ohos.extension.forms";
529 data.resource = "@profile:form_config";
530
531 Metadata data1;
532 data1.name = "ohos.extension.forms1";
533 data1.resource = "@profile:shortcuts_config";
534
535 metadata.emplace_back(data);
536 metadata.emplace_back(data1);
537 info.resourcePath = RESOURCE_PATH;
538 BundleMgrClient bundleMgrClient;
539 std::string metadataName;
540 std::vector<std::string> profileInfo;
541 auto ret = bundleMgrClient.GetResConfigFile(info, metadataName, profileInfo);
542 EXPECT_TRUE(ret);
543 EXPECT_EQ(profileInfo.size(), 2);
544 std::cout << profileInfo[0] << std::endl;
545 std::cout << profileInfo[1] << std::endl;
546 std::string uninstallMsg;
547 UninstallBundle(BUNDLE_NAME, uninstallMsg);
548 EXPECT_EQ(uninstallMsg, "Success") << "uninstall fail!" << bundleFilePath;
549 std::cout << "END GetResourceConfigFile_010" << std::endl;
550 GTEST_LOG_(INFO) << name << " end";
551 }
552
553 /**
554 * @tc.number: GetResourceConfigFile_011
555 * @tc.name: GetResConfigFile
556 * @tc.desc: Test the interface of GetResConfigFile
557 * 1. profile's suffix is not .json
558 * @tc.require: AR000GNT9D
559 */
560 HWTEST_F(BundleMgrClientSystemTest, GetResourceConfigFile_011, TestSize.Level1)
561 {
562 auto name = std::string("GetResourceConfigFile_011");
563 GTEST_LOG_(INFO) << name << " start";
564 std::string bundleFilePath = THIRD_PATH + "bundleClient1.hap";
565 std::string installMsg;
566 InstallBundle(bundleFilePath, InstallFlag::NORMAL, installMsg);
567 EXPECT_EQ(installMsg, "Success") << "install fail!" << bundleFilePath;
568
569 ExtensionAbilityInfo info;
570 std::vector<Metadata> &metadata = info.metadata;
571 Metadata data;
572 data.name = "ohos.extension.forms";
573 data.resource = "@profile:form_config1";
574 metadata.emplace_back(data);
575 info.resourcePath = RESOURCE_PATH;
576 BundleMgrClient bundleMgrClient;
577 std::string metadataName = "ohos.extension.forms";
578 std::vector<std::string> profileInfo;
579 auto ret = bundleMgrClient.GetResConfigFile(info, metadataName, profileInfo);
580 EXPECT_FALSE(ret);
581
582 std::string uninstallMsg;
583 UninstallBundle(BUNDLE_NAME, uninstallMsg);
584 EXPECT_EQ(uninstallMsg, "Success") << "uninstall fail!" << bundleFilePath;
585 std::cout << "END GetResourceConfigFile_011" << std::endl;
586 GTEST_LOG_(INFO) << name << " end";
587 }
588
589 /**
590 * @tc.number: GetResourceConfigFile_012
591 * @tc.name: GetResConfigFile
592 * @tc.desc: Test the interface of GetResConfigFile
593 * 1. profile is empty file
594 * @tc.require: AR000GNT9D
595 */
596 HWTEST_F(BundleMgrClientSystemTest, GetResourceConfigFile_012, TestSize.Level1)
597 {
598 auto name = std::string("GetResourceConfigFile_012");
599 GTEST_LOG_(INFO) << name << " start";
600 std::string bundleFilePath = THIRD_PATH + "bundleClient1.hap";
601 std::string installMsg;
602 InstallBundle(bundleFilePath, InstallFlag::NORMAL, installMsg);
603 EXPECT_EQ(installMsg, "Success") << "install fail!" << bundleFilePath;
604
605 ExtensionAbilityInfo info;
606 std::vector<Metadata> &metadata = info.metadata;
607 Metadata data;
608 data.name = "ohos.extension.forms";
609 data.resource = "@profile:form_config2";
610 metadata.emplace_back(data);
611 info.resourcePath = RESOURCE_PATH;
612 BundleMgrClient bundleMgrClient;
613 std::string metadataName = "ohos.extension.forms";
614 std::vector<std::string> profileInfo;
615 auto ret = bundleMgrClient.GetResConfigFile(info, metadataName, profileInfo);
616 EXPECT_FALSE(ret);
617
618 std::string uninstallMsg;
619 UninstallBundle(BUNDLE_NAME, uninstallMsg);
620 EXPECT_EQ(uninstallMsg, "Success") << "uninstall fail!" << bundleFilePath;
621 std::cout << "END GetResourceConfigFile_012" << std::endl;
622 GTEST_LOG_(INFO) << name << " end";
623 }
624
625 /**
626 * @tc.number: GetResourceConfigFile_013
627 * @tc.name: GetResConfigFile
628 * @tc.desc: Test the interface of GetResConfigFile
629 * 1. profile is not json-format
630 * @tc.require: AR000GNT9D
631 */
632 HWTEST_F(BundleMgrClientSystemTest, GetResourceConfigFile_013, TestSize.Level1)
633 {
634 auto name = std::string("GetResourceConfigFile_013");
635 GTEST_LOG_(INFO) << name << " start";
636 std::string bundleFilePath = THIRD_PATH + "bundleClient1.hap";
637 std::string installMsg;
638 InstallBundle(bundleFilePath, InstallFlag::NORMAL, installMsg);
639 EXPECT_EQ(installMsg, "Success") << "install fail!" << bundleFilePath;
640
641 ExtensionAbilityInfo info;
642 std::vector<Metadata> &metadata = info.metadata;
643 Metadata data;
644 data.name = "ohos.extension.forms";
645 data.resource = "@profile:form_config3";
646 metadata.emplace_back(data);
647 info.resourcePath = RESOURCE_PATH;
648 BundleMgrClient bundleMgrClient;
649 std::string metadataName = "ohos.extension.forms";
650 std::vector<std::string> profileInfo;
651 auto ret = bundleMgrClient.GetResConfigFile(info, metadataName, profileInfo);
652 EXPECT_FALSE(ret);
653
654 std::string uninstallMsg;
655 UninstallBundle(BUNDLE_NAME, uninstallMsg);
656 EXPECT_EQ(uninstallMsg, "Success") << "uninstall fail!" << bundleFilePath;
657 std::cout << "END GetResourceConfigFile_013" << std::endl;
658 GTEST_LOG_(INFO) << name << " end";
659 }
660
661 /**
662 * @tc.number: GetResourceConfigFile_014
663 * @tc.name: GetResConfigFile
664 * @tc.desc: Test the interface of GetResConfigFile
665 * 1. profiles both have json-format file and non-json-format file
666 * @tc.require: AR000GNT9D
667 */
668 HWTEST_F(BundleMgrClientSystemTest, GetResourceConfigFile_014, TestSize.Level1)
669 {
670 auto name = std::string("GetResourceConfigFile_014");
671 GTEST_LOG_(INFO) << name << " start";
672 std::string bundleFilePath = THIRD_PATH + "bundleClient1.hap";
673 std::string installMsg;
674 InstallBundle(bundleFilePath, InstallFlag::NORMAL, installMsg);
675 EXPECT_EQ(installMsg, "Success") << "install fail!" << bundleFilePath;
676
677 ExtensionAbilityInfo info;
678 std::vector<Metadata> &metadata = info.metadata;
679 Metadata data;
680 data.name = "ohos.extension.forms";
681 data.resource = "@profile:form_config";
682 Metadata data1;
683 data.name = "ohos.extension.forms";
684 data.resource = "@profile:form_config1";
685
686 metadata.emplace_back(data);
687 info.resourcePath = RESOURCE_PATH;
688 BundleMgrClient bundleMgrClient;
689 std::string metadataName = "ohos.extension.forms";
690 std::vector<std::string> profileInfo;
691 auto ret = bundleMgrClient.GetResConfigFile(info, metadataName, profileInfo);
692 EXPECT_FALSE(ret);
693
694 std::string uninstallMsg;
695 UninstallBundle(BUNDLE_NAME, uninstallMsg);
696 EXPECT_EQ(uninstallMsg, "Success") << "uninstall fail!" << bundleFilePath;
697 std::cout << "END GetResourceConfigFile_014" << std::endl;
698 GTEST_LOG_(INFO) << name << " end";
699 }
700
701 /**
702 * @tc.number: GetResourceConfigFile_015
703 * @tc.name: GetResConfigFile
704 * @tc.desc: Test the interface of GetResConfigFile
705 * 1. AbilityInfo is invalid, resourcePath is empty
706 * @tc.require: AR000GNT9D
707 */
708 HWTEST_F(BundleMgrClientSystemTest, GetResourceConfigFile_015, TestSize.Level1)
709 {
710 auto name = std::string("GetResourceConfigFile_015");
711 GTEST_LOG_(INFO) << name << " start";
712 AbilityInfo info;
713 std::vector<Metadata> &metadata = info.metadata;
714 Metadata data;
715 data.name = "ohos.extension.forms";
716 data.resource = "@profile:form_config";
717 metadata.emplace_back(data);
718 info.resourcePath = "";
719 BundleMgrClient bundleMgrClient;
720 std::string metadataName = "ohos.extension.forms";
721 std::vector<std::string> profileInfo;
722 auto ret = bundleMgrClient.GetResConfigFile(info, metadataName, profileInfo);
723 EXPECT_FALSE(ret);
724 GTEST_LOG_(INFO) << name << " end";
725 }
726
727 /**
728 * @tc.number: GetResourceConfigFile_016
729 * @tc.name: GetResConfigFile
730 * @tc.desc: Test the interface of GetResConfigFile
731 * 1. AbilityInfo is invalid, resourcePath is not existed
732 * @tc.require: AR000GNT9D
733 */
734 HWTEST_F(BundleMgrClientSystemTest, GetResourceConfigFile_016, TestSize.Level1)
735 {
736 auto name = std::string("GetResourceConfigFile_016");
737 GTEST_LOG_(INFO) << name << " start";
738 AbilityInfo info;
739 std::vector<Metadata> &metadata = info.metadata;
740 Metadata data;
741 data.name = "ohos.extension.forms";
742 data.resource = "@profile:form_config";
743 metadata.emplace_back(data);
744 info.resourcePath = "resourcePath";
745 BundleMgrClient bundleMgrClient;
746 std::string metadataName = "ohos.extension.forms";
747 std::vector<std::string> profileInfo;
748 auto ret = bundleMgrClient.GetResConfigFile(info, metadataName, profileInfo);
749 EXPECT_FALSE(ret);
750 GTEST_LOG_(INFO) << name << " end";
751 }
752
753 /**
754 * @tc.number: GetResourceConfigFile_017
755 * @tc.name: GetResConfigFile
756 * @tc.desc: Test the interface of GetResConfigFile
757 * 1. AbilityInfo is invalid, metadata is not existed
758 * @tc.require: AR000GNT9D
759 */
760 HWTEST_F(BundleMgrClientSystemTest, GetResourceConfigFile_017, TestSize.Level1)
761 {
762 auto name = std::string("GetResourceConfigFile_017");
763 GTEST_LOG_(INFO) << name << " start";
764 AbilityInfo info;
765 std::vector<Metadata> &metadata = info.metadata;
766 Metadata data;
767 data.name = "extensionName";
768 data.resource = "@profile:form_config";
769 metadata.emplace_back(data);
770 info.resourcePath = RESOURCE_PATH;
771 BundleMgrClient bundleMgrClient;
772 std::string metadataName = "ohos.extension.forms";
773 std::vector<std::string> profileInfo;
774 auto ret = bundleMgrClient.GetResConfigFile(info, metadataName, profileInfo);
775 EXPECT_FALSE(ret);
776 GTEST_LOG_(INFO) << name << " end";
777 }
778
779 /**
780 * @tc.number: GetResourceConfigFile_018
781 * @tc.name: GetResConfigFile
782 * @tc.desc: Test the interface of GetResConfigFile
783 * 1. AbilityInfo is valid
784 * 2. metadataName is not empty
785 * 3. AbilityInfo does not have metadata
786 * @tc.require: AR000GNT9D
787 */
788 HWTEST_F(BundleMgrClientSystemTest, GetResourceConfigFile_018, TestSize.Level1)
789 {
790 auto name = std::string("GetResourceConfigFile_018");
791 GTEST_LOG_(INFO) << name << " start";
792 AbilityInfo info;
793 info.resourcePath = RESOURCE_PATH;
794 BundleMgrClient bundleMgrClient;
795 std::string metadataName = "ohos.extension.forms";
796 std::vector<std::string> profileInfo;
797 auto ret = bundleMgrClient.GetResConfigFile(info, metadataName, profileInfo);
798 EXPECT_FALSE(ret);
799 GTEST_LOG_(INFO) << name << " end";
800 }
801
802 /**
803 * @tc.number: GetResourceConfigFile_019
804 * @tc.name: GetResConfigFile
805 * @tc.desc: Test the interface of GetResConfigFile
806 * 1. AbilityInfo is valid
807 * 2. metadataName is not empty
808 * 3. metadataName cannot be found
809 * @tc.require: AR000GNT9D
810 */
811 HWTEST_F(BundleMgrClientSystemTest, GetResourceConfigFile_019, TestSize.Level1)
812 {
813 auto name = std::string("GetResourceConfigFile_019");
814 GTEST_LOG_(INFO) << name << " start";
815 AbilityInfo info;
816 std::vector<Metadata> &metadata = info.metadata;
817 Metadata data;
818 data.name = "ohos.extension.forms";
819 data.resource = "@profile:form_config";
820 metadata.emplace_back(data);
821 info.resourcePath = RESOURCE_PATH;
822 BundleMgrClient bundleMgrClient;
823 std::string metadataName = "ohos.extension.forms1";
824 std::vector<std::string> profileInfo;
825 auto ret = bundleMgrClient.GetResConfigFile(info, metadataName, profileInfo);
826 EXPECT_FALSE(ret);
827 GTEST_LOG_(INFO) << name << " end";
828 }
829
830 /**
831 * @tc.number: GetResourceConfigFile_020
832 * @tc.name: GetResConfigFile
833 * @tc.desc: Test the interface of GetResConfigFile
834 * 1. AbilityInfo is valid and has only one metadata
835 * 2. metadataName is not empty
836 * 3. metadataName can be found
837 * @tc.require: AR000GNT9D
838 */
839 HWTEST_F(BundleMgrClientSystemTest, GetResourceConfigFile_020, TestSize.Level1)
840 {
841 auto name = std::string("GetResourceConfigFile_020");
842 GTEST_LOG_(INFO) << name << " start";
843 std::string bundleFilePath = THIRD_PATH + "bundleClient1.hap";
844 std::string installMsg;
845 InstallBundle(bundleFilePath, InstallFlag::NORMAL, installMsg);
846 EXPECT_EQ(installMsg, "Success") << "install fail!" << bundleFilePath;
847
848 AbilityInfo info;
849 std::vector<Metadata> &metadata = info.metadata;
850 Metadata data;
851 data.name = "ohos.extension.forms";
852 data.resource = "@profile:form_config";
853 metadata.emplace_back(data);
854 info.resourcePath = RESOURCE_PATH;
855 BundleMgrClient bundleMgrClient;
856 std::string metadataName = "ohos.extension.forms";
857 std::vector<std::string> profileInfo;
858 auto ret = bundleMgrClient.GetResConfigFile(info, metadataName, profileInfo);
859 EXPECT_TRUE(ret);
860 std::cout << profileInfo[0] << std::endl;
861
862 std::string uninstallMsg;
863 UninstallBundle(BUNDLE_NAME, uninstallMsg);
864 EXPECT_EQ(uninstallMsg, "Success") << "uninstall fail!" << bundleFilePath;
865 std::cout << "END GetResourceConfigFile_020" << std::endl;
866 GTEST_LOG_(INFO) << name << " end";
867 }
868
869 /**
870 * @tc.number: GetResourceConfigFile_021
871 * @tc.name: GetResConfigFile
872 * @tc.desc: Test the interface of GetResConfigFile
873 * 1. AbilityInfo is valid and has multiple metadata
874 * 2. metadataName is not empty
875 * 3. metadataName can be found
876 * @tc.require: AR000GNT9D
877 */
878 HWTEST_F(BundleMgrClientSystemTest, GetResourceConfigFile_021, TestSize.Level1)
879 {
880 auto name = std::string("GetResourceConfigFile_021");
881 GTEST_LOG_(INFO) << name << " start";
882 std::string bundleFilePath = THIRD_PATH + "bundleClient1.hap";
883 std::string installMsg;
884 InstallBundle(bundleFilePath, InstallFlag::NORMAL, installMsg);
885 EXPECT_EQ(installMsg, "Success") << "install fail!" << bundleFilePath;
886
887 AbilityInfo info;
888 std::vector<Metadata> &metadata = info.metadata;
889 Metadata data;
890 data.name = "ohos.extension.forms";
891 data.resource = "@profile:form_config";
892
893 Metadata data1;
894 data1.name = "ohos.extension.forms1";
895 data1.resource = "@profile:shortcuts_config";
896
897 metadata.emplace_back(data);
898 metadata.emplace_back(data1);
899 info.resourcePath = RESOURCE_PATH;
900 BundleMgrClient bundleMgrClient;
901 std::string metadataName = "ohos.extension.forms";
902 std::vector<std::string> profileInfo;
903 auto ret = bundleMgrClient.GetResConfigFile(info, metadataName, profileInfo);
904 EXPECT_TRUE(ret);
905 std::cout << profileInfo[0] << std::endl;
906
907 std::string uninstallMsg;
908 UninstallBundle(BUNDLE_NAME, uninstallMsg);
909 EXPECT_EQ(uninstallMsg, "Success") << "uninstall fail!" << bundleFilePath;
910 std::cout << "END GetResourceConfigFile_021" << std::endl;
911 GTEST_LOG_(INFO) << name << " end";
912 }
913
914 /**
915 * @tc.number: GetResourceConfigFile_022
916 * @tc.name: GetResConfigFile
917 * @tc.desc: Test the interface of GetResConfigFile
918 * 1. AbilityInfo is valid and has multiple metadata
919 * 2. metadataName is not empty
920 * 3. metadataName can be found
921 * @tc.require: AR000GNT9D
922 */
923 HWTEST_F(BundleMgrClientSystemTest, GetResourceConfigFile_022, TestSize.Level1)
924 {
925 auto name = std::string("GetResourceConfigFile_022");
926 GTEST_LOG_(INFO) << name << " start";
927 std::string bundleFilePath = THIRD_PATH + "bundleClient1.hap";
928 std::string installMsg;
929 InstallBundle(bundleFilePath, InstallFlag::NORMAL, installMsg);
930 EXPECT_EQ(installMsg, "Success") << "install fail!" << bundleFilePath;
931
932 AbilityInfo info;
933 std::vector<Metadata> &metadata = info.metadata;
934 Metadata data;
935 data.name = "ohos.extension.forms";
936 data.resource = "@profile:form_config";
937
938 Metadata data1;
939 data1.name = "ohos.extension.forms";
940 data1.resource = "@profile:shortcuts_config";
941
942 metadata.emplace_back(data);
943 metadata.emplace_back(data1);
944 info.resourcePath = RESOURCE_PATH;
945 BundleMgrClient bundleMgrClient;
946 std::string metadataName = "ohos.extension.forms";
947 std::vector<std::string> profileInfo;
948 auto ret = bundleMgrClient.GetResConfigFile(info, metadataName, profileInfo);
949 EXPECT_TRUE(ret);
950 EXPECT_EQ(profileInfo.size(), 2);
951 std::cout << profileInfo[0] << std::endl;
952 std::cout << profileInfo[1] << std::endl;
953
954 std::string uninstallMsg;
955 UninstallBundle(BUNDLE_NAME, uninstallMsg);
956 EXPECT_EQ(uninstallMsg, "Success") << "uninstall fail!" << bundleFilePath;
957 std::cout << "END GetResourceConfigFile_022" << std::endl;
958 GTEST_LOG_(INFO) << name << " end";
959 }
960
961 /**
962 * @tc.number: GetResourceConfigFile_023
963 * @tc.name: GetResConfigFile
964 * @tc.desc: Test the interface of GetResConfigFile
965 * 1. metadataName is empty
966 * 2. AbilityInfo has only one metadata
967 * @tc.require: AR000GNT9D
968 */
969 HWTEST_F(BundleMgrClientSystemTest, GetResourceConfigFile_023, TestSize.Level1)
970 {
971 auto name = std::string("GetResourceConfigFile_023");
972 GTEST_LOG_(INFO) << name << " start";
973 std::string bundleFilePath = THIRD_PATH + "bundleClient1.hap";
974 std::string installMsg;
975 InstallBundle(bundleFilePath, InstallFlag::NORMAL, installMsg);
976 EXPECT_EQ(installMsg, "Success") << "install fail!" << bundleFilePath;
977
978 AbilityInfo info;
979 std::vector<Metadata> &metadata = info.metadata;
980 Metadata data;
981 data.name = "ohos.extension.forms";
982 data.resource = "@profile:form_config";
983 metadata.emplace_back(data);
984 info.resourcePath = RESOURCE_PATH;
985 BundleMgrClient bundleMgrClient;
986 std::string metadataName;
987 std::vector<std::string> profileInfo;
988 auto ret = bundleMgrClient.GetResConfigFile(info, metadataName, profileInfo);
989 EXPECT_TRUE(ret);
990 std::cout << profileInfo[0] << std::endl;
991
992 std::string uninstallMsg;
993 UninstallBundle(BUNDLE_NAME, uninstallMsg);
994 EXPECT_EQ(uninstallMsg, "Success") << "uninstall fail!" << bundleFilePath;
995 std::cout << "END GetResourceConfigFile_023" << std::endl;
996 GTEST_LOG_(INFO) << name << " end";
997 }
998
999 /**
1000 * @tc.number: GetResourceConfigFile_024
1001 * @tc.name: GetResConfigFile
1002 * @tc.desc: Test the interface of GetResConfigFile
1003 * 1. metadataName is empty
1004 * 2. AbilityInfo has only multiple metadata
1005 * @tc.require: AR000GNT9D
1006 */
1007 HWTEST_F(BundleMgrClientSystemTest, GetResourceConfigFile_024, TestSize.Level1)
1008 {
1009 auto name = std::string("GetResourceConfigFile_024");
1010 GTEST_LOG_(INFO) << name << " start";
1011 std::string bundleFilePath = THIRD_PATH + "bundleClient1.hap";
1012 std::string installMsg;
1013 InstallBundle(bundleFilePath, InstallFlag::NORMAL, installMsg);
1014 EXPECT_EQ(installMsg, "Success") << "install fail!" << bundleFilePath;
1015
1016 AbilityInfo info;
1017 std::vector<Metadata> &metadata = info.metadata;
1018 Metadata data;
1019 data.name = "ohos.extension.forms";
1020 data.resource = "@profile:form_config";
1021
1022 Metadata data1;
1023 data1.name = "ohos.extension.forms1";
1024 data1.resource = "@profile:shortcuts_config";
1025
1026 metadata.emplace_back(data);
1027 metadata.emplace_back(data1);
1028 info.resourcePath = RESOURCE_PATH;
1029 BundleMgrClient bundleMgrClient;
1030 std::string metadataName;
1031 std::vector<std::string> profileInfo;
1032 auto ret = bundleMgrClient.GetResConfigFile(info, metadataName, profileInfo);
1033 EXPECT_TRUE(ret);
1034 EXPECT_EQ(profileInfo.size(), 2);
1035 std::cout << profileInfo[0] << std::endl;
1036 std::cout << profileInfo[1] << std::endl;
1037 std::string uninstallMsg;
1038 UninstallBundle(BUNDLE_NAME, uninstallMsg);
1039 EXPECT_EQ(uninstallMsg, "Success") << "uninstall fail!" << bundleFilePath;
1040 std::cout << "END GetResourceConfigFile_024" << std::endl;
1041 GTEST_LOG_(INFO) << name << " end";
1042 }
1043
1044 /**
1045 * @tc.number: GetResourceConfigFile_025
1046 * @tc.name: GetResConfigFile
1047 * @tc.desc: Test the interface of GetResConfigFile
1048 * 1. profile's suffix is not .json
1049 * @tc.require: AR000GNT9D
1050 */
1051 HWTEST_F(BundleMgrClientSystemTest, GetResourceConfigFile_025, TestSize.Level1)
1052 {
1053 auto name = std::string("GetResourceConfigFile_025");
1054 GTEST_LOG_(INFO) << name << " start";
1055 std::string bundleFilePath = THIRD_PATH + "bundleClient1.hap";
1056 std::string installMsg;
1057 InstallBundle(bundleFilePath, InstallFlag::NORMAL, installMsg);
1058 EXPECT_EQ(installMsg, "Success") << "install fail!" << bundleFilePath;
1059
1060 AbilityInfo info;
1061 std::vector<Metadata> &metadata = info.metadata;
1062 Metadata data;
1063 data.name = "ohos.extension.forms";
1064 data.resource = "@profile:form_config1";
1065 metadata.emplace_back(data);
1066 info.resourcePath = RESOURCE_PATH;
1067 BundleMgrClient bundleMgrClient;
1068 std::string metadataName = "ohos.extension.forms";
1069 std::vector<std::string> profileInfo;
1070 auto ret = bundleMgrClient.GetResConfigFile(info, metadataName, profileInfo);
1071 EXPECT_FALSE(ret);
1072
1073 std::string uninstallMsg;
1074 UninstallBundle(BUNDLE_NAME, uninstallMsg);
1075 EXPECT_EQ(uninstallMsg, "Success") << "uninstall fail!" << bundleFilePath;
1076 std::cout << "END GetResourceConfigFile_025" << std::endl;
1077 GTEST_LOG_(INFO) << name << " end";
1078 }
1079
1080 /**
1081 * @tc.number: GetResourceConfigFile_026
1082 * @tc.name: GetResConfigFile
1083 * @tc.desc: Test the interface of GetResConfigFile
1084 * 1. profile is empty file
1085 * @tc.require: AR000GNT9D
1086 */
1087 HWTEST_F(BundleMgrClientSystemTest, GetResourceConfigFile_026, TestSize.Level1)
1088 {
1089 auto name = std::string("GetResourceConfigFile_026");
1090 GTEST_LOG_(INFO) << name << " start";
1091 std::string bundleFilePath = THIRD_PATH + "bundleClient1.hap";
1092 std::string installMsg;
1093 InstallBundle(bundleFilePath, InstallFlag::NORMAL, installMsg);
1094 EXPECT_EQ(installMsg, "Success") << "install fail!" << bundleFilePath;
1095
1096 AbilityInfo info;
1097 std::vector<Metadata> &metadata = info.metadata;
1098 Metadata data;
1099 data.name = "ohos.extension.forms";
1100 data.resource = "@profile:form_config2";
1101 metadata.emplace_back(data);
1102 info.resourcePath = RESOURCE_PATH;
1103 BundleMgrClient bundleMgrClient;
1104 std::string metadataName = "ohos.extension.forms";
1105 std::vector<std::string> profileInfo;
1106 auto ret = bundleMgrClient.GetResConfigFile(info, metadataName, profileInfo);
1107 EXPECT_FALSE(ret);
1108
1109 std::string uninstallMsg;
1110 UninstallBundle(BUNDLE_NAME, uninstallMsg);
1111 EXPECT_EQ(uninstallMsg, "Success") << "uninstall fail!" << bundleFilePath;
1112 std::cout << "END GetResourceConfigFile_026" << std::endl;
1113 GTEST_LOG_(INFO) << name << " end";
1114 }
1115
1116 /**
1117 * @tc.number: GetResourceConfigFile_027
1118 * @tc.name: GetResConfigFile
1119 * @tc.desc: Test the interface of GetResConfigFile
1120 * 1. profile is not json-format
1121 * @tc.require: AR000GNT9D
1122 */
1123 HWTEST_F(BundleMgrClientSystemTest, GetResourceConfigFile_027, TestSize.Level1)
1124 {
1125 auto name = std::string("GetResourceConfigFile_027");
1126 GTEST_LOG_(INFO) << name << " start";
1127 std::string bundleFilePath = THIRD_PATH + "bundleClient1.hap";
1128 std::string installMsg;
1129 InstallBundle(bundleFilePath, InstallFlag::NORMAL, installMsg);
1130 EXPECT_EQ(installMsg, "Success") << "install fail!" << bundleFilePath;
1131
1132 AbilityInfo info;
1133 std::vector<Metadata> &metadata = info.metadata;
1134 Metadata data;
1135 data.name = "ohos.extension.forms";
1136 data.resource = "@profile:form_config3";
1137 metadata.emplace_back(data);
1138 info.resourcePath = RESOURCE_PATH;
1139 BundleMgrClient bundleMgrClient;
1140 std::string metadataName = "ohos.extension.forms";
1141 std::vector<std::string> profileInfo;
1142 auto ret = bundleMgrClient.GetResConfigFile(info, metadataName, profileInfo);
1143 EXPECT_FALSE(ret);
1144
1145 std::string uninstallMsg;
1146 UninstallBundle(BUNDLE_NAME, uninstallMsg);
1147 EXPECT_EQ(uninstallMsg, "Success") << "uninstall fail!" << bundleFilePath;
1148 std::cout << "END GetResourceConfigFile_027" << std::endl;
1149 GTEST_LOG_(INFO) << name << " end";
1150 }
1151
1152 /**
1153 * @tc.number: GetResourceConfigFile_028
1154 * @tc.name: GetResConfigFile
1155 * @tc.desc: Test the interface of GetResConfigFile
1156 * 1. profiles both have json-format file and non-json-format file
1157 * @tc.require: AR000GNT9D
1158 */
1159 HWTEST_F(BundleMgrClientSystemTest, GetResourceConfigFile_028, TestSize.Level1)
1160 {
1161 auto name = std::string("GetResourceConfigFile_028");
1162 GTEST_LOG_(INFO) << name << " start";
1163 std::string bundleFilePath = THIRD_PATH + "bundleClient1.hap";
1164 std::string installMsg;
1165 InstallBundle(bundleFilePath, InstallFlag::NORMAL, installMsg);
1166 EXPECT_EQ(installMsg, "Success") << "install fail!" << bundleFilePath;
1167
1168 AbilityInfo info;
1169 std::vector<Metadata> &metadata = info.metadata;
1170 Metadata data;
1171 data.name = "ohos.extension.forms";
1172 data.resource = "@profile:form_config";
1173 Metadata data1;
1174 data.name = "ohos.extension.forms";
1175 data.resource = "@profile:form_config1";
1176
1177 metadata.emplace_back(data);
1178 info.resourcePath = RESOURCE_PATH;
1179 BundleMgrClient bundleMgrClient;
1180 std::string metadataName = "ohos.extension.forms";
1181 std::vector<std::string> profileInfo;
1182 auto ret = bundleMgrClient.GetResConfigFile(info, metadataName, profileInfo);
1183 EXPECT_FALSE(ret);
1184
1185 std::string uninstallMsg;
1186 UninstallBundle(BUNDLE_NAME, uninstallMsg);
1187 EXPECT_EQ(uninstallMsg, "Success") << "uninstall fail!" << bundleFilePath;
1188 std::cout << "END GetResourceConfigFile_028" << std::endl;
1189 GTEST_LOG_(INFO) << name << " end";
1190 }
1191
1192 /**
1193 * @tc.number: GetResourceConfigFile_029
1194 * @tc.name: GetResConfigFile
1195 * @tc.desc: Test the interface of GetResConfigFile
1196 * 1. HapModuleInfo is invalid, resourcePath is empty
1197 * @tc.require: AR000GNT9D
1198 */
1199 HWTEST_F(BundleMgrClientSystemTest, GetResourceConfigFile_029, TestSize.Level1)
1200 {
1201 auto name = std::string("GetResourceConfigFile_029");
1202 GTEST_LOG_(INFO) << name << " start";
1203 HapModuleInfo info;
1204 std::vector<Metadata> &metadata = info.metadata;
1205 Metadata data;
1206 data.name = "ohos.extension.forms";
1207 data.resource = "@profile:form_config";
1208 metadata.emplace_back(data);
1209 info.resourcePath = "";
1210 BundleMgrClient bundleMgrClient;
1211 std::string metadataName = "ohos.extension.forms";
1212 std::vector<std::string> profileInfo;
1213 auto ret = bundleMgrClient.GetResConfigFile(info, metadataName, profileInfo);
1214 EXPECT_FALSE(ret);
1215 GTEST_LOG_(INFO) << name << " end";
1216 }
1217
1218 /**
1219 * @tc.number: GetResourceConfigFile_030
1220 * @tc.name: GetResConfigFile
1221 * @tc.desc: Test the interface of GetResConfigFile
1222 * 1. HapModuleInfo is invalid, resourcePath is not existed
1223 * @tc.require: AR000GNT9D
1224 */
1225 HWTEST_F(BundleMgrClientSystemTest, GetResourceConfigFile_030, TestSize.Level1)
1226 {
1227 auto name = std::string("GetResourceConfigFile_030");
1228 GTEST_LOG_(INFO) << name << " start";
1229 HapModuleInfo info;
1230 std::vector<Metadata> &metadata = info.metadata;
1231 Metadata data;
1232 data.name = "ohos.extension.forms";
1233 data.resource = "@profile:form_config";
1234 metadata.emplace_back(data);
1235 info.resourcePath = "resourcePath";
1236 BundleMgrClient bundleMgrClient;
1237 std::string metadataName = "ohos.extension.forms";
1238 std::vector<std::string> profileInfo;
1239 auto ret = bundleMgrClient.GetResConfigFile(info, metadataName, profileInfo);
1240 EXPECT_FALSE(ret);
1241 GTEST_LOG_(INFO) << name << " end";
1242 }
1243
1244 /**
1245 * @tc.number: GetResourceConfigFile_031
1246 * @tc.name: GetResConfigFile
1247 * @tc.desc: Test the interface of GetResConfigFile
1248 * 1. HapModuleInfo is invalid, metadata is not existed
1249 * @tc.require: AR000GNT9D
1250 */
1251 HWTEST_F(BundleMgrClientSystemTest, GetResourceConfigFile_031, TestSize.Level1)
1252 {
1253 auto name = std::string("GetResourceConfigFile_031");
1254 GTEST_LOG_(INFO) << name << " start";
1255 HapModuleInfo info;
1256 std::vector<Metadata> &metadata = info.metadata;
1257 Metadata data;
1258 data.name = "extensionName";
1259 data.resource = "@profile:form_config";
1260 metadata.emplace_back(data);
1261 info.resourcePath = RESOURCE_PATH;
1262 BundleMgrClient bundleMgrClient;
1263 std::string metadataName = "ohos.extension.forms";
1264 std::vector<std::string> profileInfo;
1265 auto ret = bundleMgrClient.GetResConfigFile(info, metadataName, profileInfo);
1266 EXPECT_FALSE(ret);
1267 GTEST_LOG_(INFO) << name << " end";
1268 }
1269
1270 /**
1271 * @tc.number: GetResourceConfigFile_032
1272 * @tc.name: GetResConfigFile
1273 * @tc.desc: Test the interface of GetResConfigFile
1274 * 1. HapModuleInfo is valid
1275 * 2. metadataName is not empty
1276 * 3. HapModuleInfo does not have metadata
1277 * @tc.require: AR000GNT9D
1278 */
1279 HWTEST_F(BundleMgrClientSystemTest, GetResourceConfigFile_032, TestSize.Level1)
1280 {
1281 auto name = std::string("GetResourceConfigFile_032");
1282 GTEST_LOG_(INFO) << name << " start";
1283 HapModuleInfo info;
1284 info.resourcePath = RESOURCE_PATH;
1285 BundleMgrClient bundleMgrClient;
1286 std::string metadataName = "ohos.extension.forms";
1287 std::vector<std::string> profileInfo;
1288 auto ret = bundleMgrClient.GetResConfigFile(info, metadataName, profileInfo);
1289 EXPECT_FALSE(ret);
1290 GTEST_LOG_(INFO) << name << " end";
1291 }
1292
1293 /**
1294 * @tc.number: GetResourceConfigFile_033
1295 * @tc.name: GetResConfigFile
1296 * @tc.desc: Test the interface of GetResConfigFile
1297 * 1. HapModuleInfo is valid
1298 * 2. metadataName is not empty
1299 * 3. metadataName cannot be found
1300 * @tc.require: AR000GNT9D
1301 */
1302 HWTEST_F(BundleMgrClientSystemTest, GetResourceConfigFile_033, TestSize.Level1)
1303 {
1304 auto name = std::string("GetResourceConfigFile_033");
1305 GTEST_LOG_(INFO) << name << " start";
1306 HapModuleInfo info;
1307 std::vector<Metadata> &metadata = info.metadata;
1308 Metadata data;
1309 data.name = "ohos.extension.forms";
1310 data.resource = "@profile:form_config";
1311 metadata.emplace_back(data);
1312 info.resourcePath = RESOURCE_PATH;
1313 BundleMgrClient bundleMgrClient;
1314 std::string metadataName = "ohos.extension.forms1";
1315 std::vector<std::string> profileInfo;
1316 auto ret = bundleMgrClient.GetResConfigFile(info, metadataName, profileInfo);
1317 EXPECT_FALSE(ret);
1318 GTEST_LOG_(INFO) << name << " end";
1319 }
1320
1321 /**
1322 * @tc.number: GetResourceConfigFile_034
1323 * @tc.name: GetResConfigFile
1324 * @tc.desc: Test the interface of GetResConfigFile
1325 * 1. HapModuleInfo is valid and has only one metadata
1326 * 2. metadataName is not empty
1327 * 3. metadataName can be found
1328 * @tc.require: AR000GNT9D
1329 */
1330 HWTEST_F(BundleMgrClientSystemTest, GetResourceConfigFile_034, TestSize.Level1)
1331 {
1332 auto name = std::string("GetResourceConfigFile_034");
1333 GTEST_LOG_(INFO) << name << " start";
1334 std::string bundleFilePath = THIRD_PATH + "bundleClient1.hap";
1335 std::string installMsg;
1336 InstallBundle(bundleFilePath, InstallFlag::NORMAL, installMsg);
1337 EXPECT_EQ(installMsg, "Success") << "install fail!" << bundleFilePath;
1338
1339 HapModuleInfo info;
1340 std::vector<Metadata> &metadata = info.metadata;
1341 Metadata data;
1342 data.name = "ohos.extension.forms";
1343 data.resource = "@profile:form_config";
1344 metadata.emplace_back(data);
1345 info.resourcePath = RESOURCE_PATH;
1346 BundleMgrClient bundleMgrClient;
1347 std::string metadataName = "ohos.extension.forms";
1348 std::vector<std::string> profileInfo;
1349 auto ret = bundleMgrClient.GetResConfigFile(info, metadataName, profileInfo);
1350 EXPECT_TRUE(ret);
1351 std::cout << profileInfo[0] << std::endl;
1352
1353 std::string uninstallMsg;
1354 UninstallBundle(BUNDLE_NAME, uninstallMsg);
1355 EXPECT_EQ(uninstallMsg, "Success") << "uninstall fail!" << bundleFilePath;
1356 std::cout << "END GetResourceConfigFile_034" << std::endl;
1357 GTEST_LOG_(INFO) << name << " end";
1358 }
1359
1360 /**
1361 * @tc.number: GetResourceConfigFile_035
1362 * @tc.name: GetResConfigFile
1363 * @tc.desc: Test the interface of GetResConfigFile
1364 * 1. HapModuleInfo is valid and has multiple metadata
1365 * 2. metadataName is not empty
1366 * 3. metadataName can be found
1367 * @tc.require: AR000GNT9D
1368 */
1369 HWTEST_F(BundleMgrClientSystemTest, GetResourceConfigFile_035, TestSize.Level1)
1370 {
1371 auto name = std::string("GetResourceConfigFile_035");
1372 GTEST_LOG_(INFO) << name << " start";
1373 std::string bundleFilePath = THIRD_PATH + "bundleClient1.hap";
1374 std::string installMsg;
1375 InstallBundle(bundleFilePath, InstallFlag::NORMAL, installMsg);
1376 EXPECT_EQ(installMsg, "Success") << "install fail!" << bundleFilePath;
1377
1378 HapModuleInfo info;
1379 std::vector<Metadata> &metadata = info.metadata;
1380 Metadata data;
1381 data.name = "ohos.extension.forms";
1382 data.resource = "@profile:form_config";
1383
1384 Metadata data1;
1385 data1.name = "ohos.extension.forms1";
1386 data1.resource = "@profile:shortcuts_config";
1387
1388 metadata.emplace_back(data);
1389 metadata.emplace_back(data1);
1390 info.resourcePath = RESOURCE_PATH;
1391 BundleMgrClient bundleMgrClient;
1392 std::string metadataName = "ohos.extension.forms";
1393 std::vector<std::string> profileInfo;
1394 auto ret = bundleMgrClient.GetResConfigFile(info, metadataName, profileInfo);
1395 EXPECT_TRUE(ret);
1396 std::cout << profileInfo[0] << std::endl;
1397
1398 std::string uninstallMsg;
1399 UninstallBundle(BUNDLE_NAME, uninstallMsg);
1400 EXPECT_EQ(uninstallMsg, "Success") << "uninstall fail!" << bundleFilePath;
1401 std::cout << "END GetResourceConfigFile_035" << std::endl;
1402 GTEST_LOG_(INFO) << name << " end";
1403 }
1404
1405 /**
1406 * @tc.number: GetResourceConfigFile_036
1407 * @tc.name: GetResConfigFile
1408 * @tc.desc: Test the interface of GetResConfigFile
1409 * 1. HapModuleInfo is valid and has multiple metadata
1410 * 2. metadataName is not empty
1411 * 3. metadataName can be found
1412 * @tc.require: AR000GNT9D
1413 */
1414 HWTEST_F(BundleMgrClientSystemTest, GetResourceConfigFile_036, TestSize.Level1)
1415 {
1416 auto name = std::string("GetResourceConfigFile_036");
1417 GTEST_LOG_(INFO) << name << " start";
1418 std::string bundleFilePath = THIRD_PATH + "bundleClient1.hap";
1419 std::string installMsg;
1420 InstallBundle(bundleFilePath, InstallFlag::NORMAL, installMsg);
1421 EXPECT_EQ(installMsg, "Success") << "install fail!" << bundleFilePath;
1422
1423 HapModuleInfo info;
1424 std::vector<Metadata> &metadata = info.metadata;
1425 Metadata data;
1426 data.name = "ohos.extension.forms";
1427 data.resource = "@profile:form_config";
1428
1429 Metadata data1;
1430 data1.name = "ohos.extension.forms";
1431 data1.resource = "@profile:shortcuts_config";
1432
1433 metadata.emplace_back(data);
1434 metadata.emplace_back(data1);
1435 info.resourcePath = RESOURCE_PATH;
1436 BundleMgrClient bundleMgrClient;
1437 std::string metadataName = "ohos.extension.forms";
1438 std::vector<std::string> profileInfo;
1439 auto ret = bundleMgrClient.GetResConfigFile(info, metadataName, profileInfo);
1440 EXPECT_TRUE(ret);
1441 EXPECT_EQ(profileInfo.size(), 2);
1442 std::cout << profileInfo[0] << std::endl;
1443 std::cout << profileInfo[1] << std::endl;
1444
1445 std::string uninstallMsg;
1446 UninstallBundle(BUNDLE_NAME, uninstallMsg);
1447 EXPECT_EQ(uninstallMsg, "Success") << "uninstall fail!" << bundleFilePath;
1448 std::cout << "END GetResourceConfigFile_036" << std::endl;
1449 GTEST_LOG_(INFO) << name << " end";
1450 }
1451
1452 /**
1453 * @tc.number: GetResourceConfigFile_037
1454 * @tc.name: GetResConfigFile
1455 * @tc.desc: Test the interface of GetResConfigFile
1456 * 1. metadataName is empty
1457 * 2. HapModuleInfo has only one metadata
1458 * @tc.require: AR000GNT9D
1459 */
1460 HWTEST_F(BundleMgrClientSystemTest, GetResourceConfigFile_037, TestSize.Level1)
1461 {
1462 auto name = std::string("GetResourceConfigFile_037");
1463 GTEST_LOG_(INFO) << name << " start";
1464 std::string bundleFilePath = THIRD_PATH + "bundleClient1.hap";
1465 std::string installMsg;
1466 InstallBundle(bundleFilePath, InstallFlag::NORMAL, installMsg);
1467 EXPECT_EQ(installMsg, "Success") << "install fail!" << bundleFilePath;
1468
1469 HapModuleInfo info;
1470 std::vector<Metadata> &metadata = info.metadata;
1471 Metadata data;
1472 data.name = "ohos.extension.forms";
1473 data.resource = "@profile:form_config";
1474 metadata.emplace_back(data);
1475 info.resourcePath = RESOURCE_PATH;
1476 BundleMgrClient bundleMgrClient;
1477 std::string metadataName;
1478 std::vector<std::string> profileInfo;
1479 auto ret = bundleMgrClient.GetResConfigFile(info, metadataName, profileInfo);
1480 EXPECT_TRUE(ret);
1481 std::cout << profileInfo[0] << std::endl;
1482
1483 std::string uninstallMsg;
1484 UninstallBundle(BUNDLE_NAME, uninstallMsg);
1485 EXPECT_EQ(uninstallMsg, "Success") << "uninstall fail!" << bundleFilePath;
1486 std::cout << "END GetResourceConfigFile_037" << std::endl;
1487 GTEST_LOG_(INFO) << name << " end";
1488 }
1489
1490 /**
1491 * @tc.number: GetResourceConfigFile_038
1492 * @tc.name: GetResConfigFile
1493 * @tc.desc: Test the interface of GetResConfigFile
1494 * 1. metadataName is empty
1495 * 2. HapModuleInfo has only multiple metadata
1496 * @tc.require: AR000GNT9D
1497 */
1498 HWTEST_F(BundleMgrClientSystemTest, GetResourceConfigFile_038, TestSize.Level1)
1499 {
1500 auto name = std::string("GetResourceConfigFile_038");
1501 GTEST_LOG_(INFO) << name << " start";
1502 std::string bundleFilePath = THIRD_PATH + "bundleClient1.hap";
1503 std::string installMsg;
1504 InstallBundle(bundleFilePath, InstallFlag::NORMAL, installMsg);
1505 EXPECT_EQ(installMsg, "Success") << "install fail!" << bundleFilePath;
1506
1507 HapModuleInfo info;
1508 std::vector<Metadata> &metadata = info.metadata;
1509 Metadata data;
1510 data.name = "ohos.extension.forms";
1511 data.resource = "@profile:form_config";
1512
1513 Metadata data1;
1514 data1.name = "ohos.extension.forms1";
1515 data1.resource = "@profile:shortcuts_config";
1516
1517 metadata.emplace_back(data);
1518 metadata.emplace_back(data1);
1519 info.resourcePath = RESOURCE_PATH;
1520 BundleMgrClient bundleMgrClient;
1521 std::string metadataName;
1522 std::vector<std::string> profileInfo;
1523 auto ret = bundleMgrClient.GetResConfigFile(info, metadataName, profileInfo);
1524 EXPECT_TRUE(ret);
1525 EXPECT_EQ(profileInfo.size(), 2);
1526 std::cout << profileInfo[0] << std::endl;
1527 std::cout << profileInfo[1] << std::endl;
1528 std::string uninstallMsg;
1529 UninstallBundle(BUNDLE_NAME, uninstallMsg);
1530 EXPECT_EQ(uninstallMsg, "Success") << "uninstall fail!" << bundleFilePath;
1531 std::cout << "END GetResourceConfigFile_038" << std::endl;
1532 GTEST_LOG_(INFO) << name << " end";
1533 }
1534
1535 /**
1536 * @tc.number: GetResourceConfigFile_039
1537 * @tc.name: GetResConfigFile
1538 * @tc.desc: Test the interface of GetResConfigFile
1539 * 1. profile's suffix is not .json
1540 * @tc.require: AR000GNT9D
1541 */
1542 HWTEST_F(BundleMgrClientSystemTest, GetResourceConfigFile_039, TestSize.Level1)
1543 {
1544 auto name = std::string("GetResourceConfigFile_039");
1545 GTEST_LOG_(INFO) << name << " start";
1546 std::string bundleFilePath = THIRD_PATH + "bundleClient1.hap";
1547 std::string installMsg;
1548 InstallBundle(bundleFilePath, InstallFlag::NORMAL, installMsg);
1549 EXPECT_EQ(installMsg, "Success") << "install fail!" << bundleFilePath;
1550
1551 HapModuleInfo info;
1552 std::vector<Metadata> &metadata = info.metadata;
1553 Metadata data;
1554 data.name = "ohos.extension.forms";
1555 data.resource = "@profile:form_config1";
1556 metadata.emplace_back(data);
1557 info.resourcePath = RESOURCE_PATH;
1558 BundleMgrClient bundleMgrClient;
1559 std::string metadataName = "ohos.extension.forms";
1560 std::vector<std::string> profileInfo;
1561 auto ret = bundleMgrClient.GetResConfigFile(info, metadataName, profileInfo);
1562 EXPECT_FALSE(ret);
1563
1564 std::string uninstallMsg;
1565 UninstallBundle(BUNDLE_NAME, uninstallMsg);
1566 EXPECT_EQ(uninstallMsg, "Success") << "uninstall fail!" << bundleFilePath;
1567 std::cout << "END GetResourceConfigFile_039" << std::endl;
1568 GTEST_LOG_(INFO) << name << " end";
1569 }
1570
1571 /**
1572 * @tc.number: GetResourceConfigFile_040
1573 * @tc.name: GetResConfigFile
1574 * @tc.desc: Test the interface of GetResConfigFile
1575 * 1. profile is empty file
1576 * @tc.require: AR000GNT9D
1577 */
1578 HWTEST_F(BundleMgrClientSystemTest, GetResourceConfigFile_040, TestSize.Level1)
1579 {
1580 auto name = std::string("GetResourceConfigFile_040");
1581 GTEST_LOG_(INFO) << name << " start";
1582 std::string bundleFilePath = THIRD_PATH + "bundleClient1.hap";
1583 std::string installMsg;
1584 InstallBundle(bundleFilePath, InstallFlag::NORMAL, installMsg);
1585 EXPECT_EQ(installMsg, "Success") << "install fail!" << bundleFilePath;
1586
1587 HapModuleInfo info;
1588 std::vector<Metadata> &metadata = info.metadata;
1589 Metadata data;
1590 data.name = "ohos.extension.forms";
1591 data.resource = "@profile:form_config2";
1592 metadata.emplace_back(data);
1593 info.resourcePath = RESOURCE_PATH;
1594 BundleMgrClient bundleMgrClient;
1595 std::string metadataName = "ohos.extension.forms";
1596 std::vector<std::string> profileInfo;
1597 auto ret = bundleMgrClient.GetResConfigFile(info, metadataName, profileInfo);
1598 EXPECT_FALSE(ret);
1599
1600 std::string uninstallMsg;
1601 UninstallBundle(BUNDLE_NAME, uninstallMsg);
1602 EXPECT_EQ(uninstallMsg, "Success") << "uninstall fail!" << bundleFilePath;
1603 std::cout << "END GetResourceConfigFile_040" << std::endl;
1604 GTEST_LOG_(INFO) << name << " end";
1605 }
1606
1607 /**
1608 * @tc.number: GetResourceConfigFile_041
1609 * @tc.name: GetResConfigFile
1610 * @tc.desc: Test the interface of GetResConfigFile
1611 * 1. profile is not json-format
1612 * @tc.require: AR000GNT9D
1613 */
1614 HWTEST_F(BundleMgrClientSystemTest, GetResourceConfigFile_041, TestSize.Level1)
1615 {
1616 auto name = std::string("GetResourceConfigFile_041");
1617 GTEST_LOG_(INFO) << name << " start";
1618 std::string bundleFilePath = THIRD_PATH + "bundleClient1.hap";
1619 std::string installMsg;
1620 InstallBundle(bundleFilePath, InstallFlag::NORMAL, installMsg);
1621 EXPECT_EQ(installMsg, "Success") << "install fail!" << bundleFilePath;
1622
1623 HapModuleInfo info;
1624 std::vector<Metadata> &metadata = info.metadata;
1625 Metadata data;
1626 data.name = "ohos.extension.forms";
1627 data.resource = "@profile:form_config3";
1628 metadata.emplace_back(data);
1629 info.resourcePath = RESOURCE_PATH;
1630 BundleMgrClient bundleMgrClient;
1631 std::string metadataName = "ohos.extension.forms";
1632 std::vector<std::string> profileInfo;
1633 auto ret = bundleMgrClient.GetResConfigFile(info, metadataName, profileInfo);
1634 EXPECT_FALSE(ret);
1635
1636 std::string uninstallMsg;
1637 UninstallBundle(BUNDLE_NAME, uninstallMsg);
1638 EXPECT_EQ(uninstallMsg, "Success") << "uninstall fail!" << bundleFilePath;
1639 std::cout << "END GetResourceConfigFile_041" << std::endl;
1640 GTEST_LOG_(INFO) << name << " end";
1641 }
1642
1643 /**
1644 * @tc.number: GetResourceConfigFile_042
1645 * @tc.name: GetResConfigFile
1646 * @tc.desc: Test the interface of GetResConfigFile
1647 * 1. profiles both have json-format file and non-json-format file
1648 * @tc.require: AR000GNT9D
1649 */
1650 HWTEST_F(BundleMgrClientSystemTest, GetResourceConfigFile_042, TestSize.Level1)
1651 {
1652 auto name = std::string("GetResourceConfigFile_042");
1653 GTEST_LOG_(INFO) << name << " start";
1654 std::string bundleFilePath = THIRD_PATH + "bundleClient1.hap";
1655 std::string installMsg;
1656 InstallBundle(bundleFilePath, InstallFlag::NORMAL, installMsg);
1657 EXPECT_EQ(installMsg, "Success") << "install fail!" << bundleFilePath;
1658
1659 HapModuleInfo info;
1660 std::vector<Metadata> &metadata = info.metadata;
1661 Metadata data;
1662 data.name = "ohos.extension.forms";
1663 data.resource = "@profile:form_config";
1664 Metadata data1;
1665 data.name = "ohos.extension.forms";
1666 data.resource = "@profile:form_config1";
1667
1668 metadata.emplace_back(data);
1669 info.resourcePath = RESOURCE_PATH;
1670 BundleMgrClient bundleMgrClient;
1671 std::string metadataName = "ohos.extension.forms";
1672 std::vector<std::string> profileInfo;
1673 auto ret = bundleMgrClient.GetResConfigFile(info, metadataName, profileInfo);
1674 EXPECT_FALSE(ret);
1675
1676 std::string uninstallMsg;
1677 UninstallBundle(BUNDLE_NAME, uninstallMsg);
1678 EXPECT_EQ(uninstallMsg, "Success") << "uninstall fail!" << bundleFilePath;
1679 std::cout << "END GetResourceConfigFile_042" << std::endl;
1680 GTEST_LOG_(INFO) << name << " end";
1681 }
1682
1683 /**
1684 * @tc.number: GetResourceConfigFile_04
1685 * @tc.name: GetResConfigFile
1686 * @tc.desc: Test the interface of QueryExtensionAbilityInfos
1687 * @tc.require: AR000GNT9D
1688 */
1689 HWTEST_F(BundleMgrClientSystemTest, QueryExtensionAbilityInfos_0001, TestSize.Level1)
1690 {
1691 auto name = std::string("QueryExtensionAbilityInfos_0001");
1692 GTEST_LOG_(INFO) << name << " start";
1693 std::string bundleFilePath = THIRD_PATH + "bundleClient1.hap";
1694 std::string installMsg;
1695 InstallBundle(bundleFilePath, InstallFlag::NORMAL, installMsg);
1696 EXPECT_EQ(installMsg, "Success") << "install fail!" << bundleFilePath;
1697
1698 std::vector<ExtensionAbilityInfo> infos;
1699 OHOS::AAFwk::Want want;
1700 ElementName element;
1701 element.SetBundleName(BUNDLE_NAME);
1702 element.SetAbilityName("Form");
1703 want.SetElement(element);
1704 bool ret = GetBundleMgrProxy()->QueryExtensionAbilityInfos(want, ExtensionAbilityType::FORM,
1705 ExtensionAbilityInfoFlag::GET_EXTENSION_INFO_DEFAULT, DEFAULT_USERID, infos);
1706 EXPECT_TRUE(ret);
1707 EXPECT_EQ(1, infos.size());
1708
1709 std::string uninstallMsg;
1710 UninstallBundle(BUNDLE_NAME, uninstallMsg);
1711 EXPECT_EQ(uninstallMsg, "Success") << "uninstall fail!" << bundleFilePath;
1712 std::cout << "END QueryExtensionAbilityInfos_0001" << std::endl;
1713 GTEST_LOG_(INFO) << name << " end";
1714 }
1715 } // namespace AppExecFwk
1716 } // namespace OHOS