A64: Synchronize with r16587.

test/cctest/test-socket.cc

 // Copyright 2009 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
 //       with the distribution.
 //     * Neither the name of Google Inc. nor the names of its
 //       contributors may be used to endorse or promote products derived
 //       from this software without specific prior written permission.
 //
 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #include "v8.h"
 #include "platform.h"
+#include "platform/socket.h"
 #include "cctest.h"
 
 
 using namespace ::v8::internal;
 
 
 class SocketListenerThread : public Thread {
  public:
   SocketListenerThread(int port, int data_size)
       : Thread("SocketListenerThread"),
@@ skipping 22 matching lines @@
   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();
+  server_ = new Socket;
   server_->SetReuseAddress(true);
   CHECK(server_ != NULL);
   ok = server_->Bind(port_);
   CHECK(ok);
 
   // Listen for new connections.
   ok = server_->Listen(1);
   CHECK(ok);
   listening_.Signal();
 
@@ skipping 31 matching lines @@
   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();
+  Socket* client = new Socket;
   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 + FlagDependentPortOffset();
 
-  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)));
-}