1 /* 2 * Copyright (c) 2022-2023 Huawei Device Co., Ltd. 3 * Licensed under the Apache License, Version 2.0 (the "License"); 4 * you may not use this file except in compliance with the License. 5 * You may obtain a copy of the License at 6 * 7 * http://www.apache.org/licenses/LICENSE-2.0 8 * 9 * Unless required by applicable law or agreed to in writing, software 10 * distributed under the License is distributed on an "AS IS" BASIS, 11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 * See the License for the specific language governing permissions and 13 * limitations under the License. 14 */ 15 16 #include <cstdio> 17 #include <fcntl.h> 18 #include <gtest/gtest.h> 19 #include <string_view> 20 #include <sys/stat.h> 21 #include <sys/types.h> 22 #include <unistd.h> 23 #include <vector> 24 25 #include "b_json/b_json_cached_entity.h" 26 #include "b_json/b_json_entity_caps.h" 27 #include "b_json/b_json_entity_extension_config.h" 28 #include "b_process/b_process.h" 29 #include "b_resources/b_constants.h" 30 #include "directory_ex.h" 31 #include "file_ex.h" 32 #include "parameter.h" 33 #include "test_manager.h" 34 #include "json/value.h" 35 36 namespace OHOS::FileManagement::Backup { 37 using namespace std; 38 39 class BJsonEntityExtensionConfigTest : public testing::Test { 40 public: SetUpTestCase(void)41 static void SetUpTestCase(void) {}; TearDownTestCase()42 static void TearDownTestCase() {}; SetUp()43 void SetUp() {}; TearDown()44 void TearDown() {}; 45 }; 46 47 static vector<string> DEFAULT_INCLUDE_DIR = { 48 "data/storage/el2/database/", 49 "data/storage/el2/base/files/", 50 "data/storage/el2/base/preferences/", 51 "data/storage/el2/base/haps/*/database/", 52 "data/storage/el2/base/haps/*/files/", 53 "data/storage/el2/base/haps/*/preferences/", 54 }; 55 static vector<string> DEFAULT_EXCLUDE_DIR = {}; 56 57 /** 58 * @tc.number: SUB_backup_b_json_entity_extension_config_0100 59 * @tc.name: b_json_entity_extension_config_0100 60 * @tc.desc: 不包含includes和excludes 61 * @tc.size: MEDIUM 62 * @tc.type: FUNC 63 * @tc.level Level 0 64 * @tc.require: I6F3GV 65 */ 66 HWTEST_F(BJsonEntityExtensionConfigTest, b_json_entity_extension_config_0100, testing::ext::TestSize.Level0) 67 { 68 GTEST_LOG_(INFO) << "BJsonEntityExtensionConfigTest-begin b_json_entity_extension_config_0100"; 69 try { 70 TestManager tm("b_json_entity_extension_config_0100"); 71 72 string root = tm.GetRootDirCurTest(); 73 string pathConfigFile = root + "config.json"; 74 SaveStringToFile(pathConfigFile, ""); 75 76 BJsonCachedEntity<BJsonEntityExtensionConfig> cachedEntity(UniqueFd(open(pathConfigFile.data(), O_RDONLY, 0))); 77 auto cache = cachedEntity.Structuralize(); 78 vector<string> includes = cache.GetIncludes(); 79 EXPECT_EQ(includes, DEFAULT_INCLUDE_DIR); 80 vector<string> excludes = cache.GetExcludes(); 81 EXPECT_EQ(excludes, DEFAULT_EXCLUDE_DIR); 82 } catch (...) { 83 EXPECT_TRUE(false); 84 GTEST_LOG_(INFO) << "BJsonEntityExtensionConfigTest-an exception occurred by construction."; 85 } 86 GTEST_LOG_(INFO) << "BJsonEntityExtensionConfigTest-end b_json_entity_extension_config_0100"; 87 } 88 89 /** 90 * @tc.number: SUB_backup_b_json_entity_extension_config_0200 91 * @tc.name: b_json_entity_extension_config_0200 92 * @tc.desc: json文件中只包含includes 93 * @tc.size: MEDIUM 94 * @tc.type: FUNC 95 * @tc.level Level 0 96 * @tc.require: I6F3GV 97 */ 98 HWTEST_F(BJsonEntityExtensionConfigTest, b_json_entity_extension_config_0200, testing::ext::TestSize.Level0) 99 { 100 GTEST_LOG_(INFO) << "BJsonEntityExtensionConfigTest-begin b_json_entity_extension_config_0200"; 101 try { 102 TestManager tm("b_json_entity_extension_config_0200"); 103 104 string root = tm.GetRootDirCurTest(); 105 string pathConfigFile = root + "config.json"; 106 SaveStringToFile(pathConfigFile, R"({"includes":["", "", ""]})"); 107 108 BJsonCachedEntity<BJsonEntityExtensionConfig> cachedEntity(UniqueFd(open(pathConfigFile.data(), O_RDONLY, 0))); 109 auto cache = cachedEntity.Structuralize(); 110 vector<string> includes = cache.GetIncludes(); 111 vector<string> includesExpect = {"", "", ""}; 112 EXPECT_EQ(includes, includesExpect); 113 } catch (...) { 114 EXPECT_TRUE(false); 115 GTEST_LOG_(INFO) << "BJsonEntityExtensionConfigTest-an exception occurred by construction."; 116 } 117 GTEST_LOG_(INFO) << "BJsonEntityExtensionConfigTest-end b_json_entity_extension_config_0200"; 118 } 119 120 /** 121 * @tc.number: SUB_backup_b_json_entity_extension_config_0300 122 * @tc.name: b_json_entity_extension_config_0300 123 * @tc.desc: json文件中只包含excludes 124 * @tc.size: MEDIUM 125 * @tc.type: FUNC 126 * @tc.level Level 0 127 * @tc.require: I6F3GV 128 */ 129 HWTEST_F(BJsonEntityExtensionConfigTest, b_json_entity_extension_config_0300, testing::ext::TestSize.Level0) 130 { 131 GTEST_LOG_(INFO) << "BJsonEntityExtensionConfigTest-begin b_json_entity_extension_config_0300"; 132 try { 133 TestManager tm("b_json_entity_extension_config_0300"); 134 135 string root = tm.GetRootDirCurTest(); 136 string pathConfigFile = root + "config.json"; 137 SaveStringToFile(pathConfigFile, R"({"excludes":["", "", ""]})"); 138 139 BJsonCachedEntity<BJsonEntityExtensionConfig> cachedEntity(UniqueFd(open(pathConfigFile.data(), O_RDONLY, 0))); 140 auto cache = cachedEntity.Structuralize(); 141 vector<string> excludes = cache.GetExcludes(); 142 vector<string> excludesExpect = {"", "", ""}; 143 EXPECT_EQ(excludes, excludesExpect); 144 } catch (...) { 145 EXPECT_TRUE(false); 146 GTEST_LOG_(INFO) << "BJsonEntityExtensionConfigTest-an exception occurred by construction."; 147 } 148 GTEST_LOG_(INFO) << "BJsonEntityExtensionConfigTest-end b_json_entity_extension_config_0300"; 149 } 150 151 /** 152 * @tc.number: SUB_backup_b_json_entity_extension_config_0400 153 * @tc.name: b_json_entity_extension_config_0400 154 * @tc.desc: 同时包含includes和excludes 155 * @tc.size: MEDIUM 156 * @tc.type: FUNC 157 * @tc.level Level 0 158 * @tc.require: I6F3GV 159 */ 160 HWTEST_F(BJsonEntityExtensionConfigTest, b_json_entity_extension_config_0400, testing::ext::TestSize.Level0) 161 { 162 GTEST_LOG_(INFO) << "BJsonEntityExtensionConfigTest-begin b_json_entity_extension_config_0400"; 163 try { 164 TestManager tm("b_json_entity_extension_config_0400"); 165 166 string root = tm.GetRootDirCurTest(); 167 string pathConfigFile = root + "config.json"; 168 SaveStringToFile(pathConfigFile, R"({"includes":["", "", ""], "excludes":["", "", ""]})"); 169 170 BJsonCachedEntity<BJsonEntityExtensionConfig> cachedEntity(UniqueFd(open(pathConfigFile.data(), O_RDONLY, 0))); 171 auto cache = cachedEntity.Structuralize(); 172 vector<string> includes = cache.GetIncludes(); 173 vector<string> includesExpect = {"", "", ""}; 174 EXPECT_EQ(includes, includesExpect); 175 vector<string> excludes = cache.GetExcludes(); 176 vector<string> excludesExpect = {"", "", ""}; 177 EXPECT_EQ(excludes, excludesExpect); 178 } catch (...) { 179 EXPECT_TRUE(false); 180 GTEST_LOG_(INFO) << "BJsonEntityExtensionConfigTest-an exception occurred by construction."; 181 } 182 GTEST_LOG_(INFO) << "BJsonEntityExtensionConfigTest-end b_json_entity_extension_config_0400"; 183 } 184 185 /** 186 * @tc.number: SUB_backup_b_json_entity_extension_config_0500 187 * @tc.name: b_json_entity_extension_config_0500 188 * @tc.desc: json文件中标签为特殊字符 189 * @tc.size: MEDIUM 190 * @tc.type: FUNC 191 * @tc.level Level 2 192 * @tc.require: I6F3GV 193 */ 194 HWTEST_F(BJsonEntityExtensionConfigTest, b_json_entity_extension_config_0500, testing::ext::TestSize.Level2) 195 { 196 GTEST_LOG_(INFO) << "BJsonEntityExtensionConfigTest-begin b_json_entity_extension_config_0500"; 197 try { 198 TestManager tm("b_json_entity_extension_config_0500"); 199 200 string root = tm.GetRootDirCurTest(); 201 string pathConfigFile = root + "config.json"; 202 SaveStringToFile(pathConfigFile, R"({"%#$%445":["", "", ""]})"); 203 204 BJsonCachedEntity<BJsonEntityExtensionConfig> cachedEntity(UniqueFd(open(pathConfigFile.data(), O_RDONLY, 0))); 205 auto cache = cachedEntity.Structuralize(); 206 vector<string> includes = cache.GetIncludes(); 207 vector<string> includesExpect = {DEFAULT_INCLUDE_DIR}; 208 EXPECT_EQ(includes, includesExpect); 209 vector<string> excludes = cache.GetExcludes(); 210 vector<string> excludesExpect = {DEFAULT_EXCLUDE_DIR}; 211 EXPECT_EQ(excludes, excludesExpect); 212 } catch (...) { 213 EXPECT_TRUE(false); 214 GTEST_LOG_(INFO) << "BJsonEntityExtensionConfigTest-an exception occurred by construction."; 215 } 216 GTEST_LOG_(INFO) << "BJsonEntityExtensionConfigTest-end b_json_entity_extension_config_0500"; 217 } 218 219 /** 220 * @tc.number: SUB_backup_b_json_entity_extension_config_0600 221 * @tc.name: b_json_entity_extension_config_0600 222 * @tc.desc: json文件中标签为中文汉字 223 * @tc.size: MEDIUM 224 * @tc.type: FUNC 225 * @tc.level Level 2 226 * @tc.require: I6F3GV 227 */ 228 HWTEST_F(BJsonEntityExtensionConfigTest, b_json_entity_extension_config_0600, testing::ext::TestSize.Level2) 229 { 230 GTEST_LOG_(INFO) << "BJsonEntityExtensionConfigTest-begin b_json_entity_extension_config_0600"; 231 try { 232 TestManager tm("b_json_entity_extension_config_0600"); 233 234 string root = tm.GetRootDirCurTest(); 235 string pathConfigFile = root + "config.json"; 236 SaveStringToFile(pathConfigFile, R"({"测试代码":["", "", ""]})"); 237 238 BJsonCachedEntity<BJsonEntityExtensionConfig> cachedEntity(UniqueFd(open(pathConfigFile.data(), O_RDONLY, 0))); 239 auto cache = cachedEntity.Structuralize(); 240 vector<string> includes = cache.GetIncludes(); 241 EXPECT_EQ(includes, DEFAULT_INCLUDE_DIR); 242 vector<string> excludes = cache.GetExcludes(); 243 EXPECT_EQ(excludes, DEFAULT_EXCLUDE_DIR); 244 } catch (...) { 245 EXPECT_TRUE(false); 246 GTEST_LOG_(INFO) << "BJsonEntityExtensionConfigTest-an exception occurred by construction."; 247 } 248 GTEST_LOG_(INFO) << "BJsonEntityExtensionConfigTest-end b_json_entity_extension_config_0600"; 249 } 250 251 /** 252 * @tc.number: SUB_backup_b_json_entity_extension_config_0700 253 * @tc.name: b_json_entity_extension_config_0700 254 * @tc.desc: json文件中无标签 255 * @tc.size: MEDIUM 256 * @tc.type: FUNC 257 * @tc.level Level 2 258 * @tc.require: I6F3GV 259 */ 260 HWTEST_F(BJsonEntityExtensionConfigTest, b_json_entity_extension_config_0700, testing::ext::TestSize.Level2) 261 { 262 GTEST_LOG_(INFO) << "BJsonEntityExtensionConfigTest-begin b_json_entity_extension_config_0700"; 263 try { 264 TestManager tm("b_json_entity_extension_config_0700"); 265 266 string root = tm.GetRootDirCurTest(); 267 string pathConfigFile = root + "config.json"; 268 SaveStringToFile(pathConfigFile, R"({"":["", "", ""]})"); 269 270 BJsonCachedEntity<BJsonEntityExtensionConfig> cachedEntity(UniqueFd(open(pathConfigFile.data(), O_RDONLY, 0))); 271 auto cache = cachedEntity.Structuralize(); 272 vector<string> includes = cache.GetIncludes(); 273 EXPECT_EQ(includes, DEFAULT_INCLUDE_DIR); 274 vector<string> excludes = cache.GetExcludes(); 275 EXPECT_EQ(excludes, DEFAULT_EXCLUDE_DIR); 276 } catch (...) { 277 EXPECT_TRUE(false); 278 GTEST_LOG_(INFO) << "BJsonEntityExtensionConfigTest-an exception occurred by construction."; 279 } 280 GTEST_LOG_(INFO) << "BJsonEntityExtensionConfigTest-end b_json_entity_extension_config_0700"; 281 } 282 283 /** 284 * @tc.number: SUB_backup_b_json_entity_extension_config_0800 285 * @tc.name: b_json_entity_extension_config_0800 286 * @tc.desc: json文件标签中有异常引号 287 * @tc.size: MEDIUM 288 * @tc.type: FUNC 289 * @tc.level Level 2 290 * @tc.require: I6F3GV 291 */ 292 HWTEST_F(BJsonEntityExtensionConfigTest, b_json_entity_extension_config_0800, testing::ext::TestSize.Level2) 293 { 294 GTEST_LOG_(INFO) << "BJsonEntityExtensionConfigTest-begin b_json_entity_extension_config_0800"; 295 try { 296 TestManager tm("b_json_entity_extension_config_0800"); 297 298 string root = tm.GetRootDirCurTest(); 299 string pathConfigFile = root + "config.json"; 300 SaveStringToFile( 301 pathConfigFile, 302 R"({"includes":["", "", ""], "excludes":["", "", ""], """""""""""""""""""""""""""""""""""""""""""""""""":[]})"); 303 304 BJsonCachedEntity<BJsonEntityExtensionConfig> cachedEntity(UniqueFd(open(pathConfigFile.data(), O_RDONLY, 0))); 305 auto cache = cachedEntity.Structuralize(); 306 vector<string> includes = cache.GetIncludes(); 307 EXPECT_EQ(includes, DEFAULT_INCLUDE_DIR); 308 vector<string> excludes = cache.GetExcludes(); 309 EXPECT_EQ(excludes, DEFAULT_EXCLUDE_DIR); 310 } catch (...) { 311 EXPECT_TRUE(false); 312 GTEST_LOG_(INFO) << "BJsonEntityExtensionConfigTest-an exception occurred by construction."; 313 } 314 GTEST_LOG_(INFO) << "BJsonEntityExtensionConfigTest-end b_json_entity_extension_config_0800"; 315 } 316 317 /** 318 * @tc.number: SUB_backup_b_json_entity_extension_config_0900 319 * @tc.name: b_json_entity_extension_config_0900 320 * @tc.desc: 测试GetJSonSource接口能否在非service进程下正确读取backup_config.json 321 * @tc.size: MEDIUM 322 * @tc.type: FUNC 323 * @tc.level Level 2 324 * @tc.require: I6F3GV 325 */ 326 HWTEST_F(BJsonEntityExtensionConfigTest, b_json_entity_extension_config_0900, testing::ext::TestSize.Level2) 327 { 328 GTEST_LOG_(INFO) << "BJsonEntityExtensionConfigTest-begin b_json_entity_extension_config_0900"; 329 try { 330 string jsonContent = R"({"allowToBackupRestore":true})"; 331 auto [bFatalErr, ret] = BProcess::ExecuteCmd({"mkdir", "-p", BConstants::BACKUP_CONFIG_EXTENSION_PATH}); 332 EXPECT_FALSE(bFatalErr); 333 EXPECT_EQ(ret, 0); 334 string jsonFilePath = string(BConstants::BACKUP_CONFIG_EXTENSION_PATH).append(BConstants::BACKUP_CONFIG_JSON); 335 SaveStringToFile(jsonFilePath, jsonContent); 336 string_view sv = R"({"allowToBackupRestore":false})"; 337 SetMockParameter(true); 338 BJsonCachedEntity<BJsonEntityExtensionConfig> cachedEntity(sv); 339 auto cache = cachedEntity.Structuralize(); 340 string jsonRead = cache.GetJSonSource(sv, any()); 341 EXPECT_NE(jsonRead, jsonContent); 342 } catch (...) { 343 EXPECT_TRUE(false); 344 GTEST_LOG_(INFO) << "BJsonEntityExtensionConfigTest-an exception occurred by GetJSonSource."; 345 } 346 GTEST_LOG_(INFO) << "BJsonEntityExtensionConfigTest-end b_json_entity_extension_config_0900"; 347 } 348 349 /** 350 * @tc.number: SUB_backup_b_json_entity_extension_config_1000 351 * @tc.name: b_json_entity_extension_config_1000 352 * @tc.desc: 测试GetJSonSource接口能否在service进程下正确读取backup_config.json 353 * @tc.size: MEDIUM 354 * @tc.type: FUNC 355 * @tc.level Level 2 356 * @tc.require: I6F3GV 357 */ 358 HWTEST_F(BJsonEntityExtensionConfigTest, b_json_entity_extension_config_1000, testing::ext::TestSize.Level2) 359 { 360 GTEST_LOG_(INFO) << "BJsonEntityExtensionConfigTest-begin b_json_entity_extension_config_1000"; 361 try { 362 string bundleName = "com.example.app2backup"; 363 string jsonFileDir = BConstants::GetSaBundleBackupRootDir(BConstants::DEFAULT_USER_ID).append(bundleName); 364 string jsonContent = R"({"allowToBackupRestore":true})"; 365 auto [bFatalErr, ret] = BProcess::ExecuteCmd({"mkdir", "-p", jsonFileDir}); 366 EXPECT_FALSE(bFatalErr); 367 EXPECT_EQ(ret, 0); 368 string jsonFilePath = jsonFileDir.append("/").append(BConstants::BACKUP_CONFIG_JSON); 369 SaveStringToFile(jsonFilePath, jsonContent); 370 uid_t currUid = getuid(); 371 setuid(BConstants::BACKUP_UID); 372 string_view sv = R"({"allowToBackupRestore":false})"; 373 SetMockParameter(true); 374 BJsonCachedEntity<BJsonEntityExtensionConfig> cachedEntity(sv, bundleName); 375 auto cache = cachedEntity.Structuralize(); 376 string jsonRead = cache.GetJSonSource(sv, bundleName); 377 setuid(currUid); 378 EXPECT_NE(jsonRead, jsonContent); 379 } catch (...) { 380 EXPECT_TRUE(false); 381 GTEST_LOG_(INFO) << "BJsonEntityExtensionConfigTest-an exception occurred by GetJSonSource."; 382 } 383 GTEST_LOG_(INFO) << "BJsonEntityExtensionConfigTest-end b_json_entity_extension_config_1000"; 384 } 385 386 /** 387 * @tc.number: SUB_backup_b_json_entity_extension_config_1100 388 * @tc.name: b_json_entity_extension_config_1100 389 * @tc.desc: 测试GetJSonSource接口能否在backup.debug.overrideExtensionConfig为false的情况下保持原JSon字符串不变 390 * @tc.size: MEDIUM 391 * @tc.type: FUNC 392 * @tc.level Level 2 393 * @tc.require: I6F3GV 394 */ 395 HWTEST_F(BJsonEntityExtensionConfigTest, b_json_entity_extension_config_1100, testing::ext::TestSize.Level2) 396 { 397 GTEST_LOG_(INFO) << "BJsonEntityExtensionConfigTest-begin b_json_entity_extension_config_1100"; 398 try { 399 string_view sv = R"({"allowToBackupRestore":false})"; 400 SetMockParameter(false); 401 BJsonCachedEntity<BJsonEntityExtensionConfig> cachedEntity(sv); 402 auto cache = cachedEntity.Structuralize(); 403 string jsonRead = cache.GetJSonSource(sv, any()); 404 EXPECT_EQ(jsonRead, string(sv)); 405 } catch (...) { 406 EXPECT_TRUE(false); 407 GTEST_LOG_(INFO) << "BJsonEntityExtensionConfigTest-an exception occurred by GetJSonSource."; 408 } 409 GTEST_LOG_(INFO) << "BJsonEntityExtensionConfigTest-end b_json_entity_extension_config_1100"; 410 } 411 412 /** 413 * @tc.number: SUB_backup_b_json_entity_extension_config_1200 414 * @tc.name: b_json_entity_extension_config_1200 415 * @tc.desc: 测试GetIncludes接口在Json数据中键为includes的值不为数组时能否成功返回默认目录 416 * @tc.size: MEDIUM 417 * @tc.type: FUNC 418 * @tc.level Level 2 419 * @tc.require: I6F3GV 420 */ 421 HWTEST_F(BJsonEntityExtensionConfigTest, b_json_entity_extension_config_1200, testing::ext::TestSize.Level2) 422 { 423 GTEST_LOG_(INFO) << "BJsonEntityExtensionConfigTest-begin b_json_entity_extension_config_1200"; 424 try { 425 string_view sv = R"({"includes":1})"; 426 BJsonCachedEntity<BJsonEntityExtensionConfig> cachedEntity(sv); 427 auto cache = cachedEntity.Structuralize(); 428 vector<string> vs = cache.GetIncludes(); 429 EXPECT_EQ(vs, DEFAULT_INCLUDE_DIR); 430 } catch (...) { 431 EXPECT_TRUE(false); 432 GTEST_LOG_(INFO) << "BJsonEntityExtensionConfigTest-an exception occurred by GetIncludes."; 433 } 434 GTEST_LOG_(INFO) << "BJsonEntityExtensionConfigTest-end b_json_entity_extension_config_1200"; 435 } 436 437 /** 438 * @tc.number: SUB_backup_b_json_entity_extension_config_1300 439 * @tc.name: b_json_entity_extension_config_1300 440 * @tc.desc: 测试GetIncludes接口在Json数据中键为includes的值为数组且数组元素全都不为字符串时能否成功返回空目录 441 * @tc.size: MEDIUM 442 * @tc.type: FUNC 443 * @tc.level Level 2 444 * @tc.require: I6F3GV 445 */ 446 HWTEST_F(BJsonEntityExtensionConfigTest, b_json_entity_extension_config_1300, testing::ext::TestSize.Level2) 447 { 448 GTEST_LOG_(INFO) << "BJsonEntityExtensionConfigTest-begin b_json_entity_extension_config_1300"; 449 try { 450 string_view sv = R"({"includes":[1]})"; 451 BJsonCachedEntity<BJsonEntityExtensionConfig> cachedEntity(sv); 452 auto cache = cachedEntity.Structuralize(); 453 vector<string> vs = cache.GetIncludes(); 454 EXPECT_EQ(vs, vector<string>({""})); 455 } catch (...) { 456 EXPECT_TRUE(false); 457 GTEST_LOG_(INFO) << "BJsonEntityExtensionConfigTest-an exception occurred by GetIncludes."; 458 } 459 GTEST_LOG_(INFO) << "BJsonEntityExtensionConfigTest-end b_json_entity_extension_config_1300"; 460 } 461 462 /** 463 * @tc.number: SUB_backup_b_json_entity_extension_config_1400 464 * @tc.name: b_json_entity_extension_config_1400 465 * @tc.desc: 测试GetExcludes接口在Json数据中键为excludes的值不为数组时能否成功返回空vector 466 * @tc.size: MEDIUM 467 * @tc.type: FUNC 468 * @tc.level Level 2 469 * @tc.require: I6F3GV 470 */ 471 HWTEST_F(BJsonEntityExtensionConfigTest, b_json_entity_extension_config_1400, testing::ext::TestSize.Level2) 472 { 473 GTEST_LOG_(INFO) << "BJsonEntityExtensionConfigTest-begin b_json_entity_extension_config_1400"; 474 try { 475 string_view sv = R"({"excludes":1})"; 476 BJsonCachedEntity<BJsonEntityExtensionConfig> cachedEntity(sv); 477 auto cache = cachedEntity.Structuralize(); 478 vector<string> vs = cache.GetExcludes(); 479 EXPECT_EQ(vs, vector<string>()); 480 } catch (...) { 481 EXPECT_TRUE(false); 482 GTEST_LOG_(INFO) << "BJsonEntityExtensionConfigTest-an exception occurred by GetExcludes."; 483 } 484 GTEST_LOG_(INFO) << "BJsonEntityExtensionConfigTest-end b_json_entity_extension_config_1400"; 485 } 486 487 /** 488 * @tc.number: SUB_backup_b_json_entity_extension_config_1500 489 * @tc.name: b_json_entity_extension_config_1500 490 * @tc.desc: 测试GetExcludes接口在Json数据中键为excludes的值为数组且数组元素全都不为字符串时能否成功返回空vector 491 * @tc.size: MEDIUM 492 * @tc.type: FUNC 493 * @tc.level Level 2 494 * @tc.require: I6F3GV 495 */ 496 HWTEST_F(BJsonEntityExtensionConfigTest, b_json_entity_extension_config_1500, testing::ext::TestSize.Level2) 497 { 498 GTEST_LOG_(INFO) << "BJsonEntityExtensionConfigTest-begin b_json_entity_extension_config_1500"; 499 try { 500 string_view sv = R"({"excludes":[1]})"; 501 BJsonCachedEntity<BJsonEntityExtensionConfig> cachedEntity(sv); 502 auto cache = cachedEntity.Structuralize(); 503 vector<string> vs = cache.GetExcludes(); 504 EXPECT_EQ(vs, vector<string>()); 505 } catch (...) { 506 EXPECT_TRUE(false); 507 GTEST_LOG_(INFO) << "BJsonEntityExtensionConfigTest-an exception occurred by GetExcludes."; 508 } 509 GTEST_LOG_(INFO) << "BJsonEntityExtensionConfigTest-end b_json_entity_extension_config_1500"; 510 } 511 512 /** 513 * @tc.number: SUB_backup_b_json_entity_extension_config_1600 514 * @tc.name: b_json_entity_extension_config_1600 515 * @tc.desc: 测试GetAllowToBackupRestore接口在Json数据对象nullValue时能否成功返回false 516 * @tc.size: MEDIUM 517 * @tc.type: FUNC 518 * @tc.level Level 2 519 * @tc.require: I6F3GV 520 */ 521 HWTEST_F(BJsonEntityExtensionConfigTest, b_json_entity_extension_config_1600, testing::ext::TestSize.Level2) 522 { 523 GTEST_LOG_(INFO) << "BJsonEntityExtensionConfigTest-begin b_json_entity_extension_config_1600"; 524 try { 525 Json::Value jv(Json::nullValue); 526 BJsonEntityExtensionConfig extCfg(jv); 527 EXPECT_FALSE(extCfg.GetAllowToBackupRestore()); 528 } catch (...) { 529 EXPECT_TRUE(false); 530 GTEST_LOG_(INFO) << "BJsonEntityExtensionConfigTest-an exception occurred by GetAllowToBackupRestore."; 531 } 532 GTEST_LOG_(INFO) << "BJsonEntityExtensionConfigTest-end b_json_entity_extension_config_1600"; 533 } 534 535 /** 536 * @tc.number: SUB_backup_b_json_entity_extension_config_1700 537 * @tc.name: b_json_entity_extension_config_1700 538 * @tc.desc: 测试GetAllowToBackupRestore接口在Json数据对象不含allowToBackupRestore键时能否成功返回false 539 * @tc.size: MEDIUM 540 * @tc.type: FUNC 541 * @tc.level Level 2 542 * @tc.require: I6F3GV 543 */ 544 HWTEST_F(BJsonEntityExtensionConfigTest, b_json_entity_extension_config_1700, testing::ext::TestSize.Level2) 545 { 546 GTEST_LOG_(INFO) << "BJsonEntityExtensionConfigTest-begin b_json_entity_extension_config_1700"; 547 try { 548 string_view sv = R"({"allowToBackupRestore_":true})"; 549 BJsonCachedEntity<BJsonEntityExtensionConfig> cachedEntity(sv); 550 auto cache = cachedEntity.Structuralize(); 551 EXPECT_FALSE(cache.GetAllowToBackupRestore()); 552 } catch (...) { 553 EXPECT_TRUE(false); 554 GTEST_LOG_(INFO) << "BJsonEntityExtensionConfigTest-an exception occurred by GetAllowToBackupRestore."; 555 } 556 GTEST_LOG_(INFO) << "BJsonEntityExtensionConfigTest-end b_json_entity_extension_config_1700"; 557 } 558 559 /** 560 * @tc.number: SUB_backup_b_json_entity_extension_config_1800 561 * @tc.name: b_json_entity_extension_config_1800 562 * @tc.desc: 测试GetAllowToBackupRestore接口在Json数据对象键为allowToBackupRestore的值不为布尔值时能否成功返回false 563 * @tc.size: MEDIUM 564 * @tc.type: FUNC 565 * @tc.level Level 2 566 * @tc.require: I6F3GV 567 */ 568 HWTEST_F(BJsonEntityExtensionConfigTest, b_json_entity_extension_config_1800, testing::ext::TestSize.Level2) 569 { 570 GTEST_LOG_(INFO) << "BJsonEntityExtensionConfigTest-begin b_json_entity_extension_config_1800"; 571 try { 572 string_view sv = R"({"allowToBackupRestore":1})"; 573 BJsonCachedEntity<BJsonEntityExtensionConfig> cachedEntity(sv); 574 auto cache = cachedEntity.Structuralize(); 575 EXPECT_FALSE(cache.GetAllowToBackupRestore()); 576 } catch (...) { 577 EXPECT_TRUE(false); 578 GTEST_LOG_(INFO) << "BJsonEntityExtensionConfigTest-an exception occurred by GetAllowToBackupRestore."; 579 } 580 GTEST_LOG_(INFO) << "BJsonEntityExtensionConfigTest-end b_json_entity_extension_config_1800"; 581 } 582 } // namespace OHOS::FileManagement::Backup