[email protected] | 8b37a09 | 2012-10-18 21:53:49 | [diff] [blame] | 1 | // 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] | 9c0b135 | 2012-11-04 00:03:27 | [diff] [blame] | 6 | |
[email protected] | a5b9817 | 2014-06-18 07:01:59 | [diff] [blame] | 7 | #include "base/sha1.h" |
[email protected] | 701bc89 | 2013-01-17 04:51:54 | [diff] [blame] | 8 | #include "base/stl_util.h" |
[email protected] | b12764d | 2013-12-02 22:28:30 | [diff] [blame] | 9 | #include "base/strings/string_number_conversions.h" |
[email protected] | 8b37a09 | 2012-10-18 21:53:49 | [diff] [blame] | 10 | #include "net/quic/crypto/crypto_framer.h" |
[email protected] | 6f54ab3 | 2013-03-02 17:43:35 | [diff] [blame] | 11 | #include "net/quic/crypto/crypto_handshake.h" |
[email protected] | 872edd9e | 2013-01-16 08:51:15 | [diff] [blame] | 12 | #include "net/quic/crypto/crypto_utils.h" |
[email protected] | 5351cc4b | 2013-03-03 07:22:41 | [diff] [blame] | 13 | #include "net/quic/crypto/null_encrypter.h" |
[email protected] | 4df6984 | 2013-02-27 06:32:16 | [diff] [blame] | 14 | #include "net/quic/crypto/quic_decrypter.h" |
| 15 | #include "net/quic/crypto/quic_encrypter.h" |
[email protected] | a57e027 | 2013-04-26 07:31:47 | [diff] [blame] | 16 | #include "net/quic/quic_framer.h" |
[email protected] | 5351cc4b | 2013-03-03 07:22:41 | [diff] [blame] | 17 | #include "net/quic/quic_packet_creator.h" |
[email protected] | 79d13dcb | 2014-02-05 07:23:13 | [diff] [blame] | 18 | #include "net/quic/quic_utils.h" |
[email protected] | cbd731e | 2013-10-24 00:20:39 | [diff] [blame] | 19 | #include "net/quic/test_tools/quic_connection_peer.h" |
[email protected] | c244c5a1 | 2013-05-07 20:55:04 | [diff] [blame] | 20 | #include "net/spdy/spdy_frame_builder.h" |
[email protected] | 8b37a09 | 2012-10-18 21:53:49 | [diff] [blame] | 21 | |
[email protected] | c244c5a1 | 2013-05-07 20:55:04 | [diff] [blame] | 22 | using base::StringPiece; |
[email protected] | 8b37a09 | 2012-10-18 21:53:49 | [diff] [blame] | 23 | using std::max; |
| 24 | using std::min; |
| 25 | using std::string; |
[email protected] | 64c1223 | 2014-03-26 05:43:59 | [diff] [blame] | 26 | using testing::AnyNumber; |
[email protected] | bc356fe | 2014-06-19 11:14:14 | [diff] [blame] | 27 | using testing::_; |
[email protected] | 8b37a09 | 2012-10-18 21:53:49 | [diff] [blame] | 28 | |
| 29 | namespace net { |
| 30 | namespace test { |
[email protected] | 965dbe6 | 2013-08-09 21:34:31 | [diff] [blame] | 31 | namespace { |
| 32 | |
| 33 | // No-op alarm implementation used by MockHelper. |
| 34 | class 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] | 8b37a09 | 2012-10-18 21:53:49 | [diff] [blame] | 45 | |
[email protected] | 310d37b | 2014-08-02 06:15:37 | [diff] [blame^] | 46 | QuicAckFrame MakeAckFrame(QuicPacketSequenceNumber largest_observed) { |
[email protected] | fb35b0a | 2014-04-15 21:06:49 | [diff] [blame] | 47 | QuicAckFrame ack; |
[email protected] | 310d37b | 2014-08-02 06:15:37 | [diff] [blame^] | 48 | ack.largest_observed = largest_observed; |
| 49 | ack.entropy_hash = 0; |
[email protected] | fb35b0a | 2014-04-15 21:06:49 | [diff] [blame] | 50 | return ack; |
| 51 | } |
| 52 | |
[email protected] | aa7e4ef | 2014-05-28 03:53:15 | [diff] [blame] | 53 | QuicAckFrame MakeAckFrameWithNackRanges( |
| 54 | size_t num_nack_ranges, QuicPacketSequenceNumber least_unacked) { |
[email protected] | 310d37b | 2014-08-02 06:15:37 | [diff] [blame^] | 55 | QuicAckFrame ack = MakeAckFrame(2 * num_nack_ranges + least_unacked); |
[email protected] | aa7e4ef | 2014-05-28 03:53:15 | [diff] [blame] | 56 | // 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] | 310d37b | 2014-08-02 06:15:37 | [diff] [blame^] | 58 | ack.missing_packets.insert(least_unacked + i); |
[email protected] | aa7e4ef | 2014-05-28 03:53:15 | [diff] [blame] | 59 | } |
| 60 | return ack; |
| 61 | } |
| 62 | |
[email protected] | 9cda5fd | 2014-06-03 10:20:28 | [diff] [blame] | 63 | SerializedPacket 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] | a5b9817 | 2014-06-18 07:01:59 | [diff] [blame] | 82 | uint64 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] | 8b37a09 | 2012-10-18 21:53:49 | [diff] [blame] | 90 | MockFramerVisitor::MockFramerVisitor() { |
| 91 | // By default, we want to accept packets. |
[email protected] | 14e8106c | 2013-03-14 16:25:33 | [diff] [blame] | 92 | ON_CALL(*this, OnProtocolVersionMismatch(_)) |
| 93 | .WillByDefault(testing::Return(false)); |
| 94 | |
| 95 | // By default, we want to accept packets. |
[email protected] | ec86d546 | 2013-11-17 16:04:49 | [diff] [blame] | 96 | ON_CALL(*this, OnUnauthenticatedHeader(_)) |
| 97 | .WillByDefault(testing::Return(true)); |
| 98 | |
[email protected] | 066d818 | 2014-01-04 02:02:45 | [diff] [blame] | 99 | ON_CALL(*this, OnUnauthenticatedPublicHeader(_)) |
| 100 | .WillByDefault(testing::Return(true)); |
| 101 | |
[email protected] | cff7b7b | 2013-01-11 08:49:07 | [diff] [blame] | 102 | ON_CALL(*this, OnPacketHeader(_)) |
[email protected] | 8b37a09 | 2012-10-18 21:53:49 | [diff] [blame] | 103 | .WillByDefault(testing::Return(true)); |
[email protected] | a57e027 | 2013-04-26 07:31:47 | [diff] [blame] | 104 | |
| 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] | 93dd91f | 2014-02-27 00:09:03 | [diff] [blame] | 114 | ON_CALL(*this, OnStopWaitingFrame(_)) |
| 115 | .WillByDefault(testing::Return(true)); |
| 116 | |
[email protected] | d8c52211 | 2014-04-23 09:23:25 | [diff] [blame] | 117 | ON_CALL(*this, OnPingFrame(_)) |
| 118 | .WillByDefault(testing::Return(true)); |
| 119 | |
[email protected] | a57e027 | 2013-04-26 07:31:47 | [diff] [blame] | 120 | 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] | 8b37a09 | 2012-10-18 21:53:49 | [diff] [blame] | 128 | } |
| 129 | |
[email protected] | 044ac2b | 2012-11-13 21:41:06 | [diff] [blame] | 130 | MockFramerVisitor::~MockFramerVisitor() { |
| 131 | } |
[email protected] | 8b37a09 | 2012-10-18 21:53:49 | [diff] [blame] | 132 | |
[email protected] | 4887809 | 2013-07-26 14:51:56 | [diff] [blame] | 133 | bool NoOpFramerVisitor::OnProtocolVersionMismatch(QuicVersion version) { |
[email protected] | 14e8106c | 2013-03-14 16:25:33 | [diff] [blame] | 134 | return false; |
| 135 | } |
| 136 | |
[email protected] | 066d818 | 2014-01-04 02:02:45 | [diff] [blame] | 137 | bool NoOpFramerVisitor::OnUnauthenticatedPublicHeader( |
| 138 | const QuicPacketPublicHeader& header) { |
| 139 | return true; |
| 140 | } |
| 141 | |
[email protected] | ec86d546 | 2013-11-17 16:04:49 | [diff] [blame] | 142 | bool NoOpFramerVisitor::OnUnauthenticatedHeader( |
| 143 | const QuicPacketHeader& header) { |
| 144 | return true; |
| 145 | } |
| 146 | |
[email protected] | 8b37a09 | 2012-10-18 21:53:49 | [diff] [blame] | 147 | bool NoOpFramerVisitor::OnPacketHeader(const QuicPacketHeader& header) { |
| 148 | return true; |
| 149 | } |
| 150 | |
[email protected] | a57e027 | 2013-04-26 07:31:47 | [diff] [blame] | 151 | bool NoOpFramerVisitor::OnStreamFrame(const QuicStreamFrame& frame) { |
| 152 | return true; |
| 153 | } |
| 154 | |
| 155 | bool NoOpFramerVisitor::OnAckFrame(const QuicAckFrame& frame) { |
| 156 | return true; |
| 157 | } |
| 158 | |
| 159 | bool NoOpFramerVisitor::OnCongestionFeedbackFrame( |
| 160 | const QuicCongestionFeedbackFrame& frame) { |
| 161 | return true; |
| 162 | } |
| 163 | |
[email protected] | 93dd91f | 2014-02-27 00:09:03 | [diff] [blame] | 164 | bool NoOpFramerVisitor::OnStopWaitingFrame( |
| 165 | const QuicStopWaitingFrame& frame) { |
| 166 | return true; |
| 167 | } |
| 168 | |
[email protected] | d8c52211 | 2014-04-23 09:23:25 | [diff] [blame] | 169 | bool NoOpFramerVisitor::OnPingFrame(const QuicPingFrame& frame) { |
| 170 | return true; |
| 171 | } |
| 172 | |
[email protected] | a57e027 | 2013-04-26 07:31:47 | [diff] [blame] | 173 | bool NoOpFramerVisitor::OnRstStreamFrame( |
| 174 | const QuicRstStreamFrame& frame) { |
| 175 | return true; |
| 176 | } |
| 177 | |
| 178 | bool NoOpFramerVisitor::OnConnectionCloseFrame( |
| 179 | const QuicConnectionCloseFrame& frame) { |
| 180 | return true; |
| 181 | } |
| 182 | |
| 183 | bool NoOpFramerVisitor::OnGoAwayFrame(const QuicGoAwayFrame& frame) { |
| 184 | return true; |
| 185 | } |
| 186 | |
[email protected] | cb23a92 | 2014-02-20 17:42:38 | [diff] [blame] | 187 | bool NoOpFramerVisitor::OnWindowUpdateFrame( |
| 188 | const QuicWindowUpdateFrame& frame) { |
| 189 | return true; |
| 190 | } |
| 191 | |
| 192 | bool NoOpFramerVisitor::OnBlockedFrame(const QuicBlockedFrame& frame) { |
| 193 | return true; |
| 194 | } |
| 195 | |
[email protected] | 8d659e2 | 2013-01-19 04:26:10 | [diff] [blame] | 196 | MockConnectionVisitor::MockConnectionVisitor() { |
| 197 | } |
| 198 | |
| 199 | MockConnectionVisitor::~MockConnectionVisitor() { |
| 200 | } |
| 201 | |
[email protected] | 9c0b135 | 2012-11-04 00:03:27 | [diff] [blame] | 202 | MockHelper::MockHelper() { |
| 203 | } |
| 204 | |
| 205 | MockHelper::~MockHelper() { |
| 206 | } |
| 207 | |
[email protected] | 97693d1 | 2012-11-16 16:05:00 | [diff] [blame] | 208 | const QuicClock* MockHelper::GetClock() const { |
[email protected] | 9c0b135 | 2012-11-04 00:03:27 | [diff] [blame] | 209 | return &clock_; |
| 210 | } |
| 211 | |
[email protected] | 9558c5d3 | 2012-12-22 00:08:14 | [diff] [blame] | 212 | QuicRandom* MockHelper::GetRandomGenerator() { |
| 213 | return &random_generator_; |
| 214 | } |
| 215 | |
[email protected] | 965dbe6 | 2013-08-09 21:34:31 | [diff] [blame] | 216 | QuicAlarm* MockHelper::CreateAlarm(QuicAlarm::Delegate* delegate) { |
| 217 | return new TestAlarm(delegate); |
| 218 | } |
| 219 | |
[email protected] | fe053f9 | 2013-04-23 20:18:55 | [diff] [blame] | 220 | void MockHelper::AdvanceTime(QuicTime::Delta delta) { |
| 221 | clock_.AdvanceTime(delta); |
| 222 | } |
| 223 | |
[email protected] | c05a6d22 | 2013-12-16 19:42:03 | [diff] [blame] | 224 | MockConnection::MockConnection(bool is_server) |
[email protected] | 3aa9ca7 | 2014-02-27 19:39:43 | [diff] [blame] | 225 | : QuicConnection(kTestConnectionId, |
[email protected] | 300ccd5 | 2014-01-25 08:00:19 | [diff] [blame] | 226 | IPEndPoint(TestPeerIPAddress(), kTestPort), |
[email protected] | c05a6d22 | 2013-12-16 19:42:03 | [diff] [blame] | 227 | new testing::NiceMock<MockHelper>(), |
[email protected] | cbd731e | 2013-10-24 00:20:39 | [diff] [blame] | 228 | new testing::NiceMock<MockPacketWriter>(), |
[email protected] | 66cd2d6 | 2014-08-01 18:42:39 | [diff] [blame] | 229 | true /* owns_writer */, |
[email protected] | ce7bb141 | 2014-05-17 15:51:33 | [diff] [blame] | 230 | is_server, QuicSupportedVersions()), |
[email protected] | c05a6d22 | 2013-12-16 19:42:03 | [diff] [blame] | 231 | helper_(helper()) { |
| 232 | } |
| 233 | |
| 234 | MockConnection::MockConnection(IPEndPoint address, |
| 235 | bool is_server) |
[email protected] | 3aa9ca7 | 2014-02-27 19:39:43 | [diff] [blame] | 236 | : QuicConnection(kTestConnectionId, address, |
[email protected] | c05a6d22 | 2013-12-16 19:42:03 | [diff] [blame] | 237 | new testing::NiceMock<MockHelper>(), |
| 238 | new testing::NiceMock<MockPacketWriter>(), |
[email protected] | 66cd2d6 | 2014-08-01 18:42:39 | [diff] [blame] | 239 | true /* owns_writer */, |
[email protected] | ce7bb141 | 2014-05-17 15:51:33 | [diff] [blame] | 240 | is_server, QuicSupportedVersions()), |
[email protected] | 2cfc6bb8 | 2013-10-27 03:40:44 | [diff] [blame] | 241 | helper_(helper()) { |
[email protected] | 044ac2b | 2012-11-13 21:41:06 | [diff] [blame] | 242 | } |
| 243 | |
[email protected] | 3aa9ca7 | 2014-02-27 19:39:43 | [diff] [blame] | 244 | MockConnection::MockConnection(QuicConnectionId connection_id, |
[email protected] | 14e8106c | 2013-03-14 16:25:33 | [diff] [blame] | 245 | bool is_server) |
[email protected] | 3aa9ca7 | 2014-02-27 19:39:43 | [diff] [blame] | 246 | : QuicConnection(connection_id, |
| 247 | IPEndPoint(TestPeerIPAddress(), kTestPort), |
[email protected] | c05a6d22 | 2013-12-16 19:42:03 | [diff] [blame] | 248 | new testing::NiceMock<MockHelper>(), |
| 249 | new testing::NiceMock<MockPacketWriter>(), |
[email protected] | 66cd2d6 | 2014-08-01 18:42:39 | [diff] [blame] | 250 | true /* owns_writer */, |
[email protected] | ce7bb141 | 2014-05-17 15:51:33 | [diff] [blame] | 251 | is_server, QuicSupportedVersions()), |
[email protected] | c05a6d22 | 2013-12-16 19:42:03 | [diff] [blame] | 252 | helper_(helper()) { |
[email protected] | 872edd9e | 2013-01-16 08:51:15 | [diff] [blame] | 253 | } |
| 254 | |
[email protected] | 4d64079 | 2013-12-18 22:21:08 | [diff] [blame] | 255 | MockConnection::MockConnection(bool is_server, |
| 256 | const QuicVersionVector& supported_versions) |
[email protected] | 3aa9ca7 | 2014-02-27 19:39:43 | [diff] [blame] | 257 | : QuicConnection(kTestConnectionId, |
[email protected] | 300ccd5 | 2014-01-25 08:00:19 | [diff] [blame] | 258 | IPEndPoint(TestPeerIPAddress(), kTestPort), |
[email protected] | 4d64079 | 2013-12-18 22:21:08 | [diff] [blame] | 259 | new testing::NiceMock<MockHelper>(), |
| 260 | new testing::NiceMock<MockPacketWriter>(), |
[email protected] | 66cd2d6 | 2014-08-01 18:42:39 | [diff] [blame] | 261 | true /* owns_writer */, |
[email protected] | ce7bb141 | 2014-05-17 15:51:33 | [diff] [blame] | 262 | is_server, supported_versions), |
[email protected] | 4d64079 | 2013-12-18 22:21:08 | [diff] [blame] | 263 | helper_(helper()) { |
| 264 | } |
| 265 | |
[email protected] | 044ac2b | 2012-11-13 21:41:06 | [diff] [blame] | 266 | MockConnection::~MockConnection() { |
| 267 | } |
| 268 | |
[email protected] | fe053f9 | 2013-04-23 20:18:55 | [diff] [blame] | 269 | void MockConnection::AdvanceTime(QuicTime::Delta delta) { |
[email protected] | fe053f9 | 2013-04-23 20:18:55 | [diff] [blame] | 270 | static_cast<MockHelper*>(helper())->AdvanceTime(delta); |
| 271 | } |
| 272 | |
[email protected] | c05a6d22 | 2013-12-16 19:42:03 | [diff] [blame] | 273 | PacketSavingConnection::PacketSavingConnection(bool is_server) |
| 274 | : MockConnection(is_server) { |
[email protected] | 044ac2b | 2012-11-13 21:41:06 | [diff] [blame] | 275 | } |
| 276 | |
[email protected] | 4d64079 | 2013-12-18 22:21:08 | [diff] [blame] | 277 | PacketSavingConnection::PacketSavingConnection( |
| 278 | bool is_server, |
| 279 | const QuicVersionVector& supported_versions) |
| 280 | : MockConnection(is_server, supported_versions) { |
| 281 | } |
| 282 | |
[email protected] | 044ac2b | 2012-11-13 21:41:06 | [diff] [blame] | 283 | PacketSavingConnection::~PacketSavingConnection() { |
[email protected] | 701bc89 | 2013-01-17 04:51:54 | [diff] [blame] | 284 | STLDeleteElements(&packets_); |
[email protected] | 2532de1 | 2013-05-09 12:29:33 | [diff] [blame] | 285 | STLDeleteElements(&encrypted_packets_); |
[email protected] | 044ac2b | 2012-11-13 21:41:06 | [diff] [blame] | 286 | } |
| 287 | |
[email protected] | fee17f7 | 2013-02-03 07:47:41 | [diff] [blame] | 288 | bool PacketSavingConnection::SendOrQueuePacket( |
[email protected] | 8ba8121 | 2013-05-03 13:11:48 | [diff] [blame] | 289 | EncryptionLevel level, |
[email protected] | ec86d546 | 2013-11-17 16:04:49 | [diff] [blame] | 290 | const SerializedPacket& packet, |
| 291 | TransmissionType transmission_type) { |
| 292 | packets_.push_back(packet.packet); |
[email protected] | c5e1aca | 2014-01-30 04:03:04 | [diff] [blame] | 293 | QuicEncryptedPacket* encrypted = QuicConnectionPeer::GetFramer(this)-> |
| 294 | EncryptPacket(level, packet.sequence_number, *packet.packet); |
[email protected] | 2532de1 | 2013-05-09 12:29:33 | [diff] [blame] | 295 | encrypted_packets_.push_back(encrypted); |
[email protected] | 044ac2b | 2012-11-13 21:41:06 | [diff] [blame] | 296 | return true; |
| 297 | } |
| 298 | |
[email protected] | c05a6d22 | 2013-12-16 19:42:03 | [diff] [blame] | 299 | MockSession::MockSession(QuicConnection* connection) |
[email protected] | a5b9817 | 2014-06-18 07:01:59 | [diff] [blame] | 300 | : QuicSession(connection, DefaultQuicConfig()) { |
[email protected] | ccb3421 | 2014-07-18 09:27:50 | [diff] [blame] | 301 | InitializeSession(); |
[email protected] | bbb1007 | 2014-06-13 07:41:59 | [diff] [blame] | 302 | ON_CALL(*this, WritevData(_, _, _, _, _, _)) |
[email protected] | cff7b7b | 2013-01-11 08:49:07 | [diff] [blame] | 303 | .WillByDefault(testing::Return(QuicConsumedData(0, false))); |
[email protected] | 044ac2b | 2012-11-13 21:41:06 | [diff] [blame] | 304 | } |
| 305 | |
| 306 | MockSession::~MockSession() { |
| 307 | } |
| 308 | |
[email protected] | ce7bb141 | 2014-05-17 15:51:33 | [diff] [blame] | 309 | TestSession::TestSession(QuicConnection* connection, const QuicConfig& config) |
[email protected] | a5b9817 | 2014-06-18 07:01:59 | [diff] [blame] | 310 | : QuicSession(connection, config), |
[email protected] | ccb3421 | 2014-07-18 09:27:50 | [diff] [blame] | 311 | crypto_stream_(NULL) { |
| 312 | InitializeSession(); |
| 313 | } |
[email protected] | 2532de1 | 2013-05-09 12:29:33 | [diff] [blame] | 314 | |
[email protected] | b06431078 | 2013-05-30 21:12:17 | [diff] [blame] | 315 | TestSession::~TestSession() {} |
[email protected] | 2532de1 | 2013-05-09 12:29:33 | [diff] [blame] | 316 | |
| 317 | void TestSession::SetCryptoStream(QuicCryptoStream* stream) { |
| 318 | crypto_stream_ = stream; |
| 319 | } |
| 320 | |
| 321 | QuicCryptoStream* TestSession::GetCryptoStream() { |
| 322 | return crypto_stream_; |
| 323 | } |
| 324 | |
[email protected] | 90f62f09 | 2014-03-24 02:41:23 | [diff] [blame] | 325 | TestClientSession::TestClientSession(QuicConnection* connection, |
| 326 | const QuicConfig& config) |
[email protected] | ccb3421 | 2014-07-18 09:27:50 | [diff] [blame] | 327 | : QuicClientSessionBase(connection, config), |
[email protected] | 90f62f09 | 2014-03-24 02:41:23 | [diff] [blame] | 328 | crypto_stream_(NULL) { |
[email protected] | ccb3421 | 2014-07-18 09:27:50 | [diff] [blame] | 329 | EXPECT_CALL(*this, OnProofValid(_)).Times(AnyNumber()); |
| 330 | InitializeSession(); |
[email protected] | 90f62f09 | 2014-03-24 02:41:23 | [diff] [blame] | 331 | } |
| 332 | |
| 333 | TestClientSession::~TestClientSession() {} |
| 334 | |
| 335 | void TestClientSession::SetCryptoStream(QuicCryptoStream* stream) { |
| 336 | crypto_stream_ = stream; |
| 337 | } |
| 338 | |
| 339 | QuicCryptoStream* TestClientSession::GetCryptoStream() { |
| 340 | return crypto_stream_; |
| 341 | } |
| 342 | |
[email protected] | cbd731e | 2013-10-24 00:20:39 | [diff] [blame] | 343 | MockPacketWriter::MockPacketWriter() { |
| 344 | } |
| 345 | |
| 346 | MockPacketWriter::~MockPacketWriter() { |
| 347 | } |
| 348 | |
[email protected] | fee17f7 | 2013-02-03 07:47:41 | [diff] [blame] | 349 | MockSendAlgorithm::MockSendAlgorithm() { |
[email protected] | 8d659e2 | 2013-01-19 04:26:10 | [diff] [blame] | 350 | } |
| 351 | |
[email protected] | fee17f7 | 2013-02-03 07:47:41 | [diff] [blame] | 352 | MockSendAlgorithm::~MockSendAlgorithm() { |
[email protected] | 8d659e2 | 2013-01-19 04:26:10 | [diff] [blame] | 353 | } |
| 354 | |
[email protected] | 3aa9ca7 | 2014-02-27 19:39:43 | [diff] [blame] | 355 | MockLossAlgorithm::MockLossAlgorithm() { |
| 356 | } |
| 357 | |
| 358 | MockLossAlgorithm::~MockLossAlgorithm() { |
| 359 | } |
| 360 | |
[email protected] | 97cf302 | 2013-09-05 14:30:16 | [diff] [blame] | 361 | MockAckNotifierDelegate::MockAckNotifierDelegate() { |
| 362 | } |
| 363 | |
| 364 | MockAckNotifierDelegate::~MockAckNotifierDelegate() { |
| 365 | } |
| 366 | |
[email protected] | a692ad9d | 2014-07-18 21:35:24 | [diff] [blame] | 367 | MockNetworkChangeVisitor::MockNetworkChangeVisitor() { |
| 368 | } |
| 369 | |
| 370 | MockNetworkChangeVisitor::~MockNetworkChangeVisitor() { |
| 371 | } |
| 372 | |
[email protected] | 8b37a09 | 2012-10-18 21:53:49 | [diff] [blame] | 373 | namespace { |
| 374 | |
| 375 | string 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] | 300ccd5 | 2014-01-25 08:00:19 | [diff] [blame] | 414 | IPAddressNumber TestPeerIPAddress() { return Loopback4(); } |
| 415 | |
[email protected] | b007e63 | 2013-10-28 08:39:25 | [diff] [blame] | 416 | QuicVersion QuicVersionMax() { return QuicSupportedVersions().front(); } |
| 417 | |
| 418 | QuicVersion QuicVersionMin() { return QuicSupportedVersions().back(); } |
| 419 | |
[email protected] | c05a6d22 | 2013-12-16 19:42:03 | [diff] [blame] | 420 | IPAddressNumber Loopback4() { |
[email protected] | 300ccd5 | 2014-01-25 08:00:19 | [diff] [blame] | 421 | IPAddressNumber addr; |
| 422 | CHECK(ParseIPLiteralToNumber("127.0.0.1", &addr)); |
[email protected] | c05a6d22 | 2013-12-16 19:42:03 | [diff] [blame] | 423 | return addr; |
| 424 | } |
| 425 | |
[email protected] | 730b35d7 | 2014-06-05 03:23:22 | [diff] [blame] | 426 | IPAddressNumber Loopback6() { |
| 427 | IPAddressNumber addr; |
| 428 | CHECK(ParseIPLiteralToNumber("::1", &addr)); |
| 429 | return addr; |
| 430 | } |
| 431 | |
[email protected] | 9bb57c7 | 2014-03-31 20:36:04 | [diff] [blame] | 432 | void 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] | ffc34bf | 2014-03-07 02:42:02 | [diff] [blame] | 440 | QuicEncryptedPacket* 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] | 9cda5fd | 2014-06-03 10:20:28 | [diff] [blame] | 464 | BuildUnsizedDataPacket(&framer, header, frames).packet); |
[email protected] | ffc34bf | 2014-03-07 02:42:02 | [diff] [blame] | 465 | 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] | 8b37a09 | 2012-10-18 21:53:49 | [diff] [blame] | 473 | void 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] | b007e63 | 2013-10-28 08:39:25 | [diff] [blame] | 479 | EXPECT_EQ(actual_len, expected_len); |
[email protected] | 8b37a09 | 2012-10-18 21:53:49 | [diff] [blame] | 480 | const int min_len = min(actual_len, expected_len); |
| 481 | const int max_len = max(actual_len, expected_len); |
[email protected] | 4356f0f | 2013-04-07 00:58:17 | [diff] [blame] | 482 | scoped_ptr<bool[]> marks(new bool[max_len]); |
[email protected] | 8b37a09 | 2012-10-18 21:53:49 | [diff] [blame] | 483 | 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] | b12764d | 2013-12-02 22:28:30 | [diff] [blame] | 505 | bool 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] | d3d15bf | 2013-01-30 02:51:54 | [diff] [blame] | 517 | static QuicPacket* ConstructPacketFromHandshakeMessage( |
[email protected] | 3aa9ca7 | 2014-02-27 19:39:43 | [diff] [blame] | 518 | QuicConnectionId connection_id, |
[email protected] | 14e8106c | 2013-03-14 16:25:33 | [diff] [blame] | 519 | const CryptoHandshakeMessage& message, |
| 520 | bool should_include_version) { |
[email protected] | 8b37a09 | 2012-10-18 21:53:49 | [diff] [blame] | 521 | CryptoFramer crypto_framer; |
[email protected] | dc2cc74 | 2012-10-21 13:56:13 | [diff] [blame] | 522 | scoped_ptr<QuicData> data(crypto_framer.ConstructHandshakeMessage(message)); |
[email protected] | b007e63 | 2013-10-28 08:39:25 | [diff] [blame] | 523 | QuicFramer quic_framer(QuicSupportedVersions(), QuicTime::Zero(), false); |
[email protected] | 8b37a09 | 2012-10-18 21:53:49 | [diff] [blame] | 524 | |
| 525 | QuicPacketHeader header; |
[email protected] | 3aa9ca7 | 2014-02-27 19:39:43 | [diff] [blame] | 526 | header.public_header.connection_id = connection_id; |
[email protected] | 9db44391 | 2013-02-25 05:27:03 | [diff] [blame] | 527 | header.public_header.reset_flag = false; |
[email protected] | 14e8106c | 2013-03-14 16:25:33 | [diff] [blame] | 528 | header.public_header.version_flag = should_include_version; |
[email protected] | 8b37a09 | 2012-10-18 21:53:49 | [diff] [blame] | 529 | header.packet_sequence_number = 1; |
[email protected] | 9db44391 | 2013-02-25 05:27:03 | [diff] [blame] | 530 | header.entropy_flag = false; |
| 531 | header.entropy_hash = 0; |
| 532 | header.fec_flag = false; |
[email protected] | 8b37a09 | 2012-10-18 21:53:49 | [diff] [blame] | 533 | header.fec_group = 0; |
| 534 | |
[email protected] | be24ab2 | 2012-10-22 03:01:52 | [diff] [blame] | 535 | QuicStreamFrame stream_frame(kCryptoStreamId, false, 0, |
[email protected] | 5dafdb6 | 2013-11-14 01:24:26 | [diff] [blame] | 536 | MakeIOVector(data->AsStringPiece())); |
[email protected] | 8b37a09 | 2012-10-18 21:53:49 | [diff] [blame] | 537 | |
[email protected] | be24ab2 | 2012-10-22 03:01:52 | [diff] [blame] | 538 | QuicFrame frame(&stream_frame); |
| 539 | QuicFrames frames; |
| 540 | frames.push_back(frame); |
[email protected] | 9cda5fd | 2014-06-03 10:20:28 | [diff] [blame] | 541 | return BuildUnsizedDataPacket(&quic_framer, header, frames).packet; |
[email protected] | 8b37a09 | 2012-10-18 21:53:49 | [diff] [blame] | 542 | } |
| 543 | |
[email protected] | 3aa9ca7 | 2014-02-27 19:39:43 | [diff] [blame] | 544 | QuicPacket* ConstructHandshakePacket(QuicConnectionId connection_id, |
| 545 | QuicTag tag) { |
[email protected] | d3d15bf | 2013-01-30 02:51:54 | [diff] [blame] | 546 | CryptoHandshakeMessage message; |
[email protected] | ccc66e8a | 2013-03-26 08:26:14 | [diff] [blame] | 547 | message.set_tag(tag); |
[email protected] | 3aa9ca7 | 2014-02-27 19:39:43 | [diff] [blame] | 548 | return ConstructPacketFromHandshakeMessage(connection_id, message, false); |
[email protected] | d3d15bf | 2013-01-30 02:51:54 | [diff] [blame] | 549 | } |
| 550 | |
[email protected] | ea825e0 | 2013-08-21 18:12:45 | [diff] [blame] | 551 | size_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] | f62262b | 2013-07-05 20:57:30 | [diff] [blame] | 557 | *payload_length = 1; |
| 558 | const size_t stream_length = |
[email protected] | 5dafdb6 | 2013-11-14 01:24:26 | [diff] [blame] | 559 | NullEncrypter().GetCiphertextSize(*payload_length) + |
[email protected] | b06431078 | 2013-05-30 21:12:17 | [diff] [blame] | 560 | QuicPacketCreator::StreamFramePacketOverhead( |
[email protected] | 310d37b | 2014-08-02 06:15:37 | [diff] [blame^] | 561 | PACKET_8BYTE_CONNECTION_ID, include_version, |
[email protected] | aa7e4ef | 2014-05-28 03:53:15 | [diff] [blame] | 562 | sequence_number_length, 0u, is_in_fec_group); |
[email protected] | 5dafdb6 | 2013-11-14 01:24:26 | [diff] [blame] | 563 | const size_t ack_length = NullEncrypter().GetCiphertextSize( |
[email protected] | 8e01c06 | 2013-10-31 07:35:31 | [diff] [blame] | 564 | QuicFramer::GetMinAckFrameSize( |
[email protected] | 310d37b | 2014-08-02 06:15:37 | [diff] [blame^] | 565 | sequence_number_length, PACKET_1BYTE_SEQUENCE_NUMBER)) + |
[email protected] | 3aa9ca7 | 2014-02-27 19:39:43 | [diff] [blame] | 566 | GetPacketHeaderSize(PACKET_8BYTE_CONNECTION_ID, include_version, |
[email protected] | ea825e0 | 2013-08-21 18:12:45 | [diff] [blame] | 567 | sequence_number_length, is_in_fec_group); |
[email protected] | f62262b | 2013-07-05 20:57:30 | [diff] [blame] | 568 | if (stream_length < ack_length) { |
| 569 | *payload_length = 1 + ack_length - stream_length; |
| 570 | } |
| 571 | |
[email protected] | 5dafdb6 | 2013-11-14 01:24:26 | [diff] [blame] | 572 | return NullEncrypter().GetCiphertextSize(*payload_length) + |
[email protected] | f62262b | 2013-07-05 20:57:30 | [diff] [blame] | 573 | QuicPacketCreator::StreamFramePacketOverhead( |
[email protected] | 310d37b | 2014-08-02 06:15:37 | [diff] [blame^] | 574 | PACKET_8BYTE_CONNECTION_ID, include_version, |
[email protected] | aa7e4ef | 2014-05-28 03:53:15 | [diff] [blame] | 575 | sequence_number_length, 0u, is_in_fec_group); |
[email protected] | 5351cc4b | 2013-03-03 07:22:41 | [diff] [blame] | 576 | } |
| 577 | |
[email protected] | a5b9817 | 2014-06-18 07:01:59 | [diff] [blame] | 578 | TestEntropyCalculator::TestEntropyCalculator() {} |
[email protected] | 8e01c06 | 2013-10-31 07:35:31 | [diff] [blame] | 579 | |
[email protected] | a5b9817 | 2014-06-18 07:01:59 | [diff] [blame] | 580 | TestEntropyCalculator::~TestEntropyCalculator() {} |
[email protected] | 8e01c06 | 2013-10-31 07:35:31 | [diff] [blame] | 581 | |
[email protected] | 4887809 | 2013-07-26 14:51:56 | [diff] [blame] | 582 | QuicPacketEntropyHash TestEntropyCalculator::EntropyHash( |
[email protected] | 9db44391 | 2013-02-25 05:27:03 | [diff] [blame] | 583 | QuicPacketSequenceNumber sequence_number) const { |
| 584 | return 1u; |
| 585 | } |
| 586 | |
[email protected] | a5b9817 | 2014-06-18 07:01:59 | [diff] [blame] | 587 | MockEntropyCalculator::MockEntropyCalculator() {} |
[email protected] | 8e01c06 | 2013-10-31 07:35:31 | [diff] [blame] | 588 | |
[email protected] | a5b9817 | 2014-06-18 07:01:59 | [diff] [blame] | 589 | MockEntropyCalculator::~MockEntropyCalculator() {} |
[email protected] | 8e01c06 | 2013-10-31 07:35:31 | [diff] [blame] | 590 | |
[email protected] | b06431078 | 2013-05-30 21:12:17 | [diff] [blame] | 591 | QuicConfig DefaultQuicConfig() { |
| 592 | QuicConfig config; |
| 593 | config.SetDefaults(); |
[email protected] | 7d56135 | 2014-06-20 09:09:21 | [diff] [blame] | 594 | config.SetInitialFlowControlWindowToSend( |
| 595 | kInitialSessionFlowControlWindowForTest); |
| 596 | config.SetInitialStreamFlowControlWindowToSend( |
| 597 | kInitialStreamFlowControlWindowForTest); |
| 598 | config.SetInitialSessionFlowControlWindowToSend( |
| 599 | kInitialSessionFlowControlWindowForTest); |
[email protected] | b06431078 | 2013-05-30 21:12:17 | [diff] [blame] | 600 | return config; |
| 601 | } |
| 602 | |
[email protected] | 4d64079 | 2013-12-18 22:21:08 | [diff] [blame] | 603 | QuicVersionVector SupportedVersions(QuicVersion version) { |
| 604 | QuicVersionVector versions; |
| 605 | versions.push_back(version); |
| 606 | return versions; |
| 607 | } |
| 608 | |
[email protected] | 8b37a09 | 2012-10-18 21:53:49 | [diff] [blame] | 609 | } // namespace test |
[email protected] | 8b37a09 | 2012-10-18 21:53:49 | [diff] [blame] | 610 | } // namespace net |