net/spdy/spdy_protocol_test.cc - platform/external/chromium - Git at Google

 // Copyright (c) 2011 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"

 using spdy::CONTROL_FLAG_FIN;
 using spdy::CONTROL_FLAG_NONE;
 using spdy::GOAWAY;
 using spdy::HEADERS;
 using spdy::NOOP;
 using spdy::PING;
 using spdy::RST_STREAM;
 using spdy::SETTINGS;
 using spdy::SYN_REPLY;
 using spdy::SYN_STREAM;
 using spdy::WINDOW_UPDATE;
 using spdy::FlagsAndLength;
 using spdy::SpdyControlFrame;
 using spdy::SpdyControlType;
 using spdy::SpdyDataFrame;
 using spdy::SpdyFrame;
 using spdy::SpdyFramer;
 using spdy::SpdyHeaderBlock;
 using spdy::SpdyGoAwayControlFrame;
 using spdy::SpdyRstStreamControlFrame;
 using spdy::SpdySettings;
 using spdy::SpdySettingsControlFrame;
 using spdy::SpdyStatusCodes;
 using spdy::SpdySynReplyControlFrame;
 using spdy::SpdySynStreamControlFrame;
 using spdy::SpdyWindowUpdateControlFrame;
 using spdy::SettingsFlagsAndId;
 using spdy::kLengthMask;
 using spdy::kSpdyProtocolVersion;
 using spdy::kStreamIdMask;

 namespace {

 // Test our protocol constants
 TEST(SpdyProtocolTest, ProtocolConstants) {
   EXPECT_EQ(8u, SpdyFrame::size());
   EXPECT_EQ(8u, SpdyDataFrame::size());
   EXPECT_EQ(8u, SpdyControlFrame::size());
   EXPECT_EQ(18u, SpdySynStreamControlFrame::size());
   EXPECT_EQ(14u, SpdySynReplyControlFrame::size());
   EXPECT_EQ(16u, SpdyRstStreamControlFrame::size());
   EXPECT_EQ(12u, SpdyGoAwayControlFrame::size());
   EXPECT_EQ(12u, SpdySettingsControlFrame::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(SpdyProtocolTest, FrameStructs) {
   SpdyFrame frame(SpdyFrame::size());
   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(SpdyProtocolTest, DataFrameStructs) {
   SpdyDataFrame data_frame;
   data_frame.set_stream_id(12345);
   EXPECT_EQ(12345u, data_frame.stream_id());
 }

 TEST(SpdyProtocolTest, ControlFrameStructs) {
   SpdyFramer framer;
   SpdyHeaderBlock headers;

   scoped_ptr<SpdySynStreamControlFrame> syn_frame(
       framer.CreateSynStream(123, 456, 2, CONTROL_FLAG_FIN, false, &headers));
   EXPECT_EQ(kSpdyProtocolVersion, 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());
   EXPECT_EQ(2u, syn_frame->priority());
   EXPECT_EQ(2, syn_frame->header_block_len());
   EXPECT_EQ(1u, syn_frame->flags());
   syn_frame->set_associated_stream_id(999u);
   EXPECT_EQ(123u, syn_frame->stream_id());
   EXPECT_EQ(999u, syn_frame->associated_stream_id());

   scoped_ptr<SpdySynReplyControlFrame> syn_reply(
       framer.CreateSynReply(123, CONTROL_FLAG_NONE, false, &headers));
   EXPECT_EQ(kSpdyProtocolVersion, syn_reply->version());
   EXPECT_TRUE(syn_reply->is_control_frame());
   EXPECT_EQ(SYN_REPLY, syn_reply->type());
   EXPECT_EQ(123u, syn_reply->stream_id());
   EXPECT_EQ(2, syn_reply->header_block_len());
   EXPECT_EQ(0, syn_reply->flags());

   scoped_ptr<SpdyRstStreamControlFrame> rst_frame(
       framer.CreateRstStream(123, spdy::PROTOCOL_ERROR));
   EXPECT_EQ(kSpdyProtocolVersion, rst_frame->version());
   EXPECT_TRUE(rst_frame->is_control_frame());
   EXPECT_EQ(RST_STREAM, rst_frame->type());
   EXPECT_EQ(123u, rst_frame->stream_id());
   EXPECT_EQ(spdy::PROTOCOL_ERROR, rst_frame->status());
   rst_frame->set_status(spdy::INVALID_STREAM);
   EXPECT_EQ(spdy::INVALID_STREAM, rst_frame->status());
   EXPECT_EQ(0, rst_frame->flags());

   scoped_ptr<SpdyGoAwayControlFrame> goaway_frame(
       framer.CreateGoAway(123));
   EXPECT_EQ(kSpdyProtocolVersion, goaway_frame->version());
   EXPECT_TRUE(goaway_frame->is_control_frame());
   EXPECT_EQ(GOAWAY, goaway_frame->type());
   EXPECT_EQ(123u, goaway_frame->last_accepted_stream_id());

   scoped_ptr<SpdyWindowUpdateControlFrame> window_update_frame(
       framer.CreateWindowUpdate(123, 456));
   EXPECT_EQ(kSpdyProtocolVersion, 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(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());

   // Set length to various values.  Make sure that when you set_length(x),
   // length() == x.  Also make sure the flags are unaltered.
   memset(frame.data(), '1', SpdyDataFrame::size());
   int8 flags = frame.flags();
   frame.set_length(0);
   EXPECT_EQ(0u, frame.length());
   EXPECT_EQ(flags, frame.flags());
   frame.set_length(kLengthMask);
   EXPECT_EQ(kLengthMask, frame.length());
   EXPECT_EQ(flags, frame.flags());
   frame.set_length(5u);
   EXPECT_EQ(5u, frame.length());
   EXPECT_EQ(flags, frame.flags());

   // Set flags to various values.  Make sure that when you set_flags(x),
   // flags() == x.  Also make sure the length is unaltered.
   memset(frame.data(), '1', SpdyDataFrame::size());
   uint32 length = frame.length();
   frame.set_flags(0u);
   EXPECT_EQ(0u, frame.flags());
   EXPECT_EQ(length, frame.length());
   int8 all_flags = ~0;
   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(SpdyProtocolTest, TestSpdySettingsFrame) {
   SpdyFramer framer;

   // Create a settings frame with no settings.
   SpdySettings settings;
   scoped_ptr<SpdySettingsControlFrame> settings_frame(
       framer.CreateSettings(settings));
   EXPECT_EQ(kSpdyProtocolVersion, settings_frame->version());
   EXPECT_TRUE(settings_frame->is_control_frame());
   EXPECT_EQ(SETTINGS, settings_frame->type());
   EXPECT_EQ(0u, settings_frame->num_entries());

   // We'll add several different ID/Flag combinations and then verify
   // that they encode and decode properly.
   SettingsFlagsAndId ids[] = {
     0x00000000,
     0xffffffff,
     0xff000001,
     0x01000002,
   };

   for (size_t index = 0; index < arraysize(ids); ++index) {
     settings.insert(settings.end(), std::make_pair(ids[index], index));
     settings_frame.reset(framer.CreateSettings(settings));
     EXPECT_EQ(kSpdyProtocolVersion, settings_frame->version());
     EXPECT_TRUE(settings_frame->is_control_frame());
     EXPECT_EQ(SETTINGS, settings_frame->type());
     EXPECT_EQ(index + 1, settings_frame->num_entries());

     SpdySettings parsed_settings;
     EXPECT_TRUE(framer.ParseSettings(settings_frame.get(), &parsed_settings));
     EXPECT_EQ(parsed_settings.size(), settings.size());
     SpdySettings::const_iterator it = parsed_settings.begin();
     int pos = 0;
     while (it != parsed_settings.end()) {
       SettingsFlagsAndId parsed = it->first;
       uint32 value = it->second;
       EXPECT_EQ(parsed.flags(), ids[pos].flags());
       EXPECT_EQ(parsed.id(), ids[pos].id());
       EXPECT_EQ(value, static_cast<uint32>(pos));
       ++it;
       ++pos;
     }
   }
 }

 // 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(SpdyProtocolDeathTest, TestDataFrame) {
   SpdyDataFrame frame;

   frame.set_stream_id(0);
   // TODO(mbelshe):  implement EXPECT_DEBUG_DEATH on windows.
 #ifndef WIN32
   EXPECT_DEBUG_DEATH(frame.set_stream_id(~0), "");
 #endif
   EXPECT_FALSE(frame.is_control_frame());

   frame.set_flags(0);
 #ifndef WIN32
   EXPECT_DEBUG_DEATH(frame.set_length(~0), "");
 #endif
   EXPECT_EQ(0, frame.flags());
 }

 TEST(SpdyProtocolDeathTest, TestSpdyControlFrameStreamId) {
   SpdyControlFrame frame_store(SpdySynStreamControlFrame::size());
   memset(frame_store.data(), '1', SpdyControlFrame::size());
   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(SpdyProtocolDeathTest, TestSpdyControlFrameVersion) {
   const unsigned int kVersionMask = 0x7fff;
   SpdyControlFrame frame(SpdySynStreamControlFrame::size());
   memset(frame.data(), '1', SpdyControlFrame::size());

   // 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(SpdyProtocolDeathTest, TestSpdyControlFrameType) {
   SpdyControlFrame frame(SpdyControlFrame::size());
   memset(frame.data(), 255, SpdyControlFrame::size());

   // type() should be out of bounds.
   EXPECT_FALSE(frame.AppearsToBeAValidControlFrame());

   uint16 version = frame.version();

   for (int i = SYN_STREAM; i <= spdy::NOOP; ++i) {
     frame.set_type(static_cast<SpdyControlType>(i));
     EXPECT_EQ(i, static_cast<int>(frame.type()));
     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());
   }
 }

 }  // namespace
	// Copyright (c) 2011 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"

	using spdy::CONTROL_FLAG_FIN;
	using spdy::CONTROL_FLAG_NONE;
	using spdy::GOAWAY;
	using spdy::HEADERS;
	using spdy::NOOP;
	using spdy::PING;
	using spdy::RST_STREAM;
	using spdy::SETTINGS;
	using spdy::SYN_REPLY;
	using spdy::SYN_STREAM;
	using spdy::WINDOW_UPDATE;
	using spdy::FlagsAndLength;
	using spdy::SpdyControlFrame;
	using spdy::SpdyControlType;
	using spdy::SpdyDataFrame;
	using spdy::SpdyFrame;
	using spdy::SpdyFramer;
	using spdy::SpdyHeaderBlock;
	using spdy::SpdyGoAwayControlFrame;
	using spdy::SpdyRstStreamControlFrame;
	using spdy::SpdySettings;
	using spdy::SpdySettingsControlFrame;
	using spdy::SpdyStatusCodes;
	using spdy::SpdySynReplyControlFrame;
	using spdy::SpdySynStreamControlFrame;
	using spdy::SpdyWindowUpdateControlFrame;
	using spdy::SettingsFlagsAndId;
	using spdy::kLengthMask;
	using spdy::kSpdyProtocolVersion;
	using spdy::kStreamIdMask;

	namespace {

	// Test our protocol constants
	TEST(SpdyProtocolTest, ProtocolConstants) {
	EXPECT_EQ(8u, SpdyFrame::size());
	EXPECT_EQ(8u, SpdyDataFrame::size());
	EXPECT_EQ(8u, SpdyControlFrame::size());
	EXPECT_EQ(18u, SpdySynStreamControlFrame::size());
	EXPECT_EQ(14u, SpdySynReplyControlFrame::size());
	EXPECT_EQ(16u, SpdyRstStreamControlFrame::size());
	EXPECT_EQ(12u, SpdyGoAwayControlFrame::size());
	EXPECT_EQ(12u, SpdySettingsControlFrame::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(SpdyProtocolTest, FrameStructs) {
	SpdyFrame frame(SpdyFrame::size());
	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(SpdyProtocolTest, DataFrameStructs) {
	SpdyDataFrame data_frame;
	data_frame.set_stream_id(12345);
	EXPECT_EQ(12345u, data_frame.stream_id());
	}

	TEST(SpdyProtocolTest, ControlFrameStructs) {
	SpdyFramer framer;
	SpdyHeaderBlock headers;

	scoped_ptr<SpdySynStreamControlFrame> syn_frame(
	framer.CreateSynStream(123, 456, 2, CONTROL_FLAG_FIN, false, &headers));
	EXPECT_EQ(kSpdyProtocolVersion, 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());
	EXPECT_EQ(2u, syn_frame->priority());
	EXPECT_EQ(2, syn_frame->header_block_len());
	EXPECT_EQ(1u, syn_frame->flags());
	syn_frame->set_associated_stream_id(999u);
	EXPECT_EQ(123u, syn_frame->stream_id());
	EXPECT_EQ(999u, syn_frame->associated_stream_id());

	scoped_ptr<SpdySynReplyControlFrame> syn_reply(
	framer.CreateSynReply(123, CONTROL_FLAG_NONE, false, &headers));
	EXPECT_EQ(kSpdyProtocolVersion, syn_reply->version());
	EXPECT_TRUE(syn_reply->is_control_frame());
	EXPECT_EQ(SYN_REPLY, syn_reply->type());
	EXPECT_EQ(123u, syn_reply->stream_id());
	EXPECT_EQ(2, syn_reply->header_block_len());
	EXPECT_EQ(0, syn_reply->flags());

	scoped_ptr<SpdyRstStreamControlFrame> rst_frame(
	framer.CreateRstStream(123, spdy::PROTOCOL_ERROR));
	EXPECT_EQ(kSpdyProtocolVersion, rst_frame->version());
	EXPECT_TRUE(rst_frame->is_control_frame());
	EXPECT_EQ(RST_STREAM, rst_frame->type());
	EXPECT_EQ(123u, rst_frame->stream_id());
	EXPECT_EQ(spdy::PROTOCOL_ERROR, rst_frame->status());
	rst_frame->set_status(spdy::INVALID_STREAM);
	EXPECT_EQ(spdy::INVALID_STREAM, rst_frame->status());
	EXPECT_EQ(0, rst_frame->flags());

	scoped_ptr<SpdyGoAwayControlFrame> goaway_frame(
	framer.CreateGoAway(123));
	EXPECT_EQ(kSpdyProtocolVersion, goaway_frame->version());
	EXPECT_TRUE(goaway_frame->is_control_frame());
	EXPECT_EQ(GOAWAY, goaway_frame->type());
	EXPECT_EQ(123u, goaway_frame->last_accepted_stream_id());

	scoped_ptr<SpdyWindowUpdateControlFrame> window_update_frame(
	framer.CreateWindowUpdate(123, 456));
	EXPECT_EQ(kSpdyProtocolVersion, 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(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());

	// Set length to various values. Make sure that when you set_length(x),
	// length() == x. Also make sure the flags are unaltered.
	memset(frame.data(), '1', SpdyDataFrame::size());
	int8 flags = frame.flags();
	frame.set_length(0);
	EXPECT_EQ(0u, frame.length());
	EXPECT_EQ(flags, frame.flags());
	frame.set_length(kLengthMask);
	EXPECT_EQ(kLengthMask, frame.length());
	EXPECT_EQ(flags, frame.flags());
	frame.set_length(5u);
	EXPECT_EQ(5u, frame.length());
	EXPECT_EQ(flags, frame.flags());

	// Set flags to various values. Make sure that when you set_flags(x),
	// flags() == x. Also make sure the length is unaltered.
	memset(frame.data(), '1', SpdyDataFrame::size());
	uint32 length = frame.length();
	frame.set_flags(0u);
	EXPECT_EQ(0u, frame.flags());
	EXPECT_EQ(length, frame.length());
	int8 all_flags = ~0;
	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(SpdyProtocolTest, TestSpdySettingsFrame) {
	SpdyFramer framer;

	// Create a settings frame with no settings.
	SpdySettings settings;
	scoped_ptr<SpdySettingsControlFrame> settings_frame(
	framer.CreateSettings(settings));
	EXPECT_EQ(kSpdyProtocolVersion, settings_frame->version());
	EXPECT_TRUE(settings_frame->is_control_frame());
	EXPECT_EQ(SETTINGS, settings_frame->type());
	EXPECT_EQ(0u, settings_frame->num_entries());

	// We'll add several different ID/Flag combinations and then verify
	// that they encode and decode properly.
	SettingsFlagsAndId ids[] = {
	0x00000000,
	0xffffffff,
	0xff000001,
	0x01000002,
	};

	for (size_t index = 0; index < arraysize(ids); ++index) {
	settings.insert(settings.end(), std::make_pair(ids[index], index));
	settings_frame.reset(framer.CreateSettings(settings));
	EXPECT_EQ(kSpdyProtocolVersion, settings_frame->version());
	EXPECT_TRUE(settings_frame->is_control_frame());
	EXPECT_EQ(SETTINGS, settings_frame->type());
	EXPECT_EQ(index + 1, settings_frame->num_entries());

	SpdySettings parsed_settings;
	EXPECT_TRUE(framer.ParseSettings(settings_frame.get(), &parsed_settings));
	EXPECT_EQ(parsed_settings.size(), settings.size());
	SpdySettings::const_iterator it = parsed_settings.begin();
	int pos = 0;
	while (it != parsed_settings.end()) {
	SettingsFlagsAndId parsed = it->first;
	uint32 value = it->second;
	EXPECT_EQ(parsed.flags(), ids[pos].flags());
	EXPECT_EQ(parsed.id(), ids[pos].id());
	EXPECT_EQ(value, static_cast<uint32>(pos));
	++it;
	++pos;
	}
	}
	}

	// 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(SpdyProtocolDeathTest, TestDataFrame) {
	SpdyDataFrame frame;

	frame.set_stream_id(0);
	// TODO(mbelshe): implement EXPECT_DEBUG_DEATH on windows.
	#ifndef WIN32
	EXPECT_DEBUG_DEATH(frame.set_stream_id(~0), "");
	#endif
	EXPECT_FALSE(frame.is_control_frame());

	frame.set_flags(0);
	#ifndef WIN32
	EXPECT_DEBUG_DEATH(frame.set_length(~0), "");
	#endif
	EXPECT_EQ(0, frame.flags());
	}

	TEST(SpdyProtocolDeathTest, TestSpdyControlFrameStreamId) {
	SpdyControlFrame frame_store(SpdySynStreamControlFrame::size());
	memset(frame_store.data(), '1', SpdyControlFrame::size());
	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(SpdyProtocolDeathTest, TestSpdyControlFrameVersion) {
	const unsigned int kVersionMask = 0x7fff;
	SpdyControlFrame frame(SpdySynStreamControlFrame::size());
	memset(frame.data(), '1', SpdyControlFrame::size());

	// 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(SpdyProtocolDeathTest, TestSpdyControlFrameType) {
	SpdyControlFrame frame(SpdyControlFrame::size());
	memset(frame.data(), 255, SpdyControlFrame::size());

	// type() should be out of bounds.
	EXPECT_FALSE(frame.AppearsToBeAValidControlFrame());

	uint16 version = frame.version();

	for (int i = SYN_STREAM; i <= spdy::NOOP; ++i) {
	frame.set_type(static_cast<SpdyControlType>(i));
	EXPECT_EQ(i, static_cast<int>(frame.type()));
	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());
	}
	}

	} // namespace