blob: ada82621e3b6da9ac0131156a1fa54496bf71043 [file] [log] [blame]
[email protected]8b37a092012-10-18 21:53:491// Copyright (c) 2012 The Chromium Authors. All rights reserved.
2// Use of this source code is governed by a BSD-style license that can be
3// found in the LICENSE file.
4
5#include "net/quic/test_tools/quic_test_utils.h"
[email protected]9c0b1352012-11-04 00:03:276
[email protected]a5b98172014-06-18 07:01:597#include "base/sha1.h"
[email protected]701bc892013-01-17 04:51:548#include "base/stl_util.h"
[email protected]b12764d2013-12-02 22:28:309#include "base/strings/string_number_conversions.h"
[email protected]8b37a092012-10-18 21:53:4910#include "net/quic/crypto/crypto_framer.h"
[email protected]6f54ab32013-03-02 17:43:3511#include "net/quic/crypto/crypto_handshake.h"
[email protected]872edd9e2013-01-16 08:51:1512#include "net/quic/crypto/crypto_utils.h"
[email protected]5351cc4b2013-03-03 07:22:4113#include "net/quic/crypto/null_encrypter.h"
[email protected]4df69842013-02-27 06:32:1614#include "net/quic/crypto/quic_decrypter.h"
15#include "net/quic/crypto/quic_encrypter.h"
rtenneti16a20772015-02-17 18:58:4816#include "net/quic/quic_data_writer.h"
[email protected]a57e0272013-04-26 07:31:4717#include "net/quic/quic_framer.h"
[email protected]5351cc4b2013-03-03 07:22:4118#include "net/quic/quic_packet_creator.h"
[email protected]79d13dcb2014-02-05 07:23:1319#include "net/quic/quic_utils.h"
rtennetid39bd762015-06-12 01:05:5220#include "net/quic/test_tools/crypto_test_utils.h"
[email protected]cbd731e2013-10-24 00:20:3921#include "net/quic/test_tools/quic_connection_peer.h"
[email protected]c244c5a12013-05-07 20:55:0422#include "net/spdy/spdy_frame_builder.h"
rchc99f380c2015-03-26 19:50:5623#include "net/tools/quic/quic_per_connection_packet_writer.h"
[email protected]8b37a092012-10-18 21:53:4924
[email protected]c244c5a12013-05-07 20:55:0425using base::StringPiece;
[email protected]8b37a092012-10-18 21:53:4926using std::max;
27using std::min;
28using std::string;
rchc0815442015-04-18 13:29:4629using testing::Invoke;
[email protected]bc356fe2014-06-19 11:14:1430using testing::_;
[email protected]8b37a092012-10-18 21:53:4931
32namespace net {
33namespace test {
[email protected]965dbe62013-08-09 21:34:3134namespace {
35
rch99b644c2015-11-04 05:25:2836// No-op alarm implementation used by MockConnectionHelper.
[email protected]965dbe62013-08-09 21:34:3137class TestAlarm : public QuicAlarm {
38 public:
rjshaded5ced072015-12-18 19:26:0239 explicit TestAlarm(QuicAlarm::Delegate* delegate) : QuicAlarm(delegate) {}
[email protected]965dbe62013-08-09 21:34:3140
dchengb03027d2014-10-21 12:00:2041 void SetImpl() override {}
42 void CancelImpl() override {}
[email protected]965dbe62013-08-09 21:34:3143};
44
45} // namespace
[email protected]8b37a092012-10-18 21:53:4946
rtennetia004d332015-08-28 06:44:5747QuicAckFrame MakeAckFrame(QuicPacketNumber largest_observed) {
[email protected]fb35b0a2014-04-15 21:06:4948 QuicAckFrame ack;
[email protected]310d37b2014-08-02 06:15:3749 ack.largest_observed = largest_observed;
50 ack.entropy_hash = 0;
[email protected]fb35b0a2014-04-15 21:06:4951 return ack;
52}
53
rtennetia004d332015-08-28 06:44:5754QuicAckFrame MakeAckFrameWithNackRanges(size_t num_nack_ranges,
55 QuicPacketNumber least_unacked) {
[email protected]310d37b2014-08-02 06:15:3756 QuicAckFrame ack = MakeAckFrame(2 * num_nack_ranges + least_unacked);
[email protected]aa7e4ef2014-05-28 03:53:1557 // Add enough missing packets to get num_nack_ranges nack ranges.
rtennetia004d332015-08-28 06:44:5758 for (QuicPacketNumber i = 1; i < 2 * num_nack_ranges; i += 2) {
rtenneti493d90ef2015-09-14 04:43:1159 ack.missing_packets.Add(least_unacked + i);
[email protected]aa7e4ef2014-05-28 03:53:1560 }
61 return ack;
62}
63
rtennetib6ac61a52015-02-11 20:20:5264QuicPacket* BuildUnsizedDataPacket(QuicFramer* framer,
65 const QuicPacketHeader& header,
66 const QuicFrames& frames) {
[email protected]9cda5fd2014-06-03 10:20:2867 const size_t max_plaintext_size = framer->GetMaxPlaintextSize(kMaxPacketSize);
68 size_t packet_size = GetPacketHeaderSize(header);
69 for (size_t i = 0; i < frames.size(); ++i) {
70 DCHECK_LE(packet_size, max_plaintext_size);
71 bool first_frame = i == 0;
72 bool last_frame = i == frames.size() - 1;
73 const size_t frame_size = framer->GetSerializedFrameLength(
74 frames[i], max_plaintext_size - packet_size, first_frame, last_frame,
rtennetia004d332015-08-28 06:44:5775 header.is_in_fec_group, header.public_header.packet_number_length);
[email protected]9cda5fd2014-06-03 10:20:2876 DCHECK(frame_size);
77 packet_size += frame_size;
78 }
rtenneti16a20772015-02-17 18:58:4879 return BuildUnsizedDataPacket(framer, header, frames, packet_size);
80}
81
82QuicPacket* BuildUnsizedDataPacket(QuicFramer* framer,
83 const QuicPacketHeader& header,
84 const QuicFrames& frames,
85 size_t packet_size) {
86 char* buffer = new char[packet_size];
alyssarc39b80f2015-10-22 17:13:5887 size_t length = framer->BuildDataPacket(header, frames, buffer, packet_size);
88 DCHECK_NE(0u, length);
89 // Re-construct the data packet with data ownership.
90 return new QuicPacket(buffer, length, /* owns_buffer */ true,
rtenneti16a20772015-02-17 18:58:4891 header.public_header.connection_id_length,
92 header.public_header.version_flag,
rtennetia004d332015-08-28 06:44:5793 header.public_header.packet_number_length);
[email protected]9cda5fd2014-06-03 10:20:2894}
95
Avi Drissman13fc8932015-12-20 04:40:4696uint64_t SimpleRandom::RandUint64() {
[email protected]a5b98172014-06-18 07:01:5997 unsigned char hash[base::kSHA1Length];
98 base::SHA1HashBytes(reinterpret_cast<unsigned char*>(&seed_), sizeof(seed_),
99 hash);
100 memcpy(&seed_, hash, sizeof(seed_));
101 return seed_;
102}
103
[email protected]8b37a092012-10-18 21:53:49104MockFramerVisitor::MockFramerVisitor() {
105 // By default, we want to accept packets.
[email protected]14e8106c2013-03-14 16:25:33106 ON_CALL(*this, OnProtocolVersionMismatch(_))
107 .WillByDefault(testing::Return(false));
108
109 // By default, we want to accept packets.
[email protected]ec86d5462013-11-17 16:04:49110 ON_CALL(*this, OnUnauthenticatedHeader(_))
111 .WillByDefault(testing::Return(true));
112
[email protected]066d8182014-01-04 02:02:45113 ON_CALL(*this, OnUnauthenticatedPublicHeader(_))
114 .WillByDefault(testing::Return(true));
115
rjshaded5ced072015-12-18 19:26:02116 ON_CALL(*this, OnPacketHeader(_)).WillByDefault(testing::Return(true));
[email protected]a57e0272013-04-26 07:31:47117
rjshaded5ced072015-12-18 19:26:02118 ON_CALL(*this, OnStreamFrame(_)).WillByDefault(testing::Return(true));
[email protected]a57e0272013-04-26 07:31:47119
rjshaded5ced072015-12-18 19:26:02120 ON_CALL(*this, OnAckFrame(_)).WillByDefault(testing::Return(true));
[email protected]a57e0272013-04-26 07:31:47121
rjshaded5ced072015-12-18 19:26:02122 ON_CALL(*this, OnStopWaitingFrame(_)).WillByDefault(testing::Return(true));
[email protected]93dd91f2014-02-27 00:09:03123
rjshaded5ced072015-12-18 19:26:02124 ON_CALL(*this, OnPingFrame(_)).WillByDefault(testing::Return(true));
[email protected]d8c522112014-04-23 09:23:25125
rjshaded5ced072015-12-18 19:26:02126 ON_CALL(*this, OnRstStreamFrame(_)).WillByDefault(testing::Return(true));
[email protected]a57e0272013-04-26 07:31:47127
128 ON_CALL(*this, OnConnectionCloseFrame(_))
129 .WillByDefault(testing::Return(true));
130
rjshaded5ced072015-12-18 19:26:02131 ON_CALL(*this, OnGoAwayFrame(_)).WillByDefault(testing::Return(true));
[email protected]8b37a092012-10-18 21:53:49132}
133
rtenneti021e8822015-10-18 23:59:57134MockFramerVisitor::~MockFramerVisitor() {}
[email protected]8b37a092012-10-18 21:53:49135
[email protected]48878092013-07-26 14:51:56136bool NoOpFramerVisitor::OnProtocolVersionMismatch(QuicVersion version) {
[email protected]14e8106c2013-03-14 16:25:33137 return false;
138}
139
[email protected]066d8182014-01-04 02:02:45140bool NoOpFramerVisitor::OnUnauthenticatedPublicHeader(
141 const QuicPacketPublicHeader& header) {
142 return true;
143}
144
[email protected]ec86d5462013-11-17 16:04:49145bool NoOpFramerVisitor::OnUnauthenticatedHeader(
146 const QuicPacketHeader& header) {
147 return true;
148}
149
[email protected]8b37a092012-10-18 21:53:49150bool NoOpFramerVisitor::OnPacketHeader(const QuicPacketHeader& header) {
151 return true;
152}
153
[email protected]a57e0272013-04-26 07:31:47154bool NoOpFramerVisitor::OnStreamFrame(const QuicStreamFrame& frame) {
155 return true;
156}
157
158bool NoOpFramerVisitor::OnAckFrame(const QuicAckFrame& frame) {
159 return true;
160}
161
rjshaded5ced072015-12-18 19:26:02162bool NoOpFramerVisitor::OnStopWaitingFrame(const QuicStopWaitingFrame& frame) {
[email protected]93dd91f2014-02-27 00:09:03163 return true;
164}
165
[email protected]d8c522112014-04-23 09:23:25166bool NoOpFramerVisitor::OnPingFrame(const QuicPingFrame& frame) {
167 return true;
168}
169
rjshaded5ced072015-12-18 19:26:02170bool NoOpFramerVisitor::OnRstStreamFrame(const QuicRstStreamFrame& frame) {
[email protected]a57e0272013-04-26 07:31:47171 return true;
172}
173
174bool NoOpFramerVisitor::OnConnectionCloseFrame(
175 const QuicConnectionCloseFrame& frame) {
176 return true;
177}
178
179bool NoOpFramerVisitor::OnGoAwayFrame(const QuicGoAwayFrame& frame) {
180 return true;
181}
182
[email protected]cb23a922014-02-20 17:42:38183bool NoOpFramerVisitor::OnWindowUpdateFrame(
184 const QuicWindowUpdateFrame& frame) {
185 return true;
186}
187
188bool NoOpFramerVisitor::OnBlockedFrame(const QuicBlockedFrame& frame) {
189 return true;
190}
191
rtenneti021e8822015-10-18 23:59:57192MockConnectionVisitor::MockConnectionVisitor() {}
[email protected]8d659e22013-01-19 04:26:10193
rtenneti021e8822015-10-18 23:59:57194MockConnectionVisitor::~MockConnectionVisitor() {}
[email protected]8d659e22013-01-19 04:26:10195
rch99b644c2015-11-04 05:25:28196MockConnectionHelper::MockConnectionHelper() {}
[email protected]9c0b1352012-11-04 00:03:27197
rch99b644c2015-11-04 05:25:28198MockConnectionHelper::~MockConnectionHelper() {}
[email protected]9c0b1352012-11-04 00:03:27199
rch99b644c2015-11-04 05:25:28200const QuicClock* MockConnectionHelper::GetClock() const {
[email protected]9c0b1352012-11-04 00:03:27201 return &clock_;
202}
203
rch99b644c2015-11-04 05:25:28204QuicRandom* MockConnectionHelper::GetRandomGenerator() {
[email protected]9558c5d32012-12-22 00:08:14205 return &random_generator_;
206}
207
rch99b644c2015-11-04 05:25:28208QuicAlarm* MockConnectionHelper::CreateAlarm(QuicAlarm::Delegate* delegate) {
[email protected]965dbe62013-08-09 21:34:31209 return new TestAlarm(delegate);
210}
211
jdorfman5a606722016-01-04 17:41:29212QuicBufferAllocator* MockConnectionHelper::GetBufferAllocator() {
213 return &buffer_allocator_;
214}
215
rch99b644c2015-11-04 05:25:28216void MockConnectionHelper::AdvanceTime(QuicTime::Delta delta) {
[email protected]fe053f92013-04-23 20:18:55217 clock_.AdvanceTime(delta);
218}
219
rtenneti3fe4ebbc2014-11-16 16:43:47220QuicPacketWriter* NiceMockPacketWriterFactory::Create(
221 QuicConnection* /*connection*/) const {
222 return new testing::NiceMock<MockPacketWriter>();
223}
[email protected]6d515822014-08-22 01:58:06224
rch99b644c2015-11-04 05:25:28225MockConnection::MockConnection(MockConnectionHelper* helper,
226 Perspective perspective)
rchc0815442015-04-18 13:29:46227 : MockConnection(kTestConnectionId,
rtenneti8696cf92014-11-14 21:12:12228 IPEndPoint(TestPeerIPAddress(), kTestPort),
rtenneti8a4a0732015-10-18 00:45:51229 helper,
rtenneti6f48aa92015-03-16 02:18:48230 perspective,
rtenneti8a4a0732015-10-18 00:45:51231 QuicSupportedVersions()) {}
[email protected]c05a6d222013-12-16 19:42:03232
rtenneti8a4a0732015-10-18 00:45:51233MockConnection::MockConnection(IPEndPoint address,
rch99b644c2015-11-04 05:25:28234 MockConnectionHelper* helper,
rtenneti8a4a0732015-10-18 00:45:51235 Perspective perspective)
rchc0815442015-04-18 13:29:46236 : MockConnection(kTestConnectionId,
rtenneti6f48aa92015-03-16 02:18:48237 address,
rtenneti8a4a0732015-10-18 00:45:51238 helper,
rtenneti6f48aa92015-03-16 02:18:48239 perspective,
rtenneti8a4a0732015-10-18 00:45:51240 QuicSupportedVersions()) {}
[email protected]044ac2b2012-11-13 21:41:06241
[email protected]3aa9ca72014-02-27 19:39:43242MockConnection::MockConnection(QuicConnectionId connection_id,
rch99b644c2015-11-04 05:25:28243 MockConnectionHelper* helper,
rtenneti6f48aa92015-03-16 02:18:48244 Perspective perspective)
rchc0815442015-04-18 13:29:46245 : MockConnection(connection_id,
rtennetifb3fa6c2015-03-16 23:04:55246 IPEndPoint(TestPeerIPAddress(), kTestPort),
rtenneti8a4a0732015-10-18 00:45:51247 helper,
rchc0815442015-04-18 13:29:46248 perspective,
rtenneti8a4a0732015-10-18 00:45:51249 QuicSupportedVersions()) {}
rchc0815442015-04-18 13:29:46250
rch99b644c2015-11-04 05:25:28251MockConnection::MockConnection(MockConnectionHelper* helper,
rtenneti8a4a0732015-10-18 00:45:51252 Perspective perspective,
rchc0815442015-04-18 13:29:46253 const QuicVersionVector& supported_versions)
254 : MockConnection(kTestConnectionId,
255 IPEndPoint(TestPeerIPAddress(), kTestPort),
rtenneti8a4a0732015-10-18 00:45:51256 helper,
rchc0815442015-04-18 13:29:46257 perspective,
rtenneti8a4a0732015-10-18 00:45:51258 supported_versions) {}
rchc0815442015-04-18 13:29:46259
260MockConnection::MockConnection(QuicConnectionId connection_id,
261 IPEndPoint address,
rch99b644c2015-11-04 05:25:28262 MockConnectionHelper* helper,
rchc0815442015-04-18 13:29:46263 Perspective perspective,
rchc0815442015-04-18 13:29:46264 const QuicVersionVector& supported_versions)
265 : QuicConnection(connection_id,
266 address,
rtenneti8a4a0732015-10-18 00:45:51267 helper,
rtennetifb3fa6c2015-03-16 23:04:55268 NiceMockPacketWriterFactory(),
269 /* owns_writer= */ true,
270 perspective,
rtenneti8a4a0732015-10-18 00:45:51271 supported_versions) {
rchc0815442015-04-18 13:29:46272 ON_CALL(*this, OnError(_))
273 .WillByDefault(
274 Invoke(this, &PacketSavingConnection::QuicConnection_OnError));
[email protected]4d640792013-12-18 22:21:08275}
276
rtenneti021e8822015-10-18 23:59:57277MockConnection::~MockConnection() {}
[email protected]044ac2b2012-11-13 21:41:06278
[email protected]fe053f92013-04-23 20:18:55279void MockConnection::AdvanceTime(QuicTime::Delta delta) {
rch99b644c2015-11-04 05:25:28280 static_cast<MockConnectionHelper*>(helper())->AdvanceTime(delta);
[email protected]fe053f92013-04-23 20:18:55281}
282
rch99b644c2015-11-04 05:25:28283PacketSavingConnection::PacketSavingConnection(MockConnectionHelper* helper,
rtenneti8a4a0732015-10-18 00:45:51284 Perspective perspective)
285 : MockConnection(helper, perspective) {}
[email protected]044ac2b2012-11-13 21:41:06286
[email protected]4d640792013-12-18 22:21:08287PacketSavingConnection::PacketSavingConnection(
rch99b644c2015-11-04 05:25:28288 MockConnectionHelper* helper,
rtenneti6f48aa92015-03-16 02:18:48289 Perspective perspective,
[email protected]4d640792013-12-18 22:21:08290 const QuicVersionVector& supported_versions)
rtenneti8a4a0732015-10-18 00:45:51291 : MockConnection(helper, perspective, supported_versions) {}
[email protected]4d640792013-12-18 22:21:08292
[email protected]044ac2b2012-11-13 21:41:06293PacketSavingConnection::~PacketSavingConnection() {
[email protected]2532de12013-05-09 12:29:33294 STLDeleteElements(&encrypted_packets_);
[email protected]044ac2b2012-11-13 21:41:06295}
296
rtenneti31e9fd62014-09-16 05:22:15297void PacketSavingConnection::SendOrQueuePacket(QueuedPacket packet) {
rtennetie0ee6eb2015-05-01 00:55:09298 if (!packet.serialized_packet.packet->owns_buffer()) {
299 scoped_ptr<QuicEncryptedPacket> encrypted_deleter(
300 packet.serialized_packet.packet);
301 packet.serialized_packet.packet = packet.serialized_packet.packet->Clone();
302 }
rtennetib6ac61a52015-02-11 20:20:52303 encrypted_packets_.push_back(packet.serialized_packet.packet);
rtenneti31e9fd62014-09-16 05:22:15304 // Transfer ownership of the packet to the SentPacketManager and the
305 // ack notifier to the AckNotifierManager.
rjshaded5ced072015-12-18 19:26:02306 sent_packet_manager_.OnPacketSent(&packet.serialized_packet, 0,
307 QuicTime::Zero(), 1000, NOT_RETRANSMISSION,
308 HAS_RETRANSMITTABLE_DATA);
[email protected]044ac2b2012-11-13 21:41:06309}
310
rtennetib865eb82015-06-17 20:21:46311MockQuicSpdySession::MockQuicSpdySession(QuicConnection* connection)
312 : QuicSpdySession(connection, DefaultQuicConfig()) {
rtennetid39bd762015-06-12 01:05:52313 crypto_stream_.reset(new QuicCryptoStream(this));
314 Initialize();
[email protected]bbb10072014-06-13 07:41:59315 ON_CALL(*this, WritevData(_, _, _, _, _, _))
[email protected]cff7b7b2013-01-11 08:49:07316 .WillByDefault(testing::Return(QuicConsumedData(0, false)));
[email protected]044ac2b2012-11-13 21:41:06317}
318
rtenneti021e8822015-10-18 23:59:57319MockQuicSpdySession::~MockQuicSpdySession() {}
[email protected]044ac2b2012-11-13 21:41:06320
jokulik2324d282015-12-08 21:42:57321// static
322QuicConsumedData MockQuicSpdySession::ConsumeAllData(
323 QuicStreamId /*id*/,
324 const QuicIOVector& data,
325 QuicStreamOffset /*offset*/,
326 bool fin,
327 FecProtection /*fec_protection*/,
328 QuicAckListenerInterface* /*ack_notifier_delegate*/) {
329 return QuicConsumedData(data.total_length, fin);
330}
331
rtennetib865eb82015-06-17 20:21:46332TestQuicSpdyServerSession::TestQuicSpdyServerSession(
rtennetid39bd762015-06-12 01:05:52333 QuicConnection* connection,
334 const QuicConfig& config,
335 const QuicCryptoServerConfig* crypto_config)
jokulikc971baf92016-01-06 00:36:39336 : QuicServerSessionBase(config, connection, &visitor_, crypto_config) {
rtennetid39bd762015-06-12 01:05:52337 Initialize();
[email protected]ccb34212014-07-18 09:27:50338}
[email protected]2532de12013-05-09 12:29:33339
rtenneti021e8822015-10-18 23:59:57340TestQuicSpdyServerSession::~TestQuicSpdyServerSession() {}
[email protected]2532de12013-05-09 12:29:33341
jokulikc971baf92016-01-06 00:36:39342QuicCryptoServerStreamBase*
343TestQuicSpdyServerSession::CreateQuicCryptoServerStream(
344 const QuicCryptoServerConfig* crypto_config) {
345 return new QuicCryptoServerStream(crypto_config, this);
346}
347
rtennetib865eb82015-06-17 20:21:46348QuicCryptoServerStream* TestQuicSpdyServerSession::GetCryptoStream() {
zhongyib8677022015-12-01 05:51:30349 return static_cast<QuicCryptoServerStream*>(
jokulikc971baf92016-01-06 00:36:39350 QuicServerSessionBase::GetCryptoStream());
[email protected]2532de12013-05-09 12:29:33351}
352
rtennetib865eb82015-06-17 20:21:46353TestQuicSpdyClientSession::TestQuicSpdyClientSession(
354 QuicConnection* connection,
355 const QuicConfig& config,
356 const QuicServerId& server_id,
357 QuicCryptoClientConfig* crypto_config)
rtennetid39bd762015-06-12 01:05:52358 : QuicClientSessionBase(connection, config) {
359 crypto_stream_.reset(new QuicCryptoClientStream(
360 server_id, this, CryptoTestUtils::ProofVerifyContextForTesting(),
361 crypto_config));
362 Initialize();
[email protected]90f62f092014-03-24 02:41:23363}
364
rtenneti021e8822015-10-18 23:59:57365TestQuicSpdyClientSession::~TestQuicSpdyClientSession() {}
[email protected]90f62f092014-03-24 02:41:23366
rtennetib865eb82015-06-17 20:21:46367QuicCryptoClientStream* TestQuicSpdyClientSession::GetCryptoStream() {
rtennetid39bd762015-06-12 01:05:52368 return crypto_stream_.get();
rtennetia2ea9162015-05-15 19:26:44369}
370
[email protected]cbd731e2013-10-24 00:20:39371MockPacketWriter::MockPacketWriter() {
rtenneti493d90ef2015-09-14 04:43:11372 ON_CALL(*this, GetMaxPacketSize(_))
373 .WillByDefault(testing::Return(kMaxPacketSize));
[email protected]cbd731e2013-10-24 00:20:39374}
375
rtenneti021e8822015-10-18 23:59:57376MockPacketWriter::~MockPacketWriter() {}
[email protected]cbd731e2013-10-24 00:20:39377
rtenneti021e8822015-10-18 23:59:57378MockSendAlgorithm::MockSendAlgorithm() {}
[email protected]8d659e22013-01-19 04:26:10379
rtenneti021e8822015-10-18 23:59:57380MockSendAlgorithm::~MockSendAlgorithm() {}
[email protected]8d659e22013-01-19 04:26:10381
rtenneti021e8822015-10-18 23:59:57382MockLossAlgorithm::MockLossAlgorithm() {}
[email protected]3aa9ca72014-02-27 19:39:43383
rtenneti021e8822015-10-18 23:59:57384MockLossAlgorithm::~MockLossAlgorithm() {}
[email protected]3aa9ca72014-02-27 19:39:43385
ckrasicea295fe2015-10-31 05:03:27386MockAckListener::MockAckListener() {}
[email protected]97cf3022013-09-05 14:30:16387
ckrasicea295fe2015-10-31 05:03:27388MockAckListener::~MockAckListener() {}
[email protected]97cf3022013-09-05 14:30:16389
rtenneti021e8822015-10-18 23:59:57390MockNetworkChangeVisitor::MockNetworkChangeVisitor() {}
[email protected]a692ad9d2014-07-18 21:35:24391
rtenneti021e8822015-10-18 23:59:57392MockNetworkChangeVisitor::~MockNetworkChangeVisitor() {}
[email protected]a692ad9d2014-07-18 21:35:24393
[email protected]8b37a092012-10-18 21:53:49394namespace {
395
rjshaded5ced072015-12-18 19:26:02396string HexDumpWithMarks(const char* data,
397 int length,
398 const bool* marks,
399 int mark_length) {
[email protected]8b37a092012-10-18 21:53:49400 static const char kHexChars[] = "0123456789abcdef";
401 static const int kColumns = 4;
402
403 const int kSizeLimit = 1024;
404 if (length > kSizeLimit || mark_length > kSizeLimit) {
405 LOG(ERROR) << "Only dumping first " << kSizeLimit << " bytes.";
406 length = min(length, kSizeLimit);
407 mark_length = min(mark_length, kSizeLimit);
408 }
409
410 string hex;
rjshaded5ced072015-12-18 19:26:02411 for (const char *row = data; length > 0;
[email protected]8b37a092012-10-18 21:53:49412 row += kColumns, length -= kColumns) {
rjshaded5ced072015-12-18 19:26:02413 for (const char* p = row; p < row + 4; ++p) {
[email protected]8b37a092012-10-18 21:53:49414 if (p < row + length) {
415 const bool mark =
416 (marks && (p - data) < mark_length && marks[p - data]);
417 hex += mark ? '*' : ' ';
418 hex += kHexChars[(*p & 0xf0) >> 4];
419 hex += kHexChars[*p & 0x0f];
420 hex += mark ? '*' : ' ';
421 } else {
422 hex += " ";
423 }
424 }
425 hex = hex + " ";
426
rtenneti6f48aa92015-03-16 02:18:48427 for (const char* p = row; p < row + 4 && p < row + length; ++p) {
[email protected]8b37a092012-10-18 21:53:49428 hex += (*p >= 0x20 && *p <= 0x7f) ? (*p) : '.';
rtenneti6f48aa92015-03-16 02:18:48429 }
[email protected]8b37a092012-10-18 21:53:49430
431 hex = hex + '\n';
432 }
433 return hex;
434}
435
436} // namespace
437
rjshaded5ced072015-12-18 19:26:02438IPAddressNumber TestPeerIPAddress() {
439 return Loopback4();
440}
[email protected]300ccd52014-01-25 08:00:19441
rjshaded5ced072015-12-18 19:26:02442QuicVersion QuicVersionMax() {
443 return QuicSupportedVersions().front();
444}
[email protected]b007e632013-10-28 08:39:25445
rjshaded5ced072015-12-18 19:26:02446QuicVersion QuicVersionMin() {
447 return QuicSupportedVersions().back();
448}
[email protected]b007e632013-10-28 08:39:25449
[email protected]c05a6d222013-12-16 19:42:03450IPAddressNumber Loopback4() {
[email protected]300ccd52014-01-25 08:00:19451 IPAddressNumber addr;
452 CHECK(ParseIPLiteralToNumber("127.0.0.1", &addr));
[email protected]c05a6d222013-12-16 19:42:03453 return addr;
454}
455
[email protected]730b35d72014-06-05 03:23:22456IPAddressNumber Loopback6() {
457 IPAddressNumber addr;
458 CHECK(ParseIPLiteralToNumber("::1", &addr));
459 return addr;
460}
461
rtennetie0ee6eb2015-05-01 00:55:09462IPAddressNumber Any4() {
463 IPAddressNumber any4;
464 CHECK(net::ParseIPLiteralToNumber("0.0.0.0", &any4));
465 return any4;
466}
467
[email protected]9bb57c72014-03-31 20:36:04468void GenerateBody(string* body, int length) {
469 body->clear();
470 body->reserve(length);
471 for (int i = 0; i < length; ++i) {
472 body->append(1, static_cast<char>(32 + i % (126 - 32)));
473 }
474}
475
rtennetia004d332015-08-28 06:44:57476QuicEncryptedPacket* ConstructEncryptedPacket(QuicConnectionId connection_id,
477 bool version_flag,
478 bool reset_flag,
479 QuicPacketNumber packet_number,
480 const string& data) {
rtenneti9e0fb502015-03-08 06:07:16481 return ConstructEncryptedPacket(
rtennetia004d332015-08-28 06:44:57482 connection_id, version_flag, reset_flag, packet_number, data,
483 PACKET_8BYTE_CONNECTION_ID, PACKET_6BYTE_PACKET_NUMBER);
rtenneti9e0fb502015-03-08 06:07:16484}
485
486QuicEncryptedPacket* ConstructEncryptedPacket(
487 QuicConnectionId connection_id,
488 bool version_flag,
489 bool reset_flag,
rtennetia004d332015-08-28 06:44:57490 QuicPacketNumber packet_number,
rtenneti9e0fb502015-03-08 06:07:16491 const string& data,
492 QuicConnectionIdLength connection_id_length,
rtennetia004d332015-08-28 06:44:57493 QuicPacketNumberLength packet_number_length) {
rchc0815442015-04-18 13:29:46494 return ConstructEncryptedPacket(connection_id, version_flag, reset_flag,
rtennetia004d332015-08-28 06:44:57495 packet_number, data, connection_id_length,
496 packet_number_length, nullptr);
rchc0815442015-04-18 13:29:46497}
498
499QuicEncryptedPacket* ConstructEncryptedPacket(
500 QuicConnectionId connection_id,
501 bool version_flag,
502 bool reset_flag,
rtennetia004d332015-08-28 06:44:57503 QuicPacketNumber packet_number,
rchc0815442015-04-18 13:29:46504 const string& data,
505 QuicConnectionIdLength connection_id_length,
rtennetia004d332015-08-28 06:44:57506 QuicPacketNumberLength packet_number_length,
rchc0815442015-04-18 13:29:46507 QuicVersionVector* versions) {
[email protected]ffc34bf2014-03-07 02:42:02508 QuicPacketHeader header;
509 header.public_header.connection_id = connection_id;
rtenneti9e0fb502015-03-08 06:07:16510 header.public_header.connection_id_length = connection_id_length;
[email protected]ffc34bf2014-03-07 02:42:02511 header.public_header.version_flag = version_flag;
512 header.public_header.reset_flag = reset_flag;
rtennetia004d332015-08-28 06:44:57513 header.public_header.packet_number_length = packet_number_length;
rtenneti8dd12b22015-10-21 01:26:38514 header.packet_number = packet_number;
[email protected]ffc34bf2014-03-07 02:42:02515 header.entropy_flag = false;
516 header.entropy_hash = 0;
517 header.fec_flag = false;
518 header.is_in_fec_group = NOT_IN_FEC_GROUP;
519 header.fec_group = 0;
rtennetia4228ea2015-06-04 02:31:44520 QuicStreamFrame stream_frame(1, false, 0, StringPiece(data));
[email protected]ffc34bf2014-03-07 02:42:02521 QuicFrame frame(&stream_frame);
522 QuicFrames frames;
523 frames.push_back(frame);
rchc0815442015-04-18 13:29:46524 QuicFramer framer(versions != nullptr ? *versions : QuicSupportedVersions(),
525 QuicTime::Zero(), Perspective::IS_CLIENT);
526
[email protected]ffc34bf2014-03-07 02:42:02527 scoped_ptr<QuicPacket> packet(
rtennetib6ac61a52015-02-11 20:20:52528 BuildUnsizedDataPacket(&framer, header, frames));
rtennetibe635732014-10-02 22:51:42529 EXPECT_TRUE(packet != nullptr);
rch99b644c2015-11-04 05:25:28530 char* buffer = new char[kMaxPacketSize];
531 size_t encrypted_length = framer.EncryptPayload(
532 ENCRYPTION_NONE, packet_number, *packet, buffer, kMaxPacketSize);
533 EXPECT_NE(0u, encrypted_length);
534 return new QuicEncryptedPacket(buffer, encrypted_length, true);
[email protected]ffc34bf2014-03-07 02:42:02535}
536
rchc0815442015-04-18 13:29:46537QuicEncryptedPacket* ConstructMisFramedEncryptedPacket(
538 QuicConnectionId connection_id,
539 bool version_flag,
540 bool reset_flag,
rtennetia004d332015-08-28 06:44:57541 QuicPacketNumber packet_number,
rchc0815442015-04-18 13:29:46542 const string& data,
543 QuicConnectionIdLength connection_id_length,
rtennetia004d332015-08-28 06:44:57544 QuicPacketNumberLength packet_number_length,
rchc0815442015-04-18 13:29:46545 QuicVersionVector* versions) {
546 QuicPacketHeader header;
547 header.public_header.connection_id = connection_id;
548 header.public_header.connection_id_length = connection_id_length;
549 header.public_header.version_flag = version_flag;
550 header.public_header.reset_flag = reset_flag;
rtennetia004d332015-08-28 06:44:57551 header.public_header.packet_number_length = packet_number_length;
rtenneti8dd12b22015-10-21 01:26:38552 header.packet_number = packet_number;
rchc0815442015-04-18 13:29:46553 header.entropy_flag = false;
554 header.entropy_hash = 0;
555 header.fec_flag = false;
556 header.is_in_fec_group = NOT_IN_FEC_GROUP;
557 header.fec_group = 0;
rtennetia4228ea2015-06-04 02:31:44558 QuicStreamFrame stream_frame(1, false, 0, StringPiece(data));
rtenneti85816fdf2015-05-25 03:01:10559 QuicFrame frame(&stream_frame);
rchc0815442015-04-18 13:29:46560 QuicFrames frames;
rtenneti85816fdf2015-05-25 03:01:10561 frames.push_back(frame);
562 QuicFramer framer(versions != nullptr ? *versions : QuicSupportedVersions(),
rchc0815442015-04-18 13:29:46563 QuicTime::Zero(), Perspective::IS_CLIENT);
rtenneti85816fdf2015-05-25 03:01:10564
rchc0815442015-04-18 13:29:46565 scoped_ptr<QuicPacket> packet(
566 BuildUnsizedDataPacket(&framer, header, frames));
567 EXPECT_TRUE(packet != nullptr);
rtenneti85816fdf2015-05-25 03:01:10568
569 // Now set the packet's private flags byte to 0xFF, which is an invalid value.
570 reinterpret_cast<unsigned char*>(
571 packet->mutable_data())[GetStartOfEncryptedData(
rtennetia004d332015-08-28 06:44:57572 connection_id_length, version_flag, packet_number_length)] = 0xFF;
rtenneti85816fdf2015-05-25 03:01:10573
rch99b644c2015-11-04 05:25:28574 char* buffer = new char[kMaxPacketSize];
575 size_t encrypted_length = framer.EncryptPayload(
576 ENCRYPTION_NONE, packet_number, *packet, buffer, kMaxPacketSize);
577 EXPECT_NE(0u, encrypted_length);
578 return new QuicEncryptedPacket(buffer, encrypted_length, true);
rchc0815442015-04-18 13:29:46579}
580
rjshaded5ced072015-12-18 19:26:02581void CompareCharArraysWithHexError(const string& description,
582 const char* actual,
583 const int actual_len,
584 const char* expected,
585 const int expected_len) {
[email protected]b007e632013-10-28 08:39:25586 EXPECT_EQ(actual_len, expected_len);
[email protected]8b37a092012-10-18 21:53:49587 const int min_len = min(actual_len, expected_len);
588 const int max_len = max(actual_len, expected_len);
[email protected]4356f0f2013-04-07 00:58:17589 scoped_ptr<bool[]> marks(new bool[max_len]);
[email protected]8b37a092012-10-18 21:53:49590 bool identical = (actual_len == expected_len);
591 for (int i = 0; i < min_len; ++i) {
592 if (actual[i] != expected[i]) {
593 marks[i] = true;
594 identical = false;
595 } else {
596 marks[i] = false;
597 }
598 }
599 for (int i = min_len; i < max_len; ++i) {
600 marks[i] = true;
601 }
rjshaded5ced072015-12-18 19:26:02602 if (identical)
603 return;
604 ADD_FAILURE() << "Description:\n" << description << "\n\nExpected:\n"
605 << HexDumpWithMarks(expected, expected_len, marks.get(),
606 max_len)
607 << "\nActual:\n"
608 << HexDumpWithMarks(actual, actual_len, marks.get(), max_len);
[email protected]8b37a092012-10-18 21:53:49609}
610
[email protected]b12764d2013-12-02 22:28:30611bool DecodeHexString(const base::StringPiece& hex, std::string* bytes) {
612 bytes->clear();
613 if (hex.empty())
614 return true;
Avi Drissman13fc8932015-12-20 04:40:46615 std::vector<uint8_t> v;
[email protected]b12764d2013-12-02 22:28:30616 if (!base::HexStringToBytes(hex.as_string(), &v))
617 return false;
618 if (!v.empty())
619 bytes->assign(reinterpret_cast<const char*>(&v[0]), v.size());
620 return true;
621}
622
[email protected]d3d15bf2013-01-30 02:51:54623static QuicPacket* ConstructPacketFromHandshakeMessage(
[email protected]3aa9ca72014-02-27 19:39:43624 QuicConnectionId connection_id,
[email protected]14e8106c2013-03-14 16:25:33625 const CryptoHandshakeMessage& message,
626 bool should_include_version) {
[email protected]8b37a092012-10-18 21:53:49627 CryptoFramer crypto_framer;
[email protected]dc2cc742012-10-21 13:56:13628 scoped_ptr<QuicData> data(crypto_framer.ConstructHandshakeMessage(message));
rtenneti6f48aa92015-03-16 02:18:48629 QuicFramer quic_framer(QuicSupportedVersions(), QuicTime::Zero(),
630 Perspective::IS_CLIENT);
[email protected]8b37a092012-10-18 21:53:49631
632 QuicPacketHeader header;
[email protected]3aa9ca72014-02-27 19:39:43633 header.public_header.connection_id = connection_id;
[email protected]9db443912013-02-25 05:27:03634 header.public_header.reset_flag = false;
[email protected]14e8106c2013-03-14 16:25:33635 header.public_header.version_flag = should_include_version;
rtenneti8dd12b22015-10-21 01:26:38636 header.packet_number = 1;
[email protected]9db443912013-02-25 05:27:03637 header.entropy_flag = false;
638 header.entropy_hash = 0;
639 header.fec_flag = false;
[email protected]8b37a092012-10-18 21:53:49640 header.fec_group = 0;
641
[email protected]be24ab22012-10-22 03:01:52642 QuicStreamFrame stream_frame(kCryptoStreamId, false, 0,
rtennetia4228ea2015-06-04 02:31:44643 data->AsStringPiece());
[email protected]8b37a092012-10-18 21:53:49644
[email protected]be24ab22012-10-22 03:01:52645 QuicFrame frame(&stream_frame);
646 QuicFrames frames;
647 frames.push_back(frame);
rtennetib6ac61a52015-02-11 20:20:52648 return BuildUnsizedDataPacket(&quic_framer, header, frames);
[email protected]8b37a092012-10-18 21:53:49649}
650
[email protected]3aa9ca72014-02-27 19:39:43651QuicPacket* ConstructHandshakePacket(QuicConnectionId connection_id,
652 QuicTag tag) {
[email protected]d3d15bf2013-01-30 02:51:54653 CryptoHandshakeMessage message;
[email protected]ccc66e8a2013-03-26 08:26:14654 message.set_tag(tag);
[email protected]3aa9ca72014-02-27 19:39:43655 return ConstructPacketFromHandshakeMessage(connection_id, message, false);
[email protected]d3d15bf2013-01-30 02:51:54656}
657
rtennetia004d332015-08-28 06:44:57658size_t GetPacketLengthForOneStream(QuicVersion version,
659 bool include_version,
660 QuicConnectionIdLength connection_id_length,
661 QuicPacketNumberLength packet_number_length,
662 InFecGroup is_in_fec_group,
663 size_t* payload_length) {
[email protected]f62262b2013-07-05 20:57:30664 *payload_length = 1;
665 const size_t stream_length =
[email protected]5dafdb62013-11-14 01:24:26666 NullEncrypter().GetCiphertextSize(*payload_length) +
[email protected]b064310782013-05-30 21:12:17667 QuicPacketCreator::StreamFramePacketOverhead(
rtennetia004d332015-08-28 06:44:57668 PACKET_8BYTE_CONNECTION_ID, include_version, packet_number_length, 0u,
669 is_in_fec_group);
rtennetic14c8ab2015-06-18 05:47:40670 const size_t ack_length =
671 NullEncrypter().GetCiphertextSize(
rtennetia004d332015-08-28 06:44:57672 QuicFramer::GetMinAckFrameSize(PACKET_1BYTE_PACKET_NUMBER)) +
rtenneti23186682014-10-30 01:49:33673 GetPacketHeaderSize(connection_id_length, include_version,
zhongyib8677022015-12-01 05:51:30674 /*include_path_id=*/false, packet_number_length,
675 is_in_fec_group);
[email protected]f62262b2013-07-05 20:57:30676 if (stream_length < ack_length) {
677 *payload_length = 1 + ack_length - stream_length;
678 }
679
[email protected]5dafdb62013-11-14 01:24:26680 return NullEncrypter().GetCiphertextSize(*payload_length) +
rtennetia004d332015-08-28 06:44:57681 QuicPacketCreator::StreamFramePacketOverhead(
682 connection_id_length, include_version, packet_number_length, 0u,
683 is_in_fec_group);
[email protected]5351cc4b2013-03-03 07:22:41684}
685
[email protected]a5b98172014-06-18 07:01:59686TestEntropyCalculator::TestEntropyCalculator() {}
[email protected]8e01c062013-10-31 07:35:31687
[email protected]a5b98172014-06-18 07:01:59688TestEntropyCalculator::~TestEntropyCalculator() {}
[email protected]8e01c062013-10-31 07:35:31689
[email protected]48878092013-07-26 14:51:56690QuicPacketEntropyHash TestEntropyCalculator::EntropyHash(
rtennetia004d332015-08-28 06:44:57691 QuicPacketNumber packet_number) const {
[email protected]9db443912013-02-25 05:27:03692 return 1u;
693}
694
[email protected]a5b98172014-06-18 07:01:59695MockEntropyCalculator::MockEntropyCalculator() {}
[email protected]8e01c062013-10-31 07:35:31696
[email protected]a5b98172014-06-18 07:01:59697MockEntropyCalculator::~MockEntropyCalculator() {}
[email protected]8e01c062013-10-31 07:35:31698
[email protected]b064310782013-05-30 21:12:17699QuicConfig DefaultQuicConfig() {
700 QuicConfig config;
[email protected]7d561352014-06-20 09:09:21701 config.SetInitialStreamFlowControlWindowToSend(
702 kInitialStreamFlowControlWindowForTest);
703 config.SetInitialSessionFlowControlWindowToSend(
704 kInitialSessionFlowControlWindowForTest);
[email protected]b064310782013-05-30 21:12:17705 return config;
706}
707
rtennetia2ea9162015-05-15 19:26:44708QuicConfig DefaultQuicConfigStatelessRejects() {
709 QuicConfig config = DefaultQuicConfig();
710 QuicTagVector copt;
711 copt.push_back(kSREJ);
712 config.SetConnectionOptionsToSend(copt);
713 return config;
714}
715
[email protected]4d640792013-12-18 22:21:08716QuicVersionVector SupportedVersions(QuicVersion version) {
717 QuicVersionVector versions;
718 versions.push_back(version);
719 return versions;
720}
721
rtennetibe635732014-10-02 22:51:42722TestWriterFactory::TestWriterFactory() : current_writer_(nullptr) {}
[email protected]6d515822014-08-22 01:58:06723TestWriterFactory::~TestWriterFactory() {}
724
rchc99f380c2015-03-26 19:50:56725QuicPacketWriter* TestWriterFactory::Create(QuicPacketWriter* writer,
[email protected]6d515822014-08-22 01:58:06726 QuicConnection* connection) {
727 return new PerConnectionPacketWriter(this, writer, connection);
728}
729
730void TestWriterFactory::OnPacketSent(WriteResult result) {
rtennetibe635732014-10-02 22:51:42731 if (current_writer_ != nullptr && result.status == WRITE_STATUS_ERROR) {
[email protected]ca4e0d92014-08-22 16:33:22732 current_writer_->connection()->OnWriteError(result.error_code);
rtennetibe635732014-10-02 22:51:42733 current_writer_ = nullptr;
[email protected]6d515822014-08-22 01:58:06734 }
735}
736
737void TestWriterFactory::Unregister(PerConnectionPacketWriter* writer) {
738 if (current_writer_ == writer) {
rtennetibe635732014-10-02 22:51:42739 current_writer_ = nullptr;
[email protected]6d515822014-08-22 01:58:06740 }
741}
742
743TestWriterFactory::PerConnectionPacketWriter::PerConnectionPacketWriter(
744 TestWriterFactory* factory,
rchc99f380c2015-03-26 19:50:56745 QuicPacketWriter* writer,
[email protected]6d515822014-08-22 01:58:06746 QuicConnection* connection)
rjshaded5ced072015-12-18 19:26:02747 : QuicPerConnectionPacketWriter(writer, connection), factory_(factory) {}
[email protected]6d515822014-08-22 01:58:06748
749TestWriterFactory::PerConnectionPacketWriter::~PerConnectionPacketWriter() {
750 factory_->Unregister(this);
751}
752
753WriteResult TestWriterFactory::PerConnectionPacketWriter::WritePacket(
754 const char* buffer,
755 size_t buf_len,
756 const IPAddressNumber& self_address,
757 const IPEndPoint& peer_address) {
rtennetibe635732014-10-02 22:51:42758 // A DCHECK(factory_current_writer_ == nullptr) would be wrong here -- this
759 // class may be used in a setting where connection()->OnPacketSent() is called
760 // in a different way, so TestWriterFactory::OnPacketSent might never be
761 // called.
[email protected]6d515822014-08-22 01:58:06762 factory_->current_writer_ = this;
rtennetia2ea9162015-05-15 19:26:44763 return tools::QuicPerConnectionPacketWriter::WritePacket(
764 buffer, buf_len, self_address, peer_address);
[email protected]6d515822014-08-22 01:58:06765}
766
rtenneti021e8822015-10-18 23:59:57767MockQuicConnectionDebugVisitor::MockQuicConnectionDebugVisitor() {}
rtenneti95293802015-03-27 18:59:23768
rtenneti021e8822015-10-18 23:59:57769MockQuicConnectionDebugVisitor::~MockQuicConnectionDebugVisitor() {}
rtenneti95293802015-03-27 18:59:23770
fayanga31a74b2015-12-28 17:27:14771MockReceivedPacketManager::MockReceivedPacketManager(QuicConnectionStats* stats)
772 : QuicReceivedPacketManager(stats) {}
773
774MockReceivedPacketManager::~MockReceivedPacketManager() {}
775
rtennetid39bd762015-06-12 01:05:52776void CreateClientSessionForTest(QuicServerId server_id,
777 bool supports_stateless_rejects,
778 QuicTime::Delta connection_start_time,
zhongyib8677022015-12-01 05:51:30779 QuicVersionVector supported_versions,
rch99b644c2015-11-04 05:25:28780 MockConnectionHelper* helper,
rtennetid39bd762015-06-12 01:05:52781 QuicCryptoClientConfig* crypto_client_config,
782 PacketSavingConnection** client_connection,
rtennetib865eb82015-06-17 20:21:46783 TestQuicSpdyClientSession** client_session) {
rtennetia2ea9162015-05-15 19:26:44784 CHECK(crypto_client_config);
785 CHECK(client_connection);
786 CHECK(client_session);
rtennetia2ea9162015-05-15 19:26:44787 CHECK(!connection_start_time.IsZero())
788 << "Connections must start at non-zero times, otherwise the "
789 << "strike-register will be unhappy.";
790
791 QuicConfig config = supports_stateless_rejects
792 ? DefaultQuicConfigStatelessRejects()
793 : DefaultQuicConfig();
zhongyib8677022015-12-01 05:51:30794 *client_connection = new PacketSavingConnection(
795 helper, Perspective::IS_CLIENT, supported_versions);
rtennetib865eb82015-06-17 20:21:46796 *client_session = new TestQuicSpdyClientSession(
797 *client_connection, config, server_id, crypto_client_config);
rtennetia2ea9162015-05-15 19:26:44798 (*client_connection)->AdvanceTime(connection_start_time);
799}
800
rtennetid39bd762015-06-12 01:05:52801void CreateServerSessionForTest(QuicServerId server_id,
802 QuicTime::Delta connection_start_time,
zhongyib8677022015-12-01 05:51:30803 QuicVersionVector supported_versions,
rch99b644c2015-11-04 05:25:28804 MockConnectionHelper* helper,
rtennetid39bd762015-06-12 01:05:52805 QuicCryptoServerConfig* server_crypto_config,
806 PacketSavingConnection** server_connection,
rtennetib865eb82015-06-17 20:21:46807 TestQuicSpdyServerSession** server_session) {
rtennetia2ea9162015-05-15 19:26:44808 CHECK(server_crypto_config);
809 CHECK(server_connection);
810 CHECK(server_session);
rtennetia2ea9162015-05-15 19:26:44811 CHECK(!connection_start_time.IsZero())
812 << "Connections must start at non-zero times, otherwise the "
813 << "strike-register will be unhappy.";
814
zhongyib8677022015-12-01 05:51:30815 *server_connection = new PacketSavingConnection(
816 helper, Perspective::IS_SERVER, supported_versions);
rtennetib865eb82015-06-17 20:21:46817 *server_session = new TestQuicSpdyServerSession(
rtennetid39bd762015-06-12 01:05:52818 *server_connection, DefaultQuicConfig(), server_crypto_config);
rtennetia2ea9162015-05-15 19:26:44819
820 // We advance the clock initially because the default time is zero and the
Avi Drissman13fc8932015-12-20 04:40:46821 // strike register worries that we've just overflowed a uint32_t time.
rtennetia2ea9162015-05-15 19:26:44822 (*server_connection)->AdvanceTime(connection_start_time);
823}
824
ckrasic99850b32015-10-16 21:15:58825QuicStreamId QuicClientDataStreamId(int i) {
826 return kClientDataStreamId1 + 2 * i;
827}
828
[email protected]8b37a092012-10-18 21:53:49829} // namespace test
[email protected]8b37a092012-10-18 21:53:49830} // namespace net