base/testutils.h: Use namespace webrtc::testing instead of plain testing

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.
  */
 
@@ skipping 167 matching lines @@
 
 TEST_F(PhysicalSocketTest, TestConnectWithDnsLookupIPv6) {
   SocketTest::TestConnectWithDnsLookupIPv6();
 }
 
 TEST_F(PhysicalSocketTest, TestConnectFailIPv4) {
   SocketTest::TestConnectFailIPv4();
 }
 
 void PhysicalSocketTest::ConnectInternalAcceptError(const IPAddress& loopback) {
-  testing::StreamSink sink;
+  webrtc::testing::StreamSink sink;
   SocketAddress accept_addr;
 
   // Create two clients.
   std::unique_ptr<AsyncSocket> client1(
       server_->CreateAsyncSocket(loopback.family(), SOCK_STREAM));
   sink.Monitor(client1.get());
   EXPECT_EQ(AsyncSocket::CS_CLOSED, client1->GetState());
   EXPECT_PRED1(IsUnspecOrEmptyIP, client1->GetLocalAddress().ipaddr());
 
   std::unique_ptr<AsyncSocket> client2(
       server_->CreateAsyncSocket(loopback.family(), SOCK_STREAM));
   sink.Monitor(client2.get());
   EXPECT_EQ(AsyncSocket::CS_CLOSED, client2->GetState());
   EXPECT_PRED1(IsUnspecOrEmptyIP, client2->GetLocalAddress().ipaddr());
 
   // Create server and listen.
   std::unique_ptr<AsyncSocket> server(
       server_->CreateAsyncSocket(loopback.family(), SOCK_STREAM));
   sink.Monitor(server.get());
   EXPECT_EQ(0, server->Bind(SocketAddress(loopback, 0)));
   EXPECT_EQ(0, server->Listen(5));
   EXPECT_EQ(AsyncSocket::CS_CONNECTING, server->GetState());
 
   // Ensure no pending server connections, since we haven't done anything yet.
-  EXPECT_FALSE(sink.Check(server.get(), testing::SSE_READ));
+  EXPECT_FALSE(sink.Check(server.get(), webrtc::testing::SSE_READ));
   EXPECT_TRUE(nullptr == server->Accept(&accept_addr));
   EXPECT_TRUE(accept_addr.IsNil());
 
   // Attempt first connect to listening socket.
   EXPECT_EQ(0, client1->Connect(server->GetLocalAddress()));
   EXPECT_FALSE(client1->GetLocalAddress().IsNil());
   EXPECT_NE(server->GetLocalAddress(), client1->GetLocalAddress());
 
   // Client is connecting, outcome not yet determined.
   EXPECT_EQ(AsyncSocket::CS_CONNECTING, client1->GetState());
-  EXPECT_FALSE(sink.Check(client1.get(), testing::SSE_OPEN));
-  EXPECT_FALSE(sink.Check(client1.get(), testing::SSE_CLOSE));
+  EXPECT_FALSE(sink.Check(client1.get(), webrtc::testing::SSE_OPEN));
+  EXPECT_FALSE(sink.Check(client1.get(), webrtc::testing::SSE_CLOSE));
 
   // Server has pending connection, try to accept it (will fail).
-  EXPECT_TRUE_WAIT((sink.Check(server.get(), testing::SSE_READ)), kTimeout);
+  EXPECT_TRUE_WAIT((sink.Check(server.get(), webrtc::testing::SSE_READ)),
+                   kTimeout);
   // Simulate "::accept" returning an error.
   SetFailAccept(true);
   std::unique_ptr<AsyncSocket> accepted(server->Accept(&accept_addr));
   EXPECT_FALSE(accepted);
   ASSERT_TRUE(accept_addr.IsNil());
 
   // Ensure no more pending server connections.
-  EXPECT_FALSE(sink.Check(server.get(), testing::SSE_READ));
+  EXPECT_FALSE(sink.Check(server.get(), webrtc::testing::SSE_READ));
   EXPECT_TRUE(nullptr == server->Accept(&accept_addr));
   EXPECT_TRUE(accept_addr.IsNil());
 
   // Attempt second connect to listening socket.
   EXPECT_EQ(0, client2->Connect(server->GetLocalAddress()));
   EXPECT_FALSE(client2->GetLocalAddress().IsNil());
   EXPECT_NE(server->GetLocalAddress(), client2->GetLocalAddress());
 
   // Client is connecting, outcome not yet determined.
   EXPECT_EQ(AsyncSocket::CS_CONNECTING, client2->GetState());
-  EXPECT_FALSE(sink.Check(client2.get(), testing::SSE_OPEN));
-  EXPECT_FALSE(sink.Check(client2.get(), testing::SSE_CLOSE));
+  EXPECT_FALSE(sink.Check(client2.get(), webrtc::testing::SSE_OPEN));
+  EXPECT_FALSE(sink.Check(client2.get(), webrtc::testing::SSE_CLOSE));
 
   // Server has pending connection, try to accept it (will succeed).
-  EXPECT_TRUE_WAIT((sink.Check(server.get(), testing::SSE_READ)), kTimeout);
+  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) {
   ConnectInternalAcceptError(kIPv4Loopback);
 }
@@ skipping 325 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