base/testutils.h: Use namespace webrtc::testing instead of plain testing
We shouldn't pollute the global namespace.
BUG=webrtc:7484
Review-Url: https://codereview.webrtc.org/2819473004
Cr-Commit-Position: refs/heads/master@{#17735}
diff --git a/webrtc/base/httpbase_unittest.cc b/webrtc/base/httpbase_unittest.cc
index 52c1c53..11fa821 100644
--- a/webrtc/base/httpbase_unittest.cc
+++ b/webrtc/base/httpbase_unittest.cc
@@ -106,13 +106,13 @@
HttpResponseData data;
// The source of http data, and source events
- testing::StreamSource src;
+ webrtc::testing::StreamSource src;
std::vector<Event> events;
// Document stream, and stream events
bool obtain_stream;
StreamInterface* http_stream;
- testing::StreamSink sink;
+ webrtc::testing::StreamSink sink;
};
void HttpBaseTest::SetupSource(const char* http_data) {
@@ -508,7 +508,7 @@
src.SetState(SS_CLOSED);
// Observe error event on document stream
- EXPECT_EQ(testing::SSE_ERROR, sink.Events(http_stream));
+ EXPECT_EQ(webrtc::testing::SSE_ERROR, sink.Events(http_stream));
// Future reads give an error
int error = 0;
diff --git a/webrtc/base/httpserver_unittest.cc b/webrtc/base/httpserver_unittest.cc
index 96d5fb6..4db4ad7 100644
--- a/webrtc/base/httpserver_unittest.cc
+++ b/webrtc/base/httpserver_unittest.cc
@@ -12,7 +12,7 @@
#include "webrtc/base/httpserver.h"
#include "webrtc/base/testutils.h"
-using namespace testing;
+using namespace webrtc::testing;
namespace rtc {
diff --git a/webrtc/base/physicalsocketserver_unittest.cc b/webrtc/base/physicalsocketserver_unittest.cc
index 0eea1d5..de0d485 100644
--- a/webrtc/base/physicalsocketserver_unittest.cc
+++ b/webrtc/base/physicalsocketserver_unittest.cc
@@ -185,7 +185,7 @@
}
void PhysicalSocketTest::ConnectInternalAcceptError(const IPAddress& loopback) {
- testing::StreamSink sink;
+ webrtc::testing::StreamSink sink;
SocketAddress accept_addr;
// Create two clients.
@@ -210,7 +210,7 @@
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());
@@ -221,11 +221,12 @@
// 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));
@@ -233,7 +234,7 @@
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());
@@ -244,11 +245,12 @@
// 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);
diff --git a/webrtc/base/socket_unittest.cc b/webrtc/base/socket_unittest.cc
index 4a59a16..762a88a 100644
--- a/webrtc/base/socket_unittest.cc
+++ b/webrtc/base/socket_unittest.cc
@@ -24,6 +24,13 @@
namespace rtc {
+using webrtc::testing::SSE_CLOSE;
+using webrtc::testing::SSE_ERROR;
+using webrtc::testing::SSE_OPEN;
+using webrtc::testing::SSE_READ;
+using webrtc::testing::SSE_WRITE;
+using webrtc::testing::StreamSink;
+
#define MAYBE_SKIP_IPV6 \
if (!HasIPv6Enabled()) { \
LOG(LS_INFO) << "No IPv6... skipping"; \
@@ -204,7 +211,7 @@
}
void SocketTest::ConnectInternal(const IPAddress& loopback) {
- testing::StreamSink sink;
+ StreamSink sink;
SocketAddress accept_addr;
// Create client.
@@ -223,7 +230,7 @@
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(), SSE_READ));
EXPECT_TRUE(nullptr == server->Accept(&accept_addr));
EXPECT_TRUE(accept_addr.IsNil());
@@ -234,11 +241,11 @@
// Client is connecting, outcome not yet determined.
EXPECT_EQ(AsyncSocket::CS_CONNECTING, client->GetState());
- EXPECT_FALSE(sink.Check(client.get(), testing::SSE_OPEN));
- EXPECT_FALSE(sink.Check(client.get(), testing::SSE_CLOSE));
+ EXPECT_FALSE(sink.Check(client.get(), SSE_OPEN));
+ EXPECT_FALSE(sink.Check(client.get(), SSE_CLOSE));
// Server has pending connection, accept it.
- EXPECT_TRUE_WAIT((sink.Check(server.get(), testing::SSE_READ)), kTimeout);
+ EXPECT_TRUE_WAIT((sink.Check(server.get(), SSE_READ)), kTimeout);
std::unique_ptr<AsyncSocket> accepted(server->Accept(&accept_addr));
ASSERT_TRUE(accepted);
EXPECT_FALSE(accept_addr.IsNil());
@@ -251,15 +258,15 @@
// Connected from client perspective, check the addresses are correct.
EXPECT_EQ_WAIT(AsyncSocket::CS_CONNECTED, client->GetState(), kTimeout);
- EXPECT_TRUE(sink.Check(client.get(), testing::SSE_OPEN));
- EXPECT_FALSE(sink.Check(client.get(), testing::SSE_CLOSE));
+ EXPECT_TRUE(sink.Check(client.get(), SSE_OPEN));
+ EXPECT_FALSE(sink.Check(client.get(), SSE_CLOSE));
EXPECT_EQ(client->GetRemoteAddress(), server->GetLocalAddress());
EXPECT_EQ(client->GetRemoteAddress(), accepted->GetLocalAddress());
}
void SocketTest::ConnectWithDnsLookupInternal(const IPAddress& loopback,
const std::string& host) {
- testing::StreamSink sink;
+ StreamSink sink;
SocketAddress accept_addr;
// Create client.
@@ -283,11 +290,11 @@
// Client is connecting, outcome not yet determined.
EXPECT_EQ(AsyncSocket::CS_CONNECTING, client->GetState());
- EXPECT_FALSE(sink.Check(client.get(), testing::SSE_OPEN));
- EXPECT_FALSE(sink.Check(client.get(), testing::SSE_CLOSE));
+ EXPECT_FALSE(sink.Check(client.get(), SSE_OPEN));
+ EXPECT_FALSE(sink.Check(client.get(), SSE_CLOSE));
// Server has pending connection, accept it.
- EXPECT_TRUE_WAIT((sink.Check(server.get(), testing::SSE_READ)), kTimeout);
+ EXPECT_TRUE_WAIT((sink.Check(server.get(), SSE_READ)), kTimeout);
std::unique_ptr<AsyncSocket> accepted(server->Accept(&accept_addr));
ASSERT_TRUE(accepted);
EXPECT_FALSE(accept_addr.IsNil());
@@ -300,14 +307,14 @@
// Connected from client perspective, check the addresses are correct.
EXPECT_EQ_WAIT(AsyncSocket::CS_CONNECTED, client->GetState(), kTimeout);
- EXPECT_TRUE(sink.Check(client.get(), testing::SSE_OPEN));
- EXPECT_FALSE(sink.Check(client.get(), testing::SSE_CLOSE));
+ EXPECT_TRUE(sink.Check(client.get(), SSE_OPEN));
+ EXPECT_FALSE(sink.Check(client.get(), SSE_CLOSE));
EXPECT_EQ(client->GetRemoteAddress(), server->GetLocalAddress());
EXPECT_EQ(client->GetRemoteAddress(), accepted->GetLocalAddress());
}
void SocketTest::ConnectFailInternal(const IPAddress& loopback) {
- testing::StreamSink sink;
+ StreamSink sink;
SocketAddress accept_addr;
// Create client.
@@ -329,18 +336,18 @@
// Wait for connection to fail (ECONNREFUSED).
EXPECT_EQ_WAIT(AsyncSocket::CS_CLOSED, client->GetState(), kTimeout);
- EXPECT_FALSE(sink.Check(client.get(), testing::SSE_OPEN));
- EXPECT_TRUE(sink.Check(client.get(), testing::SSE_ERROR));
+ EXPECT_FALSE(sink.Check(client.get(), SSE_OPEN));
+ EXPECT_TRUE(sink.Check(client.get(), SSE_ERROR));
EXPECT_TRUE(client->GetRemoteAddress().IsNil());
// Should be no pending server connections.
- EXPECT_FALSE(sink.Check(server.get(), testing::SSE_READ));
+ EXPECT_FALSE(sink.Check(server.get(), SSE_READ));
EXPECT_TRUE(nullptr == server->Accept(&accept_addr));
EXPECT_EQ(IPAddress(), accept_addr.ipaddr());
}
void SocketTest::ConnectWithDnsLookupFailInternal(const IPAddress& loopback) {
- testing::StreamSink sink;
+ StreamSink sink;
SocketAddress accept_addr;
// Create client.
@@ -371,11 +378,11 @@
}
EXPECT_EQ_WAIT(AsyncSocket::CS_CLOSED, client->GetState(), kTimeout);
- EXPECT_FALSE(sink.Check(client.get(), testing::SSE_OPEN));
- EXPECT_TRUE(sink.Check(client.get(), testing::SSE_ERROR));
+ EXPECT_FALSE(sink.Check(client.get(), SSE_OPEN));
+ EXPECT_TRUE(sink.Check(client.get(), SSE_ERROR));
EXPECT_TRUE(client->GetRemoteAddress().IsNil());
// Should be no pending server connections.
- EXPECT_FALSE(sink.Check(server.get(), testing::SSE_READ));
+ EXPECT_FALSE(sink.Check(server.get(), SSE_READ));
EXPECT_TRUE(nullptr == server->Accept(&accept_addr));
EXPECT_TRUE(accept_addr.IsNil());
}
@@ -400,7 +407,7 @@
void SocketTest::ConnectWhileNotClosedInternal(const IPAddress& loopback) {
// Create server and listen.
- testing::StreamSink sink;
+ StreamSink sink;
std::unique_ptr<AsyncSocket> server(
ss_->CreateAsyncSocket(loopback.family(), SOCK_STREAM));
sink.Monitor(server.get());
@@ -417,7 +424,7 @@
// Accept the original connection.
SocketAddress accept_addr;
- EXPECT_TRUE_WAIT((sink.Check(server.get(), testing::SSE_READ)), kTimeout);
+ EXPECT_TRUE_WAIT((sink.Check(server.get(), SSE_READ)), kTimeout);
std::unique_ptr<AsyncSocket> accepted(server->Accept(&accept_addr));
ASSERT_TRUE(accepted);
EXPECT_FALSE(accept_addr.IsNil());
@@ -442,7 +449,7 @@
}
void SocketTest::ServerCloseDuringConnectInternal(const IPAddress& loopback) {
- testing::StreamSink sink;
+ StreamSink sink;
// Create client.
std::unique_ptr<AsyncSocket> client(
@@ -460,17 +467,17 @@
EXPECT_EQ(0, client->Connect(server->GetLocalAddress()));
// Close down the server while the socket is in the accept queue.
- EXPECT_TRUE_WAIT(sink.Check(server.get(), testing::SSE_READ), kTimeout);
+ EXPECT_TRUE_WAIT(sink.Check(server.get(), SSE_READ), kTimeout);
server->Close();
// This should fail the connection for the client. Clean up.
EXPECT_EQ_WAIT(AsyncSocket::CS_CLOSED, client->GetState(), kTimeout);
- EXPECT_TRUE(sink.Check(client.get(), testing::SSE_ERROR));
+ EXPECT_TRUE(sink.Check(client.get(), SSE_ERROR));
client->Close();
}
void SocketTest::ClientCloseDuringConnectInternal(const IPAddress& loopback) {
- testing::StreamSink sink;
+ StreamSink sink;
SocketAddress accept_addr;
// Create client.
@@ -489,7 +496,7 @@
EXPECT_EQ(0, client->Connect(server->GetLocalAddress()));
// Close down the client while the socket is in the accept queue.
- EXPECT_TRUE_WAIT(sink.Check(server.get(), testing::SSE_READ), kTimeout);
+ EXPECT_TRUE_WAIT(sink.Check(server.get(), SSE_READ), kTimeout);
client->Close();
// The connection should still be able to be accepted.
@@ -500,15 +507,15 @@
// The accepted socket should then close (possibly with err, timing-related)
EXPECT_EQ_WAIT(AsyncSocket::CS_CLOSED, accepted->GetState(), kTimeout);
- EXPECT_TRUE(sink.Check(accepted.get(), testing::SSE_CLOSE) ||
- sink.Check(accepted.get(), testing::SSE_ERROR));
+ EXPECT_TRUE(sink.Check(accepted.get(), SSE_CLOSE) ||
+ sink.Check(accepted.get(), SSE_ERROR));
// The client should not get a close event.
- EXPECT_FALSE(sink.Check(client.get(), testing::SSE_CLOSE));
+ EXPECT_FALSE(sink.Check(client.get(), SSE_CLOSE));
}
void SocketTest::ServerCloseInternal(const IPAddress& loopback) {
- testing::StreamSink sink;
+ StreamSink sink;
SocketAddress accept_addr;
// Create client.
@@ -527,14 +534,14 @@
EXPECT_EQ(0, client->Connect(server->GetLocalAddress()));
// Accept connection.
- EXPECT_TRUE_WAIT((sink.Check(server.get(), testing::SSE_READ)), kTimeout);
+ EXPECT_TRUE_WAIT((sink.Check(server.get(), SSE_READ)), kTimeout);
std::unique_ptr<AsyncSocket> accepted(server->Accept(&accept_addr));
ASSERT_TRUE(accepted);
sink.Monitor(accepted.get());
// Both sides are now connected.
EXPECT_EQ_WAIT(AsyncSocket::CS_CONNECTED, client->GetState(), kTimeout);
- EXPECT_TRUE(sink.Check(client.get(), testing::SSE_OPEN));
+ EXPECT_TRUE(sink.Check(client.get(), SSE_OPEN));
EXPECT_EQ(client->GetRemoteAddress(), accepted->GetLocalAddress());
EXPECT_EQ(accepted->GetRemoteAddress(), client->GetLocalAddress());
@@ -544,8 +551,8 @@
EXPECT_EQ(AsyncSocket::CS_CLOSED, accepted->GetState());
// Expect that the client is notified, and has not yet closed.
- EXPECT_TRUE_WAIT(sink.Check(client.get(), testing::SSE_READ), kTimeout);
- EXPECT_FALSE(sink.Check(client.get(), testing::SSE_CLOSE));
+ EXPECT_TRUE_WAIT(sink.Check(client.get(), SSE_READ), kTimeout);
+ EXPECT_FALSE(sink.Check(client.get(), SSE_CLOSE));
EXPECT_EQ(AsyncSocket::CS_CONNECTED, client->GetState());
// Ensure the data can be read.
@@ -555,20 +562,20 @@
// Now we should close, but the remote address will remain.
EXPECT_EQ_WAIT(AsyncSocket::CS_CLOSED, client->GetState(), kTimeout);
- EXPECT_TRUE(sink.Check(client.get(), testing::SSE_CLOSE));
+ EXPECT_TRUE(sink.Check(client.get(), SSE_CLOSE));
EXPECT_FALSE(client->GetRemoteAddress().IsAnyIP());
// The closer should not get a close signal.
- EXPECT_FALSE(sink.Check(accepted.get(), testing::SSE_CLOSE));
+ EXPECT_FALSE(sink.Check(accepted.get(), SSE_CLOSE));
EXPECT_TRUE(accepted->GetRemoteAddress().IsNil());
// And the closee should only get a single signal.
Thread::Current()->ProcessMessages(0);
- EXPECT_FALSE(sink.Check(client.get(), testing::SSE_CLOSE));
+ EXPECT_FALSE(sink.Check(client.get(), SSE_CLOSE));
// Close down the client and ensure all is good.
client->Close();
- EXPECT_FALSE(sink.Check(client.get(), testing::SSE_CLOSE));
+ EXPECT_FALSE(sink.Check(client.get(), SSE_CLOSE));
EXPECT_TRUE(client->GetRemoteAddress().IsNil());
}
@@ -581,7 +588,7 @@
};
void SocketTest::CloseInClosedCallbackInternal(const IPAddress& loopback) {
- testing::StreamSink sink;
+ StreamSink sink;
SocketCloser closer;
SocketAddress accept_addr;
@@ -602,14 +609,14 @@
EXPECT_EQ(0, client->Connect(server->GetLocalAddress()));
// Accept connection.
- EXPECT_TRUE_WAIT((sink.Check(server.get(), testing::SSE_READ)), kTimeout);
+ EXPECT_TRUE_WAIT((sink.Check(server.get(), SSE_READ)), kTimeout);
std::unique_ptr<AsyncSocket> accepted(server->Accept(&accept_addr));
ASSERT_TRUE(accepted);
sink.Monitor(accepted.get());
// Both sides are now connected.
EXPECT_EQ_WAIT(AsyncSocket::CS_CONNECTED, client->GetState(), kTimeout);
- EXPECT_TRUE(sink.Check(client.get(), testing::SSE_OPEN));
+ EXPECT_TRUE(sink.Check(client.get(), SSE_OPEN));
EXPECT_EQ(client->GetRemoteAddress(), accepted->GetLocalAddress());
EXPECT_EQ(accepted->GetRemoteAddress(), client->GetLocalAddress());
@@ -618,12 +625,12 @@
EXPECT_EQ(AsyncSocket::CS_CLOSED, accepted->GetState());
// Expect that the client is notified, and has not yet closed.
- EXPECT_FALSE(sink.Check(client.get(), testing::SSE_CLOSE));
+ EXPECT_FALSE(sink.Check(client.get(), SSE_CLOSE));
EXPECT_EQ(AsyncSocket::CS_CONNECTED, client->GetState());
// Now we should be closed and invalidated
EXPECT_EQ_WAIT(AsyncSocket::CS_CLOSED, client->GetState(), kTimeout);
- EXPECT_TRUE(sink.Check(client.get(), testing::SSE_CLOSE));
+ EXPECT_TRUE(sink.Check(client.get(), SSE_CLOSE));
EXPECT_TRUE(Socket::CS_CLOSED == client->GetState());
}
@@ -636,7 +643,7 @@
};
void SocketTest::SocketServerWaitInternal(const IPAddress& loopback) {
- testing::StreamSink sink;
+ StreamSink sink;
SocketAddress accept_addr;
// Create & connect server and client sockets.
@@ -650,7 +657,7 @@
EXPECT_EQ(0, server->Listen(5));
EXPECT_EQ(0, client->Connect(server->GetLocalAddress()));
- EXPECT_TRUE_WAIT((sink.Check(server.get(), testing::SSE_READ)), kTimeout);
+ EXPECT_TRUE_WAIT((sink.Check(server.get(), SSE_READ)), kTimeout);
std::unique_ptr<AsyncSocket> accepted(server->Accept(&accept_addr));
ASSERT_TRUE(accepted);
@@ -660,17 +667,17 @@
EXPECT_EQ(client->GetLocalAddress(), accepted->GetRemoteAddress());
EXPECT_EQ_WAIT(AsyncSocket::CS_CONNECTED, client->GetState(), kTimeout);
- EXPECT_TRUE(sink.Check(client.get(), testing::SSE_OPEN));
- EXPECT_FALSE(sink.Check(client.get(), testing::SSE_CLOSE));
+ EXPECT_TRUE(sink.Check(client.get(), SSE_OPEN));
+ EXPECT_FALSE(sink.Check(client.get(), SSE_CLOSE));
EXPECT_EQ(client->GetRemoteAddress(), server->GetLocalAddress());
EXPECT_EQ(client->GetRemoteAddress(), accepted->GetLocalAddress());
// Do an i/o operation, triggering an eventual callback.
- EXPECT_FALSE(sink.Check(accepted.get(), testing::SSE_READ));
+ EXPECT_FALSE(sink.Check(accepted.get(), SSE_READ));
char buf[1024] = {0};
EXPECT_EQ(1024, client->Send(buf, 1024));
- EXPECT_FALSE(sink.Check(accepted.get(), testing::SSE_READ));
+ EXPECT_FALSE(sink.Check(accepted.get(), SSE_READ));
// Shouldn't signal when blocked in a thread Send, where process_io is false.
std::unique_ptr<Thread> thread(new Thread());
@@ -678,16 +685,16 @@
Sleeper sleeper;
TypedMessageData<AsyncSocket*> data(client.get());
thread->Send(RTC_FROM_HERE, &sleeper, 0, &data);
- EXPECT_FALSE(sink.Check(accepted.get(), testing::SSE_READ));
+ EXPECT_FALSE(sink.Check(accepted.get(), SSE_READ));
// But should signal when process_io is true.
- EXPECT_TRUE_WAIT((sink.Check(accepted.get(), testing::SSE_READ)), kTimeout);
+ EXPECT_TRUE_WAIT((sink.Check(accepted.get(), SSE_READ)), kTimeout);
EXPECT_LT(0, accepted->Recv(buf, 1024, nullptr));
}
void SocketTest::TcpInternal(const IPAddress& loopback, size_t data_size,
ptrdiff_t max_send_size) {
- testing::StreamSink sink;
+ StreamSink sink;
SocketAddress accept_addr;
// Create receiving client.
@@ -706,14 +713,14 @@
EXPECT_EQ(0, receiver->Connect(server->GetLocalAddress()));
// Accept connection which will be used for sending.
- EXPECT_TRUE_WAIT((sink.Check(server.get(), testing::SSE_READ)), kTimeout);
+ EXPECT_TRUE_WAIT((sink.Check(server.get(), SSE_READ)), kTimeout);
std::unique_ptr<AsyncSocket> sender(server->Accept(&accept_addr));
ASSERT_TRUE(sender);
sink.Monitor(sender.get());
// Both sides are now connected.
EXPECT_EQ_WAIT(AsyncSocket::CS_CONNECTED, receiver->GetState(), kTimeout);
- EXPECT_TRUE(sink.Check(receiver.get(), testing::SSE_OPEN));
+ EXPECT_TRUE(sink.Check(receiver.get(), SSE_OPEN));
EXPECT_EQ(receiver->GetRemoteAddress(), sender->GetLocalAddress());
EXPECT_EQ(sender->GetRemoteAddress(), receiver->GetLocalAddress());
@@ -765,8 +772,7 @@
while (recv_buffer.size() < sent_size) {
if (!readable) {
// Wait until data is available.
- EXPECT_TRUE_WAIT(sink.Check(receiver.get(), testing::SSE_READ),
- kTimeout);
+ EXPECT_TRUE_WAIT(sink.Check(receiver.get(), SSE_READ), kTimeout);
readable = true;
recv_called = false;
}
@@ -795,8 +801,7 @@
// Once all that we've sent has been received, expect to be able to send
// again.
if (!writable) {
- ASSERT_TRUE_WAIT(sink.Check(sender.get(), testing::SSE_WRITE),
- kTimeout);
+ ASSERT_TRUE_WAIT(sink.Check(sender.get(), SSE_WRITE), kTimeout);
writable = true;
send_called = false;
}
@@ -810,12 +815,12 @@
// Close down.
sender->Close();
EXPECT_EQ_WAIT(AsyncSocket::CS_CLOSED, receiver->GetState(), kTimeout);
- EXPECT_TRUE(sink.Check(receiver.get(), testing::SSE_CLOSE));
+ EXPECT_TRUE(sink.Check(receiver.get(), SSE_CLOSE));
receiver->Close();
}
void SocketTest::SingleFlowControlCallbackInternal(const IPAddress& loopback) {
- testing::StreamSink sink;
+ StreamSink sink;
SocketAddress accept_addr;
// Create client.
@@ -834,19 +839,19 @@
EXPECT_EQ(0, client->Connect(server->GetLocalAddress()));
// Accept connection.
- EXPECT_TRUE_WAIT((sink.Check(server.get(), testing::SSE_READ)), kTimeout);
+ EXPECT_TRUE_WAIT((sink.Check(server.get(), SSE_READ)), kTimeout);
std::unique_ptr<AsyncSocket> accepted(server->Accept(&accept_addr));
ASSERT_TRUE(accepted);
sink.Monitor(accepted.get());
// Both sides are now connected.
EXPECT_EQ_WAIT(AsyncSocket::CS_CONNECTED, client->GetState(), kTimeout);
- EXPECT_TRUE(sink.Check(client.get(), testing::SSE_OPEN));
+ EXPECT_TRUE(sink.Check(client.get(), SSE_OPEN));
EXPECT_EQ(client->GetRemoteAddress(), accepted->GetLocalAddress());
EXPECT_EQ(accepted->GetRemoteAddress(), client->GetLocalAddress());
// Expect a writable callback from the connect.
- EXPECT_TRUE_WAIT(sink.Check(accepted.get(), testing::SSE_WRITE), kTimeout);
+ EXPECT_TRUE_WAIT(sink.Check(accepted.get(), SSE_WRITE), kTimeout);
// Fill the socket buffer.
char buf[1024 * 16] = {0};
@@ -855,7 +860,7 @@
EXPECT_TRUE(accepted->IsBlocking());
// Wait until data is available.
- EXPECT_TRUE_WAIT(sink.Check(client.get(), testing::SSE_READ), kTimeout);
+ EXPECT_TRUE_WAIT(sink.Check(client.get(), SSE_READ), kTimeout);
// Pull data.
for (int i = 0; i < sends; ++i) {
@@ -863,7 +868,7 @@
}
// Expect at least one additional writable callback.
- EXPECT_TRUE_WAIT(sink.Check(accepted.get(), testing::SSE_WRITE), kTimeout);
+ EXPECT_TRUE_WAIT(sink.Check(accepted.get(), SSE_WRITE), kTimeout);
// Adding data in response to the writeable callback shouldn't cause infinite
// callbacks.
@@ -871,7 +876,7 @@
for (int i = 0; i < 100; ++i) {
accepted->Send(&buf, arraysize(buf));
rtc::Thread::Current()->ProcessMessages(1);
- if (sink.Check(accepted.get(), testing::SSE_WRITE)) {
+ if (sink.Check(accepted.get(), SSE_WRITE)) {
extras++;
}
}
diff --git a/webrtc/base/testutils.h b/webrtc/base/testutils.h
index 305d3d0..cda7a84 100644
--- a/webrtc/base/testutils.h
+++ b/webrtc/base/testutils.h
@@ -37,6 +37,7 @@
#include "webrtc/base/stringutils.h"
#include "webrtc/base/thread.h"
+namespace webrtc {
namespace testing {
using namespace rtc;
@@ -420,21 +421,21 @@
// Unittest predicates which are similar to STREQ, but for raw memory
///////////////////////////////////////////////////////////////////////////////
-inline AssertionResult CmpHelperMemEq(const char* expected_expression,
- const char* expected_length_expression,
- const char* actual_expression,
- const char* actual_length_expression,
- const void* expected,
- size_t expected_length,
- const void* actual,
- size_t actual_length)
-{
+inline ::testing::AssertionResult CmpHelperMemEq(
+ const char* expected_expression,
+ const char* expected_length_expression,
+ const char* actual_expression,
+ const char* actual_length_expression,
+ const void* expected,
+ size_t expected_length,
+ const void* actual,
+ size_t actual_length) {
if ((expected_length == actual_length)
&& (0 == memcmp(expected, actual, expected_length))) {
- return AssertionSuccess();
+ return ::testing::AssertionSuccess();
}
- Message msg;
+ ::testing::Message msg;
msg << "Value of: " << actual_expression
<< " [" << actual_length_expression << "]";
if (true) { //!actual_value.Equals(actual_expression)) {
@@ -558,6 +559,8 @@
#endif
return true;
}
+
} // namespace testing
+} // namespace webrtc
#endif // WEBRTC_BASE_TESTUTILS_H__
diff --git a/webrtc/base/virtualsocket_unittest.cc b/webrtc/base/virtualsocket_unittest.cc
index b884748..e2f1d05 100644
--- a/webrtc/base/virtualsocket_unittest.cc
+++ b/webrtc/base/virtualsocket_unittest.cc
@@ -27,6 +27,13 @@
using namespace rtc;
+using webrtc::testing::SSE_CLOSE;
+using webrtc::testing::SSE_ERROR;
+using webrtc::testing::SSE_OPEN;
+using webrtc::testing::SSE_READ;
+using webrtc::testing::SSE_WRITE;
+using webrtc::testing::StreamSink;
+
// Sends at a constant rate but with random packet sizes.
struct Sender : public MessageHandler {
Sender(Thread* th, AsyncSocket* s, uint32_t rt)
@@ -239,7 +246,7 @@
// initial_addr should be made from either INADDR_ANY or in6addr_any.
void ConnectTest(const SocketAddress& initial_addr) {
- testing::StreamSink sink;
+ StreamSink sink;
SocketAddress accept_addr;
const SocketAddress kEmptyAddr =
EmptySocketAddressWithFamily(initial_addr.family());
@@ -262,7 +269,7 @@
EXPECT_EQ(server->GetState(), AsyncSocket::CS_CONNECTING);
// No pending server connections
- EXPECT_FALSE(sink.Check(server, testing::SSE_READ));
+ EXPECT_FALSE(sink.Check(server, SSE_READ));
EXPECT_TRUE(nullptr == server->Accept(&accept_addr));
EXPECT_EQ(AF_UNSPEC, accept_addr.family());
@@ -274,18 +281,18 @@
// Client is connecting
EXPECT_EQ(client->GetState(), AsyncSocket::CS_CONNECTING);
- EXPECT_FALSE(sink.Check(client, testing::SSE_OPEN));
- EXPECT_FALSE(sink.Check(client, testing::SSE_CLOSE));
+ EXPECT_FALSE(sink.Check(client, SSE_OPEN));
+ EXPECT_FALSE(sink.Check(client, SSE_CLOSE));
ss_->ProcessMessagesUntilIdle();
// Client still connecting
EXPECT_EQ(client->GetState(), AsyncSocket::CS_CONNECTING);
- EXPECT_FALSE(sink.Check(client, testing::SSE_OPEN));
- EXPECT_FALSE(sink.Check(client, testing::SSE_CLOSE));
+ EXPECT_FALSE(sink.Check(client, SSE_OPEN));
+ EXPECT_FALSE(sink.Check(client, SSE_CLOSE));
// Server has pending connection
- EXPECT_TRUE(sink.Check(server, testing::SSE_READ));
+ EXPECT_TRUE(sink.Check(server, SSE_READ));
Socket* accepted = server->Accept(&accept_addr);
EXPECT_TRUE(nullptr != accepted);
EXPECT_NE(accept_addr, kEmptyAddr);
@@ -299,14 +306,14 @@
// Client has connected
EXPECT_EQ(client->GetState(), AsyncSocket::CS_CONNECTED);
- EXPECT_TRUE(sink.Check(client, testing::SSE_OPEN));
- EXPECT_FALSE(sink.Check(client, testing::SSE_CLOSE));
+ EXPECT_TRUE(sink.Check(client, SSE_OPEN));
+ EXPECT_FALSE(sink.Check(client, SSE_CLOSE));
EXPECT_EQ(client->GetRemoteAddress(), server->GetLocalAddress());
EXPECT_EQ(client->GetRemoteAddress(), accepted->GetLocalAddress());
}
void ConnectToNonListenerTest(const SocketAddress& initial_addr) {
- testing::StreamSink sink;
+ StreamSink sink;
SocketAddress accept_addr;
const SocketAddress nil_addr;
const SocketAddress empty_addr =
@@ -329,19 +336,19 @@
ss_->ProcessMessagesUntilIdle();
// No pending server connections
- EXPECT_FALSE(sink.Check(server, testing::SSE_READ));
+ EXPECT_FALSE(sink.Check(server, SSE_READ));
EXPECT_TRUE(nullptr == server->Accept(&accept_addr));
EXPECT_EQ(accept_addr, nil_addr);
// Connection failed
EXPECT_EQ(client->GetState(), AsyncSocket::CS_CLOSED);
- EXPECT_FALSE(sink.Check(client, testing::SSE_OPEN));
- EXPECT_TRUE(sink.Check(client, testing::SSE_ERROR));
+ EXPECT_FALSE(sink.Check(client, SSE_OPEN));
+ EXPECT_TRUE(sink.Check(client, SSE_ERROR));
EXPECT_EQ(client->GetRemoteAddress(), nil_addr);
}
void CloseDuringConnectTest(const SocketAddress& initial_addr) {
- testing::StreamSink sink;
+ StreamSink sink;
SocketAddress accept_addr;
const SocketAddress empty_addr =
EmptySocketAddressWithFamily(initial_addr.family());
@@ -362,14 +369,14 @@
EXPECT_EQ(0, client->Connect(server->GetLocalAddress()));
// Server close before socket enters accept queue
- EXPECT_FALSE(sink.Check(server.get(), testing::SSE_READ));
+ EXPECT_FALSE(sink.Check(server.get(), SSE_READ));
server->Close();
ss_->ProcessMessagesUntilIdle();
// Result: connection failed
EXPECT_EQ(client->GetState(), AsyncSocket::CS_CLOSED);
- EXPECT_TRUE(sink.Check(client.get(), testing::SSE_ERROR));
+ EXPECT_TRUE(sink.Check(client.get(), SSE_ERROR));
server.reset(ss_->CreateAsyncSocket(initial_addr.family(), SOCK_STREAM));
sink.Monitor(server.get());
@@ -384,14 +391,14 @@
ss_->ProcessMessagesUntilIdle();
// Server close while socket is in accept queue
- EXPECT_TRUE(sink.Check(server.get(), testing::SSE_READ));
+ EXPECT_TRUE(sink.Check(server.get(), SSE_READ));
server->Close();
ss_->ProcessMessagesUntilIdle();
// Result: connection failed
EXPECT_EQ(client->GetState(), AsyncSocket::CS_CLOSED);
- EXPECT_TRUE(sink.Check(client.get(), testing::SSE_ERROR));
+ EXPECT_TRUE(sink.Check(client.get(), SSE_ERROR));
// New server
server.reset(ss_->CreateAsyncSocket(initial_addr.family(), SOCK_STREAM));
@@ -407,7 +414,7 @@
ss_->ProcessMessagesUntilIdle();
// Server accepts connection
- EXPECT_TRUE(sink.Check(server.get(), testing::SSE_READ));
+ EXPECT_TRUE(sink.Check(server.get(), SSE_READ));
std::unique_ptr<AsyncSocket> accepted(server->Accept(&accept_addr));
ASSERT_TRUE(nullptr != accepted.get());
sink.Monitor(accepted.get());
@@ -423,12 +430,12 @@
// Result: accepted socket closes
EXPECT_EQ(accepted->GetState(), AsyncSocket::CS_CLOSED);
- EXPECT_TRUE(sink.Check(accepted.get(), testing::SSE_CLOSE));
- EXPECT_FALSE(sink.Check(client.get(), testing::SSE_CLOSE));
+ EXPECT_TRUE(sink.Check(accepted.get(), SSE_CLOSE));
+ EXPECT_FALSE(sink.Check(client.get(), SSE_CLOSE));
}
void CloseTest(const SocketAddress& initial_addr) {
- testing::StreamSink sink;
+ StreamSink sink;
const SocketAddress kEmptyAddr;
// Create clients
@@ -448,11 +455,11 @@
ss_->ProcessMessagesUntilIdle();
- EXPECT_TRUE(sink.Check(a, testing::SSE_OPEN));
+ EXPECT_TRUE(sink.Check(a, SSE_OPEN));
EXPECT_EQ(a->GetState(), AsyncSocket::CS_CONNECTED);
EXPECT_EQ(a->GetRemoteAddress(), b->GetLocalAddress());
- EXPECT_TRUE(sink.Check(b.get(), testing::SSE_OPEN));
+ EXPECT_TRUE(sink.Check(b.get(), SSE_OPEN));
EXPECT_EQ(b->GetState(), AsyncSocket::CS_CONNECTED);
EXPECT_EQ(b->GetRemoteAddress(), a->GetLocalAddress());
@@ -463,21 +470,21 @@
ss_->ProcessMessagesUntilIdle();
char buffer[10];
- EXPECT_FALSE(sink.Check(b.get(), testing::SSE_READ));
+ EXPECT_FALSE(sink.Check(b.get(), SSE_READ));
EXPECT_EQ(-1, b->Recv(buffer, 10, nullptr));
- EXPECT_TRUE(sink.Check(a, testing::SSE_CLOSE));
+ EXPECT_TRUE(sink.Check(a, SSE_CLOSE));
EXPECT_EQ(a->GetState(), AsyncSocket::CS_CLOSED);
EXPECT_EQ(a->GetRemoteAddress(), kEmptyAddr);
// No signal for Closer
- EXPECT_FALSE(sink.Check(b.get(), testing::SSE_CLOSE));
+ EXPECT_FALSE(sink.Check(b.get(), SSE_CLOSE));
EXPECT_EQ(b->GetState(), AsyncSocket::CS_CLOSED);
EXPECT_EQ(b->GetRemoteAddress(), kEmptyAddr);
}
void TcpSendTest(const SocketAddress& initial_addr) {
- testing::StreamSink sink;
+ StreamSink sink;
const SocketAddress kEmptyAddr;
// Connect two sockets
@@ -513,8 +520,8 @@
send_pos += result;
ss_->ProcessMessagesUntilIdle();
- EXPECT_FALSE(sink.Check(a, testing::SSE_WRITE));
- EXPECT_TRUE(sink.Check(b, testing::SSE_READ));
+ EXPECT_FALSE(sink.Check(a, SSE_WRITE));
+ EXPECT_TRUE(sink.Check(b, SSE_READ));
// Receive buffer is already filled, fill send buffer again
result = a->Send(send_buffer + send_pos, kDataSize - send_pos);
@@ -522,8 +529,8 @@
send_pos += result;
ss_->ProcessMessagesUntilIdle();
- EXPECT_FALSE(sink.Check(a, testing::SSE_WRITE));
- EXPECT_FALSE(sink.Check(b, testing::SSE_READ));
+ EXPECT_FALSE(sink.Check(a, SSE_WRITE));
+ EXPECT_FALSE(sink.Check(b, SSE_READ));
// No more room in send or receive buffer
result = a->Send(send_buffer + send_pos, kDataSize - send_pos);
@@ -536,8 +543,8 @@
recv_pos += result;
ss_->ProcessMessagesUntilIdle();
- EXPECT_TRUE(sink.Check(a, testing::SSE_WRITE));
- EXPECT_TRUE(sink.Check(b, testing::SSE_READ));
+ EXPECT_TRUE(sink.Check(a, SSE_WRITE));
+ EXPECT_TRUE(sink.Check(b, SSE_READ));
// Room for more on the sending side
result = a->Send(send_buffer + send_pos, kDataSize - send_pos);
@@ -556,7 +563,7 @@
}
ss_->ProcessMessagesUntilIdle();
- EXPECT_TRUE(sink.Check(b, testing::SSE_READ));
+ EXPECT_TRUE(sink.Check(b, SSE_READ));
// Continue to empty the recv buffer
while (true) {
@@ -575,7 +582,7 @@
send_pos += result;
ss_->ProcessMessagesUntilIdle();
- EXPECT_TRUE(sink.Check(b, testing::SSE_READ));
+ EXPECT_TRUE(sink.Check(b, SSE_READ));
// Receive the last of the data
while (true) {
@@ -589,7 +596,7 @@
}
ss_->ProcessMessagesUntilIdle();
- EXPECT_FALSE(sink.Check(b, testing::SSE_READ));
+ EXPECT_FALSE(sink.Check(b, SSE_READ));
// The received data matches the sent data
EXPECT_EQ(kDataSize, send_pos);
@@ -741,7 +748,7 @@
void CrossFamilyConnectionTest(const SocketAddress& client_addr,
const SocketAddress& server_addr,
bool shouldSucceed) {
- testing::StreamSink sink;
+ StreamSink sink;
SocketAddress accept_address;
const SocketAddress kEmptyAddr;
@@ -764,23 +771,23 @@
if (shouldSucceed) {
EXPECT_EQ(0, client->Connect(server->GetLocalAddress()));
ss_->ProcessMessagesUntilIdle();
- EXPECT_TRUE(sink.Check(server, testing::SSE_READ));
+ EXPECT_TRUE(sink.Check(server, SSE_READ));
Socket* accepted = server->Accept(&accept_address);
EXPECT_TRUE(nullptr != accepted);
EXPECT_NE(kEmptyAddr, accept_address);
ss_->ProcessMessagesUntilIdle();
- EXPECT_TRUE(sink.Check(client, testing::SSE_OPEN));
+ 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();
- EXPECT_FALSE(sink.Check(server, testing::SSE_READ));
+ EXPECT_FALSE(sink.Check(server, SSE_READ));
EXPECT_TRUE(nullptr == server->Accept(&accept_address));
EXPECT_EQ(accept_address, kEmptyAddr);
EXPECT_EQ(client->GetState(), AsyncSocket::CS_CLOSED);
- EXPECT_FALSE(sink.Check(client, testing::SSE_OPEN));
+ EXPECT_FALSE(sink.Check(client, SSE_OPEN));
EXPECT_EQ(client->GetRemoteAddress(), kEmptyAddr);
}
}
@@ -1040,7 +1047,7 @@
ss_->set_send_buffer_capacity(kBufferSize);
ss_->set_recv_buffer_capacity(kBufferSize);
- testing::StreamSink sink;
+ StreamSink sink;
AsyncSocket* socket1 =
ss_->CreateAsyncSocket(kIPv4AnyAddress.family(), SOCK_STREAM);
AsyncSocket* socket2 =
@@ -1061,22 +1068,22 @@
ss_->SetSendingBlocked(true);
EXPECT_EQ(static_cast<int>(kBufferSize), socket1->Send(data, kBufferSize));
ss_->ProcessMessagesUntilIdle();
- EXPECT_FALSE(sink.Check(socket1, testing::SSE_WRITE));
- EXPECT_FALSE(sink.Check(socket2, testing::SSE_READ));
+ EXPECT_FALSE(sink.Check(socket1, SSE_WRITE));
+ EXPECT_FALSE(sink.Check(socket2, SSE_READ));
EXPECT_FALSE(socket1->IsBlocking());
// Since the send buffer is full, next Send will result in EWOULDBLOCK.
EXPECT_EQ(-1, socket1->Send(data, kBufferSize));
- EXPECT_FALSE(sink.Check(socket1, testing::SSE_WRITE));
- EXPECT_FALSE(sink.Check(socket2, testing::SSE_READ));
+ EXPECT_FALSE(sink.Check(socket1, SSE_WRITE));
+ EXPECT_FALSE(sink.Check(socket2, SSE_READ));
EXPECT_TRUE(socket1->IsBlocking());
// When sending is unblocked, the buffered data should be sent and
// SignalWriteEvent should fire.
ss_->SetSendingBlocked(false);
ss_->ProcessMessagesUntilIdle();
- EXPECT_TRUE(sink.Check(socket1, testing::SSE_WRITE));
- EXPECT_TRUE(sink.Check(socket2, testing::SSE_READ));
+ EXPECT_TRUE(sink.Check(socket1, SSE_WRITE));
+ EXPECT_TRUE(sink.Check(socket2, SSE_READ));
}
TEST_F(VirtualSocketServerTest, CreatesStandardDistribution) {
