test_tcp_socket.cc 36 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047
  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
  3. // found in the LICENSE file.
  4. #include "ppapi/tests/test_tcp_socket.h"
  5. #include <vector>
  6. #include "ppapi/cpp/message_loop.h"
  7. #include "ppapi/cpp/tcp_socket.h"
  8. #include "ppapi/tests/test_utils.h"
  9. #include "ppapi/tests/testing_instance.h"
  10. namespace {
  11. // Validates the first line of an HTTP response.
  12. bool ValidateHttpResponse(const std::string& s) {
  13. // Just check that it begins with "HTTP/" and ends with a "\r\n".
  14. return s.size() >= 5 &&
  15. s.substr(0, 5) == "HTTP/" &&
  16. s.substr(s.size() - 2) == "\r\n";
  17. }
  18. } // namespace
  19. REGISTER_TEST_CASE(TCPSocket);
  20. TestTCPSocket::TestTCPSocket(TestingInstance* instance)
  21. : TestCase(instance),
  22. socket_interface_1_0_(NULL) {
  23. }
  24. bool TestTCPSocket::Init() {
  25. if (!pp::TCPSocket::IsAvailable())
  26. return false;
  27. socket_interface_1_0_ =
  28. static_cast<const PPB_TCPSocket_1_0*>(
  29. pp::Module::Get()->GetBrowserInterface(PPB_TCPSOCKET_INTERFACE_1_0));
  30. if (!socket_interface_1_0_)
  31. return false;
  32. // We need something to connect to, so we connect to the HTTP server whence we
  33. // came. Grab the host and port.
  34. if (!EnsureRunningOverHTTP())
  35. return false;
  36. std::string host;
  37. uint16_t port = 0;
  38. if (!GetLocalHostPort(instance_->pp_instance(), &host, &port))
  39. return false;
  40. if (!ResolveHost(instance_->pp_instance(), host, port, &test_server_addr_))
  41. return false;
  42. return true;
  43. }
  44. void TestTCPSocket::RunTests(const std::string& filter) {
  45. RUN_CALLBACK_TEST(TestTCPSocket, Connect, filter);
  46. RUN_CALLBACK_TEST(TestTCPSocket, ReadWrite, filter);
  47. RUN_CALLBACK_TEST(TestTCPSocket, SetOption, filter);
  48. RUN_CALLBACK_TEST(TestTCPSocket, Listen, filter);
  49. RUN_CALLBACK_TEST(TestTCPSocket, Backlog, filter);
  50. RUN_CALLBACK_TEST(TestTCPSocket, Interface_1_0, filter);
  51. RUN_CALLBACK_TEST(TestTCPSocket, UnexpectedCalls, filter);
  52. RUN_CALLBACK_TEST(TestTCPSocket, ConnectFails, filter);
  53. RUN_CALLBACK_TEST(TestTCPSocket, ConnectHangs, filter);
  54. RUN_CALLBACK_TEST(TestTCPSocket, WriteFails, filter);
  55. RUN_CALLBACK_TEST(TestTCPSocket, ReadFails, filter);
  56. RUN_CALLBACK_TEST(TestTCPSocket, SetSendBufferSizeFails, filter);
  57. RUN_CALLBACK_TEST(TestTCPSocket, SetReceiveBufferSizeFails, filter);
  58. RUN_CALLBACK_TEST(TestTCPSocket, SetNoDelayFails, filter);
  59. RUN_CALLBACK_TEST(TestTCPSocket, BindFailsConnectSucceeds, filter);
  60. RUN_CALLBACK_TEST(TestTCPSocket, BindFails, filter);
  61. RUN_CALLBACK_TEST(TestTCPSocket, BindHangs, filter);
  62. RUN_CALLBACK_TEST(TestTCPSocket, ListenFails, filter);
  63. RUN_CALLBACK_TEST(TestTCPSocket, ListenHangs, filter);
  64. RUN_CALLBACK_TEST(TestTCPSocket, AcceptFails, filter);
  65. RUN_CALLBACK_TEST(TestTCPSocket, AcceptHangs, filter);
  66. RUN_CALLBACK_TEST(TestTCPSocket, AcceptedSocketWriteFails, filter);
  67. RUN_CALLBACK_TEST(TestTCPSocket, AcceptedSocketReadFails, filter);
  68. RUN_CALLBACK_TEST(TestTCPSocket, BindConnectFails, filter);
  69. RUN_CALLBACK_TEST(TestTCPSocket, BindConnectHangs, filter);
  70. }
  71. std::string TestTCPSocket::TestConnect() {
  72. {
  73. // The basic case.
  74. pp::TCPSocket socket(instance_);
  75. TestCompletionCallback cb(instance_->pp_instance(), callback_type());
  76. cb.WaitForResult(socket.Connect(test_server_addr_, cb.GetCallback()));
  77. CHECK_CALLBACK_BEHAVIOR(cb);
  78. ASSERT_EQ(PP_OK, cb.result());
  79. pp::NetAddress local_addr, remote_addr;
  80. local_addr = socket.GetLocalAddress();
  81. remote_addr = socket.GetRemoteAddress();
  82. ASSERT_NE(0, local_addr.pp_resource());
  83. ASSERT_NE(0, remote_addr.pp_resource());
  84. ASSERT_TRUE(EqualNetAddress(test_server_addr_, remote_addr));
  85. socket.Close();
  86. }
  87. {
  88. // Connect a bound socket.
  89. pp::TCPSocket socket(instance_);
  90. TestCompletionCallback cb(instance_->pp_instance(), callback_type());
  91. pp::NetAddress any_port_address;
  92. ASSERT_SUBTEST_SUCCESS(GetAddressToBind(&any_port_address));
  93. cb.WaitForResult(socket.Bind(any_port_address, cb.GetCallback()));
  94. CHECK_CALLBACK_BEHAVIOR(cb);
  95. ASSERT_EQ(PP_OK, cb.result());
  96. cb.WaitForResult(socket.Connect(test_server_addr_, cb.GetCallback()));
  97. CHECK_CALLBACK_BEHAVIOR(cb);
  98. ASSERT_EQ(PP_OK, cb.result());
  99. pp::NetAddress local_addr, remote_addr;
  100. local_addr = socket.GetLocalAddress();
  101. remote_addr = socket.GetRemoteAddress();
  102. ASSERT_NE(0, local_addr.pp_resource());
  103. ASSERT_NE(0, remote_addr.pp_resource());
  104. ASSERT_TRUE(EqualNetAddress(test_server_addr_, remote_addr));
  105. ASSERT_NE(0u, GetPort(local_addr));
  106. socket.Close();
  107. }
  108. PASS();
  109. }
  110. std::string TestTCPSocket::TestReadWrite() {
  111. pp::TCPSocket socket(instance_);
  112. {
  113. TestCompletionCallback cb(instance_->pp_instance(), callback_type());
  114. cb.WaitForResult(socket.Connect(test_server_addr_, cb.GetCallback()));
  115. CHECK_CALLBACK_BEHAVIOR(cb);
  116. ASSERT_EQ(PP_OK, cb.result());
  117. }
  118. ASSERT_SUBTEST_SUCCESS(WriteToSocket(&socket, "GET / HTTP/1.0\r\n\r\n"));
  119. // Read up to the first \n and check that it looks like valid HTTP response.
  120. std::string s;
  121. ASSERT_SUBTEST_SUCCESS(ReadFirstLineFromSocket(&socket, &s));
  122. ASSERT_TRUE(ValidateHttpResponse(s));
  123. // Read until the server closes the socket.
  124. std::string read_data;
  125. int read_error;
  126. ASSERT_SUBTEST_SUCCESS(
  127. ReadFromSocketUntilError(&socket, &read_data, &read_error));
  128. ASSERT_EQ(PP_OK, read_error);
  129. // Reading again from the socket after getting an EOF should result in an
  130. // error.
  131. read_data = "";
  132. ASSERT_SUBTEST_SUCCESS(
  133. ReadFromSocketUntilError(&socket, &read_data, &read_error));
  134. ASSERT_EQ(PP_ERROR_FAILED, read_error);
  135. ASSERT_EQ("", read_data);
  136. char write_data[32 * 1024] = {0};
  137. // Write to the socket until there's an error, just to make sure the error
  138. // handling code works. As with the read case, go through two failures
  139. // (which may or may not fail with the same error code).
  140. int failures = 0;
  141. while (true) {
  142. TestCompletionCallback cb(instance_->pp_instance(), callback_type());
  143. cb.WaitForResult(socket.Write(write_data,
  144. static_cast<int32_t>(sizeof(write_data)),
  145. cb.GetCallback()));
  146. CHECK_CALLBACK_BEHAVIOR(cb);
  147. if (cb.result() > 0) {
  148. ASSERT_EQ(0, failures);
  149. continue;
  150. }
  151. // While this will most likely be PP_ERROR_CONNECTION_ABORTED, it seems best
  152. // not to rely on that, as write errors can be a bit finicky.
  153. ASSERT_LT(cb.result(), 0);
  154. ASSERT_NE(PP_ERROR_FAILED, cb.result());
  155. ASSERT_NE(PP_OK_COMPLETIONPENDING, cb.result());
  156. ++failures;
  157. if (failures == 2)
  158. break;
  159. }
  160. PASS();
  161. }
  162. std::string TestTCPSocket::TestSetOption() {
  163. pp::TCPSocket socket(instance_);
  164. TestCompletionCallback cb_1(instance_->pp_instance(), callback_type());
  165. TestCompletionCallback cb_2(instance_->pp_instance(), callback_type());
  166. TestCompletionCallback cb_3(instance_->pp_instance(), callback_type());
  167. // These options can be set even before the socket is connected.
  168. int32_t result_1 = socket.SetOption(PP_TCPSOCKET_OPTION_NO_DELAY,
  169. true, cb_1.GetCallback());
  170. int32_t result_2 = socket.SetOption(PP_TCPSOCKET_OPTION_SEND_BUFFER_SIZE,
  171. 256, cb_2.GetCallback());
  172. int32_t result_3 = socket.SetOption(PP_TCPSOCKET_OPTION_RECV_BUFFER_SIZE,
  173. 512, cb_3.GetCallback());
  174. cb_1.WaitForResult(result_1);
  175. CHECK_CALLBACK_BEHAVIOR(cb_1);
  176. ASSERT_EQ(PP_OK, cb_1.result());
  177. cb_2.WaitForResult(result_2);
  178. CHECK_CALLBACK_BEHAVIOR(cb_2);
  179. ASSERT_EQ(PP_OK, cb_2.result());
  180. cb_3.WaitForResult(result_3);
  181. CHECK_CALLBACK_BEHAVIOR(cb_3);
  182. ASSERT_EQ(PP_OK, cb_3.result());
  183. cb_1.WaitForResult(socket.Connect(test_server_addr_, cb_1.GetCallback()));
  184. CHECK_CALLBACK_BEHAVIOR(cb_1);
  185. ASSERT_EQ(PP_OK, cb_1.result());
  186. result_1 = socket.SetOption(PP_TCPSOCKET_OPTION_NO_DELAY,
  187. false, cb_1.GetCallback());
  188. result_2 = socket.SetOption(PP_TCPSOCKET_OPTION_SEND_BUFFER_SIZE,
  189. 512, cb_2.GetCallback());
  190. result_3 = socket.SetOption(PP_TCPSOCKET_OPTION_RECV_BUFFER_SIZE,
  191. 1024, cb_3.GetCallback());
  192. cb_1.WaitForResult(result_1);
  193. CHECK_CALLBACK_BEHAVIOR(cb_1);
  194. ASSERT_EQ(PP_OK, cb_1.result());
  195. cb_2.WaitForResult(result_2);
  196. CHECK_CALLBACK_BEHAVIOR(cb_2);
  197. ASSERT_EQ(PP_OK, cb_2.result());
  198. cb_3.WaitForResult(result_3);
  199. CHECK_CALLBACK_BEHAVIOR(cb_3);
  200. ASSERT_EQ(PP_OK, cb_3.result());
  201. PASS();
  202. }
  203. std::string TestTCPSocket::TestListen() {
  204. // TODO(mmenke): Whenever this test is run, the PPAPI process DCHECKs on
  205. // shutdown when a ref count is decremented on the wrong thread. Someone
  206. // should probably look into that.
  207. static const int kBacklog = 2;
  208. pp::TCPSocket server_socket(instance_);
  209. ASSERT_SUBTEST_SUCCESS(StartListen(&server_socket, kBacklog));
  210. // We can't use a blocking callback for Accept, because it will wait forever
  211. // for the client to connect, since the client connects after.
  212. TestCompletionCallbackWithOutput<pp::TCPSocket>
  213. accept_callback(instance_->pp_instance(), PP_REQUIRED);
  214. // We need to make sure there's a message loop to run accept_callback on.
  215. pp::MessageLoop current_thread_loop(pp::MessageLoop::GetCurrent());
  216. if (current_thread_loop.is_null() && testing_interface_->IsOutOfProcess()) {
  217. current_thread_loop = pp::MessageLoop(instance_);
  218. current_thread_loop.AttachToCurrentThread();
  219. }
  220. int32_t accept_rv = server_socket.Accept(accept_callback.GetCallback());
  221. pp::TCPSocket client_socket;
  222. TestCompletionCallback callback(instance_->pp_instance(), callback_type());
  223. do {
  224. client_socket = pp::TCPSocket(instance_);
  225. callback.WaitForResult(client_socket.Connect(
  226. server_socket.GetLocalAddress(), callback.GetCallback()));
  227. } while (callback.result() != PP_OK);
  228. pp::NetAddress client_local_addr = client_socket.GetLocalAddress();
  229. pp::NetAddress client_remote_addr = client_socket.GetRemoteAddress();
  230. ASSERT_FALSE(client_local_addr.is_null());
  231. ASSERT_FALSE(client_remote_addr.is_null());
  232. accept_callback.WaitForResult(accept_rv);
  233. CHECK_CALLBACK_BEHAVIOR(accept_callback);
  234. ASSERT_EQ(PP_OK, accept_callback.result());
  235. pp::TCPSocket accepted_socket(accept_callback.output());
  236. pp::NetAddress accepted_local_addr = accepted_socket.GetLocalAddress();
  237. pp::NetAddress accepted_remote_addr = accepted_socket.GetRemoteAddress();
  238. ASSERT_FALSE(accepted_local_addr.is_null());
  239. ASSERT_FALSE(accepted_remote_addr.is_null());
  240. ASSERT_TRUE(EqualNetAddress(client_local_addr, accepted_remote_addr));
  241. const std::string kSentData = "a";
  242. ASSERT_SUBTEST_SUCCESS(WriteToSocket(&client_socket, kSentData));
  243. // Close the client socket to be able to read until EOF.
  244. client_socket.Close();
  245. std::string read_data;
  246. int read_error;
  247. ASSERT_SUBTEST_SUCCESS(
  248. ReadFromSocketUntilError(&accepted_socket, &read_data, &read_error));
  249. ASSERT_EQ(kSentData, read_data);
  250. ASSERT_EQ(PP_OK, read_error);
  251. accepted_socket.Close();
  252. server_socket.Close();
  253. PASS();
  254. }
  255. std::string TestTCPSocket::TestBacklog() {
  256. static const size_t kBacklog = 5;
  257. pp::TCPSocket server_socket(instance_);
  258. ASSERT_SUBTEST_SUCCESS(StartListen(&server_socket, 2 * kBacklog));
  259. std::vector<pp::TCPSocket*> client_sockets(kBacklog);
  260. std::vector<TestCompletionCallback*> connect_callbacks(kBacklog);
  261. std::vector<int32_t> connect_rv(kBacklog);
  262. pp::NetAddress address = server_socket.GetLocalAddress();
  263. for (size_t i = 0; i < kBacklog; ++i) {
  264. client_sockets[i] = new pp::TCPSocket(instance_);
  265. connect_callbacks[i] = new TestCompletionCallback(instance_->pp_instance(),
  266. callback_type());
  267. connect_rv[i] = client_sockets[i]->Connect(
  268. address, connect_callbacks[i]->GetCallback());
  269. }
  270. std::vector<pp::TCPSocket*> accepted_sockets(kBacklog);
  271. for (size_t i = 0; i < kBacklog; ++i) {
  272. TestCompletionCallbackWithOutput<pp::TCPSocket> callback(
  273. instance_->pp_instance(), callback_type());
  274. callback.WaitForResult(server_socket.Accept(callback.GetCallback()));
  275. CHECK_CALLBACK_BEHAVIOR(callback);
  276. ASSERT_EQ(PP_OK, callback.result());
  277. accepted_sockets[i] = new pp::TCPSocket(callback.output());
  278. ASSERT_FALSE(accepted_sockets[i]->is_null());
  279. }
  280. for (size_t i = 0; i < kBacklog; ++i) {
  281. connect_callbacks[i]->WaitForResult(connect_rv[i]);
  282. CHECK_CALLBACK_BEHAVIOR(*connect_callbacks[i]);
  283. ASSERT_EQ(PP_OK, connect_callbacks[i]->result());
  284. }
  285. for (size_t i = 0; i < kBacklog; ++i) {
  286. const char byte = static_cast<char>('a' + i);
  287. ASSERT_SUBTEST_SUCCESS(WriteToSocket(client_sockets[i],
  288. std::string(1, byte)));
  289. }
  290. bool byte_received[kBacklog] = {};
  291. for (size_t i = 0; i < kBacklog; ++i) {
  292. char byte;
  293. ASSERT_SUBTEST_SUCCESS(ReadFromSocket(
  294. accepted_sockets[i], &byte, sizeof(byte)));
  295. const size_t index = byte - 'a';
  296. ASSERT_GE(index, 0u);
  297. ASSERT_LT(index, kBacklog);
  298. ASSERT_FALSE(byte_received[index]);
  299. byte_received[index] = true;
  300. }
  301. for (size_t i = 0; i < kBacklog; ++i) {
  302. ASSERT_TRUE(byte_received[i]);
  303. delete client_sockets[i];
  304. delete connect_callbacks[i];
  305. delete accepted_sockets[i];
  306. }
  307. PASS();
  308. }
  309. std::string TestTCPSocket::TestInterface_1_0() {
  310. PP_Resource socket = socket_interface_1_0_->Create(instance_->pp_instance());
  311. ASSERT_NE(0, socket);
  312. TestCompletionCallback cb(instance_->pp_instance(), callback_type());
  313. cb.WaitForResult(socket_interface_1_0_->Connect(
  314. socket, test_server_addr_.pp_resource(),
  315. cb.GetCallback().pp_completion_callback()));
  316. CHECK_CALLBACK_BEHAVIOR(cb);
  317. ASSERT_EQ(PP_OK, cb.result());
  318. ASSERT_SUBTEST_SUCCESS(WriteToSocket_1_0(socket, "GET / HTTP/1.0\r\n\r\n"));
  319. // Read up to the first \n and check that it looks like valid HTTP response.
  320. std::string s;
  321. ASSERT_SUBTEST_SUCCESS(ReadFirstLineFromSocket_1_0(socket, &s));
  322. ASSERT_TRUE(ValidateHttpResponse(s));
  323. pp::Module::Get()->core()->ReleaseResource(socket);
  324. PASS();
  325. }
  326. std::string TestTCPSocket::TestUnexpectedCalls() {
  327. // Tests that calls that are not expected given a sockets current state fail
  328. // with PP_ERROR_FAILED without breaking future operations on the socket.
  329. // Test a listen socket.
  330. {
  331. pp::TCPSocket socket(instance_);
  332. ASSERT_SUBTEST_SUCCESS(
  333. RunCommandsExpendingFailures(&socket, kListen | kAccept | kReadWrite));
  334. // Connect
  335. TestCompletionCallback cb(instance_->pp_instance(), callback_type());
  336. cb.WaitForResult(socket.Connect(test_server_addr_, cb.GetCallback()));
  337. CHECK_CALLBACK_BEHAVIOR(cb);
  338. ASSERT_EQ(PP_OK, cb.result());
  339. ASSERT_SUBTEST_SUCCESS(
  340. RunCommandsExpendingFailures(&socket, kListen | kAccept | kConnect));
  341. // Write
  342. ASSERT_SUBTEST_SUCCESS(WriteToSocket(&socket, "GET / HTTP/1.0\r\n\r\n"));
  343. ASSERT_SUBTEST_SUCCESS(
  344. RunCommandsExpendingFailures(&socket, kListen | kAccept | kConnect));
  345. // Read
  346. std::string s;
  347. ASSERT_SUBTEST_SUCCESS(ReadFirstLineFromSocket(&socket, &s));
  348. ASSERT_TRUE(ValidateHttpResponse(s));
  349. ASSERT_SUBTEST_SUCCESS(
  350. RunCommandsExpendingFailures(&socket, kListen | kAccept | kConnect));
  351. socket.Close();
  352. ASSERT_SUBTEST_SUCCESS(RunCommandsExpendingFailures(
  353. &socket, kListen | kAccept | kConnect | kReadWrite));
  354. }
  355. // Test a server socket.
  356. {
  357. pp::TCPSocket server_socket(instance_);
  358. // Bind
  359. pp::NetAddress any_port_address;
  360. ASSERT_SUBTEST_SUCCESS(GetAddressToBind(&any_port_address));
  361. TestCompletionCallback callback(instance_->pp_instance(), callback_type());
  362. callback.WaitForResult(
  363. server_socket.Bind(any_port_address, callback.GetCallback()));
  364. CHECK_CALLBACK_BEHAVIOR(callback);
  365. ASSERT_EQ(PP_OK, callback.result());
  366. ASSERT_SUBTEST_SUCCESS(RunCommandsExpendingFailures(
  367. &server_socket, kBind | kAccept | kReadWrite));
  368. // Listen
  369. callback.WaitForResult(
  370. server_socket.Listen(1 /* backlog */, callback.GetCallback()));
  371. CHECK_CALLBACK_BEHAVIOR(callback);
  372. ASSERT_EQ(PP_OK, callback.result());
  373. ASSERT_SUBTEST_SUCCESS(RunCommandsExpendingFailures(
  374. &server_socket, kBind | kListen | kConnect | kReadWrite));
  375. // Accept
  376. pp::TCPSocket client_socket(instance_);
  377. TestCompletionCallback connect_callback(instance_->pp_instance(),
  378. callback_type());
  379. int connect_result = client_socket.Connect(server_socket.GetLocalAddress(),
  380. connect_callback.GetCallback());
  381. TestCompletionCallbackWithOutput<pp::TCPSocket> accept_callback(
  382. instance_->pp_instance(), callback_type());
  383. accept_callback.WaitForResult(
  384. server_socket.Accept(accept_callback.GetCallback()));
  385. CHECK_CALLBACK_BEHAVIOR(accept_callback);
  386. ASSERT_EQ(PP_OK, accept_callback.result());
  387. connect_callback.WaitForResult(connect_result);
  388. CHECK_CALLBACK_BEHAVIOR(connect_callback);
  389. ASSERT_EQ(PP_OK, connect_callback.result());
  390. pp::TCPSocket accepted_socket(accept_callback.output());
  391. ASSERT_SUBTEST_SUCCESS(RunCommandsExpendingFailures(
  392. &server_socket, kBind | kListen | kConnect | kReadWrite));
  393. client_socket.Close();
  394. accepted_socket.Close();
  395. server_socket.Close();
  396. }
  397. PASS();
  398. }
  399. std::string TestTCPSocket::TestConnectFails() {
  400. pp::TCPSocket socket(instance_);
  401. TestCompletionCallback cb(instance_->pp_instance(), callback_type());
  402. cb.WaitForResult(socket.Connect(test_server_addr_, cb.GetCallback()));
  403. CHECK_CALLBACK_BEHAVIOR(cb);
  404. ASSERT_EQ(PP_ERROR_FAILED, cb.result());
  405. // All subsequent calls on the socket should fail.
  406. ASSERT_SUBTEST_SUCCESS(RunCommandsExpendingFailures(&socket, kAllCommands));
  407. PASS();
  408. }
  409. std::string TestTCPSocket::TestConnectHangs() {
  410. pp::TCPSocket socket(instance_);
  411. TestCompletionCallback cb(instance_->pp_instance(), callback_type());
  412. socket.Connect(test_server_addr_, DoNothingCallback());
  413. PASS();
  414. }
  415. std::string TestTCPSocket::TestWriteFails() {
  416. pp::TCPSocket socket(instance_);
  417. {
  418. TestCompletionCallback cb(instance_->pp_instance(), callback_type());
  419. cb.WaitForResult(socket.Connect(test_server_addr_, cb.GetCallback()));
  420. CHECK_CALLBACK_BEHAVIOR(cb);
  421. ASSERT_EQ(PP_OK, cb.result());
  422. }
  423. // Write to the socket until there's an error. Some writes may succeed, since
  424. // Mojo writes complete before the socket tries to send data. As with the read
  425. // case, wait for two errors.
  426. char write_data[32 * 1024] = {0};
  427. int failures = 0;
  428. while (true) {
  429. TestCompletionCallback cb(instance_->pp_instance(), callback_type());
  430. cb.WaitForResult(socket.Write(write_data,
  431. static_cast<int32_t>(sizeof(write_data)),
  432. cb.GetCallback()));
  433. CHECK_CALLBACK_BEHAVIOR(cb);
  434. if (cb.result() > 0) {
  435. ASSERT_EQ(0, failures);
  436. continue;
  437. }
  438. ASSERT_EQ(PP_ERROR_FAILED, cb.result());
  439. ++failures;
  440. if (failures == 2)
  441. break;
  442. }
  443. PASS();
  444. }
  445. std::string TestTCPSocket::TestReadFails() {
  446. pp::TCPSocket socket(instance_);
  447. TestCompletionCallback cb(instance_->pp_instance(), callback_type());
  448. cb.WaitForResult(socket.Connect(test_server_addr_, cb.GetCallback()));
  449. CHECK_CALLBACK_BEHAVIOR(cb);
  450. ASSERT_EQ(PP_OK, cb.result());
  451. std::string read_data;
  452. int read_error;
  453. // Read should fail with no data received.
  454. ASSERT_SUBTEST_SUCCESS(
  455. ReadFromSocketUntilError(&socket, &read_data, &read_error));
  456. ASSERT_EQ(PP_ERROR_FAILED, read_error);
  457. ASSERT_EQ(0, read_data.size());
  458. // Reading again after the socket has been closed should also fail.
  459. ASSERT_SUBTEST_SUCCESS(
  460. ReadFromSocketUntilError(&socket, &read_data, &read_error));
  461. ASSERT_EQ(PP_ERROR_FAILED, read_error);
  462. ASSERT_EQ(0, read_data.size());
  463. PASS();
  464. }
  465. std::string TestTCPSocket::TestSetSendBufferSizeFails() {
  466. pp::TCPSocket socket(instance_);
  467. TestCompletionCallback cb(instance_->pp_instance(), callback_type());
  468. cb.WaitForResult(socket.Connect(test_server_addr_, cb.GetCallback()));
  469. CHECK_CALLBACK_BEHAVIOR(cb);
  470. ASSERT_EQ(PP_OK, cb.result());
  471. cb.WaitForResult(socket.SetOption(PP_TCPSOCKET_OPTION_SEND_BUFFER_SIZE, 256,
  472. cb.GetCallback()));
  473. CHECK_CALLBACK_BEHAVIOR(cb);
  474. ASSERT_EQ(PP_ERROR_FAILED, cb.result());
  475. PASS();
  476. }
  477. std::string TestTCPSocket::TestSetReceiveBufferSizeFails() {
  478. pp::TCPSocket socket(instance_);
  479. TestCompletionCallback cb(instance_->pp_instance(), callback_type());
  480. cb.WaitForResult(socket.Connect(test_server_addr_, cb.GetCallback()));
  481. CHECK_CALLBACK_BEHAVIOR(cb);
  482. ASSERT_EQ(PP_OK, cb.result());
  483. cb.WaitForResult(socket.SetOption(PP_TCPSOCKET_OPTION_RECV_BUFFER_SIZE, 256,
  484. cb.GetCallback()));
  485. CHECK_CALLBACK_BEHAVIOR(cb);
  486. ASSERT_EQ(PP_ERROR_FAILED, cb.result());
  487. PASS();
  488. }
  489. std::string TestTCPSocket::TestSetNoDelayFails() {
  490. pp::TCPSocket socket(instance_);
  491. TestCompletionCallback cb(instance_->pp_instance(), callback_type());
  492. cb.WaitForResult(socket.Connect(test_server_addr_, cb.GetCallback()));
  493. CHECK_CALLBACK_BEHAVIOR(cb);
  494. ASSERT_EQ(PP_OK, cb.result());
  495. cb.WaitForResult(
  496. socket.SetOption(PP_TCPSOCKET_OPTION_NO_DELAY, true, cb.GetCallback()));
  497. CHECK_CALLBACK_BEHAVIOR(cb);
  498. ASSERT_EQ(PP_ERROR_FAILED, cb.result());
  499. PASS();
  500. }
  501. std::string TestTCPSocket::TestBindFailsConnectSucceeds() {
  502. pp::TCPSocket socket(instance_);
  503. TestCompletionCallback callback(instance_->pp_instance(), callback_type());
  504. // The address doesn't matter here, other than that it should be valid.
  505. callback.WaitForResult(
  506. socket.Bind(test_server_addr_, callback.GetCallback()));
  507. CHECK_CALLBACK_BEHAVIOR(callback);
  508. ASSERT_EQ(PP_ERROR_FAILED, callback.result());
  509. callback.WaitForResult(
  510. socket.Connect(test_server_addr_, callback.GetCallback()));
  511. CHECK_CALLBACK_BEHAVIOR(callback);
  512. ASSERT_EQ(PP_OK, callback.result());
  513. PASS();
  514. }
  515. std::string TestTCPSocket::TestBindFails() {
  516. pp::TCPSocket socket(instance_);
  517. TestCompletionCallback callback(instance_->pp_instance(), callback_type());
  518. // The address doesn't matter here, other than that it should be valid.
  519. callback.WaitForResult(
  520. socket.Bind(test_server_addr_, callback.GetCallback()));
  521. CHECK_CALLBACK_BEHAVIOR(callback);
  522. ASSERT_EQ(PP_ERROR_FAILED, callback.result());
  523. PASS();
  524. }
  525. std::string TestTCPSocket::TestBindHangs() {
  526. pp::TCPSocket socket(instance_);
  527. socket.Bind(test_server_addr_, DoNothingCallback());
  528. PASS();
  529. }
  530. std::string TestTCPSocket::TestListenFails() {
  531. pp::TCPSocket socket(instance_);
  532. TestCompletionCallback callback(instance_->pp_instance(), callback_type());
  533. // The address doesn't matter here, other than that it should be valid.
  534. callback.WaitForResult(
  535. socket.Bind(test_server_addr_, callback.GetCallback()));
  536. CHECK_CALLBACK_BEHAVIOR(callback);
  537. ASSERT_EQ(PP_OK, callback.result());
  538. callback.WaitForResult(
  539. socket.Listen(2 /* backlog */, callback.GetCallback()));
  540. CHECK_CALLBACK_BEHAVIOR(callback);
  541. ASSERT_EQ(PP_ERROR_FAILED, callback.result());
  542. // All subsequent calls on the socket should fail.
  543. ASSERT_SUBTEST_SUCCESS(RunCommandsExpendingFailures(&socket, kAllCommands));
  544. PASS();
  545. }
  546. std::string TestTCPSocket::TestListenHangs() {
  547. pp::TCPSocket socket(instance_);
  548. TestCompletionCallback callback(instance_->pp_instance(), callback_type());
  549. // The address doesn't matter here, other than that it should be valid.
  550. callback.WaitForResult(
  551. socket.Bind(test_server_addr_, callback.GetCallback()));
  552. CHECK_CALLBACK_BEHAVIOR(callback);
  553. ASSERT_EQ(PP_OK, callback.result());
  554. socket.Listen(2 /* backlog */, DoNothingCallback());
  555. PASS();
  556. }
  557. std::string TestTCPSocket::TestAcceptFails() {
  558. pp::TCPSocket socket(instance_);
  559. TestCompletionCallback callback(instance_->pp_instance(), callback_type());
  560. // The address doesn't matter here, other than that it should be valid.
  561. callback.WaitForResult(
  562. socket.Bind(test_server_addr_, callback.GetCallback()));
  563. CHECK_CALLBACK_BEHAVIOR(callback);
  564. ASSERT_EQ(PP_OK, callback.result());
  565. callback.WaitForResult(
  566. socket.Listen(2 /* backlog */, callback.GetCallback()));
  567. CHECK_CALLBACK_BEHAVIOR(callback);
  568. ASSERT_EQ(PP_OK, callback.result());
  569. TestCompletionCallbackWithOutput<pp::TCPSocket> accept_callback(
  570. instance_->pp_instance(), callback_type());
  571. accept_callback.WaitForResult(socket.Accept(accept_callback.GetCallback()));
  572. CHECK_CALLBACK_BEHAVIOR(accept_callback);
  573. ASSERT_EQ(PP_ERROR_FAILED, accept_callback.result());
  574. PASS();
  575. }
  576. std::string TestTCPSocket::TestAcceptHangs() {
  577. pp::TCPSocket socket(instance_);
  578. TestCompletionCallback callback(instance_->pp_instance(), callback_type());
  579. // The address doesn't matter here, other than that it should be valid.
  580. callback.WaitForResult(
  581. socket.Bind(test_server_addr_, callback.GetCallback()));
  582. CHECK_CALLBACK_BEHAVIOR(callback);
  583. ASSERT_EQ(PP_OK, callback.result());
  584. callback.WaitForResult(
  585. socket.Listen(2 /* backlog */, callback.GetCallback()));
  586. CHECK_CALLBACK_BEHAVIOR(callback);
  587. ASSERT_EQ(PP_OK, callback.result());
  588. socket.Accept(DoNothingCallbackWithOutput<pp::TCPSocket>());
  589. PASS();
  590. }
  591. std::string TestTCPSocket::TestAcceptedSocketWriteFails() {
  592. pp::TCPSocket socket(instance_);
  593. TestCompletionCallback callback(instance_->pp_instance(), callback_type());
  594. // The address doesn't matter here, other than that it should be valid.
  595. callback.WaitForResult(
  596. socket.Bind(test_server_addr_, callback.GetCallback()));
  597. CHECK_CALLBACK_BEHAVIOR(callback);
  598. ASSERT_EQ(PP_OK, callback.result());
  599. callback.WaitForResult(
  600. socket.Listen(2 /* backlog */, callback.GetCallback()));
  601. CHECK_CALLBACK_BEHAVIOR(callback);
  602. ASSERT_EQ(PP_OK, callback.result());
  603. TestCompletionCallbackWithOutput<pp::TCPSocket> accept_callback(
  604. instance_->pp_instance(), callback_type());
  605. accept_callback.WaitForResult(socket.Accept(accept_callback.GetCallback()));
  606. CHECK_CALLBACK_BEHAVIOR(accept_callback);
  607. ASSERT_EQ(PP_OK, accept_callback.result());
  608. pp::TCPSocket accepted_socket(accept_callback.output());
  609. // Write to the socket until there's an error. Some writes may succeed, since
  610. // Mojo writes complete before the socket tries to send data. As with the read
  611. // case, wait for two errors.
  612. char write_data[32 * 1024] = {0};
  613. int failures = 0;
  614. while (true) {
  615. callback.WaitForResult(accepted_socket.Write(
  616. write_data, static_cast<int32_t>(sizeof(write_data)),
  617. callback.GetCallback()));
  618. CHECK_CALLBACK_BEHAVIOR(callback);
  619. if (callback.result() > 0) {
  620. ASSERT_EQ(0, failures);
  621. continue;
  622. }
  623. ASSERT_EQ(PP_ERROR_FAILED, callback.result());
  624. ++failures;
  625. if (failures == 2)
  626. break;
  627. }
  628. PASS();
  629. }
  630. std::string TestTCPSocket::TestAcceptedSocketReadFails() {
  631. pp::TCPSocket socket(instance_);
  632. TestCompletionCallback callback(instance_->pp_instance(), callback_type());
  633. // The address doesn't matter here, other than that it should be valid.
  634. callback.WaitForResult(
  635. socket.Bind(test_server_addr_, callback.GetCallback()));
  636. CHECK_CALLBACK_BEHAVIOR(callback);
  637. ASSERT_EQ(PP_OK, callback.result());
  638. callback.WaitForResult(
  639. socket.Listen(2 /* backlog */, callback.GetCallback()));
  640. CHECK_CALLBACK_BEHAVIOR(callback);
  641. ASSERT_EQ(PP_OK, callback.result());
  642. TestCompletionCallbackWithOutput<pp::TCPSocket> accept_callback(
  643. instance_->pp_instance(), callback_type());
  644. accept_callback.WaitForResult(socket.Accept(accept_callback.GetCallback()));
  645. CHECK_CALLBACK_BEHAVIOR(accept_callback);
  646. ASSERT_EQ(PP_OK, accept_callback.result());
  647. pp::TCPSocket accepted_socket(accept_callback.output());
  648. std::string read_data;
  649. int read_error;
  650. // Read should fail with no data received.
  651. ASSERT_SUBTEST_SUCCESS(
  652. ReadFromSocketUntilError(&accepted_socket, &read_data, &read_error));
  653. ASSERT_EQ(PP_ERROR_FAILED, read_error);
  654. ASSERT_EQ(0, read_data.size());
  655. // Reading again after the socket has been closed should also fail.
  656. ASSERT_SUBTEST_SUCCESS(
  657. ReadFromSocketUntilError(&accepted_socket, &read_data, &read_error));
  658. ASSERT_EQ(PP_ERROR_FAILED, read_error);
  659. ASSERT_EQ(0, read_data.size());
  660. PASS();
  661. }
  662. std::string TestTCPSocket::TestBindConnectFails() {
  663. pp::TCPSocket socket(instance_);
  664. TestCompletionCallback cb(instance_->pp_instance(), callback_type());
  665. cb.WaitForResult(socket.Bind(test_server_addr_, cb.GetCallback()));
  666. CHECK_CALLBACK_BEHAVIOR(cb);
  667. ASSERT_EQ(PP_OK, cb.result());
  668. cb.WaitForResult(socket.Connect(test_server_addr_, cb.GetCallback()));
  669. CHECK_CALLBACK_BEHAVIOR(cb);
  670. ASSERT_EQ(PP_ERROR_FAILED, cb.result());
  671. // All subsequent calls on the socket should fail.
  672. ASSERT_SUBTEST_SUCCESS(RunCommandsExpendingFailures(&socket, kAllCommands));
  673. PASS();
  674. }
  675. std::string TestTCPSocket::TestBindConnectHangs() {
  676. pp::TCPSocket socket(instance_);
  677. TestCompletionCallback cb(instance_->pp_instance(), callback_type());
  678. cb.WaitForResult(socket.Bind(test_server_addr_, cb.GetCallback()));
  679. CHECK_CALLBACK_BEHAVIOR(cb);
  680. ASSERT_EQ(PP_OK, cb.result());
  681. socket.Connect(test_server_addr_, DoNothingCallback());
  682. PASS();
  683. }
  684. std::string TestTCPSocket::ReadFirstLineFromSocket(pp::TCPSocket* socket,
  685. std::string* s) {
  686. char buffer[1000];
  687. s->clear();
  688. // Make sure we don't just hang if |Read()| spews.
  689. while (s->size() < 10000) {
  690. TestCompletionCallback cb(instance_->pp_instance(), callback_type());
  691. cb.WaitForResult(socket->Read(buffer, sizeof(buffer), cb.GetCallback()));
  692. CHECK_CALLBACK_BEHAVIOR(cb);
  693. ASSERT_GT(cb.result(), 0);
  694. s->reserve(s->size() + cb.result());
  695. for (int32_t i = 0; i < cb.result(); ++i) {
  696. s->push_back(buffer[i]);
  697. if (buffer[i] == '\n')
  698. PASS();
  699. }
  700. }
  701. PASS();
  702. }
  703. std::string TestTCPSocket::ReadFirstLineFromSocket_1_0(PP_Resource socket,
  704. std::string* s) {
  705. char buffer[1000];
  706. s->clear();
  707. // Make sure we don't just hang if |Read()| spews.
  708. while (s->size() < 10000) {
  709. TestCompletionCallback cb(instance_->pp_instance(), callback_type());
  710. cb.WaitForResult(socket_interface_1_0_->Read(
  711. socket, buffer, sizeof(buffer),
  712. cb.GetCallback().pp_completion_callback()));
  713. CHECK_CALLBACK_BEHAVIOR(cb);
  714. ASSERT_GT(cb.result(), 0);
  715. s->reserve(s->size() + cb.result());
  716. for (int32_t i = 0; i < cb.result(); ++i) {
  717. s->push_back(buffer[i]);
  718. if (buffer[i] == '\n')
  719. PASS();
  720. }
  721. }
  722. PASS();
  723. }
  724. std::string TestTCPSocket::ReadFromSocket(pp::TCPSocket* socket,
  725. char* buffer,
  726. size_t num_bytes) {
  727. while (num_bytes > 0) {
  728. TestCompletionCallback callback(instance_->pp_instance(), callback_type());
  729. callback.WaitForResult(
  730. socket->Read(buffer, static_cast<int32_t>(num_bytes),
  731. callback.GetCallback()));
  732. CHECK_CALLBACK_BEHAVIOR(callback);
  733. ASSERT_GT(callback.result(), 0);
  734. buffer += callback.result();
  735. num_bytes -= callback.result();
  736. }
  737. ASSERT_EQ(0u, num_bytes);
  738. PASS();
  739. }
  740. // Reads from the socket until an error (Or 0-byte read) occurs. Populates
  741. // |read_data| and |error| with that information. Doesn't return a std::string
  742. // to distinguish it from a subtest.
  743. std::string TestTCPSocket::ReadFromSocketUntilError(pp::TCPSocket* socket,
  744. std::string* read_data,
  745. int* read_error) {
  746. // Set |read_error| to a value that a read should never complete with.
  747. *read_error = PP_OK_COMPLETIONPENDING;
  748. while (true) {
  749. char buffer[1024];
  750. TestCompletionCallback callback(instance_->pp_instance(), callback_type());
  751. callback.WaitForResult(
  752. socket->Read(buffer, sizeof(buffer), callback.GetCallback()));
  753. CHECK_CALLBACK_BEHAVIOR(callback);
  754. ASSERT_LE(callback.result(), static_cast<int32_t>(sizeof(buffer)));
  755. ASSERT_NE(PP_OK_COMPLETIONPENDING, callback.result());
  756. if (callback.result() <= 0) {
  757. *read_error = callback.result();
  758. PASS();
  759. }
  760. read_data->append(buffer, callback.result());
  761. }
  762. }
  763. std::string TestTCPSocket::WriteToSocket(pp::TCPSocket* socket,
  764. const std::string& s) {
  765. const char* buffer = s.data();
  766. size_t written = 0;
  767. while (written < s.size()) {
  768. TestCompletionCallback cb(instance_->pp_instance(), callback_type());
  769. cb.WaitForResult(
  770. socket->Write(buffer + written,
  771. static_cast<int32_t>(s.size() - written),
  772. cb.GetCallback()));
  773. CHECK_CALLBACK_BEHAVIOR(cb);
  774. ASSERT_GT(cb.result(), 0);
  775. written += cb.result();
  776. }
  777. ASSERT_EQ(written, s.size());
  778. PASS();
  779. }
  780. std::string TestTCPSocket::WriteToSocket_1_0(
  781. PP_Resource socket,
  782. const std::string& s) {
  783. const char* buffer = s.data();
  784. size_t written = 0;
  785. while (written < s.size()) {
  786. TestCompletionCallback cb(instance_->pp_instance(), callback_type());
  787. cb.WaitForResult(socket_interface_1_0_->Write(
  788. socket, buffer + written,
  789. static_cast<int32_t>(s.size() - written),
  790. cb.GetCallback().pp_completion_callback()));
  791. CHECK_CALLBACK_BEHAVIOR(cb);
  792. ASSERT_GT(cb.result(), 0);
  793. written += cb.result();
  794. }
  795. ASSERT_EQ(written, s.size());
  796. PASS();
  797. }
  798. std::string TestTCPSocket::GetAddressToBind(pp::NetAddress* address) {
  799. // Connect to |test_server_addr_| and then sets |address| to the local address
  800. // used by that connection, replacing the port with 0 to use a random port.
  801. pp::TCPSocket socket(instance_);
  802. TestCompletionCallback callback(instance_->pp_instance(), callback_type());
  803. callback.WaitForResult(
  804. socket.Connect(test_server_addr_, callback.GetCallback()));
  805. CHECK_CALLBACK_BEHAVIOR(callback);
  806. ASSERT_EQ(PP_OK, callback.result());
  807. ASSERT_TRUE(ReplacePort(instance_->pp_instance(), socket.GetLocalAddress(), 0,
  808. address));
  809. ASSERT_FALSE(address->is_null());
  810. PASS();
  811. }
  812. std::string TestTCPSocket::StartListen(pp::TCPSocket* socket, int32_t backlog) {
  813. pp::NetAddress any_port_address;
  814. ASSERT_SUBTEST_SUCCESS(GetAddressToBind(&any_port_address));
  815. TestCompletionCallback callback(instance_->pp_instance(), callback_type());
  816. callback.WaitForResult(
  817. socket->Bind(any_port_address, callback.GetCallback()));
  818. CHECK_CALLBACK_BEHAVIOR(callback);
  819. ASSERT_EQ(PP_OK, callback.result());
  820. callback.WaitForResult(
  821. socket->Listen(backlog, callback.GetCallback()));
  822. CHECK_CALLBACK_BEHAVIOR(callback);
  823. ASSERT_EQ(PP_OK, callback.result());
  824. PASS();
  825. }
  826. std::string TestTCPSocket::RunCommandsExpendingFailures(pp::TCPSocket* socket,
  827. int commands) {
  828. ASSERT_NE(0, commands);
  829. if (commands & kBind) {
  830. TestCompletionCallback cb(instance_->pp_instance(), callback_type());
  831. pp::NetAddress any_port_address;
  832. ASSERT_TRUE(ReplacePort(instance_->pp_instance(), test_server_addr_, 0,
  833. &any_port_address));
  834. cb.WaitForResult(socket->Bind(any_port_address, cb.GetCallback()));
  835. CHECK_CALLBACK_BEHAVIOR(cb);
  836. ASSERT_EQ(PP_ERROR_FAILED, cb.result());
  837. }
  838. if (commands & kListen) {
  839. TestCompletionCallback callback(instance_->pp_instance(), callback_type());
  840. callback.WaitForResult(
  841. socket->Listen(1 /* backlog */, callback.GetCallback()));
  842. CHECK_CALLBACK_BEHAVIOR(callback);
  843. ASSERT_EQ(PP_ERROR_FAILED, callback.result());
  844. }
  845. if (commands & kAccept) {
  846. TestCompletionCallbackWithOutput<pp::TCPSocket> accept_callback(
  847. instance_->pp_instance(), callback_type());
  848. accept_callback.WaitForResult(
  849. socket->Accept(accept_callback.GetCallback()));
  850. CHECK_CALLBACK_BEHAVIOR(accept_callback);
  851. ASSERT_EQ(PP_ERROR_FAILED, accept_callback.result());
  852. }
  853. if (commands & kConnect) {
  854. TestCompletionCallback cb(instance_->pp_instance(), callback_type());
  855. cb.WaitForResult(socket->Connect(test_server_addr_, cb.GetCallback()));
  856. CHECK_CALLBACK_BEHAVIOR(cb);
  857. ASSERT_EQ(PP_ERROR_FAILED, cb.result());
  858. }
  859. if (commands & kReadWrite) {
  860. // Check that a read on a new socket fails.
  861. char buffer[1] = {'1'};
  862. TestCompletionCallback cb(instance_->pp_instance(), callback_type());
  863. cb.WaitForResult(socket->Read(buffer, sizeof(buffer), cb.GetCallback()));
  864. CHECK_CALLBACK_BEHAVIOR(cb);
  865. ASSERT_EQ(PP_ERROR_FAILED, cb.result());
  866. // Check that a write on a new socket fails.
  867. cb.WaitForResult(socket->Write(buffer, sizeof(buffer), cb.GetCallback()));
  868. CHECK_CALLBACK_BEHAVIOR(cb);
  869. ASSERT_EQ(PP_ERROR_FAILED, cb.result());
  870. }
  871. PASS();
  872. }