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

Side by Side Diff: ppapi/tests/test_tcp_socket_private_shared.cc

Issue 8840007: GetDocumentURL is added to PPB_Testing_Dev. (Closed) Base URL: http://git.chromium.org/chromium/src.git@master
Patch Set: Fixed codereview issues. Created 9 years 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 unified diff | Download patch
OLDNEW
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
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
OLDNEW
« no previous file with comments | « ppapi/tests/test_tcp_socket_private_shared.h ('k') | ppapi/tests/test_udp_socket_private_shared.h » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698