1 /*
2 * Copyright (C) 2013 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17 #include "android-base/file.h"
18
19 #include <gtest/gtest.h>
20
21 #include <errno.h>
22 #include <fcntl.h>
23 #include <unistd.h>
24
25 #include <string>
26
27 #include "android-base/test_utils.h"
28
TEST(file,ReadFileToString_ENOENT)29 TEST(file, ReadFileToString_ENOENT) {
30 std::string s("hello");
31 errno = 0;
32 ASSERT_FALSE(android::base::ReadFileToString("/proc/does-not-exist", &s));
33 EXPECT_EQ(ENOENT, errno);
34 EXPECT_EQ("", s); // s was cleared.
35 }
36
TEST(file,ReadFileToString_WriteStringToFile)37 TEST(file, ReadFileToString_WriteStringToFile) {
38 TemporaryFile tf;
39 ASSERT_TRUE(tf.fd != -1);
40 ASSERT_TRUE(android::base::WriteStringToFile("abc", tf.path))
41 << strerror(errno);
42 std::string s;
43 ASSERT_TRUE(android::base::ReadFileToString(tf.path, &s))
44 << strerror(errno);
45 EXPECT_EQ("abc", s);
46 }
47
48 // symlinks require elevated privileges on Windows.
49 #if !defined(_WIN32)
TEST(file,ReadFileToString_WriteStringToFile_symlink)50 TEST(file, ReadFileToString_WriteStringToFile_symlink) {
51 TemporaryFile target, link;
52 ASSERT_EQ(0, unlink(link.path));
53 ASSERT_EQ(0, symlink(target.path, link.path));
54 ASSERT_FALSE(android::base::WriteStringToFile("foo", link.path, false));
55 ASSERT_EQ(ELOOP, errno);
56 ASSERT_TRUE(android::base::WriteStringToFile("foo", link.path, true));
57
58 std::string s;
59 ASSERT_FALSE(android::base::ReadFileToString(link.path, &s));
60 ASSERT_EQ(ELOOP, errno);
61 ASSERT_TRUE(android::base::ReadFileToString(link.path, &s, true));
62 ASSERT_EQ("foo", s);
63 }
64 #endif
65
66 // WriteStringToFile2 is explicitly for setting Unix permissions, which make no
67 // sense on Windows.
68 #if !defined(_WIN32)
TEST(file,WriteStringToFile2)69 TEST(file, WriteStringToFile2) {
70 TemporaryFile tf;
71 ASSERT_TRUE(tf.fd != -1);
72 ASSERT_TRUE(android::base::WriteStringToFile("abc", tf.path, 0660,
73 getuid(), getgid()))
74 << strerror(errno);
75 struct stat sb;
76 ASSERT_EQ(0, stat(tf.path, &sb));
77 ASSERT_EQ(0660U, static_cast<unsigned int>(sb.st_mode & ~S_IFMT));
78 ASSERT_EQ(getuid(), sb.st_uid);
79 ASSERT_EQ(getgid(), sb.st_gid);
80 std::string s;
81 ASSERT_TRUE(android::base::ReadFileToString(tf.path, &s))
82 << strerror(errno);
83 EXPECT_EQ("abc", s);
84 }
85 #endif
86
TEST(file,WriteStringToFd)87 TEST(file, WriteStringToFd) {
88 TemporaryFile tf;
89 ASSERT_TRUE(tf.fd != -1);
90 ASSERT_TRUE(android::base::WriteStringToFd("abc", tf.fd));
91
92 ASSERT_EQ(0, lseek(tf.fd, 0, SEEK_SET)) << strerror(errno);
93
94 std::string s;
95 ASSERT_TRUE(android::base::ReadFdToString(tf.fd, &s)) << strerror(errno);
96 EXPECT_EQ("abc", s);
97 }
98
TEST(file,WriteFully)99 TEST(file, WriteFully) {
100 TemporaryFile tf;
101 ASSERT_TRUE(tf.fd != -1);
102 ASSERT_TRUE(android::base::WriteFully(tf.fd, "abc", 3));
103
104 ASSERT_EQ(0, lseek(tf.fd, 0, SEEK_SET)) << strerror(errno);
105
106 std::string s;
107 s.resize(3);
108 ASSERT_TRUE(android::base::ReadFully(tf.fd, &s[0], s.size()))
109 << strerror(errno);
110 EXPECT_EQ("abc", s);
111
112 ASSERT_EQ(0, lseek(tf.fd, 0, SEEK_SET)) << strerror(errno);
113
114 s.resize(1024);
115 ASSERT_FALSE(android::base::ReadFully(tf.fd, &s[0], s.size()));
116 }
117
TEST(file,RemoveFileIfExist)118 TEST(file, RemoveFileIfExist) {
119 TemporaryFile tf;
120 ASSERT_TRUE(tf.fd != -1);
121 close(tf.fd);
122 tf.fd = -1;
123 std::string err;
124 ASSERT_TRUE(android::base::RemoveFileIfExists(tf.path, &err)) << err;
125 ASSERT_TRUE(android::base::RemoveFileIfExists(tf.path));
126 TemporaryDir td;
127 ASSERT_FALSE(android::base::RemoveFileIfExists(td.path));
128 ASSERT_FALSE(android::base::RemoveFileIfExists(td.path, &err));
129 ASSERT_EQ("is not a regular or symbol link file", err);
130 }
131
TEST(file,Readlink)132 TEST(file, Readlink) {
133 #if !defined(_WIN32)
134 // Linux doesn't allow empty symbolic links.
135 std::string min("x");
136 // ext2 and ext4 both have PAGE_SIZE limits.
137 // If file encryption is enabled, there's extra overhead to store the
138 // size of the encrypted symlink target. There's also an off-by-one
139 // in current kernels (and marlin/sailfish where we're seeing this
140 // failure are still on 3.18, far from current). http://b/33306057.
141 std::string max(static_cast<size_t>(4096 - 2 - 1 - 1), 'x');
142
143 TemporaryDir td;
144 std::string min_path{std::string(td.path) + "/" + "min"};
145 std::string max_path{std::string(td.path) + "/" + "max"};
146
147 ASSERT_EQ(0, symlink(min.c_str(), min_path.c_str()));
148 ASSERT_EQ(0, symlink(max.c_str(), max_path.c_str()));
149
150 std::string result;
151
152 result = "wrong";
153 ASSERT_TRUE(android::base::Readlink(min_path, &result));
154 ASSERT_EQ(min, result);
155
156 result = "wrong";
157 ASSERT_TRUE(android::base::Readlink(max_path, &result));
158 ASSERT_EQ(max, result);
159 #endif
160 }
161
TEST(file,Realpath)162 TEST(file, Realpath) {
163 #if !defined(_WIN32)
164 TemporaryDir td;
165 std::string basename = android::base::Basename(td.path);
166 std::string dir_name = android::base::Dirname(td.path);
167 std::string base_dir_name = android::base::Basename(dir_name);
168
169 {
170 std::string path = dir_name + "/../" + base_dir_name + "/" + basename;
171 std::string result;
172 ASSERT_TRUE(android::base::Realpath(path, &result));
173 ASSERT_EQ(td.path, result);
174 }
175
176 {
177 std::string path = std::string(td.path) + "/..";
178 std::string result;
179 ASSERT_TRUE(android::base::Realpath(path, &result));
180 ASSERT_EQ(dir_name, result);
181 }
182
183 {
184 errno = 0;
185 std::string path = std::string(td.path) + "/foo.noent";
186 std::string result = "wrong";
187 ASSERT_TRUE(!android::base::Realpath(path, &result));
188 ASSERT_TRUE(result.empty());
189 ASSERT_EQ(ENOENT, errno);
190 }
191 #endif
192 }
193
TEST(file,GetExecutableDirectory)194 TEST(file, GetExecutableDirectory) {
195 std::string path = android::base::GetExecutableDirectory();
196 ASSERT_NE("", path);
197 ASSERT_NE(android::base::GetExecutablePath(), path);
198 ASSERT_EQ('/', path[0]);
199 ASSERT_NE('/', path[path.size() - 1]);
200 }
201
TEST(file,GetExecutablePath)202 TEST(file, GetExecutablePath) {
203 ASSERT_NE("", android::base::GetExecutablePath());
204 }
205
TEST(file,Basename)206 TEST(file, Basename) {
207 EXPECT_EQ("sh", android::base::Basename("/system/bin/sh"));
208 EXPECT_EQ("sh", android::base::Basename("sh"));
209 EXPECT_EQ("sh", android::base::Basename("/system/bin/sh/"));
210 }
211
TEST(file,Dirname)212 TEST(file, Dirname) {
213 EXPECT_EQ("/system/bin", android::base::Dirname("/system/bin/sh"));
214 EXPECT_EQ(".", android::base::Dirname("sh"));
215 EXPECT_EQ("/system/bin", android::base::Dirname("/system/bin/sh/"));
216 }
217
TEST(file,ReadFileToString_capacity)218 TEST(file, ReadFileToString_capacity) {
219 TemporaryFile tf;
220 ASSERT_TRUE(tf.fd != -1);
221
222 // For a huge file, the overhead should still be small.
223 std::string s;
224 size_t size = 16 * 1024 * 1024;
225 ASSERT_TRUE(android::base::WriteStringToFile(std::string(size, 'x'), tf.path));
226 ASSERT_TRUE(android::base::ReadFileToString(tf.path, &s));
227 EXPECT_EQ(size, s.size());
228 EXPECT_LT(s.capacity(), size + 16);
229
230 // Even for weird badly-aligned sizes.
231 size += 12345;
232 ASSERT_TRUE(android::base::WriteStringToFile(std::string(size, 'x'), tf.path));
233 ASSERT_TRUE(android::base::ReadFileToString(tf.path, &s));
234 EXPECT_EQ(size, s.size());
235 EXPECT_LT(s.capacity(), size + 16);
236
237 // We'll shrink an enormous string if you read a small file into it.
238 size = 64;
239 ASSERT_TRUE(android::base::WriteStringToFile(std::string(size, 'x'), tf.path));
240 ASSERT_TRUE(android::base::ReadFileToString(tf.path, &s));
241 EXPECT_EQ(size, s.size());
242 EXPECT_LT(s.capacity(), size + 16);
243 }
244
TEST(file,ReadFileToString_capacity_0)245 TEST(file, ReadFileToString_capacity_0) {
246 TemporaryFile tf;
247 ASSERT_TRUE(tf.fd != -1);
248
249 // Because /proc reports its files as zero-length, we don't actually trust
250 // any file that claims to be zero-length. Rather than add increasingly
251 // complex heuristics for shrinking the passed-in string in that case, we
252 // currently leave it alone.
253 std::string s;
254 size_t initial_capacity = s.capacity();
255 ASSERT_TRUE(android::base::WriteStringToFile("", tf.path));
256 ASSERT_TRUE(android::base::ReadFileToString(tf.path, &s));
257 EXPECT_EQ(0U, s.size());
258 EXPECT_EQ(initial_capacity, s.capacity());
259 }
260