diff --git a/webrtc/base/asynchttprequest_unittest.cc b/webrtc/base/asynchttprequest_unittest.cc
index 0bfd795b1..19dea6407 100644
--- a/webrtc/base/asynchttprequest_unittest.cc
+++ b/webrtc/base/asynchttprequest_unittest.cc
@@ -14,6 +14,7 @@
 #include "webrtc/base/httpserver.h"
 #include "webrtc/base/socketstream.h"
 #include "webrtc/base/thread.h"
+#include "webrtc/test/testsupport/gtest_disable.h"
 
 namespace rtc {
 
@@ -143,7 +144,7 @@ TEST_F(AsyncHttpRequestTest, TestGetSuccess) {
   req->Release();
 }
 
-TEST_F(AsyncHttpRequestTest, TestGetNotFound) {
+TEST_F(AsyncHttpRequestTest, DISABLED_ON_MAC(TestGetNotFound)) {
   AsyncHttpRequest* req = CreateGetRequest(
       kServerHostnameAddr.hostname(), server().address().port(),
       "/bad");
@@ -157,7 +158,7 @@ TEST_F(AsyncHttpRequestTest, TestGetNotFound) {
   req->Release();
 }
 
-TEST_F(AsyncHttpRequestTest, TestGetToNonServer) {
+TEST_F(AsyncHttpRequestTest, DISABLED_ON_MAC(TestGetToNonServer)) {
   AsyncHttpRequest* req = CreateGetRequest(
       "127.0.0.1", server().address().port(),
       kServerGetPath);
@@ -187,7 +188,7 @@ TEST_F(AsyncHttpRequestTest, DISABLED_TestGetToInvalidHostname) {
   req->Release();
 }
 
-TEST_F(AsyncHttpRequestTest, TestPostSuccess) {
+TEST_F(AsyncHttpRequestTest, DISABLED_ON_MAC(TestPostSuccess)) {
   AsyncHttpRequest* req = CreatePostRequest(
       kServerHostnameAddr.hostname(), server().address().port(),
       kServerPostPath, "text/plain", new MemoryStream("abcd1234"));
@@ -203,7 +204,7 @@ TEST_F(AsyncHttpRequestTest, TestPostSuccess) {
 }
 
 // Ensure that we shut down properly even if work is outstanding.
-TEST_F(AsyncHttpRequestTest, TestCancel) {
+TEST_F(AsyncHttpRequestTest, DISABLED_ON_MAC(TestCancel)) {
   AsyncHttpRequest* req = CreateGetRequest(
       kServerHostnameAddr.hostname(), server().address().port(),
       kServerGetPath);
@@ -211,7 +212,7 @@ TEST_F(AsyncHttpRequestTest, TestCancel) {
   req->Destroy(true);
 }
 
-TEST_F(AsyncHttpRequestTest, TestGetSuccessDelay) {
+TEST_F(AsyncHttpRequestTest, DISABLED_ON_MAC(TestGetSuccessDelay)) {
   AsyncHttpRequest* req = CreateGetRequest(
       kServerHostnameAddr.hostname(), server().address().port(),
       kServerGetPath);
diff --git a/webrtc/base/autodetectproxy_unittest.cc b/webrtc/base/autodetectproxy_unittest.cc
index 80f220f2f..782bc2588 100644
--- a/webrtc/base/autodetectproxy_unittest.cc
+++ b/webrtc/base/autodetectproxy_unittest.cc
@@ -12,6 +12,7 @@
 #include "webrtc/base/gunit.h"
 #include "webrtc/base/httpcommon.h"
 #include "webrtc/base/httpcommon-inl.h"
+#include "webrtc/test/testsupport/gtest_disable.h"
 
 namespace rtc {
 
@@ -99,26 +100,26 @@ class AutoDetectProxyTest : public testing::Test, public sigslot::has_slots<> {
   bool done_;
 };
 
-TEST_F(AutoDetectProxyTest, TestDetectUnresolvedProxy) {
+TEST_F(AutoDetectProxyTest, DISABLED_ON_MAC(TestDetectUnresolvedProxy)) {
   TestCopesWithProxy(rtc::SocketAddress("localhost", 9999));
 }
 
-TEST_F(AutoDetectProxyTest, TestDetectUnresolvableProxy) {
+TEST_F(AutoDetectProxyTest, DISABLED_ON_MAC(TestDetectUnresolvableProxy)) {
   TestCopesWithProxy(rtc::SocketAddress("invalid", 9999));
 }
 
-TEST_F(AutoDetectProxyTest, TestDetectIPv6Proxy) {
+TEST_F(AutoDetectProxyTest, DISABLED_ON_MAC(TestDetectIPv6Proxy)) {
   TestCopesWithProxy(rtc::SocketAddress("::1", 9999));
 }
 
-TEST_F(AutoDetectProxyTest, TestDetectIPv4Proxy) {
+TEST_F(AutoDetectProxyTest, DISABLED_ON_MAC(TestDetectIPv4Proxy)) {
   TestCopesWithProxy(rtc::SocketAddress("127.0.0.1", 9999));
 }
 
 // Test that proxy detection completes successfully. (Does not actually verify
 // the correct detection result since we don't know what proxy to expect on an
 // arbitrary machine.)
-TEST_F(AutoDetectProxyTest, TestProxyDetection) {
+TEST_F(AutoDetectProxyTest, DISABLED_ON_MAC(TestProxyDetection)) {
   ASSERT_TRUE(Create(kUserAgent,
                      kPath,
                      kHost,
diff --git a/webrtc/base/cpumonitor_unittest.cc b/webrtc/base/cpumonitor_unittest.cc
index 6d9af5aec..1546f558f 100644
--- a/webrtc/base/cpumonitor_unittest.cc
+++ b/webrtc/base/cpumonitor_unittest.cc
@@ -23,6 +23,7 @@
 #include "webrtc/base/thread.h"
 #include "webrtc/base/timeutils.h"
 #include "webrtc/base/timing.h"
+#include "webrtc/test/testsupport/gtest_disable.h"
 
 namespace rtc {
 
@@ -337,7 +338,7 @@ TEST(CpuMonitorTest, TestGetSystemLoadForceFallback) {
 #endif
 
 // Tests both process and system functions in use at same time.
-TEST(CpuMonitorTest, TestGetBothLoad) {
+TEST(CpuMonitorTest, DISABLED_ON_MAC(TestGetBothLoad)) {
   TestCpuSampler(true, true, false);
 }
 
diff --git a/webrtc/base/criticalsection_unittest.cc b/webrtc/base/criticalsection_unittest.cc
index e1b05cb01..69f74fa20 100644
--- a/webrtc/base/criticalsection_unittest.cc
+++ b/webrtc/base/criticalsection_unittest.cc
@@ -16,6 +16,7 @@
 #include "webrtc/base/gunit.h"
 #include "webrtc/base/scopedptrcollection.h"
 #include "webrtc/base/thread.h"
+#include "webrtc/test/testsupport/gtest_disable.h"
 
 namespace rtc {
 
@@ -119,7 +120,7 @@ TEST(AtomicOpsTest, Simple) {
   EXPECT_EQ(0, value);
 }
 
-TEST(AtomicOpsTest, Increment) {
+TEST(AtomicOpsTest, DISABLED_ON_MAC(Increment)) {
   // Create and start lots of threads.
   AtomicOpRunner<IncrementOp> runner(0);
   ScopedPtrCollection<Thread> threads;
@@ -131,7 +132,7 @@ TEST(AtomicOpsTest, Increment) {
   EXPECT_EQ(kOperationsToRun * kNumThreads, runner.value());
 }
 
-TEST(AtomicOpsTest, Decrement) {
+TEST(AtomicOpsTest, DISABLED_ON_MAC(Decrement)) {
   // Create and start lots of threads.
   AtomicOpRunner<DecrementOp> runner(kOperationsToRun * kNumThreads);
   ScopedPtrCollection<Thread> threads;
diff --git a/webrtc/base/filelock_unittest.cc b/webrtc/base/filelock_unittest.cc
index eecbf07da..536204ec1 100644
--- a/webrtc/base/filelock_unittest.cc
+++ b/webrtc/base/filelock_unittest.cc
@@ -17,6 +17,7 @@
 #include "webrtc/base/pathutils.h"
 #include "webrtc/base/scoped_ptr.h"
 #include "webrtc/base/thread.h"
+#include "webrtc/test/testsupport/gtest_disable.h"
 
 namespace rtc {
 
@@ -76,7 +77,7 @@ TEST_F(FileLockTest, TestLockX2) {
   EXPECT_TRUE(lock2.get() == NULL);
 }
 
-TEST_F(FileLockTest, TestThreadedLock) {
+TEST_F(FileLockTest, DISABLED_ON_MAC(TestThreadedLock)) {
   scoped_ptr<FileLock> lock(FileLock::TryLock(temp_file_.pathname()));
   EXPECT_TRUE(lock.get() != NULL);
 
diff --git a/webrtc/base/logging_unittest.cc b/webrtc/base/logging_unittest.cc
index 59630d746..aa4383761 100644
--- a/webrtc/base/logging_unittest.cc
+++ b/webrtc/base/logging_unittest.cc
@@ -14,6 +14,7 @@
 #include "webrtc/base/pathutils.h"
 #include "webrtc/base/stream.h"
 #include "webrtc/base/thread.h"
+#include "webrtc/test/testsupport/gtest_disable.h"
 
 namespace rtc {
 
@@ -82,7 +83,7 @@ class LogThread : public Thread {
   }
 };
 
-TEST(LogTest, MultipleThreads) {
+TEST(LogTest, DISABLED_ON_MAC(MultipleThreads)) {
   int sev = LogMessage::GetLogToStream(NULL);
 
   LogThread thread1, thread2, thread3;
diff --git a/webrtc/base/macsocketserver_unittest.cc b/webrtc/base/macsocketserver_unittest.cc
index e98be918c..f97bf5039 100644
--- a/webrtc/base/macsocketserver_unittest.cc
+++ b/webrtc/base/macsocketserver_unittest.cc
@@ -102,19 +102,19 @@ class MacAsyncSocketTest : public SocketTest {
   SocketServerScope scope_;
 };
 
-TEST_F(MacAsyncSocketTest, TestConnectIPv4) {
+TEST_F(MacAsyncSocketTest, DISABLED_TestConnectIPv4) {
   SocketTest::TestConnectIPv4();
 }
 
-TEST_F(MacAsyncSocketTest, TestConnectIPv6) {
+TEST_F(MacAsyncSocketTest, DISABLED_TestConnectIPv6) {
   SocketTest::TestConnectIPv6();
 }
 
-TEST_F(MacAsyncSocketTest, TestConnectWithDnsLookupIPv4) {
+TEST_F(MacAsyncSocketTest, DISABLED_TestConnectWithDnsLookupIPv4) {
   SocketTest::TestConnectWithDnsLookupIPv4();
 }
 
-TEST_F(MacAsyncSocketTest, TestConnectWithDnsLookupIPv6) {
+TEST_F(MacAsyncSocketTest, DISABLED_TestConnectWithDnsLookupIPv6) {
   SocketTest::TestConnectWithDnsLookupIPv6();
 }
 
@@ -123,7 +123,7 @@ TEST_F(MacAsyncSocketTest, DISABLED_TestConnectFailIPv4) {
   SocketTest::TestConnectFailIPv4();
 }
 
-TEST_F(MacAsyncSocketTest, TestConnectFailIPv6) {
+TEST_F(MacAsyncSocketTest, DISABLED_TestConnectFailIPv6) {
   SocketTest::TestConnectFailIPv6();
 }
 
@@ -136,11 +136,11 @@ TEST_F(MacAsyncSocketTest, DISABLED_TestConnectWithDnsLookupFailIPv6) {
   SocketTest::TestConnectWithDnsLookupFailIPv6();
 }
 
-TEST_F(MacAsyncSocketTest, TestConnectWithClosedSocketIPv4) {
+TEST_F(MacAsyncSocketTest, DISABLED_TestConnectWithClosedSocketIPv4) {
   SocketTest::TestConnectWithClosedSocketIPv4();
 }
 
-TEST_F(MacAsyncSocketTest, TestConnectWithClosedSocketIPv6) {
+TEST_F(MacAsyncSocketTest, DISABLED_TestConnectWithClosedSocketIPv6) {
   SocketTest::TestConnectWithClosedSocketIPv6();
 }
 
@@ -155,51 +155,51 @@ TEST_F(MacAsyncSocketTest, DISABLED_TestServerCloseDuringConnectIPv6) {
 }
 // Flaky at the moment (0.5% failure rate).  Seems the client doesn't get
 // signalled in a timely manner...
-TEST_F(MacAsyncSocketTest, TestClientCloseDuringConnectIPv4) {
+TEST_F(MacAsyncSocketTest, DISABLED_TestClientCloseDuringConnectIPv4) {
   SocketTest::TestClientCloseDuringConnectIPv4();
 }
 
-TEST_F(MacAsyncSocketTest, TestClientCloseDuringConnectIPv6) {
+TEST_F(MacAsyncSocketTest, DISABLED_TestClientCloseDuringConnectIPv6) {
   SocketTest::TestClientCloseDuringConnectIPv6();
 }
 
-TEST_F(MacAsyncSocketTest, TestServerCloseIPv4) {
+TEST_F(MacAsyncSocketTest, DISABLED_TestServerCloseIPv4) {
   SocketTest::TestServerCloseIPv4();
 }
 
-TEST_F(MacAsyncSocketTest, TestServerCloseIPv6) {
+TEST_F(MacAsyncSocketTest, DISABLED_TestServerCloseIPv6) {
   SocketTest::TestServerCloseIPv6();
 }
 
-TEST_F(MacAsyncSocketTest, TestCloseInClosedCallbackIPv4) {
+TEST_F(MacAsyncSocketTest, DISABLED_TestCloseInClosedCallbackIPv4) {
   SocketTest::TestCloseInClosedCallbackIPv4();
 }
 
-TEST_F(MacAsyncSocketTest, TestCloseInClosedCallbackIPv6) {
+TEST_F(MacAsyncSocketTest, DISABLED_TestCloseInClosedCallbackIPv6) {
   SocketTest::TestCloseInClosedCallbackIPv6();
 }
 
-TEST_F(MacAsyncSocketTest, TestSocketServerWaitIPv4) {
+TEST_F(MacAsyncSocketTest, DISABLED_TestSocketServerWaitIPv4) {
   SocketTest::TestSocketServerWaitIPv4();
 }
 
-TEST_F(MacAsyncSocketTest, TestSocketServerWaitIPv6) {
+TEST_F(MacAsyncSocketTest, DISABLED_TestSocketServerWaitIPv6) {
   SocketTest::TestSocketServerWaitIPv6();
 }
 
-TEST_F(MacAsyncSocketTest, TestTcpIPv4) {
+TEST_F(MacAsyncSocketTest, DISABLED_TestTcpIPv4) {
   SocketTest::TestTcpIPv4();
 }
 
-TEST_F(MacAsyncSocketTest, TestTcpIPv6) {
+TEST_F(MacAsyncSocketTest, DISABLED_TestTcpIPv6) {
   SocketTest::TestTcpIPv6();
 }
 
-TEST_F(MacAsyncSocketTest, TestSingleFlowControlCallbackIPv4) {
+TEST_F(MacAsyncSocketTest, DISABLED_TestSingleFlowControlCallbackIPv4) {
   SocketTest::TestSingleFlowControlCallbackIPv4();
 }
 
-TEST_F(MacAsyncSocketTest, TestSingleFlowControlCallbackIPv6) {
+TEST_F(MacAsyncSocketTest, DISABLED_TestSingleFlowControlCallbackIPv6) {
   SocketTest::TestSingleFlowControlCallbackIPv6();
 }
 
diff --git a/webrtc/base/messagequeue_unittest.cc b/webrtc/base/messagequeue_unittest.cc
index 78024e0b2..2027d91e2 100644
--- a/webrtc/base/messagequeue_unittest.cc
+++ b/webrtc/base/messagequeue_unittest.cc
@@ -16,6 +16,7 @@
 #include "webrtc/base/thread.h"
 #include "webrtc/base/timeutils.h"
 #include "webrtc/base/nullsocketserver.h"
+#include "webrtc/test/testsupport/gtest_disable.h"
 
 using namespace rtc;
 
@@ -79,7 +80,7 @@ TEST_F(MessageQueueTest,
   DelayedPostsWithIdenticalTimesAreProcessedInFifoOrder(&q_nullss);
 }
 
-TEST_F(MessageQueueTest, DisposeNotLocked) {
+TEST_F(MessageQueueTest, DISABLED_ON_MAC(DisposeNotLocked)) {
   bool was_locked = true;
   bool deleted = false;
   DeletedLockChecker* d = new DeletedLockChecker(this, &was_locked, &deleted);
diff --git a/webrtc/base/nat_unittest.cc b/webrtc/base/nat_unittest.cc
index 0e16259a0..19c1225c1 100644
--- a/webrtc/base/nat_unittest.cc
+++ b/webrtc/base/nat_unittest.cc
@@ -19,6 +19,7 @@
 #include "webrtc/base/physicalsocketserver.h"
 #include "webrtc/base/testclient.h"
 #include "webrtc/base/virtualsocketserver.h"
+#include "webrtc/test/testsupport/gtest_disable.h"
 
 using namespace rtc;
 
@@ -236,11 +237,11 @@ void TestPhysicalInternal(const SocketAddress& int_addr) {
   TestFilters(int_pss.get(), int_addr, ext_pss.get(), ext_addrs);
 }
 
-TEST(NatTest, TestPhysicalIPv4) {
+TEST(NatTest, DISABLED_ON_MAC(TestPhysicalIPv4)) {
   TestPhysicalInternal(SocketAddress("127.0.0.1", 0));
 }
 
-TEST(NatTest, TestPhysicalIPv6) {
+TEST(NatTest, DISABLED_ON_MAC(TestPhysicalIPv6)) {
   if (HasIPv6Enabled()) {
     TestPhysicalInternal(SocketAddress("::1", 0));
   } else {
@@ -278,11 +279,11 @@ void TestVirtualInternal(int family) {
   TestFilters(int_vss.get(), int_addr, ext_vss.get(), ext_addrs);
 }
 
-TEST(NatTest, TestVirtualIPv4) {
+TEST(NatTest, DISABLED_ON_MAC(TestVirtualIPv4)) {
   TestVirtualInternal(AF_INET);
 }
 
-TEST(NatTest, TestVirtualIPv6) {
+TEST(NatTest, DISABLED_ON_MAC(TestVirtualIPv6)) {
   if (HasIPv6Enabled()) {
     TestVirtualInternal(AF_INET6);
   } else {
diff --git a/webrtc/base/nullsocketserver_unittest.cc b/webrtc/base/nullsocketserver_unittest.cc
index fe21f6ad0..6d3eb52bc 100644
--- a/webrtc/base/nullsocketserver_unittest.cc
+++ b/webrtc/base/nullsocketserver_unittest.cc
@@ -10,6 +10,7 @@
 
 #include "webrtc/base/gunit.h"
 #include "webrtc/base/nullsocketserver.h"
+#include "webrtc/test/testsupport/gtest_disable.h"
 
 namespace rtc {
 
@@ -27,7 +28,7 @@ class NullSocketServerTest
   NullSocketServer ss_;
 };
 
-TEST_F(NullSocketServerTest, WaitAndSet) {
+TEST_F(NullSocketServerTest, DISABLED_ON_MAC(WaitAndSet)) {
   Thread thread;
   EXPECT_TRUE(thread.Start());
   thread.Post(this, 0);
diff --git a/webrtc/base/physicalsocketserver_unittest.cc b/webrtc/base/physicalsocketserver_unittest.cc
index df750adbe..4d57e730c 100644
--- a/webrtc/base/physicalsocketserver_unittest.cc
+++ b/webrtc/base/physicalsocketserver_unittest.cc
@@ -18,6 +18,7 @@
 #include "webrtc/base/socket_unittest.h"
 #include "webrtc/base/testutils.h"
 #include "webrtc/base/thread.h"
+#include "webrtc/test/testsupport/gtest_disable.h"
 
 namespace rtc {
 
@@ -106,11 +107,11 @@ TEST_F(PhysicalSocketTest, TestCloseInClosedCallbackIPv6) {
   SocketTest::TestCloseInClosedCallbackIPv6();
 }
 
-TEST_F(PhysicalSocketTest, TestSocketServerWaitIPv4) {
+TEST_F(PhysicalSocketTest, DISABLED_ON_MAC(TestSocketServerWaitIPv4)) {
   SocketTest::TestSocketServerWaitIPv4();
 }
 
-TEST_F(PhysicalSocketTest, TestSocketServerWaitIPv6) {
+TEST_F(PhysicalSocketTest, DISABLED_ON_MAC(TestSocketServerWaitIPv6)) {
   SocketTest::TestSocketServerWaitIPv6();
 }
 
@@ -206,7 +207,7 @@ Thread *PosixSignalDeliveryTest::signaled_thread_ = NULL;
 
 // Test receiving a synchronous signal while not in Wait() and then entering
 // Wait() afterwards.
-TEST_F(PosixSignalDeliveryTest, RaiseThenWait) {
+TEST_F(PosixSignalDeliveryTest, DISABLED_ON_MAC(RaiseThenWait)) {
   ASSERT_TRUE(ss_->SetPosixSignalHandler(SIGTERM, &RecordSignal));
   raise(SIGTERM);
   EXPECT_TRUE(ss_->Wait(0, true));
@@ -216,7 +217,7 @@ TEST_F(PosixSignalDeliveryTest, RaiseThenWait) {
 
 // Test that we can handle getting tons of repeated signals and that we see all
 // the different ones.
-TEST_F(PosixSignalDeliveryTest, InsanelyManySignals) {
+TEST_F(PosixSignalDeliveryTest, DISABLED_ON_MAC(InsanelyManySignals)) {
   ss_->SetPosixSignalHandler(SIGTERM, &RecordSignal);
   ss_->SetPosixSignalHandler(SIGINT, &RecordSignal);
   for (int i = 0; i < 10000; ++i) {
@@ -231,7 +232,7 @@ TEST_F(PosixSignalDeliveryTest, InsanelyManySignals) {
 }
 
 // Test that a signal during a Wait() call is detected.
-TEST_F(PosixSignalDeliveryTest, SignalDuringWait) {
+TEST_F(PosixSignalDeliveryTest, DISABLED_ON_MAC(SignalDuringWait)) {
   ss_->SetPosixSignalHandler(SIGALRM, &RecordSignal);
   alarm(1);
   EXPECT_TRUE(ss_->Wait(1500, true));
@@ -256,7 +257,7 @@ class RaiseSigTermRunnable : public Runnable {
 
 // Test that it works no matter what thread the kernel chooses to give the
 // signal to (since it's not guaranteed to be the one that Wait() runs on).
-TEST_F(PosixSignalDeliveryTest, SignalOnDifferentThread) {
+TEST_F(PosixSignalDeliveryTest, DISABLED_ON_MAC(SignalOnDifferentThread)) {
   ss_->SetPosixSignalHandler(SIGTERM, &RecordSignal);
   // Mask out SIGTERM so that it can't be delivered to this thread.
   sigset_t mask;
diff --git a/webrtc/base/proxy_unittest.cc b/webrtc/base/proxy_unittest.cc
index d8a523fe1..a1ade0c7a 100644
--- a/webrtc/base/proxy_unittest.cc
+++ b/webrtc/base/proxy_unittest.cc
@@ -17,6 +17,7 @@
 #include "webrtc/base/testclient.h"
 #include "webrtc/base/testechoserver.h"
 #include "webrtc/base/virtualsocketserver.h"
+#include "webrtc/test/testsupport/gtest_disable.h"
 
 using rtc::Socket;
 using rtc::Thread;
@@ -74,7 +75,7 @@ class ProxyTest : public testing::Test {
 };
 
 // Tests whether we can use a SOCKS5 proxy to connect to a server.
-TEST_F(ProxyTest, TestSocks5Connect) {
+TEST_F(ProxyTest, DISABLED_ON_MAC(TestSocks5Connect)) {
   rtc::AsyncSocket* socket =
       ss()->CreateAsyncSocket(kSocksProxyIntAddr.family(), SOCK_STREAM);
   rtc::AsyncSocksProxySocket* proxy_socket =
@@ -118,7 +119,7 @@ TEST_F(ProxyTest, TestHttpsConnect) {
 */
 
 // Tests whether we can autodetect a SOCKS5 proxy.
-TEST_F(ProxyTest, TestAutoDetectSocks5) {
+TEST_F(ProxyTest, DISABLED_ON_MAC(TestAutoDetectSocks5)) {
   EXPECT_EQ(rtc::PROXY_SOCKS5, DetectProxyType(kSocksProxyIntAddr));
 }
 
@@ -130,6 +131,6 @@ TEST_F(ProxyTest, TestAutoDetectHttps) {
 */
 
 // Tests whether we fail properly for no proxy.
-TEST_F(ProxyTest, TestAutoDetectBogus) {
+TEST_F(ProxyTest, DISABLED_ON_MAC(TestAutoDetectBogus)) {
   EXPECT_EQ(rtc::PROXY_UNKNOWN, DetectProxyType(kBogusProxyIntAddr));
 }
diff --git a/webrtc/base/sharedexclusivelock_unittest.cc b/webrtc/base/sharedexclusivelock_unittest.cc
index 42334af75..ea406cf9e 100644
--- a/webrtc/base/sharedexclusivelock_unittest.cc
+++ b/webrtc/base/sharedexclusivelock_unittest.cc
@@ -16,6 +16,7 @@
 #include "webrtc/base/sharedexclusivelock.h"
 #include "webrtc/base/thread.h"
 #include "webrtc/base/timeutils.h"
+#include "webrtc/test/testsupport/gtest_disable.h"
 
 namespace rtc {
 
@@ -157,7 +158,7 @@ TEST_F(SharedExclusiveLockTest, DISABLED_TestSharedShared) {
   EXPECT_LE(reader1.waiting_time_in_ms(), kNoWaitThresholdInMs);
 }
 
-TEST_F(SharedExclusiveLockTest, TestSharedExclusive) {
+TEST_F(SharedExclusiveLockTest, DISABLED_ON_MAC(TestSharedExclusive)) {
   bool done;
   WriteTask writer(shared_exclusive_lock_.get(), &value_, &done);
 
@@ -176,7 +177,7 @@ TEST_F(SharedExclusiveLockTest, TestSharedExclusive) {
   EXPECT_GE(writer.waiting_time_in_ms(), kWaitThresholdInMs);
 }
 
-TEST_F(SharedExclusiveLockTest, TestExclusiveShared) {
+TEST_F(SharedExclusiveLockTest, DISABLED_ON_MAC(TestExclusiveShared)) {
   int value;
   bool done;
   ReadTask reader(shared_exclusive_lock_.get(), &value_, &done);
@@ -196,7 +197,7 @@ TEST_F(SharedExclusiveLockTest, TestExclusiveShared) {
   EXPECT_GE(reader.waiting_time_in_ms(), kWaitThresholdInMs);
 }
 
-TEST_F(SharedExclusiveLockTest, TestExclusiveExclusive) {
+TEST_F(SharedExclusiveLockTest, DISABLED_ON_MAC(TestExclusiveExclusive)) {
   bool done;
   WriteTask writer(shared_exclusive_lock_.get(), &value_, &done);
 
diff --git a/webrtc/base/signalthread_unittest.cc b/webrtc/base/signalthread_unittest.cc
index e0ea54eb3..3f534312a 100644
--- a/webrtc/base/signalthread_unittest.cc
+++ b/webrtc/base/signalthread_unittest.cc
@@ -11,6 +11,7 @@
 #include "webrtc/base/gunit.h"
 #include "webrtc/base/signalthread.h"
 #include "webrtc/base/thread.h"
+#include "webrtc/test/testsupport/gtest_disable.h"
 
 using namespace rtc;
 
@@ -133,7 +134,7 @@ class OwnerThread : public Thread, public sigslot::has_slots<> {
 // Test for when the main thread goes away while the
 // signal thread is still working.  This may happen
 // when shutting down the process.
-TEST_F(SignalThreadTest, OwnerThreadGoesAway) {
+TEST_F(SignalThreadTest, DISABLED_ON_MAC(OwnerThreadGoesAway)) {
   {
     scoped_ptr<OwnerThread> owner(new OwnerThread(this));
     main_thread_ = owner.get();
@@ -156,7 +157,7 @@ TEST_F(SignalThreadTest, OwnerThreadGoesAway) {
   EXPECT_EQ(stopped, thread_stopped_); \
   EXPECT_EQ(deleted, thread_deleted_);
 
-TEST_F(SignalThreadTest, ThreadFinishes) {
+TEST_F(SignalThreadTest, DISABLED_ON_MAC(ThreadFinishes)) {
   thread_->Start();
   EXPECT_STATE(1, 0, 0, 0, 0);
   Thread::SleepMs(500);
@@ -165,7 +166,7 @@ TEST_F(SignalThreadTest, ThreadFinishes) {
   EXPECT_STATE(1, 1, 1, 0, 1);
 }
 
-TEST_F(SignalThreadTest, ReleasedThreadFinishes) {
+TEST_F(SignalThreadTest, DISABLED_ON_MAC(ReleasedThreadFinishes)) {
   thread_->Start();
   EXPECT_STATE(1, 0, 0, 0, 0);
   thread_->Release();
@@ -177,7 +178,7 @@ TEST_F(SignalThreadTest, ReleasedThreadFinishes) {
   EXPECT_STATE(1, 1, 1, 0, 1);
 }
 
-TEST_F(SignalThreadTest, DestroyedThreadCleansUp) {
+TEST_F(SignalThreadTest, DISABLED_ON_MAC(DestroyedThreadCleansUp)) {
   thread_->Start();
   EXPECT_STATE(1, 0, 0, 0, 0);
   thread_->Destroy(true);
@@ -186,7 +187,7 @@ TEST_F(SignalThreadTest, DestroyedThreadCleansUp) {
   EXPECT_STATE(1, 0, 0, 1, 1);
 }
 
-TEST_F(SignalThreadTest, DeferredDestroyedThreadCleansUp) {
+TEST_F(SignalThreadTest, DISABLED_ON_MAC(DeferredDestroyedThreadCleansUp)) {
   thread_->Start();
   EXPECT_STATE(1, 0, 0, 0, 0);
   thread_->Destroy(false);
diff --git a/webrtc/base/sslstreamadapter_unittest.cc b/webrtc/base/sslstreamadapter_unittest.cc
index af78bfff5..f7dcb71e4 100644
--- a/webrtc/base/sslstreamadapter_unittest.cc
+++ b/webrtc/base/sslstreamadapter_unittest.cc
@@ -21,6 +21,7 @@
 #include "webrtc/base/sslidentity.h"
 #include "webrtc/base/sslstreamadapter.h"
 #include "webrtc/base/stream.h"
+#include "webrtc/test/testsupport/gtest_disable.h"
 
 static const int kBlockSize = 4096;
 static const char kAES_CM_HMAC_SHA1_80[] = "AES_CM_128_HMAC_SHA1_80";
@@ -750,7 +751,7 @@ TEST_F(SSLStreamAdapterTestDTLS,
 };
 
 // Test a handshake with small MTU
-TEST_F(SSLStreamAdapterTestDTLS, TestDTLSConnectWithSmallMtu) {
+TEST_F(SSLStreamAdapterTestDTLS, DISABLED_ON_MAC(TestDTLSConnectWithSmallMtu)) {
   MAYBE_SKIP_TEST(HaveDtls);
   SetMtu(700);
   SetHandshakeWait(20000);
diff --git a/webrtc/base/task_unittest.cc b/webrtc/base/task_unittest.cc
index 8831259c6..bdc646a58 100644
--- a/webrtc/base/task_unittest.cc
+++ b/webrtc/base/task_unittest.cc
@@ -27,6 +27,7 @@
 #include "webrtc/base/taskrunner.h"
 #include "webrtc/base/thread.h"
 #include "webrtc/base/timeutils.h"
+#include "webrtc/test/testsupport/gtest_disable.h"
 
 namespace rtc {
 
@@ -335,7 +336,7 @@ class TaskAbortTest : public sigslot::has_slots<> {
   DISALLOW_EVIL_CONSTRUCTORS(TaskAbortTest);
 };
 
-TEST(start_task_test, Abort) {
+TEST(start_task_test, DISABLED_ON_MAC(Abort)) {
   TaskAbortTest abort_test;
   abort_test.Start();
 }
@@ -398,7 +399,7 @@ class AbortShouldWakeTest : public sigslot::has_slots<> {
   DISALLOW_EVIL_CONSTRUCTORS(AbortShouldWakeTest);
 };
 
-TEST(start_task_test, AbortShouldWake) {
+TEST(start_task_test, DISABLED_ON_MAC(AbortShouldWake)) {
   AbortShouldWakeTest abort_should_wake_test;
   abort_should_wake_test.Start();
 }
@@ -496,7 +497,7 @@ class DeleteTestTaskRunner : public TaskRunner {
   DISALLOW_EVIL_CONSTRUCTORS(DeleteTestTaskRunner);
 };
 
-TEST(unstarted_task_test, DeleteTask) {
+TEST(unstarted_task_test, DISABLED_ON_MAC(DeleteTask)) {
   // This test ensures that we don't
   // crash if a task is deleted without running it.
   DeleteTestTaskRunner task_runner;
@@ -511,7 +512,7 @@ TEST(unstarted_task_test, DeleteTask) {
   task_runner.RunTasks();
 }
 
-TEST(unstarted_task_test, DoNotDeleteTask1) {
+TEST(unstarted_task_test, DISABLED_ON_MAC(DoNotDeleteTask1)) {
   // This test ensures that we don't
   // crash if a task runner is deleted without
   // running a certain task.
@@ -525,7 +526,7 @@ TEST(unstarted_task_test, DoNotDeleteTask1) {
   // Never run the tasks
 }
 
-TEST(unstarted_task_test, DoNotDeleteTask2) {
+TEST(unstarted_task_test, DISABLED_ON_MAC(DoNotDeleteTask2)) {
   // This test ensures that we don't
   // crash if a taskrunner is delete with a
   // task that has never been started.
diff --git a/webrtc/base/testclient_unittest.cc b/webrtc/base/testclient_unittest.cc
index c28266867..21a70555d 100644
--- a/webrtc/base/testclient_unittest.cc
+++ b/webrtc/base/testclient_unittest.cc
@@ -14,6 +14,7 @@
 #include "webrtc/base/testclient.h"
 #include "webrtc/base/testechoserver.h"
 #include "webrtc/base/thread.h"
+#include "webrtc/test/testsupport/gtest_disable.h"
 
 using namespace rtc;
 
@@ -51,11 +52,11 @@ void TestTcpInternal(const SocketAddress& loopback) {
 }
 
 // Tests whether the TestClient can send UDP to itself.
-TEST(TestClientTest, TestUdpIPv4) {
+TEST(TestClientTest, DISABLED_ON_MAC(TestUdpIPv4)) {
   TestUdpInternal(SocketAddress("127.0.0.1", 0));
 }
 
-TEST(TestClientTest, TestUdpIPv6) {
+TEST(TestClientTest, DISABLED_ON_MAC(TestUdpIPv6)) {
   if (HasIPv6Enabled()) {
     TestUdpInternal(SocketAddress("::1", 0));
   } else {
@@ -64,11 +65,11 @@ TEST(TestClientTest, TestUdpIPv6) {
 }
 
 // Tests whether the TestClient can connect to a server and exchange data.
-TEST(TestClientTest, TestTcpIPv4) {
+TEST(TestClientTest, DISABLED_ON_MAC(TestTcpIPv4)) {
   TestTcpInternal(SocketAddress("127.0.0.1", 0));
 }
 
-TEST(TestClientTest, TestTcpIPv6) {
+TEST(TestClientTest, DISABLED_ON_MAC(TestTcpIPv6)) {
   if (HasIPv6Enabled()) {
     TestTcpInternal(SocketAddress("::1", 0));
   } else {
diff --git a/webrtc/base/thread_checker_unittest.cc b/webrtc/base/thread_checker_unittest.cc
index 87e69c035..877cc86b8 100644
--- a/webrtc/base/thread_checker_unittest.cc
+++ b/webrtc/base/thread_checker_unittest.cc
@@ -15,6 +15,7 @@
 #include "webrtc/base/thread.h"
 #include "webrtc/base/thread_checker.h"
 #include "webrtc/base/scoped_ptr.h"
+#include "webrtc/test/testsupport/gtest_disable.h"
 
 // Duplicated from base/threading/thread_checker.h so that we can be
 // good citizens there and undef the macro.
@@ -115,7 +116,7 @@ TEST(ThreadCheckerTest, CallsAllowedOnSameThread) {
   thread_checker_class.reset();
 }
 
-TEST(ThreadCheckerTest, DestructorAllowedOnDifferentThread) {
+TEST(ThreadCheckerTest, DISABLED_ON_MAC(DestructorAllowedOnDifferentThread)) {
   scoped_ptr<ThreadCheckerClass> thread_checker_class(
       new ThreadCheckerClass);
 
@@ -128,7 +129,7 @@ TEST(ThreadCheckerTest, DestructorAllowedOnDifferentThread) {
   delete_on_thread.Join();
 }
 
-TEST(ThreadCheckerTest, DetachFromThread) {
+TEST(ThreadCheckerTest, DISABLED_ON_MAC(DetachFromThread)) {
   scoped_ptr<ThreadCheckerClass> thread_checker_class(
       new ThreadCheckerClass);
 
diff --git a/webrtc/base/thread_unittest.cc b/webrtc/base/thread_unittest.cc
index 6a6875745..97fb91dac 100644
--- a/webrtc/base/thread_unittest.cc
+++ b/webrtc/base/thread_unittest.cc
@@ -15,6 +15,7 @@
 #include "webrtc/base/physicalsocketserver.h"
 #include "webrtc/base/socketaddress.h"
 #include "webrtc/base/thread.h"
+#include "webrtc/test/testsupport/gtest_disable.h"
 
 #if defined(WEBRTC_WIN)
 #include <comdef.h>  // NOLINT
@@ -198,7 +199,7 @@ TEST(ThreadTest, DISABLED_Main) {
 
 // Test that setting thread names doesn't cause a malfunction.
 // There's no easy way to verify the name was set properly at this time.
-TEST(ThreadTest, Names) {
+TEST(ThreadTest, DISABLED_ON_MAC(Names)) {
   // Default name
   Thread *thread;
   thread = new Thread();
@@ -221,7 +222,7 @@ TEST(ThreadTest, Names) {
 
 // Test that setting thread priorities doesn't cause a malfunction.
 // There's no easy way to verify the priority was set properly at this time.
-TEST(ThreadTest, Priorities) {
+TEST(ThreadTest, DISABLED_ON_MAC(Priorities)) {
   Thread *thread;
   thread = new Thread();
   EXPECT_TRUE(thread->SetPriority(PRIORITY_HIGH));
@@ -246,7 +247,7 @@ TEST(ThreadTest, Priorities) {
 
 }
 
-TEST(ThreadTest, Wrap) {
+TEST(ThreadTest, DISABLED_ON_MAC(Wrap)) {
   CustomThread* cthread = new CustomThread();
   EXPECT_TRUE(cthread->WrapCurrent());
   EXPECT_TRUE(cthread->RunningForTest());
@@ -256,7 +257,7 @@ TEST(ThreadTest, Wrap) {
   delete cthread;
 }
 
-TEST(ThreadTest, Invoke) {
+TEST(ThreadTest, DISABLED_ON_MAC(Invoke)) {
   // Create and start the thread.
   Thread thread;
   thread.Start();
@@ -304,7 +305,7 @@ class AsyncInvokeTest : public testing::Test {
   Thread* expected_thread_;
 };
 
-TEST_F(AsyncInvokeTest, FireAndForget) {
+TEST_F(AsyncInvokeTest, DISABLED_ON_MAC(FireAndForget)) {
   AsyncInvoker invoker;
   // Create and start the thread.
   Thread thread;
@@ -315,7 +316,7 @@ TEST_F(AsyncInvokeTest, FireAndForget) {
   EXPECT_TRUE_WAIT(called, kWaitTimeout);
 }
 
-TEST_F(AsyncInvokeTest, WithCallback) {
+TEST_F(AsyncInvokeTest, DISABLED_ON_MAC(WithCallback)) {
   AsyncInvoker invoker;
   // Create and start the thread.
   Thread thread;
@@ -328,7 +329,7 @@ TEST_F(AsyncInvokeTest, WithCallback) {
   EXPECT_EQ_WAIT(42, int_value_, kWaitTimeout);
 }
 
-TEST_F(AsyncInvokeTest, CancelInvoker) {
+TEST_F(AsyncInvokeTest, DISABLED_ON_MAC(CancelInvoker)) {
   // Create and start the thread.
   Thread thread;
   thread.Start();
@@ -344,7 +345,7 @@ TEST_F(AsyncInvokeTest, CancelInvoker) {
   EXPECT_EQ(0, int_value_);
 }
 
-TEST_F(AsyncInvokeTest, CancelCallingThread) {
+TEST_F(AsyncInvokeTest, DISABLED_ON_MAC(CancelCallingThread)) {
   AsyncInvoker invoker;
   { // Create and start the thread.
     Thread thread;
@@ -361,7 +362,7 @@ TEST_F(AsyncInvokeTest, CancelCallingThread) {
   EXPECT_EQ(0, int_value_);
 }
 
-TEST_F(AsyncInvokeTest, KillInvokerBeforeExecute) {
+TEST_F(AsyncInvokeTest, DISABLED_ON_MAC(KillInvokerBeforeExecute)) {
   Thread thread;
   thread.Start();
   {
diff --git a/webrtc/base/virtualsocket_unittest.cc b/webrtc/base/virtualsocket_unittest.cc
index 253d2c5be..0a26cc9da 100644
--- a/webrtc/base/virtualsocket_unittest.cc
+++ b/webrtc/base/virtualsocket_unittest.cc
@@ -21,6 +21,7 @@
 #include "webrtc/base/thread.h"
 #include "webrtc/base/timeutils.h"
 #include "webrtc/base/virtualsocketserver.h"
+#include "webrtc/test/testsupport/gtest_disable.h"
 
 using namespace rtc;
 
@@ -775,37 +776,37 @@ class VirtualSocketServerTest : public testing::Test {
   const SocketAddress kIPv6AnyAddress;
 };
 
-TEST_F(VirtualSocketServerTest, basic_v4) {
+TEST_F(VirtualSocketServerTest, DISABLED_ON_MAC(basic_v4)) {
   SocketAddress ipv4_test_addr(IPAddress(INADDR_ANY), 5000);
   BasicTest(ipv4_test_addr);
 }
 
-TEST_F(VirtualSocketServerTest, basic_v6) {
+TEST_F(VirtualSocketServerTest,DISABLED_ON_MAC( basic_v6)) {
   SocketAddress ipv6_test_addr(IPAddress(in6addr_any), 5000);
   BasicTest(ipv6_test_addr);
 }
 
-TEST_F(VirtualSocketServerTest, connect_v4) {
+TEST_F(VirtualSocketServerTest, DISABLED_ON_MAC(connect_v4)) {
   ConnectTest(kIPv4AnyAddress);
 }
 
-TEST_F(VirtualSocketServerTest, connect_v6) {
+TEST_F(VirtualSocketServerTest, DISABLED_ON_MAC(connect_v6)) {
   ConnectTest(kIPv6AnyAddress);
 }
 
-TEST_F(VirtualSocketServerTest, connect_to_non_listener_v4) {
+TEST_F(VirtualSocketServerTest, DISABLED_ON_MAC(connect_to_non_listener_v4)) {
   ConnectToNonListenerTest(kIPv4AnyAddress);
 }
 
-TEST_F(VirtualSocketServerTest, connect_to_non_listener_v6) {
+TEST_F(VirtualSocketServerTest, DISABLED_ON_MAC(connect_to_non_listener_v6)) {
   ConnectToNonListenerTest(kIPv6AnyAddress);
 }
 
-TEST_F(VirtualSocketServerTest, close_during_connect_v4) {
+TEST_F(VirtualSocketServerTest, DISABLED_ON_MAC(close_during_connect_v4)) {
   CloseDuringConnectTest(kIPv4AnyAddress);
 }
 
-TEST_F(VirtualSocketServerTest, close_during_connect_v6) {
+TEST_F(VirtualSocketServerTest, DISABLED_ON_MAC(close_during_connect_v6)) {
   CloseDuringConnectTest(kIPv6AnyAddress);
 }
 
@@ -817,11 +818,11 @@ TEST_F(VirtualSocketServerTest, close_v6) {
   CloseTest(kIPv6AnyAddress);
 }
 
-TEST_F(VirtualSocketServerTest, tcp_send_v4) {
+TEST_F(VirtualSocketServerTest, DISABLED_ON_MAC(tcp_send_v4)) {
   TcpSendTest(kIPv4AnyAddress);
 }
 
-TEST_F(VirtualSocketServerTest, tcp_send_v6) {
+TEST_F(VirtualSocketServerTest, DISABLED_ON_MAC(tcp_send_v6)) {
   TcpSendTest(kIPv6AnyAddress);
 }
 
@@ -833,17 +834,17 @@ TEST_F(VirtualSocketServerTest, TcpSendsPacketsInOrder_v6) {
   TcpSendsPacketsInOrderTest(kIPv6AnyAddress);
 }
 
-TEST_F(VirtualSocketServerTest, bandwidth_v4) {
+TEST_F(VirtualSocketServerTest, DISABLED_ON_MAC(bandwidth_v4)) {
   SocketAddress ipv4_test_addr(IPAddress(INADDR_ANY), 1000);
   BandwidthTest(ipv4_test_addr);
 }
 
-TEST_F(VirtualSocketServerTest, bandwidth_v6) {
+TEST_F(VirtualSocketServerTest, DISABLED_ON_MAC(bandwidth_v6)) {
   SocketAddress ipv6_test_addr(IPAddress(in6addr_any), 1000);
   BandwidthTest(ipv6_test_addr);
 }
 
-TEST_F(VirtualSocketServerTest, delay_v4) {
+TEST_F(VirtualSocketServerTest, DISABLED_ON_MAC(delay_v4)) {
   SocketAddress ipv4_test_addr(IPAddress(INADDR_ANY), 1000);
   DelayTest(ipv4_test_addr);
 }
@@ -855,104 +856,104 @@ TEST_F(VirtualSocketServerTest, DISABLED_delay_v6) {
 }
 
 // Works, receiving socket sees 127.0.0.2.
-TEST_F(VirtualSocketServerTest, CanConnectFromMappedIPv6ToIPv4Any) {
+TEST_F(VirtualSocketServerTest, DISABLED_ON_MAC(CanConnectFromMappedIPv6ToIPv4Any)) {
   CrossFamilyConnectionTest(SocketAddress("::ffff:127.0.0.2", 0),
                             SocketAddress("0.0.0.0", 5000),
                             true);
 }
 
 // Fails.
-TEST_F(VirtualSocketServerTest, CantConnectFromUnMappedIPv6ToIPv4Any) {
+TEST_F(VirtualSocketServerTest, DISABLED_ON_MAC(CantConnectFromUnMappedIPv6ToIPv4Any)) {
   CrossFamilyConnectionTest(SocketAddress("::2", 0),
                             SocketAddress("0.0.0.0", 5000),
                             false);
 }
 
 // Fails.
-TEST_F(VirtualSocketServerTest, CantConnectFromUnMappedIPv6ToMappedIPv6) {
+TEST_F(VirtualSocketServerTest, DISABLED_ON_MAC(CantConnectFromUnMappedIPv6ToMappedIPv6)) {
   CrossFamilyConnectionTest(SocketAddress("::2", 0),
                             SocketAddress("::ffff:127.0.0.1", 5000),
                             false);
 }
 
 // Works. receiving socket sees ::ffff:127.0.0.2.
-TEST_F(VirtualSocketServerTest, CanConnectFromIPv4ToIPv6Any) {
+TEST_F(VirtualSocketServerTest, DISABLED_ON_MAC(CanConnectFromIPv4ToIPv6Any)) {
   CrossFamilyConnectionTest(SocketAddress("127.0.0.2", 0),
                             SocketAddress("::", 5000),
                             true);
 }
 
 // Fails.
-TEST_F(VirtualSocketServerTest, CantConnectFromIPv4ToUnMappedIPv6) {
+TEST_F(VirtualSocketServerTest, DISABLED_ON_MAC(CantConnectFromIPv4ToUnMappedIPv6)) {
   CrossFamilyConnectionTest(SocketAddress("127.0.0.2", 0),
                             SocketAddress("::1", 5000),
                             false);
 }
 
 // Works. Receiving socket sees ::ffff:127.0.0.1.
-TEST_F(VirtualSocketServerTest, CanConnectFromIPv4ToMappedIPv6) {
+TEST_F(VirtualSocketServerTest, DISABLED_ON_MAC(CanConnectFromIPv4ToMappedIPv6)) {
   CrossFamilyConnectionTest(SocketAddress("127.0.0.1", 0),
                             SocketAddress("::ffff:127.0.0.2", 5000),
                             true);
 }
 
 // Works, receiving socket sees a result from GetNextIP.
-TEST_F(VirtualSocketServerTest, CanConnectFromUnboundIPv6ToIPv4Any) {
+TEST_F(VirtualSocketServerTest, DISABLED_ON_MAC(CanConnectFromUnboundIPv6ToIPv4Any)) {
   CrossFamilyConnectionTest(SocketAddress("::", 0),
                             SocketAddress("0.0.0.0", 5000),
                             true);
 }
 
 // Works, receiving socket sees whatever GetNextIP gave the client.
-TEST_F(VirtualSocketServerTest, CanConnectFromUnboundIPv4ToIPv6Any) {
+TEST_F(VirtualSocketServerTest, DISABLED_ON_MAC(CanConnectFromUnboundIPv4ToIPv6Any)) {
   CrossFamilyConnectionTest(SocketAddress("0.0.0.0", 0),
                             SocketAddress("::", 5000),
                             true);
 }
 
-TEST_F(VirtualSocketServerTest, CanSendDatagramFromUnboundIPv4ToIPv6Any) {
+TEST_F(VirtualSocketServerTest, DISABLED_ON_MAC(CanSendDatagramFromUnboundIPv4ToIPv6Any)) {
   CrossFamilyDatagramTest(SocketAddress("0.0.0.0", 0),
                           SocketAddress("::", 5000),
                           true);
 }
 
-TEST_F(VirtualSocketServerTest, CanSendDatagramFromMappedIPv6ToIPv4Any) {
+TEST_F(VirtualSocketServerTest, DISABLED_ON_MAC(CanSendDatagramFromMappedIPv6ToIPv4Any)) {
   CrossFamilyDatagramTest(SocketAddress("::ffff:127.0.0.1", 0),
                           SocketAddress("0.0.0.0", 5000),
                           true);
 }
 
-TEST_F(VirtualSocketServerTest, CantSendDatagramFromUnMappedIPv6ToIPv4Any) {
+TEST_F(VirtualSocketServerTest, DISABLED_ON_MAC(CantSendDatagramFromUnMappedIPv6ToIPv4Any)) {
   CrossFamilyDatagramTest(SocketAddress("::2", 0),
                           SocketAddress("0.0.0.0", 5000),
                           false);
 }
 
-TEST_F(VirtualSocketServerTest, CantSendDatagramFromUnMappedIPv6ToMappedIPv6) {
+TEST_F(VirtualSocketServerTest, DISABLED_ON_MAC(CantSendDatagramFromUnMappedIPv6ToMappedIPv6)) {
   CrossFamilyDatagramTest(SocketAddress("::2", 0),
                           SocketAddress("::ffff:127.0.0.1", 5000),
                           false);
 }
 
-TEST_F(VirtualSocketServerTest, CanSendDatagramFromIPv4ToIPv6Any) {
+TEST_F(VirtualSocketServerTest, DISABLED_ON_MAC(CanSendDatagramFromIPv4ToIPv6Any)) {
   CrossFamilyDatagramTest(SocketAddress("127.0.0.2", 0),
                           SocketAddress("::", 5000),
                           true);
 }
 
-TEST_F(VirtualSocketServerTest, CantSendDatagramFromIPv4ToUnMappedIPv6) {
+TEST_F(VirtualSocketServerTest, DISABLED_ON_MAC(CantSendDatagramFromIPv4ToUnMappedIPv6)) {
   CrossFamilyDatagramTest(SocketAddress("127.0.0.2", 0),
                           SocketAddress("::1", 5000),
                           false);
 }
 
-TEST_F(VirtualSocketServerTest, CanSendDatagramFromIPv4ToMappedIPv6) {
+TEST_F(VirtualSocketServerTest, DISABLED_ON_MAC(CanSendDatagramFromIPv4ToMappedIPv6)) {
   CrossFamilyDatagramTest(SocketAddress("127.0.0.1", 0),
                           SocketAddress("::ffff:127.0.0.2", 5000),
                           true);
 }
 
-TEST_F(VirtualSocketServerTest, CanSendDatagramFromUnboundIPv6ToIPv4Any) {
+TEST_F(VirtualSocketServerTest, DISABLED_ON_MAC(CanSendDatagramFromUnboundIPv6ToIPv4Any)) {
   CrossFamilyDatagramTest(SocketAddress("::", 0),
                           SocketAddress("0.0.0.0", 5000),
                           true);