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
16 #include <gtest/gtest.h>
17 #define private public
18 #define protected public
19 #include "extension_config.h"
20 #undef private
21 #undef protected
22 #include "hilog_tag_wrapper.h"
23 #include "json_utils.h"
24
25 using namespace testing;
26 using namespace testing::ext;
27 using json = nlohmann::json;
28 namespace {
29 constexpr const char* EXTENSION_CONFIG_NAME = "extension_config_name";
30 constexpr const char* EXTENSION_TYPE_NAME = "extension_type_name";
31 constexpr const char* EXTENSION_AUTO_DISCONNECT_TIME = "auto_disconnect_time";
32
33 constexpr const char* EXTENSION_THIRD_PARTY_APP_BLOCKED_FLAG_NAME = "third_party_app_blocked_flag";
34 constexpr const char* EXTENSION_SERVICE_BLOCKED_LIST_NAME = "service_blocked_list";
35 constexpr const char* EXTENSION_SERVICE_STARTUP_ENABLE_FLAG = "service_startup_enable_flag";
36 }
37 namespace OHOS {
38 namespace AbilityRuntime {
39 class AbilityExtensionConfigTest : public testing::Test {
40 public:
41 static void SetUpTestCase();
42 static void TearDownTestCase();
43 void SetUp() override;
44 void TearDown() override;
45 public:
46 void LoadTestConfig(const std::string &configStr);
47 static std::shared_ptr<AAFwk::ExtensionConfig> extensionConfig_;
48 };
49
50 std::shared_ptr<AAFwk::ExtensionConfig> AbilityExtensionConfigTest::extensionConfig_ =
51 DelayedSingleton<AAFwk::ExtensionConfig>::GetInstance();
52
SetUpTestCase(void)53 void AbilityExtensionConfigTest::SetUpTestCase(void)
54 {}
55
TearDownTestCase(void)56 void AbilityExtensionConfigTest::TearDownTestCase(void)
57 {}
58
SetUp()59 void AbilityExtensionConfigTest::SetUp()
60 {
61 extensionConfig_->configMap_.clear();
62 }
63
TearDown()64 void AbilityExtensionConfigTest::TearDown()
65 {}
66
LoadTestConfig(const std::string & configStr)67 void AbilityExtensionConfigTest::LoadTestConfig(const std::string &configStr)
68 {
69 nlohmann::json jsonConfig = nlohmann::json::parse(configStr);
70 extensionConfig_->LoadExtensionConfig(jsonConfig);
71 }
72
73 /*
74 * @tc.number : GetExtensionConfigPath_001
75 * @tc.name : AbilityExtensionConfigTest
76 * @tc.desc : Test Function GetExtensionConfigPath
77 */
78 HWTEST_F(AbilityExtensionConfigTest, GetExtensionConfigPath_001, TestSize.Level1)
79 {
80 extensionConfig_->GetExtensionConfigPath();
81 extensionConfig_->LoadExtensionConfiguration();
82 std::string extensionTypeName = EXTENSION_TYPE_NAME;
83 extensionConfig_->GetExtensionAutoDisconnectTime(extensionTypeName);
84 auto result = extensionConfig_->IsExtensionStartThirdPartyAppEnable(extensionTypeName);
85 EXPECT_EQ(result, true);
86 }
87
88 /*
89 * @tc.number : LoadExtensionServiceBlockedList_001
90 * @tc.name : AbilityExtensionConfigTest
91 * @tc.desc : Test Function LoadExtensionServiceBlockedList
92 */
93 HWTEST_F(AbilityExtensionConfigTest, LoadExtensionServiceBlockedList_001, TestSize.Level1)
94 {
95 json jsOnFile;
96 extensionConfig_->LoadExtensionServiceBlockedList(jsOnFile, "aa");
97 jsOnFile[EXTENSION_SERVICE_STARTUP_ENABLE_FLAG] = false;
98 extensionConfig_->LoadExtensionServiceBlockedList(jsOnFile, "aa");
99 jsOnFile[EXTENSION_SERVICE_STARTUP_ENABLE_FLAG] = true;
100 extensionConfig_->LoadExtensionServiceBlockedList(jsOnFile, "aa");
101 jsOnFile[EXTENSION_SERVICE_BLOCKED_LIST_NAME] = {"aa", "bb"};
102 extensionConfig_->LoadExtensionServiceBlockedList(jsOnFile, "aa");
103 EXPECT_TRUE(extensionConfig_ != nullptr);
104 }
105
106 /*
107 * @tc.number : LoadExtensionThirdPartyAppBlockedList_001
108 * @tc.name : AbilityExtensionConfigTest
109 * @tc.desc : Test Function LoadExtensionThirdPartyAppBlockedList
110 */
111 HWTEST_F(AbilityExtensionConfigTest, LoadExtensionThirdPartyAppBlockedList_001, TestSize.Level1)
112 {
113 json jsOnFile;
114 std::string extensionTypeName = "aa";
115 extensionConfig_->LoadExtensionThirdPartyAppBlockedList(jsOnFile, extensionTypeName);
116 jsOnFile[EXTENSION_THIRD_PARTY_APP_BLOCKED_FLAG_NAME] = false;
117 extensionConfig_->LoadExtensionThirdPartyAppBlockedList(jsOnFile, extensionTypeName);
118 jsOnFile[EXTENSION_THIRD_PARTY_APP_BLOCKED_FLAG_NAME] = true;
119 extensionConfig_->LoadExtensionThirdPartyAppBlockedList(jsOnFile, extensionTypeName);
120 EXPECT_TRUE(extensionConfig_ != nullptr);
121 }
122
123 /*
124 * @tc.number : LoadExtensionAutoDisconnectTime_001
125 * @tc.name : AbilityExtensionConfigTest
126 * @tc.desc : Test Function LoadExtensionAutoDisconnectTime
127 */
128 HWTEST_F(AbilityExtensionConfigTest, LoadExtensionAutoDisconnectTime_001, TestSize.Level1)
129 {
130 json jsOnFile;
131 std::string extensionTypeName = "aa";
132 extensionConfig_->LoadExtensionAutoDisconnectTime(jsOnFile, extensionTypeName);
133 jsOnFile[EXTENSION_AUTO_DISCONNECT_TIME] = 100;
134 extensionConfig_->LoadExtensionAutoDisconnectTime(jsOnFile, extensionTypeName);
135 EXPECT_TRUE(extensionConfig_ != nullptr);
136 }
137
138 /*
139 * @tc.number : LoadExtensionConfig_001
140 * @tc.name : AbilityExtensionConfigTest
141 * @tc.desc : Test Function LoadExtensionConfig
142 */
143 HWTEST_F(AbilityExtensionConfigTest, LoadExtensionConfig_001, TestSize.Level1)
144 {
145 json jsOnFile;
146 json jsOnItem;
147 json jsOnItem2;
148 extensionConfig_->LoadExtensionConfig(jsOnFile);
149 jsOnItem[EXTENSION_TYPE_NAME] = "aa";
150 jsOnItem2[EXTENSION_TYPE_NAME] = "bb";
151 jsOnFile[EXTENSION_CONFIG_NAME] = {jsOnItem, jsOnItem2, "cc"};
152 extensionConfig_->LoadExtensionConfig(jsOnFile);
153 EXPECT_TRUE(extensionConfig_ != nullptr);
154 }
155
156 /*
157 * @tc.number : IsExtensionStartServiceEnable_001
158 * @tc.name : AbilityExtensionConfigTest
159 * @tc.desc : Test Function IsExtensionStartServiceEnable
160 */
161 HWTEST_F(AbilityExtensionConfigTest, IsExtensionStartServiceEnable_001, TestSize.Level1)
162 {
163 auto extType = "form";
164 ASSERT_NE(extensionConfig_, nullptr);
165 extensionConfig_->configMap_.clear();
166 extensionConfig_->configMap_[extType].serviceEnableFlag = false;
167 bool enable = extensionConfig_->IsExtensionStartServiceEnable(extType, "form");
168 EXPECT_EQ(enable, false);
169 }
170
171 /*
172 * @tc.number : IsExtensionStartServiceEnable_002
173 * @tc.name : AbilityExtensionConfigTest
174 * @tc.desc : Test Function IsExtensionStartServiceEnable
175 */
176 HWTEST_F(AbilityExtensionConfigTest, IsExtensionStartServiceEnable_002, TestSize.Level1)
177 {
178 auto extType = "form";
179 ASSERT_NE(extensionConfig_, nullptr);
180 extensionConfig_->configMap_.clear();
181 extensionConfig_->configMap_[extType].serviceEnableFlag = true;
182 bool enable = extensionConfig_->IsExtensionStartServiceEnable(extType, "bbb");
183 EXPECT_EQ(enable, true);
184 }
185
186 /*
187 * @tc.number : IsExtensionStartServiceEnable_003
188 * @tc.name : AbilityExtensionConfigTest
189 * @tc.desc : Test Function IsExtensionStartServiceEnable
190 */
191 HWTEST_F(AbilityExtensionConfigTest, IsExtensionStartServiceEnable_003, TestSize.Level1)
192 {
193 json jsOnFile;
194 auto extType = "form";
195 jsOnFile[EXTENSION_SERVICE_STARTUP_ENABLE_FLAG] = true;
196 jsOnFile[EXTENSION_SERVICE_BLOCKED_LIST_NAME] = {"aa", "bb", "/bundle/module/ability"};
197 extensionConfig_->LoadExtensionServiceBlockedList(jsOnFile, extType);
198 // uri not valid
199 bool enable = extensionConfig_->IsExtensionStartServiceEnable(extType, "bb");
200 EXPECT_EQ(enable, true);
201 }
202
203 /*
204 * @tc.number : IsExtensionStartServiceEnable_004
205 * @tc.name : AbilityExtensionConfigTest
206 * @tc.desc : Test Function IsExtensionStartServiceEnable
207 */
208 HWTEST_F(AbilityExtensionConfigTest, IsExtensionStartServiceEnable_004, TestSize.Level1)
209 {
210 json jsOnFile;
211 auto extType = "form";
212 jsOnFile[EXTENSION_SERVICE_STARTUP_ENABLE_FLAG] = true;
213 jsOnFile[EXTENSION_SERVICE_BLOCKED_LIST_NAME] = {"aa", "bb", "/bundle/module/ability"};
214 extensionConfig_->LoadExtensionServiceBlockedList(jsOnFile, extType);
215 // uri is valid
216 bool enable = extensionConfig_->IsExtensionStartServiceEnable(extType, "/bundle/module/ability");
217 EXPECT_EQ(enable, false);
218 }
219
220 /*
221 * @tc.number : ReadFileInfoJson_001
222 * @tc.name : AbilityExtensionConfigTest
223 * @tc.desc : Test Function ReadFileInfoJson
224 */
225 HWTEST_F(AbilityExtensionConfigTest, ReadFileInfoJson_001, TestSize.Level1)
226 {
227 nlohmann::json jsOne;
228 auto result = extensionConfig_->ReadFileInfoJson("d://dddd", jsOne);
229 EXPECT_EQ(result, false);
230 }
231
232 /*
233 * @tc.number : CheckExtensionUriValid_001
234 * @tc.name : AbilityExtensionConfigTest
235 * @tc.desc : Test Function CheckExtensionUriValid
236 */
237 HWTEST_F(AbilityExtensionConfigTest, CheckExtensionUriValid_001, TestSize.Level1)
238 {
239 auto result = extensionConfig_->CheckExtensionUriValid("http://aaa/bb/");
240 EXPECT_EQ(result, false);
241 result = extensionConfig_->CheckExtensionUriValid("http://aaa/bb/cc/");
242 EXPECT_EQ(result, false);
243 result = extensionConfig_->CheckExtensionUriValid("http://aaa//cc/");
244 EXPECT_EQ(result, false);
245 result = extensionConfig_->CheckExtensionUriValid("/bundleName/moduleName/abilityName");
246 EXPECT_EQ(result, true);
247 result = extensionConfig_->CheckExtensionUriValid("deviceName/bundleName/moduleName/abilityName");
248 EXPECT_EQ(result, true);
249 AppExecFwk::ElementName targetElementName;
250 EXPECT_EQ(targetElementName.ParseURI("deviceName/bundleName/moduleName/abilityName"), true);
251 EXPECT_EQ(targetElementName.GetBundleName(), "bundleName");
252 EXPECT_EQ(targetElementName.GetModuleName(), "moduleName");
253 EXPECT_EQ(targetElementName.GetAbilityName(), "abilityName");
254 }
255
256 /*
257 * @tc.number : GetExtensionAutoDisconnectTime_001
258 * @tc.name : AbilityExtensionConfigTest
259 * @tc.desc : Test Function GetExtensionAutoDisconnectTime
260 */
261 HWTEST_F(AbilityExtensionConfigTest, GetExtensionAutoDisconnectTime_001, TestSize.Level1)
262 {
263 TAG_LOGI(AAFwkTag::TEST, "GetExtensionAutoDisconnectTime_001 start.");
264 const std::string configStr = R"({
265 "ams_extension_config": [{
266 "name": "FormExtension",
267 "extension_type_name": "form",
268 "auto_disconnect_time": 5000
269 }]
270 })";
271 LoadTestConfig(configStr);
272 auto disconnectTime = extensionConfig_->GetExtensionAutoDisconnectTime("form");
273 EXPECT_EQ(disconnectTime, 5000);
274 TAG_LOGI(AAFwkTag::TEST, "GetExtensionAutoDisconnectTime_001 end.");
275 }
276
277 /*
278 * @tc.number : GetExtensionAutoDisconnectTime_002
279 * @tc.name : AbilityExtensionConfigTest
280 * @tc.desc : Test Function GetExtensionAutoDisconnectTime
281 */
282 HWTEST_F(AbilityExtensionConfigTest, GetExtensionAutoDisconnectTime_002, TestSize.Level1)
283 {
284 TAG_LOGI(AAFwkTag::TEST, "GetExtensionAutoDisconnectTime_002 start.");
285 const std::string configStr = R"({
286 "ams_extension_config": [{
287 "name": "FormExtension",
288 "extension_type_name": "form"
289 }]
290 })";
291 LoadTestConfig(configStr);
292 auto disconnectTime = extensionConfig_->GetExtensionAutoDisconnectTime("form");
293 EXPECT_EQ(disconnectTime, -1);
294 TAG_LOGI(AAFwkTag::TEST, "GetExtensionAutoDisconnectTime_002 end.");
295 }
296
297 /*
298 * @tc.number : GetExtensionAutoDisconnectTime_003
299 * @tc.name : AbilityExtensionConfigTest
300 * @tc.desc : Test Function GetExtensionAutoDisconnectTime
301 */
302 HWTEST_F(AbilityExtensionConfigTest, GetExtensionAutoDisconnectTime_003, TestSize.Level1)
303 {
304 TAG_LOGI(AAFwkTag::TEST, "GetExtensionAutoDisconnectTime_003 start.");
305 const std::string configStr = R"({
306 "ams_extension_config": [{
307 "name": "FormExtension",
308 "extension_type_name": "form",
309 "auto_disconnect_time": "invalid_value"
310 }]
311 })";
312 LoadTestConfig(configStr);
313 auto disconnectTime = extensionConfig_->GetExtensionAutoDisconnectTime("form");
314 EXPECT_EQ(disconnectTime, -1);
315 TAG_LOGI(AAFwkTag::TEST, "GetExtensionAutoDisconnectTime_003 end.");
316 }
317
318 /*
319 * @tc.number : GetExtensionAutoDisconnectTime_004
320 * @tc.name : AbilityExtensionConfigTest
321 * @tc.desc : Test Function GetExtensionAutoDisconnectTime
322 */
323 HWTEST_F(AbilityExtensionConfigTest, GetExtensionAutoDisconnectTime_004, TestSize.Level1)
324 {
325 TAG_LOGI(AAFwkTag::TEST, "GetExtensionAutoDisconnectTime_004 start.");
326 const std::string configStr = R"({
327 "ams_extension_config": [{
328 "name": "FormExtension",
329 "extension_type_name": 2,
330 "auto_disconnect_time": "invalid_value"
331 }]
332 })";
333 LoadTestConfig(configStr);
334 auto disconnectTime = extensionConfig_->GetExtensionAutoDisconnectTime("form");
335 EXPECT_EQ(disconnectTime, -1);
336 TAG_LOGI(AAFwkTag::TEST, "GetExtensionAutoDisconnectTime_004 end.");
337 }
338
339 /*
340 * @tc.number : GetExtensionAutoDisconnectTime_005
341 * @tc.name : AbilityExtensionConfigTest
342 * @tc.desc : Test Function GetExtensionAutoDisconnectTime
343 */
344 HWTEST_F(AbilityExtensionConfigTest, GetExtensionAutoDisconnectTime_005, TestSize.Level1)
345 {
346 TAG_LOGI(AAFwkTag::TEST, "GetExtensionAutoDisconnectTime_005 start.");
347 const std::string configStr = R"({
348 "ams_extension_config": []
349 })";
350 LoadTestConfig(configStr);
351 auto disconnectTime = extensionConfig_->GetExtensionAutoDisconnectTime("form");
352 EXPECT_EQ(disconnectTime, -1);
353 TAG_LOGI(AAFwkTag::TEST, "GetExtensionAutoDisconnectTime_005 end.");
354 }
355
356 /*
357 * @tc.number : LoadExtensionAbilityAccess_001
358 * @tc.name : AbilityExtensionConfigTest
359 * @tc.desc : Test Function LoadExtensionAbilityAccess
360 */
361 HWTEST_F(AbilityExtensionConfigTest, LoadExtensionAbilityAccess_001, TestSize.Level1)
362 {
363 TAG_LOGI(AAFwkTag::TEST, "LoadExtensionAbilityAccess_001 start.");
364 const std::string configStr = R"({
365 "ams_extension_config": [{
366 "name": "FormExtension",
367 "extension_type_name": "form"
368 }]
369 })";
370 ASSERT_NE(extensionConfig_, nullptr);
371 LoadTestConfig(configStr);
372 auto flag = extensionConfig_->configMap_["form"].abilityAccess.thirdPartyAppAccessFlag;
373 EXPECT_EQ(flag, std::nullopt);
374 TAG_LOGI(AAFwkTag::TEST, "LoadExtensionAbilityAccess_001 end.");
375 }
376
377 /*
378 * @tc.number : LoadExtensionAbilityAccess_002
379 * @tc.name : AbilityExtensionConfigTest
380 * @tc.desc : Test Function LoadExtensionAbilityAccess
381 */
382 HWTEST_F(AbilityExtensionConfigTest, LoadExtensionAbilityAccess_002, TestSize.Level1)
383 {
384 TAG_LOGI(AAFwkTag::TEST, "LoadExtensionAbilityAccess_002 start.");
385 const std::string configStr = R"({
386 "ams_extension_config": [{
387 "name": "FormExtension",
388 "extension_type_name": "form",
389 "ability_access" : 1
390 }]
391 })";
392 ASSERT_NE(extensionConfig_, nullptr);
393 LoadTestConfig(configStr);
394 auto flag = extensionConfig_->configMap_["form"].abilityAccess.thirdPartyAppAccessFlag;
395 EXPECT_EQ(flag, std::nullopt);
396 TAG_LOGI(AAFwkTag::TEST, "LoadExtensionAbilityAccess_002 end.");
397 }
398
399 /*
400 * @tc.number : LoadExtensionAbilityAccess_003
401 * @tc.name : AbilityExtensionConfigTest
402 * @tc.desc : Test Function LoadExtensionAbilityAccess
403 */
404 HWTEST_F(AbilityExtensionConfigTest, LoadExtensionAbilityAccess_003, TestSize.Level1)
405 {
406 TAG_LOGI(AAFwkTag::TEST, "LoadExtensionAbilityAccess_003 start.");
407 const std::string configStr = R"({
408 "ams_extension_config": [{
409 "name": "FormExtension",
410 "extension_type_name": "form",
411 "ability_access" : {}
412 }]
413 })";
414 ASSERT_NE(extensionConfig_, nullptr);
415 LoadTestConfig(configStr);
416 auto flag = extensionConfig_->configMap_["form"].abilityAccess.thirdPartyAppAccessFlag;
417 EXPECT_EQ(flag, std::nullopt);
418 TAG_LOGI(AAFwkTag::TEST, "LoadExtensionAbilityAccess_003 end.");
419 }
420
421 /*
422 * @tc.number : LoadExtensionAbilityAccess_004
423 * @tc.name : AbilityExtensionConfigTest
424 * @tc.desc : Test Function LoadExtensionAbilityAccess
425 */
426 HWTEST_F(AbilityExtensionConfigTest, LoadExtensionAbilityAccess_004, TestSize.Level1)
427 {
428 TAG_LOGI(AAFwkTag::TEST, "LoadExtensionAbilityAccess_004 start.");
429 const std::string configStr = R"({
430 "ams_extension_config": [{
431 "name": "FormExtension",
432 "extension_type_name": "form",
433 "ability_access" : {
434 "third_party_app_access_flag": "invalid_value",
435 "allowlist" : "invalid_value"
436 }
437 }]
438 })";
439 ASSERT_NE(extensionConfig_, nullptr);
440 LoadTestConfig(configStr);
441
442 auto &abilityAccess = extensionConfig_->configMap_["form"].abilityAccess;
443 auto flag = abilityAccess.thirdPartyAppAccessFlag;
444 EXPECT_EQ(flag, std::nullopt);
445 auto allowListSize = abilityAccess.allowList.size();
446 EXPECT_EQ(allowListSize, 0);
447 TAG_LOGI(AAFwkTag::TEST, "LoadExtensionAbilityAccess_004 end.");
448 }
449
450 /*
451 * @tc.number : LoadExtensionAbilityAccess_005
452 * @tc.name : AbilityExtensionConfigTest
453 * @tc.desc : Test Function LoadExtensionAbilityAccess
454 */
455 HWTEST_F(AbilityExtensionConfigTest, LoadExtensionAbilityAccess_005, TestSize.Level1)
456 {
457 TAG_LOGI(AAFwkTag::TEST, "LoadExtensionAbilityAccess_005 start.");
458 const std::string configStr = R"({
459 "ams_extension_config": [{
460 "name": "FormExtension",
461 "extension_type_name": "form",
462 "ability_access" : {
463 "allowlist" : []
464 }
465 }]
466 })";
467 ASSERT_NE(extensionConfig_, nullptr);
468 LoadTestConfig(configStr);
469
470 auto &abilityAccess = extensionConfig_->configMap_["form"].abilityAccess;
471 auto allowListSize = abilityAccess.allowList.size();
472 EXPECT_EQ(allowListSize, 0);
473 TAG_LOGI(AAFwkTag::TEST, "LoadExtensionAbilityAccess_005 end.");
474 }
475
476 /*
477 * @tc.number : LoadExtensionAbilityAccess_006
478 * @tc.name : AbilityExtensionConfigTest
479 * @tc.desc : Test Function LoadExtensionAbilityAccess
480 */
481 HWTEST_F(AbilityExtensionConfigTest, LoadExtensionAbilityAccess_006, TestSize.Level1)
482 {
483 TAG_LOGI(AAFwkTag::TEST, "LoadExtensionAbilityAccess_006 start.");
484 const std::string configStr = R"({
485 "ams_extension_config": [{
486 "name": "FormExtension",
487 "extension_type_name": "form",
488 "ability_access" : {
489 "allowlist" : [123]
490 }
491 }]
492 })";
493 ASSERT_NE(extensionConfig_, nullptr);
494 LoadTestConfig(configStr);
495
496 auto &abilityAccess = extensionConfig_->configMap_["form"].abilityAccess;
497 auto allowListSize = abilityAccess.allowList.size();
498 EXPECT_EQ(allowListSize, 0);
499 TAG_LOGI(AAFwkTag::TEST, "LoadExtensionAbilityAccess_006 end.");
500 }
501
502 /*
503 * @tc.number : LoadExtensionAbilityAccess_007
504 * @tc.name : AbilityExtensionConfigTest
505 * @tc.desc : Test Function LoadExtensionAbilityAccess
506 */
507 HWTEST_F(AbilityExtensionConfigTest, LoadExtensionAbilityAccess_007, TestSize.Level1)
508 {
509 TAG_LOGI(AAFwkTag::TEST, "LoadExtensionAbilityAccess_007 start.");
510 const std::string configStr = R"({
511 "ams_extension_config": [{
512 "name": "FormExtension",
513 "extension_type_name": "form",
514 "ability_access" : {
515 "allowlist" : [123]
516 }
517 }]
518 })";
519 ASSERT_NE(extensionConfig_, nullptr);
520 LoadTestConfig(configStr);
521
522 auto &abilityAccess = extensionConfig_->configMap_["form"].abilityAccess;
523 auto allowListSize = abilityAccess.allowList.size();
524 EXPECT_EQ(allowListSize, 0);
525 TAG_LOGI(AAFwkTag::TEST, "LoadExtensionAbilityAccess_007 end.");
526 }
527
528 /*
529 * @tc.number : LoadExtensionAbilityAccess_008
530 * @tc.name : AbilityExtensionConfigTest
531 * @tc.desc : Test Function LoadExtensionAbilityAccess
532 */
533 HWTEST_F(AbilityExtensionConfigTest, LoadExtensionAbilityAccess_008, TestSize.Level1)
534 {
535 TAG_LOGI(AAFwkTag::TEST, "LoadExtensionAbilityAccess_008 start.");
536 const std::string configStr = R"({
537 "ams_extension_config": [{
538 "name": "FormExtension",
539 "extension_type_name": "form",
540 "ability_access" : {
541 "allowlist" : ["invalidUrl"]
542 }
543 }]
544 })";
545 ASSERT_NE(extensionConfig_, nullptr);
546 LoadTestConfig(configStr);
547
548 auto &abilityAccess = extensionConfig_->configMap_["form"].abilityAccess;
549 auto allowListSize = abilityAccess.allowList.size();
550 EXPECT_EQ(allowListSize, 0);
551 TAG_LOGI(AAFwkTag::TEST, "LoadExtensionAbilityAccess_008 end.");
552 }
553
554 /*
555 * @tc.number : HasAbilityAccess_001
556 * @tc.name : AbilityExtensionConfigTest
557 * @tc.desc : Test Function HasAbilityAccess
558 */
559 HWTEST_F(AbilityExtensionConfigTest, HasAbilityAccess_001, TestSize.Level1)
560 {
561 TAG_LOGI(AAFwkTag::TEST, "HasAbilityAccess_001 start.");
562 const std::string configStr = R"({
563 "ams_extension_config": []
564 })";
565 ASSERT_NE(extensionConfig_, nullptr);
566 LoadTestConfig(configStr);
567
568 bool result = extensionConfig_->HasAbilityAccess("form");
569 EXPECT_FALSE(result);
570 TAG_LOGI(AAFwkTag::TEST, "HasAbilityAccess_001 end.");
571 }
572
573 /*
574 * @tc.number : HasAbilityAccess_002
575 * @tc.name : AbilityExtensionConfigTest
576 * @tc.desc : Test Function HasAbilityAccess
577 */
578 HWTEST_F(AbilityExtensionConfigTest, HasAbilityAccess_002, TestSize.Level1)
579 {
580 TAG_LOGI(AAFwkTag::TEST, "HasAbilityAccess_002 start.");
581 const std::string configStr = R"({
582 "ams_extension_config": [{
583 "name": "FormExtension",
584 "extension_type_name": "form",
585 "ability_access": {
586 "third_party_app_access_flag": false
587 }
588 }]
589 })";
590 ASSERT_NE(extensionConfig_, nullptr);
591 LoadTestConfig(configStr);
592
593 bool result = extensionConfig_->HasAbilityAccess("form");
594 EXPECT_TRUE(result);
595 TAG_LOGI(AAFwkTag::TEST, "HasAbilityAccess_002 end.");
596 }
597
598 /*
599 * @tc.number : HasThridPartyAppAccessFlag_001
600 * @tc.name : AbilityExtensionConfigTest
601 * @tc.desc : Test Function HasThridPartyAppAccessFlag
602 */
603 HWTEST_F(AbilityExtensionConfigTest, HasThridPartyAppAccessFlag_001, TestSize.Level1)
604 {
605 TAG_LOGI(AAFwkTag::TEST, "HasThridPartyAppAccessFlag_001 start.");
606 const std::string configStr = R"({
607 "ams_extension_config": []
608 })";
609 ASSERT_NE(extensionConfig_, nullptr);
610 LoadTestConfig(configStr);
611
612 bool result = extensionConfig_->HasThridPartyAppAccessFlag("form");
613 EXPECT_FALSE(result);
614 TAG_LOGI(AAFwkTag::TEST, "HasThridPartyAppAccessFlag_001 end.");
615 }
616
617 /*
618 * @tc.number : HasThridPartyAppAccessFlag_002
619 * @tc.name : AbilityExtensionConfigTest
620 * @tc.desc : Test Function HasThridPartyAppAccessFlag
621 */
622 HWTEST_F(AbilityExtensionConfigTest, HasThridPartyAppAccessFlag_002, TestSize.Level1)
623 {
624 TAG_LOGI(AAFwkTag::TEST, "HasThridPartyAppAccessFlag_002 start.");
625
626 const std::string configStr = R"({
627 "ams_extension_config": [{
628 "name": "FormExtension",
629 "extension_type_name": "form"
630 }]
631 })";
632 ASSERT_NE(extensionConfig_, nullptr);
633 LoadTestConfig(configStr);
634
635 bool result = extensionConfig_->HasThridPartyAppAccessFlag("form");
636 EXPECT_FALSE(result);
637 TAG_LOGI(AAFwkTag::TEST, "HasThridPartyAppAccessFlag_002 end.");
638 }
639
640 /*
641 * @tc.number : HasThridPartyAppAccessFlag_003
642 * @tc.name : AbilityExtensionConfigTest
643 * @tc.desc : Test Function HasThridPartyAppAccessFlag
644 */
645 HWTEST_F(AbilityExtensionConfigTest, HasThridPartyAppAccessFlag_003, TestSize.Level1)
646 {
647 TAG_LOGI(AAFwkTag::TEST, "HasThridPartyAppAccessFlag_003 start.");
648 const std::string configStr = R"({
649 "ams_extension_config": [{
650 "name": "FormExtension",
651 "extension_type_name": "form",
652 "ability_access" : {}
653 }]
654 })";
655 ASSERT_NE(extensionConfig_, nullptr);
656 LoadTestConfig(configStr);
657
658 bool result = extensionConfig_->HasThridPartyAppAccessFlag("form");
659 EXPECT_FALSE(result);
660 TAG_LOGI(AAFwkTag::TEST, "HasThridPartyAppAccessFlag_003 end.");
661 }
662
663 /*
664 * @tc.number : HasThridPartyAppAccessFlag_004
665 * @tc.name : AbilityExtensionConfigTest
666 * @tc.desc : Test Function HasThridPartyAppAccessFlag
667 */
668 HWTEST_F(AbilityExtensionConfigTest, HasThridPartyAppAccessFlag_004, TestSize.Level1)
669 {
670 TAG_LOGI(AAFwkTag::TEST, "HasThridPartyAppAccessFlag_004 start.");
671 const std::string configStr = R"({
672 "ams_extension_config": [{
673 "name": "FormExtension",
674 "extension_type_name": "form",
675 "ability_access" : {
676 "third_party_app_access_flag": false
677 }
678 }]
679 })";
680 ASSERT_NE(extensionConfig_, nullptr);
681 LoadTestConfig(configStr);
682
683 bool result = extensionConfig_->HasThridPartyAppAccessFlag("form");
684 EXPECT_TRUE(result);
685 TAG_LOGI(AAFwkTag::TEST, "HasThridPartyAppAccessFlag_004 end.");
686 }
687
688 /*
689 * @tc.number : HasServiceAccessFlag_001
690 * @tc.name : AbilityExtensionConfigTest
691 * @tc.desc : Test Function HasServiceAccessFlag
692 */
693 HWTEST_F(AbilityExtensionConfigTest, HasServiceAccessFlag_001, TestSize.Level1)
694 {
695 TAG_LOGI(AAFwkTag::TEST, "HasServiceAccessFlag_001 start.");
696 const std::string configStr = R"({
697 "ams_extension_config": [{
698 "name": "FormExtension",
699 "extension_type_name": "form",
700 "ability_access" : {
701 "service_access_flag": false
702 }
703 }]
704 })";
705 ASSERT_NE(extensionConfig_, nullptr);
706 LoadTestConfig(configStr);
707
708 bool result = extensionConfig_->HasServiceAccessFlag("form");
709 EXPECT_TRUE(result);
710 TAG_LOGI(AAFwkTag::TEST, "HasServiceAccessFlag_001 end.");
711 }
712
713 /*
714 * @tc.number : HasDefaultAccessFlag_001
715 * @tc.name : AbilityExtensionConfigTest
716 * @tc.desc : Test Function HasDefaultAccessFlag
717 */
718 HWTEST_F(AbilityExtensionConfigTest, HasDefaultAccessFlag_001, TestSize.Level1)
719 {
720 TAG_LOGI(AAFwkTag::TEST, "HasDefaultAccessFlag_001 start.");
721 const std::string configStr = R"({
722 "ams_extension_config": [{
723 "name": "FormExtension",
724 "extension_type_name": "form",
725 "ability_access" : {
726 "default_access_flag": false
727 }
728 }]
729 })";
730 ASSERT_NE(extensionConfig_, nullptr);
731 LoadTestConfig(configStr);
732
733 bool result = extensionConfig_->HasDefaultAccessFlag("form");
734 EXPECT_TRUE(result);
735 TAG_LOGI(AAFwkTag::TEST, "HasDefaultAccessFlag_001 end.");
736 }
737
738 /*
739 * @tc.number : IsExtensionStartThirdPartyAppEnableNew_001
740 * @tc.name : AbilityExtensionConfigTest
741 * @tc.desc : Test Function IsExtensionStartThirdPartyAppEnableNew
742 */
743 HWTEST_F(AbilityExtensionConfigTest, IsExtensionStartThirdPartyAppEnableNew_001, TestSize.Level1)
744 {
745 TAG_LOGI(AAFwkTag::TEST, "IsExtensionStartThirdPartyAppEnableNew_001 start.");
746 const std::string configStr = R"({
747 "ams_extension_config": []
748 })";
749 ASSERT_NE(extensionConfig_, nullptr);
750 LoadTestConfig(configStr);
751
752 bool enable = extensionConfig_->IsExtensionStartThirdPartyAppEnableNew("form",
753 "/com.acts.helloworld/entry/AllowAbility1");
754 EXPECT_TRUE(enable);
755 TAG_LOGI(AAFwkTag::TEST, "IsExtensionStartThirdPartyAppEnableNew_001 end.");
756 }
757
758 /*
759 * @tc.number : IsExtensionStartThirdPartyAppEnableNew_002
760 * @tc.name : AbilityExtensionConfigTest
761 * @tc.desc : Test Function IsExtensionStartThirdPartyAppEnableNew
762 */
763 HWTEST_F(AbilityExtensionConfigTest, IsExtensionStartThirdPartyAppEnableNew_002, TestSize.Level1)
764 {
765 TAG_LOGI(AAFwkTag::TEST, "IsExtensionStartThirdPartyAppEnableNew_002 start.");
766 const std::string configStr = R"({
767 "ams_extension_config": [{
768 "name": "FormExtension",
769 "extension_type_name": "form",
770 "ability_access" : {}
771 }]
772 })";
773 ASSERT_NE(extensionConfig_, nullptr);
774 LoadTestConfig(configStr);
775 bool enable = extensionConfig_->IsExtensionStartThirdPartyAppEnableNew("form",
776 "/com.acts.helloworld/entry/AllowAbility1");
777 EXPECT_TRUE(enable);
778 TAG_LOGI(AAFwkTag::TEST, "IsExtensionStartThirdPartyAppEnableNew_002 end.");
779 }
780
781 /*
782 * @tc.number : IsExtensionStartThirdPartyAppEnableNew_003
783 * @tc.name : AbilityExtensionConfigTest
784 * @tc.desc : Test Function IsExtensionStartThirdPartyAppEnableNew
785 */
786 HWTEST_F(AbilityExtensionConfigTest, IsExtensionStartThirdPartyAppEnableNew_003, TestSize.Level1)
787 {
788 TAG_LOGI(AAFwkTag::TEST, "IsExtensionStartThirdPartyAppEnableNew_003 start.");
789 const std::string configStr = R"({
790 "ams_extension_config": [{
791 "name": "FormExtension",
792 "extension_type_name": "form",
793 "ability_access" : {
794 "third_party_app_access_flag": false
795 }
796 }]
797 })";
798 ASSERT_NE(extensionConfig_, nullptr);
799 LoadTestConfig(configStr);
800 bool enable = extensionConfig_->IsExtensionStartThirdPartyAppEnableNew("form", "invalid_uri");
801 EXPECT_FALSE(enable);
802 TAG_LOGI(AAFwkTag::TEST, "IsExtensionStartThirdPartyAppEnableNew_003 end.");
803 }
804
805 /*
806 * @tc.number : IsExtensionStartThirdPartyAppEnableNew_004
807 * @tc.name : AbilityExtensionConfigTest
808 * @tc.desc : Test Function IsExtensionStartThirdPartyAppEnableNew
809 */
810 HWTEST_F(AbilityExtensionConfigTest, IsExtensionStartThirdPartyAppEnableNew_004, TestSize.Level1)
811 {
812 TAG_LOGI(AAFwkTag::TEST, "IsExtensionStartThirdPartyAppEnableNew_004 start.");
813 const std::string configStr = R"({
814 "ams_extension_config": [{
815 "name": "FormExtension",
816 "extension_type_name": "form",
817 "ability_access" : {
818 "third_party_app_access_flag": true
819 }
820 }]
821 })";
822 ASSERT_NE(extensionConfig_, nullptr);
823 LoadTestConfig(configStr);
824 bool enable = extensionConfig_->IsExtensionStartThirdPartyAppEnableNew("form", "invalid_uri");
825 EXPECT_TRUE(enable);
826 TAG_LOGI(AAFwkTag::TEST, "IsExtensionStartThirdPartyAppEnableNew_004 end.");
827 }
828
829 /*
830 * @tc.number : IsExtensionStartThirdPartyAppEnableNew_005
831 * @tc.name : AbilityExtensionConfigTest
832 * @tc.desc : Test Function IsExtensionStartThirdPartyAppEnableNew
833 */
834 HWTEST_F(AbilityExtensionConfigTest, IsExtensionStartThirdPartyAppEnableNew_005, TestSize.Level1)
835 {
836 TAG_LOGI(AAFwkTag::TEST, "IsExtensionStartThirdPartyAppEnableNew_005 start.");
837 const std::string configStr = R"({
838 "ams_extension_config": [{
839 "name": "FormExtension",
840 "extension_type_name": "form",
841 "ability_access" : {
842 "third_party_app_access_flag": true,
843 "blocklist" : ["/com.acts.helloworld2/entry/BlockAbility1"]
844 }
845 }]
846 })";
847 ASSERT_NE(extensionConfig_, nullptr);
848 LoadTestConfig(configStr);
849 bool enable = extensionConfig_->IsExtensionStartThirdPartyAppEnableNew("form",
850 "/com.acts.helloworld/entry/BlockAbility1");
851 EXPECT_TRUE(enable);
852 TAG_LOGI(AAFwkTag::TEST, "IsExtensionStartThirdPartyAppEnableNew_005 end.");
853 }
854
855 /*
856 * @tc.number : IsExtensionStartThirdPartyAppEnableNew_006
857 * @tc.name : AbilityExtensionConfigTest
858 * @tc.desc : Test Function IsExtensionStartThirdPartyAppEnableNew
859 */
860 HWTEST_F(AbilityExtensionConfigTest, IsExtensionStartThirdPartyAppEnableNew_006, TestSize.Level1)
861 {
862 TAG_LOGI(AAFwkTag::TEST, "IsExtensionStartThirdPartyAppEnableNew_006 start.");
863 const std::string configStr = R"({
864 "ams_extension_config": [{
865 "name": "FormExtension",
866 "extension_type_name": "form",
867 "ability_access" : {
868 "third_party_app_access_flag": true,
869 "blocklist" : ["/com.acts.helloworld/entry/BlockAbility2"]
870 }
871 }]
872 })";
873 ASSERT_NE(extensionConfig_, nullptr);
874 LoadTestConfig(configStr);
875 bool enable = extensionConfig_->IsExtensionStartThirdPartyAppEnableNew("form",
876 "/com.acts.helloworld/entry/BlockAbility1");
877 EXPECT_TRUE(enable);
878 TAG_LOGI(AAFwkTag::TEST, "IsExtensionStartThirdPartyAppEnableNew_006 end.");
879 }
880
881 /*
882 * @tc.number : IsExtensionStartThirdPartyAppEnableNew_007
883 * @tc.name : AbilityExtensionConfigTest
884 * @tc.desc : Test Function IsExtensionStartThirdPartyAppEnableNew
885 */
886 HWTEST_F(AbilityExtensionConfigTest, IsExtensionStartThirdPartyAppEnableNew_007, TestSize.Level1)
887 {
888 TAG_LOGI(AAFwkTag::TEST, "IsExtensionStartThirdPartyAppEnableNew_007 start.");
889 const std::string configStr = R"({
890 "ams_extension_config": [{
891 "name": "FormExtension",
892 "extension_type_name": "form",
893 "ability_access" : {
894 "third_party_app_access_flag": true,
895 "blocklist" : ["/com.acts.helloworld/entry/BlockAbility1"]
896 }
897 }]
898 })";
899 ASSERT_NE(extensionConfig_, nullptr);
900 LoadTestConfig(configStr);
901 bool enable = extensionConfig_->IsExtensionStartThirdPartyAppEnableNew("form",
902 "/com.acts.helloworld/entry/BlockAbility1");
903 EXPECT_FALSE(enable);
904 TAG_LOGI(AAFwkTag::TEST, "IsExtensionStartThirdPartyAppEnableNew_007 end.");
905 }
906
907 /*
908 * @tc.number : IsExtensionStartThirdPartyAppEnableNew_008
909 * @tc.name : AbilityExtensionConfigTest
910 * @tc.desc : Test Function IsExtensionStartThirdPartyAppEnableNew
911 */
912 HWTEST_F(AbilityExtensionConfigTest, IsExtensionStartThirdPartyAppEnableNew_008, TestSize.Level1)
913 {
914 TAG_LOGI(AAFwkTag::TEST, "IsExtensionStartThirdPartyAppEnableNew_008 start.");
915 const std::string configStr = R"({
916 "ams_extension_config": [{
917 "name": "FormExtension",
918 "extension_type_name": "form",
919 "ability_access" : {
920 "third_party_app_access_flag": true,
921 "blocklist" : []
922 }
923 }]
924 })";
925 ASSERT_NE(extensionConfig_, nullptr);
926 LoadTestConfig(configStr);
927 bool enable = extensionConfig_->IsExtensionStartThirdPartyAppEnableNew("form",
928 "/com.acts.helloworld/entry/BlockAbility1");
929 EXPECT_TRUE(enable);
930 TAG_LOGI(AAFwkTag::TEST, "IsExtensionStartThirdPartyAppEnableNew_008 end.");
931 }
932
933 /*
934 * @tc.number : IsExtensionStartThirdPartyAppEnableNew_009
935 * @tc.name : AbilityExtensionConfigTest
936 * @tc.desc : Test Function IsExtensionStartThirdPartyAppEnableNew
937 */
938 HWTEST_F(AbilityExtensionConfigTest, IsExtensionStartThirdPartyAppEnableNew_009, TestSize.Level1)
939 {
940 TAG_LOGI(AAFwkTag::TEST, "IsExtensionStartThirdPartyAppEnableNew_009 start.");
941 const std::string configStr = R"({
942 "ams_extension_config": [{
943 "name": "FormExtension",
944 "extension_type_name": "form",
945 "ability_access" : {
946 "third_party_app_access_flag": false,
947 "allowlist" : ["/com.acts.helloworld/entry/AllowAbility1"]
948 }
949 }]
950 })";
951 ASSERT_NE(extensionConfig_, nullptr);
952 LoadTestConfig(configStr);
953 bool enable = extensionConfig_->IsExtensionStartThirdPartyAppEnableNew("form",
954 "/com.acts.helloworld/entry/AllowAbility1");
955 EXPECT_TRUE(enable);
956 TAG_LOGI(AAFwkTag::TEST, "IsExtensionStartThirdPartyAppEnableNew_009 end.");
957 }
958
959 /*
960 * @tc.number : IsExtensionStartThirdPartyAppEnableNew_010
961 * @tc.name : AbilityExtensionConfigTest
962 * @tc.desc : Test Function IsExtensionStartThirdPartyAppEnableNew
963 */
964 HWTEST_F(AbilityExtensionConfigTest, IsExtensionStartThirdPartyAppEnableNew_010, TestSize.Level1)
965 {
966 TAG_LOGI(AAFwkTag::TEST, "IsExtensionStartThirdPartyAppEnableNew_010 start.");
967 const std::string configStr = R"({
968 "ams_extension_config": [{
969 "name": "FormExtension",
970 "extension_type_name": "form",
971 "ability_access" : {
972 "third_party_app_access_flag": false,
973 "allowlist" : []
974 }
975 }]
976 })";
977 ASSERT_NE(extensionConfig_, nullptr);
978 LoadTestConfig(configStr);
979 bool enable = extensionConfig_->IsExtensionStartThirdPartyAppEnableNew("form",
980 "/com.acts.helloworld/entry/AllowAbility1");
981 EXPECT_FALSE(enable);
982 TAG_LOGI(AAFwkTag::TEST, "IsExtensionStartThirdPartyAppEnableNew_010 end.");
983 }
984
985 /*
986 * @tc.number : IsExtensionStartServiceEnableNew_001
987 * @tc.name : AbilityExtensionConfigTest
988 * @tc.desc : Test Function IsExtensionStartServiceEnableNew
989 */
990 HWTEST_F(AbilityExtensionConfigTest, IsExtensionStartServiceEnableNew_001, TestSize.Level1)
991 {
992 TAG_LOGI(AAFwkTag::TEST, "IsExtensionStartServiceEnableNew_001 start.");
993 const std::string configStr = R"({
994 "ams_extension_config": [{
995 "name": "FormExtension",
996 "extension_type_name": "form",
997 "ability_access" : {
998 "service_access_flag": true,
999 "blocklist" : ["/com.acts.helloworld/entry/BlockAbility1"]
1000 }
1001 }]
1002 })";
1003 ASSERT_NE(extensionConfig_, nullptr);
1004 LoadTestConfig(configStr);
1005 bool enable = extensionConfig_->IsExtensionStartServiceEnableNew("form",
1006 "/com.acts.helloworld/entry/BlockAbility1");
1007 EXPECT_FALSE(enable);
1008 TAG_LOGI(AAFwkTag::TEST, "IsExtensionStartServiceEnableNew_001 end.");
1009 }
1010
1011 /*
1012 * @tc.number : IsExtensionStartServiceEnableNew_002
1013 * @tc.name : AbilityExtensionConfigTest
1014 * @tc.desc : Test Function IsExtensionStartServiceEnableNew
1015 */
1016 HWTEST_F(AbilityExtensionConfigTest, IsExtensionStartServiceEnableNew_002, TestSize.Level1)
1017 {
1018 TAG_LOGI(AAFwkTag::TEST, "IsExtensionStartServiceEnableNew_002 start.");
1019 const std::string configStr = R"({
1020 "ams_extension_config": [{
1021 "name": "FormExtension",
1022 "extension_type_name": "form",
1023 "ability_access" : {
1024 "service_access_flag": true,
1025 "blocklist" : []
1026 }
1027 }]
1028 })";
1029 ASSERT_NE(extensionConfig_, nullptr);
1030 LoadTestConfig(configStr);
1031 bool enable = extensionConfig_->IsExtensionStartServiceEnableNew("form",
1032 "/com.acts.helloworld/entry/BlockAbility1");
1033 EXPECT_TRUE(enable);
1034 TAG_LOGI(AAFwkTag::TEST, "IsExtensionStartServiceEnableNew_002 end.");
1035 }
1036
1037 /*
1038 * @tc.number : IsExtensionStartServiceEnableNew_003
1039 * @tc.name : AbilityExtensionConfigTest
1040 * @tc.desc : Test Function IsExtensionStartServiceEnableNew
1041 */
1042 HWTEST_F(AbilityExtensionConfigTest, IsExtensionStartServiceEnableNew_003, TestSize.Level1)
1043 {
1044 TAG_LOGI(AAFwkTag::TEST, "IsExtensionStartServiceEnableNew_003 start.");
1045 const std::string configStr = R"({
1046 "ams_extension_config": [{
1047 "name": "FormExtension",
1048 "extension_type_name": "form",
1049 "ability_access" : {
1050 "service_access_flag": false,
1051 "allowlist" : ["/com.acts.helloworld/entry/AllowAbility1"]
1052 }
1053 }]
1054 })";
1055 ASSERT_NE(extensionConfig_, nullptr);
1056 LoadTestConfig(configStr);
1057 bool enable = extensionConfig_->IsExtensionStartServiceEnableNew("form",
1058 "/com.acts.helloworld/entry/AllowAbility1");
1059 EXPECT_TRUE(enable);
1060 TAG_LOGI(AAFwkTag::TEST, "IsExtensionStartServiceEnableNew_003 end.");
1061 }
1062
1063 /*
1064 * @tc.number : IsExtensionStartServiceEnableNew_004
1065 * @tc.name : AbilityExtensionConfigTest
1066 * @tc.desc : Test Function IsExtensionStartServiceEnableNew
1067 */
1068 HWTEST_F(AbilityExtensionConfigTest, IsExtensionStartServiceEnableNew_004, TestSize.Level1)
1069 {
1070 TAG_LOGI(AAFwkTag::TEST, "IsExtensionStartServiceEnableNew_004 start.");
1071 const std::string configStr = R"({
1072 "ams_extension_config": [{
1073 "name": "FormExtension",
1074 "extension_type_name": "form",
1075 "ability_access" : {
1076 "service_access_flag": false,
1077 "allowlist" : []
1078 }
1079 }]
1080 })";
1081 ASSERT_NE(extensionConfig_, nullptr);
1082 LoadTestConfig(configStr);
1083 bool enable = extensionConfig_->IsExtensionStartServiceEnableNew("form",
1084 "/com.acts.helloworld/entry/AllowAbility1");
1085 EXPECT_FALSE(enable);
1086 TAG_LOGI(AAFwkTag::TEST, "IsExtensionStartServiceEnableNew_004 end.");
1087 }
1088
1089 /*
1090 * @tc.number : IsExtensionStartDefaultEnable_001
1091 * @tc.name : AbilityExtensionConfigTest
1092 * @tc.desc : Test Function IsExtensionStartDefaultEnable
1093 */
1094 HWTEST_F(AbilityExtensionConfigTest, IsExtensionStartDefaultEnable_001, TestSize.Level1)
1095 {
1096 TAG_LOGI(AAFwkTag::TEST, "IsExtensionStartDefaultEnable_001 start.");
1097 const std::string configStr = R"({
1098 "ams_extension_config": [{
1099 "name": "FormExtension",
1100 "extension_type_name": "form",
1101 "ability_access" : {
1102 "default_access_flag": true,
1103 "blocklist" : ["/com.acts.helloworld/entry/BlockAbility1"]
1104 }
1105 }]
1106 })";
1107 ASSERT_NE(extensionConfig_, nullptr);
1108 LoadTestConfig(configStr);
1109 bool enable = extensionConfig_->IsExtensionStartDefaultEnable("form",
1110 "/com.acts.helloworld/entry/BlockAbility1");
1111 EXPECT_FALSE(enable);
1112 TAG_LOGI(AAFwkTag::TEST, "IsExtensionStartDefaultEnable_001 end.");
1113 }
1114
1115 /*
1116 * @tc.number : IsExtensionStartDefaultEnable_002
1117 * @tc.name : AbilityExtensionConfigTest
1118 * @tc.desc : Test Function IsExtensionStartDefaultEnable
1119 */
1120 HWTEST_F(AbilityExtensionConfigTest, IsExtensionStartDefaultEnable_002, TestSize.Level1)
1121 {
1122 TAG_LOGI(AAFwkTag::TEST, "IsExtensionStartDefaultEnable_002 start.");
1123 const std::string configStr = R"({
1124 "ams_extension_config": [{
1125 "name": "FormExtension",
1126 "extension_type_name": "form",
1127 "ability_access" : {
1128 "default_access_flag": true,
1129 "blocklist" : []
1130 }
1131 }]
1132 })";
1133 ASSERT_NE(extensionConfig_, nullptr);
1134 LoadTestConfig(configStr);
1135 bool enable = extensionConfig_->IsExtensionStartDefaultEnable("form",
1136 "/com.acts.helloworld/entry/BlockAbility1");
1137 EXPECT_TRUE(enable);
1138 TAG_LOGI(AAFwkTag::TEST, "IsExtensionStartDefaultEnable_002 end.");
1139 }
1140
1141 /*
1142 * @tc.number : IsExtensionStartDefaultEnable_003
1143 * @tc.name : AbilityExtensionConfigTest
1144 * @tc.desc : Test Function IsExtensionStartDefaultEnable
1145 */
1146 HWTEST_F(AbilityExtensionConfigTest, IsExtensionStartDefaultEnable_003, TestSize.Level1)
1147 {
1148 TAG_LOGI(AAFwkTag::TEST, "IsExtensionStartDefaultEnable_003 start.");
1149 const std::string configStr = R"({
1150 "ams_extension_config": [{
1151 "name": "FormExtension",
1152 "extension_type_name": "form",
1153 "ability_access" : {
1154 "default_access_flag": false,
1155 "allowlist" : ["/com.acts.helloworld/entry/AllowAbility1"]
1156 }
1157 }]
1158 })";
1159 ASSERT_NE(extensionConfig_, nullptr);
1160 LoadTestConfig(configStr);
1161 bool enable = extensionConfig_->IsExtensionStartDefaultEnable("form",
1162 "/com.acts.helloworld/entry/AllowAbility1");
1163 EXPECT_TRUE(enable);
1164 TAG_LOGI(AAFwkTag::TEST, "IsExtensionStartDefaultEnable_003 end.");
1165 }
1166
1167 /*
1168 * @tc.number : IsExtensionStartDefaultEnable_004
1169 * @tc.name : AbilityExtensionConfigTest
1170 * @tc.desc : Test Function IsExtensionStartDefaultEnable
1171 */
1172 HWTEST_F(AbilityExtensionConfigTest, IsExtensionStartDefaultEnable_004, TestSize.Level1)
1173 {
1174 TAG_LOGI(AAFwkTag::TEST, "IsExtensionStartDefaultEnable_004 start.");
1175 const std::string configStr = R"({
1176 "ams_extension_config": [{
1177 "name": "FormExtension",
1178 "extension_type_name": "form",
1179 "ability_access" : {
1180 "default_access_flag": false,
1181 "allowlist" : []
1182 }
1183 }]
1184 })";
1185 ASSERT_NE(extensionConfig_, nullptr);
1186 LoadTestConfig(configStr);
1187 bool enable = extensionConfig_->IsExtensionStartDefaultEnable("form",
1188 "/com.acts.helloworld/entry/AllowAbility1");
1189 EXPECT_FALSE(enable);
1190 TAG_LOGI(AAFwkTag::TEST, "IsExtensionStartDefaultEnable_004 end.");
1191 }
1192
1193 /*
1194 * @tc.number : IsExtensionNetworkEnable_001
1195 * @tc.name : AbilityExtensionConfigTest
1196 * @tc.desc : Test Function IsExtensionNetworkEnable
1197 */
1198 HWTEST_F(AbilityExtensionConfigTest, IsExtensionNetworkEnable_001, TestSize.Level1)
1199 {
1200 TAG_LOGI(AAFwkTag::TEST, "IsExtensionNetworkEnable_001 start.");
1201 const std::string configStr = R"({
1202 "ams_extension_config": [{
1203 "name": "FormExtension",
1204 "extension_type_name": "form",
1205 "network_access_enable_flag": true
1206 }]
1207 })";
1208 ASSERT_NE(extensionConfig_, nullptr);
1209 LoadTestConfig(configStr);
1210 bool enable = extensionConfig_->IsExtensionNetworkEnable("form");
1211 EXPECT_TRUE(enable);
1212 TAG_LOGI(AAFwkTag::TEST, "IsExtensionNetworkEnable_001 end.");
1213 }
1214
1215 /*
1216 * @tc.number : IsExtensionNetworkEnable_002
1217 * @tc.name : AbilityExtensionConfigTest
1218 * @tc.desc : Test Function IsExtensionNetworkEnable
1219 */
1220 HWTEST_F(AbilityExtensionConfigTest, IsExtensionNetworkEnable_002, TestSize.Level1)
1221 {
1222 TAG_LOGI(AAFwkTag::TEST, "IsExtensionNetworkEnable_002 start.");
1223 const std::string configStr = R"({
1224 "ams_extension_config": [{
1225 "name": "FormExtension",
1226 "extension_type_name": "form",
1227 "network_access_enable_flag": "invalid_value"
1228 }]
1229 })";
1230 ASSERT_NE(extensionConfig_, nullptr);
1231 LoadTestConfig(configStr);
1232 bool enable = extensionConfig_->IsExtensionNetworkEnable("form");
1233 EXPECT_TRUE(enable);
1234 TAG_LOGI(AAFwkTag::TEST, "IsExtensionNetworkEnable_001 end.");
1235 }
1236
1237 /*
1238 * @tc.number : IsExtensionNetworkEnable_003
1239 * @tc.name : AbilityExtensionConfigTest
1240 * @tc.desc : Test Function IsExtensionNetworkEnable
1241 */
1242 HWTEST_F(AbilityExtensionConfigTest, IsExtensionNetworkEnable_003, TestSize.Level1)
1243 {
1244 TAG_LOGI(AAFwkTag::TEST, "IsExtensionNetworkEnable_003 start.");
1245 const std::string configStr = R"({
1246 "ams_extension_config": [{
1247 "name": "FormExtension",
1248 "extension_type_name": "form",
1249 "network_access_enable_flag": false
1250 }]
1251 })";
1252 ASSERT_NE(extensionConfig_, nullptr);
1253 LoadTestConfig(configStr);
1254 bool enable = extensionConfig_->IsExtensionNetworkEnable("form");
1255 EXPECT_FALSE(enable);
1256 TAG_LOGI(AAFwkTag::TEST, "IsExtensionNetworkEnable_003 end.");
1257 }
1258
1259 /*
1260 * @tc.number : IsExtensionSAEnable_001
1261 * @tc.name : AbilityExtensionConfigTest
1262 * @tc.desc : Test Function IsExtensionSAEnable
1263 */
1264 HWTEST_F(AbilityExtensionConfigTest, IsExtensionSAEnable_001, TestSize.Level1)
1265 {
1266 TAG_LOGI(AAFwkTag::TEST, "IsExtensionSAEnable_001 start.");
1267 const std::string configStr = R"({
1268 "ams_extension_config": [{
1269 "name": "FormExtension",
1270 "extension_type_name": "form",
1271 "sa_access_enable_flag": true
1272 }]
1273 })";
1274 ASSERT_NE(extensionConfig_, nullptr);
1275 LoadTestConfig(configStr);
1276 bool enable = extensionConfig_->IsExtensionSAEnable("form");
1277 EXPECT_TRUE(enable);
1278 TAG_LOGI(AAFwkTag::TEST, "IsExtensionSAEnable_001 end.");
1279 }
1280
1281 /*
1282 * @tc.number : IsExtensionSAEnable_002
1283 * @tc.name : AbilityExtensionConfigTest
1284 * @tc.desc : Test Function IsExtensionSAEnable
1285 */
1286 HWTEST_F(AbilityExtensionConfigTest, IsExtensionSAEnable_002, TestSize.Level1)
1287 {
1288 TAG_LOGI(AAFwkTag::TEST, "IsExtensionSAEnable_002 start.");
1289 const std::string configStr = R"({
1290 "ams_extension_config": [{
1291 "name": "FormExtension",
1292 "extension_type_name": "form",
1293 "sa_access_enable_flag": "invalid_value"
1294 }]
1295 })";
1296 ASSERT_NE(extensionConfig_, nullptr);
1297 LoadTestConfig(configStr);
1298 bool enable = extensionConfig_->IsExtensionSAEnable("form");
1299 EXPECT_TRUE(enable);
1300 TAG_LOGI(AAFwkTag::TEST, "IsExtensionSAEnable_002 end.");
1301 }
1302
1303 /*
1304 * @tc.number : IsExtensionSAEnable_003
1305 * @tc.name : AbilityExtensionConfigTest
1306 * @tc.desc : Test Function IsExtensionSAEnable
1307 */
1308 HWTEST_F(AbilityExtensionConfigTest, IsExtensionSAEnable_003, TestSize.Level1)
1309 {
1310 TAG_LOGI(AAFwkTag::TEST, "IsExtensionSAEnable_003 start.");
1311 const std::string configStr = R"({
1312 "ams_extension_config": [{
1313 "name": "FormExtension",
1314 "extension_type_name": "form",
1315 "sa_access_enable_flag": false
1316 }]
1317 })";
1318 ASSERT_NE(extensionConfig_, nullptr);
1319 LoadTestConfig(configStr);
1320 bool enable = extensionConfig_->IsExtensionSAEnable("form");
1321 EXPECT_FALSE(enable);
1322 TAG_LOGI(AAFwkTag::TEST, "IsExtensionSAEnable_003 end.");
1323 }
1324
1325 /*
1326 * @tc.number : IsScreenUnlockIntercept_001
1327 * @tc.name : AbilityExtensionConfigTest
1328 * @tc.desc : Test Function IsScreenUnlockIntercept
1329 */
1330 HWTEST_F(AbilityExtensionConfigTest, IsScreenUnlockIntercept_001, TestSize.Level1)
1331 {
1332 TAG_LOGI(AAFwkTag::TEST, "IsScreenUnlockIntercept_001 start.");
1333 const std::string configStr = R"({
1334 "ams_extension_config": [{
1335 "name": "FormExtension",
1336 "extension_type_name": "form",
1337 "screen_unlock_intercept": true
1338 }]
1339 })";
1340 ASSERT_NE(extensionConfig_, nullptr);
1341 LoadTestConfig(configStr);
1342 bool flag = extensionConfig_->IsScreenUnlockIntercept("form", false);
1343 EXPECT_TRUE(flag);
1344 TAG_LOGI(AAFwkTag::TEST, "IsScreenUnlockIntercept_001 end.");
1345 }
1346
1347 /*
1348 * @tc.number : IsScreenUnlockIntercept_002
1349 * @tc.name : AbilityExtensionConfigTest
1350 * @tc.desc : Test Function IsScreenUnlockIntercept
1351 */
1352 HWTEST_F(AbilityExtensionConfigTest, IsScreenUnlockIntercept_002, TestSize.Level1)
1353 {
1354 TAG_LOGI(AAFwkTag::TEST, "IsScreenUnlockIntercept_002 start.");
1355 const std::string configStr = R"({
1356 "ams_extension_config": [{
1357 "name": "FormExtension",
1358 "extension_type_name": "form",
1359 "screen_unlock_intercept": "invalid_value"
1360 }]
1361 })";
1362 ASSERT_NE(extensionConfig_, nullptr);
1363 LoadTestConfig(configStr);
1364 bool flag = extensionConfig_->IsScreenUnlockIntercept("form", false);
1365 EXPECT_FALSE(flag);
1366 TAG_LOGI(AAFwkTag::TEST, "IsScreenUnlockIntercept_002 end.");
1367 }
1368
1369 /*
1370 * @tc.number : IsScreenUnlockIntercept_003
1371 * @tc.name : AbilityExtensionConfigTest
1372 * @tc.desc : Test Function IsScreenUnlockIntercept
1373 */
1374 HWTEST_F(AbilityExtensionConfigTest, IsScreenUnlockIntercept_003, TestSize.Level1)
1375 {
1376 TAG_LOGI(AAFwkTag::TEST, "IsScreenUnlockIntercept_003 start.");
1377 const std::string configStr = R"({
1378 "ams_extension_config": [{
1379 "name": "FormExtension",
1380 "extension_type_name": "form"
1381 }]
1382 })";
1383 ASSERT_NE(extensionConfig_, nullptr);
1384 LoadTestConfig(configStr);
1385 bool flag = extensionConfig_->IsScreenUnlockIntercept("form", false);
1386 EXPECT_FALSE(flag);
1387 TAG_LOGI(AAFwkTag::TEST, "IsScreenUnlockIntercept_003 end.");
1388 }
1389
1390 /*
1391 * @tc.number : IsScreenUnlockIntercept_004
1392 * @tc.name : AbilityExtensionConfigTest
1393 * @tc.desc : Test Function IsScreenUnlockIntercept
1394 */
1395 HWTEST_F(AbilityExtensionConfigTest, IsScreenUnlockIntercept_004, TestSize.Level1)
1396 {
1397 TAG_LOGI(AAFwkTag::TEST, "IsScreenUnlockIntercept_004 start.");
1398 const std::string configStr = R"({
1399 "ams_extension_config": [{
1400 "name": "FormExtension",
1401 "extension_type_name": "form",
1402 "screen_unlock_intercept": true
1403 }]
1404 })";
1405 ASSERT_NE(extensionConfig_, nullptr);
1406 LoadTestConfig(configStr);
1407 bool flag = extensionConfig_->IsScreenUnlockIntercept("push", false);
1408 EXPECT_FALSE(flag);
1409 TAG_LOGI(AAFwkTag::TEST, "IsScreenUnlockIntercept_004 end.");
1410 }
1411
1412 /*
1413 * @tc.number : IsScreenUnlockIntercept_005
1414 * @tc.name : AbilityExtensionConfigTest
1415 * @tc.desc : Test Function IsScreenUnlockIntercept
1416 */
1417 HWTEST_F(AbilityExtensionConfigTest, IsScreenUnlockIntercept_005, TestSize.Level1)
1418 {
1419 TAG_LOGI(AAFwkTag::TEST, "IsScreenUnlockIntercept_005 start.");
1420 const std::string configStr = R"({
1421 "ams_extension_config": [{
1422 "name": "FormExtension",
1423 "extension_type_name": "form",
1424 "screen_unlock_intercept": true,
1425 "screen_unlock_intercept_exclude_system_app": true
1426 }]
1427 })";
1428 ASSERT_NE(extensionConfig_, nullptr);
1429 LoadTestConfig(configStr);
1430 bool flag = extensionConfig_->IsScreenUnlockIntercept("form", true);
1431 EXPECT_FALSE(flag);
1432 TAG_LOGI(AAFwkTag::TEST, "IsScreenUnlockIntercept_005 end.");
1433 }
1434
1435 /*
1436 * @tc.number : IsScreenUnlockIntercept_006
1437 * @tc.name : AbilityExtensionConfigTest
1438 * @tc.desc : Test Function IsScreenUnlockIntercept
1439 */
1440 HWTEST_F(AbilityExtensionConfigTest, IsScreenUnlockIntercept_006, TestSize.Level1)
1441 {
1442 TAG_LOGI(AAFwkTag::TEST, "IsScreenUnlockInterceIsScreenUnlockIntercept_006 start.");
1443 const std::string configStr = R"({
1444 "ams_extension_config": [{
1445 "name": "FormExtension",
1446 "extension_type_name": "form",
1447 "screen_unlock_intercept": true,
1448 "screen_unlock_intercept_exclude_system_app": false
1449 }]
1450 })";
1451 ASSERT_NE(extensionConfig_, nullptr);
1452 LoadTestConfig(configStr);
1453 bool flag = extensionConfig_->IsScreenUnlockIntercept("form", true);
1454 EXPECT_TRUE(flag);
1455 TAG_LOGI(AAFwkTag::TEST, "IsScreenUnlockIntercept_006 end.");
1456 }
1457
1458 /*
1459 * @tc.number : IsScreenUnlockIntercept_007
1460 * @tc.name : AbilityExtensionConfigTest
1461 * @tc.desc : Test Function IsScreenUnlockIntercept
1462 */
1463 HWTEST_F(AbilityExtensionConfigTest, IsScreenUnlockIntercept_007, TestSize.Level1)
1464 {
1465 TAG_LOGI(AAFwkTag::TEST, "IsScreenUnlockIntercept_007 start.");
1466 const std::string configStr = R"({
1467 "ams_extension_config": [{
1468 "name": "FormExtension",
1469 "extension_type_name": "form",
1470 "screen_unlock_intercept": true
1471 }]
1472 })";
1473 ASSERT_NE(extensionConfig_, nullptr);
1474 LoadTestConfig(configStr);
1475 bool flag = extensionConfig_->IsScreenUnlockIntercept("form", true);
1476 EXPECT_TRUE(flag);
1477 TAG_LOGI(AAFwkTag::TEST, "IsScreenUnlockIntercept_007 end.");
1478 }
1479
1480 /*
1481 * @tc.number : IsScreenUnlockIntercept_008
1482 * @tc.name : AbilityExtensionConfigTest
1483 * @tc.desc : Test Function IsScreenUnlockIntercept
1484 */
1485 HWTEST_F(AbilityExtensionConfigTest, IsScreenUnlockIntercept_008, TestSize.Level1)
1486 {
1487 TAG_LOGI(AAFwkTag::TEST, "IsScreenUnlockIntercept_008 start.");
1488 const std::string configStr = R"({
1489 "ams_extension_config": [{
1490 "name": "FormExtension",
1491 "extension_type_name": "form",
1492 "screen_unlock_intercept": true,
1493 "screen_unlock_intercept_exclude_system_app": "invalid value"
1494 }]
1495 })";
1496 ASSERT_NE(extensionConfig_, nullptr);
1497 LoadTestConfig(configStr);
1498 bool flag = extensionConfig_->IsScreenUnlockIntercept("form", true);
1499 EXPECT_TRUE(flag);
1500 TAG_LOGI(AAFwkTag::TEST, "IsScreenUnlockIntercept_008 end.");
1501 }
1502 }
1503 }
1504