Better handling of startup and shutdown of the debugger agent

test/cctest/test-sockets.cc

 // Copyright 2009 the V8 project authors. All rights reserved.
 
 #include "v8.h"
 #include "platform.h"
 #include "cctest.h"
 
 
 using namespace ::v8::internal;
 
 
-static const char* kPort = "5858";
-static const char* kLocalhost = "localhost";
-
 class SocketListenerThread : public Thread {
  public:
-  explicit SocketListenerThread(int data_size)
-      : data_size_(data_size), server_(NULL), client_(NULL),
+  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(5858);
+  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);
@@ skipping 12 matching lines @@
     int status = socket->Send(data, len);
     if (status <= 0) {
       return false;
     }
     sent_len += status;
   }
   return true;
 }
 
 
-static void SendAndReceive(char *data, int len) {
+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(len);
+  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, kPort);
+  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(small_data, kBufferSizeSmall);
+  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(medium_data, kBufferSizeMedium);
+  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(large_data, kBufferSizeLarge);
+  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)));
 }