Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(402)

Issues Search
    My Issues | Starred     Open | Closed | All

Unified Diff: net/socket/socks_client_socket_unittest.cc

Issue 266243004: Clang format slam. Base URL: svn://svn.chromium.org/chrome/trunk/src
Patch Set: Created 6 years, 7 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View side-by-side diff with in-line comments
Download patch
« net/base/mime_util_unittest.cc ('K') | « net/socket/socks_client_socket_pool_unittest.cc ('k') | net/socket/ssl_client_socket.h » ('j') | no next file with comments »
Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
Index: net/socket/socks_client_socket_unittest.cc
diff --git a/net/socket/socks_client_socket_unittest.cc b/net/socket/socks_client_socket_unittest.cc
index f361244feff01a7dfa3138a7bc4ded1f36b13e29..94fd59265bb5cb7098f80051a57668afe02a37e4 100644
--- a/net/socket/socks_client_socket_unittest.cc
+++ b/net/socket/socks_client_socket_unittest.cc
@@ -21,19 +21,21 @@
namespace net {
-const char kSOCKSOkRequest[] = { 0x04, 0x01, 0x00, 0x50, 127, 0, 0, 1, 0 };
-const char kSOCKSOkReply[] = { 0x00, 0x5A, 0x00, 0x00, 0, 0, 0, 0 };
+const char kSOCKSOkRequest[] = {0x04, 0x01, 0x00, 0x50, 127, 0, 0, 1, 0};
+const char kSOCKSOkReply[] = {0x00, 0x5A, 0x00, 0x00, 0, 0, 0, 0};
class SOCKSClientSocketTest : public PlatformTest {
public:
SOCKSClientSocketTest();
// Create a SOCKSClientSocket on top of a MockSocket.
- scoped_ptr<SOCKSClientSocket> BuildMockSocket(
- MockRead reads[], size_t reads_count,
- MockWrite writes[], size_t writes_count,
- HostResolver* host_resolver,
- const std::string& hostname, int port,
- NetLog* net_log);
+ scoped_ptr<SOCKSClientSocket> BuildMockSocket(MockRead reads[],
+ size_t reads_count,
+ MockWrite writes[],
+ size_t writes_count,
+ HostResolver* host_resolver,
+ const std::string& hostname,
+ int port,
+ NetLog* net_log);
virtual void SetUp();
protected:
@@ -48,7 +50,7 @@ class SOCKSClientSocketTest : public PlatformTest {
};
SOCKSClientSocketTest::SOCKSClientSocketTest()
- : host_resolver_(new MockHostResolver) {
+ : host_resolver_(new MockHostResolver) {
}
// Set up platform before every test case
@@ -65,10 +67,9 @@ scoped_ptr<SOCKSClientSocket> SOCKSClientSocketTest::BuildMockSocket(
const std::string& hostname,
int port,
NetLog* net_log) {
-
TestCompletionCallback callback;
- data_.reset(new StaticSocketDataProvider(reads, reads_count,
- writes, writes_count));
+ data_.reset(
+ new StaticSocketDataProvider(reads, reads_count, writes, writes_count));
tcp_sock_ = new MockTCPClientSocket(address_list_, net_log, data_.get());
int rv = tcp_sock_->Connect(callback.callback());
@@ -122,9 +123,7 @@ class HangingHostResolverWithCancel : public HostResolver {
outstanding_request_ = NULL;
}
- bool HasOutstandingRequest() {
- return outstanding_request_ != NULL;
- }
+ bool HasOutstandingRequest() { return outstanding_request_ != NULL; }
private:
RequestHandle outstanding_request_;
@@ -139,16 +138,19 @@ TEST_F(SOCKSClientSocketTest, CompleteHandshake) {
MockWrite data_writes[] = {
MockWrite(ASYNC, kSOCKSOkRequest, arraysize(kSOCKSOkRequest)),
- MockWrite(ASYNC, payload_write.data(), payload_write.size()) };
+ MockWrite(ASYNC, payload_write.data(), payload_write.size())};
MockRead data_reads[] = {
MockRead(ASYNC, kSOCKSOkReply, arraysize(kSOCKSOkReply)),
- MockRead(ASYNC, payload_read.data(), payload_read.size()) };
+ MockRead(ASYNC, payload_read.data(), payload_read.size())};
CapturingNetLog log;
- user_sock_ = BuildMockSocket(data_reads, arraysize(data_reads),
- data_writes, arraysize(data_writes),
+ user_sock_ = BuildMockSocket(data_reads,
+ arraysize(data_reads),
+ data_writes,
+ arraysize(data_writes),
host_resolver_.get(),
- "localhost", 80,
+ "localhost",
+ 80,
&log);
// At this state the TCP connection is completed but not the SOCKS handshake.
@@ -160,16 +162,14 @@ TEST_F(SOCKSClientSocketTest, CompleteHandshake) {
CapturingNetLog::CapturedEntryList entries;
log.GetEntries(&entries);
- EXPECT_TRUE(
- LogContainsBeginEvent(entries, 0, NetLog::TYPE_SOCKS_CONNECT));
+ EXPECT_TRUE(LogContainsBeginEvent(entries, 0, NetLog::TYPE_SOCKS_CONNECT));
EXPECT_FALSE(user_sock_->IsConnected());
rv = callback_.WaitForResult();
EXPECT_EQ(OK, rv);
EXPECT_TRUE(user_sock_->IsConnected());
log.GetEntries(&entries);
- EXPECT_TRUE(LogContainsEndEvent(
- entries, -1, NetLog::TYPE_SOCKS_CONNECT));
+ EXPECT_TRUE(LogContainsEndEvent(entries, -1, NetLog::TYPE_SOCKS_CONNECT));
scoped_refptr<IOBuffer> buffer(new IOBuffer(payload_write.size()));
memcpy(buffer->data(), payload_write.data(), payload_write.size());
@@ -199,32 +199,32 @@ TEST_F(SOCKSClientSocketTest, HandshakeFailures) {
const char fail_reply[8];
Error fail_code;
} tests[] = {
- // Failure of the server response code
- {
- { 0x01, 0x5A, 0x00, 0x00, 0, 0, 0, 0 },
- ERR_SOCKS_CONNECTION_FAILED,
- },
- // Failure of the null byte
- {
- { 0x00, 0x5B, 0x00, 0x00, 0, 0, 0, 0 },
- ERR_SOCKS_CONNECTION_FAILED,
- },
- };
+ // Failure of the server response code
+ {
+ {0x01, 0x5A, 0x00, 0x00, 0, 0, 0, 0}, ERR_SOCKS_CONNECTION_FAILED,
+ },
+ // Failure of the null byte
+ {
+ {0x00, 0x5B, 0x00, 0x00, 0, 0, 0, 0}, ERR_SOCKS_CONNECTION_FAILED,
+ },
+ };
//---------------------------------------
for (size_t i = 0; i < ARRAYSIZE_UNSAFE(tests); ++i) {
MockWrite data_writes[] = {
- MockWrite(SYNCHRONOUS, kSOCKSOkRequest, arraysize(kSOCKSOkRequest)) };
- MockRead data_reads[] = {
- MockRead(SYNCHRONOUS, tests[i].fail_reply,
- arraysize(tests[i].fail_reply)) };
+ MockWrite(SYNCHRONOUS, kSOCKSOkRequest, arraysize(kSOCKSOkRequest))};
+ MockRead data_reads[] = {MockRead(
+ SYNCHRONOUS, tests[i].fail_reply, arraysize(tests[i].fail_reply))};
CapturingNetLog log;
- user_sock_ = BuildMockSocket(data_reads, arraysize(data_reads),
- data_writes, arraysize(data_writes),
+ user_sock_ = BuildMockSocket(data_reads,
+ arraysize(data_reads),
+ data_writes,
+ arraysize(data_writes),
host_resolver_.get(),
- "localhost", 80,
+ "localhost",
+ 80,
&log);
int rv = user_sock_->Connect(callback_.callback());
@@ -232,121 +232,121 @@ TEST_F(SOCKSClientSocketTest, HandshakeFailures) {
CapturingNetLog::CapturedEntryList entries;
log.GetEntries(&entries);
- EXPECT_TRUE(LogContainsBeginEvent(
- entries, 0, NetLog::TYPE_SOCKS_CONNECT));
+ EXPECT_TRUE(LogContainsBeginEvent(entries, 0, NetLog::TYPE_SOCKS_CONNECT));
rv = callback_.WaitForResult();
EXPECT_EQ(tests[i].fail_code, rv);
EXPECT_FALSE(user_sock_->IsConnected());
EXPECT_TRUE(tcp_sock_->IsConnected());
log.GetEntries(&entries);
- EXPECT_TRUE(LogContainsEndEvent(
- entries, -1, NetLog::TYPE_SOCKS_CONNECT));
+ EXPECT_TRUE(LogContainsEndEvent(entries, -1, NetLog::TYPE_SOCKS_CONNECT));
}
}
// Tests scenario when the server sends the handshake response in
// more than one packet.
TEST_F(SOCKSClientSocketTest, PartialServerReads) {
- const char kSOCKSPartialReply1[] = { 0x00 };
- const char kSOCKSPartialReply2[] = { 0x5A, 0x00, 0x00, 0, 0, 0, 0 };
+ const char kSOCKSPartialReply1[] = {0x00};
+ const char kSOCKSPartialReply2[] = {0x5A, 0x00, 0x00, 0, 0, 0, 0};
MockWrite data_writes[] = {
- MockWrite(ASYNC, kSOCKSOkRequest, arraysize(kSOCKSOkRequest)) };
+ MockWrite(ASYNC, kSOCKSOkRequest, arraysize(kSOCKSOkRequest))};
MockRead data_reads[] = {
MockRead(ASYNC, kSOCKSPartialReply1, arraysize(kSOCKSPartialReply1)),
- MockRead(ASYNC, kSOCKSPartialReply2, arraysize(kSOCKSPartialReply2)) };
+ MockRead(ASYNC, kSOCKSPartialReply2, arraysize(kSOCKSPartialReply2))};
CapturingNetLog log;
- user_sock_ = BuildMockSocket(data_reads, arraysize(data_reads),
- data_writes, arraysize(data_writes),
+ user_sock_ = BuildMockSocket(data_reads,
+ arraysize(data_reads),
+ data_writes,
+ arraysize(data_writes),
host_resolver_.get(),
- "localhost", 80,
+ "localhost",
+ 80,
&log);
int rv = user_sock_->Connect(callback_.callback());
EXPECT_EQ(ERR_IO_PENDING, rv);
CapturingNetLog::CapturedEntryList entries;
log.GetEntries(&entries);
- EXPECT_TRUE(LogContainsBeginEvent(
- entries, 0, NetLog::TYPE_SOCKS_CONNECT));
+ EXPECT_TRUE(LogContainsBeginEvent(entries, 0, NetLog::TYPE_SOCKS_CONNECT));
rv = callback_.WaitForResult();
EXPECT_EQ(OK, rv);
EXPECT_TRUE(user_sock_->IsConnected());
log.GetEntries(&entries);
- EXPECT_TRUE(LogContainsEndEvent(
- entries, -1, NetLog::TYPE_SOCKS_CONNECT));
+ EXPECT_TRUE(LogContainsEndEvent(entries, -1, NetLog::TYPE_SOCKS_CONNECT));
}
// Tests scenario when the client sends the handshake request in
// more than one packet.
TEST_F(SOCKSClientSocketTest, PartialClientWrites) {
- const char kSOCKSPartialRequest1[] = { 0x04, 0x01 };
- const char kSOCKSPartialRequest2[] = { 0x00, 0x50, 127, 0, 0, 1, 0 };
+ const char kSOCKSPartialRequest1[] = {0x04, 0x01};
+ const char kSOCKSPartialRequest2[] = {0x00, 0x50, 127, 0, 0, 1, 0};
MockWrite data_writes[] = {
MockWrite(ASYNC, arraysize(kSOCKSPartialRequest1)),
// simulate some empty writes
- MockWrite(ASYNC, 0),
- MockWrite(ASYNC, 0),
- MockWrite(ASYNC, kSOCKSPartialRequest2,
- arraysize(kSOCKSPartialRequest2)) };
+ MockWrite(ASYNC, 0), MockWrite(ASYNC, 0),
+ MockWrite(
+ ASYNC, kSOCKSPartialRequest2, arraysize(kSOCKSPartialRequest2))};
MockRead data_reads[] = {
- MockRead(ASYNC, kSOCKSOkReply, arraysize(kSOCKSOkReply)) };
+ MockRead(ASYNC, kSOCKSOkReply, arraysize(kSOCKSOkReply))};
CapturingNetLog log;
- user_sock_ = BuildMockSocket(data_reads, arraysize(data_reads),
- data_writes, arraysize(data_writes),
+ user_sock_ = BuildMockSocket(data_reads,
+ arraysize(data_reads),
+ data_writes,
+ arraysize(data_writes),
host_resolver_.get(),
- "localhost", 80,
+ "localhost",
+ 80,
&log);
int rv = user_sock_->Connect(callback_.callback());
EXPECT_EQ(ERR_IO_PENDING, rv);
CapturingNetLog::CapturedEntryList entries;
log.GetEntries(&entries);
- EXPECT_TRUE(LogContainsBeginEvent(
- entries, 0, NetLog::TYPE_SOCKS_CONNECT));
+ EXPECT_TRUE(LogContainsBeginEvent(entries, 0, NetLog::TYPE_SOCKS_CONNECT));
rv = callback_.WaitForResult();
EXPECT_EQ(OK, rv);
EXPECT_TRUE(user_sock_->IsConnected());
log.GetEntries(&entries);
- EXPECT_TRUE(LogContainsEndEvent(
- entries, -1, NetLog::TYPE_SOCKS_CONNECT));
+ EXPECT_TRUE(LogContainsEndEvent(entries, -1, NetLog::TYPE_SOCKS_CONNECT));
}
// Tests the case when the server sends a smaller sized handshake data
// and closes the connection.
TEST_F(SOCKSClientSocketTest, FailedSocketRead) {
MockWrite data_writes[] = {
- MockWrite(ASYNC, kSOCKSOkRequest, arraysize(kSOCKSOkRequest)) };
+ MockWrite(ASYNC, kSOCKSOkRequest, arraysize(kSOCKSOkRequest))};
MockRead data_reads[] = {
MockRead(ASYNC, kSOCKSOkReply, arraysize(kSOCKSOkReply) - 2),
// close connection unexpectedly
- MockRead(SYNCHRONOUS, 0) };
+ MockRead(SYNCHRONOUS, 0)};
CapturingNetLog log;
- user_sock_ = BuildMockSocket(data_reads, arraysize(data_reads),
- data_writes, arraysize(data_writes),
+ user_sock_ = BuildMockSocket(data_reads,
+ arraysize(data_reads),
+ data_writes,
+ arraysize(data_writes),
host_resolver_.get(),
- "localhost", 80,
+ "localhost",
+ 80,
&log);
int rv = user_sock_->Connect(callback_.callback());
EXPECT_EQ(ERR_IO_PENDING, rv);
CapturingNetLog::CapturedEntryList entries;
log.GetEntries(&entries);
- EXPECT_TRUE(LogContainsBeginEvent(
- entries, 0, NetLog::TYPE_SOCKS_CONNECT));
+ EXPECT_TRUE(LogContainsBeginEvent(entries, 0, NetLog::TYPE_SOCKS_CONNECT));
rv = callback_.WaitForResult();
EXPECT_EQ(ERR_CONNECTION_CLOSED, rv);
EXPECT_FALSE(user_sock_->IsConnected());
log.GetEntries(&entries);
- EXPECT_TRUE(LogContainsEndEvent(
- entries, -1, NetLog::TYPE_SOCKS_CONNECT));
+ EXPECT_TRUE(LogContainsEndEvent(entries, -1, NetLog::TYPE_SOCKS_CONNECT));
}
// Tries to connect to an unknown hostname. Should fail rather than
@@ -358,41 +358,39 @@ TEST_F(SOCKSClientSocketTest, FailedDNS) {
CapturingNetLog log;
- user_sock_ = BuildMockSocket(NULL, 0,
- NULL, 0,
- host_resolver_.get(),
- hostname, 80,
- &log);
+ user_sock_ = BuildMockSocket(
+ NULL, 0, NULL, 0, host_resolver_.get(), hostname, 80, &log);
int rv = user_sock_->Connect(callback_.callback());
EXPECT_EQ(ERR_IO_PENDING, rv);
CapturingNetLog::CapturedEntryList entries;
log.GetEntries(&entries);
- EXPECT_TRUE(LogContainsBeginEvent(
- entries, 0, NetLog::TYPE_SOCKS_CONNECT));
+ EXPECT_TRUE(LogContainsBeginEvent(entries, 0, NetLog::TYPE_SOCKS_CONNECT));
rv = callback_.WaitForResult();
EXPECT_EQ(ERR_NAME_NOT_RESOLVED, rv);
EXPECT_FALSE(user_sock_->IsConnected());
log.GetEntries(&entries);
- EXPECT_TRUE(LogContainsEndEvent(
- entries, -1, NetLog::TYPE_SOCKS_CONNECT));
+ EXPECT_TRUE(LogContainsEndEvent(entries, -1, NetLog::TYPE_SOCKS_CONNECT));
}
// Calls Disconnect() while a host resolve is in progress. The outstanding host
// resolve should be cancelled.
TEST_F(SOCKSClientSocketTest, DisconnectWhileHostResolveInProgress) {
scoped_ptr<HangingHostResolverWithCancel> hanging_resolver(
- new HangingHostResolverWithCancel());
+ new HangingHostResolverWithCancel());
// Doesn't matter what the socket data is, we will never use it -- garbage.
- MockWrite data_writes[] = { MockWrite(SYNCHRONOUS, "", 0) };
- MockRead data_reads[] = { MockRead(SYNCHRONOUS, "", 0) };
+ MockWrite data_writes[] = {MockWrite(SYNCHRONOUS, "", 0)};
+ MockRead data_reads[] = {MockRead(SYNCHRONOUS, "", 0)};
- user_sock_ = BuildMockSocket(data_reads, arraysize(data_reads),
- data_writes, arraysize(data_writes),
+ user_sock_ = BuildMockSocket(data_reads,
+ arraysize(data_reads),
+ data_writes,
+ arraysize(data_writes),
hanging_resolver.get(),
- "foo", 80,
+ "foo",
+ 80,
NULL);
// Start connecting (will get stuck waiting for the host to resolve).
« net/base/mime_util_unittest.cc ('K') | « net/socket/socks_client_socket_pool_unittest.cc ('k') | net/socket/ssl_client_socket.h » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698