OLD | NEW |
---|---|
(Empty) | |
1 // Copyright 2014 The Chromium Authors. All rights reserved. | |
2 // Use of this source code is governed by a BSD-style license that can be | |
3 // found in the LICENSE file. | |
4 | |
5 #include "net/socket/unix_domain_client_socket_posix.h" | |
6 | |
7 #include "base/bind.h" | |
8 #include "base/file_util.h" | |
9 #include "base/files/file_path.h" | |
10 #include "base/memory/scoped_ptr.h" | |
11 #include "base/run_loop.h" | |
12 #include "net/base/io_buffer.h" | |
13 #include "net/base/net_errors.h" | |
14 #include "net/socket/unix_domain_server_socket_posix.h" | |
15 #include "testing/gtest/include/gtest/gtest.h" | |
16 | |
17 namespace net { | |
18 | |
19 namespace { | |
20 | |
21 const char kSocketFilename[] = "unix_domain_socket_for_testing"; | |
22 | |
23 bool UserCanConnectCallback(bool allow_user, uid_t uid, gid_t gid) { | |
24 return allow_user; | |
25 } | |
26 | |
27 UnixDomainServerSocket::AuthCallback CreateAuthCallback(bool allow_user) { | |
28 return base::Bind(&UserCanConnectCallback, allow_user); | |
29 } | |
30 | |
31 void CallbackWithExpectedResultValue(int expected_rv, int rv) { | |
32 EXPECT_EQ(expected_rv, rv); | |
33 } | |
34 | |
35 CompletionCallback GetCompletionCallback(int expected_rv) { | |
36 return base::Bind(&CallbackWithExpectedResultValue, expected_rv); | |
37 } | |
38 | |
39 } // namespace | |
40 | |
41 class UnixDomainClientSocketTest : public testing::Test { | |
42 protected: | |
43 virtual void SetUp() OVERRIDE { | |
mmenke
2014/07/11 20:44:03
Can just do this in the constructor / destructor (
byungchul
2014/07/14 17:49:22
Done.
| |
44 // Builds a socket path under a temp directory created newly. | |
45 base::FilePath temp_dir; | |
46 base::CreateNewTempDirectory("", &temp_dir); | |
47 socket_path_ = temp_dir.Append(kSocketFilename).value(); | |
mmenke
2014/07/11 20:44:04
Suggest you use base/files/scoped_temp_dir.h. Sor
byungchul
2014/07/14 17:49:22
Done. Thank you for good suggestion.
| |
48 } | |
49 | |
50 virtual void TearDown() OVERRIDE { | |
51 // Deletes the temp dir created by SetUp(). | |
52 base::DeleteFile(base::FilePath(socket_path_).DirName(), true); | |
53 } | |
54 | |
55 std::string socket_path_; | |
56 }; | |
57 | |
58 TEST_F(UnixDomainClientSocketTest, Connect) { | |
59 const bool kUseAbstractNamespace = false; | |
60 | |
61 UnixDomainServerSocket server_socket(CreateAuthCallback(true), | |
62 kUseAbstractNamespace); | |
63 EXPECT_EQ(OK, server_socket.ListenWithAddressAndPort(socket_path_, 0, 1)); | |
64 | |
65 scoped_ptr<StreamSocket> accepted_socket; | |
66 EXPECT_EQ(ERR_IO_PENDING, server_socket.Accept(&accepted_socket, | |
67 GetCompletionCallback(OK))); | |
68 EXPECT_TRUE(!accepted_socket); | |
mmenke
2014/07/11 20:44:04
nit: EXPECT_TRUE(!...) is the same as EXPECT_FALS
byungchul
2014/07/14 17:49:23
Done.
| |
69 | |
70 UnixDomainClientSocket client_socket(socket_path_, kUseAbstractNamespace); | |
71 EXPECT_FALSE(client_socket.IsConnected()); | |
72 | |
73 EXPECT_EQ(OK, client_socket.Connect(GetCompletionCallback(OK))); | |
mmenke
2014/07/11 20:44:03
Why is this synchronous? The server hasn't even c
byungchul
2014/07/14 17:49:22
It might be because kernel accepts the connection.
| |
74 EXPECT_TRUE(client_socket.IsConnected()); | |
75 // Not yet notified to server. | |
mmenke
2014/07/11 20:44:02
Maybe: "Server has not yet been notified of the c
byungchul
2014/07/14 17:49:22
Done.
| |
76 EXPECT_TRUE(!accepted_socket); | |
77 | |
78 base::RunLoop().RunUntilIdle(); | |
mmenke
2014/07/11 20:44:04
Is the connect message guaranteed to already be qu
byungchul
2014/07/14 17:49:23
They are unix domain sockets in same process and s
| |
79 EXPECT_TRUE(accepted_socket); | |
80 EXPECT_TRUE(accepted_socket->IsConnected()); | |
mmenke
2014/07/11 20:44:04
Maybe disconnect and then check IsConnected?
byungchul
2014/07/14 17:49:22
Done in 2 other unittests disconnecting from each
| |
81 } | |
82 | |
83 TEST_F(UnixDomainClientSocketTest, ConnectWithAbstractNamespace) { | |
84 const bool kUseAbstractNamespace = true; | |
85 | |
86 UnixDomainClientSocket client_socket(socket_path_, kUseAbstractNamespace); | |
87 EXPECT_FALSE(client_socket.IsConnected()); | |
88 | |
89 #if defined(OS_ANDROID) || defined(OS_LINUX) | |
90 UnixDomainServerSocket server_socket(CreateAuthCallback(true), | |
91 kUseAbstractNamespace); | |
92 EXPECT_EQ(OK, server_socket.ListenWithAddressAndPort(socket_path_, 0, 1)); | |
93 | |
94 scoped_ptr<StreamSocket> accepted_socket; | |
95 EXPECT_EQ(ERR_IO_PENDING, server_socket.Accept(&accepted_socket, | |
96 GetCompletionCallback(OK))); | |
97 EXPECT_TRUE(!accepted_socket); | |
98 | |
99 EXPECT_EQ(OK, client_socket.Connect(GetCompletionCallback(OK))); | |
100 EXPECT_TRUE(client_socket.IsConnected()); | |
101 // Not yet notified to server. | |
102 EXPECT_TRUE(!accepted_socket); | |
103 | |
104 base::RunLoop().RunUntilIdle(); | |
105 EXPECT_TRUE(accepted_socket); | |
106 EXPECT_TRUE(accepted_socket->IsConnected()); | |
107 #else | |
108 EXPECT_EQ(ERR_ADDRESS_INVALID, | |
109 client_socket.Connect(GetCompletionCallback(OK))); | |
110 #endif | |
111 } | |
112 | |
113 TEST_F(UnixDomainClientSocketTest, ConnectToNonExistingSocket) { | |
mmenke
2014/07/11 20:44:03
ConnectToNonExistentServer, maybe? (And same for
byungchul
2014/07/14 17:49:22
Done.
| |
114 const bool kUseAbstractNamespace = false; | |
115 | |
116 UnixDomainClientSocket client_socket(socket_path_, kUseAbstractNamespace); | |
117 EXPECT_FALSE(client_socket.IsConnected()); | |
118 EXPECT_EQ(ERR_FILE_NOT_FOUND, | |
119 client_socket.Connect(GetCompletionCallback(OK))); | |
120 } | |
121 | |
122 TEST_F(UnixDomainClientSocketTest, | |
123 ConnectToNonExistingSocketWithAbstractNamespace) { | |
124 const bool kUseAbstractNamespace = true; | |
125 | |
126 UnixDomainClientSocket client_socket(socket_path_, kUseAbstractNamespace); | |
127 EXPECT_FALSE(client_socket.IsConnected()); | |
128 #if defined(OS_ANDROID) || defined(OS_LINUX) | |
129 EXPECT_EQ(ERR_CONNECTION_REFUSED, | |
130 client_socket.Connect(GetCompletionCallback(OK))); | |
131 #else | |
132 EXPECT_EQ(ERR_ADDRESS_INVALID, | |
133 client_socket.Connect(GetCompletionCallback(OK))); | |
134 #endif | |
135 } | |
136 | |
137 TEST_F(UnixDomainClientSocketTest, ReadWrite) { | |
138 UnixDomainServerSocket server_socket(CreateAuthCallback(true), false); | |
139 EXPECT_EQ(OK, server_socket.ListenWithAddressAndPort(socket_path_, 0, 1)); | |
140 scoped_ptr<StreamSocket> accepted_socket; | |
141 EXPECT_EQ(ERR_IO_PENDING, server_socket.Accept(&accepted_socket, | |
142 GetCompletionCallback(OK))); | |
143 UnixDomainClientSocket client_socket(socket_path_, false); | |
144 EXPECT_EQ(OK, client_socket.Connect(GetCompletionCallback(OK))); | |
145 | |
146 base::RunLoop().RunUntilIdle(); | |
147 EXPECT_TRUE(accepted_socket->IsConnected()); | |
148 EXPECT_TRUE(client_socket.IsConnected()); | |
149 | |
150 // Sends data from client to server. | |
mmenke
2014/07/11 20:44:02
nit: I believe imperatives ("Send data from clien
byungchul
2014/07/14 17:49:22
Done.
| |
151 const int write_data_size = 10; | |
152 scoped_refptr<IOBuffer> write_buffer( | |
153 new StringIOBuffer(std::string(write_data_size, 'd'))); | |
154 EXPECT_EQ(write_data_size, | |
155 client_socket.Write(write_buffer, write_data_size, | |
156 GetCompletionCallback(OK))); | |
mmenke
2014/07/11 20:44:03
Are we guaranteed the entire buffer will be writte
byungchul
2014/07/14 17:49:22
Default socket write buffer must be much greater t
| |
157 // Buffer bigger than write data size. | |
mmenke
2014/07/11 20:44:04
Per google style guide, comments should generally
byungchul
2014/07/14 17:49:22
Done.
| |
158 const int read_buffer_size = write_data_size * 2; | |
159 scoped_refptr<IOBuffer> read_buffer(new IOBuffer(read_buffer_size)); | |
160 EXPECT_EQ(write_data_size, | |
161 accepted_socket->Read(read_buffer, read_buffer_size, | |
162 GetCompletionCallback(OK))); | |
mmenke
2014/07/11 20:44:03
Should compare buffer contents here, and below, ou
mmenke
2014/07/11 20:44:04
Again, are we guaranteed the entire thing will be
byungchul
2014/07/14 17:49:22
I think so, because they are running in same proce
byungchul
2014/07/14 17:49:22
Done.
| |
163 | |
164 // Sends data from server and client | |
mmenke
2014/07/11 20:44:02
nit: period
byungchul
2014/07/14 17:49:23
Done.
| |
165 EXPECT_EQ(write_data_size, | |
166 accepted_socket->Write(write_buffer, write_data_size, | |
167 GetCompletionCallback(OK))); | |
168 // Reads multiple times. | |
169 const int small_read_buffer_size = write_data_size / 3; | |
170 EXPECT_EQ(small_read_buffer_size, | |
171 client_socket.Read(read_buffer, small_read_buffer_size, | |
172 GetCompletionCallback(OK))); | |
173 EXPECT_EQ(write_data_size - small_read_buffer_size, | |
174 client_socket.Read(read_buffer, read_buffer_size, | |
175 GetCompletionCallback(OK))); | |
176 // No more data. | |
177 EXPECT_EQ(ERR_IO_PENDING, | |
178 client_socket.Read(read_buffer, read_buffer_size, | |
179 GetCompletionCallback(ERR_CONNECTION_CLOSED))); | |
mmenke
2014/07/11 20:44:02
Should we wait to get the close message from the s
byungchul
2014/07/14 17:49:23
Done.
| |
180 } | |
181 | |
182 TEST_F(UnixDomainClientSocketTest, ReadWriteAsynchronously) { | |
mmenke
2014/07/11 20:44:03
There are no asyncronous writes here. Maybe ReadB
byungchul
2014/07/14 17:49:22
Done.
| |
183 UnixDomainServerSocket server_socket(CreateAuthCallback(true), false); | |
184 EXPECT_EQ(OK, server_socket.ListenWithAddressAndPort(socket_path_, 0, 1)); | |
185 scoped_ptr<StreamSocket> accepted_socket; | |
186 EXPECT_EQ(ERR_IO_PENDING, server_socket.Accept(&accepted_socket, | |
187 GetCompletionCallback(OK))); | |
188 UnixDomainClientSocket client_socket(socket_path_, false); | |
189 EXPECT_EQ(OK, client_socket.Connect(GetCompletionCallback(OK))); | |
190 | |
191 base::RunLoop().RunUntilIdle(); | |
192 EXPECT_TRUE(accepted_socket->IsConnected()); | |
193 EXPECT_TRUE(client_socket.IsConnected()); | |
194 | |
195 // Waits for data from client. | |
196 const int write_data_size = 10; | |
197 const int read_buffer_size = write_data_size * 2; | |
198 const int small_read_buffer_size = write_data_size / 3; | |
199 // Reads smaller than write data size first. | |
200 scoped_refptr<IOBuffer> read_buffer(new IOBuffer(read_buffer_size)); | |
201 EXPECT_EQ( | |
202 ERR_IO_PENDING, | |
203 accepted_socket->Read(read_buffer, small_read_buffer_size, | |
204 GetCompletionCallback(small_read_buffer_size))); | |
205 | |
206 scoped_refptr<IOBuffer> write_buffer( | |
207 new StringIOBuffer(std::string(write_data_size, 'd'))); | |
208 EXPECT_EQ(write_data_size, | |
209 client_socket.Write(write_buffer, write_data_size, | |
210 GetCompletionCallback(OK))); | |
211 | |
212 base::RunLoop().RunUntilIdle(); | |
213 // First read completed. | |
214 | |
215 // Reads remaining data. | |
216 EXPECT_EQ(write_data_size - small_read_buffer_size, | |
217 accepted_socket->Read(read_buffer, read_buffer_size, | |
218 GetCompletionCallback(OK))); | |
219 // No more data. | |
220 EXPECT_EQ(ERR_IO_PENDING, | |
221 accepted_socket->Read( | |
222 read_buffer, read_buffer_size, | |
223 GetCompletionCallback(ERR_CONNECTION_CLOSED))); | |
224 } | |
225 | |
226 } // namespace net | |
OLD | NEW |