#include "net/quic/test_tools/quic_test_utils.h"
+#include "base/sha1.h"
#include "base/stl_util.h"
#include "base/strings/string_number_conversions.h"
#include "net/quic/crypto/crypto_framer.h"
using std::max;
using std::min;
using std::string;
-using testing::_;
using testing::AnyNumber;
+using testing::_;
namespace net {
namespace test {
} // namespace
+QuicAckFrame MakeAckFrame(QuicPacketSequenceNumber largest_observed) {
+ QuicAckFrame ack;
+ ack.largest_observed = largest_observed;
+ ack.entropy_hash = 0;
+ return ack;
+}
+
+QuicAckFrame MakeAckFrameWithNackRanges(
+ size_t num_nack_ranges, QuicPacketSequenceNumber least_unacked) {
+ QuicAckFrame ack = MakeAckFrame(2 * num_nack_ranges + least_unacked);
+ // Add enough missing packets to get num_nack_ranges nack ranges.
+ for (QuicPacketSequenceNumber i = 1; i < 2 * num_nack_ranges; i += 2) {
+ ack.missing_packets.insert(least_unacked + i);
+ }
+ return ack;
+}
+
+SerializedPacket BuildUnsizedDataPacket(QuicFramer* framer,
+ const QuicPacketHeader& header,
+ const QuicFrames& frames) {
+ const size_t max_plaintext_size = framer->GetMaxPlaintextSize(kMaxPacketSize);
+ size_t packet_size = GetPacketHeaderSize(header);
+ for (size_t i = 0; i < frames.size(); ++i) {
+ DCHECK_LE(packet_size, max_plaintext_size);
+ bool first_frame = i == 0;
+ bool last_frame = i == frames.size() - 1;
+ const size_t frame_size = framer->GetSerializedFrameLength(
+ frames[i], max_plaintext_size - packet_size, first_frame, last_frame,
+ header.is_in_fec_group,
+ header.public_header.sequence_number_length);
+ DCHECK(frame_size);
+ packet_size += frame_size;
+ }
+ return framer->BuildDataPacket(header, frames, packet_size);
+}
+
+uint64 SimpleRandom::RandUint64() {
+ unsigned char hash[base::kSHA1Length];
+ base::SHA1HashBytes(reinterpret_cast<unsigned char*>(&seed_), sizeof(seed_),
+ hash);
+ memcpy(&seed_, hash, sizeof(seed_));
+ return seed_;
+}
+
MockFramerVisitor::MockFramerVisitor() {
// By default, we want to accept packets.
ON_CALL(*this, OnProtocolVersionMismatch(_))
ON_CALL(*this, OnStopWaitingFrame(_))
.WillByDefault(testing::Return(true));
+ ON_CALL(*this, OnPingFrame(_))
+ .WillByDefault(testing::Return(true));
+
ON_CALL(*this, OnRstStreamFrame(_))
.WillByDefault(testing::Return(true));
return true;
}
+bool NoOpFramerVisitor::OnPingFrame(const QuicPingFrame& frame) {
+ return true;
+}
+
bool NoOpFramerVisitor::OnRstStreamFrame(
const QuicRstStreamFrame& frame) {
return true;
return true;
}
-FramerVisitorCapturingFrames::FramerVisitorCapturingFrames() : frame_count_(0) {
-}
-
-FramerVisitorCapturingFrames::~FramerVisitorCapturingFrames() {
- Reset();
-}
-
-void FramerVisitorCapturingFrames::Reset() {
- STLDeleteElements(&stream_data_);
- stream_frames_.clear();
- frame_count_ = 0;
- ack_.reset();
- feedback_.reset();
- rst_.reset();
- close_.reset();
- goaway_.reset();
- version_negotiation_packet_.reset();
-}
-
-bool FramerVisitorCapturingFrames::OnPacketHeader(
- const QuicPacketHeader& header) {
- header_ = header;
- frame_count_ = 0;
- return true;
-}
-
-bool FramerVisitorCapturingFrames::OnStreamFrame(const QuicStreamFrame& frame) {
- // Make a copy of the frame and store a copy of underlying string, since
- // frame.data may not exist outside this callback.
- stream_data_.push_back(frame.GetDataAsString());
- QuicStreamFrame frame_copy = frame;
- frame_copy.data.Clear();
- frame_copy.data.Append(const_cast<char*>(stream_data_.back()->data()),
- stream_data_.back()->size());
- stream_frames_.push_back(frame_copy);
- ++frame_count_;
- return true;
-}
-
-bool FramerVisitorCapturingFrames::OnAckFrame(const QuicAckFrame& frame) {
- ack_.reset(new QuicAckFrame(frame));
- ++frame_count_;
- return true;
-}
-
-bool FramerVisitorCapturingFrames::OnCongestionFeedbackFrame(
- const QuicCongestionFeedbackFrame& frame) {
- feedback_.reset(new QuicCongestionFeedbackFrame(frame));
- ++frame_count_;
- return true;
-}
-
-bool FramerVisitorCapturingFrames::OnStopWaitingFrame(
- const QuicStopWaitingFrame& frame) {
- stop_waiting_.reset(new QuicStopWaitingFrame(frame));
- ++frame_count_;
- return true;
-}
-
-bool FramerVisitorCapturingFrames::OnRstStreamFrame(
- const QuicRstStreamFrame& frame) {
- rst_.reset(new QuicRstStreamFrame(frame));
- ++frame_count_;
- return true;
-}
-
-bool FramerVisitorCapturingFrames::OnConnectionCloseFrame(
- const QuicConnectionCloseFrame& frame) {
- close_.reset(new QuicConnectionCloseFrame(frame));
- ++frame_count_;
- return true;
-}
-
-bool FramerVisitorCapturingFrames::OnGoAwayFrame(const QuicGoAwayFrame& frame) {
- goaway_.reset(new QuicGoAwayFrame(frame));
- ++frame_count_;
- return true;
-}
-
-void FramerVisitorCapturingFrames::OnVersionNegotiationPacket(
- const QuicVersionNegotiationPacket& packet) {
- version_negotiation_packet_.reset(new QuicVersionNegotiationPacket(packet));
- frame_count_ = 0;
-}
-
-FramerVisitorCapturingPublicReset::FramerVisitorCapturingPublicReset() {
-}
-
-FramerVisitorCapturingPublicReset::~FramerVisitorCapturingPublicReset() {
-}
-
-void FramerVisitorCapturingPublicReset::OnPublicResetPacket(
- const QuicPublicResetPacket& public_reset) {
- public_reset_packet_ = public_reset;
-}
-
MockConnectionVisitor::MockConnectionVisitor() {
}
IPEndPoint(TestPeerIPAddress(), kTestPort),
new testing::NiceMock<MockHelper>(),
new testing::NiceMock<MockPacketWriter>(),
+ true /* owns_writer */,
is_server, QuicSupportedVersions()),
- writer_(QuicConnectionPeer::GetWriter(this)),
helper_(helper()) {
}
: QuicConnection(kTestConnectionId, address,
new testing::NiceMock<MockHelper>(),
new testing::NiceMock<MockPacketWriter>(),
+ true /* owns_writer */,
is_server, QuicSupportedVersions()),
- writer_(QuicConnectionPeer::GetWriter(this)),
helper_(helper()) {
}
IPEndPoint(TestPeerIPAddress(), kTestPort),
new testing::NiceMock<MockHelper>(),
new testing::NiceMock<MockPacketWriter>(),
+ true /* owns_writer */,
is_server, QuicSupportedVersions()),
- writer_(QuicConnectionPeer::GetWriter(this)),
helper_(helper()) {
}
IPEndPoint(TestPeerIPAddress(), kTestPort),
new testing::NiceMock<MockHelper>(),
new testing::NiceMock<MockPacketWriter>(),
+ true /* owns_writer */,
is_server, supported_versions),
- writer_(QuicConnectionPeer::GetWriter(this)),
helper_(helper()) {
}
MockSession::MockSession(QuicConnection* connection)
: QuicSession(connection, DefaultQuicConfig()) {
- ON_CALL(*this, WritevData(_, _, _, _, _))
+ InitializeSession();
+ ON_CALL(*this, WritevData(_, _, _, _, _, _))
.WillByDefault(testing::Return(QuicConsumedData(0, false)));
}
MockSession::~MockSession() {
}
-TestSession::TestSession(QuicConnection* connection,
- const QuicConfig& config)
+TestSession::TestSession(QuicConnection* connection, const QuicConfig& config)
: QuicSession(connection, config),
crypto_stream_(NULL) {
+ InitializeSession();
}
TestSession::~TestSession() {}
const QuicConfig& config)
: QuicClientSessionBase(connection, config),
crypto_stream_(NULL) {
- EXPECT_CALL(*this, OnProofValid(_)).Times(AnyNumber());
+ EXPECT_CALL(*this, OnProofValid(_)).Times(AnyNumber());
+ InitializeSession();
}
TestClientSession::~TestClientSession() {}
MockAckNotifierDelegate::~MockAckNotifierDelegate() {
}
+MockNetworkChangeVisitor::MockNetworkChangeVisitor() {
+}
+
+MockNetworkChangeVisitor::~MockNetworkChangeVisitor() {
+}
+
namespace {
string HexDumpWithMarks(const char* data, int length,
return addr;
}
+IPAddressNumber Loopback6() {
+ IPAddressNumber addr;
+ CHECK(ParseIPLiteralToNumber("::1", &addr));
+ return addr;
+}
+
+void GenerateBody(string* body, int length) {
+ body->clear();
+ body->reserve(length);
+ for (int i = 0; i < length; ++i) {
+ body->append(1, static_cast<char>(32 + i % (126 - 32)));
+ }
+}
+
QuicEncryptedPacket* ConstructEncryptedPacket(
QuicConnectionId connection_id,
bool version_flag,
frames.push_back(frame);
QuicFramer framer(QuicSupportedVersions(), QuicTime::Zero(), false);
scoped_ptr<QuicPacket> packet(
- framer.BuildUnsizedDataPacket(header, frames).packet);
+ BuildUnsizedDataPacket(&framer, header, frames).packet);
EXPECT_TRUE(packet != NULL);
QuicEncryptedPacket* encrypted = framer.EncryptPacket(ENCRYPTION_NONE,
sequence_number,
QuicFrame frame(&stream_frame);
QuicFrames frames;
frames.push_back(frame);
- return quic_framer.BuildUnsizedDataPacket(header, frames).packet;
+ return BuildUnsizedDataPacket(&quic_framer, header, frames).packet;
}
QuicPacket* ConstructHandshakePacket(QuicConnectionId connection_id,
const size_t stream_length =
NullEncrypter().GetCiphertextSize(*payload_length) +
QuicPacketCreator::StreamFramePacketOverhead(
- version, PACKET_8BYTE_CONNECTION_ID, include_version,
- sequence_number_length, is_in_fec_group);
+ PACKET_8BYTE_CONNECTION_ID, include_version,
+ sequence_number_length, 0u, is_in_fec_group);
const size_t ack_length = NullEncrypter().GetCiphertextSize(
QuicFramer::GetMinAckFrameSize(
- version, sequence_number_length, PACKET_1BYTE_SEQUENCE_NUMBER)) +
+ sequence_number_length, PACKET_1BYTE_SEQUENCE_NUMBER)) +
GetPacketHeaderSize(PACKET_8BYTE_CONNECTION_ID, include_version,
sequence_number_length, is_in_fec_group);
if (stream_length < ack_length) {
return NullEncrypter().GetCiphertextSize(*payload_length) +
QuicPacketCreator::StreamFramePacketOverhead(
- version, PACKET_8BYTE_CONNECTION_ID, include_version,
- sequence_number_length, is_in_fec_group);
+ PACKET_8BYTE_CONNECTION_ID, include_version,
+ sequence_number_length, 0u, is_in_fec_group);
}
-TestEntropyCalculator::TestEntropyCalculator() { }
+TestEntropyCalculator::TestEntropyCalculator() {}
-TestEntropyCalculator::~TestEntropyCalculator() { }
+TestEntropyCalculator::~TestEntropyCalculator() {}
QuicPacketEntropyHash TestEntropyCalculator::EntropyHash(
QuicPacketSequenceNumber sequence_number) const {
return 1u;
}
-MockEntropyCalculator::MockEntropyCalculator() { }
+MockEntropyCalculator::MockEntropyCalculator() {}
-MockEntropyCalculator::~MockEntropyCalculator() { }
+MockEntropyCalculator::~MockEntropyCalculator() {}
QuicConfig DefaultQuicConfig() {
QuicConfig config;
config.SetDefaults();
+ config.SetInitialFlowControlWindowToSend(
+ kInitialSessionFlowControlWindowForTest);
+ config.SetInitialStreamFlowControlWindowToSend(
+ kInitialStreamFlowControlWindowForTest);
+ config.SetInitialSessionFlowControlWindowToSend(
+ kInitialSessionFlowControlWindowForTest);
return config;
}
projects / platform / framework / web / crosswalk.git / blobdiff