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/tools/quic/test_tools/quic_test_utils.h" 6 7#include "net/quic/quic_connection.h" 8#include "net/quic/test_tools/quic_connection_peer.h" 9#include "net/quic/test_tools/quic_test_utils.h" 10#include "net/tools/quic/quic_epoll_connection_helper.h" 11 12using base::StringPiece; 13using net::test::MakeAckFrame; 14using net::test::MockHelper; 15using net::test::QuicConnectionPeer; 16 17namespace net { 18namespace tools { 19namespace test { 20 21namespace { 22class NiceMockPacketWriterFactory 23 : public QuicConnection::PacketWriterFactory { 24 public: 25 NiceMockPacketWriterFactory() {} 26 virtual ~NiceMockPacketWriterFactory() {} 27 28 virtual QuicPacketWriter* Create( 29 QuicConnection* /*connection*/) const OVERRIDE { 30 return new testing::NiceMock<MockPacketWriter>(); 31 } 32 33 private: 34 DISALLOW_COPY_AND_ASSIGN(NiceMockPacketWriterFactory); 35}; 36} // namespace 37 38MockConnection::MockConnection(bool is_server) 39 : QuicConnection(kTestConnectionId, 40 IPEndPoint(net::test::Loopback4(), kTestPort), 41 new testing::NiceMock<MockHelper>(), 42 NiceMockPacketWriterFactory(), 43 /* owns_writer= */ true, 44 is_server, QuicSupportedVersions()), 45 helper_(helper()) { 46} 47 48MockConnection::MockConnection(IPEndPoint address, 49 bool is_server) 50 : QuicConnection(kTestConnectionId, address, 51 new testing::NiceMock<MockHelper>(), 52 NiceMockPacketWriterFactory(), 53 /* owns_writer= */ true, 54 is_server, QuicSupportedVersions()), 55 helper_(helper()) { 56} 57 58MockConnection::MockConnection(QuicConnectionId connection_id, 59 bool is_server) 60 : QuicConnection(connection_id, 61 IPEndPoint(net::test::Loopback4(), kTestPort), 62 new testing::NiceMock<MockHelper>(), 63 NiceMockPacketWriterFactory(), 64 /* owns_writer= */ true, 65 is_server, QuicSupportedVersions()), 66 helper_(helper()) { 67} 68 69MockConnection::MockConnection(bool is_server, 70 const QuicVersionVector& supported_versions) 71 : QuicConnection(kTestConnectionId, 72 IPEndPoint(net::test::Loopback4(), kTestPort), 73 new testing::NiceMock<MockHelper>(), 74 NiceMockPacketWriterFactory(), 75 /* owns_writer= */ true, 76 is_server, QuicSupportedVersions()), 77 helper_(helper()) { 78} 79 80MockConnection::~MockConnection() { 81} 82 83void MockConnection::AdvanceTime(QuicTime::Delta delta) { 84 static_cast<MockHelper*>(helper())->AdvanceTime(delta); 85} 86 87QuicAckFrame MakeAckFrameWithNackRanges( 88 size_t num_nack_ranges, QuicPacketSequenceNumber least_unacked) { 89 QuicAckFrame ack = MakeAckFrame(2 * num_nack_ranges + least_unacked); 90 // Add enough missing packets to get num_nack_ranges nack ranges. 91 for (QuicPacketSequenceNumber i = 1; i < 2 * num_nack_ranges; i += 2) { 92 ack.missing_packets.insert(least_unacked + i); 93 } 94 return ack; 95} 96 97TestSession::TestSession(QuicConnection* connection, 98 const QuicConfig& config) 99 : QuicSession(connection, config), 100 crypto_stream_(NULL) { 101 InitializeSession(); 102} 103 104TestSession::~TestSession() {} 105 106void TestSession::SetCryptoStream(QuicCryptoStream* stream) { 107 crypto_stream_ = stream; 108} 109 110QuicCryptoStream* TestSession::GetCryptoStream() { 111 return crypto_stream_; 112} 113 114MockPacketWriter::MockPacketWriter() { 115} 116 117MockPacketWriter::~MockPacketWriter() { 118} 119 120MockQuicServerSessionVisitor::MockQuicServerSessionVisitor() { 121} 122 123MockQuicServerSessionVisitor::~MockQuicServerSessionVisitor() { 124} 125 126MockAckNotifierDelegate::MockAckNotifierDelegate() { 127} 128 129MockAckNotifierDelegate::~MockAckNotifierDelegate() { 130} 131 132TestWriterFactory::TestWriterFactory() : current_writer_(NULL) {} 133TestWriterFactory::~TestWriterFactory() {} 134 135QuicPacketWriter* TestWriterFactory::Create(QuicPacketWriter* writer, 136 QuicConnection* connection) { 137 return new PerConnectionPacketWriter(this, writer, connection); 138} 139 140void TestWriterFactory::OnPacketSent(WriteResult result) { 141 if (current_writer_ != NULL && result.status == WRITE_STATUS_ERROR) { 142 current_writer_->connection()->OnWriteError(result.error_code); 143 current_writer_ = NULL; 144 } 145} 146 147void TestWriterFactory::Unregister(PerConnectionPacketWriter* writer) { 148 if (current_writer_ == writer) { 149 current_writer_ = NULL; 150 } 151} 152 153TestWriterFactory::PerConnectionPacketWriter::PerConnectionPacketWriter( 154 TestWriterFactory* factory, 155 QuicPacketWriter* writer, 156 QuicConnection* connection) 157 : QuicPerConnectionPacketWriter(writer, connection), 158 factory_(factory) { 159} 160 161TestWriterFactory::PerConnectionPacketWriter::~PerConnectionPacketWriter() { 162 factory_->Unregister(this); 163} 164 165WriteResult TestWriterFactory::PerConnectionPacketWriter::WritePacket( 166 const char* buffer, 167 size_t buf_len, 168 const IPAddressNumber& self_address, 169 const IPEndPoint& peer_address) { 170 // A DCHECK(factory_current_writer_ == NULL) would be wrong here -- this class 171 // may be used in a setting where connection()->OnPacketSent() is called in a 172 // different way, so TestWriterFactory::OnPacketSent might never be called. 173 factory_->current_writer_ = this; 174 return QuicPerConnectionPacketWriter::WritePacket(buffer, 175 buf_len, 176 self_address, 177 peer_address); 178} 179 180} // namespace test 181} // namespace tools 182} // namespace net 183