| OLD | NEW |
| (Empty) |
| 1 // Copyright (c) 2008 The Chromium Authors. All rights reserved. Use of this | |
| 2 // source code is governed by a BSD-style license that can be found in the | |
| 3 // LICENSE file. | |
| 4 | |
| 5 #include "base/file_util.h" | |
| 6 #include "base/path_service.h" | |
| 7 #include "base/platform_test.h" | |
| 8 #include "net/base/file_input_stream.h" | |
| 9 #include "net/base/net_errors.h" | |
| 10 #include "net/base/test_completion_callback.h" | |
| 11 #include "testing/gtest/include/gtest/gtest.h" | |
| 12 | |
| 13 static const char kTestData[] = "0123456789"; | |
| 14 | |
| 15 class FileInputStreamTest : public PlatformTest { | |
| 16 public: | |
| 17 virtual void SetUp() { | |
| 18 PlatformTest::SetUp(); | |
| 19 | |
| 20 file_util::CreateTemporaryFileName(&temp_file_path_); | |
| 21 file_util::WriteFile(temp_file_path_, kTestData, arraysize(kTestData)-1); | |
| 22 } | |
| 23 virtual void TearDown() { | |
| 24 file_util::Delete(temp_file_path_, false); | |
| 25 | |
| 26 PlatformTest::TearDown(); | |
| 27 } | |
| 28 const std::wstring temp_file_path() const { return temp_file_path_; } | |
| 29 private: | |
| 30 std::wstring temp_file_path_; | |
| 31 }; | |
| 32 | |
| 33 TEST_F(FileInputStreamTest, BasicOpenClose) { | |
| 34 net::FileInputStream stream; | |
| 35 int rv = stream.Open(temp_file_path(), false); | |
| 36 EXPECT_EQ(net::OK, rv); | |
| 37 } | |
| 38 | |
| 39 TEST_F(FileInputStreamTest, UseClosedStream) { | |
| 40 net::FileInputStream stream; | |
| 41 | |
| 42 EXPECT_FALSE(stream.IsOpen()); | |
| 43 | |
| 44 // Try seeking... | |
| 45 int64 new_offset = stream.Seek(net::FROM_BEGIN, 5); | |
| 46 EXPECT_EQ(net::ERR_UNEXPECTED, new_offset); | |
| 47 | |
| 48 // Try available... | |
| 49 int64 avail = stream.Available(); | |
| 50 EXPECT_EQ(net::ERR_UNEXPECTED, avail); | |
| 51 | |
| 52 // Try reading... | |
| 53 char buf[10]; | |
| 54 int rv = stream.Read(buf, sizeof(buf), NULL); | |
| 55 EXPECT_EQ(net::ERR_UNEXPECTED, rv); | |
| 56 } | |
| 57 | |
| 58 TEST_F(FileInputStreamTest, BasicRead) { | |
| 59 int64 file_size; | |
| 60 bool ok = file_util::GetFileSize(temp_file_path(), &file_size); | |
| 61 EXPECT_TRUE(ok); | |
| 62 | |
| 63 net::FileInputStream stream; | |
| 64 int rv = stream.Open(temp_file_path(), false); | |
| 65 EXPECT_EQ(net::OK, rv); | |
| 66 | |
| 67 int64 total_bytes_avail = stream.Available(); | |
| 68 EXPECT_EQ(file_size, total_bytes_avail); | |
| 69 | |
| 70 int64 total_bytes_read = 0; | |
| 71 | |
| 72 std::string data_read; | |
| 73 for (;;) { | |
| 74 char buf[4]; | |
| 75 rv = stream.Read(buf, sizeof(buf), NULL); | |
| 76 EXPECT_LE(0, rv); | |
| 77 if (rv <= 0) | |
| 78 break; | |
| 79 total_bytes_read += rv; | |
| 80 data_read.append(buf, rv); | |
| 81 } | |
| 82 EXPECT_EQ(file_size, total_bytes_read); | |
| 83 EXPECT_TRUE(data_read == kTestData); | |
| 84 } | |
| 85 | |
| 86 TEST_F(FileInputStreamTest, AsyncRead) { | |
| 87 int64 file_size; | |
| 88 bool ok = file_util::GetFileSize(temp_file_path(), &file_size); | |
| 89 EXPECT_TRUE(ok); | |
| 90 | |
| 91 net::FileInputStream stream; | |
| 92 int rv = stream.Open(temp_file_path(), true); | |
| 93 EXPECT_EQ(net::OK, rv); | |
| 94 | |
| 95 int64 total_bytes_avail = stream.Available(); | |
| 96 EXPECT_EQ(file_size, total_bytes_avail); | |
| 97 | |
| 98 TestCompletionCallback callback; | |
| 99 | |
| 100 int64 total_bytes_read = 0; | |
| 101 | |
| 102 std::string data_read; | |
| 103 for (;;) { | |
| 104 char buf[4]; | |
| 105 rv = stream.Read(buf, sizeof(buf), &callback); | |
| 106 if (rv == net::ERR_IO_PENDING) | |
| 107 rv = callback.WaitForResult(); | |
| 108 EXPECT_LE(0, rv); | |
| 109 if (rv <= 0) | |
| 110 break; | |
| 111 total_bytes_read += rv; | |
| 112 data_read.append(buf, rv); | |
| 113 } | |
| 114 EXPECT_EQ(file_size, total_bytes_read); | |
| 115 EXPECT_TRUE(data_read == kTestData); | |
| 116 } | |
| 117 | |
| 118 TEST_F(FileInputStreamTest, BasicRead_FromOffset) { | |
| 119 int64 file_size; | |
| 120 bool ok = file_util::GetFileSize(temp_file_path(), &file_size); | |
| 121 EXPECT_TRUE(ok); | |
| 122 | |
| 123 net::FileInputStream stream; | |
| 124 int rv = stream.Open(temp_file_path(), false); | |
| 125 EXPECT_EQ(net::OK, rv); | |
| 126 | |
| 127 const int64 kOffset = 3; | |
| 128 int64 new_offset = stream.Seek(net::FROM_BEGIN, kOffset); | |
| 129 EXPECT_EQ(kOffset, new_offset); | |
| 130 | |
| 131 int64 total_bytes_avail = stream.Available(); | |
| 132 EXPECT_EQ(file_size - kOffset, total_bytes_avail); | |
| 133 | |
| 134 int64 total_bytes_read = 0; | |
| 135 | |
| 136 std::string data_read; | |
| 137 for (;;) { | |
| 138 char buf[4]; | |
| 139 rv = stream.Read(buf, sizeof(buf), NULL); | |
| 140 EXPECT_LE(0, rv); | |
| 141 if (rv <= 0) | |
| 142 break; | |
| 143 total_bytes_read += rv; | |
| 144 data_read.append(buf, rv); | |
| 145 } | |
| 146 EXPECT_EQ(file_size - kOffset, total_bytes_read); | |
| 147 EXPECT_TRUE(data_read == kTestData + kOffset); | |
| 148 } | |
| 149 | |
| 150 TEST_F(FileInputStreamTest, AsyncRead_FromOffset) { | |
| 151 int64 file_size; | |
| 152 bool ok = file_util::GetFileSize(temp_file_path(), &file_size); | |
| 153 EXPECT_TRUE(ok); | |
| 154 | |
| 155 net::FileInputStream stream; | |
| 156 int rv = stream.Open(temp_file_path(), true); | |
| 157 EXPECT_EQ(net::OK, rv); | |
| 158 | |
| 159 const int64 kOffset = 3; | |
| 160 int64 new_offset = stream.Seek(net::FROM_BEGIN, kOffset); | |
| 161 EXPECT_EQ(kOffset, new_offset); | |
| 162 | |
| 163 int64 total_bytes_avail = stream.Available(); | |
| 164 EXPECT_EQ(file_size - kOffset, total_bytes_avail); | |
| 165 | |
| 166 TestCompletionCallback callback; | |
| 167 | |
| 168 int64 total_bytes_read = 0; | |
| 169 | |
| 170 std::string data_read; | |
| 171 for (;;) { | |
| 172 char buf[4]; | |
| 173 rv = stream.Read(buf, sizeof(buf), &callback); | |
| 174 if (rv == net::ERR_IO_PENDING) | |
| 175 rv = callback.WaitForResult(); | |
| 176 EXPECT_LE(0, rv); | |
| 177 if (rv <= 0) | |
| 178 break; | |
| 179 total_bytes_read += rv; | |
| 180 data_read.append(buf, rv); | |
| 181 } | |
| 182 EXPECT_EQ(file_size - kOffset, total_bytes_read); | |
| 183 EXPECT_TRUE(data_read == kTestData + kOffset); | |
| 184 } | |
| 185 | |
| 186 TEST_F(FileInputStreamTest, SeekAround) { | |
| 187 net::FileInputStream stream; | |
| 188 int rv = stream.Open(temp_file_path(), true); | |
| 189 EXPECT_EQ(net::OK, rv); | |
| 190 | |
| 191 const int64 kOffset = 3; | |
| 192 int64 new_offset = stream.Seek(net::FROM_BEGIN, kOffset); | |
| 193 EXPECT_EQ(kOffset, new_offset); | |
| 194 | |
| 195 new_offset = stream.Seek(net::FROM_CURRENT, kOffset); | |
| 196 EXPECT_EQ(2 * kOffset, new_offset); | |
| 197 | |
| 198 new_offset = stream.Seek(net::FROM_CURRENT, -kOffset); | |
| 199 EXPECT_EQ(kOffset, new_offset); | |
| 200 | |
| 201 const int kTestDataLen = arraysize(kTestData) - 1; | |
| 202 | |
| 203 new_offset = stream.Seek(net::FROM_END, -kTestDataLen); | |
| 204 EXPECT_EQ(0, new_offset); | |
| 205 } | |
| OLD | NEW |