Add missing status codes to WebSocketError enum.

net/websockets/websocket_frame_unittest.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "net/websockets/websocket_frame.h"
 
 #include <algorithm>
 #include <vector>
 
 #include "base/basictypes.h"
@@ skipping 27 matching lines @@
     { "\x81\x7D", 2, GG_UINT64_C(125) },
     { "\x81\x7E\x00\x7E", 4, GG_UINT64_C(126) },
     { "\x81\x7E\xFF\xFF", 4, GG_UINT64_C(0xFFFF) },
     { "\x81\x7F\x00\x00\x00\x00\x00\x01\x00\x00", 10, GG_UINT64_C(0x10000) },
     { "\x81\x7F\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF", 10,
       GG_UINT64_C(0x7FFFFFFFFFFFFFFF) }
   };
   static const int kNumTests = ARRAYSIZE_UNSAFE(kTests);
 
   for (int i = 0; i < kNumTests; ++i) {
-    WebSocketFrameHeader header;
+    WebSocketFrameHeader header(WebSocketFrameHeader::kOpCodeText);
     header.final = true;
-    header.reserved1 = false;
-    header.reserved2 = false;
-    header.reserved3 = false;
-    header.opcode = WebSocketFrameHeader::kOpCodeText;
-    header.masked = false;
     header.payload_length = kTests[i].frame_length;
 
     std::vector<char> expected_output(
         kTests[i].frame_header,
         kTests[i].frame_header + kTests[i].frame_header_length);
     std::vector<char> output(expected_output.size());
     EXPECT_EQ(static_cast<int>(expected_output.size()),
               WriteWebSocketFrameHeader(header, NULL, &output.front(),
                                         output.size()));
     EXPECT_EQ(expected_output, output);
@@ skipping 21 matching lines @@
     { "\x81\xFF\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xDE\xAD\xBE\xEF", 14,
       GG_UINT64_C(0x7FFFFFFFFFFFFFFF) }
   };
   static const int kNumTests = ARRAYSIZE_UNSAFE(kTests);
 
   WebSocketMaskingKey masking_key;
   std::copy(kMaskingKey, kMaskingKey + WebSocketFrameHeader::kMaskingKeyLength,
             masking_key.key);
 
   for (int i = 0; i < kNumTests; ++i) {
-    WebSocketFrameHeader header;
+    WebSocketFrameHeader header(WebSocketFrameHeader::kOpCodeText);
     header.final = true;
-    header.reserved1 = false;
-    header.reserved2 = false;
-    header.reserved3 = false;
-    header.opcode = WebSocketFrameHeader::kOpCodeText;
     header.masked = true;
     header.payload_length = kTests[i].frame_length;
 
     std::vector<char> expected_output(
         kTests[i].frame_header,
         kTests[i].frame_header + kTests[i].frame_header_length);
     std::vector<char> output(expected_output.size());
     EXPECT_EQ(static_cast<int>(expected_output.size()),
               WriteWebSocketFrameHeader(header, &masking_key,
                                         &output.front(), output.size()));
@@ skipping 22 matching lines @@
     { "\x87\x00", 2, 0x7 },
     { "\x8B\x00", 2, 0xB },
     { "\x8C\x00", 2, 0xC },
     { "\x8D\x00", 2, 0xD },
     { "\x8E\x00", 2, 0xE },
     { "\x8F\x00", 2, 0xF }
   };
   static const int kNumTests = ARRAYSIZE_UNSAFE(kTests);
 
   for (int i = 0; i < kNumTests; ++i) {
-    WebSocketFrameHeader header;
+    WebSocketFrameHeader header(kTests[i].opcode);
     header.final = true;
-    header.reserved1 = false;
-    header.reserved2 = false;
-    header.reserved3 = false;
-    header.opcode = kTests[i].opcode;
-    header.masked = false;
     header.payload_length = 0;
 
     std::vector<char> expected_output(
         kTests[i].frame_header,
         kTests[i].frame_header + kTests[i].frame_header_length);
     std::vector<char> output(expected_output.size());
     EXPECT_EQ(static_cast<int>(expected_output.size()),
               WriteWebSocketFrameHeader(header, NULL,
                                         &output.front(), output.size()));
     EXPECT_EQ(expected_output, output);
@@ skipping 14 matching lines @@
     { "\x01\x00", 2, false, false, false, false },
     { "\xC1\x00", 2, true, true, false, false },
     { "\xA1\x00", 2, true, false, true, false },
     { "\x91\x00", 2, true, false, false, true },
     { "\x71\x00", 2, false, true, true, true },
     { "\xF1\x00", 2, true, true, true, true }
   };
   static const int kNumTests = ARRAYSIZE_UNSAFE(kTests);
 
   for (int i = 0; i < kNumTests; ++i) {
-    WebSocketFrameHeader header;
+    WebSocketFrameHeader header(WebSocketFrameHeader::kOpCodeText);
     header.final = kTests[i].final;
     header.reserved1 = kTests[i].reserved1;
     header.reserved2 = kTests[i].reserved2;
     header.reserved3 = kTests[i].reserved3;
-    header.opcode = WebSocketFrameHeader::kOpCodeText;
-    header.masked = false;
     header.payload_length = 0;
 
     std::vector<char> expected_output(
         kTests[i].frame_header,
         kTests[i].frame_header + kTests[i].frame_header_length);
     std::vector<char> output(expected_output.size());
     EXPECT_EQ(static_cast<int>(expected_output.size()),
               WriteWebSocketFrameHeader(header, NULL,
                                         &output.front(), output.size()));
     EXPECT_EQ(expected_output, output);
@@ skipping 16 matching lines @@
     { GG_UINT64_C(0), true, 6u },
     { GG_UINT64_C(125), true, 6u },
     { GG_UINT64_C(126), true, 8u },
     { GG_UINT64_C(0xFFFF), true, 8u },
     { GG_UINT64_C(0x10000), true, 14u },
     { GG_UINT64_C(0x7FFFFFFFFFFFFFFF), true, 14u }
   };
   static const int kNumTests = ARRAYSIZE_UNSAFE(kTests);
 
   for (int i = 0; i < kNumTests; ++i) {
-    WebSocketFrameHeader header;
+    WebSocketFrameHeader header(WebSocketFrameHeader::kOpCodeText);
     header.final = true;
-    header.reserved1 = false;
-    header.reserved2 = false;
-    header.reserved3 = false;
     header.opcode = WebSocketFrameHeader::kOpCodeText;
     header.masked = kTests[i].masked;
     header.payload_length = kTests[i].payload_length;
 
     char dummy_buffer[14];
     // Set an insufficient size to |buffer_size|.
     EXPECT_EQ(ERR_INVALID_ARGUMENT,
               WriteWebSocketFrameHeader(header, NULL, dummy_buffer,
                                         kTests[i].expected_header_size - 1));
   }
@@ skipping 173 matching lines @@
   static const char kShortPayload[] = "Short Payload";
   Benchmark(kShortPayload, arraysize(kShortPayload));
 }
 
 TEST_F(WebSocketFrameTestMaskBenchmark, BenchmarkMaskLongPayload) {
   scoped_ptr<char[]> payload(new char[kLongPayloadSize]);
   std::fill(payload.get(), payload.get() + kLongPayloadSize, 'a');
   Benchmark(payload.get(), kLongPayloadSize);
 }
 
+// "IsKnownDataOpCode" is implemented using bit-mangling for efficiency, so we
+// need to check that the results match the actual op-codes defined.
+TEST(WebSocketFrameHeaderTest, IsKnownDataOpCode) {
+  // Make the test less verbose.
+  typedef WebSocketFrameHeader Frame;
+
+  // Known opcode, is used for data frames
+  EXPECT_TRUE(Frame::IsKnownDataOpCode(Frame::kOpCodeContinuation));
+  EXPECT_TRUE(Frame::IsKnownDataOpCode(Frame::kOpCodeText));
+  EXPECT_TRUE(Frame::IsKnownDataOpCode(Frame::kOpCodeBinary));
+
+  // Known opcode, is used for control frames
+  EXPECT_FALSE(Frame::IsKnownDataOpCode(Frame::kOpCodeClose));
+  EXPECT_FALSE(Frame::IsKnownDataOpCode(Frame::kOpCodePing));
+  EXPECT_FALSE(Frame::IsKnownDataOpCode(Frame::kOpCodePong));
+
+  // Check that unused opcodes return false
+  EXPECT_FALSE(Frame::IsKnownDataOpCode(Frame::kOpCodeDataUnused));
+  EXPECT_FALSE(Frame::IsKnownDataOpCode(Frame::kOpCodeControlUnused));
+
+  // Check that opcodes with the 4 bit set return false
+  EXPECT_FALSE(Frame::IsKnownDataOpCode(0x6));
+  EXPECT_FALSE(Frame::IsKnownDataOpCode(0xF));
+
+  // Check that out-of-range opcodes return false
+  EXPECT_FALSE(Frame::IsKnownDataOpCode(-1));
+  EXPECT_FALSE(Frame::IsKnownDataOpCode(0xFF));
+}
+
+// "IsKnownControlOpCode" is implemented using bit-mangling as with
+// "IsKnownDataOpCode".
+TEST(WebSocketFrameHeaderTest, IsKnownControlOpCode) {
+  // Make the test less verbose.
+  typedef WebSocketFrameHeader Frame;
+
+  // Known opcode, is used for data frames
+  EXPECT_FALSE(Frame::IsKnownControlOpCode(Frame::kOpCodeContinuation));
+  EXPECT_FALSE(Frame::IsKnownControlOpCode(Frame::kOpCodeText));
+  EXPECT_FALSE(Frame::IsKnownControlOpCode(Frame::kOpCodeBinary));
+
+  // Known opcode, is used for control frames
+  EXPECT_TRUE(Frame::IsKnownControlOpCode(Frame::kOpCodeClose));
+  EXPECT_TRUE(Frame::IsKnownControlOpCode(Frame::kOpCodePing));
+  EXPECT_TRUE(Frame::IsKnownControlOpCode(Frame::kOpCodePong));
+
+  // Check that unused opcodes return false
+  EXPECT_FALSE(Frame::IsKnownControlOpCode(Frame::kOpCodeDataUnused));
+  EXPECT_FALSE(Frame::IsKnownControlOpCode(Frame::kOpCodeControlUnused));
+
+  // Check that opcodes with the 4 bit set return false
+  EXPECT_FALSE(Frame::IsKnownControlOpCode(0x6));
+  EXPECT_FALSE(Frame::IsKnownControlOpCode(0xF));
+
+  // Check that out-of-range opcodes return false
+  EXPECT_FALSE(Frame::IsKnownControlOpCode(-1));
+  EXPECT_FALSE(Frame::IsKnownControlOpCode(0xFF));
+}
+
 }  // namespace net