Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(186)

Issues Search
    My Issues | Starred     Open | Closed | All

Unified Diff: net/spdy/spdy_framer_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
Download patch
« no previous file with comments | « net/spdy/spdy_framer_spdy3_test.cc ('k') | net/spdy/spdy_http_stream_spdy2_unittest.cc » ('j') | no next file with comments »
Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
Index: net/spdy/spdy_framer_test.cc
===================================================================
--- net/spdy/spdy_framer_test.cc (revision 126086)
+++ net/spdy/spdy_framer_test.cc (working copy)
@@ -1,1871 +0,0 @@
-// 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 <algorithm>
-#include <iostream>
-
-#include "base/memory/scoped_ptr.h"
-#include "net/spdy/spdy_framer.h"
-#include "net/spdy/spdy_protocol.h"
-#include "net/spdy/spdy_frame_builder.h"
-#include "testing/platform_test.h"
-
-namespace spdy {
-
-namespace test {
-
-std::string HexDumpWithMarks(const unsigned char* data, int length,
- const bool* marks, int mark_length) {
- static const char kHexChars[] = "0123456789ABCDEF";
- static const int kColumns = 4;
-
- const int kSizeLimit = 1024;
- if (length > kSizeLimit || mark_length > kSizeLimit) {
- LOG(ERROR) << "Only dumping first " << kSizeLimit << " bytes.";
- length = std::min(length, kSizeLimit);
- mark_length = std::min(mark_length, kSizeLimit);
- }
-
- std::string hex;
- for (const unsigned char* row = data; length > 0;
- row += kColumns, length -= kColumns) {
- for (const unsigned char *p = row; p < row + 4; ++p) {
- if (p < row + length) {
- const bool mark =
- (marks && (p - data) < mark_length && marks[p - data]);
- hex += mark ? '*' : ' ';
- hex += kHexChars[(*p & 0xf0) >> 4];
- hex += kHexChars[*p & 0x0f];
- hex += mark ? '*' : ' ';
- } else {
- hex += " ";
- }
- }
- hex = hex + " ";
-
- for (const unsigned char *p = row; p < row + 4 && p < row + length; ++p)
- hex += (*p >= 0x20 && *p <= 0x7f) ? (*p) : '.';
-
- hex = hex + '\n';
- }
- return hex;
-}
-
-void CompareCharArraysWithHexError(
- const std::string& description,
- const unsigned char* actual,
- const int actual_len,
- const unsigned char* expected,
- const int expected_len) {
- const int min_len = actual_len > expected_len ? expected_len : actual_len;
- const int max_len = actual_len > expected_len ? actual_len : expected_len;
- scoped_array<bool> marks(new bool[max_len]);
- bool identical = (actual_len == expected_len);
- for (int i = 0; i < min_len; ++i) {
- if (actual[i] != expected[i]) {
- marks[i] = true;
- identical = false;
- } else {
- marks[i] = false;
- }
- }
- for (int i = min_len; i < max_len; ++i) {
- marks[i] = true;
- }
- if (identical) return;
- ADD_FAILURE()
- << "Description:\n"
- << description
- << "\n\nExpected:\n"
- << HexDumpWithMarks(expected, expected_len, marks.get(), max_len)
- << "\nActual:\n"
- << HexDumpWithMarks(actual, actual_len, marks.get(), max_len);
-}
-
-class TestSpdyVisitor : public SpdyFramerVisitorInterface {
- public:
- static const size_t kDefaultHeaderBufferSize = 64 * 1024;
- static const size_t kDefaultCredentialBufferSize = 16 * 1024;
-
- TestSpdyVisitor()
- : use_compression_(false),
- error_count_(0),
- syn_frame_count_(0),
- syn_reply_frame_count_(0),
- headers_frame_count_(0),
- goaway_count_(0),
- credential_count_(0),
- data_bytes_(0),
- fin_frame_count_(0),
- fin_flag_count_(0),
- zero_length_data_frame_count_(0),
- header_blocks_count_(0),
- control_frame_header_data_count_(0),
- zero_length_control_frame_header_data_count_(0),
- data_frame_count_(0),
- header_buffer_(new char[kDefaultHeaderBufferSize]),
- header_buffer_length_(0),
- header_buffer_size_(kDefaultHeaderBufferSize),
- header_stream_id_(-1),
- header_control_type_(NUM_CONTROL_FRAME_TYPES),
- header_buffer_valid_(false),
- credential_buffer_(new char[kDefaultCredentialBufferSize]),
- credential_buffer_length_(0),
- credential_buffer_size_(kDefaultCredentialBufferSize) {
- }
-
- void OnError(SpdyFramer* f) {
- LOG(INFO) << "SpdyFramer Error: "
- << SpdyFramer::ErrorCodeToString(f->error_code());
- error_count_++;
- }
-
- void OnDataFrameHeader(const SpdyDataFrame* frame) {
- data_frame_count_++;
- header_stream_id_ = frame->stream_id();
- }
-
- void OnStreamFrameData(SpdyStreamId stream_id,
- const char* data,
- size_t len) {
- EXPECT_EQ(header_stream_id_, stream_id);
- if (len == 0)
- ++zero_length_data_frame_count_;
-
- data_bytes_ += len;
- std::cerr << "OnStreamFrameData(" << stream_id << ", \"";
- if (len > 0) {
- for (size_t i = 0 ; i < len; ++i) {
- std::cerr << std::hex << (0xFF & (unsigned int)data[i]) << std::dec;
- }
- }
- std::cerr << "\", " << len << ")\n";
- }
-
- void OnControl(const SpdyControlFrame* frame) {
- switch (frame->type()) {
- case SYN_STREAM:
- syn_frame_count_++;
- InitHeaderStreaming(frame);
- break;
- case SYN_REPLY:
- syn_reply_frame_count_++;
- InitHeaderStreaming(frame);
- break;
- case RST_STREAM:
- fin_frame_count_++;
- break;
- case HEADERS:
- headers_frame_count_++;
- InitHeaderStreaming(frame);
- break;
- case GOAWAY:
- goaway_count_++;
- break;
- case CREDENTIAL:
- credential_count_++;
- break;
- default:
- DLOG(FATAL); // Error!
- }
- if (frame->flags() & CONTROL_FLAG_FIN)
- ++fin_flag_count_;
- }
-
- bool OnControlFrameHeaderData(SpdyStreamId stream_id,
- const char* header_data,
- size_t len) {
- ++control_frame_header_data_count_;
- CHECK_EQ(header_stream_id_, stream_id);
- if (len == 0) {
- ++zero_length_control_frame_header_data_count_;
- // Indicates end-of-header-block.
- CHECK(header_buffer_valid_);
- bool parsed_headers = SpdyFramer::ParseHeaderBlockInBuffer(
- header_buffer_.get(), header_buffer_length_, &headers_);
- DCHECK(parsed_headers);
- return true;
- }
- const size_t available = header_buffer_size_ - header_buffer_length_;
- if (len > available) {
- header_buffer_valid_ = false;
- return false;
- }
- memcpy(header_buffer_.get() + header_buffer_length_, header_data, len);
- header_buffer_length_ += len;
- return true;
- }
-
- bool OnCredentialFrameData(const char* credential_data, size_t len) {
- if (len == 0) {
- if (!framer_.ParseCredentialData(credential_buffer_.get(),
- credential_buffer_length_,
- &credential_)) {
- ++error_count_;
- }
- return true;
- }
- const size_t available =
- credential_buffer_size_ - credential_buffer_length_;
- if (len > available) {
- return false;
- }
- memcpy(credential_buffer_.get() + credential_buffer_length_,
- credential_data, len);
- credential_buffer_length_ += len;
- return true;
- }
-
- // Convenience function which runs a framer simulation with particular input.
- void SimulateInFramer(const unsigned char* input, size_t size) {
- framer_.set_enable_compression(use_compression_);
- framer_.set_visitor(this);
- size_t input_remaining = size;
- const char* input_ptr = reinterpret_cast<const char*>(input);
- while (input_remaining > 0 &&
- framer_.error_code() == SpdyFramer::SPDY_NO_ERROR) {
- // To make the tests more interesting, we feed random (amd small) chunks
- // into the framer. This simulates getting strange-sized reads from
- // the socket.
- const size_t kMaxReadSize = 32;
- size_t bytes_read =
- (rand() % std::min(input_remaining, kMaxReadSize)) + 1;
- size_t bytes_processed = framer_.ProcessInput(input_ptr, bytes_read);
- input_remaining -= bytes_processed;
- input_ptr += bytes_processed;
- if (framer_.state() == SpdyFramer::SPDY_DONE)
- framer_.Reset();
- }
- }
-
- void InitHeaderStreaming(const SpdyControlFrame* frame) {
- memset(header_buffer_.get(), 0, header_buffer_size_);
- header_buffer_length_ = 0;
- header_stream_id_ = SpdyFramer::GetControlFrameStreamId(frame);
- header_control_type_ = frame->type();
- header_buffer_valid_ = true;
- DCHECK_NE(header_stream_id_, SpdyFramer::kInvalidStream);
- }
-
- // Override the default buffer size (16K). Call before using the framer!
- void set_header_buffer_size(size_t header_buffer_size) {
- header_buffer_size_ = header_buffer_size;
- header_buffer_.reset(new char[header_buffer_size]);
- }
-
- static size_t control_frame_buffer_max_size() {
- return SpdyFramer::kControlFrameBufferMaxSize;
- }
-
- static size_t header_data_chunk_max_size() {
- return SpdyFramer::kHeaderDataChunkMaxSize;
- }
-
- SpdyFramer framer_;
- bool use_compression_;
-
- // Counters from the visitor callbacks.
- int error_count_;
- int syn_frame_count_;
- int syn_reply_frame_count_;
- int headers_frame_count_;
- int goaway_count_;
- int credential_count_;
- int data_bytes_;
- int fin_frame_count_; // The count of RST_STREAM type frames received.
- int fin_flag_count_; // The count of frames with the FIN flag set.
- int zero_length_data_frame_count_; // The count of zero-length data frames.
- int header_blocks_count_;
- int control_frame_header_data_count_; // The count of chunks received.
- // The count of zero-length control frame header data chunks received.
- int zero_length_control_frame_header_data_count_;
- int data_frame_count_;
-
- // Header block streaming state:
- scoped_array<char> header_buffer_;
- size_t header_buffer_length_;
- size_t header_buffer_size_;
- SpdyStreamId header_stream_id_;
- SpdyControlType header_control_type_;
- bool header_buffer_valid_;
- SpdyHeaderBlock headers_;
-
- scoped_array<char> credential_buffer_;
- size_t credential_buffer_length_;
- size_t credential_buffer_size_;
- SpdyCredential credential_;
-};
-
-} // namespace test
-
-} // namespace spdy
-
-using spdy::SpdyControlFlags;
-using spdy::SpdyControlFrame;
-using spdy::SpdyDataFrame;
-using spdy::SpdyFrame;
-using spdy::SpdyFrameBuilder;
-using spdy::SpdyFramer;
-using spdy::SpdyHeaderBlock;
-using spdy::SpdySynStreamControlFrame;
-using spdy::kControlFlagMask;
-using spdy::kLengthMask;
-using spdy::CONTROL_FLAG_NONE;
-using spdy::DATA_FLAG_COMPRESSED;
-using spdy::DATA_FLAG_FIN;
-using spdy::SYN_STREAM;
-using spdy::test::CompareCharArraysWithHexError;
-using spdy::test::TestSpdyVisitor;
-
-namespace spdy {
-
-TEST(SpdyFrameBuilderTest, WriteLimits) {
- SpdyFrameBuilder builder(kLengthMask + 4);
- // length field should fail.
- EXPECT_FALSE(builder.WriteBytes(reinterpret_cast<const void*>(0x1),
- kLengthMask + 1));
- EXPECT_EQ(0, builder.length());
-
- // Writing a block of the maximum allowed size should succeed.
- const std::string kLargeData(kLengthMask, 'A');
- builder.WriteUInt32(kLengthMask);
- EXPECT_EQ(4, builder.length());
- EXPECT_TRUE(builder.WriteBytes(kLargeData.data(), kLengthMask));
- EXPECT_EQ(4 + kLengthMask, static_cast<unsigned>(builder.length()));
-}
-
-class SpdyFramerTest : public PlatformTest {
- public:
- virtual void TearDown() {}
-
- protected:
- void CompareFrame(const std::string& description,
- const SpdyFrame& actual_frame,
- const unsigned char* expected,
- const int expected_len) {
- const unsigned char* actual =
- reinterpret_cast<const unsigned char*>(actual_frame.data());
- int actual_len = actual_frame.length() + SpdyFrame::kHeaderSize;
- CompareCharArraysWithHexError(
- description, actual, actual_len, expected, expected_len);
- }
-
- // Returns true if the two header blocks have equivalent content.
- bool CompareHeaderBlocks(const SpdyHeaderBlock* expected,
- const SpdyHeaderBlock* actual) {
- if (expected->size() != actual->size()) {
- LOG(ERROR) << "Expected " << expected->size() << " headers; actually got "
- << actual->size() << "." << std::endl;
- return false;
- }
- for (SpdyHeaderBlock::const_iterator it = expected->begin();
- it != expected->end();
- ++it) {
- SpdyHeaderBlock::const_iterator it2 = actual->find(it->first);
- if (it2 == actual->end()) {
- LOG(ERROR) << "Expected header name '" << it->first << "'."
- << std::endl;
- return false;
- }
- if (it->second.compare(it2->second) != 0) {
- LOG(ERROR) << "Expected header named '" << it->first
- << "' to have a value of '" << it->second
- << "'. The actual value received was '" << it2->second
- << "'." << std::endl;
- return false;
- }
- }
- return true;
- }
-};
-
-
-// Test that we can encode and decode a SpdyHeaderBlock in serialized form.
-TEST_F(SpdyFramerTest, HeaderBlockInBuffer) {
- SpdyHeaderBlock headers;
- headers["alpha"] = "beta";
- headers["gamma"] = "charlie";
- SpdyFramer framer;
-
- // Encode the header block into a SynStream frame.
- scoped_ptr<SpdySynStreamControlFrame> frame(
- framer.CreateSynStream(1, 0, 1, CONTROL_FLAG_NONE, false, &headers));
- EXPECT_TRUE(frame.get() != NULL);
- std::string serialized_headers(frame->header_block(),
- frame->header_block_len());
- SpdyHeaderBlock new_headers;
- EXPECT_TRUE(framer.ParseHeaderBlockInBuffer(serialized_headers.c_str(),
- serialized_headers.size(),
- &new_headers));
-
- EXPECT_EQ(headers.size(), new_headers.size());
- EXPECT_EQ(headers["alpha"], new_headers["alpha"]);
- EXPECT_EQ(headers["gamma"], new_headers["gamma"]);
-}
-
-// Test that if there's not a full frame, we fail to parse it.
-TEST_F(SpdyFramerTest, UndersizedHeaderBlockInBuffer) {
- SpdyHeaderBlock headers;
- headers["alpha"] = "beta";
- headers["gamma"] = "charlie";
- SpdyFramer framer;
-
- // Encode the header block into a SynStream frame.
- scoped_ptr<SpdySynStreamControlFrame> frame(
- framer.CreateSynStream(1, 0, 1, CONTROL_FLAG_NONE, false, &headers));
- EXPECT_TRUE(frame.get() != NULL);
-
- std::string serialized_headers(frame->header_block(),
- frame->header_block_len());
- SpdyHeaderBlock new_headers;
- EXPECT_FALSE(framer.ParseHeaderBlockInBuffer(serialized_headers.c_str(),
- serialized_headers.size() - 2,
- &new_headers));
-}
-
-TEST_F(SpdyFramerTest, OutOfOrderHeaders) {
- // Frame builder with plentiful buffer size.
- SpdyFrameBuilder frame(1024);
-
- frame.WriteUInt16(kControlFlagMask | 1);
- frame.WriteUInt16(SYN_STREAM);
- frame.WriteUInt32(0); // Placeholder for the length.
- frame.WriteUInt32(3); // stream_id
- frame.WriteUInt32(0); // Associated stream id
- frame.WriteUInt16(0); // Priority.
-
- frame.WriteUInt16(2); // Number of headers.
- SpdyHeaderBlock::iterator it;
- frame.WriteString("gamma");
- frame.WriteString("gamma");
- frame.WriteString("alpha");
- frame.WriteString("alpha");
- // write the length
- frame.WriteUInt32ToOffset(4, frame.length() - SpdyFrame::kHeaderSize);
-
- SpdyHeaderBlock new_headers;
- scoped_ptr<SpdyFrame> control_frame(frame.take());
- SpdySynStreamControlFrame syn_frame(control_frame->data(), false);
- std::string serialized_headers(syn_frame.header_block(),
- syn_frame.header_block_len());
- SpdyFramer framer;
- framer.set_enable_compression(false);
- EXPECT_TRUE(framer.ParseHeaderBlockInBuffer(serialized_headers.c_str(),
- serialized_headers.size(),
- &new_headers));
-}
-
-TEST_F(SpdyFramerTest, DuplicateHeader) {
- // Frame builder with plentiful buffer size.
- SpdyFrameBuilder frame(1024);
-
- frame.WriteUInt16(kControlFlagMask | 1);
- frame.WriteUInt16(SYN_STREAM);
- frame.WriteUInt32(0); // Placeholder for the length.
- frame.WriteUInt32(3); // stream_id
- frame.WriteUInt32(0); // associated stream id
- frame.WriteUInt16(0); // Priority.
-
- frame.WriteUInt16(2); // Number of headers.
- SpdyHeaderBlock::iterator it;
- frame.WriteString("name");
- frame.WriteString("value1");
- frame.WriteString("name");
- frame.WriteString("value2");
- // write the length
- frame.WriteUInt32ToOffset(4, frame.length() - SpdyFrame::kHeaderSize);
-
- SpdyHeaderBlock new_headers;
- scoped_ptr<SpdyFrame> control_frame(frame.take());
- SpdySynStreamControlFrame syn_frame(control_frame->data(), false);
- std::string serialized_headers(syn_frame.header_block(),
- syn_frame.header_block_len());
- SpdyFramer framer;
- framer.set_enable_compression(false);
- // This should fail because duplicate headers are verboten by the spec.
- EXPECT_FALSE(framer.ParseHeaderBlockInBuffer(serialized_headers.c_str(),
- serialized_headers.size(),
- &new_headers));
-}
-
-TEST_F(SpdyFramerTest, MultiValueHeader) {
- // Frame builder with plentiful buffer size.
- SpdyFrameBuilder frame(1024);
-
- frame.WriteUInt16(kControlFlagMask | 1);
- frame.WriteUInt16(SYN_STREAM);
- frame.WriteUInt32(0); // Placeholder for the length.
- frame.WriteUInt32(3); // stream_id
- frame.WriteUInt32(0); // associated stream id
- frame.WriteUInt16(0); // Priority.
-
- frame.WriteUInt16(1); // Number of headers.
- SpdyHeaderBlock::iterator it;
- frame.WriteString("name");
- std::string value("value1\0value2");
- frame.WriteString(value);
- // write the length
- frame.WriteUInt32ToOffset(4, frame.length() - SpdyFrame::kHeaderSize);
-
- SpdyHeaderBlock new_headers;
- scoped_ptr<SpdyFrame> control_frame(frame.take());
- SpdySynStreamControlFrame syn_frame(control_frame->data(), false);
- std::string serialized_headers(syn_frame.header_block(),
- syn_frame.header_block_len());
- SpdyFramer framer;
- framer.set_enable_compression(false);
- EXPECT_TRUE(framer.ParseHeaderBlockInBuffer(serialized_headers.c_str(),
- serialized_headers.size(),
- &new_headers));
- EXPECT_TRUE(new_headers.find("name") != new_headers.end());
- EXPECT_EQ(value, new_headers.find("name")->second);
-}
-
-TEST_F(SpdyFramerTest, BasicCompression) {
- SpdyHeaderBlock headers;
- headers["server"] = "SpdyServer 1.0";
- headers["date"] = "Mon 12 Jan 2009 12:12:12 PST";
- headers["status"] = "200";
- headers["version"] = "HTTP/1.1";
- headers["content-type"] = "text/html";
- headers["content-length"] = "12";
-
- SpdyFramer framer;
- framer.set_enable_compression(true);
- scoped_ptr<SpdySynStreamControlFrame>
- frame1(framer.CreateSynStream(1, 0, 1, CONTROL_FLAG_NONE, true,
- &headers));
- scoped_ptr<SpdySynStreamControlFrame>
- frame2(framer.CreateSynStream(1, 0, 1, CONTROL_FLAG_NONE, true,
- &headers));
-
- // Expect the second frame to be more compact than the first.
- EXPECT_LE(frame2->length(), frame1->length());
-
- // Decompress the first frame
- scoped_ptr<SpdyFrame> frame3(framer.DecompressFrame(*frame1.get()));
-
- // Decompress the second frame
- scoped_ptr<SpdyFrame> frame4(framer.DecompressFrame(*frame2.get()));
-
- // Expect frames 3 & 4 to be the same.
- EXPECT_EQ(0,
- memcmp(frame3->data(), frame4->data(),
- SpdyFrame::kHeaderSize + frame3->length()));
-
-
- // Expect frames 3 to be the same as a uncompressed frame created
- // from scratch.
- scoped_ptr<SpdySynStreamControlFrame>
- uncompressed_frame(framer.CreateSynStream(1, 0, 1, CONTROL_FLAG_NONE,
- false, &headers));
- EXPECT_EQ(frame3->length(), uncompressed_frame->length());
- EXPECT_EQ(0,
- memcmp(frame3->data(), uncompressed_frame->data(),
- SpdyFrame::kHeaderSize + uncompressed_frame->length()));
-}
-
-TEST_F(SpdyFramerTest, DecompressUncompressedFrame) {
- SpdyHeaderBlock headers;
- headers["server"] = "SpdyServer 1.0";
- headers["date"] = "Mon 12 Jan 2009 12:12:12 PST";
- headers["status"] = "200";
- headers["version"] = "HTTP/1.1";
- headers["content-type"] = "text/html";
- headers["content-length"] = "12";
-
- SpdyFramer framer;
- framer.set_enable_compression(true);
- scoped_ptr<SpdySynStreamControlFrame>
- frame1(framer.CreateSynStream(1, 0, 1, CONTROL_FLAG_NONE, false,
- &headers));
-
- // Decompress the frame
- scoped_ptr<SpdyFrame> frame2(framer.DecompressFrame(*frame1.get()));
-
- EXPECT_EQ(NULL, frame2.get());
-}
-
-TEST_F(SpdyFramerTest, Basic) {
- const unsigned char input[] = {
- 0x80, 0x02, 0x00, 0x01, // SYN Stream #1
- 0x00, 0x00, 0x00, 0x14,
- 0x00, 0x00, 0x00, 0x01,
- 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x01,
- 0x00, 0x02, 'h', 'h',
- 0x00, 0x02, 'v', 'v',
-
- 0x80, 0x02, 0x00, 0x08, // HEADERS on Stream #1
- 0x00, 0x00, 0x00, 0x18,
- 0x00, 0x00, 0x00, 0x01,
- 0x00, 0x00, 0x00, 0x02,
- 0x00, 0x02, 'h', '2',
- 0x00, 0x02, 'v', '2',
- 0x00, 0x02, 'h', '3',
- 0x00, 0x02, 'v', '3',
-
- 0x00, 0x00, 0x00, 0x01, // DATA on Stream #1
- 0x00, 0x00, 0x00, 0x0c,
- 0xde, 0xad, 0xbe, 0xef,
- 0xde, 0xad, 0xbe, 0xef,
- 0xde, 0xad, 0xbe, 0xef,
-
- 0x80, 0x02, 0x00, 0x01, // SYN Stream #3
- 0x00, 0x00, 0x00, 0x0c,
- 0x00, 0x00, 0x00, 0x03,
- 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00,
-
- 0x00, 0x00, 0x00, 0x03, // DATA on Stream #3
- 0x00, 0x00, 0x00, 0x08,
- 0xde, 0xad, 0xbe, 0xef,
- 0xde, 0xad, 0xbe, 0xef,
-
- 0x00, 0x00, 0x00, 0x01, // DATA on Stream #1
- 0x00, 0x00, 0x00, 0x04,
- 0xde, 0xad, 0xbe, 0xef,
-
- 0x80, 0x02, 0x00, 0x03, // RST_STREAM on Stream #1
- 0x00, 0x00, 0x00, 0x08,
- 0x00, 0x00, 0x00, 0x01,
- 0x00, 0x00, 0x00, 0x00,
-
- 0x00, 0x00, 0x00, 0x03, // DATA on Stream #3
- 0x00, 0x00, 0x00, 0x00,
-
- 0x80, 0x02, 0x00, 0x03, // RST_STREAM on Stream #3
- 0x00, 0x00, 0x00, 0x08,
- 0x00, 0x00, 0x00, 0x03,
- 0x00, 0x00, 0x00, 0x00,
- };
-
- TestSpdyVisitor visitor;
- visitor.SimulateInFramer(input, sizeof(input));
-
- EXPECT_EQ(0, visitor.error_count_);
- EXPECT_EQ(2, visitor.syn_frame_count_);
- EXPECT_EQ(0, visitor.syn_reply_frame_count_);
- EXPECT_EQ(1, visitor.headers_frame_count_);
- EXPECT_EQ(24, visitor.data_bytes_);
- EXPECT_EQ(2, visitor.fin_frame_count_);
- EXPECT_EQ(0, visitor.fin_flag_count_);
- EXPECT_EQ(0, visitor.zero_length_data_frame_count_);
- EXPECT_EQ(4, visitor.data_frame_count_);
-}
-
-// Test that the FIN flag on a data frame signifies EOF.
-TEST_F(SpdyFramerTest, FinOnDataFrame) {
- const unsigned char input[] = {
- 0x80, 0x02, 0x00, 0x01, // SYN Stream #1
- 0x00, 0x00, 0x00, 0x14,
- 0x00, 0x00, 0x00, 0x01,
- 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x01,
- 0x00, 0x02, 'h', 'h',
- 0x00, 0x02, 'v', 'v',
-
- 0x80, 0x02, 0x00, 0x02, // SYN REPLY Stream #1
- 0x00, 0x00, 0x00, 0x10,
- 0x00, 0x00, 0x00, 0x01,
- 0x00, 0x00, 0x00, 0x01,
- 0x00, 0x02, 'a', 'a',
- 0x00, 0x02, 'b', 'b',
-
- 0x00, 0x00, 0x00, 0x01, // DATA on Stream #1
- 0x00, 0x00, 0x00, 0x0c,
- 0xde, 0xad, 0xbe, 0xef,
- 0xde, 0xad, 0xbe, 0xef,
- 0xde, 0xad, 0xbe, 0xef,
-
- 0x00, 0x00, 0x00, 0x01, // DATA on Stream #1, with EOF
- 0x01, 0x00, 0x00, 0x04,
- 0xde, 0xad, 0xbe, 0xef,
- };
-
- TestSpdyVisitor visitor;
- visitor.SimulateInFramer(input, sizeof(input));
-
- EXPECT_EQ(0, visitor.error_count_);
- EXPECT_EQ(1, visitor.syn_frame_count_);
- EXPECT_EQ(1, visitor.syn_reply_frame_count_);
- EXPECT_EQ(0, visitor.headers_frame_count_);
- EXPECT_EQ(16, visitor.data_bytes_);
- EXPECT_EQ(0, visitor.fin_frame_count_);
- EXPECT_EQ(0, visitor.fin_flag_count_);
- EXPECT_EQ(1, visitor.zero_length_data_frame_count_);
- EXPECT_EQ(2, visitor.data_frame_count_);
-}
-
-// Test that the FIN flag on a SYN reply frame signifies EOF.
-TEST_F(SpdyFramerTest, FinOnSynReplyFrame) {
- const unsigned char input[] = {
- 0x80, 0x02, 0x00, 0x01, // SYN Stream #1
- 0x00, 0x00, 0x00, 0x14,
- 0x00, 0x00, 0x00, 0x01,
- 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x01,
- 0x00, 0x02, 'h', 'h',
- 0x00, 0x02, 'v', 'v',
-
- 0x80, 0x02, 0x00, 0x02, // SYN REPLY Stream #1
- 0x01, 0x00, 0x00, 0x14,
- 0x00, 0x00, 0x00, 0x01,
- 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x01,
- 0x00, 0x02, 'a', 'a',
- 0x00, 0x02, 'b', 'b',
- };
-
- TestSpdyVisitor visitor;
- visitor.SimulateInFramer(input, sizeof(input));
-
- EXPECT_EQ(0, visitor.error_count_);
- EXPECT_EQ(1, visitor.syn_frame_count_);
- EXPECT_EQ(1, visitor.syn_reply_frame_count_);
- EXPECT_EQ(0, visitor.headers_frame_count_);
- EXPECT_EQ(0, visitor.data_bytes_);
- EXPECT_EQ(0, visitor.fin_frame_count_);
- EXPECT_EQ(1, visitor.fin_flag_count_);
- EXPECT_EQ(1, visitor.zero_length_data_frame_count_);
- EXPECT_EQ(0, visitor.data_frame_count_);
-}
-
-TEST_F(SpdyFramerTest, HeaderCompression) {
- SpdyFramer send_framer;
- SpdyFramer recv_framer;
-
- send_framer.set_enable_compression(true);
- recv_framer.set_enable_compression(true);
-
- const char kHeader1[] = "header1";
- const char kHeader2[] = "header2";
- const char kHeader3[] = "header3";
- const char kValue1[] = "value1";
- const char kValue2[] = "value2";
- const char kValue3[] = "value3";
-
- // SYN_STREAM #1
- SpdyHeaderBlock block;
- block[kHeader1] = kValue1;
- block[kHeader2] = kValue2;
- SpdyControlFlags flags(CONTROL_FLAG_NONE);
- scoped_ptr<spdy::SpdyFrame> syn_frame_1(
- send_framer.CreateSynStream(1, 0, 0, flags, true, &block));
- EXPECT_TRUE(syn_frame_1.get() != NULL);
-
- // SYN_STREAM #2
- block[kHeader3] = kValue3;
- scoped_ptr<spdy::SpdyFrame> syn_frame_2(
- send_framer.CreateSynStream(3, 0, 0, flags, true, &block));
- EXPECT_TRUE(syn_frame_2.get() != NULL);
-
- // Now start decompressing
- scoped_ptr<SpdyFrame> decompressed;
- scoped_ptr<SpdyFrame> decompressed_syn_frame;
- SpdySynStreamControlFrame* syn_frame;
- scoped_ptr<std::string> serialized_headers;
- SpdyHeaderBlock decompressed_headers;
-
- // Decompress SYN_STREAM #1
- decompressed.reset(recv_framer.DecompressFrame(*syn_frame_1.get()));
- EXPECT_TRUE(decompressed.get() != NULL);
- EXPECT_TRUE(decompressed->is_control_frame());
- EXPECT_EQ(SYN_STREAM,
- reinterpret_cast<SpdyControlFrame*>(decompressed.get())->type());
- decompressed_syn_frame.reset(
- new SpdySynStreamControlFrame(decompressed->data(), false));
- syn_frame = reinterpret_cast<SpdySynStreamControlFrame*>(
- decompressed_syn_frame.get());
- serialized_headers.reset(new std::string(syn_frame->header_block(),
- syn_frame->header_block_len()));
- EXPECT_TRUE(recv_framer.ParseHeaderBlockInBuffer(serialized_headers->c_str(),
- serialized_headers->size(),
- &decompressed_headers));
- EXPECT_EQ(2u, decompressed_headers.size());
- EXPECT_EQ(kValue1, decompressed_headers[kHeader1]);
- EXPECT_EQ(kValue2, decompressed_headers[kHeader2]);
-
- // Decompress SYN_STREAM #2
- decompressed.reset(recv_framer.DecompressFrame(*syn_frame_2.get()));
- EXPECT_TRUE(decompressed.get() != NULL);
- EXPECT_TRUE(decompressed->is_control_frame());
- EXPECT_EQ(SYN_STREAM,
- reinterpret_cast<SpdyControlFrame*>(decompressed.get())->type());
- decompressed_syn_frame.reset(
- new SpdySynStreamControlFrame(decompressed->data(), false));
- syn_frame = reinterpret_cast<SpdySynStreamControlFrame*>(
- decompressed_syn_frame.get());
- serialized_headers.reset(new std::string(syn_frame->header_block(),
- syn_frame->header_block_len()));
- decompressed_headers.clear();
- EXPECT_TRUE(recv_framer.ParseHeaderBlockInBuffer(serialized_headers->c_str(),
- serialized_headers->size(),
- &decompressed_headers));
- EXPECT_EQ(3u, decompressed_headers.size());
- EXPECT_EQ(kValue1, decompressed_headers[kHeader1]);
- EXPECT_EQ(kValue2, decompressed_headers[kHeader2]);
- EXPECT_EQ(kValue3, decompressed_headers[kHeader3]);
-
- // We didn't have data streams, so we shouldn't have (de)compressors.
- EXPECT_EQ(0, send_framer.num_stream_compressors());
- EXPECT_EQ(0, send_framer.num_stream_decompressors());
- EXPECT_EQ(0, recv_framer.num_stream_compressors());
- EXPECT_EQ(0, recv_framer.num_stream_decompressors());
-}
-
-// Verify we don't leak when we leave streams unclosed
-TEST_F(SpdyFramerTest, UnclosedStreamDataCompressors) {
- SpdyFramer send_framer;
-
- send_framer.set_enable_compression(true);
-
- const char kHeader1[] = "header1";
- const char kHeader2[] = "header2";
- const char kValue1[] = "value1";
- const char kValue2[] = "value2";
-
- SpdyHeaderBlock block;
- block[kHeader1] = kValue1;
- block[kHeader2] = kValue2;
- SpdyControlFlags flags(CONTROL_FLAG_NONE);
- scoped_ptr<spdy::SpdyFrame> syn_frame(
- send_framer.CreateSynStream(1, 0, 0, flags, true, &block));
- EXPECT_TRUE(syn_frame.get() != NULL);
-
- const char bytes[] = "this is a test test test test test!";
- scoped_ptr<SpdyFrame> send_frame(
- send_framer.CreateDataFrame(
- 1, bytes, arraysize(bytes),
- DATA_FLAG_FIN));
- EXPECT_TRUE(send_frame.get() != NULL);
-
- // Run the inputs through the framer.
- TestSpdyVisitor visitor;
- visitor.use_compression_ = true;
- const unsigned char* data;
- data = reinterpret_cast<const unsigned char*>(syn_frame->data());
- visitor.SimulateInFramer(data, syn_frame->length() + SpdyFrame::kHeaderSize);
- data = reinterpret_cast<const unsigned char*>(send_frame->data());
- visitor.SimulateInFramer(data, send_frame->length() + SpdyFrame::kHeaderSize);
-
- EXPECT_EQ(0, visitor.error_count_);
- EXPECT_EQ(1, visitor.syn_frame_count_);
- EXPECT_EQ(0, visitor.syn_reply_frame_count_);
- EXPECT_EQ(0, visitor.headers_frame_count_);
- EXPECT_EQ(arraysize(bytes), static_cast<unsigned>(visitor.data_bytes_));
- EXPECT_EQ(0, visitor.fin_frame_count_);
- EXPECT_EQ(0, visitor.fin_flag_count_);
- EXPECT_EQ(1, visitor.zero_length_data_frame_count_);
- EXPECT_EQ(1, visitor.data_frame_count_);
-
- // We closed the streams, so all compressors should be down.
- EXPECT_EQ(0, visitor.framer_.num_stream_compressors());
- EXPECT_EQ(0, visitor.framer_.num_stream_decompressors());
- EXPECT_EQ(0, send_framer.num_stream_compressors());
- EXPECT_EQ(0, send_framer.num_stream_decompressors());
-}
-
-TEST_F(SpdyFramerTest, WindowUpdateFrame) {
- scoped_ptr<SpdyWindowUpdateControlFrame> window_update_frame(
- SpdyFramer::CreateWindowUpdate(1, 0x12345678));
-
- const unsigned char expected_data_frame[] = {
- 0x80, 0x02, 0x00, 0x09,
- 0x00, 0x00, 0x00, 0x08,
- 0x00, 0x00, 0x00, 0x01,
- 0x12, 0x34, 0x56, 0x78
- };
-
- EXPECT_EQ(16u, window_update_frame->size());
- EXPECT_EQ(0,
- memcmp(window_update_frame->data(), expected_data_frame, 16));
-}
-
-TEST_F(SpdyFramerTest, CreateDataFrame) {
- SpdyFramer framer;
-
- {
- const char kDescription[] = "'hello' data frame, no FIN";
- const unsigned char kFrameData[] = {
- 0x00, 0x00, 0x00, 0x01,
- 0x00, 0x00, 0x00, 0x05,
- 'h', 'e', 'l', 'l',
- 'o'
- };
- scoped_ptr<SpdyFrame> frame(framer.CreateDataFrame(
- 1, "hello", 5, DATA_FLAG_NONE));
- CompareFrame(kDescription, *frame, kFrameData, arraysize(kFrameData));
- }
-
- {
- const char kDescription[] = "Data frame with negative data byte, no FIN";
- const unsigned char kFrameData[] = {
- 0x00, 0x00, 0x00, 0x01,
- 0x00, 0x00, 0x00, 0x01,
- 0xff
- };
- scoped_ptr<SpdyFrame> frame(framer.CreateDataFrame(
- 1, "\xff", 1, DATA_FLAG_NONE));
- CompareFrame(kDescription, *frame, kFrameData, arraysize(kFrameData));
- }
-
- {
- const char kDescription[] = "'hello' data frame, with FIN";
- const unsigned char kFrameData[] = {
- 0x00, 0x00, 0x00, 0x01,
- 0x01, 0x00, 0x00, 0x05,
- 'h', 'e', 'l', 'l',
- 'o'
- };
- scoped_ptr<SpdyFrame> frame(framer.CreateDataFrame(
- 1, "hello", 5, DATA_FLAG_FIN));
- CompareFrame(kDescription, *frame, kFrameData, arraysize(kFrameData));
- }
-
- {
- const char kDescription[] = "Empty data frame";
- const unsigned char kFrameData[] = {
- 0x00, 0x00, 0x00, 0x01,
- 0x00, 0x00, 0x00, 0x00,
- };
- scoped_ptr<SpdyFrame> frame(framer.CreateDataFrame(
- 1, "", 0, DATA_FLAG_NONE));
- CompareFrame(kDescription, *frame, kFrameData, arraysize(kFrameData));
- }
-
- {
- const char kDescription[] = "Data frame with max stream ID";
- const unsigned char kFrameData[] = {
- 0x7f, 0xff, 0xff, 0xff,
- 0x01, 0x00, 0x00, 0x05,
- 'h', 'e', 'l', 'l',
- 'o'
- };
- scoped_ptr<SpdyFrame> frame(framer.CreateDataFrame(
- 0x7fffffff, "hello", 5, DATA_FLAG_FIN));
- CompareFrame(kDescription, *frame, kFrameData, arraysize(kFrameData));
- }
-
- {
- const char kDescription[] = "Large data frame";
- const int kDataSize = 4 * 1024 * 1024; // 4 MB
- const std::string kData(kDataSize, 'A');
- const unsigned char kFrameHeader[] = {
- 0x00, 0x00, 0x00, 0x01,
- 0x01, 0x40, 0x00, 0x00,
- };
-
- const int kFrameSize = arraysize(kFrameHeader) + kDataSize;
- scoped_array<unsigned char> expected_frame_data(
- new unsigned char[kFrameSize]);
- memcpy(expected_frame_data.get(), kFrameHeader, arraysize(kFrameHeader));
- memset(expected_frame_data.get() + arraysize(kFrameHeader), 'A', kDataSize);
-
- scoped_ptr<SpdyFrame> frame(framer.CreateDataFrame(
- 1, kData.data(), kData.size(), DATA_FLAG_FIN));
- CompareFrame(kDescription, *frame, expected_frame_data.get(), kFrameSize);
- }
-}
-
-TEST_F(SpdyFramerTest, CreateSynStreamUncompressed) {
- SpdyFramer framer;
- framer.set_enable_compression(false);
-
- {
- const char kDescription[] = "SYN_STREAM frame, lowest pri, no FIN";
-
- SpdyHeaderBlock headers;
- headers["bar"] = "foo";
- headers["foo"] = "bar";
-
- const unsigned char kFrameData[] = {
- 0x80, 0x02, 0x00, 0x01,
- 0x00, 0x00, 0x00, 0x20,
- 0x00, 0x00, 0x00, 0x01,
- 0x00, 0x00, 0x00, 0x00,
- 0xC0, 0x00, 0x00, 0x02,
- 0x00, 0x03, 'b', 'a',
- 'r', 0x00, 0x03, 'f',
- 'o', 'o', 0x00, 0x03,
- 'f', 'o', 'o', 0x00,
- 0x03, 'b', 'a', 'r'
- };
- scoped_ptr<SpdyFrame> frame(framer.CreateSynStream(
- 1, 0, SPDY_PRIORITY_LOWEST, CONTROL_FLAG_NONE,
- false, &headers));
- CompareFrame(kDescription, *frame, kFrameData, arraysize(kFrameData));
- EXPECT_EQ(1u, SpdyFramer::GetControlFrameStreamId(
- reinterpret_cast<const SpdyControlFrame*>(frame.get())));
- }
-
- {
- const char kDescription[] =
- "SYN_STREAM frame with a 0-length header name, highest pri, FIN, "
- "max stream ID";
-
- SpdyHeaderBlock headers;
- headers[""] = "foo";
- headers["foo"] = "bar";
-
- const unsigned char kFrameData[] = {
- 0x80, 0x02, 0x00, 0x01,
- 0x01, 0x00, 0x00, 0x1D,
- 0x7f, 0xff, 0xff, 0xff,
- 0x7f, 0xff, 0xff, 0xff,
- 0x00, 0x00, 0x00, 0x02,
- 0x00, 0x00, 0x00, 0x03,
- 'f', 'o', 'o', 0x00,
- 0x03, 'f', 'o', 'o',
- 0x00, 0x03, 'b', 'a',
- 'r'
- };
- scoped_ptr<SpdyFrame> frame(framer.CreateSynStream(
- 0x7fffffff, 0x7fffffff, SPDY_PRIORITY_HIGHEST, CONTROL_FLAG_FIN,
- false, &headers));
- CompareFrame(kDescription, *frame, kFrameData, arraysize(kFrameData));
- }
-
- {
- const char kDescription[] =
- "SYN_STREAM frame with a 0-length header val, highest pri, FIN, "
- "max stream ID";
-
- SpdyHeaderBlock headers;
- headers["bar"] = "foo";
- headers["foo"] = "";
-
- const unsigned char kFrameData[] = {
- 0x80, 0x02, 0x00, 0x01,
- 0x01, 0x00, 0x00, 0x1D,
- 0x7f, 0xff, 0xff, 0xff,
- 0x7f, 0xff, 0xff, 0xff,
- 0x00, 0x00, 0x00, 0x02,
- 0x00, 0x03, 'b', 'a',
- 'r', 0x00, 0x03, 'f',
- 'o', 'o', 0x00, 0x03,
- 'f', 'o', 'o', 0x00,
- 0x00
- };
- scoped_ptr<SpdyFrame> frame(framer.CreateSynStream(
- 0x7fffffff, 0x7fffffff, SPDY_PRIORITY_HIGHEST, CONTROL_FLAG_FIN,
- false, &headers));
- CompareFrame(kDescription, *frame, kFrameData, arraysize(kFrameData));
- }
-}
-
-TEST_F(SpdyFramerTest, CreateSynStreamCompressed) {
- SpdyFramer framer;
- framer.set_enable_compression(true);
-
- {
- const char kDescription[] =
- "SYN_STREAM frame, lowest pri, no FIN";
-
- SpdyHeaderBlock headers;
- headers["bar"] = "foo";
- headers["foo"] = "bar";
-
- const unsigned char kFrameData[] = {
- 0x80, 0x02, 0x00, 0x01,
- 0x00, 0x00, 0x00, 0x25,
- 0x00, 0x00, 0x00, 0x01,
- 0x00, 0x00, 0x00, 0x00,
- 0xC0, 0x00, 0x38, 0xea,
- 0xdf, 0xa2, 0x51, 0xb2,
- 0x62, 0x60, 0x62, 0x60,
- 0x4e, 0x4a, 0x2c, 0x62,
- 0x60, 0x4e, 0xcb, 0xcf,
- 0x87, 0x12, 0x40, 0x2e,
- 0x00, 0x00, 0x00, 0xff,
- 0xff
- };
- scoped_ptr<SpdyFrame> frame(framer.CreateSynStream(
- 1, 0, SPDY_PRIORITY_LOWEST, CONTROL_FLAG_NONE,
- true, &headers));
- CompareFrame(kDescription, *frame, kFrameData, arraysize(kFrameData));
- }
-}
-
-TEST_F(SpdyFramerTest, CreateSynReplyUncompressed) {
- SpdyFramer framer;
- framer.set_enable_compression(false);
-
- {
- const char kDescription[] = "SYN_REPLY frame, no FIN";
-
- SpdyHeaderBlock headers;
- headers["bar"] = "foo";
- headers["foo"] = "bar";
-
- const unsigned char kFrameData[] = {
- 0x80, 0x02, 0x00, 0x02,
- 0x00, 0x00, 0x00, 0x1C,
- 0x00, 0x00, 0x00, 0x01,
- 0x00, 0x00, 0x00, 0x02,
- 0x00, 0x03, 'b', 'a',
- 'r', 0x00, 0x03, 'f',
- 'o', 'o', 0x00, 0x03,
- 'f', 'o', 'o', 0x00,
- 0x03, 'b', 'a', 'r'
- };
- scoped_ptr<SpdyFrame> frame(framer.CreateSynReply(
- 1, CONTROL_FLAG_NONE, false, &headers));
- CompareFrame(kDescription, *frame, kFrameData, arraysize(kFrameData));
- }
-
- {
- const char kDescription[] =
- "SYN_REPLY frame with a 0-length header name, FIN, max stream ID";
-
- SpdyHeaderBlock headers;
- headers[""] = "foo";
- headers["foo"] = "bar";
-
- const unsigned char kFrameData[] = {
- 0x80, 0x02, 0x00, 0x02,
- 0x01, 0x00, 0x00, 0x19,
- 0x7f, 0xff, 0xff, 0xff,
- 0x00, 0x00, 0x00, 0x02,
- 0x00, 0x00, 0x00, 0x03,
- 'f', 'o', 'o', 0x00,
- 0x03, 'f', 'o', 'o',
- 0x00, 0x03, 'b', 'a',
- 'r'
- };
- scoped_ptr<SpdyFrame> frame(framer.CreateSynReply(
- 0x7fffffff, CONTROL_FLAG_FIN, false, &headers));
- CompareFrame(kDescription, *frame, kFrameData, arraysize(kFrameData));
- }
-
- {
- const char kDescription[] =
- "SYN_REPLY frame with a 0-length header val, FIN, max stream ID";
-
- SpdyHeaderBlock headers;
- headers["bar"] = "foo";
- headers["foo"] = "";
-
- const unsigned char kFrameData[] = {
- 0x80, 0x02, 0x00, 0x02,
- 0x01, 0x00, 0x00, 0x19,
- 0x7f, 0xff, 0xff, 0xff,
- 0x00, 0x00, 0x00, 0x02,
- 0x00, 0x03, 'b', 'a',
- 'r', 0x00, 0x03, 'f',
- 'o', 'o', 0x00, 0x03,
- 'f', 'o', 'o', 0x00,
- 0x00
- };
- scoped_ptr<SpdyFrame> frame(framer.CreateSynReply(
- 0x7fffffff, CONTROL_FLAG_FIN, false, &headers));
- CompareFrame(kDescription, *frame, kFrameData, arraysize(kFrameData));
- }
-}
-
-TEST_F(SpdyFramerTest, CreateSynReplyCompressed) {
- SpdyFramer framer;
- framer.set_enable_compression(true);
-
- {
- const char kDescription[] = "SYN_REPLY frame, no FIN";
-
- SpdyHeaderBlock headers;
- headers["bar"] = "foo";
- headers["foo"] = "bar";
-
- const unsigned char kFrameData[] = {
- 0x80, 0x02, 0x00, 0x02,
- 0x00, 0x00, 0x00, 0x21,
- 0x00, 0x00, 0x00, 0x01,
- 0x00, 0x00, 0x38, 0xea,
- 0xdf, 0xa2, 0x51, 0xb2,
- 0x62, 0x60, 0x62, 0x60,
- 0x4e, 0x4a, 0x2c, 0x62,
- 0x60, 0x4e, 0xcb, 0xcf,
- 0x87, 0x12, 0x40, 0x2e,
- 0x00, 0x00, 0x00, 0xff,
- 0xff
- };
- scoped_ptr<SpdyFrame> frame(framer.CreateSynReply(
- 1, CONTROL_FLAG_NONE, true, &headers));
- CompareFrame(kDescription, *frame, kFrameData, arraysize(kFrameData));
- }
-}
-
-TEST_F(SpdyFramerTest, CreateRstStream) {
- SpdyFramer framer;
-
- {
- const char kDescription[] = "RST_STREAM frame";
- const unsigned char kFrameData[] = {
- 0x80, 0x02, 0x00, 0x03,
- 0x00, 0x00, 0x00, 0x08,
- 0x00, 0x00, 0x00, 0x01,
- 0x00, 0x00, 0x00, 0x01,
- };
- scoped_ptr<SpdyFrame> frame(framer.CreateRstStream(1, PROTOCOL_ERROR));
- CompareFrame(kDescription, *frame, kFrameData, arraysize(kFrameData));
- EXPECT_EQ(1u, SpdyFramer::GetControlFrameStreamId(
- reinterpret_cast<const SpdyControlFrame*>(frame.get())));
- }
-
- {
- const char kDescription[] = "RST_STREAM frame with max stream ID";
- const unsigned char kFrameData[] = {
- 0x80, 0x02, 0x00, 0x03,
- 0x00, 0x00, 0x00, 0x08,
- 0x7f, 0xff, 0xff, 0xff,
- 0x00, 0x00, 0x00, 0x01,
- };
- scoped_ptr<SpdyFrame> frame(framer.CreateRstStream(0x7FFFFFFF,
- PROTOCOL_ERROR));
- CompareFrame(kDescription, *frame, kFrameData, arraysize(kFrameData));
- }
-
- {
- const char kDescription[] = "RST_STREAM frame with max status code";
- const unsigned char kFrameData[] = {
- 0x80, 0x02, 0x00, 0x03,
- 0x00, 0x00, 0x00, 0x08,
- 0x7f, 0xff, 0xff, 0xff,
- 0x00, 0x00, 0x00, 0x06,
- };
- scoped_ptr<SpdyFrame> frame(framer.CreateRstStream(0x7FFFFFFF,
- INTERNAL_ERROR));
- CompareFrame(kDescription, *frame, kFrameData, arraysize(kFrameData));
- }
-}
-
-TEST_F(SpdyFramerTest, CreateSettings) {
- SpdyFramer framer;
-
- {
- const char kDescription[] = "Basic SETTINGS frame";
-
- SpdySettings settings;
- settings.push_back(SpdySetting(0x00000000, 0x00000000));
- settings.push_back(SpdySetting(0xffffffff, 0x00000001));
- settings.push_back(SpdySetting(0xff000001, 0x00000002));
-
- // Duplicates allowed
- settings.push_back(SpdySetting(0x01000002, 0x00000003));
- settings.push_back(SpdySetting(0x01000002, 0x00000003));
-
- settings.push_back(SpdySetting(0x01000003, 0x000000ff));
- settings.push_back(SpdySetting(0x01000004, 0xff000001));
- settings.push_back(SpdySetting(0x01000004, 0xffffffff));
-
- const unsigned char kFrameData[] = {
- 0x80, 0x02, 0x00, 0x04,
- 0x00, 0x00, 0x00, 0x44,
- 0x00, 0x00, 0x00, 0x08,
- 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00,
- 0xff, 0xff, 0xff, 0xff,
- 0x00, 0x00, 0x00, 0x01,
- 0xff, 0x00, 0x00, 0x01,
- 0x00, 0x00, 0x00, 0x02,
- 0x01, 0x00, 0x00, 0x02,
- 0x00, 0x00, 0x00, 0x03,
- 0x01, 0x00, 0x00, 0x02,
- 0x00, 0x00, 0x00, 0x03,
- 0x01, 0x00, 0x00, 0x03,
- 0x00, 0x00, 0x00, 0xff,
- 0x01, 0x00, 0x00, 0x04,
- 0xff, 0x00, 0x00, 0x01,
- 0x01, 0x00, 0x00, 0x04,
- 0xff, 0xff, 0xff, 0xff,
- };
- scoped_ptr<SpdyFrame> frame(framer.CreateSettings(settings));
- CompareFrame(kDescription, *frame, kFrameData, arraysize(kFrameData));
- EXPECT_EQ(SpdyFramer::kInvalidStream,
- SpdyFramer::GetControlFrameStreamId(
- reinterpret_cast<const SpdyControlFrame*>(frame.get())));
- }
-
- {
- const char kDescription[] = "Empty SETTINGS frame";
-
- SpdySettings settings;
-
- const unsigned char kFrameData[] = {
- 0x80, 0x02, 0x00, 0x04,
- 0x00, 0x00, 0x00, 0x04,
- 0x00, 0x00, 0x00, 0x00,
- };
- scoped_ptr<SpdyFrame> frame(framer.CreateSettings(settings));
- CompareFrame(kDescription, *frame, kFrameData, arraysize(kFrameData));
- }
-}
-
-TEST_F(SpdyFramerTest, CreateNopFrame) {
- SpdyFramer framer;
-
- {
- const char kDescription[] = "NOOP frame";
- const unsigned char kFrameData[] = {
- 0x80, 0x02, 0x00, 0x05,
- 0x00, 0x00, 0x00, 0x00,
- };
- scoped_ptr<SpdyFrame> frame(framer.CreateNopFrame());
- CompareFrame(kDescription, *frame, kFrameData, arraysize(kFrameData));
- EXPECT_EQ(SpdyFramer::kInvalidStream,
- SpdyFramer::GetControlFrameStreamId(
- reinterpret_cast<const SpdyControlFrame*>(frame.get())));
- }
-}
-
-TEST_F(SpdyFramerTest, CreatePingFrame) {
- SpdyFramer framer;
-
- {
- const char kDescription[] = "PING frame";
- const unsigned char kFrameData[] = {
- 0x80, 0x02, 0x00, 0x06,
- 0x00, 0x00, 0x00, 0x04,
- 0x12, 0x34, 0x56, 0x78,
- };
- scoped_ptr<SpdyFrame> frame(framer.CreatePingFrame(0x12345678u));
- CompareFrame(kDescription, *frame, kFrameData, arraysize(kFrameData));
- EXPECT_EQ(SpdyFramer::kInvalidStream,
- SpdyFramer::GetControlFrameStreamId(
- reinterpret_cast<const SpdyControlFrame*>(frame.get())));
- }
-}
-
-TEST_F(SpdyFramerTest, CreateGoAway) {
- SpdyFramer framer;
-
- {
- const char kDescription[] = "GOAWAY frame";
- const unsigned char kFrameData[] = {
- 0x80, 0x02, 0x00, 0x07,
- 0x00, 0x00, 0x00, 0x04,
- 0x00, 0x00, 0x00, 0x00,
- };
- scoped_ptr<SpdyFrame> frame(framer.CreateGoAway(0));
- CompareFrame(kDescription, *frame, kFrameData, arraysize(kFrameData));
- EXPECT_EQ(SpdyFramer::kInvalidStream,
- SpdyFramer::GetControlFrameStreamId(
- reinterpret_cast<const SpdyControlFrame*>(frame.get())));
- }
-
- {
- const char kDescription[] = "GOAWAY frame with max stream ID";
- const unsigned char kFrameData[] = {
- 0x80, 0x02, 0x00, 0x07,
- 0x00, 0x00, 0x00, 0x04,
- 0x7f, 0xff, 0xff, 0xff,
- };
- scoped_ptr<SpdyFrame> frame(framer.CreateGoAway(0x7FFFFFFF));
- CompareFrame(kDescription, *frame, kFrameData, arraysize(kFrameData));
- }
-}
-
-TEST_F(SpdyFramerTest, CreateHeadersUncompressed) {
- SpdyFramer framer;
- framer.set_enable_compression(false);
-
- {
- const char kDescription[] = "HEADERS frame, no FIN";
-
- SpdyHeaderBlock headers;
- headers["bar"] = "foo";
- headers["foo"] = "bar";
-
- const unsigned char kFrameData[] = {
- 0x80, 0x02, 0x00, 0x08,
- 0x00, 0x00, 0x00, 0x1C,
- 0x00, 0x00, 0x00, 0x01,
- 0x00, 0x00, 0x00, 0x02,
- 0x00, 0x03, 'b', 'a',
- 'r', 0x00, 0x03, 'f',
- 'o', 'o', 0x00, 0x03,
- 'f', 'o', 'o', 0x00,
- 0x03, 'b', 'a', 'r'
- };
- scoped_ptr<SpdyFrame> frame(framer.CreateHeaders(
- 1, CONTROL_FLAG_NONE, false, &headers));
- CompareFrame(kDescription, *frame, kFrameData, arraysize(kFrameData));
- }
-
- {
- const char kDescription[] =
- "HEADERS frame with a 0-length header name, FIN, max stream ID";
-
- SpdyHeaderBlock headers;
- headers[""] = "foo";
- headers["foo"] = "bar";
-
- const unsigned char kFrameData[] = {
- 0x80, 0x02, 0x00, 0x08,
- 0x01, 0x00, 0x00, 0x19,
- 0x7f, 0xff, 0xff, 0xff,
- 0x00, 0x00, 0x00, 0x02,
- 0x00, 0x00, 0x00, 0x03,
- 'f', 'o', 'o', 0x00,
- 0x03, 'f', 'o', 'o',
- 0x00, 0x03, 'b', 'a',
- 'r'
- };
- scoped_ptr<SpdyFrame> frame(framer.CreateHeaders(
- 0x7fffffff, CONTROL_FLAG_FIN, false, &headers));
- CompareFrame(kDescription, *frame, kFrameData, arraysize(kFrameData));
- }
-
- {
- const char kDescription[] =
- "HEADERS frame with a 0-length header val, FIN, max stream ID";
-
- SpdyHeaderBlock headers;
- headers["bar"] = "foo";
- headers["foo"] = "";
-
- const unsigned char kFrameData[] = {
- 0x80, 0x02, 0x00, 0x08,
- 0x01, 0x00, 0x00, 0x19,
- 0x7f, 0xff, 0xff, 0xff,
- 0x00, 0x00, 0x00, 0x02,
- 0x00, 0x03, 'b', 'a',
- 'r', 0x00, 0x03, 'f',
- 'o', 'o', 0x00, 0x03,
- 'f', 'o', 'o', 0x00,
- 0x00
- };
- scoped_ptr<SpdyFrame> frame(framer.CreateHeaders(
- 0x7fffffff, CONTROL_FLAG_FIN, false, &headers));
- CompareFrame(kDescription, *frame, kFrameData, arraysize(kFrameData));
- }
-}
-
-TEST_F(SpdyFramerTest, CreateHeadersCompressed) {
- SpdyFramer framer;
- framer.set_enable_compression(true);
-
- {
- const char kDescription[] = "HEADERS frame, no FIN";
-
- SpdyHeaderBlock headers;
- headers["bar"] = "foo";
- headers["foo"] = "bar";
-
- const unsigned char kFrameData[] = {
- 0x80, 0x02, 0x00, 0x08,
- 0x00, 0x00, 0x00, 0x21,
- 0x00, 0x00, 0x00, 0x01,
- 0x00, 0x00, 0x38, 0xea,
- 0xdf, 0xa2, 0x51, 0xb2,
- 0x62, 0x60, 0x62, 0x60,
- 0x4e, 0x4a, 0x2c, 0x62,
- 0x60, 0x4e, 0xcb, 0xcf,
- 0x87, 0x12, 0x40, 0x2e,
- 0x00, 0x00, 0x00, 0xff,
- 0xff
- };
- scoped_ptr<SpdyFrame> frame(framer.CreateHeaders(
- 1, CONTROL_FLAG_NONE, true, &headers));
- CompareFrame(kDescription, *frame, kFrameData, arraysize(kFrameData));
- }
-}
-
-TEST_F(SpdyFramerTest, CreateWindowUpdate) {
- SpdyFramer framer;
-
- {
- const char kDescription[] = "WINDOW_UPDATE frame";
- const unsigned char kFrameData[] = {
- 0x80, 0x02, 0x00, 0x09,
- 0x00, 0x00, 0x00, 0x08,
- 0x00, 0x00, 0x00, 0x01,
- 0x00, 0x00, 0x00, 0x01,
- };
- scoped_ptr<SpdyFrame> frame(framer.CreateWindowUpdate(1, 1));
- CompareFrame(kDescription, *frame, kFrameData, arraysize(kFrameData));
- EXPECT_EQ(1u, SpdyFramer::GetControlFrameStreamId(
- reinterpret_cast<const SpdyControlFrame*>(frame.get())));
- }
-
- {
- const char kDescription[] = "WINDOW_UPDATE frame with max stream ID";
- const unsigned char kFrameData[] = {
- 0x80, 0x02, 0x00, 0x09,
- 0x00, 0x00, 0x00, 0x08,
- 0x7f, 0xff, 0xff, 0xff,
- 0x00, 0x00, 0x00, 0x01,
- };
- scoped_ptr<SpdyFrame> frame(framer.CreateWindowUpdate(0x7FFFFFFF, 1));
- CompareFrame(kDescription, *frame, kFrameData, arraysize(kFrameData));
- }
-
- {
- const char kDescription[] = "WINDOW_UPDATE frame with max window delta";
- const unsigned char kFrameData[] = {
- 0x80, 0x02, 0x00, 0x09,
- 0x00, 0x00, 0x00, 0x08,
- 0x00, 0x00, 0x00, 0x01,
- 0x7f, 0xff, 0xff, 0xff,
- };
- scoped_ptr<SpdyFrame> frame(framer.CreateWindowUpdate(1, 0x7FFFFFFF));
- CompareFrame(kDescription, *frame, kFrameData, arraysize(kFrameData));
- }
-}
-
-TEST_F(SpdyFramerTest, CreateCredential) {
- SpdyFramer framer;
-
- {
- const char kDescription[] = "CREDENTIAL frame";
- const unsigned char kFrameData[] = {
- 0x80, 0x02, 0x00, 0x0A,
- 0x00, 0x00, 0x00, 0x33,
- 0x00, 0x03, 0x00, 0x00,
- 0x00, 0x05, 'p', 'r',
- 'o', 'o', 'f', 0x00,
- 0x00, 0x00, 0x06, 'a',
- ' ', 'c', 'e', 'r',
- 't', 0x00, 0x00, 0x00,
- 0x0C, 'a', 'n', 'o',
- 't', 'h', 'e', 'r',
- ' ', 'c', 'e', 'r',
- 't', 0x00, 0x00, 0x00,
- 0x0A, 'f', 'i', 'n',
- 'a', 'l', ' ', 'c',
- 'e', 'r', 't',
- };
- SpdyCredential credential;
- credential.slot = 3;
- credential.proof = "proof";
- credential.certs.push_back("a cert");
- credential.certs.push_back("another cert");
- credential.certs.push_back("final cert");
- scoped_ptr<SpdyFrame> frame(framer.CreateCredentialFrame(credential));
- CompareFrame(kDescription, *frame, kFrameData, arraysize(kFrameData));
- }
-}
-
-TEST_F(SpdyFramerTest, ParseCredentialFrame) {
- SpdyFramer framer;
-
- {
- unsigned char kFrameData[] = {
- 0x80, 0x02, 0x00, 0x0A,
- 0x00, 0x00, 0x00, 0x33,
- 0x00, 0x03, 0x00, 0x00,
- 0x00, 0x05, 'p', 'r',
- 'o', 'o', 'f', 0x00,
- 0x00, 0x00, 0x06, 'a',
- ' ', 'c', 'e', 'r',
- 't', 0x00, 0x00, 0x00,
- 0x0C, 'a', 'n', 'o',
- 't', 'h', 'e', 'r',
- ' ', 'c', 'e', 'r',
- 't', 0x00, 0x00, 0x00,
- 0x0A, 'f', 'i', 'n',
- 'a', 'l', ' ', 'c',
- 'e', 'r', 't',
- };
- SpdyCredentialControlFrame frame(reinterpret_cast<char*>(kFrameData),
- false);
- SpdyCredential credential;
- EXPECT_TRUE(SpdyFramer::ParseCredentialData(frame.payload(),
- frame.length(),
- &credential));
- EXPECT_EQ(3u, credential.slot);
- EXPECT_EQ("proof", credential.proof);
- EXPECT_EQ("a cert", credential.certs.front());
- credential.certs.erase(credential.certs.begin());
- EXPECT_EQ("another cert", credential.certs.front());
- credential.certs.erase(credential.certs.begin());
- EXPECT_EQ("final cert", credential.certs.front());
- credential.certs.erase(credential.certs.begin());
- EXPECT_TRUE(credential.certs.empty());
- }
-}
-
-TEST_F(SpdyFramerTest, DuplicateFrame) {
- SpdyFramer framer;
-
- {
- const char kDescription[] = "PING frame";
- const unsigned char kFrameData[] = {
- 0x80, 0x02, 0x00, 0x06,
- 0x00, 0x00, 0x00, 0x04,
- 0x12, 0x34, 0x56, 0x78,
- };
- scoped_ptr<SpdyFrame> frame1(framer.CreatePingFrame(0x12345678u));
- CompareFrame(kDescription, *frame1, kFrameData, arraysize(kFrameData));
-
- scoped_ptr<SpdyFrame> frame2(framer.DuplicateFrame(*frame1));
- CompareFrame(kDescription, *frame2, kFrameData, arraysize(kFrameData));
- }
-}
-
-// This test case reproduces conditions that caused ExpandControlFrameBuffer to
-// fail to expand the buffer control frame buffer when it should have, allowing
-// the framer to overrun the buffer, and smash other heap contents. This test
-// relies on the debug version of the heap manager, which checks for buffer
-// overrun errors during delete processing. Regression test for b/2974814.
-TEST_F(SpdyFramerTest, ExpandBuffer_HeapSmash) {
- // Sweep through the area of problematic values, to make sure we always cover
- // the danger zone, even if it moves around at bit due to SPDY changes.
- for (uint16 val2_len = SpdyFramer::kControlFrameBufferInitialSize - 50;
- val2_len < SpdyFramer::kControlFrameBufferInitialSize;
- val2_len++) {
- std::string val2 = std::string(val2_len, 'a');
- SpdyHeaderBlock headers;
- headers["bar"] = "foo";
- headers["foo"] = "baz";
- headers["grue"] = val2.c_str();
- SpdyFramer framer;
- scoped_ptr<SpdySynStreamControlFrame> template_frame(
- framer.CreateSynStream(1, // stream_id
- 0, // associated_stream_id
- 1, // priority
- CONTROL_FLAG_NONE,
- false, // compress
- &headers));
- EXPECT_TRUE(template_frame.get() != NULL);
- TestSpdyVisitor visitor;
- visitor.SimulateInFramer(
- reinterpret_cast<unsigned char*>(template_frame.get()->data()),
- template_frame.get()->length() + SpdyControlFrame::kHeaderSize);
- EXPECT_EQ(1, visitor.syn_frame_count_);
- }
-}
-
-TEST_F(SpdyFramerTest, ReadCredentialFrame) {
- SpdyCredential credential;
- credential.slot = 3;
- credential.proof = "proof";
- credential.certs.push_back("a cert");
- credential.certs.push_back("another cert");
- credential.certs.push_back("final cert");
- SpdyFramer framer;
- scoped_ptr<SpdyFrame> control_frame(
- framer.CreateCredentialFrame(credential));
- EXPECT_TRUE(control_frame.get() != NULL);
- TestSpdyVisitor visitor;
- visitor.use_compression_ = false;
- visitor.SimulateInFramer(
- reinterpret_cast<unsigned char*>(control_frame.get()->data()),
- control_frame.get()->length() + SpdyControlFrame::kHeaderSize);
- EXPECT_EQ(0, visitor.error_count_);
- EXPECT_EQ(1, visitor.credential_count_);
- EXPECT_EQ(control_frame->length(), visitor.credential_buffer_length_);
- EXPECT_EQ(credential.slot, visitor.credential_.slot);
- EXPECT_EQ(credential.proof, visitor.credential_.proof);
- EXPECT_EQ(credential.certs.size(), visitor.credential_.certs.size());
- for (size_t i = 0; i < credential.certs.size(); i++) {
- EXPECT_EQ(credential.certs[i], visitor.credential_.certs[i]);
- }
-}
-
-TEST_F(SpdyFramerTest, ReadCredentialFrameWithCorruptProof) {
- SpdyCredential credential;
- credential.slot = 3;
- credential.proof = "proof";
- credential.certs.push_back("a cert");
- credential.certs.push_back("another cert");
- credential.certs.push_back("final cert");
- SpdyFramer framer;
- scoped_ptr<SpdyFrame> control_frame(
- framer.CreateCredentialFrame(credential));
- EXPECT_TRUE(control_frame.get() != NULL);
- TestSpdyVisitor visitor;
- visitor.use_compression_ = false;
- unsigned char* data =
- reinterpret_cast<unsigned char*>(control_frame.get()->data());
- size_t offset = SpdyControlFrame::kHeaderSize + 4;
- data[offset] = 0xFF; // Proof length is past the end of the frame
- visitor.SimulateInFramer(
- data, control_frame.get()->length() + SpdyControlFrame::kHeaderSize);
- EXPECT_EQ(1, visitor.error_count_);
-}
-
-TEST_F(SpdyFramerTest, ReadCredentialFrameWithCorruptCertificate) {
- SpdyCredential credential;
- credential.slot = 3;
- credential.proof = "proof";
- credential.certs.push_back("a cert");
- credential.certs.push_back("another cert");
- credential.certs.push_back("final cert");
- SpdyFramer framer;
- scoped_ptr<SpdyFrame> control_frame(
- framer.CreateCredentialFrame(credential));
- EXPECT_TRUE(control_frame.get() != NULL);
- TestSpdyVisitor visitor;
- visitor.use_compression_ = false;
- unsigned char* data =
- reinterpret_cast<unsigned char*>(control_frame.get()->data());
- size_t offset = SpdyControlFrame::kHeaderSize + credential.proof.length();
- data[offset] = 0xFF; // Certificate length is past the end of the frame
- visitor.SimulateInFramer(
- data, control_frame.get()->length() + SpdyControlFrame::kHeaderSize);
- EXPECT_EQ(1, visitor.error_count_);
-}
-
-TEST_F(SpdyFramerTest, ReadGarbage) {
- SpdyFramer framer;
- unsigned char garbage_frame[256];
- memset(garbage_frame, ~0, sizeof(garbage_frame));
- TestSpdyVisitor visitor;
- visitor.use_compression_ = false;
- visitor.SimulateInFramer(garbage_frame, sizeof(garbage_frame));
- EXPECT_EQ(1, visitor.error_count_);
-}
-
-TEST_F(SpdyFramerTest, ReadGarbageWithValidVersion) {
- SpdyFramer framer;
- char garbage_frame[256];
- memset(garbage_frame, ~0, sizeof(garbage_frame));
- SpdyControlFrame control_frame(&garbage_frame[0], false);
- control_frame.set_version(kSpdyProtocolVersion);
- TestSpdyVisitor visitor;
- visitor.use_compression_ = false;
- visitor.SimulateInFramer(
- reinterpret_cast<unsigned char*>(control_frame.data()),
- sizeof(garbage_frame));
- EXPECT_EQ(1, visitor.error_count_);
-}
-
-TEST(SpdyFramer, StateToStringTest) {
- EXPECT_STREQ("ERROR",
- SpdyFramer::StateToString(SpdyFramer::SPDY_ERROR));
- EXPECT_STREQ("DONE",
- SpdyFramer::StateToString(SpdyFramer::SPDY_DONE));
- EXPECT_STREQ("AUTO_RESET",
- SpdyFramer::StateToString(SpdyFramer::SPDY_AUTO_RESET));
- EXPECT_STREQ("RESET",
- SpdyFramer::StateToString(SpdyFramer::SPDY_RESET));
- EXPECT_STREQ("READING_COMMON_HEADER",
- SpdyFramer::StateToString(
- SpdyFramer::SPDY_READING_COMMON_HEADER));
- EXPECT_STREQ("CONTROL_FRAME_PAYLOAD",
- SpdyFramer::StateToString(
- SpdyFramer::SPDY_CONTROL_FRAME_PAYLOAD));
- EXPECT_STREQ("IGNORE_REMAINING_PAYLOAD",
- SpdyFramer::StateToString(
- SpdyFramer::SPDY_IGNORE_REMAINING_PAYLOAD));
- EXPECT_STREQ("FORWARD_STREAM_FRAME",
- SpdyFramer::StateToString(
- SpdyFramer::SPDY_FORWARD_STREAM_FRAME));
- EXPECT_STREQ("SPDY_CONTROL_FRAME_BEFORE_HEADER_BLOCK",
- SpdyFramer::StateToString(
- SpdyFramer::SPDY_CONTROL_FRAME_BEFORE_HEADER_BLOCK));
- EXPECT_STREQ("SPDY_CONTROL_FRAME_HEADER_BLOCK",
- SpdyFramer::StateToString(
- SpdyFramer::SPDY_CONTROL_FRAME_HEADER_BLOCK));
- EXPECT_STREQ("SPDY_CREDENTIAL_FRAME_PAYLOAD",
- SpdyFramer::StateToString(
- SpdyFramer::SPDY_CREDENTIAL_FRAME_PAYLOAD));
- EXPECT_STREQ("UNKNOWN_STATE",
- SpdyFramer::StateToString(
- SpdyFramer::SPDY_CREDENTIAL_FRAME_PAYLOAD + 1));
-}
-
-TEST(SpdyFramer, ErrorCodeToStringTest) {
- EXPECT_STREQ("NO_ERROR",
- SpdyFramer::ErrorCodeToString(SpdyFramer::SPDY_NO_ERROR));
- EXPECT_STREQ("INVALID_CONTROL_FRAME",
- SpdyFramer::ErrorCodeToString(
- SpdyFramer::SPDY_INVALID_CONTROL_FRAME));
- EXPECT_STREQ("CONTROL_PAYLOAD_TOO_LARGE",
- SpdyFramer::ErrorCodeToString(
- SpdyFramer::SPDY_CONTROL_PAYLOAD_TOO_LARGE));
- EXPECT_STREQ("ZLIB_INIT_FAILURE",
- SpdyFramer::ErrorCodeToString(
- SpdyFramer::SPDY_ZLIB_INIT_FAILURE));
- EXPECT_STREQ("UNSUPPORTED_VERSION",
- SpdyFramer::ErrorCodeToString(
- SpdyFramer::SPDY_UNSUPPORTED_VERSION));
- EXPECT_STREQ("DECOMPRESS_FAILURE",
- SpdyFramer::ErrorCodeToString(
- SpdyFramer::SPDY_DECOMPRESS_FAILURE));
- EXPECT_STREQ("COMPRESS_FAILURE",
- SpdyFramer::ErrorCodeToString(
- SpdyFramer::SPDY_COMPRESS_FAILURE));
- EXPECT_STREQ("UNKNOWN_ERROR",
- SpdyFramer::ErrorCodeToString(SpdyFramer::LAST_ERROR));
-}
-
-TEST(SpdyFramer, StatusCodeToStringTest) {
- EXPECT_STREQ("INVALID",
- SpdyFramer::StatusCodeToString(INVALID));
- EXPECT_STREQ("PROTOCOL_ERROR",
- SpdyFramer::StatusCodeToString(PROTOCOL_ERROR));
- EXPECT_STREQ("INVALID_STREAM",
- SpdyFramer::StatusCodeToString(INVALID_STREAM));
- EXPECT_STREQ("REFUSED_STREAM",
- SpdyFramer::StatusCodeToString(REFUSED_STREAM));
- EXPECT_STREQ("UNSUPPORTED_VERSION",
- SpdyFramer::StatusCodeToString(UNSUPPORTED_VERSION));
- EXPECT_STREQ("CANCEL",
- SpdyFramer::StatusCodeToString(CANCEL));
- EXPECT_STREQ("INTERNAL_ERROR",
- SpdyFramer::StatusCodeToString(INTERNAL_ERROR));
- EXPECT_STREQ("FLOW_CONTROL_ERROR",
- SpdyFramer::StatusCodeToString(FLOW_CONTROL_ERROR));
- EXPECT_STREQ("UNKNOWN_STATUS",
- SpdyFramer::StatusCodeToString(NUM_STATUS_CODES));
-}
-
-TEST(SpdyFramer, ControlTypeToStringTest) {
- EXPECT_STREQ("SYN_STREAM",
- SpdyFramer::ControlTypeToString(SYN_STREAM));
- EXPECT_STREQ("SYN_REPLY",
- SpdyFramer::ControlTypeToString(SYN_REPLY));
- EXPECT_STREQ("RST_STREAM",
- SpdyFramer::ControlTypeToString(RST_STREAM));
- EXPECT_STREQ("SETTINGS",
- SpdyFramer::ControlTypeToString(SETTINGS));
- EXPECT_STREQ("NOOP",
- SpdyFramer::ControlTypeToString(NOOP));
- EXPECT_STREQ("PING",
- SpdyFramer::ControlTypeToString(PING));
- EXPECT_STREQ("GOAWAY",
- SpdyFramer::ControlTypeToString(GOAWAY));
- EXPECT_STREQ("HEADERS",
- SpdyFramer::ControlTypeToString(HEADERS));
- EXPECT_STREQ("WINDOW_UPDATE",
- SpdyFramer::ControlTypeToString(WINDOW_UPDATE));
- EXPECT_STREQ("SETTINGS",
- SpdyFramer::ControlTypeToString(SETTINGS));
- EXPECT_STREQ("UNKNOWN_CONTROL_TYPE",
- SpdyFramer::ControlTypeToString(NUM_CONTROL_FRAME_TYPES));
-}
-
-TEST(SpdyFramer, GetMinimumControlFrameSizeTest) {
- EXPECT_EQ(SpdySynStreamControlFrame::size(),
- SpdyFramer::GetMinimumControlFrameSize(SYN_STREAM));
- EXPECT_EQ(SpdySynReplyControlFrame::size(),
- SpdyFramer::GetMinimumControlFrameSize(SYN_REPLY));
- EXPECT_EQ(SpdyRstStreamControlFrame::size(),
- SpdyFramer::GetMinimumControlFrameSize(RST_STREAM));
- EXPECT_EQ(SpdySettingsControlFrame::size(),
- SpdyFramer::GetMinimumControlFrameSize(SETTINGS));
- EXPECT_EQ(SpdyNoOpControlFrame::size(),
- SpdyFramer::GetMinimumControlFrameSize(NOOP));
- EXPECT_EQ(SpdyPingControlFrame::size(),
- SpdyFramer::GetMinimumControlFrameSize(PING));
- EXPECT_EQ(SpdyGoAwayControlFrame::size(),
- SpdyFramer::GetMinimumControlFrameSize(GOAWAY));
- EXPECT_EQ(SpdyHeadersControlFrame::size(),
- SpdyFramer::GetMinimumControlFrameSize(HEADERS));
- EXPECT_EQ(SpdyWindowUpdateControlFrame::size(),
- SpdyFramer::GetMinimumControlFrameSize(WINDOW_UPDATE));
- EXPECT_EQ(SpdyCredentialControlFrame::size(),
- SpdyFramer::GetMinimumControlFrameSize(CREDENTIAL));
- EXPECT_EQ(static_cast<size_t>(0x7FFFFFFF),
- SpdyFramer::GetMinimumControlFrameSize(NUM_CONTROL_FRAME_TYPES));
-}
-
-std::string RandomString(int length) {
- std::string rv;
- for (int index = 0; index < length; index++)
- rv += static_cast<char>('a' + (rand() % 26));
- return rv;
-}
-
-} // namespace
« no previous file with comments | « net/spdy/spdy_framer_spdy3_test.cc ('k') | net/spdy/spdy_http_stream_spdy2_unittest.cc » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698