OLD | NEW |
| (Empty) |
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 | |
3 // found in the LICENSE file. | |
4 | |
5 #include "config.h" | |
6 #include "modules/serviceworkers/BodyStreamBuffer.h" | |
7 | |
8 #include "core/dom/DOMArrayBuffer.h" | |
9 #include "core/dom/DOMException.h" | |
10 #include "core/dom/ExceptionCode.h" | |
11 #include "platform/heap/Heap.h" | |
12 #include "public/platform/Platform.h" | |
13 #include "public/platform/WebUnitTestSupport.h" | |
14 #include "public/platform/WebVector.h" | |
15 #include "wtf/RefPtr.h" | |
16 #include "wtf/testing/WTFTestHelpers.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 void trace(Visitor* visitor) override | |
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 virtual void trace(Visitor* visitor) override | |
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(PassRefPtrWillBeRawPtr<DOMException> exception) overrid
e | |
64 { | |
65 m_exception = exception; | |
66 } | |
67 PassRefPtr<BlobDataHandle> blobHandle() | |
68 { | |
69 return m_blobHandle; | |
70 } | |
71 PassRefPtrWillBeRawPtr<DOMException> exception() | |
72 { | |
73 return m_exception; | |
74 } | |
75 | |
76 private: | |
77 RefPtr<BlobDataHandle> m_blobHandle; | |
78 RefPtrWillBeMember<DOMException> m_exception; | |
79 }; | |
80 | |
81 } // namespace | |
82 | |
83 TEST(BodyStreamBufferTest, Read) | |
84 { | |
85 BodyStreamBuffer* buffer = new BodyStreamBuffer(); | |
86 RefPtr<DOMArrayBuffer> arrayBuffer1 = DOMArrayBuffer::create("foobar", 6); | |
87 RefPtr<DOMArrayBuffer> arrayBuffer2 = DOMArrayBuffer::create("abc", 3); | |
88 RefPtr<DOMArrayBuffer> arrayBuffer3 = DOMArrayBuffer::create("piyo", 4); | |
89 buffer->write(arrayBuffer1); | |
90 buffer->write(arrayBuffer2); | |
91 EXPECT_EQ(arrayBuffer1, buffer->read()); | |
92 EXPECT_EQ(arrayBuffer2, buffer->read()); | |
93 EXPECT_FALSE(buffer->read()); | |
94 buffer->write(arrayBuffer3); | |
95 EXPECT_EQ(arrayBuffer3, buffer->read()); | |
96 EXPECT_FALSE(buffer->read()); | |
97 } | |
98 | |
99 TEST(BodyStreamBufferTest, Exception) | |
100 { | |
101 BodyStreamBuffer* buffer = new BodyStreamBuffer(); | |
102 EXPECT_FALSE(buffer->exception()); | |
103 buffer->error(DOMException::create(NetworkError, "Error Message")); | |
104 EXPECT_TRUE(buffer->exception()); | |
105 EXPECT_EQ("NetworkError", buffer->exception()->name()); | |
106 EXPECT_EQ("Error Message", buffer->exception()->message()); | |
107 } | |
108 | |
109 TEST(BodyStreamBufferTest, Observer) | |
110 { | |
111 BodyStreamBuffer* buffer = new BodyStreamBuffer(); | |
112 MockObserver* observer1 = new MockObserver(); | |
113 MockObserver* observer2 = new MockObserver(); | |
114 EXPECT_TRUE(buffer->registerObserver(observer1)); | |
115 EXPECT_FALSE(buffer->registerObserver(observer2)); | |
116 EXPECT_EQ(0, observer1->writeCount()); | |
117 EXPECT_EQ(0, observer1->closeCount()); | |
118 EXPECT_EQ(0, observer1->errorCount()); | |
119 buffer->write(DOMArrayBuffer::create("foobar", 6)); | |
120 EXPECT_EQ(1, observer1->writeCount()); | |
121 EXPECT_EQ(0, observer1->closeCount()); | |
122 EXPECT_EQ(0, observer1->errorCount()); | |
123 buffer->write(DOMArrayBuffer::create("piyo", 4)); | |
124 EXPECT_EQ(2, observer1->writeCount()); | |
125 EXPECT_EQ(0, observer1->closeCount()); | |
126 EXPECT_EQ(0, observer1->errorCount()); | |
127 EXPECT_FALSE(buffer->isClosed()); | |
128 buffer->close(); | |
129 EXPECT_TRUE(buffer->isClosed()); | |
130 EXPECT_EQ(2, observer1->writeCount()); | |
131 EXPECT_EQ(1, observer1->closeCount()); | |
132 EXPECT_EQ(0, observer1->errorCount()); | |
133 EXPECT_EQ(0, observer2->writeCount()); | |
134 EXPECT_EQ(0, observer2->closeCount()); | |
135 EXPECT_EQ(0, observer2->errorCount()); | |
136 } | |
137 | |
138 TEST(BodyStreamBufferTest, CreateBlob) | |
139 { | |
140 BodyStreamBuffer* buffer = new BodyStreamBuffer(); | |
141 BlobHandleCallback* callback1 = new BlobHandleCallback(); | |
142 BlobHandleCallback* callback2 = new BlobHandleCallback(); | |
143 EXPECT_TRUE(buffer->readAllAndCreateBlobHandle("text/html", callback1)); | |
144 EXPECT_FALSE(buffer->readAllAndCreateBlobHandle("text/html", callback2)); | |
145 buffer->write(DOMArrayBuffer::create("foobar", 6)); | |
146 EXPECT_FALSE(callback1->blobHandle()); | |
147 buffer->write(DOMArrayBuffer::create("piyo", 4)); | |
148 EXPECT_FALSE(callback1->blobHandle()); | |
149 buffer->close(); | |
150 EXPECT_TRUE(callback1->blobHandle()); | |
151 EXPECT_EQ("text/html", callback1->blobHandle()->type()); | |
152 EXPECT_FALSE(callback2->blobHandle()); | |
153 EXPECT_EQ(10u, callback1->blobHandle()->size()); | |
154 WebVector<WebBlobData::Item*> items; | |
155 EXPECT_TRUE(Platform::current()->unitTestSupport()->getBlobItems(callback1->
blobHandle()->uuid(), &items)); | |
156 EXPECT_EQ(2u, items.size()); | |
157 EXPECT_EQ(6u, items[0]->data.size()); | |
158 EXPECT_EQ(0, memcmp(items[0]->data.data(), "foobar", 6)); | |
159 EXPECT_EQ(4u, items[1]->data.size()); | |
160 EXPECT_EQ(0, memcmp(items[1]->data.data(), "piyo", 4)); | |
161 EXPECT_FALSE(callback1->exception()); | |
162 EXPECT_FALSE(callback2->exception()); | |
163 } | |
164 | |
165 TEST(BodyStreamBufferTest, CreateBlobAfterWrite) | |
166 { | |
167 BodyStreamBuffer* buffer = new BodyStreamBuffer(); | |
168 BlobHandleCallback* callback = new BlobHandleCallback(); | |
169 buffer->write(DOMArrayBuffer::create("foobar", 6)); | |
170 EXPECT_TRUE(buffer->readAllAndCreateBlobHandle("", callback)); | |
171 buffer->close(); | |
172 EXPECT_TRUE(callback->blobHandle()); | |
173 EXPECT_EQ(6u, callback->blobHandle()->size()); | |
174 WebVector<WebBlobData::Item*> items; | |
175 EXPECT_TRUE(Platform::current()->unitTestSupport()->getBlobItems(callback->b
lobHandle()->uuid(), &items)); | |
176 EXPECT_EQ(1u, items.size()); | |
177 EXPECT_EQ(6u, items[0]->data.size()); | |
178 EXPECT_EQ(0, memcmp(items[0]->data.data(), "foobar", 6)); | |
179 } | |
180 | |
181 TEST(BodyStreamBufferTest, CreateBlobAfterClose) | |
182 { | |
183 BodyStreamBuffer* buffer = new BodyStreamBuffer(); | |
184 BlobHandleCallback* callback = new BlobHandleCallback(); | |
185 buffer->write(DOMArrayBuffer::create("foobar", 6)); | |
186 buffer->close(); | |
187 EXPECT_TRUE(buffer->readAllAndCreateBlobHandle("", callback)); | |
188 EXPECT_TRUE(callback->blobHandle()); | |
189 EXPECT_EQ(6u, callback->blobHandle()->size()); | |
190 WebVector<WebBlobData::Item*> items; | |
191 EXPECT_TRUE(Platform::current()->unitTestSupport()->getBlobItems(callback->b
lobHandle()->uuid(), &items)); | |
192 EXPECT_EQ(1u, items.size()); | |
193 EXPECT_EQ(6u, items[0]->data.size()); | |
194 EXPECT_EQ(0, memcmp(items[0]->data.data(), "foobar", 6)); | |
195 } | |
196 | |
197 TEST(BodyStreamBufferTest, CreateBlobException) | |
198 { | |
199 BodyStreamBuffer* buffer = new BodyStreamBuffer(); | |
200 BlobHandleCallback* callback1 = new BlobHandleCallback(); | |
201 BlobHandleCallback* callback2 = new BlobHandleCallback(); | |
202 EXPECT_TRUE(buffer->readAllAndCreateBlobHandle("", callback1)); | |
203 EXPECT_FALSE(buffer->readAllAndCreateBlobHandle("", callback2)); | |
204 buffer->write(DOMArrayBuffer::create("foobar", 6)); | |
205 buffer->write(DOMArrayBuffer::create("piyo", 4)); | |
206 EXPECT_FALSE(buffer->hasError()); | |
207 buffer->error(DOMException::create(NetworkError, "Error Message")); | |
208 EXPECT_TRUE(buffer->hasError()); | |
209 EXPECT_FALSE(callback1->blobHandle()); | |
210 EXPECT_FALSE(callback2->blobHandle()); | |
211 EXPECT_TRUE(callback1->exception()); | |
212 EXPECT_FALSE(callback2->exception()); | |
213 EXPECT_EQ("NetworkError", callback1->exception()->name()); | |
214 EXPECT_EQ("Error Message", callback1->exception()->message()); | |
215 } | |
216 | |
217 TEST(BodyStreamBufferTest, CreateBlobExceptionAfterWrite) | |
218 { | |
219 BodyStreamBuffer* buffer = new BodyStreamBuffer(); | |
220 BlobHandleCallback* callback = new BlobHandleCallback(); | |
221 buffer->write(DOMArrayBuffer::create("foobar", 6)); | |
222 EXPECT_TRUE(buffer->readAllAndCreateBlobHandle("", callback)); | |
223 buffer->error(DOMException::create(NetworkError, "Error Message")); | |
224 EXPECT_TRUE(callback->exception()); | |
225 EXPECT_EQ("NetworkError", callback->exception()->name()); | |
226 EXPECT_EQ("Error Message", callback->exception()->message()); | |
227 } | |
228 | |
229 TEST(BodyStreamBufferTest, CreateBlobExceptionAfterError) | |
230 { | |
231 BodyStreamBuffer* buffer = new BodyStreamBuffer(); | |
232 BlobHandleCallback* callback = new BlobHandleCallback(); | |
233 buffer->write(DOMArrayBuffer::create("foobar", 6)); | |
234 buffer->error(DOMException::create(NetworkError, "Error Message")); | |
235 EXPECT_TRUE(buffer->readAllAndCreateBlobHandle("", callback)); | |
236 EXPECT_TRUE(callback->exception()); | |
237 EXPECT_EQ("NetworkError", callback->exception()->name()); | |
238 EXPECT_EQ("Error Message", callback->exception()->message()); | |
239 } | |
240 | |
241 } // namespace blink | |
OLD | NEW |