OLD | NEW |
1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. | 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 | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "base/files/file.h" | 5 #include "base/files/file.h" |
6 | 6 |
7 #include <stdint.h> | 7 #include <stdint.h> |
8 | 8 |
9 #include <utility> | 9 #include <utility> |
10 | 10 |
11 #include "base/files/file_util.h" | 11 #include "base/files/file_util.h" |
12 #include "base/files/scoped_temp_dir.h" | 12 #include "base/files/scoped_temp_dir.h" |
13 #include "base/time/time.h" | 13 #include "base/time/time.h" |
14 #include "build/build_config.h" | 14 #include "build/build_config.h" |
15 #include "testing/gtest/include/gtest/gtest.h" | 15 #include "testing/gtest/include/gtest/gtest.h" |
16 | 16 |
17 using base::File; | 17 using base::File; |
18 using base::FilePath; | 18 using base::FilePath; |
19 | 19 |
20 TEST(FileTest, Create) { | 20 TEST(FileTest, Create) { |
21 base::ScopedTempDir temp_dir; | 21 base::ScopedTempDir temp_dir; |
22 ASSERT_TRUE(temp_dir.CreateUniqueTempDir()); | 22 ASSERT_TRUE(temp_dir.CreateUniqueTempDir()); |
23 FilePath file_path = temp_dir.path().AppendASCII("create_file_1"); | 23 FilePath file_path = temp_dir.GetPath().AppendASCII("create_file_1"); |
24 | 24 |
25 { | 25 { |
26 // Don't create a File at all. | 26 // Don't create a File at all. |
27 File file; | 27 File file; |
28 EXPECT_FALSE(file.IsValid()); | 28 EXPECT_FALSE(file.IsValid()); |
29 EXPECT_EQ(base::File::FILE_ERROR_FAILED, file.error_details()); | 29 EXPECT_EQ(base::File::FILE_ERROR_FAILED, file.error_details()); |
30 | 30 |
31 File file2(base::File::FILE_ERROR_TOO_MANY_OPENED); | 31 File file2(base::File::FILE_ERROR_TOO_MANY_OPENED); |
32 EXPECT_FALSE(file2.IsValid()); | 32 EXPECT_FALSE(file2.IsValid()); |
33 EXPECT_EQ(base::File::FILE_ERROR_TOO_MANY_OPENED, file2.error_details()); | 33 EXPECT_EQ(base::File::FILE_ERROR_TOO_MANY_OPENED, file2.error_details()); |
(...skipping 51 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
85 // Create or overwrite a file. | 85 // Create or overwrite a file. |
86 File file(file_path, | 86 File file(file_path, |
87 base::File::FLAG_CREATE_ALWAYS | base::File::FLAG_WRITE); | 87 base::File::FLAG_CREATE_ALWAYS | base::File::FLAG_WRITE); |
88 EXPECT_TRUE(file.IsValid()); | 88 EXPECT_TRUE(file.IsValid()); |
89 EXPECT_TRUE(file.created()); | 89 EXPECT_TRUE(file.created()); |
90 EXPECT_EQ(base::File::FILE_OK, file.error_details()); | 90 EXPECT_EQ(base::File::FILE_OK, file.error_details()); |
91 } | 91 } |
92 | 92 |
93 { | 93 { |
94 // Create a delete-on-close file. | 94 // Create a delete-on-close file. |
95 file_path = temp_dir.path().AppendASCII("create_file_2"); | 95 file_path = temp_dir.GetPath().AppendASCII("create_file_2"); |
96 File file(file_path, | 96 File file(file_path, |
97 base::File::FLAG_OPEN_ALWAYS | base::File::FLAG_READ | | 97 base::File::FLAG_OPEN_ALWAYS | base::File::FLAG_READ | |
98 base::File::FLAG_DELETE_ON_CLOSE); | 98 base::File::FLAG_DELETE_ON_CLOSE); |
99 EXPECT_TRUE(file.IsValid()); | 99 EXPECT_TRUE(file.IsValid()); |
100 EXPECT_TRUE(file.created()); | 100 EXPECT_TRUE(file.created()); |
101 EXPECT_EQ(base::File::FILE_OK, file.error_details()); | 101 EXPECT_EQ(base::File::FILE_OK, file.error_details()); |
102 } | 102 } |
103 | 103 |
104 EXPECT_FALSE(base::PathExists(file_path)); | 104 EXPECT_FALSE(base::PathExists(file_path)); |
105 } | 105 } |
106 | 106 |
107 TEST(FileTest, Async) { | 107 TEST(FileTest, Async) { |
108 base::ScopedTempDir temp_dir; | 108 base::ScopedTempDir temp_dir; |
109 ASSERT_TRUE(temp_dir.CreateUniqueTempDir()); | 109 ASSERT_TRUE(temp_dir.CreateUniqueTempDir()); |
110 FilePath file_path = temp_dir.path().AppendASCII("create_file"); | 110 FilePath file_path = temp_dir.GetPath().AppendASCII("create_file"); |
111 | 111 |
112 { | 112 { |
113 File file(file_path, base::File::FLAG_OPEN_ALWAYS | base::File::FLAG_ASYNC); | 113 File file(file_path, base::File::FLAG_OPEN_ALWAYS | base::File::FLAG_ASYNC); |
114 EXPECT_TRUE(file.IsValid()); | 114 EXPECT_TRUE(file.IsValid()); |
115 EXPECT_TRUE(file.async()); | 115 EXPECT_TRUE(file.async()); |
116 } | 116 } |
117 | 117 |
118 { | 118 { |
119 File file(file_path, base::File::FLAG_OPEN_ALWAYS); | 119 File file(file_path, base::File::FLAG_OPEN_ALWAYS); |
120 EXPECT_TRUE(file.IsValid()); | 120 EXPECT_TRUE(file.IsValid()); |
121 EXPECT_FALSE(file.async()); | 121 EXPECT_FALSE(file.async()); |
122 } | 122 } |
123 } | 123 } |
124 | 124 |
125 TEST(FileTest, DeleteOpenFile) { | 125 TEST(FileTest, DeleteOpenFile) { |
126 base::ScopedTempDir temp_dir; | 126 base::ScopedTempDir temp_dir; |
127 ASSERT_TRUE(temp_dir.CreateUniqueTempDir()); | 127 ASSERT_TRUE(temp_dir.CreateUniqueTempDir()); |
128 FilePath file_path = temp_dir.path().AppendASCII("create_file_1"); | 128 FilePath file_path = temp_dir.GetPath().AppendASCII("create_file_1"); |
129 | 129 |
130 // Create a file. | 130 // Create a file. |
131 File file(file_path, | 131 File file(file_path, |
132 base::File::FLAG_OPEN_ALWAYS | base::File::FLAG_READ | | 132 base::File::FLAG_OPEN_ALWAYS | base::File::FLAG_READ | |
133 base::File::FLAG_SHARE_DELETE); | 133 base::File::FLAG_SHARE_DELETE); |
134 EXPECT_TRUE(file.IsValid()); | 134 EXPECT_TRUE(file.IsValid()); |
135 EXPECT_TRUE(file.created()); | 135 EXPECT_TRUE(file.created()); |
136 EXPECT_EQ(base::File::FILE_OK, file.error_details()); | 136 EXPECT_EQ(base::File::FILE_OK, file.error_details()); |
137 | 137 |
138 // Open an existing file and mark it as delete on close. | 138 // Open an existing file and mark it as delete on close. |
139 File same_file(file_path, | 139 File same_file(file_path, |
140 base::File::FLAG_OPEN | base::File::FLAG_DELETE_ON_CLOSE | | 140 base::File::FLAG_OPEN | base::File::FLAG_DELETE_ON_CLOSE | |
141 base::File::FLAG_READ); | 141 base::File::FLAG_READ); |
142 EXPECT_TRUE(file.IsValid()); | 142 EXPECT_TRUE(file.IsValid()); |
143 EXPECT_FALSE(same_file.created()); | 143 EXPECT_FALSE(same_file.created()); |
144 EXPECT_EQ(base::File::FILE_OK, same_file.error_details()); | 144 EXPECT_EQ(base::File::FILE_OK, same_file.error_details()); |
145 | 145 |
146 // Close both handles and check that the file is gone. | 146 // Close both handles and check that the file is gone. |
147 file.Close(); | 147 file.Close(); |
148 same_file.Close(); | 148 same_file.Close(); |
149 EXPECT_FALSE(base::PathExists(file_path)); | 149 EXPECT_FALSE(base::PathExists(file_path)); |
150 } | 150 } |
151 | 151 |
152 TEST(FileTest, ReadWrite) { | 152 TEST(FileTest, ReadWrite) { |
153 base::ScopedTempDir temp_dir; | 153 base::ScopedTempDir temp_dir; |
154 ASSERT_TRUE(temp_dir.CreateUniqueTempDir()); | 154 ASSERT_TRUE(temp_dir.CreateUniqueTempDir()); |
155 FilePath file_path = temp_dir.path().AppendASCII("read_write_file"); | 155 FilePath file_path = temp_dir.GetPath().AppendASCII("read_write_file"); |
156 File file(file_path, | 156 File file(file_path, |
157 base::File::FLAG_CREATE | base::File::FLAG_READ | | 157 base::File::FLAG_CREATE | base::File::FLAG_READ | |
158 base::File::FLAG_WRITE); | 158 base::File::FLAG_WRITE); |
159 ASSERT_TRUE(file.IsValid()); | 159 ASSERT_TRUE(file.IsValid()); |
160 | 160 |
161 char data_to_write[] = "test"; | 161 char data_to_write[] = "test"; |
162 const int kTestDataSize = 4; | 162 const int kTestDataSize = 4; |
163 | 163 |
164 // Write 0 bytes to the file. | 164 // Write 0 bytes to the file. |
165 int bytes_written = file.Write(0, data_to_write, 0); | 165 int bytes_written = file.Write(0, data_to_write, 0); |
(...skipping 51 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
217 EXPECT_EQ(data_to_write[i], data_read_2[i]); | 217 EXPECT_EQ(data_to_write[i], data_read_2[i]); |
218 for (int i = kTestDataSize; i < kOffsetBeyondEndOfFile; i++) | 218 for (int i = kTestDataSize; i < kOffsetBeyondEndOfFile; i++) |
219 EXPECT_EQ(0, data_read_2[i]); | 219 EXPECT_EQ(0, data_read_2[i]); |
220 for (int i = kOffsetBeyondEndOfFile; i < file_size; i++) | 220 for (int i = kOffsetBeyondEndOfFile; i < file_size; i++) |
221 EXPECT_EQ(data_to_write[i - kOffsetBeyondEndOfFile], data_read_2[i]); | 221 EXPECT_EQ(data_to_write[i - kOffsetBeyondEndOfFile], data_read_2[i]); |
222 } | 222 } |
223 | 223 |
224 TEST(FileTest, Append) { | 224 TEST(FileTest, Append) { |
225 base::ScopedTempDir temp_dir; | 225 base::ScopedTempDir temp_dir; |
226 ASSERT_TRUE(temp_dir.CreateUniqueTempDir()); | 226 ASSERT_TRUE(temp_dir.CreateUniqueTempDir()); |
227 FilePath file_path = temp_dir.path().AppendASCII("append_file"); | 227 FilePath file_path = temp_dir.GetPath().AppendASCII("append_file"); |
228 File file(file_path, base::File::FLAG_CREATE | base::File::FLAG_APPEND); | 228 File file(file_path, base::File::FLAG_CREATE | base::File::FLAG_APPEND); |
229 ASSERT_TRUE(file.IsValid()); | 229 ASSERT_TRUE(file.IsValid()); |
230 | 230 |
231 char data_to_write[] = "test"; | 231 char data_to_write[] = "test"; |
232 const int kTestDataSize = 4; | 232 const int kTestDataSize = 4; |
233 | 233 |
234 // Write 0 bytes to the file. | 234 // Write 0 bytes to the file. |
235 int bytes_written = file.Write(0, data_to_write, 0); | 235 int bytes_written = file.Write(0, data_to_write, 0); |
236 EXPECT_EQ(0, bytes_written); | 236 EXPECT_EQ(0, bytes_written); |
237 | 237 |
(...skipping 27 matching lines...) Expand all Loading... |
265 for (int i = 0; i < kTestDataSize; i++) | 265 for (int i = 0; i < kTestDataSize; i++) |
266 EXPECT_EQ(data_to_write[i], data_read_1[i]); | 266 EXPECT_EQ(data_to_write[i], data_read_1[i]); |
267 for (int i = 0; i < kAppendDataSize; i++) | 267 for (int i = 0; i < kAppendDataSize; i++) |
268 EXPECT_EQ(append_data_to_write[i], data_read_1[kTestDataSize + i]); | 268 EXPECT_EQ(append_data_to_write[i], data_read_1[kTestDataSize + i]); |
269 } | 269 } |
270 | 270 |
271 | 271 |
272 TEST(FileTest, Length) { | 272 TEST(FileTest, Length) { |
273 base::ScopedTempDir temp_dir; | 273 base::ScopedTempDir temp_dir; |
274 ASSERT_TRUE(temp_dir.CreateUniqueTempDir()); | 274 ASSERT_TRUE(temp_dir.CreateUniqueTempDir()); |
275 FilePath file_path = temp_dir.path().AppendASCII("truncate_file"); | 275 FilePath file_path = temp_dir.GetPath().AppendASCII("truncate_file"); |
276 File file(file_path, | 276 File file(file_path, |
277 base::File::FLAG_CREATE | base::File::FLAG_READ | | 277 base::File::FLAG_CREATE | base::File::FLAG_READ | |
278 base::File::FLAG_WRITE); | 278 base::File::FLAG_WRITE); |
279 ASSERT_TRUE(file.IsValid()); | 279 ASSERT_TRUE(file.IsValid()); |
280 EXPECT_EQ(0, file.GetLength()); | 280 EXPECT_EQ(0, file.GetLength()); |
281 | 281 |
282 // Write "test" to the file. | 282 // Write "test" to the file. |
283 char data_to_write[] = "test"; | 283 char data_to_write[] = "test"; |
284 int kTestDataSize = 4; | 284 int kTestDataSize = 4; |
285 int bytes_written = file.Write(0, data_to_write, kTestDataSize); | 285 int bytes_written = file.Write(0, data_to_write, kTestDataSize); |
(...skipping 31 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
317 } | 317 } |
318 | 318 |
319 // Flakily fails: http://crbug.com/86494 | 319 // Flakily fails: http://crbug.com/86494 |
320 #if defined(OS_ANDROID) | 320 #if defined(OS_ANDROID) |
321 TEST(FileTest, TouchGetInfo) { | 321 TEST(FileTest, TouchGetInfo) { |
322 #else | 322 #else |
323 TEST(FileTest, DISABLED_TouchGetInfo) { | 323 TEST(FileTest, DISABLED_TouchGetInfo) { |
324 #endif | 324 #endif |
325 base::ScopedTempDir temp_dir; | 325 base::ScopedTempDir temp_dir; |
326 ASSERT_TRUE(temp_dir.CreateUniqueTempDir()); | 326 ASSERT_TRUE(temp_dir.CreateUniqueTempDir()); |
327 File file(temp_dir.path().AppendASCII("touch_get_info_file"), | 327 File file(temp_dir.GetPath().AppendASCII("touch_get_info_file"), |
328 base::File::FLAG_CREATE | base::File::FLAG_WRITE | | 328 base::File::FLAG_CREATE | base::File::FLAG_WRITE | |
329 base::File::FLAG_WRITE_ATTRIBUTES); | 329 base::File::FLAG_WRITE_ATTRIBUTES); |
330 ASSERT_TRUE(file.IsValid()); | 330 ASSERT_TRUE(file.IsValid()); |
331 | 331 |
332 // Get info for a newly created file. | 332 // Get info for a newly created file. |
333 base::File::Info info; | 333 base::File::Info info; |
334 EXPECT_TRUE(file.GetInfo(&info)); | 334 EXPECT_TRUE(file.GetInfo(&info)); |
335 | 335 |
336 // Add 2 seconds to account for possible rounding errors on | 336 // Add 2 seconds to account for possible rounding errors on |
337 // filesystems that use a 1s or 2s timestamp granularity. | 337 // filesystems that use a 1s or 2s timestamp granularity. |
(...skipping 42 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
380 new_last_modified.ToInternalValue()); | 380 new_last_modified.ToInternalValue()); |
381 #endif | 381 #endif |
382 | 382 |
383 EXPECT_EQ(info.creation_time.ToInternalValue(), | 383 EXPECT_EQ(info.creation_time.ToInternalValue(), |
384 creation_time.ToInternalValue()); | 384 creation_time.ToInternalValue()); |
385 } | 385 } |
386 | 386 |
387 TEST(FileTest, ReadAtCurrentPosition) { | 387 TEST(FileTest, ReadAtCurrentPosition) { |
388 base::ScopedTempDir temp_dir; | 388 base::ScopedTempDir temp_dir; |
389 ASSERT_TRUE(temp_dir.CreateUniqueTempDir()); | 389 ASSERT_TRUE(temp_dir.CreateUniqueTempDir()); |
390 FilePath file_path = temp_dir.path().AppendASCII("read_at_current_position"); | 390 FilePath file_path = |
| 391 temp_dir.GetPath().AppendASCII("read_at_current_position"); |
391 File file(file_path, | 392 File file(file_path, |
392 base::File::FLAG_CREATE | base::File::FLAG_READ | | 393 base::File::FLAG_CREATE | base::File::FLAG_READ | |
393 base::File::FLAG_WRITE); | 394 base::File::FLAG_WRITE); |
394 EXPECT_TRUE(file.IsValid()); | 395 EXPECT_TRUE(file.IsValid()); |
395 | 396 |
396 const char kData[] = "test"; | 397 const char kData[] = "test"; |
397 const int kDataSize = sizeof(kData) - 1; | 398 const int kDataSize = sizeof(kData) - 1; |
398 EXPECT_EQ(kDataSize, file.Write(0, kData, kDataSize)); | 399 EXPECT_EQ(kDataSize, file.Write(0, kData, kDataSize)); |
399 | 400 |
400 EXPECT_EQ(0, file.Seek(base::File::FROM_BEGIN, 0)); | 401 EXPECT_EQ(0, file.Seek(base::File::FROM_BEGIN, 0)); |
401 | 402 |
402 char buffer[kDataSize]; | 403 char buffer[kDataSize]; |
403 int first_chunk_size = kDataSize / 2; | 404 int first_chunk_size = kDataSize / 2; |
404 EXPECT_EQ(first_chunk_size, file.ReadAtCurrentPos(buffer, first_chunk_size)); | 405 EXPECT_EQ(first_chunk_size, file.ReadAtCurrentPos(buffer, first_chunk_size)); |
405 EXPECT_EQ(kDataSize - first_chunk_size, | 406 EXPECT_EQ(kDataSize - first_chunk_size, |
406 file.ReadAtCurrentPos(buffer + first_chunk_size, | 407 file.ReadAtCurrentPos(buffer + first_chunk_size, |
407 kDataSize - first_chunk_size)); | 408 kDataSize - first_chunk_size)); |
408 EXPECT_EQ(std::string(buffer, buffer + kDataSize), std::string(kData)); | 409 EXPECT_EQ(std::string(buffer, buffer + kDataSize), std::string(kData)); |
409 } | 410 } |
410 | 411 |
411 TEST(FileTest, WriteAtCurrentPosition) { | 412 TEST(FileTest, WriteAtCurrentPosition) { |
412 base::ScopedTempDir temp_dir; | 413 base::ScopedTempDir temp_dir; |
413 ASSERT_TRUE(temp_dir.CreateUniqueTempDir()); | 414 ASSERT_TRUE(temp_dir.CreateUniqueTempDir()); |
414 FilePath file_path = temp_dir.path().AppendASCII("write_at_current_position"); | 415 FilePath file_path = |
| 416 temp_dir.GetPath().AppendASCII("write_at_current_position"); |
415 File file(file_path, | 417 File file(file_path, |
416 base::File::FLAG_CREATE | base::File::FLAG_READ | | 418 base::File::FLAG_CREATE | base::File::FLAG_READ | |
417 base::File::FLAG_WRITE); | 419 base::File::FLAG_WRITE); |
418 EXPECT_TRUE(file.IsValid()); | 420 EXPECT_TRUE(file.IsValid()); |
419 | 421 |
420 const char kData[] = "test"; | 422 const char kData[] = "test"; |
421 const int kDataSize = sizeof(kData) - 1; | 423 const int kDataSize = sizeof(kData) - 1; |
422 | 424 |
423 int first_chunk_size = kDataSize / 2; | 425 int first_chunk_size = kDataSize / 2; |
424 EXPECT_EQ(first_chunk_size, file.WriteAtCurrentPos(kData, first_chunk_size)); | 426 EXPECT_EQ(first_chunk_size, file.WriteAtCurrentPos(kData, first_chunk_size)); |
425 EXPECT_EQ(kDataSize - first_chunk_size, | 427 EXPECT_EQ(kDataSize - first_chunk_size, |
426 file.WriteAtCurrentPos(kData + first_chunk_size, | 428 file.WriteAtCurrentPos(kData + first_chunk_size, |
427 kDataSize - first_chunk_size)); | 429 kDataSize - first_chunk_size)); |
428 | 430 |
429 char buffer[kDataSize]; | 431 char buffer[kDataSize]; |
430 EXPECT_EQ(kDataSize, file.Read(0, buffer, kDataSize)); | 432 EXPECT_EQ(kDataSize, file.Read(0, buffer, kDataSize)); |
431 EXPECT_EQ(std::string(buffer, buffer + kDataSize), std::string(kData)); | 433 EXPECT_EQ(std::string(buffer, buffer + kDataSize), std::string(kData)); |
432 } | 434 } |
433 | 435 |
434 TEST(FileTest, Seek) { | 436 TEST(FileTest, Seek) { |
435 base::ScopedTempDir temp_dir; | 437 base::ScopedTempDir temp_dir; |
436 ASSERT_TRUE(temp_dir.CreateUniqueTempDir()); | 438 ASSERT_TRUE(temp_dir.CreateUniqueTempDir()); |
437 FilePath file_path = temp_dir.path().AppendASCII("seek_file"); | 439 FilePath file_path = temp_dir.GetPath().AppendASCII("seek_file"); |
438 File file(file_path, | 440 File file(file_path, |
439 base::File::FLAG_CREATE | base::File::FLAG_READ | | 441 base::File::FLAG_CREATE | base::File::FLAG_READ | |
440 base::File::FLAG_WRITE); | 442 base::File::FLAG_WRITE); |
441 ASSERT_TRUE(file.IsValid()); | 443 ASSERT_TRUE(file.IsValid()); |
442 | 444 |
443 const int64_t kOffset = 10; | 445 const int64_t kOffset = 10; |
444 EXPECT_EQ(kOffset, file.Seek(base::File::FROM_BEGIN, kOffset)); | 446 EXPECT_EQ(kOffset, file.Seek(base::File::FROM_BEGIN, kOffset)); |
445 EXPECT_EQ(2 * kOffset, file.Seek(base::File::FROM_CURRENT, kOffset)); | 447 EXPECT_EQ(2 * kOffset, file.Seek(base::File::FROM_CURRENT, kOffset)); |
446 EXPECT_EQ(kOffset, file.Seek(base::File::FROM_CURRENT, -kOffset)); | 448 EXPECT_EQ(kOffset, file.Seek(base::File::FROM_CURRENT, -kOffset)); |
447 EXPECT_TRUE(file.SetLength(kOffset * 2)); | 449 EXPECT_TRUE(file.SetLength(kOffset * 2)); |
448 EXPECT_EQ(kOffset, file.Seek(base::File::FROM_END, -kOffset)); | 450 EXPECT_EQ(kOffset, file.Seek(base::File::FROM_END, -kOffset)); |
449 } | 451 } |
450 | 452 |
451 TEST(FileTest, Duplicate) { | 453 TEST(FileTest, Duplicate) { |
452 base::ScopedTempDir temp_dir; | 454 base::ScopedTempDir temp_dir; |
453 ASSERT_TRUE(temp_dir.CreateUniqueTempDir()); | 455 ASSERT_TRUE(temp_dir.CreateUniqueTempDir()); |
454 FilePath file_path = temp_dir.path().AppendASCII("file"); | 456 FilePath file_path = temp_dir.GetPath().AppendASCII("file"); |
455 File file(file_path,(base::File::FLAG_CREATE | | 457 File file(file_path,(base::File::FLAG_CREATE | |
456 base::File::FLAG_READ | | 458 base::File::FLAG_READ | |
457 base::File::FLAG_WRITE)); | 459 base::File::FLAG_WRITE)); |
458 ASSERT_TRUE(file.IsValid()); | 460 ASSERT_TRUE(file.IsValid()); |
459 | 461 |
460 File file2(file.Duplicate()); | 462 File file2(file.Duplicate()); |
461 ASSERT_TRUE(file2.IsValid()); | 463 ASSERT_TRUE(file2.IsValid()); |
462 | 464 |
463 // Write through one handle, close it, read through the other. | 465 // Write through one handle, close it, read through the other. |
464 static const char kData[] = "now is a good time."; | 466 static const char kData[] = "now is a good time."; |
465 static const int kDataLen = sizeof(kData) - 1; | 467 static const int kDataLen = sizeof(kData) - 1; |
466 | 468 |
467 ASSERT_EQ(0, file.Seek(base::File::FROM_CURRENT, 0)); | 469 ASSERT_EQ(0, file.Seek(base::File::FROM_CURRENT, 0)); |
468 ASSERT_EQ(0, file2.Seek(base::File::FROM_CURRENT, 0)); | 470 ASSERT_EQ(0, file2.Seek(base::File::FROM_CURRENT, 0)); |
469 ASSERT_EQ(kDataLen, file.WriteAtCurrentPos(kData, kDataLen)); | 471 ASSERT_EQ(kDataLen, file.WriteAtCurrentPos(kData, kDataLen)); |
470 ASSERT_EQ(kDataLen, file.Seek(base::File::FROM_CURRENT, 0)); | 472 ASSERT_EQ(kDataLen, file.Seek(base::File::FROM_CURRENT, 0)); |
471 ASSERT_EQ(kDataLen, file2.Seek(base::File::FROM_CURRENT, 0)); | 473 ASSERT_EQ(kDataLen, file2.Seek(base::File::FROM_CURRENT, 0)); |
472 file.Close(); | 474 file.Close(); |
473 char buf[kDataLen]; | 475 char buf[kDataLen]; |
474 ASSERT_EQ(kDataLen, file2.Read(0, &buf[0], kDataLen)); | 476 ASSERT_EQ(kDataLen, file2.Read(0, &buf[0], kDataLen)); |
475 ASSERT_EQ(std::string(kData, kDataLen), std::string(&buf[0], kDataLen)); | 477 ASSERT_EQ(std::string(kData, kDataLen), std::string(&buf[0], kDataLen)); |
476 } | 478 } |
477 | 479 |
478 TEST(FileTest, DuplicateDeleteOnClose) { | 480 TEST(FileTest, DuplicateDeleteOnClose) { |
479 base::ScopedTempDir temp_dir; | 481 base::ScopedTempDir temp_dir; |
480 ASSERT_TRUE(temp_dir.CreateUniqueTempDir()); | 482 ASSERT_TRUE(temp_dir.CreateUniqueTempDir()); |
481 FilePath file_path = temp_dir.path().AppendASCII("file"); | 483 FilePath file_path = temp_dir.GetPath().AppendASCII("file"); |
482 File file(file_path,(base::File::FLAG_CREATE | | 484 File file(file_path,(base::File::FLAG_CREATE | |
483 base::File::FLAG_READ | | 485 base::File::FLAG_READ | |
484 base::File::FLAG_WRITE | | 486 base::File::FLAG_WRITE | |
485 base::File::FLAG_DELETE_ON_CLOSE)); | 487 base::File::FLAG_DELETE_ON_CLOSE)); |
486 ASSERT_TRUE(file.IsValid()); | 488 ASSERT_TRUE(file.IsValid()); |
487 File file2(file.Duplicate()); | 489 File file2(file.Duplicate()); |
488 ASSERT_TRUE(file2.IsValid()); | 490 ASSERT_TRUE(file2.IsValid()); |
489 file.Close(); | 491 file.Close(); |
490 file2.Close(); | 492 file2.Close(); |
491 ASSERT_FALSE(base::PathExists(file_path)); | 493 ASSERT_FALSE(base::PathExists(file_path)); |
492 } | 494 } |
493 | 495 |
494 #if defined(OS_WIN) | 496 #if defined(OS_WIN) |
495 TEST(FileTest, GetInfoForDirectory) { | 497 TEST(FileTest, GetInfoForDirectory) { |
496 base::ScopedTempDir temp_dir; | 498 base::ScopedTempDir temp_dir; |
497 ASSERT_TRUE(temp_dir.CreateUniqueTempDir()); | 499 ASSERT_TRUE(temp_dir.CreateUniqueTempDir()); |
498 FilePath empty_dir = temp_dir.path().Append(FILE_PATH_LITERAL("gpfi_test")); | 500 FilePath empty_dir = |
| 501 temp_dir.GetPath().Append(FILE_PATH_LITERAL("gpfi_test")); |
499 ASSERT_TRUE(CreateDirectory(empty_dir)); | 502 ASSERT_TRUE(CreateDirectory(empty_dir)); |
500 | 503 |
501 base::File dir( | 504 base::File dir( |
502 ::CreateFile(empty_dir.value().c_str(), | 505 ::CreateFile(empty_dir.value().c_str(), |
503 GENERIC_READ | GENERIC_WRITE, | 506 GENERIC_READ | GENERIC_WRITE, |
504 FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE, | 507 FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE, |
505 NULL, | 508 NULL, |
506 OPEN_EXISTING, | 509 OPEN_EXISTING, |
507 FILE_FLAG_BACKUP_SEMANTICS, // Needed to open a directory. | 510 FILE_FLAG_BACKUP_SEMANTICS, // Needed to open a directory. |
508 NULL)); | 511 NULL)); |
509 ASSERT_TRUE(dir.IsValid()); | 512 ASSERT_TRUE(dir.IsValid()); |
510 | 513 |
511 base::File::Info info; | 514 base::File::Info info; |
512 EXPECT_TRUE(dir.GetInfo(&info)); | 515 EXPECT_TRUE(dir.GetInfo(&info)); |
513 EXPECT_TRUE(info.is_directory); | 516 EXPECT_TRUE(info.is_directory); |
514 EXPECT_FALSE(info.is_symbolic_link); | 517 EXPECT_FALSE(info.is_symbolic_link); |
515 EXPECT_EQ(0, info.size); | 518 EXPECT_EQ(0, info.size); |
516 } | 519 } |
517 #endif // defined(OS_WIN) | 520 #endif // defined(OS_WIN) |
OLD | NEW |