SPDY - unforked spdy_framer and spdy_protocol tests.

net/spdy/spdy_protocol_test.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/spdy/spdy_protocol.h"
 
 #include "base/memory/scoped_ptr.h"
 #include "net/spdy/spdy_bitmasks.h"
 #include "net/spdy/spdy_framer.h"
 #include "testing/platform_test.h"
@@ skipping 27 matching lines @@
 using spdy::SpdySynReplyControlFrame;
 using spdy::SpdySynStreamControlFrame;
 using spdy::SpdyWindowUpdateControlFrame;
 using spdy::WINDOW_UPDATE;
 using spdy::kLengthMask;
 using spdy::kStreamIdMask;
 
 namespace {
 
 // Default SPDY version for unit tests.
-const int SPDY_VERSION_FOR_TESTS = 3;
+int SPDY_VERSION_FOR_TESTS = 2;

[Ryan Hamilton, 2012/03/13 19:59:12]

Ditto on my advice from the other test about making this a member variable.

[ramant (doing other things), 2012/03/13 21:43:02]

Done.

+
+enum SpdyProtocolTestTypes {
+  SPDY2,
+  SPDY3,
+};
+
+class SpdyProtocolTest
+    : public ::testing::TestWithParam<SpdyProtocolTestTypes> {
+ protected:
+  virtual void SetUp() {
+    SPDY_VERSION_FOR_TESTS = (GetParam() == SPDY2) ? 2 : 3;
+  }
+
+  virtual void TearDown() {}
+
+};
+
+class SpdyProtocolDeathTest

[Ryan Hamilton, 2012/03/13 19:59:12]

I might be missing something, but if this class is identical to
SpdyProtocolTest, is there a reason we need to have 2 different classes?

(And if we really need it to be a distinct class perhaps we can just do:

class SpdyProtocolDeathTest : public SpdyProtocolTest {};

[ramant (doing other things), 2012/03/13 21:43:02]

Done.

+    : public ::testing::TestWithParam<SpdyProtocolTestTypes> {
+ protected:
+  virtual void SetUp() {
+    SPDY_VERSION_FOR_TESTS = (GetParam() == SPDY2) ? 2 : 3;
+  }
+
+  virtual void TearDown() {}
+
+};
+
+//-----------------------------------------------------------------------------
+// All tests are run with two different SPDY versions: SPDY/2 and SPDY/3.
+INSTANTIATE_TEST_CASE_P(SpdyProtocolTests,
+                        SpdyProtocolTest,
+                        ::testing::Values(SPDY2, SPDY3));
 
 // Test our protocol constants
-TEST(SpdyProtocolSpdy3Test, ProtocolConstants) {
+TEST(SpdyProtocolTest, ProtocolConstants) {

[Ryan Hamilton, 2012/03/13 19:59:12]

Can the various TEST()s be replaced with TEST_P()s?

[ramant (doing other things), 2012/03/13 21:43:02]

Done.

   EXPECT_EQ(8u, SpdyFrame::kHeaderSize);
   EXPECT_EQ(8u, SpdyDataFrame::size());
   EXPECT_EQ(8u, SpdyControlFrame::kHeaderSize);
   EXPECT_EQ(18u, SpdySynStreamControlFrame::size());
   EXPECT_EQ(12u, SpdySynReplyControlFrame::size());
   EXPECT_EQ(16u, SpdyRstStreamControlFrame::size());
   EXPECT_EQ(12u, SpdySettingsControlFrame::size());
   EXPECT_EQ(12u, SpdyPingControlFrame::size());
   EXPECT_EQ(12u, SpdyGoAwayControlFrame::size());
   EXPECT_EQ(12u, SpdyHeadersControlFrame::size());
   EXPECT_EQ(16u, SpdyWindowUpdateControlFrame::size());
   EXPECT_EQ(4u, sizeof(FlagsAndLength));
   EXPECT_EQ(1, SYN_STREAM);
   EXPECT_EQ(2, SYN_REPLY);
   EXPECT_EQ(3, RST_STREAM);
   EXPECT_EQ(4, SETTINGS);
   EXPECT_EQ(5, NOOP);
   EXPECT_EQ(6, PING);
   EXPECT_EQ(7, GOAWAY);
   EXPECT_EQ(8, HEADERS);
   EXPECT_EQ(9, WINDOW_UPDATE);
 }
 
 // Test some of the protocol helper functions
-TEST(SpdyProtocolSpdy3Test, FrameStructs) {
+TEST(SpdyProtocolTest, FrameStructs) {
   SpdyFrame frame(SpdyFrame::kHeaderSize);
   frame.set_length(12345);
   frame.set_flags(10);
   EXPECT_EQ(12345u, frame.length());
   EXPECT_EQ(10u, frame.flags());
   EXPECT_FALSE(frame.is_control_frame());
 
   frame.set_length(0);
   frame.set_flags(10);
   EXPECT_EQ(0u, frame.length());
   EXPECT_EQ(10u, frame.flags());
   EXPECT_FALSE(frame.is_control_frame());
 }
 
-TEST(SpdyProtocolSpdy3Test, DataFrameStructs) {
+TEST(SpdyProtocolTest, DataFrameStructs) {
   SpdyDataFrame data_frame;
   data_frame.set_stream_id(12345);
   EXPECT_EQ(12345u, data_frame.stream_id());
 }
 
-TEST(SpdyProtocolSpdy3Test, ControlFrameStructs) {
+TEST_P(SpdyProtocolTest, ControlFrameStructs) {
   SpdyFramer framer(SPDY_VERSION_FOR_TESTS);
   SpdyHeaderBlock headers;
 
   scoped_ptr<SpdySynStreamControlFrame> syn_frame(
       framer.CreateSynStream(123, 456, 2, CONTROL_FLAG_FIN, false, &headers));
   EXPECT_EQ(framer.protocol_version(), syn_frame->version());
   EXPECT_TRUE(syn_frame->is_control_frame());
   EXPECT_EQ(SYN_STREAM, syn_frame->type());
   EXPECT_EQ(123u, syn_frame->stream_id());
   EXPECT_EQ(456u, syn_frame->associated_stream_id());
@@ skipping 56 matching lines @@
 
   scoped_ptr<SpdyWindowUpdateControlFrame> window_update_frame(
       framer.CreateWindowUpdate(123, 456));
   EXPECT_EQ(framer.protocol_version(), window_update_frame->version());
   EXPECT_TRUE(window_update_frame->is_control_frame());
   EXPECT_EQ(WINDOW_UPDATE, window_update_frame->type());
   EXPECT_EQ(123u, window_update_frame->stream_id());
   EXPECT_EQ(456u, window_update_frame->delta_window_size());
 }
 
-TEST(SpdyProtocolSpdy3Test, TestDataFrame) {
+TEST(SpdyProtocolTest, TestDataFrame) {
   SpdyDataFrame frame;
 
   // Set the stream ID to various values.
   frame.set_stream_id(0);
   EXPECT_EQ(0u, frame.stream_id());
   EXPECT_FALSE(frame.is_control_frame());
   frame.set_stream_id(~0 & kStreamIdMask);
   EXPECT_EQ(~0 & kStreamIdMask, frame.stream_id());
   EXPECT_FALSE(frame.is_control_frame());
 
@@ skipping 22 matching lines @@
   frame.set_flags(all_flags);
   flags = frame.flags();
   EXPECT_EQ(all_flags, flags);
   EXPECT_EQ(length, frame.length());
   frame.set_flags(5u);
   EXPECT_EQ(5u, frame.flags());
   EXPECT_EQ(length, frame.length());
 }
 
 // Test various types of SETTINGS frames.
-TEST(SpdyProtocolSpdy3Test, TestSpdySettingsFrame) {
+TEST_P(SpdyProtocolTest, TestSpdySettingsFrame) {
   SpdyFramer framer(SPDY_VERSION_FOR_TESTS);
 
   // Create a settings frame with no settings.
   SpdySettings settings;
   scoped_ptr<SpdySettingsControlFrame> settings_frame(
       framer.CreateSettings(settings));
   EXPECT_EQ(framer.protocol_version(), settings_frame->version());
   EXPECT_TRUE(settings_frame->is_control_frame());
   EXPECT_EQ(SETTINGS, settings_frame->type());
   EXPECT_EQ(0u, settings_frame->num_entries());
@@ skipping 27 matching lines @@
       uint32 value = it->second;
       EXPECT_EQ(ids[pos].flags(), parsed.flags());
       EXPECT_EQ(ids[pos].id(), parsed.id());
       EXPECT_EQ(static_cast<uint32>(pos), value);
       ++it;
       ++pos;
     }
   }
 }
 
-TEST(SpdyProtocolSpdy3Test, HasHeaderBlock) {
+TEST(SpdyProtocolTest, HasHeaderBlock) {
   SpdyControlFrame frame(SpdyControlFrame::kHeaderSize);
   for (SpdyControlType type = SYN_STREAM;
       type < NUM_CONTROL_FRAME_TYPES;
       type = static_cast<SpdyControlType>(type + 1)) {
     frame.set_type(type);
     if (type == SYN_STREAM || type == SYN_REPLY || type == HEADERS) {
       EXPECT_TRUE(frame.has_header_block());
     } else {
       EXPECT_FALSE(frame.has_header_block());
     }
   }
 }
 
+//-----------------------------------------------------------------------------
+// All tests are run with two different SPDY versions: SPDY/2 and SPDY/3.
+INSTANTIATE_TEST_CASE_P(SpdyProtocolDeathTests,
+                        SpdyProtocolDeathTest,
+                        ::testing::Values(SPDY2, SPDY3));
+
 // Make sure that overflows both die in debug mode, and do not cause problems
 // in opt mode.  Note:  The EXPECT_DEBUG_DEATH call does not work on Win32 yet,
 // so we comment it out.
-TEST(SpdyProtocolDeathSpdy3Test, TestDataFrame) {
+TEST(SpdyProtocolDeathTest, TestDataFrame) {
   SpdyDataFrame frame;
 
   frame.set_stream_id(0);
   // TODO(mbelshe):  implement EXPECT_DEBUG_DEATH on windows.
 #if !defined(WIN32) && defined(GTEST_HAS_DEATH_TEST)
 #if !defined(DCHECK_ALWAYS_ON)
   EXPECT_DEBUG_DEATH(frame.set_stream_id(~0), "");
 #else
   EXPECT_DEATH(frame.set_stream_id(~0), "");
 #endif
 #endif
   EXPECT_FALSE(frame.is_control_frame());
 
   frame.set_flags(0);
 #if !defined(WIN32) && defined(GTEST_HAS_DEATH_TEST)
 #if !defined(DCHECK_ALWAYS_ON)
   EXPECT_DEBUG_DEATH(frame.set_length(~0), "");
 #else
   EXPECT_DEATH(frame.set_length(~0), "");
 #endif
 #endif
   EXPECT_EQ(0, frame.flags());
 }
 
-TEST(SpdyProtocolDeathSpdy3Test, TestSpdyControlFrameStreamId) {
+TEST(SpdyProtocolDeathTest, TestSpdyControlFrameStreamId) {
   SpdyControlFrame frame_store(SpdySynStreamControlFrame::size());
   memset(frame_store.data(), '1', SpdyControlFrame::kHeaderSize);
   SpdySynStreamControlFrame* frame =
       reinterpret_cast<SpdySynStreamControlFrame*>(&frame_store);
 
   // Set the stream ID to various values.
   frame->set_stream_id(0);
   EXPECT_EQ(0u, frame->stream_id());
   EXPECT_FALSE(frame->is_control_frame());
   frame->set_stream_id(kStreamIdMask);
   EXPECT_EQ(kStreamIdMask, frame->stream_id());
   EXPECT_FALSE(frame->is_control_frame());
 }
 
-TEST(SpdyProtocolDeathSpdy3Test, TestSpdyControlFrameVersion) {
+TEST(SpdyProtocolDeathTest, TestSpdyControlFrameVersion) {
   const unsigned int kVersionMask = 0x7fff;
   SpdyControlFrame frame(SpdySynStreamControlFrame::size());
   memset(frame.data(), '1', SpdyControlFrame::kHeaderSize);
 
   // Set the version to various values, and make sure it does not affect the
   // type.
   frame.set_type(SYN_STREAM);
   frame.set_version(0);
   EXPECT_EQ(0, frame.version());
   EXPECT_TRUE(frame.is_control_frame());
   EXPECT_EQ(SYN_STREAM, frame.type());
 
   SpdySynStreamControlFrame* syn_stream =
       reinterpret_cast<SpdySynStreamControlFrame*>(&frame);
   syn_stream->set_stream_id(~0 & kVersionMask);
   EXPECT_EQ(~0 & kVersionMask, syn_stream->stream_id());
   EXPECT_TRUE(frame.is_control_frame());
   EXPECT_EQ(SYN_STREAM, frame.type());
 }
 
-TEST(SpdyProtocolDeathSpdy3Test, TestSpdyControlFrameType) {
+TEST_P(SpdyProtocolDeathTest, TestSpdyControlFrameType) {
   SpdyControlFrame frame(SpdyControlFrame::kHeaderSize);
   memset(frame.data(), 255, SpdyControlFrame::kHeaderSize);
 
   // type() should be out of bounds.
   EXPECT_FALSE(frame.AppearsToBeAValidControlFrame());
 
   frame.set_version(SPDY_VERSION_FOR_TESTS);
   uint16 version = frame.version();
 
   for (int i = SYN_STREAM; i <= spdy::WINDOW_UPDATE; ++i) {
     frame.set_type(static_cast<SpdyControlType>(i));
     EXPECT_EQ(i, static_cast<int>(frame.type()));
-    if (i == spdy::NOOP) {
+    if (SPDY_VERSION_FOR_TESTS != 2 && i == spdy::NOOP) {
       // NOOP frames aren't 'valid'.
       EXPECT_FALSE(frame.AppearsToBeAValidControlFrame());
     } else {
       EXPECT_TRUE(frame.AppearsToBeAValidControlFrame());
     }
     // Make sure setting type does not alter the version block.
     EXPECT_EQ(version, frame.version());
     EXPECT_TRUE(frame.is_control_frame());
   }
 }
 
-TEST(SpdyProtocolDeathSpdy3Test, TestRstStreamStatusBounds) {
+TEST_P(SpdyProtocolDeathTest, TestRstStreamStatusBounds) {
   SpdyFramer framer(SPDY_VERSION_FOR_TESTS);
   scoped_ptr<SpdyRstStreamControlFrame> rst_frame;
 
   rst_frame.reset(framer.CreateRstStream(123, spdy::PROTOCOL_ERROR));
   EXPECT_EQ(spdy::PROTOCOL_ERROR, rst_frame->status());
 
   rst_frame->set_status(spdy::INVALID);
   EXPECT_EQ(spdy::INVALID, rst_frame->status());
 
   rst_frame->set_status(
       static_cast<spdy::SpdyStatusCodes>(spdy::INVALID - 1));
   EXPECT_EQ(spdy::INVALID, rst_frame->status());
 
   rst_frame->set_status(spdy::NUM_STATUS_CODES);
   EXPECT_EQ(spdy::INVALID, rst_frame->status());
 }
 
 }  // namespace