net/spdy/spdy_protocol_test.cc - Issue 9618002: SPDY - integration of spdy/3 code.

Unified Diff: net/spdy/spdy_protocol_test.cc

Issue 9618002: SPDY - integration of spdy/3 code. (Closed) Base URL: svn://chrome-svn/chrome/trunk/src/

Patch Set: Created 8 years, 9 months ago

Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.

Jump to:

View side-by-side diff with in-line comments

Index: net/spdy/spdy_protocol_test.cc

===================================================================

--- net/spdy/spdy_protocol_test.cc (revision 125802)

+++ net/spdy/spdy_protocol_test.cc (working copy)

@@ -1,4 +1,4 @@

// Use of this source code is governed by a BSD-style license that can be

// found in the LICENSE file.

@@ -11,6 +11,7 @@

using spdy::CONTROL_FLAG_FIN;

using spdy::CONTROL_FLAG_NONE;

+using spdy::FlagsAndLength;

using spdy::GOAWAY;

using spdy::HEADERS;

using spdy::NOOP;

@@ -20,17 +21,15 @@

using spdy::SETTINGS;

using spdy::SYN_REPLY;

using spdy::SYN_STREAM;

-using spdy::WINDOW_UPDATE;

-using spdy::FlagsAndLength;

+using spdy::SettingsFlagsAndId;

using spdy::SpdyControlFrame;

using spdy::SpdyControlType;

using spdy::SpdyDataFrame;

using spdy::SpdyFrame;

using spdy::SpdyFramer;

+using spdy::SpdyGoAwayControlFrame;

using spdy::SpdyHeaderBlock;

using spdy::SpdyHeadersControlFrame;

-using spdy::SpdyGoAwayControlFrame;

-using spdy::SpdyNoOpControlFrame;

using spdy::SpdyPingControlFrame;

using spdy::SpdyRstStreamControlFrame;

using spdy::SpdySettings;

@@ -39,9 +38,8 @@

using spdy::SpdySynReplyControlFrame;

using spdy::SpdySynStreamControlFrame;

using spdy::SpdyWindowUpdateControlFrame;

-using spdy::SettingsFlagsAndId;

+using spdy::WINDOW_UPDATE;

using spdy::kLengthMask;

-using spdy::kSpdyProtocolVersion;

using spdy::kStreamIdMask;

namespace {

@@ -52,13 +50,12 @@

EXPECT_EQ(8u, SpdyDataFrame::size());

EXPECT_EQ(8u, SpdyControlFrame::kHeaderSize);

EXPECT_EQ(18u, SpdySynStreamControlFrame::size());

- EXPECT_EQ(14u, SpdySynReplyControlFrame::size());

+ EXPECT_EQ(12u, SpdySynReplyControlFrame::size());

Ryan Hamilton 2012/03/09 19:09:58 Why is this changing? Just want to make sure we'r

ramant (doing other things) 2012/03/10 01:14:09 Added separate tests for SPDY/2 and SPDY/3. Done.

EXPECT_EQ(16u, SpdyRstStreamControlFrame::size());

EXPECT_EQ(12u, SpdySettingsControlFrame::size());

- EXPECT_EQ(8u, SpdyNoOpControlFrame::size());

EXPECT_EQ(12u, SpdyPingControlFrame::size());

EXPECT_EQ(12u, SpdyGoAwayControlFrame::size());

- EXPECT_EQ(14u, SpdyHeadersControlFrame::size());

+ EXPECT_EQ(12u, SpdyHeadersControlFrame::size());

EXPECT_EQ(16u, SpdyWindowUpdateControlFrame::size());

EXPECT_EQ(4u, sizeof(FlagsAndLength));

EXPECT_EQ(1, SYN_STREAM);

@@ -95,18 +92,19 @@

}

TEST(SpdyProtocolTest, ControlFrameStructs) {

- SpdyFramer framer;

+ SpdyFramer framer(SPDY_VERSION_FOR_TESTS);

Ryan Hamilton 2012/03/09 19:09:58 Where is this defined? We want to make sure we're

ramant (doing other things) 2012/03/10 01:14:09 Forked this test for spdy/2 and spdy/3. Done.

SpdyHeaderBlock headers;

scoped_ptr<SpdySynStreamControlFrame> syn_frame(

framer.CreateSynStream(123, 456, 2, CONTROL_FLAG_FIN, false, &headers));

- EXPECT_EQ(kSpdyProtocolVersion, syn_frame->version());

+ 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());

EXPECT_EQ(2u, syn_frame->priority());

- EXPECT_EQ(2, syn_frame->header_block_len());

+ EXPECT_EQ((SPDY_VERSION_FOR_TESTS < 3) ? 2 : 4,

+ 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());

@@ -114,16 +112,17 @@

scoped_ptr<SpdySynReplyControlFrame> syn_reply(

framer.CreateSynReply(123, CONTROL_FLAG_NONE, false, &headers));

- EXPECT_EQ(kSpdyProtocolVersion, syn_reply->version());

+ EXPECT_EQ(framer.protocol_version(), 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((SPDY_VERSION_FOR_TESTS < 3) ? 2 : 4,

+ 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_EQ(framer.protocol_version(), rst_frame->version());

EXPECT_TRUE(rst_frame->is_control_frame());

EXPECT_EQ(RST_STREAM, rst_frame->type());

EXPECT_EQ(123u, rst_frame->stream_id());

@@ -132,18 +131,11 @@

EXPECT_EQ(spdy::INVALID_STREAM, rst_frame->status());

EXPECT_EQ(0, rst_frame->flags());

- scoped_ptr<SpdyNoOpControlFrame> noop_frame(

- framer.CreateNopFrame());

- EXPECT_EQ(kSpdyProtocolVersion, noop_frame->version());

- EXPECT_TRUE(noop_frame->is_control_frame());

- EXPECT_EQ(NOOP, noop_frame->type());

- EXPECT_EQ(0, noop_frame->flags());

const uint32 kUniqueId = 1234567u;

const uint32 kUniqueId2 = 31415926u;

scoped_ptr<SpdyPingControlFrame> ping_frame(

framer.CreatePingFrame(kUniqueId));

- EXPECT_EQ(kSpdyProtocolVersion, ping_frame->version());

+ EXPECT_EQ(framer.protocol_version(), ping_frame->version());

EXPECT_TRUE(ping_frame->is_control_frame());

EXPECT_EQ(PING, ping_frame->type());

EXPECT_EQ(kUniqueId, ping_frame->unique_id());

@@ -152,23 +144,24 @@

scoped_ptr<SpdyGoAwayControlFrame> goaway_frame(

framer.CreateGoAway(123));

- EXPECT_EQ(kSpdyProtocolVersion, goaway_frame->version());

+ EXPECT_EQ(framer.protocol_version(), 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<SpdyHeadersControlFrame> headers_frame(

framer.CreateHeaders(123, CONTROL_FLAG_NONE, false, &headers));

- EXPECT_EQ(kSpdyProtocolVersion, headers_frame->version());

+ EXPECT_EQ(framer.protocol_version(), headers_frame->version());

EXPECT_TRUE(headers_frame->is_control_frame());

EXPECT_EQ(HEADERS, headers_frame->type());

EXPECT_EQ(123u, headers_frame->stream_id());

- EXPECT_EQ(2, headers_frame->header_block_len());

+ EXPECT_EQ((SPDY_VERSION_FOR_TESTS < 3) ? 2 : 4,

+ headers_frame->header_block_len());

EXPECT_EQ(0, headers_frame->flags());

scoped_ptr<SpdyWindowUpdateControlFrame> window_update_frame(

framer.CreateWindowUpdate(123, 456));

- EXPECT_EQ(kSpdyProtocolVersion, window_update_frame->version());

+ 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());

@@ -219,13 +212,13 @@

// Test various types of SETTINGS frames.

TEST(SpdyProtocolTest, TestSpdySettingsFrame) {

- SpdyFramer framer;

+ 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(kSpdyProtocolVersion, settings_frame->version());

+ 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());

@@ -233,31 +226,33 @@

// We'll add several different ID/Flag combinations and then verify

// that they encode and decode properly.

SettingsFlagsAndId ids[] = {

- 0x00000000,

- 0xffffffff,

- 0xff000001,

- 0x01000002,

+ SettingsFlagsAndId::FromWireFormat(SPDY_VERSION_FOR_TESTS, 0x00000000),

+ SettingsFlagsAndId::FromWireFormat(SPDY_VERSION_FOR_TESTS, 0xffffffff),

+ SettingsFlagsAndId::FromWireFormat(SPDY_VERSION_FOR_TESTS, 0xff000001),

+ SettingsFlagsAndId::FromWireFormat(SPDY_VERSION_FOR_TESTS, 0xffffffff),

+ SettingsFlagsAndId::FromWireFormat(SPDY_VERSION_FOR_TESTS, 0x01000002),

+ SettingsFlagsAndId(3, 1)

};

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_EQ(framer.protocol_version(), 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());

+ EXPECT_EQ(settings.size(), parsed_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));

+ EXPECT_EQ(ids[pos].flags(), parsed.flags());

+ EXPECT_EQ(ids[pos].id(), parsed.id());

+ EXPECT_EQ(static_cast<uint32>(pos), value);

++it;

++pos;

}

@@ -351,10 +346,15 @@

uint16 version = frame.version();

- for (int i = SYN_STREAM; i <= spdy::NOOP; ++i) {

+ 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()));

- EXPECT_TRUE(frame.AppearsToBeAValidControlFrame());

+ if (i == spdy::NOOP) {

+ // NOOP frames aren't 'valid'.

Ryan Hamilton 2012/03/09 19:09:58 NOOP is valid in spdy/2 right?

ramant (doing other things) 2012/03/10 01:14:09 Checked in SPDY/2 tests and kept the as above for

+ 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());

@@ -362,7 +362,7 @@

}

TEST(SpdyProtocolDeathTest, TestRstStreamStatusBounds) {

- SpdyFramer framer;

+ SpdyFramer framer(SPDY_VERSION_FOR_TESTS);

scoped_ptr<SpdyRstStreamControlFrame> rst_frame;

rst_frame.reset(framer.CreateRstStream(123, spdy::PROTOCOL_ERROR));

« net/spdy/spdy_protocol.h ('K') | « net/spdy/spdy_protocol.h ('k') | net/spdy/spdy_proxy_client_socket_spdy2_unittest.cc » ('j') | net/spdy/spdy_session.h » ('J')