1 // Copyright 2014 The Chromium Authors
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 "net/server/web_socket_encoder.h"
6
7 #include <stddef.h>
8
9 #include "base/strings/strcat.h"
10 #include "net/websockets/websocket_deflate_parameters.h"
11 #include "net/websockets/websocket_extension.h"
12 #include "net/websockets/websocket_frame.h"
13 #include "testing/gtest/include/gtest/gtest.h"
14
15 namespace net {
16
TEST(WebSocketEncoderHandshakeTest,EmptyRequestShouldBeRejected)17 TEST(WebSocketEncoderHandshakeTest, EmptyRequestShouldBeRejected) {
18 WebSocketDeflateParameters params;
19 std::unique_ptr<WebSocketEncoder> server =
20 WebSocketEncoder::CreateServer("", ¶ms);
21
22 EXPECT_FALSE(server);
23 }
24
TEST(WebSocketEncoderHandshakeTest,CreateServerWithoutClientMaxWindowBitsParameter)25 TEST(WebSocketEncoderHandshakeTest,
26 CreateServerWithoutClientMaxWindowBitsParameter) {
27 WebSocketDeflateParameters params;
28 std::unique_ptr<WebSocketEncoder> server =
29 WebSocketEncoder::CreateServer("permessage-deflate", ¶ms);
30
31 ASSERT_TRUE(server);
32 EXPECT_TRUE(server->deflate_enabled());
33 EXPECT_EQ("permessage-deflate", params.AsExtension().ToString());
34 }
35
TEST(WebSocketEncoderHandshakeTest,CreateServerWithServerNoContextTakeoverParameter)36 TEST(WebSocketEncoderHandshakeTest,
37 CreateServerWithServerNoContextTakeoverParameter) {
38 WebSocketDeflateParameters params;
39 std::unique_ptr<WebSocketEncoder> server = WebSocketEncoder::CreateServer(
40 "permessage-deflate; server_no_context_takeover", ¶ms);
41 ASSERT_TRUE(server);
42 EXPECT_TRUE(server->deflate_enabled());
43 EXPECT_EQ("permessage-deflate; server_no_context_takeover",
44 params.AsExtension().ToString());
45 }
46
TEST(WebSocketEncoderHandshakeTest,FirstExtensionShouldBeChosen)47 TEST(WebSocketEncoderHandshakeTest, FirstExtensionShouldBeChosen) {
48 WebSocketDeflateParameters params;
49 std::unique_ptr<WebSocketEncoder> server = WebSocketEncoder::CreateServer(
50 "permessage-deflate; server_no_context_takeover,"
51 "permessage-deflate; server_max_window_bits=15",
52 ¶ms);
53
54 ASSERT_TRUE(server);
55 EXPECT_TRUE(server->deflate_enabled());
56 EXPECT_EQ("permessage-deflate; server_no_context_takeover",
57 params.AsExtension().ToString());
58 }
59
TEST(WebSocketEncoderHandshakeTest,FirstValidExtensionShouldBeChosen)60 TEST(WebSocketEncoderHandshakeTest, FirstValidExtensionShouldBeChosen) {
61 WebSocketDeflateParameters params;
62 std::unique_ptr<WebSocketEncoder> server = WebSocketEncoder::CreateServer(
63 "permessage-deflate; Xserver_no_context_takeover,"
64 "permessage-deflate; server_max_window_bits=15",
65 ¶ms);
66
67 ASSERT_TRUE(server);
68 EXPECT_TRUE(server->deflate_enabled());
69 EXPECT_EQ("permessage-deflate; server_max_window_bits=15",
70 params.AsExtension().ToString());
71 }
72
TEST(WebSocketEncoderHandshakeTest,AllExtensionsAreUnknownOrMalformed)73 TEST(WebSocketEncoderHandshakeTest, AllExtensionsAreUnknownOrMalformed) {
74 WebSocketDeflateParameters params;
75 std::unique_ptr<WebSocketEncoder> server =
76 WebSocketEncoder::CreateServer("unknown, permessage-deflate; x", ¶ms);
77
78 ASSERT_TRUE(server);
79 EXPECT_FALSE(server->deflate_enabled());
80 }
81
82 class WebSocketEncoderTest : public testing::Test {
83 public:
84 WebSocketEncoderTest() = default;
85
SetUp()86 void SetUp() override {
87 std::string response_extensions;
88 server_ = WebSocketEncoder::CreateServer();
89 EXPECT_EQ(std::string(), response_extensions);
90 client_ = WebSocketEncoder::CreateClient("");
91 }
92
93 // Generate deflated and continuous frames from original text.
94 // The length of `original_text` must be longer than 4*partitions.
GenerateFragmentedFrames(std::string original_text,int mask,int partitions,bool compressed)95 std::vector<std::string> GenerateFragmentedFrames(std::string original_text,
96 int mask,
97 int partitions,
98 bool compressed) {
99 constexpr uint8_t kFinalBit = 0x80;
100 constexpr uint8_t kReserved1Bit = 0x40;
101 constexpr uint8_t kMaskBit = 0x80;
102
103 // A frame consists of 3 or 2 parts: header, (mask) and payload.
104 // The first two bytes of `encoded` are the header of the frame.
105 // If there is a mask, the four bytes of the mask is inserted after the
106 // header. Finally, message contents come.
107 std::string encoded;
108 int num_mask_header;
109 char mask_key_bit;
110 std::string mask_bytes;
111
112 if (mask == 0) {
113 server_->EncodeTextFrame(original_text, mask, &encoded);
114 num_mask_header = 0;
115 mask_key_bit = 0;
116 } else {
117 client_->EncodeTextFrame(original_text, mask, &encoded);
118 num_mask_header = 4;
119 mask_key_bit = kMaskBit;
120 mask_bytes = encoded.substr(2, 4);
121 }
122 int divide_length =
123 (static_cast<int>(encoded.length()) - 2 - num_mask_header) / partitions;
124 divide_length -= divide_length % 4;
125 std::vector<std::string> encoded_frames(partitions);
126 std::string payload;
127 std::string header;
128
129 for (int i = 0; i < partitions; ++i) {
130 char first_byte = 0;
131 if (i == 0)
132 first_byte |= WebSocketFrameHeader::OpCodeEnum::kOpCodeText;
133 else
134 first_byte |= WebSocketFrameHeader::OpCodeEnum::kOpCodeContinuation;
135 if (i == partitions - 1)
136 first_byte |= kFinalBit;
137 if (compressed)
138 first_byte |= kReserved1Bit;
139
140 const int position = 2 + num_mask_header + i * divide_length;
141 const int length =
142 i < partitions - 1 ? divide_length : encoded.length() - position;
143 payload = encoded.substr(position, length);
144 header = {first_byte, static_cast<char>(payload.length() | mask_key_bit)};
145 encoded_frames[i] += header + mask_bytes + payload;
146 }
147
148 return encoded_frames;
149 }
150
151 protected:
152 std::unique_ptr<WebSocketEncoder> server_;
153 std::unique_ptr<WebSocketEncoder> client_;
154 };
155
156 class WebSocketEncoderCompressionTest : public WebSocketEncoderTest {
157 public:
WebSocketEncoderCompressionTest()158 WebSocketEncoderCompressionTest() : WebSocketEncoderTest() {}
159
SetUp()160 void SetUp() override {
161 WebSocketDeflateParameters params;
162 server_ = WebSocketEncoder::CreateServer(
163 "permessage-deflate; client_max_window_bits", ¶ms);
164 ASSERT_TRUE(server_);
165 EXPECT_TRUE(server_->deflate_enabled());
166 EXPECT_EQ("permessage-deflate; client_max_window_bits=15",
167 params.AsExtension().ToString());
168 client_ = WebSocketEncoder::CreateClient(params.AsExtension().ToString());
169 }
170 };
171
TEST_F(WebSocketEncoderTest,DeflateDisabledEncoder)172 TEST_F(WebSocketEncoderTest, DeflateDisabledEncoder) {
173 std::unique_ptr<WebSocketEncoder> server = WebSocketEncoder::CreateServer();
174 std::unique_ptr<WebSocketEncoder> client = WebSocketEncoder::CreateClient("");
175
176 ASSERT_TRUE(server);
177 ASSERT_TRUE(client);
178
179 EXPECT_FALSE(server->deflate_enabled());
180 EXPECT_FALSE(client->deflate_enabled());
181 }
182
TEST_F(WebSocketEncoderTest,ClientToServer)183 TEST_F(WebSocketEncoderTest, ClientToServer) {
184 std::string frame("ClientToServer");
185 int mask = 123456;
186 std::string encoded;
187 int bytes_consumed;
188 std::string decoded;
189
190 client_->EncodeTextFrame(frame, mask, &encoded);
191 EXPECT_EQ(WebSocketParseResult::FRAME_OK_FINAL,
192 server_->DecodeFrame(encoded, &bytes_consumed, &decoded));
193 EXPECT_EQ("ClientToServer", decoded);
194 EXPECT_EQ((int)encoded.length(), bytes_consumed);
195
196 std::string partial = encoded.substr(0, encoded.length() - 2);
197 EXPECT_EQ(WebSocketParseResult::FRAME_INCOMPLETE,
198 server_->DecodeFrame(partial, &bytes_consumed, &decoded));
199
200 std::string extra = encoded + "more stuff";
201 EXPECT_EQ(WebSocketParseResult::FRAME_OK_FINAL,
202 server_->DecodeFrame(extra, &bytes_consumed, &decoded));
203 EXPECT_EQ("ClientToServer", decoded);
204 EXPECT_EQ((int)encoded.length(), bytes_consumed);
205
206 EXPECT_EQ(
207 WebSocketParseResult::FRAME_ERROR,
208 server_->DecodeFrame(std::string("abcde"), &bytes_consumed, &decoded));
209 }
210
TEST_F(WebSocketEncoderTest,ServerToClient)211 TEST_F(WebSocketEncoderTest, ServerToClient) {
212 std::string frame("ServerToClient");
213 int mask = 0;
214 std::string encoded;
215 int bytes_consumed;
216 std::string decoded;
217
218 server_->EncodeTextFrame(frame, mask, &encoded);
219 EXPECT_EQ(WebSocketParseResult::FRAME_OK_FINAL,
220 client_->DecodeFrame(encoded, &bytes_consumed, &decoded));
221 EXPECT_EQ("ServerToClient", decoded);
222 EXPECT_EQ((int)encoded.length(), bytes_consumed);
223
224 std::string partial = encoded.substr(0, encoded.length() - 2);
225 EXPECT_EQ(WebSocketParseResult::FRAME_INCOMPLETE,
226 client_->DecodeFrame(partial, &bytes_consumed, &decoded));
227
228 std::string extra = encoded + "more stuff";
229 EXPECT_EQ(WebSocketParseResult::FRAME_OK_FINAL,
230 client_->DecodeFrame(extra, &bytes_consumed, &decoded));
231 EXPECT_EQ("ServerToClient", decoded);
232 EXPECT_EQ((int)encoded.length(), bytes_consumed);
233
234 EXPECT_EQ(
235 WebSocketParseResult::FRAME_ERROR,
236 client_->DecodeFrame(std::string("abcde"), &bytes_consumed, &decoded));
237 }
238
TEST_F(WebSocketEncoderTest,DecodeFragmentedMessageClientToServerDivided2)239 TEST_F(WebSocketEncoderTest, DecodeFragmentedMessageClientToServerDivided2) {
240 const std::string kOriginalText = "abcdefghijklmnop";
241 constexpr int kMask = 123456;
242 constexpr bool kCompressed = false;
243 constexpr int kPartitions = 2;
244 ASSERT_GT(static_cast<int>(kOriginalText.length()), 4 * kPartitions);
245 std::vector<std::string> encoded_frames =
246 GenerateFragmentedFrames(kOriginalText, kMask, kPartitions, kCompressed);
247 ASSERT_EQ(kPartitions, static_cast<int>(encoded_frames.size()));
248
249 const std::string& kEncodedFirstFrame = encoded_frames[0];
250 const std::string& kEncodedLastFrame = encoded_frames[1];
251
252 int bytes_consumed;
253 std::string decoded;
254
255 // kEncodedFirstFrame -> kEncodedLastFrame
256 EXPECT_EQ(
257 WebSocketParseResult::FRAME_OK_MIDDLE,
258 server_->DecodeFrame(kEncodedFirstFrame, &bytes_consumed, &decoded));
259 EXPECT_EQ("", decoded);
260 EXPECT_EQ(static_cast<int>(kEncodedFirstFrame.length()), bytes_consumed);
261 EXPECT_EQ(WebSocketParseResult::FRAME_OK_FINAL,
262 server_->DecodeFrame(kEncodedLastFrame, &bytes_consumed, &decoded));
263 EXPECT_EQ("abcdefghijklmnop", decoded);
264 EXPECT_EQ(static_cast<int>(kEncodedLastFrame.length()), bytes_consumed);
265 }
266
TEST_F(WebSocketEncoderTest,DecodeFragmentedMessageClientToServerDivided3)267 TEST_F(WebSocketEncoderTest, DecodeFragmentedMessageClientToServerDivided3) {
268 const std::string kOriginalText = "abcdefghijklmnop";
269 constexpr int kMask = 123456;
270 constexpr bool kCompressed = false;
271 constexpr int kPartitions = 3;
272 ASSERT_GT(static_cast<int>(kOriginalText.length()), 4 * kPartitions);
273 std::vector<std::string> encoded_frames =
274 GenerateFragmentedFrames(kOriginalText, kMask, kPartitions, kCompressed);
275 ASSERT_EQ(kPartitions, static_cast<int>(encoded_frames.size()));
276
277 const std::string& kEncodedFirstFrame = encoded_frames[0];
278 const std::string& kEncodedSecondFrame = encoded_frames[1];
279 const std::string& kEncodedLastFrame = encoded_frames[2];
280
281 int bytes_consumed;
282 std::string decoded;
283
284 // kEncodedFirstFrame -> kEncodedSecondFrame -> kEncodedLastFrame
285 EXPECT_EQ(
286 WebSocketParseResult::FRAME_OK_MIDDLE,
287 server_->DecodeFrame(kEncodedFirstFrame, &bytes_consumed, &decoded));
288 EXPECT_EQ("", decoded);
289 EXPECT_EQ(static_cast<int>(kEncodedFirstFrame.length()), bytes_consumed);
290 EXPECT_EQ(
291 WebSocketParseResult::FRAME_OK_MIDDLE,
292 server_->DecodeFrame(kEncodedSecondFrame, &bytes_consumed, &decoded));
293 EXPECT_EQ("", decoded);
294 EXPECT_EQ(static_cast<int>(kEncodedSecondFrame.length()), bytes_consumed);
295 EXPECT_EQ(WebSocketParseResult::FRAME_OK_FINAL,
296 server_->DecodeFrame(kEncodedLastFrame, &bytes_consumed, &decoded));
297 EXPECT_EQ("abcdefghijklmnop", decoded);
298 EXPECT_EQ(static_cast<int>(kEncodedLastFrame.length()), bytes_consumed);
299 }
300
TEST_F(WebSocketEncoderTest,DecodeFragmentedMessageServerToClientDivided2)301 TEST_F(WebSocketEncoderTest, DecodeFragmentedMessageServerToClientDivided2) {
302 const std::string kOriginalText = "abcdefghijklmnop";
303 constexpr int kMask = 0;
304 constexpr bool kCompressed = false;
305
306 constexpr int kPartitions = 2;
307 ASSERT_GT(static_cast<int>(kOriginalText.length()), 4 * kPartitions);
308 std::vector<std::string> encoded_frames =
309 GenerateFragmentedFrames(kOriginalText, kMask, kPartitions, kCompressed);
310 ASSERT_EQ(kPartitions, static_cast<int>(encoded_frames.size()));
311
312 const std::string& kEncodedFirstFrame = encoded_frames[0];
313 const std::string& kEncodedLastFrame = encoded_frames[1];
314
315 int bytes_consumed;
316 std::string decoded;
317
318 // kEncodedFirstFrame -> kEncodedLastFrame
319 EXPECT_EQ(
320 WebSocketParseResult::FRAME_OK_MIDDLE,
321 client_->DecodeFrame(kEncodedFirstFrame, &bytes_consumed, &decoded));
322 EXPECT_EQ("", decoded);
323 EXPECT_EQ(static_cast<int>(kEncodedFirstFrame.length()), bytes_consumed);
324 EXPECT_EQ(WebSocketParseResult::FRAME_OK_FINAL,
325 client_->DecodeFrame(kEncodedLastFrame, &bytes_consumed, &decoded));
326 EXPECT_EQ("abcdefghijklmnop", decoded);
327 EXPECT_EQ(static_cast<int>(kEncodedLastFrame.length()), bytes_consumed);
328 }
329
TEST_F(WebSocketEncoderTest,DecodeFragmentedMessageServerToClientDivided3)330 TEST_F(WebSocketEncoderTest, DecodeFragmentedMessageServerToClientDivided3) {
331 const std::string kOriginalText = "abcdefghijklmnop";
332 constexpr int kMask = 0;
333 constexpr bool kCompressed = false;
334
335 constexpr int kPartitions = 3;
336 ASSERT_GT(static_cast<int>(kOriginalText.length()), 4 * kPartitions);
337 std::vector<std::string> encoded_frames =
338 GenerateFragmentedFrames(kOriginalText, kMask, kPartitions, kCompressed);
339 ASSERT_EQ(kPartitions, static_cast<int>(encoded_frames.size()));
340
341 const std::string& kEncodedFirstFrame = encoded_frames[0];
342 const std::string& kEncodedSecondFrame = encoded_frames[1];
343 const std::string& kEncodedLastFrame = encoded_frames[2];
344
345 int bytes_consumed;
346 std::string decoded;
347
348 // kEncodedFirstFrame -> kEncodedSecondFrame -> kEncodedLastFrame
349 EXPECT_EQ(
350 WebSocketParseResult::FRAME_OK_MIDDLE,
351 client_->DecodeFrame(kEncodedFirstFrame, &bytes_consumed, &decoded));
352 EXPECT_EQ("", decoded);
353 EXPECT_EQ(static_cast<int>(kEncodedFirstFrame.length()), bytes_consumed);
354 EXPECT_EQ(
355 WebSocketParseResult::FRAME_OK_MIDDLE,
356 client_->DecodeFrame(kEncodedSecondFrame, &bytes_consumed, &decoded));
357 EXPECT_EQ("", decoded);
358 EXPECT_EQ(static_cast<int>(kEncodedSecondFrame.length()), bytes_consumed);
359 EXPECT_EQ(WebSocketParseResult::FRAME_OK_FINAL,
360 client_->DecodeFrame(kEncodedLastFrame, &bytes_consumed, &decoded));
361 EXPECT_EQ("abcdefghijklmnop", decoded);
362 EXPECT_EQ(static_cast<int>(kEncodedLastFrame.length()), bytes_consumed);
363 }
364
TEST_F(WebSocketEncoderCompressionTest,ClientToServer)365 TEST_F(WebSocketEncoderCompressionTest, ClientToServer) {
366 std::string frame("CompressionCompressionCompressionCompression");
367 int mask = 654321;
368 std::string encoded;
369 int bytes_consumed;
370 std::string decoded;
371
372 client_->EncodeTextFrame(frame, mask, &encoded);
373 EXPECT_LT(encoded.length(), frame.length());
374 EXPECT_EQ(WebSocketParseResult::FRAME_OK_FINAL,
375 server_->DecodeFrame(encoded, &bytes_consumed, &decoded));
376 EXPECT_EQ(frame, decoded);
377 EXPECT_EQ((int)encoded.length(), bytes_consumed);
378 }
379
TEST_F(WebSocketEncoderCompressionTest,ServerToClient)380 TEST_F(WebSocketEncoderCompressionTest, ServerToClient) {
381 std::string frame("CompressionCompressionCompressionCompression");
382 int mask = 0;
383 std::string encoded;
384 int bytes_consumed;
385 std::string decoded;
386
387 server_->EncodeTextFrame(frame, mask, &encoded);
388 EXPECT_LT(encoded.length(), frame.length());
389 EXPECT_EQ(WebSocketParseResult::FRAME_OK_FINAL,
390 client_->DecodeFrame(encoded, &bytes_consumed, &decoded));
391 EXPECT_EQ(frame, decoded);
392 EXPECT_EQ((int)encoded.length(), bytes_consumed);
393 }
394
TEST_F(WebSocketEncoderCompressionTest,LongFrame)395 TEST_F(WebSocketEncoderCompressionTest, LongFrame) {
396 int length = 1000000;
397 std::string temp;
398 temp.reserve(length);
399 for (int i = 0; i < length; ++i)
400 temp += (char)('a' + (i % 26));
401
402 std::string frame;
403 frame.reserve(length);
404 for (int i = 0; i < length; ++i) {
405 int64_t j = i;
406 frame += temp[(j * j) % length];
407 }
408
409 int mask = 0;
410 std::string encoded;
411 int bytes_consumed;
412 std::string decoded;
413
414 server_->EncodeTextFrame(frame, mask, &encoded);
415 EXPECT_LT(encoded.length(), frame.length());
416 EXPECT_EQ(WebSocketParseResult::FRAME_OK_FINAL,
417 client_->DecodeFrame(encoded, &bytes_consumed, &decoded));
418 EXPECT_EQ(frame, decoded);
419 EXPECT_EQ((int)encoded.length(), bytes_consumed);
420 }
421
TEST_F(WebSocketEncoderCompressionTest,DecodeFragmentedMessageClientToServer)422 TEST_F(WebSocketEncoderCompressionTest, DecodeFragmentedMessageClientToServer) {
423 const std::string kOriginalText = "abcdefghijklmnop";
424 constexpr int kMask = 123456;
425
426 constexpr int kPartitions = 3;
427 constexpr bool kCompressed = true;
428 ASSERT_GT(static_cast<int>(kOriginalText.length()), 4 * kPartitions);
429 std::vector<std::string> encoded_frames =
430 GenerateFragmentedFrames(kOriginalText, kMask, kPartitions, kCompressed);
431 ASSERT_EQ(kPartitions, static_cast<int>(encoded_frames.size()));
432
433 const std::string& kEncodedFirstFrame = encoded_frames[0];
434 const std::string& kEncodedSecondFrame = encoded_frames[1];
435 const std::string& kEncodedLastFrame = encoded_frames[2];
436
437 int bytes_consumed;
438 std::string decoded;
439
440 // kEncodedFirstFrame -> kEncodedSecondFrame -> kEncodedLastFrame
441 EXPECT_EQ(
442 WebSocketParseResult::FRAME_OK_MIDDLE,
443 server_->DecodeFrame(kEncodedFirstFrame, &bytes_consumed, &decoded));
444 EXPECT_EQ("", decoded);
445 EXPECT_EQ(static_cast<int>(kEncodedFirstFrame.length()), bytes_consumed);
446 EXPECT_EQ(
447 WebSocketParseResult::FRAME_OK_MIDDLE,
448 server_->DecodeFrame(kEncodedSecondFrame, &bytes_consumed, &decoded));
449 EXPECT_EQ("", decoded);
450 EXPECT_EQ(static_cast<int>(kEncodedSecondFrame.length()), bytes_consumed);
451 EXPECT_EQ(WebSocketParseResult::FRAME_OK_FINAL,
452 server_->DecodeFrame(kEncodedLastFrame, &bytes_consumed, &decoded));
453 EXPECT_EQ("abcdefghijklmnop", decoded);
454 EXPECT_EQ(static_cast<int>(kEncodedLastFrame.length()), bytes_consumed);
455 }
456
TEST_F(WebSocketEncoderCompressionTest,DecodeFragmentedMessageServerToClient)457 TEST_F(WebSocketEncoderCompressionTest, DecodeFragmentedMessageServerToClient) {
458 const std::string kOriginalText = "abcdefghijklmnop";
459 constexpr int kMask = 0;
460
461 constexpr int kPartitions = 3;
462 constexpr bool kCompressed = true;
463 ASSERT_GT(static_cast<int>(kOriginalText.length()), 4 * kPartitions);
464 std::vector<std::string> encoded_frames =
465 GenerateFragmentedFrames(kOriginalText, kMask, kPartitions, kCompressed);
466 ASSERT_EQ(kPartitions, static_cast<int>(encoded_frames.size()));
467
468 const std::string& kEncodedFirstFrame = encoded_frames[0];
469 const std::string& kEncodedSecondFrame = encoded_frames[1];
470 const std::string& kEncodedLastFrame = encoded_frames[2];
471
472 int bytes_consumed;
473 std::string decoded;
474
475 // kEncodedFirstFrame -> kEncodedSecondFrame -> kEncodedLastFrame
476 decoded.clear();
477 EXPECT_EQ(
478 WebSocketParseResult::FRAME_OK_MIDDLE,
479 client_->DecodeFrame(kEncodedFirstFrame, &bytes_consumed, &decoded));
480 EXPECT_EQ("", decoded);
481 EXPECT_EQ(static_cast<int>(kEncodedFirstFrame.length()), bytes_consumed);
482 EXPECT_EQ(
483 WebSocketParseResult::FRAME_OK_MIDDLE,
484 client_->DecodeFrame(kEncodedSecondFrame, &bytes_consumed, &decoded));
485 EXPECT_EQ("", decoded);
486 EXPECT_EQ(static_cast<int>(kEncodedSecondFrame.length()), bytes_consumed);
487 EXPECT_EQ(WebSocketParseResult::FRAME_OK_FINAL,
488 client_->DecodeFrame(kEncodedLastFrame, &bytes_consumed, &decoded));
489 EXPECT_EQ("abcdefghijklmnop", decoded);
490 EXPECT_EQ(static_cast<int>(kEncodedLastFrame.length()), bytes_consumed);
491 }
492
TEST_F(WebSocketEncoderCompressionTest,CheckPongFrameNotCompressed)493 TEST_F(WebSocketEncoderCompressionTest, CheckPongFrameNotCompressed) {
494 constexpr uint8_t kReserved1Bit = 0x40;
495 const std::string kOriginalText = "abcdefghijklmnop";
496 constexpr int kMask = 0;
497 std::string encoded;
498
499 server_->EncodePongFrame(kOriginalText, kMask, &encoded);
500 EXPECT_FALSE(encoded[1] & kReserved1Bit);
501 EXPECT_EQ(kOriginalText, encoded.substr(2));
502 }
503
TEST_F(WebSocketEncoderCompressionTest,CheckCloseFrameNotCompressed)504 TEST_F(WebSocketEncoderCompressionTest, CheckCloseFrameNotCompressed) {
505 constexpr uint8_t kReserved1Bit = 0x40;
506 const std::string kOriginalText = "\x03\xe8";
507 constexpr int kMask = 0;
508 std::string encoded;
509
510 server_->EncodeCloseFrame(kOriginalText, kMask, &encoded);
511 EXPECT_FALSE(encoded[1] & kReserved1Bit);
512 EXPECT_EQ(kOriginalText, encoded.substr(2));
513 }
514
515 } // namespace net
516