]>
Commit | Line | Data |
---|---|---|
1 | #include <config.h> | |
2 | ||
3 | #include <apt-pkg/error.h> | |
4 | #include <apt-pkg/fileutl.h> | |
5 | #include <apt-pkg/strutl.h> | |
6 | #include <apt-pkg/aptconfiguration.h> | |
7 | ||
8 | #include <string> | |
9 | #include <vector> | |
10 | #include <stdlib.h> | |
11 | #include <string.h> | |
12 | ||
13 | #include <gtest/gtest.h> | |
14 | ||
15 | #include "file-helpers.h" | |
16 | ||
17 | static void TestFileFd(mode_t const a_umask, mode_t const ExpectedFilePermission, | |
18 | unsigned int const filemode, APT::Configuration::Compressor const &compressor) | |
19 | { | |
20 | std::string trace; | |
21 | strprintf(trace, "TestFileFd: Compressor: %s umask: %#o permission: %#o mode: %d", compressor.Name.c_str(), a_umask, ExpectedFilePermission, filemode); | |
22 | SCOPED_TRACE(trace); | |
23 | ||
24 | static const char* fname = "apt-filefd-test.txt"; | |
25 | if (FileExists(fname) == true) | |
26 | EXPECT_EQ(0, unlink(fname)); | |
27 | ||
28 | FileFd f; | |
29 | umask(a_umask); | |
30 | EXPECT_TRUE(f.Open(fname, filemode, compressor)); | |
31 | EXPECT_TRUE(f.IsOpen()); | |
32 | EXPECT_FALSE(f.Failed()); | |
33 | EXPECT_EQ(umask(a_umask), a_umask); | |
34 | ||
35 | std::string test = "This is a test!\n"; | |
36 | EXPECT_TRUE(f.Write(test.c_str(), test.size())); | |
37 | EXPECT_TRUE(f.IsOpen()); | |
38 | EXPECT_FALSE(f.Failed()); | |
39 | ||
40 | f.Close(); | |
41 | EXPECT_FALSE(f.IsOpen()); | |
42 | EXPECT_FALSE(f.Failed()); | |
43 | ||
44 | EXPECT_TRUE(f.Open(fname, FileFd::ReadOnly, compressor)); | |
45 | EXPECT_TRUE(f.IsOpen()); | |
46 | EXPECT_FALSE(f.Failed()); | |
47 | EXPECT_FALSE(f.Eof()); | |
48 | EXPECT_NE(0, f.FileSize()); | |
49 | EXPECT_FALSE(f.Failed()); | |
50 | EXPECT_NE(0, f.ModificationTime()); | |
51 | EXPECT_FALSE(f.Failed()); | |
52 | ||
53 | // ensure the memory is as predictably messed up | |
54 | #define APT_INIT_READBACK \ | |
55 | char readback[20]; \ | |
56 | memset(readback, 'D', sizeof(readback)/sizeof(readback[0])); \ | |
57 | readback[19] = '\0'; | |
58 | #define EXPECT_N_STR(expect, actual) \ | |
59 | EXPECT_EQ(0, strncmp(expect, actual, strlen(expect))); | |
60 | ||
61 | { | |
62 | APT_INIT_READBACK | |
63 | char const * const expect = "This"; | |
64 | EXPECT_TRUE(f.Read(readback, strlen(expect))); | |
65 | EXPECT_FALSE(f.Failed()); | |
66 | EXPECT_FALSE(f.Eof()); | |
67 | EXPECT_N_STR(expect, readback); | |
68 | EXPECT_EQ(strlen(expect), f.Tell()); | |
69 | } | |
70 | { | |
71 | APT_INIT_READBACK | |
72 | char const * const expect = "test!\n"; | |
73 | EXPECT_TRUE(f.Skip((test.size() - f.Tell()) - strlen(expect))); | |
74 | EXPECT_TRUE(f.Read(readback, strlen(expect))); | |
75 | EXPECT_FALSE(f.Failed()); | |
76 | EXPECT_FALSE(f.Eof()); | |
77 | EXPECT_N_STR(expect, readback); | |
78 | EXPECT_EQ(test.size(), f.Tell()); | |
79 | } | |
80 | { | |
81 | APT_INIT_READBACK | |
82 | EXPECT_TRUE(f.Seek(0)); | |
83 | EXPECT_FALSE(f.Eof()); | |
84 | EXPECT_TRUE(f.Read(readback, 20, true)); | |
85 | EXPECT_FALSE(f.Failed()); | |
86 | EXPECT_TRUE(f.Eof()); | |
87 | EXPECT_N_STR(test.c_str(), readback); | |
88 | EXPECT_EQ(f.Size(), f.Tell()); | |
89 | } | |
90 | { | |
91 | APT_INIT_READBACK | |
92 | EXPECT_TRUE(f.Seek(0)); | |
93 | EXPECT_FALSE(f.Eof()); | |
94 | EXPECT_TRUE(f.Read(readback, test.size(), true)); | |
95 | EXPECT_FALSE(f.Failed()); | |
96 | EXPECT_FALSE(f.Eof()); | |
97 | EXPECT_N_STR(test.c_str(), readback); | |
98 | EXPECT_EQ(f.Size(), f.Tell()); | |
99 | } | |
100 | { | |
101 | APT_INIT_READBACK | |
102 | EXPECT_TRUE(f.Seek(0)); | |
103 | EXPECT_FALSE(f.Eof()); | |
104 | unsigned long long actual; | |
105 | EXPECT_TRUE(f.Read(readback, 20, &actual)); | |
106 | EXPECT_FALSE(f.Failed()); | |
107 | EXPECT_TRUE(f.Eof()); | |
108 | EXPECT_EQ(test.size(), actual); | |
109 | EXPECT_N_STR(test.c_str(), readback); | |
110 | EXPECT_EQ(f.Size(), f.Tell()); | |
111 | } | |
112 | { | |
113 | APT_INIT_READBACK | |
114 | EXPECT_TRUE(f.Seek(0)); | |
115 | EXPECT_FALSE(f.Eof()); | |
116 | f.ReadLine(readback, 20); | |
117 | EXPECT_FALSE(f.Failed()); | |
118 | EXPECT_FALSE(f.Eof()); | |
119 | EXPECT_EQ(test, readback); | |
120 | EXPECT_EQ(f.Size(), f.Tell()); | |
121 | } | |
122 | { | |
123 | APT_INIT_READBACK | |
124 | EXPECT_TRUE(f.Seek(0)); | |
125 | EXPECT_FALSE(f.Eof()); | |
126 | char const * const expect = "This"; | |
127 | f.ReadLine(readback, strlen(expect) + 1); | |
128 | EXPECT_FALSE(f.Failed()); | |
129 | EXPECT_FALSE(f.Eof()); | |
130 | EXPECT_N_STR(expect, readback); | |
131 | EXPECT_EQ(strlen(expect), f.Tell()); | |
132 | } | |
133 | #undef APT_INIT_READBACK | |
134 | ||
135 | f.Close(); | |
136 | EXPECT_FALSE(f.IsOpen()); | |
137 | EXPECT_FALSE(f.Failed()); | |
138 | ||
139 | // regression test for permission bug LP: #1304657 | |
140 | struct stat buf; | |
141 | EXPECT_EQ(0, stat(fname, &buf)); | |
142 | EXPECT_EQ(0, unlink(fname)); | |
143 | EXPECT_EQ(ExpectedFilePermission, buf.st_mode & 0777); | |
144 | } | |
145 | ||
146 | static void TestFileFd(unsigned int const filemode) | |
147 | { | |
148 | std::vector<APT::Configuration::Compressor> compressors = APT::Configuration::getCompressors(); | |
149 | ||
150 | // testing the (un)compress via pipe, as the 'real' compressors are usually built in via libraries | |
151 | compressors.push_back(APT::Configuration::Compressor("rev", ".reversed", "rev", NULL, NULL, 42)); | |
152 | //compressors.push_back(APT::Configuration::Compressor("cat", ".ident", "cat", NULL, NULL, 42)); | |
153 | ||
154 | for (std::vector<APT::Configuration::Compressor>::const_iterator c = compressors.begin(); c != compressors.end(); ++c) | |
155 | { | |
156 | if ((filemode & FileFd::ReadWrite) == FileFd::ReadWrite && | |
157 | (c->Name.empty() != true && c->Binary.empty() != true)) | |
158 | continue; | |
159 | TestFileFd(0002, 0664, filemode, *c); | |
160 | TestFileFd(0022, 0644, filemode, *c); | |
161 | TestFileFd(0077, 0600, filemode, *c); | |
162 | TestFileFd(0026, 0640, filemode, *c); | |
163 | } | |
164 | } | |
165 | ||
166 | TEST(FileUtlTest, FileFD) | |
167 | { | |
168 | std::string const startdir = SafeGetCWD(); | |
169 | EXPECT_FALSE(startdir.empty()); | |
170 | std::string tempdir; | |
171 | createTemporaryDirectory("filefd", tempdir); | |
172 | EXPECT_EQ(0, chdir(tempdir.c_str())); | |
173 | ||
174 | TestFileFd(FileFd::WriteOnly | FileFd::Create); | |
175 | TestFileFd(FileFd::WriteOnly | FileFd::Create | FileFd::Empty); | |
176 | TestFileFd(FileFd::WriteOnly | FileFd::Create | FileFd::Exclusive); | |
177 | TestFileFd(FileFd::WriteOnly | FileFd::Atomic); | |
178 | TestFileFd(FileFd::WriteOnly | FileFd::Create | FileFd::Atomic); | |
179 | // short-hands for ReadWrite with these modes | |
180 | TestFileFd(FileFd::WriteEmpty); | |
181 | TestFileFd(FileFd::WriteAny); | |
182 | TestFileFd(FileFd::WriteTemp); | |
183 | TestFileFd(FileFd::WriteAtomic); | |
184 | ||
185 | EXPECT_EQ(0, chdir(startdir.c_str())); | |
186 | removeDirectory(tempdir); | |
187 | } | |
188 | TEST(FileUtlTest, Glob) | |
189 | { | |
190 | std::vector<std::string> files; | |
191 | // normal match | |
192 | files = Glob("*akefile"); | |
193 | EXPECT_EQ(1, files.size()); | |
194 | ||
195 | // not there | |
196 | files = Glob("xxxyyyzzz"); | |
197 | EXPECT_TRUE(files.empty()); | |
198 | EXPECT_FALSE(_error->PendingError()); | |
199 | ||
200 | // many matches (number is a bit random) | |
201 | files = Glob("*.cc"); | |
202 | EXPECT_LT(10, files.size()); | |
203 | } | |
204 | TEST(FileUtlTest, GetTempDir) | |
205 | { | |
206 | char const * const envtmp = getenv("TMPDIR"); | |
207 | std::string old_tmpdir; | |
208 | if (envtmp != NULL) | |
209 | old_tmpdir = envtmp; | |
210 | ||
211 | unsetenv("TMPDIR"); | |
212 | EXPECT_EQ("/tmp", GetTempDir()); | |
213 | ||
214 | setenv("TMPDIR", "", 1); | |
215 | EXPECT_EQ("/tmp", GetTempDir()); | |
216 | ||
217 | setenv("TMPDIR", "/not-there-no-really-not", 1); | |
218 | EXPECT_EQ("/tmp", GetTempDir()); | |
219 | ||
220 | setenv("TMPDIR", "/usr", 1); | |
221 | EXPECT_EQ("/usr", GetTempDir()); | |
222 | ||
223 | unsetenv("TMPDIR"); | |
224 | if (old_tmpdir.empty() == false) | |
225 | setenv("TMPDIR", old_tmpdir.c_str(), 1); | |
226 | } |