OLD | NEW |
---|---|
(Empty) | |
1 // Copyright (c) 2013 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/message_loop.h" | |
6 #include "base/test/test_simple_task_runner.h" | |
7 #include "content/browser/streams/stream.h" | |
8 #include "content/browser/streams/stream_read_observer.h" | |
9 #include "content/browser/streams/stream_registry.h" | |
10 #include "content/browser/streams/stream_write_observer.h" | |
11 #include "testing/gtest/include/gtest/gtest.h" | |
12 | |
13 namespace content { | |
14 | |
15 class StreamTest : public testing::Test { | |
16 public: | |
17 StreamTest() {} | |
18 | |
19 virtual void SetUp() OVERRIDE { | |
20 registry_.reset(new StreamRegistry()); | |
21 } | |
22 | |
23 // Create a new IO buffer of the given |buffer_size| and fill it with random | |
24 // data. | |
25 scoped_refptr<net::IOBuffer> NewIOBuffer(size_t buffer_size) { | |
26 scoped_refptr<net::IOBuffer> buffer(new net::IOBuffer(buffer_size)); | |
27 char *bufferp = buffer->data(); | |
28 for (size_t i = 0; i < buffer_size; i++) | |
29 bufferp[i] = (i + producing_seed_key_) % (1 << sizeof(char)); | |
30 ++producing_seed_key_; | |
31 return buffer; | |
32 } | |
33 | |
34 protected: | |
35 MessageLoop message_loop_; | |
36 scoped_ptr<StreamRegistry> registry_; | |
37 | |
38 private: | |
39 int producing_seed_key_; | |
40 }; | |
41 | |
42 class TestStreamReader : public StreamReadObserver { | |
43 public: | |
44 TestStreamReader() : buffer_(new net::GrowableIOBuffer()) { | |
45 } | |
46 virtual ~TestStreamReader() {} | |
47 | |
48 void Read(Stream* stream) { | |
49 const size_t kBufferSize = 32768; | |
50 scoped_refptr<net::IOBuffer> buffer(new net::IOBuffer(kBufferSize)); | |
51 | |
52 int bytes_read = 0; | |
53 while (stream->ReadRawData(buffer, kBufferSize, &bytes_read) == | |
54 Stream::STREAM_HAS_DATA) { | |
55 size_t old_capacity = buffer_->capacity(); | |
56 buffer_->SetCapacity(old_capacity + bytes_read); | |
57 memcpy(buffer_->data() + old_capacity, buffer->data(), bytes_read); | |
58 } | |
59 } | |
60 | |
61 virtual void OnDataAvailable(Stream* stream) OVERRIDE { | |
62 Read(stream); | |
63 } | |
64 | |
65 scoped_refptr<net::GrowableIOBuffer> buffer() { return buffer_; } | |
66 | |
67 private: | |
68 scoped_refptr<net::GrowableIOBuffer> buffer_; | |
69 }; | |
70 | |
71 class TestStreamWriter : public StreamWriteObserver { | |
72 public: | |
73 TestStreamWriter() {} | |
74 virtual ~TestStreamWriter() {} | |
75 | |
76 void Write(Stream* stream, | |
77 scoped_refptr<net::IOBuffer> buffer, | |
78 size_t buffer_size) { | |
79 stream->AddData(buffer, buffer_size); | |
80 } | |
81 | |
82 virtual void OnSpaceAvailable(Stream* stream) OVERRIDE { | |
83 } | |
84 }; | |
85 | |
86 TEST_F(StreamTest, SetReadObserver) { | |
87 TestStreamReader reader; | |
88 TestStreamWriter writer; | |
89 | |
90 GURL url("blob://stream"); | |
91 scoped_refptr<Stream> stream( | |
92 new Stream(registry_.get(), &writer, GURL(), url)); | |
93 EXPECT_TRUE(stream->SetReadObserver(&reader)); | |
94 } | |
95 | |
96 TEST_F(StreamTest, SetReadObserver_SecondFails) { | |
97 TestStreamReader reader1; | |
98 TestStreamReader reader2; | |
99 TestStreamWriter writer; | |
100 | |
101 GURL url("blob://stream"); | |
102 scoped_refptr<Stream> stream( | |
103 new Stream(registry_.get(), &writer, GURL(), url)); | |
104 EXPECT_TRUE(stream->SetReadObserver(&reader1)); | |
105 EXPECT_FALSE(stream->SetReadObserver(&reader2)); | |
106 } | |
107 | |
108 TEST_F(StreamTest, SetReadObserver_TwoReaders) { | |
109 TestStreamReader reader1; | |
110 TestStreamReader reader2; | |
111 TestStreamWriter writer; | |
112 | |
113 GURL url("blob://stream"); | |
114 scoped_refptr<Stream> stream( | |
115 new Stream(registry_.get(), &writer, GURL(), url)); | |
116 EXPECT_TRUE(stream->SetReadObserver(&reader1)); | |
117 | |
118 // Once the first read observer is removed, a new one can be added. | |
119 stream->RemoveReadObserver(&reader1); | |
120 EXPECT_TRUE(stream->SetReadObserver(&reader2)); | |
121 } | |
122 | |
123 TEST_F(StreamTest, Stream) { | |
124 TestStreamReader reader; | |
125 TestStreamWriter writer; | |
126 | |
127 GURL url("blob://stream"); | |
128 scoped_refptr<Stream> stream( | |
129 new Stream(registry_.get(), &writer, GURL(), url)); | |
130 EXPECT_TRUE(stream->SetReadObserver(&reader)); | |
131 | |
132 int buffer_size = 1000000; | |
133 scoped_refptr<net::IOBuffer> buffer(NewIOBuffer(buffer_size)); | |
134 writer.Write(stream, buffer, buffer_size); | |
135 stream->Finalize(); | |
136 reader.Read(stream); | |
137 MessageLoop::current()->RunUntilIdle(); | |
138 | |
139 ASSERT_EQ(reader.buffer()->capacity(), buffer_size); | |
140 ASSERT_EQ(0, memcmp(buffer->data(), | |
141 reader.buffer()->data(), | |
142 buffer_size)); | |
143 } | |
144 | |
145 TEST_F(StreamTest, GetStream) { | |
146 TestStreamWriter writer; | |
147 | |
148 GURL url("blob://stream"); | |
149 scoped_refptr<Stream> stream1( | |
150 new Stream(registry_.get(), &writer, GURL(), url)); | |
151 | |
152 scoped_refptr<Stream> stream2 = registry_->GetStream(url); | |
153 ASSERT_EQ(stream1, stream2); | |
154 } | |
155 | |
156 TEST_F(StreamTest, GetStream_Missing) { | |
157 TestStreamWriter writer; | |
158 | |
159 GURL url1("blob://stream"); | |
160 scoped_refptr<Stream> stream1( | |
161 new Stream(registry_.get(), &writer, GURL(), url1)); | |
162 | |
163 GURL url2("blob://stream2"); | |
164 scoped_refptr<Stream> stream2 = registry_->GetStream(url2); | |
165 ASSERT_FALSE(stream2); | |
166 } | |
167 | |
168 TEST_F(StreamTest, CloneStream) { | |
169 TestStreamWriter writer; | |
170 | |
171 GURL url1("blob://stream"); | |
172 scoped_refptr<Stream> stream1( | |
173 new Stream(registry_.get(), &writer, GURL(), url1)); | |
174 | |
175 GURL url2("blob://stream2"); | |
176 ASSERT_TRUE(registry_->CloneStream(url2, url1)); | |
177 scoped_refptr<Stream> stream2 = registry_->GetStream(url2); | |
178 ASSERT_EQ(stream1, stream2); | |
179 } | |
180 | |
181 TEST_F(StreamTest, CloneStream_Missing) { | |
182 TestStreamWriter writer; | |
183 | |
184 GURL url1("blob://stream"); | |
185 scoped_refptr<Stream> stream1( | |
186 new Stream(registry_.get(), &writer, GURL(), url1)); | |
187 | |
188 GURL url2("blob://stream2"); | |
189 GURL url3("blob://stream3"); | |
190 ASSERT_FALSE(registry_->CloneStream(url2, url3)); | |
191 scoped_refptr<Stream> stream2 = registry_->GetStream(url2); | |
kinuko
2013/03/08 07:37:22
If I read the code correctly currently if we clone
| |
192 ASSERT_FALSE(stream2); | |
193 } | |
194 | |
195 TEST_F(StreamTest, UnregisterStream) { | |
196 TestStreamWriter writer; | |
197 | |
198 GURL url("blob://stream"); | |
199 scoped_refptr<Stream> stream1( | |
200 new Stream(registry_.get(), &writer, GURL(), url)); | |
201 | |
202 registry_->UnregisterStream(url); | |
203 scoped_refptr<Stream> stream2 = registry_->GetStream(url); | |
204 ASSERT_FALSE(stream2); | |
205 } | |
206 | |
207 } // namespace content | |
OLD | NEW |