1 /*
2  * Copyright (c) 2022-2024 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 <map>
17 #include <set>
18 #include <string>
19 #include <utility>
20 
21 #include <fcntl.h>
22 #include <sys/stat.h>
23 
24 #include <file_ex.h>
25 #include <gtest/gtest.h>
26 #include <json/value.h>
27 
28 #include "b_json/b_json_cached_entity.h"
29 #include "b_json/b_json_entity_ext_manage.h"
30 #include "test_manager.h"
31 
32 #include "src/b_json/b_json_entity_ext_manage.cpp"
33 
34 namespace OHOS::FileManagement::Backup {
35 using namespace std;
36 using namespace testing::ext;
37 const int32_t INDEX_FIRST = 0;
38 const int32_t INDEX_SECOND = 1;
39 const int32_t INDEX_THIRD = 2;
40 class BJsonEntityExtManageTest : public testing::Test {
41 public:
SetUpTestCase(void)42     static void SetUpTestCase(void) {};
TearDownTestCase()43     static void TearDownTestCase() {};
SetUp()44     void SetUp() {};
TearDown()45     void TearDown() {};
46 };
47 
IsEqual(const struct stat & lf,const struct stat & rh)48 bool IsEqual(const struct stat &lf, const struct stat &rh)
49 {
50     if (lf.st_size != rh.st_size) {
51         return false;
52     }
53     if (lf.st_atim.tv_sec != rh.st_atim.tv_sec) {
54         return false;
55     }
56     if (lf.st_atim.tv_nsec != rh.st_atim.tv_nsec) {
57         return false;
58     }
59     if (lf.st_mtim.tv_sec != rh.st_mtim.tv_sec) {
60         return false;
61     }
62     if (lf.st_mtim.tv_nsec != rh.st_mtim.tv_nsec) {
63         return false;
64     }
65     return true;
66 }
67 
IsEqual(const map<string,tuple<string,struct stat,bool>> & lf,const map<string,tuple<string,struct stat,bool>> & rh)68 bool IsEqual(const map<string, tuple<string, struct stat, bool>> &lf,
69              const map<string, tuple<string, struct stat, bool>> &rh)
70 {
71     if (lf.size() != rh.size()) {
72         return false;
73     }
74 
75     auto itemLF = lf.begin();
76     auto itemRH = rh.begin();
77     for (; itemLF != lf.end(); ++itemLF, ++itemRH) {
78         if (itemLF->first != itemRH->first) {
79             return false;
80         }
81         if (std::get<INDEX_FIRST>(itemLF->second) != std::get<INDEX_FIRST>(itemRH->second)) {
82             return false;
83         }
84         if (!IsEqual(std::get<INDEX_SECOND>(itemLF->second), std::get<INDEX_SECOND>(itemRH->second))) {
85             return false;
86         }
87         if (std::get<INDEX_THIRD>(itemLF->second) != std::get<INDEX_THIRD>(itemRH->second)) {
88             return false;
89         }
90     }
91 
92     return true;
93 }
94 
IsEqual(const std::vector<ExtManageInfo> & lf,const map<string,tuple<string,struct stat,bool>> & rh)95 bool IsEqual(const std::vector<ExtManageInfo> &lf, const map<string, tuple<string, struct stat, bool>> &rh)
96 {
97     if (lf.size() != rh.size()) {
98         return false;
99     }
100     for (auto &item : lf) {
101         if (rh.find(item.hashName) != rh.end()) {
102             auto [fileName, sta, isBeforeTar] = rh.at(item.hashName);
103             if (item.fileName != fileName || !IsEqual(item.sta, sta)) {
104                 return false;
105             }
106         }
107     }
108     return true;
109 }
110 
GetFileStat(const string & pathTestFile)111 struct stat GetFileStat(const string &pathTestFile)
112 {
113     struct stat sta = {};
114     if (stat(pathTestFile.data(), &sta) == -1) {
115         GTEST_LOG_(INFO) << pathTestFile << " invoked stat failure, errno :" << errno;
116         throw BError(errno);
117     }
118     return sta;
119 }
120 
121 /**
122  * @tc.number: SUB_backup_b_json_entity_ext_manage_0100
123  * @tc.name: b_json_entity_ext_manage_0100
124  * @tc.desc: 通过向接口SetExtManage传入不包含任何信息的空map参数，测试对索引文件的操作是否正确。
125  *           0：通过向索引文件写入0条数据模拟对索引文件的(空)内容的测试覆盖
126  *           1：调用接口SetExtManage，向索引文件写入数据
127  *           2：调用接口GetExtManage，从索引文件读出文件名数据
128  *           3：调用接口GetExtManageInfo，从索引文件读出文件详细数据(含文件名和对应文件的stat数据)
129  *           4：判断读出的文件名集合/文件详细数据记录个数是否为0
130  * @tc.size: MEDIUM
131  * @tc.type: FUNC
132  * @tc.level Level 0
133  * @tc.require: I6F3GV
134  */
135 HWTEST_F(BJsonEntityExtManageTest, b_json_entity_ext_manage_0100, testing::ext::TestSize.Level0)
136 {
137     GTEST_LOG_(INFO) << "BJsonEntityExtManageTest-begin b_json_entity_ext_manage_0100";
138     try {
139         // 预置文件数据
140         // 索引文件pathManageFile
141         TestManager tm("b_json_entity_ext_manage_0100");
142         string root = tm.GetRootDirCurTest();
143         string pathManageFile = root + "manage.json";
144         BJsonCachedEntity<BJsonEntityExtManage> cachedEntity(UniqueFd(open(pathManageFile.data(), O_RDONLY, 0)));
145         auto cache = cachedEntity.Structuralize();
146 
147         // 写入空数据
148         map<string, tuple<string, struct stat, bool>> info;
149         cache.SetExtManage(info);
150 
151         // 读取索引文件信息并做结果判断
152         auto fileNames = cache.GetExtManage();
153         EXPECT_EQ(fileNames.size(), 0ul);
154         auto fileInfo = cache.GetExtManageInfo();
155         EXPECT_EQ(fileInfo.size(), 0ul);
156     } catch (...) {
157         EXPECT_TRUE(false);
158         GTEST_LOG_(INFO) << "BJsonEntityExtManageTest-an exception occurred.";
159     }
160     GTEST_LOG_(INFO) << "BJsonEntityExtManageTest-end b_json_entity_ext_manage_0100";
161 }
162 
163 /**
164  * @tc.number: SUB_backup_b_json_entity_ext_manage_0200
165  * @tc.name: b_json_entity_ext_manage_0200
166  * @tc.desc: 通过向接口SetExtManage传入包含一条信息的map参数，测试对索引文件的操作是否正确。
167  *           0：通过向索引文件写入1条有效数据模拟对索引文件的(有)内容的测试覆盖
168  *           1：调用接口SetExtManage，向索引文件写入数据
169  *           2：调用接口GetExtManage，从索引文件读出文件名数据
170  *           3：调用接口GetExtManageInfo，从索引文件读出文件详细数据(含文件名和对应文件的stat数据)
171  *           4：判断读出的文件名集合/文件详细数据记录个数是否和写入时相等
172  *           5：判断读出的文件名集合/文件详细数据记录内容是否和写入时相等
173  * @tc.size: MEDIUM
174  * @tc.type: FUNC
175  * @tc.level Level 0
176  * @tc.require: I6F3GV
177  */
178 HWTEST_F(BJsonEntityExtManageTest, b_json_entity_ext_manage_0200, testing::ext::TestSize.Level0)
179 {
180     GTEST_LOG_(INFO) << "BJsonEntityExtManageTest-begin b_json_entity_ext_manage_0200";
181     try {
182         TestManager tm("b_json_entity_ext_manage_0200");
183 
184         // 预置文件数据
185         // 索引文件pathManageFile, 测试文件路径pathTestFile, 测试文件名testFileHexName
186         string root = tm.GetRootDirCurTest();
187         string pathManageFile = root + "manage.json";
188         string pathTestFile = root + "test.txt";
189         string testFileHexName = "1234567890abcdef";
190         SaveStringToFile(pathTestFile, "hello world");
191         BJsonCachedEntity<BJsonEntityExtManage> cachedEntity(UniqueFd(open(pathManageFile.data(), O_RDONLY, 0)));
192         auto cache = cachedEntity.Structuralize();
193 
194         // 生成一条有用数据并写入索引文件
195         map<string, tuple<string, struct stat, bool>> info;
196         struct stat sta = {};
197         info.emplace(testFileHexName, make_tuple(pathTestFile, sta = GetFileStat(pathTestFile), true));
198         cache.SetExtManage(info);
199 
200         // 读取索引文件内容并做结果判断
201         auto fileNames = cache.GetExtManage();
202         ASSERT_EQ(fileNames.size(), 1ul);
203         EXPECT_EQ(*fileNames.begin(), testFileHexName);
204         auto fileInfo = cache.GetExtManageInfo();
205         ASSERT_EQ(fileInfo.size(), 1ul);
206         EXPECT_EQ(fileInfo[0].hashName, testFileHexName);
207         EXPECT_EQ(fileInfo[0].fileName, pathTestFile);
208         EXPECT_TRUE(IsEqual(fileInfo[0].sta, sta));
209     } catch (...) {
210         EXPECT_TRUE(false);
211         GTEST_LOG_(INFO) << "BJsonEntityExtManageTest-an exception occurred.";
212     }
213     GTEST_LOG_(INFO) << "BJsonEntityExtManageTest-end b_json_entity_ext_manage_0200";
214 }
215 
216 /**
217  * @tc.number: SUB_backup_b_json_entity_ext_manage_0300
218  * @tc.name: b_json_entity_ext_manage_0300
219  * @tc.desc: 通过向接口SetExtManage传入包含三条信息的map参数，测试对索引文件的操作是否正确。
220  *           0：通过向索引文件写入3条有效数据模拟对索引文件的(无穷)内容的测试覆盖
221  *           1：调用接口SetExtManage，向索引文件写入数据
222  *           2：调用接口GetExtManage，从索引文件读出文件名数据
223  *           3：调用接口GetExtManageInfo，从索引文件读出文件详细数据(含文件名和对应文件的stat数据)
224  *           4：判断读出的文件名集合/文件详细数据记录个数是否和写入时相等
225  *           5：判断读出的文件名集合/文件详细数据记录内容是否和写入时相等
226  * @tc.size: MEDIUM
227  * @tc.type: FUNC
228  * @tc.level Level 0
229  * @tc.require: I6F3GV
230  */
231 HWTEST_F(BJsonEntityExtManageTest, b_json_entity_ext_manage_0300, testing::ext::TestSize.Level0)
232 {
233     GTEST_LOG_(INFO) << "BJsonEntityExtManageTest-begin b_json_entity_ext_manage_0300";
234     try {
235         TestManager tm("b_json_entity_ext_manage_0300");
236 
237         // 预置文件数据
238         // 索引文件pathManageFile1/2/3, 测试文件路径pathTestFile1/2/3, 测试文件名testFile1/2/3HexName
239         string root = tm.GetRootDirCurTest();
240         string pathManageFile = root + "manage.json";
241         string pathTestFile1 = root + "test1.txt";
242         string pathTestFile2 = root + "test2.txt";
243         string pathTestFile3 = root + "test3.txt";
244         string testFile1HexName = "1234567890abcde1";
245         string testFile2HexName = "1234567890abcde2";
246         string testFile3HexName = "1234567890abcde3";
247         SaveStringToFile(pathTestFile1, "h");
248         SaveStringToFile(pathTestFile2, "hello");
249         SaveStringToFile(pathTestFile3, "hello world");
250         BJsonCachedEntity<BJsonEntityExtManage> cachedEntity(UniqueFd(open(pathManageFile.data(), O_RDONLY, 0)));
251         auto newCache = cachedEntity.Structuralize();
252 
253         // 生成三条有用数据并写入索引文件
254         map<string, tuple<string, struct stat, bool>> info;
255         info.emplace(testFile1HexName, make_tuple(pathTestFile1, GetFileStat(pathTestFile1), true));
256         info.emplace(testFile2HexName, make_tuple(pathTestFile2, GetFileStat(pathTestFile2), true));
257         info.emplace(testFile3HexName, make_tuple(pathTestFile3, GetFileStat(pathTestFile3), true));
258         newCache.SetExtManage(info);
259 
260         // 预置结果集，用以在读取索引文件后做结果判断
261         set<string> resultFileName {testFile1HexName, testFile2HexName, testFile3HexName};
262 
263         // 读取索引文件内容并做结果判断
264         auto fileNames = newCache.GetExtManage();
265         EXPECT_EQ(fileNames.size(), info.size());
266         EXPECT_EQ(fileNames, resultFileName);
267         auto fileInfo = newCache.GetExtManageInfo();
268         EXPECT_EQ(fileInfo.size(), info.size());
269         EXPECT_TRUE(IsEqual(fileInfo, info));
270     } catch (...) {
271         EXPECT_TRUE(false);
272         GTEST_LOG_(INFO) << "BJsonEntityExtManageTest-an exception occurred.";
273     }
274     GTEST_LOG_(INFO) << "BJsonEntityExtManageTest-end b_json_entity_ext_manage_0300";
275 }
276 
277 /**
278  * @tc.number: SUB_backup_b_json_entity_ext_manage_0400
279  * @tc.name: b_json_entity_ext_manage_0400
280  * @tc.desc: 通过向接口SetExtManage传入包含三条信息的map参数，测试对索引文件的操作是否正确。
281  *           0：通过向索引文件写入3条有效数据模拟覆盖对索引文件的(无穷)内容的测试覆盖
282  *           0：通过向索引文件的记录一写入0条、记录二写入1条、记录三写入2条有效硬链接数据模拟对索引文件含
283  *              有硬链接(空、有、无穷)个的测试覆盖
284  *           1：调用接口SetExtManage，向索引文件写入数据
285  *           2：调用接口GetExtManage，从索引文件读出文件名数据
286  *           3：调用接口GetExtManageInfo，从索引文件读出文件详细数据(含文件名和对应文件的stat数据)
287  *           4：判断读出的文件名集合/文件详细数据记录个数是否和写入时相等
288  *           5：判断读出的文件名集合/文件详细数据记录内容是否和写入时相等
289  * @tc.size: MEDIUM
290  * @tc.type: FUNC
291  * @tc.level Level 0
292  * @tc.require: I6F3GV
293  */
294 HWTEST_F(BJsonEntityExtManageTest, b_json_entity_ext_manage_0400, testing::ext::TestSize.Level0)
295 {
296     GTEST_LOG_(INFO) << "BJsonEntityExtManageTest-begin b_json_entity_ext_manage_0400";
297     try {
298         TestManager tm("b_json_entity_ext_manage_0400");
299 
300         // 预置文件数据
301         // 索引文件pathManageFile1/2/3, 测试文件路径pathTestFile1/2/3, 测试文件名testFile1/2/3HexName
302         string root = tm.GetRootDirCurTest();
303         string pathManageFile = root + "manage.json";
304         string pathTestFile1 = root + "test4.txt";
305         string pathTestFile2 = root + "test5.txt";
306         string pathTestFile3 = root + "test6.txt";
307         string testFile1HexName = "1234567890abcde4";
308         string testFile2HexName = "1234567890abcde5";
309         string testFile3HexName = "1234567890abcde6";
310         SaveStringToFile(pathTestFile1, "h");
311         SaveStringToFile(pathTestFile2, "hello");
312         SaveStringToFile(pathTestFile3, "hello world");
313         BJsonCachedEntity<BJsonEntityExtManage> cachedEntity(UniqueFd(open(pathManageFile.data(), O_RDONLY, 0)));
314         auto cache = cachedEntity.Structuralize();
315 
316         // 生成三条有用数据并写入索引文件
317         map<string, tuple<string, struct stat, bool>> info;
318         info.emplace(testFile1HexName, make_tuple(pathTestFile1, GetFileStat(pathTestFile1), true));
319         info.emplace(testFile2HexName, make_tuple(pathTestFile2, GetFileStat(pathTestFile2), true));
320         info.emplace(testFile3HexName, make_tuple(pathTestFile3, GetFileStat(pathTestFile3), true));
321         cache.SetExtManage(info);
322 
323         // 预置结果集，用以在读取索引文件后做结果判断
324         set<string> resultFileName {testFile1HexName, testFile2HexName, testFile3HexName};
325 
326         // 读取索引文件内容并做结果判断
327         auto fileNames = cache.GetExtManage();
328         EXPECT_EQ(fileNames.size(), info.size());
329         EXPECT_EQ(fileNames, resultFileName);
330         auto fileInfo = cache.GetExtManageInfo();
331         EXPECT_EQ(fileInfo.size(), info.size());
332         EXPECT_TRUE(IsEqual(fileInfo, info));
333     } catch (...) {
334         EXPECT_TRUE(false);
335         GTEST_LOG_(INFO) << "BJsonEntityExtManageTest-an exception occurred.";
336     }
337     GTEST_LOG_(INFO) << "BJsonEntityExtManageTest-end b_json_entity_ext_manage_0400";
338 }
339 
340 /**
341  * @tc.number: SUB_backup_b_json_entity_ext_manage_0500
342  * @tc.name: b_json_entity_ext_manage_0500
343  * @tc.desc: 通过向接口SetExtManage传入包含三条信息的map参数，测试对索引文件的操作是否正确。
344  *           0：通过向索引文件写入3条有效数据模拟覆盖对索引文件的(无穷)内容的测试覆盖
345  *           0：通过向索引文件的记录一写入0条、记录二写入1条、记录三写入2条有效硬链接数据模拟对索引文件含
346  *              有硬链接(空、有、无穷)个的测试覆盖
347  *           0：通过传入和源文件相同stat信息向索引文件中对应记录添加硬链接
348  *           1：调用接口SetExtManage，向索引文件写入数据
349  *           2：调用接口GetExtManage，从索引文件读出文件名数据
350  *           3：调用接口GetExtManageInfo，从索引文件读出文件详细数据(含文件名和对应文件的stat数据)
351  *           4：判断读出的文件名集合/文件详细数据记录个数是否和写入时相等
352  *           5：判断读出的文件名集合/文件详细数据记录内容是否和写入时相等
353  * @tc.size: MEDIUM
354  * @tc.type: FUNC
355  * @tc.level Level 0
356  * @tc.require: I6F3GV
357  */
358 HWTEST_F(BJsonEntityExtManageTest, b_json_entity_ext_manage_0500, testing::ext::TestSize.Level0)
359 {
360     GTEST_LOG_(INFO) << "BJsonEntityExtManageTest-begin b_json_entity_ext_manage_0500";
361     try {
362         // 预置文件数据
363         // 索引文件pathManageFile1/2/3, 测试文件路径pathTestFile1/2/3, 测试文件名testFile1/2/3HexName
364         TestManager tm("b_json_entity_ext_manage_0500");
365         string root = tm.GetRootDirCurTest();
366         string pathManageFile = root + "manage.json";
367         string pathTestFile1 = root + "test7.txt";
368         string pathTestFile2 = root + "test8.txt";
369         string pathTestFile3 = root + "test9.txt";
370         string testFile1HexName = "1234567890abcde7";
371         string testFile2HexName = "1234567890abcde8";
372         string testFile3HexName = "1234567890abcde9";
373         SaveStringToFile(pathTestFile1, "h");
374         SaveStringToFile(pathTestFile2, "hello");
375         SaveStringToFile(pathTestFile3, "hello world");
376         BJsonCachedEntity<BJsonEntityExtManage> cachedEntity(UniqueFd(open(pathManageFile.data(), O_RDONLY, 0)));
377         auto cache = cachedEntity.Structuralize();
378 
379         // 生成三条有用数据并写入索引文件
380         map<string, tuple<string, struct stat, bool>> info;
381         struct stat sta = {};
382         info.emplace(testFile1HexName, make_tuple(pathTestFile1, GetFileStat(pathTestFile1), true));
383         info.emplace(testFile2HexName, make_tuple(pathTestFile2, sta = GetFileStat(pathTestFile2), true));
384         info.emplace(testFile3HexName, make_tuple(pathTestFile3, sta = GetFileStat(pathTestFile3), true));
385         cache.SetExtManage(info);
386 
387         // 预置结果集，用以在读取索引文件后做结果判断
388         set<string> resultFileName {testFile1HexName, testFile2HexName, testFile3HexName};
389 
390         // 读取索引文件内容并做结果判断
391         auto fileNames = cache.GetExtManage();
392         EXPECT_EQ(fileNames.size(), 3ul);
393         EXPECT_EQ(fileNames, resultFileName);
394         auto fileInfo = cache.GetExtManageInfo();
395         EXPECT_EQ(fileInfo.size(), info.size());
396         EXPECT_TRUE(IsEqual(fileInfo, info));
397     } catch (...) {
398         EXPECT_TRUE(false);
399         GTEST_LOG_(INFO) << "BJsonEntityExtManageTest-an exception occurred.";
400     }
401     GTEST_LOG_(INFO) << "BJsonEntityExtManageTest-end b_json_entity_ext_manage_0500";
402 }
403 
404 /**
405  * @tc.number: SUB_backup_b_json_entity_ext_manage_0700
406  * @tc.name: b_json_entity_ext_manage_0700
407  * @tc.desc: 测试GetExtManageInfo在Json数据不为数组时能否成功返回空map
408  * @tc.size: MEDIUM
409  * @tc.type: FUNC
410  * @tc.level Level 0
411  * @tc.require: I6F3GV
412  */
413 HWTEST_F(BJsonEntityExtManageTest, b_json_entity_ext_manage_0700, testing::ext::TestSize.Level0)
414 {
415     GTEST_LOG_(INFO) << "BJsonEntityExtManageTest-begin b_json_entity_ext_manage_0700";
416     try {
417         string_view sv = R"({"key":1})";
418         BJsonCachedEntity<BJsonEntityExtManage> cachedEntity(sv);
419         auto cache = cachedEntity.Structuralize();
420         auto mp = cache.GetExtManageInfo();
421         EXPECT_TRUE(mp.empty());
422     } catch (...) {
423         EXPECT_TRUE(false);
424         GTEST_LOG_(INFO) << "BJsonEntityExtManageTest-an exception occurred.";
425     }
426     GTEST_LOG_(INFO) << "BJsonEntityExtManageTest-end b_json_entity_ext_manage_0700";
427 }
428 
429 /**
430  * @tc.number: SUB_backup_b_json_entity_ext_manage_0800
431  * @tc.name: b_json_entity_ext_manage_0800
432  * @tc.desc: 测试GetExtManageInfo在Json数据为数组且仅有一个键不为information的对象时能否成功返回空map
433  * @tc.size: MEDIUM
434  * @tc.type: FUNC
435  * @tc.level Level 0
436  * @tc.require: I6F3GV
437  */
438 HWTEST_F(BJsonEntityExtManageTest, b_json_entity_ext_manage_0800, testing::ext::TestSize.Level0)
439 {
440     GTEST_LOG_(INFO) << "BJsonEntityExtManageTest-begin b_json_entity_ext_manage_0800";
441     try {
442         string_view sv = R"([{"key":1}])";
443         BJsonCachedEntity<BJsonEntityExtManage> cachedEntity(sv);
444         auto cache = cachedEntity.Structuralize();
445         auto mp = cache.GetExtManageInfo();
446         EXPECT_TRUE(mp.empty());
447     } catch (...) {
448         EXPECT_TRUE(false);
449         GTEST_LOG_(INFO) << "BJsonEntityExtManageTest-an exception occurred.";
450     }
451     GTEST_LOG_(INFO) << "BJsonEntityExtManageTest-end b_json_entity_ext_manage_0800";
452 }
453 
454 /**
455  * @tc.number: SUB_backup_b_json_entity_ext_manage_0801
456  * @tc.name: b_json_entity_ext_manage_0801
457  * @tc.desc: 测试GetExtManageInfo在Json数据为数组且有一个键为information的对象时能否成功返回空map
458  * @tc.size: MEDIUM
459  * @tc.type: FUNC
460  * @tc.level Level 0
461  * @tc.require: I6F3GV
462  */
463 HWTEST_F(BJsonEntityExtManageTest, b_json_entity_ext_manage_0801, testing::ext::TestSize.Level0)
464 {
465     GTEST_LOG_(INFO) << "BJsonEntityExtManageTest-begin b_json_entity_ext_manage_0801";
466     try {
467         string_view sv = R"([{"path":1}])";
468         BJsonCachedEntity<BJsonEntityExtManage> cachedEntity(sv);
469         auto cache = cachedEntity.Structuralize();
470         auto mp = cache.GetExtManageInfo();
471         EXPECT_TRUE(mp.empty());
472     } catch (...) {
473         EXPECT_TRUE(false);
474         GTEST_LOG_(INFO) << "BJsonEntityExtManageTest-an exception occurred.";
475     }
476     GTEST_LOG_(INFO) << "BJsonEntityExtManageTest-end b_json_entity_ext_manage_0801";
477 }
478 
479 /**
480  * @tc.number: SUB_backup_b_json_entity_ext_manage_0802
481  * @tc.name: b_json_entity_ext_manage_0802
482  * @tc.desc: 测试GetExtManageInfo在Json数据为数组且有两个键为information的对象时能否成功返回空map
483  * @tc.size: MEDIUM
484  * @tc.type: FUNC
485  * @tc.level Level 0
486  * @tc.require: I6F3GV
487  */
488 HWTEST_F(BJsonEntityExtManageTest, b_json_entity_ext_manage_0802, testing::ext::TestSize.Level0)
489 {
490     GTEST_LOG_(INFO) << "BJsonEntityExtManageTest-begin b_json_entity_ext_manage_0802";
491     try {
492         string_view sv = R"([{"path":1}, {"fileName":1}])";
493         BJsonCachedEntity<BJsonEntityExtManage> cachedEntity(sv);
494         auto cache = cachedEntity.Structuralize();
495         auto mp = cache.GetExtManageInfo();
496         EXPECT_TRUE(mp.empty());
497     } catch (...) {
498         EXPECT_TRUE(false);
499         GTEST_LOG_(INFO) << "BJsonEntityExtManageTest-an exception occurred.";
500     }
501     GTEST_LOG_(INFO) << "BJsonEntityExtManageTest-end b_json_entity_ext_manage_0802";
502 }
503 
504 /**
505  * @tc.number: SUB_backup_b_json_entity_ext_manage_0803
506  * @tc.name: b_json_entity_ext_manage_0803
507  * @tc.desc: 测试GetExtManageInfo在Json数据为数组且键为空时能否成功返回空map
508  * @tc.size: MEDIUM
509  * @tc.type: FUNC
510  * @tc.level Level 0
511  * @tc.require: I6F3GV
512  */
513 HWTEST_F(BJsonEntityExtManageTest, b_json_entity_ext_manage_0803, testing::ext::TestSize.Level0)
514 {
515     GTEST_LOG_(INFO) << "BJsonEntityExtManageTest-begin b_json_entity_ext_manage_0803";
516     try {
517         string_view sv = R"([{"":1}])";
518         BJsonCachedEntity<BJsonEntityExtManage> cachedEntity(sv);
519         auto cache = cachedEntity.Structuralize();
520         auto mp = cache.GetExtManageInfo();
521         EXPECT_TRUE(mp.empty());
522     } catch (...) {
523         EXPECT_TRUE(false);
524         GTEST_LOG_(INFO) << "BJsonEntityExtManageTest-an exception occurred.";
525     }
526     GTEST_LOG_(INFO) << "BJsonEntityExtManageTest-end b_json_entity_ext_manage_0803";
527 }
528 
529 /**
530  * @tc.number: SUB_backup_b_json_entity_ext_manage_0804
531  * @tc.name: b_json_entity_ext_manage_0804
532  * @tc.desc: 测试GetExtManageInfo
533  * @tc.size: MEDIUM
534  * @tc.type: FUNC
535  * @tc.level Level 0
536  * @tc.require: I6F3GV
537  */
538 HWTEST_F(BJsonEntityExtManageTest, b_json_entity_ext_manage_0804, testing::ext::TestSize.Level0)
539 {
540     GTEST_LOG_(INFO) << "BJsonEntityExtManageTest-begin b_json_entity_ext_manage_0804";
541     try {
542         string_view sv = R"([{"isBigFile":false}, {"fileName":"test"}])";
543         BJsonCachedEntity<BJsonEntityExtManage> cachedEntity(sv);
544         auto cache = cachedEntity.Structuralize();
545         auto mp = cache.GetExtManageInfo();
546         EXPECT_TRUE(mp.empty());
547     } catch (...) {
548         EXPECT_TRUE(false);
549         GTEST_LOG_(INFO) << "BJsonEntityExtManageTest-an exception occurred.";
550     }
551     GTEST_LOG_(INFO) << "BJsonEntityExtManageTest-end b_json_entity_ext_manage_0804";
552 }
553 
554 /**
555  * @tc.number: SUB_backup_b_json_entity_ext_manage_0900
556  * @tc.name: b_json_entity_ext_manage_0900
557  * @tc.desc: 测试CheckBigFile中st_size的两种情况
558  * @tc.size: MEDIUM
559  * @tc.type: FUNC
560  * @tc.level Level 1
561  * @tc.require: issuesI9JXNH
562  */
563 HWTEST_F(BJsonEntityExtManageTest, b_json_entity_ext_manage_0900, testing::ext::TestSize.Level1)
564 {
565     GTEST_LOG_(INFO) << "BJsonEntityExtManageTest-begin b_json_entity_ext_manage_0900";
566     try {
567         struct stat sta;
568         sta.st_size = 0;
569         bool ret = CheckBigFile(sta);
570         EXPECT_FALSE(ret);
571 
572         sta.st_size = BConstants::BIG_FILE_BOUNDARY + 1;
573         ret = CheckBigFile(sta);
574         EXPECT_TRUE(ret);
575     } catch (...) {
576         EXPECT_TRUE(false);
577         GTEST_LOG_(INFO) << "BJsonEntityExtManageTest-an exception occurred.";
578     }
579     GTEST_LOG_(INFO) << "BJsonEntityExtManageTest-end b_json_entity_ext_manage_0900";
580 }
581 
Canonicalize(const string_view & path)582 string BExcepUltils::Canonicalize(const string_view &path)
583 {
584     return string(path);
585 }
586 
587 /**
588  * @tc.number: SUB_backup_b_json_entity_ext_manage_0901
589  * @tc.name: b_json_entity_ext_manage_0901
590  * @tc.desc: 测试CheckOwnPackTar各种异常分支
591  * @tc.size: MEDIUM
592  * @tc.type: FUNC
593  * @tc.level Level 1
594  * @tc.require: issuesI9JXNH
595  */
596 HWTEST_F(BJsonEntityExtManageTest, b_json_entity_ext_manage_0901, testing::ext::TestSize.Level1)
597 {
598     GTEST_LOG_(INFO) << "BJsonEntityExtManageTest-begin b_json_entity_ext_manage_0901";
599     try {
600         string fileName = string(BConstants::PATH_BUNDLE_BACKUP_HOME)
601             .append(BConstants::SA_BUNDLE_BACKUP_BACKUP).append("/tar");
602         auto ret = CheckOwnPackTar(fileName);
603         EXPECT_FALSE(ret);
604 
605         fileName = string(BConstants::PATH_BUNDLE_BACKUP_HOME)
606             .append(BConstants::SA_BUNDLE_BACKUP_BACKUP).append("/test.tar");
607         ret = CheckOwnPackTar(fileName);
608         EXPECT_FALSE(ret);
609     } catch (...) {
610         EXPECT_TRUE(false);
611         GTEST_LOG_(INFO) << "BJsonEntityExtManageTest-an exception occurred.";
612     }
613     GTEST_LOG_(INFO) << "BJsonEntityExtManageTest-end b_json_entity_ext_manage_0901";
614 }
615 
616 /**
617  * @tc.number: SUB_backup_b_json_entity_ext_manage_0902
618  * @tc.name: b_json_entity_ext_manage_0902
619  * @tc.desc: 测试SetExtManageForClone的各种情况
620  * @tc.size: MEDIUM
621  * @tc.type: FUNC
622  * @tc.level Level 1
623  * @tc.require: issuesI9JXNH
624  */
625 HWTEST_F(BJsonEntityExtManageTest, b_json_entity_ext_manage_0902, testing::ext::TestSize.Level1)
626 {
627     GTEST_LOG_(INFO) << "BJsonEntityExtManageTest-begin b_json_entity_ext_manage_0902";
628     try {
629         TestManager tm("b_json_entity_ext_manage_0902");
630         // 预置文件数据
631         // 索引文件pathManageFile, 测试文件路径pathTestFile, 测试文件名testFileHexName
632         string root = tm.GetRootDirCurTest();
633         string pathManageFile = root + "manage.json";
634         string pathTestFile = root + "test.txt";
635         string testFileHexName = "1234567890abcdef";
636         SaveStringToFile(pathTestFile, "hello world");
637         BJsonCachedEntity<BJsonEntityExtManage> cachedEntity(UniqueFd(open(pathManageFile.data(), O_RDONLY, 0)));
638         auto cache = cachedEntity.Structuralize();
639 
640         // 生成一条有用数据并写入索引文件
641         map<string, tuple<string, struct stat, bool, bool>> info;
642         struct stat sta = {};
643         info.emplace(testFileHexName, make_tuple(pathTestFile, sta = GetFileStat(pathTestFile), false, true));
644         cache.SetExtManageForClone(info);
645 
646         // 读取索引文件内容并做结果判断
647         auto fileNames = cache.GetExtManage();
648         ASSERT_EQ(fileNames.size(), 1ul);
649         EXPECT_EQ(*fileNames.begin(), testFileHexName);
650         auto fileInfo = cache.GetExtManageInfo();
651         ASSERT_EQ(fileInfo.size(), 1ul);
652         EXPECT_EQ(fileInfo[0].hashName, testFileHexName);
653         EXPECT_EQ(fileInfo[0].fileName, pathTestFile);
654         EXPECT_TRUE(fileInfo[0].isUserTar);
655         EXPECT_FALSE(fileInfo[0].isBigFile);
656         EXPECT_TRUE(IsEqual(fileInfo[0].sta, sta));
657     } catch (...) {
658         EXPECT_TRUE(false);
659         GTEST_LOG_(INFO) << "BJsonEntityExtManageTest-an exception occurred.";
660     }
661     GTEST_LOG_(INFO) << "BJsonEntityExtManageTest-end b_json_entity_ext_manage_0902";
662 }
663 
664 /**
665  * @tc.number: SUB_backup_b_json_entity_ext_manage_0903
666  * @tc.name: b_json_entity_ext_manage_0903
667  * @tc.desc: 测试CheckOwnPackTar各种异常分支
668  * @tc.size: MEDIUM
669  * @tc.type: FUNC
670  * @tc.level Level 1
671  * @tc.require: issuesI9JXNH
672  */
673 HWTEST_F(BJsonEntityExtManageTest, b_json_entity_ext_manage_0903, testing::ext::TestSize.Level1)
674 {
675     GTEST_LOG_(INFO) << "BJsonEntityExtManageTest-begin b_json_entity_ext_manage_0903";
676     try {
677         TestManager tm("b_json_entity_ext_manage_0903");
678         // 预置文件数据
679         // 索引文件pathManageFile, 测试文件路径pathTestFile, 测试文件名testFileHexName
680         string root = tm.GetRootDirCurTest();
681         string pathManageFile = root + "manage.json";
682         BJsonCachedEntity<BJsonEntityExtManage> cachedEntity(UniqueFd(open(pathManageFile.data(), O_RDONLY, 0)));
683         auto cache = cachedEntity.Structuralize();
684         Json::Value value;
685         value["isUserTar"] = true;
686         value["information"]["test"] = "test";
687 
688         cache.obj_.clear();
689         cache.obj_.append(value);
690         // 读取索引文件内容并做结果判断
691         auto fileNames = cache.GetExtManage();
692         EXPECT_EQ(fileNames.size(), 1ul);
693         EXPECT_EQ(*fileNames.begin(), "");
694         auto infos = cache.GetExtManageInfo();
695         EXPECT_EQ(infos.size(), 0);
696     } catch (...) {
697         EXPECT_TRUE(false);
698         GTEST_LOG_(INFO) << "BJsonEntityExtManageTest-an exception occurred.";
699     }
700     GTEST_LOG_(INFO) << "BJsonEntityExtManageTest-end b_json_entity_ext_manage_0903";
701 }
702 
703 /**
704  * @tc.number: SUB_backup_b_json_entity_ext_manage_0904
705  * @tc.name: b_json_entity_ext_manage_0904
706  * @tc.desc: 测试CheckOwnPackTar各种异常分支
707  * @tc.size: MEDIUM
708  * @tc.type: FUNC
709  * @tc.level Level 1
710  * @tc.require: issuesI9JXNH
711  */
712 HWTEST_F(BJsonEntityExtManageTest, b_json_entity_ext_manage_0904, testing::ext::TestSize.Level1)
713 {
714     GTEST_LOG_(INFO) << "BJsonEntityExtManageTest-begin b_json_entity_ext_manage_0904";
715     try {
716         string fileName = "/home/user/test.tar";
717         auto ret = CheckOwnPackTar(fileName);
718         EXPECT_FALSE(ret);
719 
720         fileName = string(BConstants::PATH_BUNDLE_BACKUP_HOME)
721             .append(BConstants::SA_BUNDLE_BACKUP_BACKUP).append("/part1.tar");
722         ret = CheckOwnPackTar(fileName);
723         EXPECT_TRUE(ret);
724     } catch (...) {
725         EXPECT_TRUE(false);
726         GTEST_LOG_(INFO) << "BJsonEntityExtManageTest-an exception occurred.";
727     }
728     GTEST_LOG_(INFO) << "BJsonEntityExtManageTest-end b_json_entity_ext_manage_0904";
729 }
730 } // namespace OHOS::FileManagement::Backup