test-sockets.cc 3.95 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12
// 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:
13 14
  SocketListenerThread(int port, int data_size)
      : Thread("SocketListenerThread"),
15 16 17 18 19
        port_(port),
        data_size_(data_size),
        server_(NULL),
        client_(NULL),
        listening_(OS::CreateSemaphore(0)) {
20 21 22 23 24 25
    data_ = new char[data_size_];
  }
  ~SocketListenerThread() {
    // Close both sockets.
    delete client_;
    delete server_;
26 27
    delete listening_;
    delete[] data_;
28 29 30 31 32 33 34
  }

  void Run();
  void WaitForListening() { listening_->Wait(); }
  char* data() { return data_; }

 private:
35
  int port_;
36 37 38 39 40 41 42 43 44 45 46 47 48
  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();
49
  server_->SetReuseAddress(true);
50
  CHECK(server_ != NULL);
51
  ok = server_->Bind(port_);
52 53 54 55 56 57
  CHECK(ok);

  // Listen for new connections.
  ok = server_->Listen(1);
  CHECK(ok);
  listening_->Signal();
58

59 60 61 62 63 64 65 66 67 68 69 70
  // 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);
  }
}


71 72 73 74 75 76 77 78 79 80 81 82 83
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;
}


84 85 86
static void SendAndReceive(int port, char *data, int len) {
  static const char* kLocalhost = "localhost";

87 88
  bool ok;

89 90 91 92 93
  // Make a string with the port number.
  const int kPortBuferLen = 6;
  char port_str[kPortBuferLen];
  OS::SNPrintF(Vector<char>(port_str, kPortBuferLen), "%d", port);

94
  // Create a socket listener.
95
  SocketListenerThread* listener = new SocketListenerThread(port, len);
96 97
  listener->Start();
  listener->WaitForListening();
98

99 100 101
  // Connect and write some data.
  Socket* client = OS::CreateSocket();
  CHECK(client != NULL);
102
  ok = client->Connect(kLocalhost, port_str);
103 104 105
  CHECK(ok);

  // Send all the data.
106
  ok = SendAll(client, data, len);
107 108 109 110 111 112 113 114 115 116 117
  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.
118
  client->Shutdown();
119 120 121 122 123 124
  delete client;
  delete listener;
}


TEST(Socket) {
125 126 127 128
  // Make sure this port is not used by other tests to allow tests to run in
  // parallel.
  static const int kPort = 5859;

129 130 131 132 133 134 135 136 137
  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";
138
  SendAndReceive(kPort, small_data, kBufferSizeSmall);
139 140 141 142 143 144 145

  // 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;
  }
146
  SendAndReceive(kPort, medium_data, kBufferSizeMedium);
147
  delete[] medium_data;
148 149 150 151 152 153 154

  // 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;
  }
155
  SendAndReceive(kPort, large_data, kBufferSizeLarge);
156
  delete[] large_data;
157 158 159 160 161 162 163 164 165 166
}


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)));
}