1 // Copyright (c) 2012 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.
4
5 #include "base/files/file.h"
6
7 #include <stdint.h>
8
9 #include <utility>
10
11 #include "base/files/file_util.h"
12 #include "base/files/scoped_temp_dir.h"
13 #include "base/time/time.h"
14 #include "build/build_config.h"
15 #include "testing/gtest/include/gtest/gtest.h"
16
17 using base::File;
18 using base::FilePath;
19
TEST(FileTest,Create)20 TEST(FileTest, Create) {
21 base::ScopedTempDir temp_dir;
22 ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
23 FilePath file_path = temp_dir.path().AppendASCII("create_file_1");
24
25 {
26 // Don't create a File at all.
27 File file;
28 EXPECT_FALSE(file.IsValid());
29 EXPECT_EQ(base::File::FILE_ERROR_FAILED, file.error_details());
30
31 File file2(base::File::FILE_ERROR_TOO_MANY_OPENED);
32 EXPECT_FALSE(file2.IsValid());
33 EXPECT_EQ(base::File::FILE_ERROR_TOO_MANY_OPENED, file2.error_details());
34 }
35
36 {
37 // Open a file that doesn't exist.
38 File file(file_path, base::File::FLAG_OPEN | base::File::FLAG_READ);
39 EXPECT_FALSE(file.IsValid());
40 EXPECT_EQ(base::File::FILE_ERROR_NOT_FOUND, file.error_details());
41 }
42
43 {
44 // Open or create a file.
45 File file(file_path, base::File::FLAG_OPEN_ALWAYS | base::File::FLAG_READ);
46 EXPECT_TRUE(file.IsValid());
47 EXPECT_TRUE(file.created());
48 EXPECT_EQ(base::File::FILE_OK, file.error_details());
49 }
50
51 {
52 // Open an existing file.
53 File file(file_path, base::File::FLAG_OPEN | base::File::FLAG_READ);
54 EXPECT_TRUE(file.IsValid());
55 EXPECT_FALSE(file.created());
56 EXPECT_EQ(base::File::FILE_OK, file.error_details());
57
58 // This time verify closing the file.
59 file.Close();
60 EXPECT_FALSE(file.IsValid());
61 }
62
63 {
64 // Open an existing file through Initialize
65 File file;
66 file.Initialize(file_path, base::File::FLAG_OPEN | base::File::FLAG_READ);
67 EXPECT_TRUE(file.IsValid());
68 EXPECT_FALSE(file.created());
69 EXPECT_EQ(base::File::FILE_OK, file.error_details());
70
71 // This time verify closing the file.
72 file.Close();
73 EXPECT_FALSE(file.IsValid());
74 }
75
76 {
77 // Create a file that exists.
78 File file(file_path, base::File::FLAG_CREATE | base::File::FLAG_READ);
79 EXPECT_FALSE(file.IsValid());
80 EXPECT_FALSE(file.created());
81 EXPECT_EQ(base::File::FILE_ERROR_EXISTS, file.error_details());
82 }
83
84 {
85 // Create or overwrite a file.
86 File file(file_path,
87 base::File::FLAG_CREATE_ALWAYS | base::File::FLAG_WRITE);
88 EXPECT_TRUE(file.IsValid());
89 EXPECT_TRUE(file.created());
90 EXPECT_EQ(base::File::FILE_OK, file.error_details());
91 }
92
93 {
94 // Create a delete-on-close file.
95 file_path = temp_dir.path().AppendASCII("create_file_2");
96 File file(file_path,
97 base::File::FLAG_OPEN_ALWAYS | base::File::FLAG_READ |
98 base::File::FLAG_DELETE_ON_CLOSE);
99 EXPECT_TRUE(file.IsValid());
100 EXPECT_TRUE(file.created());
101 EXPECT_EQ(base::File::FILE_OK, file.error_details());
102 }
103
104 EXPECT_FALSE(base::PathExists(file_path));
105 }
106
TEST(FileTest,Async)107 TEST(FileTest, Async) {
108 base::ScopedTempDir temp_dir;
109 ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
110 FilePath file_path = temp_dir.path().AppendASCII("create_file");
111
112 {
113 File file(file_path, base::File::FLAG_OPEN_ALWAYS | base::File::FLAG_ASYNC);
114 EXPECT_TRUE(file.IsValid());
115 EXPECT_TRUE(file.async());
116 }
117
118 {
119 File file(file_path, base::File::FLAG_OPEN_ALWAYS);
120 EXPECT_TRUE(file.IsValid());
121 EXPECT_FALSE(file.async());
122 }
123 }
124
TEST(FileTest,DeleteOpenFile)125 TEST(FileTest, DeleteOpenFile) {
126 base::ScopedTempDir temp_dir;
127 ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
128 FilePath file_path = temp_dir.path().AppendASCII("create_file_1");
129
130 // Create a file.
131 File file(file_path,
132 base::File::FLAG_OPEN_ALWAYS | base::File::FLAG_READ |
133 base::File::FLAG_SHARE_DELETE);
134 EXPECT_TRUE(file.IsValid());
135 EXPECT_TRUE(file.created());
136 EXPECT_EQ(base::File::FILE_OK, file.error_details());
137
138 // Open an existing file and mark it as delete on close.
139 File same_file(file_path,
140 base::File::FLAG_OPEN | base::File::FLAG_DELETE_ON_CLOSE |
141 base::File::FLAG_READ);
142 EXPECT_TRUE(file.IsValid());
143 EXPECT_FALSE(same_file.created());
144 EXPECT_EQ(base::File::FILE_OK, same_file.error_details());
145
146 // Close both handles and check that the file is gone.
147 file.Close();
148 same_file.Close();
149 EXPECT_FALSE(base::PathExists(file_path));
150 }
151
TEST(FileTest,ReadWrite)152 TEST(FileTest, ReadWrite) {
153 base::ScopedTempDir temp_dir;
154 ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
155 FilePath file_path = temp_dir.path().AppendASCII("read_write_file");
156 File file(file_path,
157 base::File::FLAG_CREATE | base::File::FLAG_READ |
158 base::File::FLAG_WRITE);
159 ASSERT_TRUE(file.IsValid());
160
161 char data_to_write[] = "test";
162 const int kTestDataSize = 4;
163
164 // Write 0 bytes to the file.
165 int bytes_written = file.Write(0, data_to_write, 0);
166 EXPECT_EQ(0, bytes_written);
167
168 // Write "test" to the file.
169 bytes_written = file.Write(0, data_to_write, kTestDataSize);
170 EXPECT_EQ(kTestDataSize, bytes_written);
171
172 // Read from EOF.
173 char data_read_1[32];
174 int bytes_read = file.Read(kTestDataSize, data_read_1, kTestDataSize);
175 EXPECT_EQ(0, bytes_read);
176
177 // Read from somewhere in the middle of the file.
178 const int kPartialReadOffset = 1;
179 bytes_read = file.Read(kPartialReadOffset, data_read_1, kTestDataSize);
180 EXPECT_EQ(kTestDataSize - kPartialReadOffset, bytes_read);
181 for (int i = 0; i < bytes_read; i++)
182 EXPECT_EQ(data_to_write[i + kPartialReadOffset], data_read_1[i]);
183
184 // Read 0 bytes.
185 bytes_read = file.Read(0, data_read_1, 0);
186 EXPECT_EQ(0, bytes_read);
187
188 // Read the entire file.
189 bytes_read = file.Read(0, data_read_1, kTestDataSize);
190 EXPECT_EQ(kTestDataSize, bytes_read);
191 for (int i = 0; i < bytes_read; i++)
192 EXPECT_EQ(data_to_write[i], data_read_1[i]);
193
194 // Read again, but using the trivial native wrapper.
195 bytes_read = file.ReadNoBestEffort(0, data_read_1, kTestDataSize);
196 EXPECT_LE(bytes_read, kTestDataSize);
197 for (int i = 0; i < bytes_read; i++)
198 EXPECT_EQ(data_to_write[i], data_read_1[i]);
199
200 // Write past the end of the file.
201 const int kOffsetBeyondEndOfFile = 10;
202 const int kPartialWriteLength = 2;
203 bytes_written = file.Write(kOffsetBeyondEndOfFile,
204 data_to_write, kPartialWriteLength);
205 EXPECT_EQ(kPartialWriteLength, bytes_written);
206
207 // Make sure the file was extended.
208 int64_t file_size = 0;
209 EXPECT_TRUE(GetFileSize(file_path, &file_size));
210 EXPECT_EQ(kOffsetBeyondEndOfFile + kPartialWriteLength, file_size);
211
212 // Make sure the file was zero-padded.
213 char data_read_2[32];
214 bytes_read = file.Read(0, data_read_2, static_cast<int>(file_size));
215 EXPECT_EQ(file_size, bytes_read);
216 for (int i = 0; i < kTestDataSize; i++)
217 EXPECT_EQ(data_to_write[i], data_read_2[i]);
218 for (int i = kTestDataSize; i < kOffsetBeyondEndOfFile; i++)
219 EXPECT_EQ(0, data_read_2[i]);
220 for (int i = kOffsetBeyondEndOfFile; i < file_size; i++)
221 EXPECT_EQ(data_to_write[i - kOffsetBeyondEndOfFile], data_read_2[i]);
222 }
223
TEST(FileTest,Append)224 TEST(FileTest, Append) {
225 base::ScopedTempDir temp_dir;
226 ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
227 FilePath file_path = temp_dir.path().AppendASCII("append_file");
228 File file(file_path, base::File::FLAG_CREATE | base::File::FLAG_APPEND);
229 ASSERT_TRUE(file.IsValid());
230
231 char data_to_write[] = "test";
232 const int kTestDataSize = 4;
233
234 // Write 0 bytes to the file.
235 int bytes_written = file.Write(0, data_to_write, 0);
236 EXPECT_EQ(0, bytes_written);
237
238 // Write "test" to the file.
239 bytes_written = file.Write(0, data_to_write, kTestDataSize);
240 EXPECT_EQ(kTestDataSize, bytes_written);
241
242 file.Close();
243 File file2(file_path,
244 base::File::FLAG_OPEN | base::File::FLAG_READ |
245 base::File::FLAG_APPEND);
246 ASSERT_TRUE(file2.IsValid());
247
248 // Test passing the file around.
249 file = std::move(file2);
250 EXPECT_FALSE(file2.IsValid());
251 ASSERT_TRUE(file.IsValid());
252
253 char append_data_to_write[] = "78";
254 const int kAppendDataSize = 2;
255
256 // Append "78" to the file.
257 bytes_written = file.Write(0, append_data_to_write, kAppendDataSize);
258 EXPECT_EQ(kAppendDataSize, bytes_written);
259
260 // Read the entire file.
261 char data_read_1[32];
262 int bytes_read = file.Read(0, data_read_1,
263 kTestDataSize + kAppendDataSize);
264 EXPECT_EQ(kTestDataSize + kAppendDataSize, bytes_read);
265 for (int i = 0; i < kTestDataSize; i++)
266 EXPECT_EQ(data_to_write[i], data_read_1[i]);
267 for (int i = 0; i < kAppendDataSize; i++)
268 EXPECT_EQ(append_data_to_write[i], data_read_1[kTestDataSize + i]);
269 }
270
271
TEST(FileTest,Length)272 TEST(FileTest, Length) {
273 base::ScopedTempDir temp_dir;
274 ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
275 FilePath file_path = temp_dir.path().AppendASCII("truncate_file");
276 File file(file_path,
277 base::File::FLAG_CREATE | base::File::FLAG_READ |
278 base::File::FLAG_WRITE);
279 ASSERT_TRUE(file.IsValid());
280 EXPECT_EQ(0, file.GetLength());
281
282 // Write "test" to the file.
283 char data_to_write[] = "test";
284 int kTestDataSize = 4;
285 int bytes_written = file.Write(0, data_to_write, kTestDataSize);
286 EXPECT_EQ(kTestDataSize, bytes_written);
287
288 // Extend the file.
289 const int kExtendedFileLength = 10;
290 int64_t file_size = 0;
291 EXPECT_TRUE(file.SetLength(kExtendedFileLength));
292 EXPECT_EQ(kExtendedFileLength, file.GetLength());
293 EXPECT_TRUE(GetFileSize(file_path, &file_size));
294 EXPECT_EQ(kExtendedFileLength, file_size);
295
296 // Make sure the file was zero-padded.
297 char data_read[32];
298 int bytes_read = file.Read(0, data_read, static_cast<int>(file_size));
299 EXPECT_EQ(file_size, bytes_read);
300 for (int i = 0; i < kTestDataSize; i++)
301 EXPECT_EQ(data_to_write[i], data_read[i]);
302 for (int i = kTestDataSize; i < file_size; i++)
303 EXPECT_EQ(0, data_read[i]);
304
305 // Truncate the file.
306 const int kTruncatedFileLength = 2;
307 EXPECT_TRUE(file.SetLength(kTruncatedFileLength));
308 EXPECT_EQ(kTruncatedFileLength, file.GetLength());
309 EXPECT_TRUE(GetFileSize(file_path, &file_size));
310 EXPECT_EQ(kTruncatedFileLength, file_size);
311
312 // Make sure the file was truncated.
313 bytes_read = file.Read(0, data_read, kTestDataSize);
314 EXPECT_EQ(file_size, bytes_read);
315 for (int i = 0; i < file_size; i++)
316 EXPECT_EQ(data_to_write[i], data_read[i]);
317 }
318
319 // Flakily fails: http://crbug.com/86494
320 #if defined(OS_ANDROID)
TEST(FileTest,TouchGetInfo)321 TEST(FileTest, TouchGetInfo) {
322 #else
323 TEST(FileTest, DISABLED_TouchGetInfo) {
324 #endif
325 base::ScopedTempDir temp_dir;
326 ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
327 File file(temp_dir.path().AppendASCII("touch_get_info_file"),
328 base::File::FLAG_CREATE | base::File::FLAG_WRITE |
329 base::File::FLAG_WRITE_ATTRIBUTES);
330 ASSERT_TRUE(file.IsValid());
331
332 // Get info for a newly created file.
333 base::File::Info info;
334 EXPECT_TRUE(file.GetInfo(&info));
335
336 // Add 2 seconds to account for possible rounding errors on
337 // filesystems that use a 1s or 2s timestamp granularity.
338 base::Time now = base::Time::Now() + base::TimeDelta::FromSeconds(2);
339 EXPECT_EQ(0, info.size);
340 EXPECT_FALSE(info.is_directory);
341 EXPECT_FALSE(info.is_symbolic_link);
342 EXPECT_LE(info.last_accessed.ToInternalValue(), now.ToInternalValue());
343 EXPECT_LE(info.last_modified.ToInternalValue(), now.ToInternalValue());
344 EXPECT_LE(info.creation_time.ToInternalValue(), now.ToInternalValue());
345 base::Time creation_time = info.creation_time;
346
347 // Write "test" to the file.
348 char data[] = "test";
349 const int kTestDataSize = 4;
350 int bytes_written = file.Write(0, data, kTestDataSize);
351 EXPECT_EQ(kTestDataSize, bytes_written);
352
353 // Change the last_accessed and last_modified dates.
354 // It's best to add values that are multiples of 2 (in seconds)
355 // to the current last_accessed and last_modified times, because
356 // FATxx uses a 2s timestamp granularity.
357 base::Time new_last_accessed =
358 info.last_accessed + base::TimeDelta::FromSeconds(234);
359 base::Time new_last_modified =
360 info.last_modified + base::TimeDelta::FromMinutes(567);
361
362 EXPECT_TRUE(file.SetTimes(new_last_accessed, new_last_modified));
363
364 // Make sure the file info was updated accordingly.
365 EXPECT_TRUE(file.GetInfo(&info));
366 EXPECT_EQ(info.size, kTestDataSize);
367 EXPECT_FALSE(info.is_directory);
368 EXPECT_FALSE(info.is_symbolic_link);
369
370 // ext2/ext3 and HPS/HPS+ seem to have a timestamp granularity of 1s.
371 #if defined(OS_POSIX)
372 EXPECT_EQ(info.last_accessed.ToTimeVal().tv_sec,
373 new_last_accessed.ToTimeVal().tv_sec);
374 EXPECT_EQ(info.last_modified.ToTimeVal().tv_sec,
375 new_last_modified.ToTimeVal().tv_sec);
376 #else
377 EXPECT_EQ(info.last_accessed.ToInternalValue(),
378 new_last_accessed.ToInternalValue());
379 EXPECT_EQ(info.last_modified.ToInternalValue(),
380 new_last_modified.ToInternalValue());
381 #endif
382
383 EXPECT_EQ(info.creation_time.ToInternalValue(),
384 creation_time.ToInternalValue());
385 }
386
387 TEST(FileTest, ReadAtCurrentPosition) {
388 base::ScopedTempDir temp_dir;
389 ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
390 FilePath file_path = temp_dir.path().AppendASCII("read_at_current_position");
391 File file(file_path,
392 base::File::FLAG_CREATE | base::File::FLAG_READ |
393 base::File::FLAG_WRITE);
394 EXPECT_TRUE(file.IsValid());
395
396 const char kData[] = "test";
397 const int kDataSize = sizeof(kData) - 1;
398 EXPECT_EQ(kDataSize, file.Write(0, kData, kDataSize));
399
400 EXPECT_EQ(0, file.Seek(base::File::FROM_BEGIN, 0));
401
402 char buffer[kDataSize];
403 int first_chunk_size = kDataSize / 2;
404 EXPECT_EQ(first_chunk_size, file.ReadAtCurrentPos(buffer, first_chunk_size));
405 EXPECT_EQ(kDataSize - first_chunk_size,
406 file.ReadAtCurrentPos(buffer + first_chunk_size,
407 kDataSize - first_chunk_size));
408 EXPECT_EQ(std::string(buffer, buffer + kDataSize), std::string(kData));
409 }
410
411 TEST(FileTest, WriteAtCurrentPosition) {
412 base::ScopedTempDir temp_dir;
413 ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
414 FilePath file_path = temp_dir.path().AppendASCII("write_at_current_position");
415 File file(file_path,
416 base::File::FLAG_CREATE | base::File::FLAG_READ |
417 base::File::FLAG_WRITE);
418 EXPECT_TRUE(file.IsValid());
419
420 const char kData[] = "test";
421 const int kDataSize = sizeof(kData) - 1;
422
423 int first_chunk_size = kDataSize / 2;
424 EXPECT_EQ(first_chunk_size, file.WriteAtCurrentPos(kData, first_chunk_size));
425 EXPECT_EQ(kDataSize - first_chunk_size,
426 file.WriteAtCurrentPos(kData + first_chunk_size,
427 kDataSize - first_chunk_size));
428
429 char buffer[kDataSize];
430 EXPECT_EQ(kDataSize, file.Read(0, buffer, kDataSize));
431 EXPECT_EQ(std::string(buffer, buffer + kDataSize), std::string(kData));
432 }
433
434 TEST(FileTest, Seek) {
435 base::ScopedTempDir temp_dir;
436 ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
437 FilePath file_path = temp_dir.path().AppendASCII("seek_file");
438 File file(file_path,
439 base::File::FLAG_CREATE | base::File::FLAG_READ |
440 base::File::FLAG_WRITE);
441 ASSERT_TRUE(file.IsValid());
442
443 const int64_t kOffset = 10;
444 EXPECT_EQ(kOffset, file.Seek(base::File::FROM_BEGIN, kOffset));
445 EXPECT_EQ(2 * kOffset, file.Seek(base::File::FROM_CURRENT, kOffset));
446 EXPECT_EQ(kOffset, file.Seek(base::File::FROM_CURRENT, -kOffset));
447 EXPECT_TRUE(file.SetLength(kOffset * 2));
448 EXPECT_EQ(kOffset, file.Seek(base::File::FROM_END, -kOffset));
449 }
450
451 TEST(FileTest, Duplicate) {
452 base::ScopedTempDir temp_dir;
453 ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
454 FilePath file_path = temp_dir.path().AppendASCII("file");
455 File file(file_path,(base::File::FLAG_CREATE |
456 base::File::FLAG_READ |
457 base::File::FLAG_WRITE));
458 ASSERT_TRUE(file.IsValid());
459
460 File file2(file.Duplicate());
461 ASSERT_TRUE(file2.IsValid());
462
463 // Write through one handle, close it, read through the other.
464 static const char kData[] = "now is a good time.";
465 static const int kDataLen = sizeof(kData) - 1;
466
467 ASSERT_EQ(0, file.Seek(base::File::FROM_CURRENT, 0));
468 ASSERT_EQ(0, file2.Seek(base::File::FROM_CURRENT, 0));
469 ASSERT_EQ(kDataLen, file.WriteAtCurrentPos(kData, kDataLen));
470 ASSERT_EQ(kDataLen, file.Seek(base::File::FROM_CURRENT, 0));
471 ASSERT_EQ(kDataLen, file2.Seek(base::File::FROM_CURRENT, 0));
472 file.Close();
473 char buf[kDataLen];
474 ASSERT_EQ(kDataLen, file2.Read(0, &buf[0], kDataLen));
475 ASSERT_EQ(std::string(kData, kDataLen), std::string(&buf[0], kDataLen));
476 }
477
478 TEST(FileTest, DuplicateDeleteOnClose) {
479 base::ScopedTempDir temp_dir;
480 ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
481 FilePath file_path = temp_dir.path().AppendASCII("file");
482 File file(file_path,(base::File::FLAG_CREATE |
483 base::File::FLAG_READ |
484 base::File::FLAG_WRITE |
485 base::File::FLAG_DELETE_ON_CLOSE));
486 ASSERT_TRUE(file.IsValid());
487 File file2(file.Duplicate());
488 ASSERT_TRUE(file2.IsValid());
489 file.Close();
490 file2.Close();
491 ASSERT_FALSE(base::PathExists(file_path));
492 }
493
494 #if defined(OS_WIN)
495 TEST(FileTest, GetInfoForDirectory) {
496 base::ScopedTempDir temp_dir;
497 ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
498 FilePath empty_dir = temp_dir.path().Append(FILE_PATH_LITERAL("gpfi_test"));
499 ASSERT_TRUE(CreateDirectory(empty_dir));
500
501 base::File dir(
502 ::CreateFile(empty_dir.value().c_str(),
503 GENERIC_READ | GENERIC_WRITE,
504 FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
505 NULL,
506 OPEN_EXISTING,
507 FILE_FLAG_BACKUP_SEMANTICS, // Needed to open a directory.
508 NULL));
509 ASSERT_TRUE(dir.IsValid());
510
511 base::File::Info info;
512 EXPECT_TRUE(dir.GetInfo(&info));
513 EXPECT_TRUE(info.is_directory);
514 EXPECT_FALSE(info.is_symbolic_link);
515 EXPECT_EQ(0, info.size);
516 }
517 #endif // defined(OS_WIN)
518