third_party/libjingle/source/talk/p2p/base/relayport_unittest.cc - vendor/opensource/webrtc - Git at Google

 /*
  * libjingle
  * Copyright 2009 Google Inc.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
  *
  *  1. Redistributions of source code must retain the above copyright notice,
  *     this list of conditions and the following disclaimer.
  *  2. Redistributions in binary form must reproduce the above copyright notice,
  *     this list of conditions and the following disclaimer in the documentation
  *     and/or other materials provided with the distribution.
  *  3. The name of the author may not be used to endorse or promote products
  *     derived from this software without specific prior written permission.
  *
  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
  * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
  * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
  * EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
  * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
  * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
  * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
  * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */

 #include "talk/base/basicpacketsocketfactory.h"
 #include "talk/base/logging.h"
 #include "talk/base/gunit.h"
 #include "talk/base/helpers.h"
 #include "talk/base/physicalsocketserver.h"
 #include "talk/base/scoped_ptr.h"
 #include "talk/base/socketadapters.h"
 #include "talk/base/socketaddress.h"
 #include "talk/base/thread.h"
 #include "talk/base/virtualsocketserver.h"
 #include "talk/p2p/base/relayport.h"
 #include "talk/p2p/base/relayserver.h"

 using talk_base::SocketAddress;

 static const SocketAddress kLocalAddress = SocketAddress("192.168.1.2", 0);
 static const SocketAddress kRelayUdpAddr = SocketAddress("99.99.99.1", 5000);
 static const SocketAddress kRelayTcpAddr = SocketAddress("99.99.99.2", 5001);
 static const SocketAddress kRelaySslAddr = SocketAddress("99.99.99.3", 443);
 static const SocketAddress kRelayExtAddr = SocketAddress("99.99.99.3", 5002);

 static const int kTimeoutMs = 1000;
 static const int kMaxTimeoutMs = 5000;

 // Tests connecting a RelayPort to a fake relay server
 // (cricket::RelayServer) using all currently available protocols. The
 // network layer is faked out by using a VirtualSocketServer for
 // creating sockets. The test will monitor the current state of the
 // RelayPort and created sockets by listening for signals such as,
 // SignalConnectFailure, SignalConnectTimeout, SignalSocketClosed and
 // SignalReadPacket.
 class RelayPortTest : public testing::Test,
                       public sigslot::has_slots<> {
  public:
   RelayPortTest()
       : main_(talk_base::Thread::Current()),
         physical_socket_server_(new talk_base::PhysicalSocketServer),
         virtual_socket_server_(new talk_base::VirtualSocketServer(
             physical_socket_server_.get())),
         ss_scope_(virtual_socket_server_.get()),
         network_("unittest", "unittest", talk_base::IPAddress(INADDR_ANY)),
         socket_factory_(talk_base::Thread::Current()),
         username_(talk_base::CreateRandomString(16)),
         password_(talk_base::CreateRandomString(16)),
         relay_port_(cricket::RelayPort::Create(main_, &socket_factory_,
                                                &network_,
                                                kLocalAddress.ipaddr(),
                                                0, 0, username_, password_, "")),
         relay_server_(new cricket::RelayServer(main_)) {
   }

   void OnReadPacket(talk_base::AsyncPacketSocket* socket,
                     const char* data, size_t size,
                     const talk_base::SocketAddress& remote_addr) {
     received_packet_count_[socket]++;
   }

   void OnConnectFailure(const cricket::ProtocolAddress* addr) {
     failed_connections_.push_back(*addr);
   }

   void OnSoftTimeout(const cricket::ProtocolAddress* addr) {
     soft_timedout_connections_.push_back(*addr);
   }

  protected:
   static void SetUpTestCase() {
     // Ensure the RNG is inited.
     talk_base::InitRandom(NULL, 0);
   }

   virtual void SetUp() {
     // The relay server needs an external socket to work properly.
     talk_base::AsyncUDPSocket* ext_socket =
         CreateAsyncUdpSocket(kRelayExtAddr);
     relay_server_->AddExternalSocket(ext_socket);

     // Listen for failures.
     relay_port_->SignalConnectFailure.
         connect(this, &RelayPortTest::OnConnectFailure);

     // Listen for soft timeouts.
     relay_port_->SignalSoftTimeout.
         connect(this, &RelayPortTest::OnSoftTimeout);
   }

   // Udp has the highest 'goodness' value of the three different
   // protocols used for connecting to the relay server. As soon as
   // PrepareAddress is called, the RelayPort will start trying to
   // connect to the given UDP address. As soon as a response to the
   // sent STUN allocate request message has been received, the
   // RelayPort will consider the connection to be complete and will
   // abort any other connection attempts.
   void TestConnectUdp() {
     // Add a UDP socket to the relay server.
     talk_base::AsyncUDPSocket* internal_udp_socket =
         CreateAsyncUdpSocket(kRelayUdpAddr);
     talk_base::AsyncSocket* server_socket = CreateServerSocket(kRelayTcpAddr);

     relay_server_->AddInternalSocket(internal_udp_socket);
     relay_server_->AddInternalServerSocket(server_socket, cricket::PROTO_TCP);

     // Now add our relay addresses to the relay port and let it start.
     relay_port_->AddServerAddress(
         cricket::ProtocolAddress(kRelayUdpAddr, cricket::PROTO_UDP));
     relay_port_->AddServerAddress(
         cricket::ProtocolAddress(kRelayTcpAddr, cricket::PROTO_TCP));
     relay_port_->PrepareAddress();

     // Should be connected.
     EXPECT_TRUE_WAIT(relay_port_->IsReady(), kTimeoutMs);

     // Make sure that we are happy with UDP, ie. not continuing with
     // TCP, SSLTCP, etc.
     WAIT(relay_server_->HasConnection(kRelayTcpAddr), kTimeoutMs);

     // Should have only one connection.
     EXPECT_EQ(1, relay_server_->GetConnectionCount());

     // Should be the UDP address.
     EXPECT_TRUE(relay_server_->HasConnection(kRelayUdpAddr));
   }

   // TCP has the second best 'goodness' value, and as soon as UDP
   // connection has failed, the RelayPort will attempt to connect via
   // TCP. Here we add a fake UDP address together with a real TCP
   // address to simulate an UDP failure. As soon as UDP has failed the
   // RelayPort will try the TCP adress and succed.
   void TestConnectTcp() {
     // Create a fake UDP address for relay port to simulate a failure.
     cricket::ProtocolAddress fake_protocol_address =
         cricket::ProtocolAddress(kRelayUdpAddr, cricket::PROTO_UDP);

     // Create a server socket for the RelayServer.
     talk_base::AsyncSocket* server_socket = CreateServerSocket(kRelayTcpAddr);
     relay_server_->AddInternalServerSocket(server_socket, cricket::PROTO_TCP);

     // Add server addresses to the relay port and let it start.
     relay_port_->AddServerAddress(
         cricket::ProtocolAddress(fake_protocol_address));
     relay_port_->AddServerAddress(
         cricket::ProtocolAddress(kRelayTcpAddr, cricket::PROTO_TCP));
     relay_port_->PrepareAddress();

     EXPECT_FALSE(relay_port_->IsReady());

     // Should have timed out in 200 + 200 + 400 + 800 + 1600 ms.
     EXPECT_TRUE_WAIT(HasFailed(&fake_protocol_address), 3600);

     // Wait until relayport is ready.
     EXPECT_TRUE_WAIT(relay_port_->IsReady(), kMaxTimeoutMs);

     // Should have only one connection.
     EXPECT_EQ(1, relay_server_->GetConnectionCount());

     // Should be the TCP address.
     EXPECT_TRUE(relay_server_->HasConnection(kRelayTcpAddr));
   }

   void TestConnectSslTcp() {
     // Create a fake TCP address for relay port to simulate a failure.
     // We skip UDP here since transition from UDP to TCP has been
     // tested above.
     cricket::ProtocolAddress fake_protocol_address =
         cricket::ProtocolAddress(kRelayTcpAddr, cricket::PROTO_TCP);

     // Create a ssl server socket for the RelayServer.
     talk_base::AsyncSocket* ssl_server_socket =
         CreateServerSocket(kRelaySslAddr);
     relay_server_->AddInternalServerSocket(ssl_server_socket,
                                            cricket::PROTO_SSLTCP);

     // Create a tcp server socket that listens on the fake address so
     // the relay port can attempt to connect to it.
     talk_base::scoped_ptr<talk_base::AsyncSocket> tcp_server_socket(
         CreateServerSocket(kRelayTcpAddr));

     // Add server addresses to the relay port and let it start.
     relay_port_->AddServerAddress(fake_protocol_address);
     relay_port_->AddServerAddress(
         cricket::ProtocolAddress(kRelaySslAddr, cricket::PROTO_SSLTCP));
     relay_port_->PrepareAddress();
     EXPECT_FALSE(relay_port_->IsReady());

     // Should have timed out in 3000 ms(relayport.cc, kSoftConnectTimeoutMs).
     EXPECT_TRUE_WAIT_MARGIN(HasTimedOut(&fake_protocol_address), 3000, 100);

     // Wait until relayport is ready.
     EXPECT_TRUE_WAIT(relay_port_->IsReady(), kMaxTimeoutMs);

     // Should have only one connection.
     EXPECT_EQ(1, relay_server_->GetConnectionCount());

     // Should be the SSLTCP address.
     EXPECT_TRUE(relay_server_->HasConnection(kRelaySslAddr));
   }

  private:
   talk_base::AsyncUDPSocket* CreateAsyncUdpSocket(const SocketAddress addr) {
     talk_base::AsyncSocket* socket =
         virtual_socket_server_->CreateAsyncSocket(SOCK_DGRAM);
     talk_base::AsyncUDPSocket* packet_socket =
         talk_base::AsyncUDPSocket::Create(socket, addr);
     EXPECT_TRUE(packet_socket != NULL);
     packet_socket->SignalReadPacket.connect(this, &RelayPortTest::OnReadPacket);
     return packet_socket;
   }

   talk_base::AsyncSocket* CreateServerSocket(const SocketAddress addr) {
     talk_base::AsyncSocket* socket =
         virtual_socket_server_->CreateAsyncSocket(SOCK_STREAM);
     EXPECT_GE(socket->Bind(addr), 0);
     EXPECT_GE(socket->Listen(5), 0);
     return socket;
   }

   bool HasFailed(cricket::ProtocolAddress* addr) {
     for (size_t i = 0; i < failed_connections_.size(); i++) {
       if (failed_connections_[i].address == addr->address &&
           failed_connections_[i].proto == addr->proto) {
         return true;
       }
     }
     return false;
   }

   bool HasTimedOut(cricket::ProtocolAddress* addr) {
     for (size_t i = 0; i < soft_timedout_connections_.size(); i++) {
       if (soft_timedout_connections_[i].address == addr->address &&
           soft_timedout_connections_[i].proto == addr->proto) {
         return true;
       }
     }
     return false;
   }

   typedef std::map<talk_base::AsyncPacketSocket*, int> PacketMap;

   talk_base::Thread* main_;
   talk_base::scoped_ptr<talk_base::PhysicalSocketServer>
       physical_socket_server_;
   talk_base::scoped_ptr<talk_base::VirtualSocketServer> virtual_socket_server_;
   talk_base::SocketServerScope ss_scope_;
   talk_base::Network network_;
   talk_base::BasicPacketSocketFactory socket_factory_;
   std::string username_;
   std::string password_;
   talk_base::scoped_ptr<cricket::RelayPort> relay_port_;
   talk_base::scoped_ptr<cricket::RelayServer> relay_server_;
   std::vector<cricket::ProtocolAddress> failed_connections_;
   std::vector<cricket::ProtocolAddress> soft_timedout_connections_;
   PacketMap received_packet_count_;
 };

 TEST_F(RelayPortTest, ConnectUdp) {
   TestConnectUdp();
 }

 TEST_F(RelayPortTest, ConnectTcp) {
   TestConnectTcp();
 }

 TEST_F(RelayPortTest, ConnectSslTcp) {
   TestConnectSslTcp();
 }
	/*
	* libjingle
	* Copyright 2009 Google Inc.
	*
	* Redistribution and use in source and binary forms, with or without
	* modification, are permitted provided that the following conditions are met:
	*
	* 1. Redistributions of source code must retain the above copyright notice,
	* this list of conditions and the following disclaimer.
	* 2. Redistributions in binary form must reproduce the above copyright notice,
	* this list of conditions and the following disclaimer in the documentation
	* and/or other materials provided with the distribution.
	* 3. The name of the author may not be used to endorse or promote products
	* derived from this software without specific prior written permission.
	*
	* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
	* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
	* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
	* EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
	* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
	* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
	* OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
	* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
	* OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
	* ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
	*/

	#include "talk/base/basicpacketsocketfactory.h"
	#include "talk/base/logging.h"
	#include "talk/base/gunit.h"
	#include "talk/base/helpers.h"
	#include "talk/base/physicalsocketserver.h"
	#include "talk/base/scoped_ptr.h"
	#include "talk/base/socketadapters.h"
	#include "talk/base/socketaddress.h"
	#include "talk/base/thread.h"
	#include "talk/base/virtualsocketserver.h"
	#include "talk/p2p/base/relayport.h"
	#include "talk/p2p/base/relayserver.h"

	using talk_base::SocketAddress;

	static const SocketAddress kLocalAddress = SocketAddress("192.168.1.2", 0);
	static const SocketAddress kRelayUdpAddr = SocketAddress("99.99.99.1", 5000);
	static const SocketAddress kRelayTcpAddr = SocketAddress("99.99.99.2", 5001);
	static const SocketAddress kRelaySslAddr = SocketAddress("99.99.99.3", 443);
	static const SocketAddress kRelayExtAddr = SocketAddress("99.99.99.3", 5002);

	static const int kTimeoutMs = 1000;
	static const int kMaxTimeoutMs = 5000;

	// Tests connecting a RelayPort to a fake relay server
	// (cricket::RelayServer) using all currently available protocols. The
	// network layer is faked out by using a VirtualSocketServer for
	// creating sockets. The test will monitor the current state of the
	// RelayPort and created sockets by listening for signals such as,
	// SignalConnectFailure, SignalConnectTimeout, SignalSocketClosed and
	// SignalReadPacket.
	class RelayPortTest : public testing::Test,
	public sigslot::has_slots<> {
	public:
	RelayPortTest()
	: main_(talk_base::Thread::Current()),
	physical_socket_server_(new talk_base::PhysicalSocketServer),
	virtual_socket_server_(new talk_base::VirtualSocketServer(
	physical_socket_server_.get())),
	ss_scope_(virtual_socket_server_.get()),
	network_("unittest", "unittest", talk_base::IPAddress(INADDR_ANY)),
	socket_factory_(talk_base::Thread::Current()),
	username_(talk_base::CreateRandomString(16)),
	password_(talk_base::CreateRandomString(16)),
	relay_port_(cricket::RelayPort::Create(main_, &socket_factory_,
	&network_,
	kLocalAddress.ipaddr(),
	0, 0, username_, password_, "")),
	relay_server_(new cricket::RelayServer(main_)) {
	}

	void OnReadPacket(talk_base::AsyncPacketSocket* socket,
	const char* data, size_t size,
	const talk_base::SocketAddress& remote_addr) {
	received_packet_count_[socket]++;
	}

	void OnConnectFailure(const cricket::ProtocolAddress* addr) {
	failed_connections_.push_back(*addr);
	}

	void OnSoftTimeout(const cricket::ProtocolAddress* addr) {
	soft_timedout_connections_.push_back(*addr);
	}

	protected:
	static void SetUpTestCase() {
	// Ensure the RNG is inited.
	talk_base::InitRandom(NULL, 0);
	}

	virtual void SetUp() {
	// The relay server needs an external socket to work properly.
	talk_base::AsyncUDPSocket* ext_socket =
	CreateAsyncUdpSocket(kRelayExtAddr);
	relay_server_->AddExternalSocket(ext_socket);

	// Listen for failures.
	relay_port_->SignalConnectFailure.
	connect(this, &RelayPortTest::OnConnectFailure);

	// Listen for soft timeouts.
	relay_port_->SignalSoftTimeout.
	connect(this, &RelayPortTest::OnSoftTimeout);
	}

	// Udp has the highest 'goodness' value of the three different
	// protocols used for connecting to the relay server. As soon as
	// PrepareAddress is called, the RelayPort will start trying to
	// connect to the given UDP address. As soon as a response to the
	// sent STUN allocate request message has been received, the
	// RelayPort will consider the connection to be complete and will
	// abort any other connection attempts.
	void TestConnectUdp() {
	// Add a UDP socket to the relay server.
	talk_base::AsyncUDPSocket* internal_udp_socket =
	CreateAsyncUdpSocket(kRelayUdpAddr);
	talk_base::AsyncSocket* server_socket = CreateServerSocket(kRelayTcpAddr);

	relay_server_->AddInternalSocket(internal_udp_socket);
	relay_server_->AddInternalServerSocket(server_socket, cricket::PROTO_TCP);

	// Now add our relay addresses to the relay port and let it start.
	relay_port_->AddServerAddress(
	cricket::ProtocolAddress(kRelayUdpAddr, cricket::PROTO_UDP));
	relay_port_->AddServerAddress(
	cricket::ProtocolAddress(kRelayTcpAddr, cricket::PROTO_TCP));
	relay_port_->PrepareAddress();

	// Should be connected.
	EXPECT_TRUE_WAIT(relay_port_->IsReady(), kTimeoutMs);

	// Make sure that we are happy with UDP, ie. not continuing with
	// TCP, SSLTCP, etc.
	WAIT(relay_server_->HasConnection(kRelayTcpAddr), kTimeoutMs);

	// Should have only one connection.
	EXPECT_EQ(1, relay_server_->GetConnectionCount());

	// Should be the UDP address.
	EXPECT_TRUE(relay_server_->HasConnection(kRelayUdpAddr));
	}

	// TCP has the second best 'goodness' value, and as soon as UDP
	// connection has failed, the RelayPort will attempt to connect via
	// TCP. Here we add a fake UDP address together with a real TCP
	// address to simulate an UDP failure. As soon as UDP has failed the
	// RelayPort will try the TCP adress and succed.
	void TestConnectTcp() {
	// Create a fake UDP address for relay port to simulate a failure.
	cricket::ProtocolAddress fake_protocol_address =
	cricket::ProtocolAddress(kRelayUdpAddr, cricket::PROTO_UDP);

	// Create a server socket for the RelayServer.
	talk_base::AsyncSocket* server_socket = CreateServerSocket(kRelayTcpAddr);
	relay_server_->AddInternalServerSocket(server_socket, cricket::PROTO_TCP);

	// Add server addresses to the relay port and let it start.
	relay_port_->AddServerAddress(
	cricket::ProtocolAddress(fake_protocol_address));
	relay_port_->AddServerAddress(
	cricket::ProtocolAddress(kRelayTcpAddr, cricket::PROTO_TCP));
	relay_port_->PrepareAddress();

	EXPECT_FALSE(relay_port_->IsReady());

	// Should have timed out in 200 + 200 + 400 + 800 + 1600 ms.
	EXPECT_TRUE_WAIT(HasFailed(&fake_protocol_address), 3600);

	// Wait until relayport is ready.
	EXPECT_TRUE_WAIT(relay_port_->IsReady(), kMaxTimeoutMs);

	// Should have only one connection.
	EXPECT_EQ(1, relay_server_->GetConnectionCount());

	// Should be the TCP address.
	EXPECT_TRUE(relay_server_->HasConnection(kRelayTcpAddr));
	}

	void TestConnectSslTcp() {
	// Create a fake TCP address for relay port to simulate a failure.
	// We skip UDP here since transition from UDP to TCP has been
	// tested above.
	cricket::ProtocolAddress fake_protocol_address =
	cricket::ProtocolAddress(kRelayTcpAddr, cricket::PROTO_TCP);

	// Create a ssl server socket for the RelayServer.
	talk_base::AsyncSocket* ssl_server_socket =
	CreateServerSocket(kRelaySslAddr);
	relay_server_->AddInternalServerSocket(ssl_server_socket,
	cricket::PROTO_SSLTCP);

	// Create a tcp server socket that listens on the fake address so
	// the relay port can attempt to connect to it.
	talk_base::scoped_ptr<talk_base::AsyncSocket> tcp_server_socket(
	CreateServerSocket(kRelayTcpAddr));

	// Add server addresses to the relay port and let it start.
	relay_port_->AddServerAddress(fake_protocol_address);
	relay_port_->AddServerAddress(
	cricket::ProtocolAddress(kRelaySslAddr, cricket::PROTO_SSLTCP));
	relay_port_->PrepareAddress();
	EXPECT_FALSE(relay_port_->IsReady());

	// Should have timed out in 3000 ms(relayport.cc, kSoftConnectTimeoutMs).
	EXPECT_TRUE_WAIT_MARGIN(HasTimedOut(&fake_protocol_address), 3000, 100);

	// Wait until relayport is ready.
	EXPECT_TRUE_WAIT(relay_port_->IsReady(), kMaxTimeoutMs);

	// Should have only one connection.
	EXPECT_EQ(1, relay_server_->GetConnectionCount());

	// Should be the SSLTCP address.
	EXPECT_TRUE(relay_server_->HasConnection(kRelaySslAddr));
	}

	private:
	talk_base::AsyncUDPSocket* CreateAsyncUdpSocket(const SocketAddress addr) {
	talk_base::AsyncSocket* socket =
	virtual_socket_server_->CreateAsyncSocket(SOCK_DGRAM);
	talk_base::AsyncUDPSocket* packet_socket =
	talk_base::AsyncUDPSocket::Create(socket, addr);
	EXPECT_TRUE(packet_socket != NULL);
	packet_socket->SignalReadPacket.connect(this, &RelayPortTest::OnReadPacket);
	return packet_socket;
	}

	talk_base::AsyncSocket* CreateServerSocket(const SocketAddress addr) {
	talk_base::AsyncSocket* socket =
	virtual_socket_server_->CreateAsyncSocket(SOCK_STREAM);
	EXPECT_GE(socket->Bind(addr), 0);
	EXPECT_GE(socket->Listen(5), 0);
	return socket;
	}

	bool HasFailed(cricket::ProtocolAddress* addr) {
	for (size_t i = 0; i < failed_connections_.size(); i++) {
	if (failed_connections_[i].address == addr->address &&
	failed_connections_[i].proto == addr->proto) {
	return true;
	}
	}
	return false;
	}

	bool HasTimedOut(cricket::ProtocolAddress* addr) {
	for (size_t i = 0; i < soft_timedout_connections_.size(); i++) {
	if (soft_timedout_connections_[i].address == addr->address &&
	soft_timedout_connections_[i].proto == addr->proto) {
	return true;
	}
	}
	return false;
	}

	typedef std::map<talk_base::AsyncPacketSocket*, int> PacketMap;

	talk_base::Thread* main_;
	talk_base::scoped_ptr<talk_base::PhysicalSocketServer>
	physical_socket_server_;
	talk_base::scoped_ptr<talk_base::VirtualSocketServer> virtual_socket_server_;
	talk_base::SocketServerScope ss_scope_;
	talk_base::Network network_;
	talk_base::BasicPacketSocketFactory socket_factory_;
	std::string username_;
	std::string password_;
	talk_base::scoped_ptr<cricket::RelayPort> relay_port_;
	talk_base::scoped_ptr<cricket::RelayServer> relay_server_;
	std::vector<cricket::ProtocolAddress> failed_connections_;
	std::vector<cricket::ProtocolAddress> soft_timedout_connections_;
	PacketMap received_packet_count_;
	};

	TEST_F(RelayPortTest, ConnectUdp) {
	TestConnectUdp();
	}

	TEST_F(RelayPortTest, ConnectTcp) {
	TestConnectTcp();
	}

	TEST_F(RelayPortTest, ConnectSslTcp) {
	TestConnectSslTcp();
	}