OLD | NEW |
---|---|
1 // Copyright 2014 The Chromium Authors. All rights reserved. | 1 // Copyright 2014 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 "config.h" | 5 #include "config.h" |
6 #include "modules/fetch/BodyStreamBuffer.h" | 6 #include "modules/fetch/BodyStreamBuffer.h" |
7 | 7 |
8 #include "core/dom/DOMArrayBuffer.h" | 8 #include "core/dom/DOMArrayBuffer.h" |
yhirano
2015/07/06 03:25:39
-includes
yhirano
2015/07/06 03:25:39
Please add TODO if you want to re-add tests later.
hiroshige
2015/07/07 03:50:57
Done.
hiroshige
2015/07/07 03:50:57
Done.
| |
9 #include "core/dom/DOMException.h" | 9 #include "core/dom/DOMException.h" |
10 #include "core/dom/ExceptionCode.h" | 10 #include "core/dom/ExceptionCode.h" |
11 #include "platform/heap/Heap.h" | 11 #include "platform/heap/Heap.h" |
12 #include "public/platform/Platform.h" | 12 #include "public/platform/Platform.h" |
13 #include "public/platform/WebUnitTestSupport.h" | 13 #include "public/platform/WebUnitTestSupport.h" |
14 #include "public/platform/WebVector.h" | 14 #include "public/platform/WebVector.h" |
15 #include "wtf/RefPtr.h" | 15 #include "wtf/RefPtr.h" |
16 #include "wtf/testing/WTFTestHelpers.h" | 16 #include "wtf/testing/WTFTestHelpers.h" |
17 #include <gtest/gtest.h> | 17 #include <gtest/gtest.h> |
18 | |
19 namespace blink { | |
20 namespace { | |
21 | |
22 class MockObserver final : public BodyStreamBuffer::Observer { | |
23 public: | |
24 MockObserver() | |
25 : m_writeCount(0) | |
26 , m_closeCount(0) | |
27 , m_errorCount(0) | |
28 { | |
29 } | |
30 ~MockObserver() override { } | |
31 DEFINE_INLINE_VIRTUAL_TRACE() | |
32 { | |
33 BodyStreamBuffer::Observer::trace(visitor); | |
34 } | |
35 void onWrite() override { ++m_writeCount; } | |
36 void onClose() override { ++m_closeCount; } | |
37 void onError() override { ++m_errorCount; } | |
38 int writeCount() const { return m_writeCount; } | |
39 int closeCount() const { return m_closeCount; } | |
40 int errorCount() const { return m_errorCount; } | |
41 | |
42 private: | |
43 int m_writeCount; | |
44 int m_closeCount; | |
45 int m_errorCount; | |
46 }; | |
47 | |
48 class BlobHandleCallback final : public BodyStreamBuffer::BlobHandleCreatorClien t { | |
49 public: | |
50 BlobHandleCallback() | |
51 { | |
52 } | |
53 virtual ~BlobHandleCallback() override { } | |
54 DEFINE_INLINE_VIRTUAL_TRACE() | |
55 { | |
56 visitor->trace(m_exception); | |
57 BodyStreamBuffer::BlobHandleCreatorClient::trace(visitor); | |
58 } | |
59 virtual void didCreateBlobHandle(PassRefPtr<BlobDataHandle> blobHandle) over ride | |
60 { | |
61 m_blobHandle = blobHandle; | |
62 } | |
63 virtual void didFail(DOMException* exception) override | |
64 { | |
65 m_exception = exception; | |
66 } | |
67 PassRefPtr<BlobDataHandle> blobHandle() | |
68 { | |
69 return m_blobHandle; | |
70 } | |
71 DOMException* exception() | |
72 { | |
73 return m_exception; | |
74 } | |
75 | |
76 private: | |
77 RefPtr<BlobDataHandle> m_blobHandle; | |
78 Member<DOMException> m_exception; | |
79 }; | |
80 | |
81 class MockCanceller : public BodyStreamBuffer::Canceller { | |
82 public: | |
83 MockCanceller() : m_counter(0) { } | |
84 void cancel() override { ++m_counter; } | |
85 int counter() const { return m_counter; } | |
86 | |
87 private: | |
88 int m_counter; | |
89 }; | |
90 | |
91 } // namespace | |
92 | |
93 TEST(BodyStreamBufferTest, Read) | |
94 { | |
95 BodyStreamBuffer* buffer = new BodyStreamBuffer(new MockCanceller); | |
96 RefPtr<DOMArrayBuffer> arrayBuffer1 = DOMArrayBuffer::create("foobar", 6); | |
97 RefPtr<DOMArrayBuffer> arrayBuffer2 = DOMArrayBuffer::create("abc", 3); | |
98 RefPtr<DOMArrayBuffer> arrayBuffer3 = DOMArrayBuffer::create("piyo", 4); | |
99 buffer->write(arrayBuffer1); | |
100 buffer->write(arrayBuffer2); | |
101 EXPECT_EQ(arrayBuffer1, buffer->read()); | |
102 EXPECT_EQ(arrayBuffer2, buffer->read()); | |
103 EXPECT_FALSE(buffer->read()); | |
104 buffer->write(arrayBuffer3); | |
105 EXPECT_EQ(arrayBuffer3, buffer->read()); | |
106 EXPECT_FALSE(buffer->read()); | |
107 } | |
108 | |
109 TEST(BodyStreamBufferTest, Exception) | |
110 { | |
111 BodyStreamBuffer* buffer = new BodyStreamBuffer(new MockCanceller); | |
112 EXPECT_FALSE(buffer->exception()); | |
113 buffer->error(DOMException::create(NetworkError, "Error Message")); | |
114 EXPECT_TRUE(buffer->exception()); | |
115 EXPECT_EQ("NetworkError", buffer->exception()->name()); | |
116 EXPECT_EQ("Error Message", buffer->exception()->message()); | |
117 } | |
118 | |
119 TEST(BodyStreamBufferTest, Observer) | |
120 { | |
121 BodyStreamBuffer* buffer = new BodyStreamBuffer(new MockCanceller); | |
122 MockObserver* observer1 = new MockObserver(); | |
123 MockObserver* observer2 = new MockObserver(); | |
124 EXPECT_TRUE(buffer->registerObserver(observer1)); | |
125 EXPECT_FALSE(buffer->registerObserver(observer2)); | |
126 EXPECT_EQ(0, observer1->writeCount()); | |
127 EXPECT_EQ(0, observer1->closeCount()); | |
128 EXPECT_EQ(0, observer1->errorCount()); | |
129 buffer->write(DOMArrayBuffer::create("foobar", 6)); | |
130 EXPECT_EQ(1, observer1->writeCount()); | |
131 EXPECT_EQ(0, observer1->closeCount()); | |
132 EXPECT_EQ(0, observer1->errorCount()); | |
133 buffer->write(DOMArrayBuffer::create("piyo", 4)); | |
134 EXPECT_EQ(2, observer1->writeCount()); | |
135 EXPECT_EQ(0, observer1->closeCount()); | |
136 EXPECT_EQ(0, observer1->errorCount()); | |
137 EXPECT_FALSE(buffer->isClosed()); | |
138 buffer->close(); | |
139 EXPECT_TRUE(buffer->isClosed()); | |
140 EXPECT_EQ(2, observer1->writeCount()); | |
141 EXPECT_EQ(1, observer1->closeCount()); | |
142 EXPECT_EQ(0, observer1->errorCount()); | |
143 EXPECT_EQ(0, observer2->writeCount()); | |
144 EXPECT_EQ(0, observer2->closeCount()); | |
145 EXPECT_EQ(0, observer2->errorCount()); | |
146 } | |
147 | |
148 TEST(BodyStreamBufferTest, CreateBlob) | |
149 { | |
150 BodyStreamBuffer* buffer = new BodyStreamBuffer(new MockCanceller); | |
151 BlobHandleCallback* callback1 = new BlobHandleCallback(); | |
152 BlobHandleCallback* callback2 = new BlobHandleCallback(); | |
153 EXPECT_TRUE(buffer->readAllAndCreateBlobHandle("text/html", callback1)); | |
154 EXPECT_FALSE(buffer->readAllAndCreateBlobHandle("text/html", callback2)); | |
155 buffer->write(DOMArrayBuffer::create("foobar", 6)); | |
156 EXPECT_FALSE(callback1->blobHandle()); | |
157 buffer->write(DOMArrayBuffer::create("piyo", 4)); | |
158 EXPECT_FALSE(callback1->blobHandle()); | |
159 buffer->close(); | |
160 EXPECT_TRUE(callback1->blobHandle()); | |
161 EXPECT_EQ("text/html", callback1->blobHandle()->type()); | |
162 EXPECT_FALSE(callback2->blobHandle()); | |
163 EXPECT_EQ(10u, callback1->blobHandle()->size()); | |
164 WebVector<WebBlobData::Item*> items; | |
165 EXPECT_TRUE(Platform::current()->unitTestSupport()->getBlobItems(callback1-> blobHandle()->uuid(), &items)); | |
166 // The data has been consolidated. | |
167 EXPECT_EQ(1u, items.size()); | |
168 EXPECT_EQ(10u, items[0]->data.size()); | |
169 EXPECT_EQ(0, memcmp(items[0]->data.data(), "foobarpiyo", 10)); | |
170 EXPECT_FALSE(callback1->exception()); | |
171 EXPECT_FALSE(callback2->exception()); | |
172 } | |
173 | |
174 TEST(BodyStreamBufferTest, CreateBlobAfterWrite) | |
175 { | |
176 BodyStreamBuffer* buffer = new BodyStreamBuffer(new MockCanceller); | |
177 BlobHandleCallback* callback = new BlobHandleCallback(); | |
178 buffer->write(DOMArrayBuffer::create("foobar", 6)); | |
179 EXPECT_TRUE(buffer->readAllAndCreateBlobHandle("", callback)); | |
180 buffer->close(); | |
181 EXPECT_TRUE(callback->blobHandle()); | |
182 EXPECT_EQ(6u, callback->blobHandle()->size()); | |
183 WebVector<WebBlobData::Item*> items; | |
184 EXPECT_TRUE(Platform::current()->unitTestSupport()->getBlobItems(callback->b lobHandle()->uuid(), &items)); | |
185 EXPECT_EQ(1u, items.size()); | |
186 EXPECT_EQ(6u, items[0]->data.size()); | |
187 EXPECT_EQ(0, memcmp(items[0]->data.data(), "foobar", 6)); | |
188 } | |
189 | |
190 TEST(BodyStreamBufferTest, CreateBlobAfterClose) | |
191 { | |
192 BodyStreamBuffer* buffer = new BodyStreamBuffer(new MockCanceller); | |
193 BlobHandleCallback* callback = new BlobHandleCallback(); | |
194 buffer->write(DOMArrayBuffer::create("foobar", 6)); | |
195 buffer->close(); | |
196 EXPECT_TRUE(buffer->readAllAndCreateBlobHandle("", callback)); | |
197 EXPECT_TRUE(callback->blobHandle()); | |
198 EXPECT_EQ(6u, callback->blobHandle()->size()); | |
199 WebVector<WebBlobData::Item*> items; | |
200 EXPECT_TRUE(Platform::current()->unitTestSupport()->getBlobItems(callback->b lobHandle()->uuid(), &items)); | |
201 EXPECT_EQ(1u, items.size()); | |
202 EXPECT_EQ(6u, items[0]->data.size()); | |
203 EXPECT_EQ(0, memcmp(items[0]->data.data(), "foobar", 6)); | |
204 } | |
205 | |
206 TEST(BodyStreamBufferTest, CreateBlobException) | |
207 { | |
208 BodyStreamBuffer* buffer = new BodyStreamBuffer(new MockCanceller); | |
209 BlobHandleCallback* callback1 = new BlobHandleCallback(); | |
210 BlobHandleCallback* callback2 = new BlobHandleCallback(); | |
211 EXPECT_TRUE(buffer->readAllAndCreateBlobHandle("", callback1)); | |
212 EXPECT_FALSE(buffer->readAllAndCreateBlobHandle("", callback2)); | |
213 buffer->write(DOMArrayBuffer::create("foobar", 6)); | |
214 buffer->write(DOMArrayBuffer::create("piyo", 4)); | |
215 EXPECT_FALSE(buffer->hasError()); | |
216 buffer->error(DOMException::create(NetworkError, "Error Message")); | |
217 EXPECT_TRUE(buffer->hasError()); | |
218 EXPECT_FALSE(callback1->blobHandle()); | |
219 EXPECT_FALSE(callback2->blobHandle()); | |
220 EXPECT_TRUE(callback1->exception()); | |
221 EXPECT_FALSE(callback2->exception()); | |
222 EXPECT_EQ("NetworkError", callback1->exception()->name()); | |
223 EXPECT_EQ("Error Message", callback1->exception()->message()); | |
224 } | |
225 | |
226 TEST(BodyStreamBufferTest, CreateBlobExceptionAfterWrite) | |
227 { | |
228 BodyStreamBuffer* buffer = new BodyStreamBuffer(new MockCanceller); | |
229 BlobHandleCallback* callback = new BlobHandleCallback(); | |
230 buffer->write(DOMArrayBuffer::create("foobar", 6)); | |
231 EXPECT_TRUE(buffer->readAllAndCreateBlobHandle("", callback)); | |
232 buffer->error(DOMException::create(NetworkError, "Error Message")); | |
233 EXPECT_TRUE(callback->exception()); | |
234 EXPECT_EQ("NetworkError", callback->exception()->name()); | |
235 EXPECT_EQ("Error Message", callback->exception()->message()); | |
236 } | |
237 | |
238 TEST(BodyStreamBufferTest, CreateBlobExceptionAfterError) | |
239 { | |
240 BodyStreamBuffer* buffer = new BodyStreamBuffer(new MockCanceller); | |
241 BlobHandleCallback* callback = new BlobHandleCallback(); | |
242 buffer->write(DOMArrayBuffer::create("foobar", 6)); | |
243 buffer->error(DOMException::create(NetworkError, "Error Message")); | |
244 EXPECT_TRUE(buffer->readAllAndCreateBlobHandle("", callback)); | |
245 EXPECT_TRUE(callback->exception()); | |
246 EXPECT_EQ("NetworkError", callback->exception()->name()); | |
247 EXPECT_EQ("Error Message", callback->exception()->message()); | |
248 } | |
249 | |
250 TEST(BodyStreamBufferTest, Cancel) | |
251 { | |
252 auto canceller = new MockCanceller; | |
253 BodyStreamBuffer* buffer = new BodyStreamBuffer(canceller); | |
254 buffer->cancel(); | |
255 | |
256 EXPECT_EQ(1, canceller->counter()); | |
257 EXPECT_FALSE(buffer->isClosed()); | |
258 EXPECT_FALSE(buffer->hasError()); | |
259 } | |
260 | |
261 } // namespace blink | |
OLD | NEW |