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 |