Lines Matching refs:base
15 #include "base/files/file.h"
16 #include "base/files/file_enumerator.h"
17 #include "base/files/file_path.h"
18 #include "base/files/file_util.h"
19 #include "base/files/scoped_temp_dir.h"
20 #include "base/functional/bind.h"
21 #include "base/logging.h"
22 #include "base/path_service.h"
23 #include "base/strings/strcat.h"
24 #include "base/strings/string_util.h"
25 #include "base/strings/stringprintf.h"
26 #include "base/test/bind.h"
27 #include "base/time/time.h"
37 #define FP(path) base::FilePath(FILE_PATH_LITERAL(path))
44 std::vector<std::string> GetRelativePaths(const base::FilePath& dir,
45 base::FileEnumerator::FileType type) {
47 base::FileEnumerator files(dir, true, type);
48 for (base::FilePath path = files.Next(); !path.empty(); path = files.Next()) {
49 base::FilePath relative;
54 EXPECT_EQ(base::File::FILE_OK, files.GetError());
59 base::FilePath* file_path,
60 base::File* file) {
61 if (!base::CreateTemporaryFile(file_path))
64 if (base::WriteFile(*file_path, content.data(), content.size()) == -1)
67 *file = base::File(
68 *file_path, base::File::Flags::FLAG_OPEN | base::File::Flags::FLAG_READ);
86 void SetTimeModified(const base::Time& time) override { LogProgress(); }
92 const base::TimeTicks now = base::TimeTicks::Now();
105 const base::TimeDelta progress_period_ = base::Seconds(1);
106 base::TimeTicks next_progress_report_time_ =
107 base::TimeTicks::Now() + progress_period_;
125 base::FilePath test_dir;
126 base::FilePath foo_txt_path = test_dir.AppendASCII("foo.txt");
128 base::FilePath file_path;
129 base::File file;
134 base::FilePath bar_dir = test_dir.AppendASCII("bar");
135 base::FilePath bar1_txt_path = bar_dir.AppendASCII("bar1.txt");
140 base::FilePath bar2_txt_path = bar_dir.AppendASCII("bar2.txt");
145 file_tree_[base::FilePath()] = {{foo_txt_path}, {bar_dir}};
159 std::vector<base::File>* const files) override {
163 for (const base::FilePath& path : paths) {
176 bool List(const base::FilePath& path,
177 std::vector<base::FilePath>* const files,
178 std::vector<base::FilePath>* const subdirs) override {
187 for (const base::FilePath& file : it->second.files) {
192 for (const base::FilePath& subdir : it->second.subdirs) {
200 bool GetInfo(const base::FilePath& path, Info* const info) override {
209 base::Time::FromSecondsSinceUnixEpoch(172097977); // Some random date.
215 std::vector<base::FilePath> files, subdirs;
218 std::unordered_map<base::FilePath, DirContents> file_tree_;
219 std::unordered_map<base::FilePath, base::File> files_;
238 base::FilePath zip_path(test_dir_);
257 static base::FilePath GetDataDirectory() {
258 base::FilePath path;
259 bool success = base::PathService::Get(base::DIR_SRC_TEST_DATA_ROOT, &path);
269 void TestUnzipFile(const base::FilePath::StringType& filename,
274 void TestUnzipFile(const base::FilePath& path, bool expect_hidden_files) {
275 ASSERT_TRUE(base::PathExists(path)) << "no file " << path;
278 base::FilePath original_dir = GetDataDirectory().AppendASCII("test");
280 base::FileEnumerator files(
282 base::FileEnumerator::FILES | base::FileEnumerator::DIRECTORIES);
285 for (base::FilePath unzipped_entry_path = files.Next();
291 if (base::PathExists(unzipped_entry_path) &&
292 !base::DirectoryExists(unzipped_entry_path)) {
294 base::FilePath relative_path;
299 base::FilePath original_path = original_dir.Append(relative_path);
300 EXPECT_TRUE(base::ContentsEqual(original_path, unzipped_entry_path))
305 EXPECT_EQ(base::File::FILE_OK, files.GetError());
308 for (const base::FilePath& path : zip_contents_) {
325 base::ScopedTempDir temp_dir;
328 base::FilePath zip_file = temp_dir.GetPath().AppendASCII("out.zip");
329 base::FilePath src_dir = temp_dir.GetPath().AppendASCII("input");
330 base::FilePath out_dir = temp_dir.GetPath().AppendASCII("output");
332 base::FilePath src_file = src_dir.AppendASCII("test.txt");
333 base::FilePath out_file = out_dir.AppendASCII("test.txt");
335 EXPECT_TRUE(base::CreateDirectory(src_dir));
336 EXPECT_TRUE(base::CreateDirectory(out_dir));
338 base::Time test_mtime;
339 ASSERT_TRUE(base::Time::FromString(date_time, &test_mtime));
344 base::Time::Exploded now_parts;
345 base::Time::Now().UTCExplode(&now_parts);
348 base::Time now_time;
349 EXPECT_TRUE(base::Time::FromUTCExploded(now_parts, &now_time));
351 EXPECT_EQ(1, base::WriteFile(src_file, "1", 1));
352 EXPECT_TRUE(base::TouchFile(src_file, base::Time::Now(), test_mtime));
357 base::File::Info file_info;
358 EXPECT_TRUE(base::GetFileInfo(out_file, &file_info));
370 base::FilePath test_dir_;
372 base::ScopedTempDir temp_dir_;
375 std::unordered_set<base::FilePath> zip_contents_;
378 std::vector<base::FilePath> zip_file_list_;
385 GetRelativePaths(test_dir_, base::FileEnumerator::FileType::FILES),
388 GetRelativePaths(test_dir_, base::FileEnumerator::FileType::DIRECTORIES),
401 base::FilePath path = GetDataDirectory().AppendASCII("evil.zip");
405 base::FilePath output_dir = test_dir_.AppendASCII("out");
407 EXPECT_TRUE(base::PathExists(output_dir.AppendASCII(
413 base::FilePath path =
416 base::FilePath output_dir = test_dir_.AppendASCII("out");
418 ASSERT_TRUE(base::PathExists(
419 output_dir.Append(base::FilePath::FromUTF8Unsafe(".�.�evil.txt"))));
420 ASSERT_FALSE(base::PathExists(output_dir.AppendASCII("../evil.txt")));
424 auto filter = base::BindRepeating([](const base::FilePath& path) {
431 GetRelativePaths(test_dir_, base::FileEnumerator::FileType::FILES),
434 GetRelativePaths(test_dir_, base::FileEnumerator::FileType::DIRECTORIES),
440 auto filter = base::BindRepeating([](const base::FilePath& path) {
441 return !base::StartsWith(path.MaybeAsASCII(), "Encrypted AES");
449 ASSERT_TRUE(base::ReadFileToString(test_dir_.AppendASCII("ClearText.txt"),
453 ASSERT_TRUE(base::ReadFileToString(
460 auto filter = base::BindRepeating([](const base::FilePath& path) {
461 return !base::StartsWith(path.MaybeAsASCII(), "Encrypted AES");
469 ASSERT_TRUE(base::ReadFileToString(test_dir_.AppendASCII("ClearText.txt"),
475 GetRelativePaths(test_dir_, base::FileEnumerator::FileType::FILES),
481 auto filter = base::BindRepeating([](const base::FilePath& path) {
482 return !base::StartsWith(path.MaybeAsASCII(), "Encrypted AES");
490 ASSERT_TRUE(base::ReadFileToString(test_dir_.AppendASCII("ClearText.txt"),
496 GetRelativePaths(test_dir_, base::FileEnumerator::FileType::FILES),
506 EXPECT_TRUE(base::ReadFileToString(test_dir_.AppendASCII("ClearText.txt"),
512 GetRelativePaths(test_dir_, base::FileEnumerator::FileType::FILES),
522 GetRelativePaths(test_dir_, base::FileEnumerator::FileType::FILES),
531 GetRelativePaths(test_dir_, base::FileEnumerator::FileType::FILES),
535 GetRelativePaths(test_dir_, base::FileEnumerator::FileType::DIRECTORIES),
544 GetRelativePaths(test_dir_, base::FileEnumerator::FileType::FILES),
549 base::ReadFileToString(test_dir_.AppendASCII("repeated"), &contents));
559 GetRelativePaths(test_dir_, base::FileEnumerator::FileType::FILES),
563 GetRelativePaths(test_dir_, base::FileEnumerator::FileType::DIRECTORIES),
568 base::ReadFileToString(test_dir_.AppendASCII("repeated"), &contents));
578 GetRelativePaths(test_dir_, base::FileEnumerator::FileType::FILES),
582 GetRelativePaths(test_dir_, base::FileEnumerator::FileType::DIRECTORIES),
587 base::ReadFileToString(test_dir_.AppendASCII("repeated"), &contents));
644 GetRelativePaths(test_dir_, base::FileEnumerator::FileType::FILES);
662 EXPECT_TRUE(base::ReadFileToString(test_dir_.AppendASCII(path), &contents));
663 EXPECT_EQ(base::StrCat({"This is: ", path}), contents);
679 GetRelativePaths(test_dir_, base::FileEnumerator::FileType::FILES),
683 EXPECT_TRUE(base::ReadFileToString(test_dir_.AppendASCII("Case"), &contents));
692 GetRelativePaths(test_dir_, base::FileEnumerator::FileType::FILES),
696 EXPECT_TRUE(base::ReadFileToString(test_dir_.AppendASCII("Case"), &contents));
699 EXPECT_TRUE(base::ReadFileToString(test_dir_.AppendASCII("case"), &contents));
702 EXPECT_TRUE(base::ReadFileToString(test_dir_.AppendASCII("CASE"), &contents));
717 GetRelativePaths(test_dir_, base::FileEnumerator::FileType::FILES),
720 EXPECT_TRUE(base::ReadFileToString(test_dir_.AppendASCII("Case"), &contents));
725 GetRelativePaths(test_dir_, base::FileEnumerator::FileType::FILES),
728 EXPECT_TRUE(base::ReadFileToString(test_dir_.AppendASCII("Case"), &contents));
731 EXPECT_TRUE(base::ReadFileToString(test_dir_.AppendASCII("case"), &contents));
734 EXPECT_TRUE(base::ReadFileToString(test_dir_.AppendASCII("CASE"), &contents));
859 GetRelativePaths(test_dir_, base::FileEnumerator::FileType::FILES);
878 GetRelativePaths(test_dir_, base::FileEnumerator::FileType::DIRECTORIES),
901 base::BindLambdaForTesting([this](const base::FilePath& entry_path) {
902 return base::CreateDirectory(test_dir_.Append(entry_path));
905 base::BindLambdaForTesting([this](const base::FilePath& entry_path)
911 base::File file(GetDataDirectory().AppendASCII("test.zip"),
912 base::File::Flags::FLAG_OPEN | base::File::Flags::FLAG_READ);
914 base::FilePath dir = test_dir_;
915 base::FilePath dir_foo = dir.AppendASCII("foo");
916 base::FilePath dir_foo_bar = dir_foo.AppendASCII("bar");
917 EXPECT_TRUE(base::PathExists(dir.AppendASCII("foo.txt")));
918 EXPECT_TRUE(base::DirectoryExists(dir_foo));
919 EXPECT_TRUE(base::PathExists(dir_foo.AppendASCII("bar.txt")));
920 EXPECT_TRUE(base::DirectoryExists(dir_foo_bar));
921 EXPECT_TRUE(base::PathExists(dir_foo_bar.AppendASCII(".hidden")));
922 EXPECT_TRUE(base::PathExists(dir_foo_bar.AppendASCII("baz.txt")));
923 EXPECT_TRUE(base::PathExists(dir_foo_bar.AppendASCII("quux.txt")));
928 base::BindLambdaForTesting([this](const base::FilePath& entry_path) {
929 return base::CreateDirectory(test_dir_.Append(entry_path));
934 base::BindLambdaForTesting([](const base::FilePath& entry_path) {
938 base::File file(GetDataDirectory().AppendASCII("test.zip"),
939 base::File::Flags::FLAG_OPEN | base::File::Flags::FLAG_READ);
942 base::FilePath dir = test_dir_;
943 base::FilePath dir_foo = dir.AppendASCII("foo");
944 base::FilePath dir_foo_bar = dir_foo.AppendASCII("bar");
945 EXPECT_FALSE(base::PathExists(dir.AppendASCII("foo.txt")));
946 EXPECT_TRUE(base::DirectoryExists(dir_foo));
947 EXPECT_FALSE(base::PathExists(dir_foo.AppendASCII("bar.txt")));
948 EXPECT_TRUE(base::DirectoryExists(dir_foo_bar));
949 EXPECT_FALSE(base::PathExists(dir_foo_bar.AppendASCII(".hidden")));
950 EXPECT_FALSE(base::PathExists(dir_foo_bar.AppendASCII("baz.txt")));
951 EXPECT_FALSE(base::PathExists(dir_foo_bar.AppendASCII("quux.txt")));
960 const base::FilePath dir =
961 test_dir_.Append(base::FilePath::FromUTF8Unsafe("新しいフォルダ"));
962 EXPECT_TRUE(base::DirectoryExists(dir));
965 ASSERT_TRUE(base::ReadFileToString(
966 dir.Append(base::FilePath::FromUTF8Unsafe("SJIS_835C_ソ.txt")),
973 ASSERT_TRUE(base::ReadFileToString(dir.Append(base::FilePath::FromUTF8Unsafe(
988 EXPECT_FALSE(base::DirectoryExists(
989 test_dir_.Append(base::FilePath::FromUTF8Unsafe("新しいフォルダ"))));
991 const base::FilePath dir =
992 test_dir_.Append(base::FilePath::FromUTF8Unsafe("�V�����t�H���_"));
993 EXPECT_TRUE(base::DirectoryExists(dir));
996 ASSERT_TRUE(base::ReadFileToString(
997 dir.Append(base::FilePath::FromUTF8Unsafe("SJIS_835C_��.txt")),
1004 ASSERT_TRUE(base::ReadFileToString(dir.Append(base::FilePath::FromUTF8Unsafe(
1011 base::FilePath src_dir = GetDataDirectory().AppendASCII("test");
1013 base::ScopedTempDir temp_dir;
1015 base::FilePath zip_file = temp_dir.GetPath().AppendASCII("out.zip");
1022 base::FilePath src_dir = GetDataDirectory().AppendASCII("test");
1024 base::ScopedTempDir temp_dir;
1026 base::FilePath zip_file = temp_dir.GetPath().AppendASCII("out.zip");
1033 base::FilePath src_dir = GetDataDirectory().AppendASCII("test");
1035 base::ScopedTempDir temp_dir;
1038 base::FilePath src_dir_russian = temp_dir.GetPath().Append(
1039 base::FilePath::FromUTF8Unsafe("\xD0\xA2\xD0\xB5\xD1\x81\xD1\x82"));
1040 base::CopyDirectory(src_dir, src_dir_russian, true);
1041 base::FilePath zip_file = temp_dir.GetPath().AppendASCII("out_russian.zip");
1071 base::FilePath src_dir = GetDataDirectory().AppendASCII("test");
1073 base::ScopedTempDir temp_dir;
1075 base::FilePath zip_name = temp_dir.GetPath().AppendASCII("out.zip");
1077 base::File zip_file(zip_name,
1078 base::File::FLAG_CREATE | base::File::FLAG_WRITE);
1100 base::FilePath test_zip_file =
1103 base::ScopedTempDir scoped_temp_dir;
1105 const base::FilePath& temp_dir = scoped_temp_dir.GetPath();
1108 EXPECT_TRUE(base::DirectoryExists(temp_dir.AppendASCII("d")));
1111 SCOPED_TRACE(base::StringPrintf("Processing %d.txt", i));
1112 base::FilePath file_path =
1113 temp_dir.AppendASCII(base::StringPrintf("%d.txt", i));
1115 EXPECT_TRUE(base::GetFileSize(file_path, &file_size));
1121 base::FilePath zip_file;
1122 ASSERT_TRUE(base::CreateTemporaryFile(&zip_file));
1128 base::ScopedTempDir scoped_temp_dir;
1130 const base::FilePath& temp_dir = scoped_temp_dir.GetPath();
1132 base::FilePath bar_dir = temp_dir.AppendASCII("bar");
1133 EXPECT_TRUE(base::DirectoryExists(bar_dir));
1136 base::ReadFileToString(temp_dir.AppendASCII("foo.txt"), &file_content));
1139 base::ReadFileToString(bar_dir.AppendASCII("bar1.txt"), &file_content));
1142 base::ReadFileToString(bar_dir.AppendASCII("bar2.txt"), &file_content));
1148 base::FilePath src_dir = GetDataDirectory().AppendASCII("test");
1150 base::ScopedTempDir temp_dir;
1152 base::FilePath zip_file = temp_dir.GetPath().AppendASCII("out.zip");
1158 base::BindLambdaForTesting([&](const zip::Progress& progress) {
1185 base::FilePath src_dir = GetDataDirectory().AppendASCII("test");
1187 base::ScopedTempDir temp_dir;
1189 base::FilePath zip_file = temp_dir.GetPath().AppendASCII("out.zip");
1195 base::BindLambdaForTesting([&](const zip::Progress& progress) {
1211 .progress_period = base::Hours(1)}));
1224 base::FilePath src_dir = GetDataDirectory().AppendASCII("test");
1226 base::ScopedTempDir temp_dir;
1228 base::FilePath zip_file = temp_dir.GetPath().AppendASCII("out.zip");
1235 .progress_callback = base::BindLambdaForTesting(
1248 .progress_callback = base::BindLambdaForTesting(
1286 base::ScopedTempDir temp_dir;
1289 const base::FilePath src_dir = temp_dir.GetPath().AppendASCII("input");
1290 EXPECT_TRUE(base::CreateDirectory(src_dir));
1293 for (const base::StringPiece s : {"foo", "bar.txt", ".hidden"}) {
1294 base::File f(src_dir.AppendASCII(s),
1295 base::File::FLAG_CREATE | base::File::FLAG_WRITE);
1300 const base::FilePath dest_file = temp_dir.GetPath().AppendASCII("dest.zip");
1308 ASSERT_TRUE(base::GetFileSize(dest_file, &dest_file_size));
1316 base::ScopedTempDir temp_dir;
1319 const base::FilePath src_dir = temp_dir.GetPath().AppendASCII("input");
1320 EXPECT_TRUE(base::CreateDirectory(src_dir));
1327 base::File f(src_dir.AppendASCII("src.zip"),
1328 base::File::FLAG_CREATE | base::File::FLAG_WRITE);
1333 const base::FilePath dest_file = temp_dir.GetPath().AppendASCII("dest.zip");
1340 ASSERT_TRUE(base::GetFileSize(dest_file, &dest_file_size));
1369 base::ScopedTempDir temp_dir;
1372 const base::FilePath src_dir = temp_dir.GetPath().AppendASCII("input");
1373 EXPECT_TRUE(base::CreateDirectory(src_dir));
1379 const base::FilePath src_file = src_dir.AppendASCII("src.zip");
1382 base::File f(src_file, base::File::FLAG_CREATE | base::File::FLAG_WRITE);
1387 const base::FilePath dest_file = temp_dir.GetPath().AppendASCII("dest.zip");
1390 base::BindLambdaForTesting([&](const zip::Progress& progress) {
1398 .progress_period = base::Seconds(1)}));
1404 ASSERT_TRUE(base::GetFileSize(dest_file, &dest_file_size));