• Home
  • History
  • Annotate
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2  * Copyright (C) 2013 Google Inc. All rights reserved.
3  *
4  * Redistribution and use in source and binary forms, with or without
5  * modification, are permitted provided that the following conditions are
6  * met:
7  *
8  *     * Redistributions of source code must retain the above copyright
9  * notice, this list of conditions and the following disclaimer.
10  *     * Redistributions in binary form must reproduce the above
11  * copyright notice, this list of conditions and the following disclaimer
12  * in the documentation and/or other materials provided with the
13  * distribution.
14  *     * Neither the name of Google Inc. nor the names of its
15  * contributors may be used to endorse or promote products derived from
16  * this software without specific prior written permission.
17  *
18  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
19  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
20  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
21  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
22  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
23  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
24  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
25  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
26  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
27  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
28  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
29  */
30 
31 #include "config.h"
32 #include "modules/websockets/WebSocketPerMessageDeflate.h"
33 
34 #include "wtf/text/StringHash.h"
35 
36 #include <algorithm>
37 #include <gtest/gtest.h>
38 #include <iterator>
39 
40 namespace blink {
41 namespace {
42 
TEST(WebSocketPerMessageDeflateTest,TestDeflateHelloTakeOver)43 TEST(WebSocketPerMessageDeflateTest, TestDeflateHelloTakeOver)
44 {
45     WebSocketPerMessageDeflate c;
46     c.enable(8, WebSocketDeflater::TakeOverContext);
47     WebSocketFrame::OpCode opcode = WebSocketFrame::OpCodeText;
48     WebSocketFrame f1(opcode, "Hello", 5, WebSocketFrame::Final);
49     WebSocketFrame f2(opcode, "Hello", 5, WebSocketFrame::Final);
50 
51     ASSERT_TRUE(c.deflate(f1));
52     EXPECT_EQ(7u, f1.payloadLength);
53     EXPECT_EQ(0, memcmp("\xf2\x48\xcd\xc9\xc9\x07\x00", f1.payload, f1.payloadLength));
54     EXPECT_TRUE(f1.compress);
55     EXPECT_TRUE(f1.final);
56 
57     c.resetDeflateBuffer();
58     ASSERT_TRUE(c.deflate(f2));
59     EXPECT_EQ(5u, f2.payloadLength);
60     EXPECT_EQ(0, memcmp("\xf2\x00\x11\x00\x00", f2.payload, f2.payloadLength));
61     EXPECT_TRUE(f2.compress);
62     EXPECT_TRUE(f2.final);
63 }
64 
TEST(WebSocketPerMessageTest,TestDeflateHelloNoTakeOver)65 TEST(WebSocketPerMessageTest, TestDeflateHelloNoTakeOver)
66 {
67     WebSocketPerMessageDeflate c;
68     c.enable(8, WebSocketDeflater::DoNotTakeOverContext);
69     WebSocketFrame::OpCode opcode = WebSocketFrame::OpCodeText;
70     WebSocketFrame f1(opcode, "Hello", 5, WebSocketFrame::Final);
71     WebSocketFrame f2(opcode, "Hello", 5, WebSocketFrame::Final);
72 
73     ASSERT_TRUE(c.deflate(f1));
74     EXPECT_EQ(7u, f1.payloadLength);
75     EXPECT_EQ(0, memcmp("\xf2\x48\xcd\xc9\xc9\x07\x00", f1.payload, f1.payloadLength));
76     EXPECT_TRUE(f1.compress);
77     EXPECT_TRUE(f1.final);
78 
79     c.resetDeflateBuffer();
80     ASSERT_TRUE(c.deflate(f2));
81     EXPECT_EQ(7u, f2.payloadLength);
82     EXPECT_EQ(0, memcmp("\xf2\x48\xcd\xc9\xc9\x07\x00", f2.payload, f2.payloadLength));
83     EXPECT_TRUE(f2.compress);
84     EXPECT_TRUE(f2.final);
85 }
86 
TEST(WebSocketPerMessageDeflateTest,TestDeflateInflateMultipleFrame)87 TEST(WebSocketPerMessageDeflateTest, TestDeflateInflateMultipleFrame)
88 {
89     WebSocketPerMessageDeflate c;
90     WebSocketFrame::OpCode text = WebSocketFrame::OpCodeText;
91     c.enable(8, WebSocketDeflater::DoNotTakeOverContext);
92     size_t length = 64 * 1024;
93     std::string payload;
94     std::string expected;
95     std::string actual;
96     std::string inflated;
97     // Generate string by a linear congruential generator.
98     uint64_t r = 0;
99     for (size_t i = 0; i < length; ++i) {
100         payload += 'a' + (r % 25);
101         r = (r * 12345 + 1103515245) % (static_cast<uint64_t>(1) << 31);
102     }
103 
104     WebSocketFrame frame(text, &payload[0], payload.size(), WebSocketFrame::Final);
105     ASSERT_TRUE(c.deflate(frame));
106     ASSERT_TRUE(frame.final);
107     ASSERT_TRUE(frame.compress);
108     expected = std::string(frame.payload, frame.payloadLength);
109     for (size_t i = 0; i < length; ++i) {
110         WebSocketFrame::OpCode opcode = !i ? text : WebSocketFrame::OpCodeContinuation;
111         c.resetDeflateBuffer();
112         WebSocketFrame frame(opcode, &payload[i], 1);
113         frame.final = (i == length - 1);
114 
115         ASSERT_TRUE(c.deflate(frame));
116         ASSERT_EQ(i == length - 1, frame.final);
117         ASSERT_EQ(!i, frame.compress);
118         actual += std::string(frame.payload, frame.payloadLength);
119     }
120     EXPECT_EQ(expected, actual);
121 
122     for (size_t i = 0; i < actual.size(); ++i) {
123         WebSocketFrame::OpCode opcode = !i ? text : WebSocketFrame::OpCodeContinuation;
124         c.resetInflateBuffer();
125         WebSocketFrame frame(opcode, &actual[i], 1);
126         frame.final = (i == actual.size() - 1);
127         frame.compress = !i;
128 
129         ASSERT_TRUE(c.inflate(frame));
130         ASSERT_EQ(i == actual.size() - 1, frame.final);
131         ASSERT_FALSE(frame.compress);
132         inflated += std::string(frame.payload, frame.payloadLength);
133     }
134     EXPECT_EQ(payload, inflated);
135 }
136 
TEST(WebSocketPerMessageDeflateTest,TestDeflateBinary)137 TEST(WebSocketPerMessageDeflateTest, TestDeflateBinary)
138 {
139     WebSocketPerMessageDeflate c;
140     c.enable(8, WebSocketDeflater::TakeOverContext);
141     WebSocketFrame::OpCode opcode = WebSocketFrame::OpCodeBinary;
142     WebSocketFrame f1(opcode, "Hello", 5, WebSocketFrame::Final);
143 
144     ASSERT_TRUE(c.deflate(f1));
145     EXPECT_EQ(7u, f1.payloadLength);
146     EXPECT_EQ(0, memcmp("\xf2\x48\xcd\xc9\xc9\x07\x00", f1.payload, f1.payloadLength));
147     EXPECT_EQ(opcode, f1.opCode);
148     EXPECT_TRUE(f1.compress);
149     EXPECT_TRUE(f1.final);
150 }
151 
TEST(WebSocketPerMessageDeflateTest,TestDeflateEmptyFrame)152 TEST(WebSocketPerMessageDeflateTest, TestDeflateEmptyFrame)
153 {
154     WebSocketPerMessageDeflate c;
155     c.enable(8, WebSocketDeflater::TakeOverContext);
156     WebSocketFrame f1(WebSocketFrame::OpCodeText, "Hello", 5);
157     WebSocketFrame f2(WebSocketFrame::OpCodeContinuation, "", 0, WebSocketFrame::Final);
158 
159     ASSERT_TRUE(c.deflate(f1));
160     EXPECT_EQ(0u, f1.payloadLength);
161     EXPECT_FALSE(f1.final);
162     EXPECT_TRUE(f1.compress);
163 
164     c.resetDeflateBuffer();
165     ASSERT_TRUE(c.deflate(f2));
166     EXPECT_EQ(7u, f2.payloadLength);
167     EXPECT_EQ(0, memcmp("\xf2\x48\xcd\xc9\xc9\x07\x00", f2.payload, f2.payloadLength));
168     EXPECT_TRUE(f2.final);
169     EXPECT_FALSE(f2.compress);
170 }
171 
TEST(WebSocketPerMessageDeflateTest,TestDeflateEmptyMessages)172 TEST(WebSocketPerMessageDeflateTest, TestDeflateEmptyMessages)
173 {
174     WebSocketPerMessageDeflate c;
175     c.enable(8, WebSocketDeflater::TakeOverContext);
176     WebSocketFrame f1(WebSocketFrame::OpCodeText, "", 0);
177     WebSocketFrame f2(WebSocketFrame::OpCodeContinuation, "", 0, WebSocketFrame::Final);
178     WebSocketFrame f3(WebSocketFrame::OpCodeText, "", 0, WebSocketFrame::Final);
179     WebSocketFrame f4(WebSocketFrame::OpCodeText, "", 0, WebSocketFrame::Final);
180     WebSocketFrame f5(WebSocketFrame::OpCodeText, "Hello", 5, WebSocketFrame::Final);
181 
182     ASSERT_TRUE(c.deflate(f1));
183     EXPECT_EQ(0u, f1.payloadLength);
184     EXPECT_FALSE(f1.final);
185     EXPECT_TRUE(f1.compress);
186 
187     c.resetDeflateBuffer();
188     ASSERT_TRUE(c.deflate(f2));
189     EXPECT_EQ(1u, f2.payloadLength);
190     EXPECT_EQ(0, memcmp("\x00", f2.payload, f2.payloadLength));
191     EXPECT_TRUE(f2.final);
192     EXPECT_FALSE(f2.compress);
193 
194     c.resetDeflateBuffer();
195     ASSERT_TRUE(c.deflate(f3));
196     EXPECT_EQ(0u, f3.payloadLength);
197     EXPECT_TRUE(f3.final);
198     EXPECT_FALSE(f3.compress);
199 
200     c.resetDeflateBuffer();
201     ASSERT_TRUE(c.deflate(f4));
202     EXPECT_EQ(0u, f4.payloadLength);
203     EXPECT_TRUE(f4.final);
204     EXPECT_FALSE(f4.compress);
205 
206     c.resetDeflateBuffer();
207     ASSERT_TRUE(c.deflate(f5));
208     EXPECT_EQ(7u, f5.payloadLength);
209     EXPECT_EQ(0, memcmp("\xf2\x48\xcd\xc9\xc9\x07\x00", f5.payload, f5.payloadLength));
210     EXPECT_TRUE(f5.final);
211     EXPECT_TRUE(f5.compress);
212 }
213 
TEST(WebSocketPerMessageDeflateTest,TestControlMessage)214 TEST(WebSocketPerMessageDeflateTest, TestControlMessage)
215 {
216     WebSocketPerMessageDeflate c;
217     c.enable(8, WebSocketDeflater::TakeOverContext);
218     WebSocketFrame::OpCode opcode = WebSocketFrame::OpCodeClose;
219     WebSocketFrame f1(opcode, "Hello", 5, WebSocketFrame::Final);
220 
221     ASSERT_TRUE(c.deflate(f1));
222     EXPECT_TRUE(f1.final);
223     EXPECT_FALSE(f1.compress);
224     EXPECT_EQ(std::string("Hello"), std::string(f1.payload, f1.payloadLength));
225 }
226 
TEST(WebSocketPerMessageDeflateTest,TestDeflateControlMessageBetweenTextFrames)227 TEST(WebSocketPerMessageDeflateTest, TestDeflateControlMessageBetweenTextFrames)
228 {
229     WebSocketPerMessageDeflate c;
230     c.enable(8, WebSocketDeflater::TakeOverContext);
231     WebSocketFrame::OpCode close = WebSocketFrame::OpCodeClose;
232     WebSocketFrame::OpCode text = WebSocketFrame::OpCodeText;
233     WebSocketFrame::OpCode continuation = WebSocketFrame::OpCodeContinuation;
234     WebSocketFrame f1(text, "Hello", 5);
235     WebSocketFrame f2(close, "close", 5, WebSocketFrame::Final);
236     WebSocketFrame f3(continuation, "", 0, WebSocketFrame::Final);
237 
238     std::vector<char> compressed;
239     ASSERT_TRUE(c.deflate(f1));
240     EXPECT_FALSE(f1.final);
241     EXPECT_TRUE(f1.compress);
242     std::copy(&f1.payload[0], &f1.payload[f1.payloadLength], std::inserter(compressed, compressed.end()));
243 
244     c.resetDeflateBuffer();
245     ASSERT_TRUE(c.deflate(f2));
246     EXPECT_TRUE(f2.final);
247     EXPECT_FALSE(f2.compress);
248     EXPECT_EQ(std::string("close"), std::string(f2.payload, f2.payloadLength));
249 
250     c.resetDeflateBuffer();
251     ASSERT_TRUE(c.deflate(f3));
252     EXPECT_TRUE(f3.final);
253     EXPECT_FALSE(f3.compress);
254     std::copy(&f3.payload[0], &f3.payload[f3.payloadLength], std::inserter(compressed, compressed.end()));
255 
256     EXPECT_EQ(7u, compressed.size());
257     EXPECT_EQ(0, memcmp("\xf2\x48\xcd\xc9\xc9\x07\x00", &compressed[0], compressed.size()));
258 }
259 
TEST(WebSocketPerMessageDeflateTest,TestInflate)260 TEST(WebSocketPerMessageDeflateTest, TestInflate)
261 {
262     WebSocketPerMessageDeflate c;
263     c.enable(8, WebSocketDeflater::TakeOverContext);
264     WebSocketFrame::OpCode opcode = WebSocketFrame::OpCodeText;
265     WebSocketFrame::OpCode continuation = WebSocketFrame::OpCodeContinuation;
266     std::string expected = "HelloHi!Hello";
267     std::string actual;
268     WebSocketFrame f1(opcode, "\xf2\x48\xcd\xc9\xc9\x07\x00", 7, WebSocketFrame::Final | WebSocketFrame::Compress);
269     WebSocketFrame f2(continuation, "Hi!", 3, WebSocketFrame::Final);
270     WebSocketFrame f3(opcode, "\xf2\x00\x11\x00\x00", 5, WebSocketFrame::Final | WebSocketFrame::Compress);
271 
272     ASSERT_TRUE(c.inflate(f1));
273     EXPECT_EQ(5u, f1.payloadLength);
274     EXPECT_EQ(std::string("Hello"), std::string(f1.payload, f1.payloadLength));
275     EXPECT_FALSE(f1.compress);
276     EXPECT_TRUE(f1.final);
277 
278     c.resetInflateBuffer();
279     ASSERT_TRUE(c.inflate(f2));
280     EXPECT_EQ(3u, f2.payloadLength);
281     EXPECT_EQ(std::string("Hi!"), std::string(f2.payload, f2.payloadLength));
282     EXPECT_FALSE(f2.compress);
283     EXPECT_TRUE(f2.final);
284 
285     c.resetInflateBuffer();
286     ASSERT_TRUE(c.inflate(f3));
287     EXPECT_EQ(5u, f3.payloadLength);
288     EXPECT_EQ(std::string("Hello"), std::string(f3.payload, f3.payloadLength));
289     EXPECT_FALSE(f3.compress);
290     EXPECT_TRUE(f3.final);
291 }
292 
TEST(WebSocketPerMessageDeflateTest,TestInflateMultipleBlocksOverMultipleFrames)293 TEST(WebSocketPerMessageDeflateTest, TestInflateMultipleBlocksOverMultipleFrames)
294 {
295     WebSocketPerMessageDeflate c;
296     c.enable(8, WebSocketDeflater::TakeOverContext);
297     WebSocketFrame::OpCode opcode = WebSocketFrame::OpCodeText;
298     WebSocketFrame::OpCode continuation = WebSocketFrame::OpCodeContinuation;
299     std::string expected = "HelloHello";
300     std::string actual;
301     WebSocketFrame f1(opcode, "\xf2\x48\xcd\xc9\xc9\x07\x00\x00\x00\xff\xff", 11, WebSocketFrame::Compress);
302     WebSocketFrame f2(continuation, "\xf2\x00\x11\x00\x00", 5, WebSocketFrame::Final);
303 
304     ASSERT_TRUE(c.inflate(f1));
305     EXPECT_FALSE(f1.compress);
306     EXPECT_FALSE(f1.final);
307     actual += std::string(f1.payload, f1.payloadLength);
308 
309     c.resetInflateBuffer();
310     ASSERT_TRUE(c.inflate(f2));
311     EXPECT_FALSE(f2.compress);
312     EXPECT_TRUE(f2.final);
313     actual += std::string(f2.payload, f2.payloadLength);
314 
315     EXPECT_EQ(expected, actual);
316 }
317 
TEST(WebSocketPerMessageDeflateTest,TestInflateEmptyFrame)318 TEST(WebSocketPerMessageDeflateTest, TestInflateEmptyFrame)
319 {
320     WebSocketPerMessageDeflate c;
321     c.enable(8, WebSocketDeflater::TakeOverContext);
322     WebSocketFrame::OpCode opcode = WebSocketFrame::OpCodeText;
323     WebSocketFrame::OpCode continuation = WebSocketFrame::OpCodeContinuation;
324     WebSocketFrame f1(opcode, "", 0, WebSocketFrame::Compress);
325     WebSocketFrame f2(continuation, "\xf2\x48\xcd\xc9\xc9\x07\x00", 7, WebSocketFrame::Final);
326 
327     ASSERT_TRUE(c.inflate(f1));
328     EXPECT_EQ(0u, f1.payloadLength);
329     EXPECT_FALSE(f1.compress);
330     EXPECT_FALSE(f1.final);
331 
332     c.resetInflateBuffer();
333     ASSERT_TRUE(c.inflate(f2));
334     EXPECT_EQ(5u, f2.payloadLength);
335     EXPECT_EQ(std::string("Hello"), std::string(f2.payload, f2.payloadLength));
336     EXPECT_FALSE(f2.compress);
337     EXPECT_TRUE(f2.final);
338 }
339 
TEST(WebSocketPerMessageDeflateTest,TestInflateControlMessageBetweenTextFrames)340 TEST(WebSocketPerMessageDeflateTest, TestInflateControlMessageBetweenTextFrames)
341 {
342     WebSocketPerMessageDeflate c;
343     c.enable(8, WebSocketDeflater::TakeOverContext);
344     WebSocketFrame::OpCode close = WebSocketFrame::OpCodeClose;
345     WebSocketFrame::OpCode text = WebSocketFrame::OpCodeText;
346     WebSocketFrame f1(text, "\xf2\x48", 2, WebSocketFrame::Compress);
347     WebSocketFrame f2(close, "close", 5, WebSocketFrame::Final);
348     WebSocketFrame f3(text, "\xcd\xc9\xc9\x07\x00", 5, WebSocketFrame::Final);
349 
350     std::vector<char> decompressed;
351     ASSERT_TRUE(c.inflate(f1));
352     EXPECT_FALSE(f1.final);
353     EXPECT_FALSE(f1.compress);
354     std::copy(&f1.payload[0], &f1.payload[f1.payloadLength], std::inserter(decompressed, decompressed.end()));
355 
356     c.resetInflateBuffer();
357     ASSERT_TRUE(c.inflate(f2));
358     EXPECT_TRUE(f2.final);
359     EXPECT_FALSE(f2.compress);
360     EXPECT_EQ(std::string("close"), std::string(f2.payload, f2.payloadLength));
361 
362     c.resetInflateBuffer();
363     ASSERT_TRUE(c.inflate(f3));
364     std::copy(&f3.payload[0], &f3.payload[f3.payloadLength], std::inserter(decompressed, decompressed.end()));
365     EXPECT_TRUE(f3.final);
366     EXPECT_FALSE(f3.compress);
367 
368     EXPECT_EQ(std::string("Hello"), std::string(&decompressed[0], decompressed.size()));
369 }
370 
TEST(WebSocketPerMessageDeflateTest,TestNotEnabled)371 TEST(WebSocketPerMessageDeflateTest, TestNotEnabled)
372 {
373     WebSocketPerMessageDeflate c;
374     WebSocketFrame::OpCode opcode = WebSocketFrame::OpCodeClose;
375     WebSocketFrame f1(opcode, "Hello", 5, WebSocketFrame::Final | WebSocketFrame::Compress);
376     WebSocketFrame f2(opcode, "\xf2\x48\xcd\xc9\xc9\x07\x00", 7, WebSocketFrame::Final | WebSocketFrame::Compress);
377 
378     // deflate and inflate return true and do nothing if it is not enabled.
379     ASSERT_TRUE(c.deflate(f1));
380     ASSERT_TRUE(f1.compress);
381     ASSERT_TRUE(c.inflate(f2));
382     ASSERT_TRUE(f2.compress);
383 }
384 
processResponse(const HashMap<String,String> & serverParameters)385 bool processResponse(const HashMap<String, String>& serverParameters)
386 {
387     return WebSocketPerMessageDeflate().createExtensionProcessor()->processResponse(serverParameters);
388 }
389 
TEST(WebSocketPerMessageDeflateTest,TestValidNegotiationResponse)390 TEST(WebSocketPerMessageDeflateTest, TestValidNegotiationResponse)
391 {
392     {
393         HashMap<String, String> params;
394         EXPECT_TRUE(processResponse(params));
395     }
396     {
397         HashMap<String, String> params;
398         params.add("client_max_window_bits", "15");
399         EXPECT_TRUE(processResponse(params));
400     }
401     {
402         HashMap<String, String> params;
403         params.add("client_max_window_bits", "8");
404         EXPECT_TRUE(processResponse(params));
405     }
406     {
407         HashMap<String, String> params;
408         params.add("client_max_window_bits", "15");
409         params.add("client_no_context_takeover", String());
410         EXPECT_TRUE(processResponse(params));
411     }
412     {
413         // Unsolicited server_no_context_takeover should be ignored.
414         HashMap<String, String> params;
415         params.add("server_no_context_takeover", String());
416         EXPECT_TRUE(processResponse(params));
417     }
418     {
419         // Unsolicited server_max_window_bits should be ignored.
420         HashMap<String, String> params;
421         params.add("server_max_window_bits", "15");
422         EXPECT_TRUE(processResponse(params));
423     }
424 }
425 
TEST(WebSocketPerMessageDeflateTest,TestInvalidNegotiationResponse)426 TEST(WebSocketPerMessageDeflateTest, TestInvalidNegotiationResponse)
427 {
428     {
429         HashMap<String, String> params;
430         params.add("method", "deflate");
431         EXPECT_FALSE(processResponse(params));
432     }
433     {
434         HashMap<String, String> params;
435         params.add("foo", "");
436         EXPECT_FALSE(processResponse(params));
437     }
438     {
439         HashMap<String, String> params;
440         params.add("foo", "bar");
441         EXPECT_FALSE(processResponse(params));
442     }
443     {
444         HashMap<String, String> params;
445         params.add("client_max_window_bits", "");
446         EXPECT_FALSE(processResponse(params));
447     }
448     {
449         HashMap<String, String> params;
450         params.add("client_max_window_bits", "16");
451         EXPECT_FALSE(processResponse(params));
452     }
453     {
454         HashMap<String, String> params;
455         params.add("client_max_window_bits", "7");
456         EXPECT_FALSE(processResponse(params));
457     }
458     {
459         HashMap<String, String> params;
460         params.add("client_max_window_bits", "+15");
461         EXPECT_FALSE(processResponse(params));
462     }
463     {
464         HashMap<String, String> params;
465         params.add("client_max_window_bits", "0x9");
466         EXPECT_FALSE(processResponse(params));
467     }
468     {
469         HashMap<String, String> params;
470         params.add("client_max_window_bits", "08");
471         EXPECT_FALSE(processResponse(params));
472     }
473     {
474         // Unsolicited server_no_context_takeover should be verified though it is not used.
475         HashMap<String, String> params;
476         params.add("server_no_context_takeover", "foo");
477         EXPECT_FALSE(processResponse(params));
478     }
479     {
480         // Unsolicited server_max_window_bits should be verified though it is not used.
481         HashMap<String, String> params;
482         params.add("server_max_window_bits", "7");
483         EXPECT_FALSE(processResponse(params));
484     }
485     {
486         // Unsolicited server_max_window_bits should be verified though it is not used.
487         HashMap<String, String> params;
488         params.add("server_max_window_bits", "bar");
489         EXPECT_FALSE(processResponse(params));
490     }
491     {
492         // Unsolicited server_max_window_bits should be verified though it is not used.
493         HashMap<String, String> params;
494         params.add("server_max_window_bits", "16");
495         EXPECT_FALSE(processResponse(params));
496     }
497     {
498         // Unsolicited server_max_window_bits should be verified though it is not used.
499         HashMap<String, String> params;
500         params.add("server_max_window_bits", "08");
501         EXPECT_FALSE(processResponse(params));
502     }
503 }
504 
TEST(WebSocketPerMessageDeflateTest,TestNegotiationRequest)505 TEST(WebSocketPerMessageDeflateTest, TestNegotiationRequest)
506 {
507     String actual = WebSocketPerMessageDeflate().createExtensionProcessor()->handshakeString();
508     EXPECT_EQ(String("permessage-deflate; client_max_window_bits"), actual);
509 }
510 
511 } // namespace
512 } // namespace blink
513