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}
This commit is contained in:
kwiberg
Commit bot
parent
6daffe206d
commit
d0d81485f2
@ -106,13 +106,13 @@ public:
|
||||
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 @@ TEST_F(HttpBaseTest, SignalsDocumentStreamCloseOnUnexpectedClose) {
|
||||
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;
|
||||
|
||||
@ -12,7 +12,7 @@
|
||||
#include "webrtc/base/httpserver.h"
|
||||
#include "webrtc/base/testutils.h"
|
||||
|
||||
using namespace testing;
|
||||
using namespace webrtc::testing;
|
||||
|
||||
namespace rtc {
|
||||
|
||||
|
||||
@ -185,7 +185,7 @@ TEST_F(PhysicalSocketTest, TestConnectFailIPv4) {
|
||||
}
|
||||
|
||||
void PhysicalSocketTest::ConnectInternalAcceptError(const IPAddress& loopback) {
|
||||
testing::StreamSink sink;
|
||||
webrtc::testing::StreamSink sink;
|
||||
SocketAddress accept_addr;
|
||||
|
||||
// Create two clients.
|
||||
@ -210,7 +210,7 @@ void PhysicalSocketTest::ConnectInternalAcceptError(const IPAddress& loopback) {
|
||||
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 @@ void PhysicalSocketTest::ConnectInternalAcceptError(const IPAddress& loopback) {
|
||||
|
||||
// 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 @@ void PhysicalSocketTest::ConnectInternalAcceptError(const IPAddress& loopback) {
|
||||
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 @@ void PhysicalSocketTest::ConnectInternalAcceptError(const IPAddress& loopback) {
|
||||
|
||||
// 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);
|
||||
|
||||
@ -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 @@ bool IsUnspecOrEmptyIP(const IPAddress& address) {
|
||||
}
|
||||
|
||||
void SocketTest::ConnectInternal(const IPAddress& loopback) {
|
||||
testing::StreamSink sink;
|
||||
StreamSink sink;
|
||||
SocketAddress accept_addr;
|
||||
|
||||
// Create client.
|
||||
@ -223,7 +230,7 @@ void SocketTest::ConnectInternal(const IPAddress& loopback) {
|
||||
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 @@ void SocketTest::ConnectInternal(const IPAddress& loopback) {
|
||||
|
||||
// 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 @@ void SocketTest::ConnectInternal(const IPAddress& loopback) {
|
||||
|
||||
// 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 @@ void SocketTest::ConnectWithDnsLookupInternal(const IPAddress& loopback,
|
||||
|
||||
// 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 @@ void SocketTest::ConnectWithDnsLookupInternal(const IPAddress& loopback,
|
||||
|
||||
// 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 @@ void SocketTest::ConnectFailInternal(const IPAddress& loopback) {
|
||||
|
||||
// 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 @@ void SocketTest::ConnectWithDnsLookupFailInternal(const IPAddress& loopback) {
|
||||
}
|
||||
|
||||
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::ConnectWithClosedSocketInternal(const IPAddress& loopback) {
|
||||
|
||||
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 @@ void SocketTest::ConnectWhileNotClosedInternal(const IPAddress& loopback) {
|
||||
|
||||
// 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::ConnectWhileNotClosedInternal(const IPAddress& loopback) {
|
||||
}
|
||||
|
||||
void SocketTest::ServerCloseDuringConnectInternal(const IPAddress& loopback) {
|
||||
testing::StreamSink sink;
|
||||
StreamSink sink;
|
||||
|
||||
// Create client.
|
||||
std::unique_ptr<AsyncSocket> client(
|
||||
@ -460,17 +467,17 @@ void SocketTest::ServerCloseDuringConnectInternal(const IPAddress& loopback) {
|
||||
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 @@ void SocketTest::ClientCloseDuringConnectInternal(const IPAddress& loopback) {
|
||||
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 @@ void SocketTest::ClientCloseDuringConnectInternal(const IPAddress& loopback) {
|
||||
|
||||
// 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 @@ void SocketTest::ServerCloseInternal(const IPAddress& loopback) {
|
||||
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 @@ void SocketTest::ServerCloseInternal(const IPAddress& loopback) {
|
||||
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 @@ void SocketTest::ServerCloseInternal(const IPAddress& loopback) {
|
||||
|
||||
// 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 @@ class SocketCloser : public sigslot::has_slots<> {
|
||||
};
|
||||
|
||||
void SocketTest::CloseInClosedCallbackInternal(const IPAddress& loopback) {
|
||||
testing::StreamSink sink;
|
||||
StreamSink sink;
|
||||
SocketCloser closer;
|
||||
SocketAddress accept_addr;
|
||||
|
||||
@ -602,14 +609,14 @@ void SocketTest::CloseInClosedCallbackInternal(const IPAddress& loopback) {
|
||||
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 @@ void SocketTest::CloseInClosedCallbackInternal(const IPAddress& loopback) {
|
||||
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 @@ class Sleeper : public MessageHandler {
|
||||
};
|
||||
|
||||
void SocketTest::SocketServerWaitInternal(const IPAddress& loopback) {
|
||||
testing::StreamSink sink;
|
||||
StreamSink sink;
|
||||
SocketAddress accept_addr;
|
||||
|
||||
// Create & connect server and client sockets.
|
||||
@ -650,7 +657,7 @@ void SocketTest::SocketServerWaitInternal(const IPAddress& loopback) {
|
||||
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 @@ void SocketTest::SocketServerWaitInternal(const IPAddress& loopback) {
|
||||
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 @@ void SocketTest::SocketServerWaitInternal(const IPAddress& loopback) {
|
||||
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 @@ void SocketTest::TcpInternal(const IPAddress& loopback, size_t data_size,
|
||||
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 @@ void SocketTest::TcpInternal(const IPAddress& loopback, size_t data_size,
|
||||
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 @@ void SocketTest::TcpInternal(const IPAddress& loopback, size_t data_size,
|
||||
// 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 @@ void SocketTest::TcpInternal(const IPAddress& loopback, size_t data_size,
|
||||
// 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 @@ void SocketTest::SingleFlowControlCallbackInternal(const IPAddress& loopback) {
|
||||
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 @@ void SocketTest::SingleFlowControlCallbackInternal(const IPAddress& loopback) {
|
||||
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 @@ void SocketTest::SingleFlowControlCallbackInternal(const IPAddress& loopback) {
|
||||
}
|
||||
|
||||
// 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 @@ void SocketTest::SingleFlowControlCallbackInternal(const IPAddress& loopback) {
|
||||
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++;
|
||||
}
|
||||
}
|
||||
|
||||
@ -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 @@ class SocketTestServer : public sigslot::has_slots<> {
|
||||
// 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 @@ inline bool IsScreencastingAvailable() {
|
||||
#endif
|
||||
return true;
|
||||
}
|
||||
|
||||
} // namespace testing
|
||||
} // namespace webrtc
|
||||
|
||||
#endif // WEBRTC_BASE_TESTUTILS_H__
|
||||
|
||||
@ -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 @@ class VirtualSocketServerTest : public testing::Test {
|
||||
|
||||
// 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 @@ class VirtualSocketServerTest : public testing::Test {
|
||||
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 @@ class VirtualSocketServerTest : public testing::Test {
|
||||
|
||||
// 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 @@ class VirtualSocketServerTest : public testing::Test {
|
||||
|
||||
// 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 @@ class VirtualSocketServerTest : public testing::Test {
|
||||
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 @@ class VirtualSocketServerTest : public testing::Test {
|
||||
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 @@ class VirtualSocketServerTest : public testing::Test {
|
||||
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 @@ class VirtualSocketServerTest : public testing::Test {
|
||||
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 @@ class VirtualSocketServerTest : public testing::Test {
|
||||
|
||||
// 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 @@ class VirtualSocketServerTest : public testing::Test {
|
||||
|
||||
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 @@ class VirtualSocketServerTest : public testing::Test {
|
||||
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 @@ class VirtualSocketServerTest : public testing::Test {
|
||||
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 @@ class VirtualSocketServerTest : public testing::Test {
|
||||
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 @@ class VirtualSocketServerTest : public testing::Test {
|
||||
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 @@ class VirtualSocketServerTest : public testing::Test {
|
||||
}
|
||||
|
||||
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 @@ class VirtualSocketServerTest : public testing::Test {
|
||||
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 @@ class VirtualSocketServerTest : public testing::Test {
|
||||
}
|
||||
|
||||
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 @@ class VirtualSocketServerTest : public testing::Test {
|
||||
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 @@ class VirtualSocketServerTest : public testing::Test {
|
||||
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 @@ TEST_F(VirtualSocketServerTest, SetSendingBlockedWithTcpSocket) {
|
||||
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 @@ TEST_F(VirtualSocketServerTest, SetSendingBlockedWithTcpSocket) {
|
||||
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) {
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user