CSE2410 Fall 2014 Bounce

// Copyright 2009 the V8 project authors. All rights reserved.

#include "v8.h"

#include "platform.h"

#include "cctest.h"

using namespace ::v8::internal;

class SocketListenerThread : public Thread {

 public:

  explicit SocketListenerThread(int port, int data_size)

      : port_(port), data_size_(data_size), server_(NULL), client_(NULL),

        listening_(OS::CreateSemaphore(0)) {

    data_ = new char[data_size_];

  }

  ~SocketListenerThread() {

    // Close both sockets.

    delete client_;

    delete server_;

    delete listening_;

    delete[] data_;

  }

  void Run();

  void WaitForListening() { listening_->Wait(); }

  char* data() { return data_; }

 private:

  int port_;

  char* data_;

  int data_size_;

  Socket* server_;  // Server socket used for bind/accept.

  Socket* client_;  // Single client connection used by the test.

  Semaphore* listening_;  // Signalled when the server socket is in listen mode.

};

void SocketListenerThread::Run() {

  bool ok;

  // Create the server socket and bind it to the requested port.

  server_ = OS::CreateSocket();

  CHECK(server_ != NULL);

  ok = server_->Bind(port_);

  CHECK(ok);

  // Listen for new connections.

  ok = server_->Listen(1);

  CHECK(ok);

  listening_->Signal();

  // Accept a connection.

  client_ = server_->Accept();

  CHECK(client_ != NULL);

  // Read the expected niumber of bytes of data.

  int bytes_read = 0;

  while (bytes_read < data_size_) {

    bytes_read += client_->Receive(data_ + bytes_read, data_size_ - bytes_read);

  }

}

static bool SendAll(Socket* socket, const char* data, int len) {

  int sent_len = 0;

  while (sent_len < len) {

    int status = socket->Send(data, len);

    if (status <= 0) {

      return false;

    }

    sent_len += status;

  }

  return true;

}

static void SendAndReceive(int port, char *data, int len) {

  static const char* kLocalhost = "localhost";

  bool ok;

  // Make a string with the port number.

  const int kPortBuferLen = 6;

  char port_str[kPortBuferLen];

  OS::SNPrintF(Vector<char>(port_str, kPortBuferLen), "%d", port);

  // Create a socket listener.

  SocketListenerThread* listener = new SocketListenerThread(port, len);

  listener->Start();

  listener->WaitForListening();

  // Connect and write some data.

  Socket* client = OS::CreateSocket();

  CHECK(client != NULL);

  ok = client->Connect(kLocalhost, port_str);

  CHECK(ok);

  // Send all the data.

  ok = SendAll(client, data, len);

  CHECK(ok);

  // Wait until data is received.

  listener->Join();

  // Check that data received is the same as data send.

  for (int i = 0; i < len; i++) {

    CHECK(data[i] == listener->data()[i]);

  }

  // Close the client before the listener to avoid TIME_WAIT issues.

  client->Shutdown();

  delete client;

  delete listener;

}

TEST(Socket) {

  // Make sure this port is not used by other tests to allow tests to run in

  // parallel.

  static const int kPort = 5859;

  bool ok;

  // Initialize socket support.

  ok = Socket::Setup();

  CHECK(ok);

  // Send and receive some data.

  static const int kBufferSizeSmall = 20;

  char small_data[kBufferSizeSmall + 1] = "1234567890abcdefghij";

  SendAndReceive(kPort, small_data, kBufferSizeSmall);

  // Send and receive some more data.

  static const int kBufferSizeMedium = 10000;

  char* medium_data = new char[kBufferSizeMedium];

  for (int i = 0; i < kBufferSizeMedium; i++) {

    medium_data[i] = i % 256;

  }

  SendAndReceive(kPort, medium_data, kBufferSizeMedium);

  delete[] medium_data;

  // Send and receive even more data.

  static const int kBufferSizeLarge = 1000000;

  char* large_data = new char[kBufferSizeLarge];

  for (int i = 0; i < kBufferSizeLarge; i++) {

    large_data[i] = i % 256;

  }

  SendAndReceive(kPort, large_data, kBufferSizeLarge);

  delete[] large_data;

}

TEST(HToNNToH) {

  uint16_t x = 1234;

  CHECK_EQ(x, Socket::NToH(Socket::HToN(x)));

  uint32_t y = 12345678;

  CHECK(y == Socket::NToH(Socket::HToN(y)));

}