Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(36)

Issues Search
    My Issues | Starred     Open | Closed | All

Unified Diff: webrtc/base/virtualsocket_unittest.cc

Issue 2859373003: Refactor TestClient to use std::unique_ptr, and fix VirtualSocketServerTest leaks. (Closed)
Patch Set: git cl format Created 3 years, 7 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View side-by-side diff with in-line comments
Download patch
« webrtc/base/testclient.h ('K') | « webrtc/base/testclient_unittest.cc ('k') | webrtc/p2p/base/relayserver_unittest.cc » ('j') | no next file with comments »
Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
Index: webrtc/base/virtualsocket_unittest.cc
diff --git a/webrtc/base/virtualsocket_unittest.cc b/webrtc/base/virtualsocket_unittest.cc
index e2f1d05f16f446fdaf4b95c36074978cff47606f..bf5be4e4f1439a19af2bddbbfbb0dfebbea0a401 100644
--- a/webrtc/base/virtualsocket_unittest.cc
+++ b/webrtc/base/virtualsocket_unittest.cc
@@ -17,8 +17,9 @@
#include <memory>
#include "webrtc/base/arraysize.h"
-#include "webrtc/base/logging.h"
#include "webrtc/base/gunit.h"
+#include "webrtc/base/logging.h"
+#include "webrtc/base/ptr_util.h"
#include "webrtc/base/testclient.h"
#include "webrtc/base/testutils.h"
#include "webrtc/base/thread.h"
@@ -38,7 +39,7 @@ using webrtc::testing::StreamSink;
struct Sender : public MessageHandler {
Sender(Thread* th, AsyncSocket* s, uint32_t rt)
: thread(th),
- socket(new AsyncUDPSocket(s)),
+ socket(MakeUnique<AsyncUDPSocket>(s)),
done(false),
rate(rt),
count(0) {
@@ -84,7 +85,7 @@ struct Sender : public MessageHandler {
struct Receiver : public MessageHandler, public sigslot::has_slots<> {
Receiver(Thread* th, AsyncSocket* s, uint32_t bw)
: thread(th),
- socket(new AsyncUDPSocket(s)),
+ socket(MakeUnique<AsyncUDPSocket>(s)),
bandwidth(bw),
done(false),
count(0),
@@ -145,7 +146,7 @@ struct Receiver : public MessageHandler, public sigslot::has_slots<> {
class VirtualSocketServerTest : public testing::Test {
public:
VirtualSocketServerTest()
- : ss_(new VirtualSocketServer(nullptr)),
+ : ss_(nullptr),
kIPv4AnyAddress(IPAddress(INADDR_ANY), 0),
kIPv6AnyAddress(IPAddress(in6addr_any), 0) {}
@@ -172,23 +173,23 @@ class VirtualSocketServerTest : public testing::Test {
// the default route as the source address. Also, it can receive packets sent
// to the default route.
void TestDefaultRoute(const IPAddress& default_route) {
- ss_->SetDefaultRoute(default_route);
+ ss_.SetDefaultRoute(default_route);
// Create client1 bound to the any address.
AsyncSocket* socket =
- ss_->CreateAsyncSocket(default_route.family(), SOCK_DGRAM);
+ ss_.CreateAsyncSocket(default_route.family(), SOCK_DGRAM);
socket->Bind(EmptySocketAddressWithFamily(default_route.family()));
SocketAddress client1_any_addr = socket->GetLocalAddress();
EXPECT_TRUE(client1_any_addr.IsAnyIP());
- TestClient* client1 = new TestClient(new AsyncUDPSocket(socket));
+ auto client1 = MakeUnique<TestClient>(MakeUnique<AsyncUDPSocket>(socket));
// Create client2 bound to the default route.
AsyncSocket* socket2 =
- ss_->CreateAsyncSocket(default_route.family(), SOCK_DGRAM);
+ ss_.CreateAsyncSocket(default_route.family(), SOCK_DGRAM);
socket2->Bind(SocketAddress(default_route, 0));
SocketAddress client2_addr = socket2->GetLocalAddress();
EXPECT_FALSE(client2_addr.IsAnyIP());
- TestClient* client2 = new TestClient(new AsyncUDPSocket(socket2));
+ auto client2 = MakeUnique<TestClient>(MakeUnique<AsyncUDPSocket>(socket2));
// Client1 sends to client2, client2 should see the default route as
// client1's address.
@@ -204,17 +205,17 @@ class VirtualSocketServerTest : public testing::Test {
}
void BasicTest(const SocketAddress& initial_addr) {
- AsyncSocket* socket = ss_->CreateAsyncSocket(initial_addr.family(),
- SOCK_DGRAM);
+ AsyncSocket* socket =
+ ss_.CreateAsyncSocket(initial_addr.family(), SOCK_DGRAM);
socket->Bind(initial_addr);
SocketAddress server_addr = socket->GetLocalAddress();
// Make sure VSS didn't switch families on us.
EXPECT_EQ(server_addr.family(), initial_addr.family());
- TestClient* client1 = new TestClient(new AsyncUDPSocket(socket));
+ auto client1 = MakeUnique<TestClient>(MakeUnique<AsyncUDPSocket>(socket));
AsyncSocket* socket2 =
- ss_->CreateAsyncSocket(initial_addr.family(), SOCK_DGRAM);
- TestClient* client2 = new TestClient(new AsyncUDPSocket(socket2));
+ ss_.CreateAsyncSocket(initial_addr.family(), SOCK_DGRAM);
+ auto client2 = MakeUnique<TestClient>(MakeUnique<AsyncUDPSocket>(socket2));
SocketAddress client2_addr;
EXPECT_EQ(3, client2->SendTo("foo", 3, server_addr));
@@ -227,7 +228,8 @@ class VirtualSocketServerTest : public testing::Test {
SocketAddress empty = EmptySocketAddressWithFamily(initial_addr.family());
for (int i = 0; i < 10; i++) {
- client2 = new TestClient(AsyncUDPSocket::Create(ss_, empty));
+ client2 = MakeUnique<TestClient>(
+ WrapUnique(AsyncUDPSocket::Create(&ss_, empty)));
SocketAddress next_client2_addr;
EXPECT_EQ(3, client2->SendTo("foo", 3, server_addr));
@@ -252,15 +254,15 @@ class VirtualSocketServerTest : public testing::Test {
EmptySocketAddressWithFamily(initial_addr.family());
// Create client
- AsyncSocket* client = ss_->CreateAsyncSocket(initial_addr.family(),
- SOCK_STREAM);
+ AsyncSocket* client =
+ ss_.CreateAsyncSocket(initial_addr.family(), SOCK_STREAM);
sink.Monitor(client);
EXPECT_EQ(client->GetState(), AsyncSocket::CS_CLOSED);
EXPECT_TRUE(client->GetLocalAddress().IsNil());
// Create server
- AsyncSocket* server = ss_->CreateAsyncSocket(initial_addr.family(),
- SOCK_STREAM);
+ AsyncSocket* server =
+ ss_.CreateAsyncSocket(initial_addr.family(), SOCK_STREAM);
sink.Monitor(server);
EXPECT_NE(0, server->Listen(5)); // Bind required
EXPECT_EQ(0, server->Bind(initial_addr));
@@ -284,7 +286,7 @@ class VirtualSocketServerTest : public testing::Test {
EXPECT_FALSE(sink.Check(client, SSE_OPEN));
EXPECT_FALSE(sink.Check(client, SSE_CLOSE));
- ss_->ProcessMessagesUntilIdle();
+ ss_.ProcessMessagesUntilIdle();
// Client still connecting
EXPECT_EQ(client->GetState(), AsyncSocket::CS_CONNECTING);
@@ -302,7 +304,7 @@ class VirtualSocketServerTest : public testing::Test {
EXPECT_EQ(accepted->GetLocalAddress(), server->GetLocalAddress());
EXPECT_EQ(accepted->GetRemoteAddress(), client->GetLocalAddress());
- ss_->ProcessMessagesUntilIdle();
+ ss_.ProcessMessagesUntilIdle();
// Client has connected
EXPECT_EQ(client->GetState(), AsyncSocket::CS_CONNECTED);
@@ -320,20 +322,20 @@ class VirtualSocketServerTest : public testing::Test {
EmptySocketAddressWithFamily(initial_addr.family());
// Create client
- AsyncSocket* client = ss_->CreateAsyncSocket(initial_addr.family(),
- SOCK_STREAM);
+ AsyncSocket* client =
+ ss_.CreateAsyncSocket(initial_addr.family(), SOCK_STREAM);
sink.Monitor(client);
// Create server
- AsyncSocket* server = ss_->CreateAsyncSocket(initial_addr.family(),
- SOCK_STREAM);
+ AsyncSocket* server =
+ ss_.CreateAsyncSocket(initial_addr.family(), SOCK_STREAM);
sink.Monitor(server);
EXPECT_EQ(0, server->Bind(initial_addr));
EXPECT_EQ(server->GetLocalAddress().family(), initial_addr.family());
// Attempt connect to non-listening socket
EXPECT_EQ(0, client->Connect(server->GetLocalAddress()));
- ss_->ProcessMessagesUntilIdle();
+ ss_.ProcessMessagesUntilIdle();
// No pending server connections
EXPECT_FALSE(sink.Check(server, SSE_READ));
@@ -355,10 +357,10 @@ class VirtualSocketServerTest : public testing::Test {
// Create client and server
std::unique_ptr<AsyncSocket> client(
- ss_->CreateAsyncSocket(initial_addr.family(), SOCK_STREAM));
+ ss_.CreateAsyncSocket(initial_addr.family(), SOCK_STREAM));
sink.Monitor(client.get());
std::unique_ptr<AsyncSocket> server(
- ss_->CreateAsyncSocket(initial_addr.family(), SOCK_STREAM));
+ ss_.CreateAsyncSocket(initial_addr.family(), SOCK_STREAM));
sink.Monitor(server.get());
// Initiate connect
@@ -372,13 +374,13 @@ class VirtualSocketServerTest : public testing::Test {
EXPECT_FALSE(sink.Check(server.get(), SSE_READ));
server->Close();
- ss_->ProcessMessagesUntilIdle();
+ ss_.ProcessMessagesUntilIdle();
// Result: connection failed
EXPECT_EQ(client->GetState(), AsyncSocket::CS_CLOSED);
EXPECT_TRUE(sink.Check(client.get(), SSE_ERROR));
- server.reset(ss_->CreateAsyncSocket(initial_addr.family(), SOCK_STREAM));
+ server.reset(ss_.CreateAsyncSocket(initial_addr.family(), SOCK_STREAM));
sink.Monitor(server.get());
// Initiate connect
@@ -388,20 +390,20 @@ class VirtualSocketServerTest : public testing::Test {
EXPECT_EQ(0, server->Listen(5));
EXPECT_EQ(0, client->Connect(server->GetLocalAddress()));
- ss_->ProcessMessagesUntilIdle();
+ ss_.ProcessMessagesUntilIdle();
// Server close while socket is in accept queue
EXPECT_TRUE(sink.Check(server.get(), SSE_READ));
server->Close();
- ss_->ProcessMessagesUntilIdle();
+ ss_.ProcessMessagesUntilIdle();
// Result: connection failed
EXPECT_EQ(client->GetState(), AsyncSocket::CS_CLOSED);
EXPECT_TRUE(sink.Check(client.get(), SSE_ERROR));
// New server
- server.reset(ss_->CreateAsyncSocket(initial_addr.family(), SOCK_STREAM));
+ server.reset(ss_.CreateAsyncSocket(initial_addr.family(), SOCK_STREAM));
sink.Monitor(server.get());
// Initiate connect
@@ -411,7 +413,7 @@ class VirtualSocketServerTest : public testing::Test {
EXPECT_EQ(0, server->Listen(5));
EXPECT_EQ(0, client->Connect(server->GetLocalAddress()));
- ss_->ProcessMessagesUntilIdle();
+ ss_.ProcessMessagesUntilIdle();
// Server accepts connection
EXPECT_TRUE(sink.Check(server.get(), SSE_READ));
@@ -426,7 +428,7 @@ class VirtualSocketServerTest : public testing::Test {
EXPECT_EQ(client->GetState(), AsyncSocket::CS_CONNECTING);
client->Close();
- ss_->ProcessMessagesUntilIdle();
+ ss_.ProcessMessagesUntilIdle();
// Result: accepted socket closes
EXPECT_EQ(accepted->GetState(), AsyncSocket::CS_CLOSED);
@@ -439,13 +441,13 @@ class VirtualSocketServerTest : public testing::Test {
const SocketAddress kEmptyAddr;
// Create clients
- AsyncSocket* a = ss_->CreateAsyncSocket(initial_addr.family(), SOCK_STREAM);
+ AsyncSocket* a = ss_.CreateAsyncSocket(initial_addr.family(), SOCK_STREAM);
sink.Monitor(a);
a->Bind(initial_addr);
EXPECT_EQ(a->GetLocalAddress().family(), initial_addr.family());
std::unique_ptr<AsyncSocket> b(
- ss_->CreateAsyncSocket(initial_addr.family(), SOCK_STREAM));
+ ss_.CreateAsyncSocket(initial_addr.family(), SOCK_STREAM));
sink.Monitor(b.get());
b->Bind(initial_addr);
EXPECT_EQ(b->GetLocalAddress().family(), initial_addr.family());
@@ -453,7 +455,7 @@ class VirtualSocketServerTest : public testing::Test {
EXPECT_EQ(0, a->Connect(b->GetLocalAddress()));
EXPECT_EQ(0, b->Connect(a->GetLocalAddress()));
- ss_->ProcessMessagesUntilIdle();
+ ss_.ProcessMessagesUntilIdle();
EXPECT_TRUE(sink.Check(a, SSE_OPEN));
EXPECT_EQ(a->GetState(), AsyncSocket::CS_CONNECTED);
@@ -467,7 +469,7 @@ class VirtualSocketServerTest : public testing::Test {
b->Close();
EXPECT_EQ(1, a->Send("b", 1));
- ss_->ProcessMessagesUntilIdle();
+ ss_.ProcessMessagesUntilIdle();
char buffer[10];
EXPECT_FALSE(sink.Check(b.get(), SSE_READ));
@@ -488,12 +490,12 @@ class VirtualSocketServerTest : public testing::Test {
const SocketAddress kEmptyAddr;
// Connect two sockets
- AsyncSocket* a = ss_->CreateAsyncSocket(initial_addr.family(), SOCK_STREAM);
+ AsyncSocket* a = ss_.CreateAsyncSocket(initial_addr.family(), SOCK_STREAM);
sink.Monitor(a);
a->Bind(initial_addr);
EXPECT_EQ(a->GetLocalAddress().family(), initial_addr.family());
- AsyncSocket* b = ss_->CreateAsyncSocket(initial_addr.family(), SOCK_STREAM);
+ AsyncSocket* b = ss_.CreateAsyncSocket(initial_addr.family(), SOCK_STREAM);
sink.Monitor(b);
b->Bind(initial_addr);
EXPECT_EQ(b->GetLocalAddress().family(), initial_addr.family());
@@ -501,11 +503,11 @@ class VirtualSocketServerTest : public testing::Test {
EXPECT_EQ(0, a->Connect(b->GetLocalAddress()));
EXPECT_EQ(0, b->Connect(a->GetLocalAddress()));
- ss_->ProcessMessagesUntilIdle();
+ ss_.ProcessMessagesUntilIdle();
const size_t kBufferSize = 2000;
- ss_->set_send_buffer_capacity(kBufferSize);
- ss_->set_recv_buffer_capacity(kBufferSize);
+ ss_.set_send_buffer_capacity(kBufferSize);
+ ss_.set_recv_buffer_capacity(kBufferSize);
const size_t kDataSize = 5000;
char send_buffer[kDataSize], recv_buffer[kDataSize];
@@ -519,7 +521,7 @@ class VirtualSocketServerTest : public testing::Test {
EXPECT_EQ(static_cast<int>(kBufferSize), result);
send_pos += result;
- ss_->ProcessMessagesUntilIdle();
+ ss_.ProcessMessagesUntilIdle();
EXPECT_FALSE(sink.Check(a, SSE_WRITE));
EXPECT_TRUE(sink.Check(b, SSE_READ));
@@ -528,7 +530,7 @@ class VirtualSocketServerTest : public testing::Test {
EXPECT_EQ(static_cast<int>(kBufferSize), result);
send_pos += result;
- ss_->ProcessMessagesUntilIdle();
+ ss_.ProcessMessagesUntilIdle();
EXPECT_FALSE(sink.Check(a, SSE_WRITE));
EXPECT_FALSE(sink.Check(b, SSE_READ));
@@ -542,7 +544,7 @@ class VirtualSocketServerTest : public testing::Test {
EXPECT_EQ(500, result);
recv_pos += result;
- ss_->ProcessMessagesUntilIdle();
+ ss_.ProcessMessagesUntilIdle();
EXPECT_TRUE(sink.Check(a, SSE_WRITE));
EXPECT_TRUE(sink.Check(b, SSE_READ));
@@ -562,7 +564,7 @@ class VirtualSocketServerTest : public testing::Test {
recv_pos += result;
}
- ss_->ProcessMessagesUntilIdle();
+ ss_.ProcessMessagesUntilIdle();
EXPECT_TRUE(sink.Check(b, SSE_READ));
// Continue to empty the recv buffer
@@ -581,7 +583,7 @@ class VirtualSocketServerTest : public testing::Test {
EXPECT_EQ(500, result);
send_pos += result;
- ss_->ProcessMessagesUntilIdle();
+ ss_.ProcessMessagesUntilIdle();
EXPECT_TRUE(sink.Check(b, SSE_READ));
// Receive the last of the data
@@ -595,7 +597,7 @@ class VirtualSocketServerTest : public testing::Test {
recv_pos += result;
}
- ss_->ProcessMessagesUntilIdle();
+ ss_.ProcessMessagesUntilIdle();
EXPECT_FALSE(sink.Check(b, SSE_READ));
// The received data matches the sent data
@@ -608,10 +610,8 @@ class VirtualSocketServerTest : public testing::Test {
const SocketAddress kEmptyAddr;
// Connect two sockets
- AsyncSocket* a = ss_->CreateAsyncSocket(initial_addr.family(),
- SOCK_STREAM);
- AsyncSocket* b = ss_->CreateAsyncSocket(initial_addr.family(),
- SOCK_STREAM);
+ AsyncSocket* a = ss_.CreateAsyncSocket(initial_addr.family(), SOCK_STREAM);
+ AsyncSocket* b = ss_.CreateAsyncSocket(initial_addr.family(), SOCK_STREAM);
a->Bind(initial_addr);
EXPECT_EQ(a->GetLocalAddress().family(), initial_addr.family());
@@ -620,7 +620,7 @@ class VirtualSocketServerTest : public testing::Test {
EXPECT_EQ(0, a->Connect(b->GetLocalAddress()));
EXPECT_EQ(0, b->Connect(a->GetLocalAddress()));
- ss_->ProcessMessagesUntilIdle();
+ ss_.ProcessMessagesUntilIdle();
// First, deliver all packets in 0 ms.
char buffer[2] = { 0, 0 };
@@ -630,7 +630,7 @@ class VirtualSocketServerTest : public testing::Test {
EXPECT_EQ(1, a->Send(buffer, 1));
}
- ss_->ProcessMessagesUntilIdle();
+ ss_.ProcessMessagesUntilIdle();
for (char i = 0; i < cNumPackets; ++i) {
EXPECT_EQ(1, b->Recv(buffer, sizeof(buffer), nullptr));
@@ -641,16 +641,16 @@ class VirtualSocketServerTest : public testing::Test {
const uint32_t mean = 50;
const uint32_t stddev = 50;
- ss_->set_delay_mean(mean);
- ss_->set_delay_stddev(stddev);
- ss_->UpdateDelayDistribution();
+ ss_.set_delay_mean(mean);
+ ss_.set_delay_stddev(stddev);
+ ss_.UpdateDelayDistribution();
for (char i = 0; i < cNumPackets; ++i) {
buffer[0] = 'A' + i;
EXPECT_EQ(1, a->Send(buffer, 1));
}
- ss_->ProcessMessagesUntilIdle();
+ ss_.ProcessMessagesUntilIdle();
for (char i = 0; i < cNumPackets; ++i) {
EXPECT_EQ(1, b->Recv(buffer, sizeof(buffer), nullptr));
@@ -663,9 +663,9 @@ class VirtualSocketServerTest : public testing::Test {
// address.
void BandwidthTest(const SocketAddress& initial_addr) {
AsyncSocket* send_socket =
- ss_->CreateAsyncSocket(initial_addr.family(), SOCK_DGRAM);
+ ss_.CreateAsyncSocket(initial_addr.family(), SOCK_DGRAM);
AsyncSocket* recv_socket =
- ss_->CreateAsyncSocket(initial_addr.family(), SOCK_DGRAM);
+ ss_.CreateAsyncSocket(initial_addr.family(), SOCK_DGRAM);
ASSERT_EQ(0, send_socket->Bind(initial_addr));
ASSERT_EQ(0, recv_socket->Bind(initial_addr));
EXPECT_EQ(send_socket->GetLocalAddress().family(), initial_addr.family());
@@ -673,7 +673,7 @@ class VirtualSocketServerTest : public testing::Test {
ASSERT_EQ(0, send_socket->Connect(recv_socket->GetLocalAddress()));
uint32_t bandwidth = 64 * 1024;
- ss_->set_bandwidth(bandwidth);
+ ss_.set_bandwidth(bandwidth);
Thread* pthMain = Thread::Current();
Sender sender(pthMain, send_socket, 80 * 1024);
@@ -686,7 +686,7 @@ class VirtualSocketServerTest : public testing::Test {
ASSERT_TRUE(receiver.count >= 5 * 3 * bandwidth / 4);
ASSERT_TRUE(receiver.count <= 6 * bandwidth); // queue could drain for 1s
- ss_->set_bandwidth(0);
+ ss_.set_bandwidth(0);
}
// It is important that initial_addr's port has to be 0 such that the
@@ -700,14 +700,14 @@ class VirtualSocketServerTest : public testing::Test {
const uint32_t mean = 2000;
const uint32_t stddev = 500;
- ss_->set_delay_mean(mean);
- ss_->set_delay_stddev(stddev);
- ss_->UpdateDelayDistribution();
+ ss_.set_delay_mean(mean);
+ ss_.set_delay_stddev(stddev);
+ ss_.UpdateDelayDistribution();
AsyncSocket* send_socket =
- ss_->CreateAsyncSocket(initial_addr.family(), SOCK_DGRAM);
+ ss_.CreateAsyncSocket(initial_addr.family(), SOCK_DGRAM);
AsyncSocket* recv_socket =
- ss_->CreateAsyncSocket(initial_addr.family(), SOCK_DGRAM);
+ ss_.CreateAsyncSocket(initial_addr.family(), SOCK_DGRAM);
ASSERT_EQ(0, send_socket->Bind(initial_addr));
ASSERT_EQ(0, recv_socket->Bind(initial_addr));
EXPECT_EQ(send_socket->GetLocalAddress().family(), initial_addr.family());
@@ -722,7 +722,7 @@ class VirtualSocketServerTest : public testing::Test {
pthMain->ProcessMessages(10000);
sender.done = receiver.done = true;
- ss_->ProcessMessagesUntilIdle();
+ ss_.ProcessMessagesUntilIdle();
const double sample_mean = receiver.sum / receiver.samples;
double num =
@@ -737,9 +737,9 @@ class VirtualSocketServerTest : public testing::Test {
EXPECT_NEAR(mean, sample_mean, 0.15 * mean);
EXPECT_NEAR(stddev, sample_stddev, 0.15 * stddev);
- ss_->set_delay_mean(0);
- ss_->set_delay_stddev(0);
- ss_->UpdateDelayDistribution();
+ ss_.set_delay_mean(0);
+ ss_.set_delay_stddev(0);
+ ss_.UpdateDelayDistribution();
}
// Test cross-family communication between a client bound to client_addr and a
@@ -753,8 +753,8 @@ class VirtualSocketServerTest : public testing::Test {
const SocketAddress kEmptyAddr;
// Client gets a IPv4 address
- AsyncSocket* client = ss_->CreateAsyncSocket(client_addr.family(),
- SOCK_STREAM);
+ AsyncSocket* client =
+ ss_.CreateAsyncSocket(client_addr.family(), SOCK_STREAM);
sink.Monitor(client);
EXPECT_EQ(client->GetState(), AsyncSocket::CS_CLOSED);
EXPECT_EQ(client->GetLocalAddress(), kEmptyAddr);
@@ -762,26 +762,26 @@ class VirtualSocketServerTest : public testing::Test {
// Server gets a non-mapped non-any IPv6 address.
// IPv4 sockets should not be able to connect to this.
- AsyncSocket* server = ss_->CreateAsyncSocket(server_addr.family(),
- SOCK_STREAM);
+ AsyncSocket* server =
+ ss_.CreateAsyncSocket(server_addr.family(), SOCK_STREAM);
sink.Monitor(server);
server->Bind(server_addr);
server->Listen(5);
if (shouldSucceed) {
EXPECT_EQ(0, client->Connect(server->GetLocalAddress()));
- ss_->ProcessMessagesUntilIdle();
+ ss_.ProcessMessagesUntilIdle();
EXPECT_TRUE(sink.Check(server, SSE_READ));
Socket* accepted = server->Accept(&accept_address);
EXPECT_TRUE(nullptr != accepted);
EXPECT_NE(kEmptyAddr, accept_address);
- ss_->ProcessMessagesUntilIdle();
+ ss_.ProcessMessagesUntilIdle();
EXPECT_TRUE(sink.Check(client, SSE_OPEN));
EXPECT_EQ(client->GetRemoteAddress(), server->GetLocalAddress());
} else {
// Check that the connection failed.
EXPECT_EQ(-1, client->Connect(server->GetLocalAddress()));
- ss_->ProcessMessagesUntilIdle();
+ ss_.ProcessMessagesUntilIdle();
EXPECT_FALSE(sink.Check(server, SSE_READ));
EXPECT_TRUE(nullptr == server->Accept(&accept_address));
@@ -798,14 +798,14 @@ class VirtualSocketServerTest : public testing::Test {
void CrossFamilyDatagramTest(const SocketAddress& client_addr,
const SocketAddress& server_addr,
bool shouldSucceed) {
- AsyncSocket* socket = ss_->CreateAsyncSocket(SOCK_DGRAM);
+ AsyncSocket* socket = ss_.CreateAsyncSocket(SOCK_DGRAM);
socket->Bind(server_addr);
SocketAddress bound_server_addr = socket->GetLocalAddress();
- TestClient* client1 = new TestClient(new AsyncUDPSocket(socket));
+ auto client1 = MakeUnique<TestClient>(MakeUnique<AsyncUDPSocket>(socket));
- AsyncSocket* socket2 = ss_->CreateAsyncSocket(SOCK_DGRAM);
+ AsyncSocket* socket2 = ss_.CreateAsyncSocket(SOCK_DGRAM);
socket2->Bind(client_addr);
- TestClient* client2 = new TestClient(new AsyncUDPSocket(socket2));
+ auto client2 = MakeUnique<TestClient>(MakeUnique<AsyncUDPSocket>(socket2));
SocketAddress client2_addr;
if (shouldSucceed) {
@@ -822,12 +822,10 @@ class VirtualSocketServerTest : public testing::Test {
}
protected:
- virtual void SetUp() {
- Thread::Current()->set_socketserver(ss_);
- }
+ virtual void SetUp() { Thread::Current()->set_socketserver(&ss_); }
virtual void TearDown() { Thread::Current()->set_socketserver(nullptr); }
- VirtualSocketServer* ss_;
+ VirtualSocketServer ss_;
const SocketAddress kIPv4AnyAddress;
const SocketAddress kIPv6AnyAddress;
};
@@ -1025,33 +1023,33 @@ TEST_F(VirtualSocketServerTest, CanSendDatagramFromUnboundIPv6ToIPv4Any) {
TEST_F(VirtualSocketServerTest, SetSendingBlockedWithUdpSocket) {
AsyncSocket* socket1 =
- ss_->CreateAsyncSocket(kIPv4AnyAddress.family(), SOCK_DGRAM);
+ ss_.CreateAsyncSocket(kIPv4AnyAddress.family(), SOCK_DGRAM);
AsyncSocket* socket2 =
- ss_->CreateAsyncSocket(kIPv4AnyAddress.family(), SOCK_DGRAM);
+ ss_.CreateAsyncSocket(kIPv4AnyAddress.family(), SOCK_DGRAM);
socket1->Bind(kIPv4AnyAddress);
socket2->Bind(kIPv4AnyAddress);
- TestClient* client1 = new TestClient(new AsyncUDPSocket(socket1));
+ auto client1 = MakeUnique<TestClient>(MakeUnique<AsyncUDPSocket>(socket1));
- ss_->SetSendingBlocked(true);
+ ss_.SetSendingBlocked(true);
EXPECT_EQ(-1, client1->SendTo("foo", 3, socket2->GetLocalAddress()));
EXPECT_TRUE(socket1->IsBlocking());
EXPECT_EQ(0, client1->ready_to_send_count());
- ss_->SetSendingBlocked(false);
+ ss_.SetSendingBlocked(false);
EXPECT_EQ(1, client1->ready_to_send_count());
EXPECT_EQ(3, client1->SendTo("foo", 3, socket2->GetLocalAddress()));
}
TEST_F(VirtualSocketServerTest, SetSendingBlockedWithTcpSocket) {
constexpr size_t kBufferSize = 1024;
- ss_->set_send_buffer_capacity(kBufferSize);
- ss_->set_recv_buffer_capacity(kBufferSize);
+ ss_.set_send_buffer_capacity(kBufferSize);
+ ss_.set_recv_buffer_capacity(kBufferSize);
StreamSink sink;
AsyncSocket* socket1 =
- ss_->CreateAsyncSocket(kIPv4AnyAddress.family(), SOCK_STREAM);
+ ss_.CreateAsyncSocket(kIPv4AnyAddress.family(), SOCK_STREAM);
AsyncSocket* socket2 =
- ss_->CreateAsyncSocket(kIPv4AnyAddress.family(), SOCK_STREAM);
+ ss_.CreateAsyncSocket(kIPv4AnyAddress.family(), SOCK_STREAM);
sink.Monitor(socket1);
sink.Monitor(socket2);
socket1->Bind(kIPv4AnyAddress);
@@ -1060,14 +1058,14 @@ TEST_F(VirtualSocketServerTest, SetSendingBlockedWithTcpSocket) {
// Connect sockets.
EXPECT_EQ(0, socket1->Connect(socket2->GetLocalAddress()));
EXPECT_EQ(0, socket2->Connect(socket1->GetLocalAddress()));
- ss_->ProcessMessagesUntilIdle();
+ ss_.ProcessMessagesUntilIdle();
char data[kBufferSize] = {};
// First Send call will fill the send buffer but not send anything.
- ss_->SetSendingBlocked(true);
+ ss_.SetSendingBlocked(true);
EXPECT_EQ(static_cast<int>(kBufferSize), socket1->Send(data, kBufferSize));
- ss_->ProcessMessagesUntilIdle();
+ ss_.ProcessMessagesUntilIdle();
EXPECT_FALSE(sink.Check(socket1, SSE_WRITE));
EXPECT_FALSE(sink.Check(socket2, SSE_READ));
EXPECT_FALSE(socket1->IsBlocking());
@@ -1080,8 +1078,8 @@ TEST_F(VirtualSocketServerTest, SetSendingBlockedWithTcpSocket) {
// When sending is unblocked, the buffered data should be sent and
// SignalWriteEvent should fire.
- ss_->SetSendingBlocked(false);
- ss_->ProcessMessagesUntilIdle();
+ ss_.SetSendingBlocked(false);
+ ss_.ProcessMessagesUntilIdle();
EXPECT_TRUE(sink.Check(socket1, SSE_WRITE));
EXPECT_TRUE(sink.Check(socket2, SSE_READ));
}
« webrtc/base/testclient.h ('K') | « webrtc/base/testclient_unittest.cc ('k') | webrtc/p2p/base/relayserver_unittest.cc » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698