1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
|
// Copyright 2013 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "chrome/browser/chromeos/file_manager/zip_file_creator.h"
#include <vector>
#include "base/bind.h"
#include "base/files/file_path.h"
#include "base/files/file_util.h"
#include "base/files/scoped_temp_dir.h"
#include "base/rand_util.h"
#include "base/run_loop.h"
#include "chrome/test/base/in_process_browser_test.h"
#include "content/public/test/test_utils.h"
#include "testing/gtest/include/gtest/gtest.h"
#include "third_party/zlib/google/zip_reader.h"
namespace file_manager {
namespace {
void TestCallback(bool* out_success, const base::Closure& quit, bool success) {
*out_success = success;
quit.Run();
}
class ZipFileCreatorTest : public InProcessBrowserTest {
protected:
virtual void SetUpOnMainThread() override {
ASSERT_TRUE(dir_.CreateUniqueTempDir());
ASSERT_TRUE(base::CreateDirectory(zip_base_dir()));
}
base::FilePath zip_archive_path() const {
return dir_.path().AppendASCII("test.zip");
}
base::FilePath zip_base_dir() const {
return dir_.path().AppendASCII("files");
}
protected:
base::ScopedTempDir dir_;
};
} // namespace
IN_PROC_BROWSER_TEST_F(ZipFileCreatorTest, FailZipForAbsentFile) {
base::RunLoop run_loop;
bool success = true;
std::vector<base::FilePath> paths;
paths.push_back(base::FilePath(FILE_PATH_LITERAL("not.exist")));
(new ZipFileCreator(
base::Bind(
&TestCallback, &success, content::GetQuitTaskForRunLoop(&run_loop)),
zip_base_dir(),
paths,
zip_archive_path()))->Start();
content::RunThisRunLoop(&run_loop);
EXPECT_FALSE(success);
}
IN_PROC_BROWSER_TEST_F(ZipFileCreatorTest, SomeFilesZip) {
// Prepare files.
const base::FilePath kDir1(FILE_PATH_LITERAL("foo"));
const base::FilePath kFile1(kDir1.AppendASCII("bar"));
const base::FilePath kFile2(FILE_PATH_LITERAL("random"));
const int kRandomDataSize = 100000;
const std::string kRandomData = base::RandBytesAsString(kRandomDataSize);
base::CreateDirectory(zip_base_dir().Append(kDir1));
base::WriteFile(zip_base_dir().Append(kFile1), "123", 3);
base::WriteFile(zip_base_dir().Append(kFile2),
kRandomData.c_str(), kRandomData.size());
bool success = false;
base::RunLoop run_loop;
std::vector<base::FilePath> paths;
paths.push_back(kDir1);
paths.push_back(kFile1);
paths.push_back(kFile2);
(new ZipFileCreator(
base::Bind(
&TestCallback, &success, content::GetQuitTaskForRunLoop(&run_loop)),
zip_base_dir(),
paths,
zip_archive_path()))->Start();
content::RunThisRunLoop(&run_loop);
EXPECT_TRUE(success);
// Check the archive content.
zip::ZipReader reader;
ASSERT_TRUE(reader.Open(zip_archive_path()));
EXPECT_EQ(3, reader.num_entries());
while (reader.HasMore()) {
ASSERT_TRUE(reader.OpenCurrentEntryInZip());
const zip::ZipReader::EntryInfo* entry = reader.current_entry_info();
// ZipReader returns directory path with trailing slash.
if (entry->file_path() == kDir1.AsEndingWithSeparator()) {
EXPECT_TRUE(entry->is_directory());
} else if (entry->file_path() == kFile1) {
EXPECT_FALSE(entry->is_directory());
EXPECT_EQ(3, entry->original_size());
} else if (entry->file_path() == kFile2) {
EXPECT_FALSE(entry->is_directory());
EXPECT_EQ(kRandomDataSize, entry->original_size());
const base::FilePath out = dir_.path().AppendASCII("archived_content");
EXPECT_TRUE(reader.ExtractCurrentEntryToFilePath(out));
EXPECT_TRUE(base::ContentsEqual(zip_base_dir().Append(kFile2), out));
} else {
ADD_FAILURE();
}
ASSERT_TRUE(reader.AdvanceToNextEntry());
}
}
} // namespace file_manager
|
