zqz/platform-external-webrtc
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Update socket unittests to not use rtc::Thread::socketserver()

Browse Source 
Bug: webrtc:13145
Change-Id: I714e2002697f988c73155e6d8febefc6aff4e34b
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/231540
Reviewed-by: Mirko Bonadei <mbonadei@webrtc.org>
Commit-Queue: Niels Moller <nisse@webrtc.org>
Cr-Commit-Position: refs/heads/main@{#34951}
This commit is contained in:
Niels Möller
2021-09-08 14:05:16 +02:00
committed by WebRTC LUCI CQ
parent 32b6bc455c
commit 50f7c2cc27
4 changed files with 59 additions and 63 deletions
Download Patch File Download Diff File Expand all files Collapse all files

31
rtc_base/physical_socket_server_unittest.cc
View File

@ -116,15 +116,16 @@ class PhysicalSocketTest : public SocketTest {
protected:
PhysicalSocketTest()
: server_(new FakePhysicalSocketServer(this)),
thread_(server_.get()),
: SocketTest(&server_),
server_(this),
thread_(&server_),
fail_accept_(false),
max_send_size_(-1) {}
void ConnectInternalAcceptError(const IPAddress& loopback);
void WritableAfterPartialWrite(const IPAddress& loopback);
std::unique_ptr<FakePhysicalSocketServer> server_;
FakePhysicalSocketServer server_;
rtc::AutoSocketServerThread thread_;
bool fail_accept_;
int max_send_size_;
@ -200,20 +201,20 @@ void PhysicalSocketTest::ConnectInternalAcceptError(const IPAddress& loopback) {
// Create two clients.
std::unique_ptr<Socket> client1(
server_->CreateSocket(loopback.family(), SOCK_STREAM));
server_.CreateSocket(loopback.family(), SOCK_STREAM));
sink.Monitor(client1.get());
EXPECT_EQ(Socket::CS_CLOSED, client1->GetState());
EXPECT_TRUE(IsUnspecOrEmptyIP(client1->GetLocalAddress().ipaddr()));
std::unique_ptr<Socket> client2(
server_->CreateSocket(loopback.family(), SOCK_STREAM));
server_.CreateSocket(loopback.family(), SOCK_STREAM));
sink.Monitor(client2.get());
EXPECT_EQ(Socket::CS_CLOSED, client2->GetState());
EXPECT_TRUE(IsUnspecOrEmptyIP(client2->GetLocalAddress().ipaddr()));
// Create server and listen.
std::unique_ptr<Socket> server(
server_->CreateSocket(loopback.family(), SOCK_STREAM));
server_.CreateSocket(loopback.family(), SOCK_STREAM));
sink.Monitor(server.get());
EXPECT_EQ(0, server->Bind(SocketAddress(loopback, 0)));
EXPECT_EQ(0, server->Listen(5));
@ -477,22 +478,22 @@ TEST_F(PhysicalSocketTest,
BindFailsIfNetworkBinderFailsForNonLoopbackInterface) {
MAYBE_SKIP_IPV4;
FakeNetworkBinder fake_network_binder;
server_->set_network_binder(&fake_network_binder);
std::unique_ptr<Socket> socket(server_->CreateSocket(AF_INET, SOCK_DGRAM));
server_.set_network_binder(&fake_network_binder);
std::unique_ptr<Socket> socket(server_.CreateSocket(AF_INET, SOCK_DGRAM));
fake_network_binder.set_result(NetworkBindingResult::FAILURE);
EXPECT_EQ(-1, socket->Bind(SocketAddress("192.168.0.1", 0)));
server_->set_network_binder(nullptr);
server_.set_network_binder(nullptr);
}
// Network binder shouldn't be used if the socket is bound to the "any" IP.
TEST_F(PhysicalSocketTest, NetworkBinderIsNotUsedForAnyIp) {
MAYBE_SKIP_IPV4;
FakeNetworkBinder fake_network_binder;
server_->set_network_binder(&fake_network_binder);
std::unique_ptr<Socket> socket(server_->CreateSocket(AF_INET, SOCK_DGRAM));
server_.set_network_binder(&fake_network_binder);
std::unique_ptr<Socket> socket(server_.CreateSocket(AF_INET, SOCK_DGRAM));
EXPECT_EQ(0, socket->Bind(SocketAddress("0.0.0.0", 0)));
EXPECT_EQ(0, fake_network_binder.num_binds());
server_->set_network_binder(nullptr);
server_.set_network_binder(nullptr);
}
// For a loopback interface, failures to bind to the interface should be
@ -501,11 +502,11 @@ TEST_F(PhysicalSocketTest,
BindSucceedsIfNetworkBinderFailsForLoopbackInterface) {
MAYBE_SKIP_IPV4;
FakeNetworkBinder fake_network_binder;
server_->set_network_binder(&fake_network_binder);
std::unique_ptr<Socket> socket(server_->CreateSocket(AF_INET, SOCK_DGRAM));
server_.set_network_binder(&fake_network_binder);
std::unique_ptr<Socket> socket(server_.CreateSocket(AF_INET, SOCK_DGRAM));
fake_network_binder.set_result(NetworkBindingResult::FAILURE);
EXPECT_EQ(0, socket->Bind(SocketAddress(kIPv4Loopback, 0)));
server_->set_network_binder(nullptr);
server_.set_network_binder(nullptr);
}
#endif

82
rtc_base/socket_unittest.cc
View File

@ -53,10 +53,6 @@ using webrtc::testing::StreamSink;
// Data size to be used in TcpInternal tests.
static const size_t kTcpInternalDataSize = 1024 * 1024; // bytes
void SocketTest::SetUp() {
ss_ = Thread::Current()->socketserver();
}
void SocketTest::TestConnectIPv4() {
ConnectInternal(kIPv4Loopback);
}
@ -242,14 +238,14 @@ void SocketTest::ConnectInternal(const IPAddress& loopback) {
// Create client.
std::unique_ptr<Socket> client(
ss_->CreateSocket(loopback.family(), SOCK_STREAM));
socket_factory_->CreateSocket(loopback.family(), SOCK_STREAM));
sink.Monitor(client.get());
EXPECT_EQ(Socket::CS_CLOSED, client->GetState());
EXPECT_TRUE(IsUnspecOrEmptyIP(client->GetLocalAddress().ipaddr()));
// Create server and listen.
std::unique_ptr<Socket> server(
ss_->CreateSocket(loopback.family(), SOCK_STREAM));
socket_factory_->CreateSocket(loopback.family(), SOCK_STREAM));
sink.Monitor(server.get());
EXPECT_EQ(0, server->Bind(SocketAddress(loopback, 0)));
EXPECT_EQ(0, server->Listen(5));
@ -297,12 +293,12 @@ void SocketTest::ConnectWithDnsLookupInternal(const IPAddress& loopback,
// Create client.
std::unique_ptr<Socket> client(
ss_->CreateSocket(loopback.family(), SOCK_STREAM));
socket_factory_->CreateSocket(loopback.family(), SOCK_STREAM));
sink.Monitor(client.get());
// Create server and listen.
std::unique_ptr<Socket> server(
ss_->CreateSocket(loopback.family(), SOCK_STREAM));
socket_factory_->CreateSocket(loopback.family(), SOCK_STREAM));
sink.Monitor(server.get());
EXPECT_EQ(0, server->Bind(SocketAddress(loopback, 0)));
EXPECT_EQ(0, server->Listen(5));
@ -345,12 +341,12 @@ void SocketTest::ConnectFailInternal(const IPAddress& loopback) {
// Create client.
std::unique_ptr<Socket> client(
ss_->CreateSocket(loopback.family(), SOCK_STREAM));
socket_factory_->CreateSocket(loopback.family(), SOCK_STREAM));
sink.Monitor(client.get());
// Create server, but don't listen yet.
std::unique_ptr<Socket> server(
ss_->CreateSocket(loopback.family(), SOCK_STREAM));
socket_factory_->CreateSocket(loopback.family(), SOCK_STREAM));
sink.Monitor(server.get());
EXPECT_EQ(0, server->Bind(SocketAddress(loopback, 0)));
@ -378,12 +374,12 @@ void SocketTest::ConnectWithDnsLookupFailInternal(const IPAddress& loopback) {
// Create client.
std::unique_ptr<Socket> client(
ss_->CreateSocket(loopback.family(), SOCK_STREAM));
socket_factory_->CreateSocket(loopback.family(), SOCK_STREAM));
sink.Monitor(client.get());
// Create server, but don't listen yet.
std::unique_ptr<Socket> server(
ss_->CreateSocket(loopback.family(), SOCK_STREAM));
socket_factory_->CreateSocket(loopback.family(), SOCK_STREAM));
sink.Monitor(server.get());
EXPECT_EQ(0, server->Bind(SocketAddress(loopback, 0)));
@ -415,13 +411,13 @@ void SocketTest::ConnectWithDnsLookupFailInternal(const IPAddress& loopback) {
void SocketTest::ConnectWithClosedSocketInternal(const IPAddress& loopback) {
// Create server and listen.
std::unique_ptr<Socket> server(
ss_->CreateSocket(loopback.family(), SOCK_STREAM));
socket_factory_->CreateSocket(loopback.family(), SOCK_STREAM));
EXPECT_EQ(0, server->Bind(SocketAddress(loopback, 0)));
EXPECT_EQ(0, server->Listen(5));
// Create a client and put in to CS_CLOSED state.
std::unique_ptr<Socket> client(
ss_->CreateSocket(loopback.family(), SOCK_STREAM));
socket_factory_->CreateSocket(loopback.family(), SOCK_STREAM));
EXPECT_EQ(0, client->Close());
EXPECT_EQ(Socket::CS_CLOSED, client->GetState());
@ -434,13 +430,13 @@ void SocketTest::ConnectWhileNotClosedInternal(const IPAddress& loopback) {
// Create server and listen.
StreamSink sink;
std::unique_ptr<Socket> server(
ss_->CreateSocket(loopback.family(), SOCK_STREAM));
socket_factory_->CreateSocket(loopback.family(), SOCK_STREAM));
sink.Monitor(server.get());
EXPECT_EQ(0, server->Bind(SocketAddress(loopback, 0)));
EXPECT_EQ(0, server->Listen(5));
// Create client, connect.
std::unique_ptr<Socket> client(
ss_->CreateSocket(loopback.family(), SOCK_STREAM));
socket_factory_->CreateSocket(loopback.family(), SOCK_STREAM));
EXPECT_EQ(0, client->Connect(SocketAddress(server->GetLocalAddress())));
EXPECT_EQ(Socket::CS_CONNECTING, client->GetState());
// Try to connect again. Should fail, but not interfere with original attempt.
@ -477,12 +473,12 @@ void SocketTest::ServerCloseDuringConnectInternal(const IPAddress& loopback) {
// Create client.
std::unique_ptr<Socket> client(
ss_->CreateSocket(loopback.family(), SOCK_STREAM));
socket_factory_->CreateSocket(loopback.family(), SOCK_STREAM));
sink.Monitor(client.get());
// Create server and listen.
std::unique_ptr<Socket> server(
ss_->CreateSocket(loopback.family(), SOCK_STREAM));
socket_factory_->CreateSocket(loopback.family(), SOCK_STREAM));
sink.Monitor(server.get());
EXPECT_EQ(0, server->Bind(SocketAddress(loopback, 0)));
EXPECT_EQ(0, server->Listen(5));
@ -506,12 +502,12 @@ void SocketTest::ClientCloseDuringConnectInternal(const IPAddress& loopback) {
// Create client.
std::unique_ptr<Socket> client(
ss_->CreateSocket(loopback.family(), SOCK_STREAM));
socket_factory_->CreateSocket(loopback.family(), SOCK_STREAM));
sink.Monitor(client.get());
// Create server and listen.
std::unique_ptr<Socket> server(
ss_->CreateSocket(loopback.family(), SOCK_STREAM));
socket_factory_->CreateSocket(loopback.family(), SOCK_STREAM));
sink.Monitor(server.get());
EXPECT_EQ(0, server->Bind(SocketAddress(loopback, 0)));
EXPECT_EQ(0, server->Listen(5));
@ -544,12 +540,12 @@ void SocketTest::ServerCloseInternal(const IPAddress& loopback) {
// Create client.
std::unique_ptr<Socket> client(
ss_->CreateSocket(loopback.family(), SOCK_STREAM));
socket_factory_->CreateSocket(loopback.family(), SOCK_STREAM));
sink.Monitor(client.get());
// Create server and listen.
std::unique_ptr<Socket> server(
ss_->CreateSocket(loopback.family(), SOCK_STREAM));
socket_factory_->CreateSocket(loopback.family(), SOCK_STREAM));
sink.Monitor(server.get());
EXPECT_EQ(0, server->Bind(SocketAddress(loopback, 0)));
EXPECT_EQ(0, server->Listen(5));
@ -618,13 +614,13 @@ void SocketTest::CloseInClosedCallbackInternal(const IPAddress& loopback) {
// Create client.
std::unique_ptr<Socket> client(
ss_->CreateSocket(loopback.family(), SOCK_STREAM));
socket_factory_->CreateSocket(loopback.family(), SOCK_STREAM));
sink.Monitor(client.get());
client->SignalCloseEvent.connect(&closer, &SocketCloser::OnClose);
// Create server and listen.
std::unique_ptr<Socket> server(
ss_->CreateSocket(loopback.family(), SOCK_STREAM));
socket_factory_->CreateSocket(loopback.family(), SOCK_STREAM));
sink.Monitor(server.get());
EXPECT_EQ(0, server->Bind(SocketAddress(loopback, 0)));
EXPECT_EQ(0, server->Listen(5));
@ -677,9 +673,9 @@ class SocketDeleter : public sigslot::has_slots<> {
// became readable at the same time.
void SocketTest::DeleteInReadCallbackInternal(const IPAddress& loopback) {
std::unique_ptr<Socket> socket1(
ss_->CreateSocket(loopback.family(), SOCK_DGRAM));
socket_factory_->CreateSocket(loopback.family(), SOCK_DGRAM));
std::unique_ptr<Socket> socket2(
ss_->CreateSocket(loopback.family(), SOCK_DGRAM));
socket_factory_->CreateSocket(loopback.family(), SOCK_DGRAM));
EXPECT_EQ(0, socket1->Bind(SocketAddress(loopback, 0)));
EXPECT_EQ(0, socket2->Bind(SocketAddress(loopback, 0)));
EXPECT_EQ(3, socket1->SendTo("foo", 3, socket1->GetLocalAddress()));
@ -705,9 +701,9 @@ void SocketTest::SocketServerWaitInternal(const IPAddress& loopback) {
// Create & connect server and client sockets.
std::unique_ptr<Socket> client(
ss_->CreateSocket(loopback.family(), SOCK_STREAM));
socket_factory_->CreateSocket(loopback.family(), SOCK_STREAM));
std::unique_ptr<Socket> server(
ss_->CreateSocket(loopback.family(), SOCK_STREAM));
socket_factory_->CreateSocket(loopback.family(), SOCK_STREAM));
sink.Monitor(client.get());
sink.Monitor(server.get());
EXPECT_EQ(0, server->Bind(SocketAddress(loopback, 0)));
@ -757,12 +753,12 @@ void SocketTest::TcpInternal(const IPAddress& loopback,
// Create receiving client.
std::unique_ptr<Socket> receiver(
ss_->CreateSocket(loopback.family(), SOCK_STREAM));
socket_factory_->CreateSocket(loopback.family(), SOCK_STREAM));
sink.Monitor(receiver.get());
// Create server and listen.
std::unique_ptr<Socket> server(
ss_->CreateSocket(loopback.family(), SOCK_STREAM));
socket_factory_->CreateSocket(loopback.family(), SOCK_STREAM));
sink.Monitor(server.get());
EXPECT_EQ(0, server->Bind(SocketAddress(loopback, 0)));
EXPECT_EQ(0, server->Listen(5));
@ -883,12 +879,12 @@ void SocketTest::SingleFlowControlCallbackInternal(const IPAddress& loopback) {
// Create client.
std::unique_ptr<Socket> client(
ss_->CreateSocket(loopback.family(), SOCK_STREAM));
socket_factory_->CreateSocket(loopback.family(), SOCK_STREAM));
sink.Monitor(client.get());
// Create server and listen.
std::unique_ptr<Socket> server(
ss_->CreateSocket(loopback.family(), SOCK_STREAM));
socket_factory_->CreateSocket(loopback.family(), SOCK_STREAM));
sink.Monitor(server.get());
EXPECT_EQ(0, server->Bind(SocketAddress(loopback, 0)));
EXPECT_EQ(0, server->Listen(5));
@ -949,7 +945,7 @@ void SocketTest::SingleFlowControlCallbackInternal(const IPAddress& loopback) {
void SocketTest::UdpInternal(const IPAddress& loopback) {
SocketAddress empty = EmptySocketAddressWithFamily(loopback.family());
// Test basic bind and connect behavior.
Socket* socket = ss_->CreateSocket(loopback.family(), SOCK_DGRAM);
Socket* socket = socket_factory_->CreateSocket(loopback.family(), SOCK_DGRAM);
EXPECT_EQ(Socket::CS_CLOSED, socket->GetState());
EXPECT_EQ(0, socket->Bind(SocketAddress(loopback, 0)));
SocketAddress addr1 = socket->GetLocalAddress();
@ -960,10 +956,10 @@ void SocketTest::UdpInternal(const IPAddress& loopback) {
delete socket;
// Test send/receive behavior.
std::unique_ptr<TestClient> client1(
new TestClient(absl::WrapUnique(AsyncUDPSocket::Create(ss_, addr1))));
std::unique_ptr<TestClient> client2(
new TestClient(absl::WrapUnique(AsyncUDPSocket::Create(ss_, empty))));
auto client1 = std::make_unique<TestClient>(
absl::WrapUnique(AsyncUDPSocket::Create(socket_factory_, addr1)));
auto client2 = std::make_unique<TestClient>(
absl::WrapUnique(AsyncUDPSocket::Create(socket_factory_, empty)));
SocketAddress addr2;
EXPECT_EQ(3, client2->SendTo("foo", 3, addr1));
@ -975,8 +971,8 @@ void SocketTest::UdpInternal(const IPAddress& loopback) {
EXPECT_EQ(addr3, addr1);
// TODO: figure out what the intent is here
for (int i = 0; i < 10; ++i) {
client2.reset(
new TestClient(absl::WrapUnique(AsyncUDPSocket::Create(ss_, empty))));
client2 = std::make_unique<TestClient>(
absl::WrapUnique(AsyncUDPSocket::Create(socket_factory_, empty)));
SocketAddress addr4;
EXPECT_EQ(3, client2->SendTo("foo", 3, addr1));
@ -1002,8 +998,8 @@ void SocketTest::UdpReadyToSend(const IPAddress& loopback) {
SocketAddress test_addr(dest, 2345);
// Test send
std::unique_ptr<TestClient> client(
new TestClient(absl::WrapUnique(AsyncUDPSocket::Create(ss_, empty))));
auto client = std::make_unique<TestClient>(
absl::WrapUnique(AsyncUDPSocket::Create(socket_factory_, empty)));
int test_packet_size = 1200;
std::unique_ptr<char[]> test_packet(new char[test_packet_size]);
// Init the test packet just to avoid memcheck warning.
@ -1040,7 +1036,7 @@ void SocketTest::UdpReadyToSend(const IPAddress& loopback) {
void SocketTest::GetSetOptionsInternal(const IPAddress& loopback) {
std::unique_ptr<Socket> socket(
ss_->CreateSocket(loopback.family(), SOCK_DGRAM));
socket_factory_->CreateSocket(loopback.family(), SOCK_DGRAM));
socket->Bind(SocketAddress(loopback, 0));
// Check SNDBUF/RCVBUF.
@ -1083,7 +1079,7 @@ void SocketTest::GetSetOptionsInternal(const IPAddress& loopback) {
void SocketTest::SocketRecvTimestamp(const IPAddress& loopback) {
std::unique_ptr<Socket> socket(
ss_->CreateSocket(loopback.family(), SOCK_DGRAM));
socket_factory_->CreateSocket(loopback.family(), SOCK_DGRAM));
EXPECT_EQ(0, socket->Bind(SocketAddress(loopback, 0)));
SocketAddress address = socket->GetLocalAddress();

7
rtc_base/socket_unittest.h
View File

@ -21,11 +21,10 @@ namespace rtc {
// socketserver, and call the SocketTest test methods.
class SocketTest : public ::testing::Test {
protected:
SocketTest()
explicit SocketTest(rtc::SocketFactory* socket_factory)
: kIPv4Loopback(INADDR_LOOPBACK),
kIPv6Loopback(in6addr_loopback),
ss_(nullptr) {}
void SetUp() override;
socket_factory_(socket_factory) {}
void TestConnectIPv4();
void TestConnectIPv6();
void TestConnectWithDnsLookupIPv4();
@ -93,7 +92,7 @@ class SocketTest : public ::testing::Test {
void GetSetOptionsInternal(const IPAddress& loopback);
void SocketRecvTimestamp(const IPAddress& loopback);
SocketServer* ss_;
SocketFactory* socket_factory_;
};
// For unbound sockets, GetLocalAddress / GetRemoteAddress return AF_UNSPEC

2
rtc_base/win32_socket_server_unittest.cc
View File

@ -38,7 +38,7 @@ TEST(Win32SocketServerTest, TestPump) {
// Test that Win32Socket passes all the generic Socket tests.
class Win32SocketTest : public SocketTest {
protected:
Win32SocketTest() : thread_(&server_) {}
Win32SocketTest() : SocketTest(&server_), thread_(&server_) {}
Win32SocketServer server_;
rtc::AutoSocketServerThread thread_;
};