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

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

Issue 8804006: Reland 8688002: PPB_TCPSocket_Private/PPB_UDPSocket_Private are exposed to Browser (Closed) Base URL: svn://svn.chromium.org/chrome/trunk/src
Patch Set: fix destruction issue 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 | Annotate | Revision Log
OLDNEW
(Empty)
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
3 // found in the LICENSE file.
4
5 #include "ppapi/tests/test_tcp_socket_private_shared.h"
6
7 #include <string.h>
8 #include <new>
9 #include <string>
10 #include <vector>
11
12 #include "ppapi/cpp/module.h"
13 #include "ppapi/tests/test_utils.h"
14 #include "ppapi/tests/testing_instance.h"
15
16 REGISTER_TEST_CASE(TCPSocketPrivateShared);
17
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(
23 TestingInstance* instance)
24 : TestCase(instance), tcp_socket_private_interface_(NULL) {
25 }
26
27 bool TestTCPSocketPrivateShared::Init() {
28 tcp_socket_private_interface_ =
29 reinterpret_cast<PPB_TCPSocket_Private const*>(
30 pp::Module::Get()->GetBrowserInterface(
31 PPB_TCPSOCKET_PRIVATE_INTERFACE));
32 if (!tcp_socket_private_interface_)
33 instance_->AppendError("TCPSocketPrivate interface not available");
34 return tcp_socket_private_interface_ && InitTestingInterface();
35 }
36
37 void TestTCPSocketPrivateShared::RunTests(const std::string& filter) {
38 RUN_TEST(Create, filter);
39 RUN_TEST_FORCEASYNC_AND_NOT(GetAddress, filter);
40 RUN_TEST_FORCEASYNC_AND_NOT(Connect, filter);
41 RUN_TEST_FORCEASYNC_AND_NOT(Reconnect, filter);
42 }
43
44 void TestTCPSocketPrivateShared::QuitMessageLoop() {
45 testing_interface_->QuitMessageLoop(instance_->pp_instance());
46 }
47
48 std::string TestTCPSocketPrivateShared::CreateSocket(PP_Resource* socket) {
49 *socket = tcp_socket_private_interface_->Create(instance_->pp_instance());
50 if (0 == *socket)
51 return "PPB_TCPSocket_Private::Create failed";
52 if (!tcp_socket_private_interface_->IsTCPSocket(*socket))
53 return "PPB_TCPSocket_Private::IsTCPSocket failed";
54 PASS();
55 }
56
57 std::string TestTCPSocketPrivateShared::SyncConnect(PP_Resource socket,
58 const char* host,
59 int port) {
60 TestCompletionCallback callback(instance_->pp_instance(), force_async_);
61
62 int32_t rv = tcp_socket_private_interface_->Connect(
63 socket, host, port,
64 static_cast<pp::CompletionCallback>(callback).pp_completion_callback());
65
66 if (force_async_ && rv != PP_OK_COMPLETIONPENDING)
67 return ReportError("PPB_TCPSocket_Private::Connect force_async", rv);
68 if (rv == PP_OK_COMPLETIONPENDING)
69 rv = callback.WaitForResult();
70 if (rv != PP_OK)
71 return ReportError("PPB_TCPSocket_Private::Connect", rv);
72 PASS();
73 }
74
75 std::string TestTCPSocketPrivateShared::SyncConnectWithNetAddress(
76 PP_Resource socket, const PP_NetAddress_Private& addr) {
77 TestCompletionCallback callback(instance_->pp_instance(), force_async_);
78
79 int32_t rv = tcp_socket_private_interface_->ConnectWithNetAddress(
80 socket, &addr,
81 static_cast<pp::CompletionCallback>(callback).pp_completion_callback());
82
83 if (force_async_ && rv != PP_OK_COMPLETIONPENDING)
84 return ReportError(
85 "PPB_TCPSocket_Private::ConnectWithNetAddress force_async", rv);
86 if (rv == PP_OK_COMPLETIONPENDING)
87 rv = callback.WaitForResult();
88 if (rv != PP_OK)
89 return ReportError("PPB_TCPSocket_Private::ConnectWithNetAddress", rv);
90 PASS();
91 }
92
93 std::string TestTCPSocketPrivateShared::SyncSSLHandshake(PP_Resource socket,
94 const char* host,
95 int port) {
96 TestCompletionCallback callback(instance_->pp_instance(), force_async_);
97
98 int32_t rv = tcp_socket_private_interface_->SSLHandshake(
99 socket, host, port,
100 static_cast<pp::CompletionCallback>(callback).pp_completion_callback());
101
102 if (force_async_ && rv != PP_OK_COMPLETIONPENDING)
103 return ReportError("PPB_TCPSocket_Private::SSLHandshake force_async", rv);
104 if (rv == PP_OK_COMPLETIONPENDING)
105 rv = callback.WaitForResult();
106 if (rv != PP_OK)
107 return ReportError("PPB_TCPSocket_Private::SSLHandshake", rv);
108 PASS();
109 }
110
111 std::string TestTCPSocketPrivateShared::SyncRead(PP_Resource socket,
112 char* buffer,
113 int32_t num_bytes,
114 int32_t* bytes_read) {
115 TestCompletionCallback callback(instance_->pp_instance(), force_async_);
116
117 int32_t rv = tcp_socket_private_interface_->Read(
118 socket, buffer, num_bytes,
119 static_cast<pp::CompletionCallback>(callback).pp_completion_callback());
120
121 if (force_async_ && rv != PP_OK_COMPLETIONPENDING)
122 return ReportError("PPB_TCPSocket_Private::Read force_async", rv);
123 if (rv == PP_OK_COMPLETIONPENDING)
124 rv = callback.WaitForResult();
125
126 if (num_bytes != rv)
127 return ReportError("PPB_TCPSocket_Private::Read", rv);
128
129 *bytes_read = rv;
130 PASS();
131 }
132
133 std::string TestTCPSocketPrivateShared::SyncWrite(PP_Resource socket,
134 const char* buffer,
135 int32_t num_bytes,
136 int32_t* bytes_wrote) {
137 TestCompletionCallback callback(instance_->pp_instance(), force_async_);
138 int32_t rv = tcp_socket_private_interface_->Write(
139 socket, buffer, num_bytes,
140 static_cast<pp::CompletionCallback>(callback).pp_completion_callback());
141
142 if (force_async_ && rv != PP_OK_COMPLETIONPENDING)
143 return ReportError("PPB_TCPSocket_Private::Write force_async", rv);
144 if (rv == PP_OK_COMPLETIONPENDING)
145 rv = callback.WaitForResult();
146 if (num_bytes != rv)
147 return ReportError("PPB_TCPSocket_Private::Write", rv);
148
149 *bytes_wrote = rv;
150 PASS();
151 }
152
153 std::string TestTCPSocketPrivateShared::CheckHTTPResponse(
154 PP_Resource socket,
155 const std::string& request,
156 const std::string& response) {
157 int32_t rv;
158 std::string error_message;
159
160 error_message = SyncWrite(socket, request.c_str(), request.size(), &rv);
161 if (!error_message.empty())
162 return error_message;
163
164 std::vector<char> response_buffer(response.size());
165 error_message = SyncRead(socket, &response_buffer[0], response.size(), &rv);
166 if (!error_message.empty())
167 return error_message;
168
169 std::string actual_response(&response_buffer[0], rv);
170
171 if (response != actual_response)
172 return "CheckHTTPResponse failed, expected: " + response +
173 ", actual: " + actual_response;
174 PASS();
175 }
176
177 std::string TestTCPSocketPrivateShared::TestCreate() {
178 PP_Resource socket = tcp_socket_private_interface_->Create(0);
179 if (0 != socket)
180 return "PPB_TCPSocket_Private::Create returns valid socket " \
181 "for invalid instance";
182
183 return CreateSocket(&socket);
184 }
185
186 std::string TestTCPSocketPrivateShared::TestGetAddress() {
187 PP_Resource socket;
188 std::string error_message;
189
190 error_message = CreateSocket(&socket);
191 if (!error_message.empty())
192 return error_message;
193
194 error_message = SyncConnect(socket, kHost, kPort);
195 if (!error_message.empty())
196 return error_message;
197
198 PP_NetAddress_Private local_address, remote_address;
199
200 if (PP_TRUE != tcp_socket_private_interface_->GetLocalAddress(
201 socket, &local_address))
202 return "PPB_TCPSocketPrivate::GetLocalAddress failed";
203 if (PP_TRUE != tcp_socket_private_interface_->GetRemoteAddress(
204 socket, &remote_address))
205 return "PPB_TCPSocketPrivate::GetRemoteAddress failed";
206
207 tcp_socket_private_interface_->Disconnect(socket);
208
209 PASS();
210 }
211
212 std::string TestTCPSocketPrivateShared::TestConnect() {
213 PP_Resource socket;
214 std::string error_message;
215
216 error_message = CreateSocket(&socket);
217 if (!error_message.empty())
218 return error_message;
219 error_message = SyncConnect(socket, kHost, kPort);
220 if (!error_message.empty())
221 return error_message;
222 error_message = SyncSSLHandshake(socket, kHost, kPort);
223 if (!error_message.empty())
224 return error_message;
225 error_message =
226 CheckHTTPResponse(socket, "GET /robots.txt\r\n", "HTTP/1.0 200 OK");
227 if (!error_message.empty())
228 return error_message;
229 tcp_socket_private_interface_->Disconnect(socket);
230
231 PASS();
232 }
233
234 std::string TestTCPSocketPrivateShared::TestReconnect() {
235 PP_Resource socket;
236 std::string error_message;
237
238 error_message = CreateSocket(&socket);
239 if (!error_message.empty())
240 return error_message;
241 error_message = SyncConnect(socket, kHost, kPort);
242 if (!error_message.empty())
243 return error_message;
244 error_message = SyncSSLHandshake(socket, kHost, kPort);
245 if (!error_message.empty())
246 return error_message;
247
248 PP_NetAddress_Private remote_address;
249 if (PP_TRUE !=
250 tcp_socket_private_interface_->GetRemoteAddress(socket,
251 &remote_address))
252 return "PPB_TCPSocketPrivate::GetRemoteAddress failed";
253 tcp_socket_private_interface_->Disconnect(socket);
254
255 error_message = CreateSocket(&socket);
256 if (!error_message.empty())
257 return error_message;
258 error_message = SyncConnectWithNetAddress(socket, remote_address);
259 if (!error_message.empty())
260 return error_message;
261 error_message = SyncSSLHandshake(socket, kHost, kPort);
262 if (!error_message.empty())
263 return error_message;
264 error_message =
265 CheckHTTPResponse(socket, "GET /robots.txt\r\n", "HTTP/1.0 200 OK");
266 if (!error_message.empty())
267 return error_message;
268 tcp_socket_private_interface_->Disconnect(socket);
269
270 PASS();
271 }
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