1 // Copyright 2014 The Chromium Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
5 #include "webkit/browser/fileapi/sandbox_directory_database.h"
10 #include "base/file_util.h"
11 #include "base/files/file.h"
12 #include "base/files/scoped_temp_dir.h"
13 #include "base/memory/scoped_ptr.h"
14 #include "base/strings/string_number_conversions.h"
15 #include "base/strings/string_util.h"
16 #include "content/browser/fileapi/sandbox_database_test_helper.h"
17 #include "testing/gtest/include/gtest/gtest.h"
18 #include "third_party/leveldatabase/src/include/leveldb/db.h"
19 #include "webkit/common/fileapi/file_system_util.h"
21 #define FPL(x) FILE_PATH_LITERAL(x)
23 using fileapi::FilePathToString;
24 using fileapi::SandboxDirectoryDatabase;
29 const base::FilePath::CharType kDirectoryDatabaseName[] = FPL("Paths");
32 class SandboxDirectoryDatabaseTest : public testing::Test {
34 typedef SandboxDirectoryDatabase::FileId FileId;
35 typedef SandboxDirectoryDatabase::FileInfo FileInfo;
37 SandboxDirectoryDatabaseTest() {
38 EXPECT_TRUE(base_.CreateUniqueTempDir());
42 SandboxDirectoryDatabase* db() {
47 // Call CloseDatabase() to avoid having multiple database instances for
48 // single directory at once.
50 db_.reset(new SandboxDirectoryDatabase(path(), NULL));
53 void CloseDatabase() {
57 base::File::Error AddFileInfo(
58 FileId parent_id, const base::FilePath::StringType& name) {
61 info.parent_id = parent_id;
63 return db_->AddFileInfo(info, &file_id);
66 void CreateDirectory(FileId parent_id,
67 const base::FilePath::StringType& name,
68 FileId* file_id_out) {
70 info.parent_id = parent_id;
72 ASSERT_EQ(base::File::FILE_OK, db_->AddFileInfo(info, file_id_out));
75 void CreateFile(FileId parent_id,
76 const base::FilePath::StringType& name,
77 const base::FilePath::StringType& data_path,
78 FileId* file_id_out) {
82 info.parent_id = parent_id;
84 info.data_path = base::FilePath(data_path).NormalizePathSeparators();
85 ASSERT_EQ(base::File::FILE_OK, db_->AddFileInfo(info, &file_id));
87 base::FilePath local_path = path().Append(data_path);
88 if (!base::DirectoryExists(local_path.DirName()))
89 ASSERT_TRUE(base::CreateDirectory(local_path.DirName()));
91 base::File file(local_path,
92 base::File::FLAG_CREATE | base::File::FLAG_WRITE);
93 ASSERT_TRUE(file.IsValid());
94 ASSERT_TRUE(file.created());
97 *file_id_out = file_id;
100 void ClearDatabaseAndDirectory() {
102 ASSERT_TRUE(base::DeleteFile(path(), true /* recursive */));
103 ASSERT_TRUE(base::CreateDirectory(path()));
104 db_.reset(new SandboxDirectoryDatabase(path(), NULL));
107 bool RepairDatabase() {
108 return db()->RepairDatabase(
109 FilePathToString(path().Append(kDirectoryDatabaseName)));
112 const base::FilePath& path() {
116 // Makes link from |parent_id| to |child_id| with |name|.
117 void MakeHierarchyLink(FileId parent_id,
119 const base::FilePath::StringType& name) {
120 ASSERT_TRUE(db()->db_->Put(
121 leveldb::WriteOptions(),
122 "CHILD_OF:" + base::Int64ToString(parent_id) + ":" +
123 FilePathToString(base::FilePath(name)),
124 base::Int64ToString(child_id)).ok());
127 // Deletes link from parent of |file_id| to |file_id|.
128 void DeleteHierarchyLink(FileId file_id) {
130 ASSERT_TRUE(db()->GetFileInfo(file_id, &file_info));
131 ASSERT_TRUE(db()->db_->Delete(
132 leveldb::WriteOptions(),
133 "CHILD_OF:" + base::Int64ToString(file_info.parent_id) + ":" +
134 FilePathToString(base::FilePath(file_info.name))).ok());
138 // Common temp base for nondestructive uses.
139 base::ScopedTempDir base_;
140 scoped_ptr<SandboxDirectoryDatabase> db_;
143 DISALLOW_COPY_AND_ASSIGN(SandboxDirectoryDatabaseTest);
146 TEST_F(SandboxDirectoryDatabaseTest, TestMissingFileGetInfo) {
147 FileId file_id = 888;
149 EXPECT_FALSE(db()->GetFileInfo(file_id, &info));
152 TEST_F(SandboxDirectoryDatabaseTest, TestGetRootFileInfoBeforeCreate) {
155 EXPECT_TRUE(db()->GetFileInfo(file_id, &info));
156 EXPECT_EQ(0, info.parent_id);
157 EXPECT_TRUE(info.name.empty());
158 EXPECT_TRUE(info.data_path.empty());
161 TEST_F(SandboxDirectoryDatabaseTest, TestMissingParentAddFileInfo) {
162 FileId parent_id = 7;
163 EXPECT_EQ(base::File::FILE_ERROR_NOT_A_DIRECTORY,
164 AddFileInfo(parent_id, FILE_PATH_LITERAL("foo")));
167 TEST_F(SandboxDirectoryDatabaseTest, TestAddNameClash) {
171 info.name = FILE_PATH_LITERAL("dir 0");
172 EXPECT_EQ(base::File::FILE_OK, db()->AddFileInfo(info, &file_id));
174 // Check for name clash in the root directory.
175 base::FilePath::StringType name = info.name;
176 EXPECT_EQ(base::File::FILE_ERROR_EXISTS, AddFileInfo(0, name));
177 name = FILE_PATH_LITERAL("dir 1");
178 EXPECT_EQ(base::File::FILE_OK, AddFileInfo(0, name));
180 name = FILE_PATH_LITERAL("subdir 0");
181 EXPECT_EQ(base::File::FILE_OK, AddFileInfo(file_id, name));
183 // Check for name clash in a subdirectory.
184 EXPECT_EQ(base::File::FILE_ERROR_EXISTS, AddFileInfo(file_id, name));
185 name = FILE_PATH_LITERAL("subdir 1");
186 EXPECT_EQ(base::File::FILE_OK, AddFileInfo(file_id, name));
189 TEST_F(SandboxDirectoryDatabaseTest, TestRenameNoMoveNameClash) {
192 base::FilePath::StringType name0 = FILE_PATH_LITERAL("foo");
193 base::FilePath::StringType name1 = FILE_PATH_LITERAL("bar");
194 base::FilePath::StringType name2 = FILE_PATH_LITERAL("bas");
197 EXPECT_EQ(base::File::FILE_OK, db()->AddFileInfo(info, &file_id0));
198 EXPECT_EQ(base::File::FILE_OK, AddFileInfo(0, name1));
200 EXPECT_FALSE(db()->UpdateFileInfo(file_id0, info));
202 EXPECT_TRUE(db()->UpdateFileInfo(file_id0, info));
205 TEST_F(SandboxDirectoryDatabaseTest, TestMoveSameNameNameClash) {
209 base::FilePath::StringType name0 = FILE_PATH_LITERAL("foo");
210 base::FilePath::StringType name1 = FILE_PATH_LITERAL("bar");
213 EXPECT_EQ(base::File::FILE_OK, db()->AddFileInfo(info, &file_id0));
214 info.parent_id = file_id0;
215 EXPECT_EQ(base::File::FILE_OK, db()->AddFileInfo(info, &file_id1));
217 EXPECT_FALSE(db()->UpdateFileInfo(file_id1, info));
219 EXPECT_TRUE(db()->UpdateFileInfo(file_id1, info));
222 TEST_F(SandboxDirectoryDatabaseTest, TestMoveRenameNameClash) {
226 base::FilePath::StringType name0 = FILE_PATH_LITERAL("foo");
227 base::FilePath::StringType name1 = FILE_PATH_LITERAL("bar");
228 base::FilePath::StringType name2 = FILE_PATH_LITERAL("bas");
231 EXPECT_EQ(base::File::FILE_OK, db()->AddFileInfo(info, &file_id0));
232 info.parent_id = file_id0;
234 EXPECT_EQ(base::File::FILE_OK, db()->AddFileInfo(info, &file_id1));
237 EXPECT_FALSE(db()->UpdateFileInfo(file_id1, info));
239 EXPECT_TRUE(db()->UpdateFileInfo(file_id1, info));
240 // Also test a successful move+rename.
241 info.parent_id = file_id0;
243 EXPECT_TRUE(db()->UpdateFileInfo(file_id1, info));
246 TEST_F(SandboxDirectoryDatabaseTest, TestRemoveWithChildren) {
251 info.name = FILE_PATH_LITERAL("foo");
252 EXPECT_EQ(base::File::FILE_OK, db()->AddFileInfo(info, &file_id0));
253 info.parent_id = file_id0;
254 EXPECT_EQ(base::File::FILE_OK, db()->AddFileInfo(info, &file_id1));
255 EXPECT_FALSE(db()->RemoveFileInfo(file_id0));
256 EXPECT_TRUE(db()->RemoveFileInfo(file_id1));
257 EXPECT_TRUE(db()->RemoveFileInfo(file_id0));
260 TEST_F(SandboxDirectoryDatabaseTest, TestGetChildWithName) {
264 base::FilePath::StringType name0 = FILE_PATH_LITERAL("foo");
265 base::FilePath::StringType name1 = FILE_PATH_LITERAL("bar");
268 EXPECT_EQ(base::File::FILE_OK, db()->AddFileInfo(info, &file_id0));
269 info.parent_id = file_id0;
271 EXPECT_EQ(base::File::FILE_OK, db()->AddFileInfo(info, &file_id1));
272 EXPECT_NE(file_id0, file_id1);
274 FileId check_file_id;
275 EXPECT_FALSE(db()->GetChildWithName(0, name1, &check_file_id));
276 EXPECT_TRUE(db()->GetChildWithName(0, name0, &check_file_id));
277 EXPECT_EQ(file_id0, check_file_id);
278 EXPECT_FALSE(db()->GetChildWithName(file_id0, name0, &check_file_id));
279 EXPECT_TRUE(db()->GetChildWithName(file_id0, name1, &check_file_id));
280 EXPECT_EQ(file_id1, check_file_id);
283 TEST_F(SandboxDirectoryDatabaseTest, TestGetFileWithPath) {
288 base::FilePath::StringType name0 = FILE_PATH_LITERAL("foo");
289 base::FilePath::StringType name1 = FILE_PATH_LITERAL("bar");
290 base::FilePath::StringType name2 = FILE_PATH_LITERAL("dog");
294 EXPECT_EQ(base::File::FILE_OK, db()->AddFileInfo(info, &file_id0));
295 info.parent_id = file_id0;
297 EXPECT_EQ(base::File::FILE_OK, db()->AddFileInfo(info, &file_id1));
298 EXPECT_NE(file_id0, file_id1);
299 info.parent_id = file_id1;
301 EXPECT_EQ(base::File::FILE_OK, db()->AddFileInfo(info, &file_id2));
302 EXPECT_NE(file_id0, file_id2);
303 EXPECT_NE(file_id1, file_id2);
305 FileId check_file_id;
306 base::FilePath path = base::FilePath(name0);
307 EXPECT_TRUE(db()->GetFileWithPath(path, &check_file_id));
308 EXPECT_EQ(file_id0, check_file_id);
310 path = path.Append(name1);
311 EXPECT_TRUE(db()->GetFileWithPath(path, &check_file_id));
312 EXPECT_EQ(file_id1, check_file_id);
314 path = path.Append(name2);
315 EXPECT_TRUE(db()->GetFileWithPath(path, &check_file_id));
316 EXPECT_EQ(file_id2, check_file_id);
319 TEST_F(SandboxDirectoryDatabaseTest, TestListChildren) {
320 // No children in the root.
321 std::vector<FileId> children;
322 EXPECT_TRUE(db()->ListChildren(0, &children));
323 EXPECT_TRUE(children.empty());
325 // One child in the root.
329 info.name = FILE_PATH_LITERAL("foo");
330 EXPECT_EQ(base::File::FILE_OK, db()->AddFileInfo(info, &file_id0));
331 EXPECT_TRUE(db()->ListChildren(0, &children));
332 EXPECT_EQ(children.size(), 1UL);
333 EXPECT_EQ(children[0], file_id0);
335 // Two children in the root.
337 info.name = FILE_PATH_LITERAL("bar");
338 EXPECT_EQ(base::File::FILE_OK, db()->AddFileInfo(info, &file_id1));
339 EXPECT_TRUE(db()->ListChildren(0, &children));
340 EXPECT_EQ(2UL, children.size());
341 if (children[0] == file_id0) {
342 EXPECT_EQ(children[1], file_id1);
344 EXPECT_EQ(children[1], file_id0);
345 EXPECT_EQ(children[0], file_id1);
348 // No children in a subdirectory.
349 EXPECT_TRUE(db()->ListChildren(file_id0, &children));
350 EXPECT_TRUE(children.empty());
352 // One child in a subdirectory.
353 info.parent_id = file_id0;
354 info.name = FILE_PATH_LITERAL("foo");
357 EXPECT_EQ(base::File::FILE_OK, db()->AddFileInfo(info, &file_id2));
358 EXPECT_TRUE(db()->ListChildren(file_id0, &children));
359 EXPECT_EQ(1UL, children.size());
360 EXPECT_EQ(children[0], file_id2);
362 // Two children in a subdirectory.
363 info.name = FILE_PATH_LITERAL("bar");
364 EXPECT_EQ(base::File::FILE_OK, db()->AddFileInfo(info, &file_id3));
365 EXPECT_TRUE(db()->ListChildren(file_id0, &children));
366 EXPECT_EQ(2UL, children.size());
367 if (children[0] == file_id2) {
368 EXPECT_EQ(children[1], file_id3);
370 EXPECT_EQ(children[1], file_id2);
371 EXPECT_EQ(children[0], file_id3);
375 TEST_F(SandboxDirectoryDatabaseTest, TestUpdateModificationTime) {
379 info0.name = FILE_PATH_LITERAL("name");
380 info0.data_path = base::FilePath(FILE_PATH_LITERAL("fake path"));
381 info0.modification_time = base::Time::Now();
382 EXPECT_EQ(base::File::FILE_OK, db()->AddFileInfo(info0, &file_id));
384 EXPECT_TRUE(db()->GetFileInfo(file_id, &info1));
385 EXPECT_EQ(info0.name, info1.name);
386 EXPECT_EQ(info0.parent_id, info1.parent_id);
387 EXPECT_EQ(info0.data_path, info1.data_path);
389 floor(info0.modification_time.ToDoubleT()),
390 info1.modification_time.ToDoubleT());
392 EXPECT_TRUE(db()->UpdateModificationTime(file_id, base::Time::UnixEpoch()));
393 EXPECT_TRUE(db()->GetFileInfo(file_id, &info1));
394 EXPECT_EQ(info0.name, info1.name);
395 EXPECT_EQ(info0.parent_id, info1.parent_id);
396 EXPECT_EQ(info0.data_path, info1.data_path);
397 EXPECT_NE(info0.modification_time, info1.modification_time);
399 info1.modification_time.ToDoubleT(),
400 floor(base::Time::UnixEpoch().ToDoubleT()));
402 EXPECT_FALSE(db()->UpdateModificationTime(999, base::Time::UnixEpoch()));
405 TEST_F(SandboxDirectoryDatabaseTest, TestSimpleFileOperations) {
406 FileId file_id = 888;
408 EXPECT_FALSE(db()->GetFileInfo(file_id, &info0));
410 info0.data_path = base::FilePath(FILE_PATH_LITERAL("foo"));
411 info0.name = FILE_PATH_LITERAL("file name");
412 info0.modification_time = base::Time::Now();
413 EXPECT_EQ(base::File::FILE_OK, db()->AddFileInfo(info0, &file_id));
415 EXPECT_TRUE(db()->GetFileInfo(file_id, &info1));
416 EXPECT_EQ(info0.parent_id, info1.parent_id);
417 EXPECT_EQ(info0.data_path, info1.data_path);
418 EXPECT_EQ(info0.name, info1.name);
420 floor(info0.modification_time.ToDoubleT()),
421 info1.modification_time.ToDoubleT());
424 TEST_F(SandboxDirectoryDatabaseTest, TestOverwritingMoveFileSrcDirectory) {
428 info0.name = FILE_PATH_LITERAL("directory");
429 info0.modification_time = base::Time::Now();
430 EXPECT_EQ(base::File::FILE_OK, db()->AddFileInfo(info0, &directory_id));
435 info1.data_path = base::FilePath(FILE_PATH_LITERAL("bar"));
436 info1.name = FILE_PATH_LITERAL("file");
437 info1.modification_time = base::Time::UnixEpoch();
438 EXPECT_EQ(base::File::FILE_OK, db()->AddFileInfo(info1, &file_id));
440 EXPECT_FALSE(db()->OverwritingMoveFile(directory_id, file_id));
443 TEST_F(SandboxDirectoryDatabaseTest, TestOverwritingMoveFileDestDirectory) {
447 info0.name = FILE_PATH_LITERAL("file");
448 info0.data_path = base::FilePath(FILE_PATH_LITERAL("bar"));
449 info0.modification_time = base::Time::Now();
450 EXPECT_EQ(base::File::FILE_OK, db()->AddFileInfo(info0, &file_id));
455 info1.name = FILE_PATH_LITERAL("directory");
456 info1.modification_time = base::Time::UnixEpoch();
457 EXPECT_EQ(base::File::FILE_OK, db()->AddFileInfo(info1, &directory_id));
459 EXPECT_FALSE(db()->OverwritingMoveFile(file_id, directory_id));
462 TEST_F(SandboxDirectoryDatabaseTest, TestOverwritingMoveFileSuccess) {
466 info0.data_path = base::FilePath(FILE_PATH_LITERAL("foo"));
467 info0.name = FILE_PATH_LITERAL("file name 0");
468 info0.modification_time = base::Time::Now();
469 EXPECT_EQ(base::File::FILE_OK, db()->AddFileInfo(info0, &file_id0));
473 dir_info.parent_id = 0;
474 dir_info.name = FILE_PATH_LITERAL("directory name");
475 EXPECT_EQ(base::File::FILE_OK, db()->AddFileInfo(dir_info, &dir_id));
479 info1.parent_id = dir_id;
480 info1.data_path = base::FilePath(FILE_PATH_LITERAL("bar"));
481 info1.name = FILE_PATH_LITERAL("file name 1");
482 info1.modification_time = base::Time::UnixEpoch();
483 EXPECT_EQ(base::File::FILE_OK, db()->AddFileInfo(info1, &file_id1));
485 EXPECT_TRUE(db()->OverwritingMoveFile(file_id0, file_id1));
490 EXPECT_FALSE(db()->GetFileWithPath(base::FilePath(info0.name), &check_id));
491 EXPECT_TRUE(db()->GetFileWithPath(
492 base::FilePath(dir_info.name).Append(info1.name), &check_id));
493 EXPECT_TRUE(db()->GetFileInfo(check_id, &check_info));
495 EXPECT_EQ(info0.data_path, check_info.data_path);
498 TEST_F(SandboxDirectoryDatabaseTest, TestGetNextInteger) {
500 EXPECT_TRUE(db()->GetNextInteger(&next));
502 EXPECT_TRUE(db()->GetNextInteger(&next));
505 EXPECT_TRUE(db()->GetNextInteger(&next));
507 EXPECT_TRUE(db()->GetNextInteger(&next));
510 EXPECT_TRUE(db()->GetNextInteger(&next));
514 TEST_F(SandboxDirectoryDatabaseTest, TestConsistencyCheck_Empty) {
515 EXPECT_TRUE(db()->IsFileSystemConsistent());
518 EXPECT_TRUE(db()->GetNextInteger(&next));
520 EXPECT_TRUE(db()->IsFileSystemConsistent());
523 TEST_F(SandboxDirectoryDatabaseTest, TestConsistencyCheck_Consistent) {
525 CreateFile(0, FPL("foo"), FPL("hoge"), NULL);
526 CreateDirectory(0, FPL("bar"), &dir_id);
527 CreateFile(dir_id, FPL("baz"), FPL("fuga"), NULL);
528 CreateFile(dir_id, FPL("fizz"), FPL("buzz"), NULL);
530 EXPECT_TRUE(db()->IsFileSystemConsistent());
533 TEST_F(SandboxDirectoryDatabaseTest,
534 TestConsistencyCheck_BackingMultiEntry) {
535 const base::FilePath::CharType kBackingFileName[] = FPL("the celeb");
536 CreateFile(0, FPL("foo"), kBackingFileName, NULL);
538 EXPECT_TRUE(db()->IsFileSystemConsistent());
539 ASSERT_TRUE(base::DeleteFile(path().Append(kBackingFileName), false));
540 CreateFile(0, FPL("bar"), kBackingFileName, NULL);
541 EXPECT_FALSE(db()->IsFileSystemConsistent());
544 TEST_F(SandboxDirectoryDatabaseTest, TestConsistencyCheck_FileLost) {
545 const base::FilePath::CharType kBackingFileName[] = FPL("hoge");
546 CreateFile(0, FPL("foo"), kBackingFileName, NULL);
548 EXPECT_TRUE(db()->IsFileSystemConsistent());
549 ASSERT_TRUE(base::DeleteFile(path().Append(kBackingFileName), false));
550 EXPECT_TRUE(db()->IsFileSystemConsistent());
553 TEST_F(SandboxDirectoryDatabaseTest, TestConsistencyCheck_OrphanFile) {
554 CreateFile(0, FPL("foo"), FPL("hoge"), NULL);
556 EXPECT_TRUE(db()->IsFileSystemConsistent());
558 base::File file(path().Append(FPL("Orphan File")),
559 base::File::FLAG_CREATE | base::File::FLAG_WRITE);
560 ASSERT_TRUE(file.IsValid());
561 ASSERT_TRUE(file.created());
564 EXPECT_TRUE(db()->IsFileSystemConsistent());
567 TEST_F(SandboxDirectoryDatabaseTest, TestConsistencyCheck_RootLoop) {
568 EXPECT_TRUE(db()->IsFileSystemConsistent());
569 MakeHierarchyLink(0, 0, base::FilePath::StringType());
570 EXPECT_FALSE(db()->IsFileSystemConsistent());
573 TEST_F(SandboxDirectoryDatabaseTest, TestConsistencyCheck_DirectoryLoop) {
576 base::FilePath::StringType dir1_name = FPL("foo");
577 CreateDirectory(0, dir1_name, &dir1_id);
578 CreateDirectory(dir1_id, FPL("bar"), &dir2_id);
580 EXPECT_TRUE(db()->IsFileSystemConsistent());
581 MakeHierarchyLink(dir2_id, dir1_id, dir1_name);
582 EXPECT_FALSE(db()->IsFileSystemConsistent());
585 TEST_F(SandboxDirectoryDatabaseTest, TestConsistencyCheck_NameMismatch) {
588 CreateDirectory(0, FPL("foo"), &dir_id);
589 CreateFile(dir_id, FPL("bar"), FPL("hoge/fuga/piyo"), &file_id);
591 EXPECT_TRUE(db()->IsFileSystemConsistent());
592 DeleteHierarchyLink(file_id);
593 MakeHierarchyLink(dir_id, file_id, FPL("baz"));
594 EXPECT_FALSE(db()->IsFileSystemConsistent());
597 TEST_F(SandboxDirectoryDatabaseTest, TestConsistencyCheck_WreckedEntries) {
600 CreateDirectory(0, FPL("foo"), &dir1_id);
601 CreateDirectory(dir1_id, FPL("bar"), &dir2_id);
602 CreateFile(dir2_id, FPL("baz"), FPL("fizz/buzz"), NULL);
604 EXPECT_TRUE(db()->IsFileSystemConsistent());
605 DeleteHierarchyLink(dir2_id); // Delete link from |dir1_id| to |dir2_id|.
606 EXPECT_FALSE(db()->IsFileSystemConsistent());
609 TEST_F(SandboxDirectoryDatabaseTest, TestRepairDatabase_Success) {
610 base::FilePath::StringType kFileName = FPL("bar");
613 CreateFile(0, FPL("foo"), FPL("hoge"), NULL);
614 CreateFile(0, kFileName, FPL("fuga"), &file_id_prev);
616 const base::FilePath kDatabaseDirectory =
617 path().Append(kDirectoryDatabaseName);
619 CorruptDatabase(kDatabaseDirectory, leveldb::kDescriptorFile,
620 0, std::numeric_limits<size_t>::max());
622 EXPECT_FALSE(db()->IsFileSystemConsistent());
625 EXPECT_TRUE(db()->GetChildWithName(0, kFileName, &file_id));
626 EXPECT_EQ(file_id_prev, file_id);
628 EXPECT_TRUE(db()->IsFileSystemConsistent());
631 TEST_F(SandboxDirectoryDatabaseTest, TestRepairDatabase_Failure) {
632 base::FilePath::StringType kFileName = FPL("bar");
634 CreateFile(0, FPL("foo"), FPL("hoge"), NULL);
635 CreateFile(0, kFileName, FPL("fuga"), NULL);
637 const base::FilePath kDatabaseDirectory =
638 path().Append(kDirectoryDatabaseName);
640 CorruptDatabase(kDatabaseDirectory, leveldb::kDescriptorFile,
641 0, std::numeric_limits<size_t>::max());
642 CorruptDatabase(kDatabaseDirectory, leveldb::kLogFile,
645 EXPECT_FALSE(db()->IsFileSystemConsistent());
648 EXPECT_FALSE(db()->GetChildWithName(0, kFileName, &file_id));
649 EXPECT_TRUE(db()->IsFileSystemConsistent());
652 TEST_F(SandboxDirectoryDatabaseTest, TestRepairDatabase_MissingManifest) {
653 base::FilePath::StringType kFileName = FPL("bar");
656 CreateFile(0, FPL("foo"), FPL("hoge"), NULL);
657 CreateFile(0, kFileName, FPL("fuga"), &file_id_prev);
659 const base::FilePath kDatabaseDirectory =
660 path().Append(kDirectoryDatabaseName);
663 DeleteDatabaseFile(kDatabaseDirectory, leveldb::kDescriptorFile);
666 EXPECT_FALSE(db()->IsFileSystemConsistent());
669 EXPECT_TRUE(db()->GetChildWithName(0, kFileName, &file_id));
670 EXPECT_EQ(file_id_prev, file_id);
672 EXPECT_TRUE(db()->IsFileSystemConsistent());
675 } // namespace content