OLD | NEW |
1 // Copyright (c) 2011 The Chromium Authors. All rights reserved. | 1 // Copyright (c) 2011 The Chromium Authors. All rights reserved. |
2 // Use of this source code is governed by a BSD-style license that can be | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "ppapi/tests/test_tcp_socket_private_shared.h" | 5 #include "ppapi/tests/test_tcp_socket_private_shared.h" |
6 | 6 |
7 #include <string.h> | |
8 #include <new> | |
9 #include <string> | |
10 #include <vector> | 7 #include <vector> |
11 | 8 |
12 #include "ppapi/cpp/module.h" | 9 #include "ppapi/cpp/module.h" |
13 #include "ppapi/tests/test_utils.h" | 10 #include "ppapi/tests/test_utils.h" |
14 #include "ppapi/tests/testing_instance.h" | 11 #include "ppapi/tests/testing_instance.h" |
15 | 12 |
16 REGISTER_TEST_CASE(TCPSocketPrivateShared); | 13 REGISTER_TEST_CASE(TCPSocketPrivateShared); |
17 | 14 |
18 // TODO(ygorshenin): get rid of using external server in tests, | |
19 // http://crbug.com/105863 | |
20 const char* const TestTCPSocketPrivateShared::kHost = "www.google.com"; | |
21 | |
22 TestTCPSocketPrivateShared::TestTCPSocketPrivateShared( | 15 TestTCPSocketPrivateShared::TestTCPSocketPrivateShared( |
23 TestingInstance* instance) | 16 TestingInstance* instance) |
24 : TestCase(instance), tcp_socket_private_interface_(NULL) { | 17 : TestCase(instance), tcp_socket_private_interface_(NULL) { |
25 } | 18 } |
26 | 19 |
27 bool TestTCPSocketPrivateShared::Init() { | 20 bool TestTCPSocketPrivateShared::Init() { |
28 tcp_socket_private_interface_ = static_cast<const PPB_TCPSocket_Private*>( | 21 tcp_socket_private_interface_ = static_cast<const PPB_TCPSocket_Private*>( |
29 pp::Module::Get()->GetBrowserInterface(PPB_TCPSOCKET_PRIVATE_INTERFACE)); | 22 pp::Module::Get()->GetBrowserInterface(PPB_TCPSOCKET_PRIVATE_INTERFACE)); |
30 if (!tcp_socket_private_interface_) | 23 if (!tcp_socket_private_interface_) |
31 instance_->AppendError("TCPSocketPrivate interface not available"); | 24 instance_->AppendError("TCPSocketPrivate interface not available"); |
32 return tcp_socket_private_interface_ && InitTestingInterface(); | 25 |
| 26 bool init_host_port = false; |
| 27 if (!GetLocalHostPort(instance_->pp_instance(), &host_, &port_)) |
| 28 instance_->AppendError("Can't init host and port"); |
| 29 else |
| 30 init_host_port = true; |
| 31 |
| 32 return tcp_socket_private_interface_ && |
| 33 init_host_port && |
| 34 InitTestingInterface(); |
33 } | 35 } |
34 | 36 |
35 void TestTCPSocketPrivateShared::RunTests(const std::string& filter) { | 37 void TestTCPSocketPrivateShared::RunTests(const std::string& filter) { |
36 RUN_TEST(Create, filter); | 38 RUN_TEST(Create, filter); |
37 RUN_TEST_FORCEASYNC_AND_NOT(GetAddress, filter); | 39 RUN_TEST_FORCEASYNC_AND_NOT(GetAddress, filter); |
38 RUN_TEST_FORCEASYNC_AND_NOT(Connect, filter); | 40 RUN_TEST_FORCEASYNC_AND_NOT(Connect, filter); |
39 RUN_TEST_FORCEASYNC_AND_NOT(Reconnect, filter); | 41 RUN_TEST_FORCEASYNC_AND_NOT(Reconnect, filter); |
40 } | 42 } |
41 | 43 |
42 void TestTCPSocketPrivateShared::QuitMessageLoop() { | 44 void TestTCPSocketPrivateShared::QuitMessageLoop() { |
43 testing_interface_->QuitMessageLoop(instance_->pp_instance()); | 45 testing_interface_->QuitMessageLoop(instance_->pp_instance()); |
44 } | 46 } |
45 | 47 |
46 std::string TestTCPSocketPrivateShared::CreateSocket(PP_Resource* socket) { | 48 std::string TestTCPSocketPrivateShared::CreateSocket(PP_Resource* socket) { |
47 *socket = tcp_socket_private_interface_->Create(instance_->pp_instance()); | 49 *socket = tcp_socket_private_interface_->Create(instance_->pp_instance()); |
48 if (0 == *socket) | 50 if (0 == *socket) |
49 return "PPB_TCPSocket_Private::Create failed"; | 51 return "PPB_TCPSocket_Private::Create failed"; |
50 if (!tcp_socket_private_interface_->IsTCPSocket(*socket)) | 52 if (!tcp_socket_private_interface_->IsTCPSocket(*socket)) |
51 return "PPB_TCPSocket_Private::IsTCPSocket failed"; | 53 return "PPB_TCPSocket_Private::IsTCPSocket failed"; |
52 PASS(); | 54 PASS(); |
53 } | 55 } |
54 | 56 |
55 std::string TestTCPSocketPrivateShared::SyncConnect(PP_Resource socket, | 57 std::string TestTCPSocketPrivateShared::SyncConnect(PP_Resource socket, |
56 const char* host, | 58 const std::string& host, |
57 int port) { | 59 uint16_t port) { |
58 TestCompletionCallback callback(instance_->pp_instance(), force_async_); | 60 TestCompletionCallback callback(instance_->pp_instance(), force_async_); |
59 | 61 |
60 int32_t rv = tcp_socket_private_interface_->Connect( | 62 int32_t rv = tcp_socket_private_interface_->Connect( |
61 socket, host, port, | 63 socket, host.c_str(), port, |
62 static_cast<pp::CompletionCallback>(callback).pp_completion_callback()); | 64 static_cast<pp::CompletionCallback>(callback).pp_completion_callback()); |
63 | 65 |
64 if (force_async_ && rv != PP_OK_COMPLETIONPENDING) | 66 if (force_async_ && rv != PP_OK_COMPLETIONPENDING) |
65 return ReportError("PPB_TCPSocket_Private::Connect force_async", rv); | 67 return ReportError("PPB_TCPSocket_Private::Connect force_async", rv); |
66 if (rv == PP_OK_COMPLETIONPENDING) | 68 if (rv == PP_OK_COMPLETIONPENDING) |
67 rv = callback.WaitForResult(); | 69 rv = callback.WaitForResult(); |
68 if (rv != PP_OK) | 70 if (rv != PP_OK) |
69 return ReportError("PPB_TCPSocket_Private::Connect", rv); | 71 return ReportError("PPB_TCPSocket_Private::Connect", rv); |
70 PASS(); | 72 PASS(); |
71 } | 73 } |
72 | 74 |
73 std::string TestTCPSocketPrivateShared::SyncConnectWithNetAddress( | 75 std::string TestTCPSocketPrivateShared::SyncConnectWithNetAddress( |
74 PP_Resource socket, const PP_NetAddress_Private& addr) { | 76 PP_Resource socket, const PP_NetAddress_Private& addr) { |
75 TestCompletionCallback callback(instance_->pp_instance(), force_async_); | 77 TestCompletionCallback callback(instance_->pp_instance(), force_async_); |
76 | 78 |
77 int32_t rv = tcp_socket_private_interface_->ConnectWithNetAddress( | 79 int32_t rv = tcp_socket_private_interface_->ConnectWithNetAddress( |
78 socket, &addr, | 80 socket, &addr, |
79 static_cast<pp::CompletionCallback>(callback).pp_completion_callback()); | 81 static_cast<pp::CompletionCallback>(callback).pp_completion_callback()); |
80 | 82 |
81 if (force_async_ && rv != PP_OK_COMPLETIONPENDING) | 83 if (force_async_ && rv != PP_OK_COMPLETIONPENDING) |
82 return ReportError( | 84 return ReportError( |
83 "PPB_TCPSocket_Private::ConnectWithNetAddress force_async", rv); | 85 "PPB_TCPSocket_Private::ConnectWithNetAddress force_async", rv); |
84 if (rv == PP_OK_COMPLETIONPENDING) | 86 if (rv == PP_OK_COMPLETIONPENDING) |
85 rv = callback.WaitForResult(); | 87 rv = callback.WaitForResult(); |
86 if (rv != PP_OK) | 88 if (rv != PP_OK) |
87 return ReportError("PPB_TCPSocket_Private::ConnectWithNetAddress", rv); | 89 return ReportError("PPB_TCPSocket_Private::ConnectWithNetAddress", rv); |
88 PASS(); | 90 PASS(); |
89 } | 91 } |
90 | 92 |
91 std::string TestTCPSocketPrivateShared::SyncSSLHandshake(PP_Resource socket, | |
92 const char* host, | |
93 int port) { | |
94 TestCompletionCallback callback(instance_->pp_instance(), force_async_); | |
95 | |
96 int32_t rv = tcp_socket_private_interface_->SSLHandshake( | |
97 socket, host, port, | |
98 static_cast<pp::CompletionCallback>(callback).pp_completion_callback()); | |
99 | |
100 if (force_async_ && rv != PP_OK_COMPLETIONPENDING) | |
101 return ReportError("PPB_TCPSocket_Private::SSLHandshake force_async", rv); | |
102 if (rv == PP_OK_COMPLETIONPENDING) | |
103 rv = callback.WaitForResult(); | |
104 if (rv != PP_OK) | |
105 return ReportError("PPB_TCPSocket_Private::SSLHandshake", rv); | |
106 PASS(); | |
107 } | |
108 | |
109 std::string TestTCPSocketPrivateShared::SyncRead(PP_Resource socket, | 93 std::string TestTCPSocketPrivateShared::SyncRead(PP_Resource socket, |
110 char* buffer, | 94 char* buffer, |
111 int32_t num_bytes, | 95 int32_t num_bytes, |
112 int32_t* bytes_read) { | 96 int32_t* bytes_read) { |
113 TestCompletionCallback callback(instance_->pp_instance(), force_async_); | 97 TestCompletionCallback callback(instance_->pp_instance(), force_async_); |
114 | 98 |
115 int32_t rv = tcp_socket_private_interface_->Read( | 99 int32_t rv = tcp_socket_private_interface_->Read( |
116 socket, buffer, num_bytes, | 100 socket, buffer, num_bytes, |
117 static_cast<pp::CompletionCallback>(callback).pp_completion_callback()); | 101 static_cast<pp::CompletionCallback>(callback).pp_completion_callback()); |
118 | 102 |
(...skipping 63 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
182 } | 166 } |
183 | 167 |
184 std::string TestTCPSocketPrivateShared::TestGetAddress() { | 168 std::string TestTCPSocketPrivateShared::TestGetAddress() { |
185 PP_Resource socket; | 169 PP_Resource socket; |
186 std::string error_message; | 170 std::string error_message; |
187 | 171 |
188 error_message = CreateSocket(&socket); | 172 error_message = CreateSocket(&socket); |
189 if (!error_message.empty()) | 173 if (!error_message.empty()) |
190 return error_message; | 174 return error_message; |
191 | 175 |
192 error_message = SyncConnect(socket, kHost, kPort); | 176 error_message = SyncConnect(socket, host_, port_); |
193 if (!error_message.empty()) | 177 if (!error_message.empty()) |
194 return error_message; | 178 return error_message; |
195 | 179 |
196 PP_NetAddress_Private local_address, remote_address; | 180 PP_NetAddress_Private local_address, remote_address; |
197 | 181 |
198 if (PP_TRUE != tcp_socket_private_interface_->GetLocalAddress( | 182 if (PP_TRUE != tcp_socket_private_interface_->GetLocalAddress( |
199 socket, &local_address)) | 183 socket, &local_address)) |
200 return "PPB_TCPSocketPrivate::GetLocalAddress failed"; | 184 return "PPB_TCPSocketPrivate::GetLocalAddress failed"; |
201 if (PP_TRUE != tcp_socket_private_interface_->GetRemoteAddress( | 185 if (PP_TRUE != tcp_socket_private_interface_->GetRemoteAddress( |
202 socket, &remote_address)) | 186 socket, &remote_address)) |
203 return "PPB_TCPSocketPrivate::GetRemoteAddress failed"; | 187 return "PPB_TCPSocketPrivate::GetRemoteAddress failed"; |
204 | 188 |
205 tcp_socket_private_interface_->Disconnect(socket); | 189 tcp_socket_private_interface_->Disconnect(socket); |
206 | 190 |
207 PASS(); | 191 PASS(); |
208 } | 192 } |
209 | 193 |
210 std::string TestTCPSocketPrivateShared::TestConnect() { | 194 std::string TestTCPSocketPrivateShared::TestConnect() { |
211 PP_Resource socket; | 195 PP_Resource socket; |
212 std::string error_message; | 196 std::string error_message; |
213 | 197 |
214 error_message = CreateSocket(&socket); | 198 error_message = CreateSocket(&socket); |
215 if (!error_message.empty()) | 199 if (!error_message.empty()) |
216 return error_message; | 200 return error_message; |
217 error_message = SyncConnect(socket, kHost, kPort); | 201 error_message = SyncConnect(socket, host_, port_); |
218 if (!error_message.empty()) | |
219 return error_message; | |
220 error_message = SyncSSLHandshake(socket, kHost, kPort); | |
221 if (!error_message.empty()) | 202 if (!error_message.empty()) |
222 return error_message; | 203 return error_message; |
223 error_message = | 204 error_message = |
224 CheckHTTPResponse(socket, "GET /robots.txt\r\n", "HTTP/1.0 200 OK"); | 205 CheckHTTPResponse(socket, "GET / HTTP/1.0\r\n\r\n", "HTTP/1.0 200 OK"); |
225 if (!error_message.empty()) | 206 if (!error_message.empty()) |
226 return error_message; | 207 return error_message; |
227 tcp_socket_private_interface_->Disconnect(socket); | 208 tcp_socket_private_interface_->Disconnect(socket); |
228 | 209 |
229 PASS(); | 210 PASS(); |
230 } | 211 } |
231 | 212 |
232 std::string TestTCPSocketPrivateShared::TestReconnect() { | 213 std::string TestTCPSocketPrivateShared::TestReconnect() { |
233 PP_Resource socket; | 214 PP_Resource socket; |
234 std::string error_message; | 215 std::string error_message; |
235 | 216 |
236 error_message = CreateSocket(&socket); | 217 error_message = CreateSocket(&socket); |
237 if (!error_message.empty()) | 218 if (!error_message.empty()) |
238 return error_message; | 219 return error_message; |
239 error_message = SyncConnect(socket, kHost, kPort); | 220 error_message = SyncConnect(socket, host_, port_); |
240 if (!error_message.empty()) | |
241 return error_message; | |
242 error_message = SyncSSLHandshake(socket, kHost, kPort); | |
243 if (!error_message.empty()) | 221 if (!error_message.empty()) |
244 return error_message; | 222 return error_message; |
245 | 223 |
246 PP_NetAddress_Private remote_address; | 224 PP_NetAddress_Private remote_address; |
247 if (PP_TRUE != | 225 if (PP_TRUE != |
248 tcp_socket_private_interface_->GetRemoteAddress(socket, | 226 tcp_socket_private_interface_->GetRemoteAddress(socket, |
249 &remote_address)) | 227 &remote_address)) |
250 return "PPB_TCPSocketPrivate::GetRemoteAddress failed"; | 228 return "PPB_TCPSocketPrivate::GetRemoteAddress failed"; |
251 tcp_socket_private_interface_->Disconnect(socket); | 229 tcp_socket_private_interface_->Disconnect(socket); |
252 | 230 |
253 error_message = CreateSocket(&socket); | 231 error_message = CreateSocket(&socket); |
254 if (!error_message.empty()) | 232 if (!error_message.empty()) |
255 return error_message; | 233 return error_message; |
256 error_message = SyncConnectWithNetAddress(socket, remote_address); | 234 error_message = SyncConnectWithNetAddress(socket, remote_address); |
257 if (!error_message.empty()) | 235 if (!error_message.empty()) |
258 return error_message; | 236 return error_message; |
259 error_message = SyncSSLHandshake(socket, kHost, kPort); | 237 error_message = CheckHTTPResponse(socket, |
260 if (!error_message.empty()) | 238 "GET / HTTP/1.0\r\n\r\n", |
261 return error_message; | 239 "HTTP/1.0 200 OK"); |
262 error_message = | |
263 CheckHTTPResponse(socket, "GET /robots.txt\r\n", "HTTP/1.0 200 OK"); | |
264 if (!error_message.empty()) | 240 if (!error_message.empty()) |
265 return error_message; | 241 return error_message; |
266 tcp_socket_private_interface_->Disconnect(socket); | 242 tcp_socket_private_interface_->Disconnect(socket); |
267 | 243 |
268 PASS(); | 244 PASS(); |
269 } | 245 } |
| 246 |
| 247 // TODO(ygorshenin): test SSLHandshake somehow |
OLD | NEW |