OLD | NEW |
| (Empty) |
1 // Copyright (c) 2012 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 "net/websockets/websocket_frame.h" | |
6 | |
7 #include <algorithm> | |
8 #include <string> | |
9 #include <vector> | |
10 | |
11 #include "base/basictypes.h" | |
12 #include "base/command_line.h" | |
13 #include "base/logging.h" | |
14 #include "base/memory/aligned_memory.h" | |
15 #include "base/strings/string_number_conversions.h" | |
16 #include "base/strings/stringprintf.h" | |
17 #include "base/time/time.h" | |
18 #include "net/base/net_errors.h" | |
19 #include "testing/gtest/include/gtest/gtest.h" | |
20 | |
21 // Run | |
22 // out/Release/net_unittests --websocket-mask-iterations=100000 | |
23 // --gtest_filter='WebSocketFrameTestMaskBenchmark.*' | |
24 // to benchmark the MaskWebSocketFramePayload() function. | |
25 static const char kBenchmarkIterations[] = "websocket-mask-iterations"; | |
26 static const int kDefaultIterations = 10; | |
27 static const int kLongPayloadSize = 1 << 16; | |
28 | |
29 namespace net { | |
30 | |
31 TEST(WebSocketFrameHeaderTest, FrameLengths) { | |
32 struct TestCase { | |
33 const char* frame_header; | |
34 size_t frame_header_length; | |
35 uint64 frame_length; | |
36 }; | |
37 static const TestCase kTests[] = { | |
38 { "\x81\x00", 2, GG_UINT64_C(0) }, | |
39 { "\x81\x7D", 2, GG_UINT64_C(125) }, | |
40 { "\x81\x7E\x00\x7E", 4, GG_UINT64_C(126) }, | |
41 { "\x81\x7E\xFF\xFF", 4, GG_UINT64_C(0xFFFF) }, | |
42 { "\x81\x7F\x00\x00\x00\x00\x00\x01\x00\x00", 10, GG_UINT64_C(0x10000) }, | |
43 { "\x81\x7F\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF", 10, | |
44 GG_UINT64_C(0x7FFFFFFFFFFFFFFF) } | |
45 }; | |
46 static const int kNumTests = ARRAYSIZE_UNSAFE(kTests); | |
47 | |
48 for (int i = 0; i < kNumTests; ++i) { | |
49 WebSocketFrameHeader header(WebSocketFrameHeader::kOpCodeText); | |
50 header.final = true; | |
51 header.payload_length = kTests[i].frame_length; | |
52 | |
53 std::vector<char> expected_output( | |
54 kTests[i].frame_header, | |
55 kTests[i].frame_header + kTests[i].frame_header_length); | |
56 std::vector<char> output(expected_output.size()); | |
57 EXPECT_EQ(static_cast<int>(expected_output.size()), | |
58 WriteWebSocketFrameHeader( | |
59 header, NULL, &output.front(), output.size())); | |
60 EXPECT_EQ(expected_output, output); | |
61 } | |
62 } | |
63 | |
64 TEST(WebSocketFrameHeaderTest, FrameLengthsWithMasking) { | |
65 static const char kMaskingKey[] = "\xDE\xAD\xBE\xEF"; | |
66 COMPILE_ASSERT(ARRAYSIZE_UNSAFE(kMaskingKey) - 1 == | |
67 WebSocketFrameHeader::kMaskingKeyLength, | |
68 incorrect_masking_key_size); | |
69 | |
70 struct TestCase { | |
71 const char* frame_header; | |
72 size_t frame_header_length; | |
73 uint64 frame_length; | |
74 }; | |
75 static const TestCase kTests[] = { | |
76 { "\x81\x80\xDE\xAD\xBE\xEF", 6, GG_UINT64_C(0) }, | |
77 { "\x81\xFD\xDE\xAD\xBE\xEF", 6, GG_UINT64_C(125) }, | |
78 { "\x81\xFE\x00\x7E\xDE\xAD\xBE\xEF", 8, GG_UINT64_C(126) }, | |
79 { "\x81\xFE\xFF\xFF\xDE\xAD\xBE\xEF", 8, GG_UINT64_C(0xFFFF) }, | |
80 { "\x81\xFF\x00\x00\x00\x00\x00\x01\x00\x00\xDE\xAD\xBE\xEF", 14, | |
81 GG_UINT64_C(0x10000) }, | |
82 { "\x81\xFF\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xDE\xAD\xBE\xEF", 14, | |
83 GG_UINT64_C(0x7FFFFFFFFFFFFFFF) } | |
84 }; | |
85 static const int kNumTests = ARRAYSIZE_UNSAFE(kTests); | |
86 | |
87 WebSocketMaskingKey masking_key; | |
88 std::copy(kMaskingKey, | |
89 kMaskingKey + WebSocketFrameHeader::kMaskingKeyLength, | |
90 masking_key.key); | |
91 | |
92 for (int i = 0; i < kNumTests; ++i) { | |
93 WebSocketFrameHeader header(WebSocketFrameHeader::kOpCodeText); | |
94 header.final = true; | |
95 header.masked = true; | |
96 header.payload_length = kTests[i].frame_length; | |
97 | |
98 std::vector<char> expected_output( | |
99 kTests[i].frame_header, | |
100 kTests[i].frame_header + kTests[i].frame_header_length); | |
101 std::vector<char> output(expected_output.size()); | |
102 EXPECT_EQ(static_cast<int>(expected_output.size()), | |
103 WriteWebSocketFrameHeader( | |
104 header, &masking_key, &output.front(), output.size())); | |
105 EXPECT_EQ(expected_output, output); | |
106 } | |
107 } | |
108 | |
109 TEST(WebSocketFrameHeaderTest, FrameOpCodes) { | |
110 struct TestCase { | |
111 const char* frame_header; | |
112 size_t frame_header_length; | |
113 WebSocketFrameHeader::OpCode opcode; | |
114 }; | |
115 static const TestCase kTests[] = { | |
116 { "\x80\x00", 2, WebSocketFrameHeader::kOpCodeContinuation }, | |
117 { "\x81\x00", 2, WebSocketFrameHeader::kOpCodeText }, | |
118 { "\x82\x00", 2, WebSocketFrameHeader::kOpCodeBinary }, | |
119 { "\x88\x00", 2, WebSocketFrameHeader::kOpCodeClose }, | |
120 { "\x89\x00", 2, WebSocketFrameHeader::kOpCodePing }, | |
121 { "\x8A\x00", 2, WebSocketFrameHeader::kOpCodePong }, | |
122 // These are undefined opcodes, but the builder should accept them anyway. | |
123 { "\x83\x00", 2, 0x3 }, | |
124 { "\x84\x00", 2, 0x4 }, | |
125 { "\x85\x00", 2, 0x5 }, | |
126 { "\x86\x00", 2, 0x6 }, | |
127 { "\x87\x00", 2, 0x7 }, | |
128 { "\x8B\x00", 2, 0xB }, | |
129 { "\x8C\x00", 2, 0xC }, | |
130 { "\x8D\x00", 2, 0xD }, | |
131 { "\x8E\x00", 2, 0xE }, | |
132 { "\x8F\x00", 2, 0xF } | |
133 }; | |
134 static const int kNumTests = ARRAYSIZE_UNSAFE(kTests); | |
135 | |
136 for (int i = 0; i < kNumTests; ++i) { | |
137 WebSocketFrameHeader header(kTests[i].opcode); | |
138 header.final = true; | |
139 header.payload_length = 0; | |
140 | |
141 std::vector<char> expected_output( | |
142 kTests[i].frame_header, | |
143 kTests[i].frame_header + kTests[i].frame_header_length); | |
144 std::vector<char> output(expected_output.size()); | |
145 EXPECT_EQ(static_cast<int>(expected_output.size()), | |
146 WriteWebSocketFrameHeader( | |
147 header, NULL, &output.front(), output.size())); | |
148 EXPECT_EQ(expected_output, output); | |
149 } | |
150 } | |
151 | |
152 TEST(WebSocketFrameHeaderTest, FinalBitAndReservedBits) { | |
153 struct TestCase { | |
154 const char* frame_header; | |
155 size_t frame_header_length; | |
156 bool final; | |
157 bool reserved1; | |
158 bool reserved2; | |
159 bool reserved3; | |
160 }; | |
161 static const TestCase kTests[] = { | |
162 { "\x81\x00", 2, true, false, false, false }, | |
163 { "\x01\x00", 2, false, false, false, false }, | |
164 { "\xC1\x00", 2, true, true, false, false }, | |
165 { "\xA1\x00", 2, true, false, true, false }, | |
166 { "\x91\x00", 2, true, false, false, true }, | |
167 { "\x71\x00", 2, false, true, true, true }, | |
168 { "\xF1\x00", 2, true, true, true, true } | |
169 }; | |
170 static const int kNumTests = ARRAYSIZE_UNSAFE(kTests); | |
171 | |
172 for (int i = 0; i < kNumTests; ++i) { | |
173 WebSocketFrameHeader header(WebSocketFrameHeader::kOpCodeText); | |
174 header.final = kTests[i].final; | |
175 header.reserved1 = kTests[i].reserved1; | |
176 header.reserved2 = kTests[i].reserved2; | |
177 header.reserved3 = kTests[i].reserved3; | |
178 header.payload_length = 0; | |
179 | |
180 std::vector<char> expected_output( | |
181 kTests[i].frame_header, | |
182 kTests[i].frame_header + kTests[i].frame_header_length); | |
183 std::vector<char> output(expected_output.size()); | |
184 EXPECT_EQ(static_cast<int>(expected_output.size()), | |
185 WriteWebSocketFrameHeader( | |
186 header, NULL, &output.front(), output.size())); | |
187 EXPECT_EQ(expected_output, output); | |
188 } | |
189 } | |
190 | |
191 TEST(WebSocketFrameHeaderTest, InsufficientBufferSize) { | |
192 struct TestCase { | |
193 uint64 payload_length; | |
194 bool masked; | |
195 size_t expected_header_size; | |
196 }; | |
197 static const TestCase kTests[] = { | |
198 { GG_UINT64_C(0), false, 2u }, | |
199 { GG_UINT64_C(125), false, 2u }, | |
200 { GG_UINT64_C(126), false, 4u }, | |
201 { GG_UINT64_C(0xFFFF), false, 4u }, | |
202 { GG_UINT64_C(0x10000), false, 10u }, | |
203 { GG_UINT64_C(0x7FFFFFFFFFFFFFFF), false, 10u }, | |
204 { GG_UINT64_C(0), true, 6u }, | |
205 { GG_UINT64_C(125), true, 6u }, | |
206 { GG_UINT64_C(126), true, 8u }, | |
207 { GG_UINT64_C(0xFFFF), true, 8u }, | |
208 { GG_UINT64_C(0x10000), true, 14u }, | |
209 { GG_UINT64_C(0x7FFFFFFFFFFFFFFF), true, 14u } | |
210 }; | |
211 static const int kNumTests = ARRAYSIZE_UNSAFE(kTests); | |
212 | |
213 for (int i = 0; i < kNumTests; ++i) { | |
214 WebSocketFrameHeader header(WebSocketFrameHeader::kOpCodeText); | |
215 header.final = true; | |
216 header.opcode = WebSocketFrameHeader::kOpCodeText; | |
217 header.masked = kTests[i].masked; | |
218 header.payload_length = kTests[i].payload_length; | |
219 | |
220 char dummy_buffer[14]; | |
221 // Set an insufficient size to |buffer_size|. | |
222 EXPECT_EQ( | |
223 ERR_INVALID_ARGUMENT, | |
224 WriteWebSocketFrameHeader( | |
225 header, NULL, dummy_buffer, kTests[i].expected_header_size - 1)); | |
226 } | |
227 } | |
228 | |
229 TEST(WebSocketFrameTest, MaskPayload) { | |
230 struct TestCase { | |
231 const char* masking_key; | |
232 uint64 frame_offset; | |
233 const char* input; | |
234 const char* output; | |
235 size_t data_length; | |
236 }; | |
237 static const TestCase kTests[] = { | |
238 { "\xDE\xAD\xBE\xEF", 0, "FooBar", "\x98\xC2\xD1\xAD\xBF\xDF", 6 }, | |
239 { "\xDE\xAD\xBE\xEF", 1, "FooBar", "\xEB\xD1\x80\x9C\xCC\xCC", 6 }, | |
240 { "\xDE\xAD\xBE\xEF", 2, "FooBar", "\xF8\x80\xB1\xEF\xDF\x9D", 6 }, | |
241 { "\xDE\xAD\xBE\xEF", 3, "FooBar", "\xA9\xB1\xC2\xFC\x8E\xAC", 6 }, | |
242 { "\xDE\xAD\xBE\xEF", 4, "FooBar", "\x98\xC2\xD1\xAD\xBF\xDF", 6 }, | |
243 { "\xDE\xAD\xBE\xEF", 42, "FooBar", "\xF8\x80\xB1\xEF\xDF\x9D", 6 }, | |
244 { "\xDE\xAD\xBE\xEF", 0, "", "", 0 }, | |
245 { "\xDE\xAD\xBE\xEF", 0, "\xDE\xAD\xBE\xEF", "\x00\x00\x00\x00", 4 }, | |
246 { "\xDE\xAD\xBE\xEF", 0, "\x00\x00\x00\x00", "\xDE\xAD\xBE\xEF", 4 }, | |
247 { "\x00\x00\x00\x00", 0, "FooBar", "FooBar", 6 }, | |
248 { "\xFF\xFF\xFF\xFF", 0, "FooBar", "\xB9\x90\x90\xBD\x9E\x8D", 6 }, | |
249 }; | |
250 static const int kNumTests = ARRAYSIZE_UNSAFE(kTests); | |
251 | |
252 for (int i = 0; i < kNumTests; ++i) { | |
253 WebSocketMaskingKey masking_key; | |
254 std::copy(kTests[i].masking_key, | |
255 kTests[i].masking_key + WebSocketFrameHeader::kMaskingKeyLength, | |
256 masking_key.key); | |
257 std::vector<char> frame_data(kTests[i].input, | |
258 kTests[i].input + kTests[i].data_length); | |
259 std::vector<char> expected_output(kTests[i].output, | |
260 kTests[i].output + kTests[i].data_length); | |
261 MaskWebSocketFramePayload(masking_key, | |
262 kTests[i].frame_offset, | |
263 frame_data.empty() ? NULL : &frame_data.front(), | |
264 frame_data.size()); | |
265 EXPECT_EQ(expected_output, frame_data); | |
266 } | |
267 } | |
268 | |
269 // Check that all combinations of alignment, frame offset and chunk size work | |
270 // correctly for MaskWebSocketFramePayload(). This is mainly used to ensure that | |
271 // vectorisation optimisations don't break anything. We could take a "white box" | |
272 // approach and only test the edge cases, but since the exhaustive "black box" | |
273 // approach runs in acceptable time, we don't have to take the risk of being | |
274 // clever. | |
275 // | |
276 // This brute-force approach runs in O(N^3) time where N is the size of the | |
277 // maximum vector size we want to test again. This might need reconsidering if | |
278 // MaskWebSocketFramePayload() is ever optimised for a dedicated vector | |
279 // architecture. | |
280 TEST(WebSocketFrameTest, MaskPayloadAlignment) { | |
281 // This reflects what might be implemented in the future, rather than | |
282 // the current implementation. FMA3 and FMA4 support 256-bit vector ops. | |
283 static const size_t kMaxVectorSizeInBits = 256; | |
284 static const size_t kMaxVectorSize = kMaxVectorSizeInBits / 8; | |
285 static const size_t kMaxVectorAlignment = kMaxVectorSize; | |
286 static const size_t kMaskingKeyLength = | |
287 WebSocketFrameHeader::kMaskingKeyLength; | |
288 static const size_t kScratchBufferSize = | |
289 kMaxVectorAlignment + kMaxVectorSize * 2; | |
290 static const char kTestMask[] = "\xd2\xba\x5a\xbe"; | |
291 // We use 786 bits of random input to reduce the risk of correlated errors. | |
292 static const char kTestInput[] = { | |
293 "\x3d\x77\x1d\x1b\x19\x8c\x48\xa3\x19\x6d\xf7\xcc\x39\xe7\x57\x0b" | |
294 "\x69\x8c\xda\x4b\xfc\xac\x2c\xd3\x49\x96\x6e\x8a\x7b\x5a\x32\x76" | |
295 "\xd0\x11\x43\xa0\x89\xfc\x76\x2b\x10\x2f\x4c\x7b\x4f\xa6\xdd\xe4" | |
296 "\xfc\x8e\xd8\x72\xcf\x7e\x37\xcd\x31\xcd\xc1\xc0\x89\x0c\xa7\x4c" | |
297 "\xda\xa8\x4b\x75\xa1\xcb\xa9\x77\x19\x4d\x6e\xdf\xc8\x08\x1c\xb6" | |
298 "\x6d\xfb\x38\x04\x44\xd5\xba\x57\x9f\x76\xb0\x2e\x07\x91\xe6\xa8" | |
299 }; | |
300 static const size_t kTestInputSize = arraysize(kTestInput) - 1; | |
301 static const char kTestOutput[] = { | |
302 "\xef\xcd\x47\xa5\xcb\x36\x12\x1d\xcb\xd7\xad\x72\xeb\x5d\x0d\xb5" | |
303 "\xbb\x36\x80\xf5\x2e\x16\x76\x6d\x9b\x2c\x34\x34\xa9\xe0\x68\xc8" | |
304 "\x02\xab\x19\x1e\x5b\x46\x2c\x95\xc2\x95\x16\xc5\x9d\x1c\x87\x5a" | |
305 "\x2e\x34\x82\xcc\x1d\xc4\x6d\x73\xe3\x77\x9b\x7e\x5b\xb6\xfd\xf2" | |
306 "\x08\x12\x11\xcb\x73\x71\xf3\xc9\xcb\xf7\x34\x61\x1a\xb2\x46\x08" | |
307 "\xbf\x41\x62\xba\x96\x6f\xe0\xe9\x4d\xcc\xea\x90\xd5\x2b\xbc\x16" | |
308 }; | |
309 COMPILE_ASSERT(arraysize(kTestInput) == arraysize(kTestOutput), | |
310 output_and_input_arrays_have_the_same_length); | |
311 scoped_ptr_malloc<char, base::ScopedPtrAlignedFree> scratch( | |
312 static_cast<char*>( | |
313 base::AlignedAlloc(kScratchBufferSize, kMaxVectorAlignment))); | |
314 WebSocketMaskingKey masking_key; | |
315 std::copy(kTestMask, kTestMask + kMaskingKeyLength, masking_key.key); | |
316 for (size_t frame_offset = 0; frame_offset < kMaskingKeyLength; | |
317 ++frame_offset) { | |
318 for (size_t alignment = 0; alignment < kMaxVectorAlignment; ++alignment) { | |
319 char* const aligned_scratch = scratch.get() + alignment; | |
320 const size_t aligned_len = std::min(kScratchBufferSize - alignment, | |
321 kTestInputSize - frame_offset); | |
322 for (size_t chunk_size = 1; chunk_size < kMaxVectorSize; ++chunk_size) { | |
323 memcpy(aligned_scratch, kTestInput + frame_offset, aligned_len); | |
324 for (size_t chunk_start = 0; chunk_start < aligned_len; | |
325 chunk_start += chunk_size) { | |
326 const size_t this_chunk_size = | |
327 std::min(chunk_size, aligned_len - chunk_start); | |
328 MaskWebSocketFramePayload(masking_key, | |
329 frame_offset + chunk_start, | |
330 aligned_scratch + chunk_start, | |
331 this_chunk_size); | |
332 } | |
333 // Stop the test if it fails, since we don't want to spew thousands of | |
334 // failures. | |
335 ASSERT_TRUE(std::equal(aligned_scratch, | |
336 aligned_scratch + aligned_len, | |
337 kTestOutput + frame_offset)) | |
338 << "Output failed to match for frame_offset=" << frame_offset | |
339 << ", alignment=" << alignment << ", chunk_size=" << chunk_size; | |
340 } | |
341 } | |
342 } | |
343 } | |
344 | |
345 class WebSocketFrameTestMaskBenchmark : public testing::Test { | |
346 public: | |
347 WebSocketFrameTestMaskBenchmark() : iterations_(kDefaultIterations) {} | |
348 | |
349 virtual void SetUp() { | |
350 std::string iterations( | |
351 CommandLine::ForCurrentProcess()->GetSwitchValueASCII( | |
352 kBenchmarkIterations)); | |
353 int benchmark_iterations = 0; | |
354 if (!iterations.empty() && | |
355 base::StringToInt(iterations, &benchmark_iterations)) { | |
356 iterations_ = benchmark_iterations; | |
357 } | |
358 } | |
359 | |
360 void Benchmark(const char* const payload, size_t size) { | |
361 std::vector<char> scratch(payload, payload + size); | |
362 static const char kMaskingKey[] = "\xFE\xED\xBE\xEF"; | |
363 COMPILE_ASSERT( | |
364 arraysize(kMaskingKey) == WebSocketFrameHeader::kMaskingKeyLength + 1, | |
365 incorrect_masking_key_size); | |
366 WebSocketMaskingKey masking_key; | |
367 std::copy(kMaskingKey, | |
368 kMaskingKey + WebSocketFrameHeader::kMaskingKeyLength, | |
369 masking_key.key); | |
370 LOG(INFO) << "Benchmarking MaskWebSocketFramePayload() for " << iterations_ | |
371 << " iterations"; | |
372 using base::TimeTicks; | |
373 TimeTicks start = TimeTicks::HighResNow(); | |
374 for (int x = 0; x < iterations_; ++x) { | |
375 MaskWebSocketFramePayload( | |
376 masking_key, x % size, &scratch.front(), scratch.size()); | |
377 } | |
378 double total_time_ms = | |
379 1000 * (TimeTicks::HighResNow() - start).InMillisecondsF() / | |
380 iterations_; | |
381 LOG(INFO) << "Payload size " << size | |
382 << base::StringPrintf(" took %.03f microseconds per iteration", | |
383 total_time_ms); | |
384 } | |
385 | |
386 private: | |
387 int iterations_; | |
388 | |
389 DISALLOW_COPY_AND_ASSIGN(WebSocketFrameTestMaskBenchmark); | |
390 }; | |
391 | |
392 TEST_F(WebSocketFrameTestMaskBenchmark, BenchmarkMaskShortPayload) { | |
393 static const char kShortPayload[] = "Short Payload"; | |
394 Benchmark(kShortPayload, arraysize(kShortPayload)); | |
395 } | |
396 | |
397 TEST_F(WebSocketFrameTestMaskBenchmark, BenchmarkMaskLongPayload) { | |
398 scoped_ptr<char[]> payload(new char[kLongPayloadSize]); | |
399 std::fill(payload.get(), payload.get() + kLongPayloadSize, 'a'); | |
400 Benchmark(payload.get(), kLongPayloadSize); | |
401 } | |
402 | |
403 // "IsKnownDataOpCode" is currently implemented in an "obviously correct" | |
404 // manner, but we test is anyway in case it changes to a more complex | |
405 // implementation in future. | |
406 TEST(WebSocketFrameHeaderTest, IsKnownDataOpCode) { | |
407 // Make the test less verbose. | |
408 typedef WebSocketFrameHeader Frame; | |
409 | |
410 // Known opcode, is used for data frames | |
411 EXPECT_TRUE(Frame::IsKnownDataOpCode(Frame::kOpCodeContinuation)); | |
412 EXPECT_TRUE(Frame::IsKnownDataOpCode(Frame::kOpCodeText)); | |
413 EXPECT_TRUE(Frame::IsKnownDataOpCode(Frame::kOpCodeBinary)); | |
414 | |
415 // Known opcode, is used for control frames | |
416 EXPECT_FALSE(Frame::IsKnownDataOpCode(Frame::kOpCodeClose)); | |
417 EXPECT_FALSE(Frame::IsKnownDataOpCode(Frame::kOpCodePing)); | |
418 EXPECT_FALSE(Frame::IsKnownDataOpCode(Frame::kOpCodePong)); | |
419 | |
420 // Check that unused opcodes return false | |
421 EXPECT_FALSE(Frame::IsKnownDataOpCode(Frame::kOpCodeDataUnused)); | |
422 EXPECT_FALSE(Frame::IsKnownDataOpCode(Frame::kOpCodeControlUnused)); | |
423 | |
424 // Check that opcodes with the 4 bit set return false | |
425 EXPECT_FALSE(Frame::IsKnownDataOpCode(0x6)); | |
426 EXPECT_FALSE(Frame::IsKnownDataOpCode(0xF)); | |
427 | |
428 // Check that out-of-range opcodes return false | |
429 EXPECT_FALSE(Frame::IsKnownDataOpCode(-1)); | |
430 EXPECT_FALSE(Frame::IsKnownDataOpCode(0xFF)); | |
431 } | |
432 | |
433 // "IsKnownControlOpCode" is implemented in an "obviously correct" manner but | |
434 // might be optimised in future. | |
435 TEST(WebSocketFrameHeaderTest, IsKnownControlOpCode) { | |
436 // Make the test less verbose. | |
437 typedef WebSocketFrameHeader Frame; | |
438 | |
439 // Known opcode, is used for data frames | |
440 EXPECT_FALSE(Frame::IsKnownControlOpCode(Frame::kOpCodeContinuation)); | |
441 EXPECT_FALSE(Frame::IsKnownControlOpCode(Frame::kOpCodeText)); | |
442 EXPECT_FALSE(Frame::IsKnownControlOpCode(Frame::kOpCodeBinary)); | |
443 | |
444 // Known opcode, is used for control frames | |
445 EXPECT_TRUE(Frame::IsKnownControlOpCode(Frame::kOpCodeClose)); | |
446 EXPECT_TRUE(Frame::IsKnownControlOpCode(Frame::kOpCodePing)); | |
447 EXPECT_TRUE(Frame::IsKnownControlOpCode(Frame::kOpCodePong)); | |
448 | |
449 // Check that unused opcodes return false | |
450 EXPECT_FALSE(Frame::IsKnownControlOpCode(Frame::kOpCodeDataUnused)); | |
451 EXPECT_FALSE(Frame::IsKnownControlOpCode(Frame::kOpCodeControlUnused)); | |
452 | |
453 // Check that opcodes with the 4 bit set return false | |
454 EXPECT_FALSE(Frame::IsKnownControlOpCode(0x6)); | |
455 EXPECT_FALSE(Frame::IsKnownControlOpCode(0xF)); | |
456 | |
457 // Check that out-of-range opcodes return false | |
458 EXPECT_FALSE(Frame::IsKnownControlOpCode(-1)); | |
459 EXPECT_FALSE(Frame::IsKnownControlOpCode(0xFF)); | |
460 } | |
461 | |
462 } // namespace net | |
OLD | NEW |