OLD | NEW |
---|---|
1 // Copyright 2013 The Chromium Authors. All rights reserved. | 1 // Copyright 2013 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_udp_socket.h" | 5 #include "ppapi/tests/test_udp_socket.h" |
6 | 6 |
7 #include <vector> | 7 #include <vector> |
8 | 8 |
9 #include "ppapi/cpp/pass_ref.h" | 9 #include "ppapi/cpp/pass_ref.h" |
10 #include "ppapi/cpp/tcp_socket.h" | 10 #include "ppapi/cpp/tcp_socket.h" |
(...skipping 29 matching lines...) Expand all Loading... | |
40 } | 40 } |
41 default: { | 41 default: { |
42 PP_NOTREACHED(); | 42 PP_NOTREACHED(); |
43 } | 43 } |
44 } | 44 } |
45 return pp::NetAddress(); | 45 return pp::NetAddress(); |
46 } | 46 } |
47 | 47 |
48 } // namespace | 48 } // namespace |
49 | 49 |
50 TestUDPSocket::TestUDPSocket(TestingInstance* instance) : TestCase(instance) { | 50 TestUDPSocket::TestUDPSocket(TestingInstance* instance) |
51 : TestCase(instance), | |
52 socket_interface_1_0_(NULL), | |
53 socket_interface_1_1_(NULL) { | |
51 } | 54 } |
52 | 55 |
53 bool TestUDPSocket::Init() { | 56 bool TestUDPSocket::Init() { |
54 bool tcp_socket_is_available = pp::TCPSocket::IsAvailable(); | 57 bool tcp_socket_is_available = pp::TCPSocket::IsAvailable(); |
55 if (!tcp_socket_is_available) | 58 if (!tcp_socket_is_available) |
56 instance_->AppendError("PPB_TCPSocket interface not available"); | 59 instance_->AppendError("PPB_TCPSocket interface not available"); |
57 | 60 |
58 bool udp_socket_is_available = pp::UDPSocket::IsAvailable(); | 61 bool udp_socket_is_available = pp::UDPSocket::IsAvailable(); |
59 if (!udp_socket_is_available) | 62 if (!udp_socket_is_available) |
60 instance_->AppendError("PPB_UDPSocket interface not available"); | 63 instance_->AppendError("PPB_UDPSocket interface not available"); |
61 | 64 |
62 bool net_address_is_available = pp::NetAddress::IsAvailable(); | 65 bool net_address_is_available = pp::NetAddress::IsAvailable(); |
63 if (!net_address_is_available) | 66 if (!net_address_is_available) |
64 instance_->AppendError("PPB_NetAddress interface not available"); | 67 instance_->AppendError("PPB_NetAddress interface not available"); |
65 | 68 |
66 std::string host; | 69 std::string host; |
67 uint16_t port = 0; | 70 uint16_t port = 0; |
68 bool init_address = | 71 bool init_address = |
69 GetLocalHostPort(instance_->pp_instance(), &host, &port) && | 72 GetLocalHostPort(instance_->pp_instance(), &host, &port) && |
70 ResolveHost(instance_->pp_instance(), host, port, &address_); | 73 ResolveHost(instance_->pp_instance(), host, port, &address_); |
71 if (!init_address) | 74 if (!init_address) |
72 instance_->AppendError("Can't init address"); | 75 instance_->AppendError("Can't init address"); |
73 | 76 |
77 socket_interface_1_0_ = | |
78 static_cast<const PPB_UDPSocket_1_0*>( | |
79 pp::Module::Get()->GetBrowserInterface(PPB_UDPSOCKET_INTERFACE_1_0)); | |
80 if (!socket_interface_1_0_) | |
81 instance_->AppendError("PPB_UDPSocket_1_0 interface not available"); | |
82 | |
83 socket_interface_1_1_ = | |
84 static_cast<const PPB_UDPSocket_1_1*>( | |
85 pp::Module::Get()->GetBrowserInterface(PPB_UDPSOCKET_INTERFACE_1_1)); | |
86 if (!socket_interface_1_1_) | |
87 instance_->AppendError("PPB_UDPSocket_1_1 interface not available"); | |
88 | |
74 return tcp_socket_is_available && | 89 return tcp_socket_is_available && |
75 udp_socket_is_available && | 90 udp_socket_is_available && |
76 net_address_is_available && | 91 net_address_is_available && |
77 init_address && | 92 init_address && |
78 CheckTestingInterface() && | 93 CheckTestingInterface() && |
79 EnsureRunningOverHTTP(); | 94 EnsureRunningOverHTTP() && |
95 socket_interface_1_0_ != NULL && | |
96 socket_interface_1_1_ != NULL; | |
80 } | 97 } |
81 | 98 |
82 void TestUDPSocket::RunTests(const std::string& filter) { | 99 void TestUDPSocket::RunTests(const std::string& filter) { |
83 RUN_CALLBACK_TEST(TestUDPSocket, ReadWrite, filter); | 100 RUN_CALLBACK_TEST(TestUDPSocket, ReadWrite, filter); |
84 RUN_CALLBACK_TEST(TestUDPSocket, Broadcast, filter); | 101 RUN_CALLBACK_TEST(TestUDPSocket, Broadcast, filter); |
102 RUN_CALLBACK_TEST(TestUDPSocket, SetOption_1_0, filter); | |
103 RUN_CALLBACK_TEST(TestUDPSocket, SetOption_1_1, filter); | |
85 RUN_CALLBACK_TEST(TestUDPSocket, SetOption, filter); | 104 RUN_CALLBACK_TEST(TestUDPSocket, SetOption, filter); |
86 RUN_CALLBACK_TEST(TestUDPSocket, ParallelSend, filter); | 105 RUN_CALLBACK_TEST(TestUDPSocket, ParallelSend, filter); |
106 RUN_CALLBACK_TEST(TestUDPSocket, Multicast, filter); | |
87 } | 107 } |
88 | 108 |
89 std::string TestUDPSocket::GetLocalAddress(pp::NetAddress* address) { | 109 std::string TestUDPSocket::GetLocalAddress(pp::NetAddress* address) { |
90 pp::TCPSocket socket(instance_); | 110 pp::TCPSocket socket(instance_); |
91 TestCompletionCallback callback(instance_->pp_instance(), callback_type()); | 111 TestCompletionCallback callback(instance_->pp_instance(), callback_type()); |
92 callback.WaitForResult(socket.Connect(address_, callback.GetCallback())); | 112 callback.WaitForResult(socket.Connect(address_, callback.GetCallback())); |
93 CHECK_CALLBACK_BEHAVIOR(callback); | 113 CHECK_CALLBACK_BEHAVIOR(callback); |
94 ASSERT_EQ(PP_OK, callback.result()); | 114 ASSERT_EQ(PP_OK, callback.result()); |
95 *address = socket.GetLocalAddress(); | 115 *address = socket.GetLocalAddress(); |
96 ASSERT_NE(0, address->pp_resource()); | 116 ASSERT_NE(0, address->pp_resource()); |
(...skipping 82 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
179 &str)); | 199 &str)); |
180 | 200 |
181 callback.WaitForResult(rv); | 201 callback.WaitForResult(rv); |
182 CHECK_CALLBACK_BEHAVIOR(callback); | 202 CHECK_CALLBACK_BEHAVIOR(callback); |
183 ASSERT_FALSE(callback.result() < 0); | 203 ASSERT_FALSE(callback.result() < 0); |
184 ASSERT_EQ(message.size(), static_cast<size_t>(callback.result())); | 204 ASSERT_EQ(message.size(), static_cast<size_t>(callback.result())); |
185 ASSERT_EQ(message, str); | 205 ASSERT_EQ(message, str); |
186 PASS(); | 206 PASS(); |
187 } | 207 } |
188 | 208 |
209 std::string TestUDPSocket::SetMulticastOptions(pp::UDPSocket* socket) { | |
210 TestCompletionCallback callback_1(instance_->pp_instance(), callback_type()); | |
211 callback_1.WaitForResult(socket->SetOption( | |
212 PP_UDPSOCKET_OPTION_MULTICAST_LOOP, pp::Var(true), | |
213 callback_1.GetCallback())); | |
214 CHECK_CALLBACK_BEHAVIOR(callback_1); | |
215 ASSERT_EQ(PP_OK, callback_1.result()); | |
216 | |
217 TestCompletionCallback callback_2(instance_->pp_instance(), callback_type()); | |
218 callback_2.WaitForResult(socket->SetOption( | |
219 PP_UDPSOCKET_OPTION_MULTICAST_TTL, pp::Var(1), callback_2.GetCallback())); | |
220 CHECK_CALLBACK_BEHAVIOR(callback_2); | |
221 ASSERT_EQ(PP_OK, callback_2.result()); | |
222 | |
223 PASS(); | |
224 } | |
225 | |
189 std::string TestUDPSocket::TestReadWrite() { | 226 std::string TestUDPSocket::TestReadWrite() { |
190 pp::UDPSocket server_socket(instance_), client_socket(instance_); | 227 pp::UDPSocket server_socket(instance_), client_socket(instance_); |
191 pp::NetAddress server_address, client_address; | 228 pp::NetAddress server_address, client_address; |
192 | 229 |
193 ASSERT_SUBTEST_SUCCESS(LookupPortAndBindUDPSocket(&server_socket, | 230 ASSERT_SUBTEST_SUCCESS(LookupPortAndBindUDPSocket(&server_socket, |
194 &server_address)); | 231 &server_address)); |
195 ASSERT_SUBTEST_SUCCESS(LookupPortAndBindUDPSocket(&client_socket, | 232 ASSERT_SUBTEST_SUCCESS(LookupPortAndBindUDPSocket(&client_socket, |
196 &client_address)); | 233 &client_address)); |
197 const std::string message = "Simple message that will be sent via UDP"; | 234 const std::string message = "Simple message that will be sent via UDP"; |
198 pp::NetAddress recvfrom_address; | 235 pp::NetAddress recvfrom_address; |
(...skipping 50 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
249 // |second_message| was also received by |server1|. | 286 // |second_message| was also received by |server1|. |
250 ASSERT_SUBTEST_SUCCESS(ReadSocket(&server1, &recvfrom_address, | 287 ASSERT_SUBTEST_SUCCESS(ReadSocket(&server1, &recvfrom_address, |
251 second_message.size(), &message)); | 288 second_message.size(), &message)); |
252 ASSERT_EQ(second_message, message); | 289 ASSERT_EQ(second_message, message); |
253 | 290 |
254 server1.Close(); | 291 server1.Close(); |
255 server2.Close(); | 292 server2.Close(); |
256 PASS(); | 293 PASS(); |
257 } | 294 } |
258 | 295 |
296 std::string TestUDPSocket::TestSetOption_1_0() { | |
297 PP_Resource socket = socket_interface_1_0_->Create(instance_->pp_instance()); | |
298 ASSERT_NE(0, socket); | |
299 | |
300 // Multicast options are not supported in interface 1.0. | |
301 struct PP_Var value = PP_MakeBool(true); | |
bbudge
2015/02/19 21:27:04
Could we create a SetOption utility function to do
etrunko
2015/02/23 22:09:10
Done.
| |
302 TestCompletionCallback cb(instance_->pp_instance(), callback_type()); | |
303 cb.WaitForResult(socket_interface_1_0_->SetOption(socket, | |
304 PP_UDPSOCKET_OPTION_MULTICAST_LOOP, value, | |
305 cb.GetCallback().pp_completion_callback())); | |
306 CHECK_CALLBACK_BEHAVIOR(cb); | |
307 ASSERT_EQ(PP_ERROR_BADARGUMENT, cb.result()); | |
308 | |
309 PASS(); | |
bbudge
2015/02/19 21:27:05
If you create a resource (in this case 'socket') y
etrunko
2015/02/23 22:09:10
Done.
| |
310 } | |
311 | |
312 std::string TestUDPSocket::TestSetOption_1_1() { | |
313 PP_Resource socket = socket_interface_1_1_->Create(instance_->pp_instance()); | |
314 ASSERT_NE(0, socket); | |
315 | |
316 // Multicast options are not supported in interface 1.1. | |
317 struct PP_Var value = PP_MakeBool(true); | |
318 TestCompletionCallback cb(instance_->pp_instance(), callback_type()); | |
319 cb.WaitForResult(socket_interface_1_1_->SetOption(socket, | |
320 PP_UDPSOCKET_OPTION_MULTICAST_LOOP, value, | |
321 cb.GetCallback().pp_completion_callback())); | |
322 CHECK_CALLBACK_BEHAVIOR(cb); | |
323 ASSERT_EQ(PP_ERROR_BADARGUMENT, cb.result()); | |
324 | |
325 PASS(); | |
bbudge
2015/02/19 21:27:05
release 'socket'
etrunko
2015/02/23 22:09:10
Done.
| |
326 } | |
327 | |
259 std::string TestUDPSocket::TestSetOption() { | 328 std::string TestUDPSocket::TestSetOption() { |
260 pp::UDPSocket socket(instance_); | 329 pp::UDPSocket socket(instance_); |
261 | 330 |
262 ASSERT_SUBTEST_SUCCESS(SetBroadcastOptions(&socket)); | 331 ASSERT_SUBTEST_SUCCESS(SetBroadcastOptions(&socket)); |
332 ASSERT_SUBTEST_SUCCESS(SetMulticastOptions(&socket)); | |
263 | 333 |
264 // Try to pass incorrect option value's type. | 334 // Try to pass incorrect option value's type. |
265 TestCompletionCallback callback(instance_->pp_instance(), callback_type()); | 335 TestCompletionCallback callback(instance_->pp_instance(), callback_type()); |
266 callback.WaitForResult(socket.SetOption( | 336 callback.WaitForResult(socket.SetOption( |
267 PP_UDPSOCKET_OPTION_ADDRESS_REUSE, pp::Var(1), callback.GetCallback())); | 337 PP_UDPSOCKET_OPTION_ADDRESS_REUSE, pp::Var(1), callback.GetCallback())); |
268 CHECK_CALLBACK_BEHAVIOR(callback); | 338 CHECK_CALLBACK_BEHAVIOR(callback); |
269 ASSERT_EQ(PP_ERROR_BADARGUMENT, callback.result()); | 339 ASSERT_EQ(PP_ERROR_BADARGUMENT, callback.result()); |
270 | 340 |
341 // Invalid multicast TTL values (less than 0 and greater than 255). | |
342 callback.WaitForResult(socket->SetOption( | |
343 PP_UDPSOCKET_OPTION_MULTICAST_TTL, pp::Var(-1), callback.GetCallback())); | |
344 CHECK_CALLBACK_BEHAVIOR(callback); | |
345 ASSERT_EQ(PP_ERROR_BADARGUMENT, callback.result()); | |
346 | |
347 callback.WaitForResult(socket->SetOption( | |
348 PP_UDPSOCKET_OPTION_MULTICAST_TTL, pp::Var(256), callback.GetCallback())); | |
349 CHECK_CALLBACK_BEHAVIOR(callback); | |
350 ASSERT_EQ(PP_ERROR_BADARGUMENT, callback.result()); | |
351 | |
271 callback.WaitForResult(socket.SetOption( | 352 callback.WaitForResult(socket.SetOption( |
272 PP_UDPSOCKET_OPTION_BROADCAST, pp::Var(false), callback.GetCallback())); | 353 PP_UDPSOCKET_OPTION_BROADCAST, pp::Var(false), callback.GetCallback())); |
273 CHECK_CALLBACK_BEHAVIOR(callback); | 354 CHECK_CALLBACK_BEHAVIOR(callback); |
274 ASSERT_EQ(PP_OK, callback.result()); | 355 ASSERT_EQ(PP_OK, callback.result()); |
275 | 356 |
276 callback.WaitForResult(socket.SetOption( | 357 callback.WaitForResult(socket.SetOption( |
277 PP_UDPSOCKET_OPTION_SEND_BUFFER_SIZE, pp::Var(4096), | 358 PP_UDPSOCKET_OPTION_SEND_BUFFER_SIZE, pp::Var(4096), |
278 callback.GetCallback())); | 359 callback.GetCallback())); |
279 CHECK_CALLBACK_BEHAVIOR(callback); | 360 CHECK_CALLBACK_BEHAVIOR(callback); |
280 ASSERT_EQ(PP_OK, callback.result()); | 361 ASSERT_EQ(PP_OK, callback.result()); |
(...skipping 95 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
376 | 457 |
377 for (size_t i = 0; i < kParallelSends; i++) { | 458 for (size_t i = 0; i < kParallelSends; i++) { |
378 std::string str; | 459 std::string str; |
379 ASSERT_SUBTEST_SUCCESS( | 460 ASSERT_SUBTEST_SUCCESS( |
380 ReadSocket(&server_socket, &recvfrom_address, message.size(), &str)); | 461 ReadSocket(&server_socket, &recvfrom_address, message.size(), &str)); |
381 ASSERT_EQ(message, str); | 462 ASSERT_EQ(message, str); |
382 } | 463 } |
383 | 464 |
384 server_socket.Close(); | 465 server_socket.Close(); |
385 client_socket.Close(); | 466 client_socket.Close(); |
467 } | |
386 | 468 |
469 std::string TestUDPSocket::TestMulticast() { | |
470 pp::UDPSocket server1(instance_), server2(instance_); | |
471 | |
472 ASSERT_SUBTEST_SUCCESS(SetMulticastOptions(&server1)); | |
473 ASSERT_SUBTEST_SUCCESS(SetMulticastOptions(&server2)); | |
387 PASS(); | 474 PASS(); |
388 } | 475 } |
OLD | NEW |