text: // Copyright (c) 2012 The Chromium Authors. All rights reserved.
  // Use of this source code is governed by a BSD-style license that can be
  // found in the LICENSE file.
  
  #include "net/tools/quic/test_tools/quic_test_utils.h"
  
  #include "net/quic/quic_connection.h"
  #include "net/quic/test_tools/quic_connection_peer.h"
  #include "net/quic/test_tools/quic_test_utils.h"
  #include "net/tools/quic/quic_epoll_connection_helper.h"
  
  using base::StringPiece;
  using net::test::MakeAckFrame;
  using net::test::MockHelper;
  using net::test::QuicConnectionPeer;
  
  namespace net {
  namespace tools {
  namespace test {
  
  MockConnection::MockConnection(bool is_server)
      : QuicConnection(kTestConnectionId,
                       IPEndPoint(net::test::Loopback4(), kTestPort),
                       new testing::NiceMock<MockHelper>(),
                       new testing::NiceMock<MockPacketWriter>(),
                       is_server, QuicSupportedVersions()),
        writer_(QuicConnectionPeer::GetWriter(this)),
        helper_(helper()) {
  }
  
  MockConnection::MockConnection(IPEndPoint address,
                                 bool is_server)
      : QuicConnection(kTestConnectionId, address,
                       new testing::NiceMock<MockHelper>(),
                       new testing::NiceMock<MockPacketWriter>(),
                       is_server, QuicSupportedVersions()),
        writer_(QuicConnectionPeer::GetWriter(this)),
        helper_(helper()) {
  }
  
  MockConnection::MockConnection(QuicConnectionId connection_id,
                                 bool is_server)
      : QuicConnection(connection_id,
                       IPEndPoint(net::test::Loopback4(), kTestPort),
                       new testing::NiceMock<MockHelper>(),
                       new testing::NiceMock<MockPacketWriter>(),
                       is_server, QuicSupportedVersions()),
        writer_(QuicConnectionPeer::GetWriter(this)),
        helper_(helper()) {
  }
  
  MockConnection::MockConnection(bool is_server,
                                 const QuicVersionVector& supported_versions)
      : QuicConnection(kTestConnectionId,
                       IPEndPoint(net::test::Loopback4(), kTestPort),
                       new testing::NiceMock<MockHelper>(),
                       new testing::NiceMock<MockPacketWriter>(),
                       is_server, QuicSupportedVersions()),
        writer_(QuicConnectionPeer::GetWriter(this)),
        helper_(helper()) {
  }
  
  MockConnection::~MockConnection() {
  }
  
  void MockConnection::AdvanceTime(QuicTime::Delta delta) {
    static_cast<MockHelper*>(helper())->AdvanceTime(delta);
  }
  
  QuicAckFrame MakeAckFrameWithNackRanges(
      size_t num_nack_ranges, QuicPacketSequenceNumber least_unacked) {
    QuicAckFrame ack = MakeAckFrame(2 * num_nack_ranges + least_unacked,
                                    least_unacked);
    // Add enough missing packets to get num_nack_ranges nack ranges.
    for (QuicPacketSequenceNumber i = 1; i < 2 * num_nack_ranges; i += 2) {
      ack.received_info.missing_packets.insert(least_unacked + i);
    }
    return ack;
  }
  
  TestSession::TestSession(QuicConnection* connection,
                           const QuicConfig& config)
    : QuicSession(connection, config),
      crypto_stream_(NULL) {
  }
  
  TestSession::~TestSession() {}
  
  void TestSession::SetCryptoStream(QuicCryptoStream* stream) {
    crypto_stream_ = stream;
  }
  
  QuicCryptoStream* TestSession::GetCryptoStream() {
    return crypto_stream_;
  }
  
  MockPacketWriter::MockPacketWriter() {
  }
  
  MockPacketWriter::~MockPacketWriter() {
  }
  
  MockQuicServerSessionVisitor::MockQuicServerSessionVisitor() {
  }
  
  MockQuicServerSessionVisitor::~MockQuicServerSessionVisitor() {
  }
  
  MockAckNotifierDelegate::MockAckNotifierDelegate() {
  }
  
  MockAckNotifierDelegate::~MockAckNotifierDelegate() {
  }
  
  }  // namespace test
  }  // namespace tools
  }  // namespace net
  