blob: c781b23c5e939b50c0f824a1d07a9b83edb9c208 [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"
[email protected]a57e0272013-04-26 07:31:4716#include "net/quic/quic_framer.h"
[email protected]5351cc4b2013-03-03 07:22:4117#include "net/quic/quic_packet_creator.h"
[email protected]79d13dcb2014-02-05 07:23:1318#include "net/quic/quic_utils.h"
[email protected]cbd731e2013-10-24 00:20:3919#include "net/quic/test_tools/quic_connection_peer.h"
[email protected]c244c5a12013-05-07 20:55:0420#include "net/spdy/spdy_frame_builder.h"
[email protected]8b37a092012-10-18 21:53:4921
[email protected]c244c5a12013-05-07 20:55:0422using base::StringPiece;
[email protected]8b37a092012-10-18 21:53:4923using std::max;
24using std::min;
25using std::string;
[email protected]64c12232014-03-26 05:43:5926using testing::AnyNumber;
[email protected]bc356fe2014-06-19 11:14:1427using testing::_;
[email protected]8b37a092012-10-18 21:53:4928
29namespace net {
30namespace test {
[email protected]965dbe62013-08-09 21:34:3131namespace {
32
33// No-op alarm implementation used by MockHelper.
34class TestAlarm : public QuicAlarm {
35 public:
36 explicit TestAlarm(QuicAlarm::Delegate* delegate)
37 : QuicAlarm(delegate) {
38 }
39
40 virtual void SetImpl() OVERRIDE {}
41 virtual void CancelImpl() OVERRIDE {}
42};
43
44} // namespace
[email protected]8b37a092012-10-18 21:53:4945
[email protected]310d37b2014-08-02 06:15:3746QuicAckFrame MakeAckFrame(QuicPacketSequenceNumber largest_observed) {
[email protected]fb35b0a2014-04-15 21:06:4947 QuicAckFrame ack;
[email protected]310d37b2014-08-02 06:15:3748 ack.largest_observed = largest_observed;
49 ack.entropy_hash = 0;
[email protected]fb35b0a2014-04-15 21:06:4950 return ack;
51}
52
[email protected]aa7e4ef2014-05-28 03:53:1553QuicAckFrame MakeAckFrameWithNackRanges(
54 size_t num_nack_ranges, QuicPacketSequenceNumber least_unacked) {
[email protected]310d37b2014-08-02 06:15:3755 QuicAckFrame ack = MakeAckFrame(2 * num_nack_ranges + least_unacked);
[email protected]aa7e4ef2014-05-28 03:53:1556 // Add enough missing packets to get num_nack_ranges nack ranges.
57 for (QuicPacketSequenceNumber i = 1; i < 2 * num_nack_ranges; i += 2) {
[email protected]310d37b2014-08-02 06:15:3758 ack.missing_packets.insert(least_unacked + i);
[email protected]aa7e4ef2014-05-28 03:53:1559 }
60 return ack;
61}
62
[email protected]9cda5fd2014-06-03 10:20:2863SerializedPacket BuildUnsizedDataPacket(QuicFramer* framer,
64 const QuicPacketHeader& header,
65 const QuicFrames& frames) {
66 const size_t max_plaintext_size = framer->GetMaxPlaintextSize(kMaxPacketSize);
67 size_t packet_size = GetPacketHeaderSize(header);
68 for (size_t i = 0; i < frames.size(); ++i) {
69 DCHECK_LE(packet_size, max_plaintext_size);
70 bool first_frame = i == 0;
71 bool last_frame = i == frames.size() - 1;
72 const size_t frame_size = framer->GetSerializedFrameLength(
73 frames[i], max_plaintext_size - packet_size, first_frame, last_frame,
74 header.is_in_fec_group,
75 header.public_header.sequence_number_length);
76 DCHECK(frame_size);
77 packet_size += frame_size;
78 }
79 return framer->BuildDataPacket(header, frames, packet_size);
80}
81
[email protected]a5b98172014-06-18 07:01:5982uint64 SimpleRandom::RandUint64() {
83 unsigned char hash[base::kSHA1Length];
84 base::SHA1HashBytes(reinterpret_cast<unsigned char*>(&seed_), sizeof(seed_),
85 hash);
86 memcpy(&seed_, hash, sizeof(seed_));
87 return seed_;
88}
89
[email protected]8b37a092012-10-18 21:53:4990MockFramerVisitor::MockFramerVisitor() {
91 // By default, we want to accept packets.
[email protected]14e8106c2013-03-14 16:25:3392 ON_CALL(*this, OnProtocolVersionMismatch(_))
93 .WillByDefault(testing::Return(false));
94
95 // By default, we want to accept packets.
[email protected]ec86d5462013-11-17 16:04:4996 ON_CALL(*this, OnUnauthenticatedHeader(_))
97 .WillByDefault(testing::Return(true));
98
[email protected]066d8182014-01-04 02:02:4599 ON_CALL(*this, OnUnauthenticatedPublicHeader(_))
100 .WillByDefault(testing::Return(true));
101
[email protected]cff7b7b2013-01-11 08:49:07102 ON_CALL(*this, OnPacketHeader(_))
[email protected]8b37a092012-10-18 21:53:49103 .WillByDefault(testing::Return(true));
[email protected]a57e0272013-04-26 07:31:47104
105 ON_CALL(*this, OnStreamFrame(_))
106 .WillByDefault(testing::Return(true));
107
108 ON_CALL(*this, OnAckFrame(_))
109 .WillByDefault(testing::Return(true));
110
111 ON_CALL(*this, OnCongestionFeedbackFrame(_))
112 .WillByDefault(testing::Return(true));
113
[email protected]93dd91f2014-02-27 00:09:03114 ON_CALL(*this, OnStopWaitingFrame(_))
115 .WillByDefault(testing::Return(true));
116
[email protected]d8c522112014-04-23 09:23:25117 ON_CALL(*this, OnPingFrame(_))
118 .WillByDefault(testing::Return(true));
119
[email protected]a57e0272013-04-26 07:31:47120 ON_CALL(*this, OnRstStreamFrame(_))
121 .WillByDefault(testing::Return(true));
122
123 ON_CALL(*this, OnConnectionCloseFrame(_))
124 .WillByDefault(testing::Return(true));
125
126 ON_CALL(*this, OnGoAwayFrame(_))
127 .WillByDefault(testing::Return(true));
[email protected]8b37a092012-10-18 21:53:49128}
129
[email protected]044ac2b2012-11-13 21:41:06130MockFramerVisitor::~MockFramerVisitor() {
131}
[email protected]8b37a092012-10-18 21:53:49132
[email protected]48878092013-07-26 14:51:56133bool NoOpFramerVisitor::OnProtocolVersionMismatch(QuicVersion version) {
[email protected]14e8106c2013-03-14 16:25:33134 return false;
135}
136
[email protected]066d8182014-01-04 02:02:45137bool NoOpFramerVisitor::OnUnauthenticatedPublicHeader(
138 const QuicPacketPublicHeader& header) {
139 return true;
140}
141
[email protected]ec86d5462013-11-17 16:04:49142bool NoOpFramerVisitor::OnUnauthenticatedHeader(
143 const QuicPacketHeader& header) {
144 return true;
145}
146
[email protected]8b37a092012-10-18 21:53:49147bool NoOpFramerVisitor::OnPacketHeader(const QuicPacketHeader& header) {
148 return true;
149}
150
[email protected]a57e0272013-04-26 07:31:47151bool NoOpFramerVisitor::OnStreamFrame(const QuicStreamFrame& frame) {
152 return true;
153}
154
155bool NoOpFramerVisitor::OnAckFrame(const QuicAckFrame& frame) {
156 return true;
157}
158
159bool NoOpFramerVisitor::OnCongestionFeedbackFrame(
160 const QuicCongestionFeedbackFrame& frame) {
161 return true;
162}
163
[email protected]93dd91f2014-02-27 00:09:03164bool NoOpFramerVisitor::OnStopWaitingFrame(
165 const QuicStopWaitingFrame& frame) {
166 return true;
167}
168
[email protected]d8c522112014-04-23 09:23:25169bool NoOpFramerVisitor::OnPingFrame(const QuicPingFrame& frame) {
170 return true;
171}
172
[email protected]a57e0272013-04-26 07:31:47173bool NoOpFramerVisitor::OnRstStreamFrame(
174 const QuicRstStreamFrame& frame) {
175 return true;
176}
177
178bool NoOpFramerVisitor::OnConnectionCloseFrame(
179 const QuicConnectionCloseFrame& frame) {
180 return true;
181}
182
183bool NoOpFramerVisitor::OnGoAwayFrame(const QuicGoAwayFrame& frame) {
184 return true;
185}
186
[email protected]cb23a922014-02-20 17:42:38187bool NoOpFramerVisitor::OnWindowUpdateFrame(
188 const QuicWindowUpdateFrame& frame) {
189 return true;
190}
191
192bool NoOpFramerVisitor::OnBlockedFrame(const QuicBlockedFrame& frame) {
193 return true;
194}
195
[email protected]8d659e22013-01-19 04:26:10196MockConnectionVisitor::MockConnectionVisitor() {
197}
198
199MockConnectionVisitor::~MockConnectionVisitor() {
200}
201
[email protected]9c0b1352012-11-04 00:03:27202MockHelper::MockHelper() {
203}
204
205MockHelper::~MockHelper() {
206}
207
[email protected]97693d12012-11-16 16:05:00208const QuicClock* MockHelper::GetClock() const {
[email protected]9c0b1352012-11-04 00:03:27209 return &clock_;
210}
211
[email protected]9558c5d32012-12-22 00:08:14212QuicRandom* MockHelper::GetRandomGenerator() {
213 return &random_generator_;
214}
215
[email protected]965dbe62013-08-09 21:34:31216QuicAlarm* MockHelper::CreateAlarm(QuicAlarm::Delegate* delegate) {
217 return new TestAlarm(delegate);
218}
219
[email protected]fe053f92013-04-23 20:18:55220void MockHelper::AdvanceTime(QuicTime::Delta delta) {
221 clock_.AdvanceTime(delta);
222}
223
[email protected]c05a6d222013-12-16 19:42:03224MockConnection::MockConnection(bool is_server)
[email protected]3aa9ca72014-02-27 19:39:43225 : QuicConnection(kTestConnectionId,
[email protected]300ccd52014-01-25 08:00:19226 IPEndPoint(TestPeerIPAddress(), kTestPort),
[email protected]c05a6d222013-12-16 19:42:03227 new testing::NiceMock<MockHelper>(),
[email protected]cbd731e2013-10-24 00:20:39228 new testing::NiceMock<MockPacketWriter>(),
[email protected]66cd2d62014-08-01 18:42:39229 true /* owns_writer */,
[email protected]ce7bb1412014-05-17 15:51:33230 is_server, QuicSupportedVersions()),
[email protected]c05a6d222013-12-16 19:42:03231 helper_(helper()) {
232}
233
234MockConnection::MockConnection(IPEndPoint address,
235 bool is_server)
[email protected]3aa9ca72014-02-27 19:39:43236 : QuicConnection(kTestConnectionId, address,
[email protected]c05a6d222013-12-16 19:42:03237 new testing::NiceMock<MockHelper>(),
238 new testing::NiceMock<MockPacketWriter>(),
[email protected]66cd2d62014-08-01 18:42:39239 true /* owns_writer */,
[email protected]ce7bb1412014-05-17 15:51:33240 is_server, QuicSupportedVersions()),
[email protected]2cfc6bb82013-10-27 03:40:44241 helper_(helper()) {
[email protected]044ac2b2012-11-13 21:41:06242}
243
[email protected]3aa9ca72014-02-27 19:39:43244MockConnection::MockConnection(QuicConnectionId connection_id,
[email protected]14e8106c2013-03-14 16:25:33245 bool is_server)
[email protected]3aa9ca72014-02-27 19:39:43246 : QuicConnection(connection_id,
247 IPEndPoint(TestPeerIPAddress(), kTestPort),
[email protected]c05a6d222013-12-16 19:42:03248 new testing::NiceMock<MockHelper>(),
249 new testing::NiceMock<MockPacketWriter>(),
[email protected]66cd2d62014-08-01 18:42:39250 true /* owns_writer */,
[email protected]ce7bb1412014-05-17 15:51:33251 is_server, QuicSupportedVersions()),
[email protected]c05a6d222013-12-16 19:42:03252 helper_(helper()) {
[email protected]872edd9e2013-01-16 08:51:15253}
254
[email protected]4d640792013-12-18 22:21:08255MockConnection::MockConnection(bool is_server,
256 const QuicVersionVector& supported_versions)
[email protected]3aa9ca72014-02-27 19:39:43257 : QuicConnection(kTestConnectionId,
[email protected]300ccd52014-01-25 08:00:19258 IPEndPoint(TestPeerIPAddress(), kTestPort),
[email protected]4d640792013-12-18 22:21:08259 new testing::NiceMock<MockHelper>(),
260 new testing::NiceMock<MockPacketWriter>(),
[email protected]66cd2d62014-08-01 18:42:39261 true /* owns_writer */,
[email protected]ce7bb1412014-05-17 15:51:33262 is_server, supported_versions),
[email protected]4d640792013-12-18 22:21:08263 helper_(helper()) {
264}
265
[email protected]044ac2b2012-11-13 21:41:06266MockConnection::~MockConnection() {
267}
268
[email protected]fe053f92013-04-23 20:18:55269void MockConnection::AdvanceTime(QuicTime::Delta delta) {
[email protected]fe053f92013-04-23 20:18:55270 static_cast<MockHelper*>(helper())->AdvanceTime(delta);
271}
272
[email protected]c05a6d222013-12-16 19:42:03273PacketSavingConnection::PacketSavingConnection(bool is_server)
274 : MockConnection(is_server) {
[email protected]044ac2b2012-11-13 21:41:06275}
276
[email protected]4d640792013-12-18 22:21:08277PacketSavingConnection::PacketSavingConnection(
278 bool is_server,
279 const QuicVersionVector& supported_versions)
280 : MockConnection(is_server, supported_versions) {
281}
282
[email protected]044ac2b2012-11-13 21:41:06283PacketSavingConnection::~PacketSavingConnection() {
[email protected]701bc892013-01-17 04:51:54284 STLDeleteElements(&packets_);
[email protected]2532de12013-05-09 12:29:33285 STLDeleteElements(&encrypted_packets_);
[email protected]044ac2b2012-11-13 21:41:06286}
287
[email protected]fee17f72013-02-03 07:47:41288bool PacketSavingConnection::SendOrQueuePacket(
[email protected]8ba81212013-05-03 13:11:48289 EncryptionLevel level,
[email protected]ec86d5462013-11-17 16:04:49290 const SerializedPacket& packet,
291 TransmissionType transmission_type) {
292 packets_.push_back(packet.packet);
[email protected]c5e1aca2014-01-30 04:03:04293 QuicEncryptedPacket* encrypted = QuicConnectionPeer::GetFramer(this)->
294 EncryptPacket(level, packet.sequence_number, *packet.packet);
[email protected]2532de12013-05-09 12:29:33295 encrypted_packets_.push_back(encrypted);
[email protected]044ac2b2012-11-13 21:41:06296 return true;
297}
298
[email protected]c05a6d222013-12-16 19:42:03299MockSession::MockSession(QuicConnection* connection)
[email protected]a5b98172014-06-18 07:01:59300 : QuicSession(connection, DefaultQuicConfig()) {
[email protected]ccb34212014-07-18 09:27:50301 InitializeSession();
[email protected]bbb10072014-06-13 07:41:59302 ON_CALL(*this, WritevData(_, _, _, _, _, _))
[email protected]cff7b7b2013-01-11 08:49:07303 .WillByDefault(testing::Return(QuicConsumedData(0, false)));
[email protected]044ac2b2012-11-13 21:41:06304}
305
306MockSession::~MockSession() {
307}
308
[email protected]ce7bb1412014-05-17 15:51:33309TestSession::TestSession(QuicConnection* connection, const QuicConfig& config)
[email protected]a5b98172014-06-18 07:01:59310 : QuicSession(connection, config),
[email protected]ccb34212014-07-18 09:27:50311 crypto_stream_(NULL) {
312 InitializeSession();
313}
[email protected]2532de12013-05-09 12:29:33314
[email protected]b064310782013-05-30 21:12:17315TestSession::~TestSession() {}
[email protected]2532de12013-05-09 12:29:33316
317void TestSession::SetCryptoStream(QuicCryptoStream* stream) {
318 crypto_stream_ = stream;
319}
320
321QuicCryptoStream* TestSession::GetCryptoStream() {
322 return crypto_stream_;
323}
324
[email protected]90f62f092014-03-24 02:41:23325TestClientSession::TestClientSession(QuicConnection* connection,
326 const QuicConfig& config)
[email protected]ccb34212014-07-18 09:27:50327 : QuicClientSessionBase(connection, config),
[email protected]90f62f092014-03-24 02:41:23328 crypto_stream_(NULL) {
[email protected]ccb34212014-07-18 09:27:50329 EXPECT_CALL(*this, OnProofValid(_)).Times(AnyNumber());
330 InitializeSession();
[email protected]90f62f092014-03-24 02:41:23331}
332
333TestClientSession::~TestClientSession() {}
334
335void TestClientSession::SetCryptoStream(QuicCryptoStream* stream) {
336 crypto_stream_ = stream;
337}
338
339QuicCryptoStream* TestClientSession::GetCryptoStream() {
340 return crypto_stream_;
341}
342
[email protected]cbd731e2013-10-24 00:20:39343MockPacketWriter::MockPacketWriter() {
344}
345
346MockPacketWriter::~MockPacketWriter() {
347}
348
[email protected]fee17f72013-02-03 07:47:41349MockSendAlgorithm::MockSendAlgorithm() {
[email protected]8d659e22013-01-19 04:26:10350}
351
[email protected]fee17f72013-02-03 07:47:41352MockSendAlgorithm::~MockSendAlgorithm() {
[email protected]8d659e22013-01-19 04:26:10353}
354
[email protected]3aa9ca72014-02-27 19:39:43355MockLossAlgorithm::MockLossAlgorithm() {
356}
357
358MockLossAlgorithm::~MockLossAlgorithm() {
359}
360
[email protected]97cf3022013-09-05 14:30:16361MockAckNotifierDelegate::MockAckNotifierDelegate() {
362}
363
364MockAckNotifierDelegate::~MockAckNotifierDelegate() {
365}
366
[email protected]a692ad9d2014-07-18 21:35:24367MockNetworkChangeVisitor::MockNetworkChangeVisitor() {
368}
369
370MockNetworkChangeVisitor::~MockNetworkChangeVisitor() {
371}
372
[email protected]8b37a092012-10-18 21:53:49373namespace {
374
375string HexDumpWithMarks(const char* data, int length,
376 const bool* marks, int mark_length) {
377 static const char kHexChars[] = "0123456789abcdef";
378 static const int kColumns = 4;
379
380 const int kSizeLimit = 1024;
381 if (length > kSizeLimit || mark_length > kSizeLimit) {
382 LOG(ERROR) << "Only dumping first " << kSizeLimit << " bytes.";
383 length = min(length, kSizeLimit);
384 mark_length = min(mark_length, kSizeLimit);
385 }
386
387 string hex;
388 for (const char* row = data; length > 0;
389 row += kColumns, length -= kColumns) {
390 for (const char *p = row; p < row + 4; ++p) {
391 if (p < row + length) {
392 const bool mark =
393 (marks && (p - data) < mark_length && marks[p - data]);
394 hex += mark ? '*' : ' ';
395 hex += kHexChars[(*p & 0xf0) >> 4];
396 hex += kHexChars[*p & 0x0f];
397 hex += mark ? '*' : ' ';
398 } else {
399 hex += " ";
400 }
401 }
402 hex = hex + " ";
403
404 for (const char *p = row; p < row + 4 && p < row + length; ++p)
405 hex += (*p >= 0x20 && *p <= 0x7f) ? (*p) : '.';
406
407 hex = hex + '\n';
408 }
409 return hex;
410}
411
412} // namespace
413
[email protected]300ccd52014-01-25 08:00:19414IPAddressNumber TestPeerIPAddress() { return Loopback4(); }
415
[email protected]b007e632013-10-28 08:39:25416QuicVersion QuicVersionMax() { return QuicSupportedVersions().front(); }
417
418QuicVersion QuicVersionMin() { return QuicSupportedVersions().back(); }
419
[email protected]c05a6d222013-12-16 19:42:03420IPAddressNumber Loopback4() {
[email protected]300ccd52014-01-25 08:00:19421 IPAddressNumber addr;
422 CHECK(ParseIPLiteralToNumber("127.0.0.1", &addr));
[email protected]c05a6d222013-12-16 19:42:03423 return addr;
424}
425
[email protected]730b35d72014-06-05 03:23:22426IPAddressNumber Loopback6() {
427 IPAddressNumber addr;
428 CHECK(ParseIPLiteralToNumber("::1", &addr));
429 return addr;
430}
431
[email protected]9bb57c72014-03-31 20:36:04432void GenerateBody(string* body, int length) {
433 body->clear();
434 body->reserve(length);
435 for (int i = 0; i < length; ++i) {
436 body->append(1, static_cast<char>(32 + i % (126 - 32)));
437 }
438}
439
[email protected]ffc34bf2014-03-07 02:42:02440QuicEncryptedPacket* ConstructEncryptedPacket(
441 QuicConnectionId connection_id,
442 bool version_flag,
443 bool reset_flag,
444 QuicPacketSequenceNumber sequence_number,
445 const string& data) {
446 QuicPacketHeader header;
447 header.public_header.connection_id = connection_id;
448 header.public_header.connection_id_length = PACKET_8BYTE_CONNECTION_ID;
449 header.public_header.version_flag = version_flag;
450 header.public_header.reset_flag = reset_flag;
451 header.public_header.sequence_number_length = PACKET_6BYTE_SEQUENCE_NUMBER;
452 header.packet_sequence_number = sequence_number;
453 header.entropy_flag = false;
454 header.entropy_hash = 0;
455 header.fec_flag = false;
456 header.is_in_fec_group = NOT_IN_FEC_GROUP;
457 header.fec_group = 0;
458 QuicStreamFrame stream_frame(1, false, 0, MakeIOVector(data));
459 QuicFrame frame(&stream_frame);
460 QuicFrames frames;
461 frames.push_back(frame);
462 QuicFramer framer(QuicSupportedVersions(), QuicTime::Zero(), false);
463 scoped_ptr<QuicPacket> packet(
[email protected]9cda5fd2014-06-03 10:20:28464 BuildUnsizedDataPacket(&framer, header, frames).packet);
[email protected]ffc34bf2014-03-07 02:42:02465 EXPECT_TRUE(packet != NULL);
466 QuicEncryptedPacket* encrypted = framer.EncryptPacket(ENCRYPTION_NONE,
467 sequence_number,
468 *packet);
469 EXPECT_TRUE(encrypted != NULL);
470 return encrypted;
471}
472
[email protected]8b37a092012-10-18 21:53:49473void CompareCharArraysWithHexError(
474 const string& description,
475 const char* actual,
476 const int actual_len,
477 const char* expected,
478 const int expected_len) {
[email protected]b007e632013-10-28 08:39:25479 EXPECT_EQ(actual_len, expected_len);
[email protected]8b37a092012-10-18 21:53:49480 const int min_len = min(actual_len, expected_len);
481 const int max_len = max(actual_len, expected_len);
[email protected]4356f0f2013-04-07 00:58:17482 scoped_ptr<bool[]> marks(new bool[max_len]);
[email protected]8b37a092012-10-18 21:53:49483 bool identical = (actual_len == expected_len);
484 for (int i = 0; i < min_len; ++i) {
485 if (actual[i] != expected[i]) {
486 marks[i] = true;
487 identical = false;
488 } else {
489 marks[i] = false;
490 }
491 }
492 for (int i = min_len; i < max_len; ++i) {
493 marks[i] = true;
494 }
495 if (identical) return;
496 ADD_FAILURE()
497 << "Description:\n"
498 << description
499 << "\n\nExpected:\n"
500 << HexDumpWithMarks(expected, expected_len, marks.get(), max_len)
501 << "\nActual:\n"
502 << HexDumpWithMarks(actual, actual_len, marks.get(), max_len);
503}
504
[email protected]b12764d2013-12-02 22:28:30505bool DecodeHexString(const base::StringPiece& hex, std::string* bytes) {
506 bytes->clear();
507 if (hex.empty())
508 return true;
509 std::vector<uint8> v;
510 if (!base::HexStringToBytes(hex.as_string(), &v))
511 return false;
512 if (!v.empty())
513 bytes->assign(reinterpret_cast<const char*>(&v[0]), v.size());
514 return true;
515}
516
[email protected]d3d15bf2013-01-30 02:51:54517static QuicPacket* ConstructPacketFromHandshakeMessage(
[email protected]3aa9ca72014-02-27 19:39:43518 QuicConnectionId connection_id,
[email protected]14e8106c2013-03-14 16:25:33519 const CryptoHandshakeMessage& message,
520 bool should_include_version) {
[email protected]8b37a092012-10-18 21:53:49521 CryptoFramer crypto_framer;
[email protected]dc2cc742012-10-21 13:56:13522 scoped_ptr<QuicData> data(crypto_framer.ConstructHandshakeMessage(message));
[email protected]b007e632013-10-28 08:39:25523 QuicFramer quic_framer(QuicSupportedVersions(), QuicTime::Zero(), false);
[email protected]8b37a092012-10-18 21:53:49524
525 QuicPacketHeader header;
[email protected]3aa9ca72014-02-27 19:39:43526 header.public_header.connection_id = connection_id;
[email protected]9db443912013-02-25 05:27:03527 header.public_header.reset_flag = false;
[email protected]14e8106c2013-03-14 16:25:33528 header.public_header.version_flag = should_include_version;
[email protected]8b37a092012-10-18 21:53:49529 header.packet_sequence_number = 1;
[email protected]9db443912013-02-25 05:27:03530 header.entropy_flag = false;
531 header.entropy_hash = 0;
532 header.fec_flag = false;
[email protected]8b37a092012-10-18 21:53:49533 header.fec_group = 0;
534
[email protected]be24ab22012-10-22 03:01:52535 QuicStreamFrame stream_frame(kCryptoStreamId, false, 0,
[email protected]5dafdb62013-11-14 01:24:26536 MakeIOVector(data->AsStringPiece()));
[email protected]8b37a092012-10-18 21:53:49537
[email protected]be24ab22012-10-22 03:01:52538 QuicFrame frame(&stream_frame);
539 QuicFrames frames;
540 frames.push_back(frame);
[email protected]9cda5fd2014-06-03 10:20:28541 return BuildUnsizedDataPacket(&quic_framer, header, frames).packet;
[email protected]8b37a092012-10-18 21:53:49542}
543
[email protected]3aa9ca72014-02-27 19:39:43544QuicPacket* ConstructHandshakePacket(QuicConnectionId connection_id,
545 QuicTag tag) {
[email protected]d3d15bf2013-01-30 02:51:54546 CryptoHandshakeMessage message;
[email protected]ccc66e8a2013-03-26 08:26:14547 message.set_tag(tag);
[email protected]3aa9ca72014-02-27 19:39:43548 return ConstructPacketFromHandshakeMessage(connection_id, message, false);
[email protected]d3d15bf2013-01-30 02:51:54549}
550
[email protected]ea825e02013-08-21 18:12:45551size_t GetPacketLengthForOneStream(
552 QuicVersion version,
553 bool include_version,
554 QuicSequenceNumberLength sequence_number_length,
555 InFecGroup is_in_fec_group,
556 size_t* payload_length) {
[email protected]f62262b2013-07-05 20:57:30557 *payload_length = 1;
558 const size_t stream_length =
[email protected]5dafdb62013-11-14 01:24:26559 NullEncrypter().GetCiphertextSize(*payload_length) +
[email protected]b064310782013-05-30 21:12:17560 QuicPacketCreator::StreamFramePacketOverhead(
[email protected]310d37b2014-08-02 06:15:37561 PACKET_8BYTE_CONNECTION_ID, include_version,
[email protected]aa7e4ef2014-05-28 03:53:15562 sequence_number_length, 0u, is_in_fec_group);
[email protected]5dafdb62013-11-14 01:24:26563 const size_t ack_length = NullEncrypter().GetCiphertextSize(
[email protected]8e01c062013-10-31 07:35:31564 QuicFramer::GetMinAckFrameSize(
[email protected]310d37b2014-08-02 06:15:37565 sequence_number_length, PACKET_1BYTE_SEQUENCE_NUMBER)) +
[email protected]3aa9ca72014-02-27 19:39:43566 GetPacketHeaderSize(PACKET_8BYTE_CONNECTION_ID, include_version,
[email protected]ea825e02013-08-21 18:12:45567 sequence_number_length, is_in_fec_group);
[email protected]f62262b2013-07-05 20:57:30568 if (stream_length < ack_length) {
569 *payload_length = 1 + ack_length - stream_length;
570 }
571
[email protected]5dafdb62013-11-14 01:24:26572 return NullEncrypter().GetCiphertextSize(*payload_length) +
[email protected]f62262b2013-07-05 20:57:30573 QuicPacketCreator::StreamFramePacketOverhead(
[email protected]310d37b2014-08-02 06:15:37574 PACKET_8BYTE_CONNECTION_ID, include_version,
[email protected]aa7e4ef2014-05-28 03:53:15575 sequence_number_length, 0u, is_in_fec_group);
[email protected]5351cc4b2013-03-03 07:22:41576}
577
[email protected]a5b98172014-06-18 07:01:59578TestEntropyCalculator::TestEntropyCalculator() {}
[email protected]8e01c062013-10-31 07:35:31579
[email protected]a5b98172014-06-18 07:01:59580TestEntropyCalculator::~TestEntropyCalculator() {}
[email protected]8e01c062013-10-31 07:35:31581
[email protected]48878092013-07-26 14:51:56582QuicPacketEntropyHash TestEntropyCalculator::EntropyHash(
[email protected]9db443912013-02-25 05:27:03583 QuicPacketSequenceNumber sequence_number) const {
584 return 1u;
585}
586
[email protected]a5b98172014-06-18 07:01:59587MockEntropyCalculator::MockEntropyCalculator() {}
[email protected]8e01c062013-10-31 07:35:31588
[email protected]a5b98172014-06-18 07:01:59589MockEntropyCalculator::~MockEntropyCalculator() {}
[email protected]8e01c062013-10-31 07:35:31590
[email protected]b064310782013-05-30 21:12:17591QuicConfig DefaultQuicConfig() {
592 QuicConfig config;
593 config.SetDefaults();
[email protected]7d561352014-06-20 09:09:21594 config.SetInitialFlowControlWindowToSend(
595 kInitialSessionFlowControlWindowForTest);
596 config.SetInitialStreamFlowControlWindowToSend(
597 kInitialStreamFlowControlWindowForTest);
598 config.SetInitialSessionFlowControlWindowToSend(
599 kInitialSessionFlowControlWindowForTest);
[email protected]b064310782013-05-30 21:12:17600 return config;
601}
602
[email protected]4d640792013-12-18 22:21:08603QuicVersionVector SupportedVersions(QuicVersion version) {
604 QuicVersionVector versions;
605 versions.push_back(version);
606 return versions;
607}
608
[email protected]8b37a092012-10-18 21:53:49609} // namespace test
[email protected]8b37a092012-10-18 21:53:49610} // namespace net