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 "net/base/file_stream.h" | 5 #include "net/base/file_stream.h" |
6 | 6 |
7 #include "base/bind.h" | 7 #include "base/bind.h" |
8 #include "base/callback.h" | 8 #include "base/callback.h" |
9 #include "base/file_util.h" | 9 #include "base/file_util.h" |
10 #include "base/message_loop.h" | 10 #include "base/message_loop.h" |
(...skipping 15 matching lines...) Expand all Loading... |
26 const char kTestData[] = "0123456789"; | 26 const char kTestData[] = "0123456789"; |
27 const int kTestDataSize = arraysize(kTestData) - 1; | 27 const int kTestDataSize = arraysize(kTestData) - 1; |
28 | 28 |
29 // Creates an IOBufferWithSize that contains the kTestDataSize. | 29 // Creates an IOBufferWithSize that contains the kTestDataSize. |
30 IOBufferWithSize* CreateTestDataBuffer() { | 30 IOBufferWithSize* CreateTestDataBuffer() { |
31 IOBufferWithSize* buf = new IOBufferWithSize(kTestDataSize); | 31 IOBufferWithSize* buf = new IOBufferWithSize(kTestDataSize); |
32 memcpy(buf->data(), kTestData, kTestDataSize); | 32 memcpy(buf->data(), kTestData, kTestDataSize); |
33 return buf; | 33 return buf; |
34 } | 34 } |
35 | 35 |
36 // This NetLog is used for notifying when a file stream is closed | |
37 // (i.e. TYPE_FILE_STREAM_CLOSE event is recorded). | |
38 class NetLogForNotifyingFileClosure : public NetLog { | |
39 public: | |
40 NetLogForNotifyingFileClosure() | |
41 : last_id_(0), | |
42 on_closure_(false /* manual_reset */, false /* initially_signaled */) { | |
43 } | |
44 | |
45 // Wait until a file closure event is recorded. | |
46 bool WaitForClosure() { | |
47 const base::TimeDelta timeout(TestTimeouts::action_max_timeout()); | |
48 return on_closure_.TimedWait(timeout); | |
49 } | |
50 | |
51 // NetLog overrides: | |
52 virtual void OnAddEntry(const net::NetLog::Entry& entry) OVERRIDE { | |
53 if (entry.type() == TYPE_FILE_STREAM_CLOSE) | |
54 on_closure_.Signal(); | |
55 } | |
56 | |
57 virtual uint32 NextID() OVERRIDE { return ++last_id_; } | |
58 virtual LogLevel GetLogLevel() const OVERRIDE { return LOG_ALL; } | |
59 virtual void AddThreadSafeObserver(ThreadSafeObserver* observer, | |
60 LogLevel log_level) OVERRIDE { | |
61 NOTIMPLEMENTED(); | |
62 } | |
63 virtual void SetObserverLogLevel(ThreadSafeObserver* observer, | |
64 LogLevel log_level) OVERRIDE { | |
65 NOTIMPLEMENTED(); | |
66 } | |
67 virtual void RemoveThreadSafeObserver(ThreadSafeObserver* observer) OVERRIDE { | |
68 NOTIMPLEMENTED(); | |
69 } | |
70 | |
71 private: | |
72 uint32 last_id_; | |
73 base::WaitableEvent on_closure_; | |
74 }; | |
75 | |
76 } // namespace | 36 } // namespace |
77 | 37 |
78 class FileStreamTest : public PlatformTest { | 38 class FileStreamTest : public PlatformTest { |
79 public: | 39 public: |
80 virtual void SetUp() { | 40 virtual void SetUp() { |
81 PlatformTest::SetUp(); | 41 PlatformTest::SetUp(); |
82 | 42 |
83 file_util::CreateTemporaryFile(&temp_file_path_); | 43 file_util::CreateTemporaryFile(&temp_file_path_); |
84 file_util::WriteFile(temp_file_path_, kTestData, kTestDataSize); | 44 file_util::WriteFile(temp_file_path_, kTestData, kTestDataSize); |
85 } | 45 } |
(...skipping 20 matching lines...) Expand all Loading... |
106 EXPECT_EQ(OK, rv); | 66 EXPECT_EQ(OK, rv); |
107 EXPECT_TRUE(stream.IsOpen()); | 67 EXPECT_TRUE(stream.IsOpen()); |
108 file = stream.GetPlatformFileForTesting(); | 68 file = stream.GetPlatformFileForTesting(); |
109 } | 69 } |
110 EXPECT_NE(base::kInvalidPlatformFileValue, file); | 70 EXPECT_NE(base::kInvalidPlatformFileValue, file); |
111 base::PlatformFileInfo info; | 71 base::PlatformFileInfo info; |
112 // The file should be closed. | 72 // The file should be closed. |
113 EXPECT_FALSE(base::GetPlatformFileInfo(file, &info)); | 73 EXPECT_FALSE(base::GetPlatformFileInfo(file, &info)); |
114 } | 74 } |
115 | 75 |
116 TEST_F(FileStreamTest, FileHandleLeftOpen) { | 76 TEST_F(FileStreamTest, FileHandleNotLeftOpen) { |
117 bool created = false; | 77 bool created = false; |
118 ASSERT_EQ(kTestDataSize, | 78 ASSERT_EQ(kTestDataSize, |
119 file_util::WriteFile(temp_file_path(), kTestData, kTestDataSize)); | 79 file_util::WriteFile(temp_file_path(), kTestData, kTestDataSize)); |
120 int flags = base::PLATFORM_FILE_OPEN_ALWAYS | base::PLATFORM_FILE_READ; | 80 int flags = base::PLATFORM_FILE_OPEN_ALWAYS | base::PLATFORM_FILE_READ; |
121 base::PlatformFile file = base::CreatePlatformFile( | 81 base::PlatformFile file = base::CreatePlatformFile( |
122 temp_file_path(), flags, &created, NULL); | 82 temp_file_path(), flags, &created, NULL); |
123 | 83 |
124 { | 84 { |
125 // Seek to the beginning of the file and read. | 85 // Seek to the beginning of the file and read. |
126 FileStream read_stream(file, flags, NULL); | 86 FileStream read_stream(file, flags, NULL); |
127 EXPECT_TRUE(read_stream.IsOpen()); | 87 EXPECT_TRUE(read_stream.IsOpen()); |
128 } | 88 } |
129 | 89 |
130 EXPECT_NE(base::kInvalidPlatformFileValue, file); | 90 EXPECT_NE(base::kInvalidPlatformFileValue, file); |
131 base::PlatformFileInfo info; | 91 base::PlatformFileInfo info; |
132 // The file should still be open. | 92 // The file should be closed. |
133 EXPECT_TRUE(base::GetPlatformFileInfo(file, &info)); | 93 EXPECT_FALSE(base::GetPlatformFileInfo(file, &info)); |
134 // Clean up. | 94 EXPECT_FALSE(base::ClosePlatformFile(file)); |
135 EXPECT_TRUE(base::ClosePlatformFile(file)); | |
136 } | 95 } |
137 | 96 |
138 // Test the use of FileStream with a file handle provided at construction. | 97 // Test the use of FileStream with a file handle provided at construction. |
139 TEST_F(FileStreamTest, UseFileHandle) { | 98 TEST_F(FileStreamTest, UseFileHandle) { |
140 bool created = false; | 99 bool created = false; |
141 | 100 |
142 // 1. Test reading with a file handle. | 101 // 1. Test reading with a file handle. |
143 ASSERT_EQ(kTestDataSize, | 102 ASSERT_EQ(kTestDataSize, |
144 file_util::WriteFile(temp_file_path(), kTestData, kTestDataSize)); | 103 file_util::WriteFile(temp_file_path(), kTestData, kTestDataSize)); |
145 int flags = base::PLATFORM_FILE_OPEN_ALWAYS | base::PLATFORM_FILE_READ; | 104 int flags = base::PLATFORM_FILE_OPEN_ALWAYS | base::PLATFORM_FILE_READ; |
146 base::PlatformFile file = base::CreatePlatformFile( | 105 base::PlatformFile file = base::CreatePlatformFile( |
147 temp_file_path(), flags, &created, NULL); | 106 temp_file_path(), flags, &created, NULL); |
148 | 107 |
149 // Seek to the beginning of the file and read. | 108 // Seek to the beginning of the file and read. |
150 FileStream read_stream(file, flags, NULL); | 109 scoped_ptr<FileStream> read_stream(new FileStream(file, flags, NULL)); |
151 ASSERT_EQ(0, read_stream.SeekSync(FROM_BEGIN, 0)); | 110 ASSERT_EQ(0, read_stream->SeekSync(FROM_BEGIN, 0)); |
152 ASSERT_EQ(kTestDataSize, read_stream.Available()); | 111 ASSERT_EQ(kTestDataSize, read_stream->Available()); |
153 // Read into buffer and compare. | 112 // Read into buffer and compare. |
154 char buffer[kTestDataSize]; | 113 char buffer[kTestDataSize]; |
155 ASSERT_EQ(kTestDataSize, | 114 ASSERT_EQ(kTestDataSize, |
156 read_stream.ReadSync(buffer, kTestDataSize)); | 115 read_stream->ReadSync(buffer, kTestDataSize)); |
157 ASSERT_EQ(0, memcmp(kTestData, buffer, kTestDataSize)); | 116 ASSERT_EQ(0, memcmp(kTestData, buffer, kTestDataSize)); |
158 read_stream.CloseSync(); | 117 read_stream.reset(); |
159 | 118 |
160 // 2. Test writing with a file handle. | 119 // 2. Test writing with a file handle. |
161 file_util::Delete(temp_file_path(), false); | 120 file_util::Delete(temp_file_path(), false); |
162 flags = base::PLATFORM_FILE_OPEN_ALWAYS | base::PLATFORM_FILE_WRITE; | 121 flags = base::PLATFORM_FILE_OPEN_ALWAYS | base::PLATFORM_FILE_WRITE; |
163 file = base::CreatePlatformFile(temp_file_path(), flags, &created, NULL); | 122 file = base::CreatePlatformFile(temp_file_path(), flags, &created, NULL); |
164 | 123 |
165 FileStream write_stream(file, flags, NULL); | 124 scoped_ptr<FileStream> write_stream(new FileStream(file, flags, NULL)); |
166 ASSERT_EQ(0, write_stream.SeekSync(FROM_BEGIN, 0)); | 125 ASSERT_EQ(0, write_stream->SeekSync(FROM_BEGIN, 0)); |
167 ASSERT_EQ(kTestDataSize, | 126 ASSERT_EQ(kTestDataSize, |
168 write_stream.WriteSync(kTestData, kTestDataSize)); | 127 write_stream->WriteSync(kTestData, kTestDataSize)); |
169 write_stream.CloseSync(); | 128 write_stream.reset(); |
170 | 129 |
171 // Read into buffer and compare to make sure the handle worked fine. | 130 // Read into buffer and compare to make sure the handle worked fine. |
172 ASSERT_EQ(kTestDataSize, | 131 ASSERT_EQ(kTestDataSize, |
173 file_util::ReadFile(temp_file_path(), buffer, kTestDataSize)); | 132 file_util::ReadFile(temp_file_path(), buffer, kTestDataSize)); |
174 ASSERT_EQ(0, memcmp(kTestData, buffer, kTestDataSize)); | 133 ASSERT_EQ(0, memcmp(kTestData, buffer, kTestDataSize)); |
175 } | 134 } |
176 | 135 |
177 TEST_F(FileStreamTest, UseClosedStream) { | 136 TEST_F(FileStreamTest, UseClosedStream) { |
178 FileStream stream(NULL); | 137 FileStream stream(NULL); |
179 | 138 |
(...skipping 71 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
251 EXPECT_LE(0, rv); | 210 EXPECT_LE(0, rv); |
252 if (rv <= 0) | 211 if (rv <= 0) |
253 break; | 212 break; |
254 total_bytes_read += rv; | 213 total_bytes_read += rv; |
255 data_read.append(buf->data(), rv); | 214 data_read.append(buf->data(), rv); |
256 } | 215 } |
257 EXPECT_EQ(file_size, total_bytes_read); | 216 EXPECT_EQ(file_size, total_bytes_read); |
258 EXPECT_EQ(kTestData, data_read); | 217 EXPECT_EQ(kTestData, data_read); |
259 } | 218 } |
260 | 219 |
261 TEST_F(FileStreamTest, AsyncRead_EarlyClose) { | |
262 int64 file_size; | |
263 bool ok = file_util::GetFileSize(temp_file_path(), &file_size); | |
264 EXPECT_TRUE(ok); | |
265 | |
266 FileStream stream(NULL); | |
267 int flags = base::PLATFORM_FILE_OPEN | | |
268 base::PLATFORM_FILE_READ | | |
269 base::PLATFORM_FILE_ASYNC; | |
270 int rv = stream.OpenSync(temp_file_path(), flags); | |
271 EXPECT_EQ(OK, rv); | |
272 | |
273 int64 total_bytes_avail = stream.Available(); | |
274 EXPECT_EQ(file_size, total_bytes_avail); | |
275 | |
276 TestCompletionCallback callback; | |
277 | |
278 scoped_refptr<IOBufferWithSize> buf = new IOBufferWithSize(4); | |
279 rv = stream.Read(buf, buf->size(), callback.callback()); | |
280 stream.CloseSync(); | |
281 if (rv < 0) { | |
282 EXPECT_EQ(ERR_IO_PENDING, rv); | |
283 // The callback should not be called if the request is cancelled. | |
284 MessageLoop::current()->RunAllPending(); | |
285 EXPECT_FALSE(callback.have_result()); | |
286 } else { | |
287 EXPECT_EQ(std::string(kTestData, rv), std::string(buf->data(), rv)); | |
288 } | |
289 } | |
290 | |
291 // Similar to AsyncRead_EarlyClose but deletes a stream instead, to ensure | |
292 // that deleting a stream is safe while an async read is in flight. | |
293 TEST_F(FileStreamTest, AsyncRead_EarlyDelete) { | 220 TEST_F(FileStreamTest, AsyncRead_EarlyDelete) { |
294 int64 file_size; | 221 int64 file_size; |
295 bool ok = file_util::GetFileSize(temp_file_path(), &file_size); | 222 bool ok = file_util::GetFileSize(temp_file_path(), &file_size); |
296 EXPECT_TRUE(ok); | 223 EXPECT_TRUE(ok); |
297 | 224 |
298 scoped_ptr<FileStream> stream(new FileStream(NULL)); | 225 scoped_ptr<FileStream> stream(new FileStream(NULL)); |
299 int flags = base::PLATFORM_FILE_OPEN | | 226 int flags = base::PLATFORM_FILE_OPEN | |
300 base::PLATFORM_FILE_READ | | 227 base::PLATFORM_FILE_READ | |
301 base::PLATFORM_FILE_ASYNC; | 228 base::PLATFORM_FILE_ASYNC; |
302 TestCompletionCallback callback; | 229 TestCompletionCallback callback; |
(...skipping 10 matching lines...) Expand all Loading... |
313 if (rv < 0) { | 240 if (rv < 0) { |
314 EXPECT_EQ(ERR_IO_PENDING, rv); | 241 EXPECT_EQ(ERR_IO_PENDING, rv); |
315 // The callback should not be called if the request is cancelled. | 242 // The callback should not be called if the request is cancelled. |
316 MessageLoop::current()->RunAllPending(); | 243 MessageLoop::current()->RunAllPending(); |
317 EXPECT_FALSE(callback.have_result()); | 244 EXPECT_FALSE(callback.have_result()); |
318 } else { | 245 } else { |
319 EXPECT_EQ(std::string(kTestData, rv), std::string(buf->data(), rv)); | 246 EXPECT_EQ(std::string(kTestData, rv), std::string(buf->data(), rv)); |
320 } | 247 } |
321 } | 248 } |
322 | 249 |
323 // Similar to AsyncRead_EarlyDelete but using a given file handler rather than | |
324 // calling FileStream::Open, to ensure that deleting a stream with in-flight | |
325 // operation without auto-closing feature is also ok. | |
326 TEST_F(FileStreamTest, AsyncRead_EarlyDelete_NoAutoClose) { | |
327 int64 file_size; | |
328 bool ok = file_util::GetFileSize(temp_file_path(), &file_size); | |
329 EXPECT_TRUE(ok); | |
330 | |
331 bool created = false; | |
332 int flags = base::PLATFORM_FILE_OPEN | | |
333 base::PLATFORM_FILE_READ | | |
334 base::PLATFORM_FILE_ASYNC; | |
335 base::PlatformFileError error_code = base::PLATFORM_FILE_ERROR_FAILED; | |
336 base::PlatformFile file = base::CreatePlatformFile( | |
337 temp_file_path(), flags, &created, &error_code); | |
338 EXPECT_EQ(base::PLATFORM_FILE_OK, error_code); | |
339 | |
340 scoped_ptr<FileStream> stream(new FileStream(file, flags, NULL)); | |
341 int64 total_bytes_avail = stream->Available(); | |
342 EXPECT_EQ(file_size, total_bytes_avail); | |
343 | |
344 TestCompletionCallback callback; | |
345 scoped_refptr<IOBufferWithSize> buf = new IOBufferWithSize(4); | |
346 int rv = stream->Read(buf, buf->size(), callback.callback()); | |
347 stream.reset(); // Delete instead of closing it. | |
348 if (rv < 0) { | |
349 EXPECT_EQ(ERR_IO_PENDING, rv); | |
350 // The callback should not be called if the request is cancelled. | |
351 MessageLoop::current()->RunAllPending(); | |
352 EXPECT_FALSE(callback.have_result()); | |
353 } else { | |
354 EXPECT_EQ(std::string(kTestData, rv), std::string(buf->data(), rv)); | |
355 } | |
356 | |
357 base::PlatformFileInfo info; | |
358 // The file should still be open. | |
359 EXPECT_TRUE(base::GetPlatformFileInfo(file, &info)); | |
360 // Clean up. | |
361 EXPECT_TRUE(base::ClosePlatformFile(file)); | |
362 } | |
363 | |
364 TEST_F(FileStreamTest, BasicRead_FromOffset) { | 250 TEST_F(FileStreamTest, BasicRead_FromOffset) { |
365 int64 file_size; | 251 int64 file_size; |
366 bool ok = file_util::GetFileSize(temp_file_path(), &file_size); | 252 bool ok = file_util::GetFileSize(temp_file_path(), &file_size); |
367 EXPECT_TRUE(ok); | 253 EXPECT_TRUE(ok); |
368 | 254 |
369 FileStream stream(NULL); | 255 FileStream stream(NULL); |
370 int flags = base::PLATFORM_FILE_OPEN | | 256 int flags = base::PLATFORM_FILE_OPEN | |
371 base::PLATFORM_FILE_READ; | 257 base::PLATFORM_FILE_READ; |
372 int rv = stream.OpenSync(temp_file_path(), flags); | 258 int rv = stream.OpenSync(temp_file_path(), flags); |
373 EXPECT_EQ(OK, rv); | 259 EXPECT_EQ(OK, rv); |
(...skipping 115 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
489 | 375 |
490 const int kTestDataLen = arraysize(kTestData) - 1; | 376 const int kTestDataLen = arraysize(kTestData) - 1; |
491 | 377 |
492 rv = stream.Seek(FROM_END, -kTestDataLen, callback.callback()); | 378 rv = stream.Seek(FROM_END, -kTestDataLen, callback.callback()); |
493 ASSERT_EQ(ERR_IO_PENDING, rv); | 379 ASSERT_EQ(ERR_IO_PENDING, rv); |
494 new_offset = callback.WaitForResult(); | 380 new_offset = callback.WaitForResult(); |
495 EXPECT_EQ(0, new_offset); | 381 EXPECT_EQ(0, new_offset); |
496 } | 382 } |
497 | 383 |
498 TEST_F(FileStreamTest, BasicWrite) { | 384 TEST_F(FileStreamTest, BasicWrite) { |
499 FileStream stream(NULL); | 385 scoped_ptr<FileStream> stream(new FileStream(NULL)); |
500 int flags = base::PLATFORM_FILE_CREATE_ALWAYS | | 386 int flags = base::PLATFORM_FILE_CREATE_ALWAYS | |
501 base::PLATFORM_FILE_WRITE; | 387 base::PLATFORM_FILE_WRITE; |
502 int rv = stream.OpenSync(temp_file_path(), flags); | 388 int rv = stream->OpenSync(temp_file_path(), flags); |
503 EXPECT_EQ(OK, rv); | 389 EXPECT_EQ(OK, rv); |
504 | 390 |
505 int64 file_size; | 391 int64 file_size; |
506 bool ok = file_util::GetFileSize(temp_file_path(), &file_size); | 392 bool ok = file_util::GetFileSize(temp_file_path(), &file_size); |
507 EXPECT_TRUE(ok); | 393 EXPECT_TRUE(ok); |
508 EXPECT_EQ(0, file_size); | 394 EXPECT_EQ(0, file_size); |
509 | 395 |
510 rv = stream.WriteSync(kTestData, kTestDataSize); | 396 rv = stream->WriteSync(kTestData, kTestDataSize); |
511 EXPECT_EQ(kTestDataSize, rv); | 397 EXPECT_EQ(kTestDataSize, rv); |
512 stream.CloseSync(); | 398 stream.reset(); |
513 | 399 |
514 ok = file_util::GetFileSize(temp_file_path(), &file_size); | 400 ok = file_util::GetFileSize(temp_file_path(), &file_size); |
515 EXPECT_TRUE(ok); | 401 EXPECT_TRUE(ok); |
516 EXPECT_EQ(kTestDataSize, file_size); | 402 EXPECT_EQ(kTestDataSize, file_size); |
517 } | 403 } |
518 | 404 |
519 TEST_F(FileStreamTest, AsyncWrite) { | 405 TEST_F(FileStreamTest, AsyncWrite) { |
520 FileStream stream(NULL); | 406 FileStream stream(NULL); |
521 int flags = base::PLATFORM_FILE_CREATE_ALWAYS | | 407 int flags = base::PLATFORM_FILE_CREATE_ALWAYS | |
522 base::PLATFORM_FILE_WRITE | | 408 base::PLATFORM_FILE_WRITE | |
(...skipping 21 matching lines...) Expand all Loading... |
544 if (rv <= 0) | 430 if (rv <= 0) |
545 break; | 431 break; |
546 drainable->DidConsume(rv); | 432 drainable->DidConsume(rv); |
547 total_bytes_written += rv; | 433 total_bytes_written += rv; |
548 } | 434 } |
549 ok = file_util::GetFileSize(temp_file_path(), &file_size); | 435 ok = file_util::GetFileSize(temp_file_path(), &file_size); |
550 EXPECT_TRUE(ok); | 436 EXPECT_TRUE(ok); |
551 EXPECT_EQ(file_size, total_bytes_written); | 437 EXPECT_EQ(file_size, total_bytes_written); |
552 } | 438 } |
553 | 439 |
554 TEST_F(FileStreamTest, AsyncWrite_EarlyClose) { | 440 TEST_F(FileStreamTest, AsyncWrite_EarlyDelete) { |
555 FileStream stream(NULL); | 441 scoped_ptr<FileStream> stream(new FileStream(NULL)); |
556 int flags = base::PLATFORM_FILE_CREATE_ALWAYS | | 442 int flags = base::PLATFORM_FILE_CREATE_ALWAYS | |
557 base::PLATFORM_FILE_WRITE | | 443 base::PLATFORM_FILE_WRITE | |
558 base::PLATFORM_FILE_ASYNC; | 444 base::PLATFORM_FILE_ASYNC; |
559 int rv = stream.OpenSync(temp_file_path(), flags); | 445 int rv = stream->OpenSync(temp_file_path(), flags); |
560 EXPECT_EQ(OK, rv); | 446 EXPECT_EQ(OK, rv); |
561 | 447 |
562 int64 file_size; | 448 int64 file_size; |
563 bool ok = file_util::GetFileSize(temp_file_path(), &file_size); | 449 bool ok = file_util::GetFileSize(temp_file_path(), &file_size); |
564 EXPECT_TRUE(ok); | 450 EXPECT_TRUE(ok); |
565 EXPECT_EQ(0, file_size); | 451 EXPECT_EQ(0, file_size); |
566 | 452 |
567 TestCompletionCallback callback; | 453 TestCompletionCallback callback; |
568 | 454 |
569 scoped_refptr<IOBufferWithSize> buf = CreateTestDataBuffer(); | 455 scoped_refptr<IOBufferWithSize> buf = CreateTestDataBuffer(); |
570 rv = stream.Write(buf, buf->size(), callback.callback()); | 456 rv = stream->Write(buf, buf->size(), callback.callback()); |
571 stream.CloseSync(); | 457 stream.reset(); |
572 if (rv < 0) { | 458 if (rv < 0) { |
573 EXPECT_EQ(ERR_IO_PENDING, rv); | 459 EXPECT_EQ(ERR_IO_PENDING, rv); |
574 // The callback should not be called if the request is cancelled. | 460 // The callback should not be called if the request is cancelled. |
575 MessageLoop::current()->RunAllPending(); | 461 MessageLoop::current()->RunAllPending(); |
576 EXPECT_FALSE(callback.have_result()); | 462 EXPECT_FALSE(callback.have_result()); |
577 } else { | 463 } else { |
578 ok = file_util::GetFileSize(temp_file_path(), &file_size); | 464 ok = file_util::GetFileSize(temp_file_path(), &file_size); |
579 EXPECT_TRUE(ok); | 465 EXPECT_TRUE(ok); |
580 EXPECT_EQ(file_size, rv); | 466 EXPECT_EQ(file_size, rv); |
581 } | 467 } |
582 } | 468 } |
583 | 469 |
584 TEST_F(FileStreamTest, BasicWrite_FromOffset) { | 470 TEST_F(FileStreamTest, BasicWrite_FromOffset) { |
585 FileStream stream(NULL); | 471 scoped_ptr<FileStream> stream(new FileStream(NULL)); |
586 int flags = base::PLATFORM_FILE_OPEN | | 472 int flags = base::PLATFORM_FILE_OPEN | |
587 base::PLATFORM_FILE_WRITE; | 473 base::PLATFORM_FILE_WRITE; |
588 int rv = stream.OpenSync(temp_file_path(), flags); | 474 int rv = stream->OpenSync(temp_file_path(), flags); |
589 EXPECT_EQ(OK, rv); | 475 EXPECT_EQ(OK, rv); |
590 | 476 |
591 int64 file_size; | 477 int64 file_size; |
592 bool ok = file_util::GetFileSize(temp_file_path(), &file_size); | 478 bool ok = file_util::GetFileSize(temp_file_path(), &file_size); |
593 EXPECT_TRUE(ok); | 479 EXPECT_TRUE(ok); |
594 EXPECT_EQ(kTestDataSize, file_size); | 480 EXPECT_EQ(kTestDataSize, file_size); |
595 | 481 |
596 const int64 kOffset = 0; | 482 const int64 kOffset = 0; |
597 int64 new_offset = stream.SeekSync(FROM_END, kOffset); | 483 int64 new_offset = stream->SeekSync(FROM_END, kOffset); |
598 EXPECT_EQ(kTestDataSize, new_offset); | 484 EXPECT_EQ(kTestDataSize, new_offset); |
599 | 485 |
600 rv = stream.WriteSync(kTestData, kTestDataSize); | 486 rv = stream->WriteSync(kTestData, kTestDataSize); |
601 EXPECT_EQ(kTestDataSize, rv); | 487 EXPECT_EQ(kTestDataSize, rv); |
602 stream.CloseSync(); | 488 stream.reset(); |
603 | 489 |
604 ok = file_util::GetFileSize(temp_file_path(), &file_size); | 490 ok = file_util::GetFileSize(temp_file_path(), &file_size); |
605 EXPECT_TRUE(ok); | 491 EXPECT_TRUE(ok); |
606 EXPECT_EQ(kTestDataSize * 2, file_size); | 492 EXPECT_EQ(kTestDataSize * 2, file_size); |
607 } | 493 } |
608 | 494 |
609 TEST_F(FileStreamTest, AsyncWrite_FromOffset) { | 495 TEST_F(FileStreamTest, AsyncWrite_FromOffset) { |
610 int64 file_size; | 496 int64 file_size; |
611 bool ok = file_util::GetFileSize(temp_file_path(), &file_size); | 497 bool ok = file_util::GetFileSize(temp_file_path(), &file_size); |
612 EXPECT_TRUE(ok); | 498 EXPECT_TRUE(ok); |
(...skipping 32 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
645 ok = file_util::GetFileSize(temp_file_path(), &file_size); | 531 ok = file_util::GetFileSize(temp_file_path(), &file_size); |
646 EXPECT_TRUE(ok); | 532 EXPECT_TRUE(ok); |
647 EXPECT_EQ(file_size, kTestDataSize * 2); | 533 EXPECT_EQ(file_size, kTestDataSize * 2); |
648 } | 534 } |
649 | 535 |
650 TEST_F(FileStreamTest, BasicReadWrite) { | 536 TEST_F(FileStreamTest, BasicReadWrite) { |
651 int64 file_size; | 537 int64 file_size; |
652 bool ok = file_util::GetFileSize(temp_file_path(), &file_size); | 538 bool ok = file_util::GetFileSize(temp_file_path(), &file_size); |
653 EXPECT_TRUE(ok); | 539 EXPECT_TRUE(ok); |
654 | 540 |
655 FileStream stream(NULL); | 541 scoped_ptr<FileStream> stream(new FileStream(NULL)); |
656 int flags = base::PLATFORM_FILE_OPEN | | 542 int flags = base::PLATFORM_FILE_OPEN | |
657 base::PLATFORM_FILE_READ | | 543 base::PLATFORM_FILE_READ | |
658 base::PLATFORM_FILE_WRITE; | 544 base::PLATFORM_FILE_WRITE; |
659 int rv = stream.OpenSync(temp_file_path(), flags); | 545 int rv = stream->OpenSync(temp_file_path(), flags); |
660 EXPECT_EQ(OK, rv); | 546 EXPECT_EQ(OK, rv); |
661 | 547 |
662 int64 total_bytes_avail = stream.Available(); | 548 int64 total_bytes_avail = stream->Available(); |
663 EXPECT_EQ(file_size, total_bytes_avail); | 549 EXPECT_EQ(file_size, total_bytes_avail); |
664 | 550 |
665 int total_bytes_read = 0; | 551 int total_bytes_read = 0; |
666 | 552 |
667 std::string data_read; | 553 std::string data_read; |
668 for (;;) { | 554 for (;;) { |
669 char buf[4]; | 555 char buf[4]; |
670 rv = stream.ReadSync(buf, arraysize(buf)); | 556 rv = stream->ReadSync(buf, arraysize(buf)); |
671 EXPECT_LE(0, rv); | 557 EXPECT_LE(0, rv); |
672 if (rv <= 0) | 558 if (rv <= 0) |
673 break; | 559 break; |
674 total_bytes_read += rv; | 560 total_bytes_read += rv; |
675 data_read.append(buf, rv); | 561 data_read.append(buf, rv); |
676 } | 562 } |
677 EXPECT_EQ(file_size, total_bytes_read); | 563 EXPECT_EQ(file_size, total_bytes_read); |
678 EXPECT_TRUE(data_read == kTestData); | 564 EXPECT_TRUE(data_read == kTestData); |
679 | 565 |
680 rv = stream.WriteSync(kTestData, kTestDataSize); | 566 rv = stream->WriteSync(kTestData, kTestDataSize); |
681 EXPECT_EQ(kTestDataSize, rv); | 567 EXPECT_EQ(kTestDataSize, rv); |
682 stream.CloseSync(); | 568 stream.reset(); |
683 | 569 |
684 ok = file_util::GetFileSize(temp_file_path(), &file_size); | 570 ok = file_util::GetFileSize(temp_file_path(), &file_size); |
685 EXPECT_TRUE(ok); | 571 EXPECT_TRUE(ok); |
686 EXPECT_EQ(kTestDataSize * 2, file_size); | 572 EXPECT_EQ(kTestDataSize * 2, file_size); |
687 } | 573 } |
688 | 574 |
689 TEST_F(FileStreamTest, BasicWriteRead) { | 575 TEST_F(FileStreamTest, BasicWriteRead) { |
690 int64 file_size; | 576 int64 file_size; |
691 bool ok = file_util::GetFileSize(temp_file_path(), &file_size); | 577 bool ok = file_util::GetFileSize(temp_file_path(), &file_size); |
692 EXPECT_TRUE(ok); | 578 EXPECT_TRUE(ok); |
693 | 579 |
694 FileStream stream(NULL); | 580 scoped_ptr<FileStream> stream(new FileStream(NULL)); |
695 int flags = base::PLATFORM_FILE_OPEN | | 581 int flags = base::PLATFORM_FILE_OPEN | |
696 base::PLATFORM_FILE_READ | | 582 base::PLATFORM_FILE_READ | |
697 base::PLATFORM_FILE_WRITE; | 583 base::PLATFORM_FILE_WRITE; |
698 int rv = stream.OpenSync(temp_file_path(), flags); | 584 int rv = stream->OpenSync(temp_file_path(), flags); |
699 EXPECT_EQ(OK, rv); | 585 EXPECT_EQ(OK, rv); |
700 | 586 |
701 int64 total_bytes_avail = stream.Available(); | 587 int64 total_bytes_avail = stream->Available(); |
702 EXPECT_EQ(file_size, total_bytes_avail); | 588 EXPECT_EQ(file_size, total_bytes_avail); |
703 | 589 |
704 int64 offset = stream.SeekSync(FROM_END, 0); | 590 int64 offset = stream->SeekSync(FROM_END, 0); |
705 EXPECT_EQ(offset, file_size); | 591 EXPECT_EQ(offset, file_size); |
706 | 592 |
707 rv = stream.WriteSync(kTestData, kTestDataSize); | 593 rv = stream->WriteSync(kTestData, kTestDataSize); |
708 EXPECT_EQ(kTestDataSize, rv); | 594 EXPECT_EQ(kTestDataSize, rv); |
709 | 595 |
710 offset = stream.SeekSync(FROM_BEGIN, 0); | 596 offset = stream->SeekSync(FROM_BEGIN, 0); |
711 EXPECT_EQ(0, offset); | 597 EXPECT_EQ(0, offset); |
712 | 598 |
713 int64 total_bytes_read = 0; | 599 int64 total_bytes_read = 0; |
714 | 600 |
715 std::string data_read; | 601 std::string data_read; |
716 for (;;) { | 602 for (;;) { |
717 char buf[4]; | 603 char buf[4]; |
718 rv = stream.ReadSync(buf, arraysize(buf)); | 604 rv = stream->ReadSync(buf, arraysize(buf)); |
719 EXPECT_LE(0, rv); | 605 EXPECT_LE(0, rv); |
720 if (rv <= 0) | 606 if (rv <= 0) |
721 break; | 607 break; |
722 total_bytes_read += rv; | 608 total_bytes_read += rv; |
723 data_read.append(buf, rv); | 609 data_read.append(buf, rv); |
724 } | 610 } |
725 stream.CloseSync(); | 611 stream.reset(); |
726 | 612 |
727 ok = file_util::GetFileSize(temp_file_path(), &file_size); | 613 ok = file_util::GetFileSize(temp_file_path(), &file_size); |
728 EXPECT_TRUE(ok); | 614 EXPECT_TRUE(ok); |
729 EXPECT_EQ(kTestDataSize * 2, file_size); | 615 EXPECT_EQ(kTestDataSize * 2, file_size); |
730 EXPECT_EQ(kTestDataSize * 2, total_bytes_read); | 616 EXPECT_EQ(kTestDataSize * 2, total_bytes_read); |
731 | 617 |
732 const std::string kExpectedFileData = | 618 const std::string kExpectedFileData = |
733 std::string(kTestData) + std::string(kTestData); | 619 std::string(kTestData) + std::string(kTestData); |
734 EXPECT_EQ(kExpectedFileData, data_read); | 620 EXPECT_EQ(kExpectedFileData, data_read); |
735 } | 621 } |
736 | 622 |
737 TEST_F(FileStreamTest, BasicAsyncReadWrite) { | 623 TEST_F(FileStreamTest, BasicAsyncReadWrite) { |
738 int64 file_size; | 624 int64 file_size; |
739 bool ok = file_util::GetFileSize(temp_file_path(), &file_size); | 625 bool ok = file_util::GetFileSize(temp_file_path(), &file_size); |
740 EXPECT_TRUE(ok); | 626 EXPECT_TRUE(ok); |
741 | 627 |
742 FileStream stream(NULL); | 628 scoped_ptr<FileStream> stream(new FileStream(NULL)); |
743 int flags = base::PLATFORM_FILE_OPEN | | 629 int flags = base::PLATFORM_FILE_OPEN | |
744 base::PLATFORM_FILE_READ | | 630 base::PLATFORM_FILE_READ | |
745 base::PLATFORM_FILE_WRITE | | 631 base::PLATFORM_FILE_WRITE | |
746 base::PLATFORM_FILE_ASYNC; | 632 base::PLATFORM_FILE_ASYNC; |
747 int rv = stream.OpenSync(temp_file_path(), flags); | 633 int rv = stream->OpenSync(temp_file_path(), flags); |
748 EXPECT_EQ(OK, rv); | 634 EXPECT_EQ(OK, rv); |
749 | 635 |
750 int64 total_bytes_avail = stream.Available(); | 636 int64 total_bytes_avail = stream->Available(); |
751 EXPECT_EQ(file_size, total_bytes_avail); | 637 EXPECT_EQ(file_size, total_bytes_avail); |
752 | 638 |
753 TestCompletionCallback callback; | 639 TestCompletionCallback callback; |
754 int64 total_bytes_read = 0; | 640 int64 total_bytes_read = 0; |
755 | 641 |
756 std::string data_read; | 642 std::string data_read; |
757 for (;;) { | 643 for (;;) { |
758 scoped_refptr<IOBufferWithSize> buf = new IOBufferWithSize(4); | 644 scoped_refptr<IOBufferWithSize> buf = new IOBufferWithSize(4); |
759 rv = stream.Read(buf, buf->size(), callback.callback()); | 645 rv = stream->Read(buf, buf->size(), callback.callback()); |
760 if (rv == ERR_IO_PENDING) | 646 if (rv == ERR_IO_PENDING) |
761 rv = callback.WaitForResult(); | 647 rv = callback.WaitForResult(); |
762 EXPECT_LE(0, rv); | 648 EXPECT_LE(0, rv); |
763 if (rv <= 0) | 649 if (rv <= 0) |
764 break; | 650 break; |
765 total_bytes_read += rv; | 651 total_bytes_read += rv; |
766 data_read.append(buf->data(), rv); | 652 data_read.append(buf->data(), rv); |
767 } | 653 } |
768 EXPECT_EQ(file_size, total_bytes_read); | 654 EXPECT_EQ(file_size, total_bytes_read); |
769 EXPECT_TRUE(data_read == kTestData); | 655 EXPECT_TRUE(data_read == kTestData); |
770 | 656 |
771 int total_bytes_written = 0; | 657 int total_bytes_written = 0; |
772 | 658 |
773 scoped_refptr<IOBufferWithSize> buf = CreateTestDataBuffer(); | 659 scoped_refptr<IOBufferWithSize> buf = CreateTestDataBuffer(); |
774 scoped_refptr<DrainableIOBuffer> drainable = | 660 scoped_refptr<DrainableIOBuffer> drainable = |
775 new DrainableIOBuffer(buf, buf->size()); | 661 new DrainableIOBuffer(buf, buf->size()); |
776 while (total_bytes_written != kTestDataSize) { | 662 while (total_bytes_written != kTestDataSize) { |
777 rv = stream.Write(drainable, drainable->BytesRemaining(), | 663 rv = stream->Write(drainable, drainable->BytesRemaining(), |
778 callback.callback()); | 664 callback.callback()); |
779 if (rv == ERR_IO_PENDING) | 665 if (rv == ERR_IO_PENDING) |
780 rv = callback.WaitForResult(); | 666 rv = callback.WaitForResult(); |
781 EXPECT_LT(0, rv); | 667 EXPECT_LT(0, rv); |
782 if (rv <= 0) | 668 if (rv <= 0) |
783 break; | 669 break; |
784 drainable->DidConsume(rv); | 670 drainable->DidConsume(rv); |
785 total_bytes_written += rv; | 671 total_bytes_written += rv; |
786 } | 672 } |
787 | 673 |
788 stream.CloseSync(); | 674 stream.reset(); |
789 | 675 |
790 ok = file_util::GetFileSize(temp_file_path(), &file_size); | 676 ok = file_util::GetFileSize(temp_file_path(), &file_size); |
791 EXPECT_TRUE(ok); | 677 EXPECT_TRUE(ok); |
792 EXPECT_EQ(kTestDataSize * 2, file_size); | 678 EXPECT_EQ(kTestDataSize * 2, file_size); |
793 } | 679 } |
794 | 680 |
795 TEST_F(FileStreamTest, BasicAsyncWriteRead) { | 681 TEST_F(FileStreamTest, BasicAsyncWriteRead) { |
796 int64 file_size; | 682 int64 file_size; |
797 bool ok = file_util::GetFileSize(temp_file_path(), &file_size); | 683 bool ok = file_util::GetFileSize(temp_file_path(), &file_size); |
798 EXPECT_TRUE(ok); | 684 EXPECT_TRUE(ok); |
799 | 685 |
800 FileStream stream(NULL); | 686 scoped_ptr<FileStream> stream(new FileStream(NULL)); |
801 int flags = base::PLATFORM_FILE_OPEN | | 687 int flags = base::PLATFORM_FILE_OPEN | |
802 base::PLATFORM_FILE_READ | | 688 base::PLATFORM_FILE_READ | |
803 base::PLATFORM_FILE_WRITE | | 689 base::PLATFORM_FILE_WRITE | |
804 base::PLATFORM_FILE_ASYNC; | 690 base::PLATFORM_FILE_ASYNC; |
805 int rv = stream.OpenSync(temp_file_path(), flags); | 691 int rv = stream->OpenSync(temp_file_path(), flags); |
806 EXPECT_EQ(OK, rv); | 692 EXPECT_EQ(OK, rv); |
807 | 693 |
808 int64 total_bytes_avail = stream.Available(); | 694 int64 total_bytes_avail = stream->Available(); |
809 EXPECT_EQ(file_size, total_bytes_avail); | 695 EXPECT_EQ(file_size, total_bytes_avail); |
810 | 696 |
811 TestInt64CompletionCallback callback64; | 697 TestInt64CompletionCallback callback64; |
812 rv = stream.Seek(FROM_END, 0, callback64.callback()); | 698 rv = stream->Seek(FROM_END, 0, callback64.callback()); |
813 ASSERT_EQ(ERR_IO_PENDING, rv); | 699 ASSERT_EQ(ERR_IO_PENDING, rv); |
814 int64 offset = callback64.WaitForResult(); | 700 int64 offset = callback64.WaitForResult(); |
815 EXPECT_EQ(offset, file_size); | 701 EXPECT_EQ(offset, file_size); |
816 | 702 |
817 TestCompletionCallback callback; | 703 TestCompletionCallback callback; |
818 int total_bytes_written = 0; | 704 int total_bytes_written = 0; |
819 | 705 |
820 scoped_refptr<IOBufferWithSize> buf = CreateTestDataBuffer(); | 706 scoped_refptr<IOBufferWithSize> buf = CreateTestDataBuffer(); |
821 scoped_refptr<DrainableIOBuffer> drainable = | 707 scoped_refptr<DrainableIOBuffer> drainable = |
822 new DrainableIOBuffer(buf, buf->size()); | 708 new DrainableIOBuffer(buf, buf->size()); |
823 while (total_bytes_written != kTestDataSize) { | 709 while (total_bytes_written != kTestDataSize) { |
824 rv = stream.Write(drainable, drainable->BytesRemaining(), | 710 rv = stream->Write(drainable, drainable->BytesRemaining(), |
825 callback.callback()); | 711 callback.callback()); |
826 if (rv == ERR_IO_PENDING) | 712 if (rv == ERR_IO_PENDING) |
827 rv = callback.WaitForResult(); | 713 rv = callback.WaitForResult(); |
828 EXPECT_LT(0, rv); | 714 EXPECT_LT(0, rv); |
829 if (rv <= 0) | 715 if (rv <= 0) |
830 break; | 716 break; |
831 drainable->DidConsume(rv); | 717 drainable->DidConsume(rv); |
832 total_bytes_written += rv; | 718 total_bytes_written += rv; |
833 } | 719 } |
834 | 720 |
835 EXPECT_EQ(kTestDataSize, total_bytes_written); | 721 EXPECT_EQ(kTestDataSize, total_bytes_written); |
836 | 722 |
837 rv = stream.Seek(FROM_BEGIN, 0, callback64.callback()); | 723 rv = stream->Seek(FROM_BEGIN, 0, callback64.callback()); |
838 ASSERT_EQ(ERR_IO_PENDING, rv); | 724 ASSERT_EQ(ERR_IO_PENDING, rv); |
839 offset = callback64.WaitForResult(); | 725 offset = callback64.WaitForResult(); |
840 EXPECT_EQ(0, offset); | 726 EXPECT_EQ(0, offset); |
841 | 727 |
842 int total_bytes_read = 0; | 728 int total_bytes_read = 0; |
843 | 729 |
844 std::string data_read; | 730 std::string data_read; |
845 for (;;) { | 731 for (;;) { |
846 scoped_refptr<IOBufferWithSize> buf = new IOBufferWithSize(4); | 732 scoped_refptr<IOBufferWithSize> buf = new IOBufferWithSize(4); |
847 rv = stream.Read(buf, buf->size(), callback.callback()); | 733 rv = stream->Read(buf, buf->size(), callback.callback()); |
848 if (rv == ERR_IO_PENDING) | 734 if (rv == ERR_IO_PENDING) |
849 rv = callback.WaitForResult(); | 735 rv = callback.WaitForResult(); |
850 EXPECT_LE(0, rv); | 736 EXPECT_LE(0, rv); |
851 if (rv <= 0) | 737 if (rv <= 0) |
852 break; | 738 break; |
853 total_bytes_read += rv; | 739 total_bytes_read += rv; |
854 data_read.append(buf->data(), rv); | 740 data_read.append(buf->data(), rv); |
855 } | 741 } |
856 stream.CloseSync(); | 742 stream.reset(); |
857 | 743 |
858 ok = file_util::GetFileSize(temp_file_path(), &file_size); | 744 ok = file_util::GetFileSize(temp_file_path(), &file_size); |
859 EXPECT_TRUE(ok); | 745 EXPECT_TRUE(ok); |
860 EXPECT_EQ(kTestDataSize * 2, file_size); | 746 EXPECT_EQ(kTestDataSize * 2, file_size); |
861 | 747 |
862 EXPECT_EQ(kTestDataSize * 2, total_bytes_read); | 748 EXPECT_EQ(kTestDataSize * 2, total_bytes_read); |
863 const std::string kExpectedFileData = | 749 const std::string kExpectedFileData = |
864 std::string(kTestData) + std::string(kTestData); | 750 std::string(kTestData) + std::string(kTestData); |
865 EXPECT_EQ(kExpectedFileData, data_read); | 751 EXPECT_EQ(kExpectedFileData, data_read); |
866 } | 752 } |
(...skipping 89 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
956 scoped_refptr<DrainableIOBuffer> drainable_; | 842 scoped_refptr<DrainableIOBuffer> drainable_; |
957 | 843 |
958 DISALLOW_COPY_AND_ASSIGN(TestWriteReadCompletionCallback); | 844 DISALLOW_COPY_AND_ASSIGN(TestWriteReadCompletionCallback); |
959 }; | 845 }; |
960 | 846 |
961 TEST_F(FileStreamTest, AsyncWriteRead) { | 847 TEST_F(FileStreamTest, AsyncWriteRead) { |
962 int64 file_size; | 848 int64 file_size; |
963 bool ok = file_util::GetFileSize(temp_file_path(), &file_size); | 849 bool ok = file_util::GetFileSize(temp_file_path(), &file_size); |
964 EXPECT_TRUE(ok); | 850 EXPECT_TRUE(ok); |
965 | 851 |
966 FileStream stream(NULL); | 852 scoped_ptr<FileStream> stream(new FileStream(NULL)); |
967 int flags = base::PLATFORM_FILE_OPEN | | 853 int flags = base::PLATFORM_FILE_OPEN | |
968 base::PLATFORM_FILE_READ | | 854 base::PLATFORM_FILE_READ | |
969 base::PLATFORM_FILE_WRITE | | 855 base::PLATFORM_FILE_WRITE | |
970 base::PLATFORM_FILE_ASYNC; | 856 base::PLATFORM_FILE_ASYNC; |
971 int rv = stream.OpenSync(temp_file_path(), flags); | 857 int rv = stream->OpenSync(temp_file_path(), flags); |
972 EXPECT_EQ(OK, rv); | 858 EXPECT_EQ(OK, rv); |
973 | 859 |
974 int64 total_bytes_avail = stream.Available(); | 860 int64 total_bytes_avail = stream->Available(); |
975 EXPECT_EQ(file_size, total_bytes_avail); | 861 EXPECT_EQ(file_size, total_bytes_avail); |
976 | 862 |
977 int64 offset = stream.SeekSync(FROM_END, 0); | 863 int64 offset = stream->SeekSync(FROM_END, 0); |
978 EXPECT_EQ(offset, file_size); | 864 EXPECT_EQ(offset, file_size); |
979 | 865 |
980 int total_bytes_written = 0; | 866 int total_bytes_written = 0; |
981 int total_bytes_read = 0; | 867 int total_bytes_read = 0; |
982 std::string data_read; | 868 std::string data_read; |
983 TestWriteReadCompletionCallback callback(&stream, &total_bytes_written, | 869 TestWriteReadCompletionCallback callback(stream.get(), &total_bytes_written, |
984 &total_bytes_read, &data_read); | 870 &total_bytes_read, &data_read); |
985 | 871 |
986 scoped_refptr<IOBufferWithSize> buf = CreateTestDataBuffer(); | 872 scoped_refptr<IOBufferWithSize> buf = CreateTestDataBuffer(); |
987 rv = stream.Write(buf, buf->size(), callback.callback()); | 873 rv = stream->Write(buf, buf->size(), callback.callback()); |
988 if (rv == ERR_IO_PENDING) | 874 if (rv == ERR_IO_PENDING) |
989 rv = callback.WaitForResult(); | 875 rv = callback.WaitForResult(); |
990 EXPECT_LT(0, rv); | 876 EXPECT_LT(0, rv); |
991 EXPECT_EQ(kTestDataSize, total_bytes_written); | 877 EXPECT_EQ(kTestDataSize, total_bytes_written); |
992 | 878 |
993 stream.CloseSync(); | 879 stream.reset(); |
994 | 880 |
995 ok = file_util::GetFileSize(temp_file_path(), &file_size); | 881 ok = file_util::GetFileSize(temp_file_path(), &file_size); |
996 EXPECT_TRUE(ok); | 882 EXPECT_TRUE(ok); |
997 EXPECT_EQ(kTestDataSize * 2, file_size); | 883 EXPECT_EQ(kTestDataSize * 2, file_size); |
998 | 884 |
999 EXPECT_EQ(kTestDataSize * 2, total_bytes_read); | 885 EXPECT_EQ(kTestDataSize * 2, total_bytes_read); |
1000 const std::string kExpectedFileData = | 886 const std::string kExpectedFileData = |
1001 std::string(kTestData) + std::string(kTestData); | 887 std::string(kTestData) + std::string(kTestData); |
1002 EXPECT_EQ(kExpectedFileData, data_read); | 888 EXPECT_EQ(kExpectedFileData, data_read); |
1003 } | 889 } |
(...skipping 35 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1039 if (*total_bytes_written_ != kTestDataSize) { | 925 if (*total_bytes_written_ != kTestDataSize) { |
1040 // Recurse to finish writing all data. | 926 // Recurse to finish writing all data. |
1041 int total_bytes_written = 0; | 927 int total_bytes_written = 0; |
1042 TestWriteCloseCompletionCallback callback(stream_, &total_bytes_written); | 928 TestWriteCloseCompletionCallback callback(stream_, &total_bytes_written); |
1043 rv = stream_->Write(drainable_, drainable_->BytesRemaining(), | 929 rv = stream_->Write(drainable_, drainable_->BytesRemaining(), |
1044 callback.callback()); | 930 callback.callback()); |
1045 DCHECK_EQ(ERR_IO_PENDING, rv); | 931 DCHECK_EQ(ERR_IO_PENDING, rv); |
1046 rv = callback.WaitForResult(); | 932 rv = callback.WaitForResult(); |
1047 drainable_->DidConsume(total_bytes_written); | 933 drainable_->DidConsume(total_bytes_written); |
1048 *total_bytes_written_ += total_bytes_written; | 934 *total_bytes_written_ += total_bytes_written; |
1049 } else { // We're done writing all data. Close the file. | |
1050 stream_->CloseSync(); | |
1051 } | 935 } |
1052 | 936 |
1053 result_ = *total_bytes_written_; | 937 result_ = *total_bytes_written_; |
1054 have_result_ = true; | 938 have_result_ = true; |
1055 if (waiting_for_result_) | 939 if (waiting_for_result_) |
1056 MessageLoop::current()->Quit(); | 940 MessageLoop::current()->Quit(); |
1057 } | 941 } |
1058 | 942 |
1059 int result_; | 943 int result_; |
1060 bool have_result_; | 944 bool have_result_; |
1061 bool waiting_for_result_; | 945 bool waiting_for_result_; |
1062 FileStream* stream_; | 946 FileStream* stream_; |
1063 int* total_bytes_written_; | 947 int* total_bytes_written_; |
1064 const CompletionCallback callback_; | 948 const CompletionCallback callback_; |
1065 scoped_refptr<IOBufferWithSize> test_data_; | 949 scoped_refptr<IOBufferWithSize> test_data_; |
1066 scoped_refptr<DrainableIOBuffer> drainable_; | 950 scoped_refptr<DrainableIOBuffer> drainable_; |
1067 | 951 |
1068 DISALLOW_COPY_AND_ASSIGN(TestWriteCloseCompletionCallback); | 952 DISALLOW_COPY_AND_ASSIGN(TestWriteCloseCompletionCallback); |
1069 }; | 953 }; |
1070 | 954 |
1071 TEST_F(FileStreamTest, AsyncWriteClose) { | 955 TEST_F(FileStreamTest, AsyncWriteClose) { |
1072 int64 file_size; | 956 int64 file_size; |
1073 bool ok = file_util::GetFileSize(temp_file_path(), &file_size); | 957 bool ok = file_util::GetFileSize(temp_file_path(), &file_size); |
1074 EXPECT_TRUE(ok); | 958 EXPECT_TRUE(ok); |
1075 | 959 |
1076 FileStream stream(NULL); | 960 scoped_ptr<FileStream> stream(new FileStream(NULL)); |
1077 int flags = base::PLATFORM_FILE_OPEN | | 961 int flags = base::PLATFORM_FILE_OPEN | |
1078 base::PLATFORM_FILE_READ | | 962 base::PLATFORM_FILE_READ | |
1079 base::PLATFORM_FILE_WRITE | | 963 base::PLATFORM_FILE_WRITE | |
1080 base::PLATFORM_FILE_ASYNC; | 964 base::PLATFORM_FILE_ASYNC; |
1081 int rv = stream.OpenSync(temp_file_path(), flags); | 965 int rv = stream->OpenSync(temp_file_path(), flags); |
1082 EXPECT_EQ(OK, rv); | 966 EXPECT_EQ(OK, rv); |
1083 | 967 |
1084 int64 total_bytes_avail = stream.Available(); | 968 int64 total_bytes_avail = stream->Available(); |
1085 EXPECT_EQ(file_size, total_bytes_avail); | 969 EXPECT_EQ(file_size, total_bytes_avail); |
1086 | 970 |
1087 int64 offset = stream.SeekSync(FROM_END, 0); | 971 int64 offset = stream->SeekSync(FROM_END, 0); |
1088 EXPECT_EQ(offset, file_size); | 972 EXPECT_EQ(offset, file_size); |
1089 | 973 |
1090 int total_bytes_written = 0; | 974 int total_bytes_written = 0; |
1091 TestWriteCloseCompletionCallback callback(&stream, &total_bytes_written); | 975 TestWriteCloseCompletionCallback callback(stream.get(), &total_bytes_written); |
1092 | 976 |
1093 scoped_refptr<IOBufferWithSize> buf = CreateTestDataBuffer(); | 977 scoped_refptr<IOBufferWithSize> buf = CreateTestDataBuffer(); |
1094 rv = stream.Write(buf, buf->size(), callback.callback()); | 978 rv = stream->Write(buf, buf->size(), callback.callback()); |
1095 if (rv == ERR_IO_PENDING) | 979 if (rv == ERR_IO_PENDING) |
1096 total_bytes_written = callback.WaitForResult(); | 980 total_bytes_written = callback.WaitForResult(); |
1097 EXPECT_LT(0, total_bytes_written); | 981 EXPECT_LT(0, total_bytes_written); |
1098 EXPECT_EQ(kTestDataSize, total_bytes_written); | 982 EXPECT_EQ(kTestDataSize, total_bytes_written); |
1099 | 983 |
| 984 stream.reset(); |
| 985 |
1100 ok = file_util::GetFileSize(temp_file_path(), &file_size); | 986 ok = file_util::GetFileSize(temp_file_path(), &file_size); |
1101 EXPECT_TRUE(ok); | 987 EXPECT_TRUE(ok); |
1102 EXPECT_EQ(kTestDataSize * 2, file_size); | 988 EXPECT_EQ(kTestDataSize * 2, file_size); |
1103 } | 989 } |
1104 | 990 |
1105 // Tests truncating a file. | 991 // Tests truncating a file. |
1106 TEST_F(FileStreamTest, Truncate) { | 992 TEST_F(FileStreamTest, Truncate) { |
1107 int flags = base::PLATFORM_FILE_CREATE_ALWAYS | base::PLATFORM_FILE_WRITE; | 993 int flags = base::PLATFORM_FILE_CREATE_ALWAYS | base::PLATFORM_FILE_WRITE; |
1108 | 994 |
1109 FileStream write_stream(NULL); | 995 scoped_ptr<FileStream> write_stream(new FileStream(NULL)); |
1110 ASSERT_EQ(OK, write_stream.OpenSync(temp_file_path(), flags)); | 996 ASSERT_EQ(OK, write_stream->OpenSync(temp_file_path(), flags)); |
1111 | 997 |
1112 // Write some data to the file. | 998 // Write some data to the file. |
1113 const char test_data[] = "0123456789"; | 999 const char test_data[] = "0123456789"; |
1114 write_stream.WriteSync(test_data, arraysize(test_data)); | 1000 write_stream->WriteSync(test_data, arraysize(test_data)); |
1115 | 1001 |
1116 // Truncate the file. | 1002 // Truncate the file. |
1117 ASSERT_EQ(4, write_stream.Truncate(4)); | 1003 ASSERT_EQ(4, write_stream->Truncate(4)); |
1118 | 1004 |
1119 // Write again. | 1005 // Write again. |
1120 write_stream.WriteSync(test_data, 4); | 1006 write_stream->WriteSync(test_data, 4); |
1121 | 1007 |
1122 // Close the stream. | 1008 // Close the stream. |
1123 write_stream.CloseSync(); | 1009 write_stream.reset(); |
1124 | 1010 |
1125 // Read in the contents and make sure we get back what we expected. | 1011 // Read in the contents and make sure we get back what we expected. |
1126 std::string read_contents; | 1012 std::string read_contents; |
1127 EXPECT_TRUE(file_util::ReadFileToString(temp_file_path(), &read_contents)); | 1013 EXPECT_TRUE(file_util::ReadFileToString(temp_file_path(), &read_contents)); |
1128 | 1014 |
1129 EXPECT_EQ("01230123", read_contents); | 1015 EXPECT_EQ("01230123", read_contents); |
1130 } | 1016 } |
1131 | 1017 |
1132 TEST_F(FileStreamTest, AsyncBasicOpenClose) { | |
1133 FileStream stream(NULL); | |
1134 int flags = base::PLATFORM_FILE_OPEN | | |
1135 base::PLATFORM_FILE_READ | | |
1136 base::PLATFORM_FILE_ASYNC; | |
1137 TestCompletionCallback callback; | |
1138 int rv = stream.Open(temp_file_path(), flags, callback.callback()); | |
1139 EXPECT_EQ(ERR_IO_PENDING, rv); | |
1140 EXPECT_EQ(OK, callback.WaitForResult()); | |
1141 EXPECT_TRUE(stream.IsOpen()); | |
1142 | |
1143 stream.Close(callback.callback()); | |
1144 EXPECT_EQ(OK, callback.WaitForResult()); | |
1145 EXPECT_FALSE(stream.IsOpen()); | |
1146 } | |
1147 | |
1148 TEST_F(FileStreamTest, SyncCloseTwice) { | |
1149 FileStream stream(NULL); | |
1150 int flags = base::PLATFORM_FILE_OPEN | | |
1151 base::PLATFORM_FILE_READ; | |
1152 int rv = stream.OpenSync(temp_file_path(), flags); | |
1153 EXPECT_EQ(OK, rv); | |
1154 EXPECT_TRUE(stream.IsOpen()); | |
1155 | |
1156 // Closing twice should be safe. | |
1157 stream.CloseSync(); | |
1158 EXPECT_FALSE(stream.IsOpen()); | |
1159 | |
1160 stream.CloseSync(); | |
1161 EXPECT_FALSE(stream.IsOpen()); | |
1162 } | |
1163 | |
1164 TEST_F(FileStreamTest, AsyncCloseTwice) { | |
1165 FileStream stream(NULL); | |
1166 int flags = base::PLATFORM_FILE_OPEN | | |
1167 base::PLATFORM_FILE_READ | | |
1168 base::PLATFORM_FILE_ASYNC; | |
1169 TestCompletionCallback callback; | |
1170 int rv = stream.Open(temp_file_path(), flags, callback.callback()); | |
1171 EXPECT_EQ(ERR_IO_PENDING, rv); | |
1172 EXPECT_EQ(OK, callback.WaitForResult()); | |
1173 EXPECT_TRUE(stream.IsOpen()); | |
1174 | |
1175 // Closing twice should be safe. | |
1176 stream.Close(callback.callback()); | |
1177 EXPECT_EQ(OK, callback.WaitForResult()); | |
1178 EXPECT_FALSE(stream.IsOpen()); | |
1179 | |
1180 stream.Close(callback.callback()); | |
1181 EXPECT_EQ(OK, callback.WaitForResult()); | |
1182 EXPECT_FALSE(stream.IsOpen()); | |
1183 } | |
1184 | |
1185 // TODO(satorux): This should be gone once all once all async clients are | |
1186 // migrated to use Close(). crbug.com/114783 | |
1187 TEST_F(FileStreamTest, AsyncWriteAndCloseSync) { | |
1188 FileStream stream(NULL); | |
1189 int flags = base::PLATFORM_FILE_OPEN | | |
1190 base::PLATFORM_FILE_WRITE | | |
1191 base::PLATFORM_FILE_ASYNC; | |
1192 TestCompletionCallback callback; | |
1193 int rv = stream.Open(temp_file_path(), flags, callback.callback()); | |
1194 EXPECT_EQ(ERR_IO_PENDING, rv); | |
1195 EXPECT_EQ(OK, callback.WaitForResult()); | |
1196 EXPECT_TRUE(stream.IsOpen()); | |
1197 | |
1198 // Write some data asynchronously. | |
1199 scoped_refptr<IOBufferWithSize> buf = CreateTestDataBuffer(); | |
1200 stream.Write(buf, buf->size(), callback.callback()); | |
1201 | |
1202 // Close the stream without waiting for the completion. | |
1203 stream.CloseSync(); | |
1204 } | |
1205 | |
1206 // TODO(satorux): This should be gone once all once all async clients are | |
1207 // migrated to use Close(). crbug.com/114783 | |
1208 TEST_F(FileStreamTest, AsyncOpenAndCloseSync) { | |
1209 FileStream stream(NULL); | |
1210 int flags = base::PLATFORM_FILE_OPEN | | |
1211 base::PLATFORM_FILE_WRITE | | |
1212 base::PLATFORM_FILE_ASYNC; | |
1213 TestCompletionCallback open_callback; | |
1214 int rv = stream.Open(temp_file_path(), flags, open_callback.callback()); | |
1215 EXPECT_EQ(ERR_IO_PENDING, rv); | |
1216 | |
1217 // Close the stream without waiting for the completion. Should be safe. | |
1218 stream.CloseSync(); | |
1219 // open_callback won't be called. | |
1220 EXPECT_FALSE(open_callback.have_result()); | |
1221 } | |
1222 | |
1223 TEST_F(FileStreamTest, AsyncOpenAndDelete) { | 1018 TEST_F(FileStreamTest, AsyncOpenAndDelete) { |
1224 scoped_ptr<FileStream> stream(new FileStream(NULL)); | 1019 scoped_ptr<FileStream> stream(new FileStream(NULL)); |
1225 int flags = base::PLATFORM_FILE_OPEN | | 1020 int flags = base::PLATFORM_FILE_OPEN | |
1226 base::PLATFORM_FILE_WRITE | | 1021 base::PLATFORM_FILE_WRITE | |
1227 base::PLATFORM_FILE_ASYNC; | 1022 base::PLATFORM_FILE_ASYNC; |
1228 TestCompletionCallback open_callback; | 1023 TestCompletionCallback open_callback; |
1229 int rv = stream->Open(temp_file_path(), flags, open_callback.callback()); | 1024 int rv = stream->Open(temp_file_path(), flags, open_callback.callback()); |
1230 EXPECT_EQ(ERR_IO_PENDING, rv); | 1025 EXPECT_EQ(ERR_IO_PENDING, rv); |
1231 | 1026 |
1232 // Delete the stream without waiting for the open operation to be | 1027 // Delete the stream without waiting for the open operation to be |
1233 // complete. Should be safe. | 1028 // complete. Should be safe. |
1234 stream.reset(); | 1029 stream.reset(); |
1235 // open_callback won't be called. | 1030 // open_callback won't be called. |
| 1031 MessageLoop::current()->RunUntilIdle(); |
1236 EXPECT_FALSE(open_callback.have_result()); | 1032 EXPECT_FALSE(open_callback.have_result()); |
1237 } | 1033 } |
1238 | 1034 |
1239 TEST_F(FileStreamTest, AsyncCloseAndDelete) { | |
1240 scoped_ptr<FileStream> stream(new FileStream(NULL)); | |
1241 int flags = base::PLATFORM_FILE_OPEN | | |
1242 base::PLATFORM_FILE_WRITE | | |
1243 base::PLATFORM_FILE_ASYNC; | |
1244 TestCompletionCallback open_callback; | |
1245 int rv = stream->Open(temp_file_path(), flags, open_callback.callback()); | |
1246 EXPECT_EQ(ERR_IO_PENDING, rv); | |
1247 EXPECT_EQ(OK, open_callback.WaitForResult()); | |
1248 EXPECT_TRUE(stream->IsOpen()); | |
1249 | |
1250 TestCompletionCallback close_callback; | |
1251 stream->Close(close_callback.callback()); | |
1252 | |
1253 // Delete the stream without waiting for the close operation to be | |
1254 // complete. Should be safe. | |
1255 stream.reset(); | |
1256 // close_callback won't be called. | |
1257 EXPECT_FALSE(close_callback.have_result()); | |
1258 } | |
1259 | |
1260 } // namespace | 1035 } // namespace |
1261 | 1036 |
1262 } // namespace net | 1037 } // namespace net |
OLD | NEW |