// Copyright 2013 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include "ppapi/tests/test_tcp_socket.h"

#include <vector>

#include "ppapi/cpp/message_loop.h"
#include "ppapi/cpp/tcp_socket.h"
#include "ppapi/tests/test_utils.h"
#include "ppapi/tests/testing_instance.h"

namespace {

// Validates the first line of an HTTP response.
bool ValidateHttpResponse(const std::string& s) {
  // Just check that it begins with "HTTP/" and ends with a "\r\n".
  return s.size() >= 5 &&
         s.substr(0, 5) == "HTTP/" &&
         s.substr(s.size() - 2) == "\r\n";
}

}  // namespace

REGISTER_TEST_CASE(TCPSocket);

TestTCPSocket::TestTCPSocket(TestingInstance* instance)
    : TestCase(instance),
      socket_interface_1_0_(NULL) {
}

bool TestTCPSocket::Init() {
  if (!pp::TCPSocket::IsAvailable())
    return false;
  socket_interface_1_0_ =
      static_cast<const PPB_TCPSocket_1_0*>(
          pp::Module::Get()->GetBrowserInterface(PPB_TCPSOCKET_INTERFACE_1_0));
  if (!socket_interface_1_0_)
    return false;

  // We need something to connect to, so we connect to the HTTP server whence we
  // came. Grab the host and port.
  if (!EnsureRunningOverHTTP())
    return false;

  std::string host;
  uint16_t port = 0;
  if (!GetLocalHostPort(instance_->pp_instance(), &host, &port))
    return false;

  if (!ResolveHost(instance_->pp_instance(), host, port, &test_server_addr_))
    return false;

  return true;
}

void TestTCPSocket::RunTests(const std::string& filter) {
  RUN_CALLBACK_TEST(TestTCPSocket, Connect, filter);
  RUN_CALLBACK_TEST(TestTCPSocket, ReadWrite, filter);
  RUN_CALLBACK_TEST(TestTCPSocket, SetOption, filter);
  RUN_CALLBACK_TEST(TestTCPSocket, Listen, filter);
  RUN_CALLBACK_TEST(TestTCPSocket, Backlog, filter);
  RUN_CALLBACK_TEST(TestTCPSocket, Interface_1_0, filter);
  RUN_CALLBACK_TEST(TestTCPSocket, UnexpectedCalls, filter);

  RUN_CALLBACK_TEST(TestTCPSocket, ConnectFails, filter);
  RUN_CALLBACK_TEST(TestTCPSocket, ConnectHangs, filter);
  RUN_CALLBACK_TEST(TestTCPSocket, WriteFails, filter);
  RUN_CALLBACK_TEST(TestTCPSocket, ReadFails, filter);
  RUN_CALLBACK_TEST(TestTCPSocket, SetSendBufferSizeFails, filter);
  RUN_CALLBACK_TEST(TestTCPSocket, SetReceiveBufferSizeFails, filter);
  RUN_CALLBACK_TEST(TestTCPSocket, SetNoDelayFails, filter);
  RUN_CALLBACK_TEST(TestTCPSocket, BindFailsConnectSucceeds, filter);
  RUN_CALLBACK_TEST(TestTCPSocket, BindFails, filter);
  RUN_CALLBACK_TEST(TestTCPSocket, BindHangs, filter);
  RUN_CALLBACK_TEST(TestTCPSocket, ListenFails, filter);
  RUN_CALLBACK_TEST(TestTCPSocket, ListenHangs, filter);
  RUN_CALLBACK_TEST(TestTCPSocket, AcceptFails, filter);
  RUN_CALLBACK_TEST(TestTCPSocket, AcceptHangs, filter);
  RUN_CALLBACK_TEST(TestTCPSocket, AcceptedSocketWriteFails, filter);
  RUN_CALLBACK_TEST(TestTCPSocket, AcceptedSocketReadFails, filter);
  RUN_CALLBACK_TEST(TestTCPSocket, BindConnectFails, filter);
  RUN_CALLBACK_TEST(TestTCPSocket, BindConnectHangs, filter);
}

std::string TestTCPSocket::TestConnect() {
  {
    // The basic case.
    pp::TCPSocket socket(instance_);
    TestCompletionCallback cb(instance_->pp_instance(), callback_type());

    cb.WaitForResult(socket.Connect(test_server_addr_, cb.GetCallback()));
    CHECK_CALLBACK_BEHAVIOR(cb);
    ASSERT_EQ(PP_OK, cb.result());

    pp::NetAddress local_addr, remote_addr;
    local_addr = socket.GetLocalAddress();
    remote_addr = socket.GetRemoteAddress();

    ASSERT_NE(0, local_addr.pp_resource());
    ASSERT_NE(0, remote_addr.pp_resource());
    ASSERT_TRUE(EqualNetAddress(test_server_addr_, remote_addr));

    socket.Close();
  }

  {
    // Connect a bound socket.
    pp::TCPSocket socket(instance_);
    TestCompletionCallback cb(instance_->pp_instance(), callback_type());

    pp::NetAddress any_port_address;
    ASSERT_SUBTEST_SUCCESS(GetAddressToBind(&any_port_address));

    cb.WaitForResult(socket.Bind(any_port_address, cb.GetCallback()));
    CHECK_CALLBACK_BEHAVIOR(cb);
    ASSERT_EQ(PP_OK, cb.result());

    cb.WaitForResult(socket.Connect(test_server_addr_, cb.GetCallback()));
    CHECK_CALLBACK_BEHAVIOR(cb);
    ASSERT_EQ(PP_OK, cb.result());

    pp::NetAddress local_addr, remote_addr;
    local_addr = socket.GetLocalAddress();
    remote_addr = socket.GetRemoteAddress();

    ASSERT_NE(0, local_addr.pp_resource());
    ASSERT_NE(0, remote_addr.pp_resource());
    ASSERT_TRUE(EqualNetAddress(test_server_addr_, remote_addr));
    ASSERT_NE(0u, GetPort(local_addr));

    socket.Close();
  }

  PASS();
}

std::string TestTCPSocket::TestReadWrite() {
  pp::TCPSocket socket(instance_);
  {
    TestCompletionCallback cb(instance_->pp_instance(), callback_type());

    cb.WaitForResult(socket.Connect(test_server_addr_, cb.GetCallback()));
    CHECK_CALLBACK_BEHAVIOR(cb);
    ASSERT_EQ(PP_OK, cb.result());
  }

  ASSERT_SUBTEST_SUCCESS(WriteToSocket(&socket, "GET / HTTP/1.0\r\n\r\n"));

  // Read up to the first \n and check that it looks like valid HTTP response.
  std::string s;
  ASSERT_SUBTEST_SUCCESS(ReadFirstLineFromSocket(&socket, &s));
  ASSERT_TRUE(ValidateHttpResponse(s));

  // Read until the server closes the socket.
  std::string read_data;
  int read_error;
  ASSERT_SUBTEST_SUCCESS(
      ReadFromSocketUntilError(&socket, &read_data, &read_error));
  ASSERT_EQ(PP_OK, read_error);

  // Reading again from the socket after getting an EOF should result in an
  // error.
  read_data = "";
  ASSERT_SUBTEST_SUCCESS(
      ReadFromSocketUntilError(&socket, &read_data, &read_error));
  ASSERT_EQ(PP_ERROR_FAILED, read_error);
  ASSERT_EQ("", read_data);

  char write_data[32 * 1024] = {0};
  // Write to the socket until there's an error, just to make sure the error
  // handling code works. As with the read case, go through two failures
  // (which may or may not fail with the same error code).
  int failures = 0;
  while (true) {
    TestCompletionCallback cb(instance_->pp_instance(), callback_type());
    cb.WaitForResult(socket.Write(write_data,
                                  static_cast<int32_t>(sizeof(write_data)),
                                  cb.GetCallback()));
    CHECK_CALLBACK_BEHAVIOR(cb);
    if (cb.result() > 0) {
      ASSERT_EQ(0, failures);
      continue;
    }
    // While this will most likely be PP_ERROR_CONNECTION_ABORTED, it seems best
    // not to rely on that, as write errors can be a bit finicky.
    ASSERT_LT(cb.result(), 0);
    ASSERT_NE(PP_ERROR_FAILED, cb.result());
    ASSERT_NE(PP_OK_COMPLETIONPENDING, cb.result());
    ++failures;

    if (failures == 2)
      break;
  }

  PASS();
}

std::string TestTCPSocket::TestSetOption() {
  pp::TCPSocket socket(instance_);
  TestCompletionCallback cb_1(instance_->pp_instance(), callback_type());
  TestCompletionCallback cb_2(instance_->pp_instance(), callback_type());
  TestCompletionCallback cb_3(instance_->pp_instance(), callback_type());

  // These options can be set even before the socket is connected.
  int32_t result_1 = socket.SetOption(PP_TCPSOCKET_OPTION_NO_DELAY,
                                      true, cb_1.GetCallback());
  int32_t result_2 = socket.SetOption(PP_TCPSOCKET_OPTION_SEND_BUFFER_SIZE,
                                      256, cb_2.GetCallback());
  int32_t result_3 = socket.SetOption(PP_TCPSOCKET_OPTION_RECV_BUFFER_SIZE,
                                      512, cb_3.GetCallback());

  cb_1.WaitForResult(result_1);
  CHECK_CALLBACK_BEHAVIOR(cb_1);
  ASSERT_EQ(PP_OK, cb_1.result());

  cb_2.WaitForResult(result_2);
  CHECK_CALLBACK_BEHAVIOR(cb_2);
  ASSERT_EQ(PP_OK, cb_2.result());

  cb_3.WaitForResult(result_3);
  CHECK_CALLBACK_BEHAVIOR(cb_3);
  ASSERT_EQ(PP_OK, cb_3.result());

  cb_1.WaitForResult(socket.Connect(test_server_addr_, cb_1.GetCallback()));
  CHECK_CALLBACK_BEHAVIOR(cb_1);
  ASSERT_EQ(PP_OK, cb_1.result());

  result_1 = socket.SetOption(PP_TCPSOCKET_OPTION_NO_DELAY,
                              false, cb_1.GetCallback());
  result_2 = socket.SetOption(PP_TCPSOCKET_OPTION_SEND_BUFFER_SIZE,
                              512, cb_2.GetCallback());
  result_3 = socket.SetOption(PP_TCPSOCKET_OPTION_RECV_BUFFER_SIZE,
                              1024, cb_3.GetCallback());

  cb_1.WaitForResult(result_1);
  CHECK_CALLBACK_BEHAVIOR(cb_1);
  ASSERT_EQ(PP_OK, cb_1.result());

  cb_2.WaitForResult(result_2);
  CHECK_CALLBACK_BEHAVIOR(cb_2);
  ASSERT_EQ(PP_OK, cb_2.result());

  cb_3.WaitForResult(result_3);
  CHECK_CALLBACK_BEHAVIOR(cb_3);
  ASSERT_EQ(PP_OK, cb_3.result());

  PASS();
}

std::string TestTCPSocket::TestListen() {
  // TODO(mmenke): Whenever this test is run, the PPAPI process DCHECKs on
  // shutdown when a ref count is decremented on the wrong thread. Someone
  // should probably look into that.
  static const int kBacklog = 2;

  pp::TCPSocket server_socket(instance_);
  ASSERT_SUBTEST_SUCCESS(StartListen(&server_socket, kBacklog));

  // We can't use a blocking callback for Accept, because it will wait forever
  // for the client to connect, since the client connects after.
  TestCompletionCallbackWithOutput<pp::TCPSocket>
      accept_callback(instance_->pp_instance(), PP_REQUIRED);
  // We need to make sure there's a message loop to run accept_callback on.
  pp::MessageLoop current_thread_loop(pp::MessageLoop::GetCurrent());
  if (current_thread_loop.is_null() && testing_interface_->IsOutOfProcess()) {
    current_thread_loop = pp::MessageLoop(instance_);
    current_thread_loop.AttachToCurrentThread();
  }

  int32_t accept_rv = server_socket.Accept(accept_callback.GetCallback());

  pp::TCPSocket client_socket;
  TestCompletionCallback callback(instance_->pp_instance(), callback_type());
  do {
    client_socket = pp::TCPSocket(instance_);

    callback.WaitForResult(client_socket.Connect(
        server_socket.GetLocalAddress(), callback.GetCallback()));
  } while (callback.result() != PP_OK);

  pp::NetAddress client_local_addr = client_socket.GetLocalAddress();
  pp::NetAddress client_remote_addr = client_socket.GetRemoteAddress();
  ASSERT_FALSE(client_local_addr.is_null());
  ASSERT_FALSE(client_remote_addr.is_null());

  accept_callback.WaitForResult(accept_rv);
  CHECK_CALLBACK_BEHAVIOR(accept_callback);
  ASSERT_EQ(PP_OK, accept_callback.result());

  pp::TCPSocket accepted_socket(accept_callback.output());
  pp::NetAddress accepted_local_addr = accepted_socket.GetLocalAddress();
  pp::NetAddress accepted_remote_addr = accepted_socket.GetRemoteAddress();
  ASSERT_FALSE(accepted_local_addr.is_null());
  ASSERT_FALSE(accepted_remote_addr.is_null());

  ASSERT_TRUE(EqualNetAddress(client_local_addr, accepted_remote_addr));

  const std::string kSentData = "a";
  ASSERT_SUBTEST_SUCCESS(WriteToSocket(&client_socket, kSentData));

  // Close the client socket to be able to read until EOF.
  client_socket.Close();

  std::string read_data;
  int read_error;
  ASSERT_SUBTEST_SUCCESS(
      ReadFromSocketUntilError(&accepted_socket, &read_data, &read_error));
  ASSERT_EQ(kSentData, read_data);
  ASSERT_EQ(PP_OK, read_error);

  accepted_socket.Close();
  server_socket.Close();

  PASS();
}

std::string TestTCPSocket::TestBacklog() {
  static const size_t kBacklog = 5;

  pp::TCPSocket server_socket(instance_);
  ASSERT_SUBTEST_SUCCESS(StartListen(&server_socket, 2 * kBacklog));

  std::vector<pp::TCPSocket*> client_sockets(kBacklog);
  std::vector<TestCompletionCallback*> connect_callbacks(kBacklog);
  std::vector<int32_t> connect_rv(kBacklog);
  pp::NetAddress address = server_socket.GetLocalAddress();
  for (size_t i = 0; i < kBacklog; ++i) {
    client_sockets[i] = new pp::TCPSocket(instance_);
    connect_callbacks[i] = new TestCompletionCallback(instance_->pp_instance(),
                                                      callback_type());
    connect_rv[i] = client_sockets[i]->Connect(
        address, connect_callbacks[i]->GetCallback());
  }

  std::vector<pp::TCPSocket*> accepted_sockets(kBacklog);
  for (size_t i = 0; i < kBacklog; ++i) {
    TestCompletionCallbackWithOutput<pp::TCPSocket> callback(
        instance_->pp_instance(), callback_type());
    callback.WaitForResult(server_socket.Accept(callback.GetCallback()));
    CHECK_CALLBACK_BEHAVIOR(callback);
    ASSERT_EQ(PP_OK, callback.result());

    accepted_sockets[i] = new pp::TCPSocket(callback.output());
    ASSERT_FALSE(accepted_sockets[i]->is_null());
  }

  for (size_t i = 0; i < kBacklog; ++i) {
    connect_callbacks[i]->WaitForResult(connect_rv[i]);
    CHECK_CALLBACK_BEHAVIOR(*connect_callbacks[i]);
    ASSERT_EQ(PP_OK, connect_callbacks[i]->result());
  }

  for (size_t i = 0; i < kBacklog; ++i) {
    const char byte = static_cast<char>('a' + i);
    ASSERT_SUBTEST_SUCCESS(WriteToSocket(client_sockets[i],
                                         std::string(1, byte)));
  }

  bool byte_received[kBacklog] = {};
  for (size_t i = 0; i < kBacklog; ++i) {
    char byte;
    ASSERT_SUBTEST_SUCCESS(ReadFromSocket(
        accepted_sockets[i], &byte, sizeof(byte)));
    const size_t index = byte - 'a';
    ASSERT_GE(index, 0u);
    ASSERT_LT(index, kBacklog);
    ASSERT_FALSE(byte_received[index]);
    byte_received[index] = true;
  }

  for (size_t i = 0; i < kBacklog; ++i) {
    ASSERT_TRUE(byte_received[i]);

    delete client_sockets[i];
    delete connect_callbacks[i];
    delete accepted_sockets[i];
  }

  PASS();
}

std::string TestTCPSocket::TestInterface_1_0() {
  PP_Resource socket = socket_interface_1_0_->Create(instance_->pp_instance());
  ASSERT_NE(0, socket);

  TestCompletionCallback cb(instance_->pp_instance(), callback_type());
  cb.WaitForResult(socket_interface_1_0_->Connect(
      socket, test_server_addr_.pp_resource(),
      cb.GetCallback().pp_completion_callback()));
  CHECK_CALLBACK_BEHAVIOR(cb);
  ASSERT_EQ(PP_OK, cb.result());

  ASSERT_SUBTEST_SUCCESS(WriteToSocket_1_0(socket, "GET / HTTP/1.0\r\n\r\n"));

  // Read up to the first \n and check that it looks like valid HTTP response.
  std::string s;
  ASSERT_SUBTEST_SUCCESS(ReadFirstLineFromSocket_1_0(socket, &s));
  ASSERT_TRUE(ValidateHttpResponse(s));

  pp::Module::Get()->core()->ReleaseResource(socket);
  PASS();
}

std::string TestTCPSocket::TestUnexpectedCalls() {
  // Tests that calls that are not expected given a sockets current state fail
  // with PP_ERROR_FAILED without breaking future operations on the socket.

  // Test a listen socket.
  {
    pp::TCPSocket socket(instance_);
    ASSERT_SUBTEST_SUCCESS(
        RunCommandsExpendingFailures(&socket, kListen | kAccept | kReadWrite));

    // Connect
    TestCompletionCallback cb(instance_->pp_instance(), callback_type());
    cb.WaitForResult(socket.Connect(test_server_addr_, cb.GetCallback()));
    CHECK_CALLBACK_BEHAVIOR(cb);
    ASSERT_EQ(PP_OK, cb.result());
    ASSERT_SUBTEST_SUCCESS(
        RunCommandsExpendingFailures(&socket, kListen | kAccept | kConnect));

    // Write
    ASSERT_SUBTEST_SUCCESS(WriteToSocket(&socket, "GET / HTTP/1.0\r\n\r\n"));
    ASSERT_SUBTEST_SUCCESS(
        RunCommandsExpendingFailures(&socket, kListen | kAccept | kConnect));

    // Read
    std::string s;
    ASSERT_SUBTEST_SUCCESS(ReadFirstLineFromSocket(&socket, &s));
    ASSERT_TRUE(ValidateHttpResponse(s));
    ASSERT_SUBTEST_SUCCESS(
        RunCommandsExpendingFailures(&socket, kListen | kAccept | kConnect));

    socket.Close();
    ASSERT_SUBTEST_SUCCESS(RunCommandsExpendingFailures(
        &socket, kListen | kAccept | kConnect | kReadWrite));
  }

  // Test a server socket.
  {
    pp::TCPSocket server_socket(instance_);

    // Bind
    pp::NetAddress any_port_address;
    ASSERT_SUBTEST_SUCCESS(GetAddressToBind(&any_port_address));
    TestCompletionCallback callback(instance_->pp_instance(), callback_type());
    callback.WaitForResult(
        server_socket.Bind(any_port_address, callback.GetCallback()));
    CHECK_CALLBACK_BEHAVIOR(callback);
    ASSERT_EQ(PP_OK, callback.result());
    ASSERT_SUBTEST_SUCCESS(RunCommandsExpendingFailures(
        &server_socket, kBind | kAccept | kReadWrite));

    // Listen
    callback.WaitForResult(
        server_socket.Listen(1 /* backlog */, callback.GetCallback()));
    CHECK_CALLBACK_BEHAVIOR(callback);
    ASSERT_EQ(PP_OK, callback.result());
    ASSERT_SUBTEST_SUCCESS(RunCommandsExpendingFailures(
        &server_socket, kBind | kListen | kConnect | kReadWrite));

    // Accept
    pp::TCPSocket client_socket(instance_);
    TestCompletionCallback connect_callback(instance_->pp_instance(),
                                            callback_type());
    int connect_result = client_socket.Connect(server_socket.GetLocalAddress(),
                                               connect_callback.GetCallback());
    TestCompletionCallbackWithOutput<pp::TCPSocket> accept_callback(
        instance_->pp_instance(), callback_type());
    accept_callback.WaitForResult(
        server_socket.Accept(accept_callback.GetCallback()));
    CHECK_CALLBACK_BEHAVIOR(accept_callback);
    ASSERT_EQ(PP_OK, accept_callback.result());
    connect_callback.WaitForResult(connect_result);
    CHECK_CALLBACK_BEHAVIOR(connect_callback);
    ASSERT_EQ(PP_OK, connect_callback.result());
    pp::TCPSocket accepted_socket(accept_callback.output());
    ASSERT_SUBTEST_SUCCESS(RunCommandsExpendingFailures(
        &server_socket, kBind | kListen | kConnect | kReadWrite));

    client_socket.Close();
    accepted_socket.Close();
    server_socket.Close();
  }

  PASS();
}

std::string TestTCPSocket::TestConnectFails() {
  pp::TCPSocket socket(instance_);
  TestCompletionCallback cb(instance_->pp_instance(), callback_type());

  cb.WaitForResult(socket.Connect(test_server_addr_, cb.GetCallback()));
  CHECK_CALLBACK_BEHAVIOR(cb);
  ASSERT_EQ(PP_ERROR_FAILED, cb.result());

  // All subsequent calls on the socket should fail.
  ASSERT_SUBTEST_SUCCESS(RunCommandsExpendingFailures(&socket, kAllCommands));

  PASS();
}

std::string TestTCPSocket::TestConnectHangs() {
  pp::TCPSocket socket(instance_);
  TestCompletionCallback cb(instance_->pp_instance(), callback_type());
  socket.Connect(test_server_addr_, DoNothingCallback());
  PASS();
}

std::string TestTCPSocket::TestWriteFails() {
  pp::TCPSocket socket(instance_);
  {
    TestCompletionCallback cb(instance_->pp_instance(), callback_type());
    cb.WaitForResult(socket.Connect(test_server_addr_, cb.GetCallback()));
    CHECK_CALLBACK_BEHAVIOR(cb);
    ASSERT_EQ(PP_OK, cb.result());
  }

  // Write to the socket until there's an error. Some writes may succeed, since
  // Mojo writes complete before the socket tries to send data. As with the read
  // case, wait for two errors.
  char write_data[32 * 1024] = {0};
  int failures = 0;
  while (true) {
    TestCompletionCallback cb(instance_->pp_instance(), callback_type());
    cb.WaitForResult(socket.Write(write_data,
                                  static_cast<int32_t>(sizeof(write_data)),
                                  cb.GetCallback()));
    CHECK_CALLBACK_BEHAVIOR(cb);
    if (cb.result() > 0) {
      ASSERT_EQ(0, failures);
      continue;
    }

    ASSERT_EQ(PP_ERROR_FAILED, cb.result());
    ++failures;

    if (failures == 2)
      break;
  }

  PASS();
}

std::string TestTCPSocket::TestReadFails() {
  pp::TCPSocket socket(instance_);
  TestCompletionCallback cb(instance_->pp_instance(), callback_type());
  cb.WaitForResult(socket.Connect(test_server_addr_, cb.GetCallback()));
  CHECK_CALLBACK_BEHAVIOR(cb);
  ASSERT_EQ(PP_OK, cb.result());

  std::string read_data;
  int read_error;
  // Read should fail with no data received.
  ASSERT_SUBTEST_SUCCESS(
      ReadFromSocketUntilError(&socket, &read_data, &read_error));
  ASSERT_EQ(PP_ERROR_FAILED, read_error);
  ASSERT_EQ(0, read_data.size());

  // Reading again after the socket has been closed should also fail.
  ASSERT_SUBTEST_SUCCESS(
      ReadFromSocketUntilError(&socket, &read_data, &read_error));
  ASSERT_EQ(PP_ERROR_FAILED, read_error);
  ASSERT_EQ(0, read_data.size());

  PASS();
}

std::string TestTCPSocket::TestSetSendBufferSizeFails() {
  pp::TCPSocket socket(instance_);
  TestCompletionCallback cb(instance_->pp_instance(), callback_type());
  cb.WaitForResult(socket.Connect(test_server_addr_, cb.GetCallback()));
  CHECK_CALLBACK_BEHAVIOR(cb);
  ASSERT_EQ(PP_OK, cb.result());

  cb.WaitForResult(socket.SetOption(PP_TCPSOCKET_OPTION_SEND_BUFFER_SIZE, 256,
                                    cb.GetCallback()));
  CHECK_CALLBACK_BEHAVIOR(cb);
  ASSERT_EQ(PP_ERROR_FAILED, cb.result());
  PASS();
}

std::string TestTCPSocket::TestSetReceiveBufferSizeFails() {
  pp::TCPSocket socket(instance_);
  TestCompletionCallback cb(instance_->pp_instance(), callback_type());
  cb.WaitForResult(socket.Connect(test_server_addr_, cb.GetCallback()));
  CHECK_CALLBACK_BEHAVIOR(cb);
  ASSERT_EQ(PP_OK, cb.result());

  cb.WaitForResult(socket.SetOption(PP_TCPSOCKET_OPTION_RECV_BUFFER_SIZE, 256,
                                    cb.GetCallback()));
  CHECK_CALLBACK_BEHAVIOR(cb);
  ASSERT_EQ(PP_ERROR_FAILED, cb.result());
  PASS();
}

std::string TestTCPSocket::TestSetNoDelayFails() {
  pp::TCPSocket socket(instance_);
  TestCompletionCallback cb(instance_->pp_instance(), callback_type());
  cb.WaitForResult(socket.Connect(test_server_addr_, cb.GetCallback()));
  CHECK_CALLBACK_BEHAVIOR(cb);
  ASSERT_EQ(PP_OK, cb.result());

  cb.WaitForResult(
      socket.SetOption(PP_TCPSOCKET_OPTION_NO_DELAY, true, cb.GetCallback()));
  CHECK_CALLBACK_BEHAVIOR(cb);
  ASSERT_EQ(PP_ERROR_FAILED, cb.result());
  PASS();
}

std::string TestTCPSocket::TestBindFailsConnectSucceeds() {
  pp::TCPSocket socket(instance_);
  TestCompletionCallback callback(instance_->pp_instance(), callback_type());
  // The address doesn't matter here, other than that it should be valid.
  callback.WaitForResult(
      socket.Bind(test_server_addr_, callback.GetCallback()));
  CHECK_CALLBACK_BEHAVIOR(callback);
  ASSERT_EQ(PP_ERROR_FAILED, callback.result());

  callback.WaitForResult(
      socket.Connect(test_server_addr_, callback.GetCallback()));
  CHECK_CALLBACK_BEHAVIOR(callback);
  ASSERT_EQ(PP_OK, callback.result());

  PASS();
}

std::string TestTCPSocket::TestBindFails() {
  pp::TCPSocket socket(instance_);
  TestCompletionCallback callback(instance_->pp_instance(), callback_type());
  // The address doesn't matter here, other than that it should be valid.
  callback.WaitForResult(
      socket.Bind(test_server_addr_, callback.GetCallback()));
  CHECK_CALLBACK_BEHAVIOR(callback);
  ASSERT_EQ(PP_ERROR_FAILED, callback.result());

  PASS();
}

std::string TestTCPSocket::TestBindHangs() {
  pp::TCPSocket socket(instance_);
  socket.Bind(test_server_addr_, DoNothingCallback());
  PASS();
}

std::string TestTCPSocket::TestListenFails() {
  pp::TCPSocket socket(instance_);
  TestCompletionCallback callback(instance_->pp_instance(), callback_type());
  // The address doesn't matter here, other than that it should be valid.
  callback.WaitForResult(
      socket.Bind(test_server_addr_, callback.GetCallback()));
  CHECK_CALLBACK_BEHAVIOR(callback);
  ASSERT_EQ(PP_OK, callback.result());

  callback.WaitForResult(
      socket.Listen(2 /* backlog */, callback.GetCallback()));
  CHECK_CALLBACK_BEHAVIOR(callback);
  ASSERT_EQ(PP_ERROR_FAILED, callback.result());

  // All subsequent calls on the socket should fail.
  ASSERT_SUBTEST_SUCCESS(RunCommandsExpendingFailures(&socket, kAllCommands));

  PASS();
}

std::string TestTCPSocket::TestListenHangs() {
  pp::TCPSocket socket(instance_);
  TestCompletionCallback callback(instance_->pp_instance(), callback_type());
  // The address doesn't matter here, other than that it should be valid.
  callback.WaitForResult(
      socket.Bind(test_server_addr_, callback.GetCallback()));
  CHECK_CALLBACK_BEHAVIOR(callback);
  ASSERT_EQ(PP_OK, callback.result());

  socket.Listen(2 /* backlog */, DoNothingCallback());
  PASS();
}

std::string TestTCPSocket::TestAcceptFails() {
  pp::TCPSocket socket(instance_);
  TestCompletionCallback callback(instance_->pp_instance(), callback_type());
  // The address doesn't matter here, other than that it should be valid.
  callback.WaitForResult(
      socket.Bind(test_server_addr_, callback.GetCallback()));
  CHECK_CALLBACK_BEHAVIOR(callback);
  ASSERT_EQ(PP_OK, callback.result());

  callback.WaitForResult(
      socket.Listen(2 /* backlog */, callback.GetCallback()));
  CHECK_CALLBACK_BEHAVIOR(callback);
  ASSERT_EQ(PP_OK, callback.result());

  TestCompletionCallbackWithOutput<pp::TCPSocket> accept_callback(
      instance_->pp_instance(), callback_type());
  accept_callback.WaitForResult(socket.Accept(accept_callback.GetCallback()));
  CHECK_CALLBACK_BEHAVIOR(accept_callback);
  ASSERT_EQ(PP_ERROR_FAILED, accept_callback.result());

  PASS();
}

std::string TestTCPSocket::TestAcceptHangs() {
  pp::TCPSocket socket(instance_);
  TestCompletionCallback callback(instance_->pp_instance(), callback_type());
  // The address doesn't matter here, other than that it should be valid.
  callback.WaitForResult(
      socket.Bind(test_server_addr_, callback.GetCallback()));
  CHECK_CALLBACK_BEHAVIOR(callback);
  ASSERT_EQ(PP_OK, callback.result());

  callback.WaitForResult(
      socket.Listen(2 /* backlog */, callback.GetCallback()));
  CHECK_CALLBACK_BEHAVIOR(callback);
  ASSERT_EQ(PP_OK, callback.result());

  socket.Accept(DoNothingCallbackWithOutput<pp::TCPSocket>());
  PASS();
}

std::string TestTCPSocket::TestAcceptedSocketWriteFails() {
  pp::TCPSocket socket(instance_);
  TestCompletionCallback callback(instance_->pp_instance(), callback_type());
  // The address doesn't matter here, other than that it should be valid.
  callback.WaitForResult(
      socket.Bind(test_server_addr_, callback.GetCallback()));
  CHECK_CALLBACK_BEHAVIOR(callback);
  ASSERT_EQ(PP_OK, callback.result());

  callback.WaitForResult(
      socket.Listen(2 /* backlog */, callback.GetCallback()));
  CHECK_CALLBACK_BEHAVIOR(callback);
  ASSERT_EQ(PP_OK, callback.result());

  TestCompletionCallbackWithOutput<pp::TCPSocket> accept_callback(
      instance_->pp_instance(), callback_type());
  accept_callback.WaitForResult(socket.Accept(accept_callback.GetCallback()));
  CHECK_CALLBACK_BEHAVIOR(accept_callback);
  ASSERT_EQ(PP_OK, accept_callback.result());

  pp::TCPSocket accepted_socket(accept_callback.output());

  // Write to the socket until there's an error. Some writes may succeed, since
  // Mojo writes complete before the socket tries to send data. As with the read
  // case, wait for two errors.
  char write_data[32 * 1024] = {0};
  int failures = 0;
  while (true) {
    callback.WaitForResult(accepted_socket.Write(
        write_data, static_cast<int32_t>(sizeof(write_data)),
        callback.GetCallback()));
    CHECK_CALLBACK_BEHAVIOR(callback);
    if (callback.result() > 0) {
      ASSERT_EQ(0, failures);
      continue;
    }

    ASSERT_EQ(PP_ERROR_FAILED, callback.result());
    ++failures;

    if (failures == 2)
      break;
  }

  PASS();
}

std::string TestTCPSocket::TestAcceptedSocketReadFails() {
  pp::TCPSocket socket(instance_);
  TestCompletionCallback callback(instance_->pp_instance(), callback_type());
  // The address doesn't matter here, other than that it should be valid.
  callback.WaitForResult(
      socket.Bind(test_server_addr_, callback.GetCallback()));
  CHECK_CALLBACK_BEHAVIOR(callback);
  ASSERT_EQ(PP_OK, callback.result());

  callback.WaitForResult(
      socket.Listen(2 /* backlog */, callback.GetCallback()));
  CHECK_CALLBACK_BEHAVIOR(callback);
  ASSERT_EQ(PP_OK, callback.result());

  TestCompletionCallbackWithOutput<pp::TCPSocket> accept_callback(
      instance_->pp_instance(), callback_type());
  accept_callback.WaitForResult(socket.Accept(accept_callback.GetCallback()));
  CHECK_CALLBACK_BEHAVIOR(accept_callback);
  ASSERT_EQ(PP_OK, accept_callback.result());

  pp::TCPSocket accepted_socket(accept_callback.output());

  std::string read_data;
  int read_error;
  // Read should fail with no data received.
  ASSERT_SUBTEST_SUCCESS(
      ReadFromSocketUntilError(&accepted_socket, &read_data, &read_error));
  ASSERT_EQ(PP_ERROR_FAILED, read_error);
  ASSERT_EQ(0, read_data.size());

  // Reading again after the socket has been closed should also fail.
  ASSERT_SUBTEST_SUCCESS(
      ReadFromSocketUntilError(&accepted_socket, &read_data, &read_error));
  ASSERT_EQ(PP_ERROR_FAILED, read_error);
  ASSERT_EQ(0, read_data.size());

  PASS();
}

std::string TestTCPSocket::TestBindConnectFails() {
  pp::TCPSocket socket(instance_);
  TestCompletionCallback cb(instance_->pp_instance(), callback_type());

  cb.WaitForResult(socket.Bind(test_server_addr_, cb.GetCallback()));
  CHECK_CALLBACK_BEHAVIOR(cb);
  ASSERT_EQ(PP_OK, cb.result());

  cb.WaitForResult(socket.Connect(test_server_addr_, cb.GetCallback()));
  CHECK_CALLBACK_BEHAVIOR(cb);
  ASSERT_EQ(PP_ERROR_FAILED, cb.result());

  // All subsequent calls on the socket should fail.
  ASSERT_SUBTEST_SUCCESS(RunCommandsExpendingFailures(&socket, kAllCommands));

  PASS();
}

std::string TestTCPSocket::TestBindConnectHangs() {
  pp::TCPSocket socket(instance_);
  TestCompletionCallback cb(instance_->pp_instance(), callback_type());

  cb.WaitForResult(socket.Bind(test_server_addr_, cb.GetCallback()));
  CHECK_CALLBACK_BEHAVIOR(cb);
  ASSERT_EQ(PP_OK, cb.result());

  socket.Connect(test_server_addr_, DoNothingCallback());
  PASS();
}

std::string TestTCPSocket::ReadFirstLineFromSocket(pp::TCPSocket* socket,
                                                   std::string* s) {
  char buffer[1000];

  s->clear();
  // Make sure we don't just hang if |Read()| spews.
  while (s->size() < 10000) {
    TestCompletionCallback cb(instance_->pp_instance(), callback_type());
    cb.WaitForResult(socket->Read(buffer, sizeof(buffer), cb.GetCallback()));
    CHECK_CALLBACK_BEHAVIOR(cb);
    ASSERT_GT(cb.result(), 0);
    s->reserve(s->size() + cb.result());
    for (int32_t i = 0; i < cb.result(); ++i) {
      s->push_back(buffer[i]);
      if (buffer[i] == '\n')
        PASS();
    }
  }
  PASS();
}

std::string TestTCPSocket::ReadFirstLineFromSocket_1_0(PP_Resource socket,
                                                       std::string* s) {
  char buffer[1000];

  s->clear();
  // Make sure we don't just hang if |Read()| spews.
  while (s->size() < 10000) {
    TestCompletionCallback cb(instance_->pp_instance(), callback_type());
    cb.WaitForResult(socket_interface_1_0_->Read(
        socket, buffer, sizeof(buffer),
        cb.GetCallback().pp_completion_callback()));
    CHECK_CALLBACK_BEHAVIOR(cb);
    ASSERT_GT(cb.result(), 0);
    s->reserve(s->size() + cb.result());
    for (int32_t i = 0; i < cb.result(); ++i) {
      s->push_back(buffer[i]);
      if (buffer[i] == '\n')
        PASS();
    }
  }
  PASS();
}

std::string TestTCPSocket::ReadFromSocket(pp::TCPSocket* socket,
                                          char* buffer,
                                          size_t num_bytes) {
  while (num_bytes > 0) {
    TestCompletionCallback callback(instance_->pp_instance(), callback_type());
    callback.WaitForResult(
        socket->Read(buffer, static_cast<int32_t>(num_bytes),
        callback.GetCallback()));
    CHECK_CALLBACK_BEHAVIOR(callback);
    ASSERT_GT(callback.result(), 0);
    buffer += callback.result();
    num_bytes -= callback.result();
  }
  ASSERT_EQ(0u, num_bytes);
  PASS();
}

// Reads from the socket until an error (Or 0-byte read) occurs. Populates
// |read_data| and |error| with that information. Doesn't return a std::string
// to distinguish it from a subtest.
std::string TestTCPSocket::ReadFromSocketUntilError(pp::TCPSocket* socket,
                                                    std::string* read_data,
                                                    int* read_error) {
  // Set |read_error| to a value that a read should never complete with.
  *read_error = PP_OK_COMPLETIONPENDING;
  while (true) {
    char buffer[1024];
    TestCompletionCallback callback(instance_->pp_instance(), callback_type());
    callback.WaitForResult(
        socket->Read(buffer, sizeof(buffer), callback.GetCallback()));
    CHECK_CALLBACK_BEHAVIOR(callback);
    ASSERT_LE(callback.result(), static_cast<int32_t>(sizeof(buffer)));
    ASSERT_NE(PP_OK_COMPLETIONPENDING, callback.result());
    if (callback.result() <= 0) {
      *read_error = callback.result();
      PASS();
    }
    read_data->append(buffer, callback.result());
  }
}

std::string TestTCPSocket::WriteToSocket(pp::TCPSocket* socket,
                                         const std::string& s) {
  const char* buffer = s.data();
  size_t written = 0;
  while (written < s.size()) {
    TestCompletionCallback cb(instance_->pp_instance(), callback_type());
    cb.WaitForResult(
        socket->Write(buffer + written,
                      static_cast<int32_t>(s.size() - written),
                      cb.GetCallback()));
    CHECK_CALLBACK_BEHAVIOR(cb);
    ASSERT_GT(cb.result(), 0);
    written += cb.result();
  }
  ASSERT_EQ(written, s.size());
  PASS();
}

std::string TestTCPSocket::WriteToSocket_1_0(
    PP_Resource socket,
    const std::string& s) {
  const char* buffer = s.data();
  size_t written = 0;
  while (written < s.size()) {
    TestCompletionCallback cb(instance_->pp_instance(), callback_type());
    cb.WaitForResult(socket_interface_1_0_->Write(
        socket, buffer + written,
        static_cast<int32_t>(s.size() - written),
        cb.GetCallback().pp_completion_callback()));
    CHECK_CALLBACK_BEHAVIOR(cb);
    ASSERT_GT(cb.result(), 0);
    written += cb.result();
  }
  ASSERT_EQ(written, s.size());
  PASS();
}

std::string TestTCPSocket::GetAddressToBind(pp::NetAddress* address) {
  // Connect to |test_server_addr_| and then sets |address| to the local address
  // used by that connection, replacing the port with 0 to use a random port.
  pp::TCPSocket socket(instance_);
  TestCompletionCallback callback(instance_->pp_instance(), callback_type());
  callback.WaitForResult(
      socket.Connect(test_server_addr_, callback.GetCallback()));
  CHECK_CALLBACK_BEHAVIOR(callback);
  ASSERT_EQ(PP_OK, callback.result());

  ASSERT_TRUE(ReplacePort(instance_->pp_instance(), socket.GetLocalAddress(), 0,
                          address));
  ASSERT_FALSE(address->is_null());
  PASS();
}

std::string TestTCPSocket::StartListen(pp::TCPSocket* socket, int32_t backlog) {
  pp::NetAddress any_port_address;
  ASSERT_SUBTEST_SUCCESS(GetAddressToBind(&any_port_address));

  TestCompletionCallback callback(instance_->pp_instance(), callback_type());
  callback.WaitForResult(
      socket->Bind(any_port_address, callback.GetCallback()));
  CHECK_CALLBACK_BEHAVIOR(callback);
  ASSERT_EQ(PP_OK, callback.result());

  callback.WaitForResult(
      socket->Listen(backlog, callback.GetCallback()));
  CHECK_CALLBACK_BEHAVIOR(callback);
  ASSERT_EQ(PP_OK, callback.result());

  PASS();
}

std::string TestTCPSocket::RunCommandsExpendingFailures(pp::TCPSocket* socket,
                                                        int commands) {
  ASSERT_NE(0, commands);

  if (commands & kBind) {
    TestCompletionCallback cb(instance_->pp_instance(), callback_type());
    pp::NetAddress any_port_address;
    ASSERT_TRUE(ReplacePort(instance_->pp_instance(), test_server_addr_, 0,
                            &any_port_address));
    cb.WaitForResult(socket->Bind(any_port_address, cb.GetCallback()));
    CHECK_CALLBACK_BEHAVIOR(cb);
    ASSERT_EQ(PP_ERROR_FAILED, cb.result());
  }

  if (commands & kListen) {
    TestCompletionCallback callback(instance_->pp_instance(), callback_type());
    callback.WaitForResult(
        socket->Listen(1 /* backlog */, callback.GetCallback()));
    CHECK_CALLBACK_BEHAVIOR(callback);
    ASSERT_EQ(PP_ERROR_FAILED, callback.result());
  }

  if (commands & kAccept) {
    TestCompletionCallbackWithOutput<pp::TCPSocket> accept_callback(
        instance_->pp_instance(), callback_type());
    accept_callback.WaitForResult(
        socket->Accept(accept_callback.GetCallback()));
    CHECK_CALLBACK_BEHAVIOR(accept_callback);
    ASSERT_EQ(PP_ERROR_FAILED, accept_callback.result());
  }

  if (commands & kConnect) {
    TestCompletionCallback cb(instance_->pp_instance(), callback_type());
    cb.WaitForResult(socket->Connect(test_server_addr_, cb.GetCallback()));
    CHECK_CALLBACK_BEHAVIOR(cb);
    ASSERT_EQ(PP_ERROR_FAILED, cb.result());
  }

  if (commands & kReadWrite) {
    // Check that a read on a new socket fails.
    char buffer[1] = {'1'};
    TestCompletionCallback cb(instance_->pp_instance(), callback_type());
    cb.WaitForResult(socket->Read(buffer, sizeof(buffer), cb.GetCallback()));
    CHECK_CALLBACK_BEHAVIOR(cb);
    ASSERT_EQ(PP_ERROR_FAILED, cb.result());

    // Check that a write on a new socket fails.
    cb.WaitForResult(socket->Write(buffer, sizeof(buffer), cb.GetCallback()));
    CHECK_CALLBACK_BEHAVIOR(cb);
    ASSERT_EQ(PP_ERROR_FAILED, cb.result());
  }

  PASS();
}