Get tests working on systems that only support IPv6.

webrtc/base/physicalsocketserver_unittest.cc

 /*
  *  Copyright 2004 The WebRTC Project Authors. All rights reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
 #include <memory>
 #include <signal.h>
 #include <stdarg.h>
 
 #include "webrtc/base/gunit.h"
 #include "webrtc/base/logging.h"
 #include "webrtc/base/networkmonitor.h"
 #include "webrtc/base/physicalsocketserver.h"
 #include "webrtc/base/socket_unittest.h"
 #include "webrtc/base/testutils.h"
 #include "webrtc/base/thread.h"
 
 namespace rtc {
 
+#define MAYBE_SKIP_IPV4                    \
+  if (!HasIPv4Enabled()) {                 \
+    LOG(LS_INFO) << "No IPv4... skipping"; \
+    return;                                \
+  }
+
 #define MAYBE_SKIP_IPV6                    \
   if (!HasIPv6Enabled()) {                 \
     LOG(LS_INFO) << "No IPv6... skipping"; \
     return;                                \
   }
 
 class PhysicalSocketTest;
 
 class FakeSocketDispatcher : public SocketDispatcher {
  public:
@@ skipping 122 matching lines @@
       static_cast<FakePhysicalSocketServer*>(socketserver());
   if (ss->GetTest()->MaxSendSize() >= 0) {
     len = std::min(len, ss->GetTest()->MaxSendSize());
   }
 
   return SocketDispatcher::DoSendTo(socket, buf, len, flags, dest_addr,
       addrlen);
 }
 
 TEST_F(PhysicalSocketTest, TestConnectIPv4) {
+  MAYBE_SKIP_IPV4;
   SocketTest::TestConnectIPv4();
 }
 
 TEST_F(PhysicalSocketTest, TestConnectIPv6) {
   SocketTest::TestConnectIPv6();
 }
 
 TEST_F(PhysicalSocketTest, TestConnectWithDnsLookupIPv4) {
+  MAYBE_SKIP_IPV4;
   SocketTest::TestConnectWithDnsLookupIPv4();
 }
 
 TEST_F(PhysicalSocketTest, TestConnectWithDnsLookupIPv6) {
   SocketTest::TestConnectWithDnsLookupIPv6();
 }
 
 TEST_F(PhysicalSocketTest, TestConnectFailIPv4) {
+  MAYBE_SKIP_IPV4;
   SocketTest::TestConnectFailIPv4();
 }
 
 void PhysicalSocketTest::ConnectInternalAcceptError(const IPAddress& loopback) {
   webrtc::testing::StreamSink sink;
   SocketAddress accept_addr;
 
   // Create two clients.
   std::unique_ptr<AsyncSocket> client1(
       server_->CreateAsyncSocket(loopback.family(), SOCK_STREAM));
@@ skipping 58 matching lines @@
   EXPECT_TRUE_WAIT((sink.Check(server.get(), webrtc::testing::SSE_READ)),
                    kTimeout);
   SetFailAccept(false);
   std::unique_ptr<AsyncSocket> accepted2(server->Accept(&accept_addr));
   ASSERT_TRUE(accepted2);
   EXPECT_FALSE(accept_addr.IsNil());
   EXPECT_EQ(accepted2->GetRemoteAddress(), accept_addr);
 }
 
 TEST_F(PhysicalSocketTest, TestConnectAcceptErrorIPv4) {
+  MAYBE_SKIP_IPV4;
   ConnectInternalAcceptError(kIPv4Loopback);
 }
 
 TEST_F(PhysicalSocketTest, TestConnectAcceptErrorIPv6) {
   MAYBE_SKIP_IPV6;
   ConnectInternalAcceptError(kIPv6Loopback);
 }
 
 void PhysicalSocketTest::WritableAfterPartialWrite(const IPAddress& loopback) {
   // Simulate a really small maximum send size.
   const int kMaxSendSize = 128;
   SetMaxSendSize(kMaxSendSize);
 
   // Run the default send/receive socket tests with a smaller amount of data
   // to avoid long running times due to the small maximum send size.
   const size_t kDataSize = 128 * 1024;
   TcpInternal(loopback, kDataSize, kMaxSendSize);
 }
 
 // https://bugs.chromium.org/p/webrtc/issues/detail?id=6167
 #if defined(WEBRTC_WIN)
 #define MAYBE_TestWritableAfterPartialWriteIPv4 DISABLED_TestWritableAfterPartialWriteIPv4
 #else
 #define MAYBE_TestWritableAfterPartialWriteIPv4 TestWritableAfterPartialWriteIPv4
 #endif
 TEST_F(PhysicalSocketTest, MAYBE_TestWritableAfterPartialWriteIPv4) {
+  MAYBE_SKIP_IPV4;
   WritableAfterPartialWrite(kIPv4Loopback);
 }
 
 // https://bugs.chromium.org/p/webrtc/issues/detail?id=6167
 #if defined(WEBRTC_WIN)
 #define MAYBE_TestWritableAfterPartialWriteIPv6 DISABLED_TestWritableAfterPartialWriteIPv6
 #else
 #define MAYBE_TestWritableAfterPartialWriteIPv6 TestWritableAfterPartialWriteIPv6
 #endif
 TEST_F(PhysicalSocketTest, MAYBE_TestWritableAfterPartialWriteIPv6) {
   MAYBE_SKIP_IPV6;
   WritableAfterPartialWrite(kIPv6Loopback);
 }
 
 TEST_F(PhysicalSocketTest, TestConnectFailIPv6) {
   SocketTest::TestConnectFailIPv6();
 }
 
 TEST_F(PhysicalSocketTest, TestConnectWithDnsLookupFailIPv4) {
+  MAYBE_SKIP_IPV4;
   SocketTest::TestConnectWithDnsLookupFailIPv4();
 }
 
 TEST_F(PhysicalSocketTest, TestConnectWithDnsLookupFailIPv6) {
   SocketTest::TestConnectWithDnsLookupFailIPv6();
 }
 
 
 TEST_F(PhysicalSocketTest, TestConnectWithClosedSocketIPv4) {
+  MAYBE_SKIP_IPV4;
   SocketTest::TestConnectWithClosedSocketIPv4();
 }
 
 TEST_F(PhysicalSocketTest, TestConnectWithClosedSocketIPv6) {
   SocketTest::TestConnectWithClosedSocketIPv6();
 }
 
 TEST_F(PhysicalSocketTest, TestConnectWhileNotClosedIPv4) {
+  MAYBE_SKIP_IPV4;
   SocketTest::TestConnectWhileNotClosedIPv4();
 }
 
 TEST_F(PhysicalSocketTest, TestConnectWhileNotClosedIPv6) {
   SocketTest::TestConnectWhileNotClosedIPv6();
 }
 
 TEST_F(PhysicalSocketTest, TestServerCloseDuringConnectIPv4) {
+  MAYBE_SKIP_IPV4;
   SocketTest::TestServerCloseDuringConnectIPv4();
 }
 
 TEST_F(PhysicalSocketTest, TestServerCloseDuringConnectIPv6) {
   SocketTest::TestServerCloseDuringConnectIPv6();
 }
 
 TEST_F(PhysicalSocketTest, TestClientCloseDuringConnectIPv4) {
+  MAYBE_SKIP_IPV4;
   SocketTest::TestClientCloseDuringConnectIPv4();
 }
 
 TEST_F(PhysicalSocketTest, TestClientCloseDuringConnectIPv6) {
   SocketTest::TestClientCloseDuringConnectIPv6();
 }
 
 TEST_F(PhysicalSocketTest, TestServerCloseIPv4) {
+  MAYBE_SKIP_IPV4;
   SocketTest::TestServerCloseIPv4();
 }
 
 TEST_F(PhysicalSocketTest, TestServerCloseIPv6) {
   SocketTest::TestServerCloseIPv6();
 }
 
 TEST_F(PhysicalSocketTest, TestCloseInClosedCallbackIPv4) {
+  MAYBE_SKIP_IPV4;
   SocketTest::TestCloseInClosedCallbackIPv4();
 }
 
 TEST_F(PhysicalSocketTest, TestCloseInClosedCallbackIPv6) {
   SocketTest::TestCloseInClosedCallbackIPv6();
 }
 
 TEST_F(PhysicalSocketTest, TestSocketServerWaitIPv4) {
+  MAYBE_SKIP_IPV4;
   SocketTest::TestSocketServerWaitIPv4();
 }
 
 TEST_F(PhysicalSocketTest, TestSocketServerWaitIPv6) {
   SocketTest::TestSocketServerWaitIPv6();
 }
 
 TEST_F(PhysicalSocketTest, TestTcpIPv4) {
+  MAYBE_SKIP_IPV4;
   SocketTest::TestTcpIPv4();
 }
 
 TEST_F(PhysicalSocketTest, TestTcpIPv6) {
   SocketTest::TestTcpIPv6();
 }
 
 TEST_F(PhysicalSocketTest, TestUdpIPv4) {
+  MAYBE_SKIP_IPV4;
   SocketTest::TestUdpIPv4();
 }
 
 TEST_F(PhysicalSocketTest, TestUdpIPv6) {
   SocketTest::TestUdpIPv6();
 }
 
 // Disable for TSan v2, see
 // https://code.google.com/p/webrtc/issues/detail?id=3498 for details.
 // Also disable for MSan, see:
 // https://code.google.com/p/webrtc/issues/detail?id=4958
 // TODO(deadbeef): Enable again once test is reimplemented to be unflaky.
 // Also disable for ASan.
 // Disabled on Android: https://code.google.com/p/webrtc/issues/detail?id=4364
 // Disabled on Linux: https://bugs.chromium.org/p/webrtc/issues/detail?id=5233
 #if defined(THREAD_SANITIZER) || defined(MEMORY_SANITIZER) || \
     defined(ADDRESS_SANITIZER) || defined(WEBRTC_ANDROID) ||  \
     defined(WEBRTC_LINUX)
 #define MAYBE_TestUdpReadyToSendIPv4 DISABLED_TestUdpReadyToSendIPv4
 #else
 #define MAYBE_TestUdpReadyToSendIPv4 TestUdpReadyToSendIPv4
 #endif
 TEST_F(PhysicalSocketTest, MAYBE_TestUdpReadyToSendIPv4) {
+  MAYBE_SKIP_IPV4;
   SocketTest::TestUdpReadyToSendIPv4();
 }
 
 // https://bugs.chromium.org/p/webrtc/issues/detail?id=6167
 #if defined(WEBRTC_WIN)
 #define MAYBE_TestUdpReadyToSendIPv6 DISABLED_TestUdpReadyToSendIPv6
 #else
 #define MAYBE_TestUdpReadyToSendIPv6 TestUdpReadyToSendIPv6
 #endif
 TEST_F(PhysicalSocketTest, MAYBE_TestUdpReadyToSendIPv6) {
   SocketTest::TestUdpReadyToSendIPv6();
 }
 
 TEST_F(PhysicalSocketTest, TestGetSetOptionsIPv4) {
+  MAYBE_SKIP_IPV4;
   SocketTest::TestGetSetOptionsIPv4();
 }
 
 TEST_F(PhysicalSocketTest, TestGetSetOptionsIPv6) {
   SocketTest::TestGetSetOptionsIPv6();
 }
 
 #if defined(WEBRTC_POSIX)
 
 // We don't get recv timestamps on Mac.
 #if !defined(WEBRTC_MAC)
 TEST_F(PhysicalSocketTest, TestSocketRecvTimestampIPv4) {
+  MAYBE_SKIP_IPV4;
   SocketTest::TestSocketRecvTimestampIPv4();
 }
 
 TEST_F(PhysicalSocketTest, TestSocketRecvTimestampIPv6) {
   SocketTest::TestSocketRecvTimestampIPv6();
 }
 #endif
 
 // Verify that if the socket was unable to be bound to a real network interface
 // (not loopback), Bind will return an error.
 TEST_F(PhysicalSocketTest,
        BindFailsIfNetworkBinderFailsForNonLoopbackInterface) {
+  MAYBE_SKIP_IPV4;
   FakeNetworkBinder fake_network_binder;
   server_->set_network_binder(&fake_network_binder);
   std::unique_ptr<AsyncSocket> socket(
       server_->CreateAsyncSocket(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);
 }
 
 // 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<AsyncSocket> socket(
       server_->CreateAsyncSocket(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);
 }
 
 // For a loopback interface, failures to bind to the interface should be
 // tolerated.
 TEST_F(PhysicalSocketTest,
        BindSucceedsIfNetworkBinderFailsForLoopbackInterface) {
+  MAYBE_SKIP_IPV4;
   FakeNetworkBinder fake_network_binder;
   server_->set_network_binder(&fake_network_binder);
   std::unique_ptr<AsyncSocket> socket(
       server_->CreateAsyncSocket(AF_INET, SOCK_DGRAM));
   fake_network_binder.set_result(NetworkBindingResult::FAILURE);
   EXPECT_EQ(0, socket->Bind(SocketAddress(kIPv4Loopback, 0)));
   server_->set_network_binder(nullptr);
 }
 
 class PosixSignalDeliveryTest : public testing::Test {
@@ skipping 113 matching lines @@
   thread->Start(runnable.get());
   EXPECT_TRUE(ss_->Wait(1500, true));
   EXPECT_TRUE(ExpectSignal(SIGTERM));
   EXPECT_EQ(Thread::Current(), signaled_thread_);
   EXPECT_TRUE(ExpectNone());
 }
 
 #endif
 
 }  // namespace rtc